pax_global_header00006660000000000000000000000064150521032640014510gustar00rootroot0000000000000052 comment=3f0e9f5fca8080f87094341f8ac5027091cc7601 rclone-v1.71.0/000077500000000000000000000000001505210326400132465ustar00rootroot00000000000000rclone-v1.71.0/.gitattributes000066400000000000000000000004731505210326400161450ustar00rootroot00000000000000# Go writes go.mod and go.sum with lf even on windows go.mod text eol=lf go.sum text eol=lf # Ignore generated files in GitHub language statistics and diffs /MANUAL.* linguist-generated=true /rclone.1 linguist-generated=true # Don't fiddle with the line endings of test data **/testdata/** -text **/test/** -text rclone-v1.71.0/.github/000077500000000000000000000000001505210326400146065ustar00rootroot00000000000000rclone-v1.71.0/.github/ISSUE_TEMPLATE.md000066400000000000000000000010721505210326400173130ustar00rootroot00000000000000 #### Output of `rclone version` #### Describe the issue rclone-v1.71.0/.github/ISSUE_TEMPLATE/000077500000000000000000000000001505210326400167715ustar00rootroot00000000000000rclone-v1.71.0/.github/ISSUE_TEMPLATE/Bug.md000066400000000000000000000042221505210326400200300ustar00rootroot00000000000000--- name: Bug report about: Report a problem with rclone --- #### The associated forum post URL from `https://forum.rclone.org` #### What is the problem you are having with rclone? #### What is your rclone version (output from `rclone version`) #### Which OS you are using and how many bits (e.g. Windows 7, 64 bit) #### Which cloud storage system are you using? (e.g. Google Drive) #### The command you were trying to run (e.g. `rclone copy /tmp remote:tmp`) #### A log from the command with the `-vv` flag (e.g. output from `rclone -vv copy /tmp remote:tmp`) #### How to use GitHub * Please use the 👍 [reaction](https://blog.github.com/2016-03-10-add-reactions-to-pull-requests-issues-and-comments/) to show that you are affected by the same issue. * Please don't comment if you have no relevant information to add. It's just extra noise for everyone subscribed to this issue. * Subscribe to receive notifications on status change and new comments. rclone-v1.71.0/.github/ISSUE_TEMPLATE/Feature.md000066400000000000000000000030261505210326400207070ustar00rootroot00000000000000--- name: Feature request about: Suggest a new feature or enhancement for rclone --- #### The associated forum post URL from `https://forum.rclone.org` #### What is your current rclone version (output from `rclone version`)? #### What problem are you are trying to solve? #### How do you think rclone should be changed to solve that? #### How to use GitHub * Please use the 👍 [reaction](https://blog.github.com/2016-03-10-add-reactions-to-pull-requests-issues-and-comments/) to show that you are affected by the same issue. * Please don't comment if you have no relevant information to add. It's just extra noise for everyone subscribed to this issue. * Subscribe to receive notifications on status change and new comments. rclone-v1.71.0/.github/ISSUE_TEMPLATE/config.yml000066400000000000000000000002501505210326400207560ustar00rootroot00000000000000blank_issues_enabled: false contact_links: - name: Rclone Forum Community Support url: https://forum.rclone.org/ about: Please ask and answer questions here. rclone-v1.71.0/.github/PULL_REQUEST_TEMPLATE.md000066400000000000000000000017741505210326400204200ustar00rootroot00000000000000 #### What is the purpose of this change? #### Was the change discussed in an issue or in the forum before? #### Checklist - [ ] I have read the [contribution guidelines](https://github.com/rclone/rclone/blob/master/CONTRIBUTING.md#submitting-a-new-feature-or-bug-fix). - [ ] I have added tests for all changes in this PR if appropriate. - [ ] I have added documentation for the changes if appropriate. - [ ] All commit messages are in [house style](https://github.com/rclone/rclone/blob/master/CONTRIBUTING.md#commit-messages). - [ ] I'm done, this Pull Request is ready for review :-) rclone-v1.71.0/.github/dependabot.yml000066400000000000000000000001651505210326400174400ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: "github-actions" directory: "/" schedule: interval: "daily" rclone-v1.71.0/.github/workflows/000077500000000000000000000000001505210326400166435ustar00rootroot00000000000000rclone-v1.71.0/.github/workflows/build.yml000066400000000000000000000327741505210326400205020ustar00rootroot00000000000000--- # Github Actions build for rclone # -*- compile-command: "yamllint -f parsable build.yml" -*- name: build # 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: build: 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: 60 defaults: run: shell: bash strategy: fail-fast: false matrix: job_name: ['linux', 'linux_386', 'mac_amd64', 'mac_arm64', 'windows', 'other_os', 'go1.24'] include: - job_name: linux os: ubuntu-latest go: '>=1.25.0-rc.1' gotags: cmount build_flags: '-include "^linux/"' check: true quicktest: true racequicktest: true librclonetest: true deploy: true - job_name: linux_386 os: ubuntu-latest go: '>=1.25.0-rc.1' goarch: 386 gotags: cmount quicktest: true - job_name: mac_amd64 os: macos-latest go: '>=1.25.0-rc.1' gotags: 'cmount' build_flags: '-include "^darwin/amd64" -cgo' quicktest: true racequicktest: true deploy: true - job_name: mac_arm64 os: macos-latest go: '>=1.25.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' gotags: cmount cgo: '0' build_flags: '-include "^windows/"' build_args: '-buildmode exe' quicktest: true deploy: true - job_name: other_os os: ubuntu-latest go: '>=1.25.0-rc.1' build_flags: '-exclude "^(windows/|darwin/|linux/)"' compile_all: true deploy: true - job_name: go1.24 os: ubuntu-latest go: '1.24' quicktest: true racequicktest: true name: ${{ matrix.job_name }} runs-on: ${{ matrix.os }} steps: - name: Checkout uses: actions/checkout@v5 with: fetch-depth: 0 - name: Install Go uses: actions/setup-go@v5 with: go-version: ${{ matrix.go }} check-latest: true - name: Set environment variables run: | echo 'GOTAGS=${{ matrix.gotags }}' >> $GITHUB_ENV echo 'BUILD_FLAGS=${{ matrix.build_flags }}' >> $GITHUB_ENV echo 'BUILD_ARGS=${{ matrix.build_args }}' >> $GITHUB_ENV if [[ "${{ matrix.goarch }}" != "" ]]; then echo 'GOARCH=${{ matrix.goarch }}' >> $GITHUB_ENV ; fi if [[ "${{ matrix.cgo }}" != "" ]]; then echo 'CGO_ENABLED=${{ matrix.cgo }}' >> $GITHUB_ENV ; fi - name: Install Libraries on Linux run: | sudo modprobe fuse sudo chmod 666 /dev/fuse sudo chown root:$USER /etc/fuse.conf sudo apt-get update sudo apt-get install -y fuse3 libfuse-dev rpm pkg-config git-annex git-annex-remote-rclone nfs-common if: matrix.os == 'ubuntu-latest' - name: Install Libraries on macOS run: | # https://github.com/Homebrew/brew/issues/15621#issuecomment-1619266788 # https://github.com/orgs/Homebrew/discussions/4612#discussioncomment-6319008 unset HOMEBREW_NO_INSTALL_FROM_API brew untap --force homebrew/core brew untap --force homebrew/cask brew update brew install --cask macfuse brew install git-annex git-annex-remote-rclone if: matrix.os == 'macos-latest' - name: Install Libraries on Windows shell: powershell run: | $ProgressPreference = 'SilentlyContinue' choco install -y winfsp zip echo "CPATH=C:\Program Files\WinFsp\inc\fuse;C:\Program Files (x86)\WinFsp\inc\fuse" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append if ($env:GOARCH -eq "386") { choco install -y mingw --forcex86 --force echo "C:\\ProgramData\\chocolatey\\lib\\mingw\\tools\\install\\mingw32\\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append } # Copy mingw32-make.exe to make.exe so the same command line # can be used on Windows as on macOS and Linux $path = (get-command mingw32-make.exe).Path Copy-Item -Path $path -Destination (Join-Path (Split-Path -Path $path) 'make.exe') if: matrix.os == 'windows-latest' - name: Print Go version and environment run: | printf "Using go at: $(which go)\n" printf "Go version: $(go version)\n" printf "\n\nGo environment:\n\n" go env printf "\n\nRclone environment:\n\n" make vars printf "\n\nSystem environment:\n\n" env - name: Build rclone run: | make - name: Rclone version run: | rclone version - name: Run tests run: | make quicktest if: matrix.quicktest - name: Race test run: | make racequicktest if: matrix.racequicktest - name: Run librclone tests run: | make -C librclone/ctest test make -C librclone/ctest clean librclone/python/test_rclone.py if: matrix.librclonetest - name: Compile all architectures test run: | make make compile_all if: matrix.compile_all - name: Deploy built binaries run: | if [[ "${{ matrix.os }}" == "ubuntu-latest" ]]; then make release_dep_linux ; fi make ci_beta env: RCLONE_CONFIG_PASS: ${{ secrets.RCLONE_CONFIG_PASS }} # working-directory: '$(modulePath)' # Deploy binaries if enabled in config && not a PR && not a fork if: env.RCLONE_CONFIG_PASS != '' && matrix.deploy && github.head_ref == '' && github.repository == 'rclone/rclone' 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 run: | echo "year-week=$(/bin/date -u "+%Y%V")" >> $GITHUB_OUTPUT echo "runner-os-version=$ImageOS" >> $GITHUB_OUTPUT - name: Checkout uses: actions/checkout@v5 with: fetch-depth: 0 - name: Install Go id: setup-go uses: actions/setup-go@v5 with: go-version: '>=1.24.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@v8 with: version: latest skip-cache: true - name: Code quality test (Windows) uses: golangci/golangci-lint-action@v8 env: GOOS: "windows" with: version: latest skip-cache: true - name: Code quality test (macOS) uses: golangci/golangci-lint-action@v8 env: GOOS: "darwin" with: version: latest skip-cache: true - name: Code quality test (FreeBSD) uses: golangci/golangci-lint-action@v8 env: GOOS: "freebsd" with: version: latest skip-cache: true - name: Code quality test (OpenBSD) uses: golangci/golangci-lint-action@v8 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 ./... - name: Check Markdown format uses: DavidAnson/markdownlint-cli2-action@v20 with: globs: | CONTRIBUTING.md MAINTAINERS.md README.md RELEASE.md CODE_OF_CONDUCT.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' 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 name: "android-all" runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v5 with: fetch-depth: 0 # Upgrade together with NDK version - name: Set up Go uses: actions/setup-go@v5 with: go-version: '>=1.25.0-rc.1' - name: Set global environment variables run: | echo "VERSION=$(make version)" >> $GITHUB_ENV - name: build native rclone run: | make - name: install gomobile 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 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 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 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 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 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 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 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 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 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: Upload artifacts 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' rclone-v1.71.0/.github/workflows/build_publish_docker_image.yml000066400000000000000000000243241505210326400247110ustar00rootroot00000000000000--- # Github Actions release for rclone # -*- compile-command: "yamllint -f parsable build_publish_docker_image.yml" -*- name: Build & Push Docker Images # Trigger the workflow on push or pull request on: push: branches: - '**' tags: - '**' workflow_dispatch: inputs: manual: description: Manual run (bypass default conditions) type: boolean default: true jobs: build-image: if: inputs.manual || (github.repository == 'rclone/rclone' && github.event_name != 'pull_request') timeout-minutes: 60 strategy: fail-fast: false matrix: include: - platform: linux/amd64 runs-on: ubuntu-24.04 - platform: linux/386 runs-on: ubuntu-24.04 - platform: linux/arm64 runs-on: ubuntu-24.04-arm - platform: linux/arm/v7 runs-on: ubuntu-24.04-arm - platform: linux/arm/v6 runs-on: ubuntu-24.04-arm name: Build Docker Image for ${{ matrix.platform }} 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 with: fetch-depth: 0 - name: Set REPO_NAME Variable run: | echo "REPO_NAME=`echo ${{github.repository}} | tr '[:upper:]' '[:lower:]'`" >> ${GITHUB_ENV} - name: Set PLATFORM Variable run: | platform=${{ matrix.platform }} echo "PLATFORM=${platform//\//-}" >> $GITHUB_ENV - name: Set CACHE_NAME Variable shell: python run: | import os, re def slugify(input_string, max_length=63): slug = input_string.lower() slug = re.sub(r'[^a-z0-9 -]', ' ', slug) slug = slug.strip() slug = re.sub(r'\s+', '-', slug) slug = re.sub(r'-+', '-', slug) slug = slug[:max_length] slug = re.sub(r'[-]+$', '', slug) return slug 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']) with open(os.environ['GITHUB_ENV'], 'a') as env: env.write(f"CACHE_NAME={ref_name_slug}\n") - 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: Extract Metadata (tags, labels) for Docker id: meta uses: docker/metadata-action@v5 env: DOCKER_METADATA_ANNOTATIONS_LEVELS: manifest,manifest-descriptor # Important for digest annotation (used by Github packages) with: images: | ghcr.io/${{ env.REPO_NAME }} labels: | org.opencontainers.image.url=https://github.com/rclone/rclone/pkgs/container/rclone org.opencontainers.image.vendor=${{ github.repository_owner }} org.opencontainers.image.authors=rclone org.opencontainers.image.source=${{ github.server_url }}/${{ github.repository }} org.opencontainers.image.revision=${{ github.sha }} tags: | type=sha type=ref,event=pr type=ref,event=branch type=semver,pattern={{version}} type=semver,pattern={{major}} type=semver,pattern={{major}}.{{minor}} type=raw,value=beta,enable={{is_default_branch}} - name: Setup QEMU uses: docker/setup-qemu-action@v3 - name: Set up Docker Buildx uses: docker/setup-buildx-action@v3 - name: Load Go Build Cache for Docker id: go-cache uses: actions/cache@v4 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 - name: Inject Go Build Cache into Docker uses: reproducible-containers/buildkit-cache-dance@v3 with: cache-map: | { "go-build-cache": "/root/.cache/go-build" } skip-extraction: ${{ steps.go-cache.outputs.cache-hit }} - name: Login to GitHub Container Registry uses: docker/login-action@v3 with: registry: ghcr.io # This is the user that triggered the Workflow. In this case, it will # either be the user whom created the Release or manually triggered # the workflow_dispatch. username: ${{ github.actor }} password: ${{ secrets.GITHUB_TOKEN }} - name: Build and Publish Image Digest id: build uses: docker/build-push-action@v6 with: file: Dockerfile context: . provenance: false # don't specify 'tags' here (error "get can't push tagged ref by digest") # tags: ${{ steps.meta.outputs.tags }} labels: ${{ steps.meta.outputs.labels }} annotations: ${{ steps.meta.outputs.annotations }} platforms: ${{ matrix.platform }} 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 }} cache-to: | type=registry,ref=ghcr.io/${{ env.REPO_NAME }}:build-${{ env.CACHE_NAME }}-${{ env.PLATFORM }},image-manifest=true,mode=max,compression=zstd - name: Export Image Digest run: | mkdir -p /tmp/digests digest="${{ steps.build.outputs.digest }}" touch "/tmp/digests/${digest#sha256:}" - name: Upload Image Digest uses: actions/upload-artifact@v4 with: name: digests-${{ env.PLATFORM }} path: /tmp/digests/* retention-days: 1 if-no-files-found: error merge-image: name: Merge & Push Final Docker Image runs-on: ubuntu-24.04 needs: - build-image steps: - name: Download Image Digests uses: actions/download-artifact@v5 with: path: /tmp/digests pattern: digests-* merge-multiple: true - name: Set REPO_NAME Variable run: | echo "REPO_NAME=`echo ${{github.repository}} | tr '[:upper:]' '[:lower:]'`" >> ${GITHUB_ENV} - name: Extract Metadata (tags, labels) for Docker id: meta uses: docker/metadata-action@v5 env: DOCKER_METADATA_ANNOTATIONS_LEVELS: index with: images: | ${{ env.REPO_NAME }} ghcr.io/${{ env.REPO_NAME }} labels: | org.opencontainers.image.url=https://github.com/rclone/rclone/pkgs/container/rclone org.opencontainers.image.vendor=${{ github.repository_owner }} org.opencontainers.image.authors=rclone org.opencontainers.image.source=${{ github.server_url }}/${{ github.repository }} org.opencontainers.image.revision=${{ github.sha }} tags: | type=sha type=ref,event=pr type=ref,event=branch type=semver,pattern={{version}} type=semver,pattern={{major}} type=semver,pattern={{major}}.{{minor}} type=raw,value=beta,enable={{is_default_branch}} - name: Extract Tags shell: python run: | import json, os metadata_json = os.environ['DOCKER_METADATA_OUTPUT_JSON'] metadata = json.loads(metadata_json) tags = [f"--tag '{tag}'" for tag in metadata["tags"]] tags_string = " ".join(tags) with open(os.environ['GITHUB_ENV'], 'a') as env: env.write(f"TAGS={tags_string}\n") - name: Extract Annotations shell: python run: | import json, os metadata_json = os.environ['DOCKER_METADATA_OUTPUT_JSON'] metadata = json.loads(metadata_json) annotations = [f"--annotation '{annotation}'" for annotation in metadata["annotations"]] annotations_string = " ".join(annotations) with open(os.environ['GITHUB_ENV'], 'a') as env: env.write(f"ANNOTATIONS={annotations_string}\n") - name: Set up Docker Buildx uses: docker/setup-buildx-action@v3 - name: Login to Docker Hub uses: docker/login-action@v3 with: username: ${{ secrets.DOCKERHUB_USERNAME }} password: ${{ secrets.DOCKERHUB_TOKEN }} - name: Login to GitHub Container Registry uses: docker/login-action@v3 with: registry: ghcr.io # This is the user that triggered the Workflow. In this case, it will # either be the user whom created the Release or manually triggered # the workflow_dispatch. username: ${{ github.actor }} password: ${{ secrets.GITHUB_TOKEN }} - name: Create & Push Manifest List working-directory: /tmp/digests run: | docker buildx imagetools create \ ${{ env.TAGS }} \ ${{ env.ANNOTATIONS }} \ $(printf 'ghcr.io/${{ env.REPO_NAME }}@sha256:%s ' *) - name: Inspect and Run Multi-Platform Image run: | docker buildx imagetools inspect --raw ${{ env.REPO_NAME }}:${{ steps.meta.outputs.version }} docker buildx imagetools inspect --raw ghcr.io/${{ env.REPO_NAME }}:${{ steps.meta.outputs.version }} docker run --rm ghcr.io/${{ env.REPO_NAME }}:${{ steps.meta.outputs.version }} version rclone-v1.71.0/.github/workflows/build_publish_docker_plugin.yml000066400000000000000000000030471505210326400251240ustar00rootroot00000000000000--- # Github Actions release for rclone # -*- compile-command: "yamllint -f parsable build_publish_docker_plugin.yml" -*- name: Release Build for Docker Plugin on: release: types: [published] workflow_dispatch: inputs: manual: description: Manual run (bypass default conditions) type: boolean default: true jobs: build_docker_volume_plugin: if: inputs.manual || github.repository == 'rclone/rclone' name: Build docker plugin job runs-on: ubuntu-latest steps: - name: Free some 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 master uses: actions/checkout@v5 with: fetch-depth: 0 - name: Build and publish docker plugin shell: bash run: | VER=${GITHUB_REF#refs/tags/} PLUGIN_USER=rclone docker login --username ${{ secrets.DOCKER_HUB_USER }} \ --password-stdin <<< "${{ secrets.DOCKER_HUB_PASSWORD }}" for PLUGIN_ARCH in amd64 arm64 arm/v7 arm/v6 ;do export PLUGIN_USER PLUGIN_ARCH make docker-plugin PLUGIN_TAG=${PLUGIN_ARCH/\//-} make docker-plugin PLUGIN_TAG=${PLUGIN_ARCH/\//-}-${VER#v} done make docker-plugin PLUGIN_ARCH=amd64 PLUGIN_TAG=latest make docker-plugin PLUGIN_ARCH=amd64 PLUGIN_TAG=${VER#v} rclone-v1.71.0/.github/workflows/notify.yml000066400000000000000000000005341505210326400207000ustar00rootroot00000000000000name: Notify users based on issue labels on: issues: types: [labeled] jobs: notify: runs-on: ubuntu-latest steps: - uses: jenschelkopf/issue-label-notification-action@1.3 with: token: ${{ secrets.NOTIFY_ACTION_TOKEN }} recipients: | Support Contract=@rclone/support rclone-v1.71.0/.github/workflows/winget.yml000066400000000000000000000004671505210326400206720ustar00rootroot00000000000000name: Publish to Winget on: release: types: [released] jobs: publish: runs-on: ubuntu-latest steps: - uses: vedantmgoyal2009/winget-releaser@v2 with: identifier: Rclone.Rclone installers-regex: '-windows-\w+\.zip$' token: ${{ secrets.WINGET_TOKEN }} rclone-v1.71.0/.gitignore000066400000000000000000000003601505210326400152350ustar00rootroot00000000000000*~ _junk/ rclone rclone.exe build /docs/public/ /docs/.hugo_build.lock /docs/static/img/logos/ rclone.iml .idea .history .vscode *.test *.iml fuzz-build.zip *.orig *.rej Thumbs.db __pycache__ .DS_Store resource_windows_*.syso .devcontainer rclone-v1.71.0/.golangci.yml000066400000000000000000000100611505210326400156300ustar00rootroot00000000000000version: "2" linters: # Configure the linter set. To avoid unexpected results the implicit default # set is ignored and all the ones to use are explicitly enabled. default: none enable: # Default - errcheck - govet - ineffassign - staticcheck - unused # Additional - gocritic - misspell #- prealloc # TODO - revive - unconvert # Configure checks. Mostly using defaults but with some commented exceptions. settings: staticcheck: # With staticcheck there is only one setting, so to extend the implicit # default value it must be explicitly included. checks: # Default - all - -ST1000 - -ST1003 - -ST1016 - -ST1020 - -ST1021 - -ST1022 # Disable quickfix checks - -QF* gocritic: # With gocritic there are different settings, but since enabled-checks # and disabled-checks cannot both be set, for full customization the # alternative is to disable all defaults and explicitly enable the ones # to use. disable-all: true enabled-checks: #- appendAssign # Skip default - argOrder - assignOp - badCall - badCond #- captLocal # Skip default - caseOrder - codegenComment #- commentFormatting # Skip default - defaultCaseOrder - deprecatedComment - dupArg - dupBranchBody - dupCase - dupSubExpr - elseif #- exitAfterDefer # Skip default - flagDeref - flagName #- ifElseChain # Skip default - mapKey - newDeref - offBy1 - regexpMust - ruleguard # Enable additional check that are not enabled by default #- singleCaseSwitch # Skip default - sloppyLen - sloppyTypeAssert - switchTrue - typeSwitchVar - underef - unlambda - unslice - valSwap - wrapperFunc settings: ruleguard: rules: ${base-path}/bin/rules.go revive: # With revive there is in reality only one setting, and when at least one # rule are specified then only these rules will be considered, defaults # and all others are then implicitly disabled, so must explicitly enable # all rules to be used. rules: - name: blank-imports disabled: false - name: context-as-argument disabled: false - name: context-keys-type disabled: false - name: dot-imports disabled: false #- name: empty-block # Skip default # disabled: true - name: error-naming disabled: false - name: error-return disabled: false - name: error-strings disabled: false - name: errorf disabled: false - name: exported disabled: false #- name: increment-decrement # Skip default # disabled: true - name: indent-error-flow disabled: false - name: package-comments disabled: false - name: range disabled: false - name: receiver-naming disabled: false #- name: redefines-builtin-id # Skip default # disabled: true #- name: superfluous-else # Skip default # disabled: true - name: time-naming disabled: false - name: unexported-return disabled: false #- name: unreachable-code # Skip default # disabled: true #- name: unused-parameter # Skip default # disabled: true - name: var-declaration disabled: false - name: var-naming disabled: false formatters: enable: - goimports issues: # Maximum issues count per one linter. Set to 0 to disable. Default is 50. max-issues-per-linter: 0 # Maximum count of issues with the same text. Set to 0 to disable. Default is 3. max-same-issues: 0 run: # Timeout for total work, e.g. 30s, 5m, 5m30s. Default is 0 (disabled). timeout: 10m rclone-v1.71.0/.markdownlint.yml000066400000000000000000000026641505210326400165700ustar00rootroot00000000000000default: 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 rclone-v1.71.0/CODE_OF_CONDUCT.md000066400000000000000000000102701505210326400160450ustar00rootroot00000000000000# Rclone Code of Conduct Like the technical community as a whole, the Rclone team and community is made up of a mixture of professionals and volunteers from all over the world, working on every aspect of the mission - including mentorship, teaching, and connecting people. Diversity is one of our huge strengths, but it can also lead to communication issues and unhappiness. To that end, we have a few ground rules that we ask people to adhere to. This code applies equally to founders, mentors and those seeking help and guidance. This isn't an exhaustive list of things that you can't do. Rather, take it in the spirit in which it's intended - a guide to make it easier to enrich all of us and the technical communities in which we participate. This code of conduct applies to all spaces managed by the Rclone project or Rclone Services Ltd. This includes the issue tracker, the forum, the GitHub site, the wiki, any other online services or in-person events. In addition, violations of this code outside these spaces may affect a person's ability to participate within them. - **Be friendly and patient.** - **Be welcoming.** We strive to be a community that welcomes and supports people of all backgrounds and identities. This includes, but is not limited to members of any race, ethnicity, culture, national origin, colour, immigration status, social and economic class, educational level, sex, sexual orientation, gender identity and expression, age, size, family status, political belief, religion, and mental and physical ability. - **Be considerate.** Your work will be used by other people, and you in turn will depend on the work of others. Any decision you take will affect users and colleagues, and you should take those consequences into account when making decisions. Remember that we're a world-wide community, so you might not be communicating in someone else's primary language. - **Be respectful.** Not all of us will agree all the time, but disagreement is no excuse for poor behavior and poor manners. We might all experience some frustration now and then, but we cannot allow that frustration to turn into a personal attack. It's important to remember that a community where people feel uncomfortable or threatened is not a productive one. Members of the Rclone community should be respectful when dealing with other members as well as with people outside the Rclone community. - **Be careful in the words that you choose.** We are a community of professionals, and we conduct ourselves professionally. Be kind to others. Do not insult or put down other participants. Harassment and other exclusionary behavior aren't acceptable. This includes, but is not limited to: - Violent threats or language directed against another person. - Discriminatory jokes and language. - Posting sexually explicit or violent material. - Posting (or threatening to post) other people's personally identifying information ("doxing"). - Personal insults, especially those using racist or sexist terms. - Unwelcome sexual attention. - Advocating for, or encouraging, any of the above behavior. - Repeated harassment of others. In general, if someone asks you to stop, then stop. - **When we disagree, try to understand why.** Disagreements, both social and technical, happen all the time and Rclone is no exception. It is important that we resolve disagreements and differing views constructively. Remember that we're different. The strength of Rclone comes from its varied community, people from a wide range of backgrounds. Different people have different perspectives on issues. Being unable to understand why someone holds a viewpoint doesn't mean that they're wrong. Don't forget that it is human to err and blaming each other doesn't get us anywhere. Instead, focus on helping to resolve issues and learning from mistakes. If you believe someone is violating the code of conduct, we ask that you report it by emailing [info@rclone.com](mailto:info@rclone.com). Original text courtesy of the [Speak Up! project](http://web.archive.org/web/20141109123859/http://speakup.io/coc.html). ## Questions? If you have questions, please feel free to [contact us](mailto:info@rclone.com). rclone-v1.71.0/CONTRIBUTING.md000066400000000000000000000657151505210326400155150ustar00rootroot00000000000000# Contributing to rclone This is a short guide on how to contribute things to rclone. ## Reporting a bug If you've just got a question or aren't sure if you've found a bug then please use the [rclone forum](https://forum.rclone.org/) instead of filing an issue. When filing an issue, please include the following information if possible as well as a description of the problem. Make sure you test 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 ## 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. 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). 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 ``` 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 ``` Great, you can now compile and execute your own version of rclone: ```sh 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 ``` 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). 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 ``` 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. Make sure you - Add [unit tests](#testing) for a new feature. - Add [documentation](#writing-documentation) for a new feature. - [Commit your changes](#committing-your-changes) using the [commit message guidelines](#commit-messages). When you are done with that push your changes to GitHub: ```sh 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. 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 ### Committing your changes 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 ``` You can modify the message or changes in the latest commit using: ```sh 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). ### 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. Your previously pushed commits are replaced by: ```sh 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): ```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 ``` 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 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 ``` If everything is fine, then make the new combined commit: ```sh 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 ``` 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. ### 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. ## 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. 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). ### 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 ./... ``` You can also use `make`, if supported by your platform ```sh make quicktest ``` The quicktest is [automatically run by GitHub](#github-continuous-integration) when you push your branch to GitHub. ### Backend testing rclone contains a mixture of unit tests and integration tests. Because it is difficult (and in some respects pointless) to test cloud storage systems by mocking all their interfaces, rclone unit tests can run against any of the backends. This is done by making specially named remotes in the default config file. If you wanted to test changes in the `drive` backend, then you would 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 ``` 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/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 ``` ### 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 ``` The commands may require some extra go packages which you can install with ```sh make build_dep ``` The full integration tests are run daily on the integration test server. You can find the results at ## Code Organisation 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 - bin - scripts for use while building or maintaining rclone - cmd - the rclone 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 - 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 - 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 - 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 - librclone - in memory interface to rclone's API for embedding rclone - vfs - Virtual FileSystem layer for implementing rclone mount and similar ## Writing Documentation 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 , 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. 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. - 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). - 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. When writing documentation for an entirely new backend, see [backend documentation](#backend-documentation). 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). 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. ## Making a release There are separate instructions for making a release in the RELEASE.md file. ## Commit messages Please make the first line of your commit message a summary of the change that a user (not a developer) of rclone would like to read, and prefix it with the directory of the change followed by a colon. The changelog gets made by looking at just these first lines so make it good! If you have more to say about the commit, then enter a blank line and carry on the description. Remember to say why the change was needed - the commit itself shows what was changed. Writing more is better than less. Comparing the behaviour before the change to that after the change is very useful. Imagine you are writing to yourself in 12 months time when you've forgotten everything about what you just did and you need to get up to speed quickly. If the change fixes an issue then write `Fixes #1234` in the commit message. This can be on the subject line if it will fit. If you don't want to close the associated issue just put `#1234` and the 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 indefinitely. This was fixed by closing the read pipe after the Put completed. This will cause the write side to return a pipe closed error fixing the hang. Fixes #1498 ``` ## Adding a dependency rclone uses the [go modules](https://tip.golang.org/cmd/go/#hdr-Modules__module_versions__and_more) support in go1.11 and later to manage its dependencies. rclone can be built with modules outside of the `GOPATH`. 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 ``` 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. Please check in the changes generated by `go mod` including `go.mod` and `go.sum` in the same commit as your other changes. ## Updating a dependency If you need to update a dependency then run ```sh go get golang.org/x/crypto ``` Check in a single commit as above. ## Updating all the dependencies In order to update all the dependencies then run `make update`. This just uses the go modules to update all the modules to their latest stable release. Check in the changes in a single commit as above. This should be done early in the release cycle to pick up new versions of packages in time for them to get some testing. ## Updating a backend If you update a backend then please run the unit tests and the integration tests for that backend. Assuming the backend is called `remote`, make create a config entry called `TestRemote` for the tests to use. Now `cd remote` and run `go test -v` to run the unit tests. Then `cd fs` and run `go test -v -remote TestRemote:` to run the integration tests. The next section goes into more detail about the tests. ## Writing a new backend Choose a name. The docs here will use `remote` as an example. Note that in rclone terminology a file system backend is called a remote or an fs. ### Research - Look at the interfaces defined in `fs/types.go` - Study one or more of the existing remotes ### 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 - 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 ### 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** 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! ### Unit tests - Create a config entry called `TestRemote` for the unit tests to use - Create a `backend/remote/remote_test.go` - copy and adjust your example remote - Make sure all tests pass with `go test -v` ### 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 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:` - If your remote defines `ListR` check with this also - `go test -v -remote TestRemote: -fast-list` See the [testing](#testing) section for more information on integration tests. ### Backend documentation Add your backend to the docs - you'll need to pick an icon for it from [fontawesome](http://fontawesome.io/icons/). Keep lists of remotes in 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/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 - `bin/make_manual.py` - add the page to the `docs` constant Once you've written the docs, run `make serve` and check they look OK in the web browser and the links (internal and external) all work. ## Adding a new s3 provider 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. - `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` - `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` - `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` When adding the provider, endpoints, quirks, docs etc keep them in alphabetical order by `Provider` name, but with `AWS` first and `Other` last. Once you've written the docs, run `make serve` and check they look OK in the web browser and the links (internal and external) all work. Once you've written the code, test `rclone config` works to your satisfaction, and check the integration tests work `go test -v -remote NewS3Provider:`. You may need to adjust the quirks to get them to pass. Some providers just can't pass the tests with control characters in the names so if these fail and the provider doesn't support `urlEncodeListings` in the quirks then ignore them. Note that the `SetTier` test may also fail on non AWS providers. For an example of adding an s3 provider see [eb3082a1](https://github.com/rclone/rclone/commit/eb3082a1ebdb76d5625f14cedec3f5154a5e7b10). ## 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. ### 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) ### 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. Then, run `go build -buildmode=plugin -o PLUGIN_NAME.so .` to build the plugin. [Go reference](https://godoc.org/github.com/rclone/rclone/lib/plugin) ## Keeping a backend or command out of tree Rclone was designed to be modular so it is very easy to keep a backend or a command out of the main rclone source tree. So for example if you had a backend which accessed your proprietary systems or a command which was specialised for your needs you could 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 which has an example of an out of tree backend `ram` (which is a renamed version of the `memory` backend). rclone-v1.71.0/COPYING000066400000000000000000000021071505210326400143010ustar00rootroot00000000000000Copyright (C) 2012 by Nick Craig-Wood http://www.craig-wood.com/nick/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. rclone-v1.71.0/Dockerfile000066400000000000000000000022361505210326400152430ustar00rootroot00000000000000FROM golang:alpine AS builder ARG CGO_ENABLED=0 WORKDIR /go/src/github.com/rclone/rclone/ RUN echo "**** Set Go Environment Variables ****" && \ go env -w GOCACHE=/root/.cache/go-build RUN echo "**** Install Dependencies ****" && \ apk add --no-cache \ make \ bash \ gawk \ git COPY go.mod . COPY go.sum . RUN echo "**** Download Go Dependencies ****" && \ go mod download -x RUN echo "**** Verify Go Dependencies ****" && \ go mod verify COPY . . RUN --mount=type=cache,target=/root/.cache/go-build,sharing=locked \ echo "**** Build Binary ****" && \ make RUN echo "**** Print Version Binary ****" && \ ./rclone version # Begin final image FROM alpine:latest RUN echo "**** Install Dependencies ****" && \ apk add --no-cache \ ca-certificates \ fuse3 \ tzdata && \ echo "Enable user_allow_other in fuse" && \ echo "user_allow_other" >> /etc/fuse.conf COPY --from=builder /go/src/github.com/rclone/rclone/rclone /usr/local/bin/ RUN addgroup -g 1009 rclone && adduser -u 1009 -Ds /bin/sh -G rclone rclone ENTRYPOINT [ "rclone" ] WORKDIR /data ENV XDG_CONFIG_HOME=/config rclone-v1.71.0/MAINTAINERS.md000066400000000000000000000136411505210326400153470ustar00rootroot00000000000000# Maintainers guide for rclone Current active maintainers of rclone are: | Name | GitHub ID | Specific Responsibilities | | :--------------- | :---------------- | :-------------------------- | | Nick Craig-Wood | @ncw | overall project health | | Stefan Breunig | @breunigs | | | Ishuah Kariuki | @ishuah | | | Remus Bunduc | @remusb | cache backend | | Fabian Möller | @B4dM4n | | | Alex Chen | @Cnly | onedrive backend | | Sandeep Ummadi | @sandeepkru | azureblob backend | | Sebastian Bünger | @buengese | jottacloud, yandex & compress backends | | Ivan Andreev | @ivandeex | chunker & mailru backends | | Max Sum | @Max-Sum | union backend | | Fred | @creativeprojects | seafile backend | | Caleb Case | @calebcase | storj backend | | wiserain | @wiserain | pikpak backend | | albertony | @albertony | | | Chun-Hung Tseng | @henrybear327 | Proton Drive Backend | | Hideo Aoyama | @boukendesho | snap packaging | | nielash | @nielash | bisync | | Dan McArdle | @dmcardle | gitannex | | Sam Harrison | @childish-sambino | filescom | ## 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. ## 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. 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 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). 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 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 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 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. 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. ## 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. ## 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. 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. 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. ## Mailing list There is now an invite-only mailing list for rclone developers `rclone-dev` on google groups. ## TODO I should probably make a to register with cloud providers. rclone-v1.71.0/MANUAL.html000066400000000000000000143547261505210326400151370ustar00rootroot00000000000000 rclone(1) User Manual

rclone(1) User Manual

Nick Craig-Wood

Aug 22, 2025

NAME

rclone - manage files on cloud storage

SYNOPSIS

Usage:
  rclone [flags]
  rclone [command]

Available commands:
  about       Get quota information from the remote.
  authorize   Remote authorization.
  backend     Run a backend-specific command.
  bisync      Perform bidirectional synchronization between two paths.
  cat         Concatenates any files and sends them to stdout.
  check       Checks the files in the source and destination match.
  checksum    Checks the files in the destination against a SUM file.
  cleanup     Clean up the remote if possible.
  completion  Output completion script for a given shell.
  config      Enter an interactive configuration session.
  convmv      Convert file and directory names in place.
  copy        Copy files from source to dest, skipping identical files.
  copyto      Copy files from source to dest, skipping identical files.
  copyurl     Copy the contents of the URL supplied content to dest:path.
  cryptcheck  Cryptcheck checks the integrity of an encrypted remote.
  cryptdecode Cryptdecode returns unencrypted file names.
  dedupe      Interactively find duplicate filenames and delete/rename them.
  delete      Remove the files in path.
  deletefile  Remove a single file from remote.
  gendocs     Output markdown docs for rclone to the directory supplied.
  gitannex    Speaks with git-annex over stdin/stdout.
  hashsum     Produces a hashsum file for all the objects in the path.
  help        Show help for rclone commands, flags and backends.
  link        Generate public link to file/folder.
  listremotes List all the remotes in the config file and defined in environment variables.
  ls          List the objects in the path with size and path.
  lsd         List all directories/containers/buckets in the path.
  lsf         List directories and objects in remote:path formatted for parsing.
  lsjson      List directories and objects in the path in JSON format.
  lsl         List the objects in path with modification time, size and path.
  md5sum      Produces an md5sum file for all the objects in the path.
  mkdir       Make the path if it doesn't already exist.
  mount       Mount the remote as file system on a mountpoint.
  move        Move files from source to dest.
  moveto      Move file or directory from source to dest.
  ncdu        Explore a remote with a text based user interface.
  nfsmount    Mount the remote as file system on a mountpoint.
  obscure     Obscure password for use in the rclone config file.
  purge       Remove the path and all of its contents.
  rc          Run a command against a running rclone.
  rcat        Copies standard input to file on remote.
  rcd         Run rclone listening to remote control commands only.
  rmdir       Remove the empty directory at path.
  rmdirs      Remove empty directories under the path.
  selfupdate  Update the rclone binary.
  serve       Serve a remote over a protocol.
  settier     Changes storage class/tier of objects in remote.
  sha1sum     Produces an sha1sum file for all the objects in the path.
  size        Prints the total size and number of objects in remote:path.
  sync        Make source and dest identical, modifying destination only.
  test        Run a test command
  touch       Create new file or change file modification time.
  tree        List the contents of the remote in a tree like fashion.
  version     Show the version number.

Use "rclone [command] --help" for more information about a command.
Use "rclone help flags" for to see the global flags.
Use "rclone help backends" for a list of supported services.

Rclone syncs your files to cloud storage

rclone logo

About rclone

Rclone is a command-line program to manage files on cloud storage. It is a feature-rich alternative to cloud vendors' web storage interfaces. Over 70 cloud storage products support rclone including S3 object stores, business & consumer file storage services, as well as standard transfer protocols.

Rclone has powerful cloud equivalents to the unix commands rsync, cp, mv, mount, ls, ncdu, tree, rm, and cat. Rclone's familiar syntax includes shell pipeline support, and --dry-run protection. It is used at the command line, in scripts or via its API.

Users call rclone "The Swiss army knife of cloud storage", and "Technology indistinguishable from magic".

Rclone really looks after your data. It preserves timestamps and verifies checksums at all times. Transfers over limited bandwidth; intermittent connections, or subject to quota can be restarted, from the last good file transferred. You can check the integrity of your files. Where possible, rclone employs server-side transfers to minimise local bandwidth use and transfers from one provider to another without using local disk.

Virtual backends wrap local and cloud file systems to apply encryption, compression, chunking, hashing and joining.

Rclone mounts any local, cloud or virtual filesystem as a disk on Windows, macOS, linux and FreeBSD, and also serves these over SFTP, HTTP, WebDAV, FTP and DLNA.

Rclone is mature, open-source software originally inspired by rsync and written in Go. The friendly support community is familiar with varied use cases. Official Ubuntu, Debian, Fedora, Brew and Chocolatey repos. include rclone. For the latest version downloading from rclone.org is recommended.

Rclone is widely used on Linux, Windows and Mac. Third-party developers create innovative backup, restore, GUI and business process solutions using the rclone command line or API.

Rclone does the heavy lifting of communicating with cloud storage.

What can rclone do for you?

Rclone helps you:

  • Backup (and encrypt) files to cloud storage
  • Restore (and decrypt) files from cloud storage
  • Mirror cloud data to other cloud services or locally
  • Migrate data to the cloud, or between cloud storage vendors
  • Mount multiple, encrypted, cached or diverse cloud storage as a disk
  • Analyse and account for data held on cloud storage using lsf, ljson, size, ncdu
  • Union file systems together to present multiple local and/or cloud file systems as one

Features

  • Transfers
    • MD5, SHA1 hashes are checked at all times for file integrity
    • Timestamps are preserved on files
    • Operations can be restarted at any time
    • Can be to and from network, e.g. two different cloud providers
    • Can use multi-threaded downloads to local disk
  • Copy new or changed files to cloud storage
  • Sync (one way) to make a directory identical
  • Bisync (two way) to keep two directories in sync bidirectionally
  • Move files to cloud storage deleting the local after verification
  • Check hashes and for missing/extra files
  • Mount your cloud storage as a network disk
  • Serve local or remote files over HTTP/WebDav/FTP/SFTP/DLNA
  • Experimental Web based GUI

Supported providers

(There are many others, built on standard protocols such as WebDAV or S3, that work out of the box.)

  • 1Fichier
  • Akamai Netstorage
  • Alibaba Cloud (Aliyun) Object Storage System (OSS)
  • Amazon S3
  • Backblaze B2
  • Box
  • Ceph
  • China Mobile Ecloud Elastic Object Storage (EOS)
  • Arvan Cloud Object Storage (AOS)
  • Citrix ShareFile
  • Cloudflare R2
  • Cloudinary
  • DigitalOcean Spaces
  • Digi Storage
  • Dreamhost
  • Dropbox
  • Enterprise File Fabric
  • Exaba
  • Fastmail Files
  • FileLu Cloud Storage
  • Files.com
  • FlashBlade
  • FTP
  • Gofile
  • Google Cloud Storage
  • Google Drive
  • Google Photos
  • HDFS
  • Hetzner Storage Box
  • HiDrive
  • HTTP
  • iCloud Drive
  • ImageKit
  • Internet Archive
  • Jottacloud
  • IBM COS S3
  • IDrive e2
  • IONOS Cloud
  • Koofr
  • Leviia Object Storage
  • Liara Object Storage
  • Linkbox
  • Linode Object Storage
  • Magalu
  • Mail.ru Cloud
  • Memset Memstore
  • MEGA
  • MEGA S4
  • Memory
  • Microsoft Azure Blob Storage
  • Microsoft Azure Files Storage
  • Microsoft OneDrive
  • Minio
  • Nextcloud
  • Blomp Cloud Storage
  • OpenDrive
  • OpenStack Swift
  • Oracle Cloud Storage Swift
  • Oracle Object Storage
  • Outscale
  • OVHcloud Object Storage (Swift)
  • OVHcloud Object Storage (S3-compatible)
  • ownCloud
  • pCloud
  • Petabox
  • PikPak
  • Pixeldrain
  • premiumize.me
  • put.io
  • Proton Drive
  • QingStor
  • Qiniu Cloud Object Storage (Kodo)
  • Quatrix by Maytech
  • Rackspace Cloud Files
  • rsync.net
  • Scaleway
  • Seafile
  • Seagate Lyve Cloud
  • SeaweedFS
  • Selectel
  • SFTP
  • Sia
  • SMB / CIFS
  • StackPath
  • Storj
  • Synology
  • SugarSync
  • Tencent Cloud Object Storage (COS)
  • Uloz.to
  • Uptobox
  • Wasabi
  • WebDAV
  • Yandex Disk
  • Zoho WorkDrive
  • Zata
  • The local filesystem

Virtual providers

These backends adapt or modify other storage providers:

  • Alias: Rename existing remotes
  • Cache: Cache remotes (DEPRECATED)
  • Chunker: Split large files
  • Combine: Combine multiple remotes into a directory tree
  • Compress: Compress files
  • Crypt: Encrypt files
  • Hasher: Hash files
  • Union: Join multiple remotes to work together

Install

Rclone is a Go program and comes as a single binary file.

Quickstart

See below for some expanded Linux / macOS / Windows instructions.

See the usage docs for how to use rclone, or run rclone -h.

Already installed rclone can be easily updated to the latest version using the rclone selfupdate command.

See the release signing docs for how to verify signatures on the release.

Script installation

To install rclone on Linux/macOS/BSD systems, run:

sudo -v ; curl https://rclone.org/install.sh | sudo bash

For beta installation, run:

sudo -v ; curl https://rclone.org/install.sh | sudo bash -s beta

Note that this script checks the version of rclone installed first and won't re-download if not needed.

Linux installation

Precompiled binary

Fetch and unpack

curl -O https://downloads.rclone.org/rclone-current-linux-amd64.zip
unzip rclone-current-linux-amd64.zip
cd rclone-*-linux-amd64

Copy binary file

sudo cp rclone /usr/bin/
sudo chown root:root /usr/bin/rclone
sudo chmod 755 /usr/bin/rclone

Install manpage

sudo mkdir -p /usr/local/share/man/man1
sudo cp rclone.1 /usr/local/share/man/man1/
sudo mandb

Run rclone config to setup. See rclone config docs for more details.

rclone config

macOS installation

Installation with brew

brew install rclone

NOTE: This version of rclone will not support mount any more (see #5373). If mounting is wanted on macOS, either install a precompiled binary or enable the relevant option when installing from source.

Note that this is a third party installer not controlled by the rclone developers so it may be out of date. Its current version is as below.

Homebrew package

Installation with MacPorts

On macOS, rclone can also be installed via MacPorts:

sudo port install rclone

Note that this is a third party installer not controlled by the rclone developers so it may be out of date. Its current version is as below.

MacPorts port

More information on macports.org.

Precompiled binary, using curl

To avoid problems with macOS gatekeeper enforcing the binary to be signed and notarized it is enough to download with curl.

Download the latest version of rclone.

cd && curl -O https://downloads.rclone.org/rclone-current-osx-amd64.zip

Unzip the download and cd to the extracted folder.

unzip -a rclone-current-osx-amd64.zip && cd rclone-*-osx-amd64

Move rclone to your $PATH. You will be prompted for your password.

sudo mkdir -p /usr/local/bin
sudo mv rclone /usr/local/bin/

(the mkdir command is safe to run, even if the directory already exists).

Remove the leftover files.

cd .. && rm -rf rclone-*-osx-amd64 rclone-current-osx-amd64.zip

Run rclone config to setup. See rclone config docs for more details.

rclone config

Precompiled binary, using a web browser

When downloading a binary with a web browser, the browser will set the macOS gatekeeper quarantine attribute. Starting from Catalina, when attempting to run rclone, a pop-up will appear saying:

"rclone" cannot be opened because the developer cannot be verified.
macOS cannot verify that this app is free from malware.

The simplest fix is to run

xattr -d com.apple.quarantine rclone

Windows installation

Precompiled binary

Fetch the correct binary for your processor type by clicking on these links. If not sure, use the first link.

Open this file in the Explorer and extract rclone.exe. Rclone is a portable executable so you can place it wherever is convenient.

Open a CMD window (or powershell) and run the binary. Note that rclone does not launch a GUI by default, it runs in the CMD Window.

If you are planning to use the rclone mount feature then you will need to install the third party utility WinFsp also.

Windows package manager (Winget)

Winget comes pre-installed with the latest versions of Windows. If not, update the App Installer package from the Microsoft store.

To install rclone

winget install Rclone.Rclone

To uninstall rclone

winget uninstall Rclone.Rclone --force

Chocolatey package manager

Make sure you have Choco installed

choco search rclone
choco install rclone

This will install rclone on your Windows machine. If you are planning to use rclone mount then

choco install winfsp

will install that too.

Note that this is a third party installer not controlled by the rclone developers so it may be out of date. Its current version is as below.

Chocolatey package

Scoop package manager

Make sure you have Scoop installed

scoop install rclone

Note that this is a third party installer not controlled by the rclone developers so it may be out of date. Its current version is as below.

Scoop package

Package manager installation

Many Linux, Windows, macOS and other OS distributions package and distribute rclone.

The distributed versions of rclone are often quite out of date and for this reason we recommend one of the other installation methods if possible.

You can get an idea of how up to date or not your OS distribution's package is here.

Packaging status

Docker installation

The rclone developers maintain a docker image for rclone.

Note: We also now offer a paid version of rclone with enterprise-grade security and zero CVEs through our partner SecureBuild. If you are interested, check out their website and the Rclone SecureBuild Image.

These images are built as part of the release process based on a minimal Alpine Linux.

The :latest tag will always point to the latest stable release. You can use the :beta tag to get the latest build from master. You can also use version tags, e.g. :1.49.1, :1.49 or :1.

$ docker pull rclone/rclone:latest
latest: Pulling from rclone/rclone
Digest: sha256:0e0ced72671989bb837fea8e88578b3fc48371aa45d209663683e24cfdaa0e11
...
$ docker run --rm rclone/rclone:latest version
rclone v1.49.1
- os/arch: linux/amd64
- go version: go1.12.9

There are a few command line options to consider when starting an rclone Docker container from the rclone image.

  • You need to mount the host rclone config dir at /config/rclone into the Docker container. Due to the fact that rclone updates tokens inside its config file, and that the update process involves a file rename, you need to mount the whole host rclone config dir, not just the single host rclone config file.

  • You need to mount a host data dir at /data into the Docker container.

  • By default, the rclone binary inside a Docker container runs with UID=0 (root). As a result, all files created in a run will have UID=0. If your config and data files reside on the host with a non-root UID:GID, you need to pass these on the container start command line.

  • If you want to access the RC interface (either via the API or the Web UI), it is required to set the --rc-addr to :5572 in order to connect to it from outside the container. An explanation about why this is necessary can be found in an old pythonspeed.com article.

    • NOTE: Users running this container with the docker network set to host should probably set it to listen to localhost only, with 127.0.0.1:5572 as the value for --rc-addr

  • It is possible to use rclone mount inside a userspace Docker container, and expose the resulting fuse mount to the host. The exact docker run options to do that might vary slightly between hosts. See, e.g. the discussion in this thread.

    You also need to mount the host /etc/passwd and /etc/group for fuse to work inside the container.

Here are some commands tested on an Ubuntu 18.04.3 host:

# config on host at ~/.config/rclone/rclone.conf
# data on host at ~/data

# add a remote interactively
docker run --rm -it \
    --volume ~/.config/rclone:/config/rclone \
    --user $(id -u):$(id -g) \
    rclone/rclone \
    config

# make sure the config is ok by listing the remotes
docker run --rm \
    --volume ~/.config/rclone:/config/rclone \
    --user $(id -u):$(id -g) \
    rclone/rclone \
    listremotes

# perform mount inside Docker container, expose result to host
mkdir -p ~/data/mount
docker run --rm \
    --volume ~/.config/rclone:/config/rclone \
    --volume ~/data:/data:shared \
    --user $(id -u):$(id -g) \
    --volume /etc/passwd:/etc/passwd:ro --volume /etc/group:/etc/group:ro \
    --device /dev/fuse --cap-add SYS_ADMIN --security-opt apparmor:unconfined \
    rclone/rclone \
    mount dropbox:Photos /data/mount &
ls ~/data/mount
kill %1

Snap installation

Get it from the Snap Store

Make sure you have Snapd installed

sudo snap install rclone

Due to the strict confinement of Snap, rclone snap cannot access real /home/$USER/.config/rclone directory, default config path is as below.

  • Default config directory:
    • /home/$USER/snap/rclone/current/.config/rclone

Note: Due to the strict confinement of Snap, rclone mount feature is not supported.

If mounting is wanted, either install a precompiled binary or enable the relevant option when installing from source.

Note that this is controlled by community maintainer not the rclone developers so it may be out of date. Its current version is as below.

rclone

Source installation

Make sure you have git and Go installed. Go version 1.24 or newer is required, the latest release is recommended. You can get it from your package manager, or download it from golang.org/dl. Then you can run the following:

git clone https://github.com/rclone/rclone.git
cd rclone
go build

This will check out the rclone source in subfolder rclone, which you can later modify and send pull requests with. Then it will build the rclone executable in the same folder. As an initial check you can now run ./rclone version (.\rclone version on Windows).

Note that on macOS and Windows the mount command will not be available unless you specify an additional build tag cmount.

go build -tags cmount

This assumes you have a GCC compatible C compiler (GCC or Clang) in your PATH, as it uses cgo. But on Windows, the cgofuse library that the cmount implementation is based on, also supports building without cgo, i.e. by setting environment variable CGO_ENABLED to value 0 (static linking). This is how the official Windows release of rclone is being built, starting with version 1.59. It is still possible to build with cgo on Windows as well, by using the MinGW port of GCC, e.g. by installing it in a MSYS2 distribution (make sure you install it in the classic mingw64 subsystem, the ucrt64 version is not compatible).

Additionally, to build with mount on Windows, you must install the third party utility WinFsp, with the "Developer" feature selected. If building with cgo, you must also set environment variable CPATH pointing to the fuse include directory within the WinFsp installation (normally C:\Program Files (x86)\WinFsp\inc\fuse).

You may add arguments -ldflags -s to omit symbol table and debug information, making the executable file smaller, and -trimpath to remove references to local file system paths. The official rclone releases are built with both of these.

go build -trimpath -ldflags -s -tags cmount

If you want to customize the version string, as reported by the rclone version command, you can set one of the variables fs.Version, fs.VersionTag (to keep default suffix but customize the number), or fs.VersionSuffix (to keep default number but customize the suffix). This can be done from the build command, by adding to the -ldflags argument value as shown below.

go build -trimpath -ldflags "-s -X github.com/rclone/rclone/fs.Version=v9.9.9-test" -tags cmount

On Windows, the official executables also have the version information, as well as a file icon, embedded as binary resources. To get that with your own build you need to run the following command before the build command. It generates a Windows resource system object file, with extension .syso, e.g. resource_windows_amd64.syso, that will be automatically picked up by future build commands.

go run bin/resource_windows.go

The above command will generate a resource file containing version information based on the fs.Version variable in source at the time you run the command, which means if the value of this variable changes you need to re-run the command for it to be reflected in the version information. Also, if you override this version variable in the build command as described above, you need to do that also when generating the resource file, or else it will still use the value from the source.

go run bin/resource_windows.go -version v9.9.9-test

Instead of executing the go build command directly, you can run it via the Makefile. The default target changes the version suffix from "-DEV" to "-beta" followed by additional commit details, embeds version information binary resources on Windows, and copies the resulting rclone executable into your GOPATH bin folder ($(go env GOPATH)/bin, which corresponds to ~/go/bin/rclone by default).

make

To include mount command on macOS and Windows with Makefile build:

make GOTAGS=cmount

There are other make targets that can be used for more advanced builds, such as cross-compiling for all supported os/architectures, and packaging results into release artifacts. See Makefile and cross-compile.go for details.

Another alternative method for source installation is to download the source, build and install rclone - all in one operation, as a regular Go package. The source will be stored it in the Go module cache, and the resulting executable will be in your GOPATH bin folder ($(go env GOPATH)/bin, which corresponds to ~/go/bin/rclone by default).

go install github.com/rclone/rclone@latest

In some situations, rclone executable size might be too big for deployment in very restricted environments when all backends with large SDKs are included. To limit binary size unused backends can be commented out in backends/all/all.go and unused commands in cmd/all/all.go before building with go build or make

Ansible installation

This can be done with Stefan Weichinger's ansible role.

Instructions

  1. git clone https://github.com/stefangweichinger/ansible-rclone.git into your local roles-directory

  2. add the role to the hosts you want rclone installed to:

    - hosts: rclone-hosts
  roles:
    - rclone

Portable installation

As mentioned above, rclone is single executable (rclone, or rclone.exe on Windows) that you can download as a zip archive and extract into a location of your choosing. When executing different commands, it may create files in different locations, such as a configuration file and various temporary files. By default the locations for these are according to your operating system, e.g. configuration file in your user profile directory and temporary files in the standard temporary directory, but you can customize all of them, e.g. to make a completely self-contained, portable installation.

Run the config paths command to see the locations that rclone will use.

To override them set the corresponding options (as command-line arguments, or as environment variables):

Autostart

After installing and configuring rclone, as described above, you are ready to use rclone as an interactive command line utility. If your goal is to perform periodic operations, such as a regular sync, you will probably want to configure your rclone command in your operating system's scheduler. If you need to expose service-like features, such as remote control, GUI, serve or mount, you will often want an rclone command always running in the background, and configuring it to run in a service infrastructure may be a better option. Below are some alternatives on how to achieve this on different operating systems.

NOTE: Before setting up autorun it is highly recommended that you have tested your command manually from a Command Prompt first.

Autostart on Windows

The most relevant alternatives for autostart on Windows are:

  • Run at user log on using the Startup folder
  • Run at user log on, at system startup or at schedule using Task Scheduler
  • Run at system startup using Windows service

Running in background

Rclone is a console application, so if not starting from an existing Command Prompt, e.g. when starting rclone.exe from a shortcut, it will open a Command Prompt window. When configuring rclone to run from task scheduler and windows service you are able to set it to run hidden in background. From rclone version 1.54 you can also make it run hidden from anywhere by adding option --no-console (it may still flash briefly when the program starts). Since rclone normally writes information and any error messages to the console, you must redirect this to a file to be able to see it. Rclone has a built-in option --log-file for that.

Example command to run a sync in background:

c:\rclone\rclone.exe sync c:\files remote:/files --no-console --log-file c:\rclone\logs\sync_files.txt

User account

As mentioned in the mount documentation, mounted drives created as Administrator are not visible to other accounts, not even the account that was elevated as Administrator. By running the mount command as the built-in SYSTEM user account, it will create drives accessible for everyone on the system. Both scheduled task and Windows service can be used to achieve this.

NOTE: Remember that when rclone runs as the SYSTEM user, the user profile that it sees will not be yours. This means that if you normally run rclone with configuration file in the default location, to be able to use the same configuration when running as the system user you must explicitly tell rclone where to find it with the --config option, or else it will look in the system users profile path (C:\Windows\System32\config\systemprofile). To test your command manually from a Command Prompt, you can run it with the PsExec utility from Microsoft's Sysinternals suite, which takes option -s to execute commands as the SYSTEM user.

Start from Startup folder

To quickly execute an rclone command you can simply create a standard Windows Explorer shortcut for the complete rclone command you want to run. If you store this shortcut in the special "Startup" start-menu folder, Windows will automatically run it at login. To open this folder in Windows Explorer, enter path %APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup, or C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp if you want the command to start for every user that logs in.

This is the easiest approach to autostarting of rclone, but it offers no functionality to set it to run as different user, or to set conditions or actions on certain events. Setting up a scheduled task as described below will often give you better results.

Start from Task Scheduler

Task Scheduler is an administrative tool built into Windows, and it can be used to configure rclone to be started automatically in a highly configurable way, e.g. periodically on a schedule, on user log on, or at system startup. It can run be configured to run as the current user, or for a mount command that needs to be available to all users it can run as the SYSTEM user. For technical information, see Task Scheduler for developers.

Run as service

For running rclone at system startup, you can create a Windows service that executes your rclone command, as an alternative to scheduled task configured to run at startup.

Mount command built-in service integration

For mount commands, rclone has a built-in Windows service integration via the third-party WinFsp library it uses. Registering as a regular Windows service easy, as you just have to execute the built-in PowerShell command New-Service (requires administrative privileges).

Example of a PowerShell command that creates a Windows service for mounting some remote:/files as drive letter X:, for all users (service will be running as the local system account):

New-Service -Name Rclone -BinaryPathName 'c:\rclone\rclone.exe mount remote:/files X: --config c:\rclone\config\rclone.conf --log-file c:\rclone\logs\mount.txt'

The WinFsp service infrastructure supports incorporating services for file system implementations, such as rclone, into its own launcher service, as kind of "child services". This has the additional advantage that it also implements a network provider that integrates into Windows standard methods for managing network drives. This is currently not officially supported by Rclone, but with WinFsp version 2019.3 B2 / v1.5B2 or later it should be possible through path rewriting as described in #3340.

Third-party service integration

To Windows service running any rclone command, the excellent third-party utility NSSM, the "Non-Sucking Service Manager", can be used. It includes some advanced features such as adjusting process priority, defining process environment variables, redirect to file anything written to stdout, and customized response to different exit codes, with a GUI to configure everything from (although it can also be used from command line ).

There are also several other alternatives. To mention one more, WinSW, "Windows Service Wrapper", is worth checking out. It requires .NET Framework, but it is preinstalled on newer versions of Windows, and it also provides alternative standalone distributions which includes necessary runtime (.NET 5). WinSW is a command-line only utility, where you have to manually create an XML file with service configuration. This may be a drawback for some, but it can also be an advantage as it is easy to back up and reuse the configuration settings, without having go through manual steps in a GUI. One thing to note is that by default it does not restart the service on error, one have to explicit enable this in the configuration file (via the "onfailure" parameter).

Autostart on Linux

Start as a service

To always run rclone in background, relevant for mount commands etc, you can use systemd to set up rclone as a system or user service. Running as a system service ensures that it is run at startup even if the user it is running as has no active session. Running rclone as a user service ensures that it only starts after the configured user has logged into the system.

Run periodically from cron

To run a periodic command, such as a copy/sync, you can set up a cron job.

Usage

Rclone is a command line program to manage files on cloud storage. After download and install, continue here to learn how to use it: Initial configuration, what the basic syntax looks like, describes the various subcommands, the various options, and more.

Configure

First, you'll need to configure rclone. As the object storage systems have quite complicated authentication these are kept in a config file. (See the --config entry for how to find the config file and choose its location.)

The easiest way to make the config is to run rclone with the config option:

rclone config

See the following for detailed instructions for

Basic syntax

Rclone syncs a directory tree from one storage system to another.

Its syntax is like this

rclone subcommand [options] <parameters> <parameters...>

A subcommand is a the rclone operation required, (e.g. sync, copy, ls).

An option is a single letter flag (e.g. -v) or a group of single letter flags (e.g. -Pv) or a long flag (e.g. --progress). No options are required. Options can come after the subcommand or in between parameters too or on the end, but only global options can be used before the subcommand. Anything after a -- option will not be interpreted as an option so if you need to add a parameter which starts with a - then put a -- on its own first, eg

rclone lsf -- -directory-starting-with-dash

A parameter is usually a file path or rclone remote, eg /path/to/file or remote:path/to/file but it can be other things - the subcommand help will tell you what.

Source and destination paths are specified by the name you gave the storage system in the config file then the sub path, e.g. "drive:myfolder" to look at "myfolder" in Google drive.

You can define as many storage paths as you like in the config file.

Please use the --interactive/-i flag while learning rclone to avoid accidental data loss.

Subcommands

rclone uses a system of subcommands. For example

rclone ls remote:path # lists a remote
rclone copy /local/path remote:path # copies /local/path to the remote
rclone sync --interactive /local/path remote:path # syncs /local/path to the remote

rclone config

Enter an interactive configuration session.

Synopsis

Enter an interactive configuration session where you can setup new remotes and manage existing ones. You may also set or remove a password to protect your configuration.

rclone config [flags]

Options

  -h, --help   help for config

See the global flags page for global options not listed here.

See Also

rclone copy

Copy files from source to dest, skipping identical files.

Synopsis

Copy the source to the destination. Does not transfer files that are identical on source and destination, testing by size and modification time or MD5SUM. Doesn't delete files from the destination. If you want to also delete files from destination, to make it match source, use the sync command instead.

Note that it is always the contents of the directory that is synced, not the directory itself. So when source:path is a directory, it's the contents of source:path that are copied, not the directory name and contents.

To copy single files, use the copyto command instead.

If dest:path doesn't exist, it is created and the source:path contents go there.

For example

rclone copy source:sourcepath dest:destpath

Let's say there are two files in sourcepath

sourcepath/one.txt
sourcepath/two.txt

This copies them to

destpath/one.txt
destpath/two.txt

Not to

destpath/sourcepath/one.txt
destpath/sourcepath/two.txt

If you are familiar with rsync, rclone always works as if you had written a trailing / - meaning "copy the contents of this directory". This applies to all commands and whether you are talking about the source or destination.

See the --no-traverse option for controlling whether rclone lists the destination directory or not. Supplying this option when copying a small number of files into a large destination can speed transfers up greatly.

For example, if you have many files in /path/to/src but only a few of them change every day, you can copy all the files which have changed recently very efficiently like this:

rclone copy --max-age 24h --no-traverse /path/to/src remote:

Rclone will sync the modification times of files and directories if the backend supports it. If metadata syncing is required then use the --metadata flag.

Note that the modification time and metadata for the root directory will not be synced. See https://github.com/rclone/rclone/issues/7652 for more info.

Note: Use the -P/--progress flag to view real-time transfer statistics.

Note: Use the --dry-run or the --interactive/-i flag to test without copying anything.

Logger Flags

The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different.

The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files.

  • = path means path was found in source and destination and was identical
  • - path means path was missing on the source, so only in the destination
  • + path means path was missing on the destination, so only in the source
  • * path means path was present in source and destination but different.
  • ! path means there was an error reading or hashing the source or dest.

The --dest-after flag writes a list file using the same format flags as lsf (including customizable options for hash, modtime, etc.) Conceptually it is similar to rsync's --itemize-changes, but not identical -- it should output an accurate list of what will be on the destination after the command is finished.

When the --no-traverse flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing.

Note that these logger flags have a few limitations, and certain scenarios are not currently supported:

  • --max-duration / CutoffModeHard
  • --compare-dest / --copy-dest
  • server-side moves of an entire dir at once
  • High-level retries, because there would be duplicates (use --retries 1 to disable)
  • Possibly some unusual error scenarios

Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.)

rclone copy source:path dest:path [flags]

Options

      --absolute                Put a leading / in front of path names
      --combined string         Make a combined report of changes to this file
      --create-empty-src-dirs   Create empty source dirs on destination after copy
      --csv                     Output in CSV format
      --dest-after string       Report all files that exist on the dest post-sync
      --differ string           Report all non-matching files to this file
  -d, --dir-slash               Append a slash to directory names (default true)
      --dirs-only               Only list directories
      --error string            Report all files with errors (hashing or reading) to this file
      --files-only              Only list files (default true)
  -F, --format string           Output format - see lsf help for details (default "p")
      --hash h                  Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5")
  -h, --help                    help for copy
      --match string            Report all matching files to this file
      --missing-on-dst string   Report all files missing from the destination to this file
      --missing-on-src string   Report all files missing from the source to this file
  -s, --separator string        Separator for the items in the format (default ";")
  -t, --timeformat string       Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Copy Options

Flags for anything which can copy a file

      --check-first                                 Do all the checks before starting transfers
  -c, --checksum                                    Check for changes with size & checksum (if available, or fallback to size only)
      --compare-dest stringArray                    Include additional server-side paths during comparison
      --copy-dest stringArray                       Implies --compare-dest but also copies files from paths into destination
      --cutoff-mode HARD|SOFT|CAUTIOUS              Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD)
      --ignore-case-sync                            Ignore case when synchronizing
      --ignore-checksum                             Skip post copy check of checksums
      --ignore-existing                             Skip all files that exist on destination
      --ignore-size                                 Ignore size when skipping use modtime or checksum
  -I, --ignore-times                                Don't skip items that match size and time - transfer all unconditionally
      --immutable                                   Do not modify files, fail if existing files have been modified
      --inplace                                     Download directly to destination file instead of atomic download to temp/rename
  -l, --links                                       Translate symlinks to/from regular files with a '.rclonelink' extension
      --max-backlog int                             Maximum number of objects in sync or check backlog (default 10000)
      --max-duration Duration                       Maximum duration rclone will transfer data for (default 0s)
      --max-transfer SizeSuffix                     Maximum size of data to transfer (default off)
  -M, --metadata                                    If set, preserve metadata when copying objects
      --modify-window Duration                      Max time diff to be considered the same (default 1ns)
      --multi-thread-chunk-size SizeSuffix          Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi)
      --multi-thread-cutoff SizeSuffix              Use multi-thread downloads for files above this size (default 256Mi)
      --multi-thread-streams int                    Number of streams to use for multi-thread downloads (default 4)
      --multi-thread-write-buffer-size SizeSuffix   In memory buffer size for writing when in multi-thread mode (default 128Ki)
      --name-transform stringArray                  Transform paths during the copy process
      --no-check-dest                               Don't check the destination, copy regardless
      --no-traverse                                 Don't traverse destination file system on copy
      --no-update-dir-modtime                       Don't update directory modification times
      --no-update-modtime                           Don't update destination modtime if files identical
      --order-by string                             Instructions on how to order the transfers, e.g. 'size,descending'
      --partial-suffix string                       Add partial-suffix to temporary file name when --inplace is not used (default ".partial")
      --refresh-times                               Refresh the modtime of remote files
      --server-side-across-configs                  Allow server-side operations (e.g. copy) to work across different configs
      --size-only                                   Skip based on size only, not modtime or checksum
      --streaming-upload-cutoff SizeSuffix          Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki)
  -u, --update                                      Skip files that are newer on the destination

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone sync

Make source and dest identical, modifying destination only.

Synopsis

Sync the source to the destination, changing the destination only. Doesn't transfer files that are identical on source and destination, testing by size and modification time or MD5SUM. Destination is updated to match source, including deleting files if necessary (except duplicate objects, see below). If you don't want to delete files from destination, use the copy command instead.

Important: Since this can cause data loss, test first with the --dry-run or the --interactive/i flag.

rclone sync --interactive SOURCE remote:DESTINATION

Files in the destination won't be deleted if there were any errors at any point. Duplicate objects (files with the same name, on those providers that support it) are not yet handled. Files that are excluded won't be deleted unless --delete-excluded is used. Symlinks won't be transferred or deleted from local file systems unless --links is used.

It is always the contents of the directory that is synced, not the directory itself. So when source:path is a directory, it's the contents of source:path that are copied, not the directory name and contents. See extended explanation in the copy command if unsure.

If dest:path doesn't exist, it is created and the source:path contents go there.

It is not possible to sync overlapping remotes. However, you may exclude the destination from the sync with a filter rule or by putting an exclude-if-present file inside the destination directory and sync to a destination that is inside the source directory.

Rclone will sync the modification times of files and directories if the backend supports it. If metadata syncing is required then use the --metadata flag.

Note that the modification time and metadata for the root directory will not be synced. See https://github.com/rclone/rclone/issues/7652 for more info.

Note: Use the -P/--progress flag to view real-time transfer statistics

Note: Use the rclone dedupe command to deal with "Duplicate object/directory found in source/destination - ignoring" errors. See this forum post for more info.

Logger Flags

The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different.

The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files.

  • = path means path was found in source and destination and was identical
  • - path means path was missing on the source, so only in the destination
  • + path means path was missing on the destination, so only in the source
  • * path means path was present in source and destination but different.
  • ! path means there was an error reading or hashing the source or dest.

The --dest-after flag writes a list file using the same format flags as lsf (including customizable options for hash, modtime, etc.) Conceptually it is similar to rsync's --itemize-changes, but not identical -- it should output an accurate list of what will be on the destination after the command is finished.

When the --no-traverse flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing.

Note that these logger flags have a few limitations, and certain scenarios are not currently supported:

  • --max-duration / CutoffModeHard
  • --compare-dest / --copy-dest
  • server-side moves of an entire dir at once
  • High-level retries, because there would be duplicates (use --retries 1 to disable)
  • Possibly some unusual error scenarios

Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.)

rclone sync source:path dest:path [flags]

Options

      --absolute                Put a leading / in front of path names
      --combined string         Make a combined report of changes to this file
      --create-empty-src-dirs   Create empty source dirs on destination after sync
      --csv                     Output in CSV format
      --dest-after string       Report all files that exist on the dest post-sync
      --differ string           Report all non-matching files to this file
  -d, --dir-slash               Append a slash to directory names (default true)
      --dirs-only               Only list directories
      --error string            Report all files with errors (hashing or reading) to this file
      --files-only              Only list files (default true)
  -F, --format string           Output format - see lsf help for details (default "p")
      --hash h                  Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5")
  -h, --help                    help for sync
      --match string            Report all matching files to this file
      --missing-on-dst string   Report all files missing from the destination to this file
      --missing-on-src string   Report all files missing from the source to this file
  -s, --separator string        Separator for the items in the format (default ";")
  -t, --timeformat string       Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Copy Options

Flags for anything which can copy a file

      --check-first                                 Do all the checks before starting transfers
  -c, --checksum                                    Check for changes with size & checksum (if available, or fallback to size only)
      --compare-dest stringArray                    Include additional server-side paths during comparison
      --copy-dest stringArray                       Implies --compare-dest but also copies files from paths into destination
      --cutoff-mode HARD|SOFT|CAUTIOUS              Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD)
      --ignore-case-sync                            Ignore case when synchronizing
      --ignore-checksum                             Skip post copy check of checksums
      --ignore-existing                             Skip all files that exist on destination
      --ignore-size                                 Ignore size when skipping use modtime or checksum
  -I, --ignore-times                                Don't skip items that match size and time - transfer all unconditionally
      --immutable                                   Do not modify files, fail if existing files have been modified
      --inplace                                     Download directly to destination file instead of atomic download to temp/rename
  -l, --links                                       Translate symlinks to/from regular files with a '.rclonelink' extension
      --max-backlog int                             Maximum number of objects in sync or check backlog (default 10000)
      --max-duration Duration                       Maximum duration rclone will transfer data for (default 0s)
      --max-transfer SizeSuffix                     Maximum size of data to transfer (default off)
  -M, --metadata                                    If set, preserve metadata when copying objects
      --modify-window Duration                      Max time diff to be considered the same (default 1ns)
      --multi-thread-chunk-size SizeSuffix          Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi)
      --multi-thread-cutoff SizeSuffix              Use multi-thread downloads for files above this size (default 256Mi)
      --multi-thread-streams int                    Number of streams to use for multi-thread downloads (default 4)
      --multi-thread-write-buffer-size SizeSuffix   In memory buffer size for writing when in multi-thread mode (default 128Ki)
      --name-transform stringArray                  Transform paths during the copy process
      --no-check-dest                               Don't check the destination, copy regardless
      --no-traverse                                 Don't traverse destination file system on copy
      --no-update-dir-modtime                       Don't update directory modification times
      --no-update-modtime                           Don't update destination modtime if files identical
      --order-by string                             Instructions on how to order the transfers, e.g. 'size,descending'
      --partial-suffix string                       Add partial-suffix to temporary file name when --inplace is not used (default ".partial")
      --refresh-times                               Refresh the modtime of remote files
      --server-side-across-configs                  Allow server-side operations (e.g. copy) to work across different configs
      --size-only                                   Skip based on size only, not modtime or checksum
      --streaming-upload-cutoff SizeSuffix          Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki)
  -u, --update                                      Skip files that are newer on the destination

Sync Options

Flags used for sync commands

      --backup-dir string               Make backups into hierarchy based in DIR
      --delete-after                    When synchronizing, delete files on destination after transferring (default)
      --delete-before                   When synchronizing, delete files on destination before transferring
      --delete-during                   When synchronizing, delete files during transfer
      --fix-case                        Force rename of case insensitive dest to match source
      --ignore-errors                   Delete even if there are I/O errors
      --list-cutoff int                 To save memory, sort directory listings on disk above this threshold (default 1000000)
      --max-delete int                  When synchronizing, limit the number of deletes (default -1)
      --max-delete-size SizeSuffix      When synchronizing, limit the total size of deletes (default off)
      --suffix string                   Suffix to add to changed files
      --suffix-keep-extension           Preserve the extension when using --suffix
      --track-renames                   When synchronizing, track file renames and do a server-side move if possible
      --track-renames-strategy string   Strategies to use when synchronizing using track-renames hash|modtime|leaf (default "hash")

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone move

Move files from source to dest.

Synopsis

Moves the contents of the source directory to the destination directory. Rclone will error if the source and destination overlap and the remote does not support a server-side directory move operation.

To move single files, use the moveto command instead.

If no filters are in use and if possible this will server-side move source:path into dest:path. After this source:path will no longer exist.

Otherwise for each file in source:path selected by the filters (if any) this will move it into dest:path. If possible a server-side move will be used, otherwise it will copy it (server-side if possible) into dest:path then delete the original (if no errors on copy) in source:path.

If you want to delete empty source directories after move, use the --delete-empty-src-dirs flag.

See the --no-traverse option for controlling whether rclone lists the destination directory or not. Supplying this option when moving a small number of files into a large destination can speed transfers up greatly.

Rclone will sync the modification times of files and directories if the backend supports it. If metadata syncing is required then use the --metadata flag.

Note that the modification time and metadata for the root directory will not be synced. See https://github.com/rclone/rclone/issues/7652 for more info.

Important: Since this can cause data loss, test first with the --dry-run or the --interactive/-i flag.

Note: Use the -P/--progress flag to view real-time transfer statistics.

Logger Flags

The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different.

The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files.

  • = path means path was found in source and destination and was identical
  • - path means path was missing on the source, so only in the destination
  • + path means path was missing on the destination, so only in the source
  • * path means path was present in source and destination but different.
  • ! path means there was an error reading or hashing the source or dest.

The --dest-after flag writes a list file using the same format flags as lsf (including customizable options for hash, modtime, etc.) Conceptually it is similar to rsync's --itemize-changes, but not identical -- it should output an accurate list of what will be on the destination after the command is finished.

When the --no-traverse flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing.

Note that these logger flags have a few limitations, and certain scenarios are not currently supported:

  • --max-duration / CutoffModeHard
  • --compare-dest / --copy-dest
  • server-side moves of an entire dir at once
  • High-level retries, because there would be duplicates (use --retries 1 to disable)
  • Possibly some unusual error scenarios

Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.)

rclone move source:path dest:path [flags]

Options

      --absolute                Put a leading / in front of path names
      --combined string         Make a combined report of changes to this file
      --create-empty-src-dirs   Create empty source dirs on destination after move
      --csv                     Output in CSV format
      --delete-empty-src-dirs   Delete empty source dirs after move
      --dest-after string       Report all files that exist on the dest post-sync
      --differ string           Report all non-matching files to this file
  -d, --dir-slash               Append a slash to directory names (default true)
      --dirs-only               Only list directories
      --error string            Report all files with errors (hashing or reading) to this file
      --files-only              Only list files (default true)
  -F, --format string           Output format - see lsf help for details (default "p")
      --hash h                  Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5")
  -h, --help                    help for move
      --match string            Report all matching files to this file
      --missing-on-dst string   Report all files missing from the destination to this file
      --missing-on-src string   Report all files missing from the source to this file
  -s, --separator string        Separator for the items in the format (default ";")
  -t, --timeformat string       Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Copy Options

Flags for anything which can copy a file

      --check-first                                 Do all the checks before starting transfers
  -c, --checksum                                    Check for changes with size & checksum (if available, or fallback to size only)
      --compare-dest stringArray                    Include additional server-side paths during comparison
      --copy-dest stringArray                       Implies --compare-dest but also copies files from paths into destination
      --cutoff-mode HARD|SOFT|CAUTIOUS              Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD)
      --ignore-case-sync                            Ignore case when synchronizing
      --ignore-checksum                             Skip post copy check of checksums
      --ignore-existing                             Skip all files that exist on destination
      --ignore-size                                 Ignore size when skipping use modtime or checksum
  -I, --ignore-times                                Don't skip items that match size and time - transfer all unconditionally
      --immutable                                   Do not modify files, fail if existing files have been modified
      --inplace                                     Download directly to destination file instead of atomic download to temp/rename
  -l, --links                                       Translate symlinks to/from regular files with a '.rclonelink' extension
      --max-backlog int                             Maximum number of objects in sync or check backlog (default 10000)
      --max-duration Duration                       Maximum duration rclone will transfer data for (default 0s)
      --max-transfer SizeSuffix                     Maximum size of data to transfer (default off)
  -M, --metadata                                    If set, preserve metadata when copying objects
      --modify-window Duration                      Max time diff to be considered the same (default 1ns)
      --multi-thread-chunk-size SizeSuffix          Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi)
      --multi-thread-cutoff SizeSuffix              Use multi-thread downloads for files above this size (default 256Mi)
      --multi-thread-streams int                    Number of streams to use for multi-thread downloads (default 4)
      --multi-thread-write-buffer-size SizeSuffix   In memory buffer size for writing when in multi-thread mode (default 128Ki)
      --name-transform stringArray                  Transform paths during the copy process
      --no-check-dest                               Don't check the destination, copy regardless
      --no-traverse                                 Don't traverse destination file system on copy
      --no-update-dir-modtime                       Don't update directory modification times
      --no-update-modtime                           Don't update destination modtime if files identical
      --order-by string                             Instructions on how to order the transfers, e.g. 'size,descending'
      --partial-suffix string                       Add partial-suffix to temporary file name when --inplace is not used (default ".partial")
      --refresh-times                               Refresh the modtime of remote files
      --server-side-across-configs                  Allow server-side operations (e.g. copy) to work across different configs
      --size-only                                   Skip based on size only, not modtime or checksum
      --streaming-upload-cutoff SizeSuffix          Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki)
  -u, --update                                      Skip files that are newer on the destination

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone delete

Remove the files in path.

Synopsis

Remove the files in path. Unlike purge it obeys include/exclude filters so can be used to selectively delete files.

rclone delete only deletes files but leaves the directory structure alone. If you want to delete a directory and all of its contents use the purge command.

If you supply the --rmdirs flag, it will remove all empty directories along with it. You can also use the separate command rmdir or rmdirs to delete empty directories only.

For example, to delete all files bigger than 100 MiB, you may first want to check what would be deleted (use either):

rclone --min-size 100M lsl remote:path
rclone --dry-run --min-size 100M delete remote:path

Then proceed with the actual delete:

rclone --min-size 100M delete remote:path

That reads "delete everything with a minimum size of 100 MiB", hence delete all files bigger than 100 MiB.

Important: Since this can cause data loss, test first with the --dry-run or the --interactive/-i flag.

rclone delete remote:path [flags]

Options

  -h, --help     help for delete
      --rmdirs   rmdirs removes empty directories but leaves root intact

Options shared with other commands are described next. See the global flags page for global options not listed here.

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone purge

Remove the path and all of its contents.

Synopsis

Remove the path and all of its contents. Note that this does not obey include/exclude filters - everything will be removed. Use the delete command if you want to selectively delete files. To delete empty directories only, use command rmdir or rmdirs.

The concurrency of this operation is controlled by the --checkers global flag. However, some backends will implement this command directly, in which case --checkers will be ignored.

Important: Since this can cause data loss, test first with the --dry-run or the --interactive/-i flag.

rclone purge remote:path [flags]

Options

  -h, --help   help for purge

Options shared with other commands are described next. See the global flags page for global options not listed here.

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone mkdir

Make the path if it doesn't already exist.

rclone mkdir remote:path [flags]

Options

  -h, --help   help for mkdir

Options shared with other commands are described next. See the global flags page for global options not listed here.

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone rmdir

Remove the empty directory at path.

Synopsis

This removes empty directory given by path. Will not remove the path if it has any objects in it, not even empty subdirectories. Use command rmdirs (or delete with option --rmdirs) to do that.

To delete a path and any objects in it, use purge command.

rclone rmdir remote:path [flags]

Options

  -h, --help   help for rmdir

Options shared with other commands are described next. See the global flags page for global options not listed here.

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone check

Checks the files in the source and destination match.

Synopsis

Checks the files in the source and destination match. It compares sizes and hashes (MD5 or SHA1) and logs a report of files that don't match. It doesn't alter the source or destination.

For the crypt remote there is a dedicated command, cryptcheck, that are able to check the checksums of the encrypted files.

If you supply the --size-only flag, it will only compare the sizes not the hashes as well. Use this for a quick check.

If you supply the --download flag, it will download the data from both remotes and check them against each other on the fly. This can be useful for remotes that don't support hashes or if you really want to check all the data.

If you supply the --checkfile HASH flag with a valid hash name, the source:path must point to a text file in the SUM format.

If you supply the --one-way flag, it will only check that files in the source match the files in the destination, not the other way around. This means that extra files in the destination that are not in the source will not be detected.

The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different.

The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files.

  • = path means path was found in source and destination and was identical
  • - path means path was missing on the source, so only in the destination
  • + path means path was missing on the destination, so only in the source
  • * path means path was present in source and destination but different.
  • ! path means there was an error reading or hashing the source or dest.

The default number of parallel checks is 8. See the --checkers option for more information.

rclone check source:path dest:path [flags]

Options

  -C, --checkfile string        Treat source:path as a SUM file with hashes of given type
      --combined string         Make a combined report of changes to this file
      --differ string           Report all non-matching files to this file
      --download                Check by downloading rather than with hash
      --error string            Report all files with errors (hashing or reading) to this file
  -h, --help                    help for check
      --match string            Report all matching files to this file
      --missing-on-dst string   Report all files missing from the destination to this file
      --missing-on-src string   Report all files missing from the source to this file
      --one-way                 Check one way only, source files must exist on remote

Options shared with other commands are described next. See the global flags page for global options not listed here.

Check Options

Flags used for check commands

      --max-backlog int   Maximum number of objects in sync or check backlog (default 10000)

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone ls

List the objects in the path with size and path.

Synopsis

Lists the objects in the source path to standard output in a human readable format with size and path. Recurses by default.

Eg

$ rclone ls swift:bucket
    60295 bevajer5jef
    90613 canole
    94467 diwogej7
    37600 fubuwic

Any of the filtering options can be applied to this command.

There are several related list commands

  • ls to list size and path of objects only
  • lsl to list modification time, size and path of objects only
  • lsd to list directories only
  • lsf to list objects and directories in easy to parse format
  • lsjson to list objects and directories in JSON format

ls,lsl,lsd are designed to be human-readable. lsf is designed to be human and machine-readable. lsjson is designed to be machine-readable.

Note that ls and lsl recurse by default - use --max-depth 1 to stop the recursion.

The other list commands lsd,lsf,lsjson do not recurse by default - use -R to make them recurse.

Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes).

rclone ls remote:path [flags]

Options

  -h, --help   help for ls

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone lsd

List all directories/containers/buckets in the path.

Synopsis

Lists the directories in the source path to standard output. Does not recurse by default. Use the -R flag to recurse.

This command lists the total size of the directory (if known, -1 if not), the modification time (if known, the current time if not), the number of objects in the directory (if known, -1 if not) and the name of the directory, Eg

$ rclone lsd swift:
      494000 2018-04-26 08:43:20     10000 10000files
          65 2018-04-26 08:43:20         1 1File

Or

$ rclone lsd drive:test
          -1 2016-10-17 17:41:53        -1 1000files
          -1 2017-01-03 14:40:54        -1 2500files
          -1 2017-07-08 14:39:28        -1 4000files

If you just want the directory names use rclone lsf --dirs-only.

Any of the filtering options can be applied to this command.

There are several related list commands

  • ls to list size and path of objects only
  • lsl to list modification time, size and path of objects only
  • lsd to list directories only
  • lsf to list objects and directories in easy to parse format
  • lsjson to list objects and directories in JSON format

ls,lsl,lsd are designed to be human-readable. lsf is designed to be human and machine-readable. lsjson is designed to be machine-readable.

Note that ls and lsl recurse by default - use --max-depth 1 to stop the recursion.

The other list commands lsd,lsf,lsjson do not recurse by default - use -R to make them recurse.

Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes).

rclone lsd remote:path [flags]

Options

  -h, --help        help for lsd
  -R, --recursive   Recurse into the listing

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone lsl

List the objects in path with modification time, size and path.

Synopsis

Lists the objects in the source path to standard output in a human readable format with modification time, size and path. Recurses by default.

Eg

$ rclone lsl swift:bucket
    60295 2016-06-25 18:55:41.062626927 bevajer5jef
    90613 2016-06-25 18:55:43.302607074 canole
    94467 2016-06-25 18:55:43.046609333 diwogej7
    37600 2016-06-25 18:55:40.814629136 fubuwic

Any of the filtering options can be applied to this command.

There are several related list commands

  • ls to list size and path of objects only
  • lsl to list modification time, size and path of objects only
  • lsd to list directories only
  • lsf to list objects and directories in easy to parse format
  • lsjson to list objects and directories in JSON format

ls,lsl,lsd are designed to be human-readable. lsf is designed to be human and machine-readable. lsjson is designed to be machine-readable.

Note that ls and lsl recurse by default - use --max-depth 1 to stop the recursion.

The other list commands lsd,lsf,lsjson do not recurse by default - use -R to make them recurse.

Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes).

rclone lsl remote:path [flags]

Options

  -h, --help   help for lsl

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone md5sum

Produces an md5sum file for all the objects in the path.

Synopsis

Produces an md5sum file for all the objects in the path. This is in the same format as the standard md5sum tool produces.

By default, the hash is requested from the remote. If MD5 is not supported by the remote, no hash will be returned. With the download flag, the file will be downloaded from the remote and hashed locally enabling MD5 for any remote.

For other algorithms, see the hashsum command. Running rclone md5sum remote:path is equivalent to running rclone hashsum MD5 remote:path.

This command can also hash data received on standard input (stdin), by not passing a remote:path, or by passing a hyphen as remote:path when there is data to read (if not, the hyphen will be treated literally, as a relative path).

rclone md5sum remote:path [flags]

Options

      --base64               Output base64 encoded hashsum
  -C, --checkfile string     Validate hashes against a given SUM file instead of printing them
      --download             Download the file and hash it locally; if this flag is not specified, the hash is requested from the remote
  -h, --help                 help for md5sum
      --output-file string   Output hashsums to a file rather than the terminal

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone sha1sum

Produces an sha1sum file for all the objects in the path.

Synopsis

Produces an sha1sum file for all the objects in the path. This is in the same format as the standard sha1sum tool produces.

By default, the hash is requested from the remote. If SHA-1 is not supported by the remote, no hash will be returned. With the download flag, the file will be downloaded from the remote and hashed locally enabling SHA-1 for any remote.

For other algorithms, see the hashsum command. Running rclone sha1sum remote:path is equivalent to running rclone hashsum SHA1 remote:path.

This command can also hash data received on standard input (stdin), by not passing a remote:path, or by passing a hyphen as remote:path when there is data to read (if not, the hyphen will be treated literally, as a relative path).

This command can also hash data received on STDIN, if not passing a remote:path.

rclone sha1sum remote:path [flags]

Options

      --base64               Output base64 encoded hashsum
  -C, --checkfile string     Validate hashes against a given SUM file instead of printing them
      --download             Download the file and hash it locally; if this flag is not specified, the hash is requested from the remote
  -h, --help                 help for sha1sum
      --output-file string   Output hashsums to a file rather than the terminal

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone size

Prints the total size and number of objects in remote:path.

Synopsis

Counts objects in the path and calculates the total size. Prints the result to standard output.

By default the output is in human-readable format, but shows values in both human-readable format as well as the raw numbers (global option --human-readable is not considered). Use option --json to format output as JSON instead.

Recurses by default, use --max-depth 1 to stop the recursion.

Some backends do not always provide file sizes, see for example Google Photos and Google Docs. Rclone will then show a notice in the log indicating how many such files were encountered, and count them in as empty files in the output of the size command.

rclone size remote:path [flags]

Options

  -h, --help   help for size
      --json   Format output as JSON

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone version

Show the version number.

Synopsis

Show the rclone version number, the go version, the build target OS and architecture, the runtime OS and kernel version and bitness, build tags and the type of executable (static or dynamic).

For example:

$ rclone version
rclone v1.55.0
- os/version: ubuntu 18.04 (64 bit)
- os/kernel: 4.15.0-136-generic (x86_64)
- os/type: linux
- os/arch: amd64
- go/version: go1.16
- go/linking: static
- go/tags: none

Note: before rclone version 1.55 the os/type and os/arch lines were merged, and the "go/version" line was tagged as "go version".

If you supply the --check flag, then it will do an online check to compare your version with the latest release and the latest beta.

$ rclone version --check
yours:  1.42.0.6
latest: 1.42          (released 2018-06-16)
beta:   1.42.0.5      (released 2018-06-17)

Or

$ rclone version --check
yours:  1.41
latest: 1.42          (released 2018-06-16)
  upgrade: https://downloads.rclone.org/v1.42
beta:   1.42.0.5      (released 2018-06-17)
  upgrade: https://beta.rclone.org/v1.42-005-g56e1e820

If you supply the --deps flag then rclone will print a list of all the packages it depends on and their versions along with some other information about the build.

rclone version [flags]

Options

      --check   Check for new version
      --deps    Show the Go dependencies
  -h, --help    help for version

See the global flags page for global options not listed here.

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone cleanup

Clean up the remote if possible.

Synopsis

Clean up the remote if possible. Empty the trash or delete old file versions. Not supported by all remotes.

rclone cleanup remote:path [flags]

Options

  -h, --help   help for cleanup

Options shared with other commands are described next. See the global flags page for global options not listed here.

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone dedupe

Interactively find duplicate filenames and delete/rename them.

Synopsis

By default dedupe interactively finds files with duplicate names and offers to delete all but one or rename them to be different. This is known as deduping by name.

Deduping by name is only useful with a small group of backends (e.g. Google Drive, Opendrive) that can have duplicate file names. It can be run on wrapping backends (e.g. crypt) if they wrap a backend which supports duplicate file names.

However if --by-hash is passed in then dedupe will find files with duplicate hashes instead which will work on any backend which supports at least one hash. This can be used to find files with duplicate content. This is known as deduping by hash.

If deduping by name, first rclone will merge directories with the same name. It will do this iteratively until all the identically named directories have been merged.

Next, if deduping by name, for every group of duplicate file names / hashes, it will delete all but one identical file it finds without confirmation. This means that for most duplicated files the dedupe command will not be interactive.

dedupe considers files to be identical if they have the same file path and the same hash. If the backend does not support hashes (e.g. crypt wrapping Google Drive) then they will never be found to be identical. If you use the --size-only flag then files will be considered identical if they have the same size (any hash will be ignored). This can be useful on crypt backends which do not support hashes.

Next rclone will resolve the remaining duplicates. Exactly which action is taken depends on the dedupe mode. By default, rclone will interactively query the user for each one.

Important: Since this can cause data loss, test first with the --dry-run or the --interactive/-i flag.

Here is an example run.

Before - with duplicates

$ rclone lsl drive:dupes
  6048320 2016-03-05 16:23:16.798000000 one.txt
  6048320 2016-03-05 16:23:11.775000000 one.txt
   564374 2016-03-05 16:23:06.731000000 one.txt
  6048320 2016-03-05 16:18:26.092000000 one.txt
  6048320 2016-03-05 16:22:46.185000000 two.txt
  1744073 2016-03-05 16:22:38.104000000 two.txt
   564374 2016-03-05 16:22:52.118000000 two.txt

Now the dedupe session

$ rclone dedupe drive:dupes
2016/03/05 16:24:37 Google drive root 'dupes': Looking for duplicates using interactive mode.
one.txt: Found 4 files with duplicate names
one.txt: Deleting 2/3 identical duplicates (MD5 "1eedaa9fe86fd4b8632e2ac549403b36")
one.txt: 2 duplicates remain
  1:      6048320 bytes, 2016-03-05 16:23:16.798000000, MD5 1eedaa9fe86fd4b8632e2ac549403b36
  2:       564374 bytes, 2016-03-05 16:23:06.731000000, MD5 7594e7dc9fc28f727c42ee3e0749de81
s) Skip and do nothing
k) Keep just one (choose which in next step)
r) Rename all to be different (by changing file.jpg to file-1.jpg)
s/k/r> k
Enter the number of the file to keep> 1
one.txt: Deleted 1 extra copies
two.txt: Found 3 files with duplicate names
two.txt: 3 duplicates remain
  1:       564374 bytes, 2016-03-05 16:22:52.118000000, MD5 7594e7dc9fc28f727c42ee3e0749de81
  2:      6048320 bytes, 2016-03-05 16:22:46.185000000, MD5 1eedaa9fe86fd4b8632e2ac549403b36
  3:      1744073 bytes, 2016-03-05 16:22:38.104000000, MD5 851957f7fb6f0bc4ce76be966d336802
s) Skip and do nothing
k) Keep just one (choose which in next step)
r) Rename all to be different (by changing file.jpg to file-1.jpg)
s/k/r> r
two-1.txt: renamed from: two.txt
two-2.txt: renamed from: two.txt
two-3.txt: renamed from: two.txt

The result being

$ rclone lsl drive:dupes
  6048320 2016-03-05 16:23:16.798000000 one.txt
   564374 2016-03-05 16:22:52.118000000 two-1.txt
  6048320 2016-03-05 16:22:46.185000000 two-2.txt
  1744073 2016-03-05 16:22:38.104000000 two-3.txt

Dedupe can be run non interactively using the --dedupe-mode flag or by using an extra parameter with the same value

  • --dedupe-mode interactive - interactive as above.
  • --dedupe-mode skip - removes identical files then skips anything left.
  • --dedupe-mode first - removes identical files then keeps the first one.
  • --dedupe-mode newest - removes identical files then keeps the newest one.
  • --dedupe-mode oldest - removes identical files then keeps the oldest one.
  • --dedupe-mode largest - removes identical files then keeps the largest one.
  • --dedupe-mode smallest - removes identical files then keeps the smallest one.
  • --dedupe-mode rename - removes identical files then renames the rest to be different.
  • --dedupe-mode list - lists duplicate dirs and files only and changes nothing.

For example, to rename all the identically named photos in your Google Photos directory, do

rclone dedupe --dedupe-mode rename "drive:Google Photos"

Or

rclone dedupe rename "drive:Google Photos"
rclone dedupe [mode] remote:path [flags]

Options

      --by-hash              Find identical hashes rather than names
      --dedupe-mode string   Dedupe mode interactive|skip|first|newest|oldest|largest|smallest|rename (default "interactive")
  -h, --help                 help for dedupe

Options shared with other commands are described next. See the global flags page for global options not listed here.

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone about

Get quota information from the remote.

Synopsis

Prints quota information about a remote to standard output. The output is typically used, free, quota and trash contents.

E.g. Typical output from rclone about remote: is:

Total:   17 GiB
Used:    7.444 GiB
Free:    1.315 GiB
Trashed: 100.000 MiB
Other:   8.241 GiB

Where the fields are:

  • Total: Total size available.
  • Used: Total size used.
  • Free: Total space available to this user.
  • Trashed: Total space used by trash.
  • Other: Total amount in other storage (e.g. Gmail, Google Photos).
  • Objects: Total number of objects in the storage.

All sizes are in number of bytes.

Applying a --full flag to the command prints the bytes in full, e.g.

Total:   18253611008
Used:    7993453766
Free:    1411001220
Trashed: 104857602
Other:   8849156022

A --json flag generates conveniently machine-readable output, e.g.

{
    "total": 18253611008,
    "used": 7993453766,
    "trashed": 104857602,
    "other": 8849156022,
    "free": 1411001220
}

Not all backends print all fields. Information is not included if it is not provided by a backend. Where the value is unlimited it is omitted.

Some backends does not support the rclone about command at all, see complete list in documentation.

rclone about remote: [flags]

Options

      --full   Full numbers instead of human-readable
  -h, --help   help for about
      --json   Format output as JSON

See the global flags page for global options not listed here.

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone authorize

Remote authorization.

Synopsis

Remote authorization. Used to authorize a remote or headless rclone from a machine with a browser - use as instructed by rclone config.

The command requires 1-3 arguments: - fs name (e.g., "drive", "s3", etc.) - Either a base64 encoded JSON blob obtained from a previous rclone config session - Or a client_id and client_secret pair obtained from the remote service

Use --auth-no-open-browser to prevent rclone to open auth link in default browser automatically.

Use --template to generate HTML output via a custom Go template. If a blank string is provided as an argument to this flag, the default template is used.

rclone authorize <fs name> [base64_json_blob | client_id client_secret] [flags]

Options

      --auth-no-open-browser   Do not automatically open auth link in default browser
  -h, --help                   help for authorize
      --template string        The path to a custom Go template for generating HTML responses

See the global flags page for global options not listed here.

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone backend

Run a backend-specific command.

Synopsis

This runs a backend-specific command. The commands themselves (except for "help" and "features") are defined by the backends and you should see the backend docs for definitions.

You can discover what commands a backend implements by using

rclone backend help remote:
rclone backend help <backendname>

You can also discover information about the backend using (see operations/fsinfo in the remote control docs for more info).

rclone backend features remote:

Pass options to the backend command with -o. This should be key=value or key, e.g.:

rclone backend stats remote:path stats -o format=json -o long

Pass arguments to the backend by placing them on the end of the line

rclone backend cleanup remote:path file1 file2 file3

Note to run these commands on a running backend then see backend/command in the rc docs.

rclone backend <command> remote:path [opts] <args> [flags]

Options

  -h, --help                 help for backend
      --json                 Always output in JSON format
  -o, --option stringArray   Option in the form name=value or name

Options shared with other commands are described next. See the global flags page for global options not listed here.

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone bisync

Perform bidirectional synchronization between two paths.

Synopsis

Perform bidirectional synchronization between two paths.

Bisync provides a bidirectional cloud sync solution in rclone. It retains the Path1 and Path2 filesystem listings from the prior run. On each successive run it will: - list files on Path1 and Path2, and check for changes on each side. Changes include New, Newer, Older, and Deleted files. - Propagate changes on Path1 to Path2, and vice-versa.

Bisync is considered an advanced command, so use with care. Make sure you have read and understood the entire manual (especially the Limitations section) before using, or data loss can result. Questions can be asked in the Rclone Forum.

See full bisync description for details.

rclone bisync remote1:path1 remote2:path2 [flags]

Options

      --backup-dir1 string                   --backup-dir for Path1. Must be a non-overlapping path on the same remote.
      --backup-dir2 string                   --backup-dir for Path2. Must be a non-overlapping path on the same remote.
      --check-access                         Ensure expected RCLONE_TEST files are found on both Path1 and Path2 filesystems, else abort.
      --check-filename string                Filename for --check-access (default: RCLONE_TEST)
      --check-sync string                    Controls comparison of final listings: true|false|only (default: true) (default "true")
      --compare string                       Comma-separated list of bisync-specific compare options ex. 'size,modtime,checksum' (default: 'size,modtime')
      --conflict-loser ConflictLoserAction   Action to take on the loser of a sync conflict (when there is a winner) or on both files (when there is no winner): , num, pathname, delete (default: num)
      --conflict-resolve string              Automatically resolve conflicts by preferring the version that is: none, path1, path2, newer, older, larger, smaller (default: none) (default "none")
      --conflict-suffix string               Suffix to use when renaming a --conflict-loser. Can be either one string or two comma-separated strings to assign different suffixes to Path1/Path2. (default: 'conflict')
      --create-empty-src-dirs                Sync creation and deletion of empty directories. (Not compatible with --remove-empty-dirs)
      --download-hash                        Compute hash by downloading when otherwise unavailable. (warning: may be slow and use lots of data!)
      --filters-file string                  Read filtering patterns from a file
      --force                                Bypass --max-delete safety check and run the sync. Consider using with --verbose
  -h, --help                                 help for bisync
      --ignore-listing-checksum              Do not use checksums for listings (add --ignore-checksum to additionally skip post-copy checksum checks)
      --max-lock Duration                    Consider lock files older than this to be expired (default: 0 (never expire)) (minimum: 2m) (default 0s)
      --no-cleanup                           Retain working files (useful for troubleshooting and testing).
      --no-slow-hash                         Ignore listing checksums only on backends where they are slow
      --recover                              Automatically recover from interruptions without requiring --resync.
      --remove-empty-dirs                    Remove ALL empty directories at the final cleanup step.
      --resilient                            Allow future runs to retry after certain less-serious errors, instead of requiring --resync.
  -1, --resync                               Performs the resync run. Equivalent to --resync-mode path1. Consider using --verbose or --dry-run first.
      --resync-mode string                   During resync, prefer the version that is: path1, path2, newer, older, larger, smaller (default: path1 if --resync, otherwise none for no resync.) (default "none")
      --slow-hash-sync-only                  Ignore slow checksums for listings and deltas, but still consider them during sync calls.
      --workdir string                       Use custom working dir - useful for testing. (default: {WORKDIR})

Options shared with other commands are described next. See the global flags page for global options not listed here.

Copy Options

Flags for anything which can copy a file

      --check-first                                 Do all the checks before starting transfers
  -c, --checksum                                    Check for changes with size & checksum (if available, or fallback to size only)
      --compare-dest stringArray                    Include additional server-side paths during comparison
      --copy-dest stringArray                       Implies --compare-dest but also copies files from paths into destination
      --cutoff-mode HARD|SOFT|CAUTIOUS              Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD)
      --ignore-case-sync                            Ignore case when synchronizing
      --ignore-checksum                             Skip post copy check of checksums
      --ignore-existing                             Skip all files that exist on destination
      --ignore-size                                 Ignore size when skipping use modtime or checksum
  -I, --ignore-times                                Don't skip items that match size and time - transfer all unconditionally
      --immutable                                   Do not modify files, fail if existing files have been modified
      --inplace                                     Download directly to destination file instead of atomic download to temp/rename
  -l, --links                                       Translate symlinks to/from regular files with a '.rclonelink' extension
      --max-backlog int                             Maximum number of objects in sync or check backlog (default 10000)
      --max-duration Duration                       Maximum duration rclone will transfer data for (default 0s)
      --max-transfer SizeSuffix                     Maximum size of data to transfer (default off)
  -M, --metadata                                    If set, preserve metadata when copying objects
      --modify-window Duration                      Max time diff to be considered the same (default 1ns)
      --multi-thread-chunk-size SizeSuffix          Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi)
      --multi-thread-cutoff SizeSuffix              Use multi-thread downloads for files above this size (default 256Mi)
      --multi-thread-streams int                    Number of streams to use for multi-thread downloads (default 4)
      --multi-thread-write-buffer-size SizeSuffix   In memory buffer size for writing when in multi-thread mode (default 128Ki)
      --name-transform stringArray                  Transform paths during the copy process
      --no-check-dest                               Don't check the destination, copy regardless
      --no-traverse                                 Don't traverse destination file system on copy
      --no-update-dir-modtime                       Don't update directory modification times
      --no-update-modtime                           Don't update destination modtime if files identical
      --order-by string                             Instructions on how to order the transfers, e.g. 'size,descending'
      --partial-suffix string                       Add partial-suffix to temporary file name when --inplace is not used (default ".partial")
      --refresh-times                               Refresh the modtime of remote files
      --server-side-across-configs                  Allow server-side operations (e.g. copy) to work across different configs
      --size-only                                   Skip based on size only, not modtime or checksum
      --streaming-upload-cutoff SizeSuffix          Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki)
  -u, --update                                      Skip files that are newer on the destination

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone cat

Concatenates any files and sends them to stdout.

Synopsis

Sends any files to standard output.

You can use it like this to output a single file

rclone cat remote:path/to/file

Or like this to output any file in dir or its subdirectories.

rclone cat remote:path/to/dir

Or like this to output any .txt files in dir or its subdirectories.

rclone --include "*.txt" cat remote:path/to/dir

Use the --head flag to print characters only at the start, --tail for the end and --offset and --count to print a section in the middle. Note that if offset is negative it will count from the end, so --offset -1 --count 1 is equivalent to --tail 1.

Use the --separator flag to print a separator value between files. Be sure to shell-escape special characters. For example, to print a newline between files, use:

  • bash:

    rclone --include "*.txt" --separator $'\n' cat remote:path/to/dir

  • powershell:

    rclone --include "*.txt" --separator "`n" cat remote:path/to/dir
rclone cat remote:path [flags]

Options

      --count int          Only print N characters (default -1)
      --discard            Discard the output instead of printing
      --head int           Only print the first N characters
  -h, --help               help for cat
      --offset int         Start printing at offset N (or from end if -ve)
      --separator string   Separator to use between objects when printing multiple files
      --tail int           Only print the last N characters

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone checksum

Checks the files in the destination against a SUM file.

Synopsis

Checks that hashsums of destination files match the SUM file. It compares hashes (MD5, SHA1, etc) and logs a report of files which don't match. It doesn't alter the file system.

The sumfile is treated as the source and the dst:path is treated as the destination for the purposes of the output.

If you supply the --download flag, it will download the data from the remote and calculate the content hash on the fly. This can be useful for remotes that don't support hashes or if you really want to check all the data.

Note that hash values in the SUM file are treated as case insensitive.

If you supply the --one-way flag, it will only check that files in the source match the files in the destination, not the other way around. This means that extra files in the destination that are not in the source will not be detected.

The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different.

The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files.

  • = path means path was found in source and destination and was identical
  • - path means path was missing on the source, so only in the destination
  • + path means path was missing on the destination, so only in the source
  • * path means path was present in source and destination but different.
  • ! path means there was an error reading or hashing the source or dest.

The default number of parallel checks is 8. See the --checkers option for more information.

rclone checksum <hash> sumfile dst:path [flags]

Options

      --combined string         Make a combined report of changes to this file
      --differ string           Report all non-matching files to this file
      --download                Check by hashing the contents
      --error string            Report all files with errors (hashing or reading) to this file
  -h, --help                    help for checksum
      --match string            Report all matching files to this file
      --missing-on-dst string   Report all files missing from the destination to this file
      --missing-on-src string   Report all files missing from the source to this file
      --one-way                 Check one way only, source files must exist on remote

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone completion

Output completion script for a given shell.

Synopsis

Generates a shell completion script for rclone. Run with --help to list the supported shells.

Options

  -h, --help   help for completion

See the global flags page for global options not listed here.

See Also

rclone completion bash

Output bash completion script for rclone.

Synopsis

Generates a bash shell autocompletion script for rclone.

By default, when run without any arguments,

rclone completion bash

the generated script will be written to

/etc/bash_completion.d/rclone

and so rclone will probably need to be run as root, or with sudo.

If you supply a path to a file as the command line argument, then the generated script will be written to that file, in which case you should not need root privileges.

If output_file is "-", then the output will be written to stdout.

If you have installed the script into the default location, you can logout and login again to use the autocompletion script.

Alternatively, you can source the script directly

. /path/to/my_bash_completion_scripts/rclone

and the autocompletion functionality will be added to your current shell.

rclone completion bash [output_file] [flags]

Options

  -h, --help   help for bash

See the global flags page for global options not listed here.

See Also

rclone completion fish

Output fish completion script for rclone.

Synopsis

Generates a fish autocompletion script for rclone.

This writes to /etc/fish/completions/rclone.fish by default so will probably need to be run with sudo or as root, e.g.

sudo rclone completion fish

Logout and login again to use the autocompletion scripts, or source them directly

. /etc/fish/completions/rclone.fish

If you supply a command line argument the script will be written there.

If output_file is "-", then the output will be written to stdout.

rclone completion fish [output_file] [flags]

Options

  -h, --help   help for fish

See the global flags page for global options not listed here.

See Also

rclone completion powershell

Output powershell completion script for rclone.

Synopsis

Generate the autocompletion script for powershell.

To load completions in your current shell session:

rclone completion powershell | Out-String | Invoke-Expression

To load completions for every new session, add the output of the above command to your powershell profile.

If output_file is "-" or missing, then the output will be written to stdout.

rclone completion powershell [output_file] [flags]

Options

  -h, --help   help for powershell

See the global flags page for global options not listed here.

See Also

rclone completion zsh

Output zsh completion script for rclone.

Synopsis

Generates a zsh autocompletion script for rclone.

This writes to /usr/share/zsh/vendor-completions/_rclone by default so will probably need to be run with sudo or as root, e.g.

sudo rclone completion zsh

Logout and login again to use the autocompletion scripts, or source them directly

autoload -U compinit && compinit

If you supply a command line argument the script will be written there.

If output_file is "-", then the output will be written to stdout.

rclone completion zsh [output_file] [flags]

Options

  -h, --help   help for zsh

See the global flags page for global options not listed here.

See Also

rclone config create

Create a new remote with name, type and options.

Synopsis

Create a new remote of name with type and options. The options should be passed in pairs of key value or as key=value.

For example, to make a swift remote of name myremote using auto config you would do:

rclone config create myremote swift env_auth true
rclone config create myremote swift env_auth=true

So for example if you wanted to configure a Google Drive remote but using remote authorization you would do this:

rclone config create mydrive drive config_is_local=false

Note that if the config process would normally ask a question the default is taken (unless --non-interactive is used). Each time that happens rclone will print or DEBUG a message saying how to affect the value taken.

If any of the parameters passed is a password field, then rclone will automatically obscure them if they aren't already obscured before putting them in the config file.

NB If the password parameter is 22 characters or longer and consists only of base64 characters then rclone can get confused about whether the password is already obscured or not and put unobscured passwords into the config file. If you want to be 100% certain that the passwords get obscured then use the --obscure flag, or if you are 100% certain you are already passing obscured passwords then use --no-obscure. You can also set obscured passwords using the rclone config password command.

The flag --non-interactive is for use by applications that wish to configure rclone themselves, rather than using rclone's text based configuration questions. If this flag is set, and rclone needs to ask the user a question, a JSON blob will be returned with the question in it.

This will look something like (some irrelevant detail removed):

{
    "State": "*oauth-islocal,teamdrive,,",
    "Option": {
        "Name": "config_is_local",
        "Help": "Use web browser to automatically authenticate rclone with remote?\n * Say Y if the machine running rclone has a web browser you can use\n * Say N if running rclone on a (remote) machine without web browser access\nIf not sure try Y. If Y failed, try N.\n",
        "Default": true,
        "Examples": [
            {
                "Value": "true",
                "Help": "Yes"
            },
            {
                "Value": "false",
                "Help": "No"
            }
        ],
        "Required": false,
        "IsPassword": false,
        "Type": "bool",
        "Exclusive": true,
    },
    "Error": "",
}

The format of Option is the same as returned by rclone config providers. The question should be asked to the user and returned to rclone as the --result option along with the --state parameter.

The keys of Option are used as follows:

  • Name - name of variable - show to user
  • Help - help text. Hard wrapped at 80 chars. Any URLs should be clicky.
  • Default - default value - return this if the user just wants the default.
  • Examples - the user should be able to choose one of these
  • Required - the value should be non-empty
  • IsPassword - the value is a password and should be edited as such
  • Type - type of value, eg bool, string, int and others
  • Exclusive - if set no free-form entry allowed only the Examples
  • Irrelevant keys Provider, ShortOpt, Hide, NoPrefix, Advanced

If Error is set then it should be shown to the user at the same time as the question.

rclone config update name --continue --state "*oauth-islocal,teamdrive,," --result "true"

Note that when using --continue all passwords should be passed in the clear (not obscured). Any default config values should be passed in with each invocation of --continue.

At the end of the non interactive process, rclone will return a result with State as empty string.

If --all is passed then rclone will ask all the config questions, not just the post config questions. Any parameters are used as defaults for questions as usual.

Note that bin/config.py in the rclone source implements this protocol as a readable demonstration.

rclone config create name type [key value]* [flags]

Options

      --all               Ask the full set of config questions
      --continue          Continue the configuration process with an answer
  -h, --help              help for create
      --no-obscure        Force any passwords not to be obscured
      --no-output         Don't provide any output
      --non-interactive   Don't interact with user and return questions
      --obscure           Force any passwords to be obscured
      --result string     Result - use with --continue
      --state string      State - use with --continue

See the global flags page for global options not listed here.

See Also

rclone config delete

Delete an existing remote.

rclone config delete name [flags]

Options

  -h, --help   help for delete

See the global flags page for global options not listed here.

See Also

rclone config disconnect

Disconnects user from remote

Synopsis

This disconnects the remote: passed in to the cloud storage system.

This normally means revoking the oauth token.

To reconnect use "rclone config reconnect".

rclone config disconnect remote: [flags]

Options

  -h, --help   help for disconnect

See the global flags page for global options not listed here.

See Also

rclone config dump

Dump the config file as JSON.

rclone config dump [flags]

Options

  -h, --help   help for dump

See the global flags page for global options not listed here.

See Also

rclone config edit

Enter an interactive configuration session.

Synopsis

Enter an interactive configuration session where you can setup new remotes and manage existing ones. You may also set or remove a password to protect your configuration.

rclone config edit [flags]

Options

  -h, --help   help for edit

See the global flags page for global options not listed here.

See Also

rclone config encryption

set, remove and check the encryption for the config file

Synopsis

This command sets, clears and checks the encryption for the config file using the subcommands below.

Options

  -h, --help   help for encryption

See the global flags page for global options not listed here.

See Also

rclone config encryption check

Check that the config file is encrypted

Synopsis

This checks the config file is encrypted and that you can decrypt it.

It will attempt to decrypt the config using the password you supply.

If decryption fails it will return a non-zero exit code if using --password-command, otherwise it will prompt again for the password.

If the config file is not encrypted it will return a non zero exit code.

rclone config encryption check [flags]

Options

  -h, --help   help for check

See the global flags page for global options not listed here.

See Also

rclone config encryption remove

Remove the config file encryption password

Synopsis

Remove the config file encryption password

This removes the config file encryption, returning it to un-encrypted.

If --password-command is in use, this will be called to supply the old config password.

If the config was not encrypted then no error will be returned and this command will do nothing.

rclone config encryption remove [flags]

Options

  -h, --help   help for remove

See the global flags page for global options not listed here.

See Also

rclone config encryption set

Set or change the config file encryption password

Synopsis

This command sets or changes the config file encryption password.

If there was no config password set then it sets a new one, otherwise it changes the existing config password.

Note that if you are changing an encryption password using --password-command then this will be called once to decrypt the config using the old password and then again to read the new password to re-encrypt the config.

When --password-command is called to change the password then the environment variable RCLONE_PASSWORD_CHANGE=1 will be set. So if changing passwords programmatically you can use the environment variable to distinguish which password you must supply.

Alternatively you can remove the password first (with rclone config encryption remove), then set it again with this command which may be easier if you don't mind the unencrypted config file being on the disk briefly.

rclone config encryption set [flags]

Options

  -h, --help   help for set

See the global flags page for global options not listed here.

See Also

rclone config file

Show path of configuration file in use.

rclone config file [flags]

Options

  -h, --help   help for file

See the global flags page for global options not listed here.

See Also

rclone config password

Update password in an existing remote.

Synopsis

Update an existing remote's password. The password should be passed in pairs of key password or as key=password. The password should be passed in in clear (unobscured).

For example, to set password of a remote of name myremote you would do:

rclone config password myremote fieldname mypassword
rclone config password myremote fieldname=mypassword

This command is obsolete now that "config update" and "config create" both support obscuring passwords directly.

rclone config password name [key value]+ [flags]

Options

  -h, --help   help for password

See the global flags page for global options not listed here.

See Also

rclone config paths

Show paths used for configuration, cache, temp etc.

rclone config paths [flags]

Options

  -h, --help   help for paths

See the global flags page for global options not listed here.

See Also

rclone config providers

List in JSON format all the providers and options.

rclone config providers [flags]

Options

  -h, --help   help for providers

See the global flags page for global options not listed here.

See Also

rclone config reconnect

Re-authenticates user with remote.

Synopsis

This reconnects remote: passed in to the cloud storage system.

To disconnect the remote use "rclone config disconnect".

This normally means going through the interactive oauth flow again.

rclone config reconnect remote: [flags]

Options

  -h, --help   help for reconnect

See the global flags page for global options not listed here.

See Also

rclone config redacted

Print redacted (decrypted) config file, or the redacted config for a single remote.

Synopsis

This prints a redacted copy of the config file, either the whole config file or for a given remote.

The config file will be redacted by replacing all passwords and other sensitive info with XXX.

This makes the config file suitable for posting online for support.

It should be double checked before posting as the redaction may not be perfect.

rclone config redacted [<remote>] [flags]

Options

  -h, --help   help for redacted

See the global flags page for global options not listed here.

See Also

rclone config show

Print (decrypted) config file, or the config for a single remote.

rclone config show [<remote>] [flags]

Options

  -h, --help   help for show

See the global flags page for global options not listed here.

See Also

rclone config touch

Ensure configuration file exists.

rclone config touch [flags]

Options

  -h, --help   help for touch

See the global flags page for global options not listed here.

See Also

rclone config update

Update options in an existing remote.

Synopsis

Update an existing remote's options. The options should be passed in pairs of key value or as key=value.

For example, to update the env_auth field of a remote of name myremote you would do:

rclone config update myremote env_auth true
rclone config update myremote env_auth=true

If the remote uses OAuth the token will be updated, if you don't require this add an extra parameter thus:

rclone config update myremote env_auth=true config_refresh_token=false

Note that if the config process would normally ask a question the default is taken (unless --non-interactive is used). Each time that happens rclone will print or DEBUG a message saying how to affect the value taken.

If any of the parameters passed is a password field, then rclone will automatically obscure them if they aren't already obscured before putting them in the config file.

NB If the password parameter is 22 characters or longer and consists only of base64 characters then rclone can get confused about whether the password is already obscured or not and put unobscured passwords into the config file. If you want to be 100% certain that the passwords get obscured then use the --obscure flag, or if you are 100% certain you are already passing obscured passwords then use --no-obscure. You can also set obscured passwords using the rclone config password command.

The flag --non-interactive is for use by applications that wish to configure rclone themselves, rather than using rclone's text based configuration questions. If this flag is set, and rclone needs to ask the user a question, a JSON blob will be returned with the question in it.

This will look something like (some irrelevant detail removed):

{
    "State": "*oauth-islocal,teamdrive,,",
    "Option": {
        "Name": "config_is_local",
        "Help": "Use web browser to automatically authenticate rclone with remote?\n * Say Y if the machine running rclone has a web browser you can use\n * Say N if running rclone on a (remote) machine without web browser access\nIf not sure try Y. If Y failed, try N.\n",
        "Default": true,
        "Examples": [
            {
                "Value": "true",
                "Help": "Yes"
            },
            {
                "Value": "false",
                "Help": "No"
            }
        ],
        "Required": false,
        "IsPassword": false,
        "Type": "bool",
        "Exclusive": true,
    },
    "Error": "",
}

The format of Option is the same as returned by rclone config providers. The question should be asked to the user and returned to rclone as the --result option along with the --state parameter.

The keys of Option are used as follows:

  • Name - name of variable - show to user
  • Help - help text. Hard wrapped at 80 chars. Any URLs should be clicky.
  • Default - default value - return this if the user just wants the default.
  • Examples - the user should be able to choose one of these
  • Required - the value should be non-empty
  • IsPassword - the value is a password and should be edited as such
  • Type - type of value, eg bool, string, int and others
  • Exclusive - if set no free-form entry allowed only the Examples
  • Irrelevant keys Provider, ShortOpt, Hide, NoPrefix, Advanced

If Error is set then it should be shown to the user at the same time as the question.

rclone config update name --continue --state "*oauth-islocal,teamdrive,," --result "true"

Note that when using --continue all passwords should be passed in the clear (not obscured). Any default config values should be passed in with each invocation of --continue.

At the end of the non interactive process, rclone will return a result with State as empty string.

If --all is passed then rclone will ask all the config questions, not just the post config questions. Any parameters are used as defaults for questions as usual.

Note that bin/config.py in the rclone source implements this protocol as a readable demonstration.

rclone config update name [key value]+ [flags]

Options

      --all               Ask the full set of config questions
      --continue          Continue the configuration process with an answer
  -h, --help              help for update
      --no-obscure        Force any passwords not to be obscured
      --no-output         Don't provide any output
      --non-interactive   Don't interact with user and return questions
      --obscure           Force any passwords to be obscured
      --result string     Result - use with --continue
      --state string      State - use with --continue

See the global flags page for global options not listed here.

See Also

rclone config userinfo

Prints info about logged in user of remote.

Synopsis

This prints the details of the person logged in to the cloud storage system.

rclone config userinfo remote: [flags]

Options

  -h, --help   help for userinfo
      --json   Format output as JSON

See the global flags page for global options not listed here.

See Also

rclone convmv

Convert file and directory names in place.

Synopsis

convmv supports advanced path name transformations for converting and renaming files and directories by applying prefixes, suffixes, and other alterations.

Command Description
--name-transform prefix=XXXX Prepends XXXX to the file name.
--name-transform suffix=XXXX Appends XXXX to the file name after the extension.
--name-transform suffix_keep_extension=XXXX Appends XXXX to the file name while preserving the original file extension.
--name-transform trimprefix=XXXX Removes XXXX if it appears at the start of the file name.
--name-transform trimsuffix=XXXX Removes XXXX if it appears at the end of the file name.
--name-transform regex=/pattern/replacement/ Applies a regex-based transformation.
--name-transform replace=old:new Replaces occurrences of old with new in the file name.
--name-transform date={YYYYMMDD} Appends or prefixes the specified date format.
--name-transform truncate=N Truncates the file name to a maximum of N characters.
--name-transform base64encode Encodes the file name in Base64.
--name-transform base64decode Decodes a Base64-encoded file name.
--name-transform encoder=ENCODING Converts the file name to the specified encoding (e.g., ISO-8859-1, Windows-1252, Macintosh).
--name-transform decoder=ENCODING Decodes the file name from the specified encoding.
--name-transform charmap=MAP Applies a character mapping transformation.
--name-transform lowercase Converts the file name to lowercase.
--name-transform uppercase Converts the file name to UPPERCASE.
--name-transform titlecase Converts the file name to Title Case.
--name-transform ascii Strips non-ASCII characters.
--name-transform url URL-encodes the file name.
--name-transform nfc Converts the file name to NFC Unicode normalization form.
--name-transform nfd Converts the file name to NFD Unicode normalization form.
--name-transform nfkc Converts the file name to NFKC Unicode normalization form.
--name-transform nfkd Converts the file name to NFKD Unicode normalization form.
--name-transform command=/path/to/my/programfile names. Executes an external program to transform

Conversion modes:

none  
nfc  
nfd  
nfkc  
nfkd  
replace  
prefix  
suffix  
suffix_keep_extension  
trimprefix  
trimsuffix  
index  
date  
truncate  
base64encode  
base64decode  
encoder  
decoder  
ISO-8859-1  
Windows-1252  
Macintosh  
charmap  
lowercase  
uppercase  
titlecase  
ascii  
url  
regex  
command

Char maps:

  
IBM-Code-Page-037  
IBM-Code-Page-437  
IBM-Code-Page-850  
IBM-Code-Page-852  
IBM-Code-Page-855  
Windows-Code-Page-858  
IBM-Code-Page-860  
IBM-Code-Page-862  
IBM-Code-Page-863  
IBM-Code-Page-865  
IBM-Code-Page-866  
IBM-Code-Page-1047  
IBM-Code-Page-1140  
ISO-8859-1  
ISO-8859-2  
ISO-8859-3  
ISO-8859-4  
ISO-8859-5  
ISO-8859-6  
ISO-8859-7  
ISO-8859-8  
ISO-8859-9  
ISO-8859-10  
ISO-8859-13  
ISO-8859-14  
ISO-8859-15  
ISO-8859-16  
KOI8-R  
KOI8-U  
Macintosh  
Macintosh-Cyrillic  
Windows-874  
Windows-1250  
Windows-1251  
Windows-1252  
Windows-1253  
Windows-1254  
Windows-1255  
Windows-1256  
Windows-1257  
Windows-1258  
X-User-Defined

Encoding masks:

Asterisk  
 BackQuote  
 BackSlash  
 Colon  
 CrLf  
 Ctl  
 Del  
 Dollar  
 Dot  
 DoubleQuote  
 Exclamation  
 Hash  
 InvalidUtf8  
 LeftCrLfHtVt  
 LeftPeriod  
 LeftSpace  
 LeftTilde  
 LtGt  
 None  
 Percent  
 Pipe  
 Question  
 Raw  
 RightCrLfHtVt  
 RightPeriod  
 RightSpace  
 Semicolon  
 SingleQuote  
 Slash  
 SquareBracket

Examples:

rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,uppercase"
// Output: STORIES/THE QUICK BROWN FOX!.TXT
rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,replace=Fox:Turtle" --name-transform "all,replace=Quick:Slow"
// Output: stories/The Slow Brown Turtle!.txt
rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,base64encode"
// Output: c3Rvcmllcw==/VGhlIFF1aWNrIEJyb3duIEZveCEudHh0
rclone convmv "c3Rvcmllcw==/VGhlIFF1aWNrIEJyb3duIEZveCEudHh0" --name-transform "all,base64decode"
// Output: stories/The Quick Brown Fox!.txt
rclone convmv "stories/The Quick Brown 🦊 Fox Went to the Café!.txt" --name-transform "all,nfc"
// Output: stories/The Quick Brown 🦊 Fox Went to the Café!.txt
rclone convmv "stories/The Quick Brown 🦊 Fox Went to the Café!.txt" --name-transform "all,nfd"
// Output: stories/The Quick Brown 🦊 Fox Went to the Café!.txt
rclone convmv "stories/The Quick Brown 🦊 Fox!.txt" --name-transform "all,ascii"
// Output: stories/The Quick Brown  Fox!.txt
rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,trimsuffix=.txt"
// Output: stories/The Quick Brown Fox!
rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,prefix=OLD_"
// Output: OLD_stories/OLD_The Quick Brown Fox!.txt
rclone convmv "stories/The Quick Brown 🦊 Fox Went to the Café!.txt" --name-transform "all,charmap=ISO-8859-7"
// Output: stories/The Quick Brown _ Fox Went to the Caf_!.txt
rclone convmv "stories/The Quick Brown Fox: A Memoir [draft].txt" --name-transform "all,encoder=Colon,SquareBracket"
// Output: stories/The Quick Brown Fox： A Memoir ［draft］.txt
rclone convmv "stories/The Quick Brown 🦊 Fox Went to the Café!.txt" --name-transform "all,truncate=21"
// Output: stories/The Quick Brown 🦊 Fox
rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,command=echo"
// Output: stories/The Quick Brown Fox!.txt
rclone convmv "stories/The Quick Brown Fox!" --name-transform "date=-{YYYYMMDD}"
// Output: stories/The Quick Brown Fox!-20250618
rclone convmv "stories/The Quick Brown Fox!" --name-transform "date=-{macfriendlytime}"
// Output: stories/The Quick Brown Fox!-2025-06-18 0148PM
rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,regex=[\\.\\w]/ab"
// Output: ababababababab/ababab ababababab ababababab ababab!abababab

Multiple transformations can be used in sequence, applied in the order they are specified on the command line.

The --name-transform flag is also available in sync, copy, and move.

Files vs Directories

By default --name-transform will only apply to file names. The means only the leaf file name will be transformed. However some of the transforms would be better applied to the whole path or just directories. To choose which which part of the file path is affected some tags can be added to the --name-transform.

Tag Effect
file Only transform the leaf name of files (DEFAULT)
dir Only transform name of directories - these may appear anywhere in the path
all Transform the entire path for files and directories

This is used by adding the tag into the transform name like this: --name-transform file,prefix=ABC or --name-transform dir,prefix=DEF.

For some conversions using all is more likely to be useful, for example --name-transform all,nfc.

Note that --name-transform may not add path separators / to the name. This will cause an error.

Ordering and Conflicts

  • Transformations will be applied in the order specified by the user.
    • If the file tag is in use (the default) then only the leaf name of files will be transformed.
    • If the dir tag is in use then directories anywhere in the path will be transformed
    • If the all tag is in use then directories and files anywhere in the path will be transformed
    • Each transformation will be run one path segment at a time.
    • If a transformation adds a / or ends up with an empty path segment then that will be an error.
  • It is up to the user to put the transformations in a sensible order.
    • Conflicting transformations, such as prefix followed by trimprefix or nfc followed by nfd, are possible.
    • Instead of enforcing mutual exclusivity, transformations are applied in sequence as specified by the user, allowing for intentional use cases (e.g., trimming one prefix before adding another).
    • Users should be aware that certain combinations may lead to unexpected results and should verify transformations using --dry-run before execution.

Race Conditions and Non-Deterministic Behavior

Some transformations, such as replace=old:new, may introduce conflicts where multiple source files map to the same destination name. This can lead to race conditions when performing concurrent transfers. It is up to the user to anticipate these. * If two files from the source are transformed into the same name at the destination, the final state may be non-deterministic. * Running rclone check after a sync using such transformations may erroneously report missing or differing files due to overwritten results.

To minimize risks, users should: * Carefully review transformations that may introduce conflicts. * Use --dry-run to inspect changes before executing a sync (but keep in mind that it won't show the effect of non-deterministic transformations). * Avoid transformations that cause multiple distinct source files to map to the same destination name. * Consider disabling concurrency with --transfers=1 if necessary. * Certain transformations (e.g. prefix) will have a multiplying effect every time they are used. Avoid these when using bisync.

rclone convmv dest:path --name-transform XXX [flags]

Options

      --create-empty-src-dirs   Create empty source dirs on destination after move
      --delete-empty-src-dirs   Delete empty source dirs after move
  -h, --help                    help for convmv

Options shared with other commands are described next. See the global flags page for global options not listed here.

Copy Options

Flags for anything which can copy a file

      --check-first                                 Do all the checks before starting transfers
  -c, --checksum                                    Check for changes with size & checksum (if available, or fallback to size only)
      --compare-dest stringArray                    Include additional server-side paths during comparison
      --copy-dest stringArray                       Implies --compare-dest but also copies files from paths into destination
      --cutoff-mode HARD|SOFT|CAUTIOUS              Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD)
      --ignore-case-sync                            Ignore case when synchronizing
      --ignore-checksum                             Skip post copy check of checksums
      --ignore-existing                             Skip all files that exist on destination
      --ignore-size                                 Ignore size when skipping use modtime or checksum
  -I, --ignore-times                                Don't skip items that match size and time - transfer all unconditionally
      --immutable                                   Do not modify files, fail if existing files have been modified
      --inplace                                     Download directly to destination file instead of atomic download to temp/rename
  -l, --links                                       Translate symlinks to/from regular files with a '.rclonelink' extension
      --max-backlog int                             Maximum number of objects in sync or check backlog (default 10000)
      --max-duration Duration                       Maximum duration rclone will transfer data for (default 0s)
      --max-transfer SizeSuffix                     Maximum size of data to transfer (default off)
  -M, --metadata                                    If set, preserve metadata when copying objects
      --modify-window Duration                      Max time diff to be considered the same (default 1ns)
      --multi-thread-chunk-size SizeSuffix          Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi)
      --multi-thread-cutoff SizeSuffix              Use multi-thread downloads for files above this size (default 256Mi)
      --multi-thread-streams int                    Number of streams to use for multi-thread downloads (default 4)
      --multi-thread-write-buffer-size SizeSuffix   In memory buffer size for writing when in multi-thread mode (default 128Ki)
      --name-transform stringArray                  Transform paths during the copy process
      --no-check-dest                               Don't check the destination, copy regardless
      --no-traverse                                 Don't traverse destination file system on copy
      --no-update-dir-modtime                       Don't update directory modification times
      --no-update-modtime                           Don't update destination modtime if files identical
      --order-by string                             Instructions on how to order the transfers, e.g. 'size,descending'
      --partial-suffix string                       Add partial-suffix to temporary file name when --inplace is not used (default ".partial")
      --refresh-times                               Refresh the modtime of remote files
      --server-side-across-configs                  Allow server-side operations (e.g. copy) to work across different configs
      --size-only                                   Skip based on size only, not modtime or checksum
      --streaming-upload-cutoff SizeSuffix          Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki)
  -u, --update                                      Skip files that are newer on the destination

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone copyto

Copy files from source to dest, skipping identical files.

Synopsis

If source:path is a file or directory then it copies it to a file or directory named dest:path.

This can be used to upload single files to other than their current name. If the source is a directory then it acts exactly like the copy command.

So

rclone copyto src dst

where src and dst are rclone paths, either remote:path or /path/to/local or C:.

This will:

if src is file
    copy it to dst, overwriting an existing file if it exists
if src is directory
    copy it to dst, overwriting existing files if they exist
    see copy command for full details

This doesn't transfer files that are identical on src and dst, testing by size and modification time or MD5SUM. It doesn't delete files from the destination.

If you are looking to copy just a byte range of a file, please see 'rclone cat --offset X --count Y'

Note: Use the -P/--progress flag to view real-time transfer statistics

Logger Flags

The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different.

The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files.

  • = path means path was found in source and destination and was identical
  • - path means path was missing on the source, so only in the destination
  • + path means path was missing on the destination, so only in the source
  • * path means path was present in source and destination but different.
  • ! path means there was an error reading or hashing the source or dest.

The --dest-after flag writes a list file using the same format flags as lsf (including customizable options for hash, modtime, etc.) Conceptually it is similar to rsync's --itemize-changes, but not identical -- it should output an accurate list of what will be on the destination after the command is finished.

When the --no-traverse flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing.

Note that these logger flags have a few limitations, and certain scenarios are not currently supported:

  • --max-duration / CutoffModeHard
  • --compare-dest / --copy-dest
  • server-side moves of an entire dir at once
  • High-level retries, because there would be duplicates (use --retries 1 to disable)
  • Possibly some unusual error scenarios

Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.)

rclone copyto source:path dest:path [flags]

Options

      --absolute                Put a leading / in front of path names
      --combined string         Make a combined report of changes to this file
      --csv                     Output in CSV format
      --dest-after string       Report all files that exist on the dest post-sync
      --differ string           Report all non-matching files to this file
  -d, --dir-slash               Append a slash to directory names (default true)
      --dirs-only               Only list directories
      --error string            Report all files with errors (hashing or reading) to this file
      --files-only              Only list files (default true)
  -F, --format string           Output format - see lsf help for details (default "p")
      --hash h                  Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5")
  -h, --help                    help for copyto
      --match string            Report all matching files to this file
      --missing-on-dst string   Report all files missing from the destination to this file
      --missing-on-src string   Report all files missing from the source to this file
  -s, --separator string        Separator for the items in the format (default ";")
  -t, --timeformat string       Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Copy Options

Flags for anything which can copy a file

      --check-first                                 Do all the checks before starting transfers
  -c, --checksum                                    Check for changes with size & checksum (if available, or fallback to size only)
      --compare-dest stringArray                    Include additional server-side paths during comparison
      --copy-dest stringArray                       Implies --compare-dest but also copies files from paths into destination
      --cutoff-mode HARD|SOFT|CAUTIOUS              Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD)
      --ignore-case-sync                            Ignore case when synchronizing
      --ignore-checksum                             Skip post copy check of checksums
      --ignore-existing                             Skip all files that exist on destination
      --ignore-size                                 Ignore size when skipping use modtime or checksum
  -I, --ignore-times                                Don't skip items that match size and time - transfer all unconditionally
      --immutable                                   Do not modify files, fail if existing files have been modified
      --inplace                                     Download directly to destination file instead of atomic download to temp/rename
  -l, --links                                       Translate symlinks to/from regular files with a '.rclonelink' extension
      --max-backlog int                             Maximum number of objects in sync or check backlog (default 10000)
      --max-duration Duration                       Maximum duration rclone will transfer data for (default 0s)
      --max-transfer SizeSuffix                     Maximum size of data to transfer (default off)
  -M, --metadata                                    If set, preserve metadata when copying objects
      --modify-window Duration                      Max time diff to be considered the same (default 1ns)
      --multi-thread-chunk-size SizeSuffix          Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi)
      --multi-thread-cutoff SizeSuffix              Use multi-thread downloads for files above this size (default 256Mi)
      --multi-thread-streams int                    Number of streams to use for multi-thread downloads (default 4)
      --multi-thread-write-buffer-size SizeSuffix   In memory buffer size for writing when in multi-thread mode (default 128Ki)
      --name-transform stringArray                  Transform paths during the copy process
      --no-check-dest                               Don't check the destination, copy regardless
      --no-traverse                                 Don't traverse destination file system on copy
      --no-update-dir-modtime                       Don't update directory modification times
      --no-update-modtime                           Don't update destination modtime if files identical
      --order-by string                             Instructions on how to order the transfers, e.g. 'size,descending'
      --partial-suffix string                       Add partial-suffix to temporary file name when --inplace is not used (default ".partial")
      --refresh-times                               Refresh the modtime of remote files
      --server-side-across-configs                  Allow server-side operations (e.g. copy) to work across different configs
      --size-only                                   Skip based on size only, not modtime or checksum
      --streaming-upload-cutoff SizeSuffix          Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki)
  -u, --update                                      Skip files that are newer on the destination

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone copyurl

Copy the contents of the URL supplied content to dest:path.

Synopsis

Download a URL's content and copy it to the destination without saving it in temporary storage.

Setting --auto-filename will attempt to automatically determine the filename from the URL (after any redirections) and used in the destination path.

With --header-filename in addition, if a specific filename is set in HTTP headers, it will be used instead of the name from the URL. With --print-filename in addition, the resulting file name will be printed.

Setting --no-clobber will prevent overwriting file on the destination if there is one with the same name.

Setting --stdout or making the output file name - will cause the output to be written to standard output.

Troubleshooting

If you can't get rclone copyurl to work then here are some things you can try:

  • --disable-http2 rclone will use HTTP2 if available - try disabling it
  • --bind 0.0.0.0 rclone will use IPv6 if available - try disabling it
  • --bind ::0 to disable IPv4
  • --user agent curl - some sites have whitelists for curl's user-agent - try that
  • Make sure the site works with curl directly
rclone copyurl https://example.com dest:path [flags]

Options

  -a, --auto-filename     Get the file name from the URL and use it for destination file path
      --header-filename   Get the file name from the Content-Disposition header
  -h, --help              help for copyurl
      --no-clobber        Prevent overwriting file with same name
  -p, --print-filename    Print the resulting name from --auto-filename
      --stdout            Write the output to stdout rather than a file

Options shared with other commands are described next. See the global flags page for global options not listed here.

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone cryptcheck

Cryptcheck checks the integrity of an encrypted remote.

Synopsis

Checks a remote against a crypted remote. This is the equivalent of running rclone check, but able to check the checksums of the encrypted remote.

For it to work the underlying remote of the cryptedremote must support some kind of checksum.

It works by reading the nonce from each file on the cryptedremote: and using that to encrypt each file on the remote:. It then checks the checksum of the underlying file on the cryptedremote: against the checksum of the file it has just encrypted.

Use it like this

rclone cryptcheck /path/to/files encryptedremote:path

You can use it like this also, but that will involve downloading all the files in remote:path.

rclone cryptcheck remote:path encryptedremote:path

After it has run it will log the status of the encryptedremote:.

If you supply the --one-way flag, it will only check that files in the source match the files in the destination, not the other way around. This means that extra files in the destination that are not in the source will not be detected.

The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different.

The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files.

  • = path means path was found in source and destination and was identical
  • - path means path was missing on the source, so only in the destination
  • + path means path was missing on the destination, so only in the source
  • * path means path was present in source and destination but different.
  • ! path means there was an error reading or hashing the source or dest.

The default number of parallel checks is 8. See the --checkers option for more information.

rclone cryptcheck remote:path cryptedremote:path [flags]

Options

      --combined string         Make a combined report of changes to this file
      --differ string           Report all non-matching files to this file
      --error string            Report all files with errors (hashing or reading) to this file
  -h, --help                    help for cryptcheck
      --match string            Report all matching files to this file
      --missing-on-dst string   Report all files missing from the destination to this file
      --missing-on-src string   Report all files missing from the source to this file
      --one-way                 Check one way only, source files must exist on remote

Options shared with other commands are described next. See the global flags page for global options not listed here.

Check Options

Flags used for check commands

      --max-backlog int   Maximum number of objects in sync or check backlog (default 10000)

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone cryptdecode

Cryptdecode returns unencrypted file names.

Synopsis

Returns unencrypted file names when provided with a list of encrypted file names. List limit is 10 items.

If you supply the --reverse flag, it will return encrypted file names.

use it like this

rclone cryptdecode encryptedremote: encryptedfilename1 encryptedfilename2

rclone cryptdecode --reverse encryptedremote: filename1 filename2

Another way to accomplish this is by using the rclone backend encode (or decode) command. See the documentation on the crypt overlay for more info.

rclone cryptdecode encryptedremote: encryptedfilename [flags]

Options

  -h, --help      help for cryptdecode
      --reverse   Reverse cryptdecode, encrypts filenames

See the global flags page for global options not listed here.

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone deletefile

Remove a single file from remote.

Synopsis

Remove a single file from remote. Unlike delete it cannot be used to remove a directory and it doesn't obey include/exclude filters - if the specified file exists, it will always be removed.

rclone deletefile remote:path [flags]

Options

  -h, --help   help for deletefile

Options shared with other commands are described next. See the global flags page for global options not listed here.

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone gendocs

Output markdown docs for rclone to the directory supplied.

Synopsis

This produces markdown docs for the rclone commands to the directory supplied. These are in a format suitable for hugo to render into the rclone.org website.

rclone gendocs output_directory [flags]

Options

  -h, --help   help for gendocs

See the global flags page for global options not listed here.

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone gitannex

Speaks with git-annex over stdin/stdout.

Synopsis

Rclone's gitannex subcommand enables git-annex to store and retrieve content from an rclone remote. It is meant to be run by git-annex, not directly by users.

Installation on Linux

  1. Skip this step if your version of git-annex is 10.20240430 or newer. Otherwise, you must create a symlink somewhere on your PATH with a particular name. This symlink helps git-annex tell rclone it wants to run the "gitannex" subcommand.

    # Create the helper symlink in "$HOME/bin".
ln -s "$(realpath rclone)" "$HOME/bin/git-annex-remote-rclone-builtin"

# Verify the new symlink is on your PATH.
which git-annex-remote-rclone-builtin

  2. Add a new remote to your git-annex repo. This new remote will connect git-annex with the rclone gitannex subcommand.

    Start by asking git-annex to describe the remote's available configuration parameters.

    # If you skipped step 1:
git annex initremote MyRemote type=rclone --whatelse

# If you created a symlink in step 1:
git annex initremote MyRemote type=external externaltype=rclone-builtin --whatelse

    NOTE: If you're porting an existing git-annex-remote-rclone remote to use rclone gitannex, you can probably reuse the configuration parameters verbatim without renaming them. Check parameter synonyms with --whatelse as shown above.

    The following example creates a new git-annex remote named "MyRemote" that will use the rclone remote named "SomeRcloneRemote". That rclone remote must be one configured in your rclone.conf file, which can be located with rclone config file.

    git annex initremote MyRemote         \
    type=external                     \
    externaltype=rclone-builtin       \
    encryption=none                   \
    rcloneremotename=SomeRcloneRemote \
    rcloneprefix=git-annex-content    \
    rclonelayout=nodir

  3. Before you trust this command with your precious data, be sure to test the remote. This command is very new and has not been tested on many rclone backends. Caveat emptor!

    git annex testremote MyRemote

Happy annexing!

rclone gitannex [flags]

Options

  -h, --help   help for gitannex

See the global flags page for global options not listed here.

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone hashsum

Produces a hashsum file for all the objects in the path.

Synopsis

Produces a hash file for all the objects in the path using the hash named. The output is in the same format as the standard md5sum/sha1sum tool.

By default, the hash is requested from the remote. If the hash is not supported by the remote, no hash will be returned. With the download flag, the file will be downloaded from the remote and hashed locally enabling any hash for any remote.

For the MD5 and SHA1 algorithms there are also dedicated commands, md5sum and sha1sum.

This command can also hash data received on standard input (stdin), by not passing a remote:path, or by passing a hyphen as remote:path when there is data to read (if not, the hyphen will be treated literally, as a relative path).

Run without a hash to see the list of all supported hashes, e.g.

$ rclone hashsum
Supported hashes are:
  * md5
  * sha1
  * whirlpool
  * crc32
  * sha256
  * sha512
  * blake3
  * xxh3
  * xxh128

Then

$ rclone hashsum MD5 remote:path

Note that hash names are case insensitive and values are output in lower case.

rclone hashsum [<hash> remote:path] [flags]

Options

      --base64               Output base64 encoded hashsum
  -C, --checkfile string     Validate hashes against a given SUM file instead of printing them
      --download             Download the file and hash it locally; if this flag is not specified, the hash is requested from the remote
  -h, --help                 help for hashsum
      --output-file string   Output hashsums to a file rather than the terminal

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone link

Generate public link to file/folder.

Synopsis

Create, retrieve or remove a public link to the given file or folder.

rclone link remote:path/to/file
rclone link remote:path/to/folder/
rclone link --unlink remote:path/to/folder/
rclone link --expire 1d remote:path/to/file

If you supply the --expire flag, it will set the expiration time otherwise it will use the default (100 years). Note not all backends support the --expire flag - if the backend doesn't support it then the link returned won't expire.

Use the --unlink flag to remove existing public links to the file or folder. Note not all backends support "--unlink" flag - those that don't will just ignore it.

If successful, the last line of the output will contain the link. Exact capabilities depend on the remote, but the link will always by default be created with the least constraints – e.g. no expiry, no password protection, accessible without account.

rclone link remote:path [flags]

Options

      --expire Duration   The amount of time that the link will be valid (default off)
  -h, --help              help for link
      --unlink            Remove existing public link to file/folder

See the global flags page for global options not listed here.

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone listremotes

List all the remotes in the config file and defined in environment variables.

Synopsis

Lists all the available remotes from the config file, or the remotes matching an optional filter.

Prints the result in human-readable format by default, and as a simple list of remote names, or if used with flag --long a tabular format including the remote names, types and descriptions. Using flag --json produces machine-readable output instead, which always includes all attributes - including the source (file or environment).

Result can be filtered by a filter argument which applies to all attributes, and/or filter flags specific for each attribute. The values must be specified according to regular rclone filtering pattern syntax.

rclone listremotes [<filter>] [flags]

Options

      --description string   Filter remotes by description
  -h, --help                 help for listremotes
      --json                 Format output as JSON
      --long                 Show type and description in addition to name
      --name string          Filter remotes by name
      --order-by string      Instructions on how to order the result, e.g. 'type,name=descending'
      --source string        Filter remotes by source, e.g. 'file' or 'environment'
      --type string          Filter remotes by type

See the global flags page for global options not listed here.

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone lsf

List directories and objects in remote:path formatted for parsing.

Synopsis

List the contents of the source path (directories and objects) to standard output in a form which is easy to parse by scripts. By default this will just be the names of the objects and directories, one per line. The directories will have a / suffix.

Eg

$ rclone lsf swift:bucket
bevajer5jef
canole
diwogej7
ferejej3gux/
fubuwic

Use the --format option to control what gets listed. By default this is just the path, but you can use these parameters to control the output:

p - path
s - size
t - modification time
h - hash
i - ID of object
o - Original ID of underlying object
m - MimeType of object if known
e - encrypted name
T - tier of storage if known, e.g. "Hot" or "Cool"
M - Metadata of object in JSON blob format, eg {"key":"value"}

So if you wanted the path, size and modification time, you would use --format "pst", or maybe --format "tsp" to put the path last.

Eg

$ rclone lsf  --format "tsp" swift:bucket
2016-06-25 18:55:41;60295;bevajer5jef
2016-06-25 18:55:43;90613;canole
2016-06-25 18:55:43;94467;diwogej7
2018-04-26 08:50:45;0;ferejej3gux/
2016-06-25 18:55:40;37600;fubuwic

If you specify "h" in the format you will get the MD5 hash by default, use the --hash flag to change which hash you want. Note that this can be returned as an empty string if it isn't available on the object (and for directories), "ERROR" if there was an error reading it from the object and "UNSUPPORTED" if that object does not support that hash type.

For example, to emulate the md5sum command you can use

rclone lsf -R --hash MD5 --format hp --separator "  " --files-only .

Eg

$ rclone lsf -R --hash MD5 --format hp --separator "  " --files-only swift:bucket
7908e352297f0f530b84a756f188baa3  bevajer5jef
cd65ac234e6fea5925974a51cdd865cc  canole
03b5341b4f234b9d984d03ad076bae91  diwogej7
8fd37c3810dd660778137ac3a66cc06d  fubuwic
99713e14a4c4ff553acaf1930fad985b  gixacuh7ku

(Though "rclone md5sum ." is an easier way of typing this.)

By default the separator is ";" this can be changed with the --separator flag. Note that separators aren't escaped in the path so putting it last is a good strategy.

Eg

$ rclone lsf  --separator "," --format "tshp" swift:bucket
2016-06-25 18:55:41,60295,7908e352297f0f530b84a756f188baa3,bevajer5jef
2016-06-25 18:55:43,90613,cd65ac234e6fea5925974a51cdd865cc,canole
2016-06-25 18:55:43,94467,03b5341b4f234b9d984d03ad076bae91,diwogej7
2018-04-26 08:52:53,0,,ferejej3gux/
2016-06-25 18:55:40,37600,8fd37c3810dd660778137ac3a66cc06d,fubuwic

You can output in CSV standard format. This will escape things in " if they contain ,

Eg

$ rclone lsf --csv --files-only --format ps remote:path
test.log,22355
test.sh,449
"this file contains a comma, in the file name.txt",6

Note that the --absolute parameter is useful for making lists of files to pass to an rclone copy with the --files-from-raw flag.

For example, to find all the files modified within one day and copy those only (without traversing the whole directory structure):

rclone lsf --absolute --files-only --max-age 1d /path/to/local > new_files
rclone copy --files-from-raw new_files /path/to/local remote:path

The default time format is '2006-01-02 15:04:05'. Other formats can be specified with the --time-format flag. Examples:

rclone lsf remote:path --format pt --time-format 'Jan 2, 2006 at 3:04pm (MST)'
rclone lsf remote:path --format pt --time-format '2006-01-02 15:04:05.000000000'
rclone lsf remote:path --format pt --time-format '2006-01-02T15:04:05.999999999Z07:00'
rclone lsf remote:path --format pt --time-format RFC3339
rclone lsf remote:path --format pt --time-format DateOnly
rclone lsf remote:path --format pt --time-format max

--time-format max will automatically truncate '2006-01-02 15:04:05.000000000' to the maximum precision supported by the remote.

Any of the filtering options can be applied to this command.

There are several related list commands

  • ls to list size and path of objects only
  • lsl to list modification time, size and path of objects only
  • lsd to list directories only
  • lsf to list objects and directories in easy to parse format
  • lsjson to list objects and directories in JSON format

ls,lsl,lsd are designed to be human-readable. lsf is designed to be human and machine-readable. lsjson is designed to be machine-readable.

Note that ls and lsl recurse by default - use --max-depth 1 to stop the recursion.

The other list commands lsd,lsf,lsjson do not recurse by default - use -R to make them recurse.

Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes).

rclone lsf remote:path [flags]

Options

      --absolute             Put a leading / in front of path names
      --csv                  Output in CSV format
  -d, --dir-slash            Append a slash to directory names (default true)
      --dirs-only            Only list directories
      --files-only           Only list files
  -F, --format string        Output format - see  help for details (default "p")
      --hash h               Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5")
  -h, --help                 help for lsf
  -R, --recursive            Recurse into the listing
  -s, --separator string     Separator for the items in the format (default ";")
  -t, --time-format string   Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone lsjson

List directories and objects in the path in JSON format.

Synopsis

List directories and objects in the path in JSON format.

The output is an array of Items, where each Item looks like this:

{
  "Hashes" : {
     "SHA-1" : "f572d396fae9206628714fb2ce00f72e94f2258f",
     "MD5" : "b1946ac92492d2347c6235b4d2611184",
     "DropboxHash" : "ecb65bb98f9d905b70458986c39fcbad7715e5f2fcc3b1f07767d7c83e2438cc"
  },
  "ID": "y2djkhiujf83u33",
  "OrigID": "UYOJVTUW00Q1RzTDA",
  "IsBucket" : false,
  "IsDir" : false,
  "MimeType" : "application/octet-stream",
  "ModTime" : "2017-05-31T16:15:57.034468261+01:00",
  "Name" : "file.txt",
  "Encrypted" : "v0qpsdq8anpci8n929v3uu9338",
  "EncryptedPath" : "kja9098349023498/v0qpsdq8anpci8n929v3uu9338",
  "Path" : "full/path/goes/here/file.txt",
  "Size" : 6,
  "Tier" : "hot",
}

The exact set of properties included depends on the backend:

  • The property IsBucket will only be included for bucket-based remotes, and only for directories that are buckets. It will always be omitted when value is not true.
  • Properties Encrypted and EncryptedPath will only be included for encrypted remotes, and (as mentioned below) only if the --encrypted option is set.

Different options may also affect which properties are included:

  • If --hash is not specified, the Hashes property will be omitted. The types of hash can be specified with the --hash-type parameter (which may be repeated). If --hash-type is set then it implies --hash.
  • If --no-modtime is specified then ModTime will be blank. This can speed things up on remotes where reading the ModTime takes an extra request (e.g. s3, swift).
  • If --no-mimetype is specified then MimeType will be blank. This can speed things up on remotes where reading the MimeType takes an extra request (e.g. s3, swift).
  • If --encrypted is not specified the Encrypted and EncryptedPath properties will be omitted - even for encrypted remotes.
  • If --metadata is set then an additional Metadata property will be returned. This will have metadata in rclone standard format as a JSON object.

The default is to list directories and files/objects, but this can be changed with the following options:

  • If --dirs-only is specified then directories will be returned only, no files/objects.
  • If --files-only is specified then files will be returned only, no directories.

If --stat is set then the the output is not an array of items, but instead a single JSON blob will be returned about the item pointed to. This will return an error if the item isn't found, however on bucket based backends (like s3, gcs, b2, azureblob etc) if the item isn't found it will return an empty directory, as it isn't possible to tell empty directories from missing directories there.

The Path field will only show folders below the remote path being listed. If "remote:path" contains the file "subfolder/file.txt", the Path for "file.txt" will be "subfolder/file.txt", not "remote:path/subfolder/file.txt". When used without --recursive the Path will always be the same as Name.

The time is in RFC3339 format with up to nanosecond precision. The number of decimal digits in the seconds will depend on the precision that the remote can hold the times, so if times are accurate to the nearest millisecond (e.g. Google Drive) then 3 digits will always be shown ("2017-05-31T16:15:57.034+01:00") whereas if the times are accurate to the nearest second (Dropbox, Box, WebDav, etc.) no digits will be shown ("2017-05-31T16:15:57+01:00").

The whole output can be processed as a JSON blob, or alternatively it can be processed line by line as each item is written on individual lines (except with --stat).

Any of the filtering options can be applied to this command.

There are several related list commands

  • ls to list size and path of objects only
  • lsl to list modification time, size and path of objects only
  • lsd to list directories only
  • lsf to list objects and directories in easy to parse format
  • lsjson to list objects and directories in JSON format

ls,lsl,lsd are designed to be human-readable. lsf is designed to be human and machine-readable. lsjson is designed to be machine-readable.

Note that ls and lsl recurse by default - use --max-depth 1 to stop the recursion.

The other list commands lsd,lsf,lsjson do not recurse by default - use -R to make them recurse.

Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes).

rclone lsjson remote:path [flags]

Options

      --dirs-only               Show only directories in the listing
      --encrypted               Show the encrypted names
      --files-only              Show only files in the listing
      --hash                    Include hashes in the output (may take longer)
      --hash-type stringArray   Show only this hash type (may be repeated)
  -h, --help                    help for lsjson
  -M, --metadata                Add metadata to the listing
      --no-mimetype             Don't read the mime type (can speed things up)
      --no-modtime              Don't read the modification time (can speed things up)
      --original                Show the ID of the underlying Object
  -R, --recursive               Recurse into the listing
      --stat                    Just return the info for the pointed to file

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone mount

Mount the remote as file system on a mountpoint.

Synopsis

Rclone mount allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE.

First set up your remote using rclone config. Check it works with rclone ls etc.

On Linux and macOS, you can run mount in either foreground or background (aka daemon) mode. Mount runs in foreground mode by default. Use the --daemon flag to force background mode. On Windows you can run mount in foreground only, the flag is ignored.

In background mode rclone acts as a generic Unix mount program: the main program starts, spawns background rclone process to setup and maintain the mount, waits until success or timeout and exits with appropriate code (killing the child process if it fails).

On Linux/macOS/FreeBSD start the mount like this, where /path/to/local/mount is an empty existing directory:

rclone mount remote:path/to/files /path/to/local/mount

On Windows you can start a mount in different ways. See below for details. If foreground mount is used interactively from a console window, rclone will serve the mount and occupy the console so another window should be used to work with the mount until rclone is interrupted e.g. by pressing Ctrl-C.

The following examples will mount to an automatically assigned drive, to specific drive letter X:, to path C:\path\parent\mount (where parent directory or drive must exist, and mount must not exist, and is not supported when mounting as a network drive), and the last example will mount as network share \\cloud\remote and map it to an automatically assigned drive:

rclone mount remote:path/to/files *
rclone mount remote:path/to/files X:
rclone mount remote:path/to/files C:\path\parent\mount
rclone mount remote:path/to/files \\cloud\remote

When the program ends while in foreground mode, either via Ctrl+C or receiving a SIGINT or SIGTERM signal, the mount should be automatically stopped.

When running in background mode the user will have to stop the mount manually:

# Linux
fusermount -u /path/to/local/mount
#... or on some systems
fusermount3 -u /path/to/local/mount
# OS X or Linux when using nfsmount
umount /path/to/local/mount

The umount operation can fail, for example when the mountpoint is busy. When that happens, it is the user's responsibility to stop the mount manually.

The size of the mounted file system will be set according to information retrieved from the remote, the same as returned by the rclone about command. Remotes with unlimited storage may report the used size only, then an additional 1 PiB of free space is assumed. If the remote does not support the about feature at all, then 1 PiB is set as both the total and the free size.

Installing on Windows

To run rclone mount on Windows, you will need to download and install WinFsp.

WinFsp is an open-source Windows File System Proxy which makes it easy to write user space file systems for Windows. It provides a FUSE emulation layer which rclone uses combination with cgofuse. Both of these packages are by Bill Zissimopoulos who was very helpful during the implementation of rclone mount for Windows.

Mounting modes on windows

Unlike other operating systems, Microsoft Windows provides a different filesystem type for network and fixed drives. It optimises access on the assumption fixed disk drives are fast and reliable, while network drives have relatively high latency and less reliability. Some settings can also be differentiated between the two types, for example that Windows Explorer should just display icons and not create preview thumbnails for image and video files on network drives.

In most cases, rclone will mount the remote as a normal, fixed disk drive by default. However, you can also choose to mount it as a remote network drive, often described as a network share. If you mount an rclone remote using the default, fixed drive mode and experience unexpected program errors, freezes or other issues, consider mounting as a network drive instead.

When mounting as a fixed disk drive you can either mount to an unused drive letter, or to a path representing a nonexistent subdirectory of an existing parent directory or drive. Using the special value * will tell rclone to automatically assign the next available drive letter, starting with Z: and moving backward. Examples:

rclone mount remote:path/to/files *
rclone mount remote:path/to/files X:
rclone mount remote:path/to/files C:\path\parent\mount
rclone mount remote:path/to/files X:

Option --volname can be used to set a custom volume name for the mounted file system. The default is to use the remote name and path.

To mount as network drive, you can add option --network-mode to your mount command. Mounting to a directory path is not supported in this mode, it is a limitation Windows imposes on junctions, so the remote must always be mounted to a drive letter.

rclone mount remote:path/to/files X: --network-mode

A volume name specified with --volname will be used to create the network share path. A complete UNC path, such as \\cloud\remote, optionally with path \\cloud\remote\madeup\path, will be used as is. Any other string will be used as the share part, after a default prefix \\server\. If no volume name is specified then \\server\share will be used. You must make sure the volume name is unique when you are mounting more than one drive, or else the mount command will fail. The share name will treated as the volume label for the mapped drive, shown in Windows Explorer etc, while the complete \\server\share will be reported as the remote UNC path by net use etc, just like a normal network drive mapping.

If you specify a full network share UNC path with --volname, this will implicitly set the --network-mode option, so the following two examples have same result:

rclone mount remote:path/to/files X: --network-mode
rclone mount remote:path/to/files X: --volname \\server\share

You may also specify the network share UNC path as the mountpoint itself. Then rclone will automatically assign a drive letter, same as with * and use that as mountpoint, and instead use the UNC path specified as the volume name, as if it were specified with the --volname option. This will also implicitly set the --network-mode option. This means the following two examples have same result:

rclone mount remote:path/to/files \\cloud\remote
rclone mount remote:path/to/files * --volname \\cloud\remote

There is yet another way to enable network mode, and to set the share path, and that is to pass the "native" libfuse/WinFsp option directly: --fuse-flag --VolumePrefix=\server\share. Note that the path must be with just a single backslash prefix in this case.

Note: In previous versions of rclone this was the only supported method.

Read more about drive mapping

See also Limitations section below.

Windows filesystem permissions

The FUSE emulation layer on Windows must convert between the POSIX-based permission model used in FUSE, and the permission model used in Windows, based on access-control lists (ACL).

The mounted filesystem will normally get three entries in its access-control list (ACL), representing permissions for the POSIX permission scopes: Owner, group and others. By default, the owner and group will be taken from the current user, and the built-in group "Everyone" will be used to represent others. The user/group can be customized with FUSE options "UserName" and "GroupName", e.g. -o UserName=user123 -o GroupName="Authenticated Users". The permissions on each entry will be set according to options --dir-perms and --file-perms, which takes a value in traditional Unix numeric notation.

The default permissions corresponds to --file-perms 0666 --dir-perms 0777, i.e. read and write permissions to everyone. This means you will not be able to start any programs from the mount. To be able to do that you must add execute permissions, e.g. --file-perms 0777 --dir-perms 0777 to add it to everyone. If the program needs to write files, chances are you will have to enable VFS File Caching as well (see also limitations). Note that the default write permission have some restrictions for accounts other than the owner, specifically it lacks the "write extended attributes", as explained next.

The mapping of permissions is not always trivial, and the result you see in Windows Explorer may not be exactly like you expected. For example, when setting a value that includes write access for the group or others scope, this will be mapped to individual permissions "write attributes", "write data" and "append data", but not "write extended attributes". Windows will then show this as basic permission "Special" instead of "Write", because "Write" also covers the "write extended attributes" permission. When setting digit 0 for group or others, to indicate no permissions, they will still get individual permissions "read attributes", "read extended attributes" and "read permissions". This is done for compatibility reasons, e.g. to allow users without additional permissions to be able to read basic metadata about files like in Unix.

WinFsp 2021 (version 1.9) introduced a new FUSE option "FileSecurity", that allows the complete specification of file security descriptors using SDDL. With this you get detailed control of the resulting permissions, compared to use of the POSIX permissions described above, and no additional permissions will be added automatically for compatibility with Unix. Some example use cases will following.

If you set POSIX permissions for only allowing access to the owner, using --file-perms 0600 --dir-perms 0700, the user group and the built-in "Everyone" group will still be given some special permissions, as described above. Some programs may then (incorrectly) interpret this as the file being accessible by everyone, for example an SSH client may warn about "unprotected private key file". You can work around this by specifying -o FileSecurity="D:P(A;;FA;;;OW)", which sets file all access (FA) to the owner (OW), and nothing else.

When setting write permissions then, except for the owner, this does not include the "write extended attributes" permission, as mentioned above. This may prevent applications from writing to files, giving permission denied error instead. To set working write permissions for the built-in "Everyone" group, similar to what it gets by default but with the addition of the "write extended attributes", you can specify -o FileSecurity="D:P(A;;FRFW;;;WD)", which sets file read (FR) and file write (FW) to everyone (WD). If file execute (FX) is also needed, then change to -o FileSecurity="D:P(A;;FRFWFX;;;WD)", or set file all access (FA) to get full access permissions, including delete, with -o FileSecurity="D:P(A;;FA;;;WD)".

Windows caveats

Drives created as Administrator are not visible to other accounts, not even an account that was elevated to Administrator with the User Account Control (UAC) feature. A result of this is that if you mount to a drive letter from a Command Prompt run as Administrator, and then try to access the same drive from Windows Explorer (which does not run as Administrator), you will not be able to see the mounted drive.

If you don't need to access the drive from applications running with administrative privileges, the easiest way around this is to always create the mount from a non-elevated command prompt.

To make mapped drives available to the user account that created them regardless if elevated or not, there is a special Windows setting called linked connections that can be enabled.

It is also possible to make a drive mount available to everyone on the system, by running the process creating it as the built-in SYSTEM account. There are several ways to do this: One is to use the command-line utility PsExec, from Microsoft's Sysinternals suite, which has option -s to start processes as the SYSTEM account. Another alternative is to run the mount command from a Windows Scheduled Task, or a Windows Service, configured to run as the SYSTEM account. A third alternative is to use the WinFsp.Launcher infrastructure). Read more in the install documentation. Note that when running rclone as another user, it will not use the configuration file from your profile unless you tell it to with the --config option. Note also that it is now the SYSTEM account that will have the owner permissions, and other accounts will have permissions according to the group or others scopes. As mentioned above, these will then not get the "write extended attributes" permission, and this may prevent writing to files. You can work around this with the FileSecurity option, see example above.

Note that mapping to a directory path, instead of a drive letter, does not suffer from the same limitations.

Mounting on macOS

Mounting on macOS can be done either via built-in NFS server, macFUSE (also known as osxfuse) or FUSE-T. macFUSE is a traditional FUSE driver utilizing a macOS kernel extension (kext). FUSE-T is an alternative FUSE system which "mounts" via an NFSv4 local server.

Unicode Normalization

It is highly recommended to keep the default of --no-unicode-normalization=false for all mount and serve commands on macOS. For details, see vfs-case-sensitivity.

NFS mount

This method spins up an NFS server using serve nfs command and mounts it to the specified mountpoint. If you run this in background mode using |--daemon|, you will need to send SIGTERM signal to the rclone process using |kill| command to stop the mount.

Note that --nfs-cache-handle-limit controls the maximum number of cached file handles stored by the nfsmount caching handler. This should not be set too low or you may experience errors when trying to access files. The default is 1000000, but consider lowering this limit if the server's system resource usage causes problems.

macFUSE Notes

If installing macFUSE using dmg packages from the website, rclone will locate the macFUSE libraries without any further intervention. If however, macFUSE is installed using the macports package manager, the following addition steps are required.

sudo mkdir /usr/local/lib
cd /usr/local/lib
sudo ln -s /opt/local/lib/libfuse.2.dylib

FUSE-T Limitations, Caveats, and Notes

There are some limitations, caveats, and notes about how it works. These are current as of FUSE-T version 1.0.14.

ModTime update on read

As per the FUSE-T wiki:

File access and modification times cannot be set separately as it seems to be an issue with the NFS client which always modifies both. Can be reproduced with 'touch -m' and 'touch -a' commands

This means that viewing files with various tools, notably macOS Finder, will cause rlcone to update the modification time of the file. This may make rclone upload a full new copy of the file.

Read Only mounts

When mounting with --read-only, attempts to write to files will fail silently as opposed to with a clear warning as in macFUSE.

Limitations

Without the use of --vfs-cache-mode this can only write files sequentially, it can only seek when reading. This means that many applications won't work with their files on an rclone mount without --vfs-cache-mode writes or --vfs-cache-mode full. See the VFS File Caching section for more info. When using NFS mount on macOS, if you don't specify |--vfs-cache-mode| the mount point will be read-only.

Bucket-based remotes - Azure Blob, Swift, S3, Google Cloud Storage and B2 - can't store empty directories. Of these, only Azure Blob, Google Cloud Storage and S3 can preserve them when you add --xxx-directory_markers; otherwise, empty directories will vanish once they drop out of the directory cache.

When rclone mount is invoked on Unix with --daemon flag, the main rclone program will wait for the background mount to become ready or until the timeout specified by the --daemon-wait flag. On Linux it can check mount status using ProcFS so the flag in fact sets maximum time to wait, while the real wait can be less. On macOS / BSD the time to wait is constant and the check is performed only at the end. We advise you to set wait time on macOS reasonably.

Only supported on Linux, FreeBSD, OS X and Windows at the moment.

rclone mount vs rclone sync/copy

File systems expect things to be 100% reliable, whereas cloud storage systems are a long way from 100% reliable. The rclone sync/copy commands cope with this with lots of retries. However rclone mount can't use retries in the same way without making local copies of the uploads. Look at the VFS File Caching for solutions to make mount more reliable.

Attribute caching

You can use the flag --attr-timeout to set the time the kernel caches the attributes (size, modification time, etc.) for directory entries.

The default is 1s which caches files just long enough to avoid too many callbacks to rclone from the kernel.

In theory 0s should be the correct value for filesystems which can change outside the control of the kernel. However this causes quite a few problems such as rclone using too much memory, rclone not serving files to samba and excessive time listing directories.

The kernel can cache the info about a file for the time given by --attr-timeout. You may see corruption if the remote file changes length during this window. It will show up as either a truncated file or a file with garbage on the end. With --attr-timeout 1s this is very unlikely but not impossible. The higher you set --attr-timeout the more likely it is. The default setting of "1s" is the lowest setting which mitigates the problems above.

If you set it higher (10s or 1m say) then the kernel will call back to rclone less often making it more efficient, however there is more chance of the corruption issue above.

If files don't change on the remote outside of the control of rclone then there is no chance of corruption.

This is the same as setting the attr_timeout option in mount.fuse.

Filters

Note that all the rclone filters can be used to select a subset of the files to be visible in the mount.

systemd

When running rclone mount as a systemd service, it is possible to use Type=notify. In this case the service will enter the started state after the mountpoint has been successfully set up. Units having the rclone mount service specified as a requirement will see all files and folders immediately in this mode.

Note that systemd runs mount units without any environment variables including PATH or HOME. This means that tilde (~) expansion will not work and you should provide --config and --cache-dir explicitly as absolute paths via rclone arguments. Since mounting requires the fusermount or fusermount3 program, rclone will use the fallback PATH of /bin:/usr/bin in this scenario. Please ensure that fusermount/fusermount3 is present on this PATH.

Rclone as Unix mount helper

The core Unix program /bin/mount normally takes the -t FSTYPE argument then runs the /sbin/mount.FSTYPE helper program passing it mount options as -o key=val,... or --opt=.... Automount (classic or systemd) behaves in a similar way.

rclone by default expects GNU-style flags --key val. To run it as a mount helper you should symlink rclone binary to /sbin/mount.rclone and optionally /usr/bin/rclonefs, e.g. ln -s /usr/bin/rclone /sbin/mount.rclone. rclone will detect it and translate command-line arguments appropriately.

Now you can run classic mounts like this:

mount sftp1:subdir /mnt/data -t rclone -o vfs_cache_mode=writes,sftp_key_file=/path/to/pem

or create systemd mount units:

# /etc/systemd/system/mnt-data.mount
[Unit]
Description=Mount for /mnt/data
[Mount]
Type=rclone
What=sftp1:subdir
Where=/mnt/data
Options=rw,_netdev,allow_other,args2env,vfs-cache-mode=writes,config=/etc/rclone.conf,cache-dir=/var/rclone

optionally accompanied by systemd automount unit

# /etc/systemd/system/mnt-data.automount
[Unit]
Description=AutoMount for /mnt/data
[Automount]
Where=/mnt/data
TimeoutIdleSec=600
[Install]
WantedBy=multi-user.target

or add in /etc/fstab a line like

sftp1:subdir /mnt/data rclone rw,noauto,nofail,_netdev,x-systemd.automount,args2env,vfs_cache_mode=writes,config=/etc/rclone.conf,cache_dir=/var/cache/rclone 0 0

or use classic Automountd. Remember to provide explicit config=...,cache-dir=... as a workaround for mount units being run without HOME.

Rclone in the mount helper mode will split -o argument(s) by comma, replace _ by - and prepend -- to get the command-line flags. Options containing commas or spaces can be wrapped in single or double quotes. Any inner quotes inside outer quotes of the same type should be doubled.

Mount option syntax includes a few extra options treated specially:

  • env.NAME=VALUE will set an environment variable for the mount process. This helps with Automountd and Systemd.mount which don't allow setting custom environment for mount helpers. Typically you will use env.HTTPS_PROXY=proxy.host:3128 or env.HOME=/root
  • command=cmount can be used to run cmount or any other rclone command rather than the default mount.
  • args2env will pass mount options to the mount helper running in background via environment variables instead of command line arguments. This allows to hide secrets from such commands as ps or pgrep.
  • vv... will be transformed into appropriate --verbose=N
  • standard mount options like x-systemd.automount, _netdev, nosuid and alike are intended only for Automountd and ignored by rclone.

VFS - Virtual File System

This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system.

Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below.

The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory.

VFS Directory Cache

Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache.

--dir-cache-time duration   Time to cache directory entries for (default 5m0s)
--poll-interval duration    Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s)

However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval.

You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this:

kill -SIGHUP $(pidof rclone)

If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache:

rclone rc vfs/forget

Or individual files or directories:

rclone rc vfs/forget file=path/to/file dir=path/to/dir

VFS File Buffering

The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance.

Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared.

This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used.

The maximum memory used by rclone for buffering can be up to --buffer-size * open files.

VFS File Caching

These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility.

For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details.

Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both.

--cache-dir string                     Directory rclone will use for caching.
--vfs-cache-mode CacheMode             Cache mode off|minimal|writes|full (default off)
--vfs-cache-max-age duration           Max time since last access of objects in the cache (default 1h0m0s)
--vfs-cache-max-size SizeSuffix        Max total size of objects in the cache (default off)
--vfs-cache-min-free-space SizeSuffix  Target minimum free space on the disk containing the cache (default off)
--vfs-cache-poll-interval duration     Interval to poll the cache for stale objects (default 1m0s)
--vfs-write-back duration              Time to writeback files after last use when using cache (default 5s)

If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable.

The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space.

Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags.

If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached.

The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w .

You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap.

--vfs-cache-mode off

In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk.

This will mean some operations are not possible

  • Files can't be opened for both read AND write
  • Files opened for write can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files open for read with O_TRUNC will be opened write only
  • Files open for write only will behave as if O_TRUNC was supplied
  • Open modes O_APPEND, O_TRUNC are ignored
  • If an upload fails it can't be retried

--vfs-cache-mode minimal

This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space.

These operations are not possible

  • Files opened for write only can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files opened for write only will ignore O_APPEND, O_TRUNC
  • If an upload fails it can't be retried

--vfs-cache-mode writes

In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first.

This mode should support all normal file system operations.

If an upload fails it will be retried at exponentially increasing intervals up to 1 minute.

--vfs-cache-mode full

In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well.

In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded.

So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them.

This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes.

When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk.

When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required.

IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected.

Fingerprinting

Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from:

  • size
  • modification time
  • hash

where available on an object.

On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object).

For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it.

If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files.

If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended.

Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again.

VFS Chunked Reading

When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests.

These flags control the chunking:

--vfs-read-chunk-size SizeSuffix        Read the source objects in chunks (default 128M)
--vfs-read-chunk-size-limit SizeSuffix  Max chunk doubling size (default off)
--vfs-read-chunk-streams int            The number of parallel streams to read at once

The chunking behaves differently depending on the --vfs-read-chunk-streams parameter.

--vfs-read-chunk-streams == 0

Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely.

With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on.

Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading.

The chunks will not be buffered in memory.

--vfs-read-chunk-streams > 0

Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant.

This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores.

Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend.

For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting.

Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput.

VFS Performance

These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature.

In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction.

--no-checksum     Don't compare checksums on up/download.
--no-modtime      Don't read/write the modification time (can speed things up).
--no-seek         Don't allow seeking in files.
--read-only       Only allow read-only access.

Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file.

--vfs-read-wait duration   Time to wait for in-sequence read before seeking (default 20ms)
--vfs-write-wait duration  Time to wait for in-sequence write before giving error (default 1s)

When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS).

--transfers int  Number of file transfers to run in parallel (default 4)

By default the VFS does not support symlinks. However this may be enabled with either of the following flags:

--links      Translate symlinks to/from regular files with a '.rclonelink' extension.
--vfs-links  Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS

As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination.

Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer.

This scheme is compatible with that used by the local backend with the --local-links flag.

The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs.

It hasn't been tested with the other rclone serve commands yet.

A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree

.
├── dir
│   └── file.txt
└── linked-dir -> dir

The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands.

Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa).

VFS Case Sensitivity

Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file.

File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case.

Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default.

The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below.

The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote.

Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target.

If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true".

The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues.

In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync.

VFS Disk Options

This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically.

--vfs-disk-space-total-size    Manually set the total disk space size (example: 256G, default: -1)

Alternate report of used bytes

Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself.

WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching.

VFS Metadata

If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires.

Note that some backends won't create metadata unless you pass in the --metadata flag.

For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get

$ ls -l /mnt/
total 1048577
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G

$ cat /mnt/1G.metadata
{
        "atime": "2025-03-04T17:34:22.317069787Z",
        "btime": "2025-03-03T16:03:37.708253808Z",
        "gid": "1000",
        "mode": "100664",
        "mtime": "2025-03-03T16:03:39.640238323Z",
        "uid": "1000"
}

$ ls -l /mnt/
total 1048578
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G
-rw-rw-r-- 1 user user        185 Mar  3 16:03 1G.metadata

If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}.

rclone mount remote:path /path/to/mountpoint [flags]

Options

      --allow-non-empty                        Allow mounting over a non-empty directory (not supported on Windows)
      --allow-other                            Allow access to other users (not supported on Windows)
      --allow-root                             Allow access to root user (not supported on Windows)
      --async-read                             Use asynchronous reads (not supported on Windows) (default true)
      --attr-timeout Duration                  Time for which file/directory attributes are cached (default 1s)
      --daemon                                 Run mount in background and exit parent process (as background output is suppressed, use --log-file with --log-format=pid,... to monitor) (not supported on Windows)
      --daemon-timeout Duration                Time limit for rclone to respond to kernel (not supported on Windows) (default 0s)
      --daemon-wait Duration                   Time to wait for ready mount from daemon (maximum time on Linux, constant sleep time on OSX/BSD) (not supported on Windows) (default 1m0s)
      --debug-fuse                             Debug the FUSE internals - needs -v
      --default-permissions                    Makes kernel enforce access control based on the file mode (not supported on Windows)
      --devname string                         Set the device name - default is remote:path
      --dir-cache-time Duration                Time to cache directory entries for (default 5m0s)
      --dir-perms FileMode                     Directory permissions (default 777)
      --direct-io                              Use Direct IO, disables caching of data
      --file-perms FileMode                    File permissions (default 666)
      --fuse-flag stringArray                  Flags or arguments to be passed direct to libfuse/WinFsp (repeat if required)
      --gid uint32                             Override the gid field set by the filesystem (not supported on Windows) (default 1000)
  -h, --help                                   help for mount
      --link-perms FileMode                    Link permissions (default 666)
      --max-read-ahead SizeSuffix              The number of bytes that can be prefetched for sequential reads (not supported on Windows) (default 128Ki)
      --mount-case-insensitive Tristate        Tell the OS the mount is case insensitive (true) or sensitive (false) regardless of the backend (auto) (default unset)
      --network-mode                           Mount as remote network drive, instead of fixed disk drive (supported on Windows only)
      --no-checksum                            Don't compare checksums on up/download
      --no-modtime                             Don't read/write the modification time (can speed things up)
      --no-seek                                Don't allow seeking in files
      --noappledouble                          Ignore Apple Double (._) and .DS_Store files (supported on OSX only) (default true)
      --noapplexattr                           Ignore all "com.apple.*" extended attributes (supported on OSX only)
  -o, --option stringArray                     Option for libfuse/WinFsp (repeat if required)
      --poll-interval Duration                 Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s)
      --read-only                              Only allow read-only access
      --uid uint32                             Override the uid field set by the filesystem (not supported on Windows) (default 1000)
      --umask FileMode                         Override the permission bits set by the filesystem (not supported on Windows) (default 002)
      --vfs-block-norm-dupes                   If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost)
      --vfs-cache-max-age Duration             Max time since last access of objects in the cache (default 1h0m0s)
      --vfs-cache-max-size SizeSuffix          Max total size of objects in the cache (default off)
      --vfs-cache-min-free-space SizeSuffix    Target minimum free space on the disk containing the cache (default off)
      --vfs-cache-mode CacheMode               Cache mode off|minimal|writes|full (default off)
      --vfs-cache-poll-interval Duration       Interval to poll the cache for stale objects (default 1m0s)
      --vfs-case-insensitive                   If a file name not found, find a case insensitive match
      --vfs-disk-space-total-size SizeSuffix   Specify the total space of disk (default off)
      --vfs-fast-fingerprint                   Use fast (less accurate) fingerprints for change detection
      --vfs-links                              Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS
      --vfs-metadata-extension string          Set the extension to read metadata from
      --vfs-read-ahead SizeSuffix              Extra read ahead over --buffer-size when using cache-mode full
      --vfs-read-chunk-size SizeSuffix         Read the source objects in chunks (default 128Mi)
      --vfs-read-chunk-size-limit SizeSuffix   If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off)
      --vfs-read-chunk-streams int             The number of parallel streams to read at once
      --vfs-read-wait Duration                 Time to wait for in-sequence read before seeking (default 20ms)
      --vfs-refresh                            Refreshes the directory cache recursively in the background on start
      --vfs-used-is-size rclone size           Use the rclone size algorithm for Used size
      --vfs-write-back Duration                Time to writeback files after last use when using cache (default 5s)
      --vfs-write-wait Duration                Time to wait for in-sequence write before giving error (default 1s)
      --volname string                         Set the volume name (supported on Windows and OSX only)
      --write-back-cache                       Makes kernel buffer writes before sending them to rclone (without this, writethrough caching is used) (not supported on Windows)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone moveto

Move file or directory from source to dest.

Synopsis

If source:path is a file or directory then it moves it to a file or directory named dest:path.

This can be used to rename files or upload single files to other than their existing name. If the source is a directory then it acts exactly like the move command.

So

rclone moveto src dst

where src and dst are rclone paths, either remote:path or /path/to/local or C:.

This will:

if src is file
    move it to dst, overwriting an existing file if it exists
if src is directory
    move it to dst, overwriting existing files if they exist
    see move command for full details

This doesn't transfer files that are identical on src and dst, testing by size and modification time or MD5SUM. src will be deleted on successful transfer.

Important: Since this can cause data loss, test first with the --dry-run or the --interactive/-i flag.

Note: Use the -P/--progress flag to view real-time transfer statistics.

Logger Flags

The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different.

The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files.

  • = path means path was found in source and destination and was identical
  • - path means path was missing on the source, so only in the destination
  • + path means path was missing on the destination, so only in the source
  • * path means path was present in source and destination but different.
  • ! path means there was an error reading or hashing the source or dest.

The --dest-after flag writes a list file using the same format flags as lsf (including customizable options for hash, modtime, etc.) Conceptually it is similar to rsync's --itemize-changes, but not identical -- it should output an accurate list of what will be on the destination after the command is finished.

When the --no-traverse flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing.

Note that these logger flags have a few limitations, and certain scenarios are not currently supported:

  • --max-duration / CutoffModeHard
  • --compare-dest / --copy-dest
  • server-side moves of an entire dir at once
  • High-level retries, because there would be duplicates (use --retries 1 to disable)
  • Possibly some unusual error scenarios

Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.)

rclone moveto source:path dest:path [flags]

Options

      --absolute                Put a leading / in front of path names
      --combined string         Make a combined report of changes to this file
      --csv                     Output in CSV format
      --dest-after string       Report all files that exist on the dest post-sync
      --differ string           Report all non-matching files to this file
  -d, --dir-slash               Append a slash to directory names (default true)
      --dirs-only               Only list directories
      --error string            Report all files with errors (hashing or reading) to this file
      --files-only              Only list files (default true)
  -F, --format string           Output format - see lsf help for details (default "p")
      --hash h                  Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5")
  -h, --help                    help for moveto
      --match string            Report all matching files to this file
      --missing-on-dst string   Report all files missing from the destination to this file
      --missing-on-src string   Report all files missing from the source to this file
  -s, --separator string        Separator for the items in the format (default ";")
  -t, --timeformat string       Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Copy Options

Flags for anything which can copy a file

      --check-first                                 Do all the checks before starting transfers
  -c, --checksum                                    Check for changes with size & checksum (if available, or fallback to size only)
      --compare-dest stringArray                    Include additional server-side paths during comparison
      --copy-dest stringArray                       Implies --compare-dest but also copies files from paths into destination
      --cutoff-mode HARD|SOFT|CAUTIOUS              Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD)
      --ignore-case-sync                            Ignore case when synchronizing
      --ignore-checksum                             Skip post copy check of checksums
      --ignore-existing                             Skip all files that exist on destination
      --ignore-size                                 Ignore size when skipping use modtime or checksum
  -I, --ignore-times                                Don't skip items that match size and time - transfer all unconditionally
      --immutable                                   Do not modify files, fail if existing files have been modified
      --inplace                                     Download directly to destination file instead of atomic download to temp/rename
  -l, --links                                       Translate symlinks to/from regular files with a '.rclonelink' extension
      --max-backlog int                             Maximum number of objects in sync or check backlog (default 10000)
      --max-duration Duration                       Maximum duration rclone will transfer data for (default 0s)
      --max-transfer SizeSuffix                     Maximum size of data to transfer (default off)
  -M, --metadata                                    If set, preserve metadata when copying objects
      --modify-window Duration                      Max time diff to be considered the same (default 1ns)
      --multi-thread-chunk-size SizeSuffix          Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi)
      --multi-thread-cutoff SizeSuffix              Use multi-thread downloads for files above this size (default 256Mi)
      --multi-thread-streams int                    Number of streams to use for multi-thread downloads (default 4)
      --multi-thread-write-buffer-size SizeSuffix   In memory buffer size for writing when in multi-thread mode (default 128Ki)
      --name-transform stringArray                  Transform paths during the copy process
      --no-check-dest                               Don't check the destination, copy regardless
      --no-traverse                                 Don't traverse destination file system on copy
      --no-update-dir-modtime                       Don't update directory modification times
      --no-update-modtime                           Don't update destination modtime if files identical
      --order-by string                             Instructions on how to order the transfers, e.g. 'size,descending'
      --partial-suffix string                       Add partial-suffix to temporary file name when --inplace is not used (default ".partial")
      --refresh-times                               Refresh the modtime of remote files
      --server-side-across-configs                  Allow server-side operations (e.g. copy) to work across different configs
      --size-only                                   Skip based on size only, not modtime or checksum
      --streaming-upload-cutoff SizeSuffix          Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki)
  -u, --update                                      Skip files that are newer on the destination

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone ncdu

Explore a remote with a text based user interface.

Synopsis

This displays a text based user interface allowing the navigation of a remote. It is most useful for answering the question - "What is using all my disk space?".

To make the user interface it first scans the entire remote given and builds an in memory representation. rclone ncdu can be used during this scanning phase and you will see it building up the directory structure as it goes along.

You can interact with the user interface using key presses, press '?' to toggle the help on and off. The supported keys are:

 ↑,↓ or k,j to Move
 →,l to enter
 ←,h to return
 g toggle graph
 c toggle counts
 a toggle average size in directory
 m toggle modified time
 u toggle human-readable format
 n,s,C,A,M sort by name,size,count,asize,mtime
 d delete file/directory
 v select file/directory
 V enter visual select mode
 D delete selected files/directories
 y copy current path to clipboard
 Y display current path
 ^L refresh screen (fix screen corruption)
 r recalculate file sizes
 ? to toggle help on and off
 ESC to close the menu box
 q/^c to quit

Listed files/directories may be prefixed by a one-character flag, some of them combined with a description in brackets at end of line. These flags have the following meaning:

e means this is an empty directory, i.e. contains no files (but
  may contain empty subdirectories)
~ means this is a directory where some of the files (possibly in
  subdirectories) have unknown size, and therefore the directory
  size may be underestimated (and average size inaccurate, as it
  is average of the files with known sizes).
. means an error occurred while reading a subdirectory, and
  therefore the directory size may be underestimated (and average
  size inaccurate)
! means an error occurred while reading this directory

This an homage to the ncdu tool but for rclone remotes. It is missing lots of features at the moment but is useful as it stands. Unlike ncdu it does not show excluded files.

Note that it might take some time to delete big files/directories. The UI won't respond in the meantime since the deletion is done synchronously.

For a non-interactive listing of the remote, see the tree command. To just get the total size of the remote you can also use the size command.

rclone ncdu remote:path [flags]

Options

  -h, --help   help for ncdu

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone nfsmount

Mount the remote as file system on a mountpoint.

Synopsis

Rclone nfsmount allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE.

First set up your remote using rclone config. Check it works with rclone ls etc.

On Linux and macOS, you can run mount in either foreground or background (aka daemon) mode. Mount runs in foreground mode by default. Use the --daemon flag to force background mode. On Windows you can run mount in foreground only, the flag is ignored.

In background mode rclone acts as a generic Unix mount program: the main program starts, spawns background rclone process to setup and maintain the mount, waits until success or timeout and exits with appropriate code (killing the child process if it fails).

On Linux/macOS/FreeBSD start the mount like this, where /path/to/local/mount is an empty existing directory:

rclone nfsmount remote:path/to/files /path/to/local/mount

On Windows you can start a mount in different ways. See below for details. If foreground mount is used interactively from a console window, rclone will serve the mount and occupy the console so another window should be used to work with the mount until rclone is interrupted e.g. by pressing Ctrl-C.

The following examples will mount to an automatically assigned drive, to specific drive letter X:, to path C:\path\parent\mount (where parent directory or drive must exist, and mount must not exist, and is not supported when mounting as a network drive), and the last example will mount as network share \\cloud\remote and map it to an automatically assigned drive:

rclone nfsmount remote:path/to/files *
rclone nfsmount remote:path/to/files X:
rclone nfsmount remote:path/to/files C:\path\parent\mount
rclone nfsmount remote:path/to/files \\cloud\remote

When the program ends while in foreground mode, either via Ctrl+C or receiving a SIGINT or SIGTERM signal, the mount should be automatically stopped.

When running in background mode the user will have to stop the mount manually:

# Linux
fusermount -u /path/to/local/mount
#... or on some systems
fusermount3 -u /path/to/local/mount
# OS X or Linux when using nfsmount
umount /path/to/local/mount

The umount operation can fail, for example when the mountpoint is busy. When that happens, it is the user's responsibility to stop the mount manually.

The size of the mounted file system will be set according to information retrieved from the remote, the same as returned by the rclone about command. Remotes with unlimited storage may report the used size only, then an additional 1 PiB of free space is assumed. If the remote does not support the about feature at all, then 1 PiB is set as both the total and the free size.

Installing on Windows

To run rclone nfsmount on Windows, you will need to download and install WinFsp.

WinFsp is an open-source Windows File System Proxy which makes it easy to write user space file systems for Windows. It provides a FUSE emulation layer which rclone uses combination with cgofuse. Both of these packages are by Bill Zissimopoulos who was very helpful during the implementation of rclone nfsmount for Windows.

Mounting modes on windows

Unlike other operating systems, Microsoft Windows provides a different filesystem type for network and fixed drives. It optimises access on the assumption fixed disk drives are fast and reliable, while network drives have relatively high latency and less reliability. Some settings can also be differentiated between the two types, for example that Windows Explorer should just display icons and not create preview thumbnails for image and video files on network drives.

In most cases, rclone will mount the remote as a normal, fixed disk drive by default. However, you can also choose to mount it as a remote network drive, often described as a network share. If you mount an rclone remote using the default, fixed drive mode and experience unexpected program errors, freezes or other issues, consider mounting as a network drive instead.

When mounting as a fixed disk drive you can either mount to an unused drive letter, or to a path representing a nonexistent subdirectory of an existing parent directory or drive. Using the special value * will tell rclone to automatically assign the next available drive letter, starting with Z: and moving backward. Examples:

rclone nfsmount remote:path/to/files *
rclone nfsmount remote:path/to/files X:
rclone nfsmount remote:path/to/files C:\path\parent\mount
rclone nfsmount remote:path/to/files X:

Option --volname can be used to set a custom volume name for the mounted file system. The default is to use the remote name and path.

To mount as network drive, you can add option --network-mode to your nfsmount command. Mounting to a directory path is not supported in this mode, it is a limitation Windows imposes on junctions, so the remote must always be mounted to a drive letter.

rclone nfsmount remote:path/to/files X: --network-mode

A volume name specified with --volname will be used to create the network share path. A complete UNC path, such as \\cloud\remote, optionally with path \\cloud\remote\madeup\path, will be used as is. Any other string will be used as the share part, after a default prefix \\server\. If no volume name is specified then \\server\share will be used. You must make sure the volume name is unique when you are mounting more than one drive, or else the mount command will fail. The share name will treated as the volume label for the mapped drive, shown in Windows Explorer etc, while the complete \\server\share will be reported as the remote UNC path by net use etc, just like a normal network drive mapping.

If you specify a full network share UNC path with --volname, this will implicitly set the --network-mode option, so the following two examples have same result:

rclone nfsmount remote:path/to/files X: --network-mode
rclone nfsmount remote:path/to/files X: --volname \\server\share

You may also specify the network share UNC path as the mountpoint itself. Then rclone will automatically assign a drive letter, same as with * and use that as mountpoint, and instead use the UNC path specified as the volume name, as if it were specified with the --volname option. This will also implicitly set the --network-mode option. This means the following two examples have same result:

rclone nfsmount remote:path/to/files \\cloud\remote
rclone nfsmount remote:path/to/files * --volname \\cloud\remote

There is yet another way to enable network mode, and to set the share path, and that is to pass the "native" libfuse/WinFsp option directly: --fuse-flag --VolumePrefix=\server\share. Note that the path must be with just a single backslash prefix in this case.

Note: In previous versions of rclone this was the only supported method.

Read more about drive mapping

See also Limitations section below.

Windows filesystem permissions

The FUSE emulation layer on Windows must convert between the POSIX-based permission model used in FUSE, and the permission model used in Windows, based on access-control lists (ACL).

The mounted filesystem will normally get three entries in its access-control list (ACL), representing permissions for the POSIX permission scopes: Owner, group and others. By default, the owner and group will be taken from the current user, and the built-in group "Everyone" will be used to represent others. The user/group can be customized with FUSE options "UserName" and "GroupName", e.g. -o UserName=user123 -o GroupName="Authenticated Users". The permissions on each entry will be set according to options --dir-perms and --file-perms, which takes a value in traditional Unix numeric notation.

The default permissions corresponds to --file-perms 0666 --dir-perms 0777, i.e. read and write permissions to everyone. This means you will not be able to start any programs from the mount. To be able to do that you must add execute permissions, e.g. --file-perms 0777 --dir-perms 0777 to add it to everyone. If the program needs to write files, chances are you will have to enable VFS File Caching as well (see also limitations). Note that the default write permission have some restrictions for accounts other than the owner, specifically it lacks the "write extended attributes", as explained next.

The mapping of permissions is not always trivial, and the result you see in Windows Explorer may not be exactly like you expected. For example, when setting a value that includes write access for the group or others scope, this will be mapped to individual permissions "write attributes", "write data" and "append data", but not "write extended attributes". Windows will then show this as basic permission "Special" instead of "Write", because "Write" also covers the "write extended attributes" permission. When setting digit 0 for group or others, to indicate no permissions, they will still get individual permissions "read attributes", "read extended attributes" and "read permissions". This is done for compatibility reasons, e.g. to allow users without additional permissions to be able to read basic metadata about files like in Unix.

WinFsp 2021 (version 1.9) introduced a new FUSE option "FileSecurity", that allows the complete specification of file security descriptors using SDDL. With this you get detailed control of the resulting permissions, compared to use of the POSIX permissions described above, and no additional permissions will be added automatically for compatibility with Unix. Some example use cases will following.

If you set POSIX permissions for only allowing access to the owner, using --file-perms 0600 --dir-perms 0700, the user group and the built-in "Everyone" group will still be given some special permissions, as described above. Some programs may then (incorrectly) interpret this as the file being accessible by everyone, for example an SSH client may warn about "unprotected private key file". You can work around this by specifying -o FileSecurity="D:P(A;;FA;;;OW)", which sets file all access (FA) to the owner (OW), and nothing else.

When setting write permissions then, except for the owner, this does not include the "write extended attributes" permission, as mentioned above. This may prevent applications from writing to files, giving permission denied error instead. To set working write permissions for the built-in "Everyone" group, similar to what it gets by default but with the addition of the "write extended attributes", you can specify -o FileSecurity="D:P(A;;FRFW;;;WD)", which sets file read (FR) and file write (FW) to everyone (WD). If file execute (FX) is also needed, then change to -o FileSecurity="D:P(A;;FRFWFX;;;WD)", or set file all access (FA) to get full access permissions, including delete, with -o FileSecurity="D:P(A;;FA;;;WD)".

Windows caveats

Drives created as Administrator are not visible to other accounts, not even an account that was elevated to Administrator with the User Account Control (UAC) feature. A result of this is that if you mount to a drive letter from a Command Prompt run as Administrator, and then try to access the same drive from Windows Explorer (which does not run as Administrator), you will not be able to see the mounted drive.

If you don't need to access the drive from applications running with administrative privileges, the easiest way around this is to always create the mount from a non-elevated command prompt.

To make mapped drives available to the user account that created them regardless if elevated or not, there is a special Windows setting called linked connections that can be enabled.

It is also possible to make a drive mount available to everyone on the system, by running the process creating it as the built-in SYSTEM account. There are several ways to do this: One is to use the command-line utility PsExec, from Microsoft's Sysinternals suite, which has option -s to start processes as the SYSTEM account. Another alternative is to run the mount command from a Windows Scheduled Task, or a Windows Service, configured to run as the SYSTEM account. A third alternative is to use the WinFsp.Launcher infrastructure). Read more in the install documentation. Note that when running rclone as another user, it will not use the configuration file from your profile unless you tell it to with the --config option. Note also that it is now the SYSTEM account that will have the owner permissions, and other accounts will have permissions according to the group or others scopes. As mentioned above, these will then not get the "write extended attributes" permission, and this may prevent writing to files. You can work around this with the FileSecurity option, see example above.

Note that mapping to a directory path, instead of a drive letter, does not suffer from the same limitations.

Mounting on macOS

Mounting on macOS can be done either via built-in NFS server, macFUSE (also known as osxfuse) or FUSE-T. macFUSE is a traditional FUSE driver utilizing a macOS kernel extension (kext). FUSE-T is an alternative FUSE system which "mounts" via an NFSv4 local server.

Unicode Normalization

It is highly recommended to keep the default of --no-unicode-normalization=false for all mount and serve commands on macOS. For details, see vfs-case-sensitivity.

NFS mount

This method spins up an NFS server using serve nfs command and mounts it to the specified mountpoint. If you run this in background mode using |--daemon|, you will need to send SIGTERM signal to the rclone process using |kill| command to stop the mount.

Note that --nfs-cache-handle-limit controls the maximum number of cached file handles stored by the nfsmount caching handler. This should not be set too low or you may experience errors when trying to access files. The default is 1000000, but consider lowering this limit if the server's system resource usage causes problems.

macFUSE Notes

If installing macFUSE using dmg packages from the website, rclone will locate the macFUSE libraries without any further intervention. If however, macFUSE is installed using the macports package manager, the following addition steps are required.

sudo mkdir /usr/local/lib
cd /usr/local/lib
sudo ln -s /opt/local/lib/libfuse.2.dylib

FUSE-T Limitations, Caveats, and Notes

There are some limitations, caveats, and notes about how it works. These are current as of FUSE-T version 1.0.14.

ModTime update on read

As per the FUSE-T wiki:

File access and modification times cannot be set separately as it seems to be an issue with the NFS client which always modifies both. Can be reproduced with 'touch -m' and 'touch -a' commands

This means that viewing files with various tools, notably macOS Finder, will cause rlcone to update the modification time of the file. This may make rclone upload a full new copy of the file.

Read Only mounts

When mounting with --read-only, attempts to write to files will fail silently as opposed to with a clear warning as in macFUSE.

Limitations

Without the use of --vfs-cache-mode this can only write files sequentially, it can only seek when reading. This means that many applications won't work with their files on an rclone mount without --vfs-cache-mode writes or --vfs-cache-mode full. See the VFS File Caching section for more info. When using NFS mount on macOS, if you don't specify |--vfs-cache-mode| the mount point will be read-only.

Bucket-based remotes - Azure Blob, Swift, S3, Google Cloud Storage and B2 - can't store empty directories. Of these, only Azure Blob, Google Cloud Storage and S3 can preserve them when you add --xxx-directory_markers; otherwise, empty directories will vanish once they drop out of the directory cache.

When rclone mount is invoked on Unix with --daemon flag, the main rclone program will wait for the background mount to become ready or until the timeout specified by the --daemon-wait flag. On Linux it can check mount status using ProcFS so the flag in fact sets maximum time to wait, while the real wait can be less. On macOS / BSD the time to wait is constant and the check is performed only at the end. We advise you to set wait time on macOS reasonably.

Only supported on Linux, FreeBSD, OS X and Windows at the moment.

rclone nfsmount vs rclone sync/copy

File systems expect things to be 100% reliable, whereas cloud storage systems are a long way from 100% reliable. The rclone sync/copy commands cope with this with lots of retries. However rclone nfsmount can't use retries in the same way without making local copies of the uploads. Look at the VFS File Caching for solutions to make nfsmount more reliable.

Attribute caching

You can use the flag --attr-timeout to set the time the kernel caches the attributes (size, modification time, etc.) for directory entries.

The default is 1s which caches files just long enough to avoid too many callbacks to rclone from the kernel.

In theory 0s should be the correct value for filesystems which can change outside the control of the kernel. However this causes quite a few problems such as rclone using too much memory, rclone not serving files to samba and excessive time listing directories.

The kernel can cache the info about a file for the time given by --attr-timeout. You may see corruption if the remote file changes length during this window. It will show up as either a truncated file or a file with garbage on the end. With --attr-timeout 1s this is very unlikely but not impossible. The higher you set --attr-timeout the more likely it is. The default setting of "1s" is the lowest setting which mitigates the problems above.

If you set it higher (10s or 1m say) then the kernel will call back to rclone less often making it more efficient, however there is more chance of the corruption issue above.

If files don't change on the remote outside of the control of rclone then there is no chance of corruption.

This is the same as setting the attr_timeout option in mount.fuse.

Filters

Note that all the rclone filters can be used to select a subset of the files to be visible in the mount.

systemd

When running rclone nfsmount as a systemd service, it is possible to use Type=notify. In this case the service will enter the started state after the mountpoint has been successfully set up. Units having the rclone nfsmount service specified as a requirement will see all files and folders immediately in this mode.

Note that systemd runs mount units without any environment variables including PATH or HOME. This means that tilde (~) expansion will not work and you should provide --config and --cache-dir explicitly as absolute paths via rclone arguments. Since mounting requires the fusermount or fusermount3 program, rclone will use the fallback PATH of /bin:/usr/bin in this scenario. Please ensure that fusermount/fusermount3 is present on this PATH.

Rclone as Unix mount helper

The core Unix program /bin/mount normally takes the -t FSTYPE argument then runs the /sbin/mount.FSTYPE helper program passing it mount options as -o key=val,... or --opt=.... Automount (classic or systemd) behaves in a similar way.

rclone by default expects GNU-style flags --key val. To run it as a mount helper you should symlink rclone binary to /sbin/mount.rclone and optionally /usr/bin/rclonefs, e.g. ln -s /usr/bin/rclone /sbin/mount.rclone. rclone will detect it and translate command-line arguments appropriately.

Now you can run classic mounts like this:

mount sftp1:subdir /mnt/data -t rclone -o vfs_cache_mode=writes,sftp_key_file=/path/to/pem

or create systemd mount units:

# /etc/systemd/system/mnt-data.mount
[Unit]
Description=Mount for /mnt/data
[Mount]
Type=rclone
What=sftp1:subdir
Where=/mnt/data
Options=rw,_netdev,allow_other,args2env,vfs-cache-mode=writes,config=/etc/rclone.conf,cache-dir=/var/rclone

optionally accompanied by systemd automount unit

# /etc/systemd/system/mnt-data.automount
[Unit]
Description=AutoMount for /mnt/data
[Automount]
Where=/mnt/data
TimeoutIdleSec=600
[Install]
WantedBy=multi-user.target

or add in /etc/fstab a line like

sftp1:subdir /mnt/data rclone rw,noauto,nofail,_netdev,x-systemd.automount,args2env,vfs_cache_mode=writes,config=/etc/rclone.conf,cache_dir=/var/cache/rclone 0 0

or use classic Automountd. Remember to provide explicit config=...,cache-dir=... as a workaround for mount units being run without HOME.

Rclone in the mount helper mode will split -o argument(s) by comma, replace _ by - and prepend -- to get the command-line flags. Options containing commas or spaces can be wrapped in single or double quotes. Any inner quotes inside outer quotes of the same type should be doubled.

Mount option syntax includes a few extra options treated specially:

  • env.NAME=VALUE will set an environment variable for the mount process. This helps with Automountd and Systemd.mount which don't allow setting custom environment for mount helpers. Typically you will use env.HTTPS_PROXY=proxy.host:3128 or env.HOME=/root
  • command=cmount can be used to run cmount or any other rclone command rather than the default mount.
  • args2env will pass mount options to the mount helper running in background via environment variables instead of command line arguments. This allows to hide secrets from such commands as ps or pgrep.
  • vv... will be transformed into appropriate --verbose=N
  • standard mount options like x-systemd.automount, _netdev, nosuid and alike are intended only for Automountd and ignored by rclone.

VFS - Virtual File System

This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system.

Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below.

The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory.

VFS Directory Cache

Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache.

--dir-cache-time duration   Time to cache directory entries for (default 5m0s)
--poll-interval duration    Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s)

However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval.

You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this:

kill -SIGHUP $(pidof rclone)

If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache:

rclone rc vfs/forget

Or individual files or directories:

rclone rc vfs/forget file=path/to/file dir=path/to/dir

VFS File Buffering

The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance.

Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared.

This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used.

The maximum memory used by rclone for buffering can be up to --buffer-size * open files.

VFS File Caching

These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility.

For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details.

Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both.

--cache-dir string                     Directory rclone will use for caching.
--vfs-cache-mode CacheMode             Cache mode off|minimal|writes|full (default off)
--vfs-cache-max-age duration           Max time since last access of objects in the cache (default 1h0m0s)
--vfs-cache-max-size SizeSuffix        Max total size of objects in the cache (default off)
--vfs-cache-min-free-space SizeSuffix  Target minimum free space on the disk containing the cache (default off)
--vfs-cache-poll-interval duration     Interval to poll the cache for stale objects (default 1m0s)
--vfs-write-back duration              Time to writeback files after last use when using cache (default 5s)

If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable.

The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space.

Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags.

If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached.

The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w .

You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap.

--vfs-cache-mode off

In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk.

This will mean some operations are not possible

  • Files can't be opened for both read AND write
  • Files opened for write can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files open for read with O_TRUNC will be opened write only
  • Files open for write only will behave as if O_TRUNC was supplied
  • Open modes O_APPEND, O_TRUNC are ignored
  • If an upload fails it can't be retried

--vfs-cache-mode minimal

This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space.

These operations are not possible

  • Files opened for write only can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files opened for write only will ignore O_APPEND, O_TRUNC
  • If an upload fails it can't be retried

--vfs-cache-mode writes

In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first.

This mode should support all normal file system operations.

If an upload fails it will be retried at exponentially increasing intervals up to 1 minute.

--vfs-cache-mode full

In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well.

In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded.

So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them.

This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes.

When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk.

When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required.

IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected.

Fingerprinting

Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from:

  • size
  • modification time
  • hash

where available on an object.

On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object).

For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it.

If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files.

If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended.

Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again.

VFS Chunked Reading

When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests.

These flags control the chunking:

--vfs-read-chunk-size SizeSuffix        Read the source objects in chunks (default 128M)
--vfs-read-chunk-size-limit SizeSuffix  Max chunk doubling size (default off)
--vfs-read-chunk-streams int            The number of parallel streams to read at once

The chunking behaves differently depending on the --vfs-read-chunk-streams parameter.

--vfs-read-chunk-streams == 0

Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely.

With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on.

Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading.

The chunks will not be buffered in memory.

--vfs-read-chunk-streams > 0

Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant.

This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores.

Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend.

For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting.

Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput.

VFS Performance

These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature.

In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction.

--no-checksum     Don't compare checksums on up/download.
--no-modtime      Don't read/write the modification time (can speed things up).
--no-seek         Don't allow seeking in files.
--read-only       Only allow read-only access.

Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file.

--vfs-read-wait duration   Time to wait for in-sequence read before seeking (default 20ms)
--vfs-write-wait duration  Time to wait for in-sequence write before giving error (default 1s)

When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS).

--transfers int  Number of file transfers to run in parallel (default 4)

By default the VFS does not support symlinks. However this may be enabled with either of the following flags:

--links      Translate symlinks to/from regular files with a '.rclonelink' extension.
--vfs-links  Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS

As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination.

Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer.

This scheme is compatible with that used by the local backend with the --local-links flag.

The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs.

It hasn't been tested with the other rclone serve commands yet.

A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree

.
├── dir
│   └── file.txt
└── linked-dir -> dir

The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands.

Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa).

VFS Case Sensitivity

Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file.

File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case.

Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default.

The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below.

The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote.

Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target.

If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true".

The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues.

In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync.

VFS Disk Options

This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically.

--vfs-disk-space-total-size    Manually set the total disk space size (example: 256G, default: -1)

Alternate report of used bytes

Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself.

WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching.

VFS Metadata

If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires.

Note that some backends won't create metadata unless you pass in the --metadata flag.

For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get

$ ls -l /mnt/
total 1048577
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G

$ cat /mnt/1G.metadata
{
        "atime": "2025-03-04T17:34:22.317069787Z",
        "btime": "2025-03-03T16:03:37.708253808Z",
        "gid": "1000",
        "mode": "100664",
        "mtime": "2025-03-03T16:03:39.640238323Z",
        "uid": "1000"
}

$ ls -l /mnt/
total 1048578
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G
-rw-rw-r-- 1 user user        185 Mar  3 16:03 1G.metadata

If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}.

rclone nfsmount remote:path /path/to/mountpoint [flags]

Options

      --addr string                            IPaddress:Port or :Port to bind server to
      --allow-non-empty                        Allow mounting over a non-empty directory (not supported on Windows)
      --allow-other                            Allow access to other users (not supported on Windows)
      --allow-root                             Allow access to root user (not supported on Windows)
      --async-read                             Use asynchronous reads (not supported on Windows) (default true)
      --attr-timeout Duration                  Time for which file/directory attributes are cached (default 1s)
      --daemon                                 Run mount in background and exit parent process (as background output is suppressed, use --log-file with --log-format=pid,... to monitor) (not supported on Windows)
      --daemon-timeout Duration                Time limit for rclone to respond to kernel (not supported on Windows) (default 0s)
      --daemon-wait Duration                   Time to wait for ready mount from daemon (maximum time on Linux, constant sleep time on OSX/BSD) (not supported on Windows) (default 1m0s)
      --debug-fuse                             Debug the FUSE internals - needs -v
      --default-permissions                    Makes kernel enforce access control based on the file mode (not supported on Windows)
      --devname string                         Set the device name - default is remote:path
      --dir-cache-time Duration                Time to cache directory entries for (default 5m0s)
      --dir-perms FileMode                     Directory permissions (default 777)
      --direct-io                              Use Direct IO, disables caching of data
      --file-perms FileMode                    File permissions (default 666)
      --fuse-flag stringArray                  Flags or arguments to be passed direct to libfuse/WinFsp (repeat if required)
      --gid uint32                             Override the gid field set by the filesystem (not supported on Windows) (default 1000)
  -h, --help                                   help for nfsmount
      --link-perms FileMode                    Link permissions (default 666)
      --max-read-ahead SizeSuffix              The number of bytes that can be prefetched for sequential reads (not supported on Windows) (default 128Ki)
      --mount-case-insensitive Tristate        Tell the OS the mount is case insensitive (true) or sensitive (false) regardless of the backend (auto) (default unset)
      --network-mode                           Mount as remote network drive, instead of fixed disk drive (supported on Windows only)
      --nfs-cache-dir string                   The directory the NFS handle cache will use if set
      --nfs-cache-handle-limit int             max file handles cached simultaneously (min 5) (default 1000000)
      --nfs-cache-type memory|disk|symlink     Type of NFS handle cache to use (default memory)
      --no-checksum                            Don't compare checksums on up/download
      --no-modtime                             Don't read/write the modification time (can speed things up)
      --no-seek                                Don't allow seeking in files
      --noappledouble                          Ignore Apple Double (._) and .DS_Store files (supported on OSX only) (default true)
      --noapplexattr                           Ignore all "com.apple.*" extended attributes (supported on OSX only)
  -o, --option stringArray                     Option for libfuse/WinFsp (repeat if required)
      --poll-interval Duration                 Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s)
      --read-only                              Only allow read-only access
      --sudo                                   Use sudo to run the mount/umount commands as root.
      --uid uint32                             Override the uid field set by the filesystem (not supported on Windows) (default 1000)
      --umask FileMode                         Override the permission bits set by the filesystem (not supported on Windows) (default 002)
      --vfs-block-norm-dupes                   If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost)
      --vfs-cache-max-age Duration             Max time since last access of objects in the cache (default 1h0m0s)
      --vfs-cache-max-size SizeSuffix          Max total size of objects in the cache (default off)
      --vfs-cache-min-free-space SizeSuffix    Target minimum free space on the disk containing the cache (default off)
      --vfs-cache-mode CacheMode               Cache mode off|minimal|writes|full (default off)
      --vfs-cache-poll-interval Duration       Interval to poll the cache for stale objects (default 1m0s)
      --vfs-case-insensitive                   If a file name not found, find a case insensitive match
      --vfs-disk-space-total-size SizeSuffix   Specify the total space of disk (default off)
      --vfs-fast-fingerprint                   Use fast (less accurate) fingerprints for change detection
      --vfs-links                              Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS
      --vfs-metadata-extension string          Set the extension to read metadata from
      --vfs-read-ahead SizeSuffix              Extra read ahead over --buffer-size when using cache-mode full
      --vfs-read-chunk-size SizeSuffix         Read the source objects in chunks (default 128Mi)
      --vfs-read-chunk-size-limit SizeSuffix   If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off)
      --vfs-read-chunk-streams int             The number of parallel streams to read at once
      --vfs-read-wait Duration                 Time to wait for in-sequence read before seeking (default 20ms)
      --vfs-refresh                            Refreshes the directory cache recursively in the background on start
      --vfs-used-is-size rclone size           Use the rclone size algorithm for Used size
      --vfs-write-back Duration                Time to writeback files after last use when using cache (default 5s)
      --vfs-write-wait Duration                Time to wait for in-sequence write before giving error (default 1s)
      --volname string                         Set the volume name (supported on Windows and OSX only)
      --write-back-cache                       Makes kernel buffer writes before sending them to rclone (without this, writethrough caching is used) (not supported on Windows)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone obscure

Obscure password for use in the rclone config file.

Synopsis

In the rclone config file, human-readable passwords are obscured. Obscuring them is done by encrypting them and writing them out in base64. This is not a secure way of encrypting these passwords as rclone can decrypt them - it is to prevent "eyedropping" - namely someone seeing a password in the rclone config file by accident.

Many equally important things (like access tokens) are not obscured in the config file. However it is very hard to shoulder surf a 64 character hex token.

This command can also accept a password through STDIN instead of an argument by passing a hyphen as an argument. This will use the first line of STDIN as the password not including the trailing newline.

echo "secretpassword" | rclone obscure -

If there is no data on STDIN to read, rclone obscure will default to obfuscating the hyphen itself.

If you want to encrypt the config file then please use config file encryption - see rclone config for more info.

rclone obscure password [flags]

Options

  -h, --help   help for obscure

See the global flags page for global options not listed here.

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone rc

Run a command against a running rclone.

Synopsis

This runs a command against a running rclone. Use the --url flag to specify an non default URL to connect on. This can be either a ":port" which is taken to mean "http://localhost:port" or a "host:port" which is taken to mean "http://host:port"

A username and password can be passed in with --user and --pass.

Note that --rc-addr, --rc-user, --rc-pass will be read also for --url, --user, --pass.

The --unix-socket flag can be used to connect over a unix socket like this

# start server on /tmp/my.socket
rclone rcd --rc-addr unix:///tmp/my.socket
# Connect to it
rclone rc --unix-socket /tmp/my.socket core/stats

Arguments should be passed in as parameter=value.

The result will be returned as a JSON object by default.

The --json parameter can be used to pass in a JSON blob as an input instead of key=value arguments. This is the only way of passing in more complicated values.

The -o/--opt option can be used to set a key "opt" with key, value options in the form -o key=value or -o key. It can be repeated as many times as required. This is useful for rc commands which take the "opt" parameter which by convention is a dictionary of strings.

-o key=value -o key2

Will place this in the "opt" value

{"key":"value", "key2","")

The -a/--arg option can be used to set strings in the "arg" value. It can be repeated as many times as required. This is useful for rc commands which take the "arg" parameter which by convention is a list of strings.

-a value -a value2

Will place this in the "arg" value

["value", "value2"]

Use --loopback to connect to the rclone instance running rclone rc. This is very useful for testing commands without having to run an rclone rc server, e.g.:

rclone rc --loopback operations/about fs=/

Use rclone rc to see a list of all possible commands.

rclone rc commands parameter [flags]

Options

  -a, --arg stringArray      Argument placed in the "arg" array
  -h, --help                 help for rc
      --json string          Input JSON - use instead of key=value args
      --loopback             If set connect to this rclone instance not via HTTP
      --no-output            If set, don't output the JSON result
  -o, --opt stringArray      Option in the form name=value or name placed in the "opt" array
      --pass string          Password to use to connect to rclone remote control
      --unix-socket string   Path to a unix domain socket to dial to, instead of opening a TCP connection directly
      --url string           URL to connect to rclone remote control (default "http://localhost:5572/")
      --user string          Username to use to rclone remote control

See the global flags page for global options not listed here.

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone rcat

Copies standard input to file on remote.

Synopsis

Reads from standard input (stdin) and copies it to a single remote file.

echo "hello world" | rclone rcat remote:path/to/file
ffmpeg - | rclone rcat remote:path/to/file

If the remote file already exists, it will be overwritten.

rcat will try to upload small files in a single request, which is usually more efficient than the streaming/chunked upload endpoints, which use multiple requests. Exact behaviour depends on the remote. What is considered a small file may be set through --streaming-upload-cutoff. Uploading only starts after the cutoff is reached or if the file ends before that. The data must fit into RAM. The cutoff needs to be small enough to adhere the limits of your remote, please see there. Generally speaking, setting this cutoff too high will decrease your performance.

Use the --size flag to preallocate the file in advance at the remote end and actually stream it, even if remote backend doesn't support streaming.

--size should be the exact size of the input stream in bytes. If the size of the stream is different in length to the --size passed in then the transfer will likely fail.

Note that the upload cannot be retried because the data is not stored. If the backend supports multipart uploading then individual chunks can be retried. If you need to transfer a lot of data, you may be better off caching it locally and then rclone move it to the destination which can use retries.

rclone rcat remote:path [flags]

Options

  -h, --help       help for rcat
      --size int   File size hint to preallocate (default -1)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone rcd

Run rclone listening to remote control commands only.

Synopsis

This runs rclone so that it only listens to remote control commands.

This is useful if you are controlling rclone via the rc API.

If you pass in a path to a directory, rclone will serve that directory for GET requests on the URL passed in. It will also open the URL in the browser when rclone is run.

See the rc documentation for more info on the rc flags.

Server options

Use --rc-addr to specify which IP address and port the server should listen on, eg --rc-addr 1.2.3.4:8000 or --rc-addr :8080 to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port.

If you set --rc-addr to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info.

You can use a unix socket by setting the url to unix:///path/to/socket or just by using an absolute path name.

--rc-addr may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same.

--rc-server-read-timeout and --rc-server-write-timeout can be used to control the timeouts on the server. Note that this is the total time for a transfer.

--rc-max-header-bytes controls the maximum number of bytes the server will accept in the HTTP header.

--rc-baseurl controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used --rc-baseurl "/rclone" then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on --rc-baseurl, so --rc-baseurl "rclone", --rc-baseurl "/rclone" and --rc-baseurl "/rclone/" are all treated identically.

TLS (SSL)

By default this will serve over http. If you want you can serve over https. You will need to supply the --rc-cert and --rc-key flags. If you wish to do client side certificate validation then you will need to supply --rc-client-ca also.

--rc-cert must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. --rc-key must be set to the path of a file with the PEM encoded private key. If setting --rc-client-ca, it should be set to the path of a file with PEM encoded client certificate authority certificates.

--rc-min-tls-version is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0").

Socket activation

Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by --rc-addr).

This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html

Socket activation can be tested ad-hoc with the systemd-socket-activatecommand

   systemd-socket-activate -l 8000 -- rclone serve

This will socket-activate rclone on the first connection to port 8000 over TCP. ### Template

--rc-template allows a user to specify a custom markup template for HTTP and WebDAV serve functions. The server exports the following markup to be used within the template to server pages:

Parameter Description
.Name The full path of a file/directory.
.Title Directory listing of .Name
.Sort The current sort used. This is changeable via ?sort= parameter
Sort Options: namedirfirst,name,size,time (default namedirfirst)
.Order The current ordering used. This is changeable via ?order= parameter
Order Options: asc,desc (default asc)
.Query Currently unused.
.Breadcrumb Allows for creating a relative navigation
-- .Link The relative to the root link of the Text.
-- .Text The Name of the directory.
.Entries Information about a specific file/directory.
-- .URL The 'url' of an entry.
-- .Leaf Currently same as 'URL' but intended to be 'just' the name.
-- .IsDir Boolean for if an entry is a directory or not.
-- .Size Size in Bytes of the entry.
-- .ModTime The UTC timestamp of an entry.

The server also makes the following functions available so that they can be used within the template. These functions help extend the options for dynamic rendering of HTML. They can be used to render HTML based on specific conditions.

Function Description
afterEpoch Returns the time since the epoch for the given time.
contains Checks whether a given substring is present or not in a given string.
hasPrefix Checks whether the given string begins with the specified prefix.
hasSuffix Checks whether the given string end with the specified suffix.

Authentication

By default this will serve files without needing a login.

You can either use an htpasswd file which can take lots of users, or set a single username and password with the --rc-user and --rc-pass flags.

Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with --user-from-header (e.g., --rc---user-from-header=x-remote-user). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access.

If either of the above authentication methods is not configured and client certificates are required by the --client-ca flag passed to the server, the client certificate common name will be considered as the username.

Use --rc-htpasswd /path/to/htpasswd to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended.

To create an htpasswd file:

touch htpasswd
htpasswd -B htpasswd user
htpasswd -B htpasswd anotherUser

The password file can be updated while rclone is running.

Use --rc-realm to set the authentication realm.

Use --rc-salt to change the password hashing salt from the default.

rclone rcd <path to files to serve>* [flags]

Options

  -h, --help   help for rcd

Options shared with other commands are described next. See the global flags page for global options not listed here.

RC Options

Flags to control the Remote Control API

      --rc                                 Enable the remote control server
      --rc-addr stringArray                IPaddress:Port or :Port to bind server to (default localhost:5572)
      --rc-allow-origin string             Origin which cross-domain request (CORS) can be executed from
      --rc-baseurl string                  Prefix for URLs - leave blank for root
      --rc-cert string                     TLS PEM key (concatenation of certificate and CA certificate)
      --rc-client-ca string                Client certificate authority to verify clients with
      --rc-enable-metrics                  Enable the Prometheus metrics path at the remote control server
      --rc-files string                    Path to local files to serve on the HTTP server
      --rc-htpasswd string                 A htpasswd file - if not provided no authentication is done
      --rc-job-expire-duration Duration    Expire finished async jobs older than this value (default 1m0s)
      --rc-job-expire-interval Duration    Interval to check for expired async jobs (default 10s)
      --rc-key string                      TLS PEM Private key
      --rc-max-header-bytes int            Maximum size of request header (default 4096)
      --rc-min-tls-version string          Minimum TLS version that is acceptable (default "tls1.0")
      --rc-no-auth                         Don't require auth for certain methods
      --rc-pass string                     Password for authentication
      --rc-realm string                    Realm for authentication
      --rc-salt string                     Password hashing salt (default "dlPL2MqE")
      --rc-serve                           Enable the serving of remote objects
      --rc-serve-no-modtime                Don't read the modification time (can speed things up)
      --rc-server-read-timeout Duration    Timeout for server reading data (default 1h0m0s)
      --rc-server-write-timeout Duration   Timeout for server writing data (default 1h0m0s)
      --rc-template string                 User-specified template
      --rc-user string                     User name for authentication
      --rc-user-from-header string         User name from a defined HTTP header
      --rc-web-fetch-url string            URL to fetch the releases for webgui (default "https://api.github.com/repos/rclone/rclone-webui-react/releases/latest")
      --rc-web-gui                         Launch WebGUI on localhost
      --rc-web-gui-force-update            Force update to latest version of web gui
      --rc-web-gui-no-open-browser         Don't open the browser automatically
      --rc-web-gui-update                  Check and update to latest version of web gui

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone rmdirs

Remove empty directories under the path.

Synopsis

This recursively removes any empty directories (including directories that only contain empty directories), that it finds under the path. The root path itself will also be removed if it is empty, unless you supply the --leave-root flag.

Use command rmdir to delete just the empty directory given by path, not recurse.

This is useful for tidying up remotes that rclone has left a lot of empty directories in. For example the delete command will delete files but leave the directory structure (unless used with option --rmdirs).

This will delete --checkers directories concurrently so if you have thousands of empty directories consider increasing this number.

To delete a path and any objects in it, use the purge command.

rclone rmdirs remote:path [flags]

Options

  -h, --help         help for rmdirs
      --leave-root   Do not remove root directory if empty

Options shared with other commands are described next. See the global flags page for global options not listed here.

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone selfupdate

Update the rclone binary.

Synopsis

This command downloads the latest release of rclone and replaces the currently running binary. The download is verified with a hashsum and cryptographically signed signature; see the release signing docs for details.

If used without flags (or with implied --stable flag), this command will install the latest stable release. However, some issues may be fixed (or features added) only in the latest beta release. In such cases you should run the command with the --beta flag, i.e. rclone selfupdate --beta. You can check in advance what version would be installed by adding the --check flag, then repeat the command without it when you are satisfied.

Sometimes the rclone team may recommend you a concrete beta or stable rclone release to troubleshoot your issue or add a bleeding edge feature. The --version VER flag, if given, will update to the concrete version instead of the latest one. If you omit micro version from VER (for example 1.53), the latest matching micro version will be used.

Upon successful update rclone will print a message that contains a previous version number. You will need it if you later decide to revert your update for some reason. Then you'll have to note the previous version and run the following command: rclone selfupdate [--beta] OLDVER. If the old version contains only dots and digits (for example v1.54.0) then it's a stable release so you won't need the --beta flag. Beta releases have an additional information similar to v1.54.0-beta.5111.06f1c0c61. (if you are a developer and use a locally built rclone, the version number will end with -DEV, you will have to rebuild it as it obviously can't be distributed).

If you previously installed rclone via a package manager, the package may include local documentation or configure services. You may wish to update with the flag --package deb or --package rpm (whichever is correct for your OS) to update these too. This command with the default --package zip will update only the rclone executable so the local manual may become inaccurate after it.

The rclone mount command may or may not support extended FUSE options depending on the build and OS. selfupdate will refuse to update if the capability would be discarded.

Note: Windows forbids deletion of a currently running executable so this command will rename the old executable to 'rclone.old.exe' upon success.

Please note that this command was not available before rclone version 1.55. If it fails for you with the message unknown command "selfupdate" then you will need to update manually following the install instructions located at https://rclone.org/install/

rclone selfupdate [flags]

Options

      --beta             Install beta release
      --check            Check for latest release, do not download
  -h, --help             help for selfupdate
      --output string    Save the downloaded binary at a given path (default: replace running binary)
      --package string   Package format: zip|deb|rpm (default: zip)
      --stable           Install stable release (this is the default)
      --version string   Install the given rclone version (default: latest)

See the global flags page for global options not listed here.

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone serve

Serve a remote over a protocol.

Synopsis

Serve a remote over a given protocol. Requires the use of a subcommand to specify the protocol, e.g.

rclone serve http remote:

Each subcommand has its own options which you can see in their help.

rclone serve <protocol> [opts] <remote> [flags]

Options

  -h, --help   help for serve

See the global flags page for global options not listed here.

See Also

rclone serve dlna

Serve remote:path over DLNA

Synopsis

Run a DLNA media server for media stored in an rclone remote. Many devices, such as the Xbox and PlayStation, can automatically discover this server in the LAN and play audio/video from it. VLC is also supported. Service discovery uses UDP multicast packets (SSDP) and will thus only work on LANs.

Rclone will list all files present in the remote, without filtering based on media formats or file extensions. Additionally, there is no media transcoding support. This means that some players might show files that they are not able to play back correctly.

Rclone will add external subtitle files (.srt) to videos if they have the same filename as the video file itself (except the extension), either in the same directory as the video, or in a "Subs" subdirectory.

Server options

Use --addr to specify which IP address and port the server should listen on, e.g. --addr 1.2.3.4:8000 or --addr :8080 to listen to all IPs.

Use --name to choose the friendly server name, which is by default "rclone (hostname)".

Use --log-trace in conjunction with -vv to enable additional debug logging of all UPNP traffic.

VFS - Virtual File System

This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system.

Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below.

The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory.

VFS Directory Cache

Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache.

--dir-cache-time duration   Time to cache directory entries for (default 5m0s)
--poll-interval duration    Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s)

However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval.

You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this:

kill -SIGHUP $(pidof rclone)

If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache:

rclone rc vfs/forget

Or individual files or directories:

rclone rc vfs/forget file=path/to/file dir=path/to/dir

VFS File Buffering

The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance.

Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared.

This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used.

The maximum memory used by rclone for buffering can be up to --buffer-size * open files.

VFS File Caching

These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility.

For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details.

Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both.

--cache-dir string                     Directory rclone will use for caching.
--vfs-cache-mode CacheMode             Cache mode off|minimal|writes|full (default off)
--vfs-cache-max-age duration           Max time since last access of objects in the cache (default 1h0m0s)
--vfs-cache-max-size SizeSuffix        Max total size of objects in the cache (default off)
--vfs-cache-min-free-space SizeSuffix  Target minimum free space on the disk containing the cache (default off)
--vfs-cache-poll-interval duration     Interval to poll the cache for stale objects (default 1m0s)
--vfs-write-back duration              Time to writeback files after last use when using cache (default 5s)

If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable.

The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space.

Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags.

If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached.

The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w .

You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap.

--vfs-cache-mode off

In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk.

This will mean some operations are not possible

  • Files can't be opened for both read AND write
  • Files opened for write can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files open for read with O_TRUNC will be opened write only
  • Files open for write only will behave as if O_TRUNC was supplied
  • Open modes O_APPEND, O_TRUNC are ignored
  • If an upload fails it can't be retried

--vfs-cache-mode minimal

This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space.

These operations are not possible

  • Files opened for write only can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files opened for write only will ignore O_APPEND, O_TRUNC
  • If an upload fails it can't be retried

--vfs-cache-mode writes

In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first.

This mode should support all normal file system operations.

If an upload fails it will be retried at exponentially increasing intervals up to 1 minute.

--vfs-cache-mode full

In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well.

In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded.

So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them.

This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes.

When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk.

When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required.

IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected.

Fingerprinting

Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from:

  • size
  • modification time
  • hash

where available on an object.

On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object).

For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it.

If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files.

If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended.

Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again.

VFS Chunked Reading

When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests.

These flags control the chunking:

--vfs-read-chunk-size SizeSuffix        Read the source objects in chunks (default 128M)
--vfs-read-chunk-size-limit SizeSuffix  Max chunk doubling size (default off)
--vfs-read-chunk-streams int            The number of parallel streams to read at once

The chunking behaves differently depending on the --vfs-read-chunk-streams parameter.

--vfs-read-chunk-streams == 0

Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely.

With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on.

Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading.

The chunks will not be buffered in memory.

--vfs-read-chunk-streams > 0

Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant.

This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores.

Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend.

For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting.

Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput.

VFS Performance

These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature.

In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction.

--no-checksum     Don't compare checksums on up/download.
--no-modtime      Don't read/write the modification time (can speed things up).
--no-seek         Don't allow seeking in files.
--read-only       Only allow read-only access.

Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file.

--vfs-read-wait duration   Time to wait for in-sequence read before seeking (default 20ms)
--vfs-write-wait duration  Time to wait for in-sequence write before giving error (default 1s)

When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS).

--transfers int  Number of file transfers to run in parallel (default 4)

By default the VFS does not support symlinks. However this may be enabled with either of the following flags:

--links      Translate symlinks to/from regular files with a '.rclonelink' extension.
--vfs-links  Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS

As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination.

Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer.

This scheme is compatible with that used by the local backend with the --local-links flag.

The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs.

It hasn't been tested with the other rclone serve commands yet.

A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree

.
├── dir
│   └── file.txt
└── linked-dir -> dir

The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands.

Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa).

VFS Case Sensitivity

Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file.

File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case.

Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default.

The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below.

The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote.

Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target.

If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true".

The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues.

In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync.

VFS Disk Options

This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically.

--vfs-disk-space-total-size    Manually set the total disk space size (example: 256G, default: -1)

Alternate report of used bytes

Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself.

WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching.

VFS Metadata

If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires.

Note that some backends won't create metadata unless you pass in the --metadata flag.

For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get

$ ls -l /mnt/
total 1048577
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G

$ cat /mnt/1G.metadata
{
        "atime": "2025-03-04T17:34:22.317069787Z",
        "btime": "2025-03-03T16:03:37.708253808Z",
        "gid": "1000",
        "mode": "100664",
        "mtime": "2025-03-03T16:03:39.640238323Z",
        "uid": "1000"
}

$ ls -l /mnt/
total 1048578
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G
-rw-rw-r-- 1 user user        185 Mar  3 16:03 1G.metadata

If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}.

rclone serve dlna remote:path [flags]

Options

      --addr string                            The ip:port or :port to bind the DLNA http server to (default ":7879")
      --announce-interval Duration             The interval between SSDP announcements (default 12m0s)
      --dir-cache-time Duration                Time to cache directory entries for (default 5m0s)
      --dir-perms FileMode                     Directory permissions (default 777)
      --file-perms FileMode                    File permissions (default 666)
      --gid uint32                             Override the gid field set by the filesystem (not supported on Windows) (default 1000)
  -h, --help                                   help for dlna
      --interface stringArray                  The interface to use for SSDP (repeat as necessary)
      --link-perms FileMode                    Link permissions (default 666)
      --log-trace                              Enable trace logging of SOAP traffic
      --name string                            Name of DLNA server
      --no-checksum                            Don't compare checksums on up/download
      --no-modtime                             Don't read/write the modification time (can speed things up)
      --no-seek                                Don't allow seeking in files
      --poll-interval Duration                 Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s)
      --read-only                              Only allow read-only access
      --uid uint32                             Override the uid field set by the filesystem (not supported on Windows) (default 1000)
      --umask FileMode                         Override the permission bits set by the filesystem (not supported on Windows) (default 002)
      --vfs-block-norm-dupes                   If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost)
      --vfs-cache-max-age Duration             Max time since last access of objects in the cache (default 1h0m0s)
      --vfs-cache-max-size SizeSuffix          Max total size of objects in the cache (default off)
      --vfs-cache-min-free-space SizeSuffix    Target minimum free space on the disk containing the cache (default off)
      --vfs-cache-mode CacheMode               Cache mode off|minimal|writes|full (default off)
      --vfs-cache-poll-interval Duration       Interval to poll the cache for stale objects (default 1m0s)
      --vfs-case-insensitive                   If a file name not found, find a case insensitive match
      --vfs-disk-space-total-size SizeSuffix   Specify the total space of disk (default off)
      --vfs-fast-fingerprint                   Use fast (less accurate) fingerprints for change detection
      --vfs-links                              Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS
      --vfs-metadata-extension string          Set the extension to read metadata from
      --vfs-read-ahead SizeSuffix              Extra read ahead over --buffer-size when using cache-mode full
      --vfs-read-chunk-size SizeSuffix         Read the source objects in chunks (default 128Mi)
      --vfs-read-chunk-size-limit SizeSuffix   If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off)
      --vfs-read-chunk-streams int             The number of parallel streams to read at once
      --vfs-read-wait Duration                 Time to wait for in-sequence read before seeking (default 20ms)
      --vfs-refresh                            Refreshes the directory cache recursively in the background on start
      --vfs-used-is-size rclone size           Use the rclone size algorithm for Used size
      --vfs-write-back Duration                Time to writeback files after last use when using cache (default 5s)
      --vfs-write-wait Duration                Time to wait for in-sequence write before giving error (default 1s)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

See Also

rclone serve docker

Serve any remote on docker's volume plugin API.

Synopsis

This command implements the Docker volume plugin API allowing docker to use rclone as a data storage mechanism for various cloud providers. rclone provides docker volume plugin based on it.

To create a docker plugin, one must create a Unix or TCP socket that Docker will look for when you use the plugin and then it listens for commands from docker daemon and runs the corresponding code when necessary. Docker plugins can run as a managed plugin under control of the docker daemon or as an independent native service. For testing, you can just run it directly from the command line, for example:

sudo rclone serve docker --base-dir /tmp/rclone-volumes --socket-addr localhost:8787 -vv

Running rclone serve docker will create the said socket, listening for commands from Docker to create the necessary Volumes. Normally you need not give the --socket-addr flag. The API will listen on the unix domain socket at /run/docker/plugins/rclone.sock. In the example above rclone will create a TCP socket and a small file /etc/docker/plugins/rclone.spec containing the socket address. We use sudo because both paths are writeable only by the root user.

If you later decide to change listening socket, the docker daemon must be restarted to reconnect to /run/docker/plugins/rclone.sock or parse new /etc/docker/plugins/rclone.spec. Until you restart, any volume related docker commands will timeout trying to access the old socket. Running directly is supported on Linux only, not on Windows or MacOS. This is not a problem with managed plugin mode described in details in the full documentation.

The command will create volume mounts under the path given by --base-dir (by default /var/lib/docker-volumes/rclone available only to root) and maintain the JSON formatted file docker-plugin.state in the rclone cache directory with book-keeping records of created and mounted volumes.

All mount and VFS options are submitted by the docker daemon via API, but you can also provide defaults on the command line as well as set path to the config file and cache directory or adjust logging verbosity.

VFS - Virtual File System

This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system.

Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below.

The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory.

VFS Directory Cache

Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache.

--dir-cache-time duration   Time to cache directory entries for (default 5m0s)
--poll-interval duration    Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s)

However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval.

You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this:

kill -SIGHUP $(pidof rclone)

If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache:

rclone rc vfs/forget

Or individual files or directories:

rclone rc vfs/forget file=path/to/file dir=path/to/dir

VFS File Buffering

The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance.

Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared.

This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used.

The maximum memory used by rclone for buffering can be up to --buffer-size * open files.

VFS File Caching

These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility.

For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details.

Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both.

--cache-dir string                     Directory rclone will use for caching.
--vfs-cache-mode CacheMode             Cache mode off|minimal|writes|full (default off)
--vfs-cache-max-age duration           Max time since last access of objects in the cache (default 1h0m0s)
--vfs-cache-max-size SizeSuffix        Max total size of objects in the cache (default off)
--vfs-cache-min-free-space SizeSuffix  Target minimum free space on the disk containing the cache (default off)
--vfs-cache-poll-interval duration     Interval to poll the cache for stale objects (default 1m0s)
--vfs-write-back duration              Time to writeback files after last use when using cache (default 5s)

If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable.

The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space.

Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags.

If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached.

The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w .

You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap.

--vfs-cache-mode off

In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk.

This will mean some operations are not possible

  • Files can't be opened for both read AND write
  • Files opened for write can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files open for read with O_TRUNC will be opened write only
  • Files open for write only will behave as if O_TRUNC was supplied
  • Open modes O_APPEND, O_TRUNC are ignored
  • If an upload fails it can't be retried

--vfs-cache-mode minimal

This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space.

These operations are not possible

  • Files opened for write only can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files opened for write only will ignore O_APPEND, O_TRUNC
  • If an upload fails it can't be retried

--vfs-cache-mode writes

In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first.

This mode should support all normal file system operations.

If an upload fails it will be retried at exponentially increasing intervals up to 1 minute.

--vfs-cache-mode full

In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well.

In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded.

So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them.

This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes.

When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk.

When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required.

IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected.

Fingerprinting

Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from:

  • size
  • modification time
  • hash

where available on an object.

On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object).

For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it.

If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files.

If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended.

Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again.

VFS Chunked Reading

When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests.

These flags control the chunking:

--vfs-read-chunk-size SizeSuffix        Read the source objects in chunks (default 128M)
--vfs-read-chunk-size-limit SizeSuffix  Max chunk doubling size (default off)
--vfs-read-chunk-streams int            The number of parallel streams to read at once

The chunking behaves differently depending on the --vfs-read-chunk-streams parameter.

--vfs-read-chunk-streams == 0

Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely.

With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on.

Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading.

The chunks will not be buffered in memory.

--vfs-read-chunk-streams > 0

Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant.

This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores.

Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend.

For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting.

Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput.

VFS Performance

These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature.

In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction.

--no-checksum     Don't compare checksums on up/download.
--no-modtime      Don't read/write the modification time (can speed things up).
--no-seek         Don't allow seeking in files.
--read-only       Only allow read-only access.

Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file.

--vfs-read-wait duration   Time to wait for in-sequence read before seeking (default 20ms)
--vfs-write-wait duration  Time to wait for in-sequence write before giving error (default 1s)

When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS).

--transfers int  Number of file transfers to run in parallel (default 4)

By default the VFS does not support symlinks. However this may be enabled with either of the following flags:

--links      Translate symlinks to/from regular files with a '.rclonelink' extension.
--vfs-links  Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS

As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination.

Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer.

This scheme is compatible with that used by the local backend with the --local-links flag.

The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs.

It hasn't been tested with the other rclone serve commands yet.

A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree

.
├── dir
│   └── file.txt
└── linked-dir -> dir

The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands.

Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa).

VFS Case Sensitivity

Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file.

File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case.

Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default.

The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below.

The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote.

Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target.

If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true".

The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues.

In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync.

VFS Disk Options

This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically.

--vfs-disk-space-total-size    Manually set the total disk space size (example: 256G, default: -1)

Alternate report of used bytes

Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself.

WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching.

VFS Metadata

If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires.

Note that some backends won't create metadata unless you pass in the --metadata flag.

For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get

$ ls -l /mnt/
total 1048577
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G

$ cat /mnt/1G.metadata
{
        "atime": "2025-03-04T17:34:22.317069787Z",
        "btime": "2025-03-03T16:03:37.708253808Z",
        "gid": "1000",
        "mode": "100664",
        "mtime": "2025-03-03T16:03:39.640238323Z",
        "uid": "1000"
}

$ ls -l /mnt/
total 1048578
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G
-rw-rw-r-- 1 user user        185 Mar  3 16:03 1G.metadata

If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}.

rclone serve docker [flags]

Options

      --allow-non-empty                        Allow mounting over a non-empty directory (not supported on Windows)
      --allow-other                            Allow access to other users (not supported on Windows)
      --allow-root                             Allow access to root user (not supported on Windows)
      --async-read                             Use asynchronous reads (not supported on Windows) (default true)
      --attr-timeout Duration                  Time for which file/directory attributes are cached (default 1s)
      --base-dir string                        Base directory for volumes (default "/var/lib/docker-volumes/rclone")
      --daemon                                 Run mount in background and exit parent process (as background output is suppressed, use --log-file with --log-format=pid,... to monitor) (not supported on Windows)
      --daemon-timeout Duration                Time limit for rclone to respond to kernel (not supported on Windows) (default 0s)
      --daemon-wait Duration                   Time to wait for ready mount from daemon (maximum time on Linux, constant sleep time on OSX/BSD) (not supported on Windows) (default 1m0s)
      --debug-fuse                             Debug the FUSE internals - needs -v
      --default-permissions                    Makes kernel enforce access control based on the file mode (not supported on Windows)
      --devname string                         Set the device name - default is remote:path
      --dir-cache-time Duration                Time to cache directory entries for (default 5m0s)
      --dir-perms FileMode                     Directory permissions (default 777)
      --direct-io                              Use Direct IO, disables caching of data
      --file-perms FileMode                    File permissions (default 666)
      --forget-state                           Skip restoring previous state
      --fuse-flag stringArray                  Flags or arguments to be passed direct to libfuse/WinFsp (repeat if required)
      --gid uint32                             Override the gid field set by the filesystem (not supported on Windows) (default 1000)
  -h, --help                                   help for docker
      --link-perms FileMode                    Link permissions (default 666)
      --max-read-ahead SizeSuffix              The number of bytes that can be prefetched for sequential reads (not supported on Windows) (default 128Ki)
      --mount-case-insensitive Tristate        Tell the OS the mount is case insensitive (true) or sensitive (false) regardless of the backend (auto) (default unset)
      --network-mode                           Mount as remote network drive, instead of fixed disk drive (supported on Windows only)
      --no-checksum                            Don't compare checksums on up/download
      --no-modtime                             Don't read/write the modification time (can speed things up)
      --no-seek                                Don't allow seeking in files
      --no-spec                                Do not write spec file
      --noappledouble                          Ignore Apple Double (._) and .DS_Store files (supported on OSX only) (default true)
      --noapplexattr                           Ignore all "com.apple.*" extended attributes (supported on OSX only)
  -o, --option stringArray                     Option for libfuse/WinFsp (repeat if required)
      --poll-interval Duration                 Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s)
      --read-only                              Only allow read-only access
      --socket-addr string                     Address <host:port> or absolute path (default: /run/docker/plugins/rclone.sock)
      --socket-gid int                         GID for unix socket (default: current process GID) (default 1000)
      --uid uint32                             Override the uid field set by the filesystem (not supported on Windows) (default 1000)
      --umask FileMode                         Override the permission bits set by the filesystem (not supported on Windows) (default 002)
      --vfs-block-norm-dupes                   If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost)
      --vfs-cache-max-age Duration             Max time since last access of objects in the cache (default 1h0m0s)
      --vfs-cache-max-size SizeSuffix          Max total size of objects in the cache (default off)
      --vfs-cache-min-free-space SizeSuffix    Target minimum free space on the disk containing the cache (default off)
      --vfs-cache-mode CacheMode               Cache mode off|minimal|writes|full (default off)
      --vfs-cache-poll-interval Duration       Interval to poll the cache for stale objects (default 1m0s)
      --vfs-case-insensitive                   If a file name not found, find a case insensitive match
      --vfs-disk-space-total-size SizeSuffix   Specify the total space of disk (default off)
      --vfs-fast-fingerprint                   Use fast (less accurate) fingerprints for change detection
      --vfs-links                              Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS
      --vfs-metadata-extension string          Set the extension to read metadata from
      --vfs-read-ahead SizeSuffix              Extra read ahead over --buffer-size when using cache-mode full
      --vfs-read-chunk-size SizeSuffix         Read the source objects in chunks (default 128Mi)
      --vfs-read-chunk-size-limit SizeSuffix   If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off)
      --vfs-read-chunk-streams int             The number of parallel streams to read at once
      --vfs-read-wait Duration                 Time to wait for in-sequence read before seeking (default 20ms)
      --vfs-refresh                            Refreshes the directory cache recursively in the background on start
      --vfs-used-is-size rclone size           Use the rclone size algorithm for Used size
      --vfs-write-back Duration                Time to writeback files after last use when using cache (default 5s)
      --vfs-write-wait Duration                Time to wait for in-sequence write before giving error (default 1s)
      --volname string                         Set the volume name (supported on Windows and OSX only)
      --write-back-cache                       Makes kernel buffer writes before sending them to rclone (without this, writethrough caching is used) (not supported on Windows)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

See Also

rclone serve ftp

Serve remote:path over FTP.

Synopsis

Run a basic FTP server to serve a remote over FTP protocol. This can be viewed with a FTP client or you can make a remote of type FTP to read and write it.

Server options

Use --addr to specify which IP address and port the server should listen on, e.g. --addr 1.2.3.4:8000 or --addr :8080 to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port.

If you set --addr to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info.

Authentication

By default this will serve files without needing a login.

You can set a single username and password with the --user and --pass flags.

VFS - Virtual File System

This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system.

Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below.

The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory.

VFS Directory Cache

Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache.

--dir-cache-time duration   Time to cache directory entries for (default 5m0s)
--poll-interval duration    Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s)

However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval.

You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this:

kill -SIGHUP $(pidof rclone)

If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache:

rclone rc vfs/forget

Or individual files or directories:

rclone rc vfs/forget file=path/to/file dir=path/to/dir

VFS File Buffering

The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance.

Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared.

This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used.

The maximum memory used by rclone for buffering can be up to --buffer-size * open files.

VFS File Caching

These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility.

For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details.

Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both.

--cache-dir string                     Directory rclone will use for caching.
--vfs-cache-mode CacheMode             Cache mode off|minimal|writes|full (default off)
--vfs-cache-max-age duration           Max time since last access of objects in the cache (default 1h0m0s)
--vfs-cache-max-size SizeSuffix        Max total size of objects in the cache (default off)
--vfs-cache-min-free-space SizeSuffix  Target minimum free space on the disk containing the cache (default off)
--vfs-cache-poll-interval duration     Interval to poll the cache for stale objects (default 1m0s)
--vfs-write-back duration              Time to writeback files after last use when using cache (default 5s)

If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable.

The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space.

Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags.

If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached.

The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w .

You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap.

--vfs-cache-mode off

In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk.

This will mean some operations are not possible

  • Files can't be opened for both read AND write
  • Files opened for write can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files open for read with O_TRUNC will be opened write only
  • Files open for write only will behave as if O_TRUNC was supplied
  • Open modes O_APPEND, O_TRUNC are ignored
  • If an upload fails it can't be retried

--vfs-cache-mode minimal

This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space.

These operations are not possible

  • Files opened for write only can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files opened for write only will ignore O_APPEND, O_TRUNC
  • If an upload fails it can't be retried

--vfs-cache-mode writes

In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first.

This mode should support all normal file system operations.

If an upload fails it will be retried at exponentially increasing intervals up to 1 minute.

--vfs-cache-mode full

In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well.

In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded.

So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them.

This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes.

When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk.

When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required.

IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected.

Fingerprinting

Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from:

  • size
  • modification time
  • hash

where available on an object.

On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object).

For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it.

If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files.

If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended.

Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again.

VFS Chunked Reading

When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests.

These flags control the chunking:

--vfs-read-chunk-size SizeSuffix        Read the source objects in chunks (default 128M)
--vfs-read-chunk-size-limit SizeSuffix  Max chunk doubling size (default off)
--vfs-read-chunk-streams int            The number of parallel streams to read at once

The chunking behaves differently depending on the --vfs-read-chunk-streams parameter.

--vfs-read-chunk-streams == 0

Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely.

With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on.

Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading.

The chunks will not be buffered in memory.

--vfs-read-chunk-streams > 0

Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant.

This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores.

Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend.

For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting.

Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput.

VFS Performance

These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature.

In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction.

--no-checksum     Don't compare checksums on up/download.
--no-modtime      Don't read/write the modification time (can speed things up).
--no-seek         Don't allow seeking in files.
--read-only       Only allow read-only access.

Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file.

--vfs-read-wait duration   Time to wait for in-sequence read before seeking (default 20ms)
--vfs-write-wait duration  Time to wait for in-sequence write before giving error (default 1s)

When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS).

--transfers int  Number of file transfers to run in parallel (default 4)

By default the VFS does not support symlinks. However this may be enabled with either of the following flags:

--links      Translate symlinks to/from regular files with a '.rclonelink' extension.
--vfs-links  Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS

As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination.

Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer.

This scheme is compatible with that used by the local backend with the --local-links flag.

The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs.

It hasn't been tested with the other rclone serve commands yet.

A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree

.
├── dir
│   └── file.txt
└── linked-dir -> dir

The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands.

Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa).

VFS Case Sensitivity

Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file.

File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case.

Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default.

The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below.

The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote.

Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target.

If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true".

The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues.

In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync.

VFS Disk Options

This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically.

--vfs-disk-space-total-size    Manually set the total disk space size (example: 256G, default: -1)

Alternate report of used bytes

Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself.

WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching.

VFS Metadata

If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires.

Note that some backends won't create metadata unless you pass in the --metadata flag.

For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get

$ ls -l /mnt/
total 1048577
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G

$ cat /mnt/1G.metadata
{
        "atime": "2025-03-04T17:34:22.317069787Z",
        "btime": "2025-03-03T16:03:37.708253808Z",
        "gid": "1000",
        "mode": "100664",
        "mtime": "2025-03-03T16:03:39.640238323Z",
        "uid": "1000"
}

$ ls -l /mnt/
total 1048578
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G
-rw-rw-r-- 1 user user        185 Mar  3 16:03 1G.metadata

If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}.

Auth Proxy

If you supply the parameter --auth-proxy /path/to/program then rclone will use that program to generate backends on the fly which then are used to authenticate incoming requests. This uses a simple JSON based protocol with input on STDIN and output on STDOUT.

PLEASE NOTE: --auth-proxy and --authorized-keys cannot be used together, if --auth-proxy is set the authorized keys option will be ignored.

There is an example program bin/test_proxy.py in the rclone source code.

The program's job is to take a user and pass on the input and turn those into the config for a backend on STDOUT in JSON format. This config will have any default parameters for the backend added, but it won't use configuration from environment variables or command line options - it is the job of the proxy program to make a complete config.

This config generated must have this extra parameter - _root - root to use for the backend

And it may have this parameter - _obscure - comma separated strings for parameters to obscure

If password authentication was used by the client, input to the proxy process (on STDIN) would look similar to this:

{
    "user": "me",
    "pass": "mypassword"
}

If public-key authentication was used by the client, input to the proxy process (on STDIN) would look similar to this:

{
    "user": "me",
    "public_key": "AAAAB3NzaC1yc2EAAAADAQABAAABAQDuwESFdAe14hVS6omeyX7edc...JQdf"
}

And as an example return this on STDOUT

{
    "type": "sftp",
    "_root": "",
    "_obscure": "pass",
    "user": "me",
    "pass": "mypassword",
    "host": "sftp.example.com"
}

This would mean that an SFTP backend would be created on the fly for the user and pass/public_key returned in the output to the host given. Note that since _obscure is set to pass, rclone will obscure the pass parameter before creating the backend (which is required for sftp backends).

The program can manipulate the supplied user in any way, for example to make proxy to many different sftp backends, you could make the user be user@example.com and then set the host to example.com in the output and the user to user. For security you'd probably want to restrict the host to a limited list.

Note that an internal cache is keyed on user so only use that for configuration, don't use pass or public_key. This also means that if a user's password or public-key is changed the cache will need to expire (which takes 5 mins) before it takes effect.

This can be used to build general purpose proxies to any kind of backend that rclone supports.

rclone serve ftp remote:path [flags]

Options

      --addr string                            IPaddress:Port or :Port to bind server to (default "localhost:2121")
      --auth-proxy string                      A program to use to create the backend from the auth
      --cert string                            TLS PEM key (concatenation of certificate and CA certificate)
      --dir-cache-time Duration                Time to cache directory entries for (default 5m0s)
      --dir-perms FileMode                     Directory permissions (default 777)
      --file-perms FileMode                    File permissions (default 666)
      --gid uint32                             Override the gid field set by the filesystem (not supported on Windows) (default 1000)
  -h, --help                                   help for ftp
      --key string                             TLS PEM Private key
      --link-perms FileMode                    Link permissions (default 666)
      --no-checksum                            Don't compare checksums on up/download
      --no-modtime                             Don't read/write the modification time (can speed things up)
      --no-seek                                Don't allow seeking in files
      --pass string                            Password for authentication (empty value allow every password)
      --passive-port string                    Passive port range to use (default "30000-32000")
      --poll-interval Duration                 Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s)
      --public-ip string                       Public IP address to advertise for passive connections
      --read-only                              Only allow read-only access
      --uid uint32                             Override the uid field set by the filesystem (not supported on Windows) (default 1000)
      --umask FileMode                         Override the permission bits set by the filesystem (not supported on Windows) (default 002)
      --user string                            User name for authentication (default "anonymous")
      --vfs-block-norm-dupes                   If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost)
      --vfs-cache-max-age Duration             Max time since last access of objects in the cache (default 1h0m0s)
      --vfs-cache-max-size SizeSuffix          Max total size of objects in the cache (default off)
      --vfs-cache-min-free-space SizeSuffix    Target minimum free space on the disk containing the cache (default off)
      --vfs-cache-mode CacheMode               Cache mode off|minimal|writes|full (default off)
      --vfs-cache-poll-interval Duration       Interval to poll the cache for stale objects (default 1m0s)
      --vfs-case-insensitive                   If a file name not found, find a case insensitive match
      --vfs-disk-space-total-size SizeSuffix   Specify the total space of disk (default off)
      --vfs-fast-fingerprint                   Use fast (less accurate) fingerprints for change detection
      --vfs-links                              Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS
      --vfs-metadata-extension string          Set the extension to read metadata from
      --vfs-read-ahead SizeSuffix              Extra read ahead over --buffer-size when using cache-mode full
      --vfs-read-chunk-size SizeSuffix         Read the source objects in chunks (default 128Mi)
      --vfs-read-chunk-size-limit SizeSuffix   If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off)
      --vfs-read-chunk-streams int             The number of parallel streams to read at once
      --vfs-read-wait Duration                 Time to wait for in-sequence read before seeking (default 20ms)
      --vfs-refresh                            Refreshes the directory cache recursively in the background on start
      --vfs-used-is-size rclone size           Use the rclone size algorithm for Used size
      --vfs-write-back Duration                Time to writeback files after last use when using cache (default 5s)
      --vfs-write-wait Duration                Time to wait for in-sequence write before giving error (default 1s)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

See Also

rclone serve http

Serve the remote over HTTP.

Synopsis

Run a basic web server to serve a remote over HTTP. This can be viewed in a web browser or you can make a remote of type http read from it.

You can use the filter flags (e.g. --include, --exclude) to control what is served.

The server will log errors. Use -v to see access logs.

--bwlimit will be respected for file transfers. Use --stats to control the stats printing.

Server options

Use --addr to specify which IP address and port the server should listen on, eg --addr 1.2.3.4:8000 or --addr :8080 to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port.

If you set --addr to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info.

You can use a unix socket by setting the url to unix:///path/to/socket or just by using an absolute path name.

--addr may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same.

--server-read-timeout and --server-write-timeout can be used to control the timeouts on the server. Note that this is the total time for a transfer.

--max-header-bytes controls the maximum number of bytes the server will accept in the HTTP header.

--baseurl controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used --baseurl "/rclone" then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on --baseurl, so --baseurl "rclone", --baseurl "/rclone" and --baseurl "/rclone/" are all treated identically.

TLS (SSL)

By default this will serve over http. If you want you can serve over https. You will need to supply the --cert and --key flags. If you wish to do client side certificate validation then you will need to supply --client-ca also.

--cert must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. --key must be set to the path of a file with the PEM encoded private key. If setting --client-ca, it should be set to the path of a file with PEM encoded client certificate authority certificates.

--min-tls-version is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0").

Socket activation

Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by --addr).

This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html

Socket activation can be tested ad-hoc with the systemd-socket-activatecommand

   systemd-socket-activate -l 8000 -- rclone serve

This will socket-activate rclone on the first connection to port 8000 over TCP. ### Template

--template allows a user to specify a custom markup template for HTTP and WebDAV serve functions. The server exports the following markup to be used within the template to server pages:

Parameter Description
.Name The full path of a file/directory.
.Title Directory listing of .Name
.Sort The current sort used. This is changeable via ?sort= parameter
Sort Options: namedirfirst,name,size,time (default namedirfirst)
.Order The current ordering used. This is changeable via ?order= parameter
Order Options: asc,desc (default asc)
.Query Currently unused.
.Breadcrumb Allows for creating a relative navigation
-- .Link The relative to the root link of the Text.
-- .Text The Name of the directory.
.Entries Information about a specific file/directory.
-- .URL The 'url' of an entry.
-- .Leaf Currently same as 'URL' but intended to be 'just' the name.
-- .IsDir Boolean for if an entry is a directory or not.
-- .Size Size in Bytes of the entry.
-- .ModTime The UTC timestamp of an entry.

The server also makes the following functions available so that they can be used within the template. These functions help extend the options for dynamic rendering of HTML. They can be used to render HTML based on specific conditions.

Function Description
afterEpoch Returns the time since the epoch for the given time.
contains Checks whether a given substring is present or not in a given string.
hasPrefix Checks whether the given string begins with the specified prefix.
hasSuffix Checks whether the given string end with the specified suffix.

Authentication

By default this will serve files without needing a login.

You can either use an htpasswd file which can take lots of users, or set a single username and password with the --user and --pass flags.

Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with --user-from-header (e.g., ----user-from-header=x-remote-user). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access.

If either of the above authentication methods is not configured and client certificates are required by the --client-ca flag passed to the server, the client certificate common name will be considered as the username.

Use --htpasswd /path/to/htpasswd to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended.

To create an htpasswd file:

touch htpasswd
htpasswd -B htpasswd user
htpasswd -B htpasswd anotherUser

The password file can be updated while rclone is running.

Use --realm to set the authentication realm.

Use --salt to change the password hashing salt from the default.

VFS - Virtual File System

This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system.

Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below.

The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory.

VFS Directory Cache

Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache.

--dir-cache-time duration   Time to cache directory entries for (default 5m0s)
--poll-interval duration    Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s)

However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval.

You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this:

kill -SIGHUP $(pidof rclone)

If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache:

rclone rc vfs/forget

Or individual files or directories:

rclone rc vfs/forget file=path/to/file dir=path/to/dir

VFS File Buffering

The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance.

Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared.

This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used.

The maximum memory used by rclone for buffering can be up to --buffer-size * open files.

VFS File Caching

These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility.

For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details.

Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both.

--cache-dir string                     Directory rclone will use for caching.
--vfs-cache-mode CacheMode             Cache mode off|minimal|writes|full (default off)
--vfs-cache-max-age duration           Max time since last access of objects in the cache (default 1h0m0s)
--vfs-cache-max-size SizeSuffix        Max total size of objects in the cache (default off)
--vfs-cache-min-free-space SizeSuffix  Target minimum free space on the disk containing the cache (default off)
--vfs-cache-poll-interval duration     Interval to poll the cache for stale objects (default 1m0s)
--vfs-write-back duration              Time to writeback files after last use when using cache (default 5s)

If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable.

The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space.

Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags.

If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached.

The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w .

You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap.

--vfs-cache-mode off

In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk.

This will mean some operations are not possible

  • Files can't be opened for both read AND write
  • Files opened for write can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files open for read with O_TRUNC will be opened write only
  • Files open for write only will behave as if O_TRUNC was supplied
  • Open modes O_APPEND, O_TRUNC are ignored
  • If an upload fails it can't be retried

--vfs-cache-mode minimal

This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space.

These operations are not possible

  • Files opened for write only can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files opened for write only will ignore O_APPEND, O_TRUNC
  • If an upload fails it can't be retried

--vfs-cache-mode writes

In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first.

This mode should support all normal file system operations.

If an upload fails it will be retried at exponentially increasing intervals up to 1 minute.

--vfs-cache-mode full

In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well.

In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded.

So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them.

This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes.

When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk.

When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required.

IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected.

Fingerprinting

Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from:

  • size
  • modification time
  • hash

where available on an object.

On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object).

For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it.

If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files.

If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended.

Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again.

VFS Chunked Reading

When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests.

These flags control the chunking:

--vfs-read-chunk-size SizeSuffix        Read the source objects in chunks (default 128M)
--vfs-read-chunk-size-limit SizeSuffix  Max chunk doubling size (default off)
--vfs-read-chunk-streams int            The number of parallel streams to read at once

The chunking behaves differently depending on the --vfs-read-chunk-streams parameter.

--vfs-read-chunk-streams == 0

Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely.

With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on.

Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading.

The chunks will not be buffered in memory.

--vfs-read-chunk-streams > 0

Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant.

This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores.

Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend.

For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting.

Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput.

VFS Performance

These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature.

In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction.

--no-checksum     Don't compare checksums on up/download.
--no-modtime      Don't read/write the modification time (can speed things up).
--no-seek         Don't allow seeking in files.
--read-only       Only allow read-only access.

Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file.

--vfs-read-wait duration   Time to wait for in-sequence read before seeking (default 20ms)
--vfs-write-wait duration  Time to wait for in-sequence write before giving error (default 1s)

When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS).

--transfers int  Number of file transfers to run in parallel (default 4)

By default the VFS does not support symlinks. However this may be enabled with either of the following flags:

--links      Translate symlinks to/from regular files with a '.rclonelink' extension.
--vfs-links  Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS

As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination.

Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer.

This scheme is compatible with that used by the local backend with the --local-links flag.

The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs.

It hasn't been tested with the other rclone serve commands yet.

A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree

.
├── dir
│   └── file.txt
└── linked-dir -> dir

The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands.

Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa).

VFS Case Sensitivity

Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file.

File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case.

Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default.

The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below.

The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote.

Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target.

If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true".

The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues.

In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync.

VFS Disk Options

This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically.

--vfs-disk-space-total-size    Manually set the total disk space size (example: 256G, default: -1)

Alternate report of used bytes

Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself.

WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching.

VFS Metadata

If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires.

Note that some backends won't create metadata unless you pass in the --metadata flag.

For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get

$ ls -l /mnt/
total 1048577
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G

$ cat /mnt/1G.metadata
{
        "atime": "2025-03-04T17:34:22.317069787Z",
        "btime": "2025-03-03T16:03:37.708253808Z",
        "gid": "1000",
        "mode": "100664",
        "mtime": "2025-03-03T16:03:39.640238323Z",
        "uid": "1000"
}

$ ls -l /mnt/
total 1048578
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G
-rw-rw-r-- 1 user user        185 Mar  3 16:03 1G.metadata

If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}.

Auth Proxy

If you supply the parameter --auth-proxy /path/to/program then rclone will use that program to generate backends on the fly which then are used to authenticate incoming requests. This uses a simple JSON based protocol with input on STDIN and output on STDOUT.

PLEASE NOTE: --auth-proxy and --authorized-keys cannot be used together, if --auth-proxy is set the authorized keys option will be ignored.

There is an example program bin/test_proxy.py in the rclone source code.

The program's job is to take a user and pass on the input and turn those into the config for a backend on STDOUT in JSON format. This config will have any default parameters for the backend added, but it won't use configuration from environment variables or command line options - it is the job of the proxy program to make a complete config.

This config generated must have this extra parameter - _root - root to use for the backend

And it may have this parameter - _obscure - comma separated strings for parameters to obscure

If password authentication was used by the client, input to the proxy process (on STDIN) would look similar to this:

{
    "user": "me",
    "pass": "mypassword"
}

If public-key authentication was used by the client, input to the proxy process (on STDIN) would look similar to this:

{
    "user": "me",
    "public_key": "AAAAB3NzaC1yc2EAAAADAQABAAABAQDuwESFdAe14hVS6omeyX7edc...JQdf"
}

And as an example return this on STDOUT

{
    "type": "sftp",
    "_root": "",
    "_obscure": "pass",
    "user": "me",
    "pass": "mypassword",
    "host": "sftp.example.com"
}

This would mean that an SFTP backend would be created on the fly for the user and pass/public_key returned in the output to the host given. Note that since _obscure is set to pass, rclone will obscure the pass parameter before creating the backend (which is required for sftp backends).

The program can manipulate the supplied user in any way, for example to make proxy to many different sftp backends, you could make the user be user@example.com and then set the host to example.com in the output and the user to user. For security you'd probably want to restrict the host to a limited list.

Note that an internal cache is keyed on user so only use that for configuration, don't use pass or public_key. This also means that if a user's password or public-key is changed the cache will need to expire (which takes 5 mins) before it takes effect.

This can be used to build general purpose proxies to any kind of backend that rclone supports.

rclone serve http remote:path [flags]

Options

      --addr stringArray                       IPaddress:Port or :Port to bind server to (default 127.0.0.1:8080)
      --allow-origin string                    Origin which cross-domain request (CORS) can be executed from
      --auth-proxy string                      A program to use to create the backend from the auth
      --baseurl string                         Prefix for URLs - leave blank for root
      --cert string                            TLS PEM key (concatenation of certificate and CA certificate)
      --client-ca string                       Client certificate authority to verify clients with
      --dir-cache-time Duration                Time to cache directory entries for (default 5m0s)
      --dir-perms FileMode                     Directory permissions (default 777)
      --file-perms FileMode                    File permissions (default 666)
      --gid uint32                             Override the gid field set by the filesystem (not supported on Windows) (default 1000)
  -h, --help                                   help for http
      --htpasswd string                        A htpasswd file - if not provided no authentication is done
      --key string                             TLS PEM Private key
      --link-perms FileMode                    Link permissions (default 666)
      --max-header-bytes int                   Maximum size of request header (default 4096)
      --min-tls-version string                 Minimum TLS version that is acceptable (default "tls1.0")
      --no-checksum                            Don't compare checksums on up/download
      --no-modtime                             Don't read/write the modification time (can speed things up)
      --no-seek                                Don't allow seeking in files
      --pass string                            Password for authentication
      --poll-interval Duration                 Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s)
      --read-only                              Only allow read-only access
      --realm string                           Realm for authentication
      --salt string                            Password hashing salt (default "dlPL2MqE")
      --server-read-timeout Duration           Timeout for server reading data (default 1h0m0s)
      --server-write-timeout Duration          Timeout for server writing data (default 1h0m0s)
      --template string                        User-specified template
      --uid uint32                             Override the uid field set by the filesystem (not supported on Windows) (default 1000)
      --umask FileMode                         Override the permission bits set by the filesystem (not supported on Windows) (default 002)
      --user string                            User name for authentication
      --user-from-header string                User name from a defined HTTP header
      --vfs-block-norm-dupes                   If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost)
      --vfs-cache-max-age Duration             Max time since last access of objects in the cache (default 1h0m0s)
      --vfs-cache-max-size SizeSuffix          Max total size of objects in the cache (default off)
      --vfs-cache-min-free-space SizeSuffix    Target minimum free space on the disk containing the cache (default off)
      --vfs-cache-mode CacheMode               Cache mode off|minimal|writes|full (default off)
      --vfs-cache-poll-interval Duration       Interval to poll the cache for stale objects (default 1m0s)
      --vfs-case-insensitive                   If a file name not found, find a case insensitive match
      --vfs-disk-space-total-size SizeSuffix   Specify the total space of disk (default off)
      --vfs-fast-fingerprint                   Use fast (less accurate) fingerprints for change detection
      --vfs-links                              Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS
      --vfs-metadata-extension string          Set the extension to read metadata from
      --vfs-read-ahead SizeSuffix              Extra read ahead over --buffer-size when using cache-mode full
      --vfs-read-chunk-size SizeSuffix         Read the source objects in chunks (default 128Mi)
      --vfs-read-chunk-size-limit SizeSuffix   If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off)
      --vfs-read-chunk-streams int             The number of parallel streams to read at once
      --vfs-read-wait Duration                 Time to wait for in-sequence read before seeking (default 20ms)
      --vfs-refresh                            Refreshes the directory cache recursively in the background on start
      --vfs-used-is-size rclone size           Use the rclone size algorithm for Used size
      --vfs-write-back Duration                Time to writeback files after last use when using cache (default 5s)
      --vfs-write-wait Duration                Time to wait for in-sequence write before giving error (default 1s)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

See Also

rclone serve nfs

Serve the remote as an NFS mount

Synopsis

Create an NFS server that serves the given remote over the network.

This implements an NFSv3 server to serve any rclone remote via NFS.

The primary purpose for this command is to enable the mount command on recent macOS versions where installing FUSE is very cumbersome.

This server does not implement any authentication so any client will be able to access the data. To limit access, you can use serve nfs on the loopback address or rely on secure tunnels (such as SSH) or use firewalling.

For this reason, by default, a random TCP port is chosen and the loopback interface is used for the listening address by default; meaning that it is only available to the local machine. If you want other machines to access the NFS mount over local network, you need to specify the listening address and port using the --addr flag.

Modifying files through the NFS protocol requires VFS caching. Usually you will need to specify --vfs-cache-mode in order to be able to write to the mountpoint (full is recommended). If you don't specify VFS cache mode, the mount will be read-only.

--nfs-cache-type controls the type of the NFS handle cache. By default this is memory where new handles will be randomly allocated when needed. These are stored in memory. If the server is restarted the handle cache will be lost and connected NFS clients will get stale handle errors.

--nfs-cache-type disk uses an on disk NFS handle cache. Rclone hashes the path of the object and stores it in a file named after the hash. These hashes are stored on disk the directory controlled by --cache-dir or the exact directory may be specified with --nfs-cache-dir. Using this means that the NFS server can be restarted at will without affecting the connected clients.

--nfs-cache-type symlink is similar to --nfs-cache-type disk in that it uses an on disk cache, but the cache entries are held as symlinks. Rclone will use the handle of the underlying file as the NFS handle which improves performance. This sort of cache can't be backed up and restored as the underlying handles will change. This is Linux only. It requires running rclone as root or with CAP_DAC_READ_SEARCH. You can run rclone with this extra permission by doing this to the rclone binary sudo setcap cap_dac_read_search+ep /path/to/rclone.

--nfs-cache-handle-limit controls the maximum number of cached NFS handles stored by the caching handler. This should not be set too low or you may experience errors when trying to access files. The default is 1000000, but consider lowering this limit if the server's system resource usage causes problems. This is only used by the memory type cache.

To serve NFS over the network use following command:

rclone serve nfs remote: --addr 0.0.0.0:$PORT --vfs-cache-mode=full

This specifies a port that can be used in the mount command. To mount the server under Linux/macOS, use the following command:

mount -t nfs -o port=$PORT,mountport=$PORT,tcp $HOSTNAME:/ path/to/mountpoint

Where $PORT is the same port number used in the serve nfs command and $HOSTNAME is the network address of the machine that serve nfs was run on.

If --vfs-metadata-extension is in use then for the --nfs-cache-type disk and --nfs-cache-type cache the metadata files will have the file handle of their parent file suffixed with 0x00, 0x00, 0x00, 0x01. This means they can be looked up directly from the parent file handle is desired.

This command is only available on Unix platforms.

VFS - Virtual File System

This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system.

Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below.

The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory.

VFS Directory Cache

Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache.

--dir-cache-time duration   Time to cache directory entries for (default 5m0s)
--poll-interval duration    Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s)

However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval.

You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this:

kill -SIGHUP $(pidof rclone)

If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache:

rclone rc vfs/forget

Or individual files or directories:

rclone rc vfs/forget file=path/to/file dir=path/to/dir

VFS File Buffering

The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance.

Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared.

This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used.

The maximum memory used by rclone for buffering can be up to --buffer-size * open files.

VFS File Caching

These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility.

For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details.

Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both.

--cache-dir string                     Directory rclone will use for caching.
--vfs-cache-mode CacheMode             Cache mode off|minimal|writes|full (default off)
--vfs-cache-max-age duration           Max time since last access of objects in the cache (default 1h0m0s)
--vfs-cache-max-size SizeSuffix        Max total size of objects in the cache (default off)
--vfs-cache-min-free-space SizeSuffix  Target minimum free space on the disk containing the cache (default off)
--vfs-cache-poll-interval duration     Interval to poll the cache for stale objects (default 1m0s)
--vfs-write-back duration              Time to writeback files after last use when using cache (default 5s)

If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable.

The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space.

Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags.

If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached.

The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w .

You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap.

--vfs-cache-mode off

In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk.

This will mean some operations are not possible

  • Files can't be opened for both read AND write
  • Files opened for write can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files open for read with O_TRUNC will be opened write only
  • Files open for write only will behave as if O_TRUNC was supplied
  • Open modes O_APPEND, O_TRUNC are ignored
  • If an upload fails it can't be retried

--vfs-cache-mode minimal

This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space.

These operations are not possible

  • Files opened for write only can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files opened for write only will ignore O_APPEND, O_TRUNC
  • If an upload fails it can't be retried

--vfs-cache-mode writes

In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first.

This mode should support all normal file system operations.

If an upload fails it will be retried at exponentially increasing intervals up to 1 minute.

--vfs-cache-mode full

In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well.

In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded.

So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them.

This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes.

When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk.

When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required.

IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected.

Fingerprinting

Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from:

  • size
  • modification time
  • hash

where available on an object.

On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object).

For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it.

If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files.

If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended.

Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again.

VFS Chunked Reading

When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests.

These flags control the chunking:

--vfs-read-chunk-size SizeSuffix        Read the source objects in chunks (default 128M)
--vfs-read-chunk-size-limit SizeSuffix  Max chunk doubling size (default off)
--vfs-read-chunk-streams int            The number of parallel streams to read at once

The chunking behaves differently depending on the --vfs-read-chunk-streams parameter.

--vfs-read-chunk-streams == 0

Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely.

With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on.

Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading.

The chunks will not be buffered in memory.

--vfs-read-chunk-streams > 0

Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant.

This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores.

Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend.

For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting.

Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput.

VFS Performance

These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature.

In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction.

--no-checksum     Don't compare checksums on up/download.
--no-modtime      Don't read/write the modification time (can speed things up).
--no-seek         Don't allow seeking in files.
--read-only       Only allow read-only access.

Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file.

--vfs-read-wait duration   Time to wait for in-sequence read before seeking (default 20ms)
--vfs-write-wait duration  Time to wait for in-sequence write before giving error (default 1s)

When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS).

--transfers int  Number of file transfers to run in parallel (default 4)

By default the VFS does not support symlinks. However this may be enabled with either of the following flags:

--links      Translate symlinks to/from regular files with a '.rclonelink' extension.
--vfs-links  Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS

As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination.

Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer.

This scheme is compatible with that used by the local backend with the --local-links flag.

The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs.

It hasn't been tested with the other rclone serve commands yet.

A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree

.
├── dir
│   └── file.txt
└── linked-dir -> dir

The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands.

Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa).

VFS Case Sensitivity

Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file.

File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case.

Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default.

The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below.

The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote.

Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target.

If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true".

The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues.

In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync.

VFS Disk Options

This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically.

--vfs-disk-space-total-size    Manually set the total disk space size (example: 256G, default: -1)

Alternate report of used bytes

Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself.

WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching.

VFS Metadata

If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires.

Note that some backends won't create metadata unless you pass in the --metadata flag.

For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get

$ ls -l /mnt/
total 1048577
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G

$ cat /mnt/1G.metadata
{
        "atime": "2025-03-04T17:34:22.317069787Z",
        "btime": "2025-03-03T16:03:37.708253808Z",
        "gid": "1000",
        "mode": "100664",
        "mtime": "2025-03-03T16:03:39.640238323Z",
        "uid": "1000"
}

$ ls -l /mnt/
total 1048578
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G
-rw-rw-r-- 1 user user        185 Mar  3 16:03 1G.metadata

If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}.

rclone serve nfs remote:path [flags]

Options

      --addr string                            IPaddress:Port or :Port to bind server to
      --dir-cache-time Duration                Time to cache directory entries for (default 5m0s)
      --dir-perms FileMode                     Directory permissions (default 777)
      --file-perms FileMode                    File permissions (default 666)
      --gid uint32                             Override the gid field set by the filesystem (not supported on Windows) (default 1000)
  -h, --help                                   help for nfs
      --link-perms FileMode                    Link permissions (default 666)
      --nfs-cache-dir string                   The directory the NFS handle cache will use if set
      --nfs-cache-handle-limit int             max file handles cached simultaneously (min 5) (default 1000000)
      --nfs-cache-type memory|disk|symlink     Type of NFS handle cache to use (default memory)
      --no-checksum                            Don't compare checksums on up/download
      --no-modtime                             Don't read/write the modification time (can speed things up)
      --no-seek                                Don't allow seeking in files
      --poll-interval Duration                 Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s)
      --read-only                              Only allow read-only access
      --uid uint32                             Override the uid field set by the filesystem (not supported on Windows) (default 1000)
      --umask FileMode                         Override the permission bits set by the filesystem (not supported on Windows) (default 002)
      --vfs-block-norm-dupes                   If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost)
      --vfs-cache-max-age Duration             Max time since last access of objects in the cache (default 1h0m0s)
      --vfs-cache-max-size SizeSuffix          Max total size of objects in the cache (default off)
      --vfs-cache-min-free-space SizeSuffix    Target minimum free space on the disk containing the cache (default off)
      --vfs-cache-mode CacheMode               Cache mode off|minimal|writes|full (default off)
      --vfs-cache-poll-interval Duration       Interval to poll the cache for stale objects (default 1m0s)
      --vfs-case-insensitive                   If a file name not found, find a case insensitive match
      --vfs-disk-space-total-size SizeSuffix   Specify the total space of disk (default off)
      --vfs-fast-fingerprint                   Use fast (less accurate) fingerprints for change detection
      --vfs-links                              Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS
      --vfs-metadata-extension string          Set the extension to read metadata from
      --vfs-read-ahead SizeSuffix              Extra read ahead over --buffer-size when using cache-mode full
      --vfs-read-chunk-size SizeSuffix         Read the source objects in chunks (default 128Mi)
      --vfs-read-chunk-size-limit SizeSuffix   If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off)
      --vfs-read-chunk-streams int             The number of parallel streams to read at once
      --vfs-read-wait Duration                 Time to wait for in-sequence read before seeking (default 20ms)
      --vfs-refresh                            Refreshes the directory cache recursively in the background on start
      --vfs-used-is-size rclone size           Use the rclone size algorithm for Used size
      --vfs-write-back Duration                Time to writeback files after last use when using cache (default 5s)
      --vfs-write-wait Duration                Time to wait for in-sequence write before giving error (default 1s)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

See Also

rclone serve restic

Serve the remote for restic's REST API.

Synopsis

Run a basic web server to serve a remote over restic's REST backend API over HTTP. This allows restic to use rclone as a data storage mechanism for cloud providers that restic does not support directly.

Restic is a command-line program for doing backups.

The server will log errors. Use -v to see access logs.

--bwlimit will be respected for file transfers. Use --stats to control the stats printing.

Setting up rclone for use by restic

First set up a remote for your chosen cloud provider.

Once you have set up the remote, check it is working with, for example "rclone lsd remote:". You may have called the remote something other than "remote:" - just substitute whatever you called it in the following instructions.

Now start the rclone restic server

rclone serve restic -v remote:backup

Where you can replace "backup" in the above by whatever path in the remote you wish to use.

By default this will serve on "localhost:8080" you can change this with use of the --addr flag.

You might wish to start this server on boot.

Adding --cache-objects=false will cause rclone to stop caching objects returned from the List call. Caching is normally desirable as it speeds up downloading objects, saves transactions and uses very little memory.

Setting up restic to use rclone

Now you can follow the restic instructions on setting up restic.

Note that you will need restic 0.8.2 or later to interoperate with rclone.

For the example above you will want to use "http://localhost:8080/" as the URL for the REST server.

For example:

$ export RESTIC_REPOSITORY=rest:http://localhost:8080/
$ export RESTIC_PASSWORD=yourpassword
$ restic init
created restic backend 8b1a4b56ae at rest:http://localhost:8080/

Please note that knowledge of your password is required to access
the repository. Losing your password means that your data is
irrecoverably lost.
$ restic backup /path/to/files/to/backup
scan [/path/to/files/to/backup]
scanned 189 directories, 312 files in 0:00
[0:00] 100.00%  38.128 MiB / 38.128 MiB  501 / 501 items  0 errors  ETA 0:00
duration: 0:00
snapshot 45c8fdd8 saved

Multiple repositories

Note that you can use the endpoint to host multiple repositories. Do this by adding a directory name or path after the URL. Note that these must end with /. Eg

$ export RESTIC_REPOSITORY=rest:http://localhost:8080/user1repo/
# backup user1 stuff
$ export RESTIC_REPOSITORY=rest:http://localhost:8080/user2repo/
# backup user2 stuff

Private repositories

The--private-repos flag can be used to limit users to repositories starting with a path of /<username>/.

Server options

Use --addr to specify which IP address and port the server should listen on, eg --addr 1.2.3.4:8000 or --addr :8080 to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port.

If you set --addr to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info.

You can use a unix socket by setting the url to unix:///path/to/socket or just by using an absolute path name.

--addr may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same.

--server-read-timeout and --server-write-timeout can be used to control the timeouts on the server. Note that this is the total time for a transfer.

--max-header-bytes controls the maximum number of bytes the server will accept in the HTTP header.

--baseurl controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used --baseurl "/rclone" then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on --baseurl, so --baseurl "rclone", --baseurl "/rclone" and --baseurl "/rclone/" are all treated identically.

TLS (SSL)

By default this will serve over http. If you want you can serve over https. You will need to supply the --cert and --key flags. If you wish to do client side certificate validation then you will need to supply --client-ca also.

--cert must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. --key must be set to the path of a file with the PEM encoded private key. If setting --client-ca, it should be set to the path of a file with PEM encoded client certificate authority certificates.

--min-tls-version is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0").

Socket activation

Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by --addr).

This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html

Socket activation can be tested ad-hoc with the systemd-socket-activatecommand

   systemd-socket-activate -l 8000 -- rclone serve

This will socket-activate rclone on the first connection to port 8000 over TCP. ### Authentication

By default this will serve files without needing a login.

You can either use an htpasswd file which can take lots of users, or set a single username and password with the --user and --pass flags.

Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with --user-from-header (e.g., ----user-from-header=x-remote-user). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access.

If either of the above authentication methods is not configured and client certificates are required by the --client-ca flag passed to the server, the client certificate common name will be considered as the username.

Use --htpasswd /path/to/htpasswd to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended.

To create an htpasswd file:

touch htpasswd
htpasswd -B htpasswd user
htpasswd -B htpasswd anotherUser

The password file can be updated while rclone is running.

Use --realm to set the authentication realm.

Use --salt to change the password hashing salt from the default.

rclone serve restic remote:path [flags]

Options

      --addr stringArray                IPaddress:Port or :Port to bind server to (default 127.0.0.1:8080)
      --allow-origin string             Origin which cross-domain request (CORS) can be executed from
      --append-only                     Disallow deletion of repository data
      --baseurl string                  Prefix for URLs - leave blank for root
      --cache-objects                   Cache listed objects (default true)
      --cert string                     TLS PEM key (concatenation of certificate and CA certificate)
      --client-ca string                Client certificate authority to verify clients with
  -h, --help                            help for restic
      --htpasswd string                 A htpasswd file - if not provided no authentication is done
      --key string                      TLS PEM Private key
      --max-header-bytes int            Maximum size of request header (default 4096)
      --min-tls-version string          Minimum TLS version that is acceptable (default "tls1.0")
      --pass string                     Password for authentication
      --private-repos                   Users can only access their private repo
      --realm string                    Realm for authentication
      --salt string                     Password hashing salt (default "dlPL2MqE")
      --server-read-timeout Duration    Timeout for server reading data (default 1h0m0s)
      --server-write-timeout Duration   Timeout for server writing data (default 1h0m0s)
      --stdio                           Run an HTTP2 server on stdin/stdout
      --user string                     User name for authentication
      --user-from-header string         User name from a defined HTTP header

See the global flags page for global options not listed here.

See Also

rclone serve s3

Serve remote:path over s3.

Synopsis

serve s3 implements a basic s3 server that serves a remote via s3. This can be viewed with an s3 client, or you can make an s3 type remote to read and write to it with rclone.

serve s3 is considered Experimental so use with care.

S3 server supports Signature Version 4 authentication. Just use --auth-key accessKey,secretKey and set the Authorization header correctly in the request. (See the AWS docs).

--auth-key can be repeated for multiple auth pairs. If --auth-key is not provided then serve s3 will allow anonymous access.

Please note that some clients may require HTTPS endpoints. See the SSL docs for more information.

This command uses the VFS directory cache. All the functionality will work with --vfs-cache-mode off. Using --vfs-cache-mode full (or writes) can be used to cache objects locally to improve performance.

Use --force-path-style=false if you want to use the bucket name as a part of the hostname (such as mybucket.local)

Use --etag-hash if you want to change the hash uses for the ETag. Note that using anything other than MD5 (the default) is likely to cause problems for S3 clients which rely on the Etag being the MD5.

Quickstart

For a simple set up, to serve remote:path over s3, run the server like this:

rclone serve s3 --auth-key ACCESS_KEY_ID,SECRET_ACCESS_KEY remote:path

For example, to use a simple folder in the filesystem, run the server with a command like this:

rclone serve s3 --auth-key ACCESS_KEY_ID,SECRET_ACCESS_KEY local:/path/to/folder

The rclone.conf for the server could look like this:

[local]
type = local

The local configuration is optional though. If you run the server with a remote:path like /path/to/folder (without the local: prefix and without an rclone.conf file), rclone will fall back to a default configuration, which will be visible as a warning in the logs. But it will run nonetheless.

This will be compatible with an rclone (client) remote configuration which is defined like this:

[serves3]
type = s3
provider = Rclone
endpoint = http://127.0.0.1:8080/
access_key_id = ACCESS_KEY_ID
secret_access_key = SECRET_ACCESS_KEY
use_multipart_uploads = false

Note that setting use_multipart_uploads = false is to work around a bug which will be fixed in due course.

Bugs

When uploading multipart files serve s3 holds all the parts in memory (see #7453). This is a limitaton of the library rclone uses for serving S3 and will hopefully be fixed at some point.

Multipart server side copies do not work (see #7454). These take a very long time and eventually fail. The default threshold for multipart server side copies is 5G which is the maximum it can be, so files above this side will fail to be server side copied.

For a current list of serve s3 bugs see the serve s3 bug category on GitHub.

Limitations

serve s3 will treat all directories in the root as buckets and ignore all files in the root. You can use CreateBucket to create folders under the root, but you can't create empty folders under other folders not in the root.

When using PutObject or DeleteObject, rclone will automatically create or clean up empty folders. If you don't want to clean up empty folders automatically, use --no-cleanup.

When using ListObjects, rclone will use / when the delimiter is empty. This reduces backend requests with no effect on most operations, but if the delimiter is something other than / and empty, rclone will do a full recursive search of the backend, which can take some time.

Versioning is not currently supported.

Metadata will only be saved in memory other than the rclone mtime metadata which will be set as the modification time of the file.

Supported operations

serve s3 currently supports the following operations.

  • Bucket
    • ListBuckets
    • CreateBucket
    • DeleteBucket
  • Object
    • HeadObject
    • ListObjects
    • GetObject
    • PutObject
    • DeleteObject
    • DeleteObjects
    • CreateMultipartUpload
    • CompleteMultipartUpload
    • AbortMultipartUpload
    • CopyObject
    • UploadPart

Other operations will return error Unimplemented.

Authentication

By default this will serve files without needing a login.

You can either use an htpasswd file which can take lots of users, or set a single username and password with the --user and --pass flags.

Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with --user-from-header (e.g., ----user-from-header=x-remote-user). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access.

If either of the above authentication methods is not configured and client certificates are required by the --client-ca flag passed to the server, the client certificate common name will be considered as the username.

Use --htpasswd /path/to/htpasswd to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended.

To create an htpasswd file:

touch htpasswd
htpasswd -B htpasswd user
htpasswd -B htpasswd anotherUser

The password file can be updated while rclone is running.

Use --realm to set the authentication realm.

Use --salt to change the password hashing salt from the default.

Server options

Use --addr to specify which IP address and port the server should listen on, eg --addr 1.2.3.4:8000 or --addr :8080 to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port.

If you set --addr to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info.

You can use a unix socket by setting the url to unix:///path/to/socket or just by using an absolute path name.

--addr may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same.

--server-read-timeout and --server-write-timeout can be used to control the timeouts on the server. Note that this is the total time for a transfer.

--max-header-bytes controls the maximum number of bytes the server will accept in the HTTP header.

--baseurl controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used --baseurl "/rclone" then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on --baseurl, so --baseurl "rclone", --baseurl "/rclone" and --baseurl "/rclone/" are all treated identically.

TLS (SSL)

By default this will serve over http. If you want you can serve over https. You will need to supply the --cert and --key flags. If you wish to do client side certificate validation then you will need to supply --client-ca also.

--cert must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. --key must be set to the path of a file with the PEM encoded private key. If setting --client-ca, it should be set to the path of a file with PEM encoded client certificate authority certificates.

--min-tls-version is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0").

Socket activation

Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by --addr).

This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html

Socket activation can be tested ad-hoc with the systemd-socket-activatecommand

   systemd-socket-activate -l 8000 -- rclone serve

This will socket-activate rclone on the first connection to port 8000 over TCP. ## VFS - Virtual File System

This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system.

Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below.

The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory.

VFS Directory Cache

Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache.

--dir-cache-time duration   Time to cache directory entries for (default 5m0s)
--poll-interval duration    Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s)

However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval.

You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this:

kill -SIGHUP $(pidof rclone)

If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache:

rclone rc vfs/forget

Or individual files or directories:

rclone rc vfs/forget file=path/to/file dir=path/to/dir

VFS File Buffering

The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance.

Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared.

This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used.

The maximum memory used by rclone for buffering can be up to --buffer-size * open files.

VFS File Caching

These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility.

For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details.

Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both.

--cache-dir string                     Directory rclone will use for caching.
--vfs-cache-mode CacheMode             Cache mode off|minimal|writes|full (default off)
--vfs-cache-max-age duration           Max time since last access of objects in the cache (default 1h0m0s)
--vfs-cache-max-size SizeSuffix        Max total size of objects in the cache (default off)
--vfs-cache-min-free-space SizeSuffix  Target minimum free space on the disk containing the cache (default off)
--vfs-cache-poll-interval duration     Interval to poll the cache for stale objects (default 1m0s)
--vfs-write-back duration              Time to writeback files after last use when using cache (default 5s)

If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable.

The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space.

Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags.

If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached.

The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w .

You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap.

--vfs-cache-mode off

In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk.

This will mean some operations are not possible

  • Files can't be opened for both read AND write
  • Files opened for write can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files open for read with O_TRUNC will be opened write only
  • Files open for write only will behave as if O_TRUNC was supplied
  • Open modes O_APPEND, O_TRUNC are ignored
  • If an upload fails it can't be retried

--vfs-cache-mode minimal

This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space.

These operations are not possible

  • Files opened for write only can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files opened for write only will ignore O_APPEND, O_TRUNC
  • If an upload fails it can't be retried

--vfs-cache-mode writes

In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first.

This mode should support all normal file system operations.

If an upload fails it will be retried at exponentially increasing intervals up to 1 minute.

--vfs-cache-mode full

In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well.

In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded.

So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them.

This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes.

When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk.

When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required.

IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected.

Fingerprinting

Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from:

  • size
  • modification time
  • hash

where available on an object.

On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object).

For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it.

If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files.

If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended.

Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again.

VFS Chunked Reading

When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests.

These flags control the chunking:

--vfs-read-chunk-size SizeSuffix        Read the source objects in chunks (default 128M)
--vfs-read-chunk-size-limit SizeSuffix  Max chunk doubling size (default off)
--vfs-read-chunk-streams int            The number of parallel streams to read at once

The chunking behaves differently depending on the --vfs-read-chunk-streams parameter.

--vfs-read-chunk-streams == 0

Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely.

With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on.

Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading.

The chunks will not be buffered in memory.

--vfs-read-chunk-streams > 0

Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant.

This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores.

Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend.

For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting.

Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput.

VFS Performance

These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature.

In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction.

--no-checksum     Don't compare checksums on up/download.
--no-modtime      Don't read/write the modification time (can speed things up).
--no-seek         Don't allow seeking in files.
--read-only       Only allow read-only access.

Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file.

--vfs-read-wait duration   Time to wait for in-sequence read before seeking (default 20ms)
--vfs-write-wait duration  Time to wait for in-sequence write before giving error (default 1s)

When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS).

--transfers int  Number of file transfers to run in parallel (default 4)

By default the VFS does not support symlinks. However this may be enabled with either of the following flags:

--links      Translate symlinks to/from regular files with a '.rclonelink' extension.
--vfs-links  Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS

As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination.

Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer.

This scheme is compatible with that used by the local backend with the --local-links flag.

The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs.

It hasn't been tested with the other rclone serve commands yet.

A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree

.
├── dir
│   └── file.txt
└── linked-dir -> dir

The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands.

Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa).

VFS Case Sensitivity

Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file.

File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case.

Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default.

The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below.

The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote.

Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target.

If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true".

The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues.

In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync.

VFS Disk Options

This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically.

--vfs-disk-space-total-size    Manually set the total disk space size (example: 256G, default: -1)

Alternate report of used bytes

Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself.

WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching.

VFS Metadata

If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires.

Note that some backends won't create metadata unless you pass in the --metadata flag.

For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get

$ ls -l /mnt/
total 1048577
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G

$ cat /mnt/1G.metadata
{
        "atime": "2025-03-04T17:34:22.317069787Z",
        "btime": "2025-03-03T16:03:37.708253808Z",
        "gid": "1000",
        "mode": "100664",
        "mtime": "2025-03-03T16:03:39.640238323Z",
        "uid": "1000"
}

$ ls -l /mnt/
total 1048578
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G
-rw-rw-r-- 1 user user        185 Mar  3 16:03 1G.metadata

If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}.

rclone serve s3 remote:path [flags]

Options

      --addr stringArray                       IPaddress:Port or :Port to bind server to (default 127.0.0.1:8080)
      --allow-origin string                    Origin which cross-domain request (CORS) can be executed from
      --auth-key stringArray                   Set key pair for v4 authorization: access_key_id,secret_access_key
      --auth-proxy string                      A program to use to create the backend from the auth
      --baseurl string                         Prefix for URLs - leave blank for root
      --cert string                            TLS PEM key (concatenation of certificate and CA certificate)
      --client-ca string                       Client certificate authority to verify clients with
      --dir-cache-time Duration                Time to cache directory entries for (default 5m0s)
      --dir-perms FileMode                     Directory permissions (default 777)
      --etag-hash string                       Which hash to use for the ETag, or auto or blank for off (default "MD5")
      --file-perms FileMode                    File permissions (default 666)
      --force-path-style                       If true use path style access if false use virtual hosted style (default true)
      --gid uint32                             Override the gid field set by the filesystem (not supported on Windows) (default 1000)
  -h, --help                                   help for s3
      --htpasswd string                        A htpasswd file - if not provided no authentication is done
      --key string                             TLS PEM Private key
      --link-perms FileMode                    Link permissions (default 666)
      --max-header-bytes int                   Maximum size of request header (default 4096)
      --min-tls-version string                 Minimum TLS version that is acceptable (default "tls1.0")
      --no-checksum                            Don't compare checksums on up/download
      --no-cleanup                             Not to cleanup empty folder after object is deleted
      --no-modtime                             Don't read/write the modification time (can speed things up)
      --no-seek                                Don't allow seeking in files
      --pass string                            Password for authentication
      --poll-interval Duration                 Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s)
      --read-only                              Only allow read-only access
      --realm string                           Realm for authentication
      --salt string                            Password hashing salt (default "dlPL2MqE")
      --server-read-timeout Duration           Timeout for server reading data (default 1h0m0s)
      --server-write-timeout Duration          Timeout for server writing data (default 1h0m0s)
      --uid uint32                             Override the uid field set by the filesystem (not supported on Windows) (default 1000)
      --umask FileMode                         Override the permission bits set by the filesystem (not supported on Windows) (default 002)
      --user string                            User name for authentication
      --user-from-header string                User name from a defined HTTP header
      --vfs-block-norm-dupes                   If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost)
      --vfs-cache-max-age Duration             Max time since last access of objects in the cache (default 1h0m0s)
      --vfs-cache-max-size SizeSuffix          Max total size of objects in the cache (default off)
      --vfs-cache-min-free-space SizeSuffix    Target minimum free space on the disk containing the cache (default off)
      --vfs-cache-mode CacheMode               Cache mode off|minimal|writes|full (default off)
      --vfs-cache-poll-interval Duration       Interval to poll the cache for stale objects (default 1m0s)
      --vfs-case-insensitive                   If a file name not found, find a case insensitive match
      --vfs-disk-space-total-size SizeSuffix   Specify the total space of disk (default off)
      --vfs-fast-fingerprint                   Use fast (less accurate) fingerprints for change detection
      --vfs-links                              Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS
      --vfs-metadata-extension string          Set the extension to read metadata from
      --vfs-read-ahead SizeSuffix              Extra read ahead over --buffer-size when using cache-mode full
      --vfs-read-chunk-size SizeSuffix         Read the source objects in chunks (default 128Mi)
      --vfs-read-chunk-size-limit SizeSuffix   If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off)
      --vfs-read-chunk-streams int             The number of parallel streams to read at once
      --vfs-read-wait Duration                 Time to wait for in-sequence read before seeking (default 20ms)
      --vfs-refresh                            Refreshes the directory cache recursively in the background on start
      --vfs-used-is-size rclone size           Use the rclone size algorithm for Used size
      --vfs-write-back Duration                Time to writeback files after last use when using cache (default 5s)
      --vfs-write-wait Duration                Time to wait for in-sequence write before giving error (default 1s)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

See Also

rclone serve sftp

Serve the remote over SFTP.

Synopsis

Run an SFTP server to serve a remote over SFTP. This can be used with an SFTP client or you can make a remote of type sftp to use with it.

You can use the filter flags (e.g. --include, --exclude) to control what is served.

The server will respond to a small number of shell commands, mainly md5sum, sha1sum and df, which enable it to provide support for checksums and the about feature when accessed from an sftp remote.

Note that this server uses standard 32 KiB packet payload size, which means you must not configure the client to expect anything else, e.g. with the chunk_size option on an sftp remote.

The server will log errors. Use -v to see access logs.

--bwlimit will be respected for file transfers. Use --stats to control the stats printing.

You must provide some means of authentication, either with --user/--pass, an authorized keys file (specify location with --authorized-keys - the default is the same as ssh), an --auth-proxy, or set the --no-auth flag for no authentication when logging in.

If you don't supply a host --key then rclone will generate rsa, ecdsa and ed25519 variants, and cache them for later use in rclone's cache directory (see rclone help flags cache-dir) in the "serve-sftp" directory.

By default the server binds to localhost:2022 - if you want it to be reachable externally then supply --addr :2022 for example.

This also supports being run with socket activation, in which case it will listen on the first passed FD. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html

Socket activation can be tested ad-hoc with the systemd-socket-activatecommand:

systemd-socket-activate -l 2222 -- rclone serve sftp :local:vfs/

This will socket-activate rclone on the first connection to port 2222 over TCP.

Note that the default of --vfs-cache-mode off is fine for the rclone sftp backend, but it may not be with other SFTP clients.

If --stdio is specified, rclone will serve SFTP over stdio, which can be used with sshd via ~/.ssh/authorized_keys, for example:

restrict,command="rclone serve sftp --stdio ./photos" ssh-rsa ...

On the client you need to set --transfers 1 when using --stdio. Otherwise multiple instances of the rclone server are started by OpenSSH which can lead to "corrupted on transfer" errors. This is the case because the client chooses indiscriminately which server to send commands to while the servers all have different views of the state of the filing system.

The "restrict" in authorized_keys prevents SHA1SUMs and MD5SUMs from being used. Omitting "restrict" and using --sftp-path-override to enable checksumming is possible but less secure and you could use the SFTP server provided by OpenSSH in this case.

VFS - Virtual File System

This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system.

Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below.

The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory.

VFS Directory Cache

Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache.

--dir-cache-time duration   Time to cache directory entries for (default 5m0s)
--poll-interval duration    Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s)

However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval.

You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this:

kill -SIGHUP $(pidof rclone)

If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache:

rclone rc vfs/forget

Or individual files or directories:

rclone rc vfs/forget file=path/to/file dir=path/to/dir

VFS File Buffering

The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance.

Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared.

This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used.

The maximum memory used by rclone for buffering can be up to --buffer-size * open files.

VFS File Caching

These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility.

For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details.

Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both.

--cache-dir string                     Directory rclone will use for caching.
--vfs-cache-mode CacheMode             Cache mode off|minimal|writes|full (default off)
--vfs-cache-max-age duration           Max time since last access of objects in the cache (default 1h0m0s)
--vfs-cache-max-size SizeSuffix        Max total size of objects in the cache (default off)
--vfs-cache-min-free-space SizeSuffix  Target minimum free space on the disk containing the cache (default off)
--vfs-cache-poll-interval duration     Interval to poll the cache for stale objects (default 1m0s)
--vfs-write-back duration              Time to writeback files after last use when using cache (default 5s)

If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable.

The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space.

Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags.

If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached.

The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w .

You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap.

--vfs-cache-mode off

In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk.

This will mean some operations are not possible

  • Files can't be opened for both read AND write
  • Files opened for write can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files open for read with O_TRUNC will be opened write only
  • Files open for write only will behave as if O_TRUNC was supplied
  • Open modes O_APPEND, O_TRUNC are ignored
  • If an upload fails it can't be retried

--vfs-cache-mode minimal

This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space.

These operations are not possible

  • Files opened for write only can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files opened for write only will ignore O_APPEND, O_TRUNC
  • If an upload fails it can't be retried

--vfs-cache-mode writes

In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first.

This mode should support all normal file system operations.

If an upload fails it will be retried at exponentially increasing intervals up to 1 minute.

--vfs-cache-mode full

In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well.

In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded.

So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them.

This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes.

When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk.

When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required.

IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected.

Fingerprinting

Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from:

  • size
  • modification time
  • hash

where available on an object.

On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object).

For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it.

If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files.

If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended.

Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again.

VFS Chunked Reading

When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests.

These flags control the chunking:

--vfs-read-chunk-size SizeSuffix        Read the source objects in chunks (default 128M)
--vfs-read-chunk-size-limit SizeSuffix  Max chunk doubling size (default off)
--vfs-read-chunk-streams int            The number of parallel streams to read at once

The chunking behaves differently depending on the --vfs-read-chunk-streams parameter.

--vfs-read-chunk-streams == 0

Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely.

With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on.

Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading.

The chunks will not be buffered in memory.

--vfs-read-chunk-streams > 0

Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant.

This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores.

Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend.

For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting.

Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput.

VFS Performance

These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature.

In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction.

--no-checksum     Don't compare checksums on up/download.
--no-modtime      Don't read/write the modification time (can speed things up).
--no-seek         Don't allow seeking in files.
--read-only       Only allow read-only access.

Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file.

--vfs-read-wait duration   Time to wait for in-sequence read before seeking (default 20ms)
--vfs-write-wait duration  Time to wait for in-sequence write before giving error (default 1s)

When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS).

--transfers int  Number of file transfers to run in parallel (default 4)

By default the VFS does not support symlinks. However this may be enabled with either of the following flags:

--links      Translate symlinks to/from regular files with a '.rclonelink' extension.
--vfs-links  Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS

As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination.

Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer.

This scheme is compatible with that used by the local backend with the --local-links flag.

The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs.

It hasn't been tested with the other rclone serve commands yet.

A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree

.
├── dir
│   └── file.txt
└── linked-dir -> dir

The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands.

Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa).

VFS Case Sensitivity

Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file.

File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case.

Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default.

The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below.

The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote.

Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target.

If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true".

The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues.

In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync.

VFS Disk Options

This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically.

--vfs-disk-space-total-size    Manually set the total disk space size (example: 256G, default: -1)

Alternate report of used bytes

Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself.

WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching.

VFS Metadata

If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires.

Note that some backends won't create metadata unless you pass in the --metadata flag.

For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get

$ ls -l /mnt/
total 1048577
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G

$ cat /mnt/1G.metadata
{
        "atime": "2025-03-04T17:34:22.317069787Z",
        "btime": "2025-03-03T16:03:37.708253808Z",
        "gid": "1000",
        "mode": "100664",
        "mtime": "2025-03-03T16:03:39.640238323Z",
        "uid": "1000"
}

$ ls -l /mnt/
total 1048578
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G
-rw-rw-r-- 1 user user        185 Mar  3 16:03 1G.metadata

If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}.

Auth Proxy

If you supply the parameter --auth-proxy /path/to/program then rclone will use that program to generate backends on the fly which then are used to authenticate incoming requests. This uses a simple JSON based protocol with input on STDIN and output on STDOUT.

PLEASE NOTE: --auth-proxy and --authorized-keys cannot be used together, if --auth-proxy is set the authorized keys option will be ignored.

There is an example program bin/test_proxy.py in the rclone source code.

The program's job is to take a user and pass on the input and turn those into the config for a backend on STDOUT in JSON format. This config will have any default parameters for the backend added, but it won't use configuration from environment variables or command line options - it is the job of the proxy program to make a complete config.

This config generated must have this extra parameter - _root - root to use for the backend

And it may have this parameter - _obscure - comma separated strings for parameters to obscure

If password authentication was used by the client, input to the proxy process (on STDIN) would look similar to this:

{
    "user": "me",
    "pass": "mypassword"
}

If public-key authentication was used by the client, input to the proxy process (on STDIN) would look similar to this:

{
    "user": "me",
    "public_key": "AAAAB3NzaC1yc2EAAAADAQABAAABAQDuwESFdAe14hVS6omeyX7edc...JQdf"
}

And as an example return this on STDOUT

{
    "type": "sftp",
    "_root": "",
    "_obscure": "pass",
    "user": "me",
    "pass": "mypassword",
    "host": "sftp.example.com"
}

This would mean that an SFTP backend would be created on the fly for the user and pass/public_key returned in the output to the host given. Note that since _obscure is set to pass, rclone will obscure the pass parameter before creating the backend (which is required for sftp backends).

The program can manipulate the supplied user in any way, for example to make proxy to many different sftp backends, you could make the user be user@example.com and then set the host to example.com in the output and the user to user. For security you'd probably want to restrict the host to a limited list.

Note that an internal cache is keyed on user so only use that for configuration, don't use pass or public_key. This also means that if a user's password or public-key is changed the cache will need to expire (which takes 5 mins) before it takes effect.

This can be used to build general purpose proxies to any kind of backend that rclone supports.

rclone serve sftp remote:path [flags]

Options

      --addr string                            IPaddress:Port or :Port to bind server to (default "localhost:2022")
      --auth-proxy string                      A program to use to create the backend from the auth
      --authorized-keys string                 Authorized keys file (default "~/.ssh/authorized_keys")
      --dir-cache-time Duration                Time to cache directory entries for (default 5m0s)
      --dir-perms FileMode                     Directory permissions (default 777)
      --file-perms FileMode                    File permissions (default 666)
      --gid uint32                             Override the gid field set by the filesystem (not supported on Windows) (default 1000)
  -h, --help                                   help for sftp
      --key stringArray                        SSH private host key file (Can be multi-valued, leave blank to auto generate)
      --link-perms FileMode                    Link permissions (default 666)
      --no-auth                                Allow connections with no authentication if set
      --no-checksum                            Don't compare checksums on up/download
      --no-modtime                             Don't read/write the modification time (can speed things up)
      --no-seek                                Don't allow seeking in files
      --pass string                            Password for authentication
      --poll-interval Duration                 Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s)
      --read-only                              Only allow read-only access
      --stdio                                  Run an sftp server on stdin/stdout
      --uid uint32                             Override the uid field set by the filesystem (not supported on Windows) (default 1000)
      --umask FileMode                         Override the permission bits set by the filesystem (not supported on Windows) (default 002)
      --user string                            User name for authentication
      --vfs-block-norm-dupes                   If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost)
      --vfs-cache-max-age Duration             Max time since last access of objects in the cache (default 1h0m0s)
      --vfs-cache-max-size SizeSuffix          Max total size of objects in the cache (default off)
      --vfs-cache-min-free-space SizeSuffix    Target minimum free space on the disk containing the cache (default off)
      --vfs-cache-mode CacheMode               Cache mode off|minimal|writes|full (default off)
      --vfs-cache-poll-interval Duration       Interval to poll the cache for stale objects (default 1m0s)
      --vfs-case-insensitive                   If a file name not found, find a case insensitive match
      --vfs-disk-space-total-size SizeSuffix   Specify the total space of disk (default off)
      --vfs-fast-fingerprint                   Use fast (less accurate) fingerprints for change detection
      --vfs-links                              Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS
      --vfs-metadata-extension string          Set the extension to read metadata from
      --vfs-read-ahead SizeSuffix              Extra read ahead over --buffer-size when using cache-mode full
      --vfs-read-chunk-size SizeSuffix         Read the source objects in chunks (default 128Mi)
      --vfs-read-chunk-size-limit SizeSuffix   If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off)
      --vfs-read-chunk-streams int             The number of parallel streams to read at once
      --vfs-read-wait Duration                 Time to wait for in-sequence read before seeking (default 20ms)
      --vfs-refresh                            Refreshes the directory cache recursively in the background on start
      --vfs-used-is-size rclone size           Use the rclone size algorithm for Used size
      --vfs-write-back Duration                Time to writeback files after last use when using cache (default 5s)
      --vfs-write-wait Duration                Time to wait for in-sequence write before giving error (default 1s)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

See Also

rclone serve webdav

Serve remote:path over WebDAV.

Synopsis

Run a basic WebDAV server to serve a remote over HTTP via the WebDAV protocol. This can be viewed with a WebDAV client, through a web browser, or you can make a remote of type WebDAV to read and write it.

WebDAV options

--etag-hash

This controls the ETag header. Without this flag the ETag will be based on the ModTime and Size of the object.

If this flag is set to "auto" then rclone will choose the first supported hash on the backend or you can use a named hash such as "MD5" or "SHA-1". Use the hashsum command to see the full list.

Access WebDAV on Windows

WebDAV shared folder can be mapped as a drive on Windows, however the default settings prevent it. Windows will fail to connect to the server using insecure Basic authentication. It will not even display any login dialog. Windows requires SSL / HTTPS connection to be used with Basic. If you try to connect via Add Network Location Wizard you will get the following error: "The folder you entered does not appear to be valid. Please choose another". However, you still can connect if you set the following registry key on a client machine: HKEY_LOCAL_MACHINEto 2. The BasicAuthLevel can be set to the following values: 0 - Basic authentication disabled 1 - Basic authentication enabled for SSL connections only 2 - Basic authentication enabled for SSL connections and for non-SSL connections If required, increase the FileSizeLimitInBytes to a higher value. Navigate to the Services interface, then restart the WebClient service.

Access Office applications on WebDAV

Navigate to following registry HKEY_CURRENT_USER[14.0/15.0/16.0] Create a new DWORD BasicAuthLevel with value 2. 0 - Basic authentication disabled 1 - Basic authentication enabled for SSL connections only 2 - Basic authentication enabled for SSL and for non-SSL connections

https://learn.microsoft.com/en-us/office/troubleshoot/powerpoint/office-opens-blank-from-sharepoint

Serving over a unix socket

You can serve the webdav on a unix socket like this:

rclone serve webdav --addr unix:///tmp/my.socket remote:path

and connect to it like this using rclone and the webdav backend:

rclone --webdav-unix-socket /tmp/my.socket --webdav-url http://localhost lsf :webdav:

Note that there is no authentication on http protocol - this is expected to be done by the permissions on the socket.

Server options

Use --addr to specify which IP address and port the server should listen on, eg --addr 1.2.3.4:8000 or --addr :8080 to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port.

If you set --addr to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info.

You can use a unix socket by setting the url to unix:///path/to/socket or just by using an absolute path name.

--addr may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same.

--server-read-timeout and --server-write-timeout can be used to control the timeouts on the server. Note that this is the total time for a transfer.

--max-header-bytes controls the maximum number of bytes the server will accept in the HTTP header.

--baseurl controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used --baseurl "/rclone" then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on --baseurl, so --baseurl "rclone", --baseurl "/rclone" and --baseurl "/rclone/" are all treated identically.

TLS (SSL)

By default this will serve over http. If you want you can serve over https. You will need to supply the --cert and --key flags. If you wish to do client side certificate validation then you will need to supply --client-ca also.

--cert must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. --key must be set to the path of a file with the PEM encoded private key. If setting --client-ca, it should be set to the path of a file with PEM encoded client certificate authority certificates.

--min-tls-version is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0").

Socket activation

Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by --addr).

This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html

Socket activation can be tested ad-hoc with the systemd-socket-activatecommand

   systemd-socket-activate -l 8000 -- rclone serve

This will socket-activate rclone on the first connection to port 8000 over TCP. ### Template

--template allows a user to specify a custom markup template for HTTP and WebDAV serve functions. The server exports the following markup to be used within the template to server pages:

Parameter Description
.Name The full path of a file/directory.
.Title Directory listing of .Name
.Sort The current sort used. This is changeable via ?sort= parameter
Sort Options: namedirfirst,name,size,time (default namedirfirst)
.Order The current ordering used. This is changeable via ?order= parameter
Order Options: asc,desc (default asc)
.Query Currently unused.
.Breadcrumb Allows for creating a relative navigation
-- .Link The relative to the root link of the Text.
-- .Text The Name of the directory.
.Entries Information about a specific file/directory.
-- .URL The 'url' of an entry.
-- .Leaf Currently same as 'URL' but intended to be 'just' the name.
-- .IsDir Boolean for if an entry is a directory or not.
-- .Size Size in Bytes of the entry.
-- .ModTime The UTC timestamp of an entry.

The server also makes the following functions available so that they can be used within the template. These functions help extend the options for dynamic rendering of HTML. They can be used to render HTML based on specific conditions.

Function Description
afterEpoch Returns the time since the epoch for the given time.
contains Checks whether a given substring is present or not in a given string.
hasPrefix Checks whether the given string begins with the specified prefix.
hasSuffix Checks whether the given string end with the specified suffix.

Authentication

By default this will serve files without needing a login.

You can either use an htpasswd file which can take lots of users, or set a single username and password with the --user and --pass flags.

Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with --user-from-header (e.g., ----user-from-header=x-remote-user). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access.

If either of the above authentication methods is not configured and client certificates are required by the --client-ca flag passed to the server, the client certificate common name will be considered as the username.

Use --htpasswd /path/to/htpasswd to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended.

To create an htpasswd file:

touch htpasswd
htpasswd -B htpasswd user
htpasswd -B htpasswd anotherUser

The password file can be updated while rclone is running.

Use --realm to set the authentication realm.

Use --salt to change the password hashing salt from the default.

VFS - Virtual File System

This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system.

Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below.

The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory.

VFS Directory Cache

Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache.

--dir-cache-time duration   Time to cache directory entries for (default 5m0s)
--poll-interval duration    Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s)

However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval.

You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this:

kill -SIGHUP $(pidof rclone)

If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache:

rclone rc vfs/forget

Or individual files or directories:

rclone rc vfs/forget file=path/to/file dir=path/to/dir

VFS File Buffering

The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance.

Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared.

This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used.

The maximum memory used by rclone for buffering can be up to --buffer-size * open files.

VFS File Caching

These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility.

For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details.

Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both.

--cache-dir string                     Directory rclone will use for caching.
--vfs-cache-mode CacheMode             Cache mode off|minimal|writes|full (default off)
--vfs-cache-max-age duration           Max time since last access of objects in the cache (default 1h0m0s)
--vfs-cache-max-size SizeSuffix        Max total size of objects in the cache (default off)
--vfs-cache-min-free-space SizeSuffix  Target minimum free space on the disk containing the cache (default off)
--vfs-cache-poll-interval duration     Interval to poll the cache for stale objects (default 1m0s)
--vfs-write-back duration              Time to writeback files after last use when using cache (default 5s)

If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable.

The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space.

Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags.

If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached.

The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w .

You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap.

--vfs-cache-mode off

In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk.

This will mean some operations are not possible

  • Files can't be opened for both read AND write
  • Files opened for write can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files open for read with O_TRUNC will be opened write only
  • Files open for write only will behave as if O_TRUNC was supplied
  • Open modes O_APPEND, O_TRUNC are ignored
  • If an upload fails it can't be retried

--vfs-cache-mode minimal

This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space.

These operations are not possible

  • Files opened for write only can't be seeked
  • Existing files opened for write must have O_TRUNC set
  • Files opened for write only will ignore O_APPEND, O_TRUNC
  • If an upload fails it can't be retried

--vfs-cache-mode writes

In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first.

This mode should support all normal file system operations.

If an upload fails it will be retried at exponentially increasing intervals up to 1 minute.

--vfs-cache-mode full

In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well.

In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded.

So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them.

This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes.

When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk.

When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required.

IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected.

Fingerprinting

Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from:

  • size
  • modification time
  • hash

where available on an object.

On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object).

For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it.

If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files.

If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended.

Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again.

VFS Chunked Reading

When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests.

These flags control the chunking:

--vfs-read-chunk-size SizeSuffix        Read the source objects in chunks (default 128M)
--vfs-read-chunk-size-limit SizeSuffix  Max chunk doubling size (default off)
--vfs-read-chunk-streams int            The number of parallel streams to read at once

The chunking behaves differently depending on the --vfs-read-chunk-streams parameter.

--vfs-read-chunk-streams == 0

Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely.

With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on.

Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading.

The chunks will not be buffered in memory.

--vfs-read-chunk-streams > 0

Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant.

This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores.

Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend.

For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting.

Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput.

VFS Performance

These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature.

In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction.

--no-checksum     Don't compare checksums on up/download.
--no-modtime      Don't read/write the modification time (can speed things up).
--no-seek         Don't allow seeking in files.
--read-only       Only allow read-only access.

Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file.

--vfs-read-wait duration   Time to wait for in-sequence read before seeking (default 20ms)
--vfs-write-wait duration  Time to wait for in-sequence write before giving error (default 1s)

When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS).

--transfers int  Number of file transfers to run in parallel (default 4)

By default the VFS does not support symlinks. However this may be enabled with either of the following flags:

--links      Translate symlinks to/from regular files with a '.rclonelink' extension.
--vfs-links  Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS

As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination.

Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer.

This scheme is compatible with that used by the local backend with the --local-links flag.

The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs.

It hasn't been tested with the other rclone serve commands yet.

A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree

.
├── dir
│   └── file.txt
└── linked-dir -> dir

The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands.

Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa).

VFS Case Sensitivity

Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file.

File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case.

Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default.

The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below.

The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote.

Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target.

If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true".

The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues.

In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync.

VFS Disk Options

This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically.

--vfs-disk-space-total-size    Manually set the total disk space size (example: 256G, default: -1)

Alternate report of used bytes

Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself.

WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching.

VFS Metadata

If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires.

Note that some backends won't create metadata unless you pass in the --metadata flag.

For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get

$ ls -l /mnt/
total 1048577
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G

$ cat /mnt/1G.metadata
{
        "atime": "2025-03-04T17:34:22.317069787Z",
        "btime": "2025-03-03T16:03:37.708253808Z",
        "gid": "1000",
        "mode": "100664",
        "mtime": "2025-03-03T16:03:39.640238323Z",
        "uid": "1000"
}

$ ls -l /mnt/
total 1048578
-rw-rw-r-- 1 user user 1073741824 Mar  3 16:03 1G
-rw-rw-r-- 1 user user        185 Mar  3 16:03 1G.metadata

If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}.

Auth Proxy

If you supply the parameter --auth-proxy /path/to/program then rclone will use that program to generate backends on the fly which then are used to authenticate incoming requests. This uses a simple JSON based protocol with input on STDIN and output on STDOUT.

PLEASE NOTE: --auth-proxy and --authorized-keys cannot be used together, if --auth-proxy is set the authorized keys option will be ignored.

There is an example program bin/test_proxy.py in the rclone source code.

The program's job is to take a user and pass on the input and turn those into the config for a backend on STDOUT in JSON format. This config will have any default parameters for the backend added, but it won't use configuration from environment variables or command line options - it is the job of the proxy program to make a complete config.

This config generated must have this extra parameter - _root - root to use for the backend

And it may have this parameter - _obscure - comma separated strings for parameters to obscure

If password authentication was used by the client, input to the proxy process (on STDIN) would look similar to this:

{
    "user": "me",
    "pass": "mypassword"
}

If public-key authentication was used by the client, input to the proxy process (on STDIN) would look similar to this:

{
    "user": "me",
    "public_key": "AAAAB3NzaC1yc2EAAAADAQABAAABAQDuwESFdAe14hVS6omeyX7edc...JQdf"
}

And as an example return this on STDOUT

{
    "type": "sftp",
    "_root": "",
    "_obscure": "pass",
    "user": "me",
    "pass": "mypassword",
    "host": "sftp.example.com"
}

This would mean that an SFTP backend would be created on the fly for the user and pass/public_key returned in the output to the host given. Note that since _obscure is set to pass, rclone will obscure the pass parameter before creating the backend (which is required for sftp backends).

The program can manipulate the supplied user in any way, for example to make proxy to many different sftp backends, you could make the user be user@example.com and then set the host to example.com in the output and the user to user. For security you'd probably want to restrict the host to a limited list.

Note that an internal cache is keyed on user so only use that for configuration, don't use pass or public_key. This also means that if a user's password or public-key is changed the cache will need to expire (which takes 5 mins) before it takes effect.

This can be used to build general purpose proxies to any kind of backend that rclone supports.

rclone serve webdav remote:path [flags]

Options

      --addr stringArray                       IPaddress:Port or :Port to bind server to (default 127.0.0.1:8080)
      --allow-origin string                    Origin which cross-domain request (CORS) can be executed from
      --auth-proxy string                      A program to use to create the backend from the auth
      --baseurl string                         Prefix for URLs - leave blank for root
      --cert string                            TLS PEM key (concatenation of certificate and CA certificate)
      --client-ca string                       Client certificate authority to verify clients with
      --dir-cache-time Duration                Time to cache directory entries for (default 5m0s)
      --dir-perms FileMode                     Directory permissions (default 777)
      --disable-dir-list                       Disable HTML directory list on GET request for a directory
      --etag-hash string                       Which hash to use for the ETag, or auto or blank for off
      --file-perms FileMode                    File permissions (default 666)
      --gid uint32                             Override the gid field set by the filesystem (not supported on Windows) (default 1000)
  -h, --help                                   help for webdav
      --htpasswd string                        A htpasswd file - if not provided no authentication is done
      --key string                             TLS PEM Private key
      --link-perms FileMode                    Link permissions (default 666)
      --max-header-bytes int                   Maximum size of request header (default 4096)
      --min-tls-version string                 Minimum TLS version that is acceptable (default "tls1.0")
      --no-checksum                            Don't compare checksums on up/download
      --no-modtime                             Don't read/write the modification time (can speed things up)
      --no-seek                                Don't allow seeking in files
      --pass string                            Password for authentication
      --poll-interval Duration                 Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s)
      --read-only                              Only allow read-only access
      --realm string                           Realm for authentication
      --salt string                            Password hashing salt (default "dlPL2MqE")
      --server-read-timeout Duration           Timeout for server reading data (default 1h0m0s)
      --server-write-timeout Duration          Timeout for server writing data (default 1h0m0s)
      --template string                        User-specified template
      --uid uint32                             Override the uid field set by the filesystem (not supported on Windows) (default 1000)
      --umask FileMode                         Override the permission bits set by the filesystem (not supported on Windows) (default 002)
      --user string                            User name for authentication
      --user-from-header string                User name from a defined HTTP header
      --vfs-block-norm-dupes                   If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost)
      --vfs-cache-max-age Duration             Max time since last access of objects in the cache (default 1h0m0s)
      --vfs-cache-max-size SizeSuffix          Max total size of objects in the cache (default off)
      --vfs-cache-min-free-space SizeSuffix    Target minimum free space on the disk containing the cache (default off)
      --vfs-cache-mode CacheMode               Cache mode off|minimal|writes|full (default off)
      --vfs-cache-poll-interval Duration       Interval to poll the cache for stale objects (default 1m0s)
      --vfs-case-insensitive                   If a file name not found, find a case insensitive match
      --vfs-disk-space-total-size SizeSuffix   Specify the total space of disk (default off)
      --vfs-fast-fingerprint                   Use fast (less accurate) fingerprints for change detection
      --vfs-links                              Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS
      --vfs-metadata-extension string          Set the extension to read metadata from
      --vfs-read-ahead SizeSuffix              Extra read ahead over --buffer-size when using cache-mode full
      --vfs-read-chunk-size SizeSuffix         Read the source objects in chunks (default 128Mi)
      --vfs-read-chunk-size-limit SizeSuffix   If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off)
      --vfs-read-chunk-streams int             The number of parallel streams to read at once
      --vfs-read-wait Duration                 Time to wait for in-sequence read before seeking (default 20ms)
      --vfs-refresh                            Refreshes the directory cache recursively in the background on start
      --vfs-used-is-size rclone size           Use the rclone size algorithm for Used size
      --vfs-write-back Duration                Time to writeback files after last use when using cache (default 5s)
      --vfs-write-wait Duration                Time to wait for in-sequence write before giving error (default 1s)

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

See Also

rclone settier

Changes storage class/tier of objects in remote.

Synopsis

Changes storage tier or class at remote if supported. Few cloud storage services provides different storage classes on objects, for example AWS S3 and Glacier, Azure Blob storage - Hot, Cool and Archive, Google Cloud Storage, Regional Storage, Nearline, Coldline etc.

Note that, certain tier changes make objects not available to access immediately. For example tiering to archive in azure blob storage makes objects in frozen state, user can restore by setting tier to Hot/Cool, similarly S3 to Glacier makes object inaccessible.true

You can use it to tier single object

rclone settier Cool remote:path/file

Or use rclone filters to set tier on only specific files

rclone --include "*.txt" settier Hot remote:path/dir

Or just provide remote directory and all files in directory will be tiered

rclone settier tier remote:path/dir
rclone settier tier remote:path [flags]

Options

  -h, --help   help for settier

See the global flags page for global options not listed here.

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone test

Run a test command

Synopsis

Rclone test is used to run test commands.

Select which test command you want with the subcommand, eg

rclone test memory remote:

Each subcommand has its own options which you can see in their help.

NB Be careful running these commands, they may do strange things so reading their documentation first is recommended.

Options

  -h, --help   help for test

See the global flags page for global options not listed here.

See Also

rclone test changenotify

Log any change notify requests for the remote passed in.

rclone test changenotify remote: [flags]

Options

  -h, --help                     help for changenotify
      --poll-interval Duration   Time to wait between polling for changes (default 10s)

See the global flags page for global options not listed here.

See Also

rclone test histogram

Makes a histogram of file name characters.

Synopsis

This command outputs JSON which shows the histogram of characters used in filenames in the remote:path specified.

The data doesn't contain any identifying information but is useful for the rclone developers when developing filename compression.

rclone test histogram [remote:path] [flags]

Options

  -h, --help   help for histogram

See the global flags page for global options not listed here.

See Also

rclone test info

Discovers file name or other limitations for paths.

Synopsis

Discovers what filenames and upload methods are possible to write to the paths passed in and how long they can be. It can take some time. It will write test files into the remote:path passed in. It outputs a bit of go code for each one.

NB this can create undeletable files and other hazards - use with care

rclone test info [remote:path]+ [flags]

Options

      --all                    Run all tests
      --check-base32768        Check can store all possible base32768 characters
      --check-control          Check control characters
      --check-length           Check max filename length
      --check-normalization    Check UTF-8 Normalization
      --check-streaming        Check uploads with indeterminate file size
  -h, --help                   help for info
      --keep-test-files        Keep test files after execution
      --upload-wait Duration   Wait after writing a file (default 0s)
      --write-json string      Write results to file

See the global flags page for global options not listed here.

See Also

rclone test makefile

Make files with random contents of the size given

rclone test makefile <size> [<file>]+ [flags]

Options

      --ascii      Fill files with random ASCII printable bytes only
      --chargen    Fill files with a ASCII chargen pattern
  -h, --help       help for makefile
      --pattern    Fill files with a periodic pattern
      --seed int   Seed for the random number generator (0 for random) (default 1)
      --sparse     Make the files sparse (appear to be filled with ASCII 0x00)
      --zero       Fill files with ASCII 0x00

See the global flags page for global options not listed here.

See Also

rclone test makefiles

Make a random file hierarchy in a directory

rclone test makefiles <dir> [flags]

Options

      --ascii                      Fill files with random ASCII printable bytes only
      --chargen                    Fill files with a ASCII chargen pattern
      --files int                  Number of files to create (default 1000)
      --files-per-directory int    Average number of files per directory (default 10)
      --flat                       If set create all files in the root directory
  -h, --help                       help for makefiles
      --max-depth int              Maximum depth of directory hierarchy (default 10)
      --max-file-size SizeSuffix   Maximum size of files to create (default 100)
      --max-name-length int        Maximum size of file names (default 12)
      --min-file-size SizeSuffix   Minimum size of file to create
      --min-name-length int        Minimum size of file names (default 4)
      --pattern                    Fill files with a periodic pattern
      --seed int                   Seed for the random number generator (0 for random) (default 1)
      --sparse                     Make the files sparse (appear to be filled with ASCII 0x00)
      --zero                       Fill files with ASCII 0x00

See the global flags page for global options not listed here.

See Also

rclone test memory

Load all the objects at remote:path into memory and report memory stats.

rclone test memory remote:path [flags]

Options

  -h, --help   help for memory

See the global flags page for global options not listed here.

See Also

rclone touch

Create new file or change file modification time.

Synopsis

Set the modification time on file(s) as specified by remote:path to have the current time.

If remote:path does not exist then a zero sized file will be created, unless --no-create or --recursive is provided.

If --recursive is used then recursively sets the modification time on all existing files that is found under the path. Filters are supported, and you can test with the --dry-run or the --interactive/-i flag. This will touch --transfers files concurrently.

If --timestamp is used then sets the modification time to that time instead of the current time. Times may be specified as one of:

  • 'YYMMDD' - e.g. 17.10.30
  • 'YYYY-MM-DDTHH:MM:SS' - e.g. 2006-01-02T15:04:05
  • 'YYYY-MM-DDTHH:MM:SS.SSS' - e.g. 2006-01-02T15:04:05.123456789

Note that value of --timestamp is in UTC. If you want local time then add the --localtime flag.

rclone touch remote:path [flags]

Options

  -h, --help               help for touch
      --localtime          Use localtime for timestamp, not UTC
  -C, --no-create          Do not create the file if it does not exist (implied with --recursive)
  -R, --recursive          Recursively touch all files
  -t, --timestamp string   Use specified time instead of the current time of day

Options shared with other commands are described next. See the global flags page for global options not listed here.

Important Options

Important flags useful for most commands

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

rclone tree

List the contents of the remote in a tree like fashion.

Synopsis

Lists the contents of a remote in a similar way to the unix tree command.

For example

$ rclone tree remote:path
/
├── file1
├── file2
├── file3
└── subdir
    ├── file4
    └── file5

1 directories, 5 files

You can use any of the filtering options with the tree command (e.g. --include and --exclude. You can also use --fast-list.

The tree command has many options for controlling the listing which are compatible with the tree command, for example you can include file sizes with --size. Note that not all of them have short options as they conflict with rclone's short options.

For a more interactive navigation of the remote see the ncdu command.

rclone tree remote:path [flags]

Options

  -a, --all             All files are listed (list . files too)
  -d, --dirs-only       List directories only
      --dirsfirst       List directories before files (-U disables)
      --full-path       Print the full path prefix for each file
  -h, --help            help for tree
      --level int       Descend only level directories deep
  -D, --modtime         Print the date of last modification.
      --noindent        Don't print indentation lines
      --noreport        Turn off file/directory count at end of tree listing
  -o, --output string   Output to file instead of stdout
  -p, --protections     Print the protections for each file.
  -Q, --quote           Quote filenames with double quotes.
  -s, --size            Print the size in bytes of each file.
      --sort string     Select sort: name,version,size,mtime,ctime
      --sort-ctime      Sort files by last status change time
  -t, --sort-modtime    Sort files by last modification time
  -r, --sort-reverse    Reverse the order of the sort
  -U, --unsorted        Leave files unsorted
      --version         Sort files alphanumerically by version

Options shared with other commands are described next. See the global flags page for global options not listed here.

Filter Options

Flags for filtering directory listings

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing Options

Flags for listing directories

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

See Also

  • rclone - Show help for rclone commands, flags and backends.

Copying single files

rclone normally syncs or copies directories. However, if the source remote points to a file, rclone will just copy that file. The destination remote must point to a directory - rclone will give the error Failed to create file system for "remote:file": is a file not a directory if it isn't.

For example, suppose you have a remote with a file in called test.jpg, then you could copy just that file like this

rclone copy remote:test.jpg /tmp/download

The file test.jpg will be placed inside /tmp/download.

This is equivalent to specifying

rclone copy --files-from /tmp/files remote: /tmp/download

Where /tmp/files contains the single line

test.jpg

It is recommended to use copy when copying individual files, not sync. They have pretty much the same effect but copy will use a lot less memory.

Syntax of remote paths

The syntax of the paths passed to the rclone command are as follows.

/path/to/dir

This refers to the local file system.

On Windows \ may be used instead of / in local paths only, non local paths must use /. See local filesystem documentation for more about Windows-specific paths.

These paths needn't start with a leading / - if they don't then they will be relative to the current directory.

remote:path/to/dir

This refers to a directory path/to/dir on remote: as defined in the config file (configured with rclone config).

remote:/path/to/dir

On most backends this is refers to the same directory as remote:path/to/dir and that format should be preferred. On a very small number of remotes (FTP, SFTP, Dropbox for business) this will refer to a different directory. On these, paths without a leading / will refer to your "home" directory and paths with a leading / will refer to the root.

:backend:path/to/dir

This is an advanced form for creating remotes on the fly. backend should be the name or prefix of a backend (the type in the config file) and all the configuration for the backend should be provided on the command line (or in environment variables).

Here are some examples:

rclone lsd --http-url https://pub.rclone.org :http:

To list all the directories in the root of https://pub.rclone.org/.

rclone lsf --http-url https://example.com :http:path/to/dir

To list files and directories in https://example.com/path/to/dir/

rclone copy --http-url https://example.com :http:path/to/dir /tmp/dir

To copy files and directories in https://example.com/path/to/dir to /tmp/dir.

rclone copy --sftp-host example.com :sftp:path/to/dir /tmp/dir

To copy files and directories from example.com in the relative directory path/to/dir to /tmp/dir using sftp.

Connection strings

The above examples can also be written using a connection string syntax, so instead of providing the arguments as command line parameters --http-url https://pub.rclone.org they are provided as part of the remote specification as a kind of connection string.

rclone lsd ":http,url='https://pub.rclone.org':"
rclone lsf ":http,url='https://example.com':path/to/dir"
rclone copy ":http,url='https://example.com':path/to/dir" /tmp/dir
rclone copy :sftp,host=example.com:path/to/dir /tmp/dir

These can apply to modify existing remotes as well as create new remotes with the on the fly syntax. This example is equivalent to adding the --drive-shared-with-me parameter to the remote gdrive:.

rclone lsf "gdrive,shared_with_me:path/to/dir"

The major advantage to using the connection string style syntax is that it only applies to the remote, not to all the remotes of that type of the command line. A common confusion is this attempt to copy a file shared on google drive to the normal drive which does not work because the --drive-shared-with-me flag applies to both the source and the destination.

rclone copy --drive-shared-with-me gdrive:shared-file.txt gdrive:

However using the connection string syntax, this does work.

rclone copy "gdrive,shared_with_me:shared-file.txt" gdrive:

Note that the connection string only affects the options of the immediate backend. If for example gdriveCrypt is a crypt based on gdrive, then the following command will not work as intended, because shared_with_me is ignored by the crypt backend:

rclone copy "gdriveCrypt,shared_with_me:shared-file.txt" gdriveCrypt:

The connection strings have the following syntax

remote,parameter=value,parameter2=value2:path/to/dir
:backend,parameter=value,parameter2=value2:path/to/dir

If the parameter has a : or , then it must be placed in quotes " or ', so

remote,parameter="colon:value",parameter2="comma,value":path/to/dir
:backend,parameter='colon:value',parameter2='comma,value':path/to/dir

If a quoted value needs to include that quote, then it should be doubled, so

remote,parameter="with""quote",parameter2='with''quote':path/to/dir

This will make parameter be with"quote and parameter2 be with'quote.

If you leave off the =parameter then rclone will substitute =true which works very well with flags. For example, to use s3 configured in the environment you could use:

rclone lsd :s3,env_auth:

Which is equivalent to

rclone lsd :s3,env_auth=true:

Note that on the command line you might need to surround these connection strings with " or ' to stop the shell interpreting any special characters within them.

If you are a shell master then you'll know which strings are OK and which aren't, but if you aren't sure then enclose them in " and use ' as the inside quote. This syntax works on all OSes.

rclone copy ":http,url='https://example.com':path/to/dir" /tmp/dir

On Linux/macOS some characters are still interpreted inside " strings in the shell (notably \ and $ and ") so if your strings contain those you can swap the roles of " and ' thus. (This syntax does not work on Windows.)

rclone copy ':http,url="https://example.com":path/to/dir' /tmp/dir

Connection strings, config and logging

If you supply extra configuration to a backend by command line flag, environment variable or connection string then rclone will add a suffix based on the hash of the config to the name of the remote, eg

rclone -vv lsf --s3-chunk-size 20M s3:

Has the log message

DEBUG : s3: detected overridden config - adding "{Srj1p}" suffix to name

This is so rclone can tell the modified remote apart from the unmodified remote when caching the backends.

This should only be noticeable in the logs.

This means that on the fly backends such as

rclone -vv lsf :s3,env_auth:

Will get their own names

DEBUG : :s3: detected overridden config - adding "{YTu53}" suffix to name

Valid remote names

Remote names are case sensitive, and must adhere to the following rules:

  • May contain number, letter, _, -, ., +, @ and space.
  • May not start with - or space.
  • May not end with space.

Starting with rclone version 1.61, any Unicode numbers and letters are allowed, while in older versions it was limited to plain ASCII (0-9, A-Z, a-z). If you use the same rclone configuration from different shells, which may be configured with different character encoding, you must be cautious to use characters that are possible to write in all of them. This is mostly a problem on Windows, where the console traditionally uses a non-Unicode character set - defined by the so-called "code page".

Do not use single character names on Windows as it creates ambiguity with Windows drives' names, e.g.: remote called C is indistinguishable from C drive. Rclone will always assume that single letter name refers to a drive.

Adding global configuration to a remote

It is possible to add global configuration to the remote configuration which will be applied just before the remote is created.

This can be done in two ways. The first is to use override.var = value in the config file or the connection string for a temporary change, and the second is to use global.var = value in the config file or connection string for a permanent change.

This is explained fully below.

override.var

This is used to override a global variable just for the duration of the remote creation. It won't affect other remotes even if they are created at the same time.

This is very useful for overriding networking config needed for just for that remote. For example, say you have a remote which needs --no-check-certificate as it is running on test infrastructure without a proper certificate. You could supply the --no-check-certificate flag to rclone, but this will affect all the remotes. To make it just affect this remote you use an override. You could put this in the config file:

[remote]
type = XXX
...
override.no_check_certificate = true

or use it in the connection string remote,override.no_check_certificate=true: (or just remote,override.no_check_certificate:).

Note how the global flag name loses its initial -- and gets - replaced with _ and gets an override. prefix.

Not all global variables make sense to be overridden like this as the config is only applied during the remote creation. Here is a non exhaustive list of ones which might be useful:

  • bind_addr
  • ca_cert
  • client_cert
  • client_key
  • connect_timeout
  • disable_http2
  • disable_http_keep_alives
  • dump
  • expect_continue_timeout
  • headers
  • http_proxy
  • low_level_retries
  • max_connections
  • no_check_certificate
  • no_gzip
  • timeout
  • traffic_class
  • use_cookies
  • use_server_modtime
  • user_agent

An override.var will override all other config methods, but just for the duration of the creation of the remote.

global.var

This is used to set a global variable for everything. The global variable is set just before the remote is created.

This is useful for parameters (eg sync parameters) which can't be set as an override. For example, say you have a remote where you would always like to use the --checksum flag. You could supply the --checksum flag to rclone on every command line, but instead you could put this in the config file:

[remote]
type = XXX
...
global.checksum = true

or use it in the connection string remote,global.checksum=true: (or just remote,global.checksum:). This is equivalent to using the --checksum flag.

Note how the global flag name loses its initial -- and gets - replaced with _ and gets a global. prefix.

Any global variable can be set like this and it is exactly equivalent to using the equivalent flag on the command line. This means it will affect all uses of rclone.

If two remotes set the same global variable then the first one instantiated will be overridden by the second one. A global.var will override all other config methods when the remote is created.

Quoting and the shell

When you are typing commands to your computer you are using something called the command line shell. This interprets various characters in an OS specific way.

Here are some gotchas which may help users unfamiliar with the shell rules

Linux / macOS

If your names have spaces or shell metacharacters (e.g. *, ?, $, ', ", etc.) then you must quote them. Use single quotes ' by default.

rclone copy 'Important files?' remote:backup

If you want to send a ' you will need to use ", e.g.

rclone copy "O'Reilly Reviews" remote:backup

The rules for quoting metacharacters are complicated and if you want the full details you'll have to consult the manual page for your shell.

Windows

If your names have spaces in you need to put them in ", e.g.

rclone copy "E:\folder name\folder name\folder name" remote:backup

If you are using the root directory on its own then don't quote it (see #464 for why), e.g.

rclone copy E:\ remote:backup

Copying files or directories with : in the names

rclone uses : to mark a remote name. This is, however, a valid filename component in non-Windows OSes. The remote name parser will only search for a : up to the first / so if you need to act on a file or directory like this then use the full path starting with a /, or use ./ as a current directory prefix.

So to sync a directory called sync:me to a remote called remote: use

rclone sync --interactive ./sync:me remote:path

or

rclone sync --interactive /full/path/to/sync:me remote:path

Server-side copy

Most remotes (but not all - see the overview) support server-side copy.

This means if you want to copy one folder to another then rclone won't download all the files and re-upload them; it will instruct the server to copy them in place.

Eg

rclone copy s3:oldbucket s3:newbucket

Will copy the contents of oldbucket to newbucket without downloading and re-uploading.

Remotes which don't support server-side copy will download and re-upload in this case.

Server-side copies are used with sync and copy and will be identified in the log when using the -v flag. The move command may also use them if remote doesn't support server-side move directly. This is done by issuing a server-side copy then a delete which is much quicker than a download and re-upload.

Server-side copies will only be attempted if the remote names are the same.

This can be used when scripting to make aged backups efficiently, e.g.

rclone sync --interactive remote:current-backup remote:previous-backup
rclone sync --interactive /path/to/files remote:current-backup

Metadata support

Metadata is data about a file (or directory) which isn't the contents of the file (or directory). Normally rclone only preserves the modification time and the content (MIME) type where possible.

Rclone supports preserving all the available metadata on files and directories when using the --metadata or -M flag.

Exactly what metadata is supported and what that support means depends on the backend. Backends that support metadata have a metadata section in their docs and are listed in the features table (Eg local, s3)

Some backends don't support metadata, some only support metadata on files and some support metadata on both files and directories.

Rclone only supports a one-time sync of metadata. This means that metadata will be synced from the source object to the destination object only when the source object has changed and needs to be re-uploaded. If the metadata subsequently changes on the source object without changing the object itself then it won't be synced to the destination object. This is in line with the way rclone syncs Content-Type without the --metadata flag.

Using --metadata when syncing from local to local will preserve file attributes such as file mode, owner, extended attributes (not Windows).

Note that arbitrary metadata may be added to objects using the --metadata-set key=value flag when the object is first uploaded. This flag can be repeated as many times as necessary.

The --metadata-mapper flag can be used to pass the name of a program in which can transform metadata when it is being copied from source to destination.

Rclone supports --metadata-set and --metadata-mapper when doing server-side Move and server-side Copy, but not when doing server side DirMove (renaming a directory) as this would involve recursing into the directory. Note that you can disable DirMove with --disable DirMove and rclone will revert back to using Move for each individual object where --metadata-set and --metadata-mapper are supported.

Types of metadata

Metadata is divided into two type. System metadata and User metadata.

Metadata which the backend uses itself is called system metadata. For example on the local backend the system metadata uid will store the user ID of the file when used on a unix based platform.

Arbitrary metadata is called user metadata and this can be set however is desired.

When objects are copied from backend to backend, they will attempt to interpret system metadata if it is supplied. Metadata may change from being user metadata to system metadata as objects are copied between different backends. For example copying an object from s3 sets the content-type metadata. In a backend which understands this (like azureblob) this will become the Content-Type of the object. In a backend which doesn't understand this (like the local backend) this will become user metadata. However should the local object be copied back to s3, the Content-Type will be set correctly.

Metadata framework

Rclone implements a metadata framework which can read metadata from an object and write it to the object when (and only when) it is being uploaded.

This metadata is stored as a dictionary with string keys and string values.

There are some limits on the names of the keys (these may be clarified further in the future).

  • must be lower case
  • may be a-z 0-9 containing . - or _
  • length is backend dependent

Each backend can provide system metadata that it understands. Some backends can also store arbitrary user metadata.

Where possible the key names are standardized, so, for example, it is possible to copy object metadata from s3 to azureblob for example and metadata will be translated appropriately.

Some backends have limits on the size of the metadata and rclone will give errors on upload if they are exceeded.

Metadata preservation

The goal of the implementation is to

  1. Preserve metadata if at all possible
  2. Interpret metadata if at all possible

The consequences of 1 is that you can copy an S3 object to a local disk then back to S3 losslessly. Likewise you can copy a local file with file attributes and xattrs from local disk to s3 and back again losslessly.

The consequence of 2 is that you can copy an S3 object with metadata to Azureblob (say) and have the metadata appear on the Azureblob object also.

Standard system metadata

Here is a table of standard system metadata which, if appropriate, a backend may implement.

key description example
mode File type and mode: octal, unix style 0100664
uid User ID of owner: decimal number 500
gid Group ID of owner: decimal number 500
rdev Device ID (if special file) => hexadecimal 0
atime Time of last access: RFC 3339 2006-01-02T15:04:05.999999999Z07:00
mtime Time of last modification: RFC 3339 2006-01-02T15:04:05.999999999Z07:00
btime Time of file creation (birth): RFC 3339 2006-01-02T15:04:05.999999999Z07:00
utime Time of file upload: RFC 3339 2006-01-02T15:04:05.999999999Z07:00
cache-control Cache-Control header no-cache
content-disposition Content-Disposition header inline
content-encoding Content-Encoding header gzip
content-language Content-Language header en-US
content-type Content-Type header text/plain

The metadata keys mtime and content-type will take precedence if supplied in the metadata over reading the Content-Type or modification time of the source object.

Hashes are not included in system metadata as there is a well defined way of reading those already.

Options

Rclone has a number of options to control its behaviour. These are documented below, and in the flags page.

Options that take parameters can have the values passed in two ways, --option=value or --option value. However boolean (true/false) options behave slightly differently to the other options in that --boolean sets the option to true and the absence of the flag sets it to false. It is also possible to specify --boolean=false or --boolean=true. Note that --boolean false is not valid - this is parsed as --boolean and the false is parsed as an extra command line argument for rclone.

String values that are recognized as special identifiers, e.g. the name of the log level to set with option --log-level, are case insensitive, e.g. --log-level ERROR and --log-level error are identical.

Options documented to take a stringArray parameter accept multiple values. To pass more than one value, repeat the option; for example: --include value1 --include value2. Other options may only accept a single value, and should only be specified once, but where the specified parameter may indicate a list of values separated by space or comma. Such options are documented to take a CommaSepList parameter, if comma separated, and SpaceSepList if space separated, although some may also have different parameters such as DumpFlags or just string and the help text explains that this will be interpreted as a list.

Floating-point values with fractional part must use period (.) as decimal separator, common in English-speaking countries, regardless of your configured system locale. Parameter type float accepts decimal and hexadecimal floating-point numbers as defined by the Go syntax for floating-point literals.

Time and duration options

Options that take a Time or Duration parameter must be specified as a formatted string describing an absolute or relative time. Note that both Time and Duration parameter types can be expressed as either absolute or relative time, just with different interpretations, e.g. a relative time will be treated as an offset from the current time when passed as a Time value.

An absolute time can be specified as a string in one of the following formats:

  • RFC3339 - e.g. 2006-01-02T15:04:05Z or 2006-01-02T15:04:05+07:00
  • ISO8601 Date and time, local timezone - 2006-01-02T15:04:05
  • ISO8601 Date and time, local timezone - 2006-01-02 15:04:05
  • ISO8601 Date - 2006-01-02 (YYYY-MM-DD)

A relative time is a string with a, possibly signed, sequence of decimal numbers, each with optional fraction, and each with a unit suffix. If the string only contains a single number, then the unit suffix is optional and will default to seconds, i.e. a plain decimal value will be treated as a number of seconds. The following suffixes are valid:

  • ms - Milliseconds
  • s - Seconds
  • m - Minutes
  • h - Hours
  • d - Days
  • w - Weeks
  • M - Months
  • y - Years

Examples: "10", "300ms", "-1.5h" or "2h45m".

Size options

Options that take a SizeSuffix parameter can be specified as an integer value, which will then be assumed to represent a KiB value (multiples of 1024 bytes) by default. The interpretation can be changed by appending a suffix: B for Byte, K for KiB, M for MiB, G for GiB, T for TiB and P for PiB. These are the binary units, e.g. 1, 2**10, 2**20, 2**30 respectively.

See also --human-readable.

Main options

--backup-dir string

When using sync, copy or move, any files which would have been overwritten or deleted are moved in their original hierarchy into this directory.

If --suffix is set, then the moved files will have the suffix added to them. If there is a file with the same path (after the suffix has been added) in the directory, then it will be overwritten.

The remote in use must support server-side move or copy and you must use the same remote as the destination of the sync. The backup directory must not overlap the destination directory without it being excluded by a filter rule.

For example

rclone sync --interactive /path/to/local remote:current --backup-dir remote:old

will sync /path/to/local to remote:current, but for any files which would have been updated or deleted will be stored in remote:old.

If running rclone from a script you might want to use today's date as the directory name passed to --backup-dir to store the old files, or you might want to pass --suffix with today's date.

See --compare-dest and --copy-dest.

--bind string

Local address to bind to for outgoing connections. This can be an IPv4 address (1.2.3.4), an IPv6 address (1234::789A) or host name. If the host name doesn't resolve or resolves to more than one IP address it will give an error.

You can use --bind 0.0.0.0 to force rclone to use IPv4 addresses and --bind ::0 to force rclone to use IPv6 addresses.

--bwlimit BwTimetable

This option controls the bandwidth limit. For example

--bwlimit 10M

would mean limit the upload and download bandwidth to 10 MiB/s. NB this is bytes per second not bits per second. To use a single limit, specify the desired bandwidth in KiB/s, or use a suffix B|K|M|G|T|P. The default is 0 which means to not limit bandwidth.

The upload and download bandwidth can be specified separately, as --bwlimit UP:DOWN, so

--bwlimit 10M:100k

would mean limit the upload bandwidth to 10 MiB/s and the download bandwidth to 100 KiB/s. Either limit can be "off" meaning no limit, so to just limit the upload bandwidth you would use

--bwlimit 10M:off

this would limit the upload bandwidth to 10 MiB/s but the download bandwidth would be unlimited.

When specified as above the bandwidth limits last for the duration of run of the rclone binary.

It is also possible to specify a "timetable" of limits, which will cause certain limits to be applied at certain times. To specify a timetable, format your entries as WEEKDAY-HH:MM,BANDWIDTH WEEKDAY-HH:MM,BANDWIDTH... where: WEEKDAY is optional element.

  • BANDWIDTH can be a single number, e.g.100k or a pair of numbers for upload:download, e.g.10M:1M.
  • WEEKDAY can be written as the whole word or only using the first 3 characters. It is optional.
  • HH:MM is an hour from 00:00 to 23:59.

Entries can be separated by spaces or semicolons.

Note: Semicolons can be used as separators instead of spaces to avoid parsing issues in environments like Docker.

An example of a typical timetable to avoid link saturation during daytime working hours could be:

Using spaces as separators: --bwlimit "08:00,512k 12:00,10M 13:00,512k 18:00,30M 23:00,off"

Using semicolons as separators: --bwlimit "08:00,512k;12:00,10M;13:00,512k;18:00,30M;23:00,off"

In these examples, the transfer bandwidth will be set to 512 KiB/s at 8am every day. At noon, it will rise to 10 MiB/s, and drop back to 512 KiB/sec at 1pm. At 6pm, the bandwidth limit will be set to 30 MiB/s, and at 11pm it will be completely disabled (full speed). Anything between 11pm and 8am will remain unlimited.

An example of timetable with WEEKDAY could be:

Using spaces as separators: --bwlimit "Mon-00:00,512 Fri-23:59,10M Sat-10:00,1M Sun-20:00,off"

Using semicolons as separators: --bwlimit "Mon-00:00,512;Fri-23:59,10M;Sat-10:00,1M;Sun-20:00,off"

It means that, the transfer bandwidth will be set to 512 KiB/s on Monday. It will rise to 10 MiB/s before the end of Friday. At 10:00 on Saturday it will be set to 1 MiB/s. From 20:00 on Sunday it will be unlimited.

Timeslots without WEEKDAY are extended to the whole week. So this example:

--bwlimit "Mon-00:00,512 12:00,1M Sun-20:00,off"

Is equivalent to this:

--bwlimit "Mon-00:00,512Mon-12:00,1M Tue-12:00,1M Wed-12:00,1M Thu-12:00,1M Fri-12:00,1M Sat-12:00,1M Sun-12:00,1M Sun-20:00,off"

Bandwidth limit apply to the data transfer for all backends. For most backends the directory listing bandwidth is also included (exceptions being the non HTTP backends, ftp, sftp and storj).

Note that the units are Byte/s, not bit/s. Typically connections are measured in bit/s - to convert divide by 8. For example, let's say you have a 10 Mbit/s connection and you wish rclone to use half of it - 5 Mbit/s. This is 5/8 = 0.625 MiB/s so you would use a --bwlimit 0.625M parameter for rclone.

On Unix systems (Linux, macOS, …) the bandwidth limiter can be toggled by sending a SIGUSR2 signal to rclone. This allows to remove the limitations of a long running rclone transfer and to restore it back to the value specified with --bwlimit quickly when needed. Assuming there is only one rclone instance running, you can toggle the limiter like this:

kill -SIGUSR2 $(pidof rclone)

If you configure rclone with a remote control then you can use change the bwlimit dynamically:

rclone rc core/bwlimit rate=1M

--bwlimit-file BwTimetable

This option controls per file bandwidth limit. For the options see the --bwlimit flag.

For example use this to allow no transfers to be faster than 1 MiB/s

--bwlimit-file 1M

This can be used in conjunction with --bwlimit.

Note that if a schedule is provided the file will use the schedule in effect at the start of the transfer.

--buffer-size SizeSuffix

Use this sized buffer to speed up file transfers. Each --transfer will use this much memory for buffering.

When using mount or cmount each open file descriptor will use this much memory for buffering. See the mount documentation for more details.

Set to 0 to disable the buffering for the minimum memory usage.

Note that the memory allocation of the buffers is influenced by the --use-mmap flag.

--cache-dir string

Specify the directory rclone will use for caching, to override the default.

Default value is depending on operating system:

  • Windows %LocalAppData%\rclone, if LocalAppData is defined.
  • macOS $HOME/Library/Caches/rclone if HOME is defined.
  • Unix $XDG_CACHE_HOME/rclone if XDG_CACHE_HOME is defined, else $HOME/.cache/rclone if HOME is defined.
  • Fallback (on all OS) to $TMPDIR/rclone, where TMPDIR is the value from --temp-dir.

You can use the config paths command to see the current value.

Cache directory is heavily used by the VFS File Caching mount feature, but also by serve, GUI and other parts of rclone.

--check-first

If this flag is set then in a sync, copy or move, rclone will do all the checks to see whether files need to be transferred before doing any of the transfers. Normally rclone would start running transfers as soon as possible.

This flag can be useful on IO limited systems where transfers interfere with checking.

It can also be useful to ensure perfect ordering when using --order-by.

If both --check-first and --order-by are set when doing rclone move then rclone will use the transfer thread to delete source files which don't need transferring. This will enable perfect ordering of the transfers and deletes but will cause the transfer stats to have more items in than expected.

Using this flag can use more memory as it effectively sets --max-backlog to infinite. This means that all the info on the objects to transfer is held in memory before the transfers start.

--checkers int

Originally controlling just the number of file checkers to run in parallel, e.g. by rclone copy. Now a fairly universal parallelism control used by rclone in several places.

Note: checkers do the equality checking of files during a sync. For some storage systems (e.g. S3, Swift, Dropbox) this can take a significant amount of time so they are run in parallel.

The default is to run 8 checkers in parallel. However, in case of slow-reacting backends you may need to lower (rather than increase) this default by setting --checkers to 4 or less threads. This is especially advised if you are experiencing backend server crashes during file checking phase (e.g. on subsequent or top-up backups where little or no file copying is done and checking takes up most of the time). Increase this setting only with utmost care, while monitoring your server health and file checking throughput.

-c, --checksum

Normally rclone will look at modification time and size of files to see if they are equal. If you set this flag then rclone will check the file hash and size to determine if files are equal.

This is useful when the remote doesn't support setting modified time and a more accurate sync is desired than just checking the file size.

This is very useful when transferring between remotes which store the same hash type on the object, e.g. Drive and Swift. For details of which remotes support which hash type see the table in the overview section.

Eg rclone --checksum sync s3:/bucket swift:/bucket would run much quicker than without the --checksum flag.

When using this flag, rclone won't update mtimes of remote files if they are incorrect as it would normally.

--color AUTO|NEVER|ALWAYS

Specify when colors (and other ANSI codes) should be added to the output.

AUTO only allows ANSI codes when the output is a terminal. This is the default.

NEVER never allow ANSI codes.

ALWAYS always add ANSI codes, regardless of the output format (terminal or file).

--compare-dest stringArray

When using sync, copy or move, the specified paths are checked in addition to the destination for files. If a file identical to the source is found, that file is not copied from source. This is useful to copy just files that have changed since the last backup.

You must use the same remote as the destination of the sync. The compare directory must not overlap the destination directory.

See --copy-dest and --backup-dir.

--config string

Specify the location of the rclone configuration file, to override the default. E.g. rclone config --config="rclone.conf".

The exact default is a bit complex to describe, due to changes introduced through different versions of rclone while preserving backwards compatibility, but in most cases it is as simple as:

  • %APPDATA%/rclone/rclone.conf on Windows
  • ~/.config/rclone/rclone.conf on other

The complete logic is as follows: Rclone will look for an existing configuration file in any of the following locations, in priority order:

  1. rclone.conf (in program directory, where rclone executable is)
  2. %APPDATA%/rclone/rclone.conf (only on Windows)
  3. $XDG_CONFIG_HOME/rclone/rclone.conf (on all systems, including Windows)
  4. ~/.config/rclone/rclone.conf (see below for explanation of ~ symbol)
  5. ~/.rclone.conf

If no existing configuration file is found, then a new one will be created in the following location:

  • On Windows: Location 2 listed above, except in the unlikely event that APPDATA is not defined, then location 4 is used instead.
  • On Unix: Location 3 if XDG_CONFIG_HOME is defined, else location 4.
  • Fallback to location 5 (on all OS), when the rclone directory cannot be created, but if also a home directory was not found then path .rclone.conf relative to current working directory will be used as a final resort.

The ~ symbol in paths above represent the home directory of the current user on any OS, and the value is defined as following:

  • On Windows: %HOME% if defined, else %USERPROFILE%, or else %HOMEDRIVE%\%HOMEPATH%.
  • On Unix: $HOME if defined, else by looking up current user in OS-specific user database (e.g. passwd file), or else use the result from shell command cd && pwd.

If you run rclone config file you will see where the default location is for you. Running rclone config touch will ensure a configuration file exists, creating an empty one in the default location if there is none.

The fact that an existing file rclone.conf in the same directory as the rclone executable is always preferred, means that it is easy to run in "portable" mode by downloading rclone executable to a writable directory and then create an empty file rclone.conf in the same directory.

If the location is set to empty string "" or path to a file with name notfound, or the os null device represented by value NUL on Windows and /dev/null on Unix systems, then rclone will keep the configuration file in memory only.

You may see a log message "Config file not found - using defaults" if there is no configuration file. This can be supressed, e.g. if you are using rclone entirely with on the fly remotes, by using memory-only configuration file or by creating an empty configuration file, as described above.

The file format is basic INI: Sections of text, led by a [section] header and followed by key=value entries on separate lines. In rclone each remote is represented by its own section, where the section name defines the name of the remote. Options are specified as the key=value entries, where the key is the option name without the --backend- prefix, in lowercase and with _ instead of -. E.g. option --mega-hard-delete corresponds to key hard_delete. Only backend options can be specified. A special, and required, key type identifies the storage system, where the value is the internal lowercase name as returned by command rclone help backends. Comments are indicated by ; or # at the beginning of a line.

Example:

[megaremote]
type = mega
user = you@example.com
pass = PDPcQVVjVtzFY-GTdDFozqBhTdsPg3qH

Note that passwords are in obscured form. Also, many storage systems uses token-based authentication instead of passwords, and this requires additional steps. It is easier, and safer, to use the interactive command rclone config instead of manually editing the configuration file.

The configuration file will typically contain login information, and should therefore have restricted permissions so that only the current user can read it. Rclone tries to ensure this when it writes the file. You may also choose to encrypt the file.

When token-based authentication are used, the configuration file must be writable, because rclone needs to update the tokens inside it.

To reduce risk of corrupting an existing configuration file, rclone will not write directly to it when saving changes. Instead it will first write to a new, temporary, file. If a configuration file already existed, it will (on Unix systems) try to mirror its permissions to the new file. Then it will rename the existing file to a temporary name as backup. Next, rclone will rename the new file to the correct name, before finally cleaning up by deleting the backup file.

If the configuration file path used by rclone is a symbolic link, then this will be evaluated and rclone will write to the resolved path, instead of overwriting the symbolic link. Temporary files used in the process (described above) will be written to the same parent directory as that of the resolved configuration file, but if this directory is also a symbolic link it will not be resolved and the temporary files will be written to the location of the directory symbolic link.

--contimeout Duration

Set the connection timeout. This should be in go time format which looks like 5s for 5 seconds, 10m for 10 minutes, or 3h30m.

The connection timeout is the amount of time rclone will wait for a connection to go through to a remote object storage system. It is 1m by default.

--copy-dest stringArray

When using sync, copy or move, the specified paths are checked in addition to the destination for files. This part is the same as --compare-dest, but the difference is that with --copy-dest, if a file identical to the source is found, that file is server-side copied from the specified paths to the destination. This is useful for incremental backup.

The remote in use must support server-side copy and you must use the same remote as the destination of the sync. The compare directory must not overlap the destination directory.

See --compare-dest and --backup-dir.

--dedupe-mode interactive|skip|first|newest|oldest|largest|smallest|rename|list

Mode to run dedupe command in. One of interactive, skip, first, newest, oldest, largest, smallest, rename list. The default is interactive. See the dedupe command for more information as to what these options mean.

--default-time Time

If a file or directory does have a modification time rclone can read then rclone will display this fixed time instead.

The default is 2000-01-01 00:00:00 UTC. This can be configured in any of the ways shown in time options.

For example --default-time 2020-06-01 to set the default time to the 1st of June 2020 or --default-time 0s to set the default time to the time rclone started up.

--disable string

This disables a comma separated list of optional features. For example to disable server-side move and server-side copy use:

--disable move,copy

The features can be put in any case.

To see a list of which features can be disabled use:

--disable help

The features a remote has can be seen in JSON format with:

rclone backend features remote:

See the overview features and optional features to get an idea of which feature does what.

Note that some features can be set to true if they are true/false feature flag features by prefixing them with !. For example the CaseInsensitive feature can be forced to false with --disable CaseInsensitive and forced to true with --disable '!CaseInsensitive'. In general it isn't a good idea doing this but it may be useful in extremis.

(Note that ! is a shell command which you will need to escape with single quotes or a backslash on unix like platforms.)

This flag can be useful for debugging and in exceptional circumstances (e.g. Google Drive limiting the total volume of server-side copies to 100 GiB/day).

--disable-http2

This stops rclone from trying to use HTTP/2 if available. This can sometimes speed up transfers due to a problem in the Go standard library.

--dscp string

Specify a DSCP value or name to use in connections. This could help QoS system to identify traffic class. BE, EF, DF, LE, CSx and AFxx are allowed.

See the description of differentiated services to get an idea of this field. Setting this to 1 (LE) to identify the flow to SCAVENGER class can avoid occupying too much bandwidth in a network with DiffServ support (RFC 8622).

For example, if you configured QoS on router to handle LE properly. Running:

rclone copy --dscp LE from:/from to:/to

would make the priority lower than usual internet flows.

This option has no effect on Windows (see golang/go#42728).

-n, --dry-run

Do a trial run with no permanent changes. Use this to see what rclone would do without actually doing it. Useful when setting up the sync command which deletes files in the destination.

--expect-continue-timeout Duration

This specifies the amount of time to wait for a server's first response headers after fully writing the request headers if the request has an "Expect: 100-continue" header. Not all backends support using this.

Zero means no timeout and causes the body to be sent immediately, without waiting for the server to approve. This time does not include the time to send the request header.

The default is 1s. Set to 0 to disable.

--error-on-no-transfer

By default, rclone will exit with return code 0 if there were no errors.

This option allows rclone to return exit code 9 if no files were transferred between the source and destination. This allows using rclone in scripts, and triggering follow-on actions if data was copied, or skipping if not.

NB: Enabling this option turns a usually non-fatal error into a potentially fatal one - please check and adjust your scripts accordingly!

--fix-case

Normally, a sync to a case insensitive dest (such as macOS / Windows) will not result in a matching filename if the source and dest filenames have casing differences but are otherwise identical. For example, syncing hello.txt to HELLO.txt will normally result in the dest filename remaining HELLO.txt. If --fix-case is set, then HELLO.txt will be renamed to hello.txt to match the source.

NB:

  • directory names with incorrect casing will also be fixed
  • --fix-case will be ignored if --immutable is set
  • using --local-case-sensitive instead is not advisable; it will cause HELLO.txt to get deleted!
  • the old dest filename must not be excluded by filters. Be especially careful with --files-from, which does not respect --ignore-case!
  • on remotes that do not support server-side move, --fix-case will require downloading the file and re-uploading it. To avoid this, do not use --fix-case.

--fs-cache-expire-duration Duration

When using rclone via the API rclone caches created remotes for 5 minutes by default in the "fs cache". This means that if you do repeated actions on the same remote then rclone won't have to build it again from scratch, which makes it more efficient.

This flag sets the time that the remotes are cached for. If you set it to 0 (or negative) then rclone won't cache the remotes at all.

Note that if you use some flags, eg --backup-dir and if this is set to 0 rclone may build two remotes (one for the source or destination and one for the --backup-dir where it may have only built one before.

--fs-cache-expire-interval Duration

This controls how often rclone checks for cached remotes to expire. See the --fs-cache-expire-duration documentation above for more info. The default is 60s, set to 0 to disable expiry.

--header stringArray

Add an HTTP header for all transactions. The flag can be repeated to add multiple headers.

If you want to add headers only for uploads use --header-upload and if you want to add headers only for downloads use --header-download.

This flag is supported for all HTTP based backends even those not supported by --header-upload and --header-download so may be used as a workaround for those with care.

rclone ls remote:test --header "X-Rclone: Foo" --header "X-LetMeIn: Yes"

--header-download stringArray

Add an HTTP header for all download transactions. The flag can be repeated to add multiple headers.

rclone sync --interactive s3:test/src ~/dst --header-download "X-Amz-Meta-Test: Foo" --header-download "X-Amz-Meta-Test2: Bar"

See GitHub issue #59 for currently supported backends.

--header-upload stringArray

Add an HTTP header for all upload transactions. The flag can be repeated to add multiple headers.

rclone sync --interactive ~/src s3:test/dst --header-upload "Content-Disposition: attachment; filename='cool.html'" --header-upload "X-Amz-Meta-Test: FooBar"

See GitHub issue #59 for currently supported backends.

--http-proxy string

Use this option to set an HTTP proxy for all HTTP based services to use.

Rclone also supports the standard HTTP proxy environment variables which it will pick up automatically. The is the way the HTTP proxy will normally be set but this flag can be used to override it.

--human-readable

Rclone commands output values for sizes (e.g. number of bytes) and counts (e.g. number of files) either as raw numbers, or in human-readable format.

In human-readable format the values are scaled to larger units, indicated with a suffix shown after the value, and rounded to three decimals. Rclone consistently uses binary units (powers of 2) for sizes and decimal units (powers of 10) for counts. The unit prefix for size is according to IEC standard notation, e.g. Ki for kibi. Used with byte unit, 1 KiB means 1024 Byte. In list type of output, only the unit prefix appended to the value (e.g. 9.762Ki), while in more textual output the full unit is shown (e.g. 9.762 KiB). For counts the SI standard notation is used, e.g. prefix k for kilo. Used with file counts, 1k means 1000 files.

The various list commands output raw numbers by default. Option --human-readable will make them output values in human-readable format instead (with the short unit prefix).

The about command outputs human-readable by default, with a command-specific option --full to output the raw numbers instead.

Command size outputs both human-readable and raw numbers in the same output.

The tree command also considers --human-readable, but it will not use the exact same notation as the other commands: It rounds to one decimal, and uses single letter suffix, e.g. K instead of Ki. The reason for this is that it relies on an external library.

The interactive command ncdu shows human-readable by default, and responds to key u for toggling human-readable format.

--ignore-case-sync

Using this option will cause rclone to ignore the case of the files when synchronizing so files will not be copied/synced when the existing filenames are the same, even if the casing is different.

--ignore-checksum

Normally rclone will check that the checksums of transferred files match, and give an error "corrupted on transfer" if they don't.

You can use this option to skip that check. You should only use it if you have had the "corrupted on transfer" error message and you are sure you might want to transfer potentially corrupted data.

--ignore-existing

Using this option will make rclone unconditionally skip all files that exist on the destination, no matter the content of these files.

While this isn't a generally recommended option, it can be useful in cases where your files change due to encryption. However, it cannot correct partial transfers in case a transfer was interrupted.

When performing a move/moveto command, this flag will leave skipped files in the source location unchanged when a file with the same name exists on the destination.

--ignore-size

Normally rclone will look at modification time and size of files to see if they are equal. If you set this flag then rclone will check only the modification time. If --checksum is set then it only checks the checksum.

It will also cause rclone to skip verifying the sizes are the same after transfer.

This can be useful for transferring files to and from OneDrive which occasionally misreports the size of image files (see #399 for more info).

-I, --ignore-times

Using this option will cause rclone to unconditionally upload all files regardless of the state of files on the destination.

Normally rclone would skip any files that have the same modification time and are the same size (or have the same checksum if using --checksum).

--immutable

Treat source and destination files as immutable and disallow modification.

With this option set, files will be created and deleted as requested, but existing files will never be updated. If an existing file does not match between the source and destination, rclone will give the error Source and destination exist but do not match: immutable file modified.

Note that only commands which transfer files (e.g. sync, copy or move) are affected by this behavior, and only modification is disallowed. Files may still be deleted explicitly (e.g. delete, purge) or implicitly (e.g. sync, move). Use copy --immutable if it is desired to avoid deletion as well as modification.

This can be useful as an additional layer of protection for immutable or append-only data sets (notably backup archives), where modification implies corruption and should not be propagated.

--inplace

The --inplace flag changes the behaviour of rclone when uploading files to some backends (backends with the PartialUploads feature flag set) such as:

  • local
  • ftp
  • sftp
  • pcloud

Without --inplace (the default) rclone will first upload to a temporary file with an extension like this, where XXXXXX represents a hash of the source file's fingerprint and .partial is --partial-suffix value (.partial by default).

original-file-name.XXXXXX.partial

(rclone will make sure the final name is no longer than 100 characters by truncating the original-file-name part if necessary).

When the upload is complete, rclone will rename the .partial file to the correct name, overwriting any existing file at that point. If the upload fails then the .partial file will be deleted.

This prevents other users of the backend from seeing partially uploaded files in their new names and prevents overwriting the old file until the new one is completely uploaded.

If the --inplace flag is supplied, rclone will upload directly to the final name without creating a .partial file.

This means that an incomplete file will be visible in the directory listings while the upload is in progress and any existing files will be overwritten as soon as the upload starts. If the transfer fails then the file will be deleted. This can cause data loss of the existing file if the transfer fails.

Note that on the local file system if you don't use --inplace hard links (Unix only) will be broken. And if you do use --inplace you won't be able to update in use executables.

Note also that versions of rclone prior to v1.63.0 behave as if the --inplace flag is always supplied.

-i, --interactive

This flag can be used to tell rclone that you wish a manual confirmation before destructive operations.

It is recommended that you use this flag while learning rclone especially with rclone sync.

For example

$ rclone delete --interactive /tmp/dir
rclone: delete "important-file.txt"?
y) Yes, this is OK (default)
n) No, skip this
s) Skip all delete operations with no more questions
!) Do all delete operations with no more questions
q) Exit rclone now.
y/n/s/!/q> n

The options mean

  • y: Yes, this operation should go ahead. You can also press Return for this to happen. You'll be asked every time unless you choose s or !.
  • n: No, do not do this operation. You'll be asked every time unless you choose s or !.
  • s: Skip all the following operations of this type with no more questions. This takes effect until rclone exits. If there are any different kind of operations you'll be prompted for them.
  • !: Do all the following operations with no more questions. Useful if you've decided that you don't mind rclone doing that kind of operation. This takes effect until rclone exits . If there are any different kind of operations you'll be prompted for them.
  • q: Quit rclone now, just in case!

--leave-root

During rmdirs it will not remove root directory, even if it's empty.

-l, --links

Normally rclone will ignore symlinks or junction points (which behave like symlinks under Windows). Ignored files won't be copied, moved or deleted in a sync.

If you supply this flag then rclone will copy symbolic links from any supported backend backend, and store them as text files, with a .rclonelink suffix in the destination.

The text file will contain the target of the symbolic link.

The --links / -l flag enables this feature for all supported backends and the VFS. There are individual flags for just enabling it for the VFS --vfs-links and the local backend --local-links if required.

--list-cutoff int

When syncing rclone needs to sort directory entries before comparing them. Below this threshold (1,000,000) by default, rclone will store the directory entries in memory. 1,000,000 entries will take approx 1GB of RAM to store. Above this threshold rclone will store directory entries on disk and sort them without using a lot of memory.

Doing this is slightly less efficient then sorting them in memory and will only work well for the bucket based backends (eg s3, b2, azureblob, swift) but these are the only backends likely to have millions of entries in a directory.

--log-file string

Log all of rclone's output to a file. This is not active by default. This can be useful for tracking down problems with syncs in combination with the -v flag. See the logging section for more info.

If the file exists, then rclone will append to it.

Note that if you are using the logrotate program to manage rclone's logs, then you should use the copytruncate option as rclone doesn't have a signal to rotate logs.

Alternatively you can use the options below to manage rclone's built in log rotation.

--log-file-max-size SizeSuffix

Maximum size of the log file before it's rotated (eg 10M). This SizeSuffix is rounded to the nearest MiB or 1 MiB if lower.

If --log-file is not set then this option will be ignored.

If this option is not set, then the other log rotation options will be ignored.

For example if the following flags are in use

rclone --log-file rclone.log --log-file-max-size 1M --log-file-max-backups 3

Then this will create log files which look like this

$ ls -l
-rw-------  1 user user  1048491 Apr 11 17:15 rclone-2025-04-11T17-15-29.998.log
-rw-------  1 user user  1048511 Apr 11 17:15 rclone-2025-04-11T17-15-30.467.log
-rw-------  1 user user  1048559 Apr 11 17:15 rclone-2025-04-11T17-15-30.543.log
-rw-------  1 user user   521602 Apr 11 17:15 rclone.log

The file rclone.log being the current one.

--log-file-compress

If set, compress rotated log files using gzip. This changes the extension of the old log files to .log.gz.

Defaults to false - don't compress log files.

--log-file-max-age Duration

Maximum duration to retain old log files (eg 7d). This is rounded to the dearest day, or 1 day if lower.

The default is to retain all old log files.

--log-file-max-backups int

Maximum number of old log files to retain

The default is to retain all old log files.

--log-format string

Comma separated list of log format options. The accepted options are:

  • date - Add a date in the format YYYY/MM/YY to the log.
  • time - Add a time to the log in format HH:MM:SS.
  • microseconds - Add microseconds to the time in format HH:MM:SS.SSSSSS.
  • UTC - Make the logs in UTC not localtime.
  • longfile - Adds the source file and line number of the log statement.
  • shortfile - Adds the source file and line number of the log statement.
  • pid - Add the process ID to the log - useful with rclone mount --daemon.
  • nolevel - Don't add the level to the log.
  • json - Equivalent to adding --use-json-log

They are added to the log line in the order above.

The default log format is "date,time".

--log-level LogLevel

This sets the log level for rclone. The default log level is NOTICE.

DEBUG is equivalent to -vv. It outputs lots of debug info - useful for bug reports and really finding out what rclone is doing.

INFO is equivalent to -v. It outputs information about each transfer and prints stats once a minute by default.

NOTICE is the default log level if no logging flags are supplied. It outputs very little when things are working normally. It outputs warnings and significant events.

ERROR is equivalent to -q. It only outputs error messages.

See also the logging section.

--windows-event-log LogLevel

If this is configured (the default is OFF) then logs of this level and above will be logged to the Windows event log in addition to the normal logs. These will be logged in JSON format as described below regardless of what format the main logs are configured for.

The Windows event log only has 3 levels of severity Info, Warning and Error. If enabled we map rclone levels like this.

  • Error ← ERROR (and above)
  • Warning ← WARNING (note that this level is defined but not currently used).
  • Info ← NOTICE, INFO and DEBUG.

Rclone will declare its log source as "rclone" if it is has enough permissions to create the registry key needed. If not then logs will appear as "Application". You can run rclone version --windows-event-log DEBUG once as administrator to create the registry key in advance.

Note that the --windows-event-log level must be greater (more severe) than or equal to the --log-level. For example to log DEBUG to a log file but ERRORs to the event log you would use

--log-file rclone.log --log-level DEBUG --windows-event-log ERROR

This option is only supported Windows platforms.

--use-json-log

This switches the log format to JSON. The log messages are then streamed as individual JSON objects, with fields: level, msg, source, and time. The resulting format is what is sometimes referred to as newline-delimited JSON (NDJSON), or JSON Lines (JSONL). This is well suited for processing by traditional line-oriented tools and shell pipelines, but a complete log file is not strictly valid JSON and needs a parser that can handle it.

The JSON logs will be printed on a single line, but are shown expanded here for clarity.

{
  "time": "2025-05-13T17:30:51.036237518+01:00",
  "level": "debug",
  "msg": "4 go routines active\n",
  "source": "cmd/cmd.go:298"
}

Completed data transfer logs will have extra size information. Logs which are about a particular object will have object and objectType fields also.

{
  "time": "2025-05-13T17:38:05.540846352+01:00",
  "level": "info",
  "msg": "Copied (new) to: file2.txt",
  "size": 6,
  "object": "file.txt",
  "objectType": "*local.Object",
  "source": "operations/copy.go:368"
}

Stats logs will contain a stats field which is the same as returned from the rc call core/stats.

{
  "time": "2025-05-13T17:38:05.540912847+01:00",
  "level": "info",
  "msg": "...text version of the stats...",
  "stats": {
    "bytes": 6,
    "checks": 0,
    "deletedDirs": 0,
    "deletes": 0,
    "elapsedTime": 0.000904825,
    ...truncated for clarity...
    "totalBytes": 6,
    "totalChecks": 0,
    "totalTransfers": 1,
    "transferTime": 0.000882794,
    "transfers": 1
  },
  "source": "accounting/stats.go:569"
}

--low-level-retries int

This controls the number of low level retries rclone does.

A low level retry is used to retry a failing operation - typically one HTTP request. This might be uploading a chunk of a big file for example. You will see low level retries in the log with the -v flag.

This shouldn't need to be changed from the default in normal operations. However, if you get a lot of low level retries you may wish to reduce the value so rclone moves on to a high level retry (see the --retries flag) quicker.

Disable low level retries with --low-level-retries 1.

--max-backlog int

This is the maximum allowable backlog of files in a sync/copy/move queued for being checked or transferred.

This can be set arbitrarily large. It will only use memory when the queue is in use. Note that it will use in the order of N KiB of memory when the backlog is in use.

Setting this large allows rclone to calculate how many files are pending more accurately, give a more accurate estimated finish time and make --order-by work more accurately.

Setting this small will make rclone more synchronous to the listings of the remote which may be desirable.

Setting this to a negative number will make the backlog as large as possible.

--max-buffer-memory SizeSuffix

If set, don't allocate more than given amount of memory as buffers. If not set or set to 0 or off this will not limit the amount of memory in use.

This includes memory used by buffers created by the --buffer flag and buffers used by multi-thread transfers.

Most multi-thread transfers do not take additional memory, but some do depending on the backend (eg the s3 backend for uploads). This means there is a tension between total setting --transfers as high as possible and memory use.

Setting --max-buffer-memory allows the buffer memory to be controlled so that it doesn't overwhelm the machine and allows --transfers to be set large.

--max-connections int

This sets the maximum number of concurrent calls to the backend API. It may not map 1:1 to TCP or HTTP connections depending on the backend in use and the use of HTTP1 vs HTTP2.

When downloading files, backends only limit the initial opening of the stream. The bulk data download is not counted as a connection. This means that the --max--connections flag won't limit the total number of downloads.

Note that it is possible to cause deadlocks with this setting so it should be used with care.

If you are doing a sync or copy then make sure --max-connections is one more than the sum of --transfers and --checkers.

If you use --check-first then --max-connections just needs to be one more than the maximum of --checkers and --transfers.

So for --max-connections 3 you'd use --checkers 2 --transfers 2 --check-first or --checkers 1 --transfers 1.

Setting this flag can be useful for backends which do multipart uploads to limit the number of simultaneous parts being transferred.

--max-delete int

This tells rclone not to delete more than N files. If that limit is exceeded then a fatal error will be generated and rclone will stop the operation in progress.

--max-delete-size SizeSuffix

Rclone will stop deleting files when the total size of deletions has reached the size specified. It defaults to off.

If that limit is exceeded then a fatal error will be generated and rclone will stop the operation in progress.

--max-depth int

This modifies the recursion depth for all the commands except purge.

So if you do rclone --max-depth 1 ls remote:path you will see only the files in the top level directory. Using --max-depth 2 means you will see all the files in first two directory levels and so on.

For historical reasons the lsd command defaults to using a --max-depth of 1 - you can override this with the command line flag.

You can use this command to disable recursion (with --max-depth 1).

Note that if you use this with sync and --delete-excluded the files not recursed through are considered excluded and will be deleted on the destination. Test first with --dry-run if you are not sure what will happen.

--max-duration Duration

Rclone will stop transferring when it has run for the duration specified. Defaults to off.

When the limit is reached all transfers will stop immediately. Use --cutoff-mode to modify this behaviour.

Rclone will exit with exit code 10 if the duration limit is reached.

--max-transfer SizeSuffix

Rclone will stop transferring when it has reached the size specified. Defaults to off.

When the limit is reached all transfers will stop immediately. Use --cutoff-mode to modify this behaviour.

Rclone will exit with exit code 8 if the transfer limit is reached.

--cutoff-mode HARD|SOFT|CAUTIOUS

Configure the behavior of --max-transfer and --max-duration.

HARD will stop transferring immediately when rclone reaches the limit. This is the default.

SOFT will stop starting new transfers when rclone reaches the limit.

CAUTIOUS will try to prevent rclone from reaching the limit. Only applicable for --max-transfer.

-M, --metadata

Setting this flag enables rclone to copy the metadata from the source to the destination. For local backends this is ownership, permissions, xattr etc. See the metadata section for more info.

--metadata-mapper SpaceSepList

If you supply the parameter --metadata-mapper /path/to/program then rclone will use that program to map metadata from source object to destination object.

The argument to this flag should be a command with an optional space separated list of arguments. If one of the arguments has a space in then enclose it in ", if you want a literal " in an argument then enclose the argument in " and double the ". See CSV encoding for more info.

--metadata-mapper "python bin/test_metadata_mapper.py"
--metadata-mapper 'python bin/test_metadata_mapper.py "argument with a space"'
--metadata-mapper 'python bin/test_metadata_mapper.py "argument with ""two"" quotes"'

This uses a simple JSON based protocol with input on STDIN and output on STDOUT. This will be called for every file and directory copied and may be called concurrently.

The program's job is to take a metadata blob on the input and turn it into a metadata blob on the output suitable for the destination backend.

Input to the program (via STDIN) might look like this. This provides some context for the Metadata which may be important.

  • SrcFs is the config string for the remote that the object is currently on.
  • SrcFsType is the name of the source backend.
  • DstFs is the config string for the remote that the object is being copied to
  • DstFsType is the name of the destination backend.
  • Remote is the path of the object relative to the root.
  • Size, MimeType, ModTime are attributes of the object.
  • IsDir is true if this is a directory (not yet implemented).
  • ID is the source ID of the object if known.
  • Metadata is the backend specific metadata as described in the backend docs.
{
    "SrcFs": "gdrive:",
    "SrcFsType": "drive",
    "DstFs": "newdrive:user",
    "DstFsType": "onedrive",
    "Remote": "test.txt",
    "Size": 6,
    "MimeType": "text/plain; charset=utf-8",
    "ModTime": "2022-10-11T17:53:10.286745272+01:00",
    "IsDir": false,
    "ID": "xyz",
    "Metadata": {
        "btime": "2022-10-11T16:53:11Z",
        "content-type": "text/plain; charset=utf-8",
        "mtime": "2022-10-11T17:53:10.286745272+01:00",
        "owner": "user1@domain1.com",
        "permissions": "...",
        "description": "my nice file",
        "starred": "false"
    }
}

The program should then modify the input as desired and send it to STDOUT. The returned Metadata field will be used in its entirety for the destination object. Any other fields will be ignored. Note in this example we translate user names and permissions and add something to the description:

{
    "Metadata": {
        "btime": "2022-10-11T16:53:11Z",
        "content-type": "text/plain; charset=utf-8",
        "mtime": "2022-10-11T17:53:10.286745272+01:00",
        "owner": "user1@domain2.com",
        "permissions": "...",
        "description": "my nice file [migrated from domain1]",
        "starred": "false"
    }
}

Metadata can be removed here too.

An example python program might look something like this to implement the above transformations.

import sys, json

i = json.load(sys.stdin)
metadata = i["Metadata"]
# Add tag to description
if "description" in metadata:
    metadata["description"] += " [migrated from domain1]"
else:
    metadata["description"] = "[migrated from domain1]"
# Modify owner
if "owner" in metadata:
    metadata["owner"] = metadata["owner"].replace("domain1.com", "domain2.com")
o = { "Metadata": metadata }
json.dump(o, sys.stdout, indent="\t")

You can find this example (slightly expanded) in the rclone source code at bin/test_metadata_mapper.py.

If you want to see the input to the metadata mapper and the output returned from it in the log you can use -vv --dump mapper.

See the metadata section for more info.

--metadata-set stringArray

Specify value as string in format key=value to add metadata key with value value when uploading. This can be repeated as many times as required. See the metadata section for more info.

--modify-window Duration

When checking whether a file has been modified, this is the maximum allowed time difference that a file can have and still be considered equivalent.

The default is 1ns unless this is overridden by a remote. For example OS X only stores modification times to the nearest second so if you are reading and writing to an OS X filing system this will be 1s by default.

This command line flag allows you to override that computed default.

--multi-thread-write-buffer-size SizeSuffix

When transferring with multiple threads, rclone will buffer the specified number of bytes in memory before writing to disk for each thread.

This can improve performance if the underlying filesystem does not deal well with a lot of small writes in different positions of the file, so if you see transfers being limited by disk write speed, you might want to experiment with different values. Specially for magnetic drives and remote file systems a higher value can be useful.

Nevertheless, the default of 128k should be fine for almost all use cases, so before changing it ensure that network is not really your bottleneck.

As a final hint, size is not the only factor: block size (or similar concept) can have an impact. In one case, we observed that exact multiples of 16k performed much better than other values.

--multi-thread-chunk-size SizeSuffix

Normally the chunk size for multi thread transfers is set by the backend. However some backends such as local and smb (which implement OpenWriterAt but not OpenChunkWriter) don't have a natural chunk size.

In this case the value of this option is used (default 64Mi).

--multi-thread-cutoff SizeSuffix

When transferring files above specified size to capable backends, rclone will use multiple threads to transfer the file (default 256M).

Capable backends are marked in the overview as MultithreadUpload. (They need to implement either the OpenWriterAt or OpenChunkWriter internal interfaces). These include include, local, s3, azureblob, b2, oracleobjectstorage and smb at the time of writing.

On the local disk, rclone preallocates the file (using fallocate(FALLOC_FL_KEEP_SIZE) on unix or NTSetInformationFile on Windows both of which takes no time) then each thread writes directly into the file at the correct place. This means that rclone won't create fragmented or sparse files and there won't be any assembly time at the end of the transfer.

The number of threads used to transfer is controlled by --multi-thread-streams.

Use -vv if you wish to see info about the threads.

This will work with the sync, copy and move commands, and friends copyto, moveto. Multi thread transfers will be used with rclone mount and rclone serve if --vfs-cache-mode is set to writes or above.

Most multi-thread transfers do not take additional memory, but some do (for example uploading to s3). In the worst case memory usage can be at maximum --transfers * --multi-thread-chunk-size * --multi-thread-streams or specifically for the s3 backend --transfers * --s3-chunk-size * --s3-concurrency. However you can use the the --max-buffer-memory flag to control the maximum memory used here.

NB that this only works with supported backends as the destination but will work with any backend as the source.

NB that multi-thread copies are disabled for local to local copies as they are faster without unless --multi-thread-streams is set explicitly.

NB on Windows using multi-thread transfers to the local disk will cause the resulting files to be sparse. Use --local-no-sparse to disable sparse files (which may cause long delays at the start of transfers) or disable multi-thread transfers with --multi-thread-streams 0

--multi-thread-streams int

When using multi thread transfers (see above --multi-thread-cutoff) this sets the number of streams to use. Set to 0 to disable multi thread transfers (Default 4).

If the backend has a --backend-upload-concurrency setting (eg --s3-upload-concurrency) then this setting will be used as the number of transfers instead if it is larger than the value of --multi-thread-streams or --multi-thread-streams isn't set.

--name-transform stringArray

--name-transform introduces path name transformations for rclone copy, rclone sync, and rclone move. These transformations enable modifications to source and destination file names by applying prefixes, suffixes, and other alterations during transfer operations. For detailed docs and examples, see convmv.

--no-check-dest

The --no-check-dest can be used with move or copy and it causes rclone not to check the destination at all when copying files.

This means that:

  • the destination is not listed minimising the API calls
  • files are always transferred
  • this can cause duplicates on remotes which allow it (e.g. Google Drive)
  • --retries 1 is recommended otherwise you'll transfer everything again on a retry

This flag is useful to minimise the transactions if you know that none of the files are on the destination.

This is a specialized flag which should be ignored by most users!

--no-gzip-encoding

Don't set Accept-Encoding: gzip. This means that rclone won't ask the server for compressed files automatically. Useful if you've set the server to return files with Content-Encoding: gzip but you uploaded compressed files.

There is no need to set this in normal operation, and doing so will decrease the network transfer efficiency of rclone.

--no-traverse

The --no-traverse flag controls whether the destination file system is traversed when using the copy or move commands. --no-traverse is not compatible with sync and will be ignored if you supply it with sync.

If you are only copying a small number of files (or are filtering most of the files) and/or have a large number of files on the destination then --no-traverse will stop rclone listing the destination and save time.

However, if you are copying a large number of files, especially if you are doing a copy where lots of the files under consideration haven't changed and won't need copying then you shouldn't use --no-traverse.

See rclone copy for an example of how to use it.

--no-unicode-normalization

Don't normalize unicode characters in filenames during the sync routine.

Sometimes, an operating system will store filenames containing unicode parts in their decomposed form (particularly macOS). Some cloud storage systems will then recompose the unicode, resulting in duplicate files if the data is ever copied back to a local filesystem.

Using this flag will disable that functionality, treating each unicode character as unique. For example, by default é and é will be normalized into the same character. With --no-unicode-normalization they will be treated as unique characters.

--no-update-modtime

When using this flag, rclone won't update modification times of remote files if they are incorrect as it would normally.

This can be used if the remote is being synced with another tool also (e.g. the Google Drive client).

--no-update-dir-modtime

When using this flag, rclone won't update modification times of remote directories if they are incorrect as it would normally.

--order-by string

The --order-by flag controls the order in which files in the backlog are processed in rclone sync, rclone copy and rclone move.

The order by string is constructed like this. The first part describes what aspect is being measured:

  • size - order by the size of the files
  • name - order by the full path of the files
  • modtime - order by the modification date of the files

This can have a modifier appended with a comma:

  • ascending or asc - order so that the smallest (or oldest) is processed first
  • descending or desc - order so that the largest (or newest) is processed first
  • mixed - order so that the smallest is processed first for some threads and the largest for others

If the modifier is mixed then it can have an optional percentage (which defaults to 50), e.g. size,mixed,25 which means that 25% of the threads should be taking the smallest items and 75% the largest. The threads which take the smallest first will always take the smallest first and likewise the largest first threads. The mixed mode can be useful to minimise the transfer time when you are transferring a mixture of large and small files - the large files are guaranteed upload threads and bandwidth and the small files will be processed continuously.

If no modifier is supplied then the order is ascending.

For example

  • --order-by size,desc - send the largest files first
  • --order-by modtime,ascending - send the oldest files first
  • --order-by name - send the files with alphabetically by path first

If the --order-by flag is not supplied or it is supplied with an empty string then the default ordering will be used which is as scanned. With --checkers 1 this is mostly alphabetical, however with the default --checkers 8 it is somewhat random.

Limitations

The --order-by flag does not do a separate pass over the data. This means that it may transfer some files out of the order specified if

  • there are no files in the backlog or the source has not been fully scanned yet
  • there are more than --max-backlog files in the backlog

Rclone will do its best to transfer the best file it has so in practice this should not cause a problem. Think of --order-by as being more of a best efforts flag rather than a perfect ordering.

If you want perfect ordering then you will need to specify --check-first which will find all the files which need transferring first before transferring any.

--partial-suffix string

When --inplace is not used, it causes rclone to use the --partial-suffix as suffix for temporary files.

Suffix length limit is 16 characters.

The default is .partial.

--password-command SpaceSepList

This flag supplies a program which should supply the config password when run. This is an alternative to rclone prompting for the password or setting the RCLONE_CONFIG_PASS variable. It is also used when setting the config password for the first time.

The argument to this should be a command with a space separated list of arguments. If one of the arguments has a space in then enclose it in ", if you want a literal " in an argument then enclose the argument in " and double the ". See CSV encoding for more info.

Eg

--password-command "echo hello"
--password-command 'echo "hello with space"'
--password-command 'echo "hello with ""quotes"" and space"'

Note that when changing the configuration password the environment variable RCLONE_PASSWORD_CHANGE=1 will be set. This can be used to distinguish initial decryption of the config file from the new password.

See the Configuration Encryption for more info.

See a Windows PowerShell example on the Wiki.

-P, --progress

This flag makes rclone update the stats in a static block in the terminal providing a realtime overview of the transfer.

Any log messages will scroll above the static block. Log messages will push the static block down to the bottom of the terminal where it will stay.

Normally this is updated every 500mS but this period can be overridden with the --stats flag.

This can be used with the --stats-one-line flag for a simpler display.

To change the display length of filenames (for different terminal widths), see the --stats-file-name-length option. The default output is formatted for 80 character wide terminals.

Note: On Windows until this bug is fixed all non-ASCII characters will be replaced with . when --progress is in use.

--progress-terminal-title

This flag, when used with -P/--progress, will print the string ETA: %s to the terminal title.

-q, --quiet

This flag will limit rclone's output to error messages only.

--refresh-times

The --refresh-times flag can be used to update modification times of existing files when they are out of sync on backends which don't support hashes.

This is useful if you uploaded files with the incorrect timestamps and you now wish to correct them.

This flag is only useful for destinations which don't support hashes (e.g. crypt).

This can be used any of the sync commands sync, copy or move.

To use this flag you will need to be doing a modification time sync (so not using --size-only or --checksum). The flag will have no effect when using --size-only or --checksum.

If this flag is used when rclone comes to upload a file it will check to see if there is an existing file on the destination. If this file matches the source with size (and checksum if available) but has a differing timestamp then instead of re-uploading it, rclone will update the timestamp on the destination file. If the checksum does not match rclone will upload the new file. If the checksum is absent (e.g. on a crypt backend) then rclone will update the timestamp.

Note that some remotes can't set the modification time without re-uploading the file so this flag is less useful on them.

Normally if you are doing a modification time sync rclone will update modification times without --refresh-times provided that the remote supports checksums and the checksums match on the file. However if the checksums are absent then rclone will upload the file rather than setting the timestamp as this is the safe behaviour.

--retries int

Retry the entire sync if it fails this many times it fails (default 3).

Some remotes can be unreliable and a few retries help pick up the files which didn't get transferred because of errors.

Disable retries with --retries 1.

--retries-sleep Duration

This sets the interval between each retry specified by --retries

The default is 0. Use 0 to disable.

--server-side-across-configs

Allow server-side operations (e.g. copy or move) to work across different configurations.

This can be useful if you wish to do a server-side copy or move between two remotes which use the same backend but are configured differently.

Note that this isn't enabled by default because it isn't easy for rclone to tell if it will work between any two configurations.

--size-only

Normally rclone will look at modification time and size of files to see if they are equal. If you set this flag then rclone will check only the size.

This can be useful transferring files from Dropbox which have been modified by the desktop sync client which doesn't set checksums of modification times in the same way as rclone.

--stats Duration

Commands which transfer data (sync, copy, copyto, move, moveto) will print data transfer stats at regular intervals to show their progress.

This sets the interval.

The default is 1m. Use 0 to disable.

If you set the stats interval then all commands can show stats. This can be useful when running other commands, check or mount for example.

Stats are logged at INFO level by default which means they won't show at default log level NOTICE. Use --stats-log-level NOTICE or -v to make them show. See the logging section for more info on log levels.

Note that on macOS you can send a SIGINFO (which is normally ctrl-T in the terminal) to make the stats print immediately.

--stats-file-name-length int

By default, the --stats output will truncate file names and paths longer than 40 characters. This is equivalent to providing --stats-file-name-length 40. Use --stats-file-name-length 0 to disable any truncation of file names printed by stats.

--stats-log-level LogLevel

Log level to show --stats output at. This can be DEBUG, INFO, NOTICE, or ERROR. The default is INFO. This means at the default level of logging, which is NOTICE, the stats won't show - if you want them to then use --stats-log-level NOTICE. See the logging section for more details on log levels.

--stats-one-line

When this is specified, rclone condenses the stats into a single line showing the most important stats only.

--stats-one-line-date

When this is specified, rclone enables the single-line stats and prepends the display with a date string. The default is 2006/01/02 15:04:05 -

--stats-one-line-date-format string

When this is specified, rclone enables the single-line stats and prepends the display with a user-supplied date string. The date string MUST be enclosed in quotes. Follow golang specs for date formatting syntax.

--stats-unit string

By default, data transfer rates will be printed in bytes per second, corresponding to --stats-unit bytes.

This option allows the data rate to be printed in bits per second, by specifying --stats-unit bits. Data transfer volume will still be reported in bytes.

The rate is reported as a binary unit, not SI unit. So 1 Mbit/s equals 1,048,576 bit/s and not 1,000,000 bit/s.

--suffix string

When using sync, copy or move any files which would have been overwritten or deleted will have the suffix added to them. If there is a file with the same path (after the suffix has been added), then it will be overwritten.

The remote in use must support server-side move or copy and you must use the same remote as the destination of the sync.

This is for use with files to add the suffix in the current directory or with --backup-dir. See --backup-dir for more info.

For example

rclone copy --interactive /path/to/local/file remote:current --suffix .bak

will copy /path/to/local to remote:current, but for any files which would have been updated or deleted have .bak added.

If using rclone sync with --suffix and without --backup-dir then it is recommended to put a filter rule in excluding the suffix otherwise the sync will delete the backup files.

rclone sync --interactive /path/to/local/file remote:current --suffix .bak --exclude "*.bak"

--suffix-keep-extension

When using --suffix, setting this causes rclone put the SUFFIX before the extension of the files that it backs up rather than after.

So let's say we had --suffix -2019-01-01, without the flag file.txt would be backed up to file.txt-2019-01-01 and with the flag it would be backed up to file-2019-01-01.txt. This can be helpful to make sure the suffixed files can still be opened.

If a file has two (or more) extensions and the second (or subsequent) extension is recognised as a valid mime type, then the suffix will go before that extension. So file.tar.gz would be backed up to file-2019-01-01.tar.gz whereas file.badextension.gz would be backed up to file.badextension-2019-01-01.gz.

--syslog

On capable OSes (not Windows or Plan9) send all log output to syslog.

This can be useful for running rclone in a script or rclone mount.

--syslog-facility string

If using --syslog this sets the syslog facility (e.g. KERN, USER). See man syslog for a list of possible facilities. The default facility is DAEMON.

--temp-dir string

Specify the directory rclone will use for temporary files, to override the default. Make sure the directory exists and have accessible permissions.

By default the operating system's temp directory will be used:

  • On Unix systems, $TMPDIR if non-empty, else /tmp.
  • On Windows, the first non-empty value from %TMP%, %TEMP%, %USERPROFILE%, or the Windows directory.

When overriding the default with this option, the specified path will be set as value of environment variable TMPDIR on Unix systems and TMP and TEMP on Windows.

You can use the config paths command to see the current value.

--tpslimit float

Limit transactions per second to this number. Default is 0 which is used to mean unlimited transactions per second.

A transaction is roughly defined as an API call; its exact meaning will depend on the backend. For HTTP based backends it is an HTTP PUT/GET/POST/etc and its response. For FTP/SFTP it is a round trip transaction over TCP.

For example, to limit rclone to 10 transactions per second use --tpslimit 10, or to 1 transaction every 2 seconds use --tpslimit 0.5.

Use this when the number of transactions per second from rclone is causing a problem with the cloud storage provider (e.g. getting you banned or rate limited).

This can be very useful for rclone mount to control the behaviour of applications using it.

This limit applies to all HTTP based backends and to the FTP and SFTP backends. It does not apply to the local backend or the Storj backend.

See also --tpslimit-burst.

--tpslimit-burst int

Max burst of transactions for --tpslimit (default 1).

Normally --tpslimit will do exactly the number of transaction per second specified. However if you supply --tps-burst then rclone can save up some transactions from when it was idle giving a burst of up to the parameter supplied.

For example if you provide --tpslimit-burst 10 then if rclone has been idle for more than 10*--tpslimit then it can do 10 transactions very quickly before they are limited again.

This may be used to increase performance of --tpslimit without changing the long term average number of transactions per second.

--track-renames

By default, rclone doesn't keep track of renamed files, so if you rename a file locally then sync it to a remote, rclone will delete the old file on the remote and upload a new copy.

An rclone sync with --track-renames runs like a normal sync, but keeps track of objects which exist in the destination but not in the source (which would normally be deleted), and which objects exist in the source but not the destination (which would normally be transferred). These objects are then candidates for renaming.

After the sync, rclone matches up the source only and destination only objects using the --track-renames-strategy specified and either renames the destination object or transfers the source and deletes the destination object. --track-renames is stateless like all of rclone's syncs.

To use this flag the destination must support server-side copy or server-side move, and to use a hash based --track-renames-strategy (the default) the source and the destination must have a compatible hash.

If the destination does not support server-side copy or move, rclone will fall back to the default behaviour and log an error level message to the console.

Encrypted destinations are not currently supported by --track-renames if --track-renames-strategy includes hash.

Note that --track-renames is incompatible with --no-traverse and that it uses extra memory to keep track of all the rename candidates.

Note also that --track-renames is incompatible with --delete-before and will select --delete-after instead of --delete-during.

--track-renames-strategy string

This option changes the file matching criteria for --track-renames.

The matching is controlled by a comma separated selection of these tokens:

  • modtime - the modification time of the file - not supported on all backends
  • hash - the hash of the file contents - not supported on all backends
  • leaf - the name of the file not including its directory name
  • size - the size of the file (this is always enabled)

The default option is hash.

Using --track-renames-strategy modtime,leaf would match files based on modification time, the leaf of the file name and the size only.

Using --track-renames-strategy modtime or leaf can enable --track-renames support for encrypted destinations.

Note that the hash strategy is not supported with encrypted destinations.

--delete-(before,during,after)

This option allows you to specify when files on your destination are deleted when you sync folders.

Specifying the value --delete-before will delete all files present on the destination, but not on the source before starting the transfer of any new or updated files. This uses two passes through the file systems, one for the deletions and one for the copies.

Specifying --delete-during will delete files while checking and uploading files. This is the fastest option and uses the least memory.

Specifying --delete-after (the default value) will delay deletion of files until all new/updated files have been successfully transferred. The files to be deleted are collected in the copy pass then deleted after the copy pass has completed successfully. The files to be deleted are held in memory so this mode may use more memory. This is the safest mode as it will only delete files if there have been no errors subsequent to that. If there have been errors before the deletions start then you will get the message not deleting files as there were IO errors.

--fast-list

When doing anything which involves a directory listing (e.g. sync, copy, ls - in fact nearly every command), rclone has different strategies to choose from.

The basic strategy is to list one directory and processes it before using more directory lists to process any subdirectories. This is a mandatory backend feature, called List, which means it is supported by all backends. This strategy uses small amount of memory, and because it can be parallelised it is fast for operations involving processing of the list results.

Some backends provide the support for an alternative strategy, where all files beneath a directory can be listed in one (or a small number) of transactions. Rclone supports this alternative strategy through an optional backend feature called ListR. You can see in the storage system overview documentation's optional features section which backends it is enabled for (these tend to be the bucket-based ones, e.g. S3, B2, GCS, Swift). This strategy requires fewer transactions for highly recursive operations, which is important on backends where this is charged or heavily rate limited. It may be faster (due to fewer transactions) or slower (because it can't be parallelized) depending on different parameters, and may require more memory if rclone has to keep the whole listing in memory.

Which listing strategy rclone picks for a given operation is complicated, but in general it tries to choose the best possible. It will prefer ListR in situations where it doesn't need to store the listed files in memory, e.g. for unlimited recursive ls command variants. In other situations it will prefer List, e.g. for sync and copy, where it needs to keep the listed files in memory, and is performing operations on them where parallelization may be a huge advantage.

Rclone is not able to take all relevant parameters into account for deciding the best strategy, and therefore allows you to influence the choice in two ways: You can stop rclone from using ListR by disabling the feature, using the --disable option (--disable ListR), or you can allow rclone to use ListR where it would normally choose not to do so due to higher memory usage, using the --fast-list option. Rclone should always produce identical results either way. Using --disable ListR or --fast-list on a remote which doesn't support ListR does nothing, rclone will just ignore it.

A rule of thumb is that if you pay for transactions and can fit your entire sync listing into memory, then --fast-list is recommended. If you have a very big sync to do, then don't use --fast-list, otherwise you will run out of memory. Run some tests and compare before you decide, and if in doubt then just leave the default, let rclone decide, i.e. not use --fast-list.

--timeout Duration

This sets the IO idle timeout. If a transfer has started but then becomes idle for this long it is considered broken and disconnected.

The default is 5m. Set to 0 to disable.

--transfers int

The number of file transfers to run in parallel. It can sometimes be useful to set this to a smaller number if the remote is giving a lot of timeouts or bigger if you have lots of bandwidth and a fast remote.

The default is to run 4 file transfers in parallel.

Look at --multi-thread-streams if you would like to control single file transfers.

-u, --update

This forces rclone to skip any files which exist on the destination and have a modified time that is newer than the source file.

This can be useful in avoiding needless transfers when transferring to a remote which doesn't support modification times directly (or when using --use-server-modtime to avoid extra API calls) as it is more accurate than a --size-only check and faster than using --checksum. On such remotes (or when using --use-server-modtime) the time checked will be the uploaded time.

If an existing destination file has a modification time older than the source file's, it will be updated if the sizes are different. If the sizes are the same, it will be updated if the checksum is different or not available.

If an existing destination file has a modification time equal (within the computed modify window) to the source file's, it will be updated if the sizes are different. The checksum will not be checked in this case unless the --checksum flag is provided.

In all other cases the file will not be updated.

Consider using the --modify-window flag to compensate for time skews between the source and the backend, for backends that do not support mod times, and instead use uploaded times. However, if the backend does not support checksums, note that syncing or copying within the time skew window may still result in additional transfers for safety.

--use-mmap

If this flag is set then rclone will use anonymous memory allocated by mmap on Unix based platforms and VirtualAlloc on Windows for its transfer buffers (size controlled by --buffer-size). Memory allocated like this does not go on the Go heap and can be returned to the OS immediately when it is finished with.

If this flag is not set then rclone will allocate and free the buffers using the Go memory allocator which may use more memory as memory pages are returned less aggressively to the OS.

It is possible this does not work well on all platforms so it is disabled by default; in the future it may be enabled by default.

--use-server-modtime

Some object-store backends (e.g, Swift, S3) do not preserve file modification times (modtime). On these backends, rclone stores the original modtime as additional metadata on the object. By default it will make an API call to retrieve the metadata when the modtime is needed by an operation.

Use this flag to disable the extra API call and rely instead on the server's modified time. In cases such as a local to remote sync using --update, knowing the local file is newer than the time it was last uploaded to the remote is sufficient. In those cases, this flag can speed up the process and reduce the number of API calls necessary.

Using this flag on a sync operation without also using --update would cause all files modified at any time other than the last upload time to be uploaded again, which is probably not what you want.

-v, -vv, --verbose

With -v rclone will tell you about each file that is transferred and a small number of significant events.

With -vv rclone will become very verbose telling you about every file it considers and transfers. Please send bug reports with a log with this setting.

When setting verbosity as an environment variable, use RCLONE_VERBOSE=1 or RCLONE_VERBOSE=2 for -v and -vv respectively.

-V, --version

Prints the version number

SSL/TLS options

The outgoing SSL/TLS connections rclone makes can be controlled with these options. For example this can be very useful with the HTTP or WebDAV backends. Rclone HTTP servers have their own set of configuration for SSL/TLS which you can find in their documentation.

--ca-cert stringArray

This loads the PEM encoded certificate authority certificates and uses it to verify the certificates of the servers rclone connects to.

If you have generated certificates signed with a local CA then you will need this flag to connect to servers using those certificates.

--client-cert string

This loads the PEM encoded client side certificate.

This is used for mutual TLS authentication.

The --client-key flag is required too when using this.

--client-key string

This loads the PEM encoded client side private key used for mutual TLS authentication. Used in conjunction with --client-cert.

Supported types are:

  • Unencrypted PKCS#1 ("BEGIN RSA PRIVATE KEY")
  • Unencrypted PKCS#8 ("BEGIN PRIVATE KEY")
  • Encrypted PKCS#8 ("BEGIN ENCRYPTED PRIVATE KEY")
  • Legacy PEM encryption (e.g., DEK-Info headers), which are automatically detected.

--client-pass string

This can be used to supply an optional password to decrypt the client key file.

NB the password should be obscured so it should be the output of rclone obscure YOURPASSWORD.

--no-check-certificate

--no-check-certificate controls whether a client verifies the server's certificate chain and host name. If --no-check-certificate is true, TLS accepts any certificate presented by the server and any host name in that certificate. In this mode, TLS is susceptible to man-in-the-middle attacks.

This option defaults to false.

This should be used only for testing.

Configuration encryption

Your configuration file contains information for logging in to your cloud services. This means that you should keep your rclone.conf file in a secure location.

If you are in an environment where that isn't possible, you can add a password to your configuration. This means that you will have to supply the password every time you start rclone.

To add a password to your rclone configuration, execute rclone config.

$ rclone config
Current remotes:

e) Edit existing remote
n) New remote
d) Delete remote
s) Set configuration password
q) Quit config
e/n/d/s/q>

Go into s, Set configuration password:

e/n/d/s/q> s
Your configuration is not encrypted.
If you add a password, you will protect your login information to cloud services.
a) Add Password
q) Quit to main menu
a/q> a
Enter NEW configuration password:
password:
Confirm NEW password:
password:
Password set
Your configuration is encrypted.
c) Change Password
u) Unencrypt configuration
q) Quit to main menu
c/u/q>

Your configuration is now encrypted, and every time you start rclone you will have to supply the password. See below for details. In the same menu, you can change the password or completely remove encryption from your configuration.

There is no way to recover the configuration if you lose your password.

You can also use

rclone uses nacl secretbox which in turn uses XSalsa20 and Poly1305 to encrypt and authenticate your configuration with secret-key cryptography. The password is SHA-256 hashed, which produces the key for secretbox. The hashed password is not stored.

While this provides very good security, we do not recommend storing your encrypted rclone configuration in public if it contains sensitive information, maybe except if you use a very strong password.

If it is safe in your environment, you can set the RCLONE_CONFIG_PASS environment variable to contain your password, in which case it will be used for decrypting the configuration.

You can set this for a session from a script. For unix like systems save this to a file called set-rclone-password:

#!/bin/echo Source this file don't run it

read -s RCLONE_CONFIG_PASS
export RCLONE_CONFIG_PASS

Then source the file when you want to use it. From the shell you would do source set-rclone-password. It will then ask you for the password and set it in the environment variable.

An alternate means of supplying the password is to provide a script which will retrieve the password and print on standard output. This script should have a fully specified path name and not rely on any environment variables. The script is supplied either via --password-command="..." command line argument or via the RCLONE_PASSWORD_COMMAND environment variable.

One useful example of this is using the passwordstore application to retrieve the password:

export RCLONE_PASSWORD_COMMAND="pass rclone/config"

If the passwordstore password manager holds the password for the rclone configuration, using the script method means the password is primarily protected by the passwordstore system, and is never embedded in the clear in scripts, nor available for examination using the standard commands available. It is quite possible with long running rclone sessions for copies of passwords to be innocently captured in log files or terminal scroll buffers, etc. Using the script method of supplying the password enhances the security of the config password considerably.

If you are running rclone inside a script, unless you are using the --password-command method, you might want to disable password prompts. To do that, pass the parameter --ask-password=false to rclone. This will make rclone fail instead of asking for a password if RCLONE_CONFIG_PASS doesn't contain a valid password, and --password-command has not been supplied.

Whenever running commands that may be affected by options in a configuration file, rclone will look for an existing file according to the rules described above, and load any it finds. If an encrypted file is found, this includes decrypting it, with the possible consequence of a password prompt. When executing a command line that you know are not actually using anything from such a configuration file, you can avoid it being loaded by overriding the location, e.g. with one of the documented special values for memory-only configuration. Since only backend options can be stored in configuration files, this is normally unnecessary for commands that do not operate on backends, e.g. completion. However, it will be relevant for commands that do operate on backends in general, but are used without referencing a stored remote, e.g. listing local filesystem paths, or connection strings: rclone --config="" ls .

Configuration encryption cheatsheet

You can quickly apply a configuration encryption without plain-text at rest or transfer. Detailed instructions for popular OSes:

Mac

  • Generate and store a password

    security add-generic-password -a rclone -s config -w $(openssl rand -base64 40)

  • Add the retrieval instruction to your .zprofile / .profile

    export RCLONE_PASSWORD_COMMAND="/usr/bin/security find-generic-password -a rclone -s config -w"

Linux

  • Prerequisite: Linux doesn't come with a default password manager. Let's install the "pass" utility using a package manager, e.g. apt install pass, yum install pass, etc.; then initialize a password store: pass init rclone.

  • Generate and store a password

    echo $(openssl rand -base64 40) | pass insert -m rclone/config

  • Add the retrieval instruction

    export RCLONE_PASSWORD_COMMAND="/usr/bin/pass rclone/config"

Windows

  • Generate and store a password

    New-Object -TypeName PSCredential -ArgumentList "rclone", (ConvertTo-SecureString -String ([System.Web.Security.Membership]::GeneratePassword(40, 10)) -AsPlainText -Force) | Export-Clixml -Path "rclone-credential.xml"

  • Add the password retrieval instruction

    [Environment]::SetEnvironmentVariable("RCLONE_PASSWORD_COMMAND", "[System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToBSTR((Import-Clixml -Path "rclone-credential.xml").Password))")

Encrypt the config file (all systems)

  • Execute rclone config, and select option s) Set configuration password

  • Add/update the password from previous steps

Developer options

These options are useful when developing or debugging rclone. There are also some more remote specific options which aren't documented here which are used for testing. These start with remote name e.g. --drive-test-option - see the docs for the remote in question.

--cpuprofile string

Write CPU profile to a file. This can be analysed with go tool pprof.

--memprofile string

Write memory profile to a file. This can be analysed with go tool pprof.

--dump DumpFlags

The --dump flag takes a comma separated list of flags to dump info about.

Note that some headers, such as Accept-Encoding, may not be correct as shown in the request, and the response may not show Content-Encoding if the go standard libraries auto gzip encoding was in effect. In this case the body of the request will be gunzipped before showing it.

The available flags are:

  • headers dumps HTTP headers. Any Authorization: headers will be excluded, but output may still contain sensitive information. Can be very verbose. Useful for debugging only. Use auth if you do want the Authorization: headers.
  • auth dumps HTTP headers like headers, but also includes any Authorization: headers. This means the output will probably contain sensitive information. Use headers to dump without Authorization: headers. Can be very verbose. Useful for debugging only.
  • bodies dumps HTTP headers and bodies. May contain sensitive info. Can be very verbose. Useful for debugging only. Note that the bodies are buffered in memory so don't use this for enormous files.
  • requests is similar to bodies, but dumps the request bodies and the response headers. Useful for debugging download problems.
  • responses is similar to bodies, but dumps the response bodies and the request headers. Useful for debugging upload problems.
  • filters dumps the filters. Useful to see exactly what include and exclude options are filtering on.
  • goroutines dumps a list of the running go-routines at the end of the command.
  • openfiles dumps a list of the open files at the end of the command. It uses the lsof Unix command to do that, so you'll need that installed to use it.
  • mapper dumps the JSON blobs being sent to the program supplied with --metadata-mapper and received from it. It can be useful for debugging the metadata mapper interface.

Filtering

For the filtering options

  • --delete-excluded
  • --filter
  • --filter-from
  • --exclude
  • --exclude-from
  • --exclude-if-present
  • --include
  • --include-from
  • --files-from
  • --files-from-raw
  • --min-size
  • --max-size
  • --min-age
  • --max-age
  • --hash-filter
  • --dump filters
  • --metadata-include
  • --metadata-include-from
  • --metadata-exclude
  • --metadata-exclude-from
  • --metadata-filter
  • --metadata-filter-from

See the filtering section.

Remote control

For the remote control options and for instructions on how to remote control rclone:

  • --rc
  • Anything starting with --rc-

See the remote control section.

Logging

rclone has 4 levels of logging, ERROR, NOTICE, INFO and DEBUG.

By default, rclone logs to standard error. This means you can redirect standard error and still see the normal output of rclone commands (e.g. rclone ls).

By default, rclone will produce Error and Notice level messages.

If you use the -q flag, rclone will only produce Error messages.

If you use the -v flag, rclone will produce Error, Notice and Info messages.

If you use the -vv flag, rclone will produce Error, Notice, Info and Debug messages.

You can also control the log levels with the --log-level flag.

If you use the --log-file option, rclone will redirect Error, Info and Debug messages along with standard error to a file.

If you use the --syslog flag then rclone will log to syslog and the --syslog-facility control which facility it uses.

Rclone prefixes all log messages with their level in capitals, e.g. INFO which makes it easy to grep the log file for different kinds of information.

Metrics

Rclone can publish metrics in the OpenMetrics/Prometheus format.

To enable the metrics endpoint, use the --metrics-addr flag. Metrics can also be published on the --rc-addr port if the --rc flag and --rc-enable-metrics flags are supplied or if using rclone rcd --rc-enable-metrics

Rclone provides extensive configuration options for the metrics HTTP endpoint. These settings are grouped under the Metrics section and have a prefix --metrics-*.

When metrics are enabled with --rc-enable-metrics, they will be published on the same port as the rc API. In this case, the --metrics-* flags will be ignored, and the HTTP endpoint configuration will be managed by the --rc-* parameters.

Exit code

If any errors occur during the command execution, rclone will exit with a non-zero exit code. This allows scripts to detect when rclone operations have failed.

During the startup phase, rclone will exit immediately if an error is detected in the configuration. There will always be a log message immediately before exiting.

When rclone is running it will accumulate errors as it goes along, and only exit with a non-zero exit code if (after retries) there were still failed transfers. For every error counted there will be a high priority log message (visible with -q) showing the message and which file caused the problem. A high priority message is also shown when starting a retry so the user can see that any previous error messages may not be valid after the retry. If rclone has done a retry it will log a high priority message if the retry was successful.

List of exit codes

  • 0 - Success
  • 1 - Error not otherwise categorised
  • 2 - Syntax or usage error
  • 3 - Directory not found
  • 4 - File not found
  • 5 - Temporary error (one that more retries might fix) (Retry errors)
  • 6 - Less serious errors (like 461 errors from dropbox) (NoRetry errors)
  • 7 - Fatal error (one that more retries won't fix, like account suspended) (Fatal errors)
  • 8 - Transfer exceeded - limit set by --max-transfer reached
  • 9 - Operation successful, but no files transferred (Requires --error-on-no-transfer)
  • 10 - Duration exceeded - limit set by --max-duration reached

Environment variables

Rclone can be configured entirely using environment variables. These can be used to set defaults for options or config file entries.

Options

Every option in rclone can have its default set by environment variable.

To find the name of the environment variable, first, take the long option name, strip the leading --, change - to _, make upper case and prepend RCLONE_.

For example, to always set --stats 5s, set the environment variable RCLONE_STATS=5s. If you set stats on the command line this will override the environment variable setting.

Or to always use the trash in drive --drive-use-trash, set RCLONE_DRIVE_USE_TRASH=true.

Verbosity is slightly different, the environment variable equivalent of --verbose or -v is RCLONE_VERBOSE=1, or for -vv, RCLONE_VERBOSE=2.

The same parser is used for the options and the environment variables so they take exactly the same form.

The options set by environment variables can be seen with the -vv flag, e.g. rclone version -vv.

Options that can appear multiple times (type stringArray) are treated slightly differently as environment variables can only be defined once. In order to allow a simple mechanism for adding one or many items, the input is treated as a CSV encoded string. For example

Environment variable Equivalent options
RCLONE_EXCLUDE="*.jpg" --exclude "*.jpg"
RCLONE_EXCLUDE="*.jpg,*.png" --exclude "*.jpg" --exclude "*.png"
RCLONE_EXCLUDE='"*.jpg","*.png"' --exclude "*.jpg" --exclude "*.png"
RCLONE_EXCLUDE='"/directory with comma , in it /**"' `--exclude "/directory with comma , in it /**"

If stringArray options are defined as environment variables and options on the command line then all the values will be used.

Config file

You can set defaults for values in the config file on an individual remote basis. The names of the config items are documented in the page for each backend.

To find the name of the environment variable, you need to set, take RCLONE_CONFIG_ + name of remote + _ + name of config file option and make it all uppercase. Note one implication here is the remote's name must be convertible into a valid environment variable name, so it can only contain letters, digits, or the _ (underscore) character.

For example, to configure an S3 remote named mys3: without a config file (using unix ways of setting environment variables):

$ export RCLONE_CONFIG_MYS3_TYPE=s3
$ export RCLONE_CONFIG_MYS3_ACCESS_KEY_ID=XXX
$ export RCLONE_CONFIG_MYS3_SECRET_ACCESS_KEY=XXX
$ rclone lsd mys3:
          -1 2016-09-21 12:54:21        -1 my-bucket
$ rclone listremotes | grep mys3
mys3:

Note that if you want to create a remote using environment variables you must create the ..._TYPE variable as above.

Note that the name of a remote created using environment variable is case insensitive, in contrast to regular remotes stored in config file as documented above. You must write the name in uppercase in the environment variable, but as seen from example above it will be listed and can be accessed in lowercase, while you can also refer to the same remote in uppercase:

$ rclone lsd mys3:
          -1 2016-09-21 12:54:21        -1 my-bucket
$ rclone lsd MYS3:
          -1 2016-09-21 12:54:21        -1 my-bucket

Note that you can only set the options of the immediate backend, so RCLONE_CONFIG_MYS3CRYPT_ACCESS_KEY_ID has no effect, if myS3Crypt is a crypt remote based on an S3 remote. However RCLONE_S3_ACCESS_KEY_ID will set the access key of all remotes using S3, including myS3Crypt.

Note also that now rclone has connection strings, it is probably easier to use those instead which makes the above example

rclone lsd :s3,access_key_id=XXX,secret_access_key=XXX:

Precedence

The various different methods of backend configuration are read in this order and the first one with a value is used.

  • Parameters in connection strings, e.g. myRemote,skip_links:
  • Flag values as supplied on the command line, e.g. --skip-links
  • Remote specific environment vars, e.g. RCLONE_CONFIG_MYREMOTE_SKIP_LINKS (see above).
  • Backend-specific environment vars, e.g. RCLONE_LOCAL_SKIP_LINKS.
  • Backend generic environment vars, e.g. RCLONE_SKIP_LINKS.
  • Config file, e.g. skip_links = true.
  • Default values, e.g. false - these can't be changed.

So if both --skip-links is supplied on the command line and an environment variable RCLONE_LOCAL_SKIP_LINKS is set, the command line flag will take preference.

The backend configurations set by environment variables can be seen with the -vv flag, e.g. rclone about myRemote: -vv.

For non backend configuration the order is as follows:

  • Flag values as supplied on the command line, e.g. --stats 5s.
  • Environment vars, e.g. RCLONE_STATS=5s.
  • Default values, e.g. 1m - these can't be changed.

Other environment variables

  • RCLONE_CONFIG_PASS set to contain your config file password (see Configuration Encryption section)
  • HTTP_PROXY, HTTPS_PROXY and NO_PROXY (or the lowercase versions thereof).
    • HTTPS_PROXY takes precedence over HTTP_PROXY for https requests.
    • The environment values may be either a complete URL or a "host[:port]" for, in which case the "http" scheme is assumed.
  • USER and LOGNAME values are used as fallbacks for current username. The primary method for looking up username is OS-specific: Windows API on Windows, real user ID in /etc/passwd on Unix systems. In the documentation the current username is simply referred to as $USER.
  • RCLONE_CONFIG_DIR - rclone sets this variable for use in config files and sub processes to point to the directory holding the config file.

The options set by environment variables can be seen with the -vv and --log-level=DEBUG flags, e.g. rclone version -vv.

Configuring rclone on a remote / headless machine

Some of the configurations (those involving oauth2) require an Internet connected web browser.

If you are trying to set rclone up on a remote or headless box with no browser available on it (e.g. a NAS or a server in a datacenter) then you will need to use an alternative means of configuration. There are two ways of doing it, described below.

Configuring using rclone authorize

On the headless box run rclone config but answer N to the Use auto config? question.

Use auto config?
 * Say Y if not sure
 * Say N if you are working on a remote or headless machine

y) Yes (default)
n) No
y/n> n

Option config_token.
For this to work, you will need rclone available on a machine that has
a web browser available.
For more help and alternate methods see: https://rclone.org/remote_setup/
Execute the following on the machine with the web browser (same rclone
version recommended):
    rclone authorize "onedrive"
Then paste the result.
Enter a value.
config_token>

Then on your main desktop machine

rclone authorize "onedrive"
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth
Log in and authorize rclone for access
Waiting for code...
Got code
Paste the following into your remote machine --->
SECRET_TOKEN
<---End paste

Then back to the headless box, paste in the code

config_token> SECRET_TOKEN
--------------------
[acd12]
client_id = 
client_secret = 
token = SECRET_TOKEN
--------------------
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d>

Configuring by copying the config file

Rclone stores all of its config in a single configuration file. This can easily be copied to configure a remote rclone.

So first configure rclone on your desktop machine with

rclone config

to set up the config file.

Find the config file by running rclone config file, for example

$ rclone config file
Configuration file is stored at:
/home/user/.rclone.conf

Now transfer it to the remote box (scp, cut paste, ftp, sftp, etc.) and place it in the correct place (use rclone config file on the remote box to find out where).

Configuring using SSH Tunnel

Linux and MacOS users can utilize SSH Tunnel to redirect the headless box port 53682 to local machine by using the following command:

ssh -L localhost:53682:localhost:53682 username@remote_server

Then on the headless box run rclone config and answer Y to the Use auto config? question.

Use auto config?
 * Say Y if not sure
 * Say N if you are working on a remote or headless machine

y) Yes (default)
n) No
y/n> y

Then copy and paste the auth url http://127.0.0.1:53682/auth?state=xxxxxxxxxxxx to the browser on your local machine, complete the auth and it is done.

Filtering, includes and excludes

Filter flags determine which files rclone sync, move, ls, lsl, md5sum, sha1sum, size, delete, check and similar commands apply to.

They are specified in terms of path/file name patterns; path/file lists; file age and size, or presence of a file in a directory. Bucket based remotes without the concept of directory apply filters to object key, age and size in an analogous way.

Rclone purge does not obey filters.

To test filters without risk of damage to data, apply them to rclone ls, or with the --dry-run and -vv flags.

Rclone filter patterns can only be used in filter command line options, not in the specification of a remote.

E.g. rclone copy "remote:dir*.jpg" /path/to/dir does not have a filter effect. rclone copy remote:dir /path/to/dir --include "*.jpg" does.

Important Avoid mixing any two of --include..., --exclude... or --filter... flags in an rclone command. The results might not be what you expect. Instead use a --filter... flag.

Patterns for matching path/file names

Pattern syntax

Here is a formal definition of the pattern syntax, examples are below.

Rclone matching rules follow a glob style:

*         matches any sequence of non-separator (/) characters
**        matches any sequence of characters including / separators
?         matches any single non-separator (/) character
[ [ ! ] { character-range } ]
          character class (must be non-empty)
{ pattern-list }
          pattern alternatives
{{ regexp }}
          regular expression to match
c         matches character c (c != *, **, ?, \, [, {, })
\c        matches reserved character c (c = *, **, ?, \, [, {, }) or character class

character-range:

c         matches character c (c != \, -, ])
\c        matches reserved character c (c = \, -, ])
lo - hi   matches character c for lo <= c <= hi

pattern-list:

pattern { , pattern }
          comma-separated (without spaces) patterns

character classes (see Go regular expression reference) include:

Named character classes (e.g. [\d], [^\d], [\D], [^\D])
Perl character classes (e.g. \s, \S, \w, \W)
ASCII character classes (e.g. [[:alnum:]], [[:alpha:]], [[:punct:]], [[:xdigit:]])

regexp for advanced users to insert a regular expression - see below for more info:

Any re2 regular expression not containing `}}`

If the filter pattern starts with a / then it only matches at the top level of the directory tree, relative to the root of the remote (not necessarily the root of the drive). If it does not start with / then it is matched starting at the end of the path/file name but it only matches a complete path element - it must match from a / separator or the beginning of the path/file.

file.jpg   - matches "file.jpg"
           - matches "directory/file.jpg"
           - doesn't match "afile.jpg"
           - doesn't match "directory/afile.jpg"
/file.jpg  - matches "file.jpg" in the root directory of the remote
           - doesn't match "afile.jpg"
           - doesn't match "directory/file.jpg"

The top level of the remote might not be the top level of the drive.

E.g. for a Microsoft Windows local directory structure

F:
├── bkp
├── data
│   ├── excl
│   │   ├── 123.jpg
│   │   └── 456.jpg
│   ├── incl
│   │   └── document.pdf

To copy the contents of folder data into folder bkp excluding the contents of subfolder exclthe following command treats F:\data and F:\bkp as top level for filtering.

rclone copy F:\data\ F:\bkp\ --exclude=/excl/**

Important Use / in path/file name patterns and not \ even if running on Microsoft Windows.

Simple patterns are case sensitive unless the --ignore-case flag is used.

Without --ignore-case (default)

potato - matches "potato"
       - doesn't match "POTATO"

With --ignore-case

potato - matches "potato"
       - matches "POTATO"

Using regular expressions in filter patterns

The syntax of filter patterns is glob style matching (like bash uses) to make things easy for users. However this does not provide absolute control over the matching, so for advanced users rclone also provides a regular expression syntax.

The regular expressions used are as defined in the Go regular expression reference. Regular expressions should be enclosed in {{ }}. They will match only the last path segment if the glob doesn't start with / or the whole path name if it does. Note that rclone does not attempt to parse the supplied regular expression, meaning that using any regular expression filter will prevent rclone from using directory filter rules, as it will instead check every path against the supplied regular expression(s).

Here is how the {{regexp}} is transformed into an full regular expression to match the entire path:

{{regexp}}  becomes (^|/)(regexp)$
/{{regexp}} becomes ^(regexp)$

Regexp syntax can be mixed with glob syntax, for example

*.{{jpe?g}} to match file.jpg, file.jpeg but not file.png

You can also use regexp flags - to set case insensitive, for example

*.{{(?i)jpg}} to match file.jpg, file.JPG but not file.png

Be careful with wildcards in regular expressions - you don't want them to match path separators normally. To match any file name starting with start and ending with end write

{{start[^/]*end\.jpg}}

Not

{{start.*end\.jpg}}

Which will match a directory called start with a file called end.jpg in it as the .* will match / characters.

Note that you can use -vv --dump filters to show the filter patterns in regexp format - rclone implements the glob patterns by transforming them into regular expressions.

Filter pattern examples

Description Pattern Matches Does not match
Wildcard *.jpg /file.jpg /file.png
/dir/file.jpg /dir/file.png
Rooted /*.jpg /file.jpg /file.png
/file2.jpg /dir/file.jpg
Alternates *.{jpg,png} /file.jpg /file.gif
/dir/file.png /dir/file.gif
Path Wildcard dir/** /dir/anyfile file.png
/subdir/dir/subsubdir/anyfile /subdir/file.png
Any Char *.t?t /file.txt /file.qxt
/dir/file.tzt /dir/file.png
Range *.[a-z] /file.a /file.0
/dir/file.b /dir/file.1
Escape *.\?\?\? /file.??? /file.abc
/dir/file.??? /dir/file.def
Class *.\d\d\d /file.012 /file.abc
/dir/file.345 /dir/file.def
Regexp *.{{jpe?g}} /file.jpeg /file.png
/dir/file.jpg /dir/file.jpeeg
Rooted Regexp /{{.*\.jpe?g}} /file.jpeg /file.png
/file.jpg /dir/file.jpg

How filter rules are applied to files

Rclone path/file name filters are made up of one or more of the following flags:

  • --include
  • --include-from
  • --exclude
  • --exclude-from
  • --filter
  • --filter-from

There can be more than one instance of individual flags.

Rclone internally uses a combined list of all the include and exclude rules. The order in which rules are processed can influence the result of the filter.

All flags of the same type are processed together in the order above, regardless of what order the different types of flags are included on the command line.

Multiple instances of the same flag are processed from left to right according to their position in the command line.

To mix up the order of processing includes and excludes use --filter... flags.

Within --include-from, --exclude-from and --filter-from flags rules are processed from top to bottom of the referenced file.

If there is an --include or --include-from flag specified, rclone implies a - ** rule which it adds to the bottom of the internal rule list. Specifying a + rule with a --filter... flag does not imply that rule.

Each path/file name passed through rclone is matched against the combined filter list. At first match to a rule the path/file name is included or excluded and no further filter rules are processed for that path/file.

If rclone does not find a match, after testing against all rules (including the implied rule if appropriate), the path/file name is included.

Any path/file included at that stage is processed by the rclone command.

--files-from and --files-from-raw flags over-ride and cannot be combined with other filter options.

To see the internal combined rule list, in regular expression form, for a command add the --dump filters flag. Running an rclone command with --dump filters and -vv flags lists the internal filter elements and shows how they are applied to each source path/file. There is not currently a means provided to pass regular expression filter options into rclone directly though character class filter rules contain character classes. Go regular expression reference

How filter rules are applied to directories

Rclone commands are applied to path/file names not directories. The entire contents of a directory can be matched to a filter by the pattern directory/* or recursively by directory/**.

Directory filter rules are defined with a closing / separator.

E.g. /directory/subdirectory/ is an rclone directory filter rule.

Rclone commands can use directory filter rules to determine whether they recurse into subdirectories. This potentially optimises access to a remote by avoiding listing unnecessary directories. Whether optimisation is desirable depends on the specific filter rules and source remote content.

If any regular expression filters are in use, then no directory recursion optimisation is possible, as rclone must check every path against the supplied regular expression(s).

Directory recursion optimisation occurs if either:

  • A source remote does not support the rclone ListR primitive. local, sftp, Microsoft OneDrive and WebDAV do not support ListR. Google Drive and most bucket type storage do. Full list

  • On other remotes (those that support ListR), if the rclone command is not naturally recursive, and provided it is not run with the --fast-list flag. ls, lsf -R and size are naturally recursive but sync, copy and move are not.

  • Whenever the --disable ListR flag is applied to an rclone command.

Rclone commands imply directory filter rules from path/file filter rules. To view the directory filter rules rclone has implied for a command specify the --dump filters flag.

E.g. for an include rule

/a/*.jpg

Rclone implies the directory include rule

/a/

Directory filter rules specified in an rclone command can limit the scope of an rclone command but path/file filters still have to be specified.

E.g. rclone ls remote: --include /directory/ will not match any files. Because it is an --include option the --exclude ** rule is implied, and the /directory/ pattern serves only to optimise access to the remote by ignoring everything outside of that directory.

E.g. rclone ls remote: --filter-from filter-list.txt with a file filter-list.txt:

- /dir1/
- /dir2/
+ *.pdf
- **

All files in directories dir1 or dir2 or their subdirectories are completely excluded from the listing. Only files of suffix pdf in the root of remote: or its subdirectories are listed. The - ** rule prevents listing of any path/files not previously matched by the rules above.

Option exclude-if-present creates a directory exclude rule based on the presence of a file in a directory and takes precedence over other rclone directory filter rules.

When using pattern list syntax, if a pattern item contains either / or **, then rclone will not able to imply a directory filter rule from this pattern list.

E.g. for an include rule

{dir1/**,dir2/**}

Rclone will match files below directories dir1 or dir2 only, but will not be able to use this filter to exclude a directory dir3 from being traversed.

Directory recursion optimisation may affect performance, but normally not the result. One exception to this is sync operations with option --create-empty-src-dirs, where any traversed empty directories will be created. With the pattern list example {dir1/**,dir2/**} above, this would create an empty directory dir3 on destination (when it exists on source). Changing the filter to {dir1,dir2}/**, or splitting it into two include rules --include dir1/** --include dir2/**, will match the same files while also filtering directories, with the result that an empty directory dir3 will no longer be created.

--exclude - Exclude files matching pattern

Excludes path/file names from an rclone command based on a single exclude rule.

This flag can be repeated. See above for the order filter flags are processed in.

--exclude should not be used with --include, --include-from, --filter or --filter-from flags.

--exclude has no effect when combined with --files-from or --files-from-raw flags.

E.g. rclone ls remote: --exclude *.bak excludes all .bak files from listing.

E.g. rclone size remote: --exclude "/dir/**" returns the total size of all files on remote: excluding those in root directory dir and sub directories.

E.g. on Microsoft Windows rclone ls remote: --exclude "*\[{JP,KR,HK}\]*" lists the files in remote: without [JP] or [KR] or [HK] in their name. Quotes prevent the shell from interpreting the \ characters.\ characters escape the [ and ] so an rclone filter treats them literally rather than as a character-range. The { and } define an rclone pattern list. For other operating systems single quotes are required ie rclone ls remote: --exclude '*\[{JP,KR,HK}\]*'

--exclude-from - Read exclude patterns from file

Excludes path/file names from an rclone command based on rules in a named file. The file contains a list of remarks and pattern rules.

For an example exclude-file.txt:

# a sample exclude rule file
*.bak
file2.jpg

rclone ls remote: --exclude-from exclude-file.txt lists the files on remote: except those named file2.jpg or with a suffix .bak. That is equivalent to rclone ls remote: --exclude file2.jpg --exclude "*.bak".

This flag can be repeated. See above for the order filter flags are processed in.

The --exclude-from flag is useful where multiple exclude filter rules are applied to an rclone command.

--exclude-from should not be used with --include, --include-from, --filter or --filter-from flags.

--exclude-from has no effect when combined with --files-from or --files-from-raw flags.

--exclude-from followed by - reads filter rules from standard input.

--include - Include files matching pattern

Adds a single include rule based on path/file names to an rclone command.

This flag can be repeated. See above for the order filter flags are processed in.

--include has no effect when combined with --files-from or --files-from-raw flags.

--include implies --exclude ** at the end of an rclone internal filter list. Therefore if you mix --include and --include-from flags with --exclude, --exclude-from, --filter or --filter-from, you must use include rules for all the files you want in the include statement. For more flexibility use the --filter-from flag.

E.g. rclone ls remote: --include "*.{png,jpg}" lists the files on remote: with suffix .png and .jpg. All other files are excluded.

E.g. multiple rclone copy commands can be combined with --include and a pattern-list.

rclone copy /vol1/A remote:A
rclone copy /vol1/B remote:B

is equivalent to:

rclone copy /vol1 remote: --include "{A,B}/**"

E.g. rclone ls remote:/wheat --include "??[^[:punct:]]*" lists the files remote: directory wheat (and subdirectories) whose third character is not punctuation. This example uses an ASCII character class.

--include-from - Read include patterns from file

Adds path/file names to an rclone command based on rules in a named file. The file contains a list of remarks and pattern rules.

For an example include-file.txt:

# a sample include rule file
*.jpg
file2.avi

rclone ls remote: --include-from include-file.txt lists the files on remote: with name file2.avi or suffix .jpg. That is equivalent to rclone ls remote: --include file2.avi --include "*.jpg".

This flag can be repeated. See above for the order filter flags are processed in.

The --include-from flag is useful where multiple include filter rules are applied to an rclone command.

--include-from implies --exclude ** at the end of an rclone internal filter list. Therefore if you mix --include and --include-from flags with --exclude, --exclude-from, --filter or --filter-from, you must use include rules for all the files you want in the include statement. For more flexibility use the --filter-from flag.

--include-from has no effect when combined with --files-from or --files-from-raw flags.

--include-from followed by - reads filter rules from standard input.

--filter - Add a file-filtering rule

Specifies path/file names to an rclone command, based on a single include or exclude rule, in + or - format.

This flag can be repeated. See above for the order filter flags are processed in.

--filter + differs from --include. In the case of --include rclone implies an --exclude * rule which it adds to the bottom of the internal rule list. --filter...+ does not imply that rule.

--filter has no effect when combined with --files-from or --files-from-raw flags.

--filter should not be used with --include, --include-from, --exclude or --exclude-from flags.

E.g. rclone ls remote: --filter "- *.bak" excludes all .bak files from a list of remote:.

--filter-from - Read filtering patterns from a file

Adds path/file names to an rclone command based on rules in a named file. The file contains a list of remarks and pattern rules. Include rules start with + and exclude rules with -. ! clears existing rules. Rules are processed in the order they are defined.

This flag can be repeated. See above for the order filter flags are processed in.

Arrange the order of filter rules with the most restrictive first and work down.

Lines starting with # or ; are ignored, and can be used to write comments. Inline comments are not supported. Use -vv --dump filters to see how they appear in the final regexp.

E.g. for filter-file.txt:

# a sample filter rule file
- secret*.jpg
+ *.jpg
+ *.png
+ file2.avi
- /dir/tmp/** # WARNING! This text will be treated as part of the path.
- /dir/Trash/**
+ /dir/**
# exclude everything else
- *

rclone ls remote: --filter-from filter-file.txt lists the path/files on remote: including all jpg and png files, excluding any matching secret*.jpg and including file2.avi. It also includes everything in the directory dir at the root of remote, except remote:dir/Trash which it excludes. Everything else is excluded.

E.g. for an alternative filter-file.txt:

- secret*.jpg
+ *.jpg
+ *.png
+ file2.avi
- *

Files file1.jpg, file3.png and file2.avi are listed whilst secret17.jpg and files without the suffix .jpg or .png are excluded.

E.g. for an alternative filter-file.txt:

+ *.jpg
+ *.gif
!
+ 42.doc
- *

Only file 42.doc is listed. Prior rules are cleared by the !.

--files-from - Read list of source-file names

Adds path/files to an rclone command from a list in a named file. Rclone processes the path/file names in the order of the list, and no others.

Other filter flags (--include, --include-from, --exclude, --exclude-from, --filter and --filter-from) are ignored when --files-from is used.

--files-from expects a list of files as its input. Leading or trailing whitespace is stripped from the input lines. Lines starting with # or ; are ignored.

--files-from followed by - reads the list of files from standard input.

Rclone commands with a --files-from flag traverse the remote, treating the names in --files-from as a set of filters.

If the --no-traverse and --files-from flags are used together an rclone command does not traverse the remote. Instead it addresses each path/file named in the file individually. For each path/file name, that requires typically 1 API call. This can be efficient for a short --files-from list and a remote containing many files.

Rclone commands do not error if any names in the --files-from file are missing from the source remote.

The --files-from flag can be repeated in a single rclone command to read path/file names from more than one file. The files are read from left to right along the command line.

Paths within the --files-from file are interpreted as starting with the root specified in the rclone command. Leading / separators are ignored. See --files-from-raw if you need the input to be processed in a raw manner.

E.g. for a file files-from.txt:

# comment
file1.jpg
subdir/file2.jpg

rclone copy --files-from files-from.txt /home/me/pics remote:pics copies the following, if they exist, and only those files.

/home/me/pics/file1.jpg        → remote:pics/file1.jpg
/home/me/pics/subdir/file2.jpg → remote:pics/subdir/file2.jpg

E.g. to copy the following files referenced by their absolute paths:

/home/user1/42
/home/user1/dir/ford
/home/user2/prefect

First find a common subdirectory - in this case /home and put the remaining files in files-from.txt with or without leading /, e.g.

user1/42
user1/dir/ford
user2/prefect

Then copy these to a remote:

rclone copy --files-from files-from.txt /home remote:backup

The three files are transferred as follows:

/home/user1/42       → remote:backup/user1/important
/home/user1/dir/ford → remote:backup/user1/dir/file
/home/user2/prefect  → remote:backup/user2/stuff

Alternatively if / is chosen as root files-from.txt will be:

/home/user1/42
/home/user1/dir/ford
/home/user2/prefect

The copy command will be:

rclone copy --files-from files-from.txt / remote:backup

Then there will be an extra home directory on the remote:

/home/user1/42       → remote:backup/home/user1/42
/home/user1/dir/ford → remote:backup/home/user1/dir/ford
/home/user2/prefect  → remote:backup/home/user2/prefect

--files-from-raw - Read list of source-file names without any processing

This flag is the same as --files-from except that input is read in a raw manner. Lines with leading / trailing whitespace, and lines starting with ; or # are read without any processing. rclone lsf has a compatible format that can be used to export file lists from remotes for input to --files-from-raw.

--ignore-case - make searches case insensitive

By default, rclone filter patterns are case sensitive. The --ignore-case flag makes all of the filters patterns on the command line case insensitive.

E.g. --include "zaphod.txt" does not match a file Zaphod.txt. With --ignore-case a match is made.

Quoting shell metacharacters

Rclone commands with filter patterns containing shell metacharacters may not as work as expected in your shell and may require quoting.

E.g. linux, OSX (* metacharacter)

  • --include \*.jpg
  • --include '*.jpg'
  • --include='*.jpg'

Microsoft Windows expansion is done by the command, not shell, so --include *.jpg does not require quoting.

If the rclone error Command .... needs .... arguments maximum: you provided .... non flag arguments: is encountered, the cause is commonly spaces within the name of a remote or flag value. The fix then is to quote values containing spaces.

Other filters

--min-size - Don't transfer any file smaller than this

Controls the minimum size file within the scope of an rclone command. Default units are KiB but abbreviations B, K, M, G, T or P are valid.

E.g. rclone ls remote: --min-size 50k lists files on remote: of 50 KiB size or larger.

See the size option docs for more info.

--max-size - Don't transfer any file larger than this

Controls the maximum size file within the scope of an rclone command. Default units are KiB but abbreviations B, K, M, G, T or P are valid.

E.g. rclone ls remote: --max-size 1G lists files on remote: of 1 GiB size or smaller.

See the size option docs for more info.

--max-age - Don't transfer any file older than this

Controls the maximum age of files within the scope of an rclone command.

--max-age applies only to files and not to directories.

E.g. rclone ls remote: --max-age 2d lists files on remote: of 2 days old or less.

See the time option docs for valid formats.

--min-age - Don't transfer any file younger than this

Controls the minimum age of files within the scope of an rclone command. (see --max-age for valid formats)

--min-age applies only to files and not to directories.

E.g. rclone ls remote: --min-age 2d lists files on remote: of 2 days old or more.

See the time option docs for valid formats.

--hash-filter - Deterministically select a subset of files

The --hash-filter flag enables selecting a deterministic subset of files, useful for:

  1. Running large sync operations across multiple machines.
  2. Checking a subset of files for bitrot.
  3. Any other operations where a sample of files is required.

Syntax

The flag takes two parameters expressed as a fraction:

--hash-filter K/N
  • N: The total number of partitions (must be a positive integer).
  • K: The specific partition to select (an integer from 0 to N).

For example:

  • --hash-filter 1/3: Selects the first third of the files.
  • --hash-filter 2/3 and --hash-filter 3/3: Select the second and third partitions, respectively.

Each partition is non-overlapping, ensuring all files are covered without duplication.

Random Partition Selection

Use @ as K to randomly select a partition:

--hash-filter @/M

For example, --hash-filter @/3 will randomly select a number between 0 and 2. This will stay constant across retries.

How It Works

  • Rclone takes each file's full path, normalizes it to lowercase, and applies Unicode normalization.
  • It then hashes the normalized path into a 64 bit number.
  • The hash result is reduced modulo N to assign the file to a partition.
  • If the calculated partition does not match K the file is excluded.
  • Other filters may apply if the file is not excluded.

Important: Rclone will traverse all directories to apply the filter.

Usage Notes

  • Safe to use with rclone sync; source and destination selections will match.
  • Do not use with --delete-excluded, as this could delete unselected files.
  • Ignored if --files-from is used.

Examples

Dividing files into 4 partitions

Assuming the current directory contains file1.jpg through file9.jpg:

$ rclone lsf --hash-filter 0/4 .
file1.jpg
file5.jpg

$ rclone lsf --hash-filter 1/4 .
file3.jpg
file6.jpg
file9.jpg

$ rclone lsf --hash-filter 2/4 .
file2.jpg
file4.jpg

$ rclone lsf --hash-filter 3/4 .
file7.jpg
file8.jpg

$ rclone lsf --hash-filter 4/4 . # the same as --hash-filter 0/4
file1.jpg
file5.jpg
Syncing the first quarter of files
rclone sync --hash-filter 1/4 source:path destination:path
Checking a random 1% of files for integrity
rclone check --download --hash-filter @/100 source:path destination:path

Other flags

--delete-excluded - Delete files on dest excluded from sync

Important this flag is dangerous to your data - use with --dry-run and -v first.

In conjunction with rclone sync, --delete-excluded deletes any files on the destination which are excluded from the command.

E.g. the scope of rclone sync --interactive A: B: can be restricted:

rclone --min-size 50k --delete-excluded sync A: B:

All files on B: which are less than 50 KiB are deleted because they are excluded from the rclone sync command.

--dump filters - dump the filters to the output

Dumps the defined filters to standard output in regular expression format.

Useful for debugging.

Exclude directory based on a file

The --exclude-if-present flag controls whether a directory is within the scope of an rclone command based on the presence of a named file within it. The flag can be repeated to check for multiple file names, presence of any of them will exclude the directory.

This flag has a priority over other filter flags.

E.g. for the following directory structure:

dir1/file1
dir1/dir2/file2
dir1/dir2/dir3/file3
dir1/dir2/dir3/.ignore

The command rclone ls --exclude-if-present .ignore dir1 does not list dir3, file3 or .ignore.

Metadata filters

The metadata filters work in a very similar way to the normal file name filters, except they match metadata on the object.

The metadata should be specified as key=value patterns. This may be wildcarded using the normal filter patterns or regular expressions.

For example if you wished to list only local files with a mode of 100664 you could do that with:

rclone lsf -M --files-only --metadata-include "mode=100664" .

Or if you wished to show files with an atime, mtime or btime at a given date:

rclone lsf -M --files-only --metadata-include "[abm]time=2022-12-16*" .

Like file filtering, metadata filtering only applies to files not to directories.

The filters can be applied using these flags.

  • --metadata-include - Include metadatas matching pattern
  • --metadata-include-from - Read metadata include patterns from file (use - to read from stdin)
  • --metadata-exclude - Exclude metadatas matching pattern
  • --metadata-exclude-from - Read metadata exclude patterns from file (use - to read from stdin)
  • --metadata-filter - Add a metadata filtering rule
  • --metadata-filter-from - Read metadata filtering patterns from a file (use - to read from stdin)

Each flag can be repeated. See the section on how filter rules are applied for more details - these flags work in an identical way to the file name filtering flags, but instead of file name patterns have metadata patterns.

Common pitfalls

The most frequent filter support issues on the rclone forum are:

  • Not using paths relative to the root of the remote
  • Not using / to match from the root of a remote
  • Not using ** to match the contents of a directory

GUI (Experimental)

Rclone can serve a web based GUI (graphical user interface). This is somewhat experimental at the moment so things may be subject to change.

Run this command in a terminal and rclone will download and then display the GUI in a web browser.

rclone rcd --rc-web-gui

This will produce logs like this and rclone needs to continue to run to serve the GUI:

2019/08/25 11:40:14 NOTICE: A new release for gui is present at https://github.com/rclone/rclone-webui-react/releases/download/v0.0.6/currentbuild.zip
2019/08/25 11:40:14 NOTICE: Downloading webgui binary. Please wait. [Size: 3813937, Path :  /home/USER/.cache/rclone/webgui/v0.0.6.zip]
2019/08/25 11:40:16 NOTICE: Unzipping
2019/08/25 11:40:16 NOTICE: Serving remote control on http://127.0.0.1:5572/

This assumes you are running rclone locally on your machine. It is possible to separate the rclone and the GUI - see below for details.

If you wish to check for updates then you can add --rc-web-gui-update to the command line.

If you find your GUI broken, you may force it to update by add --rc-web-gui-force-update.

By default, rclone will open your browser. Add --rc-web-gui-no-open-browser to disable this feature.

Using the GUI

Once the GUI opens, you will be looking at the dashboard which has an overall overview.

On the left hand side you will see a series of view buttons you can click on:

  • Dashboard - main overview
  • Configs - examine and create new configurations
  • Explorer - view, download and upload files to the cloud storage systems
  • Backend - view or alter the backend config
  • Log out

(More docs and walkthrough video to come!)

How it works

When you run the rclone rcd --rc-web-gui this is what happens

  • Rclone starts but only runs the remote control API ("rc").
  • The API is bound to localhost with an auto-generated username and password.
  • If the API bundle is missing then rclone will download it.
  • rclone will start serving the files from the API bundle over the same port as the API
  • rclone will open the browser with a login_token so it can log straight in.

Advanced use

The rclone rcd may use any of the flags documented on the rc page.

The flag --rc-web-gui is shorthand for

  • Download the web GUI if necessary
  • Check we are using some authentication
  • --rc-user gui
  • --rc-pass <random password>
  • --rc-serve

These flags can be overridden as desired.

See also the rclone rcd documentation.

Example: Running a public GUI

For example the GUI could be served on a public port over SSL using an htpasswd file using the following flags:

  • --rc-web-gui
  • --rc-addr :443
  • --rc-htpasswd /path/to/htpasswd
  • --rc-cert /path/to/ssl.crt
  • --rc-key /path/to/ssl.key

Example: Running a GUI behind a proxy

If you want to run the GUI behind a proxy at /rclone you could use these flags:

  • --rc-web-gui
  • --rc-baseurl rclone
  • --rc-htpasswd /path/to/htpasswd

Or instead of htpasswd if you just want a single user and password:

  • --rc-user me
  • --rc-pass mypassword

Project

The GUI is being developed in the: rclone/rclone-webui-react repository.

Bug reports and contributions are very welcome :-)

If you have questions then please ask them on the rclone forum.

Remote controlling rclone with its API

If rclone is run with the --rc flag then it starts an HTTP server which can be used to remote control rclone using its API.

You can either use the rc command to access the API or use HTTP directly.

If you just want to run a remote control then see the rcd command.

Supported parameters

--rc

Flag to start the http server listen on remote requests.

--rc-addr=IP

IPaddress:Port or :Port to bind server to. (default "localhost:5572").

--rc-cert=KEY

SSL PEM key (concatenation of certificate and CA certificate).

--rc-client-ca=PATH

Client certificate authority to verify clients with.

--rc-htpasswd=PATH

htpasswd file - if not provided no authentication is done.

--rc-key=PATH

TLS PEM private key file.

--rc-max-header-bytes=VALUE

Maximum size of request header (default 4096).

--rc-min-tls-version=VALUE

The minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0").

--rc-user=VALUE

User name for authentication.

--rc-pass=VALUE

Password for authentication.

--rc-realm=VALUE

Realm for authentication (default "rclone").

--rc-server-read-timeout=DURATION

Timeout for server reading data (default 1h0m0s).

--rc-server-write-timeout=DURATION

Timeout for server writing data (default 1h0m0s).

--rc-serve

Enable the serving of remote objects via the HTTP interface. This means objects will be accessible at http://127.0.0.1:5572/ by default, so you can browse to http://127.0.0.1:5572/ or http://127.0.0.1:5572/* to see a listing of the remotes. Objects may be requested from remotes using this syntax http://127.0.0.1:5572/[remote:path]/path/to/object

Default Off.

--rc-serve-no-modtime

Set this flag to skip reading the modification time (can speed things up).

Default Off.

--rc-files /path/to/directory

Path to local files to serve on the HTTP server.

If this is set then rclone will serve the files in that directory. It will also open the root in the web browser if specified. This is for implementing browser based GUIs for rclone functions.

If --rc-user or --rc-pass is set then the URL that is opened will have the authorization in the URL in the http://user:pass@localhost/ style.

Default Off.

--rc-enable-metrics

Enable OpenMetrics/Prometheus compatible endpoint at /metrics. If more control over the metrics is desired (for example running it on a different port or with different auth) then endpoint can be enabled with the --metrics-* flags instead.

Default Off.

--rc-web-gui

Set this flag to serve the default web gui on the same port as rclone.

Default Off.

--rc-allow-origin

Set the allowed Access-Control-Allow-Origin for rc requests.

Can be used with --rc-web-gui if the rclone is running on different IP than the web-gui.

Default is IP address on which rc is running.

--rc-web-fetch-url

Set the URL to fetch the rclone-web-gui files from.

Default https://api.github.com/repos/rclone/rclone-webui-react/releases/latest.

--rc-web-gui-update

Set this flag to check and update rclone-webui-react from the rc-web-fetch-url.

Default Off.

--rc-web-gui-force-update

Set this flag to force update rclone-webui-react from the rc-web-fetch-url.

Default Off.

--rc-web-gui-no-open-browser

Set this flag to disable opening browser automatically when using web-gui.

Default Off.

--rc-job-expire-duration=DURATION

Expire finished async jobs older than DURATION (default 60s).

--rc-job-expire-interval=DURATION

Interval duration to check for expired async jobs (default 10s).

--rc-no-auth

By default rclone will require authorisation to have been set up on the rc interface in order to use any methods which access any rclone remotes. Eg operations/list is denied as it involved creating a remote as is sync/copy.

If this is set then no authorisation will be required on the server to use these methods. The alternative is to use --rc-user and --rc-pass and use these credentials in the request.

Default Off.

--rc-baseurl

Prefix for URLs.

Default is root

--rc-template

User-specified template.

Accessing the remote control via the rclone rc command

Rclone itself implements the remote control protocol in its rclone rc command.

You can use it like this:

$ rclone rc rc/noop param1=one param2=two
{
    "param1": "one",
    "param2": "two"
}

If the remote is running on a different URL than the default http://localhost:5572/, use the --url option to specify it:

rclone rc --url http://some.remote:1234/ rc/noop

Or, if the remote is listening on a Unix socket, use the --unix-socket option instead:

rclone rc --unix-socket /tmp/rclone.sock rc/noop

Run rclone rc on its own, without any commands, to see the help for the installed remote control commands. Note that this also needs to connect to the remote server.

JSON input

rclone rc also supports a --json flag which can be used to send more complicated input parameters.

$ rclone rc --json '{ "p1": [1,"2",null,4], "p2": { "a":1, "b":2 } }' rc/noop
{
    "p1": [
        1,
        "2",
        null,
        4
    ],
    "p2": {
        "a": 1,
        "b": 2
    }
}

If the parameter being passed is an object then it can be passed as a JSON string rather than using the --json flag which simplifies the command line.

rclone rc operations/list fs=/tmp remote=test opt='{"showHash": true}'

Rather than

rclone rc operations/list --json '{"fs": "/tmp", "remote": "test", "opt": {"showHash": true}}'

Special parameters

The rc interface supports some special parameters which apply to all commands. These start with _ to show they are different.

Running asynchronous jobs with _async = true

Each rc call is classified as a job and it is assigned its own id. By default jobs are executed immediately as they are created or synchronously.

If _async has a true value when supplied to an rc call then it will return immediately with a job id and the task will be run in the background. The job/status call can be used to get information of the background job. The job can be queried for up to 1 minute after it has finished.

It is recommended that potentially long running jobs, e.g. sync/sync, sync/copy, sync/move, operations/purge are run with the _async flag to avoid any potential problems with the HTTP request and response timing out.

Starting a job with the _async flag:

$ rclone rc --json '{ "p1": [1,"2",null,4], "p2": { "a":1, "b":2 }, "_async": true }' rc/noop
{
    "jobid": 2
}

Query the status to see if the job has finished. For more information on the meaning of these return parameters see the job/status call.

$ rclone rc --json '{ "jobid":2 }' job/status
{
    "duration": 0.000124163,
    "endTime": "2018-10-27T11:38:07.911245881+01:00",
    "error": "",
    "finished": true,
    "id": 2,
    "output": {
        "_async": true,
        "p1": [
            1,
            "2",
            null,
            4
        ],
        "p2": {
            "a": 1,
            "b": 2
        }
    },
    "startTime": "2018-10-27T11:38:07.911121728+01:00",
    "success": true
}

job/list can be used to show the running or recently completed jobs

$ rclone rc job/list
{
    "jobids": [
        2
    ]
}

Setting config flags with _config

If you wish to set config (the equivalent of the global flags) for the duration of an rc call only then pass in the _config parameter.

This should be in the same format as the main key returned by options/get.

rclone rc --loopback options/get blocks=main

You can see more help on these options with this command (see the options blocks section for more info).

rclone rc --loopback options/info blocks=main

For example, if you wished to run a sync with the --checksum parameter, you would pass this parameter in your JSON blob.

"_config":{"CheckSum": true}

If using rclone rc this could be passed as

rclone rc sync/sync ... _config='{"CheckSum": true}'

Any config parameters you don't set will inherit the global defaults which were set with command line flags or environment variables.

Note that it is possible to set some values as strings or integers - see data types for more info. Here is an example setting the equivalent of --buffer-size in string or integer format.

"_config":{"BufferSize": "42M"}
"_config":{"BufferSize": 44040192}

If you wish to check the _config assignment has worked properly then calling options/local will show what the value got set to.

Setting filter flags with _filter

If you wish to set filters for the duration of an rc call only then pass in the _filter parameter.

This should be in the same format as the filter key returned by options/get.

rclone rc --loopback options/get blocks=filter

You can see more help on these options with this command (see the options blocks section for more info).

rclone rc --loopback options/info blocks=filter

For example, if you wished to run a sync with these flags

--max-size 1M --max-age 42s --include "a" --include "b"

you would pass this parameter in your JSON blob.

"_filter":{"MaxSize":"1M", "IncludeRule":["a","b"], "MaxAge":"42s"}

If using rclone rc this could be passed as

rclone rc ... _filter='{"MaxSize":"1M", "IncludeRule":["a","b"], "MaxAge":"42s"}'

Any filter parameters you don't set will inherit the global defaults which were set with command line flags or environment variables.

Note that it is possible to set some values as strings or integers - see data types for more info. Here is an example setting the equivalent of --buffer-size in string or integer format.

"_filter":{"MinSize": "42M"}
"_filter":{"MinSize": 44040192}

If you wish to check the _filter assignment has worked properly then calling options/local will show what the value got set to.

Assigning operations to groups with _group = value

Each rc call has its own stats group for tracking its metrics. By default grouping is done by the composite group name from prefix job/ and id of the job like so job/1.

If _group has a value then stats for that request will be grouped under that value. This allows caller to group stats under their own name.

Stats for specific group can be accessed by passing group to core/stats:

$ rclone rc --json '{ "group": "job/1" }' core/stats
{
    "speed": 12345
    ...
}

Data types

When the API returns types, these will mostly be straight forward integer, string or boolean types.

However some of the types returned by the options/get call and taken by the options/set calls as well as the vfsOpt, mountOpt and the _config parameters.

  • Duration - these are returned as an integer duration in nanoseconds. They may be set as an integer, or they may be set with time string, eg "5s". See the options section for more info.
  • Size - these are returned as an integer number of bytes. They may be set as an integer or they may be set with a size suffix string, eg "10M". See the options section for more info.
  • Enumerated type (such as CutoffMode, DumpFlags, LogLevel, VfsCacheMode - these will be returned as an integer and may be set as an integer but more conveniently they can be set as a string, eg "HARD" for CutoffMode or DEBUG for LogLevel.
  • BandwidthSpec - this will be set and returned as a string, eg "1M".

Option blocks

The calls options/info (for the main config) and config/providers (for the backend config) may be used to get information on the rclone configuration options. This can be used to build user interfaces for displaying and setting any rclone option.

These consist of arrays of Option blocks. These have the following format. Each block describes a single option.

Field Type Optional Description
Name string N name of the option in snake_case
FieldName string N name of the field used in the rc - if blank use Name. May contain "." for nested fields.
Help string N help, started with a single sentence on a single line
Groups string Y groups this option belongs to - comma separated string for options classification
Provider string Y set to filter on provider
Default any N default value, if set (and not to nil or "") then Required does nothing
Value any N value to be set by flags
Examples Examples Y predefined values that can be selected from list (multiple-choice option)
ShortOpt string Y the short command line option for this
Hide Visibility N if non zero, this option is hidden from the configurator or the command line
Required bool N this option is required, meaning value cannot be empty unless there is a default
IsPassword bool N set if the option is a password
NoPrefix bool N set if the option for this should not use the backend prefix
Advanced bool N set if this is an advanced config option
Exclusive bool N set if the answer can only be one of the examples (empty string allowed unless Required or Default is set)
Sensitive bool N set if this option should be redacted when using rclone config redacted

An example of this might be the --log-level flag. Note that the Name of the option becomes the command line flag with _ replaced with -.

{
    "Advanced": false,
    "Default": 5,
    "DefaultStr": "NOTICE",
    "Examples": [
        {
            "Help": "",
            "Value": "EMERGENCY"
        },
        {
            "Help": "",
            "Value": "ALERT"
        },
        ...
    ],
    "Exclusive": true,
    "FieldName": "LogLevel",
    "Groups": "Logging",
    "Help": "Log level DEBUG|INFO|NOTICE|ERROR",
    "Hide": 0,
    "IsPassword": false,
    "Name": "log_level",
    "NoPrefix": true,
    "Required": true,
    "Sensitive": false,
    "Type": "LogLevel",
    "Value": null,
    "ValueStr": "NOTICE"
},

Note that the Help may be multiple lines separated by \n. The first line will always be a short sentence and this is the sentence shown when running rclone help flags.

Specifying remotes to work on

Remotes are specified with the fs=, srcFs=, dstFs= parameters depending on the command being used.

The parameters can be a string as per the rest of rclone, eg s3:bucket/path or :sftp:/my/dir. They can also be specified as JSON blobs.

If specifying a JSON blob it should be a object mapping strings to strings. These values will be used to configure the remote. There are 3 special values which may be set:

  • type - set to type to specify a remote called :type:
  • _name - set to name to specify a remote called name:
  • _root - sets the root of the remote - may be empty

One of _name or type should normally be set. If the local backend is desired then type should be set to local. If _root isn't specified then it defaults to the root of the remote.

For example this JSON is equivalent to remote:/tmp

{
    "_name": "remote",
    "_root": "/tmp"
}

And this is equivalent to :sftp,host='example.com':/tmp

{
    "type": "sftp",
    "host": "example.com",
    "_root": "/tmp"
}

And this is equivalent to /tmp/dir

{
    "type": "local",
    "_root": "/tmp/dir"
}

Supported commands

backend/command: Runs a backend command.

This takes the following parameters:

  • command - a string with the command name
  • fs - a remote name string e.g. "drive:"
  • arg - a list of arguments for the backend command
  • opt - a map of string to string of options

Returns:

  • result - result from the backend command

Example:

rclone rc backend/command command=noop fs=. -o echo=yes -o blue -a path1 -a path2

Returns

{
    "result": {
        "arg": [
            "path1",
            "path2"
        ],
        "name": "noop",
        "opt": {
            "blue": "",
            "echo": "yes"
        }
    }
}

Note that this is the direct equivalent of using this "backend" command:

rclone backend noop . -o echo=yes -o blue path1 path2

Note that arguments must be preceded by the "-a" flag

See the backend command for more information.

Authentication is required for this call.

cache/expire: Purge a remote from cache

Purge a remote from the cache backend. Supports either a directory or a file. Params: - remote = path to remote (required) - withData = true/false to delete cached data (chunks) as well (optional)

Eg

rclone rc cache/expire remote=path/to/sub/folder/
rclone rc cache/expire remote=/ withData=true

cache/fetch: Fetch file chunks

Ensure the specified file chunks are cached on disk.

The chunks= parameter specifies the file chunks to check. It takes a comma separated list of array slice indices. The slice indices are similar to Python slices: start[:end]

start is the 0 based chunk number from the beginning of the file to fetch inclusive. end is 0 based chunk number from the beginning of the file to fetch exclusive. Both values can be negative, in which case they count from the back of the file. The value "-5:" represents the last 5 chunks of a file.

Some valid examples are: ":5,-5:" -> the first and last five chunks "0,-2" -> the first and the second last chunk "0:10" -> the first ten chunks

Any parameter with a key that starts with "file" can be used to specify files to fetch, e.g.

rclone rc cache/fetch chunks=0 file=hello file2=home/goodbye

File names will automatically be encrypted when the a crypt remote is used on top of the cache.

cache/stats: Get cache stats

Show statistics for the cache remote.

config/create: create the config for a remote.

This takes the following parameters:

  • name - name of remote
  • parameters - a map of { "key": "value" } pairs
  • type - type of the new remote
  • opt - a dictionary of options to control the configuration
    • obscure - declare passwords are plain and need obscuring
    • noObscure - declare passwords are already obscured and don't need obscuring
    • noOutput - don't print anything to stdout
    • nonInteractive - don't interact with a user, return questions
    • continue - continue the config process with an answer
    • all - ask all the config questions not just the post config ones
    • state - state to restart with - used with continue
    • result - result to restart with - used with continue

See the config create command for more information on the above.

Authentication is required for this call.

config/delete: Delete a remote in the config file.

Parameters:

  • name - name of remote to delete

See the config delete command for more information on the above.

Authentication is required for this call.

config/dump: Dumps the config file.

Returns a JSON object: - key: value

Where keys are remote names and values are the config parameters.

See the config dump command for more information on the above.

Authentication is required for this call.

config/get: Get a remote in the config file.

Parameters:

  • name - name of remote to get

See the config dump command for more information on the above.

Authentication is required for this call.

config/listremotes: Lists the remotes in the config file and defined in environment variables.

Returns - remotes - array of remote names

See the listremotes command for more information on the above.

Authentication is required for this call.

config/password: password the config for a remote.

This takes the following parameters:

  • name - name of remote
  • parameters - a map of { "key": "value" } pairs

See the config password command for more information on the above.

Authentication is required for this call.

config/paths: Reads the config file path and other important paths.

Returns a JSON object with the following keys:

  • config: path to config file
  • cache: path to root of cache directory
  • temp: path to root of temporary directory

Eg

{
    "cache": "/home/USER/.cache/rclone",
    "config": "/home/USER/.rclone.conf",
    "temp": "/tmp"
}

See the config paths command for more information on the above.

Authentication is required for this call.

config/providers: Shows how providers are configured in the config file.

Returns a JSON object: - providers - array of objects

See the config providers command for more information on the above.

Note that the Options blocks are in the same format as returned by "options/info". They are described in the option blocks section.

Authentication is required for this call.

config/setpath: Set the path of the config file

Parameters:

  • path - path to the config file to use

Authentication is required for this call.

config/unlock: Unlock the config file.

Unlocks the config file if it is locked.

Parameters:

  • 'config_password' - password to unlock the config file

A good idea is to disable AskPassword before making this call

Authentication is required for this call.

config/update: update the config for a remote.

This takes the following parameters:

  • name - name of remote
  • parameters - a map of { "key": "value" } pairs
  • opt - a dictionary of options to control the configuration
    • obscure - declare passwords are plain and need obscuring
    • noObscure - declare passwords are already obscured and don't need obscuring
    • noOutput - don't print anything to stdout
    • nonInteractive - don't interact with a user, return questions
    • continue - continue the config process with an answer
    • all - ask all the config questions not just the post config ones
    • state - state to restart with - used with continue
    • result - result to restart with - used with continue

See the config update command for more information on the above.

Authentication is required for this call.

core/bwlimit: Set the bandwidth limit.

This sets the bandwidth limit to the string passed in. This should be a single bandwidth limit entry or a pair of upload:download bandwidth.

Eg

rclone rc core/bwlimit rate=off
{
    "bytesPerSecond": -1,
    "bytesPerSecondTx": -1,
    "bytesPerSecondRx": -1,
    "rate": "off"
}
rclone rc core/bwlimit rate=1M
{
    "bytesPerSecond": 1048576,
    "bytesPerSecondTx": 1048576,
    "bytesPerSecondRx": 1048576,
    "rate": "1M"
}
rclone rc core/bwlimit rate=1M:100k
{
    "bytesPerSecond": 1048576,
    "bytesPerSecondTx": 1048576,
    "bytesPerSecondRx": 131072,
    "rate": "1M"
}

If the rate parameter is not supplied then the bandwidth is queried

rclone rc core/bwlimit
{
    "bytesPerSecond": 1048576,
    "bytesPerSecondTx": 1048576,
    "bytesPerSecondRx": 1048576,
    "rate": "1M"
}

The format of the parameter is exactly the same as passed to --bwlimit except only one bandwidth may be specified.

In either case "rate" is returned as a human-readable string, and "bytesPerSecond" is returned as a number.

core/command: Run a rclone terminal command over rc.

This takes the following parameters:

  • command - a string with the command name.
  • arg - a list of arguments for the backend command.
  • opt - a map of string to string of options.
  • returnType - one of ("COMBINED_OUTPUT", "STREAM", "STREAM_ONLY_STDOUT", "STREAM_ONLY_STDERR").
    • Defaults to "COMBINED_OUTPUT" if not set.
    • The STREAM returnTypes will write the output to the body of the HTTP message.
    • The COMBINED_OUTPUT will write the output to the "result" parameter.

Returns:

  • result - result from the backend command.
    • Only set when using returnType "COMBINED_OUTPUT".
  • error - set if rclone exits with an error code.
  • returnType - one of ("COMBINED_OUTPUT", "STREAM", "STREAM_ONLY_STDOUT", "STREAM_ONLY_STDERR").

Example:

rclone rc core/command command=ls -a mydrive:/ -o max-depth=1
rclone rc core/command -a ls -a mydrive:/ -o max-depth=1

Returns:

{
    "error": false,
    "result": "<Raw command line output>"
}

OR
{
    "error": true,
    "result": "<Raw command line output>"
}

Authentication is required for this call.

core/du: Returns disk usage of a locally attached disk.

This returns the disk usage for the local directory passed in as dir.

If the directory is not passed in, it defaults to the directory pointed to by --cache-dir.

  • dir - string (optional)

Returns:

{
    "dir": "/",
    "info": {
        "Available": 361769115648,
        "Free": 361785892864,
        "Total": 982141468672
    }
}

core/gc: Runs a garbage collection.

This tells the go runtime to do a garbage collection run. It isn't necessary to call this normally, but it can be useful for debugging memory problems.

core/group-list: Returns list of stats.

This returns list of stats groups currently in memory.

Returns the following values:

{
    "groups":  an array of group names:
        [
            "group1",
            "group2",
            ...
        ]
}

core/memstats: Returns the memory statistics

This returns the memory statistics of the running program. What the values mean are explained in the go docs: https://golang.org/pkg/runtime/#MemStats

The most interesting values for most people are:

  • HeapAlloc - this is the amount of memory rclone is actually using
  • HeapSys - this is the amount of memory rclone has obtained from the OS
  • Sys - this is the total amount of memory requested from the OS
    • It is virtual memory so may include unused memory

core/obscure: Obscures a string passed in.

Pass a clear string and rclone will obscure it for the config file: - clear - string

Returns: - obscured - string

core/pid: Return PID of current process

This returns PID of current process. Useful for stopping rclone process.

core/quit: Terminates the app.

(Optional) Pass an exit code to be used for terminating the app: - exitCode - int

core/stats: Returns stats about current transfers.

This returns all available stats:

rclone rc core/stats

If group is not provided then summed up stats for all groups will be returned.

Parameters

  • group - name of the stats group (string, optional)
  • short - if true will not return the transferring and checking arrays (boolean, optional)

Returns the following values:

{
    "bytes": total transferred bytes since the start of the group,
    "checks": number of files checked,
    "deletes" : number of files deleted,
    "elapsedTime": time in floating point seconds since rclone was started,
    "errors": number of errors,
    "eta": estimated time in seconds until the group completes,
    "fatalError": boolean whether there has been at least one fatal error,
    "lastError": last error string,
    "renames" : number of files renamed,
    "listed" : number of directory entries listed,
    "retryError": boolean showing whether there has been at least one non-NoRetryError,
        "serverSideCopies": number of server side copies done,
        "serverSideCopyBytes": number bytes server side copied,
        "serverSideMoves": number of server side moves done,
        "serverSideMoveBytes": number bytes server side moved,
    "speed": average speed in bytes per second since start of the group,
    "totalBytes": total number of bytes in the group,
    "totalChecks": total number of checks in the group,
    "totalTransfers": total number of transfers in the group,
    "transferTime" : total time spent on running jobs,
    "transfers": number of transferred files,
    "transferring": an array of currently active file transfers:
        [
            {
                "bytes": total transferred bytes for this file,
                "eta": estimated time in seconds until file transfer completion
                "name": name of the file,
                "percentage": progress of the file transfer in percent,
                "speed": average speed over the whole transfer in bytes per second,
                "speedAvg": current speed in bytes per second as an exponentially weighted moving average,
                "size": size of the file in bytes
            }
        ],
    "checking": an array of names of currently active file checks
        []
}

Values for "transferring", "checking" and "lastError" are only assigned if data is available. The value for "eta" is null if an eta cannot be determined.

core/stats-delete: Delete stats group.

This deletes entire stats group.

Parameters

  • group - name of the stats group (string)

core/stats-reset: Reset stats.

This clears counters, errors and finished transfers for all stats or specific stats group if group is provided.

Parameters

  • group - name of the stats group (string)

core/transferred: Returns stats about completed transfers.

This returns stats about completed transfers:

rclone rc core/transferred

If group is not provided then completed transfers for all groups will be returned.

Note only the last 100 completed transfers are returned.

Parameters

  • group - name of the stats group (string)

Returns the following values:

{
    "transferred":  an array of completed transfers (including failed ones):
        [
            {
                "name": name of the file,
                "size": size of the file in bytes,
                "bytes": total transferred bytes for this file,
                "checked": if the transfer is only checked (skipped, deleted),
                "what": the purpose of the transfer (transferring, deleting, checking, importing, hashing, merging, listing, moving, renaming),
                "timestamp": integer representing millisecond unix epoch,
                "error": string description of the error (empty if successful),
                "jobid": id of the job that this transfer belongs to
            }
        ]
}

core/version: Shows the current version of rclone and the go runtime.

This shows the current version of go and the go runtime:

  • version - rclone version, e.g. "v1.53.0"
  • decomposed - version number as [major, minor, patch]
  • isGit - boolean - true if this was compiled from the git version
  • isBeta - boolean - true if this is a beta version
  • os - OS in use as according to Go
  • arch - cpu architecture in use according to Go
  • goVersion - version of Go runtime in use
  • linking - type of rclone executable (static or dynamic)
  • goTags - space separated build tags or "none"

debug/set-block-profile-rate: Set runtime.SetBlockProfileRate for blocking profiling.

SetBlockProfileRate controls the fraction of goroutine blocking events that are reported in the blocking profile. The profiler aims to sample an average of one blocking event per rate nanoseconds spent blocked.

To include every blocking event in the profile, pass rate = 1. To turn off profiling entirely, pass rate <= 0.

After calling this you can use this to see the blocking profile:

go tool pprof http://localhost:5572/debug/pprof/block

Parameters:

  • rate - int

debug/set-gc-percent: Call runtime/debug.SetGCPercent for setting the garbage collection target percentage.

SetGCPercent sets the garbage collection target percentage: a collection is triggered when the ratio of freshly allocated data to live data remaining after the previous collection reaches this percentage. SetGCPercent returns the previous setting. The initial setting is the value of the GOGC environment variable at startup, or 100 if the variable is not set.

This setting may be effectively reduced in order to maintain a memory limit. A negative percentage effectively disables garbage collection, unless the memory limit is reached.

See https://pkg.go.dev/runtime/debug#SetMemoryLimit for more details.

Parameters:

  • gc-percent - int

debug/set-mutex-profile-fraction: Set runtime.SetMutexProfileFraction for mutex profiling.

SetMutexProfileFraction controls the fraction of mutex contention events that are reported in the mutex profile. On average 1/rate events are reported. The previous rate is returned.

To turn off profiling entirely, pass rate 0. To just read the current rate, pass rate < 0. (For n>1 the details of sampling may change.)

Once this is set you can look use this to profile the mutex contention:

go tool pprof http://localhost:5572/debug/pprof/mutex

Parameters:

  • rate - int

Results:

  • previousRate - int

debug/set-soft-memory-limit: Call runtime/debug.SetMemoryLimit for setting a soft memory limit for the runtime.

SetMemoryLimit provides the runtime with a soft memory limit.

The runtime undertakes several processes to try to respect this memory limit, including adjustments to the frequency of garbage collections and returning memory to the underlying system more aggressively. This limit will be respected even if GOGC=off (or, if SetGCPercent(-1) is executed).

The input limit is provided as bytes, and includes all memory mapped, managed, and not released by the Go runtime. Notably, it does not account for space used by the Go binary and memory external to Go, such as memory managed by the underlying system on behalf of the process, or memory managed by non-Go code inside the same process. Examples of excluded memory sources include: OS kernel memory held on behalf of the process, memory allocated by C code, and memory mapped by syscall.Mmap (because it is not managed by the Go runtime).

A zero limit or a limit that's lower than the amount of memory used by the Go runtime may cause the garbage collector to run nearly continuously. However, the application may still make progress.

The memory limit is always respected by the Go runtime, so to effectively disable this behavior, set the limit very high. math.MaxInt64 is the canonical value for disabling the limit, but values much greater than the available memory on the underlying system work just as well.

See https://go.dev/doc/gc-guide for a detailed guide explaining the soft memory limit in more detail, as well as a variety of common use-cases and scenarios.

SetMemoryLimit returns the previously set memory limit. A negative input does not adjust the limit, and allows for retrieval of the currently set memory limit.

Parameters:

  • mem-limit - int

fscache/clear: Clear the Fs cache.

This clears the fs cache. This is where remotes created from backends are cached for a short while to make repeated rc calls more efficient.

If you change the parameters of a backend then you may want to call this to clear an existing remote out of the cache before re-creating it.

Authentication is required for this call.

fscache/entries: Returns the number of entries in the fs cache.

This returns the number of entries in the fs cache.

Returns - entries - number of items in the cache

Authentication is required for this call.

job/list: Lists the IDs of the running jobs

Parameters: None.

Results:

  • executeId - string id of rclone executing (change after restart)
  • jobids - array of integer job ids (starting at 1 on each restart)

job/status: Reads the status of the job ID

Parameters:

  • jobid - id of the job (integer).

Results:

  • finished - boolean
  • duration - time in seconds that the job ran for
  • endTime - time the job finished (e.g. "2018-10-26T18:50:20.528746884+01:00")
  • error - error from the job or empty string for no error
  • finished - boolean whether the job has finished or not
  • id - as passed in above
  • startTime - time the job started (e.g. "2018-10-26T18:50:20.528336039+01:00")
  • success - boolean - true for success false otherwise
  • output - output of the job as would have been returned if called synchronously
  • progress - output of the progress related to the underlying job

job/stop: Stop the running job

Parameters:

  • jobid - id of the job (integer).

job/stopgroup: Stop all running jobs in a group

Parameters:

  • group - name of the group (string).

mount/listmounts: Show current mount points

This shows currently mounted points, which can be used for performing an unmount.

This takes no parameters and returns

  • mountPoints: list of current mount points

Eg

rclone rc mount/listmounts

Authentication is required for this call.

mount/mount: Create a new mount point

rclone allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE.

If no mountType is provided, the priority is given as follows: 1. mount 2.cmount 3.mount2

This takes the following parameters:

  • fs - a remote path to be mounted (required)
  • mountPoint: valid path on the local machine (required)
  • mountType: one of the values (mount, cmount, mount2) specifies the mount implementation to use
  • mountOpt: a JSON object with Mount options in.
  • vfsOpt: a JSON object with VFS options in.

Example:

rclone rc mount/mount fs=mydrive: mountPoint=/home/<user>/mountPoint
rclone rc mount/mount fs=mydrive: mountPoint=/home/<user>/mountPoint mountType=mount
rclone rc mount/mount fs=TestDrive: mountPoint=/mnt/tmp vfsOpt='{"CacheMode": 2}' mountOpt='{"AllowOther": true}'

The vfsOpt are as described in options/get and can be seen in the the "vfs" section when running and the mountOpt can be seen in the "mount" section:

rclone rc options/get

Authentication is required for this call.

mount/types: Show all possible mount types

This shows all possible mount types and returns them as a list.

This takes no parameters and returns

  • mountTypes: list of mount types

The mount types are strings like "mount", "mount2", "cmount" and can be passed to mount/mount as the mountType parameter.

Eg

rclone rc mount/types

Authentication is required for this call.

mount/unmount: Unmount selected active mount

rclone allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE.

This takes the following parameters:

  • mountPoint: valid path on the local machine where the mount was created (required)

Example:

rclone rc mount/unmount mountPoint=/home/<user>/mountPoint

Authentication is required for this call.

mount/unmountall: Unmount all active mounts

rclone allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE.

This takes no parameters and returns error if unmount does not succeed.

Eg

rclone rc mount/unmountall

Authentication is required for this call.

operations/about: Return the space used on the remote

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"

The result is as returned from rclone about --json

See the about command for more information on the above.

Authentication is required for this call.

operations/check: check the source and destination are the same

Checks the files in the source and destination match. It compares sizes and hashes and logs a report of files that don't match. It doesn't alter the source or destination.

This takes the following parameters:

  • srcFs - a remote name string e.g. "drive:" for the source, "/" for local filesystem
  • dstFs - a remote name string e.g. "drive2:" for the destination, "/" for local filesystem
  • download - check by downloading rather than with hash
  • checkFileHash - treat checkFileFs:checkFileRemote as a SUM file with hashes of given type
  • checkFileFs - treat checkFileFs:checkFileRemote as a SUM file with hashes of given type
  • checkFileRemote - treat checkFileFs:checkFileRemote as a SUM file with hashes of given type
  • oneWay - check one way only, source files must exist on remote
  • combined - make a combined report of changes (default false)
  • missingOnSrc - report all files missing from the source (default true)
  • missingOnDst - report all files missing from the destination (default true)
  • match - report all matching files (default false)
  • differ - report all non-matching files (default true)
  • error - report all files with errors (hashing or reading) (default true)

If you supply the download flag, it will download the data from both remotes and check them against each other on the fly. This can be useful for remotes that don't support hashes or if you really want to check all the data.

If you supply the size-only global flag, it will only compare the sizes not the hashes as well. Use this for a quick check.

If you supply the checkFileHash option with a valid hash name, the checkFileFs:checkFileRemote must point to a text file in the SUM format. This treats the checksum file as the source and dstFs as the destination. Note that srcFs is not used and should not be supplied in this case.

Returns:

  • success - true if no error, false otherwise
  • status - textual summary of check, OK or text string
  • hashType - hash used in check, may be missing
  • combined - array of strings of combined report of changes
  • missingOnSrc - array of strings of all files missing from the source
  • missingOnDst - array of strings of all files missing from the destination
  • match - array of strings of all matching files
  • differ - array of strings of all non-matching files
  • error - array of strings of all files with errors (hashing or reading)

Authentication is required for this call.

operations/cleanup: Remove trashed files in the remote or path

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"

See the cleanup command for more information on the above.

Authentication is required for this call.

operations/copyfile: Copy a file from source remote to destination remote

This takes the following parameters:

  • srcFs - a remote name string e.g. "drive:" for the source, "/" for local filesystem
  • srcRemote - a path within that remote e.g. "file.txt" for the source
  • dstFs - a remote name string e.g. "drive2:" for the destination, "/" for local filesystem
  • dstRemote - a path within that remote e.g. "file2.txt" for the destination

Authentication is required for this call.

operations/copyurl: Copy the URL to the object

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"
  • remote - a path within that remote e.g. "dir"
  • url - string, URL to read from
  • autoFilename - boolean, set to true to retrieve destination file name from url

See the copyurl command for more information on the above.

Authentication is required for this call.

operations/delete: Remove files in the path

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"

See the delete command for more information on the above.

Authentication is required for this call.

operations/deletefile: Remove the single file pointed to

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"
  • remote - a path within that remote e.g. "dir"

See the deletefile command for more information on the above.

Authentication is required for this call.

operations/fsinfo: Return information about the remote

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"

This returns info about the remote passed in;

{
        // optional features and whether they are available or not
        "Features": {
                "About": true,
                "BucketBased": false,
                "BucketBasedRootOK": false,
                "CanHaveEmptyDirectories": true,
                "CaseInsensitive": false,
                "ChangeNotify": false,
                "CleanUp": false,
                "Command": true,
                "Copy": false,
                "DirCacheFlush": false,
                "DirMove": true,
                "Disconnect": false,
                "DuplicateFiles": false,
                "GetTier": false,
                "IsLocal": true,
                "ListR": false,
                "MergeDirs": false,
                "MetadataInfo": true,
                "Move": true,
                "OpenWriterAt": true,
                "PublicLink": false,
                "Purge": true,
                "PutStream": true,
                "PutUnchecked": false,
                "ReadMetadata": true,
                "ReadMimeType": false,
                "ServerSideAcrossConfigs": false,
                "SetTier": false,
                "SetWrapper": false,
                "Shutdown": false,
                "SlowHash": true,
                "SlowModTime": false,
                "UnWrap": false,
                "UserInfo": false,
                "UserMetadata": true,
                "WrapFs": false,
                "WriteMetadata": true,
                "WriteMimeType": false
        },
        // Names of hashes available
        "Hashes": [
                "md5",
                "sha1",
                "whirlpool",
                "crc32",
                "sha256",
                "dropbox",
                "mailru",
                "quickxor"
        ],
        "Name": "local",        // Name as created
        "Precision": 1,         // Precision of timestamps in ns
        "Root": "/",            // Path as created
        "String": "Local file system at /", // how the remote will appear in logs
        // Information about the system metadata for this backend
        "MetadataInfo": {
                "System": {
                        "atime": {
                                "Help": "Time of last access",
                                "Type": "RFC 3339",
                                "Example": "2006-01-02T15:04:05.999999999Z07:00"
                        },
                        "btime": {
                                "Help": "Time of file birth (creation)",
                                "Type": "RFC 3339",
                                "Example": "2006-01-02T15:04:05.999999999Z07:00"
                        },
                        "gid": {
                                "Help": "Group ID of owner",
                                "Type": "decimal number",
                                "Example": "500"
                        },
                        "mode": {
                                "Help": "File type and mode",
                                "Type": "octal, unix style",
                                "Example": "0100664"
                        },
                        "mtime": {
                                "Help": "Time of last modification",
                                "Type": "RFC 3339",
                                "Example": "2006-01-02T15:04:05.999999999Z07:00"
                        },
                        "rdev": {
                                "Help": "Device ID (if special file)",
                                "Type": "hexadecimal",
                                "Example": "1abc"
                        },
                        "uid": {
                                "Help": "User ID of owner",
                                "Type": "decimal number",
                                "Example": "500"
                        }
                },
                "Help": "Textual help string\n"
        }
}

This command does not have a command line equivalent so use this instead:

rclone rc --loopback operations/fsinfo fs=remote:

operations/hashsum: Produces a hashsum file for all the objects in the path.

Produces a hash file for all the objects in the path using the hash named. The output is in the same format as the standard md5sum/sha1sum tool.

This takes the following parameters:

  • fs - a remote name string e.g. "drive:" for the source, "/" for local filesystem
    • this can point to a file and just that file will be returned in the listing.
  • hashType - type of hash to be used
  • download - check by downloading rather than with hash (boolean)
  • base64 - output the hashes in base64 rather than hex (boolean)

If you supply the download flag, it will download the data from the remote and create the hash on the fly. This can be useful for remotes that don't support the given hash or if you really want to check all the data.

Note that if you wish to supply a checkfile to check hashes against the current files then you should use operations/check instead of operations/hashsum.

Returns:

  • hashsum - array of strings of the hashes
  • hashType - type of hash used

Example:

$ rclone rc --loopback operations/hashsum fs=bin hashType=MD5 download=true base64=true
{
    "hashType": "md5",
    "hashsum": [
        "WTSVLpuiXyJO_kGzJerRLg==  backend-versions.sh",
        "v1b_OlWCJO9LtNq3EIKkNQ==  bisect-go-rclone.sh",
        "VHbmHzHh4taXzgag8BAIKQ==  bisect-rclone.sh",
    ]
}

See the hashsum command for more information on the above.

Authentication is required for this call.

operations/list: List the given remote and path in JSON format

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"
  • remote - a path within that remote e.g. "dir"
  • opt - a dictionary of options to control the listing (optional)
    • recurse - If set recurse directories
    • noModTime - If set return modification time
    • showEncrypted - If set show decrypted names
    • showOrigIDs - If set show the IDs for each item if known
    • showHash - If set return a dictionary of hashes
    • noMimeType - If set don't show mime types
    • dirsOnly - If set only show directories
    • filesOnly - If set only show files
    • metadata - If set return metadata of objects also
    • hashTypes - array of strings of hash types to show if showHash set

Returns:

  • list
    • This is an array of objects as described in the lsjson command

See the lsjson command for more information on the above and examples.

Authentication is required for this call.

operations/mkdir: Make a destination directory or container

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"
  • remote - a path within that remote e.g. "dir"

See the mkdir command for more information on the above.

Authentication is required for this call.

operations/movefile: Move a file from source remote to destination remote

This takes the following parameters:

  • srcFs - a remote name string e.g. "drive:" for the source, "/" for local filesystem
  • srcRemote - a path within that remote e.g. "file.txt" for the source
  • dstFs - a remote name string e.g. "drive2:" for the destination, "/" for local filesystem
  • dstRemote - a path within that remote e.g. "file2.txt" for the destination

Authentication is required for this call.

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"
  • remote - a path within that remote e.g. "dir"
  • unlink - boolean - if set removes the link rather than adding it (optional)
  • expire - string - the expiry time of the link e.g. "1d" (optional)

Returns:

  • url - URL of the resource

See the link command for more information on the above.

Authentication is required for this call.

operations/purge: Remove a directory or container and all of its contents

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"
  • remote - a path within that remote e.g. "dir"

See the purge command for more information on the above.

Authentication is required for this call.

operations/rmdir: Remove an empty directory or container

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"
  • remote - a path within that remote e.g. "dir"

See the rmdir command for more information on the above.

Authentication is required for this call.

operations/rmdirs: Remove all the empty directories in the path

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"
  • remote - a path within that remote e.g. "dir"
  • leaveRoot - boolean, set to true not to delete the root

See the rmdirs command for more information on the above.

Authentication is required for this call.

operations/settier: Changes storage tier or class on all files in the path

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"

See the settier command for more information on the above.

Authentication is required for this call.

operations/settierfile: Changes storage tier or class on the single file pointed to

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"
  • remote - a path within that remote e.g. "dir"

See the settierfile command for more information on the above.

Authentication is required for this call.

operations/size: Count the number of bytes and files in remote

This takes the following parameters:

  • fs - a remote name string e.g. "drive:path/to/dir"

Returns:

  • count - number of files
  • bytes - number of bytes in those files

See the size command for more information on the above.

Authentication is required for this call.

operations/stat: Give information about the supplied file or directory

This takes the following parameters

  • fs - a remote name string eg "drive:"
  • remote - a path within that remote eg "dir"
  • opt - a dictionary of options to control the listing (optional)
    • see operations/list for the options

The result is

  • item - an object as described in the lsjson command. Will be null if not found.

Note that if you are only interested in files then it is much more efficient to set the filesOnly flag in the options.

See the lsjson command for more information on the above and examples.

Authentication is required for this call.

operations/uploadfile: Upload file using multiform/form-data

This takes the following parameters:

  • fs - a remote name string e.g. "drive:"
  • remote - a path within that remote e.g. "dir"
  • each part in body represents a file to be uploaded

See the uploadfile command for more information on the above.

Authentication is required for this call.

options/blocks: List all the option blocks

Returns: - options - a list of the options block names

options/get: Get all the global options

Returns an object where keys are option block names and values are an object with the current option values in.

Parameters:

  • blocks: optional string of comma separated blocks to include
    • all are included if this is missing or ""

Note that these are the global options which are unaffected by use of the _config and _filter parameters. If you wish to read the parameters set in _config or _filter use options/local.

This shows the internal names of the option within rclone which should map to the external options very easily with a few exceptions.

options/info: Get info about all the global options

Returns an object where keys are option block names and values are an array of objects with info about each options.

Parameters:

  • blocks: optional string of comma separated blocks to include
    • all are included if this is missing or ""

These objects are in the same format as returned by "config/providers". They are described in the option blocks section.

options/local: Get the currently active config for this call

Returns an object with the keys "config" and "filter". The "config" key contains the local config and the "filter" key contains the local filters.

Note that these are the local options specific to this rc call. If _config was not supplied then they will be the global options. Likewise with "_filter".

This call is mostly useful for seeing if _config and _filter passing is working.

This shows the internal names of the option within rclone which should map to the external options very easily with a few exceptions.

options/set: Set an option

Parameters:

  • option block name containing an object with
    • key: value

Repeated as often as required.

Only supply the options you wish to change. If an option is unknown it will be silently ignored. Not all options will have an effect when changed like this.

For example:

This sets DEBUG level logs (-vv) (these can be set by number or string)

rclone rc options/set --json '{"main": {"LogLevel": "DEBUG"}}'
rclone rc options/set --json '{"main": {"LogLevel": 8}}'

And this sets INFO level logs (-v)

rclone rc options/set --json '{"main": {"LogLevel": "INFO"}}'

And this sets NOTICE level logs (normal without -v)

rclone rc options/set --json '{"main": {"LogLevel": "NOTICE"}}'

pluginsctl/addPlugin: Add a plugin using url

Used for adding a plugin to the webgui.

This takes the following parameters:

  • url - http url of the github repo where the plugin is hosted (http://github.com/rclone/rclone-webui-react).

Example:

rclone rc pluginsctl/addPlugin

Authentication is required for this call.

pluginsctl/getPluginsForType: Get plugins with type criteria

This shows all possible plugins by a mime type.

This takes the following parameters:

  • type - supported mime type by a loaded plugin e.g. (video/mp4, audio/mp3).
  • pluginType - filter plugins based on their type e.g. (DASHBOARD, FILE_HANDLER, TERMINAL).

Returns:

  • loadedPlugins - list of current production plugins.
  • testPlugins - list of temporarily loaded development plugins, usually running on a different server.

Example:

rclone rc pluginsctl/getPluginsForType type=video/mp4

Authentication is required for this call.

pluginsctl/listPlugins: Get the list of currently loaded plugins

This allows you to get the currently enabled plugins and their details.

This takes no parameters and returns:

  • loadedPlugins - list of current production plugins.
  • testPlugins - list of temporarily loaded development plugins, usually running on a different server.

E.g.

rclone rc pluginsctl/listPlugins

Authentication is required for this call.

pluginsctl/listTestPlugins: Show currently loaded test plugins

Allows listing of test plugins with the rclone.test set to true in package.json of the plugin.

This takes no parameters and returns:

  • loadedTestPlugins - list of currently available test plugins.

E.g.

rclone rc pluginsctl/listTestPlugins

Authentication is required for this call.

pluginsctl/removePlugin: Remove a loaded plugin

This allows you to remove a plugin using it's name.

This takes parameters:

  • name - name of the plugin in the format author/plugin_name.

E.g.

rclone rc pluginsctl/removePlugin name=rclone/video-plugin

Authentication is required for this call.

pluginsctl/removeTestPlugin: Remove a test plugin

This allows you to remove a plugin using it's name.

This takes the following parameters:

  • name - name of the plugin in the format author/plugin_name.

Example:

rclone rc pluginsctl/removeTestPlugin name=rclone/rclone-webui-react

Authentication is required for this call.

rc/error: This returns an error

This returns an error with the input as part of its error string. Useful for testing error handling.

rc/list: List all the registered remote control commands

This lists all the registered remote control commands as a JSON map in the commands response.

rc/noop: Echo the input to the output parameters

This echoes the input parameters to the output parameters for testing purposes. It can be used to check that rclone is still alive and to check that parameter passing is working properly.

rc/noopauth: Echo the input to the output parameters requiring auth

This echoes the input parameters to the output parameters for testing purposes. It can be used to check that rclone is still alive and to check that parameter passing is working properly.

Authentication is required for this call.

serve/list: Show running servers

Show running servers with IDs.

This takes no parameters and returns

  • list: list of running serve commands

Each list element will have

  • id: ID of the server
  • addr: address the server is running on
  • params: parameters used to start the server

Eg

rclone rc serve/list

Returns

{
    "list": [
        {
            "addr": "[::]:4321",
            "id": "nfs-ffc2a4e5",
            "params": {
                "fs": "remote:",
                "opt": {
                    "ListenAddr": ":4321"
                },
                "type": "nfs",
                "vfsOpt": {
                    "CacheMode": "full"
                }
            }
        }
    ]
}

Authentication is required for this call.

serve/start: Create a new server

Create a new server with the specified parameters.

This takes the following parameters:

  • type - type of server: http, webdav, ftp, sftp, nfs, etc.
  • fs - remote storage path to serve
  • addr - the ip:port to run the server on, eg ":1234" or "localhost:1234"

Other parameters are as described in the documentation for the relevant rclone serve command line options. To translate a command line option to an rc parameter, remove the leading -- and replace - with _, so --vfs-cache-mode becomes vfs_cache_mode. Note that global parameters must be set with _config and _filter as described above.

Examples:

rclone rc serve/start type=nfs fs=remote: addr=:4321 vfs_cache_mode=full
rclone rc serve/start --json '{"type":"nfs","fs":"remote:","addr":":1234","vfs_cache_mode":"full"}'

This will give the reply

{
    "addr": "[::]:4321", // Address the server was started on
    "id": "nfs-ecfc6852" // Unique identifier for the server instance
}

Or an error if it failed to start.

Stop the server with serve/stop and list the running servers with serve/list.

Authentication is required for this call.

serve/stop: Unserve selected active serve

Stops a running serve instance by ID.

This takes the following parameters:

  • id: as returned by serve/start

This will give an empty response if successful or an error if not.

Example:

rclone rc serve/stop id=12345

Authentication is required for this call.

serve/stopall: Stop all active servers

Stop all active servers.

This will stop all active servers.

rclone rc serve/stopall

Authentication is required for this call.

serve/types: Show all possible serve types

This shows all possible serve types and returns them as a list.

This takes no parameters and returns

  • types: list of serve types, eg "nfs", "sftp", etc

The serve types are strings like "serve", "serve2", "cserve" and can be passed to serve/start as the serveType parameter.

Eg

rclone rc serve/types

Returns

{
    "types": [
        "http",
        "sftp",
        "nfs"
    ]
}

Authentication is required for this call.

sync/bisync: Perform bidirectional synchronization between two paths.

This takes the following parameters

  • path1 - a remote directory string e.g. drive:path1
  • path2 - a remote directory string e.g. drive:path2
  • dryRun - dry-run mode
  • resync - performs the resync run
  • checkAccess - abort if RCLONE_TEST files are not found on both filesystems
  • checkFilename - file name for checkAccess (default: RCLONE_TEST)
  • maxDelete - abort sync if percentage of deleted files is above this threshold (default: 50)
  • force - Bypass maxDelete safety check and run the sync
  • checkSync - true by default, false disables comparison of final listings, only will skip sync, only compare listings from the last run
  • createEmptySrcDirs - Sync creation and deletion of empty directories. (Not compatible with --remove-empty-dirs)
  • removeEmptyDirs - remove empty directories at the final cleanup step
  • filtersFile - read filtering patterns from a file
  • ignoreListingChecksum - Do not use checksums for listings
  • resilient - Allow future runs to retry after certain less-serious errors, instead of requiring resync.
  • workdir - server directory for history files (default: ~/.cache/rclone/bisync)
  • backupdir1 - --backup-dir for Path1. Must be a non-overlapping path on the same remote.
  • backupdir2 - --backup-dir for Path2. Must be a non-overlapping path on the same remote.
  • noCleanup - retain working files

See bisync command help and full bisync description for more information.

Authentication is required for this call.

sync/copy: copy a directory from source remote to destination remote

This takes the following parameters:

  • srcFs - a remote name string e.g. "drive:src" for the source
  • dstFs - a remote name string e.g. "drive:dst" for the destination
  • createEmptySrcDirs - create empty src directories on destination if set

See the copy command for more information on the above.

Authentication is required for this call.

sync/move: move a directory from source remote to destination remote

This takes the following parameters:

  • srcFs - a remote name string e.g. "drive:src" for the source
  • dstFs - a remote name string e.g. "drive:dst" for the destination
  • createEmptySrcDirs - create empty src directories on destination if set
  • deleteEmptySrcDirs - delete empty src directories if set

See the move command for more information on the above.

Authentication is required for this call.

sync/sync: sync a directory from source remote to destination remote

This takes the following parameters:

  • srcFs - a remote name string e.g. "drive:src" for the source
  • dstFs - a remote name string e.g. "drive:dst" for the destination
  • createEmptySrcDirs - create empty src directories on destination if set

See the sync command for more information on the above.

Authentication is required for this call.

vfs/forget: Forget files or directories in the directory cache.

This forgets the paths in the directory cache causing them to be re-read from the remote when needed.

If no paths are passed in then it will forget all the paths in the directory cache.

rclone rc vfs/forget

Otherwise pass files or dirs in as file=path or dir=path. Any parameter key starting with file will forget that file and any starting with dir will forget that dir, e.g.

rclone rc vfs/forget file=hello file2=goodbye dir=home/junk

This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied.

vfs/list: List active VFSes.

This lists the active VFSes.

It returns a list under the key "vfses" where the values are the VFS names that could be passed to the other VFS commands in the "fs" parameter.

vfs/poll-interval: Get the status or update the value of the poll-interval option.

Without any parameter given this returns the current status of the poll-interval setting.

When the interval=duration parameter is set, the poll-interval value is updated and the polling function is notified. Setting interval=0 disables poll-interval.

rclone rc vfs/poll-interval interval=5m

The timeout=duration parameter can be used to specify a time to wait for the current poll function to apply the new value. If timeout is less or equal 0, which is the default, wait indefinitely.

The new poll-interval value will only be active when the timeout is not reached.

If poll-interval is updated or disabled temporarily, some changes might not get picked up by the polling function, depending on the used remote.

This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied.

vfs/queue: Queue info for a VFS.

This returns info about the upload queue for the selected VFS.

This is only useful if --vfs-cache-mode > off. If you call it when the --vfs-cache-mode is off, it will return an empty result.

{
    "queued": // an array of files queued for upload
    [
        {
            "name":      "file",   // string: name (full path) of the file,
            "id":        123,      // integer: id of this item in the queue,
            "size":      79,       // integer: size of the file in bytes
            "expiry":    1.5       // float: time until file is eligible for transfer, lowest goes first
            "tries":     1,        // integer: number of times we have tried to upload
            "delay":     5.0,      // float: seconds between upload attempts
            "uploading": false,    // boolean: true if item is being uploaded
        },
   ],
}

The expiry time is the time until the file is eligible for being uploaded in floating point seconds. This may go negative. As rclone only transfers --transfers files at once, only the lowest --transfers expiry times will have uploading as true. So there may be files with negative expiry times for which uploading is false.

This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied.

vfs/queue-set-expiry: Set the expiry time for an item queued for upload.

Use this to adjust the expiry time for an item in the upload queue. You will need to read the id of the item using vfs/queue before using this call.

You can then set expiry to a floating point number of seconds from now when the item is eligible for upload. If you want the item to be uploaded as soon as possible then set it to a large negative number (eg -1000000000). If you want the upload of the item to be delayed for a long time then set it to a large positive number.

Setting the expiry of an item which has already has started uploading will have no effect - the item will carry on being uploaded.

This will return an error if called with --vfs-cache-mode off or if the id passed is not found.

This takes the following parameters

  • fs - select the VFS in use (optional)
  • id - a numeric ID as returned from vfs/queue
  • expiry - a new expiry time as floating point seconds
  • relative - if set, expiry is to be treated as relative to the current expiry (optional, boolean)

This returns an empty result on success, or an error.

This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied.

vfs/refresh: Refresh the directory cache.

This reads the directories for the specified paths and freshens the directory cache.

If no paths are passed in then it will refresh the root directory.

rclone rc vfs/refresh

Otherwise pass directories in as dir=path. Any parameter key starting with dir will refresh that directory, e.g.

rclone rc vfs/refresh dir=home/junk dir2=data/misc

If the parameter recursive=true is given the whole directory tree will get refreshed. This refresh will use --fast-list if enabled.

This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied.

vfs/stats: Stats for a VFS.

This returns stats for the selected VFS.

{
    // Status of the disk cache - only present if --vfs-cache-mode > off
    "diskCache": {
        "bytesUsed": 0,
        "erroredFiles": 0,
        "files": 0,
        "hashType": 1,
        "outOfSpace": false,
        "path": "/home/user/.cache/rclone/vfs/local/mnt/a",
        "pathMeta": "/home/user/.cache/rclone/vfsMeta/local/mnt/a",
        "uploadsInProgress": 0,
        "uploadsQueued": 0
    },
    "fs": "/mnt/a",
    "inUse": 1,
    // Status of the in memory metadata cache
    "metadataCache": {
        "dirs": 1,
        "files": 0
    },
    // Options as returned by options/get
    "opt": {
        "CacheMaxAge": 3600000000000,
        // ...
        "WriteWait": 1000000000
    }
}

This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied.

Accessing the remote control via HTTP

Rclone implements a simple HTTP based protocol.

Each endpoint takes an JSON object and returns a JSON object or an error. The JSON objects are essentially a map of string names to values.

All calls must made using POST.

The input objects can be supplied using URL parameters, POST parameters or by supplying "Content-Type: application/json" and a JSON blob in the body. There are examples of these below using curl.

The response will be a JSON blob in the body of the response. This is formatted to be reasonably human-readable.

Error returns

If an error occurs then there will be an HTTP error status (e.g. 500) and the body of the response will contain a JSON encoded error object, e.g.

{
    "error": "Expecting string value for key \"remote\" (was float64)",
    "input": {
        "fs": "/tmp",
        "remote": 3
    },
    "status": 400,
    "path": "operations/rmdir"
}

The keys in the error response are:

  • error - error string
  • input - the input parameters to the call
  • status - the HTTP status code
  • path - the path of the call

CORS

The sever implements basic CORS support and allows all origins for that. The response to a preflight OPTIONS request will echo the requested "Access-Control-Request-Headers" back.

Using POST with URL parameters only

curl -X POST 'http://localhost:5572/rc/noop?potato=1&sausage=2'

Response

{
    "potato": "1",
    "sausage": "2"
}

Here is what an error response looks like:

curl -X POST 'http://localhost:5572/rc/error?potato=1&sausage=2'
{
    "error": "arbitrary error on input map[potato:1 sausage:2]",
    "input": {
        "potato": "1",
        "sausage": "2"
    }
}

Note that curl doesn't return errors to the shell unless you use the -f option

$ curl -f -X POST 'http://localhost:5572/rc/error?potato=1&sausage=2'
curl: (22) The requested URL returned error: 400 Bad Request
$ echo $?
22

Using POST with a form

curl --data "potato=1" --data "sausage=2" http://localhost:5572/rc/noop

Response

{
    "potato": "1",
    "sausage": "2"
}

Note that you can combine these with URL parameters too with the POST parameters taking precedence.

curl --data "potato=1" --data "sausage=2" "http://localhost:5572/rc/noop?rutabaga=3&sausage=4"

Response

{
    "potato": "1",
    "rutabaga": "3",
    "sausage": "4"
}

Using POST with a JSON blob

curl -H "Content-Type: application/json" -X POST -d '{"potato":2,"sausage":1}' http://localhost:5572/rc/noop

response

{
    "password": "xyz",
    "username": "xyz"
}

This can be combined with URL parameters too if required. The JSON blob takes precedence.

curl -H "Content-Type: application/json" -X POST -d '{"potato":2,"sausage":1}' 'http://localhost:5572/rc/noop?rutabaga=3&potato=4'
{
    "potato": 2,
    "rutabaga": "3",
    "sausage": 1
}

Debugging rclone with pprof

If you use the --rc flag this will also enable the use of the go profiling tools on the same port.

To use these, first install go.

Debugging memory use

To profile rclone's memory use you can run:

go tool pprof -web http://localhost:5572/debug/pprof/heap

This should open a page in your browser showing what is using what memory.

You can also use the -text flag to produce a textual summary

$ go tool pprof -text http://localhost:5572/debug/pprof/heap
Showing nodes accounting for 1537.03kB, 100% of 1537.03kB total
      flat  flat%   sum%        cum   cum%
 1024.03kB 66.62% 66.62%  1024.03kB 66.62%  github.com/rclone/rclone/vendor/golang.org/x/net/http2/hpack.addDecoderNode
     513kB 33.38%   100%      513kB 33.38%  net/http.newBufioWriterSize
         0     0%   100%  1024.03kB 66.62%  github.com/rclone/rclone/cmd/all.init
         0     0%   100%  1024.03kB 66.62%  github.com/rclone/rclone/cmd/serve.init
         0     0%   100%  1024.03kB 66.62%  github.com/rclone/rclone/cmd/serve/restic.init
         0     0%   100%  1024.03kB 66.62%  github.com/rclone/rclone/vendor/golang.org/x/net/http2.init
         0     0%   100%  1024.03kB 66.62%  github.com/rclone/rclone/vendor/golang.org/x/net/http2/hpack.init
         0     0%   100%  1024.03kB 66.62%  github.com/rclone/rclone/vendor/golang.org/x/net/http2/hpack.init.0
         0     0%   100%  1024.03kB 66.62%  main.init
         0     0%   100%      513kB 33.38%  net/http.(*conn).readRequest
         0     0%   100%      513kB 33.38%  net/http.(*conn).serve
         0     0%   100%  1024.03kB 66.62%  runtime.main

Debugging go routine leaks

Memory leaks are most often caused by go routine leaks keeping memory alive which should have been garbage collected.

See all active go routines using

curl http://localhost:5572/debug/pprof/goroutine?debug=1

Or go to http://localhost:5572/debug/pprof/goroutine?debug=1 in your browser.

Other profiles to look at

You can see a summary of profiles available at http://localhost:5572/debug/pprof/

Here is how to use some of them:

  • Memory: go tool pprof http://localhost:5572/debug/pprof/heap
  • Go routines: curl http://localhost:5572/debug/pprof/goroutine?debug=1
  • 30-second CPU profile: go tool pprof http://localhost:5572/debug/pprof/profile
  • 5-second execution trace: wget http://localhost:5572/debug/pprof/trace?seconds=5
  • Goroutine blocking profile
    • Enable first with: rclone rc debug/set-block-profile-rate rate=1 (docs)
    • go tool pprof http://localhost:5572/debug/pprof/block
  • Contended mutexes:
    • Enable first with: rclone rc debug/set-mutex-profile-fraction rate=1 (docs)
    • go tool pprof http://localhost:5572/debug/pprof/mutex

See the net/http/pprof docs for more info on how to use the profiling and for a general overview see the Go team's blog post on profiling go programs.

The profiling hook is zero overhead unless it is used.

Overview of cloud storage systems

Each cloud storage system is slightly different. Rclone attempts to provide a unified interface to them, but some underlying differences show through.

Features

Here is an overview of the major features of each cloud storage system.

Name Hash ModTime Case Insensitive Duplicate Files MIME Type Metadata
1Fichier Whirlpool - No Yes R -
Akamai Netstorage MD5, SHA256 R/W No No R -
Amazon S3 (or S3 compatible) MD5 R/W No No R/W RWU
Backblaze B2 SHA1 R/W No No R/W -
Box SHA1 R/W Yes No - -
Citrix ShareFile MD5 R/W Yes No - -
Cloudinary MD5 R No Yes - -
Dropbox DBHASH ¹ R Yes No - -
Enterprise File Fabric - R/W Yes No R/W -
FileLu Cloud Storage MD5 R/W No Yes R -
Files.com MD5, CRC32 DR/W Yes No R -
FTP - R/W ¹⁰ No No - -
Gofile MD5 DR/W No Yes R -
Google Cloud Storage MD5 R/W No No R/W -
Google Drive MD5, SHA1, SHA256 DR/W No Yes R/W DRWU
Google Photos - - No Yes R -
HDFS - R/W No No - -
HiDrive HiDrive ¹² R/W No No - -
HTTP - R No No R -
iCloud Drive - R No No - -
Internet Archive MD5, SHA1, CRC32 R/W ¹¹ No No - RWU
Jottacloud MD5 R/W Yes No R RW
Koofr MD5 - Yes No - -
Linkbox - R No No - -
Mail.ru Cloud Mailru ⁶ R/W Yes No - -
Mega - - No Yes - -
Memory MD5 R/W No No - -
Microsoft Azure Blob Storage MD5 R/W No No R/W -
Microsoft Azure Files Storage MD5 R/W Yes No R/W -
Microsoft OneDrive QuickXorHash ⁵ DR/W Yes No R DRW
OpenDrive MD5 R/W Yes Partial ⁸ - -
OpenStack Swift MD5 R/W No No R/W -
Oracle Object Storage MD5 R/W No No R/W RU
pCloud MD5, SHA1 ⁷ R/W No No W -
PikPak MD5 R No No R -
Pixeldrain SHA256 R/W No No R RW
premiumize.me - - Yes No R -
put.io CRC-32 R/W No Yes R -
Proton Drive SHA1 R/W No No R -
QingStor MD5 - ⁹ No No R/W -
Quatrix by Maytech - R/W No No - -
Seafile - - No No - -
SFTP MD5, SHA1 ² DR/W Depends No - -
Sia - - No No - -
SMB - R/W Yes No - -
SugarSync - - No No - -
Storj - R No No - -
Uloz.to MD5, SHA256 ¹³ - No Yes - -
Uptobox - - No Yes - -
WebDAV MD5, SHA1 ³ R ⁴ Depends No - -
Yandex Disk MD5 R/W No No R -
Zoho WorkDrive - - No No - -
The local filesystem All DR/W Depends No - DRWU

¹ Dropbox supports its own custom hash. This is an SHA256 sum of all the 4 MiB block SHA256s.

² SFTP supports checksums if the same login has shell access and md5sum or sha1sum as well as echo are in the remote's PATH.

³ WebDAV supports hashes when used with Fastmail Files, Owncloud and Nextcloud only.

⁴ WebDAV supports modtimes when used with Fastmail Files, Owncloud and Nextcloud only.

⁵ QuickXorHash is Microsoft's own hash.

⁶ Mail.ru uses its own modified SHA1 hash

⁷ pCloud only supports SHA1 (not MD5) in its EU region

⁸ Opendrive does not support creation of duplicate files using their web client interface or other stock clients, but the underlying storage platform has been determined to allow duplicate files, and it is possible to create them with rclone. It may be that this is a mistake or an unsupported feature.

⁹ QingStor does not support SetModTime for objects bigger than 5 GiB.

¹⁰ FTP supports modtimes for the major FTP servers, and also others if they advertised required protocol extensions. See this for more details.

¹¹ Internet Archive requires option wait_archive to be set to a non-zero value for full modtime support.

¹² HiDrive supports its own custom hash. It combines SHA1 sums for each 4 KiB block hierarchically to a single top-level sum.

¹³ Uloz.to provides server-calculated MD5 hash upon file upload. MD5 and SHA256 hashes are client-calculated and stored as metadata fields.

Hash

The cloud storage system supports various hash types of the objects. The hashes are used when transferring data as an integrity check and can be specifically used with the --checksum flag in syncs and in the check command.

To use the verify checksums when transferring between cloud storage systems they must support a common hash type.

ModTime

Almost all cloud storage systems store some sort of timestamp on objects, but several of them not something that is appropriate to use for syncing. E.g. some backends will only write a timestamp that represents the time of the upload. To be relevant for syncing it should be able to store the modification time of the source object. If this is not the case, rclone will only check the file size by default, though can be configured to check the file hash (with the --checksum flag). Ideally it should also be possible to change the timestamp of an existing file without having to re-upload it.

Key Explanation
- ModTimes not supported - times likely the upload time
R ModTimes supported on files but can't be changed without re-upload
R/W Read and Write ModTimes fully supported on files
DR ModTimes supported on files and directories but can't be changed without re-upload
DR/W Read and Write ModTimes fully supported on files and directories

Storage systems with a - in the ModTime column, means the modification read on objects is not the modification time of the file when uploaded. It is most likely the time the file was uploaded, or possibly something else (like the time the picture was taken in Google Photos).

Storage systems with a R (for read-only) in the ModTime column, means the it keeps modification times on objects, and updates them when uploading objects, but it does not support changing only the modification time (SetModTime operation) without re-uploading, possibly not even without deleting existing first. Some operations in rclone, such as copy and sync commands, will automatically check for SetModTime support and re-upload if necessary to keep the modification times in sync. Other commands will not work without SetModTime support, e.g. touch command on an existing file will fail, and changes to modification time only on a files in a mount will be silently ignored.

Storage systems with R/W (for read/write) in the ModTime column, means they do also support modtime-only operations.

Storage systems with D in the ModTime column means that the following symbols apply to directories as well as files.

Case Insensitive

If a cloud storage systems is case sensitive then it is possible to have two files which differ only in case, e.g. file.txt and FILE.txt. If a cloud storage system is case insensitive then that isn't possible.

This can cause problems when syncing between a case insensitive system and a case sensitive system. The symptom of this is that no matter how many times you run the sync it never completes fully.

The local filesystem and SFTP may or may not be case sensitive depending on OS.

  • Windows - usually case insensitive, though case is preserved
  • OSX - usually case insensitive, though it is possible to format case sensitive
  • Linux - usually case sensitive, but there are case insensitive file systems (e.g. FAT formatted USB keys)

Most of the time this doesn't cause any problems as people tend to avoid files whose name differs only by case even on case sensitive systems.

Duplicate files

If a cloud storage system allows duplicate files then it can have two objects with the same name.

This confuses rclone greatly when syncing - use the rclone dedupe command to rename or remove duplicates.

Restricted filenames

Some cloud storage systems might have restrictions on the characters that are usable in file or directory names. When rclone detects such a name during a file upload, it will transparently replace the restricted characters with similar looking Unicode characters. To handle the different sets of restricted characters for different backends, rclone uses something it calls encoding.

This process is designed to avoid ambiguous file names as much as possible and allow to move files between many cloud storage systems transparently.

The name shown by rclone to the user or during log output will only contain a minimal set of replaced characters to ensure correct formatting and not necessarily the actual name used on the cloud storage.

This transformation is reversed when downloading a file or parsing rclone arguments. For example, when uploading a file named my file?.txt to Onedrive, it will be displayed as my file?.txt on the console, but stored as my file？.txt to Onedrive (the ? gets replaced by the similar looking ？ character, the so-called "fullwidth question mark"). The reverse transformation allows to read a file unusual/name.txt from Google Drive, by passing the name unusual／name.txt on the command line (the / needs to be replaced by the similar looking ／ character).

Caveats

The filename encoding system works well in most cases, at least where file names are written in English or similar languages. You might not even notice it: It just works. In some cases it may lead to issues, though. E.g. when file names are written in Chinese, or Japanese, where it is always the Unicode fullwidth variants of the punctuation marks that are used.

On Windows, the characters :, * and ? are examples of restricted characters. If these are used in filenames on a remote that supports it, Rclone will transparently convert them to their fullwidth Unicode variants ＊, ？ and ： when downloading to Windows, and back again when uploading. This way files with names that are not allowed on Windows can still be stored.

However, if you have files on your Windows system originally with these same Unicode characters in their names, they will be included in the same conversion process. E.g. if you create a file in your Windows filesystem with name Test：1.jpg, where ： is the Unicode fullwidth colon symbol, and use rclone to upload it to Google Drive, which supports regular : (halfwidth question mark), rclone will replace the fullwidth : with the halfwidth : and store the file as Test:1.jpg in Google Drive. Since both Windows and Google Drive allows the name Test：1.jpg, it would probably be better if rclone just kept the name as is in this case.

With the opposite situation; if you have a file named Test:1.jpg, in your Google Drive, e.g. uploaded from a Linux system where : is valid in file names. Then later use rclone to copy this file to your Windows computer you will notice that on your local disk it gets renamed to Test：1.jpg. The original filename is not legal on Windows, due to the :, and rclone therefore renames it to make the copy possible. That is all good. However, this can also lead to an issue: If you already had a different file named Test：1.jpg on Windows, and then use rclone to copy either way. Rclone will then treat the file originally named Test:1.jpg on Google Drive and the file originally named Test：1.jpg on Windows as the same file, and replace the contents from one with the other.

Its virtually impossible to handle all cases like these correctly in all situations, but by customizing the encoding option, changing the set of characters that rclone should convert, you should be able to create a configuration that works well for your specific situation. See also the example below.

(Windows was used as an example of a file system with many restricted characters, and Google drive a storage system with few.)

Default restricted characters

The table below shows the characters that are replaced by default.

When a replacement character is found in a filename, this character will be escaped with the ‛ character to avoid ambiguous file names. (e.g. a file named ␀.txt would shown as ‛␀.txt)

Each cloud storage backend can use a different set of characters, which will be specified in the documentation for each backend.

Character Value Replacement
NUL 0x00 ␀
SOH 0x01 ␁
STX 0x02 ␂
ETX 0x03 ␃
EOT 0x04 ␄
ENQ 0x05 ␅
ACK 0x06 ␆
BEL 0x07 ␇
BS 0x08 ␈
HT 0x09 ␉
LF 0x0A ␊
VT 0x0B ␋
FF 0x0C ␌
CR 0x0D ␍
SO 0x0E ␎
SI 0x0F ␏
DLE 0x10 ␐
DC1 0x11 ␑
DC2 0x12 ␒
DC3 0x13 ␓
DC4 0x14 ␔
NAK 0x15 ␕
SYN 0x16 ␖
ETB 0x17 ␗
CAN 0x18 ␘
EM 0x19 ␙
SUB 0x1A ␚
ESC 0x1B ␛
FS 0x1C ␜
GS 0x1D ␝
RS 0x1E ␞
US 0x1F ␟
/ 0x2F ／
DEL 0x7F ␡

The default encoding will also encode these file names as they are problematic with many cloud storage systems.

File name Replacement
. ．
.. ．．

Invalid UTF-8 bytes

Some backends only support a sequence of well formed UTF-8 bytes as file or directory names.

In this case all invalid UTF-8 bytes will be replaced with a quoted representation of the byte value to allow uploading a file to such a backend. For example, the invalid byte 0xFE will be encoded as ‛FE.

A common source of invalid UTF-8 bytes are local filesystems, that store names in a different encoding than UTF-8 or UTF-16, like latin1. See the local filenames section for details.

Encoding option

Most backends have an encoding option, specified as a flag --backend-encoding where backend is the name of the backend, or as a config parameter encoding (you'll need to select the Advanced config in rclone config to see it).

This will have default value which encodes and decodes characters in such a way as to preserve the maximum number of characters (see above).

However this can be incorrect in some scenarios, for example if you have a Windows file system with Unicode fullwidth characters ＊, ？ or ：, that you want to remain as those characters on the remote rather than being translated to regular (halfwidth) *, ? and :.

The --backend-encoding flags allow you to change that. You can disable the encoding completely with --backend-encoding Raw or set encoding = Raw in the config file.

Encoding takes a comma separated list of encodings. You can see the list of all possible values by passing an invalid value to this flag, e.g. --local-encoding "help". The command rclone help flags encoding will show you the defaults for the backends.

Encoding Characters Encoded as
Asterisk * ＊
BackQuote ` ｀
BackSlash \ ＼
Colon : ：
CrLf CR 0x0D, LF 0x0A ␍, ␊
Ctl All control characters 0x00-0x1F ␀␁␂␃␄␅␆␇␈␉␊␋␌␍␎␏␐␑␒␓␔␕␖␗␘␙␚␛␜␝␞␟
Del DEL 0x7F ␡
Dollar $ ＄
Dot . or .. as entire string ．, ．．
DoubleQuote " ＂
Exclamation ! ！
Hash # ＃
InvalidUtf8 An invalid UTF-8 character (e.g. latin1) �
LeftCrLfHtVt CR 0x0D, LF 0x0A, HT 0x09, VT 0x0B on the left of a string ␍, ␊, ␉, ␋
LeftPeriod . on the left of a string .
LeftSpace SPACE on the left of a string ␠
LeftTilde ~ on the left of a string ～
LtGt <, > ＜, ＞
None ¹ NUL 0x00 ␀
Percent % ％
Pipe | ｜
Question ? ？
RightCrLfHtVt CR 0x0D, LF 0x0A, HT 0x09, VT 0x0B on the right of a string ␍, ␊, ␉, ␋
RightPeriod . on the right of a string .
RightSpace SPACE on the right of a string ␠
Semicolon ; ；
SingleQuote ' ＇
Slash / ／
SquareBracket [, ] ［, ］

¹ Encoding from NUL 0x00 to ␀ is always implicit except when using Raw. It was previously incorrectly documented as disabling encoding, and to maintain backward compatibility, its behavior has not been changed.

Encoding example: FTP

To take a specific example, the FTP backend's default encoding is

--ftp-encoding "Slash,Del,Ctl,RightSpace,Dot"

However, let's say the FTP server is running on Windows and can't have any of the invalid Windows characters in file names. You are backing up Linux servers to this FTP server which do have those characters in file names. So you would add the Windows set which are

Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot

to the existing ones, giving:

Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot,Del,RightSpace

This can be specified using the --ftp-encoding flag or using an encoding parameter in the config file.

Encoding example: Windows

As a nother example, take a Windows system where there is a file with name Test：1.jpg, where ： is the Unicode fullwidth colon symbol. When using rclone to copy this to a remote which supports :, the regular (halfwidth) colon (such as Google Drive), you will notice that the file gets renamed to Test:1.jpg.

To avoid this you can change the set of characters rclone should convert for the local filesystem, using command-line argument --local-encoding. Rclone's default behavior on Windows corresponds to

--local-encoding "Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot"

If you want to use fullwidth characters ：, ＊ and ？ in your filenames without rclone changing them when uploading to a remote, then set the same as the default value but without Colon,Question,Asterisk:

--local-encoding "Slash,LtGt,DoubleQuote,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot"

Alternatively, you can disable the conversion of any characters with --local-encoding Raw.

Instead of using command-line argument --local-encoding, you may also set it as environment variable RCLONE_LOCAL_ENCODING, or configure a remote of type local in your config, and set the encoding option there.

The risk by doing this is that if you have a filename with the regular (halfwidth) :, * and ? in your cloud storage, and you try to download it to your Windows filesystem, this will fail. These characters are not valid in filenames on Windows, and you have told rclone not to work around this by converting them to valid fullwidth variants.

MIME Type

MIME types (also known as media types) classify types of documents using a simple text classification, e.g. text/html or application/pdf.

Some cloud storage systems support reading (R) the MIME type of objects and some support writing (W) the MIME type of objects.

The MIME type can be important if you are serving files directly to HTTP from the storage system.

If you are copying from a remote which supports reading (R) to a remote which supports writing (W) then rclone will preserve the MIME types. Otherwise they will be guessed from the extension, or the remote itself may assign the MIME type.

Metadata

Backends may or may support reading or writing metadata. They may support reading and writing system metadata (metadata intrinsic to that backend) and/or user metadata (general purpose metadata).

The levels of metadata support are

Key Explanation
R Read only System Metadata on files only
RW Read and write System Metadata on files only
RWU Read and write System Metadata and read and write User Metadata on files only
DR Read only System Metadata on files and directories
DRW Read and write System Metadata on files and directories
DRWU Read and write System Metadata and read and write User Metadata on files and directories

See the metadata docs for more info.

Optional Features

All rclone remotes support a base command set. Other features depend upon backend-specific capabilities.

Name Purge Copy Move DirMove CleanUp ListR StreamUpload MultithreadUpload LinkSharing About EmptyDir
1Fichier No Yes Yes No No No No No Yes No Yes
Akamai Netstorage Yes No No No No Yes Yes No No No Yes
Amazon S3 (or S3 compatible) No Yes No No Yes Yes Yes Yes Yes No No
Backblaze B2 No Yes No No Yes Yes Yes Yes Yes No No
Box Yes Yes Yes Yes Yes No Yes No Yes Yes Yes
Citrix ShareFile Yes Yes Yes Yes No No No No No No Yes
Dropbox Yes Yes Yes Yes No No Yes No Yes Yes Yes
Cloudinary No No No No No No Yes No No No No
Enterprise File Fabric Yes Yes Yes Yes Yes No No No No No Yes
Files.com Yes Yes Yes Yes No No Yes No Yes No Yes
FTP No No Yes Yes No No Yes No No No Yes
Gofile Yes Yes Yes Yes No No Yes No Yes Yes Yes
Google Cloud Storage Yes Yes No No No No Yes No No No No
Google Drive Yes Yes Yes Yes Yes Yes Yes No Yes Yes Yes
Google Photos No No No No No No No No No No No
HDFS Yes No Yes Yes No No Yes No No Yes Yes
HiDrive Yes Yes Yes Yes No No Yes No No No Yes
HTTP No No No No No No No No No No Yes
iCloud Drive Yes Yes Yes Yes No No No No No No Yes
ImageKit Yes No Yes No No No No No No No Yes
Internet Archive No Yes No No Yes Yes No No Yes Yes No
Jottacloud Yes Yes Yes Yes Yes Yes No No Yes Yes Yes
Koofr Yes Yes Yes Yes No No Yes No Yes Yes Yes
Mail.ru Cloud Yes Yes Yes Yes Yes No No No Yes Yes Yes
Mega Yes No Yes Yes Yes No No No Yes Yes Yes
Memory No Yes No No No Yes Yes No No No No
Microsoft Azure Blob Storage Yes Yes No No No Yes Yes Yes No No No
Microsoft Azure Files Storage No Yes Yes Yes No No Yes Yes No Yes Yes
Microsoft OneDrive Yes Yes Yes Yes Yes Yes ⁵ No No Yes Yes Yes
OpenDrive Yes Yes Yes Yes No No No No No Yes Yes
OpenStack Swift Yes ¹ Yes No No No Yes Yes No No Yes No
Oracle Object Storage No Yes No No Yes Yes Yes Yes No No No
pCloud Yes Yes Yes Yes Yes No No No Yes Yes Yes
PikPak Yes Yes Yes Yes Yes No No No Yes Yes Yes
Pixeldrain Yes No Yes Yes No No Yes No Yes Yes Yes
premiumize.me Yes No Yes Yes No No No No Yes Yes Yes
put.io Yes No Yes Yes Yes No Yes No No Yes Yes
Proton Drive Yes No Yes Yes Yes No No No No Yes Yes
QingStor No Yes No No Yes Yes No No No No No
Quatrix by Maytech Yes Yes Yes Yes No No No No No Yes Yes
Seafile Yes Yes Yes Yes Yes Yes Yes No Yes Yes Yes
SFTP No Yes ⁴ Yes Yes No No Yes No No Yes Yes
Sia No No No No No No Yes No No No Yes
SMB No No Yes Yes No No Yes Yes No No Yes
SugarSync Yes Yes Yes Yes No No Yes No Yes No Yes
Storj Yes ² Yes Yes No No Yes Yes No Yes No No
Uloz.to No No Yes Yes No No No No No No Yes
Uptobox No Yes Yes Yes No No No No No No No
WebDAV Yes Yes Yes Yes No No Yes ³ No No Yes Yes
Yandex Disk Yes Yes Yes Yes Yes No Yes No Yes Yes Yes
Zoho WorkDrive Yes Yes Yes Yes No No No No No Yes Yes
The local filesystem No No Yes Yes No No Yes Yes No Yes Yes

¹ Note Swift implements this in order to delete directory markers but it doesn't actually have a quicker way of deleting files other than deleting them individually.

² Storj implements this efficiently only for entire buckets. If purging a directory inside a bucket, files are deleted individually.

³ StreamUpload is not supported with Nextcloud

⁴ Use the --sftp-copy-is-hardlink flag to enable.

⁵ Use the --onedrive-delta flag to enable.

Purge

This deletes a directory quicker than just deleting all the files in the directory.

Copy

Used when copying an object to and from the same remote. This known as a server-side copy so you can copy a file without downloading it and uploading it again. It is used if you use rclone copy or rclone move if the remote doesn't support Move directly.

If the server doesn't support Copy directly then for copy operations the file is downloaded then re-uploaded.

Move

Used when moving/renaming an object on the same remote. This is known as a server-side move of a file. This is used in rclone move if the server doesn't support DirMove.

If the server isn't capable of Move then rclone simulates it with Copy then delete. If the server doesn't support Copy then rclone will download the file and re-upload it.

DirMove

This is used to implement rclone move to move a directory if possible. If it isn't then it will use Move on each file (which falls back to Copy then download and upload - see Move section).

CleanUp

This is used for emptying the trash for a remote by rclone cleanup.

If the server can't do CleanUp then rclone cleanup will return an error.

‡‡ Note that while Box implements this it has to delete every file individually so it will be slower than emptying the trash via the WebUI

ListR

The remote supports a recursive list to list all the contents beneath a directory quickly. This enables the --fast-list flag to work. See the rclone docs for more details.

StreamUpload

Some remotes allow files to be uploaded without knowing the file size in advance. This allows certain operations to work without spooling the file to local disk first, e.g. rclone rcat.

MultithreadUpload

Some remotes allow transfers to the remote to be sent as chunks in parallel. If this is supported then rclone will use multi-thread copying to transfer files much faster.

LinkSharing

Sets the necessary permissions on a file or folder and prints a link that allows others to access them, even if they don't have an account on the particular cloud provider.

About

Rclone about prints quota information for a remote. Typical output includes bytes used, free, quota and in trash.

If a remote lacks about capability rclone about remote:returns an error.

Backends without about capability cannot determine free space for an rclone mount, or use policy mfs (most free space) as a member of an rclone union remote.

See rclone about command

EmptyDir

The remote supports empty directories. See Limitations for details. Most Object/Bucket-based remotes do not support this.

Global Flags

This describes the global flags available to every rclone command split into groups.

Copy

Flags for anything which can copy a file.

      --check-first                                 Do all the checks before starting transfers
  -c, --checksum                                    Check for changes with size & checksum (if available, or fallback to size only)
      --compare-dest stringArray                    Include additional server-side paths during comparison
      --copy-dest stringArray                       Implies --compare-dest but also copies files from paths into destination
      --cutoff-mode HARD|SOFT|CAUTIOUS              Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD)
      --ignore-case-sync                            Ignore case when synchronizing
      --ignore-checksum                             Skip post copy check of checksums
      --ignore-existing                             Skip all files that exist on destination
      --ignore-size                                 Ignore size when skipping use modtime or checksum
  -I, --ignore-times                                Don't skip items that match size and time - transfer all unconditionally
      --immutable                                   Do not modify files, fail if existing files have been modified
      --inplace                                     Download directly to destination file instead of atomic download to temp/rename
  -l, --links                                       Translate symlinks to/from regular files with a '.rclonelink' extension
      --max-backlog int                             Maximum number of objects in sync or check backlog (default 10000)
      --max-duration Duration                       Maximum duration rclone will transfer data for (default 0s)
      --max-transfer SizeSuffix                     Maximum size of data to transfer (default off)
  -M, --metadata                                    If set, preserve metadata when copying objects
      --modify-window Duration                      Max time diff to be considered the same (default 1ns)
      --multi-thread-chunk-size SizeSuffix          Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi)
      --multi-thread-cutoff SizeSuffix              Use multi-thread downloads for files above this size (default 256Mi)
      --multi-thread-streams int                    Number of streams to use for multi-thread downloads (default 4)
      --multi-thread-write-buffer-size SizeSuffix   In memory buffer size for writing when in multi-thread mode (default 128Ki)
      --name-transform stringArray                  Transform paths during the copy process
      --no-check-dest                               Don't check the destination, copy regardless
      --no-traverse                                 Don't traverse destination file system on copy
      --no-update-dir-modtime                       Don't update directory modification times
      --no-update-modtime                           Don't update destination modtime if files identical
      --order-by string                             Instructions on how to order the transfers, e.g. 'size,descending'
      --partial-suffix string                       Add partial-suffix to temporary file name when --inplace is not used (default ".partial")
      --refresh-times                               Refresh the modtime of remote files
      --server-side-across-configs                  Allow server-side operations (e.g. copy) to work across different configs
      --size-only                                   Skip based on size only, not modtime or checksum
      --streaming-upload-cutoff SizeSuffix          Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki)
  -u, --update                                      Skip files that are newer on the destination

Sync

Flags used for sync commands.

      --backup-dir string               Make backups into hierarchy based in DIR
      --delete-after                    When synchronizing, delete files on destination after transferring (default)
      --delete-before                   When synchronizing, delete files on destination before transferring
      --delete-during                   When synchronizing, delete files during transfer
      --fix-case                        Force rename of case insensitive dest to match source
      --ignore-errors                   Delete even if there are I/O errors
      --list-cutoff int                 To save memory, sort directory listings on disk above this threshold (default 1000000)
      --max-delete int                  When synchronizing, limit the number of deletes (default -1)
      --max-delete-size SizeSuffix      When synchronizing, limit the total size of deletes (default off)
      --suffix string                   Suffix to add to changed files
      --suffix-keep-extension           Preserve the extension when using --suffix
      --track-renames                   When synchronizing, track file renames and do a server-side move if possible
      --track-renames-strategy string   Strategies to use when synchronizing using track-renames hash|modtime|leaf (default "hash")

Important

Important flags useful for most commands.

  -n, --dry-run         Do a trial run with no permanent changes
  -i, --interactive     Enable interactive mode
  -v, --verbose count   Print lots more stuff (repeat for more)

Check

Flags used for check commands.

      --max-backlog int   Maximum number of objects in sync or check backlog (default 10000)

Networking

Flags for general networking and HTTP stuff.

      --bind string                        Local address to bind to for outgoing connections, IPv4, IPv6 or name
      --bwlimit BwTimetable                Bandwidth limit in KiB/s, or use suffix B|K|M|G|T|P or a full timetable
      --bwlimit-file BwTimetable           Bandwidth limit per file in KiB/s, or use suffix B|K|M|G|T|P or a full timetable
      --ca-cert stringArray                CA certificate used to verify servers
      --client-cert string                 Client SSL certificate (PEM) for mutual TLS auth
      --client-key string                  Client SSL private key (PEM) for mutual TLS auth
      --client-pass string                 Password for client SSL private key (PEM) for mutual TLS auth (obscured) (obscured)
      --contimeout Duration                Connect timeout (default 1m0s)
      --disable-http-keep-alives           Disable HTTP keep-alives and use each connection once
      --disable-http2                      Disable HTTP/2 in the global transport
      --dscp string                        Set DSCP value to connections, value or name, e.g. CS1, LE, DF, AF21
      --expect-continue-timeout Duration   Timeout when using expect / 100-continue in HTTP (default 1s)
      --header stringArray                 Set HTTP header for all transactions
      --header-download stringArray        Set HTTP header for download transactions
      --header-upload stringArray          Set HTTP header for upload transactions
      --http-proxy string                  HTTP proxy URL
      --max-connections int                Maximum number of simultaneous backend API connections, 0 for unlimited
      --no-check-certificate               Do not verify the server SSL certificate (insecure)
      --no-gzip-encoding                   Don't set Accept-Encoding: gzip
      --timeout Duration                   IO idle timeout (default 5m0s)
      --tpslimit float                     Limit HTTP transactions per second to this
      --tpslimit-burst int                 Max burst of transactions for --tpslimit (default 1)
      --use-cookies                        Enable session cookiejar
      --user-agent string                  Set the user-agent to a specified string (default "rclone/v1.71.0")

Performance

Flags helpful for increasing performance.

      --buffer-size SizeSuffix   In memory buffer size when reading files for each --transfer (default 16Mi)
      --checkers int             Number of checkers to run in parallel (default 8)
      --transfers int            Number of file transfers to run in parallel (default 4)

Config

Flags for general configuration of rclone.

      --ask-password                        Allow prompt for password for encrypted configuration (default true)
      --auto-confirm                        If enabled, do not request console confirmation
      --cache-dir string                    Directory rclone will use for caching (default "$HOME/.cache/rclone")
      --color AUTO|NEVER|ALWAYS             When to show colors (and other ANSI codes) AUTO|NEVER|ALWAYS (default AUTO)
      --config string                       Config file (default "$HOME/.config/rclone/rclone.conf")
      --default-time Time                   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --disable string                      Disable a comma separated list of features (use --disable help to see a list)
  -n, --dry-run                             Do a trial run with no permanent changes
      --error-on-no-transfer                Sets exit code 9 if no files are transferred, useful in scripts
      --fs-cache-expire-duration Duration   Cache remotes for this long (0 to disable caching) (default 5m0s)
      --fs-cache-expire-interval Duration   Interval to check for expired remotes (default 1m0s)
      --human-readable                      Print numbers in a human-readable format, sizes with suffix Ki|Mi|Gi|Ti|Pi
  -i, --interactive                         Enable interactive mode
      --kv-lock-time Duration               Maximum time to keep key-value database locked by process (default 1s)
      --low-level-retries int               Number of low level retries to do (default 10)
      --max-buffer-memory SizeSuffix        If set, don't allocate more than this amount of memory as buffers (default off)
      --no-console                          Hide console window (supported on Windows only)
      --no-unicode-normalization            Don't normalize unicode characters in filenames
      --password-command SpaceSepList       Command for supplying password for encrypted configuration
      --retries int                         Retry operations this many times if they fail (default 3)
      --retries-sleep Duration              Interval between retrying operations if they fail, e.g. 500ms, 60s, 5m (0 to disable) (default 0s)
      --temp-dir string                     Directory rclone will use for temporary files (default "/tmp")
      --use-mmap                            Use mmap allocator (see docs)
      --use-server-modtime                  Use server modified time instead of object metadata

Debugging

Flags for developers.

      --cpuprofile string   Write cpu profile to file
      --dump DumpFlags      List of items to dump from: headers, bodies, requests, responses, auth, filters, goroutines, openfiles, mapper
      --dump-bodies         Dump HTTP headers and bodies - may contain sensitive info
      --dump-headers        Dump HTTP headers - may contain sensitive info
      --memprofile string   Write memory profile to file

Filter

Flags for filtering directory listings.

      --delete-excluded                     Delete files on dest excluded from sync
      --exclude stringArray                 Exclude files matching pattern
      --exclude-from stringArray            Read file exclude patterns from file (use - to read from stdin)
      --exclude-if-present stringArray      Exclude directories if filename is present
      --files-from stringArray              Read list of source-file names from file (use - to read from stdin)
      --files-from-raw stringArray          Read list of source-file names from file without any processing of lines (use - to read from stdin)
  -f, --filter stringArray                  Add a file filtering rule
      --filter-from stringArray             Read file filtering patterns from a file (use - to read from stdin)
      --hash-filter string                  Partition filenames by hash k/n or randomly @/n
      --ignore-case                         Ignore case in filters (case insensitive)
      --include stringArray                 Include files matching pattern
      --include-from stringArray            Read file include patterns from file (use - to read from stdin)
      --max-age Duration                    Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --max-depth int                       If set limits the recursion depth to this (default -1)
      --max-size SizeSuffix                 Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off)
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --min-age Duration                    Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off)
      --min-size SizeSuffix                 Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off)

Listing

Flags for listing directories.

      --default-time Time   Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z)
      --fast-list           Use recursive list if available; uses more memory but fewer transactions

Logging

Flags for logging and statistics.

      --log-file string                     Log everything to this file
      --log-file-compress                   If set, compress rotated log files using gzip
      --log-file-max-age Duration           Maximum duration to retain old log files (eg "7d") (default 0s)
      --log-file-max-backups int            Maximum number of old log files to retain
      --log-file-max-size SizeSuffix        Maximum size of the log file before it's rotated (eg "10M") (default off)
      --log-format Bits                     Comma separated list of log format options (default date,time)
      --log-level LogLevel                  Log level DEBUG|INFO|NOTICE|ERROR (default NOTICE)
      --log-systemd                         Activate systemd integration for the logger
      --max-stats-groups int                Maximum number of stats groups to keep in memory, on max oldest is discarded (default 1000)
  -P, --progress                            Show progress during transfer
      --progress-terminal-title             Show progress on the terminal title (requires -P/--progress)
  -q, --quiet                               Print as little stuff as possible
      --stats Duration                      Interval between printing stats, e.g. 500ms, 60s, 5m (0 to disable) (default 1m0s)
      --stats-file-name-length int          Max file name length in stats (0 for no limit) (default 45)
      --stats-log-level LogLevel            Log level to show --stats output DEBUG|INFO|NOTICE|ERROR (default INFO)
      --stats-one-line                      Make the stats fit on one line
      --stats-one-line-date                 Enable --stats-one-line and add current date/time prefix
      --stats-one-line-date-format string   Enable --stats-one-line-date and use custom formatted date: Enclose date string in double quotes ("), see https://golang.org/pkg/time/#Time.Format
      --stats-unit string                   Show data rate in stats as either 'bits' or 'bytes' per second (default "bytes")
      --syslog                              Use Syslog for logging
      --syslog-facility string              Facility for syslog, e.g. KERN,USER (default "DAEMON")
      --use-json-log                        Use json log format
  -v, --verbose count                       Print lots more stuff (repeat for more)

Metadata

Flags to control metadata.

  -M, --metadata                            If set, preserve metadata when copying objects
      --metadata-exclude stringArray        Exclude metadatas matching pattern
      --metadata-exclude-from stringArray   Read metadata exclude patterns from file (use - to read from stdin)
      --metadata-filter stringArray         Add a metadata filtering rule
      --metadata-filter-from stringArray    Read metadata filtering patterns from a file (use - to read from stdin)
      --metadata-include stringArray        Include metadatas matching pattern
      --metadata-include-from stringArray   Read metadata include patterns from file (use - to read from stdin)
      --metadata-mapper SpaceSepList        Program to run to transforming metadata before upload
      --metadata-set stringArray            Add metadata key=value when uploading

RC

Flags to control the Remote Control API.

      --rc                                 Enable the remote control server
      --rc-addr stringArray                IPaddress:Port or :Port to bind server to (default localhost:5572)
      --rc-allow-origin string             Origin which cross-domain request (CORS) can be executed from
      --rc-baseurl string                  Prefix for URLs - leave blank for root
      --rc-cert string                     TLS PEM key (concatenation of certificate and CA certificate)
      --rc-client-ca string                Client certificate authority to verify clients with
      --rc-enable-metrics                  Enable the Prometheus metrics path at the remote control server
      --rc-files string                    Path to local files to serve on the HTTP server
      --rc-htpasswd string                 A htpasswd file - if not provided no authentication is done
      --rc-job-expire-duration Duration    Expire finished async jobs older than this value (default 1m0s)
      --rc-job-expire-interval Duration    Interval to check for expired async jobs (default 10s)
      --rc-key string                      TLS PEM Private key
      --rc-max-header-bytes int            Maximum size of request header (default 4096)
      --rc-min-tls-version string          Minimum TLS version that is acceptable (default "tls1.0")
      --rc-no-auth                         Don't require auth for certain methods
      --rc-pass string                     Password for authentication
      --rc-realm string                    Realm for authentication
      --rc-salt string                     Password hashing salt (default "dlPL2MqE")
      --rc-serve                           Enable the serving of remote objects
      --rc-serve-no-modtime                Don't read the modification time (can speed things up)
      --rc-server-read-timeout Duration    Timeout for server reading data (default 1h0m0s)
      --rc-server-write-timeout Duration   Timeout for server writing data (default 1h0m0s)
      --rc-template string                 User-specified template
      --rc-user string                     User name for authentication
      --rc-user-from-header string         User name from a defined HTTP header
      --rc-web-fetch-url string            URL to fetch the releases for webgui (default "https://api.github.com/repos/rclone/rclone-webui-react/releases/latest")
      --rc-web-gui                         Launch WebGUI on localhost
      --rc-web-gui-force-update            Force update to latest version of web gui
      --rc-web-gui-no-open-browser         Don't open the browser automatically
      --rc-web-gui-update                  Check and update to latest version of web gui

Metrics

Flags to control the Metrics HTTP endpoint..

      --metrics-addr stringArray                IPaddress:Port or :Port to bind metrics server to
      --metrics-allow-origin string             Origin which cross-domain request (CORS) can be executed from
      --metrics-baseurl string                  Prefix for URLs - leave blank for root
      --metrics-cert string                     TLS PEM key (concatenation of certificate and CA certificate)
      --metrics-client-ca string                Client certificate authority to verify clients with
      --metrics-htpasswd string                 A htpasswd file - if not provided no authentication is done
      --metrics-key string                      TLS PEM Private key
      --metrics-max-header-bytes int            Maximum size of request header (default 4096)
      --metrics-min-tls-version string          Minimum TLS version that is acceptable (default "tls1.0")
      --metrics-pass string                     Password for authentication
      --metrics-realm string                    Realm for authentication
      --metrics-salt string                     Password hashing salt (default "dlPL2MqE")
      --metrics-server-read-timeout Duration    Timeout for server reading data (default 1h0m0s)
      --metrics-server-write-timeout Duration   Timeout for server writing data (default 1h0m0s)
      --metrics-template string                 User-specified template
      --metrics-user string                     User name for authentication
      --metrics-user-from-header string         User name from a defined HTTP header
      --rc-enable-metrics                       Enable the Prometheus metrics path at the remote control server

Backend

Backend-only flags (these can be set in the config file also).

      --alias-description string                            Description of the remote
      --alias-remote string                                 Remote or path to alias
      --azureblob-access-tier string                        Access tier of blob: hot, cool, cold or archive
      --azureblob-account string                            Azure Storage Account Name
      --azureblob-archive-tier-delete                       Delete archive tier blobs before overwriting
      --azureblob-chunk-size SizeSuffix                     Upload chunk size (default 4Mi)
      --azureblob-client-certificate-password string        Password for the certificate file (optional) (obscured)
      --azureblob-client-certificate-path string            Path to a PEM or PKCS12 certificate file including the private key
      --azureblob-client-id string                          The ID of the client in use
      --azureblob-client-secret string                      One of the service principal's client secrets
      --azureblob-client-send-certificate-chain             Send the certificate chain when using certificate auth
      --azureblob-copy-concurrency int                      Concurrency for multipart copy (default 512)
      --azureblob-copy-cutoff SizeSuffix                    Cutoff for switching to multipart copy (default 8Mi)
      --azureblob-delete-snapshots string                   Set to specify how to deal with snapshots on blob deletion
      --azureblob-description string                        Description of the remote
      --azureblob-directory-markers                         Upload an empty object with a trailing slash when a new directory is created
      --azureblob-disable-checksum                          Don't store MD5 checksum with object metadata
      --azureblob-disable-instance-discovery                Skip requesting Microsoft Entra instance metadata
      --azureblob-encoding Encoding                         The encoding for the backend (default Slash,BackSlash,Del,Ctl,RightPeriod,InvalidUtf8)
      --azureblob-endpoint string                           Endpoint for the service
      --azureblob-env-auth                                  Read credentials from runtime (environment variables, CLI or MSI)
      --azureblob-key string                                Storage Account Shared Key
      --azureblob-list-chunk int                            Size of blob list (default 5000)
      --azureblob-msi-client-id string                      Object ID of the user-assigned MSI to use, if any
      --azureblob-msi-mi-res-id string                      Azure resource ID of the user-assigned MSI to use, if any
      --azureblob-msi-object-id string                      Object ID of the user-assigned MSI to use, if any
      --azureblob-no-check-container                        If set, don't attempt to check the container exists or create it
      --azureblob-no-head-object                            If set, do not do HEAD before GET when getting objects
      --azureblob-password string                           The user's password (obscured)
      --azureblob-public-access string                      Public access level of a container: blob or container
      --azureblob-sas-url string                            SAS URL for container level access only
      --azureblob-service-principal-file string             Path to file containing credentials for use with a service principal
      --azureblob-tenant string                             ID of the service principal's tenant. Also called its directory ID
      --azureblob-upload-concurrency int                    Concurrency for multipart uploads (default 16)
      --azureblob-upload-cutoff string                      Cutoff for switching to chunked upload (<= 256 MiB) (deprecated)
      --azureblob-use-az                                    Use Azure CLI tool az for authentication
      --azureblob-use-copy-blob                             Whether to use the Copy Blob API when copying to the same storage account (default true)
      --azureblob-use-emulator                              Uses local storage emulator if provided as 'true'
      --azureblob-use-msi                                   Use a managed service identity to authenticate (only works in Azure)
      --azureblob-username string                           User name (usually an email address)
      --azurefiles-account string                           Azure Storage Account Name
      --azurefiles-chunk-size SizeSuffix                    Upload chunk size (default 4Mi)
      --azurefiles-client-certificate-password string       Password for the certificate file (optional) (obscured)
      --azurefiles-client-certificate-path string           Path to a PEM or PKCS12 certificate file including the private key
      --azurefiles-client-id string                         The ID of the client in use
      --azurefiles-client-secret string                     One of the service principal's client secrets
      --azurefiles-client-send-certificate-chain            Send the certificate chain when using certificate auth
      --azurefiles-connection-string string                 Azure Files Connection String
      --azurefiles-description string                       Description of the remote
      --azurefiles-disable-instance-discovery               Skip requesting Microsoft Entra instance metadata
      --azurefiles-encoding Encoding                        The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,RightPeriod,InvalidUtf8,Dot)
      --azurefiles-endpoint string                          Endpoint for the service
      --azurefiles-env-auth                                 Read credentials from runtime (environment variables, CLI or MSI)
      --azurefiles-key string                               Storage Account Shared Key
      --azurefiles-max-stream-size SizeSuffix               Max size for streamed files (default 10Gi)
      --azurefiles-msi-client-id string                     Object ID of the user-assigned MSI to use, if any
      --azurefiles-msi-mi-res-id string                     Azure resource ID of the user-assigned MSI to use, if any
      --azurefiles-msi-object-id string                     Object ID of the user-assigned MSI to use, if any
      --azurefiles-password string                          The user's password (obscured)
      --azurefiles-sas-url string                           SAS URL
      --azurefiles-service-principal-file string            Path to file containing credentials for use with a service principal
      --azurefiles-share-name string                        Azure Files Share Name
      --azurefiles-tenant string                            ID of the service principal's tenant. Also called its directory ID
      --azurefiles-upload-concurrency int                   Concurrency for multipart uploads (default 16)
      --azurefiles-use-az                                   Use Azure CLI tool az for authentication
      --azurefiles-use-msi                                  Use a managed service identity to authenticate (only works in Azure)
      --azurefiles-username string                          User name (usually an email address)
      --b2-account string                                   Account ID or Application Key ID
      --b2-chunk-size SizeSuffix                            Upload chunk size (default 96Mi)
      --b2-copy-cutoff SizeSuffix                           Cutoff for switching to multipart copy (default 4Gi)
      --b2-description string                               Description of the remote
      --b2-disable-checksum                                 Disable checksums for large (> upload cutoff) files
      --b2-download-auth-duration Duration                  Time before the public link authorization token will expire in s or suffix ms|s|m|h|d (default 1w)
      --b2-download-url string                              Custom endpoint for downloads
      --b2-encoding Encoding                                The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot)
      --b2-endpoint string                                  Endpoint for the service
      --b2-hard-delete                                      Permanently delete files on remote removal, otherwise hide files
      --b2-key string                                       Application Key
      --b2-lifecycle int                                    Set the number of days deleted files should be kept when creating a bucket
      --b2-test-mode string                                 A flag string for X-Bz-Test-Mode header for debugging
      --b2-upload-concurrency int                           Concurrency for multipart uploads (default 4)
      --b2-upload-cutoff SizeSuffix                         Cutoff for switching to chunked upload (default 200Mi)
      --b2-version-at Time                                  Show file versions as they were at the specified time (default off)
      --b2-versions                                         Include old versions in directory listings
      --box-access-token string                             Box App Primary Access Token
      --box-auth-url string                                 Auth server URL
      --box-box-config-file string                          Box App config.json location
      --box-box-sub-type string                              (default "user")
      --box-client-credentials                              Use client credentials OAuth flow
      --box-client-id string                                OAuth Client Id
      --box-client-secret string                            OAuth Client Secret
      --box-commit-retries int                              Max number of times to try committing a multipart file (default 100)
      --box-description string                              Description of the remote
      --box-encoding Encoding                               The encoding for the backend (default Slash,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot)
      --box-impersonate string                              Impersonate this user ID when using a service account
      --box-list-chunk int                                  Size of listing chunk 1-1000 (default 1000)
      --box-owned-by string                                 Only show items owned by the login (email address) passed in
      --box-root-folder-id string                           Fill in for rclone to use a non root folder as its starting point
      --box-token string                                    OAuth Access Token as a JSON blob
      --box-token-url string                                Token server url
      --box-upload-cutoff SizeSuffix                        Cutoff for switching to multipart upload (>= 50 MiB) (default 50Mi)
      --cache-chunk-clean-interval Duration                 How often should the cache perform cleanups of the chunk storage (default 1m0s)
      --cache-chunk-no-memory                               Disable the in-memory cache for storing chunks during streaming
      --cache-chunk-path string                             Directory to cache chunk files (default "$HOME/.cache/rclone/cache-backend")
      --cache-chunk-size SizeSuffix                         The size of a chunk (partial file data) (default 5Mi)
      --cache-chunk-total-size SizeSuffix                   The total size that the chunks can take up on the local disk (default 10Gi)
      --cache-db-path string                                Directory to store file structure metadata DB (default "$HOME/.cache/rclone/cache-backend")
      --cache-db-purge                                      Clear all the cached data for this remote on start
      --cache-db-wait-time Duration                         How long to wait for the DB to be available - 0 is unlimited (default 1s)
      --cache-description string                            Description of the remote
      --cache-info-age Duration                             How long to cache file structure information (directory listings, file size, times, etc.) (default 6h0m0s)
      --cache-plex-insecure string                          Skip all certificate verification when connecting to the Plex server
      --cache-plex-password string                          The password of the Plex user (obscured)
      --cache-plex-url string                               The URL of the Plex server
      --cache-plex-username string                          The username of the Plex user
      --cache-read-retries int                              How many times to retry a read from a cache storage (default 10)
      --cache-remote string                                 Remote to cache
      --cache-rps int                                       Limits the number of requests per second to the source FS (-1 to disable) (default -1)
      --cache-tmp-upload-path string                        Directory to keep temporary files until they are uploaded
      --cache-tmp-wait-time Duration                        How long should files be stored in local cache before being uploaded (default 15s)
      --cache-workers int                                   How many workers should run in parallel to download chunks (default 4)
      --cache-writes                                        Cache file data on writes through the FS
      --chunker-chunk-size SizeSuffix                       Files larger than chunk size will be split in chunks (default 2Gi)
      --chunker-description string                          Description of the remote
      --chunker-fail-hard                                   Choose how chunker should handle files with missing or invalid chunks
      --chunker-hash-type string                            Choose how chunker handles hash sums (default "md5")
      --chunker-remote string                               Remote to chunk/unchunk
      --cloudinary-adjust-media-files-extensions            Cloudinary handles media formats as a file attribute and strips it from the name, which is unlike most other file systems (default true)
      --cloudinary-api-key string                           Cloudinary API Key
      --cloudinary-api-secret string                        Cloudinary API Secret
      --cloudinary-cloud-name string                        Cloudinary Environment Name
      --cloudinary-description string                       Description of the remote
      --cloudinary-encoding Encoding                        The encoding for the backend (default Slash,LtGt,DoubleQuote,Question,Asterisk,Pipe,Hash,Percent,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot)
      --cloudinary-eventually-consistent-delay Duration     Wait N seconds for eventual consistency of the databases that support the backend operation (default 0s)
      --cloudinary-media-extensions stringArray             Cloudinary supported media extensions (default 3ds,3g2,3gp,ai,arw,avi,avif,bmp,bw,cr2,cr3,djvu,dng,eps3,fbx,flif,flv,gif,glb,gltf,hdp,heic,heif,ico,indd,jp2,jpe,jpeg,jpg,jxl,jxr,m2ts,mov,mp4,mpeg,mts,mxf,obj,ogv,pdf,ply,png,psd,svg,tga,tif,tiff,ts,u3ma,usdz,wdp,webm,webp,wmv)
      --cloudinary-upload-prefix string                     Specify the API endpoint for environments out of the US
      --cloudinary-upload-preset string                     Upload Preset to select asset manipulation on upload
      --combine-description string                          Description of the remote
      --combine-upstreams SpaceSepList                      Upstreams for combining
      --compress-description string                         Description of the remote
      --compress-level int                                  GZIP compression level (-2 to 9) (default -1)
      --compress-mode string                                Compression mode (default "gzip")
      --compress-ram-cache-limit SizeSuffix                 Some remotes don't allow the upload of files with unknown size (default 20Mi)
      --compress-remote string                              Remote to compress
  -L, --copy-links                                          Follow symlinks and copy the pointed to item
      --crypt-description string                            Description of the remote
      --crypt-directory-name-encryption                     Option to either encrypt directory names or leave them intact (default true)
      --crypt-filename-encoding string                      How to encode the encrypted filename to text string (default "base32")
      --crypt-filename-encryption string                    How to encrypt the filenames (default "standard")
      --crypt-no-data-encryption                            Option to either encrypt file data or leave it unencrypted
      --crypt-pass-bad-blocks                               If set this will pass bad blocks through as all 0
      --crypt-password string                               Password or pass phrase for encryption (obscured)
      --crypt-password2 string                              Password or pass phrase for salt (obscured)
      --crypt-remote string                                 Remote to encrypt/decrypt
      --crypt-server-side-across-configs                    Deprecated: use --server-side-across-configs instead
      --crypt-show-mapping                                  For all files listed show how the names encrypt
      --crypt-strict-names                                  If set, this will raise an error when crypt comes across a filename that can't be decrypted
      --crypt-suffix string                                 If this is set it will override the default suffix of ".bin" (default ".bin")
      --doi-description string                              Description of the remote
      --doi-doi string                                      The DOI or the doi.org URL
      --doi-doi-resolver-api-url string                     The URL of the DOI resolver API to use
      --doi-provider string                                 DOI provider
      --drive-acknowledge-abuse                             Set to allow files which return cannotDownloadAbusiveFile to be downloaded
      --drive-allow-import-name-change                      Allow the filetype to change when uploading Google docs
      --drive-auth-owner-only                               Only consider files owned by the authenticated user
      --drive-auth-url string                               Auth server URL
      --drive-chunk-size SizeSuffix                         Upload chunk size (default 8Mi)
      --drive-client-credentials                            Use client credentials OAuth flow
      --drive-client-id string                              Google Application Client Id
      --drive-client-secret string                          OAuth Client Secret
      --drive-copy-shortcut-content                         Server side copy contents of shortcuts instead of the shortcut
      --drive-description string                            Description of the remote
      --drive-disable-http2                                 Disable drive using http2 (default true)
      --drive-encoding Encoding                             The encoding for the backend (default InvalidUtf8)
      --drive-env-auth                                      Get IAM credentials from runtime (environment variables or instance meta data if no env vars)
      --drive-export-formats string                         Comma separated list of preferred formats for downloading Google docs (default "docx,xlsx,pptx,svg")
      --drive-fast-list-bug-fix                             Work around a bug in Google Drive listing (default true)
      --drive-formats string                                Deprecated: See export_formats
      --drive-impersonate string                            Impersonate this user when using a service account
      --drive-import-formats string                         Comma separated list of preferred formats for uploading Google docs
      --drive-keep-revision-forever                         Keep new head revision of each file forever
      --drive-list-chunk int                                Size of listing chunk 100-1000, 0 to disable (default 1000)
      --drive-metadata-labels Bits                          Control whether labels should be read or written in metadata (default off)
      --drive-metadata-owner Bits                           Control whether owner should be read or written in metadata (default read)
      --drive-metadata-permissions Bits                     Control whether permissions should be read or written in metadata (default off)
      --drive-pacer-burst int                               Number of API calls to allow without sleeping (default 100)
      --drive-pacer-min-sleep Duration                      Minimum time to sleep between API calls (default 100ms)
      --drive-resource-key string                           Resource key for accessing a link-shared file
      --drive-root-folder-id string                         ID of the root folder
      --drive-scope string                                  Comma separated list of scopes that rclone should use when requesting access from drive
      --drive-server-side-across-configs                    Deprecated: use --server-side-across-configs instead
      --drive-service-account-credentials string            Service Account Credentials JSON blob
      --drive-service-account-file string                   Service Account Credentials JSON file path
      --drive-shared-with-me                                Only show files that are shared with me
      --drive-show-all-gdocs                                Show all Google Docs including non-exportable ones in listings
      --drive-size-as-quota                                 Show sizes as storage quota usage, not actual size
      --drive-skip-checksum-gphotos                         Skip checksums on Google photos and videos only
      --drive-skip-dangling-shortcuts                       If set skip dangling shortcut files
      --drive-skip-gdocs                                    Skip google documents in all listings
      --drive-skip-shortcuts                                If set skip shortcut files
      --drive-starred-only                                  Only show files that are starred
      --drive-stop-on-download-limit                        Make download limit errors be fatal
      --drive-stop-on-upload-limit                          Make upload limit errors be fatal
      --drive-team-drive string                             ID of the Shared Drive (Team Drive)
      --drive-token string                                  OAuth Access Token as a JSON blob
      --drive-token-url string                              Token server url
      --drive-trashed-only                                  Only show files that are in the trash
      --drive-upload-cutoff SizeSuffix                      Cutoff for switching to chunked upload (default 8Mi)
      --drive-use-created-date                              Use file created date instead of modified date
      --drive-use-shared-date                               Use date file was shared instead of modified date
      --drive-use-trash                                     Send files to the trash instead of deleting permanently (default true)
      --drive-v2-download-min-size SizeSuffix               If Object's are greater, use drive v2 API to download (default off)
      --dropbox-auth-url string                             Auth server URL
      --dropbox-batch-mode string                           Upload file batching sync|async|off (default "sync")
      --dropbox-batch-size int                              Max number of files in upload batch
      --dropbox-batch-timeout Duration                      Max time to allow an idle upload batch before uploading (default 0s)
      --dropbox-chunk-size SizeSuffix                       Upload chunk size (< 150Mi) (default 48Mi)
      --dropbox-client-credentials                          Use client credentials OAuth flow
      --dropbox-client-id string                            OAuth Client Id
      --dropbox-client-secret string                        OAuth Client Secret
      --dropbox-description string                          Description of the remote
      --dropbox-encoding Encoding                           The encoding for the backend (default Slash,BackSlash,Del,RightSpace,InvalidUtf8,Dot)
      --dropbox-export-formats CommaSepList                 Comma separated list of preferred formats for exporting files (default html,md)
      --dropbox-impersonate string                          Impersonate this user when using a business account
      --dropbox-pacer-min-sleep Duration                    Minimum time to sleep between API calls (default 10ms)
      --dropbox-root-namespace string                       Specify a different Dropbox namespace ID to use as the root for all paths
      --dropbox-shared-files                                Instructs rclone to work on individual shared files
      --dropbox-shared-folders                              Instructs rclone to work on shared folders
      --dropbox-show-all-exports                            Show all exportable files in listings
      --dropbox-skip-exports                                Skip exportable files in all listings
      --dropbox-token string                                OAuth Access Token as a JSON blob
      --dropbox-token-url string                            Token server url
      --fichier-api-key string                              Your API Key, get it from https://1fichier.com/console/params.pl
      --fichier-cdn                                         Set if you wish to use CDN download links
      --fichier-description string                          Description of the remote
      --fichier-encoding Encoding                           The encoding for the backend (default Slash,LtGt,DoubleQuote,SingleQuote,BackQuote,Dollar,BackSlash,Del,Ctl,LeftSpace,RightSpace,InvalidUtf8,Dot)
      --fichier-file-password string                        If you want to download a shared file that is password protected, add this parameter (obscured)
      --fichier-folder-password string                      If you want to list the files in a shared folder that is password protected, add this parameter (obscured)
      --fichier-shared-folder string                        If you want to download a shared folder, add this parameter
      --filefabric-description string                       Description of the remote
      --filefabric-encoding Encoding                        The encoding for the backend (default Slash,Del,Ctl,InvalidUtf8,Dot)
      --filefabric-permanent-token string                   Permanent Authentication Token
      --filefabric-root-folder-id string                    ID of the root folder
      --filefabric-token string                             Session Token
      --filefabric-token-expiry string                      Token expiry time
      --filefabric-url string                               URL of the Enterprise File Fabric to connect to
      --filefabric-version string                           Version read from the file fabric
      --filelu-description string                           Description of the remote
      --filelu-encoding Encoding                            The encoding for the backend (default Slash,LtGt,DoubleQuote,SingleQuote,BackQuote,Dollar,Colon,Question,Asterisk,Pipe,Hash,Percent,BackSlash,CrLf,Del,Ctl,LeftSpace,LeftPeriod,LeftTilde,LeftCrLfHtVt,RightSpace,RightPeriod,RightCrLfHtVt,InvalidUtf8,Dot,SquareBracket,Semicolon,Exclamation)
      --filelu-key string                                   Your FileLu Rclone key from My Account
      --filescom-api-key string                             The API key used to authenticate with Files.com
      --filescom-description string                         Description of the remote
      --filescom-encoding Encoding                          The encoding for the backend (default Slash,BackSlash,Del,Ctl,RightSpace,RightCrLfHtVt,InvalidUtf8,Dot)
      --filescom-password string                            The password used to authenticate with Files.com (obscured)
      --filescom-site string                                Your site subdomain (e.g. mysite) or custom domain (e.g. myfiles.customdomain.com)
      --filescom-username string                            The username used to authenticate with Files.com
      --ftp-allow-insecure-tls-ciphers                      Allow insecure TLS ciphers
      --ftp-ask-password                                    Allow asking for FTP password when needed
      --ftp-close-timeout Duration                          Maximum time to wait for a response to close (default 1m0s)
      --ftp-concurrency int                                 Maximum number of FTP simultaneous connections, 0 for unlimited
      --ftp-description string                              Description of the remote
      --ftp-disable-epsv                                    Disable using EPSV even if server advertises support
      --ftp-disable-mlsd                                    Disable using MLSD even if server advertises support
      --ftp-disable-tls13                                   Disable TLS 1.3 (workaround for FTP servers with buggy TLS)
      --ftp-disable-utf8                                    Disable using UTF-8 even if server advertises support
      --ftp-encoding Encoding                               The encoding for the backend (default Slash,Del,Ctl,RightSpace,Dot)
      --ftp-explicit-tls                                    Use Explicit FTPS (FTP over TLS)
      --ftp-force-list-hidden                               Use LIST -a to force listing of hidden files and folders. This will disable the use of MLSD
      --ftp-host string                                     FTP host to connect to
      --ftp-http-proxy string                               URL for HTTP CONNECT proxy
      --ftp-idle-timeout Duration                           Max time before closing idle connections (default 1m0s)
      --ftp-no-check-certificate                            Do not verify the TLS certificate of the server
      --ftp-no-check-upload                                 Don't check the upload is OK
      --ftp-pass string                                     FTP password (obscured)
      --ftp-port int                                        FTP port number (default 21)
      --ftp-shut-timeout Duration                           Maximum time to wait for data connection closing status (default 1m0s)
      --ftp-socks-proxy string                              Socks 5 proxy host
      --ftp-tls                                             Use Implicit FTPS (FTP over TLS)
      --ftp-tls-cache-size int                              Size of TLS session cache for all control and data connections (default 32)
      --ftp-user string                                     FTP username (default "$USER")
      --ftp-writing-mdtm                                    Use MDTM to set modification time (VsFtpd quirk)
      --gcs-access-token string                             Short-lived access token
      --gcs-anonymous                                       Access public buckets and objects without credentials
      --gcs-auth-url string                                 Auth server URL
      --gcs-bucket-acl string                               Access Control List for new buckets
      --gcs-bucket-policy-only                              Access checks should use bucket-level IAM policies
      --gcs-client-credentials                              Use client credentials OAuth flow
      --gcs-client-id string                                OAuth Client Id
      --gcs-client-secret string                            OAuth Client Secret
      --gcs-decompress                                      If set this will decompress gzip encoded objects
      --gcs-description string                              Description of the remote
      --gcs-directory-markers                               Upload an empty object with a trailing slash when a new directory is created
      --gcs-encoding Encoding                               The encoding for the backend (default Slash,CrLf,InvalidUtf8,Dot)
      --gcs-endpoint string                                 Endpoint for the service
      --gcs-env-auth                                        Get GCP IAM credentials from runtime (environment variables or instance meta data if no env vars)
      --gcs-location string                                 Location for the newly created buckets
      --gcs-no-check-bucket                                 If set, don't attempt to check the bucket exists or create it
      --gcs-object-acl string                               Access Control List for new objects
      --gcs-project-number string                           Project number
      --gcs-service-account-file string                     Service Account Credentials JSON file path
      --gcs-storage-class string                            The storage class to use when storing objects in Google Cloud Storage
      --gcs-token string                                    OAuth Access Token as a JSON blob
      --gcs-token-url string                                Token server url
      --gcs-user-project string                             User project
      --gofile-access-token string                          API Access token
      --gofile-account-id string                            Account ID
      --gofile-description string                           Description of the remote
      --gofile-encoding Encoding                            The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,LeftPeriod,RightPeriod,InvalidUtf8,Dot,Exclamation)
      --gofile-list-chunk int                               Number of items to list in each call (default 1000)
      --gofile-root-folder-id string                        ID of the root folder
      --gphotos-auth-url string                             Auth server URL
      --gphotos-batch-mode string                           Upload file batching sync|async|off (default "sync")
      --gphotos-batch-size int                              Max number of files in upload batch
      --gphotos-batch-timeout Duration                      Max time to allow an idle upload batch before uploading (default 0s)
      --gphotos-client-credentials                          Use client credentials OAuth flow
      --gphotos-client-id string                            OAuth Client Id
      --gphotos-client-secret string                        OAuth Client Secret
      --gphotos-description string                          Description of the remote
      --gphotos-encoding Encoding                           The encoding for the backend (default Slash,CrLf,InvalidUtf8,Dot)
      --gphotos-include-archived                            Also view and download archived media
      --gphotos-proxy string                                Use the gphotosdl proxy for downloading the full resolution images
      --gphotos-read-only                                   Set to make the Google Photos backend read only
      --gphotos-read-size                                   Set to read the size of media items
      --gphotos-start-year int                              Year limits the photos to be downloaded to those which are uploaded after the given year (default 2000)
      --gphotos-token string                                OAuth Access Token as a JSON blob
      --gphotos-token-url string                            Token server url
      --hasher-auto-size SizeSuffix                         Auto-update checksum for files smaller than this size (disabled by default)
      --hasher-description string                           Description of the remote
      --hasher-hashes CommaSepList                          Comma separated list of supported checksum types (default md5,sha1)
      --hasher-max-age Duration                             Maximum time to keep checksums in cache (0 = no cache, off = cache forever) (default off)
      --hasher-remote string                                Remote to cache checksums for (e.g. myRemote:path)
      --hdfs-data-transfer-protection string                Kerberos data transfer protection: authentication|integrity|privacy
      --hdfs-description string                             Description of the remote
      --hdfs-encoding Encoding                              The encoding for the backend (default Slash,Colon,Del,Ctl,InvalidUtf8,Dot)
      --hdfs-namenode CommaSepList                          Hadoop name nodes and ports
      --hdfs-service-principal-name string                  Kerberos service principal name for the namenode
      --hdfs-username string                                Hadoop user name
      --hidrive-auth-url string                             Auth server URL
      --hidrive-chunk-size SizeSuffix                       Chunksize for chunked uploads (default 48Mi)
      --hidrive-client-credentials                          Use client credentials OAuth flow
      --hidrive-client-id string                            OAuth Client Id
      --hidrive-client-secret string                        OAuth Client Secret
      --hidrive-description string                          Description of the remote
      --hidrive-disable-fetching-member-count               Do not fetch number of objects in directories unless it is absolutely necessary
      --hidrive-encoding Encoding                           The encoding for the backend (default Slash,Dot)
      --hidrive-endpoint string                             Endpoint for the service (default "https://api.hidrive.strato.com/2.1")
      --hidrive-root-prefix string                          The root/parent folder for all paths (default "/")
      --hidrive-scope-access string                         Access permissions that rclone should use when requesting access from HiDrive (default "rw")
      --hidrive-scope-role string                           User-level that rclone should use when requesting access from HiDrive (default "user")
      --hidrive-token string                                OAuth Access Token as a JSON blob
      --hidrive-token-url string                            Token server url
      --hidrive-upload-concurrency int                      Concurrency for chunked uploads (default 4)
      --hidrive-upload-cutoff SizeSuffix                    Cutoff/Threshold for chunked uploads (default 96Mi)
      --http-description string                             Description of the remote
      --http-headers CommaSepList                           Set HTTP headers for all transactions
      --http-no-escape                                      Do not escape URL metacharacters in path names
      --http-no-head                                        Don't use HEAD requests
      --http-no-slash                                       Set this if the site doesn't end directories with /
      --http-url string                                     URL of HTTP host to connect to
      --iclouddrive-apple-id string                         Apple ID
      --iclouddrive-client-id string                        Client id (default "d39ba9916b7251055b22c7f910e2ea796ee65e98b2ddecea8f5dde8d9d1a815d")
      --iclouddrive-description string                      Description of the remote
      --iclouddrive-encoding Encoding                       The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot)
      --iclouddrive-password string                         Password (obscured)
      --imagekit-description string                         Description of the remote
      --imagekit-encoding Encoding                          The encoding for the backend (default Slash,LtGt,DoubleQuote,Dollar,Question,Hash,Percent,BackSlash,Del,Ctl,InvalidUtf8,Dot,SquareBracket)
      --imagekit-endpoint string                            You can find your ImageKit.io URL endpoint in your [dashboard](https://imagekit.io/dashboard/developer/api-keys)
      --imagekit-only-signed Restrict unsigned image URLs   If you have configured Restrict unsigned image URLs in your dashboard settings, set this to true
      --imagekit-private-key string                         You can find your ImageKit.io private key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys)
      --imagekit-public-key string                          You can find your ImageKit.io public key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys)
      --imagekit-upload-tags string                         Tags to add to the uploaded files, e.g. "tag1,tag2"
      --imagekit-versions                                   Include old versions in directory listings
      --internetarchive-access-key-id string                IAS3 Access Key
      --internetarchive-description string                  Description of the remote
      --internetarchive-disable-checksum                    Don't ask the server to test against MD5 checksum calculated by rclone (default true)
      --internetarchive-encoding Encoding                   The encoding for the backend (default Slash,LtGt,CrLf,Del,Ctl,InvalidUtf8,Dot)
      --internetarchive-endpoint string                     IAS3 Endpoint (default "https://s3.us.archive.org")
      --internetarchive-front-endpoint string               Host of InternetArchive Frontend (default "https://archive.org")
      --internetarchive-item-derive                         Whether to trigger derive on the IA item or not. If set to false, the item will not be derived by IA upon upload (default true)
      --internetarchive-item-metadata stringArray           Metadata to be set on the IA item, this is different from file-level metadata that can be set using --metadata-set
      --internetarchive-secret-access-key string            IAS3 Secret Key (password)
      --internetarchive-wait-archive Duration               Timeout for waiting the server's processing tasks (specifically archive and book_op) to finish (default 0s)
      --jottacloud-auth-url string                          Auth server URL
      --jottacloud-client-credentials                       Use client credentials OAuth flow
      --jottacloud-client-id string                         OAuth Client Id
      --jottacloud-client-secret string                     OAuth Client Secret
      --jottacloud-description string                       Description of the remote
      --jottacloud-encoding Encoding                        The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,Del,Ctl,InvalidUtf8,Dot)
      --jottacloud-hard-delete                              Delete files permanently rather than putting them into the trash
      --jottacloud-md5-memory-limit SizeSuffix              Files bigger than this will be cached on disk to calculate the MD5 if required (default 10Mi)
      --jottacloud-no-versions                              Avoid server side versioning by deleting files and recreating files instead of overwriting them
      --jottacloud-token string                             OAuth Access Token as a JSON blob
      --jottacloud-token-url string                         Token server url
      --jottacloud-trashed-only                             Only show files that are in the trash
      --jottacloud-upload-resume-limit SizeSuffix           Files bigger than this can be resumed if the upload fail's (default 10Mi)
      --koofr-description string                            Description of the remote
      --koofr-encoding Encoding                             The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot)
      --koofr-endpoint string                               The Koofr API endpoint to use
      --koofr-mountid string                                Mount ID of the mount to use
      --koofr-password string                               Your password for rclone generate one at https://app.koofr.net/app/admin/preferences/password (obscured)
      --koofr-provider string                               Choose your storage provider
      --koofr-setmtime                                      Does the backend support setting modification time (default true)
      --koofr-user string                                   Your user name
      --linkbox-description string                          Description of the remote
      --linkbox-token string                                Token from https://www.linkbox.to/admin/account
      --local-case-insensitive                              Force the filesystem to report itself as case insensitive
      --local-case-sensitive                                Force the filesystem to report itself as case sensitive
      --local-description string                            Description of the remote
      --local-encoding Encoding                             The encoding for the backend (default Slash,Dot)
      --local-hashes CommaSepList                           Comma separated list of supported checksum types
      --local-links                                         Translate symlinks to/from regular files with a '.rclonelink' extension for the local backend
      --local-no-check-updated                              Don't check to see if the files change during upload
      --local-no-clone                                      Disable reflink cloning for server-side copies
      --local-no-preallocate                                Disable preallocation of disk space for transferred files
      --local-no-set-modtime                                Disable setting modtime
      --local-no-sparse                                     Disable sparse files for multi-thread downloads
      --local-nounc                                         Disable UNC (long path names) conversion on Windows
      --local-time-type mtime|atime|btime|ctime             Set what kind of time is returned (default mtime)
      --local-unicode-normalization                         Apply unicode NFC normalization to paths and filenames
      --local-zero-size-links                               Assume the Stat size of links is zero (and read them instead) (deprecated)
      --mailru-auth-url string                              Auth server URL
      --mailru-check-hash                                   What should copy do if file checksum is mismatched or invalid (default true)
      --mailru-client-credentials                           Use client credentials OAuth flow
      --mailru-client-id string                             OAuth Client Id
      --mailru-client-secret string                         OAuth Client Secret
      --mailru-description string                           Description of the remote
      --mailru-encoding Encoding                            The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,InvalidUtf8,Dot)
      --mailru-pass string                                  Password (obscured)
      --mailru-speedup-enable                               Skip full upload if there is another file with same data hash (default true)
      --mailru-speedup-file-patterns string                 Comma separated list of file name patterns eligible for speedup (put by hash) (default "*.mkv,*.avi,*.mp4,*.mp3,*.zip,*.gz,*.rar,*.pdf")
      --mailru-speedup-max-disk SizeSuffix                  This option allows you to disable speedup (put by hash) for large files (default 3Gi)
      --mailru-speedup-max-memory SizeSuffix                Files larger than the size given below will always be hashed on disk (default 32Mi)
      --mailru-token string                                 OAuth Access Token as a JSON blob
      --mailru-token-url string                             Token server url
      --mailru-user string                                  User name (usually email)
      --mega-debug                                          Output more debug from Mega
      --mega-description string                             Description of the remote
      --mega-encoding Encoding                              The encoding for the backend (default Slash,InvalidUtf8,Dot)
      --mega-hard-delete                                    Delete files permanently rather than putting them into the trash
      --mega-pass string                                    Password (obscured)
      --mega-use-https                                      Use HTTPS for transfers
      --mega-user string                                    User name
      --memory-description string                           Description of the remote
      --netstorage-account string                           Set the NetStorage account name
      --netstorage-description string                       Description of the remote
      --netstorage-host string                              Domain+path of NetStorage host to connect to
      --netstorage-protocol string                          Select between HTTP or HTTPS protocol (default "https")
      --netstorage-secret string                            Set the NetStorage account secret/G2O key for authentication (obscured)
  -x, --one-file-system                                     Don't cross filesystem boundaries (unix/macOS only)
      --onedrive-access-scopes SpaceSepList                 Set scopes to be requested by rclone (default Files.Read Files.ReadWrite Files.Read.All Files.ReadWrite.All Sites.Read.All offline_access)
      --onedrive-auth-url string                            Auth server URL
      --onedrive-av-override                                Allows download of files the server thinks has a virus
      --onedrive-chunk-size SizeSuffix                      Chunk size to upload files with - must be multiple of 320k (327,680 bytes) (default 10Mi)
      --onedrive-client-credentials                         Use client credentials OAuth flow
      --onedrive-client-id string                           OAuth Client Id
      --onedrive-client-secret string                       OAuth Client Secret
      --onedrive-delta                                      If set rclone will use delta listing to implement recursive listings
      --onedrive-description string                         Description of the remote
      --onedrive-drive-id string                            The ID of the drive to use
      --onedrive-drive-type string                          The type of the drive (personal | business | documentLibrary)
      --onedrive-encoding Encoding                          The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,LeftSpace,LeftTilde,RightSpace,RightPeriod,InvalidUtf8,Dot)
      --onedrive-expose-onenote-files                       Set to make OneNote files show up in directory listings
      --onedrive-hard-delete                                Permanently delete files on removal
      --onedrive-hash-type string                           Specify the hash in use for the backend (default "auto")
      --onedrive-link-password string                       Set the password for links created by the link command
      --onedrive-link-scope string                          Set the scope of the links created by the link command (default "anonymous")
      --onedrive-link-type string                           Set the type of the links created by the link command (default "view")
      --onedrive-list-chunk int                             Size of listing chunk (default 1000)
      --onedrive-metadata-permissions Bits                  Control whether permissions should be read or written in metadata (default off)
      --onedrive-no-versions                                Remove all versions on modifying operations
      --onedrive-region string                              Choose national cloud region for OneDrive (default "global")
      --onedrive-root-folder-id string                      ID of the root folder
      --onedrive-server-side-across-configs                 Deprecated: use --server-side-across-configs instead
      --onedrive-tenant string                              ID of the service principal's tenant. Also called its directory ID
      --onedrive-token string                               OAuth Access Token as a JSON blob
      --onedrive-token-url string                           Token server url
      --onedrive-upload-cutoff SizeSuffix                   Cutoff for switching to chunked upload (default off)
      --oos-attempt-resume-upload                           If true attempt to resume previously started multipart upload for the object
      --oos-chunk-size SizeSuffix                           Chunk size to use for uploading (default 5Mi)
      --oos-compartment string                              Specify compartment OCID, if you need to list buckets
      --oos-config-file string                              Path to OCI config file (default "~/.oci/config")
      --oos-config-profile string                           Profile name inside the oci config file (default "Default")
      --oos-copy-cutoff SizeSuffix                          Cutoff for switching to multipart copy (default 4.656Gi)
      --oos-copy-timeout Duration                           Timeout for copy (default 1m0s)
      --oos-description string                              Description of the remote
      --oos-disable-checksum                                Don't store MD5 checksum with object metadata
      --oos-encoding Encoding                               The encoding for the backend (default Slash,InvalidUtf8,Dot)
      --oos-endpoint string                                 Endpoint for Object storage API
      --oos-leave-parts-on-error                            If true avoid calling abort upload on a failure, leaving all successfully uploaded parts for manual recovery
      --oos-max-upload-parts int                            Maximum number of parts in a multipart upload (default 10000)
      --oos-namespace string                                Object storage namespace
      --oos-no-check-bucket                                 If set, don't attempt to check the bucket exists or create it
      --oos-provider string                                 Choose your Auth Provider (default "env_auth")
      --oos-region string                                   Object storage Region
      --oos-sse-customer-algorithm string                   If using SSE-C, the optional header that specifies "AES256" as the encryption algorithm
      --oos-sse-customer-key string                         To use SSE-C, the optional header that specifies the base64-encoded 256-bit encryption key to use to
      --oos-sse-customer-key-file string                    To use SSE-C, a file containing the base64-encoded string of the AES-256 encryption key associated
      --oos-sse-customer-key-sha256 string                  If using SSE-C, The optional header that specifies the base64-encoded SHA256 hash of the encryption
      --oos-sse-kms-key-id string                           if using your own master key in vault, this header specifies the
      --oos-storage-tier string                             The storage class to use when storing new objects in storage. https://docs.oracle.com/en-us/iaas/Content/Object/Concepts/understandingstoragetiers.htm (default "Standard")
      --oos-upload-concurrency int                          Concurrency for multipart uploads (default 10)
      --oos-upload-cutoff SizeSuffix                        Cutoff for switching to chunked upload (default 200Mi)
      --opendrive-access string                             Files and folders will be uploaded with this access permission (default private) (default "private")
      --opendrive-chunk-size SizeSuffix                     Files will be uploaded in chunks this size (default 10Mi)
      --opendrive-description string                        Description of the remote
      --opendrive-encoding Encoding                         The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,LeftSpace,LeftCrLfHtVt,RightSpace,RightCrLfHtVt,InvalidUtf8,Dot)
      --opendrive-password string                           Password (obscured)
      --opendrive-username string                           Username
      --pcloud-auth-url string                              Auth server URL
      --pcloud-client-credentials                           Use client credentials OAuth flow
      --pcloud-client-id string                             OAuth Client Id
      --pcloud-client-secret string                         OAuth Client Secret
      --pcloud-description string                           Description of the remote
      --pcloud-encoding Encoding                            The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot)
      --pcloud-hostname string                              Hostname to connect to (default "api.pcloud.com")
      --pcloud-password string                              Your pcloud password (obscured)
      --pcloud-root-folder-id string                        Fill in for rclone to use a non root folder as its starting point (default "d0")
      --pcloud-token string                                 OAuth Access Token as a JSON blob
      --pcloud-token-url string                             Token server url
      --pcloud-username string                              Your pcloud username
      --pikpak-chunk-size SizeSuffix                        Chunk size for multipart uploads (default 5Mi)
      --pikpak-description string                           Description of the remote
      --pikpak-device-id string                             Device ID used for authorization
      --pikpak-encoding Encoding                            The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,LeftSpace,RightSpace,RightPeriod,InvalidUtf8,Dot)
      --pikpak-hash-memory-limit SizeSuffix                 Files bigger than this will be cached on disk to calculate hash if required (default 10Mi)
      --pikpak-no-media-link                                Use original file links instead of media links
      --pikpak-pass string                                  Pikpak password (obscured)
      --pikpak-root-folder-id string                        ID of the root folder
      --pikpak-trashed-only                                 Only show files that are in the trash
      --pikpak-upload-concurrency int                       Concurrency for multipart uploads (default 4)
      --pikpak-upload-cutoff SizeSuffix                     Cutoff for switching to chunked upload (default 200Mi)
      --pikpak-use-trash                                    Send files to the trash instead of deleting permanently (default true)
      --pikpak-user string                                  Pikpak username
      --pikpak-user-agent string                            HTTP user agent for pikpak (default "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:129.0) Gecko/20100101 Firefox/129.0")
      --pixeldrain-api-key string                           API key for your pixeldrain account
      --pixeldrain-api-url string                           The API endpoint to connect to. In the vast majority of cases it's fine to leave (default "https://pixeldrain.com/api")
      --pixeldrain-description string                       Description of the remote
      --pixeldrain-root-folder-id string                    Root of the filesystem to use (default "me")
      --premiumizeme-auth-url string                        Auth server URL
      --premiumizeme-client-credentials                     Use client credentials OAuth flow
      --premiumizeme-client-id string                       OAuth Client Id
      --premiumizeme-client-secret string                   OAuth Client Secret
      --premiumizeme-description string                     Description of the remote
      --premiumizeme-encoding Encoding                      The encoding for the backend (default Slash,DoubleQuote,BackSlash,Del,Ctl,InvalidUtf8,Dot)
      --premiumizeme-token string                           OAuth Access Token as a JSON blob
      --premiumizeme-token-url string                       Token server url
      --protondrive-2fa string                              The 2FA code
      --protondrive-app-version string                      The app version string (default "macos-drive@1.0.0-alpha.1+rclone")
      --protondrive-description string                      Description of the remote
      --protondrive-enable-caching                          Caches the files and folders metadata to reduce API calls (default true)
      --protondrive-encoding Encoding                       The encoding for the backend (default Slash,LeftSpace,RightSpace,InvalidUtf8,Dot)
      --protondrive-mailbox-password string                 The mailbox password of your two-password proton account (obscured)
      --protondrive-original-file-size                      Return the file size before encryption (default true)
      --protondrive-password string                         The password of your proton account (obscured)
      --protondrive-replace-existing-draft                  Create a new revision when filename conflict is detected
      --protondrive-username string                         The username of your proton account
      --putio-auth-url string                               Auth server URL
      --putio-client-credentials                            Use client credentials OAuth flow
      --putio-client-id string                              OAuth Client Id
      --putio-client-secret string                          OAuth Client Secret
      --putio-description string                            Description of the remote
      --putio-encoding Encoding                             The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot)
      --putio-token string                                  OAuth Access Token as a JSON blob
      --putio-token-url string                              Token server url
      --qingstor-access-key-id string                       QingStor Access Key ID
      --qingstor-chunk-size SizeSuffix                      Chunk size to use for uploading (default 4Mi)
      --qingstor-connection-retries int                     Number of connection retries (default 3)
      --qingstor-description string                         Description of the remote
      --qingstor-encoding Encoding                          The encoding for the backend (default Slash,Ctl,InvalidUtf8)
      --qingstor-endpoint string                            Enter an endpoint URL to connection QingStor API
      --qingstor-env-auth                                   Get QingStor credentials from runtime
      --qingstor-secret-access-key string                   QingStor Secret Access Key (password)
      --qingstor-upload-concurrency int                     Concurrency for multipart uploads (default 1)
      --qingstor-upload-cutoff SizeSuffix                   Cutoff for switching to chunked upload (default 200Mi)
      --qingstor-zone string                                Zone to connect to
      --quatrix-api-key string                              API key for accessing Quatrix account
      --quatrix-description string                          Description of the remote
      --quatrix-effective-upload-time string                Wanted upload time for one chunk (default "4s")
      --quatrix-encoding Encoding                           The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot)
      --quatrix-hard-delete                                 Delete files permanently rather than putting them into the trash
      --quatrix-host string                                 Host name of Quatrix account
      --quatrix-maximal-summary-chunk-size SizeSuffix       The maximal summary for all chunks. It should not be less than 'transfers'*'minimal_chunk_size' (default 95.367Mi)
      --quatrix-minimal-chunk-size SizeSuffix               The minimal size for one chunk (default 9.537Mi)
      --quatrix-skip-project-folders                        Skip project folders in operations
      --s3-access-key-id string                             AWS Access Key ID
      --s3-acl string                                       Canned ACL used when creating buckets and storing or copying objects
      --s3-bucket-acl string                                Canned ACL used when creating buckets
      --s3-chunk-size SizeSuffix                            Chunk size to use for uploading (default 5Mi)
      --s3-copy-cutoff SizeSuffix                           Cutoff for switching to multipart copy (default 4.656Gi)
      --s3-decompress                                       If set this will decompress gzip encoded objects
      --s3-description string                               Description of the remote
      --s3-directory-bucket                                 Set to use AWS Directory Buckets
      --s3-directory-markers                                Upload an empty object with a trailing slash when a new directory is created
      --s3-disable-checksum                                 Don't store MD5 checksum with object metadata
      --s3-disable-http2                                    Disable usage of http2 for S3 backends
      --s3-download-url string                              Custom endpoint for downloads
      --s3-encoding Encoding                                The encoding for the backend (default Slash,InvalidUtf8,Dot)
      --s3-endpoint string                                  Endpoint for S3 API
      --s3-env-auth                                         Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars)
      --s3-force-path-style                                 If true use path style access if false use virtual hosted style (default true)
      --s3-ibm-api-key string                               IBM API Key to be used to obtain IAM token
      --s3-ibm-resource-instance-id string                  IBM service instance id
      --s3-leave-parts-on-error                             If true avoid calling abort upload on a failure, leaving all successfully uploaded parts on S3 for manual recovery
      --s3-list-chunk int                                   Size of listing chunk (response list for each ListObject S3 request) (default 1000)
      --s3-list-url-encode Tristate                         Whether to url encode listings: true/false/unset (default unset)
      --s3-list-version int                                 Version of ListObjects to use: 1,2 or 0 for auto
      --s3-location-constraint string                       Location constraint - must be set to match the Region
      --s3-max-upload-parts int                             Maximum number of parts in a multipart upload (default 10000)
      --s3-might-gzip Tristate                              Set this if the backend might gzip objects (default unset)
      --s3-no-check-bucket                                  If set, don't attempt to check the bucket exists or create it
      --s3-no-head                                          If set, don't HEAD uploaded objects to check integrity
      --s3-no-head-object                                   If set, do not do HEAD before GET when getting objects
      --s3-no-system-metadata                               Suppress setting and reading of system metadata
      --s3-profile string                                   Profile to use in the shared credentials file
      --s3-provider string                                  Choose your S3 provider
      --s3-region string                                    Region to connect to
      --s3-requester-pays                                   Enables requester pays option when interacting with S3 bucket
      --s3-sdk-log-mode Bits                                Set to debug the SDK (default Off)
      --s3-secret-access-key string                         AWS Secret Access Key (password)
      --s3-server-side-encryption string                    The server-side encryption algorithm used when storing this object in S3
      --s3-session-token string                             An AWS session token
      --s3-shared-credentials-file string                   Path to the shared credentials file
      --s3-sign-accept-encoding Tristate                    Set if rclone should include Accept-Encoding as part of the signature (default unset)
      --s3-sse-customer-algorithm string                    If using SSE-C, the server-side encryption algorithm used when storing this object in S3
      --s3-sse-customer-key string                          To use SSE-C you may provide the secret encryption key used to encrypt/decrypt your data
      --s3-sse-customer-key-base64 string                   If using SSE-C you must provide the secret encryption key encoded in base64 format to encrypt/decrypt your data
      --s3-sse-customer-key-md5 string                      If using SSE-C you may provide the secret encryption key MD5 checksum (optional)
      --s3-sse-kms-key-id string                            If using KMS ID you must provide the ARN of Key
      --s3-storage-class string                             The storage class to use when storing new objects in S3
      --s3-upload-concurrency int                           Concurrency for multipart uploads and copies (default 4)
      --s3-upload-cutoff SizeSuffix                         Cutoff for switching to chunked upload (default 200Mi)
      --s3-use-accelerate-endpoint                          If true use the AWS S3 accelerated endpoint
      --s3-use-accept-encoding-gzip Accept-Encoding: gzip   Whether to send Accept-Encoding: gzip header (default unset)
      --s3-use-already-exists Tristate                      Set if rclone should report BucketAlreadyExists errors on bucket creation (default unset)
      --s3-use-arn-region                                   If true, enables arn region support for the service
      --s3-use-dual-stack                                   If true use AWS S3 dual-stack endpoint (IPv6 support)
      --s3-use-multipart-etag Tristate                      Whether to use ETag in multipart uploads for verification (default unset)
      --s3-use-multipart-uploads Tristate                   Set if rclone should use multipart uploads (default unset)
      --s3-use-presigned-request                            Whether to use a presigned request or PutObject for single part uploads
      --s3-use-unsigned-payload Tristate                    Whether to use an unsigned payload in PutObject (default unset)
      --s3-use-x-id Tristate                                Set if rclone should add x-id URL parameters (default unset)
      --s3-v2-auth                                          If true use v2 authentication
      --s3-version-at Time                                  Show file versions as they were at the specified time (default off)
      --s3-version-deleted                                  Show deleted file markers when using versions
      --s3-versions                                         Include old versions in directory listings
      --seafile-2fa                                         Two-factor authentication ('true' if the account has 2FA enabled)
      --seafile-create-library                              Should rclone create a library if it doesn't exist
      --seafile-description string                          Description of the remote
      --seafile-encoding Encoding                           The encoding for the backend (default Slash,DoubleQuote,BackSlash,Ctl,InvalidUtf8,Dot)
      --seafile-library string                              Name of the library
      --seafile-library-key string                          Library password (for encrypted libraries only) (obscured)
      --seafile-pass string                                 Password (obscured)
      --seafile-url string                                  URL of seafile host to connect to
      --seafile-user string                                 User name (usually email address)
      --sftp-ask-password                                   Allow asking for SFTP password when needed
      --sftp-blake3sum-command string                       The command used to read BLAKE3 hashes
      --sftp-chunk-size SizeSuffix                          Upload and download chunk size (default 32Ki)
      --sftp-ciphers SpaceSepList                           Space separated list of ciphers to be used for session encryption, ordered by preference
      --sftp-concurrency int                                The maximum number of outstanding requests for one file (default 64)
      --sftp-connections int                                Maximum number of SFTP simultaneous connections, 0 for unlimited
      --sftp-copy-is-hardlink                               Set to enable server side copies using hardlinks
      --sftp-crc32sum-command string                        The command used to read CRC-32 hashes
      --sftp-description string                             Description of the remote
      --sftp-disable-concurrent-reads                       If set don't use concurrent reads
      --sftp-disable-concurrent-writes                      If set don't use concurrent writes
      --sftp-disable-hashcheck                              Disable the execution of SSH commands to determine if remote file hashing is available
      --sftp-hashes CommaSepList                            Comma separated list of supported checksum types
      --sftp-host string                                    SSH host to connect to
      --sftp-host-key-algorithms SpaceSepList               Space separated list of host key algorithms, ordered by preference
      --sftp-http-proxy string                              URL for HTTP CONNECT proxy
      --sftp-idle-timeout Duration                          Max time before closing idle connections (default 1m0s)
      --sftp-key-exchange SpaceSepList                      Space separated list of key exchange algorithms, ordered by preference
      --sftp-key-file string                                Path to PEM-encoded private key file
      --sftp-key-file-pass string                           The passphrase to decrypt the PEM-encoded private key file (obscured)
      --sftp-key-pem string                                 Raw PEM-encoded private key
      --sftp-key-use-agent                                  When set forces the usage of the ssh-agent
      --sftp-known-hosts-file string                        Optional path to known_hosts file
      --sftp-macs SpaceSepList                              Space separated list of MACs (message authentication code) algorithms, ordered by preference
      --sftp-md5sum-command string                          The command used to read MD5 hashes
      --sftp-pass string                                    SSH password, leave blank to use ssh-agent (obscured)
      --sftp-path-override string                           Override path used by SSH shell commands
      --sftp-port int                                       SSH port number (default 22)
      --sftp-pubkey string                                  SSH public certificate for public certificate based authentication
      --sftp-pubkey-file string                             Optional path to public key file
      --sftp-server-command string                          Specifies the path or command to run a sftp server on the remote host
      --sftp-set-env SpaceSepList                           Environment variables to pass to sftp and commands
      --sftp-set-modtime                                    Set the modified time on the remote if set (default true)
      --sftp-sha1sum-command string                         The command used to read SHA-1 hashes
      --sftp-sha256sum-command string                       The command used to read SHA-256 hashes
      --sftp-shell-type string                              The type of SSH shell on remote server, if any
      --sftp-skip-links                                     Set to skip any symlinks and any other non regular files
      --sftp-socks-proxy string                             Socks 5 proxy host
      --sftp-ssh SpaceSepList                               Path and arguments to external ssh binary
      --sftp-subsystem string                               Specifies the SSH2 subsystem on the remote host (default "sftp")
      --sftp-use-fstat                                      If set use fstat instead of stat
      --sftp-use-insecure-cipher                            Enable the use of insecure ciphers and key exchange methods
      --sftp-user string                                    SSH username (default "$USER")
      --sftp-xxh128sum-command string                       The command used to read XXH128 hashes
      --sftp-xxh3sum-command string                         The command used to read XXH3 hashes
      --sharefile-auth-url string                           Auth server URL
      --sharefile-chunk-size SizeSuffix                     Upload chunk size (default 64Mi)
      --sharefile-client-credentials                        Use client credentials OAuth flow
      --sharefile-client-id string                          OAuth Client Id
      --sharefile-client-secret string                      OAuth Client Secret
      --sharefile-description string                        Description of the remote
      --sharefile-encoding Encoding                         The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,LeftSpace,LeftPeriod,RightSpace,RightPeriod,InvalidUtf8,Dot)
      --sharefile-endpoint string                           Endpoint for API calls
      --sharefile-root-folder-id string                     ID of the root folder
      --sharefile-token string                              OAuth Access Token as a JSON blob
      --sharefile-token-url string                          Token server url
      --sharefile-upload-cutoff SizeSuffix                  Cutoff for switching to multipart upload (default 128Mi)
      --sia-api-password string                             Sia Daemon API Password (obscured)
      --sia-api-url string                                  Sia daemon API URL, like http://sia.daemon.host:9980 (default "http://127.0.0.1:9980")
      --sia-description string                              Description of the remote
      --sia-encoding Encoding                               The encoding for the backend (default Slash,Question,Hash,Percent,Del,Ctl,InvalidUtf8,Dot)
      --sia-user-agent string                               Siad User Agent (default "Sia-Agent")
      --skip-links                                          Don't warn about skipped symlinks
      --smb-case-insensitive                                Whether the server is configured to be case-insensitive (default true)
      --smb-description string                              Description of the remote
      --smb-domain string                                   Domain name for NTLM authentication (default "WORKGROUP")
      --smb-encoding Encoding                               The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot)
      --smb-hide-special-share                              Hide special shares (e.g. print$) which users aren't supposed to access (default true)
      --smb-host string                                     SMB server hostname to connect to
      --smb-idle-timeout Duration                           Max time before closing idle connections (default 1m0s)
      --smb-kerberos-ccache string                          Path to the Kerberos credential cache (krb5cc)
      --smb-pass string                                     SMB password (obscured)
      --smb-port int                                        SMB port number (default 445)
      --smb-spn string                                      Service principal name
      --smb-use-kerberos                                    Use Kerberos authentication
      --smb-user string                                     SMB username (default "$USER")
      --storj-access-grant string                           Access grant
      --storj-api-key string                                API key
      --storj-description string                            Description of the remote
      --storj-passphrase string                             Encryption passphrase
      --storj-provider string                               Choose an authentication method (default "existing")
      --storj-satellite-address string                      Satellite address (default "us1.storj.io")
      --sugarsync-access-key-id string                      Sugarsync Access Key ID
      --sugarsync-app-id string                             Sugarsync App ID
      --sugarsync-authorization string                      Sugarsync authorization
      --sugarsync-authorization-expiry string               Sugarsync authorization expiry
      --sugarsync-deleted-id string                         Sugarsync deleted folder id
      --sugarsync-description string                        Description of the remote
      --sugarsync-encoding Encoding                         The encoding for the backend (default Slash,Ctl,InvalidUtf8,Dot)
      --sugarsync-hard-delete                               Permanently delete files if true
      --sugarsync-private-access-key string                 Sugarsync Private Access Key
      --sugarsync-refresh-token string                      Sugarsync refresh token
      --sugarsync-root-id string                            Sugarsync root id
      --sugarsync-user string                               Sugarsync user
      --swift-application-credential-id string              Application Credential ID (OS_APPLICATION_CREDENTIAL_ID)
      --swift-application-credential-name string            Application Credential Name (OS_APPLICATION_CREDENTIAL_NAME)
      --swift-application-credential-secret string          Application Credential Secret (OS_APPLICATION_CREDENTIAL_SECRET)
      --swift-auth string                                   Authentication URL for server (OS_AUTH_URL)
      --swift-auth-token string                             Auth Token from alternate authentication - optional (OS_AUTH_TOKEN)
      --swift-auth-version int                              AuthVersion - optional - set to (1,2,3) if your auth URL has no version (ST_AUTH_VERSION)
      --swift-chunk-size SizeSuffix                         Above this size files will be chunked (default 5Gi)
      --swift-description string                            Description of the remote
      --swift-domain string                                 User domain - optional (v3 auth) (OS_USER_DOMAIN_NAME)
      --swift-encoding Encoding                             The encoding for the backend (default Slash,InvalidUtf8)
      --swift-endpoint-type string                          Endpoint type to choose from the service catalogue (OS_ENDPOINT_TYPE) (default "public")
      --swift-env-auth                                      Get swift credentials from environment variables in standard OpenStack form
      --swift-fetch-until-empty-page                        When paginating, always fetch unless we received an empty page
      --swift-key string                                    API key or password (OS_PASSWORD)
      --swift-leave-parts-on-error                          If true avoid calling abort upload on a failure
      --swift-no-chunk                                      Don't chunk files during streaming upload
      --swift-no-large-objects                              Disable support for static and dynamic large objects
      --swift-partial-page-fetch-threshold int              When paginating, fetch if the current page is within this percentage of the limit
      --swift-region string                                 Region name - optional (OS_REGION_NAME)
      --swift-storage-policy string                         The storage policy to use when creating a new container
      --swift-storage-url string                            Storage URL - optional (OS_STORAGE_URL)
      --swift-tenant string                                 Tenant name - optional for v1 auth, this or tenant_id required otherwise (OS_TENANT_NAME or OS_PROJECT_NAME)
      --swift-tenant-domain string                          Tenant domain - optional (v3 auth) (OS_PROJECT_DOMAIN_NAME)
      --swift-tenant-id string                              Tenant ID - optional for v1 auth, this or tenant required otherwise (OS_TENANT_ID)
      --swift-use-segments-container Tristate               Choose destination for large object segments (default unset)
      --swift-user string                                   User name to log in (OS_USERNAME)
      --swift-user-id string                                User ID to log in - optional - most swift systems use user and leave this blank (v3 auth) (OS_USER_ID)
      --ulozto-app-token string                             The application token identifying the app. An app API key can be either found in the API
      --ulozto-description string                           Description of the remote
      --ulozto-encoding Encoding                            The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot)
      --ulozto-list-page-size int                           The size of a single page for list commands. 1-500 (default 500)
      --ulozto-password string                              The password for the user (obscured)
      --ulozto-root-folder-slug string                      If set, rclone will use this folder as the root folder for all operations. For example,
      --ulozto-username string                              The username of the principal to operate as
      --union-action-policy string                          Policy to choose upstream on ACTION category (default "epall")
      --union-cache-time int                                Cache time of usage and free space (in seconds) (default 120)
      --union-create-policy string                          Policy to choose upstream on CREATE category (default "epmfs")
      --union-description string                            Description of the remote
      --union-min-free-space SizeSuffix                     Minimum viable free space for lfs/eplfs policies (default 1Gi)
      --union-search-policy string                          Policy to choose upstream on SEARCH category (default "ff")
      --union-upstreams string                              List of space separated upstreams
      --uptobox-access-token string                         Your access token
      --uptobox-description string                          Description of the remote
      --uptobox-encoding Encoding                           The encoding for the backend (default Slash,LtGt,DoubleQuote,BackQuote,Del,Ctl,LeftSpace,InvalidUtf8,Dot)
      --uptobox-private                                     Set to make uploaded files private
      --webdav-auth-redirect                                Preserve authentication on redirect
      --webdav-bearer-token string                          Bearer token instead of user/pass (e.g. a Macaroon)
      --webdav-bearer-token-command string                  Command to run to get a bearer token
      --webdav-description string                           Description of the remote
      --webdav-encoding string                              The encoding for the backend
      --webdav-headers CommaSepList                         Set HTTP headers for all transactions
      --webdav-nextcloud-chunk-size SizeSuffix              Nextcloud upload chunk size (default 10Mi)
      --webdav-owncloud-exclude-mounts                      Exclude ownCloud mounted storages
      --webdav-owncloud-exclude-shares                      Exclude ownCloud shares
      --webdav-pacer-min-sleep Duration                     Minimum time to sleep between API calls (default 10ms)
      --webdav-pass string                                  Password (obscured)
      --webdav-unix-socket string                           Path to a unix domain socket to dial to, instead of opening a TCP connection directly
      --webdav-url string                                   URL of http host to connect to
      --webdav-user string                                  User name
      --webdav-vendor string                                Name of the WebDAV site/service/software you are using
      --yandex-auth-url string                              Auth server URL
      --yandex-client-credentials                           Use client credentials OAuth flow
      --yandex-client-id string                             OAuth Client Id
      --yandex-client-secret string                         OAuth Client Secret
      --yandex-description string                           Description of the remote
      --yandex-encoding Encoding                            The encoding for the backend (default Slash,Del,Ctl,InvalidUtf8,Dot)
      --yandex-hard-delete                                  Delete files permanently rather than putting them into the trash
      --yandex-spoof-ua                                     Set the user agent to match an official version of the yandex disk client. May help with upload performance (default true)
      --yandex-token string                                 OAuth Access Token as a JSON blob
      --yandex-token-url string                             Token server url
      --zoho-auth-url string                                Auth server URL
      --zoho-client-credentials                             Use client credentials OAuth flow
      --zoho-client-id string                               OAuth Client Id
      --zoho-client-secret string                           OAuth Client Secret
      --zoho-description string                             Description of the remote
      --zoho-encoding Encoding                              The encoding for the backend (default Del,Ctl,InvalidUtf8)
      --zoho-region string                                  Zoho region to connect to
      --zoho-token string                                   OAuth Access Token as a JSON blob
      --zoho-token-url string                               Token server url
      --zoho-upload-cutoff SizeSuffix                       Cutoff for switching to large file upload api (>= 10 MiB) (default 10Mi)

Docker Volume Plugin

Introduction

Docker 1.9 has added support for creating named volumes via command-line interface and mounting them in containers as a way to share data between them. Since Docker 1.10 you can create named volumes with Docker Compose by descriptions in docker-compose.yml files for use by container groups on a single host. As of Docker 1.12 volumes are supported by Docker Swarm included with Docker Engine and created from descriptions in swarm compose v3 files for use with swarm stacks across multiple cluster nodes.

Docker Volume Plugins augment the default local volume driver included in Docker with stateful volumes shared across containers and hosts. Unlike local volumes, your data will not be deleted when such volume is removed. Plugins can run managed by the docker daemon, as a native system service (under systemd, sysv or upstart) or as a standalone executable. Rclone can run as docker volume plugin in all these modes. It interacts with the local docker daemon via plugin API and handles mounting of remote file systems into docker containers so it must run on the same host as the docker daemon or on every Swarm node.

Getting started

In the first example we will use the SFTP rclone volume with Docker engine on a standalone Ubuntu machine.

Start from installing Docker on the host.

The FUSE driver is a prerequisite for rclone mounting and should be installed on host:

sudo apt-get -y install fuse3

Create two directories required by rclone docker plugin:

sudo mkdir -p /var/lib/docker-plugins/rclone/config
sudo mkdir -p /var/lib/docker-plugins/rclone/cache

Install the managed rclone docker plugin for your architecture (here amd64):

docker plugin install rclone/docker-volume-rclone:amd64 args="-v" --alias rclone --grant-all-permissions
docker plugin list

Create your SFTP volume:

docker volume create firstvolume -d rclone -o type=sftp -o sftp-host=_hostname_ -o sftp-user=_username_ -o sftp-pass=_password_ -o allow-other=true

Note that since all options are static, you don't even have to run rclone config or create the rclone.conf file (but the config directory should still be present). In the simplest case you can use localhost as hostname and your SSH credentials as username and password. You can also change the remote path to your home directory on the host, for example -o path=/home/username.

Time to create a test container and mount the volume into it:

docker run --rm -it -v firstvolume:/mnt --workdir /mnt ubuntu:latest bash

If all goes well, you will enter the new container and change right to the mounted SFTP remote. You can type ls to list the mounted directory or otherwise play with it. Type exit when you are done. The container will stop but the volume will stay, ready to be reused. When it's not needed anymore, remove it:

docker volume list
docker volume remove firstvolume

Now let us try something more elaborate: Google Drive volume on multi-node Docker Swarm.

You should start from installing Docker and FUSE, creating plugin directories and installing rclone plugin on every swarm node. Then setup the Swarm.

Google Drive volumes need an access token which can be setup via web browser and will be periodically renewed by rclone. The managed plugin cannot run a browser so we will use a technique similar to the rclone setup on a headless box.

Run rclone config on another machine equipped with web browser and graphical user interface. Create the Google Drive remote. When done, transfer the resulting rclone.conf to the Swarm cluster and save as /var/lib/docker-plugins/rclone/config/rclone.conf on every node. By default this location is accessible only to the root user so you will need appropriate privileges. The resulting config will look like this:

[gdrive]
type = drive
scope = drive
drive_id = 1234567...
root_folder_id = 0Abcd...
token = {"access_token":...}

Now create the file named example.yml with a swarm stack description like this:

version: '3'
services:
  heimdall:
    image: linuxserver/heimdall:latest
    ports: [8080:80]
    volumes: [configdata:/config]
volumes:
  configdata:
    driver: rclone
    driver_opts:
      remote: 'gdrive:heimdall'
      allow_other: 'true'
      vfs_cache_mode: full
      poll_interval: 0

and run the stack:

docker stack deploy example -c ./example.yml

After a few seconds docker will spread the parsed stack description over cluster, create the example_heimdall service on port 8080, run service containers on one or more cluster nodes and request the example_configdata volume from rclone plugins on the node hosts. You can use the following commands to confirm results:

docker service ls
docker service ps example_heimdall
docker volume ls

Point your browser to http://cluster.host.address:8080 and play with the service. Stop it with docker stack remove example when you are done. Note that the example_configdata volume(s) created on demand at the cluster nodes will not be automatically removed together with the stack but stay for future reuse. You can remove them manually by invoking the docker volume remove example_configdata command on every node.

Creating Volumes via CLI

Volumes can be created with docker volume create. Here are a few examples:

docker volume create vol1 -d rclone -o remote=storj: -o vfs-cache-mode=full
docker volume create vol2 -d rclone -o remote=:storj,access_grant=xxx:heimdall
docker volume create vol3 -d rclone -o type=storj -o path=heimdall -o storj-access-grant=xxx -o poll-interval=0

Note the -d rclone flag that tells docker to request volume from the rclone driver. This works even if you installed managed driver by its full name rclone/docker-volume-rclone because you provided the --alias rclone option.

Volumes can be inspected as follows:

docker volume list
docker volume inspect vol1

Volume Configuration

Rclone flags and volume options are set via the -o flag to the docker volume create command. They include backend-specific parameters as well as mount and VFS options. Also there are a few special -o options: remote, fs, type, path, mount-type and persist.

remote determines an existing remote name from the config file, with trailing colon and optionally with a remote path. See the full syntax in the rclone documentation. This option can be aliased as fs to prevent confusion with the remote parameter of such backends as crypt or alias.

The remote=:backend:dir/subdir syntax can be used to create on-the-fly (config-less) remotes, while the type and path options provide a simpler alternative for this. Using two split options

-o type=backend -o path=dir/subdir

is equivalent to the combined syntax

-o remote=:backend:dir/subdir

but is arguably easier to parameterize in scripts. The path part is optional.

Mount and VFS options as well as backend parameters are named like their twin command-line flags without the -- CLI prefix. Optionally you can use underscores instead of dashes in option names. For example, --vfs-cache-mode full becomes -o vfs-cache-mode=full or -o vfs_cache_mode=full. Boolean CLI flags without value will gain the true value, e.g. --allow-other becomes -o allow-other=true or -o allow_other=true.

Please note that you can provide parameters only for the backend immediately referenced by the backend type of mounted remote. If this is a wrapping backend like alias, chunker or crypt, you cannot provide options for the referred to remote or backend. This limitation is imposed by the rclone connection string parser. The only workaround is to feed plugin with rclone.conf or configure plugin arguments (see below).

Special Volume Options

mount-type determines the mount method and in general can be one of: mount, cmount, or mount2. This can be aliased as mount_type. It should be noted that the managed rclone docker plugin currently does not support the cmount method and mount2 is rarely needed. This option defaults to the first found method, which is usually mount so you generally won't need it.

persist is a reserved boolean (true/false) option. In future it will allow to persist on-the-fly remotes in the plugin rclone.conf file.

Connection Strings

The remote value can be extended with connection strings as an alternative way to supply backend parameters. This is equivalent to the -o backend options with one syntactic difference. Inside connection string the backend prefix must be dropped from parameter names but in the -o param=value array it must be present. For instance, compare the following option array

-o remote=:sftp:/home -o sftp-host=localhost

with equivalent connection string:

-o remote=:sftp,host=localhost:/home

This difference exists because flag options -o key=val include not only backend parameters but also mount/VFS flags and possibly other settings. Also it allows to discriminate the remote option from the crypt-remote (or similarly named backend parameters) and arguably simplifies scripting due to clearer value substitution.

Using with Swarm or Compose

Both Docker Swarm and Docker Compose use YAML-formatted text files to describe groups (stacks) of containers, their properties, networks and volumes. Compose uses the compose v2 format, Swarm uses the compose v3 format. They are mostly similar, differences are explained in the docker documentation.

Volumes are described by the children of the top-level volumes: node. Each of them should be named after its volume and have at least two elements, the self-explanatory driver: rclone value and the driver_opts: structure playing the same role as -o key=val CLI flags:

volumes:
  volume_name_1:
    driver: rclone
    driver_opts:
      remote: 'gdrive:'
      allow_other: 'true'
      vfs_cache_mode: full
      token: '{"type": "borrower", "expires": "2021-12-31"}'
      poll_interval: 0

Notice a few important details: - YAML prefers _ in option names instead of -. - YAML treats single and double quotes interchangeably. Simple strings and integers can be left unquoted. - Boolean values must be quoted like 'true' or "false" because these two words are reserved by YAML. - The filesystem string is keyed with remote (or with fs). Normally you can omit quotes here, but if the string ends with colon, you must quote it like remote: "storage_box:". - YAML is picky about surrounding braces in values as this is in fact another syntax for key/value mappings. For example, JSON access tokens usually contain double quotes and surrounding braces, so you must put them in single quotes.

Installing as Managed Plugin

Docker daemon can install plugins from an image registry and run them managed. We maintain the docker-volume-rclone plugin image on Docker Hub.

Rclone volume plugin requires Docker Engine >= 19.03.15

The plugin requires presence of two directories on the host before it can be installed. Note that plugin will not create them automatically. By default they must exist on host at the following locations (though you can tweak the paths): - /var/lib/docker-plugins/rclone/config is reserved for the rclone.conf config file and must exist even if it's empty and the config file is not present. - /var/lib/docker-plugins/rclone/cache holds the plugin state file as well as optional VFS caches.

You can install managed plugin with default settings as follows:

docker plugin install rclone/docker-volume-rclone:amd64 --grant-all-permissions --alias rclone

The :amd64 part of the image specification after colon is called a tag. Usually you will want to install the latest plugin for your architecture. In this case the tag will just name it, like amd64 above. The following plugin architectures are currently available: - amd64 - arm64 - arm-v7

Sometimes you might want a concrete plugin version, not the latest one. Then you should use image tag in the form :ARCHITECTURE-VERSION. For example, to install plugin version v1.56.2 on architecture arm64 you will use tag arm64-1.56.2 (note the removed v) so the full image specification becomes rclone/docker-volume-rclone:arm64-1.56.2.

We also provide the latest plugin tag, but since docker does not support multi-architecture plugins as of the time of this writing, this tag is currently an alias for amd64. By convention the latest tag is the default one and can be omitted, thus both rclone/docker-volume-rclone:latest and just rclone/docker-volume-rclone will refer to the latest plugin release for the amd64 platform.

Also the amd64 part can be omitted from the versioned rclone plugin tags. For example, rclone image reference rclone/docker-volume-rclone:amd64-1.56.2 can be abbreviated as rclone/docker-volume-rclone:1.56.2 for convenience. However, for non-intel architectures you still have to use the full tag as amd64 or latest will fail to start.

Managed plugin is in fact a special container running in a namespace separate from normal docker containers. Inside it runs the rclone serve docker command. The config and cache directories are bind-mounted into the container at start. The docker daemon connects to a unix socket created by the command inside the container. The command creates on-demand remote mounts right inside, then docker machinery propagates them through kernel mount namespaces and bind-mounts into requesting user containers.

You can tweak a few plugin settings after installation when it's disabled (not in use), for instance:

docker plugin disable rclone
docker plugin set rclone RCLONE_VERBOSE=2 config=/etc/rclone args="--vfs-cache-mode=writes --allow-other"
docker plugin enable rclone
docker plugin inspect rclone

Note that if docker refuses to disable the plugin, you should find and remove all active volumes connected with it as well as containers and swarm services that use them. This is rather tedious so please carefully plan in advance.

You can tweak the following settings: args, config, cache, HTTP_PROXY, HTTPS_PROXY, NO_PROXY and RCLONE_VERBOSE. It's your task to keep plugin settings in sync across swarm cluster nodes.

args sets command-line arguments for the rclone serve docker command (none by default). Arguments should be separated by space so you will normally want to put them in quotes on the docker plugin set command line. Both serve docker flags and generic rclone flags are supported, including backend parameters that will be used as defaults for volume creation. Note that plugin will fail (due to this docker bug) if the args value is empty. Use e.g. args="-v" as a workaround.

config=/host/dir sets alternative host location for the config directory. Plugin will look for rclone.conf here. It's not an error if the config file is not present but the directory must exist. Please note that plugin can periodically rewrite the config file, for example when it renews storage access tokens. Keep this in mind and try to avoid races between the plugin and other instances of rclone on the host that might try to change the config simultaneously resulting in corrupted rclone.conf. You can also put stuff like private key files for SFTP remotes in this directory. Just note that it's bind-mounted inside the plugin container at the predefined path /data/config. For example, if your key file is named sftp-box1.key on the host, the corresponding volume config option should read -o sftp-key-file=/data/config/sftp-box1.key.

cache=/host/dir sets alternative host location for the cache directory. The plugin will keep VFS caches here. Also it will create and maintain the docker-plugin.state file in this directory. When the plugin is restarted or reinstalled, it will look in this file to recreate any volumes that existed previously. However, they will not be re-mounted into consuming containers after restart. Usually this is not a problem as the docker daemon normally will restart affected user containers after failures, daemon restarts or host reboots.

RCLONE_VERBOSE sets plugin verbosity from 0 (errors only, by default) to 2 (debugging). Verbosity can be also tweaked via args="-v [-v] ...". Since arguments are more generic, you will rarely need this setting. The plugin output by default feeds the docker daemon log on local host. Log entries are reflected as errors in the docker log but retain their actual level assigned by rclone in the encapsulated message string.

HTTP_PROXY, HTTPS_PROXY, NO_PROXY customize the plugin proxy settings.

You can set custom plugin options right when you install it, in one go:

docker plugin remove rclone
docker plugin install rclone/docker-volume-rclone:amd64 \
       --alias rclone --grant-all-permissions \
       args="-v --allow-other" config=/etc/rclone
docker plugin inspect rclone

Healthchecks

The docker plugin volume protocol doesn't provide a way for plugins to inform the docker daemon that a volume is (un-)available. As a workaround you can setup a healthcheck to verify that the mount is responding, for example:

services:
  my_service:
    image: my_image
    healthcheck:
      test: ls /path/to/rclone/mount || exit 1
      interval: 1m
      timeout: 15s
      retries: 3
      start_period: 15s

Running Plugin under Systemd

In most cases you should prefer managed mode. Moreover, MacOS and Windows do not support native Docker plugins. Please use managed mode on these systems. Proceed further only if you are on Linux.

First, install rclone. You can just run it (type rclone serve docker and hit enter) for the test.

Install FUSE:

sudo apt-get -y install fuse

Download two systemd configuration files: docker-volume-rclone.service and docker-volume-rclone.socket.

Put them to the /etc/systemd/system/ directory:

cp docker-volume-plugin.service /etc/systemd/system/
cp docker-volume-plugin.socket  /etc/systemd/system/

Please note that all commands in this section must be run as root but we omit sudo prefix for brevity. Now create directories required by the service:

mkdir -p /var/lib/docker-volumes/rclone
mkdir -p /var/lib/docker-plugins/rclone/config
mkdir -p /var/lib/docker-plugins/rclone/cache

Run the docker plugin service in the socket activated mode:

systemctl daemon-reload
systemctl start docker-volume-rclone.service
systemctl enable docker-volume-rclone.socket
systemctl start docker-volume-rclone.socket
systemctl restart docker

Or run the service directly: - run systemctl daemon-reload to let systemd pick up new config - run systemctl enable docker-volume-rclone.service to make the new service start automatically when you power on your machine. - run systemctl start docker-volume-rclone.service to start the service now. - run systemctl restart docker to restart docker daemon and let it detect the new plugin socket. Note that this step is not needed in managed mode where docker knows about plugin state changes.

The two methods are equivalent from the user perspective, but I personally prefer socket activation.

Troubleshooting

You can see managed plugin settings with

docker plugin list
docker plugin inspect rclone

Note that docker (including latest 20.10.7) will not show actual values of args, just the defaults.

Use journalctl --unit docker to see managed plugin output as part of the docker daemon log. Note that docker reflects plugin lines as errors but their actual level can be seen from encapsulated message string.

You will usually install the latest version of managed plugin for your platform. Use the following commands to print the actual installed version:

PLUGID=$(docker plugin list --no-trunc | awk '/rclone/{print$1}')
sudo runc --root /run/docker/runtime-runc/plugins.moby exec $PLUGID rclone version

You can even use runc to run shell inside the plugin container:

sudo runc --root /run/docker/runtime-runc/plugins.moby exec --tty $PLUGID bash

Also you can use curl to check the plugin socket connectivity:

docker plugin list --no-trunc
PLUGID=123abc...
sudo curl -H Content-Type:application/json -XPOST -d {} --unix-socket /run/docker/plugins/$PLUGID/rclone.sock http://localhost/Plugin.Activate

though this is rarely needed.

If the plugin fails to work properly, and only as a last resort after you tried diagnosing with the above methods, you can try clearing the state of the plugin. Note that all existing rclone docker volumes will probably have to be recreated. This might be needed because a reinstall don't cleanup existing state files to allow for easy restoration, as stated above.

docker plugin disable rclone # disable the plugin to ensure no interference
sudo rm /var/lib/docker-plugins/rclone/cache/docker-plugin.state # removing the plugin state
docker plugin enable rclone # re-enable the plugin afterward

Caveats

Finally I'd like to mention a caveat with updating volume settings. Docker CLI does not have a dedicated command like docker volume update. It may be tempting to invoke docker volume create with updated options on existing volume, but there is a gotcha. The command will do nothing, it won't even return an error. I hope that docker maintainers will fix this some day. In the meantime be aware that you must remove your volume before recreating it with new settings:

docker volume remove my_vol
docker volume create my_vol -d rclone -o opt1=new_val1 ...

and verify that settings did update:

docker volume list
docker volume inspect my_vol

If docker refuses to remove the volume, you should find containers or swarm services that use it and stop them first.

Bisync

bisync is considered an advanced command, so use with care. Make sure you have read and understood the entire manual (especially the Limitations section) before using, or data loss can result. Questions can be asked in the Rclone Forum.

Getting started

  • Install rclone and setup your remotes.
  • Bisync will create its working directory at ~/.cache/rclone/bisync on Linux, /Users/yourusername/Library/Caches/rclone/bisync on Mac, or C:\Users\MyLogin\AppData\Local\rclone\bisync on Windows. Make sure that this location is writable.
  • Run bisync with the --resync flag, specifying the paths to the local and remote sync directory roots.
  • For successive sync runs, leave off the --resync flag. (Important!)
  • Consider using a filters file for excluding unnecessary files and directories from the sync.
  • Consider setting up the --check-access feature for safety.
  • On Linux or Mac, consider setting up a crontab entry. bisync can safely run in concurrent cron jobs thanks to lock files it maintains.

For example, your first command might look like this:

rclone bisync remote1:path1 remote2:path2 --create-empty-src-dirs --compare size,modtime,checksum --slow-hash-sync-only --resilient -MvP --drive-skip-gdocs --fix-case --resync --dry-run

If all looks good, run it again without --dry-run. After that, remove --resync as well.

Here is a typical run log (with timestamps removed for clarity):

rclone bisync /testdir/path1/ /testdir/path2/ --verbose
INFO  : Synching Path1 "/testdir/path1/" with Path2 "/testdir/path2/"
INFO  : Path1 checking for diffs
INFO  : - Path1    File is new                         - file11.txt
INFO  : - Path1    File is newer                       - file2.txt
INFO  : - Path1    File is newer                       - file5.txt
INFO  : - Path1    File is newer                       - file7.txt
INFO  : - Path1    File was deleted                    - file4.txt
INFO  : - Path1    File was deleted                    - file6.txt
INFO  : - Path1    File was deleted                    - file8.txt
INFO  : Path1:    7 changes:    1 new,    3 newer,    0 older,    3 deleted
INFO  : Path2 checking for diffs
INFO  : - Path2    File is new                         - file10.txt
INFO  : - Path2    File is newer                       - file1.txt
INFO  : - Path2    File is newer                       - file5.txt
INFO  : - Path2    File is newer                       - file6.txt
INFO  : - Path2    File was deleted                    - file3.txt
INFO  : - Path2    File was deleted                    - file7.txt
INFO  : - Path2    File was deleted                    - file8.txt
INFO  : Path2:    7 changes:    1 new,    3 newer,    0 older,    3 deleted
INFO  : Applying changes
INFO  : - Path1    Queue copy to Path2                 - /testdir/path2/file11.txt
INFO  : - Path1    Queue copy to Path2                 - /testdir/path2/file2.txt
INFO  : - Path2    Queue delete                        - /testdir/path2/file4.txt
NOTICE: - WARNING  New or changed in both paths        - file5.txt
NOTICE: - Path1    Renaming Path1 copy                 - /testdir/path1/file5.txt..path1
NOTICE: - Path1    Queue copy to Path2                 - /testdir/path2/file5.txt..path1
NOTICE: - Path2    Renaming Path2 copy                 - /testdir/path2/file5.txt..path2
NOTICE: - Path2    Queue copy to Path1                 - /testdir/path1/file5.txt..path2
INFO  : - Path2    Queue copy to Path1                 - /testdir/path1/file6.txt
INFO  : - Path1    Queue copy to Path2                 - /testdir/path2/file7.txt
INFO  : - Path2    Queue copy to Path1                 - /testdir/path1/file1.txt
INFO  : - Path2    Queue copy to Path1                 - /testdir/path1/file10.txt
INFO  : - Path1    Queue delete                        - /testdir/path1/file3.txt
INFO  : - Path2    Do queued copies to                 - Path1
INFO  : - Path1    Do queued copies to                 - Path2
INFO  : -          Do queued deletes on                - Path1
INFO  : -          Do queued deletes on                - Path2
INFO  : Updating listings
INFO  : Validating listings for Path1 "/testdir/path1/" vs Path2 "/testdir/path2/"
INFO  : Bisync successful

Command line syntax

$ rclone bisync --help
Usage:
  rclone bisync remote1:path1 remote2:path2 [flags]

Positional arguments:
  Path1, Path2  Local path, or remote storage with ':' plus optional path.
                Type 'rclone listremotes' for list of configured remotes.

Optional Flags:
      --backup-dir1 string                   --backup-dir for Path1. Must be a non-overlapping path on the same remote.
      --backup-dir2 string                   --backup-dir for Path2. Must be a non-overlapping path on the same remote.
      --check-access                         Ensure expected RCLONE_TEST files are found on both Path1 and Path2 filesystems, else abort.
      --check-filename string                Filename for --check-access (default: RCLONE_TEST)
      --check-sync string                    Controls comparison of final listings: true|false|only (default: true) (default "true")
      --compare string                       Comma-separated list of bisync-specific compare options ex. 'size,modtime,checksum' (default: 'size,modtime')
      --conflict-loser ConflictLoserAction   Action to take on the loser of a sync conflict (when there is a winner) or on both files (when there is no winner): , num, pathname, delete (default: num)
      --conflict-resolve string              Automatically resolve conflicts by preferring the version that is: none, path1, path2, newer, older, larger, smaller (default: none) (default "none")
      --conflict-suffix string               Suffix to use when renaming a --conflict-loser. Can be either one string or two comma-separated strings to assign different suffixes to Path1/Path2. (default: 'conflict')
      --create-empty-src-dirs                Sync creation and deletion of empty directories. (Not compatible with --remove-empty-dirs)
      --download-hash                        Compute hash by downloading when otherwise unavailable. (warning: may be slow and use lots of data!)
      --filters-file string                  Read filtering patterns from a file
      --force                                Bypass --max-delete safety check and run the sync. Consider using with --verbose
  -h, --help                                 help for bisync
      --ignore-listing-checksum              Do not use checksums for listings (add --ignore-checksum to additionally skip post-copy checksum checks)
      --max-lock Duration                    Consider lock files older than this to be expired (default: 0 (never expire)) (minimum: 2m) (default 0s)
      --no-cleanup                           Retain working files (useful for troubleshooting and testing).
      --no-slow-hash                         Ignore listing checksums only on backends where they are slow
      --recover                              Automatically recover from interruptions without requiring --resync.
      --remove-empty-dirs                    Remove ALL empty directories at the final cleanup step.
      --resilient                            Allow future runs to retry after certain less-serious errors, instead of requiring --resync.
  -1, --resync                               Performs the resync run. Equivalent to --resync-mode path1. Consider using --verbose or --dry-run first.
      --resync-mode string                   During resync, prefer the version that is: path1, path2, newer, older, larger, smaller (default: path1 if --resync, otherwise none for no resync.) (default "none")
      --retries int                          Retry operations this many times if they fail (requires --resilient). (default 3)
      --retries-sleep Duration               Interval between retrying operations if they fail, e.g. 500ms, 60s, 5m (0 to disable) (default 0s)
      --slow-hash-sync-only                  Ignore slow checksums for listings and deltas, but still consider them during sync calls.
      --workdir string                       Use custom working dir - useful for testing. (default: {WORKDIR})
      --max-delete PERCENT                   Safety check on maximum percentage of deleted files allowed. If exceeded, the bisync run will abort. (default: 50%)
  -n, --dry-run                              Go through the motions - No files are copied/deleted.
  -v, --verbose                              Increases logging verbosity. May be specified more than once for more details.

Arbitrary rclone flags may be specified on the bisync command line, for example rclone bisync ./testdir/path1/ gdrive:testdir/path2/ --drive-skip-gdocs -v -v --timeout 10s Note that interactions of various rclone flags with bisync process flow has not been fully tested yet.

Paths

Path1 and Path2 arguments may be references to any mix of local directory paths (absolute or relative), UNC paths (//server/share/path), Windows drive paths (with a drive letter and :) or configured remotes with optional subdirectory paths. Cloud references are distinguished by having a : in the argument (see Windows support below).

Path1 and Path2 are treated equally, in that neither has priority for file changes (except during --resync), and access efficiency does not change whether a remote is on Path1 or Path2.

The listings in bisync working directory (default: ~/.cache/rclone/bisync) are named based on the Path1 and Path2 arguments so that separate syncs to individual directories within the tree may be set up, e.g.: path_to_local_tree..dropbox_subdir.lst.

Any empty directories after the sync on both the Path1 and Path2 filesystems are not deleted by default, unless --create-empty-src-dirs is specified. If the --remove-empty-dirs flag is specified, then both paths will have ALL empty directories purged as the last step in the process.

Command-line flags

--resync

This will effectively make both Path1 and Path2 filesystems contain a matching superset of all files. By default, Path2 files that do not exist in Path1 will be copied to Path1, and the process will then copy the Path1 tree to Path2.

The --resync sequence is roughly equivalent to the following (but see --resync-mode for other options):

rclone copy Path2 Path1 --ignore-existing [--create-empty-src-dirs]
rclone copy Path1 Path2 [--create-empty-src-dirs]

The base directories on both Path1 and Path2 filesystems must exist or bisync will fail. This is required for safety - that bisync can verify that both paths are valid.

When using --resync, a newer version of a file on the Path2 filesystem will (by default) be overwritten by the Path1 filesystem version. (Note that this is NOT entirely symmetrical, and more symmetrical options can be specified with the --resync-mode flag.) Carefully evaluate deltas using --dry-run.

For a resync run, one of the paths may be empty (no files in the path tree). The resync run should result in files on both paths, else a normal non-resync run will fail.

For a non-resync run, either path being empty (no files in the tree) fails with Empty current PathN listing. Cannot sync to an empty directory: X.pathN.lst This is a safety check that an unexpected empty path does not result in deleting everything in the other path.

Note that --resync implies --resync-mode path1 unless a different --resync-mode is explicitly specified. It is not necessary to use both the --resync and --resync-mode flags -- either one is sufficient without the other.

Note: --resync (including --resync-mode) should only be used under three specific (rare) circumstances:

  1. It is your first bisync run (between these two paths)
  2. You've just made changes to your bisync settings (such as editing the contents of your --filters-file)
  3. There was an error on the prior run, and as a result, bisync now requires --resync to recover

The rest of the time, you should omit --resync. The reason is because --resync will only copy (not sync) each side to the other. Therefore, if you included --resync for every bisync run, it would never be possible to delete a file -- the deleted file would always keep reappearing at the end of every run (because it's being copied from the other side where it still exists). Similarly, renaming a file would always result in a duplicate copy (both old and new name) on both sides.

If you find that frequent interruptions from #3 are an issue, rather than automatically running --resync, the recommended alternative is to use the --resilient, --recover, and --conflict-resolve flags, (along with Graceful Shutdown mode, when needed) for a very robust "set-it-and-forget-it" bisync setup that can automatically bounce back from almost any interruption it might encounter. Consider adding something like the following:

--resilient --recover --max-lock 2m --conflict-resolve newer

--resync-mode CHOICE

In the event that a file differs on both sides during a --resync, --resync-mode controls which version will overwrite the other. The supported options are similar to --conflict-resolve. For all of the following options, the version that is kept is referred to as the "winner", and the version that is overwritten (deleted) is referred to as the "loser". The options are named after the "winner":

  • path1 - (the default) - the version from Path1 is unconditionally considered the winner (regardless of modtime and size, if any). This can be useful if one side is more trusted or up-to-date than the other, at the time of the --resync.
  • path2 - same as path1, except the path2 version is considered the winner.
  • newer - the newer file (by modtime) is considered the winner, regardless of which side it came from. This may result in having a mix of some winners from Path1, and some winners from Path2. (The implementation is analogous to running rclone copy --update in both directions.)
  • older - same as newer, except the older file is considered the winner, and the newer file is considered the loser.
  • larger - the larger file (by size) is considered the winner (regardless of modtime, if any). This can be a useful option for remotes without modtime support, or with the kinds of files (such as logs) that tend to grow but not shrink, over time.
  • smaller - the smaller file (by size) is considered the winner (regardless of modtime, if any).

For all of the above options, note the following:

  • If either of the underlying remotes lacks support for the chosen method, it will be ignored and will fall back to the default of path1. (For example, if --resync-mode newer is set, but one of the paths uses a remote that doesn't support modtime.)
  • If a winner can't be determined because the chosen method's attribute is missing or equal, it will be ignored, and bisync will instead try to determine whether the files differ by looking at the other --compare methods in effect. (For example, if --resync-mode newer is set, but the Path1 and Path2 modtimes are identical, bisync will compare the sizes.) If bisync concludes that they differ, preference is given to whichever is the "source" at that moment. (In practice, this gives a slight advantage to Path2, as the 2to1 copy comes before the 1to2 copy.) If the files do not differ, nothing is copied (as both sides are already correct).
  • These options apply only to files that exist on both sides (with the same name and relative path). Files that exist only on one side and not the other are always copied to the other, during --resync (this is one of the main differences between resync and non-resync runs.).
  • --conflict-resolve, --conflict-loser, and --conflict-suffix do not apply during --resync, and unlike these flags, nothing is renamed during --resync. When a file differs on both sides during --resync, one version always overwrites the other (much like in rclone copy.) (Consider using --backup-dir to retain a backup of the losing version.)
  • Unlike for --conflict-resolve, --resync-mode none is not a valid option (or rather, it will be interpreted as "no resync", unless --resync has also been specified, in which case it will be ignored.)
  • Winners and losers are decided at the individual file-level only (there is not currently an option to pick an entire winning directory atomically, although the path1 and path2 options typically produce a similar result.)
  • To maintain backward-compatibility, the --resync flag implies --resync-mode path1 unless a different --resync-mode is explicitly specified. Similarly, all --resync-mode options (except none) imply --resync, so it is not necessary to use both the --resync and --resync-mode flags simultaneously -- either one is sufficient without the other.

--check-access

Access check files are an additional safety measure against data loss. bisync will ensure it can find matching RCLONE_TEST files in the same places in the Path1 and Path2 filesystems. RCLONE_TEST files are not generated automatically. For --check-access to succeed, you must first either: A) Place one or more RCLONE_TEST files in both systems, or B) Set --check-filename to a filename already in use in various locations throughout your sync'd fileset. Recommended methods for A) include:

  • rclone touch Path1/RCLONE_TEST (create a new file)
  • rclone copyto Path1/RCLONE_TEST Path2/RCLONE_TEST (copy an existing file)
  • rclone copy Path1/RCLONE_TEST Path2/RCLONE_TEST --include "RCLONE_TEST" (copy multiple files at once, recursively)
  • create the files manually (outside of rclone)
  • run bisync once without --check-access to set matching files on both filesystems will also work, but is not preferred, due to potential for user error (you are temporarily disabling the safety feature).

Note that --check-access is still enforced on --resync, so bisync --resync --check-access will not work as a method of initially setting the files (this is to ensure that bisync can't inadvertently circumvent its own safety switch.)

Time stamps and file contents for RCLONE_TEST files are not important, just the names and locations. If you have symbolic links in your sync tree it is recommended to place RCLONE_TEST files in the linked-to directory tree to protect against bisync assuming a bunch of deleted files if the linked-to tree should not be accessible. See also the --check-filename flag.

--check-filename

Name of the file(s) used in access health validation. The default --check-filename is RCLONE_TEST. One or more files having this filename must exist, synchronized between your source and destination filesets, in order for --check-access to succeed. See --check-access for additional details.

--compare

As of v1.66, bisync fully supports comparing based on any combination of size, modtime, and checksum (lifting the prior restriction on backends without modtime support.)

By default (without the --compare flag), bisync inherits the same comparison options as sync (that is: size and modtime by default, unless modified with flags such as --checksum or --size-only.)

If the --compare flag is set, it will override these defaults. This can be useful if you wish to compare based on combinations not currently supported in sync, such as comparing all three of size AND modtime AND checksum simultaneously (or just modtime AND checksum).

--compare takes a comma-separated list, with the currently supported values being size, modtime, and checksum. For example, if you want to compare size and checksum, but not modtime, you would do:

--compare size,checksum

Or if you want to compare all three:

--compare size,modtime,checksum

--compare overrides any conflicting flags. For example, if you set the conflicting flags --compare checksum --size-only, --size-only will be ignored, and bisync will compare checksum and not size. To avoid confusion, it is recommended to use either --compare or the normal sync flags, but not both.

If --compare includes checksum and both remotes support checksums but have no hash types in common with each other, checksums will be considered only for comparisons within the same side (to determine what has changed since the prior sync), but not for comparisons against the opposite side. If one side supports checksums and the other does not, checksums will only be considered on the side that supports them.

When comparing with checksum and/or size without modtime, bisync cannot determine whether a file is newer or older -- only whether it is changed or unchanged. (If it is changed on both sides, bisync still does the standard equality-check to avoid declaring a sync conflict unless it absolutely has to.)

It is recommended to do a --resync when changing --compare settings, as otherwise your prior listing files may not contain the attributes you wish to compare (for example, they will not have stored checksums if you were not previously comparing checksums.)

--ignore-listing-checksum

When --checksum or --compare checksum is set, bisync will retrieve (or generate) checksums (for backends that support them) when creating the listings for both paths, and store the checksums in the listing files. --ignore-listing-checksum will disable this behavior, which may speed things up considerably, especially on backends (such as local) where hashes must be computed on the fly instead of retrieved. Please note the following:

  • As of v1.66, --ignore-listing-checksum is now automatically set when neither --checksum nor --compare checksum are in use (as the checksums would not be used for anything.)
  • --ignore-listing-checksum is NOT the same as --ignore-checksum, and you may wish to use one or the other, or both. In a nutshell: --ignore-listing-checksum controls whether checksums are considered when scanning for diffs, while --ignore-checksum controls whether checksums are considered during the copy/sync operations that follow, if there ARE diffs.
  • Unless --ignore-listing-checksum is passed, bisync currently computes hashes for one path even when there's no common hash with the other path (for example, a crypt remote.) This can still be beneficial, as the hashes will still be used to detect changes within the same side (if --checksum or --compare checksum is set), even if they can't be used to compare against the opposite side.
  • If you wish to ignore listing checksums only on remotes where they are slow to compute, consider using --no-slow-hash (or --slow-hash-sync-only) instead of --ignore-listing-checksum.
  • If --ignore-listing-checksum is used simultaneously with --compare checksum (or --checksum), checksums will be ignored for bisync deltas, but still considered during the sync operations that follow (if deltas are detected based on modtime and/or size.)

--no-slow-hash

On some remotes (notably local), checksums can dramatically slow down a bisync run, because hashes cannot be stored and need to be computed in real-time when they are requested. On other remotes (such as drive), they add practically no time at all. The --no-slow-hash flag will automatically skip checksums on remotes where they are slow, while still comparing them on others (assuming --compare includes checksum.) This can be useful when one of your bisync paths is slow but you still want to check checksums on the other, for a more robust sync.

--slow-hash-sync-only

Same as --no-slow-hash, except slow hashes are still considered during sync calls. They are still NOT considered for determining deltas, nor or they included in listings. They are also skipped during --resync. The main use case for this flag is when you have a large number of files, but relatively few of them change from run to run -- so you don't want to check your entire tree every time (it would take too long), but you still want to consider checksums for the smaller group of files for which a modtime or size change was detected. Keep in mind that this speed savings comes with a safety trade-off: if a file's content were to change without a change to its modtime or size, bisync would not detect it, and it would not be synced.

--slow-hash-sync-only is only useful if both remotes share a common hash type (if they don't, bisync will automatically fall back to --no-slow-hash.) Both --no-slow-hash and --slow-hash-sync-only have no effect without --compare checksum (or --checksum).

--download-hash

If --download-hash is set, bisync will use best efforts to obtain an MD5 checksum by downloading and computing on-the-fly, when checksums are not otherwise available (for example, a remote that doesn't support them.) Note that since rclone has to download the entire file, this may dramatically slow down your bisync runs, and is also likely to use a lot of data, so it is probably not practical for bisync paths with a large total file size. However, it can be a good option for syncing small-but-important files with maximum accuracy (for example, a source code repo on a crypt remote.) An additional advantage over methods like cryptcheck is that the original file is not required for comparison (for example, --download-hash can be used to bisync two different crypt remotes with different passwords.)

When --download-hash is set, bisync still looks for more efficient checksums first, and falls back to downloading only when none are found. It takes priority over conflicting flags such as --no-slow-hash. --download-hash is not suitable for Google Docs and other files of unknown size, as their checksums would change from run to run (due to small variances in the internals of the generated export file.) Therefore, bisync automatically skips --download-hash for files with a size less than 0.

See also: Hasher backend, cryptcheck command, rclone check --download option, md5sum command

--max-delete

As a safety check, if greater than the --max-delete percent of files were deleted on either the Path1 or Path2 filesystem, then bisync will abort with a warning message, without making any changes. The default --max-delete is 50%. One way to trigger this limit is to rename a directory that contains more than half of your files. This will appear to bisync as a bunch of deleted files and a bunch of new files. This safety check is intended to block bisync from deleting all of the files on both filesystems due to a temporary network access issue, or if the user had inadvertently deleted the files on one side or the other. To force the sync, either set a different delete percentage limit, e.g. --max-delete 75 (allows up to 75% deletion), or use --force to bypass the check.

Also see the all files changed check.

--filters-file

By using rclone filter features you can exclude file types or directory sub-trees from the sync. See the bisync filters section and generic --filter-from documentation. An example filters file contains filters for non-allowed files for syncing with Dropbox.

If you make changes to your filters file then bisync requires a run with --resync. This is a safety feature, which prevents existing files on the Path1 and/or Path2 side from seeming to disappear from view (since they are excluded in the new listings), which would fool bisync into seeing them as deleted (as compared to the prior run listings), and then bisync would proceed to delete them for real.

To block this from happening, bisync calculates an MD5 hash of the filters file and stores the hash in a .md5 file in the same place as your filters file. On the next run with --filters-file set, bisync re-calculates the MD5 hash of the current filters file and compares it to the hash stored in the .md5 file. If they don't match, the run aborts with a critical error and thus forces you to do a --resync, likely avoiding a disaster.

--conflict-resolve CHOICE

In bisync, a "conflict" is a file that is new or changed on both sides (relative to the prior run) AND is not currently identical on both sides. --conflict-resolve controls how bisync handles such a scenario. The currently supported options are:

  • none - (the default) - do not attempt to pick a winner, keep and rename both files according to --conflict-loser and --conflict-suffix settings. For example, with the default settings, file.txt on Path1 is renamed file.txt.conflict1 and file.txt on Path2 is renamed file.txt.conflict2. Both are copied to the opposite path during the run, so both sides end up with a copy of both files. (As none is the default, it is not necessary to specify --conflict-resolve none -- you can just omit the flag.)
  • newer - the newer file (by modtime) is considered the winner and is copied without renaming. The older file (the "loser") is handled according to --conflict-loser and --conflict-suffix settings (either renamed or deleted.) For example, if file.txt on Path1 is newer than file.txt on Path2, the result on both sides (with other default settings) will be file.txt (winner from Path1) and file.txt.conflict1 (loser from Path2).
  • older - same as newer, except the older file is considered the winner, and the newer file is considered the loser.
  • larger - the larger file (by size) is considered the winner (regardless of modtime, if any).
  • smaller - the smaller file (by size) is considered the winner (regardless of modtime, if any).
  • path1 - the version from Path1 is unconditionally considered the winner (regardless of modtime and size, if any). This can be useful if one side is usually more trusted or up-to-date than the other.
  • path2 - same as path1, except the path2 version is considered the winner.

For all of the above options, note the following:

  • If either of the underlying remotes lacks support for the chosen method, it will be ignored and fall back to none. (For example, if --conflict-resolve newer is set, but one of the paths uses a remote that doesn't support modtime.)
  • If a winner can't be determined because the chosen method's attribute is missing or equal, it will be ignored and fall back to none. (For example, if --conflict-resolve newer is set, but the Path1 and Path2 modtimes are identical, even if the sizes may differ.)
  • If the file's content is currently identical on both sides, it is not considered a "conflict", even if new or changed on both sides since the prior sync. (For example, if you made a change on one side and then synced it to the other side by other means.) Therefore, none of the conflict resolution flags apply in this scenario.
  • The conflict resolution flags do not apply during a --resync, as there is no "prior run" to speak of (but see --resync-mode for similar options.)

--conflict-loser CHOICE

--conflict-loser determines what happens to the "loser" of a sync conflict (when --conflict-resolve determines a winner) or to both files (when there is no winner.) The currently supported options are:

  • num - (the default) - auto-number the conflicts by automatically appending the next available number to the --conflict-suffix, in chronological order. For example, with the default settings, the first conflict for file.txt will be renamed file.txt.conflict1. If file.txt.conflict1 already exists, file.txt.conflict2 will be used instead (etc., up to a maximum of 9223372036854775807 conflicts.)
  • pathname - rename the conflicts according to which side they came from, which was the default behavior prior to v1.66. For example, with --conflict-suffix path, file.txt from Path1 will be renamed file.txt.path1, and file.txt from Path2 will be renamed file.txt.path2. If two non-identical suffixes are provided (ex. --conflict-suffix cloud,local), the trailing digit is omitted. Importantly, note that with pathname, there is no auto-numbering beyond 2, so if file.txt.path2 somehow already exists, it will be overwritten. Using a dynamic date variable in your --conflict-suffix (see below) is one possible way to avoid this. Note also that conflicts-of-conflicts are possible, if the original conflict is not manually resolved -- for example, if for some reason you edited file.txt.path1 on both sides, and those edits were different, the result would be file.txt.path1.path1 and file.txt.path1.path2 (in addition to file.txt.path2.)
  • delete - keep the winner only and delete the loser, instead of renaming it. If a winner cannot be determined (see --conflict-resolve for details on how this could happen), delete is ignored and the default num is used instead (i.e. both versions are kept and renamed, and neither is deleted.) delete is inherently the most destructive option, so use it only with care.

For all of the above options, note that if a winner cannot be determined (see --conflict-resolve for details on how this could happen), or if --conflict-resolve is not in use, both files will be renamed.

--conflict-suffix STRING[,STRING]

--conflict-suffix controls the suffix that is appended when bisync renames a --conflict-loser (default: conflict). --conflict-suffix will accept either one string or two comma-separated strings to assign different suffixes to Path1 vs. Path2. This may be helpful later in identifying the source of the conflict. (For example, --conflict-suffix dropboxconflict,laptopconflict)

With --conflict-loser num, a number is always appended to the suffix. With --conflict-loser pathname, a number is appended only when one suffix is specified (or when two identical suffixes are specified.) i.e. with --conflict-loser pathname, all of the following would produce exactly the same result:

--conflict-suffix path
--conflict-suffix path,path
--conflict-suffix path1,path2

Suffixes may be as short as 1 character. By default, the suffix is appended after any other extensions (ex. file.jpg.conflict1), however, this can be changed with the --suffix-keep-extension flag (i.e. to instead result in file.conflict1.jpg).

--conflict-suffix supports several dynamic date variables when enclosed in curly braces as globs. This can be helpful to track the date and/or time that each conflict was handled by bisync. For example:

--conflict-suffix {DateOnly}-conflict
// result: myfile.txt.2006-01-02-conflict1

All of the formats described here (go Time.Layout constants) and here (go Time.Format examples) are supported, but take care to ensure that your chosen format does not use any characters that are illegal on your remotes (for example, macOS does not allow colons in filenames, and slashes are also best avoided as they are often interpreted as directory separators.) To address this particular issue, an additional {MacFriendlyTime} (or just {mac}) option is supported, which results in 2006-01-02 0304PM.

Note that --conflict-suffix is entirely separate from rclone's main --sufix flag. This is intentional, as users may wish to use both flags simultaneously, if also using --backup-dir.

Finally, note that the default in bisync prior to v1.66 was to rename conflicts with ..path1 and ..path2 (with two periods, and path instead of conflict.) Bisync now defaults to a single dot instead of a double dot, but additional dots can be added by including them in the specified suffix string. For example, for behavior equivalent to the previous default, use:

[--conflict-resolve none] --conflict-loser pathname --conflict-suffix .path

--check-sync

Enabled by default, the check-sync function checks that all of the same files exist in both the Path1 and Path2 history listings. This check-sync integrity check is performed at the end of the sync run by default. Any untrapped failing copy/deletes between the two paths might result in differences between the two listings and in the untracked file content differences between the two paths. A resync run would correct the error.

Note that the default-enabled integrity check locally executes a load of both the final Path1 and Path2 listings, and thus adds to the run time of a sync. Using --check-sync=false will disable it and may significantly reduce the sync run times for very large numbers of files.

The check may be run manually with --check-sync=only. It runs only the integrity check and terminates without actually syncing.

Note that currently, --check-sync only checks listing snapshots and NOT the actual files on the remotes. Note also that the listing snapshots will not know about any changes that happened during or after the latest bisync run, as those will be discovered on the next run. Therefore, while listings should always match each other at the end of a bisync run, it is expected that they will not match the underlying remotes, nor will the remotes match each other, if there were changes during or after the run. This is normal, and any differences will be detected and synced on the next run.

For a robust integrity check of the current state of the remotes (as opposed to just their listing snapshots), consider using check (or cryptcheck, if at least one path is a crypt remote) instead of --check-sync, keeping in mind that differences are expected if files changed during or after your last bisync run.

For example, a possible sequence could look like this:

  1. Normally scheduled bisync run:

    rclone bisync Path1 Path2 -MPc --check-access --max-delete 10 --filters-file /path/to/filters.txt -v --no-cleanup --ignore-listing-checksum --disable ListR --checkers=16 --drive-pacer-min-sleep=10ms --create-empty-src-dirs --resilient

  2. Periodic independent integrity check (perhaps scheduled nightly or weekly):

    rclone check -MvPc Path1 Path2 --filter-from /path/to/filters.txt

  3. If diffs are found, you have some choices to correct them. If one side is more up-to-date and you want to make the other side match it, you could run:

    rclone sync Path1 Path2 --filter-from /path/to/filters.txt --create-empty-src-dirs -MPc -v

(or switch Path1 and Path2 to make Path2 the source-of-truth)

Or, if neither side is totally up-to-date, you could run a --resync to bring them back into agreement (but remember that this could cause deleted files to re-appear.)

*Note also that rclone check does not currently include empty directories, so if you want to know if any empty directories are out of sync, consider alternatively running the above rclone sync command with --dry-run added.

See also: Concurrent modifications, --resilient

--resilient

By default, most errors or interruptions will cause bisync to abort and require --resync to recover. This is a safety feature, to prevent bisync from running again until a user checks things out. However, in some cases, bisync can go too far and enforce a lockout when one isn't actually necessary, like for certain less-serious errors that might resolve themselves on the next run. When --resilient is specified, bisync tries its best to recover and self-correct, and only requires --resync as a last resort when a human's involvement is absolutely necessary. The intended use case is for running bisync as a background process (such as via scheduled cron).

When using --resilient mode, bisync will still report the error and abort, however it will not lock out future runs -- allowing the possibility of retrying at the next normally scheduled time, without requiring a --resync first. Examples of such retryable errors include access test failures, missing listing files, and filter change detections. These safety features will still prevent the current run from proceeding -- the difference is that if conditions have improved by the time of the next run, that next run will be allowed to proceed. Certain more serious errors will still enforce a --resync lockout, even in --resilient mode, to prevent data loss.

Behavior of --resilient may change in a future version. (See also: --recover, --max-lock, Graceful Shutdown)

--recover

If --recover is set, in the event of a sudden interruption or other un-graceful shutdown, bisync will attempt to automatically recover on the next run, instead of requiring --resync. Bisync is able to recover robustly by keeping one "backup" listing at all times, representing the state of both paths after the last known successful sync. Bisync can then compare the current state with this snapshot to determine which changes it needs to retry. Changes that were synced after this snapshot (during the run that was later interrupted) will appear to bisync as if they are "new or changed on both sides", but in most cases this is not a problem, as bisync will simply do its usual "equality check" and learn that no action needs to be taken on these files, since they are already identical on both sides.

In the rare event that a file is synced successfully during a run that later aborts, and then that same file changes AGAIN before the next run, bisync will think it is a sync conflict, and handle it accordingly. (From bisync's perspective, the file has changed on both sides since the last trusted sync, and the files on either side are not currently identical.) Therefore, --recover carries with it a slightly increased chance of having conflicts -- though in practice this is pretty rare, as the conditions required to cause it are quite specific. This risk can be reduced by using bisync's "Graceful Shutdown" mode (triggered by sending SIGINT or Ctrl+C), when you have the choice, instead of forcing a sudden termination.

--recover and --resilient are similar, but distinct -- the main difference is that --resilient is about retrying, while --recover is about recovering. Most users will probably want both. --resilient allows retrying when bisync has chosen to abort itself due to safety features such as failing --check-access or detecting a filter change. --resilient does not cover external interruptions such as a user shutting down their computer in the middle of a sync -- that is what --recover is for.

--max-lock

Bisync uses lock files as a safety feature to prevent interference from other bisync runs while it is running. Bisync normally removes these lock files at the end of a run, but if bisync is abruptly interrupted, these files will be left behind. By default, they will lock out all future runs, until the user has a chance to manually check things out and remove the lock. As an alternative, --max-lock can be used to make them automatically expire after a certain period of time, so that future runs are not locked out forever, and auto-recovery is possible. --max-lock can be any duration 2m or greater (or 0 to disable). If set, lock files older than this will be considered "expired", and future runs will be allowed to disregard them and proceed. (Note that the --max-lock duration must be set by the process that left the lock file -- not the later one interpreting it.)

If set, bisync will also "renew" these lock files every --max-lock minus one minute throughout a run, for extra safety. (For example, with --max-lock 5m, bisync would renew the lock file (for another 5 minutes) every 4 minutes until the run has completed.) In other words, it should not be possible for a lock file to pass its expiration time while the process that created it is still running -- and you can therefore be reasonably sure that any expired lock file you may find was left there by an interrupted run, not one that is still running and just taking awhile.

If --max-lock is 0 or not set, the default is that lock files will never expire, and will block future runs (of these same two bisync paths) indefinitely.

For maximum resilience from disruptions, consider setting a relatively short duration like --max-lock 2m along with --resilient and --recover, and a relatively frequent cron schedule. The result will be a very robust "set-it-and-forget-it" bisync run that can automatically bounce back from almost any interruption it might encounter, without requiring the user to get involved and run a --resync. (See also: Graceful Shutdown mode)

--backup-dir1 and --backup-dir2

As of v1.66, --backup-dir is supported in bisync. Because --backup-dir must be a non-overlapping path on the same remote, Bisync has introduced new --backup-dir1 and --backup-dir2 flags to support separate backup-dirs for Path1 and Path2 (bisyncing between different remotes with --backup-dir would not otherwise be possible.) --backup-dir1 and --backup-dir2 can use different remotes from each other, but --backup-dir1 must use the same remote as Path1, and --backup-dir2 must use the same remote as Path2. Each backup directory must not overlap its respective bisync Path without being excluded by a filter rule.

The standard --backup-dir will also work, if both paths use the same remote (but note that deleted files from both paths would be mixed together in the same dir). If either --backup-dir1 and --backup-dir2 are set, they will override --backup-dir.

Example:

rclone bisync /Users/someuser/some/local/path/Bisync gdrive:Bisync --backup-dir1 /Users/someuser/some/local/path/BackupDir --backup-dir2 gdrive:BackupDir --suffix -2023-08-26 --suffix-keep-extension --check-access --max-delete 10 --filters-file /Users/someuser/some/local/path/bisync_filters.txt --no-cleanup --ignore-listing-checksum --checkers=16 --drive-pacer-min-sleep=10ms --create-empty-src-dirs --resilient -MvP --drive-skip-gdocs --fix-case

In this example, if the user deletes a file in /Users/someuser/some/local/path/Bisync, bisync will propagate the delete to the other side by moving the corresponding file from gdrive:Bisync to gdrive:BackupDir. If the user deletes a file from gdrive:Bisync, bisync moves it from /Users/someuser/some/local/path/Bisync to /Users/someuser/some/local/path/BackupDir.

In the event of a rename due to a sync conflict, the rename is not considered a delete, unless a previous conflict with the same name already exists and would get overwritten.

See also: --suffix, --suffix-keep-extension

Operation

Runtime flow details

bisync retains the listings of the Path1 and Path2 filesystems from the prior run. On each successive run it will:

  • list files on path1 and path2, and check for changes on each side. Changes include New, Newer, Older, and Deleted files.
  • Propagate changes on path1 to path2, and vice-versa.

Safety measures

  • Lock file prevents multiple simultaneous runs when taking a while. This can be particularly useful if bisync is run by cron scheduler.
  • Handle change conflicts non-destructively by creating .conflict1, .conflict2, etc. file versions, according to --conflict-resolve, --conflict-loser, and --conflict-suffix settings.
  • File system access health check using RCLONE_TEST files (see the --check-access flag).
  • Abort on excessive deletes - protects against a failed listing being interpreted as all the files were deleted. See the --max-delete and --force flags.
  • If something evil happens, bisync goes into a safe state to block damage by later runs. (See Error Handling)

Normal sync checks

Type Description Result Implementation
Path2 new File is new on Path2, does not exist on Path1 Path2 version survives rclone copy Path2 to Path1
Path2 newer File is newer on Path2, unchanged on Path1 Path2 version survives rclone copy Path2 to Path1
Path2 deleted File is deleted on Path2, unchanged on Path1 File is deleted rclone delete Path1
Path1 new File is new on Path1, does not exist on Path2 Path1 version survives rclone copy Path1 to Path2
Path1 newer File is newer on Path1, unchanged on Path2 Path1 version survives rclone copy Path1 to Path2
Path1 older File is older on Path1, unchanged on Path2 Path1 version survives rclone copy Path1 to Path2
Path2 older File is older on Path2, unchanged on Path1 Path2 version survives rclone copy Path2 to Path1
Path1 deleted File no longer exists on Path1 File is deleted rclone delete Path2

Unusual sync checks

Type Description Result Implementation
Path1 new/changed AND Path2 new/changed AND Path1 == Path2 File is new/changed on Path1 AND new/changed on Path2 AND Path1 version is currently identical to Path2 No change None
Path1 new AND Path2 new File is new on Path1 AND new on Path2 (and Path1 version is NOT identical to Path2) Conflicts handled according to --conflict-resolve & --conflict-loser settings default: rclone copy renamed Path2.conflict2 file to Path1, rclone copy renamed Path1.conflict1 file to Path2
Path2 newer AND Path1 changed File is newer on Path2 AND also changed (newer/older/size) on Path1 (and Path1 version is NOT identical to Path2) Conflicts handled according to --conflict-resolve & --conflict-loser settings default: rclone copy renamed Path2.conflict2 file to Path1, rclone copy renamed Path1.conflict1 file to Path2
Path2 newer AND Path1 deleted File is newer on Path2 AND also deleted on Path1 Path2 version survives rclone copy Path2 to Path1
Path2 deleted AND Path1 changed File is deleted on Path2 AND changed (newer/older/size) on Path1 Path1 version survives rclone copy Path1 to Path2
Path1 deleted AND Path2 changed File is deleted on Path1 AND changed (newer/older/size) on Path2 Path2 version survives rclone copy Path2 to Path1

As of rclone v1.64, bisync is now better at detecting false positive sync conflicts, which would previously have resulted in unnecessary renames and duplicates. Now, when bisync comes to a file that it wants to rename (because it is new/changed on both sides), it first checks whether the Path1 and Path2 versions are currently identical (using the same underlying function as check.) If bisync concludes that the files are identical, it will skip them and move on. Otherwise, it will create renamed duplicates, as before. This behavior also improves the experience of renaming directories, as a --resync is no longer required, so long as the same change has been made on both sides.

All files changed check

If all prior existing files on either of the filesystems have changed (e.g. timestamps have changed due to changing the system's timezone) then bisync will abort without making any changes. Any new files are not considered for this check. You could use --force to force the sync (whichever side has the changed timestamp files wins). Alternately, a --resync may be used (Path1 versions will be pushed to Path2). Consider the situation carefully and perhaps use --dry-run before you commit to the changes.

Modification times

By default, bisync compares files by modification time and size. If you or your application should change the content of a file without changing the modification time and size, then bisync will not notice the change, and thus will not copy it to the other side. As an alternative, consider comparing by checksum (if your remotes support it). See --compare for details.

Error handling

Certain bisync critical errors, such as file copy/move failing, will result in a bisync lockout of following runs. The lockout is asserted because the sync status and history of the Path1 and Path2 filesystems cannot be trusted, so it is safer to block any further changes until someone checks things out. The recovery is to do a --resync again.

It is recommended to use --resync --dry-run --verbose initially and carefully review what changes will be made before running the --resync without --dry-run.

Most of these events come up due to an error status from an internal call. On such a critical error the {...}.path1.lst and {...}.path2.lst listing files are renamed to extension .lst-err, which blocks any future bisync runs (since the normal .lst files are not found). Bisync keeps them under bisync subdirectory of the rclone cache directory, typically at ${HOME}/.cache/rclone/bisync/ on Linux.

Some errors are considered temporary and re-running the bisync is not blocked. The critical return blocks further bisync runs.

See also: --resilient, --recover, --max-lock, Graceful Shutdown

Lock file

When bisync is running, a lock file is created in the bisync working directory, typically at ~/.cache/rclone/bisync/PATH1..PATH2.lck on Linux. If bisync should crash or hang, the lock file will remain in place and block any further runs of bisync for the same paths. Delete the lock file as part of debugging the situation. The lock file effectively blocks follow-on (e.g., scheduled by cron) runs when the prior invocation is taking a long time. The lock file contains PID of the blocking process, which may help in debug. Lock files can be set to automatically expire after a certain amount of time, using the --max-lock flag.

Note that while concurrent bisync runs are allowed, be very cautious that there is no overlap in the trees being synched between concurrent runs, lest there be replicated files, deleted files and general mayhem.

Exit codes

rclone bisync returns the following codes to calling program:

  • 0 on a successful run,
  • 1 for a non-critical failing run (a rerun may be successful),
  • 2 on syntax or usage error,
  • 7 for a critically aborted run (requires a --resync to recover).

See also the section about exit codes in main docs.

Graceful Shutdown

Bisync has a "Graceful Shutdown" mode which is activated by sending SIGINT or pressing Ctrl+C during a run. Once triggered, bisync will use best efforts to exit cleanly before the timer runs out. If bisync is in the middle of transferring files, it will attempt to cleanly empty its queue by finishing what it has started but not taking more. If it cannot do so within 30 seconds, it will cancel the in-progress transfers at that point and then give itself a maximum of 60 seconds to wrap up, save its state for next time, and exit. With the -vP flags you will see constant status updates and a final confirmation of whether or not the graceful shutdown was successful.

At any point during the "Graceful Shutdown" sequence, a second SIGINT or Ctrl+C will trigger an immediate, un-graceful exit, which will leave things in a messier state. Usually a robust recovery will still be possible if using --recover mode, otherwise you will need to do a --resync.

If you plan to use Graceful Shutdown mode, it is recommended to use --resilient and --recover, and it is important to NOT use --inplace, otherwise you risk leaving partially-written files on one side, which may be confused for real files on the next run. Note also that in the event of an abrupt interruption, a lock file will be left behind to block concurrent runs. You will need to delete it before you can proceed with the next run (or wait for it to expire on its own, if using --max-lock.)

Limitations

Supported backends

Bisync is integration-tested against all rclone backends to verify compatibility. Most backends (including all backends not listed below) are deemed fully supported with no known issues. Occasionally, however, these tests reveal issues with particular backends, usually related to a provider-specific limitation beyond rclone's control (for example, disallowed special characters and filename encodings.)

The following backends have known issues that need more investigation:

The following backends either have not been tested recently or have known issues that are deemed unfixable for the time being:

  • TestCache (cache)
  • TestFileLu (filelu)
  • TestFilesCom (filescom)
  • TestImageKit (imagekit)
  • TestJottacloud (jottacloud)
  • TestLinkbox (linkbox)
  • TestMailru (mailru)
  • TestMega (mega)
  • TestOpenDrive (opendrive)
  • TestOracleObjectStorage (oracleobjectstorage)
  • TestPikPak (pikpak)
  • TestPixeldrain (pixeldrain)
  • TestProtonDrive (protondrive)
  • TestPutio (putio)
  • TestQuatrix (quatrix)
  • TestS3GCS (s3)
    • TestBisyncRemoteRemote/extended_filenames
  • TestS3Rclone (s3)
  • TestSFTPRsyncNet (sftp)
  • TestStorj (storj)
  • TestWebdavInfiniteScale (webdav)
  • TestWebdavNextcloud (webdav)
  • TestWebdavOwncloud (webdav)
  • TestnStorage (netstorage) (more info)

The above lists are updated for each stable release of rclone. For test results updated nightly based on the latest beta, visit rclone's integration test status page.

Early beta versions of rclone bisync required both underlying backends to support modification times, and refused to run otherwise. This limitation has been lifted as of v1.66, as bisync now supports comparing checksum and/or size instead of (or in addition to) modtime. See --compare for details.

Concurrent modifications

When using Local, FTP or SFTP remotes with --inplace, rclone does not create temporary files at the destination when copying, and thus if the connection is lost the created file may be corrupt, which will likely propagate back to the original path on the next sync, resulting in data loss. It is therefore recommended to omit --inplace.

Files that change during a bisync run may result in data loss. Prior to rclone v1.66, this was commonly seen in highly dynamic environments, where the filesystem was getting hammered by running processes during the sync. As of rclone v1.66, bisync was redesigned to use a "snapshot" model, greatly reducing the risks from changes during a sync. Changes that are not detected during the current sync will now be detected during the following sync, and will no longer cause the entire run to throw a critical error. There is additionally a mechanism to mark files as needing to be internally rechecked next time, for added safety. It should therefore no longer be necessary to sync only at quiet times -- however, note that an error can still occur if a file happens to change at the exact moment it's being read/written by bisync (same as would happen in rclone sync.) (See also: --ignore-checksum, --local-no-check-updated)

Empty directories

By default, new/deleted empty directories on one path are not propagated to the other side. This is because bisync (and rclone) natively works on files, not directories. However, this can be changed with the --create-empty-src-dirs flag, which works in much the same way as in sync and copy. When used, empty directories created or deleted on one side will also be created or deleted on the other side. The following should be noted:

  • --create-empty-src-dirs is not compatible with --remove-empty-dirs. Use only one or the other (or neither).
  • It is not recommended to switch back and forth between --create-empty-src-dirs and the default (no --create-empty-src-dirs) without running -- resync. This is because it may appear as though all directories (not just the empty ones) were created/deleted, when actually you've just toggled between making them visible/invisible to bisync. It looks scarier than it is, but it's still probably best to stick to one or the other, and use --resync when you need to switch.

Renamed directories

By default, renaming a folder on the Path1 side results in deleting all files on the Path2 side and then copying all files again from Path1 to Path2. Bisync sees this as all files in the old directory name as deleted and all files in the new directory name as new.

A recommended solution is to use --track-renames, which is now supported in bisync as of rclone v1.66. Note that --track-renames is not available during --resync, as --resync does not delete anything (--track-renames only supports sync, not copy.)

Otherwise, the most effective and efficient method of renaming a directory is to rename it to the same name on both sides. (As of rclone v1.64, a --resync is no longer required after doing so, as bisync will automatically detect that Path1 and Path2 are in agreement.)

--fast-list used by default

Unlike most other rclone commands, bisync uses --fast-list by default, for backends that support it. In many cases this is desirable, however, there are some scenarios in which bisync could be faster without --fast-list, and there is also a known issue concerning Google Drive users with many empty directories. For now, the recommended way to avoid using --fast-list is to add --disable ListR to all bisync commands. The default behavior may change in a future version.

Case (and unicode) sensitivity

As of v1.66, case and unicode form differences no longer cause critical errors, and normalization (when comparing between filesystems) is handled according to the same flags and defaults as rclone sync. See the following options (all of which are supported by bisync) to control this behavior more granularly:

Note that in the (probably rare) event that --fix-case is used AND a file is new/changed on both sides AND the checksums match AND the filename case does not match, the Path1 filename is considered the winner, for the purposes of --fix-case (Path2 will be renamed to match it).

Windows support

Bisync has been tested on Windows 8.1, Windows 10 Pro 64-bit and on Windows GitHub runners.

Drive letters are allowed, including drive letters mapped to network drives (rclone bisync J:\localsync GDrive:). If a drive letter is omitted, the shell current drive is the default. Drive letters are a single character follows by :, so cloud names must be more than one character long.

Absolute paths (with or without a drive letter), and relative paths (with or without a drive letter) are supported.

Working directory is created at C:\Users\MyLogin\AppData\Local\rclone\bisync.

Note that bisync output may show a mix of forward / and back \ slashes.

Be careful of case independent directory and file naming on Windows vs. case dependent Linux

Filtering

See filtering documentation for how filter rules are written and interpreted.

Bisync's --filters-file flag slightly extends the rclone's --filter-from filtering mechanism. For a given bisync run you may provide only one --filters-file. The --include*, --exclude*, and --filter flags are also supported.

How to filter directories

Filtering portions of the directory tree is a critical feature for syncing.

Examples of directory trees (always beneath the Path1/Path2 root level) you may want to exclude from your sync:

  • Directory trees containing only software build intermediate files.
  • Directory trees containing application temporary files and data such as the Windows C:\Users\MyLogin\AppData\ tree.
  • Directory trees containing files that are large, less important, or are getting thrashed continuously by ongoing processes.

On the other hand, there may be only select directories that you actually want to sync, and exclude all others. See the Example include-style filters for Windows user directories below.

Filters file writing guidelines

  1. Begin with excluding directory trees:
    • e.g. - /AppData/
    • ** on the end is not necessary. Once a given directory level is excluded then everything beneath it won't be looked at by rclone.
    • Exclude such directories that are unneeded, are big, dynamically thrashed, or where there may be access permission issues.
    • Excluding such dirs first will make rclone operations (much) faster.
    • Specific files may also be excluded, as with the Dropbox exclusions example below.
  2. Decide if it's easier (or cleaner) to:
    • Include select directories and therefore exclude everything else -- or --
    • Exclude select directories and therefore include everything else
  3. Include select directories:
    • Add lines like: + /Documents/PersonalFiles/** to select which directories to include in the sync.
    • ** on the end specifies to include the full depth of the specified tree.
    • With Include-style filters, files at the Path1/Path2 root are not included. They may be included with + /*.
    • Place RCLONE_TEST files within these included directory trees. They will only be looked for in these directory trees.
    • Finish by excluding everything else by adding - ** at the end of the filters file.
    • Disregard step 4.
  4. Exclude select directories:
    • Add more lines like in step 1. For example: -/Desktop/tempfiles/, or - /testdir/. Again, a ** on the end is not necessary.
    • Do not add a - ** in the file. Without this line, everything will be included that has not been explicitly excluded.
    • Disregard step 3.

A few rules for the syntax of a filter file expanding on filtering documentation:

  • Lines may start with spaces and tabs - rclone strips leading whitespace.
  • If the first non-whitespace character is a # then the line is a comment and will be ignored.
  • Blank lines are ignored.
  • The first non-whitespace character on a filter line must be a + or -.
  • Exactly 1 space is allowed between the +/- and the path term.
  • Only forward slashes (/) are used in path terms, even on Windows.
  • The rest of the line is taken as the path term. Trailing whitespace is taken literally, and probably is an error.

Example include-style filters for Windows user directories

This Windows include-style example is based on the sync root (Path1) set to C:\Users\MyLogin. The strategy is to select specific directories to be synched with a network drive (Path2).

  • - /AppData/ excludes an entire tree of Windows stored stuff that need not be synched. In my case, AppData has >11 GB of stuff I don't care about, and there are some subdirectories beneath AppData that are not accessible to my user login, resulting in bisync critical aborts.
  • Windows creates cache files starting with both upper and lowercase NTUSER at C:\Users\MyLogin. These files may be dynamic, locked, and are generally don't care.
  • There are just a few directories with my data that I do want synched, in the form of + /<path>. By selecting only the directory trees I want to avoid the dozen plus directories that various apps make at C:\Users\MyLogin\Documents.
  • Include files in the root of the sync point, C:\Users\MyLogin, by adding the + /* line.
  • This is an Include-style filters file, therefore it ends with - ** which excludes everything not explicitly included.
- /AppData/
- NTUSER*
- ntuser*
+ /Documents/Family/**
+ /Documents/Sketchup/**
+ /Documents/Microcapture_Photo/**
+ /Documents/Microcapture_Video/**
+ /Desktop/**
+ /Pictures/**
+ /*
- **

Note also that Windows implements several "library" links such as C:\Users\MyLogin\My Documents\My Music pointing to C:\Users\MyLogin\Music. rclone sees these as links, so you must add --links to the bisync command line if you which to follow these links. I find that I get permission errors in trying to follow the links, so I don't include the rclone --links flag, but then you get lots of Can't follow symlink… noise from rclone about not following the links. This noise can be quashed by adding --quiet to the bisync command line.

Example exclude-style filters files for use with Dropbox

  • Dropbox disallows syncing the listed temporary and configuration/data files. The - <filename> filters exclude these files where ever they may occur in the sync tree. Consider adding similar exclusions for file types you don't need to sync, such as core dump and software build files.
  • bisync testing creates /testdir/ at the top level of the sync tree, and usually deletes the tree after the test. If a normal sync should run while the /testdir/ tree exists the --check-access phase may fail due to unbalanced RCLONE_TEST files. The - /testdir/ filter blocks this tree from being synched. You don't need this exclusion if you are not doing bisync development testing.
  • Everything else beneath the Path1/Path2 root will be synched.
  • RCLONE_TEST files may be placed anywhere within the tree, including the root.

Example filters file for Dropbox

# Filter file for use with bisync
# See https://rclone.org/filtering/ for filtering rules
# NOTICE: If you make changes to this file you MUST do a --resync run.
#         Run with --dry-run to see what changes will be made.

# Dropbox won't sync some files so filter them away here.
# See https://help.dropbox.com/installs-integrations/sync-uploads/files-not-syncing
- .dropbox.attr
- ~*.tmp
- ~$*
- .~*
- desktop.ini
- .dropbox

# Used for bisync testing, so excluded from normal runs
- /testdir/

# Other example filters
#- /TiBU/
#- /Photos/

How --check-access handles filters

At the start of a bisync run, listings are gathered for Path1 and Path2 while using the user's --filters-file. During the check access phase, bisync scans these listings for RCLONE_TEST files. Any RCLONE_TEST files hidden by the --filters-file are not in the listings and thus not checked during the check access phase.

Troubleshooting

Reading bisync logs

Here are two normal runs. The first one has a newer file on the remote. The second has no deltas between local and remote.

2021/05/16 00:24:38 INFO  : Synching Path1 "/path/to/local/tree/" with Path2 "dropbox:/"
2021/05/16 00:24:38 INFO  : Path1 checking for diffs
2021/05/16 00:24:38 INFO  : - Path1    File is new                         - file.txt
2021/05/16 00:24:38 INFO  : Path1:    1 changes:    1 new,    0 newer,    0 older,    0 deleted
2021/05/16 00:24:38 INFO  : Path2 checking for diffs
2021/05/16 00:24:38 INFO  : Applying changes
2021/05/16 00:24:38 INFO  : - Path1    Queue copy to Path2                 - dropbox:/file.txt
2021/05/16 00:24:38 INFO  : - Path1    Do queued copies to                 - Path2
2021/05/16 00:24:38 INFO  : Updating listings
2021/05/16 00:24:38 INFO  : Validating listings for Path1 "/path/to/local/tree/" vs Path2 "dropbox:/"
2021/05/16 00:24:38 INFO  : Bisync successful

2021/05/16 00:36:52 INFO  : Synching Path1 "/path/to/local/tree/" with Path2 "dropbox:/"
2021/05/16 00:36:52 INFO  : Path1 checking for diffs
2021/05/16 00:36:52 INFO  : Path2 checking for diffs
2021/05/16 00:36:52 INFO  : No changes found
2021/05/16 00:36:52 INFO  : Updating listings
2021/05/16 00:36:52 INFO  : Validating listings for Path1 "/path/to/local/tree/" vs Path2 "dropbox:/"
2021/05/16 00:36:52 INFO  : Bisync successful

Dry run oddity

The --dry-run messages may indicate that it would try to delete some files. For example, if a file is new on Path2 and does not exist on Path1 then it would normally be copied to Path1, but with --dry-run enabled those copies don't happen, which leads to the attempted delete on Path2, blocked again by --dry-run: ... Not deleting as --dry-run.

This whole confusing situation is an artifact of the --dry-run flag. Scrutinize the proposed deletes carefully, and if the files would have been copied to Path1 then the threatened deletes on Path2 may be disregarded.

Retries

Rclone has built-in retries. If you run with --verbose you'll see error and retry messages such as shown below. This is usually not a bug. If at the end of the run, you see Bisync successful and not Bisync critical error or Bisync aborted then the run was successful, and you can ignore the error messages.

The following run shows an intermittent fail. Lines 5 and 6 are low-level messages. Line 6 is a bubbled-up warning message, conveying the error. Rclone normally retries failing commands, so there may be numerous such messages in the log.

Since there are no final error/warning messages on line 7, rclone has recovered from failure after a retry, and the overall sync was successful.

1: 2021/05/14 00:44:12 INFO  : Synching Path1 "/path/to/local/tree" with Path2 "dropbox:"
2: 2021/05/14 00:44:12 INFO  : Path1 checking for diffs
3: 2021/05/14 00:44:12 INFO  : Path2 checking for diffs
4: 2021/05/14 00:44:12 INFO  : Path2:  113 changes:   22 new,    0 newer,    0 older,   91 deleted
5: 2021/05/14 00:44:12 ERROR : /path/to/local/tree/objects/af: error listing: unexpected end of JSON input
6: 2021/05/14 00:44:12 NOTICE: WARNING  listing try 1 failed.                 - dropbox:
7: 2021/05/14 00:44:12 INFO  : Bisync successful

This log shows a Critical failure which requires a --resync to recover from. See the Runtime Error Handling section.

2021/05/12 00:49:40 INFO  : Google drive root '': Waiting for checks to finish
2021/05/12 00:49:40 INFO  : Google drive root '': Waiting for transfers to finish
2021/05/12 00:49:40 INFO  : Google drive root '': not deleting files as there were IO errors
2021/05/12 00:49:40 ERROR : Attempt 3/3 failed with 3 errors and: not deleting files as there were IO errors
2021/05/12 00:49:40 ERROR : Failed to sync: not deleting files as there were IO errors
2021/05/12 00:49:40 NOTICE: WARNING  rclone sync try 3 failed.           - /path/to/local/tree/
2021/05/12 00:49:40 ERROR : Bisync aborted. Must run --resync to recover.

Denied downloads of "infected" or "abusive" files

Google Drive has a filter for certain file types (.exe, .apk, et cetera) that by default cannot be copied from Google Drive to the local filesystem. If you are having problems, run with --verbose to see specifically which files are generating complaints. If the error is This file has been identified as malware or spam and cannot be downloaded, consider using the flag --drive-acknowledge-abuse.

Google Docs (and other files of unknown size)

As of v1.66, Google Docs (including Google Sheets, Slides, etc.) are now supported in bisync, subject to the same options, defaults, and limitations as in rclone sync. When bisyncing drive with non-drive backends, the drive -> non-drive direction is controlled by --drive-export-formats (default "docx,xlsx,pptx,svg") and the non-drive -> drive direction is controlled by --drive-import-formats (default none.)

For example, with the default export/import formats, a Google Sheet on the drive side will be synced to an .xlsx file on the non-drive side. In the reverse direction, .xlsx files with filenames that match an existing Google Sheet will be synced to that Google Sheet, while .xlsx files that do NOT match an existing Google Sheet will be copied to drive as normal .xlsx files (without conversion to Sheets, although the Google Drive web browser UI may still give you the option to open it as one.)

If --drive-import-formats is set (it's not, by default), then all of the specified formats will be converted to Google Docs, if there is no existing Google Doc with a matching name. Caution: such conversion can be quite lossy, and in most cases it's probably not what you want!

To bisync Google Docs as URL shortcut links (in a manner similar to "Drive for Desktop"), use: --drive-export-formats url (or alternatives.)

Note that these link files cannot be edited on the non-drive side -- you will get errors if you try to sync an edited link file back to drive. They CAN be deleted (it will result in deleting the corresponding Google Doc.) If you create a .url file on the non-drive side that does not match an existing Google Doc, bisyncing it will just result in copying the literal .url file over to drive (no Google Doc will be created.) So, as a general rule of thumb, think of them as read-only placeholders on the non-drive side, and make all your changes on the drive side.

Likewise, even with other export-formats, it is best to only move/rename Google Docs on the drive side. This is because otherwise, bisync will interpret this as a file deleted and another created, and accordingly, it will delete the Google Doc and create a new file at the new path. (Whether or not that new file is a Google Doc depends on --drive-import-formats.)

Lastly, take note that all Google Docs on the drive side have a size of -1 and no checksum. Therefore, they cannot be reliably synced with the --checksum or --size-only flags. (To be exact: they will still get created/deleted, and bisync's delta engine will notice changes and queue them for syncing, but the underlying sync function will consider them identical and skip them.) To work around this, use the default (modtime and size) instead of --checksum or --size-only.

To ignore Google Docs entirely, use --drive-skip-gdocs.

Usage examples

Cron

Rclone does not yet have a built-in capability to monitor the local file system for changes and must be blindly run periodically. On Windows this can be done using a Task Scheduler, on Linux you can use Cron which is described below.

The 1st example runs a sync every 5 minutes between a local directory and an OwnCloud server, with output logged to a runlog file:

# Minute (0-59)
#      Hour (0-23)
#           Day of Month (1-31)
#                Month (1-12 or Jan-Dec)
#                     Day of Week (0-6 or Sun-Sat)
#                         Command
  */5  *    *    *    *   /path/to/rclone bisync /local/files MyCloud: --check-access --filters-file /path/to/bysync-filters.txt --log-file /path/to//bisync.log

See crontab syntax for the details of crontab time interval expressions.

If you run rclone bisync as a cron job, redirect stdout/stderr to a file. The 2nd example runs a sync to Dropbox every hour and logs all stdout (via the >>) and stderr (via 2>&1) to a log file.

0 * * * * /path/to/rclone bisync /path/to/local/dropbox Dropbox: --check-access --filters-file /home/user/filters.txt >> /path/to/logs/dropbox-run.log 2>&1

Sharing an encrypted folder tree between hosts

bisync can keep a local folder in sync with a cloud service, but what if you have some highly sensitive files to be synched?

Usage of a cloud service is for exchanging both routine and sensitive personal files between one's home network, one's personal notebook when on the road, and with one's work computer. The routine data is not sensitive. For the sensitive data, configure an rclone crypt remote to point to a subdirectory within the local disk tree that is bisync'd to Dropbox, and then set up an bisync for this local crypt directory to a directory outside of the main sync tree.

Linux server setup

  • /path/to/DBoxroot is the root of my local sync tree. There are numerous subdirectories.
  • /path/to/DBoxroot/crypt is the root subdirectory for files that are encrypted. This local directory target is setup as an rclone crypt remote named Dropcrypt:. See rclone.conf snippet below.
  • /path/to/my/unencrypted/files is the root of my sensitive files - not encrypted, not within the tree synched to Dropbox.
  • To sync my local unencrypted files with the encrypted Dropbox versions I manually run bisync /path/to/my/unencrypted/files DropCrypt:. This step could be bundled into a script to run before and after the full Dropbox tree sync in the last step, thus actively keeping the sensitive files in sync.
  • bisync /path/to/DBoxroot Dropbox: runs periodically via cron, keeping my full local sync tree in sync with Dropbox.

Windows notebook setup

  • The Dropbox client runs keeping the local tree C:\Users\MyLogin\Dropbox always in sync with Dropbox. I could have used rclone bisync instead.
  • A separate directory tree at C:\Users\MyLogin\Documents\DropLocal hosts the tree of unencrypted files/folders.
  • To sync my local unencrypted files with the encrypted Dropbox versions I manually run the following command: rclone bisync C:\Users\MyLogin\Documents\DropLocal Dropcrypt:.
  • The Dropbox client then syncs the changes with Dropbox.

rclone.conf snippet

[Dropbox]
type = dropbox
...

[Dropcrypt]
type = crypt
remote = /path/to/DBoxroot/crypt          # on the Linux server
remote = C:\Users\MyLogin\Dropbox\crypt   # on the Windows notebook
filename_encryption = standard
directory_name_encryption = true
password = ...
...

Testing

You should read this section only if you are developing for rclone. You need to have rclone source code locally to work with bisync tests.

Bisync has a dedicated test framework implemented in the bisync_test.go file located in the rclone source tree. The test suite is based on the go test command. Series of tests are stored in subdirectories below the cmd/bisync/testdata directory. Individual tests can be invoked by their directory name, e.g. go test . -case basic -remote local -remote2 gdrive: -v

Tests will make a temporary folder on remote and purge it afterwards. If during test run there are intermittent errors and rclone retries, these errors will be captured and flagged as invalid MISCOMPAREs. Rerunning the test will let it pass. Consider such failures as noise.

Test command syntax

usage: go test ./cmd/bisync [options...]

Options:
  -case NAME        Name(s) of the test case(s) to run. Multiple names should
                    be separated by commas. You can remove the `test_` prefix
                    and replace `_` by `-` in test name for convenience.
                    If not `all`, the name(s) should map to a directory under
                    `./cmd/bisync/testdata`.
                    Use `all` to run all tests (default: all)
  -remote PATH1     `local` or name of cloud service with `:` (default: local)
  -remote2 PATH2    `local` or name of cloud service with `:` (default: local)
  -no-compare       Disable comparing test results with the golden directory
                    (default: compare)
  -no-cleanup       Disable cleanup of Path1 and Path2 testdirs.
                    Useful for troubleshooting. (default: cleanup)
  -golden           Store results in the golden directory (default: false)
                    This flag can be used with multiple tests.
  -debug            Print debug messages
  -stop-at NUM      Stop test after given step number. (default: run to the end)
                    Implies `-no-compare` and `-no-cleanup`, if the test really
                    ends prematurely. Only meaningful for a single test case.
  -refresh-times    Force refreshing the target modtime, useful for Dropbox
                    (default: false)
  -verbose          Run tests verbosely

Note: unlike rclone flags which must be prefixed by double dash (--), the test command flags can be equally prefixed by a single - or double dash.

Running tests

  • go test . -case basic -remote local -remote2 local runs the test_basic test case using only the local filesystem, syncing one local directory with another local directory. Test script output is to the console, while commands within scenario.txt have their output sent to the .../workdir/test.log file, which is finally compared to the golden copy.
  • The first argument after go test should be a relative name of the directory containing bisync source code. If you run tests right from there, the argument will be . (current directory) as in most examples below. If you run bisync tests from the rclone source directory, the command should be go test ./cmd/bisync ....
  • The test engine will mangle rclone output to ensure comparability with golden listings and logs.
  • Test scenarios are located in ./cmd/bisync/testdata. The test -case argument should match the full name of a subdirectory under that directory. Every test subdirectory name on disk must start with test_, this prefix can be omitted on command line for brevity. Also, underscores in the name can be replaced by dashes for convenience.
  • go test . -remote local -remote2 local -case all runs all tests.
  • Path1 and Path2 may either be the keyword local or may be names of configured cloud services. go test . -remote gdrive: -remote2 dropbox: -case basic will run the test between these two services, without transferring any files to the local filesystem.
  • Test run stdout and stderr console output may be directed to a file, e.g. go test . -remote gdrive: -remote2 local -case all > runlog.txt 2>&1

Test execution flow

  1. The base setup in the initial directory of the testcase is applied on the Path1 and Path2 filesystems (via rclone copy the initial directory to Path1, then rclone sync Path1 to Path2).
  2. The commands in the scenario.txt file are applied, with output directed to the test.log file in the test working directory. Typically, the first actual command in the scenario.txt file is to do a --resync, which establishes the baseline {...}.path1.lst and {...}.path2.lst files in the test working directory (.../workdir/ relative to the temporary test directory). Various commands and listing snapshots are done within the test.
  3. Finally, the contents of the test working directory are compared to the contents of the testcase's golden directory.

Notes about testing

  • Test cases are in individual directories beneath ./cmd/bisync/testdata. A command line reference to a test is understood to reference a directory beneath testdata. For example, go test ./cmd/bisync -case dry-run -remote gdrive: -remote2 local refers to the test case in ./cmd/bisync/testdata/test_dry_run.
  • The test working directory is located at .../workdir relative to a temporary test directory, usually under /tmp on Linux.
  • The local test sync tree is created at a temporary directory named like bisync.XXX under system temporary directory.
  • The remote test sync tree is located at a temporary directory under <remote:>/bisync.XXX/.
  • path1 and/or path2 subdirectories are created in a temporary directory under the respective local or cloud test remote.
  • By default, the Path1 and Path2 test dirs and workdir will be deleted after each test run. The -no-cleanup flag disables purging these directories when validating and debugging a given test. These directories will be flushed before running another test, independent of the -no-cleanup usage.
  • You will likely want to add - /testdir/ to your normal bisync --filters-file so that normal syncs do not attempt to sync the test temporary directories, which may have RCLONE_TEST miscompares in some testcases which would otherwise trip the --check-access system. The --check-access mechanism is hard-coded to ignore RCLONE_TEST files beneath bisync/testdata, so the test cases may reside on the synched tree even if there are check file mismatches in the test tree.
  • Some Dropbox tests can fail, notably printing the following message: src and dst identical but can't set mod time without deleting and re-uploading This is expected and happens due to the way Dropbox handles modification times. You should use the -refresh-times test flag to make up for this.
  • If Dropbox tests hit request limit for you and print error message too_many_requests/...: Too many requests or write operations. then follow the Dropbox App ID instructions.

Updating golden results

Sometimes even a slight change in the bisync source can cause little changes spread around many log files. Updating them manually would be a nightmare.

The -golden flag will store the test.log and *.lst listings from each test case into respective golden directories. Golden results will automatically contain generic strings instead of local or cloud paths which means that they should match when run with a different cloud service.

Your normal workflow might be as follows:

  1. Git-clone the rclone sources locally
  2. Modify bisync source and check that it builds
  3. Run the whole test suite go test ./cmd/bisync -remote local
  4. If some tests show log difference, recheck them individually, e.g.: go test ./cmd/bisync -remote local -case basic
  5. If you are convinced with the difference, goldenize all tests at once: go test ./cmd/bisync -remote local -golden
  6. Use word diff: git diff --word-diff ./cmd/bisync/testdata/. Please note that normal line-level diff is generally useless here.
  7. Check the difference carefully!
  8. Commit the change (git commit) only if you are sure. If unsure, save your code changes then wipe the log diffs from git: git reset [--hard].

Structure of test scenarios

  • <testname>/initial/ contains a tree of files that will be set as the initial condition on both Path1 and Path2 testdirs.
  • <testname>/modfiles/ contains files that will be used to modify the Path1 and/or Path2 filesystems.
  • <testname>/golden/ contains the expected content of the test working directory (workdir) at the completion of the testcase.
  • <testname>/scenario.txt contains the body of the test, in the form of various commands to modify files, run bisync, and snapshot listings. Output from these commands is captured to .../workdir/test.log for comparison to the golden files.

Supported test commands

  • test <some message> Print the line to the console and to the test.log: test sync is working correctly with options x, y, z
  • copy-listings <prefix> Save a copy of all .lst listings in the test working directory with the specified prefix: save-listings exclude-pass-run
  • move-listings <prefix> Similar to copy-listings but removes the source
  • purge-children <dir> This will delete all child files and purge all child subdirs under given directory but keep the parent intact. This behavior is important for tests with Google Drive because removing and re-creating the parent would change its ID.
  • delete-file <file> Delete a single file.
  • delete-glob <dir> <pattern> Delete a group of files located one level deep in the given directory with names matching a given glob pattern.
  • touch-glob YYYY-MM-DD <dir> <pattern> Change modification time on a group of files.
  • touch-copy YYYY-MM-DD <source-file> <dest-dir> Change file modification time then copy it to destination.
  • copy-file <source-file> <dest-dir> Copy a single file to given directory.
  • copy-as <source-file> <dest-file> Similar to above but destination must include both directory and the new file name at destination.
  • copy-dir <src> <dst> and sync-dir <src> <dst> Copy/sync a directory. Equivalent of rclone copy and rclone sync.
  • list-dirs <dir> Equivalent to rclone lsf -R --dirs-only <dir>
  • bisync [options] Runs bisync against -remote and -remote2.

Supported substitution terms

  • {testdir/} - the root dir of the testcase
  • {datadir/} - the modfiles dir under the testcase root
  • {workdir/} - the temporary test working directory
  • {path1/} - the root of the Path1 test directory tree
  • {path2/} - the root of the Path2 test directory tree
  • {session} - base name of the test listings
  • {/} - OS-specific path separator
  • {spc}, {tab}, {eol} - whitespace
  • {chr:HH} - raw byte with given hexadecimal code

Substitution results of the terms named like {dir/} will end with / (or backslash on Windows), so it is not necessary to include slash in the usage, for example delete-file {path1/}file1.txt.

Benchmarks

This section is work in progress.

Here are a few data points for scale, execution times, and memory usage.

The first set of data was taken between a local disk to Dropbox. The speedtest.net download speed was ~170 Mbps, and upload speed was ~10 Mbps. 500 files (~9.5 MB each) had been already synched. 50 files were added in a new directory, each ~9.5 MB, ~475 MB total.

Change Operations and times Overall run time
500 files synched (nothing to move) 1x listings for Path1 & Path2 1.5 sec
500 files synched with --check-access 1x listings for Path1 & Path2 1.5 sec
50 new files on remote Queued 50 copies down: 27 sec 29 sec
Moved local dir Queued 50 copies up: 410 sec, 50 deletes up: 9 sec 421 sec
Moved remote dir Queued 50 copies down: 31 sec, 50 deletes down: <1 sec 33 sec
Delete local dir Queued 50 deletes up: 9 sec 13 sec

This next data is from a user's application. They had ~400GB of data over 1.96 million files being sync'ed between a Windows local disk and some remote cloud. The file full path length was on average 35 characters (which factors into load time and RAM required).

  • Loading the prior listing into memory (1.96 million files, listing file size 140 MB) took ~30 sec and occupied about 1 GB of RAM.
  • Getting a fresh listing of the local file system (producing the 140 MB output file) took about XXX sec.
  • Getting a fresh listing of the remote file system (producing the 140 MB output file) took about XXX sec. The network download speed was measured at XXX Mb/s.
  • Once the prior and current Path1 and Path2 listings were loaded (a total of four to be loaded, two at a time), determining the deltas was pretty quick (a few seconds for this test case), and the transfer time for any files to be copied was dominated by the network bandwidth.

References

rclone's bisync implementation was derived from the rclonesync-V2 project, including documentation and test mechanisms, with @cjnaz's full support and encouragement.

rclone bisync is similar in nature to a range of other projects:

Bisync adopts the differential synchronization technique, which is based on keeping history of changes performed by both synchronizing sides. See the Dual Shadow Method section in Neil Fraser's article.

Also note a number of academic publications by Benjamin Pierce about Unison and synchronization in general.

Changelog

v1.71

  • bisync is now officially released from beta.

  • Fixed an issue causing hash type to be set incorrectly if path2 had slow hashes and --no-slow-hash or --slow-hash-sync-only was in use.

  • Fixed an issue causing errors when running concurrent bisync runs through the rc.

v1.69.1

  • Fixed an issue causing listings to not capture concurrent modifications under certain conditions

v1.68

  • Fixed an issue affecting backends that round modtimes to a lower precision.

v1.67

  • Added integration tests against all backends.

v1.66

  • Copies and deletes are now handled in one operation instead of two

  • --track-renames and --backup-dir are now supported

  • Partial uploads known issue on local/ftp/sftp has been resolved (unless using --inplace)

  • Final listings are now generated from sync results, to avoid needing to re-list

  • Bisync is now much more resilient to changes that happen during a bisync run, and far less prone to critical errors / undetected changes

  • Bisync is now capable of rolling a file listing back in cases of uncertainty, essentially marking the file as needing to be rechecked next time.

  • A few basic terminal colors are now supported, controllable with --color (AUTO|NEVER|ALWAYS)

  • Initial listing snapshots of Path1 and Path2 are now generated concurrently, using the same "march" infrastructure as check and sync, for performance improvements and less risk of error.

  • Fixed handling of unicode normalization and case insensitivity, support for --fix-case, --ignore-case-sync, --no-unicode-normalization

  • --resync is now much more efficient (especially for users of --create-empty-src-dirs)

  • Google Docs (and other files of unknown size) are now supported (with the same options as in sync)

  • Equality checks before a sync conflict rename now fall back to cryptcheck (when possible) or --download, instead of of --size-only, when check is not available.

  • Bisync no longer fails to find the correct listing file when configs are overridden with backend-specific flags.

  • Bisync now fully supports comparing based on any combination of size, modtime, and checksum, lifting the prior restriction on backends without modtime support.

  • Bisync now supports a "Graceful Shutdown" mode to cleanly cancel a run early without requiring --resync.

  • New --recover flag allows robust recovery in the event of interruptions, without requiring --resync.

  • A new --max-lock setting allows lock files to automatically renew and expire, for better automatic recovery when a run is interrupted.

  • Bisync now supports auto-resolving sync conflicts and customizing rename behavior with new --conflict-resolve, --conflict-loser, and --conflict-suffix flags.

  • A new --resync-mode flag allows more control over which version of a file gets kept during a --resync.

  • Bisync now supports --retries and --retries-sleep (when --resilient is set.)

v1.64

Release signing

The hashes of the binary artefacts of the rclone release are signed with a public PGP/GPG key. This can be verified manually as described below.

The same mechanism is also used by rclone selfupdate to verify that the release has not been tampered with before the new update is installed. This checks the SHA256 hash and the signature with a public key compiled into the rclone binary.

Release signing key

You may obtain the release signing key from:

  • From KEYS on this website - this file contains all past signing keys also.
  • The git repository hosted on GitHub - https://github.com/rclone/rclone/blob/master/docs/content/KEYS
  • gpg --keyserver hkps://keys.openpgp.org --search nick@craig-wood.com
  • gpg --keyserver hkps://keyserver.ubuntu.com --search nick@craig-wood.com
  • https://www.craig-wood.com/nick/pub/pgp-key.txt

After importing the key, verify that the fingerprint of one of the keys matches: FBF737ECE9F8AB18604BD2AC93935E02FF3B54FA as this key is used for signing.

We recommend that you cross-check the fingerprint shown above through the domains listed below. By cross-checking the integrity of the fingerprint across multiple domains you can be confident that you obtained the correct key.

If you find anything that doesn't not match, please contact the developers at once.

How to verify the release

In the release directory you will see the release files and some files called MD5SUMS, SHA1SUMS and SHA256SUMS.

$ rclone lsf --http-url https://downloads.rclone.org/v1.63.1 :http:
MD5SUMS
SHA1SUMS
SHA256SUMS
rclone-v1.63.1-freebsd-386.zip
rclone-v1.63.1-freebsd-amd64.zip
...
rclone-v1.63.1-windows-arm64.zip
rclone-v1.63.1.tar.gz
version.txt

The MD5SUMS, SHA1SUMS and SHA256SUMS contain hashes of the binary files in the release directory along with a signature.

For example:

$ rclone cat --http-url https://downloads.rclone.org/v1.63.1 :http:SHA256SUMS
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

f6d1b2d7477475ce681bdce8cb56f7870f174cb6b2a9ac5d7b3764296ea4a113  rclone-v1.63.1-freebsd-386.zip
7266febec1f01a25d6575de51c44ddf749071a4950a6384e4164954dff7ac37e  rclone-v1.63.1-freebsd-amd64.zip
...
66ca083757fb22198309b73879831ed2b42309892394bf193ff95c75dff69c73  rclone-v1.63.1-windows-amd64.zip
bbb47c16882b6c5f2e8c1b04229378e28f68734c613321ef0ea2263760f74cd0  rclone-v1.63.1-windows-arm64.zip
-----BEGIN PGP SIGNATURE-----

iF0EARECAB0WIQT79zfs6firGGBL0qyTk14C/ztU+gUCZLVKJQAKCRCTk14C/ztU
+pZuAJ0XJ+QWLP/3jCtkmgcgc4KAwd/rrwCcCRZQ7E+oye1FPY46HOVzCFU3L7g=
=8qrL
-----END PGP SIGNATURE-----

Download the files

The first step is to download the binary and SUMs file and verify that the SUMs you have downloaded match. Here we download rclone-v1.63.1-windows-amd64.zip - choose the binary (or binaries) appropriate to your architecture. We've also chosen the SHA256SUMS as these are the most secure. You could verify the other types of hash also for extra security. rclone selfupdate verifies just the SHA256SUMS.

$ mkdir /tmp/check
$ cd /tmp/check
$ rclone copy --http-url https://downloads.rclone.org/v1.63.1 :http:SHA256SUMS .
$ rclone copy --http-url https://downloads.rclone.org/v1.63.1 :http:rclone-v1.63.1-windows-amd64.zip .

Verify the signatures

First verify the signatures on the SHA256 file.

Import the key. See above for ways to verify this key is correct.

$ gpg --keyserver keyserver.ubuntu.com --receive-keys FBF737ECE9F8AB18604BD2AC93935E02FF3B54FA
gpg: key 93935E02FF3B54FA: public key "Nick Craig-Wood <nick@craig-wood.com>" imported
gpg: Total number processed: 1
gpg:               imported: 1

Then check the signature:

$ gpg --verify SHA256SUMS 
gpg: Signature made Mon 17 Jul 2023 15:03:17 BST
gpg:                using DSA key FBF737ECE9F8AB18604BD2AC93935E02FF3B54FA
gpg: Good signature from "Nick Craig-Wood <nick@craig-wood.com>" [ultimate]

Verify the signature was good and is using the fingerprint shown above.

Repeat for MD5SUMS and SHA1SUMS if desired.

Verify the hashes

Now that we know the signatures on the hashes are OK we can verify the binaries match the hashes, completing the verification.

$ sha256sum -c SHA256SUMS 2>&1 | grep OK
rclone-v1.63.1-windows-amd64.zip: OK

Or do the check with rclone

$ rclone hashsum sha256 -C SHA256SUMS rclone-v1.63.1-windows-amd64.zip 
2023/09/11 10:53:58 NOTICE: SHA256SUMS: improperly formatted checksum line 0
2023/09/11 10:53:58 NOTICE: SHA256SUMS: improperly formatted checksum line 1
2023/09/11 10:53:58 NOTICE: SHA256SUMS: improperly formatted checksum line 49
2023/09/11 10:53:58 NOTICE: SHA256SUMS: 4 warning(s) suppressed...
= rclone-v1.63.1-windows-amd64.zip
2023/09/11 10:53:58 NOTICE: Local file system at /tmp/check: 0 differences found
2023/09/11 10:53:58 NOTICE: Local file system at /tmp/check: 1 matching files

Verify signatures and hashes together

You can verify the signatures and hashes in one command line like this:

$ h=$(gpg --decrypt SHA256SUMS) && echo "$h" | sha256sum - -c --ignore-missing
gpg: Signature made Mon 17 Jul 2023 15:03:17 BST
gpg:                using DSA key FBF737ECE9F8AB18604BD2AC93935E02FF3B54FA
gpg: Good signature from "Nick Craig-Wood <nick@craig-wood.com>" [ultimate]
gpg:                 aka "Nick Craig-Wood <nick@memset.com>" [unknown]
rclone-v1.63.1-windows-amd64.zip: OK

1Fichier

This is a backend for the 1fichier cloud storage service. Note that a Premium subscription is required to use the API.

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Configuration

The initial setup for 1Fichier involves getting the API key from the website which you need to do in your browser.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / 1Fichier
   \ "fichier"
[snip]
Storage> fichier
** See help for fichier backend at: https://rclone.org/fichier/ **

Your API Key, get it from https://1fichier.com/console/params.pl
Enter a string value. Press Enter for the default ("").
api_key> example_key

Edit advanced config? (y/n)
y) Yes
n) No
y/n> 
Remote config
Configuration complete.
Options:
- type: fichier
- api_key: example_key
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

Once configured you can then use rclone like this,

List directories in top level of your 1Fichier account

rclone lsd remote:

List all the files in your 1Fichier account

rclone ls remote:

To copy a local directory to a 1Fichier directory called backup

rclone copy /home/source remote:backup

Modification times and hashes

1Fichier does not support modification times. It supports the Whirlpool hash algorithm.

Duplicated files

1Fichier can have two files with exactly the same name and path (unlike a normal file system).

Duplicated files cause problems with the syncing and you will see messages in the log about duplicates.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
\ 0x5C ＼
< 0x3C ＜
> 0x3E ＞
" 0x22 ＂
$ 0x24 ＄
` 0x60 ｀
' 0x27 ＇

File names can also not start or end with the following characters. These only get replaced if they are the first or last character in the name:

Character Value Replacement
SP 0x20 ␠

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Standard options

Here are the Standard options specific to fichier (1Fichier).

--fichier-api-key

Your API Key, get it from https://1fichier.com/console/params.pl.

Properties:

  • Config: api_key
  • Env Var: RCLONE_FICHIER_API_KEY
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to fichier (1Fichier).

--fichier-shared-folder

If you want to download a shared folder, add this parameter.

Properties:

  • Config: shared_folder
  • Env Var: RCLONE_FICHIER_SHARED_FOLDER
  • Type: string
  • Required: false

--fichier-file-password

If you want to download a shared file that is password protected, add this parameter.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: file_password
  • Env Var: RCLONE_FICHIER_FILE_PASSWORD
  • Type: string
  • Required: false

--fichier-folder-password

If you want to list the files in a shared folder that is password protected, add this parameter.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: folder_password
  • Env Var: RCLONE_FICHIER_FOLDER_PASSWORD
  • Type: string
  • Required: false

--fichier-cdn

Set if you wish to use CDN download links.

Properties:

  • Config: cdn
  • Env Var: RCLONE_FICHIER_CDN
  • Type: bool
  • Default: false

--fichier-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_FICHIER_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,SingleQuote,BackQuote,Dollar,BackSlash,Del,Ctl,LeftSpace,RightSpace,InvalidUtf8,Dot

--fichier-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_FICHIER_DESCRIPTION
  • Type: string
  • Required: false

Limitations

rclone about is not supported by the 1Fichier backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

Alias

The alias remote provides a new name for another remote.

Paths may be as deep as required or a local path, e.g. remote:directory/subdirectory or /directory/subdirectory.

During the initial setup with rclone config you will specify the target remote. The target remote can either be a local path or another remote.

Subfolders can be used in target remote. Assume an alias remote named backup with the target mydrive:private/backup. Invoking rclone mkdir backup:desktop is exactly the same as invoking rclone mkdir mydrive:private/backup/desktop.

There will be no special handling of paths containing .. segments. Invoking rclone mkdir backup:../desktop is exactly the same as invoking rclone mkdir mydrive:private/backup/../desktop. The empty path is not allowed as a remote. To alias the current directory use . instead.

The target remote can also be a connection string. This can be used to modify the config of a remote for different uses, e.g. the alias myDriveTrash with the target remote myDrive,trashed_only: can be used to only show the trashed files in myDrive.

Configuration

Here is an example of how to make an alias called remote for local folder. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Alias for an existing remote
   \ "alias"
[snip]
Storage> alias
Remote or path to alias.
Can be "myremote:path/to/dir", "myremote:bucket", "myremote:" or "/local/path".
remote> /mnt/storage/backup
Remote config
Configuration complete.
Options:
- type: alias
- remote: /mnt/storage/backup
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y
Current remotes:

Name                 Type
====                 ====
remote               alias

e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> q

Once configured you can then use rclone like this,

List directories in top level in /mnt/storage/backup

rclone lsd remote:

List all the files in /mnt/storage/backup

rclone ls remote:

Copy another local directory to the alias directory called source

rclone copy /home/source remote:source

Standard options

Here are the Standard options specific to alias (Alias for an existing remote).

--alias-remote

Remote or path to alias.

Can be "myremote:path/to/dir", "myremote:bucket", "myremote:" or "/local/path".

Properties:

  • Config: remote
  • Env Var: RCLONE_ALIAS_REMOTE
  • Type: string
  • Required: true

Advanced options

Here are the Advanced options specific to alias (Alias for an existing remote).

--alias-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_ALIAS_DESCRIPTION
  • Type: string
  • Required: false

Amazon S3 Storage Providers

The S3 backend can be used with a number of different providers:

  • AWS S3
  • Alibaba Cloud (Aliyun) Object Storage System (OSS)
  • Ceph
  • China Mobile Ecloud Elastic Object Storage (EOS)
  • Cloudflare R2
  • Arvan Cloud Object Storage (AOS)
  • DigitalOcean Spaces
  • Dreamhost
  • Exaba
  • GCS
  • Huawei OBS
  • IBM COS S3
  • IDrive e2
  • IONOS Cloud
  • Leviia Object Storage
  • Liara Object Storage
  • Linode Object Storage
  • Magalu Object Storage
  • MEGA S4 Object Storage
  • Minio
  • Outscale
  • OVHcloud
  • Petabox
  • Pure Storage FlashBlade
  • Qiniu Cloud Object Storage (Kodo)
  • RackCorp Object Storage
  • Rclone Serve S3
  • Scaleway
  • Seagate Lyve Cloud
  • SeaweedFS
  • Selectel
  • StackPath
  • Storj
  • Synology C2 Object Storage
  • Tencent Cloud Object Storage (COS)
  • Wasabi
  • Zata

Paths are specified as remote:bucket (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:bucket/path/to/dir.

Once you have made a remote (see the provider specific section above) you can use it like this:

See all buckets

rclone lsd remote:

Make a new bucket

rclone mkdir remote:bucket

List the contents of a bucket

rclone ls remote:bucket

Sync /home/local/directory to the remote bucket, deleting any excess files in the bucket.

rclone sync --interactive /home/local/directory remote:bucket

Configuration

Here is an example of making an s3 configuration for the AWS S3 provider. Most applies to the other providers as well, any differences are described below.

First run

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ "s3"
[snip]
Storage> s3
Choose your S3 provider.
Choose a number from below, or type in your own value
 1 / Amazon Web Services (AWS) S3
   \ "AWS"
 2 / Ceph Object Storage
   \ "Ceph"
 3 / DigitalOcean Spaces
   \ "DigitalOcean"
 4 / Dreamhost DreamObjects
   \ "Dreamhost"
 5 / IBM COS S3
   \ "IBMCOS"
 6 / Minio Object Storage
   \ "Minio"
 7 / Wasabi Object Storage
   \ "Wasabi"
 8 / Any other S3 compatible provider
   \ "Other"
provider> 1
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own value
 1 / Enter AWS credentials in the next step
   \ "false"
 2 / Get AWS credentials from the environment (env vars or IAM)
   \ "true"
env_auth> 1
AWS Access Key ID - leave blank for anonymous access or runtime credentials.
access_key_id> XXX
AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials.
secret_access_key> YYY
Region to connect to.
Choose a number from below, or type in your own value
   / The default endpoint - a good choice if you are unsure.
 1 | US Region, Northern Virginia, or Pacific Northwest.
   | Leave location constraint empty.
   \ "us-east-1"
   / US East (Ohio) Region
 2 | Needs location constraint us-east-2.
   \ "us-east-2"
   / US West (Oregon) Region
 3 | Needs location constraint us-west-2.
   \ "us-west-2"
   / US West (Northern California) Region
 4 | Needs location constraint us-west-1.
   \ "us-west-1"
   / Canada (Central) Region
 5 | Needs location constraint ca-central-1.
   \ "ca-central-1"
   / EU (Ireland) Region
 6 | Needs location constraint EU or eu-west-1.
   \ "eu-west-1"
   / EU (London) Region
 7 | Needs location constraint eu-west-2.
   \ "eu-west-2"
   / EU (Frankfurt) Region
 8 | Needs location constraint eu-central-1.
   \ "eu-central-1"
   / Asia Pacific (Singapore) Region
 9 | Needs location constraint ap-southeast-1.
   \ "ap-southeast-1"
   / Asia Pacific (Sydney) Region
10 | Needs location constraint ap-southeast-2.
   \ "ap-southeast-2"
   / Asia Pacific (Tokyo) Region
11 | Needs location constraint ap-northeast-1.
   \ "ap-northeast-1"
   / Asia Pacific (Seoul)
12 | Needs location constraint ap-northeast-2.
   \ "ap-northeast-2"
   / Asia Pacific (Mumbai)
13 | Needs location constraint ap-south-1.
   \ "ap-south-1"
   / Asia Pacific (Hong Kong) Region
14 | Needs location constraint ap-east-1.
   \ "ap-east-1"
   / South America (Sao Paulo) Region
15 | Needs location constraint sa-east-1.
   \ "sa-east-1"
region> 1
Endpoint for S3 API.
Leave blank if using AWS to use the default endpoint for the region.
endpoint>
Location constraint - must be set to match the Region. Used when creating buckets only.
Choose a number from below, or type in your own value
 1 / Empty for US Region, Northern Virginia, or Pacific Northwest.
   \ ""
 2 / US East (Ohio) Region.
   \ "us-east-2"
 3 / US West (Oregon) Region.
   \ "us-west-2"
 4 / US West (Northern California) Region.
   \ "us-west-1"
 5 / Canada (Central) Region.
   \ "ca-central-1"
 6 / EU (Ireland) Region.
   \ "eu-west-1"
 7 / EU (London) Region.
   \ "eu-west-2"
 8 / EU Region.
   \ "EU"
 9 / Asia Pacific (Singapore) Region.
   \ "ap-southeast-1"
10 / Asia Pacific (Sydney) Region.
   \ "ap-southeast-2"
11 / Asia Pacific (Tokyo) Region.
   \ "ap-northeast-1"
12 / Asia Pacific (Seoul)
   \ "ap-northeast-2"
13 / Asia Pacific (Mumbai)
   \ "ap-south-1"
14 / Asia Pacific (Hong Kong)
   \ "ap-east-1"
15 / South America (Sao Paulo) Region.
   \ "sa-east-1"
location_constraint> 1
Canned ACL used when creating buckets and/or storing objects in S3.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Choose a number from below, or type in your own value
 1 / Owner gets FULL_CONTROL. No one else has access rights (default).
   \ "private"
 2 / Owner gets FULL_CONTROL. The AllUsers group gets READ access.
   \ "public-read"
   / Owner gets FULL_CONTROL. The AllUsers group gets READ and WRITE access.
 3 | Granting this on a bucket is generally not recommended.
   \ "public-read-write"
 4 / Owner gets FULL_CONTROL. The AuthenticatedUsers group gets READ access.
   \ "authenticated-read"
   / Object owner gets FULL_CONTROL. Bucket owner gets READ access.
 5 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it.
   \ "bucket-owner-read"
   / Both the object owner and the bucket owner get FULL_CONTROL over the object.
 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it.
   \ "bucket-owner-full-control"
acl> 1
The server-side encryption algorithm used when storing this object in S3.
Choose a number from below, or type in your own value
 1 / None
   \ ""
 2 / AES256
   \ "AES256"
server_side_encryption> 1
The storage class to use when storing objects in S3.
Choose a number from below, or type in your own value
 1 / Default
   \ ""
 2 / Standard storage class
   \ "STANDARD"
 3 / Reduced redundancy storage class
   \ "REDUCED_REDUNDANCY"
 4 / Standard Infrequent Access storage class
   \ "STANDARD_IA"
 5 / One Zone Infrequent Access storage class
   \ "ONEZONE_IA"
 6 / Glacier Flexible Retrieval storage class
   \ "GLACIER"
 7 / Glacier Deep Archive storage class
   \ "DEEP_ARCHIVE"
 8 / Intelligent-Tiering storage class
   \ "INTELLIGENT_TIERING"
 9 / Glacier Instant Retrieval storage class
   \ "GLACIER_IR"
storage_class> 1
Remote config
Configuration complete.
Options:
- type: s3
- provider: AWS
- env_auth: false
- access_key_id: XXX
- secret_access_key: YYY
- region: us-east-1
- endpoint:
- location_constraint:
- acl: private
- server_side_encryption:
- storage_class:
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d>

Modification times and hashes

Modification times

The modified time is stored as metadata on the object as X-Amz-Meta-Mtime as floating point since the epoch, accurate to 1 ns.

If the modification time needs to be updated rclone will attempt to perform a server side copy to update the modification if the object can be copied in a single part. In the case the object is larger than 5Gb or is in Glacier or Glacier Deep Archive storage the object will be uploaded rather than copied.

Note that reading this from the object takes an additional HEAD request as the metadata isn't returned in object listings.

Hashes

For small objects which weren't uploaded as multipart uploads (objects sized below --s3-upload-cutoff if uploaded with rclone) rclone uses the ETag: header as an MD5 checksum.

However for objects which were uploaded as multipart uploads or with server side encryption (SSE-AWS or SSE-C) the ETag header is no longer the MD5 sum of the data, so rclone adds an additional piece of metadata X-Amz-Meta-Md5chksum which is a base64 encoded MD5 hash (in the same format as is required for Content-MD5). You can use base64 -d and hexdump to check this value manually:

echo 'VWTGdNx3LyXQDfA0e2Edxw==' | base64 -d | hexdump

or you can use rclone check to verify the hashes are OK.

For large objects, calculating this hash can take some time so the addition of this hash can be disabled with --s3-disable-checksum. This will mean that these objects do not have an MD5 checksum.

Note that reading this from the object takes an additional HEAD request as the metadata isn't returned in object listings.

Reducing costs

Avoiding HEAD requests to read the modification time

By default, rclone will use the modification time of objects stored in S3 for syncing. This is stored in object metadata which unfortunately takes an extra HEAD request to read which can be expensive (in time and money).

The modification time is used by default for all operations that require checking the time a file was last updated. It allows rclone to treat the remote more like a true filesystem, but it is inefficient on S3 because it requires an extra API call to retrieve the metadata.

The extra API calls can be avoided when syncing (using rclone sync or rclone copy) in a few different ways, each with its own tradeoffs.

  • --size-only
    • Only checks the size of files.
    • Uses no extra transactions.
    • If the file doesn't change size then rclone won't detect it has changed.
    • rclone sync --size-only /path/to/source s3:bucket
  • --checksum
    • Checks the size and MD5 checksum of files.
    • Uses no extra transactions.
    • The most accurate detection of changes possible.
    • Will cause the source to read an MD5 checksum which, if it is a local disk, will cause lots of disk activity.
    • If the source and destination are both S3 this is the recommended flag to use for maximum efficiency.
    • rclone sync --checksum /path/to/source s3:bucket
  • --update --use-server-modtime
    • Uses no extra transactions.
    • Modification time becomes the time the object was uploaded.
    • For many operations this is sufficient to determine if it needs uploading.
    • Using --update along with --use-server-modtime, avoids the extra API call and uploads files whose local modification time is newer than the time it was last uploaded.
    • Files created with timestamps in the past will be missed by the sync.
    • rclone sync --update --use-server-modtime /path/to/source s3:bucket

These flags can and should be used in combination with --fast-list - see below.

If using rclone mount or any command using the VFS (eg rclone serve) commands then you might want to consider using the VFS flag --no-modtime which will stop rclone reading the modification time for every object. You could also use --use-server-modtime if you are happy with the modification times of the objects being the time of upload.

Avoiding GET requests to read directory listings

Rclone's default directory traversal is to process each directory individually. This takes one API call per directory. Using the --fast-list flag will read all info about the objects into memory first using a smaller number of API calls (one per 1000 objects). See the rclone docs for more details.

rclone sync --fast-list --checksum /path/to/source s3:bucket

--fast-list trades off API transactions for memory use. As a rough guide rclone uses 1k of memory per object stored, so using --fast-list on a sync of a million objects will use roughly 1 GiB of RAM.

If you are only copying a small number of files into a big repository then using --no-traverse is a good idea. This finds objects directly instead of through directory listings. You can do a "top-up" sync very cheaply by using --max-age and --no-traverse to copy only recent files, eg

rclone copy --max-age 24h --no-traverse /path/to/source s3:bucket

You'd then do a full rclone sync less often.

Note that --fast-list isn't required in the top-up sync.

Avoiding HEAD requests after PUT

By default, rclone will HEAD every object it uploads. It does this to check the object got uploaded correctly.

You can disable this with the --s3-no-head option - see there for more details.

Setting this flag increases the chance for undetected upload failures.

Increasing performance

Using server-side copy

If you are copying objects between S3 buckets in the same region, you should use server-side copy. This is much faster than downloading and re-uploading the objects, as no data is transferred.

For rclone to use server-side copy, you must use the same remote for the source and destination.

rclone copy s3:source-bucket s3:destination-bucket

When using server-side copy, the performance is limited by the rate at which rclone issues API requests to S3. See below for how to increase the number of API requests rclone makes.

Increasing the rate of API requests

You can increase the rate of API requests to S3 by increasing the parallelism using --transfers and --checkers options.

Rclone uses a very conservative defaults for these settings, as not all providers support high rates of requests. Depending on your provider, you can increase significantly the number of transfers and checkers.

For example, with AWS S3, if you can increase the number of checkers to values like 200. If you are doing a server-side copy, you can also increase the number of transfers to 200.

rclone sync --transfers 200 --checkers 200 --checksum s3:source-bucket s3:destination-bucket

You will need to experiment with these values to find the optimal settings for your setup.

Data integrity

Rclone does its best to verify every part of an upload or download to the s3 provider using various hashes.

Every HTTP transaction to/from the provider has a X-Amz-Content-Sha256 or a Content-Md5 header to guard against corruption of the HTTP body. The HTTP Header is protected by the signature passed in the Authorization header.

All communications with the provider is done over https for encryption and additional error protection.

Single part uploads

  • Rclone uploads single part uploads with a Content-Md5 using the MD5 hash read from the source. The provider checks this is correct on receipt of the data.

  • Rclone then does a HEAD request (disable with --s3-no-head) to read the ETag back which is the MD5 of the file and checks that with what it sent.

Note that if the source does not have an MD5 then the single part uploads will not have hash protection. In this case it is recommended to use --s3-upload-cutoff 0 so all files are uploaded as multipart uploads.

Multipart uploads

For files above --s3-upload-cutoff rclone splits the file into multiple parts for upload.

  • Each part is protected with both an X-Amz-Content-Sha256 and a Content-Md5

When rclone has finished the upload of all the parts it then completes the upload by sending:

  • The MD5 hash of each part
  • The number of parts
  • This info is all protected with a X-Amz-Content-Sha256

The provider checks the MD5 for all the parts it has received against what rclone sends and if it is good it returns OK.

Rclone then does a HEAD request (disable with --s3-no-head) and checks the ETag is what it expects (in this case it should be the MD5 sum of all the MD5 sums of all the parts with the number of parts on the end).

If the source has an MD5 sum then rclone will attach the X-Amz-Meta-Md5chksum with it as the ETag for a multipart upload can't easily be checked against the file as the chunk size must be known in order to calculate it.

Downloads

Rclone checks the MD5 hash of the data downloaded against either the ETag or the X-Amz-Meta-Md5chksum metadata (if present) which rclone uploads with multipart uploads.

Further checking

At each stage rclone and the provider are sending and checking hashes of everything. Rclone deliberately HEADs each object after upload to check it arrived safely for extra security. (You can disable this with --s3-no-head).

If you require further assurance that your data is intact you can use rclone check to check the hashes locally vs the remote.

And if you are feeling ultimately paranoid use rclone check --download which will download the files and check them against the local copies. (Note that this doesn't use disk to do this - it streams them in memory).

Versions

When bucket versioning is enabled (this can be done with rclone with the rclone backend versioning command) when rclone uploads a new version of a file it creates a new version of it Likewise when you delete a file, the old version will be marked hidden and still be available.

Old versions of files, where available, are visible using the --s3-versions flag.

It is also possible to view a bucket as it was at a certain point in time, using the --s3-version-at flag. This will show the file versions as they were at that time, showing files that have been deleted afterwards, and hiding files that were created since.

If you wish to remove all the old versions then you can use the rclone backend cleanup-hidden remote:bucket command which will delete all the old hidden versions of files, leaving the current ones intact. You can also supply a path and only old versions under that path will be deleted, e.g. rclone backend cleanup-hidden remote:bucket/path/to/stuff.

When you purge a bucket, the current and the old versions will be deleted then the bucket will be deleted.

However delete will cause the current versions of the files to become hidden old versions.

Here is a session showing the listing and retrieval of an old version followed by a cleanup of the old versions.

Show current version and all the versions with --s3-versions flag.

$ rclone -q ls s3:cleanup-test
        9 one.txt

$ rclone -q --s3-versions ls s3:cleanup-test
        9 one.txt
        8 one-v2016-07-04-141032-000.txt
       16 one-v2016-07-04-141003-000.txt
       15 one-v2016-07-02-155621-000.txt

Retrieve an old version

$ rclone -q --s3-versions copy s3:cleanup-test/one-v2016-07-04-141003-000.txt /tmp

$ ls -l /tmp/one-v2016-07-04-141003-000.txt
-rw-rw-r-- 1 ncw ncw 16 Jul  2 17:46 /tmp/one-v2016-07-04-141003-000.txt

Clean up all the old versions and show that they've gone.

$ rclone -q backend cleanup-hidden s3:cleanup-test

$ rclone -q ls s3:cleanup-test
        9 one.txt

$ rclone -q --s3-versions ls s3:cleanup-test
        9 one.txt

Versions naming caveat

When using --s3-versions flag rclone is relying on the file name to work out whether the objects are versions or not. Versions' names are created by inserting timestamp between file name and its extension.

        9 file.txt
        8 file-v2023-07-17-161032-000.txt
       16 file-v2023-06-15-141003-000.txt

If there are real files present with the same names as versions, then behaviour of --s3-versions can be unpredictable.

Cleanup

If you run rclone cleanup s3:bucket then it will remove all pending multipart uploads older than 24 hours. You can use the --interactive/i or --dry-run flag to see exactly what it will do. If you want more control over the expiry date then run rclone backend cleanup s3:bucket -o max-age=1h to expire all uploads older than one hour. You can use rclone backend list-multipart-uploads s3:bucket to see the pending multipart uploads.

Restricted filename characters

S3 allows any valid UTF-8 string as a key.

Invalid UTF-8 bytes will be replaced, as they can't be used in XML.

The following characters are replaced since these are problematic when dealing with the REST API:

Character Value Replacement
NUL 0x00 ␀
/ 0x2F ／

The encoding will also encode these file names as they don't seem to work with the SDK properly:

File name Replacement
. ．
.. ．．

Multipart uploads

rclone supports multipart uploads with S3 which means that it can upload files bigger than 5 GiB.

Note that files uploaded both with multipart upload and through crypt remotes do not have MD5 sums.

rclone switches from single part uploads to multipart uploads at the point specified by --s3-upload-cutoff. This can be a maximum of 5 GiB and a minimum of 0 (ie always upload multipart files).

The chunk sizes used in the multipart upload are specified by --s3-chunk-size and the number of chunks uploaded concurrently is specified by --s3-upload-concurrency.

Multipart uploads will use --transfers * --s3-upload-concurrency * --s3-chunk-size extra memory. Single part uploads to not use extra memory.

Single part transfers can be faster than multipart transfers or slower depending on your latency from S3 - the more latency, the more likely single part transfers will be faster.

Increasing --s3-upload-concurrency will increase throughput (8 would be a sensible value) and increasing --s3-chunk-size also increases throughput (16M would be sensible). Increasing either of these will use more memory. The default values are high enough to gain most of the possible performance without using too much memory.

Buckets and Regions

With Amazon S3 you can list buckets (rclone lsd) using any region, but you can only access the content of a bucket from the region it was created in. If you attempt to access a bucket from the wrong region, you will get an error, incorrect region, the bucket is not in 'XXX' region.

Authentication

There are a number of ways to supply rclone with a set of AWS credentials, with and without using the environment.

The different authentication methods are tried in this order:

  • Directly in the rclone configuration file (env_auth = false in the config file):
    • access_key_id and secret_access_key are required.
    • session_token can be optionally set when using AWS STS.
  • Runtime configuration (env_auth = true in the config file):
    • Export the following environment variables before running rclone:
      • Access Key ID: AWS_ACCESS_KEY_ID or AWS_ACCESS_KEY
      • Secret Access Key: AWS_SECRET_ACCESS_KEY or AWS_SECRET_KEY
      • Session Token: AWS_SESSION_TOKEN (optional)
    • Or, use a named profile:
      • Profile files are standard files used by AWS CLI tools
      • By default it will use the profile in your home directory (e.g. ~/.aws/credentials on unix based systems) file and the "default" profile, to change set these environment variables or config keys:
        • AWS_SHARED_CREDENTIALS_FILE to control which file or the shared_credentials_file config key.
        • AWS_PROFILE to control which profile to use or the profile config key.
    • Or, run rclone in an ECS task with an IAM role (AWS only).
    • Or, run rclone on an EC2 instance with an IAM role (AWS only).
    • Or, run rclone in an EKS pod with an IAM role that is associated with a service account (AWS only).
    • Or, use process credentials to read config from an external program.

With env_auth = true rclone (which uses the SDK for Go v2) should support all authentication methods that the aws CLI tool does and the other AWS SDKs.

If none of these option actually end up providing rclone with AWS credentials then S3 interaction will be non-authenticated (see the anonymous access section for more info).

S3 Permissions

When using the sync subcommand of rclone the following minimum permissions are required to be available on the bucket being written to:

  • ListBucket
  • DeleteObject
  • GetObject
  • PutObject
  • PutObjectACL
  • CreateBucket (unless using s3-no-check-bucket)

When using the lsd subcommand, the ListAllMyBuckets permission is required.

Example policy:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "AWS": "arn:aws:iam::USER_SID:user/USER_NAME"
            },
            "Action": [
                "s3:ListBucket",
                "s3:DeleteObject",
                "s3:GetObject",
                "s3:PutObject",
                "s3:PutObjectAcl"
            ],
            "Resource": [
              "arn:aws:s3:::BUCKET_NAME/*",
              "arn:aws:s3:::BUCKET_NAME"
            ]
        },
        {
            "Effect": "Allow",
            "Action": "s3:ListAllMyBuckets",
            "Resource": "arn:aws:s3:::*"
        }
    ]
}

Notes on above:

  1. This is a policy that can be used when creating bucket. It assumes that USER_NAME has been created.
  2. The Resource entry must include both resource ARNs, as one implies the bucket and the other implies the bucket's objects.
  3. When using s3-no-check-bucket and the bucket already exists, the "arn:aws:s3:::BUCKET_NAME" doesn't have to be included.

For reference, here's an Ansible script that will generate one or more buckets that will work with rclone sync.

Key Management System (KMS)

If you are using server-side encryption with KMS then you must make sure rclone is configured with server_side_encryption = aws:kms otherwise you will find you can't transfer small objects - these will create checksum errors.

Glacier and Glacier Deep Archive

You can upload objects using the glacier storage class or transition them to glacier using a lifecycle policy. The bucket can still be synced or copied into normally, but if rclone tries to access data from the glacier storage class you will see an error like below.

2017/09/11 19:07:43 Failed to sync: failed to open source object: Object in GLACIER, restore first: path/to/file

In this case you need to restore the object(s) in question before accessing object contents. The restore section below shows how to do this with rclone.

Note that rclone only speaks the S3 API it does not speak the Glacier Vault API, so rclone cannot directly access Glacier Vaults.

Object-lock enabled S3 bucket

According to AWS's documentation on S3 Object Lock:

If you configure a default retention period on a bucket, requests to upload objects in such a bucket must include the Content-MD5 header.

As mentioned in the Modification times and hashes section, small files that are not uploaded as multipart, use a different tag, causing the upload to fail. A simple solution is to set the --s3-upload-cutoff 0 and force all the files to be uploaded as multipart.

Standard options

Here are the Standard options specific to s3 (Amazon S3 Compliant Storage Providers including AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, Exaba, FlashBlade, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, Magalu, Mega, Minio, Netease, Outscale, OVHcloud, Petabox, RackCorp, Rclone, Scaleway, SeaweedFS, Selectel, StackPath, Storj, Synology, TencentCOS, Wasabi, Qiniu, Zata and others).

--s3-provider

Choose your S3 provider.

Properties:

  • Config: provider
  • Env Var: RCLONE_S3_PROVIDER
  • Type: string
  • Required: false
  • Examples:
    • "AWS"
      • Amazon Web Services (AWS) S3
    • "Alibaba"
      • Alibaba Cloud Object Storage System (OSS) formerly Aliyun
    • "ArvanCloud"
      • Arvan Cloud Object Storage (AOS)
    • "Ceph"
      • Ceph Object Storage
    • "ChinaMobile"
      • China Mobile Ecloud Elastic Object Storage (EOS)
    • "Cloudflare"
      • Cloudflare R2 Storage
    • "DigitalOcean"
      • DigitalOcean Spaces
    • "Dreamhost"
      • Dreamhost DreamObjects
    • "Exaba"
      • Exaba Object Storage
    • "FlashBlade"
      • Pure Storage FlashBlade Object Storage
    • "GCS"
      • Google Cloud Storage
    • "HuaweiOBS"
      • Huawei Object Storage Service
    • "IBMCOS"
      • IBM COS S3
    • "IDrive"
      • IDrive e2
    • "IONOS"
      • IONOS Cloud
    • "LyveCloud"
      • Seagate Lyve Cloud
    • "Leviia"
      • Leviia Object Storage
    • "Liara"
      • Liara Object Storage
    • "Linode"
      • Linode Object Storage
    • "Magalu"
      • Magalu Object Storage
    • "Mega"
      • MEGA S4 Object Storage
    • "Minio"
      • Minio Object Storage
    • "Netease"
      • Netease Object Storage (NOS)
    • "Outscale"
      • OUTSCALE Object Storage (OOS)
    • "OVHcloud"
      • OVHcloud Object Storage
    • "Petabox"
      • Petabox Object Storage
    • "RackCorp"
      • RackCorp Object Storage
    • "Rclone"
      • Rclone S3 Server
    • "Scaleway"
      • Scaleway Object Storage
    • "SeaweedFS"
      • SeaweedFS S3
    • "Selectel"
      • Selectel Object Storage
    • "StackPath"
      • StackPath Object Storage
    • "Storj"
      • Storj (S3 Compatible Gateway)
    • "Synology"
      • Synology C2 Object Storage
    • "TencentCOS"
      • Tencent Cloud Object Storage (COS)
    • "Wasabi"
      • Wasabi Object Storage
    • "Qiniu"
      • Qiniu Object Storage (Kodo)
    • "Zata"
      • Zata (S3 compatible Gateway)
    • "Other"
      • Any other S3 compatible provider

--s3-env-auth

Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).

Only applies if access_key_id and secret_access_key is blank.

Properties:

  • Config: env_auth
  • Env Var: RCLONE_S3_ENV_AUTH
  • Type: bool
  • Default: false
  • Examples:
    • "false"
      • Enter AWS credentials in the next step.
    • "true"
      • Get AWS credentials from the environment (env vars or IAM).

--s3-access-key-id

AWS Access Key ID.

Leave blank for anonymous access or runtime credentials.

Properties:

  • Config: access_key_id
  • Env Var: RCLONE_S3_ACCESS_KEY_ID
  • Type: string
  • Required: false

--s3-secret-access-key

AWS Secret Access Key (password).

Leave blank for anonymous access or runtime credentials.

Properties:

  • Config: secret_access_key
  • Env Var: RCLONE_S3_SECRET_ACCESS_KEY
  • Type: string
  • Required: false

--s3-region

Region to connect to.

Properties:

  • Config: region
  • Env Var: RCLONE_S3_REGION
  • Provider: AWS
  • Type: string
  • Required: false
  • Examples:
    • "us-east-1"
      • The default endpoint - a good choice if you are unsure.
      • US Region, Northern Virginia, or Pacific Northwest.
      • Leave location constraint empty.
    • "us-east-2"
      • US East (Ohio) Region.
      • Needs location constraint us-east-2.
    • "us-west-1"
      • US West (Northern California) Region.
      • Needs location constraint us-west-1.
    • "us-west-2"
      • US West (Oregon) Region.
      • Needs location constraint us-west-2.
    • "ca-central-1"
      • Canada (Central) Region.
      • Needs location constraint ca-central-1.
    • "eu-west-1"
      • EU (Ireland) Region.
      • Needs location constraint EU or eu-west-1.
    • "eu-west-2"
      • EU (London) Region.
      • Needs location constraint eu-west-2.
    • "eu-west-3"
      • EU (Paris) Region.
      • Needs location constraint eu-west-3.
    • "eu-north-1"
      • EU (Stockholm) Region.
      • Needs location constraint eu-north-1.
    • "eu-south-1"
      • EU (Milan) Region.
      • Needs location constraint eu-south-1.
    • "eu-central-1"
      • EU (Frankfurt) Region.
      • Needs location constraint eu-central-1.
    • "ap-southeast-1"
      • Asia Pacific (Singapore) Region.
      • Needs location constraint ap-southeast-1.
    • "ap-southeast-2"
      • Asia Pacific (Sydney) Region.
      • Needs location constraint ap-southeast-2.
    • "ap-northeast-1"
      • Asia Pacific (Tokyo) Region.
      • Needs location constraint ap-northeast-1.
    • "ap-northeast-2"
      • Asia Pacific (Seoul).
      • Needs location constraint ap-northeast-2.
    • "ap-northeast-3"
      • Asia Pacific (Osaka-Local).
      • Needs location constraint ap-northeast-3.
    • "ap-south-1"
      • Asia Pacific (Mumbai).
      • Needs location constraint ap-south-1.
    • "ap-east-1"
      • Asia Pacific (Hong Kong) Region.
      • Needs location constraint ap-east-1.
    • "sa-east-1"
      • South America (Sao Paulo) Region.
      • Needs location constraint sa-east-1.
    • "il-central-1"
      • Israel (Tel Aviv) Region.
      • Needs location constraint il-central-1.
    • "me-south-1"
      • Middle East (Bahrain) Region.
      • Needs location constraint me-south-1.
    • "af-south-1"
      • Africa (Cape Town) Region.
      • Needs location constraint af-south-1.
    • "cn-north-1"
      • China (Beijing) Region.
      • Needs location constraint cn-north-1.
    • "cn-northwest-1"
      • China (Ningxia) Region.
      • Needs location constraint cn-northwest-1.
    • "us-gov-east-1"
      • AWS GovCloud (US-East) Region.
      • Needs location constraint us-gov-east-1.
    • "us-gov-west-1"
      • AWS GovCloud (US) Region.
      • Needs location constraint us-gov-west-1.

--s3-endpoint

Endpoint for S3 API.

Leave blank if using AWS to use the default endpoint for the region.

Properties:

  • Config: endpoint
  • Env Var: RCLONE_S3_ENDPOINT
  • Provider: AWS
  • Type: string
  • Required: false

--s3-location-constraint

Location constraint - must be set to match the Region.

Used when creating buckets only.

Properties:

  • Config: location_constraint
  • Env Var: RCLONE_S3_LOCATION_CONSTRAINT
  • Provider: AWS
  • Type: string
  • Required: false
  • Examples:
    • ""
      • Empty for US Region, Northern Virginia, or Pacific Northwest
    • "us-east-2"
      • US East (Ohio) Region
    • "us-west-1"
      • US West (Northern California) Region
    • "us-west-2"
      • US West (Oregon) Region
    • "ca-central-1"
      • Canada (Central) Region
    • "eu-west-1"
      • EU (Ireland) Region
    • "eu-west-2"
      • EU (London) Region
    • "eu-west-3"
      • EU (Paris) Region
    • "eu-north-1"
      • EU (Stockholm) Region
    • "eu-south-1"
      • EU (Milan) Region
    • "EU"
      • EU Region
    • "ap-southeast-1"
      • Asia Pacific (Singapore) Region
    • "ap-southeast-2"
      • Asia Pacific (Sydney) Region
    • "ap-northeast-1"
      • Asia Pacific (Tokyo) Region
    • "ap-northeast-2"
      • Asia Pacific (Seoul) Region
    • "ap-northeast-3"
      • Asia Pacific (Osaka-Local) Region
    • "ap-south-1"
      • Asia Pacific (Mumbai) Region
    • "ap-east-1"
      • Asia Pacific (Hong Kong) Region
    • "sa-east-1"
      • South America (Sao Paulo) Region
    • "il-central-1"
      • Israel (Tel Aviv) Region
    • "me-south-1"
      • Middle East (Bahrain) Region
    • "af-south-1"
      • Africa (Cape Town) Region
    • "cn-north-1"
      • China (Beijing) Region
    • "cn-northwest-1"
      • China (Ningxia) Region
    • "us-gov-east-1"
      • AWS GovCloud (US-East) Region
    • "us-gov-west-1"
      • AWS GovCloud (US) Region

--s3-acl

Canned ACL used when creating buckets and storing or copying objects.

This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too.

For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl

Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one.

If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used.

Properties:

  • Config: acl
  • Env Var: RCLONE_S3_ACL
  • Provider: !Storj,Selectel,Synology,Cloudflare,FlashBlade,Mega
  • Type: string
  • Required: false
  • Examples:
    • "default"
      • Owner gets Full_CONTROL.
      • No one else has access rights (default).
    • "private"
      • Owner gets FULL_CONTROL.
      • No one else has access rights (default).
    • "public-read"
      • Owner gets FULL_CONTROL.
      • The AllUsers group gets READ access.
    • "public-read-write"
      • Owner gets FULL_CONTROL.
      • The AllUsers group gets READ and WRITE access.
      • Granting this on a bucket is generally not recommended.
    • "authenticated-read"
      • Owner gets FULL_CONTROL.
      • The AuthenticatedUsers group gets READ access.
    • "bucket-owner-read"
      • Object owner gets FULL_CONTROL.
      • Bucket owner gets READ access.
      • If you specify this canned ACL when creating a bucket, Amazon S3 ignores it.
    • "bucket-owner-full-control"
      • Both the object owner and the bucket owner get FULL_CONTROL over the object.
      • If you specify this canned ACL when creating a bucket, Amazon S3 ignores it.
    • "private"
      • Owner gets FULL_CONTROL.
      • No one else has access rights (default).
      • This acl is available on IBM Cloud (Infra), IBM Cloud (Storage), On-Premise COS.
    • "public-read"
      • Owner gets FULL_CONTROL.
      • The AllUsers group gets READ access.
      • This acl is available on IBM Cloud (Infra), IBM Cloud (Storage), On-Premise IBM COS.
    • "public-read-write"
      • Owner gets FULL_CONTROL.
      • The AllUsers group gets READ and WRITE access.
      • This acl is available on IBM Cloud (Infra), On-Premise IBM COS.
    • "authenticated-read"
      • Owner gets FULL_CONTROL.
      • The AuthenticatedUsers group gets READ access.
      • Not supported on Buckets.
      • This acl is available on IBM Cloud (Infra) and On-Premise IBM COS.

--s3-server-side-encryption

The server-side encryption algorithm used when storing this object in S3.

Properties:

  • Config: server_side_encryption
  • Env Var: RCLONE_S3_SERVER_SIDE_ENCRYPTION
  • Provider: AWS,Ceph,ChinaMobile,Minio
  • Type: string
  • Required: false
  • Examples:
    • ""
      • None
    • "AES256"
      • AES256
    • "aws:kms"
      • aws:kms

--s3-sse-kms-key-id

If using KMS ID you must provide the ARN of Key.

Properties:

  • Config: sse_kms_key_id
  • Env Var: RCLONE_S3_SSE_KMS_KEY_ID
  • Provider: AWS,Ceph,Minio
  • Type: string
  • Required: false
  • Examples:
    • ""
      • None
    • "arn:aws:kms:us-east-1:*"
      • arn:aws:kms:*

--s3-storage-class

The storage class to use when storing new objects in S3.

Properties:

  • Config: storage_class
  • Env Var: RCLONE_S3_STORAGE_CLASS
  • Provider: AWS
  • Type: string
  • Required: false
  • Examples:
    • ""
      • Default
    • "STANDARD"
      • Standard storage class
    • "REDUCED_REDUNDANCY"
      • Reduced redundancy storage class
    • "STANDARD_IA"
      • Standard Infrequent Access storage class
    • "ONEZONE_IA"
      • One Zone Infrequent Access storage class
    • "GLACIER"
      • Glacier Flexible Retrieval storage class
    • "DEEP_ARCHIVE"
      • Glacier Deep Archive storage class
    • "INTELLIGENT_TIERING"
      • Intelligent-Tiering storage class
    • "GLACIER_IR"
      • Glacier Instant Retrieval storage class

--s3-ibm-api-key

IBM API Key to be used to obtain IAM token

Properties:

  • Config: ibm_api_key
  • Env Var: RCLONE_S3_IBM_API_KEY
  • Provider: IBMCOS
  • Type: string
  • Required: false

--s3-ibm-resource-instance-id

IBM service instance id

Properties:

  • Config: ibm_resource_instance_id
  • Env Var: RCLONE_S3_IBM_RESOURCE_INSTANCE_ID
  • Provider: IBMCOS
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to s3 (Amazon S3 Compliant Storage Providers including AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, Exaba, FlashBlade, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, Magalu, Mega, Minio, Netease, Outscale, OVHcloud, Petabox, RackCorp, Rclone, Scaleway, SeaweedFS, Selectel, StackPath, Storj, Synology, TencentCOS, Wasabi, Qiniu, Zata and others).

--s3-bucket-acl

Canned ACL used when creating buckets.

For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl

Note that this ACL is applied when only when creating buckets. If it isn't set then "acl" is used instead.

If the "acl" and "bucket_acl" are empty strings then no X-Amz-Acl: header is added and the default (private) will be used.

Properties:

  • Config: bucket_acl
  • Env Var: RCLONE_S3_BUCKET_ACL
  • Provider: !Storj,Selectel,Synology,Cloudflare,FlashBlade
  • Type: string
  • Required: false
  • Examples:
    • "private"
      • Owner gets FULL_CONTROL.
      • No one else has access rights (default).
    • "public-read"
      • Owner gets FULL_CONTROL.
      • The AllUsers group gets READ access.
    • "public-read-write"
      • Owner gets FULL_CONTROL.
      • The AllUsers group gets READ and WRITE access.
      • Granting this on a bucket is generally not recommended.
    • "authenticated-read"
      • Owner gets FULL_CONTROL.
      • The AuthenticatedUsers group gets READ access.

--s3-requester-pays

Enables requester pays option when interacting with S3 bucket.

Properties:

  • Config: requester_pays
  • Env Var: RCLONE_S3_REQUESTER_PAYS
  • Provider: AWS
  • Type: bool
  • Default: false

--s3-sse-customer-algorithm

If using SSE-C, the server-side encryption algorithm used when storing this object in S3.

Properties:

  • Config: sse_customer_algorithm
  • Env Var: RCLONE_S3_SSE_CUSTOMER_ALGORITHM
  • Provider: AWS,Ceph,ChinaMobile,Minio
  • Type: string
  • Required: false
  • Examples:
    • ""
      • None
    • "AES256"
      • AES256

--s3-sse-customer-key

To use SSE-C you may provide the secret encryption key used to encrypt/decrypt your data.

Alternatively you can provide --sse-customer-key-base64.

Properties:

  • Config: sse_customer_key
  • Env Var: RCLONE_S3_SSE_CUSTOMER_KEY
  • Provider: AWS,Ceph,ChinaMobile,Minio
  • Type: string
  • Required: false
  • Examples:
    • ""
      • None

--s3-sse-customer-key-base64

If using SSE-C you must provide the secret encryption key encoded in base64 format to encrypt/decrypt your data.

Alternatively you can provide --sse-customer-key.

Properties:

  • Config: sse_customer_key_base64
  • Env Var: RCLONE_S3_SSE_CUSTOMER_KEY_BASE64
  • Provider: AWS,Ceph,ChinaMobile,Minio
  • Type: string
  • Required: false
  • Examples:
    • ""
      • None

--s3-sse-customer-key-md5

If using SSE-C you may provide the secret encryption key MD5 checksum (optional).

If you leave it blank, this is calculated automatically from the sse_customer_key provided.

Properties:

  • Config: sse_customer_key_md5
  • Env Var: RCLONE_S3_SSE_CUSTOMER_KEY_MD5
  • Provider: AWS,Ceph,ChinaMobile,Minio
  • Type: string
  • Required: false
  • Examples:
    • ""
      • None

--s3-upload-cutoff

Cutoff for switching to chunked upload.

Any files larger than this will be uploaded in chunks of chunk_size. The minimum is 0 and the maximum is 5 GiB.

Properties:

  • Config: upload_cutoff
  • Env Var: RCLONE_S3_UPLOAD_CUTOFF
  • Type: SizeSuffix
  • Default: 200Mi

--s3-chunk-size

Chunk size to use for uploading.

When uploading files larger than upload_cutoff or files with unknown size (e.g. from "rclone rcat" or uploaded with "rclone mount" or google photos or google docs) they will be uploaded as multipart uploads using this chunk size.

Note that "--s3-upload-concurrency" chunks of this size are buffered in memory per transfer.

If you are transferring large files over high-speed links and you have enough memory, then increasing this will speed up the transfers.

Rclone will automatically increase the chunk size when uploading a large file of known size to stay below the 10,000 chunks limit.

Files of unknown size are uploaded with the configured chunk_size. Since the default chunk size is 5 MiB and there can be at most 10,000 chunks, this means that by default the maximum size of a file you can stream upload is 48 GiB. If you wish to stream upload larger files then you will need to increase chunk_size.

Increasing the chunk size decreases the accuracy of the progress statistics displayed with "-P" flag. Rclone treats chunk as sent when it's buffered by the AWS SDK, when in fact it may still be uploading. A bigger chunk size means a bigger AWS SDK buffer and progress reporting more deviating from the truth.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_S3_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 5Mi

--s3-max-upload-parts

Maximum number of parts in a multipart upload.

This option defines the maximum number of multipart chunks to use when doing a multipart upload.

This can be useful if a service does not support the AWS S3 specification of 10,000 chunks.

Rclone will automatically increase the chunk size when uploading a large file of a known size to stay below this number of chunks limit.

Properties:

  • Config: max_upload_parts
  • Env Var: RCLONE_S3_MAX_UPLOAD_PARTS
  • Type: int
  • Default: 10000

--s3-copy-cutoff

Cutoff for switching to multipart copy.

Any files larger than this that need to be server-side copied will be copied in chunks of this size.

The minimum is 0 and the maximum is 5 GiB.

Properties:

  • Config: copy_cutoff
  • Env Var: RCLONE_S3_COPY_CUTOFF
  • Type: SizeSuffix
  • Default: 4.656Gi

--s3-disable-checksum

Don't store MD5 checksum with object metadata.

Normally rclone will calculate the MD5 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading.

Properties:

  • Config: disable_checksum
  • Env Var: RCLONE_S3_DISABLE_CHECKSUM
  • Type: bool
  • Default: false

--s3-shared-credentials-file

Path to the shared credentials file.

If env_auth = true then rclone can use a shared credentials file.

If this variable is empty rclone will look for the "AWS_SHARED_CREDENTIALS_FILE" env variable. If the env value is empty it will default to the current user's home directory.

Linux/OSX: "$HOME/.aws/credentials"
Windows:   "%USERPROFILE%\.aws\credentials"

Properties:

  • Config: shared_credentials_file
  • Env Var: RCLONE_S3_SHARED_CREDENTIALS_FILE
  • Type: string
  • Required: false

--s3-profile

Profile to use in the shared credentials file.

If env_auth = true then rclone can use a shared credentials file. This variable controls which profile is used in that file.

If empty it will default to the environment variable "AWS_PROFILE" or "default" if that environment variable is also not set.

Properties:

  • Config: profile
  • Env Var: RCLONE_S3_PROFILE
  • Type: string
  • Required: false

--s3-session-token

An AWS session token.

Properties:

  • Config: session_token
  • Env Var: RCLONE_S3_SESSION_TOKEN
  • Type: string
  • Required: false

--s3-upload-concurrency

Concurrency for multipart uploads and copies.

This is the number of chunks of the same file that are uploaded concurrently for multipart uploads and copies.

If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers.

Properties:

  • Config: upload_concurrency
  • Env Var: RCLONE_S3_UPLOAD_CONCURRENCY
  • Type: int
  • Default: 4

--s3-force-path-style

If true use path style access if false use virtual hosted style.

If this is true (the default) then rclone will use path style access, if false then rclone will use virtual path style. See the AWS S3 docs for more info.

Some providers (e.g. AWS, Aliyun OSS, Netease COS, or Tencent COS) require this set to false - rclone will do this automatically based on the provider setting.

Note that if your bucket isn't a valid DNS name, i.e. has '.' or '_' in, you'll need to set this to true.

Properties:

  • Config: force_path_style
  • Env Var: RCLONE_S3_FORCE_PATH_STYLE
  • Type: bool
  • Default: true

--s3-v2-auth

If true use v2 authentication.

If this is false (the default) then rclone will use v4 authentication. If it is set then rclone will use v2 authentication.

Use this only if v4 signatures don't work, e.g. pre Jewel/v10 CEPH.

Properties:

  • Config: v2_auth
  • Env Var: RCLONE_S3_V2_AUTH
  • Type: bool
  • Default: false

--s3-use-dual-stack

If true use AWS S3 dual-stack endpoint (IPv6 support).

See AWS Docs on Dualstack Endpoints

Properties:

  • Config: use_dual_stack
  • Env Var: RCLONE_S3_USE_DUAL_STACK
  • Type: bool
  • Default: false

--s3-use-accelerate-endpoint

If true use the AWS S3 accelerated endpoint.

See: AWS S3 Transfer acceleration

Properties:

  • Config: use_accelerate_endpoint
  • Env Var: RCLONE_S3_USE_ACCELERATE_ENDPOINT
  • Provider: AWS
  • Type: bool
  • Default: false

--s3-use-arn-region

If true, enables arn region support for the service.

Properties:

  • Config: use_arn_region
  • Env Var: RCLONE_S3_USE_ARN_REGION
  • Type: bool
  • Default: false

--s3-leave-parts-on-error

If true avoid calling abort upload on a failure, leaving all successfully uploaded parts on S3 for manual recovery.

It should be set to true for resuming uploads across different sessions.

WARNING: Storing parts of an incomplete multipart upload counts towards space usage on S3 and will add additional costs if not cleaned up.

Properties:

  • Config: leave_parts_on_error
  • Env Var: RCLONE_S3_LEAVE_PARTS_ON_ERROR
  • Provider: AWS
  • Type: bool
  • Default: false

--s3-list-chunk

Size of listing chunk (response list for each ListObject S3 request).

This option is also known as "MaxKeys", "max-items", or "page-size" from the AWS S3 specification. Most services truncate the response list to 1000 objects even if requested more than that. In AWS S3 this is a global maximum and cannot be changed, see AWS S3. In Ceph, this can be increased with the "rgw list buckets max chunk" option.

Properties:

  • Config: list_chunk
  • Env Var: RCLONE_S3_LIST_CHUNK
  • Type: int
  • Default: 1000

--s3-list-version

Version of ListObjects to use: 1,2 or 0 for auto.

When S3 originally launched it only provided the ListObjects call to enumerate objects in a bucket.

However in May 2016 the ListObjectsV2 call was introduced. This is much higher performance and should be used if at all possible.

If set to the default, 0, rclone will guess according to the provider set which list objects method to call. If it guesses wrong, then it may be set manually here.

Properties:

  • Config: list_version
  • Env Var: RCLONE_S3_LIST_VERSION
  • Type: int
  • Default: 0

--s3-list-url-encode

Whether to url encode listings: true/false/unset

Some providers support URL encoding listings and where this is available this is more reliable when using control characters in file names. If this is set to unset (the default) then rclone will choose according to the provider setting what to apply, but you can override rclone's choice here.

Properties:

  • Config: list_url_encode
  • Env Var: RCLONE_S3_LIST_URL_ENCODE
  • Type: Tristate
  • Default: unset

--s3-no-check-bucket

If set, don't attempt to check the bucket exists or create it.

This can be useful when trying to minimise the number of transactions rclone does if you know the bucket exists already.

It can also be needed if the user you are using does not have bucket creation permissions. Before v1.52.0 this would have passed silently due to a bug.

Properties:

  • Config: no_check_bucket
  • Env Var: RCLONE_S3_NO_CHECK_BUCKET
  • Type: bool
  • Default: false

--s3-no-head

If set, don't HEAD uploaded objects to check integrity.

This can be useful when trying to minimise the number of transactions rclone does.

Setting it means that if rclone receives a 200 OK message after uploading an object with PUT then it will assume that it got uploaded properly.

In particular it will assume:

  • the metadata, including modtime, storage class and content type was as uploaded
  • the size was as uploaded

It reads the following items from the response for a single part PUT:

  • the MD5SUM
  • The uploaded date

For multipart uploads these items aren't read.

If an source object of unknown length is uploaded then rclone will do a HEAD request.

Setting this flag increases the chance for undetected upload failures, in particular an incorrect size, so it isn't recommended for normal operation. In practice the chance of an undetected upload failure is very small even with this flag.

Properties:

  • Config: no_head
  • Env Var: RCLONE_S3_NO_HEAD
  • Type: bool
  • Default: false

--s3-no-head-object

If set, do not do HEAD before GET when getting objects.

Properties:

  • Config: no_head_object
  • Env Var: RCLONE_S3_NO_HEAD_OBJECT
  • Type: bool
  • Default: false

--s3-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_S3_ENCODING
  • Type: Encoding
  • Default: Slash,InvalidUtf8,Dot

--s3-memory-pool-flush-time

How often internal memory buffer pools will be flushed. (no longer used)

Properties:

  • Config: memory_pool_flush_time
  • Env Var: RCLONE_S3_MEMORY_POOL_FLUSH_TIME
  • Type: Duration
  • Default: 1m0s

--s3-memory-pool-use-mmap

Whether to use mmap buffers in internal memory pool. (no longer used)

Properties:

  • Config: memory_pool_use_mmap
  • Env Var: RCLONE_S3_MEMORY_POOL_USE_MMAP
  • Type: bool
  • Default: false

--s3-disable-http2

Disable usage of http2 for S3 backends.

There is currently an unsolved issue with the s3 (specifically minio) backend and HTTP/2. HTTP/2 is enabled by default for the s3 backend but can be disabled here. When the issue is solved this flag will be removed.

See: https://github.com/rclone/rclone/issues/4673, https://github.com/rclone/rclone/issues/3631

Properties:

  • Config: disable_http2
  • Env Var: RCLONE_S3_DISABLE_HTTP2
  • Type: bool
  • Default: false

--s3-download-url

Custom endpoint for downloads. This is usually set to a CloudFront CDN URL as AWS S3 offers cheaper egress for data downloaded through the CloudFront network.

Properties:

  • Config: download_url
  • Env Var: RCLONE_S3_DOWNLOAD_URL
  • Type: string
  • Required: false

--s3-directory-markers

Upload an empty object with a trailing slash when a new directory is created

Empty folders are unsupported for bucket based remotes, this option creates an empty object ending with "/", to persist the folder.

Properties:

  • Config: directory_markers
  • Env Var: RCLONE_S3_DIRECTORY_MARKERS
  • Type: bool
  • Default: false

--s3-use-multipart-etag

Whether to use ETag in multipart uploads for verification

This should be true, false or left unset to use the default for the provider.

Properties:

  • Config: use_multipart_etag
  • Env Var: RCLONE_S3_USE_MULTIPART_ETAG
  • Type: Tristate
  • Default: unset

--s3-use-unsigned-payload

Whether to use an unsigned payload in PutObject

Rclone has to avoid the AWS SDK seeking the body when calling PutObject. The AWS provider can add checksums in the trailer to avoid seeking but other providers can't.

This should be true, false or left unset to use the default for the provider.

Properties:

  • Config: use_unsigned_payload
  • Env Var: RCLONE_S3_USE_UNSIGNED_PAYLOAD
  • Type: Tristate
  • Default: unset

--s3-use-presigned-request

Whether to use a presigned request or PutObject for single part uploads

If this is false rclone will use PutObject from the AWS SDK to upload an object.

Versions of rclone < 1.59 use presigned requests to upload a single part object and setting this flag to true will re-enable that functionality. This shouldn't be necessary except in exceptional circumstances or for testing.

Properties:

  • Config: use_presigned_request
  • Env Var: RCLONE_S3_USE_PRESIGNED_REQUEST
  • Type: bool
  • Default: false

--s3-versions

Include old versions in directory listings.

Properties:

  • Config: versions
  • Env Var: RCLONE_S3_VERSIONS
  • Type: bool
  • Default: false

--s3-version-at

Show file versions as they were at the specified time.

The parameter should be a date, "2006-01-02", datetime "2006-01-02 15:04:05" or a duration for that long ago, eg "100d" or "1h".

Note that when using this no file write operations are permitted, so you can't upload files or delete them.

See the time option docs for valid formats.

Properties:

  • Config: version_at
  • Env Var: RCLONE_S3_VERSION_AT
  • Type: Time
  • Default: off

--s3-version-deleted

Show deleted file markers when using versions.

This shows deleted file markers in the listing when using versions. These will appear as 0 size files. The only operation which can be performed on them is deletion.

Deleting a delete marker will reveal the previous version.

Deleted files will always show with a timestamp.

Properties:

  • Config: version_deleted
  • Env Var: RCLONE_S3_VERSION_DELETED
  • Type: bool
  • Default: false

--s3-decompress

If set this will decompress gzip encoded objects.

It is possible to upload objects to S3 with "Content-Encoding: gzip" set. Normally rclone will download these files as compressed objects.

If this flag is set then rclone will decompress these files with "Content-Encoding: gzip" as they are received. This means that rclone can't check the size and hash but the file contents will be decompressed.

Properties:

  • Config: decompress
  • Env Var: RCLONE_S3_DECOMPRESS
  • Type: bool
  • Default: false

--s3-might-gzip

Set this if the backend might gzip objects.

Normally providers will not alter objects when they are downloaded. If an object was not uploaded with Content-Encoding: gzip then it won't be set on download.

However some providers may gzip objects even if they weren't uploaded with Content-Encoding: gzip (eg Cloudflare).

A symptom of this would be receiving errors like

ERROR corrupted on transfer: sizes differ NNN vs MMM

If you set this flag and rclone downloads an object with Content-Encoding: gzip set and chunked transfer encoding, then rclone will decompress the object on the fly.

If this is set to unset (the default) then rclone will choose according to the provider setting what to apply, but you can override rclone's choice here.

Properties:

  • Config: might_gzip
  • Env Var: RCLONE_S3_MIGHT_GZIP
  • Type: Tristate
  • Default: unset

--s3-use-accept-encoding-gzip

Whether to send Accept-Encoding: gzip header.

By default, rclone will append Accept-Encoding: gzip to the request to download compressed objects whenever possible.

However some providers such as Google Cloud Storage may alter the HTTP headers, breaking the signature of the request.

A symptom of this would be receiving errors like

SignatureDoesNotMatch: The request signature we calculated does not match the signature you provided.

In this case, you might want to try disabling this option.

Properties:

  • Config: use_accept_encoding_gzip
  • Env Var: RCLONE_S3_USE_ACCEPT_ENCODING_GZIP
  • Type: Tristate
  • Default: unset

--s3-no-system-metadata

Suppress setting and reading of system metadata

Properties:

  • Config: no_system_metadata
  • Env Var: RCLONE_S3_NO_SYSTEM_METADATA
  • Type: bool
  • Default: false

--s3-sts-endpoint

Endpoint for STS (deprecated).

Leave blank if using AWS to use the default endpoint for the region.

Properties:

  • Config: sts_endpoint
  • Env Var: RCLONE_S3_STS_ENDPOINT
  • Provider: AWS
  • Type: string
  • Required: false

--s3-use-already-exists

Set if rclone should report BucketAlreadyExists errors on bucket creation.

At some point during the evolution of the s3 protocol, AWS started returning an AlreadyOwnedByYou error when attempting to create a bucket that the user already owned, rather than a BucketAlreadyExists error.

Unfortunately exactly what has been implemented by s3 clones is a little inconsistent, some return AlreadyOwnedByYou, some return BucketAlreadyExists and some return no error at all.

This is important to rclone because it ensures the bucket exists by creating it on quite a lot of operations (unless --s3-no-check-bucket is used).

If rclone knows the provider can return AlreadyOwnedByYou or returns no error then it can report BucketAlreadyExists errors when the user attempts to create a bucket not owned by them. Otherwise rclone ignores the BucketAlreadyExists error which can lead to confusion.

This should be automatically set correctly for all providers rclone knows about - please make a bug report if not.

Properties:

  • Config: use_already_exists
  • Env Var: RCLONE_S3_USE_ALREADY_EXISTS
  • Type: Tristate
  • Default: unset

--s3-use-multipart-uploads

Set if rclone should use multipart uploads.

You can change this if you want to disable the use of multipart uploads. This shouldn't be necessary in normal operation.

This should be automatically set correctly for all providers rclone knows about - please make a bug report if not.

Properties:

  • Config: use_multipart_uploads
  • Env Var: RCLONE_S3_USE_MULTIPART_UPLOADS
  • Type: Tristate
  • Default: unset

--s3-use-x-id

Set if rclone should add x-id URL parameters.

You can change this if you want to disable the AWS SDK from adding x-id URL parameters.

This shouldn't be necessary in normal operation.

This should be automatically set correctly for all providers rclone knows about - please make a bug report if not.

Properties:

  • Config: use_x_id
  • Env Var: RCLONE_S3_USE_X_ID
  • Type: Tristate
  • Default: unset

--s3-sign-accept-encoding

Set if rclone should include Accept-Encoding as part of the signature.

You can change this if you want to stop rclone including Accept-Encoding as part of the signature.

This shouldn't be necessary in normal operation.

This should be automatically set correctly for all providers rclone knows about - please make a bug report if not.

Properties:

  • Config: sign_accept_encoding
  • Env Var: RCLONE_S3_SIGN_ACCEPT_ENCODING
  • Type: Tristate
  • Default: unset

--s3-directory-bucket

Set to use AWS Directory Buckets

If you are using an AWS Directory Bucket then set this flag.

This will ensure no Content-Md5 headers are sent and ensure ETag headers are not interpreted as MD5 sums. X-Amz-Meta-Md5chksum will be set on all objects whether single or multipart uploaded.

This also sets no_check_bucket = true.

Note that Directory Buckets do not support:

  • Versioning
  • Content-Encoding: gzip

Rclone limitations with Directory Buckets:

  • rclone does not support creating Directory Buckets with rclone mkdir
  • ... or removing them with rclone rmdir yet
  • Directory Buckets do not appear when doing rclone lsf at the top level.
  • Rclone can't remove auto created directories yet. In theory this should work with directory_markers = true but it doesn't.
  • Directories don't seem to appear in recursive (ListR) listings.

Properties:

  • Config: directory_bucket
  • Env Var: RCLONE_S3_DIRECTORY_BUCKET
  • Provider: AWS
  • Type: bool
  • Default: false

--s3-sdk-log-mode

Set to debug the SDK

This can be set to a comma separated list of the following functions:

  • Signing
  • Retries
  • Request
  • RequestWithBody
  • Response
  • ResponseWithBody
  • DeprecatedUsage
  • RequestEventMessage
  • ResponseEventMessage

Use Off to disable and All to set all log levels. You will need to use -vv to see the debug level logs.

Properties:

  • Config: sdk_log_mode
  • Env Var: RCLONE_S3_SDK_LOG_MODE
  • Type: Bits
  • Default: Off

--s3-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_S3_DESCRIPTION
  • Type: string
  • Required: false

Metadata

User metadata is stored as x-amz-meta- keys. S3 metadata keys are case insensitive and are always returned in lower case.

Here are the possible system metadata items for the s3 backend.

Name Help Type Example Read Only
btime Time of file birth (creation) read from Last-Modified header RFC 3339 2006-01-02T15:04:05.999999999Z07:00 Y
cache-control Cache-Control header string no-cache N
content-disposition Content-Disposition header string inline N
content-encoding Content-Encoding header string gzip N
content-language Content-Language header string en-US N
content-type Content-Type header string text/plain N
mtime Time of last modification, read from rclone metadata RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N
tier Tier of the object string GLACIER Y

See the metadata docs for more info.

Backend commands

Here are the commands specific to the s3 backend.

Run them with

rclone backend COMMAND remote:

The help below will explain what arguments each command takes.

See the backend command for more info on how to pass options and arguments.

These can be run on a running backend using the rc command backend/command.

restore

Restore objects from GLACIER or INTELLIGENT-TIERING archive tier

rclone backend restore remote: [options] [<arguments>+]

This command can be used to restore one or more objects from GLACIER to normal storage or from INTELLIGENT-TIERING Archive Access / Deep Archive Access tier to the Frequent Access tier.

Usage Examples:

rclone backend restore s3:bucket/path/to/ --include /object -o priority=PRIORITY -o lifetime=DAYS
rclone backend restore s3:bucket/path/to/directory -o priority=PRIORITY -o lifetime=DAYS
rclone backend restore s3:bucket -o priority=PRIORITY -o lifetime=DAYS
rclone backend restore s3:bucket/path/to/directory -o priority=PRIORITY

This flag also obeys the filters. Test first with --interactive/-i or --dry-run flags

rclone --interactive backend restore --include "*.txt" s3:bucket/path -o priority=Standard -o lifetime=1

All the objects shown will be marked for restore, then

rclone backend restore --include "*.txt" s3:bucket/path -o priority=Standard -o lifetime=1

It returns a list of status dictionaries with Remote and Status keys. The Status will be OK if it was successful or an error message if not.

[
    {
        "Status": "OK",
        "Remote": "test.txt"
    },
    {
        "Status": "OK",
        "Remote": "test/file4.txt"
    }
]

Options:

  • "description": The optional description for the job.
  • "lifetime": Lifetime of the active copy in days, ignored for INTELLIGENT-TIERING storage
  • "priority": Priority of restore: Standard|Expedited|Bulk

restore-status

Show the restore status for objects being restored from GLACIER or INTELLIGENT-TIERING storage

rclone backend restore-status remote: [options] [<arguments>+]

This command can be used to show the status for objects being restored from GLACIER to normal storage or from INTELLIGENT-TIERING Archive Access / Deep Archive Access tier to the Frequent Access tier.

Usage Examples:

rclone backend restore-status s3:bucket/path/to/object
rclone backend restore-status s3:bucket/path/to/directory
rclone backend restore-status -o all s3:bucket/path/to/directory

This command does not obey the filters.

It returns a list of status dictionaries.

[
    {
        "Remote": "file.txt",
        "VersionID": null,
        "RestoreStatus": {
            "IsRestoreInProgress": true,
            "RestoreExpiryDate": "2023-09-06T12:29:19+01:00"
        },
        "StorageClass": "GLACIER"
    },
    {
        "Remote": "test.pdf",
        "VersionID": null,
        "RestoreStatus": {
            "IsRestoreInProgress": false,
            "RestoreExpiryDate": "2023-09-06T12:29:19+01:00"
        },
        "StorageClass": "DEEP_ARCHIVE"
    },
    {
        "Remote": "test.gz",
        "VersionID": null,
        "RestoreStatus": {
            "IsRestoreInProgress": true,
            "RestoreExpiryDate": "null"
        },
        "StorageClass": "INTELLIGENT_TIERING"
    }
]

Options:

  • "all": if set then show all objects, not just ones with restore status

list-multipart-uploads

List the unfinished multipart uploads

rclone backend list-multipart-uploads remote: [options] [<arguments>+]

This command lists the unfinished multipart uploads in JSON format.

rclone backend list-multipart s3:bucket/path/to/object

It returns a dictionary of buckets with values as lists of unfinished multipart uploads.

You can call it with no bucket in which case it lists all bucket, with a bucket or with a bucket and path.

{
  "rclone": [
    {
      "Initiated": "2020-06-26T14:20:36Z",
      "Initiator": {
        "DisplayName": "XXX",
        "ID": "arn:aws:iam::XXX:user/XXX"
      },
      "Key": "KEY",
      "Owner": {
        "DisplayName": null,
        "ID": "XXX"
      },
      "StorageClass": "STANDARD",
      "UploadId": "XXX"
    }
  ],
  "rclone-1000files": [],
  "rclone-dst": []
}

cleanup

Remove unfinished multipart uploads.

rclone backend cleanup remote: [options] [<arguments>+]

This command removes unfinished multipart uploads of age greater than max-age which defaults to 24 hours.

Note that you can use --interactive/-i or --dry-run with this command to see what it would do.

rclone backend cleanup s3:bucket/path/to/object
rclone backend cleanup -o max-age=7w s3:bucket/path/to/object

Durations are parsed as per the rest of rclone, 2h, 7d, 7w etc.

Options:

  • "max-age": Max age of upload to delete

cleanup-hidden

Remove old versions of files.

rclone backend cleanup-hidden remote: [options] [<arguments>+]

This command removes any old hidden versions of files on a versions enabled bucket.

Note that you can use --interactive/-i or --dry-run with this command to see what it would do.

rclone backend cleanup-hidden s3:bucket/path/to/dir

versioning

Set/get versioning support for a bucket.

rclone backend versioning remote: [options] [<arguments>+]

This command sets versioning support if a parameter is passed and then returns the current versioning status for the bucket supplied.

rclone backend versioning s3:bucket # read status only
rclone backend versioning s3:bucket Enabled
rclone backend versioning s3:bucket Suspended

It may return "Enabled", "Suspended" or "Unversioned". Note that once versioning has been enabled the status can't be set back to "Unversioned".

set

Set command for updating the config parameters.

rclone backend set remote: [options] [<arguments>+]

This set command can be used to update the config parameters for a running s3 backend.

Usage Examples:

rclone backend set s3: [-o opt_name=opt_value] [-o opt_name2=opt_value2]
rclone rc backend/command command=set fs=s3: [-o opt_name=opt_value] [-o opt_name2=opt_value2]
rclone rc backend/command command=set fs=s3: -o session_token=X -o access_key_id=X -o secret_access_key=X

The option keys are named as they are in the config file.

This rebuilds the connection to the s3 backend when it is called with the new parameters. Only new parameters need be passed as the values will default to those currently in use.

It doesn't return anything.

Anonymous access to public buckets

If you want to use rclone to access a public bucket, configure with a blank access_key_id and secret_access_key. Your config should end up looking like this:

[anons3]
type = s3
provider = AWS

Then use it as normal with the name of the public bucket, e.g.

rclone lsd anons3:1000genomes

You will be able to list and copy data but not upload it.

You can also do this entirely on the command line

rclone lsd :s3,provider=AWS:1000genomes

Providers

AWS S3

This is the provider used as main example and described in the configuration section above.

AWS Directory Buckets

From rclone v1.69 Directory Buckets are supported.

You will need to set the directory_buckets = true config parameter or use --s3-directory-buckets.

Note that rclone cannot yet:

  • Create directory buckets
  • List directory buckets

See the --s3-directory-buckets flag for more info

AWS Snowball Edge

AWS Snowball is a hardware appliance used for transferring bulk data back to AWS. Its main software interface is S3 object storage.

To use rclone with AWS Snowball Edge devices, configure as standard for an 'S3 Compatible Service'.

If using rclone pre v1.59 be sure to set upload_cutoff = 0 otherwise you will run into authentication header issues as the snowball device does not support query parameter based authentication.

With rclone v1.59 or later setting upload_cutoff should not be necessary.

eg.

[snowball]
type = s3
provider = Other
access_key_id = YOUR_ACCESS_KEY
secret_access_key = YOUR_SECRET_KEY
endpoint = http://[IP of Snowball]:8080
upload_cutoff = 0

Alibaba OSS

Here is an example of making an Alibaba Cloud (Aliyun) OSS configuration. First run:

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> oss
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ "s3"
[snip]
Storage> s3
Choose your S3 provider.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / Amazon Web Services (AWS) S3
   \ "AWS"
 2 / Alibaba Cloud Object Storage System (OSS) formerly Aliyun
   \ "Alibaba"
 3 / Ceph Object Storage
   \ "Ceph"
[snip]
provider> Alibaba
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Enter a boolean value (true or false). Press Enter for the default ("false").
Choose a number from below, or type in your own value
 1 / Enter AWS credentials in the next step
   \ "false"
 2 / Get AWS credentials from the environment (env vars or IAM)
   \ "true"
env_auth> 1
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a string value. Press Enter for the default ("").
access_key_id> accesskeyid
AWS Secret Access Key (password)
Leave blank for anonymous access or runtime credentials.
Enter a string value. Press Enter for the default ("").
secret_access_key> secretaccesskey
Endpoint for OSS API.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / East China 1 (Hangzhou)
   \ "oss-cn-hangzhou.aliyuncs.com"
 2 / East China 2 (Shanghai)
   \ "oss-cn-shanghai.aliyuncs.com"
 3 / North China 1 (Qingdao)
   \ "oss-cn-qingdao.aliyuncs.com"
[snip]
endpoint> 1
Canned ACL used when creating buckets and storing or copying objects.

Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / Owner gets FULL_CONTROL. No one else has access rights (default).
   \ "private"
 2 / Owner gets FULL_CONTROL. The AllUsers group gets READ access.
   \ "public-read"
   / Owner gets FULL_CONTROL. The AllUsers group gets READ and WRITE access.
[snip]
acl> 1
The storage class to use when storing new objects in OSS.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / Default
   \ ""
 2 / Standard storage class
   \ "STANDARD"
 3 / Archive storage mode.
   \ "GLACIER"
 4 / Infrequent access storage mode.
   \ "STANDARD_IA"
storage_class> 1
Edit advanced config? (y/n)
y) Yes
n) No
y/n> n
Remote config
--------------------
[oss]
type = s3
provider = Alibaba
env_auth = false
access_key_id = accesskeyid
secret_access_key = secretaccesskey
endpoint = oss-cn-hangzhou.aliyuncs.com
acl = private
storage_class = Standard
--------------------
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

ArvanCloud

ArvanCloud ArvanCloud Object Storage goes beyond the limited traditional file storage. It gives you access to backup and archived files and allows sharing. Files like profile image in the app, images sent by users or scanned documents can be stored securely and easily in our Object Storage service.

ArvanCloud provides an S3 interface which can be configured for use with rclone like this.

No remotes found, make a new one?
n) New remote
s) Set configuration password
n/s> n
name> ArvanCloud
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Amazon S3 (also Dreamhost, Ceph, ChinaMobile, ArvanCloud, Liara, Minio)
   \ "s3"
[snip]
Storage> s3
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own value
 1 / Enter AWS credentials in the next step
   \ "false"
 2 / Get AWS credentials from the environment (env vars or IAM)
   \ "true"
env_auth> 1
AWS Access Key ID - leave blank for anonymous access or runtime credentials.
access_key_id> YOURACCESSKEY
AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials.
secret_access_key> YOURSECRETACCESSKEY
Region to connect to.
Choose a number from below, or type in your own value
   / The default endpoint - a good choice if you are unsure.
 1 | US Region, Northern Virginia, or Pacific Northwest.
   | Leave location constraint empty.
   \ "us-east-1"
[snip]
region> 
Endpoint for S3 API.
Leave blank if using ArvanCloud to use the default endpoint for the region.
Specify if using an S3 clone such as Ceph.
endpoint> s3.arvanstorage.com
Location constraint - must be set to match the Region. Used when creating buckets only.
Choose a number from below, or type in your own value
 1 / Empty for Iran-Tehran Region.
   \ ""
[snip]
location_constraint>
Canned ACL used when creating buckets and/or storing objects in S3.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Choose a number from below, or type in your own value
 1 / Owner gets FULL_CONTROL. No one else has access rights (default).
   \ "private"
[snip]
acl>
The server-side encryption algorithm used when storing this object in S3.
Choose a number from below, or type in your own value
 1 / None
   \ ""
 2 / AES256
   \ "AES256"
server_side_encryption>
The storage class to use when storing objects in S3.
Choose a number from below, or type in your own value
 1 / Default
   \ ""
 2 / Standard storage class
   \ "STANDARD"
storage_class>
Remote config
--------------------
[ArvanCloud]
env_auth = false
access_key_id = YOURACCESSKEY
secret_access_key = YOURSECRETACCESSKEY
region = ir-thr-at1
endpoint = s3.arvanstorage.com
location_constraint =
acl =
server_side_encryption =
storage_class =
--------------------
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

This will leave the config file looking like this.

[ArvanCloud]
type = s3
provider = ArvanCloud
env_auth = false
access_key_id = YOURACCESSKEY
secret_access_key = YOURSECRETACCESSKEY
region =
endpoint = s3.arvanstorage.com
location_constraint =
acl =
server_side_encryption =
storage_class =

Ceph

Ceph is an open-source, unified, distributed storage system designed for excellent performance, reliability and scalability. It has an S3 compatible object storage interface.

To use rclone with Ceph, configure as above but leave the region blank and set the endpoint. You should end up with something like this in your config:

[ceph]
type = s3
provider = Ceph
env_auth = false
access_key_id = XXX
secret_access_key = YYY
region =
endpoint = https://ceph.endpoint.example.com
location_constraint =
acl =
server_side_encryption =
storage_class =

If you are using an older version of CEPH (e.g. 10.2.x Jewel) and a version of rclone before v1.59 then you may need to supply the parameter --s3-upload-cutoff 0 or put this in the config file as upload_cutoff 0 to work around a bug which causes uploading of small files to fail.

Note also that Ceph sometimes puts / in the passwords it gives users. If you read the secret access key using the command line tools you will get a JSON blob with the / escaped as \/. Make sure you only write / in the secret access key.

Eg the dump from Ceph looks something like this (irrelevant keys removed).

{
    "user_id": "xxx",
    "display_name": "xxxx",
    "keys": [
        {
            "user": "xxx",
            "access_key": "xxxxxx",
            "secret_key": "xxxxxx\/xxxx"
        }
    ],
}

Because this is a json dump, it is encoding the / as \/, so if you use the secret key as xxxxxx/xxxx it will work fine.

China Mobile Ecloud Elastic Object Storage (EOS)

Here is an example of making an China Mobile Ecloud Elastic Object Storage (EOS) configuration. First run:

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> ChinaMobile
Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
 ...
XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ (s3)
 ...
Storage> s3
Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 ...
 4 / China Mobile Ecloud Elastic Object Storage (EOS)
   \ (ChinaMobile)
 ...
provider> ChinaMobile
Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth>
Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> accesskeyid
Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> secretaccesskey
Option endpoint.
Endpoint for China Mobile Ecloud Elastic Object Storage (EOS) API.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
   / The default endpoint - a good choice if you are unsure.
 1 | East China (Suzhou)
   \ (eos-wuxi-1.cmecloud.cn)
 2 / East China (Jinan)
   \ (eos-jinan-1.cmecloud.cn)
 3 / East China (Hangzhou)
   \ (eos-ningbo-1.cmecloud.cn)
 4 / East China (Shanghai-1)
   \ (eos-shanghai-1.cmecloud.cn)
 5 / Central China (Zhengzhou)
   \ (eos-zhengzhou-1.cmecloud.cn)
 6 / Central China (Changsha-1)
   \ (eos-hunan-1.cmecloud.cn)
 7 / Central China (Changsha-2)
   \ (eos-zhuzhou-1.cmecloud.cn)
 8 / South China (Guangzhou-2)
   \ (eos-guangzhou-1.cmecloud.cn)
 9 / South China (Guangzhou-3)
   \ (eos-dongguan-1.cmecloud.cn)
10 / North China (Beijing-1)
   \ (eos-beijing-1.cmecloud.cn)
11 / North China (Beijing-2)
   \ (eos-beijing-2.cmecloud.cn)
12 / North China (Beijing-3)
   \ (eos-beijing-4.cmecloud.cn)
13 / North China (Huhehaote)
   \ (eos-huhehaote-1.cmecloud.cn)
14 / Southwest China (Chengdu)
   \ (eos-chengdu-1.cmecloud.cn)
15 / Southwest China (Chongqing)
   \ (eos-chongqing-1.cmecloud.cn)
16 / Southwest China (Guiyang)
   \ (eos-guiyang-1.cmecloud.cn)
17 / Nouthwest China (Xian)
   \ (eos-xian-1.cmecloud.cn)
18 / Yunnan China (Kunming)
   \ (eos-yunnan.cmecloud.cn)
19 / Yunnan China (Kunming-2)
   \ (eos-yunnan-2.cmecloud.cn)
20 / Tianjin China (Tianjin)
   \ (eos-tianjin-1.cmecloud.cn)
21 / Jilin China (Changchun)
   \ (eos-jilin-1.cmecloud.cn)
22 / Hubei China (Xiangyan)
   \ (eos-hubei-1.cmecloud.cn)
23 / Jiangxi China (Nanchang)
   \ (eos-jiangxi-1.cmecloud.cn)
24 / Gansu China (Lanzhou)
   \ (eos-gansu-1.cmecloud.cn)
25 / Shanxi China (Taiyuan)
   \ (eos-shanxi-1.cmecloud.cn)
26 / Liaoning China (Shenyang)
   \ (eos-liaoning-1.cmecloud.cn)
27 / Hebei China (Shijiazhuang)
   \ (eos-hebei-1.cmecloud.cn)
28 / Fujian China (Xiamen)
   \ (eos-fujian-1.cmecloud.cn)
29 / Guangxi China (Nanning)
   \ (eos-guangxi-1.cmecloud.cn)
30 / Anhui China (Huainan)
   \ (eos-anhui-1.cmecloud.cn)
endpoint> 1
Option location_constraint.
Location constraint - must match endpoint.
Used when creating buckets only.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / East China (Suzhou)
   \ (wuxi1)
 2 / East China (Jinan)
   \ (jinan1)
 3 / East China (Hangzhou)
   \ (ningbo1)
 4 / East China (Shanghai-1)
   \ (shanghai1)
 5 / Central China (Zhengzhou)
   \ (zhengzhou1)
 6 / Central China (Changsha-1)
   \ (hunan1)
 7 / Central China (Changsha-2)
   \ (zhuzhou1)
 8 / South China (Guangzhou-2)
   \ (guangzhou1)
 9 / South China (Guangzhou-3)
   \ (dongguan1)
10 / North China (Beijing-1)
   \ (beijing1)
11 / North China (Beijing-2)
   \ (beijing2)
12 / North China (Beijing-3)
   \ (beijing4)
13 / North China (Huhehaote)
   \ (huhehaote1)
14 / Southwest China (Chengdu)
   \ (chengdu1)
15 / Southwest China (Chongqing)
   \ (chongqing1)
16 / Southwest China (Guiyang)
   \ (guiyang1)
17 / Nouthwest China (Xian)
   \ (xian1)
18 / Yunnan China (Kunming)
   \ (yunnan)
19 / Yunnan China (Kunming-2)
   \ (yunnan2)
20 / Tianjin China (Tianjin)
   \ (tianjin1)
21 / Jilin China (Changchun)
   \ (jilin1)
22 / Hubei China (Xiangyan)
   \ (hubei1)
23 / Jiangxi China (Nanchang)
   \ (jiangxi1)
24 / Gansu China (Lanzhou)
   \ (gansu1)
25 / Shanxi China (Taiyuan)
   \ (shanxi1)
26 / Liaoning China (Shenyang)
   \ (liaoning1)
27 / Hebei China (Shijiazhuang)
   \ (hebei1)
28 / Fujian China (Xiamen)
   \ (fujian1)
29 / Guangxi China (Nanning)
   \ (guangxi1)
30 / Anhui China (Huainan)
   \ (anhui1)
location_constraint> 1
Option acl.
Canned ACL used when creating buckets and storing or copying objects.
This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
   / Owner gets FULL_CONTROL.
 1 | No one else has access rights (default).
   \ (private)
   / Owner gets FULL_CONTROL.
 2 | The AllUsers group gets READ access.
   \ (public-read)
   / Owner gets FULL_CONTROL.
 3 | The AllUsers group gets READ and WRITE access.
   | Granting this on a bucket is generally not recommended.
   \ (public-read-write)
   / Owner gets FULL_CONTROL.
 4 | The AuthenticatedUsers group gets READ access.
   \ (authenticated-read)
   / Object owner gets FULL_CONTROL.
acl> private
Option server_side_encryption.
The server-side encryption algorithm used when storing this object in S3.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / None
   \ ()
 2 / AES256
   \ (AES256)
server_side_encryption>
Option storage_class.
The storage class to use when storing new objects in ChinaMobile.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Default
   \ ()
 2 / Standard storage class
   \ (STANDARD)
 3 / Archive storage mode
   \ (GLACIER)
 4 / Infrequent access storage mode
   \ (STANDARD_IA)
storage_class>
Edit advanced config?
y) Yes
n) No (default)
y/n> n
--------------------
[ChinaMobile]
type = s3
provider = ChinaMobile
access_key_id = accesskeyid
secret_access_key = secretaccesskey
endpoint = eos-wuxi-1.cmecloud.cn
location_constraint = wuxi1
acl = private
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Cloudflare R2

Cloudflare R2 Storage allows developers to store large amounts of unstructured data without the costly egress bandwidth fees associated with typical cloud storage services.

Here is an example of making a Cloudflare R2 configuration. First run:

rclone config

This will guide you through an interactive setup process.

Note that all buckets are private, and all are stored in the same "auto" region. It is necessary to use Cloudflare workers to share the content of a bucket publicly.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> r2
Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
...
XX / Amazon S3 Compliant Storage Providers including AWS, Alibaba, Ceph, China Mobile, Cloudflare, ArvanCloud, DigitalOcean, Dreamhost, Huawei OBS, IBM COS, Lyve Cloud, Minio, Magalu, Netease, RackCorp, Scaleway, SeaweedFS, StackPath, Storj, Synology, Tencent COS and Wasabi
   \ (s3)
...
Storage> s3
Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
...
XX / Cloudflare R2 Storage
   \ (Cloudflare)
...
provider> Cloudflare
Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth> 1
Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> ACCESS_KEY
Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> SECRET_ACCESS_KEY
Option region.
Region to connect to.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / R2 buckets are automatically distributed across Cloudflare's data centers for low latency.
   \ (auto)
region> 1
Option endpoint.
Endpoint for S3 API.
Required when using an S3 clone.
Enter a value. Press Enter to leave empty.
endpoint> https://ACCOUNT_ID.r2.cloudflarestorage.com
Edit advanced config?
y) Yes
n) No (default)
y/n> n
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

This will leave your config looking something like:

[r2]
type = s3
provider = Cloudflare
access_key_id = ACCESS_KEY
secret_access_key = SECRET_ACCESS_KEY
region = auto
endpoint = https://ACCOUNT_ID.r2.cloudflarestorage.com
acl = private

Now run rclone lsf r2: to see your buckets and rclone lsf r2:bucket to look within a bucket.

For R2 tokens with the "Object Read & Write" permission, you may also need to add no_check_bucket = true for object uploads to work correctly.

Note that Cloudflare decompresses files uploaded with Content-Encoding: gzip by default which is a deviation from what AWS does. If this is causing a problem then upload the files with --header-upload "Cache-Control: no-transform"

A consequence of this is that Content-Encoding: gzip will never appear in the metadata on Cloudflare.

DigitalOcean Spaces

Spaces is an S3-interoperable object storage service from cloud provider DigitalOcean.

To connect to DigitalOcean Spaces you will need an access key and secret key. These can be retrieved on the "Applications & API" page of the DigitalOcean control panel. They will be needed when prompted by rclone config for your access_key_id and secret_access_key.

When prompted for a region or location_constraint, press enter to use the default value. The region must be included in the endpoint setting (e.g. nyc3.digitaloceanspaces.com). The default values can be used for other settings.

Going through the whole process of creating a new remote by running rclone config, each prompt should be answered as shown below:

Storage> s3
env_auth> 1
access_key_id> YOUR_ACCESS_KEY
secret_access_key> YOUR_SECRET_KEY
region>
endpoint> nyc3.digitaloceanspaces.com
location_constraint>
acl>
storage_class>

The resulting configuration file should look like:

[spaces]
type = s3
provider = DigitalOcean
env_auth = false
access_key_id = YOUR_ACCESS_KEY
secret_access_key = YOUR_SECRET_KEY
region =
endpoint = nyc3.digitaloceanspaces.com
location_constraint =
acl =
server_side_encryption =
storage_class =

Once configured, you can create a new Space and begin copying files. For example:

rclone mkdir spaces:my-new-space
rclone copy /path/to/files spaces:my-new-space

Dreamhost

Dreamhost DreamObjects is an object storage system based on CEPH.

To use rclone with Dreamhost, configure as above but leave the region blank and set the endpoint. You should end up with something like this in your config:

[dreamobjects]
type = s3
provider = DreamHost
env_auth = false
access_key_id = your_access_key
secret_access_key = your_secret_key
region =
endpoint = objects-us-west-1.dream.io
location_constraint =
acl = private
server_side_encryption =
storage_class =

Exaba

Exaba is an on-premises, S3-compatible storage for service providers and large enterprises. It is quick to deploy, with dynamic node management, tenant accounting, and a built-in key management system. It delivers secure, high-performance data storage with flexible, usage-based pricing.

A container version exaba/exaba is free for end-users and on that page you can find instructions on how to set it up. You will need to log into the admin first (on port 9006 by default) to set up the container, then you can use the service on port 9000.

You can also join the exaba support slack if you need more help.

An rclone config walkthrough might look like this but details may vary depending exactly on how you have set up the container.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter name for new remote.
name> exaba

Option Storage.
Type of storage to configure.
Storage> s3

Option provider.
Choose your S3 provider.
provider> Exaba

Option env_auth.
env_auth> 1

Option access_key_id.
access_key_id> XXX

Option secret_access_key.
secret_access_key> YYY

Option region.
region>

Option endpoint.
endpoint> http://127.0.0.1:9000/

Option location_constraint.
location_constraint>

Option acl.
acl>

Edit advanced config?
y) Yes
n) No (default)
y/n> n

And the config generated will end up looking like this:

[exaba]
type = s3
provider = Exaba
access_key_id = XXX
secret_access_key = XXX
endpoint = http://127.0.0.1:9000/

Google Cloud Storage

GoogleCloudStorage is an S3-interoperable object storage service from Google Cloud Platform.

To connect to Google Cloud Storage you will need an access key and secret key. These can be retrieved by creating an HMAC key.

[gs]
type = s3
provider = GCS
access_key_id = your_access_key
secret_access_key = your_secret_key
endpoint = https://storage.googleapis.com

Note that --s3-versions does not work with GCS when it needs to do directory paging. Rclone will return the error:

s3 protocol error: received versions listing with IsTruncated set with no NextKeyMarker

This is Google bug #312292516.

Huawei OBS

Object Storage Service (OBS) provides stable, secure, efficient, and easy-to-use cloud storage that lets you store virtually any volume of unstructured data in any format and access it from anywhere.

OBS provides an S3 interface, you can copy and modify the following configuration and add it to your rclone configuration file.

[obs]
type = s3
provider = HuaweiOBS
access_key_id = your-access-key-id
secret_access_key = your-secret-access-key
region = af-south-1
endpoint = obs.af-south-1.myhuaweicloud.com
acl = private

Or you can also configure via the interactive command line:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> obs
Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ (s3)
[snip]
Storage> s3
Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
[snip]
 9 / Huawei Object Storage Service
   \ (HuaweiOBS)
[snip]
provider> 9
Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth> 1
Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> your-access-key-id
Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> your-secret-access-key
Option region.
Region to connect to.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / AF-Johannesburg
   \ (af-south-1)
 2 / AP-Bangkok
   \ (ap-southeast-2)
[snip]
region> 1
Option endpoint.
Endpoint for OBS API.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / AF-Johannesburg
   \ (obs.af-south-1.myhuaweicloud.com)
 2 / AP-Bangkok
   \ (obs.ap-southeast-2.myhuaweicloud.com)
[snip]
endpoint> 1
Option acl.
Canned ACL used when creating buckets and storing or copying objects.
This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
   / Owner gets FULL_CONTROL.
 1 | No one else has access rights (default).
   \ (private)
[snip]
acl> 1
Edit advanced config?
y) Yes
n) No (default)
y/n>
--------------------
[obs]
type = s3
provider = HuaweiOBS
access_key_id = your-access-key-id
secret_access_key = your-secret-access-key
region = af-south-1
endpoint = obs.af-south-1.myhuaweicloud.com
acl = private
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y
Current remotes:

Name                 Type
====                 ====
obs                  s3

e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> q

IBM COS (S3)

Information stored with IBM Cloud Object Storage is encrypted and dispersed across multiple geographic locations, and accessed through an implementation of the S3 API. This service makes use of the distributed storage technologies provided by IBM’s Cloud Object Storage System (formerly Cleversafe). For more information visit: (http://www.ibm.com/cloud/object-storage)

To configure access to IBM COS S3, follow the steps below:

  1. Run rclone config and select n for a new remote.
    2018/02/14 14:13:11 NOTICE: Config file "C:\\Users\\a\\.config\\rclone\\rclone.conf" not found - using defaults
    No remotes found, make a new one?
    n) New remote
    s) Set configuration password
    q) Quit config
    n/s/q> n
  1. Enter the name for the configuration
    name> <YOUR NAME>
  1. Select "s3" storage.
Choose a number from below, or type in your own value
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ "s3"
[snip]
Storage> s3
  1. Select IBM COS as the S3 Storage Provider.
Choose the S3 provider.
Choose a number from below, or type in your own value
     1 / Choose this option to configure Storage to AWS S3
       \ "AWS"
     2 / Choose this option to configure Storage to Ceph Systems
     \ "Ceph"
     3 /  Choose this option to configure Storage to Dreamhost
     \ "Dreamhost"
   4 / Choose this option to the configure Storage to IBM COS S3
     \ "IBMCOS"
     5 / Choose this option to the configure Storage to Minio
     \ "Minio"
     Provider>4
  1. Enter the Access Key and Secret.
    AWS Access Key ID - leave blank for anonymous access or runtime credentials.
    access_key_id> <>
    AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials.
    secret_access_key> <>
  1. Specify the endpoint for IBM COS. For Public IBM COS, choose from the option below. For On Premise IBM COS, enter an endpoint address.
    Endpoint for IBM COS S3 API.
    Specify if using an IBM COS On Premise.
    Choose a number from below, or type in your own value
     1 / US Cross Region Endpoint
       \ "s3-api.us-geo.objectstorage.softlayer.net"
     2 / US Cross Region Dallas Endpoint
       \ "s3-api.dal.us-geo.objectstorage.softlayer.net"
     3 / US Cross Region Washington DC Endpoint
       \ "s3-api.wdc-us-geo.objectstorage.softlayer.net"
     4 / US Cross Region San Jose Endpoint
       \ "s3-api.sjc-us-geo.objectstorage.softlayer.net"
     5 / US Cross Region Private Endpoint
       \ "s3-api.us-geo.objectstorage.service.networklayer.com"
     6 / US Cross Region Dallas Private Endpoint
       \ "s3-api.dal-us-geo.objectstorage.service.networklayer.com"
     7 / US Cross Region Washington DC Private Endpoint
       \ "s3-api.wdc-us-geo.objectstorage.service.networklayer.com"
     8 / US Cross Region San Jose Private Endpoint
       \ "s3-api.sjc-us-geo.objectstorage.service.networklayer.com"
     9 / US Region East Endpoint
       \ "s3.us-east.objectstorage.softlayer.net"
    10 / US Region East Private Endpoint
       \ "s3.us-east.objectstorage.service.networklayer.com"
    11 / US Region South Endpoint
[snip]
    34 / Toronto Single Site Private Endpoint
       \ "s3.tor01.objectstorage.service.networklayer.com"
    endpoint>1
  1. Specify a IBM COS Location Constraint. The location constraint must match endpoint when using IBM Cloud Public. For on-prem COS, do not make a selection from this list, hit enter
     1 / US Cross Region Standard
       \ "us-standard"
     2 / US Cross Region Vault
       \ "us-vault"
     3 / US Cross Region Cold
       \ "us-cold"
     4 / US Cross Region Flex
       \ "us-flex"
     5 / US East Region Standard
       \ "us-east-standard"
     6 / US East Region Vault
       \ "us-east-vault"
     7 / US East Region Cold
       \ "us-east-cold"
     8 / US East Region Flex
       \ "us-east-flex"
     9 / US South Region Standard
       \ "us-south-standard"
    10 / US South Region Vault
       \ "us-south-vault"
[snip]
    32 / Toronto Flex
       \ "tor01-flex"
location_constraint>1
  1. Specify a canned ACL. IBM Cloud (Storage) supports "public-read" and "private". IBM Cloud(Infra) supports all the canned ACLs. On-Premise COS supports all the canned ACLs.
Canned ACL used when creating buckets and/or storing objects in S3.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Choose a number from below, or type in your own value
      1 / Owner gets FULL_CONTROL. No one else has access rights (default). This acl is available on IBM Cloud (Infra), IBM Cloud (Storage), On-Premise COS
      \ "private"
      2  / Owner gets FULL_CONTROL. The AllUsers group gets READ access. This acl is available on IBM Cloud (Infra), IBM Cloud (Storage), On-Premise IBM COS
      \ "public-read"
      3 / Owner gets FULL_CONTROL. The AllUsers group gets READ and WRITE access. This acl is available on IBM Cloud (Infra), On-Premise IBM COS
      \ "public-read-write"
      4  / Owner gets FULL_CONTROL. The AuthenticatedUsers group gets READ access. Not supported on Buckets. This acl is available on IBM Cloud (Infra) and On-Premise IBM COS
      \ "authenticated-read"
acl> 1
  1. Review the displayed configuration and accept to save the "remote" then quit. The config file should look like this
    [xxx]
    type = s3
    Provider = IBMCOS
    access_key_id = xxx
    secret_access_key = yyy
    endpoint = s3-api.us-geo.objectstorage.softlayer.net
    location_constraint = us-standard
    acl = private
  1. Execute rclone commands
    1)  Create a bucket.
        rclone mkdir IBM-COS-XREGION:newbucket
    2)  List available buckets.
        rclone lsd IBM-COS-XREGION:
        -1 2017-11-08 21:16:22        -1 test
        -1 2018-02-14 20:16:39        -1 newbucket
    3)  List contents of a bucket.
        rclone ls IBM-COS-XREGION:newbucket
        18685952 test.exe
    4)  Copy a file from local to remote.
        rclone copy /Users/file.txt IBM-COS-XREGION:newbucket
    5)  Copy a file from remote to local.
        rclone copy IBM-COS-XREGION:newbucket/file.txt .
    6)  Delete a file on remote.
        rclone delete IBM-COS-XREGION:newbucket/file.txt

IBM IAM authentication

If using IBM IAM authentication with IBM API KEY you need to fill in these additional parameters 1. Select false for env_auth 2. Leave access_key_id and secret_access_key blank 3. Paste your ibm_api_key

Option ibm_api_key.
IBM API Key to be used to obtain IAM token
Enter a value of type string. Press Enter for the default (1).
ibm_api_key>
  1. Paste your ibm_resource_instance_id
Option ibm_resource_instance_id.
IBM service instance id
Enter a value of type string. Press Enter for the default (2).
ibm_resource_instance_id>
  1. In advanced settings type true for v2_auth
Option v2_auth.
If true use v2 authentication.
If this is false (the default) then rclone will use v4 authentication.
If it is set then rclone will use v2 authentication.
Use this only if v4 signatures don't work, e.g. pre Jewel/v10 CEPH.
Enter a boolean value (true or false). Press Enter for the default (true).
v2_auth>

IDrive e2

Here is an example of making an IDrive e2 configuration. First run:

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter name for new remote.
name> e2

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ (s3)
[snip]
Storage> s3

Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
[snip]
XX / IDrive e2
   \ (IDrive)
[snip]
provider> IDrive

Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth> 

Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> YOUR_ACCESS_KEY

Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> YOUR_SECRET_KEY

Option acl.
Canned ACL used when creating buckets and storing or copying objects.
This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
   / Owner gets FULL_CONTROL.
 1 | No one else has access rights (default).
   \ (private)
   / Owner gets FULL_CONTROL.
 2 | The AllUsers group gets READ access.
   \ (public-read)
   / Owner gets FULL_CONTROL.
 3 | The AllUsers group gets READ and WRITE access.
   | Granting this on a bucket is generally not recommended.
   \ (public-read-write)
   / Owner gets FULL_CONTROL.
 4 | The AuthenticatedUsers group gets READ access.
   \ (authenticated-read)
   / Object owner gets FULL_CONTROL.
 5 | Bucket owner gets READ access.
   | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it.
   \ (bucket-owner-read)
   / Both the object owner and the bucket owner get FULL_CONTROL over the object.
 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it.
   \ (bucket-owner-full-control)
acl> 

Edit advanced config?
y) Yes
n) No (default)
y/n> 

Configuration complete.
Options:
- type: s3
- provider: IDrive
- access_key_id: YOUR_ACCESS_KEY
- secret_access_key: YOUR_SECRET_KEY
- endpoint: q9d9.la12.idrivee2-5.com
Keep this "e2" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

IONOS Cloud

IONOS S3 Object Storage is a service offered by IONOS for storing and accessing unstructured data. To connect to the service, you will need an access key and a secret key. These can be found in the Data Center Designer, by selecting Manager resources > Object Storage Key Manager.

Here is an example of a configuration. First, run rclone config. This will walk you through an interactive setup process. Type n to add the new remote, and then enter a name:

Enter name for new remote.
name> ionos-fra

Type s3 to choose the connection type:

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ (s3)
[snip]
Storage> s3

Type IONOS:

Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
[snip]
XX / IONOS Cloud
   \ (IONOS)
[snip]
provider> IONOS

Press Enter to choose the default option Enter AWS credentials in the next step:

Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth>

Enter your Access Key and Secret key. These can be retrieved in the Data Center Designer, click on the menu “Manager resources” / "Object Storage Key Manager".

Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> YOUR_ACCESS_KEY

Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> YOUR_SECRET_KEY

Choose the region where your bucket is located:

Option region.
Region where your bucket will be created and your data stored.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Frankfurt, Germany
   \ (de)
 2 / Berlin, Germany
   \ (eu-central-2)
 3 / Logrono, Spain
   \ (eu-south-2)
region> 2

Choose the endpoint from the same region:

Option endpoint.
Endpoint for IONOS S3 Object Storage.
Specify the endpoint from the same region.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Frankfurt, Germany
   \ (s3-eu-central-1.ionoscloud.com)
 2 / Berlin, Germany
   \ (s3-eu-central-2.ionoscloud.com)
 3 / Logrono, Spain
   \ (s3-eu-south-2.ionoscloud.com)
endpoint> 1

Press Enter to choose the default option or choose the desired ACL setting:

Option acl.
Canned ACL used when creating buckets and storing or copying objects.
This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
   / Owner gets FULL_CONTROL.
 1 | No one else has access rights (default).
   \ (private)
   / Owner gets FULL_CONTROL.
[snip]
acl>

Press Enter to skip the advanced config:

Edit advanced config?
y) Yes
n) No (default)
y/n>

Press Enter to save the configuration, and then q to quit the configuration process:

Configuration complete.
Options:
- type: s3
- provider: IONOS
- access_key_id: YOUR_ACCESS_KEY
- secret_access_key: YOUR_SECRET_KEY
- endpoint: s3-eu-central-1.ionoscloud.com
Keep this "ionos-fra" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Done! Now you can try some commands (for macOS, use ./rclone instead of rclone).

  1. Create a bucket (the name must be unique within the whole IONOS S3)
rclone mkdir ionos-fra:my-bucket
  1. List available buckets
rclone lsd ionos-fra:
  1. Copy a file from local to remote
rclone copy /Users/file.txt ionos-fra:my-bucket
  1. List contents of a bucket
rclone ls ionos-fra:my-bucket
  1. Copy a file from remote to local
rclone copy ionos-fra:my-bucket/file.txt

Leviia Cloud Object Storage

Leviia Object Storage, backup and secure your data in a 100% French cloud, independent of GAFAM..

To configure access to Leviia, follow the steps below:

  1. Run rclone config and select n for a new remote.
rclone config
No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
  1. Give the name of the configuration. For example, name it 'leviia'.
name> leviia
  1. Select s3 storage.
Choose a number from below, or type in your own value
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ (s3)
[snip]
Storage> s3
  1. Select Leviia provider.
Choose a number from below, or type in your own value
1 / Amazon Web Services (AWS) S3
   \ "AWS"
[snip]
15 / Leviia Object Storage
   \ (Leviia)
[snip]
provider> Leviia
  1. Enter your SecretId and SecretKey of Leviia.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Enter a boolean value (true or false). Press Enter for the default ("false").
Choose a number from below, or type in your own value
 1 / Enter AWS credentials in the next step
   \ "false"
 2 / Get AWS credentials from the environment (env vars or IAM)
   \ "true"
env_auth> 1
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a string value. Press Enter for the default ("").
access_key_id> ZnIx.xxxxxxxxxxxxxxx
AWS Secret Access Key (password)
Leave blank for anonymous access or runtime credentials.
Enter a string value. Press Enter for the default ("").
secret_access_key> xxxxxxxxxxx
  1. Select endpoint for Leviia.
   / The default endpoint
 1 | Leviia.
   \ (s3.leviia.com)
[snip]
endpoint> 1
  1. Choose acl.
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
   / Owner gets FULL_CONTROL.
 1 | No one else has access rights (default).
   \ (private)
   / Owner gets FULL_CONTROL.
 2 | The AllUsers group gets READ access.
   \ (public-read)
[snip]
acl> 1
Edit advanced config? (y/n)
y) Yes
n) No (default)
y/n> n
Remote config
--------------------
[leviia]
- type: s3
- provider: Leviia
- access_key_id: ZnIx.xxxxxxx
- secret_access_key: xxxxxxxx
- endpoint: s3.leviia.com
- acl: private
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y
Current remotes:

Name                 Type
====                 ====
leviia                s3

Liara

Here is an example of making a Liara Object Storage configuration. First run:

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
n/s> n
name> Liara
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Amazon S3 (also Dreamhost, Ceph, ChinaMobile, ArvanCloud, Liara, Minio)
   \ "s3"
[snip]
Storage> s3
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own value
 1 / Enter AWS credentials in the next step
   \ "false"
 2 / Get AWS credentials from the environment (env vars or IAM)
   \ "true"
env_auth> 1
AWS Access Key ID - leave blank for anonymous access or runtime credentials.
access_key_id> YOURACCESSKEY
AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials.
secret_access_key> YOURSECRETACCESSKEY
Region to connect to.
Choose a number from below, or type in your own value
   / The default endpoint
 1 | US Region, Northern Virginia, or Pacific Northwest.
   | Leave location constraint empty.
   \ "us-east-1"
[snip]
region>
Endpoint for S3 API.
Leave blank if using Liara to use the default endpoint for the region.
Specify if using an S3 clone such as Ceph.
endpoint> storage.iran.liara.space
Canned ACL used when creating buckets and/or storing objects in S3.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Choose a number from below, or type in your own value
 1 / Owner gets FULL_CONTROL. No one else has access rights (default).
   \ "private"
[snip]
acl>
The server-side encryption algorithm used when storing this object in S3.
Choose a number from below, or type in your own value
 1 / None
   \ ""
 2 / AES256
   \ "AES256"
server_side_encryption>
The storage class to use when storing objects in S3.
Choose a number from below, or type in your own value
 1 / Default
   \ ""
 2 / Standard storage class
   \ "STANDARD"
storage_class>
Remote config
--------------------
[Liara]
env_auth = false
access_key_id = YOURACCESSKEY
secret_access_key = YOURSECRETACCESSKEY
endpoint = storage.iran.liara.space
location_constraint =
acl =
server_side_encryption =
storage_class =
--------------------
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

This will leave the config file looking like this.

[Liara]
type = s3
provider = Liara
env_auth = false
access_key_id = YOURACCESSKEY
secret_access_key = YOURSECRETACCESSKEY
region =
endpoint = storage.iran.liara.space
location_constraint =
acl =
server_side_encryption =
storage_class =

Linode

Here is an example of making a Linode Object Storage configuration. First run:

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter name for new remote.
name> linode

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS, ...Linode, ...and others
   \ (s3)
[snip]
Storage> s3

Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
[snip]
XX / Linode Object Storage
   \ (Linode)
[snip]
provider> Linode

Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth> 

Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> ACCESS_KEY

Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> SECRET_ACCESS_KEY

Option endpoint.
Endpoint for Linode Object Storage API.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Amsterdam (Netherlands), nl-ams-1
   \ (nl-ams-1.linodeobjects.com)
 2 / Atlanta, GA (USA), us-southeast-1
   \ (us-southeast-1.linodeobjects.com)
 3 / Chennai (India), in-maa-1
   \ (in-maa-1.linodeobjects.com)
 4 / Chicago, IL (USA), us-ord-1
   \ (us-ord-1.linodeobjects.com)
 5 / Frankfurt (Germany), eu-central-1
   \ (eu-central-1.linodeobjects.com)
 6 / Jakarta (Indonesia), id-cgk-1
   \ (id-cgk-1.linodeobjects.com)
 7 / London 2 (Great Britain), gb-lon-1
   \ (gb-lon-1.linodeobjects.com)
 8 / Los Angeles, CA (USA), us-lax-1
   \ (us-lax-1.linodeobjects.com)
 9 / Madrid (Spain), es-mad-1
   \ (es-mad-1.linodeobjects.com)
10 / Melbourne (Australia), au-mel-1
   \ (au-mel-1.linodeobjects.com)
11 / Miami, FL (USA), us-mia-1
   \ (us-mia-1.linodeobjects.com)
12 / Milan (Italy), it-mil-1
   \ (it-mil-1.linodeobjects.com)
13 / Newark, NJ (USA), us-east-1
   \ (us-east-1.linodeobjects.com)
14 / Osaka (Japan), jp-osa-1
   \ (jp-osa-1.linodeobjects.com)
15 / Paris (France), fr-par-1
   \ (fr-par-1.linodeobjects.com)
16 / São Paulo (Brazil), br-gru-1
   \ (br-gru-1.linodeobjects.com)
17 / Seattle, WA (USA), us-sea-1
   \ (us-sea-1.linodeobjects.com)
18 / Singapore, ap-south-1
   \ (ap-south-1.linodeobjects.com)
19 / Singapore 2, sg-sin-1
   \ (sg-sin-1.linodeobjects.com)
20 / Stockholm (Sweden), se-sto-1
   \ (se-sto-1.linodeobjects.com)
21 / Washington, DC, (USA), us-iad-1
   \ (us-iad-1.linodeobjects.com)
endpoint> 5

Option acl.
Canned ACL used when creating buckets and storing or copying objects.
This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
If the acl is an empty string then no X-Amz-Acl: header is added and
the default (private) will be used.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
   / Owner gets FULL_CONTROL.
 1 | No one else has access rights (default).
   \ (private)
[snip]
acl> 

Edit advanced config?
y) Yes
n) No (default)
y/n> n

Configuration complete.
Options:
- type: s3
- provider: Linode
- access_key_id: ACCESS_KEY
- secret_access_key: SECRET_ACCESS_KEY
- endpoint: eu-central-1.linodeobjects.com
Keep this "linode" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

This will leave the config file looking like this.

[linode]
type = s3
provider = Linode
access_key_id = ACCESS_KEY
secret_access_key = SECRET_ACCESS_KEY
endpoint = eu-central-1.linodeobjects.com

Magalu

Here is an example of making a Magalu Object Storage configuration. First run:

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter name for new remote.
name> magalu

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS, ...Magalu, ...and others
   \ (s3)
[snip]
Storage> s3

Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
[snip]
XX / Magalu Object Storage
   \ (Magalu)
[snip]
provider> Magalu

Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth> 1

Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> ACCESS_KEY

Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> SECRET_ACCESS_KEY

Option endpoint.
Endpoint for Magalu Object Storage API.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / São Paulo, SP (BR), br-se1
   \ (br-se1.magaluobjects.com)
 2 / Fortaleza, CE (BR), br-ne1
   \ (br-ne1.magaluobjects.com)
endpoint> 2

Option acl.
Canned ACL used when creating buckets and storing or copying objects.
This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
If the acl is an empty string then no X-Amz-Acl: header is added and
the default (private) will be used.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
   / Owner gets FULL_CONTROL.
 1 | No one else has access rights (default).
   \ (private)
[snip]
acl> 

Edit advanced config?
y) Yes
n) No (default)
y/n> n

Configuration complete.
Options:
- type: s3
- provider: magalu
- access_key_id: ACCESS_KEY
- secret_access_key: SECRET_ACCESS_KEY
- endpoint: br-ne1.magaluobjects.com
Keep this "magalu" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

This will leave the config file looking like this.

[magalu]
type = s3
provider = Magalu
access_key_id = ACCESS_KEY
secret_access_key = SECRET_ACCESS_KEY
endpoint = br-ne1.magaluobjects.com

MEGA S4

MEGA S4 Object Storage is an S3 compatible object storage system. It has a single pricing tier with no additional charges for data transfers or API requests and it is included in existing Pro plans.

Here is an example of making a configuration. First run:

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter name for new remote.
name> megas4

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS,... Mega, ...
   \ (s3)
[snip]
Storage> s3

Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
[snip]
XX / MEGA S4 Object Storage
   \ (Mega)
[snip]
provider> Mega

Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth>

Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> XXX

Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> XXX

Option endpoint.
Endpoint for S3 API.
Required when using an S3 clone.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Mega S4 eu-central-1 (Amsterdam)
   \ (s3.eu-central-1.s4.mega.io)
 2 / Mega S4 eu-central-2 (Bettembourg)
   \ (s3.eu-central-2.s4.mega.io)
 3 / Mega S4 ca-central-1 (Montreal)
   \ (s3.ca-central-1.s4.mega.io)
 4 / Mega S4 ca-west-1 (Vancouver)
   \ (s3.ca-west-1.s4.mega.io)
endpoint> 1

Edit advanced config?
y) Yes
n) No (default)
y/n> n

Configuration complete.
Options:
- type: s3
- provider: Mega
- access_key_id: XXX
- secret_access_key: XXX
- endpoint: s3.eu-central-1.s4.mega.io
Keep this "megas4" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

This will leave the config file looking like this.

[megas4]
type = s3
provider = Mega
access_key_id = XXX
secret_access_key = XXX
endpoint = s3.eu-central-1.s4.mega.io

Minio

Minio is an object storage server built for cloud application developers and devops.

It is very easy to install and provides an S3 compatible server which can be used by rclone.

To use it, install Minio following the instructions here.

When it configures itself Minio will print something like this

Endpoint:  http://192.168.1.106:9000  http://172.23.0.1:9000
AccessKey: USWUXHGYZQYFYFFIT3RE
SecretKey: MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03
Region:    us-east-1
SQS ARNs:  arn:minio:sqs:us-east-1:1:redis arn:minio:sqs:us-east-1:2:redis

Browser Access:
   http://192.168.1.106:9000  http://172.23.0.1:9000

Command-line Access: https://docs.minio.io/docs/minio-client-quickstart-guide
   $ mc config host add myminio http://192.168.1.106:9000 USWUXHGYZQYFYFFIT3RE MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03

Object API (Amazon S3 compatible):
   Go:         https://docs.minio.io/docs/golang-client-quickstart-guide
   Java:       https://docs.minio.io/docs/java-client-quickstart-guide
   Python:     https://docs.minio.io/docs/python-client-quickstart-guide
   JavaScript: https://docs.minio.io/docs/javascript-client-quickstart-guide
   .NET:       https://docs.minio.io/docs/dotnet-client-quickstart-guide

Drive Capacity: 26 GiB Free, 165 GiB Total

These details need to go into rclone config like this. Note that it is important to put the region in as stated above.

env_auth> 1
access_key_id> USWUXHGYZQYFYFFIT3RE
secret_access_key> MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03
region> us-east-1
endpoint> http://192.168.1.106:9000
location_constraint>
server_side_encryption>

Which makes the config file look like this

[minio]
type = s3
provider = Minio
env_auth = false
access_key_id = USWUXHGYZQYFYFFIT3RE
secret_access_key = MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03
region = us-east-1
endpoint = http://192.168.1.106:9000
location_constraint =
server_side_encryption =

So once set up, for example, to copy files into a bucket

rclone copy /path/to/files minio:bucket

Netease NOS

For Netease NOS configure as per the configurator rclone config setting the provider Netease. This will automatically set force_path_style = false which is necessary for it to run properly.

Outscale

OUTSCALE Object Storage (OOS) is an enterprise-grade, S3-compatible storage service provided by OUTSCALE, a brand of Dassault Systèmes. For more information about OOS, see the official documentation.

Here is an example of an OOS configuration that you can paste into your rclone configuration file:

[outscale]
type = s3
provider = Outscale
env_auth = false
access_key_id = ABCDEFGHIJ0123456789
secret_access_key = XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
region = eu-west-2
endpoint = oos.eu-west-2.outscale.com
acl = private

You can also run rclone config to go through the interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
Enter name for new remote.
name> outscale
Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
 X / Amazon S3 Compliant Storage Providers including AWS, ...Outscale, ...and others
   \ (s3)
[snip]
Storage> outscale
Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
[snip]
XX / OUTSCALE Object Storage (OOS)
   \ (Outscale)
[snip]
provider> Outscale
Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth> 
Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> ABCDEFGHIJ0123456789
Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Option region.
Region where your bucket will be created and your data stored.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Paris, France
   \ (eu-west-2)
 2 / New Jersey, USA
   \ (us-east-2)
 3 / California, USA
   \ (us-west-1)
 4 / SecNumCloud, Paris, France
   \ (cloudgouv-eu-west-1)
 5 / Tokyo, Japan
   \ (ap-northeast-1)
region> 1
Option endpoint.
Endpoint for S3 API.
Required when using an S3 clone.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Outscale EU West 2 (Paris)
   \ (oos.eu-west-2.outscale.com)
 2 / Outscale US east 2 (New Jersey)
   \ (oos.us-east-2.outscale.com)
 3 / Outscale EU West 1 (California)
   \ (oos.us-west-1.outscale.com)
 4 / Outscale SecNumCloud (Paris)
   \ (oos.cloudgouv-eu-west-1.outscale.com)
 5 / Outscale AP Northeast 1 (Japan)
   \ (oos.ap-northeast-1.outscale.com)
endpoint> 1
Option acl.
Canned ACL used when creating buckets and storing or copying objects.
This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
If the acl is an empty string then no X-Amz-Acl: header is added and
the default (private) will be used.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
   / Owner gets FULL_CONTROL.
 1 | No one else has access rights (default).
   \ (private)
[snip]
acl> 1
Edit advanced config?
y) Yes
n) No (default)
y/n> n
Configuration complete.
Options:
- type: s3
- provider: Outscale
- access_key_id: ABCDEFGHIJ0123456789
- secret_access_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
- endpoint: oos.eu-west-2.outscale.com
Keep this "outscale" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

OVHcloud

OVHcloud Object Storage is an S3-compatible general-purpose object storage platform available in all OVHcloud regions. To use the platform, you will need an access key and secret key. To know more about it and how to interact with the platform, take a look at the documentation.

Here is an example of making an OVHcloud Object Storage configuration with rclone config:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter name for new remote.
name> ovhcloud-rbx

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[...]
 XX / Amazon S3 Compliant Storage Providers including AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, Magalu, Minio, Netease, Outscale, OVHcloud, Petabox, RackCorp, Rclone, Scaleway, SeaweedFS, Selectel, StackPath, Storj, Synology, TencentCOS, Wasabi, Qiniu and others
   \ (s3)
[...]
Storage> s3

Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
[...]
XX / OVHcloud Object Storage
   \ (OVHcloud)
[...]
provider> OVHcloud

Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth> 1

Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> my_access

Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> my_secret

Option region.
Region where your bucket will be created and your data stored.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Gravelines, France
   \ (gra)
 2 / Roubaix, France
   \ (rbx)
 3 / Strasbourg, France
   \ (sbg)
 4 / Paris, France (3AZ)
   \ (eu-west-par)
 5 / Frankfurt, Germany
   \ (de)
 6 / London, United Kingdom
   \ (uk)
 7 / Warsaw, Poland
   \ (waw)
 8 / Beauharnois, Canada
   \ (bhs)
 9 / Toronto, Canada
   \ (ca-east-tor)
10 / Singapore
   \ (sgp)
11 / Sydney, Australia
   \ (ap-southeast-syd)
12 / Mumbai, India
   \ (ap-south-mum)
13 / Vint Hill, Virginia, USA
   \ (us-east-va)
14 / Hillsboro, Oregon, USA
   \ (us-west-or)
15 / Roubaix, France (Cold Archive)
   \ (rbx-archive)
region> 2

Option endpoint.
Endpoint for OVHcloud Object Storage.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / OVHcloud Gravelines, France
   \ (s3.gra.io.cloud.ovh.net)
 2 / OVHcloud Roubaix, France
   \ (s3.rbx.io.cloud.ovh.net)
 3 / OVHcloud Strasbourg, France
   \ (s3.sbg.io.cloud.ovh.net)
 4 / OVHcloud Paris, France (3AZ)
   \ (s3.eu-west-par.io.cloud.ovh.net)
 5 / OVHcloud Frankfurt, Germany
   \ (s3.de.io.cloud.ovh.net)
 6 / OVHcloud London, United Kingdom
   \ (s3.uk.io.cloud.ovh.net)
 7 / OVHcloud Warsaw, Poland
   \ (s3.waw.io.cloud.ovh.net)
 8 / OVHcloud Beauharnois, Canada
   \ (s3.bhs.io.cloud.ovh.net)
 9 / OVHcloud Toronto, Canada
   \ (s3.ca-east-tor.io.cloud.ovh.net)
10 / OVHcloud Singapore
   \ (s3.sgp.io.cloud.ovh.net)
11 / OVHcloud Sydney, Australia
   \ (s3.ap-southeast-syd.io.cloud.ovh.net)
12 / OVHcloud Mumbai, India
   \ (s3.ap-south-mum.io.cloud.ovh.net)
13 / OVHcloud Vint Hill, Virginia, USA
   \ (s3.us-east-va.io.cloud.ovh.us)
14 / OVHcloud Hillsboro, Oregon, USA
   \ (s3.us-west-or.io.cloud.ovh.us)
15 / OVHcloud Roubaix, France (Cold Archive)
   \ (s3.rbx-archive.io.cloud.ovh.net)
endpoint> 2

Option acl.
Canned ACL used when creating buckets and storing or copying objects.
This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
If the acl is an empty string then no X-Amz-Acl: header is added and
the default (private) will be used.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
   / Owner gets FULL_CONTROL.
 1 | No one else has access rights (default).
   \ (private)
   / Owner gets FULL_CONTROL.
 2 | The AllUsers group gets READ access.
   \ (public-read)
   / Owner gets FULL_CONTROL.
 3 | The AllUsers group gets READ and WRITE access.
   | Granting this on a bucket is generally not recommended.
   \ (public-read-write)
   / Owner gets FULL_CONTROL.
 4 | The AuthenticatedUsers group gets READ access.
   \ (authenticated-read)
   / Object owner gets FULL_CONTROL.
 5 | Bucket owner gets READ access.
   | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it.
   \ (bucket-owner-read)
   / Both the object owner and the bucket owner get FULL_CONTROL over the object.
 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it.
   \ (bucket-owner-full-control)
acl> 1

Edit advanced config?
y) Yes
n) No (default)
y/n> n

Configuration complete.
Options:
- type: s3
- provider: OVHcloud
- access_key_id: my_access
- secret_access_key: my_secret
- region: rbx
- endpoint: s3.rbx.io.cloud.ovh.net
- acl: private
Keep this "ovhcloud-rbx" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Your configuration file should now look like this:

[ovhcloud-rbx]
type = s3
provider = OVHcloud
access_key_id = my_access
secret_access_key = my_secret
region = rbx
endpoint = s3.rbx.io.cloud.ovh.net
acl = private

Petabox

Here is an example of making a Petabox configuration. First run:

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
n/s> n

Enter name for new remote.
name> My Petabox Storage

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ "s3"
[snip]
Storage> s3

Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
[snip]
XX / Petabox Object Storage
   \ (Petabox)
[snip]
provider> Petabox

Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth> 1

Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> YOUR_ACCESS_KEY_ID

Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> YOUR_SECRET_ACCESS_KEY

Option region.
Region where your bucket will be created and your data stored.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / US East (N. Virginia)
   \ (us-east-1)
 2 / Europe (Frankfurt)
   \ (eu-central-1)
 3 / Asia Pacific (Singapore)
   \ (ap-southeast-1)
 4 / Middle East (Bahrain)
   \ (me-south-1)
 5 / South America (São Paulo)
   \ (sa-east-1)
region> 1

Option endpoint.
Endpoint for Petabox S3 Object Storage.
Specify the endpoint from the same region.
Choose a number from below, or type in your own value.
 1 / US East (N. Virginia)
   \ (s3.petabox.io)
 2 / US East (N. Virginia)
   \ (s3.us-east-1.petabox.io)
 3 / Europe (Frankfurt)
   \ (s3.eu-central-1.petabox.io)
 4 / Asia Pacific (Singapore)
   \ (s3.ap-southeast-1.petabox.io)
 5 / Middle East (Bahrain)
   \ (s3.me-south-1.petabox.io)
 6 / South America (São Paulo)
   \ (s3.sa-east-1.petabox.io)
endpoint> 1

Option acl.
Canned ACL used when creating buckets and storing or copying objects.
This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
If the acl is an empty string then no X-Amz-Acl: header is added and
the default (private) will be used.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
   / Owner gets FULL_CONTROL.
 1 | No one else has access rights (default).
   \ (private)
   / Owner gets FULL_CONTROL.
 2 | The AllUsers group gets READ access.
   \ (public-read)
   / Owner gets FULL_CONTROL.
 3 | The AllUsers group gets READ and WRITE access.
   | Granting this on a bucket is generally not recommended.
   \ (public-read-write)
   / Owner gets FULL_CONTROL.
 4 | The AuthenticatedUsers group gets READ access.
   \ (authenticated-read)
   / Object owner gets FULL_CONTROL.
 5 | Bucket owner gets READ access.
   | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it.
   \ (bucket-owner-read)
   / Both the object owner and the bucket owner get FULL_CONTROL over the object.
 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it.
   \ (bucket-owner-full-control)
acl> 1

Edit advanced config?
y) Yes
n) No (default)
y/n> No

Configuration complete.
Options:
- type: s3
- provider: Petabox
- access_key_id: YOUR_ACCESS_KEY_ID
- secret_access_key: YOUR_SECRET_ACCESS_KEY
- region: us-east-1
- endpoint: s3.petabox.io
Keep this "My Petabox Storage" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

This will leave the config file looking like this.

[My Petabox Storage]
type = s3
provider = Petabox
access_key_id = YOUR_ACCESS_KEY_ID
secret_access_key = YOUR_SECRET_ACCESS_KEY
region = us-east-1
endpoint = s3.petabox.io

Pure Storage FlashBlade

Pure Storage FlashBlade is a high performance S3-compatible object store.

FlashBlade supports most modern S3 features including:

  • ListObjectsV2
  • Multipart uploads with AWS-compatible ETags
  • Advanced checksum algorithms (SHA256, CRC32, CRC32C) with trailer support (Purity//FB 4.4.2+)
  • Object versioning and lifecycle management
  • Virtual hosted-style requests (requires DNS configuration)

To configure rclone for Pure Storage FlashBlade:

First run:

rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter name for new remote.
name> flashblade

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
 4 / Amazon S3 Compliant Storage Providers including AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, FlashBlade, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, Magalu, Minio, Netease, Outscale, Petabox, RackCorp, Rclone, Scaleway, SeaweedFS, Selectel, StackPath, Storj, Synology, TencentCOS, Wasabi, Qiniu and others
   \ (s3)
[snip]
Storage> s3

Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
[snip]
 9 / Pure Storage FlashBlade Object Storage
   \ (FlashBlade)
[snip]
provider> FlashBlade

Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth> 1

Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> ACCESS_KEY_ID

Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> SECRET_ACCESS_KEY

Option endpoint.
Endpoint for S3 API.
Required when using an S3 clone.
Enter a value. Press Enter to leave empty.
endpoint> https://s3.flashblade.example.com

Edit advanced config?
y) Yes
n) No (default)
y/n> n

Configuration complete.
Options:
- type: s3
- provider: FlashBlade
- access_key_id: ACCESS_KEY_ID
- secret_access_key: SECRET_ACCESS_KEY
- endpoint: https://s3.flashblade.example.com
Keep this "flashblade" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

This results in the following configuration being stored in ~/.config/rclone/rclone.conf:

[flashblade]
type = s3
provider = FlashBlade
access_key_id = ACCESS_KEY_ID
secret_access_key = SECRET_ACCESS_KEY
endpoint = https://s3.flashblade.example.com

Note: The FlashBlade endpoint should be the S3 data VIP. For virtual-hosted style requests, ensure proper DNS configuration: subdomains of the endpoint hostname should resolve to a FlashBlade data VIP. For example, if your endpoint is https://s3.flashblade.example.com, then bucket-name.s3.flashblade.example.com should also resolve to the data VIP.

Qiniu Cloud Object Storage (Kodo)

Qiniu Cloud Object Storage (Kodo), a completely independent-researched core technology which is proven by repeated customer experience has occupied absolute leading market leader position. Kodo can be widely applied to mass data management.

To configure access to Qiniu Kodo, follow the steps below:

  1. Run rclone config and select n for a new remote.
rclone config
No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
  1. Give the name of the configuration. For example, name it 'qiniu'.
name> qiniu
  1. Select s3 storage.
Choose a number from below, or type in your own value
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ (s3)
[snip]
Storage> s3
  1. Select Qiniu provider.
Choose a number from below, or type in your own value
1 / Amazon Web Services (AWS) S3
   \ "AWS"
[snip]
22 / Qiniu Object Storage (Kodo)
   \ (Qiniu)
[snip]
provider> Qiniu
  1. Enter your SecretId and SecretKey of Qiniu Kodo.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Enter a boolean value (true or false). Press Enter for the default ("false").
Choose a number from below, or type in your own value
 1 / Enter AWS credentials in the next step
   \ "false"
 2 / Get AWS credentials from the environment (env vars or IAM)
   \ "true"
env_auth> 1
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a string value. Press Enter for the default ("").
access_key_id> AKIDxxxxxxxxxx
AWS Secret Access Key (password)
Leave blank for anonymous access or runtime credentials.
Enter a string value. Press Enter for the default ("").
secret_access_key> xxxxxxxxxxx
  1. Select endpoint for Qiniu Kodo. This is the standard endpoint for different region.
   / The default endpoint - a good choice if you are unsure.
 1 | East China Region 1.
   | Needs location constraint cn-east-1.
   \ (cn-east-1)
   / East China Region 2.
 2 | Needs location constraint cn-east-2.
   \ (cn-east-2)
   / North China Region 1.
 3 | Needs location constraint cn-north-1.
   \ (cn-north-1)
   / South China Region 1.
 4 | Needs location constraint cn-south-1.
   \ (cn-south-1)
   / North America Region.
 5 | Needs location constraint us-north-1.
   \ (us-north-1)
   / Southeast Asia Region 1.
 6 | Needs location constraint ap-southeast-1.
   \ (ap-southeast-1)
   / Northeast Asia Region 1.
 7 | Needs location constraint ap-northeast-1.
   \ (ap-northeast-1)
[snip]
endpoint> 1

Option endpoint.
Endpoint for Qiniu Object Storage.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / East China Endpoint 1
   \ (s3-cn-east-1.qiniucs.com)
 2 / East China Endpoint 2
   \ (s3-cn-east-2.qiniucs.com)
 3 / North China Endpoint 1
   \ (s3-cn-north-1.qiniucs.com)
 4 / South China Endpoint 1
   \ (s3-cn-south-1.qiniucs.com)
 5 / North America Endpoint 1
   \ (s3-us-north-1.qiniucs.com)
 6 / Southeast Asia Endpoint 1
   \ (s3-ap-southeast-1.qiniucs.com)
 7 / Northeast Asia Endpoint 1
   \ (s3-ap-northeast-1.qiniucs.com)
endpoint> 1

Option location_constraint.
Location constraint - must be set to match the Region.
Used when creating buckets only.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / East China Region 1
   \ (cn-east-1)
 2 / East China Region 2
   \ (cn-east-2)
 3 / North China Region 1
   \ (cn-north-1)
 4 / South China Region 1
   \ (cn-south-1)
 5 / North America Region 1
   \ (us-north-1)
 6 / Southeast Asia Region 1
   \ (ap-southeast-1)
 7 / Northeast Asia Region 1
   \ (ap-northeast-1)
location_constraint> 1
  1. Choose acl and storage class.
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
   / Owner gets FULL_CONTROL.
 1 | No one else has access rights (default).
   \ (private)
   / Owner gets FULL_CONTROL.
 2 | The AllUsers group gets READ access.
   \ (public-read)
[snip]
acl> 2
The storage class to use when storing new objects in Tencent COS.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / Standard storage class
   \ (STANDARD)
 2 / Infrequent access storage mode
   \ (LINE)
 3 / Archive storage mode
   \ (GLACIER)
 4 / Deep archive storage mode
   \ (DEEP_ARCHIVE)
[snip]
storage_class> 1
Edit advanced config? (y/n)
y) Yes
n) No (default)
y/n> n
Remote config
--------------------
[qiniu]
- type: s3
- provider: Qiniu
- access_key_id: xxx
- secret_access_key: xxx
- region: cn-east-1
- endpoint: s3-cn-east-1.qiniucs.com
- location_constraint: cn-east-1
- acl: public-read
- storage_class: STANDARD
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y
Current remotes:

Name                 Type
====                 ====
qiniu                s3

RackCorp

RackCorp Object Storage is an S3 compatible object storage platform from your friendly cloud provider RackCorp. The service is fast, reliable, well priced and located in many strategic locations unserviced by others, to ensure you can maintain data sovereignty.

Before you can use RackCorp Object Storage, you'll need to "sign up" for an account on our "portal". Next you can create an access key, a secret key and buckets, in your location of choice with ease. These details are required for the next steps of configuration, when rclone config asks for your access_key_id and secret_access_key.

Your config should end up looking a bit like this:

[RCS3-demo-config]
type = s3
provider = RackCorp
env_auth = true
access_key_id = YOURACCESSKEY
secret_access_key = YOURSECRETACCESSKEY
region = au-nsw
endpoint = s3.rackcorp.com
location_constraint = au-nsw

Rclone Serve S3

Rclone can serve any remote over the S3 protocol. For details see the rclone serve s3 documentation.

For example, to serve remote:path over s3, run the server like this:

rclone serve s3 --auth-key ACCESS_KEY_ID,SECRET_ACCESS_KEY remote:path

This will be compatible with an rclone remote which is defined like this:

[serves3]
type = s3
provider = Rclone
endpoint = http://127.0.0.1:8080/
access_key_id = ACCESS_KEY_ID
secret_access_key = SECRET_ACCESS_KEY
use_multipart_uploads = false

Note that setting use_multipart_uploads = false is to work around a bug which will be fixed in due course.

Scaleway

Scaleway The Object Storage platform allows you to store anything from backups, logs and web assets to documents and photos. Files can be dropped from the Scaleway console or transferred through our API and CLI or using any S3-compatible tool.

Scaleway provides an S3 interface which can be configured for use with rclone like this:

[scaleway]
type = s3
provider = Scaleway
env_auth = false
endpoint = s3.nl-ams.scw.cloud
access_key_id = SCWXXXXXXXXXXXXXX
secret_access_key = 1111111-2222-3333-44444-55555555555555
region = nl-ams
location_constraint = nl-ams
acl = private
upload_cutoff = 5M
chunk_size = 5M
copy_cutoff = 5M

Scaleway Glacier is the low-cost S3 Glacier alternative from Scaleway and it works the same way as on S3 by accepting the "GLACIER" storage_class. So you can configure your remote with the storage_class = GLACIER option to upload directly to Scaleway Glacier. Don't forget that in this state you can't read files back after, you will need to restore them to "STANDARD" storage_class first before being able to read them (see "restore" section above)

Seagate Lyve Cloud

Seagate Lyve Cloud is an S3 compatible object storage platform from Seagate intended for enterprise use.

Here is a config run through for a remote called remote - you may choose a different name of course. Note that to create an access key and secret key you will need to create a service account first.

$ rclone config
No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote

Choose s3 backend

Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ (s3)
[snip]
Storage> s3

Choose LyveCloud as S3 provider

Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
[snip]
XX / Seagate Lyve Cloud
   \ (LyveCloud)
[snip]
provider> LyveCloud

Take the default (just press enter) to enter access key and secret in the config file.

Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth>
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> XXX
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> YYY

Leave region blank

Region to connect to.
Leave blank if you are using an S3 clone and you don't have a region.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
   / Use this if unsure.
 1 | Will use v4 signatures and an empty region.
   \ ()
   / Use this only if v4 signatures don't work.
 2 | E.g. pre Jewel/v10 CEPH.
   \ (other-v2-signature)
region>

Enter your Lyve Cloud endpoint. This field cannot be kept empty.

Endpoint for Lyve Cloud S3 API.
Required when using an S3 clone.
Please type in your LyveCloud endpoint.
Examples:
- s3.us-west-1.{account_name}.lyve.seagate.com (US West 1 - California)
- s3.eu-west-1.{account_name}.lyve.seagate.com (US West 1 - Ireland)
Enter a value.
endpoint> s3.us-west-1.global.lyve.seagate.com

Leave location constraint blank

Location constraint - must be set to match the Region.
Leave blank if not sure. Used when creating buckets only.
Enter a value. Press Enter to leave empty.
location_constraint>

Choose default ACL (private).

Canned ACL used when creating buckets and storing or copying objects.
This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
   / Owner gets FULL_CONTROL.
 1 | No one else has access rights (default).
   \ (private)
[snip]
acl>

And the config file should end up looking like this:

[remote]
type = s3
provider = LyveCloud
access_key_id = XXX
secret_access_key = YYY
endpoint = s3.us-east-1.lyvecloud.seagate.com

SeaweedFS

SeaweedFS is a distributed storage system for blobs, objects, files, and data lake, with O(1) disk seek and a scalable file metadata store. It has an S3 compatible object storage interface. SeaweedFS can also act as a gateway to remote S3 compatible object store to cache data and metadata with asynchronous write back, for fast local speed and minimize access cost.

Assuming the SeaweedFS are configured with weed shell as such:

> s3.bucket.create -name foo
> s3.configure -access_key=any -secret_key=any -buckets=foo -user=me -actions=Read,Write,List,Tagging,Admin -apply
{
  "identities": [
    {
      "name": "me",
      "credentials": [
        {
          "accessKey": "any",
          "secretKey": "any"
        }
      ],
      "actions": [
        "Read:foo",
        "Write:foo",
        "List:foo",
        "Tagging:foo",
        "Admin:foo"
      ]
    }
  ]
}

To use rclone with SeaweedFS, above configuration should end up with something like this in your config:

[seaweedfs_s3]
type = s3
provider = SeaweedFS
access_key_id = any
secret_access_key = any
endpoint = localhost:8333

So once set up, for example to copy files into a bucket

rclone copy /path/to/files seaweedfs_s3:foo

Selectel

Selectel Cloud Storage is an S3 compatible storage system which features triple redundancy storage, automatic scaling, high availability and a comprehensive IAM system.

Selectel have a section on their website for configuring rclone which shows how to make the right API keys.

From rclone v1.69 Selectel is a supported operator - please choose the Selectel provider type.

Note that you should use "vHosted" access for the buckets (which is the recommended default), not "path style".

You can use rclone config to make a new provider like this

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter name for new remote.
name> selectel

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / Amazon S3 Compliant Storage Providers including ..., Selectel, ...
   \ (s3)
[snip]
Storage> s3

Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
[snip]
XX / Selectel Object Storage
   \ (Selectel)
[snip]
provider> Selectel

Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth> 1

Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> ACCESS_KEY

Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> SECRET_ACCESS_KEY

Option region.
Region where your data stored.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / St. Petersburg
   \ (ru-1)
region> 1

Option endpoint.
Endpoint for Selectel Object Storage.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Saint Petersburg
   \ (s3.ru-1.storage.selcloud.ru)
endpoint> 1

Edit advanced config?
y) Yes
n) No (default)
y/n> n

Configuration complete.
Options:
- type: s3
- provider: Selectel
- access_key_id: ACCESS_KEY
- secret_access_key: SECRET_ACCESS_KEY
- region: ru-1
- endpoint: s3.ru-1.storage.selcloud.ru
Keep this "selectel" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

And your config should end up looking like this:

[selectel]
type = s3
provider = Selectel
access_key_id = ACCESS_KEY
secret_access_key = SECRET_ACCESS_KEY
region = ru-1
endpoint = s3.ru-1.storage.selcloud.ru

Storj

Storj is a decentralized cloud storage which can be used through its native protocol or an S3 compatible gateway.

The S3 compatible gateway is configured using rclone config with a type of s3 and with a provider name of Storj. Here is an example run of the configurator.

Type of storage to configure.
Storage> s3
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth> 1
Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> XXXX (as shown when creating the access grant)
Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> XXXX (as shown when creating the access grant)
Option endpoint.
Endpoint of the Shared Gateway.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / EU1 Shared Gateway
   \ (gateway.eu1.storjshare.io)
 2 / US1 Shared Gateway
   \ (gateway.us1.storjshare.io)
 3 / Asia-Pacific Shared Gateway
   \ (gateway.ap1.storjshare.io)
endpoint> 1 (as shown when creating the access grant)
Edit advanced config?
y) Yes
n) No (default)
y/n> n

Note that s3 credentials are generated when you create an access grant.

Backend quirks

  • --chunk-size is forced to be 64 MiB or greater. This will use more memory than the default of 5 MiB.
  • Server side copy is disabled as it isn't currently supported in the gateway.
  • GetTier and SetTier are not supported.

Backend bugs

Due to issue #39 uploading multipart files via the S3 gateway causes them to lose their metadata. For rclone's purpose this means that the modification time is not stored, nor is any MD5SUM (if one is available from the source).

This has the following consequences:

  • Using rclone rcat will fail as the metadata doesn't match after upload
  • Uploading files with rclone mount will fail for the same reason
    • This can worked around by using --vfs-cache-mode writes or --vfs-cache-mode full or setting --s3-upload-cutoff large
  • Files uploaded via a multipart upload won't have their modtimes
    • This will mean that rclone sync will likely keep trying to upload files bigger than --s3-upload-cutoff
    • This can be worked around with --checksum or --size-only or setting --s3-upload-cutoff large
    • The maximum value for --s3-upload-cutoff is 5GiB though

One general purpose workaround is to set --s3-upload-cutoff 5G. This means that rclone will upload files smaller than 5GiB as single parts. Note that this can be set in the config file with upload_cutoff = 5G or configured in the advanced settings. If you regularly transfer files larger than 5G then using --checksum or --size-only in rclone sync is the recommended workaround.

Comparison with the native protocol

Use the the native protocol to take advantage of client-side encryption as well as to achieve the best possible download performance. Uploads will be erasure-coded locally, thus a 1gb upload will result in 2.68gb of data being uploaded to storage nodes across the network.

Use this backend and the S3 compatible Hosted Gateway to increase upload performance and reduce the load on your systems and network. Uploads will be encrypted and erasure-coded server-side, thus a 1GB upload will result in only in 1GB of data being uploaded to storage nodes across the network.

For more detailed comparison please check the documentation of the storj backend.

Synology C2 Object Storage

Synology C2 Object Storage provides a secure, S3-compatible, and cost-effective cloud storage solution without API request, download fees, and deletion penalty.

The S3 compatible gateway is configured using rclone config with a type of s3 and with a provider name of Synology. Here is an example run of the configurator.

First run:

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config

n/s/q> n

Enter name for new remote.1
name> syno

Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value

XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ "s3"

Storage> s3

Choose your S3 provider.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 24 / Synology C2 Object Storage
   \ (Synology)

provider> Synology

Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Enter a boolean value (true or false). Press Enter for the default ("false").
Choose a number from below, or type in your own value
 1 / Enter AWS credentials in the next step
   \ "false"
 2 / Get AWS credentials from the environment (env vars or IAM)
   \ "true"

env_auth> 1

AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a string value. Press Enter for the default ("").

access_key_id> accesskeyid

AWS Secret Access Key (password)
Leave blank for anonymous access or runtime credentials.
Enter a string value. Press Enter for the default ("").

secret_access_key> secretaccesskey

Region where your data stored.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Europe Region 1
   \ (eu-001)
 2 / Europe Region 2
   \ (eu-002)
 3 / US Region 1
   \ (us-001)
 4 / US Region 2
   \ (us-002)
 5 / Asia (Taiwan)
   \ (tw-001)

region > 1

Option endpoint.
Endpoint for Synology C2 Object Storage API.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / EU Endpoint 1
   \ (eu-001.s3.synologyc2.net)
 2 / US Endpoint 1
   \ (us-001.s3.synologyc2.net)
 3 / TW Endpoint 1
   \ (tw-001.s3.synologyc2.net)

endpoint> 1

Option location_constraint.
Location constraint - must be set to match the Region.
Leave blank if not sure. Used when creating buckets only.
Enter a value. Press Enter to leave empty.
location_constraint>

Edit advanced config? (y/n)
y) Yes
n) No
y/n> y

Option no_check_bucket.
If set, don't attempt to check the bucket exists or create it.
This can be useful when trying to minimise the number of transactions
rclone does if you know the bucket exists already.
It can also be needed if the user you are using does not have bucket
creation permissions. Before v1.52.0 this would have passed silently
due to a bug.
Enter a boolean value (true or false). Press Enter for the default (true).

no_check_bucket> true

Configuration complete.
Options:
- type: s3
- provider: Synology
- region: eu-001
- endpoint: eu-001.s3.synologyc2.net
- no_check_bucket: true
Keep this "syno" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote

y/e/d> y

Tencent COS

Tencent Cloud Object Storage (COS) is a distributed storage service offered by Tencent Cloud for unstructured data. It is secure, stable, massive, convenient, low-delay and low-cost.

To configure access to Tencent COS, follow the steps below:

  1. Run rclone config and select n for a new remote.
rclone config
No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
  1. Give the name of the configuration. For example, name it 'cos'.
name> cos
  1. Select s3 storage.
Choose a number from below, or type in your own value
[snip]
XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ "s3"
[snip]
Storage> s3
  1. Select TencentCOS provider.
Choose a number from below, or type in your own value
1 / Amazon Web Services (AWS) S3
   \ "AWS"
[snip]
11 / Tencent Cloud Object Storage (COS)
   \ "TencentCOS"
[snip]
provider> TencentCOS
  1. Enter your SecretId and SecretKey of Tencent Cloud.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Enter a boolean value (true or false). Press Enter for the default ("false").
Choose a number from below, or type in your own value
 1 / Enter AWS credentials in the next step
   \ "false"
 2 / Get AWS credentials from the environment (env vars or IAM)
   \ "true"
env_auth> 1
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a string value. Press Enter for the default ("").
access_key_id> AKIDxxxxxxxxxx
AWS Secret Access Key (password)
Leave blank for anonymous access or runtime credentials.
Enter a string value. Press Enter for the default ("").
secret_access_key> xxxxxxxxxxx
  1. Select endpoint for Tencent COS. This is the standard endpoint for different region.
 1 / Beijing Region.
   \ "cos.ap-beijing.myqcloud.com"
 2 / Nanjing Region.
   \ "cos.ap-nanjing.myqcloud.com"
 3 / Shanghai Region.
   \ "cos.ap-shanghai.myqcloud.com"
 4 / Guangzhou Region.
   \ "cos.ap-guangzhou.myqcloud.com"
[snip]
endpoint> 4
  1. Choose acl and storage class.
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / Owner gets Full_CONTROL. No one else has access rights (default).
   \ "default"
[snip]
acl> 1
The storage class to use when storing new objects in Tencent COS.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / Default
   \ ""
[snip]
storage_class> 1
Edit advanced config? (y/n)
y) Yes
n) No (default)
y/n> n
Remote config
--------------------
[cos]
type = s3
provider = TencentCOS
env_auth = false
access_key_id = xxx
secret_access_key = xxx
endpoint = cos.ap-guangzhou.myqcloud.com
acl = default
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y
Current remotes:

Name                 Type
====                 ====
cos                  s3

Wasabi

Wasabi is a cloud-based object storage service for a broad range of applications and use cases. Wasabi is designed for individuals and organizations that require a high-performance, reliable, and secure data storage infrastructure at minimal cost.

Wasabi provides an S3 interface which can be configured for use with rclone like this.

No remotes found, make a new one?
n) New remote
s) Set configuration password
n/s> n
name> wasabi
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Amazon S3 (also Dreamhost, Ceph, ChinaMobile, ArvanCloud, Minio, Liara)
   \ "s3"
[snip]
Storage> s3
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own value
 1 / Enter AWS credentials in the next step
   \ "false"
 2 / Get AWS credentials from the environment (env vars or IAM)
   \ "true"
env_auth> 1
AWS Access Key ID - leave blank for anonymous access or runtime credentials.
access_key_id> YOURACCESSKEY
AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials.
secret_access_key> YOURSECRETACCESSKEY
Region to connect to.
Choose a number from below, or type in your own value
   / The default endpoint - a good choice if you are unsure.
 1 | US Region, Northern Virginia, or Pacific Northwest.
   | Leave location constraint empty.
   \ "us-east-1"
[snip]
region> us-east-1
Endpoint for S3 API.
Leave blank if using AWS to use the default endpoint for the region.
Specify if using an S3 clone such as Ceph.
endpoint> s3.wasabisys.com
Location constraint - must be set to match the Region. Used when creating buckets only.
Choose a number from below, or type in your own value
 1 / Empty for US Region, Northern Virginia, or Pacific Northwest.
   \ ""
[snip]
location_constraint>
Canned ACL used when creating buckets and/or storing objects in S3.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Choose a number from below, or type in your own value
 1 / Owner gets FULL_CONTROL. No one else has access rights (default).
   \ "private"
[snip]
acl>
The server-side encryption algorithm used when storing this object in S3.
Choose a number from below, or type in your own value
 1 / None
   \ ""
 2 / AES256
   \ "AES256"
server_side_encryption>
The storage class to use when storing objects in S3.
Choose a number from below, or type in your own value
 1 / Default
   \ ""
 2 / Standard storage class
   \ "STANDARD"
 3 / Reduced redundancy storage class
   \ "REDUCED_REDUNDANCY"
 4 / Standard Infrequent Access storage class
   \ "STANDARD_IA"
storage_class>
Remote config
--------------------
[wasabi]
env_auth = false
access_key_id = YOURACCESSKEY
secret_access_key = YOURSECRETACCESSKEY
region = us-east-1
endpoint = s3.wasabisys.com
location_constraint =
acl =
server_side_encryption =
storage_class =
--------------------
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

This will leave the config file looking like this.

[wasabi]
type = s3
provider = Wasabi
env_auth = false
access_key_id = YOURACCESSKEY
secret_access_key = YOURSECRETACCESSKEY
region =
endpoint = s3.wasabisys.com
location_constraint =
acl =
server_side_encryption =
storage_class =

Zata Object Storage

Zata Object Storage provides a secure, S3-compatible cloud storage solution designed for scalability and performance, ideal for a variety of data storage needs.

First run:

rclone config
This will guide you through an interactive setup process:

e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> n

Enter name for new remote.
name> my zata storage 

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
 
XX / Amazon S3 Compliant Storage Providers including AWS, ...
   \ (s3)
 
Storage> s3

Option provider.
Choose your S3 provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 
XX / Zata (S3 compatible Gateway)
   \ (Zata)

provider> Zata

Option env_auth.
Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars).
Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own boolean value (true or false).
Press Enter for the default (false).
 1 / Enter AWS credentials in the next step.
   \ (false)
 2 / Get AWS credentials from the environment (env vars or IAM).
   \ (true)
env_auth>

Option access_key_id.
AWS Access Key ID.
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
access_key_id> "your key"

Option secret_access_key.
AWS Secret Access Key (password).
Leave blank for anonymous access or runtime credentials.
Enter a value. Press Enter to leave empty.
secret_access_key> "your secret key"

Option region.
Region where you can connect with.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Indore, Madhya Pradesh, India
   \ (us-east-1)
region> 1

Option endpoint.
Endpoint for Zata Object Storage.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / South Asia Endpoint
   \ (idr01.zata.ai)
endpoint> 1

Option location_constraint.
Location constraint - must be set to match the Region.
Leave blank if not sure. Used when creating buckets only.
Enter a value. Press Enter to leave empty.
location_constraint>

Option acl.
Canned ACL used when creating buckets and storing or copying objects.
This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too.
For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl
Note that this ACL is applied when server-side copying objects as S3
doesn't copy the ACL from the source but rather writes a fresh one.
If the acl is an empty string then no X-Amz-Acl: header is added and
the default (private) will be used.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
   / Owner gets FULL_CONTROL.
 1 | No one else has access rights (default).
   \ (private)
   / Owner gets FULL_CONTROL.
 2 | The AllUsers group gets READ access.
   \ (public-read)
   / Owner gets FULL_CONTROL.
 3 | The AllUsers group gets READ and WRITE access.
   | Granting this on a bucket is generally not recommended.
   \ (public-read-write)
   / Owner gets FULL_CONTROL.
 4 | The AuthenticatedUsers group gets READ access.
   \ (authenticated-read)
   / Object owner gets FULL_CONTROL.
 5 | Bucket owner gets READ access.
   | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it.
   \ (bucket-owner-read)
   / Both the object owner and the bucket owner get FULL_CONTROL over the object.
 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it.
   \ (bucket-owner-full-control)
acl>

Edit advanced config?
y) Yes
n) No (default)
y/n>

Configuration complete.
Options:
- type: s3
- provider: Zata
- access_key_id: xxx
- secret_access_key: xxx
- region: us-east-1
- endpoint: idr01.zata.ai
Keep this "my zata storage" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d>

This will leave the config file looking like this.

[my zata storage]
type = s3
provider = Zata
access_key_id = xxx
secret_access_key = xxx
region = us-east-1
endpoint = idr01.zata.ai

Memory usage

The most common cause of rclone using lots of memory is a single directory with millions of files in. Despite s3 not really having the concepts of directories, rclone does the sync on a directory by directory basis to be compatible with normal filing systems.

Rclone loads each directory into memory as rclone objects. Each rclone object takes 0.5k-1k of memory, so approximately 1GB per 1,000,000 files, and the sync for that directory does not begin until it is entirely loaded in memory. So the sync can take a long time to start for large directories.

To sync a directory with 100,000,000 files in you would need approximately 100 GB of memory. At some point the amount of memory becomes difficult to provide so there is a workaround for this which involves a bit of scripting.

At some point rclone will gain a sync mode which is effectively this workaround but built in to rclone.

Limitations

rclone about is not supported by the S3 backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

Backblaze B2

B2 is Backblaze's cloud storage system.

Paths are specified as remote:bucket (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:bucket/path/to/dir.

Configuration

Here is an example of making a b2 configuration. First run

rclone config

This will guide you through an interactive setup process. To authenticate you will either need your Account ID (a short hex number) and Master Application Key (a long hex number) OR an Application Key, which is the recommended method. See below for further details on generating and using an Application Key.

No remotes found, make a new one?
n) New remote
q) Quit config
n/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Backblaze B2
   \ "b2"
[snip]
Storage> b2
Account ID or Application Key ID
account> 123456789abc
Application Key
key> 0123456789abcdef0123456789abcdef0123456789
Endpoint for the service - leave blank normally.
endpoint>
Remote config
Configuration complete.
Options:
- type: b2
- account: 123456789abc
- key: 0123456789abcdef0123456789abcdef0123456789
- endpoint:
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

This remote is called remote and can now be used like this

See all buckets

rclone lsd remote:

Create a new bucket

rclone mkdir remote:bucket

List the contents of a bucket

rclone ls remote:bucket

Sync /home/local/directory to the remote bucket, deleting any excess files in the bucket.

rclone sync --interactive /home/local/directory remote:bucket

Application Keys

B2 supports multiple Application Keys for different access permission to B2 Buckets.

You can use these with rclone too; you will need to use rclone version 1.43 or later.

Follow Backblaze's docs to create an Application Key with the required permission and add the applicationKeyId as the account and the Application Key itself as the key.

Note that you must put the applicationKeyId as the account – you can't use the master Account ID. If you try then B2 will return 401 errors.

--fast-list

This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details.

Modification times

The modification time is stored as metadata on the object as X-Bz-Info-src_last_modified_millis as milliseconds since 1970-01-01 in the Backblaze standard. Other tools should be able to use this as a modified time.

Modified times are used in syncing and are fully supported. Note that if a modification time needs to be updated on an object then it will create a new version of the object.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
\ 0x5C ＼

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Note that in 2020-05 Backblaze started allowing  characters in file names. Rclone hasn't changed its encoding as this could cause syncs to re-transfer files. If you want rclone not to replace  then see the --b2-encoding flag below and remove the BackSlash from the string. This can be set in the config.

SHA1 checksums

The SHA1 checksums of the files are checked on upload and download and will be used in the syncing process.

Large files (bigger than the limit in --b2-upload-cutoff) which are uploaded in chunks will store their SHA1 on the object as X-Bz-Info-large_file_sha1 as recommended by Backblaze.

For a large file to be uploaded with an SHA1 checksum, the source needs to support SHA1 checksums. The local disk supports SHA1 checksums so large file transfers from local disk will have an SHA1. See the overview for exactly which remotes support SHA1.

Sources which don't support SHA1, in particular crypt will upload large files without SHA1 checksums. This may be fixed in the future (see #1767).

Files sizes below --b2-upload-cutoff will always have an SHA1 regardless of the source.

Transfers

Backblaze recommends that you do lots of transfers simultaneously for maximum speed. In tests from my SSD equipped laptop the optimum setting is about --transfers 32 though higher numbers may be used for a slight speed improvement. The optimum number for you may vary depending on your hardware, how big the files are, how much you want to load your computer, etc. The default of --transfers 4 is definitely too low for Backblaze B2 though.

Note that uploading big files (bigger than 200 MiB by default) will use a 96 MiB RAM buffer by default. There can be at most --transfers of these in use at any moment, so this sets the upper limit on the memory used.

Versions

The default setting of B2 is to keep old versions of files. This means when rclone uploads a new version of a file it creates a new version of it. Likewise when you delete a file, the old version will be marked hidden and still be available.

Whether B2 keeps old versions of files or not can be adjusted on a per bucket basis using the "Lifecycle settings" on the B2 control panel or when creating the bucket using the --b2-lifecycle flag or after creation using the rclone backend lifecycle command.

You may opt in to a "hard delete" of files with the --b2-hard-delete flag which permanently removes files on deletion instead of hiding them.

Old versions of files, where available, are visible using the --b2-versions flag.

It is also possible to view a bucket as it was at a certain point in time, using the --b2-version-at flag. This will show the file versions as they were at that time, showing files that have been deleted afterwards, and hiding files that were created since.

If you wish to remove all the old versions, and unfinished large file uploads, then you can use the rclone cleanup remote:bucket command which will delete all the old versions of files, leaving the current ones intact. You can also supply a path and only old versions under that path will be deleted, e.g. rclone cleanup remote:bucket/path/to/stuff.

Note that cleanup will remove partially uploaded files from the bucket if they are more than a day old. If you want more control over the expiry date then run rclone backend cleanup b2:bucket -o max-age=1h to remove all unfinished large file uploads older than one hour, leaving old versions intact.

If you wish to remove all the old versions, leaving current files and unfinished large files intact, then you can use the rclone backend cleanup-hidden remote:bucket command. You can also supply a path and only old versions under that path will be deleted, e.g. rclone backend cleanup-hidden remote:bucket/path/to/stuff.

When you purge a bucket, the current and the old versions will be deleted then the bucket will be deleted.

However delete will cause the current versions of the files to become hidden old versions.

Here is a session showing the listing and retrieval of an old version followed by a cleanup of the old versions.

Show current version and all the versions with --b2-versions flag.

$ rclone -q ls b2:cleanup-test
        9 one.txt

$ rclone -q --b2-versions ls b2:cleanup-test
        9 one.txt
        8 one-v2016-07-04-141032-000.txt
       16 one-v2016-07-04-141003-000.txt
       15 one-v2016-07-02-155621-000.txt

Retrieve an old version

$ rclone -q --b2-versions copy b2:cleanup-test/one-v2016-07-04-141003-000.txt /tmp

$ ls -l /tmp/one-v2016-07-04-141003-000.txt
-rw-rw-r-- 1 ncw ncw 16 Jul  2 17:46 /tmp/one-v2016-07-04-141003-000.txt

Clean up all the old versions and show that they've gone.

$ rclone -q cleanup b2:cleanup-test

$ rclone -q ls b2:cleanup-test
        9 one.txt

$ rclone -q --b2-versions ls b2:cleanup-test
        9 one.txt

Versions naming caveat

When using --b2-versions flag rclone is relying on the file name to work out whether the objects are versions or not. Versions' names are created by inserting timestamp between file name and its extension.

        9 file.txt
        8 file-v2023-07-17-161032-000.txt
       16 file-v2023-06-15-141003-000.txt

If there are real files present with the same names as versions, then behaviour of --b2-versions can be unpredictable.

Data usage

It is useful to know how many requests are sent to the server in different scenarios.

All copy commands send the following 4 requests:

/b2api/v1/b2_authorize_account
/b2api/v1/b2_create_bucket
/b2api/v1/b2_list_buckets
/b2api/v1/b2_list_file_names

The b2_list_file_names request will be sent once for every 1k files in the remote path, providing the checksum and modification time of the listed files. As of version 1.33 issue #818 causes extra requests to be sent when using B2 with Crypt. When a copy operation does not require any files to be uploaded, no more requests will be sent.

Uploading files that do not require chunking, will send 2 requests per file upload:

/b2api/v1/b2_get_upload_url
/b2api/v1/b2_upload_file/

Uploading files requiring chunking, will send 2 requests (one each to start and finish the upload) and another 2 requests for each chunk:

/b2api/v1/b2_start_large_file
/b2api/v1/b2_get_upload_part_url
/b2api/v1/b2_upload_part/
/b2api/v1/b2_finish_large_file

Versions

Versions can be viewed with the --b2-versions flag. When it is set rclone will show and act on older versions of files. For example

Listing without --b2-versions

$ rclone -q ls b2:cleanup-test
        9 one.txt

And with

$ rclone -q --b2-versions ls b2:cleanup-test
        9 one.txt
        8 one-v2016-07-04-141032-000.txt
       16 one-v2016-07-04-141003-000.txt
       15 one-v2016-07-02-155621-000.txt

Showing that the current version is unchanged but older versions can be seen. These have the UTC date that they were uploaded to the server to the nearest millisecond appended to them.

Note that when using --b2-versions no file write operations are permitted, so you can't upload files or delete them.

Rclone supports generating file share links for private B2 buckets. They can either be for a file for example:

./rclone link B2:bucket/path/to/file.txt
https://f002.backblazeb2.com/file/bucket/path/to/file.txt?Authorization=xxxxxxxx

or if run on a directory you will get:

./rclone link B2:bucket/path
https://f002.backblazeb2.com/file/bucket/path?Authorization=xxxxxxxx

you can then use the authorization token (the part of the url from the ?Authorization= on) on any file path under that directory. For example:

https://f002.backblazeb2.com/file/bucket/path/to/file1?Authorization=xxxxxxxx
https://f002.backblazeb2.com/file/bucket/path/file2?Authorization=xxxxxxxx
https://f002.backblazeb2.com/file/bucket/path/folder/file3?Authorization=xxxxxxxx

Standard options

Here are the Standard options specific to b2 (Backblaze B2).

--b2-account

Account ID or Application Key ID.

Properties:

  • Config: account
  • Env Var: RCLONE_B2_ACCOUNT
  • Type: string
  • Required: true

--b2-key

Application Key.

Properties:

  • Config: key
  • Env Var: RCLONE_B2_KEY
  • Type: string
  • Required: true

--b2-hard-delete

Permanently delete files on remote removal, otherwise hide files.

Properties:

  • Config: hard_delete
  • Env Var: RCLONE_B2_HARD_DELETE
  • Type: bool
  • Default: false

Advanced options

Here are the Advanced options specific to b2 (Backblaze B2).

--b2-endpoint

Endpoint for the service.

Leave blank normally.

Properties:

  • Config: endpoint
  • Env Var: RCLONE_B2_ENDPOINT
  • Type: string
  • Required: false

--b2-test-mode

A flag string for X-Bz-Test-Mode header for debugging.

This is for debugging purposes only. Setting it to one of the strings below will cause b2 to return specific errors:

  • "fail_some_uploads"
  • "expire_some_account_authorization_tokens"
  • "force_cap_exceeded"

These will be set in the "X-Bz-Test-Mode" header which is documented in the b2 integrations checklist.

Properties:

  • Config: test_mode
  • Env Var: RCLONE_B2_TEST_MODE
  • Type: string
  • Required: false

--b2-versions

Include old versions in directory listings.

Note that when using this no file write operations are permitted, so you can't upload files or delete them.

Properties:

  • Config: versions
  • Env Var: RCLONE_B2_VERSIONS
  • Type: bool
  • Default: false

--b2-version-at

Show file versions as they were at the specified time.

Note that when using this no file write operations are permitted, so you can't upload files or delete them.

Properties:

  • Config: version_at
  • Env Var: RCLONE_B2_VERSION_AT
  • Type: Time
  • Default: off

--b2-upload-cutoff

Cutoff for switching to chunked upload.

Files above this size will be uploaded in chunks of "--b2-chunk-size".

This value should be set no larger than 4.657 GiB (== 5 GB).

Properties:

  • Config: upload_cutoff
  • Env Var: RCLONE_B2_UPLOAD_CUTOFF
  • Type: SizeSuffix
  • Default: 200Mi

--b2-copy-cutoff

Cutoff for switching to multipart copy.

Any files larger than this that need to be server-side copied will be copied in chunks of this size.

The minimum is 0 and the maximum is 4.6 GiB.

Properties:

  • Config: copy_cutoff
  • Env Var: RCLONE_B2_COPY_CUTOFF
  • Type: SizeSuffix
  • Default: 4Gi

--b2-chunk-size

Upload chunk size.

When uploading large files, chunk the file into this size.

Must fit in memory. These chunks are buffered in memory and there might a maximum of "--transfers" chunks in progress at once.

5,000,000 Bytes is the minimum size.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_B2_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 96Mi

--b2-upload-concurrency

Concurrency for multipart uploads.

This is the number of chunks of the same file that are uploaded concurrently.

Note that chunks are stored in memory and there may be up to "--transfers" * "--b2-upload-concurrency" chunks stored at once in memory.

Properties:

  • Config: upload_concurrency
  • Env Var: RCLONE_B2_UPLOAD_CONCURRENCY
  • Type: int
  • Default: 4

--b2-disable-checksum

Disable checksums for large (> upload cutoff) files.

Normally rclone will calculate the SHA1 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading.

Properties:

  • Config: disable_checksum
  • Env Var: RCLONE_B2_DISABLE_CHECKSUM
  • Type: bool
  • Default: false

--b2-download-url

Custom endpoint for downloads.

This is usually set to a Cloudflare CDN URL as Backblaze offers free egress for data downloaded through the Cloudflare network. Rclone works with private buckets by sending an "Authorization" header. If the custom endpoint rewrites the requests for authentication, e.g., in Cloudflare Workers, this header needs to be handled properly. Leave blank if you want to use the endpoint provided by Backblaze.

The URL provided here SHOULD have the protocol and SHOULD NOT have a trailing slash or specify the /file/bucket subpath as rclone will request files with "{download_url}/file/{bucket_name}/{path}".

Example: > https://mysubdomain.mydomain.tld (No trailing "/", "file" or "bucket")

Properties:

  • Config: download_url
  • Env Var: RCLONE_B2_DOWNLOAD_URL
  • Type: string
  • Required: false

--b2-download-auth-duration

Time before the public link authorization token will expire in s or suffix ms|s|m|h|d.

This is used in combination with "rclone link" for making files accessible to the public and sets the duration before the download authorization token will expire.

The minimum value is 1 second. The maximum value is one week.

Properties:

  • Config: download_auth_duration
  • Env Var: RCLONE_B2_DOWNLOAD_AUTH_DURATION
  • Type: Duration
  • Default: 1w

--b2-memory-pool-flush-time

How often internal memory buffer pools will be flushed. (no longer used)

Properties:

  • Config: memory_pool_flush_time
  • Env Var: RCLONE_B2_MEMORY_POOL_FLUSH_TIME
  • Type: Duration
  • Default: 1m0s

--b2-memory-pool-use-mmap

Whether to use mmap buffers in internal memory pool. (no longer used)

Properties:

  • Config: memory_pool_use_mmap
  • Env Var: RCLONE_B2_MEMORY_POOL_USE_MMAP
  • Type: bool
  • Default: false

--b2-lifecycle

Set the number of days deleted files should be kept when creating a bucket.

On bucket creation, this parameter is used to create a lifecycle rule for the entire bucket.

If lifecycle is 0 (the default) it does not create a lifecycle rule so the default B2 behaviour applies. This is to create versions of files on delete and overwrite and to keep them indefinitely.

If lifecycle is >0 then it creates a single rule setting the number of days before a file that is deleted or overwritten is deleted permanently. This is known as daysFromHidingToDeleting in the b2 docs.

The minimum value for this parameter is 1 day.

You can also enable hard_delete in the config also which will mean deletions won't cause versions but overwrites will still cause versions to be made.

See: rclone backend lifecycle for setting lifecycles after bucket creation.

Properties:

  • Config: lifecycle
  • Env Var: RCLONE_B2_LIFECYCLE
  • Type: int
  • Default: 0

--b2-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_B2_ENCODING
  • Type: Encoding
  • Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot

--b2-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_B2_DESCRIPTION
  • Type: string
  • Required: false

Backend commands

Here are the commands specific to the b2 backend.

Run them with

rclone backend COMMAND remote:

The help below will explain what arguments each command takes.

See the backend command for more info on how to pass options and arguments.

These can be run on a running backend using the rc command backend/command.

lifecycle

Read or set the lifecycle for a bucket

rclone backend lifecycle remote: [options] [<arguments>+]

This command can be used to read or set the lifecycle for a bucket.

Usage Examples:

To show the current lifecycle rules:

rclone backend lifecycle b2:bucket

This will dump something like this showing the lifecycle rules.

[
    {
        "daysFromHidingToDeleting": 1,
        "daysFromUploadingToHiding": null,
        "daysFromStartingToCancelingUnfinishedLargeFiles": null,
        "fileNamePrefix": ""
    }
]

If there are no lifecycle rules (the default) then it will just return [].

To reset the current lifecycle rules:

rclone backend lifecycle b2:bucket -o daysFromHidingToDeleting=30
rclone backend lifecycle b2:bucket -o daysFromUploadingToHiding=5 -o daysFromHidingToDeleting=1

This will run and then print the new lifecycle rules as above.

Rclone only lets you set lifecycles for the whole bucket with the fileNamePrefix = "".

You can't disable versioning with B2. The best you can do is to set the daysFromHidingToDeleting to 1 day. You can enable hard_delete in the config also which will mean deletions won't cause versions but overwrites will still cause versions to be made.

rclone backend lifecycle b2:bucket -o daysFromHidingToDeleting=1

See: https://www.backblaze.com/docs/cloud-storage-lifecycle-rules

Options:

  • "daysFromHidingToDeleting": After a file has been hidden for this many days it is deleted. 0 is off.
  • "daysFromStartingToCancelingUnfinishedLargeFiles": Cancels any unfinished large file versions after this many days
  • "daysFromUploadingToHiding": This many days after uploading a file is hidden

cleanup

Remove unfinished large file uploads.

rclone backend cleanup remote: [options] [<arguments>+]

This command removes unfinished large file uploads of age greater than max-age, which defaults to 24 hours.

Note that you can use --interactive/-i or --dry-run with this command to see what it would do.

rclone backend cleanup b2:bucket/path/to/object
rclone backend cleanup -o max-age=7w b2:bucket/path/to/object

Durations are parsed as per the rest of rclone, 2h, 7d, 7w etc.

Options:

  • "max-age": Max age of upload to delete

cleanup-hidden

Remove old versions of files.

rclone backend cleanup-hidden remote: [options] [<arguments>+]

This command removes any old hidden versions of files.

Note that you can use --interactive/-i or --dry-run with this command to see what it would do.

rclone backend cleanup-hidden b2:bucket/path/to/dir

Limitations

rclone about is not supported by the B2 backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

Box

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

The initial setup for Box involves getting a token from Box which you can do either in your browser, or with a config.json downloaded from Box to use JWT authentication. rclone config walks you through it.

Configuration

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Box
   \ "box"
[snip]
Storage> box
Box App Client Id - leave blank normally.
client_id> 
Box App Client Secret - leave blank normally.
client_secret>
Box App config.json location
Leave blank normally.
Enter a string value. Press Enter for the default ("").
box_config_file>
Box App Primary Access Token
Leave blank normally.
Enter a string value. Press Enter for the default ("").
access_token>

Enter a string value. Press Enter for the default ("user").
Choose a number from below, or type in your own value
 1 / Rclone should act on behalf of a user
   \ "user"
 2 / Rclone should act on behalf of a service account
   \ "enterprise"
box_sub_type>
Remote config
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y) Yes
n) No
y/n> y
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth?state=XXXXXXXXXXXXXXXXXXXXXX
Log in and authorize rclone for access
Waiting for code...
Got code
Configuration complete.
Options:
- type: box
- client_id:
- client_secret:
- token: {"access_token":"XXX","token_type":"bearer","refresh_token":"XXX","expiry":"XXX"}
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

See the remote setup docs for how to set it up on a machine with no Internet browser available.

Note that rclone runs a webserver on your local machine to collect the token as returned from Box. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this may require you to unblock it temporarily if you are running a host firewall.

Once configured you can then use rclone like this,

List directories in top level of your Box

rclone lsd remote:

List all the files in your Box

rclone ls remote:

To copy a local directory to an Box directory called backup

rclone copy /home/source remote:backup

Using rclone with an Enterprise account with SSO

If you have an "Enterprise" account type with Box with single sign on (SSO), you need to create a password to use Box with rclone. This can be done at your Enterprise Box account by going to Settings, "Account" Tab, and then set the password in the "Authentication" field.

Once you have done this, you can setup your Enterprise Box account using the same procedure detailed above in the, using the password you have just set.

Invalid refresh token

According to the box docs:

Each refresh_token is valid for one use in 60 days.

This means that if you

  • Don't use the box remote for 60 days
  • Copy the config file with a box refresh token in and use it in two places
  • Get an error on a token refresh

then rclone will return an error which includes the text Invalid refresh token.

To fix this you will need to use oauth2 again to update the refresh token. You can use the methods in the remote setup docs, bearing in mind that if you use the copy the config file method, you should not use that remote on the computer you did the authentication on.

Here is how to do it.

$ rclone config
Current remotes:

Name                 Type
====                 ====
remote               box

e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> e
Choose a number from below, or type in an existing value
 1 > remote
remote> remote
Configuration complete.
Options:
- type: box
- token: {"access_token":"XXX","token_type":"bearer","refresh_token":"XXX","expiry":"2017-07-08T23:40:08.059167677+01:00"}
Keep this "remote" remote?
Edit remote
Value "client_id" = ""
Edit? (y/n)>
y) Yes
n) No
y/n> n
Value "client_secret" = ""
Edit? (y/n)>
y) Yes
n) No
y/n> n
Remote config
Already have a token - refresh?
y) Yes
n) No
y/n> y
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y) Yes
n) No
y/n> y
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth
Log in and authorize rclone for access
Waiting for code...
Got code
Configuration complete.
Options:
- type: box
- token: {"access_token":"YYY","token_type":"bearer","refresh_token":"YYY","expiry":"2017-07-23T12:22:29.259137901+01:00"}
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

Modification times and hashes

Box allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not.

Box supports SHA1 type hashes, so you can use the --checksum flag.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
\ 0x5C ＼

File names can also not end with the following characters. These only get replaced if they are the last character in the name:

Character Value Replacement
SP 0x20 ␠

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Transfers

For files above 50 MiB rclone will use a chunked transfer. Rclone will upload up to --transfers chunks at the same time (shared among all the multipart uploads). Chunks are buffered in memory and are normally 8 MiB so increasing --transfers will increase memory use.

Deleting files

Depending on the enterprise settings for your user, the item will either be actually deleted from Box or moved to the trash.

Emptying the trash is supported via the rclone however cleanup command however this deletes every trashed file and folder individually so it may take a very long time. Emptying the trash via the WebUI does not have this limitation so it is advised to empty the trash via the WebUI.

Root folder ID

You can set the root_folder_id for rclone. This is the directory (identified by its Folder ID) that rclone considers to be the root of your Box drive.

Normally you will leave this blank and rclone will determine the correct root to use itself.

However you can set this to restrict rclone to a specific folder hierarchy.

In order to do this you will have to find the Folder ID of the directory you wish rclone to display. This will be the last segment of the URL when you open the relevant folder in the Box web interface.

So if the folder you want rclone to use has a URL which looks like https://app.box.com/folder/11xxxxxxxxx8 in the browser, then you use 11xxxxxxxxx8 as the root_folder_id in the config.

Standard options

Here are the Standard options specific to box (Box).

--box-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_BOX_CLIENT_ID
  • Type: string
  • Required: false

--box-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_BOX_CLIENT_SECRET
  • Type: string
  • Required: false

--box-box-config-file

Box App config.json location

Leave blank normally.

Leading ~ will be expanded in the file name as will environment variables such as ${RCLONE_CONFIG_DIR}.

Properties:

  • Config: box_config_file
  • Env Var: RCLONE_BOX_BOX_CONFIG_FILE
  • Type: string
  • Required: false

--box-access-token

Box App Primary Access Token

Leave blank normally.

Properties:

  • Config: access_token
  • Env Var: RCLONE_BOX_ACCESS_TOKEN
  • Type: string
  • Required: false

--box-box-sub-type

Properties:

  • Config: box_sub_type
  • Env Var: RCLONE_BOX_BOX_SUB_TYPE
  • Type: string
  • Default: "user"
  • Examples:
    • "user"
      • Rclone should act on behalf of a user.
    • "enterprise"
      • Rclone should act on behalf of a service account.

Advanced options

Here are the Advanced options specific to box (Box).

--box-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_BOX_TOKEN
  • Type: string
  • Required: false

--box-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_BOX_AUTH_URL
  • Type: string
  • Required: false

--box-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_BOX_TOKEN_URL
  • Type: string
  • Required: false

--box-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_BOX_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--box-root-folder-id

Fill in for rclone to use a non root folder as its starting point.

Properties:

  • Config: root_folder_id
  • Env Var: RCLONE_BOX_ROOT_FOLDER_ID
  • Type: string
  • Default: "0"

--box-upload-cutoff

Cutoff for switching to multipart upload (>= 50 MiB).

Properties:

  • Config: upload_cutoff
  • Env Var: RCLONE_BOX_UPLOAD_CUTOFF
  • Type: SizeSuffix
  • Default: 50Mi

--box-commit-retries

Max number of times to try committing a multipart file.

Properties:

  • Config: commit_retries
  • Env Var: RCLONE_BOX_COMMIT_RETRIES
  • Type: int
  • Default: 100

--box-list-chunk

Size of listing chunk 1-1000.

Properties:

  • Config: list_chunk
  • Env Var: RCLONE_BOX_LIST_CHUNK
  • Type: int
  • Default: 1000

--box-owned-by

Only show items owned by the login (email address) passed in.

Properties:

  • Config: owned_by
  • Env Var: RCLONE_BOX_OWNED_BY
  • Type: string
  • Required: false

--box-impersonate

Impersonate this user ID when using a service account.

Setting this flag allows rclone, when using a JWT service account, to act on behalf of another user by setting the as-user header.

The user ID is the Box identifier for a user. User IDs can found for any user via the GET /users endpoint, which is only available to admins, or by calling the GET /users/me endpoint with an authenticated user session.

See: https://developer.box.com/guides/authentication/jwt/as-user/

Properties:

  • Config: impersonate
  • Env Var: RCLONE_BOX_IMPERSONATE
  • Type: string
  • Required: false

--box-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_BOX_ENCODING
  • Type: Encoding
  • Default: Slash,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot

--box-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_BOX_DESCRIPTION
  • Type: string
  • Required: false

Limitations

Note that Box is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc".

Box file names can't have the \ character in. rclone maps this to and from an identical looking unicode equivalent ＼ (U+FF3C Fullwidth Reverse Solidus).

Box only supports filenames up to 255 characters in length.

Box has API rate limits that sometimes reduce the speed of rclone.

rclone about is not supported by the Box backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

Get your own Box App ID

Here is how to create your own Box App ID for rclone:

  1. Go to the Box Developer Console and login, then click My Apps on the sidebar. Click Create New App and select Custom App.

  2. In the first screen on the box that pops up, you can pretty much enter whatever you want. The App Name can be whatever. For Purpose choose automation to avoid having to fill out anything else. Click Next.

  3. In the second screen of the creation screen, select User Authentication (OAuth 2.0). Then click Create App.

  4. You should now be on the Configuration tab of your new app. If not, click on it at the top of the webpage. Copy down Client ID and Client Secret, you'll need those for rclone.

  5. Under "OAuth 2.0 Redirect URI", add http://127.0.0.1:53682/

  6. For Application Scopes, select Read all files and folders stored in Box and Write all files and folders stored in box (assuming you want to do both). Leave others unchecked. Click Save Changes at the top right.

Cache

The cache remote wraps another existing remote and stores file structure and its data for long running tasks like rclone mount.

Status

The cache backend code is working but it currently doesn't have a maintainer so there are outstanding bugs which aren't getting fixed.

The cache backend is due to be phased out in favour of the VFS caching layer eventually which is more tightly integrated into rclone.

Until this happens we recommend only using the cache backend if you find you can't work without it. There are many docs online describing the use of the cache backend to minimize API hits and by-and-large these are out of date and the cache backend isn't needed in those scenarios any more.

Configuration

To get started you just need to have an existing remote which can be configured with cache.

Here is an example of how to make a remote called test-cache. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
n/r/c/s/q> n
name> test-cache
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Cache a remote
   \ "cache"
[snip]
Storage> cache
Remote to cache.
Normally should contain a ':' and a path, e.g. "myremote:path/to/dir",
"myremote:bucket" or maybe "myremote:" (not recommended).
remote> local:/test
Optional: The URL of the Plex server
plex_url> http://127.0.0.1:32400
Optional: The username of the Plex user
plex_username> dummyusername
Optional: The password of the Plex user
y) Yes type in my own password
g) Generate random password
n) No leave this optional password blank
y/g/n> y
Enter the password:
password:
Confirm the password:
password:
The size of a chunk. Lower value good for slow connections but can affect seamless reading.
Default: 5M
Choose a number from below, or type in your own value
 1 / 1 MiB
   \ "1M"
 2 / 5 MiB
   \ "5M"
 3 / 10 MiB
   \ "10M"
chunk_size> 2
How much time should object info (file size, file hashes, etc.) be stored in cache. Use a very high value if you don't plan on changing the source FS from outside the cache.
Accepted units are: "s", "m", "h".
Default: 5m
Choose a number from below, or type in your own value
 1 / 1 hour
   \ "1h"
 2 / 24 hours
   \ "24h"
 3 / 24 hours
   \ "48h"
info_age> 2
The maximum size of stored chunks. When the storage grows beyond this size, the oldest chunks will be deleted.
Default: 10G
Choose a number from below, or type in your own value
 1 / 500 MiB
   \ "500M"
 2 / 1 GiB
   \ "1G"
 3 / 10 GiB
   \ "10G"
chunk_total_size> 3
Remote config
--------------------
[test-cache]
remote = local:/test
plex_url = http://127.0.0.1:32400
plex_username = dummyusername
plex_password = *** ENCRYPTED ***
chunk_size = 5M
info_age = 48h
chunk_total_size = 10G

You can then use it like this,

List directories in top level of your drive

rclone lsd test-cache:

List all the files in your drive

rclone ls test-cache:

To start a cached mount

rclone mount --allow-other test-cache: /var/tmp/test-cache

Write Features

Offline uploading

In an effort to make writing through cache more reliable, the backend now supports this feature which can be activated by specifying a cache-tmp-upload-path.

A files goes through these states when using this feature:

  1. An upload is started (usually by copying a file on the cache remote)
  2. When the copy to the temporary location is complete the file is part of the cached remote and looks and behaves like any other file (reading included)
  3. After cache-tmp-wait-time passes and the file is next in line, rclone move is used to move the file to the cloud provider
  4. Reading the file still works during the upload but most modifications on it will be prohibited
  5. Once the move is complete the file is unlocked for modifications as it becomes as any other regular file
  6. If the file is being read through cache when it's actually deleted from the temporary path then cache will simply swap the source to the cloud provider without interrupting the reading (small blip can happen though)

Files are uploaded in sequence and only one file is uploaded at a time. Uploads will be stored in a queue and be processed based on the order they were added. The queue and the temporary storage is persistent across restarts but can be cleared on startup with the --cache-db-purge flag.

Write Support

Writes are supported through cache. One caveat is that a mounted cache remote does not add any retry or fallback mechanism to the upload operation. This will depend on the implementation of the wrapped remote. Consider using Offline uploading for reliable writes.

One special case is covered with cache-writes which will cache the file data at the same time as the upload when it is enabled making it available from the cache store immediately once the upload is finished.

Read Features

Multiple connections

To counter the high latency between a local PC where rclone is running and cloud providers, the cache remote can split multiple requests to the cloud provider for smaller file chunks and combines them together locally where they can be available almost immediately before the reader usually needs them.

This is similar to buffering when media files are played online. Rclone will stay around the current marker but always try its best to stay ahead and prepare the data before.

Plex Integration

There is a direct integration with Plex which allows cache to detect during reading if the file is in playback or not. This helps cache to adapt how it queries the cloud provider depending on what is needed for.

Scans will have a minimum amount of workers (1) while in a confirmed playback cache will deploy the configured number of workers.

This integration opens the doorway to additional performance improvements which will be explored in the near future.

Note: If Plex options are not configured, cache will function with its configured options without adapting any of its settings.

How to enable? Run rclone config and add all the Plex options (endpoint, username and password) in your remote and it will be automatically enabled.

Affected settings: - cache-workers: Configured value during confirmed playback or 1 all the other times

Certificate Validation

When the Plex server is configured to only accept secure connections, it is possible to use .plex.direct URLs to ensure certificate validation succeeds. These URLs are used by Plex internally to connect to the Plex server securely.

The format for these URLs is the following:

https://ip-with-dots-replaced.server-hash.plex.direct:32400/

The ip-with-dots-replaced part can be any IPv4 address, where the dots have been replaced with dashes, e.g. 127.0.0.1 becomes 127-0-0-1.

To get the server-hash part, the easiest way is to visit

https://plex.tv/api/resources?includeHttps=1&X-Plex-Token=your-plex-token

This page will list all the available Plex servers for your account with at least one .plex.direct link for each. Copy one URL and replace the IP address with the desired address. This can be used as the plex_url value.

Known issues

Mount and --dir-cache-time

--dir-cache-time controls the first layer of directory caching which works at the mount layer. Being an independent caching mechanism from the cache backend, it will manage its own entries based on the configured time.

To avoid getting in a scenario where dir cache has obsolete data and cache would have the correct one, try to set --dir-cache-time to a lower time than --cache-info-age. Default values are already configured in this way.

Windows support - Experimental

There are a couple of issues with Windows mount functionality that still require some investigations. It should be considered as experimental thus far as fixes come in for this OS.

Most of the issues seem to be related to the difference between filesystems on Linux flavors and Windows as cache is heavily dependent on them.

Any reports or feedback on how cache behaves on this OS is greatly appreciated.

  • https://github.com/rclone/rclone/issues/1935
  • https://github.com/rclone/rclone/issues/1907
  • https://github.com/rclone/rclone/issues/1834

Risk of throttling

Future iterations of the cache backend will make use of the pooling functionality of the cloud provider to synchronize and at the same time make writing through it more tolerant to failures.

There are a couple of enhancements in track to add these but in the meantime there is a valid concern that the expiring cache listings can lead to cloud provider throttles or bans due to repeated queries on it for very large mounts.

Some recommendations: - don't use a very small interval for entry information (--cache-info-age) - while writes aren't yet optimised, you can still write through cache which gives you the advantage of adding the file in the cache at the same time if configured to do so.

Future enhancements:

  • https://github.com/rclone/rclone/issues/1937
  • https://github.com/rclone/rclone/issues/1936

cache and crypt

One common scenario is to keep your data encrypted in the cloud provider using the crypt remote. crypt uses a similar technique to wrap around an existing remote and handles this translation in a seamless way.

There is an issue with wrapping the remotes in this order: cloud remote -> crypt -> cache

During testing, I experienced a lot of bans with the remotes in this order. I suspect it might be related to how crypt opens files on the cloud provider which makes it think we're downloading the full file instead of small chunks. Organizing the remotes in this order yields better results: cloud remote -> cache -> crypt

absolute remote paths

cache can not differentiate between relative and absolute paths for the wrapped remote. Any path given in the remote config setting and on the command line will be passed to the wrapped remote as is, but for storing the chunks on disk the path will be made relative by removing any leading / character.

This behavior is irrelevant for most backend types, but there are backends where a leading / changes the effective directory, e.g. in the sftp backend paths starting with a / are relative to the root of the SSH server and paths without are relative to the user home directory. As a result sftp:bin and sftp:/bin will share the same cache folder, even if they represent a different directory on the SSH server.

Cache and Remote Control (--rc)

Cache supports the new --rc mode in rclone and can be remote controlled through the following end points: By default, the listener is disabled if you do not add the flag.

rc cache/expire

Purge a remote from the cache backend. Supports either a directory or a file. It supports both encrypted and unencrypted file names if cache is wrapped by crypt.

Params: - remote = path to remote (required) - withData = true/false to delete cached data (chunks) as well (optional, false by default)

Standard options

Here are the Standard options specific to cache (Cache a remote).

--cache-remote

Remote to cache.

Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended).

Properties:

  • Config: remote
  • Env Var: RCLONE_CACHE_REMOTE
  • Type: string
  • Required: true

--cache-plex-url

The URL of the Plex server.

Properties:

  • Config: plex_url
  • Env Var: RCLONE_CACHE_PLEX_URL
  • Type: string
  • Required: false

--cache-plex-username

The username of the Plex user.

Properties:

  • Config: plex_username
  • Env Var: RCLONE_CACHE_PLEX_USERNAME
  • Type: string
  • Required: false

--cache-plex-password

The password of the Plex user.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: plex_password
  • Env Var: RCLONE_CACHE_PLEX_PASSWORD
  • Type: string
  • Required: false

--cache-chunk-size

The size of a chunk (partial file data).

Use lower numbers for slower connections. If the chunk size is changed, any downloaded chunks will be invalid and cache-chunk-path will need to be cleared or unexpected EOF errors will occur.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_CACHE_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 5Mi
  • Examples:
    • "1M"
      • 1 MiB
    • "5M"
      • 5 MiB
    • "10M"
      • 10 MiB

--cache-info-age

How long to cache file structure information (directory listings, file size, times, etc.). If all write operations are done through the cache then you can safely make this value very large as the cache store will also be updated in real time.

Properties:

  • Config: info_age
  • Env Var: RCLONE_CACHE_INFO_AGE
  • Type: Duration
  • Default: 6h0m0s
  • Examples:
    • "1h"
      • 1 hour
    • "24h"
      • 24 hours
    • "48h"
      • 48 hours

--cache-chunk-total-size

The total size that the chunks can take up on the local disk.

If the cache exceeds this value then it will start to delete the oldest chunks until it goes under this value.

Properties:

  • Config: chunk_total_size
  • Env Var: RCLONE_CACHE_CHUNK_TOTAL_SIZE
  • Type: SizeSuffix
  • Default: 10Gi
  • Examples:
    • "500M"
      • 500 MiB
    • "1G"
      • 1 GiB
    • "10G"
      • 10 GiB

Advanced options

Here are the Advanced options specific to cache (Cache a remote).

--cache-plex-token

The plex token for authentication - auto set normally.

Properties:

  • Config: plex_token
  • Env Var: RCLONE_CACHE_PLEX_TOKEN
  • Type: string
  • Required: false

--cache-plex-insecure

Skip all certificate verification when connecting to the Plex server.

Properties:

  • Config: plex_insecure
  • Env Var: RCLONE_CACHE_PLEX_INSECURE
  • Type: string
  • Required: false

--cache-db-path

Directory to store file structure metadata DB.

The remote name is used as the DB file name.

Properties:

  • Config: db_path
  • Env Var: RCLONE_CACHE_DB_PATH
  • Type: string
  • Default: "$HOME/.cache/rclone/cache-backend"

--cache-chunk-path

Directory to cache chunk files.

Path to where partial file data (chunks) are stored locally. The remote name is appended to the final path.

This config follows the "--cache-db-path". If you specify a custom location for "--cache-db-path" and don't specify one for "--cache-chunk-path" then "--cache-chunk-path" will use the same path as "--cache-db-path".

Properties:

  • Config: chunk_path
  • Env Var: RCLONE_CACHE_CHUNK_PATH
  • Type: string
  • Default: "$HOME/.cache/rclone/cache-backend"

--cache-db-purge

Clear all the cached data for this remote on start.

Properties:

  • Config: db_purge
  • Env Var: RCLONE_CACHE_DB_PURGE
  • Type: bool
  • Default: false

--cache-chunk-clean-interval

How often should the cache perform cleanups of the chunk storage.

The default value should be ok for most people. If you find that the cache goes over "cache-chunk-total-size" too often then try to lower this value to force it to perform cleanups more often.

Properties:

  • Config: chunk_clean_interval
  • Env Var: RCLONE_CACHE_CHUNK_CLEAN_INTERVAL
  • Type: Duration
  • Default: 1m0s

--cache-read-retries

How many times to retry a read from a cache storage.

Since reading from a cache stream is independent from downloading file data, readers can get to a point where there's no more data in the cache. Most of the times this can indicate a connectivity issue if cache isn't able to provide file data anymore.

For really slow connections, increase this to a point where the stream is able to provide data but your experience will be very stuttering.

Properties:

  • Config: read_retries
  • Env Var: RCLONE_CACHE_READ_RETRIES
  • Type: int
  • Default: 10

--cache-workers

How many workers should run in parallel to download chunks.

Higher values will mean more parallel processing (better CPU needed) and more concurrent requests on the cloud provider. This impacts several aspects like the cloud provider API limits, more stress on the hardware that rclone runs on but it also means that streams will be more fluid and data will be available much more faster to readers.

Note: If the optional Plex integration is enabled then this setting will adapt to the type of reading performed and the value specified here will be used as a maximum number of workers to use.

Properties:

  • Config: workers
  • Env Var: RCLONE_CACHE_WORKERS
  • Type: int
  • Default: 4

--cache-chunk-no-memory

Disable the in-memory cache for storing chunks during streaming.

By default, cache will keep file data during streaming in RAM as well to provide it to readers as fast as possible.

This transient data is evicted as soon as it is read and the number of chunks stored doesn't exceed the number of workers. However, depending on other settings like "cache-chunk-size" and "cache-workers" this footprint can increase if there are parallel streams too (multiple files being read at the same time).

If the hardware permits it, use this feature to provide an overall better performance during streaming but it can also be disabled if RAM is not available on the local machine.

Properties:

  • Config: chunk_no_memory
  • Env Var: RCLONE_CACHE_CHUNK_NO_MEMORY
  • Type: bool
  • Default: false

--cache-rps

Limits the number of requests per second to the source FS (-1 to disable).

This setting places a hard limit on the number of requests per second that cache will be doing to the cloud provider remote and try to respect that value by setting waits between reads.

If you find that you're getting banned or limited on the cloud provider through cache and know that a smaller number of requests per second will allow you to work with it then you can use this setting for that.

A good balance of all the other settings should make this setting useless but it is available to set for more special cases.

NOTE: This will limit the number of requests during streams but other API calls to the cloud provider like directory listings will still pass.

Properties:

  • Config: rps
  • Env Var: RCLONE_CACHE_RPS
  • Type: int
  • Default: -1

--cache-writes

Cache file data on writes through the FS.

If you need to read files immediately after you upload them through cache you can enable this flag to have their data stored in the cache store at the same time during upload.

Properties:

  • Config: writes
  • Env Var: RCLONE_CACHE_WRITES
  • Type: bool
  • Default: false

--cache-tmp-upload-path

Directory to keep temporary files until they are uploaded.

This is the path where cache will use as a temporary storage for new files that need to be uploaded to the cloud provider.

Specifying a value will enable this feature. Without it, it is completely disabled and files will be uploaded directly to the cloud provider

Properties:

  • Config: tmp_upload_path
  • Env Var: RCLONE_CACHE_TMP_UPLOAD_PATH
  • Type: string
  • Required: false

--cache-tmp-wait-time

How long should files be stored in local cache before being uploaded.

This is the duration that a file must wait in the temporary location cache-tmp-upload-path before it is selected for upload.

Note that only one file is uploaded at a time and it can take longer to start the upload if a queue formed for this purpose.

Properties:

  • Config: tmp_wait_time
  • Env Var: RCLONE_CACHE_TMP_WAIT_TIME
  • Type: Duration
  • Default: 15s

--cache-db-wait-time

How long to wait for the DB to be available - 0 is unlimited.

Only one process can have the DB open at any one time, so rclone waits for this duration for the DB to become available before it gives an error.

If you set it to 0 then it will wait forever.

Properties:

  • Config: db_wait_time
  • Env Var: RCLONE_CACHE_DB_WAIT_TIME
  • Type: Duration
  • Default: 1s

--cache-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_CACHE_DESCRIPTION
  • Type: string
  • Required: false

Backend commands

Here are the commands specific to the cache backend.

Run them with

rclone backend COMMAND remote:

The help below will explain what arguments each command takes.

See the backend command for more info on how to pass options and arguments.

These can be run on a running backend using the rc command backend/command.

stats

Print stats on the cache backend in JSON format.

rclone backend stats remote: [options] [<arguments>+]

Chunker

The chunker overlay transparently splits large files into smaller chunks during upload to wrapped remote and transparently assembles them back when the file is downloaded. This allows to effectively overcome size limits imposed by storage providers.

Configuration

To use it, first set up the underlying remote following the configuration instructions for that remote. You can also use a local pathname instead of a remote.

First check your chosen remote is working - we'll call it remote:path here. Note that anything inside remote:path will be chunked and anything outside won't. This means that if you are using a bucket-based remote (e.g. S3, B2, swift) then you should probably put the bucket in the remote s3:bucket.

Now configure chunker using rclone config. We will call this one overlay to separate it from the remote itself.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> overlay
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Transparently chunk/split large files
   \ "chunker"
[snip]
Storage> chunker
Remote to chunk/unchunk.
Normally should contain a ':' and a path, e.g. "myremote:path/to/dir",
"myremote:bucket" or maybe "myremote:" (not recommended).
Enter a string value. Press Enter for the default ("").
remote> remote:path
Files larger than chunk size will be split in chunks.
Enter a size with suffix K,M,G,T. Press Enter for the default ("2G").
chunk_size> 100M
Choose how chunker handles hash sums. All modes but "none" require metadata.
Enter a string value. Press Enter for the default ("md5").
Choose a number from below, or type in your own value
 1 / Pass any hash supported by wrapped remote for non-chunked files, return nothing otherwise
   \ "none"
 2 / MD5 for composite files
   \ "md5"
 3 / SHA1 for composite files
   \ "sha1"
 4 / MD5 for all files
   \ "md5all"
 5 / SHA1 for all files
   \ "sha1all"
 6 / Copying a file to chunker will request MD5 from the source falling back to SHA1 if unsupported
   \ "md5quick"
 7 / Similar to "md5quick" but prefers SHA1 over MD5
   \ "sha1quick"
hash_type> md5
Edit advanced config? (y/n)
y) Yes
n) No
y/n> n
Remote config
--------------------
[overlay]
type = chunker
remote = remote:bucket
chunk_size = 100M
hash_type = md5
--------------------
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

Specifying the remote

In normal use, make sure the remote has a : in. If you specify the remote without a : then rclone will use a local directory of that name. So if you use a remote of /path/to/secret/files then rclone will chunk stuff in that directory. If you use a remote of name then rclone will put files in a directory called name in the current directory.

Chunking

When rclone starts a file upload, chunker checks the file size. If it doesn't exceed the configured chunk size, chunker will just pass the file to the wrapped remote (however, see caveat below). If a file is large, chunker will transparently cut data in pieces with temporary names and stream them one by one, on the fly. Each data chunk will contain the specified number of bytes, except for the last one which may have less data. If file size is unknown in advance (this is called a streaming upload), chunker will internally create a temporary copy, record its size and repeat the above process.

When upload completes, temporary chunk files are finally renamed. This scheme guarantees that operations can be run in parallel and look from outside as atomic. A similar method with hidden temporary chunks is used for other operations (copy/move/rename, etc.). If an operation fails, hidden chunks are normally destroyed, and the target composite file stays intact.

When a composite file download is requested, chunker transparently assembles it by concatenating data chunks in order. As the split is trivial one could even manually concatenate data chunks together to obtain the original content.

When the list rclone command scans a directory on wrapped remote, the potential chunk files are accounted for, grouped and assembled into composite directory entries. Any temporary chunks are hidden.

List and other commands can sometimes come across composite files with missing or invalid chunks, e.g. shadowed by like-named directory or another file. This usually means that wrapped file system has been directly tampered with or damaged. If chunker detects a missing chunk it will by default print warning, skip the whole incomplete group of chunks but proceed with current command. You can set the --chunker-fail-hard flag to have commands abort with error message in such cases.

Caveat: As it is now, chunker will always create a temporary file in the backend and then rename it, even if the file is below the chunk threshold. This will result in unnecessary API calls and can severely restrict throughput when handling transfers primarily composed of small files on some backends (e.g. Box). A workaround to this issue is to use chunker only for files above the chunk threshold via --min-size and then perform a separate call without chunker on the remaining files.

Chunk names

The default chunk name format is *.rclone_chunk.###, hence by default chunk names are BIG_FILE_NAME.rclone_chunk.001, BIG_FILE_NAME.rclone_chunk.002 etc. You can configure another name format using the name_format configuration file option. The format uses asterisk * as a placeholder for the base file name and one or more consecutive hash characters # as a placeholder for sequential chunk number. There must be one and only one asterisk. The number of consecutive hash characters defines the minimum length of a string representing a chunk number. If decimal chunk number has less digits than the number of hashes, it is left-padded by zeros. If the decimal string is longer, it is left intact. By default numbering starts from 1 but there is another option that allows user to start from 0, e.g. for compatibility with legacy software.

For example, if name format is big_*-##.part and original file name is data.txt and numbering starts from 0, then the first chunk will be named big_data.txt-00.part, the 99th chunk will be big_data.txt-98.part and the 302nd chunk will become big_data.txt-301.part.

Note that list assembles composite directory entries only when chunk names match the configured format and treats non-conforming file names as normal non-chunked files.

When using norename transactions, chunk names will additionally have a unique file version suffix. For example, BIG_FILE_NAME.rclone_chunk.001_bp562k.

Metadata

Besides data chunks chunker will by default create metadata object for a composite file. The object is named after the original file. Chunker allows user to disable metadata completely (the none format). Note that metadata is normally not created for files smaller than the configured chunk size. This may change in future rclone releases.

Simple JSON metadata format

This is the default format. It supports hash sums and chunk validation for composite files. Meta objects carry the following fields:

  • ver - version of format, currently 1
  • size - total size of composite file
  • nchunks - number of data chunks in file
  • md5 - MD5 hashsum of composite file (if present)
  • sha1 - SHA1 hashsum (if present)
  • txn - identifies current version of the file

There is no field for composite file name as it's simply equal to the name of meta object on the wrapped remote. Please refer to respective sections for details on hashsums and modified time handling.

No metadata

You can disable meta objects by setting the meta format option to none. In this mode chunker will scan directory for all files that follow configured chunk name format, group them by detecting chunks with the same base name and show group names as virtual composite files. This method is more prone to missing chunk errors (especially missing last chunk) than format with metadata enabled.

Hashsums

Chunker supports hashsums only when a compatible metadata is present. Hence, if you choose metadata format of none, chunker will report hashsum as UNSUPPORTED.

Please note that by default metadata is stored only for composite files. If a file is smaller than configured chunk size, chunker will transparently redirect hash requests to wrapped remote, so support depends on that. You will see the empty string as a hashsum of requested type for small files if the wrapped remote doesn't support it.

Many storage backends support MD5 and SHA1 hash types, so does chunker. With chunker you can choose one or another but not both. MD5 is set by default as the most supported type. Since chunker keeps hashes for composite files and falls back to the wrapped remote hash for non-chunked ones, we advise you to choose the same hash type as supported by wrapped remote so that your file listings look coherent.

If your storage backend does not support MD5 or SHA1 but you need consistent file hashing, configure chunker with md5all or sha1all. These two modes guarantee given hash for all files. If wrapped remote doesn't support it, chunker will then add metadata to all files, even small. However, this can double the amount of small files in storage and incur additional service charges. You can even use chunker to force md5/sha1 support in any other remote at expense of sidecar meta objects by setting e.g. hash_type=sha1all to force hashsums and chunk_size=1P to effectively disable chunking.

Normally, when a file is copied to chunker controlled remote, chunker will ask the file source for compatible file hash and revert to on-the-fly calculation if none is found. This involves some CPU overhead but provides a guarantee that given hashsum is available. Also, chunker will reject a server-side copy or move operation if source and destination hashsum types are different resulting in the extra network bandwidth, too. In some rare cases this may be undesired, so chunker provides two optional choices: sha1quick and md5quick. If the source does not support primary hash type and the quick mode is enabled, chunker will try to fall back to the secondary type. This will save CPU and bandwidth but can result in empty hashsums at destination. Beware of consequences: the sync command will revert (sometimes silently) to time/size comparison if compatible hashsums between source and target are not found.

Modification times

Chunker stores modification times using the wrapped remote so support depends on that. For a small non-chunked file the chunker overlay simply manipulates modification time of the wrapped remote file. For a composite file with metadata chunker will get and set modification time of the metadata object on the wrapped remote. If file is chunked but metadata format is none then chunker will use modification time of the first data chunk.

Migrations

The idiomatic way to migrate to a different chunk size, hash type, transaction style or chunk naming scheme is to:

  • Collect all your chunked files under a directory and have your chunker remote point to it.
  • Create another directory (most probably on the same cloud storage) and configure a new remote with desired metadata format, hash type, chunk naming etc.
  • Now run rclone sync --interactive oldchunks: newchunks: and all your data will be transparently converted in transfer. This may take some time, yet chunker will try server-side copy if possible.
  • After checking data integrity you may remove configuration section of the old remote.

If rclone gets killed during a long operation on a big composite file, hidden temporary chunks may stay in the directory. They will not be shown by the list command but will eat up your account quota. Please note that the deletefile command deletes only active chunks of a file. As a workaround, you can use remote of the wrapped file system to see them. An easy way to get rid of hidden garbage is to copy littered directory somewhere using the chunker remote and purge the original directory. The copy command will copy only active chunks while the purge will remove everything including garbage.

Caveats and Limitations

Chunker requires wrapped remote to support server-side move (or copy + delete) operations, otherwise it will explicitly refuse to start. This is because it internally renames temporary chunk files to their final names when an operation completes successfully.

Chunker encodes chunk number in file name, so with default name_format setting it adds 17 characters. Also chunker adds 7 characters of temporary suffix during operations. Many file systems limit base file name without path by 255 characters. Using rclone's crypt remote as a base file system limits file name by 143 characters. Thus, maximum name length is 231 for most files and 119 for chunker-over-crypt. A user in need can change name format to e.g. *.rcc## and save 10 characters (provided at most 99 chunks per file).

Note that a move implemented using the copy-and-delete method may incur double charging with some cloud storage providers.

Chunker will not automatically rename existing chunks when you run rclone config on a live remote and change the chunk name format. Beware that in result of this some files which have been treated as chunks before the change can pop up in directory listings as normal files and vice versa. The same warning holds for the chunk size. If you desperately need to change critical chunking settings, you should run data migration as described above.

If wrapped remote is case insensitive, the chunker overlay will inherit that property (so you can't have a file called "Hello.doc" and "hello.doc" in the same directory).

Chunker included in rclone releases up to v1.54 can sometimes fail to detect metadata produced by recent versions of rclone. We recommend users to keep rclone up-to-date to avoid data corruption.

Changing transactions is dangerous and requires explicit migration.

Standard options

Here are the Standard options specific to chunker (Transparently chunk/split large files).

--chunker-remote

Remote to chunk/unchunk.

Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended).

Properties:

  • Config: remote
  • Env Var: RCLONE_CHUNKER_REMOTE
  • Type: string
  • Required: true

--chunker-chunk-size

Files larger than chunk size will be split in chunks.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_CHUNKER_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 2Gi

--chunker-hash-type

Choose how chunker handles hash sums.

All modes but "none" require metadata.

Properties:

  • Config: hash_type
  • Env Var: RCLONE_CHUNKER_HASH_TYPE
  • Type: string
  • Default: "md5"
  • Examples:
    • "none"
      • Pass any hash supported by wrapped remote for non-chunked files.
      • Return nothing otherwise.
    • "md5"
      • MD5 for composite files.
    • "sha1"
      • SHA1 for composite files.
    • "md5all"
      • MD5 for all files.
    • "sha1all"
      • SHA1 for all files.
    • "md5quick"
      • Copying a file to chunker will request MD5 from the source.
      • Falling back to SHA1 if unsupported.
    • "sha1quick"
      • Similar to "md5quick" but prefers SHA1 over MD5.

Advanced options

Here are the Advanced options specific to chunker (Transparently chunk/split large files).

--chunker-name-format

String format of chunk file names.

The two placeholders are: base file name (*) and chunk number (#...). There must be one and only one asterisk and one or more consecutive hash characters. If chunk number has less digits than the number of hashes, it is left-padded by zeros. If there are more digits in the number, they are left as is. Possible chunk files are ignored if their name does not match given format.

Properties:

  • Config: name_format
  • Env Var: RCLONE_CHUNKER_NAME_FORMAT
  • Type: string
  • Default: "*.rclone_chunk.###"

--chunker-start-from

Minimum valid chunk number. Usually 0 or 1.

By default chunk numbers start from 1.

Properties:

  • Config: start_from
  • Env Var: RCLONE_CHUNKER_START_FROM
  • Type: int
  • Default: 1

--chunker-meta-format

Format of the metadata object or "none".

By default "simplejson". Metadata is a small JSON file named after the composite file.

Properties:

  • Config: meta_format
  • Env Var: RCLONE_CHUNKER_META_FORMAT
  • Type: string
  • Default: "simplejson"
  • Examples:
    • "none"
      • Do not use metadata files at all.
      • Requires hash type "none".
    • "simplejson"
      • Simple JSON supports hash sums and chunk validation.
      • It has the following fields: ver, size, nchunks, md5, sha1.

--chunker-fail-hard

Choose how chunker should handle files with missing or invalid chunks.

Properties:

  • Config: fail_hard
  • Env Var: RCLONE_CHUNKER_FAIL_HARD
  • Type: bool
  • Default: false
  • Examples:
    • "true"
      • Report errors and abort current command.
    • "false"
      • Warn user, skip incomplete file and proceed.

--chunker-transactions

Choose how chunker should handle temporary files during transactions.

Properties:

  • Config: transactions
  • Env Var: RCLONE_CHUNKER_TRANSACTIONS
  • Type: string
  • Default: "rename"
  • Examples:
    • "rename"
      • Rename temporary files after a successful transaction.
    • "norename"
      • Leave temporary file names and write transaction ID to metadata file.
      • Metadata is required for no rename transactions (meta format cannot be "none").
      • If you are using norename transactions you should be careful not to downgrade Rclone
      • as older versions of Rclone don't support this transaction style and will misinterpret
      • files manipulated by norename transactions.
      • This method is EXPERIMENTAL, don't use on production systems.
    • "auto"
      • Rename or norename will be used depending on capabilities of the backend.
      • If meta format is set to "none", rename transactions will always be used.
      • This method is EXPERIMENTAL, don't use on production systems.

--chunker-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_CHUNKER_DESCRIPTION
  • Type: string
  • Required: false

Cloudinary

This is a backend for the Cloudinary platform

About Cloudinary

Cloudinary is an image and video API platform. Trusted by 1.5 million developers and 10,000 enterprise and hyper-growth companies as a critical part of their tech stack to deliver visually engaging experiences.

Accounts & Pricing

To use this backend, you need to create a free account on Cloudinary. Start with a free plan with generous usage limits. Then, as your requirements grow, upgrade to a plan that best fits your needs. See the pricing details.

Securing Your Credentials

Please refer to the docs

Configuration

Here is an example of making a Cloudinary configuration.

First, create a cloudinary.com account and choose a plan.

You will need to log in and get the API Key and API Secret for your account from the developer section.

Now run

rclone config

Follow the interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter the name for the new remote.
name> cloudinary-media-library

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / cloudinary.com
\ (cloudinary)
[snip]
Storage> cloudinary

Option cloud_name.
You can find your cloudinary.com cloud_name in your [dashboard](https://console.cloudinary.com/pm/developer-dashboard)
Enter a value.
cloud_name> ****************************

Option api_key.
You can find your cloudinary.com api key in your [dashboard](https://console.cloudinary.com/pm/developer-dashboard)
Enter a value.
api_key> ****************************

Option api_secret.
You can find your cloudinary.com api secret in your [dashboard](https://console.cloudinary.com/pm/developer-dashboard)
This value must be a single character, one of the following: y, g.
y/g> y
Enter a value.
api_secret> ****************************

Option upload_prefix.
[Upload prefix](https://cloudinary.com/documentation/cloudinary_sdks#configuration_parameters) to specify alternative data center
Enter a value.
upload_prefix>

Option upload_preset.
[Upload presets](https://cloudinary.com/documentation/upload_presets) can be defined for different upload profiles
Enter a value.
upload_preset>

Edit advanced config?
y) Yes
n) No (default)
y/n> n

Configuration complete.
Options:
- type: cloudinary
- api_key: ****************************
- api_secret: ****************************
- cloud_name: ****************************
- upload_prefix:
- upload_preset:

Keep this "cloudinary-media-library" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

List directories in the top level of your Media Library

rclone lsd cloudinary-media-library:

Make a new directory.

rclone mkdir cloudinary-media-library:directory

List the contents of a directory.

rclone ls cloudinary-media-library:directory

Modified time and hashes

Cloudinary stores md5 and timestamps for any successful Put automatically and read-only.

Standard options

Here are the Standard options specific to cloudinary (Cloudinary).

--cloudinary-cloud-name

Cloudinary Environment Name

Properties:

  • Config: cloud_name
  • Env Var: RCLONE_CLOUDINARY_CLOUD_NAME
  • Type: string
  • Required: true

--cloudinary-api-key

Cloudinary API Key

Properties:

  • Config: api_key
  • Env Var: RCLONE_CLOUDINARY_API_KEY
  • Type: string
  • Required: true

--cloudinary-api-secret

Cloudinary API Secret

Properties:

  • Config: api_secret
  • Env Var: RCLONE_CLOUDINARY_API_SECRET
  • Type: string
  • Required: true

--cloudinary-upload-prefix

Specify the API endpoint for environments out of the US

Properties:

  • Config: upload_prefix
  • Env Var: RCLONE_CLOUDINARY_UPLOAD_PREFIX
  • Type: string
  • Required: false

--cloudinary-upload-preset

Upload Preset to select asset manipulation on upload

Properties:

  • Config: upload_preset
  • Env Var: RCLONE_CLOUDINARY_UPLOAD_PRESET
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to cloudinary (Cloudinary).

--cloudinary-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_CLOUDINARY_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,Question,Asterisk,Pipe,Hash,Percent,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot

--cloudinary-eventually-consistent-delay

Wait N seconds for eventual consistency of the databases that support the backend operation

Properties:

  • Config: eventually_consistent_delay
  • Env Var: RCLONE_CLOUDINARY_EVENTUALLY_CONSISTENT_DELAY
  • Type: Duration
  • Default: 0s

--cloudinary-adjust-media-files-extensions

Cloudinary handles media formats as a file attribute and strips it from the name, which is unlike most other file systems

Properties:

  • Config: adjust_media_files_extensions
  • Env Var: RCLONE_CLOUDINARY_ADJUST_MEDIA_FILES_EXTENSIONS
  • Type: bool
  • Default: true

--cloudinary-media-extensions

Cloudinary supported media extensions

Properties:

  • Config: media_extensions
  • Env Var: RCLONE_CLOUDINARY_MEDIA_EXTENSIONS
  • Type: stringArray
  • Default: [3ds 3g2 3gp ai arw avi avif bmp bw cr2 cr3 djvu dng eps3 fbx flif flv gif glb gltf hdp heic heif ico indd jp2 jpe jpeg jpg jxl jxr m2ts mov mp4 mpeg mts mxf obj ogv pdf ply png psd svg tga tif tiff ts u3ma usdz wdp webm webp wmv]

--cloudinary-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_CLOUDINARY_DESCRIPTION
  • Type: string
  • Required: false

Citrix ShareFile

Citrix ShareFile is a secure file sharing and transfer service aimed as business.

Configuration

The initial setup for Citrix ShareFile involves getting a token from Citrix ShareFile which you can in your browser. rclone config walks you through it.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
XX / Citrix Sharefile
   \ "sharefile"
Storage> sharefile
** See help for sharefile backend at: https://rclone.org/sharefile/ **

ID of the root folder

Leave blank to access "Personal Folders".  You can use one of the
standard values here or any folder ID (long hex number ID).
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / Access the Personal Folders. (Default)
   \ ""
 2 / Access the Favorites folder.
   \ "favorites"
 3 / Access all the shared folders.
   \ "allshared"
 4 / Access all the individual connectors.
   \ "connectors"
 5 / Access the home, favorites, and shared folders as well as the connectors.
   \ "top"
root_folder_id> 
Edit advanced config? (y/n)
y) Yes
n) No
y/n> n
Remote config
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y) Yes
n) No
y/n> y
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth?state=XXX
Log in and authorize rclone for access
Waiting for code...
Got code
Configuration complete.
Options:
- type: sharefile
- endpoint: https://XXX.sharefile.com
- token: {"access_token":"XXX","token_type":"bearer","refresh_token":"XXX","expiry":"2019-09-30T19:41:45.878561877+01:00"}
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

See the remote setup docs for how to set it up on a machine with no Internet browser available.

Note that rclone runs a webserver on your local machine to collect the token as returned from Citrix ShareFile. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall.

Once configured you can then use rclone like this,

List directories in top level of your ShareFile

rclone lsd remote:

List all the files in your ShareFile

rclone ls remote:

To copy a local directory to an ShareFile directory called backup

rclone copy /home/source remote:backup

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Modification times and hashes

ShareFile allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not.

ShareFile supports MD5 type hashes, so you can use the --checksum flag.

Transfers

For files above 128 MiB rclone will use a chunked transfer. Rclone will upload up to --transfers chunks at the same time (shared among all the multipart uploads). Chunks are buffered in memory and are normally 64 MiB so increasing --transfers will increase memory use.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
\ 0x5C ＼
* 0x2A ＊
< 0x3C ＜
> 0x3E ＞
? 0x3F ？
: 0x3A ：
| 0x7C ｜
" 0x22 ＂

File names can also not start or end with the following characters. These only get replaced if they are the first or last character in the name:

Character Value Replacement
SP 0x20 ␠
. 0x2E ．

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Standard options

Here are the Standard options specific to sharefile (Citrix Sharefile).

--sharefile-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_SHAREFILE_CLIENT_ID
  • Type: string
  • Required: false

--sharefile-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_SHAREFILE_CLIENT_SECRET
  • Type: string
  • Required: false

--sharefile-root-folder-id

ID of the root folder.

Leave blank to access "Personal Folders". You can use one of the standard values here or any folder ID (long hex number ID).

Properties:

  • Config: root_folder_id
  • Env Var: RCLONE_SHAREFILE_ROOT_FOLDER_ID
  • Type: string
  • Required: false
  • Examples:
    • ""
      • Access the Personal Folders (default).
    • "favorites"
      • Access the Favorites folder.
    • "allshared"
      • Access all the shared folders.
    • "connectors"
      • Access all the individual connectors.
    • "top"
      • Access the home, favorites, and shared folders as well as the connectors.

Advanced options

Here are the Advanced options specific to sharefile (Citrix Sharefile).

--sharefile-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_SHAREFILE_TOKEN
  • Type: string
  • Required: false

--sharefile-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_SHAREFILE_AUTH_URL
  • Type: string
  • Required: false

--sharefile-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_SHAREFILE_TOKEN_URL
  • Type: string
  • Required: false

--sharefile-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_SHAREFILE_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--sharefile-upload-cutoff

Cutoff for switching to multipart upload.

Properties:

  • Config: upload_cutoff
  • Env Var: RCLONE_SHAREFILE_UPLOAD_CUTOFF
  • Type: SizeSuffix
  • Default: 128Mi

--sharefile-chunk-size

Upload chunk size.

Must a power of 2 >= 256k.

Making this larger will improve performance, but note that each chunk is buffered in memory one per transfer.

Reducing this will reduce memory usage but decrease performance.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_SHAREFILE_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 64Mi

--sharefile-endpoint

Endpoint for API calls.

This is usually auto discovered as part of the oauth process, but can be set manually to something like: https://XXX.sharefile.com

Properties:

  • Config: endpoint
  • Env Var: RCLONE_SHAREFILE_ENDPOINT
  • Type: string
  • Required: false

--sharefile-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_SHAREFILE_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,LeftSpace,LeftPeriod,RightSpace,RightPeriod,InvalidUtf8,Dot

--sharefile-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_SHAREFILE_DESCRIPTION
  • Type: string
  • Required: false

Limitations

Note that ShareFile is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc".

ShareFile only supports filenames up to 256 characters in length.

rclone about is not supported by the Citrix ShareFile backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

Crypt

Rclone crypt remotes encrypt and decrypt other remotes.

A remote of type crypt does not access a storage system directly, but instead wraps another remote, which in turn accesses the storage system. This is similar to how alias, union, chunker and a few others work. It makes the usage very flexible, as you can add a layer, in this case an encryption layer, on top of any other backend, even in multiple layers. Rclone's functionality can be used as with any other remote, for example you can mount a crypt remote.

Accessing a storage system through a crypt remote realizes client-side encryption, which makes it safe to keep your data in a location you do not trust will not get compromised. When working against the crypt remote, rclone will automatically encrypt (before uploading) and decrypt (after downloading) on your local system as needed on the fly, leaving the data encrypted at rest in the wrapped remote. If you access the storage system using an application other than rclone, or access the wrapped remote directly using rclone, there will not be any encryption/decryption: Downloading existing content will just give you the encrypted (scrambled) format, and anything you upload will not become encrypted.

The encryption is a secret-key encryption (also called symmetric key encryption) algorithm, where a password (or pass phrase) is used to generate real encryption key. The password can be supplied by user, or you may chose to let rclone generate one. It will be stored in the configuration file, in a lightly obscured form. If you are in an environment where you are not able to keep your configuration secured, you should add configuration encryption as protection. As long as you have this configuration file, you will be able to decrypt your data. Without the configuration file, as long as you remember the password (or keep it in a safe place), you can re-create the configuration and gain access to the existing data. You may also configure a corresponding remote in a different installation to access the same data. See below for guidance to changing password.

Encryption uses cryptographic salt, to permute the encryption key so that the same string may be encrypted in different ways. When configuring the crypt remote it is optional to enter a salt, or to let rclone generate a unique salt. If omitted, rclone uses a built-in unique string. Normally in cryptography, the salt is stored together with the encrypted content, and do not have to be memorized by the user. This is not the case in rclone, because rclone does not store any additional information on the remotes. Use of custom salt is effectively a second password that must be memorized.

File content encryption is performed using NaCl SecretBox, based on XSalsa20 cipher and Poly1305 for integrity. Names (file- and directory names) are also encrypted by default, but this has some implications and is therefore possible to be turned off.

Configuration

Here is an example of how to make a remote called secret.

To use crypt, first set up the underlying remote. Follow the rclone config instructions for the specific backend.

Before configuring the crypt remote, check the underlying remote is working. In this example the underlying remote is called remote. We will configure a path path within this remote to contain the encrypted content. Anything inside remote:path will be encrypted and anything outside will not.

Configure crypt using rclone config. In this example the crypt remote is called secret, to differentiate it from the underlying remote.

When you are done you can use the crypt remote named secret just as you would with any other remote, e.g. rclone copy D:\docs secret:\docs, and rclone will encrypt and decrypt as needed on the fly. If you access the wrapped remote remote:path directly you will bypass the encryption, and anything you read will be in encrypted form, and anything you write will be unencrypted. To avoid issues it is best to configure a dedicated path for encrypted content, and access it exclusively through a crypt remote.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> secret
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Encrypt/Decrypt a remote
   \ "crypt"
[snip]
Storage> crypt
** See help for crypt backend at: https://rclone.org/crypt/ **

Remote to encrypt/decrypt.
Normally should contain a ':' and a path, eg "myremote:path/to/dir",
"myremote:bucket" or maybe "myremote:" (not recommended).
Enter a string value. Press Enter for the default ("").
remote> remote:path
How to encrypt the filenames.
Enter a string value. Press Enter for the default ("standard").
Choose a number from below, or type in your own value.
   / Encrypt the filenames.
 1 | See the docs for the details.
   \ "standard"
 2 / Very simple filename obfuscation.
   \ "obfuscate"
   / Don't encrypt the file names.
 3 | Adds a ".bin" extension only.
   \ "off"
filename_encryption>
Option to either encrypt directory names or leave them intact.

NB If filename_encryption is "off" then this option will do nothing.
Enter a boolean value (true or false). Press Enter for the default ("true").
Choose a number from below, or type in your own value
 1 / Encrypt directory names.
   \ "true"
 2 / Don't encrypt directory names, leave them intact.
   \ "false"
directory_name_encryption>
Password or pass phrase for encryption.
y) Yes type in my own password
g) Generate random password
y/g> y
Enter the password:
password:
Confirm the password:
password:
Password or pass phrase for salt. Optional but recommended.
Should be different to the previous password.
y) Yes type in my own password
g) Generate random password
n) No leave this optional password blank (default)
y/g/n> g
Password strength in bits.
64 is just about memorable
128 is secure
1024 is the maximum
Bits> 128
Your password is: JAsJvRcgR-_veXNfy_sGmQ
Use this password? Please note that an obscured version of this
password (and not the password itself) will be stored under your
configuration file, so keep this generated password in a safe place.
y) Yes (default)
n) No
y/n>
Edit advanced config? (y/n)
y) Yes
n) No (default)
y/n>
Remote config
--------------------
[secret]
type = crypt
remote = remote:path
password = *** ENCRYPTED ***
password2 = *** ENCRYPTED ***
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d>

Important The crypt password stored in rclone.conf is lightly obscured. That only protects it from cursory inspection. It is not secure unless configuration encryption of rclone.conf is specified.

A long passphrase is recommended, or rclone config can generate a random one.

The obscured password is created using AES-CTR with a static key. The IV (nonce) is stored verbatim at the beginning of the obscured password. This static key is shared between all versions of rclone.

If you reconfigure rclone with the same passwords/passphrases elsewhere it will be compatible, but the obscured version will be different due to the different salt.

Rclone does not encrypt

  • file length - this can be calculated within 16 bytes
  • modification time - used for syncing

Specifying the remote

When configuring the remote to encrypt/decrypt, you may specify any string that rclone accepts as a source/destination of other commands.

The primary use case is to specify the path into an already configured remote (e.g. remote:path/to/dir or remote:bucket), such that data in a remote untrusted location can be stored encrypted.

You may also specify a local filesystem path, such as /path/to/dir on Linux, C:\path\to\dir on Windows. By creating a crypt remote pointing to such a local filesystem path, you can use rclone as a utility for pure local file encryption, for example to keep encrypted files on a removable USB drive.

Note: A string which do not contain a : will by rclone be treated as a relative path in the local filesystem. For example, if you enter the name remote without the trailing :, it will be treated as a subdirectory of the current directory with name "remote".

If a path remote:path/to/dir is specified, rclone stores encrypted files in path/to/dir on the remote. With file name encryption, files saved to secret:subdir/subfile are stored in the unencrypted path path/to/dir but the subdir/subpath element is encrypted.

The path you specify does not have to exist, rclone will create it when needed.

If you intend to use the wrapped remote both directly for keeping unencrypted content, as well as through a crypt remote for encrypted content, it is recommended to point the crypt remote to a separate directory within the wrapped remote. If you use a bucket-based storage system (e.g. Swift, S3, Google Compute Storage, B2) it is generally advisable to wrap the crypt remote around a specific bucket (s3:bucket). If wrapping around the entire root of the storage (s3:), and use the optional file name encryption, rclone will encrypt the bucket name.

Changing password

Should the password, or the configuration file containing a lightly obscured form of the password, be compromised, you need to re-encrypt your data with a new password. Since rclone uses secret-key encryption, where the encryption key is generated directly from the password kept on the client, it is not possible to change the password/key of already encrypted content. Just changing the password configured for an existing crypt remote means you will no longer able to decrypt any of the previously encrypted content. The only possibility is to re-upload everything via a crypt remote configured with your new password.

Depending on the size of your data, your bandwidth, storage quota etc, there are different approaches you can take: - If you have everything in a different location, for example on your local system, you could remove all of the prior encrypted files, change the password for your configured crypt remote (or delete and re-create the crypt configuration), and then re-upload everything from the alternative location. - If you have enough space on the storage system you can create a new crypt remote pointing to a separate directory on the same backend, and then use rclone to copy everything from the original crypt remote to the new, effectively decrypting everything on the fly using the old password and re-encrypting using the new password. When done, delete the original crypt remote directory and finally the rclone crypt configuration with the old password. All data will be streamed from the storage system and back, so you will get half the bandwidth and be charged twice if you have upload and download quota on the storage system.

Note: A security problem related to the random password generator was fixed in rclone version 1.53.3 (released 2020-11-19). Passwords generated by rclone config in version 1.49.0 (released 2019-08-26) to 1.53.2 (released 2020-10-26) are not considered secure and should be changed. If you made up your own password, or used rclone version older than 1.49.0 or newer than 1.53.2 to generate it, you are not affected by this issue. See issue #4783 for more details, and a tool you can use to check if you are affected.

Example

Create the following file structure using "standard" file name encryption.

plaintext/
├── file0.txt
├── file1.txt
└── subdir
    ├── file2.txt
    ├── file3.txt
    └── subsubdir
        └── file4.txt

Copy these to the remote, and list them

$ rclone -q copy plaintext secret:
$ rclone -q ls secret:
        7 file1.txt
        6 file0.txt
        8 subdir/file2.txt
       10 subdir/subsubdir/file4.txt
        9 subdir/file3.txt

The crypt remote looks like

$ rclone -q ls remote:path
       55 hagjclgavj2mbiqm6u6cnjjqcg
       54 v05749mltvv1tf4onltun46gls
       57 86vhrsv86mpbtd3a0akjuqslj8/dlj7fkq4kdq72emafg7a7s41uo
       58 86vhrsv86mpbtd3a0akjuqslj8/7uu829995du6o42n32otfhjqp4/b9pausrfansjth5ob3jkdqd4lc
       56 86vhrsv86mpbtd3a0akjuqslj8/8njh1sk437gttmep3p70g81aps

The directory structure is preserved

$ rclone -q ls secret:subdir
        8 file2.txt
        9 file3.txt
       10 subsubdir/file4.txt

Without file name encryption .bin extensions are added to underlying names. This prevents the cloud provider attempting to interpret file content.

$ rclone -q ls remote:path
       54 file0.txt.bin
       57 subdir/file3.txt.bin
       56 subdir/file2.txt.bin
       58 subdir/subsubdir/file4.txt.bin
       55 file1.txt.bin

File name encryption modes

Off

  • doesn't hide file names or directory structure
  • allows for longer file names (~246 characters)
  • can use sub paths and copy single files

Standard

  • file names encrypted
  • file names can't be as long (~143 characters)
  • can use sub paths and copy single files
  • directory structure visible
  • identical files names will have identical uploaded names
  • can use shortcuts to shorten the directory recursion

Obfuscation

This is a simple "rotate" of the filename, with each file having a rot distance based on the filename. Rclone stores the distance at the beginning of the filename. A file called "hello" may become "53.jgnnq".

Obfuscation is not a strong encryption of filenames, but hinders automated scanning tools picking up on filename patterns. It is an intermediate between "off" and "standard" which allows for longer path segment names.

There is a possibility with some unicode based filenames that the obfuscation is weak and may map lower case characters to upper case equivalents.

Obfuscation cannot be relied upon for strong protection.

  • file names very lightly obfuscated
  • file names can be longer than standard encryption
  • can use sub paths and copy single files
  • directory structure visible
  • identical files names will have identical uploaded names

Cloud storage systems have limits on file name length and total path length which rclone is more likely to breach using "Standard" file name encryption. Where file names are 143 or fewer characters in length issues should not be encountered, irrespective of cloud storage provider.

An experimental advanced option filename_encoding is now provided to address this problem to a certain degree. For cloud storage systems with case sensitive file names (e.g. Google Drive), base64 can be used to reduce file name length. For cloud storage systems using UTF-16 to store file names internally (e.g. OneDrive, Dropbox, Box), base32768 can be used to drastically reduce file name length.

An alternative, future rclone file name encryption mode may tolerate backend provider path length limits.

Directory name encryption

Crypt offers the option of encrypting dir names or leaving them intact. There are two options:

True

Encrypts the whole file path including directory names Example: 1/12/123.txt is encrypted to p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng/qgm4avr35m5loi1th53ato71v0

False

Only encrypts file names, skips directory names Example: 1/12/123.txt is encrypted to 1/12/qgm4avr35m5loi1th53ato71v0

Modification times and hashes

Crypt stores modification times using the underlying remote so support depends on that.

Hashes are not stored for crypt. However the data integrity is protected by an extremely strong crypto authenticator.

Use the rclone cryptcheck command to check the integrity of an encrypted remote instead of rclone check which can't check the checksums properly.

Standard options

Here are the Standard options specific to crypt (Encrypt/Decrypt a remote).

--crypt-remote

Remote to encrypt/decrypt.

Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended).

Properties:

  • Config: remote
  • Env Var: RCLONE_CRYPT_REMOTE
  • Type: string
  • Required: true

--crypt-filename-encryption

How to encrypt the filenames.

Properties:

  • Config: filename_encryption
  • Env Var: RCLONE_CRYPT_FILENAME_ENCRYPTION
  • Type: string
  • Default: "standard"
  • Examples:
    • "standard"
      • Encrypt the filenames.
      • See the docs for the details.
    • "obfuscate"
      • Very simple filename obfuscation.
    • "off"
      • Don't encrypt the file names.
      • Adds a ".bin", or "suffix" extension only.

--crypt-directory-name-encryption

Option to either encrypt directory names or leave them intact.

NB If filename_encryption is "off" then this option will do nothing.

Properties:

  • Config: directory_name_encryption
  • Env Var: RCLONE_CRYPT_DIRECTORY_NAME_ENCRYPTION
  • Type: bool
  • Default: true
  • Examples:
    • "true"
      • Encrypt directory names.
    • "false"
      • Don't encrypt directory names, leave them intact.

--crypt-password

Password or pass phrase for encryption.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: password
  • Env Var: RCLONE_CRYPT_PASSWORD
  • Type: string
  • Required: true

--crypt-password2

Password or pass phrase for salt.

Optional but recommended. Should be different to the previous password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: password2
  • Env Var: RCLONE_CRYPT_PASSWORD2
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to crypt (Encrypt/Decrypt a remote).

--crypt-server-side-across-configs

Deprecated: use --server-side-across-configs instead.

Allow server-side operations (e.g. copy) to work across different crypt configs.

Normally this option is not what you want, but if you have two crypts pointing to the same backend you can use it.

This can be used, for example, to change file name encryption type without re-uploading all the data. Just make two crypt backends pointing to two different directories with the single changed parameter and use rclone move to move the files between the crypt remotes.

Properties:

  • Config: server_side_across_configs
  • Env Var: RCLONE_CRYPT_SERVER_SIDE_ACROSS_CONFIGS
  • Type: bool
  • Default: false

--crypt-show-mapping

For all files listed show how the names encrypt.

If this flag is set then for each file that the remote is asked to list, it will log (at level INFO) a line stating the decrypted file name and the encrypted file name.

This is so you can work out which encrypted names are which decrypted names just in case you need to do something with the encrypted file names, or for debugging purposes.

Properties:

  • Config: show_mapping
  • Env Var: RCLONE_CRYPT_SHOW_MAPPING
  • Type: bool
  • Default: false

--crypt-no-data-encryption

Option to either encrypt file data or leave it unencrypted.

Properties:

  • Config: no_data_encryption
  • Env Var: RCLONE_CRYPT_NO_DATA_ENCRYPTION
  • Type: bool
  • Default: false
  • Examples:
    • "true"
      • Don't encrypt file data, leave it unencrypted.
    • "false"
      • Encrypt file data.

--crypt-pass-bad-blocks

If set this will pass bad blocks through as all 0.

This should not be set in normal operation, it should only be set if trying to recover an encrypted file with errors and it is desired to recover as much of the file as possible.

Properties:

  • Config: pass_bad_blocks
  • Env Var: RCLONE_CRYPT_PASS_BAD_BLOCKS
  • Type: bool
  • Default: false

--crypt-strict-names

If set, this will raise an error when crypt comes across a filename that can't be decrypted.

(By default, rclone will just log a NOTICE and continue as normal.) This can happen if encrypted and unencrypted files are stored in the same directory (which is not recommended.) It may also indicate a more serious problem that should be investigated.

Properties:

  • Config: strict_names
  • Env Var: RCLONE_CRYPT_STRICT_NAMES
  • Type: bool
  • Default: false

--crypt-filename-encoding

How to encode the encrypted filename to text string.

This option could help with shortening the encrypted filename. The suitable option would depend on the way your remote count the filename length and if it's case sensitive.

Properties:

  • Config: filename_encoding
  • Env Var: RCLONE_CRYPT_FILENAME_ENCODING
  • Type: string
  • Default: "base32"
  • Examples:
    • "base32"
      • Encode using base32. Suitable for all remote.
    • "base64"
      • Encode using base64. Suitable for case sensitive remote.
    • "base32768"
      • Encode using base32768. Suitable if your remote counts UTF-16 or
      • Unicode codepoint instead of UTF-8 byte length. (Eg. Onedrive, Dropbox)

--crypt-suffix

If this is set it will override the default suffix of ".bin".

Setting suffix to "none" will result in an empty suffix. This may be useful when the path length is critical.

Properties:

  • Config: suffix
  • Env Var: RCLONE_CRYPT_SUFFIX
  • Type: string
  • Default: ".bin"

--crypt-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_CRYPT_DESCRIPTION
  • Type: string
  • Required: false

Metadata

Any metadata supported by the underlying remote is read and written.

See the metadata docs for more info.

Backend commands

Here are the commands specific to the crypt backend.

Run them with

rclone backend COMMAND remote:

The help below will explain what arguments each command takes.

See the backend command for more info on how to pass options and arguments.

These can be run on a running backend using the rc command backend/command.

encode

Encode the given filename(s)

rclone backend encode remote: [options] [<arguments>+]

This encodes the filenames given as arguments returning a list of strings of the encoded results.

Usage Example:

rclone backend encode crypt: file1 [file2...]
rclone rc backend/command command=encode fs=crypt: file1 [file2...]

decode

Decode the given filename(s)

rclone backend decode remote: [options] [<arguments>+]

This decodes the filenames given as arguments returning a list of strings of the decoded results. It will return an error if any of the inputs are invalid.

Usage Example:

rclone backend decode crypt: encryptedfile1 [encryptedfile2...]
rclone rc backend/command command=decode fs=crypt: encryptedfile1 [encryptedfile2...]

Backing up an encrypted remote

If you wish to backup an encrypted remote, it is recommended that you use rclone sync on the encrypted files, and make sure the passwords are the same in the new encrypted remote.

This will have the following advantages

  • rclone sync will check the checksums while copying
  • you can use rclone check between the encrypted remotes
  • you don't decrypt and encrypt unnecessarily

For example, let's say you have your original remote at remote: with the encrypted version at eremote: with path remote:crypt. You would then set up the new remote remote2: and then the encrypted version eremote2: with path remote2:crypt using the same passwords as eremote:.

To sync the two remotes you would do

rclone sync --interactive remote:crypt remote2:crypt

And to check the integrity you would do

rclone check remote:crypt remote2:crypt

File formats

File encryption

Files are encrypted 1:1 source file to destination object. The file has a header and is divided into chunks.

  • 8 bytes magic string RCLONE\x00\x00
  • 24 bytes Nonce (IV)

The initial nonce is generated from the operating systems crypto strong random number generator. The nonce is incremented for each chunk read making sure each nonce is unique for each block written. The chance of a nonce being reused is minuscule. If you wrote an exabyte of data (10¹⁸ bytes) you would have a probability of approximately 2×10⁻³² of reusing a nonce.

Chunk

Each chunk will contain 64 KiB of data, except for the last one which may have less data. The data chunk is in standard NaCl SecretBox format. SecretBox uses XSalsa20 and Poly1305 to encrypt and authenticate messages.

Each chunk contains:

  • 16 Bytes of Poly1305 authenticator
  • 1 - 65536 bytes XSalsa20 encrypted data

64k chunk size was chosen as the best performing chunk size (the authenticator takes too much time below this and the performance drops off due to cache effects above this). Note that these chunks are buffered in memory so they can't be too big.

This uses a 32 byte (256 bit key) key derived from the user password.

Examples

1 byte file will encrypt to

  • 32 bytes header
  • 17 bytes data chunk

49 bytes total

1 MiB (1048576 bytes) file will encrypt to

  • 32 bytes header
  • 16 chunks of 65568 bytes

1049120 bytes total (a 0.05% overhead). This is the overhead for big files.

Name encryption

File names are encrypted segment by segment - the path is broken up into / separated strings and these are encrypted individually.

File segments are padded using PKCS#7 to a multiple of 16 bytes before encryption.

They are then encrypted with EME using AES with 256 bit key. EME (ECB-Mix-ECB) is a wide-block encryption mode presented in the 2003 paper "A Parallelizable Enciphering Mode" by Halevi and Rogaway.

This makes for deterministic encryption which is what we want - the same filename must encrypt to the same thing otherwise we can't find it on the cloud storage system.

This means that

  • filenames with the same name will encrypt the same
  • filenames which start the same won't have a common prefix

This uses a 32 byte key (256 bits) and a 16 byte (128 bits) IV both of which are derived from the user password.

After encryption they are written out using a modified version of standard base32 encoding as described in RFC4648. The standard encoding is modified in two ways:

  • it becomes lower case (no-one likes upper case filenames!)
  • we strip the padding character =

base32 is used rather than the more efficient base64 so rclone can be used on case insensitive remotes (e.g. Windows, Box, Dropbox, Onedrive etc).

Key derivation

Rclone uses scrypt with parameters N=16384, r=8, p=1 with an optional user supplied salt (password2) to derive the 32+32+16 = 80 bytes of key material required. If the user doesn't supply a salt then rclone uses an internal one.

scrypt makes it impractical to mount a dictionary attack on rclone encrypted data. For full protection against this you should always use a salt.

SEE ALSO

Compress

Warning

This remote is currently experimental. Things may break and data may be lost. Anything you do with this remote is at your own risk. Please understand the risks associated with using experimental code and don't use this remote in critical applications.

The Compress remote adds compression to another remote. It is best used with remotes containing many large compressible files.

Configuration

To use this remote, all you need to do is specify another remote and a compression mode to use:

Current remotes:

Name                 Type
====                 ====
remote_to_press      sometype

e) Edit existing remote
$ rclone config
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> n
name> compress
...
 8 / Compress a remote
   \ "compress"
...
Storage> compress
** See help for compress backend at: https://rclone.org/compress/ **

Remote to compress.
Enter a string value. Press Enter for the default ("").
remote> remote_to_press:subdir 
Compression mode.
Enter a string value. Press Enter for the default ("gzip").
Choose a number from below, or type in your own value
 1 / Gzip compression balanced for speed and compression strength.
   \ "gzip"
compression_mode> gzip
Edit advanced config? (y/n)
y) Yes
n) No (default)
y/n> n
Remote config
--------------------
[compress]
type = compress
remote = remote_to_press:subdir
compression_mode = gzip
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Compression Modes

Currently only gzip compression is supported. It provides a decent balance between speed and size and is well supported by other applications. Compression strength can further be configured via an advanced setting where 0 is no compression and 9 is strongest compression.

File types

If you open a remote wrapped by compress, you will see that there are many files with an extension corresponding to the compression algorithm you chose. These files are standard files that can be opened by various archive programs, but they have some hidden metadata that allows them to be used by rclone. While you may download and decompress these files at will, do not manually delete or rename files. Files without correct metadata files will not be recognized by rclone.

File names

The compressed files will be named *.###########.gz where * is the base file and the # part is base64 encoded size of the uncompressed file. The file names should not be changed by anything other than the rclone compression backend.

Standard options

Here are the Standard options specific to compress (Compress a remote).

--compress-remote

Remote to compress.

Properties:

  • Config: remote
  • Env Var: RCLONE_COMPRESS_REMOTE
  • Type: string
  • Required: true

--compress-mode

Compression mode.

Properties:

  • Config: mode
  • Env Var: RCLONE_COMPRESS_MODE
  • Type: string
  • Default: "gzip"
  • Examples:
    • "gzip"
      • Standard gzip compression with fastest parameters.

Advanced options

Here are the Advanced options specific to compress (Compress a remote).

--compress-level

GZIP compression level (-2 to 9).

Generally -1 (default, equivalent to 5) is recommended. Levels 1 to 9 increase compression at the cost of speed. Going past 6 generally offers very little return.

Level -2 uses Huffman encoding only. Only use if you know what you are doing. Level 0 turns off compression.

Properties:

  • Config: level
  • Env Var: RCLONE_COMPRESS_LEVEL
  • Type: int
  • Default: -1

--compress-ram-cache-limit

Some remotes don't allow the upload of files with unknown size. In this case the compressed file will need to be cached to determine it's size.

Files smaller than this limit will be cached in RAM, files larger than this limit will be cached on disk.

Properties:

  • Config: ram_cache_limit
  • Env Var: RCLONE_COMPRESS_RAM_CACHE_LIMIT
  • Type: SizeSuffix
  • Default: 20Mi

--compress-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_COMPRESS_DESCRIPTION
  • Type: string
  • Required: false

Metadata

Any metadata supported by the underlying remote is read and written.

See the metadata docs for more info.

Combine

The combine backend joins remotes together into a single directory tree.

For example you might have a remote for images on one provider:

$ rclone tree s3:imagesbucket
/
├── image1.jpg
└── image2.jpg

And a remote for files on another:

$ rclone tree drive:important/files
/
├── file1.txt
└── file2.txt

The combine backend can join these together into a synthetic directory structure like this:

$ rclone tree combined:
/
├── files
│   ├── file1.txt
│   └── file2.txt
└── images
    ├── image1.jpg
    └── image2.jpg

You'd do this by specifying an upstreams parameter in the config like this

upstreams = images=s3:imagesbucket files=drive:important/files

During the initial setup with rclone config you will specify the upstreams remotes as a space separated list. The upstream remotes can either be a local paths or other remotes.

Configuration

Here is an example of how to make a combine called remote for the example above. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
...
XX / Combine several remotes into one
   \ (combine)
...
Storage> combine
Option upstreams.
Upstreams for combining
These should be in the form
    dir=remote:path dir2=remote2:path
Where before the = is specified the root directory and after is the remote to
put there.
Embedded spaces can be added using quotes
    "dir=remote:path with space" "dir2=remote2:path with space"
Enter a fs.SpaceSepList value.
upstreams> images=s3:imagesbucket files=drive:important/files
Configuration complete.
Options:
- type: combine
- upstreams: images=s3:imagesbucket files=drive:important/files
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Configuring for Google Drive Shared Drives

Rclone has a convenience feature for making a combine backend for all the shared drives you have access to.

Assuming your main (non shared drive) Google drive remote is called drive: you would run

rclone backend -o config drives drive:

This would produce something like this:

[My Drive]
type = alias
remote = drive,team_drive=0ABCDEF-01234567890,root_folder_id=:

[Test Drive]
type = alias
remote = drive,team_drive=0ABCDEFabcdefghijkl,root_folder_id=:

[AllDrives]
type = combine
upstreams = "My Drive=My Drive:" "Test Drive=Test Drive:"

If you then add that config to your config file (find it with rclone config file) then you can access all the shared drives in one place with the AllDrives: remote.

See the Google Drive docs for full info.

Standard options

Here are the Standard options specific to combine (Combine several remotes into one).

--combine-upstreams

Upstreams for combining

These should be in the form

dir=remote:path dir2=remote2:path

Where before the = is specified the root directory and after is the remote to put there.

Embedded spaces can be added using quotes

"dir=remote:path with space" "dir2=remote2:path with space"

Properties:

  • Config: upstreams
  • Env Var: RCLONE_COMBINE_UPSTREAMS
  • Type: SpaceSepList
  • Default:

Advanced options

Here are the Advanced options specific to combine (Combine several remotes into one).

--combine-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_COMBINE_DESCRIPTION
  • Type: string
  • Required: false

Metadata

Any metadata supported by the underlying remote is read and written.

See the metadata docs for more info.

DOI

The DOI remote is a read only remote for reading files from digital object identifiers (DOI).

Currently, the DOI backend supports DOIs hosted with: - InvenioRDM - Zenodo - CaltechDATA - Other InvenioRDM repositories - Dataverse - Harvard Dataverse - Other Dataverse repositories

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Configuration

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
Enter name for new remote.
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / DOI datasets
   \ (doi)
[snip]
Storage> doi
Option doi.
The DOI or the doi.org URL.
Enter a value.
doi> 10.5281/zenodo.5876941
Edit advanced config?
y) Yes
n) No (default)
y/n> n
Configuration complete.
Options:
- type: doi
- doi: 10.5281/zenodo.5876941
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Standard options

Here are the Standard options specific to doi (DOI datasets).

--doi-doi

The DOI or the doi.org URL.

Properties:

  • Config: doi
  • Env Var: RCLONE_DOI_DOI
  • Type: string
  • Required: true

Advanced options

Here are the Advanced options specific to doi (DOI datasets).

--doi-provider

DOI provider.

The DOI provider can be set when rclone does not automatically recognize a supported DOI provider.

Properties:

  • Config: provider
  • Env Var: RCLONE_DOI_PROVIDER
  • Type: string
  • Required: false
  • Examples:
    • "auto"
      • Auto-detect provider
    • "zenodo"
      • Zenodo
    • "dataverse"
      • Dataverse
    • "invenio"
      • Invenio

--doi-doi-resolver-api-url

The URL of the DOI resolver API to use.

The DOI resolver can be set for testing or for cases when the the canonical DOI resolver API cannot be used.

Defaults to "https://doi.org/api".

Properties:

  • Config: doi_resolver_api_url
  • Env Var: RCLONE_DOI_DOI_RESOLVER_API_URL
  • Type: string
  • Required: false

--doi-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_DOI_DESCRIPTION
  • Type: string
  • Required: false

Backend commands

Here are the commands specific to the doi backend.

Run them with

rclone backend COMMAND remote:

The help below will explain what arguments each command takes.

See the backend command for more info on how to pass options and arguments.

These can be run on a running backend using the rc command backend/command.

metadata

Show metadata about the DOI.

rclone backend metadata remote: [options] [<arguments>+]

This command returns a JSON object with some information about the DOI.

rclone backend medatadata doi:

It returns a JSON object representing metadata about the DOI.

set

Set command for updating the config parameters.

rclone backend set remote: [options] [<arguments>+]

This set command can be used to update the config parameters for a running doi backend.

Usage Examples:

rclone backend set doi: [-o opt_name=opt_value] [-o opt_name2=opt_value2]
rclone rc backend/command command=set fs=doi: [-o opt_name=opt_value] [-o opt_name2=opt_value2]
rclone rc backend/command command=set fs=doi: -o doi=NEW_DOI

The option keys are named as they are in the config file.

This rebuilds the connection to the doi backend when it is called with the new parameters. Only new parameters need be passed as the values will default to those currently in use.

It doesn't return anything.

Dropbox

Paths are specified as remote:path

Dropbox paths may be as deep as required, e.g. remote:directory/subdirectory.

Configuration

The initial setup for dropbox involves getting a token from Dropbox which you need to do in your browser. rclone config walks you through it.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

n) New remote
d) Delete remote
q) Quit config
e/n/d/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Dropbox
   \ "dropbox"
[snip]
Storage> dropbox
Dropbox App Key - leave blank normally.
app_key>
Dropbox App Secret - leave blank normally.
app_secret>
Remote config
Please visit:
https://www.dropbox.com/1/oauth2/authorize?client_id=XXXXXXXXXXXXXXX&response_type=code
Enter the code: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX_XXXXXXXXXX
Configuration complete.
Options:
- type: dropbox
- app_key:
- app_secret:
- token: XXXXXXXXXXXXXXXXXXXXXXXXXXXXX_XXXX_XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

See the remote setup docs for how to set it up on a machine with no Internet browser available.

Note that rclone runs a webserver on your local machine to collect the token as returned from Dropbox. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and it may require you to unblock it temporarily if you are running a host firewall, or use manual mode.

You can then use it like this,

List directories in top level of your dropbox

rclone lsd remote:

List all the files in your dropbox

rclone ls remote:

To copy a local directory to a dropbox directory called backup

rclone copy /home/source remote:backup

Dropbox for business

Rclone supports Dropbox for business and Team Folders.

When using Dropbox for business remote: and remote:path/to/file will refer to your personal folder.

If you wish to see Team Folders you must use a leading / in the path, so rclone lsd remote:/ will refer to the root and show you all Team Folders and your User Folder.

You can then use team folders like this remote:/TeamFolder and remote:/TeamFolder/path/to/file.

A leading / for a Dropbox personal account will do nothing, but it will take an extra HTTP transaction so it should be avoided.

Modification times and hashes

Dropbox supports modified times, but the only way to set a modification time is to re-upload the file.

This means that if you uploaded your data with an older version of rclone which didn't support the v2 API and modified times, rclone will decide to upload all your old data to fix the modification times. If you don't want this to happen use --size-only or --checksum flag to stop it.

Dropbox supports its own hash type which is checked for all transfers.

Restricted filename characters

Character Value Replacement
NUL 0x00 ␀
/ 0x2F ／
DEL 0x7F ␡
\ 0x5C ＼

File names can also not end with the following characters. These only get replaced if they are the last character in the name:

Character Value Replacement
SP 0x20 ␠

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Batch mode uploads

Using batch mode uploads is very important for performance when using the Dropbox API. See the dropbox performance guide for more info.

There are 3 modes rclone can use for uploads.

--dropbox-batch-mode off

In this mode rclone will not use upload batching. This was the default before rclone v1.55. It has the disadvantage that it is very likely to encounter too_many_requests errors like this

NOTICE: too_many_requests/.: Too many requests or write operations. Trying again in 15 seconds.

When rclone receives these it has to wait for 15s or sometimes 300s before continuing which really slows down transfers.

This will happen especially if --transfers is large, so this mode isn't recommended except for compatibility or investigating problems.

--dropbox-batch-mode sync

In this mode rclone will batch up uploads to the size specified by --dropbox-batch-size and commit them together.

Using this mode means you can use a much higher --transfers parameter (32 or 64 works fine) without receiving too_many_requests errors.

This mode ensures full data integrity.

Note that there may be a pause when quitting rclone while rclone finishes up the last batch using this mode.

--dropbox-batch-mode async

In this mode rclone will batch up uploads to the size specified by --dropbox-batch-size and commit them together.

However it will not wait for the status of the batch to be returned to the caller. This means rclone can use a much bigger batch size (much bigger than --transfers), at the cost of not being able to check the status of the upload.

This provides the maximum possible upload speed especially with lots of small files, however rclone can't check the file got uploaded properly using this mode.

If you are using this mode then using "rclone check" after the transfer completes is recommended. Or you could do an initial transfer with --dropbox-batch-mode async then do a final transfer with --dropbox-batch-mode sync (the default).

Note that there may be a pause when quitting rclone while rclone finishes up the last batch using this mode.

Exporting files

Certain files in Dropbox are "exportable", such as Dropbox Paper documents. These files need to be converted to another format in order to be downloaded. Often multiple formats are available for conversion.

When rclone downloads a exportable file, it chooses the format to download based on the --dropbox-export-formats setting. By default, the export formats are html,md, which are sensible defaults for Dropbox Paper.

Rclone chooses the first format ID in the export formats list that Dropbox supports for a given file. If no format in the list is usable, rclone will choose the default format that Dropbox suggests.

Rclone will change the extension to correspond to the export format. Here are some examples of how extensions are mapped:

File type Filename in Dropbox Filename in rclone
Paper mydoc.paper mydoc.html
Paper template mydoc.papert mydoc.papert.html
other mydoc mydoc.html

Importing exportable files is not yet supported by rclone.

Here are the supported export extensions known by rclone. Note that rclone does not currently support other formats not on this list, even if Dropbox supports them. Also, Dropbox could change the list of supported formats at any time.

Format ID Name Description
html HTML HTML document
md Markdown Markdown text format

Standard options

Here are the Standard options specific to dropbox (Dropbox).

--dropbox-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_DROPBOX_CLIENT_ID
  • Type: string
  • Required: false

--dropbox-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_DROPBOX_CLIENT_SECRET
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to dropbox (Dropbox).

--dropbox-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_DROPBOX_TOKEN
  • Type: string
  • Required: false

--dropbox-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_DROPBOX_AUTH_URL
  • Type: string
  • Required: false

--dropbox-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_DROPBOX_TOKEN_URL
  • Type: string
  • Required: false

--dropbox-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_DROPBOX_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--dropbox-chunk-size

Upload chunk size (< 150Mi).

Any files larger than this will be uploaded in chunks of this size.

Note that chunks are buffered in memory (one at a time) so rclone can deal with retries. Setting this larger will increase the speed slightly (at most 10% for 128 MiB in tests) at the cost of using more memory. It can be set smaller if you are tight on memory.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_DROPBOX_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 48Mi

--dropbox-impersonate

Impersonate this user when using a business account.

Note that if you want to use impersonate, you should make sure this flag is set when running "rclone config" as this will cause rclone to request the "members.read" scope which it won't normally. This is needed to lookup a members email address into the internal ID that dropbox uses in the API.

Using the "members.read" scope will require a Dropbox Team Admin to approve during the OAuth flow.

You will have to use your own App (setting your own client_id and client_secret) to use this option as currently rclone's default set of permissions doesn't include "members.read". This can be added once v1.55 or later is in use everywhere.

Properties:

  • Config: impersonate
  • Env Var: RCLONE_DROPBOX_IMPERSONATE
  • Type: string
  • Required: false

--dropbox-shared-files

Instructs rclone to work on individual shared files.

In this mode rclone's features are extremely limited - only list (ls, lsl, etc.) operations and read operations (e.g. downloading) are supported in this mode. All other operations will be disabled.

Properties:

  • Config: shared_files
  • Env Var: RCLONE_DROPBOX_SHARED_FILES
  • Type: bool
  • Default: false

--dropbox-shared-folders

Instructs rclone to work on shared folders.

When this flag is used with no path only the List operation is supported and all available shared folders will be listed. If you specify a path the first part will be interpreted as the name of shared folder. Rclone will then try to mount this shared to the root namespace. On success shared folder rclone proceeds normally. The shared folder is now pretty much a normal folder and all normal operations are supported.

Note that we don't unmount the shared folder afterwards so the --dropbox-shared-folders can be omitted after the first use of a particular shared folder.

See also --dropbox-root-namespace for an alternative way to work with shared folders.

Properties:

  • Config: shared_folders
  • Env Var: RCLONE_DROPBOX_SHARED_FOLDERS
  • Type: bool
  • Default: false

--dropbox-pacer-min-sleep

Minimum time to sleep between API calls.

Properties:

  • Config: pacer_min_sleep
  • Env Var: RCLONE_DROPBOX_PACER_MIN_SLEEP
  • Type: Duration
  • Default: 10ms

--dropbox-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_DROPBOX_ENCODING
  • Type: Encoding
  • Default: Slash,BackSlash,Del,RightSpace,InvalidUtf8,Dot

--dropbox-root-namespace

Specify a different Dropbox namespace ID to use as the root for all paths.

Properties:

  • Config: root_namespace
  • Env Var: RCLONE_DROPBOX_ROOT_NAMESPACE
  • Type: string
  • Required: false

--dropbox-export-formats

Comma separated list of preferred formats for exporting files

Certain Dropbox files can only be accessed by exporting them to another format. These include Dropbox Paper documents.

For each such file, rclone will choose the first format on this list that Dropbox considers valid. If none is valid, it will choose Dropbox's default format.

Known formats include: "html", "md" (markdown)

Properties:

  • Config: export_formats
  • Env Var: RCLONE_DROPBOX_EXPORT_FORMATS
  • Type: CommaSepList
  • Default: html,md

--dropbox-skip-exports

Skip exportable files in all listings.

If given, exportable files practically become invisible to rclone.

Properties:

  • Config: skip_exports
  • Env Var: RCLONE_DROPBOX_SKIP_EXPORTS
  • Type: bool
  • Default: false

--dropbox-show-all-exports

Show all exportable files in listings.

Adding this flag will allow all exportable files to be server side copied. Note that rclone doesn't add extensions to the exportable file names in this mode.

Do not use this flag when trying to download exportable files - rclone will fail to download them.

Properties:

  • Config: show_all_exports
  • Env Var: RCLONE_DROPBOX_SHOW_ALL_EXPORTS
  • Type: bool
  • Default: false

--dropbox-batch-mode

Upload file batching sync|async|off.

This sets the batch mode used by rclone.

For full info see the main docs

This has 3 possible values

  • off - no batching
  • sync - batch uploads and check completion (default)
  • async - batch upload and don't check completion

Rclone will close any outstanding batches when it exits which may make a delay on quit.

Properties:

  • Config: batch_mode
  • Env Var: RCLONE_DROPBOX_BATCH_MODE
  • Type: string
  • Default: "sync"

--dropbox-batch-size

Max number of files in upload batch.

This sets the batch size of files to upload. It has to be less than 1000.

By default this is 0 which means rclone will calculate the batch size depending on the setting of batch_mode.

  • batch_mode: async - default batch_size is 100
  • batch_mode: sync - default batch_size is the same as --transfers
  • batch_mode: off - not in use

Rclone will close any outstanding batches when it exits which may make a delay on quit.

Setting this is a great idea if you are uploading lots of small files as it will make them a lot quicker. You can use --transfers 32 to maximise throughput.

Properties:

  • Config: batch_size
  • Env Var: RCLONE_DROPBOX_BATCH_SIZE
  • Type: int
  • Default: 0

--dropbox-batch-timeout

Max time to allow an idle upload batch before uploading.

If an upload batch is idle for more than this long then it will be uploaded.

The default for this is 0 which means rclone will choose a sensible default based on the batch_mode in use.

  • batch_mode: async - default batch_timeout is 10s
  • batch_mode: sync - default batch_timeout is 500ms
  • batch_mode: off - not in use

Properties:

  • Config: batch_timeout
  • Env Var: RCLONE_DROPBOX_BATCH_TIMEOUT
  • Type: Duration
  • Default: 0s

--dropbox-batch-commit-timeout

Max time to wait for a batch to finish committing. (no longer used)

Properties:

  • Config: batch_commit_timeout
  • Env Var: RCLONE_DROPBOX_BATCH_COMMIT_TIMEOUT
  • Type: Duration
  • Default: 10m0s

--dropbox-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_DROPBOX_DESCRIPTION
  • Type: string
  • Required: false

Limitations

Note that Dropbox is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc".

There are some file names such as thumbs.db which Dropbox can't store. There is a full list of them in the "Ignored Files" section of this document. Rclone will issue an error message File name disallowed - not uploading if it attempts to upload one of those file names, but the sync won't fail.

Some errors may occur if you try to sync copyright-protected files because Dropbox has its own copyright detector that prevents this sort of file being downloaded. This will return the error ERROR : /path/to/your/file: Failed to copy: failed to open source object: path/restricted_content/.

If you have more than 10,000 files in a directory then rclone purge dropbox:dir will return the error Failed to purge: There are too many files involved in this operation. As a work-around do an rclone delete dropbox:dir followed by an rclone rmdir dropbox:dir.

When using rclone link you'll need to set --expire if using a non-personal account otherwise the visibility may not be correct. (Note that --expire isn't supported on personal accounts). See the forum discussion and the dropbox SDK issue.

Modification times for Dropbox Paper documents are not exact, and may not change for some period after the document is edited. To make sure you get recent changes in a sync, either wait an hour or so, or use --ignore-times to force a full sync.

Get your own Dropbox App ID

When you use rclone with Dropbox in its default configuration you are using rclone's App ID. This is shared between all the rclone users.

Here is how to create your own Dropbox App ID for rclone:

  1. Log into the Dropbox App console with your Dropbox Account (It need not to be the same account as the Dropbox you want to access)

  2. Choose an API => Usually this should be Dropbox API

  3. Choose the type of access you want to use => Full Dropbox or App Folder. If you want to use Team Folders, Full Dropbox is required (see here).

  4. Name your App. The app name is global, so you can't use rclone for example

  5. Click the button Create App

  6. Switch to the Permissions tab. Enable at least the following permissions: account_info.read, files.metadata.write, files.content.write, files.content.read, sharing.write. The files.metadata.read and sharing.read checkboxes will be marked too. Click Submit

  7. Switch to the Settings tab. Fill OAuth2 - Redirect URIs as http://localhost:53682/ and click on Add

  8. Find the App key and App secret values on the Settings tab. Use these values in rclone config to add a new remote or edit an existing remote. The App key setting corresponds to client_id in rclone config, the App secret corresponds to client_secret

Enterprise File Fabric

This backend supports Storage Made Easy's Enterprise File Fabric™ which provides a software solution to integrate and unify File and Object Storage accessible through a global file system.

Configuration

The initial setup for the Enterprise File Fabric backend involves getting a token from the Enterprise File Fabric which you need to do in your browser. rclone config walks you through it.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Enterprise File Fabric
   \ "filefabric"
[snip]
Storage> filefabric
** See help for filefabric backend at: https://rclone.org/filefabric/ **

URL of the Enterprise File Fabric to connect to
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / Storage Made Easy US
   \ "https://storagemadeeasy.com"
 2 / Storage Made Easy EU
   \ "https://eu.storagemadeeasy.com"
 3 / Connect to your Enterprise File Fabric
   \ "https://yourfabric.smestorage.com"
url> https://yourfabric.smestorage.com/
ID of the root folder
Leave blank normally.

Fill in to make rclone start with directory of a given ID.

Enter a string value. Press Enter for the default ("").
root_folder_id> 
Permanent Authentication Token

A Permanent Authentication Token can be created in the Enterprise File
Fabric, on the users Dashboard under Security, there is an entry
you'll see called "My Authentication Tokens". Click the Manage button
to create one.

These tokens are normally valid for several years.

For more info see: https://docs.storagemadeeasy.com/organisationcloud/api-tokens

Enter a string value. Press Enter for the default ("").
permanent_token> xxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx
Edit advanced config? (y/n)
y) Yes
n) No (default)
y/n> n
Remote config
Configuration complete.
Options:
- type: filefabric
- url: https://yourfabric.smestorage.com/
- permanent_token: xxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Once configured you can then use rclone like this,

List directories in top level of your Enterprise File Fabric

rclone lsd remote:

List all the files in your Enterprise File Fabric

rclone ls remote:

To copy a local directory to an Enterprise File Fabric directory called backup

rclone copy /home/source remote:backup

Modification times and hashes

The Enterprise File Fabric allows modification times to be set on files accurate to 1 second. These will be used to detect whether objects need syncing or not.

The Enterprise File Fabric does not support any data hashes at this time.

Restricted filename characters

The default restricted characters set will be replaced.

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Empty files

Empty files aren't supported by the Enterprise File Fabric. Rclone will therefore upload an empty file as a single space with a mime type of application/vnd.rclone.empty.file and files with that mime type are treated as empty.

Root folder ID

You can set the root_folder_id for rclone. This is the directory (identified by its Folder ID) that rclone considers to be the root of your Enterprise File Fabric.

Normally you will leave this blank and rclone will determine the correct root to use itself.

However you can set this to restrict rclone to a specific folder hierarchy.

In order to do this you will have to find the Folder ID of the directory you wish rclone to display. These aren't displayed in the web interface, but you can use rclone lsf to find them, for example

$ rclone lsf --dirs-only -Fip --csv filefabric:
120673758,Burnt PDFs/
120673759,My Quick Uploads/
120673755,My Syncs/
120673756,My backups/
120673757,My contacts/
120673761,S3 Storage/

The ID for "S3 Storage" would be 120673761.

Standard options

Here are the Standard options specific to filefabric (Enterprise File Fabric).

--filefabric-url

URL of the Enterprise File Fabric to connect to.

Properties:

  • Config: url
  • Env Var: RCLONE_FILEFABRIC_URL
  • Type: string
  • Required: true
  • Examples:
    • "https://storagemadeeasy.com"
      • Storage Made Easy US
    • "https://eu.storagemadeeasy.com"
      • Storage Made Easy EU
    • "https://yourfabric.smestorage.com"
      • Connect to your Enterprise File Fabric

--filefabric-root-folder-id

ID of the root folder.

Leave blank normally.

Fill in to make rclone start with directory of a given ID.

Properties:

  • Config: root_folder_id
  • Env Var: RCLONE_FILEFABRIC_ROOT_FOLDER_ID
  • Type: string
  • Required: false

--filefabric-permanent-token

Permanent Authentication Token.

A Permanent Authentication Token can be created in the Enterprise File Fabric, on the users Dashboard under Security, there is an entry you'll see called "My Authentication Tokens". Click the Manage button to create one.

These tokens are normally valid for several years.

For more info see: https://docs.storagemadeeasy.com/organisationcloud/api-tokens

Properties:

  • Config: permanent_token
  • Env Var: RCLONE_FILEFABRIC_PERMANENT_TOKEN
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to filefabric (Enterprise File Fabric).

--filefabric-token

Session Token.

This is a session token which rclone caches in the config file. It is usually valid for 1 hour.

Don't set this value - rclone will set it automatically.

Properties:

  • Config: token
  • Env Var: RCLONE_FILEFABRIC_TOKEN
  • Type: string
  • Required: false

--filefabric-token-expiry

Token expiry time.

Don't set this value - rclone will set it automatically.

Properties:

  • Config: token_expiry
  • Env Var: RCLONE_FILEFABRIC_TOKEN_EXPIRY
  • Type: string
  • Required: false

--filefabric-version

Version read from the file fabric.

Don't set this value - rclone will set it automatically.

Properties:

  • Config: version
  • Env Var: RCLONE_FILEFABRIC_VERSION
  • Type: string
  • Required: false

--filefabric-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_FILEFABRIC_ENCODING
  • Type: Encoding
  • Default: Slash,Del,Ctl,InvalidUtf8,Dot

--filefabric-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_FILEFABRIC_DESCRIPTION
  • Type: string
  • Required: false

FileLu

FileLu is a reliable cloud storage provider offering features like secure file uploads, downloads, flexible storage options, and sharing capabilities. With support for high storage limits and seamless integration with rclone, FileLu makes managing files in the cloud easy. Its cross-platform file backup services let you upload and back up files from any internet-connected device.

Configuration

Here is an example of how to make a remote called filelu. First, run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> filelu
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
xx / FileLu Cloud Storage
   \ "filelu"
[snip]
Storage> filelu
Enter your FileLu Rclone Key:
key> YOUR_FILELU_RCLONE_KEY RC_xxxxxxxxxxxxxxxxxxxxxxxx
Configuration complete.

Keep this "filelu" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

Paths

A path without an initial / will operate in the Rclone directory.

A path with an initial / will operate at the root where you can see the Rclone directory.

$ rclone lsf TestFileLu:/
CCTV/
Camera/
Documents/
Music/
Photos/
Rclone/
Vault/
Videos/

Example Commands

Create a new folder named foldername in the Rclone directory:

rclone mkdir filelu:foldername

Delete a folder on FileLu:

rclone rmdir filelu:/folder/path/

Delete a file on FileLu:

rclone delete filelu:/hello.txt

List files from your FileLu account:

rclone ls filelu:

List all folders:

rclone lsd filelu:

Copy a specific file to the FileLu root:

rclone copy D:\\hello.txt filelu:

Copy files from a local directory to a FileLu directory:

rclone copy D:/local-folder filelu:/remote-folder/path/

Download a file from FileLu into a local directory:

rclone copy filelu:/file-path/hello.txt D:/local-folder

Move files from a local directory to a FileLu directory:

rclone move D:\\local-folder filelu:/remote-path/

Sync files from a local directory to a FileLu directory:

rclone sync --interactive D:/local-folder filelu:/remote-path/

Mount remote to local Linux:

rclone mount filelu: /root/mnt --vfs-cache-mode full

Mount remote to local Windows:

rclone mount filelu: D:/local_mnt --vfs-cache-mode full

Get storage info about the FileLu account:

rclone about filelu:

All the other rclone commands are supported by this backend.

FolderID instead of folder path

We use the FolderID instead of the folder name to prevent errors when users have identical folder names or paths. For example, if a user has two or three folders named "test_folders," the system may become confused and won't know which folder to move. In large storage systems, some clients have hundred of thousands of folders and a few millions of files, duplicate folder names or paths are quite common.

Modification Times and Hashes

FileLu supports both modification times and MD5 hashes.

FileLu only supports filenames and folder names up to 255 characters in length, where a character is a Unicode character.

Duplicated Files

When uploading and syncing via Rclone, FileLu does not allow uploading duplicate files within the same directory. However, you can upload duplicate files, provided they are in different directories (folders).

Failure to Log / Invalid Credentials or KEY

Ensure that you have the correct Rclone key, which can be found in My Account. Every time you toggle Rclone OFF and ON in My Account, a new RC_xxxxxxxxxxxxxxxxxxxx key is generated. Be sure to update your Rclone configuration with the new key.

If you are connecting to your FileLu remote for the first time and encounter an error such as:

Failed to create file system for "my-filelu-remote:": couldn't login: Invalid credentials

Ensure your Rclone Key is correct.

Process killed

Accounts with large files or extensive metadata may experience significant memory usage during list/sync operations. Ensure the system running rclone has sufficient memory and CPU to handle these operations.

Standard options

Here are the Standard options specific to filelu (FileLu Cloud Storage).

--filelu-key

Your FileLu Rclone key from My Account

Properties:

  • Config: key
  • Env Var: RCLONE_FILELU_KEY
  • Type: string
  • Required: true

Advanced options

Here are the Advanced options specific to filelu (FileLu Cloud Storage).

--filelu-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_FILELU_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,SingleQuote,BackQuote,Dollar,Colon,Question,Asterisk,Pipe,Hash,Percent,BackSlash,CrLf,Del,Ctl,LeftSpace,LeftPeriod,LeftTilde,LeftCrLfHtVt,RightSpace,RightPeriod,RightCrLfHtVt,InvalidUtf8,Dot,SquareBracket,Semicolon,Exclamation

--filelu-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_FILELU_DESCRIPTION
  • Type: string
  • Required: false

Limitations

This backend uses a custom library implementing the FileLu API. While it supports file transfers, some advanced features may not yet be available. Please report any issues to the rclone forum for troubleshooting and updates.

For further information, visit FileLu's website.

Files.com

Files.com is a cloud storage service that provides a secure and easy way to store and share files.

The initial setup for filescom involves authenticating with your Files.com account. You can do this by providing your site subdomain, username, and password. Alternatively, you can authenticate using an API Key from Files.com. rclone config walks you through it.

Configuration

Here is an example of how to make a remote called remote. First run:

rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter name for new remote.
name> remote

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / Files.com
  \ "filescom"
[snip]
Storage> filescom

Option site.
Your site subdomain (e.g. mysite) or custom domain (e.g. myfiles.customdomain.com)
Enter a value. Press Enter to leave empty.
site> mysite

Option username.
The username used to authenticate with Files.com.
Enter a value. Press Enter to leave empty.
username> user

Option password.
The password used to authenticate with Files.com.
Choose an alternative below. Press Enter for the default (n).
y) Yes, type in my own password
g) Generate random password
n) No, leave this optional password blank (default)
y/g/n> y
Enter the password:
password:
Confirm the password:
password:

Edit advanced config?
y) Yes
n) No (default)
y/n> n

Configuration complete.
Options:
- type: filescom
- site: mysite
- username: user
- password: *** ENCRYPTED ***
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Once configured you can use rclone.

See all files in the top level:

rclone lsf remote:

Make a new directory in the root:

rclone mkdir remote:dir

Recursively List the contents:

rclone ls remote:

Sync /home/local/directory to the remote directory, deleting any excess files in the directory.

rclone sync --interactive /home/local/directory remote:dir

Hashes

In December 2024 files.com started supporting more checksums.

However if you want hashes you must enable them in your site by visiting the "File Integrity" section in "Data Governance" to configure your settings and select the checksum algorithms that meet your requirements.

Rclone currently only support CRC32 and MD5 for use in syncing but selecting more checksums will not affect rclone's operations.

For use with rclone, selecting at least MD5 is recommended so rclone can do an end to end integrity check.

Standard options

Here are the Standard options specific to filescom (Files.com).

--filescom-site

Your site subdomain (e.g. mysite) or custom domain (e.g. myfiles.customdomain.com).

Properties:

  • Config: site
  • Env Var: RCLONE_FILESCOM_SITE
  • Type: string
  • Required: false

--filescom-username

The username used to authenticate with Files.com.

Properties:

  • Config: username
  • Env Var: RCLONE_FILESCOM_USERNAME
  • Type: string
  • Required: false

--filescom-password

The password used to authenticate with Files.com.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: password
  • Env Var: RCLONE_FILESCOM_PASSWORD
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to filescom (Files.com).

--filescom-api-key

The API key used to authenticate with Files.com.

Properties:

  • Config: api_key
  • Env Var: RCLONE_FILESCOM_API_KEY
  • Type: string
  • Required: false

--filescom-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_FILESCOM_ENCODING
  • Type: Encoding
  • Default: Slash,BackSlash,Del,Ctl,RightSpace,RightCrLfHtVt,InvalidUtf8,Dot

--filescom-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_FILESCOM_DESCRIPTION
  • Type: string
  • Required: false

FTP

FTP is the File Transfer Protocol. Rclone FTP support is provided using the github.com/jlaffaye/ftp package.

Limitations of Rclone's FTP backend

Paths are specified as remote:path. If the path does not begin with a / it is relative to the home directory of the user. An empty path remote: refers to the user's home directory.

Configuration

To create an FTP configuration named remote, run

rclone config

Rclone config guides you through an interactive setup process. A minimal rclone FTP remote definition only requires host, username and password. For an anonymous FTP server, see below.

No remotes found, make a new one?
n) New remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
n/r/c/s/q> n
name> remote
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / FTP
   \ "ftp"
[snip]
Storage> ftp
** See help for ftp backend at: https://rclone.org/ftp/ **

FTP host to connect to
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / Connect to ftp.example.com
   \ "ftp.example.com"
host> ftp.example.com
FTP username
Enter a string value. Press Enter for the default ("$USER").
user> 
FTP port number
Enter a signed integer. Press Enter for the default (21).
port> 
FTP password
y) Yes type in my own password
g) Generate random password
y/g> y
Enter the password:
password:
Confirm the password:
password:
Use FTP over TLS (Implicit)
Enter a boolean value (true or false). Press Enter for the default ("false").
tls> 
Use FTP over TLS (Explicit)
Enter a boolean value (true or false). Press Enter for the default ("false").
explicit_tls> 
Remote config
Configuration complete.
Options:
- type: ftp
- host: ftp.example.com
- pass: *** ENCRYPTED ***
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

To see all directories in the home directory of remote

rclone lsd remote:

Make a new directory

rclone mkdir remote:path/to/directory

List the contents of a directory

rclone ls remote:path/to/directory

Sync /home/local/directory to the remote directory, deleting any excess files in the directory.

rclone sync --interactive /home/local/directory remote:directory

Anonymous FTP

When connecting to a FTP server that allows anonymous login, you can use the special "anonymous" username. Traditionally, this user account accepts any string as a password, although it is common to use either the password "anonymous" or "guest". Some servers require the use of a valid e-mail address as password.

Using on-the-fly or connection string remotes makes it easy to access such servers, without requiring any configuration in advance. The following are examples of that:

rclone lsf :ftp: --ftp-host=speedtest.tele2.net --ftp-user=anonymous --ftp-pass=$(rclone obscure dummy)
rclone lsf :ftp,host=speedtest.tele2.net,user=anonymous,pass=$(rclone obscure dummy):

The above examples work in Linux shells and in PowerShell, but not Windows Command Prompt. They execute the rclone obscure command to create a password string in the format required by the pass option. The following examples are exactly the same, except use an already obscured string representation of the same password "dummy", and therefore works even in Windows Command Prompt:

rclone lsf :ftp: --ftp-host=speedtest.tele2.net --ftp-user=anonymous --ftp-pass=IXs2wc8OJOz7SYLBk47Ji1rHTmxM
rclone lsf :ftp,host=speedtest.tele2.net,user=anonymous,pass=IXs2wc8OJOz7SYLBk47Ji1rHTmxM:

Implicit TLS

Rlone FTP supports implicit FTP over TLS servers (FTPS). This has to be enabled in the FTP backend config for the remote, or with --ftp-tls. The default FTPS port is 990, not 21 and can be set with --ftp-port.

TLS Options

TLS options for Implicit and Explicit TLS can be set using the following flags which are specific to the FTP backend:

--ftp-no-check-certificate     Do not verify the TLS certificate of the server
--ftp-disable-tls13            Disable TLS 1.3 (workaround for FTP servers with buggy TLS)
--ftp-tls-cache-size int       Size of TLS session cache for all control and data connections (default 32)

However any of the global TLS flags can also be used such as:

--ca-cert stringArray          CA certificate used to verify servers
--client-cert string           Client SSL certificate (PEM) for mutual TLS auth
--client-key string            Client SSL private key (PEM) for mutual TLS auth
--no-check-certificate         Do not verify the server SSL certificate (insecure)

If these need to be put in the config file so they apply to just the FTP backend then use the override syntax, eg

override.ca_cert = XXX
override.client_cert = XXX
override.client_key = XXX

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

File names cannot end with the following characters. Replacement is limited to the last character in a file name:

Character Value Replacement
SP 0x20 ␠

Not all FTP servers can have all characters in file names, for example:

FTP Server Forbidden characters
proftpd *
pureftpd \ [ ]

This backend's interactive configuration wizard provides a selection of sensible encoding settings for major FTP servers: ProFTPd, PureFTPd, VsFTPd. Just hit a selection number when prompted.

Standard options

Here are the Standard options specific to ftp (FTP).

--ftp-host

FTP host to connect to.

E.g. "ftp.example.com".

Properties:

  • Config: host
  • Env Var: RCLONE_FTP_HOST
  • Type: string
  • Required: true

--ftp-user

FTP username.

Properties:

  • Config: user
  • Env Var: RCLONE_FTP_USER
  • Type: string
  • Default: "$USER"

--ftp-port

FTP port number.

Properties:

  • Config: port
  • Env Var: RCLONE_FTP_PORT
  • Type: int
  • Default: 21

--ftp-pass

FTP password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: pass
  • Env Var: RCLONE_FTP_PASS
  • Type: string
  • Required: false

--ftp-tls

Use Implicit FTPS (FTP over TLS).

When using implicit FTP over TLS the client connects using TLS right from the start which breaks compatibility with non-TLS-aware servers. This is usually served over port 990 rather than port 21. Cannot be used in combination with explicit FTPS.

Properties:

  • Config: tls
  • Env Var: RCLONE_FTP_TLS
  • Type: bool
  • Default: false

--ftp-explicit-tls

Use Explicit FTPS (FTP over TLS).

When using explicit FTP over TLS the client explicitly requests security from the server in order to upgrade a plain text connection to an encrypted one. Cannot be used in combination with implicit FTPS.

Properties:

  • Config: explicit_tls
  • Env Var: RCLONE_FTP_EXPLICIT_TLS
  • Type: bool
  • Default: false

Advanced options

Here are the Advanced options specific to ftp (FTP).

--ftp-concurrency

Maximum number of FTP simultaneous connections, 0 for unlimited.

Note that setting this is very likely to cause deadlocks so it should be used with care.

If you are doing a sync or copy then make sure concurrency is one more than the sum of --transfers and --checkers.

If you use --check-first then it just needs to be one more than the maximum of --checkers and --transfers.

So for concurrency 3 you'd use --checkers 2 --transfers 2 --check-first or --checkers 1 --transfers 1.

Properties:

  • Config: concurrency
  • Env Var: RCLONE_FTP_CONCURRENCY
  • Type: int
  • Default: 0

--ftp-no-check-certificate

Do not verify the TLS certificate of the server.

Properties:

  • Config: no_check_certificate
  • Env Var: RCLONE_FTP_NO_CHECK_CERTIFICATE
  • Type: bool
  • Default: false

--ftp-disable-epsv

Disable using EPSV even if server advertises support.

Properties:

  • Config: disable_epsv
  • Env Var: RCLONE_FTP_DISABLE_EPSV
  • Type: bool
  • Default: false

--ftp-disable-mlsd

Disable using MLSD even if server advertises support.

Properties:

  • Config: disable_mlsd
  • Env Var: RCLONE_FTP_DISABLE_MLSD
  • Type: bool
  • Default: false

--ftp-disable-utf8

Disable using UTF-8 even if server advertises support.

Properties:

  • Config: disable_utf8
  • Env Var: RCLONE_FTP_DISABLE_UTF8
  • Type: bool
  • Default: false

--ftp-writing-mdtm

Use MDTM to set modification time (VsFtpd quirk)

Properties:

  • Config: writing_mdtm
  • Env Var: RCLONE_FTP_WRITING_MDTM
  • Type: bool
  • Default: false

--ftp-force-list-hidden

Use LIST -a to force listing of hidden files and folders. This will disable the use of MLSD.

Properties:

  • Config: force_list_hidden
  • Env Var: RCLONE_FTP_FORCE_LIST_HIDDEN
  • Type: bool
  • Default: false

--ftp-idle-timeout

Max time before closing idle connections.

If no connections have been returned to the connection pool in the time given, rclone will empty the connection pool.

Set to 0 to keep connections indefinitely.

Properties:

  • Config: idle_timeout
  • Env Var: RCLONE_FTP_IDLE_TIMEOUT
  • Type: Duration
  • Default: 1m0s

--ftp-close-timeout

Maximum time to wait for a response to close.

Properties:

  • Config: close_timeout
  • Env Var: RCLONE_FTP_CLOSE_TIMEOUT
  • Type: Duration
  • Default: 1m0s

--ftp-tls-cache-size

Size of TLS session cache for all control and data connections.

TLS cache allows to resume TLS sessions and reuse PSK between connections. Increase if default size is not enough resulting in TLS resumption errors. Enabled by default. Use 0 to disable.

Properties:

  • Config: tls_cache_size
  • Env Var: RCLONE_FTP_TLS_CACHE_SIZE
  • Type: int
  • Default: 32

--ftp-disable-tls13

Disable TLS 1.3 (workaround for FTP servers with buggy TLS)

Properties:

  • Config: disable_tls13
  • Env Var: RCLONE_FTP_DISABLE_TLS13
  • Type: bool
  • Default: false

--ftp-allow-insecure-tls-ciphers

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

Properties:

  • Config: allow_insecure_tls_ciphers
  • Env Var: RCLONE_FTP_ALLOW_INSECURE_TLS_CIPHERS
  • Type: bool
  • Default: false

--ftp-shut-timeout

Maximum time to wait for data connection closing status.

Properties:

  • Config: shut_timeout
  • Env Var: RCLONE_FTP_SHUT_TIMEOUT
  • Type: Duration
  • Default: 1m0s

--ftp-ask-password

Allow asking for FTP password when needed.

If this is set and no password is supplied then rclone will ask for a password

Properties:

  • Config: ask_password
  • Env Var: RCLONE_FTP_ASK_PASSWORD
  • Type: bool
  • Default: false

--ftp-socks-proxy

Socks 5 proxy host.

Supports the format user:pass@host:port, user@host:port, host:port.

Example:

myUser:myPass@localhost:9005

Properties:

  • Config: socks_proxy
  • Env Var: RCLONE_FTP_SOCKS_PROXY
  • Type: string
  • Required: false

--ftp-http-proxy

URL for HTTP CONNECT proxy

Set this to a URL for an HTTP proxy which supports the HTTP CONNECT verb.

Properties:

  • Config: http_proxy
  • Env Var: RCLONE_FTP_HTTP_PROXY
  • Type: string
  • Required: false

--ftp-no-check-upload

Don't check the upload is OK

Normally rclone will try to check the upload exists after it has uploaded a file to make sure the size and modification time are as expected.

This flag stops rclone doing these checks. This enables uploading to folders which are write only.

You will likely need to use the --inplace flag also if uploading to a write only folder.

Properties:

  • Config: no_check_upload
  • Env Var: RCLONE_FTP_NO_CHECK_UPLOAD
  • Type: bool
  • Default: false

--ftp-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_FTP_ENCODING
  • Type: Encoding
  • Default: Slash,Del,Ctl,RightSpace,Dot
  • Examples:
    • "Asterisk,Ctl,Dot,Slash"
      • ProFTPd can't handle '*' in file names
    • "BackSlash,Ctl,Del,Dot,RightSpace,Slash,SquareBracket"
      • PureFTPd can't handle '[]' or '*' in file names
    • "Ctl,LeftPeriod,Slash"
      • VsFTPd can't handle file names starting with dot

--ftp-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_FTP_DESCRIPTION
  • Type: string
  • Required: false

Limitations

FTP servers acting as rclone remotes must support passive mode. The mode cannot be configured as passive is the only supported one. Rclone's FTP implementation is not compatible with active mode as the library it uses doesn't support it. This will likely never be supported due to security concerns.

Rclone's FTP backend does not support any checksums but can compare file sizes.

rclone about is not supported by the FTP backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

The implementation of : --dump headers, --dump bodies, --dump auth for debugging isn't the same as for rclone HTTP based backends - it has less fine grained control.

--timeout isn't supported (but --contimeout is).

--bind isn't supported.

Rclone's FTP backend could support server-side move but does not at present.

The ftp_proxy environment variable is not currently supported.

Modification times

File modification time (timestamps) is supported to 1 second resolution for major FTP servers: ProFTPd, PureFTPd, VsFTPd, and FileZilla FTP server. The VsFTPd server has non-standard implementation of time related protocol commands and needs a special configuration setting: writing_mdtm = true.

Support for precise file time with other FTP servers varies depending on what protocol extensions they advertise. If all the MLSD, MDTM and MFTM extensions are present, rclone will use them together to provide precise time. Otherwise the times you see on the FTP server through rclone are those of the last file upload.

You can use the following command to check whether rclone can use precise time with your FTP server: rclone backend features your_ftp_remote: (the trailing colon is important). Look for the number in the line tagged by Precision designating the remote time precision expressed as nanoseconds. A value of 1000000000 means that file time precision of 1 second is available. A value of 3153600000000000000 (or another large number) means "unsupported".

Gofile

Gofile is a content storage and distribution platform. Its aim is to provide as much service as possible for free or at a very low price.

The initial setup for Gofile involves logging in to the web interface and going to the "My Profile" section. Copy the "Account API token" for use in the config file.

Note that if you wish to connect rclone to Gofile you will need a premium account.

Configuration

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter name for new remote.
name> remote

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
XX / Gofile
   \ (gofile)
Storage> gofile

Option access_token.
API Access token
You can get this from the web control panel.
Enter a value. Press Enter to leave empty.
access_token> YOURACCESSTOKEN

Edit advanced config?
y) Yes
n) No (default)
y/n> n

Configuration complete.
Options:
- type: gofile
- access_token: YOURACCESSTOKEN
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Once configured you can then use rclone like this,

List directories and files in the top level of your Gofile

rclone lsf remote:

To copy a local directory to an Gofile directory called backup

rclone copy /home/source remote:backup

Modification times and hashes

Gofile supports modification times with a resolution of 1 second.

Gofile supports MD5 hashes, so you can use the --checksum flag.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
! 0x21 ！
" 0x22 ＂
* 0x2A ＊
: 0x3A ：
< 0x3C ＜
> 0x3E ＞
? 0x3F ？
\ 0x5C ＼
| 0x7C ｜

File names can also not start or end with the following characters. These only get replaced if they are the first or last character in the name:

Character Value Replacement
. 0x2E ．

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Gofile supports rclone link to make public links to files or directories. If you specify a directory it will download as a zip file. You can use the --expire flag to specify the time the link should be valid. Note that rclone link --unlink removes all the public links for a file.

Root folder ID

You can set the root_folder_id for rclone. This is the directory (identified by its Folder ID) that rclone considers to be the root of your Gofile drive.

Normally you will leave this blank and rclone will determine the correct root to use itself and fill in the value in the config file.

However you can set this to restrict rclone to a specific folder hierarchy.

In order to do this you will have to find the Folder ID of the directory you wish rclone to display.

You can do this with rclone

$ rclone lsf -Fip --dirs-only remote:
d6341f53-ee65-4f29-9f59-d11e8070b2a0;Files/
f4f5c9b8-6ece-478b-b03e-4538edfe5a1c;Photos/
d50e356c-29ca-4b27-a3a7-494d91026e04;Videos/

The ID to use is the part before the ; so you could set

root_folder_id = d6341f53-ee65-4f29-9f59-d11e8070b2a0

To restrict rclone to the Files directory.

Standard options

Here are the Standard options specific to gofile (Gofile).

--gofile-access-token

API Access token

You can get this from the web control panel.

Properties:

  • Config: access_token
  • Env Var: RCLONE_GOFILE_ACCESS_TOKEN
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to gofile (Gofile).

--gofile-root-folder-id

ID of the root folder

Leave this blank normally, rclone will fill it in automatically.

If you want rclone to be restricted to a particular folder you can fill it in - see the docs for more info.

Properties:

  • Config: root_folder_id
  • Env Var: RCLONE_GOFILE_ROOT_FOLDER_ID
  • Type: string
  • Required: false

--gofile-account-id

Account ID

Leave this blank normally, rclone will fill it in automatically.

Properties:

  • Config: account_id
  • Env Var: RCLONE_GOFILE_ACCOUNT_ID
  • Type: string
  • Required: false

--gofile-list-chunk

Number of items to list in each call

Properties:

  • Config: list_chunk
  • Env Var: RCLONE_GOFILE_LIST_CHUNK
  • Type: int
  • Default: 1000

--gofile-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_GOFILE_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,LeftPeriod,RightPeriod,InvalidUtf8,Dot,Exclamation

--gofile-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_GOFILE_DESCRIPTION
  • Type: string
  • Required: false

Limitations

Gofile only supports filenames up to 255 characters in length, where a character is a unicode character.

Directories should not be cached for more than 24h otherwise files in the directory may not be downloadable. In practice this means when using a VFS based rclone command such as rclone mount you should make sure --dir-cache-time is less than 24h.

Note that Gofile is currently limited to a total of 100,000 items. If you attempt to upload more than that you will get error-limit-100000. This limit may be lifted in the future.

Duplicated files

Gofile is capable of having files with duplicated file names. For instance two files called hello.txt in the same directory.

Rclone cannot sync that to a normal file system but it can be fixed with the rclone dedupe command.

Duplicated files cause problems with the syncing and you will see messages in the log about duplicates.

Use rclone dedupe to fix duplicated files.

Google Cloud Storage

Paths are specified as remote:bucket (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:bucket/path/to/dir.

Configuration

The initial setup for google cloud storage involves getting a token from Google Cloud Storage which you need to do in your browser. rclone config walks you through it.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

n) New remote
d) Delete remote
q) Quit config
e/n/d/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Google Cloud Storage (this is not Google Drive)
   \ "google cloud storage"
[snip]
Storage> google cloud storage
Google Application Client Id - leave blank normally.
client_id>
Google Application Client Secret - leave blank normally.
client_secret>
Project number optional - needed only for list/create/delete buckets - see your developer console.
project_number> 12345678
Service Account Credentials JSON file path - needed only if you want use SA instead of interactive login.
service_account_file>
Access Control List for new objects.
Choose a number from below, or type in your own value
 1 / Object owner gets OWNER access, and all Authenticated Users get READER access.
   \ "authenticatedRead"
 2 / Object owner gets OWNER access, and project team owners get OWNER access.
   \ "bucketOwnerFullControl"
 3 / Object owner gets OWNER access, and project team owners get READER access.
   \ "bucketOwnerRead"
 4 / Object owner gets OWNER access [default if left blank].
   \ "private"
 5 / Object owner gets OWNER access, and project team members get access according to their roles.
   \ "projectPrivate"
 6 / Object owner gets OWNER access, and all Users get READER access.
   \ "publicRead"
object_acl> 4
Access Control List for new buckets.
Choose a number from below, or type in your own value
 1 / Project team owners get OWNER access, and all Authenticated Users get READER access.
   \ "authenticatedRead"
 2 / Project team owners get OWNER access [default if left blank].
   \ "private"
 3 / Project team members get access according to their roles.
   \ "projectPrivate"
 4 / Project team owners get OWNER access, and all Users get READER access.
   \ "publicRead"
 5 / Project team owners get OWNER access, and all Users get WRITER access.
   \ "publicReadWrite"
bucket_acl> 2
Location for the newly created buckets.
Choose a number from below, or type in your own value
 1 / Empty for default location (US).
   \ ""
 2 / Multi-regional location for Asia.
   \ "asia"
 3 / Multi-regional location for Europe.
   \ "eu"
 4 / Multi-regional location for United States.
   \ "us"
 5 / Taiwan.
   \ "asia-east1"
 6 / Tokyo.
   \ "asia-northeast1"
 7 / Singapore.
   \ "asia-southeast1"
 8 / Sydney.
   \ "australia-southeast1"
 9 / Belgium.
   \ "europe-west1"
10 / London.
   \ "europe-west2"
11 / Iowa.
   \ "us-central1"
12 / South Carolina.
   \ "us-east1"
13 / Northern Virginia.
   \ "us-east4"
14 / Oregon.
   \ "us-west1"
location> 12
The storage class to use when storing objects in Google Cloud Storage.
Choose a number from below, or type in your own value
 1 / Default
   \ ""
 2 / Multi-regional storage class
   \ "MULTI_REGIONAL"
 3 / Regional storage class
   \ "REGIONAL"
 4 / Nearline storage class
   \ "NEARLINE"
 5 / Coldline storage class
   \ "COLDLINE"
 6 / Durable reduced availability storage class
   \ "DURABLE_REDUCED_AVAILABILITY"
storage_class> 5
Remote config
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y) Yes
n) No
y/n> y
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth
Log in and authorize rclone for access
Waiting for code...
Got code
Configuration complete.
Options:
- type: google cloud storage
- client_id:
- client_secret:
- token: {"AccessToken":"xxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","RefreshToken":"x/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx_xxxxxxxxx","Expiry":"2014-07-17T20:49:14.929208288+01:00","Extra":null}
- project_number: 12345678
- object_acl: private
- bucket_acl: private
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

See the remote setup docs for how to set it up on a machine with no Internet browser available.

Note that rclone runs a webserver on your local machine to collect the token as returned from Google if using web browser to automatically authenticate. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall, or use manual mode.

This remote is called remote and can now be used like this

See all the buckets in your project

rclone lsd remote:

Make a new bucket

rclone mkdir remote:bucket

List the contents of a bucket

rclone ls remote:bucket

Sync /home/local/directory to the remote bucket, deleting any excess files in the bucket.

rclone sync --interactive /home/local/directory remote:bucket

Service Account support

You can set up rclone with Google Cloud Storage in an unattended mode, i.e. not tied to a specific end-user Google account. This is useful when you want to synchronise files onto machines that don't have actively logged-in users, for example build machines.

To get credentials for Google Cloud Platform IAM Service Accounts, please head to the Service Account section of the Google Developer Console. Service Accounts behave just like normal User permissions in Google Cloud Storage ACLs, so you can limit their access (e.g. make them read only). After creating an account, a JSON file containing the Service Account's credentials will be downloaded onto your machines. These credentials are what rclone will use for authentication.

To use a Service Account instead of OAuth2 token flow, enter the path to your Service Account credentials at the service_account_file prompt and rclone won't use the browser based authentication flow. If you'd rather stuff the contents of the credentials file into the rclone config file, you can set service_account_credentials with the actual contents of the file instead, or set the equivalent environment variable.

Service Account Authentication with Access Tokens

Another option for service account authentication is to use access tokens via gcloud impersonate-service-account. Access tokens protect security by avoiding the use of the JSON key file, which can be breached. They also bypass oauth login flow, which is simpler on remote VMs that lack a web browser.

If you already have a working service account, skip to step 3.

1. Create a service account using

gcloud iam service-accounts create gcs-read-only

You can re-use an existing service account as well (like the one created above)

2. Attach a Viewer (read-only) or User (read-write) role to the service account

 $ PROJECT_ID=my-project
 $ gcloud --verbose iam service-accounts add-iam-policy-binding \
    gcs-read-only@${PROJECT_ID}.iam.gserviceaccount.com  \
    --member=serviceAccount:gcs-read-only@${PROJECT_ID}.iam.gserviceaccount.com \
    --role=roles/storage.objectViewer

Use the Google Cloud console to identify a limited role. Some relevant pre-defined roles:

  • roles/storage.objectUser -- read-write access but no admin privileges
  • roles/storage.objectViewer -- read-only access to objects
  • roles/storage.admin -- create buckets & administrative roles

3. Get a temporary access key for the service account

$ gcloud auth application-default print-access-token  \
   --impersonate-service-account \
      gcs-read-only@${PROJECT_ID}.iam.gserviceaccount.com  

ya29.c.c0ASRK0GbAFEewXD [truncated]

4. Update access_token setting

hit CTRL-C when you see waiting for code. This will save the config without doing oauth flow

rclone config update ${REMOTE_NAME} access_token ya29.c.c0Axxxx

5. Run rclone as usual

rclone ls dev-gcs:${MY_BUCKET}/

More Info on Service Accounts

Anonymous Access

For downloads of objects that permit public access you can configure rclone to use anonymous access by setting anonymous to true. With unauthorized access you can't write or create files but only read or list those buckets and objects that have public read access.

Application Default Credentials

If no other source of credentials is provided, rclone will fall back to Application Default Credentials this is useful both when you already have configured authentication for your developer account, or in production when running on a google compute host. Note that if running in docker, you may need to run additional commands on your google compute machine - see this page.

Note that in the case application default credentials are used, there is no need to explicitly configure a project number.

--fast-list

This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details.

Custom upload headers

You can set custom upload headers with the --header-upload flag. Google Cloud Storage supports the headers as described in the working with metadata documentation

  • Cache-Control
  • Content-Disposition
  • Content-Encoding
  • Content-Language
  • Content-Type
  • X-Goog-Storage-Class
  • X-Goog-Meta-

Eg --header-upload "Content-Type text/potato"

Note that the last of these is for setting custom metadata in the form --header-upload "x-goog-meta-key: value"

Modification times

Google Cloud Storage stores md5sum natively. Google's gsutil tool stores modification time with one-second precision as goog-reserved-file-mtime in file metadata.

To ensure compatibility with gsutil, rclone stores modification time in 2 separate metadata entries. mtime uses RFC3339 format with one-nanosecond precision. goog-reserved-file-mtime uses Unix timestamp format with one-second precision. To get modification time from object metadata, rclone reads the metadata in the following order: mtime, goog-reserved-file-mtime, object updated time.

Note that rclone's default modify window is 1ns. Files uploaded by gsutil only contain timestamps with one-second precision. If you use rclone to sync files previously uploaded by gsutil, rclone will attempt to update modification time for all these files. To avoid these possibly unnecessary updates, use --modify-window 1s.

Restricted filename characters

Character Value Replacement
NUL 0x00 ␀
LF 0x0A ␊
CR 0x0D ␍
/ 0x2F ／

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Standard options

Here are the Standard options specific to google cloud storage (Google Cloud Storage (this is not Google Drive)).

--gcs-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_GCS_CLIENT_ID
  • Type: string
  • Required: false

--gcs-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_GCS_CLIENT_SECRET
  • Type: string
  • Required: false

--gcs-project-number

Project number.

Optional - needed only for list/create/delete buckets - see your developer console.

Properties:

  • Config: project_number
  • Env Var: RCLONE_GCS_PROJECT_NUMBER
  • Type: string
  • Required: false

--gcs-user-project

User project.

Optional - needed only for requester pays.

Properties:

  • Config: user_project
  • Env Var: RCLONE_GCS_USER_PROJECT
  • Type: string
  • Required: false

--gcs-service-account-file

Service Account Credentials JSON file path.

Leave blank normally. Needed only if you want use SA instead of interactive login.

Leading ~ will be expanded in the file name as will environment variables such as ${RCLONE_CONFIG_DIR}.

Properties:

  • Config: service_account_file
  • Env Var: RCLONE_GCS_SERVICE_ACCOUNT_FILE
  • Type: string
  • Required: false

--gcs-service-account-credentials

Service Account Credentials JSON blob.

Leave blank normally. Needed only if you want use SA instead of interactive login.

Properties:

  • Config: service_account_credentials
  • Env Var: RCLONE_GCS_SERVICE_ACCOUNT_CREDENTIALS
  • Type: string
  • Required: false

--gcs-anonymous

Access public buckets and objects without credentials.

Set to 'true' if you just want to download files and don't configure credentials.

Properties:

  • Config: anonymous
  • Env Var: RCLONE_GCS_ANONYMOUS
  • Type: bool
  • Default: false

--gcs-object-acl

Access Control List for new objects.

Properties:

  • Config: object_acl
  • Env Var: RCLONE_GCS_OBJECT_ACL
  • Type: string
  • Required: false
  • Examples:
    • "authenticatedRead"
      • Object owner gets OWNER access.
      • All Authenticated Users get READER access.
    • "bucketOwnerFullControl"
      • Object owner gets OWNER access.
      • Project team owners get OWNER access.
    • "bucketOwnerRead"
      • Object owner gets OWNER access.
      • Project team owners get READER access.
    • "private"
      • Object owner gets OWNER access.
      • Default if left blank.
    • "projectPrivate"
      • Object owner gets OWNER access.
      • Project team members get access according to their roles.
    • "publicRead"
      • Object owner gets OWNER access.
      • All Users get READER access.

--gcs-bucket-acl

Access Control List for new buckets.

Properties:

  • Config: bucket_acl
  • Env Var: RCLONE_GCS_BUCKET_ACL
  • Type: string
  • Required: false
  • Examples:
    • "authenticatedRead"
      • Project team owners get OWNER access.
      • All Authenticated Users get READER access.
    • "private"
      • Project team owners get OWNER access.
      • Default if left blank.
    • "projectPrivate"
      • Project team members get access according to their roles.
    • "publicRead"
      • Project team owners get OWNER access.
      • All Users get READER access.
    • "publicReadWrite"
      • Project team owners get OWNER access.
      • All Users get WRITER access.

--gcs-bucket-policy-only

Access checks should use bucket-level IAM policies.

If you want to upload objects to a bucket with Bucket Policy Only set then you will need to set this.

When it is set, rclone:

  • ignores ACLs set on buckets
  • ignores ACLs set on objects
  • creates buckets with Bucket Policy Only set

Docs: https://cloud.google.com/storage/docs/bucket-policy-only

Properties:

  • Config: bucket_policy_only
  • Env Var: RCLONE_GCS_BUCKET_POLICY_ONLY
  • Type: bool
  • Default: false

--gcs-location

Location for the newly created buckets.

Properties:

  • Config: location
  • Env Var: RCLONE_GCS_LOCATION
  • Type: string
  • Required: false
  • Examples:
    • ""
      • Empty for default location (US)
    • "asia"
      • Multi-regional location for Asia
    • "eu"
      • Multi-regional location for Europe
    • "us"
      • Multi-regional location for United States
    • "asia-east1"
      • Taiwan
    • "asia-east2"
      • Hong Kong
    • "asia-northeast1"
      • Tokyo
    • "asia-northeast2"
      • Osaka
    • "asia-northeast3"
      • Seoul
    • "asia-south1"
      • Mumbai
    • "asia-south2"
      • Delhi
    • "asia-southeast1"
      • Singapore
    • "asia-southeast2"
      • Jakarta
    • "australia-southeast1"
      • Sydney
    • "australia-southeast2"
      • Melbourne
    • "europe-north1"
      • Finland
    • "europe-west1"
      • Belgium
    • "europe-west2"
      • London
    • "europe-west3"
      • Frankfurt
    • "europe-west4"
      • Netherlands
    • "europe-west6"
      • Zürich
    • "europe-central2"
      • Warsaw
    • "us-central1"
      • Iowa
    • "us-east1"
      • South Carolina
    • "us-east4"
      • Northern Virginia
    • "us-west1"
      • Oregon
    • "us-west2"
      • California
    • "us-west3"
      • Salt Lake City
    • "us-west4"
      • Las Vegas
    • "northamerica-northeast1"
      • Montréal
    • "northamerica-northeast2"
      • Toronto
    • "southamerica-east1"
      • São Paulo
    • "southamerica-west1"
      • Santiago
    • "asia1"
      • Dual region: asia-northeast1 and asia-northeast2.
    • "eur4"
      • Dual region: europe-north1 and europe-west4.
    • "nam4"
      • Dual region: us-central1 and us-east1.

--gcs-storage-class

The storage class to use when storing objects in Google Cloud Storage.

Properties:

  • Config: storage_class
  • Env Var: RCLONE_GCS_STORAGE_CLASS
  • Type: string
  • Required: false
  • Examples:
    • ""
      • Default
    • "MULTI_REGIONAL"
      • Multi-regional storage class
    • "REGIONAL"
      • Regional storage class
    • "NEARLINE"
      • Nearline storage class
    • "COLDLINE"
      • Coldline storage class
    • "ARCHIVE"
      • Archive storage class
    • "DURABLE_REDUCED_AVAILABILITY"
      • Durable reduced availability storage class

--gcs-env-auth

Get GCP IAM credentials from runtime (environment variables or instance meta data if no env vars).

Only applies if service_account_file and service_account_credentials is blank.

Properties:

  • Config: env_auth
  • Env Var: RCLONE_GCS_ENV_AUTH
  • Type: bool
  • Default: false
  • Examples:
    • "false"
      • Enter credentials in the next step.
    • "true"
      • Get GCP IAM credentials from the environment (env vars or IAM).

Advanced options

Here are the Advanced options specific to google cloud storage (Google Cloud Storage (this is not Google Drive)).

--gcs-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_GCS_TOKEN
  • Type: string
  • Required: false

--gcs-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_GCS_AUTH_URL
  • Type: string
  • Required: false

--gcs-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_GCS_TOKEN_URL
  • Type: string
  • Required: false

--gcs-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_GCS_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--gcs-access-token

Short-lived access token.

Leave blank normally. Needed only if you want use short-lived access token instead of interactive login.

Properties:

  • Config: access_token
  • Env Var: RCLONE_GCS_ACCESS_TOKEN
  • Type: string
  • Required: false

--gcs-directory-markers

Upload an empty object with a trailing slash when a new directory is created

Empty folders are unsupported for bucket based remotes, this option creates an empty object ending with "/", to persist the folder.

Properties:

  • Config: directory_markers
  • Env Var: RCLONE_GCS_DIRECTORY_MARKERS
  • Type: bool
  • Default: false

--gcs-no-check-bucket

If set, don't attempt to check the bucket exists or create it.

This can be useful when trying to minimise the number of transactions rclone does if you know the bucket exists already.

Properties:

  • Config: no_check_bucket
  • Env Var: RCLONE_GCS_NO_CHECK_BUCKET
  • Type: bool
  • Default: false

--gcs-decompress

If set this will decompress gzip encoded objects.

It is possible to upload objects to GCS with "Content-Encoding: gzip" set. Normally rclone will download these files as compressed objects.

If this flag is set then rclone will decompress these files with "Content-Encoding: gzip" as they are received. This means that rclone can't check the size and hash but the file contents will be decompressed.

Properties:

  • Config: decompress
  • Env Var: RCLONE_GCS_DECOMPRESS
  • Type: bool
  • Default: false

--gcs-endpoint

Endpoint for the service.

Leave blank normally.

Properties:

  • Config: endpoint
  • Env Var: RCLONE_GCS_ENDPOINT
  • Type: string
  • Required: false

--gcs-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_GCS_ENCODING
  • Type: Encoding
  • Default: Slash,CrLf,InvalidUtf8,Dot

--gcs-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_GCS_DESCRIPTION
  • Type: string
  • Required: false

Limitations

rclone about is not supported by the Google Cloud Storage backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

Google Drive

Paths are specified as drive:path

Drive paths may be as deep as required, e.g. drive:directory/subdirectory.

Configuration

The initial setup for drive involves getting a token from Google drive which you need to do in your browser. rclone config walks you through it.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
n/r/c/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Google Drive
   \ "drive"
[snip]
Storage> drive
Google Application Client Id - leave blank normally.
client_id>
Google Application Client Secret - leave blank normally.
client_secret>
Scope that rclone should use when requesting access from drive.
Choose a number from below, or type in your own value
 1 / Full access all files, excluding Application Data Folder.
   \ "drive"
 2 / Read-only access to file metadata and file contents.
   \ "drive.readonly"
   / Access to files created by rclone only.
 3 | These are visible in the drive website.
   | File authorization is revoked when the user deauthorizes the app.
   \ "drive.file"
   / Allows read and write access to the Application Data folder.
 4 | This is not visible in the drive website.
   \ "drive.appfolder"
   / Allows read-only access to file metadata but
 5 | does not allow any access to read or download file content.
   \ "drive.metadata.readonly"
scope> 1
Service Account Credentials JSON file path - needed only if you want use SA instead of interactive login.
service_account_file>
Remote config
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y) Yes
n) No
y/n> y
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth
Log in and authorize rclone for access
Waiting for code...
Got code
Configure this as a Shared Drive (Team Drive)?
y) Yes
n) No
y/n> n
Configuration complete.
Options:
type: drive
- client_id:
- client_secret:
- scope: drive
- root_folder_id:
- service_account_file:
- token: {"access_token":"XXX","token_type":"Bearer","refresh_token":"XXX","expiry":"2014-03-16T13:57:58.955387075Z"}
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

See the remote setup docs for how to set it up on a machine with no Internet browser available.

Note that rclone runs a webserver on your local machine to collect the token as returned from Google if using web browser to automatically authenticate. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and it may require you to unblock it temporarily if you are running a host firewall, or use manual mode.

You can then use it like this,

List directories in top level of your drive

rclone lsd remote:

List all the files in your drive

rclone ls remote:

To copy a local directory to a drive directory called backup

rclone copy /home/source remote:backup

Scopes

Rclone allows you to select which scope you would like for rclone to use. This changes what type of token is granted to rclone. The scopes are defined here.

A comma-separated list is allowed e.g. drive.readonly,drive.file.

The scope are

drive

This is the default scope and allows full access to all files, except for the Application Data Folder (see below).

Choose this one if you aren't sure.

drive.readonly

This allows read only access to all files. Files may be listed and downloaded but not uploaded, renamed or deleted.

drive.file

With this scope rclone can read/view/modify only those files and folders it creates.

So if you uploaded files to drive via the web interface (or any other means) they will not be visible to rclone.

This can be useful if you are using rclone to backup data and you want to be sure confidential data on your drive is not visible to rclone.

Files created with this scope are visible in the web interface.

drive.appfolder

This gives rclone its own private area to store files. Rclone will not be able to see any other files on your drive and you won't be able to see rclone's files from the web interface either.

drive.metadata.readonly

This allows read only access to file names only. It does not allow rclone to download or upload data, or rename or delete files or directories.

Root folder ID

This option has been moved to the advanced section. You can set the root_folder_id for rclone. This is the directory (identified by its Folder ID) that rclone considers to be the root of your drive.

Normally you will leave this blank and rclone will determine the correct root to use itself.

However you can set this to restrict rclone to a specific folder hierarchy or to access data within the "Computers" tab on the drive web interface (where files from Google's Backup and Sync desktop program go).

In order to do this you will have to find the Folder ID of the directory you wish rclone to display. This will be the last segment of the URL when you open the relevant folder in the drive web interface.

So if the folder you want rclone to use has a URL which looks like https://drive.google.com/drive/folders/1XyfxxxxxxxxxxxxxxxxxxxxxxxxxKHCh in the browser, then you use 1XyfxxxxxxxxxxxxxxxxxxxxxxxxxKHCh as the root_folder_id in the config.

NB folders under the "Computers" tab seem to be read only (drive gives a 500 error) when using rclone.

There doesn't appear to be an API to discover the folder IDs of the "Computers" tab - please contact us if you know otherwise!

Note also that rclone can't access any data under the "Backups" tab on the google drive web interface yet.

Service Account support

You can set up rclone with Google Drive in an unattended mode, i.e. not tied to a specific end-user Google account. This is useful when you want to synchronise files onto machines that don't have actively logged-in users, for example build machines.

To use a Service Account instead of OAuth2 token flow, enter the path to your Service Account credentials at the service_account_file prompt during rclone config and rclone won't use the browser based authentication flow. If you'd rather stuff the contents of the credentials file into the rclone config file, you can set service_account_credentials with the actual contents of the file instead, or set the equivalent environment variable.

Use case - Google Workspace account and individual Drive

Let's say that you are the administrator of a Google Workspace. The goal is to read or write data on an individual's Drive account, who IS a member of the domain. We'll call the domain example.com, and the user foo@example.com.

There's a few steps we need to go through to accomplish this:

1. Create a service account for example.com
  • To create a service account and obtain its credentials, go to the Google Developer Console.
  • You must have a project - create one if you don't and make sure you are on the selected project.
  • Then go to "IAM & admin" -> "Service Accounts".
  • Use the "Create Service Account" button. Fill in "Service account name" and "Service account ID" with something that identifies your client.
  • Select "Create And Continue". Step 2 and 3 are optional.
  • Click on the newly created service account
  • Click "Keys" and then "Add Key" and then "Create new key"
  • Choose type "JSON" and click create
  • This will download a small JSON file that rclone will use for authentication.

If you ever need to remove access, press the "Delete service account key" button.

2. Allowing API access to example.com Google Drive
  • Go to example.com's Workspace Admin Console
  • Go into "Security" (or use the search bar)
  • Select "Access and data control" and then "API controls"
  • Click "Manage domain-wide delegation"
  • Click "Add new"
  • In the "Client ID" field enter the service account's "Client ID" - this can be found in the Developer Console under "IAM & Admin" -> "Service Accounts", then "View Client ID" for the newly created service account. It is a ~21 character numerical string.
  • In the next field, "OAuth Scopes", enter https://www.googleapis.com/auth/drive to grant read/write access to Google Drive specifically. You can also use https://www.googleapis.com/auth/drive.readonly for read only access.
  • Click "Authorise"
3. Configure rclone, assuming a new install
rclone config

n/s/q> n         # New
name>gdrive      # Gdrive is an example name
Storage>         # Type drive
client_id>       # Can be left blank
client_secret>   # Can be left blank
scope>           # Select the scope use used in step 2
root_folder_id>  # Can be left blank
service_account_file> /home/foo/myJSONfile.json # Path to the JSON file you downloaded in step 1.
y/n>             # Auto config, n
4. Verify that it's working
  • rclone -v --drive-impersonate foo@example.com lsf gdrive:backup
  • The arguments do:
    • -v - verbose logging
    • --drive-impersonate foo@example.com - this is what does the magic, pretending to be user foo.
    • lsf - list files in a parsing friendly way
    • gdrive:backup - use the remote called gdrive, work in the folder named backup.

Note: in case you configured a specific root folder on gdrive and rclone is unable to access the contents of that folder when using --drive-impersonate, do this instead: - in the gdrive web interface, share your root folder with the user/email of the new Service Account you created/selected at step 1 - use rclone without specifying the --drive-impersonate option, like this: rclone -v lsf gdrive:backup

Shared drives (team drives)

If you want to configure the remote to point to a Google Shared Drive (previously known as Team Drives) then answer y to the question Configure this as a Shared Drive (Team Drive)?.

This will fetch the list of Shared Drives from google and allow you to configure which one you want to use. You can also type in a Shared Drive ID if you prefer.

For example:

Configure this as a Shared Drive (Team Drive)?
y) Yes
n) No
y/n> y
Fetching Shared Drive list...
Choose a number from below, or type in your own value
 1 / Rclone Test
   \ "xxxxxxxxxxxxxxxxxxxx"
 2 / Rclone Test 2
   \ "yyyyyyyyyyyyyyyyyyyy"
 3 / Rclone Test 3
   \ "zzzzzzzzzzzzzzzzzzzz"
Enter a Shared Drive ID> 1
Configuration complete.
Options:
- type: drive
- client_id:
- client_secret:
- token: {"AccessToken":"xxxx.x.xxxxx_xxxxxxxxxxx_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","RefreshToken":"1/xxxxxxxxxxxxxxxx_xxxxxxxxxxxxxxxxxxxxxxxxxx","Expiry":"2014-03-16T13:57:58.955387075Z","Extra":null}
- team_drive: xxxxxxxxxxxxxxxxxxxx
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

--fast-list

This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details.

It does this by combining multiple list calls into a single API request.

This works by combining many '%s' in parents filters into one expression. To list the contents of directories a, b and c, the following requests will be send by the regular List function:

trashed=false and 'a' in parents
trashed=false and 'b' in parents
trashed=false and 'c' in parents

These can now be combined into a single request:

trashed=false and ('a' in parents or 'b' in parents or 'c' in parents)

The implementation of ListR will put up to 50 parents filters into one request. It will use the --checkers value to specify the number of requests to run in parallel.

In tests, these batch requests were up to 20x faster than the regular method. Running the following command against different sized folders gives:

rclone lsjson -vv -R --checkers=6 gdrive:folder

small folder (220 directories, 700 files):

  • without --fast-list: 38s
  • with --fast-list: 10s

large folder (10600 directories, 39000 files):

  • without --fast-list: 22:05 min
  • with --fast-list: 58s

Modification times and hashes

Google drive stores modification times accurate to 1 ms.

Hash algorithms MD5, SHA1 and SHA256 are supported. Note, however, that a small fraction of files uploaded may not have SHA1 or SHA256 hashes especially if they were uploaded before 2018.

Restricted filename characters

Only Invalid UTF-8 bytes will be replaced, as they can't be used in JSON strings.

In contrast to other backends, / can also be used in names and . or .. are valid names.

Revisions

Google drive stores revisions of files. When you upload a change to an existing file to google drive using rclone it will create a new revision of that file.

Revisions follow the standard google policy which at time of writing was

  • They are deleted after 30 days or 100 revisions (whatever comes first).
  • They do not count towards a user storage quota.

Deleting files

By default rclone will send all files to the trash when deleting files. If deleting them permanently is required then use the --drive-use-trash=false flag, or set the equivalent environment variable.

Shortcuts

In March 2020 Google introduced a new feature in Google Drive called drive shortcuts (API). These will (by September 2020) replace the ability for files or folders to be in multiple folders at once.

Shortcuts are files that link to other files on Google Drive somewhat like a symlink in unix, except they point to the underlying file data (e.g. the inode in unix terms) so they don't break if the source is renamed or moved about.

By default rclone treats these as follows.

For shortcuts pointing to files:

  • When listing a file shortcut appears as the destination file.
  • When downloading the contents of the destination file is downloaded.
  • When updating shortcut file with a non shortcut file, the shortcut is removed then a new file is uploaded in place of the shortcut.
  • When server-side moving (renaming) the shortcut is renamed, not the destination file.
  • When server-side copying the shortcut is copied, not the contents of the shortcut. (unless --drive-copy-shortcut-content is in use in which case the contents of the shortcut gets copied).
  • When deleting the shortcut is deleted not the linked file.
  • When setting the modification time, the modification time of the linked file will be set.

For shortcuts pointing to folders:

  • When listing the shortcut appears as a folder and that folder will contain the contents of the linked folder appear (including any sub folders)
  • When downloading the contents of the linked folder and sub contents are downloaded
  • When uploading to a shortcut folder the file will be placed in the linked folder
  • When server-side moving (renaming) the shortcut is renamed, not the destination folder
  • When server-side copying the contents of the linked folder is copied, not the shortcut.
  • When deleting with rclone rmdir or rclone purge the shortcut is deleted not the linked folder.
  • NB When deleting with rclone remove or rclone mount the contents of the linked folder will be deleted.

The rclone backend command can be used to create shortcuts.

Shortcuts can be completely ignored with the --drive-skip-shortcuts flag or the corresponding skip_shortcuts configuration setting.

If you have shortcuts that lead to an infinite recursion in your drive (e.g. a shortcut pointing to a parent folder), skip_shortcuts might be mandatory to be able to copy the drive.

Emptying trash

If you wish to empty your trash you can use the rclone cleanup remote: command which will permanently delete all your trashed files. This command does not take any path arguments.

Note that Google Drive takes some time (minutes to days) to empty the trash even though the command returns within a few seconds. No output is echoed, so there will be no confirmation even using -v or -vv.

Quota information

To view your current quota you can use the rclone about remote: command which will display your usage limit (quota), the usage in Google Drive, the size of all files in the Trash and the space used by other Google services such as Gmail. This command does not take any path arguments.

Import/Export of google documents

Google documents can be exported from and uploaded to Google Drive.

When rclone downloads a Google doc it chooses a format to download depending upon the --drive-export-formats setting. By default the export formats are docx,xlsx,pptx,svg which are a sensible default for an editable document.

When choosing a format, rclone runs down the list provided in order and chooses the first file format the doc can be exported as from the list. If the file can't be exported to a format on the formats list, then rclone will choose a format from the default list.

If you prefer an archive copy then you might use --drive-export-formats pdf, or if you prefer openoffice/libreoffice formats you might use --drive-export-formats ods,odt,odp.

Note that rclone adds the extension to the google doc, so if it is called My Spreadsheet on google docs, it will be exported as My Spreadsheet.xlsx or My Spreadsheet.pdf etc.

When importing files into Google Drive, rclone will convert all files with an extension in --drive-import-formats to their associated document type. rclone will not convert any files by default, since the conversion is lossy process.

The conversion must result in a file with the same extension when the --drive-export-formats rules are applied to the uploaded document.

Here are some examples for allowed and prohibited conversions.

export-formats import-formats Upload Ext Document Ext Allowed
odt odt odt odt Yes
odt docx,odt odt odt Yes
docx docx docx Yes
odt odt docx No
odt,docx docx,odt docx odt No
docx,odt docx,odt docx docx Yes
docx,odt docx,odt odt docx No

This limitation can be disabled by specifying --drive-allow-import-name-change. When using this flag, rclone can convert multiple files types resulting in the same document type at once, e.g. with --drive-import-formats docx,odt,txt, all files having these extension would result in a document represented as a docx file. This brings the additional risk of overwriting a document, if multiple files have the same stem. Many rclone operations will not handle this name change in any way. They assume an equal name when copying files and might copy the file again or delete them when the name changes.

Here are the possible export extensions with their corresponding mime types. Most of these can also be used for importing, but there more that are not listed here. Some of these additional ones might only be available when the operating system provides the correct MIME type entries.

This list can be changed by Google Drive at any time and might not represent the currently available conversions.

Extension Mime Type Description
bmp image/bmp Windows Bitmap format
csv text/csv Standard CSV format for Spreadsheets
doc application/msword Classic Word file
docx application/vnd.openxmlformats-officedocument.wordprocessingml.document Microsoft Office Document
epub application/epub+zip E-book format
html text/html An HTML Document
jpg image/jpeg A JPEG Image File
json application/vnd.google-apps.script+json JSON Text Format for Google Apps scripts
md text/markdown Markdown Text Format
odp application/vnd.oasis.opendocument.presentation Openoffice Presentation
ods application/vnd.oasis.opendocument.spreadsheet Openoffice Spreadsheet
ods application/x-vnd.oasis.opendocument.spreadsheet Openoffice Spreadsheet
odt application/vnd.oasis.opendocument.text Openoffice Document
pdf application/pdf Adobe PDF Format
pjpeg image/pjpeg Progressive JPEG Image
png image/png PNG Image Format
pptx application/vnd.openxmlformats-officedocument.presentationml.presentation Microsoft Office Powerpoint
rtf application/rtf Rich Text Format
svg image/svg+xml Scalable Vector Graphics Format
tsv text/tab-separated-values Standard TSV format for spreadsheets
txt text/plain Plain Text
wmf application/x-msmetafile Windows Meta File
xls application/vnd.ms-excel Classic Excel file
xlsx application/vnd.openxmlformats-officedocument.spreadsheetml.sheet Microsoft Office Spreadsheet
zip application/zip A ZIP file of HTML, Images CSS

Google documents can also be exported as link files. These files will open a browser window for the Google Docs website of that document when opened. The link file extension has to be specified as a --drive-export-formats parameter. They will match all available Google Documents.

Extension Description OS Support
desktop freedesktop.org specified desktop entry Linux
link.html An HTML Document with a redirect All
url INI style link file macOS, Windows
webloc macOS specific XML format macOS

Standard options

Here are the Standard options specific to drive (Google Drive).

--drive-client-id

Google Application Client Id Setting your own is recommended. See https://rclone.org/drive/#making-your-own-client-id for how to create your own. If you leave this blank, it will use an internal key which is low performance.

Properties:

  • Config: client_id
  • Env Var: RCLONE_DRIVE_CLIENT_ID
  • Type: string
  • Required: false

--drive-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_DRIVE_CLIENT_SECRET
  • Type: string
  • Required: false

--drive-scope

Comma separated list of scopes that rclone should use when requesting access from drive.

Properties:

  • Config: scope
  • Env Var: RCLONE_DRIVE_SCOPE
  • Type: string
  • Required: false
  • Examples:
    • "drive"
      • Full access all files, excluding Application Data Folder.
    • "drive.readonly"
      • Read-only access to file metadata and file contents.
    • "drive.file"
      • Access to files created by rclone only.
      • These are visible in the drive website.
      • File authorization is revoked when the user deauthorizes the app.
    • "drive.appfolder"
      • Allows read and write access to the Application Data folder.
      • This is not visible in the drive website.
    • "drive.metadata.readonly"
      • Allows read-only access to file metadata but
      • does not allow any access to read or download file content.

--drive-service-account-file

Service Account Credentials JSON file path.

Leave blank normally. Needed only if you want use SA instead of interactive login.

Leading ~ will be expanded in the file name as will environment variables such as ${RCLONE_CONFIG_DIR}.

Properties:

  • Config: service_account_file
  • Env Var: RCLONE_DRIVE_SERVICE_ACCOUNT_FILE
  • Type: string
  • Required: false

--drive-alternate-export

Deprecated: No longer needed.

Properties:

  • Config: alternate_export
  • Env Var: RCLONE_DRIVE_ALTERNATE_EXPORT
  • Type: bool
  • Default: false

Advanced options

Here are the Advanced options specific to drive (Google Drive).

--drive-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_DRIVE_TOKEN
  • Type: string
  • Required: false

--drive-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_DRIVE_AUTH_URL
  • Type: string
  • Required: false

--drive-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_DRIVE_TOKEN_URL
  • Type: string
  • Required: false

--drive-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_DRIVE_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--drive-root-folder-id

ID of the root folder. Leave blank normally.

Fill in to access "Computers" folders (see docs), or for rclone to use a non root folder as its starting point.

Properties:

  • Config: root_folder_id
  • Env Var: RCLONE_DRIVE_ROOT_FOLDER_ID
  • Type: string
  • Required: false

--drive-service-account-credentials

Service Account Credentials JSON blob.

Leave blank normally. Needed only if you want use SA instead of interactive login.

Properties:

  • Config: service_account_credentials
  • Env Var: RCLONE_DRIVE_SERVICE_ACCOUNT_CREDENTIALS
  • Type: string
  • Required: false

--drive-team-drive

ID of the Shared Drive (Team Drive).

Properties:

  • Config: team_drive
  • Env Var: RCLONE_DRIVE_TEAM_DRIVE
  • Type: string
  • Required: false

--drive-auth-owner-only

Only consider files owned by the authenticated user.

Properties:

  • Config: auth_owner_only
  • Env Var: RCLONE_DRIVE_AUTH_OWNER_ONLY
  • Type: bool
  • Default: false

--drive-use-trash

Send files to the trash instead of deleting permanently.

Defaults to true, namely sending files to the trash. Use --drive-use-trash=false to delete files permanently instead.

Properties:

  • Config: use_trash
  • Env Var: RCLONE_DRIVE_USE_TRASH
  • Type: bool
  • Default: true

--drive-copy-shortcut-content

Server side copy contents of shortcuts instead of the shortcut.

When doing server side copies, normally rclone will copy shortcuts as shortcuts.

If this flag is used then rclone will copy the contents of shortcuts rather than shortcuts themselves when doing server side copies.

Properties:

  • Config: copy_shortcut_content
  • Env Var: RCLONE_DRIVE_COPY_SHORTCUT_CONTENT
  • Type: bool
  • Default: false

--drive-skip-gdocs

Skip google documents in all listings.

If given, gdocs practically become invisible to rclone.

Properties:

  • Config: skip_gdocs
  • Env Var: RCLONE_DRIVE_SKIP_GDOCS
  • Type: bool
  • Default: false

--drive-show-all-gdocs

Show all Google Docs including non-exportable ones in listings.

If you try a server side copy on a Google Form without this flag, you will get this error:

No export formats found for "application/vnd.google-apps.form"

However adding this flag will allow the form to be server side copied.

Note that rclone doesn't add extensions to the Google Docs file names in this mode.

Do not use this flag when trying to download Google Docs - rclone will fail to download them.

Properties:

  • Config: show_all_gdocs
  • Env Var: RCLONE_DRIVE_SHOW_ALL_GDOCS
  • Type: bool
  • Default: false

--drive-skip-checksum-gphotos

Skip checksums on Google photos and videos only.

Use this if you get checksum errors when transferring Google photos or videos.

Setting this flag will cause Google photos and videos to return a blank checksums.

Google photos are identified by being in the "photos" space.

Corrupted checksums are caused by Google modifying the image/video but not updating the checksum.

Properties:

  • Config: skip_checksum_gphotos
  • Env Var: RCLONE_DRIVE_SKIP_CHECKSUM_GPHOTOS
  • Type: bool
  • Default: false

--drive-shared-with-me

Only show files that are shared with me.

Instructs rclone to operate on your "Shared with me" folder (where Google Drive lets you access the files and folders others have shared with you).

This works both with the "list" (lsd, lsl, etc.) and the "copy" commands (copy, sync, etc.), and with all other commands too.

Properties:

  • Config: shared_with_me
  • Env Var: RCLONE_DRIVE_SHARED_WITH_ME
  • Type: bool
  • Default: false

--drive-trashed-only

Only show files that are in the trash.

This will show trashed files in their original directory structure.

Properties:

  • Config: trashed_only
  • Env Var: RCLONE_DRIVE_TRASHED_ONLY
  • Type: bool
  • Default: false

--drive-starred-only

Only show files that are starred.

Properties:

  • Config: starred_only
  • Env Var: RCLONE_DRIVE_STARRED_ONLY
  • Type: bool
  • Default: false

--drive-formats

Deprecated: See export_formats.

Properties:

  • Config: formats
  • Env Var: RCLONE_DRIVE_FORMATS
  • Type: string
  • Required: false

--drive-export-formats

Comma separated list of preferred formats for downloading Google docs.

Properties:

  • Config: export_formats
  • Env Var: RCLONE_DRIVE_EXPORT_FORMATS
  • Type: string
  • Default: "docx,xlsx,pptx,svg"

--drive-import-formats

Comma separated list of preferred formats for uploading Google docs.

Properties:

  • Config: import_formats
  • Env Var: RCLONE_DRIVE_IMPORT_FORMATS
  • Type: string
  • Required: false

--drive-allow-import-name-change

Allow the filetype to change when uploading Google docs.

E.g. file.doc to file.docx. This will confuse sync and reupload every time.

Properties:

  • Config: allow_import_name_change
  • Env Var: RCLONE_DRIVE_ALLOW_IMPORT_NAME_CHANGE
  • Type: bool
  • Default: false

--drive-use-created-date

Use file created date instead of modified date.

Useful when downloading data and you want the creation date used in place of the last modified date.

WARNING: This flag may have some unexpected consequences.

When uploading to your drive all files will be overwritten unless they haven't been modified since their creation. And the inverse will occur while downloading. This side effect can be avoided by using the "--checksum" flag.

This feature was implemented to retain photos capture date as recorded by google photos. You will first need to check the "Create a Google Photos folder" option in your google drive settings. You can then copy or move the photos locally and use the date the image was taken (created) set as the modification date.

Properties:

  • Config: use_created_date
  • Env Var: RCLONE_DRIVE_USE_CREATED_DATE
  • Type: bool
  • Default: false

--drive-use-shared-date

Use date file was shared instead of modified date.

Note that, as with "--drive-use-created-date", this flag may have unexpected consequences when uploading/downloading files.

If both this flag and "--drive-use-created-date" are set, the created date is used.

Properties:

  • Config: use_shared_date
  • Env Var: RCLONE_DRIVE_USE_SHARED_DATE
  • Type: bool
  • Default: false

--drive-list-chunk

Size of listing chunk 100-1000, 0 to disable.

Properties:

  • Config: list_chunk
  • Env Var: RCLONE_DRIVE_LIST_CHUNK
  • Type: int
  • Default: 1000

--drive-impersonate

Impersonate this user when using a service account.

Properties:

  • Config: impersonate
  • Env Var: RCLONE_DRIVE_IMPERSONATE
  • Type: string
  • Required: false

--drive-upload-cutoff

Cutoff for switching to chunked upload.

Properties:

  • Config: upload_cutoff
  • Env Var: RCLONE_DRIVE_UPLOAD_CUTOFF
  • Type: SizeSuffix
  • Default: 8Mi

--drive-chunk-size

Upload chunk size.

Must a power of 2 >= 256k.

Making this larger will improve performance, but note that each chunk is buffered in memory one per transfer.

Reducing this will reduce memory usage but decrease performance.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_DRIVE_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 8Mi

--drive-acknowledge-abuse

Set to allow files which return cannotDownloadAbusiveFile to be downloaded.

If downloading a file returns the error "This file has been identified as malware or spam and cannot be downloaded" with the error code "cannotDownloadAbusiveFile" then supply this flag to rclone to indicate you acknowledge the risks of downloading the file and rclone will download it anyway.

Note that if you are using service account it will need Manager permission (not Content Manager) to for this flag to work. If the SA does not have the right permission, Google will just ignore the flag.

Properties:

  • Config: acknowledge_abuse
  • Env Var: RCLONE_DRIVE_ACKNOWLEDGE_ABUSE
  • Type: bool
  • Default: false

--drive-keep-revision-forever

Keep new head revision of each file forever.

Properties:

  • Config: keep_revision_forever
  • Env Var: RCLONE_DRIVE_KEEP_REVISION_FOREVER
  • Type: bool
  • Default: false

--drive-size-as-quota

Show sizes as storage quota usage, not actual size.

Show the size of a file as the storage quota used. This is the current version plus any older versions that have been set to keep forever.

WARNING: This flag may have some unexpected consequences.

It is not recommended to set this flag in your config - the recommended usage is using the flag form --drive-size-as-quota when doing rclone ls/lsl/lsf/lsjson/etc only.

If you do use this flag for syncing (not recommended) then you will need to use --ignore size also.

Properties:

  • Config: size_as_quota
  • Env Var: RCLONE_DRIVE_SIZE_AS_QUOTA
  • Type: bool
  • Default: false

--drive-v2-download-min-size

If Object's are greater, use drive v2 API to download.

Properties:

  • Config: v2_download_min_size
  • Env Var: RCLONE_DRIVE_V2_DOWNLOAD_MIN_SIZE
  • Type: SizeSuffix
  • Default: off

--drive-pacer-min-sleep

Minimum time to sleep between API calls.

Properties:

  • Config: pacer_min_sleep
  • Env Var: RCLONE_DRIVE_PACER_MIN_SLEEP
  • Type: Duration
  • Default: 100ms

--drive-pacer-burst

Number of API calls to allow without sleeping.

Properties:

  • Config: pacer_burst
  • Env Var: RCLONE_DRIVE_PACER_BURST
  • Type: int
  • Default: 100

--drive-server-side-across-configs

Deprecated: use --server-side-across-configs instead.

Allow server-side operations (e.g. copy) to work across different drive configs.

This can be useful if you wish to do a server-side copy between two different Google drives. Note that this isn't enabled by default because it isn't easy to tell if it will work between any two configurations.

Properties:

  • Config: server_side_across_configs
  • Env Var: RCLONE_DRIVE_SERVER_SIDE_ACROSS_CONFIGS
  • Type: bool
  • Default: false

--drive-disable-http2

Disable drive using http2.

There is currently an unsolved issue with the google drive backend and HTTP/2. HTTP/2 is therefore disabled by default for the drive backend but can be re-enabled here. When the issue is solved this flag will be removed.

See: https://github.com/rclone/rclone/issues/3631

Properties:

  • Config: disable_http2
  • Env Var: RCLONE_DRIVE_DISABLE_HTTP2
  • Type: bool
  • Default: true

--drive-stop-on-upload-limit

Make upload limit errors be fatal.

At the time of writing it is only possible to upload 750 GiB of data to Google Drive a day (this is an undocumented limit). When this limit is reached Google Drive produces a slightly different error message. When this flag is set it causes these errors to be fatal. These will stop the in-progress sync.

Note that this detection is relying on error message strings which Google don't document so it may break in the future.

See: https://github.com/rclone/rclone/issues/3857

Properties:

  • Config: stop_on_upload_limit
  • Env Var: RCLONE_DRIVE_STOP_ON_UPLOAD_LIMIT
  • Type: bool
  • Default: false

--drive-stop-on-download-limit

Make download limit errors be fatal.

At the time of writing it is only possible to download 10 TiB of data from Google Drive a day (this is an undocumented limit). When this limit is reached Google Drive produces a slightly different error message. When this flag is set it causes these errors to be fatal. These will stop the in-progress sync.

Note that this detection is relying on error message strings which Google don't document so it may break in the future.

Properties:

  • Config: stop_on_download_limit
  • Env Var: RCLONE_DRIVE_STOP_ON_DOWNLOAD_LIMIT
  • Type: bool
  • Default: false

--drive-skip-shortcuts

If set skip shortcut files.

Normally rclone dereferences shortcut files making them appear as if they are the original file (see the shortcuts section). If this flag is set then rclone will ignore shortcut files completely.

Properties:

  • Config: skip_shortcuts
  • Env Var: RCLONE_DRIVE_SKIP_SHORTCUTS
  • Type: bool
  • Default: false

--drive-skip-dangling-shortcuts

If set skip dangling shortcut files.

If this is set then rclone will not show any dangling shortcuts in listings.

Properties:

  • Config: skip_dangling_shortcuts
  • Env Var: RCLONE_DRIVE_SKIP_DANGLING_SHORTCUTS
  • Type: bool
  • Default: false

--drive-resource-key

Resource key for accessing a link-shared file.

If you need to access files shared with a link like this

https://drive.google.com/drive/folders/XXX?resourcekey=YYY&usp=sharing

Then you will need to use the first part "XXX" as the "root_folder_id" and the second part "YYY" as the "resource_key" otherwise you will get 404 not found errors when trying to access the directory.

See: https://developers.google.com/drive/api/guides/resource-keys

This resource key requirement only applies to a subset of old files.

Note also that opening the folder once in the web interface (with the user you've authenticated rclone with) seems to be enough so that the resource key is not needed.

Properties:

  • Config: resource_key
  • Env Var: RCLONE_DRIVE_RESOURCE_KEY
  • Type: string
  • Required: false

--drive-fast-list-bug-fix

Work around a bug in Google Drive listing.

Normally rclone will work around a bug in Google Drive when using --fast-list (ListR) where the search "(A in parents) or (B in parents)" returns nothing sometimes. See #3114, #4289 and https://issuetracker.google.com/issues/149522397

Rclone detects this by finding no items in more than one directory when listing and retries them as lists of individual directories.

This means that if you have a lot of empty directories rclone will end up listing them all individually and this can take many more API calls.

This flag allows the work-around to be disabled. This is not recommended in normal use - only if you have a particular case you are having trouble with like many empty directories.

Properties:

  • Config: fast_list_bug_fix
  • Env Var: RCLONE_DRIVE_FAST_LIST_BUG_FIX
  • Type: bool
  • Default: true

--drive-metadata-owner

Control whether owner should be read or written in metadata.

Owner is a standard part of the file metadata so is easy to read. But it isn't always desirable to set the owner from the metadata.

Note that you can't set the owner on Shared Drives, and that setting ownership will generate an email to the new owner (this can't be disabled), and you can't transfer ownership to someone outside your organization.

Properties:

  • Config: metadata_owner
  • Env Var: RCLONE_DRIVE_METADATA_OWNER
  • Type: Bits
  • Default: read
  • Examples:
    • "off"
      • Do not read or write the value
    • "read"
      • Read the value only
    • "write"
      • Write the value only
    • "failok"
      • If writing fails log errors only, don't fail the transfer
    • "read,write"
      • Read and Write the value.

--drive-metadata-permissions

Control whether permissions should be read or written in metadata.

Reading permissions metadata from files can be done quickly, but it isn't always desirable to set the permissions from the metadata.

Note that rclone drops any inherited permissions on Shared Drives and any owner permission on My Drives as these are duplicated in the owner metadata.

Properties:

  • Config: metadata_permissions
  • Env Var: RCLONE_DRIVE_METADATA_PERMISSIONS
  • Type: Bits
  • Default: off
  • Examples:
    • "off"
      • Do not read or write the value
    • "read"
      • Read the value only
    • "write"
      • Write the value only
    • "failok"
      • If writing fails log errors only, don't fail the transfer
    • "read,write"
      • Read and Write the value.

--drive-metadata-labels

Control whether labels should be read or written in metadata.

Reading labels metadata from files takes an extra API transaction and will slow down listings. It isn't always desirable to set the labels from the metadata.

The format of labels is documented in the drive API documentation at https://developers.google.com/drive/api/reference/rest/v3/Label - rclone just provides a JSON dump of this format.

When setting labels, the label and fields must already exist - rclone will not create them. This means that if you are transferring labels from two different accounts you will have to create the labels in advance and use the metadata mapper to translate the IDs between the two accounts.

Properties:

  • Config: metadata_labels
  • Env Var: RCLONE_DRIVE_METADATA_LABELS
  • Type: Bits
  • Default: off
  • Examples:
    • "off"
      • Do not read or write the value
    • "read"
      • Read the value only
    • "write"
      • Write the value only
    • "failok"
      • If writing fails log errors only, don't fail the transfer
    • "read,write"
      • Read and Write the value.

--drive-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_DRIVE_ENCODING
  • Type: Encoding
  • Default: InvalidUtf8

--drive-env-auth

Get IAM credentials from runtime (environment variables or instance meta data if no env vars).

Only applies if service_account_file and service_account_credentials is blank.

Properties:

  • Config: env_auth
  • Env Var: RCLONE_DRIVE_ENV_AUTH
  • Type: bool
  • Default: false
  • Examples:
    • "false"
      • Enter credentials in the next step.
    • "true"
      • Get GCP IAM credentials from the environment (env vars or IAM).

--drive-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_DRIVE_DESCRIPTION
  • Type: string
  • Required: false

Metadata

User metadata is stored in the properties field of the drive object.

Metadata is supported on files and directories.

Here are the possible system metadata items for the drive backend.

Name Help Type Example Read Only
btime Time of file birth (creation) with mS accuracy. Note that this is only writable on fresh uploads - it can't be written for updates. RFC 3339 2006-01-02T15:04:05.999Z07:00 N
content-type The MIME type of the file. string text/plain N
copy-requires-writer-permission Whether the options to copy, print, or download this file, should be disabled for readers and commenters. boolean true N
description A short description of the file. string Contract for signing N
folder-color-rgb The color for a folder or a shortcut to a folder as an RGB hex string. string 881133 N
labels Labels attached to this file in a JSON dump of Googled drive format. Enable with --drive-metadata-labels. JSON [] N
mtime Time of last modification with mS accuracy. RFC 3339 2006-01-02T15:04:05.999Z07:00 N
owner The owner of the file. Usually an email address. Enable with --drive-metadata-owner. string user@example.com N
permissions Permissions in a JSON dump of Google drive format. On shared drives these will only be present if they aren't inherited. Enable with --drive-metadata-permissions. JSON {} N
starred Whether the user has starred the file. boolean false N
viewed-by-me Whether the file has been viewed by this user. boolean true Y
writers-can-share Whether users with only writer permission can modify the file's permissions. Not populated and ignored when setting for items in shared drives. boolean false N

See the metadata docs for more info.

Backend commands

Here are the commands specific to the drive backend.

Run them with

rclone backend COMMAND remote:

The help below will explain what arguments each command takes.

See the backend command for more info on how to pass options and arguments.

These can be run on a running backend using the rc command backend/command.

get

Get command for fetching the drive config parameters

rclone backend get remote: [options] [<arguments>+]

This is a get command which will be used to fetch the various drive config parameters

Usage Examples:

rclone backend get drive: [-o service_account_file] [-o chunk_size]
rclone rc backend/command command=get fs=drive: [-o service_account_file] [-o chunk_size]

Options:

  • "chunk_size": show the current upload chunk size
  • "service_account_file": show the current service account file

set

Set command for updating the drive config parameters

rclone backend set remote: [options] [<arguments>+]

This is a set command which will be used to update the various drive config parameters

Usage Examples:

rclone backend set drive: [-o service_account_file=sa.json] [-o chunk_size=67108864]
rclone rc backend/command command=set fs=drive: [-o service_account_file=sa.json] [-o chunk_size=67108864]

Options:

  • "chunk_size": update the current upload chunk size
  • "service_account_file": update the current service account file

shortcut

Create shortcuts from files or directories

rclone backend shortcut remote: [options] [<arguments>+]

This command creates shortcuts from files or directories.

Usage:

rclone backend shortcut drive: source_item destination_shortcut
rclone backend shortcut drive: source_item -o target=drive2: destination_shortcut

In the first example this creates a shortcut from the "source_item" which can be a file or a directory to the "destination_shortcut". The "source_item" and the "destination_shortcut" should be relative paths from "drive:"

In the second example this creates a shortcut from the "source_item" relative to "drive:" to the "destination_shortcut" relative to "drive2:". This may fail with a permission error if the user authenticated with "drive2:" can't read files from "drive:".

Options:

  • "target": optional target remote for the shortcut destination

drives

List the Shared Drives available to this account

rclone backend drives remote: [options] [<arguments>+]

This command lists the Shared Drives (Team Drives) available to this account.

Usage:

rclone backend [-o config] drives drive:

This will return a JSON list of objects like this

[
    {
        "id": "0ABCDEF-01234567890",
        "kind": "drive#teamDrive",
        "name": "My Drive"
    },
    {
        "id": "0ABCDEFabcdefghijkl",
        "kind": "drive#teamDrive",
        "name": "Test Drive"
    }
]

With the -o config parameter it will output the list in a format suitable for adding to a config file to make aliases for all the drives found and a combined drive.

[My Drive]
type = alias
remote = drive,team_drive=0ABCDEF-01234567890,root_folder_id=:

[Test Drive]
type = alias
remote = drive,team_drive=0ABCDEFabcdefghijkl,root_folder_id=:

[AllDrives]
type = combine
upstreams = "My Drive=My Drive:" "Test Drive=Test Drive:"

Adding this to the rclone config file will cause those team drives to be accessible with the aliases shown. Any illegal characters will be substituted with "_" and duplicate names will have numbers suffixed. It will also add a remote called AllDrives which shows all the shared drives combined into one directory tree.

untrash

Untrash files and directories

rclone backend untrash remote: [options] [<arguments>+]

This command untrashes all the files and directories in the directory passed in recursively.

Usage:

This takes an optional directory to trash which make this easier to use via the API.

rclone backend untrash drive:directory
rclone backend --interactive untrash drive:directory subdir

Use the --interactive/-i or --dry-run flag to see what would be restored before restoring it.

Result:

{
    "Untrashed": 17,
    "Errors": 0
}

copyid

Copy files by ID

rclone backend copyid remote: [options] [<arguments>+]

This command copies files by ID

Usage:

rclone backend copyid drive: ID path
rclone backend copyid drive: ID1 path1 ID2 path2

It copies the drive file with ID given to the path (an rclone path which will be passed internally to rclone copyto). The ID and path pairs can be repeated.

The path should end with a / to indicate copy the file as named to this directory. If it doesn't end with a / then the last path component will be used as the file name.

If the destination is a drive backend then server-side copying will be attempted if possible.

Use the --interactive/-i or --dry-run flag to see what would be copied before copying.

moveid

Move files by ID

rclone backend moveid remote: [options] [<arguments>+]

This command moves files by ID

Usage:

rclone backend moveid drive: ID path
rclone backend moveid drive: ID1 path1 ID2 path2

It moves the drive file with ID given to the path (an rclone path which will be passed internally to rclone moveto).

The path should end with a / to indicate move the file as named to this directory. If it doesn't end with a / then the last path component will be used as the file name.

If the destination is a drive backend then server-side moving will be attempted if possible.

Use the --interactive/-i or --dry-run flag to see what would be moved beforehand.

exportformats

Dump the export formats for debug purposes

rclone backend exportformats remote: [options] [<arguments>+]

importformats

Dump the import formats for debug purposes

rclone backend importformats remote: [options] [<arguments>+]

query

List files using Google Drive query language

rclone backend query remote: [options] [<arguments>+]

This command lists files based on a query

Usage:

rclone backend query drive: query

The query syntax is documented at Google Drive Search query terms and operators.

For example:

rclone backend query drive: "'0ABc9DEFGHIJKLMNop0QRatUVW3X' in parents and name contains 'foo'"

If the query contains literal ' or  characters, these need to be escaped with  characters. "'" becomes "'" and "" becomes "\", for example to match a file named "foo ' .txt":

rclone backend query drive: "name = 'foo \' \\\.txt'"

The result is a JSON array of matches, for example:

[
{
    "createdTime": "2017-06-29T19:58:28.537Z",
    "id": "0AxBe_CDEF4zkGHI4d0FjYko2QkD",
    "md5Checksum": "68518d16be0c6fbfab918be61d658032",
    "mimeType": "text/plain",
    "modifiedTime": "2024-02-02T10:40:02.874Z",
    "name": "foo ' \\.txt",
    "parents": [
        "0BxAe_BCDE4zkFGZpcWJGek0xbzC"
    ],
    "resourceKey": "0-ABCDEFGHIXJQpIGqBJq3MC",
    "sha1Checksum": "8f284fa768bfb4e45d076a579ab3905ab6bfa893",
    "size": "311",
    "webViewLink": "https://drive.google.com/file/d/0AxBe_CDEF4zkGHI4d0FjYko2QkD/view?usp=drivesdk\u0026resourcekey=0-ABCDEFGHIXJQpIGqBJq3MC"
}
]

rescue

Rescue or delete any orphaned files

rclone backend rescue remote: [options] [<arguments>+]

This command rescues or deletes any orphaned files or directories.

Sometimes files can get orphaned in Google Drive. This means that they are no longer in any folder in Google Drive.

This command finds those files and either rescues them to a directory you specify or deletes them.

Usage:

This can be used in 3 ways.

First, list all orphaned files

rclone backend rescue drive:

Second rescue all orphaned files to the directory indicated

rclone backend rescue drive: "relative/path/to/rescue/directory"

e.g. To rescue all orphans to a directory called "Orphans" in the top level

rclone backend rescue drive: Orphans

Third delete all orphaned files to the trash

rclone backend rescue drive: -o delete

Limitations

Drive has quite a lot of rate limiting. This causes rclone to be limited to transferring about 2 files per second only. Individual files may be transferred much faster at 100s of MiB/s but lots of small files can take a long time.

Server side copies are also subject to a separate rate limit. If you see User rate limit exceeded errors, wait at least 24 hours and retry. You can disable server-side copies with --disable copy to download and upload the files if you prefer.

Limitations of Google Docs

Google docs will appear as size -1 in rclone ls, rclone ncdu etc, and as size 0 in anything which uses the VFS layer, e.g. rclone mount and rclone serve. When calculating directory totals, e.g. in rclone size and rclone ncdu, they will be counted in as empty files.

This is because rclone can't find out the size of the Google docs without downloading them.

Google docs will transfer correctly with rclone sync, rclone copy etc as rclone knows to ignore the size when doing the transfer.

However an unfortunate consequence of this is that you may not be able to download Google docs using rclone mount. If it doesn't work you will get a 0 sized file. If you try again the doc may gain its correct size and be downloadable. Whether it will work on not depends on the application accessing the mount and the OS you are running - experiment to find out if it does work for you!

Duplicated files

Sometimes, for no reason I've been able to track down, drive will duplicate a file that rclone uploads. Drive unlike all the other remotes can have duplicated files.

Duplicated files cause problems with the syncing and you will see messages in the log about duplicates.

Use rclone dedupe to fix duplicated files.

Note that this isn't just a problem with rclone, even Google Photos on Android duplicates files on drive sometimes.

Rclone appears to be re-copying files it shouldn't

The most likely cause of this is the duplicated file issue above - run rclone dedupe and check your logs for duplicate object or directory messages.

This can also be caused by a delay/caching on google drive's end when comparing directory listings. Specifically with team drives used in combination with --fast-list. Files that were uploaded recently may not appear on the directory list sent to rclone when using --fast-list.

Waiting a moderate period of time between attempts (estimated to be approximately 1 hour) and/or not using --fast-list both seem to be effective in preventing the problem.

SHA1 or SHA256 hashes may be missing

All files have MD5 hashes, but a small fraction of files uploaded may not have SHA1 or SHA256 hashes especially if they were uploaded before 2018.

Making your own client_id

When you use rclone with Google drive in its default configuration you are using rclone's client_id. This is shared between all the rclone users. There is a global rate limit on the number of queries per second that each client_id can do set by Google. rclone already has a high quota and I will continue to make sure it is high enough by contacting Google.

It is strongly recommended to use your own client ID as the default rclone ID is heavily used. If you have multiple services running, it is recommended to use an API key for each service. The default Google quota is 10 transactions per second so it is recommended to stay under that number as if you use more than that, it will cause rclone to rate limit and make things slower.

Here is how to create your own Google Drive client ID for rclone:

  1. Log into the Google API Console with your Google account. It doesn't matter what Google account you use. (It need not be the same account as the Google Drive you want to access)

  2. Select a project or create a new project.

  3. Under "ENABLE APIS AND SERVICES" search for "Drive", and enable the "Google Drive API".

  4. Click "Credentials" in the left-side panel (not "Create credentials", which opens the wizard).

  5. If you already configured an "Oauth Consent Screen", then skip to the next step; if not, click on "CONFIGURE CONSENT SCREEN" button (near the top right corner of the right panel), then select "External" and click on "CREATE"; on the next screen, enter an "Application name" ("rclone" is OK); enter "User Support Email" (your own email is OK); enter "Developer Contact Email" (your own email is OK); then click on "Save" (all other data is optional). You will also have to add some scopes, including

  • https://www.googleapis.com/auth/docs
  • https://www.googleapis.com/auth/drive in order to be able to edit, create and delete files with RClone.
  • https://www.googleapis.com/auth/drive.metadata.readonly which you may also want to add.
  • If you want to add all at once, comma separated it would be https://www.googleapis.com/auth/docs,https://www.googleapis.com/auth/drive,https://www.googleapis.com/auth/drive.metadata.readonly.

  1. After adding scopes, click "Save and continue" to add test users. Be sure to add your own account to the test users. Once you've added yourself as a test user and saved the changes, click again on "Credentials" on the left panel to go back to the "Credentials" screen.

    (PS: if you are a GSuite user, you could also select "Internal" instead of "External" above, but this will restrict API use to Google Workspace users in your organisation).

  2. Click on the "+ CREATE CREDENTIALS" button at the top of the screen, then select "OAuth client ID".

  3. Choose an application type of "Desktop app" and click "Create". (the default name is fine)

  4. It will show you a client ID and client secret. Make a note of these.

    (If you selected "External" at Step 5 continue to Step 10. If you chose "Internal" you don't need to publish and can skip straight to Step 11 but your destination drive must be part of the same Google Workspace.)

  5. Go to "Oauth consent screen" and then click "PUBLISH APP" button and confirm. You will also want to add yourself as a test user.

  6. Provide the noted client ID and client secret to rclone.

Be aware that, due to the "enhanced security" recently introduced by Google, you are theoretically expected to "submit your app for verification" and then wait a few weeks(!) for their response; in practice, you can go right ahead and use the client ID and client secret with rclone, the only issue will be a very scary confirmation screen shown when you connect via your browser for rclone to be able to get its token-id (but as this only happens during the remote configuration, it's not such a big deal). Keeping the application in "Testing" will work as well, but the limitation is that any grants will expire after a week, which can be annoying to refresh constantly. If, for whatever reason, a short grant time is not a problem, then keeping the application in testing mode would also be sufficient.

(Thanks to @balazer on github for these instructions.)

Sometimes, creation of an OAuth consent in Google API Console fails due to an error message “The request failed because changes to one of the field of the resource is not supported”. As a convenient workaround, the necessary Google Drive API key can be created on the Python Quickstart page. Just push the Enable the Drive API button to receive the Client ID and Secret. Note that it will automatically create a new project in the API Console.

Google Photos

The rclone backend for Google Photos is a specialized backend for transferring photos and videos to and from Google Photos.

NB The Google Photos API which rclone uses has quite a few limitations, so please read the limitations section carefully to make sure it is suitable for your use.

NB From March 31, 2025 rclone can only download photos it uploaded. This limitation is due to policy changes at Google. You may need to run rclone config reconnect remote: to make rclone work again after upgrading to rclone v1.70.

Configuration

The initial setup for google cloud storage involves getting a token from Google Photos which you need to do in your browser. rclone config walks you through it.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Google Photos
   \ "google photos"
[snip]
Storage> google photos
** See help for google photos backend at: https://rclone.org/googlephotos/ **

Google Application Client Id
Leave blank normally.
Enter a string value. Press Enter for the default ("").
client_id> 
Google Application Client Secret
Leave blank normally.
Enter a string value. Press Enter for the default ("").
client_secret> 
Set to make the Google Photos backend read only.

If you choose read only then rclone will only request read only access
to your photos, otherwise rclone will request full access.
Enter a boolean value (true or false). Press Enter for the default ("false").
read_only> 
Edit advanced config? (y/n)
y) Yes
n) No
y/n> n
Remote config
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y) Yes
n) No
y/n> y
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth
Log in and authorize rclone for access
Waiting for code...
Got code

*** IMPORTANT: All media items uploaded to Google Photos with rclone
*** are stored in full resolution at original quality.  These uploads
*** will count towards storage in your Google Account.

Configuration complete.
Options:
- type: google photos
- token: {"access_token":"XXX","token_type":"Bearer","refresh_token":"XXX","expiry":"2019-06-28T17:38:04.644930156+01:00"}
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

See the remote setup docs for how to set it up on a machine with no Internet browser available.

Note that rclone runs a webserver on your local machine to collect the token as returned from Google if using web browser to automatically authenticate. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this may require you to unblock it temporarily if you are running a host firewall, or use manual mode.

This remote is called remote and can now be used like this

See all the albums in your photos

rclone lsd remote:album

Make a new album

rclone mkdir remote:album/newAlbum

List the contents of an album

rclone ls remote:album/newAlbum

Sync /home/local/images to the Google Photos, removing any excess files in the album.

rclone sync --interactive /home/local/image remote:album/newAlbum

Layout

As Google Photos is not a general purpose cloud storage system, the backend is laid out to help you navigate it.

The directories under media show different ways of categorizing the media. Each file will appear multiple times. So if you want to make a backup of your google photos you might choose to backup remote:media/by-month. (NB remote:media/by-day is rather slow at the moment so avoid for syncing.)

Note that all your photos and videos will appear somewhere under media, but they may not appear under album unless you've put them into albums.

/
- upload
    - file1.jpg
    - file2.jpg
    - ...
- media
    - all
        - file1.jpg
        - file2.jpg
        - ...
    - by-year
        - 2000
            - file1.jpg
            - ...
        - 2001
            - file2.jpg
            - ...
        - ...
    - by-month
        - 2000
            - 2000-01
                - file1.jpg
                - ...
            - 2000-02
                - file2.jpg
                - ...
        - ...
    - by-day
        - 2000
            - 2000-01-01
                - file1.jpg
                - ...
            - 2000-01-02
                - file2.jpg
                - ...
        - ...
- album
    - album name
    - album name/sub
- shared-album
    - album name
    - album name/sub
- feature
    - favorites
        - file1.jpg
        - file2.jpg

There are two writable parts of the tree, the upload directory and sub directories of the album directory.

The upload directory is for uploading files you don't want to put into albums. This will be empty to start with and will contain the files you've uploaded for one rclone session only, becoming empty again when you restart rclone. The use case for this would be if you have a load of files you just want to once off dump into Google Photos. For repeated syncing, uploading to album will work better.

Directories within the album directory are also writeable and you may create new directories (albums) under album. If you copy files with a directory hierarchy in there then rclone will create albums with the / character in them. For example if you do

rclone copy /path/to/images remote:album/images

and the images directory contains

images
    - file1.jpg
    dir
        file2.jpg
    dir2
        dir3
            file3.jpg

Then rclone will create the following albums with the following files in

  • images
    • file1.jpg
  • images/dir
    • file2.jpg
  • images/dir2/dir3
    • file3.jpg

This means that you can use the album path pretty much like a normal filesystem and it is a good target for repeated syncing.

The shared-album directory shows albums shared with you or by you. This is similar to the Sharing tab in the Google Photos web interface.

Standard options

Here are the Standard options specific to google photos (Google Photos).

--gphotos-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_GPHOTOS_CLIENT_ID
  • Type: string
  • Required: false

--gphotos-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_GPHOTOS_CLIENT_SECRET
  • Type: string
  • Required: false

--gphotos-read-only

Set to make the Google Photos backend read only.

If you choose read only then rclone will only request read only access to your photos, otherwise rclone will request full access.

Properties:

  • Config: read_only
  • Env Var: RCLONE_GPHOTOS_READ_ONLY
  • Type: bool
  • Default: false

Advanced options

Here are the Advanced options specific to google photos (Google Photos).

--gphotos-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_GPHOTOS_TOKEN
  • Type: string
  • Required: false

--gphotos-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_GPHOTOS_AUTH_URL
  • Type: string
  • Required: false

--gphotos-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_GPHOTOS_TOKEN_URL
  • Type: string
  • Required: false

--gphotos-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_GPHOTOS_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--gphotos-read-size

Set to read the size of media items.

Normally rclone does not read the size of media items since this takes another transaction. This isn't necessary for syncing. However rclone mount needs to know the size of files in advance of reading them, so setting this flag when using rclone mount is recommended if you want to read the media.

Properties:

  • Config: read_size
  • Env Var: RCLONE_GPHOTOS_READ_SIZE
  • Type: bool
  • Default: false

--gphotos-start-year

Year limits the photos to be downloaded to those which are uploaded after the given year.

Properties:

  • Config: start_year
  • Env Var: RCLONE_GPHOTOS_START_YEAR
  • Type: int
  • Default: 2000

--gphotos-include-archived

Also view and download archived media.

By default, rclone does not request archived media. Thus, when syncing, archived media is not visible in directory listings or transferred.

Note that media in albums is always visible and synced, no matter their archive status.

With this flag, archived media are always visible in directory listings and transferred.

Without this flag, archived media will not be visible in directory listings and won't be transferred.

Properties:

  • Config: include_archived
  • Env Var: RCLONE_GPHOTOS_INCLUDE_ARCHIVED
  • Type: bool
  • Default: false

--gphotos-proxy

Use the gphotosdl proxy for downloading the full resolution images

The Google API will deliver images and video which aren't full resolution, and/or have EXIF data missing.

However if you use the gphotosdl proxy then you can download original, unchanged images.

This runs a headless browser in the background.

Download the software from gphotosdl

First run with

gphotosdl -login

Then once you have logged into google photos close the browser window and run

gphotosdl

Then supply the parameter --gphotos-proxy "http://localhost:8282" to make rclone use the proxy.

Properties:

  • Config: proxy
  • Env Var: RCLONE_GPHOTOS_PROXY
  • Type: string
  • Required: false

--gphotos-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_GPHOTOS_ENCODING
  • Type: Encoding
  • Default: Slash,CrLf,InvalidUtf8,Dot

--gphotos-batch-mode

Upload file batching sync|async|off.

This sets the batch mode used by rclone.

This has 3 possible values

  • off - no batching
  • sync - batch uploads and check completion (default)
  • async - batch upload and don't check completion

Rclone will close any outstanding batches when it exits which may make a delay on quit.

Properties:

  • Config: batch_mode
  • Env Var: RCLONE_GPHOTOS_BATCH_MODE
  • Type: string
  • Default: "sync"

--gphotos-batch-size

Max number of files in upload batch.

This sets the batch size of files to upload. It has to be less than 50.

By default this is 0 which means rclone will calculate the batch size depending on the setting of batch_mode.

  • batch_mode: async - default batch_size is 50
  • batch_mode: sync - default batch_size is the same as --transfers
  • batch_mode: off - not in use

Rclone will close any outstanding batches when it exits which may make a delay on quit.

Setting this is a great idea if you are uploading lots of small files as it will make them a lot quicker. You can use --transfers 32 to maximise throughput.

Properties:

  • Config: batch_size
  • Env Var: RCLONE_GPHOTOS_BATCH_SIZE
  • Type: int
  • Default: 0

--gphotos-batch-timeout

Max time to allow an idle upload batch before uploading.

If an upload batch is idle for more than this long then it will be uploaded.

The default for this is 0 which means rclone will choose a sensible default based on the batch_mode in use.

  • batch_mode: async - default batch_timeout is 10s
  • batch_mode: sync - default batch_timeout is 1s
  • batch_mode: off - not in use

Properties:

  • Config: batch_timeout
  • Env Var: RCLONE_GPHOTOS_BATCH_TIMEOUT
  • Type: Duration
  • Default: 0s

--gphotos-batch-commit-timeout

Max time to wait for a batch to finish committing. (no longer used)

Properties:

  • Config: batch_commit_timeout
  • Env Var: RCLONE_GPHOTOS_BATCH_COMMIT_TIMEOUT
  • Type: Duration
  • Default: 10m0s

--gphotos-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_GPHOTOS_DESCRIPTION
  • Type: string
  • Required: false

Limitations

Only images and videos can be uploaded. If you attempt to upload non videos or images or formats that Google Photos doesn't understand, rclone will upload the file, then Google Photos will give an error when it is put turned into a media item.

NB From March 31, 2025 rclone can only download photos it uploaded. This limitation is due to policy changes at Google. You may need to run rclone config reconnect remote: to make rclone work again after upgrading to rclone v1.70.

Note that all media items uploaded to Google Photos through the API are stored in full resolution at "original quality" and will count towards your storage quota in your Google Account. The API does not offer a way to upload in "high quality" mode..

rclone about is not supported by the Google Photos backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about See rclone about

Downloading Images

When Images are downloaded this strips EXIF location (according to the docs and my tests). This is a limitation of the Google Photos API and is covered by bug #112096115.

The current google API does not allow photos to be downloaded at original resolution. This is very important if you are, for example, relying on "Google Photos" as a backup of your photos. You will not be able to use rclone to redownload original images. You could use 'google takeout' to recover the original photos as a last resort

NB you can use the --gphotos-proxy flag to use a headless browser to download images in full resolution.

Downloading Videos

When videos are downloaded they are downloaded in a really compressed version of the video compared to downloading it via the Google Photos web interface. This is covered by bug #113672044.

NB you can use the --gphotos-proxy flag to use a headless browser to download images in full resolution.

Duplicates

If a file name is duplicated in a directory then rclone will add the file ID into its name. So two files called file.jpg would then appear as file {123456}.jpg and file {ABCDEF}.jpg (the actual IDs are a lot longer alas!).

If you upload the same image (with the same binary data) twice then Google Photos will deduplicate it. However it will retain the filename from the first upload which may confuse rclone. For example if you uploaded an image to upload then uploaded the same image to album/my_album the filename of the image in album/my_album will be what it was uploaded with initially, not what you uploaded it with to album. In practise this shouldn't cause too many problems.

Modification times

The date shown of media in Google Photos is the creation date as determined by the EXIF information, or the upload date if that is not known.

This is not changeable by rclone and is not the modification date of the media on local disk. This means that rclone cannot use the dates from Google Photos for syncing purposes.

Size

The Google Photos API does not return the size of media. This means that when syncing to Google Photos, rclone can only do a file existence check.

It is possible to read the size of the media, but this needs an extra HTTP HEAD request per media item so is very slow and uses up a lot of transactions. This can be enabled with the --gphotos-read-size option or the read_size = true config parameter.

If you want to use the backend with rclone mount you may need to enable this flag (depending on your OS and application using the photos) otherwise you may not be able to read media off the mount. You'll need to experiment to see if it works for you without the flag.

Albums

Rclone can only upload files to albums it created. This is a limitation of the Google Photos API.

Rclone can remove files it uploaded from albums it created only.

Deleting files

Rclone can remove files from albums it created, but note that the Google Photos API does not allow media to be deleted permanently so this media will still remain. See bug #109759781.

Rclone cannot delete files anywhere except under album.

Deleting albums

The Google Photos API does not support deleting albums - see bug #135714733.

Making your own client_id

When you use rclone with Google photos in its default configuration you are using rclone's client_id. This is shared between all the rclone users. There is a global rate limit on the number of queries per second that each client_id can do set by Google.

If there is a problem with this client_id (eg quota too low or the client_id stops working) then you can make your own.

Please follow the steps in the google drive docs. You will need these scopes instead of the drive ones detailed:

https://www.googleapis.com/auth/photoslibrary.appendonly
https://www.googleapis.com/auth/photoslibrary.readonly.appcreateddata
https://www.googleapis.com/auth/photoslibrary.edit.appcreateddata

Hasher

Hasher is a special overlay backend to create remotes which handle checksums for other remotes. It's main functions include: - Emulate hash types unimplemented by backends - Cache checksums to help with slow hashing of large local or (S)FTP files - Warm up checksum cache from external SUM files

Getting started

To use Hasher, first set up the underlying remote following the configuration instructions for that remote. You can also use a local pathname instead of a remote. Check that your base remote is working.

Let's call the base remote myRemote:path here. Note that anything inside myRemote:path will be handled by hasher and anything outside won't. This means that if you are using a bucket based remote (S3, B2, Swift) then you should put the bucket in the remote s3:bucket.

Now proceed to interactive or manual configuration.

Interactive configuration

Run rclone config:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> Hasher1
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Handle checksums for other remotes
   \ "hasher"
[snip]
Storage> hasher
Remote to cache checksums for, like myremote:mypath.
Enter a string value. Press Enter for the default ("").
remote> myRemote:path
Comma separated list of supported checksum types.
Enter a string value. Press Enter for the default ("md5,sha1").
hashsums> md5
Maximum time to keep checksums in cache. 0 = no cache, off = cache forever.
max_age> off
Edit advanced config? (y/n)
y) Yes
n) No
y/n> n
Remote config
--------------------
[Hasher1]
type = hasher
remote = myRemote:path
hashsums = md5
max_age = off
--------------------
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

Manual configuration

Run rclone config path to see the path of current active config file, usually YOURHOME/.config/rclone/rclone.conf. Open it in your favorite text editor, find section for the base remote and create new section for hasher like in the following examples:

[Hasher1]
type = hasher
remote = myRemote:path
hashes = md5
max_age = off

[Hasher2]
type = hasher
remote = /local/path
hashes = dropbox,sha1
max_age = 24h

Hasher takes basically the following parameters: - remote is required, - hashes is a comma separated list of supported checksums (by default md5,sha1), - max_age - maximum time to keep a checksum value in the cache, 0 will disable caching completely, off will cache "forever" (that is until the files get changed).

Make sure the remote has : (colon) in. If you specify the remote without a colon then rclone will use a local directory of that name. So if you use a remote of /local/path then rclone will handle hashes for that directory. If you use remote = name literally then rclone will put files in a directory called name located under current directory.

Usage

Basic operations

Now you can use it as Hasher2:subdir/file instead of base remote. Hasher will transparently update cache with new checksums when a file is fully read or overwritten, like:

rclone copy External:path/file Hasher:dest/path

rclone cat Hasher:path/to/file > /dev/null

The way to refresh all cached checksums (even unsupported by the base backend) for a subtree is to re-download all files in the subtree. For example, use hashsum --download using any supported hashsum on the command line (we just care to re-read):

rclone hashsum MD5 --download Hasher:path/to/subtree > /dev/null

rclone backend dump Hasher:path/to/subtree

You can print or drop hashsum cache using custom backend commands:

rclone backend dump Hasher:dir/subdir

rclone backend drop Hasher:

Pre-Seed from a SUM File

Hasher supports two backend commands: generic SUM file import and faster but less consistent stickyimport.

rclone backend import Hasher:dir/subdir SHA1 /path/to/SHA1SUM [--checkers 4]

Instead of SHA1 it can be any hash supported by the remote. The last argument can point to either a local or an other-remote:path text file in SUM format. The command will parse the SUM file, then walk down the path given by the first argument, snapshot current fingerprints and fill in the cache entries correspondingly. - Paths in the SUM file are treated as relative to hasher:dir/subdir. - The command will not check that supplied values are correct. You must know what you are doing. - This is a one-time action. The SUM file will not get "attached" to the remote. Cache entries can still be overwritten later, should the object's fingerprint change. - The tree walk can take long depending on the tree size. You can increase --checkers to make it faster. Or use stickyimport if you don't care about fingerprints and consistency.

rclone backend stickyimport hasher:path/to/data sha1 remote:/path/to/sum.sha1

stickyimport is similar to import but works much faster because it does not need to stat existing files and skips initial tree walk. Instead of binding cache entries to file fingerprints it creates sticky entries bound to the file name alone ignoring size, modification time etc. Such hash entries can be replaced only by purge, delete, backend drop or by full re-read/re-write of the files.

Configuration reference

Standard options

Here are the Standard options specific to hasher (Better checksums for other remotes).

--hasher-remote

Remote to cache checksums for (e.g. myRemote:path).

Properties:

  • Config: remote
  • Env Var: RCLONE_HASHER_REMOTE
  • Type: string
  • Required: true

--hasher-hashes

Comma separated list of supported checksum types.

Properties:

  • Config: hashes
  • Env Var: RCLONE_HASHER_HASHES
  • Type: CommaSepList
  • Default: md5,sha1

--hasher-max-age

Maximum time to keep checksums in cache (0 = no cache, off = cache forever).

Properties:

  • Config: max_age
  • Env Var: RCLONE_HASHER_MAX_AGE
  • Type: Duration
  • Default: off

Advanced options

Here are the Advanced options specific to hasher (Better checksums for other remotes).

--hasher-auto-size

Auto-update checksum for files smaller than this size (disabled by default).

Properties:

  • Config: auto_size
  • Env Var: RCLONE_HASHER_AUTO_SIZE
  • Type: SizeSuffix
  • Default: 0

--hasher-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_HASHER_DESCRIPTION
  • Type: string
  • Required: false

Metadata

Any metadata supported by the underlying remote is read and written.

See the metadata docs for more info.

Backend commands

Here are the commands specific to the hasher backend.

Run them with

rclone backend COMMAND remote:

The help below will explain what arguments each command takes.

See the backend command for more info on how to pass options and arguments.

These can be run on a running backend using the rc command backend/command.

drop

Drop cache

rclone backend drop remote: [options] [<arguments>+]

Completely drop checksum cache. Usage Example: rclone backend drop hasher:

dump

Dump the database

rclone backend dump remote: [options] [<arguments>+]

Dump cache records covered by the current remote

fulldump

Full dump of the database

rclone backend fulldump remote: [options] [<arguments>+]

Dump all cache records in the database

import

Import a SUM file

rclone backend import remote: [options] [<arguments>+]

Amend hash cache from a SUM file and bind checksums to files by size/time. Usage Example: rclone backend import hasher:subdir md5 /path/to/sum.md5

stickyimport

Perform fast import of a SUM file

rclone backend stickyimport remote: [options] [<arguments>+]

Fill hash cache from a SUM file without verifying file fingerprints. Usage Example: rclone backend stickyimport hasher:subdir md5 remote:path/to/sum.md5

Implementation details (advanced)

This section explains how various rclone operations work on a hasher remote.

Disclaimer. This section describes current implementation which can change in future rclone versions!.

Hashsum command

The rclone hashsum (or md5sum or sha1sum) command will:

  1. if requested hash is supported by lower level, just pass it.
  2. if object size is below auto_size then download object and calculate requested hashes on the fly.
  3. if unsupported and the size is big enough, build object fingerprint (including size, modtime if supported, first-found other hash if any).
  4. if the strict match is found in cache for the requested remote, return the stored hash.
  5. if remote found but fingerprint mismatched, then purge the entry and proceed to step 6.
  6. if remote not found or had no requested hash type or after step 5: download object, calculate all supported hashes on the fly and store in cache; return requested hash.

Other operations

  • any time a hash is requested, follow the logic from 1-4 from hashsum above
  • whenever a file is uploaded or downloaded in full, capture the stream to calculate all supported hashes on the fly and update database
  • server-side move will update keys of existing cache entries
  • deletefile will remove a single cache entry
  • purge will remove all cache entries under the purged path

Note that setting max_age = 0 will disable checksum caching completely.

If you set max_age = off, checksums in cache will never age, unless you fully rewrite or delete the file.

Cache storage

Cached checksums are stored as bolt database files under rclone cache directory, usually ~/.cache/rclone/kv/. Databases are maintained one per base backend, named like BaseRemote~hasher.bolt. Checksums for multiple alias-es into a single base backend will be stored in the single database. All local paths are treated as aliases into the local backend (unless encrypted or chunked) and stored in ~/.cache/rclone/kv/local~hasher.bolt. Databases can be shared between multiple rclone processes.

HDFS

HDFS is a distributed file-system, part of the Apache Hadoop framework.

Paths are specified as remote: or remote:path/to/dir.

Configuration

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[skip]
XX / Hadoop distributed file system
   \ "hdfs"
[skip]
Storage> hdfs
** See help for hdfs backend at: https://rclone.org/hdfs/ **

hadoop name node and port
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / Connect to host namenode at port 8020
   \ "namenode:8020"
namenode> namenode.hadoop:8020
hadoop user name
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / Connect to hdfs as root
   \ "root"
username> root
Edit advanced config? (y/n)
y) Yes
n) No (default)
y/n> n
Remote config
Configuration complete.
Options:
- type: hdfs
- namenode: namenode.hadoop:8020
- username: root
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y
Current remotes:

Name                 Type
====                 ====
hadoop               hdfs

e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> q

This remote is called remote and can now be used like this

See all the top level directories

rclone lsd remote:

List the contents of a directory

rclone ls remote:directory

Sync the remote directory to /home/local/directory, deleting any excess files.

rclone sync --interactive remote:directory /home/local/directory

Setting up your own HDFS instance for testing

You may start with a manual setup or use the docker image from the tests:

If you want to build the docker image

git clone https://github.com/rclone/rclone.git
cd rclone/fstest/testserver/images/test-hdfs
docker build --rm -t rclone/test-hdfs .

Or you can just use the latest one pushed

docker run --rm --name "rclone-hdfs" -p 127.0.0.1:9866:9866 -p 127.0.0.1:8020:8020 --hostname "rclone-hdfs" rclone/test-hdfs

NB it need few seconds to startup.

For this docker image the remote needs to be configured like this:

[remote]
type = hdfs
namenode = 127.0.0.1:8020
username = root

You can stop this image with docker kill rclone-hdfs (NB it does not use volumes, so all data uploaded will be lost.)

Modification times

Time accurate to 1 second is stored.

Checksum

No checksums are implemented.

Usage information

You can use the rclone about remote: command which will display filesystem size and current usage.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
: 0x3A ：

Invalid UTF-8 bytes will also be replaced.

Standard options

Here are the Standard options specific to hdfs (Hadoop distributed file system).

--hdfs-namenode

Hadoop name nodes and ports.

E.g. "namenode-1:8020,namenode-2:8020,..." to connect to host namenodes at port 8020.

Properties:

  • Config: namenode
  • Env Var: RCLONE_HDFS_NAMENODE
  • Type: CommaSepList
  • Default:

--hdfs-username

Hadoop user name.

Properties:

  • Config: username
  • Env Var: RCLONE_HDFS_USERNAME
  • Type: string
  • Required: false
  • Examples:
    • "root"
      • Connect to hdfs as root.

Advanced options

Here are the Advanced options specific to hdfs (Hadoop distributed file system).

--hdfs-service-principal-name

Kerberos service principal name for the namenode.

Enables KERBEROS authentication. Specifies the Service Principal Name (SERVICE/FQDN) for the namenode. E.g. "hdfs/namenode.hadoop.docker" for namenode running as service 'hdfs' with FQDN 'namenode.hadoop.docker'.

Properties:

  • Config: service_principal_name
  • Env Var: RCLONE_HDFS_SERVICE_PRINCIPAL_NAME
  • Type: string
  • Required: false

--hdfs-data-transfer-protection

Kerberos data transfer protection: authentication|integrity|privacy.

Specifies whether or not authentication, data signature integrity checks, and wire encryption are required when communicating with the datanodes. Possible values are 'authentication', 'integrity' and 'privacy'. Used only with KERBEROS enabled.

Properties:

  • Config: data_transfer_protection
  • Env Var: RCLONE_HDFS_DATA_TRANSFER_PROTECTION
  • Type: string
  • Required: false
  • Examples:
    • "privacy"
      • Ensure authentication, integrity and encryption enabled.

--hdfs-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_HDFS_ENCODING
  • Type: Encoding
  • Default: Slash,Colon,Del,Ctl,InvalidUtf8,Dot

--hdfs-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_HDFS_DESCRIPTION
  • Type: string
  • Required: false

Limitations

  • No server-side Move or DirMove.
  • Checksums not implemented.

HiDrive

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

The initial setup for hidrive involves getting a token from HiDrive which you need to do in your browser. rclone config walks you through it.

Configuration

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found - make a new one
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / HiDrive
   \ "hidrive"
[snip]
Storage> hidrive
OAuth Client Id - Leave blank normally.
client_id>
OAuth Client Secret - Leave blank normally.
client_secret>
Access permissions that rclone should use when requesting access from HiDrive.
Leave blank normally.
scope_access>
Edit advanced config?
y/n> n
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y/n> y
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth?state=xxxxxxxxxxxxxxxxxxxxxx
Log in and authorize rclone for access
Waiting for code...
Got code
Configuration complete.
Options:
- type: hidrive
- token: {"access_token":"xxxxxxxxxxxxxxxxxxxx","token_type":"Bearer","refresh_token":"xxxxxxxxxxxxxxxxxxxxxxx","expiry":"xxxxxxxxxxxxxxxxxxxxxxx"}
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

You should be aware that OAuth-tokens can be used to access your account and hence should not be shared with other persons. See the below section for more information.

See the remote setup docs for how to set it up on a machine with no Internet browser available.

Note that rclone runs a webserver on your local machine to collect the token as returned from HiDrive. This only runs from the moment it opens your browser to the moment you get back the verification code. The webserver runs on http://127.0.0.1:53682/. If local port 53682 is protected by a firewall you may need to temporarily unblock the firewall to complete authorization.

Once configured you can then use rclone like this,

List directories in top level of your HiDrive root folder

rclone lsd remote:

List all the files in your HiDrive filesystem

rclone ls remote:

To copy a local directory to a HiDrive directory called backup

rclone copy /home/source remote:backup

Keeping your tokens safe

Any OAuth-tokens will be stored by rclone in the remote's configuration file as unencrypted text. Anyone can use a valid refresh-token to access your HiDrive filesystem without knowing your password. Therefore you should make sure no one else can access your configuration.

It is possible to encrypt rclone's configuration file. You can find information on securing your configuration file by viewing the configuration encryption docs.

Invalid refresh token

As can be verified here, each refresh_token (for Native Applications) is valid for 60 days. If used to access HiDrivei, its validity will be automatically extended.

This means that if you

  • Don't use the HiDrive remote for 60 days

then rclone will return an error which includes a text that implies the refresh token is invalid or expired.

To fix this you will need to authorize rclone to access your HiDrive account again.

Using

rclone config reconnect remote:

the process is very similar to the process of initial setup exemplified before.

Modification times and hashes

HiDrive allows modification times to be set on objects accurate to 1 second.

HiDrive supports its own hash type which is used to verify the integrity of file contents after successful transfers.

Restricted filename characters

HiDrive cannot store files or folders that include / (0x2F) or null-bytes (0x00) in their name. Any other characters can be used in the names of files or folders. Additionally, files or folders cannot be named either of the following: . or ..

Therefore rclone will automatically replace these characters, if files or folders are stored or accessed with such names.

You can read about how this filename encoding works in general here.

Keep in mind that HiDrive only supports file or folder names with a length of 255 characters or less.

Transfers

HiDrive limits file sizes per single request to a maximum of 2 GiB. To allow storage of larger files and allow for better upload performance, the hidrive backend will use a chunked transfer for files larger than 96 MiB. Rclone will upload multiple parts/chunks of the file at the same time. Chunks in the process of being uploaded are buffered in memory, so you may want to restrict this behaviour on systems with limited resources.

You can customize this behaviour using the following options:

  • chunk_size: size of file parts
  • upload_cutoff: files larger or equal to this in size will use a chunked transfer
  • upload_concurrency: number of file-parts to upload at the same time

See the below section about configuration options for more details.

Root folder

You can set the root folder for rclone. This is the directory that rclone considers to be the root of your HiDrive.

Usually, you will leave this blank, and rclone will use the root of the account.

However, you can set this to restrict rclone to a specific folder hierarchy.

This works by prepending the contents of the root_prefix option to any paths accessed by rclone. For example, the following two ways to access the home directory are equivalent:

rclone lsd --hidrive-root-prefix="/users/test/" remote:path

rclone lsd remote:/users/test/path

See the below section about configuration options for more details.

Directory member count

By default, rclone will know the number of directory members contained in a directory. For example, rclone lsd uses this information.

The acquisition of this information will result in additional time costs for HiDrive's API. When dealing with large directory structures, it may be desirable to circumvent this time cost, especially when this information is not explicitly needed. For this, the disable_fetching_member_count option can be used.

See the below section about configuration options for more details.

Standard options

Here are the Standard options specific to hidrive (HiDrive).

--hidrive-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_HIDRIVE_CLIENT_ID
  • Type: string
  • Required: false

--hidrive-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_HIDRIVE_CLIENT_SECRET
  • Type: string
  • Required: false

--hidrive-scope-access

Access permissions that rclone should use when requesting access from HiDrive.

Properties:

  • Config: scope_access
  • Env Var: RCLONE_HIDRIVE_SCOPE_ACCESS
  • Type: string
  • Default: "rw"
  • Examples:
    • "rw"
      • Read and write access to resources.
    • "ro"
      • Read-only access to resources.

Advanced options

Here are the Advanced options specific to hidrive (HiDrive).

--hidrive-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_HIDRIVE_TOKEN
  • Type: string
  • Required: false

--hidrive-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_HIDRIVE_AUTH_URL
  • Type: string
  • Required: false

--hidrive-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_HIDRIVE_TOKEN_URL
  • Type: string
  • Required: false

--hidrive-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_HIDRIVE_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--hidrive-scope-role

User-level that rclone should use when requesting access from HiDrive.

Properties:

  • Config: scope_role
  • Env Var: RCLONE_HIDRIVE_SCOPE_ROLE
  • Type: string
  • Default: "user"
  • Examples:
    • "user"
      • User-level access to management permissions.
      • This will be sufficient in most cases.
    • "admin"
      • Extensive access to management permissions.
    • "owner"
      • Full access to management permissions.

--hidrive-root-prefix

The root/parent folder for all paths.

Fill in to use the specified folder as the parent for all paths given to the remote. This way rclone can use any folder as its starting point.

Properties:

  • Config: root_prefix
  • Env Var: RCLONE_HIDRIVE_ROOT_PREFIX
  • Type: string
  • Default: "/"
  • Examples:
    • "/"
      • The topmost directory accessible by rclone.
      • This will be equivalent with "root" if rclone uses a regular HiDrive user account.
    • "root"
      • The topmost directory of the HiDrive user account
    • ""
      • This specifies that there is no root-prefix for your paths.
      • When using this you will always need to specify paths to this remote with a valid parent e.g. "remote:/path/to/dir" or "remote:root/path/to/dir".

--hidrive-endpoint

Endpoint for the service.

This is the URL that API-calls will be made to.

Properties:

  • Config: endpoint
  • Env Var: RCLONE_HIDRIVE_ENDPOINT
  • Type: string
  • Default: "https://api.hidrive.strato.com/2.1"

--hidrive-disable-fetching-member-count

Do not fetch number of objects in directories unless it is absolutely necessary.

Requests may be faster if the number of objects in subdirectories is not fetched.

Properties:

  • Config: disable_fetching_member_count
  • Env Var: RCLONE_HIDRIVE_DISABLE_FETCHING_MEMBER_COUNT
  • Type: bool
  • Default: false

--hidrive-chunk-size

Chunksize for chunked uploads.

Any files larger than the configured cutoff (or files of unknown size) will be uploaded in chunks of this size.

The upper limit for this is 2147483647 bytes (about 2.000Gi). That is the maximum amount of bytes a single upload-operation will support. Setting this above the upper limit or to a negative value will cause uploads to fail.

Setting this to larger values may increase the upload speed at the cost of using more memory. It can be set to smaller values smaller to save on memory.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_HIDRIVE_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 48Mi

--hidrive-upload-cutoff

Cutoff/Threshold for chunked uploads.

Any files larger than this will be uploaded in chunks of the configured chunksize.

The upper limit for this is 2147483647 bytes (about 2.000Gi). That is the maximum amount of bytes a single upload-operation will support. Setting this above the upper limit will cause uploads to fail.

Properties:

  • Config: upload_cutoff
  • Env Var: RCLONE_HIDRIVE_UPLOAD_CUTOFF
  • Type: SizeSuffix
  • Default: 96Mi

--hidrive-upload-concurrency

Concurrency for chunked uploads.

This is the upper limit for how many transfers for the same file are running concurrently. Setting this above to a value smaller than 1 will cause uploads to deadlock.

If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers.

Properties:

  • Config: upload_concurrency
  • Env Var: RCLONE_HIDRIVE_UPLOAD_CONCURRENCY
  • Type: int
  • Default: 4

--hidrive-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_HIDRIVE_ENCODING
  • Type: Encoding
  • Default: Slash,Dot

--hidrive-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_HIDRIVE_DESCRIPTION
  • Type: string
  • Required: false

Limitations

HiDrive is able to store symbolic links (symlinks) by design, for example, when unpacked from a zip archive.

There exists no direct mechanism to manage native symlinks in remotes. As such this implementation has chosen to ignore any native symlinks present in the remote. rclone will not be able to access or show any symlinks stored in the hidrive-remote. This means symlinks cannot be individually removed, copied, or moved, except when removing, copying, or moving the parent folder.

This does not affect the .rclonelink-files that rclone uses to encode and store symbolic links.

Sparse files

It is possible to store sparse files in HiDrive.

Note that copying a sparse file will expand the holes into null-byte (0x00) regions that will then consume disk space. Likewise, when downloading a sparse file, the resulting file will have null-byte regions in the place of file holes.

HTTP

The HTTP remote is a read only remote for reading files of a webserver. The webserver should provide file listings which rclone will read and turn into a remote. This has been tested with common webservers such as Apache/Nginx/Caddy and will likely work with file listings from most web servers. (If it doesn't then please file an issue, or send a pull request!)

Paths are specified as remote: or remote:path.

The remote: represents the configured url, and any path following it will be resolved relative to this url, according to the URL standard. This means with remote url https://beta.rclone.org/branch and path fix, the resolved URL will be https://beta.rclone.org/branch/fix, while with path /fix the resolved URL will be https://beta.rclone.org/fix as the absolute path is resolved from the root of the domain.

If the path following the remote: ends with / it will be assumed to point to a directory. If the path does not end with /, then a HEAD request is sent and the response used to decide if it it is treated as a file or a directory (run with -vv to see details). When --http-no-head is specified, a path without ending / is always assumed to be a file. If rclone incorrectly assumes the path is a file, the solution is to specify the path with ending /. When you know the path is a directory, ending it with / is always better as it avoids the initial HEAD request.

To just download a single file it is easier to use copyurl.

Configuration

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / HTTP
   \ "http"
[snip]
Storage> http
URL of http host to connect to
Choose a number from below, or type in your own value
 1 / Connect to example.com
   \ "https://example.com"
url> https://beta.rclone.org
Remote config
Configuration complete.
Options:
- type: http
- url: https://beta.rclone.org
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y
Current remotes:

Name                 Type
====                 ====
remote               http

e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> q

This remote is called remote and can now be used like this

See all the top level directories

rclone lsd remote:

List the contents of a directory

rclone ls remote:directory

Sync the remote directory to /home/local/directory, deleting any excess files.

rclone sync --interactive remote:directory /home/local/directory

Read only

This remote is read only - you can't upload files to an HTTP server.

Modification times

Most HTTP servers store time accurate to 1 second.

Checksum

No checksums are stored.

Usage without a config file

Since the http remote only has one config parameter it is easy to use without a config file:

rclone lsd --http-url https://beta.rclone.org :http:

or:

rclone lsd :http,url='https://beta.rclone.org':

Standard options

Here are the Standard options specific to http (HTTP).

--http-url

URL of HTTP host to connect to.

E.g. "https://example.com", or "https://user:pass@example.com" to use a username and password.

Properties:

  • Config: url
  • Env Var: RCLONE_HTTP_URL
  • Type: string
  • Required: true

--http-no-escape

Do not escape URL metacharacters in path names.

Properties:

  • Config: no_escape
  • Env Var: RCLONE_HTTP_NO_ESCAPE
  • Type: bool
  • Default: false

Advanced options

Here are the Advanced options specific to http (HTTP).

--http-headers

Set HTTP headers for all transactions.

Use this to set additional HTTP headers for all transactions.

The input format is comma separated list of key,value pairs. Standard CSV encoding may be used.

For example, to set a Cookie use 'Cookie,name=value', or '"Cookie","name=value"'.

You can set multiple headers, e.g. '"Cookie","name=value","Authorization","xxx"'.

Properties:

  • Config: headers
  • Env Var: RCLONE_HTTP_HEADERS
  • Type: CommaSepList
  • Default:

--http-no-slash

Set this if the site doesn't end directories with /.

Use this if your target website does not use / on the end of directories.

A / on the end of a path is how rclone normally tells the difference between files and directories. If this flag is set, then rclone will treat all files with Content-Type: text/html as directories and read URLs from them rather than downloading them.

Note that this may cause rclone to confuse genuine HTML files with directories.

Properties:

  • Config: no_slash
  • Env Var: RCLONE_HTTP_NO_SLASH
  • Type: bool
  • Default: false

--http-no-head

Don't use HEAD requests.

HEAD requests are mainly used to find file sizes in dir listing. If your site is being very slow to load then you can try this option. Normally rclone does a HEAD request for each potential file in a directory listing to:

  • find its size
  • check it really exists
  • check to see if it is a directory

If you set this option, rclone will not do the HEAD request. This will mean that directory listings are much quicker, but rclone won't have the times or sizes of any files, and some files that don't exist may be in the listing.

Properties:

  • Config: no_head
  • Env Var: RCLONE_HTTP_NO_HEAD
  • Type: bool
  • Default: false

--http-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_HTTP_DESCRIPTION
  • Type: string
  • Required: false

Backend commands

Here are the commands specific to the http backend.

Run them with

rclone backend COMMAND remote:

The help below will explain what arguments each command takes.

See the backend command for more info on how to pass options and arguments.

These can be run on a running backend using the rc command backend/command.

set

Set command for updating the config parameters.

rclone backend set remote: [options] [<arguments>+]

This set command can be used to update the config parameters for a running http backend.

Usage Examples:

rclone backend set remote: [-o opt_name=opt_value] [-o opt_name2=opt_value2]
rclone rc backend/command command=set fs=remote: [-o opt_name=opt_value] [-o opt_name2=opt_value2]
rclone rc backend/command command=set fs=remote: -o url=https://example.com

The option keys are named as they are in the config file.

This rebuilds the connection to the http backend when it is called with the new parameters. Only new parameters need be passed as the values will default to those currently in use.

It doesn't return anything.

Limitations

rclone about is not supported by the HTTP backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

ImageKit

This is a backend for the ImageKit.io storage service.

About ImageKit

ImageKit.io provides real-time image and video optimizations, transformations, and CDN delivery. Over 1,000 businesses and 70,000 developers trust ImageKit with their images and videos on the web.

Accounts & Pricing

To use this backend, you need to create an account on ImageKit. Start with a free plan with generous usage limits. Then, as your requirements grow, upgrade to a plan that best fits your needs. See the pricing details.

Configuration

Here is an example of making an imagekit configuration.

Firstly create a ImageKit.io account and choose a plan.

You will need to log in and get the publicKey and privateKey for your account from the developer section.

Now run

rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter the name for the new remote.
name> imagekit-media-library

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / ImageKit.io
\ (imagekit)
[snip]
Storage> imagekit
  
Option endpoint.
You can find your ImageKit.io URL endpoint in your [dashboard](https://imagekit.io/dashboard/developer/api-keys)
Enter a value.
endpoint> https://ik.imagekit.io/imagekit_id  

Option public_key.
You can find your ImageKit.io public key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys)
Enter a value.
public_key> public_****************************

Option private_key.
You can find your ImageKit.io private key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys)
Enter a value.
private_key> private_****************************

Edit advanced config?
y) Yes
n) No (default)
y/n> n

Configuration complete.
Options:
- type: imagekit
- endpoint: https://ik.imagekit.io/imagekit_id
- public_key: public_****************************
- private_key: private_****************************

Keep this "imagekit-media-library" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

List directories in the top level of your Media Library

rclone lsd imagekit-media-library:

Make a new directory.

rclone mkdir imagekit-media-library:directory

List the contents of a directory.

rclone ls imagekit-media-library:directory

Modified time and hashes

ImageKit does not support modification times or hashes yet.

Checksums

No checksums are supported.

Standard options

Here are the Standard options specific to imagekit (ImageKit.io).

--imagekit-endpoint

You can find your ImageKit.io URL endpoint in your dashboard

Properties:

  • Config: endpoint
  • Env Var: RCLONE_IMAGEKIT_ENDPOINT
  • Type: string
  • Required: true

--imagekit-public-key

You can find your ImageKit.io public key in your dashboard

Properties:

  • Config: public_key
  • Env Var: RCLONE_IMAGEKIT_PUBLIC_KEY
  • Type: string
  • Required: true

--imagekit-private-key

You can find your ImageKit.io private key in your dashboard

Properties:

  • Config: private_key
  • Env Var: RCLONE_IMAGEKIT_PRIVATE_KEY
  • Type: string
  • Required: true

Advanced options

Here are the Advanced options specific to imagekit (ImageKit.io).

--imagekit-only-signed

If you have configured Restrict unsigned image URLs in your dashboard settings, set this to true.

Properties:

  • Config: only_signed
  • Env Var: RCLONE_IMAGEKIT_ONLY_SIGNED
  • Type: bool
  • Default: false

--imagekit-versions

Include old versions in directory listings.

Properties:

  • Config: versions
  • Env Var: RCLONE_IMAGEKIT_VERSIONS
  • Type: bool
  • Default: false

--imagekit-upload-tags

Tags to add to the uploaded files, e.g. "tag1,tag2".

Properties:

  • Config: upload_tags
  • Env Var: RCLONE_IMAGEKIT_UPLOAD_TAGS
  • Type: string
  • Required: false

--imagekit-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_IMAGEKIT_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,Dollar,Question,Hash,Percent,BackSlash,Del,Ctl,InvalidUtf8,Dot,SquareBracket

--imagekit-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_IMAGEKIT_DESCRIPTION
  • Type: string
  • Required: false

Metadata

Any metadata supported by the underlying remote is read and written.

Here are the possible system metadata items for the imagekit backend.

Name Help Type Example Read Only
aws-tags AI generated tags by AWS Rekognition associated with the image string tag1,tag2 Y
btime Time of file birth (creation) read from Last-Modified header RFC 3339 2006-01-02T15:04:05.999999999Z07:00 Y
custom-coordinates Custom coordinates of the file string 0,0,100,100 Y
file-type Type of the file string image Y
google-tags AI generated tags by Google Cloud Vision associated with the image string tag1,tag2 Y
has-alpha Whether the image has alpha channel or not bool Y
height Height of the image or video in pixels int Y
is-private-file Whether the file is private or not bool Y
size Size of the object in bytes int64 Y
tags Tags associated with the file string tag1,tag2 Y
width Width of the image or video in pixels int Y

See the metadata docs for more info.

iCloud Drive

Configuration

The initial setup for an iCloud Drive backend involves getting a trust token/session. This can be done by simply using the regular iCloud password, and accepting the code prompt on another iCloud connected device.

IMPORTANT: At the moment an app specific password won't be accepted. Only use your regular password and 2FA.

rclone config walks you through the token creation. The trust token is valid for 30 days. After which you will have to reauthenticate with rclone reconnect or rclone config.

Here is an example of how to make a remote called iclouddrive. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> iclouddrive
Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / iCloud Drive
   \ (iclouddrive)
[snip]
Storage> iclouddrive
Option apple_id.
Apple ID.
Enter a value.
apple_id> APPLEID  
Option password.
Password.
Choose an alternative below.
y) Yes, type in my own password
g) Generate random password
y/g> y
Enter the password:
password:
Confirm the password:
password:
Edit advanced config?
y) Yes
n) No (default)
y/n> n
Option config_2fa.
Two-factor authentication: please enter your 2FA code
Enter a value.
config_2fa> 2FACODE
Remote config
--------------------
[iclouddrive]
- type: iclouddrive
- apple_id: APPLEID
- password: *** ENCRYPTED ***
- cookies: ****************************
- trust_token: ****************************
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Advanced Data Protection

ADP is currently unsupported and need to be disabled

On iPhone, Settings > Apple Account > iCloud > 'Access iCloud Data on the Web' must be ON, and 'Advanced Data Protection' OFF.

Troubleshooting

Missing PCS cookies from the request

This means you have Advanced Data Protection (ADP) turned on. This is not supported at the moment. If you want to use rclone you will have to turn it off. See above for how to turn it off.

You will need to clear the cookies and the trust_token fields in the config. Or you can delete the remote config and start again.

You should then run rclone reconnect remote:.

Note that changing the ADP setting may not take effect immediately - you may need to wait a few hours or a day before you can get rclone to work - keep clearing the config entry and running rclone reconnect remote: until rclone functions properly.

Standard options

Here are the Standard options specific to iclouddrive (iCloud Drive).

--iclouddrive-apple-id

Apple ID.

Properties:

  • Config: apple_id
  • Env Var: RCLONE_ICLOUDDRIVE_APPLE_ID
  • Type: string
  • Required: true

--iclouddrive-password

Password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: password
  • Env Var: RCLONE_ICLOUDDRIVE_PASSWORD
  • Type: string
  • Required: true

--iclouddrive-trust-token

Trust token (internal use)

Properties:

  • Config: trust_token
  • Env Var: RCLONE_ICLOUDDRIVE_TRUST_TOKEN
  • Type: string
  • Required: false

--iclouddrive-cookies

cookies (internal use only)

Properties:

  • Config: cookies
  • Env Var: RCLONE_ICLOUDDRIVE_COOKIES
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to iclouddrive (iCloud Drive).

--iclouddrive-client-id

Client id

Properties:

  • Config: client_id
  • Env Var: RCLONE_ICLOUDDRIVE_CLIENT_ID
  • Type: string
  • Default: "d39ba9916b7251055b22c7f910e2ea796ee65e98b2ddecea8f5dde8d9d1a815d"

--iclouddrive-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_ICLOUDDRIVE_ENCODING
  • Type: Encoding
  • Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot

--iclouddrive-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_ICLOUDDRIVE_DESCRIPTION
  • Type: string
  • Required: false

Internet Archive

The Internet Archive backend utilizes Items on archive.org

Refer to IAS3 API documentation for the API this backend uses.

Paths are specified as remote:bucket (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:item/path/to/dir.

Unlike S3, listing up all items uploaded by you isn't supported.

Once you have made a remote, you can use it like this:

Make a new item

rclone mkdir remote:item

List the contents of a item

rclone ls remote:item

Sync /home/local/directory to the remote item, deleting any excess files in the item.

rclone sync --interactive /home/local/directory remote:item

Notes

Because of Internet Archive's architecture, it enqueues write operations (and extra post-processings) in a per-item queue. You can check item's queue at https://catalogd.archive.org/history/item-name-here . Because of that, all uploads/deletes will not show up immediately and takes some time to be available. The per-item queue is enqueued to an another queue, Item Deriver Queue. You can check the status of Item Deriver Queue here. This queue has a limit, and it may block you from uploading, or even deleting. You should avoid uploading a lot of small files for better behavior.

You can optionally wait for the server's processing to finish, by setting non-zero value to wait_archive key. By making it wait, rclone can do normal file comparison. Make sure to set a large enough value (e.g. 30m0s for smaller files) as it can take a long time depending on server's queue.

About metadata

This backend supports setting, updating and reading metadata of each file. The metadata will appear as file metadata on Internet Archive. However, some fields are reserved by both Internet Archive and rclone.

The following are reserved by Internet Archive: - name - source - size - md5 - crc32 - sha1 - format - old_version - viruscheck - summation

Trying to set values to these keys is ignored with a warning. Only setting mtime is an exception. Doing so make it the identical behavior as setting ModTime.

rclone reserves all the keys starting with rclone-. Setting value for these keys will give you warnings, but values are set according to request.

If there are multiple values for a key, only the first one is returned. This is a limitation of rclone, that supports one value per one key. It can be triggered when you did a server-side copy.

Reading metadata will also provide custom (non-standard nor reserved) ones.

Filtering auto generated files

The Internet Archive automatically creates metadata files after upload. These can cause problems when doing an rclone sync as rclone will try, and fail, to delete them. These metadata files are not changeable, as they are created by the Internet Archive automatically.

These auto-created files can be excluded from the sync using metadata filtering.

rclone sync ... --metadata-exclude "source=metadata" --metadata-exclude "format=Metadata"

Which excludes from the sync any files which have the source=metadata or format=Metadata flags which are added to Internet Archive auto-created files.

Configuration

Here is an example of making an internetarchive configuration. Most applies to the other providers as well, any differences are described below.

First run

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
XX / InternetArchive Items
   \ (internetarchive)
Storage> internetarchive
Option access_key_id.
IAS3 Access Key.
Leave blank for anonymous access.
You can find one here: https://archive.org/account/s3.php
Enter a value. Press Enter to leave empty.
access_key_id> XXXX
Option secret_access_key.
IAS3 Secret Key (password).
Leave blank for anonymous access.
Enter a value. Press Enter to leave empty.
secret_access_key> XXXX
Edit advanced config?
y) Yes
n) No (default)
y/n> y
Option endpoint.
IAS3 Endpoint.
Leave blank for default value.
Enter a string value. Press Enter for the default (https://s3.us.archive.org).
endpoint> 
Option front_endpoint.
Host of InternetArchive Frontend.
Leave blank for default value.
Enter a string value. Press Enter for the default (https://archive.org).
front_endpoint> 
Option disable_checksum.
Don't store MD5 checksum with object metadata.
Normally rclone will calculate the MD5 checksum of the input before
uploading it so it can ask the server to check the object against checksum.
This is great for data integrity checking but can cause long delays for
large files to start uploading.
Enter a boolean value (true or false). Press Enter for the default (true).
disable_checksum> true
Option encoding.
The encoding for the backend.
See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info.
Enter a encoder.MultiEncoder value. Press Enter for the default (Slash,Question,Hash,Percent,Del,Ctl,InvalidUtf8,Dot).
encoding> 
Edit advanced config?
y) Yes
n) No (default)
y/n> n
Configuration complete.
Options:
- type: internetarchive
- access_key_id: XXXX
- secret_access_key: XXXX
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Standard options

Here are the Standard options specific to internetarchive (Internet Archive).

--internetarchive-access-key-id

IAS3 Access Key.

Leave blank for anonymous access. You can find one here: https://archive.org/account/s3.php

Properties:

  • Config: access_key_id
  • Env Var: RCLONE_INTERNETARCHIVE_ACCESS_KEY_ID
  • Type: string
  • Required: false

--internetarchive-secret-access-key

IAS3 Secret Key (password).

Leave blank for anonymous access.

Properties:

  • Config: secret_access_key
  • Env Var: RCLONE_INTERNETARCHIVE_SECRET_ACCESS_KEY
  • Type: string
  • Required: false

--internetarchive-item-derive

Whether to trigger derive on the IA item or not. If set to false, the item will not be derived by IA upon upload. The derive process produces a number of secondary files from an upload to make an upload more usable on the web. Setting this to false is useful for uploading files that are already in a format that IA can display or reduce burden on IA's infrastructure.

Properties:

  • Config: item_derive
  • Env Var: RCLONE_INTERNETARCHIVE_ITEM_DERIVE
  • Type: bool
  • Default: true

Advanced options

Here are the Advanced options specific to internetarchive (Internet Archive).

--internetarchive-endpoint

IAS3 Endpoint.

Leave blank for default value.

Properties:

  • Config: endpoint
  • Env Var: RCLONE_INTERNETARCHIVE_ENDPOINT
  • Type: string
  • Default: "https://s3.us.archive.org"

--internetarchive-front-endpoint

Host of InternetArchive Frontend.

Leave blank for default value.

Properties:

  • Config: front_endpoint
  • Env Var: RCLONE_INTERNETARCHIVE_FRONT_ENDPOINT
  • Type: string
  • Default: "https://archive.org"

--internetarchive-item-metadata

Metadata to be set on the IA item, this is different from file-level metadata that can be set using --metadata-set. Format is key=value and the 'x-archive-meta-' prefix is automatically added.

Properties:

  • Config: item_metadata
  • Env Var: RCLONE_INTERNETARCHIVE_ITEM_METADATA
  • Type: stringArray
  • Default: []

--internetarchive-disable-checksum

Don't ask the server to test against MD5 checksum calculated by rclone. Normally rclone will calculate the MD5 checksum of the input before uploading it so it can ask the server to check the object against checksum. This is great for data integrity checking but can cause long delays for large files to start uploading.

Properties:

  • Config: disable_checksum
  • Env Var: RCLONE_INTERNETARCHIVE_DISABLE_CHECKSUM
  • Type: bool
  • Default: true

--internetarchive-wait-archive

Timeout for waiting the server's processing tasks (specifically archive and book_op) to finish. Only enable if you need to be guaranteed to be reflected after write operations. 0 to disable waiting. No errors to be thrown in case of timeout.

Properties:

  • Config: wait_archive
  • Env Var: RCLONE_INTERNETARCHIVE_WAIT_ARCHIVE
  • Type: Duration
  • Default: 0s

--internetarchive-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_INTERNETARCHIVE_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,CrLf,Del,Ctl,InvalidUtf8,Dot

--internetarchive-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_INTERNETARCHIVE_DESCRIPTION
  • Type: string
  • Required: false

Metadata

Metadata fields provided by Internet Archive. If there are multiple values for a key, only the first one is returned. This is a limitation of Rclone, that supports one value per one key.

Owner is able to add custom keys. Metadata feature grabs all the keys including them.

Here are the possible system metadata items for the internetarchive backend.

Name Help Type Example Read Only
crc32 CRC32 calculated by Internet Archive string 01234567 Y
format Name of format identified by Internet Archive string Comma-Separated Values Y
md5 MD5 hash calculated by Internet Archive string 01234567012345670123456701234567 Y
mtime Time of last modification, managed by Rclone RFC 3339 2006-01-02T15:04:05.999999999Z Y
name Full file path, without the bucket part filename backend/internetarchive/internetarchive.go Y
old_version Whether the file was replaced and moved by keep-old-version flag boolean true Y
rclone-ia-mtime Time of last modification, managed by Internet Archive RFC 3339 2006-01-02T15:04:05.999999999Z N
rclone-mtime Time of last modification, managed by Rclone RFC 3339 2006-01-02T15:04:05.999999999Z N
rclone-update-track Random value used by Rclone for tracking changes inside Internet Archive string aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa N
sha1 SHA1 hash calculated by Internet Archive string 0123456701234567012345670123456701234567 Y
size File size in bytes decimal number 123456 Y
source The source of the file string original Y
summation Check https://forum.rclone.org/t/31922 for how it is used string md5 Y
viruscheck The last time viruscheck process was run for the file (?) unixtime 1654191352 Y

See the metadata docs for more info.

Jottacloud

Jottacloud is a cloud storage service provider from a Norwegian company, using its own datacenters in Norway. In addition to the official service at jottacloud.com, it also provides white-label solutions to different companies, such as: * Telia * Telia Cloud (cloud.telia.se) * Telia Sky (sky.telia.no) * Tele2 * Tele2 Cloud (mittcloud.tele2.se) * Onlime * Onlime Cloud Storage (onlime.dk) * Elkjøp (with subsidiaries): * Elkjøp Cloud (cloud.elkjop.no) * Elgiganten Sweden (cloud.elgiganten.se) * Elgiganten Denmark (cloud.elgiganten.dk) * Giganti Cloud (cloud.gigantti.fi) * ELKO Cloud (cloud.elko.is)

Most of the white-label versions are supported by this backend, although may require different authentication setup - described below.

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Authentication types

Some of the whitelabel versions uses a different authentication method than the official service, and you have to choose the correct one when setting up the remote.

Standard authentication

The standard authentication method used by the official service (jottacloud.com), as well as some of the whitelabel services, requires you to generate a single-use personal login token from the account security settings in the service's web interface. Log in to your account, go to "Settings" and then "Security", or use the direct link presented to you by rclone when configuring the remote: https://www.jottacloud.com/web/secure. Scroll down to the section "Personal login token", and click the "Generate" button. Note that if you are using a whitelabel service you probably can't use the direct link, you need to find the same page in their dedicated web interface, and also it may be in a different location than described above.

To access your account from multiple instances of rclone, you need to configure each of them with a separate personal login token. E.g. you create a Jottacloud remote with rclone in one location, and copy the configuration file to a second location where you also want to run rclone and access the same remote. Then you need to replace the token for one of them, using the config reconnect command, which requires you to generate a new personal login token and supply as input. If you do not do this, the token may easily end up being invalidated, resulting in both instances failing with an error message something along the lines of:

oauth2: cannot fetch token: 400 Bad Request
Response: {"error":"invalid_grant","error_description":"Stale token"}

When this happens, you need to replace the token as described above to be able to use your remote again.

All personal login tokens you have taken into use will be listed in the web interface under "My logged in devices", and from the right side of that list you can click the "X" button to revoke individual tokens.

Legacy authentication

If you are using one of the whitelabel versions (e.g. from Elkjøp) you may not have the option to generate a CLI token. In this case you'll have to use the legacy authentication. To do this select yes when the setup asks for legacy authentication and enter your username and password. The rest of the setup is identical to the default setup.

Telia Cloud authentication

Similar to other whitelabel versions Telia Cloud doesn't offer the option of creating a CLI token, and additionally uses a separate authentication flow where the username is generated internally. To setup rclone to use Telia Cloud, choose Telia Cloud authentication in the setup. The rest of the setup is identical to the default setup.

Tele2 Cloud authentication

As Tele2-Com Hem merger was completed this authentication can be used for former Com Hem Cloud and Tele2 Cloud customers as no support for creating a CLI token exists, and additionally uses a separate authentication flow where the username is generated internally. To setup rclone to use Tele2 Cloud, choose Tele2 Cloud authentication in the setup. The rest of the setup is identical to the default setup.

Onlime Cloud Storage authentication

Onlime has sold access to Jottacloud proper, while providing localized support to Danish Customers, but have recently set up their own hosting, transferring their customers from Jottacloud servers to their own ones.

This, of course, necessitates using their servers for authentication, but otherwise functionality and architecture seems equivalent to Jottacloud.

To setup rclone to use Onlime Cloud Storage, choose Onlime Cloud authentication in the setup. The rest of the setup is identical to the default setup.

Configuration

Here is an example of how to make a remote called remote with the default setup. First run:

rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / Jottacloud
   \ (jottacloud)
[snip]
Storage> jottacloud
Edit advanced config?
y) Yes
n) No (default)
y/n> n
Option config_type.
Select authentication type.
Choose a number from below, or type in an existing string value.
Press Enter for the default (standard).
   / Standard authentication.
 1 | Use this if you're a normal Jottacloud user.
   \ (standard)
   / Legacy authentication.
 2 | This is only required for certain whitelabel versions of Jottacloud and not recommended for normal users.
   \ (legacy)
   / Telia Cloud authentication.
 3 | Use this if you are using Telia Cloud.
   \ (telia)
   / Tele2 Cloud authentication.
 4 | Use this if you are using Tele2 Cloud.
   \ (tele2)
   / Onlime Cloud authentication.
 5 | Use this if you are using Onlime Cloud.
   \ (onlime)
config_type> 1
Personal login token.
Generate here: https://www.jottacloud.com/web/secure
Login Token> <your token here>
Use a non-standard device/mountpoint?
Choosing no, the default, will let you access the storage used for the archive
section of the official Jottacloud client. If you instead want to access the
sync or the backup section, for example, you must choose yes.
y) Yes
n) No (default)
y/n> y
Option config_device.
The device to use. In standard setup the built-in Jotta device is used,
which contains predefined mountpoints for archive, sync etc. All other devices
are treated as backup devices by the official Jottacloud client. You may create
a new by entering a unique name.
Choose a number from below, or type in your own string value.
Press Enter for the default (DESKTOP-3H31129).
 1 > DESKTOP-3H31129
 2 > Jotta
config_device> 2
Option config_mountpoint.
The mountpoint to use for the built-in device Jotta.
The standard setup is to use the Archive mountpoint. Most other mountpoints
have very limited support in rclone and should generally be avoided.
Choose a number from below, or type in an existing string value.
Press Enter for the default (Archive).
 1 > Archive
 2 > Shared
 3 > Sync
config_mountpoint> 1
Configuration complete.
Options:
- type: jottacloud
- configVersion: 1
- client_id: jottacli
- client_secret:
- tokenURL: https://id.jottacloud.com/auth/realms/jottacloud/protocol/openid-connect/token
- token: {........}
- username: 2940e57271a93d987d6f8a21
- device: Jotta
- mountpoint: Archive
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Once configured you can then use rclone like this,

List directories in top level of your Jottacloud

rclone lsd remote:

List all the files in your Jottacloud

rclone ls remote:

To copy a local directory to an Jottacloud directory called backup

rclone copy /home/source remote:backup

Devices and Mountpoints

The official Jottacloud client registers a device for each computer you install it on, and shows them in the backup section of the user interface. For each folder you select for backup it will create a mountpoint within this device. A built-in device called Jotta is special, and contains mountpoints Archive, Sync and some others, used for corresponding features in official clients.

With rclone you'll want to use the standard Jotta/Archive device/mountpoint in most cases. However, you may for example want to access files from the sync or backup functionality provided by the official clients, and rclone therefore provides the option to select other devices and mountpoints during config.

You are allowed to create new devices and mountpoints. All devices except the built-in Jotta device are treated as backup devices by official Jottacloud clients, and the mountpoints on them are individual backup sets.

With the built-in Jotta device, only existing, built-in, mountpoints can be selected. In addition to the mentioned Archive and Sync, it may contain several other mountpoints such as: Latest, Links, Shared and Trash. All of these are special mountpoints with a different internal representation than the "regular" mountpoints. Rclone will only to a very limited degree support them. Generally you should avoid these, unless you know what you are doing.

--fast-list

This backend supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details.

Note that the implementation in Jottacloud always uses only a single API request to get the entire list, so for large folders this could lead to long wait time before the first results are shown.

Note also that with rclone version 1.58 and newer, information about MIME types and metadata item utime are not available when using --fast-list.

Modification times and hashes

Jottacloud allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not.

Jottacloud supports MD5 type hashes, so you can use the --checksum flag.

Note that Jottacloud requires the MD5 hash before upload so if the source does not have an MD5 checksum then the file will be cached temporarily on disk (in location given by --temp-dir) before it is uploaded. Small files will be cached in memory - see the --jottacloud-md5-memory-limit flag. When uploading from local disk the source checksum is always available, so this does not apply. Starting with rclone version 1.52 the same is true for encrypted remotes (in older versions the crypt backend would not calculate hashes for uploads from local disk, so the Jottacloud backend had to do it as described above).

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
" 0x22 ＂
* 0x2A ＊
: 0x3A ：
< 0x3C ＜
> 0x3E ＞
? 0x3F ？
| 0x7C ｜

Invalid UTF-8 bytes will also be replaced, as they can't be used in XML strings.

Deleting files

By default, rclone will send all files to the trash when deleting files. They will be permanently deleted automatically after 30 days. You may bypass the trash and permanently delete files immediately by using the --jottacloud-hard-delete flag, or set the equivalent environment variable. Emptying the trash is supported by the cleanup command.

Versions

Jottacloud supports file versioning. When rclone uploads a new version of a file it creates a new version of it. Currently rclone only supports retrieving the current version but older versions can be accessed via the Jottacloud Website.

Versioning can be disabled by --jottacloud-no-versions option. This is achieved by deleting the remote file prior to uploading a new version. If the upload the fails no version of the file will be available in the remote.

Quota information

To view your current quota you can use the rclone about remote: command which will display your usage limit (unless it is unlimited) and the current usage.

Standard options

Here are the Standard options specific to jottacloud (Jottacloud).

--jottacloud-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_JOTTACLOUD_CLIENT_ID
  • Type: string
  • Required: false

--jottacloud-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_JOTTACLOUD_CLIENT_SECRET
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to jottacloud (Jottacloud).

--jottacloud-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_JOTTACLOUD_TOKEN
  • Type: string
  • Required: false

--jottacloud-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_JOTTACLOUD_AUTH_URL
  • Type: string
  • Required: false

--jottacloud-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_JOTTACLOUD_TOKEN_URL
  • Type: string
  • Required: false

--jottacloud-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_JOTTACLOUD_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--jottacloud-md5-memory-limit

Files bigger than this will be cached on disk to calculate the MD5 if required.

Properties:

  • Config: md5_memory_limit
  • Env Var: RCLONE_JOTTACLOUD_MD5_MEMORY_LIMIT
  • Type: SizeSuffix
  • Default: 10Mi

--jottacloud-trashed-only

Only show files that are in the trash.

This will show trashed files in their original directory structure.

Properties:

  • Config: trashed_only
  • Env Var: RCLONE_JOTTACLOUD_TRASHED_ONLY
  • Type: bool
  • Default: false

--jottacloud-hard-delete

Delete files permanently rather than putting them into the trash.

Properties:

  • Config: hard_delete
  • Env Var: RCLONE_JOTTACLOUD_HARD_DELETE
  • Type: bool
  • Default: false

--jottacloud-upload-resume-limit

Files bigger than this can be resumed if the upload fail's.

Properties:

  • Config: upload_resume_limit
  • Env Var: RCLONE_JOTTACLOUD_UPLOAD_RESUME_LIMIT
  • Type: SizeSuffix
  • Default: 10Mi

--jottacloud-no-versions

Avoid server side versioning by deleting files and recreating files instead of overwriting them.

Properties:

  • Config: no_versions
  • Env Var: RCLONE_JOTTACLOUD_NO_VERSIONS
  • Type: bool
  • Default: false

--jottacloud-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_JOTTACLOUD_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,Del,Ctl,InvalidUtf8,Dot

--jottacloud-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_JOTTACLOUD_DESCRIPTION
  • Type: string
  • Required: false

Metadata

Jottacloud has limited support for metadata, currently an extended set of timestamps.

Here are the possible system metadata items for the jottacloud backend.

Name Help Type Example Read Only
btime Time of file birth (creation), read from rclone metadata RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N
content-type MIME type, also known as media type string text/plain Y
mtime Time of last modification, read from rclone metadata RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N
utime Time of last upload, when current revision was created, generated by backend RFC 3339 2006-01-02T15:04:05.999999999Z07:00 Y

See the metadata docs for more info.

Limitations

Note that Jottacloud is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc".

There are quite a few characters that can't be in Jottacloud file names. Rclone will map these names to and from an identical looking unicode equivalent. For example if a file has a ? in it will be mapped to ？ instead.

Jottacloud only supports filenames up to 255 characters in length.

Troubleshooting

Jottacloud exhibits some inconsistent behaviours regarding deleted files and folders which may cause Copy, Move and DirMove operations to previously deleted paths to fail. Emptying the trash should help in such cases.

Koofr

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Configuration

The initial setup for Koofr involves creating an application password for rclone. You can do that by opening the Koofr web application, giving the password a nice name like rclone and clicking on generate.

Here is an example of how to make a remote called koofr. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> koofr
Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
22 / Koofr, Digi Storage and other Koofr-compatible storage providers
   \ (koofr)
[snip]
Storage> koofr
Option provider.
Choose your storage provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Koofr, https://app.koofr.net/
   \ (koofr)
 2 / Digi Storage, https://storage.rcs-rds.ro/
   \ (digistorage)
 3 / Any other Koofr API compatible storage service
   \ (other)
provider> 1    
Option user.
Your user name.
Enter a value.
user> USERNAME
Option password.
Your password for rclone (generate one at https://app.koofr.net/app/admin/preferences/password).
Choose an alternative below.
y) Yes, type in my own password
g) Generate random password
y/g> y
Enter the password:
password:
Confirm the password:
password:
Edit advanced config?
y) Yes
n) No (default)
y/n> n
Remote config
--------------------
[koofr]
type = koofr
provider = koofr
user = USERNAME
password = *** ENCRYPTED ***
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

You can choose to edit advanced config in order to enter your own service URL if you use an on-premise or white label Koofr instance, or choose an alternative mount instead of your primary storage.

Once configured you can then use rclone like this,

List directories in top level of your Koofr

rclone lsd koofr:

List all the files in your Koofr

rclone ls koofr:

To copy a local directory to an Koofr directory called backup

rclone copy /home/source koofr:backup

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
\ 0x5C ＼

Invalid UTF-8 bytes will also be replaced, as they can't be used in XML strings.

Standard options

Here are the Standard options specific to koofr (Koofr, Digi Storage and other Koofr-compatible storage providers).

--koofr-provider

Choose your storage provider.

Properties:

  • Config: provider
  • Env Var: RCLONE_KOOFR_PROVIDER
  • Type: string
  • Required: false
  • Examples:
    • "koofr"
      • Koofr, https://app.koofr.net/
    • "digistorage"
      • Digi Storage, https://storage.rcs-rds.ro/
    • "other"
      • Any other Koofr API compatible storage service

--koofr-endpoint

The Koofr API endpoint to use.

Properties:

  • Config: endpoint
  • Env Var: RCLONE_KOOFR_ENDPOINT
  • Provider: other
  • Type: string
  • Required: true

--koofr-user

Your user name.

Properties:

  • Config: user
  • Env Var: RCLONE_KOOFR_USER
  • Type: string
  • Required: true

--koofr-password

Your password for rclone generate one at https://app.koofr.net/app/admin/preferences/password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: password
  • Env Var: RCLONE_KOOFR_PASSWORD
  • Provider: koofr
  • Type: string
  • Required: true

Advanced options

Here are the Advanced options specific to koofr (Koofr, Digi Storage and other Koofr-compatible storage providers).

--koofr-mountid

Mount ID of the mount to use.

If omitted, the primary mount is used.

Properties:

  • Config: mountid
  • Env Var: RCLONE_KOOFR_MOUNTID
  • Type: string
  • Required: false

--koofr-setmtime

Does the backend support setting modification time.

Set this to false if you use a mount ID that points to a Dropbox or Amazon Drive backend.

Properties:

  • Config: setmtime
  • Env Var: RCLONE_KOOFR_SETMTIME
  • Type: bool
  • Default: true

--koofr-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_KOOFR_ENCODING
  • Type: Encoding
  • Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot

--koofr-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_KOOFR_DESCRIPTION
  • Type: string
  • Required: false

Limitations

Note that Koofr is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc".

Providers

Koofr

This is the original Koofr storage provider used as main example and described in the configuration section above.

Digi Storage

Digi Storage is a cloud storage service run by Digi.ro that provides a Koofr API.

Here is an example of how to make a remote called ds. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> ds
Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
22 / Koofr, Digi Storage and other Koofr-compatible storage providers
   \ (koofr)
[snip]
Storage> koofr
Option provider.
Choose your storage provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Koofr, https://app.koofr.net/
   \ (koofr)
 2 / Digi Storage, https://storage.rcs-rds.ro/
   \ (digistorage)
 3 / Any other Koofr API compatible storage service
   \ (other)
provider> 2
Option user.
Your user name.
Enter a value.
user> USERNAME
Option password.
Your password for rclone (generate one at https://storage.rcs-rds.ro/app/admin/preferences/password).
Choose an alternative below.
y) Yes, type in my own password
g) Generate random password
y/g> y
Enter the password:
password:
Confirm the password:
password:
Edit advanced config?
y) Yes
n) No (default)
y/n> n
--------------------
[ds]
type = koofr
provider = digistorage
user = USERNAME
password = *** ENCRYPTED ***
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Other

You may also want to use another, public or private storage provider that runs a Koofr API compatible service, by simply providing the base URL to connect to.

Here is an example of how to make a remote called other. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> other
Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
22 / Koofr, Digi Storage and other Koofr-compatible storage providers
   \ (koofr)
[snip]
Storage> koofr
Option provider.
Choose your storage provider.
Choose a number from below, or type in your own value.
Press Enter to leave empty.
 1 / Koofr, https://app.koofr.net/
   \ (koofr)
 2 / Digi Storage, https://storage.rcs-rds.ro/
   \ (digistorage)
 3 / Any other Koofr API compatible storage service
   \ (other)
provider> 3
Option endpoint.
The Koofr API endpoint to use.
Enter a value.
endpoint> https://koofr.other.org
Option user.
Your user name.
Enter a value.
user> USERNAME
Option password.
Your password for rclone (generate one at your service's settings page).
Choose an alternative below.
y) Yes, type in my own password
g) Generate random password
y/g> y
Enter the password:
password:
Confirm the password:
password:
Edit advanced config?
y) Yes
n) No (default)
y/n> n
--------------------
[other]
type = koofr
provider = other
endpoint = https://koofr.other.org
user = USERNAME
password = *** ENCRYPTED ***
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Linkbox

Linkbox is a private cloud drive.

Configuration

Here is an example of making a remote for Linkbox.

First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter name for new remote.
name> remote

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
XX / Linkbox
   \ (linkbox)
Storage> XX

Option token.
Token from https://www.linkbox.to/admin/account
Enter a value.
token> testFromCLToken

Configuration complete.
Options:
- type: linkbox
- token: XXXXXXXXXXX
Keep this "linkbox" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Standard options

Here are the Standard options specific to linkbox (Linkbox).

Token from https://www.linkbox.to/admin/account

Properties:

  • Config: token
  • Env Var: RCLONE_LINKBOX_TOKEN
  • Type: string
  • Required: true

Advanced options

Here are the Advanced options specific to linkbox (Linkbox).

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_LINKBOX_DESCRIPTION
  • Type: string
  • Required: false

Limitations

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Mail.ru Cloud

Mail.ru Cloud is a cloud storage provided by a Russian internet company Mail.Ru Group. The official desktop client is Disk-O:, available on Windows and Mac OS.

Features highlights

  • Paths may be as deep as required, e.g. remote:directory/subdirectory
  • Files have a last modified time property, directories don't
  • Deleted files are by default moved to the trash
  • Files and directories can be shared via public links
  • Partial uploads or streaming are not supported, file size must be known before upload
  • Maximum file size is limited to 2G for a free account, unlimited for paid accounts
  • Storage keeps hash for all files and performs transparent deduplication, the hash algorithm is a modified SHA1
  • If a particular file is already present in storage, one can quickly submit file hash instead of long file upload (this optimization is supported by rclone)

Configuration

Here is an example of making a mailru configuration.

First create a Mail.ru Cloud account and choose a tariff.

You will need to log in and create an app password for rclone. Rclone will not work with your normal username and password - it will give an error like oauth2: server response missing access_token.

  • Click on your user icon in the top right
  • Go to Security / "Пароль и безопасность"
  • Click password for apps / "Пароли для внешних приложений"
  • Add the password - give it a name - eg "rclone"
  • Select the permissions level. For some reason just "Full access to Cloud" (WebDav) doesn't work for Rclone currently. You have to select "Full access to Mail, Cloud and Calendar" (all protocols). (thread on forum.rclone.org)
  • Copy the password and use this password below - your normal login password won't work.

Now run

rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Mail.ru Cloud
   \ "mailru"
[snip]
Storage> mailru
User name (usually email)
Enter a string value. Press Enter for the default ("").
user> username@mail.ru
Password

This must be an app password - rclone will not work with your normal
password. See the Configuration section in the docs for how to make an
app password.
y) Yes type in my own password
g) Generate random password
y/g> y
Enter the password:
password:
Confirm the password:
password:
Skip full upload if there is another file with same data hash.
This feature is called "speedup" or "put by hash". It is especially efficient
in case of generally available files like popular books, video or audio clips
[snip]
Enter a boolean value (true or false). Press Enter for the default ("true").
Choose a number from below, or type in your own value
 1 / Enable
   \ "true"
 2 / Disable
   \ "false"
speedup_enable> 1
Edit advanced config? (y/n)
y) Yes
n) No
y/n> n
Remote config
Configuration complete.
Options:
- type: mailru
- user: username@mail.ru
- pass: *** ENCRYPTED ***
- speedup_enable: true
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

Configuration of this backend does not require a local web browser. You can use the configured backend as shown below:

See top level directories

rclone lsd remote:

Make a new directory

rclone mkdir remote:directory

List the contents of a directory

rclone ls remote:directory

Sync /home/local/directory to the remote path, deleting any excess files in the path.

rclone sync --interactive /home/local/directory remote:directory

Modification times and hashes

Files support a modification time attribute with up to 1 second precision. Directories do not have a modification time, which is shown as "Jan 1 1970".

File hashes are supported, with a custom Mail.ru algorithm based on SHA1. If file size is less than or equal to the SHA1 block size (20 bytes), its hash is simply its data right-padded with zero bytes. Hashes of a larger file is computed as a SHA1 of the file data bytes concatenated with a decimal representation of the data length.

Emptying Trash

Removing a file or directory actually moves it to the trash, which is not visible to rclone but can be seen in a web browser. The trashed file still occupies part of total quota. If you wish to empty your trash and free some quota, you can use the rclone cleanup remote: command, which will permanently delete all your trashed files. This command does not take any path arguments.

Quota information

To view your current quota you can use the rclone about remote: command which will display your usage limit (quota) and the current usage.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
" 0x22 ＂
* 0x2A ＊
: 0x3A ：
< 0x3C ＜
> 0x3E ＞
? 0x3F ？
\ 0x5C ＼
| 0x7C ｜

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Standard options

Here are the Standard options specific to mailru (Mail.ru Cloud).

--mailru-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_MAILRU_CLIENT_ID
  • Type: string
  • Required: false

--mailru-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_MAILRU_CLIENT_SECRET
  • Type: string
  • Required: false

--mailru-user

User name (usually email).

Properties:

  • Config: user
  • Env Var: RCLONE_MAILRU_USER
  • Type: string
  • Required: true

--mailru-pass

Password.

This must be an app password - rclone will not work with your normal password. See the Configuration section in the docs for how to make an app password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: pass
  • Env Var: RCLONE_MAILRU_PASS
  • Type: string
  • Required: true

--mailru-speedup-enable

Skip full upload if there is another file with same data hash.

This feature is called "speedup" or "put by hash". It is especially efficient in case of generally available files like popular books, video or audio clips, because files are searched by hash in all accounts of all mailru users. It is meaningless and ineffective if source file is unique or encrypted. Please note that rclone may need local memory and disk space to calculate content hash in advance and decide whether full upload is required. Also, if rclone does not know file size in advance (e.g. in case of streaming or partial uploads), it will not even try this optimization.

Properties:

  • Config: speedup_enable
  • Env Var: RCLONE_MAILRU_SPEEDUP_ENABLE
  • Type: bool
  • Default: true
  • Examples:
    • "true"
      • Enable
    • "false"
      • Disable

Advanced options

Here are the Advanced options specific to mailru (Mail.ru Cloud).

--mailru-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_MAILRU_TOKEN
  • Type: string
  • Required: false

--mailru-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_MAILRU_AUTH_URL
  • Type: string
  • Required: false

--mailru-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_MAILRU_TOKEN_URL
  • Type: string
  • Required: false

--mailru-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_MAILRU_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--mailru-speedup-file-patterns

Comma separated list of file name patterns eligible for speedup (put by hash).

Patterns are case insensitive and can contain '*' or '?' meta characters.

Properties:

  • Config: speedup_file_patterns
  • Env Var: RCLONE_MAILRU_SPEEDUP_FILE_PATTERNS
  • Type: string
  • Default: ".mkv,.avi,.mp4,.mp3,.zip,.gz,.rar,.pdf"
  • Examples:
    • ""
      • Empty list completely disables speedup (put by hash).
    • "*"
      • All files will be attempted for speedup.
    • ".mkv,.avi,.mp4,.mp3"
      • Only common audio/video files will be tried for put by hash.
    • ".zip,.gz,.rar,.pdf"
      • Only common archives or PDF books will be tried for speedup.

--mailru-speedup-max-disk

This option allows you to disable speedup (put by hash) for large files.

Reason is that preliminary hashing can exhaust your RAM or disk space.

Properties:

  • Config: speedup_max_disk
  • Env Var: RCLONE_MAILRU_SPEEDUP_MAX_DISK
  • Type: SizeSuffix
  • Default: 3Gi
  • Examples:
    • "0"
      • Completely disable speedup (put by hash).
    • "1G"
      • Files larger than 1Gb will be uploaded directly.
    • "3G"
      • Choose this option if you have less than 3Gb free on local disk.

--mailru-speedup-max-memory

Files larger than the size given below will always be hashed on disk.

Properties:

  • Config: speedup_max_memory
  • Env Var: RCLONE_MAILRU_SPEEDUP_MAX_MEMORY
  • Type: SizeSuffix
  • Default: 32Mi
  • Examples:
    • "0"
      • Preliminary hashing will always be done in a temporary disk location.
    • "32M"
      • Do not dedicate more than 32Mb RAM for preliminary hashing.
    • "256M"
      • You have at most 256Mb RAM free for hash calculations.

--mailru-check-hash

What should copy do if file checksum is mismatched or invalid.

Properties:

  • Config: check_hash
  • Env Var: RCLONE_MAILRU_CHECK_HASH
  • Type: bool
  • Default: true
  • Examples:
    • "true"
      • Fail with error.
    • "false"
      • Ignore and continue.

--mailru-user-agent

HTTP user agent used internally by client.

Defaults to "rclone/VERSION" or "--user-agent" provided on command line.

Properties:

  • Config: user_agent
  • Env Var: RCLONE_MAILRU_USER_AGENT
  • Type: string
  • Required: false

--mailru-quirks

Comma separated list of internal maintenance flags.

This option must not be used by an ordinary user. It is intended only to facilitate remote troubleshooting of backend issues. Strict meaning of flags is not documented and not guaranteed to persist between releases. Quirks will be removed when the backend grows stable. Supported quirks: atomicmkdir binlist unknowndirs

Properties:

  • Config: quirks
  • Env Var: RCLONE_MAILRU_QUIRKS
  • Type: string
  • Required: false

--mailru-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_MAILRU_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,InvalidUtf8,Dot

--mailru-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_MAILRU_DESCRIPTION
  • Type: string
  • Required: false

Limitations

File size limits depend on your account. A single file size is limited by 2G for a free account and unlimited for paid tariffs. Please refer to the Mail.ru site for the total uploaded size limits.

Note that Mailru is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc".

Mega

Mega is a cloud storage and file hosting service known for its security feature where all files are encrypted locally before they are uploaded. This prevents anyone (including employees of Mega) from accessing the files without knowledge of the key used for encryption.

This is an rclone backend for Mega which supports the file transfer features of Mega using the same client side encryption.

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Configuration

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Mega
   \ "mega"
[snip]
Storage> mega
User name
user> you@example.com
Password.
y) Yes type in my own password
g) Generate random password
n) No leave this optional password blank
y/g/n> y
Enter the password:
password:
Confirm the password:
password:
Remote config
Configuration complete.
Options:
- type: mega
- user: you@example.com
- pass: *** ENCRYPTED ***
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

NOTE: The encryption keys need to have been already generated after a regular login via the browser, otherwise attempting to use the credentials in rclone will fail.

Once configured you can then use rclone like this,

List directories in top level of your Mega

rclone lsd remote:

List all the files in your Mega

rclone ls remote:

To copy a local directory to an Mega directory called backup

rclone copy /home/source remote:backup

Modification times and hashes

Mega does not support modification times or hashes yet.

Restricted filename characters

Character Value Replacement
NUL 0x00 ␀
/ 0x2F ／

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Duplicated files

Mega can have two files with exactly the same name and path (unlike a normal file system).

Duplicated files cause problems with the syncing and you will see messages in the log about duplicates.

Use rclone dedupe to fix duplicated files.

Failure to log-in

Object not found

If you are connecting to your Mega remote for the first time, to test access and synchronization, you may receive an error such as

Failed to create file system for "my-mega-remote:": 
couldn't login: Object (typically, node or user) not found

The diagnostic steps often recommended in the rclone forum start with the MEGAcmd utility. Note that this refers to the official C++ command from https://github.com/meganz/MEGAcmd and not the go language built command from t3rm1n4l/megacmd that is no longer maintained.

Follow the instructions for installing MEGAcmd and try accessing your remote as they recommend. You can establish whether or not you can log in using MEGAcmd, and obtain diagnostic information to help you, and search or work with others in the forum.

MEGA CMD> login me@example.com
Password:
Fetching nodes ...
Loading transfers from local cache
Login complete as me@example.com
me@example.com:/$

Note that some have found issues with passwords containing special characters. If you can not log on with rclone, but MEGAcmd logs on just fine, then consider changing your password temporarily to pure alphanumeric characters, in case that helps.

Repeated commands blocks access

Mega remotes seem to get blocked (reject logins) under "heavy use". We haven't worked out the exact blocking rules but it seems to be related to fast paced, successive rclone commands.

For example, executing this command 90 times in a row rclone link remote:file will cause the remote to become "blocked". This is not an abnormal situation, for example if you wish to get the public links of a directory with hundred of files... After more or less a week, the remote will remote accept rclone logins normally again.

You can mitigate this issue by mounting the remote it with rclone mount. This will log-in when mounting and a log-out when unmounting only. You can also run rclone rcd and then use rclone rc to run the commands over the API to avoid logging in each time.

Rclone does not currently close mega sessions (you can see them in the web interface), however closing the sessions does not solve the issue.

If you space rclone commands by 3 seconds it will avoid blocking the remote. We haven't identified the exact blocking rules, so perhaps one could execute the command 80 times without waiting and avoid blocking by waiting 3 seconds, then continuing...

Note that this has been observed by trial and error and might not be set in stone.

Other tools seem not to produce this blocking effect, as they use a different working approach (state-based, using sessionIDs instead of log-in) which isn't compatible with the current stateless rclone approach.

Note that once blocked, the use of other tools (such as megacmd) is not a sure workaround: following megacmd login times have been observed in succession for blocked remote: 7 minutes, 20 min, 30min, 30 min, 30min. Web access looks unaffected though.

Investigation is continuing in relation to workarounds based on timeouts, pacers, retrials and tpslimits - if you discover something relevant, please post on the forum.

So, if rclone was working nicely and suddenly you are unable to log-in and you are sure the user and the password are correct, likely you have got the remote blocked for a while.

Standard options

Here are the Standard options specific to mega (Mega).

--mega-user

User name.

Properties:

  • Config: user
  • Env Var: RCLONE_MEGA_USER
  • Type: string
  • Required: true

--mega-pass

Password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: pass
  • Env Var: RCLONE_MEGA_PASS
  • Type: string
  • Required: true

Advanced options

Here are the Advanced options specific to mega (Mega).

--mega-debug

Output more debug from Mega.

If this flag is set (along with -vv) it will print further debugging information from the mega backend.

Properties:

  • Config: debug
  • Env Var: RCLONE_MEGA_DEBUG
  • Type: bool
  • Default: false

--mega-hard-delete

Delete files permanently rather than putting them into the trash.

Normally the mega backend will put all deletions into the trash rather than permanently deleting them. If you specify this then rclone will permanently delete objects instead.

Properties:

  • Config: hard_delete
  • Env Var: RCLONE_MEGA_HARD_DELETE
  • Type: bool
  • Default: false

--mega-use-https

Use HTTPS for transfers.

MEGA uses plain text HTTP connections by default. Some ISPs throttle HTTP connections, this causes transfers to become very slow. Enabling this will force MEGA to use HTTPS for all transfers. HTTPS is normally not necessary since all data is already encrypted anyway. Enabling it will increase CPU usage and add network overhead.

Properties:

  • Config: use_https
  • Env Var: RCLONE_MEGA_USE_HTTPS
  • Type: bool
  • Default: false

--mega-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_MEGA_ENCODING
  • Type: Encoding
  • Default: Slash,InvalidUtf8,Dot

--mega-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_MEGA_DESCRIPTION
  • Type: string
  • Required: false

Process killed

On accounts with large files or something else, memory usage can significantly increase when executing list/sync instructions. When running on cloud providers (like AWS with EC2), check if the instance type has sufficient memory/CPU to execute the commands. Use the resource monitoring tools to inspect after sending the commands. Look at this issue.

Limitations

This backend uses the go-mega go library which is an opensource go library implementing the Mega API. There doesn't appear to be any documentation for the mega protocol beyond the mega C++ SDK source code so there are likely quite a few errors still remaining in this library.

Mega allows duplicate files which may confuse rclone.

Memory

The memory backend is an in RAM backend. It does not persist its data - use the local backend for that.

The memory backend behaves like a bucket-based remote (e.g. like s3). Because it has no parameters you can just use it with the :memory: remote name.

Configuration

You can configure it as a remote like this with rclone config too if you want to:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Memory
   \ "memory"
[snip]
Storage> memory
** See help for memory backend at: https://rclone.org/memory/ **

Remote config

Configuration complete.
Options:
- type: memory
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Because the memory backend isn't persistent it is most useful for testing or with an rclone server or rclone mount, e.g.

rclone mount :memory: /mnt/tmp
rclone serve webdav :memory:
rclone serve sftp :memory:

Modification times and hashes

The memory backend supports MD5 hashes and modification times accurate to 1 nS.

Restricted filename characters

The memory backend replaces the default restricted characters set.

Advanced options

Here are the Advanced options specific to memory (In memory object storage system.).

--memory-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_MEMORY_DESCRIPTION
  • Type: string
  • Required: false

Akamai NetStorage

Paths are specified as remote: You may put subdirectories in too, e.g. remote:/path/to/dir. If you have a CP code you can use that as the folder after the domain such as <domain>/<cpcode>/<internal directories within cpcode>.

For example, this is commonly configured with or without a CP code: * With a CP code. [your-domain-prefix]-nsu.akamaihd.net/123456/subdirectory/ * Without a CP code. [your-domain-prefix]-nsu.akamaihd.net

See all buckets rclone lsd remote: The initial setup for Netstorage involves getting an account and secret. Use rclone config to walk you through the setup process.

Configuration

Here's an example of how to make a remote called ns1.

  1. To begin the interactive configuration process, enter this command:
rclone config
  1. Type n to create a new remote.
n) New remote
d) Delete remote
q) Quit config
e/n/d/q> n
  1. For this example, enter ns1 when you reach the name> prompt.
name> ns1
  1. Enter netstorage as the type of storage to configure.
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
XX / NetStorage
   \ "netstorage"
Storage> netstorage
  1. Select between the HTTP or HTTPS protocol. Most users should choose HTTPS, which is the default. HTTP is provided primarily for debugging purposes.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / HTTP protocol
   \ "http"
 2 / HTTPS protocol
   \ "https"
protocol> 1
  1. Specify your NetStorage host, CP code, and any necessary content paths using this format: <domain>/<cpcode>/<content>/
Enter a string value. Press Enter for the default ("").
host> baseball-nsu.akamaihd.net/123456/content/
  1. Set the netstorage account name
Enter a string value. Press Enter for the default ("").
account> username
  1. Set the Netstorage account secret/G2O key which will be used for authentication purposes. Select the y option to set your own password then enter your secret. Note: The secret is stored in the rclone.conf file with hex-encoded encryption.
y) Yes type in my own password
g) Generate random password
y/g> y
Enter the password:
password:
Confirm the password:
password:
  1. View the summary and confirm your remote configuration.
[ns1]
type = netstorage
protocol = http
host = baseball-nsu.akamaihd.net/123456/content/
account = username
secret = *** ENCRYPTED ***
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

This remote is called ns1 and can now be used.

Example operations

Get started with rclone and NetStorage with these examples. For additional rclone commands, visit https://rclone.org/commands/.

See contents of a directory in your project

rclone lsd ns1:/974012/testing/

Sync the contents local with remote

rclone sync . ns1:/974012/testing/

Upload local content to remote

rclone copy notes.txt ns1:/974012/testing/

Delete content on remote

rclone delete ns1:/974012/testing/notes.txt

Move or copy content between CP codes.

Your credentials must have access to two CP codes on the same remote. You can't perform operations between different remotes.

rclone move ns1:/974012/testing/notes.txt ns1:/974450/testing2/

Features

The Netstorage backend changes the rclone --links, -l behavior. When uploading, instead of creating the .rclonelink file, use the "symlink" API in order to create the corresponding symlink on the remote. The .rclonelink file will not be created, the upload will be intercepted and only the symlink file that matches the source file name with no suffix will be created on the remote.

This will effectively allow commands like copy/copyto, move/moveto and sync to upload from local to remote and download from remote to local directories with symlinks. Due to internal rclone limitations, it is not possible to upload an individual symlink file to any remote backend. You can always use the "backend symlink" command to create a symlink on the NetStorage server, refer to "symlink" section below.

Individual symlink files on the remote can be used with the commands like "cat" to print the destination name, or "delete" to delete symlink, or copy, copy/to and move/moveto to download from the remote to local. Note: individual symlink files on the remote should be specified including the suffix .rclonelink.

Note: No file with the suffix .rclonelink should ever exist on the server since it is not possible to actually upload/create a file with .rclonelink suffix with rclone, it can only exist if it is manually created through a non-rclone method on the remote.

Implicit vs. Explicit Directories

With NetStorage, directories can exist in one of two forms:

  1. Explicit Directory. This is an actual, physical directory that you have created in a storage group.
  2. Implicit Directory. This refers to a directory within a path that has not been physically created. For example, during upload of a file, nonexistent subdirectories can be specified in the target path. NetStorage creates these as "implicit." While the directories aren't physically created, they exist implicitly and the noted path is connected with the uploaded file.

Rclone will intercept all file uploads and mkdir commands for the NetStorage remote and will explicitly issue the mkdir command for each directory in the uploading path. This will help with the interoperability with the other Akamai services such as SFTP and the Content Management Shell (CMShell). Rclone will not guarantee correctness of operations with implicit directories which might have been created as a result of using an upload API directly.

--fast-list / ListR support

NetStorage remote supports the ListR feature by using the "list" NetStorage API action to return a lexicographical list of all objects within the specified CP code, recursing into subdirectories as they're encountered.

  • Rclone will use the ListR method for some commands by default. Commands such as lsf -R will use ListR by default. To disable this, include the --disable listR option to use the non-recursive method of listing objects.

  • Rclone will not use the ListR method for some commands. Commands such as sync don't use ListR by default. To force using the ListR method, include the --fast-list option.

There are pros and cons of using the ListR method, refer to rclone documentation. In general, the sync command over an existing deep tree on the remote will run faster with the "--fast-list" flag but with extra memory usage as a side effect. It might also result in higher CPU utilization but the whole task can be completed faster.

Note: There is a known limitation that "lsf -R" will display number of files in the directory and directory size as -1 when ListR method is used. The workaround is to pass "--disable listR" flag if these numbers are important in the output.

Purge

NetStorage remote supports the purge feature by using the "quick-delete" NetStorage API action. The quick-delete action is disabled by default for security reasons and can be enabled for the account through the Akamai portal. Rclone will first try to use quick-delete action for the purge command and if this functionality is disabled then will fall back to a standard delete method.

Note: Read the NetStorage Usage API for considerations when using "quick-delete". In general, using quick-delete method will not delete the tree immediately and objects targeted for quick-delete may still be accessible.

Standard options

Here are the Standard options specific to netstorage (Akamai NetStorage).

--netstorage-host

Domain+path of NetStorage host to connect to.

Format should be <domain>/<internal folders>

Properties:

  • Config: host
  • Env Var: RCLONE_NETSTORAGE_HOST
  • Type: string
  • Required: true

--netstorage-account

Set the NetStorage account name

Properties:

  • Config: account
  • Env Var: RCLONE_NETSTORAGE_ACCOUNT
  • Type: string
  • Required: true

--netstorage-secret

Set the NetStorage account secret/G2O key for authentication.

Please choose the 'y' option to set your own password then enter your secret.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: secret
  • Env Var: RCLONE_NETSTORAGE_SECRET
  • Type: string
  • Required: true

Advanced options

Here are the Advanced options specific to netstorage (Akamai NetStorage).

--netstorage-protocol

Select between HTTP or HTTPS protocol.

Most users should choose HTTPS, which is the default. HTTP is provided primarily for debugging purposes.

Properties:

  • Config: protocol
  • Env Var: RCLONE_NETSTORAGE_PROTOCOL
  • Type: string
  • Default: "https"
  • Examples:
    • "http"
      • HTTP protocol
    • "https"
      • HTTPS protocol

--netstorage-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_NETSTORAGE_DESCRIPTION
  • Type: string
  • Required: false

Backend commands

Here are the commands specific to the netstorage backend.

Run them with

rclone backend COMMAND remote:

The help below will explain what arguments each command takes.

See the backend command for more info on how to pass options and arguments.

These can be run on a running backend using the rc command backend/command.

du

Return disk usage information for a specified directory

rclone backend du remote: [options] [<arguments>+]

The usage information returned, includes the targeted directory as well as all files stored in any sub-directories that may exist.

You can create a symbolic link in ObjectStore with the symlink action.

rclone backend symlink remote: [options] [<arguments>+]

The desired path location (including applicable sub-directories) ending in the object that will be the target of the symlink (for example, /links/mylink). Include the file extension for the object, if applicable. rclone backend symlink <src> <path>

Microsoft Azure Blob Storage

Paths are specified as remote:container (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:container/path/to/dir.

Configuration

Here is an example of making a Microsoft Azure Blob Storage configuration. For a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Microsoft Azure Blob Storage
   \ "azureblob"
[snip]
Storage> azureblob
Storage Account Name
account> account_name
Storage Account Key
key> base64encodedkey==
Endpoint for the service - leave blank normally.
endpoint> 
Remote config
Configuration complete.
Options:
- type: azureblob
- account: account_name
- key: base64encodedkey==
- endpoint:
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

See all containers

rclone lsd remote:

Make a new container

rclone mkdir remote:container

List the contents of a container

rclone ls remote:container

Sync /home/local/directory to the remote container, deleting any excess files in the container.

rclone sync --interactive /home/local/directory remote:container

--fast-list

This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details.

Modification times and hashes

The modification time is stored as metadata on the object with the mtime key. It is stored using RFC3339 Format time with nanosecond precision. The metadata is supplied during directory listings so there is no performance overhead to using it.

If you wish to use the Azure standard LastModified time stored on the object as the modified time, then use the --use-server-modtime flag. Note that rclone can't set LastModified, so using the --update flag when syncing is recommended if using --use-server-modtime.

MD5 hashes are stored with blobs. However blobs that were uploaded in chunks only have an MD5 if the source remote was capable of MD5 hashes, e.g. the local disk.

Performance

When uploading large files, increasing the value of --azureblob-upload-concurrency will increase performance at the cost of using more memory. The default of 16 is set quite conservatively to use less memory. It maybe be necessary raise it to 64 or higher to fully utilize a 1 GBit/s link with a single file transfer.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
/ 0x2F ／
\ 0x5C ＼

File names can also not end with the following characters. These only get replaced if they are the last character in the name:

Character Value Replacement
. 0x2E ．

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Authentication

There are a number of ways of supplying credentials for Azure Blob Storage. Rclone tries them in the order of the sections below.

Env Auth

If the env_auth config parameter is true then rclone will pull credentials from the environment or runtime.

It tries these authentication methods in this order:

  1. Environment Variables
  2. Managed Service Identity Credentials
  3. Azure CLI credentials (as used by the az tool)

These are described in the following sections

Env Auth: 1. Environment Variables

If env_auth is set and environment variables are present rclone authenticates a service principal with a secret or certificate, or a user with a password, depending on which environment variable are set. It reads configuration from these variables, in the following order:

  1. Service principal with client secret
    • AZURE_TENANT_ID: ID of the service principal's tenant. Also called its "directory" ID.
    • AZURE_CLIENT_ID: the service principal's client ID
    • AZURE_CLIENT_SECRET: one of the service principal's client secrets
  2. Service principal with certificate
    • AZURE_TENANT_ID: ID of the service principal's tenant. Also called its "directory" ID.
    • AZURE_CLIENT_ID: the service principal's client ID
    • AZURE_CLIENT_CERTIFICATE_PATH: path to a PEM or PKCS12 certificate file including the private key.
    • AZURE_CLIENT_CERTIFICATE_PASSWORD: (optional) password for the certificate file.
    • AZURE_CLIENT_SEND_CERTIFICATE_CHAIN: (optional) Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to "true" or "1", authentication requests include the x5c header.
  3. User with username and password
    • AZURE_TENANT_ID: (optional) tenant to authenticate in. Defaults to "organizations".
    • AZURE_CLIENT_ID: client ID of the application the user will authenticate to
    • AZURE_USERNAME: a username (usually an email address)
    • AZURE_PASSWORD: the user's password
  4. Workload Identity
    • AZURE_TENANT_ID: Tenant to authenticate in.
    • AZURE_CLIENT_ID: Client ID of the application the user will authenticate to.
    • AZURE_FEDERATED_TOKEN_FILE: Path to projected service account token file.
    • AZURE_AUTHORITY_HOST: Authority of an Azure Active Directory endpoint (default: login.microsoftonline.com).
Env Auth: 2. Managed Service Identity Credentials

When using Managed Service Identity if the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default.

If the resource has multiple user-assigned identities you will need to unset env_auth and set use_msi instead. See the use_msi section.

If you are operating in disconnected clouds, or private clouds such as Azure Stack you may want to set disable_instance_discovery = true. This determines whether rclone requests Microsoft Entra instance metadata from https://login.microsoft.com/ before authenticating. Setting this to true will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy.

Env Auth: 3. Azure CLI credentials (as used by the az tool)

Credentials created with the az tool can be picked up using env_auth.

For example if you were to login with a service principal like this:

az login --service-principal -u XXX -p XXX --tenant XXX

Then you could access rclone resources like this:

rclone lsf :azureblob,env_auth,account=ACCOUNT:CONTAINER

Or

rclone lsf --azureblob-env-auth --azureblob-account=ACCOUNT :azureblob:CONTAINER

Which is analogous to using the az tool:

az storage blob list --container-name CONTAINER --account-name ACCOUNT --auth-mode login

Account and Shared Key

This is the most straight forward and least flexible way. Just fill in the account and key lines and leave the rest blank.

SAS URL

This can be an account level SAS URL or container level SAS URL.

To use it leave account and key blank and fill in sas_url.

An account level SAS URL or container level SAS URL can be obtained from the Azure portal or the Azure Storage Explorer. To get a container level SAS URL right click on a container in the Azure Blob explorer in the Azure portal.

If you use a container level SAS URL, rclone operations are permitted only on a particular container, e.g.

rclone ls azureblob:container

You can also list the single container from the root. This will only show the container specified by the SAS URL.

$ rclone lsd azureblob:
container/

Note that you can't see or access any other containers - this will fail

rclone ls azureblob:othercontainer

Container level SAS URLs are useful for temporarily allowing third parties access to a single container or putting credentials into an untrusted environment such as a CI build server.

Service principal with client secret

If these variables are set, rclone will authenticate with a service principal with a client secret.

  • tenant: ID of the service principal's tenant. Also called its "directory" ID.
  • client_id: the service principal's client ID
  • client_secret: one of the service principal's client secrets

The credentials can also be placed in a file using the service_principal_file configuration option.

Service principal with certificate

If these variables are set, rclone will authenticate with a service principal with certificate.

  • tenant: ID of the service principal's tenant. Also called its "directory" ID.
  • client_id: the service principal's client ID
  • client_certificate_path: path to a PEM or PKCS12 certificate file including the private key.
  • client_certificate_password: (optional) password for the certificate file.
  • client_send_certificate_chain: (optional) Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to "true" or "1", authentication requests include the x5c header.

NB client_certificate_password must be obscured - see rclone obscure.

User with username and password

If these variables are set, rclone will authenticate with username and password.

  • tenant: (optional) tenant to authenticate in. Defaults to "organizations".
  • client_id: client ID of the application the user will authenticate to
  • username: a username (usually an email address)
  • password: the user's password

Microsoft doesn't recommend this kind of authentication, because it's less secure than other authentication flows. This method is not interactive, so it isn't compatible with any form of multi-factor authentication, and the application must already have user or admin consent. This credential can only authenticate work and school accounts; it can't authenticate Microsoft accounts.

NB password must be obscured - see rclone obscure.

Managed Service Identity Credentials

If use_msi is set then managed service identity credentials are used. This authentication only works when running in an Azure service. env_auth needs to be unset to use this.

However if you have multiple user identities to choose from these must be explicitly specified using exactly one of the msi_object_id, msi_client_id, or msi_mi_res_id parameters.

If none of msi_object_id, msi_client_id, or msi_mi_res_id is set, this is is equivalent to using env_auth.

Fedrated Identity Credentials

If these variables are set, rclone will authenticate with fedrated identity.

  • tenant_id: tenant_id to authenticate in storage
  • client_id: client ID of the application the user will authenticate to storage
  • msi_client_id: managed identity client ID of the application the user will authenticate to

By default "api://AzureADTokenExchange" is used as scope for token retrieval over MSI. This token is then exchanged for actual storage token using 'tenant_id' and 'client_id'.

Azure CLI tool az

Set to use the Azure CLI tool az as the sole means of authentication.

Setting this can be useful if you wish to use the az CLI on a host with a System Managed Identity that you do not want to use.

Don't set env_auth at the same time.

Anonymous

If you want to access resources with public anonymous access then set account only. You can do this without making an rclone config:

rclone lsf :azureblob,account=ACCOUNT:CONTAINER

Standard options

Here are the Standard options specific to azureblob (Microsoft Azure Blob Storage).

--azureblob-account

Azure Storage Account Name.

Set this to the Azure Storage Account Name in use.

Leave blank to use SAS URL or Emulator, otherwise it needs to be set.

If this is blank and if env_auth is set it will be read from the environment variable AZURE_STORAGE_ACCOUNT_NAME if possible.

Properties:

  • Config: account
  • Env Var: RCLONE_AZUREBLOB_ACCOUNT
  • Type: string
  • Required: false

--azureblob-env-auth

Read credentials from runtime (environment variables, CLI or MSI).

See the authentication docs for full info.

Properties:

  • Config: env_auth
  • Env Var: RCLONE_AZUREBLOB_ENV_AUTH
  • Type: bool
  • Default: false

--azureblob-key

Storage Account Shared Key.

Leave blank to use SAS URL or Emulator.

Properties:

  • Config: key
  • Env Var: RCLONE_AZUREBLOB_KEY
  • Type: string
  • Required: false

--azureblob-sas-url

SAS URL for container level access only.

Leave blank if using account/key or Emulator.

Properties:

  • Config: sas_url
  • Env Var: RCLONE_AZUREBLOB_SAS_URL
  • Type: string
  • Required: false

--azureblob-tenant

ID of the service principal's tenant. Also called its directory ID.

Set this if using - Service principal with client secret - Service principal with certificate - User with username and password

Properties:

  • Config: tenant
  • Env Var: RCLONE_AZUREBLOB_TENANT
  • Type: string
  • Required: false

--azureblob-client-id

The ID of the client in use.

Set this if using - Service principal with client secret - Service principal with certificate - User with username and password

Properties:

  • Config: client_id
  • Env Var: RCLONE_AZUREBLOB_CLIENT_ID
  • Type: string
  • Required: false

--azureblob-client-secret

One of the service principal's client secrets

Set this if using - Service principal with client secret

Properties:

  • Config: client_secret
  • Env Var: RCLONE_AZUREBLOB_CLIENT_SECRET
  • Type: string
  • Required: false

--azureblob-client-certificate-path

Path to a PEM or PKCS12 certificate file including the private key.

Set this if using - Service principal with certificate

Properties:

  • Config: client_certificate_path
  • Env Var: RCLONE_AZUREBLOB_CLIENT_CERTIFICATE_PATH
  • Type: string
  • Required: false

--azureblob-client-certificate-password

Password for the certificate file (optional).

Optionally set this if using - Service principal with certificate

And the certificate has a password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: client_certificate_password
  • Env Var: RCLONE_AZUREBLOB_CLIENT_CERTIFICATE_PASSWORD
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to azureblob (Microsoft Azure Blob Storage).

--azureblob-client-send-certificate-chain

Send the certificate chain when using certificate auth.

Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to true, authentication requests include the x5c header.

Optionally set this if using - Service principal with certificate

Properties:

  • Config: client_send_certificate_chain
  • Env Var: RCLONE_AZUREBLOB_CLIENT_SEND_CERTIFICATE_CHAIN
  • Type: bool
  • Default: false

--azureblob-username

User name (usually an email address)

Set this if using - User with username and password

Properties:

  • Config: username
  • Env Var: RCLONE_AZUREBLOB_USERNAME
  • Type: string
  • Required: false

--azureblob-password

The user's password

Set this if using - User with username and password

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: password
  • Env Var: RCLONE_AZUREBLOB_PASSWORD
  • Type: string
  • Required: false

--azureblob-service-principal-file

Path to file containing credentials for use with a service principal.

Leave blank normally. Needed only if you want to use a service principal instead of interactive login.

$ az ad sp create-for-rbac --name "<name>" \
  --role "Storage Blob Data Owner" \
  --scopes "/subscriptions/<subscription>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account>/blobServices/default/containers/<container>" \
  > azure-principal.json

See "Create an Azure service principal" and "Assign an Azure role for access to blob data" pages for more details.

It may be more convenient to put the credentials directly into the rclone config file under the client_id, tenant and client_secret keys instead of setting service_principal_file.

Properties:

  • Config: service_principal_file
  • Env Var: RCLONE_AZUREBLOB_SERVICE_PRINCIPAL_FILE
  • Type: string
  • Required: false

--azureblob-disable-instance-discovery

Skip requesting Microsoft Entra instance metadata

This should be set true only by applications authenticating in disconnected clouds, or private clouds such as Azure Stack.

It determines whether rclone requests Microsoft Entra instance metadata from https://login.microsoft.com/ before authenticating.

Setting this to true will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy.

Properties:

  • Config: disable_instance_discovery
  • Env Var: RCLONE_AZUREBLOB_DISABLE_INSTANCE_DISCOVERY
  • Type: bool
  • Default: false

--azureblob-use-msi

Use a managed service identity to authenticate (only works in Azure).

When true, use a managed service identity to authenticate to Azure Storage instead of a SAS token or account key.

If the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default. If the resource has multiple user-assigned identities, the identity to use must be explicitly specified using exactly one of the msi_object_id, msi_client_id, or msi_mi_res_id parameters.

Properties:

  • Config: use_msi
  • Env Var: RCLONE_AZUREBLOB_USE_MSI
  • Type: bool
  • Default: false

--azureblob-msi-object-id

Object ID of the user-assigned MSI to use, if any.

Leave blank if msi_client_id or msi_mi_res_id specified.

Properties:

  • Config: msi_object_id
  • Env Var: RCLONE_AZUREBLOB_MSI_OBJECT_ID
  • Type: string
  • Required: false

--azureblob-msi-client-id

Object ID of the user-assigned MSI to use, if any.

Leave blank if msi_object_id or msi_mi_res_id specified.

Properties:

  • Config: msi_client_id
  • Env Var: RCLONE_AZUREBLOB_MSI_CLIENT_ID
  • Type: string
  • Required: false

--azureblob-msi-mi-res-id

Azure resource ID of the user-assigned MSI to use, if any.

Leave blank if msi_client_id or msi_object_id specified.

Properties:

  • Config: msi_mi_res_id
  • Env Var: RCLONE_AZUREBLOB_MSI_MI_RES_ID
  • Type: string
  • Required: false

--azureblob-use-emulator

Uses local storage emulator if provided as 'true'.

Leave blank if using real azure storage endpoint.

Properties:

  • Config: use_emulator
  • Env Var: RCLONE_AZUREBLOB_USE_EMULATOR
  • Type: bool
  • Default: false

--azureblob-use-az

Use Azure CLI tool az for authentication

Set to use the Azure CLI tool az as the sole means of authentication.

Setting this can be useful if you wish to use the az CLI on a host with a System Managed Identity that you do not want to use.

Don't set env_auth at the same time.

Properties:

  • Config: use_az
  • Env Var: RCLONE_AZUREBLOB_USE_AZ
  • Type: bool
  • Default: false

--azureblob-endpoint

Endpoint for the service.

Leave blank normally.

Properties:

  • Config: endpoint
  • Env Var: RCLONE_AZUREBLOB_ENDPOINT
  • Type: string
  • Required: false

--azureblob-upload-cutoff

Cutoff for switching to chunked upload (<= 256 MiB) (deprecated).

Properties:

  • Config: upload_cutoff
  • Env Var: RCLONE_AZUREBLOB_UPLOAD_CUTOFF
  • Type: string
  • Required: false

--azureblob-chunk-size

Upload chunk size.

Note that this is stored in memory and there may be up to "--transfers" * "--azureblob-upload-concurrency" chunks stored at once in memory.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_AZUREBLOB_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 4Mi

--azureblob-upload-concurrency

Concurrency for multipart uploads.

This is the number of chunks of the same file that are uploaded concurrently.

If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers.

In tests, upload speed increases almost linearly with upload concurrency. For example to fill a gigabit pipe it may be necessary to raise this to 64. Note that this will use more memory.

Note that chunks are stored in memory and there may be up to "--transfers" * "--azureblob-upload-concurrency" chunks stored at once in memory.

Properties:

  • Config: upload_concurrency
  • Env Var: RCLONE_AZUREBLOB_UPLOAD_CONCURRENCY
  • Type: int
  • Default: 16

--azureblob-copy-cutoff

Cutoff for switching to multipart copy.

Any files larger than this that need to be server-side copied will be copied in chunks of chunk_size using the put block list API.

Files smaller than this limit will be copied with the Copy Blob API.

Properties:

  • Config: copy_cutoff
  • Env Var: RCLONE_AZUREBLOB_COPY_CUTOFF
  • Type: SizeSuffix
  • Default: 8Mi

--azureblob-copy-concurrency

Concurrency for multipart copy.

This is the number of chunks of the same file that are copied concurrently.

These chunks are not buffered in memory and Microsoft recommends setting this value to greater than 1000 in the azcopy documentation.

https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azcopy-optimize#increase-concurrency

In tests, copy speed increases almost linearly with copy concurrency.

Properties:

  • Config: copy_concurrency
  • Env Var: RCLONE_AZUREBLOB_COPY_CONCURRENCY
  • Type: int
  • Default: 512

--azureblob-use-copy-blob

Whether to use the Copy Blob API when copying to the same storage account.

If true (the default) then rclone will use the Copy Blob API for copies to the same storage account even when the size is above the copy_cutoff.

Rclone assumes that the same storage account means the same config and does not check for the same storage account in different configs.

There should be no need to change this value.

Properties:

  • Config: use_copy_blob
  • Env Var: RCLONE_AZUREBLOB_USE_COPY_BLOB
  • Type: bool
  • Default: true

--azureblob-list-chunk

Size of blob list.

This sets the number of blobs requested in each listing chunk. Default is the maximum, 5000. "List blobs" requests are permitted 2 minutes per megabyte to complete. If an operation is taking longer than 2 minutes per megabyte on average, it will time out ( source ). This can be used to limit the number of blobs items to return, to avoid the time out.

Properties:

  • Config: list_chunk
  • Env Var: RCLONE_AZUREBLOB_LIST_CHUNK
  • Type: int
  • Default: 5000

--azureblob-access-tier

Access tier of blob: hot, cool, cold or archive.

Archived blobs can be restored by setting access tier to hot, cool or cold. Leave blank if you intend to use default access tier, which is set at account level

If there is no "access tier" specified, rclone doesn't apply any tier. rclone performs "Set Tier" operation on blobs while uploading, if objects are not modified, specifying "access tier" to new one will have no effect. If blobs are in "archive tier" at remote, trying to perform data transfer operations from remote will not be allowed. User should first restore by tiering blob to "Hot", "Cool" or "Cold".

Properties:

  • Config: access_tier
  • Env Var: RCLONE_AZUREBLOB_ACCESS_TIER
  • Type: string
  • Required: false

--azureblob-archive-tier-delete

Delete archive tier blobs before overwriting.

Archive tier blobs cannot be updated. So without this flag, if you attempt to update an archive tier blob, then rclone will produce the error:

can't update archive tier blob without --azureblob-archive-tier-delete

With this flag set then before rclone attempts to overwrite an archive tier blob, it will delete the existing blob before uploading its replacement. This has the potential for data loss if the upload fails (unlike updating a normal blob) and also may cost more since deleting archive tier blobs early may be chargable.

Properties:

  • Config: archive_tier_delete
  • Env Var: RCLONE_AZUREBLOB_ARCHIVE_TIER_DELETE
  • Type: bool
  • Default: false

--azureblob-disable-checksum

Don't store MD5 checksum with object metadata.

Normally rclone will calculate the MD5 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading.

Properties:

  • Config: disable_checksum
  • Env Var: RCLONE_AZUREBLOB_DISABLE_CHECKSUM
  • Type: bool
  • Default: false

--azureblob-memory-pool-flush-time

How often internal memory buffer pools will be flushed. (no longer used)

Properties:

  • Config: memory_pool_flush_time
  • Env Var: RCLONE_AZUREBLOB_MEMORY_POOL_FLUSH_TIME
  • Type: Duration
  • Default: 1m0s

--azureblob-memory-pool-use-mmap

Whether to use mmap buffers in internal memory pool. (no longer used)

Properties:

  • Config: memory_pool_use_mmap
  • Env Var: RCLONE_AZUREBLOB_MEMORY_POOL_USE_MMAP
  • Type: bool
  • Default: false

--azureblob-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_AZUREBLOB_ENCODING
  • Type: Encoding
  • Default: Slash,BackSlash,Del,Ctl,RightPeriod,InvalidUtf8

--azureblob-public-access

Public access level of a container: blob or container.

Properties:

  • Config: public_access
  • Env Var: RCLONE_AZUREBLOB_PUBLIC_ACCESS
  • Type: string
  • Required: false
  • Examples:
    • ""
      • The container and its blobs can be accessed only with an authorized request.
      • It's a default value.
    • "blob"
      • Blob data within this container can be read via anonymous request.
    • "container"
      • Allow full public read access for container and blob data.

--azureblob-directory-markers

Upload an empty object with a trailing slash when a new directory is created

Empty folders are unsupported for bucket based remotes, this option creates an empty object ending with "/", to persist the folder.

This object also has the metadata "hdi_isfolder = true" to conform to the Microsoft standard.

Properties:

  • Config: directory_markers
  • Env Var: RCLONE_AZUREBLOB_DIRECTORY_MARKERS
  • Type: bool
  • Default: false

--azureblob-no-check-container

If set, don't attempt to check the container exists or create it.

This can be useful when trying to minimise the number of transactions rclone does if you know the container exists already.

Properties:

  • Config: no_check_container
  • Env Var: RCLONE_AZUREBLOB_NO_CHECK_CONTAINER
  • Type: bool
  • Default: false

--azureblob-no-head-object

If set, do not do HEAD before GET when getting objects.

Properties:

  • Config: no_head_object
  • Env Var: RCLONE_AZUREBLOB_NO_HEAD_OBJECT
  • Type: bool
  • Default: false

--azureblob-delete-snapshots

Set to specify how to deal with snapshots on blob deletion.

Properties:

  • Config: delete_snapshots
  • Env Var: RCLONE_AZUREBLOB_DELETE_SNAPSHOTS
  • Type: string
  • Required: false
  • Choices:
    • ""
      • By default, the delete operation fails if a blob has snapshots
    • "include"
      • Specify 'include' to remove the root blob and all its snapshots
    • "only"
      • Specify 'only' to remove only the snapshots but keep the root blob.

--azureblob-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_AZUREBLOB_DESCRIPTION
  • Type: string
  • Required: false

Custom upload headers

You can set custom upload headers with the --header-upload flag.

  • Cache-Control
  • Content-Disposition
  • Content-Encoding
  • Content-Language
  • Content-Type
  • X-MS-Tags

Eg --header-upload "Content-Type: text/potato" or --header-upload "X-MS-Tags: foo=bar"

Limitations

MD5 sums are only uploaded with chunked files if the source has an MD5 sum. This will always be the case for a local to azure copy.

rclone about is not supported by the Microsoft Azure Blob storage backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

Azure Storage Emulator Support

You can run rclone with the storage emulator (usually azurite).

To do this, just set up a new remote with rclone config following the instructions in the introduction and set use_emulator in the advanced settings as true. You do not need to provide a default account name nor an account key. But you can override them in the account and key options. (Prior to v1.61 they were hard coded to azurite's devstoreaccount1.)

Also, if you want to access a storage emulator instance running on a different machine, you can override the endpoint parameter in the advanced settings, setting it to http(s)://<host>:<port>/devstoreaccount1 (e.g. http://10.254.2.5:10000/devstoreaccount1).

Microsoft Azure Files Storage

Paths are specified as remote: You may put subdirectories in too, e.g. remote:path/to/dir.

Configuration

Here is an example of making a Microsoft Azure Files Storage configuration. For a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Microsoft Azure Files Storage
   \ "azurefiles"
[snip]

Option account.
Azure Storage Account Name.
Set this to the Azure Storage Account Name in use.
Leave blank to use SAS URL or connection string, otherwise it needs to be set.
If this is blank and if env_auth is set it will be read from the
environment variable `AZURE_STORAGE_ACCOUNT_NAME` if possible.
Enter a value. Press Enter to leave empty.
account> account_name

Option share_name.
Azure Files Share Name.
This is required and is the name of the share to access.
Enter a value. Press Enter to leave empty.
share_name> share_name

Option env_auth.
Read credentials from runtime (environment variables, CLI or MSI).
See the [authentication docs](/azurefiles#authentication) for full info.
Enter a boolean value (true or false). Press Enter for the default (false).
env_auth> 

Option key.
Storage Account Shared Key.
Leave blank to use SAS URL or connection string.
Enter a value. Press Enter to leave empty.
key> base64encodedkey==

Option sas_url.
SAS URL.
Leave blank if using account/key or connection string.
Enter a value. Press Enter to leave empty.
sas_url> 

Option connection_string.
Azure Files Connection String.
Enter a value. Press Enter to leave empty.
connection_string> 
[snip]

Configuration complete.
Options:
- type: azurefiles
- account: account_name
- share_name: share_name
- key: base64encodedkey==
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d>

Once configured you can use rclone.

See all files in the top level:

rclone lsf remote:

Make a new directory in the root:

rclone mkdir remote:dir

Recursively List the contents:

rclone ls remote:

Sync /home/local/directory to the remote directory, deleting any excess files in the directory.

rclone sync --interactive /home/local/directory remote:dir

Modified time

The modified time is stored as Azure standard LastModified time on files

Performance

When uploading large files, increasing the value of --azurefiles-upload-concurrency will increase performance at the cost of using more memory. The default of 16 is set quite conservatively to use less memory. It maybe be necessary raise it to 64 or higher to fully utilize a 1 GBit/s link with a single file transfer.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
" 0x22 ＂
* 0x2A ＊
: 0x3A ：
< 0x3C ＜
> 0x3E ＞
? 0x3F ？
\ 0x5C ＼
| 0x7C ｜

File names can also not end with the following characters. These only get replaced if they are the last character in the name:

Character Value Replacement
. 0x2E ．

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Hashes

MD5 hashes are stored with files. Not all files will have MD5 hashes as these have to be uploaded with the file.

Authentication

There are a number of ways of supplying credentials for Azure Files Storage. Rclone tries them in the order of the sections below.

Env Auth

If the env_auth config parameter is true then rclone will pull credentials from the environment or runtime.

It tries these authentication methods in this order:

  1. Environment Variables
  2. Managed Service Identity Credentials
  3. Azure CLI credentials (as used by the az tool)

These are described in the following sections

Env Auth: 1. Environment Variables

If env_auth is set and environment variables are present rclone authenticates a service principal with a secret or certificate, or a user with a password, depending on which environment variable are set. It reads configuration from these variables, in the following order:

  1. Service principal with client secret
    • AZURE_TENANT_ID: ID of the service principal's tenant. Also called its "directory" ID.
    • AZURE_CLIENT_ID: the service principal's client ID
    • AZURE_CLIENT_SECRET: one of the service principal's client secrets
  2. Service principal with certificate
    • AZURE_TENANT_ID: ID of the service principal's tenant. Also called its "directory" ID.
    • AZURE_CLIENT_ID: the service principal's client ID
    • AZURE_CLIENT_CERTIFICATE_PATH: path to a PEM or PKCS12 certificate file including the private key.
    • AZURE_CLIENT_CERTIFICATE_PASSWORD: (optional) password for the certificate file.
    • AZURE_CLIENT_SEND_CERTIFICATE_CHAIN: (optional) Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to "true" or "1", authentication requests include the x5c header.
  3. User with username and password
    • AZURE_TENANT_ID: (optional) tenant to authenticate in. Defaults to "organizations".
    • AZURE_CLIENT_ID: client ID of the application the user will authenticate to
    • AZURE_USERNAME: a username (usually an email address)
    • AZURE_PASSWORD: the user's password
  4. Workload Identity
    • AZURE_TENANT_ID: Tenant to authenticate in.
    • AZURE_CLIENT_ID: Client ID of the application the user will authenticate to.
    • AZURE_FEDERATED_TOKEN_FILE: Path to projected service account token file.
    • AZURE_AUTHORITY_HOST: Authority of an Azure Active Directory endpoint (default: login.microsoftonline.com).
Env Auth: 2. Managed Service Identity Credentials

When using Managed Service Identity if the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default.

If the resource has multiple user-assigned identities you will need to unset env_auth and set use_msi instead. See the use_msi section.

If you are operating in disconnected clouds, or private clouds such as Azure Stack you may want to set disable_instance_discovery = true. This determines whether rclone requests Microsoft Entra instance metadata from https://login.microsoft.com/ before authenticating. Setting this to true will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy.

Env Auth: 3. Azure CLI credentials (as used by the az tool)

Credentials created with the az tool can be picked up using env_auth.

For example if you were to login with a service principal like this:

az login --service-principal -u XXX -p XXX --tenant XXX

Then you could access rclone resources like this:

rclone lsf :azurefiles,env_auth,account=ACCOUNT:

Or

rclone lsf --azurefiles-env-auth --azurefiles-account=ACCOUNT :azurefiles:

Account and Shared Key

This is the most straight forward and least flexible way. Just fill in the account and key lines and leave the rest blank.

SAS URL

To use it leave account, key and connection_string blank and fill in sas_url.

Connection String

To use it leave account, key and "sas_url" blank and fill in connection_string.

Service principal with client secret

If these variables are set, rclone will authenticate with a service principal with a client secret.

  • tenant: ID of the service principal's tenant. Also called its "directory" ID.
  • client_id: the service principal's client ID
  • client_secret: one of the service principal's client secrets

The credentials can also be placed in a file using the service_principal_file configuration option.

Service principal with certificate

If these variables are set, rclone will authenticate with a service principal with certificate.

  • tenant: ID of the service principal's tenant. Also called its "directory" ID.
  • client_id: the service principal's client ID
  • client_certificate_path: path to a PEM or PKCS12 certificate file including the private key.
  • client_certificate_password: (optional) password for the certificate file.
  • client_send_certificate_chain: (optional) Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to "true" or "1", authentication requests include the x5c header.

NB client_certificate_password must be obscured - see rclone obscure.

User with username and password

If these variables are set, rclone will authenticate with username and password.

  • tenant: (optional) tenant to authenticate in. Defaults to "organizations".
  • client_id: client ID of the application the user will authenticate to
  • username: a username (usually an email address)
  • password: the user's password

Microsoft doesn't recommend this kind of authentication, because it's less secure than other authentication flows. This method is not interactive, so it isn't compatible with any form of multi-factor authentication, and the application must already have user or admin consent. This credential can only authenticate work and school accounts; it can't authenticate Microsoft accounts.

NB password must be obscured - see rclone obscure.

Managed Service Identity Credentials

If use_msi is set then managed service identity credentials are used. This authentication only works when running in an Azure service. env_auth needs to be unset to use this.

However if you have multiple user identities to choose from these must be explicitly specified using exactly one of the msi_object_id, msi_client_id, or msi_mi_res_id parameters.

If none of msi_object_id, msi_client_id, or msi_mi_res_id is set, this is is equivalent to using env_auth.

Fedrated Identity Credentials

If these variables are set, rclone will authenticate with fedrated identity.

  • tenant_id: tenant_id to authenticate in storage
  • client_id: client ID of the application the user will authenticate to storage
  • msi_client_id: managed identity client ID of the application the user will authenticate to

By default "api://AzureADTokenExchange" is used as scope for token retrieval over MSI. This token is then exchanged for actual storage token using 'tenant_id' and 'client_id'.

Azure CLI tool az

Set to use the Azure CLI tool az as the sole means of authentication. Setting this can be useful if you wish to use the az CLI on a host with a System Managed Identity that you do not want to use. Don't set env_auth at the same time.

Standard options

Here are the Standard options specific to azurefiles (Microsoft Azure Files).

--azurefiles-account

Azure Storage Account Name.

Set this to the Azure Storage Account Name in use.

Leave blank to use SAS URL or connection string, otherwise it needs to be set.

If this is blank and if env_auth is set it will be read from the environment variable AZURE_STORAGE_ACCOUNT_NAME if possible.

Properties:

  • Config: account
  • Env Var: RCLONE_AZUREFILES_ACCOUNT
  • Type: string
  • Required: false

--azurefiles-share-name

Azure Files Share Name.

This is required and is the name of the share to access.

Properties:

  • Config: share_name
  • Env Var: RCLONE_AZUREFILES_SHARE_NAME
  • Type: string
  • Required: false

--azurefiles-env-auth

Read credentials from runtime (environment variables, CLI or MSI).

See the authentication docs for full info.

Properties:

  • Config: env_auth
  • Env Var: RCLONE_AZUREFILES_ENV_AUTH
  • Type: bool
  • Default: false

--azurefiles-key

Storage Account Shared Key.

Leave blank to use SAS URL or connection string.

Properties:

  • Config: key
  • Env Var: RCLONE_AZUREFILES_KEY
  • Type: string
  • Required: false

--azurefiles-sas-url

SAS URL.

Leave blank if using account/key or connection string.

Properties:

  • Config: sas_url
  • Env Var: RCLONE_AZUREFILES_SAS_URL
  • Type: string
  • Required: false

--azurefiles-connection-string

Azure Files Connection String.

Properties:

  • Config: connection_string
  • Env Var: RCLONE_AZUREFILES_CONNECTION_STRING
  • Type: string
  • Required: false

--azurefiles-tenant

ID of the service principal's tenant. Also called its directory ID.

Set this if using - Service principal with client secret - Service principal with certificate - User with username and password

Properties:

  • Config: tenant
  • Env Var: RCLONE_AZUREFILES_TENANT
  • Type: string
  • Required: false

--azurefiles-client-id

The ID of the client in use.

Set this if using - Service principal with client secret - Service principal with certificate - User with username and password

Properties:

  • Config: client_id
  • Env Var: RCLONE_AZUREFILES_CLIENT_ID
  • Type: string
  • Required: false

--azurefiles-client-secret

One of the service principal's client secrets

Set this if using - Service principal with client secret

Properties:

  • Config: client_secret
  • Env Var: RCLONE_AZUREFILES_CLIENT_SECRET
  • Type: string
  • Required: false

--azurefiles-client-certificate-path

Path to a PEM or PKCS12 certificate file including the private key.

Set this if using - Service principal with certificate

Properties:

  • Config: client_certificate_path
  • Env Var: RCLONE_AZUREFILES_CLIENT_CERTIFICATE_PATH
  • Type: string
  • Required: false

--azurefiles-client-certificate-password

Password for the certificate file (optional).

Optionally set this if using - Service principal with certificate

And the certificate has a password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: client_certificate_password
  • Env Var: RCLONE_AZUREFILES_CLIENT_CERTIFICATE_PASSWORD
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to azurefiles (Microsoft Azure Files).

--azurefiles-client-send-certificate-chain

Send the certificate chain when using certificate auth.

Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to true, authentication requests include the x5c header.

Optionally set this if using - Service principal with certificate

Properties:

  • Config: client_send_certificate_chain
  • Env Var: RCLONE_AZUREFILES_CLIENT_SEND_CERTIFICATE_CHAIN
  • Type: bool
  • Default: false

--azurefiles-username

User name (usually an email address)

Set this if using - User with username and password

Properties:

  • Config: username
  • Env Var: RCLONE_AZUREFILES_USERNAME
  • Type: string
  • Required: false

--azurefiles-password

The user's password

Set this if using - User with username and password

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: password
  • Env Var: RCLONE_AZUREFILES_PASSWORD
  • Type: string
  • Required: false

--azurefiles-service-principal-file

Path to file containing credentials for use with a service principal.

Leave blank normally. Needed only if you want to use a service principal instead of interactive login.

$ az ad sp create-for-rbac --name "<name>" \
  --role "Storage Files Data Owner" \
  --scopes "/subscriptions/<subscription>/resourceGroups/<resource-group>/providers/Microsoft.Storage/storageAccounts/<storage-account>/blobServices/default/containers/<container>" \
  > azure-principal.json

See "Create an Azure service principal" and "Assign an Azure role for access to files data" pages for more details.

NB this section needs updating for Azure Files - pull requests appreciated!

It may be more convenient to put the credentials directly into the rclone config file under the client_id, tenant and client_secret keys instead of setting service_principal_file.

Properties:

  • Config: service_principal_file
  • Env Var: RCLONE_AZUREFILES_SERVICE_PRINCIPAL_FILE
  • Type: string
  • Required: false

--azurefiles-use-msi

Use a managed service identity to authenticate (only works in Azure).

When true, use a managed service identity to authenticate to Azure Storage instead of a SAS token or account key.

If the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default. If the resource has multiple user-assigned identities, the identity to use must be explicitly specified using exactly one of the msi_object_id, msi_client_id, or msi_mi_res_id parameters.

Properties:

  • Config: use_msi
  • Env Var: RCLONE_AZUREFILES_USE_MSI
  • Type: bool
  • Default: false

--azurefiles-msi-object-id

Object ID of the user-assigned MSI to use, if any.

Leave blank if msi_client_id or msi_mi_res_id specified.

Properties:

  • Config: msi_object_id
  • Env Var: RCLONE_AZUREFILES_MSI_OBJECT_ID
  • Type: string
  • Required: false

--azurefiles-msi-client-id

Object ID of the user-assigned MSI to use, if any.

Leave blank if msi_object_id or msi_mi_res_id specified.

Properties:

  • Config: msi_client_id
  • Env Var: RCLONE_AZUREFILES_MSI_CLIENT_ID
  • Type: string
  • Required: false

--azurefiles-msi-mi-res-id

Azure resource ID of the user-assigned MSI to use, if any.

Leave blank if msi_client_id or msi_object_id specified.

Properties:

  • Config: msi_mi_res_id
  • Env Var: RCLONE_AZUREFILES_MSI_MI_RES_ID
  • Type: string
  • Required: false

--azurefiles-disable-instance-discovery

Skip requesting Microsoft Entra instance metadata This should be set true only by applications authenticating in disconnected clouds, or private clouds such as Azure Stack. It determines whether rclone requests Microsoft Entra instance metadata from https://login.microsoft.com/ before authenticating. Setting this to true will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy.

Properties:

  • Config: disable_instance_discovery
  • Env Var: RCLONE_AZUREFILES_DISABLE_INSTANCE_DISCOVERY
  • Type: bool
  • Default: false

--azurefiles-use-az

Use Azure CLI tool az for authentication Set to use the Azure CLI tool az as the sole means of authentication. Setting this can be useful if you wish to use the az CLI on a host with a System Managed Identity that you do not want to use. Don't set env_auth at the same time.

Properties:

  • Config: use_az
  • Env Var: RCLONE_AZUREFILES_USE_AZ
  • Type: bool
  • Default: false

--azurefiles-endpoint

Endpoint for the service.

Leave blank normally.

Properties:

  • Config: endpoint
  • Env Var: RCLONE_AZUREFILES_ENDPOINT
  • Type: string
  • Required: false

--azurefiles-chunk-size

Upload chunk size.

Note that this is stored in memory and there may be up to "--transfers" * "--azurefile-upload-concurrency" chunks stored at once in memory.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_AZUREFILES_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 4Mi

--azurefiles-upload-concurrency

Concurrency for multipart uploads.

This is the number of chunks of the same file that are uploaded concurrently.

If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers.

Note that chunks are stored in memory and there may be up to "--transfers" * "--azurefile-upload-concurrency" chunks stored at once in memory.

Properties:

  • Config: upload_concurrency
  • Env Var: RCLONE_AZUREFILES_UPLOAD_CONCURRENCY
  • Type: int
  • Default: 16

--azurefiles-max-stream-size

Max size for streamed files.

Azure files needs to know in advance how big the file will be. When rclone doesn't know it uses this value instead.

This will be used when rclone is streaming data, the most common uses are:

  • Uploading files with --vfs-cache-mode off with rclone mount
  • Using rclone rcat
  • Copying files with unknown length

You will need this much free space in the share as the file will be this size temporarily.

Properties:

  • Config: max_stream_size
  • Env Var: RCLONE_AZUREFILES_MAX_STREAM_SIZE
  • Type: SizeSuffix
  • Default: 10Gi

--azurefiles-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_AZUREFILES_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,RightPeriod,InvalidUtf8,Dot

--azurefiles-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_AZUREFILES_DESCRIPTION
  • Type: string
  • Required: false

Custom upload headers

You can set custom upload headers with the --header-upload flag.

  • Cache-Control
  • Content-Disposition
  • Content-Encoding
  • Content-Language
  • Content-Type

Eg --header-upload "Content-Type: text/potato"

Limitations

MD5 sums are only uploaded with chunked files if the source has an MD5 sum. This will always be the case for a local to azure copy.

Microsoft OneDrive

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Configuration

The initial setup for OneDrive involves getting a token from Microsoft which you need to do in your browser. rclone config walks you through it.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> n
name> remote
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Microsoft OneDrive
   \ "onedrive"
[snip]
Storage> onedrive
Microsoft App Client Id
Leave blank normally.
Enter a string value. Press Enter for the default ("").
client_id>
Microsoft App Client Secret
Leave blank normally.
Enter a string value. Press Enter for the default ("").
client_secret>
Edit advanced config? (y/n)
y) Yes
n) No
y/n> n
Remote config
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y) Yes
n) No
y/n> y
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth
Log in and authorize rclone for access
Waiting for code...
Got code
Choose a number from below, or type in an existing value
 1 / OneDrive Personal or Business
   \ "onedrive"
 2 / Sharepoint site
   \ "sharepoint"
 3 / Type in driveID
   \ "driveid"
 4 / Type in SiteID
   \ "siteid"
 5 / Search a Sharepoint site
   \ "search"
Your choice> 1
Found 1 drives, please select the one you want to use:
0: OneDrive (business) id=b!Eqwertyuiopasdfghjklzxcvbnm-7mnbvcxzlkjhgfdsapoiuytrewqk
Chose drive to use:> 0
Found drive 'root' of type 'business', URL: https://org-my.sharepoint.com/personal/you/Documents
Is that okay?
y) Yes
n) No
y/n> y
Configuration complete.
Options:
- type: onedrive
- token: {"access_token":"youraccesstoken","token_type":"Bearer","refresh_token":"yourrefreshtoken","expiry":"2018-08-26T22:39:52.486512262+08:00"}
- drive_id: b!Eqwertyuiopasdfghjklzxcvbnm-7mnbvcxzlkjhgfdsapoiuytrewqk
- drive_type: business
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

See the remote setup docs for how to set it up on a machine with no Internet browser available.

Note that rclone runs a webserver on your local machine to collect the token as returned from Microsoft. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall.

Once configured you can then use rclone like this,

List directories in top level of your OneDrive

rclone lsd remote:

List all the files in your OneDrive

rclone ls remote:

To copy a local directory to an OneDrive directory called backup

rclone copy /home/source remote:backup

Getting your own Client ID and Key

rclone uses a default Client ID when talking to OneDrive, unless a custom client_id is specified in the config. The default Client ID and Key are shared by all rclone users when performing requests.

You may choose to create and use your own Client ID, in case the default one does not work well for you. For example, you might see throttling.

Creating Client ID for OneDrive Personal

To create your own Client ID, please follow these steps:

  1. Open https://portal.azure.com/?quickstart=true#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/~/Overview and then under the Add menu click App registration.
    • If you have not created an Azure account, you will be prompted to. This is free, but you need to provide a phone number, address, and credit card for identity verification.
  2. Enter a name for your app, choose account type Accounts in any organizational directory (Any Azure AD directory - Multitenant) and personal Microsoft accounts (e.g. Skype, Xbox), select Web in Redirect URI, then type (do not copy and paste) http://localhost:53682/ and click Register. Copy and keep the Application (client) ID under the app name for later use.
  3. Under manage select Certificates & secrets, click New client secret. Enter a description (can be anything) and set Expires to 24 months. Copy and keep that secret Value for later use (you won't be able to see this value afterwards).
  4. Under manage select API permissions, click Add a permission and select Microsoft Graph then select delegated permissions.
  5. Search and select the following permissions: Files.Read, Files.ReadWrite, Files.Read.All, Files.ReadWrite.All, offline_access, User.Read and Sites.Read.All (if custom access scopes are configured, select the permissions accordingly). Once selected click Add permissions at the bottom.

Now the application is complete. Run rclone config to create or edit a OneDrive remote. Supply the app ID and password as Client ID and Secret, respectively. rclone will walk you through the remaining steps.

The access_scopes option allows you to configure the permissions requested by rclone. See Microsoft Docs for more information about the different scopes.

The Sites.Read.All permission is required if you need to search SharePoint sites when configuring the remote. However, if that permission is not assigned, you need to exclude Sites.Read.All from your access scopes or set disable_site_permission option to true in the advanced options.

Creating Client ID for OneDrive Business

The steps for OneDrive Personal may or may not work for OneDrive Business, depending on the security settings of the organization. A common error is that the publisher of the App is not verified.

You may try to verify you account, or try to limit the App to your organization only, as shown below.

  1. Make sure to create the App with your business account.
  2. Follow the steps above to create an App. However, we need a different account type here: Accounts in this organizational directory only (*** - Single tenant). Note that you can also change the account type after creating the App.
  3. Find the tenant ID of your organization.
  4. In the rclone config, set auth_url to https://login.microsoftonline.com/YOUR_TENANT_ID/oauth2/v2.0/authorize.
  5. In the rclone config, set token_url to https://login.microsoftonline.com/YOUR_TENANT_ID/oauth2/v2.0/token.

Note: If you have a special region, you may need a different host in step 4 and 5. Here are some hints.

Using OAuth Client Credential flow

OAuth Client Credential flow will allow rclone to use permissions directly associated with the Azure AD Enterprise application, rather that adopting the context of an Azure AD user account.

This flow can be enabled by following the steps below:

  1. Create the Enterprise App registration in the Azure AD portal and obtain a Client ID and Client Secret as described above.
  2. Ensure that the application has the appropriate permissions and they are assigned as Application Permissions
  3. Configure the remote, ensuring that Client ID and Client Secret are entered correctly.
  4. In the Advanced Config section, enter true for client_credentials and in the tenant section enter the tenant ID.

When it comes to choosing the type of the connection work with the client credentials flow. In particular the "onedrive" option does not work. You can use the "sharepoint" option or if that does not find the correct drive ID type it in manually with the "driveid" option.

NOTE Assigning permissions directly to the application means that anyone with the Client ID and Client Secret can access your OneDrive files. Take care to safeguard these credentials.

Modification times and hashes

OneDrive allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not.

OneDrive Personal, OneDrive for Business and Sharepoint Server support QuickXorHash.

Before rclone 1.62 the default hash for Onedrive Personal was SHA1. For rclone 1.62 and above the default for all Onedrive backends is QuickXorHash.

Starting from July 2023 SHA1 support is being phased out in Onedrive Personal in favour of QuickXorHash. If necessary the --onedrive-hash-type flag (or hash_type config option) can be used to select SHA1 during the transition period if this is important your workflow.

For all types of OneDrive you can use the --checksum flag.

--fast-list

This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details.

This must be enabled with the --onedrive-delta flag (or delta = true in the config file) as it can cause performance degradation.

It does this by using the delta listing facilities of OneDrive which returns all the files in the remote very efficiently. This is much more efficient than listing directories recursively and is Microsoft's recommended way of reading all the file information from a drive.

This can be useful with rclone mount and rclone rc vfs/refresh recursive=true) to very quickly fill the mount with information about all the files.

The API used for the recursive listing (ListR) only supports listing from the root of the drive. This will become increasingly inefficient the further away you get from the root as rclone will have to discard files outside of the directory you are using.

Some commands (like rclone lsf -R) will use ListR by default - you can turn this off with --disable ListR if you need to.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
" 0x22 ＂
* 0x2A ＊
: 0x3A ：
< 0x3C ＜
> 0x3E ＞
? 0x3F ？
\ 0x5C ＼
| 0x7C ｜

File names can also not end with the following characters. These only get replaced if they are the last character in the name:

Character Value Replacement
SP 0x20 ␠
. 0x2E ．

File names can also not begin with the following characters. These only get replaced if they are the first character in the name:

Character Value Replacement
SP 0x20 ␠
~ 0x7E ～

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Deleting files

Any files you delete with rclone will end up in the trash. Microsoft doesn't provide an API to permanently delete files, nor to empty the trash, so you will have to do that with one of Microsoft's apps or via the OneDrive website.

Standard options

Here are the Standard options specific to onedrive (Microsoft OneDrive).

--onedrive-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_ONEDRIVE_CLIENT_ID
  • Type: string
  • Required: false

--onedrive-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_ONEDRIVE_CLIENT_SECRET
  • Type: string
  • Required: false

--onedrive-region

Choose national cloud region for OneDrive.

Properties:

  • Config: region
  • Env Var: RCLONE_ONEDRIVE_REGION
  • Type: string
  • Default: "global"
  • Examples:
    • "global"
      • Microsoft Cloud Global
    • "us"
      • Microsoft Cloud for US Government
    • "de"
      • Microsoft Cloud Germany (deprecated - try global region first).
    • "cn"
      • Azure and Office 365 operated by Vnet Group in China

--onedrive-tenant

ID of the service principal's tenant. Also called its directory ID.

Set this if using - Client Credential flow

Properties:

  • Config: tenant
  • Env Var: RCLONE_ONEDRIVE_TENANT
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to onedrive (Microsoft OneDrive).

--onedrive-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_ONEDRIVE_TOKEN
  • Type: string
  • Required: false

--onedrive-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_ONEDRIVE_AUTH_URL
  • Type: string
  • Required: false

--onedrive-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_ONEDRIVE_TOKEN_URL
  • Type: string
  • Required: false

--onedrive-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_ONEDRIVE_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--onedrive-upload-cutoff

Cutoff for switching to chunked upload.

Any files larger than this will be uploaded in chunks of chunk_size.

This is disabled by default as uploading using single part uploads causes rclone to use twice the storage on Onedrive business as when rclone sets the modification time after the upload Onedrive creates a new version.

See: https://github.com/rclone/rclone/issues/1716

Properties:

  • Config: upload_cutoff
  • Env Var: RCLONE_ONEDRIVE_UPLOAD_CUTOFF
  • Type: SizeSuffix
  • Default: off

--onedrive-chunk-size

Chunk size to upload files with - must be multiple of 320k (327,680 bytes).

Above this size files will be chunked - must be multiple of 320k (327,680 bytes) and should not exceed 250M (262,144,000 bytes) else you may encounter "Microsoft.SharePoint.Client.InvalidClientQueryException: The request message is too big." Note that the chunks will be buffered into memory.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_ONEDRIVE_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 10Mi

--onedrive-drive-id

The ID of the drive to use.

Properties:

  • Config: drive_id
  • Env Var: RCLONE_ONEDRIVE_DRIVE_ID
  • Type: string
  • Required: false

--onedrive-drive-type

The type of the drive (personal | business | documentLibrary).

Properties:

  • Config: drive_type
  • Env Var: RCLONE_ONEDRIVE_DRIVE_TYPE
  • Type: string
  • Required: false

--onedrive-root-folder-id

ID of the root folder.

This isn't normally needed, but in special circumstances you might know the folder ID that you wish to access but not be able to get there through a path traversal.

Properties:

  • Config: root_folder_id
  • Env Var: RCLONE_ONEDRIVE_ROOT_FOLDER_ID
  • Type: string
  • Required: false

--onedrive-access-scopes

Set scopes to be requested by rclone.

Choose or manually enter a custom space separated list with all scopes, that rclone should request.

Properties:

  • Config: access_scopes
  • Env Var: RCLONE_ONEDRIVE_ACCESS_SCOPES
  • Type: SpaceSepList
  • Default: Files.Read Files.ReadWrite Files.Read.All Files.ReadWrite.All Sites.Read.All offline_access
  • Examples:
    • "Files.Read Files.ReadWrite Files.Read.All Files.ReadWrite.All Sites.Read.All offline_access"
      • Read and write access to all resources
    • "Files.Read Files.Read.All Sites.Read.All offline_access"
      • Read only access to all resources
    • "Files.Read Files.ReadWrite Files.Read.All Files.ReadWrite.All offline_access"
      • Read and write access to all resources, without the ability to browse SharePoint sites.
      • Same as if disable_site_permission was set to true

--onedrive-disable-site-permission

Disable the request for Sites.Read.All permission.

If set to true, you will no longer be able to search for a SharePoint site when configuring drive ID, because rclone will not request Sites.Read.All permission. Set it to true if your organization didn't assign Sites.Read.All permission to the application, and your organization disallows users to consent app permission request on their own.

Properties:

  • Config: disable_site_permission
  • Env Var: RCLONE_ONEDRIVE_DISABLE_SITE_PERMISSION
  • Type: bool
  • Default: false

--onedrive-expose-onenote-files

Set to make OneNote files show up in directory listings.

By default, rclone will hide OneNote files in directory listings because operations like "Open" and "Update" won't work on them. But this behaviour may also prevent you from deleting them. If you want to delete OneNote files or otherwise want them to show up in directory listing, set this option.

Properties:

  • Config: expose_onenote_files
  • Env Var: RCLONE_ONEDRIVE_EXPOSE_ONENOTE_FILES
  • Type: bool
  • Default: false

--onedrive-server-side-across-configs

Deprecated: use --server-side-across-configs instead.

Allow server-side operations (e.g. copy) to work across different onedrive configs.

This will work if you are copying between two OneDrive Personal drives AND the files to copy are already shared between them. Additionally, it should also function for a user who has access permissions both between Onedrive for business and SharePoint under the same tenant, and between SharePoint and another SharePoint under the same tenant. In other cases, rclone will fall back to normal copy (which will be slightly slower).

Properties:

  • Config: server_side_across_configs
  • Env Var: RCLONE_ONEDRIVE_SERVER_SIDE_ACROSS_CONFIGS
  • Type: bool
  • Default: false

--onedrive-list-chunk

Size of listing chunk.

Properties:

  • Config: list_chunk
  • Env Var: RCLONE_ONEDRIVE_LIST_CHUNK
  • Type: int
  • Default: 1000

--onedrive-no-versions

Remove all versions on modifying operations.

Onedrive for business creates versions when rclone uploads new files overwriting an existing one and when it sets the modification time.

These versions take up space out of the quota.

This flag checks for versions after file upload and setting modification time and removes all but the last version.

NB Onedrive personal can't currently delete versions so don't use this flag there.

Properties:

  • Config: no_versions
  • Env Var: RCLONE_ONEDRIVE_NO_VERSIONS
  • Type: bool
  • Default: false

--onedrive-hard-delete

Permanently delete files on removal.

Normally files will get sent to the recycle bin on deletion. Setting this flag causes them to be permanently deleted. Use with care.

OneDrive personal accounts do not support the permanentDelete API, it only applies to OneDrive for Business and SharePoint document libraries.

Properties:

  • Config: hard_delete
  • Env Var: RCLONE_ONEDRIVE_HARD_DELETE
  • Type: bool
  • Default: false

Set the scope of the links created by the link command.

Properties:

  • Config: link_scope
  • Env Var: RCLONE_ONEDRIVE_LINK_SCOPE
  • Type: string
  • Default: "anonymous"
  • Examples:
    • "anonymous"
      • Anyone with the link has access, without needing to sign in.
      • This may include people outside of your organization.
      • Anonymous link support may be disabled by an administrator.
    • "organization"
      • Anyone signed into your organization (tenant) can use the link to get access.
      • Only available in OneDrive for Business and SharePoint.

Set the type of the links created by the link command.

Properties:

  • Config: link_type
  • Env Var: RCLONE_ONEDRIVE_LINK_TYPE
  • Type: string
  • Default: "view"
  • Examples:
    • "view"
      • Creates a read-only link to the item.
    • "edit"
      • Creates a read-write link to the item.
    • "embed"
      • Creates an embeddable link to the item.

Set the password for links created by the link command.

At the time of writing this only works with OneDrive personal paid accounts.

Properties:

  • Config: link_password
  • Env Var: RCLONE_ONEDRIVE_LINK_PASSWORD
  • Type: string
  • Required: false

--onedrive-hash-type

Specify the hash in use for the backend.

This specifies the hash type in use. If set to "auto" it will use the default hash which is QuickXorHash.

Before rclone 1.62 an SHA1 hash was used by default for Onedrive Personal. For 1.62 and later the default is to use a QuickXorHash for all onedrive types. If an SHA1 hash is desired then set this option accordingly.

From July 2023 QuickXorHash will be the only available hash for both OneDrive for Business and OneDrive Personal.

This can be set to "none" to not use any hashes.

If the hash requested does not exist on the object, it will be returned as an empty string which is treated as a missing hash by rclone.

Properties:

  • Config: hash_type
  • Env Var: RCLONE_ONEDRIVE_HASH_TYPE
  • Type: string
  • Default: "auto"
  • Examples:
    • "auto"
      • Rclone chooses the best hash
    • "quickxor"
      • QuickXor
    • "sha1"
      • SHA1
    • "sha256"
      • SHA256
    • "crc32"
      • CRC32
    • "none"
      • None - don't use any hashes

--onedrive-av-override

Allows download of files the server thinks has a virus.

The onedrive/sharepoint server may check files uploaded with an Anti Virus checker. If it detects any potential viruses or malware it will block download of the file.

In this case you will see a message like this

server reports this file is infected with a virus - use --onedrive-av-override to download anyway: Infected (name of virus): 403 Forbidden:

If you are 100% sure you want to download this file anyway then use the --onedrive-av-override flag, or av_override = true in the config file.

Properties:

  • Config: av_override
  • Env Var: RCLONE_ONEDRIVE_AV_OVERRIDE
  • Type: bool
  • Default: false

--onedrive-delta

If set rclone will use delta listing to implement recursive listings.

If this flag is set the onedrive backend will advertise ListR support for recursive listings.

Setting this flag speeds up these things greatly:

rclone lsf -R onedrive:
rclone size onedrive:
rclone rc vfs/refresh recursive=true

However the delta listing API only works at the root of the drive. If you use it not at the root then it recurses from the root and discards all the data that is not under the directory you asked for. So it will be correct but may not be very efficient.

This is why this flag is not set as the default.

As a rule of thumb if nearly all of your data is under rclone's root directory (the root/directory in onedrive:root/directory) then using this flag will be be a big performance win. If your data is mostly not under the root then using this flag will be a big performance loss.

It is recommended if you are mounting your onedrive at the root (or near the root when using crypt) and using rclone rc vfs/refresh.

Properties:

  • Config: delta
  • Env Var: RCLONE_ONEDRIVE_DELTA
  • Type: bool
  • Default: false

--onedrive-metadata-permissions

Control whether permissions should be read or written in metadata.

Reading permissions metadata from files can be done quickly, but it isn't always desirable to set the permissions from the metadata.

Properties:

  • Config: metadata_permissions
  • Env Var: RCLONE_ONEDRIVE_METADATA_PERMISSIONS
  • Type: Bits
  • Default: off
  • Examples:
    • "off"
      • Do not read or write the value
    • "read"
      • Read the value only
    • "write"
      • Write the value only
    • "read,write"
      • Read and Write the value.
    • "failok"
      • If writing fails log errors only, don't fail the transfer

--onedrive-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_ONEDRIVE_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,LeftSpace,LeftTilde,RightSpace,RightPeriod,InvalidUtf8,Dot

--onedrive-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_ONEDRIVE_DESCRIPTION
  • Type: string
  • Required: false

Metadata

OneDrive supports System Metadata (not User Metadata, as of this writing) for both files and directories. Much of the metadata is read-only, and there are some differences between OneDrive Personal and Business (see table below for details).

Permissions are also supported, if --onedrive-metadata-permissions is set. The accepted values for --onedrive-metadata-permissions are "read", "write", "read,write", and "off" (the default). "write" supports adding new permissions, updating the "role" of existing permissions, and removing permissions. Updating and removing require the Permission ID to be known, so it is recommended to use "read,write" instead of "write" if you wish to update/remove permissions.

Permissions are read/written in JSON format using the same schema as the OneDrive API, which differs slightly between OneDrive Personal and Business.

Example for OneDrive Personal:

[
    {
        "id": "1234567890ABC!123",
        "grantedTo": {
            "user": {
                "id": "ryan@contoso.com"
            },
            "application": {},
            "device": {}
        },
        "invitation": {
            "email": "ryan@contoso.com"
        },
        "link": {
            "webUrl": "https://1drv.ms/t/s!1234567890ABC"
        },
        "roles": [
            "read"
        ],
        "shareId": "s!1234567890ABC"
    }
]

Example for OneDrive Business:

[
    {
        "id": "48d31887-5fad-4d73-a9f5-3c356e68a038",
        "grantedToIdentities": [
            {
                "user": {
                    "displayName": "ryan@contoso.com"
                },
                "application": {},
                "device": {}
            }
        ],
        "link": {
            "type": "view",
            "scope": "users",
            "webUrl": "https://contoso.sharepoint.com/:w:/t/design/a577ghg9hgh737613bmbjf839026561fmzhsr85ng9f3hjck2t5s"
        },
        "roles": [
            "read"
        ],
        "shareId": "u!LKj1lkdlals90j1nlkascl"
    },
    {
        "id": "5D33DD65C6932946",
        "grantedTo": {
            "user": {
                "displayName": "John Doe",
                "id": "efee1b77-fb3b-4f65-99d6-274c11914d12"
            },
            "application": {},
            "device": {}
        },
        "roles": [
            "owner"
        ],
        "shareId": "FWxc1lasfdbEAGM5fI7B67aB5ZMPDMmQ11U"
    }
]

To write permissions, pass in a "permissions" metadata key using this same format. The --metadata-mapper tool can be very helpful for this.

When adding permissions, an email address can be provided in the User.ID or DisplayName properties of grantedTo or grantedToIdentities. Alternatively, an ObjectID can be provided in User.ID. At least one valid recipient must be provided in order to add a permission for a user. Creating a Public Link is also supported, if Link.Scope is set to "anonymous".

Example request to add a "read" permission with --metadata-mapper:

{
    "Metadata": {
        "permissions": "[{\"grantedToIdentities\":[{\"user\":{\"id\":\"ryan@contoso.com\"}}],\"roles\":[\"read\"]}]"
    }
}

Note that adding a permission can fail if a conflicting permission already exists for the file/folder.

To update an existing permission, include both the Permission ID and the new roles to be assigned. roles is the only property that can be changed.

To remove permissions, pass in a blob containing only the permissions you wish to keep (which can be empty, to remove all.) Note that the owner role will be ignored, as it cannot be removed.

Note that both reading and writing permissions requires extra API calls, so if you don't need to read or write permissions it is recommended to omit --onedrive-metadata-permissions.

Metadata and permissions are supported for Folders (directories) as well as Files. Note that setting the mtime or btime on a Folder requires one extra API call on OneDrive Business only.

OneDrive does not currently support User Metadata. When writing metadata, only writeable system properties will be written -- any read-only or unrecognized keys passed in will be ignored.

TIP: to see the metadata and permissions for any file or folder, run:

rclone lsjson remote:path --stat -M --onedrive-metadata-permissions read

Here are the possible system metadata items for the onedrive backend.

Name Help Type Example Read Only
btime Time of file birth (creation) with S accuracy (mS for OneDrive Personal). RFC 3339 2006-01-02T15:04:05Z N
content-type The MIME type of the file. string text/plain Y
created-by-display-name Display name of the user that created the item. string John Doe Y
created-by-id ID of the user that created the item. string 48d31887-5fad-4d73-a9f5-3c356e68a038 Y
description A short description of the file. Max 1024 characters. Only supported for OneDrive Personal. string Contract for signing N
id The unique identifier of the item within OneDrive. string 01BYE5RZ6QN3ZWBTUFOFD3GSPGOHDJD36K Y
last-modified-by-display-name Display name of the user that last modified the item. string John Doe Y
last-modified-by-id ID of the user that last modified the item. string 48d31887-5fad-4d73-a9f5-3c356e68a038 Y
malware-detected Whether OneDrive has detected that the item contains malware. boolean true Y
mtime Time of last modification with S accuracy (mS for OneDrive Personal). RFC 3339 2006-01-02T15:04:05Z N
package-type If present, indicates that this item is a package instead of a folder or file. Packages are treated like files in some contexts and folders in others. string oneNote Y
permissions Permissions in a JSON dump of OneDrive format. Enable with --onedrive-metadata-permissions. Properties: id, grantedTo, grantedToIdentities, invitation, inheritedFrom, link, roles, shareId JSON {} N
shared-by-id ID of the user that shared the item (if shared). string 48d31887-5fad-4d73-a9f5-3c356e68a038 Y
shared-owner-id ID of the owner of the shared item (if shared). string 48d31887-5fad-4d73-a9f5-3c356e68a038 Y
shared-scope If shared, indicates the scope of how the item is shared: anonymous, organization, or users. string users Y
shared-time Time when the item was shared, with S accuracy (mS for OneDrive Personal). RFC 3339 2006-01-02T15:04:05Z Y
utime Time of upload with S accuracy (mS for OneDrive Personal). RFC 3339 2006-01-02T15:04:05Z Y

See the metadata docs for more info.

Impersonate other users as Admin

Unlike Google Drive and impersonating any domain user via service accounts, OneDrive requires you to authenticate as an admin account, and manually setup a remote per user you wish to impersonate.

  1. In Microsoft 365 Admin Center, open each user you need to "impersonate" and go to the OneDrive section. There is a heading called "Get access to files", you need to click to create the link, this creates the link of the format https://{tenant}-my.sharepoint.com/personal/{user_name_domain_tld}/ but also changes the permissions so you your admin user has access.
  2. Then in powershell run the following commands:
Install-Module Microsoft.Graph -Scope CurrentUser -Repository PSGallery -Force
Import-Module Microsoft.Graph.Files
Connect-MgGraph -Scopes "Files.ReadWrite.All"
# Follow the steps to allow access to your admin user
# Then run this for each user you want to impersonate to get the Drive ID
Get-MgUserDefaultDrive -UserId '{emailaddress}'
# This will give you output of the format:
# Name     Id                                                                 DriveType CreatedDateTime
# ----     --                                                                 --------- ---------------
# OneDrive b!XYZ123                                                           business  14/10/2023 1:00:58 pm
  1. Then in rclone add a onedrive remote type, and use the Type in driveID with the DriveID you got in the previous step. One remote per user. It will then confirm the drive ID, and hopefully give you a message of Found drive "root" of type "business" and then include the URL of the format https://{tenant}-my.sharepoint.com/personal/{user_name_domain_tld}/Documents

Limitations

If you don't use rclone for 90 days the refresh token will expire. This will result in authorization problems. This is easy to fix by running the rclone config reconnect remote: command to get a new token and refresh token.

Naming

Note that OneDrive is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc".

There are quite a few characters that can't be in OneDrive file names. These can't occur on Windows platforms, but on non-Windows platforms they are common. Rclone will map these names to and from an identical looking unicode equivalent. For example if a file has a ? in it will be mapped to ？ instead.

File sizes

The largest allowed file size is 250 GiB for both OneDrive Personal and OneDrive for Business (Updated 13 Jan 2021).

Path length

The entire path, including the file name, must contain fewer than 400 characters for OneDrive, OneDrive for Business and SharePoint Online. If you are encrypting file and folder names with rclone, you may want to pay attention to this limitation because the encrypted names are typically longer than the original ones.

Number of files

OneDrive seems to be OK with at least 50,000 files in a folder, but at 100,000 rclone will get errors listing the directory like couldn’t list files: UnknownError:. See #2707 for more info.

An official document about the limitations for different types of OneDrive can be found here.

Versions

Every change in a file OneDrive causes the service to create a new version of the file. This counts against a users quota. For example changing the modification time of a file creates a second version, so the file apparently uses twice the space.

For example the copy command is affected by this as rclone copies the file and then afterwards sets the modification time to match the source file which uses another version.

You can use the rclone cleanup command (see below) to remove all old versions.

Or you can set the no_versions parameter to true and rclone will remove versions after operations which create new versions. This takes extra transactions so only enable it if you need it.

Note At the time of writing Onedrive Personal creates versions (but not for setting the modification time) but the API for removing them returns "API not found" so cleanup and no_versions should not be used on Onedrive Personal.

Disabling versioning

Starting October 2018, users will no longer be able to disable versioning by default. This is because Microsoft has brought an update to the mechanism. To change this new default setting, a PowerShell command is required to be run by a SharePoint admin. If you are an admin, you can run these commands in PowerShell to change that setting:

  1. Install-Module -Name Microsoft.Online.SharePoint.PowerShell (in case you haven't installed this already)
  2. Import-Module Microsoft.Online.SharePoint.PowerShell -DisableNameChecking
  3. Connect-SPOService -Url https://YOURSITE-admin.sharepoint.com -Credential YOU@YOURSITE.COM (replacing YOURSITE, YOU, YOURSITE.COM with the actual values; this will prompt for your credentials)
  4. Set-SPOTenant -EnableMinimumVersionRequirement $False
  5. Disconnect-SPOService (to disconnect from the server)

Below are the steps for normal users to disable versioning. If you don't see the "No Versioning" option, make sure the above requirements are met.

User Weropol has found a method to disable versioning on OneDrive

  1. Open the settings menu by clicking on the gear symbol at the top of the OneDrive Business page.
  2. Click Site settings.
  3. Once on the Site settings page, navigate to Site Administration > Site libraries and lists.
  4. Click Customize "Documents".
  5. Click General Settings > Versioning Settings.
  6. Under Document Version History select the option No versioning. Note: This will disable the creation of new file versions, but will not remove any previous versions. Your documents are safe.
  7. Apply the changes by clicking OK.
  8. Use rclone to upload or modify files. (I also use the --no-update-modtime flag)
  9. Restore the versioning settings after using rclone. (Optional)

Cleanup

OneDrive supports rclone cleanup which causes rclone to look through every file under the path supplied and delete all version but the current version. Because this involves traversing all the files, then querying each file for versions it can be quite slow. Rclone does --checkers tests in parallel. The command also supports --interactive/i or --dry-run which is a great way to see what it would do.

rclone cleanup --interactive remote:path/subdir # interactively remove all old version for path/subdir
rclone cleanup remote:path/subdir               # unconditionally remove all old version for path/subdir

NB Onedrive personal can't currently delete versions

Troubleshooting

Excessive throttling or blocked on SharePoint

If you experience excessive throttling or is being blocked on SharePoint then it may help to set the user agent explicitly with a flag like this: --user-agent "ISV|rclone.org|rclone/v1.55.1"

The specific details can be found in the Microsoft document: Avoid getting throttled or blocked in SharePoint Online

Unexpected file size/hash differences on Sharepoint

It is a known issue that Sharepoint (not OneDrive or OneDrive for Business) silently modifies uploaded files, mainly Office files (.docx, .xlsx, etc.), causing file size and hash checks to fail. There are also other situations that will cause OneDrive to report inconsistent file sizes. To use rclone with such affected files on Sharepoint, you may disable these checks with the following command line arguments:

--ignore-checksum --ignore-size

Alternatively, if you have write access to the OneDrive files, it may be possible to fix this problem for certain files, by attempting the steps below. Open the web interface for OneDrive and find the affected files (which will be in the error messages/log for rclone). Simply click on each of these files, causing OneDrive to open them on the web. This will cause each file to be converted in place to a format that is functionally equivalent but which will no longer trigger the size discrepancy. Once all problematic files are converted you will no longer need the ignore options above.

Replacing/deleting existing files on Sharepoint gets "item not found"

It is a known issue that Sharepoint (not OneDrive or OneDrive for Business) may return "item not found" errors when users try to replace or delete uploaded files; this seems to mainly affect Office files (.docx, .xlsx, etc.) and web files (.html, .aspx, etc.). As a workaround, you may use the --backup-dir <BACKUP_DIR> command line argument so rclone moves the files to be replaced/deleted into a given backup directory (instead of directly replacing/deleting them). For example, to instruct rclone to move the files into the directory rclone-backup-dir on backend mysharepoint, you may use:

--backup-dir mysharepoint:rclone-backup-dir

access_denied (AADSTS65005)

Error: access_denied
Code: AADSTS65005
Description: Using application 'rclone' is currently not supported for your organization [YOUR_ORGANIZATION] because it is in an unmanaged state. An administrator needs to claim ownership of the company by DNS validation of [YOUR_ORGANIZATION] before the application rclone can be provisioned.

This means that rclone can't use the OneDrive for Business API with your account. You can't do much about it, maybe write an email to your admins.

However, there are other ways to interact with your OneDrive account. Have a look at the WebDAV backend: https://rclone.org/webdav/#sharepoint

invalid_grant (AADSTS50076)

Error: invalid_grant
Code: AADSTS50076
Description: Due to a configuration change made by your administrator, or because you moved to a new location, you must use multi-factor authentication to access '...'.

If you see the error above after enabling multi-factor authentication for your account, you can fix it by refreshing your OAuth refresh token. To do that, run rclone config, and choose to edit your OneDrive backend. Then, you don't need to actually make any changes until you reach this question: Already have a token - refresh?. For this question, answer y and go through the process to refresh your token, just like the first time the backend is configured. After this, rclone should work again for this backend.

On Sharepoint and OneDrive for Business, rclone link may return an "Invalid request" error. A possible cause is that the organisation admin didn't allow public links to be made for the organisation/sharepoint library. To fix the permissions as an admin, take a look at the docs: 1, 2.

Can not access Shared with me files

Shared with me files is not supported by rclone currently, but there is a workaround:

  1. Visit https://onedrive.live.com
  2. Right click a item in Shared, then click Add shortcut to My files in the context make_shortcut
  3. The shortcut will appear in My files, you can access it with rclone, it behaves like a normal folder/file. in_my_files rclone_mount

Live Photos uploaded from iOS (small video clips in .heic files)

The iOS OneDrive app introduced upload and storage of Live Photos in 2020. The usage and download of these uploaded Live Photos is unfortunately still work-in-progress and this introduces several issues when copying, synchronising and mounting – both in rclone and in the native OneDrive client on Windows.

The root cause can easily be seen if you locate one of your Live Photos in the OneDrive web interface. Then download the photo from the web interface. You will then see that the size of downloaded .heic file is smaller than the size displayed in the web interface. The downloaded file is smaller because it only contains a single frame (still photo) extracted from the Live Photo (movie) stored in OneDrive.

The different sizes will cause rclone copy/sync to repeatedly recopy unmodified photos something like this:

DEBUG : 20230203_123826234_iOS.heic: Sizes differ (src 4470314 vs dst 1298667)
DEBUG : 20230203_123826234_iOS.heic: sha1 = fc2edde7863b7a7c93ca6771498ac797f8460750 OK
INFO  : 20230203_123826234_iOS.heic: Copied (replaced existing)

These recopies can be worked around by adding --ignore-size. Please note that this workaround only syncs the still-picture not the movie clip, and relies on modification dates being correctly updated on all files in all situations.

The different sizes will also cause rclone check to report size errors something like this:

ERROR : 20230203_123826234_iOS.heic: sizes differ

These check errors can be suppressed by adding --ignore-size.

The different sizes will also cause rclone mount to fail downloading with an error something like this:

ERROR : 20230203_123826234_iOS.heic: ReadFileHandle.Read error: low level retry 1/10: unexpected EOF

or like this when using --cache-mode=full:

INFO  : 20230203_123826234_iOS.heic: vfs cache: downloader: error count now 1: vfs reader: failed to write to cache file: 416 Requested Range Not Satisfiable:
ERROR : 20230203_123826234_iOS.heic: vfs cache: failed to download: vfs reader: failed to write to cache file: 416 Requested Range Not Satisfiable:

OpenDrive

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Configuration

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

n) New remote
d) Delete remote
q) Quit config
e/n/d/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / OpenDrive
   \ "opendrive"
[snip]
Storage> opendrive
Username
username>
Password
y) Yes type in my own password
g) Generate random password
y/g> y
Enter the password:
password:
Confirm the password:
password:
Configuration complete.
Options:
- type: opendrive
- username:
- password: *** ENCRYPTED ***
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

List directories in top level of your OpenDrive

rclone lsd remote:

List all the files in your OpenDrive

rclone ls remote:

To copy a local directory to an OpenDrive directory called backup

rclone copy /home/source remote:backup

Modification times and hashes

OpenDrive allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not.

The MD5 hash algorithm is supported.

Restricted filename characters

Character Value Replacement
NUL 0x00 ␀
/ 0x2F ／
" 0x22 ＂
* 0x2A ＊
: 0x3A ：
< 0x3C ＜
> 0x3E ＞
? 0x3F ？
\ 0x5C ＼
| 0x7C ｜

File names can also not begin or end with the following characters. These only get replaced if they are the first or last character in the name:

Character Value Replacement
SP 0x20 ␠
HT 0x09 ␉
LF 0x0A ␊
VT 0x0B ␋
CR 0x0D ␍

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Standard options

Here are the Standard options specific to opendrive (OpenDrive).

--opendrive-username

Username.

Properties:

  • Config: username
  • Env Var: RCLONE_OPENDRIVE_USERNAME
  • Type: string
  • Required: true

--opendrive-password

Password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: password
  • Env Var: RCLONE_OPENDRIVE_PASSWORD
  • Type: string
  • Required: true

Advanced options

Here are the Advanced options specific to opendrive (OpenDrive).

--opendrive-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_OPENDRIVE_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,LeftSpace,LeftCrLfHtVt,RightSpace,RightCrLfHtVt,InvalidUtf8,Dot

--opendrive-chunk-size

Files will be uploaded in chunks this size.

Note that these chunks are buffered in memory so increasing them will increase memory use.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_OPENDRIVE_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 10Mi

--opendrive-access

Files and folders will be uploaded with this access permission (default private)

Properties:

  • Config: access
  • Env Var: RCLONE_OPENDRIVE_ACCESS
  • Type: string
  • Default: "private"
  • Examples:
    • "private"
      • The file or folder access can be granted in a way that will allow select users to view, read or write what is absolutely essential for them.
    • "public"
      • The file or folder can be downloaded by anyone from a web browser. The link can be shared in any way,
    • "hidden"
      • The file or folder can be accessed has the same restrictions as Public if the user knows the URL of the file or folder link in order to access the contents

--opendrive-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_OPENDRIVE_DESCRIPTION
  • Type: string
  • Required: false

Limitations

Note that OpenDrive is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc".

There are quite a few characters that can't be in OpenDrive file names. These can't occur on Windows platforms, but on non-Windows platforms they are common. Rclone will map these names to and from an identical looking unicode equivalent. For example if a file has a ? in it will be mapped to ？ instead.

rclone about is not supported by the OpenDrive backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

Oracle Object Storage

Paths are specified as remote:bucket (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:bucket/path/to/dir.

Sample command to transfer local artifacts to remote:bucket in oracle object storage:

rclone -vvv --progress --stats-one-line --max-stats-groups 10 --log-format date,time,UTC,longfile --fast-list --buffer-size 256Mi --oos-no-check-bucket --oos-upload-cutoff 10Mi --multi-thread-cutoff 16Mi --multi-thread-streams 3000 --transfers 3000 --checkers 64 --retries 2 --oos-chunk-size 10Mi --oos-upload-concurrency 10000 --oos-attempt-resume-upload --oos-leave-parts-on-error sync ./artifacts remote:bucket -vv

Configuration

Here is an example of making an oracle object storage configuration. rclone config walks you through it.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> n

Enter name for new remote.
name> remote

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
[snip]
XX / Oracle Cloud Infrastructure Object Storage
   \ (oracleobjectstorage)
Storage> oracleobjectstorage

Option provider.
Choose your Auth Provider
Choose a number from below, or type in your own string value.
Press Enter for the default (env_auth).
 1 / automatically pickup the credentials from runtime(env), first one to provide auth wins
   \ (env_auth)
   / use an OCI user and an API key for authentication.
 2 | you’ll need to put in a config file your tenancy OCID, user OCID, region, the path, fingerprint to an API key.
   | https://docs.oracle.com/en-us/iaas/Content/API/Concepts/sdkconfig.htm
   \ (user_principal_auth)
   / use instance principals to authorize an instance to make API calls.
 3 | each instance has its own identity, and authenticates using the certificates that are read from instance metadata.
   | https://docs.oracle.com/en-us/iaas/Content/Identity/Tasks/callingservicesfrominstances.htm
   \ (instance_principal_auth)
   / use workload identity to grant Kubernetes pods policy-driven access to Oracle Cloud
 4 | Infrastructure (OCI) resources using OCI Identity and Access Management (IAM).
   | https://docs.oracle.com/en-us/iaas/Content/ContEng/Tasks/contenggrantingworkloadaccesstoresources.htm
   \ (workload_identity_auth)
 5 / use resource principals to make API calls
   \ (resource_principal_auth)
 6 / no credentials needed, this is typically for reading public buckets
   \ (no_auth)
provider> 2

Option namespace.
Object storage namespace
Enter a value.
namespace> idbamagbg734

Option compartment.
Object storage compartment OCID
Enter a value.
compartment> ocid1.compartment.oc1..aaaaaaaapufkxc7ame3sthry5i7ujrwfc7ejnthhu6bhanm5oqfjpyasjkba

Option region.
Object storage Region
Enter a value.
region> us-ashburn-1

Option endpoint.
Endpoint for Object storage API.
Leave blank to use the default endpoint for the region.
Enter a value. Press Enter to leave empty.
endpoint> 

Option config_file.
Full Path to OCI config file
Choose a number from below, or type in your own string value.
Press Enter for the default (~/.oci/config).
 1 / oci configuration file location
   \ (~/.oci/config)
config_file> /etc/oci/dev.conf

Option config_profile.
Profile name inside OCI config file
Choose a number from below, or type in your own string value.
Press Enter for the default (Default).
 1 / Use the default profile
   \ (Default)
config_profile> Test

Edit advanced config?
y) Yes
n) No (default)
y/n> n

Configuration complete.
Options:
- type: oracleobjectstorage
- namespace: idbamagbg734
- compartment: ocid1.compartment.oc1..aaaaaaaapufkxc7ame3sthry5i7ujrwfc7ejnthhu6bhanm5oqfjpyasjkba
- region: us-ashburn-1
- provider: user_principal_auth
- config_file: /etc/oci/dev.conf
- config_profile: Test
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

See all buckets

rclone lsd remote:

Create a new bucket

rclone mkdir remote:bucket

List the contents of a bucket

rclone ls remote:bucket
rclone ls remote:bucket --max-depth 1

Authentication Providers

OCI has various authentication methods. To learn more about authentication methods please refer oci authentication methods These choices can be specified in the rclone config file.

Rclone supports the following OCI authentication provider.

User Principal
Instance Principal
Resource Principal
Workload Identity
No authentication

User Principal

Sample rclone config file for Authentication Provider User Principal:

[oos]
type = oracleobjectstorage
namespace = id<redacted>34
compartment = ocid1.compartment.oc1..aa<redacted>ba
region = us-ashburn-1
provider = user_principal_auth
config_file = /home/opc/.oci/config
config_profile = Default

Advantages: - One can use this method from any server within OCI or on-premises or from other cloud provider.

Considerations: - you need to configure user’s privileges / policy to allow access to object storage - Overhead of managing users and keys. - If the user is deleted, the config file will no longer work and may cause automation regressions that use the user's credentials.

Instance Principal

An OCI compute instance can be authorized to use rclone by using it's identity and certificates as an instance principal. With this approach no credentials have to be stored and managed.

Sample rclone configuration file for Authentication Provider Instance Principal:

[opc@rclone ~]$ cat ~/.config/rclone/rclone.conf
[oos]
type = oracleobjectstorage
namespace = id<redacted>fn
compartment = ocid1.compartment.oc1..aa<redacted>k7a
region = us-ashburn-1
provider = instance_principal_auth

Advantages:

  • With instance principals, you don't need to configure user credentials and transfer/ save it to disk in your compute instances or rotate the credentials.
  • You don’t need to deal with users and keys.
  • Greatly helps in automation as you don't have to manage access keys, user private keys, storing them in vault, using kms etc.

Considerations:

  • You need to configure a dynamic group having this instance as member and add policy to read object storage to that dynamic group.
  • Everyone who has access to this machine can execute the CLI commands.
  • It is applicable for oci compute instances only. It cannot be used on external instance or resources.

Resource Principal

Resource principal auth is very similar to instance principal auth but used for resources that are not compute instances such as serverless functions. To use resource principal ensure Rclone process is started with these environment variables set in its process.

export OCI_RESOURCE_PRINCIPAL_VERSION=2.2
export OCI_RESOURCE_PRINCIPAL_REGION=us-ashburn-1
export OCI_RESOURCE_PRINCIPAL_PRIVATE_PEM=/usr/share/model-server/key.pem
export OCI_RESOURCE_PRINCIPAL_RPST=/usr/share/model-server/security_token

Sample rclone configuration file for Authentication Provider Resource Principal:

[oos]
type = oracleobjectstorage
namespace = id<redacted>34
compartment = ocid1.compartment.oc1..aa<redacted>ba
region = us-ashburn-1
provider = resource_principal_auth

Workload Identity

Workload Identity auth may be used when running Rclone from Kubernetes pod on a Container Engine for Kubernetes (OKE) cluster. For more details on configuring Workload Identity, see Granting Workloads Access to OCI Resources. To use workload identity, ensure Rclone is started with these environment variables set in its process.

export OCI_RESOURCE_PRINCIPAL_VERSION=2.2
export OCI_RESOURCE_PRINCIPAL_REGION=us-ashburn-1

No authentication

Public buckets do not require any authentication mechanism to read objects. Sample rclone configuration file for No authentication:

[oos]
type = oracleobjectstorage
namespace = id<redacted>34
compartment = ocid1.compartment.oc1..aa<redacted>ba
region = us-ashburn-1
provider = no_auth

Modification times and hashes

The modification time is stored as metadata on the object as opc-meta-mtime as floating point since the epoch, accurate to 1 ns.

If the modification time needs to be updated rclone will attempt to perform a server side copy to update the modification if the object can be copied in a single part. In the case the object is larger than 5Gb, the object will be uploaded rather than copied.

Note that reading this from the object takes an additional HEAD request as the metadata isn't returned in object listings.

The MD5 hash algorithm is supported.

Multipart uploads

rclone supports multipart uploads with OOS which means that it can upload files bigger than 5 GiB.

Note that files uploaded both with multipart upload and through crypt remotes do not have MD5 sums.

rclone switches from single part uploads to multipart uploads at the point specified by --oos-upload-cutoff. This can be a maximum of 5 GiB and a minimum of 0 (ie always upload multipart files).

The chunk sizes used in the multipart upload are specified by --oos-chunk-size and the number of chunks uploaded concurrently is specified by --oos-upload-concurrency.

Multipart uploads will use --transfers * --oos-upload-concurrency * --oos-chunk-size extra memory. Single part uploads to not use extra memory.

Single part transfers can be faster than multipart transfers or slower depending on your latency from oos - the more latency, the more likely single part transfers will be faster.

Increasing --oos-upload-concurrency will increase throughput (8 would be a sensible value) and increasing --oos-chunk-size also increases throughput (16M would be sensible). Increasing either of these will use more memory. The default values are high enough to gain most of the possible performance without using too much memory.

Standard options

Here are the Standard options specific to oracleobjectstorage (Oracle Cloud Infrastructure Object Storage).

--oos-provider

Choose your Auth Provider

Properties:

  • Config: provider
  • Env Var: RCLONE_OOS_PROVIDER
  • Type: string
  • Default: "env_auth"
  • Examples:
    • "env_auth"
      • automatically pickup the credentials from runtime(env), first one to provide auth wins
    • "user_principal_auth"
      • use an OCI user and an API key for authentication.
      • you’ll need to put in a config file your tenancy OCID, user OCID, region, the path, fingerprint to an API key.
      • https://docs.oracle.com/en-us/iaas/Content/API/Concepts/sdkconfig.htm
    • "instance_principal_auth"
      • use instance principals to authorize an instance to make API calls.
      • each instance has its own identity, and authenticates using the certificates that are read from instance metadata.
      • https://docs.oracle.com/en-us/iaas/Content/Identity/Tasks/callingservicesfrominstances.htm
    • "workload_identity_auth"
      • use workload identity to grant OCI Container Engine for Kubernetes workloads policy-driven access to OCI resources using OCI Identity and Access Management (IAM).
      • https://docs.oracle.com/en-us/iaas/Content/ContEng/Tasks/contenggrantingworkloadaccesstoresources.htm
    • "resource_principal_auth"
      • use resource principals to make API calls
    • "no_auth"
      • no credentials needed, this is typically for reading public buckets

--oos-namespace

Object storage namespace

Properties:

  • Config: namespace
  • Env Var: RCLONE_OOS_NAMESPACE
  • Type: string
  • Required: true

--oos-compartment

Specify compartment OCID, if you need to list buckets.

List objects works without compartment OCID.

Properties:

  • Config: compartment
  • Env Var: RCLONE_OOS_COMPARTMENT
  • Provider: !no_auth
  • Type: string
  • Required: false

--oos-region

Object storage Region

Properties:

  • Config: region
  • Env Var: RCLONE_OOS_REGION
  • Type: string
  • Required: true

--oos-endpoint

Endpoint for Object storage API.

Leave blank to use the default endpoint for the region.

Properties:

  • Config: endpoint
  • Env Var: RCLONE_OOS_ENDPOINT
  • Type: string
  • Required: false

--oos-config-file

Path to OCI config file

Properties:

  • Config: config_file
  • Env Var: RCLONE_OOS_CONFIG_FILE
  • Provider: user_principal_auth
  • Type: string
  • Default: "~/.oci/config"
  • Examples:
    • "~/.oci/config"
      • oci configuration file location

--oos-config-profile

Profile name inside the oci config file

Properties:

  • Config: config_profile
  • Env Var: RCLONE_OOS_CONFIG_PROFILE
  • Provider: user_principal_auth
  • Type: string
  • Default: "Default"
  • Examples:
    • "Default"
      • Use the default profile

Advanced options

Here are the Advanced options specific to oracleobjectstorage (Oracle Cloud Infrastructure Object Storage).

--oos-storage-tier

The storage class to use when storing new objects in storage. https://docs.oracle.com/en-us/iaas/Content/Object/Concepts/understandingstoragetiers.htm

Properties:

  • Config: storage_tier
  • Env Var: RCLONE_OOS_STORAGE_TIER
  • Type: string
  • Default: "Standard"
  • Examples:
    • "Standard"
      • Standard storage tier, this is the default tier
    • "InfrequentAccess"
      • InfrequentAccess storage tier
    • "Archive"
      • Archive storage tier

--oos-upload-cutoff

Cutoff for switching to chunked upload.

Any files larger than this will be uploaded in chunks of chunk_size. The minimum is 0 and the maximum is 5 GiB.

Properties:

  • Config: upload_cutoff
  • Env Var: RCLONE_OOS_UPLOAD_CUTOFF
  • Type: SizeSuffix
  • Default: 200Mi

--oos-chunk-size

Chunk size to use for uploading.

When uploading files larger than upload_cutoff or files with unknown size (e.g. from "rclone rcat" or uploaded with "rclone mount" they will be uploaded as multipart uploads using this chunk size.

Note that "upload_concurrency" chunks of this size are buffered in memory per transfer.

If you are transferring large files over high-speed links and you have enough memory, then increasing this will speed up the transfers.

Rclone will automatically increase the chunk size when uploading a large file of known size to stay below the 10,000 chunks limit.

Files of unknown size are uploaded with the configured chunk_size. Since the default chunk size is 5 MiB and there can be at most 10,000 chunks, this means that by default the maximum size of a file you can stream upload is 48 GiB. If you wish to stream upload larger files then you will need to increase chunk_size.

Increasing the chunk size decreases the accuracy of the progress statistics displayed with "-P" flag.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_OOS_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 5Mi

--oos-max-upload-parts

Maximum number of parts in a multipart upload.

This option defines the maximum number of multipart chunks to use when doing a multipart upload.

OCI has max parts limit of 10,000 chunks.

Rclone will automatically increase the chunk size when uploading a large file of a known size to stay below this number of chunks limit.

Properties:

  • Config: max_upload_parts
  • Env Var: RCLONE_OOS_MAX_UPLOAD_PARTS
  • Type: int
  • Default: 10000

--oos-upload-concurrency

Concurrency for multipart uploads.

This is the number of chunks of the same file that are uploaded concurrently.

If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers.

Properties:

  • Config: upload_concurrency
  • Env Var: RCLONE_OOS_UPLOAD_CONCURRENCY
  • Type: int
  • Default: 10

--oos-copy-cutoff

Cutoff for switching to multipart copy.

Any files larger than this that need to be server-side copied will be copied in chunks of this size.

The minimum is 0 and the maximum is 5 GiB.

Properties:

  • Config: copy_cutoff
  • Env Var: RCLONE_OOS_COPY_CUTOFF
  • Type: SizeSuffix
  • Default: 4.656Gi

--oos-copy-timeout

Timeout for copy.

Copy is an asynchronous operation, specify timeout to wait for copy to succeed

Properties:

  • Config: copy_timeout
  • Env Var: RCLONE_OOS_COPY_TIMEOUT
  • Type: Duration
  • Default: 1m0s

--oos-disable-checksum

Don't store MD5 checksum with object metadata.

Normally rclone will calculate the MD5 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading.

Properties:

  • Config: disable_checksum
  • Env Var: RCLONE_OOS_DISABLE_CHECKSUM
  • Type: bool
  • Default: false

--oos-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_OOS_ENCODING
  • Type: Encoding
  • Default: Slash,InvalidUtf8,Dot

--oos-leave-parts-on-error

If true avoid calling abort upload on a failure, leaving all successfully uploaded parts for manual recovery.

It should be set to true for resuming uploads across different sessions.

WARNING: Storing parts of an incomplete multipart upload counts towards space usage on object storage and will add additional costs if not cleaned up.

Properties:

  • Config: leave_parts_on_error
  • Env Var: RCLONE_OOS_LEAVE_PARTS_ON_ERROR
  • Type: bool
  • Default: false

--oos-attempt-resume-upload

If true attempt to resume previously started multipart upload for the object. This will be helpful to speed up multipart transfers by resuming uploads from past session.

WARNING: If chunk size differs in resumed session from past incomplete session, then the resumed multipart upload is aborted and a new multipart upload is started with the new chunk size.

The flag leave_parts_on_error must be true to resume and optimize to skip parts that were already uploaded successfully.

Properties:

  • Config: attempt_resume_upload
  • Env Var: RCLONE_OOS_ATTEMPT_RESUME_UPLOAD
  • Type: bool
  • Default: false

--oos-no-check-bucket

If set, don't attempt to check the bucket exists or create it.

This can be useful when trying to minimise the number of transactions rclone does if you know the bucket exists already.

It can also be needed if the user you are using does not have bucket creation permissions.

Properties:

  • Config: no_check_bucket
  • Env Var: RCLONE_OOS_NO_CHECK_BUCKET
  • Type: bool
  • Default: false

--oos-sse-customer-key-file

To use SSE-C, a file containing the base64-encoded string of the AES-256 encryption key associated with the object. Please note only one of sse_customer_key_file|sse_customer_key|sse_kms_key_id is needed.'

Properties:

  • Config: sse_customer_key_file
  • Env Var: RCLONE_OOS_SSE_CUSTOMER_KEY_FILE
  • Type: string
  • Required: false
  • Examples:
    • ""
      • None

--oos-sse-customer-key

To use SSE-C, the optional header that specifies the base64-encoded 256-bit encryption key to use to encrypt or decrypt the data. Please note only one of sse_customer_key_file|sse_customer_key|sse_kms_key_id is needed. For more information, see Using Your Own Keys for Server-Side Encryption (https://docs.cloud.oracle.com/Content/Object/Tasks/usingyourencryptionkeys.htm)

Properties:

  • Config: sse_customer_key
  • Env Var: RCLONE_OOS_SSE_CUSTOMER_KEY
  • Type: string
  • Required: false
  • Examples:
    • ""
      • None

--oos-sse-customer-key-sha256

If using SSE-C, The optional header that specifies the base64-encoded SHA256 hash of the encryption key. This value is used to check the integrity of the encryption key. see Using Your Own Keys for Server-Side Encryption (https://docs.cloud.oracle.com/Content/Object/Tasks/usingyourencryptionkeys.htm).

Properties:

  • Config: sse_customer_key_sha256
  • Env Var: RCLONE_OOS_SSE_CUSTOMER_KEY_SHA256
  • Type: string
  • Required: false
  • Examples:
    • ""
      • None

--oos-sse-kms-key-id

if using your own master key in vault, this header specifies the OCID (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of a master encryption key used to call the Key Management service to generate a data encryption key or to encrypt or decrypt a data encryption key. Please note only one of sse_customer_key_file|sse_customer_key|sse_kms_key_id is needed.

Properties:

  • Config: sse_kms_key_id
  • Env Var: RCLONE_OOS_SSE_KMS_KEY_ID
  • Type: string
  • Required: false
  • Examples:
    • ""
      • None

--oos-sse-customer-algorithm

If using SSE-C, the optional header that specifies "AES256" as the encryption algorithm. Object Storage supports "AES256" as the encryption algorithm. For more information, see Using Your Own Keys for Server-Side Encryption (https://docs.cloud.oracle.com/Content/Object/Tasks/usingyourencryptionkeys.htm).

Properties:

  • Config: sse_customer_algorithm
  • Env Var: RCLONE_OOS_SSE_CUSTOMER_ALGORITHM
  • Type: string
  • Required: false
  • Examples:
    • ""
      • None
    • "AES256"
      • AES256

--oos-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_OOS_DESCRIPTION
  • Type: string
  • Required: false

Metadata

User metadata is stored as opc-meta- keys.

Here are the possible system metadata items for the oracleobjectstorage backend.

Name Help Type Example Read Only
opc-meta-atime Time of last access ISO 8601 2025-06-30T22:27:43-04:00 N
opc-meta-btime Time of file birth (creation) ISO 8601 2025-06-30T22:27:43-04:00 N
opc-meta-gid Group ID of owner decimal number 500 N
opc-meta-mode File type and mode octal, unix style 0100664 N
opc-meta-mtime Time of last modification ISO 8601 2025-06-30T22:27:43-04:00 N
opc-meta-uid User ID of owner decimal number 500 N

See the metadata docs for more info.

Backend commands

Here are the commands specific to the oracleobjectstorage backend.

Run them with

rclone backend COMMAND remote:

The help below will explain what arguments each command takes.

See the backend command for more info on how to pass options and arguments.

These can be run on a running backend using the rc command backend/command.

rename

change the name of an object

rclone backend rename remote: [options] [<arguments>+]

This command can be used to rename a object.

Usage Examples:

rclone backend rename oos:bucket relative-object-path-under-bucket object-new-name

list-multipart-uploads

List the unfinished multipart uploads

rclone backend list-multipart-uploads remote: [options] [<arguments>+]

This command lists the unfinished multipart uploads in JSON format.

rclone backend list-multipart-uploads oos:bucket/path/to/object

It returns a dictionary of buckets with values as lists of unfinished multipart uploads.

You can call it with no bucket in which case it lists all bucket, with a bucket or with a bucket and path.

{
  "test-bucket": [
            {
                    "namespace": "test-namespace",
                    "bucket": "test-bucket",
                    "object": "600m.bin",
                    "uploadId": "51dd8114-52a4-b2f2-c42f-5291f05eb3c8",
                    "timeCreated": "2022-07-29T06:21:16.595Z",
                    "storageTier": "Standard"
            }
    ]

cleanup

Remove unfinished multipart uploads.

rclone backend cleanup remote: [options] [<arguments>+]

This command removes unfinished multipart uploads of age greater than max-age which defaults to 24 hours.

Note that you can use --interactive/-i or --dry-run with this command to see what it would do.

rclone backend cleanup oos:bucket/path/to/object
rclone backend cleanup -o max-age=7w oos:bucket/path/to/object

Durations are parsed as per the rest of rclone, 2h, 7d, 7w etc.

Options:

  • "max-age": Max age of upload to delete

restore

Restore objects from Archive to Standard storage

rclone backend restore remote: [options] [<arguments>+]

This command can be used to restore one or more objects from Archive to Standard storage.

Usage Examples:

rclone backend restore oos:bucket/path/to/directory -o hours=HOURS
rclone backend restore oos:bucket -o hours=HOURS

This flag also obeys the filters. Test first with --interactive/-i or --dry-run flags

rclone --interactive backend restore --include "*.txt" oos:bucket/path -o hours=72

All the objects shown will be marked for restore, then

rclone backend restore --include "*.txt" oos:bucket/path -o hours=72

It returns a list of status dictionaries with Object Name and Status
keys. The Status will be "RESTORED"" if it was successful or an error message
if not.

[
    {
        "Object": "test.txt"
        "Status": "RESTORED",
    },
    {
        "Object": "test/file4.txt"
        "Status": "RESTORED",
    }
]

Options:

  • "hours": The number of hours for which this object will be restored. Default is 24 hrs.

Tutorials

Mounting Buckets

QingStor

Paths are specified as remote:bucket (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:bucket/path/to/dir.

Configuration

Here is an example of making an QingStor configuration. First run

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
n/r/c/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / QingStor Object Storage
   \ "qingstor"
[snip]
Storage> qingstor
Get QingStor credentials from runtime. Only applies if access_key_id and secret_access_key is blank.
Choose a number from below, or type in your own value
 1 / Enter QingStor credentials in the next step
   \ "false"
 2 / Get QingStor credentials from the environment (env vars or IAM)
   \ "true"
env_auth> 1
QingStor Access Key ID - leave blank for anonymous access or runtime credentials.
access_key_id> access_key
QingStor Secret Access Key (password) - leave blank for anonymous access or runtime credentials.
secret_access_key> secret_key
Enter an endpoint URL to connection QingStor API.
Leave blank will use the default value "https://qingstor.com:443"
endpoint>
Zone connect to. Default is "pek3a".
Choose a number from below, or type in your own value
   / The Beijing (China) Three Zone
 1 | Needs location constraint pek3a.
   \ "pek3a"
   / The Shanghai (China) First Zone
 2 | Needs location constraint sh1a.
   \ "sh1a"
zone> 1
Number of connection retry.
Leave blank will use the default value "3".
connection_retries>
Remote config
Configuration complete.
Options:
- type: qingstor
- env_auth: false
- access_key_id: access_key
- secret_access_key: secret_key
- endpoint:
- zone: pek3a
- connection_retries:
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

This remote is called remote and can now be used like this

See all buckets

rclone lsd remote:

Make a new bucket

rclone mkdir remote:bucket

List the contents of a bucket

rclone ls remote:bucket

Sync /home/local/directory to the remote bucket, deleting any excess files in the bucket.

rclone sync --interactive /home/local/directory remote:bucket

--fast-list

This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details.

Multipart uploads

rclone supports multipart uploads with QingStor which means that it can upload files bigger than 5 GiB. Note that files uploaded with multipart upload don't have an MD5SUM.

Note that incomplete multipart uploads older than 24 hours can be removed with rclone cleanup remote:bucket just for one bucket rclone cleanup remote: for all buckets. QingStor does not ever remove incomplete multipart uploads so it may be necessary to run this from time to time.

Buckets and Zone

With QingStor you can list buckets (rclone lsd) using any zone, but you can only access the content of a bucket from the zone it was created in. If you attempt to access a bucket from the wrong zone, you will get an error, incorrect zone, the bucket is not in 'XXX' zone.

Authentication

There are two ways to supply rclone with a set of QingStor credentials. In order of precedence:

  • Directly in the rclone configuration file (as configured by rclone config)
    • set access_key_id and secret_access_key
  • Runtime configuration:
    • set env_auth to true in the config file
    • Exporting the following environment variables before running rclone
      • Access Key ID: QS_ACCESS_KEY_ID or QS_ACCESS_KEY
      • Secret Access Key: QS_SECRET_ACCESS_KEY or QS_SECRET_KEY

Restricted filename characters

The control characters 0x00-0x1F and / are replaced as in the default restricted characters set. Note that 0x7F is not replaced.

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Standard options

Here are the Standard options specific to qingstor (QingCloud Object Storage).

--qingstor-env-auth

Get QingStor credentials from runtime.

Only applies if access_key_id and secret_access_key is blank.

Properties:

  • Config: env_auth
  • Env Var: RCLONE_QINGSTOR_ENV_AUTH
  • Type: bool
  • Default: false
  • Examples:
    • "false"
      • Enter QingStor credentials in the next step.
    • "true"
      • Get QingStor credentials from the environment (env vars or IAM).

--qingstor-access-key-id

QingStor Access Key ID.

Leave blank for anonymous access or runtime credentials.

Properties:

  • Config: access_key_id
  • Env Var: RCLONE_QINGSTOR_ACCESS_KEY_ID
  • Type: string
  • Required: false

--qingstor-secret-access-key

QingStor Secret Access Key (password).

Leave blank for anonymous access or runtime credentials.

Properties:

  • Config: secret_access_key
  • Env Var: RCLONE_QINGSTOR_SECRET_ACCESS_KEY
  • Type: string
  • Required: false

--qingstor-endpoint

Enter an endpoint URL to connection QingStor API.

Leave blank will use the default value "https://qingstor.com:443".

Properties:

  • Config: endpoint
  • Env Var: RCLONE_QINGSTOR_ENDPOINT
  • Type: string
  • Required: false

--qingstor-zone

Zone to connect to.

Default is "pek3a".

Properties:

  • Config: zone
  • Env Var: RCLONE_QINGSTOR_ZONE
  • Type: string
  • Required: false
  • Examples:
    • "pek3a"
      • The Beijing (China) Three Zone.
      • Needs location constraint pek3a.
    • "sh1a"
      • The Shanghai (China) First Zone.
      • Needs location constraint sh1a.
    • "gd2a"
      • The Guangdong (China) Second Zone.
      • Needs location constraint gd2a.

Advanced options

Here are the Advanced options specific to qingstor (QingCloud Object Storage).

--qingstor-connection-retries

Number of connection retries.

Properties:

  • Config: connection_retries
  • Env Var: RCLONE_QINGSTOR_CONNECTION_RETRIES
  • Type: int
  • Default: 3

--qingstor-upload-cutoff

Cutoff for switching to chunked upload.

Any files larger than this will be uploaded in chunks of chunk_size. The minimum is 0 and the maximum is 5 GiB.

Properties:

  • Config: upload_cutoff
  • Env Var: RCLONE_QINGSTOR_UPLOAD_CUTOFF
  • Type: SizeSuffix
  • Default: 200Mi

--qingstor-chunk-size

Chunk size to use for uploading.

When uploading files larger than upload_cutoff they will be uploaded as multipart uploads using this chunk size.

Note that "--qingstor-upload-concurrency" chunks of this size are buffered in memory per transfer.

If you are transferring large files over high-speed links and you have enough memory, then increasing this will speed up the transfers.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_QINGSTOR_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 4Mi

--qingstor-upload-concurrency

Concurrency for multipart uploads.

This is the number of chunks of the same file that are uploaded concurrently.

NB if you set this to > 1 then the checksums of multipart uploads become corrupted (the uploads themselves are not corrupted though).

If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers.

Properties:

  • Config: upload_concurrency
  • Env Var: RCLONE_QINGSTOR_UPLOAD_CONCURRENCY
  • Type: int
  • Default: 1

--qingstor-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_QINGSTOR_ENCODING
  • Type: Encoding
  • Default: Slash,Ctl,InvalidUtf8

--qingstor-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_QINGSTOR_DESCRIPTION
  • Type: string
  • Required: false

Limitations

rclone about is not supported by the qingstor backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

Quatrix

Quatrix by Maytech is Quatrix Secure Compliant File Sharing | Maytech.

Paths are specified as remote:path

Paths may be as deep as required, e.g., remote:directory/subdirectory.

The initial setup for Quatrix involves getting an API Key from Quatrix. You can get the API key in the user's profile at https://<account>/profile/api-keys or with the help of the API - https://docs.maytech.net/quatrix/quatrix-api/api-explorer#/API-Key/post_api_key_create.

See complete Swagger documentation for Quatrix - https://docs.maytech.net/quatrix/quatrix-api/api-explorer

Configuration

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Quatrix by Maytech
   \ "quatrix"
[snip]
Storage> quatrix
API key for accessing Quatrix account.
api_key> your_api_key
Host name of Quatrix account.
host> example.quatrix.it

Configuration complete.
Options:
- type: quatrix
- api_key: your_api_key
- host: example.quatrix.it
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

Once configured you can then use rclone like this,

List directories in top level of your Quatrix

rclone lsd remote:

List all the files in your Quatrix

rclone ls remote:

To copy a local directory to an Quatrix directory called backup

rclone copy /home/source remote:backup

API key validity

API Key is created with no expiration date. It will be valid until you delete or deactivate it in your account. After disabling, the API Key can be enabled back. If the API Key was deleted and a new key was created, you can update it in rclone config. The same happens if the hostname was changed.

$ rclone config
Current remotes:

Name                 Type
====                 ====
remote               quatrix

e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> e
Choose a number from below, or type in an existing value
 1 > remote
remote> remote
Configuration complete.
Options:
- type: quatrix
- host: some_host.quatrix.it
- api_key: your_api_key
Keep this "remote" remote?
Edit remote
Option api_key.
API key for accessing Quatrix account
Enter a string value. Press Enter for the default (your_api_key)
api_key>
Option host.
Host name of Quatrix account
Enter a string value. Press Enter for the default (some_host.quatrix.it).

Configuration complete.
Options:
- type: quatrix
- host: some_host.quatrix.it
- api_key: your_api_key
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

Modification times and hashes

Quatrix allows modification times to be set on objects accurate to 1 microsecond. These will be used to detect whether objects need syncing or not.

Quatrix does not support hashes, so you cannot use the --checksum flag.

Restricted filename characters

File names in Quatrix are case sensitive and have limitations like the maximum length of a filename is 255, and the minimum length is 1. A file name cannot be equal to . or .. nor contain / , \ or non-printable ascii.

Transfers

For files above 50 MiB rclone will use a chunked transfer. Rclone will upload up to --transfers chunks at the same time (shared among all multipart uploads). Chunks are buffered in memory, and the minimal chunk size is 10_000_000 bytes by default, and it can be changed in the advanced configuration, so increasing --transfers will increase the memory use. The chunk size has a maximum size limit, which is set to 100_000_000 bytes by default and can be changed in the advanced configuration. The size of the uploaded chunk will dynamically change depending on the upload speed. The total memory use equals the number of transfers multiplied by the minimal chunk size. In case there's free memory allocated for the upload (which equals the difference of maximal_summary_chunk_size and minimal_chunk_size * transfers), the chunk size may increase in case of high upload speed. As well as it can decrease in case of upload speed problems. If no free memory is available, all chunks will equal minimal_chunk_size.

Deleting files

Files you delete with rclone will end up in Trash and be stored there for 30 days. Quatrix also provides an API to permanently delete files and an API to empty the Trash so that you can remove files permanently from your account.

Standard options

Here are the Standard options specific to quatrix (Quatrix by Maytech).

--quatrix-api-key

API key for accessing Quatrix account

Properties:

  • Config: api_key
  • Env Var: RCLONE_QUATRIX_API_KEY
  • Type: string
  • Required: true

--quatrix-host

Host name of Quatrix account

Properties:

  • Config: host
  • Env Var: RCLONE_QUATRIX_HOST
  • Type: string
  • Required: true

Advanced options

Here are the Advanced options specific to quatrix (Quatrix by Maytech).

--quatrix-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_QUATRIX_ENCODING
  • Type: Encoding
  • Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot

--quatrix-effective-upload-time

Wanted upload time for one chunk

Properties:

  • Config: effective_upload_time
  • Env Var: RCLONE_QUATRIX_EFFECTIVE_UPLOAD_TIME
  • Type: string
  • Default: "4s"

--quatrix-minimal-chunk-size

The minimal size for one chunk

Properties:

  • Config: minimal_chunk_size
  • Env Var: RCLONE_QUATRIX_MINIMAL_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 9.537Mi

--quatrix-maximal-summary-chunk-size

The maximal summary for all chunks. It should not be less than 'transfers'*'minimal_chunk_size'

Properties:

  • Config: maximal_summary_chunk_size
  • Env Var: RCLONE_QUATRIX_MAXIMAL_SUMMARY_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 95.367Mi

--quatrix-hard-delete

Delete files permanently rather than putting them into the trash

Properties:

  • Config: hard_delete
  • Env Var: RCLONE_QUATRIX_HARD_DELETE
  • Type: bool
  • Default: false

--quatrix-skip-project-folders

Skip project folders in operations

Properties:

  • Config: skip_project_folders
  • Env Var: RCLONE_QUATRIX_SKIP_PROJECT_FOLDERS
  • Type: bool
  • Default: false

--quatrix-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_QUATRIX_DESCRIPTION
  • Type: string
  • Required: false

Storage usage

The storage usage in Quatrix is restricted to the account during the purchase. You can restrict any user with a smaller storage limit. The account limit is applied if the user has no custom storage limit. Once you've reached the limit, the upload of files will fail. This can be fixed by freeing up the space or increasing the quota.

Server-side operations

Quatrix supports server-side operations (copy and move). In case of conflict, files are overwritten during server-side operation.

Sia

Sia (sia.tech) is a decentralized cloud storage platform based on the blockchain technology. With rclone you can use it like any other remote filesystem or mount Sia folders locally. The technology behind it involves a number of new concepts such as Siacoins and Wallet, Blockchain and Consensus, Renting and Hosting, and so on. If you are new to it, you'd better first familiarize yourself using their excellent support documentation.

Introduction

Before you can use rclone with Sia, you will need to have a running copy of Sia-UI or siad (the Sia daemon) locally on your computer or on local network (e.g. a NAS). Please follow the Get started guide and install one.

rclone interacts with Sia network by talking to the Sia daemon via HTTP API which is usually available on port 9980. By default you will run the daemon locally on the same computer so it's safe to leave the API password blank (the API URL will be http://127.0.0.1:9980 making external access impossible).

However, if you want to access Sia daemon running on another node, for example due to memory constraints or because you want to share single daemon between several rclone and Sia-UI instances, you'll need to make a few more provisions: - Ensure you have Sia daemon installed directly or in a docker container because Sia-UI does not support this mode natively. - Run it on externally accessible port, for example provide --api-addr :9980 and --disable-api-security arguments on the daemon command line. - Enforce API password for the siad daemon via environment variable SIA_API_PASSWORD or text file named apipassword in the daemon directory. - Set rclone backend option api_password taking it from above locations.

Notes: 1. If your wallet is locked, rclone cannot unlock it automatically. You should either unlock it in advance by using Sia-UI or via command line siac wallet unlock. Alternatively you can make siad unlock your wallet automatically upon startup by running it with environment variable SIA_WALLET_PASSWORD. 2. If siad cannot find the SIA_API_PASSWORD variable or the apipassword file in the SIA_DIR directory, it will generate a random password and store in the text file named apipassword under YOUR_HOME/.sia/ directory on Unix or C:\Users\YOUR_HOME\AppData\Local\Sia\apipassword on Windows. Remember this when you configure password in rclone. 3. The only way to use siad without API password is to run it on localhost with command line argument --authorize-api=false, but this is insecure and strongly discouraged.

Configuration

Here is an example of how to make a sia remote called mySia. First, run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> mySia
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
...
29 / Sia Decentralized Cloud
   \ "sia"
...
Storage> sia
Sia daemon API URL, like http://sia.daemon.host:9980.
Note that siad must run with --disable-api-security to open API port for other hosts (not recommended).
Keep default if Sia daemon runs on localhost.
Enter a string value. Press Enter for the default ("http://127.0.0.1:9980").
api_url> http://127.0.0.1:9980
Sia Daemon API Password.
Can be found in the apipassword file located in HOME/.sia/ or in the daemon directory.
y) Yes type in my own password
g) Generate random password
n) No leave this optional password blank (default)
y/g/n> y
Enter the password:
password:
Confirm the password:
password:
Edit advanced config?
y) Yes
n) No (default)
y/n> n
--------------------
[mySia]
type = sia
api_url = http://127.0.0.1:9980
api_password = *** ENCRYPTED ***
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Once configured, you can then use rclone like this:

  • List directories in top level of your Sia storage
rclone lsd mySia:
  • List all the files in your Sia storage
rclone ls mySia:
  • Upload a local directory to the Sia directory called backup
rclone copy /home/source mySia:backup

Standard options

Here are the Standard options specific to sia (Sia Decentralized Cloud).

--sia-api-url

Sia daemon API URL, like http://sia.daemon.host:9980.

Note that siad must run with --disable-api-security to open API port for other hosts (not recommended). Keep default if Sia daemon runs on localhost.

Properties:

  • Config: api_url
  • Env Var: RCLONE_SIA_API_URL
  • Type: string
  • Default: "http://127.0.0.1:9980"

--sia-api-password

Sia Daemon API Password.

Can be found in the apipassword file located in HOME/.sia/ or in the daemon directory.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: api_password
  • Env Var: RCLONE_SIA_API_PASSWORD
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to sia (Sia Decentralized Cloud).

--sia-user-agent

Siad User Agent

Sia daemon requires the 'Sia-Agent' user agent by default for security

Properties:

  • Config: user_agent
  • Env Var: RCLONE_SIA_USER_AGENT
  • Type: string
  • Default: "Sia-Agent"

--sia-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_SIA_ENCODING
  • Type: Encoding
  • Default: Slash,Question,Hash,Percent,Del,Ctl,InvalidUtf8,Dot

--sia-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_SIA_DESCRIPTION
  • Type: string
  • Required: false

Limitations

  • Modification times not supported
  • Checksums not supported
  • rclone about not supported
  • rclone can work only with Siad or Sia-UI at the moment, the SkyNet daemon is not supported yet.
  • Sia does not allow control characters or symbols like question and pound signs in file names. rclone will transparently encode them for you, but you'd better be aware

Swift

Swift refers to OpenStack Object Storage. Commercial implementations of that being:

Paths are specified as remote:container (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:container/path/to/dir.

Configuration

Here is an example of making a swift configuration. First run

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / OpenStack Swift (Rackspace Cloud Files, Blomp Cloud Storage, Memset Memstore, OVH)
   \ "swift"
[snip]
Storage> swift
Get swift credentials from environment variables in standard OpenStack form.
Choose a number from below, or type in your own value
 1 / Enter swift credentials in the next step
   \ "false"
 2 / Get swift credentials from environment vars. Leave other fields blank if using this.
   \ "true"
env_auth> true
User name to log in (OS_USERNAME).
user> 
API key or password (OS_PASSWORD).
key> 
Authentication URL for server (OS_AUTH_URL).
Choose a number from below, or type in your own value
 1 / Rackspace US
   \ "https://auth.api.rackspacecloud.com/v1.0"
 2 / Rackspace UK
   \ "https://lon.auth.api.rackspacecloud.com/v1.0"
 3 / Rackspace v2
   \ "https://identity.api.rackspacecloud.com/v2.0"
 4 / Memset Memstore UK
   \ "https://auth.storage.memset.com/v1.0"
 5 / Memset Memstore UK v2
   \ "https://auth.storage.memset.com/v2.0"
 6 / OVH
   \ "https://auth.cloud.ovh.net/v3"
 7  / Blomp Cloud Storage
   \ "https://authenticate.ain.net"
auth> 
User ID to log in - optional - most swift systems use user and leave this blank (v3 auth) (OS_USER_ID).
user_id> 
User domain - optional (v3 auth) (OS_USER_DOMAIN_NAME)
domain> 
Tenant name - optional for v1 auth, this or tenant_id required otherwise (OS_TENANT_NAME or OS_PROJECT_NAME)
tenant> 
Tenant ID - optional for v1 auth, this or tenant required otherwise (OS_TENANT_ID)
tenant_id> 
Tenant domain - optional (v3 auth) (OS_PROJECT_DOMAIN_NAME)
tenant_domain> 
Region name - optional (OS_REGION_NAME)
region> 
Storage URL - optional (OS_STORAGE_URL)
storage_url> 
Auth Token from alternate authentication - optional (OS_AUTH_TOKEN)
auth_token> 
AuthVersion - optional - set to (1,2,3) if your auth URL has no version (ST_AUTH_VERSION)
auth_version> 
Endpoint type to choose from the service catalogue (OS_ENDPOINT_TYPE)
Choose a number from below, or type in your own value
 1 / Public (default, choose this if not sure)
   \ "public"
 2 / Internal (use internal service net)
   \ "internal"
 3 / Admin
   \ "admin"
endpoint_type> 
Remote config
--------------------
[test]
env_auth = true
user = 
key = 
auth = 
user_id = 
domain = 
tenant = 
tenant_id = 
tenant_domain = 
region = 
storage_url = 
auth_token = 
auth_version = 
endpoint_type = 
--------------------
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

This remote is called remote and can now be used like this

See all containers

rclone lsd remote:

Make a new container

rclone mkdir remote:container

List the contents of a container

rclone ls remote:container

Sync /home/local/directory to the remote container, deleting any excess files in the container.

rclone sync --interactive /home/local/directory remote:container

Configuration from an OpenStack credentials file

An OpenStack credentials file typically looks something something like this (without the comments)

export OS_AUTH_URL=https://a.provider.net/v2.0
export OS_TENANT_ID=ffffffffffffffffffffffffffffffff
export OS_TENANT_NAME="1234567890123456"
export OS_USERNAME="123abc567xy"
echo "Please enter your OpenStack Password: "
read -sr OS_PASSWORD_INPUT
export OS_PASSWORD=$OS_PASSWORD_INPUT
export OS_REGION_NAME="SBG1"
if [ -z "$OS_REGION_NAME" ]; then unset OS_REGION_NAME; fi

The config file needs to look something like this where $OS_USERNAME represents the value of the OS_USERNAME variable - 123abc567xy in the example above.

[remote]
type = swift
user = $OS_USERNAME
key = $OS_PASSWORD
auth = $OS_AUTH_URL
tenant = $OS_TENANT_NAME

Note that you may (or may not) need to set region too - try without first.

Configuration from the environment

If you prefer you can configure rclone to use swift using a standard set of OpenStack environment variables.

When you run through the config, make sure you choose true for env_auth and leave everything else blank.

rclone will then set any empty config parameters from the environment using standard OpenStack environment variables. There is a list of the variables in the docs for the swift library.

Using an alternate authentication method

If your OpenStack installation uses a non-standard authentication method that might not be yet supported by rclone or the underlying swift library, you can authenticate externally (e.g. calling manually the openstack commands to get a token). Then, you just need to pass the two configuration variables auth_token and storage_url. If they are both provided, the other variables are ignored. rclone will not try to authenticate but instead assume it is already authenticated and use these two variables to access the OpenStack installation.

Using rclone without a config file

You can use rclone with swift without a config file, if desired, like this:

source openstack-credentials-file
export RCLONE_CONFIG_MYREMOTE_TYPE=swift
export RCLONE_CONFIG_MYREMOTE_ENV_AUTH=true
rclone lsd myremote:

--fast-list

This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details.

--update and --use-server-modtime

As noted below, the modified time is stored on metadata on the object. It is used by default for all operations that require checking the time a file was last updated. It allows rclone to treat the remote more like a true filesystem, but it is inefficient because it requires an extra API call to retrieve the metadata.

For many operations, the time the object was last uploaded to the remote is sufficient to determine if it is "dirty". By using --update along with --use-server-modtime, you can avoid the extra API call and simply upload files whose local modtime is newer than the time it was last uploaded.

Modification times and hashes

The modified time is stored as metadata on the object as X-Object-Meta-Mtime as floating point since the epoch accurate to 1 ns.

This is a de facto standard (used in the official python-swiftclient amongst others) for storing the modification time for an object.

The MD5 hash algorithm is supported.

Restricted filename characters

Character Value Replacement
NUL 0x00 ␀
/ 0x2F ／

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Standard options

Here are the Standard options specific to swift (OpenStack Swift (Rackspace Cloud Files, Blomp Cloud Storage, Memset Memstore, OVH)).

--swift-env-auth

Get swift credentials from environment variables in standard OpenStack form.

Properties:

  • Config: env_auth
  • Env Var: RCLONE_SWIFT_ENV_AUTH
  • Type: bool
  • Default: false
  • Examples:
    • "false"
      • Enter swift credentials in the next step.
    • "true"
      • Get swift credentials from environment vars.
      • Leave other fields blank if using this.

--swift-user

User name to log in (OS_USERNAME).

Properties:

  • Config: user
  • Env Var: RCLONE_SWIFT_USER
  • Type: string
  • Required: false

--swift-key

API key or password (OS_PASSWORD).

Properties:

  • Config: key
  • Env Var: RCLONE_SWIFT_KEY
  • Type: string
  • Required: false

--swift-auth

Authentication URL for server (OS_AUTH_URL).

Properties:

  • Config: auth
  • Env Var: RCLONE_SWIFT_AUTH
  • Type: string
  • Required: false
  • Examples:
    • "https://auth.api.rackspacecloud.com/v1.0"
      • Rackspace US
    • "https://lon.auth.api.rackspacecloud.com/v1.0"
      • Rackspace UK
    • "https://identity.api.rackspacecloud.com/v2.0"
      • Rackspace v2
    • "https://auth.storage.memset.com/v1.0"
      • Memset Memstore UK
    • "https://auth.storage.memset.com/v2.0"
      • Memset Memstore UK v2
    • "https://auth.cloud.ovh.net/v3"
      • OVH
    • "https://authenticate.ain.net"
      • Blomp Cloud Storage

--swift-user-id

User ID to log in - optional - most swift systems use user and leave this blank (v3 auth) (OS_USER_ID).

Properties:

  • Config: user_id
  • Env Var: RCLONE_SWIFT_USER_ID
  • Type: string
  • Required: false

--swift-domain

User domain - optional (v3 auth) (OS_USER_DOMAIN_NAME)

Properties:

  • Config: domain
  • Env Var: RCLONE_SWIFT_DOMAIN
  • Type: string
  • Required: false

--swift-tenant

Tenant name - optional for v1 auth, this or tenant_id required otherwise (OS_TENANT_NAME or OS_PROJECT_NAME).

Properties:

  • Config: tenant
  • Env Var: RCLONE_SWIFT_TENANT
  • Type: string
  • Required: false

--swift-tenant-id

Tenant ID - optional for v1 auth, this or tenant required otherwise (OS_TENANT_ID).

Properties:

  • Config: tenant_id
  • Env Var: RCLONE_SWIFT_TENANT_ID
  • Type: string
  • Required: false

--swift-tenant-domain

Tenant domain - optional (v3 auth) (OS_PROJECT_DOMAIN_NAME).

Properties:

  • Config: tenant_domain
  • Env Var: RCLONE_SWIFT_TENANT_DOMAIN
  • Type: string
  • Required: false

--swift-region

Region name - optional (OS_REGION_NAME).

Properties:

  • Config: region
  • Env Var: RCLONE_SWIFT_REGION
  • Type: string
  • Required: false

--swift-storage-url

Storage URL - optional (OS_STORAGE_URL).

Properties:

  • Config: storage_url
  • Env Var: RCLONE_SWIFT_STORAGE_URL
  • Type: string
  • Required: false

--swift-auth-token

Auth Token from alternate authentication - optional (OS_AUTH_TOKEN).

Properties:

  • Config: auth_token
  • Env Var: RCLONE_SWIFT_AUTH_TOKEN
  • Type: string
  • Required: false

--swift-application-credential-id

Application Credential ID (OS_APPLICATION_CREDENTIAL_ID).

Properties:

  • Config: application_credential_id
  • Env Var: RCLONE_SWIFT_APPLICATION_CREDENTIAL_ID
  • Type: string
  • Required: false

--swift-application-credential-name

Application Credential Name (OS_APPLICATION_CREDENTIAL_NAME).

Properties:

  • Config: application_credential_name
  • Env Var: RCLONE_SWIFT_APPLICATION_CREDENTIAL_NAME
  • Type: string
  • Required: false

--swift-application-credential-secret

Application Credential Secret (OS_APPLICATION_CREDENTIAL_SECRET).

Properties:

  • Config: application_credential_secret
  • Env Var: RCLONE_SWIFT_APPLICATION_CREDENTIAL_SECRET
  • Type: string
  • Required: false

--swift-auth-version

AuthVersion - optional - set to (1,2,3) if your auth URL has no version (ST_AUTH_VERSION).

Properties:

  • Config: auth_version
  • Env Var: RCLONE_SWIFT_AUTH_VERSION
  • Type: int
  • Default: 0

--swift-endpoint-type

Endpoint type to choose from the service catalogue (OS_ENDPOINT_TYPE).

Properties:

  • Config: endpoint_type
  • Env Var: RCLONE_SWIFT_ENDPOINT_TYPE
  • Type: string
  • Default: "public"
  • Examples:
    • "public"
      • Public (default, choose this if not sure)
    • "internal"
      • Internal (use internal service net)
    • "admin"
      • Admin

--swift-storage-policy

The storage policy to use when creating a new container.

This applies the specified storage policy when creating a new container. The policy cannot be changed afterwards. The allowed configuration values and their meaning depend on your Swift storage provider.

Properties:

  • Config: storage_policy
  • Env Var: RCLONE_SWIFT_STORAGE_POLICY
  • Type: string
  • Required: false
  • Examples:
    • ""
      • Default
    • "pcs"
      • OVH Public Cloud Storage
    • "pca"
      • OVH Public Cloud Archive

Advanced options

Here are the Advanced options specific to swift (OpenStack Swift (Rackspace Cloud Files, Blomp Cloud Storage, Memset Memstore, OVH)).

--swift-leave-parts-on-error

If true avoid calling abort upload on a failure.

It should be set to true for resuming uploads across different sessions.

Properties:

  • Config: leave_parts_on_error
  • Env Var: RCLONE_SWIFT_LEAVE_PARTS_ON_ERROR
  • Type: bool
  • Default: false

--swift-fetch-until-empty-page

When paginating, always fetch unless we received an empty page.

Consider using this option if rclone listings show fewer objects than expected, or if repeated syncs copy unchanged objects.

It is safe to enable this, but rclone may make more API calls than necessary.

This is one of a pair of workarounds to handle implementations of the Swift API that do not implement pagination as expected. See also "partial_page_fetch_threshold".

Properties:

  • Config: fetch_until_empty_page
  • Env Var: RCLONE_SWIFT_FETCH_UNTIL_EMPTY_PAGE
  • Type: bool
  • Default: false

--swift-partial-page-fetch-threshold

When paginating, fetch if the current page is within this percentage of the limit.

Consider using this option if rclone listings show fewer objects than expected, or if repeated syncs copy unchanged objects.

It is safe to enable this, but rclone may make more API calls than necessary.

This is one of a pair of workarounds to handle implementations of the Swift API that do not implement pagination as expected. See also "fetch_until_empty_page".

Properties:

  • Config: partial_page_fetch_threshold
  • Env Var: RCLONE_SWIFT_PARTIAL_PAGE_FETCH_THRESHOLD
  • Type: int
  • Default: 0

--swift-chunk-size

Above this size files will be chunked.

Above this size files will be chunked into a a _segments container or a .file-segments directory. (See the use_segments_container option for more info). Default for this is 5 GiB which is its maximum value, which means only files above this size will be chunked.

Rclone uploads chunked files as dynamic large objects (DLO).

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_SWIFT_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 5Gi

--swift-no-chunk

Don't chunk files during streaming upload.

When doing streaming uploads (e.g. using rcat or mount with --vfs-cache-mode off) setting this flag will cause the swift backend to not upload chunked files.

This will limit the maximum streamed upload size to 5 GiB. This is useful because non chunked files are easier to deal with and have an MD5SUM.

Rclone will still chunk files bigger than chunk_size when doing normal copy operations.

Properties:

  • Config: no_chunk
  • Env Var: RCLONE_SWIFT_NO_CHUNK
  • Type: bool
  • Default: false

--swift-no-large-objects

Disable support for static and dynamic large objects

Swift cannot transparently store files bigger than 5 GiB. There are two schemes for chunking large files, static large objects (SLO) or dynamic large objects (DLO), and the API does not allow rclone to determine whether a file is a static or dynamic large object without doing a HEAD on the object. Since these need to be treated differently, this means rclone has to issue HEAD requests for objects for example when reading checksums.

When no_large_objects is set, rclone will assume that there are no static or dynamic large objects stored. This means it can stop doing the extra HEAD calls which in turn increases performance greatly especially when doing a swift to swift transfer with --checksum set.

Setting this option implies no_chunk and also that no files will be uploaded in chunks, so files bigger than 5 GiB will just fail on upload.

If you set this option and there are static or dynamic large objects, then this will give incorrect hashes for them. Downloads will succeed, but other operations such as Remove and Copy will fail.

Properties:

  • Config: no_large_objects
  • Env Var: RCLONE_SWIFT_NO_LARGE_OBJECTS
  • Type: bool
  • Default: false

--swift-use-segments-container

Choose destination for large object segments

Swift cannot transparently store files bigger than 5 GiB and rclone will chunk files larger than chunk_size (default 5 GiB) in order to upload them.

If this value is true the chunks will be stored in an additional container named the same as the destination container but with _segments appended. This means that there won't be any duplicated data in the original container but having another container may not be acceptable.

If this value is false the chunks will be stored in a .file-segments directory in the root of the container. This directory will be omitted when listing the container. Some providers (eg Blomp) require this mode as creating additional containers isn't allowed. If it is desired to see the .file-segments directory in the root then this flag must be set to true.

If this value is unset (the default), then rclone will choose the value to use. It will be false unless rclone detects any auth_urls that it knows need it to be true. In this case you'll see a message in the DEBUG log.

Properties:

  • Config: use_segments_container
  • Env Var: RCLONE_SWIFT_USE_SEGMENTS_CONTAINER
  • Type: Tristate
  • Default: unset

--swift-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_SWIFT_ENCODING
  • Type: Encoding
  • Default: Slash,InvalidUtf8

--swift-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_SWIFT_DESCRIPTION
  • Type: string
  • Required: false

Limitations

The Swift API doesn't return a correct MD5SUM for segmented files (Dynamic or Static Large Objects) so rclone won't check or use the MD5SUM for these.

Troubleshooting

Rclone gives Failed to create file system for "remote:": Bad Request

Due to an oddity of the underlying swift library, it gives a "Bad Request" error rather than a more sensible error when the authentication fails for Swift.

So this most likely means your username / password is wrong. You can investigate further with the --dump-bodies flag.

This may also be caused by specifying the region when you shouldn't have (e.g. OVH).

Rclone gives Failed to create file system: Response didn't have storage url and auth token

This is most likely caused by forgetting to specify your tenant when setting up a swift remote.

OVH Cloud Archive

To use rclone with OVH cloud archive, first use rclone config to set up a swift backend with OVH, choosing pca as the storage_policy.

Uploading Objects

Uploading objects to OVH cloud archive is no different to object storage, you just simply run the command you like (move, copy or sync) to upload the objects. Once uploaded the objects will show in a "Frozen" state within the OVH control panel.

Retrieving Objects

To retrieve objects use rclone copy as normal. If the objects are in a frozen state then rclone will ask for them all to be unfrozen and it will wait at the end of the output with a message like the following:

2019/03/23 13:06:33 NOTICE: Received retry after error - sleeping until 2019-03-23T13:16:33.481657164+01:00 (9m59.99985121s)

Rclone will wait for the time specified then retry the copy.

pCloud

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Configuration

The initial setup for pCloud involves getting a token from pCloud which you need to do in your browser. rclone config walks you through it.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Pcloud
   \ "pcloud"
[snip]
Storage> pcloud
Pcloud App Client Id - leave blank normally.
client_id> 
Pcloud App Client Secret - leave blank normally.
client_secret> 
Edit advanced config?
y) Yes
n) No (default)
y/n> n
Remote config
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y) Yes
n) No
y/n> y
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth
Log in and authorize rclone for access
Waiting for code...
Got code
Configuration complete.
Options:
- type: pcloud
- client_id:
- client_secret:
- token: {"access_token":"XXX","token_type":"bearer","expiry":"0001-01-01T00:00:00Z"}
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

See the remote setup docs for how to set it up on a machine with no Internet browser available.

Note if you are using remote config with rclone authorize while your pcloud server is the EU region, you will need to set the hostname in 'Edit advanced config', otherwise you might get a token error.

Note that rclone runs a webserver on your local machine to collect the token as returned from pCloud. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall.

Once configured you can then use rclone like this,

List directories in top level of your pCloud

rclone lsd remote:

List all the files in your pCloud

rclone ls remote:

To copy a local directory to a pCloud directory called backup

rclone copy /home/source remote:backup

Modification times and hashes

pCloud allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not. In order to set a Modification time pCloud requires the object be re-uploaded.

pCloud supports MD5 and SHA1 hashes in the US region, and SHA1 and SHA256 hashes in the EU region, so you can use the --checksum flag.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
\ 0x5C ＼

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Deleting files

Deleted files will be moved to the trash. Your subscription level will determine how long items stay in the trash. rclone cleanup can be used to empty the trash.

Emptying the trash

Due to an API limitation, the rclone cleanup command will only work if you set your username and password in the advanced options for this backend. Since we generally want to avoid storing user passwords in the rclone config file, we advise you to only set this up if you need the rclone cleanup command to work.

Root folder ID

You can set the root_folder_id for rclone. This is the directory (identified by its Folder ID) that rclone considers to be the root of your pCloud drive.

Normally you will leave this blank and rclone will determine the correct root to use itself.

However you can set this to restrict rclone to a specific folder hierarchy.

In order to do this you will have to find the Folder ID of the directory you wish rclone to display. This will be the folder field of the URL when you open the relevant folder in the pCloud web interface.

So if the folder you want rclone to use has a URL which looks like https://my.pcloud.com/#page=filemanager&folder=5xxxxxxxx8&tpl=foldergrid in the browser, then you use 5xxxxxxxx8 as the root_folder_id in the config.

Standard options

Here are the Standard options specific to pcloud (Pcloud).

--pcloud-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_PCLOUD_CLIENT_ID
  • Type: string
  • Required: false

--pcloud-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_PCLOUD_CLIENT_SECRET
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to pcloud (Pcloud).

--pcloud-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_PCLOUD_TOKEN
  • Type: string
  • Required: false

--pcloud-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_PCLOUD_AUTH_URL
  • Type: string
  • Required: false

--pcloud-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_PCLOUD_TOKEN_URL
  • Type: string
  • Required: false

--pcloud-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_PCLOUD_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--pcloud-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_PCLOUD_ENCODING
  • Type: Encoding
  • Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot

--pcloud-root-folder-id

Fill in for rclone to use a non root folder as its starting point.

Properties:

  • Config: root_folder_id
  • Env Var: RCLONE_PCLOUD_ROOT_FOLDER_ID
  • Type: string
  • Default: "d0"

--pcloud-hostname

Hostname to connect to.

This is normally set when rclone initially does the oauth connection, however you will need to set it by hand if you are using remote config with rclone authorize.

Properties:

  • Config: hostname
  • Env Var: RCLONE_PCLOUD_HOSTNAME
  • Type: string
  • Default: "api.pcloud.com"
  • Examples:
    • "api.pcloud.com"
      • Original/US region
    • "eapi.pcloud.com"
      • EU region

--pcloud-username

Your pcloud username.

This is only required when you want to use the cleanup command. Due to a bug in the pcloud API the required API does not support OAuth authentication so we have to rely on user password authentication for it.

Properties:

  • Config: username
  • Env Var: RCLONE_PCLOUD_USERNAME
  • Type: string
  • Required: false

--pcloud-password

Your pcloud password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: password
  • Env Var: RCLONE_PCLOUD_PASSWORD
  • Type: string
  • Required: false

--pcloud-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_PCLOUD_DESCRIPTION
  • Type: string
  • Required: false

PikPak

PikPak is a private cloud drive.

Paths are specified as remote:path, and may be as deep as required, e.g. remote:directory/subdirectory.

Configuration

Here is an example of making a remote for PikPak.

First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n

Enter name for new remote.
name> remote

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
XX / PikPak
   \ (pikpak)
Storage> XX

Option user.
Pikpak username.
Enter a value.
user> USERNAME

Option pass.
Pikpak password.
Choose an alternative below.
y) Yes, type in my own password
g) Generate random password
y/g> y
Enter the password:
password:
Confirm the password:
password:

Edit advanced config?
y) Yes
n) No (default)
y/n> 

Configuration complete.
Options:
- type: pikpak
- user: USERNAME
- pass: *** ENCRYPTED ***
- token: {"access_token":"eyJ...","token_type":"Bearer","refresh_token":"os...","expiry":"2023-01-26T18:54:32.170582647+09:00"}
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Modification times and hashes

PikPak keeps modification times on objects, and updates them when uploading objects, but it does not support changing only the modification time

The MD5 hash algorithm is supported.

Standard options

Here are the Standard options specific to pikpak (PikPak).

--pikpak-user

Pikpak username.

Properties:

  • Config: user
  • Env Var: RCLONE_PIKPAK_USER
  • Type: string
  • Required: true

--pikpak-pass

Pikpak password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: pass
  • Env Var: RCLONE_PIKPAK_PASS
  • Type: string
  • Required: true

Advanced options

Here are the Advanced options specific to pikpak (PikPak).

--pikpak-device-id

Device ID used for authorization.

Properties:

  • Config: device_id
  • Env Var: RCLONE_PIKPAK_DEVICE_ID
  • Type: string
  • Required: false

--pikpak-user-agent

HTTP user agent for pikpak.

Defaults to "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:129.0) Gecko/20100101 Firefox/129.0" or "--pikpak-user-agent" provided on command line.

Properties:

  • Config: user_agent
  • Env Var: RCLONE_PIKPAK_USER_AGENT
  • Type: string
  • Default: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:129.0) Gecko/20100101 Firefox/129.0"

--pikpak-root-folder-id

ID of the root folder. Leave blank normally.

Fill in for rclone to use a non root folder as its starting point.

Properties:

  • Config: root_folder_id
  • Env Var: RCLONE_PIKPAK_ROOT_FOLDER_ID
  • Type: string
  • Required: false

--pikpak-use-trash

Send files to the trash instead of deleting permanently.

Defaults to true, namely sending files to the trash. Use --pikpak-use-trash=false to delete files permanently instead.

Properties:

  • Config: use_trash
  • Env Var: RCLONE_PIKPAK_USE_TRASH
  • Type: bool
  • Default: true

--pikpak-trashed-only

Only show files that are in the trash.

This will show trashed files in their original directory structure.

Properties:

  • Config: trashed_only
  • Env Var: RCLONE_PIKPAK_TRASHED_ONLY
  • Type: bool
  • Default: false

Use original file links instead of media links.

This avoids issues caused by invalid media links, but may reduce download speeds.

Properties:

  • Config: no_media_link
  • Env Var: RCLONE_PIKPAK_NO_MEDIA_LINK
  • Type: bool
  • Default: false

--pikpak-hash-memory-limit

Files bigger than this will be cached on disk to calculate hash if required.

Properties:

  • Config: hash_memory_limit
  • Env Var: RCLONE_PIKPAK_HASH_MEMORY_LIMIT
  • Type: SizeSuffix
  • Default: 10Mi

--pikpak-upload-cutoff

Cutoff for switching to chunked upload.

Any files larger than this will be uploaded in chunks of chunk_size. The minimum is 0 and the maximum is 5 GiB.

Properties:

  • Config: upload_cutoff
  • Env Var: RCLONE_PIKPAK_UPLOAD_CUTOFF
  • Type: SizeSuffix
  • Default: 200Mi

--pikpak-chunk-size

Chunk size for multipart uploads.

Large files will be uploaded in chunks of this size.

Note that this is stored in memory and there may be up to "--transfers" * "--pikpak-upload-concurrency" chunks stored at once in memory.

If you are transferring large files over high-speed links and you have enough memory, then increasing this will speed up the transfers.

Rclone will automatically increase the chunk size when uploading a large file of known size to stay below the 10,000 chunks limit.

Increasing the chunk size decreases the accuracy of the progress statistics displayed with "-P" flag.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_PIKPAK_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 5Mi

--pikpak-upload-concurrency

Concurrency for multipart uploads.

This is the number of chunks of the same file that are uploaded concurrently for multipart uploads.

Note that chunks are stored in memory and there may be up to "--transfers" * "--pikpak-upload-concurrency" chunks stored at once in memory.

If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers.

Properties:

  • Config: upload_concurrency
  • Env Var: RCLONE_PIKPAK_UPLOAD_CONCURRENCY
  • Type: int
  • Default: 4

--pikpak-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_PIKPAK_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,LeftSpace,RightSpace,RightPeriod,InvalidUtf8,Dot

--pikpak-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_PIKPAK_DESCRIPTION
  • Type: string
  • Required: false

Backend commands

Here are the commands specific to the pikpak backend.

Run them with

rclone backend COMMAND remote:

The help below will explain what arguments each command takes.

See the backend command for more info on how to pass options and arguments.

These can be run on a running backend using the rc command backend/command.

addurl

Add offline download task for url

rclone backend addurl remote: [options] [<arguments>+]

This command adds offline download task for url.

Usage:

rclone backend addurl pikpak:dirpath url

Downloads will be stored in 'dirpath'. If 'dirpath' is invalid, download will fallback to default 'My Pack' folder.

decompress

Request decompress of a file/files in a folder

rclone backend decompress remote: [options] [<arguments>+]

This command requests decompress of file/files in a folder.

Usage:

rclone backend decompress pikpak:dirpath {filename} -o password=password
rclone backend decompress pikpak:dirpath {filename} -o delete-src-file

An optional argument 'filename' can be specified for a file located in 'pikpak:dirpath'. You may want to pass '-o password=password' for a password-protected files. Also, pass '-o delete-src-file' to delete source files after decompression finished.

Result:

{
    "Decompressed": 17,
    "SourceDeleted": 0,
    "Errors": 0
}

Limitations

Hashes may be empty

PikPak supports MD5 hash, but sometimes given empty especially for user-uploaded files.

Deleted files still visible with trashed-only

Deleted files will still be visible with --pikpak-trashed-only even after the trash emptied. This goes away after few days.

Pixeldrain

This is the backend for Pixeldrain's premium filesystem feature. This is not the same as pixeldrain's free file sharing product. The filesystem requires either a Pro subscription or the Prepaid plan. More information on subscriptions.

An overview of the filesystem's features and limitations is available in the filesystem guide on pixeldrain.

Usage with account

To use the personal filesystem you will need a pixeldrain account and either the Prepaid plan or one of the Patreon-based subscriptions. After registering and subscribing, your personal filesystem will be available at this link: https://pixeldrain.com/d/me.

Go to the API keys page on your account and generate a new API key for rclone. Then run rclone config and use the API key to create a new backend.

Example:

No remotes found, make a new one?
n) New remote
d) Delete remote
c) Copy remote
s) Set configuration password
q) Quit config
n/d/c/s/q> n

Enter name for new remote.
name> pixeldrainfs

Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
...
XX / Pixeldrain Filesystem
   \ (pixeldrain)
...
Storage> pixeldrain

Option api_key.
API key for your pixeldrain account.
Found on https://pixeldrain.com/user/api_keys.
Enter a value. Press Enter to leave empty.
api_key> b1bb1e81-9b7b-406b-986a-c9b20be76e15

Option directory_id.
Root of the filesystem to use. Set to 'me' to use your personal filesystem.
Set to a shared directory ID to use a shared directory.
Enter a string value. Press Enter for the default (me).
directory_id>

Edit advanced config?
y) Yes
n) No (default)
y/n>

Configuration complete.
Options:
- type: pixeldrain
- api_key: b1bb1e81-9b7b-406b-986a-c9b20be76e15
Keep this "pixeldrainfs" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d>

Current remotes:

Name                 Type
====                 ====
pixeldrainfs         pixeldrain

e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> q

Usage without account

It is possible to gain read-only access to publicly shared directories through rclone. For this you only need a directory ID. The directory ID can be found in the URL of a shared directory, the URL will look like this https://pixeldrain.com/d/abcd1234 where abcd1234 is the directory ID. Directory IDs in your own filesystem can also be listed with the lsf command:

rclone lsf Pixeldrain: --dirs-only -Fpi

This will print directories in your Pixeldrain home directory and their public IDs.

Enter this directory ID in the rclone config and you will be able to access the directory.

Standard options

Here are the Standard options specific to pixeldrain (Pixeldrain Filesystem).

--pixeldrain-api-key

API key for your pixeldrain account. Found on https://pixeldrain.com/user/api_keys.

Properties:

  • Config: api_key
  • Env Var: RCLONE_PIXELDRAIN_API_KEY
  • Type: string
  • Required: false

--pixeldrain-root-folder-id

Root of the filesystem to use.

Set to 'me' to use your personal filesystem. Set to a shared directory ID to use a shared directory.

Properties:

  • Config: root_folder_id
  • Env Var: RCLONE_PIXELDRAIN_ROOT_FOLDER_ID
  • Type: string
  • Default: "me"

Advanced options

Here are the Advanced options specific to pixeldrain (Pixeldrain Filesystem).

--pixeldrain-api-url

The API endpoint to connect to. In the vast majority of cases it's fine to leave this at default. It is only intended to be changed for testing purposes.

Properties:

  • Config: api_url
  • Env Var: RCLONE_PIXELDRAIN_API_URL
  • Type: string
  • Default: "https://pixeldrain.com/api"

--pixeldrain-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_PIXELDRAIN_DESCRIPTION
  • Type: string
  • Required: false

Metadata

Pixeldrain supports file modes and creation times.

Here are the possible system metadata items for the pixeldrain backend.

Name Help Type Example Read Only
btime Time of file birth (creation) RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N
mode File mode octal, unix style 755 N
mtime Time of last modification RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N

See the metadata docs for more info.

premiumize.me

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Configuration

The initial setup for premiumize.me involves getting a token from premiumize.me which you need to do in your browser. rclone config walks you through it.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / premiumize.me
   \ "premiumizeme"
[snip]
Storage> premiumizeme
** See help for premiumizeme backend at: https://rclone.org/premiumizeme/ **

Remote config
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y) Yes
n) No
y/n> y
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth
Log in and authorize rclone for access
Waiting for code...
Got code
Configuration complete.
Options:
- type: premiumizeme
- token: {"access_token":"XXX","token_type":"Bearer","refresh_token":"XXX","expiry":"2029-08-07T18:44:15.548915378+01:00"}
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d>

See the remote setup docs for how to set it up on a machine with no Internet browser available.

Note that rclone runs a webserver on your local machine to collect the token as returned from premiumize.me. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall.

Once configured you can then use rclone like this,

List directories in top level of your premiumize.me

rclone lsd remote:

List all the files in your premiumize.me

rclone ls remote:

To copy a local directory to an premiumize.me directory called backup

rclone copy /home/source remote:backup

Modification times and hashes

premiumize.me does not support modification times or hashes, therefore syncing will default to --size-only checking. Note that using --update will work.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
\ 0x5C ＼
" 0x22 ＂

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Standard options

Here are the Standard options specific to premiumizeme (premiumize.me).

--premiumizeme-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_PREMIUMIZEME_CLIENT_ID
  • Type: string
  • Required: false

--premiumizeme-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_PREMIUMIZEME_CLIENT_SECRET
  • Type: string
  • Required: false

--premiumizeme-api-key

API Key.

This is not normally used - use oauth instead.

Properties:

  • Config: api_key
  • Env Var: RCLONE_PREMIUMIZEME_API_KEY
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to premiumizeme (premiumize.me).

--premiumizeme-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_PREMIUMIZEME_TOKEN
  • Type: string
  • Required: false

--premiumizeme-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_PREMIUMIZEME_AUTH_URL
  • Type: string
  • Required: false

--premiumizeme-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_PREMIUMIZEME_TOKEN_URL
  • Type: string
  • Required: false

--premiumizeme-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_PREMIUMIZEME_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--premiumizeme-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_PREMIUMIZEME_ENCODING
  • Type: Encoding
  • Default: Slash,DoubleQuote,BackSlash,Del,Ctl,InvalidUtf8,Dot

--premiumizeme-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_PREMIUMIZEME_DESCRIPTION
  • Type: string
  • Required: false

Limitations

Note that premiumize.me is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc".

premiumize.me file names can't have the \ or " characters in. rclone maps these to and from an identical looking unicode equivalents ＼ and ＂

premiumize.me only supports filenames up to 255 characters in length.

Proton Drive

Proton Drive is an end-to-end encrypted Swiss vault for your files that protects your data.

This is an rclone backend for Proton Drive which supports the file transfer features of Proton Drive using the same client-side encryption.

Due to the fact that Proton Drive doesn't publish its API documentation, this backend is implemented with best efforts by reading the open-sourced client source code and observing the Proton Drive traffic in the browser.

NB This backend is currently in Beta. It is believed to be correct and all the integration tests pass. However the Proton Drive protocol has evolved over time there may be accounts it is not compatible with. Please post on the rclone forum if you find an incompatibility.

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Configurations

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Proton Drive
   \ "protondrive"
[snip]
Storage> protondrive
User name
user> you@protonmail.com
Password.
y) Yes type in my own password
g) Generate random password
n) No leave this optional password blank
y/g/n> y
Enter the password:
password:
Confirm the password:
password:
Option 2fa.
2FA code (if the account requires one)
Enter a value. Press Enter to leave empty.
2fa> 123456
Remote config
Configuration complete.
Options:
- type: protondrive
- user: you@protonmail.com
- pass: *** ENCRYPTED ***
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

NOTE: The Proton Drive encryption keys need to have been already generated after a regular login via the browser, otherwise attempting to use the credentials in rclone will fail.

Once configured you can then use rclone like this,

List directories in top level of your Proton Drive

rclone lsd remote:

List all the files in your Proton Drive

rclone ls remote:

To copy a local directory to an Proton Drive directory called backup

rclone copy /home/source remote:backup

Modification times and hashes

Proton Drive Bridge does not support updating modification times yet.

The SHA1 hash algorithm is supported.

Restricted filename characters

Invalid UTF-8 bytes will be replaced, also left and right spaces will be removed (code reference)

Duplicated files

Proton Drive can not have two files with exactly the same name and path. If the conflict occurs, depending on the advanced config, the file might or might not be overwritten.

Mailbox password

Please set your mailbox password in the advanced config section.

Caching

The cache is currently built for the case when the rclone is the only instance performing operations to the mount point. The event system, which is the proton API system that provides visibility of what has changed on the drive, is yet to be implemented, so updates from other clients won’t be reflected in the cache. Thus, if there are concurrent clients accessing the same mount point, then we might have a problem with caching the stale data.

Standard options

Here are the Standard options specific to protondrive (Proton Drive).

--protondrive-username

The username of your proton account

Properties:

  • Config: username
  • Env Var: RCLONE_PROTONDRIVE_USERNAME
  • Type: string
  • Required: true

--protondrive-password

The password of your proton account.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: password
  • Env Var: RCLONE_PROTONDRIVE_PASSWORD
  • Type: string
  • Required: true

--protondrive-2fa

The 2FA code

The value can also be provided with --protondrive-2fa=000000

The 2FA code of your proton drive account if the account is set up with two-factor authentication

Properties:

  • Config: 2fa
  • Env Var: RCLONE_PROTONDRIVE_2FA
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to protondrive (Proton Drive).

--protondrive-mailbox-password

The mailbox password of your two-password proton account.

For more information regarding the mailbox password, please check the following official knowledge base article: https://proton.me/support/the-difference-between-the-mailbox-password-and-login-password

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: mailbox_password
  • Env Var: RCLONE_PROTONDRIVE_MAILBOX_PASSWORD
  • Type: string
  • Required: false

--protondrive-client-uid

Client uid key (internal use only)

Properties:

  • Config: client_uid
  • Env Var: RCLONE_PROTONDRIVE_CLIENT_UID
  • Type: string
  • Required: false

--protondrive-client-access-token

Client access token key (internal use only)

Properties:

  • Config: client_access_token
  • Env Var: RCLONE_PROTONDRIVE_CLIENT_ACCESS_TOKEN
  • Type: string
  • Required: false

--protondrive-client-refresh-token

Client refresh token key (internal use only)

Properties:

  • Config: client_refresh_token
  • Env Var: RCLONE_PROTONDRIVE_CLIENT_REFRESH_TOKEN
  • Type: string
  • Required: false

--protondrive-client-salted-key-pass

Client salted key pass key (internal use only)

Properties:

  • Config: client_salted_key_pass
  • Env Var: RCLONE_PROTONDRIVE_CLIENT_SALTED_KEY_PASS
  • Type: string
  • Required: false

--protondrive-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_PROTONDRIVE_ENCODING
  • Type: Encoding
  • Default: Slash,LeftSpace,RightSpace,InvalidUtf8,Dot

--protondrive-original-file-size

Return the file size before encryption

The size of the encrypted file will be different from (bigger than) the original file size. Unless there is a reason to return the file size after encryption is performed, otherwise, set this option to true, as features like Open() which will need to be supplied with original content size, will fail to operate properly

Properties:

  • Config: original_file_size
  • Env Var: RCLONE_PROTONDRIVE_ORIGINAL_FILE_SIZE
  • Type: bool
  • Default: true

--protondrive-app-version

The app version string

The app version string indicates the client that is currently performing the API request. This information is required and will be sent with every API request.

Properties:

  • Config: app_version
  • Env Var: RCLONE_PROTONDRIVE_APP_VERSION
  • Type: string
  • Default: "macos-drive@1.0.0-alpha.1+rclone"

--protondrive-replace-existing-draft

Create a new revision when filename conflict is detected

When a file upload is cancelled or failed before completion, a draft will be created and the subsequent upload of the same file to the same location will be reported as a conflict.

The value can also be set by --protondrive-replace-existing-draft=true

If the option is set to true, the draft will be replaced and then the upload operation will restart. If there are other clients also uploading at the same file location at the same time, the behavior is currently unknown. Need to set to true for integration tests. If the option is set to false, an error "a draft exist - usually this means a file is being uploaded at another client, or, there was a failed upload attempt" will be returned, and no upload will happen.

Properties:

  • Config: replace_existing_draft
  • Env Var: RCLONE_PROTONDRIVE_REPLACE_EXISTING_DRAFT
  • Type: bool
  • Default: false

--protondrive-enable-caching

Caches the files and folders metadata to reduce API calls

Notice: If you are mounting ProtonDrive as a VFS, please disable this feature, as the current implementation doesn't update or clear the cache when there are external changes.

The files and folders on ProtonDrive are represented as links with keyrings, which can be cached to improve performance and be friendly to the API server.

The cache is currently built for the case when the rclone is the only instance performing operations to the mount point. The event system, which is the proton API system that provides visibility of what has changed on the drive, is yet to be implemented, so updates from other clients won’t be reflected in the cache. Thus, if there are concurrent clients accessing the same mount point, then we might have a problem with caching the stale data.

Properties:

  • Config: enable_caching
  • Env Var: RCLONE_PROTONDRIVE_ENABLE_CACHING
  • Type: bool
  • Default: true

--protondrive-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_PROTONDRIVE_DESCRIPTION
  • Type: string
  • Required: false

Limitations

This backend uses the Proton-API-Bridge, which is based on go-proton-api, a fork of the official repo.

There is no official API documentation available from Proton Drive. But, thanks to Proton open sourcing proton-go-api and the web, iOS, and Android client codebases, we don't need to completely reverse engineer the APIs by observing the web client traffic!

proton-go-api provides the basic building blocks of API calls and error handling, such as 429 exponential back-off, but it is pretty much just a barebone interface to the Proton API. For example, the encryption and decryption of the Proton Drive file are not provided in this library.

The Proton-API-Bridge, attempts to bridge the gap, so rclone can be built on top of this quickly. This codebase handles the intricate tasks before and after calling Proton APIs, particularly the complex encryption scheme, allowing developers to implement features for other software on top of this codebase. There are likely quite a few errors in this library, as there isn't official documentation available.

put.io

Paths are specified as remote:path

put.io paths may be as deep as required, e.g. remote:directory/subdirectory.

Configuration

The initial setup for put.io involves getting a token from put.io which you need to do in your browser. rclone config walks you through it.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> putio
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Put.io
   \ "putio"
[snip]
Storage> putio
** See help for putio backend at: https://rclone.org/putio/ **

Remote config
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y) Yes
n) No
y/n> y
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth
Log in and authorize rclone for access
Waiting for code...
Got code
--------------------
[putio]
type = putio
token = {"access_token":"XXXXXXXX","expiry":"0001-01-01T00:00:00Z"}
--------------------
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y
Current remotes:

Name                 Type
====                 ====
putio                putio

e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> q

See the remote setup docs for how to set it up on a machine with no Internet browser available.

Note that rclone runs a webserver on your local machine to collect the token as returned from put.io if using web browser to automatically authenticate. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall, or use manual mode.

You can then use it like this,

List directories in top level of your put.io

rclone lsd remote:

List all the files in your put.io

rclone ls remote:

To copy a local directory to a put.io directory called backup

rclone copy /home/source remote:backup

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
\ 0x5C ＼

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Standard options

Here are the Standard options specific to putio (Put.io).

--putio-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_PUTIO_CLIENT_ID
  • Type: string
  • Required: false

--putio-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_PUTIO_CLIENT_SECRET
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to putio (Put.io).

--putio-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_PUTIO_TOKEN
  • Type: string
  • Required: false

--putio-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_PUTIO_AUTH_URL
  • Type: string
  • Required: false

--putio-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_PUTIO_TOKEN_URL
  • Type: string
  • Required: false

--putio-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_PUTIO_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--putio-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_PUTIO_ENCODING
  • Type: Encoding
  • Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot

--putio-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_PUTIO_DESCRIPTION
  • Type: string
  • Required: false

Limitations

put.io has rate limiting. When you hit a limit, rclone automatically retries after waiting the amount of time requested by the server.

If you want to avoid ever hitting these limits, you may use the --tpslimit flag with a low number. Note that the imposed limits may be different for different operations, and may change over time.

Proton Drive

Proton Drive is an end-to-end encrypted Swiss vault for your files that protects your data.

This is an rclone backend for Proton Drive which supports the file transfer features of Proton Drive using the same client-side encryption.

Due to the fact that Proton Drive doesn't publish its API documentation, this backend is implemented with best efforts by reading the open-sourced client source code and observing the Proton Drive traffic in the browser.

NB This backend is currently in Beta. It is believed to be correct and all the integration tests pass. However the Proton Drive protocol has evolved over time there may be accounts it is not compatible with. Please post on the rclone forum if you find an incompatibility.

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Configurations

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Proton Drive
   \ "protondrive"
[snip]
Storage> protondrive
User name
user> you@protonmail.com
Password.
y) Yes type in my own password
g) Generate random password
n) No leave this optional password blank
y/g/n> y
Enter the password:
password:
Confirm the password:
password:
Option 2fa.
2FA code (if the account requires one)
Enter a value. Press Enter to leave empty.
2fa> 123456
Remote config
Configuration complete.
Options:
- type: protondrive
- user: you@protonmail.com
- pass: *** ENCRYPTED ***
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

NOTE: The Proton Drive encryption keys need to have been already generated after a regular login via the browser, otherwise attempting to use the credentials in rclone will fail.

Once configured you can then use rclone like this,

List directories in top level of your Proton Drive

rclone lsd remote:

List all the files in your Proton Drive

rclone ls remote:

To copy a local directory to an Proton Drive directory called backup

rclone copy /home/source remote:backup

Modification times and hashes

Proton Drive Bridge does not support updating modification times yet.

The SHA1 hash algorithm is supported.

Restricted filename characters

Invalid UTF-8 bytes will be replaced, also left and right spaces will be removed (code reference)

Duplicated files

Proton Drive can not have two files with exactly the same name and path. If the conflict occurs, depending on the advanced config, the file might or might not be overwritten.

Mailbox password

Please set your mailbox password in the advanced config section.

Caching

The cache is currently built for the case when the rclone is the only instance performing operations to the mount point. The event system, which is the proton API system that provides visibility of what has changed on the drive, is yet to be implemented, so updates from other clients won’t be reflected in the cache. Thus, if there are concurrent clients accessing the same mount point, then we might have a problem with caching the stale data.

Standard options

Here are the Standard options specific to protondrive (Proton Drive).

--protondrive-username

The username of your proton account

Properties:

  • Config: username
  • Env Var: RCLONE_PROTONDRIVE_USERNAME
  • Type: string
  • Required: true

--protondrive-password

The password of your proton account.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: password
  • Env Var: RCLONE_PROTONDRIVE_PASSWORD
  • Type: string
  • Required: true

--protondrive-2fa

The 2FA code

The value can also be provided with --protondrive-2fa=000000

The 2FA code of your proton drive account if the account is set up with two-factor authentication

Properties:

  • Config: 2fa
  • Env Var: RCLONE_PROTONDRIVE_2FA
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to protondrive (Proton Drive).

--protondrive-mailbox-password

The mailbox password of your two-password proton account.

For more information regarding the mailbox password, please check the following official knowledge base article: https://proton.me/support/the-difference-between-the-mailbox-password-and-login-password

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: mailbox_password
  • Env Var: RCLONE_PROTONDRIVE_MAILBOX_PASSWORD
  • Type: string
  • Required: false

--protondrive-client-uid

Client uid key (internal use only)

Properties:

  • Config: client_uid
  • Env Var: RCLONE_PROTONDRIVE_CLIENT_UID
  • Type: string
  • Required: false

--protondrive-client-access-token

Client access token key (internal use only)

Properties:

  • Config: client_access_token
  • Env Var: RCLONE_PROTONDRIVE_CLIENT_ACCESS_TOKEN
  • Type: string
  • Required: false

--protondrive-client-refresh-token

Client refresh token key (internal use only)

Properties:

  • Config: client_refresh_token
  • Env Var: RCLONE_PROTONDRIVE_CLIENT_REFRESH_TOKEN
  • Type: string
  • Required: false

--protondrive-client-salted-key-pass

Client salted key pass key (internal use only)

Properties:

  • Config: client_salted_key_pass
  • Env Var: RCLONE_PROTONDRIVE_CLIENT_SALTED_KEY_PASS
  • Type: string
  • Required: false

--protondrive-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_PROTONDRIVE_ENCODING
  • Type: Encoding
  • Default: Slash,LeftSpace,RightSpace,InvalidUtf8,Dot

--protondrive-original-file-size

Return the file size before encryption

The size of the encrypted file will be different from (bigger than) the original file size. Unless there is a reason to return the file size after encryption is performed, otherwise, set this option to true, as features like Open() which will need to be supplied with original content size, will fail to operate properly

Properties:

  • Config: original_file_size
  • Env Var: RCLONE_PROTONDRIVE_ORIGINAL_FILE_SIZE
  • Type: bool
  • Default: true

--protondrive-app-version

The app version string

The app version string indicates the client that is currently performing the API request. This information is required and will be sent with every API request.

Properties:

  • Config: app_version
  • Env Var: RCLONE_PROTONDRIVE_APP_VERSION
  • Type: string
  • Default: "macos-drive@1.0.0-alpha.1+rclone"

--protondrive-replace-existing-draft

Create a new revision when filename conflict is detected

When a file upload is cancelled or failed before completion, a draft will be created and the subsequent upload of the same file to the same location will be reported as a conflict.

The value can also be set by --protondrive-replace-existing-draft=true

If the option is set to true, the draft will be replaced and then the upload operation will restart. If there are other clients also uploading at the same file location at the same time, the behavior is currently unknown. Need to set to true for integration tests. If the option is set to false, an error "a draft exist - usually this means a file is being uploaded at another client, or, there was a failed upload attempt" will be returned, and no upload will happen.

Properties:

  • Config: replace_existing_draft
  • Env Var: RCLONE_PROTONDRIVE_REPLACE_EXISTING_DRAFT
  • Type: bool
  • Default: false

--protondrive-enable-caching

Caches the files and folders metadata to reduce API calls

Notice: If you are mounting ProtonDrive as a VFS, please disable this feature, as the current implementation doesn't update or clear the cache when there are external changes.

The files and folders on ProtonDrive are represented as links with keyrings, which can be cached to improve performance and be friendly to the API server.

The cache is currently built for the case when the rclone is the only instance performing operations to the mount point. The event system, which is the proton API system that provides visibility of what has changed on the drive, is yet to be implemented, so updates from other clients won’t be reflected in the cache. Thus, if there are concurrent clients accessing the same mount point, then we might have a problem with caching the stale data.

Properties:

  • Config: enable_caching
  • Env Var: RCLONE_PROTONDRIVE_ENABLE_CACHING
  • Type: bool
  • Default: true

--protondrive-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_PROTONDRIVE_DESCRIPTION
  • Type: string
  • Required: false

Limitations

This backend uses the Proton-API-Bridge, which is based on go-proton-api, a fork of the official repo.

There is no official API documentation available from Proton Drive. But, thanks to Proton open sourcing proton-go-api and the web, iOS, and Android client codebases, we don't need to completely reverse engineer the APIs by observing the web client traffic!

proton-go-api provides the basic building blocks of API calls and error handling, such as 429 exponential back-off, but it is pretty much just a barebone interface to the Proton API. For example, the encryption and decryption of the Proton Drive file are not provided in this library.

The Proton-API-Bridge, attempts to bridge the gap, so rclone can be built on top of this quickly. This codebase handles the intricate tasks before and after calling Proton APIs, particularly the complex encryption scheme, allowing developers to implement features for other software on top of this codebase. There are likely quite a few errors in this library, as there isn't official documentation available.

Seafile

This is a backend for the Seafile storage service: - It works with both the free community edition or the professional edition. - Seafile versions 6.x, 7.x, 8.x and 9.x are all supported. - Encrypted libraries are also supported. - It supports 2FA enabled users - Using a Library API Token is not supported

Configuration

There are two distinct modes you can setup your remote: - you point your remote to the root of the server, meaning you don't specify a library during the configuration: Paths are specified as remote:library. You may put subdirectories in too, e.g. remote:library/path/to/dir. - you point your remote to a specific library during the configuration: Paths are specified as remote:path/to/dir. This is the recommended mode when using encrypted libraries. (This mode is possibly slightly faster than the root mode)

Configuration in root mode

Here is an example of making a seafile configuration for a user with no two-factor authentication. First run

rclone config

This will guide you through an interactive setup process. To authenticate you will need the URL of your server, your email (or username) and your password.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> seafile
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Seafile
   \ "seafile"
[snip]
Storage> seafile
** See help for seafile backend at: https://rclone.org/seafile/ **

URL of seafile host to connect to
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / Connect to cloud.seafile.com
   \ "https://cloud.seafile.com/"
url> http://my.seafile.server/
User name (usually email address)
Enter a string value. Press Enter for the default ("").
user> me@example.com
Password
y) Yes type in my own password
g) Generate random password
n) No leave this optional password blank (default)
y/g> y
Enter the password:
password:
Confirm the password:
password:
Two-factor authentication ('true' if the account has 2FA enabled)
Enter a boolean value (true or false). Press Enter for the default ("false").
2fa> false
Name of the library. Leave blank to access all non-encrypted libraries.
Enter a string value. Press Enter for the default ("").
library>
Library password (for encrypted libraries only). Leave blank if you pass it through the command line.
y) Yes type in my own password
g) Generate random password
n) No leave this optional password blank (default)
y/g/n> n
Edit advanced config? (y/n)
y) Yes
n) No (default)
y/n> n
Remote config
Two-factor authentication is not enabled on this account.
--------------------
[seafile]
type = seafile
url = http://my.seafile.server/
user = me@example.com
pass = *** ENCRYPTED ***
2fa = false
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

This remote is called seafile. It's pointing to the root of your seafile server and can now be used like this:

See all libraries

rclone lsd seafile:

Create a new library

rclone mkdir seafile:library

List the contents of a library

rclone ls seafile:library

Sync /home/local/directory to the remote library, deleting any excess files in the library.

rclone sync --interactive /home/local/directory seafile:library

Configuration in library mode

Here's an example of a configuration in library mode with a user that has the two-factor authentication enabled. Your 2FA code will be asked at the end of the configuration, and will attempt to authenticate you:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> seafile
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Seafile
   \ "seafile"
[snip]
Storage> seafile
** See help for seafile backend at: https://rclone.org/seafile/ **

URL of seafile host to connect to
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
 1 / Connect to cloud.seafile.com
   \ "https://cloud.seafile.com/"
url> http://my.seafile.server/
User name (usually email address)
Enter a string value. Press Enter for the default ("").
user> me@example.com
Password
y) Yes type in my own password
g) Generate random password
n) No leave this optional password blank (default)
y/g> y
Enter the password:
password:
Confirm the password:
password:
Two-factor authentication ('true' if the account has 2FA enabled)
Enter a boolean value (true or false). Press Enter for the default ("false").
2fa> true
Name of the library. Leave blank to access all non-encrypted libraries.
Enter a string value. Press Enter for the default ("").
library> My Library
Library password (for encrypted libraries only). Leave blank if you pass it through the command line.
y) Yes type in my own password
g) Generate random password
n) No leave this optional password blank (default)
y/g/n> n
Edit advanced config? (y/n)
y) Yes
n) No (default)
y/n> n
Remote config
Two-factor authentication: please enter your 2FA code
2fa code> 123456
Authenticating...
Success!
--------------------
[seafile]
type = seafile
url = http://my.seafile.server/
user = me@example.com
pass = 
2fa = true
library = My Library
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

You'll notice your password is blank in the configuration. It's because we only need the password to authenticate you once.

You specified My Library during the configuration. The root of the remote is pointing at the root of the library My Library:

See all files in the library:

rclone lsd seafile:

Create a new directory inside the library

rclone mkdir seafile:directory

List the contents of a directory

rclone ls seafile:directory

Sync /home/local/directory to the remote library, deleting any excess files in the library.

rclone sync --interactive /home/local/directory seafile:

--fast-list

Seafile version 7+ supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details. Please note this is not supported on seafile server version 6.x

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
/ 0x2F ／
" 0x22 ＂
\ 0x5C ＼

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Rclone supports generating share links for non-encrypted libraries only. They can either be for a file or a directory:

rclone link seafile:seafile-tutorial.doc
http://my.seafile.server/f/fdcd8a2f93f84b8b90f4/

or if run on a directory you will get:

rclone link seafile:dir
http://my.seafile.server/d/9ea2455f6f55478bbb0d/

Please note a share link is unique for each file or directory. If you run a link command on a file/dir that has already been shared, you will get the exact same link.

Compatibility

It has been actively developed using the seafile docker image of these versions: - 6.3.4 community edition - 7.0.5 community edition - 7.1.3 community edition - 9.0.10 community edition

Versions below 6.0 are not supported. Versions between 6.0 and 6.3 haven't been tested and might not work properly.

Each new version of rclone is automatically tested against the latest docker image of the seafile community server.

Standard options

Here are the Standard options specific to seafile (seafile).

--seafile-url

URL of seafile host to connect to.

Properties:

  • Config: url
  • Env Var: RCLONE_SEAFILE_URL
  • Type: string
  • Required: true
  • Examples:
    • "https://cloud.seafile.com/"
      • Connect to cloud.seafile.com.

--seafile-user

User name (usually email address).

Properties:

  • Config: user
  • Env Var: RCLONE_SEAFILE_USER
  • Type: string
  • Required: true

--seafile-pass

Password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: pass
  • Env Var: RCLONE_SEAFILE_PASS
  • Type: string
  • Required: false

--seafile-2fa

Two-factor authentication ('true' if the account has 2FA enabled).

Properties:

  • Config: 2fa
  • Env Var: RCLONE_SEAFILE_2FA
  • Type: bool
  • Default: false

--seafile-library

Name of the library.

Leave blank to access all non-encrypted libraries.

Properties:

  • Config: library
  • Env Var: RCLONE_SEAFILE_LIBRARY
  • Type: string
  • Required: false

--seafile-library-key

Library password (for encrypted libraries only).

Leave blank if you pass it through the command line.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: library_key
  • Env Var: RCLONE_SEAFILE_LIBRARY_KEY
  • Type: string
  • Required: false

--seafile-auth-token

Authentication token.

Properties:

  • Config: auth_token
  • Env Var: RCLONE_SEAFILE_AUTH_TOKEN
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to seafile (seafile).

--seafile-create-library

Should rclone create a library if it doesn't exist.

Properties:

  • Config: create_library
  • Env Var: RCLONE_SEAFILE_CREATE_LIBRARY
  • Type: bool
  • Default: false

--seafile-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_SEAFILE_ENCODING
  • Type: Encoding
  • Default: Slash,DoubleQuote,BackSlash,Ctl,InvalidUtf8,Dot

--seafile-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_SEAFILE_DESCRIPTION
  • Type: string
  • Required: false

SFTP

SFTP is the Secure (or SSH) File Transfer Protocol.

The SFTP backend can be used with a number of different providers:

  • Hetzner Storage Box
  • rsync.net

SFTP runs over SSH v2 and is installed as standard with most modern SSH installations.

Paths are specified as remote:path. If the path does not begin with a / it is relative to the home directory of the user. An empty path remote: refers to the user's home directory. For example, rclone lsd remote: would list the home directory of the user configured in the rclone remote config (i.e /home/sftpuser). However, rclone lsd remote:/ would list the root directory for remote machine (i.e. /)

Note that some SFTP servers will need the leading / - Synology is a good example of this. rsync.net and Hetzner, on the other hand, requires users to OMIT the leading /.

Note that by default rclone will try to execute shell commands on the server, see shell access considerations.

Configuration

Here is an example of making an SFTP configuration. First run

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / SSH/SFTP
   \ "sftp"
[snip]
Storage> sftp
SSH host to connect to
Choose a number from below, or type in your own value
 1 / Connect to example.com
   \ "example.com"
host> example.com
SSH username
Enter a string value. Press Enter for the default ("$USER").
user> sftpuser
SSH port number
Enter a signed integer. Press Enter for the default (22).
port>
SSH password, leave blank to use ssh-agent.
y) Yes type in my own password
g) Generate random password
n) No leave this optional password blank
y/g/n> n
Path to unencrypted PEM-encoded private key file, leave blank to use ssh-agent.
key_file>
Remote config
Configuration complete.
Options:
- type: sftp
- host: example.com
- user: sftpuser
- port:
- pass:
- key_file:
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

This remote is called remote and can now be used like this:

See all directories in the home directory

rclone lsd remote:

See all directories in the root directory

rclone lsd remote:/

Make a new directory

rclone mkdir remote:path/to/directory

List the contents of a directory

rclone ls remote:path/to/directory

Sync /home/local/directory to the remote directory, deleting any excess files in the directory.

rclone sync --interactive /home/local/directory remote:directory

Mount the remote path /srv/www-data/ to the local path /mnt/www-data

rclone mount remote:/srv/www-data/ /mnt/www-data

SSH Authentication

The SFTP remote supports three authentication methods:

  • Password
  • Key file, including certificate signed keys
  • ssh-agent

Key files should be PEM-encoded private key files. For instance /home/$USER/.ssh/id_rsa. Only unencrypted OpenSSH or PEM encrypted files are supported.

The key file can be specified in either an external file (key_file) or contained within the rclone config file (key_pem). If using key_pem in the config file, the entry should be on a single line with new line ('' or '') separating lines. i.e.

key_pem = -----BEGIN RSA PRIVATE KEY-----\nMaMbaIXtE\n0gAMbMbaSsd\nMbaass\n-----END RSA PRIVATE KEY-----

This will generate it correctly for key_pem for use in the config:

awk '{printf "%s\\n", $0}' < ~/.ssh/id_rsa

If you don't specify pass, key_file, or key_pem or ask_password then rclone will attempt to contact an ssh-agent. You can also specify key_use_agent to force the usage of an ssh-agent. In this case key_file or key_pem can also be specified to force the usage of a specific key in the ssh-agent.

Using an ssh-agent is the only way to load encrypted OpenSSH keys at the moment.

If you set the ask_password option, rclone will prompt for a password when needed and no password has been configured.

Certificate-signed keys

With traditional key-based authentication, you configure your private key only, and the public key built into it will be used during the authentication process.

If you have a certificate you may use it to sign your public key, creating a separate SSH user certificate that should be used instead of the plain public key extracted from the private key. Then you must provide the path to the user certificate public key file in pubkey_file or the content of the file in pubkey.

Note: This is not the traditional public key paired with your private key, typically saved as /home/$USER/.ssh/id_rsa.pub. Setting this path in pubkey_file will not work.

Example:

[remote]
type = sftp
host = example.com
user = sftpuser
key_file = ~/id_rsa
pubkey_file = ~/id_rsa-cert.pub

If you concatenate a cert with a private key then you can specify the merged file in both places.

Note: the cert must come first in the file. e.g.

cat id_rsa-cert.pub id_rsa > merged_key

Host key validation

By default rclone will not check the server's host key for validation. This can allow an attacker to replace a server with their own and if you use password authentication then this can lead to that password being exposed.

Host key matching, using standard known_hosts files can be turned on by enabling the known_hosts_file option. This can point to the file maintained by OpenSSH or can point to a unique file.

e.g. using the OpenSSH known_hosts file:

[remote]
type = sftp
host = example.com
user = sftpuser
pass = 
known_hosts_file = ~/.ssh/known_hosts

Alternatively you can create your own known hosts file like this:

ssh-keyscan -t dsa,rsa,ecdsa,ed25519 example.com >> known_hosts

There are some limitations:

  • rclone will not manage this file for you. If the key is missing or wrong then the connection will be refused.
  • If the server is set up for a certificate host key then the entry in the known_hosts file must be the @cert-authority entry for the CA

If the host key provided by the server does not match the one in the file (or is missing) then the connection will be aborted and an error returned such as

NewFs: couldn't connect SSH: ssh: handshake failed: knownhosts: key mismatch

or

NewFs: couldn't connect SSH: ssh: handshake failed: knownhosts: key is unknown

If you see an error such as

NewFs: couldn't connect SSH: ssh: handshake failed: ssh: no authorities for hostname: example.com:22

then it is likely the server has presented a CA signed host certificate and you will need to add the appropriate @cert-authority entry.

The known_hosts_file setting can be set during rclone config as an advanced option.

ssh-agent on macOS

Note that there seem to be various problems with using an ssh-agent on macOS due to recent changes in the OS. The most effective work-around seems to be to start an ssh-agent in each session, e.g.

eval `ssh-agent -s` && ssh-add -A

And then at the end of the session

eval `ssh-agent -k`

These commands can be used in scripts of course.

Shell access

Some functionality of the SFTP backend relies on remote shell access, and the possibility to execute commands. This includes checksum, and in some cases also about. The shell commands that must be executed may be different on different type of shells, and also quoting/escaping of file path arguments containing special characters may be different. Rclone therefore needs to know what type of shell it is, and if shell access is available at all.

Most servers run on some version of Unix, and then a basic Unix shell can be assumed, without further distinction. Windows 10, Server 2019, and later can also run a SSH server, which is a port of OpenSSH (see official installation guide). On a Windows server the shell handling is different: Although it can also be set up to use a Unix type shell, e.g. Cygwin bash, the default is to use Windows Command Prompt (cmd.exe), and PowerShell is a recommended alternative. All of these have behave differently, which rclone must handle.

Rclone tries to auto-detect what type of shell is used on the server, first time you access the SFTP remote. If a remote shell session is successfully created, it will look for indications that it is CMD or PowerShell, with fall-back to Unix if not something else is detected. If unable to even create a remote shell session, then shell command execution will be disabled entirely. The result is stored in the SFTP remote configuration, in option shell_type, so that the auto-detection only have to be performed once. If you manually set a value for this option before first run, the auto-detection will be skipped, and if you set a different value later this will override any existing. Value none can be set to avoid any attempts at executing shell commands, e.g. if this is not allowed on the server. If you have shell_type = none in the configuration then the ssh must not be set.

When the server is rclone serve sftp, the rclone SFTP remote will detect this as a Unix type shell - even if it is running on Windows. This server does not actually have a shell, but it accepts input commands matching the specific ones that the SFTP backend relies on for Unix shells, e.g. md5sum and df. Also it handles the string escape rules used for Unix shell. Treating it as a Unix type shell from a SFTP remote will therefore always be correct, and support all features.

Shell access considerations

The shell type auto-detection logic, described above, means that by default rclone will try to run a shell command the first time a new sftp remote is accessed. If you configure a sftp remote without a config file, e.g. an on the fly remote, rclone will have nowhere to store the result, and it will re-run the command on every access. To avoid this you should explicitly set the shell_type option to the correct value, or to none if you want to prevent rclone from executing any remote shell commands.

It is also important to note that, since the shell type decides how quoting and escaping of file paths used as command-line arguments are performed, configuring the wrong shell type may leave you exposed to command injection exploits. Make sure to confirm the auto-detected shell type, or explicitly set the shell type you know is correct, or disable shell access until you know.

Checksum

SFTP does not natively support checksums (file hash), but rclone is able to use checksumming if the same login has shell access, and can execute remote commands. If there is a command that can calculate compatible checksums on the remote system, Rclone can then be configured to execute this whenever a checksum is needed, and read back the results. By default MD5 and SHA-1 are considered, but also CRC32, SHA-256, BLAKE3, XXH3 and XXH128 are supported, option hashes can be set to specify which to consider.

Normally this requires an external utility being available on the server. E.g. for MD5 checksums, by default rclone will try commands md5sum, md5 and rclone md5sum, and the first one found usable will be picked. These utilities normally need to be in the remote's PATH to be found.

In some cases the shell itself is capable of calculating checksums. PowerShell is an example of such a shell. If rclone detects that the remote shell is PowerShell, which means it most probably is a Windows OpenSSH server, rclone will use a predefined script block to produce the checksums for MD5, SHA-1 and SHA-256 when no external checksum commands are found (see shell access). This assumes PowerShell version 4.0 or newer.

The options md5sum_command, sha1_command, etc. can be used to customize the commands to be executed for calculation of checksums. You can for example set a specific path to where the md5sum executable are located, or specify some other tool that print checksums in compatible format. The value can include command-line arguments, or even shell script blocks as with PowerShell. Rclone has subcommands hashsum, md5sum and sha1sum that use compatible format, which means if you have an rclone executable on the server it can be used. As mentioned above, they will be automatically picked up if found in PATH, but if not you can set something like /path/to/rclone md5sum as the value of option md5sum_command to make sure a specific executable is used.

Remote checksumming is recommended and enabled by default. First time rclone is using a SFTP remote, if options md5sum_command or sha1_command are not set, it will check if any of the default commands for each of them, as described above, can be used. The result will be saved in the remote configuration, so next time it will use the same. Value none will be set if none of the default commands could be used for a specific algorithm, and this algorithm will not be supported by the remote.

Disabling the checksumming completely may be required if you are connecting to SFTP servers which are not under your control, and to which the execution of remote shell commands is prohibited. Set the configuration option disable_hashcheck to true to disable checksumming entirely (you get the same effect by setting option hashes to none or options md5sum_command, sha1_command etc. to none). Set option shell_type to none to not only disable checksumming, but also disable all other functionality that are based on remote shell command execution.

Modification times and hashes

Modified times are stored on the server to 1 second precision.

Modified times are used in syncing and are fully supported.

Some SFTP servers disable setting/modifying the file modification time after upload (for example, certain configurations of ProFTPd with mod_sftp). If you are using one of these servers, you can set the option set_modtime = false in your RClone backend configuration to disable this behaviour.

About command

The about command returns the total space, free space, and used space on the remote for the disk of the specified path on the remote or, if not set, the disk of the root on the remote.

SFTP usually supports the about command, but it depends on the server. If the server implements the vendor-specific VFS statistics extension, which is normally the case with OpenSSH instances, it will be used. If not, but the same login has access to a Unix shell, where the df command is available (e.g. in the remote's PATH), then this will be used instead. If the server shell is PowerShell, probably with a Windows OpenSSH server, rclone will use a built-in shell command (see shell access). If none of the above is applicable, about will fail.

Standard options

Here are the Standard options specific to sftp (SSH/SFTP).

--sftp-host

SSH host to connect to.

E.g. "example.com".

Properties:

  • Config: host
  • Env Var: RCLONE_SFTP_HOST
  • Type: string
  • Required: true

--sftp-user

SSH username.

Properties:

  • Config: user
  • Env Var: RCLONE_SFTP_USER
  • Type: string
  • Default: "$USER"

--sftp-port

SSH port number.

Properties:

  • Config: port
  • Env Var: RCLONE_SFTP_PORT
  • Type: int
  • Default: 22

--sftp-pass

SSH password, leave blank to use ssh-agent.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: pass
  • Env Var: RCLONE_SFTP_PASS
  • Type: string
  • Required: false

--sftp-key-pem

Raw PEM-encoded private key.

Note that this should be on a single line with line endings replaced with '', eg

key_pem = -----BEGIN RSA PRIVATE KEY-----\nMaMbaIXtE\n0gAMbMbaSsd\nMbaass\n-----END RSA PRIVATE KEY-----

This will generate the single line correctly:

awk '{printf "%s\\n", $0}' < ~/.ssh/id_rsa

If specified, it will override the key_file parameter.

Properties:

  • Config: key_pem
  • Env Var: RCLONE_SFTP_KEY_PEM
  • Type: string
  • Required: false

--sftp-key-file

Path to PEM-encoded private key file.

Leave blank or set key-use-agent to use ssh-agent.

Leading ~ will be expanded in the file name as will environment variables such as ${RCLONE_CONFIG_DIR}.

Properties:

  • Config: key_file
  • Env Var: RCLONE_SFTP_KEY_FILE
  • Type: string
  • Required: false

--sftp-key-file-pass

The passphrase to decrypt the PEM-encoded private key file.

Only PEM encrypted key files (old OpenSSH format) are supported. Encrypted keys in the new OpenSSH format can't be used.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: key_file_pass
  • Env Var: RCLONE_SFTP_KEY_FILE_PASS
  • Type: string
  • Required: false

--sftp-pubkey

SSH public certificate for public certificate based authentication. Set this if you have a signed certificate you want to use for authentication. If specified will override pubkey_file.

Properties:

  • Config: pubkey
  • Env Var: RCLONE_SFTP_PUBKEY
  • Type: string
  • Required: false

--sftp-pubkey-file

Optional path to public key file.

Set this if you have a signed certificate you want to use for authentication.

Leading ~ will be expanded in the file name as will environment variables such as ${RCLONE_CONFIG_DIR}.

Properties:

  • Config: pubkey_file
  • Env Var: RCLONE_SFTP_PUBKEY_FILE
  • Type: string
  • Required: false

--sftp-key-use-agent

When set forces the usage of the ssh-agent.

When key-file is also set, the ".pub" file of the specified key-file is read and only the associated key is requested from the ssh-agent. This allows to avoid Too many authentication failures for *username* errors when the ssh-agent contains many keys.

Properties:

  • Config: key_use_agent
  • Env Var: RCLONE_SFTP_KEY_USE_AGENT
  • Type: bool
  • Default: false

--sftp-use-insecure-cipher

Enable the use of insecure ciphers and key exchange methods.

This enables the use of the following insecure ciphers and key exchange methods:

  • aes128-cbc
  • aes192-cbc
  • aes256-cbc
  • 3des-cbc
  • diffie-hellman-group-exchange-sha256
  • diffie-hellman-group-exchange-sha1

Those algorithms are insecure and may allow plaintext data to be recovered by an attacker.

This must be false if you use either ciphers or key_exchange advanced options.

Properties:

  • Config: use_insecure_cipher
  • Env Var: RCLONE_SFTP_USE_INSECURE_CIPHER
  • Type: bool
  • Default: false
  • Examples:
    • "false"
      • Use default Cipher list.
    • "true"
      • Enables the use of the aes128-cbc cipher and diffie-hellman-group-exchange-sha256, diffie-hellman-group-exchange-sha1 key exchange.

--sftp-disable-hashcheck

Disable the execution of SSH commands to determine if remote file hashing is available.

Leave blank or set to false to enable hashing (recommended), set to true to disable hashing.

Properties:

  • Config: disable_hashcheck
  • Env Var: RCLONE_SFTP_DISABLE_HASHCHECK
  • Type: bool
  • Default: false

--sftp-ssh

Path and arguments to external ssh binary.

Normally rclone will use its internal ssh library to connect to the SFTP server. However it does not implement all possible ssh options so it may be desirable to use an external ssh binary.

Rclone ignores all the internal config if you use this option and expects you to configure the ssh binary with the user/host/port and any other options you need.

Important The ssh command must log in without asking for a password so needs to be configured with keys or certificates.

Rclone will run the command supplied either with the additional arguments "-s sftp" to access the SFTP subsystem or with commands such as "md5sum /path/to/file" appended to read checksums.

Any arguments with spaces in should be surrounded by "double quotes".

An example setting might be:

ssh -o ServerAliveInterval=20 user@example.com

Note that when using an external ssh binary rclone makes a new ssh connection for every hash it calculates.

Properties:

  • Config: ssh
  • Env Var: RCLONE_SFTP_SSH
  • Type: SpaceSepList
  • Default:

Advanced options

Here are the Advanced options specific to sftp (SSH/SFTP).

--sftp-known-hosts-file

Optional path to known_hosts file.

Set this value to enable server host key validation.

Leading ~ will be expanded in the file name as will environment variables such as ${RCLONE_CONFIG_DIR}.

Properties:

  • Config: known_hosts_file
  • Env Var: RCLONE_SFTP_KNOWN_HOSTS_FILE
  • Type: string
  • Required: false
  • Examples:
    • "~/.ssh/known_hosts"
      • Use OpenSSH's known_hosts file.

--sftp-ask-password

Allow asking for SFTP password when needed.

If this is set and no password is supplied then rclone will: - ask for a password - not contact the ssh agent

Properties:

  • Config: ask_password
  • Env Var: RCLONE_SFTP_ASK_PASSWORD
  • Type: bool
  • Default: false

--sftp-path-override

Override path used by SSH shell commands.

This allows checksum calculation when SFTP and SSH paths are different. This issue affects among others Synology NAS boxes.

E.g. if shared folders can be found in directories representing volumes:

rclone sync /home/local/directory remote:/directory --sftp-path-override /volume2/directory

E.g. if home directory can be found in a shared folder called "home":

rclone sync /home/local/directory remote:/home/directory --sftp-path-override /volume1/homes/USER/directory

To specify only the path to the SFTP remote's root, and allow rclone to add any relative subpaths automatically (including unwrapping/decrypting remotes as necessary), add the '@' character to the beginning of the path.

E.g. the first example above could be rewritten as:

rclone sync /home/local/directory remote:/directory --sftp-path-override @/volume2

Note that when using this method with Synology "home" folders, the full "/homes/USER" path should be specified instead of "/home".

E.g. the second example above should be rewritten as:

rclone sync /home/local/directory remote:/homes/USER/directory --sftp-path-override @/volume1

Properties:

  • Config: path_override
  • Env Var: RCLONE_SFTP_PATH_OVERRIDE
  • Type: string
  • Required: false

--sftp-set-modtime

Set the modified time on the remote if set.

Properties:

  • Config: set_modtime
  • Env Var: RCLONE_SFTP_SET_MODTIME
  • Type: bool
  • Default: true

--sftp-shell-type

The type of SSH shell on remote server, if any.

Leave blank for autodetect.

Properties:

  • Config: shell_type
  • Env Var: RCLONE_SFTP_SHELL_TYPE
  • Type: string
  • Required: false
  • Examples:
    • "none"
      • No shell access
    • "unix"
      • Unix shell
    • "powershell"
      • PowerShell
    • "cmd"
      • Windows Command Prompt

--sftp-hashes

Comma separated list of supported checksum types.

Properties:

  • Config: hashes
  • Env Var: RCLONE_SFTP_HASHES
  • Type: CommaSepList
  • Default:

--sftp-md5sum-command

The command used to read MD5 hashes.

Leave blank for autodetect.

Properties:

  • Config: md5sum_command
  • Env Var: RCLONE_SFTP_MD5SUM_COMMAND
  • Type: string
  • Required: false

--sftp-sha1sum-command

The command used to read SHA-1 hashes.

Leave blank for autodetect.

Properties:

  • Config: sha1sum_command
  • Env Var: RCLONE_SFTP_SHA1SUM_COMMAND
  • Type: string
  • Required: false

--sftp-crc32sum-command

The command used to read CRC-32 hashes.

Leave blank for autodetect.

Properties:

  • Config: crc32sum_command
  • Env Var: RCLONE_SFTP_CRC32SUM_COMMAND
  • Type: string
  • Required: false

--sftp-sha256sum-command

The command used to read SHA-256 hashes.

Leave blank for autodetect.

Properties:

  • Config: sha256sum_command
  • Env Var: RCLONE_SFTP_SHA256SUM_COMMAND
  • Type: string
  • Required: false

--sftp-blake3sum-command

The command used to read BLAKE3 hashes.

Leave blank for autodetect.

Properties:

  • Config: blake3sum_command
  • Env Var: RCLONE_SFTP_BLAKE3SUM_COMMAND
  • Type: string
  • Required: false

--sftp-xxh3sum-command

The command used to read XXH3 hashes.

Leave blank for autodetect.

Properties:

  • Config: xxh3sum_command
  • Env Var: RCLONE_SFTP_XXH3SUM_COMMAND
  • Type: string
  • Required: false

--sftp-xxh128sum-command

The command used to read XXH128 hashes.

Leave blank for autodetect.

Properties:

  • Config: xxh128sum_command
  • Env Var: RCLONE_SFTP_XXH128SUM_COMMAND
  • Type: string
  • Required: false

Set to skip any symlinks and any other non regular files.

Properties:

  • Config: skip_links
  • Env Var: RCLONE_SFTP_SKIP_LINKS
  • Type: bool
  • Default: false

--sftp-subsystem

Specifies the SSH2 subsystem on the remote host.

Properties:

  • Config: subsystem
  • Env Var: RCLONE_SFTP_SUBSYSTEM
  • Type: string
  • Default: "sftp"

--sftp-server-command

Specifies the path or command to run a sftp server on the remote host.

The subsystem option is ignored when server_command is defined.

If adding server_command to the configuration file please note that it should not be enclosed in quotes, since that will make rclone fail.

A working example is:

[remote_name]
type = sftp
server_command = sudo /usr/libexec/openssh/sftp-server

Properties:

  • Config: server_command
  • Env Var: RCLONE_SFTP_SERVER_COMMAND
  • Type: string
  • Required: false

--sftp-use-fstat

If set use fstat instead of stat.

Some servers limit the amount of open files and calling Stat after opening the file will throw an error from the server. Setting this flag will call Fstat instead of Stat which is called on an already open file handle.

It has been found that this helps with IBM Sterling SFTP servers which have "extractability" level set to 1 which means only 1 file can be opened at any given time.

Properties:

  • Config: use_fstat
  • Env Var: RCLONE_SFTP_USE_FSTAT
  • Type: bool
  • Default: false

--sftp-disable-concurrent-reads

If set don't use concurrent reads.

Normally concurrent reads are safe to use and not using them will degrade performance, so this option is disabled by default.

Some servers limit the amount number of times a file can be downloaded. Using concurrent reads can trigger this limit, so if you have a server which returns

Failed to copy: file does not exist

Then you may need to enable this flag.

If concurrent reads are disabled, the use_fstat option is ignored.

Properties:

  • Config: disable_concurrent_reads
  • Env Var: RCLONE_SFTP_DISABLE_CONCURRENT_READS
  • Type: bool
  • Default: false

--sftp-disable-concurrent-writes

If set don't use concurrent writes.

Normally rclone uses concurrent writes to upload files. This improves the performance greatly, especially for distant servers.

This option disables concurrent writes should that be necessary.

Properties:

  • Config: disable_concurrent_writes
  • Env Var: RCLONE_SFTP_DISABLE_CONCURRENT_WRITES
  • Type: bool
  • Default: false

--sftp-idle-timeout

Max time before closing idle connections.

If no connections have been returned to the connection pool in the time given, rclone will empty the connection pool.

Set to 0 to keep connections indefinitely.

Properties:

  • Config: idle_timeout
  • Env Var: RCLONE_SFTP_IDLE_TIMEOUT
  • Type: Duration
  • Default: 1m0s

--sftp-chunk-size

Upload and download chunk size.

This controls the maximum size of payload in SFTP protocol packets. The RFC limits this to 32768 bytes (32k), which is the default. However, a lot of servers support larger sizes, typically limited to a maximum total package size of 256k, and setting it larger will increase transfer speed dramatically on high latency links. This includes OpenSSH, and, for example, using the value of 255k works well, leaving plenty of room for overhead while still being within a total packet size of 256k.

Make sure to test thoroughly before using a value higher than 32k, and only use it if you always connect to the same server or after sufficiently broad testing. If you get errors such as "failed to send packet payload: EOF", lots of "connection lost", or "corrupted on transfer", when copying a larger file, try lowering the value. The server run by rclone serve sftp sends packets with standard 32k maximum payload so you must not set a different chunk_size when downloading files, but it accepts packets up to the 256k total size, so for uploads the chunk_size can be set as for the OpenSSH example above.

Properties:

  • Config: chunk_size
  • Env Var: RCLONE_SFTP_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 32Ki

--sftp-concurrency

The maximum number of outstanding requests for one file

This controls the maximum number of outstanding requests for one file. Increasing it will increase throughput on high latency links at the cost of using more memory.

Properties:

  • Config: concurrency
  • Env Var: RCLONE_SFTP_CONCURRENCY
  • Type: int
  • Default: 64

--sftp-connections

Maximum number of SFTP simultaneous connections, 0 for unlimited.

Note that setting this is very likely to cause deadlocks so it should be used with care.

If you are doing a sync or copy then make sure connections is one more than the sum of --transfers and --checkers.

If you use --check-first then it just needs to be one more than the maximum of --checkers and --transfers.

So for connections 3 you'd use --checkers 2 --transfers 2 --check-first or --checkers 1 --transfers 1.

Properties:

  • Config: connections
  • Env Var: RCLONE_SFTP_CONNECTIONS
  • Type: int
  • Default: 0

--sftp-set-env

Environment variables to pass to sftp and commands

Set environment variables in the form:

VAR=value

to be passed to the sftp client and to any commands run (eg md5sum).

Pass multiple variables space separated, eg

VAR1=value VAR2=value

and pass variables with spaces in quotes, eg

"VAR3=value with space" "VAR4=value with space" VAR5=nospacehere

Properties:

  • Config: set_env
  • Env Var: RCLONE_SFTP_SET_ENV
  • Type: SpaceSepList
  • Default:

--sftp-ciphers

Space separated list of ciphers to be used for session encryption, ordered by preference.

At least one must match with server configuration. This can be checked for example using ssh -Q cipher.

This must not be set if use_insecure_cipher is true.

Example:

aes128-ctr aes192-ctr aes256-ctr aes128-gcm@openssh.com aes256-gcm@openssh.com

Properties:

  • Config: ciphers
  • Env Var: RCLONE_SFTP_CIPHERS
  • Type: SpaceSepList
  • Default:

--sftp-key-exchange

Space separated list of key exchange algorithms, ordered by preference.

At least one must match with server configuration. This can be checked for example using ssh -Q kex.

This must not be set if use_insecure_cipher is true.

Example:

sntrup761x25519-sha512@openssh.com curve25519-sha256 curve25519-sha256@libssh.org ecdh-sha2-nistp256

Properties:

  • Config: key_exchange
  • Env Var: RCLONE_SFTP_KEY_EXCHANGE
  • Type: SpaceSepList
  • Default:

--sftp-macs

Space separated list of MACs (message authentication code) algorithms, ordered by preference.

At least one must match with server configuration. This can be checked for example using ssh -Q mac.

Example:

umac-64-etm@openssh.com umac-128-etm@openssh.com hmac-sha2-256-etm@openssh.com

Properties:

  • Config: macs
  • Env Var: RCLONE_SFTP_MACS
  • Type: SpaceSepList
  • Default:

--sftp-host-key-algorithms

Space separated list of host key algorithms, ordered by preference.

At least one must match with server configuration. This can be checked for example using ssh -Q HostKeyAlgorithms.

Note: This can affect the outcome of key negotiation with the server even if server host key validation is not enabled.

Example:

ssh-ed25519 ssh-rsa ssh-dss

Properties:

  • Config: host_key_algorithms
  • Env Var: RCLONE_SFTP_HOST_KEY_ALGORITHMS
  • Type: SpaceSepList
  • Default:

--sftp-socks-proxy

Socks 5 proxy host.

Supports the format user:pass@host:port, user@host:port, host:port.

Example:

myUser:myPass@localhost:9005

Properties:

  • Config: socks_proxy
  • Env Var: RCLONE_SFTP_SOCKS_PROXY
  • Type: string
  • Required: false

--sftp-http-proxy

URL for HTTP CONNECT proxy

Set this to a URL for an HTTP proxy which supports the HTTP CONNECT verb.

Properties:

  • Config: http_proxy
  • Env Var: RCLONE_SFTP_HTTP_PROXY
  • Type: string
  • Required: false

Set to enable server side copies using hardlinks.

The SFTP protocol does not define a copy command so normally server side copies are not allowed with the sftp backend.

However the SFTP protocol does support hardlinking, and if you enable this flag then the sftp backend will support server side copies. These will be implemented by doing a hardlink from the source to the destination.

Not all sftp servers support this.

Note that hardlinking two files together will use no additional space as the source and the destination will be the same file.

This feature may be useful backups made with --copy-dest.

Properties:

  • Config: copy_is_hardlink
  • Env Var: RCLONE_SFTP_COPY_IS_HARDLINK
  • Type: bool
  • Default: false

--sftp-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_SFTP_DESCRIPTION
  • Type: string
  • Required: false

Limitations

On some SFTP servers (e.g. Synology) the paths are different for SSH and SFTP so the hashes can't be calculated properly. You can either use --sftp-path-override or disable_hashcheck.

The only ssh agent supported under Windows is Putty's pageant.

The Go SSH library disables the use of the aes128-cbc cipher by default, due to security concerns. This can be re-enabled on a per-connection basis by setting the use_insecure_cipher setting in the configuration file to true. Further details on the insecurity of this cipher can be found in this paper.

SFTP isn't supported under plan9 until this issue is fixed.

Note that since SFTP isn't HTTP based the following flags don't work with it: --dump-headers, --dump-bodies, --dump-auth.

Note that --timeout and --contimeout are both supported.

rsync.net

rsync.net is supported through the SFTP backend.

See rsync.net's documentation of rclone examples.

Hetzner Storage Box

Hetzner Storage Boxes are supported through the SFTP backend on port 23.

See Hetzner's documentation for details

SMB

SMB is a communication protocol to share files over network.

This relies on go-smb2 library for communication with SMB protocol.

Paths are specified as remote:sharename (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:item/path/to/dir.

Notes

The first path segment must be the name of the share, which you entered when you started to share on Windows. On smbd, it's the section title in smb.conf (usually in /etc/samba/) file. You can find shares by querying the root if you're unsure (e.g. rclone lsd remote:).

You can't access to the shared printers from rclone, obviously.

You can't use Anonymous access for logging in. You have to use the guest user with an empty password instead. The rclone client tries to avoid 8.3 names when uploading files by encoding trailing spaces and periods. Alternatively, the local backend on Windows can access SMB servers using UNC paths, by \\server\share. This doesn't apply to non-Windows OSes, such as Linux and macOS.

Configuration

Here is an example of making a SMB configuration.

First run

rclone config

This will guide you through an interactive setup process.

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Option Storage.
Type of storage to configure.
Choose a number from below, or type in your own value.
XX / SMB / CIFS
   \ (smb)
Storage> smb

Option host.
Samba hostname to connect to.
E.g. "example.com".
Enter a value.
host> localhost

Option user.
Samba username.
Enter a string value. Press Enter for the default (lesmi).
user> guest

Option port.
Samba port number.
Enter a signed integer. Press Enter for the default (445).
port> 

Option pass.
Samba password.
Choose an alternative below. Press Enter for the default (n).
y) Yes, type in my own password
g) Generate random password
n) No, leave this optional password blank (default)
y/g/n> g
Password strength in bits.
64 is just about memorable
128 is secure
1024 is the maximum
Bits> 64
Your password is: XXXX
Use this password? Please note that an obscured version of this 
password (and not the password itself) will be stored under your 
configuration file, so keep this generated password in a safe place.
y) Yes (default)
n) No
y/n> y

Option domain.
Domain name for NTLM authentication.
Enter a string value. Press Enter for the default (WORKGROUP).
domain> 

Edit advanced config?
y) Yes
n) No (default)
y/n> n

Configuration complete.
Options:
- type: samba
- host: localhost
- user: guest
- pass: *** ENCRYPTED ***
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> d

Standard options

Here are the Standard options specific to smb (SMB / CIFS).

--smb-host

SMB server hostname to connect to.

E.g. "example.com".

Properties:

  • Config: host
  • Env Var: RCLONE_SMB_HOST
  • Type: string
  • Required: true

--smb-user

SMB username.

Properties:

  • Config: user
  • Env Var: RCLONE_SMB_USER
  • Type: string
  • Default: "$USER"

--smb-port

SMB port number.

Properties:

  • Config: port
  • Env Var: RCLONE_SMB_PORT
  • Type: int
  • Default: 445

--smb-pass

SMB password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: pass
  • Env Var: RCLONE_SMB_PASS
  • Type: string
  • Required: false

--smb-domain

Domain name for NTLM authentication.

Properties:

  • Config: domain
  • Env Var: RCLONE_SMB_DOMAIN
  • Type: string
  • Default: "WORKGROUP"

--smb-spn

Service principal name.

Rclone presents this name to the server. Some servers use this as further authentication, and it often needs to be set for clusters. For example:

cifs/remotehost:1020

Leave blank if not sure.

Properties:

  • Config: spn
  • Env Var: RCLONE_SMB_SPN
  • Type: string
  • Required: false

--smb-use-kerberos

Use Kerberos authentication.

If set, rclone will use Kerberos authentication instead of NTLM. This requires a valid Kerberos configuration and credentials cache to be available, either in the default locations or as specified by the KRB5_CONFIG and KRB5CCNAME environment variables.

Properties:

  • Config: use_kerberos
  • Env Var: RCLONE_SMB_USE_KERBEROS
  • Type: bool
  • Default: false

Advanced options

Here are the Advanced options specific to smb (SMB / CIFS).

--smb-idle-timeout

Max time before closing idle connections.

If no connections have been returned to the connection pool in the time given, rclone will empty the connection pool.

Set to 0 to keep connections indefinitely.

Properties:

  • Config: idle_timeout
  • Env Var: RCLONE_SMB_IDLE_TIMEOUT
  • Type: Duration
  • Default: 1m0s

--smb-hide-special-share

Hide special shares (e.g. print$) which users aren't supposed to access.

Properties:

  • Config: hide_special_share
  • Env Var: RCLONE_SMB_HIDE_SPECIAL_SHARE
  • Type: bool
  • Default: true

--smb-case-insensitive

Whether the server is configured to be case-insensitive.

Always true on Windows shares.

Properties:

  • Config: case_insensitive
  • Env Var: RCLONE_SMB_CASE_INSENSITIVE
  • Type: bool
  • Default: true

--smb-kerberos-ccache

Path to the Kerberos credential cache (krb5cc).

Overrides the default KRB5CCNAME environment variable and allows this instance of the SMB backend to use a different Kerberos cache file. This is useful when mounting multiple SMB with different credentials or running in multi-user environments.

Supported formats: - FILE:/path/to/ccache – Use the specified file. - DIR:/path/to/ccachedir – Use the primary file inside the specified directory. - /path/to/ccache – Interpreted as a file path.

Properties:

  • Config: kerberos_ccache
  • Env Var: RCLONE_SMB_KERBEROS_CCACHE
  • Type: string
  • Required: false

--smb-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_SMB_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot

--smb-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_SMB_DESCRIPTION
  • Type: string
  • Required: false

Storj

Storj is redefining the cloud to support the future of data—sustainably and economically. Storj leverages the vast global supply of underutilized resources to deliver better security, durability, and performance services. Experience up to 90% lower costs and carbon reduction with Storj.

Storj is an encrypted, secure, and cost-effective object storage service that enables you to store, back up, and archive large amounts of data in a decentralized manner.

Backend options

Storj can be used both with this native backend and with the s3 backend using the Storj S3 compatible gateway (shared or private).

Use this backend to take advantage of client-side encryption as well as to achieve the best possible download performance. Uploads will be erasure-coded locally, thus a 1gb upload will result in 2.68gb of data being uploaded to storage nodes across the network.

Use the s3 backend and one of the S3 compatible Hosted Gateways to increase upload performance and reduce the load on your systems and network. Uploads will be encrypted and erasure-coded server-side, thus a 1GB upload will result in only in 1GB of data being uploaded to storage nodes across the network.

Side by side comparison with more details:

  • Characteristics:
    • Storj backend: Uses native RPC protocol, connects directly to the storage nodes which hosts the data. Requires more CPU resource of encoding/decoding and has network amplification (especially during the upload), uses lots of TCP connections
    • S3 backend: Uses S3 compatible HTTP Rest API via the shared gateways. There is no network amplification, but performance depends on the shared gateways and the secret encryption key is shared with the gateway.
  • Typical usage:
    • Storj backend: Server environments and desktops with enough resources, internet speed and connectivity - and applications where storjs client-side encryption is required.
    • S3 backend: Desktops and similar with limited resources, internet speed or connectivity.
  • Security:
    • Storj backend: strong. Private encryption key doesn't need to leave the local computer.
    • S3 backend: weaker. Private encryption key is shared with the authentication service of the hosted gateway, where it's stored encrypted. It can be stronger when combining with the rclone crypt backend.
  • Bandwidth usage (upload):
    • Storj backend: higher. As data is erasure coded on the client side both the original data and the parities should be uploaded. About ~2.7 times more data is required to be uploaded. Client may start to upload with even higher number of nodes (~3.7 times more) and abandon/stop the slow uploads.
    • S3 backend: normal. Only the raw data is uploaded, erasure coding happens on the gateway.
  • Bandwidth usage (download)
    • Storj backend: almost normal. Only the minimal number of data is required, but to avoid very slow data providers a few more sources are used and the slowest are ignored (max 1.2x overhead).
    • S3 backend: normal. Only the raw data is downloaded, erasure coding happens on the shared gateway.
  • CPU usage:
    • Storj backend: higher, but more predictable. Erasure code and encryption/decryption happens locally which requires significant CPU usage.
    • S3 backend: less. Erasure code and encryption/decryption happens on shared s3 gateways (and as is, it depends on the current load on the gateways)
  • TCP connection usage:
    • Storj backend: high. A direct connection is required to each of the Storj nodes resulting in 110 connections on upload and 35 on download per 64 MB segment. Not all the connections are actively used (slow ones are pruned), but they are all opened. Adjusting the max open file limit may be required.
    • S3 backend: normal. Only one connection per download/upload thread is required to the shared gateway.
  • Overall performance:
    • Storj backend: with enough resources (CPU and bandwidth) storj backend can provide even 2x better performance. Data is directly downloaded to / uploaded from to the client instead of the gateway.
    • S3 backend: Can be faster on edge devices where CPU and network bandwidth is limited as the shared S3 compatible gateways take care about the encrypting/decryption and erasure coding and no download/upload amplification.
  • Decentralization:
    • Storj backend: high. Data is downloaded directly from the distributed cloud of storage providers.
    • S3 backend: low. Requires a running S3 gateway (either self-hosted or Storj-hosted).
  • Limitations:
    • Storj backend: rclone checksum is not possible without download, as checksum metadata is not calculated during upload
    • S3 backend: secret encryption key is shared with the gateway

Configuration

To make a new Storj configuration you need one of the following: * Access Grant that someone else shared with you. * API Key of a Storj project you are a member of.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

Setup with access grant

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Storj Decentralized Cloud Storage
   \ "storj"
[snip]
Storage> storj
** See help for storj backend at: https://rclone.org/storj/ **

Choose an authentication method.
Enter a string value. Press Enter for the default ("existing").
Choose a number from below, or type in your own value
 1 / Use an existing access grant.
   \ "existing"
 2 / Create a new access grant from satellite address, API key, and passphrase.
   \ "new"
provider> existing
Access Grant.
Enter a string value. Press Enter for the default ("").
access_grant> your-access-grant-received-by-someone-else
Remote config
Configuration complete.
Options:
- type: storj
- access_grant: your-access-grant-received-by-someone-else
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Setup with API key and passphrase

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Storj Decentralized Cloud Storage
   \ "storj"
[snip]
Storage> storj
** See help for storj backend at: https://rclone.org/storj/ **

Choose an authentication method.
Enter a string value. Press Enter for the default ("existing").
Choose a number from below, or type in your own value
 1 / Use an existing access grant.
   \ "existing"
 2 / Create a new access grant from satellite address, API key, and passphrase.
   \ "new"
provider> new
Satellite Address. Custom satellite address should match the format: `<nodeid>@<address>:<port>`.
Enter a string value. Press Enter for the default ("us1.storj.io").
Choose a number from below, or type in your own value
 1 / US1
   \ "us1.storj.io"
 2 / EU1
   \ "eu1.storj.io"
 3 / AP1
   \ "ap1.storj.io"
satellite_address> 1
API Key.
Enter a string value. Press Enter for the default ("").
api_key> your-api-key-for-your-storj-project
Encryption Passphrase. To access existing objects enter passphrase used for uploading.
Enter a string value. Press Enter for the default ("").
passphrase> your-human-readable-encryption-passphrase
Remote config
Configuration complete.
Options:
- type: storj
- satellite_address: 12EayRS2V1kEsWESU9QMRseFhdxYxKicsiFmxrsLZHeLUtdps3S@us1.storj.io:7777
- api_key: your-api-key-for-your-storj-project
- passphrase: your-human-readable-encryption-passphrase
- access_grant: the-access-grant-generated-from-the-api-key-and-passphrase
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Standard options

Here are the Standard options specific to storj (Storj Decentralized Cloud Storage).

--storj-provider

Choose an authentication method.

Properties:

  • Config: provider
  • Env Var: RCLONE_STORJ_PROVIDER
  • Type: string
  • Default: "existing"
  • Examples:
    • "existing"
      • Use an existing access grant.
    • "new"
      • Create a new access grant from satellite address, API key, and passphrase.

--storj-access-grant

Access grant.

Properties:

  • Config: access_grant
  • Env Var: RCLONE_STORJ_ACCESS_GRANT
  • Provider: existing
  • Type: string
  • Required: false

--storj-satellite-address

Satellite address.

Custom satellite address should match the format: <nodeid>@<address>:<port>.

Properties:

  • Config: satellite_address
  • Env Var: RCLONE_STORJ_SATELLITE_ADDRESS
  • Provider: new
  • Type: string
  • Default: "us1.storj.io"
  • Examples:
    • "us1.storj.io"
      • US1
    • "eu1.storj.io"
      • EU1
    • "ap1.storj.io"
      • AP1

--storj-api-key

API key.

Properties:

  • Config: api_key
  • Env Var: RCLONE_STORJ_API_KEY
  • Provider: new
  • Type: string
  • Required: false

--storj-passphrase

Encryption passphrase.

To access existing objects enter passphrase used for uploading.

Properties:

  • Config: passphrase
  • Env Var: RCLONE_STORJ_PASSPHRASE
  • Provider: new
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to storj (Storj Decentralized Cloud Storage).

--storj-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_STORJ_DESCRIPTION
  • Type: string
  • Required: false

Usage

Paths are specified as remote:bucket (or remote: for the lsf command.) You may put subdirectories in too, e.g. remote:bucket/path/to/dir.

Once configured you can then use rclone like this.

Create a new bucket

Use the mkdir command to create new bucket, e.g. bucket.

rclone mkdir remote:bucket

List all buckets

Use the lsf command to list all buckets.

rclone lsf remote:

Note the colon (:) character at the end of the command line.

Delete a bucket

Use the rmdir command to delete an empty bucket.

rclone rmdir remote:bucket

Use the purge command to delete a non-empty bucket with all its content.

rclone purge remote:bucket

Upload objects

Use the copy command to upload an object.

rclone copy --progress /home/local/directory/file.ext remote:bucket/path/to/dir/

The --progress flag is for displaying progress information. Remove it if you don't need this information.

Use a folder in the local path to upload all its objects.

rclone copy --progress /home/local/directory/ remote:bucket/path/to/dir/

Only modified files will be copied.

List objects

Use the ls command to list recursively all objects in a bucket.

rclone ls remote:bucket

Add the folder to the remote path to list recursively all objects in this folder.

rclone ls remote:bucket/path/to/dir/

Use the lsf command to list non-recursively all objects in a bucket or a folder.

rclone lsf remote:bucket/path/to/dir/

Download objects

Use the copy command to download an object.

rclone copy --progress remote:bucket/path/to/dir/file.ext /home/local/directory/

The --progress flag is for displaying progress information. Remove it if you don't need this information.

Use a folder in the remote path to download all its objects.

rclone copy --progress remote:bucket/path/to/dir/ /home/local/directory/

Delete objects

Use the deletefile command to delete a single object.

rclone deletefile remote:bucket/path/to/dir/file.ext

Use the delete command to delete all object in a folder.

rclone delete remote:bucket/path/to/dir/

Use the size command to print the total size of objects in a bucket or a folder.

rclone size remote:bucket/path/to/dir/

Sync two Locations

Use the sync command to sync the source to the destination, changing the destination only, deleting any excess files.

rclone sync --interactive --progress /home/local/directory/ remote:bucket/path/to/dir/

The --progress flag is for displaying progress information. Remove it if you don't need this information.

Since this can cause data loss, test first with the --dry-run flag to see exactly what would be copied and deleted.

The sync can be done also from Storj to the local file system.

rclone sync --interactive --progress remote:bucket/path/to/dir/ /home/local/directory/

Or between two Storj buckets.

rclone sync --interactive --progress remote-us:bucket/path/to/dir/ remote-europe:bucket/path/to/dir/

Or even between another cloud storage and Storj.

rclone sync --interactive --progress s3:bucket/path/to/dir/ storj:bucket/path/to/dir/

Limitations

rclone about is not supported by the rclone Storj backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

Known issues

If you get errors like too many open files this usually happens when the default ulimit for system max open files is exceeded. Native Storj protocol opens a large number of TCP connections (each of which is counted as an open file). For a single upload stream you can expect 110 TCP connections to be opened. For a single download stream you can expect 35. This batch of connections will be opened for every 64 MiB segment and you should also expect TCP connections to be reused. If you do many transfers you eventually open a connection to most storage nodes (thousands of nodes).

To fix these, please raise your system limits. You can do this issuing a ulimit -n 65536 just before you run rclone. To change the limits more permanently you can add this to your shell startup script, e.g. $HOME/.bashrc, or change the system-wide configuration, usually /etc/sysctl.conf and/or /etc/security/limits.conf, but please refer to your operating system manual.

SugarSync

SugarSync is a cloud service that enables active synchronization of files across computers and other devices for file backup, access, syncing, and sharing.

Configuration

The initial setup for SugarSync involves getting a token from SugarSync which you can do with rclone. rclone config walks you through it.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Sugarsync
   \ "sugarsync"
[snip]
Storage> sugarsync
** See help for sugarsync backend at: https://rclone.org/sugarsync/ **

Sugarsync App ID.
Leave blank to use rclone's.
Enter a string value. Press Enter for the default ("").
app_id> 
Sugarsync Access Key ID.
Leave blank to use rclone's.
Enter a string value. Press Enter for the default ("").
access_key_id> 
Sugarsync Private Access Key
Leave blank to use rclone's.
Enter a string value. Press Enter for the default ("").
private_access_key> 
Permanently delete files if true
otherwise put them in the deleted files.
Enter a boolean value (true or false). Press Enter for the default ("false").
hard_delete> 
Edit advanced config? (y/n)
y) Yes
n) No (default)
y/n> n
Remote config
Username (email address)> nick@craig-wood.com
Your Sugarsync password is only required during setup and will not be stored.
password:
Configuration complete.
Options:
- type: sugarsync
- refresh_token: https://api.sugarsync.com/app-authorization/XXXXXXXXXXXXXXXXXX
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Note that the config asks for your email and password but doesn't store them, it only uses them to get the initial token.

Once configured you can then use rclone like this,

List directories (sync folders) in top level of your SugarSync

rclone lsd remote:

List all the files in your SugarSync folder "Test"

rclone ls remote:Test

To copy a local directory to an SugarSync folder called backup

rclone copy /home/source remote:backup

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

NB you can't create files in the top level folder you have to create a folder, which rclone will create as a "Sync Folder" with SugarSync.

Modification times and hashes

SugarSync does not support modification times or hashes, therefore syncing will default to --size-only checking. Note that using --update will work as rclone can read the time files were uploaded.

Restricted filename characters

SugarSync replaces the default restricted characters set except for DEL.

Invalid UTF-8 bytes will also be replaced, as they can't be used in XML strings.

Deleting files

Deleted files will be moved to the "Deleted items" folder by default.

However you can supply the flag --sugarsync-hard-delete or set the config parameter hard_delete = true if you would like files to be deleted straight away.

Standard options

Here are the Standard options specific to sugarsync (Sugarsync).

--sugarsync-app-id

Sugarsync App ID.

Leave blank to use rclone's.

Properties:

  • Config: app_id
  • Env Var: RCLONE_SUGARSYNC_APP_ID
  • Type: string
  • Required: false

--sugarsync-access-key-id

Sugarsync Access Key ID.

Leave blank to use rclone's.

Properties:

  • Config: access_key_id
  • Env Var: RCLONE_SUGARSYNC_ACCESS_KEY_ID
  • Type: string
  • Required: false

--sugarsync-private-access-key

Sugarsync Private Access Key.

Leave blank to use rclone's.

Properties:

  • Config: private_access_key
  • Env Var: RCLONE_SUGARSYNC_PRIVATE_ACCESS_KEY
  • Type: string
  • Required: false

--sugarsync-hard-delete

Permanently delete files if true otherwise put them in the deleted files.

Properties:

  • Config: hard_delete
  • Env Var: RCLONE_SUGARSYNC_HARD_DELETE
  • Type: bool
  • Default: false

Advanced options

Here are the Advanced options specific to sugarsync (Sugarsync).

--sugarsync-refresh-token

Sugarsync refresh token.

Leave blank normally, will be auto configured by rclone.

Properties:

  • Config: refresh_token
  • Env Var: RCLONE_SUGARSYNC_REFRESH_TOKEN
  • Type: string
  • Required: false

--sugarsync-authorization

Sugarsync authorization.

Leave blank normally, will be auto configured by rclone.

Properties:

  • Config: authorization
  • Env Var: RCLONE_SUGARSYNC_AUTHORIZATION
  • Type: string
  • Required: false

--sugarsync-authorization-expiry

Sugarsync authorization expiry.

Leave blank normally, will be auto configured by rclone.

Properties:

  • Config: authorization_expiry
  • Env Var: RCLONE_SUGARSYNC_AUTHORIZATION_EXPIRY
  • Type: string
  • Required: false

--sugarsync-user

Sugarsync user.

Leave blank normally, will be auto configured by rclone.

Properties:

  • Config: user
  • Env Var: RCLONE_SUGARSYNC_USER
  • Type: string
  • Required: false

--sugarsync-root-id

Sugarsync root id.

Leave blank normally, will be auto configured by rclone.

Properties:

  • Config: root_id
  • Env Var: RCLONE_SUGARSYNC_ROOT_ID
  • Type: string
  • Required: false

--sugarsync-deleted-id

Sugarsync deleted folder id.

Leave blank normally, will be auto configured by rclone.

Properties:

  • Config: deleted_id
  • Env Var: RCLONE_SUGARSYNC_DELETED_ID
  • Type: string
  • Required: false

--sugarsync-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_SUGARSYNC_ENCODING
  • Type: Encoding
  • Default: Slash,Ctl,InvalidUtf8,Dot

--sugarsync-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_SUGARSYNC_DESCRIPTION
  • Type: string
  • Required: false

Limitations

rclone about is not supported by the SugarSync backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

Uloz.to

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

The initial setup for Uloz.to involves filling in the user credentials. rclone config walks you through it.

Configuration

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Uloz.to
   \ "ulozto"
[snip]
Storage> ulozto

Option app_token.
The application token identifying the app. An app API key can be either found in the API doc 
https://uloz.to/upload-resumable-api-beta or obtained from customer service.
Enter a value. Press Enter to leave empty.
app_token> token_value

Option username.
The username of the principal to operate as.
Enter a value. Press Enter to leave empty.
username> user

Option password.
The password for the user.
Choose an alternative below. Press Enter for the default (n).
y) Yes, type in my own password
g) Generate random password
n) No, leave this optional password blank (default)
y/g/n> y
Enter the password:
password:
Confirm the password:
password:

Edit advanced config?
y) Yes
n) No (default)
y/n> n

Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d> y

Once configured you can then use rclone like this,

List folders in root level folder:

rclone lsd remote:

List all the files in your root folder:

rclone ls remote:

To copy a local folder to a Uloz.to folder called backup:

rclone copy /home/source remote:backup

User credentials

The only reliable method is to authenticate the user using username and password. Uloz.to offers an API key as well, but it's reserved for the use of Uloz.to's in-house application and using it in different circumstances is unreliable.

Modification times and hashes

Uloz.to doesn't allow the user to set a custom modification time, or retrieve the hashes after upload. As a result, the integration uses a free form field the API provides to encode client-provided timestamps and hashes. Timestamps are stored with microsecond precision.

A server calculated MD5 hash of the file is verified upon upload. Afterwards, the backend only serves the client-side calculated hashes. Hashes can also be retrieved upon creating a file download link, but it's impractical for list-like use cases.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
\ 0x5C ＼

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Transfers

All files are currently uploaded using a single HTTP request, so for uploading large files a stable connection is necessary. Rclone will upload up to --transfers chunks at the same time (shared among all uploads).

Deleting files

By default, files are moved to the recycle bin whereas folders are deleted immediately. Trashed files are permanently deleted after 30 days in the recycle bin.

Emptying the trash is currently not implemented in rclone.

Root folder ID

You can set the root_folder_slug for rclone. This is the folder (identified by its Folder slug) that rclone considers to be the root of your Uloz.to drive.

Normally you will leave this blank and rclone will determine the correct root to use itself. However you can set this to restrict rclone to a specific folder hierarchy.

In order to do this you will have to find the Folder slug of the folder you wish to use as root. This will be the last segment of the URL when you open the relevant folder in the Uloz.to web interface.

For example, for exploring a folder with URL https://uloz.to/fm/my-files/foobar, foobar should be used as the root slug.

root_folder_slug can be used alongside a specific path in the remote path. For example, if your remote's root_folder_slug corresponds to /foo/bar, remote:baz/qux will refer to ABSOLUTE_ULOZTO_ROOT/foo/bar/baz/qux.

Standard options

Here are the Standard options specific to ulozto (Uloz.to).

--ulozto-app-token

The application token identifying the app. An app API key can be either found in the API doc https://uloz.to/upload-resumable-api-beta or obtained from customer service.

Properties:

  • Config: app_token
  • Env Var: RCLONE_ULOZTO_APP_TOKEN
  • Type: string
  • Required: false

--ulozto-username

The username of the principal to operate as.

Properties:

  • Config: username
  • Env Var: RCLONE_ULOZTO_USERNAME
  • Type: string
  • Required: false

--ulozto-password

The password for the user.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: password
  • Env Var: RCLONE_ULOZTO_PASSWORD
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to ulozto (Uloz.to).

--ulozto-root-folder-slug

If set, rclone will use this folder as the root folder for all operations. For example, if the slug identifies 'foo/bar/', 'ulozto:baz' is equivalent to 'ulozto:foo/bar/baz' without any root slug set.

Properties:

  • Config: root_folder_slug
  • Env Var: RCLONE_ULOZTO_ROOT_FOLDER_SLUG
  • Type: string
  • Required: false

--ulozto-list-page-size

The size of a single page for list commands. 1-500

Properties:

  • Config: list_page_size
  • Env Var: RCLONE_ULOZTO_LIST_PAGE_SIZE
  • Type: int
  • Default: 500

--ulozto-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_ULOZTO_ENCODING
  • Type: Encoding
  • Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot

--ulozto-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_ULOZTO_DESCRIPTION
  • Type: string
  • Required: false

Limitations

Uloz.to file names can't have the \ character in. rclone maps this to and from an identical looking unicode equivalent ＼ (U+FF3C Fullwidth Reverse Solidus).

Uloz.to only supports filenames up to 255 characters in length.

Uloz.to rate limits access to the API, but exact details are undisclosed. Practical testing reveals that hitting the rate limit during normal use is very rare, although not impossible with higher number of concurrently uploaded files.

rclone about is not supported by the Uloz.to backend. Although there's an endpoint to retrieve the information for the UI, it's not exposed in the API. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote.

See List of backends that do not support rclone about and rclone about

Uptobox

This is a Backend for Uptobox file storage service. Uptobox is closer to a one-click hoster than a traditional cloud storage provider and therefore not suitable for long term storage.

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Configuration

To configure an Uptobox backend you'll need your personal api token. You'll find it in your account settings

Here is an example of how to make a remote called remote with the default setup. First run:

rclone config

This will guide you through an interactive setup process:

Current remotes:

Name                 Type
====                 ====
TestUptobox          uptobox

e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> n
name> uptobox
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[...]
37 / Uptobox
   \ "uptobox"
[...]
Storage> uptobox
** See help for uptobox backend at: https://rclone.org/uptobox/ **

Your API Key, get it from https://uptobox.com/my_account
Enter a string value. Press Enter for the default ("").
api_key> xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Edit advanced config? (y/n)
y) Yes
n) No (default)
y/n> n
Remote config
--------------------
[uptobox]
type = uptobox
api_key = xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
--------------------
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d>

Once configured you can then use rclone like this,

List directories in top level of your Uptobox

rclone lsd remote:

List all the files in your Uptobox

rclone ls remote:

To copy a local directory to an Uptobox directory called backup

rclone copy /home/source remote:backup

Modification times and hashes

Uptobox supports neither modified times nor checksums. All timestamps will read as that set by --default-time.

Restricted filename characters

In addition to the default restricted characters set the following characters are also replaced:

Character Value Replacement
" 0x22 ＂
` 0x41 ｀

Invalid UTF-8 bytes will also be replaced, as they can't be used in XML strings.

Standard options

Here are the Standard options specific to uptobox (Uptobox).

--uptobox-access-token

Your access token.

Get it from https://uptobox.com/my_account.

Properties:

  • Config: access_token
  • Env Var: RCLONE_UPTOBOX_ACCESS_TOKEN
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to uptobox (Uptobox).

--uptobox-private

Set to make uploaded files private

Properties:

  • Config: private
  • Env Var: RCLONE_UPTOBOX_PRIVATE
  • Type: bool
  • Default: false

--uptobox-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_UPTOBOX_ENCODING
  • Type: Encoding
  • Default: Slash,LtGt,DoubleQuote,BackQuote,Del,Ctl,LeftSpace,InvalidUtf8,Dot

--uptobox-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_UPTOBOX_DESCRIPTION
  • Type: string
  • Required: false

Limitations

Uptobox will delete inactive files that have not been accessed in 60 days.

rclone about is not supported by this backend an overview of used space can however been seen in the uptobox web interface.

Union

The union backend joins several remotes together to make a single unified view of them.

During the initial setup with rclone config you will specify the upstream remotes as a space separated list. The upstream remotes can either be a local paths or other remotes.

The attributes :ro, :nc and :writeback can be attached to the end of the remote to tag the remote as read only, no create or writeback, e.g. remote:directory/subdirectory:ro or remote:directory/subdirectory:nc.

  • :ro means files will only be read from here and never written
  • :nc means new files or directories won't be created here
  • :writeback means files found in different remotes will be written back here. See the writeback section for more info.

Subfolders can be used in upstream remotes. Assume a union remote named backup with the remotes mydrive:private/backup. Invoking rclone mkdir backup:desktop is exactly the same as invoking rclone mkdir mydrive:private/backup/desktop.

There is no special handling of paths containing .. segments. Invoking rclone mkdir backup:../desktop is exactly the same as invoking rclone mkdir mydrive:private/backup/../desktop.

Configuration

Here is an example of how to make a union called remote for local folders. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Union merges the contents of several remotes
   \ "union"
[snip]
Storage> union
List of space separated upstreams.
Can be 'upstreama:test/dir upstreamb:', '\"upstreama:test/space:ro dir\" upstreamb:', etc.
Enter a string value. Press Enter for the default ("").
upstreams> remote1:dir1 remote2:dir2 remote3:dir3
Policy to choose upstream on ACTION class.
Enter a string value. Press Enter for the default ("epall").
action_policy>
Policy to choose upstream on CREATE class.
Enter a string value. Press Enter for the default ("epmfs").
create_policy>
Policy to choose upstream on SEARCH class.
Enter a string value. Press Enter for the default ("ff").
search_policy>
Cache time of usage and free space (in seconds). This option is only useful when a path preserving policy is used.
Enter a signed integer. Press Enter for the default ("120").
cache_time>
Remote config
Configuration complete.
Options:
- type: union
- upstreams: remote1:dir1 remote2:dir2 remote3:dir3
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y
Current remotes:

Name                 Type
====                 ====
remote               union

e) Edit existing remote
n) New remote
d) Delete remote
r) Rename remote
c) Copy remote
s) Set configuration password
q) Quit config
e/n/d/r/c/s/q> q

Once configured you can then use rclone like this,

List directories in top level in remote1:dir1, remote2:dir2 and remote3:dir3

rclone lsd remote:

List all the files in remote1:dir1, remote2:dir2 and remote3:dir3

rclone ls remote:

Copy another local directory to the union directory called source, which will be placed into remote3:dir3

rclone copy C:\source remote:source

Behavior / Policies

The behavior of union backend is inspired by trapexit/mergerfs. All functions are grouped into 3 categories: action, create and search. These functions and categories can be assigned a policy which dictates what file or directory is chosen when performing that behavior. Any policy can be assigned to a function or category though some may not be very useful in practice. For instance: rand (random) may be useful for file creation (create) but could lead to very odd behavior if used for delete if there were more than one copy of the file.

Function / Category classifications

Category Description Functions
action Writing Existing file move, rmdir, rmdirs, delete, purge and copy, sync (as destination when file exist)
create Create non-existing file copy, sync (as destination when file not exist)
search Reading and listing file ls, lsd, lsl, cat, md5sum, sha1sum and copy, sync (as source)
N/A size, about

Path Preservation

Policies, as described below, are of two basic types. path preserving and non-path preserving.

All policies which start with ep (epff, eplfs, eplus, epmfs, eprand) are path preserving. ep stands for existing path.

A path preserving policy will only consider upstreams where the relative path being accessed already exists.

When using non-path preserving policies paths will be created in target upstreams as necessary.

Quota Relevant Policies

Some policies rely on quota information. These policies should be used only if your upstreams support the respective quota fields.

Policy Required Field
lfs, eplfs Free
mfs, epmfs Free
lus, eplus Used
lno, eplno Objects

To check if your upstream supports the field, run rclone about remote: [flags] and see if the required field exists.

Filters

Policies basically search upstream remotes and create a list of files / paths for functions to work on. The policy is responsible for filtering and sorting. The policy type defines the sorting but filtering is mostly uniform as described below.

  • No search policies filter.
  • All action policies will filter out remotes which are tagged as read-only.
  • All create policies will filter out remotes which are tagged read-only or no-create.

If all remotes are filtered an error will be returned.

Policy descriptions

The policies definition are inspired by trapexit/mergerfs but not exactly the same. Some policy definition could be different due to the much larger latency of remote file systems.

Policy Description
all Search category: same as epall. Action category: same as epall. Create category: act on all upstreams.
epall (existing path, all) Search category: Given this order configured, act on the first one found where the relative path exists. Action category: apply to all found. Create category: act on all upstreams where the relative path exists.
epff (existing path, first found) Act on the first one found, by the time upstreams reply, where the relative path exists.
eplfs (existing path, least free space) Of all the upstreams on which the relative path exists choose the one with the least free space.
eplus (existing path, least used space) Of all the upstreams on which the relative path exists choose the one with the least used space.
eplno (existing path, least number of objects) Of all the upstreams on which the relative path exists choose the one with the least number of objects.
epmfs (existing path, most free space) Of all the upstreams on which the relative path exists choose the one with the most free space.
eprand (existing path, random) Calls epall and then randomizes. Returns only one upstream.
ff (first found) Search category: same as epff. Action category: same as epff. Create category: Act on the first one found by the time upstreams reply.
lfs (least free space) Search category: same as eplfs. Action category: same as eplfs. Create category: Pick the upstream with the least available free space.
lus (least used space) Search category: same as eplus. Action category: same as eplus. Create category: Pick the upstream with the least used space.
lno (least number of objects) Search category: same as eplno. Action category: same as eplno. Create category: Pick the upstream with the least number of objects.
mfs (most free space) Search category: same as epmfs. Action category: same as epmfs. Create category: Pick the upstream with the most available free space.
newest Pick the file / directory with the largest mtime.
rand (random) Calls all and then randomizes. Returns only one upstream.

Writeback

The tag :writeback on an upstream remote can be used to make a simple cache system like this:

[union]
type = union
action_policy = all
create_policy = all
search_policy = ff
upstreams = /local:writeback remote:dir

When files are opened for read, if the file is in remote:dir but not /local then rclone will copy the file entirely into /local before returning a reference to the file in /local. The copy will be done with the equivalent of rclone copy so will use --multi-thread-streams if configured. Any copies will be logged with an INFO log.

When files are written, they will be written to both remote:dir and /local.

As many remotes as desired can be added to upstreams but there should only be one :writeback tag.

Rclone does not manage the :writeback remote in any way other than writing files back to it. So if you need to expire old files or manage the size then you will have to do this yourself.

Standard options

Here are the Standard options specific to union (Union merges the contents of several upstream fs).

--union-upstreams

List of space separated upstreams.

Can be 'upstreama:test/dir upstreamb:', '"upstreama:test/space:ro dir" upstreamb:', etc.

Properties:

  • Config: upstreams
  • Env Var: RCLONE_UNION_UPSTREAMS
  • Type: string
  • Required: true

--union-action-policy

Policy to choose upstream on ACTION category.

Properties:

  • Config: action_policy
  • Env Var: RCLONE_UNION_ACTION_POLICY
  • Type: string
  • Default: "epall"

--union-create-policy

Policy to choose upstream on CREATE category.

Properties:

  • Config: create_policy
  • Env Var: RCLONE_UNION_CREATE_POLICY
  • Type: string
  • Default: "epmfs"

--union-search-policy

Policy to choose upstream on SEARCH category.

Properties:

  • Config: search_policy
  • Env Var: RCLONE_UNION_SEARCH_POLICY
  • Type: string
  • Default: "ff"

--union-cache-time

Cache time of usage and free space (in seconds).

This option is only useful when a path preserving policy is used.

Properties:

  • Config: cache_time
  • Env Var: RCLONE_UNION_CACHE_TIME
  • Type: int
  • Default: 120

Advanced options

Here are the Advanced options specific to union (Union merges the contents of several upstream fs).

--union-min-free-space

Minimum viable free space for lfs/eplfs policies.

If a remote has less than this much free space then it won't be considered for use in lfs or eplfs policies.

Properties:

  • Config: min_free_space
  • Env Var: RCLONE_UNION_MIN_FREE_SPACE
  • Type: SizeSuffix
  • Default: 1Gi

--union-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_UNION_DESCRIPTION
  • Type: string
  • Required: false

Metadata

Any metadata supported by the underlying remote is read and written.

See the metadata docs for more info.

WebDAV

Paths are specified as remote:path

Paths may be as deep as required, e.g. remote:directory/subdirectory.

Configuration

To configure the WebDAV remote you will need to have a URL for it, and a username and password. If you know what kind of system you are connecting to then rclone can enable extra features.

Here is an example of how to make a remote called remote. First run:

 rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
q) Quit config
n/s/q> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / WebDAV
   \ "webdav"
[snip]
Storage> webdav
URL of http host to connect to
Choose a number from below, or type in your own value
 1 / Connect to example.com
   \ "https://example.com"
url> https://example.com/remote.php/webdav/
Name of the WebDAV site/service/software you are using
Choose a number from below, or type in your own value
 1 / Fastmail Files
   \ (fastmail)
 2 / Nextcloud
   \ (nextcloud)
 3 / Owncloud
   \ (owncloud)
 4 / Sharepoint Online, authenticated by Microsoft account
   \ (sharepoint)
 5 / Sharepoint with NTLM authentication, usually self-hosted or on-premises
   \ (sharepoint-ntlm)
 6 / rclone WebDAV server to serve a remote over HTTP via the WebDAV protocol
   \ (rclone)
 7 / Other site/service or software
   \ (other)
vendor> 2
User name
user> user
Password.
y) Yes type in my own password
g) Generate random password
n) No leave this optional password blank
y/g/n> y
Enter the password:
password:
Confirm the password:
password:
Bearer token instead of user/pass (e.g. a Macaroon)
bearer_token>
Remote config
Configuration complete.
Options:
- type: webdav
- url: https://example.com/remote.php/webdav/
- vendor: nextcloud
- user: user
- pass: *** ENCRYPTED ***
- bearer_token:
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

Once configured you can then use rclone like this,

List directories in top level of your WebDAV

rclone lsd remote:

List all the files in your WebDAV

rclone ls remote:

To copy a local directory to an WebDAV directory called backup

rclone copy /home/source remote:backup

Modification times and hashes

Plain WebDAV does not support modified times. However when used with Fastmail Files, ownCloud or Nextcloud rclone will support modified times.

Likewise plain WebDAV does not support hashes, however when used with Fastmail Files, ownCloud or Nextcloud rclone will support SHA1 and MD5 hashes. Depending on the exact version of ownCloud or Nextcloud hashes may appear on all objects, or only on objects which had a hash uploaded with them.

Standard options

Here are the Standard options specific to webdav (WebDAV).

--webdav-url

URL of http host to connect to.

E.g. https://example.com.

Properties:

  • Config: url
  • Env Var: RCLONE_WEBDAV_URL
  • Type: string
  • Required: true

--webdav-vendor

Name of the WebDAV site/service/software you are using.

Properties:

  • Config: vendor
  • Env Var: RCLONE_WEBDAV_VENDOR
  • Type: string
  • Required: false
  • Examples:
    • "fastmail"
      • Fastmail Files
    • "nextcloud"
      • Nextcloud
    • "owncloud"
      • Owncloud 10 PHP based WebDAV server
    • "infinitescale"
      • ownCloud Infinite Scale
    • "sharepoint"
      • Sharepoint Online, authenticated by Microsoft account
    • "sharepoint-ntlm"
      • Sharepoint with NTLM authentication, usually self-hosted or on-premises
    • "rclone"
      • rclone WebDAV server to serve a remote over HTTP via the WebDAV protocol
    • "other"
      • Other site/service or software

--webdav-user

User name.

In case NTLM authentication is used, the username should be in the format 'Domain'.

Properties:

  • Config: user
  • Env Var: RCLONE_WEBDAV_USER
  • Type: string
  • Required: false

--webdav-pass

Password.

NB Input to this must be obscured - see rclone obscure.

Properties:

  • Config: pass
  • Env Var: RCLONE_WEBDAV_PASS
  • Type: string
  • Required: false

--webdav-bearer-token

Bearer token instead of user/pass (e.g. a Macaroon).

Properties:

  • Config: bearer_token
  • Env Var: RCLONE_WEBDAV_BEARER_TOKEN
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to webdav (WebDAV).

--webdav-bearer-token-command

Command to run to get a bearer token.

Properties:

  • Config: bearer_token_command
  • Env Var: RCLONE_WEBDAV_BEARER_TOKEN_COMMAND
  • Type: string
  • Required: false

--webdav-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Default encoding is Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,Hash,Percent,BackSlash,Del,Ctl,LeftSpace,LeftTilde,RightSpace,RightPeriod,InvalidUtf8 for sharepoint-ntlm or identity otherwise.

Properties:

  • Config: encoding
  • Env Var: RCLONE_WEBDAV_ENCODING
  • Type: string
  • Required: false

--webdav-headers

Set HTTP headers for all transactions.

Use this to set additional HTTP headers for all transactions

The input format is comma separated list of key,value pairs. Standard CSV encoding may be used.

For example, to set a Cookie use 'Cookie,name=value', or '"Cookie","name=value"'.

You can set multiple headers, e.g. '"Cookie","name=value","Authorization","xxx"'.

Properties:

  • Config: headers
  • Env Var: RCLONE_WEBDAV_HEADERS
  • Type: CommaSepList
  • Default:

--webdav-pacer-min-sleep

Minimum time to sleep between API calls.

Properties:

  • Config: pacer_min_sleep
  • Env Var: RCLONE_WEBDAV_PACER_MIN_SLEEP
  • Type: Duration
  • Default: 10ms

--webdav-nextcloud-chunk-size

Nextcloud upload chunk size.

We recommend configuring your NextCloud instance to increase the max chunk size to 1 GB for better upload performances. See https://docs.nextcloud.com/server/latest/admin_manual/configuration_files/big_file_upload_configuration.html#adjust-chunk-size-on-nextcloud-side

Set to 0 to disable chunked uploading.

Properties:

  • Config: nextcloud_chunk_size
  • Env Var: RCLONE_WEBDAV_NEXTCLOUD_CHUNK_SIZE
  • Type: SizeSuffix
  • Default: 10Mi

--webdav-owncloud-exclude-shares

Exclude ownCloud shares

Properties:

  • Config: owncloud_exclude_shares
  • Env Var: RCLONE_WEBDAV_OWNCLOUD_EXCLUDE_SHARES
  • Type: bool
  • Default: false

--webdav-owncloud-exclude-mounts

Exclude ownCloud mounted storages

Properties:

  • Config: owncloud_exclude_mounts
  • Env Var: RCLONE_WEBDAV_OWNCLOUD_EXCLUDE_MOUNTS
  • Type: bool
  • Default: false

--webdav-unix-socket

Path to a unix domain socket to dial to, instead of opening a TCP connection directly

Properties:

  • Config: unix_socket
  • Env Var: RCLONE_WEBDAV_UNIX_SOCKET
  • Type: string
  • Required: false

--webdav-auth-redirect

Preserve authentication on redirect.

If the server redirects rclone to a new domain when it is trying to read a file then normally rclone will drop the Authorization: header from the request.

This is standard security practice to avoid sending your credentials to an unknown webserver.

However this is desirable in some circumstances. If you are getting an error like "401 Unauthorized" when rclone is attempting to read files from the webdav server then you can try this option.

Properties:

  • Config: auth_redirect
  • Env Var: RCLONE_WEBDAV_AUTH_REDIRECT
  • Type: bool
  • Default: false

--webdav-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_WEBDAV_DESCRIPTION
  • Type: string
  • Required: false

Provider notes

See below for notes on specific providers.

Fastmail Files

Use https://webdav.fastmail.com/ or a subdirectory as the URL, and your Fastmail email username@domain.tld as the username. Follow this documentation to create an app password with access to Files (WebDAV) and use this as the password.

Fastmail supports modified times using the X-OC-Mtime header.

ownCloud

Click on the settings cog in the bottom right of the page and this will show the WebDAV URL that rclone needs in the config step. It will look something like https://example.com/remote.php/webdav/.

ownCloud supports modified times using the X-OC-Mtime header.

Nextcloud

This is configured in an identical way to ownCloud. Note that Nextcloud initially did not support streaming of files (rcat) whereas ownCloud did, but this seems to be fixed as of 2020-11-27 (tested with rclone v1.53.1 and Nextcloud Server v19).

ownCloud Infinite Scale

The WebDAV URL for Infinite Scale can be found in the details panel of any space in Infinite Scale, if the display was enabled in the personal settings of the user through a checkbox there.

Infinite Scale works with the chunking tus upload protocol. The chunk size is currently fixed 10 MB.

Sharepoint Online

Rclone can be used with Sharepoint provided by OneDrive for Business or Office365 Education Accounts. This feature is only needed for a few of these Accounts, mostly Office365 Education ones. These accounts are sometimes not verified by the domain owner github#1975

This means that these accounts can't be added using the official API (other Accounts should work with the "onedrive" option). However, it is possible to access them using webdav.

To use a sharepoint remote with rclone, add it like this: First, you need to get your remote's URL:

  • Go here to open your OneDrive or to sign in
  • Now take a look at your address bar, the URL should look like this: https://[YOUR-DOMAIN]-my.sharepoint.com/personal/[YOUR-EMAIL]/_layouts/15/onedrive.aspx

You'll only need this URL up to the email address. After that, you'll most likely want to add "/Documents". That subdirectory contains the actual data stored on your OneDrive.

Add the remote to rclone like this: Configure the url as https://[YOUR-DOMAIN]-my.sharepoint.com/personal/[YOUR-EMAIL]/Documents and use your normal account email and password for user and pass. If you have 2FA enabled, you have to generate an app password. Set the vendor to sharepoint.

Your config file should look like this:

[sharepoint]
type = webdav
url = https://[YOUR-DOMAIN]-my.sharepoint.com/personal/[YOUR-EMAIL]/Documents
vendor = sharepoint
user = YourEmailAddress
pass = encryptedpassword

Sharepoint with NTLM Authentication

Use this option in case your (hosted) Sharepoint is not tied to OneDrive accounts and uses NTLM authentication.

To get the url configuration, similarly to the above, first navigate to the desired directory in your browser to get the URL, then strip everything after the name of the opened directory.

Example: If the URL is: https://example.sharepoint.com/sites/12345/Documents/Forms/AllItems.aspx

The configuration to use would be: https://example.sharepoint.com/sites/12345/Documents

Set the vendor to sharepoint-ntlm.

NTLM uses domain and user name combination for authentication, set user to DOMAIN\username.

Your config file should look like this:

[sharepoint]
type = webdav
url = https://[YOUR-DOMAIN]/some-path-to/Documents
vendor = sharepoint-ntlm
user = DOMAIN\user
pass = encryptedpassword

Required Flags for SharePoint

As SharePoint does some special things with uploaded documents, you won't be able to use the documents size or the documents hash to compare if a file has been changed since the upload / which file is newer.

For Rclone calls copying files (especially Office files such as .docx, .xlsx, etc.) from/to SharePoint (like copy, sync, etc.), you should append these flags to ensure Rclone uses the "Last Modified" datetime property to compare your documents:

--ignore-size --ignore-checksum --update

Rclone

Use this option if you are hosting remotes over WebDAV provided by rclone. Read rclone serve webdav for more details.

rclone serve supports modified times using the X-OC-Mtime header.

dCache

dCache is a storage system that supports many protocols and authentication/authorisation schemes. For WebDAV clients, it allows users to authenticate with username and password (BASIC), X.509, Kerberos, and various bearer tokens, including Macaroons and OpenID-Connect access tokens.

Configure as normal using the other type. Don't enter a username or password, instead enter your Macaroon as the bearer_token.

The config will end up looking something like this.

[dcache]
type = webdav
url = https://dcache...
vendor = other
user =
pass =
bearer_token = your-macaroon

There is a script that obtains a Macaroon from a dCache WebDAV endpoint, and creates an rclone config file.

Macaroons may also be obtained from the dCacheView web-browser/JavaScript client that comes with dCache.

OpenID-Connect

dCache also supports authenticating with OpenID-Connect access tokens. OpenID-Connect is a protocol (based on OAuth 2.0) that allows services to identify users who have authenticated with some central service.

Support for OpenID-Connect in rclone is currently achieved using another software package called oidc-agent. This is a command-line tool that facilitates obtaining an access token. Once installed and configured, an access token is obtained by running the oidc-token command. The following example shows a (shortened) access token obtained from the XDC OIDC Provider.

paul@celebrimbor:~$ oidc-token XDC
eyJraWQ[...]QFXDt0
paul@celebrimbor:~$

Note Before the oidc-token command will work, the refresh token must be loaded into the oidc agent. This is done with the oidc-add command (e.g., oidc-add XDC). This is typically done once per login session. Full details on this and how to register oidc-agent with your OIDC Provider are provided in the oidc-agent documentation.

The rclone bearer_token_command configuration option is used to fetch the access token from oidc-agent.

Configure as a normal WebDAV endpoint, using the 'other' vendor, leaving the username and password empty. When prompted, choose to edit the advanced config and enter the command to get a bearer token (e.g., oidc-agent XDC).

The following example config shows a WebDAV endpoint that uses oidc-agent to supply an access token from the XDC OIDC Provider.

[dcache]
type = webdav
url = https://dcache.example.org/
vendor = other
bearer_token_command = oidc-token XDC

Yandex Disk

Yandex Disk is a cloud storage solution created by Yandex.

Configuration

Here is an example of making a yandex configuration. First run

rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
n/s> n
name> remote
Type of storage to configure.
Choose a number from below, or type in your own value
[snip]
XX / Yandex Disk
   \ "yandex"
[snip]
Storage> yandex
Yandex Client Id - leave blank normally.
client_id>
Yandex Client Secret - leave blank normally.
client_secret>
Remote config
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y) Yes
n) No
y/n> y
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth
Log in and authorize rclone for access
Waiting for code...
Got code
Configuration complete.
Options:
- type: yandex
- client_id:
- client_secret:
- token: {"access_token":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","token_type":"OAuth","expiry":"2016-12-29T12:27:11.362788025Z"}
Keep this "remote" remote?
y) Yes this is OK
e) Edit this remote
d) Delete this remote
y/e/d> y

See the remote setup docs for how to set it up on a machine with no Internet browser available.

Note that rclone runs a webserver on your local machine to collect the token as returned from Yandex Disk. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall.

Once configured you can then use rclone like this,

See top level directories

rclone lsd remote:

Make a new directory

rclone mkdir remote:directory

List the contents of a directory

rclone ls remote:directory

Sync /home/local/directory to the remote path, deleting any excess files in the path.

rclone sync --interactive /home/local/directory remote:directory

Yandex paths may be as deep as required, e.g. remote:directory/subdirectory.

Modification times and hashes

Modified times are supported and are stored accurate to 1 ns in custom metadata called rclone_modified in RFC3339 with nanoseconds format.

The MD5 hash algorithm is natively supported by Yandex Disk.

Emptying Trash

If you wish to empty your trash you can use the rclone cleanup remote: command which will permanently delete all your trashed files. This command does not take any path arguments.

Quota information

To view your current quota you can use the rclone about remote: command which will display your usage limit (quota) and the current usage.

Restricted filename characters

The default restricted characters set are replaced.

Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings.

Standard options

Here are the Standard options specific to yandex (Yandex Disk).

--yandex-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_YANDEX_CLIENT_ID
  • Type: string
  • Required: false

--yandex-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_YANDEX_CLIENT_SECRET
  • Type: string
  • Required: false

Advanced options

Here are the Advanced options specific to yandex (Yandex Disk).

--yandex-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_YANDEX_TOKEN
  • Type: string
  • Required: false

--yandex-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_YANDEX_AUTH_URL
  • Type: string
  • Required: false

--yandex-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_YANDEX_TOKEN_URL
  • Type: string
  • Required: false

--yandex-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_YANDEX_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--yandex-hard-delete

Delete files permanently rather than putting them into the trash.

Properties:

  • Config: hard_delete
  • Env Var: RCLONE_YANDEX_HARD_DELETE
  • Type: bool
  • Default: false

--yandex-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_YANDEX_ENCODING
  • Type: Encoding
  • Default: Slash,Del,Ctl,InvalidUtf8,Dot

--yandex-spoof-ua

Set the user agent to match an official version of the yandex disk client. May help with upload performance.

Properties:

  • Config: spoof_ua
  • Env Var: RCLONE_YANDEX_SPOOF_UA
  • Type: bool
  • Default: true

--yandex-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_YANDEX_DESCRIPTION
  • Type: string
  • Required: false

Limitations

When uploading very large files (bigger than about 5 GiB) you will need to increase the --timeout parameter. This is because Yandex pauses (perhaps to calculate the MD5SUM for the entire file) before returning confirmation that the file has been uploaded. The default handling of timeouts in rclone is to assume a 5 minute pause is an error and close the connection - you'll see net/http: timeout awaiting response headers errors in the logs if this is happening. Setting the timeout to twice the max size of file in GiB should be enough, so if you want to upload a 30 GiB file set a timeout of 2 * 30 = 60m, that is --timeout 60m.

Having a Yandex Mail account is mandatory to use the Yandex.Disk subscription. Token generation will work without a mail account, but Rclone won't be able to complete any actions.

[403 - DiskUnsupportedUserAccountTypeError] User account type is not supported.

Zoho Workdrive

Zoho WorkDrive is a cloud storage solution created by Zoho.

Configuration

Here is an example of making a zoho configuration. First run

rclone config

This will guide you through an interactive setup process:

No remotes found, make a new one?
n) New remote
s) Set configuration password
n/s> n
name> remote
Type of storage to configure.
Enter a string value. Press Enter for the default ("").
Choose a number from below, or type in your own value
[snip]
XX / Zoho
   \ "zoho"
[snip]
Storage> zoho
** See help for zoho backend at: https://rclone.org/zoho/ **

OAuth Client Id
Leave blank normally.
Enter a string value. Press Enter for the default ("").
client_id> 
OAuth Client Secret
Leave blank normally.
Enter a string value. Press Enter for the default ("").
client_secret> 
Edit advanced config? (y/n)
y) Yes
n) No (default)
y/n> n
Remote config
Use web browser to automatically authenticate rclone with remote?
 * Say Y if the machine running rclone has a web browser you can use
 * Say N if running rclone on a (remote) machine without web browser access
If not sure try Y. If Y failed, try N.
y) Yes (default)
n) No
y/n> 
If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth?state=LVn0IHzxej1ZkmQw31d0wQ
Log in and authorize rclone for access
Waiting for code...
Got code
Choose a number from below, or type in your own value
 1 / MyTeam
   \ "4u28602177065ff22426787a6745dba8954eb"
Enter a Team ID> 1
Choose a number from below, or type in your own value
 1 / General
   \ "4u2869d2aa6fca04f4f2f896b6539243b85b1"
Enter a Workspace ID> 1
Configuration complete.
Options:
- type: zoho
- token: {"access_token":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","token_type":"Zoho-oauthtoken","refresh_token":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","expiry":"2020-10-12T00:54:52.370275223+02:00"}
- root_folder_id: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Keep this "remote" remote?
y) Yes this is OK (default)
e) Edit this remote
d) Delete this remote
y/e/d>

See the remote setup docs for how to set it up on a machine with no Internet browser available.

Rclone runs a webserver on your local computer to collect the authorization token from Zoho Workdrive. This is only from the moment your browser is opened until the token is returned. The webserver runs on http://127.0.0.1:53682/. If local port 53682 is protected by a firewall you may need to temporarily unblock the firewall to complete authorization.

Once configured you can then use rclone like this,

See top level directories

rclone lsd remote:

Make a new directory

rclone mkdir remote:directory

List the contents of a directory

rclone ls remote:directory

Sync /home/local/directory to the remote path, deleting any excess files in the path.

rclone sync --interactive /home/local/directory remote:directory

Zoho paths may be as deep as required, eg remote:directory/subdirectory.

Modification times and hashes

Modified times are currently not supported for Zoho Workdrive

No hash algorithms are supported.

Usage information

To view your current quota you can use the rclone about remote: command which will display your current usage.

Restricted filename characters

Only control characters and invalid UTF-8 are replaced. In addition most Unicode full-width characters are not supported at all and will be removed from filenames during upload.

Standard options

Here are the Standard options specific to zoho (Zoho).

--zoho-client-id

OAuth Client Id.

Leave blank normally.

Properties:

  • Config: client_id
  • Env Var: RCLONE_ZOHO_CLIENT_ID
  • Type: string
  • Required: false

--zoho-client-secret

OAuth Client Secret.

Leave blank normally.

Properties:

  • Config: client_secret
  • Env Var: RCLONE_ZOHO_CLIENT_SECRET
  • Type: string
  • Required: false

--zoho-region

Zoho region to connect to.

You'll have to use the region your organization is registered in. If not sure use the same top level domain as you connect to in your browser.

Properties:

  • Config: region
  • Env Var: RCLONE_ZOHO_REGION
  • Type: string
  • Required: false
  • Examples:
    • "com"
      • United states / Global
    • "eu"
      • Europe
    • "in"
      • India
    • "jp"
      • Japan
    • "com.cn"
      • China
    • "com.au"
      • Australia

Advanced options

Here are the Advanced options specific to zoho (Zoho).

--zoho-token

OAuth Access Token as a JSON blob.

Properties:

  • Config: token
  • Env Var: RCLONE_ZOHO_TOKEN
  • Type: string
  • Required: false

--zoho-auth-url

Auth server URL.

Leave blank to use the provider defaults.

Properties:

  • Config: auth_url
  • Env Var: RCLONE_ZOHO_AUTH_URL
  • Type: string
  • Required: false

--zoho-token-url

Token server url.

Leave blank to use the provider defaults.

Properties:

  • Config: token_url
  • Env Var: RCLONE_ZOHO_TOKEN_URL
  • Type: string
  • Required: false

--zoho-client-credentials

Use client credentials OAuth flow.

This will use the OAUTH2 client Credentials Flow as described in RFC 6749.

Note that this option is NOT supported by all backends.

Properties:

  • Config: client_credentials
  • Env Var: RCLONE_ZOHO_CLIENT_CREDENTIALS
  • Type: bool
  • Default: false

--zoho-upload-cutoff

Cutoff for switching to large file upload api (>= 10 MiB).

Properties:

  • Config: upload_cutoff
  • Env Var: RCLONE_ZOHO_UPLOAD_CUTOFF
  • Type: SizeSuffix
  • Default: 10Mi

--zoho-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_ZOHO_ENCODING
  • Type: Encoding
  • Default: Del,Ctl,InvalidUtf8

--zoho-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_ZOHO_DESCRIPTION
  • Type: string
  • Required: false

Setting up your own client_id

For Zoho we advise you to set up your own client_id. To do so you have to complete the following steps.

  1. Log in to the Zoho API Console

  2. Create a new client of type "Server-based Application". The name and website don't matter, but you must add the redirect URL http://localhost:53682/.

  3. Once the client is created, you can go to the settings tab and enable it in other regions.

The client id and client secret can now be used with rclone.

Local Filesystem

Local paths are specified as normal filesystem paths, e.g. /path/to/wherever, so

rclone sync --interactive /home/source /tmp/destination

Will sync /home/source to /tmp/destination.

Configuration

For consistencies sake one can also configure a remote of type local in the config file, and access the local filesystem using rclone remote paths, e.g. remote:path/to/wherever, but it is probably easier not to.

Modification times

Rclone reads and writes the modification times using an accuracy determined by the OS. Typically this is 1ns on Linux, 10 ns on Windows and 1 Second on OS X.

Filenames

Filenames should be encoded in UTF-8 on disk. This is the normal case for Windows and OS X.

There is a bit more uncertainty in the Linux world, but new distributions will have UTF-8 encoded files names. If you are using an old Linux filesystem with non UTF-8 file names (e.g. latin1) then you can use the convmv tool to convert the filesystem to UTF-8. This tool is available in most distributions' package managers.

If an invalid (non-UTF8) filename is read, the invalid characters will be replaced with a quoted representation of the invalid bytes. The name gro\xdf will be transferred as gro‛DF. rclone will emit a debug message in this case (use -v to see), e.g.

Local file system at .: Replacing invalid UTF-8 characters in "gro\xdf"

Restricted characters

With the local backend, restrictions on the characters that are usable in file or directory names depend on the operating system. To check what rclone will replace by default on your system, run rclone help flags local-encoding.

On non Windows platforms the following characters are replaced when handling file names.

Character Value Replacement
NUL 0x00 ␀
/ 0x2F ／

When running on Windows the following characters are replaced. This list is based on the Windows file naming conventions.

Character Value Replacement
NUL 0x00 ␀
SOH 0x01 ␁
STX 0x02 ␂
ETX 0x03 ␃
EOT 0x04 ␄
ENQ 0x05 ␅
ACK 0x06 ␆
BEL 0x07 ␇
BS 0x08 ␈
HT 0x09 ␉
LF 0x0A ␊
VT 0x0B ␋
FF 0x0C ␌
CR 0x0D ␍
SO 0x0E ␎
SI 0x0F ␏
DLE 0x10 ␐
DC1 0x11 ␑
DC2 0x12 ␒
DC3 0x13 ␓
DC4 0x14 ␔
NAK 0x15 ␕
SYN 0x16 ␖
ETB 0x17 ␗
CAN 0x18 ␘
EM 0x19 ␙
SUB 0x1A ␚
ESC 0x1B ␛
FS 0x1C ␜
GS 0x1D ␝
RS 0x1E ␞
US 0x1F ␟
/ 0x2F ／
" 0x22 ＂
* 0x2A ＊
: 0x3A ：
< 0x3C ＜
> 0x3E ＞
? 0x3F ？
\ 0x5C ＼
| 0x7C ｜

File names on Windows can also not end with the following characters. These only get replaced if they are the last character in the name:

Character Value Replacement
SP 0x20 ␠
. 0x2E ．

Invalid UTF-8 bytes will also be replaced, as they can't be converted to UTF-16.

Paths on Windows

On Windows there are many ways of specifying a path to a file system resource. Local paths can be absolute, like C:\path\to\wherever, or relative, like ..\wherever. Network paths in UNC format, \\server\share, are also supported. Path separator can be either \ (as in C:\path\to\wherever) or / (as in C:/path/to/wherever). Length of these paths are limited to 259 characters for files and 247 characters for directories, but there is an alternative extended-length path format increasing the limit to (approximately) 32,767 characters. This format requires absolute paths and the use of prefix \\?\, e.g. \\?\D:\some\very\long\path. For convenience rclone will automatically convert regular paths into the corresponding extended-length paths, so in most cases you do not have to worry about this (read more below). Using the same prefix \\?\ it is also possible to specify path to volumes identified by their GUID, e.g. \\?\Volume{b75e2c83-0000-0000-0000-602f00000000}\some\path.

Long paths

Rclone handles long paths automatically, by converting all paths to extended-length path format, which allows paths up to 32,767 characters.

This conversion will ensure paths are absolute and prefix them with the \\?\. This is why you will see that your paths, for instance .\files is shown as path \\?\C:\files in the output, and \\server\share as \\?\UNC\server\share.

However, in rare cases this may cause problems with buggy file system drivers like EncFS. To disable UNC conversion globally, add this to your .rclone.conf file:

[local]
nounc = true

If you want to selectively disable UNC, you can add it to a separate entry like this:

[nounc]
type = local
nounc = true

And use rclone like this:

rclone copy c:\src nounc:z:\dst

This will use UNC paths on c:\src but not on z:\dst. Of course this will cause problems if the absolute path length of a file exceeds 259 characters on z, so only use this option if you have to.

Normally rclone will ignore symlinks or junction points (which behave like symlinks under Windows).

If you supply --copy-links or -L then rclone will follow the symlink and copy the pointed to file or directory. Note that this flag is incompatible with --links / -l.

This flag applies to all commands.

For example, supposing you have a directory structure like this

$ tree /tmp/a
/tmp/a
├── b -> ../b
├── expected -> ../expected
├── one
└── two
    └── three

Then you can see the difference with and without the flag like this

$ rclone ls /tmp/a
        6 one
        6 two/three

and

$ rclone -L ls /tmp/a
     4174 expected
        6 one
        6 two/three
        6 b/two
        6 b/one

--local-links, --links, -l

Normally rclone will ignore symlinks or junction points (which behave like symlinks under Windows).

If you supply this flag then rclone will copy symbolic links from the local storage, and store them as text files, with a .rclonelink suffix in the remote storage.

The text file will contain the target of the symbolic link (see example).

This flag applies to all commands.

For example, supposing you have a directory structure like this

$ tree /tmp/a
/tmp/a
├── file1 -> ./file4
└── file2 -> /home/user/file3

Copying the entire directory with '-l'

$ rclone copy -l /tmp/a/ remote:/tmp/a/

The remote files are created with a .rclonelink suffix

$ rclone ls remote:/tmp/a
       5 file1.rclonelink
      14 file2.rclonelink

The remote files will contain the target of the symbolic links

$ rclone cat remote:/tmp/a/file1.rclonelink
./file4

$ rclone cat remote:/tmp/a/file2.rclonelink
/home/user/file3

Copying them back with '-l'

$ rclone copy -l remote:/tmp/a/ /tmp/b/

$ tree /tmp/b
/tmp/b
├── file1 -> ./file4
└── file2 -> /home/user/file3

However, if copied back without '-l'

$ rclone copyto remote:/tmp/a/ /tmp/b/

$ tree /tmp/b
/tmp/b
├── file1.rclonelink
└── file2.rclonelink

If you want to copy a single file with -l then you must use the .rclonelink suffix.

$ rclone copy -l remote:/tmp/a/file1.rclonelink /tmp/c

$ tree /tmp/c
/tmp/c
└── file1 -> ./file4

Note that --local-links just enables this feature for the local backend. --links and -l enable the feature for all supported backends and the VFS.

Note that this flag is incompatible with -copy-links / -L.

Restricting filesystems with --one-file-system

Normally rclone will recurse through filesystems as mounted.

However if you set --one-file-system or -x this tells rclone to stay in the filesystem specified by the root and not to recurse into different file systems.

For example if you have a directory hierarchy like this

root
├── disk1     - disk1 mounted on the root
│   └── file3 - stored on disk1
├── disk2     - disk2 mounted on the root
│   └── file4 - stored on disk12
├── file1     - stored on the root disk
└── file2     - stored on the root disk

Using rclone --one-file-system copy root remote: will only copy file1 and file2. Eg

$ rclone -q --one-file-system ls root
        0 file1
        0 file2
$ rclone -q ls root
        0 disk1/file3
        0 disk2/file4
        0 file1
        0 file2

NB Rclone (like most unix tools such as du, rsync and tar) treats a bind mount to the same device as being on the same filesystem.

NB This flag is only available on Unix based systems. On systems where it isn't supported (e.g. Windows) it will be ignored.

Advanced options

Here are the Advanced options specific to local (Local Disk).

--local-nounc

Disable UNC (long path names) conversion on Windows.

Properties:

  • Config: nounc
  • Env Var: RCLONE_LOCAL_NOUNC
  • Type: bool
  • Default: false
  • Examples:
    • "true"
      • Disables long file names.

--copy-links / -L

Follow symlinks and copy the pointed to item.

Properties:

  • Config: copy_links
  • Env Var: RCLONE_LOCAL_COPY_LINKS
  • Type: bool
  • Default: false

Translate symlinks to/from regular files with a '.rclonelink' extension for the local backend.

Properties:

  • Config: links
  • Env Var: RCLONE_LOCAL_LINKS
  • Type: bool
  • Default: false

Don't warn about skipped symlinks.

This flag disables warning messages on skipped symlinks or junction points, as you explicitly acknowledge that they should be skipped.

Properties:

  • Config: skip_links
  • Env Var: RCLONE_LOCAL_SKIP_LINKS
  • Type: bool
  • Default: false

Assume the Stat size of links is zero (and read them instead) (deprecated).

Rclone used to use the Stat size of links as the link size, but this fails in quite a few places:

  • Windows
  • On some virtual filesystems (such ash LucidLink)
  • Android

So rclone now always reads the link.

Properties:

  • Config: zero_size_links
  • Env Var: RCLONE_LOCAL_ZERO_SIZE_LINKS
  • Type: bool
  • Default: false

--local-unicode-normalization

Apply unicode NFC normalization to paths and filenames.

This flag can be used to normalize file names into unicode NFC form that are read from the local filesystem.

Rclone does not normally touch the encoding of file names it reads from the file system.

This can be useful when using macOS as it normally provides decomposed (NFD) unicode which in some language (eg Korean) doesn't display properly on some OSes.

Note that rclone compares filenames with unicode normalization in the sync routine so this flag shouldn't normally be used.

Properties:

  • Config: unicode_normalization
  • Env Var: RCLONE_LOCAL_UNICODE_NORMALIZATION
  • Type: bool
  • Default: false

--local-no-check-updated

Don't check to see if the files change during upload.

Normally rclone checks the size and modification time of files as they are being uploaded and aborts with a message which starts "can't copy - source file is being updated" if the file changes during upload.

However on some file systems this modification time check may fail (e.g. Glusterfs #2206) so this check can be disabled with this flag.

If this flag is set, rclone will use its best efforts to transfer a file which is being updated. If the file is only having things appended to it (e.g. a log) then rclone will transfer the log file with the size it had the first time rclone saw it.

If the file is being modified throughout (not just appended to) then the transfer may fail with a hash check failure.

In detail, once the file has had stat() called on it for the first time we:

  • Only transfer the size that stat gave
  • Only checksum the size that stat gave
  • Don't update the stat info for the file

NB do not use this flag on a Windows Volume Shadow (VSS). For some unknown reason, files in a VSS sometimes show different sizes from the directory listing (where the initial stat value comes from on Windows) and when stat is called on them directly. Other copy tools always use the direct stat value and setting this flag will disable that.

Properties:

  • Config: no_check_updated
  • Env Var: RCLONE_LOCAL_NO_CHECK_UPDATED
  • Type: bool
  • Default: false

--one-file-system / -x

Don't cross filesystem boundaries (unix/macOS only).

Properties:

  • Config: one_file_system
  • Env Var: RCLONE_LOCAL_ONE_FILE_SYSTEM
  • Type: bool
  • Default: false

--local-case-sensitive

Force the filesystem to report itself as case sensitive.

Normally the local backend declares itself as case insensitive on Windows/macOS and case sensitive for everything else. Use this flag to override the default choice.

Properties:

  • Config: case_sensitive
  • Env Var: RCLONE_LOCAL_CASE_SENSITIVE
  • Type: bool
  • Default: false

--local-case-insensitive

Force the filesystem to report itself as case insensitive.

Normally the local backend declares itself as case insensitive on Windows/macOS and case sensitive for everything else. Use this flag to override the default choice.

Properties:

  • Config: case_insensitive
  • Env Var: RCLONE_LOCAL_CASE_INSENSITIVE
  • Type: bool
  • Default: false

--local-no-clone

Disable reflink cloning for server-side copies.

Normally, for local-to-local transfers, rclone will "clone" the file when possible, and fall back to "copying" only when cloning is not supported.

Cloning creates a shallow copy (or "reflink") which initially shares blocks with the original file. Unlike a "hardlink", the two files are independent and neither will affect the other if subsequently modified.

Cloning is usually preferable to copying, as it is much faster and is deduplicated by default (i.e. having two identical files does not consume more storage than having just one.) However, for use cases where data redundancy is preferable, --local-no-clone can be used to disable cloning and force "deep" copies.

Currently, cloning is only supported when using APFS on macOS (support for other platforms may be added in the future.)

Properties:

  • Config: no_clone
  • Env Var: RCLONE_LOCAL_NO_CLONE
  • Type: bool
  • Default: false

--local-no-preallocate

Disable preallocation of disk space for transferred files.

Preallocation of disk space helps prevent filesystem fragmentation. However, some virtual filesystem layers (such as Google Drive File Stream) may incorrectly set the actual file size equal to the preallocated space, causing checksum and file size checks to fail. Use this flag to disable preallocation.

Properties:

  • Config: no_preallocate
  • Env Var: RCLONE_LOCAL_NO_PREALLOCATE
  • Type: bool
  • Default: false

--local-no-sparse

Disable sparse files for multi-thread downloads.

On Windows platforms rclone will make sparse files when doing multi-thread downloads. This avoids long pauses on large files where the OS zeros the file. However sparse files may be undesirable as they cause disk fragmentation and can be slow to work with.

Properties:

  • Config: no_sparse
  • Env Var: RCLONE_LOCAL_NO_SPARSE
  • Type: bool
  • Default: false

--local-no-set-modtime

Disable setting modtime.

Normally rclone updates modification time of files after they are done uploading. This can cause permissions issues on Linux platforms when the user rclone is running as does not own the file uploaded, such as when copying to a CIFS mount owned by another user. If this option is enabled, rclone will no longer update the modtime after copying a file.

Properties:

  • Config: no_set_modtime
  • Env Var: RCLONE_LOCAL_NO_SET_MODTIME
  • Type: bool
  • Default: false

--local-time-type

Set what kind of time is returned.

Normally rclone does all operations on the mtime or Modification time.

If you set this flag then rclone will return the Modified time as whatever you set here. So if you use "rclone lsl --local-time-type ctime" then you will see ctimes in the listing.

If the OS doesn't support returning the time_type specified then rclone will silently replace it with the modification time which all OSes support.

  • mtime is supported by all OSes
  • atime is supported on all OSes except: plan9, js
  • btime is only supported on: Windows, macOS, freebsd, netbsd
  • ctime is supported on all Oses except: Windows, plan9, js

Note that setting the time will still set the modified time so this is only useful for reading.

Properties:

  • Config: time_type
  • Env Var: RCLONE_LOCAL_TIME_TYPE
  • Type: mtime|atime|btime|ctime
  • Default: mtime
  • Examples:
    • "mtime"
      • The last modification time.
    • "atime"
      • The last access time.
    • "btime"
      • The creation time.
    • "ctime"
      • The last status change time.

--local-hashes

Comma separated list of supported checksum types.

Properties:

  • Config: hashes
  • Env Var: RCLONE_LOCAL_HASHES
  • Type: CommaSepList
  • Default:

--local-encoding

The encoding for the backend.

See the encoding section in the overview for more info.

Properties:

  • Config: encoding
  • Env Var: RCLONE_LOCAL_ENCODING
  • Type: Encoding
  • Default: Slash,Dot

--local-description

Description of the remote.

Properties:

  • Config: description
  • Env Var: RCLONE_LOCAL_DESCRIPTION
  • Type: string
  • Required: false

Metadata

Depending on which OS is in use the local backend may return only some of the system metadata. Setting system metadata is supported on all OSes but setting user metadata is only supported on linux, freebsd, netbsd, macOS and Solaris. It is not supported on Windows yet (see pkg/attrs#47).

User metadata is stored as extended attributes (which may not be supported by all file systems) under the "user.*" prefix.

Metadata is supported on files and directories.

Here are the possible system metadata items for the local backend.

Name Help Type Example Read Only
atime Time of last access RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N
btime Time of file birth (creation) RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N
gid Group ID of owner decimal number 500 N
mode File type and mode octal, unix style 0100664 N
mtime Time of last modification RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N
rdev Device ID (if special file) hexadecimal 1abc N
uid User ID of owner decimal number 500 N

See the metadata docs for more info.

Backend commands

Here are the commands specific to the local backend.

Run them with

rclone backend COMMAND remote:

The help below will explain what arguments each command takes.

See the backend command for more info on how to pass options and arguments.

These can be run on a running backend using the rc command backend/command.

noop

A null operation for testing backend commands

rclone backend noop remote: [options] [<arguments>+]

This is a test command which has some options you can try to change the output.

Options:

  • "echo": echo the input arguments
  • "error": return an error based on option value

Changelog

v1.71.0 - 2025-08-22

See commits

  • New S3 providers
    • Exaba (Nick Craig-Wood)
      • We've been working with Exaba and they would love early adopters, self-hosters and testers
    • OVHcloud Object Storage (Florent Vennetier)
    • Zata ($@M@RTH_)
  • New Features
    • Allow global config to be overriden or set on backend creation (Nick Craig-Wood)
    • bisync: Promoted from beta to stable (nielash)
    • build
      • Update to go1.25 and make go1.24 the minimum required version (Nick Craig-Wood)
      • Update all dependencies (Nick Craig-Wood)
      • Upgrade golangci-lint to v2 and fix code and config (albertony)
      • Add markdown linting to workflow and fix all the docs (albertony)
      • Extend check for edits of autogenerated files to all commits in a pull request (albertony)
      • Set default shell to bash in build.yml (Ross Smith II)
    • config
      • Make parsing of Duration options consistent (albertony)
      • Add error if RCLONE_CONFIG_PASS was supplied it but didn't decrypt the config (n4n5)
    • copy, copyto: Implement logger flags to store result of sync (Marvin Rösch)
    • doc fixes (albertony, Ali Zein Yousuf, Binbin Qian, curlwget, Ed Craig-Wood, jinjingroad, Lucas Bremgartner, n4n5, Nick Craig-Wood)
    • hash: Add support for BLAKE3, XXH3, XXH128 (albertony)
    • http
      • Add --client-pass support for encrypted --client-key files (Nick Craig-Wood)
      • Allow setting of --http-proxy from the command line (Nick Craig-Wood)
    • lib/mmap: Convert to using unsafe.Slice to avoid deprecated reflect.SliceHeader (cui)
    • lib/transform: Avoid empty charmap entry (albertony)
    • log: Add log rotation options when using --log-file (Nick Craig-Wood)
    • move, moveto: Implement logger flags to store result of sync (Marvin Rösch)
    • pool: Unify memory between multipart and asyncreader to use one pool (Nick Craig-Wood)
    • purge: Exit with a fatal error if filters are set on rclone purge (Nick Craig-Wood)
    • rc
      • Add config/unlock to unlock the config file (n4n5)
      • Fix config/listremotes to send an empty array instead of nil (n4n5)
      • Populate transfer snapshot with "what" value (Timothy Jacobs)
    • serve sftp: Add support for more hashes (crc32, sha256, blake3, xxh3, xxh128) (albertony)
    • transform: Add truncate_keep_extension and truncate_bytes (nielash)
  • Bug Fixes
    • about: Fix potential overflow of about in various backends (Nick Craig-Wood)
    • accounting
      • Fix incorrect stats with --transfers=1 (Yu Xin)
      • Fix stats (speed=0 and eta=nil) when starting jobs via rc (Nick Craig-Wood)
    • bisync
      • Fix concurrent runs via rc (nielash)
      • Fix --no-slow-hash settings on path2 (nielash)
    • config: fix problem reading pasted tokens over 4095 bytes (Nick Craig-Wood)
    • oauthutil: Fix nil pointer crash when started with expired token (Nick Craig-Wood)
    • operations: Fix too many connections open when using --max-buffer-memory (Nick Craig-Wood)
    • pool: Fix deadlock with --max-buffer-memory and multipart transfers (Nick Craig-Wood)
    • rc: Fix operations/check ignoring oneWay parameter (houance)
  • Mount
    • Fix identification of symlinks in directory listings (huangnauh)
  • Local
    • Configurable supported hashes (albertony)
    • Fix --copy-links on Windows when listing Junction points (Anagh Kumar Baranwal)
  • Azure Blob
    • Add support for client assertion based authentication (Vikas Bhansali)
    • Fix deadlock with --max-connections with InvalidBlockOrBlob errors (Nick Craig-Wood)
    • Fix double accounting for multipart uploads (Nick Craig-Wood)
  • Azurefiles
    • Add support for client assertion based authentication (Vikas Bhansali)
    • Fix hash getting erased when modtime is set (nielash)
  • Box
    • Fix about: cannot unmarshal number 1.0e+18 into Go struct field (Nick Craig-Wood)
  • Combine
    • Fix directory not found errors with ListP interface (Nick Craig-Wood)
  • Filescom
    • Document that hashes need to be enabled (Nick Craig-Wood)
  • FTP
    • Allow insecure TLS ciphers (Anagh Kumar Baranwal)
    • Make TLS config default to global TLS config (Nick Craig-Wood)
      • This allows --ca-cert, --client-cert etc to be used.
      • This also allows override.ca_cert = XXX to be used in the config file.
  • Googlephotos
    • Added warning for Google Photos compatability-fixes (raider13209)
  • Imagekit
    • Return correct error when attempting to upload zero length files (Nick Craig-Wood)
    • Don't low level retry uploads (Nick Craig-Wood)
    • Remove server side Copy method as it was downloading and uploading (Nick Craig-Wood)
  • Internetarchive
    • Fix server side copy of files with & (Nick Craig-Wood)
  • Mega
    • Fix tls handshake failure (necaran)
  • Oracleobjectstorage
    • Add read only metadata support (praveen-solanki-oracle)
  • Pikpak
    • Rewrite upload to bypass AWS S3 manager (wiserain)
    • Enhance Move for better handling of error and name collision (wiserain)
    • Enhance Copy method to handle name collisions and improve error management (wiserain)
    • Add file name integrity check during upload (wiserain)
  • S3
    • Add --s3-use-arn-region flag (Nick Craig-Wood)
    • Fix memory leak by cloning strings (liubingrun)
    • Fix multipart upload and server side copy when using bucket policy SSE-C (Albin Parou)
    • Fix Content-Type: aws-chunked causing upload errors with --metadata (Nick Craig-Wood)
  • SFTP
    • Add support for more hashes (crc32, sha256, blake3, xxh3, xxh128) (albertony)
  • Smb
    • Add --smb-kerberos-ccache option to set kerberos ccache per smb backend (Sudipto Baral)
    • Refresh Kerberos credentials when ccache file changes (Sudipto Baral)
    • Improve multithreaded upload performance using multiple connections (Sudipto Baral)

v1.70.3 - 2025-07-09

See commits

  • Bug Fixes
    • check: Fix difference report (was reporting error counts) (albertony)
    • march: Fix deadlock when using --no-traverse (Nick Craig-Wood)
    • doc fixes (albertony, Nick Craig-Wood)
  • Azure Blob
    • Fix server side copy error "requires exactly one scope" (Nick Craig-Wood)
  • B2
    • Fix finding objects when using --b2-version-at (Davide Bizzarri)
  • Linkbox
    • Fix upload error "user upload file not exist" (Nick Craig-Wood)
  • Pikpak
    • Improve error handling for missing links and unrecoverable 500s (wiserain)
  • WebDAV
    • Fix setting modtime to that of local object instead of remote (WeidiDeng)

v1.70.2 - 2025-06-27

See commits

  • Bug Fixes
    • convmv: Make --dry-run logs less noisy (nielash)
    • sync: Avoid copying dir metadata to itself (nielash)
    • build: Bump github.com/go-chi/chi/v5 from 5.2.1 to 5.2.2 to fix GHSA-vrw8-fxc6-2r93 (dependabot[bot])
    • convmv: Fix moving to unicode-equivalent name (nielash)
    • log: Fix deadlock when using systemd logging (Nick Craig-Wood)
    • pacer: Fix nil pointer deref in RetryError (Nick Craig-Wood)
    • doc fixes (Ali Zein Yousuf, Nick Craig-Wood)
  • Local
    • Fix --skip-links on Windows when skipping Junction points (Nick Craig-Wood)

v1.70.1 - 2025-06-19

See commits

  • Bug Fixes
    • convmv: Fix spurious "error running command echo" on Windows (Nick Craig-Wood)
    • doc fixes (albertony, Ed Craig-Wood, jinjingroad)

v1.70.0 - 2025-06-17

See commits

  • New backends
  • New commands
    • convmv: for moving and transforming files (nielash)
  • New Features
    • Add --max-connections to control maximum backend concurrency (Nick Craig-Wood)
    • Add --max-buffer-memory to limit total buffer memory usage (Nick Craig-Wood)
    • Add transform library and --name-transform flag (nielash)
    • sync: Implement --list-cutoff to allow on disk sorting for reduced memory use (Nick Craig-Wood)
    • accounting: Add listed stat for number of directory entries listed (Nick Craig-Wood)
    • backend: Skip hash calculation when the hashType is None (Oleksiy Stashok)
    • build
      • Update to go1.24 and make go1.22 the minimum required version (Nick Craig-Wood)
      • Disable docker builds on PRs & add missing dockerfile changes (Anagh Kumar Baranwal)
      • Modernize Go usage (Nick Craig-Wood)
      • Update all dependencies (Nick Craig-Wood)
    • cmd/authorize: Show required arguments in help text (simwai)
    • cmd/config: add --no-output option (Jess)
    • cmd/gitannex
      • Tweak parsing of "rcloneremotename" config (Dan McArdle)
      • Permit remotes with options (Dan McArdle)
      • Reject unknown layout modes in INITREMOTE (Dan McArdle)
    • docker image: Add label org.opencontainers.image.source for release notes in Renovate dependency updates (Robin Schneider)
    • doc fixes (albertony, Andrew Kreimer, Ben Boeckel, Christoph Berger, Danny Garside, Dimitri Papadopoulos, eccoisle, Ed Craig-Wood, Fernando Fernández, jack, Jeff Geerling, Jugal Kishore, kingston125, luzpaz, Markus Gerstel, Matt Ickstadt, Michael Kebe, Nick Craig-Wood, PrathameshLakawade, Ser-Bul, simonmcnair, Tim White, Zachary Vorhies)
    • filter:
      • Add --hash-filter to deterministically select a subset of files (Nick Craig-Wood)
      • Show --min-size and --max-size in --dump filters (Nick Craig-Wood)
    • hash: Add SHA512 support for file hashes (Enduriel)
    • http servers: Add --user-from-header to use for authentication (Moises Lima)
    • lib/batcher: Deprecate unused option: batch_commit_timeout (Dan McArdle)
    • log:
      • Remove github.com/sirupsen/logrus and replace with log/slog (Nick Craig-Wood)
      • Add --windows-event-log-level to support Windows Event Log (Nick Craig-Wood)
    • rc
      • Add add short parameter to core/stats to not return transferring and checking (Nick Craig-Wood)
      • In options/info make FieldName contain a "." if it should be nested (Nick Craig-Wood)
      • Add rc control for serve commands (Nick Craig-Wood)
      • rcserver: Improve content-type check (Jonathan Giannuzzi)
    • serve nfs
      • Update docs to note Windows is not supported (Zachary Vorhies)
      • Change the format of --nfs-cache-type symlink file handles (Nick Craig-Wood)
      • Make metadata files have special file handles (Nick Craig-Wood)
    • touch: Make touch obey --transfers (Nick Craig-Wood)
    • version: Add --deps flag to show dependencies and other build info (Nick Craig-Wood)
  • Bug Fixes
    • serve s3:
      • Fix ListObjectsV2 response (fhuber)
      • Remove redundant handler initialization (Tho Neyugn)
    • stats: Fix goroutine leak and improve stats accounting process (Nathanael Demacon)
  • VFS
    • Add --vfs-metadata-extension to expose metadata sidecar files (Nick Craig-Wood)
  • Azure Blob
    • Add support for x-ms-tags header (Trevor Starick)
    • Cleanup uncommitted blocks on upload errors (Nick Craig-Wood)
    • Speed up server side copies for small files (Nick Craig-Wood)
    • Implement multipart server side copy (Nick Craig-Wood)
    • Remove uncommitted blocks on InvalidBlobOrBlock error (Nick Craig-Wood)
    • Fix handling of objects with // in (Nick Craig-Wood)
    • Handle retry error codes more carefully (Nick Craig-Wood)
    • Fix errors not being retried when doing single part copy (Nick Craig-Wood)
    • Fix multipart server side copies of 0 sized files (Nick Craig-Wood)
  • Azurefiles
    • Add --azurefiles-use-az and --azurefiles-disable-instance-discovery (b-wimmer)
  • B2
    • Add SkipDestructive handling to backend commands (Pat Patterson)
    • Use file id from listing when not presented in headers (ahxxm)
  • Cloudinary
    • Automatically add/remove known media files extensions (yuval-cloudinary)
    • Var naming convention (yuval-cloudinary)
  • Drive
    • Added backend moveid command (Spencer McCullough)
  • Dropbox
    • Support Dropbox Paper (Dave Vasilevsky)
  • FTP
    • Add --ftp-http-proxy to connect via HTTP CONNECT proxy
  • Gofile
    • Update to use new direct upload endpoint (wbulot)
  • Googlephotos
    • Update read only and read write scopes to meet Google's requirements. (Germán Casares)
  • Iclouddrive
    • Fix panic and files potentially downloaded twice (Clément Wehrung)
  • Internetarchive
    • Add --internetarchive-metadata="key=value" for setting item metadata (Corentin Barreau)
  • Onedrive
    • Fix "The upload session was not found" errors (Nick Craig-Wood)
    • Re-add --onedrive-upload-cutoff flag (Nick Craig-Wood)
    • Fix crash if no metadata was updated (Nick Craig-Wood)
  • Opendrive
    • Added --opendrive-access flag to handle permissions (Joel K Biju)
  • Pcloud
    • Fix "Access denied. You do not have permissions to perform this operation" on large uploads (Nick Craig-Wood)
  • S3
    • Fix handling of objects with // in (Nick Craig-Wood)
    • Add IBM IAM signer (Alexander Minbaev)
    • Split the GCS quirks into --s3-use-x-id and --s3-sign-accept-encoding (Nick Craig-Wood)
    • Implement paged listing interface ListP (Nick Craig-Wood)
    • Add Pure Storage FlashBlade provider support (Jeremy Daer)
    • Require custom endpoint for Lyve Cloud v2 support (PrathameshLakawade)
    • MEGA S4 support (Nick Craig-Wood)
  • SFTP
    • Add --sftp-http-proxy to connect via HTTP CONNECT proxy (Nick Craig-Wood)
  • Smb
    • Add support for kerberos authentication (Jonathan Giannuzzi)
    • Improve connection pooling efficiency (Jonathan Giannuzzi)
  • WebDAV
    • Retry propfind on 425 status (Jörn Friedrich Dreyer)
    • Add an ownCloud Infinite Scale vendor that enables tus chunked upload support (Klaas Freitag)

v1.69.3 - 2025-05-21

See commits

  • Bug Fixes
    • build: Reapply update github.com/golang-jwt/jwt/v5 from 5.2.1 to 5.2.2 to fix CVE-2025-30204 (dependabot[bot])
    • build: Update github.com/ebitengine/purego to work around bug in go1.24.3 (Nick Craig-Wood)

v1.69.2 - 2025-05-01

See commits

  • Bug fixes
    • accounting: Fix percentDiff calculation -- (Anagh Kumar Baranwal)
    • build
      • Update github.com/golang-jwt/jwt/v4 from 4.5.1 to 4.5.2 to fix CVE-2025-30204 (dependabot[bot])
      • Update github.com/golang-jwt/jwt/v5 from 5.2.1 to 5.2.2 to fix CVE-2025-30204 (dependabot[bot])
      • Update golang.org/x/crypto to v0.35.0 to fix CVE-2025-22869 (Nick Craig-Wood)
      • Update golang.org/x/net from 0.36.0 to 0.38.0 to fix CVE-2025-22870 (dependabot[bot])
      • Update golang.org/x/net to 0.36.0. to fix CVE-2025-22869 (dependabot[bot])
      • Stop building with go < go1.23 as security updates forbade it (Nick Craig-Wood)
      • Fix docker plugin build (Anagh Kumar Baranwal)
    • cmd: Fix crash if rclone is invoked without any arguments (Janne Hellsten)
    • config: Read configuration passwords from stdin even when terminated with EOF (Samantha Bowen)
    • doc fixes (Andrew Kreimer, Danny Garside, eccoisle, Ed Craig-Wood, emyarod, jack, Jugal Kishore, Markus Gerstel, Michael Kebe, Nick Craig-Wood, simonmcnair, simwai, Zachary Vorhies)
    • fs: Fix corruption of SizeSuffix with "B" suffix in config (eg --min-size) (Nick Craig-Wood)
    • lib/http: Fix race between Serve() and Shutdown() (Nick Craig-Wood)
    • object: Fix memory object out of bounds Seek (Nick Craig-Wood)
    • operations: Fix call fmt.Errorf with wrong err (alingse)
    • rc
      • Disable the metrics server when running rclone rc (hiddenmarten)
      • Fix debug/* commands not being available over unix sockets (Nick Craig-Wood)
    • serve nfs: Fix unlikely crash (Nick Craig-Wood)
    • stats: Fix the speed not getting updated after a pause in the processing (Anagh Kumar Baranwal)
    • sync
      • Fix cpu spinning when empty directory finding with leading slashes (Nick Craig-Wood)
      • Copy dir modtimes even when copyEmptySrcDirs is false (ll3006)
  • VFS
    • Fix directory cache serving stale data (Lorenz Brun)
    • Fix inefficient directory caching when directory reads are slow (huanghaojun)
    • Fix integration test failures (Nick Craig-Wood)
  • Drive
    • Metadata: fix error when setting copy-requires-writer-permission on a folder (Nick Craig-Wood)
  • Dropbox
    • Retry link without expiry (Dave Vasilevsky)
  • HTTP
    • Correct root if definitely pointing to a file (nielash)
  • Iclouddrive
    • Fix so created files are writable (Ben Alex)
  • Onedrive
    • Fix metadata ordering in permissions (Nick Craig-Wood)

v1.69.1 - 2025-02-14

See commits

  • Bug Fixes
    • lib/oauthutil: Fix redirect URL mismatch errors (Nick Craig-Wood)
    • bisync: Fix listings missing concurrent modifications (nielash)
    • serve s3: Fix list objects encoding-type (Nick Craig-Wood)
    • fs: Fix confusing "didn't find section in config file" error (Nick Craig-Wood)
    • doc fixes (Christoph Berger, Dimitri Papadopoulos, Matt Ickstadt, Nick Craig-Wood, Tim White, Zachary Vorhies)
    • build: Added parallel docker builds and caching for go build in the container (Anagh Kumar Baranwal)
  • VFS
    • Fix the cache failing to upload symlinks when --links was specified (Nick Craig-Wood)
    • Fix race detected by race detector (Nick Craig-Wood)
    • Close the change notify channel on Shutdown (izouxv)
  • B2
    • Fix "fatal error: concurrent map writes" (Nick Craig-Wood)
  • Iclouddrive
    • Add notes on ADP and Missing PCS cookies (Nick Craig-Wood)
  • Onedrive
    • Mark German (de) region as deprecated (Nick Craig-Wood)
  • S3
    • Added new storage class to magalu provider (Bruno Fernandes)
    • Add DigitalOcean regions SFO2, LON1, TOR1, BLR1 (jkpe)
    • Add latest Linode Object Storage endpoints (jbagwell-akamai)

v1.69.0 - 2025-01-12

See commits

  • New backends
  • Security fixes
  • New Features
    • accounting: Write the current bwlimit to the log on SIGUSR2 (Nick Craig-Wood)
    • bisync: Change exit code from 2 to 7 for critically aborted run (albertony)
    • build
      • Update all dependencies (Nick Craig-Wood)
      • Replace Windows-specific NewLazyDLL with NewLazySystemDLL (albertony)
    • cmd: Change exit code from 1 to 2 for syntax and usage errors (albertony)
    • docker serve: make sure all mount and VFS options are parsed (Nick Craig-Wood)
    • doc fixes (albertony, Alexandre Hamez, Anthony Metzidis, buengese, Dan McArdle, David Seifert, Francesco Frassinelli, Michael R. Davis, Nick Craig-Wood, Pawel Palucha, Randy Bush, remygrandin, Sam Harrison, shenpengfeng, tgfisher, Thomas ten Cate, ToM, Tony Metzidis, vintagefuture, Yxxx)
    • fs: Make --links flag global and add new --local-links and --vfs-links flags (Nick Craig-Wood)
    • http servers: Disable automatic authentication skipping for unix sockets in http servers (Moises Lima)
      • This was making it impossible to use unix sockets with an proxy
      • This might now cause rclone to need authentication where it didn't before
    • oauthutil: add support for OAuth client credential flow (Martin Hassack, Nick Craig-Wood)
    • operations: make log messages consistent for mkdir/rmdir at INFO level (Nick Craig-Wood)
    • rc: Add relative to vfs/queue-set-expiry (Nick Craig-Wood)
    • serve dlna: Sort the directory entries by directories first then alphabetically by name (Nick Craig-Wood)
    • serve nfs
      • Introduce symlink support (Nick Craig-Wood)
      • Implement --nfs-cache-type symlink (Nick Craig-Wood)
    • size: Make output compatible with -P (Nick Craig-Wood)
    • test makefiles: Add --flat flag for making directories with many entries (Nick Craig-Wood)
  • Bug Fixes
    • accounting
      • Fix global error acounting (Benjamin Legrand)
      • Fix debug printing when debug wasn't set (Nick Craig-Wood)
      • Fix race stopping/starting the stats counter (Nick Craig-Wood)
    • rc/job: Use mutex for adding listeners thread safety (hayden.pan)
    • serve docker: Fix incorrect GID assignment (TAKEI Yuya)
    • serve nfs: Fix missing inode numbers which was messing up ls -laR (Nick Craig-Wood)
    • serve s3: Fix Last-Modified timestamp (Nick Craig-Wood)
    • serve sftp: Fix loading of authorized keys file with comment on last line (albertony)
  • Mount
    • Introduce symlink support (Filipe Azevedo, Nick Craig-Wood)
    • Better snap mount error message (divinity76)
    • mount2: Fix missing . and .. entries (Filipe Azevedo)
  • VFS
    • With --vfs-used-is-size value is calculated and then thrown away (Ilias Ozgur Can Leonard)
    • Add symlink support to VFS (Filipe Azevedo, Nick Craig-Wood)
      • This can be enabled with the specific --vfs-links flag or the global --links flag
    • Fix open files disappearing from directory listings (Nick Craig-Wood)
    • Add remote name to vfs cache log messages (Nick Craig-Wood)
  • Cache
    • Fix parent not getting pinned when remote is a file (nielash)
  • Azure Blob
    • Add --azureblob-disable-instance-discovery (Nick Craig-Wood)
    • Add --azureblob-use-az to force the use of the Azure CLI for auth (Nick Craig-Wood)
    • Quit multipart uploads if the context is cancelled (Nick Craig-Wood)
  • Azurefiles
    • Fix missing x-ms-file-request-intent header (Nick Craig-Wood)
  • B2
    • Add daysFromStartingToCancelingUnfinishedLargeFiles to backend lifecycle command (Louis Laureys)
  • Box
    • Fix server-side copying a file over existing dst (nielash)
    • Fix panic when decoding corrupted PEM from JWT file (Nick Craig-Wood)
  • Drive
    • Add support for markdown format (Noam Ross)
    • Implement rclone backend rescue to rescue orphaned files (Nick Craig-Wood)
  • Dropbox
    • Fix server side copying over existing object (Nick Craig-Wood)
    • Fix return status when full to be fatal error (Nick Craig-Wood)
  • FTP
    • Implement --ftp-no-check-upload to allow upload to write only dirs (Nick Craig-Wood)
    • Fix ls commands returning empty on "Microsoft FTP Service" servers (Francesco Frassinelli)
  • Gofile
    • Fix server side copying over existing object (Nick Craig-Wood)
  • Google Cloud Storage
    • Add access token auth with --gcs-access-token (Leandro Piccilli)
    • Update docs on service account access tokens (Anthony Metzidis)
  • Googlephotos
    • Implement --gphotos-proxy to allow download of full resolution media (Nick Craig-Wood)
    • Fix nil pointer crash on upload (Nick Craig-Wood)
  • HTTP
    • Fix incorrect URLs with initial slash (Oleg Kunitsyn)
  • Onedrive
    • Add support for OAuth client credential flow (Martin Hassack, Nick Craig-Wood)
    • Fix time precision for OneDrive personal (Nick Craig-Wood)
    • Fix server side copying over existing object (Nick Craig-Wood)
  • Opendrive
    • Add rclone about support to backend (quiescens)
  • Oracle Object Storage
    • Make specifying compartmentid optional (Manoj Ghosh)
    • Quit multipart uploads if the context is cancelled (Nick Craig-Wood)
  • Pikpak
    • Add option to use original file links (wiserain)
  • Protondrive
    • Improve performance of Proton Drive backend (Lawrence Murray)
  • Putio
    • Fix server side copying over existing object (Nick Craig-Wood)
  • S3
    • Add initial --s3-directory-bucket to support AWS Directory Buckets (Nick Craig-Wood)
    • Add Wasabi eu-south-1 region (Diego Monti)
    • Fix download of compressed files from Cloudflare R2 (Nick Craig-Wood)
    • Rename glacier storage class to flexible retrieval (Henry Lee)
    • Quit multipart uploads if the context is cancelled (Nick Craig-Wood)
  • SFTP
    • Allow inline ssh public certificate for sftp (Dimitar Ivanov)
    • Fix nil check when using auth proxy (Nick Craig-Wood)
  • Smb
    • Add initial support for Kerberos authentication (more work needed). (Francesco Frassinelli)
    • Fix panic if stat fails (Nick Craig-Wood)
  • Sugarsync
    • Fix server side copying over existing object (Nick Craig-Wood)
  • WebDAV
    • Nextcloud: implement backoff and retry for 423 LOCKED errors (Nick Craig-Wood)
    • Make --webdav-auth-redirect to fix 401 unauthorized on redirect (Nick Craig-Wood)
  • Yandex
    • Fix server side copying over existing object (Nick Craig-Wood)
  • Zoho
    • Use download server to accelerate downloads (buengese)
    • Switch to large file upload API for larger files, fix missing URL encoding of filenames for the upload API (buengese)
    • Print clear error message when missing oauth scope (buengese)
    • Try to handle rate limits a bit better (buengese)
    • Add support for private spaces (buengese)
    • Make upload cutoff configurable (buengese)

v1.68.2 - 2024-11-15

See commits

  • Security fixes
  • Bug Fixes
    • accounting: Fix wrong message on SIGUSR2 to enable/disable bwlimit (Nick Craig-Wood)
    • bisync: Fix output capture restoring the wrong output for logrus (Dimitrios Slamaris)
    • dlna: Fix loggingResponseWriter disregarding log level (Simon Bos)
    • serve s3: Fix excess locking which was making serve s3 single threaded (Nick Craig-Wood)
    • doc fixes (Nick Craig-Wood, tgfisher, Alexandre Hamez, Randy Bush)
  • Local
    • Fix permission and ownership on symlinks with --links and --metadata (Nick Craig-Wood)
    • Fix --copy-links on macOS when cloning (nielash)
  • Onedrive
    • Fix Retry-After handling to look at 503 errors also (Nick Craig-Wood)
  • Pikpak
    • Fix cid/gcid calculations for fs.OverrideRemote (wiserain)
    • Fix fatal crash on startup with token that can't be refreshed (Nick Craig-Wood)
  • S3
    • Fix crash when using --s3-download-url after migration to SDKv2 (Nick Craig-Wood)
    • Storj provider: fix server-side copy of files bigger than 5GB (Kaloyan Raev)
    • Fix multitenant multipart uploads with CEPH (Nick Craig-Wood)

v1.68.1 - 2024-09-24

See commits

  • Bug Fixes
    • build: Fix docker release build (ttionya)
    • doc fixes (Nick Craig-Wood, Pawel Palucha)
    • fs
      • Fix --dump filters not always appearing (Nick Craig-Wood)
      • Fix setting stringArray config values from environment variables (Nick Craig-Wood)
    • rc: Fix default value of --metrics-addr (Nick Craig-Wood)
    • serve docker: Add missing vfs-read-chunk-streams option in docker volume driver (Divyam)
  • Onedrive
    • Fix spurious "Couldn't decode error response: EOF" DEBUG (Nick Craig-Wood)
  • Pikpak
    • Fix login issue where token retrieval fails (wiserain)
  • S3
    • Fix rclone ignoring static credentials when env_auth=true (Nick Craig-Wood)

v1.68.0 - 2024-09-08

See commits

  • New backends
  • Changed backends
    • S3 backend updated to use AWS SDKv2 as v1 is now unsupported.
      • The matrix of providers and auth methods is huge and there could be problems with obscure combinations.
      • Please report problems in a new issue on Github.
  • New commands
    • config encryption: set, remove and check to manage config file encryption (Nick Craig-Wood)
  • New Features
    • build
      • Update to go1.23 and make go1.21 the minimum required version (Nick Craig-Wood)
      • Update all dependencies (Nick Craig-Wood)
      • Disable wasm/js build due to go bug #64856 (Nick Craig-Wood)
      • Enable custom linting rules with ruleguard via gocritic (albertony)
      • Update logging statements to make --use-json-log work always (albertony)
      • Adding new code quality tests and fixing the fallout (albertony)
    • config
      • Internal config re-organised to be more consistent and make it available from the rc (Nick Craig-Wood)
      • Avoid remotes with empty names from the environment (albertony)
      • Make listing of remotes more consistent (albertony)
      • Make getting config values more consistent (albertony)
      • Use --password-command to set config file password if supplied (Nick Craig-Wood)
    • doc fixes (albertony, crystalstall, David Seifert, Eng Zer Jun, Ernie Hershey, Florian Klink, John Oxley, kapitainsky, Mathieu Moreau, Nick Craig-Wood, nipil, Pétr Bozsó, Russ Bubley, Sam Harrison, Thearas, URenko, Will Miles, yuval-cloudinary)
    • fs: Allow semicolons as well as spaces in --bwlimit timetable parsing (Kyle Reynolds)
    • help
      • Global flags help command now takes glob filter (albertony)
      • Make help command output less distracting (albertony)
    • lib/encoder: Add Raw encoding for use where no encoding at all is required, eg --local-encoding Raw (URenko)
    • listremotes: Added options for filtering, ordering and json output (albertony)
    • nfsmount
      • Make the --sudo flag work for umount as well as mount (Nick Craig-Wood)
      • Add -o tcp option to NFS mount options to fix mounting under Linux (Nick Craig-Wood)
    • operations: copy: generate stable partial suffix (Georg Welzel)
    • rc
      • Add options/info call to enumerate options (Nick Craig-Wood)
      • Add option blocks parameter to options/get and options/info (Nick Craig-Wood)
      • Add vfs/queue to show the status of the upload queue (Nick Craig-Wood)
      • Add vfs/queue-set-expiry to adjust expiry of items in the VFS queue (Nick Craig-Wood)
      • Add --unix-socket option to rc command (Florian Klink)
      • Prevent unmount rc command from sending a STOPPING=1 sd-notify message (AThePeanut4)
    • rcserver: Implement prometheus metrics on a dedicated port (Oleg Kunitsyn)
    • serve dlna
      • Also look at "Subs" subdirectory (Florian Klink)
      • Don't swallow video.{idx,sub} (Florian Klink)
      • Set more correct mime type (Florian Klink)
    • serve nfs
      • Implement on disk cache for file handles selected with --nfs-cache-type (Nick Craig-Wood)
      • Add tracing to filesystem calls (Nick Craig-Wood)
      • Mask unimplemented error from chmod (Nick Craig-Wood)
      • Unify the nfs library logging with rclone's logging better (Nick Craig-Wood)
      • Fix incorrect user id and group id exported to NFS (Nick Craig-Wood)
    • serve s3
      • Implement --auth-proxy (Sawjan Gurung)
      • Update to AWS SDKv2 by updating github.com/rclone/gofakes3 (Nick Craig-Wood)
  • Bug Fixes
    • bisync: Fix sync time problems with backends that round time (eg Dropbox) (nielash)
    • serve dlna: Fix panic: invalid argument to Int63n (Nick Craig-Wood)
  • VFS
    • Add --vfs-read-chunk-streams to parallel read chunks from files (Nick Craig-Wood)
      • This can increase mount performance on high bandwidth or large latency links
    • Fix cache encoding with special characters (URenko)
  • Local
    • Fix encoding of root path fix (URenko)
    • Add server-side copy (using clone) with xattrs on macOS (nielash)
      • --local-no-clone flag to disable cloning for server-side copies (nielash)
    • Support setting custom --metadata during server-side Copy (nielash)
  • Azure Blob
    • Allow anonymous access for public resources (Nick Craig-Wood)
  • B2
    • Include custom upload headers in large file info (Pat Patterson)
  • Drive
    • Fix copying Google Docs to a backend which only supports SHA1 (Nick Craig-Wood)
  • Fichier
    • Fix detection of Flood Detected error (Nick Craig-Wood)
    • Fix server side move (Nick Craig-Wood)
  • HTTP
    • Reload client certificates on expiry (Saleh Dindar)
    • Support listening on passed FDs (Florian Klink)
  • Jottacloud
    • Fix setting of metadata on server side move (albertony)
  • Onedrive
    • Fix nil pointer error when uploading small files (Nick Craig-Wood)
  • Pcloud
    • Implement SetModTime (Georg Welzel)
    • Implement OpenWriterAt feature to enable multipart uploads (Georg Welzel)
    • Fix failing large file uploads (Georg Welzel)
  • Pikpak
    • Improve data consistency by ensuring async tasks complete (wiserain)
    • Implement custom hash to replace wrong sha1 (wiserain)
    • Fix error with copyto command (wiserain)
    • Optimize file move by removing unnecessary readMetaData() call (wiserain)
    • Non-buffered hash calculation for local source files (wiserain)
    • Optimize upload by pre-fetching gcid from API (wiserain)
    • Correct file transfer progress for uploads by hash (wiserain)
    • Update to using AWS SDK v2 (wiserain)
  • S3
    • Update to using AWS SDK v2 (Nick Craig-Wood)
      • Add --s3-sdk-log-mode to control SDKv2 debugging (Nick Craig-Wood)
    • Fix incorrect region for Magalu provider (Filipe Herculano)
    • Allow restoring from intelligent-tiering storage class (Pawel Palucha)
  • SFTP
    • Use uint32 for mtime to save memory (Tomasz Melcer)
    • Ignore useless errors when closing the connection pool (Nick Craig-Wood)
    • Support listening on passed FDs (Florian Klink)
  • Swift
    • Add workarounds for bad listings in Ceph RGW (Paul Collins)
    • Add total/free space info in about command. (fsantagostinobietti)
  • Ulozto
    • Fix upload of > 2GB files on 32 bit platforms (Tobias Markus)
  • WebDAV
    • Add --webdav-unix-socket-path to connect to a unix socket (Florian Klink)
  • Yandex
    • Implement custom user agent to help with upload speeds (Sebastian Bünger)
  • Zoho
    • Fix inefficiencies uploading with new API to avoid throttling (Nick Craig-Wood)

v1.67.0 - 2024-06-14

See commits

  • New backends
  • New commands
    • gitannex: Enables git-annex to store and retrieve content from an rclone remote (Dan McArdle)
  • New Features
    • accounting: Add deleted files total size to status summary line (Kyle Reynolds)
    • build
      • Fix CVE-2023-45288 by upgrading golang.org/x/net (Nick Craig-Wood)
      • Fix CVE-2024-35255 by upgrading github.com/Azure/azure-sdk-for-go/sdk/azidentity to 1.6.0 (dependabot)
      • Convert source files with CRLF to LF (albertony)
      • Update all dependencies (Nick Craig-Wood)
    • doc updates (albertony, Alex Garel, Dave Nicolson, Dominik Joe Pantůček, Eric Wolf, Erisa A, Evan Harris, Evan McBeth, Gachoud Philippe, hidewrong, jakzoe, jumbi77, kapitainsky, Kyle Reynolds, Lewis Hook, Nick Craig-Wood, overallteach, pawsey-kbuckley, Pieter van Oostrum, psychopatt, racerole, static-moonlight, Warrentheo, yudrywet, yumeiyin )
    • ncdu: Do not quit on Esc to aid usability (Katia Esposito)
    • rcserver: Set ModTime for dirs and files served by --rc-serve (Nikita Shoshin)
  • Bug Fixes
    • bisync: Add integration tests against all backends and fix many many problems (nielash)
    • config: Fix default value for description (Nick Craig-Wood)
    • copy: Fix nil pointer dereference when corrupted on transfer with nil dst (nielash)
    • fs
      • Improve JSON Unmarshalling for Duration types (Kyle Reynolds)
      • Close the CPU profile on exit (guangwu)
      • Replace /bin/bash with /usr/bin/env bash (Florian Klink)
    • oauthutil: Clear client secret if client ID is set (Michael Terry)
    • operations
      • Rework rcat so that it doesn't call the --metadata-mapper twice (Nick Craig-Wood)
      • Ensure SrcFsType is set correctly when using --metadata-mapper (Nick Craig-Wood)
      • Fix "optional feature not implemented" error with a crypted sftp bug (Nick Craig-Wood)
      • Fix very long file names when using copy with --partial (Nick Craig-Wood)
      • Fix retries downloading too much data with certain backends (Nick Craig-Wood)
      • Fix move when dst is nil and fdst is case-insensitive (nielash)
      • Fix lsjson --encrypted when using --crypt-XXX parameters (Nick Craig-Wood)
      • Fix missing metadata for multipart transfers to local disk (Nick Craig-Wood)
      • Fix incorrect modtime on some multipart transfers (Nick Craig-Wood)
      • Fix hashing problem in integration tests (Nick Craig-Wood)
    • rc
      • Fix stats groups being ignored in operations/check (Nick Craig-Wood)
      • Fix incorrect Content-Type in HTTP API (Kyle Reynolds)
    • serve s3
      • Fix Last-Modified header format (Butanediol)
      • Fix in-memory metadata storing wrong modtime (nielash)
      • Fix XML of error message (Nick Craig-Wood)
    • serve webdav: Fix webdav with --baseurl under Windows (Nick Craig-Wood)
    • serve dlna: Make BrowseMetadata more compliant (albertony)
    • serve http: Added Content-Length header when HTML directory is served (Sunny)
    • sync
      • Don't sync directories if they haven't been modified (Nick Craig-Wood)
      • Don't test reading metadata if we can't write it (Nick Craig-Wood)
      • Fix case normalisation (problem on on s3) (Nick Craig-Wood)
      • Fix management of empty directories to make it more accurate (Nick Craig-Wood)
      • Fix creation of empty directories when --create-empty-src-dirs=false (Nick Craig-Wood)
      • Fix directory modification times not being set (Nick Craig-Wood)
      • Fix "failed to update directory timestamp or metadata: directory not found" (Nick Craig-Wood)
      • Fix expecting SFTP to have MkdirMetadata method: optional feature not implemented (Nick Craig-Wood)
    • test info: Improve cleanup of temp files (Kyle Reynolds)
    • touch: Fix using -R on certain backends (Nick Craig-Wood)
  • Mount
    • Add --direct-io flag to force uncached access (Nick Craig-Wood)
  • VFS
    • Fix download loop when file size shrunk (Nick Craig-Wood)
    • Fix renaming a directory (nielash)
  • Local
    • Add --local-time-type to use mtime/atime/btime/ctime as the time (Nick Craig-Wood)
    • Allow SeBackupPrivilege and/or SeRestorePrivilege to work on Windows (Charles Hamilton)
  • Azure Blob
    • Fix encoding issue with dir path comparison (nielash)
  • B2
    • Add new cleanup and cleanup-hidden backend commands. (Pat Patterson)
    • Update B2 URLs to new home (Nick Craig-Wood)
  • Chunker
    • Fix startup when root points to composite multi-chunk file without metadata (nielash)
    • Fix case-insensitive comparison on local without metadata (nielash)
    • Fix "finalizer already set" error (nielash)
  • Drive
    • Add backend query command for general purpose querying of files (John-Paul Smith)
    • Stop sending notification emails when setting permissions (Nick Craig-Wood)
    • Fix server side copy with metadata from my drive to shared drive (Nick Craig-Wood)
    • Set all metadata permissions and return error summary instead of stopping on the first error (Nick Craig-Wood)
    • Make errors setting permissions into no retry errors (Nick Craig-Wood)
    • Fix description being overwritten on server side moves (Nick Craig-Wood)
    • Allow setting metadata to fail if failok flag is set (Nick Craig-Wood)
    • Fix panic when using --metadata-mapper on large google doc files (Nick Craig-Wood)
  • Dropbox
    • Add --dropbox-root-namespace to override the root namespace (Bill Fraser)
  • Google Cloud Storage
    • Fix encoding issue with dir path comparison (nielash)
  • Hdfs
    • Fix f.String() not including subpath (nielash)
  • Http
    • Add --http-no-escape to not escape URL metacharacters in path names (Kyle Reynolds)
  • Jottacloud
    • Set metadata on server side copy and move (albertony)
  • Linkbox
    • Fix working with names longer than 8-25 Unicode chars. (Vitaly)
    • Fix list paging and optimized synchronization. (gvitali)
  • Mailru
    • Attempt to fix throttling by increasing min sleep to 100ms (Nick Craig-Wood)
  • Memory
    • Fix dst mutating src after server-side copy (nielash)
    • Fix deadlock in operations.Purge (nielash)
    • Fix incorrect list entries when rooted at subdirectory (nielash)
  • Onedrive
    • Add --onedrive-hard-delete to permanently delete files (Nick Craig-Wood)
    • Make server-side copy work in more scenarios (YukiUnHappy)
    • Fix "unauthenticated: Unauthenticated" errors when downloading (Nick Craig-Wood)
    • Fix --metadata-mapper being called twice if writing permissions (nielash)
    • Set all metadata permissions and return error summary instead of stopping on the first error (nielash)
    • Make errors setting permissions into no retry errors (Nick Craig-Wood)
    • Skip writing permissions with 'owner' role (nielash)
    • Fix references to deprecated permissions properties (nielash)
    • Add support for group permissions (nielash)
    • Allow setting permissions to fail if failok flag is set (Nick Craig-Wood)
  • Pikpak
    • Make getFile() usage more efficient to avoid the download limit (wiserain)
    • Improve upload reliability and resolve potential file conflicts (wiserain)
    • Implement configurable chunk size for multipart upload (wiserain)
  • Protondrive
    • Don't auth with an empty access token (Michał Dzienisiewicz)
  • Qingstor
    • Disable integration tests as test account suspended (Nick Craig-Wood)
  • Quatrix
    • Fix f.String() not including subpath (nielash)
  • S3
    • Add new AWS region il-central-1 Tel Aviv (yoelvini)
    • Update Scaleway's configuration options (Alexandre Lavigne)
    • Ceph: fix quirks when creating buckets to fix trying to create an existing bucket (Thomas Schneider)
    • Fix encoding issue with dir path comparison (nielash)
    • Fix 405 error on HEAD for delete marker with versionId (nielash)
    • Validate --s3-copy-cutoff size before copy (hoyho)
  • SFTP
    • Add --sftp-connections to limit the maximum number of connections (Tomasz Melcer)
  • Storj
    • Update storj.io/uplink to latest release (JT Olio)
    • Update bio on request (Nick Craig-Wood)
  • Swift
    • Implement --swift-use-segments-container to allow >5G files on Blomp (Nick Craig-Wood)
  • Union
    • Fix deleting dirs when all remotes can't have empty dirs (Nick Craig-Wood)
  • WebDAV
    • Fix setting modification times erasing checksums on owncloud and nextcloud (nielash)
    • owncloud: Add --webdav-owncloud-exclude-mounts which allows excluding mounted folders when listing remote resources (Thomas Müller)
  • Zoho
    • Fix throttling problem when uploading files (Nick Craig-Wood)
    • Use cursor listing for improved performance (Nick Craig-Wood)
    • Retry reading info after upload if size wasn't returned (Nick Craig-Wood)
    • Remove simple file names complication which is no longer needed (Nick Craig-Wood)
    • Sleep for 60 seconds if rate limit error received (Nick Craig-Wood)

v1.66.0 - 2024-03-10

See commits

  • Major features
    • Rclone will now sync directory modification times if the backend supports it.
    • Rclone will now sync directory metadata if the backend supports it when -M/--metadata is in use.
      • See the overview and look for the D flags in the Metadata column to see which backends support it.
    • Bisync has received many updates see below for more details or bisync's changelog
  • Removed backends
    • amazonclouddrive: Remove Amazon Drive backend code and docs (Nick Craig-Wood)
  • New Features
    • backend
      • Add description field for all backends (Paul Stern)
    • build
      • Update to go1.22 and make go1.20 the minimum required version (Nick Craig-Wood)
      • Fix CVE-2024-24786 by upgrading google.golang.org/protobuf (Nick Craig-Wood)
    • check: Respect --no-unicode-normalization and --ignore-case-sync for --checkfile (nielash)
    • cmd: Much improved shell auto completion which reduces the size of the completion file and works faster (Nick Craig-Wood)
    • doc updates (albertony, ben-ba, Eli, emyarod, huajin tong, Jack Provance, kapitainsky, keongalvin, Nick Craig-Wood, nielash, rarspace01, rzitzer, Tera, Vincent Murphy)
    • fs: Add more detailed logging for file includes/excludes (Kyle Reynolds)
    • lsf
      • Add --time-format flag (nielash)
      • Make metadata appear for directories (Nick Craig-Wood)
    • lsjson: Make metadata appear for directories (Nick Craig-Wood)
    • rc
      • Add srcFs and dstFs to core/stats and core/transferred stats (Nick Craig-Wood)
      • Add operations/hashsum to the rc as rclone hashsum equivalent (Nick Craig-Wood)
      • Add config/paths to the rc as rclone config paths equivalent (Nick Craig-Wood)
    • sync
      • Optionally report list of synced paths to file (nielash)
      • Implement directory sync for mod times and metadata (Nick Craig-Wood)
      • Don't set directory modtimes if already set (nielash)
      • Don't sync directory modtimes from backends which don't have directories (Nick Craig-Wood)
  • Bug Fixes
    • backend
      • Make backends which use oauth implement the Shutdown and shutdown the oauth properly (rkonfj)
    • bisync
      • Handle unicode and case normalization consistently (nielash)
      • Partial uploads known issue on local/ftp/sftp has been resolved (unless using --inplace) (nielash)
      • Fixed handling of unicode normalization and case insensitivity, support for --fix-case, --ignore-case-sync, --no-unicode-normalization (nielash)
      • Bisync no longer fails to find the correct listing file when configs are overridden with backend-specific flags. (nielash)
    • nfsmount
      • Fix exit after external unmount (nielash)
      • Fix --volname being ignored (nielash)
    • operations
      • Fix renaming a file on macOS (nielash)
      • Fix case-insensitive moves in operations.Move (nielash)
      • Fix TestCaseInsensitiveMoveFileDryRun on chunker integration tests (nielash)
      • Fix TestMkdirModTime test (Nick Craig-Wood)
      • Fix TestSetDirModTime for backends with SetDirModTime but not Metadata (Nick Craig-Wood)
      • Fix typo in log messages (nielash)
    • serve nfs: Fix writing files via Finder on macOS (nielash)
    • serve restic: Fix error handling (Michael Eischer)
    • serve webdav: Fix --baseurl without leading / (Nick Craig-Wood)
    • stats: Fix race between ResetCounters and stopAverageLoop called from time.AfterFunc (Nick Craig-Wood)
    • sync
      • --fix-case flag to rename case insensitive dest (nielash)
      • Use operations.DirMove instead of sync.MoveDir for --fix-case (nielash)
    • systemd: Fix detection and switch to the coreos package everywhere rather than having 2 separate libraries (Anagh Kumar Baranwal)
  • Mount
    • Fix macOS not noticing errors with --daemon (Nick Craig-Wood)
    • Notice daemon dying much quicker (Nick Craig-Wood)
  • VFS
    • Fix unicode normalization on macOS (nielash)
  • Bisync
    • Copies and deletes are now handled in one operation instead of two (nielash)
    • --track-renames and --backup-dir are now supported (nielash)
    • Final listings are now generated from sync results, to avoid needing to re-list (nielash)
    • Bisync is now much more resilient to changes that happen during a bisync run, and far less prone to critical errors / undetected changes (nielash)
    • Bisync is now capable of rolling a file listing back in cases of uncertainty, essentially marking the file as needing to be rechecked next time. (nielash)
    • A few basic terminal colors are now supported, controllable with --color (AUTO|NEVER|ALWAYS) (nielash)
    • Initial listing snapshots of Path1 and Path2 are now generated concurrently, using the same "march" infrastructure as check and sync, for performance improvements and less risk of error. (nielash)
    • --resync is now much more efficient (especially for users of --create-empty-src-dirs) (nielash)
    • Google Docs (and other files of unknown size) are now supported (with the same options as in sync) (nielash)
    • Equality checks before a sync conflict rename now fall back to cryptcheck (when possible) or --download, (nielash) instead of of --size-only, when check is not available.
    • Bisync now fully supports comparing based on any combination of size, modtime, and checksum, lifting the prior restriction on backends without modtime support. (nielash)
    • Bisync now supports a "Graceful Shutdown" mode to cleanly cancel a run early without requiring --resync. (nielash)
    • New --recover flag allows robust recovery in the event of interruptions, without requiring --resync. (nielash)
    • A new --max-lock setting allows lock files to automatically renew and expire, for better automatic recovery when a run is interrupted. (nielash)
    • Bisync now supports auto-resolving sync conflicts and customizing rename behavior with new --conflict-resolve, --conflict-loser, and --conflict-suffix flags. (nielash)
    • A new --resync-mode flag allows more control over which version of a file gets kept during a --resync. (nielash)
    • Bisync now supports --retries and --retries-sleep (when --resilient is set.) (nielash)
    • Clarify file operation directions in dry-run logs (Kyle Reynolds)
  • Local
    • Fix cleanRootPath on Windows after go1.21.4 stdlib update (nielash)
    • Implement setting modification time on directories (nielash)
    • Implement modtime and metadata for directories (Nick Craig-Wood)
    • Fix setting of btime on directories on Windows (Nick Craig-Wood)
    • Delete backend implementation of Purge to speed up and make stats (Nick Craig-Wood)
    • Support metadata setting and mapping on server side Move (Nick Craig-Wood)
  • Cache
    • Implement setting modification time on directories (if supported by wrapped remote) (nielash)
    • Implement setting metadata on directories (Nick Craig-Wood)
  • Crypt
    • Implement setting modification time on directories (if supported by wrapped remote) (nielash)
    • Implement setting metadata on directories (Nick Craig-Wood)
    • Improve handling of undecryptable file names (nielash)
    • Add missing error check spotted by linter (Nick Craig-Wood)
  • Azure Blob
    • Implement --azureblob-delete-snapshots (Nick Craig-Wood)
  • B2
    • Clarify exactly what --b2-download-auth-duration does in the docs (Nick Craig-Wood)
  • Chunker
    • Implement setting modification time on directories (if supported by wrapped remote) (nielash)
    • Implement setting metadata on directories (Nick Craig-Wood)
  • Combine
    • Implement setting modification time on directories (if supported by wrapped remote) (nielash)
    • Implement setting metadata on directories (Nick Craig-Wood)
    • Fix directory metadata error on upstream root (nielash)
    • Fix directory move across upstreams (nielash)
  • Compress
    • Implement setting modification time on directories (if supported by wrapped remote) (nielash)
    • Implement setting metadata on directories (Nick Craig-Wood)
  • Drive
    • Implement setting modification time on directories (nielash)
    • Implement modtime and metadata setting for directories (Nick Craig-Wood)
    • Support metadata setting and mapping on server side Move,Copy (Nick Craig-Wood)
  • FTP
    • Fix mkdir with rsftp which is returning the wrong code (Nick Craig-Wood)
  • Hasher
    • Implement setting modification time on directories (if supported by wrapped remote) (nielash)
    • Implement setting metadata on directories (Nick Craig-Wood)
    • Fix error from trying to stop an already-stopped db (nielash)
    • Look for cached hash if passed hash unexpectedly blank (nielash)
  • Imagekit
    • Updated docs and web content (Harshit Budhraja)
    • Updated overview - supported operations (Harshit Budhraja)
  • Mega
    • Fix panic with go1.22 (Nick Craig-Wood)
  • Netstorage
    • Fix Root to return correct directory when pointing to a file (Nick Craig-Wood)
  • Onedrive
    • Add metadata support (nielash)
  • Opendrive
    • Fix moving file/folder within the same parent dir (nielash)
  • Oracle Object Storage
    • Support backend restore command (Nikhil Ahuja)
    • Support workload identity authentication for OKE (Anders Swanson)
  • Protondrive
    • Fix encoding of Root method (Nick Craig-Wood)
  • Quatrix
    • Fix Content-Range header (Volodymyr)
    • Add option to skip project folders (Oksana Zhykina)
    • Fix Root to return correct directory when pointing to a file (Nick Craig-Wood)
  • S3
    • Add --s3-version-deleted to show delete markers in listings when using versions. (Nick Craig-Wood)
    • Add IPv6 support with option --s3-use-dual-stack (Anthony Metzidis)
    • Copy parts in parallel when doing chunked server side copy (Nick Craig-Wood)
    • GCS provider: fix server side copy of files bigger than 5G (Nick Craig-Wood)
    • Support metadata setting and mapping on server side Copy (Nick Craig-Wood)
  • Seafile
    • Fix download/upload error when FILE_SERVER_ROOT is relative (DanielEgbers)
    • Fix Root to return correct directory when pointing to a file (Nick Craig-Wood)
  • SFTP
    • Implement setting modification time on directories (nielash)
    • Set directory modtimes update on write flag (Nick Craig-Wood)
    • Shorten wait delay for external ssh binaries now that we are using go1.20 (Nick Craig-Wood)
  • Swift
    • Avoid unnecessary container versioning check (Joe Cai)
  • Union
    • Implement setting modification time on directories (if supported by wrapped remote) (nielash)
    • Implement setting metadata on directories (Nick Craig-Wood)
  • WebDAV
    • Reduce priority of chunks upload log (Gabriel Ramos)
    • owncloud: Add config owncloud_exclude_shares which allows to exclude shared files and folders when listing remote resources (Thomas Müller)

v1.65.2 - 2024-01-24

See commits

  • Bug Fixes
    • build: bump github.com/cloudflare/circl from 1.3.6 to 1.3.7 (dependabot)
    • docs updates (Nick Craig-Wood, kapitainsky, nielash, Tera, Harshit Budhraja)
  • VFS
    • Fix stale data when using --vfs-cache-mode full (Nick Craig-Wood)
  • Azure Blob
    • IMPORTANT Fix data corruption bug - see #7590 (Nick Craig-Wood)

v1.65.1 - 2024-01-08

See commits

  • Bug Fixes
    • build
      • Bump golang.org/x/crypto to fix ssh terrapin CVE-2023-48795 (dependabot)
      • Update to go1.21.5 to fix Windows path problems (Nick Craig-Wood)
      • Fix docker build on arm/v6 (Nick Craig-Wood)
    • install.sh: fix harmless error message on install (Nick Craig-Wood)
    • accounting: fix stats to show server side transfers (Nick Craig-Wood)
    • doc fixes (albertony, ben-ba, Eli Orzitzer, emyarod, keongalvin, rarspace01)
    • nfsmount: Compile for all unix oses, add --sudo and fix error/option handling (Nick Craig-Wood)
    • operations: Fix files moved by rclone move not being counted as transfers (Nick Craig-Wood)
    • oauthutil: Avoid panic when *token and *ts.token are the same (rkonfj)
    • serve s3: Fix listing oddities (Nick Craig-Wood)
  • VFS
    • Note that --vfs-refresh runs in the background (Nick Craig-Wood)
  • Azurefiles
    • Fix storage base url (Oksana)
  • Crypt
    • Fix rclone move a file over itself deleting the file (Nick Craig-Wood)
  • Chunker
    • Fix rclone move a file over itself deleting the file (Nick Craig-Wood)
  • Compress
    • Fix rclone move a file over itself deleting the file (Nick Craig-Wood)
  • Dropbox
    • Fix used space on dropbox team accounts (Nick Craig-Wood)
  • FTP
    • Fix multi-thread copy (WeidiDeng)
  • Googlephotos
    • Fix nil pointer exception when batch failed (Nick Craig-Wood)
  • Hasher
    • Fix rclone move a file over itself deleting the file (Nick Craig-Wood)
    • Fix invalid memory address error when MaxAge == 0 (nielash)
  • Onedrive
    • Fix error listing: unknown object type <nil> (Nick Craig-Wood)
    • Fix "unauthenticated: Unauthenticated" errors when uploading (Nick Craig-Wood)
  • Oracleobjectstorage
    • Fix object storage endpoint for custom endpoints (Manoj Ghosh)
    • Multipart copy create bucket if it doesn't exist. (Manoj Ghosh)
  • Protondrive
    • Fix CVE-2023-45286 / GHSA-xwh9-gc39-5298 (Nick Craig-Wood)
  • S3
    • Fix crash if no UploadId in multipart upload (Nick Craig-Wood)
  • Smb
    • Fix shares not listed by updating go-smb2 (halms)
  • Union
    • Fix rclone move a file over itself deleting the file (Nick Craig-Wood)

v1.65.0 - 2023-11-26

See commits

  • New backends
    • Azure Files (karan, moongdal, Nick Craig-Wood)
    • ImageKit (Abhinav Dhiman)
    • Linkbox (viktor, Nick Craig-Wood)
  • New commands
    • serve s3: Let rclone act as an S3 compatible server (Mikubill, Artur Neumann, Saw-jan, Nick Craig-Wood)
    • nfsmount: mount command to provide mount mechanism on macOS without FUSE (Saleh Dindar)
    • serve nfs: to serve a remote for use by nfsmount (Saleh Dindar)
  • New Features
    • install.sh: Clean up temp files in install script (Jacob Hands)
    • build
      • Update all dependencies (Nick Craig-Wood)
      • Refactor version info and icon resource handling on windows (albertony)
    • doc updates (albertony, alfish2000, asdffdsazqqq, Dimitri Papadopoulos, Herby Gillot, Joda Stößer, Manoj Ghosh, Nick Craig-Wood)
    • Implement --metadata-mapper to transform metadata with a user supplied program (Nick Craig-Wood)
    • Add ChunkWriterDoesntSeek feature flag and set it for b2 (Nick Craig-Wood)
    • lib/http: Export basic go string functions for use in --template (Gabriel Espinoza)
    • makefile: Use POSIX compatible install arguments (Mina Galić)
    • operations
      • Use less memory when doing multithread uploads (Nick Craig-Wood)
      • Implement --partial-suffix to control extension of temporary file names (Volodymyr)
    • rc
      • Add operations/check to the rc API (Nick Craig-Wood)
      • Always report an error as JSON (Nick Craig-Wood)
      • Set Last-Modified header for files served by --rc-serve (Nikita Shoshin)
    • size: Dont show duplicate object count when less than 1k (albertony)
  • Bug Fixes
    • fshttp: Fix --contimeout being ignored (你知道未来吗)
    • march: Fix excessive parallelism when using --no-traverse (Nick Craig-Wood)
    • ncdu: Fix crash when re-entering changed directory after rescan (Nick Craig-Wood)
    • operations
      • Fix overwrite of destination when multi-thread transfer fails (Nick Craig-Wood)
      • Fix invalid UTF-8 when truncating file names when not using --inplace (Nick Craig-Wood)
    • serve dnla: Fix crash on graceful exit (wuxingzhong)
  • Mount
    • Disable mount for freebsd and alias cmount as mount on that platform (Nick Craig-Wood)
  • VFS
    • Add --vfs-refresh flag to read all the directories on start (Beyond Meat)
    • Implement Name() method in WriteFileHandle and ReadFileHandle (Saleh Dindar)
    • Add go-billy dependency and make sure vfs.Handle implements billy.File (Saleh Dindar)
    • Error out early if can't upload 0 length file (Nick Craig-Wood)
  • Local
    • Fix copying from Windows Volume Shadows (Nick Craig-Wood)
  • Azure Blob
    • Add support for cold tier (Ivan Yanitra)
  • B2
    • Implement "rclone backend lifecycle" to read and set bucket lifecycles (Nick Craig-Wood)
    • Implement --b2-lifecycle to control lifecycle when creating buckets (Nick Craig-Wood)
    • Fix listing all buckets when not needed (Nick Craig-Wood)
    • Fix multi-thread upload with copyto going to wrong name (Nick Craig-Wood)
    • Fix server side chunked copy when file size was exactly --b2-copy-cutoff (Nick Craig-Wood)
    • Fix streaming chunked files an exact multiple of chunk size (Nick Craig-Wood)
  • Box
    • Filter more EventIDs when polling (David Sze)
    • Add more logging for polling (David Sze)
    • Fix performance problem reading metadata for single files (Nick Craig-Wood)
  • Drive
    • Add read/write metadata support (Nick Craig-Wood)
    • Add support for SHA-1 and SHA-256 checksums (rinsuki)
    • Add --drive-show-all-gdocs to allow unexportable gdocs to be server side copied (Nick Craig-Wood)
    • Add a note that --drive-scope accepts comma-separated list of scopes (Keigo Imai)
    • Fix error updating created time metadata on existing object (Nick Craig-Wood)
    • Fix integration tests by enabling metadata support from the context (Nick Craig-Wood)
  • Dropbox
    • Factor batcher into lib/batcher (Nick Craig-Wood)
    • Fix missing encoding for rclone purge (Nick Craig-Wood)
  • Google Cloud Storage
    • Fix 400 Bad request errors when using multi-thread copy (Nick Craig-Wood)
  • Googlephotos
    • Implement batcher for uploads (Nick Craig-Wood)
  • Hdfs
    • Added support for list of namenodes in hdfs remote config (Tayo-pasedaRJ)
  • HTTP
    • Implement set backend command to update running backend (Nick Craig-Wood)
    • Enable methods used with WebDAV (Alen Šiljak)
  • Jottacloud
    • Add support for reading and writing metadata (albertony)
  • Onedrive
    • Implement ListR method which gives --fast-list support (Nick Craig-Wood)
      • This must be enabled with the --onedrive-delta flag
  • Quatrix
    • Add partial upload support (Oksana Zhykina)
    • Overwrite files on conflict during server-side move (Oksana Zhykina)
  • S3
    • Add Linode provider (Nick Craig-Wood)
    • Add docs on how to add a new provider (Nick Craig-Wood)
    • Fix no error being returned when creating a bucket we don't own (Nick Craig-Wood)
    • Emit a debug message if anonymous credentials are in use (Nick Craig-Wood)
    • Add --s3-disable-multipart-uploads flag (Nick Craig-Wood)
    • Detect looping when using gcs and versions (Nick Craig-Wood)
  • SFTP
    • Implement --sftp-copy-is-hardlink to server side copy as hardlink (Nick Craig-Wood)
  • Smb
    • Fix incorrect about size by switching to github.com/cloudsoda/go-smb2 fork (Nick Craig-Wood)
    • Fix modtime of multithread uploads by setting PartialUploads (Nick Craig-Wood)
  • WebDAV
    • Added an rclone vendor to work with rclone serve webdav (Adithya Kumar)

v1.64.2 - 2023-10-19

See commits

  • Bug Fixes
    • selfupdate: Fix "invalid hashsum signature" error (Nick Craig-Wood)
    • build: Fix docker build running out of space (Nick Craig-Wood)

v1.64.1 - 2023-10-17

See commits

  • Bug Fixes
    • cmd: Make --progress output logs in the same format as without (Nick Craig-Wood)
    • docs fixes (Dimitri Papadopoulos Orfanos, Herby Gillot, Manoj Ghosh, Nick Craig-Wood)
    • lsjson: Make sure we set the global metadata flag too (Nick Craig-Wood)
    • operations
      • Ensure concurrency is no greater than the number of chunks (Pat Patterson)
      • Fix OpenOptions ignored in copy if operation was a multiThreadCopy (Vitor Gomes)
      • Fix error message on delete to have file name (Nick Craig-Wood)
    • serve sftp: Return not supported error for not supported commands (Nick Craig-Wood)
    • build: Upgrade golang.org/x/net to v0.17.0 to fix HTTP/2 rapid reset (Nick Craig-Wood)
    • pacer: Fix b2 deadlock by defaulting max connections to unlimited (Nick Craig-Wood)
  • Mount
    • Fix automount not detecting drive is ready (Nick Craig-Wood)
  • VFS
    • Fix update dir modification time (Saleh Dindar)
  • Azure Blob
    • Fix "fatal error: concurrent map writes" (Nick Craig-Wood)
  • B2
    • Fix multipart upload: corrupted on transfer: sizes differ XXX vs 0 (Nick Craig-Wood)
    • Fix locking window when getting multipart upload URL (Nick Craig-Wood)
    • Fix server side copies greater than 4GB (Nick Craig-Wood)
    • Fix chunked streaming uploads (Nick Craig-Wood)
    • Reduce default --b2-upload-concurrency to 4 to reduce memory usage (Nick Craig-Wood)
  • Onedrive
    • Fix the configurator to allow /teams/ID in the config (Nick Craig-Wood)
  • Oracleobjectstorage
    • Fix OpenOptions being ignored in uploadMultipart with chunkWriter (Nick Craig-Wood)
  • S3
    • Fix slice bounds out of range error when listing (Nick Craig-Wood)
    • Fix OpenOptions being ignored in uploadMultipart with chunkWriter (Vitor Gomes)
  • Storj
    • Update storj.io/uplink to v1.12.0 (Kaloyan Raev)

v1.64.0 - 2023-09-11

See commits

  • New backends
  • Major changes
    • Multi-thread transfers (Vitor Gomes, Nick Craig-Wood, Manoj Ghosh, Edwin Mackenzie-Owen)
      • Multi-thread transfers are now available when transferring to:
        • local, s3, azureblob, b2, oracleobjectstorage and smb
      • This greatly improves transfer speed between two network sources.
      • In memory buffering has been unified between all backends and should share memory better.
      • See --multi-thread docs for more info
  • New commands
    • rclone config redacted support mechanism for showing redacted config (Nick Craig-Wood)
  • New Features
    • accounting
      • Show server side stats in own lines and not as bytes transferred (Nick Craig-Wood)
    • bisync
      • Add new --ignore-listing-checksum flag to distinguish from --ignore-checksum (nielash)
      • Add experimental --resilient mode to allow recovery from self-correctable errors (nielash)
      • Add support for --create-empty-src-dirs (nielash)
      • Dry runs no longer commit filter changes (nielash)
      • Enforce --check-access during --resync (nielash)
      • Apply filters correctly during deletes (nielash)
      • Equality check before renaming (leave identical files alone) (nielash)
      • Fix dryRun rc parameter being ignored (nielash)
    • build
      • Update to go1.21 and make go1.19 the minimum required version (Anagh Kumar Baranwal, Nick Craig-Wood)
      • Update dependencies (Nick Craig-Wood)
      • Add snap installation (hideo aoyama)
      • Change Winget Releaser job to ubuntu-latest (sitiom)
    • cmd: Refactor and use sysdnotify in more commands (eNV25)
    • config: Add --multi-thread-chunk-size flag (Vitor Gomes)
    • doc updates (antoinetran, Benjamin, Bjørn Smith, Dean Attali, gabriel-suela, James Braza, Justin Hellings, kapitainsky, Mahad, Masamune3210, Nick Craig-Wood, Nihaal Sangha, Niklas Hambüchen, Raymond Berger, r-ricci, Sawada Tsunayoshi, Tiago Boeing, Vladislav Vorobev)
    • fs
      • Use atomic types everywhere (Roberto Ricci)
      • When --max-transfer limit is reached exit with code (10) (kapitainsky)
      • Add rclone completion powershell - basic implementation only (Nick Craig-Wood)
    • http servers: Allow CORS to be set with --allow-origin flag (yuudi)
    • lib/rest: Remove unnecessary nil check (Eng Zer Jun)
    • ncdu: Add keybinding to rescan filesystem (eNV25)
    • rc
      • Add executeId to job listings (yuudi)
      • Add core/du to measure local disk usage (Nick Craig-Wood)
      • Add operations/settier to API (Drew Stinnett)
    • rclone test info: Add --check-base32768 flag to check can store all base32768 characters (Nick Craig-Wood)
    • rmdirs: Remove directories concurrently controlled by --checkers (Nick Craig-Wood)
  • Bug Fixes
    • accounting: Don't stop calculating average transfer speed until the operation is complete (Jacob Hands)
    • fs: Fix transferTime not being set in JSON logs (Jacob Hands)
    • fshttp: Fix --bind 0.0.0.0 allowing IPv6 and --bind ::0 allowing IPv4 (Nick Craig-Wood)
    • operations: Fix overlapping check on case insensitive file systems (Nick Craig-Wood)
    • serve dlna: Fix MIME type if backend can't identify it (Nick Craig-Wood)
    • serve ftp: Fix race condition when using the auth proxy (Nick Craig-Wood)
    • serve sftp: Fix hash calculations with --vfs-cache-mode full (Nick Craig-Wood)
    • serve webdav: Fix error: Expecting fs.Object or fs.Directory, got nil (Nick Craig-Wood)
    • sync: Fix lockup with --cutoff-mode=soft and --max-duration (Nick Craig-Wood)
  • Mount
    • fix: Mount parsing for linux (Anagh Kumar Baranwal)
  • VFS
    • Add --vfs-cache-min-free-space to control minimum free space on the disk containing the cache (Nick Craig-Wood)
    • Added cache cleaner for directories to reduce memory usage (Anagh Kumar Baranwal)
    • Update parent directory modtimes on vfs actions (David Pedersen)
    • Keep virtual directory status accurate and reduce deadlock potential (Anagh Kumar Baranwal)
    • Make sure struct field is aligned for atomic access (Roberto Ricci)
  • Local
    • Rmdir return an error if the path is not a dir (zjx20)
  • Azure Blob
    • Implement OpenChunkWriter and multi-thread uploads (Nick Craig-Wood)
    • Fix creation of directory markers (Nick Craig-Wood)
    • Fix purging with directory markers (Nick Craig-Wood)
  • B2
    • Implement OpenChunkWriter and multi-thread uploads (Nick Craig-Wood)
    • Fix rclone link when object path contains special characters (Alishan Ladhani)
  • Box
    • Add polling support (David Sze)
    • Add --box-impersonate to impersonate a user ID (Nick Craig-Wood)
    • Fix unhelpful decoding of error messages into decimal numbers (Nick Craig-Wood)
  • Chunker
    • Update documentation to mention issue with small files (Ricardo D'O. Albanus)
  • Compress
    • Fix ChangeNotify (Nick Craig-Wood)
  • Drive
    • Add --drive-fast-list-bug-fix to control ListR bug workaround (Nick Craig-Wood)
  • Fichier
    • Implement DirMove (Nick Craig-Wood)
    • Fix error code parsing (alexia)
  • FTP
    • Add socks_proxy support for SOCKS5 proxies (Zach)
    • Fix 425 "TLS session of data connection not resumed" errors (Nick Craig-Wood)
  • Hdfs
    • Retry "replication in progress" errors when uploading (Nick Craig-Wood)
    • Fix uploading to the wrong object on Update with overridden remote name (Nick Craig-Wood)
  • HTTP
    • CORS should not be sent if not set (yuudi)
    • Fix webdav OPTIONS response (yuudi)
  • Opendrive
    • Fix List on a just deleted and remade directory (Nick Craig-Wood)
  • Oracleobjectstorage
    • Use rclone's rate limiter in multipart transfers (Manoj Ghosh)
    • Implement OpenChunkWriter and multi-thread uploads (Manoj Ghosh)
  • S3
    • Refactor multipart upload to use OpenChunkWriter and ChunkWriter (Vitor Gomes)
    • Factor generic multipart upload into lib/multipart (Nick Craig-Wood)
    • Fix purging of root directory with --s3-directory-markers (Nick Craig-Wood)
    • Add rclone backend set command to update the running config (Nick Craig-Wood)
    • Add rclone backend restore-status command (Nick Craig-Wood)
  • SFTP
    • Stop uploads re-using the same ssh connection to improve performance (Nick Craig-Wood)
    • Add --sftp-ssh to specify an external ssh binary to use (Nick Craig-Wood)
    • Add socks_proxy support for SOCKS5 proxies (Zach)
    • Support dynamic --sftp-path-override (nielash)
    • Fix spurious warning when using --sftp-ssh (Nick Craig-Wood)
  • Smb
    • Implement multi-threaded writes for copies to smb (Edwin Mackenzie-Owen)
  • Storj
    • Performance improvement for large file uploads (Kaloyan Raev)
  • Swift
    • Fix HEADing 0-length objects when --swift-no-large-objects set (Julian Lepinski)
  • Union
    • Add :writback to act as a simple cache (Nick Craig-Wood)
  • WebDAV
    • Nextcloud: fix segment violation in low-level retry (Paul)
  • Zoho
    • Remove Range requests workarounds to fix integration tests (Nick Craig-Wood)

v1.63.1 - 2023-07-17

See commits

  • Bug Fixes
    • build: Fix macos builds for versions < 12 (Anagh Kumar Baranwal)
    • dirtree: Fix performance with large directories of directories and --fast-list (Nick Craig-Wood)
    • operations
      • Fix deadlock when using lsd/ls with --progress (Nick Craig-Wood)
      • Fix .rclonelink files not being converted back to symlinks (Nick Craig-Wood)
    • doc fixes (Dean Attali, Mahad, Nick Craig-Wood, Sawada Tsunayoshi, Vladislav Vorobev)
  • Local
    • Fix partial directory read for corrupted filesystem (Nick Craig-Wood)
  • Box
    • Fix reconnect failing with HTTP 400 Bad Request (albertony)
  • Smb
    • Fix "Statfs failed: bucket or container name is needed" when mounting (Nick Craig-Wood)
  • WebDAV
    • Nextcloud: fix must use /dav/files/USER endpoint not /webdav error (Paul)
    • Nextcloud chunking: add more guidance for the user to check the config (darix)

v1.63.0 - 2023-06-30

See commits

  • New backends
  • Major changes
    • Files will be copied to a temporary name ending in .partial when copying to local,ftp,sftp then renamed at the end of the transfer. (Janne Hellsten, Nick Craig-Wood)
      • This helps with data integrity as we don't delete the existing file until the new one is complete.
      • It can be disabled with the --inplace flag.
      • This behaviour will also happen if the backend is wrapped, for example sftp wrapped with crypt.
    • The s3, azureblob and gcs backends now support directory markers so empty directories are supported (Jānis Bebrītis, Nick Craig-Wood)
    • The --default-time flag now controls the unknown modification time of files/dirs (Nick Craig-Wood)
      • If a file or directory does not have a modification time rclone can read then rclone will display this fixed time instead.
      • For the old behaviour use --default-time 0s which will set this time to the time rclone started up.
  • New Features
    • build
      • Modernise linters in use and fixup all affected code (albertony)
      • Push docker beta to GHCR (GitHub container registry) (Richard Tweed)
    • cat: Add --separator option to cat command (Loren Gordon)
    • config
      • Do not remove/overwrite other files during config file save (albertony)
      • Do not overwrite config file symbolic link (albertony)
      • Stop config create making invalid config files (Nick Craig-Wood)
    • doc updates (Adam K, Aditya Basu, albertony, asdffdsazqqq, Damo, danielkrajnik, Dimitri Papadopoulos, dlitster, Drew Parsons, jumbi77, kapitainsky, mac-15, Mariusz Suchodolski, Nick Craig-Wood, NickIAm, Rintze Zelle, Stanislav Gromov, Tareq Sharafy, URenko, yuudi, Zach Kipp)
    • fs
      • Add size to JSON logs when moving or copying an object (Nick Craig-Wood)
      • Allow boolean features to be enabled with --disable !Feature (Nick Craig-Wood)
    • genautocomplete: Rename to completion with alias to the old name (Nick Craig-Wood)
    • librclone: Added example on using librclone with Go (alankrit)
    • lsjson: Make --stat more efficient (Nick Craig-Wood)
    • operations
      • Implement --multi-thread-write-buffer-size for speed improvements on downloads (Paulo Schreiner)
      • Reopen downloads on error when using check --download and cat (Nick Craig-Wood)
    • rc: config/listremotes includes remotes defined with environment variables (kapitainsky)
    • selfupdate: Obey --no-check-certificate flag (Nick Craig-Wood)
    • serve restic: Trigger systemd notify (Shyim)
    • serve webdav: Implement owncloud checksum and modtime extensions (WeidiDeng)
    • sync: --suffix-keep-extension preserve 2 part extensions like .tar.gz (Nick Craig-Wood)
  • Bug Fixes
    • accounting
      • Fix Prometheus metrics to be the same as core/stats (Nick Craig-Wood)
      • Bwlimit signal handler should always start (Sam Lai)
    • bisync: Fix maxDelete parameter being ignored via the rc (Nick Craig-Wood)
    • cmd/ncdu: Fix screen corruption when logging (eNV25)
    • filter: Fix deadlock with errors on --files-from (douchen)
    • fs
      • Fix interaction between --progress and --interactive (Nick Craig-Wood)
      • Fix infinite recursive call in pacer ModifyCalculator (fixes issue reported by the staticcheck linter) (albertony)
    • lib/atexit: Ensure OnError only calls cancel function once (Nick Craig-Wood)
    • lib/rest: Fix problems re-using HTTP connections (Nick Craig-Wood)
    • rc
      • Fix operations/stat with trailing / (Nick Craig-Wood)
      • Fix missing --rc flags (Nick Craig-Wood)
      • Fix output of Time values in options/get (Nick Craig-Wood)
    • serve dlna: Fix potential data race (Nick Craig-Wood)
    • version: Fix reported os/kernel version for windows (albertony)
  • Mount
    • Add --mount-case-insensitive to force the mount to be case insensitive (Nick Craig-Wood)
    • Removed unnecessary byte slice allocation for reads (Anagh Kumar Baranwal)
    • Clarify rclone mount error when installed via homebrew (Nick Craig-Wood)
    • Added _netdev to the example mount so it gets treated as a remote-fs rather than local-fs (Anagh Kumar Baranwal)
  • Mount2
    • Updated go-fuse version (Anagh Kumar Baranwal)
    • Fixed statfs (Anagh Kumar Baranwal)
    • Disable xattrs (Anagh Kumar Baranwal)
  • VFS
    • Add MkdirAll function to make a directory and all beneath (Nick Craig-Wood)
    • Fix reload: failed to add virtual dir entry: file does not exist (Nick Craig-Wood)
    • Fix writing to a read only directory creating spurious directory entries (WeidiDeng)
    • Fix potential data race (Nick Craig-Wood)
    • Fix backends being Shutdown too early when startup takes a long time (Nick Craig-Wood)
  • Local
    • Fix filtering of symlinks with -l/--links flag (Nick Craig-Wood)
    • Fix /path/to/file.rclonelink when -l/--links is in use (Nick Craig-Wood)
    • Fix crash with --metadata on Android (Nick Craig-Wood)
  • Cache
    • Fix backends shutting down when in use when used via the rc (Nick Craig-Wood)
  • Crypt
    • Add --crypt-suffix option to set a custom suffix for encrypted files (jladbrook)
    • Add --crypt-pass-bad-blocks to allow corrupted file output (Nick Craig-Wood)
    • Fix reading 0 length files (Nick Craig-Wood)
    • Try not to return "unexpected EOF" error (Nick Craig-Wood)
    • Reduce allocations (albertony)
    • Recommend Dropbox for base32768 encoding (Nick Craig-Wood)
  • Azure Blob
    • Empty directory markers (Nick Craig-Wood)
    • Support azure workload identities (Tareq Sharafy)
    • Fix azure blob uploads with multiple bits of metadata (Nick Craig-Wood)
    • Fix azurite compatibility by sending nil tier if set to empty string (Roel Arents)
  • Combine
    • Implement missing methods (Nick Craig-Wood)
    • Fix goroutine stack overflow on bad object (Nick Craig-Wood)
  • Drive
    • Add --drive-env-auth to get IAM credentials from runtime (Peter Brunner)
    • Update drive service account guide (Juang, Yi-Lin)
    • Fix change notify picking up files outside the root (Nick Craig-Wood)
    • Fix trailing slash mis-identificaton of folder as file (Nick Craig-Wood)
    • Fix incorrect remote after Update on object (Nick Craig-Wood)
  • Dropbox
    • Implement --dropbox-pacer-min-sleep flag (Nick Craig-Wood)
    • Fix the dropbox batcher stalling (Misty)
  • Fichier
    • Add --ficicher-cdn option to use the CDN for download (Nick Craig-Wood)
  • FTP
    • Lower log message priority when SetModTime is not supported to debug (Tobias Gion)
    • Fix "unsupported LIST line" errors on startup (Nick Craig-Wood)
    • Fix "501 Not a valid pathname." errors when creating directories (Nick Craig-Wood)
  • Google Cloud Storage
    • Empty directory markers (Jānis Bebrītis, Nick Craig-Wood)
    • Added --gcs-user-project needed for requester pays (Christopher Merry)
  • HTTP
    • Add client certificate user auth middleware. This can auth serve restic from the username in the client cert. (Peter Fern)
  • Jottacloud
    • Fix vfs writeback stuck in a failed upload loop with file versioning disabled (albertony)
  • Onedrive
    • Add --onedrive-av-override flag to download files flagged as virus (Nick Craig-Wood)
    • Fix quickxorhash on 32 bit architectures (Nick Craig-Wood)
    • Report any list errors during rclone cleanup (albertony)
  • Putio
    • Fix uploading to the wrong object on Update with overridden remote name (Nick Craig-Wood)
    • Fix modification times not being preserved for server side copy and move (Nick Craig-Wood)
    • Fix server side copy failures (400 errors) (Nick Craig-Wood)
  • S3
    • Empty directory markers (Jānis Bebrītis, Nick Craig-Wood)
    • Update Scaleway storage classes (Brian Starkey)
    • Fix --s3-versions on individual objects (Nick Craig-Wood)
    • Fix hang on aborting multipart upload with iDrive e2 (Nick Craig-Wood)
    • Fix missing "tier" metadata (Nick Craig-Wood)
    • Fix V3sign: add missing subresource delete (cc)
    • Fix Arvancloud Domain and region changes and alphabetise the provider (Ehsan Tadayon)
    • Fix Qiniu KODO quirks virtualHostStyle is false (zzq)
  • SFTP
    • Add --sftp-host-key-algorithms to allow specifying SSH host key algorithms (Joel)
    • Fix using --sftp-key-use-agent and --sftp-key-file together needing private key file (Arnav Singh)
    • Fix move to allow overwriting existing files (Nick Craig-Wood)
    • Don't stat directories before listing them (Nick Craig-Wood)
    • Don't check remote points to a file if it ends with / (Nick Craig-Wood)
  • Sharefile
    • Disable streamed transfers as they no longer work (Nick Craig-Wood)
  • Smb
    • Code cleanup to avoid overwriting ctx before first use (fixes issue reported by the staticcheck linter) (albertony)
  • Storj
    • Fix "uplink: too many requests" errors when uploading to the same file (Nick Craig-Wood)
    • Fix uploading to the wrong object on Update with overridden remote name (Nick Craig-Wood)
  • Swift
    • Ignore 404 error when deleting an object (Nick Craig-Wood)
  • Union
    • Implement missing methods (Nick Craig-Wood)
    • Allow errors to be unwrapped for inspection (Nick Craig-Wood)
  • Uptobox
    • Add --uptobox-private flag to make all uploaded files private (Nick Craig-Wood)
    • Fix improper regex (Aaron Gokaslan)
    • Fix Update returning the wrong object (Nick Craig-Wood)
    • Fix rmdir declaring that directories weren't empty (Nick Craig-Wood)
  • WebDAV
    • nextcloud: Add support for chunked uploads (Paul)
    • Set modtime using propset for owncloud and nextcloud (WeidiDeng)
    • Make pacer minSleep configurable with --webdav-pacer-min-sleep (ed)
    • Fix server side copy/move not overwriting (WeidiDeng)
    • Fix modtime on server side copy for owncloud and nextcloud (Nick Craig-Wood)
  • Yandex
    • Fix 400 Bad Request on transfer failure (Nick Craig-Wood)
  • Zoho
    • Fix downloads with Range: header returning the wrong data (Nick Craig-Wood)

v1.62.2 - 2023-03-16

See commits

  • Bug Fixes
    • docker volume plugin: Add missing fuse3 dependency (Nick Craig-Wood)
    • docs: Fix size documentation (asdffdsazqqq)
  • FTP
    • Fix 426 errors on downloads with vsftpd (Lesmiscore)

v1.62.1 - 2023-03-15

See commits

  • Bug Fixes
    • docker: Add missing fuse3 dependency (cycneuramus)
    • build: Update release docs to be more careful with the tag (Nick Craig-Wood)
    • build: Set Github release to draft while uploading binaries (Nick Craig-Wood)

v1.62.0 - 2023-03-14

See commits

  • New Features
    • accounting: Make checkers show what they are doing (Nick Craig-Wood)
    • authorize: Add support for custom templates (Hunter Wittenborn)
    • build
      • Update to go1.20 (Nick Craig-Wood, Anagh Kumar Baranwal)
      • Add winget releaser workflow (Ryan Caezar Itang)
      • Add dependabot (Ryan Caezar Itang)
    • doc updates (albertony, Bryan Kaplan, Gerard Bosch, IMTheNachoMan, Justin Winokur, Manoj Ghosh, Nick Craig-Wood, Ole Frost, Peter Brunner, piyushgarg, Ryan Caezar Itang, Simmon Li, ToBeFree)
    • filter: Emit INFO message when can't work out directory filters (Nick Craig-Wood)
    • fs
      • Added multiple ca certificate support. (alankrit)
      • Add --max-delete-size a delete size threshold (Leandro Sacchet)
    • fspath: Allow the symbols @ and + in remote names (albertony)
    • lib/terminal: Enable windows console virtual terminal sequences processing (ANSI/VT100 colors) (albertony)
    • move: If --check-first and --order-by are set then delete with perfect ordering (Nick Craig-Wood)
    • serve http: Support --auth-proxy (Matthias Baur)
  • Bug Fixes
    • accounting
      • Avoid negative ETA values for very slow speeds (albertony)
      • Limit length of ETA string (albertony)
      • Show human readable elapsed time when longer than a day (albertony)
    • all: Apply codeql fixes (Aaron Gokaslan)
    • build
      • Fix condition for manual workflow run (albertony)
      • Fix building for ARMv5 and ARMv6 (albertony)
        • selfupdate: Consider ARM version
        • install.sh: fix ARMv6 download
        • version: Report ARM version
    • deletefile: Return error code 4 if file does not exist (Nick Craig-Wood)
    • docker: Fix volume plugin does not remount volume on docker restart (logopk)
    • fs: Fix race conditions in --max-delete and --max-delete-size (Nick Craig-Wood)
    • lib/oauthutil: Handle fatal errors better (Alex Chen)
    • mount2: Fix --allow-non-empty (Nick Craig-Wood)
    • operations: Fix concurrency: use --checkers unless transferring files (Nick Craig-Wood)
    • serve ftp: Fix timestamps older than 1 year in listings (Nick Craig-Wood)
    • sync: Fix concurrency: use --checkers unless transferring files (Nick Craig-Wood)
    • tree
      • Fix nil pointer exception on stat failure (Nick Craig-Wood)
      • Fix colored output on windows (albertony)
      • Fix display of files with illegal Windows file system names (Nick Craig-Wood)
  • Mount
    • Fix creating and renaming files on case insensitive backends (Nick Craig-Wood)
    • Do not treat \\?\ prefixed paths as network share paths on windows (albertony)
    • Fix check for empty mount point on Linux (Nick Craig-Wood)
    • Fix --allow-non-empty (Nick Craig-Wood)
    • Avoid incorrect or premature overlap check on windows (albertony)
    • Update to fuse3 after bazil.org/fuse update (Nick Craig-Wood)
  • VFS
    • Make uploaded files retain modtime with non-modtime backends (Nick Craig-Wood)
    • Fix incorrect modtime on fs which don't support setting modtime (Nick Craig-Wood)
    • Fix rename of directory containing files to be uploaded (Nick Craig-Wood)
  • Local
    • Fix %!w(<nil>) in "failed to read directory" error (Marks Polakovs)
    • Fix exclusion of dangling symlinks with -L/--copy-links (Nick Craig-Wood)
  • Crypt
    • Obey --ignore-checksum (Nick Craig-Wood)
    • Fix for unencrypted directory names on case insensitive remotes (Ole Frost)
  • Azure Blob
    • Remove workarounds for SDK bugs after v0.6.1 update (Nick Craig-Wood)
  • B2
    • Fix uploading files bigger than 1TiB (Nick Craig-Wood)
  • Drive
    • Note that --drive-acknowledge-abuse needs SA Manager permission (Nick Craig-Wood)
    • Make --drive-stop-on-upload-limit to respond to storageQuotaExceeded (Ninh Pham)
  • FTP
    • Retry 426 errors (Nick Craig-Wood)
    • Retry errors when initiating downloads (Nick Craig-Wood)
    • Revert to upstream github.com/jlaffaye/ftp now fix is merged (Nick Craig-Wood)
  • Google Cloud Storage
    • Add --gcs-env-auth to pick up IAM credentials from env/instance (Peter Brunner)
  • Mega
    • Add --mega-use-https flag (NodudeWasTaken)
  • Onedrive
    • Default onedrive personal to QuickXorHash as Microsoft is removing SHA1 (Nick Craig-Wood)
    • Add --onedrive-hash-type to change the hash in use (Nick Craig-Wood)
    • Improve speed of QuickXorHash (LXY)
  • Oracle Object Storage
    • Speed up operations by using S3 pacer and setting minsleep to 10ms (Manoj Ghosh)
    • Expose the storage_tier option in config (Manoj Ghosh)
    • Bring your own encryption keys (Manoj Ghosh)
  • S3
    • Check multipart upload ETag when --s3-no-head is in use (Nick Craig-Wood)
    • Add --s3-sts-endpoint to specify STS endpoint (Nick Craig-Wood)
    • Fix incorrect tier support for StorJ and IDrive when pointing at a file (Ole Frost)
    • Fix AWS STS failing if --s3-endpoint is set (Nick Craig-Wood)
    • Make purge remove directory markers too (Nick Craig-Wood)
  • Seafile
    • Renew library password (Fred)
  • SFTP
    • Fix uploads being 65% slower than they should be with crypt (Nick Craig-Wood)
  • Smb
    • Allow SPN (service principal name) to be configured (Nick Craig-Wood)
    • Check smb connection is closed (happyxhw)
  • Storj
    • Implement rclone link (Kaloyan Raev)
    • Implement rclone purge (Kaloyan Raev)
    • Update satellite urls and labels (Kaloyan Raev)
  • WebDAV
    • Fix interop with davrods server (Nick Craig-Wood)

v1.61.1 - 2022-12-23

See commits

  • Bug Fixes
    • docs:
      • Show only significant parts of version number in version introduced label (albertony)
      • Fix unescaped HTML (Nick Craig-Wood)
    • lib/http: Shutdown all servers on exit to remove unix socket (Nick Craig-Wood)
    • rc: Fix --rc-addr flag (which is an alternate for --url) (Anagh Kumar Baranwal)
    • serve restic
      • Don't serve via http if serving via --stdio (Nick Craig-Wood)
      • Fix immediate exit when not using stdio (Nick Craig-Wood)
    • serve webdav
      • Fix --baseurl handling after lib/http refactor (Nick Craig-Wood)
      • Fix running duplicate Serve call (Nick Craig-Wood)
  • Azure Blob
    • Fix "409 Public access is not permitted on this storage account" (Nick Craig-Wood)
  • S3
    • storj: Update endpoints (Kaloyan Raev)

v1.61.0 - 2022-12-20

See commits

  • New backends
  • New Features
    • build: Add vulnerability testing using govulncheck (albertony)
    • cmd: Enable SIGINFO (Ctrl-T) handler on FreeBSD, NetBSD, OpenBSD and Dragonfly BSD (x3-apptech)
    • config: Add config/setpath for setting config path via rc/librclone (Nick Craig-Wood)
    • dedupe
      • Count Checks in the stats while scanning for duplicates (Nick Craig-Wood)
      • Make dedupe obey the filters (Nick Craig-Wood)
    • dlna: Properly attribute code used from https://github.com/anacrolix/dms (Nick Craig-Wood)
    • docs
      • Add minimum versions and status badges to backend and command docs (Nick Craig-Wood, albertony)
      • Remote names may not start or end with space (albertony)
    • filter: Add metadata filters --metadata-include/exclude/filter and friends (Nick Craig-Wood)
    • fs
      • Make all duration flags take y, M, w, d etc suffixes (Nick Craig-Wood)
      • Add global flag --color to control terminal colors (Kevin Verstaen)
    • fspath: Allow unicode numbers and letters in remote names (albertony)
    • lib/file: Improve error message for creating dir on non-existent network host on windows (albertony)
    • lib/http: Finish port of rclone servers to lib/http (Tom Mombourquette, Nick Craig-Wood)
    • lib/oauthutil: Improved usability of config flows needing web browser (Ole Frost)
    • ncdu
      • Add support for modification time (albertony)
      • Fallback to sort by name also for sort by average size (albertony)
      • Rework to use tcell directly instead of the termbox wrapper (eNV25)
    • rc: Add commands to set GC Percent & Memory Limit (go 1.19+) (Anagh Kumar Baranwal)
    • rcat: Preserve metadata when Copy falls back to Rcat (Nick Craig-Wood)
    • rcd: Refactor rclone rc server to use lib/http (Nick Craig-Wood)
    • rcserver: Avoid generating default credentials with htpasswd (Kamui)
    • restic: Refactor to use lib/http (Nolan Woods)
    • serve http: Support unix sockets and multiple listeners (Tom Mombourquette)
    • serve webdav: Refactor to use lib/http (Nick Craig-Wood)
    • test: Replace defer cleanup with t.Cleanup (Eng Zer Jun)
    • test memory: Read metadata if -M flag is specified (Nick Craig-Wood)
    • wasm: Comply with wasm_exec.js licence terms (Matthew Vernon)
  • Bug Fixes
    • build: Update golang.org/x/net/http2 to fix GO-2022-1144 (Nick Craig-Wood)
    • restic: Fix typo in docs 'remove' should be 'remote' (asdffdsazqqq)
    • serve dlna: Fix panic: Logger uninitialized. (Nick Craig-Wood)
  • Mount
    • Update cgofuse for FUSE-T support for mounting volumes on Mac (Nick Craig-Wood)
  • VFS
    • Windows: fix slow opening of exe files by not truncating files when not necessary (Nick Craig-Wood)
    • Fix IO Error opening a file with O_CREATE|O_RDONLY in --vfs-cache-mode not full (Nick Craig-Wood)
  • Crypt
    • Fix compress wrapping crypt giving upload errors (Nick Craig-Wood)
  • Azure Blob
    • Port to new SDK (Nick Craig-Wood)
      • Revamp authentication to include all methods and docs (Nick Craig-Wood)
      • Port old authentication methods to new SDK (Nick Craig-Wood, Brad Ackerman)
      • Thanks to Stonebranch for sponsoring this work.
    • Add --azureblob-no-check-container to assume container exists (Nick Craig-Wood)
    • Add --use-server-modtime support (Abdullah Saglam)
    • Add support for custom upload headers (rkettelerij)
    • Allow emulator account/key override (Roel Arents)
    • Support simple "environment credentials" (Nathaniel Wesley Filardo)
    • Ignore AuthorizationFailure when trying to create a create a container (Nick Craig-Wood)
  • Box
    • Added note on Box API rate limits (Ole Frost)
  • Drive
    • Handle shared drives with leading/trailing space in name (related to) (albertony)
  • FTP
    • Update help text of implicit/explicit TLS options to refer to FTPS instead of FTP (ycdtosa)
    • Improve performance to speed up --files-from and NewObject (Anthony Pessy)
  • HTTP
    • Parse GET responses when no_head is set (Arnie97)
    • Do not update object size based on Range requests (Arnie97)
    • Support Content-Range response header (Arnie97)
  • Onedrive
    • Document workaround for shared with me files (vanplus)
  • S3
    • Add Liara LOS to provider list (MohammadReza)
    • Add DigitalOcean Spaces regions sfo3, fra1, syd1 (Jack)
    • Avoid privileged GetBucketLocation to resolve s3 region (Anthony Pessy)
    • Stop setting object and bucket ACL to private if it is an empty string (Philip Harvey)
    • If bucket or object ACL is empty string then don't add X-Amz-Acl: header (Nick Craig-Wood)
    • Reduce memory consumption for s3 objects (Erik Agterdenbos)
    • Fix listing loop when using v2 listing on v1 server (Nick Craig-Wood)
    • Fix nil pointer exception when using Versions (Nick Craig-Wood)
    • Fix excess memory usage when using versions (Nick Craig-Wood)
    • Ignore versionIDs from uploads unless using --s3-versions or --s3-versions-at (Nick Craig-Wood)
  • SFTP
    • Add configuration options to set ssh Ciphers / MACs / KeyExchange (dgouju)
    • Auto-detect shell type for fish (albertony)
    • Fix NewObject with leading / (Nick Craig-Wood)
  • Smb
    • Fix issue where spurious dot directory is created (albertony)
  • Storj
    • Implement server side Copy (Kaloyan Raev)

v1.60.1 - 2022-11-17

See commits

  • Bug Fixes
    • lib/cache: Fix alias backend shutting down too soon (Nick Craig-Wood)
    • wasm: Fix walltime link error by adding up-to-date wasm_exec.js (João Henrique Franco)
    • docs
      • Update faq.md with bisync (Samuel Johnson)
      • Corrected download links in windows install docs (coultonluke)
      • Add direct download link for windows arm64 (albertony)
      • Remove link to rclone slack as it is no longer supported (Nick Craig-Wood)
      • Faq: how to use a proxy server that requires a username and password (asdffdsazqqq)
      • Oracle-object-storage: doc fix (Manoj Ghosh)
      • Fix typo remove in rclone_serve_restic command (Joda Stößer)
      • Fix character that was incorrectly interpreted as markdown (Clément Notin)
  • VFS
    • Fix deadlock caused by cache cleaner and upload finishing (Nick Craig-Wood)
  • Local
    • Clean absolute paths (albertony)
    • Fix -L/--copy-links with filters missing directories (Nick Craig-Wood)
  • Mailru
    • Note that an app password is now needed (Nick Craig-Wood)
    • Allow timestamps to be before the epoch 1970-01-01 (Nick Craig-Wood)
  • S3
    • Add provider quirk --s3-might-gzip to fix corrupted on transfer: sizes differ (Nick Craig-Wood)
    • Allow Storj to server side copy since it seems to work now (Nick Craig-Wood)
    • Fix for unchecked err value in s3 listv2 (Aaron Gokaslan)
    • Add additional Wasabi locations (techknowlogick)
  • Smb
    • Fix Failed to sync: context canceled at the end of syncs (Nick Craig-Wood)
  • WebDAV
    • Fix Move/Copy/DirMove when using -server-side-across-configs (Nick Craig-Wood)

v1.60.0 - 2022-10-21

See commits

  • New backends
  • New Features
    • build
      • Update to go1.19 and make go1.17 the minimum required version (Nick Craig-Wood)
      • Install.sh: fix arm-v7 download (Ole Frost)
    • fs: Warn the user when using an existing remote name without a colon (Nick Craig-Wood)
    • httplib: Add --xxx-min-tls-version option to select minimum TLS version for HTTP servers (Robert Newson)
    • librclone: Add PHP bindings and test program (Jordi Gonzalez Muñoz)
    • operations
      • Add --server-side-across-configs global flag for any backend (Nick Craig-Wood)
      • Optimise --copy-dest and --compare-dest (Nick Craig-Wood)
    • rc: add job/stopgroup to stop group (Evan Spensley)
    • serve dlna
      • Add --announce-interval to control SSDP Announce Interval (YanceyChiew)
      • Add --interface to Specify SSDP interface names line (Simon Bos)
      • Add support for more external subtitles (YanceyChiew)
      • Add verification of addresses (YanceyChiew)
    • sync: Optimise --copy-dest and --compare-dest (Nick Craig-Wood)
    • doc updates (albertony, Alexander Knorr, anonion, João Henrique Franco, Josh Soref, Lorenzo Milesi, Marco Molteni, Mark Trolley, Ole Frost, partev, Ryan Morey, Tom Mombourquette, YFdyh000)
  • Bug Fixes
    • filter
      • Fix incorrect filtering with UseFilter context flag and wrapping backends (Nick Craig-Wood)
      • Make sure we check --files-from when looking for a single file (Nick Craig-Wood)
    • rc
      • Fix mount/listmounts not returning the full Fs entered in mount/mount (Tom Mombourquette)
      • Handle external unmount when mounting (Isaac Aymerich)
      • Validate Daemon option is not set when mounting a volume via RC (Isaac Aymerich)
    • sync: Update docs and error messages to reflect fixes to overlap checks (Nick Naumann)
  • VFS
    • Reduce memory use by embedding sync.Cond (Nick Craig-Wood)
    • Reduce memory usage by re-ordering commonly used structures (Nick Craig-Wood)
    • Fix excess CPU used by VFS cache cleaner looping (Nick Craig-Wood)
  • Local
    • Obey file filters in listing to fix errors on excluded files (Nick Craig-Wood)
    • Fix "Failed to read metadata: function not implemented" on old Linux kernels (Nick Craig-Wood)
  • Compress
    • Fix crash due to nil metadata (Nick Craig-Wood)
    • Fix error handling to not use or return nil objects (Nick Craig-Wood)
  • Drive
    • Make --drive-stop-on-upload-limit obey quota exceeded error (Steve Kowalik)
  • FTP
    • Add --ftp-force-list-hidden option to show hidden items (Øyvind Heddeland Instefjord)
    • Fix hang when using ExplicitTLS to certain servers. (Nick Craig-Wood)
  • Google Cloud Storage
    • Add --gcs-endpoint flag and config parameter (Nick Craig-Wood)
  • Hubic
    • Remove backend as service has now shut down (Nick Craig-Wood)
  • Onedrive
    • Rename Onedrive(cn) 21Vianet to Vnet Group (Yen Hu)
    • Disable change notify in China region since it is not supported (Nick Craig-Wood)
  • S3
    • Implement --s3-versions flag to show old versions of objects if enabled (Nick Craig-Wood)
    • Implement --s3-version-at flag to show versions of objects at a particular time (Nick Craig-Wood)
    • Implement backend versioning command to get/set bucket versioning (Nick Craig-Wood)
    • Implement Purge to purge versions and backend cleanup-hidden (Nick Craig-Wood)
    • Add --s3-decompress flag to decompress gzip-encoded files (Nick Craig-Wood)
    • Add --s3-sse-customer-key-base64 to supply keys with binary data (Richard Bateman)
    • Try to keep the maximum precision in ModTime with --user-server-modtime (Nick Craig-Wood)
    • Drop binary metadata with an ERROR message as it can't be stored (Nick Craig-Wood)
    • Add --s3-no-system-metadata to suppress read and write of system metadata (Nick Craig-Wood)
  • SFTP
    • Fix directory creation races (Lesmiscore)
  • Swift
    • Add --swift-no-large-objects to reduce HEAD requests (Nick Craig-Wood)
  • Union
    • Propagate SlowHash feature to fix hasher interaction (Lesmiscore)

v1.59.2 - 2022-09-15

See commits

  • Bug Fixes
    • config: Move locking to fix fatal error: concurrent map read and map write (Nick Craig-Wood)
  • Local
    • Disable xattr support if the filesystems indicates it is not supported (Nick Craig-Wood)
  • Azure Blob
    • Fix chunksize calculations producing too many parts (Nick Craig-Wood)
  • B2
    • Fix chunksize calculations producing too many parts (Nick Craig-Wood)
  • S3
    • Fix chunksize calculations producing too many parts (Nick Craig-Wood)

v1.59.1 - 2022-08-08

See commits

  • Bug Fixes
    • accounting: Fix panic in core/stats-reset with unknown group (Nick Craig-Wood)
    • build: Fix android build after GitHub actions change (Nick Craig-Wood)
    • dlna: Fix SOAP action header parsing (Joram Schrijver)
    • docs: Fix links to mount command from install docs (albertony)
    • dropbox: Fix ChangeNotify was unable to decrypt errors (Nick Craig-Wood)
    • fs: Fix parsing of times and durations of the form "YYYY-MM-DD HH:MM:SS" (Nick Craig-Wood)
    • serve sftp: Fix checksum detection (Nick Craig-Wood)
    • sync: Add accidentally missed filter-sensitivity to --backup-dir option (Nick Naumann)
  • Combine
    • Fix docs showing remote= instead of upstreams= (Nick Craig-Wood)
    • Throw error if duplicate directory name is specified (Nick Craig-Wood)
    • Fix errors with backends shutting down while in use (Nick Craig-Wood)
  • Dropbox
    • Fix hang on quit with --dropbox-batch-mode off (Nick Craig-Wood)
    • Fix infinite loop on uploading a corrupted file (Nick Craig-Wood)
  • Internetarchive
    • Ignore checksums for files using the different method (Lesmiscore)
    • Handle hash symbol in the middle of filename (Lesmiscore)
  • Jottacloud
    • Fix working with whitelabel Elgiganten Cloud
    • Do not store username in config when using standard auth (albertony)
  • Mega
    • Fix nil pointer exception when bad node received (Nick Craig-Wood)
  • S3
    • Fix --s3-no-head panic: reflect: Elem of invalid type s3.PutObjectInput (Nick Craig-Wood)
  • SFTP
    • Fix issue with WS_FTP by working around failing RealPath (albertony)
  • Union
    • Fix duplicated files when using directories with leading / (Nick Craig-Wood)
    • Fix multiple files being uploaded when roots don't exist (Nick Craig-Wood)
    • Fix panic due to misalignment of struct field in 32 bit architectures (r-ricci)

v1.59.0 - 2022-07-09

See commits

  • New backends
  • New commands
    • test makefile: Create a single file for testing (Nick Craig-Wood)
  • New Features
    • Metadata framework to read and write system and user metadata on backends (Nick Craig-Wood)
      • Implemented initially for local, s3 and internetarchive backends
      • --metadata/-M flag to control whether metadata is copied
      • --metadata-set flag to specify metadata for uploads
      • Thanks to Manz Solutions for sponsoring this work.
    • build
      • Update to go1.18 and make go1.16 the minimum required version (Nick Craig-Wood)
      • Update android go build to 1.18.x and NDK to 23.1.7779620 (Nick Craig-Wood)
      • All windows binaries now no longer CGO (Nick Craig-Wood)
      • Add linux/arm/v6 to docker images (Nick Craig-Wood)
      • A huge number of fixes found with staticcheck (albertony)
      • Configurable version suffix independent of version number (albertony)
    • check: Implement --no-traverse and --no-unicode-normalization (Nick Craig-Wood)
    • config: Readability improvements (albertony)
    • copyurl: Add --header-filename to honor the HTTP header filename directive (J-P Treen)
    • filter: Allow multiple --exclude-if-present flags (albertony)
    • fshttp: Add --disable-http-keep-alives to disable HTTP Keep Alives (Nick Craig-Wood)
    • install.sh
      • Set the modes on the files and/or directories on macOS (Michael C Tiernan - MIT-Research Computing Project)
      • Pre verify sudo authorization -v before calling curl. (Michael C Tiernan - MIT-Research Computing Project)
    • lib/encoder: Add Semicolon encoding (Nick Craig-Wood)
    • lsf: Add metadata support with M flag (Nick Craig-Wood)
    • lsjson: Add --metadata/-M flag (Nick Craig-Wood)
    • ncdu
      • Implement multi selection (CrossR)
      • Replace termbox with tcell's termbox wrapper (eNV25)
      • Display correct path in delete confirmation dialog (Roberto Ricci)
    • operations
      • Speed up hash checking by aborting the other hash if first returns nothing (Nick Craig-Wood)
      • Use correct src/dst in some log messages (zzr93)
    • rcat: Check checksums by default like copy does (Nick Craig-Wood)
    • selfupdate: Replace deprecated x/crypto/openpgp package with ProtonMail/go-crypto (albertony)
    • serve ftp: Check --passive-port arguments are correct (Nick Craig-Wood)
    • size: Warn about inaccurate results when objects with unknown size (albertony)
    • sync: Overlap check is now filter-sensitive so --backup-dir can be in the root provided it is filtered (Nick)
    • test info: Check file name lengths using 1,2,3,4 byte unicode characters (Nick Craig-Wood)
    • test makefile(s): --sparse, --zero, --pattern, --ascii, --chargen flags to control file contents (Nick Craig-Wood)
    • Make sure we call the Shutdown method on backends (Martin Czygan)
  • Bug Fixes
    • accounting: Fix unknown length file transfers counting 3 transfers each (buda)
    • ncdu: Fix issue where dir size is summed when file sizes are -1 (albertony)
    • sync/copy/move
      • Fix --fast-list --create-empty-src-dirs and --exclude (Nick Craig-Wood)
      • Fix --max-duration and --cutoff-mode soft (Nick Craig-Wood)
    • Fix fs cache unpin (Martin Czygan)
    • Set proper exit code for errors that are not low-level retried (e.g. size/timestamp changing) (albertony)
  • Mount
    • Support windows/arm64 (may still be problems - see #5828) (Nick Craig-Wood)
    • Log IO errors at ERROR level (Nick Craig-Wood)
    • Ignore _netdev mount argument (Hugal31)
  • VFS
    • Add --vfs-fast-fingerprint for less accurate but faster fingerprints (Nick Craig-Wood)
    • Add --vfs-disk-space-total-size option to manually set the total disk space (Claudio Maradonna)
    • vfscache: Fix fatal error: sync: unlock of unlocked mutex error (Nick Craig-Wood)
  • Local
    • Fix parsing of --local-nounc flag (Nick Craig-Wood)
    • Add Metadata support (Nick Craig-Wood)
  • Crypt
    • Support metadata (Nick Craig-Wood)
  • Azure Blob
    • Calculate Chunksize/blocksize to stay below maxUploadParts (Leroy van Logchem)
    • Use chunksize lib to determine chunksize dynamically (Derek Battams)
    • Case insensitive access tier (Rob Pickerill)
    • Allow remote emulator (azurite) (Lorenzo Maiorfi)
  • B2
    • Add --b2-version-at flag to show file versions at time specified (SwazRGB)
    • Use chunksize lib to determine chunksize dynamically (Derek Battams)
  • Chunker
    • Mark as not supporting metadata (Nick Craig-Wood)
  • Compress
    • Support metadata (Nick Craig-Wood)
  • Drive
    • Make backend config -o config add a combined AllDrives: remote (Nick Craig-Wood)
    • Make --drive-shared-with-me work with shared drives (Nick Craig-Wood)
    • Add --drive-resource-key for accessing link-shared files (Nick Craig-Wood)
    • Add backend commands exportformats and importformats for debugging (Nick Craig-Wood)
    • Fix 404 errors on copy/server side copy objects from public folder (Nick Craig-Wood)
    • Update Internal OAuth consent screen docs (Phil Shackleton)
    • Moved root_folder_id to advanced section (Abhiraj)
  • Dropbox
    • Migrate from deprecated api (m8rge)
    • Add logs to show when poll interval limits are exceeded (Nick Craig-Wood)
    • Fix nil pointer exception on dropbox impersonate user not found (Nick Craig-Wood)
  • Fichier
    • Parse api error codes and them accordingly (buengese)
  • FTP
    • Add support for disable_utf8 option (Jason Zheng)
    • Revert to upstream github.com/jlaffaye/ftp from our fork (Nick Craig-Wood)
  • Google Cloud Storage
    • Add --gcs-no-check-bucket to minimise transactions and perms (Nick Gooding)
    • Add --gcs-decompress flag to decompress gzip-encoded files (Nick Craig-Wood)
      • by default these will be downloaded compressed (which previously failed)
  • Hasher
    • Support metadata (Nick Craig-Wood)
  • HTTP
    • Fix missing response when using custom auth handler (albertony)
  • Jottacloud
    • Add support for upload to custom device and mountpoint (albertony)
    • Always store username in config and use it to avoid initial API request (albertony)
    • Fix issue with server-side copy when destination is in trash (albertony)
    • Fix listing output of remote with special characters (albertony)
  • Mailru
    • Fix timeout by using int instead of time.Duration for keeping number of seconds (albertony)
  • Mega
    • Document using MEGAcmd to help with login failures (Art M. Gallagher)
  • Onedrive
    • Implement --poll-interval for onedrive (Hugo Laloge)
    • Add access scopes option (Sven Gerber)
  • Opendrive
    • Resolve lag and truncate bugs (Scott Grimes)
  • Pcloud
    • Fix about with no free space left (buengese)
    • Fix cleanup (buengese)
  • S3
    • Use PUT Object instead of presigned URLs to upload single part objects (Nick Craig-Wood)
    • Backend restore command to skip non-GLACIER objects (Vincent Murphy)
    • Use chunksize lib to determine chunksize dynamically (Derek Battams)
    • Retry RequestTimeout errors (Nick Craig-Wood)
    • Implement reading and writing of metadata (Nick Craig-Wood)
  • SFTP
    • Add support for about and hashsum on windows server (albertony)
    • Use vendor-specific VFS statistics extension for about if available (albertony)
    • Add --sftp-chunk-size to control packets sizes for high latency links (Nick Craig-Wood)
    • Add --sftp-concurrency to improve high latency transfers (Nick Craig-Wood)
    • Add --sftp-set-env option to set environment variables (Nick Craig-Wood)
    • Add Hetzner Storage Boxes to supported sftp backends (Anthrazz)
  • Storj
    • Fix put which lead to the file being unreadable when using mount (Erik van Velzen)
  • Union
    • Add min_free_space option for lfs/eplfs policies (Nick Craig-Wood)
    • Fix uploading files to union of all bucket based remotes (Nick Craig-Wood)
    • Fix get free space for remotes which don't support it (Nick Craig-Wood)
    • Fix eplus policy to select correct entry for existing files (Nick Craig-Wood)
    • Support metadata (Nick Craig-Wood)
  • Uptobox
    • Fix root path handling (buengese)
  • WebDAV
    • Add SharePoint in other specific regions support (Noah Hsu)
  • Yandex
    • Handle api error on server-side move (albertony)
  • Zoho
    • Add Japan and China regions (buengese)

v1.58.1 - 2022-04-29

See commits

  • Bug Fixes
    • build: Update github.com/billziss-gh to github.com/winfsp (Nick Craig-Wood)
    • filter: Fix timezone of --min-age/-max-age from UTC to local as documented (Nick Craig-Wood)
    • rc/js: Correct RC method names (Sơn Trần-Nguyễn)
    • docs
      • Fix some links to command pages (albertony)
      • Add --multi-thread-streams note to --transfers. (Zsolt Ero)
  • Mount
    • Fix --devname and fusermount: unknown option 'fsname' when mounting via rc (Nick Craig-Wood)
  • VFS
    • Remove wording which suggests VFS is only for mounting (Nick Craig-Wood)
  • Dropbox
    • Fix retries of multipart uploads with incorrect_offset error (Nick Craig-Wood)
  • Google Cloud Storage
    • Use the s3 pacer to speed up transactions (Nick Craig-Wood)
    • pacer: Default the Google pacer to a burst of 100 to fix gcs pacing (Nick Craig-Wood)
  • Jottacloud
    • Fix scope in token request (albertony)
  • Netstorage
    • Fix unescaped HTML in documentation (Nick Craig-Wood)
    • Make levels of headings consistent (Nick Craig-Wood)
    • Add support contacts to netstorage doc (Nil Alexandrov)
  • Onedrive
    • Note that sharepoint also changes web files (.html, .aspx) (GH)
  • Putio
    • Handle rate limit errors (Berkan Teber)
    • Fix multithread download and other ranged requests (rafma0)
  • S3
    • Add ChinaMobile EOS to provider list (GuoXingbin)
    • Sync providers in config description with providers (Nick Craig-Wood)
  • SFTP
    • Fix OpenSSH 8.8+ RSA keys incompatibility (KARBOWSKI Piotr)
    • Note that Scaleway C14 is deprecating SFTP in favor of S3 (Adrien Rey-Jarthon)
  • Storj
    • Fix bucket creation on Move (Nick Craig-Wood)
  • WebDAV
    • Don't override Referer if user sets it (Nick Craig-Wood)

v1.58.0 - 2022-03-18

See commits

  • New backends
  • New commands
    • bisync - experimental bidirectional cloud sync (Ivan Andreev, Chris Nelson)
  • New Features
    • build
      • Add windows/arm64 build (rclone mount not supported yet) (Nick Craig-Wood)
      • Raise minimum go version to go1.15 (Nick Craig-Wood)
    • config: Allow dot in remote names and improve config editing (albertony)
    • dedupe: Add quit as a choice in interactive mode (albertony)
    • dlna: Change icons to the newest ones. (Alain Nussbaumer)
    • filter: Add {{ regexp }} syntax to pattern matches (Nick Craig-Wood)
    • fshttp: Add prometheus metrics for HTTP status code (Michał Matczuk)
    • hashsum: Support creating hash from data received on stdin (albertony)
    • librclone
      • Allow empty string or null input instead of empty json object (albertony)
      • Add support for mount commands (albertony)
    • operations: Add server-side moves to stats (Ole Frost)
    • rc: Allow user to disable authentication for web gui (negative0)
    • tree: Remove obsolete --human replaced by global --human-readable (albertony)
    • version: Report correct friendly-name for newer Windows 10/11 versions (albertony)
  • Bug Fixes
    • build
      • Fix ARM architecture version in .deb packages after nfpm change (Nick Craig-Wood)
      • Hard fork github.com/jlaffaye/ftp to fix go get github.com/rclone/rclone (Nick Craig-Wood)
    • oauthutil: Fix crash when webbrowser requests /robots.txt (Nick Craig-Wood)
    • operations: Fix goroutine leak in case of copy retry (Ankur Gupta)
    • rc:
      • Fix operations/publiclink default for expires parameter (Nick Craig-Wood)
      • Fix missing computation of transferQueueSize when summing up statistics group (Carlo Mion)
      • Fix missing StatsInfo fields in the computation of the group sum (Carlo Mion)
    • sync: Fix --max-duration so it doesn't retry when the duration is exceeded (Nick Craig-Wood)
    • touch: Fix issue where a directory is created instead of a file (albertony)
  • Mount
    • Add --devname to set the device name sent to FUSE for mount display (Nick Craig-Wood)
  • VFS
    • Add vfs/stats remote control to show statistics (Nick Craig-Wood)
    • Fix failed to _ensure cache internal error: downloaders is nil error (Nick Craig-Wood)
    • Fix handling of special characters in file names (Bumsu Hyeon)
  • Local
    • Fix hash invalidation which caused errors with local crypt mount (Nick Craig-Wood)
  • Crypt
    • Add base64 and base32768 filename encoding options (Max Sum, Sinan Tan)
  • Azure Blob
    • Implement --azureblob-upload-concurrency parameter to speed uploads (Nick Craig-Wood)
    • Remove 100MB upper limit on chunk_size as it is no longer needed (Nick Craig-Wood)
    • Raise --azureblob-upload-concurrency to 16 by default (Nick Craig-Wood)
    • Fix crash with SAS URL and no container (Nick Craig-Wood)
  • Compress
    • Fix crash if metadata upload failed (Nick Craig-Wood)
    • Fix memory leak (Nick Craig-Wood)
  • Drive
    • Added --drive-copy-shortcut-content (Abhiraj)
    • Disable OAuth OOB flow (copy a token) due to Google deprecation (Nick Craig-Wood)
    • Add --drive-skip-dangling-shortcuts flag (Nick Craig-Wood)
    • When using a link type --drive-export-formats shows all doc types (Nick Craig-Wood)
  • Dropbox
    • Speed up directory listings by specifying 1000 items in a chunk (Nick Craig-Wood)
    • Save an API request when at the root (Nick Craig-Wood)
  • Fichier
    • Implemented About functionality (Gourav T)
  • FTP
    • Add --ftp-ask-password to prompt for password when needed (Borna Butkovic)
  • Google Cloud Storage
    • Add missing regions (Nick Craig-Wood)
    • Disable OAuth OOB flow (copy a token) due to Google deprecation (Nick Craig-Wood)
  • Googlephotos
    • Disable OAuth OOB flow (copy a token) due to Google deprecation (Nick Craig-Wood)
  • Hasher
    • Fix crash on object not found (Nick Craig-Wood)
  • Hdfs
    • Add file (Move) and directory move (DirMove) support (Andy Jackson)
  • HTTP
    • Improved recognition of URL pointing to a single file (albertony)
  • Jottacloud
    • Change API used by recursive list (ListR) (Kim)
    • Add support for Tele2 Cloud (Fredric Arklid)
  • Koofr
    • Add Digistorage service as a Koofr provider. (jaKa)
  • Mailru
    • Fix int32 overflow on arm32 (Ivan Andreev)
  • Onedrive
    • Add config option for oauth scope Sites.Read.All (Charlie Jiang)
    • Minor optimization of quickxorhash (Isaac Levy)
    • Add --onedrive-root-folder-id flag (Nick Craig-Wood)
    • Do not retry on 400 pathIsTooLong error (ctrl-q)
  • Pcloud
    • Add support for recursive list (ListR) (Niels van de Weem)
    • Fix pre-1970 time stamps (Nick Craig-Wood)
  • S3
    • Use ListObjectsV2 for faster listings (Felix Bünemann)
      • Fallback to ListObject v1 on unsupported providers (Nick Craig-Wood)
    • Use the ETag on multipart transfers to verify the transfer was OK (Nick Craig-Wood)
      • Add --s3-use-multipart-etag provider quirk to disable this on unsupported providers (Nick Craig-Wood)
    • New Providers
      • RackCorp object storage (bbabich)
      • Seagate Lyve Cloud storage (Nick Craig-Wood)
      • SeaweedFS (Chris Lu)
      • Storj Shared gateways (Márton Elek, Nick Craig-Wood)
    • Add Wasabi AP Northeast 2 endpoint info (lindwurm)
    • Add GLACIER_IR storage class (Yunhai Luo)
    • Document Content-MD5 workaround for object-lock enabled buckets (Paulo Martins)
    • Fix multipart upload with --no-head flag (Nick Craig-Wood)
    • Simplify content length processing in s3 with download url (Logeshwaran Murugesan)
  • SFTP
    • Add rclone to list of supported md5sum/sha1sum commands to look for (albertony)
    • Refactor so we only have one way of running remote commands (Nick Craig-Wood)
    • Fix timeout on hashing large files by sending keepalives (Nick Craig-Wood)
    • Fix unnecessary seeking when uploading and downloading files (Nick Craig-Wood)
    • Update docs on how to create known_hosts file (Nick Craig-Wood)
  • Storj
    • Rename tardigrade backend to storj backend (Nick Craig-Wood)
    • Implement server side Move for files (Nick Craig-Wood)
    • Update docs to explain differences between s3 and this backend (Elek, Márton)
  • Swift
    • Fix About so it shows info about the current container only (Nick Craig-Wood)
  • Union
    • Fix treatment of remotes with // in (Nick Craig-Wood)
    • Fix deadlock when one part of a multi-upload fails (Nick Craig-Wood)
    • Fix eplus policy returned nil (Vitor Arruda)
  • Yandex
    • Add permanent deletion support (deinferno)

v1.57.0 - 2021-11-01

See commits

  • New backends
    • Sia: for Sia decentralized cloud (Ian Levesque, Matthew Sevey, Ivan Andreev)
    • Hasher: caches hashes and enable hashes for backends that don't support them (Ivan Andreev)
  • New commands
    • lsjson --stat: to get info about a single file/dir and operations/stat api (Nick Craig-Wood)
    • config paths: show configured paths (albertony)
  • New Features
    • about: Make human-readable output more consistent with other commands (albertony)
    • build
      • Use go1.17 for building and make go1.14 the minimum supported (Nick Craig-Wood)
      • Update Go to 1.16 and NDK to 22b for Android builds (x0b)
    • config
      • Support hyphen in remote name from environment variable (albertony)
      • Make temporary directory user-configurable (albertony)
      • Convert --cache-dir value to an absolute path (albertony)
      • Do not override MIME types from OS defaults (albertony)
    • docs
      • Toc styling and header levels cleanup (albertony)
      • Extend documentation on valid remote names (albertony)
      • Mention make for building and cmount tag for macos (Alex Chen)
      • ...and many more contributions to numerous to mention!
    • fs: Move with --ignore-existing will not delete skipped files (Nathan Collins)
    • hashsum
      • Treat hash values in sum file as case insensitive (Ivan Andreev)
      • Don't put ERROR or UNSUPPORTED in output (Ivan Andreev)
    • lib/encoder: Add encoding of square brackets (Ivan Andreev)
    • lib/file: Improve error message when attempting to create dir on nonexistent drive on windows (albertony)
    • lib/http: Factor password hash salt into options with default (Nolan Woods)
    • lib/kv: Add key-value database api (Ivan Andreev)
    • librclone
      • Add RcloneFreeString function (albertony)
      • Free strings in python example (albertony)
    • log: Optionally print pid in logs (Ivan Andreev)
    • ls: Introduce --human-readable global option to print human-readable sizes (albertony)
    • ncdu: Introduce key u to toggle human-readable (albertony)
    • operations: Add rmdirs -v output (Justin Winokur)
    • serve sftp
      • Generate an ECDSA server key as well as RSA (Nick Craig-Wood)
      • Generate an Ed25519 server key as well as ECDSA and RSA (albertony)
    • serve docker
      • Allow to customize proxy settings of docker plugin (Ivan Andreev)
      • Build docker plugin for multiple platforms (Thomas Stachl)
    • size: Include human-readable count (albertony)
    • touch: Add support for touching files in directory, with recursive option, filtering and --dry-run/-i (albertony)
    • tree: Option to print human-readable sizes removed in favor of global option (albertony)
  • Bug Fixes
    • lib/http
      • Fix bad username check in single auth secret provider (Nolan Woods)
      • Fix handling of SSL credentials (Nolan Woods)
    • serve ftp: Ensure modtime is passed as UTC always to fix timezone oddities (Nick Craig-Wood)
    • serve sftp: Fix generation of server keys on windows (albertony)
    • serve docker: Fix octal umask (Ivan Andreev)
  • Mount
    • Enable rclone to be run as mount helper direct from the fstab (Ivan Andreev)
    • Use procfs to validate mount on linux (Ivan Andreev)
    • Correctly daemonize for compatibility with automount (Ivan Andreev)
  • VFS
    • Ensure names used in cache path are legal on current OS (albertony)
    • Ignore ECLOSED when truncating file handles to fix intermittent bad file descriptor error (Nick Craig-Wood)
  • Local
    • Refactor default OS encoding out from local backend into shared encoder lib (albertony)
  • Crypt
    • Return wrapped object even with --crypt-no-data-encryption (Ivan Andreev)
    • Fix uploads with --crypt-no-data-encryption (Nick Craig-Wood)
  • Azure Blob
    • Add --azureblob-no-head-object (Tatsuya Noyori)
  • Box
    • Make listings of heavily used directories more reliable (Nick Craig-Wood)
    • When doing cleanup delete as much as possible (Nick Craig-Wood)
    • Add --box-list-chunk to control listing chunk size (Nick Craig-Wood)
    • Delete items in parallel in cleanup using --checkers threads (Nick Craig-Wood)
    • Add --box-owned-by to only show items owned by the login passed (Nick Craig-Wood)
    • Retry operation_blocked_temporary errors (Nick Craig-Wood)
  • Chunker
    • Md5all must create metadata if base hash is slow (Ivan Andreev)
  • Drive
    • Speed up directory listings by constraining the API listing using the current filters (fotile96, Ivan Andreev)
    • Fix buffering for single request upload for files smaller than --drive-upload-cutoff (YenForYang)
    • Add -o config option to backend drives to make config for all shared drives (Nick Craig-Wood)
  • Dropbox
    • Add --dropbox-batch-commit-timeout to control batch timeout (Nick Craig-Wood)
  • Filefabric
    • Make backoff exponential for error_background to fix errors (Nick Craig-Wood)
    • Fix directory move after API change (Nick Craig-Wood)
  • FTP
    • Enable tls session cache by default (Ivan Andreev)
    • Add option to disable tls13 (Ivan Andreev)
    • Fix timeout after long uploads (Ivan Andreev)
    • Add support for precise time (Ivan Andreev)
    • Enable CI for ProFtpd, PureFtpd, VsFtpd (Ivan Andreev)
  • Googlephotos
    • Use encoder for album names to fix albums with control characters (Parth Shukla)
  • Jottacloud
    • Implement SetModTime to support modtime-only changes (albertony)
    • Improved error handling with SetModTime and corrupt files in general (albertony)
    • Add support for UserInfo (rclone config userinfo) feature (albertony)
    • Return direct download link from rclone link command (albertony)
  • Koofr
    • Create direct share link (Dmitry Bogatov)
  • Pcloud
    • Add sha256 support (Ken Enrique Morel)
  • Premiumizeme
    • Fix directory listing after API changes (Nick Craig-Wood)
    • Fix server side move after API change (Nick Craig-Wood)
    • Fix server side directory move after API changes (Nick Craig-Wood)
  • S3
    • Add support to use CDN URL to download the file (Logeshwaran)
    • Add AWS Snowball Edge to providers examples (r0kk3rz)
    • Use a combination of SDK retries and rclone retries (Nick Craig-Wood)
    • Fix IAM Role for Service Account not working and other auth problems (Nick Craig-Wood)
    • Fix shared_credentials_file auth after reverting incorrect fix (Nick Craig-Wood)
    • Fix corrupted on transfer: sizes differ 0 vs xxxx with Ceph (Nick Craig-Wood)
  • Seafile
    • Fix error when not configured for 2fa (Fred)
  • SFTP
    • Fix timeout when doing MD5SUM of large file (Nick Craig-Wood)
  • Swift
    • Update OCI URL (David Liu)
    • Document OVH Cloud Archive (HNGamingUK)
  • Union
    • Fix rename not working with union of local disk and bucket based remote (Nick Craig-Wood)

v1.56.2 - 2021-10-01

See commits

  • Bug Fixes
    • serve http: Re-add missing auth to http service (Nolan Woods)
    • build: Update golang.org/x/sys to fix crash on macOS when compiled with go1.17 (Herby Gillot)
  • FTP
    • Fix deadlock after failed update when concurrency=1 (Ivan Andreev)

v1.56.1 - 2021-09-19

See commits

  • Bug Fixes
    • accounting: Fix maximum bwlimit by scaling scale max token bucket size (Nick Craig-Wood)
    • rc: Fix speed does not update in core/stats (negative0)
    • selfupdate: Fix --quiet option, not quite quiet (yedamo)
    • serve http: Fix serve http exiting directly after starting (Cnly)
    • build
      • Apply gofmt from golang 1.17 (Ivan Andreev)
      • Update Go to 1.16 and NDK to 22b for android/any (x0b)
  • Mount
    • Fix --daemon mode (Ivan Andreev)
  • VFS
    • Fix duplicates on rename (Nick Craig-Wood)
    • Fix crash when truncating a just uploaded object (Nick Craig-Wood)
    • Fix issue where empty dirs would build up in cache meta dir (albertony)
  • Drive
    • Fix instructions for auto config (Greg Sadetsky)
    • Fix lsf example without drive-impersonate (Greg Sadetsky)
  • Onedrive
    • Handle HTTP 400 better in PublicLink (Alex Chen)
    • Clarification of the process for creating custom client_id (Mariano Absatz)
  • Pcloud
    • Return an early error when Put is called with an unknown size (Nick Craig-Wood)
    • Try harder to delete a failed upload (Nick Craig-Wood)
  • S3
    • Add Wasabi's AP-Northeast endpoint info (hota)
    • Fix typo in s3 documentation (Greg Sadetsky)
  • Seafile
    • Fix 2fa config state machine (Fred)
  • SFTP
    • Remove spurious error message on --sftp-disable-concurrent-reads (Nick Craig-Wood)
  • Sugarsync
    • Fix initial connection after config re-arrangement (Nick Craig-Wood)

v1.56.0 - 2021-07-20

See commits

  • New backends
  • New commands
  • Deprecations
    • dbhashsum: Remove command deprecated a year ago (Ivan Andreev)
    • cache: Deprecate cache backend (Ivan Andreev)
  • New Features
    • rework config system so it can be used non-interactively via cli and rc API.
      • See docs in config create
      • This is a very big change to all the backends so may cause breakages - please file bugs!
    • librclone - export the rclone RC as a C library (lewisxy) (Nick Craig-Wood)
      • Link a C-API rclone shared object into your project
      • Use the RC as an in memory interface
      • Python example supplied
      • Also supports Android and gomobile
    • fs
      • Add --disable-http2 for global http2 disable (Nick Craig-Wood)
      • Make --dump imply -vv (Alex Chen)
      • Use binary prefixes for size and rate units (albertony)
      • Use decimal prefixes for counts (albertony)
      • Add google search widget to rclone.org (Ivan Andreev)
    • accounting: Calculate rolling average speed (Haochen Tong)
    • atexit: Terminate with non-zero status after receiving signal (Michael Hanselmann)
    • build
      • Only run event-based workflow scripts under rclone repo with manual override (Mathieu Carbou)
      • Add Android build with gomobile (x0b)
    • check: Log the hash in use like cryptcheck does (Nick Craig-Wood)
    • version: Print os/version, kernel and bitness (Ivan Andreev)
    • config
      • Prevent use of Windows reserved names in config file name (albertony)
      • Create config file in windows appdata directory by default (albertony)
      • Treat any config file paths with filename notfound as memory-only config (albertony)
      • Delay load config file (albertony)
      • Replace defaultConfig with a thread-safe in-memory implementation (Chris Macklin)
      • Allow config create and friends to take key=value parameters (Nick Craig-Wood)
      • Fixed issues with flags/options set by environment vars. (Ole Frost)
    • fshttp: Implement graceful DSCP error handling (Tyson Moore)
    • lib/http - provides an abstraction for a central http server that services can bind routes to (Nolan Woods)
      • Add --template config and flags to serve/data (Nolan Woods)
      • Add default 404 handler (Nolan Woods)
    • link: Use "off" value for unset expiry (Nick Craig-Wood)
    • oauthutil: Raise fatal error if token expired without refresh token (Alex Chen)
    • rcat: Add --size flag for more efficient uploads of known size (Nazar Mishturak)
    • serve sftp: Add --stdio flag to serve via stdio (Tom)
    • sync: Don't warn about --no-traverse when --files-from is set (Nick Gaya)
    • test makefiles
      • Add --seed flag and make data generated repeatable (Nick Craig-Wood)
      • Add log levels and speed summary (Nick Craig-Wood)
  • Bug Fixes
    • accounting: Fix startTime of statsGroups.sum (Haochen Tong)
    • cmd/ncdu: Fix out of range panic in delete (buengese)
    • config
      • Fix issues with memory-only config file paths (albertony)
      • Fix in memory config not saving on the fly backend config (Nick Craig-Wood)
    • fshttp: Fix address parsing for DSCP (Tyson Moore)
    • ncdu: Update termbox-go library to fix crash (Nick Craig-Wood)
    • oauthutil: Fix old authorize result not recognised (Cnly)
    • operations: Don't update timestamps of files in --compare-dest (Nick Gaya)
    • selfupdate: fix archive name on macos (Ivan Andreev)
  • Mount
    • Refactor before adding serve docker (Antoine GIRARD)
  • VFS
    • Add cache reset for --vfs-cache-max-size handling at cache poll interval (Leo Luan)
    • Fix modtime changing when reading file into cache (Nick Craig-Wood)
    • Avoid unnecessary subdir in cache path (albertony)
    • Fix that umask option cannot be set as environment variable (albertony)
    • Do not print notice about missing poll-interval support when set to 0 (albertony)
  • Local
    • Always use readlink to read symlink size for better compatibility (Nick Craig-Wood)
    • Add --local-unicode-normalization (and remove --local-no-unicode-normalization) (Nick Craig-Wood)
    • Skip entries removed concurrently with List() (Ivan Andreev)
  • Crypt
    • Support timestamped filenames from --b2-versions (Dominik Mydlil)
  • B2
    • Don't include the bucket name in public link file prefixes (Jeffrey Tolar)
    • Fix versions and .files with no extension (Nick Craig-Wood)
    • Factor version handling into lib/version (Dominik Mydlil)
  • Box
    • Use upload preflight check to avoid listings in file uploads (Nick Craig-Wood)
    • Return errors instead of calling log.Fatal with them (Nick Craig-Wood)
  • Drive
    • Switch to the Drives API for looking up shared drives (Nick Craig-Wood)
    • Fix some google docs being treated as files (Nick Craig-Wood)
  • Dropbox
    • Add --dropbox-batch-mode flag to speed up uploading (Nick Craig-Wood)
    • Set visibility in link sharing when --expire is set (Nick Craig-Wood)
    • Simplify chunked uploads (Alexey Ivanov)
    • Improve "own App IP" instructions (Ivan Andreev)
  • Fichier
    • Check if more than one upload link is returned (Nick Craig-Wood)
    • Support downloading password protected files and folders (Florian Penzkofer)
    • Make error messages report text from the API (Nick Craig-Wood)
    • Fix move of files in the same directory (Nick Craig-Wood)
    • Check that we actually got a download token and retry if we didn't (buengese)
  • Filefabric
    • Fix listing after change of from field from "int" to int. (Nick Craig-Wood)
  • FTP
    • Make upload error 250 indicate success (Nick Craig-Wood)
  • GCS
    • Make compatible with gsutil's mtime metadata (database64128)
    • Clean up time format constants (database64128)
  • Google Photos
    • Fix read only scope not being used properly (Nick Craig-Wood)
  • HTTP
    • Replace httplib with lib/http (Nolan Woods)
    • Clean up Bind to better use middleware (Nolan Woods)
  • Jottacloud
    • Fix legacy auth with state based config system (buengese)
    • Fix invalid url in output from link command (albertony)
    • Add no versions option (buengese)
  • Onedrive
    • Add list_chunk option (Nick Gaya)
    • Also report root error if unable to cancel multipart upload (Cnly)
    • Fix failed to configure: empty token found error (Nick Craig-Wood)
    • Make link return direct download link (Xuanchen Wu)
  • S3
    • Add --s3-no-head-object (Tatsuya Noyori)
    • Remove WebIdentityRoleProvider to fix crash on auth (Nick Craig-Wood)
    • Don't check to see if remote is object if it ends with / (Nick Craig-Wood)
    • Add SeaweedFS (Chris Lu)
    • Update Alibaba OSS endpoints (Chuan Zh)
  • SFTP
    • Fix performance regression by re-enabling concurrent writes (Nick Craig-Wood)
    • Expand tilde and environment variables in configured known_hosts_file (albertony)
  • Tardigrade
    • Upgrade to uplink v1.4.6 (Caleb Case)
    • Use negative offset (Caleb Case)
    • Add warning about too many open files (acsfer)
  • WebDAV
    • Fix sharepoint auth over http (Nick Craig-Wood)
    • Add headers option (Antoon Prins)

v1.55.1 - 2021-04-26

See commits

  • Bug Fixes
    • selfupdate
      • Dont detect FUSE if build is static (Ivan Andreev)
      • Add build tag noselfupdate (Ivan Andreev)
    • sync: Fix incorrect error reported by graceful cutoff (Nick Craig-Wood)
    • install.sh: fix macOS arm64 download (Nick Craig-Wood)
    • build: Fix version numbers in android branch builds (Nick Craig-Wood)
    • docs
      • Contributing.md: update setup instructions for go1.16 (Nick Gaya)
      • WinFsp 2021 is out of beta (albertony)
      • Minor cleanup of space around code section (albertony)
      • Fixed some typos (albertony)
  • VFS
    • Fix a code path which allows dirty data to be removed causing data loss (Nick Craig-Wood)
  • Compress
    • Fix compressed name regexp (buengese)
  • Drive
    • Fix backend copyid of google doc to directory (Nick Craig-Wood)
    • Don't open browser when service account... (Ansh Mittal)
  • Dropbox
    • Add missing team_data.member scope for use with --impersonate (Nick Craig-Wood)
    • Fix About after scopes changes - rclone config reconnect needed (Nick Craig-Wood)
    • Fix Unable to decrypt returned paths from changeNotify (Nick Craig-Wood)
  • FTP
    • Fix implicit TLS (Ivan Andreev)
  • Onedrive
    • Work around for random "Unable to initialize RPS" errors (OleFrost)
  • SFTP
    • Revert sftp library to v1.12.0 from v1.13.0 to fix performance regression (Nick Craig-Wood)
    • Fix Update ReadFrom failed: failed to send packet: EOF errors (Nick Craig-Wood)
  • Zoho
    • Fix error when region isn't set (buengese)
    • Do not ask for mountpoint twice when using headless setup (buengese)

v1.55.0 - 2021-03-31

See commits

  • New commands
    • selfupdate (Ivan Andreev)
      • Allows rclone to update itself in-place or via a package (using --package flag)
      • Reads cryptographically signed signatures for non beta releases
      • Works on all OSes.
    • test - these are test commands - use with care!
      • histogram - Makes a histogram of file name characters.
      • info - Discovers file name or other limitations for paths.
      • makefiles - Make a random file hierarchy for testing.
      • memory - Load all the objects at remote:path into memory and report memory stats.
  • New Features
    • Connection strings
      • Config parameters can now be passed as part of the remote name as a connection string.
      • For example, to do the equivalent of --drive-shared-with-me use drive,shared_with_me:
      • Make sure we don't save on the fly remote config to the config file (Nick Craig-Wood)
      • Make sure backends with additional config have a different name for caching (Nick Craig-Wood)
      • This work was sponsored by CERN, through the CS3MESH4EOSC Project.
        • CS3MESH4EOSC has received funding from the European Union’s Horizon 2020
        • research and innovation programme under Grant Agreement no. 863353.
    • build
      • Update go build version to go1.16 and raise minimum go version to go1.13 (Nick Craig-Wood)
      • Make a macOS ARM64 build to support Apple Silicon (Nick Craig-Wood)
      • Install macfuse 4.x instead of osxfuse 3.x (Nick Craig-Wood)
      • Use GO386=softfloat instead of deprecated GO386=387 for 386 builds (Nick Craig-Wood)
      • Disable IOS builds for the time being (Nick Craig-Wood)
      • Androids builds made with up to date NDK (x0b)
      • Add an rclone user to the Docker image but don't use it by default (cynthia kwok)
    • dedupe: Make largest directory primary to minimize data moved (Saksham Khanna)
    • config
      • Wrap config library in an interface (Fionera)
      • Make config file system pluggable (Nick Craig-Wood)
      • --config "" or "/notfound" for in memory config only (Nick Craig-Wood)
      • Clear fs cache of stale entries when altering config (Nick Craig-Wood)
    • copyurl: Add option to print resulting auto-filename (albertony)
    • delete: Make --rmdirs obey the filters (Nick Craig-Wood)
    • docs - many fixes and reworks from edwardxml, albertony, pvalls, Ivan Andreev, Evan Harris, buengese, Alexey Tabakman
    • encoder/filename - add SCSU as tables (Klaus Post)
    • Add multiple paths support to --compare-dest and --copy-dest flag (K265)
    • filter: Make --exclude "dir/" equivalent to --exclude "dir/**" (Nick Craig-Wood)
    • fshttp: Add DSCP support with --dscp for QoS with differentiated services (Max Sum)
    • lib/cache: Add Delete and DeletePrefix methods (Nick Craig-Wood)
    • lib/file
      • Make pre-allocate detect disk full errors and return them (Nick Craig-Wood)
      • Don't run preallocate concurrently (Nick Craig-Wood)
      • Retry preallocate on EINTR (Nick Craig-Wood)
    • operations: Made copy and sync operations obey a RetryAfterError (Ankur Gupta)
    • rc
      • Add string alternatives for setting options over the rc (Nick Craig-Wood)
      • Add options/local to see the options configured in the context (Nick Craig-Wood)
      • Add _config parameter to set global config for just this rc call (Nick Craig-Wood)
      • Implement passing filter config with _filter parameter (Nick Craig-Wood)
      • Add fscache/clear and fscache/entries to control the fs cache (Nick Craig-Wood)
      • Avoid +Inf value for speed in core/stats (albertony)
      • Add a full set of stats to core/stats (Nick Craig-Wood)
      • Allow fs= params to be a JSON blob (Nick Craig-Wood)
    • rcd: Added systemd notification during the rclone rcd command. (Naveen Honest Raj)
    • rmdirs: Make --rmdirs obey the filters (Nick Craig-Wood)
    • version: Show build tags and type of executable (Ivan Andreev)
  • Bug Fixes
    • install.sh: make it fail on download errors (Ivan Andreev)
    • Fix excessive retries missing --max-duration timeout (Nick Craig-Wood)
    • Fix crash when --low-level-retries=0 (Nick Craig-Wood)
    • Fix failed token refresh on mounts created via the rc (Nick Craig-Wood)
    • fshttp: Fix bandwidth limiting after bad merge (Nick Craig-Wood)
    • lib/atexit
      • Unregister interrupt handler once it has fired so users can interrupt again (Nick Craig-Wood)
      • Fix occasional failure to unmount with CTRL-C (Nick Craig-Wood)
      • Fix deadlock calling Finalise while Run is running (Nick Craig-Wood)
    • lib/rest: Fix multipart uploads not stopping on context cancel (Nick Craig-Wood)
  • Mount
    • Allow mounting to root directory on windows (albertony)
    • Improved handling of relative paths on windows (albertony)
    • Fix unicode issues with accented characters on macOS (Nick Craig-Wood)
    • Docs: document the new FileSecurity option in WinFsp 2021 (albertony)
    • Docs: add note about volume path syntax on windows (albertony)
    • Fix caching of old directories after renaming them (Nick Craig-Wood)
    • Update cgofuse to the latest version to bring in macfuse 4 fix (Nick Craig-Wood)
  • VFS
    • --vfs-used-is-size to report used space using recursive scan (tYYGH)
    • Don't set modification time if it was already correct (Nick Craig-Wood)
    • Fix Create causing windows explorer to truncate files on CTRL-C CTRL-V (Nick Craig-Wood)
    • Fix modtimes not updating when writing via cache (Nick Craig-Wood)
    • Fix modtimes changing by fractional seconds after upload (Nick Craig-Wood)
    • Fix modtime set if --vfs-cache-mode writes/full and no write (Nick Craig-Wood)
    • Rename files in cache and cancel uploads on directory rename (Nick Craig-Wood)
    • Fix directory renaming by renaming dirs cached in memory (Nick Craig-Wood)
  • Local
    • Add flag --local-no-preallocate (David Sze)
    • Make nounc an advanced option except on Windows (albertony)
    • Don't ignore preallocate disk full errors (Nick Craig-Wood)
  • Cache
    • Add --fs-cache-expire-duration to control the fs cache (Nick Craig-Wood)
  • Crypt
    • Add option to not encrypt data (Vesnyx)
    • Log hash ok on upload (albertony)
  • Azure Blob
    • Add container public access level support. (Manish Kumar)
  • B2
    • Fix HTML files downloaded via cloudflare (Nick Craig-Wood)
  • Box
    • Fix transfers getting stuck on token expiry after API change (Nick Craig-Wood)
  • Chunker
    • Partially implement no-rename transactions (Maxwell Calman)
  • Drive
    • Don't stop server side copy if couldn't read description (Nick Craig-Wood)
    • Pass context on to drive SDK - to help with cancellation (Nick Craig-Wood)
  • Dropbox
    • Add polling for changes support (Robert Thomas)
    • Make --timeout 0 work properly (Nick Craig-Wood)
    • Raise priority of rate limited message to INFO to make it more noticeable (Nick Craig-Wood)
  • Fichier
    • Implement copy & move (buengese)
    • Implement public link (buengese)
  • FTP
    • Implement Shutdown method (Nick Craig-Wood)
    • Close idle connections after --ftp-idle-timeout (1m by default) (Nick Craig-Wood)
    • Make --timeout 0 work properly (Nick Craig-Wood)
    • Add --ftp-close-timeout flag for use with awkward ftp servers (Nick Craig-Wood)
    • Retry connections and logins on 421 errors (Nick Craig-Wood)
  • Hdfs
    • Fix permissions for when directory is created (Lucas Messenger)
  • Onedrive
    • Make --timeout 0 work properly (Nick Craig-Wood)
  • S3
    • Fix --s3-profile which wasn't working (Nick Craig-Wood)
  • SFTP
    • Close idle connections after --sftp-idle-timeout (1m by default) (Nick Craig-Wood)
    • Fix "file not found" errors for read once servers (Nick Craig-Wood)
    • Fix SetModTime stat failed: object not found with --sftp-set-modtime=false (Nick Craig-Wood)
  • Swift
    • Update github.com/ncw/swift to v2.0.0 (Nick Craig-Wood)
    • Implement copying large objects (nguyenhuuluan434)
  • Union
    • Fix crash when using epff policy (Nick Craig-Wood)
    • Fix union attempting to update files on a read only file system (Nick Craig-Wood)
    • Refactor to use fspath.SplitFs instead of fs.ParseRemote (Nick Craig-Wood)
    • Fix initialisation broken in refactor (Nick Craig-Wood)
  • WebDAV
    • Add support for sharepoint with NTLM authentication (Rauno Ots)
    • Make sharepoint-ntlm docs more consistent (Alex Chen)
    • Improve terminology in sharepoint-ntlm docs (Ivan Andreev)
    • Disable HTTP/2 for NTLM authentication (georne)
    • Fix sharepoint-ntlm error 401 for parallel actions (Ivan Andreev)
    • Check that purged directory really exists (Ivan Andreev)
  • Yandex
    • Make --timeout 0 work properly (Nick Craig-Wood)
  • Zoho
    • Replace client id - you will need to rclone config reconnect after this (buengese)
    • Add forgotten setupRegion() to NewFs - this finally fixes regions other than EU (buengese)

v1.54.1 - 2021-03-08

See commits

  • Bug Fixes
    • accounting: Fix --bwlimit when up or down is off (Nick Craig-Wood)
    • docs
      • Fix nesting of brackets and backticks in ftp docs (edwardxml)
      • Fix broken link in sftp page (edwardxml)
      • Fix typo in crypt.md (Romeo Kienzler)
      • Changelog: Correct link to digitalis.io (Alex JOST)
      • Replace #file-caching with #vfs-file-caching (Miron Veryanskiy)
      • Convert bogus example link to code (edwardxml)
      • Remove dead link from rc.md (edwardxml)
    • rc: Sync,copy,move: document createEmptySrcDirs parameter (Nick Craig-Wood)
    • lsjson: Fix unterminated JSON in the presence of errors (Nick Craig-Wood)
  • Mount
    • Fix mount dropping on macOS by setting --daemon-timeout 10m (Nick Craig-Wood)
  • VFS
    • Document simultaneous usage with the same cache shouldn't be used (Nick Craig-Wood)
  • B2
    • Automatically raise upload cutoff to avoid spurious error (Nick Craig-Wood)
    • Fix failed to create file system with application key limited to a prefix (Nick Craig-Wood)
  • Drive
    • Refer to Shared Drives instead of Team Drives (Nick Craig-Wood)
  • Dropbox
    • Add scopes to oauth request and optionally "members.read" (Nick Craig-Wood)
  • S3
    • Fix failed to create file system with folder level permissions policy (Nick Craig-Wood)
    • Fix Wasabi HEAD requests returning stale data by using only 1 transport (Nick Craig-Wood)
    • Fix shared_credentials_file auth (Dmitry Chepurovskiy)
    • Add --s3-no-head to reducing costs docs (Nick Craig-Wood)
  • Union
    • Fix mkdir at root with remote:/ (Nick Craig-Wood)
  • Zoho
    • Fix custom client id's (buengese)

v1.54.0 - 2021-02-02

See commits

  • New backends
    • Compression remote (experimental) (buengese)
    • Enterprise File Fabric (Nick Craig-Wood)
    • HDFS (Hadoop Distributed File System) (Yury Stankevich)
    • Zoho workdrive (buengese)
  • New Features
    • Deglobalise the config (Nick Craig-Wood)
      • Global config now read from the context
      • This will enable passing of global config via the rc
      • This work was sponsored by Digitalis
    • Add --bwlimit for upload and download (Nick Craig-Wood)
      • Obey bwlimit in http Transport for better limiting
    • Enhance systemd integration (Hekmon)
      • log level identification, manual activation with flag, automatic systemd launch detection
      • Don't compile systemd log integration for non unix systems (Benjamin Gustin)
    • Add a --download flag to md5sum/sha1sum/hashsum to force rclone to download and hash files locally (lostheli)
    • Add --progress-terminal-title to print ETA to terminal title (LaSombra)
    • Make backend env vars show in help as the defaults for backend flags (Nick Craig-Wood)
    • build
      • Raise minimum go version to go1.12 (Nick Craig-Wood)
    • dedupe
      • Add --by-hash to dedupe on content hash not file name (Nick Craig-Wood)
      • Add --dedupe-mode list to just list dupes, changing nothing (Nick Craig-Wood)
      • Add warning if used on a remote which can't have duplicate names (Nick Craig-Wood)
    • fs
      • Add Shutdown optional method for backends (Nick Craig-Wood)
      • When using --files-from check files concurrently (zhucan)
      • Accumulate stats when using --dry-run (Ingo Weiss)
      • Always show stats when using --dry-run or --interactive (Nick Craig-Wood)
      • Add support for flag --no-console on windows to hide the console window (albertony)
    • genautocomplete: Add support to output to stdout (Ingo)
    • ncdu
      • Highlight read errors instead of aborting (Claudio Bantaloukas)
      • Add sort by average size in directory (Adam Plánský)
      • Add toggle option for average s3ize in directory - key 'a' (Adam Plánský)
      • Add empty folder flag into ncdu browser (Adam Plánský)
      • Add ! (error) and . (unreadable) file flags to go with e (empty) (Nick Craig-Wood)
    • obscure: Make rclone obscure - ignore newline at end of line (Nick Craig-Wood)
    • operations
      • Add logs when need to upload files to set mod times (Nick Craig-Wood)
      • Move and copy log name of the destination object in verbose (Adam Plánský)
      • Add size if known to skipped items and JSON log (Nick Craig-Wood)
    • rc
      • Prefer actual listener address if using ":port" or "addr:0" only (Nick Craig-Wood)
      • Add listener for finished jobs (Aleksandar Jankovic)
    • serve ftp: Add options to enable TLS (Deepak Sah)
    • serve http/webdav: Redirect requests to the base url without the / (Nick Craig-Wood)
    • serve restic: Implement object cache (Nick Craig-Wood)
    • stats: Add counter for deleted directories (Nick Craig-Wood)
    • sync: Only print "There was nothing to transfer" if no errors (Nick Craig-Wood)
    • webui
      • Prompt user for updating webui if an update is available (Chaitanya Bankanhal)
      • Fix plugins initialization (negative0)
  • Bug Fixes
    • fs
      • Fix nil pointer on copy & move operations directly to remote (Anagh Kumar Baranwal)
      • Fix parsing of .. when joining remotes (Nick Craig-Wood)
    • log: Fix enabling systemd logging when using --log-file (Nick Craig-Wood)
    • check
      • Make the error count match up in the log message (Nick Craig-Wood)
    • move: Fix data loss when source and destination are the same object (Nick Craig-Wood)
    • operations
      • Fix --cutoff-mode hard not cutting off immediately (Nick Craig-Wood)
      • Fix --immutable error message (Nick Craig-Wood)
    • sync
      • Fix --cutoff-mode soft & cautious so it doesn't end the transfer early (Nick Craig-Wood)
      • Fix --immutable errors retrying many times (Nick Craig-Wood)
  • Docs
    • Many fixes and a rewrite of the filtering docs (edwardxml)
    • Many spelling and grammar fixes (Josh Soref)
    • Doc fixes for commands delete, purge, rmdir, rmdirs and mount (albertony)
    • And thanks to these people for many doc fixes too numerous to list
      • Ameer Dawood, Antoine GIRARD, Bob Bagwill, Christopher Stewart
      • CokeMine, David, Dov Murik, Durval Menezes, Evan Harris, gtorelly
      • Ilyess Bachiri, Janne Johansson, Kerry Su, Marcin Zelent,
      • Martin Michlmayr, Milly, Sơn Trần-Nguyễn
  • Mount
    • Update systemd status with cache stats (Hekmon)
    • Disable bazil/fuse based mount on macOS (Nick Craig-Wood)
      • Make rclone mount actually run rclone cmount under macOS (Nick Craig-Wood)
    • Implement mknod to make NFS file creation work (Nick Craig-Wood)
    • Make sure we don't call umount more than once (Nick Craig-Wood)
    • More user friendly mounting as network drive on windows (albertony)
    • Detect if uid or gid are set in same option string: -o uid=123,gid=456 (albertony)
    • Don't attempt to unmount if fs has been destroyed already (Nick Craig-Wood)
  • VFS
    • Fix virtual entries causing deleted files to still appear (Nick Craig-Wood)
    • Fix "file already exists" error for stale cache files (Nick Craig-Wood)
    • Fix file leaks with --vfs-cache-mode full and --buffer-size 0 (Nick Craig-Wood)
    • Fix invalid cache path on windows when using :backend: as remote (albertony)
  • Local
    • Continue listing files/folders when a circular symlink is detected (Manish Gupta)
    • New flag --local-zero-size-links to fix sync on some virtual filesystems (Riccardo Iaconelli)
  • Azure Blob
    • Add support for service principals (James Lim)
    • Add support for managed identities (Brad Ackerman)
    • Add examples for access tier (Bob Pusateri)
    • Utilize the streaming capabilities from the SDK for multipart uploads (Denis Neuling)
    • Fix setting of mime types (Nick Craig-Wood)
    • Fix crash when listing outside a SAS URL's root (Nick Craig-Wood)
    • Delete archive tier blobs before update if --azureblob-archive-tier-delete (Nick Craig-Wood)
    • Fix crash on startup (Nick Craig-Wood)
    • Fix memory usage by upgrading the SDK to v0.13.0 and implementing a TransferManager (Nick Craig-Wood)
    • Require go1.14+ to compile due to SDK changes (Nick Craig-Wood)
  • B2
    • Make NewObject use less expensive API calls (Nick Craig-Wood)
      • This will improve --files-from and restic serve in particular
    • Fixed crash on an empty file name (lluuaapp)
  • Box
    • Fix NewObject for files that differ in case (Nick Craig-Wood)
    • Fix finding directories in a case insensitive way (Nick Craig-Wood)
  • Chunker
    • Skip long local hashing, hash in-transit (fixes) (Ivan Andreev)
    • Set Features ReadMimeType to false as Object.MimeType not supported (Nick Craig-Wood)
    • Fix case-insensitive NewObject, test metadata detection (Ivan Andreev)
  • Drive
    • Implement rclone backend copyid command for copying files by ID (Nick Craig-Wood)
    • Added flag --drive-stop-on-download-limit to stop transfers when the download limit is exceeded (Anagh Kumar Baranwal)
    • Implement CleanUp workaround for team drives (buengese)
    • Allow shortcut resolution and creation to be retried (Nick Craig-Wood)
    • Log that emptying the trash can take some time (Nick Craig-Wood)
    • Add xdg office icons to xdg desktop files (Pau Rodriguez-Estivill)
  • Dropbox
    • Add support for viewing shared files and folders (buengese)
    • Enable short lived access tokens (Nick Craig-Wood)
    • Implement IDer on Objects so rclone lsf etc can read the IDs (buengese)
    • Set Features ReadMimeType to false as Object.MimeType not supported (Nick Craig-Wood)
    • Make malformed_path errors from too long files not retriable (Nick Craig-Wood)
    • Test file name length before upload to fix upload loop (Nick Craig-Wood)
  • Fichier
    • Set Features ReadMimeType to true as Object.MimeType is supported (Nick Craig-Wood)
  • FTP
    • Add --ftp-disable-msld option to ignore MLSD for really old servers (Nick Craig-Wood)
    • Make --tpslimit apply (Nick Craig-Wood)
  • Google Cloud Storage
    • Storage class object header support (Laurens Janssen)
    • Fix anonymous client to use rclone's HTTP client (Nick Craig-Wood)
    • Fix Entry doesn't belong in directory "" (same as directory) - ignoring (Nick Craig-Wood)
  • Googlephotos
    • New flag --gphotos-include-archived to show archived photos as well (Nicolas Rueff)
  • Jottacloud
    • Don't erroneously report support for writing mime types (buengese)
    • Add support for Telia Cloud (Patrik Nordlén)
  • Mailru
    • Accept special folders eg camera-upload (Ivan Andreev)
    • Avoid prehashing of large local files (Ivan Andreev)
    • Fix uploads after recent changes on server (Ivan Andreev)
    • Fix range requests after June 2020 changes on server (Ivan Andreev)
    • Fix invalid timestamp on corrupted files (fixes) (Ivan Andreev)
    • Remove deprecated protocol quirks (Ivan Andreev)
  • Memory
    • Fix setting of mime types (Nick Craig-Wood)
  • Onedrive
    • Add support for China region operated by 21vianet and other regional suppliers (NyaMisty)
    • Warn on gateway timeout errors (Nick Craig-Wood)
    • Fall back to normal copy if server-side copy unavailable (Alex Chen)
    • Fix server-side copy completely disabled on OneDrive for Business (Cnly)
    • (business only) workaround to replace existing file on server-side copy (Alex Chen)
    • Enhance link creation with expiry, scope, type and password (Nick Craig-Wood)
    • Remove % and # from the set of encoded characters (Alex Chen)
    • Support addressing site by server-relative URL (kice)
  • Opendrive
    • Fix finding directories in a case insensitive way (Nick Craig-Wood)
  • Pcloud
    • Fix setting of mime types (Nick Craig-Wood)
  • Premiumizeme
    • Fix finding directories in a case insensitive way (Nick Craig-Wood)
  • Qingstor
    • Fix error propagation in CleanUp (Nick Craig-Wood)
    • Fix rclone cleanup (Nick Craig-Wood)
  • S3
    • Added --s3-disable-http2 to disable http/2 (Anagh Kumar Baranwal)
    • Complete SSE-C implementation (Nick Craig-Wood)
      • Fix hashes on small files with AWS:KMS and SSE-C (Nick Craig-Wood)
      • Add MD5 metadata to objects uploaded with SSE-AWS/SSE-C (Nick Craig-Wood)
    • Add --s3-no-head parameter to minimise transactions on upload (Nick Craig-Wood)
    • Update docs with a Reducing Costs section (Nick Craig-Wood)
    • Added error handling for error code 429 indicating too many requests (Anagh Kumar Baranwal)
    • Add requester pays option (kelv)
    • Fix copy multipart with v2 auth failing with 'SignatureDoesNotMatch' (Louis Koo)
  • SFTP
    • Allow cert based auth via optional pubkey (Stephen Harris)
    • Allow user to optionally check server hosts key to add security (Stephen Harris)
    • Defer asking for user passwords until the SSH connection succeeds (Stephen Harris)
    • Remember entered password in AskPass mode (Stephen Harris)
    • Implement Shutdown method (Nick Craig-Wood)
    • Implement keyboard interactive authentication (Nick Craig-Wood)
    • Make --tpslimit apply (Nick Craig-Wood)
    • Implement --sftp-use-fstat for unusual SFTP servers (Nick Craig-Wood)
  • Sugarsync
    • Fix NewObject for files that differ in case (Nick Craig-Wood)
    • Fix finding directories in a case insensitive way (Nick Craig-Wood)
  • Swift
    • Fix deletion of parts of Static Large Object (SLO) (Nguyễn Hữu Luân)
    • Ensure partially uploaded large files are uploaded unless --swift-leave-parts-on-error (Nguyễn Hữu Luân)
  • Tardigrade
    • Upgrade to uplink v1.4.1 (Caleb Case)
  • WebDAV
    • Updated docs to show streaming to nextcloud is working (Durval Menezes)
  • Yandex
    • Set Features WriteMimeType to false as Yandex ignores mime types (Nick Craig-Wood)

v1.53.4 - 2021-01-20

See commits

  • Bug Fixes
    • accounting: Fix data race in Transferred() (Maciej Zimnoch)
    • build
      • Stop tagged releases making a current beta (Nick Craig-Wood)
      • Upgrade docker buildx action (Matteo Pietro Dazzi)
      • Add -buildmode to cross-compile.go (Nick Craig-Wood)
      • Fix docker build by upgrading ilteoood/docker_buildx (Nick Craig-Wood)
      • Revert GitHub actions brew fix since this is now fixed (Nick Craig-Wood)
      • Fix brew install --cask syntax for macOS build (Nick Craig-Wood)
      • Update nfpm syntax to fix build of .deb/.rpm packages (Nick Craig-Wood)
      • Fix for Windows build errors (Ivan Andreev)
    • fs: Parseduration: fixed tests to use UTC time (Ankur Gupta)
    • fshttp: Prevent overlap of HTTP headers in logs (Nathan Collins)
    • rc
      • Fix core/command giving 500 internal error (Nick Craig-Wood)
      • Add Copy method to rc.Params (Nick Craig-Wood)
      • Fix 500 error when marshalling errors from core/command (Nick Craig-Wood)
      • plugins: Create plugins files only if webui is enabled. (negative0)
    • serve http: Fix serving files of unknown length (Nick Craig-Wood)
    • serve sftp: Fix authentication on one connection blocking others (Nick Craig-Wood)
  • Mount
    • Add optional brew tag to throw an error when using mount in the binaries installed via Homebrew (Anagh Kumar Baranwal)
    • Add "." and ".." to directories to match cmount and expectations (Nick Craig-Wood)
  • VFS
    • Make cache dir absolute before using it to fix path too long errors (Nick Craig-Wood)
  • Chunker
    • Improve detection of incompatible metadata (Ivan Andreev)
  • Google Cloud Storage
    • Fix server side copy of large objects (Nick Craig-Wood)
  • Jottacloud
    • Fix token renewer to fix long uploads (Nick Craig-Wood)
    • Fix token refresh failed: is not a regular file error (Nick Craig-Wood)
  • Pcloud
    • Only use SHA1 hashes in EU region (Nick Craig-Wood)
  • Sharefile
    • Undo Fix backend due to API swapping integers for strings (Nick Craig-Wood)
  • WebDAV
    • Fix Open Range requests to fix 4shared mount (Nick Craig-Wood)
    • Add "Depth: 0" to GET requests to fix bitrix (Nick Craig-Wood)

v1.53.3 - 2020-11-19

See commits

  • Bug Fixes
    • random: Fix incorrect use of math/rand instead of crypto/rand CVE-2020-28924 (Nick Craig-Wood)
      • Passwords you have generated with rclone config may be insecure
      • See issue #4783 for more details and a checking tool
    • random: Seed math/rand in one place with crypto strong seed (Nick Craig-Wood)
  • VFS
    • Fix vfs/refresh calls with fs= parameter (Nick Craig-Wood)
  • Sharefile
    • Fix backend due to API swapping integers for strings (Nick Craig-Wood)

v1.53.2 - 2020-10-26

See commits

  • Bug Fixes
    • accounting
      • Fix incorrect speed and transferTime in core/stats (Nick Craig-Wood)
      • Stabilize display order of transfers on Windows (Nick Craig-Wood)
    • operations
      • Fix use of --suffix without --backup-dir (Nick Craig-Wood)
      • Fix spurious "--checksum is in use but the source and destination have no hashes in common" (Nick Craig-Wood)
    • build
      • Work around GitHub actions brew problem (Nick Craig-Wood)
      • Stop using set-env and set-path in the GitHub actions (Nick Craig-Wood)
  • Mount
    • mount2: Fix the swapped UID / GID values (Russell Cattelan)
  • VFS
    • Detect and recover from a file being removed externally from the cache (Nick Craig-Wood)
    • Fix a deadlock vulnerability in downloaders.Close (Leo Luan)
    • Fix a race condition in retryFailedResets (Leo Luan)
    • Fix missed concurrency control between some item operations and reset (Leo Luan)
    • Add exponential backoff during ENOSPC retries (Leo Luan)
    • Add a missed update of used cache space (Leo Luan)
    • Fix --no-modtime to not attempt to set modtimes (as documented) (Nick Craig-Wood)
  • Local
    • Fix sizes and syncing with --links option on Windows (Nick Craig-Wood)
  • Chunker
    • Disable ListR to fix missing files on GDrive (workaround) (Ivan Andreev)
    • Fix upload over crypt (Ivan Andreev)
  • Fichier
    • Increase maximum file size from 100GB to 300GB (gyutw)
  • Jottacloud
    • Remove clientSecret from config when upgrading to token based authentication (buengese)
    • Avoid double url escaping of device/mountpoint (albertony)
    • Remove DirMove workaround as it's not required anymore - also (buengese)
  • Mailru
    • Fix uploads after recent changes on server (Ivan Andreev)
    • Fix range requests after june changes on server (Ivan Andreev)
    • Fix invalid timestamp on corrupted files (fixes) (Ivan Andreev)
  • Onedrive
    • Fix disk usage for sharepoint (Nick Craig-Wood)
  • S3
    • Add missing regions for AWS (Anagh Kumar Baranwal)
  • Seafile
    • Fix accessing libraries > 2GB on 32 bit systems (Muffin King)
  • SFTP
    • Always convert the checksum to lower case (buengese)
  • Union
    • Create root directories if none exist (Nick Craig-Wood)

v1.53.1 - 2020-09-13

See commits

  • Bug Fixes
    • accounting: Remove new line from end of --stats-one-line display (Nick Craig-Wood)
    • check
      • Add back missing --download flag (Nick Craig-Wood)
      • Fix docs (Nick Craig-Wood)
    • docs
      • Note --log-file does append (Nick Craig-Wood)
      • Add full stops for consistency in rclone --help (edwardxml)
      • Add Tencent COS to s3 provider list (wjielai)
      • Updated mount command to reflect that it requires Go 1.13 or newer (Evan Harris)
      • jottacloud: Mention that uploads from local disk will not need to cache files to disk for md5 calculation (albertony)
      • Fix formatting of rc docs page (Nick Craig-Wood)
    • build
      • Include vendor tar ball in release and fix startdev (Nick Craig-Wood)
      • Fix "Illegal instruction" error for ARMv6 builds (Nick Craig-Wood)
      • Fix architecture name in ARMv7 build (Nick Craig-Wood)
  • VFS
    • Fix spurious error "vfs cache: failed to _ensure cache EOF" (Nick Craig-Wood)
    • Log an ERROR if we fail to set the file to be sparse (Nick Craig-Wood)
  • Local
    • Log an ERROR if we fail to set the file to be sparse (Nick Craig-Wood)
  • Drive
    • Re-adds special oauth help text (Tim Gallant)
  • Opendrive
    • Do not retry 400 errors (Evan Harris)

v1.53.0 - 2020-09-02

See commits

  • New Features
    • The VFS layer was heavily reworked for this release - see below for more details
    • Interactive mode -i/--interactive for destructive operations (fishbullet)
    • Add --bwlimit-file flag to limit speeds of individual file transfers (Nick Craig-Wood)
    • Transfers are sorted by start time in the stats and progress output (Max Sum)
    • Make sure backends expand ~ and environment vars in file names they use (Nick Craig-Wood)
    • Add --refresh-times flag to set modtimes on hashless backends (Nick Craig-Wood)
    • build
      • Remove vendor directory in favour of Go modules (Nick Craig-Wood)
      • Build with go1.15.x by default (Nick Craig-Wood)
      • Drop macOS 386 build as it is no longer supported by go1.15 (Nick Craig-Wood)
      • Add ARMv7 to the supported builds (Nick Craig-Wood)
      • Enable rclone cmount on macOS (Nick Craig-Wood)
      • Make rclone build with gccgo (Nick Craig-Wood)
      • Make rclone build with wasm (Nick Craig-Wood)
      • Change beta numbering to be semver compatible (Nick Craig-Wood)
      • Add file properties and icon to Windows executable (albertony)
      • Add experimental interface for integrating rclone into browsers (Nick Craig-Wood)
    • lib: Add file name compression (Klaus Post)
    • rc
      • Allow installation and use of plugins and test plugins with rclone-webui (Chaitanya Bankanhal)
      • Add reverse proxy pluginsHandler for serving plugins (Chaitanya Bankanhal)
      • Add mount/listmounts option for listing current mounts (Chaitanya Bankanhal)
      • Add operations/uploadfile to upload a file through rc using encoding multipart/form-data (Chaitanya Bankanhal)
      • Add core/command to execute rclone terminal commands. (Chaitanya Bankanhal)
    • rclone check
      • Add reporting of filenames for same/missing/changed (Nick Craig-Wood)
      • Make check command obey --dry-run/-i/--interactive (Nick Craig-Wood)
      • Make check do --checkers files concurrently (Nick Craig-Wood)
      • Retry downloads if they fail when using the --download flag (Nick Craig-Wood)
      • Make it show stats by default (Nick Craig-Wood)
    • rclone obscure: Allow obscure command to accept password on STDIN (David Ibarra)
    • rclone config
      • Set RCLONE_CONFIG_DIR for use in config files and subprocesses (Nick Craig-Wood)
      • Reject remote names starting with a dash. (jtagcat)
    • rclone cryptcheck: Add reporting of filenames for same/missing/changed (Nick Craig-Wood)
    • rclone dedupe: Make it obey the --size-only flag for duplicate detection (Nick Craig-Wood)
    • rclone link: Add --expire and --unlink flags (Roman Kredentser)
    • rclone mkdir: Warn when using mkdir on remotes which can't have empty directories (Nick Craig-Wood)
    • rclone rc: Allow JSON parameters to simplify command line usage (Nick Craig-Wood)
    • rclone serve ftp
      • Don't compile on < go1.13 after dependency update (Nick Craig-Wood)
      • Add error message if auth proxy fails (Nick Craig-Wood)
      • Use refactored goftp.io/server library for binary shrink (Nick Craig-Wood)
    • rclone serve restic: Expose interfaces so that rclone can be used as a library from within restic (Jack)
    • rclone sync: Add --track-renames-strategy leaf (Nick Craig-Wood)
    • rclone touch: Add ability to set nanosecond resolution times (Nick Craig-Wood)
    • rclone tree: Remove -i shorthand for --noindent as it conflicts with -i/--interactive (Nick Craig-Wood)
  • Bug Fixes
    • accounting
      • Fix documentation for speed/speedAvg (Nick Craig-Wood)
      • Fix elapsed time not show actual time since beginning (Chaitanya Bankanhal)
      • Fix deadlock in stats printing (Nick Craig-Wood)
    • build
      • Fix file handle leak in GitHub release tool (Garrett Squire)
    • rclone check: Fix successful retries with --download counting errors (Nick Craig-Wood)
    • rclone dedupe: Fix logging to be easier to understand (Nick Craig-Wood)
  • Mount
    • Warn macOS users that mount implementation is changing (Nick Craig-Wood)
      • to test the new implementation use rclone cmount instead of rclone mount
      • this is because the library rclone uses has dropped macOS support
    • rc interface
      • Add call for unmount all (Chaitanya Bankanhal)
      • Make mount/mount remote control take vfsOpt option (Nick Craig-Wood)
      • Add mountOpt to mount/mount (Nick Craig-Wood)
      • Add VFS and Mount options to mount/listmounts (Nick Craig-Wood)
    • Catch panics in cgofuse initialization and turn into error messages (Nick Craig-Wood)
    • Always supply stat information in Readdir (Nick Craig-Wood)
    • Add support for reading unknown length files using direct IO (Windows) (Nick Craig-Wood)
    • Fix On Windows don't add -o uid/gid=-1 if user supplies -o uid/gid. (Nick Craig-Wood)
    • Fix macOS losing directory contents in cmount (Nick Craig-Wood)
    • Fix volume name broken in recent refactor (Nick Craig-Wood)
  • VFS
    • Implement partial reads for --vfs-cache-mode full (Nick Craig-Wood)
    • Add --vfs-writeback option to delay writes back to cloud storage (Nick Craig-Wood)
    • Add --vfs-read-ahead parameter for use with --vfs-cache-mode full (Nick Craig-Wood)
    • Restart pending uploads on restart of the cache (Nick Craig-Wood)
    • Support synchronous cache space recovery upon ENOSPC (Leo Luan)
    • Allow ReadAt and WriteAt to run concurrently with themselves (Nick Craig-Wood)
    • Change modtime of file before upload to current (Rob Calistri)
    • Recommend --vfs-cache-modes writes on backends which can't stream (Nick Craig-Wood)
    • Add an optional fs parameter to vfs rc methods (Nick Craig-Wood)
    • Fix errors when using > 260 char files in the cache in Windows (Nick Craig-Wood)
    • Fix renaming of items while they are being uploaded (Nick Craig-Wood)
    • Fix very high load caused by slow directory listings (Nick Craig-Wood)
    • Fix renamed files not being uploaded with --vfs-cache-mode minimal (Nick Craig-Wood)
    • Fix directory locking caused by slow directory listings (Nick Craig-Wood)
    • Fix saving from chrome without --vfs-cache-mode writes (Nick Craig-Wood)
  • Local
    • Add --local-no-updated to provide a consistent view of changing objects (Nick Craig-Wood)
    • Add --local-no-set-modtime option to prevent modtime changes (tyhuber1)
    • Fix race conditions updating and reading Object metadata (Nick Craig-Wood)
  • Cache
    • Make any created backends be cached to fix rc problems (Nick Craig-Wood)
    • Fix dedupe on caches wrapping drives (Nick Craig-Wood)
  • Crypt
    • Add --crypt-server-side-across-configs flag (Nick Craig-Wood)
    • Make any created backends be cached to fix rc problems (Nick Craig-Wood)
  • Alias
    • Make any created backends be cached to fix rc problems (Nick Craig-Wood)
  • Azure Blob
    • Don't compile on < go1.13 after dependency update (Nick Craig-Wood)
  • B2
    • Implement server-side copy for files > 5GB (Nick Craig-Wood)
    • Cancel in progress multipart uploads and copies on rclone exit (Nick Craig-Wood)
    • Note that b2's encoding now allows  but rclone's hasn't changed (Nick Craig-Wood)
    • Fix transfers when using download_url (Nick Craig-Wood)
  • Box
    • Implement rclone cleanup (buengese)
    • Cancel in progress multipart uploads and copies on rclone exit (Nick Craig-Wood)
    • Allow authentication with access token (David)
  • Chunker
    • Make any created backends be cached to fix rc problems (Nick Craig-Wood)
  • Drive
    • Add rclone backend drives to list shared drives (teamdrives) (Nick Craig-Wood)
    • Implement rclone backend untrash (Nick Craig-Wood)
    • Work around drive bug which didn't set modtime of copied docs (Nick Craig-Wood)
    • Added --drive-starred-only to only show starred files (Jay McEntire)
    • Deprecate --drive-alternate-export as it is no longer needed (themylogin)
    • Fix duplication of Google docs on server-side copy (Nick Craig-Wood)
    • Fix "panic: send on closed channel" when recycling dir entries (Nick Craig-Wood)
  • Dropbox
    • Add copyright detector info in limitations section in the docs (Alex Guerrero)
    • Fix rclone link by removing expires parameter (Nick Craig-Wood)
  • Fichier
    • Detect Flood detected: IP Locked error and sleep for 30s (Nick Craig-Wood)
  • FTP
    • Add explicit TLS support (Heiko Bornholdt)
    • Add support for --dump bodies and --dump auth for debugging (Nick Craig-Wood)
    • Fix interoperation with pure-ftpd (Nick Craig-Wood)
  • Google Cloud Storage
    • Add support for anonymous access (Kai Lüke)
  • Jottacloud
    • Bring back legacy authentication for use with whitelabel versions (buengese)
    • Switch to new api root - also implement a very ugly workaround for the DirMove failures (buengese)
  • Onedrive
    • Rework cancel of multipart uploads on rclone exit (Nick Craig-Wood)
    • Implement rclone cleanup (Nick Craig-Wood)
    • Add --onedrive-no-versions flag to remove old versions (Nick Craig-Wood)
  • Pcloud
    • Implement rclone link for public link creation (buengese)
  • Qingstor
    • Cancel in progress multipart uploads on rclone exit (Nick Craig-Wood)
  • S3
    • Preserve metadata when doing multipart copy (Nick Craig-Wood)
    • Cancel in progress multipart uploads and copies on rclone exit (Nick Craig-Wood)
    • Add rclone link for public link sharing (Roman Kredentser)
    • Add rclone backend restore command to restore objects from GLACIER (Nick Craig-Wood)
    • Add rclone cleanup and rclone backend cleanup to clean unfinished multipart uploads (Nick Craig-Wood)
    • Add rclone backend list-multipart-uploads to list unfinished multipart uploads (Nick Craig-Wood)
    • Add --s3-max-upload-parts support (Kamil Trzciński)
    • Add --s3-no-check-bucket for minimising rclone transactions and perms (Nick Craig-Wood)
    • Add --s3-profile and --s3-shared-credentials-file options (Nick Craig-Wood)
    • Use regional s3 us-east-1 endpoint (David)
    • Add Scaleway provider (Vincent Feltz)
    • Update IBM COS endpoints (Egor Margineanu)
    • Reduce the default --s3-copy-cutoff to < 5GB for Backblaze S3 compatibility (Nick Craig-Wood)
    • Fix detection of bucket existing (Nick Craig-Wood)
  • SFTP
    • Use the absolute path instead of the relative path for listing for improved compatibility (Nick Craig-Wood)
    • Add --sftp-subsystem and --sftp-server-command options (aus)
  • Swift
    • Fix dangling large objects breaking the listing (Nick Craig-Wood)
    • Fix purge not deleting directory markers (Nick Craig-Wood)
    • Fix update multipart object removing all of its own parts (Nick Craig-Wood)
    • Fix missing hash from object returned from upload (Nick Craig-Wood)
  • Tardigrade
    • Upgrade to uplink v1.2.0 (Kaloyan Raev)
  • Union
    • Fix writing with the all policy (Nick Craig-Wood)
  • WebDAV
    • Fix directory creation with 4shared (Nick Craig-Wood)

v1.52.3 - 2020-08-07

See commits

  • Bug Fixes
    • docs
      • Disable smart typography (e.g. en-dash) in MANUAL.* and man page (Nick Craig-Wood)
      • Update install.md to reflect minimum Go version (Evan Harris)
      • Update install from source instructions (Nick Craig-Wood)
      • make_manual: Support SOURCE_DATE_EPOCH (Morten Linderud)
    • log: Fix --use-json-log going to stderr not --log-file on Windows (Nick Craig-Wood)
    • serve dlna: Fix file list on Samsung Series 6+ TVs (Matteo Pietro Dazzi)
    • sync: Fix deadlock with --track-renames-strategy modtime (Nick Craig-Wood)
  • Cache
    • Fix moveto/copyto remote:file remote:file2 (Nick Craig-Wood)
  • Drive
    • Stop using root_folder_id as a cache (Nick Craig-Wood)
    • Make dangling shortcuts appear in listings (Nick Craig-Wood)
    • Drop "Disabling ListR" messages down to debug (Nick Craig-Wood)
    • Workaround and policy for Google Drive API (Dmitry Ustalov)
  • FTP
    • Add note to docs about home vs root directory selection (Nick Craig-Wood)
  • Onedrive
    • Fix reverting to Copy when Move would have worked (Nick Craig-Wood)
    • Avoid comma rendered in URL in onedrive.md (Kevin)
  • Pcloud
    • Fix oauth on European region "eapi.pcloud.com" (Nick Craig-Wood)
  • S3
    • Fix bucket Region auto detection when Region unset in config (Nick Craig-Wood)

v1.52.2 - 2020-06-24

See commits

  • Bug Fixes
    • build
      • Fix docker release build action (Nick Craig-Wood)
      • Fix custom timezone in Docker image (NoLooseEnds)
    • check: Fix misleading message which printed errors instead of differences (Nick Craig-Wood)
    • errors: Add WSAECONNREFUSED and more to the list of retriable Windows errors (Nick Craig-Wood)
    • rcd: Fix incorrect prometheus metrics (Gary Kim)
    • serve restic: Fix flags so they use environment variables (Nick Craig-Wood)
    • serve webdav: Fix flags so they use environment variables (Nick Craig-Wood)
    • sync: Fix --track-renames-strategy modtime (Nick Craig-Wood)
  • Drive
    • Fix not being able to delete a directory with a trashed shortcut (Nick Craig-Wood)
    • Fix creating a directory inside a shortcut (Nick Craig-Wood)
    • Fix --drive-impersonate with cached root_folder_id (Nick Craig-Wood)
  • SFTP
    • Fix SSH key PEM loading (Zac Rubin)
  • Swift
    • Speed up deletes by not retrying segment container deletes (Nick Craig-Wood)
  • Tardigrade
    • Upgrade to uplink v1.1.1 (Caleb Case)
  • WebDAV
    • Fix free/used display for rclone about/df for certain backends (Nick Craig-Wood)

v1.52.1 - 2020-06-10

See commits

  • Bug Fixes
    • lib/file: Fix SetSparse on Windows 7 which fixes downloads of files > 250MB (Nick Craig-Wood)
    • build
      • Update go.mod to go1.14 to enable -mod=vendor build (Nick Craig-Wood)
      • Remove quicktest from Dockerfile (Nick Craig-Wood)
      • Build Docker images with GitHub actions (Matteo Pietro Dazzi)
      • Update Docker build workflows (Nick Craig-Wood)
      • Set user_allow_other in /etc/fuse.conf in the Docker image (Nick Craig-Wood)
      • Fix xgo build after go1.14 go.mod update (Nick Craig-Wood)
    • docs
      • Add link to source and modified time to footer of every page (Nick Craig-Wood)
      • Remove manually set dates and use git dates instead (Nick Craig-Wood)
      • Minor tense, punctuation, brevity and positivity changes for the home page (edwardxml)
      • Remove leading slash in page reference in footer when present (Nick Craig-Wood)
      • Note commands which need obscured input in the docs (Nick Craig-Wood)
      • obscure: Write more help as we are referencing it elsewhere (Nick Craig-Wood)
  • VFS
    • Fix OS vs Unix path confusion - fixes ChangeNotify on Windows (Nick Craig-Wood)
  • Drive
    • Fix missing items when listing using --fast-list / ListR (Nick Craig-Wood)
  • Putio
    • Fix panic on Object.Open (Cenk Alti)
  • S3
    • Fix upload of single files into buckets without create permission (Nick Craig-Wood)
    • Fix --header-upload (Nick Craig-Wood)
  • Tardigrade
    • Fix listing bug by upgrading to v1.0.7
    • Set UserAgent to rclone (Caleb Case)

v1.52.0 - 2020-05-27

Special thanks to Martin Michlmayr for proof reading and correcting all the docs and Edward Barker for helping re-write the front page.

See commits

  • New backends
    • Tardigrade backend for use with storj.io (Caleb Case)
    • Union re-write to have multiple writable remotes (Max Sum)
    • Seafile for Seafile server (Fred @creativeprojects)
  • New commands
    • backend: command for backend-specific commands (see backends) (Nick Craig-Wood)
    • cachestats: Deprecate in favour of rclone backend stats cache: (Nick Craig-Wood)
    • dbhashsum: Deprecate in favour of rclone hashsum DropboxHash (Nick Craig-Wood)
  • New Features
    • Add --header-download and --header-upload flags for setting HTTP headers when uploading/downloading (Tim Gallant)
    • Add --header flag to add HTTP headers to every HTTP transaction (Nick Craig-Wood)
    • Add --check-first to do all checking before starting transfers (Nick Craig-Wood)
    • Add --track-renames-strategy for configurable matching criteria for --track-renames (Bernd Schoolmann)
    • Add --cutoff-mode hard,soft,cautious (Shing Kit Chan & Franklyn Tackitt)
    • Filter flags (e.g. --files-from -) can read from stdin (fishbullet)
    • Add --error-on-no-transfer option (Jon Fautley)
    • Implement --order-by xxx,mixed for copying some small and some big files (Nick Craig-Wood)
    • Allow --max-backlog to be negative meaning as large as possible (Nick Craig-Wood)
    • Added --no-unicode-normalization flag to allow Unicode filenames to remain unique (Ben Zenker)
    • Allow --min-age/--max-age to take a date as well as a duration (Nick Craig-Wood)
    • Add rename statistics for file and directory renames (Nick Craig-Wood)
    • Add statistics output to JSON log (reddi)
    • Make stats be printed on non-zero exit code (Nick Craig-Wood)
    • When running --password-command allow use of stdin (Sébastien Gross)
    • Stop empty strings being a valid remote path (Nick Craig-Wood)
    • accounting: support WriterTo for less memory copying (Nick Craig-Wood)
    • build
      • Update to use go1.14 for the build (Nick Craig-Wood)
      • Add -trimpath to release build for reproduceable builds (Nick Craig-Wood)
      • Remove GOOS and GOARCH from Dockerfile (Brandon Philips)
    • config
      • Fsync the config file after writing to save more reliably (Nick Craig-Wood)
      • Add --obscure and --no-obscure flags to config create/update (Nick Craig-Wood)
      • Make config show take remote: as well as remote (Nick Craig-Wood)
    • copyurl: Add --no-clobber flag (Denis)
    • delete: Added --rmdirs flag to delete directories as well (Kush)
    • filter: Added --files-from-raw flag (Ankur Gupta)
    • genautocomplete: Add support for fish shell (Matan Rosenberg)
    • log: Add support for syslog LOCAL facilities (Patryk Jakuszew)
    • lsjson: Add --hash-type parameter and use it in lsf to speed up hashing (Nick Craig-Wood)
    • rc
      • Add -o/--opt and -a/--arg for more structured input (Nick Craig-Wood)
      • Implement backend/command for running backend-specific commands remotely (Nick Craig-Wood)
      • Add mount/mount command for starting rclone mount via the API (Chaitanya)
    • rcd: Add Prometheus metrics support (Gary Kim)
    • serve http
      • Added a --template flag for user defined markup (calistri)
      • Add Last-Modified headers to files and directories (Nick Craig-Wood)
    • serve sftp: Add support for multiple host keys by repeating --key flag (Maxime Suret)
    • touch: Add --localtime flag to make --timestamp localtime not UTC (Nick Craig-Wood)
  • Bug Fixes
    • accounting
      • Restore "Max number of stats groups reached" log line (Michał Matczuk)
      • Correct exitcode on Transfer Limit Exceeded flag. (Anuar Serdaliyev)
      • Reset bytes read during copy retry (Ankur Gupta)
      • Fix race clearing stats (Nick Craig-Wood)
    • copy: Only create empty directories when they don't exist on the remote (Ishuah Kariuki)
    • dedupe: Stop dedupe deleting files with identical IDs (Nick Craig-Wood)
    • oauth
      • Use custom http client so that --no-check-certificate is honored by oauth token fetch (Mark Spieth)
      • Replace deprecated oauth2.NoContext (Lars Lehtonen)
    • operations
      • Fix setting the timestamp on Windows for multithread copy (Nick Craig-Wood)
      • Make rcat obey --ignore-checksum (Nick Craig-Wood)
      • Make --max-transfer more accurate (Nick Craig-Wood)
    • rc
      • Fix dropped error (Lars Lehtonen)
      • Fix misplaced http server config (Xiaoxing Ye)
      • Disable duplicate log (ElonH)
    • serve dlna
      • Cds: don't specify childCount at all when unknown (Dan Walters)
      • Cds: use modification time as date in dlna metadata (Dan Walters)
    • serve restic: Fix tests after restic project removed vendoring (Nick Craig-Wood)
    • sync
      • Fix incorrect "nothing to transfer" message using --delete-before (Nick Craig-Wood)
      • Only create empty directories when they don't exist on the remote (Ishuah Kariuki)
  • Mount
    • Add --async-read flag to disable asynchronous reads (Nick Craig-Wood)
    • Ignore --allow-root flag with a warning as it has been removed upstream (Nick Craig-Wood)
    • Warn if --allow-non-empty used on Windows and clarify docs (Nick Craig-Wood)
    • Constrain to go1.13 or above otherwise bazil.org/fuse fails to compile (Nick Craig-Wood)
    • Fix fail because of too long volume name (evileye)
    • Report 1PB free for unknown disk sizes (Nick Craig-Wood)
    • Map more rclone errors into file systems errors (Nick Craig-Wood)
    • Fix disappearing cwd problem (Nick Craig-Wood)
    • Use ReaddirPlus on Windows to improve directory listing performance (Nick Craig-Wood)
    • Send a hint as to whether the filesystem is case insensitive or not (Nick Craig-Wood)
    • Add rc command mount/types (Nick Craig-Wood)
    • Change maximum leaf name length to 1024 bytes (Nick Craig-Wood)
  • VFS
    • Add --vfs-read-wait and --vfs-write-wait flags to control time waiting for a sequential read/write (Nick Craig-Wood)
    • Change default --vfs-read-wait to 20ms (it was 5ms and not configurable) (Nick Craig-Wood)
    • Make df output more consistent on a rclone mount. (Yves G)
    • Report 1PB free for unknown disk sizes (Nick Craig-Wood)
    • Fix race condition caused by unlocked reading of Dir.path (Nick Craig-Wood)
    • Make File lock and Dir lock not overlap to avoid deadlock (Nick Craig-Wood)
    • Implement lock ordering between File and Dir to eliminate deadlocks (Nick Craig-Wood)
    • Factor the vfs cache into its own package (Nick Craig-Wood)
    • Pin the Fs in use in the Fs cache (Nick Craig-Wood)
    • Add SetSys() methods to Node to allow caching stuff on a node (Nick Craig-Wood)
    • Ignore file not found errors from Hash in Read.Release (Nick Craig-Wood)
    • Fix hang in read wait code (Nick Craig-Wood)
  • Local
    • Speed up multi thread downloads by using sparse files on Windows (Nick Craig-Wood)
    • Implement --local-no-sparse flag for disabling sparse files (Nick Craig-Wood)
    • Implement rclone backend noop for testing purposes (Nick Craig-Wood)
    • Fix "file not found" errors on post transfer Hash calculation (Nick Craig-Wood)
  • Cache
    • Implement rclone backend stats command (Nick Craig-Wood)
    • Fix Server Side Copy with Temp Upload (Brandon McNama)
    • Remove Unused Functions (Lars Lehtonen)
    • Disable race tests until bbolt is fixed (Nick Craig-Wood)
    • Move methods used for testing into test file (greatroar)
    • Add Pin and Unpin and canonicalised lookup (Nick Craig-Wood)
    • Use proper import path go.etcd.io/bbolt (Robert-André Mauchin)
  • Crypt
    • Calculate hashes for uploads from local disk (Nick Craig-Wood)
      • This allows encrypted Jottacloud uploads without using local disk
      • This means encrypted s3/b2 uploads will now have hashes
    • Added rclone backend decode/encode commands to replicate functionality of cryptdecode (Anagh Kumar Baranwal)
    • Get rid of the unused Cipher interface as it obfuscated the code (Nick Craig-Wood)
  • Azure Blob
    • Implement streaming of unknown sized files so rcat is now supported (Nick Craig-Wood)
    • Implement memory pooling to control memory use (Nick Craig-Wood)
    • Add --azureblob-disable-checksum flag (Nick Craig-Wood)
    • Retry InvalidBlobOrBlock error as it may indicate block concurrency problems (Nick Craig-Wood)
    • Remove unused Object.parseTimeString() (Lars Lehtonen)
    • Fix permission error on SAS URL limited to container (Nick Craig-Wood)
  • B2
    • Add support for --header-upload and --header-download (Tim Gallant)
    • Ignore directory markers at the root also (Nick Craig-Wood)
    • Force the case of the SHA1 to lowercase (Nick Craig-Wood)
    • Remove unused largeUpload.clearUploadURL() (Lars Lehtonen)
  • Box
    • Add support for --header-upload and --header-download (Tim Gallant)
    • Implement About to read size used (Nick Craig-Wood)
    • Add token renew function for jwt auth (David Bramwell)
    • Added support for interchangeable root folder for Box backend (Sunil Patra)
    • Remove unnecessary iat from jws claims (David)
  • Drive
    • Follow shortcuts by default, skip with --drive-skip-shortcuts (Nick Craig-Wood)
    • Implement rclone backend shortcut command for creating shortcuts (Nick Craig-Wood)
    • Added rclone backend command to change service_account_file and chunk_size (Anagh Kumar Baranwal)
    • Fix missing files when using --fast-list and --drive-shared-with-me (Nick Craig-Wood)
    • Fix duplicate items when using --drive-shared-with-me (Nick Craig-Wood)
    • Extend --drive-stop-on-upload-limit to respond to teamDriveFileLimitExceeded. (harry)
    • Don't delete files with multiple parents to avoid data loss (Nick Craig-Wood)
    • Server side copy docs use default description if empty (Nick Craig-Wood)
  • Dropbox
    • Make error insufficient space to be fatal (harry)
    • Add info about required redirect url (Elan Ruusamäe)
  • Fichier
    • Add support for --header-upload and --header-download (Tim Gallant)
    • Implement custom pacer to deal with the new rate limiting (buengese)
  • FTP
    • Fix lockup when using concurrency limit on failed connections (Nick Craig-Wood)
    • Fix lockup on failed upload when using concurrency limit (Nick Craig-Wood)
    • Fix lockup on Close failures when using concurrency limit (Nick Craig-Wood)
    • Work around pureftp sending spurious 150 messages (Nick Craig-Wood)
  • Google Cloud Storage
    • Add support for --header-upload and --header-download (Nick Craig-Wood)
    • Add ARCHIVE storage class to help (Adam Stroud)
    • Ignore directory markers at the root (Nick Craig-Wood)
  • Googlephotos
    • Make the start year configurable (Daven)
    • Add support for --header-upload and --header-download (Tim Gallant)
    • Create feature/favorites directory (Brandon Philips)
    • Fix "concurrent map write" error (Nick Craig-Wood)
    • Don't put an image in error message (Nick Craig-Wood)
  • HTTP
    • Improved directory listing with new template from Caddy project (calisro)
  • Jottacloud
    • Implement --jottacloud-trashed-only (buengese)
    • Add support for --header-upload and --header-download (Tim Gallant)
    • Use RawURLEncoding when decoding base64 encoded login token (buengese)
    • Implement cleanup (buengese)
    • Update docs regarding cleanup, removed remains from old auth, and added warning about special mountpoints. (albertony)
  • Mailru
    • Describe 2FA requirements (valery1707)
  • Onedrive
    • Implement --onedrive-server-side-across-configs (Nick Craig-Wood)
    • Add support for --header-upload and --header-download (Tim Gallant)
    • Fix occasional 416 errors on multipart uploads (Nick Craig-Wood)
    • Added maximum chunk size limit warning in the docs (Harry)
    • Fix missing drive on config (Nick Craig-Wood)
    • Make error quotaLimitReached to be fatal (harry)
  • Opendrive
    • Add support for --header-upload and --header-download (Tim Gallant)
  • Pcloud
    • Added support for interchangeable root folder for pCloud backend (Sunil Patra)
    • Add support for --header-upload and --header-download (Tim Gallant)
    • Fix initial config "Auth state doesn't match" message (Nick Craig-Wood)
  • Premiumizeme
    • Add support for --header-upload and --header-download (Tim Gallant)
    • Prune unused functions (Lars Lehtonen)
  • Putio
    • Add support for --header-upload and --header-download (Nick Craig-Wood)
    • Make downloading files use the rclone http Client (Nick Craig-Wood)
    • Fix parsing of remotes with leading and trailing / (Nick Craig-Wood)
  • Qingstor
    • Make rclone cleanup remove pending multipart uploads older than 24h (Nick Craig-Wood)
    • Try harder to cancel failed multipart uploads (Nick Craig-Wood)
    • Prune multiUploader.list() (Lars Lehtonen)
    • Lint fix (Lars Lehtonen)
  • S3
    • Add support for --header-upload and --header-download (Tim Gallant)
    • Use memory pool for buffer allocations (Maciej Zimnoch)
    • Add SSE-C support for AWS, Ceph, and MinIO (Jack Anderson)
    • Fail fast multipart upload (Michał Matczuk)
    • Report errors on bucket creation (mkdir) correctly (Nick Craig-Wood)
    • Specify that Minio supports URL encoding in listings (Nick Craig-Wood)
    • Added 500 as retryErrorCode (Michał Matczuk)
    • Use --low-level-retries as the number of SDK retries (Aleksandar Janković)
    • Fix multipart abort context (Aleksandar Jankovic)
    • Replace deprecated session.New() with session.NewSession() (Lars Lehtonen)
    • Use the provided size parameter when allocating a new memory pool (Joachim Brandon LeBlanc)
    • Use rclone's low level retries instead of AWS SDK to fix listing retries (Nick Craig-Wood)
    • Ignore directory markers at the root also (Nick Craig-Wood)
    • Use single memory pool (Michał Matczuk)
    • Do not resize buf on put to memBuf (Michał Matczuk)
    • Improve docs for --s3-disable-checksum (Nick Craig-Wood)
    • Don't leak memory or tokens in edge cases for multipart upload (Nick Craig-Wood)
  • Seafile
    • Implement 2FA (Fred)
  • SFTP
    • Added --sftp-pem-key to support inline key files (calisro)
    • Fix post transfer copies failing with 0 size when using set_modtime=false (Nick Craig-Wood)
  • Sharefile
    • Add support for --header-upload and --header-download (Tim Gallant)
  • Sugarsync
    • Add support for --header-upload and --header-download (Tim Gallant)
  • Swift
    • Add support for --header-upload and --header-download (Nick Craig-Wood)
    • Fix cosmetic issue in error message (Martin Michlmayr)
  • Union
    • Implement multiple writable remotes (Max Sum)
    • Fix server-side copy (Max Sum)
    • Implement ListR (Max Sum)
    • Enable ListR when upstreams contain local (Max Sum)
  • WebDAV
    • Add support for --header-upload and --header-download (Tim Gallant)
    • Fix X-OC-Mtime header for Transip compatibility (Nick Craig-Wood)
    • Report full and consistent usage with about (Yves G)
  • Yandex
    • Add support for --header-upload and --header-download (Tim Gallant)

v1.51.0 - 2020-02-01

  • New backends
  • New Features
    • Adjust all backends to have --backend-encoding parameter (Nick Craig-Wood)
      • this enables the encoding for special characters to be adjusted or disabled
    • Add --max-duration flag to control the maximum duration of a transfer session (boosh)
    • Add --expect-continue-timeout flag, default 1s (Nick Craig-Wood)
    • Add --no-check-dest flag for copying without testing the destination (Nick Craig-Wood)
    • Implement --order-by flag to order transfers (Nick Craig-Wood)
    • accounting
      • Don't show entries in both transferring and checking (Nick Craig-Wood)
      • Add option to delete stats (Aleksandar Jankovic)
    • build
      • Compress the test builds with gzip (Nick Craig-Wood)
      • Implement a framework for starting test servers during tests (Nick Craig-Wood)
    • cmd: Always print elapsed time to tenth place seconds in progress (Gary Kim)
    • config
      • Add --password-command to allow dynamic config password (Damon Permezel)
      • Give config questions default values (Nick Craig-Wood)
      • Check a remote exists when creating a new one (Nick Craig-Wood)
    • copyurl: Add --stdout flag to write to stdout (Nick Craig-Wood)
    • dedupe: Implement keep smallest too (Nick Craig-Wood)
    • hashsum: Add flag --base64 flag (landall)
    • lsf: Speed up on s3/swift/etc by not reading mimetype by default (Nick Craig-Wood)
    • lsjson: Add --no-mimetype flag (Nick Craig-Wood)
    • rc: Add methods to turn on blocking and mutex profiling (Nick Craig-Wood)
    • rcd
      • Adding group parameter to stats (Chaitanya)
      • Move webgui apart; option to disable browser (Xiaoxing Ye)
    • serve sftp: Add support for public key with auth proxy (Paul Tinsley)
    • stats: Show deletes in stats and hide zero stats (anuar45)
  • Bug Fixes
    • accounting
      • Fix error counter counting multiple times (Ankur Gupta)
      • Fix error count shown as checks (Cnly)
      • Clear finished transfer in stats-reset (Maciej Zimnoch)
      • Added StatsInfo locking in statsGroups sum function (Michał Matczuk)
    • asyncreader: Fix EOF error (buengese)
    • check: Fix --one-way recursing more directories than it needs to (Nick Craig-Wood)
    • chunkedreader: Disable hash calculation for first segment (Nick Craig-Wood)
    • config
      • Do not open browser on headless on drive/gcs/google photos (Xiaoxing Ye)
      • SetValueAndSave ignore error if config section does not exist yet (buengese)
    • cmd: Fix completion with an encrypted config (Danil Semelenov)
    • dbhashsum: Stop it returning UNSUPPORTED on dropbox (Nick Craig-Wood)
    • dedupe: Add missing modes to help string (Nick Craig-Wood)
    • operations
      • Fix dedupe continuing on errors like insufficientFilePersimmon (SezalAgrawal)
      • Clear accounting before low level retry (Maciej Zimnoch)
      • Write debug message when hashes could not be checked (Ole Schütt)
      • Move interface assertion to tests to remove pflag dependency (Nick Craig-Wood)
      • Make NewOverrideObjectInfo public and factor uses (Nick Craig-Wood)
    • proxy: Replace use of bcrypt with sha256 (Nick Craig-Wood)
    • vendor
      • Update bazil.org/fuse to fix FreeBSD 12.1 (Nick Craig-Wood)
      • Update github.com/t3rm1n4l/go-mega to fix mega "illegal base64 data at input byte 22" (Nick Craig-Wood)
      • Update termbox-go to fix ncdu command on FreeBSD (Kuang-che Wu)
      • Update t3rm1n4l/go-mega - fixes mega: couldn't login: crypto/aes: invalid key size 0 (Nick Craig-Wood)
  • Mount
    • Enable async reads for a 20% speedup (Nick Craig-Wood)
    • Replace use of WriteAt with Write for cache mode >= writes and O_APPEND (Brett Dutro)
    • Make sure we call unmount when exiting (Nick Craig-Wood)
    • Don't build on go1.10 as bazil/fuse no longer supports it (Nick Craig-Wood)
    • When setting dates discard out of range dates (Nick Craig-Wood)
  • VFS
    • Add a newly created file straight into the directory (Nick Craig-Wood)
    • Only calculate one hash for reads for a speedup (Nick Craig-Wood)
    • Make ReadAt for non cached files work better with non-sequential reads (Nick Craig-Wood)
    • Fix edge cases when reading ModTime from file (Nick Craig-Wood)
    • Make sure existing files opened for write show correct size (Nick Craig-Wood)
    • Don't cache the path in RW file objects to fix renaming (Nick Craig-Wood)
    • Fix rename of open files when using the VFS cache (Nick Craig-Wood)
    • When renaming files in the cache, rename the cache item in memory too (Nick Craig-Wood)
    • Fix open file renaming on drive when using --vfs-cache-mode writes (Nick Craig-Wood)
    • Fix incorrect modtime for mv into mount with --vfs-cache-modes writes (Nick Craig-Wood)
    • On rename, rename in cache too if the file exists (Anagh Kumar Baranwal)
  • Local
    • Make source file being updated errors be NoLowLevelRetry errors (Nick Craig-Wood)
    • Fix update of hidden files on Windows (Nick Craig-Wood)
  • Cache
    • Follow move of upstream library github.com/coreos/bbolt github.com/etcd-io/bbolt (Nick Craig-Wood)
    • Fix fatal error: concurrent map writes (Nick Craig-Wood)
  • Crypt
    • Reorder the filename encryption options (Thomas Eales)
    • Correctly handle trailing dot (buengese)
  • Chunker
    • Reduce length of temporary suffix (Ivan Andreev)
  • Drive
    • Add --drive-stop-on-upload-limit flag to stop syncs when upload limit reached (Nick Craig-Wood)
    • Add --drive-use-shared-date to use date file was shared instead of modified date (Garry McNulty)
    • Make sure invalid auth for teamdrives always reports an error (Nick Craig-Wood)
    • Fix --fast-list when using appDataFolder (Nick Craig-Wood)
    • Use multipart resumable uploads for streaming and uploads in mount (Nick Craig-Wood)
    • Log an ERROR if an incomplete search is returned (Nick Craig-Wood)
    • Hide dangerous config from the configurator (Nick Craig-Wood)
  • Dropbox
    • Treat insufficient_space errors as non retriable errors (Nick Craig-Wood)
  • Jottacloud
    • Use new auth method used by official client (buengese)
    • Add URL to generate Login Token to config wizard (Nick Craig-Wood)
    • Add support whitelabel versions (buengese)
  • Koofr
    • Use rclone HTTP client. (jaKa)
  • Onedrive
    • Add Sites.Read.All permission (Benjamin Richter)
    • Add support "Retry-After" header (Motonori IWAMURO)
  • Opendrive
    • Implement --opendrive-chunk-size (Nick Craig-Wood)
  • S3
    • Re-implement multipart upload to fix memory issues (Nick Craig-Wood)
    • Add --s3-copy-cutoff for size to switch to multipart copy (Nick Craig-Wood)
    • Add new region Asia Pacific (Hong Kong) (Outvi V)
    • Reduce memory usage streaming files by reducing max stream upload size (Nick Craig-Wood)
    • Add --s3-list-chunk option for bucket listing (Thomas Kriechbaumer)
    • Force path style bucket access to off for AWS deprecation (Nick Craig-Wood)
    • Use AWS web identity role provider if available (Tennix)
    • Add StackPath Object Storage Support (Dave Koston)
    • Fix ExpiryWindow value (Aleksandar Jankovic)
    • Fix DisableChecksum condition (Aleksandar Janković)
    • Fix URL decoding of NextMarker (Nick Craig-Wood)
  • SFTP
    • Add --sftp-skip-links to skip symlinks and non regular files (Nick Craig-Wood)
    • Retry Creation of Connection (Sebastian Brandt)
    • Fix "failed to parse private key file: ssh: not an encrypted key" error (Nick Craig-Wood)
    • Open files for update write only to fix AWS SFTP interop (Nick Craig-Wood)
  • Swift
    • Reserve segments of dynamic large object when delete objects in container what was enabled versioning. (Nguyễn Hữu Luân)
    • Fix parsing of X-Object-Manifest (Nick Craig-Wood)
    • Update OVH API endpoint (unbelauscht)
  • WebDAV
    • Make nextcloud only upload SHA1 checksums (Nick Craig-Wood)
    • Fix case of "Bearer" in Authorization: header to agree with RFC (Nick Craig-Wood)
    • Add Referer header to fix problems with WAFs (Nick Craig-Wood)

v1.50.2 - 2019-11-19

  • Bug Fixes
    • accounting: Fix memory leak on retries operations (Nick Craig-Wood)
  • Drive
    • Fix listing of the root directory with drive.files scope (Nick Craig-Wood)
    • Fix --drive-root-folder-id with team/shared drives (Nick Craig-Wood)

v1.50.1 - 2019-11-02

  • Bug Fixes
    • hash: Fix accidentally changed hash names for DropboxHash and CRC-32 (Nick Craig-Wood)
    • fshttp: Fix error reporting on tpslimit token bucket errors (Nick Craig-Wood)
    • fshttp: Don't print token bucket errors on context cancelled (Nick Craig-Wood)
  • Local
    • Fix listings of . on Windows (Nick Craig-Wood)
  • Onedrive
    • Fix DirMove/Move after Onedrive change (Xiaoxing Ye)

v1.50.0 - 2019-10-26

  • New backends
  • New Features
    • encodings (Fabian Möller & Nick Craig-Wood)
    • build
      • Update to use go1.13 for the build (Nick Craig-Wood)
      • Drop support for go1.9 (Nick Craig-Wood)
      • Build rclone with GitHub actions (Nick Craig-Wood)
      • Convert python scripts to python3 (Nick Craig-Wood)
      • Swap Azure/go-ansiterm for mattn/go-colorable (Nick Craig-Wood)
      • Dockerfile fixes (Matei David)
      • Add plugin support for backends and commands (Richard Patel)
    • config
      • Use alternating Red/Green in config to make more obvious (Nick Craig-Wood)
    • contrib
      • Add sample DLNA server Docker Compose manifest. (pataquets)
      • Add sample WebDAV server Docker Compose manifest. (pataquets)
    • copyurl
      • Add --auto-filename flag for using file name from URL in destination path (Denis)
    • serve dlna:
      • Many compatibility improvements (Dan Walters)
      • Support for external srt subtitles (Dan Walters)
    • rc
      • Added command core/quit (Saksham Khanna)
  • Bug Fixes
    • sync
      • Make --update/-u not transfer files that haven't changed (Nick Craig-Wood)
      • Free objects after they come out of the transfer pipe to save memory (Nick Craig-Wood)
      • Fix --files-from without --no-traverse doing a recursive scan (Nick Craig-Wood)
    • operations
      • Fix accounting for server-side copies (Nick Craig-Wood)
      • Display 'All duplicates removed' only if dedupe successful (Sezal Agrawal)
      • Display 'Deleted X extra copies' only if dedupe successful (Sezal Agrawal)
    • accounting
      • Only allow up to 100 completed transfers in the accounting list to save memory (Nick Craig-Wood)
      • Cull the old time ranges when possible to save memory (Nick Craig-Wood)
      • Fix panic due to server-side copy fallback (Ivan Andreev)
      • Fix memory leak noticeable for transfers of large numbers of objects (Nick Craig-Wood)
      • Fix total duration calculation (Nick Craig-Wood)
    • cmd
      • Fix environment variables not setting command line flags (Nick Craig-Wood)
      • Make autocomplete compatible with bash's posix mode for macOS (Danil Semelenov)
      • Make --progress work in git bash on Windows (Nick Craig-Wood)
      • Fix 'compopt: command not found' on autocomplete on macOS (Danil Semelenov)
    • config
      • Fix setting of non top level flags from environment variables (Nick Craig-Wood)
      • Check config names more carefully and report errors (Nick Craig-Wood)
      • Remove error: can't use --size-only and --ignore-size together. (Nick Craig-Wood)
    • filter: Prevent mixing options when --files-from is in use (Michele Caci)
    • serve sftp: Fix crash on unsupported operations (e.g. Readlink) (Nick Craig-Wood)
  • Mount
    • Allow files of unknown size to be read properly (Nick Craig-Wood)
    • Skip tests on <= 2 CPUs to avoid lockup (Nick Craig-Wood)
    • Fix panic on File.Open (Nick Craig-Wood)
    • Fix "mount_fusefs: -o timeout=: option not supported" on FreeBSD (Nick Craig-Wood)
    • Don't pass huge filenames (>4k) to FUSE as it can't cope (Nick Craig-Wood)
  • VFS
    • Add flag --vfs-case-insensitive for windows/macOS mounts (Ivan Andreev)
    • Make objects of unknown size readable through the VFS (Nick Craig-Wood)
    • Move writeback of dirty data out of close() method into its own method (FlushWrites) and remove close() call from Flush() (Brett Dutro)
    • Stop empty dirs disappearing when renamed on bucket-based remotes (Nick Craig-Wood)
    • Stop change notify polling clearing so much of the directory cache (Nick Craig-Wood)
  • Azure Blob
    • Disable logging to the Windows event log (Nick Craig-Wood)
  • B2
    • Remove unverified: prefix on sha1 to improve interop (e.g. with CyberDuck) (Nick Craig-Wood)
  • Box
    • Add options to get access token via JWT auth (David)
  • Drive
    • Disable HTTP/2 by default to work around INTERNAL_ERROR problems (Nick Craig-Wood)
    • Make sure that drive root ID is always canonical (Nick Craig-Wood)
    • Fix --drive-shared-with-me from the root with lsand --fast-list (Nick Craig-Wood)
    • Fix ChangeNotify polling for shared drives (Nick Craig-Wood)
    • Fix change notify polling when using appDataFolder (Nick Craig-Wood)
  • Dropbox
    • Make disallowed filenames errors not retry (Nick Craig-Wood)
    • Fix nil pointer exception on restricted files (Nick Craig-Wood)
  • Fichier
    • Fix accessing files > 2GB on 32 bit systems (Nick Craig-Wood)
  • FTP
    • Allow disabling EPSV mode (Jon Fautley)
  • HTTP
    • HEAD directory entries in parallel to speedup (Nick Craig-Wood)
    • Add --http-no-head to stop rclone doing HEAD in listings (Nick Craig-Wood)
  • Putio
    • Add ability to resume uploads (Cenk Alti)
  • S3
    • Fix signature v2_auth headers (Anthony Rusdi)
    • Fix encoding for control characters (Nick Craig-Wood)
    • Only ask for URL encoded directory listings if we need them on Ceph (Nick Craig-Wood)
    • Add option for multipart failure behaviour (Aleksandar Jankovic)
    • Support for multipart copy (庄天翼)
    • Fix nil pointer reference if no metadata returned for object (Nick Craig-Wood)
  • SFTP
    • Fix --sftp-ask-password trying to contact the ssh agent (Nick Craig-Wood)
    • Fix hashes of files with backslashes (Nick Craig-Wood)
    • Include more ciphers with --sftp-use-insecure-cipher (Carlos Ferreyra)
  • WebDAV
    • Parse and return Sharepoint error response (Henning Surmeier)

v1.49.5 - 2019-10-05

  • Bug Fixes
    • Revert back to go1.12.x for the v1.49.x builds as go1.13.x was causing issues (Nick Craig-Wood)
    • Fix rpm packages by using master builds of nfpm (Nick Craig-Wood)
    • Fix macOS build after brew changes (Nick Craig-Wood)

v1.49.4 - 2019-09-29

  • Bug Fixes
    • cmd/rcd: Address ZipSlip vulnerability (Richard Patel)
    • accounting: Fix file handle leak on errors (Nick Craig-Wood)
    • oauthutil: Fix security problem when running with two users on the same machine (Nick Craig-Wood)
  • FTP
    • Fix listing of an empty root returning: error dir not found (Nick Craig-Wood)
  • S3
    • Fix SetModTime on GLACIER/ARCHIVE objects and implement set/get tier (Nick Craig-Wood)

v1.49.3 - 2019-09-15

  • Bug Fixes
    • accounting
      • Fix total duration calculation (Aleksandar Jankovic)
      • Fix "file already closed" on transfer retries (Nick Craig-Wood)

v1.49.2 - 2019-09-08

  • New Features
    • build: Add Docker workflow support (Alfonso Montero)
  • Bug Fixes
    • accounting: Fix locking in Transfer to avoid deadlock with --progress (Nick Craig-Wood)
    • docs: Fix template argument for mktemp in install.sh (Cnly)
    • operations: Fix -u/--update with google photos / files of unknown size (Nick Craig-Wood)
    • rc: Fix docs for config/create /update /password (Nick Craig-Wood)
  • Google Cloud Storage
    • Fix need for elevated permissions on SetModTime (Nick Craig-Wood)

v1.49.1 - 2019-08-28

  • Bug Fixes
    • config: Fix generated passwords being stored as empty password (Nick Craig-Wood)
    • rcd: Added missing parameter for web-gui info logs. (Chaitanya)
  • Googlephotos
    • Fix crash on error response (Nick Craig-Wood)
  • Onedrive
    • Fix crash on error response (Nick Craig-Wood)

v1.49.0 - 2019-08-26

  • New backends
  • New Features
    • Experimental web GUI (Chaitanya Bankanhal)
    • Implement --compare-dest & --copy-dest (yparitcher)
    • Implement --suffix without --backup-dir for backup to current dir (yparitcher)
    • config reconnect to re-login (re-run the oauth login) for the backend. (Nick Craig-Wood)
    • config userinfo to discover which user you are logged in as. (Nick Craig-Wood)
    • config disconnect to disconnect you (log out) from the backend. (Nick Craig-Wood)
    • Add --use-json-log for JSON logging (justinalin)
    • Add context propagation to rclone (Aleksandar Jankovic)
    • Reworking internal statistics interfaces so they work with rc jobs (Aleksandar Jankovic)
    • Add Higher units for ETA (AbelThar)
    • Update rclone logos to new design (Andreas Chlupka)
    • hash: Add CRC-32 support (Cenk Alti)
    • help showbackend: Fixed advanced option category when there are no standard options (buengese)
    • ncdu: Display/Copy to Clipboard Current Path (Gary Kim)
    • operations:
      • Run hashing operations in parallel (Nick Craig-Wood)
      • Don't calculate checksums when using --ignore-checksum (Nick Craig-Wood)
      • Check transfer hashes when using --size-only mode (Nick Craig-Wood)
      • Disable multi thread copy for local to local copies (Nick Craig-Wood)
      • Debug successful hashes as well as failures (Nick Craig-Wood)
    • rc
      • Add ability to stop async jobs (Aleksandar Jankovic)
      • Return current settings if core/bwlimit called without parameters (Nick Craig-Wood)
      • Rclone-WebUI integration with rclone (Chaitanya Bankanhal)
      • Added command line parameter to control the cross origin resource sharing (CORS) in the rcd. (Security Improvement) (Chaitanya Bankanhal)
      • Add anchor tags to the docs so links are consistent (Nick Craig-Wood)
      • Remove _async key from input parameters after parsing so later operations won't get confused (buengese)
      • Add call to clear stats (Aleksandar Jankovic)
    • rcd
      • Auto-login for web-gui (Chaitanya Bankanhal)
      • Implement --baseurl for rcd and web-gui (Chaitanya Bankanhal)
    • serve dlna
      • Only select interfaces which can multicast for SSDP (Nick Craig-Wood)
      • Add more builtin mime types to cover standard audio/video (Nick Craig-Wood)
      • Fix missing mime types on Android causing missing videos (Nick Craig-Wood)
    • serve ftp
      • Refactor to bring into line with other serve commands (Nick Craig-Wood)
      • Implement --auth-proxy (Nick Craig-Wood)
    • serve http: Implement --baseurl (Nick Craig-Wood)
    • serve restic: Implement --baseurl (Nick Craig-Wood)
    • serve sftp
      • Implement auth proxy (Nick Craig-Wood)
      • Fix detection of whether server is authorized (Nick Craig-Wood)
    • serve webdav
      • Implement --baseurl (Nick Craig-Wood)
      • Support --auth-proxy (Nick Craig-Wood)
  • Bug Fixes
    • Make "bad record MAC" a retriable error (Nick Craig-Wood)
    • copyurl: Fix copying files that return HTTP errors (Nick Craig-Wood)
    • march: Fix checking sub-directories when using --no-traverse (buengese)
    • rc
      • Fix unmarshalable http.AuthFn in options and put in test for marshalability (Nick Craig-Wood)
      • Move job expire flags to rc to fix initialization problem (Nick Craig-Wood)
      • Fix --loopback with rc/list and others (Nick Craig-Wood)
    • rcat: Fix slowdown on systems with multiple hashes (Nick Craig-Wood)
    • rcd: Fix permissions problems on cache directory with web gui download (Nick Craig-Wood)
  • Mount
    • Default --daemon-timeout to 15 minutes on macOS and FreeBSD (Nick Craig-Wood)
    • Update docs to show mounting from root OK for bucket-based (Nick Craig-Wood)
    • Remove nonseekable flag from write files (Nick Craig-Wood)
  • VFS
    • Make write without cache more efficient (Nick Craig-Wood)
    • Fix --vfs-cache-mode minimal and writes ignoring cached files (Nick Craig-Wood)
  • Local
    • Add --local-case-sensitive and --local-case-insensitive (Nick Craig-Wood)
    • Avoid polluting page cache when uploading local files to remote backends (Michał Matczuk)
    • Don't calculate any hashes by default (Nick Craig-Wood)
    • Fadvise run syscall on a dedicated go routine (Michał Matczuk)
  • Azure Blob
    • Azure Storage Emulator support (Sandeep)
    • Updated config help details to remove connection string references (Sandeep)
    • Make all operations work from the root (Nick Craig-Wood)
  • B2
    • Implement link sharing (yparitcher)
    • Enable server-side copy to copy between buckets (Nick Craig-Wood)
    • Make all operations work from the root (Nick Craig-Wood)
  • Drive
    • Fix server-side copy of big files (Nick Craig-Wood)
    • Update API for teamdrive use (Nick Craig-Wood)
    • Add error for purge with --drive-trashed-only (ginvine)
  • Fichier
    • Make FolderID int and adjust related code (buengese)
  • Google Cloud Storage
    • Reduce oauth scope requested as suggested by Google (Nick Craig-Wood)
    • Make all operations work from the root (Nick Craig-Wood)
  • HTTP
    • Add --http-headers flag for setting arbitrary headers (Nick Craig-Wood)
  • Jottacloud
    • Use new api for retrieving internal username (buengese)
    • Refactor configuration and minor cleanup (buengese)
  • Koofr
    • Support setting modification times on Koofr backend. (jaKa)
  • Opendrive
    • Refactor to use existing lib/rest facilities for uploads (Nick Craig-Wood)
  • Qingstor
    • Upgrade to v3 SDK and fix listing loop (Nick Craig-Wood)
    • Make all operations work from the root (Nick Craig-Wood)
  • S3
    • Add INTELLIGENT_TIERING storage class (Matti Niemenmaa)
    • Make all operations work from the root (Nick Craig-Wood)
  • SFTP
    • Add missing interface check and fix About (Nick Craig-Wood)
    • Completely ignore all modtime checks if SetModTime=false (Jon Fautley)
    • Support md5/sha1 with rsync.net (Nick Craig-Wood)
    • Save the md5/sha1 command in use to the config file for efficiency (Nick Craig-Wood)
    • Opt-in support for diffie-hellman-group-exchange-sha256 diffie-hellman-group-exchange-sha1 (Yi FU)
  • Swift
    • Use FixRangeOption to fix 0 length files via the VFS (Nick Craig-Wood)
    • Fix upload when using no_chunk to return the correct size (Nick Craig-Wood)
    • Make all operations work from the root (Nick Craig-Wood)
    • Fix segments leak during failed large file uploads. (nguyenhuuluan434)
  • WebDAV
    • Add --webdav-bearer-token-command (Nick Craig-Wood)
    • Refresh token when it expires with --webdav-bearer-token-command (Nick Craig-Wood)
    • Add docs for using bearer_token_command with oidc-agent (Paul Millar)

v1.48.0 - 2019-06-15

  • New commands
    • serve sftp: Serve an rclone remote over SFTP (Nick Craig-Wood)
  • New Features
    • Multi threaded downloads to local storage (Nick Craig-Wood)
      • controlled with --multi-thread-cutoff and --multi-thread-streams
    • Use rclone.conf from rclone executable directory to enable portable use (albertony)
    • Allow sync of a file and a directory with the same name (forgems)
      • this is common on bucket-based remotes, e.g. s3, gcs
    • Add --ignore-case-sync for forced case insensitivity (garry415)
    • Implement --stats-one-line-date and --stats-one-line-date-format (Peter Berbec)
    • Log an ERROR for all commands which exit with non-zero status (Nick Craig-Wood)
    • Use go-homedir to read the home directory more reliably (Nick Craig-Wood)
    • Enable creating encrypted config through external script invocation (Wojciech Smigielski)
    • build: Drop support for go1.8 (Nick Craig-Wood)
    • config: Make config create/update encrypt passwords where necessary (Nick Craig-Wood)
    • copyurl: Honor --no-check-certificate (Stefan Breunig)
    • install: Linux skip man pages if no mandb (didil)
    • lsf: Support showing the Tier of the object (Nick Craig-Wood)
    • lsjson
      • Added EncryptedPath to output (calisro)
      • Support showing the Tier of the object (Nick Craig-Wood)
      • Add IsBucket field for bucket-based remote listing of the root (Nick Craig-Wood)
    • rc
      • Add --loopback flag to run commands directly without a server (Nick Craig-Wood)
      • Add operations/fsinfo: Return information about the remote (Nick Craig-Wood)
      • Skip auth for OPTIONS request (Nick Craig-Wood)
      • cmd/providers: Add DefaultStr, ValueStr and Type fields (Nick Craig-Wood)
      • jobs: Make job expiry timeouts configurable (Aleksandar Jankovic)
    • serve dlna reworked and improved (Dan Walters)
    • serve ftp: add --ftp-public-ip flag to specify public IP (calistri)
    • serve restic: Add support for --private-repos in serve restic (Florian Apolloner)
    • serve webdav: Combine serve webdav and serve http (Gary Kim)
    • size: Ignore negative sizes when calculating total (Garry McNulty)
  • Bug Fixes
    • Make move and copy individual files obey --backup-dir (Nick Craig-Wood)
    • If --ignore-checksum is in effect, don't calculate checksum (Nick Craig-Wood)
    • moveto: Fix case-insensitive same remote move (Gary Kim)
    • rc: Fix serving bucket-based objects with --rc-serve (Nick Craig-Wood)
    • serve webdav: Fix serveDir not being updated with changes from webdav (Gary Kim)
  • Mount
    • Fix poll interval documentation (Animosity022)
  • VFS
    • Make WriteAt for non cached files work with non-sequential writes (Nick Craig-Wood)
  • Local
    • Only calculate the required hashes for big speedup (Nick Craig-Wood)
    • Log errors when listing instead of returning an error (Nick Craig-Wood)
    • Fix preallocate warning on Linux with ZFS (Nick Craig-Wood)
  • Crypt
    • Make rclone dedupe work through crypt (Nick Craig-Wood)
    • Fix wrapping of ChangeNotify to decrypt directories properly (Nick Craig-Wood)
    • Support PublicLink (rclone link) of underlying backend (Nick Craig-Wood)
    • Implement Optional methods SetTier, GetTier (Nick Craig-Wood)
  • B2
    • Implement server-side copy (Nick Craig-Wood)
    • Implement SetModTime (Nick Craig-Wood)
  • Drive
    • Fix move and copy from TeamDrive to GDrive (Fionera)
    • Add notes that cleanup works in the background on drive (Nick Craig-Wood)
    • Add --drive-server-side-across-configs to default back to old server-side copy semantics by default (Nick Craig-Wood)
    • Add --drive-size-as-quota to show storage quota usage for file size (Garry McNulty)
  • FTP
    • Add FTP List timeout (Jeff Quinn)
    • Add FTP over TLS support (Gary Kim)
    • Add --ftp-no-check-certificate option for FTPS (Gary Kim)
  • Google Cloud Storage
    • Fix upload errors when uploading pre 1970 files (Nick Craig-Wood)
  • Jottacloud
    • Add support for selecting device and mountpoint. (buengese)
  • Mega
    • Add cleanup support (Gary Kim)
  • Onedrive
    • More accurately check if root is found (Cnly)
  • S3
    • Support S3 Accelerated endpoints with --s3-use-accelerate-endpoint (Nick Craig-Wood)
    • Add config info for Wasabi's EU Central endpoint (Robert Marko)
    • Make SetModTime work for GLACIER while syncing (Philip Harvey)
  • SFTP
    • Add About support (Gary Kim)
    • Fix about parsing of df results so it can cope with -ve results (Nick Craig-Wood)
    • Send custom client version and debug server version (Nick Craig-Wood)
  • WebDAV
    • Retry on 423 Locked errors (Nick Craig-Wood)

v1.47.0 - 2019-04-13

  • New backends
    • Backend for Koofr cloud storage service. (jaKa)
  • New Features
    • Resume downloads if the reader fails in copy (Nick Craig-Wood)
      • this means rclone will restart transfers if the source has an error
      • this is most useful for downloads or cloud to cloud copies
    • Use --fast-list for listing operations where it won't use more memory (Nick Craig-Wood)
      • this should speed up the following operations on remotes which support ListR
      • dedupe, serve restic lsf, ls, lsl, lsjson, lsd, md5sum, sha1sum, hashsum, size, delete, cat, settier
      • use --disable ListR to get old behaviour if required
    • Make --files-from traverse the destination unless --no-traverse is set (Nick Craig-Wood)
      • this fixes --files-from with Google drive and excessive API use in general.
    • Make server-side copy account bytes and obey --max-transfer (Nick Craig-Wood)
    • Add --create-empty-src-dirs flag and default to not creating empty dirs (ishuah)
    • Add client side TLS/SSL flags --ca-cert/--client-cert/--client-key (Nick Craig-Wood)
    • Implement --suffix-keep-extension for use with --suffix (Nick Craig-Wood)
    • build:
      • Switch to semver compliant version tags to be go modules compliant (Nick Craig-Wood)
      • Update to use go1.12.x for the build (Nick Craig-Wood)
    • serve dlna: Add connection manager service description to improve compatibility (Dan Walters)
    • lsf: Add 'e' format to show encrypted names and 'o' for original IDs (Nick Craig-Wood)
    • lsjson: Added --files-only and --dirs-only flags (calistri)
    • rc: Implement operations/publiclink the equivalent of rclone link (Nick Craig-Wood)
  • Bug Fixes
    • accounting: Fix total ETA when --stats-unit bits is in effect (Nick Craig-Wood)
    • Bash TAB completion
      • Use private custom func to fix clash between rclone and kubectl (Nick Craig-Wood)
      • Fix for remotes with underscores in their names (Six)
      • Fix completion of remotes (Florian Gamböck)
      • Fix autocompletion of remote paths with spaces (Danil Semelenov)
    • serve dlna: Fix root XML service descriptor (Dan Walters)
    • ncdu: Fix display corruption with Chinese characters (Nick Craig-Wood)
    • Add SIGTERM to signals which run the exit handlers on unix (Nick Craig-Wood)
    • rc: Reload filter when the options are set via the rc (Nick Craig-Wood)
  • VFS / Mount
    • Fix FreeBSD: Ignore Truncate if called with no readers and already the correct size (Nick Craig-Wood)
    • Read directory and check for a file before mkdir (Nick Craig-Wood)
    • Shorten the locking window for vfs/refresh (Nick Craig-Wood)
  • Azure Blob
    • Enable MD5 checksums when uploading files bigger than the "Cutoff" (Dr.Rx)
    • Fix SAS URL support (Nick Craig-Wood)
  • B2
    • Allow manual configuration of backblaze downloadUrl (Vince)
    • Ignore already_hidden error on remove (Nick Craig-Wood)
    • Ignore malformed src_last_modified_millis (Nick Craig-Wood)
  • Drive
    • Add --skip-checksum-gphotos to ignore incorrect checksums on Google Photos (Nick Craig-Wood)
    • Allow server-side move/copy between different remotes. (Fionera)
    • Add docs on team drives and --fast-list eventual consistency (Nestar47)
    • Fix imports of text files (Nick Craig-Wood)
    • Fix range requests on 0 length files (Nick Craig-Wood)
    • Fix creation of duplicates with server-side copy (Nick Craig-Wood)
  • Dropbox
    • Retry blank errors to fix long listings (Nick Craig-Wood)
  • FTP
    • Add --ftp-concurrency to limit maximum number of connections (Nick Craig-Wood)
  • Google Cloud Storage
    • Fall back to default application credentials (marcintustin)
    • Allow bucket policy only buckets (Nick Craig-Wood)
  • HTTP
    • Add --http-no-slash for websites with directories with no slashes (Nick Craig-Wood)
    • Remove duplicates from listings (Nick Craig-Wood)
    • Fix socket leak on 404 errors (Nick Craig-Wood)
  • Jottacloud
    • Fix token refresh (Sebastian Bünger)
    • Add device registration (Oliver Heyme)
  • Onedrive
    • Implement graceful cancel of multipart uploads if rclone is interrupted (Cnly)
    • Always add trailing colon to path when addressing items, (Cnly)
    • Return errors instead of panic for invalid uploads (Fabian Möller)
  • S3
    • Add support for "Glacier Deep Archive" storage class (Manu)
    • Update Dreamhost endpoint (Nick Craig-Wood)
    • Note incompatibility with CEPH Jewel (Nick Craig-Wood)
  • SFTP
    • Allow custom ssh client config (Alexandru Bumbacea)
  • Swift
    • Obey Retry-After to enable OVH restore from cold storage (Nick Craig-Wood)
    • Work around token expiry on CEPH (Nick Craig-Wood)
  • WebDAV
    • Allow IsCollection property to be integer or boolean (Nick Craig-Wood)
    • Fix race when creating directories (Nick Craig-Wood)
    • Fix About/df when reading the available/total returns 0 (Nick Craig-Wood)

v1.46 - 2019-02-09

  • New backends
    • Support Alibaba Cloud (Aliyun) OSS via the s3 backend (Nick Craig-Wood)
  • New commands
    • serve dlna: serves a remove via DLNA for the local network (nicolov)
  • New Features
    • copy, move: Restore deprecated --no-traverse flag (Nick Craig-Wood)
      • This is useful for when transferring a small number of files into a large destination
    • genautocomplete: Add remote path completion for bash completion (Christopher Peterson & Danil Semelenov)
    • Buffer memory handling reworked to return memory to the OS better (Nick Craig-Wood)
      • Buffer recycling library to replace sync.Pool
      • Optionally use memory mapped memory for better memory shrinking
      • Enable with --use-mmap if having memory problems - not default yet
    • Parallelise reading of files specified by --files-from (Nick Craig-Wood)
    • check: Add stats showing total files matched. (Dario Guzik)
    • Allow rename/delete open files under Windows (Nick Craig-Wood)
    • lsjson: Use exactly the correct number of decimal places in the seconds (Nick Craig-Wood)
    • Add cookie support with cmdline switch --use-cookies for all HTTP based remotes (qip)
    • Warn if --checksum is set but there are no hashes available (Nick Craig-Wood)
    • Rework rate limiting (pacer) to be more accurate and allow bursting (Nick Craig-Wood)
    • Improve error reporting for too many/few arguments in commands (Nick Craig-Wood)
    • listremotes: Remove -l short flag as it conflicts with the new global flag (weetmuts)
    • Make http serving with auth generate INFO messages on auth fail (Nick Craig-Wood)
  • Bug Fixes
    • Fix layout of stats (Nick Craig-Wood)
    • Fix --progress crash under Windows Jenkins (Nick Craig-Wood)
    • Fix transfer of google/onedrive docs by calling Rcat in Copy when size is -1 (Cnly)
    • copyurl: Fix checking of --dry-run (Denis Skovpen)
  • Mount
    • Check that mountpoint and local directory to mount don't overlap (Nick Craig-Wood)
    • Fix mount size under 32 bit Windows (Nick Craig-Wood)
  • VFS
    • Implement renaming of directories for backends without DirMove (Nick Craig-Wood)
      • now all backends except b2 support renaming directories
    • Implement --vfs-cache-max-size to limit the total size of the cache (Nick Craig-Wood)
    • Add --dir-perms and --file-perms flags to set default permissions (Nick Craig-Wood)
    • Fix deadlock on concurrent operations on a directory (Nick Craig-Wood)
    • Fix deadlock between RWFileHandle.close and File.Remove (Nick Craig-Wood)
    • Fix renaming/deleting open files with cache mode "writes" under Windows (Nick Craig-Wood)
    • Fix panic on rename with --dry-run set (Nick Craig-Wood)
    • Fix vfs/refresh with recurse=true needing the --fast-list flag
  • Local
    • Add support for -l/--links (symbolic link translation) (yair@unicorn)
      • this works by showing links as link.rclonelink - see local backend docs for more info
      • this errors if used with -L/--copy-links
    • Fix renaming/deleting open files on Windows (Nick Craig-Wood)
  • Crypt
    • Check for maximum length before decrypting filename to fix panic (Garry McNulty)
  • Azure Blob
    • Allow building azureblob backend on *BSD (themylogin)
    • Use the rclone HTTP client to support --dump headers, --tpslimit, etc. (Nick Craig-Wood)
    • Use the s3 pacer for 0 delay in non error conditions (Nick Craig-Wood)
    • Ignore directory markers (Nick Craig-Wood)
    • Stop Mkdir attempting to create existing containers (Nick Craig-Wood)
  • B2
    • cleanup: will remove unfinished large files >24hrs old (Garry McNulty)
    • For a bucket limited application key check the bucket name (Nick Craig-Wood)
      • before this, rclone would use the authorised bucket regardless of what you put on the command line
    • Added --b2-disable-checksum flag (Wojciech Smigielski)
      • this enables large files to be uploaded without a SHA-1 hash for speed reasons
  • Drive
    • Set default pacer to 100ms for 10 tps (Nick Craig-Wood)
      • This fits the Google defaults much better and reduces the 403 errors massively
      • Add --drive-pacer-min-sleep and --drive-pacer-burst to control the pacer
    • Improve ChangeNotify support for items with multiple parents (Fabian Möller)
    • Fix ListR for items with multiple parents - this fixes oddities with vfs/refresh (Fabian Möller)
    • Fix using --drive-impersonate and appfolders (Nick Craig-Wood)
    • Fix google docs in rclone mount for some (not all) applications (Nick Craig-Wood)
  • Dropbox
    • Retry-After support for Dropbox backend (Mathieu Carbou)
  • FTP
    • Wait for 60 seconds for a connection to Close then declare it dead (Nick Craig-Wood)
      • helps with indefinite hangs on some FTP servers
  • Google Cloud Storage
    • Update google cloud storage endpoints (weetmuts)
  • HTTP
    • Add an example with username and password which is supported but wasn't documented (Nick Craig-Wood)
    • Fix backend with --files-from and nonexistent files (Nick Craig-Wood)
  • Hubic
    • Make error message more informative if authentication fails (Nick Craig-Wood)
  • Jottacloud
    • Resume and deduplication support (Oliver Heyme)
    • Use token auth for all API requests Don't store password anymore (Sebastian Bünger)
    • Add support for 2-factor authentication (Sebastian Bünger)
  • Mega
    • Implement v2 account login which fixes logins for newer Mega accounts (Nick Craig-Wood)
    • Return error if an unknown length file is attempted to be uploaded (Nick Craig-Wood)
    • Add new error codes for better error reporting (Nick Craig-Wood)
  • Onedrive
    • Fix broken support for "shared with me" folders (Alex Chen)
    • Fix root ID not normalised (Cnly)
    • Return err instead of panic on unknown-sized uploads (Cnly)
  • Qingstor
    • Fix go routine leak on multipart upload errors (Nick Craig-Wood)
    • Add upload chunk size/concurrency/cutoff control (Nick Craig-Wood)
    • Default --qingstor-upload-concurrency to 1 to work around bug (Nick Craig-Wood)
  • S3
    • Implement --s3-upload-cutoff for single part uploads below this (Nick Craig-Wood)
    • Change --s3-upload-concurrency default to 4 to increase performance (Nick Craig-Wood)
    • Add --s3-bucket-acl to control bucket ACL (Nick Craig-Wood)
    • Auto detect region for buckets on operation failure (Nick Craig-Wood)
    • Add GLACIER storage class (William Cocker)
    • Add Scaleway to s3 documentation (Rémy Léone)
    • Add AWS endpoint eu-north-1 (weetmuts)
  • SFTP
    • Add support for PEM encrypted private keys (Fabian Möller)
    • Add option to force the usage of an ssh-agent (Fabian Möller)
    • Perform environment variable expansion on key-file (Fabian Möller)
    • Fix rmdir on Windows based servers (e.g. CrushFTP) (Nick Craig-Wood)
    • Fix rmdir deleting directory contents on some SFTP servers (Nick Craig-Wood)
    • Fix error on dangling symlinks (Nick Craig-Wood)
  • Swift
    • Add --swift-no-chunk to disable segmented uploads in rcat/mount (Nick Craig-Wood)
    • Introduce application credential auth support (kayrus)
    • Fix memory usage by slimming Object (Nick Craig-Wood)
    • Fix extra requests on upload (Nick Craig-Wood)
    • Fix reauth on big files (Nick Craig-Wood)
  • Union
    • Fix poll-interval not working (Nick Craig-Wood)
  • WebDAV
    • Support About which means rclone mount will show the correct disk size (Nick Craig-Wood)
    • Support MD5 and SHA1 hashes with Owncloud and Nextcloud (Nick Craig-Wood)
    • Fail soft on time parsing errors (Nick Craig-Wood)
    • Fix infinite loop on failed directory creation (Nick Craig-Wood)
    • Fix identification of directories for Bitrix Site Manager (Nick Craig-Wood)
    • Fix upload of 0 length files on some servers (Nick Craig-Wood)
    • Fix if MKCOL fails with 423 Locked assume the directory exists (Nick Craig-Wood)

v1.45 - 2018-11-24

  • New backends
    • The Yandex backend was re-written - see below for details (Sebastian Bünger)
  • New commands
    • rcd: New command just to serve the remote control API (Nick Craig-Wood)
  • New Features
    • The remote control API (rc) was greatly expanded to allow full control over rclone (Nick Craig-Wood)
      • sensitive operations require authorization or the --rc-no-auth flag
      • config/* operations to configure rclone
      • options/* for reading/setting command line flags
      • operations/* for all low level operations, e.g. copy file, list directory
      • sync/* for sync, copy and move
      • --rc-files flag to serve files on the rc http server
        • this is for building web native GUIs for rclone
      • Optionally serving objects on the rc http server
      • Ensure rclone fails to start up if the --rc port is in use already
      • See the rc docs for more info
    • sync/copy/move
      • Make --files-from only read the objects specified and don't scan directories (Nick Craig-Wood)
        • This is a huge speed improvement for destinations with lots of files
    • filter: Add --ignore-case flag (Nick Craig-Wood)
    • ncdu: Add remove function ('d' key) (Henning Surmeier)
    • rc command
      • Add --json flag for structured JSON input (Nick Craig-Wood)
      • Add --user and --pass flags and interpret --rc-user, --rc-pass, --rc-addr (Nick Craig-Wood)
    • build
      • Require go1.8 or later for compilation (Nick Craig-Wood)
      • Enable softfloat on MIPS arch (Scott Edlund)
      • Integration test framework revamped with a better report and better retries (Nick Craig-Wood)
  • Bug Fixes
    • cmd: Make --progress update the stats correctly at the end (Nick Craig-Wood)
    • config: Create config directory on save if it is missing (Nick Craig-Wood)
    • dedupe: Check for existing filename before renaming a dupe file (ssaqua)
    • move: Don't create directories with --dry-run (Nick Craig-Wood)
    • operations: Fix Purge and Rmdirs when dir is not the root (Nick Craig-Wood)
    • serve http/webdav/restic: Ensure rclone exits if the port is in use (Nick Craig-Wood)
  • Mount
    • Make --volname work for Windows and macOS (Nick Craig-Wood)
  • Azure Blob
    • Avoid context deadline exceeded error by setting a large TryTimeout value (brused27)
    • Fix erroneous Rmdir error "directory not empty" (Nick Craig-Wood)
    • Wait for up to 60s to create a just deleted container (Nick Craig-Wood)
  • Dropbox
    • Add dropbox impersonate support (Jake Coggiano)
  • Jottacloud
    • Fix bug in --fast-list handing of empty folders (albertony)
  • Opendrive
    • Fix transfer of files with + and & in (Nick Craig-Wood)
    • Fix retries of upload chunks (Nick Craig-Wood)
  • S3
    • Set ACL for server-side copies to that provided by the user (Nick Craig-Wood)
    • Fix role_arn, credential_source, ... (Erik Swanson)
    • Add config info for Wasabi's US-West endpoint (Henry Ptasinski)
  • SFTP
    • Ensure file hash checking is really disabled (Jon Fautley)
  • Swift
    • Add pacer for retries to make swift more reliable (Nick Craig-Wood)
  • WebDAV
    • Add Content-Type to PUT requests (Nick Craig-Wood)
    • Fix config parsing so --webdav-user and --webdav-pass flags work (Nick Craig-Wood)
    • Add RFC3339 date format (Ralf Hemberger)
  • Yandex
    • The yandex backend was re-written (Sebastian Bünger)
      • This implements low level retries (Sebastian Bünger)
      • Copy, Move, DirMove, PublicLink and About optional interfaces (Sebastian Bünger)
      • Improved general error handling (Sebastian Bünger)
      • Removed ListR for now due to inconsistent behaviour (Sebastian Bünger)

v1.44 - 2018-10-15

  • New commands
    • serve ftp: Add ftp server (Antoine GIRARD)
    • settier: perform storage tier changes on supported remotes (sandeepkru)
  • New Features
    • Reworked command line help
      • Make default help less verbose (Nick Craig-Wood)
      • Split flags up into global and backend flags (Nick Craig-Wood)
      • Implement specialised help for flags and backends (Nick Craig-Wood)
      • Show URL of backend help page when starting config (Nick Craig-Wood)
    • stats: Long names now split in center (Joanna Marek)
    • Add --log-format flag for more control over log output (dcpu)
    • rc: Add support for OPTIONS and basic CORS (frenos)
    • stats: show FatalErrors and NoRetryErrors in stats (Cédric Connes)
  • Bug Fixes
    • Fix -P not ending with a new line (Nick Craig-Wood)
    • config: don't create default config dir when user supplies --config (albertony)
    • Don't print non-ASCII characters with --progress on windows (Nick Craig-Wood)
    • Correct logs for excluded items (ssaqua)
  • Mount
    • Remove EXPERIMENTAL tags (Nick Craig-Wood)
  • VFS
    • Fix race condition detected by serve ftp tests (Nick Craig-Wood)
    • Add vfs/poll-interval rc command (Fabian Möller)
    • Enable rename for nearly all remotes using server-side Move or Copy (Nick Craig-Wood)
    • Reduce directory cache cleared by poll-interval (Fabian Möller)
    • Remove EXPERIMENTAL tags (Nick Craig-Wood)
  • Local
    • Skip bad symlinks in dir listing with -L enabled (Cédric Connes)
    • Preallocate files on Windows to reduce fragmentation (Nick Craig-Wood)
    • Preallocate files on linux with fallocate(2) (Nick Craig-Wood)
  • Cache
    • Add cache/fetch rc function (Fabian Möller)
    • Fix worker scale down (Fabian Möller)
    • Improve performance by not sending info requests for cached chunks (dcpu)
    • Fix error return value of cache/fetch rc method (Fabian Möller)
    • Documentation fix for cache-chunk-total-size (Anagh Kumar Baranwal)
    • Preserve leading / in wrapped remote path (Fabian Möller)
    • Add plex_insecure option to skip certificate validation (Fabian Möller)
    • Remove entries that no longer exist in the source (dcpu)
  • Crypt
    • Preserve leading / in wrapped remote path (Fabian Möller)
  • Alias
    • Fix handling of Windows network paths (Nick Craig-Wood)
  • Azure Blob
    • Add --azureblob-list-chunk parameter (Santiago Rodríguez)
    • Implemented settier command support on azureblob remote. (sandeepkru)
    • Work around SDK bug which causes errors for chunk-sized files (Nick Craig-Wood)
  • Box
    • Implement link sharing. (Sebastian Bünger)
  • Drive
    • Add --drive-import-formats - google docs can now be imported (Fabian Möller)
      • Rewrite mime type and extension handling (Fabian Möller)
      • Add document links (Fabian Möller)
      • Add support for multipart document extensions (Fabian Möller)
      • Add support for apps-script to json export (Fabian Möller)
      • Fix escaped chars in documents during list (Fabian Möller)
    • Add --drive-v2-download-min-size a workaround for slow downloads (Fabian Möller)
    • Improve directory notifications in ChangeNotify (Fabian Möller)
    • When listing team drives in config, continue on failure (Nick Craig-Wood)
  • FTP
    • Add a small pause after failed upload before deleting file (Nick Craig-Wood)
  • Google Cloud Storage
    • Fix service_account_file being ignored (Fabian Möller)
  • Jottacloud
    • Minor improvement in quota info (omit if unlimited) (albertony)
    • Add --fast-list support (albertony)
    • Add permanent delete support: --jottacloud-hard-delete (albertony)
    • Add link sharing support (albertony)
    • Fix handling of reserved characters. (Sebastian Bünger)
    • Fix socket leak on Object.Remove (Nick Craig-Wood)
  • Onedrive
    • Rework to support Microsoft Graph (Cnly)
      • NB this will require re-authenticating the remote
    • Removed upload cutoff and always do session uploads (Oliver Heyme)
    • Use single-part upload for empty files (Cnly)
    • Fix new fields not saved when editing old config (Alex Chen)
    • Fix sometimes special chars in filenames not replaced (Alex Chen)
    • Ignore OneNote files by default (Alex Chen)
    • Add link sharing support (jackyzy823)
  • S3
    • Use custom pacer, to retry operations when reasonable (Craig Miskell)
    • Use configured server-side-encryption and storage class options when calling CopyObject() (Paul Kohout)
    • Make --s3-v2-auth flag (Nick Craig-Wood)
    • Fix v2 auth on files with spaces (Nick Craig-Wood)
  • Union
    • Implement union backend which reads from multiple backends (Felix Brucker)
    • Implement optional interfaces (Move, DirMove, Copy, etc.) (Nick Craig-Wood)
    • Fix ChangeNotify to support multiple remotes (Fabian Möller)
    • Fix --backup-dir on union backend (Nick Craig-Wood)
  • WebDAV
    • Add another time format (Nick Craig-Wood)
    • Add a small pause after failed upload before deleting file (Nick Craig-Wood)
    • Add workaround for missing mtime (buergi)
    • Sharepoint: Renew cookies after 12hrs (Henning Surmeier)
  • Yandex
    • Remove redundant nil checks (teresy)

v1.43.1 - 2018-09-07

Point release to fix hubic and azureblob backends.

  • Bug Fixes
    • ncdu: Return error instead of log.Fatal in Show (Fabian Möller)
    • cmd: Fix crash with --progress and --stats 0 (Nick Craig-Wood)
    • docs: Tidy website display (Anagh Kumar Baranwal)
  • Azure Blob:
    • Fix multi-part uploads. (sandeepkru)
  • Hubic
    • Fix uploads (Nick Craig-Wood)
    • Retry auth fetching if it fails to make hubic more reliable (Nick Craig-Wood)

v1.43 - 2018-09-01

  • New backends
    • Jottacloud (Sebastian Bünger)
  • New commands
    • copyurl: copies a URL to a remote (Denis)
  • New Features
    • Reworked config for backends (Nick Craig-Wood)
      • All backend config can now be supplied by command line, env var or config file
      • Advanced section in the config wizard for the optional items
      • A large step towards rclone backends being usable in other go software
      • Allow on the fly remotes with :backend: syntax
    • Stats revamp
      • Add --progress/-P flag to show interactive progress (Nick Craig-Wood)
      • Show the total progress of the sync in the stats (Nick Craig-Wood)
      • Add --stats-one-line flag for single line stats (Nick Craig-Wood)
    • Added weekday schedule into --bwlimit (Mateusz)
    • lsjson: Add option to show the original object IDs (Fabian Möller)
    • serve webdav: Make Content-Type without reading the file and add --etag-hash (Nick Craig-Wood)
    • build
      • Build macOS with native compiler (Nick Craig-Wood)
      • Update to use go1.11 for the build (Nick Craig-Wood)
    • rc
      • Added core/stats to return the stats (reddi1)
    • version --check: Prints the current release and beta versions (Nick Craig-Wood)
  • Bug Fixes
    • accounting
      • Fix time to completion estimates (Nick Craig-Wood)
      • Fix moving average speed for file stats (Nick Craig-Wood)
    • config: Fix error reading password from piped input (Nick Craig-Wood)
    • move: Fix --delete-empty-src-dirs flag to delete all empty dirs on move (ishuah)
  • Mount
    • Implement --daemon-timeout flag for OSXFUSE (Nick Craig-Wood)
    • Fix mount --daemon not working with encrypted config (Alex Chen)
    • Clip the number of blocks to 2^32-1 on macOS - fixes borg backup (Nick Craig-Wood)
  • VFS
    • Enable vfs-read-chunk-size by default (Fabian Möller)
    • Add the vfs/refresh rc command (Fabian Möller)
    • Add non recursive mode to vfs/refresh rc command (Fabian Möller)
    • Try to seek buffer on read only files (Fabian Möller)
  • Local
    • Fix crash when deprecated --local-no-unicode-normalization is supplied (Nick Craig-Wood)
    • Fix mkdir error when trying to copy files to the root of a drive on windows (Nick Craig-Wood)
  • Cache
    • Fix nil pointer deref when using lsjson on cached directory (Nick Craig-Wood)
    • Fix nil pointer deref for occasional crash on playback (Nick Craig-Wood)
  • Crypt
    • Fix accounting when checking hashes on upload (Nick Craig-Wood)
  • Amazon Cloud Drive
    • Make very clear in the docs that rclone has no ACD keys (Nick Craig-Wood)
  • Azure Blob
    • Add connection string and SAS URL auth (Nick Craig-Wood)
    • List the container to see if it exists (Nick Craig-Wood)
    • Port new Azure Blob Storage SDK (sandeepkru)
    • Added blob tier, tier between Hot, Cool and Archive. (sandeepkru)
    • Remove leading / from paths (Nick Craig-Wood)
  • B2
    • Support Application Keys (Nick Craig-Wood)
    • Remove leading / from paths (Nick Craig-Wood)
  • Box
    • Fix upload of > 2GB files on 32 bit platforms (Nick Craig-Wood)
    • Make --box-commit-retries flag defaulting to 100 to fix large uploads (Nick Craig-Wood)
  • Drive
    • Add --drive-keep-revision-forever flag (lewapm)
    • Handle gdocs when filtering file names in list (Fabian Möller)
    • Support using --fast-list for large speedups (Fabian Möller)
  • FTP
    • Fix Put mkParentDir failed: 521 for BunnyCDN (Nick Craig-Wood)
  • Google Cloud Storage
    • Fix index out of range error with --fast-list (Nick Craig-Wood)
  • Jottacloud
    • Fix MD5 error check (Oliver Heyme)
    • Handle empty time values (Martin Polden)
    • Calculate missing MD5s (Oliver Heyme)
    • Docs, fixes and tests for MD5 calculation (Nick Craig-Wood)
    • Add optional MimeTyper interface. (Sebastian Bünger)
    • Implement optional About interface (for df support). (Sebastian Bünger)
  • Mega
    • Wait for events instead of arbitrary sleeping (Nick Craig-Wood)
    • Add --mega-hard-delete flag (Nick Craig-Wood)
    • Fix failed logins with upper case chars in email (Nick Craig-Wood)
  • Onedrive
    • Shared folder support (Yoni Jah)
    • Implement DirMove (Cnly)
    • Fix rmdir sometimes deleting directories with contents (Nick Craig-Wood)
  • Pcloud
    • Delete half uploaded files on upload error (Nick Craig-Wood)
  • Qingstor
    • Remove leading / from paths (Nick Craig-Wood)
  • S3
    • Fix index out of range error with --fast-list (Nick Craig-Wood)
    • Add --s3-force-path-style (Nick Craig-Wood)
    • Add support for KMS Key ID (bsteiss)
    • Remove leading / from paths (Nick Craig-Wood)
  • Swift
    • Add storage_policy (Ruben Vandamme)
    • Make it so just storage_url or auth_token can be overridden (Nick Craig-Wood)
    • Fix server-side copy bug for unusual file names (Nick Craig-Wood)
    • Remove leading / from paths (Nick Craig-Wood)
  • WebDAV
    • Ensure we call MKCOL with a URL with a trailing / for QNAP interop (Nick Craig-Wood)
    • If root ends with / then don't check if it is a file (Nick Craig-Wood)
    • Don't accept redirects when reading metadata (Nick Craig-Wood)
    • Add bearer token (Macaroon) support for dCache (Nick Craig-Wood)
    • Document dCache and Macaroons (Onno Zweers)
    • Sharepoint recursion with different depth (Henning)
    • Attempt to remove failed uploads (Nick Craig-Wood)
  • Yandex
    • Fix listing/deleting files in the root (Nick Craig-Wood)

v1.42 - 2018-06-16

  • New backends
    • OpenDrive (Oliver Heyme, Jakub Karlicek, ncw)
  • New commands
    • deletefile command (Filip Bartodziej)
  • New Features
    • copy, move: Copy single files directly, don't use --files-from work-around
      • this makes them much more efficient
    • Implement --max-transfer flag to quit transferring at a limit
      • make exit code 8 for --max-transfer exceeded
    • copy: copy empty source directories to destination (Ishuah Kariuki)
    • check: Add --one-way flag (Kasper Byrdal Nielsen)
    • Add siginfo handler for macOS for ctrl-T stats (kubatasiemski)
    • rc
      • add core/gc to run a garbage collection on demand
      • enable go profiling by default on the --rc port
      • return error from remote on failure
    • lsf
      • Add --absolute flag to add a leading / onto path names
      • Add --csv flag for compliant CSV output
      • Add 'm' format specifier to show the MimeType
      • Implement 'i' format for showing object ID
    • lsjson
      • Add MimeType to the output
      • Add ID field to output to show Object ID
    • Add --retries-sleep flag (Benjamin Joseph Dag)
    • Oauth tidy up web page and error handling (Henning Surmeier)
  • Bug Fixes
    • Password prompt output with --log-file fixed for unix (Filip Bartodziej)
    • Calculate ModifyWindow each time on the fly to fix various problems (Stefan Breunig)
  • Mount
    • Only print "File.rename error" if there actually is an error (Stefan Breunig)
    • Delay rename if file has open writers instead of failing outright (Stefan Breunig)
    • Ensure atexit gets run on interrupt
    • macOS enhancements
      • Make --noappledouble --noapplexattr
      • Add --volname flag and remove special chars from it
      • Make Get/List/Set/Remove xattr return ENOSYS for efficiency
      • Make --daemon work for macOS without CGO
  • VFS
    • Add --vfs-read-chunk-size and --vfs-read-chunk-size-limit (Fabian Möller)
    • Fix ChangeNotify for new or changed folders (Fabian Möller)
  • Local
    • Fix symlink/junction point directory handling under Windows
      • NB you will need to add -L to your command line to copy files with reparse points
  • Cache
    • Add non cached dirs on notifications (Remus Bunduc)
    • Allow root to be expired from rc (Remus Bunduc)
    • Clean remaining empty folders from temp upload path (Remus Bunduc)
    • Cache lists using batch writes (Remus Bunduc)
    • Use secure websockets for HTTPS Plex addresses (John Clayton)
    • Reconnect plex websocket on failures (Remus Bunduc)
    • Fix panic when running without plex configs (Remus Bunduc)
    • Fix root folder caching (Remus Bunduc)
  • Crypt
    • Check the encrypted hash of files when uploading for extra data security
  • Dropbox
    • Make Dropbox for business folders accessible using an initial / in the path
  • Google Cloud Storage
    • Low level retry all operations if necessary
  • Google Drive
    • Add --drive-acknowledge-abuse to download flagged files
    • Add --drive-alternate-export to fix large doc export
    • Don't attempt to choose Team Drives when using rclone config create
    • Fix change list polling with team drives
    • Fix ChangeNotify for folders (Fabian Möller)
    • Fix about (and df on a mount) for team drives
  • Onedrive
    • Errorhandler for onedrive for business requests (Henning Surmeier)
  • S3
    • Adjust upload concurrency with --s3-upload-concurrency (themylogin)
    • Fix --s3-chunk-size which was always using the minimum
  • SFTP
    • Add --ssh-path-override flag (Piotr Oleszczyk)
    • Fix slow downloads for long latency connections
  • Webdav
    • Add workarounds for biz.mail.ru
    • Ignore Reason-Phrase in status line to fix 4shared (Rodrigo)
    • Better error message generation

v1.41 - 2018-04-28

  • New backends
    • Mega support added
    • Webdav now supports SharePoint cookie authentication (hensur)
  • New commands
    • link: create public link to files and folders (Stefan Breunig)
    • about: gets quota info from a remote (a-roussos, ncw)
    • hashsum: a generic tool for any hash to produce md5sum like output
  • New Features
    • lsd: Add -R flag and fix and update docs for all ls commands
    • ncdu: added a "refresh" key - CTRL-L (Keith Goldfarb)
    • serve restic: Add append-only mode (Steve Kriss)
    • serve restic: Disallow overwriting files in append-only mode (Alexander Neumann)
    • serve restic: Print actual listener address (Matt Holt)
    • size: Add --json flag (Matthew Holt)
    • sync: implement --ignore-errors (Mateusz Pabian)
    • dedupe: Add dedupe largest functionality (Richard Yang)
    • fs: Extend SizeSuffix to include TB and PB for rclone about
    • fs: add --dump goroutines and --dump openfiles for debugging
    • rc: implement core/memstats to print internal memory usage info
    • rc: new call rc/pid (Michael P. Dubner)
  • Compile
    • Drop support for go1.6
  • Release
    • Fix make tarball (Chih-Hsuan Yen)
  • Bug Fixes
    • filter: fix --min-age and --max-age together check
    • fs: limit MaxIdleConns and MaxIdleConnsPerHost in transport
    • lsd,lsf: make sure all times we output are in local time
    • rc: fix setting bwlimit to unlimited
    • rc: take note of the --rc-addr flag too as per the docs
  • Mount
    • Use About to return the correct disk total/used/free (e.g. in df)
    • Set --attr-timeout default to 1s - fixes:
      • rclone using too much memory
      • rclone not serving files to samba
      • excessive time listing directories
    • Fix df -i (upstream fix)
  • VFS
    • Filter files . and .. from directory listing
    • Only make the VFS cache if --vfs-cache-mode > Off
  • Local
    • Add --local-no-check-updated to disable updated file checks
    • Retry remove on Windows sharing violation error
  • Cache
    • Flush the memory cache after close
    • Purge file data on notification
    • Always forget parent dir for notifications
    • Integrate with Plex websocket
    • Add rc cache/stats (seuffert)
    • Add info log on notification
  • Box
    • Fix failure reading large directories - parse file/directory size as float
  • Dropbox
    • Fix crypt+obfuscate on dropbox
    • Fix repeatedly uploading the same files
  • FTP
    • Work around strange response from box FTP server
    • More workarounds for FTP servers to fix mkParentDir error
    • Fix no error on listing nonexistent directory
  • Google Cloud Storage
    • Add service_account_credentials (Matt Holt)
    • Detect bucket presence by listing it - minimises permissions needed
    • Ignore zero length directory markers
  • Google Drive
    • Add service_account_credentials (Matt Holt)
    • Fix directory move leaving a hardlinked directory behind
    • Return proper google errors when Opening files
    • When initialized with a filepath, optional features used incorrect root path (Stefan Breunig)
  • HTTP
    • Fix sync for servers which don't return Content-Length in HEAD
  • Onedrive
    • Add QuickXorHash support for OneDrive for business
    • Fix socket leak in multipart session upload
  • S3
    • Look in S3 named profile files for credentials
    • Add --s3-disable-checksum to disable checksum uploading (Chris Redekop)
    • Hierarchical configuration support (Giri Badanahatti)
    • Add in config for all the supported S3 providers
    • Add One Zone Infrequent Access storage class (Craig Rachel)
    • Add --use-server-modtime support (Peter Baumgartner)
    • Add --s3-chunk-size option to control multipart uploads
    • Ignore zero length directory markers
  • SFTP
    • Update docs to match code, fix typos and clarify disable_hashcheck prompt (Michael G. Noll)
    • Update docs with Synology quirks
    • Fail soft with a debug on hash failure
  • Swift
    • Add --use-server-modtime support (Peter Baumgartner)
  • Webdav
    • Support SharePoint cookie authentication (hensur)
    • Strip leading and trailing / off root

v1.40 - 2018-03-19

  • New backends
    • Alias backend to create aliases for existing remote names (Fabian Möller)
  • New commands
    • lsf: list for parsing purposes (Jakub Tasiemski)
      • by default this is a simple non recursive list of files and directories
      • it can be configured to add more info in an easy to parse way
    • serve restic: for serving a remote as a Restic REST endpoint
      • This enables restic to use any backends that rclone can access
      • Thanks Alexander Neumann for help, patches and review
    • rc: enable the remote control of a running rclone
      • The running rclone must be started with --rc and related flags.
      • Currently there is support for bwlimit, and flushing for mount and cache.
  • New Features
    • --max-delete flag to add a delete threshold (Bjørn Erik Pedersen)
    • All backends now support RangeOption for ranged Open
      • cat: Use RangeOption for limited fetches to make more efficient
      • cryptcheck: make reading of nonce more efficient with RangeOption
    • serve http/webdav/restic
      • support SSL/TLS
      • add --user --pass and --htpasswd for authentication
    • copy/move: detect file size change during copy/move and abort transfer (ishuah)
    • cryptdecode: added option to return encrypted file names. (ishuah)
    • lsjson: add --encrypted to show encrypted name (Jakub Tasiemski)
    • Add --stats-file-name-length to specify the printed file name length for stats (Will Gunn)
  • Compile
    • Code base was shuffled and factored
      • backends moved into a backend directory
      • large packages split up
      • See the CONTRIBUTING.md doc for info as to what lives where now
    • Update to using go1.10 as the default go version
    • Implement daily full integration tests
  • Release
    • Include a source tarball and sign it and the binaries
    • Sign the git tags as part of the release process
    • Add .deb and .rpm packages as part of the build
    • Make a beta release for all branches on the main repo (but not pull requests)
  • Bug Fixes
    • config: fixes errors on nonexistent config by loading config file only on first access
    • config: retry saving the config after failure (Mateusz)
    • sync: when using --backup-dir don't delete files if we can't set their modtime
      • this fixes odd behaviour with Dropbox and --backup-dir
    • fshttp: fix idle timeouts for HTTP connections
    • serve http: fix serving files with : in - fixes
    • Fix --exclude-if-present to ignore directories which it doesn't have permission for (Iakov Davydov)
    • Make accounting work properly with crypt and b2
    • remove --no-traverse flag because it is obsolete
  • Mount
    • Add --attr-timeout flag to control attribute caching in kernel
      • this now defaults to 0 which is correct but less efficient
      • see the mount docs for more info
    • Add --daemon flag to allow mount to run in the background (ishuah)
    • Fix: Return ENOSYS rather than EIO on attempted link
      • This fixes FileZilla accessing an rclone mount served over sftp.
    • Fix setting modtime twice
    • Mount tests now run on CI for Linux (mount & cmount)/Mac/Windows
    • Many bugs fixed in the VFS layer - see below
  • VFS
    • Many fixes for --vfs-cache-mode writes and above
      • Update cached copy if we know it has changed (fixes stale data)
      • Clean path names before using them in the cache
      • Disable cache cleaner if --vfs-cache-poll-interval=0
      • Fill and clean the cache immediately on startup
    • Fix Windows opening every file when it stats the file
    • Fix applying modtime for an open Write Handle
    • Fix creation of files when truncating
    • Write 0 bytes when flushing unwritten handles to avoid race conditions in FUSE
    • Downgrade "poll-interval is not supported" message to Info
    • Make OpenFile and friends return EINVAL if O_RDONLY and O_TRUNC
  • Local
    • Downgrade "invalid cross-device link: trying copy" to debug
    • Make DirMove return fs.ErrorCantDirMove to allow fallback to Copy for cross device
    • Fix race conditions updating the hashes
  • Cache
    • Add support for polling - cache will update when remote changes on supported backends
    • Reduce log level for Plex api
    • Fix dir cache issue
    • Implement --cache-db-wait-time flag
    • Improve efficiency with RangeOption and RangeSeek
    • Fix dirmove with temp fs enabled
    • Notify vfs when using temp fs
    • Offline uploading
    • Remote control support for path flushing
  • Amazon cloud drive
    • Rclone no longer has any working keys - disable integration tests
    • Implement DirChangeNotify to notify cache/vfs/mount of changes
  • Azureblob
    • Don't check for bucket/container presence if listing was OK
      • this makes rclone do one less request per invocation
    • Improve accounting for chunked uploads
  • Backblaze B2
    • Don't check for bucket/container presence if listing was OK
      • this makes rclone do one less request per invocation
  • Box
    • Improve accounting for chunked uploads
  • Dropbox
    • Fix custom oauth client parameters
  • Google Cloud Storage
    • Don't check for bucket/container presence if listing was OK
      • this makes rclone do one less request per invocation
  • Google Drive
    • Migrate to api v3 (Fabian Möller)
    • Add scope configuration and root folder selection
    • Add --drive-impersonate for service accounts
      • thanks to everyone who tested, explored and contributed docs
    • Add --drive-use-created-date to use created date as modified date (nbuchanan)
    • Request the export formats only when required
      • This makes rclone quicker when there are no google docs
    • Fix finding paths with latin1 chars (a workaround for a drive bug)
    • Fix copying of a single Google doc file
    • Fix --drive-auth-owner-only to look in all directories
  • HTTP
    • Fix handling of directories with & in
  • Onedrive
    • Removed upload cutoff and always do session uploads
      • this stops the creation of multiple versions on business onedrive
    • Overwrite object size value with real size when reading file. (Victor)
      • this fixes oddities when onedrive misreports the size of images
  • Pcloud
    • Remove unused chunked upload flag and code
  • Qingstor
    • Don't check for bucket/container presence if listing was OK
      • this makes rclone do one less request per invocation
  • S3
    • Support hashes for multipart files (Chris Redekop)
    • Initial support for IBM COS (S3) (Giri Badanahatti)
    • Update docs to discourage use of v2 auth with CEPH and others
    • Don't check for bucket/container presence if listing was OK
      • this makes rclone do one less request per invocation
    • Fix server-side copy and set modtime on files with + in
  • SFTP
    • Add option to disable remote hash check command execution (Jon Fautley)
    • Add --sftp-ask-password flag to prompt for password when needed (Leo R. Lundgren)
    • Add set_modtime configuration option
    • Fix following of symlinks
    • Fix reading config file outside of Fs setup
    • Fix reading $USER in username fallback not $HOME
    • Fix running under crontab - Use correct OS way of reading username
  • Swift
    • Fix refresh of authentication token
      • in v1.39 a bug was introduced which ignored new tokens - this fixes it
    • Fix extra HEAD transaction when uploading a new file
    • Don't check for bucket/container presence if listing was OK
      • this makes rclone do one less request per invocation
  • Webdav
    • Add new time formats to support mydrive.ch and others

v1.39 - 2017-12-23

  • New backends
    • WebDAV
      • tested with nextcloud, owncloud, put.io and others!
    • Pcloud
    • cache - wraps a cache around other backends (Remus Bunduc)
      • useful in combination with mount
      • NB this feature is in beta so use with care
  • New commands
    • serve command with subcommands:
      • serve webdav: this implements a webdav server for any rclone remote.
      • serve http: command to serve a remote over HTTP
    • config: add sub commands for full config file management
      • create/delete/dump/edit/file/password/providers/show/update
    • touch: to create or update the timestamp of a file (Jakub Tasiemski)
  • New Features
    • curl install for rclone (Filip Bartodziej)
    • --stats now shows percentage, size, rate and ETA in condensed form (Ishuah Kariuki)
    • --exclude-if-present to exclude a directory if a file is present (Iakov Davydov)
    • rmdirs: add --leave-root flag (lewapm)
    • move: add --delete-empty-src-dirs flag to remove dirs after move (Ishuah Kariuki)
    • Add --dump flag, introduce --dump requests, responses and remove --dump-auth, --dump-filters
      • Obscure X-Auth-Token: from headers when dumping too
    • Document and implement exit codes for different failure modes (Ishuah Kariuki)
  • Compile
  • Bug Fixes
    • Retry lots more different types of errors to make multipart transfers more reliable
    • Save the config before asking for a token, fixes disappearing oauth config
    • Warn the user if --include and --exclude are used together (Ernest Borowski)
    • Fix duplicate files (e.g. on Google drive) causing spurious copies
    • Allow trailing and leading whitespace for passwords (Jason Rose)
    • ncdu: fix crashes on empty directories
    • rcat: fix goroutine leak
    • moveto/copyto: Fix to allow copying to the same name
  • Mount
    • --vfs-cache mode to make writes into mounts more reliable.
      • this requires caching files on the disk (see --cache-dir)
      • As this is a new feature, use with care
    • Use sdnotify to signal systemd the mount is ready (Fabian Möller)
    • Check if directory is not empty before mounting (Ernest Borowski)
  • Local
    • Add error message for cross file system moves
    • Fix equality check for times
  • Dropbox
    • Rework multipart upload
      • buffer the chunks when uploading large files so they can be retried
      • change default chunk size to 48MB now we are buffering them in memory
      • retry every error after the first chunk is done successfully
    • Fix error when renaming directories
  • Swift
    • Fix crash on bad authentication
  • Google Drive
    • Add service account support (Tim Cooijmans)
  • S3
    • Make it work properly with Digital Ocean Spaces (Andrew Starr-Bochicchio)
    • Fix crash if a bad listing is received
    • Add support for ECS task IAM roles (David Minor)
  • Backblaze B2
    • Fix multipart upload retries
    • Fix --hard-delete to make it work 100% of the time
  • Swift
    • Allow authentication with storage URL and auth key (Giovanni Pizzi)
    • Add new fields for swift configuration to support IBM Bluemix Swift (Pierre Carlson)
    • Add OS_TENANT_ID and OS_USER_ID to config
    • Allow configs with user id instead of user name
    • Check if swift segments container exists before creating (John Leach)
    • Fix memory leak in swift transfers (upstream fix)
  • SFTP
    • Add option to enable the use of aes128-cbc cipher (Jon Fautley)
  • Amazon cloud drive
    • Fix download of large files failing with "Only one auth mechanism allowed"
  • crypt
    • Option to encrypt directory names or leave them intact
    • Implement DirChangeNotify (Fabian Möller)
  • onedrive
    • Add option to choose resourceURL during setup of OneDrive Business account if more than one is available for user

v1.38 - 2017-09-30

  • New backends
    • Azure Blob Storage (thanks Andrei Dragomir)
    • Box
    • Onedrive for Business (thanks Oliver Heyme)
    • QingStor from QingCloud (thanks wuyu)
  • New commands
    • rcat - read from standard input and stream upload
    • tree - shows a nicely formatted recursive listing
    • cryptdecode - decode encrypted file names (thanks ishuah)
    • config show - print the config file
    • config file - print the config file location
  • New Features
    • Empty directories are deleted on sync
    • dedupe - implement merging of duplicate directories
    • check and cryptcheck made more consistent and use less memory
    • cleanup for remaining remotes (thanks ishuah)
    • --immutable for ensuring that files don't change (thanks Jacob McNamee)
    • --user-agent option (thanks Alex McGrath Kraak)
    • --disable flag to disable optional features
    • --bind flag for choosing the local addr on outgoing connections
    • Support for zsh auto-completion (thanks bpicode)
    • Stop normalizing file names but do a normalized compare in sync
  • Compile
    • Update to using go1.9 as the default go version
    • Remove snapd build due to maintenance problems
  • Bug Fixes
    • Improve retriable error detection which makes multipart uploads better
    • Make check obey --ignore-size
    • Fix bwlimit toggle in conjunction with schedules (thanks cbruegg)
    • config ensures newly written config is on the same mount
  • Local
    • Revert to copy when moving file across file system boundaries
    • --skip-links to suppress symlink warnings (thanks Zhiming Wang)
  • Mount
    • Reuse rcat internals to support uploads from all remotes
  • Dropbox
    • Fix "entry doesn't belong in directory" error
    • Stop using deprecated API methods
  • Swift
    • Fix server-side copy to empty container with --fast-list
  • Google Drive
    • Change the default for --drive-use-trash to true
  • S3
    • Set session token when using STS (thanks Girish Ramakrishnan)
    • Glacier docs and error messages (thanks Jan Varho)
    • Read 1000 (not 1024) items in dir listings to fix Wasabi
  • Backblaze B2
    • Fix SHA1 mismatch when downloading files with no SHA1
    • Calculate missing hashes on the fly instead of spooling
    • --b2-hard-delete to permanently delete (not hide) files (thanks John Papandriopoulos)
  • Hubic
    • Fix creating containers - no longer have to use the default container
  • Swift
    • Optionally configure from a standard set of OpenStack environment vars
    • Add endpoint_type config
  • Google Cloud Storage
    • Fix bucket creation to work with limited permission users
  • SFTP
    • Implement connection pooling for multiple ssh connections
    • Limit new connections per second
    • Add support for MD5 and SHA1 hashes where available (thanks Christian Brüggemann)
  • HTTP
    • Fix URL encoding issues
    • Fix directories with : in
    • Fix panic with URL encoded content

v1.37 - 2017-07-22

  • New backends
    • FTP - thanks to Antonio Messina
    • HTTP - thanks to Vasiliy Tolstov
  • New commands
    • rclone ncdu - for exploring a remote with a text based user interface.
    • rclone lsjson - for listing with a machine-readable output
    • rclone dbhashsum - to show Dropbox style hashes of files (local or Dropbox)
  • New Features
    • Implement --fast-list flag
      • This allows remotes to list recursively if they can
      • This uses less transactions (important if you pay for them)
      • This may or may not be quicker
      • This will use more memory as it has to hold the listing in memory
      • --old-sync-method deprecated - the remaining uses are covered by --fast-list
      • This involved a major re-write of all the listing code
    • Add --tpslimit and --tpslimit-burst to limit transactions per second
      • this is useful in conjunction with rclone mount to limit external apps
    • Add --stats-log-level so can see --stats without -v
    • Print password prompts to stderr - Hraban Luyat
    • Warn about duplicate files when syncing
    • Oauth improvements
      • allow auth_url and token_url to be set in the config file
      • Print redirection URI if using own credentials.
    • Don't Mkdir at the start of sync to save transactions
  • Compile
    • Update build to go1.8.3
    • Require go1.6 for building rclone
    • Compile 386 builds with "GO386=387" for maximum compatibility
  • Bug Fixes
    • Fix menu selection when no remotes
    • Config saving reworked to not kill the file if disk gets full
    • Don't delete remote if name does not change while renaming
    • moveto, copyto: report transfers and checks as per move and copy
  • Local
    • Add --local-no-unicode-normalization flag - Bob Potter
  • Mount
    • Now supported on Windows using cgofuse and WinFsp - thanks to Bill Zissimopoulos for much help
    • Compare checksums on upload/download via FUSE
    • Unmount when program ends with SIGINT (Ctrl+C) or SIGTERM - Jérôme Vizcaino
    • On read only open of file, make open pending until first read
    • Make --read-only reject modify operations
    • Implement ModTime via FUSE for remotes that support it
    • Allow modTime to be changed even before all writers are closed
    • Fix panic on renames
    • Fix hang on errored upload
  • Crypt
    • Report the name:root as specified by the user
    • Add an "obfuscate" option for filename encryption - Stephen Harris
  • Amazon Drive
    • Fix initialization order for token renewer
    • Remove revoked credentials, allow oauth proxy config and update docs
  • B2
    • Reduce minimum chunk size to 5MB
  • Drive
    • Add team drive support
    • Reduce bandwidth by adding fields for partial responses - Martin Kristensen
    • Implement --drive-shared-with-me flag to view shared with me files - Danny Tsai
    • Add --drive-trashed-only to read only the files in the trash
    • Remove obsolete --drive-full-list
    • Add missing seek to start on retries of chunked uploads
    • Fix stats accounting for upload
    • Convert / in names to a unicode equivalent (／)
    • Poll for Google Drive changes when mounted
  • OneDrive
    • Fix the uploading of files with spaces
    • Fix initialization order for token renewer
    • Display speeds accurately when uploading - Yoni Jah
    • Swap to using http://localhost:53682/ as redirect URL - Michael Ledin
    • Retry on token expired error, reset upload body on retry - Yoni Jah
  • Google Cloud Storage
    • Add ability to specify location and storage class via config and command line - thanks gdm85
    • Create container if necessary on server-side copy
    • Increase directory listing chunk to 1000 to increase performance
    • Obtain a refresh token for GCS - Steven Lu
  • Yandex
    • Fix the name reported in log messages (was empty)
    • Correct error return for listing empty directory
  • Dropbox
    • Rewritten to use the v2 API
      • Now supports ModTime
        • Can only set by uploading the file again
        • If you uploaded with an old rclone, rclone may upload everything again
        • Use --size-only or --checksum to avoid this
      • Now supports the Dropbox content hashing scheme
      • Now supports low level retries
  • S3
    • Work around eventual consistency in bucket creation
    • Create container if necessary on server-side copy
    • Add us-east-2 (Ohio) and eu-west-2 (London) S3 regions - Zahiar Ahmed
  • Swift, Hubic
    • Fix zero length directory markers showing in the subdirectory listing
      • this caused lots of duplicate transfers
    • Fix paged directory listings
      • this caused duplicate directory errors
    • Create container if necessary on server-side copy
    • Increase directory listing chunk to 1000 to increase performance
    • Make sensible error if the user forgets the container
  • SFTP
    • Add support for using ssh key files
    • Fix under Windows
    • Fix ssh agent on Windows
    • Adapt to latest version of library - Igor Kharin

v1.36 - 2017-03-18

  • New Features
    • SFTP remote (Jack Schmidt)
    • Re-implement sync routine to work a directory at a time reducing memory usage
    • Logging revamped to be more inline with rsync - now much quieter
      • -v only shows transfers
      • -vv is for full debug
      • --syslog to log to syslog on capable platforms
    • Implement --backup-dir and --suffix
    • Implement --track-renames (initial implementation by Bjørn Erik Pedersen)
    • Add time-based bandwidth limits (Lukas Loesche)
    • rclone cryptcheck: checks integrity of crypt remotes
    • Allow all config file variables and options to be set from environment variables
    • Add --buffer-size parameter to control buffer size for copy
    • Make --delete-after the default
    • Add --ignore-checksum flag (fixed by Hisham Zarka)
    • rclone check: Add --download flag to check all the data, not just hashes
    • rclone cat: add --head, --tail, --offset, --count and --discard
    • rclone config: when choosing from a list, allow the value to be entered too
    • rclone config: allow rename and copy of remotes
    • rclone obscure: for generating encrypted passwords for rclone's config (T.C. Ferguson)
    • Comply with XDG Base Directory specification (Dario Giovannetti)
      • this moves the default location of the config file in a backwards compatible way
    • Release changes
      • Ubuntu snap support (Dedsec1)
      • Compile with go 1.8
      • MIPS/Linux big and little endian support
  • Bug Fixes
    • Fix copyto copying things to the wrong place if the destination dir didn't exist
    • Fix parsing of remotes in moveto and copyto
    • Fix --delete-before deleting files on copy
    • Fix --files-from with an empty file copying everything
    • Fix sync: don't update mod times if --dry-run set
    • Fix MimeType propagation
    • Fix filters to add ** rules to directory rules
  • Local
    • Implement -L, --copy-links flag to allow rclone to follow symlinks
    • Open files in write only mode so rclone can write to an rclone mount
    • Fix unnormalised unicode causing problems reading directories
    • Fix interaction between -x flag and --max-depth
  • Mount
    • Implement proper directory handling (mkdir, rmdir, renaming)
    • Make include and exclude filters apply to mount
    • Implement read and write async buffers - control with --buffer-size
    • Fix fsync on for directories
    • Fix retry on network failure when reading off crypt
  • Crypt
    • Add --crypt-show-mapping to show encrypted file mapping
    • Fix crypt writer getting stuck in a loop
      • IMPORTANT this bug had the potential to cause data corruption when
        • reading data from a network based remote and
        • writing to a crypt on Google Drive
      • Use the cryptcheck command to validate your data if you are concerned
      • If syncing two crypt remotes, sync the unencrypted remote
  • Amazon Drive
    • Fix panics on Move (rename)
    • Fix panic on token expiry
  • B2
    • Fix inconsistent listings and rclone check
    • Fix uploading empty files with go1.8
    • Constrain memory usage when doing multipart uploads
    • Fix upload url not being refreshed properly
  • Drive
    • Fix Rmdir on directories with trashed files
    • Fix "Ignoring unknown object" when downloading
    • Add --drive-list-chunk
    • Add --drive-skip-gdocs (Károly Oláh)
  • OneDrive
    • Implement Move
    • Fix Copy
      • Fix overwrite detection in Copy
      • Fix waitForJob to parse errors correctly
    • Use token renewer to stop auth errors on long uploads
    • Fix uploading empty files with go1.8
  • Google Cloud Storage
    • Fix depth 1 directory listings
  • Yandex
    • Fix single level directory listing
  • Dropbox
    • Normalise the case for single level directory listings
    • Fix depth 1 listing
  • S3
    • Added ca-central-1 region (Jon Yergatian)

v1.35 - 2017-01-02

  • New Features
    • moveto and copyto commands for choosing a destination name on copy/move
    • rmdirs command to recursively delete empty directories
    • Allow repeated --include/--exclude/--filter options
    • Only show transfer stats on commands which transfer stuff
      • show stats on any command using the --stats flag
    • Allow overlapping directories in move when server-side dir move is supported
    • Add --stats-unit option - thanks Scott McGillivray
  • Bug Fixes
    • Fix the config file being overwritten when two rclone instances are running
    • Make rclone lsd obey the filters properly
    • Fix compilation on mips
    • Fix not transferring files that don't differ in size
    • Fix panic on nil retry/fatal error
  • Mount
    • Retry reads on error - should help with reliability a lot
    • Report the modification times for directories from the remote
    • Add bandwidth accounting and limiting (fixes --bwlimit)
    • If --stats provided will show stats and which files are transferring
    • Support R/W files if truncate is set.
    • Implement statfs interface so df works
    • Note that write is now supported on Amazon Drive
    • Report number of blocks in a file - thanks Stefan Breunig
  • Crypt
    • Prevent the user pointing crypt at itself
    • Fix failed to authenticate decrypted block errors
      • these will now return the underlying unexpected EOF instead
  • Amazon Drive
    • Add support for server-side move and directory move - thanks Stefan Breunig
    • Fix nil pointer deref on size attribute
  • B2
    • Use new prefix and delimiter parameters in directory listings
      • This makes --max-depth 1 dir listings as used in mount much faster
    • Reauth the account while doing uploads too - should help with token expiry
  • Drive
    • Make DirMove more efficient and complain about moving the root
    • Create destination directory on Move()

v1.34 - 2016-11-06

  • New Features
    • Stop single file and --files-from operations iterating through the source bucket.
    • Stop removing failed upload to cloud storage remotes
    • Make ContentType be preserved for cloud to cloud copies
    • Add support to toggle bandwidth limits via SIGUSR2 - thanks Marco Paganini
    • rclone check shows count of hashes that couldn't be checked
    • rclone listremotes command
    • Support linux/arm64 build - thanks Fredrik Fornwall
    • Remove Authorization: lines from --dump-headers output
  • Bug Fixes
    • Ignore files with control characters in the names
    • Fix rclone move command
      • Delete src files which already existed in dst
      • Fix deletion of src file when dst file older
    • Fix rclone check on encrypted file systems
    • Make failed uploads not count as "Transferred"
    • Make sure high level retries show with -q
    • Use a vendor directory with godep for repeatable builds
  • rclone mount - FUSE
    • Implement FUSE mount options
      • --no-modtime, --debug-fuse, --read-only, --allow-non-empty, --allow-root, --allow-other
      • --default-permissions, --write-back-cache, --max-read-ahead, --umask, --uid, --gid
    • Add --dir-cache-time to control caching of directory entries
    • Implement seek for files opened for read (useful for video players)
      • with -no-seek flag to disable
    • Fix crash on 32 bit ARM (alignment of 64 bit counter)
    • ...and many more internal fixes and improvements!
  • Crypt
    • Don't show encrypted password in configurator to stop confusion
  • Amazon Drive
    • New wait for upload option --acd-upload-wait-per-gb
      • upload timeouts scale by file size and can be disabled
    • Add 502 Bad Gateway to list of errors we retry
    • Fix overwriting a file with a zero length file
    • Fix ACD file size warning limit - thanks Felix Bünemann
  • Local
    • Unix: implement -x/--one-file-system to stay on a single file system
      • thanks Durval Menezes and Luiz Carlos Rumbelsperger Viana
    • Windows: ignore the symlink bit on files
    • Windows: Ignore directory-based junction points
  • B2
    • Make sure each upload has at least one upload slot - fixes strange upload stats
    • Fix uploads when using crypt
    • Fix download of large files (sha1 mismatch)
    • Return error when we try to create a bucket which someone else owns
    • Update B2 docs with Data usage, and Crypt section - thanks Tomasz Mazur
  • S3
    • Command line and config file support for
      • Setting/overriding ACL - thanks Radek Šenfeld
      • Setting storage class - thanks Asko Tamm
  • Drive
    • Make exponential backoff work exactly as per Google specification
    • add .epub, .odp and .tsv as export formats.
  • Swift
    • Don't read metadata for directory marker objects

v1.33 - 2016-08-24

  • New Features
    • Implement encryption
      • data encrypted in NACL secretbox format
      • with optional file name encryption
    • New commands
      • rclone mount - implements FUSE mounting of remotes (EXPERIMENTAL)
        • works on Linux, FreeBSD and OS X (need testers for the last 2!)
      • rclone cat - outputs remote file or files to the terminal
      • rclone genautocomplete - command to make a bash completion script for rclone
    • Editing a remote using rclone config now goes through the wizard
    • Compile with go 1.7 - this fixes rclone on macOS Sierra and on 386 processors
    • Use cobra for sub commands and docs generation
  • drive
    • Document how to make your own client_id
  • s3
    • User-configurable Amazon S3 ACL (thanks Radek Šenfeld)
  • b2
    • Fix stats accounting for upload - no more jumping to 100% done
    • On cleanup delete hide marker if it is the current file
    • New B2 API endpoint (thanks Per Cederberg)
    • Set maximum backoff to 5 Minutes
  • onedrive
    • Fix URL escaping in file names - e.g. uploading files with + in them.
  • amazon cloud drive
    • Fix token expiry during large uploads
    • Work around 408 REQUEST_TIMEOUT and 504 GATEWAY_TIMEOUT errors
  • local
    • Fix filenames with invalid UTF-8 not being uploaded
    • Fix problem with some UTF-8 characters on OS X

v1.32 - 2016-07-13

  • Backblaze B2
    • Fix upload of files large files not in root

v1.31 - 2016-07-13

  • New Features
    • Reduce memory on sync by about 50%
    • Implement --no-traverse flag to stop copy traversing the destination remote.
      • This can be used to reduce memory usage down to the smallest possible.
      • Useful to copy a small number of files into a large destination folder.
    • Implement cleanup command for emptying trash / removing old versions of files
      • Currently B2 only
    • Single file handling improved
      • Now copied with --files-from
      • Automatically sets --no-traverse when copying a single file
    • Info on using installing with ansible - thanks Stefan Weichinger
    • Implement --no-update-modtime flag to stop rclone fixing the remote modified times.
  • Bug Fixes
    • Fix move command - stop it running for overlapping Fses - this was causing data loss.
  • Local
    • Fix incomplete hashes - this was causing problems for B2.
  • Amazon Drive
    • Rename Amazon Cloud Drive to Amazon Drive - no changes to config file needed.
  • Swift
    • Add support for non-default project domain - thanks Antonio Messina.
  • S3
    • Add instructions on how to use rclone with minio.
    • Add ap-northeast-2 (Seoul) and ap-south-1 (Mumbai) regions.
    • Skip setting the modified time for objects > 5GB as it isn't possible.
  • Backblaze B2
    • Add --b2-versions flag so old versions can be listed and retrieved.
    • Treat 403 errors (e.g. cap exceeded) as fatal.
    • Implement cleanup command for deleting old file versions.
    • Make error handling compliant with B2 integrations notes.
    • Fix handling of token expiry.
    • Implement --b2-test-mode to set X-Bz-Test-Mode header.
    • Set cutoff for chunked upload to 200MB as per B2 guidelines.
    • Make upload multi-threaded.
  • Dropbox
    • Don't retry 461 errors.

v1.30 - 2016-06-18

  • New Features
    • Directory listing code reworked for more features and better error reporting (thanks to Klaus Post for help). This enables
      • Directory include filtering for efficiency
      • --max-depth parameter
      • Better error reporting
      • More to come
    • Retry more errors
    • Add --ignore-size flag - for uploading images to onedrive
    • Log -v output to stdout by default
    • Display the transfer stats in more human-readable form
    • Make 0 size files specifiable with --max-size 0b
    • Add b suffix so we can specify bytes in --bwlimit, --min-size, etc.
    • Use "password:" instead of "password>" prompt - thanks Klaus Post and Leigh Klotz
  • Bug Fixes
    • Fix retry doing one too many retries
  • Local
    • Fix problems with OS X and UTF-8 characters
  • Amazon Drive
    • Check a file exists before uploading to help with 408 Conflict errors
    • Reauth on 401 errors - this has been causing a lot of problems
    • Work around spurious 403 errors
    • Restart directory listings on error
  • Google Drive
    • Check a file exists before uploading to help with duplicates
    • Fix retry of multipart uploads
  • Backblaze B2
    • Implement large file uploading
  • S3
    • Add AES256 server-side encryption for - thanks Justin R. Wilson
  • Google Cloud Storage
    • Make sure we don't use conflicting content types on upload
    • Add service account support - thanks Michal Witkowski
  • Swift
    • Add auth version parameter
    • Add domain option for openstack (v3 auth) - thanks Fabian Ruff

v1.29 - 2016-04-18

  • New Features
    • Implement -I, --ignore-times for unconditional upload
    • Improve dedupecommand
      • Now removes identical copies without asking
      • Now obeys --dry-run
      • Implement --dedupe-mode for non interactive running
        • --dedupe-mode interactive - interactive the default.
        • --dedupe-mode skip - removes identical files then skips anything left.
        • --dedupe-mode first - removes identical files then keeps the first one.
        • --dedupe-mode newest - removes identical files then keeps the newest one.
        • --dedupe-mode oldest - removes identical files then keeps the oldest one.
        • --dedupe-mode rename - removes identical files then renames the rest to be different.
  • Bug fixes
    • Make rclone check obey the --size-only flag.
    • Use "application/octet-stream" if discovered mime type is invalid.
    • Fix missing "quit" option when there are no remotes.
  • Google Drive
    • Increase default chunk size to 8 MB - increases upload speed of big files
    • Speed up directory listings and make more reliable
    • Add missing retries for Move and DirMove - increases reliability
    • Preserve mime type on file update
  • Backblaze B2
    • Enable mod time syncing
      • This means that B2 will now check modification times
      • It will upload new files to update the modification times
      • (there isn't an API to just set the mod time.)
      • If you want the old behaviour use --size-only.
    • Update API to new version
    • Fix parsing of mod time when not in metadata
  • Swift/Hubic
    • Don't return an MD5SUM for static large objects
  • S3
    • Fix uploading files bigger than 50GB

v1.28 - 2016-03-01

  • New Features
    • Configuration file encryption - thanks Klaus Post
    • Improve rclone config adding more help and making it easier to understand
    • Implement -u/--update so creation times can be used on all remotes
    • Implement --low-level-retries flag
    • Optionally disable gzip compression on downloads with --no-gzip-encoding
  • Bug fixes
    • Don't make directories if --dry-run set
    • Fix and document the move command
    • Fix redirecting stderr on unix-like OSes when using --log-file
    • Fix delete command to wait until all finished - fixes missing deletes.
  • Backblaze B2
    • Use one upload URL per go routine fixes more than one upload using auth token
    • Add pacing, retries and reauthentication - fixes token expiry problems
    • Upload without using a temporary file from local (and remotes which support SHA1)
    • Fix reading metadata for all files when it shouldn't have been
  • Drive
    • Fix listing drive documents at root
    • Disable copy and move for Google docs
  • Swift
    • Fix uploading of chunked files with non ASCII characters
    • Allow setting of storage_url in the config - thanks Xavier Lucas
  • S3
    • Allow IAM role and credentials from environment variables - thanks Brian Stengaard
    • Allow low privilege users to use S3 (check if directory exists during Mkdir) - thanks Jakub Gedeon
  • Amazon Drive
    • Retry on more things to make directory listings more reliable

v1.27 - 2016-01-31

  • New Features
    • Easier headless configuration with rclone authorize
    • Add support for multiple hash types - we now check SHA1 as well as MD5 hashes.
    • delete command which does obey the filters (unlike purge)
    • dedupe command to deduplicate a remote. Useful with Google Drive.
    • Add --ignore-existing flag to skip all files that exist on destination.
    • Add --delete-before, --delete-during, --delete-after flags.
    • Add --memprofile flag to debug memory use.
    • Warn the user about files with same name but different case
    • Make --include rules add their implicit exclude * at the end of the filter list
    • Deprecate compiling with go1.3
  • Amazon Drive
    • Fix download of files > 10 GB
    • Fix directory traversal ("Next token is expired") for large directory listings
    • Remove 409 conflict from error codes we will retry - stops very long pauses
  • Backblaze B2
    • SHA1 hashes now checked by rclone core
  • Drive
    • Add --drive-auth-owner-only to only consider files owned by the user - thanks Björn Harrtell
    • Export Google documents
  • Dropbox
    • Make file exclusion error controllable with -q
  • Swift
    • Fix upload from unprivileged user.
  • S3
    • Fix updating of mod times of files with + in.
  • Local
    • Add local file system option to disable UNC on Windows.

v1.26 - 2016-01-02

  • New Features
    • Yandex storage backend - thank you Dmitry Burdeev ("dibu")
    • Implement Backblaze B2 storage backend
    • Add --min-age and --max-age flags - thank you Adriano Aurélio Meirelles
    • Make ls/lsl/md5sum/size/check obey includes and excludes
  • Fixes
    • Fix crash in http logging
    • Upload releases to github too
  • Swift
    • Fix sync for chunked files
  • OneDrive
    • Re-enable server-side copy
    • Don't mask HTTP error codes with JSON decode error
  • S3
    • Fix corrupting Content-Type on mod time update (thanks Joseph Spurrier)

v1.25 - 2015-11-14

  • New features
    • Implement Hubic storage system
  • Fixes
    • Fix deletion of some excluded files without --delete-excluded
      • This could have deleted files unexpectedly on sync
      • Always check first with --dry-run!
  • Swift
    • Stop SetModTime losing metadata (e.g. X-Object-Manifest)
      • This could have caused data loss for files > 5GB in size
    • Use ContentType from Object to avoid lookups in listings
  • OneDrive
    • disable server-side copy as it seems to be broken at Microsoft

v1.24 - 2015-11-07

  • New features
    • Add support for Microsoft OneDrive
    • Add --no-check-certificate option to disable server certificate verification
    • Add async readahead buffer for faster transfer of big files
  • Fixes
    • Allow spaces in remotes and check remote names for validity at creation time
    • Allow '&' and disallow ':' in Windows filenames.
  • Swift
    • Ignore directory marker objects where appropriate - allows working with Hubic
    • Don't delete the container if fs wasn't at root
  • S3
    • Don't delete the bucket if fs wasn't at root
  • Google Cloud Storage
    • Don't delete the bucket if fs wasn't at root

v1.23 - 2015-10-03

  • New features
    • Implement rclone size for measuring remotes
  • Fixes
    • Fix headless config for drive and gcs
    • Tell the user they should try again if the webserver method failed
    • Improve output of --dump-headers
  • S3
    • Allow anonymous access to public buckets
  • Swift
    • Stop chunked operations logging "Failed to read info: Object Not Found"
    • Use Content-Length on uploads for extra reliability

v1.22 - 2015-09-28

  • Implement rsync like include and exclude flags
  • swift
    • Support files > 5GB - thanks Sergey Tolmachev

v1.21 - 2015-09-22

  • New features
    • Display individual transfer progress
    • Make lsl output times in localtime
  • Fixes
    • Fix allowing user to override credentials again in Drive, GCS and ACD
  • Amazon Drive
    • Implement compliant pacing scheme
  • Google Drive
    • Make directory reads concurrent for increased speed.

v1.20 - 2015-09-15

  • New features
    • Amazon Drive support
    • Oauth support redone - fix many bugs and improve usability
      • Use "golang.org/x/oauth2" as oauth library of choice
      • Improve oauth usability for smoother initial signup
      • drive, googlecloudstorage: optionally use auto config for the oauth token
    • Implement --dump-headers and --dump-bodies debug flags
    • Show multiple matched commands if abbreviation too short
    • Implement server-side move where possible
  • local
    • Always use UNC paths internally on Windows - fixes a lot of bugs
  • dropbox
    • force use of our custom transport which makes timeouts work
  • Thanks to Klaus Post for lots of help with this release

v1.19 - 2015-08-28

  • New features
    • Server side copies for s3/swift/drive/dropbox/gcs
    • Move command - uses server-side copies if it can
    • Implement --retries flag - tries 3 times by default
    • Build for plan9/amd64 and solaris/amd64 too
  • Fixes
    • Make a current version download with a fixed URL for scripting
    • Ignore rmdir in limited fs rather than throwing error
  • dropbox
    • Increase chunk size to improve upload speeds massively
    • Issue an error message when trying to upload bad file name

v1.18 - 2015-08-17

  • drive
    • Add --drive-use-trash flag so rclone trashes instead of deletes
    • Add "Forbidden to download" message for files with no downloadURL
  • dropbox
    • Remove datastore
      • This was deprecated and it caused a lot of problems
      • Modification times and MD5SUMs no longer stored
    • Fix uploading files > 2GB
  • s3
    • use official AWS SDK from github.com/aws/aws-sdk-go
    • NB will most likely require you to delete and recreate remote
    • enable multipart upload which enables files > 5GB
    • tested with Ceph / RadosGW / S3 emulation
    • many thanks to Sam Liston and Brian Haymore at the Utah Center for High Performance Computing for a Ceph test account
  • misc
    • Show errors when reading the config file
    • Do not print stats in quiet mode - thanks Leonid Shalupov
    • Add FAQ
    • Fix created directories not obeying umask
    • Linux installation instructions - thanks Shimon Doodkin

v1.17 - 2015-06-14

  • dropbox: fix case insensitivity issues - thanks Leonid Shalupov

v1.16 - 2015-06-09

  • Fix uploading big files which was causing timeouts or panics
  • Don't check md5sum after download with --size-only

v1.15 - 2015-06-06

  • Add --checksum flag to only discard transfers by MD5SUM - thanks Alex Couper
  • Implement --size-only flag to sync on size not checksum & modtime
  • Expand docs and remove duplicated information
  • Document rclone's limitations with directories
  • dropbox: update docs about case insensitivity

v1.14 - 2015-05-21

  • local: fix encoding of non utf-8 file names - fixes a duplicate file problem
  • drive: docs about rate limiting
  • google cloud storage: Fix compile after API change in "google.golang.org/api/storage/v1"

v1.13 - 2015-05-10

  • Revise documentation (especially sync)
  • Implement --timeout and --conntimeout
  • s3: ignore etags from multipart uploads which aren't md5sums

v1.12 - 2015-03-15

  • drive: Use chunked upload for files above a certain size
  • drive: add --drive-chunk-size and --drive-upload-cutoff parameters
  • drive: switch to insert from update when a failed copy deletes the upload
  • core: Log duplicate files if they are detected

v1.11 - 2015-03-04

  • swift: add region parameter
  • drive: fix crash on failed to update remote mtime
  • In remote paths, change native directory separators to /
  • Add synchronization to ls/lsl/lsd output to stop corruptions
  • Ensure all stats/log messages to go stderr
  • Add --log-file flag to log everything (including panics) to file
  • Make it possible to disable stats printing with --stats=0
  • Implement --bwlimit to limit data transfer bandwidth

v1.10 - 2015-02-12

  • s3: list an unlimited number of items
  • Fix getting stuck in the configurator

v1.09 - 2015-02-07

  • windows: Stop drive letters (e.g. C:) getting mixed up with remotes (e.g. drive:)
  • local: Fix directory separators on Windows
  • drive: fix rate limit exceeded errors

v1.08 - 2015-02-04

  • drive: fix subdirectory listing to not list entire drive
  • drive: Fix SetModTime
  • dropbox: adapt code to recent library changes

v1.07 - 2014-12-23

  • google cloud storage: fix memory leak

v1.06 - 2014-12-12

  • Fix "Couldn't find home directory" on OSX
  • swift: Add tenant parameter
  • Use new location of Google API packages

v1.05 - 2014-08-09

  • Improved tests and consequently lots of minor fixes
  • core: Fix race detected by go race detector
  • core: Fixes after running errcheck
  • drive: reset root directory on Rmdir and Purge
  • fs: Document that Purger returns error on empty directory, test and fix
  • google cloud storage: fix ListDir on subdirectory
  • google cloud storage: re-read metadata in SetModTime
  • s3: make reading metadata more reliable to work around eventual consistency problems
  • s3: strip trailing / from ListDir()
  • swift: return directories without / in ListDir

v1.04 - 2014-07-21

  • google cloud storage: Fix crash on Update

v1.03 - 2014-07-20

  • swift, s3, dropbox: fix updated files being marked as corrupted
  • Make compile with go 1.1 again

v1.02 - 2014-07-19

  • Implement Dropbox remote
  • Implement Google Cloud Storage remote
  • Verify Md5sums and Sizes after copies
  • Remove times from "ls" command - lists sizes only
  • Add add "lsl" - lists times and sizes
  • Add "md5sum" command

v1.01 - 2014-07-04

  • drive: fix transfer of big files using up lots of memory

v1.00 - 2014-07-03

  • drive: fix whole second dates

v0.99 - 2014-06-26

  • Fix --dry-run not working
  • Make compatible with go 1.1

v0.98 - 2014-05-30

  • s3: Treat missing Content-Length as 0 for some ceph installations
  • rclonetest: add file with a space in

v0.97 - 2014-05-05

  • Implement copying of single files
  • s3 & swift: support paths inside containers/buckets

v0.96 - 2014-04-24

  • drive: Fix multiple files of same name being created
  • drive: Use o.Update and fs.Put to optimise transfers
  • Add version number, -V and --version

v0.95 - 2014-03-28

  • rclone.org: website, docs and graphics
  • drive: fix path parsing

v0.94 - 2014-03-27

  • Change remote format one last time
  • GNU style flags

v0.93 - 2014-03-16

  • drive: store token in config file
  • cross compile other versions
  • set strict permissions on config file

v0.92 - 2014-03-15

  • Config fixes and --config option

v0.91 - 2014-03-15

  • Make config file

v0.90 - 2013-06-27

  • Project named rclone

v0.00 - 2012-11-18

  • Project started

Bugs and Limitations

Limitations

Directory timestamps aren't preserved on some backends

As of v1.66, rclone supports syncing directory modtimes, if the backend supports it. Some backends do not support it -- see overview for a complete list. Additionally, note that empty directories are not synced by default (this can be enabled with --create-empty-src-dirs.)

Rclone struggles with millions of files in a directory/bucket

Currently rclone loads each directory/bucket entirely into memory before using it. Since each rclone object takes 0.5k-1k of memory this can take a very long time and use a large amount of memory.

Millions of files in a directory tends to occur on bucket-based remotes (e.g. S3 buckets) since those remotes do not segregate subdirectories within the bucket.

Bucket-based remotes and folders

Bucket-based remotes (e.g. S3/GCS/Swift/B2) do not have a concept of directories. Rclone therefore cannot create directories in them which means that empty directories on a bucket-based remote will tend to disappear.

Some software creates empty keys ending in / as directory markers. Rclone doesn't do this as it potentially creates more objects and costs more. This ability may be added in the future (probably via a flag/option).

Bugs

Bugs are stored in rclone's GitHub project:

Frequently Asked Questions

Do all cloud storage systems support all rclone commands

Yes they do. All the rclone commands (e.g. sync, copy, etc.) will work on all the remote storage systems.

Can I copy the config from one machine to another

Sure! Rclone stores all of its config in a single file. If you want to find this file, run rclone config file which will tell you where it is.

See the remote setup docs for more info.

How do I configure rclone on a remote / headless box with no browser?

This has now been documented in its own remote setup page.

How can I get rid of the "Config file not found" notice?

If you see a notice like 'NOTICE: Config file "rclone.conf" not found', this means you have not configured any remotes.

If you need to configure a remote, see the config help docs.

If you are using rclone entirely with on the fly remotes, you can create an empty config file to get rid of this notice, for example:

rclone config touch

Can rclone sync directly from drive to s3

Rclone can sync between two remote cloud storage systems just fine.

Note that it effectively downloads the file and uploads it again, so the node running rclone would need to have lots of bandwidth.

The syncs would be incremental (on a file by file basis).

e.g.

rclone sync --interactive drive:Folder s3:bucket

Using rclone from multiple locations at the same time

You can use rclone from multiple places at the same time if you choose different subdirectory for the output, e.g.

Server A> rclone sync --interactive /tmp/whatever remote:ServerA
Server B> rclone sync --interactive /tmp/whatever remote:ServerB

If you sync to the same directory then you should use rclone copy otherwise the two instances of rclone may delete each other's files, e.g.

Server A> rclone copy /tmp/whatever remote:Backup
Server B> rclone copy /tmp/whatever remote:Backup

The file names you upload from Server A and Server B should be different in this case, otherwise some file systems (e.g. Drive) may make duplicates.

Why doesn't rclone support partial transfers / binary diffs like rsync?

Rclone stores each file you transfer as a native object on the remote cloud storage system. This means that you can see the files you upload as expected using alternative access methods (e.g. using the Google Drive web interface). There is a 1:1 mapping between files on your hard disk and objects created in the cloud storage system.

Cloud storage systems (at least none I've come across yet) don't support partially uploading an object. You can't take an existing object, and change some bytes in the middle of it.

It would be possible to make a sync system which stored binary diffs like rsync does, instead of whole objects, but that would break the 1:1 mapping of files on your hard disk to objects in the remote cloud storage system.

All the cloud storage systems support partial downloads of content, so it would be possible to make partial downloads work. However to make this work efficiently this would require storing a significant amount of metadata, which breaks the desired 1:1 mapping of files to objects.

Can rclone do bi-directional sync?

Yes, since rclone v1.58.0, bidirectional cloud sync is available.

Can I use rclone with an HTTP proxy?

Yes. rclone will follow the standard environment variables for proxies, similar to cURL and other programs.

In general the variables are called http_proxy (for services reached over http) and https_proxy (for services reached over https). Most public services will be using https, but you may wish to set both.

The content of the variable is protocol://server:port. The protocol value is the one used to talk to the proxy server, itself, and is commonly either http or socks5.

Slightly annoyingly, there is no standard for the name; some applications may use http_proxy but another one HTTP_PROXY. The Go libraries used by rclone will try both variations, but you may wish to set all possibilities. So, on Linux, you may end up with code similar to

export http_proxy=http://proxyserver:12345
export https_proxy=$http_proxy
export HTTP_PROXY=$http_proxy
export HTTPS_PROXY=$http_proxy

Note: If the proxy server requires a username and password, then use

export http_proxy=http://username:password@proxyserver:12345
export https_proxy=$http_proxy
export HTTP_PROXY=$http_proxy
export HTTPS_PROXY=$http_proxy

The NO_PROXY allows you to disable the proxy for specific hosts. Hosts must be comma separated, and can contain domains or parts. For instance "foo.com" also matches "bar.foo.com".

e.g.

export no_proxy=localhost,127.0.0.0/8,my.host.name
export NO_PROXY=$no_proxy

Note that the FTP backend does not support ftp_proxy yet.

You can use the command line argument --http-proxy to set the proxy, and in turn use an override in the config file if you want it set for a single backend, eg override.http_proxy = http://... in the config file.

The FTP and SFTP backends have their own http_proxy settings to support an HTTP CONNECT proxy ( --ftp-http-proxy and --sftp-http-proxy )

Rclone gives x509 SSL root certificates error

x509: failed to load system roots and no roots provided means that rclone can't find the SSL root certificates. Likely you are running rclone on a NAS with a cut-down Linux OS, or possibly on Solaris.

x509: certificate signed by unknown authority error may occur on outdated systems, where rclone can't verify the server with the SSL root certificates.

Rclone (via the Go runtime) tries to load the root certificates from these places on Linux.

"/etc/ssl/certs/ca-certificates.crt", // Debian/Ubuntu/Gentoo etc.
"/etc/pki/tls/certs/ca-bundle.crt",   // Fedora/RHEL
"/etc/ssl/ca-bundle.pem",             // OpenSUSE
"/etc/pki/tls/cacert.pem",            // OpenELEC

So doing something like this should fix the problem. It also sets the time which is important for SSL to work properly.

mkdir -p /etc/ssl/certs/
curl -o /etc/ssl/certs/ca-certificates.crt https://raw.githubusercontent.com/bagder/ca-bundle/master/ca-bundle.crt
ntpclient -s -h pool.ntp.org

The two environment variables SSL_CERT_FILE and SSL_CERT_DIR, mentioned in the x509 package, provide an additional way to provide the SSL root certificates on Unix systems other than macOS.

Note that you may need to add the --insecure option to the curl command line if it doesn't work without.

curl --insecure -o /etc/ssl/certs/ca-certificates.crt https://raw.githubusercontent.com/bagder/ca-bundle/master/ca-bundle.crt

On macOS, you can install ca-certificates with Homebrew, and specify the SSL root certificates with the --ca-cert flag.

brew install ca-certificates
find $(brew --prefix)/etc/ca-certificates -type f

Rclone gives Failed to load config file: function not implemented error

Likely this means that you are running rclone on Linux version not supported by the go runtime, ie earlier than version 2.6.23.

See the system requirements section in the go install docs for full details.

All my uploaded docx/xlsx/pptx files appear as archive/zip

This is caused by uploading these files from a Windows computer which hasn't got the Microsoft Office suite installed. The easiest way to fix is to install the Word viewer and the Microsoft Office Compatibility Pack for Word, Excel, and PowerPoint 2007 and later versions' file formats

tcp lookup some.domain.com no such host

This happens when rclone cannot resolve a domain. Please check that your DNS setup is generally working, e.g.

# both should print a long list of possible IP addresses
dig www.googleapis.com          # resolve using your default DNS
dig www.googleapis.com @8.8.8.8 # resolve with Google's DNS server

If you are using systemd-resolved (default on Arch Linux), ensure it is at version 233 or higher. Previous releases contain a bug which causes not all domains to be resolved properly.

The Go resolver decision can be influenced with the GODEBUG=netdns=... environment variable. This also allows to resolve certain issues with DNS resolution. On Windows or MacOS systems, try forcing use of the internal Go resolver by setting GODEBUG=netdns=go at runtime. On other systems (Linux, *BSD, etc) try forcing use of the system name resolver by setting GODEBUG=netdns=cgo (and recompile rclone from source with CGO enabled if necessary). See the name resolution section in the go docs.

Failed to start auth webserver on Windows

Error: config failed to refresh token: failed to start auth webserver: listen tcp 127.0.0.1:53682: bind: An attempt was made to access a socket in a way forbidden by its access permissions.
...
yyyy/mm/dd hh:mm:ss Fatal error: config failed to refresh token: failed to start auth webserver: listen tcp 127.0.0.1:53682: bind: An attempt was made to access a socket in a way forbidden by its access permissions.

This is sometimes caused by the Host Network Service causing issues with opening the port on the host.

A simple solution may be restarting the Host Network Service with eg. Powershell

Restart-Service hns

The total size reported in the stats for a sync is wrong and keeps changing

It is likely you have more than 10,000 files that need to be synced. By default, rclone only gets 10,000 files ahead in a sync so as not to use up too much memory. You can change this default with the --max-backlog flag.

Rclone is using too much memory or appears to have a memory leak

Rclone is written in Go which uses a garbage collector. The default settings for the garbage collector mean that it runs when the heap size has doubled.

However it is possible to tune the garbage collector to use less memory by setting GOGC to a lower value, say export GOGC=20. This will make the garbage collector work harder, reducing memory size at the expense of CPU usage.

The most common cause of rclone using lots of memory is a single directory with millions of files in.

Before rclone v1.70 has to load this entirely into memory as rclone objects. Each rclone object takes 0.5k-1k of memory. There is a workaround for this which involves a bit of scripting.

However with rclone v1.70 and later rclone will automatically save directory entries to disk when a directory with more than --list-cutoff (1,000,000 by default) entries is detected.

From v1.70 rclone also has the --max-buffer-memory flag which helps particularly when multi-thread transfers are using too much memory.

Rclone changes fullwidth Unicode punctuation marks in file names

For example: On a Windows system, you have a file with name Test：1.jpg, where ： is the Unicode fullwidth colon symbol. When using rclone to copy this to your Google Drive, you will notice that the file gets renamed to Test:1.jpg, where : is the regular (halfwidth) colon.

The reason for such renames is the way rclone handles different restricted filenames on different cloud storage systems. It tries to avoid ambiguous file names as much and allow moving files between many cloud storage systems transparently, by replacing invalid characters with similar looking Unicode characters when transferring to one storage system, and replacing back again when transferring to a different storage system where the original characters are supported. When the same Unicode characters are intentionally used in file names, this replacement strategy leads to unwanted renames. Read more under section caveats.

License

This is free software under the terms of the MIT license (check the COPYING file included with the source code).

Copyright (C) 2019 by Nick Craig-Wood https://www.craig-wood.com/nick/

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

Authors and contributors

Authors

Contributors

{{< rem email addresses removed from here need to be added to bin/.ignore-emails to make sure update-authors.py doesn't immediately put them back in again. >}}

Contact the rclone project

Forum

Forum for questions and general discussion:

  • https://forum.rclone.org

Business support

For business support or sponsorship enquiries please see:

  • https://rclone.com/
  • sponsorship@rclone.com

GitHub repository

The project's repository is located at:

  • https://github.com/rclone/rclone

There you can file bug reports or contribute with pull requests.

Twitter

You can also follow Nick on twitter for rclone announcements:

Email

Or if all else fails or you want to ask something private or confidential

  • info@rclone.com

Please don't email requests for help to this address - those are better directed to the forum unless you'd like to sign up for business support.

rclone-v1.71.0/MANUAL.md000066400000000000000000117034421505210326400145610ustar00rootroot00000000000000% rclone(1) User Manual % Nick Craig-Wood % Aug 22, 2025 # NAME rclone - manage files on cloud storage # SYNOPSIS ``` Usage: rclone [flags] rclone [command] Available commands: about Get quota information from the remote. authorize Remote authorization. backend Run a backend-specific command. bisync Perform bidirectional synchronization between two paths. cat Concatenates any files and sends them to stdout. check Checks the files in the source and destination match. checksum Checks the files in the destination against a SUM file. cleanup Clean up the remote if possible. completion Output completion script for a given shell. config Enter an interactive configuration session. convmv Convert file and directory names in place. copy Copy files from source to dest, skipping identical files. copyto Copy files from source to dest, skipping identical files. copyurl Copy the contents of the URL supplied content to dest:path. cryptcheck Cryptcheck checks the integrity of an encrypted remote. cryptdecode Cryptdecode returns unencrypted file names. dedupe Interactively find duplicate filenames and delete/rename them. delete Remove the files in path. deletefile Remove a single file from remote. gendocs Output markdown docs for rclone to the directory supplied. gitannex Speaks with git-annex over stdin/stdout. hashsum Produces a hashsum file for all the objects in the path. help Show help for rclone commands, flags and backends. link Generate public link to file/folder. listremotes List all the remotes in the config file and defined in environment variables. ls List the objects in the path with size and path. lsd List all directories/containers/buckets in the path. lsf List directories and objects in remote:path formatted for parsing. lsjson List directories and objects in the path in JSON format. lsl List the objects in path with modification time, size and path. md5sum Produces an md5sum file for all the objects in the path. mkdir Make the path if it doesn't already exist. mount Mount the remote as file system on a mountpoint. move Move files from source to dest. moveto Move file or directory from source to dest. ncdu Explore a remote with a text based user interface. nfsmount Mount the remote as file system on a mountpoint. obscure Obscure password for use in the rclone config file. purge Remove the path and all of its contents. rc Run a command against a running rclone. rcat Copies standard input to file on remote. rcd Run rclone listening to remote control commands only. rmdir Remove the empty directory at path. rmdirs Remove empty directories under the path. selfupdate Update the rclone binary. serve Serve a remote over a protocol. settier Changes storage class/tier of objects in remote. sha1sum Produces an sha1sum file for all the objects in the path. size Prints the total size and number of objects in remote:path. sync Make source and dest identical, modifying destination only. test Run a test command touch Create new file or change file modification time. tree List the contents of the remote in a tree like fashion. version Show the version number. Use "rclone [command] --help" for more information about a command. Use "rclone help flags" for to see the global flags. Use "rclone help backends" for a list of supported services. ``` # Rclone syncs your files to cloud storage rclone logo - [About rclone](#about) - [What can rclone do for you?](#what) - [What features does rclone have?](#features) - [What providers does rclone support?](#providers) - [Download](https://rclone.org/downloads/) - [Install](https://rclone.org/install/) - [Donate.](https://rclone.org/donate/) ## About rclone {#about} Rclone is a command-line program to manage files on cloud storage. It is a feature-rich alternative to cloud vendors' web storage interfaces. [Over 70 cloud storage products](#providers) support rclone including S3 object stores, business & consumer file storage services, as well as standard transfer protocols. Rclone has powerful cloud equivalents to the unix commands rsync, cp, mv, mount, ls, ncdu, tree, rm, and cat. Rclone's familiar syntax includes shell pipeline support, and `--dry-run` protection. It is used at the command line, in scripts or via its [API](/rc). Users call rclone *"The Swiss army knife of cloud storage"*, and *"Technology indistinguishable from magic"*. Rclone really looks after your data. It preserves timestamps and verifies checksums at all times. Transfers over limited bandwidth; intermittent connections, or subject to quota can be restarted, from the last good file transferred. You can [check](https://rclone.org/commands/rclone_check/) the integrity of your files. Where possible, rclone employs server-side transfers to minimise local bandwidth use and transfers from one provider to another without using local disk. Virtual backends wrap local and cloud file systems to apply [encryption](https://rclone.org/crypt/), [compression](https://rclone.org/compress/), [chunking](https://rclone.org/chunker/), [hashing](https://rclone.org/hasher/) and [joining](https://rclone.org/union/). Rclone [mounts](https://rclone.org/commands/rclone_mount/) any local, cloud or virtual filesystem as a disk on Windows, macOS, linux and FreeBSD, and also serves these over [SFTP](https://rclone.org/commands/rclone_serve_sftp/), [HTTP](https://rclone.org/commands/rclone_serve_http/), [WebDAV](https://rclone.org/commands/rclone_serve_webdav/), [FTP](https://rclone.org/commands/rclone_serve_ftp/) and [DLNA](https://rclone.org/commands/rclone_serve_dlna/). Rclone is mature, open-source software originally inspired by rsync and written in [Go](https://golang.org). The friendly support community is familiar with varied use cases. Official Ubuntu, Debian, Fedora, Brew and Chocolatey repos. include rclone. For the latest version [downloading from rclone.org](https://rclone.org/downloads/) is recommended. Rclone is widely used on Linux, Windows and Mac. Third-party developers create innovative backup, restore, GUI and business process solutions using the rclone command line or API. Rclone does the heavy lifting of communicating with cloud storage. ## What can rclone do for you? {#what} Rclone helps you: - Backup (and encrypt) files to cloud storage - Restore (and decrypt) files from cloud storage - Mirror cloud data to other cloud services or locally - Migrate data to the cloud, or between cloud storage vendors - Mount multiple, encrypted, cached or diverse cloud storage as a disk - Analyse and account for data held on cloud storage using [lsf](https://rclone.org/commands/rclone_lsf/), [ljson](https://rclone.org/commands/rclone_lsjson/), [size](https://rclone.org/commands/rclone_size/), [ncdu](https://rclone.org/commands/rclone_ncdu/) - [Union](https://rclone.org/union/) file systems together to present multiple local and/or cloud file systems as one ## Features {#features} - Transfers - MD5, SHA1 hashes are checked at all times for file integrity - Timestamps are preserved on files - Operations can be restarted at any time - Can be to and from network, e.g. two different cloud providers - Can use multi-threaded downloads to local disk - [Copy](https://rclone.org/commands/rclone_copy/) new or changed files to cloud storage - [Sync](https://rclone.org/commands/rclone_sync/) (one way) to make a directory identical - [Bisync](https://rclone.org/bisync/) (two way) to keep two directories in sync bidirectionally - [Move](https://rclone.org/commands/rclone_move/) files to cloud storage deleting the local after verification - [Check](https://rclone.org/commands/rclone_check/) hashes and for missing/extra files - [Mount](https://rclone.org/commands/rclone_mount/) your cloud storage as a network disk - [Serve](https://rclone.org/commands/rclone_serve/) local or remote files over [HTTP](https://rclone.org/commands/rclone_serve_http/)/[WebDav](https://rclone.org/commands/rclone_serve_webdav/)/[FTP](https://rclone.org/commands/rclone_serve_ftp/)/[SFTP](https://rclone.org/commands/rclone_serve_sftp/)/[DLNA](https://rclone.org/commands/rclone_serve_dlna/) - Experimental [Web based GUI](https://rclone.org/gui/) ## Supported providers {#providers} (There are many others, built on standard protocols such as WebDAV or S3, that work out of the box.) - 1Fichier - Akamai Netstorage - Alibaba Cloud (Aliyun) Object Storage System (OSS) - Amazon S3 - Backblaze B2 - Box - Ceph - China Mobile Ecloud Elastic Object Storage (EOS) - Arvan Cloud Object Storage (AOS) - Citrix ShareFile - Cloudflare R2 - Cloudinary - DigitalOcean Spaces - Digi Storage - Dreamhost - Dropbox - Enterprise File Fabric - Exaba - Fastmail Files - FileLu Cloud Storage - Files.com - FlashBlade - FTP - Gofile - Google Cloud Storage - Google Drive - Google Photos - HDFS - Hetzner Storage Box - HiDrive - HTTP - iCloud Drive - ImageKit - Internet Archive - Jottacloud - IBM COS S3 - IDrive e2 - IONOS Cloud - Koofr - Leviia Object Storage - Liara Object Storage - Linkbox - Linode Object Storage - Magalu - Mail.ru Cloud - Memset Memstore - MEGA - MEGA S4 - Memory - Microsoft Azure Blob Storage - Microsoft Azure Files Storage - Microsoft OneDrive - Minio - Nextcloud - Blomp Cloud Storage - OpenDrive - OpenStack Swift - Oracle Cloud Storage Swift - Oracle Object Storage - Outscale - OVHcloud Object Storage (Swift) - OVHcloud Object Storage (S3-compatible) - ownCloud - pCloud - Petabox - PikPak - Pixeldrain - premiumize.me - put.io - Proton Drive - QingStor - Qiniu Cloud Object Storage (Kodo) - Quatrix by Maytech - Rackspace Cloud Files - rsync.net - Scaleway - Seafile - Seagate Lyve Cloud - SeaweedFS - Selectel - SFTP - Sia - SMB / CIFS - StackPath - Storj - Synology - SugarSync - Tencent Cloud Object Storage (COS) - Uloz.to - Uptobox - Wasabi - WebDAV - Yandex Disk - Zoho WorkDrive - Zata - The local filesystem ## Virtual providers These backends adapt or modify other storage providers: - Alias: Rename existing remotes - Cache: Cache remotes (DEPRECATED) - Chunker: Split large files - Combine: Combine multiple remotes into a directory tree - Compress: Compress files - Crypt: Encrypt files - Hasher: Hash files - Union: Join multiple remotes to work together ## Links * [Home page](https://rclone.org/) * [GitHub project page for source and bug tracker](https://github.com/rclone/rclone) * [Rclone Forum](https://forum.rclone.org) * [Downloads](https://rclone.org/downloads/) # Install Rclone is a Go program and comes as a single binary file. ## Quickstart - [Download](https://rclone.org/downloads/) the relevant binary. - Extract the `rclone` executable, `rclone.exe` on Windows, from the archive. - Run `rclone config` to setup. See [rclone config docs](https://rclone.org/docs/) for more details. - Optionally configure [automatic execution](#autostart). See below for some expanded Linux / macOS / Windows instructions. See the [usage](https://rclone.org/docs/) docs for how to use rclone, or run `rclone -h`. Already installed rclone can be easily updated to the latest version using the [rclone selfupdate](https://rclone.org/commands/rclone_selfupdate/) command. See [the release signing docs](https://rclone.org/release_signing/) for how to verify signatures on the release. ## Script installation To install rclone on Linux/macOS/BSD systems, run: ```sh sudo -v ; curl https://rclone.org/install.sh | sudo bash ``` For beta installation, run: ```sh sudo -v ; curl https://rclone.org/install.sh | sudo bash -s beta ``` Note that this script checks the version of rclone installed first and won't re-download if not needed. ## Linux installation {#linux} ### Precompiled binary {#linux-precompiled} Fetch and unpack ```sh curl -O https://downloads.rclone.org/rclone-current-linux-amd64.zip unzip rclone-current-linux-amd64.zip cd rclone-*-linux-amd64 ``` Copy binary file ```sh sudo cp rclone /usr/bin/ sudo chown root:root /usr/bin/rclone sudo chmod 755 /usr/bin/rclone ``` Install manpage ```sh sudo mkdir -p /usr/local/share/man/man1 sudo cp rclone.1 /usr/local/share/man/man1/ sudo mandb ``` Run `rclone config` to setup. See [rclone config docs](https://rclone.org/docs/) for more details. ```sh rclone config ``` ## macOS installation {#macos} ### Installation with brew {#macos-brew} ```sh brew install rclone ``` NOTE: This version of rclone will not support `mount` any more (see [#5373](https://github.com/rclone/rclone/issues/5373)). If mounting is wanted on macOS, either install a precompiled binary or enable the relevant option when [installing from source](#source). Note that this is a third party installer not controlled by the rclone developers so it may be out of date. Its current version is as below. [![Homebrew package](https://repology.org/badge/version-for-repo/homebrew/rclone.svg)](https://repology.org/project/rclone/versions) ### Installation with MacPorts {#macos-macports} On macOS, rclone can also be installed via [MacPorts](https://www.macports.org): ```sh sudo port install rclone ``` Note that this is a third party installer not controlled by the rclone developers so it may be out of date. Its current version is as below. [![MacPorts port](https://repology.org/badge/version-for-repo/macports/rclone.svg)](https://repology.org/project/rclone/versions) More information on [macports.org](https://ports.macports.org/port/rclone/). ### Precompiled binary, using curl {#macos-precompiled} To avoid problems with macOS gatekeeper enforcing the binary to be signed and notarized it is enough to download with `curl`. Download the latest version of rclone. ```sh cd && curl -O https://downloads.rclone.org/rclone-current-osx-amd64.zip ``` Unzip the download and cd to the extracted folder. ```sh unzip -a rclone-current-osx-amd64.zip && cd rclone-*-osx-amd64 ``` Move rclone to your $PATH. You will be prompted for your password. ```sh sudo mkdir -p /usr/local/bin sudo mv rclone /usr/local/bin/ ``` (the `mkdir` command is safe to run, even if the directory already exists). Remove the leftover files. ```sh cd .. && rm -rf rclone-*-osx-amd64 rclone-current-osx-amd64.zip ``` Run `rclone config` to setup. See [rclone config docs](https://rclone.org/docs/) for more details. ```sh rclone config ``` ### Precompiled binary, using a web browser {#macos-precompiled-web} When downloading a binary with a web browser, the browser will set the macOS gatekeeper quarantine attribute. Starting from Catalina, when attempting to run `rclone`, a pop-up will appear saying: ```sh "rclone" cannot be opened because the developer cannot be verified. macOS cannot verify that this app is free from malware. ``` The simplest fix is to run ```sh xattr -d com.apple.quarantine rclone ``` ## Windows installation {#windows} ### Precompiled binary {#windows-precompiled} Fetch the correct binary for your processor type by clicking on these links. If not sure, use the first link. - [Intel/AMD - 64 Bit](https://downloads.rclone.org/rclone-current-windows-amd64.zip) - [Intel/AMD - 32 Bit](https://downloads.rclone.org/rclone-current-windows-386.zip) - [ARM - 64 Bit](https://downloads.rclone.org/rclone-current-windows-arm64.zip) Open this file in the Explorer and extract `rclone.exe`. Rclone is a portable executable so you can place it wherever is convenient. Open a CMD window (or powershell) and run the binary. Note that rclone does not launch a GUI by default, it runs in the CMD Window. - Run `rclone.exe config` to setup. See [rclone config docs](https://rclone.org/docs/) for more details. - Optionally configure [automatic execution](#autostart). If you are planning to use the [rclone mount](https://rclone.org/commands/rclone_mount/) feature then you will need to install the third party utility [WinFsp](https://winfsp.dev/) also. ### Windows package manager (Winget) {#windows-chocolatey} [Winget](https://learn.microsoft.com/en-us/windows/package-manager/) comes pre-installed with the latest versions of Windows. If not, update the [App Installer](https://www.microsoft.com/p/app-installer/9nblggh4nns1) package from the Microsoft store. To install rclone ```bat winget install Rclone.Rclone ``` To uninstall rclone ```bat winget uninstall Rclone.Rclone --force ``` ### Chocolatey package manager {#windows-chocolatey} Make sure you have [Choco](https://chocolatey.org/) installed ```bat choco search rclone choco install rclone ``` This will install rclone on your Windows machine. If you are planning to use [rclone mount](https://rclone.org/commands/rclone_mount/) then ```bat choco install winfsp ``` will install that too. Note that this is a third party installer not controlled by the rclone developers so it may be out of date. Its current version is as below. [![Chocolatey package](https://repology.org/badge/version-for-repo/chocolatey/rclone.svg)](https://repology.org/project/rclone/versions) ### Scoop package manager {#windows-scoop} Make sure you have [Scoop](https://scoop.sh/) installed ```bat scoop install rclone ``` Note that this is a third party installer not controlled by the rclone developers so it may be out of date. Its current version is as below. [![Scoop package](https://repology.org/badge/version-for-repo/scoop/rclone.svg)](https://repology.org/project/rclone/versions) ## Package manager installation {#package-manager} Many Linux, Windows, macOS and other OS distributions package and distribute rclone. The distributed versions of rclone are often quite out of date and for this reason we recommend one of the other installation methods if possible. You can get an idea of how up to date or not your OS distribution's package is here. [![Packaging status](https://repology.org/badge/vertical-allrepos/rclone.svg?columns=3)](https://repology.org/project/rclone/versions) ## Docker installation {#docker} The rclone developers maintain a [docker image for rclone](https://hub.docker.com/r/rclone/rclone). **Note:** We also now offer a paid version of rclone with enterprise-grade security and zero CVEs through our partner [SecureBuild](https://securebuild.com/blog/introducing-securebuild). If you are interested, check out their website and the [Rclone SecureBuild Image](https://securebuild.com/images/rclone). These images are built as part of the release process based on a minimal Alpine Linux. The `:latest` tag will always point to the latest stable release. You can use the `:beta` tag to get the latest build from master. You can also use version tags, e.g. `:1.49.1`, `:1.49` or `:1`. ```sh $ docker pull rclone/rclone:latest latest: Pulling from rclone/rclone Digest: sha256:0e0ced72671989bb837fea8e88578b3fc48371aa45d209663683e24cfdaa0e11 ... $ docker run --rm rclone/rclone:latest version rclone v1.49.1 - os/arch: linux/amd64 - go version: go1.12.9 ``` There are a few command line options to consider when starting an rclone Docker container from the rclone image. - You need to mount the host rclone config dir at `/config/rclone` into the Docker container. Due to the fact that rclone updates tokens inside its config file, and that the update process involves a file rename, you need to mount the whole host rclone config dir, not just the single host rclone config file. - You need to mount a host data dir at `/data` into the Docker container. - By default, the rclone binary inside a Docker container runs with UID=0 (root). As a result, all files created in a run will have UID=0. If your config and data files reside on the host with a non-root UID:GID, you need to pass these on the container start command line. - If you want to access the RC interface (either via the API or the Web UI), it is required to set the `--rc-addr` to `:5572` in order to connect to it from outside the container. An explanation about why this is necessary can be found in an old [pythonspeed.com](https://web.archive.org/web/20200808071950/https://pythonspeed.com/articles/docker-connection-refused/) article. - NOTE: Users running this container with the docker network set to `host` should probably set it to listen to localhost only, with `127.0.0.1:5572` as the value for `--rc-addr` - It is possible to use `rclone mount` inside a userspace Docker container, and expose the resulting fuse mount to the host. The exact `docker run` options to do that might vary slightly between hosts. See, e.g. the discussion in this [thread](https://github.com/moby/moby/issues/9448). You also need to mount the host `/etc/passwd` and `/etc/group` for fuse to work inside the container. Here are some commands tested on an Ubuntu 18.04.3 host: ```sh # config on host at ~/.config/rclone/rclone.conf # data on host at ~/data # add a remote interactively docker run --rm -it \ --volume ~/.config/rclone:/config/rclone \ --user $(id -u):$(id -g) \ rclone/rclone \ config # make sure the config is ok by listing the remotes docker run --rm \ --volume ~/.config/rclone:/config/rclone \ --user $(id -u):$(id -g) \ rclone/rclone \ listremotes # perform mount inside Docker container, expose result to host mkdir -p ~/data/mount docker run --rm \ --volume ~/.config/rclone:/config/rclone \ --volume ~/data:/data:shared \ --user $(id -u):$(id -g) \ --volume /etc/passwd:/etc/passwd:ro --volume /etc/group:/etc/group:ro \ --device /dev/fuse --cap-add SYS_ADMIN --security-opt apparmor:unconfined \ rclone/rclone \ mount dropbox:Photos /data/mount & ls ~/data/mount kill %1 ``` ## Snap installation {#snap} [![Get it from the Snap Store](https://snapcraft.io/static/images/badges/en/snap-store-black.svg)](https://snapcraft.io/rclone) Make sure you have [Snapd installed](https://snapcraft.io/docs/installing-snapd) ```sh sudo snap install rclone ``` Due to the strict confinement of Snap, rclone snap cannot access real `/home/$USER/.config/rclone` directory, default config path is as below. - Default config directory: - /home/$USER/snap/rclone/current/.config/rclone Note: Due to the strict confinement of Snap, `rclone mount` feature is `not` supported. If mounting is wanted, either install a precompiled binary or enable the relevant option when [installing from source](#source). Note that this is controlled by [community maintainer](https://github.com/boukendesho/rclone-snap) not the rclone developers so it may be out of date. Its current version is as below. [![rclone](https://snapcraft.io/rclone/badge.svg)](https://snapcraft.io/rclone) ## Source installation {#source} Make sure you have git and [Go](https://golang.org/) installed. Go version 1.24 or newer is required, the latest release is recommended. You can get it from your package manager, or download it from [golang.org/dl](https://golang.org/dl/). Then you can run the following: ```sh git clone https://github.com/rclone/rclone.git cd rclone go build ``` This will check out the rclone source in subfolder rclone, which you can later modify and send pull requests with. Then it will build the rclone executable in the same folder. As an initial check you can now run `./rclone version` (`.\rclone version` on Windows). Note that on macOS and Windows the [mount](https://rclone.org/commands/rclone_mount/) command will not be available unless you specify an additional build tag `cmount`. ```sh go build -tags cmount ``` This assumes you have a GCC compatible C compiler (GCC or Clang) in your PATH, as it uses [cgo](https://pkg.go.dev/cmd/cgo). But on Windows, the [cgofuse](https://github.com/winfsp/cgofuse) library that the cmount implementation is based on, also supports building [without cgo](https://github.com/golang/go/wiki/WindowsDLLs), i.e. by setting environment variable CGO_ENABLED to value 0 (static linking). This is how the official Windows release of rclone is being built, starting with version 1.59. It is still possible to build with cgo on Windows as well, by using the MinGW port of GCC, e.g. by installing it in a [MSYS2](https://www.msys2.org) distribution (make sure you install it in the classic mingw64 subsystem, the ucrt64 version is not compatible). Additionally, to build with mount on Windows, you must install the third party utility [WinFsp](https://winfsp.dev/), with the "Developer" feature selected. If building with cgo, you must also set environment variable CPATH pointing to the fuse include directory within the WinFsp installation (normally `C:\Program Files (x86)\WinFsp\inc\fuse`). You may add arguments `-ldflags -s` to omit symbol table and debug information, making the executable file smaller, and `-trimpath` to remove references to local file system paths. The official rclone releases are built with both of these. ```sh go build -trimpath -ldflags -s -tags cmount ``` If you want to customize the version string, as reported by the `rclone version` command, you can set one of the variables `fs.Version`, `fs.VersionTag` (to keep default suffix but customize the number), or `fs.VersionSuffix` (to keep default number but customize the suffix). This can be done from the build command, by adding to the `-ldflags` argument value as shown below. ```sh go build -trimpath -ldflags "-s -X github.com/rclone/rclone/fs.Version=v9.9.9-test" -tags cmount ``` On Windows, the official executables also have the version information, as well as a file icon, embedded as binary resources. To get that with your own build you need to run the following command **before** the build command. It generates a Windows resource system object file, with extension .syso, e.g. `resource_windows_amd64.syso`, that will be automatically picked up by future build commands. ```sh go run bin/resource_windows.go ``` The above command will generate a resource file containing version information based on the fs.Version variable in source at the time you run the command, which means if the value of this variable changes you need to re-run the command for it to be reflected in the version information. Also, if you override this version variable in the build command as described above, you need to do that also when generating the resource file, or else it will still use the value from the source. ```sh go run bin/resource_windows.go -version v9.9.9-test ``` Instead of executing the `go build` command directly, you can run it via the Makefile. The default target changes the version suffix from "-DEV" to "-beta" followed by additional commit details, embeds version information binary resources on Windows, and copies the resulting rclone executable into your GOPATH bin folder (`$(go env GOPATH)/bin`, which corresponds to `~/go/bin/rclone` by default). ```sh make ``` To include mount command on macOS and Windows with Makefile build: ```sh make GOTAGS=cmount ``` There are other make targets that can be used for more advanced builds, such as cross-compiling for all supported os/architectures, and packaging results into release artifacts. See [Makefile](https://github.com/rclone/rclone/blob/master/Makefile) and [cross-compile.go](https://github.com/rclone/rclone/blob/master/bin/cross-compile.go) for details. Another alternative method for source installation is to download the source, build and install rclone - all in one operation, as a regular Go package. The source will be stored it in the Go module cache, and the resulting executable will be in your GOPATH bin folder (`$(go env GOPATH)/bin`, which corresponds to `~/go/bin/rclone` by default). ```sh go install github.com/rclone/rclone@latest ``` In some situations, rclone executable size might be too big for deployment in very restricted environments when all backends with large SDKs are included. To limit binary size unused backends can be commented out in `backends/all/all.go` and unused commands in `cmd/all/all.go` before building with `go build` or `make` ## Ansible installation {#ansible} This can be done with [Stefan Weichinger's ansible role](https://github.com/stefangweichinger/ansible-rclone). Instructions 1. `git clone https://github.com/stefangweichinger/ansible-rclone.git` into your local roles-directory 2. add the role to the hosts you want rclone installed to: ```yml - hosts: rclone-hosts roles: - rclone ``` ## Portable installation {#portable} As mentioned [above](https://rclone.org/install/#quickstart), rclone is single executable (`rclone`, or `rclone.exe` on Windows) that you can download as a zip archive and extract into a location of your choosing. When executing different commands, it may create files in different locations, such as a configuration file and various temporary files. By default the locations for these are according to your operating system, e.g. configuration file in your user profile directory and temporary files in the standard temporary directory, but you can customize all of them, e.g. to make a completely self-contained, portable installation. Run the [config paths](https://rclone.org/commands/rclone_config_paths/) command to see the locations that rclone will use. To override them set the corresponding options (as command-line arguments, or as [environment variables](https://rclone.org/docs/#environment-variables)): - [--config](https://rclone.org/docs/#config-string) - [--cache-dir](https://rclone.org/docs/#cache-dir-string) - [--temp-dir](https://rclone.org/docs/#temp-dir-string) ## Autostart After installing and configuring rclone, as described above, you are ready to use rclone as an interactive command line utility. If your goal is to perform *periodic* operations, such as a regular [sync](https://rclone.org/commands/rclone_sync/), you will probably want to configure your rclone command in your operating system's scheduler. If you need to expose *service*-like features, such as [remote control](https://rclone.org/rc/), [GUI](https://rclone.org/gui/), [serve](https://rclone.org/commands/rclone_serve/) or [mount](https://rclone.org/commands/rclone_mount/), you will often want an rclone command always running in the background, and configuring it to run in a service infrastructure may be a better option. Below are some alternatives on how to achieve this on different operating systems. NOTE: Before setting up autorun it is highly recommended that you have tested your command manually from a Command Prompt first. ### Autostart on Windows The most relevant alternatives for autostart on Windows are: - Run at user log on using the Startup folder - Run at user log on, at system startup or at schedule using Task Scheduler - Run at system startup using Windows service #### Running in background Rclone is a console application, so if not starting from an existing Command Prompt, e.g. when starting rclone.exe from a shortcut, it will open a Command Prompt window. When configuring rclone to run from task scheduler and windows service you are able to set it to run hidden in background. From rclone version 1.54 you can also make it run hidden from anywhere by adding option `--no-console` (it may still flash briefly when the program starts). Since rclone normally writes information and any error messages to the console, you must redirect this to a file to be able to see it. Rclone has a built-in option `--log-file` for that. Example command to run a sync in background: ```bat c:\rclone\rclone.exe sync c:\files remote:/files --no-console --log-file c:\rclone\logs\sync_files.txt ``` #### User account As mentioned in the [mount](https://rclone.org/commands/rclone_mount/) documentation, mounted drives created as Administrator are not visible to other accounts, not even the account that was elevated as Administrator. By running the mount command as the built-in `SYSTEM` user account, it will create drives accessible for everyone on the system. Both scheduled task and Windows service can be used to achieve this. NOTE: Remember that when rclone runs as the `SYSTEM` user, the user profile that it sees will not be yours. This means that if you normally run rclone with configuration file in the default location, to be able to use the same configuration when running as the system user you must explicitly tell rclone where to find it with the [`--config`](https://rclone.org/docs/#config-string) option, or else it will look in the system users profile path (`C:\Windows\System32\config\systemprofile`). To test your command manually from a Command Prompt, you can run it with the [PsExec](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) utility from Microsoft's Sysinternals suite, which takes option `-s` to execute commands as the `SYSTEM` user. #### Start from Startup folder To quickly execute an rclone command you can simply create a standard Windows Explorer shortcut for the complete rclone command you want to run. If you store this shortcut in the special "Startup" start-menu folder, Windows will automatically run it at login. To open this folder in Windows Explorer, enter path `%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup`, or `C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp` if you want the command to start for *every* user that logs in. This is the easiest approach to autostarting of rclone, but it offers no functionality to set it to run as different user, or to set conditions or actions on certain events. Setting up a scheduled task as described below will often give you better results. #### Start from Task Scheduler Task Scheduler is an administrative tool built into Windows, and it can be used to configure rclone to be started automatically in a highly configurable way, e.g. periodically on a schedule, on user log on, or at system startup. It can run be configured to run as the current user, or for a mount command that needs to be available to all users it can run as the `SYSTEM` user. For technical information, see [Task Scheduler for developers](https://docs.microsoft.com/windows/win32/taskschd/task-scheduler-start-page). #### Run as service For running rclone at system startup, you can create a Windows service that executes your rclone command, as an alternative to scheduled task configured to run at startup. ##### Mount command built-in service integration For mount commands, rclone has a built-in Windows service integration via the third-party WinFsp library it uses. Registering as a regular Windows service easy, as you just have to execute the built-in PowerShell command `New-Service` (requires administrative privileges). Example of a PowerShell command that creates a Windows service for mounting some `remote:/files` as drive letter `X:`, for *all* users (service will be running as the local system account): ```pwsh New-Service -Name Rclone -BinaryPathName 'c:\rclone\rclone.exe mount remote:/files X: --config c:\rclone\config\rclone.conf --log-file c:\rclone\logs\mount.txt' ``` The [WinFsp service infrastructure](https://github.com/billziss-gh/winfsp/wiki/WinFsp-Service-Architecture) supports incorporating services for file system implementations, such as rclone, into its own launcher service, as kind of "child services". This has the additional advantage that it also implements a network provider that integrates into Windows standard methods for managing network drives. This is currently not officially supported by Rclone, but with WinFsp version 2019.3 B2 / v1.5B2 or later it should be possible through path rewriting as described in [#3340](https://github.com/rclone/rclone/issues/3340). ##### Third-party service integration To Windows service running any rclone command, the excellent third-party utility [NSSM](http://nssm.cc), the "Non-Sucking Service Manager", can be used. It includes some advanced features such as adjusting process priority, defining process environment variables, redirect to file anything written to stdout, and customized response to different exit codes, with a GUI to configure everything from (although it can also be used from command line ). There are also several other alternatives. To mention one more, [WinSW](https://github.com/winsw/winsw), "Windows Service Wrapper", is worth checking out. It requires .NET Framework, but it is preinstalled on newer versions of Windows, and it also provides alternative standalone distributions which includes necessary runtime (.NET 5). WinSW is a command-line only utility, where you have to manually create an XML file with service configuration. This may be a drawback for some, but it can also be an advantage as it is easy to back up and reuse the configuration settings, without having go through manual steps in a GUI. One thing to note is that by default it does not restart the service on error, one have to explicit enable this in the configuration file (via the "onfailure" parameter). ### Autostart on Linux #### Start as a service To always run rclone in background, relevant for mount commands etc, you can use systemd to set up rclone as a system or user service. Running as a system service ensures that it is run at startup even if the user it is running as has no active session. Running rclone as a user service ensures that it only starts after the configured user has logged into the system. #### Run periodically from cron To run a periodic command, such as a copy/sync, you can set up a cron job. # Usage Rclone is a command line program to manage files on cloud storage. After [download](https://rclone.org/downloads/) and [install](/install), continue here to learn how to use it: Initial [configuration](#configure), what the [basic syntax](#basic-syntax) looks like, describes the various [subcommands](#subcommands), the various [options](#options), and more. ## Configure First, you'll need to configure rclone. As the object storage systems have quite complicated authentication these are kept in a config file. (See the [`--config`](#config-string) entry for how to find the config file and choose its location.) The easiest way to make the config is to run rclone with the config option: ```sh rclone config ``` See the following for detailed instructions for - [1Fichier](https://rclone.org/fichier/) - [Akamai Netstorage](https://rclone.org/netstorage/) - [Alias](https://rclone.org/alias/) - [Amazon S3](https://rclone.org/s3/) - [Backblaze B2](https://rclone.org/b2/) - [Box](https://rclone.org/box/) - [Chunker](https://rclone.org/chunker/) - transparently splits large files for other remotes - [Citrix ShareFile](https://rclone.org/sharefile/) - [Compress](https://rclone.org/compress/) - [Cloudinary](https://rclone.org/cloudinary/) - [Combine](https://rclone.org/combine/) - [Crypt](https://rclone.org/crypt/) - to encrypt other remotes - [DigitalOcean Spaces](https://rclone.org/s3/#digitalocean-spaces) - [Digi Storage](https://rclone.org/koofr/#digi-storage) - [Dropbox](https://rclone.org/dropbox/) - [Enterprise File Fabric](https://rclone.org/filefabric/) - [FileLu Cloud Storage](https://rclone.org/filelu/) - [Files.com](https://rclone.org/filescom/) - [FTP](https://rclone.org/ftp/) - [Gofile](https://rclone.org/gofile/) - [Google Cloud Storage](https://rclone.org/googlecloudstorage/) - [Google Drive](https://rclone.org/drive/) - [Google Photos](https://rclone.org/googlephotos/) - [Hasher](https://rclone.org/hasher/) - to handle checksums for other remotes - [HDFS](https://rclone.org/hdfs/) - [Hetzner Storage Box](https://rclone.org/sftp/#hetzner-storage-box) - [HiDrive](https://rclone.org/hidrive/) - [HTTP](https://rclone.org/http/) - [iCloud Drive](https://rclone.org/iclouddrive/) - [Internet Archive](https://rclone.org/internetarchive/) - [Jottacloud](https://rclone.org/jottacloud/) - [Koofr](https://rclone.org/koofr/) - [Linkbox](https://rclone.org/linkbox/) - [Mail.ru Cloud](https://rclone.org/mailru/) - [Mega](https://rclone.org/mega/) - [Memory](https://rclone.org/memory/) - [Microsoft Azure Blob Storage](https://rclone.org/azureblob/) - [Microsoft Azure Files Storage](https://rclone.org/azurefiles/) - [Microsoft OneDrive](https://rclone.org/onedrive/) - [OpenStack Swift / Rackspace Cloudfiles / Blomp Cloud Storage / Memset Memstore](https://rclone.org/swift/) - [OpenDrive](https://rclone.org/opendrive/) - [Oracle Object Storage](https://rclone.org/oracleobjectstorage/) - [Pcloud](https://rclone.org/pcloud/) - [PikPak](https://rclone.org/pikpak/) - [Pixeldrain](https://rclone.org/pixeldrain/) - [premiumize.me](https://rclone.org/premiumizeme/) - [put.io](https://rclone.org/putio/) - [Proton Drive](https://rclone.org/protondrive/) - [QingStor](https://rclone.org/qingstor/) - [Quatrix by Maytech](https://rclone.org/quatrix/) - [rsync.net](https://rclone.org/sftp/#rsync-net) - [Seafile](https://rclone.org/seafile/) - [SFTP](https://rclone.org/sftp/) - [Sia](https://rclone.org/sia/) - [SMB](https://rclone.org/smb/) - [Storj](https://rclone.org/storj/) - [SugarSync](https://rclone.org/sugarsync/) - [Union](https://rclone.org/union/) - [Uloz.to](https://rclone.org/ulozto/) - [Uptobox](https://rclone.org/uptobox/) - [WebDAV](https://rclone.org/webdav/) - [Yandex Disk](https://rclone.org/yandex/) - [Zoho WorkDrive](https://rclone.org/zoho/) - [The local filesystem](https://rclone.org/local/) ## Basic syntax Rclone syncs a directory tree from one storage system to another. Its syntax is like this ```sh rclone subcommand [options] ``` A `subcommand` is a the rclone operation required, (e.g. `sync`, `copy`, `ls`). An `option` is a single letter flag (e.g. `-v`) or a group of single letter flags (e.g. `-Pv`) or a long flag (e.g. `--progress`). No options are required. Options can come after the `subcommand` or in between parameters too or on the end, but only global options can be used before the `subcommand`. Anything after a `--` option will not be interpreted as an option so if you need to add a parameter which starts with a `-` then put a `--` on its own first, eg ```sh rclone lsf -- -directory-starting-with-dash ``` A `parameter` is usually a file path or [rclone remote](#syntax-of-remote-paths), eg `/path/to/file` or `remote:path/to/file` but it can be other things - the `subcommand` help will tell you what. Source and destination paths are specified by the name you gave the storage system in the config file then the sub path, e.g. "drive:myfolder" to look at "myfolder" in Google drive. You can define as many storage paths as you like in the config file. Please use the [`--interactive`/`-i`](#interactive) flag while learning rclone to avoid accidental data loss. ## Subcommands rclone uses a system of subcommands. For example ```sh rclone ls remote:path # lists a remote rclone copy /local/path remote:path # copies /local/path to the remote rclone sync --interactive /local/path remote:path # syncs /local/path to the remote ``` # rclone config Enter an interactive configuration session. ## Synopsis Enter an interactive configuration session where you can setup new remotes and manage existing ones. You may also set or remove a password to protect your configuration. ``` rclone config [flags] ``` ## Options ``` -h, --help help for config ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. * [rclone config create](https://rclone.org/commands/rclone_config_create/) - Create a new remote with name, type and options. * [rclone config delete](https://rclone.org/commands/rclone_config_delete/) - Delete an existing remote. * [rclone config disconnect](https://rclone.org/commands/rclone_config_disconnect/) - Disconnects user from remote * [rclone config dump](https://rclone.org/commands/rclone_config_dump/) - Dump the config file as JSON. * [rclone config edit](https://rclone.org/commands/rclone_config_edit/) - Enter an interactive configuration session. * [rclone config encryption](https://rclone.org/commands/rclone_config_encryption/) - set, remove and check the encryption for the config file * [rclone config file](https://rclone.org/commands/rclone_config_file/) - Show path of configuration file in use. * [rclone config password](https://rclone.org/commands/rclone_config_password/) - Update password in an existing remote. * [rclone config paths](https://rclone.org/commands/rclone_config_paths/) - Show paths used for configuration, cache, temp etc. * [rclone config providers](https://rclone.org/commands/rclone_config_providers/) - List in JSON format all the providers and options. * [rclone config reconnect](https://rclone.org/commands/rclone_config_reconnect/) - Re-authenticates user with remote. * [rclone config redacted](https://rclone.org/commands/rclone_config_redacted/) - Print redacted (decrypted) config file, or the redacted config for a single remote. * [rclone config show](https://rclone.org/commands/rclone_config_show/) - Print (decrypted) config file, or the config for a single remote. * [rclone config touch](https://rclone.org/commands/rclone_config_touch/) - Ensure configuration file exists. * [rclone config update](https://rclone.org/commands/rclone_config_update/) - Update options in an existing remote. * [rclone config userinfo](https://rclone.org/commands/rclone_config_userinfo/) - Prints info about logged in user of remote. # rclone copy Copy files from source to dest, skipping identical files. ## Synopsis Copy the source to the destination. Does not transfer files that are identical on source and destination, testing by size and modification time or MD5SUM. Doesn't delete files from the destination. If you want to also delete files from destination, to make it match source, use the [sync](https://rclone.org/commands/rclone_sync/) command instead. Note that it is always the contents of the directory that is synced, not the directory itself. So when source:path is a directory, it's the contents of source:path that are copied, not the directory name and contents. To copy single files, use the [copyto](https://rclone.org/commands/rclone_copyto/) command instead. If dest:path doesn't exist, it is created and the source:path contents go there. For example rclone copy source:sourcepath dest:destpath Let's say there are two files in sourcepath sourcepath/one.txt sourcepath/two.txt This copies them to destpath/one.txt destpath/two.txt Not to destpath/sourcepath/one.txt destpath/sourcepath/two.txt If you are familiar with `rsync`, rclone always works as if you had written a trailing `/` - meaning "copy the contents of this directory". This applies to all commands and whether you are talking about the source or destination. See the [--no-traverse](https://rclone.org/docs/#no-traverse) option for controlling whether rclone lists the destination directory or not. Supplying this option when copying a small number of files into a large destination can speed transfers up greatly. For example, if you have many files in /path/to/src but only a few of them change every day, you can copy all the files which have changed recently very efficiently like this: rclone copy --max-age 24h --no-traverse /path/to/src remote: Rclone will sync the modification times of files and directories if the backend supports it. If metadata syncing is required then use the `--metadata` flag. Note that the modification time and metadata for the root directory will **not** be synced. See https://github.com/rclone/rclone/issues/7652 for more info. **Note**: Use the `-P`/`--progress` flag to view real-time transfer statistics. **Note**: Use the `--dry-run` or the `--interactive`/`-i` flag to test without copying anything. # Logger Flags The `--differ`, `--missing-on-dst`, `--missing-on-src`, `--match` and `--error` flags write paths, one per line, to the file name (or stdout if it is `-`) supplied. What they write is described in the help below. For example `--differ` will write all paths which are present on both the source and destination but different. The `--combined` flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - `= path` means path was found in source and destination and was identical - `- path` means path was missing on the source, so only in the destination - `+ path` means path was missing on the destination, so only in the source - `* path` means path was present in source and destination but different. - `! path` means there was an error reading or hashing the source or dest. The `--dest-after` flag writes a list file using the same format flags as [`lsf`](https://rclone.org/commands/rclone_lsf/#synopsis) (including [customizable options for hash, modtime, etc.](https://rclone.org/commands/rclone_lsf/#synopsis)) Conceptually it is similar to rsync's `--itemize-changes`, but not identical -- it should output an accurate list of what will be on the destination after the command is finished. When the `--no-traverse` flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing. Note that these logger flags have a few limitations, and certain scenarios are not currently supported: - `--max-duration` / `CutoffModeHard` - `--compare-dest` / `--copy-dest` - server-side moves of an entire dir at once - High-level retries, because there would be duplicates (use `--retries 1` to disable) - Possibly some unusual error scenarios Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.) ``` rclone copy source:path dest:path [flags] ``` ## Options ``` --absolute Put a leading / in front of path names --combined string Make a combined report of changes to this file --create-empty-src-dirs Create empty source dirs on destination after copy --csv Output in CSV format --dest-after string Report all files that exist on the dest post-sync --differ string Report all non-matching files to this file -d, --dir-slash Append a slash to directory names (default true) --dirs-only Only list directories --error string Report all files with errors (hashing or reading) to this file --files-only Only list files (default true) -F, --format string Output format - see lsf help for details (default "p") --hash h Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5") -h, --help help for copy --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file -s, --separator string Separator for the items in the format (default ";") -t, --timeformat string Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Copy Options Flags for anything which can copy a file ``` --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination ``` ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone sync Make source and dest identical, modifying destination only. ## Synopsis Sync the source to the destination, changing the destination only. Doesn't transfer files that are identical on source and destination, testing by size and modification time or MD5SUM. Destination is updated to match source, including deleting files if necessary (except duplicate objects, see below). If you don't want to delete files from destination, use the [copy](https://rclone.org/commands/rclone_copy/) command instead. **Important**: Since this can cause data loss, test first with the `--dry-run` or the `--interactive`/`i` flag. rclone sync --interactive SOURCE remote:DESTINATION Files in the destination won't be deleted if there were any errors at any point. Duplicate objects (files with the same name, on those providers that support it) are not yet handled. Files that are excluded won't be deleted unless `--delete-excluded` is used. Symlinks won't be transferred or deleted from local file systems unless `--links` is used. It is always the contents of the directory that is synced, not the directory itself. So when source:path is a directory, it's the contents of source:path that are copied, not the directory name and contents. See extended explanation in the [copy](https://rclone.org/commands/rclone_copy/) command if unsure. If dest:path doesn't exist, it is created and the source:path contents go there. It is not possible to sync overlapping remotes. However, you may exclude the destination from the sync with a filter rule or by putting an exclude-if-present file inside the destination directory and sync to a destination that is inside the source directory. Rclone will sync the modification times of files and directories if the backend supports it. If metadata syncing is required then use the `--metadata` flag. Note that the modification time and metadata for the root directory will **not** be synced. See https://github.com/rclone/rclone/issues/7652 for more info. **Note**: Use the `-P`/`--progress` flag to view real-time transfer statistics **Note**: Use the `rclone dedupe` command to deal with "Duplicate object/directory found in source/destination - ignoring" errors. See [this forum post](https://forum.rclone.org/t/sync-not-clearing-duplicates/14372) for more info. # Logger Flags The `--differ`, `--missing-on-dst`, `--missing-on-src`, `--match` and `--error` flags write paths, one per line, to the file name (or stdout if it is `-`) supplied. What they write is described in the help below. For example `--differ` will write all paths which are present on both the source and destination but different. The `--combined` flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - `= path` means path was found in source and destination and was identical - `- path` means path was missing on the source, so only in the destination - `+ path` means path was missing on the destination, so only in the source - `* path` means path was present in source and destination but different. - `! path` means there was an error reading or hashing the source or dest. The `--dest-after` flag writes a list file using the same format flags as [`lsf`](https://rclone.org/commands/rclone_lsf/#synopsis) (including [customizable options for hash, modtime, etc.](https://rclone.org/commands/rclone_lsf/#synopsis)) Conceptually it is similar to rsync's `--itemize-changes`, but not identical -- it should output an accurate list of what will be on the destination after the command is finished. When the `--no-traverse` flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing. Note that these logger flags have a few limitations, and certain scenarios are not currently supported: - `--max-duration` / `CutoffModeHard` - `--compare-dest` / `--copy-dest` - server-side moves of an entire dir at once - High-level retries, because there would be duplicates (use `--retries 1` to disable) - Possibly some unusual error scenarios Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.) ``` rclone sync source:path dest:path [flags] ``` ## Options ``` --absolute Put a leading / in front of path names --combined string Make a combined report of changes to this file --create-empty-src-dirs Create empty source dirs on destination after sync --csv Output in CSV format --dest-after string Report all files that exist on the dest post-sync --differ string Report all non-matching files to this file -d, --dir-slash Append a slash to directory names (default true) --dirs-only Only list directories --error string Report all files with errors (hashing or reading) to this file --files-only Only list files (default true) -F, --format string Output format - see lsf help for details (default "p") --hash h Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5") -h, --help help for sync --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file -s, --separator string Separator for the items in the format (default ";") -t, --timeformat string Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Copy Options Flags for anything which can copy a file ``` --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination ``` ### Sync Options Flags used for sync commands ``` --backup-dir string Make backups into hierarchy based in DIR --delete-after When synchronizing, delete files on destination after transferring (default) --delete-before When synchronizing, delete files on destination before transferring --delete-during When synchronizing, delete files during transfer --fix-case Force rename of case insensitive dest to match source --ignore-errors Delete even if there are I/O errors --list-cutoff int To save memory, sort directory listings on disk above this threshold (default 1000000) --max-delete int When synchronizing, limit the number of deletes (default -1) --max-delete-size SizeSuffix When synchronizing, limit the total size of deletes (default off) --suffix string Suffix to add to changed files --suffix-keep-extension Preserve the extension when using --suffix --track-renames When synchronizing, track file renames and do a server-side move if possible --track-renames-strategy string Strategies to use when synchronizing using track-renames hash|modtime|leaf (default "hash") ``` ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone move Move files from source to dest. ## Synopsis Moves the contents of the source directory to the destination directory. Rclone will error if the source and destination overlap and the remote does not support a server-side directory move operation. To move single files, use the [moveto](https://rclone.org/commands/rclone_moveto/) command instead. If no filters are in use and if possible this will server-side move `source:path` into `dest:path`. After this `source:path` will no longer exist. Otherwise for each file in `source:path` selected by the filters (if any) this will move it into `dest:path`. If possible a server-side move will be used, otherwise it will copy it (server-side if possible) into `dest:path` then delete the original (if no errors on copy) in `source:path`. If you want to delete empty source directories after move, use the `--delete-empty-src-dirs` flag. See the [--no-traverse](https://rclone.org/docs/#no-traverse) option for controlling whether rclone lists the destination directory or not. Supplying this option when moving a small number of files into a large destination can speed transfers up greatly. Rclone will sync the modification times of files and directories if the backend supports it. If metadata syncing is required then use the `--metadata` flag. Note that the modification time and metadata for the root directory will **not** be synced. See https://github.com/rclone/rclone/issues/7652 for more info. **Important**: Since this can cause data loss, test first with the `--dry-run` or the `--interactive`/`-i` flag. **Note**: Use the `-P`/`--progress` flag to view real-time transfer statistics. # Logger Flags The `--differ`, `--missing-on-dst`, `--missing-on-src`, `--match` and `--error` flags write paths, one per line, to the file name (or stdout if it is `-`) supplied. What they write is described in the help below. For example `--differ` will write all paths which are present on both the source and destination but different. The `--combined` flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - `= path` means path was found in source and destination and was identical - `- path` means path was missing on the source, so only in the destination - `+ path` means path was missing on the destination, so only in the source - `* path` means path was present in source and destination but different. - `! path` means there was an error reading or hashing the source or dest. The `--dest-after` flag writes a list file using the same format flags as [`lsf`](https://rclone.org/commands/rclone_lsf/#synopsis) (including [customizable options for hash, modtime, etc.](https://rclone.org/commands/rclone_lsf/#synopsis)) Conceptually it is similar to rsync's `--itemize-changes`, but not identical -- it should output an accurate list of what will be on the destination after the command is finished. When the `--no-traverse` flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing. Note that these logger flags have a few limitations, and certain scenarios are not currently supported: - `--max-duration` / `CutoffModeHard` - `--compare-dest` / `--copy-dest` - server-side moves of an entire dir at once - High-level retries, because there would be duplicates (use `--retries 1` to disable) - Possibly some unusual error scenarios Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.) ``` rclone move source:path dest:path [flags] ``` ## Options ``` --absolute Put a leading / in front of path names --combined string Make a combined report of changes to this file --create-empty-src-dirs Create empty source dirs on destination after move --csv Output in CSV format --delete-empty-src-dirs Delete empty source dirs after move --dest-after string Report all files that exist on the dest post-sync --differ string Report all non-matching files to this file -d, --dir-slash Append a slash to directory names (default true) --dirs-only Only list directories --error string Report all files with errors (hashing or reading) to this file --files-only Only list files (default true) -F, --format string Output format - see lsf help for details (default "p") --hash h Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5") -h, --help help for move --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file -s, --separator string Separator for the items in the format (default ";") -t, --timeformat string Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Copy Options Flags for anything which can copy a file ``` --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination ``` ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone delete Remove the files in path. ## Synopsis Remove the files in path. Unlike [purge](https://rclone.org/commands/rclone_purge/) it obeys include/exclude filters so can be used to selectively delete files. `rclone delete` only deletes files but leaves the directory structure alone. If you want to delete a directory and all of its contents use the [purge](https://rclone.org/commands/rclone_purge/) command. If you supply the `--rmdirs` flag, it will remove all empty directories along with it. You can also use the separate command [rmdir](https://rclone.org/commands/rclone_rmdir/) or [rmdirs](https://rclone.org/commands/rclone_rmdirs/) to delete empty directories only. For example, to delete all files bigger than 100 MiB, you may first want to check what would be deleted (use either): rclone --min-size 100M lsl remote:path rclone --dry-run --min-size 100M delete remote:path Then proceed with the actual delete: rclone --min-size 100M delete remote:path That reads "delete everything with a minimum size of 100 MiB", hence delete all files bigger than 100 MiB. **Important**: Since this can cause data loss, test first with the `--dry-run` or the `--interactive`/`-i` flag. ``` rclone delete remote:path [flags] ``` ## Options ``` -h, --help help for delete --rmdirs rmdirs removes empty directories but leaves root intact ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone purge Remove the path and all of its contents. ## Synopsis Remove the path and all of its contents. Note that this does not obey include/exclude filters - everything will be removed. Use the [delete](https://rclone.org/commands/rclone_delete/) command if you want to selectively delete files. To delete empty directories only, use command [rmdir](https://rclone.org/commands/rclone_rmdir/) or [rmdirs](https://rclone.org/commands/rclone_rmdirs/). The concurrency of this operation is controlled by the `--checkers` global flag. However, some backends will implement this command directly, in which case `--checkers` will be ignored. **Important**: Since this can cause data loss, test first with the `--dry-run` or the `--interactive`/`-i` flag. ``` rclone purge remote:path [flags] ``` ## Options ``` -h, --help help for purge ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone mkdir Make the path if it doesn't already exist. ``` rclone mkdir remote:path [flags] ``` ## Options ``` -h, --help help for mkdir ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone rmdir Remove the empty directory at path. ## Synopsis This removes empty directory given by path. Will not remove the path if it has any objects in it, not even empty subdirectories. Use command [rmdirs](https://rclone.org/commands/rclone_rmdirs/) (or [delete](https://rclone.org/commands/rclone_delete/) with option `--rmdirs`) to do that. To delete a path and any objects in it, use [purge](https://rclone.org/commands/rclone_purge/) command. ``` rclone rmdir remote:path [flags] ``` ## Options ``` -h, --help help for rmdir ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone check Checks the files in the source and destination match. ## Synopsis Checks the files in the source and destination match. It compares sizes and hashes (MD5 or SHA1) and logs a report of files that don't match. It doesn't alter the source or destination. For the [crypt](https://rclone.org/crypt/) remote there is a dedicated command, [cryptcheck](https://rclone.org/commands/rclone_cryptcheck/), that are able to check the checksums of the encrypted files. If you supply the `--size-only` flag, it will only compare the sizes not the hashes as well. Use this for a quick check. If you supply the `--download` flag, it will download the data from both remotes and check them against each other on the fly. This can be useful for remotes that don't support hashes or if you really want to check all the data. If you supply the `--checkfile HASH` flag with a valid hash name, the `source:path` must point to a text file in the SUM format. If you supply the `--one-way` flag, it will only check that files in the source match the files in the destination, not the other way around. This means that extra files in the destination that are not in the source will not be detected. The `--differ`, `--missing-on-dst`, `--missing-on-src`, `--match` and `--error` flags write paths, one per line, to the file name (or stdout if it is `-`) supplied. What they write is described in the help below. For example `--differ` will write all paths which are present on both the source and destination but different. The `--combined` flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - `= path` means path was found in source and destination and was identical - `- path` means path was missing on the source, so only in the destination - `+ path` means path was missing on the destination, so only in the source - `* path` means path was present in source and destination but different. - `! path` means there was an error reading or hashing the source or dest. The default number of parallel checks is 8. See the [--checkers](https://rclone.org/docs/#checkers-int) option for more information. ``` rclone check source:path dest:path [flags] ``` ## Options ``` -C, --checkfile string Treat source:path as a SUM file with hashes of given type --combined string Make a combined report of changes to this file --differ string Report all non-matching files to this file --download Check by downloading rather than with hash --error string Report all files with errors (hashing or reading) to this file -h, --help help for check --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file --one-way Check one way only, source files must exist on remote ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Check Options Flags used for check commands ``` --max-backlog int Maximum number of objects in sync or check backlog (default 10000) ``` ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone ls List the objects in the path with size and path. ## Synopsis Lists the objects in the source path to standard output in a human readable format with size and path. Recurses by default. Eg $ rclone ls swift:bucket 60295 bevajer5jef 90613 canole 94467 diwogej7 37600 fubuwic Any of the filtering options can be applied to this command. There are several related list commands * `ls` to list size and path of objects only * `lsl` to list modification time, size and path of objects only * `lsd` to list directories only * `lsf` to list objects and directories in easy to parse format * `lsjson` to list objects and directories in JSON format `ls`,`lsl`,`lsd` are designed to be human-readable. `lsf` is designed to be human and machine-readable. `lsjson` is designed to be machine-readable. Note that `ls` and `lsl` recurse by default - use `--max-depth 1` to stop the recursion. The other list commands `lsd`,`lsf`,`lsjson` do not recurse by default - use `-R` to make them recurse. Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes). ``` rclone ls remote:path [flags] ``` ## Options ``` -h, --help help for ls ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone lsd List all directories/containers/buckets in the path. ## Synopsis Lists the directories in the source path to standard output. Does not recurse by default. Use the `-R` flag to recurse. This command lists the total size of the directory (if known, -1 if not), the modification time (if known, the current time if not), the number of objects in the directory (if known, -1 if not) and the name of the directory, Eg $ rclone lsd swift: 494000 2018-04-26 08:43:20 10000 10000files 65 2018-04-26 08:43:20 1 1File Or $ rclone lsd drive:test -1 2016-10-17 17:41:53 -1 1000files -1 2017-01-03 14:40:54 -1 2500files -1 2017-07-08 14:39:28 -1 4000files If you just want the directory names use `rclone lsf --dirs-only`. Any of the filtering options can be applied to this command. There are several related list commands * `ls` to list size and path of objects only * `lsl` to list modification time, size and path of objects only * `lsd` to list directories only * `lsf` to list objects and directories in easy to parse format * `lsjson` to list objects and directories in JSON format `ls`,`lsl`,`lsd` are designed to be human-readable. `lsf` is designed to be human and machine-readable. `lsjson` is designed to be machine-readable. Note that `ls` and `lsl` recurse by default - use `--max-depth 1` to stop the recursion. The other list commands `lsd`,`lsf`,`lsjson` do not recurse by default - use `-R` to make them recurse. Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes). ``` rclone lsd remote:path [flags] ``` ## Options ``` -h, --help help for lsd -R, --recursive Recurse into the listing ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone lsl List the objects in path with modification time, size and path. ## Synopsis Lists the objects in the source path to standard output in a human readable format with modification time, size and path. Recurses by default. Eg $ rclone lsl swift:bucket 60295 2016-06-25 18:55:41.062626927 bevajer5jef 90613 2016-06-25 18:55:43.302607074 canole 94467 2016-06-25 18:55:43.046609333 diwogej7 37600 2016-06-25 18:55:40.814629136 fubuwic Any of the filtering options can be applied to this command. There are several related list commands * `ls` to list size and path of objects only * `lsl` to list modification time, size and path of objects only * `lsd` to list directories only * `lsf` to list objects and directories in easy to parse format * `lsjson` to list objects and directories in JSON format `ls`,`lsl`,`lsd` are designed to be human-readable. `lsf` is designed to be human and machine-readable. `lsjson` is designed to be machine-readable. Note that `ls` and `lsl` recurse by default - use `--max-depth 1` to stop the recursion. The other list commands `lsd`,`lsf`,`lsjson` do not recurse by default - use `-R` to make them recurse. Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes). ``` rclone lsl remote:path [flags] ``` ## Options ``` -h, --help help for lsl ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone md5sum Produces an md5sum file for all the objects in the path. ## Synopsis Produces an md5sum file for all the objects in the path. This is in the same format as the standard md5sum tool produces. By default, the hash is requested from the remote. If MD5 is not supported by the remote, no hash will be returned. With the download flag, the file will be downloaded from the remote and hashed locally enabling MD5 for any remote. For other algorithms, see the [hashsum](https://rclone.org/commands/rclone_hashsum/) command. Running `rclone md5sum remote:path` is equivalent to running `rclone hashsum MD5 remote:path`. This command can also hash data received on standard input (stdin), by not passing a remote:path, or by passing a hyphen as remote:path when there is data to read (if not, the hyphen will be treated literally, as a relative path). ``` rclone md5sum remote:path [flags] ``` ## Options ``` --base64 Output base64 encoded hashsum -C, --checkfile string Validate hashes against a given SUM file instead of printing them --download Download the file and hash it locally; if this flag is not specified, the hash is requested from the remote -h, --help help for md5sum --output-file string Output hashsums to a file rather than the terminal ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone sha1sum Produces an sha1sum file for all the objects in the path. ## Synopsis Produces an sha1sum file for all the objects in the path. This is in the same format as the standard sha1sum tool produces. By default, the hash is requested from the remote. If SHA-1 is not supported by the remote, no hash will be returned. With the download flag, the file will be downloaded from the remote and hashed locally enabling SHA-1 for any remote. For other algorithms, see the [hashsum](https://rclone.org/commands/rclone_hashsum/) command. Running `rclone sha1sum remote:path` is equivalent to running `rclone hashsum SHA1 remote:path`. This command can also hash data received on standard input (stdin), by not passing a remote:path, or by passing a hyphen as remote:path when there is data to read (if not, the hyphen will be treated literally, as a relative path). This command can also hash data received on STDIN, if not passing a remote:path. ``` rclone sha1sum remote:path [flags] ``` ## Options ``` --base64 Output base64 encoded hashsum -C, --checkfile string Validate hashes against a given SUM file instead of printing them --download Download the file and hash it locally; if this flag is not specified, the hash is requested from the remote -h, --help help for sha1sum --output-file string Output hashsums to a file rather than the terminal ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone size Prints the total size and number of objects in remote:path. ## Synopsis Counts objects in the path and calculates the total size. Prints the result to standard output. By default the output is in human-readable format, but shows values in both human-readable format as well as the raw numbers (global option `--human-readable` is not considered). Use option `--json` to format output as JSON instead. Recurses by default, use `--max-depth 1` to stop the recursion. Some backends do not always provide file sizes, see for example [Google Photos](https://rclone.org/googlephotos/#size) and [Google Docs](https://rclone.org/drive/#limitations-of-google-docs). Rclone will then show a notice in the log indicating how many such files were encountered, and count them in as empty files in the output of the size command. ``` rclone size remote:path [flags] ``` ## Options ``` -h, --help help for size --json Format output as JSON ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone version Show the version number. ## Synopsis Show the rclone version number, the go version, the build target OS and architecture, the runtime OS and kernel version and bitness, build tags and the type of executable (static or dynamic). For example: $ rclone version rclone v1.55.0 - os/version: ubuntu 18.04 (64 bit) - os/kernel: 4.15.0-136-generic (x86_64) - os/type: linux - os/arch: amd64 - go/version: go1.16 - go/linking: static - go/tags: none Note: before rclone version 1.55 the os/type and os/arch lines were merged, and the "go/version" line was tagged as "go version". If you supply the --check flag, then it will do an online check to compare your version with the latest release and the latest beta. $ rclone version --check yours: 1.42.0.6 latest: 1.42 (released 2018-06-16) beta: 1.42.0.5 (released 2018-06-17) Or $ rclone version --check yours: 1.41 latest: 1.42 (released 2018-06-16) upgrade: https://downloads.rclone.org/v1.42 beta: 1.42.0.5 (released 2018-06-17) upgrade: https://beta.rclone.org/v1.42-005-g56e1e820 If you supply the --deps flag then rclone will print a list of all the packages it depends on and their versions along with some other information about the build. ``` rclone version [flags] ``` ## Options ``` --check Check for new version --deps Show the Go dependencies -h, --help help for version ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone cleanup Clean up the remote if possible. ## Synopsis Clean up the remote if possible. Empty the trash or delete old file versions. Not supported by all remotes. ``` rclone cleanup remote:path [flags] ``` ## Options ``` -h, --help help for cleanup ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone dedupe Interactively find duplicate filenames and delete/rename them. ## Synopsis By default `dedupe` interactively finds files with duplicate names and offers to delete all but one or rename them to be different. This is known as deduping by name. Deduping by name is only useful with a small group of backends (e.g. Google Drive, Opendrive) that can have duplicate file names. It can be run on wrapping backends (e.g. crypt) if they wrap a backend which supports duplicate file names. However if `--by-hash` is passed in then dedupe will find files with duplicate hashes instead which will work on any backend which supports at least one hash. This can be used to find files with duplicate content. This is known as deduping by hash. If deduping by name, first rclone will merge directories with the same name. It will do this iteratively until all the identically named directories have been merged. Next, if deduping by name, for every group of duplicate file names / hashes, it will delete all but one identical file it finds without confirmation. This means that for most duplicated files the `dedupe` command will not be interactive. `dedupe` considers files to be identical if they have the same file path and the same hash. If the backend does not support hashes (e.g. crypt wrapping Google Drive) then they will never be found to be identical. If you use the `--size-only` flag then files will be considered identical if they have the same size (any hash will be ignored). This can be useful on crypt backends which do not support hashes. Next rclone will resolve the remaining duplicates. Exactly which action is taken depends on the dedupe mode. By default, rclone will interactively query the user for each one. **Important**: Since this can cause data loss, test first with the `--dry-run` or the `--interactive`/`-i` flag. Here is an example run. Before - with duplicates $ rclone lsl drive:dupes 6048320 2016-03-05 16:23:16.798000000 one.txt 6048320 2016-03-05 16:23:11.775000000 one.txt 564374 2016-03-05 16:23:06.731000000 one.txt 6048320 2016-03-05 16:18:26.092000000 one.txt 6048320 2016-03-05 16:22:46.185000000 two.txt 1744073 2016-03-05 16:22:38.104000000 two.txt 564374 2016-03-05 16:22:52.118000000 two.txt Now the `dedupe` session $ rclone dedupe drive:dupes 2016/03/05 16:24:37 Google drive root 'dupes': Looking for duplicates using interactive mode. one.txt: Found 4 files with duplicate names one.txt: Deleting 2/3 identical duplicates (MD5 "1eedaa9fe86fd4b8632e2ac549403b36") one.txt: 2 duplicates remain 1: 6048320 bytes, 2016-03-05 16:23:16.798000000, MD5 1eedaa9fe86fd4b8632e2ac549403b36 2: 564374 bytes, 2016-03-05 16:23:06.731000000, MD5 7594e7dc9fc28f727c42ee3e0749de81 s) Skip and do nothing k) Keep just one (choose which in next step) r) Rename all to be different (by changing file.jpg to file-1.jpg) s/k/r> k Enter the number of the file to keep> 1 one.txt: Deleted 1 extra copies two.txt: Found 3 files with duplicate names two.txt: 3 duplicates remain 1: 564374 bytes, 2016-03-05 16:22:52.118000000, MD5 7594e7dc9fc28f727c42ee3e0749de81 2: 6048320 bytes, 2016-03-05 16:22:46.185000000, MD5 1eedaa9fe86fd4b8632e2ac549403b36 3: 1744073 bytes, 2016-03-05 16:22:38.104000000, MD5 851957f7fb6f0bc4ce76be966d336802 s) Skip and do nothing k) Keep just one (choose which in next step) r) Rename all to be different (by changing file.jpg to file-1.jpg) s/k/r> r two-1.txt: renamed from: two.txt two-2.txt: renamed from: two.txt two-3.txt: renamed from: two.txt The result being $ rclone lsl drive:dupes 6048320 2016-03-05 16:23:16.798000000 one.txt 564374 2016-03-05 16:22:52.118000000 two-1.txt 6048320 2016-03-05 16:22:46.185000000 two-2.txt 1744073 2016-03-05 16:22:38.104000000 two-3.txt Dedupe can be run non interactively using the `--dedupe-mode` flag or by using an extra parameter with the same value * `--dedupe-mode interactive` - interactive as above. * `--dedupe-mode skip` - removes identical files then skips anything left. * `--dedupe-mode first` - removes identical files then keeps the first one. * `--dedupe-mode newest` - removes identical files then keeps the newest one. * `--dedupe-mode oldest` - removes identical files then keeps the oldest one. * `--dedupe-mode largest` - removes identical files then keeps the largest one. * `--dedupe-mode smallest` - removes identical files then keeps the smallest one. * `--dedupe-mode rename` - removes identical files then renames the rest to be different. * `--dedupe-mode list` - lists duplicate dirs and files only and changes nothing. For example, to rename all the identically named photos in your Google Photos directory, do rclone dedupe --dedupe-mode rename "drive:Google Photos" Or rclone dedupe rename "drive:Google Photos" ``` rclone dedupe [mode] remote:path [flags] ``` ## Options ``` --by-hash Find identical hashes rather than names --dedupe-mode string Dedupe mode interactive|skip|first|newest|oldest|largest|smallest|rename (default "interactive") -h, --help help for dedupe ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone about Get quota information from the remote. ## Synopsis Prints quota information about a remote to standard output. The output is typically used, free, quota and trash contents. E.g. Typical output from `rclone about remote:` is: Total: 17 GiB Used: 7.444 GiB Free: 1.315 GiB Trashed: 100.000 MiB Other: 8.241 GiB Where the fields are: * Total: Total size available. * Used: Total size used. * Free: Total space available to this user. * Trashed: Total space used by trash. * Other: Total amount in other storage (e.g. Gmail, Google Photos). * Objects: Total number of objects in the storage. All sizes are in number of bytes. Applying a `--full` flag to the command prints the bytes in full, e.g. Total: 18253611008 Used: 7993453766 Free: 1411001220 Trashed: 104857602 Other: 8849156022 A `--json` flag generates conveniently machine-readable output, e.g. { "total": 18253611008, "used": 7993453766, "trashed": 104857602, "other": 8849156022, "free": 1411001220 } Not all backends print all fields. Information is not included if it is not provided by a backend. Where the value is unlimited it is omitted. Some backends does not support the `rclone about` command at all, see complete list in [documentation](https://rclone.org/overview/#optional-features). ``` rclone about remote: [flags] ``` ## Options ``` --full Full numbers instead of human-readable -h, --help help for about --json Format output as JSON ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone authorize Remote authorization. ## Synopsis Remote authorization. Used to authorize a remote or headless rclone from a machine with a browser - use as instructed by rclone config. The command requires 1-3 arguments: - fs name (e.g., "drive", "s3", etc.) - Either a base64 encoded JSON blob obtained from a previous rclone config session - Or a client_id and client_secret pair obtained from the remote service Use --auth-no-open-browser to prevent rclone to open auth link in default browser automatically. Use --template to generate HTML output via a custom Go template. If a blank string is provided as an argument to this flag, the default template is used. ``` rclone authorize [base64_json_blob | client_id client_secret] [flags] ``` ## Options ``` --auth-no-open-browser Do not automatically open auth link in default browser -h, --help help for authorize --template string The path to a custom Go template for generating HTML responses ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone backend Run a backend-specific command. ## Synopsis This runs a backend-specific command. The commands themselves (except for "help" and "features") are defined by the backends and you should see the backend docs for definitions. You can discover what commands a backend implements by using rclone backend help remote: rclone backend help You can also discover information about the backend using (see [operations/fsinfo](https://rclone.org/rc/#operations-fsinfo) in the remote control docs for more info). rclone backend features remote: Pass options to the backend command with -o. This should be key=value or key, e.g.: rclone backend stats remote:path stats -o format=json -o long Pass arguments to the backend by placing them on the end of the line rclone backend cleanup remote:path file1 file2 file3 Note to run these commands on a running backend then see [backend/command](https://rclone.org/rc/#backend-command) in the rc docs. ``` rclone backend remote:path [opts] [flags] ``` ## Options ``` -h, --help help for backend --json Always output in JSON format -o, --option stringArray Option in the form name=value or name ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone bisync Perform bidirectional synchronization between two paths. ## Synopsis Perform bidirectional synchronization between two paths. [Bisync](https://rclone.org/bisync/) provides a bidirectional cloud sync solution in rclone. It retains the Path1 and Path2 filesystem listings from the prior run. On each successive run it will: - list files on Path1 and Path2, and check for changes on each side. Changes include `New`, `Newer`, `Older`, and `Deleted` files. - Propagate changes on Path1 to Path2, and vice-versa. Bisync is considered an **advanced command**, so use with care. Make sure you have read and understood the entire [manual](https://rclone.org/bisync) (especially the [Limitations](https://rclone.org/bisync/#limitations) section) before using, or data loss can result. Questions can be asked in the [Rclone Forum](https://forum.rclone.org/). See [full bisync description](https://rclone.org/bisync/) for details. ``` rclone bisync remote1:path1 remote2:path2 [flags] ``` ## Options ``` --backup-dir1 string --backup-dir for Path1. Must be a non-overlapping path on the same remote. --backup-dir2 string --backup-dir for Path2. Must be a non-overlapping path on the same remote. --check-access Ensure expected RCLONE_TEST files are found on both Path1 and Path2 filesystems, else abort. --check-filename string Filename for --check-access (default: RCLONE_TEST) --check-sync string Controls comparison of final listings: true|false|only (default: true) (default "true") --compare string Comma-separated list of bisync-specific compare options ex. 'size,modtime,checksum' (default: 'size,modtime') --conflict-loser ConflictLoserAction Action to take on the loser of a sync conflict (when there is a winner) or on both files (when there is no winner): , num, pathname, delete (default: num) --conflict-resolve string Automatically resolve conflicts by preferring the version that is: none, path1, path2, newer, older, larger, smaller (default: none) (default "none") --conflict-suffix string Suffix to use when renaming a --conflict-loser. Can be either one string or two comma-separated strings to assign different suffixes to Path1/Path2. (default: 'conflict') --create-empty-src-dirs Sync creation and deletion of empty directories. (Not compatible with --remove-empty-dirs) --download-hash Compute hash by downloading when otherwise unavailable. (warning: may be slow and use lots of data!) --filters-file string Read filtering patterns from a file --force Bypass --max-delete safety check and run the sync. Consider using with --verbose -h, --help help for bisync --ignore-listing-checksum Do not use checksums for listings (add --ignore-checksum to additionally skip post-copy checksum checks) --max-lock Duration Consider lock files older than this to be expired (default: 0 (never expire)) (minimum: 2m) (default 0s) --no-cleanup Retain working files (useful for troubleshooting and testing). --no-slow-hash Ignore listing checksums only on backends where they are slow --recover Automatically recover from interruptions without requiring --resync. --remove-empty-dirs Remove ALL empty directories at the final cleanup step. --resilient Allow future runs to retry after certain less-serious errors, instead of requiring --resync. -1, --resync Performs the resync run. Equivalent to --resync-mode path1. Consider using --verbose or --dry-run first. --resync-mode string During resync, prefer the version that is: path1, path2, newer, older, larger, smaller (default: path1 if --resync, otherwise none for no resync.) (default "none") --slow-hash-sync-only Ignore slow checksums for listings and deltas, but still consider them during sync calls. --workdir string Use custom working dir - useful for testing. (default: {WORKDIR}) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Copy Options Flags for anything which can copy a file ``` --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination ``` ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone cat Concatenates any files and sends them to stdout. ## Synopsis Sends any files to standard output. You can use it like this to output a single file rclone cat remote:path/to/file Or like this to output any file in dir or its subdirectories. rclone cat remote:path/to/dir Or like this to output any .txt files in dir or its subdirectories. rclone --include "*.txt" cat remote:path/to/dir Use the `--head` flag to print characters only at the start, `--tail` for the end and `--offset` and `--count` to print a section in the middle. Note that if offset is negative it will count from the end, so `--offset -1 --count 1` is equivalent to `--tail 1`. Use the `--separator` flag to print a separator value between files. Be sure to shell-escape special characters. For example, to print a newline between files, use: * bash: rclone --include "*.txt" --separator $'\n' cat remote:path/to/dir * powershell: rclone --include "*.txt" --separator "`n" cat remote:path/to/dir ``` rclone cat remote:path [flags] ``` ## Options ``` --count int Only print N characters (default -1) --discard Discard the output instead of printing --head int Only print the first N characters -h, --help help for cat --offset int Start printing at offset N (or from end if -ve) --separator string Separator to use between objects when printing multiple files --tail int Only print the last N characters ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone checksum Checks the files in the destination against a SUM file. ## Synopsis Checks that hashsums of destination files match the SUM file. It compares hashes (MD5, SHA1, etc) and logs a report of files which don't match. It doesn't alter the file system. The sumfile is treated as the source and the dst:path is treated as the destination for the purposes of the output. If you supply the `--download` flag, it will download the data from the remote and calculate the content hash on the fly. This can be useful for remotes that don't support hashes or if you really want to check all the data. Note that hash values in the SUM file are treated as case insensitive. If you supply the `--one-way` flag, it will only check that files in the source match the files in the destination, not the other way around. This means that extra files in the destination that are not in the source will not be detected. The `--differ`, `--missing-on-dst`, `--missing-on-src`, `--match` and `--error` flags write paths, one per line, to the file name (or stdout if it is `-`) supplied. What they write is described in the help below. For example `--differ` will write all paths which are present on both the source and destination but different. The `--combined` flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - `= path` means path was found in source and destination and was identical - `- path` means path was missing on the source, so only in the destination - `+ path` means path was missing on the destination, so only in the source - `* path` means path was present in source and destination but different. - `! path` means there was an error reading or hashing the source or dest. The default number of parallel checks is 8. See the [--checkers](https://rclone.org/docs/#checkers-int) option for more information. ``` rclone checksum sumfile dst:path [flags] ``` ## Options ``` --combined string Make a combined report of changes to this file --differ string Report all non-matching files to this file --download Check by hashing the contents --error string Report all files with errors (hashing or reading) to this file -h, --help help for checksum --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file --one-way Check one way only, source files must exist on remote ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone completion Output completion script for a given shell. ## Synopsis Generates a shell completion script for rclone. Run with `--help` to list the supported shells. ## Options ``` -h, --help help for completion ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. * [rclone completion bash](https://rclone.org/commands/rclone_completion_bash/) - Output bash completion script for rclone. * [rclone completion fish](https://rclone.org/commands/rclone_completion_fish/) - Output fish completion script for rclone. * [rclone completion powershell](https://rclone.org/commands/rclone_completion_powershell/) - Output powershell completion script for rclone. * [rclone completion zsh](https://rclone.org/commands/rclone_completion_zsh/) - Output zsh completion script for rclone. # rclone completion bash Output bash completion script for rclone. ## Synopsis Generates a bash shell autocompletion script for rclone. By default, when run without any arguments, rclone completion bash the generated script will be written to /etc/bash_completion.d/rclone and so rclone will probably need to be run as root, or with sudo. If you supply a path to a file as the command line argument, then the generated script will be written to that file, in which case you should not need root privileges. If output_file is "-", then the output will be written to stdout. If you have installed the script into the default location, you can logout and login again to use the autocompletion script. Alternatively, you can source the script directly . /path/to/my_bash_completion_scripts/rclone and the autocompletion functionality will be added to your current shell. ``` rclone completion bash [output_file] [flags] ``` ## Options ``` -h, --help help for bash ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone completion](https://rclone.org/commands/rclone_completion/) - Output completion script for a given shell. # rclone completion fish Output fish completion script for rclone. ## Synopsis Generates a fish autocompletion script for rclone. This writes to /etc/fish/completions/rclone.fish by default so will probably need to be run with sudo or as root, e.g. sudo rclone completion fish Logout and login again to use the autocompletion scripts, or source them directly . /etc/fish/completions/rclone.fish If you supply a command line argument the script will be written there. If output_file is "-", then the output will be written to stdout. ``` rclone completion fish [output_file] [flags] ``` ## Options ``` -h, --help help for fish ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone completion](https://rclone.org/commands/rclone_completion/) - Output completion script for a given shell. # rclone completion powershell Output powershell completion script for rclone. ## Synopsis Generate the autocompletion script for powershell. To load completions in your current shell session: rclone completion powershell | Out-String | Invoke-Expression To load completions for every new session, add the output of the above command to your powershell profile. If output_file is "-" or missing, then the output will be written to stdout. ``` rclone completion powershell [output_file] [flags] ``` ## Options ``` -h, --help help for powershell ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone completion](https://rclone.org/commands/rclone_completion/) - Output completion script for a given shell. # rclone completion zsh Output zsh completion script for rclone. ## Synopsis Generates a zsh autocompletion script for rclone. This writes to /usr/share/zsh/vendor-completions/_rclone by default so will probably need to be run with sudo or as root, e.g. sudo rclone completion zsh Logout and login again to use the autocompletion scripts, or source them directly autoload -U compinit && compinit If you supply a command line argument the script will be written there. If output_file is "-", then the output will be written to stdout. ``` rclone completion zsh [output_file] [flags] ``` ## Options ``` -h, --help help for zsh ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone completion](https://rclone.org/commands/rclone_completion/) - Output completion script for a given shell. # rclone config create Create a new remote with name, type and options. ## Synopsis Create a new remote of `name` with `type` and options. The options should be passed in pairs of `key` `value` or as `key=value`. For example, to make a swift remote of name myremote using auto config you would do: rclone config create myremote swift env_auth true rclone config create myremote swift env_auth=true So for example if you wanted to configure a Google Drive remote but using remote authorization you would do this: rclone config create mydrive drive config_is_local=false Note that if the config process would normally ask a question the default is taken (unless `--non-interactive` is used). Each time that happens rclone will print or DEBUG a message saying how to affect the value taken. If any of the parameters passed is a password field, then rclone will automatically obscure them if they aren't already obscured before putting them in the config file. **NB** If the password parameter is 22 characters or longer and consists only of base64 characters then rclone can get confused about whether the password is already obscured or not and put unobscured passwords into the config file. If you want to be 100% certain that the passwords get obscured then use the `--obscure` flag, or if you are 100% certain you are already passing obscured passwords then use `--no-obscure`. You can also set obscured passwords using the `rclone config password` command. The flag `--non-interactive` is for use by applications that wish to configure rclone themselves, rather than using rclone's text based configuration questions. If this flag is set, and rclone needs to ask the user a question, a JSON blob will be returned with the question in it. This will look something like (some irrelevant detail removed): ``` { "State": "*oauth-islocal,teamdrive,,", "Option": { "Name": "config_is_local", "Help": "Use web browser to automatically authenticate rclone with remote?\n * Say Y if the machine running rclone has a web browser you can use\n * Say N if running rclone on a (remote) machine without web browser access\nIf not sure try Y. If Y failed, try N.\n", "Default": true, "Examples": [ { "Value": "true", "Help": "Yes" }, { "Value": "false", "Help": "No" } ], "Required": false, "IsPassword": false, "Type": "bool", "Exclusive": true, }, "Error": "", } ``` The format of `Option` is the same as returned by `rclone config providers`. The question should be asked to the user and returned to rclone as the `--result` option along with the `--state` parameter. The keys of `Option` are used as follows: - `Name` - name of variable - show to user - `Help` - help text. Hard wrapped at 80 chars. Any URLs should be clicky. - `Default` - default value - return this if the user just wants the default. - `Examples` - the user should be able to choose one of these - `Required` - the value should be non-empty - `IsPassword` - the value is a password and should be edited as such - `Type` - type of value, eg `bool`, `string`, `int` and others - `Exclusive` - if set no free-form entry allowed only the `Examples` - Irrelevant keys `Provider`, `ShortOpt`, `Hide`, `NoPrefix`, `Advanced` If `Error` is set then it should be shown to the user at the same time as the question. rclone config update name --continue --state "*oauth-islocal,teamdrive,," --result "true" Note that when using `--continue` all passwords should be passed in the clear (not obscured). Any default config values should be passed in with each invocation of `--continue`. At the end of the non interactive process, rclone will return a result with `State` as empty string. If `--all` is passed then rclone will ask all the config questions, not just the post config questions. Any parameters are used as defaults for questions as usual. Note that `bin/config.py` in the rclone source implements this protocol as a readable demonstration. ``` rclone config create name type [key value]* [flags] ``` ## Options ``` --all Ask the full set of config questions --continue Continue the configuration process with an answer -h, --help help for create --no-obscure Force any passwords not to be obscured --no-output Don't provide any output --non-interactive Don't interact with user and return questions --obscure Force any passwords to be obscured --result string Result - use with --continue --state string State - use with --continue ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config delete Delete an existing remote. ``` rclone config delete name [flags] ``` ## Options ``` -h, --help help for delete ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config disconnect Disconnects user from remote ## Synopsis This disconnects the remote: passed in to the cloud storage system. This normally means revoking the oauth token. To reconnect use "rclone config reconnect". ``` rclone config disconnect remote: [flags] ``` ## Options ``` -h, --help help for disconnect ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config dump Dump the config file as JSON. ``` rclone config dump [flags] ``` ## Options ``` -h, --help help for dump ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config edit Enter an interactive configuration session. ## Synopsis Enter an interactive configuration session where you can setup new remotes and manage existing ones. You may also set or remove a password to protect your configuration. ``` rclone config edit [flags] ``` ## Options ``` -h, --help help for edit ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config encryption set, remove and check the encryption for the config file ## Synopsis This command sets, clears and checks the encryption for the config file using the subcommands below. ## Options ``` -h, --help help for encryption ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. * [rclone config encryption check](https://rclone.org/commands/rclone_config_encryption_check/) - Check that the config file is encrypted * [rclone config encryption remove](https://rclone.org/commands/rclone_config_encryption_remove/) - Remove the config file encryption password * [rclone config encryption set](https://rclone.org/commands/rclone_config_encryption_set/) - Set or change the config file encryption password # rclone config encryption check Check that the config file is encrypted ## Synopsis This checks the config file is encrypted and that you can decrypt it. It will attempt to decrypt the config using the password you supply. If decryption fails it will return a non-zero exit code if using `--password-command`, otherwise it will prompt again for the password. If the config file is not encrypted it will return a non zero exit code. ``` rclone config encryption check [flags] ``` ## Options ``` -h, --help help for check ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config encryption](https://rclone.org/commands/rclone_config_encryption/) - set, remove and check the encryption for the config file # rclone config encryption remove Remove the config file encryption password ## Synopsis Remove the config file encryption password This removes the config file encryption, returning it to un-encrypted. If `--password-command` is in use, this will be called to supply the old config password. If the config was not encrypted then no error will be returned and this command will do nothing. ``` rclone config encryption remove [flags] ``` ## Options ``` -h, --help help for remove ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config encryption](https://rclone.org/commands/rclone_config_encryption/) - set, remove and check the encryption for the config file # rclone config encryption set Set or change the config file encryption password ## Synopsis This command sets or changes the config file encryption password. If there was no config password set then it sets a new one, otherwise it changes the existing config password. Note that if you are changing an encryption password using `--password-command` then this will be called once to decrypt the config using the old password and then again to read the new password to re-encrypt the config. When `--password-command` is called to change the password then the environment variable `RCLONE_PASSWORD_CHANGE=1` will be set. So if changing passwords programmatically you can use the environment variable to distinguish which password you must supply. Alternatively you can remove the password first (with `rclone config encryption remove`), then set it again with this command which may be easier if you don't mind the unencrypted config file being on the disk briefly. ``` rclone config encryption set [flags] ``` ## Options ``` -h, --help help for set ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config encryption](https://rclone.org/commands/rclone_config_encryption/) - set, remove and check the encryption for the config file # rclone config file Show path of configuration file in use. ``` rclone config file [flags] ``` ## Options ``` -h, --help help for file ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config password Update password in an existing remote. ## Synopsis Update an existing remote's password. The password should be passed in pairs of `key` `password` or as `key=password`. The `password` should be passed in in clear (unobscured). For example, to set password of a remote of name myremote you would do: rclone config password myremote fieldname mypassword rclone config password myremote fieldname=mypassword This command is obsolete now that "config update" and "config create" both support obscuring passwords directly. ``` rclone config password name [key value]+ [flags] ``` ## Options ``` -h, --help help for password ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config paths Show paths used for configuration, cache, temp etc. ``` rclone config paths [flags] ``` ## Options ``` -h, --help help for paths ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config providers List in JSON format all the providers and options. ``` rclone config providers [flags] ``` ## Options ``` -h, --help help for providers ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config reconnect Re-authenticates user with remote. ## Synopsis This reconnects remote: passed in to the cloud storage system. To disconnect the remote use "rclone config disconnect". This normally means going through the interactive oauth flow again. ``` rclone config reconnect remote: [flags] ``` ## Options ``` -h, --help help for reconnect ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config redacted Print redacted (decrypted) config file, or the redacted config for a single remote. ## Synopsis This prints a redacted copy of the config file, either the whole config file or for a given remote. The config file will be redacted by replacing all passwords and other sensitive info with XXX. This makes the config file suitable for posting online for support. It should be double checked before posting as the redaction may not be perfect. ``` rclone config redacted [] [flags] ``` ## Options ``` -h, --help help for redacted ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config show Print (decrypted) config file, or the config for a single remote. ``` rclone config show [] [flags] ``` ## Options ``` -h, --help help for show ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config touch Ensure configuration file exists. ``` rclone config touch [flags] ``` ## Options ``` -h, --help help for touch ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config update Update options in an existing remote. ## Synopsis Update an existing remote's options. The options should be passed in pairs of `key` `value` or as `key=value`. For example, to update the env_auth field of a remote of name myremote you would do: rclone config update myremote env_auth true rclone config update myremote env_auth=true If the remote uses OAuth the token will be updated, if you don't require this add an extra parameter thus: rclone config update myremote env_auth=true config_refresh_token=false Note that if the config process would normally ask a question the default is taken (unless `--non-interactive` is used). Each time that happens rclone will print or DEBUG a message saying how to affect the value taken. If any of the parameters passed is a password field, then rclone will automatically obscure them if they aren't already obscured before putting them in the config file. **NB** If the password parameter is 22 characters or longer and consists only of base64 characters then rclone can get confused about whether the password is already obscured or not and put unobscured passwords into the config file. If you want to be 100% certain that the passwords get obscured then use the `--obscure` flag, or if you are 100% certain you are already passing obscured passwords then use `--no-obscure`. You can also set obscured passwords using the `rclone config password` command. The flag `--non-interactive` is for use by applications that wish to configure rclone themselves, rather than using rclone's text based configuration questions. If this flag is set, and rclone needs to ask the user a question, a JSON blob will be returned with the question in it. This will look something like (some irrelevant detail removed): ``` { "State": "*oauth-islocal,teamdrive,,", "Option": { "Name": "config_is_local", "Help": "Use web browser to automatically authenticate rclone with remote?\n * Say Y if the machine running rclone has a web browser you can use\n * Say N if running rclone on a (remote) machine without web browser access\nIf not sure try Y. If Y failed, try N.\n", "Default": true, "Examples": [ { "Value": "true", "Help": "Yes" }, { "Value": "false", "Help": "No" } ], "Required": false, "IsPassword": false, "Type": "bool", "Exclusive": true, }, "Error": "", } ``` The format of `Option` is the same as returned by `rclone config providers`. The question should be asked to the user and returned to rclone as the `--result` option along with the `--state` parameter. The keys of `Option` are used as follows: - `Name` - name of variable - show to user - `Help` - help text. Hard wrapped at 80 chars. Any URLs should be clicky. - `Default` - default value - return this if the user just wants the default. - `Examples` - the user should be able to choose one of these - `Required` - the value should be non-empty - `IsPassword` - the value is a password and should be edited as such - `Type` - type of value, eg `bool`, `string`, `int` and others - `Exclusive` - if set no free-form entry allowed only the `Examples` - Irrelevant keys `Provider`, `ShortOpt`, `Hide`, `NoPrefix`, `Advanced` If `Error` is set then it should be shown to the user at the same time as the question. rclone config update name --continue --state "*oauth-islocal,teamdrive,," --result "true" Note that when using `--continue` all passwords should be passed in the clear (not obscured). Any default config values should be passed in with each invocation of `--continue`. At the end of the non interactive process, rclone will return a result with `State` as empty string. If `--all` is passed then rclone will ask all the config questions, not just the post config questions. Any parameters are used as defaults for questions as usual. Note that `bin/config.py` in the rclone source implements this protocol as a readable demonstration. ``` rclone config update name [key value]+ [flags] ``` ## Options ``` --all Ask the full set of config questions --continue Continue the configuration process with an answer -h, --help help for update --no-obscure Force any passwords not to be obscured --no-output Don't provide any output --non-interactive Don't interact with user and return questions --obscure Force any passwords to be obscured --result string Result - use with --continue --state string State - use with --continue ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone config userinfo Prints info about logged in user of remote. ## Synopsis This prints the details of the person logged in to the cloud storage system. ``` rclone config userinfo remote: [flags] ``` ## Options ``` -h, --help help for userinfo --json Format output as JSON ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone config](https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session. # rclone convmv Convert file and directory names in place. ## Synopsis convmv supports advanced path name transformations for converting and renaming files and directories by applying prefixes, suffixes, and other alterations. | Command | Description | |------|------| | `--name-transform prefix=XXXX` | Prepends XXXX to the file name. | | `--name-transform suffix=XXXX` | Appends XXXX to the file name after the extension. | | `--name-transform suffix_keep_extension=XXXX` | Appends XXXX to the file name while preserving the original file extension. | | `--name-transform trimprefix=XXXX` | Removes XXXX if it appears at the start of the file name. | | `--name-transform trimsuffix=XXXX` | Removes XXXX if it appears at the end of the file name. | | `--name-transform regex=/pattern/replacement/` | Applies a regex-based transformation. | | `--name-transform replace=old:new` | Replaces occurrences of old with new in the file name. | | `--name-transform date={YYYYMMDD}` | Appends or prefixes the specified date format. | | `--name-transform truncate=N` | Truncates the file name to a maximum of N characters. | | `--name-transform base64encode` | Encodes the file name in Base64. | | `--name-transform base64decode` | Decodes a Base64-encoded file name. | | `--name-transform encoder=ENCODING` | Converts the file name to the specified encoding (e.g., ISO-8859-1, Windows-1252, Macintosh). | | `--name-transform decoder=ENCODING` | Decodes the file name from the specified encoding. | | `--name-transform charmap=MAP` | Applies a character mapping transformation. | | `--name-transform lowercase` | Converts the file name to lowercase. | | `--name-transform uppercase` | Converts the file name to UPPERCASE. | | `--name-transform titlecase` | Converts the file name to Title Case. | | `--name-transform ascii` | Strips non-ASCII characters. | | `--name-transform url` | URL-encodes the file name. | | `--name-transform nfc` | Converts the file name to NFC Unicode normalization form. | | `--name-transform nfd` | Converts the file name to NFD Unicode normalization form. | | `--name-transform nfkc` | Converts the file name to NFKC Unicode normalization form. | | `--name-transform nfkd` | Converts the file name to NFKD Unicode normalization form. | | `--name-transform command=/path/to/my/programfile names.` | Executes an external program to transform | Conversion modes: ``` none nfc nfd nfkc nfkd replace prefix suffix suffix_keep_extension trimprefix trimsuffix index date truncate base64encode base64decode encoder decoder ISO-8859-1 Windows-1252 Macintosh charmap lowercase uppercase titlecase ascii url regex command ``` Char maps: ``` IBM-Code-Page-037 IBM-Code-Page-437 IBM-Code-Page-850 IBM-Code-Page-852 IBM-Code-Page-855 Windows-Code-Page-858 IBM-Code-Page-860 IBM-Code-Page-862 IBM-Code-Page-863 IBM-Code-Page-865 IBM-Code-Page-866 IBM-Code-Page-1047 IBM-Code-Page-1140 ISO-8859-1 ISO-8859-2 ISO-8859-3 ISO-8859-4 ISO-8859-5 ISO-8859-6 ISO-8859-7 ISO-8859-8 ISO-8859-9 ISO-8859-10 ISO-8859-13 ISO-8859-14 ISO-8859-15 ISO-8859-16 KOI8-R KOI8-U Macintosh Macintosh-Cyrillic Windows-874 Windows-1250 Windows-1251 Windows-1252 Windows-1253 Windows-1254 Windows-1255 Windows-1256 Windows-1257 Windows-1258 X-User-Defined ``` Encoding masks: ``` Asterisk BackQuote BackSlash Colon CrLf Ctl Del Dollar Dot DoubleQuote Exclamation Hash InvalidUtf8 LeftCrLfHtVt LeftPeriod LeftSpace LeftTilde LtGt None Percent Pipe Question Raw RightCrLfHtVt RightPeriod RightSpace Semicolon SingleQuote Slash SquareBracket ``` Examples: ``` rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,uppercase" // Output: STORIES/THE QUICK BROWN FOX!.TXT ``` ``` rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,replace=Fox:Turtle" --name-transform "all,replace=Quick:Slow" // Output: stories/The Slow Brown Turtle!.txt ``` ``` rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,base64encode" // Output: c3Rvcmllcw==/VGhlIFF1aWNrIEJyb3duIEZveCEudHh0 ``` ``` rclone convmv "c3Rvcmllcw==/VGhlIFF1aWNrIEJyb3duIEZveCEudHh0" --name-transform "all,base64decode" // Output: stories/The Quick Brown Fox!.txt ``` ``` rclone convmv "stories/The Quick Brown 🦊 Fox Went to the Café!.txt" --name-transform "all,nfc" // Output: stories/The Quick Brown 🦊 Fox Went to the Café!.txt ``` ``` rclone convmv "stories/The Quick Brown 🦊 Fox Went to the Café!.txt" --name-transform "all,nfd" // Output: stories/The Quick Brown 🦊 Fox Went to the Café!.txt ``` ``` rclone convmv "stories/The Quick Brown 🦊 Fox!.txt" --name-transform "all,ascii" // Output: stories/The Quick Brown Fox!.txt ``` ``` rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,trimsuffix=.txt" // Output: stories/The Quick Brown Fox! ``` ``` rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,prefix=OLD_" // Output: OLD_stories/OLD_The Quick Brown Fox!.txt ``` ``` rclone convmv "stories/The Quick Brown 🦊 Fox Went to the Café!.txt" --name-transform "all,charmap=ISO-8859-7" // Output: stories/The Quick Brown _ Fox Went to the Caf_!.txt ``` ``` rclone convmv "stories/The Quick Brown Fox: A Memoir [draft].txt" --name-transform "all,encoder=Colon,SquareBracket" // Output: stories/The Quick Brown Fox： A Memoir ［draft］.txt ``` ``` rclone convmv "stories/The Quick Brown 🦊 Fox Went to the Café!.txt" --name-transform "all,truncate=21" // Output: stories/The Quick Brown 🦊 Fox ``` ``` rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,command=echo" // Output: stories/The Quick Brown Fox!.txt ``` ``` rclone convmv "stories/The Quick Brown Fox!" --name-transform "date=-{YYYYMMDD}" // Output: stories/The Quick Brown Fox!-20250618 ``` ``` rclone convmv "stories/The Quick Brown Fox!" --name-transform "date=-{macfriendlytime}" // Output: stories/The Quick Brown Fox!-2025-06-18 0148PM ``` ``` rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,regex=[\\.\\w]/ab" // Output: ababababababab/ababab ababababab ababababab ababab!abababab ``` Multiple transformations can be used in sequence, applied in the order they are specified on the command line. The `--name-transform` flag is also available in `sync`, `copy`, and `move`. # Files vs Directories By default `--name-transform` will only apply to file names. The means only the leaf file name will be transformed. However some of the transforms would be better applied to the whole path or just directories. To choose which which part of the file path is affected some tags can be added to the `--name-transform`. | Tag | Effect | |------|------| | `file` | Only transform the leaf name of files (DEFAULT) | | `dir` | Only transform name of directories - these may appear anywhere in the path | | `all` | Transform the entire path for files and directories | This is used by adding the tag into the transform name like this: `--name-transform file,prefix=ABC` or `--name-transform dir,prefix=DEF`. For some conversions using all is more likely to be useful, for example `--name-transform all,nfc`. Note that `--name-transform` may not add path separators `/` to the name. This will cause an error. # Ordering and Conflicts * Transformations will be applied in the order specified by the user. * If the `file` tag is in use (the default) then only the leaf name of files will be transformed. * If the `dir` tag is in use then directories anywhere in the path will be transformed * If the `all` tag is in use then directories and files anywhere in the path will be transformed * Each transformation will be run one path segment at a time. * If a transformation adds a `/` or ends up with an empty path segment then that will be an error. * It is up to the user to put the transformations in a sensible order. * Conflicting transformations, such as `prefix` followed by `trimprefix` or `nfc` followed by `nfd`, are possible. * Instead of enforcing mutual exclusivity, transformations are applied in sequence as specified by the user, allowing for intentional use cases (e.g., trimming one prefix before adding another). * Users should be aware that certain combinations may lead to unexpected results and should verify transformations using `--dry-run` before execution. # Race Conditions and Non-Deterministic Behavior Some transformations, such as `replace=old:new`, may introduce conflicts where multiple source files map to the same destination name. This can lead to race conditions when performing concurrent transfers. It is up to the user to anticipate these. * If two files from the source are transformed into the same name at the destination, the final state may be non-deterministic. * Running rclone check after a sync using such transformations may erroneously report missing or differing files due to overwritten results. To minimize risks, users should: * Carefully review transformations that may introduce conflicts. * Use `--dry-run` to inspect changes before executing a sync (but keep in mind that it won't show the effect of non-deterministic transformations). * Avoid transformations that cause multiple distinct source files to map to the same destination name. * Consider disabling concurrency with `--transfers=1` if necessary. * Certain transformations (e.g. `prefix`) will have a multiplying effect every time they are used. Avoid these when using `bisync`. ``` rclone convmv dest:path --name-transform XXX [flags] ``` ## Options ``` --create-empty-src-dirs Create empty source dirs on destination after move --delete-empty-src-dirs Delete empty source dirs after move -h, --help help for convmv ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Copy Options Flags for anything which can copy a file ``` --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination ``` ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone copyto Copy files from source to dest, skipping identical files. ## Synopsis If source:path is a file or directory then it copies it to a file or directory named dest:path. This can be used to upload single files to other than their current name. If the source is a directory then it acts exactly like the [copy](https://rclone.org/commands/rclone_copy/) command. So rclone copyto src dst where src and dst are rclone paths, either remote:path or /path/to/local or C:\windows\path\if\on\windows. This will: if src is file copy it to dst, overwriting an existing file if it exists if src is directory copy it to dst, overwriting existing files if they exist see copy command for full details This doesn't transfer files that are identical on src and dst, testing by size and modification time or MD5SUM. It doesn't delete files from the destination. *If you are looking to copy just a byte range of a file, please see 'rclone cat --offset X --count Y'* **Note**: Use the `-P`/`--progress` flag to view real-time transfer statistics # Logger Flags The `--differ`, `--missing-on-dst`, `--missing-on-src`, `--match` and `--error` flags write paths, one per line, to the file name (or stdout if it is `-`) supplied. What they write is described in the help below. For example `--differ` will write all paths which are present on both the source and destination but different. The `--combined` flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - `= path` means path was found in source and destination and was identical - `- path` means path was missing on the source, so only in the destination - `+ path` means path was missing on the destination, so only in the source - `* path` means path was present in source and destination but different. - `! path` means there was an error reading or hashing the source or dest. The `--dest-after` flag writes a list file using the same format flags as [`lsf`](https://rclone.org/commands/rclone_lsf/#synopsis) (including [customizable options for hash, modtime, etc.](https://rclone.org/commands/rclone_lsf/#synopsis)) Conceptually it is similar to rsync's `--itemize-changes`, but not identical -- it should output an accurate list of what will be on the destination after the command is finished. When the `--no-traverse` flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing. Note that these logger flags have a few limitations, and certain scenarios are not currently supported: - `--max-duration` / `CutoffModeHard` - `--compare-dest` / `--copy-dest` - server-side moves of an entire dir at once - High-level retries, because there would be duplicates (use `--retries 1` to disable) - Possibly some unusual error scenarios Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.) ``` rclone copyto source:path dest:path [flags] ``` ## Options ``` --absolute Put a leading / in front of path names --combined string Make a combined report of changes to this file --csv Output in CSV format --dest-after string Report all files that exist on the dest post-sync --differ string Report all non-matching files to this file -d, --dir-slash Append a slash to directory names (default true) --dirs-only Only list directories --error string Report all files with errors (hashing or reading) to this file --files-only Only list files (default true) -F, --format string Output format - see lsf help for details (default "p") --hash h Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5") -h, --help help for copyto --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file -s, --separator string Separator for the items in the format (default ";") -t, --timeformat string Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Copy Options Flags for anything which can copy a file ``` --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination ``` ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone copyurl Copy the contents of the URL supplied content to dest:path. ## Synopsis Download a URL's content and copy it to the destination without saving it in temporary storage. Setting `--auto-filename` will attempt to automatically determine the filename from the URL (after any redirections) and used in the destination path. With `--header-filename` in addition, if a specific filename is set in HTTP headers, it will be used instead of the name from the URL. With `--print-filename` in addition, the resulting file name will be printed. Setting `--no-clobber` will prevent overwriting file on the destination if there is one with the same name. Setting `--stdout` or making the output file name `-` will cause the output to be written to standard output. ## Troubleshooting If you can't get `rclone copyurl` to work then here are some things you can try: - `--disable-http2` rclone will use HTTP2 if available - try disabling it - `--bind 0.0.0.0` rclone will use IPv6 if available - try disabling it - `--bind ::0` to disable IPv4 - `--user agent curl` - some sites have whitelists for curl's user-agent - try that - Make sure the site works with `curl` directly ``` rclone copyurl https://example.com dest:path [flags] ``` ## Options ``` -a, --auto-filename Get the file name from the URL and use it for destination file path --header-filename Get the file name from the Content-Disposition header -h, --help help for copyurl --no-clobber Prevent overwriting file with same name -p, --print-filename Print the resulting name from --auto-filename --stdout Write the output to stdout rather than a file ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone cryptcheck Cryptcheck checks the integrity of an encrypted remote. ## Synopsis Checks a remote against a [crypted](https://rclone.org/crypt/) remote. This is the equivalent of running rclone [check](https://rclone.org/commands/rclone_check/), but able to check the checksums of the encrypted remote. For it to work the underlying remote of the cryptedremote must support some kind of checksum. It works by reading the nonce from each file on the cryptedremote: and using that to encrypt each file on the remote:. It then checks the checksum of the underlying file on the cryptedremote: against the checksum of the file it has just encrypted. Use it like this rclone cryptcheck /path/to/files encryptedremote:path You can use it like this also, but that will involve downloading all the files in remote:path. rclone cryptcheck remote:path encryptedremote:path After it has run it will log the status of the encryptedremote:. If you supply the `--one-way` flag, it will only check that files in the source match the files in the destination, not the other way around. This means that extra files in the destination that are not in the source will not be detected. The `--differ`, `--missing-on-dst`, `--missing-on-src`, `--match` and `--error` flags write paths, one per line, to the file name (or stdout if it is `-`) supplied. What they write is described in the help below. For example `--differ` will write all paths which are present on both the source and destination but different. The `--combined` flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - `= path` means path was found in source and destination and was identical - `- path` means path was missing on the source, so only in the destination - `+ path` means path was missing on the destination, so only in the source - `* path` means path was present in source and destination but different. - `! path` means there was an error reading or hashing the source or dest. The default number of parallel checks is 8. See the [--checkers](https://rclone.org/docs/#checkers-int) option for more information. ``` rclone cryptcheck remote:path cryptedremote:path [flags] ``` ## Options ``` --combined string Make a combined report of changes to this file --differ string Report all non-matching files to this file --error string Report all files with errors (hashing or reading) to this file -h, --help help for cryptcheck --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file --one-way Check one way only, source files must exist on remote ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Check Options Flags used for check commands ``` --max-backlog int Maximum number of objects in sync or check backlog (default 10000) ``` ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone cryptdecode Cryptdecode returns unencrypted file names. ## Synopsis Returns unencrypted file names when provided with a list of encrypted file names. List limit is 10 items. If you supply the `--reverse` flag, it will return encrypted file names. use it like this rclone cryptdecode encryptedremote: encryptedfilename1 encryptedfilename2 rclone cryptdecode --reverse encryptedremote: filename1 filename2 Another way to accomplish this is by using the `rclone backend encode` (or `decode`) command. See the documentation on the [crypt](https://rclone.org/crypt/) overlay for more info. ``` rclone cryptdecode encryptedremote: encryptedfilename [flags] ``` ## Options ``` -h, --help help for cryptdecode --reverse Reverse cryptdecode, encrypts filenames ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone deletefile Remove a single file from remote. ## Synopsis Remove a single file from remote. Unlike `delete` it cannot be used to remove a directory and it doesn't obey include/exclude filters - if the specified file exists, it will always be removed. ``` rclone deletefile remote:path [flags] ``` ## Options ``` -h, --help help for deletefile ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone gendocs Output markdown docs for rclone to the directory supplied. ## Synopsis This produces markdown docs for the rclone commands to the directory supplied. These are in a format suitable for hugo to render into the rclone.org website. ``` rclone gendocs output_directory [flags] ``` ## Options ``` -h, --help help for gendocs ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone gitannex Speaks with git-annex over stdin/stdout. ## Synopsis Rclone's `gitannex` subcommand enables [git-annex] to store and retrieve content from an rclone remote. It is meant to be run by git-annex, not directly by users. [git-annex]: https://git-annex.branchable.com/ Installation on Linux --------------------- 1. Skip this step if your version of git-annex is [10.20240430] or newer. Otherwise, you must create a symlink somewhere on your PATH with a particular name. This symlink helps git-annex tell rclone it wants to run the "gitannex" subcommand. ```sh # Create the helper symlink in "$HOME/bin". ln -s "$(realpath rclone)" "$HOME/bin/git-annex-remote-rclone-builtin" # Verify the new symlink is on your PATH. which git-annex-remote-rclone-builtin ``` [10.20240430]: https://git-annex.branchable.com/news/version_10.20240430/ 2. Add a new remote to your git-annex repo. This new remote will connect git-annex with the `rclone gitannex` subcommand. Start by asking git-annex to describe the remote's available configuration parameters. ```sh # If you skipped step 1: git annex initremote MyRemote type=rclone --whatelse # If you created a symlink in step 1: git annex initremote MyRemote type=external externaltype=rclone-builtin --whatelse ``` > **NOTE**: If you're porting an existing [git-annex-remote-rclone] remote to > use `rclone gitannex`, you can probably reuse the configuration parameters > verbatim without renaming them. Check parameter synonyms with `--whatelse` > as shown above. > > [git-annex-remote-rclone]: https://github.com/git-annex-remote-rclone/git-annex-remote-rclone The following example creates a new git-annex remote named "MyRemote" that will use the rclone remote named "SomeRcloneRemote". That rclone remote must be one configured in your rclone.conf file, which can be located with `rclone config file`. ```sh git annex initremote MyRemote \ type=external \ externaltype=rclone-builtin \ encryption=none \ rcloneremotename=SomeRcloneRemote \ rcloneprefix=git-annex-content \ rclonelayout=nodir ``` 3. Before you trust this command with your precious data, be sure to **test the remote**. This command is very new and has not been tested on many rclone backends. Caveat emptor! ```sh git annex testremote MyRemote ``` Happy annexing! ``` rclone gitannex [flags] ``` ## Options ``` -h, --help help for gitannex ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone hashsum Produces a hashsum file for all the objects in the path. ## Synopsis Produces a hash file for all the objects in the path using the hash named. The output is in the same format as the standard md5sum/sha1sum tool. By default, the hash is requested from the remote. If the hash is not supported by the remote, no hash will be returned. With the download flag, the file will be downloaded from the remote and hashed locally enabling any hash for any remote. For the MD5 and SHA1 algorithms there are also dedicated commands, [md5sum](https://rclone.org/commands/rclone_md5sum/) and [sha1sum](https://rclone.org/commands/rclone_sha1sum/). This command can also hash data received on standard input (stdin), by not passing a remote:path, or by passing a hyphen as remote:path when there is data to read (if not, the hyphen will be treated literally, as a relative path). Run without a hash to see the list of all supported hashes, e.g. $ rclone hashsum Supported hashes are: * md5 * sha1 * whirlpool * crc32 * sha256 * sha512 * blake3 * xxh3 * xxh128 Then $ rclone hashsum MD5 remote:path Note that hash names are case insensitive and values are output in lower case. ``` rclone hashsum [ remote:path] [flags] ``` ## Options ``` --base64 Output base64 encoded hashsum -C, --checkfile string Validate hashes against a given SUM file instead of printing them --download Download the file and hash it locally; if this flag is not specified, the hash is requested from the remote -h, --help help for hashsum --output-file string Output hashsums to a file rather than the terminal ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone link Generate public link to file/folder. ## Synopsis Create, retrieve or remove a public link to the given file or folder. rclone link remote:path/to/file rclone link remote:path/to/folder/ rclone link --unlink remote:path/to/folder/ rclone link --expire 1d remote:path/to/file If you supply the --expire flag, it will set the expiration time otherwise it will use the default (100 years). **Note** not all backends support the --expire flag - if the backend doesn't support it then the link returned won't expire. Use the --unlink flag to remove existing public links to the file or folder. **Note** not all backends support "--unlink" flag - those that don't will just ignore it. If successful, the last line of the output will contain the link. Exact capabilities depend on the remote, but the link will always by default be created with the least constraints – e.g. no expiry, no password protection, accessible without account. ``` rclone link remote:path [flags] ``` ## Options ``` --expire Duration The amount of time that the link will be valid (default off) -h, --help help for link --unlink Remove existing public link to file/folder ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone listremotes List all the remotes in the config file and defined in environment variables. ## Synopsis Lists all the available remotes from the config file, or the remotes matching an optional filter. Prints the result in human-readable format by default, and as a simple list of remote names, or if used with flag `--long` a tabular format including the remote names, types and descriptions. Using flag `--json` produces machine-readable output instead, which always includes all attributes - including the source (file or environment). Result can be filtered by a filter argument which applies to all attributes, and/or filter flags specific for each attribute. The values must be specified according to regular rclone filtering pattern syntax. ``` rclone listremotes [] [flags] ``` ## Options ``` --description string Filter remotes by description -h, --help help for listremotes --json Format output as JSON --long Show type and description in addition to name --name string Filter remotes by name --order-by string Instructions on how to order the result, e.g. 'type,name=descending' --source string Filter remotes by source, e.g. 'file' or 'environment' --type string Filter remotes by type ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone lsf List directories and objects in remote:path formatted for parsing. ## Synopsis List the contents of the source path (directories and objects) to standard output in a form which is easy to parse by scripts. By default this will just be the names of the objects and directories, one per line. The directories will have a / suffix. Eg $ rclone lsf swift:bucket bevajer5jef canole diwogej7 ferejej3gux/ fubuwic Use the `--format` option to control what gets listed. By default this is just the path, but you can use these parameters to control the output: p - path s - size t - modification time h - hash i - ID of object o - Original ID of underlying object m - MimeType of object if known e - encrypted name T - tier of storage if known, e.g. "Hot" or "Cool" M - Metadata of object in JSON blob format, eg {"key":"value"} So if you wanted the path, size and modification time, you would use `--format "pst"`, or maybe `--format "tsp"` to put the path last. Eg $ rclone lsf --format "tsp" swift:bucket 2016-06-25 18:55:41;60295;bevajer5jef 2016-06-25 18:55:43;90613;canole 2016-06-25 18:55:43;94467;diwogej7 2018-04-26 08:50:45;0;ferejej3gux/ 2016-06-25 18:55:40;37600;fubuwic If you specify "h" in the format you will get the MD5 hash by default, use the `--hash` flag to change which hash you want. Note that this can be returned as an empty string if it isn't available on the object (and for directories), "ERROR" if there was an error reading it from the object and "UNSUPPORTED" if that object does not support that hash type. For example, to emulate the md5sum command you can use rclone lsf -R --hash MD5 --format hp --separator " " --files-only . Eg $ rclone lsf -R --hash MD5 --format hp --separator " " --files-only swift:bucket 7908e352297f0f530b84a756f188baa3 bevajer5jef cd65ac234e6fea5925974a51cdd865cc canole 03b5341b4f234b9d984d03ad076bae91 diwogej7 8fd37c3810dd660778137ac3a66cc06d fubuwic 99713e14a4c4ff553acaf1930fad985b gixacuh7ku (Though "rclone md5sum ." is an easier way of typing this.) By default the separator is ";" this can be changed with the `--separator` flag. Note that separators aren't escaped in the path so putting it last is a good strategy. Eg $ rclone lsf --separator "," --format "tshp" swift:bucket 2016-06-25 18:55:41,60295,7908e352297f0f530b84a756f188baa3,bevajer5jef 2016-06-25 18:55:43,90613,cd65ac234e6fea5925974a51cdd865cc,canole 2016-06-25 18:55:43,94467,03b5341b4f234b9d984d03ad076bae91,diwogej7 2018-04-26 08:52:53,0,,ferejej3gux/ 2016-06-25 18:55:40,37600,8fd37c3810dd660778137ac3a66cc06d,fubuwic You can output in CSV standard format. This will escape things in " if they contain , Eg $ rclone lsf --csv --files-only --format ps remote:path test.log,22355 test.sh,449 "this file contains a comma, in the file name.txt",6 Note that the `--absolute` parameter is useful for making lists of files to pass to an rclone copy with the `--files-from-raw` flag. For example, to find all the files modified within one day and copy those only (without traversing the whole directory structure): rclone lsf --absolute --files-only --max-age 1d /path/to/local > new_files rclone copy --files-from-raw new_files /path/to/local remote:path The default time format is `'2006-01-02 15:04:05'`. [Other formats](https://pkg.go.dev/time#pkg-constants) can be specified with the `--time-format` flag. Examples: rclone lsf remote:path --format pt --time-format 'Jan 2, 2006 at 3:04pm (MST)' rclone lsf remote:path --format pt --time-format '2006-01-02 15:04:05.000000000' rclone lsf remote:path --format pt --time-format '2006-01-02T15:04:05.999999999Z07:00' rclone lsf remote:path --format pt --time-format RFC3339 rclone lsf remote:path --format pt --time-format DateOnly rclone lsf remote:path --format pt --time-format max `--time-format max` will automatically truncate '`2006-01-02 15:04:05.000000000`' to the maximum precision supported by the remote. Any of the filtering options can be applied to this command. There are several related list commands * `ls` to list size and path of objects only * `lsl` to list modification time, size and path of objects only * `lsd` to list directories only * `lsf` to list objects and directories in easy to parse format * `lsjson` to list objects and directories in JSON format `ls`,`lsl`,`lsd` are designed to be human-readable. `lsf` is designed to be human and machine-readable. `lsjson` is designed to be machine-readable. Note that `ls` and `lsl` recurse by default - use `--max-depth 1` to stop the recursion. The other list commands `lsd`,`lsf`,`lsjson` do not recurse by default - use `-R` to make them recurse. Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes). ``` rclone lsf remote:path [flags] ``` ## Options ``` --absolute Put a leading / in front of path names --csv Output in CSV format -d, --dir-slash Append a slash to directory names (default true) --dirs-only Only list directories --files-only Only list files -F, --format string Output format - see help for details (default "p") --hash h Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5") -h, --help help for lsf -R, --recursive Recurse into the listing -s, --separator string Separator for the items in the format (default ";") -t, --time-format string Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone lsjson List directories and objects in the path in JSON format. ## Synopsis List directories and objects in the path in JSON format. The output is an array of Items, where each Item looks like this: { "Hashes" : { "SHA-1" : "f572d396fae9206628714fb2ce00f72e94f2258f", "MD5" : "b1946ac92492d2347c6235b4d2611184", "DropboxHash" : "ecb65bb98f9d905b70458986c39fcbad7715e5f2fcc3b1f07767d7c83e2438cc" }, "ID": "y2djkhiujf83u33", "OrigID": "UYOJVTUW00Q1RzTDA", "IsBucket" : false, "IsDir" : false, "MimeType" : "application/octet-stream", "ModTime" : "2017-05-31T16:15:57.034468261+01:00", "Name" : "file.txt", "Encrypted" : "v0qpsdq8anpci8n929v3uu9338", "EncryptedPath" : "kja9098349023498/v0qpsdq8anpci8n929v3uu9338", "Path" : "full/path/goes/here/file.txt", "Size" : 6, "Tier" : "hot", } The exact set of properties included depends on the backend: - The property IsBucket will only be included for bucket-based remotes, and only for directories that are buckets. It will always be omitted when value is not true. - Properties Encrypted and EncryptedPath will only be included for encrypted remotes, and (as mentioned below) only if the `--encrypted` option is set. Different options may also affect which properties are included: - If `--hash` is not specified, the Hashes property will be omitted. The types of hash can be specified with the `--hash-type` parameter (which may be repeated). If `--hash-type` is set then it implies `--hash`. - If `--no-modtime` is specified then ModTime will be blank. This can speed things up on remotes where reading the ModTime takes an extra request (e.g. s3, swift). - If `--no-mimetype` is specified then MimeType will be blank. This can speed things up on remotes where reading the MimeType takes an extra request (e.g. s3, swift). - If `--encrypted` is not specified the Encrypted and EncryptedPath properties will be omitted - even for encrypted remotes. - If `--metadata` is set then an additional Metadata property will be returned. This will have [metadata](https://rclone.org/docs/#metadata) in rclone standard format as a JSON object. The default is to list directories and files/objects, but this can be changed with the following options: - If `--dirs-only` is specified then directories will be returned only, no files/objects. - If `--files-only` is specified then files will be returned only, no directories. If `--stat` is set then the the output is not an array of items, but instead a single JSON blob will be returned about the item pointed to. This will return an error if the item isn't found, however on bucket based backends (like s3, gcs, b2, azureblob etc) if the item isn't found it will return an empty directory, as it isn't possible to tell empty directories from missing directories there. The Path field will only show folders below the remote path being listed. If "remote:path" contains the file "subfolder/file.txt", the Path for "file.txt" will be "subfolder/file.txt", not "remote:path/subfolder/file.txt". When used without `--recursive` the Path will always be the same as Name. The time is in RFC3339 format with up to nanosecond precision. The number of decimal digits in the seconds will depend on the precision that the remote can hold the times, so if times are accurate to the nearest millisecond (e.g. Google Drive) then 3 digits will always be shown ("2017-05-31T16:15:57.034+01:00") whereas if the times are accurate to the nearest second (Dropbox, Box, WebDav, etc.) no digits will be shown ("2017-05-31T16:15:57+01:00"). The whole output can be processed as a JSON blob, or alternatively it can be processed line by line as each item is written on individual lines (except with `--stat`). Any of the filtering options can be applied to this command. There are several related list commands * `ls` to list size and path of objects only * `lsl` to list modification time, size and path of objects only * `lsd` to list directories only * `lsf` to list objects and directories in easy to parse format * `lsjson` to list objects and directories in JSON format `ls`,`lsl`,`lsd` are designed to be human-readable. `lsf` is designed to be human and machine-readable. `lsjson` is designed to be machine-readable. Note that `ls` and `lsl` recurse by default - use `--max-depth 1` to stop the recursion. The other list commands `lsd`,`lsf`,`lsjson` do not recurse by default - use `-R` to make them recurse. Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes). ``` rclone lsjson remote:path [flags] ``` ## Options ``` --dirs-only Show only directories in the listing --encrypted Show the encrypted names --files-only Show only files in the listing --hash Include hashes in the output (may take longer) --hash-type stringArray Show only this hash type (may be repeated) -h, --help help for lsjson -M, --metadata Add metadata to the listing --no-mimetype Don't read the mime type (can speed things up) --no-modtime Don't read the modification time (can speed things up) --original Show the ID of the underlying Object -R, --recursive Recurse into the listing --stat Just return the info for the pointed to file ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone mount Mount the remote as file system on a mountpoint. ## Synopsis Rclone mount allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE. First set up your remote using `rclone config`. Check it works with `rclone ls` etc. On Linux and macOS, you can run mount in either foreground or background (aka daemon) mode. Mount runs in foreground mode by default. Use the `--daemon` flag to force background mode. On Windows you can run mount in foreground only, the flag is ignored. In background mode rclone acts as a generic Unix mount program: the main program starts, spawns background rclone process to setup and maintain the mount, waits until success or timeout and exits with appropriate code (killing the child process if it fails). On Linux/macOS/FreeBSD start the mount like this, where `/path/to/local/mount` is an **empty** **existing** directory: rclone mount remote:path/to/files /path/to/local/mount On Windows you can start a mount in different ways. See [below](#mounting-modes-on-windows) for details. If foreground mount is used interactively from a console window, rclone will serve the mount and occupy the console so another window should be used to work with the mount until rclone is interrupted e.g. by pressing Ctrl-C. The following examples will mount to an automatically assigned drive, to specific drive letter `X:`, to path `C:\path\parent\mount` (where parent directory or drive must exist, and mount must **not** exist, and is not supported when [mounting as a network drive](#mounting-modes-on-windows)), and the last example will mount as network share `\\cloud\remote` and map it to an automatically assigned drive: rclone mount remote:path/to/files * rclone mount remote:path/to/files X: rclone mount remote:path/to/files C:\path\parent\mount rclone mount remote:path/to/files \\cloud\remote When the program ends while in foreground mode, either via Ctrl+C or receiving a SIGINT or SIGTERM signal, the mount should be automatically stopped. When running in background mode the user will have to stop the mount manually: # Linux fusermount -u /path/to/local/mount #... or on some systems fusermount3 -u /path/to/local/mount # OS X or Linux when using nfsmount umount /path/to/local/mount The umount operation can fail, for example when the mountpoint is busy. When that happens, it is the user's responsibility to stop the mount manually. The size of the mounted file system will be set according to information retrieved from the remote, the same as returned by the [rclone about](https://rclone.org/commands/rclone_about/) command. Remotes with unlimited storage may report the used size only, then an additional 1 PiB of free space is assumed. If the remote does not [support](https://rclone.org/overview/#optional-features) the about feature at all, then 1 PiB is set as both the total and the free size. ## Installing on Windows To run rclone mount on Windows, you will need to download and install [WinFsp](http://www.secfs.net/winfsp/). [WinFsp](https://github.com/winfsp/winfsp) is an open-source Windows File System Proxy which makes it easy to write user space file systems for Windows. It provides a FUSE emulation layer which rclone uses combination with [cgofuse](https://github.com/winfsp/cgofuse). Both of these packages are by Bill Zissimopoulos who was very helpful during the implementation of rclone mount for Windows. ### Mounting modes on windows Unlike other operating systems, Microsoft Windows provides a different filesystem type for network and fixed drives. It optimises access on the assumption fixed disk drives are fast and reliable, while network drives have relatively high latency and less reliability. Some settings can also be differentiated between the two types, for example that Windows Explorer should just display icons and not create preview thumbnails for image and video files on network drives. In most cases, rclone will mount the remote as a normal, fixed disk drive by default. However, you can also choose to mount it as a remote network drive, often described as a network share. If you mount an rclone remote using the default, fixed drive mode and experience unexpected program errors, freezes or other issues, consider mounting as a network drive instead. When mounting as a fixed disk drive you can either mount to an unused drive letter, or to a path representing a **nonexistent** subdirectory of an **existing** parent directory or drive. Using the special value `*` will tell rclone to automatically assign the next available drive letter, starting with Z: and moving backward. Examples: rclone mount remote:path/to/files * rclone mount remote:path/to/files X: rclone mount remote:path/to/files C:\path\parent\mount rclone mount remote:path/to/files X: Option `--volname` can be used to set a custom volume name for the mounted file system. The default is to use the remote name and path. To mount as network drive, you can add option `--network-mode` to your mount command. Mounting to a directory path is not supported in this mode, it is a limitation Windows imposes on junctions, so the remote must always be mounted to a drive letter. rclone mount remote:path/to/files X: --network-mode A volume name specified with `--volname` will be used to create the network share path. A complete UNC path, such as `\\cloud\remote`, optionally with path `\\cloud\remote\madeup\path`, will be used as is. Any other string will be used as the share part, after a default prefix `\\server\`. If no volume name is specified then `\\server\share` will be used. You must make sure the volume name is unique when you are mounting more than one drive, or else the mount command will fail. The share name will treated as the volume label for the mapped drive, shown in Windows Explorer etc, while the complete `\\server\share` will be reported as the remote UNC path by `net use` etc, just like a normal network drive mapping. If you specify a full network share UNC path with `--volname`, this will implicitly set the `--network-mode` option, so the following two examples have same result: rclone mount remote:path/to/files X: --network-mode rclone mount remote:path/to/files X: --volname \\server\share You may also specify the network share UNC path as the mountpoint itself. Then rclone will automatically assign a drive letter, same as with `*` and use that as mountpoint, and instead use the UNC path specified as the volume name, as if it were specified with the `--volname` option. This will also implicitly set the `--network-mode` option. This means the following two examples have same result: rclone mount remote:path/to/files \\cloud\remote rclone mount remote:path/to/files * --volname \\cloud\remote There is yet another way to enable network mode, and to set the share path, and that is to pass the "native" libfuse/WinFsp option directly: `--fuse-flag --VolumePrefix=\server\share`. Note that the path must be with just a single backslash prefix in this case. *Note:* In previous versions of rclone this was the only supported method. [Read more about drive mapping](https://en.wikipedia.org/wiki/Drive_mapping) See also [Limitations](#limitations) section below. ### Windows filesystem permissions The FUSE emulation layer on Windows must convert between the POSIX-based permission model used in FUSE, and the permission model used in Windows, based on access-control lists (ACL). The mounted filesystem will normally get three entries in its access-control list (ACL), representing permissions for the POSIX permission scopes: Owner, group and others. By default, the owner and group will be taken from the current user, and the built-in group "Everyone" will be used to represent others. The user/group can be customized with FUSE options "UserName" and "GroupName", e.g. `-o UserName=user123 -o GroupName="Authenticated Users"`. The permissions on each entry will be set according to [options](#options) `--dir-perms` and `--file-perms`, which takes a value in traditional Unix [numeric notation](https://en.wikipedia.org/wiki/File-system_permissions#Numeric_notation). The default permissions corresponds to `--file-perms 0666 --dir-perms 0777`, i.e. read and write permissions to everyone. This means you will not be able to start any programs from the mount. To be able to do that you must add execute permissions, e.g. `--file-perms 0777 --dir-perms 0777` to add it to everyone. If the program needs to write files, chances are you will have to enable [VFS File Caching](#vfs-file-caching) as well (see also [limitations](#limitations)). Note that the default write permission have some restrictions for accounts other than the owner, specifically it lacks the "write extended attributes", as explained next. The mapping of permissions is not always trivial, and the result you see in Windows Explorer may not be exactly like you expected. For example, when setting a value that includes write access for the group or others scope, this will be mapped to individual permissions "write attributes", "write data" and "append data", but not "write extended attributes". Windows will then show this as basic permission "Special" instead of "Write", because "Write" also covers the "write extended attributes" permission. When setting digit 0 for group or others, to indicate no permissions, they will still get individual permissions "read attributes", "read extended attributes" and "read permissions". This is done for compatibility reasons, e.g. to allow users without additional permissions to be able to read basic metadata about files like in Unix. WinFsp 2021 (version 1.9) introduced a new FUSE option "FileSecurity", that allows the complete specification of file security descriptors using [SDDL](https://docs.microsoft.com/en-us/windows/win32/secauthz/security-descriptor-string-format). With this you get detailed control of the resulting permissions, compared to use of the POSIX permissions described above, and no additional permissions will be added automatically for compatibility with Unix. Some example use cases will following. If you set POSIX permissions for only allowing access to the owner, using `--file-perms 0600 --dir-perms 0700`, the user group and the built-in "Everyone" group will still be given some special permissions, as described above. Some programs may then (incorrectly) interpret this as the file being accessible by everyone, for example an SSH client may warn about "unprotected private key file". You can work around this by specifying `-o FileSecurity="D:P(A;;FA;;;OW)"`, which sets file all access (FA) to the owner (OW), and nothing else. When setting write permissions then, except for the owner, this does not include the "write extended attributes" permission, as mentioned above. This may prevent applications from writing to files, giving permission denied error instead. To set working write permissions for the built-in "Everyone" group, similar to what it gets by default but with the addition of the "write extended attributes", you can specify `-o FileSecurity="D:P(A;;FRFW;;;WD)"`, which sets file read (FR) and file write (FW) to everyone (WD). If file execute (FX) is also needed, then change to `-o FileSecurity="D:P(A;;FRFWFX;;;WD)"`, or set file all access (FA) to get full access permissions, including delete, with `-o FileSecurity="D:P(A;;FA;;;WD)"`. ### Windows caveats Drives created as Administrator are not visible to other accounts, not even an account that was elevated to Administrator with the User Account Control (UAC) feature. A result of this is that if you mount to a drive letter from a Command Prompt run as Administrator, and then try to access the same drive from Windows Explorer (which does not run as Administrator), you will not be able to see the mounted drive. If you don't need to access the drive from applications running with administrative privileges, the easiest way around this is to always create the mount from a non-elevated command prompt. To make mapped drives available to the user account that created them regardless if elevated or not, there is a special Windows setting called [linked connections](https://docs.microsoft.com/en-us/troubleshoot/windows-client/networking/mapped-drives-not-available-from-elevated-command#detail-to-configure-the-enablelinkedconnections-registry-entry) that can be enabled. It is also possible to make a drive mount available to everyone on the system, by running the process creating it as the built-in SYSTEM account. There are several ways to do this: One is to use the command-line utility [PsExec](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec), from Microsoft's Sysinternals suite, which has option `-s` to start processes as the SYSTEM account. Another alternative is to run the mount command from a Windows Scheduled Task, or a Windows Service, configured to run as the SYSTEM account. A third alternative is to use the [WinFsp.Launcher infrastructure](https://github.com/winfsp/winfsp/wiki/WinFsp-Service-Architecture)). Read more in the [install documentation](https://rclone.org/install/). Note that when running rclone as another user, it will not use the configuration file from your profile unless you tell it to with the [`--config`](https://rclone.org/docs/#config-string) option. Note also that it is now the SYSTEM account that will have the owner permissions, and other accounts will have permissions according to the group or others scopes. As mentioned above, these will then not get the "write extended attributes" permission, and this may prevent writing to files. You can work around this with the FileSecurity option, see example above. Note that mapping to a directory path, instead of a drive letter, does not suffer from the same limitations. ## Mounting on macOS Mounting on macOS can be done either via [built-in NFS server](https://rclone.org/commands/rclone_serve_nfs/), [macFUSE](https://osxfuse.github.io/) (also known as osxfuse) or [FUSE-T](https://www.fuse-t.org/). macFUSE is a traditional FUSE driver utilizing a macOS kernel extension (kext). FUSE-T is an alternative FUSE system which "mounts" via an NFSv4 local server. #### Unicode Normalization It is highly recommended to keep the default of `--no-unicode-normalization=false` for all `mount` and `serve` commands on macOS. For details, see [vfs-case-sensitivity](https://rclone.org/commands/rclone_mount/#vfs-case-sensitivity). ### NFS mount This method spins up an NFS server using [serve nfs](https://rclone.org/commands/rclone_serve_nfs/) command and mounts it to the specified mountpoint. If you run this in background mode using |--daemon|, you will need to send SIGTERM signal to the rclone process using |kill| command to stop the mount. Note that `--nfs-cache-handle-limit` controls the maximum number of cached file handles stored by the `nfsmount` caching handler. This should not be set too low or you may experience errors when trying to access files. The default is 1000000, but consider lowering this limit if the server's system resource usage causes problems. ### macFUSE Notes If installing macFUSE using [dmg packages](https://github.com/osxfuse/osxfuse/releases) from the website, rclone will locate the macFUSE libraries without any further intervention. If however, macFUSE is installed using the [macports](https://www.macports.org/) package manager, the following addition steps are required. sudo mkdir /usr/local/lib cd /usr/local/lib sudo ln -s /opt/local/lib/libfuse.2.dylib ### FUSE-T Limitations, Caveats, and Notes There are some limitations, caveats, and notes about how it works. These are current as of FUSE-T version 1.0.14. #### ModTime update on read As per the [FUSE-T wiki](https://github.com/macos-fuse-t/fuse-t/wiki#caveats): > File access and modification times cannot be set separately as it seems to be an > issue with the NFS client which always modifies both. Can be reproduced with > 'touch -m' and 'touch -a' commands This means that viewing files with various tools, notably macOS Finder, will cause rlcone to update the modification time of the file. This may make rclone upload a full new copy of the file. #### Read Only mounts When mounting with `--read-only`, attempts to write to files will fail *silently* as opposed to with a clear warning as in macFUSE. ## Limitations Without the use of `--vfs-cache-mode` this can only write files sequentially, it can only seek when reading. This means that many applications won't work with their files on an rclone mount without `--vfs-cache-mode writes` or `--vfs-cache-mode full`. See the [VFS File Caching](#vfs-file-caching) section for more info. When using NFS mount on macOS, if you don't specify |--vfs-cache-mode| the mount point will be read-only. Bucket-based remotes - Azure Blob, Swift, S3, Google Cloud Storage and B2 - can't store empty directories. Of these, only Azure Blob, Google Cloud Storage and S3 can preserve them when you add `--xxx-directory_markers`; otherwise, empty directories will vanish once they drop out of the directory cache. When `rclone mount` is invoked on Unix with `--daemon` flag, the main rclone program will wait for the background mount to become ready or until the timeout specified by the `--daemon-wait` flag. On Linux it can check mount status using ProcFS so the flag in fact sets **maximum** time to wait, while the real wait can be less. On macOS / BSD the time to wait is constant and the check is performed only at the end. We advise you to set wait time on macOS reasonably. Only supported on Linux, FreeBSD, OS X and Windows at the moment. ## rclone mount vs rclone sync/copy File systems expect things to be 100% reliable, whereas cloud storage systems are a long way from 100% reliable. The rclone sync/copy commands cope with this with lots of retries. However rclone mount can't use retries in the same way without making local copies of the uploads. Look at the [VFS File Caching](#vfs-file-caching) for solutions to make mount more reliable. ## Attribute caching You can use the flag `--attr-timeout` to set the time the kernel caches the attributes (size, modification time, etc.) for directory entries. The default is `1s` which caches files just long enough to avoid too many callbacks to rclone from the kernel. In theory 0s should be the correct value for filesystems which can change outside the control of the kernel. However this causes quite a few problems such as [rclone using too much memory](https://github.com/rclone/rclone/issues/2157), [rclone not serving files to samba](https://forum.rclone.org/t/rclone-1-39-vs-1-40-mount-issue/5112) and [excessive time listing directories](https://github.com/rclone/rclone/issues/2095#issuecomment-371141147). The kernel can cache the info about a file for the time given by `--attr-timeout`. You may see corruption if the remote file changes length during this window. It will show up as either a truncated file or a file with garbage on the end. With `--attr-timeout 1s` this is very unlikely but not impossible. The higher you set `--attr-timeout` the more likely it is. The default setting of "1s" is the lowest setting which mitigates the problems above. If you set it higher (`10s` or `1m` say) then the kernel will call back to rclone less often making it more efficient, however there is more chance of the corruption issue above. If files don't change on the remote outside of the control of rclone then there is no chance of corruption. This is the same as setting the attr_timeout option in mount.fuse. ## Filters Note that all the rclone filters can be used to select a subset of the files to be visible in the mount. ## systemd When running rclone mount as a systemd service, it is possible to use Type=notify. In this case the service will enter the started state after the mountpoint has been successfully set up. Units having the rclone mount service specified as a requirement will see all files and folders immediately in this mode. Note that systemd runs mount units without any environment variables including `PATH` or `HOME`. This means that tilde (`~`) expansion will not work and you should provide `--config` and `--cache-dir` explicitly as absolute paths via rclone arguments. Since mounting requires the `fusermount` or `fusermount3` program, rclone will use the fallback PATH of `/bin:/usr/bin` in this scenario. Please ensure that `fusermount`/`fusermount3` is present on this PATH. ## Rclone as Unix mount helper The core Unix program `/bin/mount` normally takes the `-t FSTYPE` argument then runs the `/sbin/mount.FSTYPE` helper program passing it mount options as `-o key=val,...` or `--opt=...`. Automount (classic or systemd) behaves in a similar way. rclone by default expects GNU-style flags `--key val`. To run it as a mount helper you should symlink rclone binary to `/sbin/mount.rclone` and optionally `/usr/bin/rclonefs`, e.g. `ln -s /usr/bin/rclone /sbin/mount.rclone`. rclone will detect it and translate command-line arguments appropriately. Now you can run classic mounts like this: ``` mount sftp1:subdir /mnt/data -t rclone -o vfs_cache_mode=writes,sftp_key_file=/path/to/pem ``` or create systemd mount units: ``` # /etc/systemd/system/mnt-data.mount [Unit] Description=Mount for /mnt/data [Mount] Type=rclone What=sftp1:subdir Where=/mnt/data Options=rw,_netdev,allow_other,args2env,vfs-cache-mode=writes,config=/etc/rclone.conf,cache-dir=/var/rclone ``` optionally accompanied by systemd automount unit ``` # /etc/systemd/system/mnt-data.automount [Unit] Description=AutoMount for /mnt/data [Automount] Where=/mnt/data TimeoutIdleSec=600 [Install] WantedBy=multi-user.target ``` or add in `/etc/fstab` a line like ``` sftp1:subdir /mnt/data rclone rw,noauto,nofail,_netdev,x-systemd.automount,args2env,vfs_cache_mode=writes,config=/etc/rclone.conf,cache_dir=/var/cache/rclone 0 0 ``` or use classic Automountd. Remember to provide explicit `config=...,cache-dir=...` as a workaround for mount units being run without `HOME`. Rclone in the mount helper mode will split `-o` argument(s) by comma, replace `_` by `-` and prepend `--` to get the command-line flags. Options containing commas or spaces can be wrapped in single or double quotes. Any inner quotes inside outer quotes of the same type should be doubled. Mount option syntax includes a few extra options treated specially: - `env.NAME=VALUE` will set an environment variable for the mount process. This helps with Automountd and Systemd.mount which don't allow setting custom environment for mount helpers. Typically you will use `env.HTTPS_PROXY=proxy.host:3128` or `env.HOME=/root` - `command=cmount` can be used to run `cmount` or any other rclone command rather than the default `mount`. - `args2env` will pass mount options to the mount helper running in background via environment variables instead of command line arguments. This allows to hide secrets from such commands as `ps` or `pgrep`. - `vv...` will be transformed into appropriate `--verbose=N` - standard mount options like `x-systemd.automount`, `_netdev`, `nosuid` and alike are intended only for Automountd and ignored by rclone. ## VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. ## VFS Directory Cache Using the `--dir-cache-time` flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a `SIGHUP` signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a [remote control](/rc) then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir ## VFS File Buffering The `--buffer-size` flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to `--buffer-size * open files`. ## VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with `-vv` rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with `--cache-dir` or setting the appropriate environment variable. The cache has 4 different modes selected by `--vfs-cache-mode`. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for `--vfs-write-back` seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using `--vfs-cache-max-size` or `--vfs-cache-min-free-space` note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every `--vfs-cache-poll-interval`. Secondly because open files cannot be evicted from the cache. When `--vfs-cache-max-size` or `--vfs-cache-min-free-space` is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The `--vfs-cache-max-age` will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You **should not** run two copies of rclone using the same VFS cache with the same or overlapping remotes if using `--vfs-cache-mode > off`. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with `--cache-dir`. You don't need to worry about this if the remotes in use don't overlap. ### --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible * Files can't be opened for both read AND write * Files opened for write can't be seeked * Existing files opened for write must have O_TRUNC set * Files open for read with O_TRUNC will be opened write only * Files open for write only will behave as if O_TRUNC was supplied * Open modes O_APPEND, O_TRUNC are ignored * If an upload fails it can't be retried ### --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible * Files opened for write only can't be seeked * Existing files opened for write must have O_TRUNC set * Files opened for write only will ignore O_APPEND, O_TRUNC * If an upload fails it can't be retried ### --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. ### --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to `--vfs-cache-mode` writes. When reading a file rclone will read `--buffer-size` plus `--vfs-read-ahead` bytes ahead. The `--buffer-size` is buffered in memory whereas the `--vfs-read-ahead` is buffered on disk. When using this mode it is recommended that `--buffer-size` is not set too large and `--vfs-read-ahead` is set large if required. **IMPORTANT** not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. ### Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example `hash` is slow with the `local` and `sftp` backends as they have to read the entire file and hash it, and `modtime` is slow with the `s3`, `swift`, `ftp` and `qinqstor` backends because they need to do an extra API call to fetch it. If you use the `--vfs-fast-fingerprint` flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over `local`, `s3` or `swift` backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. ## VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the `--vfs-read-chunk-streams` parameter. ### `--vfs-read-chunk-streams` == 0 Rclone will start reading a chunk of size `--vfs-read-chunk-size`, and then double the size for each read. When `--vfs-read-chunk-size-limit` is specified, and greater than `--vfs-read-chunk-size`, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With `--vfs-read-chunk-size 100M` and `--vfs-read-chunk-size-limit 0` the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When `--vfs-read-chunk-size-limit 500M` is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting `--vfs-read-chunk-size` to `0` or "off" disables chunked reading. The chunks will not be buffered in memory. ### `--vfs-read-chunk-streams` > 0 Rclone reads `--vfs-read-chunk-streams` chunks of size `--vfs-read-chunk-size` concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of `--vfs-read-chunk-size` and `--vfs-read-chunk-streams` as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be `--vfs-read-chunk-streams 16` and `--vfs-read-chunk-size 4M`. In testing with AWS S3 the performance scaled roughly as the `--vfs-read-chunk-streams` setting. Similar settings should work for high latency links, but depending on the latency they may need more `--vfs-read-chunk-streams` in order to get the throughput. ## VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the [chunked reading](#vfs-chunked-reading) feature. In particular S3 and Swift benefit hugely from the `--no-modtime` flag (or use `--use-server-modtime` for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (`--vfs-cache-mode` with value writes or full), the global flag `--transfers` can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag `--checkers` has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) ## Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink `link-to-file.txt` would be stored on cloud storage as `link-to-file.txt.rclonelink` and the contents would be the path to the symlink destination. Note that `--links` enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). `--vfs-links` just enables it for the VFS layer. This scheme is compatible with that used by the [local backend with the --local-links flag](https://rclone.org/local/#symlinks-junction-points). The `--vfs-links` flag has been designed for `rclone mount`, `rclone nfsmount` and `rclone serve nfs`. It hasn't been tested with the other `rclone serve` commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree ``` . ├── dir │   └── file.txt └── linked-dir -> dir ``` The VFS will correctly resolve `linked-dir` but not `linked-dir/file.txt`. This is not a problem for the tested commands but may be for other commands. **Note** that there is an outstanding issue with symlink support [issue #8245](https://github.com/rclone/rclone/issues/8245) with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). ## VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The `--vfs-case-insensitive` VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The `--no-unicode-normalization` flag controls whether a similar "fixup" is performed for filenames that differ but are [canonically equivalent](https://en.wikipedia.org/wiki/Unicode_equivalence) with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of `false` on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the `--vfs-block-norm-dupes` flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. `--vfs-block- norm-dupes` prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in `rclone sync`. ## VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) ## Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running `df` on the filesystem, then pass the flag `--vfs-used-is-size` to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to `rclone size` and compute the total used space itself. _WARNING._ Contrary to `rclone size`, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. ## VFS Metadata If you use the `--vfs-metadata-extension` flag you can get the VFS to expose files which contain the [metadata](https://rclone.org/docs/#metadata) as a JSON blob. These files will not appear in the directory listing, but can be `stat`-ed and opened and once they have been they **will** appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the `--metadata` flag. For example, using `rclone mount` with `--metadata --vfs-metadata-extension .metadata` we get ``` $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata ``` If the file has no metadata it will be returned as `{}` and if there is an error reading the metadata the error will be returned as `{"error":"error string"}`. ``` rclone mount remote:path /path/to/mountpoint [flags] ``` ## Options ``` --allow-non-empty Allow mounting over a non-empty directory (not supported on Windows) --allow-other Allow access to other users (not supported on Windows) --allow-root Allow access to root user (not supported on Windows) --async-read Use asynchronous reads (not supported on Windows) (default true) --attr-timeout Duration Time for which file/directory attributes are cached (default 1s) --daemon Run mount in background and exit parent process (as background output is suppressed, use --log-file with --log-format=pid,... to monitor) (not supported on Windows) --daemon-timeout Duration Time limit for rclone to respond to kernel (not supported on Windows) (default 0s) --daemon-wait Duration Time to wait for ready mount from daemon (maximum time on Linux, constant sleep time on OSX/BSD) (not supported on Windows) (default 1m0s) --debug-fuse Debug the FUSE internals - needs -v --default-permissions Makes kernel enforce access control based on the file mode (not supported on Windows) --devname string Set the device name - default is remote:path --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --direct-io Use Direct IO, disables caching of data --file-perms FileMode File permissions (default 666) --fuse-flag stringArray Flags or arguments to be passed direct to libfuse/WinFsp (repeat if required) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for mount --link-perms FileMode Link permissions (default 666) --max-read-ahead SizeSuffix The number of bytes that can be prefetched for sequential reads (not supported on Windows) (default 128Ki) --mount-case-insensitive Tristate Tell the OS the mount is case insensitive (true) or sensitive (false) regardless of the backend (auto) (default unset) --network-mode Mount as remote network drive, instead of fixed disk drive (supported on Windows only) --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --noappledouble Ignore Apple Double (._) and .DS_Store files (supported on OSX only) (default true) --noapplexattr Ignore all "com.apple.*" extended attributes (supported on OSX only) -o, --option stringArray Option for libfuse/WinFsp (repeat if required) --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) --volname string Set the volume name (supported on Windows and OSX only) --write-back-cache Makes kernel buffer writes before sending them to rclone (without this, writethrough caching is used) (not supported on Windows) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone moveto Move file or directory from source to dest. ## Synopsis If source:path is a file or directory then it moves it to a file or directory named dest:path. This can be used to rename files or upload single files to other than their existing name. If the source is a directory then it acts exactly like the [move](https://rclone.org/commands/rclone_move/) command. So rclone moveto src dst where src and dst are rclone paths, either remote:path or /path/to/local or C:\windows\path\if\on\windows. This will: if src is file move it to dst, overwriting an existing file if it exists if src is directory move it to dst, overwriting existing files if they exist see move command for full details This doesn't transfer files that are identical on src and dst, testing by size and modification time or MD5SUM. src will be deleted on successful transfer. **Important**: Since this can cause data loss, test first with the `--dry-run` or the `--interactive`/`-i` flag. **Note**: Use the `-P`/`--progress` flag to view real-time transfer statistics. # Logger Flags The `--differ`, `--missing-on-dst`, `--missing-on-src`, `--match` and `--error` flags write paths, one per line, to the file name (or stdout if it is `-`) supplied. What they write is described in the help below. For example `--differ` will write all paths which are present on both the source and destination but different. The `--combined` flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - `= path` means path was found in source and destination and was identical - `- path` means path was missing on the source, so only in the destination - `+ path` means path was missing on the destination, so only in the source - `* path` means path was present in source and destination but different. - `! path` means there was an error reading or hashing the source or dest. The `--dest-after` flag writes a list file using the same format flags as [`lsf`](https://rclone.org/commands/rclone_lsf/#synopsis) (including [customizable options for hash, modtime, etc.](https://rclone.org/commands/rclone_lsf/#synopsis)) Conceptually it is similar to rsync's `--itemize-changes`, but not identical -- it should output an accurate list of what will be on the destination after the command is finished. When the `--no-traverse` flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing. Note that these logger flags have a few limitations, and certain scenarios are not currently supported: - `--max-duration` / `CutoffModeHard` - `--compare-dest` / `--copy-dest` - server-side moves of an entire dir at once - High-level retries, because there would be duplicates (use `--retries 1` to disable) - Possibly some unusual error scenarios Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.) ``` rclone moveto source:path dest:path [flags] ``` ## Options ``` --absolute Put a leading / in front of path names --combined string Make a combined report of changes to this file --csv Output in CSV format --dest-after string Report all files that exist on the dest post-sync --differ string Report all non-matching files to this file -d, --dir-slash Append a slash to directory names (default true) --dirs-only Only list directories --error string Report all files with errors (hashing or reading) to this file --files-only Only list files (default true) -F, --format string Output format - see lsf help for details (default "p") --hash h Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5") -h, --help help for moveto --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file -s, --separator string Separator for the items in the format (default ";") -t, --timeformat string Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Copy Options Flags for anything which can copy a file ``` --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination ``` ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone ncdu Explore a remote with a text based user interface. ## Synopsis This displays a text based user interface allowing the navigation of a remote. It is most useful for answering the question - "What is using all my disk space?". To make the user interface it first scans the entire remote given and builds an in memory representation. rclone ncdu can be used during this scanning phase and you will see it building up the directory structure as it goes along. You can interact with the user interface using key presses, press '?' to toggle the help on and off. The supported keys are: ↑,↓ or k,j to Move →,l to enter ←,h to return g toggle graph c toggle counts a toggle average size in directory m toggle modified time u toggle human-readable format n,s,C,A,M sort by name,size,count,asize,mtime d delete file/directory v select file/directory V enter visual select mode D delete selected files/directories y copy current path to clipboard Y display current path ^L refresh screen (fix screen corruption) r recalculate file sizes ? to toggle help on and off ESC to close the menu box q/^c to quit Listed files/directories may be prefixed by a one-character flag, some of them combined with a description in brackets at end of line. These flags have the following meaning: e means this is an empty directory, i.e. contains no files (but may contain empty subdirectories) ~ means this is a directory where some of the files (possibly in subdirectories) have unknown size, and therefore the directory size may be underestimated (and average size inaccurate, as it is average of the files with known sizes). . means an error occurred while reading a subdirectory, and therefore the directory size may be underestimated (and average size inaccurate) ! means an error occurred while reading this directory This an homage to the [ncdu tool](https://dev.yorhel.nl/ncdu) but for rclone remotes. It is missing lots of features at the moment but is useful as it stands. Unlike ncdu it does not show excluded files. Note that it might take some time to delete big files/directories. The UI won't respond in the meantime since the deletion is done synchronously. For a non-interactive listing of the remote, see the [tree](https://rclone.org/commands/rclone_tree/) command. To just get the total size of the remote you can also use the [size](https://rclone.org/commands/rclone_size/) command. ``` rclone ncdu remote:path [flags] ``` ## Options ``` -h, --help help for ncdu ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone nfsmount Mount the remote as file system on a mountpoint. ## Synopsis Rclone nfsmount allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE. First set up your remote using `rclone config`. Check it works with `rclone ls` etc. On Linux and macOS, you can run mount in either foreground or background (aka daemon) mode. Mount runs in foreground mode by default. Use the `--daemon` flag to force background mode. On Windows you can run mount in foreground only, the flag is ignored. In background mode rclone acts as a generic Unix mount program: the main program starts, spawns background rclone process to setup and maintain the mount, waits until success or timeout and exits with appropriate code (killing the child process if it fails). On Linux/macOS/FreeBSD start the mount like this, where `/path/to/local/mount` is an **empty** **existing** directory: rclone nfsmount remote:path/to/files /path/to/local/mount On Windows you can start a mount in different ways. See [below](#mounting-modes-on-windows) for details. If foreground mount is used interactively from a console window, rclone will serve the mount and occupy the console so another window should be used to work with the mount until rclone is interrupted e.g. by pressing Ctrl-C. The following examples will mount to an automatically assigned drive, to specific drive letter `X:`, to path `C:\path\parent\mount` (where parent directory or drive must exist, and mount must **not** exist, and is not supported when [mounting as a network drive](#mounting-modes-on-windows)), and the last example will mount as network share `\\cloud\remote` and map it to an automatically assigned drive: rclone nfsmount remote:path/to/files * rclone nfsmount remote:path/to/files X: rclone nfsmount remote:path/to/files C:\path\parent\mount rclone nfsmount remote:path/to/files \\cloud\remote When the program ends while in foreground mode, either via Ctrl+C or receiving a SIGINT or SIGTERM signal, the mount should be automatically stopped. When running in background mode the user will have to stop the mount manually: # Linux fusermount -u /path/to/local/mount #... or on some systems fusermount3 -u /path/to/local/mount # OS X or Linux when using nfsmount umount /path/to/local/mount The umount operation can fail, for example when the mountpoint is busy. When that happens, it is the user's responsibility to stop the mount manually. The size of the mounted file system will be set according to information retrieved from the remote, the same as returned by the [rclone about](https://rclone.org/commands/rclone_about/) command. Remotes with unlimited storage may report the used size only, then an additional 1 PiB of free space is assumed. If the remote does not [support](https://rclone.org/overview/#optional-features) the about feature at all, then 1 PiB is set as both the total and the free size. ## Installing on Windows To run rclone nfsmount on Windows, you will need to download and install [WinFsp](http://www.secfs.net/winfsp/). [WinFsp](https://github.com/winfsp/winfsp) is an open-source Windows File System Proxy which makes it easy to write user space file systems for Windows. It provides a FUSE emulation layer which rclone uses combination with [cgofuse](https://github.com/winfsp/cgofuse). Both of these packages are by Bill Zissimopoulos who was very helpful during the implementation of rclone nfsmount for Windows. ### Mounting modes on windows Unlike other operating systems, Microsoft Windows provides a different filesystem type for network and fixed drives. It optimises access on the assumption fixed disk drives are fast and reliable, while network drives have relatively high latency and less reliability. Some settings can also be differentiated between the two types, for example that Windows Explorer should just display icons and not create preview thumbnails for image and video files on network drives. In most cases, rclone will mount the remote as a normal, fixed disk drive by default. However, you can also choose to mount it as a remote network drive, often described as a network share. If you mount an rclone remote using the default, fixed drive mode and experience unexpected program errors, freezes or other issues, consider mounting as a network drive instead. When mounting as a fixed disk drive you can either mount to an unused drive letter, or to a path representing a **nonexistent** subdirectory of an **existing** parent directory or drive. Using the special value `*` will tell rclone to automatically assign the next available drive letter, starting with Z: and moving backward. Examples: rclone nfsmount remote:path/to/files * rclone nfsmount remote:path/to/files X: rclone nfsmount remote:path/to/files C:\path\parent\mount rclone nfsmount remote:path/to/files X: Option `--volname` can be used to set a custom volume name for the mounted file system. The default is to use the remote name and path. To mount as network drive, you can add option `--network-mode` to your nfsmount command. Mounting to a directory path is not supported in this mode, it is a limitation Windows imposes on junctions, so the remote must always be mounted to a drive letter. rclone nfsmount remote:path/to/files X: --network-mode A volume name specified with `--volname` will be used to create the network share path. A complete UNC path, such as `\\cloud\remote`, optionally with path `\\cloud\remote\madeup\path`, will be used as is. Any other string will be used as the share part, after a default prefix `\\server\`. If no volume name is specified then `\\server\share` will be used. You must make sure the volume name is unique when you are mounting more than one drive, or else the mount command will fail. The share name will treated as the volume label for the mapped drive, shown in Windows Explorer etc, while the complete `\\server\share` will be reported as the remote UNC path by `net use` etc, just like a normal network drive mapping. If you specify a full network share UNC path with `--volname`, this will implicitly set the `--network-mode` option, so the following two examples have same result: rclone nfsmount remote:path/to/files X: --network-mode rclone nfsmount remote:path/to/files X: --volname \\server\share You may also specify the network share UNC path as the mountpoint itself. Then rclone will automatically assign a drive letter, same as with `*` and use that as mountpoint, and instead use the UNC path specified as the volume name, as if it were specified with the `--volname` option. This will also implicitly set the `--network-mode` option. This means the following two examples have same result: rclone nfsmount remote:path/to/files \\cloud\remote rclone nfsmount remote:path/to/files * --volname \\cloud\remote There is yet another way to enable network mode, and to set the share path, and that is to pass the "native" libfuse/WinFsp option directly: `--fuse-flag --VolumePrefix=\server\share`. Note that the path must be with just a single backslash prefix in this case. *Note:* In previous versions of rclone this was the only supported method. [Read more about drive mapping](https://en.wikipedia.org/wiki/Drive_mapping) See also [Limitations](#limitations) section below. ### Windows filesystem permissions The FUSE emulation layer on Windows must convert between the POSIX-based permission model used in FUSE, and the permission model used in Windows, based on access-control lists (ACL). The mounted filesystem will normally get three entries in its access-control list (ACL), representing permissions for the POSIX permission scopes: Owner, group and others. By default, the owner and group will be taken from the current user, and the built-in group "Everyone" will be used to represent others. The user/group can be customized with FUSE options "UserName" and "GroupName", e.g. `-o UserName=user123 -o GroupName="Authenticated Users"`. The permissions on each entry will be set according to [options](#options) `--dir-perms` and `--file-perms`, which takes a value in traditional Unix [numeric notation](https://en.wikipedia.org/wiki/File-system_permissions#Numeric_notation). The default permissions corresponds to `--file-perms 0666 --dir-perms 0777`, i.e. read and write permissions to everyone. This means you will not be able to start any programs from the mount. To be able to do that you must add execute permissions, e.g. `--file-perms 0777 --dir-perms 0777` to add it to everyone. If the program needs to write files, chances are you will have to enable [VFS File Caching](#vfs-file-caching) as well (see also [limitations](#limitations)). Note that the default write permission have some restrictions for accounts other than the owner, specifically it lacks the "write extended attributes", as explained next. The mapping of permissions is not always trivial, and the result you see in Windows Explorer may not be exactly like you expected. For example, when setting a value that includes write access for the group or others scope, this will be mapped to individual permissions "write attributes", "write data" and "append data", but not "write extended attributes". Windows will then show this as basic permission "Special" instead of "Write", because "Write" also covers the "write extended attributes" permission. When setting digit 0 for group or others, to indicate no permissions, they will still get individual permissions "read attributes", "read extended attributes" and "read permissions". This is done for compatibility reasons, e.g. to allow users without additional permissions to be able to read basic metadata about files like in Unix. WinFsp 2021 (version 1.9) introduced a new FUSE option "FileSecurity", that allows the complete specification of file security descriptors using [SDDL](https://docs.microsoft.com/en-us/windows/win32/secauthz/security-descriptor-string-format). With this you get detailed control of the resulting permissions, compared to use of the POSIX permissions described above, and no additional permissions will be added automatically for compatibility with Unix. Some example use cases will following. If you set POSIX permissions for only allowing access to the owner, using `--file-perms 0600 --dir-perms 0700`, the user group and the built-in "Everyone" group will still be given some special permissions, as described above. Some programs may then (incorrectly) interpret this as the file being accessible by everyone, for example an SSH client may warn about "unprotected private key file". You can work around this by specifying `-o FileSecurity="D:P(A;;FA;;;OW)"`, which sets file all access (FA) to the owner (OW), and nothing else. When setting write permissions then, except for the owner, this does not include the "write extended attributes" permission, as mentioned above. This may prevent applications from writing to files, giving permission denied error instead. To set working write permissions for the built-in "Everyone" group, similar to what it gets by default but with the addition of the "write extended attributes", you can specify `-o FileSecurity="D:P(A;;FRFW;;;WD)"`, which sets file read (FR) and file write (FW) to everyone (WD). If file execute (FX) is also needed, then change to `-o FileSecurity="D:P(A;;FRFWFX;;;WD)"`, or set file all access (FA) to get full access permissions, including delete, with `-o FileSecurity="D:P(A;;FA;;;WD)"`. ### Windows caveats Drives created as Administrator are not visible to other accounts, not even an account that was elevated to Administrator with the User Account Control (UAC) feature. A result of this is that if you mount to a drive letter from a Command Prompt run as Administrator, and then try to access the same drive from Windows Explorer (which does not run as Administrator), you will not be able to see the mounted drive. If you don't need to access the drive from applications running with administrative privileges, the easiest way around this is to always create the mount from a non-elevated command prompt. To make mapped drives available to the user account that created them regardless if elevated or not, there is a special Windows setting called [linked connections](https://docs.microsoft.com/en-us/troubleshoot/windows-client/networking/mapped-drives-not-available-from-elevated-command#detail-to-configure-the-enablelinkedconnections-registry-entry) that can be enabled. It is also possible to make a drive mount available to everyone on the system, by running the process creating it as the built-in SYSTEM account. There are several ways to do this: One is to use the command-line utility [PsExec](https://docs.microsoft.com/en-us/sysinternals/downloads/psexec), from Microsoft's Sysinternals suite, which has option `-s` to start processes as the SYSTEM account. Another alternative is to run the mount command from a Windows Scheduled Task, or a Windows Service, configured to run as the SYSTEM account. A third alternative is to use the [WinFsp.Launcher infrastructure](https://github.com/winfsp/winfsp/wiki/WinFsp-Service-Architecture)). Read more in the [install documentation](https://rclone.org/install/). Note that when running rclone as another user, it will not use the configuration file from your profile unless you tell it to with the [`--config`](https://rclone.org/docs/#config-string) option. Note also that it is now the SYSTEM account that will have the owner permissions, and other accounts will have permissions according to the group or others scopes. As mentioned above, these will then not get the "write extended attributes" permission, and this may prevent writing to files. You can work around this with the FileSecurity option, see example above. Note that mapping to a directory path, instead of a drive letter, does not suffer from the same limitations. ## Mounting on macOS Mounting on macOS can be done either via [built-in NFS server](https://rclone.org/commands/rclone_serve_nfs/), [macFUSE](https://osxfuse.github.io/) (also known as osxfuse) or [FUSE-T](https://www.fuse-t.org/). macFUSE is a traditional FUSE driver utilizing a macOS kernel extension (kext). FUSE-T is an alternative FUSE system which "mounts" via an NFSv4 local server. #### Unicode Normalization It is highly recommended to keep the default of `--no-unicode-normalization=false` for all `mount` and `serve` commands on macOS. For details, see [vfs-case-sensitivity](https://rclone.org/commands/rclone_mount/#vfs-case-sensitivity). ### NFS mount This method spins up an NFS server using [serve nfs](https://rclone.org/commands/rclone_serve_nfs/) command and mounts it to the specified mountpoint. If you run this in background mode using |--daemon|, you will need to send SIGTERM signal to the rclone process using |kill| command to stop the mount. Note that `--nfs-cache-handle-limit` controls the maximum number of cached file handles stored by the `nfsmount` caching handler. This should not be set too low or you may experience errors when trying to access files. The default is 1000000, but consider lowering this limit if the server's system resource usage causes problems. ### macFUSE Notes If installing macFUSE using [dmg packages](https://github.com/osxfuse/osxfuse/releases) from the website, rclone will locate the macFUSE libraries without any further intervention. If however, macFUSE is installed using the [macports](https://www.macports.org/) package manager, the following addition steps are required. sudo mkdir /usr/local/lib cd /usr/local/lib sudo ln -s /opt/local/lib/libfuse.2.dylib ### FUSE-T Limitations, Caveats, and Notes There are some limitations, caveats, and notes about how it works. These are current as of FUSE-T version 1.0.14. #### ModTime update on read As per the [FUSE-T wiki](https://github.com/macos-fuse-t/fuse-t/wiki#caveats): > File access and modification times cannot be set separately as it seems to be an > issue with the NFS client which always modifies both. Can be reproduced with > 'touch -m' and 'touch -a' commands This means that viewing files with various tools, notably macOS Finder, will cause rlcone to update the modification time of the file. This may make rclone upload a full new copy of the file. #### Read Only mounts When mounting with `--read-only`, attempts to write to files will fail *silently* as opposed to with a clear warning as in macFUSE. ## Limitations Without the use of `--vfs-cache-mode` this can only write files sequentially, it can only seek when reading. This means that many applications won't work with their files on an rclone mount without `--vfs-cache-mode writes` or `--vfs-cache-mode full`. See the [VFS File Caching](#vfs-file-caching) section for more info. When using NFS mount on macOS, if you don't specify |--vfs-cache-mode| the mount point will be read-only. Bucket-based remotes - Azure Blob, Swift, S3, Google Cloud Storage and B2 - can't store empty directories. Of these, only Azure Blob, Google Cloud Storage and S3 can preserve them when you add `--xxx-directory_markers`; otherwise, empty directories will vanish once they drop out of the directory cache. When `rclone mount` is invoked on Unix with `--daemon` flag, the main rclone program will wait for the background mount to become ready or until the timeout specified by the `--daemon-wait` flag. On Linux it can check mount status using ProcFS so the flag in fact sets **maximum** time to wait, while the real wait can be less. On macOS / BSD the time to wait is constant and the check is performed only at the end. We advise you to set wait time on macOS reasonably. Only supported on Linux, FreeBSD, OS X and Windows at the moment. ## rclone nfsmount vs rclone sync/copy File systems expect things to be 100% reliable, whereas cloud storage systems are a long way from 100% reliable. The rclone sync/copy commands cope with this with lots of retries. However rclone nfsmount can't use retries in the same way without making local copies of the uploads. Look at the [VFS File Caching](#vfs-file-caching) for solutions to make nfsmount more reliable. ## Attribute caching You can use the flag `--attr-timeout` to set the time the kernel caches the attributes (size, modification time, etc.) for directory entries. The default is `1s` which caches files just long enough to avoid too many callbacks to rclone from the kernel. In theory 0s should be the correct value for filesystems which can change outside the control of the kernel. However this causes quite a few problems such as [rclone using too much memory](https://github.com/rclone/rclone/issues/2157), [rclone not serving files to samba](https://forum.rclone.org/t/rclone-1-39-vs-1-40-mount-issue/5112) and [excessive time listing directories](https://github.com/rclone/rclone/issues/2095#issuecomment-371141147). The kernel can cache the info about a file for the time given by `--attr-timeout`. You may see corruption if the remote file changes length during this window. It will show up as either a truncated file or a file with garbage on the end. With `--attr-timeout 1s` this is very unlikely but not impossible. The higher you set `--attr-timeout` the more likely it is. The default setting of "1s" is the lowest setting which mitigates the problems above. If you set it higher (`10s` or `1m` say) then the kernel will call back to rclone less often making it more efficient, however there is more chance of the corruption issue above. If files don't change on the remote outside of the control of rclone then there is no chance of corruption. This is the same as setting the attr_timeout option in mount.fuse. ## Filters Note that all the rclone filters can be used to select a subset of the files to be visible in the mount. ## systemd When running rclone nfsmount as a systemd service, it is possible to use Type=notify. In this case the service will enter the started state after the mountpoint has been successfully set up. Units having the rclone nfsmount service specified as a requirement will see all files and folders immediately in this mode. Note that systemd runs mount units without any environment variables including `PATH` or `HOME`. This means that tilde (`~`) expansion will not work and you should provide `--config` and `--cache-dir` explicitly as absolute paths via rclone arguments. Since mounting requires the `fusermount` or `fusermount3` program, rclone will use the fallback PATH of `/bin:/usr/bin` in this scenario. Please ensure that `fusermount`/`fusermount3` is present on this PATH. ## Rclone as Unix mount helper The core Unix program `/bin/mount` normally takes the `-t FSTYPE` argument then runs the `/sbin/mount.FSTYPE` helper program passing it mount options as `-o key=val,...` or `--opt=...`. Automount (classic or systemd) behaves in a similar way. rclone by default expects GNU-style flags `--key val`. To run it as a mount helper you should symlink rclone binary to `/sbin/mount.rclone` and optionally `/usr/bin/rclonefs`, e.g. `ln -s /usr/bin/rclone /sbin/mount.rclone`. rclone will detect it and translate command-line arguments appropriately. Now you can run classic mounts like this: ``` mount sftp1:subdir /mnt/data -t rclone -o vfs_cache_mode=writes,sftp_key_file=/path/to/pem ``` or create systemd mount units: ``` # /etc/systemd/system/mnt-data.mount [Unit] Description=Mount for /mnt/data [Mount] Type=rclone What=sftp1:subdir Where=/mnt/data Options=rw,_netdev,allow_other,args2env,vfs-cache-mode=writes,config=/etc/rclone.conf,cache-dir=/var/rclone ``` optionally accompanied by systemd automount unit ``` # /etc/systemd/system/mnt-data.automount [Unit] Description=AutoMount for /mnt/data [Automount] Where=/mnt/data TimeoutIdleSec=600 [Install] WantedBy=multi-user.target ``` or add in `/etc/fstab` a line like ``` sftp1:subdir /mnt/data rclone rw,noauto,nofail,_netdev,x-systemd.automount,args2env,vfs_cache_mode=writes,config=/etc/rclone.conf,cache_dir=/var/cache/rclone 0 0 ``` or use classic Automountd. Remember to provide explicit `config=...,cache-dir=...` as a workaround for mount units being run without `HOME`. Rclone in the mount helper mode will split `-o` argument(s) by comma, replace `_` by `-` and prepend `--` to get the command-line flags. Options containing commas or spaces can be wrapped in single or double quotes. Any inner quotes inside outer quotes of the same type should be doubled. Mount option syntax includes a few extra options treated specially: - `env.NAME=VALUE` will set an environment variable for the mount process. This helps with Automountd and Systemd.mount which don't allow setting custom environment for mount helpers. Typically you will use `env.HTTPS_PROXY=proxy.host:3128` or `env.HOME=/root` - `command=cmount` can be used to run `cmount` or any other rclone command rather than the default `mount`. - `args2env` will pass mount options to the mount helper running in background via environment variables instead of command line arguments. This allows to hide secrets from such commands as `ps` or `pgrep`. - `vv...` will be transformed into appropriate `--verbose=N` - standard mount options like `x-systemd.automount`, `_netdev`, `nosuid` and alike are intended only for Automountd and ignored by rclone. ## VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. ## VFS Directory Cache Using the `--dir-cache-time` flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a `SIGHUP` signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a [remote control](/rc) then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir ## VFS File Buffering The `--buffer-size` flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to `--buffer-size * open files`. ## VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with `-vv` rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with `--cache-dir` or setting the appropriate environment variable. The cache has 4 different modes selected by `--vfs-cache-mode`. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for `--vfs-write-back` seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using `--vfs-cache-max-size` or `--vfs-cache-min-free-space` note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every `--vfs-cache-poll-interval`. Secondly because open files cannot be evicted from the cache. When `--vfs-cache-max-size` or `--vfs-cache-min-free-space` is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The `--vfs-cache-max-age` will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You **should not** run two copies of rclone using the same VFS cache with the same or overlapping remotes if using `--vfs-cache-mode > off`. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with `--cache-dir`. You don't need to worry about this if the remotes in use don't overlap. ### --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible * Files can't be opened for both read AND write * Files opened for write can't be seeked * Existing files opened for write must have O_TRUNC set * Files open for read with O_TRUNC will be opened write only * Files open for write only will behave as if O_TRUNC was supplied * Open modes O_APPEND, O_TRUNC are ignored * If an upload fails it can't be retried ### --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible * Files opened for write only can't be seeked * Existing files opened for write must have O_TRUNC set * Files opened for write only will ignore O_APPEND, O_TRUNC * If an upload fails it can't be retried ### --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. ### --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to `--vfs-cache-mode` writes. When reading a file rclone will read `--buffer-size` plus `--vfs-read-ahead` bytes ahead. The `--buffer-size` is buffered in memory whereas the `--vfs-read-ahead` is buffered on disk. When using this mode it is recommended that `--buffer-size` is not set too large and `--vfs-read-ahead` is set large if required. **IMPORTANT** not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. ### Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example `hash` is slow with the `local` and `sftp` backends as they have to read the entire file and hash it, and `modtime` is slow with the `s3`, `swift`, `ftp` and `qinqstor` backends because they need to do an extra API call to fetch it. If you use the `--vfs-fast-fingerprint` flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over `local`, `s3` or `swift` backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. ## VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the `--vfs-read-chunk-streams` parameter. ### `--vfs-read-chunk-streams` == 0 Rclone will start reading a chunk of size `--vfs-read-chunk-size`, and then double the size for each read. When `--vfs-read-chunk-size-limit` is specified, and greater than `--vfs-read-chunk-size`, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With `--vfs-read-chunk-size 100M` and `--vfs-read-chunk-size-limit 0` the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When `--vfs-read-chunk-size-limit 500M` is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting `--vfs-read-chunk-size` to `0` or "off" disables chunked reading. The chunks will not be buffered in memory. ### `--vfs-read-chunk-streams` > 0 Rclone reads `--vfs-read-chunk-streams` chunks of size `--vfs-read-chunk-size` concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of `--vfs-read-chunk-size` and `--vfs-read-chunk-streams` as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be `--vfs-read-chunk-streams 16` and `--vfs-read-chunk-size 4M`. In testing with AWS S3 the performance scaled roughly as the `--vfs-read-chunk-streams` setting. Similar settings should work for high latency links, but depending on the latency they may need more `--vfs-read-chunk-streams` in order to get the throughput. ## VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the [chunked reading](#vfs-chunked-reading) feature. In particular S3 and Swift benefit hugely from the `--no-modtime` flag (or use `--use-server-modtime` for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (`--vfs-cache-mode` with value writes or full), the global flag `--transfers` can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag `--checkers` has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) ## Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink `link-to-file.txt` would be stored on cloud storage as `link-to-file.txt.rclonelink` and the contents would be the path to the symlink destination. Note that `--links` enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). `--vfs-links` just enables it for the VFS layer. This scheme is compatible with that used by the [local backend with the --local-links flag](https://rclone.org/local/#symlinks-junction-points). The `--vfs-links` flag has been designed for `rclone mount`, `rclone nfsmount` and `rclone serve nfs`. It hasn't been tested with the other `rclone serve` commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree ``` . ├── dir │   └── file.txt └── linked-dir -> dir ``` The VFS will correctly resolve `linked-dir` but not `linked-dir/file.txt`. This is not a problem for the tested commands but may be for other commands. **Note** that there is an outstanding issue with symlink support [issue #8245](https://github.com/rclone/rclone/issues/8245) with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). ## VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The `--vfs-case-insensitive` VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The `--no-unicode-normalization` flag controls whether a similar "fixup" is performed for filenames that differ but are [canonically equivalent](https://en.wikipedia.org/wiki/Unicode_equivalence) with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of `false` on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the `--vfs-block-norm-dupes` flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. `--vfs-block- norm-dupes` prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in `rclone sync`. ## VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) ## Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running `df` on the filesystem, then pass the flag `--vfs-used-is-size` to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to `rclone size` and compute the total used space itself. _WARNING._ Contrary to `rclone size`, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. ## VFS Metadata If you use the `--vfs-metadata-extension` flag you can get the VFS to expose files which contain the [metadata](https://rclone.org/docs/#metadata) as a JSON blob. These files will not appear in the directory listing, but can be `stat`-ed and opened and once they have been they **will** appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the `--metadata` flag. For example, using `rclone mount` with `--metadata --vfs-metadata-extension .metadata` we get ``` $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata ``` If the file has no metadata it will be returned as `{}` and if there is an error reading the metadata the error will be returned as `{"error":"error string"}`. ``` rclone nfsmount remote:path /path/to/mountpoint [flags] ``` ## Options ``` --addr string IPaddress:Port or :Port to bind server to --allow-non-empty Allow mounting over a non-empty directory (not supported on Windows) --allow-other Allow access to other users (not supported on Windows) --allow-root Allow access to root user (not supported on Windows) --async-read Use asynchronous reads (not supported on Windows) (default true) --attr-timeout Duration Time for which file/directory attributes are cached (default 1s) --daemon Run mount in background and exit parent process (as background output is suppressed, use --log-file with --log-format=pid,... to monitor) (not supported on Windows) --daemon-timeout Duration Time limit for rclone to respond to kernel (not supported on Windows) (default 0s) --daemon-wait Duration Time to wait for ready mount from daemon (maximum time on Linux, constant sleep time on OSX/BSD) (not supported on Windows) (default 1m0s) --debug-fuse Debug the FUSE internals - needs -v --default-permissions Makes kernel enforce access control based on the file mode (not supported on Windows) --devname string Set the device name - default is remote:path --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --direct-io Use Direct IO, disables caching of data --file-perms FileMode File permissions (default 666) --fuse-flag stringArray Flags or arguments to be passed direct to libfuse/WinFsp (repeat if required) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for nfsmount --link-perms FileMode Link permissions (default 666) --max-read-ahead SizeSuffix The number of bytes that can be prefetched for sequential reads (not supported on Windows) (default 128Ki) --mount-case-insensitive Tristate Tell the OS the mount is case insensitive (true) or sensitive (false) regardless of the backend (auto) (default unset) --network-mode Mount as remote network drive, instead of fixed disk drive (supported on Windows only) --nfs-cache-dir string The directory the NFS handle cache will use if set --nfs-cache-handle-limit int max file handles cached simultaneously (min 5) (default 1000000) --nfs-cache-type memory|disk|symlink Type of NFS handle cache to use (default memory) --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --noappledouble Ignore Apple Double (._) and .DS_Store files (supported on OSX only) (default true) --noapplexattr Ignore all "com.apple.*" extended attributes (supported on OSX only) -o, --option stringArray Option for libfuse/WinFsp (repeat if required) --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --sudo Use sudo to run the mount/umount commands as root. --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) --volname string Set the volume name (supported on Windows and OSX only) --write-back-cache Makes kernel buffer writes before sending them to rclone (without this, writethrough caching is used) (not supported on Windows) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone obscure Obscure password for use in the rclone config file. ## Synopsis In the rclone config file, human-readable passwords are obscured. Obscuring them is done by encrypting them and writing them out in base64. This is **not** a secure way of encrypting these passwords as rclone can decrypt them - it is to prevent "eyedropping" - namely someone seeing a password in the rclone config file by accident. Many equally important things (like access tokens) are not obscured in the config file. However it is very hard to shoulder surf a 64 character hex token. This command can also accept a password through STDIN instead of an argument by passing a hyphen as an argument. This will use the first line of STDIN as the password not including the trailing newline. echo "secretpassword" | rclone obscure - If there is no data on STDIN to read, rclone obscure will default to obfuscating the hyphen itself. If you want to encrypt the config file then please use config file encryption - see [rclone config](https://rclone.org/commands/rclone_config/) for more info. ``` rclone obscure password [flags] ``` ## Options ``` -h, --help help for obscure ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone rc Run a command against a running rclone. ## Synopsis This runs a command against a running rclone. Use the `--url` flag to specify an non default URL to connect on. This can be either a ":port" which is taken to mean "http://localhost:port" or a "host:port" which is taken to mean "http://host:port" A username and password can be passed in with `--user` and `--pass`. Note that `--rc-addr`, `--rc-user`, `--rc-pass` will be read also for `--url`, `--user`, `--pass`. The `--unix-socket` flag can be used to connect over a unix socket like this # start server on /tmp/my.socket rclone rcd --rc-addr unix:///tmp/my.socket # Connect to it rclone rc --unix-socket /tmp/my.socket core/stats Arguments should be passed in as parameter=value. The result will be returned as a JSON object by default. The `--json` parameter can be used to pass in a JSON blob as an input instead of key=value arguments. This is the only way of passing in more complicated values. The `-o`/`--opt` option can be used to set a key "opt" with key, value options in the form `-o key=value` or `-o key`. It can be repeated as many times as required. This is useful for rc commands which take the "opt" parameter which by convention is a dictionary of strings. -o key=value -o key2 Will place this in the "opt" value {"key":"value", "key2","") The `-a`/`--arg` option can be used to set strings in the "arg" value. It can be repeated as many times as required. This is useful for rc commands which take the "arg" parameter which by convention is a list of strings. -a value -a value2 Will place this in the "arg" value ["value", "value2"] Use `--loopback` to connect to the rclone instance running `rclone rc`. This is very useful for testing commands without having to run an rclone rc server, e.g.: rclone rc --loopback operations/about fs=/ Use `rclone rc` to see a list of all possible commands. ``` rclone rc commands parameter [flags] ``` ## Options ``` -a, --arg stringArray Argument placed in the "arg" array -h, --help help for rc --json string Input JSON - use instead of key=value args --loopback If set connect to this rclone instance not via HTTP --no-output If set, don't output the JSON result -o, --opt stringArray Option in the form name=value or name placed in the "opt" array --pass string Password to use to connect to rclone remote control --unix-socket string Path to a unix domain socket to dial to, instead of opening a TCP connection directly --url string URL to connect to rclone remote control (default "http://localhost:5572/") --user string Username to use to rclone remote control ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone rcat Copies standard input to file on remote. ## Synopsis Reads from standard input (stdin) and copies it to a single remote file. echo "hello world" | rclone rcat remote:path/to/file ffmpeg - | rclone rcat remote:path/to/file If the remote file already exists, it will be overwritten. rcat will try to upload small files in a single request, which is usually more efficient than the streaming/chunked upload endpoints, which use multiple requests. Exact behaviour depends on the remote. What is considered a small file may be set through `--streaming-upload-cutoff`. Uploading only starts after the cutoff is reached or if the file ends before that. The data must fit into RAM. The cutoff needs to be small enough to adhere the limits of your remote, please see there. Generally speaking, setting this cutoff too high will decrease your performance. Use the `--size` flag to preallocate the file in advance at the remote end and actually stream it, even if remote backend doesn't support streaming. `--size` should be the exact size of the input stream in bytes. If the size of the stream is different in length to the `--size` passed in then the transfer will likely fail. Note that the upload cannot be retried because the data is not stored. If the backend supports multipart uploading then individual chunks can be retried. If you need to transfer a lot of data, you may be better off caching it locally and then `rclone move` it to the destination which can use retries. ``` rclone rcat remote:path [flags] ``` ## Options ``` -h, --help help for rcat --size int File size hint to preallocate (default -1) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone rcd Run rclone listening to remote control commands only. ## Synopsis This runs rclone so that it only listens to remote control commands. This is useful if you are controlling rclone via the rc API. If you pass in a path to a directory, rclone will serve that directory for GET requests on the URL passed in. It will also open the URL in the browser when rclone is run. See the [rc documentation](https://rclone.org/rc/) for more info on the rc flags. ## Server options Use `--rc-addr` to specify which IP address and port the server should listen on, eg `--rc-addr 1.2.3.4:8000` or `--rc-addr :8080` to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port. If you set `--rc-addr` to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info. You can use a unix socket by setting the url to `unix:///path/to/socket` or just by using an absolute path name. `--rc-addr` may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same. `--rc-server-read-timeout` and `--rc-server-write-timeout` can be used to control the timeouts on the server. Note that this is the total time for a transfer. `--rc-max-header-bytes` controls the maximum number of bytes the server will accept in the HTTP header. `--rc-baseurl` controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used `--rc-baseurl "/rclone"` then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on `--rc-baseurl`, so `--rc-baseurl "rclone"`, `--rc-baseurl "/rclone"` and `--rc-baseurl "/rclone/"` are all treated identically. ### TLS (SSL) By default this will serve over http. If you want you can serve over https. You will need to supply the `--rc-cert` and `--rc-key` flags. If you wish to do client side certificate validation then you will need to supply `--rc-client-ca` also. `--rc-cert` must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. `--rc-key` must be set to the path of a file with the PEM encoded private key. If setting `--rc-client-ca`, it should be set to the path of a file with PEM encoded client certificate authority certificates. `--rc-min-tls-version` is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0"). ## Socket activation Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by `--rc-addr`). This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html Socket activation can be tested ad-hoc with the `systemd-socket-activate`command systemd-socket-activate -l 8000 -- rclone serve This will socket-activate rclone on the first connection to port 8000 over TCP. ### Template `--rc-template` allows a user to specify a custom markup template for HTTP and WebDAV serve functions. The server exports the following markup to be used within the template to server pages: | Parameter | Description | | :---------- | :---------- | | .Name | The full path of a file/directory. | | .Title | Directory listing of .Name | | .Sort | The current sort used. This is changeable via ?sort= parameter | | | Sort Options: namedirfirst,name,size,time (default namedirfirst) | | .Order | The current ordering used. This is changeable via ?order= parameter | | | Order Options: asc,desc (default asc) | | .Query | Currently unused. | | .Breadcrumb | Allows for creating a relative navigation | |-- .Link | The relative to the root link of the Text. | |-- .Text | The Name of the directory. | | .Entries | Information about a specific file/directory. | |-- .URL | The 'url' of an entry. | |-- .Leaf | Currently same as 'URL' but intended to be 'just' the name. | |-- .IsDir | Boolean for if an entry is a directory or not. | |-- .Size | Size in Bytes of the entry. | |-- .ModTime | The UTC timestamp of an entry. | The server also makes the following functions available so that they can be used within the template. These functions help extend the options for dynamic rendering of HTML. They can be used to render HTML based on specific conditions. | Function | Description | | :---------- | :---------- | | afterEpoch | Returns the time since the epoch for the given time. | | contains | Checks whether a given substring is present or not in a given string. | | hasPrefix | Checks whether the given string begins with the specified prefix. | | hasSuffix | Checks whether the given string end with the specified suffix. | ### Authentication By default this will serve files without needing a login. You can either use an htpasswd file which can take lots of users, or set a single username and password with the `--rc-user` and `--rc-pass` flags. Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with `--user-from-header` (e.g., `--rc---user-from-header=x-remote-user`). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access. If either of the above authentication methods is not configured and client certificates are required by the `--client-ca` flag passed to the server, the client certificate common name will be considered as the username. Use `--rc-htpasswd /path/to/htpasswd` to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended. To create an htpasswd file: touch htpasswd htpasswd -B htpasswd user htpasswd -B htpasswd anotherUser The password file can be updated while rclone is running. Use `--rc-realm` to set the authentication realm. Use `--rc-salt` to change the password hashing salt from the default. ``` rclone rcd * [flags] ``` ## Options ``` -h, --help help for rcd ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### RC Options Flags to control the Remote Control API ``` --rc Enable the remote control server --rc-addr stringArray IPaddress:Port or :Port to bind server to (default localhost:5572) --rc-allow-origin string Origin which cross-domain request (CORS) can be executed from --rc-baseurl string Prefix for URLs - leave blank for root --rc-cert string TLS PEM key (concatenation of certificate and CA certificate) --rc-client-ca string Client certificate authority to verify clients with --rc-enable-metrics Enable the Prometheus metrics path at the remote control server --rc-files string Path to local files to serve on the HTTP server --rc-htpasswd string A htpasswd file - if not provided no authentication is done --rc-job-expire-duration Duration Expire finished async jobs older than this value (default 1m0s) --rc-job-expire-interval Duration Interval to check for expired async jobs (default 10s) --rc-key string TLS PEM Private key --rc-max-header-bytes int Maximum size of request header (default 4096) --rc-min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --rc-no-auth Don't require auth for certain methods --rc-pass string Password for authentication --rc-realm string Realm for authentication --rc-salt string Password hashing salt (default "dlPL2MqE") --rc-serve Enable the serving of remote objects --rc-serve-no-modtime Don't read the modification time (can speed things up) --rc-server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --rc-server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --rc-template string User-specified template --rc-user string User name for authentication --rc-user-from-header string User name from a defined HTTP header --rc-web-fetch-url string URL to fetch the releases for webgui (default "https://api.github.com/repos/rclone/rclone-webui-react/releases/latest") --rc-web-gui Launch WebGUI on localhost --rc-web-gui-force-update Force update to latest version of web gui --rc-web-gui-no-open-browser Don't open the browser automatically --rc-web-gui-update Check and update to latest version of web gui ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone rmdirs Remove empty directories under the path. ## Synopsis This recursively removes any empty directories (including directories that only contain empty directories), that it finds under the path. The root path itself will also be removed if it is empty, unless you supply the `--leave-root` flag. Use command [rmdir](https://rclone.org/commands/rclone_rmdir/) to delete just the empty directory given by path, not recurse. This is useful for tidying up remotes that rclone has left a lot of empty directories in. For example the [delete](https://rclone.org/commands/rclone_delete/) command will delete files but leave the directory structure (unless used with option `--rmdirs`). This will delete `--checkers` directories concurrently so if you have thousands of empty directories consider increasing this number. To delete a path and any objects in it, use the [purge](https://rclone.org/commands/rclone_purge/) command. ``` rclone rmdirs remote:path [flags] ``` ## Options ``` -h, --help help for rmdirs --leave-root Do not remove root directory if empty ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone selfupdate Update the rclone binary. ## Synopsis This command downloads the latest release of rclone and replaces the currently running binary. The download is verified with a hashsum and cryptographically signed signature; see [the release signing docs](https://rclone.org/release_signing/) for details. If used without flags (or with implied `--stable` flag), this command will install the latest stable release. However, some issues may be fixed (or features added) only in the latest beta release. In such cases you should run the command with the `--beta` flag, i.e. `rclone selfupdate --beta`. You can check in advance what version would be installed by adding the `--check` flag, then repeat the command without it when you are satisfied. Sometimes the rclone team may recommend you a concrete beta or stable rclone release to troubleshoot your issue or add a bleeding edge feature. The `--version VER` flag, if given, will update to the concrete version instead of the latest one. If you omit micro version from `VER` (for example `1.53`), the latest matching micro version will be used. Upon successful update rclone will print a message that contains a previous version number. You will need it if you later decide to revert your update for some reason. Then you'll have to note the previous version and run the following command: `rclone selfupdate [--beta] OLDVER`. If the old version contains only dots and digits (for example `v1.54.0`) then it's a stable release so you won't need the `--beta` flag. Beta releases have an additional information similar to `v1.54.0-beta.5111.06f1c0c61`. (if you are a developer and use a locally built rclone, the version number will end with `-DEV`, you will have to rebuild it as it obviously can't be distributed). If you previously installed rclone via a package manager, the package may include local documentation or configure services. You may wish to update with the flag `--package deb` or `--package rpm` (whichever is correct for your OS) to update these too. This command with the default `--package zip` will update only the rclone executable so the local manual may become inaccurate after it. The [rclone mount](https://rclone.org/commands/rclone_mount/) command may or may not support extended FUSE options depending on the build and OS. `selfupdate` will refuse to update if the capability would be discarded. Note: Windows forbids deletion of a currently running executable so this command will rename the old executable to 'rclone.old.exe' upon success. Please note that this command was not available before rclone version 1.55. If it fails for you with the message `unknown command "selfupdate"` then you will need to update manually following the install instructions located at https://rclone.org/install/ ``` rclone selfupdate [flags] ``` ## Options ``` --beta Install beta release --check Check for latest release, do not download -h, --help help for selfupdate --output string Save the downloaded binary at a given path (default: replace running binary) --package string Package format: zip|deb|rpm (default: zip) --stable Install stable release (this is the default) --version string Install the given rclone version (default: latest) ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone serve Serve a remote over a protocol. ## Synopsis Serve a remote over a given protocol. Requires the use of a subcommand to specify the protocol, e.g. rclone serve http remote: Each subcommand has its own options which you can see in their help. ``` rclone serve [opts] [flags] ``` ## Options ``` -h, --help help for serve ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. * [rclone serve dlna](https://rclone.org/commands/rclone_serve_dlna/) - Serve remote:path over DLNA * [rclone serve docker](https://rclone.org/commands/rclone_serve_docker/) - Serve any remote on docker's volume plugin API. * [rclone serve ftp](https://rclone.org/commands/rclone_serve_ftp/) - Serve remote:path over FTP. * [rclone serve http](https://rclone.org/commands/rclone_serve_http/) - Serve the remote over HTTP. * [rclone serve nfs](https://rclone.org/commands/rclone_serve_nfs/) - Serve the remote as an NFS mount * [rclone serve restic](https://rclone.org/commands/rclone_serve_restic/) - Serve the remote for restic's REST API. * [rclone serve s3](https://rclone.org/commands/rclone_serve_s3/) - Serve remote:path over s3. * [rclone serve sftp](https://rclone.org/commands/rclone_serve_sftp/) - Serve the remote over SFTP. * [rclone serve webdav](https://rclone.org/commands/rclone_serve_webdav/) - Serve remote:path over WebDAV. # rclone serve dlna Serve remote:path over DLNA ## Synopsis Run a DLNA media server for media stored in an rclone remote. Many devices, such as the Xbox and PlayStation, can automatically discover this server in the LAN and play audio/video from it. VLC is also supported. Service discovery uses UDP multicast packets (SSDP) and will thus only work on LANs. Rclone will list all files present in the remote, without filtering based on media formats or file extensions. Additionally, there is no media transcoding support. This means that some players might show files that they are not able to play back correctly. Rclone will add external subtitle files (.srt) to videos if they have the same filename as the video file itself (except the extension), either in the same directory as the video, or in a "Subs" subdirectory. ## Server options Use `--addr` to specify which IP address and port the server should listen on, e.g. `--addr 1.2.3.4:8000` or `--addr :8080` to listen to all IPs. Use `--name` to choose the friendly server name, which is by default "rclone (hostname)". Use `--log-trace` in conjunction with `-vv` to enable additional debug logging of all UPNP traffic. ## VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. ## VFS Directory Cache Using the `--dir-cache-time` flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a `SIGHUP` signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a [remote control](/rc) then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir ## VFS File Buffering The `--buffer-size` flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to `--buffer-size * open files`. ## VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with `-vv` rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with `--cache-dir` or setting the appropriate environment variable. The cache has 4 different modes selected by `--vfs-cache-mode`. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for `--vfs-write-back` seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using `--vfs-cache-max-size` or `--vfs-cache-min-free-space` note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every `--vfs-cache-poll-interval`. Secondly because open files cannot be evicted from the cache. When `--vfs-cache-max-size` or `--vfs-cache-min-free-space` is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The `--vfs-cache-max-age` will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You **should not** run two copies of rclone using the same VFS cache with the same or overlapping remotes if using `--vfs-cache-mode > off`. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with `--cache-dir`. You don't need to worry about this if the remotes in use don't overlap. ### --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible * Files can't be opened for both read AND write * Files opened for write can't be seeked * Existing files opened for write must have O_TRUNC set * Files open for read with O_TRUNC will be opened write only * Files open for write only will behave as if O_TRUNC was supplied * Open modes O_APPEND, O_TRUNC are ignored * If an upload fails it can't be retried ### --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible * Files opened for write only can't be seeked * Existing files opened for write must have O_TRUNC set * Files opened for write only will ignore O_APPEND, O_TRUNC * If an upload fails it can't be retried ### --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. ### --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to `--vfs-cache-mode` writes. When reading a file rclone will read `--buffer-size` plus `--vfs-read-ahead` bytes ahead. The `--buffer-size` is buffered in memory whereas the `--vfs-read-ahead` is buffered on disk. When using this mode it is recommended that `--buffer-size` is not set too large and `--vfs-read-ahead` is set large if required. **IMPORTANT** not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. ### Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example `hash` is slow with the `local` and `sftp` backends as they have to read the entire file and hash it, and `modtime` is slow with the `s3`, `swift`, `ftp` and `qinqstor` backends because they need to do an extra API call to fetch it. If you use the `--vfs-fast-fingerprint` flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over `local`, `s3` or `swift` backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. ## VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the `--vfs-read-chunk-streams` parameter. ### `--vfs-read-chunk-streams` == 0 Rclone will start reading a chunk of size `--vfs-read-chunk-size`, and then double the size for each read. When `--vfs-read-chunk-size-limit` is specified, and greater than `--vfs-read-chunk-size`, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With `--vfs-read-chunk-size 100M` and `--vfs-read-chunk-size-limit 0` the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When `--vfs-read-chunk-size-limit 500M` is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting `--vfs-read-chunk-size` to `0` or "off" disables chunked reading. The chunks will not be buffered in memory. ### `--vfs-read-chunk-streams` > 0 Rclone reads `--vfs-read-chunk-streams` chunks of size `--vfs-read-chunk-size` concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of `--vfs-read-chunk-size` and `--vfs-read-chunk-streams` as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be `--vfs-read-chunk-streams 16` and `--vfs-read-chunk-size 4M`. In testing with AWS S3 the performance scaled roughly as the `--vfs-read-chunk-streams` setting. Similar settings should work for high latency links, but depending on the latency they may need more `--vfs-read-chunk-streams` in order to get the throughput. ## VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the [chunked reading](#vfs-chunked-reading) feature. In particular S3 and Swift benefit hugely from the `--no-modtime` flag (or use `--use-server-modtime` for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (`--vfs-cache-mode` with value writes or full), the global flag `--transfers` can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag `--checkers` has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) ## Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink `link-to-file.txt` would be stored on cloud storage as `link-to-file.txt.rclonelink` and the contents would be the path to the symlink destination. Note that `--links` enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). `--vfs-links` just enables it for the VFS layer. This scheme is compatible with that used by the [local backend with the --local-links flag](https://rclone.org/local/#symlinks-junction-points). The `--vfs-links` flag has been designed for `rclone mount`, `rclone nfsmount` and `rclone serve nfs`. It hasn't been tested with the other `rclone serve` commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree ``` . ├── dir │   └── file.txt └── linked-dir -> dir ``` The VFS will correctly resolve `linked-dir` but not `linked-dir/file.txt`. This is not a problem for the tested commands but may be for other commands. **Note** that there is an outstanding issue with symlink support [issue #8245](https://github.com/rclone/rclone/issues/8245) with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). ## VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The `--vfs-case-insensitive` VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The `--no-unicode-normalization` flag controls whether a similar "fixup" is performed for filenames that differ but are [canonically equivalent](https://en.wikipedia.org/wiki/Unicode_equivalence) with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of `false` on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the `--vfs-block-norm-dupes` flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. `--vfs-block- norm-dupes` prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in `rclone sync`. ## VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) ## Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running `df` on the filesystem, then pass the flag `--vfs-used-is-size` to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to `rclone size` and compute the total used space itself. _WARNING._ Contrary to `rclone size`, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. ## VFS Metadata If you use the `--vfs-metadata-extension` flag you can get the VFS to expose files which contain the [metadata](https://rclone.org/docs/#metadata) as a JSON blob. These files will not appear in the directory listing, but can be `stat`-ed and opened and once they have been they **will** appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the `--metadata` flag. For example, using `rclone mount` with `--metadata --vfs-metadata-extension .metadata` we get ``` $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata ``` If the file has no metadata it will be returned as `{}` and if there is an error reading the metadata the error will be returned as `{"error":"error string"}`. ``` rclone serve dlna remote:path [flags] ``` ## Options ``` --addr string The ip:port or :port to bind the DLNA http server to (default ":7879") --announce-interval Duration The interval between SSDP announcements (default 12m0s) --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --file-perms FileMode File permissions (default 666) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for dlna --interface stringArray The interface to use for SSDP (repeat as necessary) --link-perms FileMode Link permissions (default 666) --log-trace Enable trace logging of SOAP traffic --name string Name of DLNA server --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ## See Also * [rclone serve](https://rclone.org/commands/rclone_serve/) - Serve a remote over a protocol. # rclone serve docker Serve any remote on docker's volume plugin API. ## Synopsis This command implements the Docker volume plugin API allowing docker to use rclone as a data storage mechanism for various cloud providers. rclone provides [docker volume plugin](/docker) based on it. To create a docker plugin, one must create a Unix or TCP socket that Docker will look for when you use the plugin and then it listens for commands from docker daemon and runs the corresponding code when necessary. Docker plugins can run as a managed plugin under control of the docker daemon or as an independent native service. For testing, you can just run it directly from the command line, for example: ``` sudo rclone serve docker --base-dir /tmp/rclone-volumes --socket-addr localhost:8787 -vv ``` Running `rclone serve docker` will create the said socket, listening for commands from Docker to create the necessary Volumes. Normally you need not give the `--socket-addr` flag. The API will listen on the unix domain socket at `/run/docker/plugins/rclone.sock`. In the example above rclone will create a TCP socket and a small file `/etc/docker/plugins/rclone.spec` containing the socket address. We use `sudo` because both paths are writeable only by the root user. If you later decide to change listening socket, the docker daemon must be restarted to reconnect to `/run/docker/plugins/rclone.sock` or parse new `/etc/docker/plugins/rclone.spec`. Until you restart, any volume related docker commands will timeout trying to access the old socket. Running directly is supported on **Linux only**, not on Windows or MacOS. This is not a problem with managed plugin mode described in details in the [full documentation](https://rclone.org/docker). The command will create volume mounts under the path given by `--base-dir` (by default `/var/lib/docker-volumes/rclone` available only to root) and maintain the JSON formatted file `docker-plugin.state` in the rclone cache directory with book-keeping records of created and mounted volumes. All mount and VFS options are submitted by the docker daemon via API, but you can also provide defaults on the command line as well as set path to the config file and cache directory or adjust logging verbosity. ## VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. ## VFS Directory Cache Using the `--dir-cache-time` flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a `SIGHUP` signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a [remote control](/rc) then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir ## VFS File Buffering The `--buffer-size` flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to `--buffer-size * open files`. ## VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with `-vv` rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with `--cache-dir` or setting the appropriate environment variable. The cache has 4 different modes selected by `--vfs-cache-mode`. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for `--vfs-write-back` seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using `--vfs-cache-max-size` or `--vfs-cache-min-free-space` note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every `--vfs-cache-poll-interval`. Secondly because open files cannot be evicted from the cache. When `--vfs-cache-max-size` or `--vfs-cache-min-free-space` is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The `--vfs-cache-max-age` will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You **should not** run two copies of rclone using the same VFS cache with the same or overlapping remotes if using `--vfs-cache-mode > off`. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with `--cache-dir`. You don't need to worry about this if the remotes in use don't overlap. ### --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible * Files can't be opened for both read AND write * Files opened for write can't be seeked * Existing files opened for write must have O_TRUNC set * Files open for read with O_TRUNC will be opened write only * Files open for write only will behave as if O_TRUNC was supplied * Open modes O_APPEND, O_TRUNC are ignored * If an upload fails it can't be retried ### --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible * Files opened for write only can't be seeked * Existing files opened for write must have O_TRUNC set * Files opened for write only will ignore O_APPEND, O_TRUNC * If an upload fails it can't be retried ### --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. ### --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to `--vfs-cache-mode` writes. When reading a file rclone will read `--buffer-size` plus `--vfs-read-ahead` bytes ahead. The `--buffer-size` is buffered in memory whereas the `--vfs-read-ahead` is buffered on disk. When using this mode it is recommended that `--buffer-size` is not set too large and `--vfs-read-ahead` is set large if required. **IMPORTANT** not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. ### Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example `hash` is slow with the `local` and `sftp` backends as they have to read the entire file and hash it, and `modtime` is slow with the `s3`, `swift`, `ftp` and `qinqstor` backends because they need to do an extra API call to fetch it. If you use the `--vfs-fast-fingerprint` flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over `local`, `s3` or `swift` backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. ## VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the `--vfs-read-chunk-streams` parameter. ### `--vfs-read-chunk-streams` == 0 Rclone will start reading a chunk of size `--vfs-read-chunk-size`, and then double the size for each read. When `--vfs-read-chunk-size-limit` is specified, and greater than `--vfs-read-chunk-size`, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With `--vfs-read-chunk-size 100M` and `--vfs-read-chunk-size-limit 0` the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When `--vfs-read-chunk-size-limit 500M` is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting `--vfs-read-chunk-size` to `0` or "off" disables chunked reading. The chunks will not be buffered in memory. ### `--vfs-read-chunk-streams` > 0 Rclone reads `--vfs-read-chunk-streams` chunks of size `--vfs-read-chunk-size` concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of `--vfs-read-chunk-size` and `--vfs-read-chunk-streams` as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be `--vfs-read-chunk-streams 16` and `--vfs-read-chunk-size 4M`. In testing with AWS S3 the performance scaled roughly as the `--vfs-read-chunk-streams` setting. Similar settings should work for high latency links, but depending on the latency they may need more `--vfs-read-chunk-streams` in order to get the throughput. ## VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the [chunked reading](#vfs-chunked-reading) feature. In particular S3 and Swift benefit hugely from the `--no-modtime` flag (or use `--use-server-modtime` for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (`--vfs-cache-mode` with value writes or full), the global flag `--transfers` can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag `--checkers` has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) ## Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink `link-to-file.txt` would be stored on cloud storage as `link-to-file.txt.rclonelink` and the contents would be the path to the symlink destination. Note that `--links` enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). `--vfs-links` just enables it for the VFS layer. This scheme is compatible with that used by the [local backend with the --local-links flag](https://rclone.org/local/#symlinks-junction-points). The `--vfs-links` flag has been designed for `rclone mount`, `rclone nfsmount` and `rclone serve nfs`. It hasn't been tested with the other `rclone serve` commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree ``` . ├── dir │   └── file.txt └── linked-dir -> dir ``` The VFS will correctly resolve `linked-dir` but not `linked-dir/file.txt`. This is not a problem for the tested commands but may be for other commands. **Note** that there is an outstanding issue with symlink support [issue #8245](https://github.com/rclone/rclone/issues/8245) with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). ## VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The `--vfs-case-insensitive` VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The `--no-unicode-normalization` flag controls whether a similar "fixup" is performed for filenames that differ but are [canonically equivalent](https://en.wikipedia.org/wiki/Unicode_equivalence) with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of `false` on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the `--vfs-block-norm-dupes` flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. `--vfs-block- norm-dupes` prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in `rclone sync`. ## VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) ## Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running `df` on the filesystem, then pass the flag `--vfs-used-is-size` to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to `rclone size` and compute the total used space itself. _WARNING._ Contrary to `rclone size`, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. ## VFS Metadata If you use the `--vfs-metadata-extension` flag you can get the VFS to expose files which contain the [metadata](https://rclone.org/docs/#metadata) as a JSON blob. These files will not appear in the directory listing, but can be `stat`-ed and opened and once they have been they **will** appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the `--metadata` flag. For example, using `rclone mount` with `--metadata --vfs-metadata-extension .metadata` we get ``` $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata ``` If the file has no metadata it will be returned as `{}` and if there is an error reading the metadata the error will be returned as `{"error":"error string"}`. ``` rclone serve docker [flags] ``` ## Options ``` --allow-non-empty Allow mounting over a non-empty directory (not supported on Windows) --allow-other Allow access to other users (not supported on Windows) --allow-root Allow access to root user (not supported on Windows) --async-read Use asynchronous reads (not supported on Windows) (default true) --attr-timeout Duration Time for which file/directory attributes are cached (default 1s) --base-dir string Base directory for volumes (default "/var/lib/docker-volumes/rclone") --daemon Run mount in background and exit parent process (as background output is suppressed, use --log-file with --log-format=pid,... to monitor) (not supported on Windows) --daemon-timeout Duration Time limit for rclone to respond to kernel (not supported on Windows) (default 0s) --daemon-wait Duration Time to wait for ready mount from daemon (maximum time on Linux, constant sleep time on OSX/BSD) (not supported on Windows) (default 1m0s) --debug-fuse Debug the FUSE internals - needs -v --default-permissions Makes kernel enforce access control based on the file mode (not supported on Windows) --devname string Set the device name - default is remote:path --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --direct-io Use Direct IO, disables caching of data --file-perms FileMode File permissions (default 666) --forget-state Skip restoring previous state --fuse-flag stringArray Flags or arguments to be passed direct to libfuse/WinFsp (repeat if required) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for docker --link-perms FileMode Link permissions (default 666) --max-read-ahead SizeSuffix The number of bytes that can be prefetched for sequential reads (not supported on Windows) (default 128Ki) --mount-case-insensitive Tristate Tell the OS the mount is case insensitive (true) or sensitive (false) regardless of the backend (auto) (default unset) --network-mode Mount as remote network drive, instead of fixed disk drive (supported on Windows only) --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --no-spec Do not write spec file --noappledouble Ignore Apple Double (._) and .DS_Store files (supported on OSX only) (default true) --noapplexattr Ignore all "com.apple.*" extended attributes (supported on OSX only) -o, --option stringArray Option for libfuse/WinFsp (repeat if required) --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --socket-addr string Address or absolute path (default: /run/docker/plugins/rclone.sock) --socket-gid int GID for unix socket (default: current process GID) (default 1000) --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) --volname string Set the volume name (supported on Windows and OSX only) --write-back-cache Makes kernel buffer writes before sending them to rclone (without this, writethrough caching is used) (not supported on Windows) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ## See Also * [rclone serve](https://rclone.org/commands/rclone_serve/) - Serve a remote over a protocol. # rclone serve ftp Serve remote:path over FTP. ## Synopsis Run a basic FTP server to serve a remote over FTP protocol. This can be viewed with a FTP client or you can make a remote of type FTP to read and write it. ## Server options Use --addr to specify which IP address and port the server should listen on, e.g. --addr 1.2.3.4:8000 or --addr :8080 to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port. If you set --addr to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info. ### Authentication By default this will serve files without needing a login. You can set a single username and password with the --user and --pass flags. ## VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. ## VFS Directory Cache Using the `--dir-cache-time` flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a `SIGHUP` signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a [remote control](/rc) then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir ## VFS File Buffering The `--buffer-size` flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to `--buffer-size * open files`. ## VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with `-vv` rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with `--cache-dir` or setting the appropriate environment variable. The cache has 4 different modes selected by `--vfs-cache-mode`. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for `--vfs-write-back` seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using `--vfs-cache-max-size` or `--vfs-cache-min-free-space` note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every `--vfs-cache-poll-interval`. Secondly because open files cannot be evicted from the cache. When `--vfs-cache-max-size` or `--vfs-cache-min-free-space` is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The `--vfs-cache-max-age` will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You **should not** run two copies of rclone using the same VFS cache with the same or overlapping remotes if using `--vfs-cache-mode > off`. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with `--cache-dir`. You don't need to worry about this if the remotes in use don't overlap. ### --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible * Files can't be opened for both read AND write * Files opened for write can't be seeked * Existing files opened for write must have O_TRUNC set * Files open for read with O_TRUNC will be opened write only * Files open for write only will behave as if O_TRUNC was supplied * Open modes O_APPEND, O_TRUNC are ignored * If an upload fails it can't be retried ### --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible * Files opened for write only can't be seeked * Existing files opened for write must have O_TRUNC set * Files opened for write only will ignore O_APPEND, O_TRUNC * If an upload fails it can't be retried ### --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. ### --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to `--vfs-cache-mode` writes. When reading a file rclone will read `--buffer-size` plus `--vfs-read-ahead` bytes ahead. The `--buffer-size` is buffered in memory whereas the `--vfs-read-ahead` is buffered on disk. When using this mode it is recommended that `--buffer-size` is not set too large and `--vfs-read-ahead` is set large if required. **IMPORTANT** not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. ### Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example `hash` is slow with the `local` and `sftp` backends as they have to read the entire file and hash it, and `modtime` is slow with the `s3`, `swift`, `ftp` and `qinqstor` backends because they need to do an extra API call to fetch it. If you use the `--vfs-fast-fingerprint` flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over `local`, `s3` or `swift` backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. ## VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the `--vfs-read-chunk-streams` parameter. ### `--vfs-read-chunk-streams` == 0 Rclone will start reading a chunk of size `--vfs-read-chunk-size`, and then double the size for each read. When `--vfs-read-chunk-size-limit` is specified, and greater than `--vfs-read-chunk-size`, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With `--vfs-read-chunk-size 100M` and `--vfs-read-chunk-size-limit 0` the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When `--vfs-read-chunk-size-limit 500M` is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting `--vfs-read-chunk-size` to `0` or "off" disables chunked reading. The chunks will not be buffered in memory. ### `--vfs-read-chunk-streams` > 0 Rclone reads `--vfs-read-chunk-streams` chunks of size `--vfs-read-chunk-size` concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of `--vfs-read-chunk-size` and `--vfs-read-chunk-streams` as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be `--vfs-read-chunk-streams 16` and `--vfs-read-chunk-size 4M`. In testing with AWS S3 the performance scaled roughly as the `--vfs-read-chunk-streams` setting. Similar settings should work for high latency links, but depending on the latency they may need more `--vfs-read-chunk-streams` in order to get the throughput. ## VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the [chunked reading](#vfs-chunked-reading) feature. In particular S3 and Swift benefit hugely from the `--no-modtime` flag (or use `--use-server-modtime` for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (`--vfs-cache-mode` with value writes or full), the global flag `--transfers` can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag `--checkers` has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) ## Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink `link-to-file.txt` would be stored on cloud storage as `link-to-file.txt.rclonelink` and the contents would be the path to the symlink destination. Note that `--links` enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). `--vfs-links` just enables it for the VFS layer. This scheme is compatible with that used by the [local backend with the --local-links flag](https://rclone.org/local/#symlinks-junction-points). The `--vfs-links` flag has been designed for `rclone mount`, `rclone nfsmount` and `rclone serve nfs`. It hasn't been tested with the other `rclone serve` commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree ``` . ├── dir │   └── file.txt └── linked-dir -> dir ``` The VFS will correctly resolve `linked-dir` but not `linked-dir/file.txt`. This is not a problem for the tested commands but may be for other commands. **Note** that there is an outstanding issue with symlink support [issue #8245](https://github.com/rclone/rclone/issues/8245) with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). ## VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The `--vfs-case-insensitive` VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The `--no-unicode-normalization` flag controls whether a similar "fixup" is performed for filenames that differ but are [canonically equivalent](https://en.wikipedia.org/wiki/Unicode_equivalence) with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of `false` on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the `--vfs-block-norm-dupes` flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. `--vfs-block- norm-dupes` prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in `rclone sync`. ## VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) ## Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running `df` on the filesystem, then pass the flag `--vfs-used-is-size` to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to `rclone size` and compute the total used space itself. _WARNING._ Contrary to `rclone size`, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. ## VFS Metadata If you use the `--vfs-metadata-extension` flag you can get the VFS to expose files which contain the [metadata](https://rclone.org/docs/#metadata) as a JSON blob. These files will not appear in the directory listing, but can be `stat`-ed and opened and once they have been they **will** appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the `--metadata` flag. For example, using `rclone mount` with `--metadata --vfs-metadata-extension .metadata` we get ``` $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata ``` If the file has no metadata it will be returned as `{}` and if there is an error reading the metadata the error will be returned as `{"error":"error string"}`. ## Auth Proxy If you supply the parameter `--auth-proxy /path/to/program` then rclone will use that program to generate backends on the fly which then are used to authenticate incoming requests. This uses a simple JSON based protocol with input on STDIN and output on STDOUT. **PLEASE NOTE:** `--auth-proxy` and `--authorized-keys` cannot be used together, if `--auth-proxy` is set the authorized keys option will be ignored. There is an example program [bin/test_proxy.py](https://github.com/rclone/rclone/blob/master/bin/test_proxy.py) in the rclone source code. The program's job is to take a `user` and `pass` on the input and turn those into the config for a backend on STDOUT in JSON format. This config will have any default parameters for the backend added, but it won't use configuration from environment variables or command line options - it is the job of the proxy program to make a complete config. This config generated must have this extra parameter - `_root` - root to use for the backend And it may have this parameter - `_obscure` - comma separated strings for parameters to obscure If password authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: ``` { "user": "me", "pass": "mypassword" } ``` If public-key authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: ``` { "user": "me", "public_key": "AAAAB3NzaC1yc2EAAAADAQABAAABAQDuwESFdAe14hVS6omeyX7edc...JQdf" } ``` And as an example return this on STDOUT ``` { "type": "sftp", "_root": "", "_obscure": "pass", "user": "me", "pass": "mypassword", "host": "sftp.example.com" } ``` This would mean that an SFTP backend would be created on the fly for the `user` and `pass`/`public_key` returned in the output to the host given. Note that since `_obscure` is set to `pass`, rclone will obscure the `pass` parameter before creating the backend (which is required for sftp backends). The program can manipulate the supplied `user` in any way, for example to make proxy to many different sftp backends, you could make the `user` be `user@example.com` and then set the `host` to `example.com` in the output and the user to `user`. For security you'd probably want to restrict the `host` to a limited list. Note that an internal cache is keyed on `user` so only use that for configuration, don't use `pass` or `public_key`. This also means that if a user's password or public-key is changed the cache will need to expire (which takes 5 mins) before it takes effect. This can be used to build general purpose proxies to any kind of backend that rclone supports. ``` rclone serve ftp remote:path [flags] ``` ## Options ``` --addr string IPaddress:Port or :Port to bind server to (default "localhost:2121") --auth-proxy string A program to use to create the backend from the auth --cert string TLS PEM key (concatenation of certificate and CA certificate) --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --file-perms FileMode File permissions (default 666) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for ftp --key string TLS PEM Private key --link-perms FileMode Link permissions (default 666) --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --pass string Password for authentication (empty value allow every password) --passive-port string Passive port range to use (default "30000-32000") --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --public-ip string Public IP address to advertise for passive connections --read-only Only allow read-only access --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --user string User name for authentication (default "anonymous") --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ## See Also * [rclone serve](https://rclone.org/commands/rclone_serve/) - Serve a remote over a protocol. # rclone serve http Serve the remote over HTTP. ## Synopsis Run a basic web server to serve a remote over HTTP. This can be viewed in a web browser or you can make a remote of type http read from it. You can use the filter flags (e.g. `--include`, `--exclude`) to control what is served. The server will log errors. Use `-v` to see access logs. `--bwlimit` will be respected for file transfers. Use `--stats` to control the stats printing. ## Server options Use `--addr` to specify which IP address and port the server should listen on, eg `--addr 1.2.3.4:8000` or `--addr :8080` to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port. If you set `--addr` to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info. You can use a unix socket by setting the url to `unix:///path/to/socket` or just by using an absolute path name. `--addr` may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same. `--server-read-timeout` and `--server-write-timeout` can be used to control the timeouts on the server. Note that this is the total time for a transfer. `--max-header-bytes` controls the maximum number of bytes the server will accept in the HTTP header. `--baseurl` controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used `--baseurl "/rclone"` then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on `--baseurl`, so `--baseurl "rclone"`, `--baseurl "/rclone"` and `--baseurl "/rclone/"` are all treated identically. ### TLS (SSL) By default this will serve over http. If you want you can serve over https. You will need to supply the `--cert` and `--key` flags. If you wish to do client side certificate validation then you will need to supply `--client-ca` also. `--cert` must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. `--key` must be set to the path of a file with the PEM encoded private key. If setting `--client-ca`, it should be set to the path of a file with PEM encoded client certificate authority certificates. `--min-tls-version` is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0"). ## Socket activation Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by `--addr`). This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html Socket activation can be tested ad-hoc with the `systemd-socket-activate`command systemd-socket-activate -l 8000 -- rclone serve This will socket-activate rclone on the first connection to port 8000 over TCP. ### Template `--template` allows a user to specify a custom markup template for HTTP and WebDAV serve functions. The server exports the following markup to be used within the template to server pages: | Parameter | Description | | :---------- | :---------- | | .Name | The full path of a file/directory. | | .Title | Directory listing of .Name | | .Sort | The current sort used. This is changeable via ?sort= parameter | | | Sort Options: namedirfirst,name,size,time (default namedirfirst) | | .Order | The current ordering used. This is changeable via ?order= parameter | | | Order Options: asc,desc (default asc) | | .Query | Currently unused. | | .Breadcrumb | Allows for creating a relative navigation | |-- .Link | The relative to the root link of the Text. | |-- .Text | The Name of the directory. | | .Entries | Information about a specific file/directory. | |-- .URL | The 'url' of an entry. | |-- .Leaf | Currently same as 'URL' but intended to be 'just' the name. | |-- .IsDir | Boolean for if an entry is a directory or not. | |-- .Size | Size in Bytes of the entry. | |-- .ModTime | The UTC timestamp of an entry. | The server also makes the following functions available so that they can be used within the template. These functions help extend the options for dynamic rendering of HTML. They can be used to render HTML based on specific conditions. | Function | Description | | :---------- | :---------- | | afterEpoch | Returns the time since the epoch for the given time. | | contains | Checks whether a given substring is present or not in a given string. | | hasPrefix | Checks whether the given string begins with the specified prefix. | | hasSuffix | Checks whether the given string end with the specified suffix. | ### Authentication By default this will serve files without needing a login. You can either use an htpasswd file which can take lots of users, or set a single username and password with the `--user` and `--pass` flags. Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with `--user-from-header` (e.g., `----user-from-header=x-remote-user`). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access. If either of the above authentication methods is not configured and client certificates are required by the `--client-ca` flag passed to the server, the client certificate common name will be considered as the username. Use `--htpasswd /path/to/htpasswd` to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended. To create an htpasswd file: touch htpasswd htpasswd -B htpasswd user htpasswd -B htpasswd anotherUser The password file can be updated while rclone is running. Use `--realm` to set the authentication realm. Use `--salt` to change the password hashing salt from the default. ## VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. ## VFS Directory Cache Using the `--dir-cache-time` flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a `SIGHUP` signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a [remote control](/rc) then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir ## VFS File Buffering The `--buffer-size` flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to `--buffer-size * open files`. ## VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with `-vv` rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with `--cache-dir` or setting the appropriate environment variable. The cache has 4 different modes selected by `--vfs-cache-mode`. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for `--vfs-write-back` seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using `--vfs-cache-max-size` or `--vfs-cache-min-free-space` note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every `--vfs-cache-poll-interval`. Secondly because open files cannot be evicted from the cache. When `--vfs-cache-max-size` or `--vfs-cache-min-free-space` is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The `--vfs-cache-max-age` will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You **should not** run two copies of rclone using the same VFS cache with the same or overlapping remotes if using `--vfs-cache-mode > off`. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with `--cache-dir`. You don't need to worry about this if the remotes in use don't overlap. ### --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible * Files can't be opened for both read AND write * Files opened for write can't be seeked * Existing files opened for write must have O_TRUNC set * Files open for read with O_TRUNC will be opened write only * Files open for write only will behave as if O_TRUNC was supplied * Open modes O_APPEND, O_TRUNC are ignored * If an upload fails it can't be retried ### --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible * Files opened for write only can't be seeked * Existing files opened for write must have O_TRUNC set * Files opened for write only will ignore O_APPEND, O_TRUNC * If an upload fails it can't be retried ### --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. ### --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to `--vfs-cache-mode` writes. When reading a file rclone will read `--buffer-size` plus `--vfs-read-ahead` bytes ahead. The `--buffer-size` is buffered in memory whereas the `--vfs-read-ahead` is buffered on disk. When using this mode it is recommended that `--buffer-size` is not set too large and `--vfs-read-ahead` is set large if required. **IMPORTANT** not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. ### Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example `hash` is slow with the `local` and `sftp` backends as they have to read the entire file and hash it, and `modtime` is slow with the `s3`, `swift`, `ftp` and `qinqstor` backends because they need to do an extra API call to fetch it. If you use the `--vfs-fast-fingerprint` flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over `local`, `s3` or `swift` backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. ## VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the `--vfs-read-chunk-streams` parameter. ### `--vfs-read-chunk-streams` == 0 Rclone will start reading a chunk of size `--vfs-read-chunk-size`, and then double the size for each read. When `--vfs-read-chunk-size-limit` is specified, and greater than `--vfs-read-chunk-size`, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With `--vfs-read-chunk-size 100M` and `--vfs-read-chunk-size-limit 0` the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When `--vfs-read-chunk-size-limit 500M` is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting `--vfs-read-chunk-size` to `0` or "off" disables chunked reading. The chunks will not be buffered in memory. ### `--vfs-read-chunk-streams` > 0 Rclone reads `--vfs-read-chunk-streams` chunks of size `--vfs-read-chunk-size` concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of `--vfs-read-chunk-size` and `--vfs-read-chunk-streams` as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be `--vfs-read-chunk-streams 16` and `--vfs-read-chunk-size 4M`. In testing with AWS S3 the performance scaled roughly as the `--vfs-read-chunk-streams` setting. Similar settings should work for high latency links, but depending on the latency they may need more `--vfs-read-chunk-streams` in order to get the throughput. ## VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the [chunked reading](#vfs-chunked-reading) feature. In particular S3 and Swift benefit hugely from the `--no-modtime` flag (or use `--use-server-modtime` for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (`--vfs-cache-mode` with value writes or full), the global flag `--transfers` can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag `--checkers` has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) ## Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink `link-to-file.txt` would be stored on cloud storage as `link-to-file.txt.rclonelink` and the contents would be the path to the symlink destination. Note that `--links` enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). `--vfs-links` just enables it for the VFS layer. This scheme is compatible with that used by the [local backend with the --local-links flag](https://rclone.org/local/#symlinks-junction-points). The `--vfs-links` flag has been designed for `rclone mount`, `rclone nfsmount` and `rclone serve nfs`. It hasn't been tested with the other `rclone serve` commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree ``` . ├── dir │   └── file.txt └── linked-dir -> dir ``` The VFS will correctly resolve `linked-dir` but not `linked-dir/file.txt`. This is not a problem for the tested commands but may be for other commands. **Note** that there is an outstanding issue with symlink support [issue #8245](https://github.com/rclone/rclone/issues/8245) with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). ## VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The `--vfs-case-insensitive` VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The `--no-unicode-normalization` flag controls whether a similar "fixup" is performed for filenames that differ but are [canonically equivalent](https://en.wikipedia.org/wiki/Unicode_equivalence) with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of `false` on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the `--vfs-block-norm-dupes` flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. `--vfs-block- norm-dupes` prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in `rclone sync`. ## VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) ## Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running `df` on the filesystem, then pass the flag `--vfs-used-is-size` to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to `rclone size` and compute the total used space itself. _WARNING._ Contrary to `rclone size`, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. ## VFS Metadata If you use the `--vfs-metadata-extension` flag you can get the VFS to expose files which contain the [metadata](https://rclone.org/docs/#metadata) as a JSON blob. These files will not appear in the directory listing, but can be `stat`-ed and opened and once they have been they **will** appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the `--metadata` flag. For example, using `rclone mount` with `--metadata --vfs-metadata-extension .metadata` we get ``` $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata ``` If the file has no metadata it will be returned as `{}` and if there is an error reading the metadata the error will be returned as `{"error":"error string"}`. ## Auth Proxy If you supply the parameter `--auth-proxy /path/to/program` then rclone will use that program to generate backends on the fly which then are used to authenticate incoming requests. This uses a simple JSON based protocol with input on STDIN and output on STDOUT. **PLEASE NOTE:** `--auth-proxy` and `--authorized-keys` cannot be used together, if `--auth-proxy` is set the authorized keys option will be ignored. There is an example program [bin/test_proxy.py](https://github.com/rclone/rclone/blob/master/bin/test_proxy.py) in the rclone source code. The program's job is to take a `user` and `pass` on the input and turn those into the config for a backend on STDOUT in JSON format. This config will have any default parameters for the backend added, but it won't use configuration from environment variables or command line options - it is the job of the proxy program to make a complete config. This config generated must have this extra parameter - `_root` - root to use for the backend And it may have this parameter - `_obscure` - comma separated strings for parameters to obscure If password authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: ``` { "user": "me", "pass": "mypassword" } ``` If public-key authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: ``` { "user": "me", "public_key": "AAAAB3NzaC1yc2EAAAADAQABAAABAQDuwESFdAe14hVS6omeyX7edc...JQdf" } ``` And as an example return this on STDOUT ``` { "type": "sftp", "_root": "", "_obscure": "pass", "user": "me", "pass": "mypassword", "host": "sftp.example.com" } ``` This would mean that an SFTP backend would be created on the fly for the `user` and `pass`/`public_key` returned in the output to the host given. Note that since `_obscure` is set to `pass`, rclone will obscure the `pass` parameter before creating the backend (which is required for sftp backends). The program can manipulate the supplied `user` in any way, for example to make proxy to many different sftp backends, you could make the `user` be `user@example.com` and then set the `host` to `example.com` in the output and the user to `user`. For security you'd probably want to restrict the `host` to a limited list. Note that an internal cache is keyed on `user` so only use that for configuration, don't use `pass` or `public_key`. This also means that if a user's password or public-key is changed the cache will need to expire (which takes 5 mins) before it takes effect. This can be used to build general purpose proxies to any kind of backend that rclone supports. ``` rclone serve http remote:path [flags] ``` ## Options ``` --addr stringArray IPaddress:Port or :Port to bind server to (default 127.0.0.1:8080) --allow-origin string Origin which cross-domain request (CORS) can be executed from --auth-proxy string A program to use to create the backend from the auth --baseurl string Prefix for URLs - leave blank for root --cert string TLS PEM key (concatenation of certificate and CA certificate) --client-ca string Client certificate authority to verify clients with --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --file-perms FileMode File permissions (default 666) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for http --htpasswd string A htpasswd file - if not provided no authentication is done --key string TLS PEM Private key --link-perms FileMode Link permissions (default 666) --max-header-bytes int Maximum size of request header (default 4096) --min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --pass string Password for authentication --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --realm string Realm for authentication --salt string Password hashing salt (default "dlPL2MqE") --server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --template string User-specified template --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --user string User name for authentication --user-from-header string User name from a defined HTTP header --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ## See Also * [rclone serve](https://rclone.org/commands/rclone_serve/) - Serve a remote over a protocol. # rclone serve nfs Serve the remote as an NFS mount ## Synopsis Create an NFS server that serves the given remote over the network. This implements an NFSv3 server to serve any rclone remote via NFS. The primary purpose for this command is to enable the [mount command](https://rclone.org/commands/rclone_mount/) on recent macOS versions where installing FUSE is very cumbersome. This server does not implement any authentication so any client will be able to access the data. To limit access, you can use `serve nfs` on the loopback address or rely on secure tunnels (such as SSH) or use firewalling. For this reason, by default, a random TCP port is chosen and the loopback interface is used for the listening address by default; meaning that it is only available to the local machine. If you want other machines to access the NFS mount over local network, you need to specify the listening address and port using the `--addr` flag. Modifying files through the NFS protocol requires VFS caching. Usually you will need to specify `--vfs-cache-mode` in order to be able to write to the mountpoint (`full` is recommended). If you don't specify VFS cache mode, the mount will be read-only. `--nfs-cache-type` controls the type of the NFS handle cache. By default this is `memory` where new handles will be randomly allocated when needed. These are stored in memory. If the server is restarted the handle cache will be lost and connected NFS clients will get stale handle errors. `--nfs-cache-type disk` uses an on disk NFS handle cache. Rclone hashes the path of the object and stores it in a file named after the hash. These hashes are stored on disk the directory controlled by `--cache-dir` or the exact directory may be specified with `--nfs-cache-dir`. Using this means that the NFS server can be restarted at will without affecting the connected clients. `--nfs-cache-type symlink` is similar to `--nfs-cache-type disk` in that it uses an on disk cache, but the cache entries are held as symlinks. Rclone will use the handle of the underlying file as the NFS handle which improves performance. This sort of cache can't be backed up and restored as the underlying handles will change. This is Linux only. It requires running rclone as root or with `CAP_DAC_READ_SEARCH`. You can run rclone with this extra permission by doing this to the rclone binary `sudo setcap cap_dac_read_search+ep /path/to/rclone`. `--nfs-cache-handle-limit` controls the maximum number of cached NFS handles stored by the caching handler. This should not be set too low or you may experience errors when trying to access files. The default is `1000000`, but consider lowering this limit if the server's system resource usage causes problems. This is only used by the `memory` type cache. To serve NFS over the network use following command: rclone serve nfs remote: --addr 0.0.0.0:$PORT --vfs-cache-mode=full This specifies a port that can be used in the mount command. To mount the server under Linux/macOS, use the following command: mount -t nfs -o port=$PORT,mountport=$PORT,tcp $HOSTNAME:/ path/to/mountpoint Where `$PORT` is the same port number used in the `serve nfs` command and `$HOSTNAME` is the network address of the machine that `serve nfs` was run on. If `--vfs-metadata-extension` is in use then for the `--nfs-cache-type disk` and `--nfs-cache-type cache` the metadata files will have the file handle of their parent file suffixed with `0x00, 0x00, 0x00, 0x01`. This means they can be looked up directly from the parent file handle is desired. This command is only available on Unix platforms. ## VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. ## VFS Directory Cache Using the `--dir-cache-time` flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a `SIGHUP` signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a [remote control](/rc) then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir ## VFS File Buffering The `--buffer-size` flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to `--buffer-size * open files`. ## VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with `-vv` rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with `--cache-dir` or setting the appropriate environment variable. The cache has 4 different modes selected by `--vfs-cache-mode`. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for `--vfs-write-back` seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using `--vfs-cache-max-size` or `--vfs-cache-min-free-space` note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every `--vfs-cache-poll-interval`. Secondly because open files cannot be evicted from the cache. When `--vfs-cache-max-size` or `--vfs-cache-min-free-space` is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The `--vfs-cache-max-age` will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You **should not** run two copies of rclone using the same VFS cache with the same or overlapping remotes if using `--vfs-cache-mode > off`. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with `--cache-dir`. You don't need to worry about this if the remotes in use don't overlap. ### --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible * Files can't be opened for both read AND write * Files opened for write can't be seeked * Existing files opened for write must have O_TRUNC set * Files open for read with O_TRUNC will be opened write only * Files open for write only will behave as if O_TRUNC was supplied * Open modes O_APPEND, O_TRUNC are ignored * If an upload fails it can't be retried ### --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible * Files opened for write only can't be seeked * Existing files opened for write must have O_TRUNC set * Files opened for write only will ignore O_APPEND, O_TRUNC * If an upload fails it can't be retried ### --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. ### --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to `--vfs-cache-mode` writes. When reading a file rclone will read `--buffer-size` plus `--vfs-read-ahead` bytes ahead. The `--buffer-size` is buffered in memory whereas the `--vfs-read-ahead` is buffered on disk. When using this mode it is recommended that `--buffer-size` is not set too large and `--vfs-read-ahead` is set large if required. **IMPORTANT** not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. ### Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example `hash` is slow with the `local` and `sftp` backends as they have to read the entire file and hash it, and `modtime` is slow with the `s3`, `swift`, `ftp` and `qinqstor` backends because they need to do an extra API call to fetch it. If you use the `--vfs-fast-fingerprint` flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over `local`, `s3` or `swift` backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. ## VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the `--vfs-read-chunk-streams` parameter. ### `--vfs-read-chunk-streams` == 0 Rclone will start reading a chunk of size `--vfs-read-chunk-size`, and then double the size for each read. When `--vfs-read-chunk-size-limit` is specified, and greater than `--vfs-read-chunk-size`, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With `--vfs-read-chunk-size 100M` and `--vfs-read-chunk-size-limit 0` the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When `--vfs-read-chunk-size-limit 500M` is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting `--vfs-read-chunk-size` to `0` or "off" disables chunked reading. The chunks will not be buffered in memory. ### `--vfs-read-chunk-streams` > 0 Rclone reads `--vfs-read-chunk-streams` chunks of size `--vfs-read-chunk-size` concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of `--vfs-read-chunk-size` and `--vfs-read-chunk-streams` as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be `--vfs-read-chunk-streams 16` and `--vfs-read-chunk-size 4M`. In testing with AWS S3 the performance scaled roughly as the `--vfs-read-chunk-streams` setting. Similar settings should work for high latency links, but depending on the latency they may need more `--vfs-read-chunk-streams` in order to get the throughput. ## VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the [chunked reading](#vfs-chunked-reading) feature. In particular S3 and Swift benefit hugely from the `--no-modtime` flag (or use `--use-server-modtime` for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (`--vfs-cache-mode` with value writes or full), the global flag `--transfers` can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag `--checkers` has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) ## Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink `link-to-file.txt` would be stored on cloud storage as `link-to-file.txt.rclonelink` and the contents would be the path to the symlink destination. Note that `--links` enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). `--vfs-links` just enables it for the VFS layer. This scheme is compatible with that used by the [local backend with the --local-links flag](https://rclone.org/local/#symlinks-junction-points). The `--vfs-links` flag has been designed for `rclone mount`, `rclone nfsmount` and `rclone serve nfs`. It hasn't been tested with the other `rclone serve` commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree ``` . ├── dir │   └── file.txt └── linked-dir -> dir ``` The VFS will correctly resolve `linked-dir` but not `linked-dir/file.txt`. This is not a problem for the tested commands but may be for other commands. **Note** that there is an outstanding issue with symlink support [issue #8245](https://github.com/rclone/rclone/issues/8245) with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). ## VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The `--vfs-case-insensitive` VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The `--no-unicode-normalization` flag controls whether a similar "fixup" is performed for filenames that differ but are [canonically equivalent](https://en.wikipedia.org/wiki/Unicode_equivalence) with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of `false` on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the `--vfs-block-norm-dupes` flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. `--vfs-block- norm-dupes` prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in `rclone sync`. ## VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) ## Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running `df` on the filesystem, then pass the flag `--vfs-used-is-size` to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to `rclone size` and compute the total used space itself. _WARNING._ Contrary to `rclone size`, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. ## VFS Metadata If you use the `--vfs-metadata-extension` flag you can get the VFS to expose files which contain the [metadata](https://rclone.org/docs/#metadata) as a JSON blob. These files will not appear in the directory listing, but can be `stat`-ed and opened and once they have been they **will** appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the `--metadata` flag. For example, using `rclone mount` with `--metadata --vfs-metadata-extension .metadata` we get ``` $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata ``` If the file has no metadata it will be returned as `{}` and if there is an error reading the metadata the error will be returned as `{"error":"error string"}`. ``` rclone serve nfs remote:path [flags] ``` ## Options ``` --addr string IPaddress:Port or :Port to bind server to --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --file-perms FileMode File permissions (default 666) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for nfs --link-perms FileMode Link permissions (default 666) --nfs-cache-dir string The directory the NFS handle cache will use if set --nfs-cache-handle-limit int max file handles cached simultaneously (min 5) (default 1000000) --nfs-cache-type memory|disk|symlink Type of NFS handle cache to use (default memory) --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ## See Also * [rclone serve](https://rclone.org/commands/rclone_serve/) - Serve a remote over a protocol. # rclone serve restic Serve the remote for restic's REST API. ## Synopsis Run a basic web server to serve a remote over restic's REST backend API over HTTP. This allows restic to use rclone as a data storage mechanism for cloud providers that restic does not support directly. [Restic](https://restic.net/) is a command-line program for doing backups. The server will log errors. Use -v to see access logs. `--bwlimit` will be respected for file transfers. Use `--stats` to control the stats printing. ## Setting up rclone for use by restic ### First [set up a remote for your chosen cloud provider](https://rclone.org/docs/#configure). Once you have set up the remote, check it is working with, for example "rclone lsd remote:". You may have called the remote something other than "remote:" - just substitute whatever you called it in the following instructions. Now start the rclone restic server rclone serve restic -v remote:backup Where you can replace "backup" in the above by whatever path in the remote you wish to use. By default this will serve on "localhost:8080" you can change this with use of the `--addr` flag. You might wish to start this server on boot. Adding `--cache-objects=false` will cause rclone to stop caching objects returned from the List call. Caching is normally desirable as it speeds up downloading objects, saves transactions and uses very little memory. ## Setting up restic to use rclone ### Now you can [follow the restic instructions](http://restic.readthedocs.io/en/latest/030_preparing_a_new_repo.html#rest-server) on setting up restic. Note that you will need restic 0.8.2 or later to interoperate with rclone. For the example above you will want to use "http://localhost:8080/" as the URL for the REST server. For example: $ export RESTIC_REPOSITORY=rest:http://localhost:8080/ $ export RESTIC_PASSWORD=yourpassword $ restic init created restic backend 8b1a4b56ae at rest:http://localhost:8080/ Please note that knowledge of your password is required to access the repository. Losing your password means that your data is irrecoverably lost. $ restic backup /path/to/files/to/backup scan [/path/to/files/to/backup] scanned 189 directories, 312 files in 0:00 [0:00] 100.00% 38.128 MiB / 38.128 MiB 501 / 501 items 0 errors ETA 0:00 duration: 0:00 snapshot 45c8fdd8 saved ### Multiple repositories #### Note that you can use the endpoint to host multiple repositories. Do this by adding a directory name or path after the URL. Note that these **must** end with /. Eg $ export RESTIC_REPOSITORY=rest:http://localhost:8080/user1repo/ # backup user1 stuff $ export RESTIC_REPOSITORY=rest:http://localhost:8080/user2repo/ # backup user2 stuff ### Private repositories #### The`--private-repos` flag can be used to limit users to repositories starting with a path of `//`. ## Server options Use `--addr` to specify which IP address and port the server should listen on, eg `--addr 1.2.3.4:8000` or `--addr :8080` to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port. If you set `--addr` to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info. You can use a unix socket by setting the url to `unix:///path/to/socket` or just by using an absolute path name. `--addr` may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same. `--server-read-timeout` and `--server-write-timeout` can be used to control the timeouts on the server. Note that this is the total time for a transfer. `--max-header-bytes` controls the maximum number of bytes the server will accept in the HTTP header. `--baseurl` controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used `--baseurl "/rclone"` then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on `--baseurl`, so `--baseurl "rclone"`, `--baseurl "/rclone"` and `--baseurl "/rclone/"` are all treated identically. ### TLS (SSL) By default this will serve over http. If you want you can serve over https. You will need to supply the `--cert` and `--key` flags. If you wish to do client side certificate validation then you will need to supply `--client-ca` also. `--cert` must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. `--key` must be set to the path of a file with the PEM encoded private key. If setting `--client-ca`, it should be set to the path of a file with PEM encoded client certificate authority certificates. `--min-tls-version` is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0"). ## Socket activation Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by `--addr`). This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html Socket activation can be tested ad-hoc with the `systemd-socket-activate`command systemd-socket-activate -l 8000 -- rclone serve This will socket-activate rclone on the first connection to port 8000 over TCP. ### Authentication By default this will serve files without needing a login. You can either use an htpasswd file which can take lots of users, or set a single username and password with the `--user` and `--pass` flags. Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with `--user-from-header` (e.g., `----user-from-header=x-remote-user`). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access. If either of the above authentication methods is not configured and client certificates are required by the `--client-ca` flag passed to the server, the client certificate common name will be considered as the username. Use `--htpasswd /path/to/htpasswd` to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended. To create an htpasswd file: touch htpasswd htpasswd -B htpasswd user htpasswd -B htpasswd anotherUser The password file can be updated while rclone is running. Use `--realm` to set the authentication realm. Use `--salt` to change the password hashing salt from the default. ``` rclone serve restic remote:path [flags] ``` ## Options ``` --addr stringArray IPaddress:Port or :Port to bind server to (default 127.0.0.1:8080) --allow-origin string Origin which cross-domain request (CORS) can be executed from --append-only Disallow deletion of repository data --baseurl string Prefix for URLs - leave blank for root --cache-objects Cache listed objects (default true) --cert string TLS PEM key (concatenation of certificate and CA certificate) --client-ca string Client certificate authority to verify clients with -h, --help help for restic --htpasswd string A htpasswd file - if not provided no authentication is done --key string TLS PEM Private key --max-header-bytes int Maximum size of request header (default 4096) --min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --pass string Password for authentication --private-repos Users can only access their private repo --realm string Realm for authentication --salt string Password hashing salt (default "dlPL2MqE") --server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --stdio Run an HTTP2 server on stdin/stdout --user string User name for authentication --user-from-header string User name from a defined HTTP header ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone serve](https://rclone.org/commands/rclone_serve/) - Serve a remote over a protocol. # rclone serve s3 Serve remote:path over s3. ## Synopsis `serve s3` implements a basic s3 server that serves a remote via s3. This can be viewed with an s3 client, or you can make an [s3 type remote](https://rclone.org/s3/) to read and write to it with rclone. `serve s3` is considered **Experimental** so use with care. S3 server supports Signature Version 4 authentication. Just use `--auth-key accessKey,secretKey` and set the `Authorization` header correctly in the request. (See the [AWS docs](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)). `--auth-key` can be repeated for multiple auth pairs. If `--auth-key` is not provided then `serve s3` will allow anonymous access. Please note that some clients may require HTTPS endpoints. See [the SSL docs](#tls-ssl) for more information. This command uses the [VFS directory cache](#vfs-virtual-file-system). All the functionality will work with `--vfs-cache-mode off`. Using `--vfs-cache-mode full` (or `writes`) can be used to cache objects locally to improve performance. Use `--force-path-style=false` if you want to use the bucket name as a part of the hostname (such as mybucket.local) Use `--etag-hash` if you want to change the hash uses for the `ETag`. Note that using anything other than `MD5` (the default) is likely to cause problems for S3 clients which rely on the Etag being the MD5. ## Quickstart For a simple set up, to serve `remote:path` over s3, run the server like this: ``` rclone serve s3 --auth-key ACCESS_KEY_ID,SECRET_ACCESS_KEY remote:path ``` For example, to use a simple folder in the filesystem, run the server with a command like this: ``` rclone serve s3 --auth-key ACCESS_KEY_ID,SECRET_ACCESS_KEY local:/path/to/folder ``` The `rclone.conf` for the server could look like this: ``` [local] type = local ``` The `local` configuration is optional though. If you run the server with a `remote:path` like `/path/to/folder` (without the `local:` prefix and without an `rclone.conf` file), rclone will fall back to a default configuration, which will be visible as a warning in the logs. But it will run nonetheless. This will be compatible with an rclone (client) remote configuration which is defined like this: ``` [serves3] type = s3 provider = Rclone endpoint = http://127.0.0.1:8080/ access_key_id = ACCESS_KEY_ID secret_access_key = SECRET_ACCESS_KEY use_multipart_uploads = false ``` Note that setting `use_multipart_uploads = false` is to work around [a bug](#bugs) which will be fixed in due course. ## Bugs When uploading multipart files `serve s3` holds all the parts in memory (see [#7453](https://github.com/rclone/rclone/issues/7453)). This is a limitaton of the library rclone uses for serving S3 and will hopefully be fixed at some point. Multipart server side copies do not work (see [#7454](https://github.com/rclone/rclone/issues/7454)). These take a very long time and eventually fail. The default threshold for multipart server side copies is 5G which is the maximum it can be, so files above this side will fail to be server side copied. For a current list of `serve s3` bugs see the [serve s3](https://github.com/rclone/rclone/labels/serve%20s3) bug category on GitHub. ## Limitations `serve s3` will treat all directories in the root as buckets and ignore all files in the root. You can use `CreateBucket` to create folders under the root, but you can't create empty folders under other folders not in the root. When using `PutObject` or `DeleteObject`, rclone will automatically create or clean up empty folders. If you don't want to clean up empty folders automatically, use `--no-cleanup`. When using `ListObjects`, rclone will use `/` when the delimiter is empty. This reduces backend requests with no effect on most operations, but if the delimiter is something other than `/` and empty, rclone will do a full recursive search of the backend, which can take some time. Versioning is not currently supported. Metadata will only be saved in memory other than the rclone `mtime` metadata which will be set as the modification time of the file. ## Supported operations `serve s3` currently supports the following operations. - Bucket - `ListBuckets` - `CreateBucket` - `DeleteBucket` - Object - `HeadObject` - `ListObjects` - `GetObject` - `PutObject` - `DeleteObject` - `DeleteObjects` - `CreateMultipartUpload` - `CompleteMultipartUpload` - `AbortMultipartUpload` - `CopyObject` - `UploadPart` Other operations will return error `Unimplemented`. ### Authentication By default this will serve files without needing a login. You can either use an htpasswd file which can take lots of users, or set a single username and password with the `--user` and `--pass` flags. Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with `--user-from-header` (e.g., `----user-from-header=x-remote-user`). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access. If either of the above authentication methods is not configured and client certificates are required by the `--client-ca` flag passed to the server, the client certificate common name will be considered as the username. Use `--htpasswd /path/to/htpasswd` to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended. To create an htpasswd file: touch htpasswd htpasswd -B htpasswd user htpasswd -B htpasswd anotherUser The password file can be updated while rclone is running. Use `--realm` to set the authentication realm. Use `--salt` to change the password hashing salt from the default. ## Server options Use `--addr` to specify which IP address and port the server should listen on, eg `--addr 1.2.3.4:8000` or `--addr :8080` to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port. If you set `--addr` to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info. You can use a unix socket by setting the url to `unix:///path/to/socket` or just by using an absolute path name. `--addr` may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same. `--server-read-timeout` and `--server-write-timeout` can be used to control the timeouts on the server. Note that this is the total time for a transfer. `--max-header-bytes` controls the maximum number of bytes the server will accept in the HTTP header. `--baseurl` controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used `--baseurl "/rclone"` then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on `--baseurl`, so `--baseurl "rclone"`, `--baseurl "/rclone"` and `--baseurl "/rclone/"` are all treated identically. ### TLS (SSL) By default this will serve over http. If you want you can serve over https. You will need to supply the `--cert` and `--key` flags. If you wish to do client side certificate validation then you will need to supply `--client-ca` also. `--cert` must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. `--key` must be set to the path of a file with the PEM encoded private key. If setting `--client-ca`, it should be set to the path of a file with PEM encoded client certificate authority certificates. `--min-tls-version` is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0"). ## Socket activation Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by `--addr`). This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html Socket activation can be tested ad-hoc with the `systemd-socket-activate`command systemd-socket-activate -l 8000 -- rclone serve This will socket-activate rclone on the first connection to port 8000 over TCP. ## VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. ## VFS Directory Cache Using the `--dir-cache-time` flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a `SIGHUP` signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a [remote control](/rc) then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir ## VFS File Buffering The `--buffer-size` flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to `--buffer-size * open files`. ## VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with `-vv` rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with `--cache-dir` or setting the appropriate environment variable. The cache has 4 different modes selected by `--vfs-cache-mode`. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for `--vfs-write-back` seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using `--vfs-cache-max-size` or `--vfs-cache-min-free-space` note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every `--vfs-cache-poll-interval`. Secondly because open files cannot be evicted from the cache. When `--vfs-cache-max-size` or `--vfs-cache-min-free-space` is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The `--vfs-cache-max-age` will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You **should not** run two copies of rclone using the same VFS cache with the same or overlapping remotes if using `--vfs-cache-mode > off`. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with `--cache-dir`. You don't need to worry about this if the remotes in use don't overlap. ### --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible * Files can't be opened for both read AND write * Files opened for write can't be seeked * Existing files opened for write must have O_TRUNC set * Files open for read with O_TRUNC will be opened write only * Files open for write only will behave as if O_TRUNC was supplied * Open modes O_APPEND, O_TRUNC are ignored * If an upload fails it can't be retried ### --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible * Files opened for write only can't be seeked * Existing files opened for write must have O_TRUNC set * Files opened for write only will ignore O_APPEND, O_TRUNC * If an upload fails it can't be retried ### --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. ### --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to `--vfs-cache-mode` writes. When reading a file rclone will read `--buffer-size` plus `--vfs-read-ahead` bytes ahead. The `--buffer-size` is buffered in memory whereas the `--vfs-read-ahead` is buffered on disk. When using this mode it is recommended that `--buffer-size` is not set too large and `--vfs-read-ahead` is set large if required. **IMPORTANT** not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. ### Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example `hash` is slow with the `local` and `sftp` backends as they have to read the entire file and hash it, and `modtime` is slow with the `s3`, `swift`, `ftp` and `qinqstor` backends because they need to do an extra API call to fetch it. If you use the `--vfs-fast-fingerprint` flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over `local`, `s3` or `swift` backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. ## VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the `--vfs-read-chunk-streams` parameter. ### `--vfs-read-chunk-streams` == 0 Rclone will start reading a chunk of size `--vfs-read-chunk-size`, and then double the size for each read. When `--vfs-read-chunk-size-limit` is specified, and greater than `--vfs-read-chunk-size`, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With `--vfs-read-chunk-size 100M` and `--vfs-read-chunk-size-limit 0` the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When `--vfs-read-chunk-size-limit 500M` is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting `--vfs-read-chunk-size` to `0` or "off" disables chunked reading. The chunks will not be buffered in memory. ### `--vfs-read-chunk-streams` > 0 Rclone reads `--vfs-read-chunk-streams` chunks of size `--vfs-read-chunk-size` concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of `--vfs-read-chunk-size` and `--vfs-read-chunk-streams` as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be `--vfs-read-chunk-streams 16` and `--vfs-read-chunk-size 4M`. In testing with AWS S3 the performance scaled roughly as the `--vfs-read-chunk-streams` setting. Similar settings should work for high latency links, but depending on the latency they may need more `--vfs-read-chunk-streams` in order to get the throughput. ## VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the [chunked reading](#vfs-chunked-reading) feature. In particular S3 and Swift benefit hugely from the `--no-modtime` flag (or use `--use-server-modtime` for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (`--vfs-cache-mode` with value writes or full), the global flag `--transfers` can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag `--checkers` has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) ## Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink `link-to-file.txt` would be stored on cloud storage as `link-to-file.txt.rclonelink` and the contents would be the path to the symlink destination. Note that `--links` enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). `--vfs-links` just enables it for the VFS layer. This scheme is compatible with that used by the [local backend with the --local-links flag](https://rclone.org/local/#symlinks-junction-points). The `--vfs-links` flag has been designed for `rclone mount`, `rclone nfsmount` and `rclone serve nfs`. It hasn't been tested with the other `rclone serve` commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree ``` . ├── dir │   └── file.txt └── linked-dir -> dir ``` The VFS will correctly resolve `linked-dir` but not `linked-dir/file.txt`. This is not a problem for the tested commands but may be for other commands. **Note** that there is an outstanding issue with symlink support [issue #8245](https://github.com/rclone/rclone/issues/8245) with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). ## VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The `--vfs-case-insensitive` VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The `--no-unicode-normalization` flag controls whether a similar "fixup" is performed for filenames that differ but are [canonically equivalent](https://en.wikipedia.org/wiki/Unicode_equivalence) with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of `false` on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the `--vfs-block-norm-dupes` flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. `--vfs-block- norm-dupes` prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in `rclone sync`. ## VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) ## Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running `df` on the filesystem, then pass the flag `--vfs-used-is-size` to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to `rclone size` and compute the total used space itself. _WARNING._ Contrary to `rclone size`, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. ## VFS Metadata If you use the `--vfs-metadata-extension` flag you can get the VFS to expose files which contain the [metadata](https://rclone.org/docs/#metadata) as a JSON blob. These files will not appear in the directory listing, but can be `stat`-ed and opened and once they have been they **will** appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the `--metadata` flag. For example, using `rclone mount` with `--metadata --vfs-metadata-extension .metadata` we get ``` $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata ``` If the file has no metadata it will be returned as `{}` and if there is an error reading the metadata the error will be returned as `{"error":"error string"}`. ``` rclone serve s3 remote:path [flags] ``` ## Options ``` --addr stringArray IPaddress:Port or :Port to bind server to (default 127.0.0.1:8080) --allow-origin string Origin which cross-domain request (CORS) can be executed from --auth-key stringArray Set key pair for v4 authorization: access_key_id,secret_access_key --auth-proxy string A program to use to create the backend from the auth --baseurl string Prefix for URLs - leave blank for root --cert string TLS PEM key (concatenation of certificate and CA certificate) --client-ca string Client certificate authority to verify clients with --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --etag-hash string Which hash to use for the ETag, or auto or blank for off (default "MD5") --file-perms FileMode File permissions (default 666) --force-path-style If true use path style access if false use virtual hosted style (default true) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for s3 --htpasswd string A htpasswd file - if not provided no authentication is done --key string TLS PEM Private key --link-perms FileMode Link permissions (default 666) --max-header-bytes int Maximum size of request header (default 4096) --min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --no-checksum Don't compare checksums on up/download --no-cleanup Not to cleanup empty folder after object is deleted --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --pass string Password for authentication --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --realm string Realm for authentication --salt string Password hashing salt (default "dlPL2MqE") --server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --user string User name for authentication --user-from-header string User name from a defined HTTP header --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ## See Also * [rclone serve](https://rclone.org/commands/rclone_serve/) - Serve a remote over a protocol. # rclone serve sftp Serve the remote over SFTP. ## Synopsis Run an SFTP server to serve a remote over SFTP. This can be used with an SFTP client or you can make a remote of type [sftp](/sftp) to use with it. You can use the [filter](/filtering) flags (e.g. `--include`, `--exclude`) to control what is served. The server will respond to a small number of shell commands, mainly md5sum, sha1sum and df, which enable it to provide support for checksums and the about feature when accessed from an sftp remote. Note that this server uses standard 32 KiB packet payload size, which means you must not configure the client to expect anything else, e.g. with the [chunk_size](https://rclone.org/sftp/#sftp-chunk-size) option on an sftp remote. The server will log errors. Use `-v` to see access logs. `--bwlimit` will be respected for file transfers. Use `--stats` to control the stats printing. You must provide some means of authentication, either with `--user`/`--pass`, an authorized keys file (specify location with `--authorized-keys` - the default is the same as ssh), an `--auth-proxy`, or set the `--no-auth` flag for no authentication when logging in. If you don't supply a host `--key` then rclone will generate rsa, ecdsa and ed25519 variants, and cache them for later use in rclone's cache directory (see `rclone help flags cache-dir`) in the "serve-sftp" directory. By default the server binds to localhost:2022 - if you want it to be reachable externally then supply `--addr :2022` for example. This also supports being run with socket activation, in which case it will listen on the first passed FD. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html Socket activation can be tested ad-hoc with the `systemd-socket-activate`command: systemd-socket-activate -l 2222 -- rclone serve sftp :local:vfs/ This will socket-activate rclone on the first connection to port 2222 over TCP. Note that the default of `--vfs-cache-mode off` is fine for the rclone sftp backend, but it may not be with other SFTP clients. If `--stdio` is specified, rclone will serve SFTP over stdio, which can be used with sshd via ~/.ssh/authorized_keys, for example: restrict,command="rclone serve sftp --stdio ./photos" ssh-rsa ... On the client you need to set `--transfers 1` when using `--stdio`. Otherwise multiple instances of the rclone server are started by OpenSSH which can lead to "corrupted on transfer" errors. This is the case because the client chooses indiscriminately which server to send commands to while the servers all have different views of the state of the filing system. The "restrict" in authorized_keys prevents SHA1SUMs and MD5SUMs from being used. Omitting "restrict" and using `--sftp-path-override` to enable checksumming is possible but less secure and you could use the SFTP server provided by OpenSSH in this case. ## VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. ## VFS Directory Cache Using the `--dir-cache-time` flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a `SIGHUP` signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a [remote control](/rc) then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir ## VFS File Buffering The `--buffer-size` flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to `--buffer-size * open files`. ## VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with `-vv` rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with `--cache-dir` or setting the appropriate environment variable. The cache has 4 different modes selected by `--vfs-cache-mode`. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for `--vfs-write-back` seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using `--vfs-cache-max-size` or `--vfs-cache-min-free-space` note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every `--vfs-cache-poll-interval`. Secondly because open files cannot be evicted from the cache. When `--vfs-cache-max-size` or `--vfs-cache-min-free-space` is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The `--vfs-cache-max-age` will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You **should not** run two copies of rclone using the same VFS cache with the same or overlapping remotes if using `--vfs-cache-mode > off`. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with `--cache-dir`. You don't need to worry about this if the remotes in use don't overlap. ### --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible * Files can't be opened for both read AND write * Files opened for write can't be seeked * Existing files opened for write must have O_TRUNC set * Files open for read with O_TRUNC will be opened write only * Files open for write only will behave as if O_TRUNC was supplied * Open modes O_APPEND, O_TRUNC are ignored * If an upload fails it can't be retried ### --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible * Files opened for write only can't be seeked * Existing files opened for write must have O_TRUNC set * Files opened for write only will ignore O_APPEND, O_TRUNC * If an upload fails it can't be retried ### --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. ### --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to `--vfs-cache-mode` writes. When reading a file rclone will read `--buffer-size` plus `--vfs-read-ahead` bytes ahead. The `--buffer-size` is buffered in memory whereas the `--vfs-read-ahead` is buffered on disk. When using this mode it is recommended that `--buffer-size` is not set too large and `--vfs-read-ahead` is set large if required. **IMPORTANT** not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. ### Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example `hash` is slow with the `local` and `sftp` backends as they have to read the entire file and hash it, and `modtime` is slow with the `s3`, `swift`, `ftp` and `qinqstor` backends because they need to do an extra API call to fetch it. If you use the `--vfs-fast-fingerprint` flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over `local`, `s3` or `swift` backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. ## VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the `--vfs-read-chunk-streams` parameter. ### `--vfs-read-chunk-streams` == 0 Rclone will start reading a chunk of size `--vfs-read-chunk-size`, and then double the size for each read. When `--vfs-read-chunk-size-limit` is specified, and greater than `--vfs-read-chunk-size`, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With `--vfs-read-chunk-size 100M` and `--vfs-read-chunk-size-limit 0` the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When `--vfs-read-chunk-size-limit 500M` is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting `--vfs-read-chunk-size` to `0` or "off" disables chunked reading. The chunks will not be buffered in memory. ### `--vfs-read-chunk-streams` > 0 Rclone reads `--vfs-read-chunk-streams` chunks of size `--vfs-read-chunk-size` concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of `--vfs-read-chunk-size` and `--vfs-read-chunk-streams` as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be `--vfs-read-chunk-streams 16` and `--vfs-read-chunk-size 4M`. In testing with AWS S3 the performance scaled roughly as the `--vfs-read-chunk-streams` setting. Similar settings should work for high latency links, but depending on the latency they may need more `--vfs-read-chunk-streams` in order to get the throughput. ## VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the [chunked reading](#vfs-chunked-reading) feature. In particular S3 and Swift benefit hugely from the `--no-modtime` flag (or use `--use-server-modtime` for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (`--vfs-cache-mode` with value writes or full), the global flag `--transfers` can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag `--checkers` has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) ## Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink `link-to-file.txt` would be stored on cloud storage as `link-to-file.txt.rclonelink` and the contents would be the path to the symlink destination. Note that `--links` enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). `--vfs-links` just enables it for the VFS layer. This scheme is compatible with that used by the [local backend with the --local-links flag](https://rclone.org/local/#symlinks-junction-points). The `--vfs-links` flag has been designed for `rclone mount`, `rclone nfsmount` and `rclone serve nfs`. It hasn't been tested with the other `rclone serve` commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree ``` . ├── dir │   └── file.txt └── linked-dir -> dir ``` The VFS will correctly resolve `linked-dir` but not `linked-dir/file.txt`. This is not a problem for the tested commands but may be for other commands. **Note** that there is an outstanding issue with symlink support [issue #8245](https://github.com/rclone/rclone/issues/8245) with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). ## VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The `--vfs-case-insensitive` VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The `--no-unicode-normalization` flag controls whether a similar "fixup" is performed for filenames that differ but are [canonically equivalent](https://en.wikipedia.org/wiki/Unicode_equivalence) with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of `false` on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the `--vfs-block-norm-dupes` flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. `--vfs-block- norm-dupes` prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in `rclone sync`. ## VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) ## Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running `df` on the filesystem, then pass the flag `--vfs-used-is-size` to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to `rclone size` and compute the total used space itself. _WARNING._ Contrary to `rclone size`, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. ## VFS Metadata If you use the `--vfs-metadata-extension` flag you can get the VFS to expose files which contain the [metadata](https://rclone.org/docs/#metadata) as a JSON blob. These files will not appear in the directory listing, but can be `stat`-ed and opened and once they have been they **will** appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the `--metadata` flag. For example, using `rclone mount` with `--metadata --vfs-metadata-extension .metadata` we get ``` $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata ``` If the file has no metadata it will be returned as `{}` and if there is an error reading the metadata the error will be returned as `{"error":"error string"}`. ## Auth Proxy If you supply the parameter `--auth-proxy /path/to/program` then rclone will use that program to generate backends on the fly which then are used to authenticate incoming requests. This uses a simple JSON based protocol with input on STDIN and output on STDOUT. **PLEASE NOTE:** `--auth-proxy` and `--authorized-keys` cannot be used together, if `--auth-proxy` is set the authorized keys option will be ignored. There is an example program [bin/test_proxy.py](https://github.com/rclone/rclone/blob/master/bin/test_proxy.py) in the rclone source code. The program's job is to take a `user` and `pass` on the input and turn those into the config for a backend on STDOUT in JSON format. This config will have any default parameters for the backend added, but it won't use configuration from environment variables or command line options - it is the job of the proxy program to make a complete config. This config generated must have this extra parameter - `_root` - root to use for the backend And it may have this parameter - `_obscure` - comma separated strings for parameters to obscure If password authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: ``` { "user": "me", "pass": "mypassword" } ``` If public-key authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: ``` { "user": "me", "public_key": "AAAAB3NzaC1yc2EAAAADAQABAAABAQDuwESFdAe14hVS6omeyX7edc...JQdf" } ``` And as an example return this on STDOUT ``` { "type": "sftp", "_root": "", "_obscure": "pass", "user": "me", "pass": "mypassword", "host": "sftp.example.com" } ``` This would mean that an SFTP backend would be created on the fly for the `user` and `pass`/`public_key` returned in the output to the host given. Note that since `_obscure` is set to `pass`, rclone will obscure the `pass` parameter before creating the backend (which is required for sftp backends). The program can manipulate the supplied `user` in any way, for example to make proxy to many different sftp backends, you could make the `user` be `user@example.com` and then set the `host` to `example.com` in the output and the user to `user`. For security you'd probably want to restrict the `host` to a limited list. Note that an internal cache is keyed on `user` so only use that for configuration, don't use `pass` or `public_key`. This also means that if a user's password or public-key is changed the cache will need to expire (which takes 5 mins) before it takes effect. This can be used to build general purpose proxies to any kind of backend that rclone supports. ``` rclone serve sftp remote:path [flags] ``` ## Options ``` --addr string IPaddress:Port or :Port to bind server to (default "localhost:2022") --auth-proxy string A program to use to create the backend from the auth --authorized-keys string Authorized keys file (default "~/.ssh/authorized_keys") --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --file-perms FileMode File permissions (default 666) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for sftp --key stringArray SSH private host key file (Can be multi-valued, leave blank to auto generate) --link-perms FileMode Link permissions (default 666) --no-auth Allow connections with no authentication if set --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --pass string Password for authentication --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --stdio Run an sftp server on stdin/stdout --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --user string User name for authentication --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ## See Also * [rclone serve](https://rclone.org/commands/rclone_serve/) - Serve a remote over a protocol. # rclone serve webdav Serve remote:path over WebDAV. ## Synopsis Run a basic WebDAV server to serve a remote over HTTP via the WebDAV protocol. This can be viewed with a WebDAV client, through a web browser, or you can make a remote of type WebDAV to read and write it. ## WebDAV options ### --etag-hash This controls the ETag header. Without this flag the ETag will be based on the ModTime and Size of the object. If this flag is set to "auto" then rclone will choose the first supported hash on the backend or you can use a named hash such as "MD5" or "SHA-1". Use the [hashsum](https://rclone.org/commands/rclone_hashsum/) command to see the full list. ## Access WebDAV on Windows WebDAV shared folder can be mapped as a drive on Windows, however the default settings prevent it. Windows will fail to connect to the server using insecure Basic authentication. It will not even display any login dialog. Windows requires SSL / HTTPS connection to be used with Basic. If you try to connect via Add Network Location Wizard you will get the following error: "The folder you entered does not appear to be valid. Please choose another". However, you still can connect if you set the following registry key on a client machine: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WebClient\Parameters\BasicAuthLevel to 2. The BasicAuthLevel can be set to the following values: 0 - Basic authentication disabled 1 - Basic authentication enabled for SSL connections only 2 - Basic authentication enabled for SSL connections and for non-SSL connections If required, increase the FileSizeLimitInBytes to a higher value. Navigate to the Services interface, then restart the WebClient service. ## Access Office applications on WebDAV Navigate to following registry HKEY_CURRENT_USER\Software\Microsoft\Office\[14.0/15.0/16.0]\Common\Internet Create a new DWORD BasicAuthLevel with value 2. 0 - Basic authentication disabled 1 - Basic authentication enabled for SSL connections only 2 - Basic authentication enabled for SSL and for non-SSL connections https://learn.microsoft.com/en-us/office/troubleshoot/powerpoint/office-opens-blank-from-sharepoint ## Serving over a unix socket You can serve the webdav on a unix socket like this: rclone serve webdav --addr unix:///tmp/my.socket remote:path and connect to it like this using rclone and the webdav backend: rclone --webdav-unix-socket /tmp/my.socket --webdav-url http://localhost lsf :webdav: Note that there is no authentication on http protocol - this is expected to be done by the permissions on the socket. ## Server options Use `--addr` to specify which IP address and port the server should listen on, eg `--addr 1.2.3.4:8000` or `--addr :8080` to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port. If you set `--addr` to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info. You can use a unix socket by setting the url to `unix:///path/to/socket` or just by using an absolute path name. `--addr` may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same. `--server-read-timeout` and `--server-write-timeout` can be used to control the timeouts on the server. Note that this is the total time for a transfer. `--max-header-bytes` controls the maximum number of bytes the server will accept in the HTTP header. `--baseurl` controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used `--baseurl "/rclone"` then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on `--baseurl`, so `--baseurl "rclone"`, `--baseurl "/rclone"` and `--baseurl "/rclone/"` are all treated identically. ### TLS (SSL) By default this will serve over http. If you want you can serve over https. You will need to supply the `--cert` and `--key` flags. If you wish to do client side certificate validation then you will need to supply `--client-ca` also. `--cert` must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. `--key` must be set to the path of a file with the PEM encoded private key. If setting `--client-ca`, it should be set to the path of a file with PEM encoded client certificate authority certificates. `--min-tls-version` is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0"). ## Socket activation Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by `--addr`). This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html Socket activation can be tested ad-hoc with the `systemd-socket-activate`command systemd-socket-activate -l 8000 -- rclone serve This will socket-activate rclone on the first connection to port 8000 over TCP. ### Template `--template` allows a user to specify a custom markup template for HTTP and WebDAV serve functions. The server exports the following markup to be used within the template to server pages: | Parameter | Description | | :---------- | :---------- | | .Name | The full path of a file/directory. | | .Title | Directory listing of .Name | | .Sort | The current sort used. This is changeable via ?sort= parameter | | | Sort Options: namedirfirst,name,size,time (default namedirfirst) | | .Order | The current ordering used. This is changeable via ?order= parameter | | | Order Options: asc,desc (default asc) | | .Query | Currently unused. | | .Breadcrumb | Allows for creating a relative navigation | |-- .Link | The relative to the root link of the Text. | |-- .Text | The Name of the directory. | | .Entries | Information about a specific file/directory. | |-- .URL | The 'url' of an entry. | |-- .Leaf | Currently same as 'URL' but intended to be 'just' the name. | |-- .IsDir | Boolean for if an entry is a directory or not. | |-- .Size | Size in Bytes of the entry. | |-- .ModTime | The UTC timestamp of an entry. | The server also makes the following functions available so that they can be used within the template. These functions help extend the options for dynamic rendering of HTML. They can be used to render HTML based on specific conditions. | Function | Description | | :---------- | :---------- | | afterEpoch | Returns the time since the epoch for the given time. | | contains | Checks whether a given substring is present or not in a given string. | | hasPrefix | Checks whether the given string begins with the specified prefix. | | hasSuffix | Checks whether the given string end with the specified suffix. | ### Authentication By default this will serve files without needing a login. You can either use an htpasswd file which can take lots of users, or set a single username and password with the `--user` and `--pass` flags. Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with `--user-from-header` (e.g., `----user-from-header=x-remote-user`). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access. If either of the above authentication methods is not configured and client certificates are required by the `--client-ca` flag passed to the server, the client certificate common name will be considered as the username. Use `--htpasswd /path/to/htpasswd` to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended. To create an htpasswd file: touch htpasswd htpasswd -B htpasswd user htpasswd -B htpasswd anotherUser The password file can be updated while rclone is running. Use `--realm` to set the authentication realm. Use `--salt` to change the password hashing salt from the default. ## VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. ## VFS Directory Cache Using the `--dir-cache-time` flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a `SIGHUP` signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a [remote control](/rc) then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir ## VFS File Buffering The `--buffer-size` flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to `--buffer-size * open files`. ## VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with `-vv` rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with `--cache-dir` or setting the appropriate environment variable. The cache has 4 different modes selected by `--vfs-cache-mode`. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for `--vfs-write-back` seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using `--vfs-cache-max-size` or `--vfs-cache-min-free-space` note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every `--vfs-cache-poll-interval`. Secondly because open files cannot be evicted from the cache. When `--vfs-cache-max-size` or `--vfs-cache-min-free-space` is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The `--vfs-cache-max-age` will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You **should not** run two copies of rclone using the same VFS cache with the same or overlapping remotes if using `--vfs-cache-mode > off`. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with `--cache-dir`. You don't need to worry about this if the remotes in use don't overlap. ### --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible * Files can't be opened for both read AND write * Files opened for write can't be seeked * Existing files opened for write must have O_TRUNC set * Files open for read with O_TRUNC will be opened write only * Files open for write only will behave as if O_TRUNC was supplied * Open modes O_APPEND, O_TRUNC are ignored * If an upload fails it can't be retried ### --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible * Files opened for write only can't be seeked * Existing files opened for write must have O_TRUNC set * Files opened for write only will ignore O_APPEND, O_TRUNC * If an upload fails it can't be retried ### --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. ### --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to `--vfs-cache-mode` writes. When reading a file rclone will read `--buffer-size` plus `--vfs-read-ahead` bytes ahead. The `--buffer-size` is buffered in memory whereas the `--vfs-read-ahead` is buffered on disk. When using this mode it is recommended that `--buffer-size` is not set too large and `--vfs-read-ahead` is set large if required. **IMPORTANT** not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. ### Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example `hash` is slow with the `local` and `sftp` backends as they have to read the entire file and hash it, and `modtime` is slow with the `s3`, `swift`, `ftp` and `qinqstor` backends because they need to do an extra API call to fetch it. If you use the `--vfs-fast-fingerprint` flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over `local`, `s3` or `swift` backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. ## VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the `--vfs-read-chunk-streams` parameter. ### `--vfs-read-chunk-streams` == 0 Rclone will start reading a chunk of size `--vfs-read-chunk-size`, and then double the size for each read. When `--vfs-read-chunk-size-limit` is specified, and greater than `--vfs-read-chunk-size`, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With `--vfs-read-chunk-size 100M` and `--vfs-read-chunk-size-limit 0` the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When `--vfs-read-chunk-size-limit 500M` is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting `--vfs-read-chunk-size` to `0` or "off" disables chunked reading. The chunks will not be buffered in memory. ### `--vfs-read-chunk-streams` > 0 Rclone reads `--vfs-read-chunk-streams` chunks of size `--vfs-read-chunk-size` concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of `--vfs-read-chunk-size` and `--vfs-read-chunk-streams` as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be `--vfs-read-chunk-streams 16` and `--vfs-read-chunk-size 4M`. In testing with AWS S3 the performance scaled roughly as the `--vfs-read-chunk-streams` setting. Similar settings should work for high latency links, but depending on the latency they may need more `--vfs-read-chunk-streams` in order to get the throughput. ## VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the [chunked reading](#vfs-chunked-reading) feature. In particular S3 and Swift benefit hugely from the `--no-modtime` flag (or use `--use-server-modtime` for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (`--vfs-cache-mode` with value writes or full), the global flag `--transfers` can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag `--checkers` has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) ## Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink `link-to-file.txt` would be stored on cloud storage as `link-to-file.txt.rclonelink` and the contents would be the path to the symlink destination. Note that `--links` enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). `--vfs-links` just enables it for the VFS layer. This scheme is compatible with that used by the [local backend with the --local-links flag](https://rclone.org/local/#symlinks-junction-points). The `--vfs-links` flag has been designed for `rclone mount`, `rclone nfsmount` and `rclone serve nfs`. It hasn't been tested with the other `rclone serve` commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree ``` . ├── dir │   └── file.txt └── linked-dir -> dir ``` The VFS will correctly resolve `linked-dir` but not `linked-dir/file.txt`. This is not a problem for the tested commands but may be for other commands. **Note** that there is an outstanding issue with symlink support [issue #8245](https://github.com/rclone/rclone/issues/8245) with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). ## VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The `--vfs-case-insensitive` VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The `--no-unicode-normalization` flag controls whether a similar "fixup" is performed for filenames that differ but are [canonically equivalent](https://en.wikipedia.org/wiki/Unicode_equivalence) with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of `false` on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the `--vfs-block-norm-dupes` flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. `--vfs-block- norm-dupes` prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in `rclone sync`. ## VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) ## Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running `df` on the filesystem, then pass the flag `--vfs-used-is-size` to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to `rclone size` and compute the total used space itself. _WARNING._ Contrary to `rclone size`, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. ## VFS Metadata If you use the `--vfs-metadata-extension` flag you can get the VFS to expose files which contain the [metadata](https://rclone.org/docs/#metadata) as a JSON blob. These files will not appear in the directory listing, but can be `stat`-ed and opened and once they have been they **will** appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the `--metadata` flag. For example, using `rclone mount` with `--metadata --vfs-metadata-extension .metadata` we get ``` $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata ``` If the file has no metadata it will be returned as `{}` and if there is an error reading the metadata the error will be returned as `{"error":"error string"}`. ## Auth Proxy If you supply the parameter `--auth-proxy /path/to/program` then rclone will use that program to generate backends on the fly which then are used to authenticate incoming requests. This uses a simple JSON based protocol with input on STDIN and output on STDOUT. **PLEASE NOTE:** `--auth-proxy` and `--authorized-keys` cannot be used together, if `--auth-proxy` is set the authorized keys option will be ignored. There is an example program [bin/test_proxy.py](https://github.com/rclone/rclone/blob/master/bin/test_proxy.py) in the rclone source code. The program's job is to take a `user` and `pass` on the input and turn those into the config for a backend on STDOUT in JSON format. This config will have any default parameters for the backend added, but it won't use configuration from environment variables or command line options - it is the job of the proxy program to make a complete config. This config generated must have this extra parameter - `_root` - root to use for the backend And it may have this parameter - `_obscure` - comma separated strings for parameters to obscure If password authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: ``` { "user": "me", "pass": "mypassword" } ``` If public-key authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: ``` { "user": "me", "public_key": "AAAAB3NzaC1yc2EAAAADAQABAAABAQDuwESFdAe14hVS6omeyX7edc...JQdf" } ``` And as an example return this on STDOUT ``` { "type": "sftp", "_root": "", "_obscure": "pass", "user": "me", "pass": "mypassword", "host": "sftp.example.com" } ``` This would mean that an SFTP backend would be created on the fly for the `user` and `pass`/`public_key` returned in the output to the host given. Note that since `_obscure` is set to `pass`, rclone will obscure the `pass` parameter before creating the backend (which is required for sftp backends). The program can manipulate the supplied `user` in any way, for example to make proxy to many different sftp backends, you could make the `user` be `user@example.com` and then set the `host` to `example.com` in the output and the user to `user`. For security you'd probably want to restrict the `host` to a limited list. Note that an internal cache is keyed on `user` so only use that for configuration, don't use `pass` or `public_key`. This also means that if a user's password or public-key is changed the cache will need to expire (which takes 5 mins) before it takes effect. This can be used to build general purpose proxies to any kind of backend that rclone supports. ``` rclone serve webdav remote:path [flags] ``` ## Options ``` --addr stringArray IPaddress:Port or :Port to bind server to (default 127.0.0.1:8080) --allow-origin string Origin which cross-domain request (CORS) can be executed from --auth-proxy string A program to use to create the backend from the auth --baseurl string Prefix for URLs - leave blank for root --cert string TLS PEM key (concatenation of certificate and CA certificate) --client-ca string Client certificate authority to verify clients with --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --disable-dir-list Disable HTML directory list on GET request for a directory --etag-hash string Which hash to use for the ETag, or auto or blank for off --file-perms FileMode File permissions (default 666) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for webdav --htpasswd string A htpasswd file - if not provided no authentication is done --key string TLS PEM Private key --link-perms FileMode Link permissions (default 666) --max-header-bytes int Maximum size of request header (default 4096) --min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --pass string Password for authentication --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --realm string Realm for authentication --salt string Password hashing salt (default "dlPL2MqE") --server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --template string User-specified template --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --user string User name for authentication --user-from-header string User name from a defined HTTP header --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ## See Also * [rclone serve](https://rclone.org/commands/rclone_serve/) - Serve a remote over a protocol. # rclone settier Changes storage class/tier of objects in remote. ## Synopsis Changes storage tier or class at remote if supported. Few cloud storage services provides different storage classes on objects, for example AWS S3 and Glacier, Azure Blob storage - Hot, Cool and Archive, Google Cloud Storage, Regional Storage, Nearline, Coldline etc. Note that, certain tier changes make objects not available to access immediately. For example tiering to archive in azure blob storage makes objects in frozen state, user can restore by setting tier to Hot/Cool, similarly S3 to Glacier makes object inaccessible.true You can use it to tier single object rclone settier Cool remote:path/file Or use rclone filters to set tier on only specific files rclone --include "*.txt" settier Hot remote:path/dir Or just provide remote directory and all files in directory will be tiered rclone settier tier remote:path/dir ``` rclone settier tier remote:path [flags] ``` ## Options ``` -h, --help help for settier ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone test Run a test command ## Synopsis Rclone test is used to run test commands. Select which test command you want with the subcommand, eg rclone test memory remote: Each subcommand has its own options which you can see in their help. **NB** Be careful running these commands, they may do strange things so reading their documentation first is recommended. ## Options ``` -h, --help help for test ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. * [rclone test changenotify](https://rclone.org/commands/rclone_test_changenotify/) - Log any change notify requests for the remote passed in. * [rclone test histogram](https://rclone.org/commands/rclone_test_histogram/) - Makes a histogram of file name characters. * [rclone test info](https://rclone.org/commands/rclone_test_info/) - Discovers file name or other limitations for paths. * [rclone test makefile](https://rclone.org/commands/rclone_test_makefile/) - Make files with random contents of the size given * [rclone test makefiles](https://rclone.org/commands/rclone_test_makefiles/) - Make a random file hierarchy in a directory * [rclone test memory](https://rclone.org/commands/rclone_test_memory/) - Load all the objects at remote:path into memory and report memory stats. # rclone test changenotify Log any change notify requests for the remote passed in. ``` rclone test changenotify remote: [flags] ``` ## Options ``` -h, --help help for changenotify --poll-interval Duration Time to wait between polling for changes (default 10s) ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone test](https://rclone.org/commands/rclone_test/) - Run a test command # rclone test histogram Makes a histogram of file name characters. ## Synopsis This command outputs JSON which shows the histogram of characters used in filenames in the remote:path specified. The data doesn't contain any identifying information but is useful for the rclone developers when developing filename compression. ``` rclone test histogram [remote:path] [flags] ``` ## Options ``` -h, --help help for histogram ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone test](https://rclone.org/commands/rclone_test/) - Run a test command # rclone test info Discovers file name or other limitations for paths. ## Synopsis Discovers what filenames and upload methods are possible to write to the paths passed in and how long they can be. It can take some time. It will write test files into the remote:path passed in. It outputs a bit of go code for each one. **NB** this can create undeletable files and other hazards - use with care ``` rclone test info [remote:path]+ [flags] ``` ## Options ``` --all Run all tests --check-base32768 Check can store all possible base32768 characters --check-control Check control characters --check-length Check max filename length --check-normalization Check UTF-8 Normalization --check-streaming Check uploads with indeterminate file size -h, --help help for info --keep-test-files Keep test files after execution --upload-wait Duration Wait after writing a file (default 0s) --write-json string Write results to file ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone test](https://rclone.org/commands/rclone_test/) - Run a test command # rclone test makefile Make files with random contents of the size given ``` rclone test makefile []+ [flags] ``` ## Options ``` --ascii Fill files with random ASCII printable bytes only --chargen Fill files with a ASCII chargen pattern -h, --help help for makefile --pattern Fill files with a periodic pattern --seed int Seed for the random number generator (0 for random) (default 1) --sparse Make the files sparse (appear to be filled with ASCII 0x00) --zero Fill files with ASCII 0x00 ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone test](https://rclone.org/commands/rclone_test/) - Run a test command # rclone test makefiles Make a random file hierarchy in a directory ``` rclone test makefiles [flags] ``` ## Options ``` --ascii Fill files with random ASCII printable bytes only --chargen Fill files with a ASCII chargen pattern --files int Number of files to create (default 1000) --files-per-directory int Average number of files per directory (default 10) --flat If set create all files in the root directory -h, --help help for makefiles --max-depth int Maximum depth of directory hierarchy (default 10) --max-file-size SizeSuffix Maximum size of files to create (default 100) --max-name-length int Maximum size of file names (default 12) --min-file-size SizeSuffix Minimum size of file to create --min-name-length int Minimum size of file names (default 4) --pattern Fill files with a periodic pattern --seed int Seed for the random number generator (0 for random) (default 1) --sparse Make the files sparse (appear to be filled with ASCII 0x00) --zero Fill files with ASCII 0x00 ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone test](https://rclone.org/commands/rclone_test/) - Run a test command # rclone test memory Load all the objects at remote:path into memory and report memory stats. ``` rclone test memory remote:path [flags] ``` ## Options ``` -h, --help help for memory ``` See the [global flags page](https://rclone.org/flags/) for global options not listed here. ## See Also * [rclone test](https://rclone.org/commands/rclone_test/) - Run a test command # rclone touch Create new file or change file modification time. ## Synopsis Set the modification time on file(s) as specified by remote:path to have the current time. If remote:path does not exist then a zero sized file will be created, unless `--no-create` or `--recursive` is provided. If `--recursive` is used then recursively sets the modification time on all existing files that is found under the path. Filters are supported, and you can test with the `--dry-run` or the `--interactive`/`-i` flag. This will touch `--transfers` files concurrently. If `--timestamp` is used then sets the modification time to that time instead of the current time. Times may be specified as one of: - 'YYMMDD' - e.g. 17.10.30 - 'YYYY-MM-DDTHH:MM:SS' - e.g. 2006-01-02T15:04:05 - 'YYYY-MM-DDTHH:MM:SS.SSS' - e.g. 2006-01-02T15:04:05.123456789 Note that value of `--timestamp` is in UTC. If you want local time then add the `--localtime` flag. ``` rclone touch remote:path [flags] ``` ## Options ``` -h, --help help for touch --localtime Use localtime for timestamp, not UTC -C, --no-create Do not create the file if it does not exist (implied with --recursive) -R, --recursive Recursively touch all files -t, --timestamp string Use specified time instead of the current time of day ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Important Options Important flags useful for most commands ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. # rclone tree List the contents of the remote in a tree like fashion. ## Synopsis Lists the contents of a remote in a similar way to the unix tree command. For example $ rclone tree remote:path / ├── file1 ├── file2 ├── file3 └── subdir ├── file4 └── file5 1 directories, 5 files You can use any of the filtering options with the tree command (e.g. `--include` and `--exclude`. You can also use `--fast-list`. The tree command has many options for controlling the listing which are compatible with the tree command, for example you can include file sizes with `--size`. Note that not all of them have short options as they conflict with rclone's short options. For a more interactive navigation of the remote see the [ncdu](https://rclone.org/commands/rclone_ncdu/) command. ``` rclone tree remote:path [flags] ``` ## Options ``` -a, --all All files are listed (list . files too) -d, --dirs-only List directories only --dirsfirst List directories before files (-U disables) --full-path Print the full path prefix for each file -h, --help help for tree --level int Descend only level directories deep -D, --modtime Print the date of last modification. --noindent Don't print indentation lines --noreport Turn off file/directory count at end of tree listing -o, --output string Output to file instead of stdout -p, --protections Print the protections for each file. -Q, --quote Quote filenames with double quotes. -s, --size Print the size in bytes of each file. --sort string Select sort: name,version,size,mtime,ctime --sort-ctime Sort files by last status change time -t, --sort-modtime Sort files by last modification time -r, --sort-reverse Reverse the order of the sort -U, --unsorted Leave files unsorted --version Sort files alphanumerically by version ``` Options shared with other commands are described next. See the [global flags page](https://rclone.org/flags/) for global options not listed here. ### Filter Options Flags for filtering directory listings ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ### Listing Options Flags for listing directories ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## See Also * [rclone](https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends. ## Copying single files rclone normally syncs or copies directories. However, if the source remote points to a file, rclone will just copy that file. The destination remote must point to a directory - rclone will give the error `Failed to create file system for "remote:file": is a file not a directory` if it isn't. For example, suppose you have a remote with a file in called `test.jpg`, then you could copy just that file like this ```sh rclone copy remote:test.jpg /tmp/download ``` The file `test.jpg` will be placed inside `/tmp/download`. This is equivalent to specifying ```sh rclone copy --files-from /tmp/files remote: /tmp/download ``` Where `/tmp/files` contains the single line ```sh test.jpg ``` It is recommended to use `copy` when copying individual files, not `sync`. They have pretty much the same effect but `copy` will use a lot less memory. ## Syntax of remote paths The syntax of the paths passed to the rclone command are as follows. ### /path/to/dir This refers to the local file system. On Windows `\` may be used instead of `/` in local paths **only**, non local paths must use `/`. See [local filesystem](https://rclone.org/local/#paths-on-windows) documentation for more about Windows-specific paths. These paths needn't start with a leading `/` - if they don't then they will be relative to the current directory. ### remote:path/to/dir This refers to a directory `path/to/dir` on `remote:` as defined in the config file (configured with `rclone config`). ### remote:/path/to/dir On most backends this is refers to the same directory as `remote:path/to/dir` and that format should be preferred. On a very small number of remotes (FTP, SFTP, Dropbox for business) this will refer to a different directory. On these, paths without a leading `/` will refer to your "home" directory and paths with a leading `/` will refer to the root. ### :backend:path/to/dir This is an advanced form for creating remotes on the fly. `backend` should be the name or prefix of a backend (the `type` in the config file) and all the configuration for the backend should be provided on the command line (or in environment variables). Here are some examples: ```sh rclone lsd --http-url https://pub.rclone.org :http: ``` To list all the directories in the root of `https://pub.rclone.org/`. ```sh rclone lsf --http-url https://example.com :http:path/to/dir ``` To list files and directories in `https://example.com/path/to/dir/` ```sh rclone copy --http-url https://example.com :http:path/to/dir /tmp/dir ``` To copy files and directories in `https://example.com/path/to/dir` to `/tmp/dir`. ```sh rclone copy --sftp-host example.com :sftp:path/to/dir /tmp/dir ``` To copy files and directories from `example.com` in the relative directory `path/to/dir` to `/tmp/dir` using sftp. ### Connection strings {#connection-strings} The above examples can also be written using a connection string syntax, so instead of providing the arguments as command line parameters `--http-url https://pub.rclone.org` they are provided as part of the remote specification as a kind of connection string. ```sh rclone lsd ":http,url='https://pub.rclone.org':" rclone lsf ":http,url='https://example.com':path/to/dir" rclone copy ":http,url='https://example.com':path/to/dir" /tmp/dir rclone copy :sftp,host=example.com:path/to/dir /tmp/dir ``` These can apply to modify existing remotes as well as create new remotes with the on the fly syntax. This example is equivalent to adding the `--drive-shared-with-me` parameter to the remote `gdrive:`. ```sh rclone lsf "gdrive,shared_with_me:path/to/dir" ``` The major advantage to using the connection string style syntax is that it only applies to the remote, not to all the remotes of that type of the command line. A common confusion is this attempt to copy a file shared on google drive to the normal drive which **does not work** because the `--drive-shared-with-me` flag applies to both the source and the destination. ```sh rclone copy --drive-shared-with-me gdrive:shared-file.txt gdrive: ``` However using the connection string syntax, this does work. ```sh rclone copy "gdrive,shared_with_me:shared-file.txt" gdrive: ``` Note that the connection string only affects the options of the immediate backend. If for example gdriveCrypt is a crypt based on gdrive, then the following command **will not work** as intended, because `shared_with_me` is ignored by the crypt backend: ```sh rclone copy "gdriveCrypt,shared_with_me:shared-file.txt" gdriveCrypt: ``` The connection strings have the following syntax ```sh remote,parameter=value,parameter2=value2:path/to/dir :backend,parameter=value,parameter2=value2:path/to/dir ``` If the `parameter` has a `:` or `,` then it must be placed in quotes `"` or `'`, so ```sh remote,parameter="colon:value",parameter2="comma,value":path/to/dir :backend,parameter='colon:value',parameter2='comma,value':path/to/dir ``` If a quoted value needs to include that quote, then it should be doubled, so ```sh remote,parameter="with""quote",parameter2='with''quote':path/to/dir ``` This will make `parameter` be `with"quote` and `parameter2` be `with'quote`. If you leave off the `=parameter` then rclone will substitute `=true` which works very well with flags. For example, to use s3 configured in the environment you could use: ```sh rclone lsd :s3,env_auth: ``` Which is equivalent to ```sh rclone lsd :s3,env_auth=true: ``` Note that on the command line you might need to surround these connection strings with `"` or `'` to stop the shell interpreting any special characters within them. If you are a shell master then you'll know which strings are OK and which aren't, but if you aren't sure then enclose them in `"` and use `'` as the inside quote. This syntax works on all OSes. ```sh rclone copy ":http,url='https://example.com':path/to/dir" /tmp/dir ``` On Linux/macOS some characters are still interpreted inside `"` strings in the shell (notably `\` and `$` and `"`) so if your strings contain those you can swap the roles of `"` and `'` thus. (This syntax does not work on Windows.) ```sh rclone copy ':http,url="https://example.com":path/to/dir' /tmp/dir ``` #### Connection strings, config and logging If you supply extra configuration to a backend by command line flag, environment variable or connection string then rclone will add a suffix based on the hash of the config to the name of the remote, eg ```sh rclone -vv lsf --s3-chunk-size 20M s3: ``` Has the log message ```sh DEBUG : s3: detected overridden config - adding "{Srj1p}" suffix to name ``` This is so rclone can tell the modified remote apart from the unmodified remote when caching the backends. This should only be noticeable in the logs. This means that on the fly backends such as ```sh rclone -vv lsf :s3,env_auth: ``` Will get their own names ```sh DEBUG : :s3: detected overridden config - adding "{YTu53}" suffix to name ``` ### Valid remote names Remote names are case sensitive, and must adhere to the following rules: - May contain number, letter, `_`, `-`, `.`, `+`, `@` and space. - May not start with `-` or space. - May not end with space. Starting with rclone version 1.61, any Unicode numbers and letters are allowed, while in older versions it was limited to plain ASCII (0-9, A-Z, a-z). If you use the same rclone configuration from different shells, which may be configured with different character encoding, you must be cautious to use characters that are possible to write in all of them. This is mostly a problem on Windows, where the console traditionally uses a non-Unicode character set - defined by the so-called "code page". Do not use single character names on Windows as it creates ambiguity with Windows drives' names, e.g.: remote called `C` is indistinguishable from `C` drive. Rclone will always assume that single letter name refers to a drive. ## Adding global configuration to a remote {#globalconfig} It is possible to add global configuration to the remote configuration which will be applied just before the remote is created. This can be done in two ways. The first is to use `override.var = value` in the config file or the connection string for a temporary change, and the second is to use `global.var = value` in the config file or connection string for a permanent change. This is explained fully below. ### override.var This is used to override a global variable **just** for the duration of the remote creation. It won't affect other remotes even if they are created at the same time. This is very useful for overriding networking config needed for just for that remote. For example, say you have a remote which needs `--no-check-certificate` as it is running on test infrastructure without a proper certificate. You could supply the `--no-check-certificate` flag to rclone, but this will affect **all** the remotes. To make it just affect this remote you use an override. You could put this in the config file: ```ini [remote] type = XXX ... override.no_check_certificate = true ``` or use it in the connection string `remote,override.no_check_certificate=true:` (or just `remote,override.no_check_certificate:`). Note how the global flag name loses its initial `--` and gets `-` replaced with `_` and gets an `override.` prefix. Not all global variables make sense to be overridden like this as the config is only applied during the remote creation. Here is a non exhaustive list of ones which might be useful: - `bind_addr` - `ca_cert` - `client_cert` - `client_key` - `connect_timeout` - `disable_http2` - `disable_http_keep_alives` - `dump` - `expect_continue_timeout` - `headers` - `http_proxy` - `low_level_retries` - `max_connections` - `no_check_certificate` - `no_gzip` - `timeout` - `traffic_class` - `use_cookies` - `use_server_modtime` - `user_agent` An `override.var` will override all other config methods, but **just** for the duration of the creation of the remote. ### global.var This is used to set a global variable **for everything**. The global variable is set just before the remote is created. This is useful for parameters (eg sync parameters) which can't be set as an `override`. For example, say you have a remote where you would always like to use the `--checksum` flag. You could supply the `--checksum` flag to rclone on every command line, but instead you could put this in the config file: ```ini [remote] type = XXX ... global.checksum = true ``` or use it in the connection string `remote,global.checksum=true:` (or just `remote,global.checksum:`). This is equivalent to using the `--checksum` flag. Note how the global flag name loses its initial `--` and gets `-` replaced with `_` and gets a `global.` prefix. Any global variable can be set like this and it is exactly equivalent to using the equivalent flag on the command line. This means it will affect all uses of rclone. If two remotes set the same global variable then the first one instantiated will be overridden by the second one. A `global.var` will override all other config methods when the remote is created. ## Quoting and the shell When you are typing commands to your computer you are using something called the command line shell. This interprets various characters in an OS specific way. Here are some gotchas which may help users unfamiliar with the shell rules ### Linux / macOS If your names have spaces or shell metacharacters (e.g. `*`, `?`, `$`, `'`, `"`, etc.) then you must quote them. Use single quotes `'` by default. ```sh rclone copy 'Important files?' remote:backup ``` If you want to send a `'` you will need to use `"`, e.g. ```sh rclone copy "O'Reilly Reviews" remote:backup ``` The rules for quoting metacharacters are complicated and if you want the full details you'll have to consult the manual page for your shell. ### Windows If your names have spaces in you need to put them in `"`, e.g. ```bat rclone copy "E:\folder name\folder name\folder name" remote:backup ``` If you are using the root directory on its own then don't quote it (see [#464](https://github.com/rclone/rclone/issues/464) for why), e.g. ```bat rclone copy E:\ remote:backup ``` ## Copying files or directories with `:` in the names rclone uses `:` to mark a remote name. This is, however, a valid filename component in non-Windows OSes. The remote name parser will only search for a `:` up to the first `/` so if you need to act on a file or directory like this then use the full path starting with a `/`, or use `./` as a current directory prefix. So to sync a directory called `sync:me` to a remote called `remote:` use ```sh rclone sync --interactive ./sync:me remote:path ``` or ```sh rclone sync --interactive /full/path/to/sync:me remote:path ``` ## Server-side copy Most remotes (but not all - see [the overview](https://rclone.org/overview/#optional-features)) support server-side copy. This means if you want to copy one folder to another then rclone won't download all the files and re-upload them; it will instruct the server to copy them in place. Eg ```sh rclone copy s3:oldbucket s3:newbucket ``` Will copy the contents of `oldbucket` to `newbucket` without downloading and re-uploading. Remotes which don't support server-side copy **will** download and re-upload in this case. Server-side copies are used with `sync` and `copy` and will be identified in the log when using the `-v` flag. The `move` command may also use them if remote doesn't support server-side move directly. This is done by issuing a server-side copy then a delete which is much quicker than a download and re-upload. Server-side copies will only be attempted if the remote names are the same. This can be used when scripting to make aged backups efficiently, e.g. ```sh rclone sync --interactive remote:current-backup remote:previous-backup rclone sync --interactive /path/to/files remote:current-backup ``` ## Metadata support {#metadata} Metadata is data about a file (or directory) which isn't the contents of the file (or directory). Normally rclone only preserves the modification time and the content (MIME) type where possible. Rclone supports preserving all the available metadata on files and directories when using the `--metadata` or `-M` flag. Exactly what metadata is supported and what that support means depends on the backend. Backends that support metadata have a metadata section in their docs and are listed in the [features table](https://rclone.org/overview/#features) (Eg [local](https://rclone.org/local/#metadata), [s3](/s3/#metadata)) Some backends don't support metadata, some only support metadata on files and some support metadata on both files and directories. Rclone only supports a one-time sync of metadata. This means that metadata will be synced from the source object to the destination object only when the source object has changed and needs to be re-uploaded. If the metadata subsequently changes on the source object without changing the object itself then it won't be synced to the destination object. This is in line with the way rclone syncs `Content-Type` without the `--metadata` flag. Using `--metadata` when syncing from local to local will preserve file attributes such as file mode, owner, extended attributes (not Windows). Note that arbitrary metadata may be added to objects using the `--metadata-set key=value` flag when the object is first uploaded. This flag can be repeated as many times as necessary. The [--metadata-mapper](#metadata-mapper) flag can be used to pass the name of a program in which can transform metadata when it is being copied from source to destination. Rclone supports `--metadata-set` and `--metadata-mapper` when doing server-side `Move` and server-side `Copy`, but not when doing server side `DirMove` (renaming a directory) as this would involve recursing into the directory. Note that you can disable `DirMove` with `--disable DirMove` and rclone will revert back to using `Move` for each individual object where `--metadata-set` and `--metadata-mapper` are supported. ### Types of metadata Metadata is divided into two type. System metadata and User metadata. Metadata which the backend uses itself is called system metadata. For example on the local backend the system metadata `uid` will store the user ID of the file when used on a unix based platform. Arbitrary metadata is called user metadata and this can be set however is desired. When objects are copied from backend to backend, they will attempt to interpret system metadata if it is supplied. Metadata may change from being user metadata to system metadata as objects are copied between different backends. For example copying an object from s3 sets the `content-type` metadata. In a backend which understands this (like `azureblob`) this will become the Content-Type of the object. In a backend which doesn't understand this (like the `local` backend) this will become user metadata. However should the local object be copied back to s3, the Content-Type will be set correctly. ### Metadata framework Rclone implements a metadata framework which can read metadata from an object and write it to the object when (and only when) it is being uploaded. This metadata is stored as a dictionary with string keys and string values. There are some limits on the names of the keys (these may be clarified further in the future). - must be lower case - may be `a-z` `0-9` containing `.` `-` or `_` - length is backend dependent Each backend can provide system metadata that it understands. Some backends can also store arbitrary user metadata. Where possible the key names are standardized, so, for example, it is possible to copy object metadata from s3 to azureblob for example and metadata will be translated appropriately. Some backends have limits on the size of the metadata and rclone will give errors on upload if they are exceeded. ### Metadata preservation The goal of the implementation is to 1. Preserve metadata if at all possible 2. Interpret metadata if at all possible The consequences of 1 is that you can copy an S3 object to a local disk then back to S3 losslessly. Likewise you can copy a local file with file attributes and xattrs from local disk to s3 and back again losslessly. The consequence of 2 is that you can copy an S3 object with metadata to Azureblob (say) and have the metadata appear on the Azureblob object also. ### Standard system metadata Here is a table of standard system metadata which, if appropriate, a backend may implement. | key | description | example | |---------------------|-------------|---------| | mode | File type and mode: octal, unix style | 0100664 | | uid | User ID of owner: decimal number | 500 | | gid | Group ID of owner: decimal number | 500 | | rdev | Device ID (if special file) => hexadecimal | 0 | | atime | Time of last access: RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | | mtime | Time of last modification: RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | | btime | Time of file creation (birth): RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | | utime | Time of file upload: RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | | cache-control | Cache-Control header | no-cache | | content-disposition | Content-Disposition header | inline | | content-encoding | Content-Encoding header | gzip | | content-language | Content-Language header | en-US | | content-type | Content-Type header | text/plain | The metadata keys `mtime` and `content-type` will take precedence if supplied in the metadata over reading the `Content-Type` or modification time of the source object. Hashes are not included in system metadata as there is a well defined way of reading those already. ## Options Rclone has a number of options to control its behaviour. These are documented below, and in the [flags](/flags) page. Options that take parameters can have the values passed in two ways, `--option=value` or `--option value`. However boolean (true/false) options behave slightly differently to the other options in that `--boolean` sets the option to `true` and the absence of the flag sets it to `false`. It is also possible to specify `--boolean=false` or `--boolean=true`. Note that `--boolean false` is not valid - this is parsed as `--boolean` and the `false` is parsed as an extra command line argument for rclone. String values that are recognized as special identifiers, e.g. the name of the log level to set with option `--log-level`, are case insensitive, e.g. `--log-level ERROR` and `--log-level error` are identical. Options documented to take a `stringArray` parameter accept multiple values. To pass more than one value, repeat the option; for example: `--include value1 --include value2`. Other options may only accept a single value, and should only be specified once, but where the specified parameter may indicate a list of values separated by space or comma. Such options are documented to take a `CommaSepList` parameter, if comma separated, and `SpaceSepList` if space separated, although some may also have different parameters such as `DumpFlags` or just `string` and the help text explains that this will be interpreted as a list. Floating-point values with fractional part must use period (`.`) as decimal separator, common in English-speaking countries, regardless of your configured system locale. Parameter type `float` accepts decimal and hexadecimal floating-point numbers as defined by the Go syntax for [floating-point literals](https://go.dev/ref/spec#Floating-point_literals). ### Time and duration options {#time-options} Options that take a `Time` or `Duration` parameter must be specified as a formatted string describing an absolute or relative time. Note that both `Time` and `Duration` parameter types can be expressed as either absolute or relative time, just with different interpretations, e.g. a relative time will be treated as an offset from the current time when passed as a `Time` value. An absolute time can be specified as a string in one of the following formats: - RFC3339 - e.g. `2006-01-02T15:04:05Z` or `2006-01-02T15:04:05+07:00` - ISO8601 Date and time, local timezone - `2006-01-02T15:04:05` - ISO8601 Date and time, local timezone - `2006-01-02 15:04:05` - ISO8601 Date - `2006-01-02` (YYYY-MM-DD) A relative time is a string with a, possibly signed, sequence of decimal numbers, each with optional fraction, and each with a unit suffix. If the string only contains a single number, then the unit suffix is optional and will default to seconds, i.e. a plain decimal value will be treated as a number of seconds. The following suffixes are valid: - `ms` - Milliseconds - `s` - Seconds - `m` - Minutes - `h` - Hours - `d` - Days - `w` - Weeks - `M` - Months - `y` - Years Examples: "10", "300ms", "-1.5h" or "2h45m". ### Size options Options that take a SizeSuffix parameter can be specified as an integer value, which will then be assumed to represent a KiB value (multiples of 1024 bytes) by default. The interpretation can be changed by appending a suffix: `B` for Byte, `K` for KiB, `M` for MiB, `G` for GiB, `T` for TiB and `P` for PiB. These are the binary units, e.g. 1, 2\*\*10, 2\*\*20, 2\*\*30 respectively. See also [--human-readable](#human-readable). ## Main options ### --backup-dir string When using [sync](https://rclone.org/commands/rclone_sync/), [copy](https://rclone.org/commands/rclone_copy/) or [move](https://rclone.org/commands/rclone_move/), any files which would have been overwritten or deleted are moved in their original hierarchy into this directory. If `--suffix` is set, then the moved files will have the suffix added to them. If there is a file with the same path (after the suffix has been added) in the directory, then it will be overwritten. The remote in use must support server-side move or copy and you must use the same remote as the destination of the sync. The backup directory must not overlap the destination directory without it being excluded by a filter rule. For example ```sh rclone sync --interactive /path/to/local remote:current --backup-dir remote:old ``` will sync `/path/to/local` to `remote:current`, but for any files which would have been updated or deleted will be stored in `remote:old`. If running rclone from a script you might want to use today's date as the directory name passed to `--backup-dir` to store the old files, or you might want to pass `--suffix` with today's date. See `--compare-dest` and `--copy-dest`. ### --bind string Local address to bind to for outgoing connections. This can be an IPv4 address (1.2.3.4), an IPv6 address (1234::789A) or host name. If the host name doesn't resolve or resolves to more than one IP address it will give an error. You can use `--bind 0.0.0.0` to force rclone to use IPv4 addresses and `--bind ::0` to force rclone to use IPv6 addresses. ### --bwlimit BwTimetable This option controls the bandwidth limit. For example ```sh --bwlimit 10M ``` would mean limit the upload and download bandwidth to 10 MiB/s. **NB** this is **bytes** per second not **bits** per second. To use a single limit, specify the desired bandwidth in KiB/s, or use a suffix B|K|M|G|T|P. The default is `0` which means to not limit bandwidth. The upload and download bandwidth can be specified separately, as `--bwlimit UP:DOWN`, so ```sh --bwlimit 10M:100k ``` would mean limit the upload bandwidth to 10 MiB/s and the download bandwidth to 100 KiB/s. Either limit can be "off" meaning no limit, so to just limit the upload bandwidth you would use ```sh --bwlimit 10M:off ``` this would limit the upload bandwidth to 10 MiB/s but the download bandwidth would be unlimited. When specified as above the bandwidth limits last for the duration of run of the rclone binary. It is also possible to specify a "timetable" of limits, which will cause certain limits to be applied at certain times. To specify a timetable, format your entries as `WEEKDAY-HH:MM,BANDWIDTH WEEKDAY-HH:MM,BANDWIDTH...` where: `WEEKDAY` is optional element. - `BANDWIDTH` can be a single number, e.g.`100k` or a pair of numbers for upload:download, e.g.`10M:1M`. - `WEEKDAY` can be written as the whole word or only using the first 3 characters. It is optional. - `HH:MM` is an hour from 00:00 to 23:59. Entries can be separated by spaces or semicolons. **Note:** Semicolons can be used as separators instead of spaces to avoid parsing issues in environments like Docker. An example of a typical timetable to avoid link saturation during daytime working hours could be: Using spaces as separators: `--bwlimit "08:00,512k 12:00,10M 13:00,512k 18:00,30M 23:00,off"` Using semicolons as separators: `--bwlimit "08:00,512k;12:00,10M;13:00,512k;18:00,30M;23:00,off"` In these examples, the transfer bandwidth will be set to 512 KiB/s at 8am every day. At noon, it will rise to 10 MiB/s, and drop back to 512 KiB/sec at 1pm. At 6pm, the bandwidth limit will be set to 30 MiB/s, and at 11pm it will be completely disabled (full speed). Anything between 11pm and 8am will remain unlimited. An example of timetable with `WEEKDAY` could be: Using spaces as separators: `--bwlimit "Mon-00:00,512 Fri-23:59,10M Sat-10:00,1M Sun-20:00,off"` Using semicolons as separators: `--bwlimit "Mon-00:00,512;Fri-23:59,10M;Sat-10:00,1M;Sun-20:00,off"` It means that, the transfer bandwidth will be set to 512 KiB/s on Monday. It will rise to 10 MiB/s before the end of Friday. At 10:00 on Saturday it will be set to 1 MiB/s. From 20:00 on Sunday it will be unlimited. Timeslots without `WEEKDAY` are extended to the whole week. So this example: ```sh --bwlimit "Mon-00:00,512 12:00,1M Sun-20:00,off" ``` Is equivalent to this: ```sh --bwlimit "Mon-00:00,512Mon-12:00,1M Tue-12:00,1M Wed-12:00,1M Thu-12:00,1M Fri-12:00,1M Sat-12:00,1M Sun-12:00,1M Sun-20:00,off" ``` Bandwidth limit apply to the data transfer for all backends. For most backends the directory listing bandwidth is also included (exceptions being the non HTTP backends, `ftp`, `sftp` and `storj`). Note that the units are **Byte/s**, not **bit/s**. Typically connections are measured in bit/s - to convert divide by 8. For example, let's say you have a 10 Mbit/s connection and you wish rclone to use half of it - 5 Mbit/s. This is 5/8 = 0.625 MiB/s so you would use a `--bwlimit 0.625M` parameter for rclone. On Unix systems (Linux, macOS, …) the bandwidth limiter can be toggled by sending a `SIGUSR2` signal to rclone. This allows to remove the limitations of a long running rclone transfer and to restore it back to the value specified with `--bwlimit` quickly when needed. Assuming there is only one rclone instance running, you can toggle the limiter like this: ```sh kill -SIGUSR2 $(pidof rclone) ``` If you configure rclone with a [remote control](/rc) then you can use change the bwlimit dynamically: ```sh rclone rc core/bwlimit rate=1M ``` ### --bwlimit-file BwTimetable This option controls per file bandwidth limit. For the options see the `--bwlimit` flag. For example use this to allow no transfers to be faster than 1 MiB/s ```sh --bwlimit-file 1M ``` This can be used in conjunction with `--bwlimit`. Note that if a schedule is provided the file will use the schedule in effect at the start of the transfer. ### --buffer-size SizeSuffix Use this sized buffer to speed up file transfers. Each `--transfer` will use this much memory for buffering. When using `mount` or `cmount` each open file descriptor will use this much memory for buffering. See the [mount](https://rclone.org/commands/rclone_mount/#file-buffering) documentation for more details. Set to `0` to disable the buffering for the minimum memory usage. Note that the memory allocation of the buffers is influenced by the [--use-mmap](#use-mmap) flag. ### --cache-dir string Specify the directory rclone will use for caching, to override the default. Default value is depending on operating system: - Windows `%LocalAppData%\rclone`, if `LocalAppData` is defined. - macOS `$HOME/Library/Caches/rclone` if `HOME` is defined. - Unix `$XDG_CACHE_HOME/rclone` if `XDG_CACHE_HOME` is defined, else `$HOME/.cache/rclone` if `HOME` is defined. - Fallback (on all OS) to `$TMPDIR/rclone`, where `TMPDIR` is the value from [--temp-dir](#temp-dir-string). You can use the [config paths](https://rclone.org/commands/rclone_config_paths/) command to see the current value. Cache directory is heavily used by the [VFS File Caching](https://rclone.org/commands/rclone_mount/#vfs-file-caching) mount feature, but also by [serve](https://rclone.org/commands/rclone_serve/), [GUI](/gui) and other parts of rclone. ### --check-first If this flag is set then in a [sync](https://rclone.org/commands/rclone_sync/), [copy](https://rclone.org/commands/rclone_copy/) or [move](https://rclone.org/commands/rclone_move/), rclone will do all the checks to see whether files need to be transferred before doing any of the transfers. Normally rclone would start running transfers as soon as possible. This flag can be useful on IO limited systems where transfers interfere with checking. It can also be useful to ensure perfect ordering when using `--order-by`. If both `--check-first` and `--order-by` are set when doing `rclone move` then rclone will use the transfer thread to delete source files which don't need transferring. This will enable perfect ordering of the transfers and deletes but will cause the transfer stats to have more items in than expected. Using this flag can use more memory as it effectively sets `--max-backlog` to infinite. This means that all the info on the objects to transfer is held in memory before the transfers start. ### --checkers int Originally controlling just the number of file checkers to run in parallel, e.g. by `rclone copy`. Now a fairly universal parallelism control used by `rclone` in several places. Note: checkers do the equality checking of files during a sync. For some storage systems (e.g. S3, Swift, Dropbox) this can take a significant amount of time so they are run in parallel. The default is to run 8 checkers in parallel. However, in case of slow-reacting backends you may need to lower (rather than increase) this default by setting `--checkers` to 4 or less threads. This is especially advised if you are experiencing backend server crashes during file checking phase (e.g. on subsequent or top-up backups where little or no file copying is done and checking takes up most of the time). Increase this setting only with utmost care, while monitoring your server health and file checking throughput. ### -c, --checksum Normally rclone will look at modification time and size of files to see if they are equal. If you set this flag then rclone will check the file hash and size to determine if files are equal. This is useful when the remote doesn't support setting modified time and a more accurate sync is desired than just checking the file size. This is very useful when transferring between remotes which store the same hash type on the object, e.g. Drive and Swift. For details of which remotes support which hash type see the table in the [overview section](https://rclone.org/overview/). Eg `rclone --checksum sync s3:/bucket swift:/bucket` would run much quicker than without the `--checksum` flag. When using this flag, rclone won't update mtimes of remote files if they are incorrect as it would normally. ### --color AUTO|NEVER|ALWAYS Specify when colors (and other ANSI codes) should be added to the output. `AUTO` only allows ANSI codes when the output is a terminal. This is the default. `NEVER` never allow ANSI codes. `ALWAYS` always add ANSI codes, regardless of the output format (terminal or file). ### --compare-dest stringArray When using [sync](https://rclone.org/commands/rclone_sync/), [copy](https://rclone.org/commands/rclone_copy/) or [move](https://rclone.org/commands/rclone_move/), the specified paths are checked in addition to the destination for files. If a file identical to the source is found, that file is **not** copied from source. This is useful to copy just files that have changed since the last backup. You must use the same remote as the destination of the sync. The compare directory must not overlap the destination directory. See `--copy-dest` and `--backup-dir`. ### --config string Specify the location of the rclone configuration file, to override the default. E.g. `rclone config --config="rclone.conf"`. The exact default is a bit complex to describe, due to changes introduced through different versions of rclone while preserving backwards compatibility, but in most cases it is as simple as: - `%APPDATA%/rclone/rclone.conf` on Windows - `~/.config/rclone/rclone.conf` on other The complete logic is as follows: Rclone will look for an existing configuration file in any of the following locations, in priority order: 1. `rclone.conf` (in program directory, where rclone executable is) 2. `%APPDATA%/rclone/rclone.conf` (only on Windows) 3. `$XDG_CONFIG_HOME/rclone/rclone.conf` (on all systems, including Windows) 4. `~/.config/rclone/rclone.conf` (see below for explanation of ~ symbol) 5. `~/.rclone.conf` If no existing configuration file is found, then a new one will be created in the following location: - On Windows: Location 2 listed above, except in the unlikely event that `APPDATA` is not defined, then location 4 is used instead. - On Unix: Location 3 if `XDG_CONFIG_HOME` is defined, else location 4. - Fallback to location 5 (on all OS), when the rclone directory cannot be created, but if also a home directory was not found then path `.rclone.conf` relative to current working directory will be used as a final resort. The `~` symbol in paths above represent the home directory of the current user on any OS, and the value is defined as following: - On Windows: `%HOME%` if defined, else `%USERPROFILE%`, or else `%HOMEDRIVE%\%HOMEPATH%`. - On Unix: `$HOME` if defined, else by looking up current user in OS-specific user database (e.g. passwd file), or else use the result from shell command `cd && pwd`. If you run `rclone config file` you will see where the default location is for you. Running `rclone config touch` will ensure a configuration file exists, creating an empty one in the default location if there is none. The fact that an existing file `rclone.conf` in the same directory as the rclone executable is always preferred, means that it is easy to run in "portable" mode by downloading rclone executable to a writable directory and then create an empty file `rclone.conf` in the same directory. If the location is set to empty string `""` or path to a file with name `notfound`, or the os null device represented by value `NUL` on Windows and `/dev/null` on Unix systems, then rclone will keep the configuration file in memory only. You may see a log message "Config file not found - using defaults" if there is no configuration file. This can be supressed, e.g. if you are using rclone entirely with [on the fly remotes](https://rclone.org/docs/#backend-path-to-dir), by using memory-only configuration file or by creating an empty configuration file, as described above. The file format is basic [INI](https://en.wikipedia.org/wiki/INI_file#Format): Sections of text, led by a `[section]` header and followed by `key=value` entries on separate lines. In rclone each remote is represented by its own section, where the section name defines the name of the remote. Options are specified as the `key=value` entries, where the key is the option name without the `--backend-` prefix, in lowercase and with `_` instead of `-`. E.g. option `--mega-hard-delete` corresponds to key `hard_delete`. Only backend options can be specified. A special, and required, key `type` identifies the [storage system](https://rclone.org/overview/), where the value is the internal lowercase name as returned by command `rclone help backends`. Comments are indicated by `;` or `#` at the beginning of a line. Example: ```ini [megaremote] type = mega user = you@example.com pass = PDPcQVVjVtzFY-GTdDFozqBhTdsPg3qH ``` Note that passwords are in [obscured](https://rclone.org/commands/rclone_obscure/) form. Also, many storage systems uses token-based authentication instead of passwords, and this requires additional steps. It is easier, and safer, to use the interactive command `rclone config` instead of manually editing the configuration file. The configuration file will typically contain login information, and should therefore have restricted permissions so that only the current user can read it. Rclone tries to ensure this when it writes the file. You may also choose to [encrypt](#configuration-encryption) the file. When token-based authentication are used, the configuration file must be writable, because rclone needs to update the tokens inside it. To reduce risk of corrupting an existing configuration file, rclone will not write directly to it when saving changes. Instead it will first write to a new, temporary, file. If a configuration file already existed, it will (on Unix systems) try to mirror its permissions to the new file. Then it will rename the existing file to a temporary name as backup. Next, rclone will rename the new file to the correct name, before finally cleaning up by deleting the backup file. If the configuration file path used by rclone is a symbolic link, then this will be evaluated and rclone will write to the resolved path, instead of overwriting the symbolic link. Temporary files used in the process (described above) will be written to the same parent directory as that of the resolved configuration file, but if this directory is also a symbolic link it will not be resolved and the temporary files will be written to the location of the directory symbolic link. ### --contimeout Duration Set the connection timeout. This should be in go time format which looks like `5s` for 5 seconds, `10m` for 10 minutes, or `3h30m`. The connection timeout is the amount of time rclone will wait for a connection to go through to a remote object storage system. It is `1m` by default. ### --copy-dest stringArray When using [sync](https://rclone.org/commands/rclone_sync/), [copy](https://rclone.org/commands/rclone_copy/) or [move](https://rclone.org/commands/rclone_move/), the specified paths are checked in addition to the destination for files. This part is the same as `--compare-dest`, but the difference is that with `--copy-dest`, if a file identical to the source is found, that file is server-side copied from the specified paths to the destination. This is useful for incremental backup. The remote in use must support server-side copy and you must use the same remote as the destination of the sync. The compare directory must not overlap the destination directory. See `--compare-dest` and `--backup-dir`. ### --dedupe-mode interactive|skip|first|newest|oldest|largest|smallest|rename|list Mode to run dedupe command in. One of `interactive`, `skip`, `first`, `newest`, `oldest`, `largest`, `smallest`, `rename` `list`. The default is `interactive`. See the [dedupe](https://rclone.org/commands/rclone_dedupe/) command for more information as to what these options mean. ### --default-time Time If a file or directory does have a modification time rclone can read then rclone will display this fixed time instead. The default is `2000-01-01 00:00:00 UTC`. This can be configured in any of the ways shown in [time options](#time-options). For example `--default-time 2020-06-01` to set the default time to the 1st of June 2020 or `--default-time 0s` to set the default time to the time rclone started up. ### --disable string This disables a comma separated list of optional features. For example to disable server-side move and server-side copy use: ```sh --disable move,copy ``` The features can be put in any case. To see a list of which features can be disabled use: ```sh --disable help ``` The features a remote has can be seen in JSON format with: ```sh rclone backend features remote: ``` See the overview [features](https://rclone.org/overview/#features) and [optional features](https://rclone.org/overview/#optional-features) to get an idea of which feature does what. Note that some features can be set to `true` if they are `true`/`false` feature flag features by prefixing them with `!`. For example the `CaseInsensitive` feature can be forced to `false` with `--disable CaseInsensitive` and forced to `true` with `--disable '!CaseInsensitive'`. In general it isn't a good idea doing this but it may be useful in extremis. (Note that `!` is a shell command which you will need to escape with single quotes or a backslash on unix like platforms.) This flag can be useful for debugging and in exceptional circumstances (e.g. Google Drive limiting the total volume of server-side copies to 100 GiB/day). ### --disable-http2 This stops rclone from trying to use HTTP/2 if available. This can sometimes speed up transfers due to a [problem in the Go standard library](https://github.com/golang/go/issues/37373). ### --dscp string Specify a DSCP value or name to use in connections. This could help QoS system to identify traffic class. BE, EF, DF, LE, CSx and AFxx are allowed. See the description of [differentiated services](https://en.wikipedia.org/wiki/Differentiated_services) to get an idea of this field. Setting this to 1 (LE) to identify the flow to SCAVENGER class can avoid occupying too much bandwidth in a network with DiffServ support ([RFC 8622](https://tools.ietf.org/html/rfc8622)). For example, if you configured QoS on router to handle LE properly. Running: ```sh rclone copy --dscp LE from:/from to:/to ``` would make the priority lower than usual internet flows. This option has no effect on Windows (see [golang/go#42728](https://github.com/golang/go/issues/42728)). ### -n, --dry-run Do a trial run with no permanent changes. Use this to see what rclone would do without actually doing it. Useful when setting up the [sync](https://rclone.org/commands/rclone_sync/) command which deletes files in the destination. ### --expect-continue-timeout Duration This specifies the amount of time to wait for a server's first response headers after fully writing the request headers if the request has an "Expect: 100-continue" header. Not all backends support using this. Zero means no timeout and causes the body to be sent immediately, without waiting for the server to approve. This time does not include the time to send the request header. The default is `1s`. Set to `0` to disable. ### --error-on-no-transfer By default, rclone will exit with return code 0 if there were no errors. This option allows rclone to return exit code 9 if no files were transferred between the source and destination. This allows using rclone in scripts, and triggering follow-on actions if data was copied, or skipping if not. NB: Enabling this option turns a usually non-fatal error into a potentially fatal one - please check and adjust your scripts accordingly! ### --fix-case Normally, a sync to a case insensitive dest (such as macOS / Windows) will not result in a matching filename if the source and dest filenames have casing differences but are otherwise identical. For example, syncing `hello.txt` to `HELLO.txt` will normally result in the dest filename remaining `HELLO.txt`. If `--fix-case` is set, then `HELLO.txt` will be renamed to `hello.txt` to match the source. NB: - directory names with incorrect casing will also be fixed - `--fix-case` will be ignored if `--immutable` is set - using `--local-case-sensitive` instead is not advisable; it will cause `HELLO.txt` to get deleted! - the old dest filename must not be excluded by filters. Be especially careful with [`--files-from`](https://rclone.org/filtering/#files-from-read-list-of-source-file-names), which does not respect [`--ignore-case`](https://rclone.org/filtering/#ignore-case-make-searches-case-insensitive)! - on remotes that do not support server-side move, `--fix-case` will require downloading the file and re-uploading it. To avoid this, do not use `--fix-case`. ### --fs-cache-expire-duration Duration When using rclone via the API rclone caches created remotes for 5 minutes by default in the "fs cache". This means that if you do repeated actions on the same remote then rclone won't have to build it again from scratch, which makes it more efficient. This flag sets the time that the remotes are cached for. If you set it to `0` (or negative) then rclone won't cache the remotes at all. Note that if you use some flags, eg `--backup-dir` and if this is set to `0` rclone may build two remotes (one for the source or destination and one for the `--backup-dir` where it may have only built one before. ### --fs-cache-expire-interval Duration This controls how often rclone checks for cached remotes to expire. See the `--fs-cache-expire-duration` documentation above for more info. The default is 60s, set to 0 to disable expiry. ### --header stringArray Add an HTTP header for all transactions. The flag can be repeated to add multiple headers. If you want to add headers only for uploads use `--header-upload` and if you want to add headers only for downloads use `--header-download`. This flag is supported for all HTTP based backends even those not supported by `--header-upload` and `--header-download` so may be used as a workaround for those with care. ```sh rclone ls remote:test --header "X-Rclone: Foo" --header "X-LetMeIn: Yes" ``` ### --header-download stringArray Add an HTTP header for all download transactions. The flag can be repeated to add multiple headers. ```sh rclone sync --interactive s3:test/src ~/dst --header-download "X-Amz-Meta-Test: Foo" --header-download "X-Amz-Meta-Test2: Bar" ``` See GitHub issue [#59](https://github.com/rclone/rclone/issues/59) for currently supported backends. ### --header-upload stringArray Add an HTTP header for all upload transactions. The flag can be repeated to add multiple headers. ```sh rclone sync --interactive ~/src s3:test/dst --header-upload "Content-Disposition: attachment; filename='cool.html'" --header-upload "X-Amz-Meta-Test: FooBar" ``` See GitHub issue [#59](https://github.com/rclone/rclone/issues/59) for currently supported backends. ### --http-proxy string Use this option to set an HTTP proxy for all HTTP based services to use. Rclone also supports the standard HTTP proxy environment variables which it will pick up automatically. The is the way the HTTP proxy will normally be set but this flag can be used to override it. ### --human-readable Rclone commands output values for sizes (e.g. number of bytes) and counts (e.g. number of files) either as *raw* numbers, or in *human-readable* format. In human-readable format the values are scaled to larger units, indicated with a suffix shown after the value, and rounded to three decimals. Rclone consistently uses binary units (powers of 2) for sizes and decimal units (powers of 10) for counts. The unit prefix for size is according to IEC standard notation, e.g. `Ki` for kibi. Used with byte unit, `1 KiB` means 1024 Byte. In list type of output, only the unit prefix appended to the value (e.g. `9.762Ki`), while in more textual output the full unit is shown (e.g. `9.762 KiB`). For counts the SI standard notation is used, e.g. prefix `k` for kilo. Used with file counts, `1k` means 1000 files. The various [list](https://rclone.org/commands/rclone_ls/) commands output raw numbers by default. Option `--human-readable` will make them output values in human-readable format instead (with the short unit prefix). The [about](https://rclone.org/commands/rclone_about/) command outputs human-readable by default, with a command-specific option `--full` to output the raw numbers instead. Command [size](https://rclone.org/commands/rclone_size/) outputs both human-readable and raw numbers in the same output. The [tree](https://rclone.org/commands/rclone_tree/) command also considers `--human-readable`, but it will not use the exact same notation as the other commands: It rounds to one decimal, and uses single letter suffix, e.g. `K` instead of `Ki`. The reason for this is that it relies on an external library. The interactive command [ncdu](https://rclone.org/commands/rclone_ncdu/) shows human-readable by default, and responds to key `u` for toggling human-readable format. ### --ignore-case-sync Using this option will cause rclone to ignore the case of the files when synchronizing so files will not be copied/synced when the existing filenames are the same, even if the casing is different. ### --ignore-checksum Normally rclone will check that the checksums of transferred files match, and give an error "corrupted on transfer" if they don't. You can use this option to skip that check. You should only use it if you have had the "corrupted on transfer" error message and you are sure you might want to transfer potentially corrupted data. ### --ignore-existing Using this option will make rclone unconditionally skip all files that exist on the destination, no matter the content of these files. While this isn't a generally recommended option, it can be useful in cases where your files change due to encryption. However, it cannot correct partial transfers in case a transfer was interrupted. When performing a `move`/`moveto` command, this flag will leave skipped files in the source location unchanged when a file with the same name exists on the destination. ### --ignore-size Normally rclone will look at modification time and size of files to see if they are equal. If you set this flag then rclone will check only the modification time. If `--checksum` is set then it only checks the checksum. It will also cause rclone to skip verifying the sizes are the same after transfer. This can be useful for transferring files to and from OneDrive which occasionally misreports the size of image files (see [#399](https://github.com/rclone/rclone/issues/399) for more info). ### -I, --ignore-times Using this option will cause rclone to unconditionally upload all files regardless of the state of files on the destination. Normally rclone would skip any files that have the same modification time and are the same size (or have the same checksum if using `--checksum`). ### --immutable Treat source and destination files as immutable and disallow modification. With this option set, files will be created and deleted as requested, but existing files will never be updated. If an existing file does not match between the source and destination, rclone will give the error `Source and destination exist but do not match: immutable file modified`. Note that only commands which transfer files (e.g. [sync](https://rclone.org/commands/rclone_sync/), [copy](https://rclone.org/commands/rclone_copy/) or [move](https://rclone.org/commands/rclone_move/)) are affected by this behavior, and only modification is disallowed. Files may still be deleted explicitly (e.g. [delete](https://rclone.org/commands/rclone_delete/), [purge](https://rclone.org/commands/rclone_purge/)) or implicitly (e.g. [sync](https://rclone.org/commands/rclone_sync/), [move](https://rclone.org/commands/rclone_move/)). Use `copy --immutable` if it is desired to avoid deletion as well as modification. This can be useful as an additional layer of protection for immutable or append-only data sets (notably backup archives), where modification implies corruption and should not be propagated. ### --inplace {#inplace} The `--inplace` flag changes the behaviour of rclone when uploading files to some backends (backends with the `PartialUploads` feature flag set) such as: - local - ftp - sftp - pcloud Without `--inplace` (the default) rclone will first upload to a temporary file with an extension like this, where `XXXXXX` represents a hash of the source file's fingerprint and `.partial` is [--partial-suffix](#partial-suffix) value (`.partial` by default). ```text original-file-name.XXXXXX.partial ``` (rclone will make sure the final name is no longer than 100 characters by truncating the `original-file-name` part if necessary). When the upload is complete, rclone will rename the `.partial` file to the correct name, overwriting any existing file at that point. If the upload fails then the `.partial` file will be deleted. This prevents other users of the backend from seeing partially uploaded files in their new names and prevents overwriting the old file until the new one is completely uploaded. If the `--inplace` flag is supplied, rclone will upload directly to the final name without creating a `.partial` file. This means that an incomplete file will be visible in the directory listings while the upload is in progress and any existing files will be overwritten as soon as the upload starts. If the transfer fails then the file will be deleted. This can cause data loss of the existing file if the transfer fails. Note that on the local file system if you don't use `--inplace` hard links (Unix only) will be broken. And if you do use `--inplace` you won't be able to update in use executables. Note also that versions of rclone prior to v1.63.0 behave as if the `--inplace` flag is always supplied. ### -i, --interactive {#interactive} This flag can be used to tell rclone that you wish a manual confirmation before destructive operations. It is **recommended** that you use this flag while learning rclone especially with `rclone sync`. For example ```sh $ rclone delete --interactive /tmp/dir rclone: delete "important-file.txt"? y) Yes, this is OK (default) n) No, skip this s) Skip all delete operations with no more questions !) Do all delete operations with no more questions q) Exit rclone now. y/n/s/!/q> n ``` The options mean - `y`: **Yes**, this operation should go ahead. You can also press Return for this to happen. You'll be asked every time unless you choose `s` or `!`. - `n`: **No**, do not do this operation. You'll be asked every time unless you choose `s` or `!`. - `s`: **Skip** all the following operations of this type with no more questions. This takes effect until rclone exits. If there are any different kind of operations you'll be prompted for them. - `!`: **Do all** the following operations with no more questions. Useful if you've decided that you don't mind rclone doing that kind of operation. This takes effect until rclone exits . If there are any different kind of operations you'll be prompted for them. - `q`: **Quit** rclone now, just in case! ### --leave-root During rmdirs it will not remove root directory, even if it's empty. ### -l, --links Normally rclone will ignore symlinks or junction points (which behave like symlinks under Windows). Ignored files won't be copied, moved or deleted in a sync. If you supply this flag then rclone will copy symbolic links from any supported backend backend, and store them as text files, with a `.rclonelink` suffix in the destination. The text file will contain the target of the symbolic link. The `--links` / `-l` flag enables this feature for all supported backends and the VFS. There are individual flags for just enabling it for the VFS `--vfs-links` and the local backend `--local-links` if required. ### --list-cutoff int {#list-cutoff} When syncing rclone needs to sort directory entries before comparing them. Below this threshold (1,000,000) by default, rclone will store the directory entries in memory. 1,000,000 entries will take approx 1GB of RAM to store. Above this threshold rclone will store directory entries on disk and sort them without using a lot of memory. Doing this is slightly less efficient then sorting them in memory and will only work well for the bucket based backends (eg s3, b2, azureblob, swift) but these are the only backends likely to have millions of entries in a directory. ### --log-file string Log all of rclone's output to a file. This is not active by default. This can be useful for tracking down problems with syncs in combination with the `-v` flag. See the [logging](#logging) section for more info. If the file exists, then rclone will append to it. Note that if you are using the `logrotate` program to manage rclone's logs, then you should use the `copytruncate` option as rclone doesn't have a signal to rotate logs. Alternatively you can use the options below to manage rclone's built in log rotation. ### --log-file-max-size SizeSuffix Maximum size of the log file before it's rotated (eg `10M`). This SizeSuffix is rounded to the nearest MiB or 1 MiB if lower. If `--log-file` is not set then this option will be ignored. If this option is not set, then the other log rotation options will be ignored. For example if the following flags are in use ```sh rclone --log-file rclone.log --log-file-max-size 1M --log-file-max-backups 3 ``` Then this will create log files which look like this ```console $ ls -l -rw------- 1 user user 1048491 Apr 11 17:15 rclone-2025-04-11T17-15-29.998.log -rw------- 1 user user 1048511 Apr 11 17:15 rclone-2025-04-11T17-15-30.467.log -rw------- 1 user user 1048559 Apr 11 17:15 rclone-2025-04-11T17-15-30.543.log -rw------- 1 user user 521602 Apr 11 17:15 rclone.log ``` The file `rclone.log` being the current one. ### --log-file-compress If set, compress rotated log files using gzip. This changes the extension of the old log files to `.log.gz`. Defaults to false - don't compress log files. ### --log-file-max-age Duration Maximum duration to retain old log files (eg `7d`). This is rounded to the dearest day, or 1 day if lower. The default is to retain all old log files. ### --log-file-max-backups int Maximum number of old log files to retain The default is to retain all old log files. ### --log-format string Comma separated list of log format options. The accepted options are: - `date` - Add a date in the format YYYY/MM/YY to the log. - `time` - Add a time to the log in format HH:MM:SS. - `microseconds` - Add microseconds to the time in format HH:MM:SS.SSSSSS. - `UTC` - Make the logs in UTC not localtime. - `longfile` - Adds the source file and line number of the log statement. - `shortfile` - Adds the source file and line number of the log statement. - `pid` - Add the process ID to the log - useful with `rclone mount --daemon`. - `nolevel` - Don't add the level to the log. - `json` - Equivalent to adding `--use-json-log` They are added to the log line in the order above. The default log format is `"date,time"`. ### --log-level LogLevel This sets the log level for rclone. The default log level is `NOTICE`. `DEBUG` is equivalent to `-vv`. It outputs lots of debug info - useful for bug reports and really finding out what rclone is doing. `INFO` is equivalent to `-v`. It outputs information about each transfer and prints stats once a minute by default. `NOTICE` is the default log level if no logging flags are supplied. It outputs very little when things are working normally. It outputs warnings and significant events. `ERROR` is equivalent to `-q`. It only outputs error messages. See also the [logging](#logging) section. ### --windows-event-log LogLevel If this is configured (the default is `OFF`) then logs of this level and above will be logged to the Windows event log in **addition** to the normal logs. These will be logged in JSON format as described below regardless of what format the main logs are configured for. The Windows event log only has 3 levels of severity `Info`, `Warning` and `Error`. If enabled we map rclone levels like this. - `Error` ← `ERROR` (and above) - `Warning` ← `WARNING` (note that this level is defined but not currently used). - `Info` ← `NOTICE`, `INFO` and `DEBUG`. Rclone will declare its log source as "rclone" if it is has enough permissions to create the registry key needed. If not then logs will appear as "Application". You can run `rclone version --windows-event-log DEBUG` once as administrator to create the registry key in advance. **Note** that the `--windows-event-log` level must be greater (more severe) than or equal to the `--log-level`. For example to log DEBUG to a log file but ERRORs to the event log you would use ```sh --log-file rclone.log --log-level DEBUG --windows-event-log ERROR ``` This option is only supported Windows platforms. ### --use-json-log This switches the log format to JSON. The log messages are then streamed as individual JSON objects, with fields: `level`, `msg`, `source`, and `time`. The resulting format is what is sometimes referred to as [newline-delimited JSON](https://en.wikipedia.org/wiki/JSON_streaming#Newline-delimited_JSON) (NDJSON), or JSON Lines (JSONL). This is well suited for processing by traditional line-oriented tools and shell pipelines, but a complete log file is not strictly valid JSON and needs a parser that can handle it. The JSON logs will be printed on a single line, but are shown expanded here for clarity. ```json { "time": "2025-05-13T17:30:51.036237518+01:00", "level": "debug", "msg": "4 go routines active\n", "source": "cmd/cmd.go:298" } ``` Completed data transfer logs will have extra `size` information. Logs which are about a particular object will have `object` and `objectType` fields also. ```json { "time": "2025-05-13T17:38:05.540846352+01:00", "level": "info", "msg": "Copied (new) to: file2.txt", "size": 6, "object": "file.txt", "objectType": "*local.Object", "source": "operations/copy.go:368" } ``` Stats logs will contain a `stats` field which is the same as returned from the rc call [core/stats](https://rclone.org/rc/#core-stats). ```json { "time": "2025-05-13T17:38:05.540912847+01:00", "level": "info", "msg": "...text version of the stats...", "stats": { "bytes": 6, "checks": 0, "deletedDirs": 0, "deletes": 0, "elapsedTime": 0.000904825, ...truncated for clarity... "totalBytes": 6, "totalChecks": 0, "totalTransfers": 1, "transferTime": 0.000882794, "transfers": 1 }, "source": "accounting/stats.go:569" } ``` ### --low-level-retries int This controls the number of low level retries rclone does. A low level retry is used to retry a failing operation - typically one HTTP request. This might be uploading a chunk of a big file for example. You will see low level retries in the log with the `-v` flag. This shouldn't need to be changed from the default in normal operations. However, if you get a lot of low level retries you may wish to reduce the value so rclone moves on to a high level retry (see the `--retries` flag) quicker. Disable low level retries with `--low-level-retries 1`. ### --max-backlog int This is the maximum allowable backlog of files in a sync/copy/move queued for being checked or transferred. This can be set arbitrarily large. It will only use memory when the queue is in use. Note that it will use in the order of N KiB of memory when the backlog is in use. Setting this large allows rclone to calculate how many files are pending more accurately, give a more accurate estimated finish time and make `--order-by` work more accurately. Setting this small will make rclone more synchronous to the listings of the remote which may be desirable. Setting this to a negative number will make the backlog as large as possible. ### --max-buffer-memory SizeSuffix {#max-buffer-memory} If set, don't allocate more than given amount of memory as buffers. If not set or set to `0` or `off` this will not limit the amount of memory in use. This includes memory used by buffers created by the `--buffer` flag and buffers used by multi-thread transfers. Most multi-thread transfers do not take additional memory, but some do depending on the backend (eg the s3 backend for uploads). This means there is a tension between total setting `--transfers` as high as possible and memory use. Setting `--max-buffer-memory` allows the buffer memory to be controlled so that it doesn't overwhelm the machine and allows `--transfers` to be set large. ### --max-connections int This sets the maximum number of concurrent calls to the backend API. It may not map 1:1 to TCP or HTTP connections depending on the backend in use and the use of HTTP1 vs HTTP2. When downloading files, backends only limit the initial opening of the stream. The bulk data download is not counted as a connection. This means that the `--max--connections` flag won't limit the total number of downloads. Note that it is possible to cause deadlocks with this setting so it should be used with care. If you are doing a sync or copy then make sure `--max-connections` is one more than the sum of `--transfers` and `--checkers`. If you use `--check-first` then `--max-connections` just needs to be one more than the maximum of `--checkers` and `--transfers`. So for `--max-connections 3` you'd use `--checkers 2 --transfers 2 --check-first` or `--checkers 1 --transfers 1`. Setting this flag can be useful for backends which do multipart uploads to limit the number of simultaneous parts being transferred. ### --max-delete int This tells rclone not to delete more than N files. If that limit is exceeded then a fatal error will be generated and rclone will stop the operation in progress. ### --max-delete-size SizeSuffix Rclone will stop deleting files when the total size of deletions has reached the size specified. It defaults to off. If that limit is exceeded then a fatal error will be generated and rclone will stop the operation in progress. ### --max-depth int This modifies the recursion depth for all the commands except purge. So if you do `rclone --max-depth 1 ls remote:path` you will see only the files in the top level directory. Using `--max-depth 2` means you will see all the files in first two directory levels and so on. For historical reasons the `lsd` command defaults to using a `--max-depth` of 1 - you can override this with the command line flag. You can use this command to disable recursion (with `--max-depth 1`). Note that if you use this with `sync` and `--delete-excluded` the files not recursed through are considered excluded and will be deleted on the destination. Test first with `--dry-run` if you are not sure what will happen. ### --max-duration Duration Rclone will stop transferring when it has run for the duration specified. Defaults to off. When the limit is reached all transfers will stop immediately. Use `--cutoff-mode` to modify this behaviour. Rclone will exit with exit code 10 if the duration limit is reached. ### --max-transfer SizeSuffix Rclone will stop transferring when it has reached the size specified. Defaults to off. When the limit is reached all transfers will stop immediately. Use `--cutoff-mode` to modify this behaviour. Rclone will exit with exit code 8 if the transfer limit is reached. ### --cutoff-mode HARD|SOFT|CAUTIOUS Configure the behavior of `--max-transfer` and `--max-duration`. `HARD` will stop transferring immediately when rclone reaches the limit. This is the default. `SOFT` will stop starting new transfers when rclone reaches the limit. `CAUTIOUS` will try to prevent rclone from reaching the limit. Only applicable for `--max-transfer`. ## -M, --metadata Setting this flag enables rclone to copy the metadata from the source to the destination. For local backends this is ownership, permissions, xattr etc. See the [metadata section](#metadata) for more info. ### --metadata-mapper SpaceSepList {#metadata-mapper} If you supply the parameter `--metadata-mapper /path/to/program` then rclone will use that program to map metadata from source object to destination object. The argument to this flag should be a command with an optional space separated list of arguments. If one of the arguments has a space in then enclose it in `"`, if you want a literal `"` in an argument then enclose the argument in `"` and double the `"`. See [CSV encoding](https://godoc.org/encoding/csv) for more info. ```sh --metadata-mapper "python bin/test_metadata_mapper.py" --metadata-mapper 'python bin/test_metadata_mapper.py "argument with a space"' --metadata-mapper 'python bin/test_metadata_mapper.py "argument with ""two"" quotes"' ``` This uses a simple JSON based protocol with input on STDIN and output on STDOUT. This will be called for every file and directory copied and may be called concurrently. The program's job is to take a metadata blob on the input and turn it into a metadata blob on the output suitable for the destination backend. Input to the program (via STDIN) might look like this. This provides some context for the `Metadata` which may be important. - `SrcFs` is the config string for the remote that the object is currently on. - `SrcFsType` is the name of the source backend. - `DstFs` is the config string for the remote that the object is being copied to - `DstFsType` is the name of the destination backend. - `Remote` is the path of the object relative to the root. - `Size`, `MimeType`, `ModTime` are attributes of the object. - `IsDir` is `true` if this is a directory (not yet implemented). - `ID` is the source `ID` of the object if known. - `Metadata` is the backend specific metadata as described in the backend docs. ```json { "SrcFs": "gdrive:", "SrcFsType": "drive", "DstFs": "newdrive:user", "DstFsType": "onedrive", "Remote": "test.txt", "Size": 6, "MimeType": "text/plain; charset=utf-8", "ModTime": "2022-10-11T17:53:10.286745272+01:00", "IsDir": false, "ID": "xyz", "Metadata": { "btime": "2022-10-11T16:53:11Z", "content-type": "text/plain; charset=utf-8", "mtime": "2022-10-11T17:53:10.286745272+01:00", "owner": "user1@domain1.com", "permissions": "...", "description": "my nice file", "starred": "false" } } ``` The program should then modify the input as desired and send it to STDOUT. The returned `Metadata` field will be used in its entirety for the destination object. Any other fields will be ignored. Note in this example we translate user names and permissions and add something to the description: ```json { "Metadata": { "btime": "2022-10-11T16:53:11Z", "content-type": "text/plain; charset=utf-8", "mtime": "2022-10-11T17:53:10.286745272+01:00", "owner": "user1@domain2.com", "permissions": "...", "description": "my nice file [migrated from domain1]", "starred": "false" } } ``` Metadata can be removed here too. An example python program might look something like this to implement the above transformations. ```python import sys, json i = json.load(sys.stdin) metadata = i["Metadata"] # Add tag to description if "description" in metadata: metadata["description"] += " [migrated from domain1]" else: metadata["description"] = "[migrated from domain1]" # Modify owner if "owner" in metadata: metadata["owner"] = metadata["owner"].replace("domain1.com", "domain2.com") o = { "Metadata": metadata } json.dump(o, sys.stdout, indent="\t") ``` You can find this example (slightly expanded) in the rclone source code at [bin/test_metadata_mapper.py](https://github.com/rclone/rclone/blob/master/bin/test_metadata_mapper.py). If you want to see the input to the metadata mapper and the output returned from it in the log you can use `-vv --dump mapper`. See the [metadata section](#metadata) for more info. ### --metadata-set stringArray Specify value as string in format `key=value` to add metadata `key` with value `value` when uploading. This can be repeated as many times as required. See the [metadata section](#metadata) for more info. ### --modify-window Duration When checking whether a file has been modified, this is the maximum allowed time difference that a file can have and still be considered equivalent. The default is `1ns` unless this is overridden by a remote. For example OS X only stores modification times to the nearest second so if you are reading and writing to an OS X filing system this will be `1s` by default. This command line flag allows you to override that computed default. ### --multi-thread-write-buffer-size SizeSuffix When transferring with multiple threads, rclone will buffer the specified number of bytes in memory before writing to disk for each thread. This can improve performance if the underlying filesystem does not deal well with a lot of small writes in different positions of the file, so if you see transfers being limited by disk write speed, you might want to experiment with different values. Specially for magnetic drives and remote file systems a higher value can be useful. Nevertheless, the default of `128k` should be fine for almost all use cases, so before changing it ensure that network is not really your bottleneck. As a final hint, size is not the only factor: block size (or similar concept) can have an impact. In one case, we observed that exact multiples of 16k performed much better than other values. ### --multi-thread-chunk-size SizeSuffix Normally the chunk size for multi thread transfers is set by the backend. However some backends such as `local` and `smb` (which implement `OpenWriterAt` but not `OpenChunkWriter`) don't have a natural chunk size. In this case the value of this option is used (default 64Mi). ### --multi-thread-cutoff SizeSuffix {#multi-thread-cutoff} When transferring files above specified size to capable backends, rclone will use multiple threads to transfer the file (default 256M). Capable backends are marked in the [overview](https://rclone.org/overview/#optional-features) as `MultithreadUpload`. (They need to implement either the `OpenWriterAt` or `OpenChunkWriter` internal interfaces). These include include, `local`, `s3`, `azureblob`, `b2`, `oracleobjectstorage` and `smb` at the time of writing. On the local disk, rclone preallocates the file (using `fallocate(FALLOC_FL_KEEP_SIZE)` on unix or `NTSetInformationFile` on Windows both of which takes no time) then each thread writes directly into the file at the correct place. This means that rclone won't create fragmented or sparse files and there won't be any assembly time at the end of the transfer. The number of threads used to transfer is controlled by `--multi-thread-streams`. Use `-vv` if you wish to see info about the threads. This will work with the [sync](https://rclone.org/commands/rclone_sync/), [copy](https://rclone.org/commands/rclone_copy/) and [move](https://rclone.org/commands/rclone_move/) commands, and friends [copyto](https://rclone.org/commands/rclone_copyto/), [moveto](https://rclone.org/commands/rclone_moveto/). Multi thread transfers will be used with `rclone mount` and `rclone serve` if `--vfs-cache-mode` is set to `writes` or above. Most multi-thread transfers do not take additional memory, but some do (for example uploading to s3). In the worst case memory usage can be at maximum `--transfers` \* `--multi-thread-chunk-size` \* `--multi-thread-streams` or specifically for the s3 backend `--transfers` \* `--s3-chunk-size` \* `--s3-concurrency`. However you can use the the [--max-buffer-memory](https://rclone.org/docs/#max-buffer-memory) flag to control the maximum memory used here. **NB** that this **only** works with supported backends as the destination but will work with any backend as the source. **NB** that multi-thread copies are disabled for local to local copies as they are faster without unless `--multi-thread-streams` is set explicitly. **NB** on Windows using multi-thread transfers to the local disk will cause the resulting files to be [sparse](https://en.wikipedia.org/wiki/Sparse_file). Use `--local-no-sparse` to disable sparse files (which may cause long delays at the start of transfers) or disable multi-thread transfers with `--multi-thread-streams 0` ### --multi-thread-streams int When using multi thread transfers (see above `--multi-thread-cutoff`) this sets the number of streams to use. Set to `0` to disable multi thread transfers (Default 4). If the backend has a `--backend-upload-concurrency` setting (eg `--s3-upload-concurrency`) then this setting will be used as the number of transfers instead if it is larger than the value of `--multi-thread-streams` or `--multi-thread-streams` isn't set. ### --name-transform stringArray `--name-transform` introduces path name transformations for `rclone copy`, `rclone sync`, and `rclone move`. These transformations enable modifications to source and destination file names by applying prefixes, suffixes, and other alterations during transfer operations. For detailed docs and examples, see [`convmv`](https://rclone.org/commands/rclone_convmv/). ### --no-check-dest The `--no-check-dest` can be used with `move` or `copy` and it causes rclone not to check the destination at all when copying files. This means that: - the destination is not listed minimising the API calls - files are always transferred - this can cause duplicates on remotes which allow it (e.g. Google Drive) - `--retries 1` is recommended otherwise you'll transfer everything again on a retry This flag is useful to minimise the transactions if you know that none of the files are on the destination. This is a specialized flag which should be ignored by most users! ### --no-gzip-encoding Don't set `Accept-Encoding: gzip`. This means that rclone won't ask the server for compressed files automatically. Useful if you've set the server to return files with `Content-Encoding: gzip` but you uploaded compressed files. There is no need to set this in normal operation, and doing so will decrease the network transfer efficiency of rclone. ### --no-traverse The `--no-traverse` flag controls whether the destination file system is traversed when using the `copy` or `move` commands. `--no-traverse` is not compatible with `sync` and will be ignored if you supply it with `sync`. If you are only copying a small number of files (or are filtering most of the files) and/or have a large number of files on the destination then `--no-traverse` will stop rclone listing the destination and save time. However, if you are copying a large number of files, especially if you are doing a copy where lots of the files under consideration haven't changed and won't need copying then you shouldn't use `--no-traverse`. See [rclone copy](https://rclone.org/commands/rclone_copy/) for an example of how to use it. ### --no-unicode-normalization Don't normalize unicode characters in filenames during the sync routine. Sometimes, an operating system will store filenames containing unicode parts in their decomposed form (particularly macOS). Some cloud storage systems will then recompose the unicode, resulting in duplicate files if the data is ever copied back to a local filesystem. Using this flag will disable that functionality, treating each unicode character as unique. For example, by default é and é will be normalized into the same character. With `--no-unicode-normalization` they will be treated as unique characters. ### --no-update-modtime When using this flag, rclone won't update modification times of remote files if they are incorrect as it would normally. This can be used if the remote is being synced with another tool also (e.g. the Google Drive client). ### --no-update-dir-modtime When using this flag, rclone won't update modification times of remote directories if they are incorrect as it would normally. ### --order-by string The `--order-by` flag controls the order in which files in the backlog are processed in `rclone sync`, `rclone copy` and `rclone move`. The order by string is constructed like this. The first part describes what aspect is being measured: - `size` - order by the size of the files - `name` - order by the full path of the files - `modtime` - order by the modification date of the files This can have a modifier appended with a comma: - `ascending` or `asc` - order so that the smallest (or oldest) is processed first - `descending` or `desc` - order so that the largest (or newest) is processed first - `mixed` - order so that the smallest is processed first for some threads and the largest for others If the modifier is `mixed` then it can have an optional percentage (which defaults to `50`), e.g. `size,mixed,25` which means that 25% of the threads should be taking the smallest items and 75% the largest. The threads which take the smallest first will always take the smallest first and likewise the largest first threads. The `mixed` mode can be useful to minimise the transfer time when you are transferring a mixture of large and small files - the large files are guaranteed upload threads and bandwidth and the small files will be processed continuously. If no modifier is supplied then the order is `ascending`. For example - `--order-by size,desc` - send the largest files first - `--order-by modtime,ascending` - send the oldest files first - `--order-by name` - send the files with alphabetically by path first If the `--order-by` flag is not supplied or it is supplied with an empty string then the default ordering will be used which is as scanned. With `--checkers 1` this is mostly alphabetical, however with the default `--checkers 8` it is somewhat random. #### Limitations The `--order-by` flag does not do a separate pass over the data. This means that it may transfer some files out of the order specified if - there are no files in the backlog or the source has not been fully scanned yet - there are more than [--max-backlog](#max-backlog-int) files in the backlog Rclone will do its best to transfer the best file it has so in practice this should not cause a problem. Think of `--order-by` as being more of a best efforts flag rather than a perfect ordering. If you want perfect ordering then you will need to specify [--check-first](#check-first) which will find all the files which need transferring first before transferring any. ### --partial-suffix string {#partial-suffix} When [--inplace](#inplace) is not used, it causes rclone to use the `--partial-suffix` as suffix for temporary files. Suffix length limit is 16 characters. The default is `.partial`. ### --password-command SpaceSepList {#password-command} This flag supplies a program which should supply the config password when run. This is an alternative to rclone prompting for the password or setting the `RCLONE_CONFIG_PASS` variable. It is also used when setting the config password for the first time. The argument to this should be a command with a space separated list of arguments. If one of the arguments has a space in then enclose it in `"`, if you want a literal `"` in an argument then enclose the argument in `"` and double the `"`. See [CSV encoding](https://godoc.org/encoding/csv) for more info. Eg ```sh --password-command "echo hello" --password-command 'echo "hello with space"' --password-command 'echo "hello with ""quotes"" and space"' ``` Note that when changing the configuration password the environment variable `RCLONE_PASSWORD_CHANGE=1` will be set. This can be used to distinguish initial decryption of the config file from the new password. See the [Configuration Encryption](#configuration-encryption) for more info. See a [Windows PowerShell example on the Wiki](https://github.com/rclone/rclone/wiki/Windows-Powershell-use-rclone-password-command-for-Config-file-password). ### -P, --progress This flag makes rclone update the stats in a static block in the terminal providing a realtime overview of the transfer. Any log messages will scroll above the static block. Log messages will push the static block down to the bottom of the terminal where it will stay. Normally this is updated every 500mS but this period can be overridden with the `--stats` flag. This can be used with the `--stats-one-line` flag for a simpler display. To change the display length of filenames (for different terminal widths), see the `--stats-file-name-length` option. The default output is formatted for 80 character wide terminals. Note: On Windows until [this bug](https://github.com/Azure/go-ansiterm/issues/26) is fixed all non-ASCII characters will be replaced with `.` when `--progress` is in use. ### --progress-terminal-title This flag, when used with `-P/--progress`, will print the string `ETA: %s` to the terminal title. ### -q, --quiet This flag will limit rclone's output to error messages only. ### --refresh-times The `--refresh-times` flag can be used to update modification times of existing files when they are out of sync on backends which don't support hashes. This is useful if you uploaded files with the incorrect timestamps and you now wish to correct them. This flag is **only** useful for destinations which don't support hashes (e.g. `crypt`). This can be used any of the sync commands [sync](https://rclone.org/commands/rclone_sync/), [copy](https://rclone.org/commands/rclone_copy/) or [move](https://rclone.org/commands/rclone_move/). To use this flag you will need to be doing a modification time sync (so not using `--size-only` or `--checksum`). The flag will have no effect when using `--size-only` or `--checksum`. If this flag is used when rclone comes to upload a file it will check to see if there is an existing file on the destination. If this file matches the source with size (and checksum if available) but has a differing timestamp then instead of re-uploading it, rclone will update the timestamp on the destination file. If the checksum does not match rclone will upload the new file. If the checksum is absent (e.g. on a `crypt` backend) then rclone will update the timestamp. Note that some remotes can't set the modification time without re-uploading the file so this flag is less useful on them. Normally if you are doing a modification time sync rclone will update modification times without `--refresh-times` provided that the remote supports checksums **and** the checksums match on the file. However if the checksums are absent then rclone will upload the file rather than setting the timestamp as this is the safe behaviour. ### --retries int Retry the entire sync if it fails this many times it fails (default 3). Some remotes can be unreliable and a few retries help pick up the files which didn't get transferred because of errors. Disable retries with `--retries 1`. ### --retries-sleep Duration This sets the interval between each retry specified by `--retries` The default is `0`. Use `0` to disable. ### --server-side-across-configs Allow server-side operations (e.g. copy or move) to work across different configurations. This can be useful if you wish to do a server-side copy or move between two remotes which use the same backend but are configured differently. Note that this isn't enabled by default because it isn't easy for rclone to tell if it will work between any two configurations. ### --size-only Normally rclone will look at modification time and size of files to see if they are equal. If you set this flag then rclone will check only the size. This can be useful transferring files from Dropbox which have been modified by the desktop sync client which doesn't set checksums of modification times in the same way as rclone. ### --stats Duration Commands which transfer data ([sync](https://rclone.org/commands/rclone_sync/), [copy](https://rclone.org/commands/rclone_copy/), [copyto](https://rclone.org/commands/rclone_copyto/), [move](https://rclone.org/commands/rclone_move/), [moveto](https://rclone.org/commands/rclone_moveto/)) will print data transfer stats at regular intervals to show their progress. This sets the interval. The default is `1m`. Use `0` to disable. If you set the stats interval then all commands can show stats. This can be useful when running other commands, `check` or `mount` for example. Stats are logged at `INFO` level by default which means they won't show at default log level `NOTICE`. Use `--stats-log-level NOTICE` or `-v` to make them show. See the [logging](#logging) section for more info on log levels. Note that on macOS you can send a SIGINFO (which is normally ctrl-T in the terminal) to make the stats print immediately. ### --stats-file-name-length int By default, the `--stats` output will truncate file names and paths longer than 40 characters. This is equivalent to providing `--stats-file-name-length 40`. Use `--stats-file-name-length 0` to disable any truncation of file names printed by stats. ### --stats-log-level LogLevel Log level to show `--stats` output at. This can be `DEBUG`, `INFO`, `NOTICE`, or `ERROR`. The default is `INFO`. This means at the default level of logging, which is `NOTICE`, the stats won't show - if you want them to then use `--stats-log-level NOTICE`. See the [logging](#logging) section for more details on log levels. ### --stats-one-line When this is specified, rclone condenses the stats into a single line showing the most important stats only. ### --stats-one-line-date When this is specified, rclone enables the single-line stats and prepends the display with a date string. The default is `2006/01/02 15:04:05 - ` ### --stats-one-line-date-format string When this is specified, rclone enables the single-line stats and prepends the display with a user-supplied date string. The date string MUST be enclosed in quotes. Follow [golang specs](https://golang.org/pkg/time/#Time.Format) for date formatting syntax. ### --stats-unit string By default, data transfer rates will be printed in bytes per second, corresponding to `--stats-unit bytes`. This option allows the data rate to be printed in bits per second, by specifying `--stats-unit bits`. Data transfer volume will still be reported in bytes. The rate is reported as a binary unit, not SI unit. So 1 Mbit/s equals 1,048,576 bit/s and not 1,000,000 bit/s. ### --suffix string When using [sync](https://rclone.org/commands/rclone_sync/), [copy](https://rclone.org/commands/rclone_copy/) or [move](https://rclone.org/commands/rclone_move/) any files which would have been overwritten or deleted will have the suffix added to them. If there is a file with the same path (after the suffix has been added), then it will be overwritten. The remote in use must support server-side move or copy and you must use the same remote as the destination of the sync. This is for use with files to add the suffix in the current directory or with `--backup-dir`. See `--backup-dir` for more info. For example ```sh rclone copy --interactive /path/to/local/file remote:current --suffix .bak ``` will copy `/path/to/local` to `remote:current`, but for any files which would have been updated or deleted have .bak added. If using `rclone sync` with `--suffix` and without `--backup-dir` then it is recommended to put a filter rule in excluding the suffix otherwise the `sync` will delete the backup files. ```sh rclone sync --interactive /path/to/local/file remote:current --suffix .bak --exclude "*.bak" ``` ### --suffix-keep-extension When using `--suffix`, setting this causes rclone put the SUFFIX before the extension of the files that it backs up rather than after. So let's say we had `--suffix -2019-01-01`, without the flag `file.txt` would be backed up to `file.txt-2019-01-01` and with the flag it would be backed up to `file-2019-01-01.txt`. This can be helpful to make sure the suffixed files can still be opened. If a file has two (or more) extensions and the second (or subsequent) extension is recognised as a valid mime type, then the suffix will go before that extension. So `file.tar.gz` would be backed up to `file-2019-01-01.tar.gz` whereas `file.badextension.gz` would be backed up to `file.badextension-2019-01-01.gz`. ### --syslog On capable OSes (not Windows or Plan9) send all log output to syslog. This can be useful for running rclone in a script or `rclone mount`. ### --syslog-facility string If using `--syslog` this sets the syslog facility (e.g. `KERN`, `USER`). See `man syslog` for a list of possible facilities. The default facility is `DAEMON`. ### --temp-dir string Specify the directory rclone will use for temporary files, to override the default. Make sure the directory exists and have accessible permissions. By default the operating system's temp directory will be used: - On Unix systems, `$TMPDIR` if non-empty, else `/tmp`. - On Windows, the first non-empty value from `%TMP%`, `%TEMP%`, `%USERPROFILE%`, or the Windows directory. When overriding the default with this option, the specified path will be set as value of environment variable `TMPDIR` on Unix systems and `TMP` and `TEMP` on Windows. You can use the [config paths](https://rclone.org/commands/rclone_config_paths/) command to see the current value. ### --tpslimit float Limit transactions per second to this number. Default is 0 which is used to mean unlimited transactions per second. A transaction is roughly defined as an API call; its exact meaning will depend on the backend. For HTTP based backends it is an HTTP PUT/GET/POST/etc and its response. For FTP/SFTP it is a round trip transaction over TCP. For example, to limit rclone to 10 transactions per second use `--tpslimit 10`, or to 1 transaction every 2 seconds use `--tpslimit 0.5`. Use this when the number of transactions per second from rclone is causing a problem with the cloud storage provider (e.g. getting you banned or rate limited). This can be very useful for `rclone mount` to control the behaviour of applications using it. This limit applies to all HTTP based backends and to the FTP and SFTP backends. It does not apply to the local backend or the Storj backend. See also `--tpslimit-burst`. ### --tpslimit-burst int Max burst of transactions for `--tpslimit` (default `1`). Normally `--tpslimit` will do exactly the number of transaction per second specified. However if you supply `--tps-burst` then rclone can save up some transactions from when it was idle giving a burst of up to the parameter supplied. For example if you provide `--tpslimit-burst 10` then if rclone has been idle for more than 10*`--tpslimit` then it can do 10 transactions very quickly before they are limited again. This may be used to increase performance of `--tpslimit` without changing the long term average number of transactions per second. ### --track-renames By default, rclone doesn't keep track of renamed files, so if you rename a file locally then sync it to a remote, rclone will delete the old file on the remote and upload a new copy. An rclone sync with `--track-renames` runs like a normal sync, but keeps track of objects which exist in the destination but not in the source (which would normally be deleted), and which objects exist in the source but not the destination (which would normally be transferred). These objects are then candidates for renaming. After the sync, rclone matches up the source only and destination only objects using the `--track-renames-strategy` specified and either renames the destination object or transfers the source and deletes the destination object. `--track-renames` is stateless like all of rclone's syncs. To use this flag the destination must support server-side copy or server-side move, and to use a hash based `--track-renames-strategy` (the default) the source and the destination must have a compatible hash. If the destination does not support server-side copy or move, rclone will fall back to the default behaviour and log an error level message to the console. Encrypted destinations are not currently supported by `--track-renames` if `--track-renames-strategy` includes `hash`. Note that `--track-renames` is incompatible with `--no-traverse` and that it uses extra memory to keep track of all the rename candidates. Note also that `--track-renames` is incompatible with `--delete-before` and will select `--delete-after` instead of `--delete-during`. ### --track-renames-strategy string This option changes the file matching criteria for `--track-renames`. The matching is controlled by a comma separated selection of these tokens: - `modtime` - the modification time of the file - not supported on all backends - `hash` - the hash of the file contents - not supported on all backends - `leaf` - the name of the file not including its directory name - `size` - the size of the file (this is always enabled) The default option is `hash`. Using `--track-renames-strategy modtime,leaf` would match files based on modification time, the leaf of the file name and the size only. Using `--track-renames-strategy modtime` or `leaf` can enable `--track-renames` support for encrypted destinations. Note that the `hash` strategy is not supported with encrypted destinations. ### --delete-(before,during,after) This option allows you to specify when files on your destination are deleted when you sync folders. Specifying the value `--delete-before` will delete all files present on the destination, but not on the source *before* starting the transfer of any new or updated files. This uses two passes through the file systems, one for the deletions and one for the copies. Specifying `--delete-during` will delete files while checking and uploading files. This is the fastest option and uses the least memory. Specifying `--delete-after` (the default value) will delay deletion of files until all new/updated files have been successfully transferred. The files to be deleted are collected in the copy pass then deleted after the copy pass has completed successfully. The files to be deleted are held in memory so this mode may use more memory. This is the safest mode as it will only delete files if there have been no errors subsequent to that. If there have been errors before the deletions start then you will get the message `not deleting files as there were IO errors`. ### --fast-list When doing anything which involves a directory listing (e.g. `sync`, `copy`, `ls` - in fact nearly every command), rclone has different strategies to choose from. The basic strategy is to list one directory and processes it before using more directory lists to process any subdirectories. This is a mandatory backend feature, called `List`, which means it is supported by all backends. This strategy uses small amount of memory, and because it can be parallelised it is fast for operations involving processing of the list results. Some backends provide the support for an alternative strategy, where all files beneath a directory can be listed in one (or a small number) of transactions. Rclone supports this alternative strategy through an optional backend feature called [`ListR`](https://rclone.org/overview/#listr). You can see in the storage system overview documentation's [optional features](https://rclone.org/overview/#optional-features) section which backends it is enabled for (these tend to be the bucket-based ones, e.g. S3, B2, GCS, Swift). This strategy requires fewer transactions for highly recursive operations, which is important on backends where this is charged or heavily rate limited. It may be faster (due to fewer transactions) or slower (because it can't be parallelized) depending on different parameters, and may require more memory if rclone has to keep the whole listing in memory. Which listing strategy rclone picks for a given operation is complicated, but in general it tries to choose the best possible. It will prefer `ListR` in situations where it doesn't need to store the listed files in memory, e.g. for unlimited recursive `ls` command variants. In other situations it will prefer `List`, e.g. for `sync` and `copy`, where it needs to keep the listed files in memory, and is performing operations on them where parallelization may be a huge advantage. Rclone is not able to take all relevant parameters into account for deciding the best strategy, and therefore allows you to influence the choice in two ways: You can stop rclone from using `ListR` by disabling the feature, using the [--disable](#disable-string) option (`--disable ListR`), or you can allow rclone to use `ListR` where it would normally choose not to do so due to higher memory usage, using the `--fast-list` option. Rclone should always produce identical results either way. Using `--disable ListR` or `--fast-list` on a remote which doesn't support `ListR` does nothing, rclone will just ignore it. A rule of thumb is that if you pay for transactions and can fit your entire sync listing into memory, then `--fast-list` is recommended. If you have a very big sync to do, then don't use `--fast-list`, otherwise you will run out of memory. Run some tests and compare before you decide, and if in doubt then just leave the default, let rclone decide, i.e. not use `--fast-list`. ### --timeout Duration This sets the IO idle timeout. If a transfer has started but then becomes idle for this long it is considered broken and disconnected. The default is `5m`. Set to `0` to disable. ### --transfers int The number of file transfers to run in parallel. It can sometimes be useful to set this to a smaller number if the remote is giving a lot of timeouts or bigger if you have lots of bandwidth and a fast remote. The default is to run 4 file transfers in parallel. Look at --multi-thread-streams if you would like to control single file transfers. ### -u, --update This forces rclone to skip any files which exist on the destination and have a modified time that is newer than the source file. This can be useful in avoiding needless transfers when transferring to a remote which doesn't support modification times directly (or when using `--use-server-modtime` to avoid extra API calls) as it is more accurate than a `--size-only` check and faster than using `--checksum`. On such remotes (or when using `--use-server-modtime`) the time checked will be the uploaded time. If an existing destination file has a modification time older than the source file's, it will be updated if the sizes are different. If the sizes are the same, it will be updated if the checksum is different or not available. If an existing destination file has a modification time equal (within the computed modify window) to the source file's, it will be updated if the sizes are different. The checksum will not be checked in this case unless the `--checksum` flag is provided. In all other cases the file will not be updated. Consider using the `--modify-window` flag to compensate for time skews between the source and the backend, for backends that do not support mod times, and instead use uploaded times. However, if the backend does not support checksums, note that syncing or copying within the time skew window may still result in additional transfers for safety. ### --use-mmap If this flag is set then rclone will use anonymous memory allocated by mmap on Unix based platforms and VirtualAlloc on Windows for its transfer buffers (size controlled by `--buffer-size`). Memory allocated like this does not go on the Go heap and can be returned to the OS immediately when it is finished with. If this flag is not set then rclone will allocate and free the buffers using the Go memory allocator which may use more memory as memory pages are returned less aggressively to the OS. It is possible this does not work well on all platforms so it is disabled by default; in the future it may be enabled by default. ### --use-server-modtime Some object-store backends (e.g, Swift, S3) do not preserve file modification times (modtime). On these backends, rclone stores the original modtime as additional metadata on the object. By default it will make an API call to retrieve the metadata when the modtime is needed by an operation. Use this flag to disable the extra API call and rely instead on the server's modified time. In cases such as a local to remote sync using `--update`, knowing the local file is newer than the time it was last uploaded to the remote is sufficient. In those cases, this flag can speed up the process and reduce the number of API calls necessary. Using this flag on a sync operation without also using `--update` would cause all files modified at any time other than the last upload time to be uploaded again, which is probably not what you want. ### -v, -vv, --verbose With `-v` rclone will tell you about each file that is transferred and a small number of significant events. With `-vv` rclone will become very verbose telling you about every file it considers and transfers. Please send bug reports with a log with this setting. When setting verbosity as an environment variable, use `RCLONE_VERBOSE=1` or `RCLONE_VERBOSE=2` for `-v` and `-vv` respectively. ### -V, --version Prints the version number ## SSL/TLS options The outgoing SSL/TLS connections rclone makes can be controlled with these options. For example this can be very useful with the HTTP or WebDAV backends. Rclone HTTP servers have their own set of configuration for SSL/TLS which you can find in their documentation. ### --ca-cert stringArray This loads the PEM encoded certificate authority certificates and uses it to verify the certificates of the servers rclone connects to. If you have generated certificates signed with a local CA then you will need this flag to connect to servers using those certificates. ### --client-cert string This loads the PEM encoded client side certificate. This is used for [mutual TLS authentication](https://en.wikipedia.org/wiki/Mutual_authentication). The `--client-key` flag is required too when using this. ### --client-key string This loads the PEM encoded client side private key used for mutual TLS authentication. Used in conjunction with `--client-cert`. Supported types are: - Unencrypted PKCS#1 ("BEGIN RSA PRIVATE KEY") - Unencrypted PKCS#8 ("BEGIN PRIVATE KEY") - Encrypted PKCS#8 ("BEGIN ENCRYPTED PRIVATE KEY") - Legacy PEM encryption (e.g., DEK-Info headers), which are automatically detected. ### --client-pass string This can be used to supply an optional password to decrypt the client key file. **NB** the password should be obscured so it should be the output of `rclone obscure YOURPASSWORD`. ### --no-check-certificate `--no-check-certificate` controls whether a client verifies the server's certificate chain and host name. If `--no-check-certificate` is true, TLS accepts any certificate presented by the server and any host name in that certificate. In this mode, TLS is susceptible to man-in-the-middle attacks. This option defaults to `false`. **This should be used only for testing.** ## Configuration encryption Your configuration file contains information for logging in to your cloud services. This means that you should keep your `rclone.conf` file in a secure location. If you are in an environment where that isn't possible, you can add a password to your configuration. This means that you will have to supply the password every time you start rclone. To add a password to your rclone configuration, execute `rclone config`. ```sh $ rclone config Current remotes: e) Edit existing remote n) New remote d) Delete remote s) Set configuration password q) Quit config e/n/d/s/q> ``` Go into `s`, Set configuration password: ```sh e/n/d/s/q> s Your configuration is not encrypted. If you add a password, you will protect your login information to cloud services. a) Add Password q) Quit to main menu a/q> a Enter NEW configuration password: password: Confirm NEW password: password: Password set Your configuration is encrypted. c) Change Password u) Unencrypt configuration q) Quit to main menu c/u/q> ``` Your configuration is now encrypted, and every time you start rclone you will have to supply the password. See below for details. In the same menu, you can change the password or completely remove encryption from your configuration. There is no way to recover the configuration if you lose your password. You can also use - [rclone config encryption set](https://rclone.org/commands/rclone_config_encryption_set/) to set the config encryption directly - [rclone config encryption remove](https://rclone.org/commands/rclone_config_encryption_remove/) to remove it - [rclone config encryption check](https://rclone.org/commands/rclone_config_encryption_check/) to check that it is encrypted properly. rclone uses [nacl secretbox](https://godoc.org/golang.org/x/crypto/nacl/secretbox) which in turn uses XSalsa20 and Poly1305 to encrypt and authenticate your configuration with secret-key cryptography. The password is SHA-256 hashed, which produces the key for secretbox. The hashed password is not stored. While this provides very good security, we do not recommend storing your encrypted rclone configuration in public if it contains sensitive information, maybe except if you use a very strong password. If it is safe in your environment, you can set the `RCLONE_CONFIG_PASS` environment variable to contain your password, in which case it will be used for decrypting the configuration. You can set this for a session from a script. For unix like systems save this to a file called `set-rclone-password`: ```sh #!/bin/echo Source this file don't run it read -s RCLONE_CONFIG_PASS export RCLONE_CONFIG_PASS ``` Then source the file when you want to use it. From the shell you would do `source set-rclone-password`. It will then ask you for the password and set it in the environment variable. An alternate means of supplying the password is to provide a script which will retrieve the password and print on standard output. This script should have a fully specified path name and not rely on any environment variables. The script is supplied either via [`--password-command="..."`](#password-command) command line argument or via the `RCLONE_PASSWORD_COMMAND` environment variable. One useful example of this is using the `passwordstore` application to retrieve the password: ```sh export RCLONE_PASSWORD_COMMAND="pass rclone/config" ``` If the `passwordstore` password manager holds the password for the rclone configuration, using the script method means the password is primarily protected by the `passwordstore` system, and is never embedded in the clear in scripts, nor available for examination using the standard commands available. It is quite possible with long running rclone sessions for copies of passwords to be innocently captured in log files or terminal scroll buffers, etc. Using the script method of supplying the password enhances the security of the config password considerably. If you are running rclone inside a script, unless you are using the `--password-command` method, you might want to disable password prompts. To do that, pass the parameter `--ask-password=false` to rclone. This will make rclone fail instead of asking for a password if `RCLONE_CONFIG_PASS` doesn't contain a valid password, and `--password-command` has not been supplied. Whenever running commands that may be affected by options in a configuration file, rclone will look for an existing file according to the rules described [above](#config-string), and load any it finds. If an encrypted file is found, this includes decrypting it, with the possible consequence of a password prompt. When executing a command line that you know are not actually using anything from such a configuration file, you can avoid it being loaded by overriding the location, e.g. with one of the documented special values for memory-only configuration. Since only backend options can be stored in configuration files, this is normally unnecessary for commands that do not operate on backends, e.g. `completion`. However, it will be relevant for commands that do operate on backends in general, but are used without referencing a stored remote, e.g. listing local filesystem paths, or [connection strings](#connection-strings): `rclone --config="" ls .` ### Configuration encryption cheatsheet You can quickly apply a configuration encryption without plain-text at rest or transfer. Detailed instructions for popular OSes: #### Mac - Generate and store a password ```sh security add-generic-password -a rclone -s config -w $(openssl rand -base64 40) ``` - Add the retrieval instruction to your `.zprofile` / `.profile` ```sh export RCLONE_PASSWORD_COMMAND="/usr/bin/security find-generic-password -a rclone -s config -w" ``` #### Linux - Prerequisite: Linux doesn't come with a default password manager. Let's install the "pass" utility using a package manager, e.g. `apt install pass`, `yum install pass`, [etc.](https://www.passwordstore.org/#download); then initialize a password store: `pass init rclone`. - Generate and store a password ```sh echo $(openssl rand -base64 40) | pass insert -m rclone/config ``` - Add the retrieval instruction ```sh export RCLONE_PASSWORD_COMMAND="/usr/bin/pass rclone/config" ``` #### Windows - Generate and store a password ```pwsh New-Object -TypeName PSCredential -ArgumentList "rclone", (ConvertTo-SecureString -String ([System.Web.Security.Membership]::GeneratePassword(40, 10)) -AsPlainText -Force) | Export-Clixml -Path "rclone-credential.xml" ``` - Add the password retrieval instruction ```pwsh [Environment]::SetEnvironmentVariable("RCLONE_PASSWORD_COMMAND", "[System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToBSTR((Import-Clixml -Path "rclone-credential.xml").Password))") ``` #### Encrypt the config file (all systems) - Execute `rclone config`, and select option `s) Set configuration password` - Add/update the password from previous steps ## Developer options These options are useful when developing or debugging rclone. There are also some more remote specific options which aren't documented here which are used for testing. These start with remote name e.g. `--drive-test-option` - see the docs for the remote in question. ### --cpuprofile string Write CPU profile to a file. This can be analysed with `go tool pprof`. ### --memprofile string Write memory profile to a file. This can be analysed with `go tool pprof`. ### --dump DumpFlags The `--dump` flag takes a comma separated list of flags to dump info about. Note that some headers, such as `Accept-Encoding`, may not be correct as shown in the request, and the response may not show `Content-Encoding` if the go standard libraries auto gzip encoding was in effect. In this case the body of the request will be gunzipped before showing it. The available flags are: - `headers` dumps HTTP headers. Any `Authorization:` headers will be excluded, but output may still contain sensitive information. Can be very verbose. Useful for debugging only. Use `auth` if you do want the `Authorization:` headers. - `auth` dumps HTTP headers like `headers`, but also includes any `Authorization:` headers. This means the output will probably contain sensitive information. Use `headers` to dump without `Authorization:` headers. Can be very verbose. Useful for debugging only. - `bodies` dumps HTTP headers and bodies. May contain sensitive info. Can be very verbose. Useful for debugging only. Note that the bodies are buffered in memory so don't use this for enormous files. - `requests` is similar to `bodies`, but dumps the request bodies and the response headers. Useful for debugging download problems. - `responses` is similar to `bodies`, but dumps the response bodies and the request headers. Useful for debugging upload problems. - `filters` dumps the filters. Useful to see exactly what include and exclude options are filtering on. - `goroutines` dumps a list of the running go-routines at the end of the command. - `openfiles` dumps a list of the open files at the end of the command. It uses the `lsof` Unix command to do that, so you'll need that installed to use it. - `mapper` dumps the JSON blobs being sent to the program supplied with `--metadata-mapper` and received from it. It can be useful for debugging the metadata mapper interface. ## Filtering For the filtering options - `--delete-excluded` - `--filter` - `--filter-from` - `--exclude` - `--exclude-from` - `--exclude-if-present` - `--include` - `--include-from` - `--files-from` - `--files-from-raw` - `--min-size` - `--max-size` - `--min-age` - `--max-age` - `--hash-filter` - `--dump filters` - `--metadata-include` - `--metadata-include-from` - `--metadata-exclude` - `--metadata-exclude-from` - `--metadata-filter` - `--metadata-filter-from` See the [filtering section](https://rclone.org/filtering/). ## Remote control For the remote control options and for instructions on how to remote control rclone: - `--rc` - Anything starting with `--rc-` See [the remote control section](https://rclone.org/rc/). ## Logging rclone has 4 levels of logging, `ERROR`, `NOTICE`, `INFO` and `DEBUG`. By default, rclone logs to standard error. This means you can redirect standard error and still see the normal output of rclone commands (e.g. `rclone ls`). By default, rclone will produce `Error` and `Notice` level messages. If you use the `-q` flag, rclone will only produce `Error` messages. If you use the `-v` flag, rclone will produce `Error`, `Notice` and `Info` messages. If you use the `-vv` flag, rclone will produce `Error`, `Notice`, `Info` and `Debug` messages. You can also control the log levels with the `--log-level` flag. If you use the `--log-file` option, rclone will redirect `Error`, `Info` and `Debug` messages along with standard error to a file. If you use the `--syslog` flag then rclone will log to syslog and the `--syslog-facility` control which facility it uses. Rclone prefixes all log messages with their level in capitals, e.g. INFO which makes it easy to grep the log file for different kinds of information. ## Metrics Rclone can publish metrics in the OpenMetrics/Prometheus format. To enable the metrics endpoint, use the `--metrics-addr` flag. Metrics can also be published on the `--rc-addr` port if the `--rc` flag and `--rc-enable-metrics` flags are supplied or if using rclone rcd `--rc-enable-metrics` Rclone provides extensive configuration options for the metrics HTTP endpoint. These settings are grouped under the Metrics section and have a prefix `--metrics-*`. When metrics are enabled with `--rc-enable-metrics`, they will be published on the same port as the rc API. In this case, the `--metrics-*` flags will be ignored, and the HTTP endpoint configuration will be managed by the `--rc-*` parameters. ## Exit code If any errors occur during the command execution, rclone will exit with a non-zero exit code. This allows scripts to detect when rclone operations have failed. During the startup phase, rclone will exit immediately if an error is detected in the configuration. There will always be a log message immediately before exiting. When rclone is running it will accumulate errors as it goes along, and only exit with a non-zero exit code if (after retries) there were still failed transfers. For every error counted there will be a high priority log message (visible with `-q`) showing the message and which file caused the problem. A high priority message is also shown when starting a retry so the user can see that any previous error messages may not be valid after the retry. If rclone has done a retry it will log a high priority message if the retry was successful. ### List of exit codes - `0` - Success - `1` - Error not otherwise categorised - `2` - Syntax or usage error - `3` - Directory not found - `4` - File not found - `5` - Temporary error (one that more retries might fix) (Retry errors) - `6` - Less serious errors (like 461 errors from dropbox) (NoRetry errors) - `7` - Fatal error (one that more retries won't fix, like account suspended) (Fatal errors) - `8` - Transfer exceeded - limit set by --max-transfer reached - `9` - Operation successful, but no files transferred (Requires [`--error-on-no-transfer`](#error-on-no-transfer)) - `10` - Duration exceeded - limit set by --max-duration reached ## Environment variables Rclone can be configured entirely using environment variables. These can be used to set defaults for options or config file entries. ### Options Every option in rclone can have its default set by environment variable. To find the name of the environment variable, first, take the long option name, strip the leading `--`, change `-` to `_`, make upper case and prepend `RCLONE_`. For example, to always set `--stats 5s`, set the environment variable `RCLONE_STATS=5s`. If you set stats on the command line this will override the environment variable setting. Or to always use the trash in drive `--drive-use-trash`, set `RCLONE_DRIVE_USE_TRASH=true`. Verbosity is slightly different, the environment variable equivalent of `--verbose` or `-v` is `RCLONE_VERBOSE=1`, or for `-vv`, `RCLONE_VERBOSE=2`. The same parser is used for the options and the environment variables so they take exactly the same form. The options set by environment variables can be seen with the `-vv` flag, e.g. `rclone version -vv`. Options that can appear multiple times (type `stringArray`) are treated slightly differently as environment variables can only be defined once. In order to allow a simple mechanism for adding one or many items, the input is treated as a [CSV encoded](https://godoc.org/encoding/csv) string. For example | Environment variable | Equivalent options | |----------------------|--------------------| | `RCLONE_EXCLUDE="*.jpg"` | `--exclude "*.jpg"` | | `RCLONE_EXCLUDE="*.jpg,*.png"` | `--exclude "*.jpg"` `--exclude "*.png"` | | `RCLONE_EXCLUDE='"*.jpg","*.png"'` | `--exclude "*.jpg"` `--exclude "*.png"` | | `RCLONE_EXCLUDE='"/directory with comma , in it /**"'` | `--exclude "/directory with comma , in it /**" | If `stringArray` options are defined as environment variables **and** options on the command line then all the values will be used. ### Config file You can set defaults for values in the config file on an individual remote basis. The names of the config items are documented in the page for each backend. To find the name of the environment variable, you need to set, take `RCLONE_CONFIG_` + name of remote + `_` + name of config file option and make it all uppercase. Note one implication here is the remote's name must be convertible into a valid environment variable name, so it can only contain letters, digits, or the `_` (underscore) character. For example, to configure an S3 remote named `mys3:` without a config file (using unix ways of setting environment variables): ```sh $ export RCLONE_CONFIG_MYS3_TYPE=s3 $ export RCLONE_CONFIG_MYS3_ACCESS_KEY_ID=XXX $ export RCLONE_CONFIG_MYS3_SECRET_ACCESS_KEY=XXX $ rclone lsd mys3: -1 2016-09-21 12:54:21 -1 my-bucket $ rclone listremotes | grep mys3 mys3: ``` Note that if you want to create a remote using environment variables you must create the `..._TYPE` variable as above. Note that the name of a remote created using environment variable is case insensitive, in contrast to regular remotes stored in config file as documented [above](#valid-remote-names). You must write the name in uppercase in the environment variable, but as seen from example above it will be listed and can be accessed in lowercase, while you can also refer to the same remote in uppercase: ```sh $ rclone lsd mys3: -1 2016-09-21 12:54:21 -1 my-bucket $ rclone lsd MYS3: -1 2016-09-21 12:54:21 -1 my-bucket ``` Note that you can only set the options of the immediate backend, so RCLONE_CONFIG_MYS3CRYPT_ACCESS_KEY_ID has no effect, if myS3Crypt is a crypt remote based on an S3 remote. However RCLONE_S3_ACCESS_KEY_ID will set the access key of all remotes using S3, including myS3Crypt. Note also that now rclone has [connection strings](#connection-strings), it is probably easier to use those instead which makes the above example ```sh rclone lsd :s3,access_key_id=XXX,secret_access_key=XXX: ``` ### Precedence The various different methods of backend configuration are read in this order and the first one with a value is used. - Parameters in connection strings, e.g. `myRemote,skip_links:` - Flag values as supplied on the command line, e.g. `--skip-links` - Remote specific environment vars, e.g. `RCLONE_CONFIG_MYREMOTE_SKIP_LINKS` (see above). - Backend-specific environment vars, e.g. `RCLONE_LOCAL_SKIP_LINKS`. - Backend generic environment vars, e.g. `RCLONE_SKIP_LINKS`. - Config file, e.g. `skip_links = true`. - Default values, e.g. `false` - these can't be changed. So if both `--skip-links` is supplied on the command line and an environment variable `RCLONE_LOCAL_SKIP_LINKS` is set, the command line flag will take preference. The backend configurations set by environment variables can be seen with the `-vv` flag, e.g. `rclone about myRemote: -vv`. For non backend configuration the order is as follows: - Flag values as supplied on the command line, e.g. `--stats 5s`. - Environment vars, e.g. `RCLONE_STATS=5s`. - Default values, e.g. `1m` - these can't be changed. ### Other environment variables - `RCLONE_CONFIG_PASS` set to contain your config file password (see [Configuration Encryption](#configuration-encryption) section) - `HTTP_PROXY`, `HTTPS_PROXY` and `NO_PROXY` (or the lowercase versions thereof). - `HTTPS_PROXY` takes precedence over `HTTP_PROXY` for https requests. - The environment values may be either a complete URL or a "host[:port]" for, in which case the "http" scheme is assumed. - `USER` and `LOGNAME` values are used as fallbacks for current username. The primary method for looking up username is OS-specific: Windows API on Windows, real user ID in /etc/passwd on Unix systems. In the documentation the current username is simply referred to as `$USER`. - `RCLONE_CONFIG_DIR` - rclone **sets** this variable for use in config files and sub processes to point to the directory holding the config file. The options set by environment variables can be seen with the `-vv` and `--log-level=DEBUG` flags, e.g. `rclone version -vv`. # Configuring rclone on a remote / headless machine # Some of the configurations (those involving oauth2) require an Internet connected web browser. If you are trying to set rclone up on a remote or headless box with no browser available on it (e.g. a NAS or a server in a datacenter) then you will need to use an alternative means of configuration. There are two ways of doing it, described below. ## Configuring using rclone authorize ## On the headless box run `rclone` config but answer `N` to the `Use auto config?` question. ``` Use auto config? * Say Y if not sure * Say N if you are working on a remote or headless machine y) Yes (default) n) No y/n> n Option config_token. For this to work, you will need rclone available on a machine that has a web browser available. For more help and alternate methods see: https://rclone.org/remote_setup/ Execute the following on the machine with the web browser (same rclone version recommended): rclone authorize "onedrive" Then paste the result. Enter a value. config_token> ``` Then on your main desktop machine ``` rclone authorize "onedrive" If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Paste the following into your remote machine ---> SECRET_TOKEN <---End paste ``` Then back to the headless box, paste in the code ``` config_token> SECRET_TOKEN -------------------- [acd12] client_id = client_secret = token = SECRET_TOKEN -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> ``` ## Configuring by copying the config file ## Rclone stores all of its config in a single configuration file. This can easily be copied to configure a remote rclone. So first configure rclone on your desktop machine with rclone config to set up the config file. Find the config file by running `rclone config file`, for example ``` $ rclone config file Configuration file is stored at: /home/user/.rclone.conf ``` Now transfer it to the remote box (scp, cut paste, ftp, sftp, etc.) and place it in the correct place (use `rclone config file` on the remote box to find out where). ## Configuring using SSH Tunnel ## Linux and MacOS users can utilize SSH Tunnel to redirect the headless box port 53682 to local machine by using the following command: ``` ssh -L localhost:53682:localhost:53682 username@remote_server ``` Then on the headless box run `rclone config` and answer `Y` to the `Use auto config?` question. ``` Use auto config? * Say Y if not sure * Say N if you are working on a remote or headless machine y) Yes (default) n) No y/n> y ``` Then copy and paste the auth url `http://127.0.0.1:53682/auth?state=xxxxxxxxxxxx` to the browser on your local machine, complete the auth and it is done. # Filtering, includes and excludes Filter flags determine which files rclone `sync`, `move`, `ls`, `lsl`, `md5sum`, `sha1sum`, `size`, `delete`, `check` and similar commands apply to. They are specified in terms of path/file name patterns; path/file lists; file age and size, or presence of a file in a directory. Bucket based remotes without the concept of directory apply filters to object key, age and size in an analogous way. Rclone `purge` does not obey filters. To test filters without risk of damage to data, apply them to `rclone ls`, or with the `--dry-run` and `-vv` flags. Rclone filter patterns can only be used in filter command line options, not in the specification of a remote. E.g. `rclone copy "remote:dir*.jpg" /path/to/dir` does not have a filter effect. `rclone copy remote:dir /path/to/dir --include "*.jpg"` does. **Important** Avoid mixing any two of `--include...`, `--exclude...` or `--filter...` flags in an rclone command. The results might not be what you expect. Instead use a `--filter...` flag. ## Patterns for matching path/file names ### Pattern syntax {#patterns} Here is a formal definition of the pattern syntax, [examples](#examples) are below. Rclone matching rules follow a glob style: ```text * matches any sequence of non-separator (/) characters ** matches any sequence of characters including / separators ? matches any single non-separator (/) character [ [ ! ] { character-range } ] character class (must be non-empty) { pattern-list } pattern alternatives {{ regexp }} regular expression to match c matches character c (c != *, **, ?, \, [, {, }) \c matches reserved character c (c = *, **, ?, \, [, {, }) or character class ``` character-range: ```text c matches character c (c != \, -, ]) \c matches reserved character c (c = \, -, ]) lo - hi matches character c for lo <= c <= hi ``` pattern-list: ```text pattern { , pattern } comma-separated (without spaces) patterns ``` character classes (see [Go regular expression reference](https://golang.org/pkg/regexp/syntax/)) include: ```text Named character classes (e.g. [\d], [^\d], [\D], [^\D]) Perl character classes (e.g. \s, \S, \w, \W) ASCII character classes (e.g. [[:alnum:]], [[:alpha:]], [[:punct:]], [[:xdigit:]]) ``` regexp for advanced users to insert a regular expression - see [below](#regexp) for more info: ```text Any re2 regular expression not containing `}}` ``` If the filter pattern starts with a `/` then it only matches at the top level of the directory tree, **relative to the root of the remote** (not necessarily the root of the drive). If it does not start with `/` then it is matched starting at the **end of the path/file name** but it only matches a complete path element - it must match from a `/` separator or the beginning of the path/file. ```text file.jpg - matches "file.jpg" - matches "directory/file.jpg" - doesn't match "afile.jpg" - doesn't match "directory/afile.jpg" /file.jpg - matches "file.jpg" in the root directory of the remote - doesn't match "afile.jpg" - doesn't match "directory/file.jpg" ``` The top level of the remote might not be the top level of the drive. E.g. for a Microsoft Windows local directory structure ```text F: ├── bkp ├── data │ ├── excl │ │ ├── 123.jpg │ │ └── 456.jpg │ ├── incl │ │ └── document.pdf ``` To copy the contents of folder `data` into folder `bkp` excluding the contents of subfolder `excl`the following command treats `F:\data` and `F:\bkp` as top level for filtering. `rclone copy F:\data\ F:\bkp\ --exclude=/excl/**` **Important** Use `/` in path/file name patterns and not `\` even if running on Microsoft Windows. Simple patterns are case sensitive unless the `--ignore-case` flag is used. Without `--ignore-case` (default) ```text potato - matches "potato" - doesn't match "POTATO" ``` With `--ignore-case` ```text potato - matches "potato" - matches "POTATO" ``` ## Using regular expressions in filter patterns {#regexp} The syntax of filter patterns is glob style matching (like `bash` uses) to make things easy for users. However this does not provide absolute control over the matching, so for advanced users rclone also provides a regular expression syntax. The regular expressions used are as defined in the [Go regular expression reference](https://golang.org/pkg/regexp/syntax/). Regular expressions should be enclosed in `{{` `}}`. They will match only the last path segment if the glob doesn't start with `/` or the whole path name if it does. Note that rclone does not attempt to parse the supplied regular expression, meaning that using any regular expression filter will prevent rclone from using [directory filter rules](#directory_filter), as it will instead check every path against the supplied regular expression(s). Here is how the `{{regexp}}` is transformed into an full regular expression to match the entire path: ```text {{regexp}} becomes (^|/)(regexp)$ /{{regexp}} becomes ^(regexp)$ ``` Regexp syntax can be mixed with glob syntax, for example ```text *.{{jpe?g}} to match file.jpg, file.jpeg but not file.png ``` You can also use regexp flags - to set case insensitive, for example ```text *.{{(?i)jpg}} to match file.jpg, file.JPG but not file.png ``` Be careful with wildcards in regular expressions - you don't want them to match path separators normally. To match any file name starting with `start` and ending with `end` write ```text {{start[^/]*end\.jpg}} ``` Not ```text {{start.*end\.jpg}} ``` Which will match a directory called `start` with a file called `end.jpg` in it as the `.*` will match `/` characters. Note that you can use `-vv --dump filters` to show the filter patterns in regexp format - rclone implements the glob patterns by transforming them into regular expressions. ## Filter pattern examples {#examples} | Description | Pattern | Matches | Does not match | | ----------- |-------- | ------- | -------------- | | Wildcard | `*.jpg` | `/file.jpg` | `/file.png` | | | | `/dir/file.jpg` | `/dir/file.png` | | Rooted | `/*.jpg` | `/file.jpg` | `/file.png` | | | | `/file2.jpg` | `/dir/file.jpg` | | Alternates | `*.{jpg,png}` | `/file.jpg` | `/file.gif` | | | | `/dir/file.png` | `/dir/file.gif` | | Path Wildcard | `dir/**` | `/dir/anyfile` | `file.png` | | | | `/subdir/dir/subsubdir/anyfile` | `/subdir/file.png` | | Any Char | `*.t?t` | `/file.txt` | `/file.qxt` | | | | `/dir/file.tzt` | `/dir/file.png` | | Range | `*.[a-z]` | `/file.a` | `/file.0` | | | | `/dir/file.b` | `/dir/file.1` | | Escape | `*.\?\?\?` | `/file.???` | `/file.abc` | | | | `/dir/file.???` | `/dir/file.def` | | Class | `*.\d\d\d` | `/file.012` | `/file.abc` | | | | `/dir/file.345` | `/dir/file.def` | | Regexp | `*.{{jpe?g}}` | `/file.jpeg` | `/file.png` | | | | `/dir/file.jpg` | `/dir/file.jpeeg` | | Rooted Regexp | `/{{.*\.jpe?g}}` | `/file.jpeg` | `/file.png` | | | | `/file.jpg` | `/dir/file.jpg` | ## How filter rules are applied to files {#how-filter-rules-work} Rclone path/file name filters are made up of one or more of the following flags: - `--include` - `--include-from` - `--exclude` - `--exclude-from` - `--filter` - `--filter-from` There can be more than one instance of individual flags. Rclone internally uses a combined list of all the include and exclude rules. The order in which rules are processed can influence the result of the filter. All flags of the same type are processed together in the order above, regardless of what order the different types of flags are included on the command line. Multiple instances of the same flag are processed from left to right according to their position in the command line. To mix up the order of processing includes and excludes use `--filter...` flags. Within `--include-from`, `--exclude-from` and `--filter-from` flags rules are processed from top to bottom of the referenced file. If there is an `--include` or `--include-from` flag specified, rclone implies a `- **` rule which it adds to the bottom of the internal rule list. Specifying a `+` rule with a `--filter...` flag does not imply that rule. Each path/file name passed through rclone is matched against the combined filter list. At first match to a rule the path/file name is included or excluded and no further filter rules are processed for that path/file. If rclone does not find a match, after testing against all rules (including the implied rule if appropriate), the path/file name is included. Any path/file included at that stage is processed by the rclone command. `--files-from` and `--files-from-raw` flags over-ride and cannot be combined with other filter options. To see the internal combined rule list, in regular expression form, for a command add the `--dump filters` flag. Running an rclone command with `--dump filters` and `-vv` flags lists the internal filter elements and shows how they are applied to each source path/file. There is not currently a means provided to pass regular expression filter options into rclone directly though character class filter rules contain character classes. [Go regular expression reference](https://golang.org/pkg/regexp/syntax/) ### How filter rules are applied to directories {#directory_filter} Rclone commands are applied to path/file names not directories. The entire contents of a directory can be matched to a filter by the pattern `directory/*` or recursively by `directory/**`. Directory filter rules are defined with a closing `/` separator. E.g. `/directory/subdirectory/` is an rclone directory filter rule. Rclone commands can use directory filter rules to determine whether they recurse into subdirectories. This potentially optimises access to a remote by avoiding listing unnecessary directories. Whether optimisation is desirable depends on the specific filter rules and source remote content. If any [regular expression filters](#regexp) are in use, then no directory recursion optimisation is possible, as rclone must check every path against the supplied regular expression(s). Directory recursion optimisation occurs if either: - A source remote does not support the rclone `ListR` primitive. local, sftp, Microsoft OneDrive and WebDAV do not support `ListR`. Google Drive and most bucket type storage do. [Full list](https://rclone.org/overview/#optional-features) - On other remotes (those that support `ListR`), if the rclone command is not naturally recursive, and provided it is not run with the `--fast-list` flag. `ls`, `lsf -R` and `size` are naturally recursive but `sync`, `copy` and `move` are not. - Whenever the `--disable ListR` flag is applied to an rclone command. Rclone commands imply directory filter rules from path/file filter rules. To view the directory filter rules rclone has implied for a command specify the `--dump filters` flag. E.g. for an include rule ```text /a/*.jpg ``` Rclone implies the directory include rule ```text /a/ ``` Directory filter rules specified in an rclone command can limit the scope of an rclone command but path/file filters still have to be specified. E.g. `rclone ls remote: --include /directory/` will not match any files. Because it is an `--include` option the `--exclude **` rule is implied, and the `/directory/` pattern serves only to optimise access to the remote by ignoring everything outside of that directory. E.g. `rclone ls remote: --filter-from filter-list.txt` with a file `filter-list.txt`: ```text - /dir1/ - /dir2/ + *.pdf - ** ``` All files in directories `dir1` or `dir2` or their subdirectories are completely excluded from the listing. Only files of suffix `pdf` in the root of `remote:` or its subdirectories are listed. The `- **` rule prevents listing of any path/files not previously matched by the rules above. Option `exclude-if-present` creates a directory exclude rule based on the presence of a file in a directory and takes precedence over other rclone directory filter rules. When using pattern list syntax, if a pattern item contains either `/` or `**`, then rclone will not able to imply a directory filter rule from this pattern list. E.g. for an include rule ```text {dir1/**,dir2/**} ``` Rclone will match files below directories `dir1` or `dir2` only, but will not be able to use this filter to exclude a directory `dir3` from being traversed. Directory recursion optimisation may affect performance, but normally not the result. One exception to this is sync operations with option `--create-empty-src-dirs`, where any traversed empty directories will be created. With the pattern list example `{dir1/**,dir2/**}` above, this would create an empty directory `dir3` on destination (when it exists on source). Changing the filter to `{dir1,dir2}/**`, or splitting it into two include rules `--include dir1/** --include dir2/**`, will match the same files while also filtering directories, with the result that an empty directory `dir3` will no longer be created. ### `--exclude` - Exclude files matching pattern Excludes path/file names from an rclone command based on a single exclude rule. This flag can be repeated. See above for the order filter flags are processed in. `--exclude` should not be used with `--include`, `--include-from`, `--filter` or `--filter-from` flags. `--exclude` has no effect when combined with `--files-from` or `--files-from-raw` flags. E.g. `rclone ls remote: --exclude *.bak` excludes all .bak files from listing. E.g. `rclone size remote: --exclude "/dir/**"` returns the total size of all files on `remote:` excluding those in root directory `dir` and sub directories. E.g. on Microsoft Windows `rclone ls remote: --exclude "*\[{JP,KR,HK}\]*"` lists the files in `remote:` without `[JP]` or `[KR]` or `[HK]` in their name. Quotes prevent the shell from interpreting the `\` characters.`\` characters escape the `[` and `]` so an rclone filter treats them literally rather than as a character-range. The `{` and `}` define an rclone pattern list. For other operating systems single quotes are required ie `rclone ls remote: --exclude '*\[{JP,KR,HK}\]*'` ### `--exclude-from` - Read exclude patterns from file Excludes path/file names from an rclone command based on rules in a named file. The file contains a list of remarks and pattern rules. For an example `exclude-file.txt`: ```text # a sample exclude rule file *.bak file2.jpg ``` `rclone ls remote: --exclude-from exclude-file.txt` lists the files on `remote:` except those named `file2.jpg` or with a suffix `.bak`. That is equivalent to `rclone ls remote: --exclude file2.jpg --exclude "*.bak"`. This flag can be repeated. See above for the order filter flags are processed in. The `--exclude-from` flag is useful where multiple exclude filter rules are applied to an rclone command. `--exclude-from` should not be used with `--include`, `--include-from`, `--filter` or `--filter-from` flags. `--exclude-from` has no effect when combined with `--files-from` or `--files-from-raw` flags. `--exclude-from` followed by `-` reads filter rules from standard input. ### `--include` - Include files matching pattern Adds a single include rule based on path/file names to an rclone command. This flag can be repeated. See above for the order filter flags are processed in. `--include` has no effect when combined with `--files-from` or `--files-from-raw` flags. `--include` implies `--exclude **` at the end of an rclone internal filter list. Therefore if you mix `--include` and `--include-from` flags with `--exclude`, `--exclude-from`, `--filter` or `--filter-from`, you must use include rules for all the files you want in the include statement. For more flexibility use the `--filter-from` flag. E.g. `rclone ls remote: --include "*.{png,jpg}"` lists the files on `remote:` with suffix `.png` and `.jpg`. All other files are excluded. E.g. multiple rclone copy commands can be combined with `--include` and a pattern-list. ```sh rclone copy /vol1/A remote:A rclone copy /vol1/B remote:B ``` is equivalent to: ```sh rclone copy /vol1 remote: --include "{A,B}/**" ``` E.g. `rclone ls remote:/wheat --include "??[^[:punct:]]*"` lists the files `remote:` directory `wheat` (and subdirectories) whose third character is not punctuation. This example uses an [ASCII character class](https://golang.org/pkg/regexp/syntax/). ### `--include-from` - Read include patterns from file Adds path/file names to an rclone command based on rules in a named file. The file contains a list of remarks and pattern rules. For an example `include-file.txt`: ```text # a sample include rule file *.jpg file2.avi ``` `rclone ls remote: --include-from include-file.txt` lists the files on `remote:` with name `file2.avi` or suffix `.jpg`. That is equivalent to `rclone ls remote: --include file2.avi --include "*.jpg"`. This flag can be repeated. See above for the order filter flags are processed in. The `--include-from` flag is useful where multiple include filter rules are applied to an rclone command. `--include-from` implies `--exclude **` at the end of an rclone internal filter list. Therefore if you mix `--include` and `--include-from` flags with `--exclude`, `--exclude-from`, `--filter` or `--filter-from`, you must use include rules for all the files you want in the include statement. For more flexibility use the `--filter-from` flag. `--include-from` has no effect when combined with `--files-from` or `--files-from-raw` flags. `--include-from` followed by `-` reads filter rules from standard input. ### `--filter` - Add a file-filtering rule Specifies path/file names to an rclone command, based on a single include or exclude rule, in `+` or `-` format. This flag can be repeated. See above for the order filter flags are processed in. `--filter +` differs from `--include`. In the case of `--include` rclone implies an `--exclude *` rule which it adds to the bottom of the internal rule list. `--filter...+` does not imply that rule. `--filter` has no effect when combined with `--files-from` or `--files-from-raw` flags. `--filter` should not be used with `--include`, `--include-from`, `--exclude` or `--exclude-from` flags. E.g. `rclone ls remote: --filter "- *.bak"` excludes all `.bak` files from a list of `remote:`. ### `--filter-from` - Read filtering patterns from a file Adds path/file names to an rclone command based on rules in a named file. The file contains a list of remarks and pattern rules. Include rules start with `+ ` and exclude rules with `- `. `!` clears existing rules. Rules are processed in the order they are defined. This flag can be repeated. See above for the order filter flags are processed in. Arrange the order of filter rules with the most restrictive first and work down. Lines starting with # or ; are ignored, and can be used to write comments. Inline comments are not supported. *Use `-vv --dump filters` to see how they appear in the final regexp.* E.g. for `filter-file.txt`: ```text # a sample filter rule file - secret*.jpg + *.jpg + *.png + file2.avi - /dir/tmp/** # WARNING! This text will be treated as part of the path. - /dir/Trash/** + /dir/** # exclude everything else - * ``` `rclone ls remote: --filter-from filter-file.txt` lists the path/files on `remote:` including all `jpg` and `png` files, excluding any matching `secret*.jpg` and including `file2.avi`. It also includes everything in the directory `dir` at the root of `remote`, except `remote:dir/Trash` which it excludes. Everything else is excluded. E.g. for an alternative `filter-file.txt`: ```text - secret*.jpg + *.jpg + *.png + file2.avi - * ``` Files `file1.jpg`, `file3.png` and `file2.avi` are listed whilst `secret17.jpg` and files without the suffix `.jpg` or `.png` are excluded. E.g. for an alternative `filter-file.txt`: ```text + *.jpg + *.gif ! + 42.doc - * ``` Only file 42.doc is listed. Prior rules are cleared by the `!`. ### `--files-from` - Read list of source-file names Adds path/files to an rclone command from a list in a named file. Rclone processes the path/file names in the order of the list, and no others. Other filter flags (`--include`, `--include-from`, `--exclude`, `--exclude-from`, `--filter` and `--filter-from`) are ignored when `--files-from` is used. `--files-from` expects a list of files as its input. Leading or trailing whitespace is stripped from the input lines. Lines starting with `#` or `;` are ignored. `--files-from` followed by `-` reads the list of files from standard input. Rclone commands with a `--files-from` flag traverse the remote, treating the names in `--files-from` as a set of filters. If the `--no-traverse` and `--files-from` flags are used together an rclone command does not traverse the remote. Instead it addresses each path/file named in the file individually. For each path/file name, that requires typically 1 API call. This can be efficient for a short `--files-from` list and a remote containing many files. Rclone commands do not error if any names in the `--files-from` file are missing from the source remote. The `--files-from` flag can be repeated in a single rclone command to read path/file names from more than one file. The files are read from left to right along the command line. Paths within the `--files-from` file are interpreted as starting with the root specified in the rclone command. Leading `/` separators are ignored. See [--files-from-raw](#files-from-raw-read-list-of-source-file-names-without-any-processing) if you need the input to be processed in a raw manner. E.g. for a file `files-from.txt`: ```text # comment file1.jpg subdir/file2.jpg ``` `rclone copy --files-from files-from.txt /home/me/pics remote:pics` copies the following, if they exist, and only those files. ```text /home/me/pics/file1.jpg → remote:pics/file1.jpg /home/me/pics/subdir/file2.jpg → remote:pics/subdir/file2.jpg ``` E.g. to copy the following files referenced by their absolute paths: ```text /home/user1/42 /home/user1/dir/ford /home/user2/prefect ``` First find a common subdirectory - in this case `/home` and put the remaining files in `files-from.txt` with or without leading `/`, e.g. ```text user1/42 user1/dir/ford user2/prefect ``` Then copy these to a remote: ```sh rclone copy --files-from files-from.txt /home remote:backup ``` The three files are transferred as follows: ```text /home/user1/42 → remote:backup/user1/important /home/user1/dir/ford → remote:backup/user1/dir/file /home/user2/prefect → remote:backup/user2/stuff ``` Alternatively if `/` is chosen as root `files-from.txt` will be: ```text /home/user1/42 /home/user1/dir/ford /home/user2/prefect ``` The copy command will be: ```sh rclone copy --files-from files-from.txt / remote:backup ``` Then there will be an extra `home` directory on the remote: ```text /home/user1/42 → remote:backup/home/user1/42 /home/user1/dir/ford → remote:backup/home/user1/dir/ford /home/user2/prefect → remote:backup/home/user2/prefect ``` ### `--files-from-raw` - Read list of source-file names without any processing This flag is the same as `--files-from` except that input is read in a raw manner. Lines with leading / trailing whitespace, and lines starting with `;` or `#` are read without any processing. [rclone lsf](https://rclone.org/commands/rclone_lsf/) has a compatible format that can be used to export file lists from remotes for input to `--files-from-raw`. ### `--ignore-case` - make searches case insensitive By default, rclone filter patterns are case sensitive. The `--ignore-case` flag makes all of the filters patterns on the command line case insensitive. E.g. `--include "zaphod.txt"` does not match a file `Zaphod.txt`. With `--ignore-case` a match is made. ## Quoting shell metacharacters Rclone commands with filter patterns containing shell metacharacters may not as work as expected in your shell and may require quoting. E.g. linux, OSX (`*` metacharacter) - `--include \*.jpg` - `--include '*.jpg'` - `--include='*.jpg'` Microsoft Windows expansion is done by the command, not shell, so `--include *.jpg` does not require quoting. If the rclone error `Command .... needs .... arguments maximum: you provided .... non flag arguments:` is encountered, the cause is commonly spaces within the name of a remote or flag value. The fix then is to quote values containing spaces. ## Other filters ### `--min-size` - Don't transfer any file smaller than this Controls the minimum size file within the scope of an rclone command. Default units are `KiB` but abbreviations `B`, `K`, `M`, `G`, `T` or `P` are valid. E.g. `rclone ls remote: --min-size 50k` lists files on `remote:` of 50 KiB size or larger. See [the size option docs](https://rclone.org/docs/#size-options) for more info. ### `--max-size` - Don't transfer any file larger than this Controls the maximum size file within the scope of an rclone command. Default units are `KiB` but abbreviations `B`, `K`, `M`, `G`, `T` or `P` are valid. E.g. `rclone ls remote: --max-size 1G` lists files on `remote:` of 1 GiB size or smaller. See [the size option docs](https://rclone.org/docs/#size-options) for more info. ### `--max-age` - Don't transfer any file older than this Controls the maximum age of files within the scope of an rclone command. `--max-age` applies only to files and not to directories. E.g. `rclone ls remote: --max-age 2d` lists files on `remote:` of 2 days old or less. See [the time option docs](https://rclone.org/docs/#time-options) for valid formats. ### `--min-age` - Don't transfer any file younger than this Controls the minimum age of files within the scope of an rclone command. (see `--max-age` for valid formats) `--min-age` applies only to files and not to directories. E.g. `rclone ls remote: --min-age 2d` lists files on `remote:` of 2 days old or more. See [the time option docs](https://rclone.org/docs/#time-options) for valid formats. ### `--hash-filter` - Deterministically select a subset of files {#hash-filter} The `--hash-filter` flag enables selecting a deterministic subset of files, useful for: 1. Running large sync operations across multiple machines. 2. Checking a subset of files for bitrot. 3. Any other operations where a sample of files is required. #### Syntax The flag takes two parameters expressed as a fraction: ```sh --hash-filter K/N ``` - `N`: The total number of partitions (must be a positive integer). - `K`: The specific partition to select (an integer from `0` to `N`). For example: - `--hash-filter 1/3`: Selects the first third of the files. - `--hash-filter 2/3` and `--hash-filter 3/3`: Select the second and third partitions, respectively. Each partition is non-overlapping, ensuring all files are covered without duplication. #### Random Partition Selection Use `@` as `K` to randomly select a partition: ```sh --hash-filter @/M ``` For example, `--hash-filter @/3` will randomly select a number between 0 and 2. This will stay constant across retries. #### How It Works - Rclone takes each file's full path, normalizes it to lowercase, and applies Unicode normalization. - It then hashes the normalized path into a 64 bit number. - The hash result is reduced modulo `N` to assign the file to a partition. - If the calculated partition does not match `K` the file is excluded. - Other filters may apply if the file is not excluded. **Important:** Rclone will traverse all directories to apply the filter. #### Usage Notes - Safe to use with `rclone sync`; source and destination selections will match. - **Do not** use with `--delete-excluded`, as this could delete unselected files. - Ignored if `--files-from` is used. #### Examples ##### Dividing files into 4 partitions Assuming the current directory contains `file1.jpg` through `file9.jpg`: ```sh $ rclone lsf --hash-filter 0/4 . file1.jpg file5.jpg $ rclone lsf --hash-filter 1/4 . file3.jpg file6.jpg file9.jpg $ rclone lsf --hash-filter 2/4 . file2.jpg file4.jpg $ rclone lsf --hash-filter 3/4 . file7.jpg file8.jpg $ rclone lsf --hash-filter 4/4 . # the same as --hash-filter 0/4 file1.jpg file5.jpg ``` ##### Syncing the first quarter of files ```sh rclone sync --hash-filter 1/4 source:path destination:path ``` ##### Checking a random 1% of files for integrity ```sh rclone check --download --hash-filter @/100 source:path destination:path ``` ## Other flags ### `--delete-excluded` - Delete files on dest excluded from sync **Important** this flag is dangerous to your data - use with `--dry-run` and `-v` first. In conjunction with `rclone sync`, `--delete-excluded` deletes any files on the destination which are excluded from the command. E.g. the scope of `rclone sync --interactive A: B:` can be restricted: ```sh rclone --min-size 50k --delete-excluded sync A: B: ``` All files on `B:` which are less than 50 KiB are deleted because they are excluded from the rclone sync command. ### `--dump filters` - dump the filters to the output Dumps the defined filters to standard output in regular expression format. Useful for debugging. ## Exclude directory based on a file The `--exclude-if-present` flag controls whether a directory is within the scope of an rclone command based on the presence of a named file within it. The flag can be repeated to check for multiple file names, presence of any of them will exclude the directory. This flag has a priority over other filter flags. E.g. for the following directory structure: ```text dir1/file1 dir1/dir2/file2 dir1/dir2/dir3/file3 dir1/dir2/dir3/.ignore ``` The command `rclone ls --exclude-if-present .ignore dir1` does not list `dir3`, `file3` or `.ignore`. ## Metadata filters {#metadata} The metadata filters work in a very similar way to the normal file name filters, except they match [metadata](https://rclone.org/docs/#metadata) on the object. The metadata should be specified as `key=value` patterns. This may be wildcarded using the normal [filter patterns](#patterns) or [regular expressions](#regexp). For example if you wished to list only local files with a mode of `100664` you could do that with: ```sh rclone lsf -M --files-only --metadata-include "mode=100664" . ``` Or if you wished to show files with an `atime`, `mtime` or `btime` at a given date: ```sh rclone lsf -M --files-only --metadata-include "[abm]time=2022-12-16*" . ``` Like file filtering, metadata filtering only applies to files not to directories. The filters can be applied using these flags. - `--metadata-include` - Include metadatas matching pattern - `--metadata-include-from` - Read metadata include patterns from file (use - to read from stdin) - `--metadata-exclude` - Exclude metadatas matching pattern - `--metadata-exclude-from` - Read metadata exclude patterns from file (use - to read from stdin) - `--metadata-filter` - Add a metadata filtering rule - `--metadata-filter-from` - Read metadata filtering patterns from a file (use - to read from stdin) Each flag can be repeated. See the section on [how filter rules are applied](#how-filter-rules-work) for more details - these flags work in an identical way to the file name filtering flags, but instead of file name patterns have metadata patterns. ## Common pitfalls The most frequent filter support issues on the [rclone forum](https://forum.rclone.org/) are: - Not using paths relative to the root of the remote - Not using `/` to match from the root of a remote - Not using `**` to match the contents of a directory # GUI (Experimental) Rclone can serve a web based GUI (graphical user interface). This is somewhat experimental at the moment so things may be subject to change. Run this command in a terminal and rclone will download and then display the GUI in a web browser. ```sh rclone rcd --rc-web-gui ``` This will produce logs like this and rclone needs to continue to run to serve the GUI: ```text 2019/08/25 11:40:14 NOTICE: A new release for gui is present at https://github.com/rclone/rclone-webui-react/releases/download/v0.0.6/currentbuild.zip 2019/08/25 11:40:14 NOTICE: Downloading webgui binary. Please wait. [Size: 3813937, Path : /home/USER/.cache/rclone/webgui/v0.0.6.zip] 2019/08/25 11:40:16 NOTICE: Unzipping 2019/08/25 11:40:16 NOTICE: Serving remote control on http://127.0.0.1:5572/ ``` This assumes you are running rclone locally on your machine. It is possible to separate the rclone and the GUI - see below for details. If you wish to check for updates then you can add `--rc-web-gui-update` to the command line. If you find your GUI broken, you may force it to update by add `--rc-web-gui-force-update`. By default, rclone will open your browser. Add `--rc-web-gui-no-open-browser` to disable this feature. ## Using the GUI Once the GUI opens, you will be looking at the dashboard which has an overall overview. On the left hand side you will see a series of view buttons you can click on: - Dashboard - main overview - Configs - examine and create new configurations - Explorer - view, download and upload files to the cloud storage systems - Backend - view or alter the backend config - Log out (More docs and walkthrough video to come!) ## How it works When you run the `rclone rcd --rc-web-gui` this is what happens - Rclone starts but only runs the remote control API ("rc"). - The API is bound to localhost with an auto-generated username and password. - If the API bundle is missing then rclone will download it. - rclone will start serving the files from the API bundle over the same port as the API - rclone will open the browser with a `login_token` so it can log straight in. ## Advanced use The `rclone rcd` may use any of the [flags documented on the rc page](https://rclone.org/rc/#supported-parameters). The flag `--rc-web-gui` is shorthand for - Download the web GUI if necessary - Check we are using some authentication - `--rc-user gui` - `--rc-pass ` - `--rc-serve` These flags can be overridden as desired. See also the [rclone rcd documentation](https://rclone.org/commands/rclone_rcd/). ### Example: Running a public GUI For example the GUI could be served on a public port over SSL using an htpasswd file using the following flags: - `--rc-web-gui` - `--rc-addr :443` - `--rc-htpasswd /path/to/htpasswd` - `--rc-cert /path/to/ssl.crt` - `--rc-key /path/to/ssl.key` ### Example: Running a GUI behind a proxy If you want to run the GUI behind a proxy at `/rclone` you could use these flags: - `--rc-web-gui` - `--rc-baseurl rclone` - `--rc-htpasswd /path/to/htpasswd` Or instead of htpasswd if you just want a single user and password: - `--rc-user me` - `--rc-pass mypassword` ## Project The GUI is being developed in the: [rclone/rclone-webui-react repository](https://github.com/rclone/rclone-webui-react). Bug reports and contributions are very welcome :-) If you have questions then please ask them on the [rclone forum](https://forum.rclone.org/). # Remote controlling rclone with its API If rclone is run with the `--rc` flag then it starts an HTTP server which can be used to remote control rclone using its API. You can either use the [rc](#api-rc) command to access the API or [use HTTP directly](#api-http). If you just want to run a remote control then see the [rcd](https://rclone.org/commands/rclone_rcd/) command. ## Supported parameters ### --rc Flag to start the http server listen on remote requests. ### --rc-addr=IP IPaddress:Port or :Port to bind server to. (default "localhost:5572"). ### --rc-cert=KEY SSL PEM key (concatenation of certificate and CA certificate). ### --rc-client-ca=PATH Client certificate authority to verify clients with. ### --rc-htpasswd=PATH htpasswd file - if not provided no authentication is done. ### --rc-key=PATH TLS PEM private key file. ### --rc-max-header-bytes=VALUE Maximum size of request header (default 4096). ### --rc-min-tls-version=VALUE The minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0"). ### --rc-user=VALUE User name for authentication. ### --rc-pass=VALUE Password for authentication. ### --rc-realm=VALUE Realm for authentication (default "rclone"). ### --rc-server-read-timeout=DURATION Timeout for server reading data (default 1h0m0s). ### --rc-server-write-timeout=DURATION Timeout for server writing data (default 1h0m0s). ### --rc-serve Enable the serving of remote objects via the HTTP interface. This means objects will be accessible at `http://127.0.0.1:5572/` by default, so you can browse to `http://127.0.0.1:5572/` or `http://127.0.0.1:5572/*` to see a listing of the remotes. Objects may be requested from remotes using this syntax `http://127.0.0.1:5572/[remote:path]/path/to/object` Default Off. ### --rc-serve-no-modtime Set this flag to skip reading the modification time (can speed things up). Default Off. ### --rc-files /path/to/directory Path to local files to serve on the HTTP server. If this is set then rclone will serve the files in that directory. It will also open the root in the web browser if specified. This is for implementing browser based GUIs for rclone functions. If `--rc-user` or `--rc-pass` is set then the URL that is opened will have the authorization in the URL in the `http://user:pass@localhost/` style. Default Off. ### --rc-enable-metrics Enable OpenMetrics/Prometheus compatible endpoint at `/metrics`. If more control over the metrics is desired (for example running it on a different port or with different auth) then endpoint can be enabled with the `--metrics-*` flags instead. Default Off. ### --rc-web-gui Set this flag to serve the default web gui on the same port as rclone. Default Off. ### --rc-allow-origin Set the allowed Access-Control-Allow-Origin for rc requests. Can be used with --rc-web-gui if the rclone is running on different IP than the web-gui. Default is IP address on which rc is running. ### --rc-web-fetch-url Set the URL to fetch the rclone-web-gui files from. Default . ### --rc-web-gui-update Set this flag to check and update rclone-webui-react from the rc-web-fetch-url. Default Off. ### --rc-web-gui-force-update Set this flag to force update rclone-webui-react from the rc-web-fetch-url. Default Off. ### --rc-web-gui-no-open-browser Set this flag to disable opening browser automatically when using web-gui. Default Off. ### --rc-job-expire-duration=DURATION Expire finished async jobs older than DURATION (default 60s). ### --rc-job-expire-interval=DURATION Interval duration to check for expired async jobs (default 10s). ### --rc-no-auth By default rclone will require authorisation to have been set up on the rc interface in order to use any methods which access any rclone remotes. Eg `operations/list` is denied as it involved creating a remote as is `sync/copy`. If this is set then no authorisation will be required on the server to use these methods. The alternative is to use `--rc-user` and `--rc-pass` and use these credentials in the request. Default Off. ### --rc-baseurl Prefix for URLs. Default is root ### --rc-template User-specified template. ## Accessing the remote control via the rclone rc command {#api-rc} Rclone itself implements the remote control protocol in its `rclone rc` command. You can use it like this: ```sh $ rclone rc rc/noop param1=one param2=two { "param1": "one", "param2": "two" } ``` If the remote is running on a different URL than the default `http://localhost:5572/`, use the `--url` option to specify it: ```sh rclone rc --url http://some.remote:1234/ rc/noop ``` Or, if the remote is listening on a Unix socket, use the `--unix-socket` option instead: ```sh rclone rc --unix-socket /tmp/rclone.sock rc/noop ``` Run `rclone rc` on its own, without any commands, to see the help for the installed remote control commands. Note that this also needs to connect to the remote server. ## JSON input `rclone rc` also supports a `--json` flag which can be used to send more complicated input parameters. ```sh $ rclone rc --json '{ "p1": [1,"2",null,4], "p2": { "a":1, "b":2 } }' rc/noop { "p1": [ 1, "2", null, 4 ], "p2": { "a": 1, "b": 2 } } ``` If the parameter being passed is an object then it can be passed as a JSON string rather than using the `--json` flag which simplifies the command line. ```sh rclone rc operations/list fs=/tmp remote=test opt='{"showHash": true}' ``` Rather than ```sh rclone rc operations/list --json '{"fs": "/tmp", "remote": "test", "opt": {"showHash": true}}' ``` ## Special parameters The rc interface supports some special parameters which apply to **all** commands. These start with `_` to show they are different. ### Running asynchronous jobs with _async = true Each rc call is classified as a job and it is assigned its own id. By default jobs are executed immediately as they are created or synchronously. If `_async` has a true value when supplied to an rc call then it will return immediately with a job id and the task will be run in the background. The `job/status` call can be used to get information of the background job. The job can be queried for up to 1 minute after it has finished. It is recommended that potentially long running jobs, e.g. `sync/sync`, `sync/copy`, `sync/move`, `operations/purge` are run with the `_async` flag to avoid any potential problems with the HTTP request and response timing out. Starting a job with the `_async` flag: ```sh $ rclone rc --json '{ "p1": [1,"2",null,4], "p2": { "a":1, "b":2 }, "_async": true }' rc/noop { "jobid": 2 } ``` Query the status to see if the job has finished. For more information on the meaning of these return parameters see the `job/status` call. ```sh $ rclone rc --json '{ "jobid":2 }' job/status { "duration": 0.000124163, "endTime": "2018-10-27T11:38:07.911245881+01:00", "error": "", "finished": true, "id": 2, "output": { "_async": true, "p1": [ 1, "2", null, 4 ], "p2": { "a": 1, "b": 2 } }, "startTime": "2018-10-27T11:38:07.911121728+01:00", "success": true } ``` `job/list` can be used to show the running or recently completed jobs ```sh $ rclone rc job/list { "jobids": [ 2 ] } ``` ### Setting config flags with _config If you wish to set config (the equivalent of the global flags) for the duration of an rc call only then pass in the `_config` parameter. This should be in the same format as the `main` key returned by [options/get](#options-get). ```sh rclone rc --loopback options/get blocks=main ``` You can see more help on these options with this command (see [the options blocks section](#option-blocks) for more info). ```sh rclone rc --loopback options/info blocks=main ``` For example, if you wished to run a sync with the `--checksum` parameter, you would pass this parameter in your JSON blob. ```json "_config":{"CheckSum": true} ``` If using `rclone rc` this could be passed as ```sh rclone rc sync/sync ... _config='{"CheckSum": true}' ``` Any config parameters you don't set will inherit the global defaults which were set with command line flags or environment variables. Note that it is possible to set some values as strings or integers - see [data types](#data-types) for more info. Here is an example setting the equivalent of `--buffer-size` in string or integer format. ```json "_config":{"BufferSize": "42M"} "_config":{"BufferSize": 44040192} ``` If you wish to check the `_config` assignment has worked properly then calling `options/local` will show what the value got set to. ### Setting filter flags with _filter If you wish to set filters for the duration of an rc call only then pass in the `_filter` parameter. This should be in the same format as the `filter` key returned by [options/get](#options-get). ```sh rclone rc --loopback options/get blocks=filter ``` You can see more help on these options with this command (see [the options blocks section](#option-blocks) for more info). ```sh rclone rc --loopback options/info blocks=filter ``` For example, if you wished to run a sync with these flags ```sh --max-size 1M --max-age 42s --include "a" --include "b" ``` you would pass this parameter in your JSON blob. ```json "_filter":{"MaxSize":"1M", "IncludeRule":["a","b"], "MaxAge":"42s"} ``` If using `rclone rc` this could be passed as ```sh rclone rc ... _filter='{"MaxSize":"1M", "IncludeRule":["a","b"], "MaxAge":"42s"}' ``` Any filter parameters you don't set will inherit the global defaults which were set with command line flags or environment variables. Note that it is possible to set some values as strings or integers - see [data types](#data-types) for more info. Here is an example setting the equivalent of `--buffer-size` in string or integer format. ```json "_filter":{"MinSize": "42M"} "_filter":{"MinSize": 44040192} ``` If you wish to check the `_filter` assignment has worked properly then calling `options/local` will show what the value got set to. ### Assigning operations to groups with _group = value Each rc call has its own stats group for tracking its metrics. By default grouping is done by the composite group name from prefix `job/` and id of the job like so `job/1`. If `_group` has a value then stats for that request will be grouped under that value. This allows caller to group stats under their own name. Stats for specific group can be accessed by passing `group` to `core/stats`: ```sh $ rclone rc --json '{ "group": "job/1" }' core/stats { "speed": 12345 ... } ``` ## Data types {#data-types} When the API returns types, these will mostly be straight forward integer, string or boolean types. However some of the types returned by the [options/get](#options-get) call and taken by the [options/set](#options-set) calls as well as the `vfsOpt`, `mountOpt` and the `_config` parameters. - `Duration` - these are returned as an integer duration in nanoseconds. They may be set as an integer, or they may be set with time string, eg "5s". See the [options section](https://rclone.org/docs/#options) for more info. - `Size` - these are returned as an integer number of bytes. They may be set as an integer or they may be set with a size suffix string, eg "10M". See the [options section](https://rclone.org/docs/#options) for more info. - Enumerated type (such as `CutoffMode`, `DumpFlags`, `LogLevel`, `VfsCacheMode` - these will be returned as an integer and may be set as an integer but more conveniently they can be set as a string, eg "HARD" for `CutoffMode` or `DEBUG` for `LogLevel`. - `BandwidthSpec` - this will be set and returned as a string, eg "1M". ### Option blocks {#option-blocks} The calls [options/info](#options-info) (for the main config) and [config/providers](#config-providers) (for the backend config) may be used to get information on the rclone configuration options. This can be used to build user interfaces for displaying and setting any rclone option. These consist of arrays of `Option` blocks. These have the following format. Each block describes a single option. | Field | Type | Optional | Description | |-------|------|----------|-------------| | Name | string | N | name of the option in snake_case | | FieldName | string | N | name of the field used in the rc - if blank use Name. May contain "." for nested fields. | | Help | string | N | help, started with a single sentence on a single line | | Groups | string | Y | groups this option belongs to - comma separated string for options classification | | Provider | string | Y | set to filter on provider | | Default | any | N | default value, if set (and not to nil or "") then Required does nothing | | Value | any | N | value to be set by flags | | Examples | Examples | Y | predefined values that can be selected from list (multiple-choice option) | | ShortOpt | string | Y | the short command line option for this | | Hide | Visibility | N | if non zero, this option is hidden from the configurator or the command line | | Required | bool | N | this option is required, meaning value cannot be empty unless there is a default | | IsPassword | bool | N | set if the option is a password | | NoPrefix | bool | N | set if the option for this should not use the backend prefix | | Advanced | bool | N | set if this is an advanced config option | | Exclusive | bool | N | set if the answer can only be one of the examples (empty string allowed unless Required or Default is set) | | Sensitive | bool | N | set if this option should be redacted when using `rclone config redacted` | An example of this might be the `--log-level` flag. Note that the `Name` of the option becomes the command line flag with `_` replaced with `-`. ```json { "Advanced": false, "Default": 5, "DefaultStr": "NOTICE", "Examples": [ { "Help": "", "Value": "EMERGENCY" }, { "Help": "", "Value": "ALERT" }, ... ], "Exclusive": true, "FieldName": "LogLevel", "Groups": "Logging", "Help": "Log level DEBUG|INFO|NOTICE|ERROR", "Hide": 0, "IsPassword": false, "Name": "log_level", "NoPrefix": true, "Required": true, "Sensitive": false, "Type": "LogLevel", "Value": null, "ValueStr": "NOTICE" }, ``` Note that the `Help` may be multiple lines separated by `\n`. The first line will always be a short sentence and this is the sentence shown when running `rclone help flags`. ## Specifying remotes to work on Remotes are specified with the `fs=`, `srcFs=`, `dstFs=` parameters depending on the command being used. The parameters can be a string as per the rest of rclone, eg `s3:bucket/path` or `:sftp:/my/dir`. They can also be specified as JSON blobs. If specifying a JSON blob it should be a object mapping strings to strings. These values will be used to configure the remote. There are 3 special values which may be set: - `type` - set to `type` to specify a remote called `:type:` - `_name` - set to `name` to specify a remote called `name:` - `_root` - sets the root of the remote - may be empty One of `_name` or `type` should normally be set. If the `local` backend is desired then `type` should be set to `local`. If `_root` isn't specified then it defaults to the root of the remote. For example this JSON is equivalent to `remote:/tmp` ```json { "_name": "remote", "_root": "/tmp" } ``` And this is equivalent to `:sftp,host='example.com':/tmp` ```json { "type": "sftp", "host": "example.com", "_root": "/tmp" } ``` And this is equivalent to `/tmp/dir` ```json { "type": "local", "_root": "/tmp/dir" } ``` ## Supported commands ### backend/command: Runs a backend command. {#backend-command} This takes the following parameters: - command - a string with the command name - fs - a remote name string e.g. "drive:" - arg - a list of arguments for the backend command - opt - a map of string to string of options Returns: - result - result from the backend command Example: rclone rc backend/command command=noop fs=. -o echo=yes -o blue -a path1 -a path2 Returns ``` { "result": { "arg": [ "path1", "path2" ], "name": "noop", "opt": { "blue": "", "echo": "yes" } } } ``` Note that this is the direct equivalent of using this "backend" command: rclone backend noop . -o echo=yes -o blue path1 path2 Note that arguments must be preceded by the "-a" flag See the [backend](https://rclone.org/commands/rclone_backend/) command for more information. **Authentication is required for this call.** ### cache/expire: Purge a remote from cache {#cache-expire} Purge a remote from the cache backend. Supports either a directory or a file. Params: - remote = path to remote (required) - withData = true/false to delete cached data (chunks) as well (optional) Eg rclone rc cache/expire remote=path/to/sub/folder/ rclone rc cache/expire remote=/ withData=true ### cache/fetch: Fetch file chunks {#cache-fetch} Ensure the specified file chunks are cached on disk. The chunks= parameter specifies the file chunks to check. It takes a comma separated list of array slice indices. The slice indices are similar to Python slices: start[:end] start is the 0 based chunk number from the beginning of the file to fetch inclusive. end is 0 based chunk number from the beginning of the file to fetch exclusive. Both values can be negative, in which case they count from the back of the file. The value "-5:" represents the last 5 chunks of a file. Some valid examples are: ":5,-5:" -> the first and last five chunks "0,-2" -> the first and the second last chunk "0:10" -> the first ten chunks Any parameter with a key that starts with "file" can be used to specify files to fetch, e.g. rclone rc cache/fetch chunks=0 file=hello file2=home/goodbye File names will automatically be encrypted when the a crypt remote is used on top of the cache. ### cache/stats: Get cache stats {#cache-stats} Show statistics for the cache remote. ### config/create: create the config for a remote. {#config-create} This takes the following parameters: - name - name of remote - parameters - a map of \{ "key": "value" \} pairs - type - type of the new remote - opt - a dictionary of options to control the configuration - obscure - declare passwords are plain and need obscuring - noObscure - declare passwords are already obscured and don't need obscuring - noOutput - don't print anything to stdout - nonInteractive - don't interact with a user, return questions - continue - continue the config process with an answer - all - ask all the config questions not just the post config ones - state - state to restart with - used with continue - result - result to restart with - used with continue See the [config create](https://rclone.org/commands/rclone_config_create/) command for more information on the above. **Authentication is required for this call.** ### config/delete: Delete a remote in the config file. {#config-delete} Parameters: - name - name of remote to delete See the [config delete](https://rclone.org/commands/rclone_config_delete/) command for more information on the above. **Authentication is required for this call.** ### config/dump: Dumps the config file. {#config-dump} Returns a JSON object: - key: value Where keys are remote names and values are the config parameters. See the [config dump](https://rclone.org/commands/rclone_config_dump/) command for more information on the above. **Authentication is required for this call.** ### config/get: Get a remote in the config file. {#config-get} Parameters: - name - name of remote to get See the [config dump](https://rclone.org/commands/rclone_config_dump/) command for more information on the above. **Authentication is required for this call.** ### config/listremotes: Lists the remotes in the config file and defined in environment variables. {#config-listremotes} Returns - remotes - array of remote names See the [listremotes](https://rclone.org/commands/rclone_listremotes/) command for more information on the above. **Authentication is required for this call.** ### config/password: password the config for a remote. {#config-password} This takes the following parameters: - name - name of remote - parameters - a map of \{ "key": "value" \} pairs See the [config password](https://rclone.org/commands/rclone_config_password/) command for more information on the above. **Authentication is required for this call.** ### config/paths: Reads the config file path and other important paths. {#config-paths} Returns a JSON object with the following keys: - config: path to config file - cache: path to root of cache directory - temp: path to root of temporary directory Eg { "cache": "/home/USER/.cache/rclone", "config": "/home/USER/.rclone.conf", "temp": "/tmp" } See the [config paths](https://rclone.org/commands/rclone_config_paths/) command for more information on the above. **Authentication is required for this call.** ### config/providers: Shows how providers are configured in the config file. {#config-providers} Returns a JSON object: - providers - array of objects See the [config providers](https://rclone.org/commands/rclone_config_providers/) command for more information on the above. Note that the Options blocks are in the same format as returned by "options/info". They are described in the [option blocks](#option-blocks) section. **Authentication is required for this call.** ### config/setpath: Set the path of the config file {#config-setpath} Parameters: - path - path to the config file to use **Authentication is required for this call.** ### config/unlock: Unlock the config file. {#config-unlock} Unlocks the config file if it is locked. Parameters: - 'config_password' - password to unlock the config file A good idea is to disable AskPassword before making this call **Authentication is required for this call.** ### config/update: update the config for a remote. {#config-update} This takes the following parameters: - name - name of remote - parameters - a map of \{ "key": "value" \} pairs - opt - a dictionary of options to control the configuration - obscure - declare passwords are plain and need obscuring - noObscure - declare passwords are already obscured and don't need obscuring - noOutput - don't print anything to stdout - nonInteractive - don't interact with a user, return questions - continue - continue the config process with an answer - all - ask all the config questions not just the post config ones - state - state to restart with - used with continue - result - result to restart with - used with continue See the [config update](https://rclone.org/commands/rclone_config_update/) command for more information on the above. **Authentication is required for this call.** ### core/bwlimit: Set the bandwidth limit. {#core-bwlimit} This sets the bandwidth limit to the string passed in. This should be a single bandwidth limit entry or a pair of upload:download bandwidth. Eg rclone rc core/bwlimit rate=off { "bytesPerSecond": -1, "bytesPerSecondTx": -1, "bytesPerSecondRx": -1, "rate": "off" } rclone rc core/bwlimit rate=1M { "bytesPerSecond": 1048576, "bytesPerSecondTx": 1048576, "bytesPerSecondRx": 1048576, "rate": "1M" } rclone rc core/bwlimit rate=1M:100k { "bytesPerSecond": 1048576, "bytesPerSecondTx": 1048576, "bytesPerSecondRx": 131072, "rate": "1M" } If the rate parameter is not supplied then the bandwidth is queried rclone rc core/bwlimit { "bytesPerSecond": 1048576, "bytesPerSecondTx": 1048576, "bytesPerSecondRx": 1048576, "rate": "1M" } The format of the parameter is exactly the same as passed to --bwlimit except only one bandwidth may be specified. In either case "rate" is returned as a human-readable string, and "bytesPerSecond" is returned as a number. ### core/command: Run a rclone terminal command over rc. {#core-command} This takes the following parameters: - command - a string with the command name. - arg - a list of arguments for the backend command. - opt - a map of string to string of options. - returnType - one of ("COMBINED_OUTPUT", "STREAM", "STREAM_ONLY_STDOUT", "STREAM_ONLY_STDERR"). - Defaults to "COMBINED_OUTPUT" if not set. - The STREAM returnTypes will write the output to the body of the HTTP message. - The COMBINED_OUTPUT will write the output to the "result" parameter. Returns: - result - result from the backend command. - Only set when using returnType "COMBINED_OUTPUT". - error - set if rclone exits with an error code. - returnType - one of ("COMBINED_OUTPUT", "STREAM", "STREAM_ONLY_STDOUT", "STREAM_ONLY_STDERR"). Example: rclone rc core/command command=ls -a mydrive:/ -o max-depth=1 rclone rc core/command -a ls -a mydrive:/ -o max-depth=1 Returns: ``` { "error": false, "result": "" } OR { "error": true, "result": "" } ``` **Authentication is required for this call.** ### core/du: Returns disk usage of a locally attached disk. {#core-du} This returns the disk usage for the local directory passed in as dir. If the directory is not passed in, it defaults to the directory pointed to by --cache-dir. - dir - string (optional) Returns: ``` { "dir": "/", "info": { "Available": 361769115648, "Free": 361785892864, "Total": 982141468672 } } ``` ### core/gc: Runs a garbage collection. {#core-gc} This tells the go runtime to do a garbage collection run. It isn't necessary to call this normally, but it can be useful for debugging memory problems. ### core/group-list: Returns list of stats. {#core-group-list} This returns list of stats groups currently in memory. Returns the following values: ``` { "groups": an array of group names: [ "group1", "group2", ... ] } ``` ### core/memstats: Returns the memory statistics {#core-memstats} This returns the memory statistics of the running program. What the values mean are explained in the go docs: https://golang.org/pkg/runtime/#MemStats The most interesting values for most people are: - HeapAlloc - this is the amount of memory rclone is actually using - HeapSys - this is the amount of memory rclone has obtained from the OS - Sys - this is the total amount of memory requested from the OS - It is virtual memory so may include unused memory ### core/obscure: Obscures a string passed in. {#core-obscure} Pass a clear string and rclone will obscure it for the config file: - clear - string Returns: - obscured - string ### core/pid: Return PID of current process {#core-pid} This returns PID of current process. Useful for stopping rclone process. ### core/quit: Terminates the app. {#core-quit} (Optional) Pass an exit code to be used for terminating the app: - exitCode - int ### core/stats: Returns stats about current transfers. {#core-stats} This returns all available stats: rclone rc core/stats If group is not provided then summed up stats for all groups will be returned. Parameters - group - name of the stats group (string, optional) - short - if true will not return the transferring and checking arrays (boolean, optional) Returns the following values: ``` { "bytes": total transferred bytes since the start of the group, "checks": number of files checked, "deletes" : number of files deleted, "elapsedTime": time in floating point seconds since rclone was started, "errors": number of errors, "eta": estimated time in seconds until the group completes, "fatalError": boolean whether there has been at least one fatal error, "lastError": last error string, "renames" : number of files renamed, "listed" : number of directory entries listed, "retryError": boolean showing whether there has been at least one non-NoRetryError, "serverSideCopies": number of server side copies done, "serverSideCopyBytes": number bytes server side copied, "serverSideMoves": number of server side moves done, "serverSideMoveBytes": number bytes server side moved, "speed": average speed in bytes per second since start of the group, "totalBytes": total number of bytes in the group, "totalChecks": total number of checks in the group, "totalTransfers": total number of transfers in the group, "transferTime" : total time spent on running jobs, "transfers": number of transferred files, "transferring": an array of currently active file transfers: [ { "bytes": total transferred bytes for this file, "eta": estimated time in seconds until file transfer completion "name": name of the file, "percentage": progress of the file transfer in percent, "speed": average speed over the whole transfer in bytes per second, "speedAvg": current speed in bytes per second as an exponentially weighted moving average, "size": size of the file in bytes } ], "checking": an array of names of currently active file checks [] } ``` Values for "transferring", "checking" and "lastError" are only assigned if data is available. The value for "eta" is null if an eta cannot be determined. ### core/stats-delete: Delete stats group. {#core-stats-delete} This deletes entire stats group. Parameters - group - name of the stats group (string) ### core/stats-reset: Reset stats. {#core-stats-reset} This clears counters, errors and finished transfers for all stats or specific stats group if group is provided. Parameters - group - name of the stats group (string) ### core/transferred: Returns stats about completed transfers. {#core-transferred} This returns stats about completed transfers: rclone rc core/transferred If group is not provided then completed transfers for all groups will be returned. Note only the last 100 completed transfers are returned. Parameters - group - name of the stats group (string) Returns the following values: ``` { "transferred": an array of completed transfers (including failed ones): [ { "name": name of the file, "size": size of the file in bytes, "bytes": total transferred bytes for this file, "checked": if the transfer is only checked (skipped, deleted), "what": the purpose of the transfer (transferring, deleting, checking, importing, hashing, merging, listing, moving, renaming), "timestamp": integer representing millisecond unix epoch, "error": string description of the error (empty if successful), "jobid": id of the job that this transfer belongs to } ] } ``` ### core/version: Shows the current version of rclone and the go runtime. {#core-version} This shows the current version of go and the go runtime: - version - rclone version, e.g. "v1.53.0" - decomposed - version number as [major, minor, patch] - isGit - boolean - true if this was compiled from the git version - isBeta - boolean - true if this is a beta version - os - OS in use as according to Go - arch - cpu architecture in use according to Go - goVersion - version of Go runtime in use - linking - type of rclone executable (static or dynamic) - goTags - space separated build tags or "none" ### debug/set-block-profile-rate: Set runtime.SetBlockProfileRate for blocking profiling. {#debug-set-block-profile-rate} SetBlockProfileRate controls the fraction of goroutine blocking events that are reported in the blocking profile. The profiler aims to sample an average of one blocking event per rate nanoseconds spent blocked. To include every blocking event in the profile, pass rate = 1. To turn off profiling entirely, pass rate <= 0. After calling this you can use this to see the blocking profile: go tool pprof http://localhost:5572/debug/pprof/block Parameters: - rate - int ### debug/set-gc-percent: Call runtime/debug.SetGCPercent for setting the garbage collection target percentage. {#debug-set-gc-percent} SetGCPercent sets the garbage collection target percentage: a collection is triggered when the ratio of freshly allocated data to live data remaining after the previous collection reaches this percentage. SetGCPercent returns the previous setting. The initial setting is the value of the GOGC environment variable at startup, or 100 if the variable is not set. This setting may be effectively reduced in order to maintain a memory limit. A negative percentage effectively disables garbage collection, unless the memory limit is reached. See https://pkg.go.dev/runtime/debug#SetMemoryLimit for more details. Parameters: - gc-percent - int ### debug/set-mutex-profile-fraction: Set runtime.SetMutexProfileFraction for mutex profiling. {#debug-set-mutex-profile-fraction} SetMutexProfileFraction controls the fraction of mutex contention events that are reported in the mutex profile. On average 1/rate events are reported. The previous rate is returned. To turn off profiling entirely, pass rate 0. To just read the current rate, pass rate < 0. (For n>1 the details of sampling may change.) Once this is set you can look use this to profile the mutex contention: go tool pprof http://localhost:5572/debug/pprof/mutex Parameters: - rate - int Results: - previousRate - int ### debug/set-soft-memory-limit: Call runtime/debug.SetMemoryLimit for setting a soft memory limit for the runtime. {#debug-set-soft-memory-limit} SetMemoryLimit provides the runtime with a soft memory limit. The runtime undertakes several processes to try to respect this memory limit, including adjustments to the frequency of garbage collections and returning memory to the underlying system more aggressively. This limit will be respected even if GOGC=off (or, if SetGCPercent(-1) is executed). The input limit is provided as bytes, and includes all memory mapped, managed, and not released by the Go runtime. Notably, it does not account for space used by the Go binary and memory external to Go, such as memory managed by the underlying system on behalf of the process, or memory managed by non-Go code inside the same process. Examples of excluded memory sources include: OS kernel memory held on behalf of the process, memory allocated by C code, and memory mapped by syscall.Mmap (because it is not managed by the Go runtime). A zero limit or a limit that's lower than the amount of memory used by the Go runtime may cause the garbage collector to run nearly continuously. However, the application may still make progress. The memory limit is always respected by the Go runtime, so to effectively disable this behavior, set the limit very high. math.MaxInt64 is the canonical value for disabling the limit, but values much greater than the available memory on the underlying system work just as well. See https://go.dev/doc/gc-guide for a detailed guide explaining the soft memory limit in more detail, as well as a variety of common use-cases and scenarios. SetMemoryLimit returns the previously set memory limit. A negative input does not adjust the limit, and allows for retrieval of the currently set memory limit. Parameters: - mem-limit - int ### fscache/clear: Clear the Fs cache. {#fscache-clear} This clears the fs cache. This is where remotes created from backends are cached for a short while to make repeated rc calls more efficient. If you change the parameters of a backend then you may want to call this to clear an existing remote out of the cache before re-creating it. **Authentication is required for this call.** ### fscache/entries: Returns the number of entries in the fs cache. {#fscache-entries} This returns the number of entries in the fs cache. Returns - entries - number of items in the cache **Authentication is required for this call.** ### job/list: Lists the IDs of the running jobs {#job-list} Parameters: None. Results: - executeId - string id of rclone executing (change after restart) - jobids - array of integer job ids (starting at 1 on each restart) ### job/status: Reads the status of the job ID {#job-status} Parameters: - jobid - id of the job (integer). Results: - finished - boolean - duration - time in seconds that the job ran for - endTime - time the job finished (e.g. "2018-10-26T18:50:20.528746884+01:00") - error - error from the job or empty string for no error - finished - boolean whether the job has finished or not - id - as passed in above - startTime - time the job started (e.g. "2018-10-26T18:50:20.528336039+01:00") - success - boolean - true for success false otherwise - output - output of the job as would have been returned if called synchronously - progress - output of the progress related to the underlying job ### job/stop: Stop the running job {#job-stop} Parameters: - jobid - id of the job (integer). ### job/stopgroup: Stop all running jobs in a group {#job-stopgroup} Parameters: - group - name of the group (string). ### mount/listmounts: Show current mount points {#mount-listmounts} This shows currently mounted points, which can be used for performing an unmount. This takes no parameters and returns - mountPoints: list of current mount points Eg rclone rc mount/listmounts **Authentication is required for this call.** ### mount/mount: Create a new mount point {#mount-mount} rclone allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE. If no mountType is provided, the priority is given as follows: 1. mount 2.cmount 3.mount2 This takes the following parameters: - fs - a remote path to be mounted (required) - mountPoint: valid path on the local machine (required) - mountType: one of the values (mount, cmount, mount2) specifies the mount implementation to use - mountOpt: a JSON object with Mount options in. - vfsOpt: a JSON object with VFS options in. Example: rclone rc mount/mount fs=mydrive: mountPoint=/home//mountPoint rclone rc mount/mount fs=mydrive: mountPoint=/home//mountPoint mountType=mount rclone rc mount/mount fs=TestDrive: mountPoint=/mnt/tmp vfsOpt='{"CacheMode": 2}' mountOpt='{"AllowOther": true}' The vfsOpt are as described in options/get and can be seen in the the "vfs" section when running and the mountOpt can be seen in the "mount" section: rclone rc options/get **Authentication is required for this call.** ### mount/types: Show all possible mount types {#mount-types} This shows all possible mount types and returns them as a list. This takes no parameters and returns - mountTypes: list of mount types The mount types are strings like "mount", "mount2", "cmount" and can be passed to mount/mount as the mountType parameter. Eg rclone rc mount/types **Authentication is required for this call.** ### mount/unmount: Unmount selected active mount {#mount-unmount} rclone allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE. This takes the following parameters: - mountPoint: valid path on the local machine where the mount was created (required) Example: rclone rc mount/unmount mountPoint=/home//mountPoint **Authentication is required for this call.** ### mount/unmountall: Unmount all active mounts {#mount-unmountall} rclone allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE. This takes no parameters and returns error if unmount does not succeed. Eg rclone rc mount/unmountall **Authentication is required for this call.** ### operations/about: Return the space used on the remote {#operations-about} This takes the following parameters: - fs - a remote name string e.g. "drive:" The result is as returned from rclone about --json See the [about](https://rclone.org/commands/rclone_about/) command for more information on the above. **Authentication is required for this call.** ### operations/check: check the source and destination are the same {#operations-check} Checks the files in the source and destination match. It compares sizes and hashes and logs a report of files that don't match. It doesn't alter the source or destination. This takes the following parameters: - srcFs - a remote name string e.g. "drive:" for the source, "/" for local filesystem - dstFs - a remote name string e.g. "drive2:" for the destination, "/" for local filesystem - download - check by downloading rather than with hash - checkFileHash - treat checkFileFs:checkFileRemote as a SUM file with hashes of given type - checkFileFs - treat checkFileFs:checkFileRemote as a SUM file with hashes of given type - checkFileRemote - treat checkFileFs:checkFileRemote as a SUM file with hashes of given type - oneWay - check one way only, source files must exist on remote - combined - make a combined report of changes (default false) - missingOnSrc - report all files missing from the source (default true) - missingOnDst - report all files missing from the destination (default true) - match - report all matching files (default false) - differ - report all non-matching files (default true) - error - report all files with errors (hashing or reading) (default true) If you supply the download flag, it will download the data from both remotes and check them against each other on the fly. This can be useful for remotes that don't support hashes or if you really want to check all the data. If you supply the size-only global flag, it will only compare the sizes not the hashes as well. Use this for a quick check. If you supply the checkFileHash option with a valid hash name, the checkFileFs:checkFileRemote must point to a text file in the SUM format. This treats the checksum file as the source and dstFs as the destination. Note that srcFs is not used and should not be supplied in this case. Returns: - success - true if no error, false otherwise - status - textual summary of check, OK or text string - hashType - hash used in check, may be missing - combined - array of strings of combined report of changes - missingOnSrc - array of strings of all files missing from the source - missingOnDst - array of strings of all files missing from the destination - match - array of strings of all matching files - differ - array of strings of all non-matching files - error - array of strings of all files with errors (hashing or reading) **Authentication is required for this call.** ### operations/cleanup: Remove trashed files in the remote or path {#operations-cleanup} This takes the following parameters: - fs - a remote name string e.g. "drive:" See the [cleanup](https://rclone.org/commands/rclone_cleanup/) command for more information on the above. **Authentication is required for this call.** ### operations/copyfile: Copy a file from source remote to destination remote {#operations-copyfile} This takes the following parameters: - srcFs - a remote name string e.g. "drive:" for the source, "/" for local filesystem - srcRemote - a path within that remote e.g. "file.txt" for the source - dstFs - a remote name string e.g. "drive2:" for the destination, "/" for local filesystem - dstRemote - a path within that remote e.g. "file2.txt" for the destination **Authentication is required for this call.** ### operations/copyurl: Copy the URL to the object {#operations-copyurl} This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" - url - string, URL to read from - autoFilename - boolean, set to true to retrieve destination file name from url See the [copyurl](https://rclone.org/commands/rclone_copyurl/) command for more information on the above. **Authentication is required for this call.** ### operations/delete: Remove files in the path {#operations-delete} This takes the following parameters: - fs - a remote name string e.g. "drive:" See the [delete](https://rclone.org/commands/rclone_delete/) command for more information on the above. **Authentication is required for this call.** ### operations/deletefile: Remove the single file pointed to {#operations-deletefile} This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" See the [deletefile](https://rclone.org/commands/rclone_deletefile/) command for more information on the above. **Authentication is required for this call.** ### operations/fsinfo: Return information about the remote {#operations-fsinfo} This takes the following parameters: - fs - a remote name string e.g. "drive:" This returns info about the remote passed in; ``` { // optional features and whether they are available or not "Features": { "About": true, "BucketBased": false, "BucketBasedRootOK": false, "CanHaveEmptyDirectories": true, "CaseInsensitive": false, "ChangeNotify": false, "CleanUp": false, "Command": true, "Copy": false, "DirCacheFlush": false, "DirMove": true, "Disconnect": false, "DuplicateFiles": false, "GetTier": false, "IsLocal": true, "ListR": false, "MergeDirs": false, "MetadataInfo": true, "Move": true, "OpenWriterAt": true, "PublicLink": false, "Purge": true, "PutStream": true, "PutUnchecked": false, "ReadMetadata": true, "ReadMimeType": false, "ServerSideAcrossConfigs": false, "SetTier": false, "SetWrapper": false, "Shutdown": false, "SlowHash": true, "SlowModTime": false, "UnWrap": false, "UserInfo": false, "UserMetadata": true, "WrapFs": false, "WriteMetadata": true, "WriteMimeType": false }, // Names of hashes available "Hashes": [ "md5", "sha1", "whirlpool", "crc32", "sha256", "dropbox", "mailru", "quickxor" ], "Name": "local", // Name as created "Precision": 1, // Precision of timestamps in ns "Root": "/", // Path as created "String": "Local file system at /", // how the remote will appear in logs // Information about the system metadata for this backend "MetadataInfo": { "System": { "atime": { "Help": "Time of last access", "Type": "RFC 3339", "Example": "2006-01-02T15:04:05.999999999Z07:00" }, "btime": { "Help": "Time of file birth (creation)", "Type": "RFC 3339", "Example": "2006-01-02T15:04:05.999999999Z07:00" }, "gid": { "Help": "Group ID of owner", "Type": "decimal number", "Example": "500" }, "mode": { "Help": "File type and mode", "Type": "octal, unix style", "Example": "0100664" }, "mtime": { "Help": "Time of last modification", "Type": "RFC 3339", "Example": "2006-01-02T15:04:05.999999999Z07:00" }, "rdev": { "Help": "Device ID (if special file)", "Type": "hexadecimal", "Example": "1abc" }, "uid": { "Help": "User ID of owner", "Type": "decimal number", "Example": "500" } }, "Help": "Textual help string\n" } } ``` This command does not have a command line equivalent so use this instead: rclone rc --loopback operations/fsinfo fs=remote: ### operations/hashsum: Produces a hashsum file for all the objects in the path. {#operations-hashsum} Produces a hash file for all the objects in the path using the hash named. The output is in the same format as the standard md5sum/sha1sum tool. This takes the following parameters: - fs - a remote name string e.g. "drive:" for the source, "/" for local filesystem - this can point to a file and just that file will be returned in the listing. - hashType - type of hash to be used - download - check by downloading rather than with hash (boolean) - base64 - output the hashes in base64 rather than hex (boolean) If you supply the download flag, it will download the data from the remote and create the hash on the fly. This can be useful for remotes that don't support the given hash or if you really want to check all the data. Note that if you wish to supply a checkfile to check hashes against the current files then you should use operations/check instead of operations/hashsum. Returns: - hashsum - array of strings of the hashes - hashType - type of hash used Example: $ rclone rc --loopback operations/hashsum fs=bin hashType=MD5 download=true base64=true { "hashType": "md5", "hashsum": [ "WTSVLpuiXyJO_kGzJerRLg== backend-versions.sh", "v1b_OlWCJO9LtNq3EIKkNQ== bisect-go-rclone.sh", "VHbmHzHh4taXzgag8BAIKQ== bisect-rclone.sh", ] } See the [hashsum](https://rclone.org/commands/rclone_hashsum/) command for more information on the above. **Authentication is required for this call.** ### operations/list: List the given remote and path in JSON format {#operations-list} This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" - opt - a dictionary of options to control the listing (optional) - recurse - If set recurse directories - noModTime - If set return modification time - showEncrypted - If set show decrypted names - showOrigIDs - If set show the IDs for each item if known - showHash - If set return a dictionary of hashes - noMimeType - If set don't show mime types - dirsOnly - If set only show directories - filesOnly - If set only show files - metadata - If set return metadata of objects also - hashTypes - array of strings of hash types to show if showHash set Returns: - list - This is an array of objects as described in the lsjson command See the [lsjson](https://rclone.org/commands/rclone_lsjson/) command for more information on the above and examples. **Authentication is required for this call.** ### operations/mkdir: Make a destination directory or container {#operations-mkdir} This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" See the [mkdir](https://rclone.org/commands/rclone_mkdir/) command for more information on the above. **Authentication is required for this call.** ### operations/movefile: Move a file from source remote to destination remote {#operations-movefile} This takes the following parameters: - srcFs - a remote name string e.g. "drive:" for the source, "/" for local filesystem - srcRemote - a path within that remote e.g. "file.txt" for the source - dstFs - a remote name string e.g. "drive2:" for the destination, "/" for local filesystem - dstRemote - a path within that remote e.g. "file2.txt" for the destination **Authentication is required for this call.** ### operations/publiclink: Create or retrieve a public link to the given file or folder. {#operations-publiclink} This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" - unlink - boolean - if set removes the link rather than adding it (optional) - expire - string - the expiry time of the link e.g. "1d" (optional) Returns: - url - URL of the resource See the [link](https://rclone.org/commands/rclone_link/) command for more information on the above. **Authentication is required for this call.** ### operations/purge: Remove a directory or container and all of its contents {#operations-purge} This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" See the [purge](https://rclone.org/commands/rclone_purge/) command for more information on the above. **Authentication is required for this call.** ### operations/rmdir: Remove an empty directory or container {#operations-rmdir} This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" See the [rmdir](https://rclone.org/commands/rclone_rmdir/) command for more information on the above. **Authentication is required for this call.** ### operations/rmdirs: Remove all the empty directories in the path {#operations-rmdirs} This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" - leaveRoot - boolean, set to true not to delete the root See the [rmdirs](https://rclone.org/commands/rclone_rmdirs/) command for more information on the above. **Authentication is required for this call.** ### operations/settier: Changes storage tier or class on all files in the path {#operations-settier} This takes the following parameters: - fs - a remote name string e.g. "drive:" See the [settier](https://rclone.org/commands/rclone_settier/) command for more information on the above. **Authentication is required for this call.** ### operations/settierfile: Changes storage tier or class on the single file pointed to {#operations-settierfile} This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" See the [settierfile](https://rclone.org/commands/rclone_settierfile/) command for more information on the above. **Authentication is required for this call.** ### operations/size: Count the number of bytes and files in remote {#operations-size} This takes the following parameters: - fs - a remote name string e.g. "drive:path/to/dir" Returns: - count - number of files - bytes - number of bytes in those files See the [size](https://rclone.org/commands/rclone_size/) command for more information on the above. **Authentication is required for this call.** ### operations/stat: Give information about the supplied file or directory {#operations-stat} This takes the following parameters - fs - a remote name string eg "drive:" - remote - a path within that remote eg "dir" - opt - a dictionary of options to control the listing (optional) - see operations/list for the options The result is - item - an object as described in the lsjson command. Will be null if not found. Note that if you are only interested in files then it is much more efficient to set the filesOnly flag in the options. See the [lsjson](https://rclone.org/commands/rclone_lsjson/) command for more information on the above and examples. **Authentication is required for this call.** ### operations/uploadfile: Upload file using multiform/form-data {#operations-uploadfile} This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" - each part in body represents a file to be uploaded See the [uploadfile](https://rclone.org/commands/rclone_uploadfile/) command for more information on the above. **Authentication is required for this call.** ### options/blocks: List all the option blocks {#options-blocks} Returns: - options - a list of the options block names ### options/get: Get all the global options {#options-get} Returns an object where keys are option block names and values are an object with the current option values in. Parameters: - blocks: optional string of comma separated blocks to include - all are included if this is missing or "" Note that these are the global options which are unaffected by use of the _config and _filter parameters. If you wish to read the parameters set in _config or _filter use options/local. This shows the internal names of the option within rclone which should map to the external options very easily with a few exceptions. ### options/info: Get info about all the global options {#options-info} Returns an object where keys are option block names and values are an array of objects with info about each options. Parameters: - blocks: optional string of comma separated blocks to include - all are included if this is missing or "" These objects are in the same format as returned by "config/providers". They are described in the [option blocks](#option-blocks) section. ### options/local: Get the currently active config for this call {#options-local} Returns an object with the keys "config" and "filter". The "config" key contains the local config and the "filter" key contains the local filters. Note that these are the local options specific to this rc call. If _config was not supplied then they will be the global options. Likewise with "_filter". This call is mostly useful for seeing if _config and _filter passing is working. This shows the internal names of the option within rclone which should map to the external options very easily with a few exceptions. ### options/set: Set an option {#options-set} Parameters: - option block name containing an object with - key: value Repeated as often as required. Only supply the options you wish to change. If an option is unknown it will be silently ignored. Not all options will have an effect when changed like this. For example: This sets DEBUG level logs (-vv) (these can be set by number or string) rclone rc options/set --json '{"main": {"LogLevel": "DEBUG"}}' rclone rc options/set --json '{"main": {"LogLevel": 8}}' And this sets INFO level logs (-v) rclone rc options/set --json '{"main": {"LogLevel": "INFO"}}' And this sets NOTICE level logs (normal without -v) rclone rc options/set --json '{"main": {"LogLevel": "NOTICE"}}' ### pluginsctl/addPlugin: Add a plugin using url {#pluginsctl-addPlugin} Used for adding a plugin to the webgui. This takes the following parameters: - url - http url of the github repo where the plugin is hosted (http://github.com/rclone/rclone-webui-react). Example: rclone rc pluginsctl/addPlugin **Authentication is required for this call.** ### pluginsctl/getPluginsForType: Get plugins with type criteria {#pluginsctl-getPluginsForType} This shows all possible plugins by a mime type. This takes the following parameters: - type - supported mime type by a loaded plugin e.g. (video/mp4, audio/mp3). - pluginType - filter plugins based on their type e.g. (DASHBOARD, FILE_HANDLER, TERMINAL). Returns: - loadedPlugins - list of current production plugins. - testPlugins - list of temporarily loaded development plugins, usually running on a different server. Example: rclone rc pluginsctl/getPluginsForType type=video/mp4 **Authentication is required for this call.** ### pluginsctl/listPlugins: Get the list of currently loaded plugins {#pluginsctl-listPlugins} This allows you to get the currently enabled plugins and their details. This takes no parameters and returns: - loadedPlugins - list of current production plugins. - testPlugins - list of temporarily loaded development plugins, usually running on a different server. E.g. rclone rc pluginsctl/listPlugins **Authentication is required for this call.** ### pluginsctl/listTestPlugins: Show currently loaded test plugins {#pluginsctl-listTestPlugins} Allows listing of test plugins with the rclone.test set to true in package.json of the plugin. This takes no parameters and returns: - loadedTestPlugins - list of currently available test plugins. E.g. rclone rc pluginsctl/listTestPlugins **Authentication is required for this call.** ### pluginsctl/removePlugin: Remove a loaded plugin {#pluginsctl-removePlugin} This allows you to remove a plugin using it's name. This takes parameters: - name - name of the plugin in the format `author`/`plugin_name`. E.g. rclone rc pluginsctl/removePlugin name=rclone/video-plugin **Authentication is required for this call.** ### pluginsctl/removeTestPlugin: Remove a test plugin {#pluginsctl-removeTestPlugin} This allows you to remove a plugin using it's name. This takes the following parameters: - name - name of the plugin in the format `author`/`plugin_name`. Example: rclone rc pluginsctl/removeTestPlugin name=rclone/rclone-webui-react **Authentication is required for this call.** ### rc/error: This returns an error {#rc-error} This returns an error with the input as part of its error string. Useful for testing error handling. ### rc/list: List all the registered remote control commands {#rc-list} This lists all the registered remote control commands as a JSON map in the commands response. ### rc/noop: Echo the input to the output parameters {#rc-noop} This echoes the input parameters to the output parameters for testing purposes. It can be used to check that rclone is still alive and to check that parameter passing is working properly. ### rc/noopauth: Echo the input to the output parameters requiring auth {#rc-noopauth} This echoes the input parameters to the output parameters for testing purposes. It can be used to check that rclone is still alive and to check that parameter passing is working properly. **Authentication is required for this call.** ### serve/list: Show running servers {#serve-list} Show running servers with IDs. This takes no parameters and returns - list: list of running serve commands Each list element will have - id: ID of the server - addr: address the server is running on - params: parameters used to start the server Eg rclone rc serve/list Returns ```json { "list": [ { "addr": "[::]:4321", "id": "nfs-ffc2a4e5", "params": { "fs": "remote:", "opt": { "ListenAddr": ":4321" }, "type": "nfs", "vfsOpt": { "CacheMode": "full" } } } ] } ``` **Authentication is required for this call.** ### serve/start: Create a new server {#serve-start} Create a new server with the specified parameters. This takes the following parameters: - `type` - type of server: `http`, `webdav`, `ftp`, `sftp`, `nfs`, etc. - `fs` - remote storage path to serve - `addr` - the ip:port to run the server on, eg ":1234" or "localhost:1234" Other parameters are as described in the documentation for the relevant [rclone serve](https://rclone.org/commands/rclone_serve/) command line options. To translate a command line option to an rc parameter, remove the leading `--` and replace `-` with `_`, so `--vfs-cache-mode` becomes `vfs_cache_mode`. Note that global parameters must be set with `_config` and `_filter` as described above. Examples: rclone rc serve/start type=nfs fs=remote: addr=:4321 vfs_cache_mode=full rclone rc serve/start --json '{"type":"nfs","fs":"remote:","addr":":1234","vfs_cache_mode":"full"}' This will give the reply ```json { "addr": "[::]:4321", // Address the server was started on "id": "nfs-ecfc6852" // Unique identifier for the server instance } ``` Or an error if it failed to start. Stop the server with `serve/stop` and list the running servers with `serve/list`. **Authentication is required for this call.** ### serve/stop: Unserve selected active serve {#serve-stop} Stops a running `serve` instance by ID. This takes the following parameters: - id: as returned by serve/start This will give an empty response if successful or an error if not. Example: rclone rc serve/stop id=12345 **Authentication is required for this call.** ### serve/stopall: Stop all active servers {#serve-stopall} Stop all active servers. This will stop all active servers. rclone rc serve/stopall **Authentication is required for this call.** ### serve/types: Show all possible serve types {#serve-types} This shows all possible serve types and returns them as a list. This takes no parameters and returns - types: list of serve types, eg "nfs", "sftp", etc The serve types are strings like "serve", "serve2", "cserve" and can be passed to serve/start as the serveType parameter. Eg rclone rc serve/types Returns ```json { "types": [ "http", "sftp", "nfs" ] } ``` **Authentication is required for this call.** ### sync/bisync: Perform bidirectional synchronization between two paths. {#sync-bisync} This takes the following parameters - path1 - a remote directory string e.g. `drive:path1` - path2 - a remote directory string e.g. `drive:path2` - dryRun - dry-run mode - resync - performs the resync run - checkAccess - abort if RCLONE_TEST files are not found on both filesystems - checkFilename - file name for checkAccess (default: RCLONE_TEST) - maxDelete - abort sync if percentage of deleted files is above this threshold (default: 50) - force - Bypass maxDelete safety check and run the sync - checkSync - `true` by default, `false` disables comparison of final listings, `only` will skip sync, only compare listings from the last run - createEmptySrcDirs - Sync creation and deletion of empty directories. (Not compatible with --remove-empty-dirs) - removeEmptyDirs - remove empty directories at the final cleanup step - filtersFile - read filtering patterns from a file - ignoreListingChecksum - Do not use checksums for listings - resilient - Allow future runs to retry after certain less-serious errors, instead of requiring resync. - workdir - server directory for history files (default: `~/.cache/rclone/bisync`) - backupdir1 - --backup-dir for Path1. Must be a non-overlapping path on the same remote. - backupdir2 - --backup-dir for Path2. Must be a non-overlapping path on the same remote. - noCleanup - retain working files See [bisync command help](https://rclone.org/commands/rclone_bisync/) and [full bisync description](https://rclone.org/bisync/) for more information. **Authentication is required for this call.** ### sync/copy: copy a directory from source remote to destination remote {#sync-copy} This takes the following parameters: - srcFs - a remote name string e.g. "drive:src" for the source - dstFs - a remote name string e.g. "drive:dst" for the destination - createEmptySrcDirs - create empty src directories on destination if set See the [copy](https://rclone.org/commands/rclone_copy/) command for more information on the above. **Authentication is required for this call.** ### sync/move: move a directory from source remote to destination remote {#sync-move} This takes the following parameters: - srcFs - a remote name string e.g. "drive:src" for the source - dstFs - a remote name string e.g. "drive:dst" for the destination - createEmptySrcDirs - create empty src directories on destination if set - deleteEmptySrcDirs - delete empty src directories if set See the [move](https://rclone.org/commands/rclone_move/) command for more information on the above. **Authentication is required for this call.** ### sync/sync: sync a directory from source remote to destination remote {#sync-sync} This takes the following parameters: - srcFs - a remote name string e.g. "drive:src" for the source - dstFs - a remote name string e.g. "drive:dst" for the destination - createEmptySrcDirs - create empty src directories on destination if set See the [sync](https://rclone.org/commands/rclone_sync/) command for more information on the above. **Authentication is required for this call.** ### vfs/forget: Forget files or directories in the directory cache. {#vfs-forget} This forgets the paths in the directory cache causing them to be re-read from the remote when needed. If no paths are passed in then it will forget all the paths in the directory cache. rclone rc vfs/forget Otherwise pass files or dirs in as file=path or dir=path. Any parameter key starting with file will forget that file and any starting with dir will forget that dir, e.g. rclone rc vfs/forget file=hello file2=goodbye dir=home/junk This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied. ### vfs/list: List active VFSes. {#vfs-list} This lists the active VFSes. It returns a list under the key "vfses" where the values are the VFS names that could be passed to the other VFS commands in the "fs" parameter. ### vfs/poll-interval: Get the status or update the value of the poll-interval option. {#vfs-poll-interval} Without any parameter given this returns the current status of the poll-interval setting. When the interval=duration parameter is set, the poll-interval value is updated and the polling function is notified. Setting interval=0 disables poll-interval. rclone rc vfs/poll-interval interval=5m The timeout=duration parameter can be used to specify a time to wait for the current poll function to apply the new value. If timeout is less or equal 0, which is the default, wait indefinitely. The new poll-interval value will only be active when the timeout is not reached. If poll-interval is updated or disabled temporarily, some changes might not get picked up by the polling function, depending on the used remote. This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied. ### vfs/queue: Queue info for a VFS. {#vfs-queue} This returns info about the upload queue for the selected VFS. This is only useful if `--vfs-cache-mode` > off. If you call it when the `--vfs-cache-mode` is off, it will return an empty result. { "queued": // an array of files queued for upload [ { "name": "file", // string: name (full path) of the file, "id": 123, // integer: id of this item in the queue, "size": 79, // integer: size of the file in bytes "expiry": 1.5 // float: time until file is eligible for transfer, lowest goes first "tries": 1, // integer: number of times we have tried to upload "delay": 5.0, // float: seconds between upload attempts "uploading": false, // boolean: true if item is being uploaded }, ], } The `expiry` time is the time until the file is eligible for being uploaded in floating point seconds. This may go negative. As rclone only transfers `--transfers` files at once, only the lowest `--transfers` expiry times will have `uploading` as `true`. So there may be files with negative expiry times for which `uploading` is `false`. This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied. ### vfs/queue-set-expiry: Set the expiry time for an item queued for upload. {#vfs-queue-set-expiry} Use this to adjust the `expiry` time for an item in the upload queue. You will need to read the `id` of the item using `vfs/queue` before using this call. You can then set `expiry` to a floating point number of seconds from now when the item is eligible for upload. If you want the item to be uploaded as soon as possible then set it to a large negative number (eg -1000000000). If you want the upload of the item to be delayed for a long time then set it to a large positive number. Setting the `expiry` of an item which has already has started uploading will have no effect - the item will carry on being uploaded. This will return an error if called with `--vfs-cache-mode` off or if the `id` passed is not found. This takes the following parameters - `fs` - select the VFS in use (optional) - `id` - a numeric ID as returned from `vfs/queue` - `expiry` - a new expiry time as floating point seconds - `relative` - if set, expiry is to be treated as relative to the current expiry (optional, boolean) This returns an empty result on success, or an error. This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied. ### vfs/refresh: Refresh the directory cache. {#vfs-refresh} This reads the directories for the specified paths and freshens the directory cache. If no paths are passed in then it will refresh the root directory. rclone rc vfs/refresh Otherwise pass directories in as dir=path. Any parameter key starting with dir will refresh that directory, e.g. rclone rc vfs/refresh dir=home/junk dir2=data/misc If the parameter recursive=true is given the whole directory tree will get refreshed. This refresh will use --fast-list if enabled. This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied. ### vfs/stats: Stats for a VFS. {#vfs-stats} This returns stats for the selected VFS. { // Status of the disk cache - only present if --vfs-cache-mode > off "diskCache": { "bytesUsed": 0, "erroredFiles": 0, "files": 0, "hashType": 1, "outOfSpace": false, "path": "/home/user/.cache/rclone/vfs/local/mnt/a", "pathMeta": "/home/user/.cache/rclone/vfsMeta/local/mnt/a", "uploadsInProgress": 0, "uploadsQueued": 0 }, "fs": "/mnt/a", "inUse": 1, // Status of the in memory metadata cache "metadataCache": { "dirs": 1, "files": 0 }, // Options as returned by options/get "opt": { "CacheMaxAge": 3600000000000, // ... "WriteWait": 1000000000 } } This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied. ## Accessing the remote control via HTTP {#api-http} Rclone implements a simple HTTP based protocol. Each endpoint takes an JSON object and returns a JSON object or an error. The JSON objects are essentially a map of string names to values. All calls must made using POST. The input objects can be supplied using URL parameters, POST parameters or by supplying "Content-Type: application/json" and a JSON blob in the body. There are examples of these below using `curl`. The response will be a JSON blob in the body of the response. This is formatted to be reasonably human-readable. ### Error returns If an error occurs then there will be an HTTP error status (e.g. 500) and the body of the response will contain a JSON encoded error object, e.g. ```json { "error": "Expecting string value for key \"remote\" (was float64)", "input": { "fs": "/tmp", "remote": 3 }, "status": 400, "path": "operations/rmdir" } ``` The keys in the error response are: - error - error string - input - the input parameters to the call - status - the HTTP status code - path - the path of the call ### CORS The sever implements basic CORS support and allows all origins for that. The response to a preflight OPTIONS request will echo the requested "Access-Control-Request-Headers" back. ### Using POST with URL parameters only ```sh curl -X POST 'http://localhost:5572/rc/noop?potato=1&sausage=2' ``` Response ```json { "potato": "1", "sausage": "2" } ``` Here is what an error response looks like: ```sh curl -X POST 'http://localhost:5572/rc/error?potato=1&sausage=2' ``` ```json { "error": "arbitrary error on input map[potato:1 sausage:2]", "input": { "potato": "1", "sausage": "2" } } ``` Note that curl doesn't return errors to the shell unless you use the `-f` option ```sh $ curl -f -X POST 'http://localhost:5572/rc/error?potato=1&sausage=2' curl: (22) The requested URL returned error: 400 Bad Request $ echo $? 22 ``` ### Using POST with a form ```sh curl --data "potato=1" --data "sausage=2" http://localhost:5572/rc/noop ``` Response ```json { "potato": "1", "sausage": "2" } ``` Note that you can combine these with URL parameters too with the POST parameters taking precedence. ```sh curl --data "potato=1" --data "sausage=2" "http://localhost:5572/rc/noop?rutabaga=3&sausage=4" ``` Response ```json { "potato": "1", "rutabaga": "3", "sausage": "4" } ``` ### Using POST with a JSON blob ```sh curl -H "Content-Type: application/json" -X POST -d '{"potato":2,"sausage":1}' http://localhost:5572/rc/noop ``` response ```json { "password": "xyz", "username": "xyz" } ``` This can be combined with URL parameters too if required. The JSON blob takes precedence. ```sh curl -H "Content-Type: application/json" -X POST -d '{"potato":2,"sausage":1}' 'http://localhost:5572/rc/noop?rutabaga=3&potato=4' ``` ```json { "potato": 2, "rutabaga": "3", "sausage": 1 } ``` ## Debugging rclone with pprof If you use the `--rc` flag this will also enable the use of the go profiling tools on the same port. To use these, first [install go](https://golang.org/doc/install). ### Debugging memory use To profile rclone's memory use you can run: ```sh go tool pprof -web http://localhost:5572/debug/pprof/heap ``` This should open a page in your browser showing what is using what memory. You can also use the `-text` flag to produce a textual summary ```sh $ go tool pprof -text http://localhost:5572/debug/pprof/heap Showing nodes accounting for 1537.03kB, 100% of 1537.03kB total flat flat% sum% cum cum% 1024.03kB 66.62% 66.62% 1024.03kB 66.62% github.com/rclone/rclone/vendor/golang.org/x/net/http2/hpack.addDecoderNode 513kB 33.38% 100% 513kB 33.38% net/http.newBufioWriterSize 0 0% 100% 1024.03kB 66.62% github.com/rclone/rclone/cmd/all.init 0 0% 100% 1024.03kB 66.62% github.com/rclone/rclone/cmd/serve.init 0 0% 100% 1024.03kB 66.62% github.com/rclone/rclone/cmd/serve/restic.init 0 0% 100% 1024.03kB 66.62% github.com/rclone/rclone/vendor/golang.org/x/net/http2.init 0 0% 100% 1024.03kB 66.62% github.com/rclone/rclone/vendor/golang.org/x/net/http2/hpack.init 0 0% 100% 1024.03kB 66.62% github.com/rclone/rclone/vendor/golang.org/x/net/http2/hpack.init.0 0 0% 100% 1024.03kB 66.62% main.init 0 0% 100% 513kB 33.38% net/http.(*conn).readRequest 0 0% 100% 513kB 33.38% net/http.(*conn).serve 0 0% 100% 1024.03kB 66.62% runtime.main ``` ### Debugging go routine leaks Memory leaks are most often caused by go routine leaks keeping memory alive which should have been garbage collected. See all active go routines using ```sh curl http://localhost:5572/debug/pprof/goroutine?debug=1 ``` Or go to in your browser. ### Other profiles to look at You can see a summary of profiles available at Here is how to use some of them: - Memory: `go tool pprof http://localhost:5572/debug/pprof/heap` - Go routines: `curl http://localhost:5572/debug/pprof/goroutine?debug=1` - 30-second CPU profile: `go tool pprof http://localhost:5572/debug/pprof/profile` - 5-second execution trace: `wget http://localhost:5572/debug/pprof/trace?seconds=5` - Goroutine blocking profile - Enable first with: `rclone rc debug/set-block-profile-rate rate=1` ([docs](#debug-set-block-profile-rate)) - `go tool pprof http://localhost:5572/debug/pprof/block` - Contended mutexes: - Enable first with: `rclone rc debug/set-mutex-profile-fraction rate=1` ([docs](#debug-set-mutex-profile-fraction)) - `go tool pprof http://localhost:5572/debug/pprof/mutex` See the [net/http/pprof docs](https://golang.org/pkg/net/http/pprof/) for more info on how to use the profiling and for a general overview see [the Go team's blog post on profiling go programs](https://blog.golang.org/profiling-go-programs). The profiling hook is [zero overhead unless it is used](https://stackoverflow.com/q/26545159/164234). # Overview of cloud storage systems Each cloud storage system is slightly different. Rclone attempts to provide a unified interface to them, but some underlying differences show through. ## Features Here is an overview of the major features of each cloud storage system. | Name | Hash | ModTime | Case Insensitive | Duplicate Files | MIME Type | Metadata | | ---------------------------- |:-----------------:|:-------:|:----------------:|:---------------:|:---------:|:--------:| | 1Fichier | Whirlpool | - | No | Yes | R | - | | Akamai Netstorage | MD5, SHA256 | R/W | No | No | R | - | | Amazon S3 (or S3 compatible) | MD5 | R/W | No | No | R/W | RWU | | Backblaze B2 | SHA1 | R/W | No | No | R/W | - | | Box | SHA1 | R/W | Yes | No | - | - | | Citrix ShareFile | MD5 | R/W | Yes | No | - | - | | Cloudinary | MD5 | R | No | Yes | - | - | | Dropbox | DBHASH ¹ | R | Yes | No | - | - | | Enterprise File Fabric | - | R/W | Yes | No | R/W | - | | FileLu Cloud Storage | MD5 | R/W | No | Yes | R | - | | Files.com | MD5, CRC32 | DR/W | Yes | No | R | - | | FTP | - | R/W ¹⁰ | No | No | - | - | | Gofile | MD5 | DR/W | No | Yes | R | - | | Google Cloud Storage | MD5 | R/W | No | No | R/W | - | | Google Drive | MD5, SHA1, SHA256 | DR/W | No | Yes | R/W | DRWU | | Google Photos | - | - | No | Yes | R | - | | HDFS | - | R/W | No | No | - | - | | HiDrive | HiDrive ¹² | R/W | No | No | - | - | | HTTP | - | R | No | No | R | - | | iCloud Drive | - | R | No | No | - | - | | Internet Archive | MD5, SHA1, CRC32 | R/W ¹¹ | No | No | - | RWU | | Jottacloud | MD5 | R/W | Yes | No | R | RW | | Koofr | MD5 | - | Yes | No | - | - | | Linkbox | - | R | No | No | - | - | | Mail.ru Cloud | Mailru ⁶ | R/W | Yes | No | - | - | | Mega | - | - | No | Yes | - | - | | Memory | MD5 | R/W | No | No | - | - | | Microsoft Azure Blob Storage | MD5 | R/W | No | No | R/W | - | | Microsoft Azure Files Storage | MD5 | R/W | Yes | No | R/W | - | | Microsoft OneDrive | QuickXorHash ⁵ | DR/W | Yes | No | R | DRW | | OpenDrive | MD5 | R/W | Yes | Partial ⁸ | - | - | | OpenStack Swift | MD5 | R/W | No | No | R/W | - | | Oracle Object Storage | MD5 | R/W | No | No | R/W | RU | | pCloud | MD5, SHA1 ⁷ | R/W | No | No | W | - | | PikPak | MD5 | R | No | No | R | - | | Pixeldrain | SHA256 | R/W | No | No | R | RW | | premiumize.me | - | - | Yes | No | R | - | | put.io | CRC-32 | R/W | No | Yes | R | - | | Proton Drive | SHA1 | R/W | No | No | R | - | | QingStor | MD5 | - ⁹ | No | No | R/W | - | | Quatrix by Maytech | - | R/W | No | No | - | - | | Seafile | - | - | No | No | - | - | | SFTP | MD5, SHA1 ² | DR/W | Depends | No | - | - | | Sia | - | - | No | No | - | - | | SMB | - | R/W | Yes | No | - | - | | SugarSync | - | - | No | No | - | - | | Storj | - | R | No | No | - | - | | Uloz.to | MD5, SHA256 ¹³ | - | No | Yes | - | - | | Uptobox | - | - | No | Yes | - | - | | WebDAV | MD5, SHA1 ³ | R ⁴ | Depends | No | - | - | | Yandex Disk | MD5 | R/W | No | No | R | - | | Zoho WorkDrive | - | - | No | No | - | - | | The local filesystem | All | DR/W | Depends | No | - | DRWU | ¹ Dropbox supports [its own custom hash](https://www.dropbox.com/developers/reference/content-hash). This is an SHA256 sum of all the 4 MiB block SHA256s. ² SFTP supports checksums if the same login has shell access and `md5sum` or `sha1sum` as well as `echo` are in the remote's PATH. ³ WebDAV supports hashes when used with Fastmail Files, Owncloud and Nextcloud only. ⁴ WebDAV supports modtimes when used with Fastmail Files, Owncloud and Nextcloud only. ⁵ [QuickXorHash](https://docs.microsoft.com/en-us/onedrive/developer/code-snippets/quickxorhash) is Microsoft's own hash. ⁶ Mail.ru uses its own modified SHA1 hash ⁷ pCloud only supports SHA1 (not MD5) in its EU region ⁸ Opendrive does not support creation of duplicate files using their web client interface or other stock clients, but the underlying storage platform has been determined to allow duplicate files, and it is possible to create them with `rclone`. It may be that this is a mistake or an unsupported feature. ⁹ QingStor does not support SetModTime for objects bigger than 5 GiB. ¹⁰ FTP supports modtimes for the major FTP servers, and also others if they advertised required protocol extensions. See [this](https://rclone.org/ftp/#modification-times) for more details. ¹¹ Internet Archive requires option `wait_archive` to be set to a non-zero value for full modtime support. ¹² HiDrive supports [its own custom hash](https://static.hidrive.com/dev/0001). It combines SHA1 sums for each 4 KiB block hierarchically to a single top-level sum. ¹³ Uloz.to provides server-calculated MD5 hash upon file upload. MD5 and SHA256 hashes are client-calculated and stored as metadata fields. ### Hash The cloud storage system supports various hash types of the objects. The hashes are used when transferring data as an integrity check and can be specifically used with the `--checksum` flag in syncs and in the `check` command. To use the verify checksums when transferring between cloud storage systems they must support a common hash type. ### ModTime Almost all cloud storage systems store some sort of timestamp on objects, but several of them not something that is appropriate to use for syncing. E.g. some backends will only write a timestamp that represents the time of the upload. To be relevant for syncing it should be able to store the modification time of the source object. If this is not the case, rclone will only check the file size by default, though can be configured to check the file hash (with the `--checksum` flag). Ideally it should also be possible to change the timestamp of an existing file without having to re-upload it. | Key | Explanation | |-----|-------------| | `-` | ModTimes not supported - times likely the upload time | | `R` | ModTimes supported on files but can't be changed without re-upload | | `R/W` | Read and Write ModTimes fully supported on files | | `DR` | ModTimes supported on files and directories but can't be changed without re-upload | | `DR/W` | Read and Write ModTimes fully supported on files and directories | Storage systems with a `-` in the ModTime column, means the modification read on objects is not the modification time of the file when uploaded. It is most likely the time the file was uploaded, or possibly something else (like the time the picture was taken in Google Photos). Storage systems with a `R` (for read-only) in the ModTime column, means the it keeps modification times on objects, and updates them when uploading objects, but it does not support changing only the modification time (`SetModTime` operation) without re-uploading, possibly not even without deleting existing first. Some operations in rclone, such as `copy` and `sync` commands, will automatically check for `SetModTime` support and re-upload if necessary to keep the modification times in sync. Other commands will not work without `SetModTime` support, e.g. `touch` command on an existing file will fail, and changes to modification time only on a files in a `mount` will be silently ignored. Storage systems with `R/W` (for read/write) in the ModTime column, means they do also support modtime-only operations. Storage systems with `D` in the ModTime column means that the following symbols apply to directories as well as files. ### Case Insensitive If a cloud storage systems is case sensitive then it is possible to have two files which differ only in case, e.g. `file.txt` and `FILE.txt`. If a cloud storage system is case insensitive then that isn't possible. This can cause problems when syncing between a case insensitive system and a case sensitive system. The symptom of this is that no matter how many times you run the sync it never completes fully. The local filesystem and SFTP may or may not be case sensitive depending on OS. - Windows - usually case insensitive, though case is preserved - OSX - usually case insensitive, though it is possible to format case sensitive - Linux - usually case sensitive, but there are case insensitive file systems (e.g. FAT formatted USB keys) Most of the time this doesn't cause any problems as people tend to avoid files whose name differs only by case even on case sensitive systems. ### Duplicate files If a cloud storage system allows duplicate files then it can have two objects with the same name. This confuses rclone greatly when syncing - use the `rclone dedupe` command to rename or remove duplicates. ### Restricted filenames Some cloud storage systems might have restrictions on the characters that are usable in file or directory names. When `rclone` detects such a name during a file upload, it will transparently replace the restricted characters with similar looking Unicode characters. To handle the different sets of restricted characters for different backends, rclone uses something it calls [encoding](#encoding). This process is designed to avoid ambiguous file names as much as possible and allow to move files between many cloud storage systems transparently. The name shown by `rclone` to the user or during log output will only contain a minimal set of [replaced characters](#restricted-characters) to ensure correct formatting and not necessarily the actual name used on the cloud storage. This transformation is reversed when downloading a file or parsing `rclone` arguments. For example, when uploading a file named `my file?.txt` to Onedrive, it will be displayed as `my file?.txt` on the console, but stored as `my file？.txt` to Onedrive (the `?` gets replaced by the similar looking `？` character, the so-called "fullwidth question mark"). The reverse transformation allows to read a file `unusual/name.txt` from Google Drive, by passing the name `unusual／name.txt` on the command line (the `/` needs to be replaced by the similar looking `／` character). #### Caveats {#restricted-filenames-caveats} The filename encoding system works well in most cases, at least where file names are written in English or similar languages. You might not even notice it: It just works. In some cases it may lead to issues, though. E.g. when file names are written in Chinese, or Japanese, where it is always the Unicode fullwidth variants of the punctuation marks that are used. On Windows, the characters `:`, `*` and `?` are examples of restricted characters. If these are used in filenames on a remote that supports it, Rclone will transparently convert them to their fullwidth Unicode variants `＊`, `？` and `：` when downloading to Windows, and back again when uploading. This way files with names that are not allowed on Windows can still be stored. However, if you have files on your Windows system originally with these same Unicode characters in their names, they will be included in the same conversion process. E.g. if you create a file in your Windows filesystem with name `Test：1.jpg`, where `：` is the Unicode fullwidth colon symbol, and use rclone to upload it to Google Drive, which supports regular `:` (halfwidth question mark), rclone will replace the fullwidth `:` with the halfwidth `:` and store the file as `Test:1.jpg` in Google Drive. Since both Windows and Google Drive allows the name `Test：1.jpg`, it would probably be better if rclone just kept the name as is in this case. With the opposite situation; if you have a file named `Test:1.jpg`, in your Google Drive, e.g. uploaded from a Linux system where `:` is valid in file names. Then later use rclone to copy this file to your Windows computer you will notice that on your local disk it gets renamed to `Test：1.jpg`. The original filename is not legal on Windows, due to the `:`, and rclone therefore renames it to make the copy possible. That is all good. However, this can also lead to an issue: If you already had a *different* file named `Test：1.jpg` on Windows, and then use rclone to copy either way. Rclone will then treat the file originally named `Test:1.jpg` on Google Drive and the file originally named `Test：1.jpg` on Windows as the same file, and replace the contents from one with the other. Its virtually impossible to handle all cases like these correctly in all situations, but by customizing the [encoding option](#encoding), changing the set of characters that rclone should convert, you should be able to create a configuration that works well for your specific situation. See also the [example](https://rclone.org/overview/#encoding-example-windows) below. (Windows was used as an example of a file system with many restricted characters, and Google drive a storage system with few.) #### Default restricted characters {#restricted-characters} The table below shows the characters that are replaced by default. When a replacement character is found in a filename, this character will be escaped with the `‛` character to avoid ambiguous file names. (e.g. a file named `␀.txt` would shown as `‛␀.txt`) Each cloud storage backend can use a different set of characters, which will be specified in the documentation for each backend. | Character | Value | Replacement | | --------- |:-----:|:-----------:| | NUL | 0x00 | ␀ | | SOH | 0x01 | ␁ | | STX | 0x02 | ␂ | | ETX | 0x03 | ␃ | | EOT | 0x04 | ␄ | | ENQ | 0x05 | ␅ | | ACK | 0x06 | ␆ | | BEL | 0x07 | ␇ | | BS | 0x08 | ␈ | | HT | 0x09 | ␉ | | LF | 0x0A | ␊ | | VT | 0x0B | ␋ | | FF | 0x0C | ␌ | | CR | 0x0D | ␍ | | SO | 0x0E | ␎ | | SI | 0x0F | ␏ | | DLE | 0x10 | ␐ | | DC1 | 0x11 | ␑ | | DC2 | 0x12 | ␒ | | DC3 | 0x13 | ␓ | | DC4 | 0x14 | ␔ | | NAK | 0x15 | ␕ | | SYN | 0x16 | ␖ | | ETB | 0x17 | ␗ | | CAN | 0x18 | ␘ | | EM | 0x19 | ␙ | | SUB | 0x1A | ␚ | | ESC | 0x1B | ␛ | | FS | 0x1C | ␜ | | GS | 0x1D | ␝ | | RS | 0x1E | ␞ | | US | 0x1F | ␟ | | / | 0x2F | ／ | | DEL | 0x7F | ␡ | The default encoding will also encode these file names as they are problematic with many cloud storage systems. | File name | Replacement | | --------- |:-----------:| | . | ． | | .. | ．． | #### Invalid UTF-8 bytes {#invalid-utf8} Some backends only support a sequence of well formed UTF-8 bytes as file or directory names. In this case all invalid UTF-8 bytes will be replaced with a quoted representation of the byte value to allow uploading a file to such a backend. For example, the invalid byte `0xFE` will be encoded as `‛FE`. A common source of invalid UTF-8 bytes are local filesystems, that store names in a different encoding than UTF-8 or UTF-16, like latin1. See the [local filenames](https://rclone.org/local/#filenames) section for details. #### Encoding option {#encoding} Most backends have an encoding option, specified as a flag `--backend-encoding` where `backend` is the name of the backend, or as a config parameter `encoding` (you'll need to select the Advanced config in `rclone config` to see it). This will have default value which encodes and decodes characters in such a way as to preserve the maximum number of characters (see above). However this can be incorrect in some scenarios, for example if you have a Windows file system with Unicode fullwidth characters `＊`, `？` or `：`, that you want to remain as those characters on the remote rather than being translated to regular (halfwidth) `*`, `?` and `:`. The `--backend-encoding` flags allow you to change that. You can disable the encoding completely with `--backend-encoding Raw` or set `encoding = Raw` in the config file. Encoding takes a comma separated list of encodings. You can see the list of all possible values by passing an invalid value to this flag, e.g. `--local-encoding "help"`. The command `rclone help flags encoding` will show you the defaults for the backends. | Encoding | Characters | Encoded as | | --------- | ---------- | ---------- | | Asterisk | `*` | `＊` | | BackQuote | `` ` `` | `｀` | | BackSlash | `\` | `＼` | | Colon | `:` | `：` | | CrLf | CR 0x0D, LF 0x0A | `␍`, `␊` | | Ctl | All control characters 0x00-0x1F | `␀␁␂␃␄␅␆␇␈␉␊␋␌␍␎␏␐␑␒␓␔␕␖␗␘␙␚␛␜␝␞␟` | | Del | DEL 0x7F | `␡` | | Dollar | `$` | `＄` | | Dot | `.` or `..` as entire string | `．`, `．．` | | DoubleQuote | `"` | `＂` | | Exclamation | `!` | `！` | | Hash | `#` | `＃` | | InvalidUtf8 | An invalid UTF-8 character (e.g. latin1) | `�` | | LeftCrLfHtVt | CR 0x0D, LF 0x0A, HT 0x09, VT 0x0B on the left of a string | `␍`, `␊`, `␉`, `␋` | | LeftPeriod | `.` on the left of a string | `.` | | LeftSpace | SPACE on the left of a string | `␠` | | LeftTilde | `~` on the left of a string | `～` | | LtGt | `<`, `>` | `＜`, `＞` | | None ¹ | NUL 0x00 | ␀ | | Percent | `%` | `％` | | Pipe | \| | `｜` | | Question | `?` | `？` | | RightCrLfHtVt | CR 0x0D, LF 0x0A, HT 0x09, VT 0x0B on the right of a string | `␍`, `␊`, `␉`, `␋` | | RightPeriod | `.` on the right of a string | `.` | | RightSpace | SPACE on the right of a string | `␠` | | Semicolon | `;` | `；` | | SingleQuote | `'` | `＇` | | Slash | `/` | `／` | | SquareBracket | `[`, `]` | `［`, `］` | ¹ Encoding from NUL 0x00 to ␀ is always implicit except when using Raw. It was previously incorrectly documented as disabling encoding, and to maintain backward compatibility, its behavior has not been changed. ##### Encoding example: FTP To take a specific example, the FTP backend's default encoding is ```sh --ftp-encoding "Slash,Del,Ctl,RightSpace,Dot" ``` However, let's say the FTP server is running on Windows and can't have any of the invalid Windows characters in file names. You are backing up Linux servers to this FTP server which do have those characters in file names. So you would add the Windows set which are ```text Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot ``` to the existing ones, giving: ```text Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot,Del,RightSpace ``` This can be specified using the `--ftp-encoding` flag or using an `encoding` parameter in the config file. ##### Encoding example: Windows As a nother example, take a Windows system where there is a file with name `Test：1.jpg`, where `：` is the Unicode fullwidth colon symbol. When using rclone to copy this to a remote which supports `:`, the regular (halfwidth) colon (such as Google Drive), you will notice that the file gets renamed to `Test:1.jpg`. To avoid this you can change the set of characters rclone should convert for the local filesystem, using command-line argument `--local-encoding`. Rclone's default behavior on Windows corresponds to ```sh --local-encoding "Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot" ``` If you want to use fullwidth characters `：`, `＊` and `？` in your filenames without rclone changing them when uploading to a remote, then set the same as the default value but without `Colon,Question,Asterisk`: ```sh --local-encoding "Slash,LtGt,DoubleQuote,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot" ``` Alternatively, you can disable the conversion of any characters with `--local-encoding Raw`. Instead of using command-line argument `--local-encoding`, you may also set it as [environment variable](https://rclone.org/docs/#environment-variables) `RCLONE_LOCAL_ENCODING`, or [configure](https://rclone.org/docs/#configure) a remote of type `local` in your config, and set the `encoding` option there. The risk by doing this is that if you have a filename with the regular (halfwidth) `:`, `*` and `?` in your cloud storage, and you try to download it to your Windows filesystem, this will fail. These characters are not valid in filenames on Windows, and you have told rclone not to work around this by converting them to valid fullwidth variants. ### MIME Type MIME types (also known as media types) classify types of documents using a simple text classification, e.g. `text/html` or `application/pdf`. Some cloud storage systems support reading (`R`) the MIME type of objects and some support writing (`W`) the MIME type of objects. The MIME type can be important if you are serving files directly to HTTP from the storage system. If you are copying from a remote which supports reading (`R`) to a remote which supports writing (`W`) then rclone will preserve the MIME types. Otherwise they will be guessed from the extension, or the remote itself may assign the MIME type. ### Metadata Backends may or may support reading or writing metadata. They may support reading and writing system metadata (metadata intrinsic to that backend) and/or user metadata (general purpose metadata). The levels of metadata support are | Key | Explanation | |-----|-------------| | `R` | Read only System Metadata on files only| | `RW` | Read and write System Metadata on files only| | `RWU` | Read and write System Metadata and read and write User Metadata on files only| | `DR` | Read only System Metadata on files and directories | | `DRW` | Read and write System Metadata on files and directories| | `DRWU` | Read and write System Metadata and read and write User Metadata on files and directories | See [the metadata docs](https://rclone.org/docs/#metadata) for more info. ## Optional Features All rclone remotes support a base command set. Other features depend upon backend-specific capabilities. | Name | Purge | Copy | Move | DirMove | CleanUp | ListR | StreamUpload | MultithreadUpload | LinkSharing | About | EmptyDir | | ---------------------------- |:-----:|:----:|:----:|:-------:|:-------:|:-----:|:------------:|:------------------|:------------:|:-----:|:--------:| | 1Fichier | No | Yes | Yes | No | No | No | No | No | Yes | No | Yes | | Akamai Netstorage | Yes | No | No | No | No | Yes | Yes | No | No | No | Yes | | Amazon S3 (or S3 compatible) | No | Yes | No | No | Yes | Yes | Yes | Yes | Yes | No | No | | Backblaze B2 | No | Yes | No | No | Yes | Yes | Yes | Yes | Yes | No | No | | Box | Yes | Yes | Yes | Yes | Yes | No | Yes | No | Yes | Yes | Yes | | Citrix ShareFile | Yes | Yes | Yes | Yes | No | No | No | No | No | No | Yes | | Dropbox | Yes | Yes | Yes | Yes | No | No | Yes | No | Yes | Yes | Yes | | Cloudinary | No | No | No | No | No | No | Yes | No | No | No | No | | Enterprise File Fabric | Yes | Yes | Yes | Yes | Yes | No | No | No | No | No | Yes | | Files.com | Yes | Yes | Yes | Yes | No | No | Yes | No | Yes | No | Yes | | FTP | No | No | Yes | Yes | No | No | Yes | No | No | No | Yes | | Gofile | Yes | Yes | Yes | Yes | No | No | Yes | No | Yes | Yes | Yes | | Google Cloud Storage | Yes | Yes | No | No | No | No | Yes | No | No | No | No | | Google Drive | Yes | Yes | Yes | Yes | Yes | Yes | Yes | No | Yes | Yes | Yes | | Google Photos | No | No | No | No | No | No | No | No | No | No | No | | HDFS | Yes | No | Yes | Yes | No | No | Yes | No | No | Yes | Yes | | HiDrive | Yes | Yes | Yes | Yes | No | No | Yes | No | No | No | Yes | | HTTP | No | No | No | No | No | No | No | No | No | No | Yes | | iCloud Drive | Yes | Yes | Yes | Yes | No | No | No | No | No | No | Yes | | ImageKit | Yes | No | Yes | No | No | No | No | No | No | No | Yes | | Internet Archive | No | Yes | No | No | Yes | Yes | No | No | Yes | Yes | No | | Jottacloud | Yes | Yes | Yes | Yes | Yes | Yes | No | No | Yes | Yes | Yes | | Koofr | Yes | Yes | Yes | Yes | No | No | Yes | No | Yes | Yes | Yes | | Mail.ru Cloud | Yes | Yes | Yes | Yes | Yes | No | No | No | Yes | Yes | Yes | | Mega | Yes | No | Yes | Yes | Yes | No | No | No | Yes | Yes | Yes | | Memory | No | Yes | No | No | No | Yes | Yes | No | No | No | No | | Microsoft Azure Blob Storage | Yes | Yes | No | No | No | Yes | Yes | Yes | No | No | No | | Microsoft Azure Files Storage | No | Yes | Yes | Yes | No | No | Yes | Yes | No | Yes | Yes | | Microsoft OneDrive | Yes | Yes | Yes | Yes | Yes | Yes ⁵ | No | No | Yes | Yes | Yes | | OpenDrive | Yes | Yes | Yes | Yes | No | No | No | No | No | Yes | Yes | | OpenStack Swift | Yes ¹ | Yes | No | No | No | Yes | Yes | No | No | Yes | No | | Oracle Object Storage | No | Yes | No | No | Yes | Yes | Yes | Yes | No | No | No | | pCloud | Yes | Yes | Yes | Yes | Yes | No | No | No | Yes | Yes | Yes | | PikPak | Yes | Yes | Yes | Yes | Yes | No | No | No | Yes | Yes | Yes | | Pixeldrain | Yes | No | Yes | Yes | No | No | Yes | No | Yes | Yes | Yes | | premiumize.me | Yes | No | Yes | Yes | No | No | No | No | Yes | Yes | Yes | | put.io | Yes | No | Yes | Yes | Yes | No | Yes | No | No | Yes | Yes | | Proton Drive | Yes | No | Yes | Yes | Yes | No | No | No | No | Yes | Yes | | QingStor | No | Yes | No | No | Yes | Yes | No | No | No | No | No | | Quatrix by Maytech | Yes | Yes | Yes | Yes | No | No | No | No | No | Yes | Yes | | Seafile | Yes | Yes | Yes | Yes | Yes | Yes | Yes | No | Yes | Yes | Yes | | SFTP | No | Yes ⁴| Yes | Yes | No | No | Yes | No | No | Yes | Yes | | Sia | No | No | No | No | No | No | Yes | No | No | No | Yes | | SMB | No | No | Yes | Yes | No | No | Yes | Yes | No | No | Yes | | SugarSync | Yes | Yes | Yes | Yes | No | No | Yes | No | Yes | No | Yes | | Storj | Yes ² | Yes | Yes | No | No | Yes | Yes | No | Yes | No | No | | Uloz.to | No | No | Yes | Yes | No | No | No | No | No | No | Yes | | Uptobox | No | Yes | Yes | Yes | No | No | No | No | No | No | No | | WebDAV | Yes | Yes | Yes | Yes | No | No | Yes ³ | No | No | Yes | Yes | | Yandex Disk | Yes | Yes | Yes | Yes | Yes | No | Yes | No | Yes | Yes | Yes | | Zoho WorkDrive | Yes | Yes | Yes | Yes | No | No | No | No | No | Yes | Yes | | The local filesystem | No | No | Yes | Yes | No | No | Yes | Yes | No | Yes | Yes | ¹ Note Swift implements this in order to delete directory markers but it doesn't actually have a quicker way of deleting files other than deleting them individually. ² Storj implements this efficiently only for entire buckets. If purging a directory inside a bucket, files are deleted individually. ³ StreamUpload is not supported with Nextcloud ⁴ Use the `--sftp-copy-is-hardlink` flag to enable. ⁵ Use the `--onedrive-delta` flag to enable. ### Purge This deletes a directory quicker than just deleting all the files in the directory. ### Copy Used when copying an object to and from the same remote. This known as a server-side copy so you can copy a file without downloading it and uploading it again. It is used if you use `rclone copy` or `rclone move` if the remote doesn't support `Move` directly. If the server doesn't support `Copy` directly then for copy operations the file is downloaded then re-uploaded. ### Move Used when moving/renaming an object on the same remote. This is known as a server-side move of a file. This is used in `rclone move` if the server doesn't support `DirMove`. If the server isn't capable of `Move` then rclone simulates it with `Copy` then delete. If the server doesn't support `Copy` then rclone will download the file and re-upload it. ### DirMove This is used to implement `rclone move` to move a directory if possible. If it isn't then it will use `Move` on each file (which falls back to `Copy` then download and upload - see `Move` section). ### CleanUp This is used for emptying the trash for a remote by `rclone cleanup`. If the server can't do `CleanUp` then `rclone cleanup` will return an error. ‡‡ Note that while Box implements this it has to delete every file individually so it will be slower than emptying the trash via the WebUI ### ListR The remote supports a recursive list to list all the contents beneath a directory quickly. This enables the `--fast-list` flag to work. See the [rclone docs](https://rclone.org/docs/#fast-list) for more details. ### StreamUpload Some remotes allow files to be uploaded without knowing the file size in advance. This allows certain operations to work without spooling the file to local disk first, e.g. `rclone rcat`. ### MultithreadUpload Some remotes allow transfers to the remote to be sent as chunks in parallel. If this is supported then rclone will use multi-thread copying to transfer files much faster. ### LinkSharing Sets the necessary permissions on a file or folder and prints a link that allows others to access them, even if they don't have an account on the particular cloud provider. ### About Rclone `about` prints quota information for a remote. Typical output includes bytes used, free, quota and in trash. If a remote lacks about capability `rclone about remote:`returns an error. Backends without about capability cannot determine free space for an rclone mount, or use policy `mfs` (most free space) as a member of an rclone union remote. See [rclone about command](https://rclone.org/commands/rclone_about/) ### EmptyDir The remote supports empty directories. See [Limitations](https://rclone.org/bugs/#limitations) for details. Most Object/Bucket-based remotes do not support this. # Global Flags This describes the global flags available to every rclone command split into groups. ## Copy Flags for anything which can copy a file. ``` --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination ``` ## Sync Flags used for sync commands. ``` --backup-dir string Make backups into hierarchy based in DIR --delete-after When synchronizing, delete files on destination after transferring (default) --delete-before When synchronizing, delete files on destination before transferring --delete-during When synchronizing, delete files during transfer --fix-case Force rename of case insensitive dest to match source --ignore-errors Delete even if there are I/O errors --list-cutoff int To save memory, sort directory listings on disk above this threshold (default 1000000) --max-delete int When synchronizing, limit the number of deletes (default -1) --max-delete-size SizeSuffix When synchronizing, limit the total size of deletes (default off) --suffix string Suffix to add to changed files --suffix-keep-extension Preserve the extension when using --suffix --track-renames When synchronizing, track file renames and do a server-side move if possible --track-renames-strategy string Strategies to use when synchronizing using track-renames hash|modtime|leaf (default "hash") ``` ## Important Important flags useful for most commands. ``` -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) ``` ## Check Flags used for check commands. ``` --max-backlog int Maximum number of objects in sync or check backlog (default 10000) ``` ## Networking Flags for general networking and HTTP stuff. ``` --bind string Local address to bind to for outgoing connections, IPv4, IPv6 or name --bwlimit BwTimetable Bandwidth limit in KiB/s, or use suffix B|K|M|G|T|P or a full timetable --bwlimit-file BwTimetable Bandwidth limit per file in KiB/s, or use suffix B|K|M|G|T|P or a full timetable --ca-cert stringArray CA certificate used to verify servers --client-cert string Client SSL certificate (PEM) for mutual TLS auth --client-key string Client SSL private key (PEM) for mutual TLS auth --client-pass string Password for client SSL private key (PEM) for mutual TLS auth (obscured) (obscured) --contimeout Duration Connect timeout (default 1m0s) --disable-http-keep-alives Disable HTTP keep-alives and use each connection once --disable-http2 Disable HTTP/2 in the global transport --dscp string Set DSCP value to connections, value or name, e.g. CS1, LE, DF, AF21 --expect-continue-timeout Duration Timeout when using expect / 100-continue in HTTP (default 1s) --header stringArray Set HTTP header for all transactions --header-download stringArray Set HTTP header for download transactions --header-upload stringArray Set HTTP header for upload transactions --http-proxy string HTTP proxy URL --max-connections int Maximum number of simultaneous backend API connections, 0 for unlimited --no-check-certificate Do not verify the server SSL certificate (insecure) --no-gzip-encoding Don't set Accept-Encoding: gzip --timeout Duration IO idle timeout (default 5m0s) --tpslimit float Limit HTTP transactions per second to this --tpslimit-burst int Max burst of transactions for --tpslimit (default 1) --use-cookies Enable session cookiejar --user-agent string Set the user-agent to a specified string (default "rclone/v1.71.0") ``` ## Performance Flags helpful for increasing performance. ``` --buffer-size SizeSuffix In memory buffer size when reading files for each --transfer (default 16Mi) --checkers int Number of checkers to run in parallel (default 8) --transfers int Number of file transfers to run in parallel (default 4) ``` ## Config Flags for general configuration of rclone. ``` --ask-password Allow prompt for password for encrypted configuration (default true) --auto-confirm If enabled, do not request console confirmation --cache-dir string Directory rclone will use for caching (default "$HOME/.cache/rclone") --color AUTO|NEVER|ALWAYS When to show colors (and other ANSI codes) AUTO|NEVER|ALWAYS (default AUTO) --config string Config file (default "$HOME/.config/rclone/rclone.conf") --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --disable string Disable a comma separated list of features (use --disable help to see a list) -n, --dry-run Do a trial run with no permanent changes --error-on-no-transfer Sets exit code 9 if no files are transferred, useful in scripts --fs-cache-expire-duration Duration Cache remotes for this long (0 to disable caching) (default 5m0s) --fs-cache-expire-interval Duration Interval to check for expired remotes (default 1m0s) --human-readable Print numbers in a human-readable format, sizes with suffix Ki|Mi|Gi|Ti|Pi -i, --interactive Enable interactive mode --kv-lock-time Duration Maximum time to keep key-value database locked by process (default 1s) --low-level-retries int Number of low level retries to do (default 10) --max-buffer-memory SizeSuffix If set, don't allocate more than this amount of memory as buffers (default off) --no-console Hide console window (supported on Windows only) --no-unicode-normalization Don't normalize unicode characters in filenames --password-command SpaceSepList Command for supplying password for encrypted configuration --retries int Retry operations this many times if they fail (default 3) --retries-sleep Duration Interval between retrying operations if they fail, e.g. 500ms, 60s, 5m (0 to disable) (default 0s) --temp-dir string Directory rclone will use for temporary files (default "/tmp") --use-mmap Use mmap allocator (see docs) --use-server-modtime Use server modified time instead of object metadata ``` ## Debugging Flags for developers. ``` --cpuprofile string Write cpu profile to file --dump DumpFlags List of items to dump from: headers, bodies, requests, responses, auth, filters, goroutines, openfiles, mapper --dump-bodies Dump HTTP headers and bodies - may contain sensitive info --dump-headers Dump HTTP headers - may contain sensitive info --memprofile string Write memory profile to file ``` ## Filter Flags for filtering directory listings. ``` --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) ``` ## Listing Flags for listing directories. ``` --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions ``` ## Logging Flags for logging and statistics. ``` --log-file string Log everything to this file --log-file-compress If set, compress rotated log files using gzip --log-file-max-age Duration Maximum duration to retain old log files (eg "7d") (default 0s) --log-file-max-backups int Maximum number of old log files to retain --log-file-max-size SizeSuffix Maximum size of the log file before it's rotated (eg "10M") (default off) --log-format Bits Comma separated list of log format options (default date,time) --log-level LogLevel Log level DEBUG|INFO|NOTICE|ERROR (default NOTICE) --log-systemd Activate systemd integration for the logger --max-stats-groups int Maximum number of stats groups to keep in memory, on max oldest is discarded (default 1000) -P, --progress Show progress during transfer --progress-terminal-title Show progress on the terminal title (requires -P/--progress) -q, --quiet Print as little stuff as possible --stats Duration Interval between printing stats, e.g. 500ms, 60s, 5m (0 to disable) (default 1m0s) --stats-file-name-length int Max file name length in stats (0 for no limit) (default 45) --stats-log-level LogLevel Log level to show --stats output DEBUG|INFO|NOTICE|ERROR (default INFO) --stats-one-line Make the stats fit on one line --stats-one-line-date Enable --stats-one-line and add current date/time prefix --stats-one-line-date-format string Enable --stats-one-line-date and use custom formatted date: Enclose date string in double quotes ("), see https://golang.org/pkg/time/#Time.Format --stats-unit string Show data rate in stats as either 'bits' or 'bytes' per second (default "bytes") --syslog Use Syslog for logging --syslog-facility string Facility for syslog, e.g. KERN,USER (default "DAEMON") --use-json-log Use json log format -v, --verbose count Print lots more stuff (repeat for more) ``` ## Metadata Flags to control metadata. ``` -M, --metadata If set, preserve metadata when copying objects --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --metadata-mapper SpaceSepList Program to run to transforming metadata before upload --metadata-set stringArray Add metadata key=value when uploading ``` ## RC Flags to control the Remote Control API. ``` --rc Enable the remote control server --rc-addr stringArray IPaddress:Port or :Port to bind server to (default localhost:5572) --rc-allow-origin string Origin which cross-domain request (CORS) can be executed from --rc-baseurl string Prefix for URLs - leave blank for root --rc-cert string TLS PEM key (concatenation of certificate and CA certificate) --rc-client-ca string Client certificate authority to verify clients with --rc-enable-metrics Enable the Prometheus metrics path at the remote control server --rc-files string Path to local files to serve on the HTTP server --rc-htpasswd string A htpasswd file - if not provided no authentication is done --rc-job-expire-duration Duration Expire finished async jobs older than this value (default 1m0s) --rc-job-expire-interval Duration Interval to check for expired async jobs (default 10s) --rc-key string TLS PEM Private key --rc-max-header-bytes int Maximum size of request header (default 4096) --rc-min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --rc-no-auth Don't require auth for certain methods --rc-pass string Password for authentication --rc-realm string Realm for authentication --rc-salt string Password hashing salt (default "dlPL2MqE") --rc-serve Enable the serving of remote objects --rc-serve-no-modtime Don't read the modification time (can speed things up) --rc-server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --rc-server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --rc-template string User-specified template --rc-user string User name for authentication --rc-user-from-header string User name from a defined HTTP header --rc-web-fetch-url string URL to fetch the releases for webgui (default "https://api.github.com/repos/rclone/rclone-webui-react/releases/latest") --rc-web-gui Launch WebGUI on localhost --rc-web-gui-force-update Force update to latest version of web gui --rc-web-gui-no-open-browser Don't open the browser automatically --rc-web-gui-update Check and update to latest version of web gui ``` ## Metrics Flags to control the Metrics HTTP endpoint.. ``` --metrics-addr stringArray IPaddress:Port or :Port to bind metrics server to --metrics-allow-origin string Origin which cross-domain request (CORS) can be executed from --metrics-baseurl string Prefix for URLs - leave blank for root --metrics-cert string TLS PEM key (concatenation of certificate and CA certificate) --metrics-client-ca string Client certificate authority to verify clients with --metrics-htpasswd string A htpasswd file - if not provided no authentication is done --metrics-key string TLS PEM Private key --metrics-max-header-bytes int Maximum size of request header (default 4096) --metrics-min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --metrics-pass string Password for authentication --metrics-realm string Realm for authentication --metrics-salt string Password hashing salt (default "dlPL2MqE") --metrics-server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --metrics-server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --metrics-template string User-specified template --metrics-user string User name for authentication --metrics-user-from-header string User name from a defined HTTP header --rc-enable-metrics Enable the Prometheus metrics path at the remote control server ``` ## Backend Backend-only flags (these can be set in the config file also). ``` --alias-description string Description of the remote --alias-remote string Remote or path to alias --azureblob-access-tier string Access tier of blob: hot, cool, cold or archive --azureblob-account string Azure Storage Account Name --azureblob-archive-tier-delete Delete archive tier blobs before overwriting --azureblob-chunk-size SizeSuffix Upload chunk size (default 4Mi) --azureblob-client-certificate-password string Password for the certificate file (optional) (obscured) --azureblob-client-certificate-path string Path to a PEM or PKCS12 certificate file including the private key --azureblob-client-id string The ID of the client in use --azureblob-client-secret string One of the service principal's client secrets --azureblob-client-send-certificate-chain Send the certificate chain when using certificate auth --azureblob-copy-concurrency int Concurrency for multipart copy (default 512) --azureblob-copy-cutoff SizeSuffix Cutoff for switching to multipart copy (default 8Mi) --azureblob-delete-snapshots string Set to specify how to deal with snapshots on blob deletion --azureblob-description string Description of the remote --azureblob-directory-markers Upload an empty object with a trailing slash when a new directory is created --azureblob-disable-checksum Don't store MD5 checksum with object metadata --azureblob-disable-instance-discovery Skip requesting Microsoft Entra instance metadata --azureblob-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,RightPeriod,InvalidUtf8) --azureblob-endpoint string Endpoint for the service --azureblob-env-auth Read credentials from runtime (environment variables, CLI or MSI) --azureblob-key string Storage Account Shared Key --azureblob-list-chunk int Size of blob list (default 5000) --azureblob-msi-client-id string Object ID of the user-assigned MSI to use, if any --azureblob-msi-mi-res-id string Azure resource ID of the user-assigned MSI to use, if any --azureblob-msi-object-id string Object ID of the user-assigned MSI to use, if any --azureblob-no-check-container If set, don't attempt to check the container exists or create it --azureblob-no-head-object If set, do not do HEAD before GET when getting objects --azureblob-password string The user's password (obscured) --azureblob-public-access string Public access level of a container: blob or container --azureblob-sas-url string SAS URL for container level access only --azureblob-service-principal-file string Path to file containing credentials for use with a service principal --azureblob-tenant string ID of the service principal's tenant. Also called its directory ID --azureblob-upload-concurrency int Concurrency for multipart uploads (default 16) --azureblob-upload-cutoff string Cutoff for switching to chunked upload (<= 256 MiB) (deprecated) --azureblob-use-az Use Azure CLI tool az for authentication --azureblob-use-copy-blob Whether to use the Copy Blob API when copying to the same storage account (default true) --azureblob-use-emulator Uses local storage emulator if provided as 'true' --azureblob-use-msi Use a managed service identity to authenticate (only works in Azure) --azureblob-username string User name (usually an email address) --azurefiles-account string Azure Storage Account Name --azurefiles-chunk-size SizeSuffix Upload chunk size (default 4Mi) --azurefiles-client-certificate-password string Password for the certificate file (optional) (obscured) --azurefiles-client-certificate-path string Path to a PEM or PKCS12 certificate file including the private key --azurefiles-client-id string The ID of the client in use --azurefiles-client-secret string One of the service principal's client secrets --azurefiles-client-send-certificate-chain Send the certificate chain when using certificate auth --azurefiles-connection-string string Azure Files Connection String --azurefiles-description string Description of the remote --azurefiles-disable-instance-discovery Skip requesting Microsoft Entra instance metadata --azurefiles-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,RightPeriod,InvalidUtf8,Dot) --azurefiles-endpoint string Endpoint for the service --azurefiles-env-auth Read credentials from runtime (environment variables, CLI or MSI) --azurefiles-key string Storage Account Shared Key --azurefiles-max-stream-size SizeSuffix Max size for streamed files (default 10Gi) --azurefiles-msi-client-id string Object ID of the user-assigned MSI to use, if any --azurefiles-msi-mi-res-id string Azure resource ID of the user-assigned MSI to use, if any --azurefiles-msi-object-id string Object ID of the user-assigned MSI to use, if any --azurefiles-password string The user's password (obscured) --azurefiles-sas-url string SAS URL --azurefiles-service-principal-file string Path to file containing credentials for use with a service principal --azurefiles-share-name string Azure Files Share Name --azurefiles-tenant string ID of the service principal's tenant. Also called its directory ID --azurefiles-upload-concurrency int Concurrency for multipart uploads (default 16) --azurefiles-use-az Use Azure CLI tool az for authentication --azurefiles-use-msi Use a managed service identity to authenticate (only works in Azure) --azurefiles-username string User name (usually an email address) --b2-account string Account ID or Application Key ID --b2-chunk-size SizeSuffix Upload chunk size (default 96Mi) --b2-copy-cutoff SizeSuffix Cutoff for switching to multipart copy (default 4Gi) --b2-description string Description of the remote --b2-disable-checksum Disable checksums for large (> upload cutoff) files --b2-download-auth-duration Duration Time before the public link authorization token will expire in s or suffix ms|s|m|h|d (default 1w) --b2-download-url string Custom endpoint for downloads --b2-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --b2-endpoint string Endpoint for the service --b2-hard-delete Permanently delete files on remote removal, otherwise hide files --b2-key string Application Key --b2-lifecycle int Set the number of days deleted files should be kept when creating a bucket --b2-test-mode string A flag string for X-Bz-Test-Mode header for debugging --b2-upload-concurrency int Concurrency for multipart uploads (default 4) --b2-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default 200Mi) --b2-version-at Time Show file versions as they were at the specified time (default off) --b2-versions Include old versions in directory listings --box-access-token string Box App Primary Access Token --box-auth-url string Auth server URL --box-box-config-file string Box App config.json location --box-box-sub-type string (default "user") --box-client-credentials Use client credentials OAuth flow --box-client-id string OAuth Client Id --box-client-secret string OAuth Client Secret --box-commit-retries int Max number of times to try committing a multipart file (default 100) --box-description string Description of the remote --box-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot) --box-impersonate string Impersonate this user ID when using a service account --box-list-chunk int Size of listing chunk 1-1000 (default 1000) --box-owned-by string Only show items owned by the login (email address) passed in --box-root-folder-id string Fill in for rclone to use a non root folder as its starting point --box-token string OAuth Access Token as a JSON blob --box-token-url string Token server url --box-upload-cutoff SizeSuffix Cutoff for switching to multipart upload (>= 50 MiB) (default 50Mi) --cache-chunk-clean-interval Duration How often should the cache perform cleanups of the chunk storage (default 1m0s) --cache-chunk-no-memory Disable the in-memory cache for storing chunks during streaming --cache-chunk-path string Directory to cache chunk files (default "$HOME/.cache/rclone/cache-backend") --cache-chunk-size SizeSuffix The size of a chunk (partial file data) (default 5Mi) --cache-chunk-total-size SizeSuffix The total size that the chunks can take up on the local disk (default 10Gi) --cache-db-path string Directory to store file structure metadata DB (default "$HOME/.cache/rclone/cache-backend") --cache-db-purge Clear all the cached data for this remote on start --cache-db-wait-time Duration How long to wait for the DB to be available - 0 is unlimited (default 1s) --cache-description string Description of the remote --cache-info-age Duration How long to cache file structure information (directory listings, file size, times, etc.) (default 6h0m0s) --cache-plex-insecure string Skip all certificate verification when connecting to the Plex server --cache-plex-password string The password of the Plex user (obscured) --cache-plex-url string The URL of the Plex server --cache-plex-username string The username of the Plex user --cache-read-retries int How many times to retry a read from a cache storage (default 10) --cache-remote string Remote to cache --cache-rps int Limits the number of requests per second to the source FS (-1 to disable) (default -1) --cache-tmp-upload-path string Directory to keep temporary files until they are uploaded --cache-tmp-wait-time Duration How long should files be stored in local cache before being uploaded (default 15s) --cache-workers int How many workers should run in parallel to download chunks (default 4) --cache-writes Cache file data on writes through the FS --chunker-chunk-size SizeSuffix Files larger than chunk size will be split in chunks (default 2Gi) --chunker-description string Description of the remote --chunker-fail-hard Choose how chunker should handle files with missing or invalid chunks --chunker-hash-type string Choose how chunker handles hash sums (default "md5") --chunker-remote string Remote to chunk/unchunk --cloudinary-adjust-media-files-extensions Cloudinary handles media formats as a file attribute and strips it from the name, which is unlike most other file systems (default true) --cloudinary-api-key string Cloudinary API Key --cloudinary-api-secret string Cloudinary API Secret --cloudinary-cloud-name string Cloudinary Environment Name --cloudinary-description string Description of the remote --cloudinary-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Question,Asterisk,Pipe,Hash,Percent,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot) --cloudinary-eventually-consistent-delay Duration Wait N seconds for eventual consistency of the databases that support the backend operation (default 0s) --cloudinary-media-extensions stringArray Cloudinary supported media extensions (default 3ds,3g2,3gp,ai,arw,avi,avif,bmp,bw,cr2,cr3,djvu,dng,eps3,fbx,flif,flv,gif,glb,gltf,hdp,heic,heif,ico,indd,jp2,jpe,jpeg,jpg,jxl,jxr,m2ts,mov,mp4,mpeg,mts,mxf,obj,ogv,pdf,ply,png,psd,svg,tga,tif,tiff,ts,u3ma,usdz,wdp,webm,webp,wmv) --cloudinary-upload-prefix string Specify the API endpoint for environments out of the US --cloudinary-upload-preset string Upload Preset to select asset manipulation on upload --combine-description string Description of the remote --combine-upstreams SpaceSepList Upstreams for combining --compress-description string Description of the remote --compress-level int GZIP compression level (-2 to 9) (default -1) --compress-mode string Compression mode (default "gzip") --compress-ram-cache-limit SizeSuffix Some remotes don't allow the upload of files with unknown size (default 20Mi) --compress-remote string Remote to compress -L, --copy-links Follow symlinks and copy the pointed to item --crypt-description string Description of the remote --crypt-directory-name-encryption Option to either encrypt directory names or leave them intact (default true) --crypt-filename-encoding string How to encode the encrypted filename to text string (default "base32") --crypt-filename-encryption string How to encrypt the filenames (default "standard") --crypt-no-data-encryption Option to either encrypt file data or leave it unencrypted --crypt-pass-bad-blocks If set this will pass bad blocks through as all 0 --crypt-password string Password or pass phrase for encryption (obscured) --crypt-password2 string Password or pass phrase for salt (obscured) --crypt-remote string Remote to encrypt/decrypt --crypt-server-side-across-configs Deprecated: use --server-side-across-configs instead --crypt-show-mapping For all files listed show how the names encrypt --crypt-strict-names If set, this will raise an error when crypt comes across a filename that can't be decrypted --crypt-suffix string If this is set it will override the default suffix of ".bin" (default ".bin") --doi-description string Description of the remote --doi-doi string The DOI or the doi.org URL --doi-doi-resolver-api-url string The URL of the DOI resolver API to use --doi-provider string DOI provider --drive-acknowledge-abuse Set to allow files which return cannotDownloadAbusiveFile to be downloaded --drive-allow-import-name-change Allow the filetype to change when uploading Google docs --drive-auth-owner-only Only consider files owned by the authenticated user --drive-auth-url string Auth server URL --drive-chunk-size SizeSuffix Upload chunk size (default 8Mi) --drive-client-credentials Use client credentials OAuth flow --drive-client-id string Google Application Client Id --drive-client-secret string OAuth Client Secret --drive-copy-shortcut-content Server side copy contents of shortcuts instead of the shortcut --drive-description string Description of the remote --drive-disable-http2 Disable drive using http2 (default true) --drive-encoding Encoding The encoding for the backend (default InvalidUtf8) --drive-env-auth Get IAM credentials from runtime (environment variables or instance meta data if no env vars) --drive-export-formats string Comma separated list of preferred formats for downloading Google docs (default "docx,xlsx,pptx,svg") --drive-fast-list-bug-fix Work around a bug in Google Drive listing (default true) --drive-formats string Deprecated: See export_formats --drive-impersonate string Impersonate this user when using a service account --drive-import-formats string Comma separated list of preferred formats for uploading Google docs --drive-keep-revision-forever Keep new head revision of each file forever --drive-list-chunk int Size of listing chunk 100-1000, 0 to disable (default 1000) --drive-metadata-labels Bits Control whether labels should be read or written in metadata (default off) --drive-metadata-owner Bits Control whether owner should be read or written in metadata (default read) --drive-metadata-permissions Bits Control whether permissions should be read or written in metadata (default off) --drive-pacer-burst int Number of API calls to allow without sleeping (default 100) --drive-pacer-min-sleep Duration Minimum time to sleep between API calls (default 100ms) --drive-resource-key string Resource key for accessing a link-shared file --drive-root-folder-id string ID of the root folder --drive-scope string Comma separated list of scopes that rclone should use when requesting access from drive --drive-server-side-across-configs Deprecated: use --server-side-across-configs instead --drive-service-account-credentials string Service Account Credentials JSON blob --drive-service-account-file string Service Account Credentials JSON file path --drive-shared-with-me Only show files that are shared with me --drive-show-all-gdocs Show all Google Docs including non-exportable ones in listings --drive-size-as-quota Show sizes as storage quota usage, not actual size --drive-skip-checksum-gphotos Skip checksums on Google photos and videos only --drive-skip-dangling-shortcuts If set skip dangling shortcut files --drive-skip-gdocs Skip google documents in all listings --drive-skip-shortcuts If set skip shortcut files --drive-starred-only Only show files that are starred --drive-stop-on-download-limit Make download limit errors be fatal --drive-stop-on-upload-limit Make upload limit errors be fatal --drive-team-drive string ID of the Shared Drive (Team Drive) --drive-token string OAuth Access Token as a JSON blob --drive-token-url string Token server url --drive-trashed-only Only show files that are in the trash --drive-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default 8Mi) --drive-use-created-date Use file created date instead of modified date --drive-use-shared-date Use date file was shared instead of modified date --drive-use-trash Send files to the trash instead of deleting permanently (default true) --drive-v2-download-min-size SizeSuffix If Object's are greater, use drive v2 API to download (default off) --dropbox-auth-url string Auth server URL --dropbox-batch-mode string Upload file batching sync|async|off (default "sync") --dropbox-batch-size int Max number of files in upload batch --dropbox-batch-timeout Duration Max time to allow an idle upload batch before uploading (default 0s) --dropbox-chunk-size SizeSuffix Upload chunk size (< 150Mi) (default 48Mi) --dropbox-client-credentials Use client credentials OAuth flow --dropbox-client-id string OAuth Client Id --dropbox-client-secret string OAuth Client Secret --dropbox-description string Description of the remote --dropbox-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,RightSpace,InvalidUtf8,Dot) --dropbox-export-formats CommaSepList Comma separated list of preferred formats for exporting files (default html,md) --dropbox-impersonate string Impersonate this user when using a business account --dropbox-pacer-min-sleep Duration Minimum time to sleep between API calls (default 10ms) --dropbox-root-namespace string Specify a different Dropbox namespace ID to use as the root for all paths --dropbox-shared-files Instructs rclone to work on individual shared files --dropbox-shared-folders Instructs rclone to work on shared folders --dropbox-show-all-exports Show all exportable files in listings --dropbox-skip-exports Skip exportable files in all listings --dropbox-token string OAuth Access Token as a JSON blob --dropbox-token-url string Token server url --fichier-api-key string Your API Key, get it from https://1fichier.com/console/params.pl --fichier-cdn Set if you wish to use CDN download links --fichier-description string Description of the remote --fichier-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,SingleQuote,BackQuote,Dollar,BackSlash,Del,Ctl,LeftSpace,RightSpace,InvalidUtf8,Dot) --fichier-file-password string If you want to download a shared file that is password protected, add this parameter (obscured) --fichier-folder-password string If you want to list the files in a shared folder that is password protected, add this parameter (obscured) --fichier-shared-folder string If you want to download a shared folder, add this parameter --filefabric-description string Description of the remote --filefabric-encoding Encoding The encoding for the backend (default Slash,Del,Ctl,InvalidUtf8,Dot) --filefabric-permanent-token string Permanent Authentication Token --filefabric-root-folder-id string ID of the root folder --filefabric-token string Session Token --filefabric-token-expiry string Token expiry time --filefabric-url string URL of the Enterprise File Fabric to connect to --filefabric-version string Version read from the file fabric --filelu-description string Description of the remote --filelu-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,SingleQuote,BackQuote,Dollar,Colon,Question,Asterisk,Pipe,Hash,Percent,BackSlash,CrLf,Del,Ctl,LeftSpace,LeftPeriod,LeftTilde,LeftCrLfHtVt,RightSpace,RightPeriod,RightCrLfHtVt,InvalidUtf8,Dot,SquareBracket,Semicolon,Exclamation) --filelu-key string Your FileLu Rclone key from My Account --filescom-api-key string The API key used to authenticate with Files.com --filescom-description string Description of the remote --filescom-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,RightSpace,RightCrLfHtVt,InvalidUtf8,Dot) --filescom-password string The password used to authenticate with Files.com (obscured) --filescom-site string Your site subdomain (e.g. mysite) or custom domain (e.g. myfiles.customdomain.com) --filescom-username string The username used to authenticate with Files.com --ftp-allow-insecure-tls-ciphers Allow insecure TLS ciphers --ftp-ask-password Allow asking for FTP password when needed --ftp-close-timeout Duration Maximum time to wait for a response to close (default 1m0s) --ftp-concurrency int Maximum number of FTP simultaneous connections, 0 for unlimited --ftp-description string Description of the remote --ftp-disable-epsv Disable using EPSV even if server advertises support --ftp-disable-mlsd Disable using MLSD even if server advertises support --ftp-disable-tls13 Disable TLS 1.3 (workaround for FTP servers with buggy TLS) --ftp-disable-utf8 Disable using UTF-8 even if server advertises support --ftp-encoding Encoding The encoding for the backend (default Slash,Del,Ctl,RightSpace,Dot) --ftp-explicit-tls Use Explicit FTPS (FTP over TLS) --ftp-force-list-hidden Use LIST -a to force listing of hidden files and folders. This will disable the use of MLSD --ftp-host string FTP host to connect to --ftp-http-proxy string URL for HTTP CONNECT proxy --ftp-idle-timeout Duration Max time before closing idle connections (default 1m0s) --ftp-no-check-certificate Do not verify the TLS certificate of the server --ftp-no-check-upload Don't check the upload is OK --ftp-pass string FTP password (obscured) --ftp-port int FTP port number (default 21) --ftp-shut-timeout Duration Maximum time to wait for data connection closing status (default 1m0s) --ftp-socks-proxy string Socks 5 proxy host --ftp-tls Use Implicit FTPS (FTP over TLS) --ftp-tls-cache-size int Size of TLS session cache for all control and data connections (default 32) --ftp-user string FTP username (default "$USER") --ftp-writing-mdtm Use MDTM to set modification time (VsFtpd quirk) --gcs-access-token string Short-lived access token --gcs-anonymous Access public buckets and objects without credentials --gcs-auth-url string Auth server URL --gcs-bucket-acl string Access Control List for new buckets --gcs-bucket-policy-only Access checks should use bucket-level IAM policies --gcs-client-credentials Use client credentials OAuth flow --gcs-client-id string OAuth Client Id --gcs-client-secret string OAuth Client Secret --gcs-decompress If set this will decompress gzip encoded objects --gcs-description string Description of the remote --gcs-directory-markers Upload an empty object with a trailing slash when a new directory is created --gcs-encoding Encoding The encoding for the backend (default Slash,CrLf,InvalidUtf8,Dot) --gcs-endpoint string Endpoint for the service --gcs-env-auth Get GCP IAM credentials from runtime (environment variables or instance meta data if no env vars) --gcs-location string Location for the newly created buckets --gcs-no-check-bucket If set, don't attempt to check the bucket exists or create it --gcs-object-acl string Access Control List for new objects --gcs-project-number string Project number --gcs-service-account-file string Service Account Credentials JSON file path --gcs-storage-class string The storage class to use when storing objects in Google Cloud Storage --gcs-token string OAuth Access Token as a JSON blob --gcs-token-url string Token server url --gcs-user-project string User project --gofile-access-token string API Access token --gofile-account-id string Account ID --gofile-description string Description of the remote --gofile-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,LeftPeriod,RightPeriod,InvalidUtf8,Dot,Exclamation) --gofile-list-chunk int Number of items to list in each call (default 1000) --gofile-root-folder-id string ID of the root folder --gphotos-auth-url string Auth server URL --gphotos-batch-mode string Upload file batching sync|async|off (default "sync") --gphotos-batch-size int Max number of files in upload batch --gphotos-batch-timeout Duration Max time to allow an idle upload batch before uploading (default 0s) --gphotos-client-credentials Use client credentials OAuth flow --gphotos-client-id string OAuth Client Id --gphotos-client-secret string OAuth Client Secret --gphotos-description string Description of the remote --gphotos-encoding Encoding The encoding for the backend (default Slash,CrLf,InvalidUtf8,Dot) --gphotos-include-archived Also view and download archived media --gphotos-proxy string Use the gphotosdl proxy for downloading the full resolution images --gphotos-read-only Set to make the Google Photos backend read only --gphotos-read-size Set to read the size of media items --gphotos-start-year int Year limits the photos to be downloaded to those which are uploaded after the given year (default 2000) --gphotos-token string OAuth Access Token as a JSON blob --gphotos-token-url string Token server url --hasher-auto-size SizeSuffix Auto-update checksum for files smaller than this size (disabled by default) --hasher-description string Description of the remote --hasher-hashes CommaSepList Comma separated list of supported checksum types (default md5,sha1) --hasher-max-age Duration Maximum time to keep checksums in cache (0 = no cache, off = cache forever) (default off) --hasher-remote string Remote to cache checksums for (e.g. myRemote:path) --hdfs-data-transfer-protection string Kerberos data transfer protection: authentication|integrity|privacy --hdfs-description string Description of the remote --hdfs-encoding Encoding The encoding for the backend (default Slash,Colon,Del,Ctl,InvalidUtf8,Dot) --hdfs-namenode CommaSepList Hadoop name nodes and ports --hdfs-service-principal-name string Kerberos service principal name for the namenode --hdfs-username string Hadoop user name --hidrive-auth-url string Auth server URL --hidrive-chunk-size SizeSuffix Chunksize for chunked uploads (default 48Mi) --hidrive-client-credentials Use client credentials OAuth flow --hidrive-client-id string OAuth Client Id --hidrive-client-secret string OAuth Client Secret --hidrive-description string Description of the remote --hidrive-disable-fetching-member-count Do not fetch number of objects in directories unless it is absolutely necessary --hidrive-encoding Encoding The encoding for the backend (default Slash,Dot) --hidrive-endpoint string Endpoint for the service (default "https://api.hidrive.strato.com/2.1") --hidrive-root-prefix string The root/parent folder for all paths (default "/") --hidrive-scope-access string Access permissions that rclone should use when requesting access from HiDrive (default "rw") --hidrive-scope-role string User-level that rclone should use when requesting access from HiDrive (default "user") --hidrive-token string OAuth Access Token as a JSON blob --hidrive-token-url string Token server url --hidrive-upload-concurrency int Concurrency for chunked uploads (default 4) --hidrive-upload-cutoff SizeSuffix Cutoff/Threshold for chunked uploads (default 96Mi) --http-description string Description of the remote --http-headers CommaSepList Set HTTP headers for all transactions --http-no-escape Do not escape URL metacharacters in path names --http-no-head Don't use HEAD requests --http-no-slash Set this if the site doesn't end directories with / --http-url string URL of HTTP host to connect to --iclouddrive-apple-id string Apple ID --iclouddrive-client-id string Client id (default "d39ba9916b7251055b22c7f910e2ea796ee65e98b2ddecea8f5dde8d9d1a815d") --iclouddrive-description string Description of the remote --iclouddrive-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --iclouddrive-password string Password (obscured) --imagekit-description string Description of the remote --imagekit-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Dollar,Question,Hash,Percent,BackSlash,Del,Ctl,InvalidUtf8,Dot,SquareBracket) --imagekit-endpoint string You can find your ImageKit.io URL endpoint in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) --imagekit-only-signed Restrict unsigned image URLs If you have configured Restrict unsigned image URLs in your dashboard settings, set this to true --imagekit-private-key string You can find your ImageKit.io private key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) --imagekit-public-key string You can find your ImageKit.io public key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) --imagekit-upload-tags string Tags to add to the uploaded files, e.g. "tag1,tag2" --imagekit-versions Include old versions in directory listings --internetarchive-access-key-id string IAS3 Access Key --internetarchive-description string Description of the remote --internetarchive-disable-checksum Don't ask the server to test against MD5 checksum calculated by rclone (default true) --internetarchive-encoding Encoding The encoding for the backend (default Slash,LtGt,CrLf,Del,Ctl,InvalidUtf8,Dot) --internetarchive-endpoint string IAS3 Endpoint (default "https://s3.us.archive.org") --internetarchive-front-endpoint string Host of InternetArchive Frontend (default "https://archive.org") --internetarchive-item-derive Whether to trigger derive on the IA item or not. If set to false, the item will not be derived by IA upon upload (default true) --internetarchive-item-metadata stringArray Metadata to be set on the IA item, this is different from file-level metadata that can be set using --metadata-set --internetarchive-secret-access-key string IAS3 Secret Key (password) --internetarchive-wait-archive Duration Timeout for waiting the server's processing tasks (specifically archive and book_op) to finish (default 0s) --jottacloud-auth-url string Auth server URL --jottacloud-client-credentials Use client credentials OAuth flow --jottacloud-client-id string OAuth Client Id --jottacloud-client-secret string OAuth Client Secret --jottacloud-description string Description of the remote --jottacloud-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,Del,Ctl,InvalidUtf8,Dot) --jottacloud-hard-delete Delete files permanently rather than putting them into the trash --jottacloud-md5-memory-limit SizeSuffix Files bigger than this will be cached on disk to calculate the MD5 if required (default 10Mi) --jottacloud-no-versions Avoid server side versioning by deleting files and recreating files instead of overwriting them --jottacloud-token string OAuth Access Token as a JSON blob --jottacloud-token-url string Token server url --jottacloud-trashed-only Only show files that are in the trash --jottacloud-upload-resume-limit SizeSuffix Files bigger than this can be resumed if the upload fail's (default 10Mi) --koofr-description string Description of the remote --koofr-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --koofr-endpoint string The Koofr API endpoint to use --koofr-mountid string Mount ID of the mount to use --koofr-password string Your password for rclone generate one at https://app.koofr.net/app/admin/preferences/password (obscured) --koofr-provider string Choose your storage provider --koofr-setmtime Does the backend support setting modification time (default true) --koofr-user string Your user name --linkbox-description string Description of the remote --linkbox-token string Token from https://www.linkbox.to/admin/account --local-case-insensitive Force the filesystem to report itself as case insensitive --local-case-sensitive Force the filesystem to report itself as case sensitive --local-description string Description of the remote --local-encoding Encoding The encoding for the backend (default Slash,Dot) --local-hashes CommaSepList Comma separated list of supported checksum types --local-links Translate symlinks to/from regular files with a '.rclonelink' extension for the local backend --local-no-check-updated Don't check to see if the files change during upload --local-no-clone Disable reflink cloning for server-side copies --local-no-preallocate Disable preallocation of disk space for transferred files --local-no-set-modtime Disable setting modtime --local-no-sparse Disable sparse files for multi-thread downloads --local-nounc Disable UNC (long path names) conversion on Windows --local-time-type mtime|atime|btime|ctime Set what kind of time is returned (default mtime) --local-unicode-normalization Apply unicode NFC normalization to paths and filenames --local-zero-size-links Assume the Stat size of links is zero (and read them instead) (deprecated) --mailru-auth-url string Auth server URL --mailru-check-hash What should copy do if file checksum is mismatched or invalid (default true) --mailru-client-credentials Use client credentials OAuth flow --mailru-client-id string OAuth Client Id --mailru-client-secret string OAuth Client Secret --mailru-description string Description of the remote --mailru-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,InvalidUtf8,Dot) --mailru-pass string Password (obscured) --mailru-speedup-enable Skip full upload if there is another file with same data hash (default true) --mailru-speedup-file-patterns string Comma separated list of file name patterns eligible for speedup (put by hash) (default "*.mkv,*.avi,*.mp4,*.mp3,*.zip,*.gz,*.rar,*.pdf") --mailru-speedup-max-disk SizeSuffix This option allows you to disable speedup (put by hash) for large files (default 3Gi) --mailru-speedup-max-memory SizeSuffix Files larger than the size given below will always be hashed on disk (default 32Mi) --mailru-token string OAuth Access Token as a JSON blob --mailru-token-url string Token server url --mailru-user string User name (usually email) --mega-debug Output more debug from Mega --mega-description string Description of the remote --mega-encoding Encoding The encoding for the backend (default Slash,InvalidUtf8,Dot) --mega-hard-delete Delete files permanently rather than putting them into the trash --mega-pass string Password (obscured) --mega-use-https Use HTTPS for transfers --mega-user string User name --memory-description string Description of the remote --netstorage-account string Set the NetStorage account name --netstorage-description string Description of the remote --netstorage-host string Domain+path of NetStorage host to connect to --netstorage-protocol string Select between HTTP or HTTPS protocol (default "https") --netstorage-secret string Set the NetStorage account secret/G2O key for authentication (obscured) -x, --one-file-system Don't cross filesystem boundaries (unix/macOS only) --onedrive-access-scopes SpaceSepList Set scopes to be requested by rclone (default Files.Read Files.ReadWrite Files.Read.All Files.ReadWrite.All Sites.Read.All offline_access) --onedrive-auth-url string Auth server URL --onedrive-av-override Allows download of files the server thinks has a virus --onedrive-chunk-size SizeSuffix Chunk size to upload files with - must be multiple of 320k (327,680 bytes) (default 10Mi) --onedrive-client-credentials Use client credentials OAuth flow --onedrive-client-id string OAuth Client Id --onedrive-client-secret string OAuth Client Secret --onedrive-delta If set rclone will use delta listing to implement recursive listings --onedrive-description string Description of the remote --onedrive-drive-id string The ID of the drive to use --onedrive-drive-type string The type of the drive (personal | business | documentLibrary) --onedrive-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,LeftSpace,LeftTilde,RightSpace,RightPeriod,InvalidUtf8,Dot) --onedrive-expose-onenote-files Set to make OneNote files show up in directory listings --onedrive-hard-delete Permanently delete files on removal --onedrive-hash-type string Specify the hash in use for the backend (default "auto") --onedrive-link-password string Set the password for links created by the link command --onedrive-link-scope string Set the scope of the links created by the link command (default "anonymous") --onedrive-link-type string Set the type of the links created by the link command (default "view") --onedrive-list-chunk int Size of listing chunk (default 1000) --onedrive-metadata-permissions Bits Control whether permissions should be read or written in metadata (default off) --onedrive-no-versions Remove all versions on modifying operations --onedrive-region string Choose national cloud region for OneDrive (default "global") --onedrive-root-folder-id string ID of the root folder --onedrive-server-side-across-configs Deprecated: use --server-side-across-configs instead --onedrive-tenant string ID of the service principal's tenant. Also called its directory ID --onedrive-token string OAuth Access Token as a JSON blob --onedrive-token-url string Token server url --onedrive-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default off) --oos-attempt-resume-upload If true attempt to resume previously started multipart upload for the object --oos-chunk-size SizeSuffix Chunk size to use for uploading (default 5Mi) --oos-compartment string Specify compartment OCID, if you need to list buckets --oos-config-file string Path to OCI config file (default "~/.oci/config") --oos-config-profile string Profile name inside the oci config file (default "Default") --oos-copy-cutoff SizeSuffix Cutoff for switching to multipart copy (default 4.656Gi) --oos-copy-timeout Duration Timeout for copy (default 1m0s) --oos-description string Description of the remote --oos-disable-checksum Don't store MD5 checksum with object metadata --oos-encoding Encoding The encoding for the backend (default Slash,InvalidUtf8,Dot) --oos-endpoint string Endpoint for Object storage API --oos-leave-parts-on-error If true avoid calling abort upload on a failure, leaving all successfully uploaded parts for manual recovery --oos-max-upload-parts int Maximum number of parts in a multipart upload (default 10000) --oos-namespace string Object storage namespace --oos-no-check-bucket If set, don't attempt to check the bucket exists or create it --oos-provider string Choose your Auth Provider (default "env_auth") --oos-region string Object storage Region --oos-sse-customer-algorithm string If using SSE-C, the optional header that specifies "AES256" as the encryption algorithm --oos-sse-customer-key string To use SSE-C, the optional header that specifies the base64-encoded 256-bit encryption key to use to --oos-sse-customer-key-file string To use SSE-C, a file containing the base64-encoded string of the AES-256 encryption key associated --oos-sse-customer-key-sha256 string If using SSE-C, The optional header that specifies the base64-encoded SHA256 hash of the encryption --oos-sse-kms-key-id string if using your own master key in vault, this header specifies the --oos-storage-tier string The storage class to use when storing new objects in storage. https://docs.oracle.com/en-us/iaas/Content/Object/Concepts/understandingstoragetiers.htm (default "Standard") --oos-upload-concurrency int Concurrency for multipart uploads (default 10) --oos-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default 200Mi) --opendrive-access string Files and folders will be uploaded with this access permission (default private) (default "private") --opendrive-chunk-size SizeSuffix Files will be uploaded in chunks this size (default 10Mi) --opendrive-description string Description of the remote --opendrive-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,LeftSpace,LeftCrLfHtVt,RightSpace,RightCrLfHtVt,InvalidUtf8,Dot) --opendrive-password string Password (obscured) --opendrive-username string Username --pcloud-auth-url string Auth server URL --pcloud-client-credentials Use client credentials OAuth flow --pcloud-client-id string OAuth Client Id --pcloud-client-secret string OAuth Client Secret --pcloud-description string Description of the remote --pcloud-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --pcloud-hostname string Hostname to connect to (default "api.pcloud.com") --pcloud-password string Your pcloud password (obscured) --pcloud-root-folder-id string Fill in for rclone to use a non root folder as its starting point (default "d0") --pcloud-token string OAuth Access Token as a JSON blob --pcloud-token-url string Token server url --pcloud-username string Your pcloud username --pikpak-chunk-size SizeSuffix Chunk size for multipart uploads (default 5Mi) --pikpak-description string Description of the remote --pikpak-device-id string Device ID used for authorization --pikpak-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,LeftSpace,RightSpace,RightPeriod,InvalidUtf8,Dot) --pikpak-hash-memory-limit SizeSuffix Files bigger than this will be cached on disk to calculate hash if required (default 10Mi) --pikpak-no-media-link Use original file links instead of media links --pikpak-pass string Pikpak password (obscured) --pikpak-root-folder-id string ID of the root folder --pikpak-trashed-only Only show files that are in the trash --pikpak-upload-concurrency int Concurrency for multipart uploads (default 4) --pikpak-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default 200Mi) --pikpak-use-trash Send files to the trash instead of deleting permanently (default true) --pikpak-user string Pikpak username --pikpak-user-agent string HTTP user agent for pikpak (default "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:129.0) Gecko/20100101 Firefox/129.0") --pixeldrain-api-key string API key for your pixeldrain account --pixeldrain-api-url string The API endpoint to connect to. In the vast majority of cases it's fine to leave (default "https://pixeldrain.com/api") --pixeldrain-description string Description of the remote --pixeldrain-root-folder-id string Root of the filesystem to use (default "me") --premiumizeme-auth-url string Auth server URL --premiumizeme-client-credentials Use client credentials OAuth flow --premiumizeme-client-id string OAuth Client Id --premiumizeme-client-secret string OAuth Client Secret --premiumizeme-description string Description of the remote --premiumizeme-encoding Encoding The encoding for the backend (default Slash,DoubleQuote,BackSlash,Del,Ctl,InvalidUtf8,Dot) --premiumizeme-token string OAuth Access Token as a JSON blob --premiumizeme-token-url string Token server url --protondrive-2fa string The 2FA code --protondrive-app-version string The app version string (default "macos-drive@1.0.0-alpha.1+rclone") --protondrive-description string Description of the remote --protondrive-enable-caching Caches the files and folders metadata to reduce API calls (default true) --protondrive-encoding Encoding The encoding for the backend (default Slash,LeftSpace,RightSpace,InvalidUtf8,Dot) --protondrive-mailbox-password string The mailbox password of your two-password proton account (obscured) --protondrive-original-file-size Return the file size before encryption (default true) --protondrive-password string The password of your proton account (obscured) --protondrive-replace-existing-draft Create a new revision when filename conflict is detected --protondrive-username string The username of your proton account --putio-auth-url string Auth server URL --putio-client-credentials Use client credentials OAuth flow --putio-client-id string OAuth Client Id --putio-client-secret string OAuth Client Secret --putio-description string Description of the remote --putio-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --putio-token string OAuth Access Token as a JSON blob --putio-token-url string Token server url --qingstor-access-key-id string QingStor Access Key ID --qingstor-chunk-size SizeSuffix Chunk size to use for uploading (default 4Mi) --qingstor-connection-retries int Number of connection retries (default 3) --qingstor-description string Description of the remote --qingstor-encoding Encoding The encoding for the backend (default Slash,Ctl,InvalidUtf8) --qingstor-endpoint string Enter an endpoint URL to connection QingStor API --qingstor-env-auth Get QingStor credentials from runtime --qingstor-secret-access-key string QingStor Secret Access Key (password) --qingstor-upload-concurrency int Concurrency for multipart uploads (default 1) --qingstor-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default 200Mi) --qingstor-zone string Zone to connect to --quatrix-api-key string API key for accessing Quatrix account --quatrix-description string Description of the remote --quatrix-effective-upload-time string Wanted upload time for one chunk (default "4s") --quatrix-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --quatrix-hard-delete Delete files permanently rather than putting them into the trash --quatrix-host string Host name of Quatrix account --quatrix-maximal-summary-chunk-size SizeSuffix The maximal summary for all chunks. It should not be less than 'transfers'*'minimal_chunk_size' (default 95.367Mi) --quatrix-minimal-chunk-size SizeSuffix The minimal size for one chunk (default 9.537Mi) --quatrix-skip-project-folders Skip project folders in operations --s3-access-key-id string AWS Access Key ID --s3-acl string Canned ACL used when creating buckets and storing or copying objects --s3-bucket-acl string Canned ACL used when creating buckets --s3-chunk-size SizeSuffix Chunk size to use for uploading (default 5Mi) --s3-copy-cutoff SizeSuffix Cutoff for switching to multipart copy (default 4.656Gi) --s3-decompress If set this will decompress gzip encoded objects --s3-description string Description of the remote --s3-directory-bucket Set to use AWS Directory Buckets --s3-directory-markers Upload an empty object with a trailing slash when a new directory is created --s3-disable-checksum Don't store MD5 checksum with object metadata --s3-disable-http2 Disable usage of http2 for S3 backends --s3-download-url string Custom endpoint for downloads --s3-encoding Encoding The encoding for the backend (default Slash,InvalidUtf8,Dot) --s3-endpoint string Endpoint for S3 API --s3-env-auth Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars) --s3-force-path-style If true use path style access if false use virtual hosted style (default true) --s3-ibm-api-key string IBM API Key to be used to obtain IAM token --s3-ibm-resource-instance-id string IBM service instance id --s3-leave-parts-on-error If true avoid calling abort upload on a failure, leaving all successfully uploaded parts on S3 for manual recovery --s3-list-chunk int Size of listing chunk (response list for each ListObject S3 request) (default 1000) --s3-list-url-encode Tristate Whether to url encode listings: true/false/unset (default unset) --s3-list-version int Version of ListObjects to use: 1,2 or 0 for auto --s3-location-constraint string Location constraint - must be set to match the Region --s3-max-upload-parts int Maximum number of parts in a multipart upload (default 10000) --s3-might-gzip Tristate Set this if the backend might gzip objects (default unset) --s3-no-check-bucket If set, don't attempt to check the bucket exists or create it --s3-no-head If set, don't HEAD uploaded objects to check integrity --s3-no-head-object If set, do not do HEAD before GET when getting objects --s3-no-system-metadata Suppress setting and reading of system metadata --s3-profile string Profile to use in the shared credentials file --s3-provider string Choose your S3 provider --s3-region string Region to connect to --s3-requester-pays Enables requester pays option when interacting with S3 bucket --s3-sdk-log-mode Bits Set to debug the SDK (default Off) --s3-secret-access-key string AWS Secret Access Key (password) --s3-server-side-encryption string The server-side encryption algorithm used when storing this object in S3 --s3-session-token string An AWS session token --s3-shared-credentials-file string Path to the shared credentials file --s3-sign-accept-encoding Tristate Set if rclone should include Accept-Encoding as part of the signature (default unset) --s3-sse-customer-algorithm string If using SSE-C, the server-side encryption algorithm used when storing this object in S3 --s3-sse-customer-key string To use SSE-C you may provide the secret encryption key used to encrypt/decrypt your data --s3-sse-customer-key-base64 string If using SSE-C you must provide the secret encryption key encoded in base64 format to encrypt/decrypt your data --s3-sse-customer-key-md5 string If using SSE-C you may provide the secret encryption key MD5 checksum (optional) --s3-sse-kms-key-id string If using KMS ID you must provide the ARN of Key --s3-storage-class string The storage class to use when storing new objects in S3 --s3-upload-concurrency int Concurrency for multipart uploads and copies (default 4) --s3-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default 200Mi) --s3-use-accelerate-endpoint If true use the AWS S3 accelerated endpoint --s3-use-accept-encoding-gzip Accept-Encoding: gzip Whether to send Accept-Encoding: gzip header (default unset) --s3-use-already-exists Tristate Set if rclone should report BucketAlreadyExists errors on bucket creation (default unset) --s3-use-arn-region If true, enables arn region support for the service --s3-use-dual-stack If true use AWS S3 dual-stack endpoint (IPv6 support) --s3-use-multipart-etag Tristate Whether to use ETag in multipart uploads for verification (default unset) --s3-use-multipart-uploads Tristate Set if rclone should use multipart uploads (default unset) --s3-use-presigned-request Whether to use a presigned request or PutObject for single part uploads --s3-use-unsigned-payload Tristate Whether to use an unsigned payload in PutObject (default unset) --s3-use-x-id Tristate Set if rclone should add x-id URL parameters (default unset) --s3-v2-auth If true use v2 authentication --s3-version-at Time Show file versions as they were at the specified time (default off) --s3-version-deleted Show deleted file markers when using versions --s3-versions Include old versions in directory listings --seafile-2fa Two-factor authentication ('true' if the account has 2FA enabled) --seafile-create-library Should rclone create a library if it doesn't exist --seafile-description string Description of the remote --seafile-encoding Encoding The encoding for the backend (default Slash,DoubleQuote,BackSlash,Ctl,InvalidUtf8,Dot) --seafile-library string Name of the library --seafile-library-key string Library password (for encrypted libraries only) (obscured) --seafile-pass string Password (obscured) --seafile-url string URL of seafile host to connect to --seafile-user string User name (usually email address) --sftp-ask-password Allow asking for SFTP password when needed --sftp-blake3sum-command string The command used to read BLAKE3 hashes --sftp-chunk-size SizeSuffix Upload and download chunk size (default 32Ki) --sftp-ciphers SpaceSepList Space separated list of ciphers to be used for session encryption, ordered by preference --sftp-concurrency int The maximum number of outstanding requests for one file (default 64) --sftp-connections int Maximum number of SFTP simultaneous connections, 0 for unlimited --sftp-copy-is-hardlink Set to enable server side copies using hardlinks --sftp-crc32sum-command string The command used to read CRC-32 hashes --sftp-description string Description of the remote --sftp-disable-concurrent-reads If set don't use concurrent reads --sftp-disable-concurrent-writes If set don't use concurrent writes --sftp-disable-hashcheck Disable the execution of SSH commands to determine if remote file hashing is available --sftp-hashes CommaSepList Comma separated list of supported checksum types --sftp-host string SSH host to connect to --sftp-host-key-algorithms SpaceSepList Space separated list of host key algorithms, ordered by preference --sftp-http-proxy string URL for HTTP CONNECT proxy --sftp-idle-timeout Duration Max time before closing idle connections (default 1m0s) --sftp-key-exchange SpaceSepList Space separated list of key exchange algorithms, ordered by preference --sftp-key-file string Path to PEM-encoded private key file --sftp-key-file-pass string The passphrase to decrypt the PEM-encoded private key file (obscured) --sftp-key-pem string Raw PEM-encoded private key --sftp-key-use-agent When set forces the usage of the ssh-agent --sftp-known-hosts-file string Optional path to known_hosts file --sftp-macs SpaceSepList Space separated list of MACs (message authentication code) algorithms, ordered by preference --sftp-md5sum-command string The command used to read MD5 hashes --sftp-pass string SSH password, leave blank to use ssh-agent (obscured) --sftp-path-override string Override path used by SSH shell commands --sftp-port int SSH port number (default 22) --sftp-pubkey string SSH public certificate for public certificate based authentication --sftp-pubkey-file string Optional path to public key file --sftp-server-command string Specifies the path or command to run a sftp server on the remote host --sftp-set-env SpaceSepList Environment variables to pass to sftp and commands --sftp-set-modtime Set the modified time on the remote if set (default true) --sftp-sha1sum-command string The command used to read SHA-1 hashes --sftp-sha256sum-command string The command used to read SHA-256 hashes --sftp-shell-type string The type of SSH shell on remote server, if any --sftp-skip-links Set to skip any symlinks and any other non regular files --sftp-socks-proxy string Socks 5 proxy host --sftp-ssh SpaceSepList Path and arguments to external ssh binary --sftp-subsystem string Specifies the SSH2 subsystem on the remote host (default "sftp") --sftp-use-fstat If set use fstat instead of stat --sftp-use-insecure-cipher Enable the use of insecure ciphers and key exchange methods --sftp-user string SSH username (default "$USER") --sftp-xxh128sum-command string The command used to read XXH128 hashes --sftp-xxh3sum-command string The command used to read XXH3 hashes --sharefile-auth-url string Auth server URL --sharefile-chunk-size SizeSuffix Upload chunk size (default 64Mi) --sharefile-client-credentials Use client credentials OAuth flow --sharefile-client-id string OAuth Client Id --sharefile-client-secret string OAuth Client Secret --sharefile-description string Description of the remote --sharefile-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,LeftSpace,LeftPeriod,RightSpace,RightPeriod,InvalidUtf8,Dot) --sharefile-endpoint string Endpoint for API calls --sharefile-root-folder-id string ID of the root folder --sharefile-token string OAuth Access Token as a JSON blob --sharefile-token-url string Token server url --sharefile-upload-cutoff SizeSuffix Cutoff for switching to multipart upload (default 128Mi) --sia-api-password string Sia Daemon API Password (obscured) --sia-api-url string Sia daemon API URL, like http://sia.daemon.host:9980 (default "http://127.0.0.1:9980") --sia-description string Description of the remote --sia-encoding Encoding The encoding for the backend (default Slash,Question,Hash,Percent,Del,Ctl,InvalidUtf8,Dot) --sia-user-agent string Siad User Agent (default "Sia-Agent") --skip-links Don't warn about skipped symlinks --smb-case-insensitive Whether the server is configured to be case-insensitive (default true) --smb-description string Description of the remote --smb-domain string Domain name for NTLM authentication (default "WORKGROUP") --smb-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot) --smb-hide-special-share Hide special shares (e.g. print$) which users aren't supposed to access (default true) --smb-host string SMB server hostname to connect to --smb-idle-timeout Duration Max time before closing idle connections (default 1m0s) --smb-kerberos-ccache string Path to the Kerberos credential cache (krb5cc) --smb-pass string SMB password (obscured) --smb-port int SMB port number (default 445) --smb-spn string Service principal name --smb-use-kerberos Use Kerberos authentication --smb-user string SMB username (default "$USER") --storj-access-grant string Access grant --storj-api-key string API key --storj-description string Description of the remote --storj-passphrase string Encryption passphrase --storj-provider string Choose an authentication method (default "existing") --storj-satellite-address string Satellite address (default "us1.storj.io") --sugarsync-access-key-id string Sugarsync Access Key ID --sugarsync-app-id string Sugarsync App ID --sugarsync-authorization string Sugarsync authorization --sugarsync-authorization-expiry string Sugarsync authorization expiry --sugarsync-deleted-id string Sugarsync deleted folder id --sugarsync-description string Description of the remote --sugarsync-encoding Encoding The encoding for the backend (default Slash,Ctl,InvalidUtf8,Dot) --sugarsync-hard-delete Permanently delete files if true --sugarsync-private-access-key string Sugarsync Private Access Key --sugarsync-refresh-token string Sugarsync refresh token --sugarsync-root-id string Sugarsync root id --sugarsync-user string Sugarsync user --swift-application-credential-id string Application Credential ID (OS_APPLICATION_CREDENTIAL_ID) --swift-application-credential-name string Application Credential Name (OS_APPLICATION_CREDENTIAL_NAME) --swift-application-credential-secret string Application Credential Secret (OS_APPLICATION_CREDENTIAL_SECRET) --swift-auth string Authentication URL for server (OS_AUTH_URL) --swift-auth-token string Auth Token from alternate authentication - optional (OS_AUTH_TOKEN) --swift-auth-version int AuthVersion - optional - set to (1,2,3) if your auth URL has no version (ST_AUTH_VERSION) --swift-chunk-size SizeSuffix Above this size files will be chunked (default 5Gi) --swift-description string Description of the remote --swift-domain string User domain - optional (v3 auth) (OS_USER_DOMAIN_NAME) --swift-encoding Encoding The encoding for the backend (default Slash,InvalidUtf8) --swift-endpoint-type string Endpoint type to choose from the service catalogue (OS_ENDPOINT_TYPE) (default "public") --swift-env-auth Get swift credentials from environment variables in standard OpenStack form --swift-fetch-until-empty-page When paginating, always fetch unless we received an empty page --swift-key string API key or password (OS_PASSWORD) --swift-leave-parts-on-error If true avoid calling abort upload on a failure --swift-no-chunk Don't chunk files during streaming upload --swift-no-large-objects Disable support for static and dynamic large objects --swift-partial-page-fetch-threshold int When paginating, fetch if the current page is within this percentage of the limit --swift-region string Region name - optional (OS_REGION_NAME) --swift-storage-policy string The storage policy to use when creating a new container --swift-storage-url string Storage URL - optional (OS_STORAGE_URL) --swift-tenant string Tenant name - optional for v1 auth, this or tenant_id required otherwise (OS_TENANT_NAME or OS_PROJECT_NAME) --swift-tenant-domain string Tenant domain - optional (v3 auth) (OS_PROJECT_DOMAIN_NAME) --swift-tenant-id string Tenant ID - optional for v1 auth, this or tenant required otherwise (OS_TENANT_ID) --swift-use-segments-container Tristate Choose destination for large object segments (default unset) --swift-user string User name to log in (OS_USERNAME) --swift-user-id string User ID to log in - optional - most swift systems use user and leave this blank (v3 auth) (OS_USER_ID) --ulozto-app-token string The application token identifying the app. An app API key can be either found in the API --ulozto-description string Description of the remote --ulozto-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --ulozto-list-page-size int The size of a single page for list commands. 1-500 (default 500) --ulozto-password string The password for the user (obscured) --ulozto-root-folder-slug string If set, rclone will use this folder as the root folder for all operations. For example, --ulozto-username string The username of the principal to operate as --union-action-policy string Policy to choose upstream on ACTION category (default "epall") --union-cache-time int Cache time of usage and free space (in seconds) (default 120) --union-create-policy string Policy to choose upstream on CREATE category (default "epmfs") --union-description string Description of the remote --union-min-free-space SizeSuffix Minimum viable free space for lfs/eplfs policies (default 1Gi) --union-search-policy string Policy to choose upstream on SEARCH category (default "ff") --union-upstreams string List of space separated upstreams --uptobox-access-token string Your access token --uptobox-description string Description of the remote --uptobox-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,BackQuote,Del,Ctl,LeftSpace,InvalidUtf8,Dot) --uptobox-private Set to make uploaded files private --webdav-auth-redirect Preserve authentication on redirect --webdav-bearer-token string Bearer token instead of user/pass (e.g. a Macaroon) --webdav-bearer-token-command string Command to run to get a bearer token --webdav-description string Description of the remote --webdav-encoding string The encoding for the backend --webdav-headers CommaSepList Set HTTP headers for all transactions --webdav-nextcloud-chunk-size SizeSuffix Nextcloud upload chunk size (default 10Mi) --webdav-owncloud-exclude-mounts Exclude ownCloud mounted storages --webdav-owncloud-exclude-shares Exclude ownCloud shares --webdav-pacer-min-sleep Duration Minimum time to sleep between API calls (default 10ms) --webdav-pass string Password (obscured) --webdav-unix-socket string Path to a unix domain socket to dial to, instead of opening a TCP connection directly --webdav-url string URL of http host to connect to --webdav-user string User name --webdav-vendor string Name of the WebDAV site/service/software you are using --yandex-auth-url string Auth server URL --yandex-client-credentials Use client credentials OAuth flow --yandex-client-id string OAuth Client Id --yandex-client-secret string OAuth Client Secret --yandex-description string Description of the remote --yandex-encoding Encoding The encoding for the backend (default Slash,Del,Ctl,InvalidUtf8,Dot) --yandex-hard-delete Delete files permanently rather than putting them into the trash --yandex-spoof-ua Set the user agent to match an official version of the yandex disk client. May help with upload performance (default true) --yandex-token string OAuth Access Token as a JSON blob --yandex-token-url string Token server url --zoho-auth-url string Auth server URL --zoho-client-credentials Use client credentials OAuth flow --zoho-client-id string OAuth Client Id --zoho-client-secret string OAuth Client Secret --zoho-description string Description of the remote --zoho-encoding Encoding The encoding for the backend (default Del,Ctl,InvalidUtf8) --zoho-region string Zoho region to connect to --zoho-token string OAuth Access Token as a JSON blob --zoho-token-url string Token server url --zoho-upload-cutoff SizeSuffix Cutoff for switching to large file upload api (>= 10 MiB) (default 10Mi) ``` # Docker Volume Plugin ## Introduction Docker 1.9 has added support for creating [named volumes](https://docs.docker.com/storage/volumes/) via [command-line interface](https://docs.docker.com/engine/reference/commandline/volume_create/) and mounting them in containers as a way to share data between them. Since Docker 1.10 you can create named volumes with [Docker Compose](https://docs.docker.com/compose/) by descriptions in [docker-compose.yml](https://docs.docker.com/compose/compose-file/compose-file-v2/#volume-configuration-reference) files for use by container groups on a single host. As of Docker 1.12 volumes are supported by [Docker Swarm](https://docs.docker.com/engine/swarm/key-concepts/) included with Docker Engine and created from descriptions in [swarm compose v3](https://docs.docker.com/compose/compose-file/compose-file-v3/#volume-configuration-reference) files for use with _swarm stacks_ across multiple cluster nodes. [Docker Volume Plugins](https://docs.docker.com/engine/extend/plugins_volume/) augment the default `local` volume driver included in Docker with stateful volumes shared across containers and hosts. Unlike local volumes, your data will _not_ be deleted when such volume is removed. Plugins can run managed by the docker daemon, as a native system service (under systemd, _sysv_ or _upstart_) or as a standalone executable. Rclone can run as docker volume plugin in all these modes. It interacts with the local docker daemon via [plugin API](https://docs.docker.com/engine/extend/plugin_api/) and handles mounting of remote file systems into docker containers so it must run on the same host as the docker daemon or on every Swarm node. ## Getting started In the first example we will use the [SFTP](https://rclone.org/sftp/) rclone volume with Docker engine on a standalone Ubuntu machine. Start from [installing Docker](https://docs.docker.com/engine/install/) on the host. The _FUSE_ driver is a prerequisite for rclone mounting and should be installed on host: ``` sudo apt-get -y install fuse3 ``` Create two directories required by rclone docker plugin: ``` sudo mkdir -p /var/lib/docker-plugins/rclone/config sudo mkdir -p /var/lib/docker-plugins/rclone/cache ``` Install the managed rclone docker plugin for your architecture (here `amd64`): ``` docker plugin install rclone/docker-volume-rclone:amd64 args="-v" --alias rclone --grant-all-permissions docker plugin list ``` Create your [SFTP volume](https://rclone.org/sftp/#standard-options): ``` docker volume create firstvolume -d rclone -o type=sftp -o sftp-host=_hostname_ -o sftp-user=_username_ -o sftp-pass=_password_ -o allow-other=true ``` Note that since all options are static, you don't even have to run `rclone config` or create the `rclone.conf` file (but the `config` directory should still be present). In the simplest case you can use `localhost` as _hostname_ and your SSH credentials as _username_ and _password_. You can also change the remote path to your home directory on the host, for example `-o path=/home/username`. Time to create a test container and mount the volume into it: ``` docker run --rm -it -v firstvolume:/mnt --workdir /mnt ubuntu:latest bash ``` If all goes well, you will enter the new container and change right to the mounted SFTP remote. You can type `ls` to list the mounted directory or otherwise play with it. Type `exit` when you are done. The container will stop but the volume will stay, ready to be reused. When it's not needed anymore, remove it: ``` docker volume list docker volume remove firstvolume ``` Now let us try **something more elaborate**: [Google Drive](https://rclone.org/drive/) volume on multi-node Docker Swarm. You should start from installing Docker and FUSE, creating plugin directories and installing rclone plugin on _every_ swarm node. Then [setup the Swarm](https://docs.docker.com/engine/swarm/swarm-mode/). Google Drive volumes need an access token which can be setup via web browser and will be periodically renewed by rclone. The managed plugin cannot run a browser so we will use a technique similar to the [rclone setup on a headless box](https://rclone.org/remote_setup/). Run [rclone config](https://rclone.org/commands/rclone_config_create/) on _another_ machine equipped with _web browser_ and graphical user interface. Create the [Google Drive remote](https://rclone.org/drive/#standard-options). When done, transfer the resulting `rclone.conf` to the Swarm cluster and save as `/var/lib/docker-plugins/rclone/config/rclone.conf` on _every_ node. By default this location is accessible only to the root user so you will need appropriate privileges. The resulting config will look like this: ``` [gdrive] type = drive scope = drive drive_id = 1234567... root_folder_id = 0Abcd... token = {"access_token":...} ``` Now create the file named `example.yml` with a swarm stack description like this: ``` version: '3' services: heimdall: image: linuxserver/heimdall:latest ports: [8080:80] volumes: [configdata:/config] volumes: configdata: driver: rclone driver_opts: remote: 'gdrive:heimdall' allow_other: 'true' vfs_cache_mode: full poll_interval: 0 ``` and run the stack: ``` docker stack deploy example -c ./example.yml ``` After a few seconds docker will spread the parsed stack description over cluster, create the `example_heimdall` service on port _8080_, run service containers on one or more cluster nodes and request the `example_configdata` volume from rclone plugins on the node hosts. You can use the following commands to confirm results: ``` docker service ls docker service ps example_heimdall docker volume ls ``` Point your browser to `http://cluster.host.address:8080` and play with the service. Stop it with `docker stack remove example` when you are done. Note that the `example_configdata` volume(s) created on demand at the cluster nodes will not be automatically removed together with the stack but stay for future reuse. You can remove them manually by invoking the `docker volume remove example_configdata` command on every node. ## Creating Volumes via CLI Volumes can be created with [docker volume create](https://docs.docker.com/engine/reference/commandline/volume_create/). Here are a few examples: ``` docker volume create vol1 -d rclone -o remote=storj: -o vfs-cache-mode=full docker volume create vol2 -d rclone -o remote=:storj,access_grant=xxx:heimdall docker volume create vol3 -d rclone -o type=storj -o path=heimdall -o storj-access-grant=xxx -o poll-interval=0 ``` Note the `-d rclone` flag that tells docker to request volume from the rclone driver. This works even if you installed managed driver by its full name `rclone/docker-volume-rclone` because you provided the `--alias rclone` option. Volumes can be inspected as follows: ``` docker volume list docker volume inspect vol1 ``` ## Volume Configuration Rclone flags and volume options are set via the `-o` flag to the `docker volume create` command. They include backend-specific parameters as well as mount and _VFS_ options. Also there are a few special `-o` options: `remote`, `fs`, `type`, `path`, `mount-type` and `persist`. `remote` determines an existing remote name from the config file, with trailing colon and optionally with a remote path. See the full syntax in the [rclone documentation](https://rclone.org/docs/#syntax-of-remote-paths). This option can be aliased as `fs` to prevent confusion with the _remote_ parameter of such backends as _crypt_ or _alias_. The `remote=:backend:dir/subdir` syntax can be used to create [on-the-fly (config-less) remotes](https://rclone.org/docs/#backend-path-to-dir), while the `type` and `path` options provide a simpler alternative for this. Using two split options ``` -o type=backend -o path=dir/subdir ``` is equivalent to the combined syntax ``` -o remote=:backend:dir/subdir ``` but is arguably easier to parameterize in scripts. The `path` part is optional. [Mount and VFS options](https://rclone.org/commands/rclone_serve_docker/#options) as well as [backend parameters](https://rclone.org/flags/#backend) are named like their twin command-line flags without the `--` CLI prefix. Optionally you can use underscores instead of dashes in option names. For example, `--vfs-cache-mode full` becomes `-o vfs-cache-mode=full` or `-o vfs_cache_mode=full`. Boolean CLI flags without value will gain the `true` value, e.g. `--allow-other` becomes `-o allow-other=true` or `-o allow_other=true`. Please note that you can provide parameters only for the backend immediately referenced by the backend type of mounted `remote`. If this is a wrapping backend like _alias, chunker or crypt_, you cannot provide options for the referred to remote or backend. This limitation is imposed by the rclone connection string parser. The only workaround is to feed plugin with `rclone.conf` or configure plugin arguments (see below). ## Special Volume Options `mount-type` determines the mount method and in general can be one of: `mount`, `cmount`, or `mount2`. This can be aliased as `mount_type`. It should be noted that the managed rclone docker plugin currently does not support the `cmount` method and `mount2` is rarely needed. This option defaults to the first found method, which is usually `mount` so you generally won't need it. `persist` is a reserved boolean (true/false) option. In future it will allow to persist on-the-fly remotes in the plugin `rclone.conf` file. ## Connection Strings The `remote` value can be extended with [connection strings](https://rclone.org/docs/#connection-strings) as an alternative way to supply backend parameters. This is equivalent to the `-o` backend options with one _syntactic difference_. Inside connection string the backend prefix must be dropped from parameter names but in the `-o param=value` array it must be present. For instance, compare the following option array ``` -o remote=:sftp:/home -o sftp-host=localhost ``` with equivalent connection string: ``` -o remote=:sftp,host=localhost:/home ``` This difference exists because flag options `-o key=val` include not only backend parameters but also mount/VFS flags and possibly other settings. Also it allows to discriminate the `remote` option from the `crypt-remote` (or similarly named backend parameters) and arguably simplifies scripting due to clearer value substitution. ## Using with Swarm or Compose Both _Docker Swarm_ and _Docker Compose_ use [YAML](http://yaml.org/spec/1.2/spec.html)-formatted text files to describe groups (stacks) of containers, their properties, networks and volumes. _Compose_ uses the [compose v2](https://docs.docker.com/compose/compose-file/compose-file-v2/#volume-configuration-reference) format, _Swarm_ uses the [compose v3](https://docs.docker.com/compose/compose-file/compose-file-v3/#volume-configuration-reference) format. They are mostly similar, differences are explained in the [docker documentation](https://docs.docker.com/compose/compose-file/compose-versioning/#upgrading). Volumes are described by the children of the top-level `volumes:` node. Each of them should be named after its volume and have at least two elements, the self-explanatory `driver: rclone` value and the `driver_opts:` structure playing the same role as `-o key=val` CLI flags: ``` volumes: volume_name_1: driver: rclone driver_opts: remote: 'gdrive:' allow_other: 'true' vfs_cache_mode: full token: '{"type": "borrower", "expires": "2021-12-31"}' poll_interval: 0 ``` Notice a few important details: - YAML prefers `_` in option names instead of `-`. - YAML treats single and double quotes interchangeably. Simple strings and integers can be left unquoted. - Boolean values must be quoted like `'true'` or `"false"` because these two words are reserved by YAML. - The filesystem string is keyed with `remote` (or with `fs`). Normally you can omit quotes here, but if the string ends with colon, you **must** quote it like `remote: "storage_box:"`. - YAML is picky about surrounding braces in values as this is in fact another [syntax for key/value mappings](http://yaml.org/spec/1.2/spec.html#id2790832). For example, JSON access tokens usually contain double quotes and surrounding braces, so you must put them in single quotes. ## Installing as Managed Plugin Docker daemon can install plugins from an image registry and run them managed. We maintain the [docker-volume-rclone](https://hub.docker.com/p/rclone/docker-volume-rclone/) plugin image on [Docker Hub](https://hub.docker.com). Rclone volume plugin requires **Docker Engine >= 19.03.15** The plugin requires presence of two directories on the host before it can be installed. Note that plugin will **not** create them automatically. By default they must exist on host at the following locations (though you can tweak the paths): - `/var/lib/docker-plugins/rclone/config` is reserved for the `rclone.conf` config file and **must** exist even if it's empty and the config file is not present. - `/var/lib/docker-plugins/rclone/cache` holds the plugin state file as well as optional VFS caches. You can [install managed plugin](https://docs.docker.com/engine/reference/commandline/plugin_install/) with default settings as follows: ``` docker plugin install rclone/docker-volume-rclone:amd64 --grant-all-permissions --alias rclone ``` The `:amd64` part of the image specification after colon is called a _tag_. Usually you will want to install the latest plugin for your architecture. In this case the tag will just name it, like `amd64` above. The following plugin architectures are currently available: - `amd64` - `arm64` - `arm-v7` Sometimes you might want a concrete plugin version, not the latest one. Then you should use image tag in the form `:ARCHITECTURE-VERSION`. For example, to install plugin version `v1.56.2` on architecture `arm64` you will use tag `arm64-1.56.2` (note the removed `v`) so the full image specification becomes `rclone/docker-volume-rclone:arm64-1.56.2`. We also provide the `latest` plugin tag, but since docker does not support multi-architecture plugins as of the time of this writing, this tag is currently an **alias for `amd64`**. By convention the `latest` tag is the default one and can be omitted, thus both `rclone/docker-volume-rclone:latest` and just `rclone/docker-volume-rclone` will refer to the latest plugin release for the `amd64` platform. Also the `amd64` part can be omitted from the versioned rclone plugin tags. For example, rclone image reference `rclone/docker-volume-rclone:amd64-1.56.2` can be abbreviated as `rclone/docker-volume-rclone:1.56.2` for convenience. However, for non-intel architectures you still have to use the full tag as `amd64` or `latest` will fail to start. Managed plugin is in fact a special container running in a namespace separate from normal docker containers. Inside it runs the `rclone serve docker` command. The config and cache directories are bind-mounted into the container at start. The docker daemon connects to a unix socket created by the command inside the container. The command creates on-demand remote mounts right inside, then docker machinery propagates them through kernel mount namespaces and bind-mounts into requesting user containers. You can tweak a few plugin settings after installation when it's disabled (not in use), for instance: ``` docker plugin disable rclone docker plugin set rclone RCLONE_VERBOSE=2 config=/etc/rclone args="--vfs-cache-mode=writes --allow-other" docker plugin enable rclone docker plugin inspect rclone ``` Note that if docker refuses to disable the plugin, you should find and remove all active volumes connected with it as well as containers and swarm services that use them. This is rather tedious so please carefully plan in advance. You can tweak the following settings: `args`, `config`, `cache`, `HTTP_PROXY`, `HTTPS_PROXY`, `NO_PROXY` and `RCLONE_VERBOSE`. It's _your_ task to keep plugin settings in sync across swarm cluster nodes. `args` sets command-line arguments for the `rclone serve docker` command (_none_ by default). Arguments should be separated by space so you will normally want to put them in quotes on the [docker plugin set](https://docs.docker.com/engine/reference/commandline/plugin_set/) command line. Both [serve docker flags](https://rclone.org/commands/rclone_serve_docker/#options) and [generic rclone flags](https://rclone.org/flags/) are supported, including backend parameters that will be used as defaults for volume creation. Note that plugin will fail (due to [this docker bug](https://github.com/moby/moby/blob/v20.10.7/plugin/v2/plugin.go#L195)) if the `args` value is empty. Use e.g. `args="-v"` as a workaround. `config=/host/dir` sets alternative host location for the config directory. Plugin will look for `rclone.conf` here. It's not an error if the config file is not present but the directory must exist. Please note that plugin can periodically rewrite the config file, for example when it renews storage access tokens. Keep this in mind and try to avoid races between the plugin and other instances of rclone on the host that might try to change the config simultaneously resulting in corrupted `rclone.conf`. You can also put stuff like private key files for SFTP remotes in this directory. Just note that it's bind-mounted inside the plugin container at the predefined path `/data/config`. For example, if your key file is named `sftp-box1.key` on the host, the corresponding volume config option should read `-o sftp-key-file=/data/config/sftp-box1.key`. `cache=/host/dir` sets alternative host location for the _cache_ directory. The plugin will keep VFS caches here. Also it will create and maintain the `docker-plugin.state` file in this directory. When the plugin is restarted or reinstalled, it will look in this file to recreate any volumes that existed previously. However, they will not be re-mounted into consuming containers after restart. Usually this is not a problem as the docker daemon normally will restart affected user containers after failures, daemon restarts or host reboots. `RCLONE_VERBOSE` sets plugin verbosity from `0` (errors only, by default) to `2` (debugging). Verbosity can be also tweaked via `args="-v [-v] ..."`. Since arguments are more generic, you will rarely need this setting. The plugin output by default feeds the docker daemon log on local host. Log entries are reflected as _errors_ in the docker log but retain their actual level assigned by rclone in the encapsulated message string. `HTTP_PROXY`, `HTTPS_PROXY`, `NO_PROXY` customize the plugin proxy settings. You can set custom plugin options right when you install it, _in one go_: ``` docker plugin remove rclone docker plugin install rclone/docker-volume-rclone:amd64 \ --alias rclone --grant-all-permissions \ args="-v --allow-other" config=/etc/rclone docker plugin inspect rclone ``` ## Healthchecks The docker plugin volume protocol doesn't provide a way for plugins to inform the docker daemon that a volume is (un-)available. As a workaround you can setup a healthcheck to verify that the mount is responding, for example: ``` services: my_service: image: my_image healthcheck: test: ls /path/to/rclone/mount || exit 1 interval: 1m timeout: 15s retries: 3 start_period: 15s ``` ## Running Plugin under Systemd In most cases you should prefer managed mode. Moreover, MacOS and Windows do not support native Docker plugins. Please use managed mode on these systems. Proceed further only if you are on Linux. First, [install rclone](https://rclone.org/install/). You can just run it (type `rclone serve docker` and hit enter) for the test. Install _FUSE_: ``` sudo apt-get -y install fuse ``` Download two systemd configuration files: [docker-volume-rclone.service](https://raw.githubusercontent.com/rclone/rclone/master/contrib/docker-plugin/systemd/docker-volume-rclone.service) and [docker-volume-rclone.socket](https://raw.githubusercontent.com/rclone/rclone/master/contrib/docker-plugin/systemd/docker-volume-rclone.socket). Put them to the `/etc/systemd/system/` directory: ``` cp docker-volume-plugin.service /etc/systemd/system/ cp docker-volume-plugin.socket /etc/systemd/system/ ``` Please note that all commands in this section must be run as _root_ but we omit `sudo` prefix for brevity. Now create directories required by the service: ``` mkdir -p /var/lib/docker-volumes/rclone mkdir -p /var/lib/docker-plugins/rclone/config mkdir -p /var/lib/docker-plugins/rclone/cache ``` Run the docker plugin service in the socket activated mode: ``` systemctl daemon-reload systemctl start docker-volume-rclone.service systemctl enable docker-volume-rclone.socket systemctl start docker-volume-rclone.socket systemctl restart docker ``` Or run the service directly: - run `systemctl daemon-reload` to let systemd pick up new config - run `systemctl enable docker-volume-rclone.service` to make the new service start automatically when you power on your machine. - run `systemctl start docker-volume-rclone.service` to start the service now. - run `systemctl restart docker` to restart docker daemon and let it detect the new plugin socket. Note that this step is not needed in managed mode where docker knows about plugin state changes. The two methods are equivalent from the user perspective, but I personally prefer socket activation. ## Troubleshooting You can [see managed plugin settings](https://docs.docker.com/engine/extend/#debugging-plugins) with ``` docker plugin list docker plugin inspect rclone ``` Note that docker (including latest 20.10.7) will not show actual values of `args`, just the defaults. Use `journalctl --unit docker` to see managed plugin output as part of the docker daemon log. Note that docker reflects plugin lines as _errors_ but their actual level can be seen from encapsulated message string. You will usually install the latest version of managed plugin for your platform. Use the following commands to print the actual installed version: ``` PLUGID=$(docker plugin list --no-trunc | awk '/rclone/{print$1}') sudo runc --root /run/docker/runtime-runc/plugins.moby exec $PLUGID rclone version ``` You can even use `runc` to run shell inside the plugin container: ``` sudo runc --root /run/docker/runtime-runc/plugins.moby exec --tty $PLUGID bash ``` Also you can use curl to check the plugin socket connectivity: ``` docker plugin list --no-trunc PLUGID=123abc... sudo curl -H Content-Type:application/json -XPOST -d {} --unix-socket /run/docker/plugins/$PLUGID/rclone.sock http://localhost/Plugin.Activate ``` though this is rarely needed. If the plugin fails to work properly, and only as a last resort after you tried diagnosing with the above methods, you can try clearing the state of the plugin. **Note that all existing rclone docker volumes will probably have to be recreated.** This might be needed because a reinstall don't cleanup existing state files to allow for easy restoration, as stated above. ``` docker plugin disable rclone # disable the plugin to ensure no interference sudo rm /var/lib/docker-plugins/rclone/cache/docker-plugin.state # removing the plugin state docker plugin enable rclone # re-enable the plugin afterward ``` ## Caveats Finally I'd like to mention a _caveat with updating volume settings_. Docker CLI does not have a dedicated command like `docker volume update`. It may be tempting to invoke `docker volume create` with updated options on existing volume, but there is a gotcha. The command will do nothing, it won't even return an error. I hope that docker maintainers will fix this some day. In the meantime be aware that you must remove your volume before recreating it with new settings: ``` docker volume remove my_vol docker volume create my_vol -d rclone -o opt1=new_val1 ... ``` and verify that settings did update: ``` docker volume list docker volume inspect my_vol ``` If docker refuses to remove the volume, you should find containers or swarm services that use it and stop them first. ## Bisync `bisync` is considered an **advanced command**, so use with care. Make sure you have read and understood the entire [manual](https://rclone.org/bisync) (especially the [Limitations](#limitations) section) before using, or data loss can result. Questions can be asked in the [Rclone Forum](https://forum.rclone.org/). ## Getting started {#getting-started} - [Install rclone](https://rclone.org/install/) and setup your remotes. - Bisync will create its working directory at `~/.cache/rclone/bisync` on Linux, `/Users/yourusername/Library/Caches/rclone/bisync` on Mac, or `C:\Users\MyLogin\AppData\Local\rclone\bisync` on Windows. Make sure that this location is writable. - Run bisync with the `--resync` flag, specifying the paths to the local and remote sync directory roots. - For successive sync runs, leave off the `--resync` flag. (**Important!**) - Consider using a [filters file](#filtering) for excluding unnecessary files and directories from the sync. - Consider setting up the [--check-access](#check-access) feature for safety. - On Linux or Mac, consider setting up a [crontab entry](#cron). bisync can safely run in concurrent cron jobs thanks to lock files it maintains. For example, your first command might look like this: ```bash rclone bisync remote1:path1 remote2:path2 --create-empty-src-dirs --compare size,modtime,checksum --slow-hash-sync-only --resilient -MvP --drive-skip-gdocs --fix-case --resync --dry-run ``` If all looks good, run it again without `--dry-run`. After that, remove `--resync` as well. Here is a typical run log (with timestamps removed for clarity): ```bash rclone bisync /testdir/path1/ /testdir/path2/ --verbose INFO : Synching Path1 "/testdir/path1/" with Path2 "/testdir/path2/" INFO : Path1 checking for diffs INFO : - Path1 File is new - file11.txt INFO : - Path1 File is newer - file2.txt INFO : - Path1 File is newer - file5.txt INFO : - Path1 File is newer - file7.txt INFO : - Path1 File was deleted - file4.txt INFO : - Path1 File was deleted - file6.txt INFO : - Path1 File was deleted - file8.txt INFO : Path1: 7 changes: 1 new, 3 newer, 0 older, 3 deleted INFO : Path2 checking for diffs INFO : - Path2 File is new - file10.txt INFO : - Path2 File is newer - file1.txt INFO : - Path2 File is newer - file5.txt INFO : - Path2 File is newer - file6.txt INFO : - Path2 File was deleted - file3.txt INFO : - Path2 File was deleted - file7.txt INFO : - Path2 File was deleted - file8.txt INFO : Path2: 7 changes: 1 new, 3 newer, 0 older, 3 deleted INFO : Applying changes INFO : - Path1 Queue copy to Path2 - /testdir/path2/file11.txt INFO : - Path1 Queue copy to Path2 - /testdir/path2/file2.txt INFO : - Path2 Queue delete - /testdir/path2/file4.txt NOTICE: - WARNING New or changed in both paths - file5.txt NOTICE: - Path1 Renaming Path1 copy - /testdir/path1/file5.txt..path1 NOTICE: - Path1 Queue copy to Path2 - /testdir/path2/file5.txt..path1 NOTICE: - Path2 Renaming Path2 copy - /testdir/path2/file5.txt..path2 NOTICE: - Path2 Queue copy to Path1 - /testdir/path1/file5.txt..path2 INFO : - Path2 Queue copy to Path1 - /testdir/path1/file6.txt INFO : - Path1 Queue copy to Path2 - /testdir/path2/file7.txt INFO : - Path2 Queue copy to Path1 - /testdir/path1/file1.txt INFO : - Path2 Queue copy to Path1 - /testdir/path1/file10.txt INFO : - Path1 Queue delete - /testdir/path1/file3.txt INFO : - Path2 Do queued copies to - Path1 INFO : - Path1 Do queued copies to - Path2 INFO : - Do queued deletes on - Path1 INFO : - Do queued deletes on - Path2 INFO : Updating listings INFO : Validating listings for Path1 "/testdir/path1/" vs Path2 "/testdir/path2/" INFO : Bisync successful ``` ## Command line syntax ```bash $ rclone bisync --help Usage: rclone bisync remote1:path1 remote2:path2 [flags] Positional arguments: Path1, Path2 Local path, or remote storage with ':' plus optional path. Type 'rclone listremotes' for list of configured remotes. Optional Flags: --backup-dir1 string --backup-dir for Path1. Must be a non-overlapping path on the same remote. --backup-dir2 string --backup-dir for Path2. Must be a non-overlapping path on the same remote. --check-access Ensure expected RCLONE_TEST files are found on both Path1 and Path2 filesystems, else abort. --check-filename string Filename for --check-access (default: RCLONE_TEST) --check-sync string Controls comparison of final listings: true|false|only (default: true) (default "true") --compare string Comma-separated list of bisync-specific compare options ex. 'size,modtime,checksum' (default: 'size,modtime') --conflict-loser ConflictLoserAction Action to take on the loser of a sync conflict (when there is a winner) or on both files (when there is no winner): , num, pathname, delete (default: num) --conflict-resolve string Automatically resolve conflicts by preferring the version that is: none, path1, path2, newer, older, larger, smaller (default: none) (default "none") --conflict-suffix string Suffix to use when renaming a --conflict-loser. Can be either one string or two comma-separated strings to assign different suffixes to Path1/Path2. (default: 'conflict') --create-empty-src-dirs Sync creation and deletion of empty directories. (Not compatible with --remove-empty-dirs) --download-hash Compute hash by downloading when otherwise unavailable. (warning: may be slow and use lots of data!) --filters-file string Read filtering patterns from a file --force Bypass --max-delete safety check and run the sync. Consider using with --verbose -h, --help help for bisync --ignore-listing-checksum Do not use checksums for listings (add --ignore-checksum to additionally skip post-copy checksum checks) --max-lock Duration Consider lock files older than this to be expired (default: 0 (never expire)) (minimum: 2m) (default 0s) --no-cleanup Retain working files (useful for troubleshooting and testing). --no-slow-hash Ignore listing checksums only on backends where they are slow --recover Automatically recover from interruptions without requiring --resync. --remove-empty-dirs Remove ALL empty directories at the final cleanup step. --resilient Allow future runs to retry after certain less-serious errors, instead of requiring --resync. -1, --resync Performs the resync run. Equivalent to --resync-mode path1. Consider using --verbose or --dry-run first. --resync-mode string During resync, prefer the version that is: path1, path2, newer, older, larger, smaller (default: path1 if --resync, otherwise none for no resync.) (default "none") --retries int Retry operations this many times if they fail (requires --resilient). (default 3) --retries-sleep Duration Interval between retrying operations if they fail, e.g. 500ms, 60s, 5m (0 to disable) (default 0s) --slow-hash-sync-only Ignore slow checksums for listings and deltas, but still consider them during sync calls. --workdir string Use custom working dir - useful for testing. (default: {WORKDIR}) --max-delete PERCENT Safety check on maximum percentage of deleted files allowed. If exceeded, the bisync run will abort. (default: 50%) -n, --dry-run Go through the motions - No files are copied/deleted. -v, --verbose Increases logging verbosity. May be specified more than once for more details. ``` Arbitrary rclone flags may be specified on the [bisync command line](https://rclone.org/commands/rclone_bisync/), for example `rclone bisync ./testdir/path1/ gdrive:testdir/path2/ --drive-skip-gdocs -v -v --timeout 10s` Note that interactions of various rclone flags with bisync process flow has not been fully tested yet. ### Paths Path1 and Path2 arguments may be references to any mix of local directory paths (absolute or relative), UNC paths (`//server/share/path`), Windows drive paths (with a drive letter and `:`) or configured [remotes](https://rclone.org/docs/#syntax-of-remote-paths) with optional subdirectory paths. Cloud references are distinguished by having a `:` in the argument (see [Windows support](#windows) below). Path1 and Path2 are treated equally, in that neither has priority for file changes (except during [`--resync`](#resync)), and access efficiency does not change whether a remote is on Path1 or Path2. The listings in bisync working directory (default: `~/.cache/rclone/bisync`) are named based on the Path1 and Path2 arguments so that separate syncs to individual directories within the tree may be set up, e.g.: `path_to_local_tree..dropbox_subdir.lst`. Any empty directories after the sync on both the Path1 and Path2 filesystems are not deleted by default, unless `--create-empty-src-dirs` is specified. If the `--remove-empty-dirs` flag is specified, then both paths will have ALL empty directories purged as the last step in the process. ## Command-line flags ### --resync This will effectively make both Path1 and Path2 filesystems contain a matching superset of all files. By default, Path2 files that do not exist in Path1 will be copied to Path1, and the process will then copy the Path1 tree to Path2. The `--resync` sequence is roughly equivalent to the following (but see [`--resync-mode`](#resync-mode) for other options): ```bash rclone copy Path2 Path1 --ignore-existing [--create-empty-src-dirs] rclone copy Path1 Path2 [--create-empty-src-dirs] ``` The base directories on both Path1 and Path2 filesystems must exist or bisync will fail. This is required for safety - that bisync can verify that both paths are valid. When using `--resync`, a newer version of a file on the Path2 filesystem will (by default) be overwritten by the Path1 filesystem version. (Note that this is [NOT entirely symmetrical](https://github.com/rclone/rclone/issues/5681#issuecomment-938761815), and more symmetrical options can be specified with the [`--resync-mode`](#resync-mode) flag.) Carefully evaluate deltas using [--dry-run](https://rclone.org/flags/#non-backend-flags). For a resync run, one of the paths may be empty (no files in the path tree). The resync run should result in files on both paths, else a normal non-resync run will fail. For a non-resync run, either path being empty (no files in the tree) fails with `Empty current PathN listing. Cannot sync to an empty directory: X.pathN.lst` This is a safety check that an unexpected empty path does not result in deleting **everything** in the other path. Note that `--resync` implies `--resync-mode path1` unless a different [`--resync-mode`](#resync-mode) is explicitly specified. It is not necessary to use both the `--resync` and `--resync-mode` flags -- either one is sufficient without the other. **Note:** `--resync` (including `--resync-mode`) should only be used under three specific (rare) circumstances: 1. It is your *first* bisync run (between these two paths) 2. You've just made changes to your bisync settings (such as editing the contents of your `--filters-file`) 3. There was an error on the prior run, and as a result, bisync now requires `--resync` to recover The rest of the time, you should *omit* `--resync`. The reason is because `--resync` will only *copy* (not *sync*) each side to the other. Therefore, if you included `--resync` for every bisync run, it would never be possible to delete a file -- the deleted file would always keep reappearing at the end of every run (because it's being copied from the other side where it still exists). Similarly, renaming a file would always result in a duplicate copy (both old and new name) on both sides. If you find that frequent interruptions from #3 are an issue, rather than automatically running `--resync`, the recommended alternative is to use the [`--resilient`](#resilient), [`--recover`](#recover), and [`--conflict-resolve`](#conflict-resolve) flags, (along with [Graceful Shutdown](#graceful-shutdown) mode, when needed) for a very robust "set-it-and-forget-it" bisync setup that can automatically bounce back from almost any interruption it might encounter. Consider adding something like the following: ```bash --resilient --recover --max-lock 2m --conflict-resolve newer ``` ### --resync-mode CHOICE {#resync-mode} In the event that a file differs on both sides during a `--resync`, `--resync-mode` controls which version will overwrite the other. The supported options are similar to [`--conflict-resolve`](#conflict-resolve). For all of the following options, the version that is kept is referred to as the "winner", and the version that is overwritten (deleted) is referred to as the "loser". The options are named after the "winner": - `path1` - (the default) - the version from Path1 is unconditionally considered the winner (regardless of `modtime` and `size`, if any). This can be useful if one side is more trusted or up-to-date than the other, at the time of the `--resync`. - `path2` - same as `path1`, except the path2 version is considered the winner. - `newer` - the newer file (by `modtime`) is considered the winner, regardless of which side it came from. This may result in having a mix of some winners from Path1, and some winners from Path2. (The implementation is analogous to running `rclone copy --update` in both directions.) - `older` - same as `newer`, except the older file is considered the winner, and the newer file is considered the loser. - `larger` - the larger file (by `size`) is considered the winner (regardless of `modtime`, if any). This can be a useful option for remotes without `modtime` support, or with the kinds of files (such as logs) that tend to grow but not shrink, over time. - `smaller` - the smaller file (by `size`) is considered the winner (regardless of `modtime`, if any). For all of the above options, note the following: - If either of the underlying remotes lacks support for the chosen method, it will be ignored and will fall back to the default of `path1`. (For example, if `--resync-mode newer` is set, but one of the paths uses a remote that doesn't support `modtime`.) - If a winner can't be determined because the chosen method's attribute is missing or equal, it will be ignored, and bisync will instead try to determine whether the files differ by looking at the other `--compare` methods in effect. (For example, if `--resync-mode newer` is set, but the Path1 and Path2 modtimes are identical, bisync will compare the sizes.) If bisync concludes that they differ, preference is given to whichever is the "source" at that moment. (In practice, this gives a slight advantage to Path2, as the 2to1 copy comes before the 1to2 copy.) If the files *do not* differ, nothing is copied (as both sides are already correct). - These options apply only to files that exist on both sides (with the same name and relative path). Files that exist *only* on one side and not the other are *always* copied to the other, during `--resync` (this is one of the main differences between resync and non-resync runs.). - `--conflict-resolve`, `--conflict-loser`, and `--conflict-suffix` do not apply during `--resync`, and unlike these flags, nothing is renamed during `--resync`. When a file differs on both sides during `--resync`, one version always overwrites the other (much like in `rclone copy`.) (Consider using [`--backup-dir`](#backup-dir1-and-backup-dir2) to retain a backup of the losing version.) - Unlike for `--conflict-resolve`, `--resync-mode none` is not a valid option (or rather, it will be interpreted as "no resync", unless `--resync` has also been specified, in which case it will be ignored.) - Winners and losers are decided at the individual file-level only (there is not currently an option to pick an entire winning directory atomically, although the `path1` and `path2` options typically produce a similar result.) - To maintain backward-compatibility, the `--resync` flag implies `--resync-mode path1` unless a different `--resync-mode` is explicitly specified. Similarly, all `--resync-mode` options (except `none`) imply `--resync`, so it is not necessary to use both the `--resync` and `--resync-mode` flags simultaneously -- either one is sufficient without the other. ### --check-access Access check files are an additional safety measure against data loss. bisync will ensure it can find matching `RCLONE_TEST` files in the same places in the Path1 and Path2 filesystems. `RCLONE_TEST` files are not generated automatically. For `--check-access` to succeed, you must first either: **A)** Place one or more `RCLONE_TEST` files in both systems, or **B)** Set `--check-filename` to a filename already in use in various locations throughout your sync'd fileset. Recommended methods for **A)** include: - `rclone touch Path1/RCLONE_TEST` (create a new file) - `rclone copyto Path1/RCLONE_TEST Path2/RCLONE_TEST` (copy an existing file) - `rclone copy Path1/RCLONE_TEST Path2/RCLONE_TEST --include "RCLONE_TEST"` (copy multiple files at once, recursively) - create the files manually (outside of rclone) - run `bisync` once *without* `--check-access` to set matching files on both filesystems will also work, but is not preferred, due to potential for user error (you are temporarily disabling the safety feature). Note that `--check-access` is still enforced on `--resync`, so `bisync --resync --check-access` will not work as a method of initially setting the files (this is to ensure that bisync can't [inadvertently circumvent its own safety switch](https://forum.rclone.org/t/bisync-bugs-and-feature-requests/37636#:~:text=3.%20%2D%2Dcheck%2Daccess%20doesn%27t%20always%20fail%20when%20it%20should).) Time stamps and file contents for `RCLONE_TEST` files are not important, just the names and locations. If you have symbolic links in your sync tree it is recommended to place `RCLONE_TEST` files in the linked-to directory tree to protect against bisync assuming a bunch of deleted files if the linked-to tree should not be accessible. See also the [--check-filename](--check-filename) flag. ### --check-filename Name of the file(s) used in access health validation. The default `--check-filename` is `RCLONE_TEST`. One or more files having this filename must exist, synchronized between your source and destination filesets, in order for `--check-access` to succeed. See [--check-access](#check-access) for additional details. ### --compare As of `v1.66`, bisync fully supports comparing based on any combination of size, modtime, and checksum (lifting the prior restriction on backends without modtime support.) By default (without the `--compare` flag), bisync inherits the same comparison options as `sync` (that is: `size` and `modtime` by default, unless modified with flags such as [`--checksum`](https://rclone.org/docs/#c-checksum) or [`--size-only`](/docs/#size-only).) If the `--compare` flag is set, it will override these defaults. This can be useful if you wish to compare based on combinations not currently supported in `sync`, such as comparing all three of `size` AND `modtime` AND `checksum` simultaneously (or just `modtime` AND `checksum`). `--compare` takes a comma-separated list, with the currently supported values being `size`, `modtime`, and `checksum`. For example, if you want to compare size and checksum, but not modtime, you would do: ```bash --compare size,checksum ``` Or if you want to compare all three: ```bash --compare size,modtime,checksum ``` `--compare` overrides any conflicting flags. For example, if you set the conflicting flags `--compare checksum --size-only`, `--size-only` will be ignored, and bisync will compare checksum and not size. To avoid confusion, it is recommended to use *either* `--compare` or the normal `sync` flags, but not both. If `--compare` includes `checksum` and both remotes support checksums but have no hash types in common with each other, checksums will be considered *only* for comparisons within the same side (to determine what has changed since the prior sync), but not for comparisons against the opposite side. If one side supports checksums and the other does not, checksums will only be considered on the side that supports them. When comparing with `checksum` and/or `size` without `modtime`, bisync cannot determine whether a file is `newer` or `older` -- only whether it is `changed` or `unchanged`. (If it is `changed` on both sides, bisync still does the standard equality-check to avoid declaring a sync conflict unless it absolutely has to.) It is recommended to do a `--resync` when changing `--compare` settings, as otherwise your prior listing files may not contain the attributes you wish to compare (for example, they will not have stored checksums if you were not previously comparing checksums.) ### --ignore-listing-checksum When `--checksum` or `--compare checksum` is set, bisync will retrieve (or generate) checksums (for backends that support them) when creating the listings for both paths, and store the checksums in the listing files. `--ignore-listing-checksum` will disable this behavior, which may speed things up considerably, especially on backends (such as [local](https://rclone.org/local/)) where hashes must be computed on the fly instead of retrieved. Please note the following: - As of `v1.66`, `--ignore-listing-checksum` is now automatically set when neither `--checksum` nor `--compare checksum` are in use (as the checksums would not be used for anything.) - `--ignore-listing-checksum` is NOT the same as [`--ignore-checksum`](https://rclone.org/docs/#ignore-checksum), and you may wish to use one or the other, or both. In a nutshell: `--ignore-listing-checksum` controls whether checksums are considered when scanning for diffs, while `--ignore-checksum` controls whether checksums are considered during the copy/sync operations that follow, if there ARE diffs. - Unless `--ignore-listing-checksum` is passed, bisync currently computes hashes for one path *even when there's no common hash with the other path* (for example, a [crypt](https://rclone.org/crypt/#modification-times-and-hashes) remote.) This can still be beneficial, as the hashes will still be used to detect changes within the same side (if `--checksum` or `--compare checksum` is set), even if they can't be used to compare against the opposite side. - If you wish to ignore listing checksums *only* on remotes where they are slow to compute, consider using [`--no-slow-hash`](#no-slow-hash) (or [`--slow-hash-sync-only`](#slow-hash-sync-only)) instead of `--ignore-listing-checksum`. - If `--ignore-listing-checksum` is used simultaneously with `--compare checksum` (or `--checksum`), checksums will be ignored for bisync deltas, but still considered during the sync operations that follow (if deltas are detected based on modtime and/or size.) ### --no-slow-hash On some remotes (notably `local`), checksums can dramatically slow down a bisync run, because hashes cannot be stored and need to be computed in real-time when they are requested. On other remotes (such as `drive`), they add practically no time at all. The `--no-slow-hash` flag will automatically skip checksums on remotes where they are slow, while still comparing them on others (assuming [`--compare`](#compare) includes `checksum`.) This can be useful when one of your bisync paths is slow but you still want to check checksums on the other, for a more robust sync. ### --slow-hash-sync-only Same as [`--no-slow-hash`](#no-slow-hash), except slow hashes are still considered during sync calls. They are still NOT considered for determining deltas, nor or they included in listings. They are also skipped during `--resync`. The main use case for this flag is when you have a large number of files, but relatively few of them change from run to run -- so you don't want to check your entire tree every time (it would take too long), but you still want to consider checksums for the smaller group of files for which a `modtime` or `size` change was detected. Keep in mind that this speed savings comes with a safety trade-off: if a file's content were to change without a change to its `modtime` or `size`, bisync would not detect it, and it would not be synced. `--slow-hash-sync-only` is only useful if both remotes share a common hash type (if they don't, bisync will automatically fall back to `--no-slow-hash`.) Both `--no-slow-hash` and `--slow-hash-sync-only` have no effect without `--compare checksum` (or `--checksum`). ### --download-hash If `--download-hash` is set, bisync will use best efforts to obtain an MD5 checksum by downloading and computing on-the-fly, when checksums are not otherwise available (for example, a remote that doesn't support them.) Note that since rclone has to download the entire file, this may dramatically slow down your bisync runs, and is also likely to use a lot of data, so it is probably not practical for bisync paths with a large total file size. However, it can be a good option for syncing small-but-important files with maximum accuracy (for example, a source code repo on a `crypt` remote.) An additional advantage over methods like [`cryptcheck`](https://rclone.org/commands/rclone_cryptcheck/) is that the original file is not required for comparison (for example, `--download-hash` can be used to bisync two different crypt remotes with different passwords.) When `--download-hash` is set, bisync still looks for more efficient checksums first, and falls back to downloading only when none are found. It takes priority over conflicting flags such as `--no-slow-hash`. `--download-hash` is not suitable for [Google Docs](#gdocs) and other files of unknown size, as their checksums would change from run to run (due to small variances in the internals of the generated export file.) Therefore, bisync automatically skips `--download-hash` for files with a size less than 0. See also: [`Hasher`](https://rclone.org/hasher/) backend, [`cryptcheck`](https://rclone.org/commands/rclone_cryptcheck/) command, [`rclone check --download`](https://rclone.org/commands/rclone_check/) option, [`md5sum`](https://rclone.org/commands/rclone_md5sum/) command ### --max-delete As a safety check, if greater than the `--max-delete` percent of files were deleted on either the Path1 or Path2 filesystem, then bisync will abort with a warning message, without making any changes. The default `--max-delete` is `50%`. One way to trigger this limit is to rename a directory that contains more than half of your files. This will appear to bisync as a bunch of deleted files and a bunch of new files. This safety check is intended to block bisync from deleting all of the files on both filesystems due to a temporary network access issue, or if the user had inadvertently deleted the files on one side or the other. To force the sync, either set a different delete percentage limit, e.g. `--max-delete 75` (allows up to 75% deletion), or use `--force` to bypass the check. Also see the [all files changed](#all-files-changed) check. ### --filters-file {#filters-file} By using rclone filter features you can exclude file types or directory sub-trees from the sync. See the [bisync filters](#filtering) section and generic [--filter-from](https://rclone.org/filtering/#filter-from-read-filtering-patterns-from-a-file) documentation. An [example filters file](#example-filters-file) contains filters for non-allowed files for syncing with Dropbox. If you make changes to your filters file then bisync requires a run with `--resync`. This is a safety feature, which prevents existing files on the Path1 and/or Path2 side from seeming to disappear from view (since they are excluded in the new listings), which would fool bisync into seeing them as deleted (as compared to the prior run listings), and then bisync would proceed to delete them for real. To block this from happening, bisync calculates an MD5 hash of the filters file and stores the hash in a `.md5` file in the same place as your filters file. On the next run with `--filters-file` set, bisync re-calculates the MD5 hash of the current filters file and compares it to the hash stored in the `.md5` file. If they don't match, the run aborts with a critical error and thus forces you to do a `--resync`, likely avoiding a disaster. ### --conflict-resolve CHOICE {#conflict-resolve} In bisync, a "conflict" is a file that is *new* or *changed* on *both sides* (relative to the prior run) AND is *not currently identical* on both sides. `--conflict-resolve` controls how bisync handles such a scenario. The currently supported options are: - `none` - (the default) - do not attempt to pick a winner, keep and rename both files according to [`--conflict-loser`](#conflict-loser) and [`--conflict-suffix`](#conflict-suffix) settings. For example, with the default settings, `file.txt` on Path1 is renamed `file.txt.conflict1` and `file.txt` on Path2 is renamed `file.txt.conflict2`. Both are copied to the opposite path during the run, so both sides end up with a copy of both files. (As `none` is the default, it is not necessary to specify `--conflict-resolve none` -- you can just omit the flag.) - `newer` - the newer file (by `modtime`) is considered the winner and is copied without renaming. The older file (the "loser") is handled according to `--conflict-loser` and `--conflict-suffix` settings (either renamed or deleted.) For example, if `file.txt` on Path1 is newer than `file.txt` on Path2, the result on both sides (with other default settings) will be `file.txt` (winner from Path1) and `file.txt.conflict1` (loser from Path2). - `older` - same as `newer`, except the older file is considered the winner, and the newer file is considered the loser. - `larger` - the larger file (by `size`) is considered the winner (regardless of `modtime`, if any). - `smaller` - the smaller file (by `size`) is considered the winner (regardless of `modtime`, if any). - `path1` - the version from Path1 is unconditionally considered the winner (regardless of `modtime` and `size`, if any). This can be useful if one side is usually more trusted or up-to-date than the other. - `path2` - same as `path1`, except the path2 version is considered the winner. For all of the above options, note the following: - If either of the underlying remotes lacks support for the chosen method, it will be ignored and fall back to `none`. (For example, if `--conflict-resolve newer` is set, but one of the paths uses a remote that doesn't support `modtime`.) - If a winner can't be determined because the chosen method's attribute is missing or equal, it will be ignored and fall back to `none`. (For example, if `--conflict-resolve newer` is set, but the Path1 and Path2 modtimes are identical, even if the sizes may differ.) - If the file's content is currently identical on both sides, it is not considered a "conflict", even if new or changed on both sides since the prior sync. (For example, if you made a change on one side and then synced it to the other side by other means.) Therefore, none of the conflict resolution flags apply in this scenario. - The conflict resolution flags do not apply during a `--resync`, as there is no "prior run" to speak of (but see [`--resync-mode`](#resync-mode) for similar options.) ### --conflict-loser CHOICE {#conflict-loser} `--conflict-loser` determines what happens to the "loser" of a sync conflict (when [`--conflict-resolve`](#conflict-resolve) determines a winner) or to both files (when there is no winner.) The currently supported options are: - `num` - (the default) - auto-number the conflicts by automatically appending the next available number to the `--conflict-suffix`, in chronological order. For example, with the default settings, the first conflict for `file.txt` will be renamed `file.txt.conflict1`. If `file.txt.conflict1` already exists, `file.txt.conflict2` will be used instead (etc., up to a maximum of 9223372036854775807 conflicts.) - `pathname` - rename the conflicts according to which side they came from, which was the default behavior prior to `v1.66`. For example, with `--conflict-suffix path`, `file.txt` from Path1 will be renamed `file.txt.path1`, and `file.txt` from Path2 will be renamed `file.txt.path2`. If two non-identical suffixes are provided (ex. `--conflict-suffix cloud,local`), the trailing digit is omitted. Importantly, note that with `pathname`, there is no auto-numbering beyond `2`, so if `file.txt.path2` somehow already exists, it will be overwritten. Using a dynamic date variable in your `--conflict-suffix` (see below) is one possible way to avoid this. Note also that conflicts-of-conflicts are possible, if the original conflict is not manually resolved -- for example, if for some reason you edited `file.txt.path1` on both sides, and those edits were different, the result would be `file.txt.path1.path1` and `file.txt.path1.path2` (in addition to `file.txt.path2`.) - `delete` - keep the winner only and delete the loser, instead of renaming it. If a winner cannot be determined (see `--conflict-resolve` for details on how this could happen), `delete` is ignored and the default `num` is used instead (i.e. both versions are kept and renamed, and neither is deleted.) `delete` is inherently the most destructive option, so use it only with care. For all of the above options, note that if a winner cannot be determined (see `--conflict-resolve` for details on how this could happen), or if `--conflict-resolve` is not in use, *both* files will be renamed. ### --conflict-suffix STRING[,STRING] {#conflict-suffix} `--conflict-suffix` controls the suffix that is appended when bisync renames a [`--conflict-loser`](#conflict-loser) (default: `conflict`). `--conflict-suffix` will accept either one string or two comma-separated strings to assign different suffixes to Path1 vs. Path2. This may be helpful later in identifying the source of the conflict. (For example, `--conflict-suffix dropboxconflict,laptopconflict`) With `--conflict-loser num`, a number is always appended to the suffix. With `--conflict-loser pathname`, a number is appended only when one suffix is specified (or when two identical suffixes are specified.) i.e. with `--conflict-loser pathname`, all of the following would produce exactly the same result: ```bash --conflict-suffix path --conflict-suffix path,path --conflict-suffix path1,path2 ``` Suffixes may be as short as 1 character. By default, the suffix is appended after any other extensions (ex. `file.jpg.conflict1`), however, this can be changed with the [`--suffix-keep-extension`](https://rclone.org/docs/#suffix-keep-extension) flag (i.e. to instead result in `file.conflict1.jpg`). `--conflict-suffix` supports several *dynamic date variables* when enclosed in curly braces as globs. This can be helpful to track the date and/or time that each conflict was handled by bisync. For example: ```bash --conflict-suffix {DateOnly}-conflict // result: myfile.txt.2006-01-02-conflict1 ``` All of the formats described [here (go Time.Layout constants)](https://pkg.go.dev/time#pkg-constants) and [here (go Time.Format examples)](https://pkg.go.dev/time#example-Time.Format) are supported, but take care to ensure that your chosen format does not use any characters that are illegal on your remotes (for example, macOS does not allow colons in filenames, and slashes are also best avoided as they are often interpreted as directory separators.) To address this particular issue, an additional `{MacFriendlyTime}` (or just `{mac}`) option is supported, which results in `2006-01-02 0304PM`. Note that `--conflict-suffix` is entirely separate from rclone's main [`--sufix`](https://rclone.org/docs/#suffix-string) flag. This is intentional, as users may wish to use both flags simultaneously, if also using [`--backup-dir`](#backup-dir1-and-backup-dir2). Finally, note that the default in bisync prior to `v1.66` was to rename conflicts with `..path1` and `..path2` (with two periods, and `path` instead of `conflict`.) Bisync now defaults to a single dot instead of a double dot, but additional dots can be added by including them in the specified suffix string. For example, for behavior equivalent to the previous default, use: ```bash [--conflict-resolve none] --conflict-loser pathname --conflict-suffix .path ``` ### --check-sync Enabled by default, the check-sync function checks that all of the same files exist in both the Path1 and Path2 history listings. This *check-sync* integrity check is performed at the end of the sync run by default. Any untrapped failing copy/deletes between the two paths might result in differences between the two listings and in the untracked file content differences between the two paths. A resync run would correct the error. Note that the default-enabled integrity check locally executes a load of both the final Path1 and Path2 listings, and thus adds to the run time of a sync. Using `--check-sync=false` will disable it and may significantly reduce the sync run times for very large numbers of files. The check may be run manually with `--check-sync=only`. It runs only the integrity check and terminates without actually syncing. Note that currently, `--check-sync` **only checks listing snapshots and NOT the actual files on the remotes.** Note also that the listing snapshots will not know about any changes that happened during or after the latest bisync run, as those will be discovered on the next run. Therefore, while listings should always match *each other* at the end of a bisync run, it is *expected* that they will not match the underlying remotes, nor will the remotes match each other, if there were changes during or after the run. This is normal, and any differences will be detected and synced on the next run. For a robust integrity check of the current state of the remotes (as opposed to just their listing snapshots), consider using [`check`](commands/rclone_check/) (or [`cryptcheck`](https://rclone.org/commands/rclone_cryptcheck/), if at least one path is a `crypt` remote) instead of `--check-sync`, keeping in mind that differences are expected if files changed during or after your last bisync run. For example, a possible sequence could look like this: 1. Normally scheduled bisync run: ```bash rclone bisync Path1 Path2 -MPc --check-access --max-delete 10 --filters-file /path/to/filters.txt -v --no-cleanup --ignore-listing-checksum --disable ListR --checkers=16 --drive-pacer-min-sleep=10ms --create-empty-src-dirs --resilient ``` 2. Periodic independent integrity check (perhaps scheduled nightly or weekly): ```bash rclone check -MvPc Path1 Path2 --filter-from /path/to/filters.txt ``` 3. If diffs are found, you have some choices to correct them. If one side is more up-to-date and you want to make the other side match it, you could run: ```bash rclone sync Path1 Path2 --filter-from /path/to/filters.txt --create-empty-src-dirs -MPc -v ``` (or switch Path1 and Path2 to make Path2 the source-of-truth) Or, if neither side is totally up-to-date, you could run a `--resync` to bring them back into agreement (but remember that this could cause deleted files to re-appear.) *Note also that `rclone check` does not currently include empty directories, so if you want to know if any empty directories are out of sync, consider alternatively running the above `rclone sync` command with `--dry-run` added. See also: [Concurrent modifications](#concurrent-modifications), [`--resilient`](#resilient) ### --resilient By default, most errors or interruptions will cause bisync to abort and require [`--resync`](#resync) to recover. This is a safety feature, to prevent bisync from running again until a user checks things out. However, in some cases, bisync can go too far and enforce a lockout when one isn't actually necessary, like for certain less-serious errors that might resolve themselves on the next run. When `--resilient` is specified, bisync tries its best to recover and self-correct, and only requires `--resync` as a last resort when a human's involvement is absolutely necessary. The intended use case is for running bisync as a background process (such as via scheduled [cron](#cron)). When using `--resilient` mode, bisync will still report the error and abort, however it will not lock out future runs -- allowing the possibility of retrying at the next normally scheduled time, without requiring a `--resync` first. Examples of such retryable errors include access test failures, missing listing files, and filter change detections. These safety features will still prevent the *current* run from proceeding -- the difference is that if conditions have improved by the time of the *next* run, that next run will be allowed to proceed. Certain more serious errors will still enforce a `--resync` lockout, even in `--resilient` mode, to prevent data loss. Behavior of `--resilient` may change in a future version. (See also: [`--recover`](#recover), [`--max-lock`](#max-lock), [Graceful Shutdown](#graceful-shutdown)) ### --recover If `--recover` is set, in the event of a sudden interruption or other un-graceful shutdown, bisync will attempt to automatically recover on the next run, instead of requiring `--resync`. Bisync is able to recover robustly by keeping one "backup" listing at all times, representing the state of both paths after the last known successful sync. Bisync can then compare the current state with this snapshot to determine which changes it needs to retry. Changes that were synced after this snapshot (during the run that was later interrupted) will appear to bisync as if they are "new or changed on both sides", but in most cases this is not a problem, as bisync will simply do its usual "equality check" and learn that no action needs to be taken on these files, since they are already identical on both sides. In the rare event that a file is synced successfully during a run that later aborts, and then that same file changes AGAIN before the next run, bisync will think it is a sync conflict, and handle it accordingly. (From bisync's perspective, the file has changed on both sides since the last trusted sync, and the files on either side are not currently identical.) Therefore, `--recover` carries with it a slightly increased chance of having conflicts -- though in practice this is pretty rare, as the conditions required to cause it are quite specific. This risk can be reduced by using bisync's ["Graceful Shutdown"](#graceful-shutdown) mode (triggered by sending `SIGINT` or `Ctrl+C`), when you have the choice, instead of forcing a sudden termination. `--recover` and `--resilient` are similar, but distinct -- the main difference is that `--resilient` is about *retrying*, while `--recover` is about *recovering*. Most users will probably want both. `--resilient` allows retrying when bisync has chosen to abort itself due to safety features such as failing `--check-access` or detecting a filter change. `--resilient` does not cover external interruptions such as a user shutting down their computer in the middle of a sync -- that is what `--recover` is for. ### --max-lock Bisync uses [lock files](#lock-file) as a safety feature to prevent interference from other bisync runs while it is running. Bisync normally removes these lock files at the end of a run, but if bisync is abruptly interrupted, these files will be left behind. By default, they will lock out all future runs, until the user has a chance to manually check things out and remove the lock. As an alternative, `--max-lock` can be used to make them automatically expire after a certain period of time, so that future runs are not locked out forever, and auto-recovery is possible. `--max-lock` can be any duration `2m` or greater (or `0` to disable). If set, lock files older than this will be considered "expired", and future runs will be allowed to disregard them and proceed. (Note that the `--max-lock` duration must be set by the process that left the lock file -- not the later one interpreting it.) If set, bisync will also "renew" these lock files every `--max-lock minus one minute` throughout a run, for extra safety. (For example, with `--max-lock 5m`, bisync would renew the lock file (for another 5 minutes) every 4 minutes until the run has completed.) In other words, it should not be possible for a lock file to pass its expiration time while the process that created it is still running -- and you can therefore be reasonably sure that any *expired* lock file you may find was left there by an interrupted run, not one that is still running and just taking awhile. If `--max-lock` is `0` or not set, the default is that lock files will never expire, and will block future runs (of these same two bisync paths) indefinitely. For maximum resilience from disruptions, consider setting a relatively short duration like `--max-lock 2m` along with [`--resilient`](#resilient) and [`--recover`](#recover), and a relatively frequent [cron schedule](#cron). The result will be a very robust "set-it-and-forget-it" bisync run that can automatically bounce back from almost any interruption it might encounter, without requiring the user to get involved and run a `--resync`. (See also: [Graceful Shutdown](#graceful-shutdown) mode) ### --backup-dir1 and --backup-dir2 As of `v1.66`, [`--backup-dir`](https://rclone.org/docs/#backup-dir-string) is supported in bisync. Because `--backup-dir` must be a non-overlapping path on the same remote, Bisync has introduced new `--backup-dir1` and `--backup-dir2` flags to support separate backup-dirs for `Path1` and `Path2` (bisyncing between different remotes with `--backup-dir` would not otherwise be possible.) `--backup-dir1` and `--backup-dir2` can use different remotes from each other, but `--backup-dir1` must use the same remote as `Path1`, and `--backup-dir2` must use the same remote as `Path2`. Each backup directory must not overlap its respective bisync Path without being excluded by a filter rule. The standard `--backup-dir` will also work, if both paths use the same remote (but note that deleted files from both paths would be mixed together in the same dir). If either `--backup-dir1` and `--backup-dir2` are set, they will override `--backup-dir`. Example: ```bash rclone bisync /Users/someuser/some/local/path/Bisync gdrive:Bisync --backup-dir1 /Users/someuser/some/local/path/BackupDir --backup-dir2 gdrive:BackupDir --suffix -2023-08-26 --suffix-keep-extension --check-access --max-delete 10 --filters-file /Users/someuser/some/local/path/bisync_filters.txt --no-cleanup --ignore-listing-checksum --checkers=16 --drive-pacer-min-sleep=10ms --create-empty-src-dirs --resilient -MvP --drive-skip-gdocs --fix-case ``` In this example, if the user deletes a file in `/Users/someuser/some/local/path/Bisync`, bisync will propagate the delete to the other side by moving the corresponding file from `gdrive:Bisync` to `gdrive:BackupDir`. If the user deletes a file from `gdrive:Bisync`, bisync moves it from `/Users/someuser/some/local/path/Bisync` to `/Users/someuser/some/local/path/BackupDir`. In the event of a [rename due to a sync conflict](#conflict-loser), the rename is not considered a delete, unless a previous conflict with the same name already exists and would get overwritten. See also: [`--suffix`](https://rclone.org/docs/#suffix-string), [`--suffix-keep-extension`](https://rclone.org/docs/#suffix-keep-extension) ## Operation ### Runtime flow details bisync retains the listings of the `Path1` and `Path2` filesystems from the prior run. On each successive run it will: - list files on `path1` and `path2`, and check for changes on each side. Changes include `New`, `Newer`, `Older`, and `Deleted` files. - Propagate changes on `path1` to `path2`, and vice-versa. ### Safety measures - Lock file prevents multiple simultaneous runs when taking a while. This can be particularly useful if bisync is run by cron scheduler. - Handle change conflicts non-destructively by creating `.conflict1`, `.conflict2`, etc. file versions, according to [`--conflict-resolve`](#conflict-resolve), [`--conflict-loser`](#conflict-loser), and [`--conflict-suffix`](#conflict-suffix) settings. - File system access health check using `RCLONE_TEST` files (see the `--check-access` flag). - Abort on excessive deletes - protects against a failed listing being interpreted as all the files were deleted. See the `--max-delete` and `--force` flags. - If something evil happens, bisync goes into a safe state to block damage by later runs. (See [Error Handling](#error-handling)) ### Normal sync checks Type | Description | Result | Implementation --------------|-----------------------------------------------|--------------------------|----------------------------- Path2 new | File is new on Path2, does not exist on Path1 | Path2 version survives | `rclone copy` Path2 to Path1 Path2 newer | File is newer on Path2, unchanged on Path1 | Path2 version survives | `rclone copy` Path2 to Path1 Path2 deleted | File is deleted on Path2, unchanged on Path1 | File is deleted | `rclone delete` Path1 Path1 new | File is new on Path1, does not exist on Path2 | Path1 version survives | `rclone copy` Path1 to Path2 Path1 newer | File is newer on Path1, unchanged on Path2 | Path1 version survives | `rclone copy` Path1 to Path2 Path1 older | File is older on Path1, unchanged on Path2 | *Path1 version survives* | `rclone copy` Path1 to Path2 Path2 older | File is older on Path2, unchanged on Path1 | *Path2 version survives* | `rclone copy` Path2 to Path1 Path1 deleted | File no longer exists on Path1 | File is deleted | `rclone delete` Path2 ### Unusual sync checks Type | Description | Result | Implementation --------------------------------|---------------------------------------|------------------------------------|----------------------- Path1 new/changed AND Path2 new/changed AND Path1 == Path2 | File is new/changed on Path1 AND new/changed on Path2 AND Path1 version is currently identical to Path2 | No change | None Path1 new AND Path2 new | File is new on Path1 AND new on Path2 (and Path1 version is NOT identical to Path2) | Conflicts handled according to [`--conflict-resolve`](#conflict-resolve) & [`--conflict-loser`](#conflict-loser) settings | default: `rclone copy` renamed `Path2.conflict2` file to Path1, `rclone copy` renamed `Path1.conflict1` file to Path2 Path2 newer AND Path1 changed | File is newer on Path2 AND also changed (newer/older/size) on Path1 (and Path1 version is NOT identical to Path2) | Conflicts handled according to [`--conflict-resolve`](#conflict-resolve) & [`--conflict-loser`](#conflict-loser) settings | default: `rclone copy` renamed `Path2.conflict2` file to Path1, `rclone copy` renamed `Path1.conflict1` file to Path2 Path2 newer AND Path1 deleted | File is newer on Path2 AND also deleted on Path1 | Path2 version survives | `rclone copy` Path2 to Path1 Path2 deleted AND Path1 changed | File is deleted on Path2 AND changed (newer/older/size) on Path1 | Path1 version survives |`rclone copy` Path1 to Path2 Path1 deleted AND Path2 changed | File is deleted on Path1 AND changed (newer/older/size) on Path2 | Path2 version survives | `rclone copy` Path2 to Path1 As of `rclone v1.64`, bisync is now better at detecting *false positive* sync conflicts, which would previously have resulted in unnecessary renames and duplicates. Now, when bisync comes to a file that it wants to rename (because it is new/changed on both sides), it first checks whether the Path1 and Path2 versions are currently *identical* (using the same underlying function as [`check`](commands/rclone_check/).) If bisync concludes that the files are identical, it will skip them and move on. Otherwise, it will create renamed duplicates, as before. This behavior also [improves the experience of renaming directories](https://forum.rclone.org/t/bisync-bugs-and-feature-requests/37636#:~:text=Renamed%20directories), as a `--resync` is no longer required, so long as the same change has been made on both sides. ### All files changed check {#all-files-changed} If *all* prior existing files on either of the filesystems have changed (e.g. timestamps have changed due to changing the system's timezone) then bisync will abort without making any changes. Any new files are not considered for this check. You could use `--force` to force the sync (whichever side has the changed timestamp files wins). Alternately, a `--resync` may be used (Path1 versions will be pushed to Path2). Consider the situation carefully and perhaps use `--dry-run` before you commit to the changes. ### Modification times By default, bisync compares files by modification time and size. If you or your application should change the content of a file without changing the modification time and size, then bisync will *not* notice the change, and thus will not copy it to the other side. As an alternative, consider comparing by checksum (if your remotes support it). See [`--compare`](#compare) for details. ### Error handling {#error-handling} Certain bisync critical errors, such as file copy/move failing, will result in a bisync lockout of following runs. The lockout is asserted because the sync status and history of the Path1 and Path2 filesystems cannot be trusted, so it is safer to block any further changes until someone checks things out. The recovery is to do a `--resync` again. It is recommended to use `--resync --dry-run --verbose` initially and *carefully* review what changes will be made before running the `--resync` without `--dry-run`. Most of these events come up due to an error status from an internal call. On such a critical error the `{...}.path1.lst` and `{...}.path2.lst` listing files are renamed to extension `.lst-err`, which blocks any future bisync runs (since the normal `.lst` files are not found). Bisync keeps them under `bisync` subdirectory of the rclone cache directory, typically at `${HOME}/.cache/rclone/bisync/` on Linux. Some errors are considered temporary and re-running the bisync is not blocked. The *critical return* blocks further bisync runs. See also: [`--resilient`](#resilient), [`--recover`](#recover), [`--max-lock`](#max-lock), [Graceful Shutdown](#graceful-shutdown) ### Lock file When bisync is running, a lock file is created in the bisync working directory, typically at `~/.cache/rclone/bisync/PATH1..PATH2.lck` on Linux. If bisync should crash or hang, the lock file will remain in place and block any further runs of bisync *for the same paths*. Delete the lock file as part of debugging the situation. The lock file effectively blocks follow-on (e.g., scheduled by *cron*) runs when the prior invocation is taking a long time. The lock file contains *PID* of the blocking process, which may help in debug. Lock files can be set to automatically expire after a certain amount of time, using the [`--max-lock`](#max-lock) flag. **Note** that while concurrent bisync runs are allowed, *be very cautious* that there is no overlap in the trees being synched between concurrent runs, lest there be replicated files, deleted files and general mayhem. ### Exit codes `rclone bisync` returns the following codes to calling program: - `0` on a successful run, - `1` for a non-critical failing run (a rerun may be successful), - `2` on syntax or usage error, - `7` for a critically aborted run (requires a `--resync` to recover). See also the section about [exit codes](https://rclone.org/docs/#exit-code) in main docs. ### Graceful Shutdown Bisync has a "Graceful Shutdown" mode which is activated by sending `SIGINT` or pressing `Ctrl+C` during a run. Once triggered, bisync will use best efforts to exit cleanly before the timer runs out. If bisync is in the middle of transferring files, it will attempt to cleanly empty its queue by finishing what it has started but not taking more. If it cannot do so within 30 seconds, it will cancel the in-progress transfers at that point and then give itself a maximum of 60 seconds to wrap up, save its state for next time, and exit. With the `-vP` flags you will see constant status updates and a final confirmation of whether or not the graceful shutdown was successful. At any point during the "Graceful Shutdown" sequence, a second `SIGINT` or `Ctrl+C` will trigger an immediate, un-graceful exit, which will leave things in a messier state. Usually a robust recovery will still be possible if using [`--recover`](#recover) mode, otherwise you will need to do a `--resync`. If you plan to use Graceful Shutdown mode, it is recommended to use [`--resilient`](#resilient) and [`--recover`](#recover), and it is important to NOT use [`--inplace`](https://rclone.org/docs/#inplace), otherwise you risk leaving partially-written files on one side, which may be confused for real files on the next run. Note also that in the event of an abrupt interruption, a [lock file](#lock-file) will be left behind to block concurrent runs. You will need to delete it before you can proceed with the next run (or wait for it to expire on its own, if using `--max-lock`.) ## Limitations ### Supported backends Bisync is integration-tested against all rclone backends to verify compatibility. Most backends (including all backends not listed below) are deemed fully supported with no known issues. Occasionally, however, these tests reveal issues with particular backends, usually related to a provider-specific limitation beyond rclone's control (for example, disallowed special characters and filename encodings.) The following backends have known issues that need more investigation: - `TestGoFile` (`gofile`) - [`TestBisyncRemoteLocal/all_changed`](https://pub.rclone.org/integration-tests/current/gofile-cmd.bisync-TestGoFile-1.txt) - [`TestBisyncRemoteLocal/backupdir`](https://pub.rclone.org/integration-tests/current/gofile-cmd.bisync-TestGoFile-1.txt) - [`TestBisyncRemoteLocal/basic`](https://pub.rclone.org/integration-tests/current/gofile-cmd.bisync-TestGoFile-1.txt) - [`TestBisyncRemoteLocal/changes`](https://pub.rclone.org/integration-tests/current/gofile-cmd.bisync-TestGoFile-1.txt) - [`TestBisyncRemoteLocal/check_access`](https://pub.rclone.org/integration-tests/current/gofile-cmd.bisync-TestGoFile-1.txt) - [78 more](https://pub.rclone.org/integration-tests/current/) - Updated: 2025-08-21-010015 The following backends either have not been tested recently or have known issues that are deemed unfixable for the time being: - `TestCache` (`cache`) - `TestFileLu` (`filelu`) - `TestFilesCom` (`filescom`) - `TestImageKit` (`imagekit`) - `TestJottacloud` (`jottacloud`) - `TestLinkbox` (`linkbox`) - `TestMailru` (`mailru`) - `TestMega` (`mega`) - `TestOpenDrive` (`opendrive`) - `TestOracleObjectStorage` (`oracleobjectstorage`) - `TestPikPak` (`pikpak`) - `TestPixeldrain` (`pixeldrain`) - `TestProtonDrive` (`protondrive`) - `TestPutio` (`putio`) - `TestQuatrix` (`quatrix`) - `TestS3GCS` (`s3`) - `TestBisyncRemoteRemote/extended_filenames` - `TestS3Rclone` (`s3`) - `TestSFTPRsyncNet` (`sftp`) - `TestStorj` (`storj`) - `TestWebdavInfiniteScale` (`webdav`) - `TestWebdavNextcloud` (`webdav`) - `TestWebdavOwncloud` (`webdav`) - `TestnStorage` (`netstorage`) ([more info](https://github.com/rclone/rclone/blob/master/fstest/test_all/config.yaml)) The above lists are updated for each stable release of rclone. For test results updated nightly based on the latest beta, visit rclone's [integration test status page](https://pub.rclone.org/integration-tests/current/). Early beta versions of `rclone bisync` required both underlying backends to support modification times, and refused to run otherwise. This limitation has been lifted as of `v1.66`, as bisync now supports comparing checksum and/or size instead of (or in addition to) modtime. See [`--compare`](#compare) for details. ### Concurrent modifications When using **Local, FTP or SFTP** remotes with [`--inplace`](https://rclone.org/docs/#inplace), rclone does not create *temporary* files at the destination when copying, and thus if the connection is lost the created file may be corrupt, which will likely propagate back to the original path on the next sync, resulting in data loss. It is therefore recommended to *omit* `--inplace`. Files that **change during** a bisync run may result in data loss. Prior to `rclone v1.66`, this was commonly seen in highly dynamic environments, where the filesystem was getting hammered by running processes during the sync. As of `rclone v1.66`, bisync was redesigned to use a "snapshot" model, greatly reducing the risks from changes during a sync. Changes that are not detected during the current sync will now be detected during the following sync, and will no longer cause the entire run to throw a critical error. There is additionally a mechanism to mark files as needing to be internally rechecked next time, for added safety. It should therefore no longer be necessary to sync only at quiet times -- however, note that an error can still occur if a file happens to change at the exact moment it's being read/written by bisync (same as would happen in `rclone sync`.) (See also: [`--ignore-checksum`](https://rclone.org/docs/#ignore-checksum), [`--local-no-check-updated`](https://rclone.org/local/#local-no-check-updated)) ### Empty directories By default, new/deleted empty directories on one path are *not* propagated to the other side. This is because bisync (and rclone) natively works on files, not directories. However, this can be changed with the `--create-empty-src-dirs` flag, which works in much the same way as in [`sync`](https://rclone.org/commands/rclone_sync/) and [`copy`](https://rclone.org/commands/rclone_copy/). When used, empty directories created or deleted on one side will also be created or deleted on the other side. The following should be noted: - `--create-empty-src-dirs` is not compatible with `--remove-empty-dirs`. Use only one or the other (or neither). - It is not recommended to switch back and forth between `--create-empty-src-dirs` and the default (no `--create-empty-src-dirs`) without running `-- resync`. This is because it may appear as though all directories (not just the empty ones) were created/deleted, when actually you've just toggled between making them visible/invisible to bisync. It looks scarier than it is, but it's still probably best to stick to one or the other, and use `--resync` when you need to switch. ### Renamed directories By default, renaming a folder on the Path1 side results in deleting all files on the Path2 side and then copying all files again from Path1 to Path2. Bisync sees this as all files in the old directory name as deleted and all files in the new directory name as new. A recommended solution is to use [`--track-renames`](https://rclone.org/docs/#track-renames), which is now supported in bisync as of `rclone v1.66`. Note that `--track-renames` is not available during `--resync`, as `--resync` does not delete anything (`--track-renames` only supports `sync`, not `copy`.) Otherwise, the most effective and efficient method of renaming a directory is to rename it to the same name on both sides. (As of `rclone v1.64`, a `--resync` is no longer required after doing so, as bisync will automatically detect that Path1 and Path2 are in agreement.) ### `--fast-list` used by default Unlike most other rclone commands, bisync uses [`--fast-list`](https://rclone.org/docs/#fast-list) by default, for backends that support it. In many cases this is desirable, however, there are some scenarios in which bisync could be faster *without* `--fast-list`, and there is also a [known issue concerning Google Drive users with many empty directories](https://github.com/rclone/rclone/commit/cbf3d4356135814921382dd3285d859d15d0aa77). For now, the recommended way to avoid using `--fast-list` is to add `--disable ListR` to all bisync commands. The default behavior may change in a future version. ### Case (and unicode) sensitivity {#case-sensitivity} As of `v1.66`, case and unicode form differences no longer cause critical errors, and normalization (when comparing between filesystems) is handled according to the same flags and defaults as `rclone sync`. See the following options (all of which are supported by bisync) to control this behavior more granularly: - [`--fix-case`](https://rclone.org/docs/#fix-case) - [`--ignore-case-sync`](https://rclone.org/docs/#ignore-case-sync) - [`--no-unicode-normalization`](https://rclone.org/docs/#no-unicode-normalization) - [`--local-unicode-normalization`](https://rclone.org/local/#local-unicode-normalization) and [`--local-case-sensitive`](https://rclone.org/local/#local-case-sensitive) (caution: these are normally not what you want.) Note that in the (probably rare) event that `--fix-case` is used AND a file is new/changed on both sides AND the checksums match AND the filename case does not match, the Path1 filename is considered the winner, for the purposes of `--fix-case` (Path2 will be renamed to match it). ## Windows support {#windows} Bisync has been tested on Windows 8.1, Windows 10 Pro 64-bit and on Windows GitHub runners. Drive letters are allowed, including drive letters mapped to network drives (`rclone bisync J:\localsync GDrive:`). If a drive letter is omitted, the shell current drive is the default. Drive letters are a single character follows by `:`, so cloud names must be more than one character long. Absolute paths (with or without a drive letter), and relative paths (with or without a drive letter) are supported. Working directory is created at `C:\Users\MyLogin\AppData\Local\rclone\bisync`. Note that bisync output may show a mix of forward `/` and back `\` slashes. Be careful of case independent directory and file naming on Windows vs. case dependent Linux ## Filtering {#filtering} See [filtering documentation](https://rclone.org/filtering/) for how filter rules are written and interpreted. Bisync's [`--filters-file`](#filters-file) flag slightly extends the rclone's [--filter-from](https://rclone.org/filtering/#filter-from-read-filtering-patterns-from-a-file) filtering mechanism. For a given bisync run you may provide *only one* `--filters-file`. The `--include*`, `--exclude*`, and `--filter` flags are also supported. ### How to filter directories Filtering portions of the directory tree is a critical feature for syncing. Examples of directory trees (always beneath the Path1/Path2 root level) you may want to exclude from your sync: - Directory trees containing only software build intermediate files. - Directory trees containing application temporary files and data such as the Windows `C:\Users\MyLogin\AppData\` tree. - Directory trees containing files that are large, less important, or are getting thrashed continuously by ongoing processes. On the other hand, there may be only select directories that you actually want to sync, and exclude all others. See the [Example include-style filters for Windows user directories](#include-filters) below. ### Filters file writing guidelines 1. Begin with excluding directory trees: - e.g. `- /AppData/` - `**` on the end is not necessary. Once a given directory level is excluded then everything beneath it won't be looked at by rclone. - Exclude such directories that are unneeded, are big, dynamically thrashed, or where there may be access permission issues. - Excluding such dirs first will make rclone operations (much) faster. - Specific files may also be excluded, as with the Dropbox exclusions example below. 2. Decide if it's easier (or cleaner) to: - Include select directories and therefore *exclude everything else* -- or -- - Exclude select directories and therefore *include everything else* 3. Include select directories: - Add lines like: `+ /Documents/PersonalFiles/**` to select which directories to include in the sync. - `**` on the end specifies to include the full depth of the specified tree. - With Include-style filters, files at the Path1/Path2 root are not included. They may be included with `+ /*`. - Place RCLONE_TEST files within these included directory trees. They will only be looked for in these directory trees. - Finish by excluding everything else by adding `- **` at the end of the filters file. - Disregard step 4. 4. Exclude select directories: - Add more lines like in step 1. For example: `-/Desktop/tempfiles/`, or `- /testdir/`. Again, a `**` on the end is not necessary. - Do *not* add a `- **` in the file. Without this line, everything will be included that has not been explicitly excluded. - Disregard step 3. A few rules for the syntax of a filter file expanding on [filtering documentation](https://rclone.org/filtering/): - Lines may start with spaces and tabs - rclone strips leading whitespace. - If the first non-whitespace character is a `#` then the line is a comment and will be ignored. - Blank lines are ignored. - The first non-whitespace character on a filter line must be a `+` or `-`. - Exactly 1 space is allowed between the `+/-` and the path term. - Only forward slashes (`/`) are used in path terms, even on Windows. - The rest of the line is taken as the path term. Trailing whitespace is taken literally, and probably is an error. ### Example include-style filters for Windows user directories {#include-filters} This Windows *include-style* example is based on the sync root (Path1) set to `C:\Users\MyLogin`. The strategy is to select specific directories to be synched with a network drive (Path2). - `- /AppData/` excludes an entire tree of Windows stored stuff that need not be synched. In my case, AppData has >11 GB of stuff I don't care about, and there are some subdirectories beneath AppData that are not accessible to my user login, resulting in bisync critical aborts. - Windows creates cache files starting with both upper and lowercase `NTUSER` at `C:\Users\MyLogin`. These files may be dynamic, locked, and are generally *don't care*. - There are just a few directories with *my* data that I do want synched, in the form of `+ /`. By selecting only the directory trees I want to avoid the dozen plus directories that various apps make at `C:\Users\MyLogin\Documents`. - Include files in the root of the sync point, `C:\Users\MyLogin`, by adding the `+ /*` line. - This is an Include-style filters file, therefore it ends with `- **` which excludes everything not explicitly included. ```text - /AppData/ - NTUSER* - ntuser* + /Documents/Family/** + /Documents/Sketchup/** + /Documents/Microcapture_Photo/** + /Documents/Microcapture_Video/** + /Desktop/** + /Pictures/** + /* - ** ``` Note also that Windows implements several "library" links such as `C:\Users\MyLogin\My Documents\My Music` pointing to `C:\Users\MyLogin\Music`. rclone sees these as links, so you must add `--links` to the bisync command line if you which to follow these links. I find that I get permission errors in trying to follow the links, so I don't include the rclone `--links` flag, but then you get lots of `Can't follow symlink…` noise from rclone about not following the links. This noise can be quashed by adding `--quiet` to the bisync command line. ## Example exclude-style filters files for use with Dropbox {#exclude-filters} - Dropbox disallows syncing the listed temporary and configuration/data files. The `- ` filters exclude these files where ever they may occur in the sync tree. Consider adding similar exclusions for file types you don't need to sync, such as core dump and software build files. - bisync testing creates `/testdir/` at the top level of the sync tree, and usually deletes the tree after the test. If a normal sync should run while the `/testdir/` tree exists the `--check-access` phase may fail due to unbalanced RCLONE_TEST files. The `- /testdir/` filter blocks this tree from being synched. You don't need this exclusion if you are not doing bisync development testing. - Everything else beneath the Path1/Path2 root will be synched. - RCLONE_TEST files may be placed anywhere within the tree, including the root. ### Example filters file for Dropbox {#example-filters-file} ```text # Filter file for use with bisync # See https://rclone.org/filtering/ for filtering rules # NOTICE: If you make changes to this file you MUST do a --resync run. # Run with --dry-run to see what changes will be made. # Dropbox won't sync some files so filter them away here. # See https://help.dropbox.com/installs-integrations/sync-uploads/files-not-syncing - .dropbox.attr - ~*.tmp - ~$* - .~* - desktop.ini - .dropbox # Used for bisync testing, so excluded from normal runs - /testdir/ # Other example filters #- /TiBU/ #- /Photos/ ``` ### How --check-access handles filters At the start of a bisync run, listings are gathered for Path1 and Path2 while using the user's `--filters-file`. During the check access phase, bisync scans these listings for `RCLONE_TEST` files. Any `RCLONE_TEST` files hidden by the `--filters-file` are *not* in the listings and thus not checked during the check access phase. ## Troubleshooting {#troubleshooting} ### Reading bisync logs Here are two normal runs. The first one has a newer file on the remote. The second has no deltas between local and remote. ```bash 2021/05/16 00:24:38 INFO : Synching Path1 "/path/to/local/tree/" with Path2 "dropbox:/" 2021/05/16 00:24:38 INFO : Path1 checking for diffs 2021/05/16 00:24:38 INFO : - Path1 File is new - file.txt 2021/05/16 00:24:38 INFO : Path1: 1 changes: 1 new, 0 newer, 0 older, 0 deleted 2021/05/16 00:24:38 INFO : Path2 checking for diffs 2021/05/16 00:24:38 INFO : Applying changes 2021/05/16 00:24:38 INFO : - Path1 Queue copy to Path2 - dropbox:/file.txt 2021/05/16 00:24:38 INFO : - Path1 Do queued copies to - Path2 2021/05/16 00:24:38 INFO : Updating listings 2021/05/16 00:24:38 INFO : Validating listings for Path1 "/path/to/local/tree/" vs Path2 "dropbox:/" 2021/05/16 00:24:38 INFO : Bisync successful 2021/05/16 00:36:52 INFO : Synching Path1 "/path/to/local/tree/" with Path2 "dropbox:/" 2021/05/16 00:36:52 INFO : Path1 checking for diffs 2021/05/16 00:36:52 INFO : Path2 checking for diffs 2021/05/16 00:36:52 INFO : No changes found 2021/05/16 00:36:52 INFO : Updating listings 2021/05/16 00:36:52 INFO : Validating listings for Path1 "/path/to/local/tree/" vs Path2 "dropbox:/" 2021/05/16 00:36:52 INFO : Bisync successful ``` ### Dry run oddity The `--dry-run` messages may indicate that it would try to delete some files. For example, if a file is new on Path2 and does not exist on Path1 then it would normally be copied to Path1, but with `--dry-run` enabled those copies don't happen, which leads to the attempted delete on Path2, blocked again by --dry-run: `... Not deleting as --dry-run`. This whole confusing situation is an artifact of the `--dry-run` flag. Scrutinize the proposed deletes carefully, and if the files would have been copied to Path1 then the threatened deletes on Path2 may be disregarded. ### Retries Rclone has built-in retries. If you run with `--verbose` you'll see error and retry messages such as shown below. This is usually not a bug. If at the end of the run, you see `Bisync successful` and not `Bisync critical error` or `Bisync aborted` then the run was successful, and you can ignore the error messages. The following run shows an intermittent fail. Lines *5* and *6* are low-level messages. Line *6* is a bubbled-up *warning* message, conveying the error. Rclone normally retries failing commands, so there may be numerous such messages in the log. Since there are no final error/warning messages on line *7*, rclone has recovered from failure after a retry, and the overall sync was successful. ```bash 1: 2021/05/14 00:44:12 INFO : Synching Path1 "/path/to/local/tree" with Path2 "dropbox:" 2: 2021/05/14 00:44:12 INFO : Path1 checking for diffs 3: 2021/05/14 00:44:12 INFO : Path2 checking for diffs 4: 2021/05/14 00:44:12 INFO : Path2: 113 changes: 22 new, 0 newer, 0 older, 91 deleted 5: 2021/05/14 00:44:12 ERROR : /path/to/local/tree/objects/af: error listing: unexpected end of JSON input 6: 2021/05/14 00:44:12 NOTICE: WARNING listing try 1 failed. - dropbox: 7: 2021/05/14 00:44:12 INFO : Bisync successful ``` This log shows a *Critical failure* which requires a `--resync` to recover from. See the [Runtime Error Handling](#error-handling) section. ```bash 2021/05/12 00:49:40 INFO : Google drive root '': Waiting for checks to finish 2021/05/12 00:49:40 INFO : Google drive root '': Waiting for transfers to finish 2021/05/12 00:49:40 INFO : Google drive root '': not deleting files as there were IO errors 2021/05/12 00:49:40 ERROR : Attempt 3/3 failed with 3 errors and: not deleting files as there were IO errors 2021/05/12 00:49:40 ERROR : Failed to sync: not deleting files as there were IO errors 2021/05/12 00:49:40 NOTICE: WARNING rclone sync try 3 failed. - /path/to/local/tree/ 2021/05/12 00:49:40 ERROR : Bisync aborted. Must run --resync to recover. ``` ### Denied downloads of "infected" or "abusive" files Google Drive has a filter for certain file types (`.exe`, `.apk`, et cetera) that by default cannot be copied from Google Drive to the local filesystem. If you are having problems, run with `--verbose` to see specifically which files are generating complaints. If the error is `This file has been identified as malware or spam and cannot be downloaded`, consider using the flag [--drive-acknowledge-abuse](https://rclone.org/drive/#drive-acknowledge-abuse). ### Google Docs (and other files of unknown size) {#gdocs} As of `v1.66`, [Google Docs](https://rclone.org/drive/#import-export-of-google-documents) (including Google Sheets, Slides, etc.) are now supported in bisync, subject to the same options, defaults, and limitations as in `rclone sync`. When bisyncing drive with non-drive backends, the drive -> non-drive direction is controlled by [`--drive-export-formats`](https://rclone.org/drive/#drive-export-formats) (default `"docx,xlsx,pptx,svg"`) and the non-drive -> drive direction is controlled by [`--drive-import-formats`](https://rclone.org/drive/#drive-import-formats) (default none.) For example, with the default export/import formats, a Google Sheet on the drive side will be synced to an `.xlsx` file on the non-drive side. In the reverse direction, `.xlsx` files with filenames that match an existing Google Sheet will be synced to that Google Sheet, while `.xlsx` files that do NOT match an existing Google Sheet will be copied to drive as normal `.xlsx` files (without conversion to Sheets, although the Google Drive web browser UI may still give you the option to open it as one.) If `--drive-import-formats` is set (it's not, by default), then all of the specified formats will be converted to Google Docs, if there is no existing Google Doc with a matching name. Caution: such conversion can be quite lossy, and in most cases it's probably not what you want! To bisync Google Docs as URL shortcut links (in a manner similar to "Drive for Desktop"), use: `--drive-export-formats url` (or [alternatives](https://rclone.org/drive/#exportformats:~:text=available%20Google%20Documents.-,Extension,macOS,-Standard%20options).) Note that these link files cannot be edited on the non-drive side -- you will get errors if you try to sync an edited link file back to drive. They CAN be deleted (it will result in deleting the corresponding Google Doc.) If you create a `.url` file on the non-drive side that does not match an existing Google Doc, bisyncing it will just result in copying the literal `.url` file over to drive (no Google Doc will be created.) So, as a general rule of thumb, think of them as read-only placeholders on the non-drive side, and make all your changes on the drive side. Likewise, even with other export-formats, it is best to only move/rename Google Docs on the drive side. This is because otherwise, bisync will interpret this as a file deleted and another created, and accordingly, it will delete the Google Doc and create a new file at the new path. (Whether or not that new file is a Google Doc depends on `--drive-import-formats`.) Lastly, take note that all Google Docs on the drive side have a size of `-1` and no checksum. Therefore, they cannot be reliably synced with the `--checksum` or `--size-only` flags. (To be exact: they will still get created/deleted, and bisync's delta engine will notice changes and queue them for syncing, but the underlying sync function will consider them identical and skip them.) To work around this, use the default (modtime and size) instead of `--checksum` or `--size-only`. To ignore Google Docs entirely, use [`--drive-skip-gdocs`](https://rclone.org/drive/#drive-skip-gdocs). ## Usage examples ### Cron {#cron} Rclone does not yet have a built-in capability to monitor the local file system for changes and must be blindly run periodically. On Windows this can be done using a *Task Scheduler*, on Linux you can use *Cron* which is described below. The 1st example runs a sync every 5 minutes between a local directory and an OwnCloud server, with output logged to a runlog file: ```bash # Minute (0-59) # Hour (0-23) # Day of Month (1-31) # Month (1-12 or Jan-Dec) # Day of Week (0-6 or Sun-Sat) # Command */5 * * * * /path/to/rclone bisync /local/files MyCloud: --check-access --filters-file /path/to/bysync-filters.txt --log-file /path/to//bisync.log ``` See [crontab syntax](https://www.man7.org/linux/man-pages/man1/crontab.1p.html#INPUT_FILES) for the details of crontab time interval expressions. If you run `rclone bisync` as a cron job, redirect stdout/stderr to a file. The 2nd example runs a sync to Dropbox every hour and logs all stdout (via the `>>`) and stderr (via `2>&1`) to a log file. ```bash 0 * * * * /path/to/rclone bisync /path/to/local/dropbox Dropbox: --check-access --filters-file /home/user/filters.txt >> /path/to/logs/dropbox-run.log 2>&1 ``` ### Sharing an encrypted folder tree between hosts bisync can keep a local folder in sync with a cloud service, but what if you have some highly sensitive files to be synched? Usage of a cloud service is for exchanging both routine and sensitive personal files between one's home network, one's personal notebook when on the road, and with one's work computer. The routine data is not sensitive. For the sensitive data, configure an rclone [crypt remote](https://rclone.org/crypt/) to point to a subdirectory within the local disk tree that is bisync'd to Dropbox, and then set up an bisync for this local crypt directory to a directory outside of the main sync tree. ### Linux server setup - `/path/to/DBoxroot` is the root of my local sync tree. There are numerous subdirectories. - `/path/to/DBoxroot/crypt` is the root subdirectory for files that are encrypted. This local directory target is setup as an rclone crypt remote named `Dropcrypt:`. See [rclone.conf](#rclone-conf-snippet) snippet below. - `/path/to/my/unencrypted/files` is the root of my sensitive files - not encrypted, not within the tree synched to Dropbox. - To sync my local unencrypted files with the encrypted Dropbox versions I manually run `bisync /path/to/my/unencrypted/files DropCrypt:`. This step could be bundled into a script to run before and after the full Dropbox tree sync in the last step, thus actively keeping the sensitive files in sync. - `bisync /path/to/DBoxroot Dropbox:` runs periodically via cron, keeping my full local sync tree in sync with Dropbox. ### Windows notebook setup - The Dropbox client runs keeping the local tree `C:\Users\MyLogin\Dropbox` always in sync with Dropbox. I could have used `rclone bisync` instead. - A separate directory tree at `C:\Users\MyLogin\Documents\DropLocal` hosts the tree of unencrypted files/folders. - To sync my local unencrypted files with the encrypted Dropbox versions I manually run the following command: `rclone bisync C:\Users\MyLogin\Documents\DropLocal Dropcrypt:`. - The Dropbox client then syncs the changes with Dropbox. ### rclone.conf snippet {#rclone-conf-snippet} ```ini [Dropbox] type = dropbox ... [Dropcrypt] type = crypt remote = /path/to/DBoxroot/crypt # on the Linux server remote = C:\Users\MyLogin\Dropbox\crypt # on the Windows notebook filename_encryption = standard directory_name_encryption = true password = ... ... ``` ## Testing {#testing} You should read this section only if you are developing for rclone. You need to have rclone source code locally to work with bisync tests. Bisync has a dedicated test framework implemented in the `bisync_test.go` file located in the rclone source tree. The test suite is based on the `go test` command. Series of tests are stored in subdirectories below the `cmd/bisync/testdata` directory. Individual tests can be invoked by their directory name, e.g. `go test . -case basic -remote local -remote2 gdrive: -v` Tests will make a temporary folder on remote and purge it afterwards. If during test run there are intermittent errors and rclone retries, these errors will be captured and flagged as invalid MISCOMPAREs. Rerunning the test will let it pass. Consider such failures as noise. ### Test command syntax ```bash usage: go test ./cmd/bisync [options...] Options: -case NAME Name(s) of the test case(s) to run. Multiple names should be separated by commas. You can remove the `test_` prefix and replace `_` by `-` in test name for convenience. If not `all`, the name(s) should map to a directory under `./cmd/bisync/testdata`. Use `all` to run all tests (default: all) -remote PATH1 `local` or name of cloud service with `:` (default: local) -remote2 PATH2 `local` or name of cloud service with `:` (default: local) -no-compare Disable comparing test results with the golden directory (default: compare) -no-cleanup Disable cleanup of Path1 and Path2 testdirs. Useful for troubleshooting. (default: cleanup) -golden Store results in the golden directory (default: false) This flag can be used with multiple tests. -debug Print debug messages -stop-at NUM Stop test after given step number. (default: run to the end) Implies `-no-compare` and `-no-cleanup`, if the test really ends prematurely. Only meaningful for a single test case. -refresh-times Force refreshing the target modtime, useful for Dropbox (default: false) -verbose Run tests verbosely ``` Note: unlike rclone flags which must be prefixed by double dash (`--`), the test command flags can be equally prefixed by a single `-` or double dash. ### Running tests - `go test . -case basic -remote local -remote2 local` runs the `test_basic` test case using only the local filesystem, syncing one local directory with another local directory. Test script output is to the console, while commands within scenario.txt have their output sent to the `.../workdir/test.log` file, which is finally compared to the golden copy. - The first argument after `go test` should be a relative name of the directory containing bisync source code. If you run tests right from there, the argument will be `.` (current directory) as in most examples below. If you run bisync tests from the rclone source directory, the command should be `go test ./cmd/bisync ...`. - The test engine will mangle rclone output to ensure comparability with golden listings and logs. - Test scenarios are located in `./cmd/bisync/testdata`. The test `-case` argument should match the full name of a subdirectory under that directory. Every test subdirectory name on disk must start with `test_`, this prefix can be omitted on command line for brevity. Also, underscores in the name can be replaced by dashes for convenience. - `go test . -remote local -remote2 local -case all` runs all tests. - Path1 and Path2 may either be the keyword `local` or may be names of configured cloud services. `go test . -remote gdrive: -remote2 dropbox: -case basic` will run the test between these two services, without transferring any files to the local filesystem. - Test run stdout and stderr console output may be directed to a file, e.g. `go test . -remote gdrive: -remote2 local -case all > runlog.txt 2>&1` ### Test execution flow 1. The base setup in the `initial` directory of the testcase is applied on the Path1 and Path2 filesystems (via rclone copy the initial directory to Path1, then rclone sync Path1 to Path2). 2. The commands in the scenario.txt file are applied, with output directed to the `test.log` file in the test working directory. Typically, the first actual command in the `scenario.txt` file is to do a `--resync`, which establishes the baseline `{...}.path1.lst` and `{...}.path2.lst` files in the test working directory (`.../workdir/` relative to the temporary test directory). Various commands and listing snapshots are done within the test. 3. Finally, the contents of the test working directory are compared to the contents of the testcase's golden directory. ### Notes about testing - Test cases are in individual directories beneath `./cmd/bisync/testdata`. A command line reference to a test is understood to reference a directory beneath `testdata`. For example, `go test ./cmd/bisync -case dry-run -remote gdrive: -remote2 local` refers to the test case in `./cmd/bisync/testdata/test_dry_run`. - The test working directory is located at `.../workdir` relative to a temporary test directory, usually under `/tmp` on Linux. - The local test sync tree is created at a temporary directory named like `bisync.XXX` under system temporary directory. - The remote test sync tree is located at a temporary directory under `/bisync.XXX/`. - `path1` and/or `path2` subdirectories are created in a temporary directory under the respective local or cloud test remote. - By default, the Path1 and Path2 test dirs and workdir will be deleted after each test run. The `-no-cleanup` flag disables purging these directories when validating and debugging a given test. These directories will be flushed before running another test, independent of the `-no-cleanup` usage. - You will likely want to add `- /testdir/` to your normal bisync `--filters-file` so that normal syncs do not attempt to sync the test temporary directories, which may have `RCLONE_TEST` miscompares in some testcases which would otherwise trip the `--check-access` system. The `--check-access` mechanism is hard-coded to ignore `RCLONE_TEST` files beneath `bisync/testdata`, so the test cases may reside on the synched tree even if there are check file mismatches in the test tree. - Some Dropbox tests can fail, notably printing the following message: `src and dst identical but can't set mod time without deleting and re-uploading` This is expected and happens due to the way Dropbox handles modification times. You should use the `-refresh-times` test flag to make up for this. - If Dropbox tests hit request limit for you and print error message `too_many_requests/...: Too many requests or write operations.` then follow the [Dropbox App ID instructions](https://rclone.org/dropbox/#get-your-own-dropbox-app-id). ### Updating golden results Sometimes even a slight change in the bisync source can cause little changes spread around many log files. Updating them manually would be a nightmare. The `-golden` flag will store the `test.log` and `*.lst` listings from each test case into respective golden directories. Golden results will automatically contain generic strings instead of local or cloud paths which means that they should match when run with a different cloud service. Your normal workflow might be as follows: 1. Git-clone the rclone sources locally 2. Modify bisync source and check that it builds 3. Run the whole test suite `go test ./cmd/bisync -remote local` 4. If some tests show log difference, recheck them individually, e.g.: `go test ./cmd/bisync -remote local -case basic` 5. If you are convinced with the difference, goldenize all tests at once: `go test ./cmd/bisync -remote local -golden` 6. Use word diff: `git diff --word-diff ./cmd/bisync/testdata/`. Please note that normal line-level diff is generally useless here. 7. Check the difference *carefully*! 8. Commit the change (`git commit`) *only* if you are sure. If unsure, save your code changes then wipe the log diffs from git: `git reset [--hard]`. ### Structure of test scenarios - `/initial/` contains a tree of files that will be set as the initial condition on both Path1 and Path2 testdirs. - `/modfiles/` contains files that will be used to modify the Path1 and/or Path2 filesystems. - `/golden/` contains the expected content of the test working directory (`workdir`) at the completion of the testcase. - `/scenario.txt` contains the body of the test, in the form of various commands to modify files, run bisync, and snapshot listings. Output from these commands is captured to `.../workdir/test.log` for comparison to the golden files. ### Supported test commands - `test ` Print the line to the console and to the `test.log`: `test sync is working correctly with options x, y, z` - `copy-listings ` Save a copy of all `.lst` listings in the test working directory with the specified prefix: `save-listings exclude-pass-run` - `move-listings ` Similar to `copy-listings` but removes the source - `purge-children ` This will delete all child files and purge all child subdirs under given directory but keep the parent intact. This behavior is important for tests with Google Drive because removing and re-creating the parent would change its ID. - `delete-file ` Delete a single file. - `delete-glob ` Delete a group of files located one level deep in the given directory with names matching a given glob pattern. - `touch-glob YYYY-MM-DD ` Change modification time on a group of files. - `touch-copy YYYY-MM-DD ` Change file modification time then copy it to destination. - `copy-file ` Copy a single file to given directory. - `copy-as ` Similar to above but destination must include both directory and the new file name at destination. - `copy-dir ` and `sync-dir ` Copy/sync a directory. Equivalent of `rclone copy` and `rclone sync`. - `list-dirs ` Equivalent to `rclone lsf -R --dirs-only ` - `bisync [options]` Runs bisync against `-remote` and `-remote2`. ### Supported substitution terms - `{testdir/}` - the root dir of the testcase - `{datadir/}` - the `modfiles` dir under the testcase root - `{workdir/}` - the temporary test working directory - `{path1/}` - the root of the Path1 test directory tree - `{path2/}` - the root of the Path2 test directory tree - `{session}` - base name of the test listings - `{/}` - OS-specific path separator - `{spc}`, `{tab}`, `{eol}` - whitespace - `{chr:HH}` - raw byte with given hexadecimal code Substitution results of the terms named like `{dir/}` will end with `/` (or backslash on Windows), so it is not necessary to include slash in the usage, for example `delete-file {path1/}file1.txt`. ## Benchmarks *This section is work in progress.* Here are a few data points for scale, execution times, and memory usage. The first set of data was taken between a local disk to Dropbox. The [speedtest.net](https://speedtest.net) download speed was ~170 Mbps, and upload speed was ~10 Mbps. 500 files (~9.5 MB each) had been already synched. 50 files were added in a new directory, each ~9.5 MB, ~475 MB total. Change | Operations and times | Overall run time --------------------------------------|--------------------------------------------------------|------------------ 500 files synched (nothing to move) | 1x listings for Path1 & Path2 | 1.5 sec 500 files synched with --check-access | 1x listings for Path1 & Path2 | 1.5 sec 50 new files on remote | Queued 50 copies down: 27 sec | 29 sec Moved local dir | Queued 50 copies up: 410 sec, 50 deletes up: 9 sec | 421 sec Moved remote dir | Queued 50 copies down: 31 sec, 50 deletes down: <1 sec | 33 sec Delete local dir | Queued 50 deletes up: 9 sec | 13 sec This next data is from a user's application. They had ~400GB of data over 1.96 million files being sync'ed between a Windows local disk and some remote cloud. The file full path length was on average 35 characters (which factors into load time and RAM required). - Loading the prior listing into memory (1.96 million files, listing file size 140 MB) took ~30 sec and occupied about 1 GB of RAM. - Getting a fresh listing of the local file system (producing the 140 MB output file) took about XXX sec. - Getting a fresh listing of the remote file system (producing the 140 MB output file) took about XXX sec. The network download speed was measured at XXX Mb/s. - Once the prior and current Path1 and Path2 listings were loaded (a total of four to be loaded, two at a time), determining the deltas was pretty quick (a few seconds for this test case), and the transfer time for any files to be copied was dominated by the network bandwidth. ## References rclone's bisync implementation was derived from the [rclonesync-V2](https://github.com/cjnaz/rclonesync-V2) project, including documentation and test mechanisms, with [@cjnaz](https://github.com/cjnaz)'s full support and encouragement. `rclone bisync` is similar in nature to a range of other projects: - [unison](https://github.com/bcpierce00/unison) - [syncthing](https://github.com/syncthing/syncthing) - [cjnaz/rclonesync](https://github.com/cjnaz/rclonesync-V2) - [ConorWilliams/rsinc](https://github.com/ConorWilliams/rsinc) - [jwink3101/syncrclone](https://github.com/Jwink3101/syncrclone) - [DavideRossi/upback](https://github.com/DavideRossi/upback) Bisync adopts the differential synchronization technique, which is based on keeping history of changes performed by both synchronizing sides. See the *Dual Shadow Method* section in [Neil Fraser's article](https://neil.fraser.name/writing/sync/). Also note a number of academic publications by [Benjamin Pierce](http://www.cis.upenn.edu/%7Ebcpierce/papers/index.shtml#File%20Synchronization) about *Unison* and synchronization in general. ## Changelog ### `v1.71` - `bisync` is now officially released from beta. - Fixed an issue causing hash type to be set incorrectly if `path2` had slow hashes and `--no-slow-hash` or `--slow-hash-sync-only` was in use. - Fixed an issue causing errors when running concurrent bisync runs through the `rc`. ### `v1.69.1` - Fixed an issue causing listings to not capture concurrent modifications under certain conditions ### `v1.68` - Fixed an issue affecting backends that round modtimes to a lower precision. ### `v1.67` - Added integration tests against all backends. ### `v1.66` - Copies and deletes are now handled in one operation instead of two - `--track-renames` and `--backup-dir` are now supported - Partial uploads known issue on `local`/`ftp`/`sftp` has been resolved (unless using `--inplace`) - Final listings are now generated from sync results, to avoid needing to re-list - Bisync is now much more resilient to changes that happen during a bisync run, and far less prone to critical errors / undetected changes - Bisync is now capable of rolling a file listing back in cases of uncertainty, essentially marking the file as needing to be rechecked next time. - A few basic terminal colors are now supported, controllable with [`--color`](https://rclone.org/docs/#color) (`AUTO`|`NEVER`|`ALWAYS`) - Initial listing snapshots of Path1 and Path2 are now generated concurrently, using the same "march" infrastructure as `check` and `sync`, for performance improvements and less [risk of error](https://forum.rclone.org/t/bisync-bugs-and-feature-requests/37636#:~:text=4.%20Listings%20should%20alternate%20between%20paths%20to%20minimize%20errors). - Fixed handling of unicode normalization and case insensitivity, support for [`--fix-case`](https://rclone.org/docs/#fix-case), [`--ignore-case-sync`](/docs/#ignore-case-sync), [`--no-unicode-normalization`](https://rclone.org/docs/#no-unicode-normalization) - `--resync` is now much more efficient (especially for users of `--create-empty-src-dirs`) - Google Docs (and other files of unknown size) are now supported (with the same options as in `sync`) - Equality checks before a sync conflict rename now fall back to `cryptcheck` (when possible) or `--download`, instead of of `--size-only`, when `check` is not available. - Bisync no longer fails to find the correct listing file when configs are overridden with backend-specific flags. - Bisync now fully supports comparing based on any combination of size, modtime, and checksum, lifting the prior restriction on backends without modtime support. - Bisync now supports a "Graceful Shutdown" mode to cleanly cancel a run early without requiring `--resync`. - New `--recover` flag allows robust recovery in the event of interruptions, without requiring `--resync`. - A new `--max-lock` setting allows lock files to automatically renew and expire, for better automatic recovery when a run is interrupted. - Bisync now supports auto-resolving sync conflicts and customizing rename behavior with new [`--conflict-resolve`](#conflict-resolve), [`--conflict-loser`](#conflict-loser), and [`--conflict-suffix`](#conflict-suffix) flags. - A new [`--resync-mode`](#resync-mode) flag allows more control over which version of a file gets kept during a `--resync`. - Bisync now supports [`--retries`](https://rclone.org/docs/#retries-int) and [`--retries-sleep`](/docs/#retries-sleep-time) (when [`--resilient`](#resilient) is set.) ### `v1.64` - Fixed an [issue](https://forum.rclone.org/t/bisync-bugs-and-feature-requests/37636#:~:text=1.%20Dry%20runs%20are%20not%20completely%20dry) causing dry runs to inadvertently commit filter changes - Fixed an [issue](https://forum.rclone.org/t/bisync-bugs-and-feature-requests/37636#:~:text=2.%20%2D%2Dresync%20deletes%20data%2C%20contrary%20to%20docs) causing `--resync` to erroneously delete empty folders and duplicate files unique to Path2 - `--check-access` is now enforced during `--resync`, preventing data loss in [certain user error scenarios](https://forum.rclone.org/t/bisync-bugs-and-feature-requests/37636#:~:text=%2D%2Dcheck%2Daccess%20doesn%27t%20always%20fail%20when%20it%20should) - Fixed an [issue](https://forum.rclone.org/t/bisync-bugs-and-feature-requests/37636#:~:text=5.%20Bisync%20reads%20files%20in%20excluded%20directories%20during%20delete%20operations) causing bisync to consider more files than necessary due to overbroad filters during delete operations - [Improved detection of false positive change conflicts](https://forum.rclone.org/t/bisync-bugs-and-feature-requests/37636#:~:text=1.%20Identical%20files%20should%20be%20left%20alone%2C%20even%20if%20new/newer/changed%20on%20both%20sides) (identical files are now left alone instead of renamed) - Added [support for `--create-empty-src-dirs`](https://forum.rclone.org/t/bisync-bugs-and-feature-requests/37636#:~:text=3.%20Bisync%20should%20create/delete%20empty%20directories%20as%20sync%20does%2C%20when%20%2D%2Dcreate%2Dempty%2Dsrc%2Ddirs%20is%20passed) - Added experimental `--resilient` mode to allow [recovery from self-correctable errors](https://forum.rclone.org/t/bisync-bugs-and-feature-requests/37636#:~:text=2.%20Bisync%20should%20be%20more%20resilient%20to%20self%2Dcorrectable%20errors) - Added [new `--ignore-listing-checksum` flag](https://forum.rclone.org/t/bisync-bugs-and-feature-requests/37636#:~:text=6.%20%2D%2Dignore%2Dchecksum%20should%20be%20split%20into%20two%20flags%20for%20separate%20purposes) to distinguish from `--ignore-checksum` - [Performance improvements](https://forum.rclone.org/t/bisync-bugs-and-feature-requests/37636#:~:text=6.%20Deletes%20take%20several%20times%20longer%20than%20copies) for large remotes - Documentation and testing improvements # Release signing The hashes of the binary artefacts of the rclone release are signed with a public PGP/GPG key. This can be verified manually as described below. The same mechanism is also used by [rclone selfupdate](https://rclone.org/commands/rclone_selfupdate/) to verify that the release has not been tampered with before the new update is installed. This checks the SHA256 hash and the signature with a public key compiled into the rclone binary. ## Release signing key You may obtain the release signing key from: - From [KEYS](/KEYS) on this website - this file contains all past signing keys also. - The git repository hosted on GitHub - https://github.com/rclone/rclone/blob/master/docs/content/KEYS - `gpg --keyserver hkps://keys.openpgp.org --search nick@craig-wood.com` - `gpg --keyserver hkps://keyserver.ubuntu.com --search nick@craig-wood.com` - https://www.craig-wood.com/nick/pub/pgp-key.txt After importing the key, verify that the fingerprint of one of the keys matches: `FBF737ECE9F8AB18604BD2AC93935E02FF3B54FA` as this key is used for signing. We recommend that you cross-check the fingerprint shown above through the domains listed below. By cross-checking the integrity of the fingerprint across multiple domains you can be confident that you obtained the correct key. - The [source for this page on GitHub](https://github.com/rclone/rclone/blob/master/docs/content/release_signing.md). - Through DNS `dig key.rclone.org txt` If you find anything that doesn't not match, please contact the developers at once. ## How to verify the release In the release directory you will see the release files and some files called `MD5SUMS`, `SHA1SUMS` and `SHA256SUMS`. ``` $ rclone lsf --http-url https://downloads.rclone.org/v1.63.1 :http: MD5SUMS SHA1SUMS SHA256SUMS rclone-v1.63.1-freebsd-386.zip rclone-v1.63.1-freebsd-amd64.zip ... rclone-v1.63.1-windows-arm64.zip rclone-v1.63.1.tar.gz version.txt ``` The `MD5SUMS`, `SHA1SUMS` and `SHA256SUMS` contain hashes of the binary files in the release directory along with a signature. For example: ``` $ rclone cat --http-url https://downloads.rclone.org/v1.63.1 :http:SHA256SUMS -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 f6d1b2d7477475ce681bdce8cb56f7870f174cb6b2a9ac5d7b3764296ea4a113 rclone-v1.63.1-freebsd-386.zip 7266febec1f01a25d6575de51c44ddf749071a4950a6384e4164954dff7ac37e rclone-v1.63.1-freebsd-amd64.zip ... 66ca083757fb22198309b73879831ed2b42309892394bf193ff95c75dff69c73 rclone-v1.63.1-windows-amd64.zip bbb47c16882b6c5f2e8c1b04229378e28f68734c613321ef0ea2263760f74cd0 rclone-v1.63.1-windows-arm64.zip -----BEGIN PGP SIGNATURE----- iF0EARECAB0WIQT79zfs6firGGBL0qyTk14C/ztU+gUCZLVKJQAKCRCTk14C/ztU +pZuAJ0XJ+QWLP/3jCtkmgcgc4KAwd/rrwCcCRZQ7E+oye1FPY46HOVzCFU3L7g= =8qrL -----END PGP SIGNATURE----- ``` ### Download the files The first step is to download the binary and SUMs file and verify that the SUMs you have downloaded match. Here we download `rclone-v1.63.1-windows-amd64.zip` - choose the binary (or binaries) appropriate to your architecture. We've also chosen the `SHA256SUMS` as these are the most secure. You could verify the other types of hash also for extra security. `rclone selfupdate` verifies just the `SHA256SUMS`. ``` $ mkdir /tmp/check $ cd /tmp/check $ rclone copy --http-url https://downloads.rclone.org/v1.63.1 :http:SHA256SUMS . $ rclone copy --http-url https://downloads.rclone.org/v1.63.1 :http:rclone-v1.63.1-windows-amd64.zip . ``` ### Verify the signatures First verify the signatures on the SHA256 file. Import the key. See above for ways to verify this key is correct. ``` $ gpg --keyserver keyserver.ubuntu.com --receive-keys FBF737ECE9F8AB18604BD2AC93935E02FF3B54FA gpg: key 93935E02FF3B54FA: public key "Nick Craig-Wood " imported gpg: Total number processed: 1 gpg: imported: 1 ``` Then check the signature: ``` $ gpg --verify SHA256SUMS gpg: Signature made Mon 17 Jul 2023 15:03:17 BST gpg: using DSA key FBF737ECE9F8AB18604BD2AC93935E02FF3B54FA gpg: Good signature from "Nick Craig-Wood " [ultimate] ``` Verify the signature was good and is using the fingerprint shown above. Repeat for `MD5SUMS` and `SHA1SUMS` if desired. ### Verify the hashes Now that we know the signatures on the hashes are OK we can verify the binaries match the hashes, completing the verification. ``` $ sha256sum -c SHA256SUMS 2>&1 | grep OK rclone-v1.63.1-windows-amd64.zip: OK ``` Or do the check with rclone ``` $ rclone hashsum sha256 -C SHA256SUMS rclone-v1.63.1-windows-amd64.zip 2023/09/11 10:53:58 NOTICE: SHA256SUMS: improperly formatted checksum line 0 2023/09/11 10:53:58 NOTICE: SHA256SUMS: improperly formatted checksum line 1 2023/09/11 10:53:58 NOTICE: SHA256SUMS: improperly formatted checksum line 49 2023/09/11 10:53:58 NOTICE: SHA256SUMS: 4 warning(s) suppressed... = rclone-v1.63.1-windows-amd64.zip 2023/09/11 10:53:58 NOTICE: Local file system at /tmp/check: 0 differences found 2023/09/11 10:53:58 NOTICE: Local file system at /tmp/check: 1 matching files ``` ### Verify signatures and hashes together You can verify the signatures and hashes in one command line like this: ``` $ h=$(gpg --decrypt SHA256SUMS) && echo "$h" | sha256sum - -c --ignore-missing gpg: Signature made Mon 17 Jul 2023 15:03:17 BST gpg: using DSA key FBF737ECE9F8AB18604BD2AC93935E02FF3B54FA gpg: Good signature from "Nick Craig-Wood " [ultimate] gpg: aka "Nick Craig-Wood " [unknown] rclone-v1.63.1-windows-amd64.zip: OK ``` # 1Fichier This is a backend for the [1fichier](https://1fichier.com) cloud storage service. Note that a Premium subscription is required to use the API. Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configuration The initial setup for 1Fichier involves getting the API key from the website which you need to do in your browser. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / 1Fichier \ "fichier" [snip] Storage> fichier ** See help for fichier backend at: https://rclone.org/fichier/ ** Your API Key, get it from https://1fichier.com/console/params.pl Enter a string value. Press Enter for the default (""). api_key> example_key Edit advanced config? (y/n) y) Yes n) No y/n> Remote config Configuration complete. Options: - type: fichier - api_key: example_key Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` Once configured you can then use `rclone` like this, List directories in top level of your 1Fichier account rclone lsd remote: List all the files in your 1Fichier account rclone ls remote: To copy a local directory to a 1Fichier directory called backup rclone copy /home/source remote:backup ### Modification times and hashes 1Fichier does not support modification times. It supports the Whirlpool hash algorithm. ### Duplicated files 1Fichier can have two files with exactly the same name and path (unlike a normal file system). Duplicated files cause problems with the syncing and you will see messages in the log about duplicates. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | \ | 0x5C | ＼ | | < | 0x3C | ＜ | | > | 0x3E | ＞ | | " | 0x22 | ＂ | | $ | 0x24 | ＄ | | ` | 0x60 | ｀ | | ' | 0x27 | ＇ | File names can also not start or end with the following characters. These only get replaced if they are the first or last character in the name: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | SP | 0x20 | ␠ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Standard options Here are the Standard options specific to fichier (1Fichier). #### --fichier-api-key Your API Key, get it from https://1fichier.com/console/params.pl. Properties: - Config: api_key - Env Var: RCLONE_FICHIER_API_KEY - Type: string - Required: false ### Advanced options Here are the Advanced options specific to fichier (1Fichier). #### --fichier-shared-folder If you want to download a shared folder, add this parameter. Properties: - Config: shared_folder - Env Var: RCLONE_FICHIER_SHARED_FOLDER - Type: string - Required: false #### --fichier-file-password If you want to download a shared file that is password protected, add this parameter. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: file_password - Env Var: RCLONE_FICHIER_FILE_PASSWORD - Type: string - Required: false #### --fichier-folder-password If you want to list the files in a shared folder that is password protected, add this parameter. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: folder_password - Env Var: RCLONE_FICHIER_FOLDER_PASSWORD - Type: string - Required: false #### --fichier-cdn Set if you wish to use CDN download links. Properties: - Config: cdn - Env Var: RCLONE_FICHIER_CDN - Type: bool - Default: false #### --fichier-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_FICHIER_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,SingleQuote,BackQuote,Dollar,BackSlash,Del,Ctl,LeftSpace,RightSpace,InvalidUtf8,Dot #### --fichier-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_FICHIER_DESCRIPTION - Type: string - Required: false ## Limitations `rclone about` is not supported by the 1Fichier backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) # Alias The `alias` remote provides a new name for another remote. Paths may be as deep as required or a local path, e.g. `remote:directory/subdirectory` or `/directory/subdirectory`. During the initial setup with `rclone config` you will specify the target remote. The target remote can either be a local path or another remote. Subfolders can be used in target remote. Assume an alias remote named `backup` with the target `mydrive:private/backup`. Invoking `rclone mkdir backup:desktop` is exactly the same as invoking `rclone mkdir mydrive:private/backup/desktop`. There will be no special handling of paths containing `..` segments. Invoking `rclone mkdir backup:../desktop` is exactly the same as invoking `rclone mkdir mydrive:private/backup/../desktop`. The empty path is not allowed as a remote. To alias the current directory use `.` instead. The target remote can also be a [connection string](https://rclone.org/docs/#connection-strings). This can be used to modify the config of a remote for different uses, e.g. the alias `myDriveTrash` with the target remote `myDrive,trashed_only:` can be used to only show the trashed files in `myDrive`. ## Configuration Here is an example of how to make an alias called `remote` for local folder. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Alias for an existing remote \ "alias" [snip] Storage> alias Remote or path to alias. Can be "myremote:path/to/dir", "myremote:bucket", "myremote:" or "/local/path". remote> /mnt/storage/backup Remote config Configuration complete. Options: - type: alias - remote: /mnt/storage/backup Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== remote alias e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q ``` Once configured you can then use `rclone` like this, List directories in top level in `/mnt/storage/backup` rclone lsd remote: List all the files in `/mnt/storage/backup` rclone ls remote: Copy another local directory to the alias directory called source rclone copy /home/source remote:source ### Standard options Here are the Standard options specific to alias (Alias for an existing remote). #### --alias-remote Remote or path to alias. Can be "myremote:path/to/dir", "myremote:bucket", "myremote:" or "/local/path". Properties: - Config: remote - Env Var: RCLONE_ALIAS_REMOTE - Type: string - Required: true ### Advanced options Here are the Advanced options specific to alias (Alias for an existing remote). #### --alias-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_ALIAS_DESCRIPTION - Type: string - Required: false # Amazon S3 Storage Providers The S3 backend can be used with a number of different providers: - AWS S3 - Alibaba Cloud (Aliyun) Object Storage System (OSS) - Ceph - China Mobile Ecloud Elastic Object Storage (EOS) - Cloudflare R2 - Arvan Cloud Object Storage (AOS) - DigitalOcean Spaces - Dreamhost - Exaba - GCS - Huawei OBS - IBM COS S3 - IDrive e2 - IONOS Cloud - Leviia Object Storage - Liara Object Storage - Linode Object Storage - Magalu Object Storage - MEGA S4 Object Storage - Minio - Outscale - OVHcloud - Petabox - Pure Storage FlashBlade - Qiniu Cloud Object Storage (Kodo) - RackCorp Object Storage - Rclone Serve S3 - Scaleway - Seagate Lyve Cloud - SeaweedFS - Selectel - StackPath - Storj - Synology C2 Object Storage - Tencent Cloud Object Storage (COS) - Wasabi - Zata Paths are specified as `remote:bucket` (or `remote:` for the `lsd` command.) You may put subdirectories in too, e.g. `remote:bucket/path/to/dir`. Once you have made a remote (see the provider specific section above) you can use it like this: See all buckets rclone lsd remote: Make a new bucket rclone mkdir remote:bucket List the contents of a bucket rclone ls remote:bucket Sync `/home/local/directory` to the remote bucket, deleting any excess files in the bucket. rclone sync --interactive /home/local/directory remote:bucket ## Configuration Here is an example of making an s3 configuration for the AWS S3 provider. Most applies to the other providers as well, any differences are described [below](#providers). First run rclone config This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ "s3" [snip] Storage> s3 Choose your S3 provider. Choose a number from below, or type in your own value 1 / Amazon Web Services (AWS) S3 \ "AWS" 2 / Ceph Object Storage \ "Ceph" 3 / DigitalOcean Spaces \ "DigitalOcean" 4 / Dreamhost DreamObjects \ "Dreamhost" 5 / IBM COS S3 \ "IBMCOS" 6 / Minio Object Storage \ "Minio" 7 / Wasabi Object Storage \ "Wasabi" 8 / Any other S3 compatible provider \ "Other" provider> 1 Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID - leave blank for anonymous access or runtime credentials. access_key_id> XXX AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials. secret_access_key> YYY Region to connect to. Choose a number from below, or type in your own value / The default endpoint - a good choice if you are unsure. 1 | US Region, Northern Virginia, or Pacific Northwest. | Leave location constraint empty. \ "us-east-1" / US East (Ohio) Region 2 | Needs location constraint us-east-2. \ "us-east-2" / US West (Oregon) Region 3 | Needs location constraint us-west-2. \ "us-west-2" / US West (Northern California) Region 4 | Needs location constraint us-west-1. \ "us-west-1" / Canada (Central) Region 5 | Needs location constraint ca-central-1. \ "ca-central-1" / EU (Ireland) Region 6 | Needs location constraint EU or eu-west-1. \ "eu-west-1" / EU (London) Region 7 | Needs location constraint eu-west-2. \ "eu-west-2" / EU (Frankfurt) Region 8 | Needs location constraint eu-central-1. \ "eu-central-1" / Asia Pacific (Singapore) Region 9 | Needs location constraint ap-southeast-1. \ "ap-southeast-1" / Asia Pacific (Sydney) Region 10 | Needs location constraint ap-southeast-2. \ "ap-southeast-2" / Asia Pacific (Tokyo) Region 11 | Needs location constraint ap-northeast-1. \ "ap-northeast-1" / Asia Pacific (Seoul) 12 | Needs location constraint ap-northeast-2. \ "ap-northeast-2" / Asia Pacific (Mumbai) 13 | Needs location constraint ap-south-1. \ "ap-south-1" / Asia Pacific (Hong Kong) Region 14 | Needs location constraint ap-east-1. \ "ap-east-1" / South America (Sao Paulo) Region 15 | Needs location constraint sa-east-1. \ "sa-east-1" region> 1 Endpoint for S3 API. Leave blank if using AWS to use the default endpoint for the region. endpoint> Location constraint - must be set to match the Region. Used when creating buckets only. Choose a number from below, or type in your own value 1 / Empty for US Region, Northern Virginia, or Pacific Northwest. \ "" 2 / US East (Ohio) Region. \ "us-east-2" 3 / US West (Oregon) Region. \ "us-west-2" 4 / US West (Northern California) Region. \ "us-west-1" 5 / Canada (Central) Region. \ "ca-central-1" 6 / EU (Ireland) Region. \ "eu-west-1" 7 / EU (London) Region. \ "eu-west-2" 8 / EU Region. \ "EU" 9 / Asia Pacific (Singapore) Region. \ "ap-southeast-1" 10 / Asia Pacific (Sydney) Region. \ "ap-southeast-2" 11 / Asia Pacific (Tokyo) Region. \ "ap-northeast-1" 12 / Asia Pacific (Seoul) \ "ap-northeast-2" 13 / Asia Pacific (Mumbai) \ "ap-south-1" 14 / Asia Pacific (Hong Kong) \ "ap-east-1" 15 / South America (Sao Paulo) Region. \ "sa-east-1" location_constraint> 1 Canned ACL used when creating buckets and/or storing objects in S3. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Choose a number from below, or type in your own value 1 / Owner gets FULL_CONTROL. No one else has access rights (default). \ "private" 2 / Owner gets FULL_CONTROL. The AllUsers group gets READ access. \ "public-read" / Owner gets FULL_CONTROL. The AllUsers group gets READ and WRITE access. 3 | Granting this on a bucket is generally not recommended. \ "public-read-write" 4 / Owner gets FULL_CONTROL. The AuthenticatedUsers group gets READ access. \ "authenticated-read" / Object owner gets FULL_CONTROL. Bucket owner gets READ access. 5 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ "bucket-owner-read" / Both the object owner and the bucket owner get FULL_CONTROL over the object. 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ "bucket-owner-full-control" acl> 1 The server-side encryption algorithm used when storing this object in S3. Choose a number from below, or type in your own value 1 / None \ "" 2 / AES256 \ "AES256" server_side_encryption> 1 The storage class to use when storing objects in S3. Choose a number from below, or type in your own value 1 / Default \ "" 2 / Standard storage class \ "STANDARD" 3 / Reduced redundancy storage class \ "REDUCED_REDUNDANCY" 4 / Standard Infrequent Access storage class \ "STANDARD_IA" 5 / One Zone Infrequent Access storage class \ "ONEZONE_IA" 6 / Glacier Flexible Retrieval storage class \ "GLACIER" 7 / Glacier Deep Archive storage class \ "DEEP_ARCHIVE" 8 / Intelligent-Tiering storage class \ "INTELLIGENT_TIERING" 9 / Glacier Instant Retrieval storage class \ "GLACIER_IR" storage_class> 1 Remote config Configuration complete. Options: - type: s3 - provider: AWS - env_auth: false - access_key_id: XXX - secret_access_key: YYY - region: us-east-1 - endpoint: - location_constraint: - acl: private - server_side_encryption: - storage_class: Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> ``` ### Modification times and hashes #### Modification times The modified time is stored as metadata on the object as `X-Amz-Meta-Mtime` as floating point since the epoch, accurate to 1 ns. If the modification time needs to be updated rclone will attempt to perform a server side copy to update the modification if the object can be copied in a single part. In the case the object is larger than 5Gb or is in Glacier or Glacier Deep Archive storage the object will be uploaded rather than copied. Note that reading this from the object takes an additional `HEAD` request as the metadata isn't returned in object listings. #### Hashes For small objects which weren't uploaded as multipart uploads (objects sized below `--s3-upload-cutoff` if uploaded with rclone) rclone uses the `ETag:` header as an MD5 checksum. However for objects which were uploaded as multipart uploads or with server side encryption (SSE-AWS or SSE-C) the `ETag` header is no longer the MD5 sum of the data, so rclone adds an additional piece of metadata `X-Amz-Meta-Md5chksum` which is a base64 encoded MD5 hash (in the same format as is required for `Content-MD5`). You can use base64 -d and hexdump to check this value manually: echo 'VWTGdNx3LyXQDfA0e2Edxw==' | base64 -d | hexdump or you can use `rclone check` to verify the hashes are OK. For large objects, calculating this hash can take some time so the addition of this hash can be disabled with `--s3-disable-checksum`. This will mean that these objects do not have an MD5 checksum. Note that reading this from the object takes an additional `HEAD` request as the metadata isn't returned in object listings. ### Reducing costs #### Avoiding HEAD requests to read the modification time By default, rclone will use the modification time of objects stored in S3 for syncing. This is stored in object metadata which unfortunately takes an extra HEAD request to read which can be expensive (in time and money). The modification time is used by default for all operations that require checking the time a file was last updated. It allows rclone to treat the remote more like a true filesystem, but it is inefficient on S3 because it requires an extra API call to retrieve the metadata. The extra API calls can be avoided when syncing (using `rclone sync` or `rclone copy`) in a few different ways, each with its own tradeoffs. - `--size-only` - Only checks the size of files. - Uses no extra transactions. - If the file doesn't change size then rclone won't detect it has changed. - `rclone sync --size-only /path/to/source s3:bucket` - `--checksum` - Checks the size and MD5 checksum of files. - Uses no extra transactions. - The most accurate detection of changes possible. - Will cause the source to read an MD5 checksum which, if it is a local disk, will cause lots of disk activity. - If the source and destination are both S3 this is the **recommended** flag to use for maximum efficiency. - `rclone sync --checksum /path/to/source s3:bucket` - `--update --use-server-modtime` - Uses no extra transactions. - Modification time becomes the time the object was uploaded. - For many operations this is sufficient to determine if it needs uploading. - Using `--update` along with `--use-server-modtime`, avoids the extra API call and uploads files whose local modification time is newer than the time it was last uploaded. - Files created with timestamps in the past will be missed by the sync. - `rclone sync --update --use-server-modtime /path/to/source s3:bucket` These flags can and should be used in combination with `--fast-list` - see below. If using `rclone mount` or any command using the VFS (eg `rclone serve`) commands then you might want to consider using the VFS flag `--no-modtime` which will stop rclone reading the modification time for every object. You could also use `--use-server-modtime` if you are happy with the modification times of the objects being the time of upload. #### Avoiding GET requests to read directory listings Rclone's default directory traversal is to process each directory individually. This takes one API call per directory. Using the `--fast-list` flag will read all info about the objects into memory first using a smaller number of API calls (one per 1000 objects). See the [rclone docs](https://rclone.org/docs/#fast-list) for more details. rclone sync --fast-list --checksum /path/to/source s3:bucket `--fast-list` trades off API transactions for memory use. As a rough guide rclone uses 1k of memory per object stored, so using `--fast-list` on a sync of a million objects will use roughly 1 GiB of RAM. If you are only copying a small number of files into a big repository then using `--no-traverse` is a good idea. This finds objects directly instead of through directory listings. You can do a "top-up" sync very cheaply by using `--max-age` and `--no-traverse` to copy only recent files, eg rclone copy --max-age 24h --no-traverse /path/to/source s3:bucket You'd then do a full `rclone sync` less often. Note that `--fast-list` isn't required in the top-up sync. #### Avoiding HEAD requests after PUT By default, rclone will HEAD every object it uploads. It does this to check the object got uploaded correctly. You can disable this with the [--s3-no-head](#s3-no-head) option - see there for more details. Setting this flag increases the chance for undetected upload failures. ### Increasing performance #### Using server-side copy If you are copying objects between S3 buckets in the same region, you should use server-side copy. This is much faster than downloading and re-uploading the objects, as no data is transferred. For rclone to use server-side copy, you must use the same remote for the source and destination. rclone copy s3:source-bucket s3:destination-bucket When using server-side copy, the performance is limited by the rate at which rclone issues API requests to S3. See below for how to increase the number of API requests rclone makes. #### Increasing the rate of API requests You can increase the rate of API requests to S3 by increasing the parallelism using `--transfers` and `--checkers` options. Rclone uses a very conservative defaults for these settings, as not all providers support high rates of requests. Depending on your provider, you can increase significantly the number of transfers and checkers. For example, with AWS S3, if you can increase the number of checkers to values like 200. If you are doing a server-side copy, you can also increase the number of transfers to 200. rclone sync --transfers 200 --checkers 200 --checksum s3:source-bucket s3:destination-bucket You will need to experiment with these values to find the optimal settings for your setup. ### Data integrity Rclone does its best to verify every part of an upload or download to the s3 provider using various hashes. Every HTTP transaction to/from the provider has a `X-Amz-Content-Sha256` or a `Content-Md5` header to guard against corruption of the HTTP body. The HTTP Header is protected by the signature passed in the `Authorization` header. All communications with the provider is done over https for encryption and additional error protection. #### Single part uploads - Rclone uploads single part uploads with a `Content-Md5` using the MD5 hash read from the source. The provider checks this is correct on receipt of the data. - Rclone then does a HEAD request (disable with `--s3-no-head`) to read the `ETag` back which is the MD5 of the file and checks that with what it sent. Note that if the source does not have an MD5 then the single part uploads will not have hash protection. In this case it is recommended to use `--s3-upload-cutoff 0` so all files are uploaded as multipart uploads. #### Multipart uploads For files above `--s3-upload-cutoff` rclone splits the file into multiple parts for upload. - Each part is protected with both an `X-Amz-Content-Sha256` and a `Content-Md5` When rclone has finished the upload of all the parts it then completes the upload by sending: - The MD5 hash of each part - The number of parts - This info is all protected with a `X-Amz-Content-Sha256` The provider checks the MD5 for all the parts it has received against what rclone sends and if it is good it returns OK. Rclone then does a HEAD request (disable with `--s3-no-head`) and checks the ETag is what it expects (in this case it should be the MD5 sum of all the MD5 sums of all the parts with the number of parts on the end). If the source has an MD5 sum then rclone will attach the `X-Amz-Meta-Md5chksum` with it as the `ETag` for a multipart upload can't easily be checked against the file as the chunk size must be known in order to calculate it. #### Downloads Rclone checks the MD5 hash of the data downloaded against either the ETag or the `X-Amz-Meta-Md5chksum` metadata (if present) which rclone uploads with multipart uploads. #### Further checking At each stage rclone and the provider are sending and checking hashes of **everything**. Rclone deliberately HEADs each object after upload to check it arrived safely for extra security. (You can disable this with `--s3-no-head`). If you require further assurance that your data is intact you can use `rclone check` to check the hashes locally vs the remote. And if you are feeling ultimately paranoid use `rclone check --download` which will download the files and check them against the local copies. (Note that this doesn't use disk to do this - it streams them in memory). ### Versions When bucket versioning is enabled (this can be done with rclone with the [`rclone backend versioning`](#versioning) command) when rclone uploads a new version of a file it creates a [new version of it](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Versioning.html) Likewise when you delete a file, the old version will be marked hidden and still be available. Old versions of files, where available, are visible using the [`--s3-versions`](#s3-versions) flag. It is also possible to view a bucket as it was at a certain point in time, using the [`--s3-version-at`](#s3-version-at) flag. This will show the file versions as they were at that time, showing files that have been deleted afterwards, and hiding files that were created since. If you wish to remove all the old versions then you can use the [`rclone backend cleanup-hidden remote:bucket`](#cleanup-hidden) command which will delete all the old hidden versions of files, leaving the current ones intact. You can also supply a path and only old versions under that path will be deleted, e.g. `rclone backend cleanup-hidden remote:bucket/path/to/stuff`. When you `purge` a bucket, the current and the old versions will be deleted then the bucket will be deleted. However `delete` will cause the current versions of the files to become hidden old versions. Here is a session showing the listing and retrieval of an old version followed by a `cleanup` of the old versions. Show current version and all the versions with `--s3-versions` flag. ``` $ rclone -q ls s3:cleanup-test 9 one.txt $ rclone -q --s3-versions ls s3:cleanup-test 9 one.txt 8 one-v2016-07-04-141032-000.txt 16 one-v2016-07-04-141003-000.txt 15 one-v2016-07-02-155621-000.txt ``` Retrieve an old version ``` $ rclone -q --s3-versions copy s3:cleanup-test/one-v2016-07-04-141003-000.txt /tmp $ ls -l /tmp/one-v2016-07-04-141003-000.txt -rw-rw-r-- 1 ncw ncw 16 Jul 2 17:46 /tmp/one-v2016-07-04-141003-000.txt ``` Clean up all the old versions and show that they've gone. ``` $ rclone -q backend cleanup-hidden s3:cleanup-test $ rclone -q ls s3:cleanup-test 9 one.txt $ rclone -q --s3-versions ls s3:cleanup-test 9 one.txt ``` #### Versions naming caveat When using `--s3-versions` flag rclone is relying on the file name to work out whether the objects are versions or not. Versions' names are created by inserting timestamp between file name and its extension. ``` 9 file.txt 8 file-v2023-07-17-161032-000.txt 16 file-v2023-06-15-141003-000.txt ``` If there are real files present with the same names as versions, then behaviour of `--s3-versions` can be unpredictable. ### Cleanup If you run `rclone cleanup s3:bucket` then it will remove all pending multipart uploads older than 24 hours. You can use the `--interactive`/`i` or `--dry-run` flag to see exactly what it will do. If you want more control over the expiry date then run `rclone backend cleanup s3:bucket -o max-age=1h` to expire all uploads older than one hour. You can use `rclone backend list-multipart-uploads s3:bucket` to see the pending multipart uploads. ### Restricted filename characters S3 allows any valid UTF-8 string as a key. Invalid UTF-8 bytes will be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in XML. The following characters are replaced since these are problematic when dealing with the REST API: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | NUL | 0x00 | ␀ | | / | 0x2F | ／ | The encoding will also encode these file names as they don't seem to work with the SDK properly: | File name | Replacement | | --------- |:-----------:| | . | ． | | .. | ．． | ### Multipart uploads rclone supports multipart uploads with S3 which means that it can upload files bigger than 5 GiB. Note that files uploaded *both* with multipart upload *and* through crypt remotes do not have MD5 sums. rclone switches from single part uploads to multipart uploads at the point specified by `--s3-upload-cutoff`. This can be a maximum of 5 GiB and a minimum of 0 (ie always upload multipart files). The chunk sizes used in the multipart upload are specified by `--s3-chunk-size` and the number of chunks uploaded concurrently is specified by `--s3-upload-concurrency`. Multipart uploads will use `--transfers` * `--s3-upload-concurrency` * `--s3-chunk-size` extra memory. Single part uploads to not use extra memory. Single part transfers can be faster than multipart transfers or slower depending on your latency from S3 - the more latency, the more likely single part transfers will be faster. Increasing `--s3-upload-concurrency` will increase throughput (8 would be a sensible value) and increasing `--s3-chunk-size` also increases throughput (16M would be sensible). Increasing either of these will use more memory. The default values are high enough to gain most of the possible performance without using too much memory. ### Buckets and Regions With Amazon S3 you can list buckets (`rclone lsd`) using any region, but you can only access the content of a bucket from the region it was created in. If you attempt to access a bucket from the wrong region, you will get an error, `incorrect region, the bucket is not in 'XXX' region`. ### Authentication There are a number of ways to supply `rclone` with a set of AWS credentials, with and without using the environment. The different authentication methods are tried in this order: - Directly in the rclone configuration file (`env_auth = false` in the config file): - `access_key_id` and `secret_access_key` are required. - `session_token` can be optionally set when using AWS STS. - Runtime configuration (`env_auth = true` in the config file): - Export the following environment variables before running `rclone`: - Access Key ID: `AWS_ACCESS_KEY_ID` or `AWS_ACCESS_KEY` - Secret Access Key: `AWS_SECRET_ACCESS_KEY` or `AWS_SECRET_KEY` - Session Token: `AWS_SESSION_TOKEN` (optional) - Or, use a [named profile](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html): - Profile files are standard files used by AWS CLI tools - By default it will use the profile in your home directory (e.g. `~/.aws/credentials` on unix based systems) file and the "default" profile, to change set these environment variables or config keys: - `AWS_SHARED_CREDENTIALS_FILE` to control which file or the `shared_credentials_file` config key. - `AWS_PROFILE` to control which profile to use or the `profile` config key. - Or, run `rclone` in an ECS task with an IAM role (AWS only). - Or, run `rclone` on an EC2 instance with an IAM role (AWS only). - Or, run `rclone` in an EKS pod with an IAM role that is associated with a service account (AWS only). - Or, use [process credentials](https://docs.aws.amazon.com/sdkref/latest/guide/feature-process-credentials.html) to read config from an external program. With `env_auth = true` rclone (which uses the SDK for Go v2) should support [all authentication methods](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html) that the `aws` CLI tool does and the other AWS SDKs. If none of these option actually end up providing `rclone` with AWS credentials then S3 interaction will be non-authenticated (see the [anonymous access](#anonymous-access) section for more info). ### S3 Permissions When using the `sync` subcommand of `rclone` the following minimum permissions are required to be available on the bucket being written to: * `ListBucket` * `DeleteObject` * `GetObject` * `PutObject` * `PutObjectACL` * `CreateBucket` (unless using [s3-no-check-bucket](#s3-no-check-bucket)) When using the `lsd` subcommand, the `ListAllMyBuckets` permission is required. Example policy: ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::USER_SID:user/USER_NAME" }, "Action": [ "s3:ListBucket", "s3:DeleteObject", "s3:GetObject", "s3:PutObject", "s3:PutObjectAcl" ], "Resource": [ "arn:aws:s3:::BUCKET_NAME/*", "arn:aws:s3:::BUCKET_NAME" ] }, { "Effect": "Allow", "Action": "s3:ListAllMyBuckets", "Resource": "arn:aws:s3:::*" } ] } ``` Notes on above: 1. This is a policy that can be used when creating bucket. It assumes that `USER_NAME` has been created. 2. The Resource entry must include both resource ARNs, as one implies the bucket and the other implies the bucket's objects. 3. When using [s3-no-check-bucket](#s3-no-check-bucket) and the bucket already exists, the `"arn:aws:s3:::BUCKET_NAME"` doesn't have to be included. For reference, [here's an Ansible script](https://gist.github.com/ebridges/ebfc9042dd7c756cd101cfa807b7ae2b) that will generate one or more buckets that will work with `rclone sync`. ### Key Management System (KMS) If you are using server-side encryption with KMS then you must make sure rclone is configured with `server_side_encryption = aws:kms` otherwise you will find you can't transfer small objects - these will create checksum errors. ### Glacier and Glacier Deep Archive You can upload objects using the glacier storage class or transition them to glacier using a [lifecycle policy](http://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-lifecycle.html). The bucket can still be synced or copied into normally, but if rclone tries to access data from the glacier storage class you will see an error like below. 2017/09/11 19:07:43 Failed to sync: failed to open source object: Object in GLACIER, restore first: path/to/file In this case you need to [restore](http://docs.aws.amazon.com/AmazonS3/latest/user-guide/restore-archived-objects.html) the object(s) in question before accessing object contents. The [restore](#restore) section below shows how to do this with rclone. Note that rclone only speaks the S3 API it does not speak the Glacier Vault API, so rclone cannot directly access Glacier Vaults. ### Object-lock enabled S3 bucket According to AWS's [documentation on S3 Object Lock](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lock-overview.html#object-lock-permission): > If you configure a default retention period on a bucket, requests to upload objects in such a bucket must include the Content-MD5 header. As mentioned in the [Modification times and hashes](#modification-times-and-hashes) section, small files that are not uploaded as multipart, use a different tag, causing the upload to fail. A simple solution is to set the `--s3-upload-cutoff 0` and force all the files to be uploaded as multipart. ### Standard options Here are the Standard options specific to s3 (Amazon S3 Compliant Storage Providers including AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, Exaba, FlashBlade, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, Magalu, Mega, Minio, Netease, Outscale, OVHcloud, Petabox, RackCorp, Rclone, Scaleway, SeaweedFS, Selectel, StackPath, Storj, Synology, TencentCOS, Wasabi, Qiniu, Zata and others). #### --s3-provider Choose your S3 provider. Properties: - Config: provider - Env Var: RCLONE_S3_PROVIDER - Type: string - Required: false - Examples: - "AWS" - Amazon Web Services (AWS) S3 - "Alibaba" - Alibaba Cloud Object Storage System (OSS) formerly Aliyun - "ArvanCloud" - Arvan Cloud Object Storage (AOS) - "Ceph" - Ceph Object Storage - "ChinaMobile" - China Mobile Ecloud Elastic Object Storage (EOS) - "Cloudflare" - Cloudflare R2 Storage - "DigitalOcean" - DigitalOcean Spaces - "Dreamhost" - Dreamhost DreamObjects - "Exaba" - Exaba Object Storage - "FlashBlade" - Pure Storage FlashBlade Object Storage - "GCS" - Google Cloud Storage - "HuaweiOBS" - Huawei Object Storage Service - "IBMCOS" - IBM COS S3 - "IDrive" - IDrive e2 - "IONOS" - IONOS Cloud - "LyveCloud" - Seagate Lyve Cloud - "Leviia" - Leviia Object Storage - "Liara" - Liara Object Storage - "Linode" - Linode Object Storage - "Magalu" - Magalu Object Storage - "Mega" - MEGA S4 Object Storage - "Minio" - Minio Object Storage - "Netease" - Netease Object Storage (NOS) - "Outscale" - OUTSCALE Object Storage (OOS) - "OVHcloud" - OVHcloud Object Storage - "Petabox" - Petabox Object Storage - "RackCorp" - RackCorp Object Storage - "Rclone" - Rclone S3 Server - "Scaleway" - Scaleway Object Storage - "SeaweedFS" - SeaweedFS S3 - "Selectel" - Selectel Object Storage - "StackPath" - StackPath Object Storage - "Storj" - Storj (S3 Compatible Gateway) - "Synology" - Synology C2 Object Storage - "TencentCOS" - Tencent Cloud Object Storage (COS) - "Wasabi" - Wasabi Object Storage - "Qiniu" - Qiniu Object Storage (Kodo) - "Zata" - Zata (S3 compatible Gateway) - "Other" - Any other S3 compatible provider #### --s3-env-auth Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Properties: - Config: env_auth - Env Var: RCLONE_S3_ENV_AUTH - Type: bool - Default: false - Examples: - "false" - Enter AWS credentials in the next step. - "true" - Get AWS credentials from the environment (env vars or IAM). #### --s3-access-key-id AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Properties: - Config: access_key_id - Env Var: RCLONE_S3_ACCESS_KEY_ID - Type: string - Required: false #### --s3-secret-access-key AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Properties: - Config: secret_access_key - Env Var: RCLONE_S3_SECRET_ACCESS_KEY - Type: string - Required: false #### --s3-region Region to connect to. Properties: - Config: region - Env Var: RCLONE_S3_REGION - Provider: AWS - Type: string - Required: false - Examples: - "us-east-1" - The default endpoint - a good choice if you are unsure. - US Region, Northern Virginia, or Pacific Northwest. - Leave location constraint empty. - "us-east-2" - US East (Ohio) Region. - Needs location constraint us-east-2. - "us-west-1" - US West (Northern California) Region. - Needs location constraint us-west-1. - "us-west-2" - US West (Oregon) Region. - Needs location constraint us-west-2. - "ca-central-1" - Canada (Central) Region. - Needs location constraint ca-central-1. - "eu-west-1" - EU (Ireland) Region. - Needs location constraint EU or eu-west-1. - "eu-west-2" - EU (London) Region. - Needs location constraint eu-west-2. - "eu-west-3" - EU (Paris) Region. - Needs location constraint eu-west-3. - "eu-north-1" - EU (Stockholm) Region. - Needs location constraint eu-north-1. - "eu-south-1" - EU (Milan) Region. - Needs location constraint eu-south-1. - "eu-central-1" - EU (Frankfurt) Region. - Needs location constraint eu-central-1. - "ap-southeast-1" - Asia Pacific (Singapore) Region. - Needs location constraint ap-southeast-1. - "ap-southeast-2" - Asia Pacific (Sydney) Region. - Needs location constraint ap-southeast-2. - "ap-northeast-1" - Asia Pacific (Tokyo) Region. - Needs location constraint ap-northeast-1. - "ap-northeast-2" - Asia Pacific (Seoul). - Needs location constraint ap-northeast-2. - "ap-northeast-3" - Asia Pacific (Osaka-Local). - Needs location constraint ap-northeast-3. - "ap-south-1" - Asia Pacific (Mumbai). - Needs location constraint ap-south-1. - "ap-east-1" - Asia Pacific (Hong Kong) Region. - Needs location constraint ap-east-1. - "sa-east-1" - South America (Sao Paulo) Region. - Needs location constraint sa-east-1. - "il-central-1" - Israel (Tel Aviv) Region. - Needs location constraint il-central-1. - "me-south-1" - Middle East (Bahrain) Region. - Needs location constraint me-south-1. - "af-south-1" - Africa (Cape Town) Region. - Needs location constraint af-south-1. - "cn-north-1" - China (Beijing) Region. - Needs location constraint cn-north-1. - "cn-northwest-1" - China (Ningxia) Region. - Needs location constraint cn-northwest-1. - "us-gov-east-1" - AWS GovCloud (US-East) Region. - Needs location constraint us-gov-east-1. - "us-gov-west-1" - AWS GovCloud (US) Region. - Needs location constraint us-gov-west-1. #### --s3-endpoint Endpoint for S3 API. Leave blank if using AWS to use the default endpoint for the region. Properties: - Config: endpoint - Env Var: RCLONE_S3_ENDPOINT - Provider: AWS - Type: string - Required: false #### --s3-location-constraint Location constraint - must be set to match the Region. Used when creating buckets only. Properties: - Config: location_constraint - Env Var: RCLONE_S3_LOCATION_CONSTRAINT - Provider: AWS - Type: string - Required: false - Examples: - "" - Empty for US Region, Northern Virginia, or Pacific Northwest - "us-east-2" - US East (Ohio) Region - "us-west-1" - US West (Northern California) Region - "us-west-2" - US West (Oregon) Region - "ca-central-1" - Canada (Central) Region - "eu-west-1" - EU (Ireland) Region - "eu-west-2" - EU (London) Region - "eu-west-3" - EU (Paris) Region - "eu-north-1" - EU (Stockholm) Region - "eu-south-1" - EU (Milan) Region - "EU" - EU Region - "ap-southeast-1" - Asia Pacific (Singapore) Region - "ap-southeast-2" - Asia Pacific (Sydney) Region - "ap-northeast-1" - Asia Pacific (Tokyo) Region - "ap-northeast-2" - Asia Pacific (Seoul) Region - "ap-northeast-3" - Asia Pacific (Osaka-Local) Region - "ap-south-1" - Asia Pacific (Mumbai) Region - "ap-east-1" - Asia Pacific (Hong Kong) Region - "sa-east-1" - South America (Sao Paulo) Region - "il-central-1" - Israel (Tel Aviv) Region - "me-south-1" - Middle East (Bahrain) Region - "af-south-1" - Africa (Cape Town) Region - "cn-north-1" - China (Beijing) Region - "cn-northwest-1" - China (Ningxia) Region - "us-gov-east-1" - AWS GovCloud (US-East) Region - "us-gov-west-1" - AWS GovCloud (US) Region #### --s3-acl Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Properties: - Config: acl - Env Var: RCLONE_S3_ACL - Provider: !Storj,Selectel,Synology,Cloudflare,FlashBlade,Mega - Type: string - Required: false - Examples: - "default" - Owner gets Full_CONTROL. - No one else has access rights (default). - "private" - Owner gets FULL_CONTROL. - No one else has access rights (default). - "public-read" - Owner gets FULL_CONTROL. - The AllUsers group gets READ access. - "public-read-write" - Owner gets FULL_CONTROL. - The AllUsers group gets READ and WRITE access. - Granting this on a bucket is generally not recommended. - "authenticated-read" - Owner gets FULL_CONTROL. - The AuthenticatedUsers group gets READ access. - "bucket-owner-read" - Object owner gets FULL_CONTROL. - Bucket owner gets READ access. - If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. - "bucket-owner-full-control" - Both the object owner and the bucket owner get FULL_CONTROL over the object. - If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. - "private" - Owner gets FULL_CONTROL. - No one else has access rights (default). - This acl is available on IBM Cloud (Infra), IBM Cloud (Storage), On-Premise COS. - "public-read" - Owner gets FULL_CONTROL. - The AllUsers group gets READ access. - This acl is available on IBM Cloud (Infra), IBM Cloud (Storage), On-Premise IBM COS. - "public-read-write" - Owner gets FULL_CONTROL. - The AllUsers group gets READ and WRITE access. - This acl is available on IBM Cloud (Infra), On-Premise IBM COS. - "authenticated-read" - Owner gets FULL_CONTROL. - The AuthenticatedUsers group gets READ access. - Not supported on Buckets. - This acl is available on IBM Cloud (Infra) and On-Premise IBM COS. #### --s3-server-side-encryption The server-side encryption algorithm used when storing this object in S3. Properties: - Config: server_side_encryption - Env Var: RCLONE_S3_SERVER_SIDE_ENCRYPTION - Provider: AWS,Ceph,ChinaMobile,Minio - Type: string - Required: false - Examples: - "" - None - "AES256" - AES256 - "aws:kms" - aws:kms #### --s3-sse-kms-key-id If using KMS ID you must provide the ARN of Key. Properties: - Config: sse_kms_key_id - Env Var: RCLONE_S3_SSE_KMS_KEY_ID - Provider: AWS,Ceph,Minio - Type: string - Required: false - Examples: - "" - None - "arn:aws:kms:us-east-1:*" - arn:aws:kms:* #### --s3-storage-class The storage class to use when storing new objects in S3. Properties: - Config: storage_class - Env Var: RCLONE_S3_STORAGE_CLASS - Provider: AWS - Type: string - Required: false - Examples: - "" - Default - "STANDARD" - Standard storage class - "REDUCED_REDUNDANCY" - Reduced redundancy storage class - "STANDARD_IA" - Standard Infrequent Access storage class - "ONEZONE_IA" - One Zone Infrequent Access storage class - "GLACIER" - Glacier Flexible Retrieval storage class - "DEEP_ARCHIVE" - Glacier Deep Archive storage class - "INTELLIGENT_TIERING" - Intelligent-Tiering storage class - "GLACIER_IR" - Glacier Instant Retrieval storage class #### --s3-ibm-api-key IBM API Key to be used to obtain IAM token Properties: - Config: ibm_api_key - Env Var: RCLONE_S3_IBM_API_KEY - Provider: IBMCOS - Type: string - Required: false #### --s3-ibm-resource-instance-id IBM service instance id Properties: - Config: ibm_resource_instance_id - Env Var: RCLONE_S3_IBM_RESOURCE_INSTANCE_ID - Provider: IBMCOS - Type: string - Required: false ### Advanced options Here are the Advanced options specific to s3 (Amazon S3 Compliant Storage Providers including AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, Exaba, FlashBlade, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, Magalu, Mega, Minio, Netease, Outscale, OVHcloud, Petabox, RackCorp, Rclone, Scaleway, SeaweedFS, Selectel, StackPath, Storj, Synology, TencentCOS, Wasabi, Qiniu, Zata and others). #### --s3-bucket-acl Canned ACL used when creating buckets. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when only when creating buckets. If it isn't set then "acl" is used instead. If the "acl" and "bucket_acl" are empty strings then no X-Amz-Acl: header is added and the default (private) will be used. Properties: - Config: bucket_acl - Env Var: RCLONE_S3_BUCKET_ACL - Provider: !Storj,Selectel,Synology,Cloudflare,FlashBlade - Type: string - Required: false - Examples: - "private" - Owner gets FULL_CONTROL. - No one else has access rights (default). - "public-read" - Owner gets FULL_CONTROL. - The AllUsers group gets READ access. - "public-read-write" - Owner gets FULL_CONTROL. - The AllUsers group gets READ and WRITE access. - Granting this on a bucket is generally not recommended. - "authenticated-read" - Owner gets FULL_CONTROL. - The AuthenticatedUsers group gets READ access. #### --s3-requester-pays Enables requester pays option when interacting with S3 bucket. Properties: - Config: requester_pays - Env Var: RCLONE_S3_REQUESTER_PAYS - Provider: AWS - Type: bool - Default: false #### --s3-sse-customer-algorithm If using SSE-C, the server-side encryption algorithm used when storing this object in S3. Properties: - Config: sse_customer_algorithm - Env Var: RCLONE_S3_SSE_CUSTOMER_ALGORITHM - Provider: AWS,Ceph,ChinaMobile,Minio - Type: string - Required: false - Examples: - "" - None - "AES256" - AES256 #### --s3-sse-customer-key To use SSE-C you may provide the secret encryption key used to encrypt/decrypt your data. Alternatively you can provide --sse-customer-key-base64. Properties: - Config: sse_customer_key - Env Var: RCLONE_S3_SSE_CUSTOMER_KEY - Provider: AWS,Ceph,ChinaMobile,Minio - Type: string - Required: false - Examples: - "" - None #### --s3-sse-customer-key-base64 If using SSE-C you must provide the secret encryption key encoded in base64 format to encrypt/decrypt your data. Alternatively you can provide --sse-customer-key. Properties: - Config: sse_customer_key_base64 - Env Var: RCLONE_S3_SSE_CUSTOMER_KEY_BASE64 - Provider: AWS,Ceph,ChinaMobile,Minio - Type: string - Required: false - Examples: - "" - None #### --s3-sse-customer-key-md5 If using SSE-C you may provide the secret encryption key MD5 checksum (optional). If you leave it blank, this is calculated automatically from the sse_customer_key provided. Properties: - Config: sse_customer_key_md5 - Env Var: RCLONE_S3_SSE_CUSTOMER_KEY_MD5 - Provider: AWS,Ceph,ChinaMobile,Minio - Type: string - Required: false - Examples: - "" - None #### --s3-upload-cutoff Cutoff for switching to chunked upload. Any files larger than this will be uploaded in chunks of chunk_size. The minimum is 0 and the maximum is 5 GiB. Properties: - Config: upload_cutoff - Env Var: RCLONE_S3_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 200Mi #### --s3-chunk-size Chunk size to use for uploading. When uploading files larger than upload_cutoff or files with unknown size (e.g. from "rclone rcat" or uploaded with "rclone mount" or google photos or google docs) they will be uploaded as multipart uploads using this chunk size. Note that "--s3-upload-concurrency" chunks of this size are buffered in memory per transfer. If you are transferring large files over high-speed links and you have enough memory, then increasing this will speed up the transfers. Rclone will automatically increase the chunk size when uploading a large file of known size to stay below the 10,000 chunks limit. Files of unknown size are uploaded with the configured chunk_size. Since the default chunk size is 5 MiB and there can be at most 10,000 chunks, this means that by default the maximum size of a file you can stream upload is 48 GiB. If you wish to stream upload larger files then you will need to increase chunk_size. Increasing the chunk size decreases the accuracy of the progress statistics displayed with "-P" flag. Rclone treats chunk as sent when it's buffered by the AWS SDK, when in fact it may still be uploading. A bigger chunk size means a bigger AWS SDK buffer and progress reporting more deviating from the truth. Properties: - Config: chunk_size - Env Var: RCLONE_S3_CHUNK_SIZE - Type: SizeSuffix - Default: 5Mi #### --s3-max-upload-parts Maximum number of parts in a multipart upload. This option defines the maximum number of multipart chunks to use when doing a multipart upload. This can be useful if a service does not support the AWS S3 specification of 10,000 chunks. Rclone will automatically increase the chunk size when uploading a large file of a known size to stay below this number of chunks limit. Properties: - Config: max_upload_parts - Env Var: RCLONE_S3_MAX_UPLOAD_PARTS - Type: int - Default: 10000 #### --s3-copy-cutoff Cutoff for switching to multipart copy. Any files larger than this that need to be server-side copied will be copied in chunks of this size. The minimum is 0 and the maximum is 5 GiB. Properties: - Config: copy_cutoff - Env Var: RCLONE_S3_COPY_CUTOFF - Type: SizeSuffix - Default: 4.656Gi #### --s3-disable-checksum Don't store MD5 checksum with object metadata. Normally rclone will calculate the MD5 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading. Properties: - Config: disable_checksum - Env Var: RCLONE_S3_DISABLE_CHECKSUM - Type: bool - Default: false #### --s3-shared-credentials-file Path to the shared credentials file. If env_auth = true then rclone can use a shared credentials file. If this variable is empty rclone will look for the "AWS_SHARED_CREDENTIALS_FILE" env variable. If the env value is empty it will default to the current user's home directory. Linux/OSX: "$HOME/.aws/credentials" Windows: "%USERPROFILE%\.aws\credentials" Properties: - Config: shared_credentials_file - Env Var: RCLONE_S3_SHARED_CREDENTIALS_FILE - Type: string - Required: false #### --s3-profile Profile to use in the shared credentials file. If env_auth = true then rclone can use a shared credentials file. This variable controls which profile is used in that file. If empty it will default to the environment variable "AWS_PROFILE" or "default" if that environment variable is also not set. Properties: - Config: profile - Env Var: RCLONE_S3_PROFILE - Type: string - Required: false #### --s3-session-token An AWS session token. Properties: - Config: session_token - Env Var: RCLONE_S3_SESSION_TOKEN - Type: string - Required: false #### --s3-upload-concurrency Concurrency for multipart uploads and copies. This is the number of chunks of the same file that are uploaded concurrently for multipart uploads and copies. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. Properties: - Config: upload_concurrency - Env Var: RCLONE_S3_UPLOAD_CONCURRENCY - Type: int - Default: 4 #### --s3-force-path-style If true use path style access if false use virtual hosted style. If this is true (the default) then rclone will use path style access, if false then rclone will use virtual path style. See [the AWS S3 docs](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingBucket.html#access-bucket-intro) for more info. Some providers (e.g. AWS, Aliyun OSS, Netease COS, or Tencent COS) require this set to false - rclone will do this automatically based on the provider setting. Note that if your bucket isn't a valid DNS name, i.e. has '.' or '_' in, you'll need to set this to true. Properties: - Config: force_path_style - Env Var: RCLONE_S3_FORCE_PATH_STYLE - Type: bool - Default: true #### --s3-v2-auth If true use v2 authentication. If this is false (the default) then rclone will use v4 authentication. If it is set then rclone will use v2 authentication. Use this only if v4 signatures don't work, e.g. pre Jewel/v10 CEPH. Properties: - Config: v2_auth - Env Var: RCLONE_S3_V2_AUTH - Type: bool - Default: false #### --s3-use-dual-stack If true use AWS S3 dual-stack endpoint (IPv6 support). See [AWS Docs on Dualstack Endpoints](https://docs.aws.amazon.com/AmazonS3/latest/userguide/dual-stack-endpoints.html) Properties: - Config: use_dual_stack - Env Var: RCLONE_S3_USE_DUAL_STACK - Type: bool - Default: false #### --s3-use-accelerate-endpoint If true use the AWS S3 accelerated endpoint. See: [AWS S3 Transfer acceleration](https://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration-examples.html) Properties: - Config: use_accelerate_endpoint - Env Var: RCLONE_S3_USE_ACCELERATE_ENDPOINT - Provider: AWS - Type: bool - Default: false #### --s3-use-arn-region If true, enables arn region support for the service. Properties: - Config: use_arn_region - Env Var: RCLONE_S3_USE_ARN_REGION - Type: bool - Default: false #### --s3-leave-parts-on-error If true avoid calling abort upload on a failure, leaving all successfully uploaded parts on S3 for manual recovery. It should be set to true for resuming uploads across different sessions. WARNING: Storing parts of an incomplete multipart upload counts towards space usage on S3 and will add additional costs if not cleaned up. Properties: - Config: leave_parts_on_error - Env Var: RCLONE_S3_LEAVE_PARTS_ON_ERROR - Provider: AWS - Type: bool - Default: false #### --s3-list-chunk Size of listing chunk (response list for each ListObject S3 request). This option is also known as "MaxKeys", "max-items", or "page-size" from the AWS S3 specification. Most services truncate the response list to 1000 objects even if requested more than that. In AWS S3 this is a global maximum and cannot be changed, see [AWS S3](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html). In Ceph, this can be increased with the "rgw list buckets max chunk" option. Properties: - Config: list_chunk - Env Var: RCLONE_S3_LIST_CHUNK - Type: int - Default: 1000 #### --s3-list-version Version of ListObjects to use: 1,2 or 0 for auto. When S3 originally launched it only provided the ListObjects call to enumerate objects in a bucket. However in May 2016 the ListObjectsV2 call was introduced. This is much higher performance and should be used if at all possible. If set to the default, 0, rclone will guess according to the provider set which list objects method to call. If it guesses wrong, then it may be set manually here. Properties: - Config: list_version - Env Var: RCLONE_S3_LIST_VERSION - Type: int - Default: 0 #### --s3-list-url-encode Whether to url encode listings: true/false/unset Some providers support URL encoding listings and where this is available this is more reliable when using control characters in file names. If this is set to unset (the default) then rclone will choose according to the provider setting what to apply, but you can override rclone's choice here. Properties: - Config: list_url_encode - Env Var: RCLONE_S3_LIST_URL_ENCODE - Type: Tristate - Default: unset #### --s3-no-check-bucket If set, don't attempt to check the bucket exists or create it. This can be useful when trying to minimise the number of transactions rclone does if you know the bucket exists already. It can also be needed if the user you are using does not have bucket creation permissions. Before v1.52.0 this would have passed silently due to a bug. Properties: - Config: no_check_bucket - Env Var: RCLONE_S3_NO_CHECK_BUCKET - Type: bool - Default: false #### --s3-no-head If set, don't HEAD uploaded objects to check integrity. This can be useful when trying to minimise the number of transactions rclone does. Setting it means that if rclone receives a 200 OK message after uploading an object with PUT then it will assume that it got uploaded properly. In particular it will assume: - the metadata, including modtime, storage class and content type was as uploaded - the size was as uploaded It reads the following items from the response for a single part PUT: - the MD5SUM - The uploaded date For multipart uploads these items aren't read. If an source object of unknown length is uploaded then rclone **will** do a HEAD request. Setting this flag increases the chance for undetected upload failures, in particular an incorrect size, so it isn't recommended for normal operation. In practice the chance of an undetected upload failure is very small even with this flag. Properties: - Config: no_head - Env Var: RCLONE_S3_NO_HEAD - Type: bool - Default: false #### --s3-no-head-object If set, do not do HEAD before GET when getting objects. Properties: - Config: no_head_object - Env Var: RCLONE_S3_NO_HEAD_OBJECT - Type: bool - Default: false #### --s3-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_S3_ENCODING - Type: Encoding - Default: Slash,InvalidUtf8,Dot #### --s3-memory-pool-flush-time How often internal memory buffer pools will be flushed. (no longer used) Properties: - Config: memory_pool_flush_time - Env Var: RCLONE_S3_MEMORY_POOL_FLUSH_TIME - Type: Duration - Default: 1m0s #### --s3-memory-pool-use-mmap Whether to use mmap buffers in internal memory pool. (no longer used) Properties: - Config: memory_pool_use_mmap - Env Var: RCLONE_S3_MEMORY_POOL_USE_MMAP - Type: bool - Default: false #### --s3-disable-http2 Disable usage of http2 for S3 backends. There is currently an unsolved issue with the s3 (specifically minio) backend and HTTP/2. HTTP/2 is enabled by default for the s3 backend but can be disabled here. When the issue is solved this flag will be removed. See: https://github.com/rclone/rclone/issues/4673, https://github.com/rclone/rclone/issues/3631 Properties: - Config: disable_http2 - Env Var: RCLONE_S3_DISABLE_HTTP2 - Type: bool - Default: false #### --s3-download-url Custom endpoint for downloads. This is usually set to a CloudFront CDN URL as AWS S3 offers cheaper egress for data downloaded through the CloudFront network. Properties: - Config: download_url - Env Var: RCLONE_S3_DOWNLOAD_URL - Type: string - Required: false #### --s3-directory-markers Upload an empty object with a trailing slash when a new directory is created Empty folders are unsupported for bucket based remotes, this option creates an empty object ending with "/", to persist the folder. Properties: - Config: directory_markers - Env Var: RCLONE_S3_DIRECTORY_MARKERS - Type: bool - Default: false #### --s3-use-multipart-etag Whether to use ETag in multipart uploads for verification This should be true, false or left unset to use the default for the provider. Properties: - Config: use_multipart_etag - Env Var: RCLONE_S3_USE_MULTIPART_ETAG - Type: Tristate - Default: unset #### --s3-use-unsigned-payload Whether to use an unsigned payload in PutObject Rclone has to avoid the AWS SDK seeking the body when calling PutObject. The AWS provider can add checksums in the trailer to avoid seeking but other providers can't. This should be true, false or left unset to use the default for the provider. Properties: - Config: use_unsigned_payload - Env Var: RCLONE_S3_USE_UNSIGNED_PAYLOAD - Type: Tristate - Default: unset #### --s3-use-presigned-request Whether to use a presigned request or PutObject for single part uploads If this is false rclone will use PutObject from the AWS SDK to upload an object. Versions of rclone < 1.59 use presigned requests to upload a single part object and setting this flag to true will re-enable that functionality. This shouldn't be necessary except in exceptional circumstances or for testing. Properties: - Config: use_presigned_request - Env Var: RCLONE_S3_USE_PRESIGNED_REQUEST - Type: bool - Default: false #### --s3-versions Include old versions in directory listings. Properties: - Config: versions - Env Var: RCLONE_S3_VERSIONS - Type: bool - Default: false #### --s3-version-at Show file versions as they were at the specified time. The parameter should be a date, "2006-01-02", datetime "2006-01-02 15:04:05" or a duration for that long ago, eg "100d" or "1h". Note that when using this no file write operations are permitted, so you can't upload files or delete them. See [the time option docs](https://rclone.org/docs/#time-options) for valid formats. Properties: - Config: version_at - Env Var: RCLONE_S3_VERSION_AT - Type: Time - Default: off #### --s3-version-deleted Show deleted file markers when using versions. This shows deleted file markers in the listing when using versions. These will appear as 0 size files. The only operation which can be performed on them is deletion. Deleting a delete marker will reveal the previous version. Deleted files will always show with a timestamp. Properties: - Config: version_deleted - Env Var: RCLONE_S3_VERSION_DELETED - Type: bool - Default: false #### --s3-decompress If set this will decompress gzip encoded objects. It is possible to upload objects to S3 with "Content-Encoding: gzip" set. Normally rclone will download these files as compressed objects. If this flag is set then rclone will decompress these files with "Content-Encoding: gzip" as they are received. This means that rclone can't check the size and hash but the file contents will be decompressed. Properties: - Config: decompress - Env Var: RCLONE_S3_DECOMPRESS - Type: bool - Default: false #### --s3-might-gzip Set this if the backend might gzip objects. Normally providers will not alter objects when they are downloaded. If an object was not uploaded with `Content-Encoding: gzip` then it won't be set on download. However some providers may gzip objects even if they weren't uploaded with `Content-Encoding: gzip` (eg Cloudflare). A symptom of this would be receiving errors like ERROR corrupted on transfer: sizes differ NNN vs MMM If you set this flag and rclone downloads an object with Content-Encoding: gzip set and chunked transfer encoding, then rclone will decompress the object on the fly. If this is set to unset (the default) then rclone will choose according to the provider setting what to apply, but you can override rclone's choice here. Properties: - Config: might_gzip - Env Var: RCLONE_S3_MIGHT_GZIP - Type: Tristate - Default: unset #### --s3-use-accept-encoding-gzip Whether to send `Accept-Encoding: gzip` header. By default, rclone will append `Accept-Encoding: gzip` to the request to download compressed objects whenever possible. However some providers such as Google Cloud Storage may alter the HTTP headers, breaking the signature of the request. A symptom of this would be receiving errors like SignatureDoesNotMatch: The request signature we calculated does not match the signature you provided. In this case, you might want to try disabling this option. Properties: - Config: use_accept_encoding_gzip - Env Var: RCLONE_S3_USE_ACCEPT_ENCODING_GZIP - Type: Tristate - Default: unset #### --s3-no-system-metadata Suppress setting and reading of system metadata Properties: - Config: no_system_metadata - Env Var: RCLONE_S3_NO_SYSTEM_METADATA - Type: bool - Default: false #### --s3-sts-endpoint Endpoint for STS (deprecated). Leave blank if using AWS to use the default endpoint for the region. Properties: - Config: sts_endpoint - Env Var: RCLONE_S3_STS_ENDPOINT - Provider: AWS - Type: string - Required: false #### --s3-use-already-exists Set if rclone should report BucketAlreadyExists errors on bucket creation. At some point during the evolution of the s3 protocol, AWS started returning an `AlreadyOwnedByYou` error when attempting to create a bucket that the user already owned, rather than a `BucketAlreadyExists` error. Unfortunately exactly what has been implemented by s3 clones is a little inconsistent, some return `AlreadyOwnedByYou`, some return `BucketAlreadyExists` and some return no error at all. This is important to rclone because it ensures the bucket exists by creating it on quite a lot of operations (unless `--s3-no-check-bucket` is used). If rclone knows the provider can return `AlreadyOwnedByYou` or returns no error then it can report `BucketAlreadyExists` errors when the user attempts to create a bucket not owned by them. Otherwise rclone ignores the `BucketAlreadyExists` error which can lead to confusion. This should be automatically set correctly for all providers rclone knows about - please make a bug report if not. Properties: - Config: use_already_exists - Env Var: RCLONE_S3_USE_ALREADY_EXISTS - Type: Tristate - Default: unset #### --s3-use-multipart-uploads Set if rclone should use multipart uploads. You can change this if you want to disable the use of multipart uploads. This shouldn't be necessary in normal operation. This should be automatically set correctly for all providers rclone knows about - please make a bug report if not. Properties: - Config: use_multipart_uploads - Env Var: RCLONE_S3_USE_MULTIPART_UPLOADS - Type: Tristate - Default: unset #### --s3-use-x-id Set if rclone should add x-id URL parameters. You can change this if you want to disable the AWS SDK from adding x-id URL parameters. This shouldn't be necessary in normal operation. This should be automatically set correctly for all providers rclone knows about - please make a bug report if not. Properties: - Config: use_x_id - Env Var: RCLONE_S3_USE_X_ID - Type: Tristate - Default: unset #### --s3-sign-accept-encoding Set if rclone should include Accept-Encoding as part of the signature. You can change this if you want to stop rclone including Accept-Encoding as part of the signature. This shouldn't be necessary in normal operation. This should be automatically set correctly for all providers rclone knows about - please make a bug report if not. Properties: - Config: sign_accept_encoding - Env Var: RCLONE_S3_SIGN_ACCEPT_ENCODING - Type: Tristate - Default: unset #### --s3-directory-bucket Set to use AWS Directory Buckets If you are using an AWS Directory Bucket then set this flag. This will ensure no `Content-Md5` headers are sent and ensure `ETag` headers are not interpreted as MD5 sums. `X-Amz-Meta-Md5chksum` will be set on all objects whether single or multipart uploaded. This also sets `no_check_bucket = true`. Note that Directory Buckets do not support: - Versioning - `Content-Encoding: gzip` Rclone limitations with Directory Buckets: - rclone does not support creating Directory Buckets with `rclone mkdir` - ... or removing them with `rclone rmdir` yet - Directory Buckets do not appear when doing `rclone lsf` at the top level. - Rclone can't remove auto created directories yet. In theory this should work with `directory_markers = true` but it doesn't. - Directories don't seem to appear in recursive (ListR) listings. Properties: - Config: directory_bucket - Env Var: RCLONE_S3_DIRECTORY_BUCKET - Provider: AWS - Type: bool - Default: false #### --s3-sdk-log-mode Set to debug the SDK This can be set to a comma separated list of the following functions: - `Signing` - `Retries` - `Request` - `RequestWithBody` - `Response` - `ResponseWithBody` - `DeprecatedUsage` - `RequestEventMessage` - `ResponseEventMessage` Use `Off` to disable and `All` to set all log levels. You will need to use `-vv` to see the debug level logs. Properties: - Config: sdk_log_mode - Env Var: RCLONE_S3_SDK_LOG_MODE - Type: Bits - Default: Off #### --s3-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_S3_DESCRIPTION - Type: string - Required: false ### Metadata User metadata is stored as x-amz-meta- keys. S3 metadata keys are case insensitive and are always returned in lower case. Here are the possible system metadata items for the s3 backend. | Name | Help | Type | Example | Read Only | |------|------|------|---------|-----------| | btime | Time of file birth (creation) read from Last-Modified header | RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | **Y** | | cache-control | Cache-Control header | string | no-cache | N | | content-disposition | Content-Disposition header | string | inline | N | | content-encoding | Content-Encoding header | string | gzip | N | | content-language | Content-Language header | string | en-US | N | | content-type | Content-Type header | string | text/plain | N | | mtime | Time of last modification, read from rclone metadata | RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | N | | tier | Tier of the object | string | GLACIER | **Y** | See the [metadata](https://rclone.org/docs/#metadata) docs for more info. ## Backend commands Here are the commands specific to the s3 backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the [backend](https://rclone.org/commands/rclone_backend/) command for more info on how to pass options and arguments. These can be run on a running backend using the rc command [backend/command](https://rclone.org/rc/#backend-command). ### restore Restore objects from GLACIER or INTELLIGENT-TIERING archive tier rclone backend restore remote: [options] [+] This command can be used to restore one or more objects from GLACIER to normal storage or from INTELLIGENT-TIERING Archive Access / Deep Archive Access tier to the Frequent Access tier. Usage Examples: rclone backend restore s3:bucket/path/to/ --include /object -o priority=PRIORITY -o lifetime=DAYS rclone backend restore s3:bucket/path/to/directory -o priority=PRIORITY -o lifetime=DAYS rclone backend restore s3:bucket -o priority=PRIORITY -o lifetime=DAYS rclone backend restore s3:bucket/path/to/directory -o priority=PRIORITY This flag also obeys the filters. Test first with --interactive/-i or --dry-run flags rclone --interactive backend restore --include "*.txt" s3:bucket/path -o priority=Standard -o lifetime=1 All the objects shown will be marked for restore, then rclone backend restore --include "*.txt" s3:bucket/path -o priority=Standard -o lifetime=1 It returns a list of status dictionaries with Remote and Status keys. The Status will be OK if it was successful or an error message if not. [ { "Status": "OK", "Remote": "test.txt" }, { "Status": "OK", "Remote": "test/file4.txt" } ] Options: - "description": The optional description for the job. - "lifetime": Lifetime of the active copy in days, ignored for INTELLIGENT-TIERING storage - "priority": Priority of restore: Standard|Expedited|Bulk ### restore-status Show the restore status for objects being restored from GLACIER or INTELLIGENT-TIERING storage rclone backend restore-status remote: [options] [+] This command can be used to show the status for objects being restored from GLACIER to normal storage or from INTELLIGENT-TIERING Archive Access / Deep Archive Access tier to the Frequent Access tier. Usage Examples: rclone backend restore-status s3:bucket/path/to/object rclone backend restore-status s3:bucket/path/to/directory rclone backend restore-status -o all s3:bucket/path/to/directory This command does not obey the filters. It returns a list of status dictionaries. [ { "Remote": "file.txt", "VersionID": null, "RestoreStatus": { "IsRestoreInProgress": true, "RestoreExpiryDate": "2023-09-06T12:29:19+01:00" }, "StorageClass": "GLACIER" }, { "Remote": "test.pdf", "VersionID": null, "RestoreStatus": { "IsRestoreInProgress": false, "RestoreExpiryDate": "2023-09-06T12:29:19+01:00" }, "StorageClass": "DEEP_ARCHIVE" }, { "Remote": "test.gz", "VersionID": null, "RestoreStatus": { "IsRestoreInProgress": true, "RestoreExpiryDate": "null" }, "StorageClass": "INTELLIGENT_TIERING" } ] Options: - "all": if set then show all objects, not just ones with restore status ### list-multipart-uploads List the unfinished multipart uploads rclone backend list-multipart-uploads remote: [options] [+] This command lists the unfinished multipart uploads in JSON format. rclone backend list-multipart s3:bucket/path/to/object It returns a dictionary of buckets with values as lists of unfinished multipart uploads. You can call it with no bucket in which case it lists all bucket, with a bucket or with a bucket and path. { "rclone": [ { "Initiated": "2020-06-26T14:20:36Z", "Initiator": { "DisplayName": "XXX", "ID": "arn:aws:iam::XXX:user/XXX" }, "Key": "KEY", "Owner": { "DisplayName": null, "ID": "XXX" }, "StorageClass": "STANDARD", "UploadId": "XXX" } ], "rclone-1000files": [], "rclone-dst": [] } ### cleanup Remove unfinished multipart uploads. rclone backend cleanup remote: [options] [+] This command removes unfinished multipart uploads of age greater than max-age which defaults to 24 hours. Note that you can use --interactive/-i or --dry-run with this command to see what it would do. rclone backend cleanup s3:bucket/path/to/object rclone backend cleanup -o max-age=7w s3:bucket/path/to/object Durations are parsed as per the rest of rclone, 2h, 7d, 7w etc. Options: - "max-age": Max age of upload to delete ### cleanup-hidden Remove old versions of files. rclone backend cleanup-hidden remote: [options] [+] This command removes any old hidden versions of files on a versions enabled bucket. Note that you can use --interactive/-i or --dry-run with this command to see what it would do. rclone backend cleanup-hidden s3:bucket/path/to/dir ### versioning Set/get versioning support for a bucket. rclone backend versioning remote: [options] [+] This command sets versioning support if a parameter is passed and then returns the current versioning status for the bucket supplied. rclone backend versioning s3:bucket # read status only rclone backend versioning s3:bucket Enabled rclone backend versioning s3:bucket Suspended It may return "Enabled", "Suspended" or "Unversioned". Note that once versioning has been enabled the status can't be set back to "Unversioned". ### set Set command for updating the config parameters. rclone backend set remote: [options] [+] This set command can be used to update the config parameters for a running s3 backend. Usage Examples: rclone backend set s3: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=s3: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=s3: -o session_token=X -o access_key_id=X -o secret_access_key=X The option keys are named as they are in the config file. This rebuilds the connection to the s3 backend when it is called with the new parameters. Only new parameters need be passed as the values will default to those currently in use. It doesn't return anything. ### Anonymous access to public buckets {#anonymous-access} If you want to use rclone to access a public bucket, configure with a blank `access_key_id` and `secret_access_key`. Your config should end up looking like this: ``` [anons3] type = s3 provider = AWS ``` Then use it as normal with the name of the public bucket, e.g. rclone lsd anons3:1000genomes You will be able to list and copy data but not upload it. You can also do this entirely on the command line rclone lsd :s3,provider=AWS:1000genomes ## Providers ### AWS S3 This is the provider used as main example and described in the [configuration](#configuration) section above. ### AWS Directory Buckets From rclone v1.69 [Directory Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-overview.html) are supported. You will need to set the `directory_buckets = true` config parameter or use `--s3-directory-buckets`. Note that rclone cannot yet: - Create directory buckets - List directory buckets See [the --s3-directory-buckets flag](#s3-directory-buckets) for more info ### AWS Snowball Edge [AWS Snowball](https://aws.amazon.com/snowball/) is a hardware appliance used for transferring bulk data back to AWS. Its main software interface is S3 object storage. To use rclone with AWS Snowball Edge devices, configure as standard for an 'S3 Compatible Service'. If using rclone pre v1.59 be sure to set `upload_cutoff = 0` otherwise you will run into authentication header issues as the snowball device does not support query parameter based authentication. With rclone v1.59 or later setting `upload_cutoff` should not be necessary. eg. ``` [snowball] type = s3 provider = Other access_key_id = YOUR_ACCESS_KEY secret_access_key = YOUR_SECRET_KEY endpoint = http://[IP of Snowball]:8080 upload_cutoff = 0 ``` ### Alibaba OSS {#alibaba-oss} Here is an example of making an [Alibaba Cloud (Aliyun) OSS](https://www.alibabacloud.com/product/oss/) configuration. First run: rclone config This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> oss Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ "s3" [snip] Storage> s3 Choose your S3 provider. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Amazon Web Services (AWS) S3 \ "AWS" 2 / Alibaba Cloud Object Storage System (OSS) formerly Aliyun \ "Alibaba" 3 / Ceph Object Storage \ "Ceph" [snip] provider> Alibaba Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Enter a boolean value (true or false). Press Enter for the default ("false"). Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). access_key_id> accesskeyid AWS Secret Access Key (password) Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). secret_access_key> secretaccesskey Endpoint for OSS API. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / East China 1 (Hangzhou) \ "oss-cn-hangzhou.aliyuncs.com" 2 / East China 2 (Shanghai) \ "oss-cn-shanghai.aliyuncs.com" 3 / North China 1 (Qingdao) \ "oss-cn-qingdao.aliyuncs.com" [snip] endpoint> 1 Canned ACL used when creating buckets and storing or copying objects. Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Owner gets FULL_CONTROL. No one else has access rights (default). \ "private" 2 / Owner gets FULL_CONTROL. The AllUsers group gets READ access. \ "public-read" / Owner gets FULL_CONTROL. The AllUsers group gets READ and WRITE access. [snip] acl> 1 The storage class to use when storing new objects in OSS. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Default \ "" 2 / Standard storage class \ "STANDARD" 3 / Archive storage mode. \ "GLACIER" 4 / Infrequent access storage mode. \ "STANDARD_IA" storage_class> 1 Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config -------------------- [oss] type = s3 provider = Alibaba env_auth = false access_key_id = accesskeyid secret_access_key = secretaccesskey endpoint = oss-cn-hangzhou.aliyuncs.com acl = private storage_class = Standard -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` ### ArvanCloud {#arvan-cloud} [ArvanCloud](https://www.arvancloud.com/en/products/cloud-storage) ArvanCloud Object Storage goes beyond the limited traditional file storage. It gives you access to backup and archived files and allows sharing. Files like profile image in the app, images sent by users or scanned documents can be stored securely and easily in our Object Storage service. ArvanCloud provides an S3 interface which can be configured for use with rclone like this. ``` No remotes found, make a new one? n) New remote s) Set configuration password n/s> n name> ArvanCloud Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Amazon S3 (also Dreamhost, Ceph, ChinaMobile, ArvanCloud, Liara, Minio) \ "s3" [snip] Storage> s3 Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID - leave blank for anonymous access or runtime credentials. access_key_id> YOURACCESSKEY AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials. secret_access_key> YOURSECRETACCESSKEY Region to connect to. Choose a number from below, or type in your own value / The default endpoint - a good choice if you are unsure. 1 | US Region, Northern Virginia, or Pacific Northwest. | Leave location constraint empty. \ "us-east-1" [snip] region> Endpoint for S3 API. Leave blank if using ArvanCloud to use the default endpoint for the region. Specify if using an S3 clone such as Ceph. endpoint> s3.arvanstorage.com Location constraint - must be set to match the Region. Used when creating buckets only. Choose a number from below, or type in your own value 1 / Empty for Iran-Tehran Region. \ "" [snip] location_constraint> Canned ACL used when creating buckets and/or storing objects in S3. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Choose a number from below, or type in your own value 1 / Owner gets FULL_CONTROL. No one else has access rights (default). \ "private" [snip] acl> The server-side encryption algorithm used when storing this object in S3. Choose a number from below, or type in your own value 1 / None \ "" 2 / AES256 \ "AES256" server_side_encryption> The storage class to use when storing objects in S3. Choose a number from below, or type in your own value 1 / Default \ "" 2 / Standard storage class \ "STANDARD" storage_class> Remote config -------------------- [ArvanCloud] env_auth = false access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY region = ir-thr-at1 endpoint = s3.arvanstorage.com location_constraint = acl = server_side_encryption = storage_class = -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` This will leave the config file looking like this. ``` [ArvanCloud] type = s3 provider = ArvanCloud env_auth = false access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY region = endpoint = s3.arvanstorage.com location_constraint = acl = server_side_encryption = storage_class = ``` ### Ceph [Ceph](https://ceph.com/) is an open-source, unified, distributed storage system designed for excellent performance, reliability and scalability. It has an S3 compatible object storage interface. To use rclone with Ceph, configure as above but leave the region blank and set the endpoint. You should end up with something like this in your config: ``` [ceph] type = s3 provider = Ceph env_auth = false access_key_id = XXX secret_access_key = YYY region = endpoint = https://ceph.endpoint.example.com location_constraint = acl = server_side_encryption = storage_class = ``` If you are using an older version of CEPH (e.g. 10.2.x Jewel) and a version of rclone before v1.59 then you may need to supply the parameter `--s3-upload-cutoff 0` or put this in the config file as `upload_cutoff 0` to work around a bug which causes uploading of small files to fail. Note also that Ceph sometimes puts `/` in the passwords it gives users. If you read the secret access key using the command line tools you will get a JSON blob with the `/` escaped as `\/`. Make sure you only write `/` in the secret access key. Eg the dump from Ceph looks something like this (irrelevant keys removed). ``` { "user_id": "xxx", "display_name": "xxxx", "keys": [ { "user": "xxx", "access_key": "xxxxxx", "secret_key": "xxxxxx\/xxxx" } ], } ``` Because this is a json dump, it is encoding the `/` as `\/`, so if you use the secret key as `xxxxxx/xxxx` it will work fine. ### China Mobile Ecloud Elastic Object Storage (EOS) {#china-mobile-ecloud-eos} Here is an example of making an [China Mobile Ecloud Elastic Object Storage (EOS)](https:///ecloud.10086.cn/home/product-introduction/eos/) configuration. First run: rclone config This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> ChinaMobile Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. ... XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) ... Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. ... 4 / China Mobile Ecloud Elastic Object Storage (EOS) \ (ChinaMobile) ... provider> ChinaMobile Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> accesskeyid Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> secretaccesskey Option endpoint. Endpoint for China Mobile Ecloud Elastic Object Storage (EOS) API. Choose a number from below, or type in your own value. Press Enter to leave empty. / The default endpoint - a good choice if you are unsure. 1 | East China (Suzhou) \ (eos-wuxi-1.cmecloud.cn) 2 / East China (Jinan) \ (eos-jinan-1.cmecloud.cn) 3 / East China (Hangzhou) \ (eos-ningbo-1.cmecloud.cn) 4 / East China (Shanghai-1) \ (eos-shanghai-1.cmecloud.cn) 5 / Central China (Zhengzhou) \ (eos-zhengzhou-1.cmecloud.cn) 6 / Central China (Changsha-1) \ (eos-hunan-1.cmecloud.cn) 7 / Central China (Changsha-2) \ (eos-zhuzhou-1.cmecloud.cn) 8 / South China (Guangzhou-2) \ (eos-guangzhou-1.cmecloud.cn) 9 / South China (Guangzhou-3) \ (eos-dongguan-1.cmecloud.cn) 10 / North China (Beijing-1) \ (eos-beijing-1.cmecloud.cn) 11 / North China (Beijing-2) \ (eos-beijing-2.cmecloud.cn) 12 / North China (Beijing-3) \ (eos-beijing-4.cmecloud.cn) 13 / North China (Huhehaote) \ (eos-huhehaote-1.cmecloud.cn) 14 / Southwest China (Chengdu) \ (eos-chengdu-1.cmecloud.cn) 15 / Southwest China (Chongqing) \ (eos-chongqing-1.cmecloud.cn) 16 / Southwest China (Guiyang) \ (eos-guiyang-1.cmecloud.cn) 17 / Nouthwest China (Xian) \ (eos-xian-1.cmecloud.cn) 18 / Yunnan China (Kunming) \ (eos-yunnan.cmecloud.cn) 19 / Yunnan China (Kunming-2) \ (eos-yunnan-2.cmecloud.cn) 20 / Tianjin China (Tianjin) \ (eos-tianjin-1.cmecloud.cn) 21 / Jilin China (Changchun) \ (eos-jilin-1.cmecloud.cn) 22 / Hubei China (Xiangyan) \ (eos-hubei-1.cmecloud.cn) 23 / Jiangxi China (Nanchang) \ (eos-jiangxi-1.cmecloud.cn) 24 / Gansu China (Lanzhou) \ (eos-gansu-1.cmecloud.cn) 25 / Shanxi China (Taiyuan) \ (eos-shanxi-1.cmecloud.cn) 26 / Liaoning China (Shenyang) \ (eos-liaoning-1.cmecloud.cn) 27 / Hebei China (Shijiazhuang) \ (eos-hebei-1.cmecloud.cn) 28 / Fujian China (Xiamen) \ (eos-fujian-1.cmecloud.cn) 29 / Guangxi China (Nanning) \ (eos-guangxi-1.cmecloud.cn) 30 / Anhui China (Huainan) \ (eos-anhui-1.cmecloud.cn) endpoint> 1 Option location_constraint. Location constraint - must match endpoint. Used when creating buckets only. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / East China (Suzhou) \ (wuxi1) 2 / East China (Jinan) \ (jinan1) 3 / East China (Hangzhou) \ (ningbo1) 4 / East China (Shanghai-1) \ (shanghai1) 5 / Central China (Zhengzhou) \ (zhengzhou1) 6 / Central China (Changsha-1) \ (hunan1) 7 / Central China (Changsha-2) \ (zhuzhou1) 8 / South China (Guangzhou-2) \ (guangzhou1) 9 / South China (Guangzhou-3) \ (dongguan1) 10 / North China (Beijing-1) \ (beijing1) 11 / North China (Beijing-2) \ (beijing2) 12 / North China (Beijing-3) \ (beijing4) 13 / North China (Huhehaote) \ (huhehaote1) 14 / Southwest China (Chengdu) \ (chengdu1) 15 / Southwest China (Chongqing) \ (chongqing1) 16 / Southwest China (Guiyang) \ (guiyang1) 17 / Nouthwest China (Xian) \ (xian1) 18 / Yunnan China (Kunming) \ (yunnan) 19 / Yunnan China (Kunming-2) \ (yunnan2) 20 / Tianjin China (Tianjin) \ (tianjin1) 21 / Jilin China (Changchun) \ (jilin1) 22 / Hubei China (Xiangyan) \ (hubei1) 23 / Jiangxi China (Nanchang) \ (jiangxi1) 24 / Gansu China (Lanzhou) \ (gansu1) 25 / Shanxi China (Taiyuan) \ (shanxi1) 26 / Liaoning China (Shenyang) \ (liaoning1) 27 / Hebei China (Shijiazhuang) \ (hebei1) 28 / Fujian China (Xiamen) \ (fujian1) 29 / Guangxi China (Nanning) \ (guangxi1) 30 / Anhui China (Huainan) \ (anhui1) location_constraint> 1 Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) / Owner gets FULL_CONTROL. 3 | The AllUsers group gets READ and WRITE access. | Granting this on a bucket is generally not recommended. \ (public-read-write) / Owner gets FULL_CONTROL. 4 | The AuthenticatedUsers group gets READ access. \ (authenticated-read) / Object owner gets FULL_CONTROL. acl> private Option server_side_encryption. The server-side encryption algorithm used when storing this object in S3. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / None \ () 2 / AES256 \ (AES256) server_side_encryption> Option storage_class. The storage class to use when storing new objects in ChinaMobile. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Default \ () 2 / Standard storage class \ (STANDARD) 3 / Archive storage mode \ (GLACIER) 4 / Infrequent access storage mode \ (STANDARD_IA) storage_class> Edit advanced config? y) Yes n) No (default) y/n> n -------------------- [ChinaMobile] type = s3 provider = ChinaMobile access_key_id = accesskeyid secret_access_key = secretaccesskey endpoint = eos-wuxi-1.cmecloud.cn location_constraint = wuxi1 acl = private -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ### Cloudflare R2 {#cloudflare-r2} [Cloudflare R2](https://blog.cloudflare.com/r2-open-beta/) Storage allows developers to store large amounts of unstructured data without the costly egress bandwidth fees associated with typical cloud storage services. Here is an example of making a Cloudflare R2 configuration. First run: rclone config This will guide you through an interactive setup process. Note that all buckets are private, and all are stored in the same "auto" region. It is necessary to use Cloudflare workers to share the content of a bucket publicly. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> r2 Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. ... XX / Amazon S3 Compliant Storage Providers including AWS, Alibaba, Ceph, China Mobile, Cloudflare, ArvanCloud, DigitalOcean, Dreamhost, Huawei OBS, IBM COS, Lyve Cloud, Minio, Magalu, Netease, RackCorp, Scaleway, SeaweedFS, StackPath, Storj, Synology, Tencent COS and Wasabi \ (s3) ... Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. ... XX / Cloudflare R2 Storage \ (Cloudflare) ... provider> Cloudflare Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> ACCESS_KEY Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> SECRET_ACCESS_KEY Option region. Region to connect to. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / R2 buckets are automatically distributed across Cloudflare's data centers for low latency. \ (auto) region> 1 Option endpoint. Endpoint for S3 API. Required when using an S3 clone. Enter a value. Press Enter to leave empty. endpoint> https://ACCOUNT_ID.r2.cloudflarestorage.com Edit advanced config? y) Yes n) No (default) y/n> n -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` This will leave your config looking something like: ``` [r2] type = s3 provider = Cloudflare access_key_id = ACCESS_KEY secret_access_key = SECRET_ACCESS_KEY region = auto endpoint = https://ACCOUNT_ID.r2.cloudflarestorage.com acl = private ``` Now run `rclone lsf r2:` to see your buckets and `rclone lsf r2:bucket` to look within a bucket. For R2 tokens with the "Object Read & Write" permission, you may also need to add `no_check_bucket = true` for object uploads to work correctly. Note that Cloudflare decompresses files uploaded with `Content-Encoding: gzip` by default which is a deviation from what AWS does. If this is causing a problem then upload the files with `--header-upload "Cache-Control: no-transform"` A consequence of this is that `Content-Encoding: gzip` will never appear in the metadata on Cloudflare. ### DigitalOcean Spaces [Spaces](https://www.digitalocean.com/products/object-storage/) is an [S3-interoperable](https://developers.digitalocean.com/documentation/spaces/) object storage service from cloud provider DigitalOcean. To connect to DigitalOcean Spaces you will need an access key and secret key. These can be retrieved on the "[Applications & API](https://cloud.digitalocean.com/settings/api/tokens)" page of the DigitalOcean control panel. They will be needed when prompted by `rclone config` for your `access_key_id` and `secret_access_key`. When prompted for a `region` or `location_constraint`, press enter to use the default value. The region must be included in the `endpoint` setting (e.g. `nyc3.digitaloceanspaces.com`). The default values can be used for other settings. Going through the whole process of creating a new remote by running `rclone config`, each prompt should be answered as shown below: ``` Storage> s3 env_auth> 1 access_key_id> YOUR_ACCESS_KEY secret_access_key> YOUR_SECRET_KEY region> endpoint> nyc3.digitaloceanspaces.com location_constraint> acl> storage_class> ``` The resulting configuration file should look like: ``` [spaces] type = s3 provider = DigitalOcean env_auth = false access_key_id = YOUR_ACCESS_KEY secret_access_key = YOUR_SECRET_KEY region = endpoint = nyc3.digitaloceanspaces.com location_constraint = acl = server_side_encryption = storage_class = ``` Once configured, you can create a new Space and begin copying files. For example: ``` rclone mkdir spaces:my-new-space rclone copy /path/to/files spaces:my-new-space ``` ### Dreamhost Dreamhost [DreamObjects](https://www.dreamhost.com/cloud/storage/) is an object storage system based on CEPH. To use rclone with Dreamhost, configure as above but leave the region blank and set the endpoint. You should end up with something like this in your config: ``` [dreamobjects] type = s3 provider = DreamHost env_auth = false access_key_id = your_access_key secret_access_key = your_secret_key region = endpoint = objects-us-west-1.dream.io location_constraint = acl = private server_side_encryption = storage_class = ``` ### Exaba {#exaba} [Exaba](https://exaba.com/) is an on-premises, S3-compatible storage for service providers and large enterprises. It is quick to deploy, with dynamic node management, tenant accounting, and a built-in key management system. It delivers secure, high-performance data storage with flexible, usage-based pricing. A container version [exaba/exaba](https://hub.docker.com/r/exaba/exaba) is free for end-users and on that page you can find instructions on how to set it up. You will need to log into the admin first (on port 9006 by default) to set up the container, then you can use the service on port 9000. You can also join the [exaba support slack](https://join.slack.com/t/exabasupport/shared_invite/zt-3b5jycjs3-0gDNyv60xKsAdNgjX72amQ) if you need more help. An `rclone config` walkthrough might look like this but details may vary depending exactly on how you have set up the container. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> exaba Option Storage. Type of storage to configure. Storage> s3 Option provider. Choose your S3 provider. provider> Exaba Option env_auth. env_auth> 1 Option access_key_id. access_key_id> XXX Option secret_access_key. secret_access_key> YYY Option region. region> Option endpoint. endpoint> http://127.0.0.1:9000/ Option location_constraint. location_constraint> Option acl. acl> Edit advanced config? y) Yes n) No (default) y/n> n ``` And the config generated will end up looking like this: ``` [exaba] type = s3 provider = Exaba access_key_id = XXX secret_access_key = XXX endpoint = http://127.0.0.1:9000/ ``` ### Google Cloud Storage [GoogleCloudStorage](https://cloud.google.com/storage/docs) is an [S3-interoperable](https://cloud.google.com/storage/docs/interoperability) object storage service from Google Cloud Platform. To connect to Google Cloud Storage you will need an access key and secret key. These can be retrieved by creating an [HMAC key](https://cloud.google.com/storage/docs/authentication/managing-hmackeys). ``` [gs] type = s3 provider = GCS access_key_id = your_access_key secret_access_key = your_secret_key endpoint = https://storage.googleapis.com ``` **Note** that `--s3-versions` does not work with GCS when it needs to do directory paging. Rclone will return the error: s3 protocol error: received versions listing with IsTruncated set with no NextKeyMarker This is Google bug [#312292516](https://issuetracker.google.com/u/0/issues/312292516). ### Huawei OBS {#huawei-obs} Object Storage Service (OBS) provides stable, secure, efficient, and easy-to-use cloud storage that lets you store virtually any volume of unstructured data in any format and access it from anywhere. OBS provides an S3 interface, you can copy and modify the following configuration and add it to your rclone configuration file. ``` [obs] type = s3 provider = HuaweiOBS access_key_id = your-access-key-id secret_access_key = your-secret-access-key region = af-south-1 endpoint = obs.af-south-1.myhuaweicloud.com acl = private ``` Or you can also configure via the interactive command line: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> obs Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] 9 / Huawei Object Storage Service \ (HuaweiOBS) [snip] provider> 9 Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> your-access-key-id Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> your-secret-access-key Option region. Region to connect to. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / AF-Johannesburg \ (af-south-1) 2 / AP-Bangkok \ (ap-southeast-2) [snip] region> 1 Option endpoint. Endpoint for OBS API. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / AF-Johannesburg \ (obs.af-south-1.myhuaweicloud.com) 2 / AP-Bangkok \ (obs.ap-southeast-2.myhuaweicloud.com) [snip] endpoint> 1 Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) [snip] acl> 1 Edit advanced config? y) Yes n) No (default) y/n> -------------------- [obs] type = s3 provider = HuaweiOBS access_key_id = your-access-key-id secret_access_key = your-secret-access-key region = af-south-1 endpoint = obs.af-south-1.myhuaweicloud.com acl = private -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== obs s3 e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q ``` ### IBM COS (S3) Information stored with IBM Cloud Object Storage is encrypted and dispersed across multiple geographic locations, and accessed through an implementation of the S3 API. This service makes use of the distributed storage technologies provided by IBM’s Cloud Object Storage System (formerly Cleversafe). For more information visit: (http://www.ibm.com/cloud/object-storage) To configure access to IBM COS S3, follow the steps below: 1. Run rclone config and select n for a new remote. ``` 2018/02/14 14:13:11 NOTICE: Config file "C:\\Users\\a\\.config\\rclone\\rclone.conf" not found - using defaults No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n ``` 2. Enter the name for the configuration ``` name> ``` 3. Select "s3" storage. ``` Choose a number from below, or type in your own value [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ "s3" [snip] Storage> s3 ``` 4. Select IBM COS as the S3 Storage Provider. ``` Choose the S3 provider. Choose a number from below, or type in your own value 1 / Choose this option to configure Storage to AWS S3 \ "AWS" 2 / Choose this option to configure Storage to Ceph Systems \ "Ceph" 3 / Choose this option to configure Storage to Dreamhost \ "Dreamhost" 4 / Choose this option to the configure Storage to IBM COS S3 \ "IBMCOS" 5 / Choose this option to the configure Storage to Minio \ "Minio" Provider>4 ``` 5. Enter the Access Key and Secret. ``` AWS Access Key ID - leave blank for anonymous access or runtime credentials. access_key_id> <> AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials. secret_access_key> <> ``` 6. Specify the endpoint for IBM COS. For Public IBM COS, choose from the option below. For On Premise IBM COS, enter an endpoint address. ``` Endpoint for IBM COS S3 API. Specify if using an IBM COS On Premise. Choose a number from below, or type in your own value 1 / US Cross Region Endpoint \ "s3-api.us-geo.objectstorage.softlayer.net" 2 / US Cross Region Dallas Endpoint \ "s3-api.dal.us-geo.objectstorage.softlayer.net" 3 / US Cross Region Washington DC Endpoint \ "s3-api.wdc-us-geo.objectstorage.softlayer.net" 4 / US Cross Region San Jose Endpoint \ "s3-api.sjc-us-geo.objectstorage.softlayer.net" 5 / US Cross Region Private Endpoint \ "s3-api.us-geo.objectstorage.service.networklayer.com" 6 / US Cross Region Dallas Private Endpoint \ "s3-api.dal-us-geo.objectstorage.service.networklayer.com" 7 / US Cross Region Washington DC Private Endpoint \ "s3-api.wdc-us-geo.objectstorage.service.networklayer.com" 8 / US Cross Region San Jose Private Endpoint \ "s3-api.sjc-us-geo.objectstorage.service.networklayer.com" 9 / US Region East Endpoint \ "s3.us-east.objectstorage.softlayer.net" 10 / US Region East Private Endpoint \ "s3.us-east.objectstorage.service.networklayer.com" 11 / US Region South Endpoint [snip] 34 / Toronto Single Site Private Endpoint \ "s3.tor01.objectstorage.service.networklayer.com" endpoint>1 ``` 7. Specify a IBM COS Location Constraint. The location constraint must match endpoint when using IBM Cloud Public. For on-prem COS, do not make a selection from this list, hit enter ``` 1 / US Cross Region Standard \ "us-standard" 2 / US Cross Region Vault \ "us-vault" 3 / US Cross Region Cold \ "us-cold" 4 / US Cross Region Flex \ "us-flex" 5 / US East Region Standard \ "us-east-standard" 6 / US East Region Vault \ "us-east-vault" 7 / US East Region Cold \ "us-east-cold" 8 / US East Region Flex \ "us-east-flex" 9 / US South Region Standard \ "us-south-standard" 10 / US South Region Vault \ "us-south-vault" [snip] 32 / Toronto Flex \ "tor01-flex" location_constraint>1 ``` 8. Specify a canned ACL. IBM Cloud (Storage) supports "public-read" and "private". IBM Cloud(Infra) supports all the canned ACLs. On-Premise COS supports all the canned ACLs. ``` Canned ACL used when creating buckets and/or storing objects in S3. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Choose a number from below, or type in your own value 1 / Owner gets FULL_CONTROL. No one else has access rights (default). This acl is available on IBM Cloud (Infra), IBM Cloud (Storage), On-Premise COS \ "private" 2 / Owner gets FULL_CONTROL. The AllUsers group gets READ access. This acl is available on IBM Cloud (Infra), IBM Cloud (Storage), On-Premise IBM COS \ "public-read" 3 / Owner gets FULL_CONTROL. The AllUsers group gets READ and WRITE access. This acl is available on IBM Cloud (Infra), On-Premise IBM COS \ "public-read-write" 4 / Owner gets FULL_CONTROL. The AuthenticatedUsers group gets READ access. Not supported on Buckets. This acl is available on IBM Cloud (Infra) and On-Premise IBM COS \ "authenticated-read" acl> 1 ``` 9. Review the displayed configuration and accept to save the "remote" then quit. The config file should look like this ``` [xxx] type = s3 Provider = IBMCOS access_key_id = xxx secret_access_key = yyy endpoint = s3-api.us-geo.objectstorage.softlayer.net location_constraint = us-standard acl = private ``` 10. Execute rclone commands ``` 1) Create a bucket. rclone mkdir IBM-COS-XREGION:newbucket 2) List available buckets. rclone lsd IBM-COS-XREGION: -1 2017-11-08 21:16:22 -1 test -1 2018-02-14 20:16:39 -1 newbucket 3) List contents of a bucket. rclone ls IBM-COS-XREGION:newbucket 18685952 test.exe 4) Copy a file from local to remote. rclone copy /Users/file.txt IBM-COS-XREGION:newbucket 5) Copy a file from remote to local. rclone copy IBM-COS-XREGION:newbucket/file.txt . 6) Delete a file on remote. rclone delete IBM-COS-XREGION:newbucket/file.txt ``` #### IBM IAM authentication If using IBM IAM authentication with IBM API KEY you need to fill in these additional parameters 1. Select false for env_auth 2. Leave `access_key_id` and `secret_access_key` blank 3. Paste your `ibm_api_key` ``` Option ibm_api_key. IBM API Key to be used to obtain IAM token Enter a value of type string. Press Enter for the default (1). ibm_api_key> ``` 4. Paste your `ibm_resource_instance_id` ``` Option ibm_resource_instance_id. IBM service instance id Enter a value of type string. Press Enter for the default (2). ibm_resource_instance_id> ``` 5. In advanced settings type true for `v2_auth` ``` Option v2_auth. If true use v2 authentication. If this is false (the default) then rclone will use v4 authentication. If it is set then rclone will use v2 authentication. Use this only if v4 signatures don't work, e.g. pre Jewel/v10 CEPH. Enter a boolean value (true or false). Press Enter for the default (true). v2_auth> ``` ### IDrive e2 {#idrive-e2} Here is an example of making an [IDrive e2](https://www.idrive.com/e2/) configuration. First run: rclone config This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> e2 Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / IDrive e2 \ (IDrive) [snip] provider> IDrive Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> YOUR_ACCESS_KEY Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> YOUR_SECRET_KEY Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) / Owner gets FULL_CONTROL. 3 | The AllUsers group gets READ and WRITE access. | Granting this on a bucket is generally not recommended. \ (public-read-write) / Owner gets FULL_CONTROL. 4 | The AuthenticatedUsers group gets READ access. \ (authenticated-read) / Object owner gets FULL_CONTROL. 5 | Bucket owner gets READ access. | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-read) / Both the object owner and the bucket owner get FULL_CONTROL over the object. 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-full-control) acl> Edit advanced config? y) Yes n) No (default) y/n> Configuration complete. Options: - type: s3 - provider: IDrive - access_key_id: YOUR_ACCESS_KEY - secret_access_key: YOUR_SECRET_KEY - endpoint: q9d9.la12.idrivee2-5.com Keep this "e2" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ### IONOS Cloud {#ionos} [IONOS S3 Object Storage](https://cloud.ionos.com/storage/object-storage) is a service offered by IONOS for storing and accessing unstructured data. To connect to the service, you will need an access key and a secret key. These can be found in the [Data Center Designer](https://dcd.ionos.com/), by selecting **Manager resources** > **Object Storage Key Manager**. Here is an example of a configuration. First, run `rclone config`. This will walk you through an interactive setup process. Type `n` to add the new remote, and then enter a name: ``` Enter name for new remote. name> ionos-fra ``` Type `s3` to choose the connection type: ``` Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) [snip] Storage> s3 ``` Type `IONOS`: ``` Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / IONOS Cloud \ (IONOS) [snip] provider> IONOS ``` Press Enter to choose the default option `Enter AWS credentials in the next step`: ``` Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> ``` Enter your Access Key and Secret key. These can be retrieved in the [Data Center Designer](https://dcd.ionos.com/), click on the menu “Manager resources” / "Object Storage Key Manager". ``` Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> YOUR_ACCESS_KEY Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> YOUR_SECRET_KEY ``` Choose the region where your bucket is located: ``` Option region. Region where your bucket will be created and your data stored. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Frankfurt, Germany \ (de) 2 / Berlin, Germany \ (eu-central-2) 3 / Logrono, Spain \ (eu-south-2) region> 2 ``` Choose the endpoint from the same region: ``` Option endpoint. Endpoint for IONOS S3 Object Storage. Specify the endpoint from the same region. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Frankfurt, Germany \ (s3-eu-central-1.ionoscloud.com) 2 / Berlin, Germany \ (s3-eu-central-2.ionoscloud.com) 3 / Logrono, Spain \ (s3-eu-south-2.ionoscloud.com) endpoint> 1 ``` Press Enter to choose the default option or choose the desired ACL setting: ``` Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. [snip] acl> ``` Press Enter to skip the advanced config: ``` Edit advanced config? y) Yes n) No (default) y/n> ``` Press Enter to save the configuration, and then `q` to quit the configuration process: ``` Configuration complete. Options: - type: s3 - provider: IONOS - access_key_id: YOUR_ACCESS_KEY - secret_access_key: YOUR_SECRET_KEY - endpoint: s3-eu-central-1.ionoscloud.com Keep this "ionos-fra" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` Done! Now you can try some commands (for macOS, use `./rclone` instead of `rclone`). 1) Create a bucket (the name must be unique within the whole IONOS S3) ``` rclone mkdir ionos-fra:my-bucket ``` 2) List available buckets ``` rclone lsd ionos-fra: ``` 4) Copy a file from local to remote ``` rclone copy /Users/file.txt ionos-fra:my-bucket ``` 3) List contents of a bucket ``` rclone ls ionos-fra:my-bucket ``` 5) Copy a file from remote to local ``` rclone copy ionos-fra:my-bucket/file.txt ``` ### Leviia Cloud Object Storage {#leviia} [Leviia Object Storage](https://www.leviia.com/object-storage/), backup and secure your data in a 100% French cloud, independent of GAFAM.. To configure access to Leviia, follow the steps below: 1. Run `rclone config` and select `n` for a new remote. ``` rclone config No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n ``` 2. Give the name of the configuration. For example, name it 'leviia'. ``` name> leviia ``` 3. Select `s3` storage. ``` Choose a number from below, or type in your own value [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) [snip] Storage> s3 ``` 4. Select `Leviia` provider. ``` Choose a number from below, or type in your own value 1 / Amazon Web Services (AWS) S3 \ "AWS" [snip] 15 / Leviia Object Storage \ (Leviia) [snip] provider> Leviia ``` 5. Enter your SecretId and SecretKey of Leviia. ``` Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Enter a boolean value (true or false). Press Enter for the default ("false"). Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). access_key_id> ZnIx.xxxxxxxxxxxxxxx AWS Secret Access Key (password) Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). secret_access_key> xxxxxxxxxxx ``` 6. Select endpoint for Leviia. ``` / The default endpoint 1 | Leviia. \ (s3.leviia.com) [snip] endpoint> 1 ``` 7. Choose acl. ``` Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) [snip] acl> 1 Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config -------------------- [leviia] - type: s3 - provider: Leviia - access_key_id: ZnIx.xxxxxxx - secret_access_key: xxxxxxxx - endpoint: s3.leviia.com - acl: private -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== leviia s3 ``` ### Liara {#liara-cloud} Here is an example of making a [Liara Object Storage](https://liara.ir/landing/object-storage) configuration. First run: rclone config This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password n/s> n name> Liara Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Amazon S3 (also Dreamhost, Ceph, ChinaMobile, ArvanCloud, Liara, Minio) \ "s3" [snip] Storage> s3 Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID - leave blank for anonymous access or runtime credentials. access_key_id> YOURACCESSKEY AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials. secret_access_key> YOURSECRETACCESSKEY Region to connect to. Choose a number from below, or type in your own value / The default endpoint 1 | US Region, Northern Virginia, or Pacific Northwest. | Leave location constraint empty. \ "us-east-1" [snip] region> Endpoint for S3 API. Leave blank if using Liara to use the default endpoint for the region. Specify if using an S3 clone such as Ceph. endpoint> storage.iran.liara.space Canned ACL used when creating buckets and/or storing objects in S3. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Choose a number from below, or type in your own value 1 / Owner gets FULL_CONTROL. No one else has access rights (default). \ "private" [snip] acl> The server-side encryption algorithm used when storing this object in S3. Choose a number from below, or type in your own value 1 / None \ "" 2 / AES256 \ "AES256" server_side_encryption> The storage class to use when storing objects in S3. Choose a number from below, or type in your own value 1 / Default \ "" 2 / Standard storage class \ "STANDARD" storage_class> Remote config -------------------- [Liara] env_auth = false access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY endpoint = storage.iran.liara.space location_constraint = acl = server_side_encryption = storage_class = -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` This will leave the config file looking like this. ``` [Liara] type = s3 provider = Liara env_auth = false access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY region = endpoint = storage.iran.liara.space location_constraint = acl = server_side_encryption = storage_class = ``` ### Linode {#linode} Here is an example of making a [Linode Object Storage](https://www.linode.com/products/object-storage/) configuration. First run: rclone config This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> linode Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ...Linode, ...and others \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / Linode Object Storage \ (Linode) [snip] provider> Linode Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> ACCESS_KEY Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> SECRET_ACCESS_KEY Option endpoint. Endpoint for Linode Object Storage API. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Amsterdam (Netherlands), nl-ams-1 \ (nl-ams-1.linodeobjects.com) 2 / Atlanta, GA (USA), us-southeast-1 \ (us-southeast-1.linodeobjects.com) 3 / Chennai (India), in-maa-1 \ (in-maa-1.linodeobjects.com) 4 / Chicago, IL (USA), us-ord-1 \ (us-ord-1.linodeobjects.com) 5 / Frankfurt (Germany), eu-central-1 \ (eu-central-1.linodeobjects.com) 6 / Jakarta (Indonesia), id-cgk-1 \ (id-cgk-1.linodeobjects.com) 7 / London 2 (Great Britain), gb-lon-1 \ (gb-lon-1.linodeobjects.com) 8 / Los Angeles, CA (USA), us-lax-1 \ (us-lax-1.linodeobjects.com) 9 / Madrid (Spain), es-mad-1 \ (es-mad-1.linodeobjects.com) 10 / Melbourne (Australia), au-mel-1 \ (au-mel-1.linodeobjects.com) 11 / Miami, FL (USA), us-mia-1 \ (us-mia-1.linodeobjects.com) 12 / Milan (Italy), it-mil-1 \ (it-mil-1.linodeobjects.com) 13 / Newark, NJ (USA), us-east-1 \ (us-east-1.linodeobjects.com) 14 / Osaka (Japan), jp-osa-1 \ (jp-osa-1.linodeobjects.com) 15 / Paris (France), fr-par-1 \ (fr-par-1.linodeobjects.com) 16 / São Paulo (Brazil), br-gru-1 \ (br-gru-1.linodeobjects.com) 17 / Seattle, WA (USA), us-sea-1 \ (us-sea-1.linodeobjects.com) 18 / Singapore, ap-south-1 \ (ap-south-1.linodeobjects.com) 19 / Singapore 2, sg-sin-1 \ (sg-sin-1.linodeobjects.com) 20 / Stockholm (Sweden), se-sto-1 \ (se-sto-1.linodeobjects.com) 21 / Washington, DC, (USA), us-iad-1 \ (us-iad-1.linodeobjects.com) endpoint> 5 Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) [snip] acl> Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: s3 - provider: Linode - access_key_id: ACCESS_KEY - secret_access_key: SECRET_ACCESS_KEY - endpoint: eu-central-1.linodeobjects.com Keep this "linode" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` This will leave the config file looking like this. ``` [linode] type = s3 provider = Linode access_key_id = ACCESS_KEY secret_access_key = SECRET_ACCESS_KEY endpoint = eu-central-1.linodeobjects.com ``` ### Magalu {#magalu} Here is an example of making a [Magalu Object Storage](https://magalu.cloud/object-storage/) configuration. First run: rclone config This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> magalu Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ...Magalu, ...and others \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / Magalu Object Storage \ (Magalu) [snip] provider> Magalu Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> ACCESS_KEY Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> SECRET_ACCESS_KEY Option endpoint. Endpoint for Magalu Object Storage API. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / São Paulo, SP (BR), br-se1 \ (br-se1.magaluobjects.com) 2 / Fortaleza, CE (BR), br-ne1 \ (br-ne1.magaluobjects.com) endpoint> 2 Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) [snip] acl> Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: s3 - provider: magalu - access_key_id: ACCESS_KEY - secret_access_key: SECRET_ACCESS_KEY - endpoint: br-ne1.magaluobjects.com Keep this "magalu" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` This will leave the config file looking like this. ``` [magalu] type = s3 provider = Magalu access_key_id = ACCESS_KEY secret_access_key = SECRET_ACCESS_KEY endpoint = br-ne1.magaluobjects.com ``` ### MEGA S4 {#mega} [MEGA S4 Object Storage](https://mega.io/objectstorage) is an S3 compatible object storage system. It has a single pricing tier with no additional charges for data transfers or API requests and it is included in existing Pro plans. Here is an example of making a configuration. First run: rclone config This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> megas4 Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS,... Mega, ... \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / MEGA S4 Object Storage \ (Mega) [snip] provider> Mega Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> XXX Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> XXX Option endpoint. Endpoint for S3 API. Required when using an S3 clone. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Mega S4 eu-central-1 (Amsterdam) \ (s3.eu-central-1.s4.mega.io) 2 / Mega S4 eu-central-2 (Bettembourg) \ (s3.eu-central-2.s4.mega.io) 3 / Mega S4 ca-central-1 (Montreal) \ (s3.ca-central-1.s4.mega.io) 4 / Mega S4 ca-west-1 (Vancouver) \ (s3.ca-west-1.s4.mega.io) endpoint> 1 Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: s3 - provider: Mega - access_key_id: XXX - secret_access_key: XXX - endpoint: s3.eu-central-1.s4.mega.io Keep this "megas4" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` This will leave the config file looking like this. ``` [megas4] type = s3 provider = Mega access_key_id = XXX secret_access_key = XXX endpoint = s3.eu-central-1.s4.mega.io ``` ### Minio [Minio](https://minio.io/) is an object storage server built for cloud application developers and devops. It is very easy to install and provides an S3 compatible server which can be used by rclone. To use it, install Minio following the instructions [here](https://docs.minio.io/docs/minio-quickstart-guide). When it configures itself Minio will print something like this ``` Endpoint: http://192.168.1.106:9000 http://172.23.0.1:9000 AccessKey: USWUXHGYZQYFYFFIT3RE SecretKey: MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03 Region: us-east-1 SQS ARNs: arn:minio:sqs:us-east-1:1:redis arn:minio:sqs:us-east-1:2:redis Browser Access: http://192.168.1.106:9000 http://172.23.0.1:9000 Command-line Access: https://docs.minio.io/docs/minio-client-quickstart-guide $ mc config host add myminio http://192.168.1.106:9000 USWUXHGYZQYFYFFIT3RE MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03 Object API (Amazon S3 compatible): Go: https://docs.minio.io/docs/golang-client-quickstart-guide Java: https://docs.minio.io/docs/java-client-quickstart-guide Python: https://docs.minio.io/docs/python-client-quickstart-guide JavaScript: https://docs.minio.io/docs/javascript-client-quickstart-guide .NET: https://docs.minio.io/docs/dotnet-client-quickstart-guide Drive Capacity: 26 GiB Free, 165 GiB Total ``` These details need to go into `rclone config` like this. Note that it is important to put the region in as stated above. ``` env_auth> 1 access_key_id> USWUXHGYZQYFYFFIT3RE secret_access_key> MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03 region> us-east-1 endpoint> http://192.168.1.106:9000 location_constraint> server_side_encryption> ``` Which makes the config file look like this ``` [minio] type = s3 provider = Minio env_auth = false access_key_id = USWUXHGYZQYFYFFIT3RE secret_access_key = MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03 region = us-east-1 endpoint = http://192.168.1.106:9000 location_constraint = server_side_encryption = ``` So once set up, for example, to copy files into a bucket ``` rclone copy /path/to/files minio:bucket ``` ### Netease NOS For Netease NOS configure as per the configurator `rclone config` setting the provider `Netease`. This will automatically set `force_path_style = false` which is necessary for it to run properly. ### Outscale [OUTSCALE Object Storage (OOS)](https://en.outscale.com/storage/outscale-object-storage/) is an enterprise-grade, S3-compatible storage service provided by OUTSCALE, a brand of Dassault Systèmes. For more information about OOS, see the [official documentation](https://docs.outscale.com/en/userguide/OUTSCALE-Object-Storage-OOS.html). Here is an example of an OOS configuration that you can paste into your rclone configuration file: ``` [outscale] type = s3 provider = Outscale env_auth = false access_key_id = ABCDEFGHIJ0123456789 secret_access_key = XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX region = eu-west-2 endpoint = oos.eu-west-2.outscale.com acl = private ``` You can also run `rclone config` to go through the interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n ``` ``` Enter name for new remote. name> outscale ``` ``` Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] X / Amazon S3 Compliant Storage Providers including AWS, ...Outscale, ...and others \ (s3) [snip] Storage> outscale ``` ``` Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / OUTSCALE Object Storage (OOS) \ (Outscale) [snip] provider> Outscale ``` ``` Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> ``` ``` Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> ABCDEFGHIJ0123456789 ``` ``` Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX ``` ``` Option region. Region where your bucket will be created and your data stored. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Paris, France \ (eu-west-2) 2 / New Jersey, USA \ (us-east-2) 3 / California, USA \ (us-west-1) 4 / SecNumCloud, Paris, France \ (cloudgouv-eu-west-1) 5 / Tokyo, Japan \ (ap-northeast-1) region> 1 ``` ``` Option endpoint. Endpoint for S3 API. Required when using an S3 clone. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Outscale EU West 2 (Paris) \ (oos.eu-west-2.outscale.com) 2 / Outscale US east 2 (New Jersey) \ (oos.us-east-2.outscale.com) 3 / Outscale EU West 1 (California) \ (oos.us-west-1.outscale.com) 4 / Outscale SecNumCloud (Paris) \ (oos.cloudgouv-eu-west-1.outscale.com) 5 / Outscale AP Northeast 1 (Japan) \ (oos.ap-northeast-1.outscale.com) endpoint> 1 ``` ``` Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) [snip] acl> 1 ``` ``` Edit advanced config? y) Yes n) No (default) y/n> n ``` ``` Configuration complete. Options: - type: s3 - provider: Outscale - access_key_id: ABCDEFGHIJ0123456789 - secret_access_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX - endpoint: oos.eu-west-2.outscale.com Keep this "outscale" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ### OVHcloud {#ovhcloud} [OVHcloud Object Storage](https://www.ovhcloud.com/en-ie/public-cloud/object-storage/) is an S3-compatible general-purpose object storage platform available in all OVHcloud regions. To use the platform, you will need an access key and secret key. To know more about it and how to interact with the platform, take a look at the [documentation](https://ovh.to/8stqhuo). Here is an example of making an OVHcloud Object Storage configuration with `rclone config`: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> ovhcloud-rbx Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [...] XX / Amazon S3 Compliant Storage Providers including AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, Magalu, Minio, Netease, Outscale, OVHcloud, Petabox, RackCorp, Rclone, Scaleway, SeaweedFS, Selectel, StackPath, Storj, Synology, TencentCOS, Wasabi, Qiniu and others \ (s3) [...] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [...] XX / OVHcloud Object Storage \ (OVHcloud) [...] provider> OVHcloud Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> my_access Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> my_secret Option region. Region where your bucket will be created and your data stored. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Gravelines, France \ (gra) 2 / Roubaix, France \ (rbx) 3 / Strasbourg, France \ (sbg) 4 / Paris, France (3AZ) \ (eu-west-par) 5 / Frankfurt, Germany \ (de) 6 / London, United Kingdom \ (uk) 7 / Warsaw, Poland \ (waw) 8 / Beauharnois, Canada \ (bhs) 9 / Toronto, Canada \ (ca-east-tor) 10 / Singapore \ (sgp) 11 / Sydney, Australia \ (ap-southeast-syd) 12 / Mumbai, India \ (ap-south-mum) 13 / Vint Hill, Virginia, USA \ (us-east-va) 14 / Hillsboro, Oregon, USA \ (us-west-or) 15 / Roubaix, France (Cold Archive) \ (rbx-archive) region> 2 Option endpoint. Endpoint for OVHcloud Object Storage. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / OVHcloud Gravelines, France \ (s3.gra.io.cloud.ovh.net) 2 / OVHcloud Roubaix, France \ (s3.rbx.io.cloud.ovh.net) 3 / OVHcloud Strasbourg, France \ (s3.sbg.io.cloud.ovh.net) 4 / OVHcloud Paris, France (3AZ) \ (s3.eu-west-par.io.cloud.ovh.net) 5 / OVHcloud Frankfurt, Germany \ (s3.de.io.cloud.ovh.net) 6 / OVHcloud London, United Kingdom \ (s3.uk.io.cloud.ovh.net) 7 / OVHcloud Warsaw, Poland \ (s3.waw.io.cloud.ovh.net) 8 / OVHcloud Beauharnois, Canada \ (s3.bhs.io.cloud.ovh.net) 9 / OVHcloud Toronto, Canada \ (s3.ca-east-tor.io.cloud.ovh.net) 10 / OVHcloud Singapore \ (s3.sgp.io.cloud.ovh.net) 11 / OVHcloud Sydney, Australia \ (s3.ap-southeast-syd.io.cloud.ovh.net) 12 / OVHcloud Mumbai, India \ (s3.ap-south-mum.io.cloud.ovh.net) 13 / OVHcloud Vint Hill, Virginia, USA \ (s3.us-east-va.io.cloud.ovh.us) 14 / OVHcloud Hillsboro, Oregon, USA \ (s3.us-west-or.io.cloud.ovh.us) 15 / OVHcloud Roubaix, France (Cold Archive) \ (s3.rbx-archive.io.cloud.ovh.net) endpoint> 2 Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) / Owner gets FULL_CONTROL. 3 | The AllUsers group gets READ and WRITE access. | Granting this on a bucket is generally not recommended. \ (public-read-write) / Owner gets FULL_CONTROL. 4 | The AuthenticatedUsers group gets READ access. \ (authenticated-read) / Object owner gets FULL_CONTROL. 5 | Bucket owner gets READ access. | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-read) / Both the object owner and the bucket owner get FULL_CONTROL over the object. 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-full-control) acl> 1 Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: s3 - provider: OVHcloud - access_key_id: my_access - secret_access_key: my_secret - region: rbx - endpoint: s3.rbx.io.cloud.ovh.net - acl: private Keep this "ovhcloud-rbx" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` Your configuration file should now look like this: ``` [ovhcloud-rbx] type = s3 provider = OVHcloud access_key_id = my_access secret_access_key = my_secret region = rbx endpoint = s3.rbx.io.cloud.ovh.net acl = private ``` ### Petabox Here is an example of making a [Petabox](https://petabox.io/) configuration. First run: ```bash rclone config ``` This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password n/s> n Enter name for new remote. name> My Petabox Storage Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ "s3" [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / Petabox Object Storage \ (Petabox) [snip] provider> Petabox Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> YOUR_ACCESS_KEY_ID Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> YOUR_SECRET_ACCESS_KEY Option region. Region where your bucket will be created and your data stored. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / US East (N. Virginia) \ (us-east-1) 2 / Europe (Frankfurt) \ (eu-central-1) 3 / Asia Pacific (Singapore) \ (ap-southeast-1) 4 / Middle East (Bahrain) \ (me-south-1) 5 / South America (São Paulo) \ (sa-east-1) region> 1 Option endpoint. Endpoint for Petabox S3 Object Storage. Specify the endpoint from the same region. Choose a number from below, or type in your own value. 1 / US East (N. Virginia) \ (s3.petabox.io) 2 / US East (N. Virginia) \ (s3.us-east-1.petabox.io) 3 / Europe (Frankfurt) \ (s3.eu-central-1.petabox.io) 4 / Asia Pacific (Singapore) \ (s3.ap-southeast-1.petabox.io) 5 / Middle East (Bahrain) \ (s3.me-south-1.petabox.io) 6 / South America (São Paulo) \ (s3.sa-east-1.petabox.io) endpoint> 1 Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) / Owner gets FULL_CONTROL. 3 | The AllUsers group gets READ and WRITE access. | Granting this on a bucket is generally not recommended. \ (public-read-write) / Owner gets FULL_CONTROL. 4 | The AuthenticatedUsers group gets READ access. \ (authenticated-read) / Object owner gets FULL_CONTROL. 5 | Bucket owner gets READ access. | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-read) / Both the object owner and the bucket owner get FULL_CONTROL over the object. 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-full-control) acl> 1 Edit advanced config? y) Yes n) No (default) y/n> No Configuration complete. Options: - type: s3 - provider: Petabox - access_key_id: YOUR_ACCESS_KEY_ID - secret_access_key: YOUR_SECRET_ACCESS_KEY - region: us-east-1 - endpoint: s3.petabox.io Keep this "My Petabox Storage" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` This will leave the config file looking like this. ``` [My Petabox Storage] type = s3 provider = Petabox access_key_id = YOUR_ACCESS_KEY_ID secret_access_key = YOUR_SECRET_ACCESS_KEY region = us-east-1 endpoint = s3.petabox.io ``` ### Pure Storage FlashBlade [Pure Storage FlashBlade](https://www.purestorage.com/products/unstructured-data-storage.html) is a high performance S3-compatible object store. FlashBlade supports most modern S3 features including: - ListObjectsV2 - Multipart uploads with AWS-compatible ETags - Advanced checksum algorithms (SHA256, CRC32, CRC32C) with trailer support (Purity//FB 4.4.2+) - Object versioning and lifecycle management - Virtual hosted-style requests (requires DNS configuration) To configure rclone for Pure Storage FlashBlade: First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> flashblade Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] 4 / Amazon S3 Compliant Storage Providers including AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, FlashBlade, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, Magalu, Minio, Netease, Outscale, Petabox, RackCorp, Rclone, Scaleway, SeaweedFS, Selectel, StackPath, Storj, Synology, TencentCOS, Wasabi, Qiniu and others \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] 9 / Pure Storage FlashBlade Object Storage \ (FlashBlade) [snip] provider> FlashBlade Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> ACCESS_KEY_ID Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> SECRET_ACCESS_KEY Option endpoint. Endpoint for S3 API. Required when using an S3 clone. Enter a value. Press Enter to leave empty. endpoint> https://s3.flashblade.example.com Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: s3 - provider: FlashBlade - access_key_id: ACCESS_KEY_ID - secret_access_key: SECRET_ACCESS_KEY - endpoint: https://s3.flashblade.example.com Keep this "flashblade" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` This results in the following configuration being stored in `~/.config/rclone/rclone.conf`: ``` [flashblade] type = s3 provider = FlashBlade access_key_id = ACCESS_KEY_ID secret_access_key = SECRET_ACCESS_KEY endpoint = https://s3.flashblade.example.com ``` Note: The FlashBlade endpoint should be the S3 data VIP. For virtual-hosted style requests, ensure proper DNS configuration: subdomains of the endpoint hostname should resolve to a FlashBlade data VIP. For example, if your endpoint is `https://s3.flashblade.example.com`, then `bucket-name.s3.flashblade.example.com` should also resolve to the data VIP. ### Qiniu Cloud Object Storage (Kodo) {#qiniu} [Qiniu Cloud Object Storage (Kodo)](https://www.qiniu.com/en/products/kodo), a completely independent-researched core technology which is proven by repeated customer experience has occupied absolute leading market leader position. Kodo can be widely applied to mass data management. To configure access to Qiniu Kodo, follow the steps below: 1. Run `rclone config` and select `n` for a new remote. ``` rclone config No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n ``` 2. Give the name of the configuration. For example, name it 'qiniu'. ``` name> qiniu ``` 3. Select `s3` storage. ``` Choose a number from below, or type in your own value [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) [snip] Storage> s3 ``` 4. Select `Qiniu` provider. ``` Choose a number from below, or type in your own value 1 / Amazon Web Services (AWS) S3 \ "AWS" [snip] 22 / Qiniu Object Storage (Kodo) \ (Qiniu) [snip] provider> Qiniu ``` 5. Enter your SecretId and SecretKey of Qiniu Kodo. ``` Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Enter a boolean value (true or false). Press Enter for the default ("false"). Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). access_key_id> AKIDxxxxxxxxxx AWS Secret Access Key (password) Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). secret_access_key> xxxxxxxxxxx ``` 6. Select endpoint for Qiniu Kodo. This is the standard endpoint for different region. ``` / The default endpoint - a good choice if you are unsure. 1 | East China Region 1. | Needs location constraint cn-east-1. \ (cn-east-1) / East China Region 2. 2 | Needs location constraint cn-east-2. \ (cn-east-2) / North China Region 1. 3 | Needs location constraint cn-north-1. \ (cn-north-1) / South China Region 1. 4 | Needs location constraint cn-south-1. \ (cn-south-1) / North America Region. 5 | Needs location constraint us-north-1. \ (us-north-1) / Southeast Asia Region 1. 6 | Needs location constraint ap-southeast-1. \ (ap-southeast-1) / Northeast Asia Region 1. 7 | Needs location constraint ap-northeast-1. \ (ap-northeast-1) [snip] endpoint> 1 Option endpoint. Endpoint for Qiniu Object Storage. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / East China Endpoint 1 \ (s3-cn-east-1.qiniucs.com) 2 / East China Endpoint 2 \ (s3-cn-east-2.qiniucs.com) 3 / North China Endpoint 1 \ (s3-cn-north-1.qiniucs.com) 4 / South China Endpoint 1 \ (s3-cn-south-1.qiniucs.com) 5 / North America Endpoint 1 \ (s3-us-north-1.qiniucs.com) 6 / Southeast Asia Endpoint 1 \ (s3-ap-southeast-1.qiniucs.com) 7 / Northeast Asia Endpoint 1 \ (s3-ap-northeast-1.qiniucs.com) endpoint> 1 Option location_constraint. Location constraint - must be set to match the Region. Used when creating buckets only. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / East China Region 1 \ (cn-east-1) 2 / East China Region 2 \ (cn-east-2) 3 / North China Region 1 \ (cn-north-1) 4 / South China Region 1 \ (cn-south-1) 5 / North America Region 1 \ (us-north-1) 6 / Southeast Asia Region 1 \ (ap-southeast-1) 7 / Northeast Asia Region 1 \ (ap-northeast-1) location_constraint> 1 ``` 7. Choose acl and storage class. ``` Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) [snip] acl> 2 The storage class to use when storing new objects in Tencent COS. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Standard storage class \ (STANDARD) 2 / Infrequent access storage mode \ (LINE) 3 / Archive storage mode \ (GLACIER) 4 / Deep archive storage mode \ (DEEP_ARCHIVE) [snip] storage_class> 1 Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config -------------------- [qiniu] - type: s3 - provider: Qiniu - access_key_id: xxx - secret_access_key: xxx - region: cn-east-1 - endpoint: s3-cn-east-1.qiniucs.com - location_constraint: cn-east-1 - acl: public-read - storage_class: STANDARD -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== qiniu s3 ``` ### RackCorp {#RackCorp} [RackCorp Object Storage](https://www.rackcorp.com/storage/s3storage) is an S3 compatible object storage platform from your friendly cloud provider RackCorp. The service is fast, reliable, well priced and located in many strategic locations unserviced by others, to ensure you can maintain data sovereignty. Before you can use RackCorp Object Storage, you'll need to "[sign up](https://www.rackcorp.com/signup)" for an account on our "[portal](https://portal.rackcorp.com)". Next you can create an `access key`, a `secret key` and `buckets`, in your location of choice with ease. These details are required for the next steps of configuration, when `rclone config` asks for your `access_key_id` and `secret_access_key`. Your config should end up looking a bit like this: ``` [RCS3-demo-config] type = s3 provider = RackCorp env_auth = true access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY region = au-nsw endpoint = s3.rackcorp.com location_constraint = au-nsw ``` ### Rclone Serve S3 {#rclone} Rclone can serve any remote over the S3 protocol. For details see the [rclone serve s3](https://rclone.org/commands/rclone_serve_s3/) documentation. For example, to serve `remote:path` over s3, run the server like this: ``` rclone serve s3 --auth-key ACCESS_KEY_ID,SECRET_ACCESS_KEY remote:path ``` This will be compatible with an rclone remote which is defined like this: ``` [serves3] type = s3 provider = Rclone endpoint = http://127.0.0.1:8080/ access_key_id = ACCESS_KEY_ID secret_access_key = SECRET_ACCESS_KEY use_multipart_uploads = false ``` Note that setting `use_multipart_uploads = false` is to work around [a bug](https://rclone.org/commands/rclone_serve_s3/#bugs) which will be fixed in due course. ### Scaleway [Scaleway](https://www.scaleway.com/object-storage/) The Object Storage platform allows you to store anything from backups, logs and web assets to documents and photos. Files can be dropped from the Scaleway console or transferred through our API and CLI or using any S3-compatible tool. Scaleway provides an S3 interface which can be configured for use with rclone like this: ``` [scaleway] type = s3 provider = Scaleway env_auth = false endpoint = s3.nl-ams.scw.cloud access_key_id = SCWXXXXXXXXXXXXXX secret_access_key = 1111111-2222-3333-44444-55555555555555 region = nl-ams location_constraint = nl-ams acl = private upload_cutoff = 5M chunk_size = 5M copy_cutoff = 5M ``` [Scaleway Glacier](https://www.scaleway.com/en/glacier-cold-storage/) is the low-cost S3 Glacier alternative from Scaleway and it works the same way as on S3 by accepting the "GLACIER" `storage_class`. So you can configure your remote with the `storage_class = GLACIER` option to upload directly to Scaleway Glacier. Don't forget that in this state you can't read files back after, you will need to restore them to "STANDARD" storage_class first before being able to read them (see "restore" section above) ### Seagate Lyve Cloud {#lyve} [Seagate Lyve Cloud](https://www.seagate.com/gb/en/services/cloud/storage/) is an S3 compatible object storage platform from [Seagate](https://seagate.com/) intended for enterprise use. Here is a config run through for a remote called `remote` - you may choose a different name of course. Note that to create an access key and secret key you will need to create a service account first. ``` $ rclone config No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote ``` Choose `s3` backend ``` Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) [snip] Storage> s3 ``` Choose `LyveCloud` as S3 provider ``` Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / Seagate Lyve Cloud \ (LyveCloud) [snip] provider> LyveCloud ``` Take the default (just press enter) to enter access key and secret in the config file. ``` Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> ``` ``` AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> XXX ``` ``` AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> YYY ``` Leave region blank ``` Region to connect to. Leave blank if you are using an S3 clone and you don't have a region. Choose a number from below, or type in your own value. Press Enter to leave empty. / Use this if unsure. 1 | Will use v4 signatures and an empty region. \ () / Use this only if v4 signatures don't work. 2 | E.g. pre Jewel/v10 CEPH. \ (other-v2-signature) region> ``` Enter your Lyve Cloud endpoint. This field cannot be kept empty. ``` Endpoint for Lyve Cloud S3 API. Required when using an S3 clone. Please type in your LyveCloud endpoint. Examples: - s3.us-west-1.{account_name}.lyve.seagate.com (US West 1 - California) - s3.eu-west-1.{account_name}.lyve.seagate.com (US West 1 - Ireland) Enter a value. endpoint> s3.us-west-1.global.lyve.seagate.com ``` Leave location constraint blank ``` Location constraint - must be set to match the Region. Leave blank if not sure. Used when creating buckets only. Enter a value. Press Enter to leave empty. location_constraint> ``` Choose default ACL (`private`). ``` Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) [snip] acl> ``` And the config file should end up looking like this: ``` [remote] type = s3 provider = LyveCloud access_key_id = XXX secret_access_key = YYY endpoint = s3.us-east-1.lyvecloud.seagate.com ``` ### SeaweedFS [SeaweedFS](https://github.com/chrislusf/seaweedfs/) is a distributed storage system for blobs, objects, files, and data lake, with O(1) disk seek and a scalable file metadata store. It has an S3 compatible object storage interface. SeaweedFS can also act as a [gateway to remote S3 compatible object store](https://github.com/chrislusf/seaweedfs/wiki/Gateway-to-Remote-Object-Storage) to cache data and metadata with asynchronous write back, for fast local speed and minimize access cost. Assuming the SeaweedFS are configured with `weed shell` as such: ``` > s3.bucket.create -name foo > s3.configure -access_key=any -secret_key=any -buckets=foo -user=me -actions=Read,Write,List,Tagging,Admin -apply { "identities": [ { "name": "me", "credentials": [ { "accessKey": "any", "secretKey": "any" } ], "actions": [ "Read:foo", "Write:foo", "List:foo", "Tagging:foo", "Admin:foo" ] } ] } ``` To use rclone with SeaweedFS, above configuration should end up with something like this in your config: ``` [seaweedfs_s3] type = s3 provider = SeaweedFS access_key_id = any secret_access_key = any endpoint = localhost:8333 ``` So once set up, for example to copy files into a bucket ``` rclone copy /path/to/files seaweedfs_s3:foo ``` ### Selectel [Selectel Cloud Storage](https://selectel.ru/services/cloud/storage/) is an S3 compatible storage system which features triple redundancy storage, automatic scaling, high availability and a comprehensive IAM system. Selectel have a section on their website for [configuring rclone](https://docs.selectel.ru/en/cloud/object-storage/tools/rclone/) which shows how to make the right API keys. From rclone v1.69 Selectel is a supported operator - please choose the `Selectel` provider type. Note that you should use "vHosted" access for the buckets (which is the recommended default), not "path style". You can use `rclone config` to make a new provider like this ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> selectel Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including ..., Selectel, ... \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / Selectel Object Storage \ (Selectel) [snip] provider> Selectel Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> ACCESS_KEY Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> SECRET_ACCESS_KEY Option region. Region where your data stored. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / St. Petersburg \ (ru-1) region> 1 Option endpoint. Endpoint for Selectel Object Storage. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Saint Petersburg \ (s3.ru-1.storage.selcloud.ru) endpoint> 1 Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: s3 - provider: Selectel - access_key_id: ACCESS_KEY - secret_access_key: SECRET_ACCESS_KEY - region: ru-1 - endpoint: s3.ru-1.storage.selcloud.ru Keep this "selectel" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` And your config should end up looking like this: ``` [selectel] type = s3 provider = Selectel access_key_id = ACCESS_KEY secret_access_key = SECRET_ACCESS_KEY region = ru-1 endpoint = s3.ru-1.storage.selcloud.ru ``` ### Storj Storj is a decentralized cloud storage which can be used through its native protocol or an S3 compatible gateway. The S3 compatible gateway is configured using `rclone config` with a type of `s3` and with a provider name of `Storj`. Here is an example run of the configurator. ``` Type of storage to configure. Storage> s3 Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> XXXX (as shown when creating the access grant) Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> XXXX (as shown when creating the access grant) Option endpoint. Endpoint of the Shared Gateway. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / EU1 Shared Gateway \ (gateway.eu1.storjshare.io) 2 / US1 Shared Gateway \ (gateway.us1.storjshare.io) 3 / Asia-Pacific Shared Gateway \ (gateway.ap1.storjshare.io) endpoint> 1 (as shown when creating the access grant) Edit advanced config? y) Yes n) No (default) y/n> n ``` Note that s3 credentials are generated when you [create an access grant](https://docs.storj.io/dcs/api-reference/s3-compatible-gateway#usage). #### Backend quirks - `--chunk-size` is forced to be 64 MiB or greater. This will use more memory than the default of 5 MiB. - Server side copy is disabled as it isn't currently supported in the gateway. - GetTier and SetTier are not supported. #### Backend bugs Due to [issue #39](https://github.com/storj/gateway-mt/issues/39) uploading multipart files via the S3 gateway causes them to lose their metadata. For rclone's purpose this means that the modification time is not stored, nor is any MD5SUM (if one is available from the source). This has the following consequences: - Using `rclone rcat` will fail as the metadata doesn't match after upload - Uploading files with `rclone mount` will fail for the same reason - This can worked around by using `--vfs-cache-mode writes` or `--vfs-cache-mode full` or setting `--s3-upload-cutoff` large - Files uploaded via a multipart upload won't have their modtimes - This will mean that `rclone sync` will likely keep trying to upload files bigger than `--s3-upload-cutoff` - This can be worked around with `--checksum` or `--size-only` or setting `--s3-upload-cutoff` large - The maximum value for `--s3-upload-cutoff` is 5GiB though One general purpose workaround is to set `--s3-upload-cutoff 5G`. This means that rclone will upload files smaller than 5GiB as single parts. Note that this can be set in the config file with `upload_cutoff = 5G` or configured in the advanced settings. If you regularly transfer files larger than 5G then using `--checksum` or `--size-only` in `rclone sync` is the recommended workaround. #### Comparison with the native protocol Use the [the native protocol](/storj) to take advantage of client-side encryption as well as to achieve the best possible download performance. Uploads will be erasure-coded locally, thus a 1gb upload will result in 2.68gb of data being uploaded to storage nodes across the network. Use this backend and the S3 compatible Hosted Gateway to increase upload performance and reduce the load on your systems and network. Uploads will be encrypted and erasure-coded server-side, thus a 1GB upload will result in only in 1GB of data being uploaded to storage nodes across the network. For more detailed comparison please check the documentation of the [storj](/storj) backend. ### Synology C2 Object Storage {#synology-c2} [Synology C2 Object Storage](https://c2.synology.com/en-global/object-storage/overview) provides a secure, S3-compatible, and cost-effective cloud storage solution without API request, download fees, and deletion penalty. The S3 compatible gateway is configured using `rclone config` with a type of `s3` and with a provider name of `Synology`. Here is an example run of the configurator. First run: ``` rclone config ``` This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote.1 name> syno Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value XX / Amazon S3 Compliant Storage Providers including AWS, ... \ "s3" Storage> s3 Choose your S3 provider. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 24 / Synology C2 Object Storage \ (Synology) provider> Synology Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Enter a boolean value (true or false). Press Enter for the default ("false"). Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). access_key_id> accesskeyid AWS Secret Access Key (password) Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). secret_access_key> secretaccesskey Region where your data stored. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Europe Region 1 \ (eu-001) 2 / Europe Region 2 \ (eu-002) 3 / US Region 1 \ (us-001) 4 / US Region 2 \ (us-002) 5 / Asia (Taiwan) \ (tw-001) region > 1 Option endpoint. Endpoint for Synology C2 Object Storage API. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / EU Endpoint 1 \ (eu-001.s3.synologyc2.net) 2 / US Endpoint 1 \ (us-001.s3.synologyc2.net) 3 / TW Endpoint 1 \ (tw-001.s3.synologyc2.net) endpoint> 1 Option location_constraint. Location constraint - must be set to match the Region. Leave blank if not sure. Used when creating buckets only. Enter a value. Press Enter to leave empty. location_constraint> Edit advanced config? (y/n) y) Yes n) No y/n> y Option no_check_bucket. If set, don't attempt to check the bucket exists or create it. This can be useful when trying to minimise the number of transactions rclone does if you know the bucket exists already. It can also be needed if the user you are using does not have bucket creation permissions. Before v1.52.0 this would have passed silently due to a bug. Enter a boolean value (true or false). Press Enter for the default (true). no_check_bucket> true Configuration complete. Options: - type: s3 - provider: Synology - region: eu-001 - endpoint: eu-001.s3.synologyc2.net - no_check_bucket: true Keep this "syno" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ### Tencent COS {#tencent-cos} [Tencent Cloud Object Storage (COS)](https://intl.cloud.tencent.com/product/cos) is a distributed storage service offered by Tencent Cloud for unstructured data. It is secure, stable, massive, convenient, low-delay and low-cost. To configure access to Tencent COS, follow the steps below: 1. Run `rclone config` and select `n` for a new remote. ``` rclone config No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n ``` 2. Give the name of the configuration. For example, name it 'cos'. ``` name> cos ``` 3. Select `s3` storage. ``` Choose a number from below, or type in your own value [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ "s3" [snip] Storage> s3 ``` 4. Select `TencentCOS` provider. ``` Choose a number from below, or type in your own value 1 / Amazon Web Services (AWS) S3 \ "AWS" [snip] 11 / Tencent Cloud Object Storage (COS) \ "TencentCOS" [snip] provider> TencentCOS ``` 5. Enter your SecretId and SecretKey of Tencent Cloud. ``` Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Enter a boolean value (true or false). Press Enter for the default ("false"). Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). access_key_id> AKIDxxxxxxxxxx AWS Secret Access Key (password) Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). secret_access_key> xxxxxxxxxxx ``` 6. Select endpoint for Tencent COS. This is the standard endpoint for different region. ``` 1 / Beijing Region. \ "cos.ap-beijing.myqcloud.com" 2 / Nanjing Region. \ "cos.ap-nanjing.myqcloud.com" 3 / Shanghai Region. \ "cos.ap-shanghai.myqcloud.com" 4 / Guangzhou Region. \ "cos.ap-guangzhou.myqcloud.com" [snip] endpoint> 4 ``` 7. Choose acl and storage class. ``` Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Owner gets Full_CONTROL. No one else has access rights (default). \ "default" [snip] acl> 1 The storage class to use when storing new objects in Tencent COS. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Default \ "" [snip] storage_class> 1 Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config -------------------- [cos] type = s3 provider = TencentCOS env_auth = false access_key_id = xxx secret_access_key = xxx endpoint = cos.ap-guangzhou.myqcloud.com acl = default -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== cos s3 ``` ### Wasabi [Wasabi](https://wasabi.com) is a cloud-based object storage service for a broad range of applications and use cases. Wasabi is designed for individuals and organizations that require a high-performance, reliable, and secure data storage infrastructure at minimal cost. Wasabi provides an S3 interface which can be configured for use with rclone like this. ``` No remotes found, make a new one? n) New remote s) Set configuration password n/s> n name> wasabi Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Amazon S3 (also Dreamhost, Ceph, ChinaMobile, ArvanCloud, Minio, Liara) \ "s3" [snip] Storage> s3 Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID - leave blank for anonymous access or runtime credentials. access_key_id> YOURACCESSKEY AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials. secret_access_key> YOURSECRETACCESSKEY Region to connect to. Choose a number from below, or type in your own value / The default endpoint - a good choice if you are unsure. 1 | US Region, Northern Virginia, or Pacific Northwest. | Leave location constraint empty. \ "us-east-1" [snip] region> us-east-1 Endpoint for S3 API. Leave blank if using AWS to use the default endpoint for the region. Specify if using an S3 clone such as Ceph. endpoint> s3.wasabisys.com Location constraint - must be set to match the Region. Used when creating buckets only. Choose a number from below, or type in your own value 1 / Empty for US Region, Northern Virginia, or Pacific Northwest. \ "" [snip] location_constraint> Canned ACL used when creating buckets and/or storing objects in S3. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Choose a number from below, or type in your own value 1 / Owner gets FULL_CONTROL. No one else has access rights (default). \ "private" [snip] acl> The server-side encryption algorithm used when storing this object in S3. Choose a number from below, or type in your own value 1 / None \ "" 2 / AES256 \ "AES256" server_side_encryption> The storage class to use when storing objects in S3. Choose a number from below, or type in your own value 1 / Default \ "" 2 / Standard storage class \ "STANDARD" 3 / Reduced redundancy storage class \ "REDUCED_REDUNDANCY" 4 / Standard Infrequent Access storage class \ "STANDARD_IA" storage_class> Remote config -------------------- [wasabi] env_auth = false access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY region = us-east-1 endpoint = s3.wasabisys.com location_constraint = acl = server_side_encryption = storage_class = -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` This will leave the config file looking like this. ``` [wasabi] type = s3 provider = Wasabi env_auth = false access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY region = endpoint = s3.wasabisys.com location_constraint = acl = server_side_encryption = storage_class = ``` ### Zata Object Storage {#Zata} [Zata Object Storage](https://zata.ai/) provides a secure, S3-compatible cloud storage solution designed for scalability and performance, ideal for a variety of data storage needs. First run: ``` rclone config ``` ``` This will guide you through an interactive setup process: e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> n Enter name for new remote. name> my zata storage Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. XX / Zata (S3 compatible Gateway) \ (Zata) provider> Zata Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> "your key" Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> "your secret key" Option region. Region where you can connect with. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Indore, Madhya Pradesh, India \ (us-east-1) region> 1 Option endpoint. Endpoint for Zata Object Storage. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / South Asia Endpoint \ (idr01.zata.ai) endpoint> 1 Option location_constraint. Location constraint - must be set to match the Region. Leave blank if not sure. Used when creating buckets only. Enter a value. Press Enter to leave empty. location_constraint> Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) / Owner gets FULL_CONTROL. 3 | The AllUsers group gets READ and WRITE access. | Granting this on a bucket is generally not recommended. \ (public-read-write) / Owner gets FULL_CONTROL. 4 | The AuthenticatedUsers group gets READ access. \ (authenticated-read) / Object owner gets FULL_CONTROL. 5 | Bucket owner gets READ access. | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-read) / Both the object owner and the bucket owner get FULL_CONTROL over the object. 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-full-control) acl> Edit advanced config? y) Yes n) No (default) y/n> Configuration complete. Options: - type: s3 - provider: Zata - access_key_id: xxx - secret_access_key: xxx - region: us-east-1 - endpoint: idr01.zata.ai Keep this "my zata storage" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> ``` This will leave the config file looking like this. ``` [my zata storage] type = s3 provider = Zata access_key_id = xxx secret_access_key = xxx region = us-east-1 endpoint = idr01.zata.ai ``` ## Memory usage {#memory} The most common cause of rclone using lots of memory is a single directory with millions of files in. Despite s3 not really having the concepts of directories, rclone does the sync on a directory by directory basis to be compatible with normal filing systems. Rclone loads each directory into memory as rclone objects. Each rclone object takes 0.5k-1k of memory, so approximately 1GB per 1,000,000 files, and the sync for that directory does not begin until it is entirely loaded in memory. So the sync can take a long time to start for large directories. To sync a directory with 100,000,000 files in you would need approximately 100 GB of memory. At some point the amount of memory becomes difficult to provide so there is [a workaround for this](https://github.com/rclone/rclone/wiki/Big-syncs-with-millions-of-files) which involves a bit of scripting. At some point rclone will gain a sync mode which is effectively this workaround but built in to rclone. ## Limitations `rclone about` is not supported by the S3 backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) # Backblaze B2 B2 is [Backblaze's cloud storage system](https://www.backblaze.com/cloud-storage). Paths are specified as `remote:bucket` (or `remote:` for the `lsd` command.) You may put subdirectories in too, e.g. `remote:bucket/path/to/dir`. ## Configuration Here is an example of making a b2 configuration. First run rclone config This will guide you through an interactive setup process. To authenticate you will either need your Account ID (a short hex number) and Master Application Key (a long hex number) OR an Application Key, which is the recommended method. See below for further details on generating and using an Application Key. ``` No remotes found, make a new one? n) New remote q) Quit config n/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Backblaze B2 \ "b2" [snip] Storage> b2 Account ID or Application Key ID account> 123456789abc Application Key key> 0123456789abcdef0123456789abcdef0123456789 Endpoint for the service - leave blank normally. endpoint> Remote config Configuration complete. Options: - type: b2 - account: 123456789abc - key: 0123456789abcdef0123456789abcdef0123456789 - endpoint: Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` This remote is called `remote` and can now be used like this See all buckets rclone lsd remote: Create a new bucket rclone mkdir remote:bucket List the contents of a bucket rclone ls remote:bucket Sync `/home/local/directory` to the remote bucket, deleting any excess files in the bucket. rclone sync --interactive /home/local/directory remote:bucket ### Application Keys B2 supports multiple [Application Keys for different access permission to B2 Buckets](https://www.backblaze.com/docs/cloud-storage-application-keys). You can use these with rclone too; you will need to use rclone version 1.43 or later. Follow Backblaze's docs to create an Application Key with the required permission and add the `applicationKeyId` as the `account` and the `Application Key` itself as the `key`. Note that you must put the _applicationKeyId_ as the `account` – you can't use the master Account ID. If you try then B2 will return 401 errors. ### --fast-list This remote supports `--fast-list` which allows you to use fewer transactions in exchange for more memory. See the [rclone docs](https://rclone.org/docs/#fast-list) for more details. ### Modification times The modification time is stored as metadata on the object as `X-Bz-Info-src_last_modified_millis` as milliseconds since 1970-01-01 in the Backblaze standard. Other tools should be able to use this as a modified time. Modified times are used in syncing and are fully supported. Note that if a modification time needs to be updated on an object then it will create a new version of the object. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | \ | 0x5C | ＼ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. Note that in 2020-05 Backblaze started allowing \ characters in file names. Rclone hasn't changed its encoding as this could cause syncs to re-transfer files. If you want rclone not to replace \ then see the `--b2-encoding` flag below and remove the `BackSlash` from the string. This can be set in the config. ### SHA1 checksums The SHA1 checksums of the files are checked on upload and download and will be used in the syncing process. Large files (bigger than the limit in `--b2-upload-cutoff`) which are uploaded in chunks will store their SHA1 on the object as `X-Bz-Info-large_file_sha1` as recommended by Backblaze. For a large file to be uploaded with an SHA1 checksum, the source needs to support SHA1 checksums. The local disk supports SHA1 checksums so large file transfers from local disk will have an SHA1. See [the overview](https://rclone.org/overview/#features) for exactly which remotes support SHA1. Sources which don't support SHA1, in particular `crypt` will upload large files without SHA1 checksums. This may be fixed in the future (see [#1767](https://github.com/rclone/rclone/issues/1767)). Files sizes below `--b2-upload-cutoff` will always have an SHA1 regardless of the source. ### Transfers Backblaze recommends that you do lots of transfers simultaneously for maximum speed. In tests from my SSD equipped laptop the optimum setting is about `--transfers 32` though higher numbers may be used for a slight speed improvement. The optimum number for you may vary depending on your hardware, how big the files are, how much you want to load your computer, etc. The default of `--transfers 4` is definitely too low for Backblaze B2 though. Note that uploading big files (bigger than 200 MiB by default) will use a 96 MiB RAM buffer by default. There can be at most `--transfers` of these in use at any moment, so this sets the upper limit on the memory used. ### Versions The default setting of B2 is to keep old versions of files. This means when rclone uploads a new version of a file it creates a [new version of it](https://www.backblaze.com/docs/cloud-storage-file-versions). Likewise when you delete a file, the old version will be marked hidden and still be available. Whether B2 keeps old versions of files or not can be adjusted on a per bucket basis using the "Lifecycle settings" on the B2 control panel or when creating the bucket using the [--b2-lifecycle](#b2-lifecycle) flag or after creation using the [rclone backend lifecycle](#lifecycle) command. You may opt in to a "hard delete" of files with the `--b2-hard-delete` flag which permanently removes files on deletion instead of hiding them. Old versions of files, where available, are visible using the `--b2-versions` flag. It is also possible to view a bucket as it was at a certain point in time, using the `--b2-version-at` flag. This will show the file versions as they were at that time, showing files that have been deleted afterwards, and hiding files that were created since. If you wish to remove all the old versions, and unfinished large file uploads, then you can use the `rclone cleanup remote:bucket` command which will delete all the old versions of files, leaving the current ones intact. You can also supply a path and only old versions under that path will be deleted, e.g. `rclone cleanup remote:bucket/path/to/stuff`. Note that `cleanup` will remove partially uploaded files from the bucket if they are more than a day old. If you want more control over the expiry date then run `rclone backend cleanup b2:bucket -o max-age=1h` to remove all unfinished large file uploads older than one hour, leaving old versions intact. If you wish to remove all the old versions, leaving current files and unfinished large files intact, then you can use the [`rclone backend cleanup-hidden remote:bucket`](#cleanup-hidden) command. You can also supply a path and only old versions under that path will be deleted, e.g. `rclone backend cleanup-hidden remote:bucket/path/to/stuff`. When you `purge` a bucket, the current and the old versions will be deleted then the bucket will be deleted. However `delete` will cause the current versions of the files to become hidden old versions. Here is a session showing the listing and retrieval of an old version followed by a `cleanup` of the old versions. Show current version and all the versions with `--b2-versions` flag. ``` $ rclone -q ls b2:cleanup-test 9 one.txt $ rclone -q --b2-versions ls b2:cleanup-test 9 one.txt 8 one-v2016-07-04-141032-000.txt 16 one-v2016-07-04-141003-000.txt 15 one-v2016-07-02-155621-000.txt ``` Retrieve an old version ``` $ rclone -q --b2-versions copy b2:cleanup-test/one-v2016-07-04-141003-000.txt /tmp $ ls -l /tmp/one-v2016-07-04-141003-000.txt -rw-rw-r-- 1 ncw ncw 16 Jul 2 17:46 /tmp/one-v2016-07-04-141003-000.txt ``` Clean up all the old versions and show that they've gone. ``` $ rclone -q cleanup b2:cleanup-test $ rclone -q ls b2:cleanup-test 9 one.txt $ rclone -q --b2-versions ls b2:cleanup-test 9 one.txt ``` #### Versions naming caveat When using `--b2-versions` flag rclone is relying on the file name to work out whether the objects are versions or not. Versions' names are created by inserting timestamp between file name and its extension. ``` 9 file.txt 8 file-v2023-07-17-161032-000.txt 16 file-v2023-06-15-141003-000.txt ``` If there are real files present with the same names as versions, then behaviour of `--b2-versions` can be unpredictable. ### Data usage It is useful to know how many requests are sent to the server in different scenarios. All copy commands send the following 4 requests: ``` /b2api/v1/b2_authorize_account /b2api/v1/b2_create_bucket /b2api/v1/b2_list_buckets /b2api/v1/b2_list_file_names ``` The `b2_list_file_names` request will be sent once for every 1k files in the remote path, providing the checksum and modification time of the listed files. As of version 1.33 issue [#818](https://github.com/rclone/rclone/issues/818) causes extra requests to be sent when using B2 with Crypt. When a copy operation does not require any files to be uploaded, no more requests will be sent. Uploading files that do not require chunking, will send 2 requests per file upload: ``` /b2api/v1/b2_get_upload_url /b2api/v1/b2_upload_file/ ``` Uploading files requiring chunking, will send 2 requests (one each to start and finish the upload) and another 2 requests for each chunk: ``` /b2api/v1/b2_start_large_file /b2api/v1/b2_get_upload_part_url /b2api/v1/b2_upload_part/ /b2api/v1/b2_finish_large_file ``` #### Versions Versions can be viewed with the `--b2-versions` flag. When it is set rclone will show and act on older versions of files. For example Listing without `--b2-versions` ``` $ rclone -q ls b2:cleanup-test 9 one.txt ``` And with ``` $ rclone -q --b2-versions ls b2:cleanup-test 9 one.txt 8 one-v2016-07-04-141032-000.txt 16 one-v2016-07-04-141003-000.txt 15 one-v2016-07-02-155621-000.txt ``` Showing that the current version is unchanged but older versions can be seen. These have the UTC date that they were uploaded to the server to the nearest millisecond appended to them. Note that when using `--b2-versions` no file write operations are permitted, so you can't upload files or delete them. ### B2 and rclone link Rclone supports generating file share links for private B2 buckets. They can either be for a file for example: ``` ./rclone link B2:bucket/path/to/file.txt https://f002.backblazeb2.com/file/bucket/path/to/file.txt?Authorization=xxxxxxxx ``` or if run on a directory you will get: ``` ./rclone link B2:bucket/path https://f002.backblazeb2.com/file/bucket/path?Authorization=xxxxxxxx ``` you can then use the authorization token (the part of the url from the `?Authorization=` on) on any file path under that directory. For example: ``` https://f002.backblazeb2.com/file/bucket/path/to/file1?Authorization=xxxxxxxx https://f002.backblazeb2.com/file/bucket/path/file2?Authorization=xxxxxxxx https://f002.backblazeb2.com/file/bucket/path/folder/file3?Authorization=xxxxxxxx ``` ### Standard options Here are the Standard options specific to b2 (Backblaze B2). #### --b2-account Account ID or Application Key ID. Properties: - Config: account - Env Var: RCLONE_B2_ACCOUNT - Type: string - Required: true #### --b2-key Application Key. Properties: - Config: key - Env Var: RCLONE_B2_KEY - Type: string - Required: true #### --b2-hard-delete Permanently delete files on remote removal, otherwise hide files. Properties: - Config: hard_delete - Env Var: RCLONE_B2_HARD_DELETE - Type: bool - Default: false ### Advanced options Here are the Advanced options specific to b2 (Backblaze B2). #### --b2-endpoint Endpoint for the service. Leave blank normally. Properties: - Config: endpoint - Env Var: RCLONE_B2_ENDPOINT - Type: string - Required: false #### --b2-test-mode A flag string for X-Bz-Test-Mode header for debugging. This is for debugging purposes only. Setting it to one of the strings below will cause b2 to return specific errors: * "fail_some_uploads" * "expire_some_account_authorization_tokens" * "force_cap_exceeded" These will be set in the "X-Bz-Test-Mode" header which is documented in the [b2 integrations checklist](https://www.backblaze.com/docs/cloud-storage-integration-checklist). Properties: - Config: test_mode - Env Var: RCLONE_B2_TEST_MODE - Type: string - Required: false #### --b2-versions Include old versions in directory listings. Note that when using this no file write operations are permitted, so you can't upload files or delete them. Properties: - Config: versions - Env Var: RCLONE_B2_VERSIONS - Type: bool - Default: false #### --b2-version-at Show file versions as they were at the specified time. Note that when using this no file write operations are permitted, so you can't upload files or delete them. Properties: - Config: version_at - Env Var: RCLONE_B2_VERSION_AT - Type: Time - Default: off #### --b2-upload-cutoff Cutoff for switching to chunked upload. Files above this size will be uploaded in chunks of "--b2-chunk-size". This value should be set no larger than 4.657 GiB (== 5 GB). Properties: - Config: upload_cutoff - Env Var: RCLONE_B2_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 200Mi #### --b2-copy-cutoff Cutoff for switching to multipart copy. Any files larger than this that need to be server-side copied will be copied in chunks of this size. The minimum is 0 and the maximum is 4.6 GiB. Properties: - Config: copy_cutoff - Env Var: RCLONE_B2_COPY_CUTOFF - Type: SizeSuffix - Default: 4Gi #### --b2-chunk-size Upload chunk size. When uploading large files, chunk the file into this size. Must fit in memory. These chunks are buffered in memory and there might a maximum of "--transfers" chunks in progress at once. 5,000,000 Bytes is the minimum size. Properties: - Config: chunk_size - Env Var: RCLONE_B2_CHUNK_SIZE - Type: SizeSuffix - Default: 96Mi #### --b2-upload-concurrency Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently. Note that chunks are stored in memory and there may be up to "--transfers" * "--b2-upload-concurrency" chunks stored at once in memory. Properties: - Config: upload_concurrency - Env Var: RCLONE_B2_UPLOAD_CONCURRENCY - Type: int - Default: 4 #### --b2-disable-checksum Disable checksums for large (> upload cutoff) files. Normally rclone will calculate the SHA1 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading. Properties: - Config: disable_checksum - Env Var: RCLONE_B2_DISABLE_CHECKSUM - Type: bool - Default: false #### --b2-download-url Custom endpoint for downloads. This is usually set to a Cloudflare CDN URL as Backblaze offers free egress for data downloaded through the Cloudflare network. Rclone works with private buckets by sending an "Authorization" header. If the custom endpoint rewrites the requests for authentication, e.g., in Cloudflare Workers, this header needs to be handled properly. Leave blank if you want to use the endpoint provided by Backblaze. The URL provided here SHOULD have the protocol and SHOULD NOT have a trailing slash or specify the /file/bucket subpath as rclone will request files with "{download_url}/file/{bucket_name}/{path}". Example: > https://mysubdomain.mydomain.tld (No trailing "/", "file" or "bucket") Properties: - Config: download_url - Env Var: RCLONE_B2_DOWNLOAD_URL - Type: string - Required: false #### --b2-download-auth-duration Time before the public link authorization token will expire in s or suffix ms|s|m|h|d. This is used in combination with "rclone link" for making files accessible to the public and sets the duration before the download authorization token will expire. The minimum value is 1 second. The maximum value is one week. Properties: - Config: download_auth_duration - Env Var: RCLONE_B2_DOWNLOAD_AUTH_DURATION - Type: Duration - Default: 1w #### --b2-memory-pool-flush-time How often internal memory buffer pools will be flushed. (no longer used) Properties: - Config: memory_pool_flush_time - Env Var: RCLONE_B2_MEMORY_POOL_FLUSH_TIME - Type: Duration - Default: 1m0s #### --b2-memory-pool-use-mmap Whether to use mmap buffers in internal memory pool. (no longer used) Properties: - Config: memory_pool_use_mmap - Env Var: RCLONE_B2_MEMORY_POOL_USE_MMAP - Type: bool - Default: false #### --b2-lifecycle Set the number of days deleted files should be kept when creating a bucket. On bucket creation, this parameter is used to create a lifecycle rule for the entire bucket. If lifecycle is 0 (the default) it does not create a lifecycle rule so the default B2 behaviour applies. This is to create versions of files on delete and overwrite and to keep them indefinitely. If lifecycle is >0 then it creates a single rule setting the number of days before a file that is deleted or overwritten is deleted permanently. This is known as daysFromHidingToDeleting in the b2 docs. The minimum value for this parameter is 1 day. You can also enable hard_delete in the config also which will mean deletions won't cause versions but overwrites will still cause versions to be made. See: [rclone backend lifecycle](#lifecycle) for setting lifecycles after bucket creation. Properties: - Config: lifecycle - Env Var: RCLONE_B2_LIFECYCLE - Type: int - Default: 0 #### --b2-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_B2_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot #### --b2-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_B2_DESCRIPTION - Type: string - Required: false ## Backend commands Here are the commands specific to the b2 backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the [backend](https://rclone.org/commands/rclone_backend/) command for more info on how to pass options and arguments. These can be run on a running backend using the rc command [backend/command](https://rclone.org/rc/#backend-command). ### lifecycle Read or set the lifecycle for a bucket rclone backend lifecycle remote: [options] [+] This command can be used to read or set the lifecycle for a bucket. Usage Examples: To show the current lifecycle rules: rclone backend lifecycle b2:bucket This will dump something like this showing the lifecycle rules. [ { "daysFromHidingToDeleting": 1, "daysFromUploadingToHiding": null, "daysFromStartingToCancelingUnfinishedLargeFiles": null, "fileNamePrefix": "" } ] If there are no lifecycle rules (the default) then it will just return []. To reset the current lifecycle rules: rclone backend lifecycle b2:bucket -o daysFromHidingToDeleting=30 rclone backend lifecycle b2:bucket -o daysFromUploadingToHiding=5 -o daysFromHidingToDeleting=1 This will run and then print the new lifecycle rules as above. Rclone only lets you set lifecycles for the whole bucket with the fileNamePrefix = "". You can't disable versioning with B2. The best you can do is to set the daysFromHidingToDeleting to 1 day. You can enable hard_delete in the config also which will mean deletions won't cause versions but overwrites will still cause versions to be made. rclone backend lifecycle b2:bucket -o daysFromHidingToDeleting=1 See: https://www.backblaze.com/docs/cloud-storage-lifecycle-rules Options: - "daysFromHidingToDeleting": After a file has been hidden for this many days it is deleted. 0 is off. - "daysFromStartingToCancelingUnfinishedLargeFiles": Cancels any unfinished large file versions after this many days - "daysFromUploadingToHiding": This many days after uploading a file is hidden ### cleanup Remove unfinished large file uploads. rclone backend cleanup remote: [options] [+] This command removes unfinished large file uploads of age greater than max-age, which defaults to 24 hours. Note that you can use --interactive/-i or --dry-run with this command to see what it would do. rclone backend cleanup b2:bucket/path/to/object rclone backend cleanup -o max-age=7w b2:bucket/path/to/object Durations are parsed as per the rest of rclone, 2h, 7d, 7w etc. Options: - "max-age": Max age of upload to delete ### cleanup-hidden Remove old versions of files. rclone backend cleanup-hidden remote: [options] [+] This command removes any old hidden versions of files. Note that you can use --interactive/-i or --dry-run with this command to see what it would do. rclone backend cleanup-hidden b2:bucket/path/to/dir ## Limitations `rclone about` is not supported by the B2 backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) # Box Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. The initial setup for Box involves getting a token from Box which you can do either in your browser, or with a config.json downloaded from Box to use JWT authentication. `rclone config` walks you through it. ## Configuration Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Box \ "box" [snip] Storage> box Box App Client Id - leave blank normally. client_id> Box App Client Secret - leave blank normally. client_secret> Box App config.json location Leave blank normally. Enter a string value. Press Enter for the default (""). box_config_file> Box App Primary Access Token Leave blank normally. Enter a string value. Press Enter for the default (""). access_token> Enter a string value. Press Enter for the default ("user"). Choose a number from below, or type in your own value 1 / Rclone should act on behalf of a user \ "user" 2 / Rclone should act on behalf of a service account \ "enterprise" box_sub_type> Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth?state=XXXXXXXXXXXXXXXXXXXXXX Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: box - client_id: - client_secret: - token: {"access_token":"XXX","token_type":"bearer","refresh_token":"XXX","expiry":"XXX"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` See the [remote setup docs](https://rclone.org/remote_setup/) for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Box. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on `http://127.0.0.1:53682/` and this may require you to unblock it temporarily if you are running a host firewall. Once configured you can then use `rclone` like this, List directories in top level of your Box rclone lsd remote: List all the files in your Box rclone ls remote: To copy a local directory to an Box directory called backup rclone copy /home/source remote:backup ### Using rclone with an Enterprise account with SSO If you have an "Enterprise" account type with Box with single sign on (SSO), you need to create a password to use Box with rclone. This can be done at your Enterprise Box account by going to Settings, "Account" Tab, and then set the password in the "Authentication" field. Once you have done this, you can setup your Enterprise Box account using the same procedure detailed above in the, using the password you have just set. ### Invalid refresh token According to the [box docs](https://developer.box.com/v2.0/docs/oauth-20#section-6-using-the-access-and-refresh-tokens): > Each refresh_token is valid for one use in 60 days. This means that if you * Don't use the box remote for 60 days * Copy the config file with a box refresh token in and use it in two places * Get an error on a token refresh then rclone will return an error which includes the text `Invalid refresh token`. To fix this you will need to use oauth2 again to update the refresh token. You can use the methods in [the remote setup docs](https://rclone.org/remote_setup/), bearing in mind that if you use the copy the config file method, you should not use that remote on the computer you did the authentication on. Here is how to do it. ``` $ rclone config Current remotes: Name Type ==== ==== remote box e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> e Choose a number from below, or type in an existing value 1 > remote remote> remote Configuration complete. Options: - type: box - token: {"access_token":"XXX","token_type":"bearer","refresh_token":"XXX","expiry":"2017-07-08T23:40:08.059167677+01:00"} Keep this "remote" remote? Edit remote Value "client_id" = "" Edit? (y/n)> y) Yes n) No y/n> n Value "client_secret" = "" Edit? (y/n)> y) Yes n) No y/n> n Remote config Already have a token - refresh? y) Yes n) No y/n> y Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: box - token: {"access_token":"YYY","token_type":"bearer","refresh_token":"YYY","expiry":"2017-07-23T12:22:29.259137901+01:00"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` ### Modification times and hashes Box allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not. Box supports SHA1 type hashes, so you can use the `--checksum` flag. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | \ | 0x5C | ＼ | File names can also not end with the following characters. These only get replaced if they are the last character in the name: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | SP | 0x20 | ␠ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Transfers For files above 50 MiB rclone will use a chunked transfer. Rclone will upload up to `--transfers` chunks at the same time (shared among all the multipart uploads). Chunks are buffered in memory and are normally 8 MiB so increasing `--transfers` will increase memory use. ### Deleting files Depending on the enterprise settings for your user, the item will either be actually deleted from Box or moved to the trash. Emptying the trash is supported via the rclone however cleanup command however this deletes every trashed file and folder individually so it may take a very long time. Emptying the trash via the WebUI does not have this limitation so it is advised to empty the trash via the WebUI. ### Root folder ID You can set the `root_folder_id` for rclone. This is the directory (identified by its `Folder ID`) that rclone considers to be the root of your Box drive. Normally you will leave this blank and rclone will determine the correct root to use itself. However you can set this to restrict rclone to a specific folder hierarchy. In order to do this you will have to find the `Folder ID` of the directory you wish rclone to display. This will be the last segment of the URL when you open the relevant folder in the Box web interface. So if the folder you want rclone to use has a URL which looks like `https://app.box.com/folder/11xxxxxxxxx8` in the browser, then you use `11xxxxxxxxx8` as the `root_folder_id` in the config. ### Standard options Here are the Standard options specific to box (Box). #### --box-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_BOX_CLIENT_ID - Type: string - Required: false #### --box-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_BOX_CLIENT_SECRET - Type: string - Required: false #### --box-box-config-file Box App config.json location Leave blank normally. Leading `~` will be expanded in the file name as will environment variables such as `${RCLONE_CONFIG_DIR}`. Properties: - Config: box_config_file - Env Var: RCLONE_BOX_BOX_CONFIG_FILE - Type: string - Required: false #### --box-access-token Box App Primary Access Token Leave blank normally. Properties: - Config: access_token - Env Var: RCLONE_BOX_ACCESS_TOKEN - Type: string - Required: false #### --box-box-sub-type Properties: - Config: box_sub_type - Env Var: RCLONE_BOX_BOX_SUB_TYPE - Type: string - Default: "user" - Examples: - "user" - Rclone should act on behalf of a user. - "enterprise" - Rclone should act on behalf of a service account. ### Advanced options Here are the Advanced options specific to box (Box). #### --box-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_BOX_TOKEN - Type: string - Required: false #### --box-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_BOX_AUTH_URL - Type: string - Required: false #### --box-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_BOX_TOKEN_URL - Type: string - Required: false #### --box-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_BOX_CLIENT_CREDENTIALS - Type: bool - Default: false #### --box-root-folder-id Fill in for rclone to use a non root folder as its starting point. Properties: - Config: root_folder_id - Env Var: RCLONE_BOX_ROOT_FOLDER_ID - Type: string - Default: "0" #### --box-upload-cutoff Cutoff for switching to multipart upload (>= 50 MiB). Properties: - Config: upload_cutoff - Env Var: RCLONE_BOX_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 50Mi #### --box-commit-retries Max number of times to try committing a multipart file. Properties: - Config: commit_retries - Env Var: RCLONE_BOX_COMMIT_RETRIES - Type: int - Default: 100 #### --box-list-chunk Size of listing chunk 1-1000. Properties: - Config: list_chunk - Env Var: RCLONE_BOX_LIST_CHUNK - Type: int - Default: 1000 #### --box-owned-by Only show items owned by the login (email address) passed in. Properties: - Config: owned_by - Env Var: RCLONE_BOX_OWNED_BY - Type: string - Required: false #### --box-impersonate Impersonate this user ID when using a service account. Setting this flag allows rclone, when using a JWT service account, to act on behalf of another user by setting the as-user header. The user ID is the Box identifier for a user. User IDs can found for any user via the GET /users endpoint, which is only available to admins, or by calling the GET /users/me endpoint with an authenticated user session. See: https://developer.box.com/guides/authentication/jwt/as-user/ Properties: - Config: impersonate - Env Var: RCLONE_BOX_IMPERSONATE - Type: string - Required: false #### --box-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_BOX_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot #### --box-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_BOX_DESCRIPTION - Type: string - Required: false ## Limitations Note that Box is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". Box file names can't have the `\` character in. rclone maps this to and from an identical looking unicode equivalent `＼` (U+FF3C Fullwidth Reverse Solidus). Box only supports filenames up to 255 characters in length. Box has [API rate limits](https://developer.box.com/guides/api-calls/permissions-and-errors/rate-limits/) that sometimes reduce the speed of rclone. `rclone about` is not supported by the Box backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) ## Get your own Box App ID Here is how to create your own Box App ID for rclone: 1. Go to the [Box Developer Console](https://app.box.com/developers/console) and login, then click `My Apps` on the sidebar. Click `Create New App` and select `Custom App`. 2. In the first screen on the box that pops up, you can pretty much enter whatever you want. The `App Name` can be whatever. For `Purpose` choose automation to avoid having to fill out anything else. Click `Next`. 3. In the second screen of the creation screen, select `User Authentication (OAuth 2.0)`. Then click `Create App`. 4. You should now be on the `Configuration` tab of your new app. If not, click on it at the top of the webpage. Copy down `Client ID` and `Client Secret`, you'll need those for rclone. 5. Under "OAuth 2.0 Redirect URI", add `http://127.0.0.1:53682/` 6. For `Application Scopes`, select `Read all files and folders stored in Box` and `Write all files and folders stored in box` (assuming you want to do both). Leave others unchecked. Click `Save Changes` at the top right. # Cache The `cache` remote wraps another existing remote and stores file structure and its data for long running tasks like `rclone mount`. ## Status The cache backend code is working but it currently doesn't have a maintainer so there are [outstanding bugs](https://github.com/rclone/rclone/issues?q=is%3Aopen+is%3Aissue+label%3Abug+label%3A%22Remote%3A+Cache%22) which aren't getting fixed. The cache backend is due to be phased out in favour of the VFS caching layer eventually which is more tightly integrated into rclone. Until this happens we recommend only using the cache backend if you find you can't work without it. There are many docs online describing the use of the cache backend to minimize API hits and by-and-large these are out of date and the cache backend isn't needed in those scenarios any more. ## Configuration To get started you just need to have an existing remote which can be configured with `cache`. Here is an example of how to make a remote called `test-cache`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config n/r/c/s/q> n name> test-cache Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Cache a remote \ "cache" [snip] Storage> cache Remote to cache. Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended). remote> local:/test Optional: The URL of the Plex server plex_url> http://127.0.0.1:32400 Optional: The username of the Plex user plex_username> dummyusername Optional: The password of the Plex user y) Yes type in my own password g) Generate random password n) No leave this optional password blank y/g/n> y Enter the password: password: Confirm the password: password: The size of a chunk. Lower value good for slow connections but can affect seamless reading. Default: 5M Choose a number from below, or type in your own value 1 / 1 MiB \ "1M" 2 / 5 MiB \ "5M" 3 / 10 MiB \ "10M" chunk_size> 2 How much time should object info (file size, file hashes, etc.) be stored in cache. Use a very high value if you don't plan on changing the source FS from outside the cache. Accepted units are: "s", "m", "h". Default: 5m Choose a number from below, or type in your own value 1 / 1 hour \ "1h" 2 / 24 hours \ "24h" 3 / 24 hours \ "48h" info_age> 2 The maximum size of stored chunks. When the storage grows beyond this size, the oldest chunks will be deleted. Default: 10G Choose a number from below, or type in your own value 1 / 500 MiB \ "500M" 2 / 1 GiB \ "1G" 3 / 10 GiB \ "10G" chunk_total_size> 3 Remote config -------------------- [test-cache] remote = local:/test plex_url = http://127.0.0.1:32400 plex_username = dummyusername plex_password = *** ENCRYPTED *** chunk_size = 5M info_age = 48h chunk_total_size = 10G ``` You can then use it like this, List directories in top level of your drive rclone lsd test-cache: List all the files in your drive rclone ls test-cache: To start a cached mount rclone mount --allow-other test-cache: /var/tmp/test-cache ### Write Features ### ### Offline uploading ### In an effort to make writing through cache more reliable, the backend now supports this feature which can be activated by specifying a `cache-tmp-upload-path`. A files goes through these states when using this feature: 1. An upload is started (usually by copying a file on the cache remote) 2. When the copy to the temporary location is complete the file is part of the cached remote and looks and behaves like any other file (reading included) 3. After `cache-tmp-wait-time` passes and the file is next in line, `rclone move` is used to move the file to the cloud provider 4. Reading the file still works during the upload but most modifications on it will be prohibited 5. Once the move is complete the file is unlocked for modifications as it becomes as any other regular file 6. If the file is being read through `cache` when it's actually deleted from the temporary path then `cache` will simply swap the source to the cloud provider without interrupting the reading (small blip can happen though) Files are uploaded in sequence and only one file is uploaded at a time. Uploads will be stored in a queue and be processed based on the order they were added. The queue and the temporary storage is persistent across restarts but can be cleared on startup with the `--cache-db-purge` flag. ### Write Support ### Writes are supported through `cache`. One caveat is that a mounted cache remote does not add any retry or fallback mechanism to the upload operation. This will depend on the implementation of the wrapped remote. Consider using `Offline uploading` for reliable writes. One special case is covered with `cache-writes` which will cache the file data at the same time as the upload when it is enabled making it available from the cache store immediately once the upload is finished. ### Read Features ### #### Multiple connections #### To counter the high latency between a local PC where rclone is running and cloud providers, the cache remote can split multiple requests to the cloud provider for smaller file chunks and combines them together locally where they can be available almost immediately before the reader usually needs them. This is similar to buffering when media files are played online. Rclone will stay around the current marker but always try its best to stay ahead and prepare the data before. #### Plex Integration #### There is a direct integration with Plex which allows cache to detect during reading if the file is in playback or not. This helps cache to adapt how it queries the cloud provider depending on what is needed for. Scans will have a minimum amount of workers (1) while in a confirmed playback cache will deploy the configured number of workers. This integration opens the doorway to additional performance improvements which will be explored in the near future. **Note:** If Plex options are not configured, `cache` will function with its configured options without adapting any of its settings. How to enable? Run `rclone config` and add all the Plex options (endpoint, username and password) in your remote and it will be automatically enabled. Affected settings: - `cache-workers`: _Configured value_ during confirmed playback or _1_ all the other times ##### Certificate Validation ##### When the Plex server is configured to only accept secure connections, it is possible to use `.plex.direct` URLs to ensure certificate validation succeeds. These URLs are used by Plex internally to connect to the Plex server securely. The format for these URLs is the following: `https://ip-with-dots-replaced.server-hash.plex.direct:32400/` The `ip-with-dots-replaced` part can be any IPv4 address, where the dots have been replaced with dashes, e.g. `127.0.0.1` becomes `127-0-0-1`. To get the `server-hash` part, the easiest way is to visit https://plex.tv/api/resources?includeHttps=1&X-Plex-Token=your-plex-token This page will list all the available Plex servers for your account with at least one `.plex.direct` link for each. Copy one URL and replace the IP address with the desired address. This can be used as the `plex_url` value. ### Known issues ### #### Mount and --dir-cache-time #### --dir-cache-time controls the first layer of directory caching which works at the mount layer. Being an independent caching mechanism from the `cache` backend, it will manage its own entries based on the configured time. To avoid getting in a scenario where dir cache has obsolete data and cache would have the correct one, try to set `--dir-cache-time` to a lower time than `--cache-info-age`. Default values are already configured in this way. #### Windows support - Experimental #### There are a couple of issues with Windows `mount` functionality that still require some investigations. It should be considered as experimental thus far as fixes come in for this OS. Most of the issues seem to be related to the difference between filesystems on Linux flavors and Windows as cache is heavily dependent on them. Any reports or feedback on how cache behaves on this OS is greatly appreciated. - https://github.com/rclone/rclone/issues/1935 - https://github.com/rclone/rclone/issues/1907 - https://github.com/rclone/rclone/issues/1834 #### Risk of throttling #### Future iterations of the cache backend will make use of the pooling functionality of the cloud provider to synchronize and at the same time make writing through it more tolerant to failures. There are a couple of enhancements in track to add these but in the meantime there is a valid concern that the expiring cache listings can lead to cloud provider throttles or bans due to repeated queries on it for very large mounts. Some recommendations: - don't use a very small interval for entry information (`--cache-info-age`) - while writes aren't yet optimised, you can still write through `cache` which gives you the advantage of adding the file in the cache at the same time if configured to do so. Future enhancements: - https://github.com/rclone/rclone/issues/1937 - https://github.com/rclone/rclone/issues/1936 #### cache and crypt #### One common scenario is to keep your data encrypted in the cloud provider using the `crypt` remote. `crypt` uses a similar technique to wrap around an existing remote and handles this translation in a seamless way. There is an issue with wrapping the remotes in this order: **cloud remote** -> **crypt** -> **cache** During testing, I experienced a lot of bans with the remotes in this order. I suspect it might be related to how crypt opens files on the cloud provider which makes it think we're downloading the full file instead of small chunks. Organizing the remotes in this order yields better results: **cloud remote** -> **cache** -> **crypt** #### absolute remote paths #### `cache` can not differentiate between relative and absolute paths for the wrapped remote. Any path given in the `remote` config setting and on the command line will be passed to the wrapped remote as is, but for storing the chunks on disk the path will be made relative by removing any leading `/` character. This behavior is irrelevant for most backend types, but there are backends where a leading `/` changes the effective directory, e.g. in the `sftp` backend paths starting with a `/` are relative to the root of the SSH server and paths without are relative to the user home directory. As a result `sftp:bin` and `sftp:/bin` will share the same cache folder, even if they represent a different directory on the SSH server. ### Cache and Remote Control (--rc) ### Cache supports the new `--rc` mode in rclone and can be remote controlled through the following end points: By default, the listener is disabled if you do not add the flag. ### rc cache/expire Purge a remote from the cache backend. Supports either a directory or a file. It supports both encrypted and unencrypted file names if cache is wrapped by crypt. Params: - **remote** = path to remote **(required)** - **withData** = true/false to delete cached data (chunks) as well _(optional, false by default)_ ### Standard options Here are the Standard options specific to cache (Cache a remote). #### --cache-remote Remote to cache. Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended). Properties: - Config: remote - Env Var: RCLONE_CACHE_REMOTE - Type: string - Required: true #### --cache-plex-url The URL of the Plex server. Properties: - Config: plex_url - Env Var: RCLONE_CACHE_PLEX_URL - Type: string - Required: false #### --cache-plex-username The username of the Plex user. Properties: - Config: plex_username - Env Var: RCLONE_CACHE_PLEX_USERNAME - Type: string - Required: false #### --cache-plex-password The password of the Plex user. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: plex_password - Env Var: RCLONE_CACHE_PLEX_PASSWORD - Type: string - Required: false #### --cache-chunk-size The size of a chunk (partial file data). Use lower numbers for slower connections. If the chunk size is changed, any downloaded chunks will be invalid and cache-chunk-path will need to be cleared or unexpected EOF errors will occur. Properties: - Config: chunk_size - Env Var: RCLONE_CACHE_CHUNK_SIZE - Type: SizeSuffix - Default: 5Mi - Examples: - "1M" - 1 MiB - "5M" - 5 MiB - "10M" - 10 MiB #### --cache-info-age How long to cache file structure information (directory listings, file size, times, etc.). If all write operations are done through the cache then you can safely make this value very large as the cache store will also be updated in real time. Properties: - Config: info_age - Env Var: RCLONE_CACHE_INFO_AGE - Type: Duration - Default: 6h0m0s - Examples: - "1h" - 1 hour - "24h" - 24 hours - "48h" - 48 hours #### --cache-chunk-total-size The total size that the chunks can take up on the local disk. If the cache exceeds this value then it will start to delete the oldest chunks until it goes under this value. Properties: - Config: chunk_total_size - Env Var: RCLONE_CACHE_CHUNK_TOTAL_SIZE - Type: SizeSuffix - Default: 10Gi - Examples: - "500M" - 500 MiB - "1G" - 1 GiB - "10G" - 10 GiB ### Advanced options Here are the Advanced options specific to cache (Cache a remote). #### --cache-plex-token The plex token for authentication - auto set normally. Properties: - Config: plex_token - Env Var: RCLONE_CACHE_PLEX_TOKEN - Type: string - Required: false #### --cache-plex-insecure Skip all certificate verification when connecting to the Plex server. Properties: - Config: plex_insecure - Env Var: RCLONE_CACHE_PLEX_INSECURE - Type: string - Required: false #### --cache-db-path Directory to store file structure metadata DB. The remote name is used as the DB file name. Properties: - Config: db_path - Env Var: RCLONE_CACHE_DB_PATH - Type: string - Default: "$HOME/.cache/rclone/cache-backend" #### --cache-chunk-path Directory to cache chunk files. Path to where partial file data (chunks) are stored locally. The remote name is appended to the final path. This config follows the "--cache-db-path". If you specify a custom location for "--cache-db-path" and don't specify one for "--cache-chunk-path" then "--cache-chunk-path" will use the same path as "--cache-db-path". Properties: - Config: chunk_path - Env Var: RCLONE_CACHE_CHUNK_PATH - Type: string - Default: "$HOME/.cache/rclone/cache-backend" #### --cache-db-purge Clear all the cached data for this remote on start. Properties: - Config: db_purge - Env Var: RCLONE_CACHE_DB_PURGE - Type: bool - Default: false #### --cache-chunk-clean-interval How often should the cache perform cleanups of the chunk storage. The default value should be ok for most people. If you find that the cache goes over "cache-chunk-total-size" too often then try to lower this value to force it to perform cleanups more often. Properties: - Config: chunk_clean_interval - Env Var: RCLONE_CACHE_CHUNK_CLEAN_INTERVAL - Type: Duration - Default: 1m0s #### --cache-read-retries How many times to retry a read from a cache storage. Since reading from a cache stream is independent from downloading file data, readers can get to a point where there's no more data in the cache. Most of the times this can indicate a connectivity issue if cache isn't able to provide file data anymore. For really slow connections, increase this to a point where the stream is able to provide data but your experience will be very stuttering. Properties: - Config: read_retries - Env Var: RCLONE_CACHE_READ_RETRIES - Type: int - Default: 10 #### --cache-workers How many workers should run in parallel to download chunks. Higher values will mean more parallel processing (better CPU needed) and more concurrent requests on the cloud provider. This impacts several aspects like the cloud provider API limits, more stress on the hardware that rclone runs on but it also means that streams will be more fluid and data will be available much more faster to readers. **Note**: If the optional Plex integration is enabled then this setting will adapt to the type of reading performed and the value specified here will be used as a maximum number of workers to use. Properties: - Config: workers - Env Var: RCLONE_CACHE_WORKERS - Type: int - Default: 4 #### --cache-chunk-no-memory Disable the in-memory cache for storing chunks during streaming. By default, cache will keep file data during streaming in RAM as well to provide it to readers as fast as possible. This transient data is evicted as soon as it is read and the number of chunks stored doesn't exceed the number of workers. However, depending on other settings like "cache-chunk-size" and "cache-workers" this footprint can increase if there are parallel streams too (multiple files being read at the same time). If the hardware permits it, use this feature to provide an overall better performance during streaming but it can also be disabled if RAM is not available on the local machine. Properties: - Config: chunk_no_memory - Env Var: RCLONE_CACHE_CHUNK_NO_MEMORY - Type: bool - Default: false #### --cache-rps Limits the number of requests per second to the source FS (-1 to disable). This setting places a hard limit on the number of requests per second that cache will be doing to the cloud provider remote and try to respect that value by setting waits between reads. If you find that you're getting banned or limited on the cloud provider through cache and know that a smaller number of requests per second will allow you to work with it then you can use this setting for that. A good balance of all the other settings should make this setting useless but it is available to set for more special cases. **NOTE**: This will limit the number of requests during streams but other API calls to the cloud provider like directory listings will still pass. Properties: - Config: rps - Env Var: RCLONE_CACHE_RPS - Type: int - Default: -1 #### --cache-writes Cache file data on writes through the FS. If you need to read files immediately after you upload them through cache you can enable this flag to have their data stored in the cache store at the same time during upload. Properties: - Config: writes - Env Var: RCLONE_CACHE_WRITES - Type: bool - Default: false #### --cache-tmp-upload-path Directory to keep temporary files until they are uploaded. This is the path where cache will use as a temporary storage for new files that need to be uploaded to the cloud provider. Specifying a value will enable this feature. Without it, it is completely disabled and files will be uploaded directly to the cloud provider Properties: - Config: tmp_upload_path - Env Var: RCLONE_CACHE_TMP_UPLOAD_PATH - Type: string - Required: false #### --cache-tmp-wait-time How long should files be stored in local cache before being uploaded. This is the duration that a file must wait in the temporary location _cache-tmp-upload-path_ before it is selected for upload. Note that only one file is uploaded at a time and it can take longer to start the upload if a queue formed for this purpose. Properties: - Config: tmp_wait_time - Env Var: RCLONE_CACHE_TMP_WAIT_TIME - Type: Duration - Default: 15s #### --cache-db-wait-time How long to wait for the DB to be available - 0 is unlimited. Only one process can have the DB open at any one time, so rclone waits for this duration for the DB to become available before it gives an error. If you set it to 0 then it will wait forever. Properties: - Config: db_wait_time - Env Var: RCLONE_CACHE_DB_WAIT_TIME - Type: Duration - Default: 1s #### --cache-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_CACHE_DESCRIPTION - Type: string - Required: false ## Backend commands Here are the commands specific to the cache backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the [backend](https://rclone.org/commands/rclone_backend/) command for more info on how to pass options and arguments. These can be run on a running backend using the rc command [backend/command](https://rclone.org/rc/#backend-command). ### stats Print stats on the cache backend in JSON format. rclone backend stats remote: [options] [+] # Chunker The `chunker` overlay transparently splits large files into smaller chunks during upload to wrapped remote and transparently assembles them back when the file is downloaded. This allows to effectively overcome size limits imposed by storage providers. ## Configuration To use it, first set up the underlying remote following the configuration instructions for that remote. You can also use a local pathname instead of a remote. First check your chosen remote is working - we'll call it `remote:path` here. Note that anything inside `remote:path` will be chunked and anything outside won't. This means that if you are using a bucket-based remote (e.g. S3, B2, swift) then you should probably put the bucket in the remote `s3:bucket`. Now configure `chunker` using `rclone config`. We will call this one `overlay` to separate it from the `remote` itself. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> overlay Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Transparently chunk/split large files \ "chunker" [snip] Storage> chunker Remote to chunk/unchunk. Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended). Enter a string value. Press Enter for the default (""). remote> remote:path Files larger than chunk size will be split in chunks. Enter a size with suffix K,M,G,T. Press Enter for the default ("2G"). chunk_size> 100M Choose how chunker handles hash sums. All modes but "none" require metadata. Enter a string value. Press Enter for the default ("md5"). Choose a number from below, or type in your own value 1 / Pass any hash supported by wrapped remote for non-chunked files, return nothing otherwise \ "none" 2 / MD5 for composite files \ "md5" 3 / SHA1 for composite files \ "sha1" 4 / MD5 for all files \ "md5all" 5 / SHA1 for all files \ "sha1all" 6 / Copying a file to chunker will request MD5 from the source falling back to SHA1 if unsupported \ "md5quick" 7 / Similar to "md5quick" but prefers SHA1 over MD5 \ "sha1quick" hash_type> md5 Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config -------------------- [overlay] type = chunker remote = remote:bucket chunk_size = 100M hash_type = md5 -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` ### Specifying the remote In normal use, make sure the remote has a `:` in. If you specify the remote without a `:` then rclone will use a local directory of that name. So if you use a remote of `/path/to/secret/files` then rclone will chunk stuff in that directory. If you use a remote of `name` then rclone will put files in a directory called `name` in the current directory. ### Chunking When rclone starts a file upload, chunker checks the file size. If it doesn't exceed the configured chunk size, chunker will just pass the file to the wrapped remote (however, see caveat below). If a file is large, chunker will transparently cut data in pieces with temporary names and stream them one by one, on the fly. Each data chunk will contain the specified number of bytes, except for the last one which may have less data. If file size is unknown in advance (this is called a streaming upload), chunker will internally create a temporary copy, record its size and repeat the above process. When upload completes, temporary chunk files are finally renamed. This scheme guarantees that operations can be run in parallel and look from outside as atomic. A similar method with hidden temporary chunks is used for other operations (copy/move/rename, etc.). If an operation fails, hidden chunks are normally destroyed, and the target composite file stays intact. When a composite file download is requested, chunker transparently assembles it by concatenating data chunks in order. As the split is trivial one could even manually concatenate data chunks together to obtain the original content. When the `list` rclone command scans a directory on wrapped remote, the potential chunk files are accounted for, grouped and assembled into composite directory entries. Any temporary chunks are hidden. List and other commands can sometimes come across composite files with missing or invalid chunks, e.g. shadowed by like-named directory or another file. This usually means that wrapped file system has been directly tampered with or damaged. If chunker detects a missing chunk it will by default print warning, skip the whole incomplete group of chunks but proceed with current command. You can set the `--chunker-fail-hard` flag to have commands abort with error message in such cases. **Caveat**: As it is now, chunker will always create a temporary file in the backend and then rename it, even if the file is below the chunk threshold. This will result in unnecessary API calls and can severely restrict throughput when handling transfers primarily composed of small files on some backends (e.g. Box). A workaround to this issue is to use chunker only for files above the chunk threshold via `--min-size` and then perform a separate call without chunker on the remaining files. #### Chunk names The default chunk name format is `*.rclone_chunk.###`, hence by default chunk names are `BIG_FILE_NAME.rclone_chunk.001`, `BIG_FILE_NAME.rclone_chunk.002` etc. You can configure another name format using the `name_format` configuration file option. The format uses asterisk `*` as a placeholder for the base file name and one or more consecutive hash characters `#` as a placeholder for sequential chunk number. There must be one and only one asterisk. The number of consecutive hash characters defines the minimum length of a string representing a chunk number. If decimal chunk number has less digits than the number of hashes, it is left-padded by zeros. If the decimal string is longer, it is left intact. By default numbering starts from 1 but there is another option that allows user to start from 0, e.g. for compatibility with legacy software. For example, if name format is `big_*-##.part` and original file name is `data.txt` and numbering starts from 0, then the first chunk will be named `big_data.txt-00.part`, the 99th chunk will be `big_data.txt-98.part` and the 302nd chunk will become `big_data.txt-301.part`. Note that `list` assembles composite directory entries only when chunk names match the configured format and treats non-conforming file names as normal non-chunked files. When using `norename` transactions, chunk names will additionally have a unique file version suffix. For example, `BIG_FILE_NAME.rclone_chunk.001_bp562k`. ### Metadata Besides data chunks chunker will by default create metadata object for a composite file. The object is named after the original file. Chunker allows user to disable metadata completely (the `none` format). Note that metadata is normally not created for files smaller than the configured chunk size. This may change in future rclone releases. #### Simple JSON metadata format This is the default format. It supports hash sums and chunk validation for composite files. Meta objects carry the following fields: - `ver` - version of format, currently `1` - `size` - total size of composite file - `nchunks` - number of data chunks in file - `md5` - MD5 hashsum of composite file (if present) - `sha1` - SHA1 hashsum (if present) - `txn` - identifies current version of the file There is no field for composite file name as it's simply equal to the name of meta object on the wrapped remote. Please refer to respective sections for details on hashsums and modified time handling. #### No metadata You can disable meta objects by setting the meta format option to `none`. In this mode chunker will scan directory for all files that follow configured chunk name format, group them by detecting chunks with the same base name and show group names as virtual composite files. This method is more prone to missing chunk errors (especially missing last chunk) than format with metadata enabled. ### Hashsums Chunker supports hashsums only when a compatible metadata is present. Hence, if you choose metadata format of `none`, chunker will report hashsum as `UNSUPPORTED`. Please note that by default metadata is stored only for composite files. If a file is smaller than configured chunk size, chunker will transparently redirect hash requests to wrapped remote, so support depends on that. You will see the empty string as a hashsum of requested type for small files if the wrapped remote doesn't support it. Many storage backends support MD5 and SHA1 hash types, so does chunker. With chunker you can choose one or another but not both. MD5 is set by default as the most supported type. Since chunker keeps hashes for composite files and falls back to the wrapped remote hash for non-chunked ones, we advise you to choose the same hash type as supported by wrapped remote so that your file listings look coherent. If your storage backend does not support MD5 or SHA1 but you need consistent file hashing, configure chunker with `md5all` or `sha1all`. These two modes guarantee given hash for all files. If wrapped remote doesn't support it, chunker will then add metadata to all files, even small. However, this can double the amount of small files in storage and incur additional service charges. You can even use chunker to force md5/sha1 support in any other remote at expense of sidecar meta objects by setting e.g. `hash_type=sha1all` to force hashsums and `chunk_size=1P` to effectively disable chunking. Normally, when a file is copied to chunker controlled remote, chunker will ask the file source for compatible file hash and revert to on-the-fly calculation if none is found. This involves some CPU overhead but provides a guarantee that given hashsum is available. Also, chunker will reject a server-side copy or move operation if source and destination hashsum types are different resulting in the extra network bandwidth, too. In some rare cases this may be undesired, so chunker provides two optional choices: `sha1quick` and `md5quick`. If the source does not support primary hash type and the quick mode is enabled, chunker will try to fall back to the secondary type. This will save CPU and bandwidth but can result in empty hashsums at destination. Beware of consequences: the `sync` command will revert (sometimes silently) to time/size comparison if compatible hashsums between source and target are not found. ### Modification times Chunker stores modification times using the wrapped remote so support depends on that. For a small non-chunked file the chunker overlay simply manipulates modification time of the wrapped remote file. For a composite file with metadata chunker will get and set modification time of the metadata object on the wrapped remote. If file is chunked but metadata format is `none` then chunker will use modification time of the first data chunk. ### Migrations The idiomatic way to migrate to a different chunk size, hash type, transaction style or chunk naming scheme is to: - Collect all your chunked files under a directory and have your chunker remote point to it. - Create another directory (most probably on the same cloud storage) and configure a new remote with desired metadata format, hash type, chunk naming etc. - Now run `rclone sync --interactive oldchunks: newchunks:` and all your data will be transparently converted in transfer. This may take some time, yet chunker will try server-side copy if possible. - After checking data integrity you may remove configuration section of the old remote. If rclone gets killed during a long operation on a big composite file, hidden temporary chunks may stay in the directory. They will not be shown by the `list` command but will eat up your account quota. Please note that the `deletefile` command deletes only active chunks of a file. As a workaround, you can use remote of the wrapped file system to see them. An easy way to get rid of hidden garbage is to copy littered directory somewhere using the chunker remote and purge the original directory. The `copy` command will copy only active chunks while the `purge` will remove everything including garbage. ### Caveats and Limitations Chunker requires wrapped remote to support server-side `move` (or `copy` + `delete`) operations, otherwise it will explicitly refuse to start. This is because it internally renames temporary chunk files to their final names when an operation completes successfully. Chunker encodes chunk number in file name, so with default `name_format` setting it adds 17 characters. Also chunker adds 7 characters of temporary suffix during operations. Many file systems limit base file name without path by 255 characters. Using rclone's crypt remote as a base file system limits file name by 143 characters. Thus, maximum name length is 231 for most files and 119 for chunker-over-crypt. A user in need can change name format to e.g. `*.rcc##` and save 10 characters (provided at most 99 chunks per file). Note that a move implemented using the copy-and-delete method may incur double charging with some cloud storage providers. Chunker will not automatically rename existing chunks when you run `rclone config` on a live remote and change the chunk name format. Beware that in result of this some files which have been treated as chunks before the change can pop up in directory listings as normal files and vice versa. The same warning holds for the chunk size. If you desperately need to change critical chunking settings, you should run data migration as described above. If wrapped remote is case insensitive, the chunker overlay will inherit that property (so you can't have a file called "Hello.doc" and "hello.doc" in the same directory). Chunker included in rclone releases up to `v1.54` can sometimes fail to detect metadata produced by recent versions of rclone. We recommend users to keep rclone up-to-date to avoid data corruption. Changing `transactions` is dangerous and requires explicit migration. ### Standard options Here are the Standard options specific to chunker (Transparently chunk/split large files). #### --chunker-remote Remote to chunk/unchunk. Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended). Properties: - Config: remote - Env Var: RCLONE_CHUNKER_REMOTE - Type: string - Required: true #### --chunker-chunk-size Files larger than chunk size will be split in chunks. Properties: - Config: chunk_size - Env Var: RCLONE_CHUNKER_CHUNK_SIZE - Type: SizeSuffix - Default: 2Gi #### --chunker-hash-type Choose how chunker handles hash sums. All modes but "none" require metadata. Properties: - Config: hash_type - Env Var: RCLONE_CHUNKER_HASH_TYPE - Type: string - Default: "md5" - Examples: - "none" - Pass any hash supported by wrapped remote for non-chunked files. - Return nothing otherwise. - "md5" - MD5 for composite files. - "sha1" - SHA1 for composite files. - "md5all" - MD5 for all files. - "sha1all" - SHA1 for all files. - "md5quick" - Copying a file to chunker will request MD5 from the source. - Falling back to SHA1 if unsupported. - "sha1quick" - Similar to "md5quick" but prefers SHA1 over MD5. ### Advanced options Here are the Advanced options specific to chunker (Transparently chunk/split large files). #### --chunker-name-format String format of chunk file names. The two placeholders are: base file name (*) and chunk number (#...). There must be one and only one asterisk and one or more consecutive hash characters. If chunk number has less digits than the number of hashes, it is left-padded by zeros. If there are more digits in the number, they are left as is. Possible chunk files are ignored if their name does not match given format. Properties: - Config: name_format - Env Var: RCLONE_CHUNKER_NAME_FORMAT - Type: string - Default: "*.rclone_chunk.###" #### --chunker-start-from Minimum valid chunk number. Usually 0 or 1. By default chunk numbers start from 1. Properties: - Config: start_from - Env Var: RCLONE_CHUNKER_START_FROM - Type: int - Default: 1 #### --chunker-meta-format Format of the metadata object or "none". By default "simplejson". Metadata is a small JSON file named after the composite file. Properties: - Config: meta_format - Env Var: RCLONE_CHUNKER_META_FORMAT - Type: string - Default: "simplejson" - Examples: - "none" - Do not use metadata files at all. - Requires hash type "none". - "simplejson" - Simple JSON supports hash sums and chunk validation. - - It has the following fields: ver, size, nchunks, md5, sha1. #### --chunker-fail-hard Choose how chunker should handle files with missing or invalid chunks. Properties: - Config: fail_hard - Env Var: RCLONE_CHUNKER_FAIL_HARD - Type: bool - Default: false - Examples: - "true" - Report errors and abort current command. - "false" - Warn user, skip incomplete file and proceed. #### --chunker-transactions Choose how chunker should handle temporary files during transactions. Properties: - Config: transactions - Env Var: RCLONE_CHUNKER_TRANSACTIONS - Type: string - Default: "rename" - Examples: - "rename" - Rename temporary files after a successful transaction. - "norename" - Leave temporary file names and write transaction ID to metadata file. - Metadata is required for no rename transactions (meta format cannot be "none"). - If you are using norename transactions you should be careful not to downgrade Rclone - as older versions of Rclone don't support this transaction style and will misinterpret - files manipulated by norename transactions. - This method is EXPERIMENTAL, don't use on production systems. - "auto" - Rename or norename will be used depending on capabilities of the backend. - If meta format is set to "none", rename transactions will always be used. - This method is EXPERIMENTAL, don't use on production systems. #### --chunker-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_CHUNKER_DESCRIPTION - Type: string - Required: false # Cloudinary This is a backend for the [Cloudinary](https://cloudinary.com/) platform ## About Cloudinary [Cloudinary](https://cloudinary.com/) is an image and video API platform. Trusted by 1.5 million developers and 10,000 enterprise and hyper-growth companies as a critical part of their tech stack to deliver visually engaging experiences. ## Accounts & Pricing To use this backend, you need to [create a free account](https://cloudinary.com/users/register_free) on Cloudinary. Start with a free plan with generous usage limits. Then, as your requirements grow, upgrade to a plan that best fits your needs. See [the pricing details](https://cloudinary.com/pricing). ## Securing Your Credentials Please refer to the [docs](https://rclone.org/docs/#configuration-encryption-cheatsheet) ## Configuration Here is an example of making a Cloudinary configuration. First, create a [cloudinary.com](https://cloudinary.com/users/register_free) account and choose a plan. You will need to log in and get the `API Key` and `API Secret` for your account from the developer section. Now run `rclone config` Follow the interactive setup process: ```text No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter the name for the new remote. name> cloudinary-media-library Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / cloudinary.com \ (cloudinary) [snip] Storage> cloudinary Option cloud_name. You can find your cloudinary.com cloud_name in your [dashboard](https://console.cloudinary.com/pm/developer-dashboard) Enter a value. cloud_name> **************************** Option api_key. You can find your cloudinary.com api key in your [dashboard](https://console.cloudinary.com/pm/developer-dashboard) Enter a value. api_key> **************************** Option api_secret. You can find your cloudinary.com api secret in your [dashboard](https://console.cloudinary.com/pm/developer-dashboard) This value must be a single character, one of the following: y, g. y/g> y Enter a value. api_secret> **************************** Option upload_prefix. [Upload prefix](https://cloudinary.com/documentation/cloudinary_sdks#configuration_parameters) to specify alternative data center Enter a value. upload_prefix> Option upload_preset. [Upload presets](https://cloudinary.com/documentation/upload_presets) can be defined for different upload profiles Enter a value. upload_preset> Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: cloudinary - api_key: **************************** - api_secret: **************************** - cloud_name: **************************** - upload_prefix: - upload_preset: Keep this "cloudinary-media-library" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` List directories in the top level of your Media Library `rclone lsd cloudinary-media-library:` Make a new directory. `rclone mkdir cloudinary-media-library:directory` List the contents of a directory. `rclone ls cloudinary-media-library:directory` ### Modified time and hashes Cloudinary stores md5 and timestamps for any successful Put automatically and read-only. ### Standard options Here are the Standard options specific to cloudinary (Cloudinary). #### --cloudinary-cloud-name Cloudinary Environment Name Properties: - Config: cloud_name - Env Var: RCLONE_CLOUDINARY_CLOUD_NAME - Type: string - Required: true #### --cloudinary-api-key Cloudinary API Key Properties: - Config: api_key - Env Var: RCLONE_CLOUDINARY_API_KEY - Type: string - Required: true #### --cloudinary-api-secret Cloudinary API Secret Properties: - Config: api_secret - Env Var: RCLONE_CLOUDINARY_API_SECRET - Type: string - Required: true #### --cloudinary-upload-prefix Specify the API endpoint for environments out of the US Properties: - Config: upload_prefix - Env Var: RCLONE_CLOUDINARY_UPLOAD_PREFIX - Type: string - Required: false #### --cloudinary-upload-preset Upload Preset to select asset manipulation on upload Properties: - Config: upload_preset - Env Var: RCLONE_CLOUDINARY_UPLOAD_PRESET - Type: string - Required: false ### Advanced options Here are the Advanced options specific to cloudinary (Cloudinary). #### --cloudinary-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_CLOUDINARY_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Question,Asterisk,Pipe,Hash,Percent,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot #### --cloudinary-eventually-consistent-delay Wait N seconds for eventual consistency of the databases that support the backend operation Properties: - Config: eventually_consistent_delay - Env Var: RCLONE_CLOUDINARY_EVENTUALLY_CONSISTENT_DELAY - Type: Duration - Default: 0s #### --cloudinary-adjust-media-files-extensions Cloudinary handles media formats as a file attribute and strips it from the name, which is unlike most other file systems Properties: - Config: adjust_media_files_extensions - Env Var: RCLONE_CLOUDINARY_ADJUST_MEDIA_FILES_EXTENSIONS - Type: bool - Default: true #### --cloudinary-media-extensions Cloudinary supported media extensions Properties: - Config: media_extensions - Env Var: RCLONE_CLOUDINARY_MEDIA_EXTENSIONS - Type: stringArray - Default: [3ds 3g2 3gp ai arw avi avif bmp bw cr2 cr3 djvu dng eps3 fbx flif flv gif glb gltf hdp heic heif ico indd jp2 jpe jpeg jpg jxl jxr m2ts mov mp4 mpeg mts mxf obj ogv pdf ply png psd svg tga tif tiff ts u3ma usdz wdp webm webp wmv] #### --cloudinary-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_CLOUDINARY_DESCRIPTION - Type: string - Required: false # Citrix ShareFile [Citrix ShareFile](https://sharefile.com) is a secure file sharing and transfer service aimed as business. ## Configuration The initial setup for Citrix ShareFile involves getting a token from Citrix ShareFile which you can in your browser. `rclone config` walks you through it. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value XX / Citrix Sharefile \ "sharefile" Storage> sharefile ** See help for sharefile backend at: https://rclone.org/sharefile/ ** ID of the root folder Leave blank to access "Personal Folders". You can use one of the standard values here or any folder ID (long hex number ID). Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Access the Personal Folders. (Default) \ "" 2 / Access the Favorites folder. \ "favorites" 3 / Access all the shared folders. \ "allshared" 4 / Access all the individual connectors. \ "connectors" 5 / Access the home, favorites, and shared folders as well as the connectors. \ "top" root_folder_id> Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth?state=XXX Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: sharefile - endpoint: https://XXX.sharefile.com - token: {"access_token":"XXX","token_type":"bearer","refresh_token":"XXX","expiry":"2019-09-30T19:41:45.878561877+01:00"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` See the [remote setup docs](https://rclone.org/remote_setup/) for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Citrix ShareFile. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on `http://127.0.0.1:53682/` and this it may require you to unblock it temporarily if you are running a host firewall. Once configured you can then use `rclone` like this, List directories in top level of your ShareFile rclone lsd remote: List all the files in your ShareFile rclone ls remote: To copy a local directory to an ShareFile directory called backup rclone copy /home/source remote:backup Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ### Modification times and hashes ShareFile allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not. ShareFile supports MD5 type hashes, so you can use the `--checksum` flag. ### Transfers For files above 128 MiB rclone will use a chunked transfer. Rclone will upload up to `--transfers` chunks at the same time (shared among all the multipart uploads). Chunks are buffered in memory and are normally 64 MiB so increasing `--transfers` will increase memory use. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | \\ | 0x5C | ＼ | | * | 0x2A | ＊ | | < | 0x3C | ＜ | | > | 0x3E | ＞ | | ? | 0x3F | ？ | | : | 0x3A | ： | | \| | 0x7C | ｜ | | " | 0x22 | ＂ | File names can also not start or end with the following characters. These only get replaced if they are the first or last character in the name: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | SP | 0x20 | ␠ | | . | 0x2E | ． | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Standard options Here are the Standard options specific to sharefile (Citrix Sharefile). #### --sharefile-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_SHAREFILE_CLIENT_ID - Type: string - Required: false #### --sharefile-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_SHAREFILE_CLIENT_SECRET - Type: string - Required: false #### --sharefile-root-folder-id ID of the root folder. Leave blank to access "Personal Folders". You can use one of the standard values here or any folder ID (long hex number ID). Properties: - Config: root_folder_id - Env Var: RCLONE_SHAREFILE_ROOT_FOLDER_ID - Type: string - Required: false - Examples: - "" - Access the Personal Folders (default). - "favorites" - Access the Favorites folder. - "allshared" - Access all the shared folders. - "connectors" - Access all the individual connectors. - "top" - Access the home, favorites, and shared folders as well as the connectors. ### Advanced options Here are the Advanced options specific to sharefile (Citrix Sharefile). #### --sharefile-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_SHAREFILE_TOKEN - Type: string - Required: false #### --sharefile-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_SHAREFILE_AUTH_URL - Type: string - Required: false #### --sharefile-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_SHAREFILE_TOKEN_URL - Type: string - Required: false #### --sharefile-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_SHAREFILE_CLIENT_CREDENTIALS - Type: bool - Default: false #### --sharefile-upload-cutoff Cutoff for switching to multipart upload. Properties: - Config: upload_cutoff - Env Var: RCLONE_SHAREFILE_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 128Mi #### --sharefile-chunk-size Upload chunk size. Must a power of 2 >= 256k. Making this larger will improve performance, but note that each chunk is buffered in memory one per transfer. Reducing this will reduce memory usage but decrease performance. Properties: - Config: chunk_size - Env Var: RCLONE_SHAREFILE_CHUNK_SIZE - Type: SizeSuffix - Default: 64Mi #### --sharefile-endpoint Endpoint for API calls. This is usually auto discovered as part of the oauth process, but can be set manually to something like: https://XXX.sharefile.com Properties: - Config: endpoint - Env Var: RCLONE_SHAREFILE_ENDPOINT - Type: string - Required: false #### --sharefile-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_SHAREFILE_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,LeftSpace,LeftPeriod,RightSpace,RightPeriod,InvalidUtf8,Dot #### --sharefile-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SHAREFILE_DESCRIPTION - Type: string - Required: false ## Limitations Note that ShareFile is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". ShareFile only supports filenames up to 256 characters in length. `rclone about` is not supported by the Citrix ShareFile backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) # Crypt Rclone `crypt` remotes encrypt and decrypt other remotes. A remote of type `crypt` does not access a [storage system](https://rclone.org/overview/) directly, but instead wraps another remote, which in turn accesses the storage system. This is similar to how [alias](https://rclone.org/alias/), [union](https://rclone.org/union/), [chunker](https://rclone.org/chunker/) and a few others work. It makes the usage very flexible, as you can add a layer, in this case an encryption layer, on top of any other backend, even in multiple layers. Rclone's functionality can be used as with any other remote, for example you can [mount](https://rclone.org/commands/rclone_mount/) a crypt remote. Accessing a storage system through a crypt remote realizes client-side encryption, which makes it safe to keep your data in a location you do not trust will not get compromised. When working against the `crypt` remote, rclone will automatically encrypt (before uploading) and decrypt (after downloading) on your local system as needed on the fly, leaving the data encrypted at rest in the wrapped remote. If you access the storage system using an application other than rclone, or access the wrapped remote directly using rclone, there will not be any encryption/decryption: Downloading existing content will just give you the encrypted (scrambled) format, and anything you upload will *not* become encrypted. The encryption is a secret-key encryption (also called symmetric key encryption) algorithm, where a password (or pass phrase) is used to generate real encryption key. The password can be supplied by user, or you may chose to let rclone generate one. It will be stored in the configuration file, in a lightly obscured form. If you are in an environment where you are not able to keep your configuration secured, you should add [configuration encryption](https://rclone.org/docs/#configuration-encryption) as protection. As long as you have this configuration file, you will be able to decrypt your data. Without the configuration file, as long as you remember the password (or keep it in a safe place), you can re-create the configuration and gain access to the existing data. You may also configure a corresponding remote in a different installation to access the same data. See below for guidance to [changing password](#changing-password). Encryption uses [cryptographic salt](https://en.wikipedia.org/wiki/Salt_(cryptography)), to permute the encryption key so that the same string may be encrypted in different ways. When configuring the crypt remote it is optional to enter a salt, or to let rclone generate a unique salt. If omitted, rclone uses a built-in unique string. Normally in cryptography, the salt is stored together with the encrypted content, and do not have to be memorized by the user. This is not the case in rclone, because rclone does not store any additional information on the remotes. Use of custom salt is effectively a second password that must be memorized. [File content](#file-encryption) encryption is performed using [NaCl SecretBox](https://godoc.org/golang.org/x/crypto/nacl/secretbox), based on XSalsa20 cipher and Poly1305 for integrity. [Names](#name-encryption) (file- and directory names) are also encrypted by default, but this has some implications and is therefore possible to be turned off. ## Configuration Here is an example of how to make a remote called `secret`. To use `crypt`, first set up the underlying remote. Follow the `rclone config` instructions for the specific backend. Before configuring the crypt remote, check the underlying remote is working. In this example the underlying remote is called `remote`. We will configure a path `path` within this remote to contain the encrypted content. Anything inside `remote:path` will be encrypted and anything outside will not. Configure `crypt` using `rclone config`. In this example the `crypt` remote is called `secret`, to differentiate it from the underlying `remote`. When you are done you can use the crypt remote named `secret` just as you would with any other remote, e.g. `rclone copy D:\docs secret:\docs`, and rclone will encrypt and decrypt as needed on the fly. If you access the wrapped remote `remote:path` directly you will bypass the encryption, and anything you read will be in encrypted form, and anything you write will be unencrypted. To avoid issues it is best to configure a dedicated path for encrypted content, and access it exclusively through a crypt remote. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> secret Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Encrypt/Decrypt a remote \ "crypt" [snip] Storage> crypt ** See help for crypt backend at: https://rclone.org/crypt/ ** Remote to encrypt/decrypt. Normally should contain a ':' and a path, eg "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended). Enter a string value. Press Enter for the default (""). remote> remote:path How to encrypt the filenames. Enter a string value. Press Enter for the default ("standard"). Choose a number from below, or type in your own value. / Encrypt the filenames. 1 | See the docs for the details. \ "standard" 2 / Very simple filename obfuscation. \ "obfuscate" / Don't encrypt the file names. 3 | Adds a ".bin" extension only. \ "off" filename_encryption> Option to either encrypt directory names or leave them intact. NB If filename_encryption is "off" then this option will do nothing. Enter a boolean value (true or false). Press Enter for the default ("true"). Choose a number from below, or type in your own value 1 / Encrypt directory names. \ "true" 2 / Don't encrypt directory names, leave them intact. \ "false" directory_name_encryption> Password or pass phrase for encryption. y) Yes type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Password or pass phrase for salt. Optional but recommended. Should be different to the previous password. y) Yes type in my own password g) Generate random password n) No leave this optional password blank (default) y/g/n> g Password strength in bits. 64 is just about memorable 128 is secure 1024 is the maximum Bits> 128 Your password is: JAsJvRcgR-_veXNfy_sGmQ Use this password? Please note that an obscured version of this password (and not the password itself) will be stored under your configuration file, so keep this generated password in a safe place. y) Yes (default) n) No y/n> Edit advanced config? (y/n) y) Yes n) No (default) y/n> Remote config -------------------- [secret] type = crypt remote = remote:path password = *** ENCRYPTED *** password2 = *** ENCRYPTED *** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> ``` **Important** The crypt password stored in `rclone.conf` is lightly obscured. That only protects it from cursory inspection. It is not secure unless [configuration encryption](https://rclone.org/docs/#configuration-encryption) of `rclone.conf` is specified. A long passphrase is recommended, or `rclone config` can generate a random one. The obscured password is created using AES-CTR with a static key. The IV (nonce) is stored verbatim at the beginning of the obscured password. This static key is shared between all versions of rclone. If you reconfigure rclone with the same passwords/passphrases elsewhere it will be compatible, but the obscured version will be different due to the different salt. Rclone does not encrypt * file length - this can be calculated within 16 bytes * modification time - used for syncing ### Specifying the remote When configuring the remote to encrypt/decrypt, you may specify any string that rclone accepts as a source/destination of other commands. The primary use case is to specify the path into an already configured remote (e.g. `remote:path/to/dir` or `remote:bucket`), such that data in a remote untrusted location can be stored encrypted. You may also specify a local filesystem path, such as `/path/to/dir` on Linux, `C:\path\to\dir` on Windows. By creating a crypt remote pointing to such a local filesystem path, you can use rclone as a utility for pure local file encryption, for example to keep encrypted files on a removable USB drive. **Note**: A string which do not contain a `:` will by rclone be treated as a relative path in the local filesystem. For example, if you enter the name `remote` without the trailing `:`, it will be treated as a subdirectory of the current directory with name "remote". If a path `remote:path/to/dir` is specified, rclone stores encrypted files in `path/to/dir` on the remote. With file name encryption, files saved to `secret:subdir/subfile` are stored in the unencrypted path `path/to/dir` but the `subdir/subpath` element is encrypted. The path you specify does not have to exist, rclone will create it when needed. If you intend to use the wrapped remote both directly for keeping unencrypted content, as well as through a crypt remote for encrypted content, it is recommended to point the crypt remote to a separate directory within the wrapped remote. If you use a bucket-based storage system (e.g. Swift, S3, Google Compute Storage, B2) it is generally advisable to wrap the crypt remote around a specific bucket (`s3:bucket`). If wrapping around the entire root of the storage (`s3:`), and use the optional file name encryption, rclone will encrypt the bucket name. ### Changing password Should the password, or the configuration file containing a lightly obscured form of the password, be compromised, you need to re-encrypt your data with a new password. Since rclone uses secret-key encryption, where the encryption key is generated directly from the password kept on the client, it is not possible to change the password/key of already encrypted content. Just changing the password configured for an existing crypt remote means you will no longer able to decrypt any of the previously encrypted content. The only possibility is to re-upload everything via a crypt remote configured with your new password. Depending on the size of your data, your bandwidth, storage quota etc, there are different approaches you can take: - If you have everything in a different location, for example on your local system, you could remove all of the prior encrypted files, change the password for your configured crypt remote (or delete and re-create the crypt configuration), and then re-upload everything from the alternative location. - If you have enough space on the storage system you can create a new crypt remote pointing to a separate directory on the same backend, and then use rclone to copy everything from the original crypt remote to the new, effectively decrypting everything on the fly using the old password and re-encrypting using the new password. When done, delete the original crypt remote directory and finally the rclone crypt configuration with the old password. All data will be streamed from the storage system and back, so you will get half the bandwidth and be charged twice if you have upload and download quota on the storage system. **Note**: A security problem related to the random password generator was fixed in rclone version 1.53.3 (released 2020-11-19). Passwords generated by rclone config in version 1.49.0 (released 2019-08-26) to 1.53.2 (released 2020-10-26) are not considered secure and should be changed. If you made up your own password, or used rclone version older than 1.49.0 or newer than 1.53.2 to generate it, you are *not* affected by this issue. See [issue #4783](https://github.com/rclone/rclone/issues/4783) for more details, and a tool you can use to check if you are affected. ### Example Create the following file structure using "standard" file name encryption. ``` plaintext/ ├── file0.txt ├── file1.txt └── subdir ├── file2.txt ├── file3.txt └── subsubdir └── file4.txt ``` Copy these to the remote, and list them ``` $ rclone -q copy plaintext secret: $ rclone -q ls secret: 7 file1.txt 6 file0.txt 8 subdir/file2.txt 10 subdir/subsubdir/file4.txt 9 subdir/file3.txt ``` The crypt remote looks like ``` $ rclone -q ls remote:path 55 hagjclgavj2mbiqm6u6cnjjqcg 54 v05749mltvv1tf4onltun46gls 57 86vhrsv86mpbtd3a0akjuqslj8/dlj7fkq4kdq72emafg7a7s41uo 58 86vhrsv86mpbtd3a0akjuqslj8/7uu829995du6o42n32otfhjqp4/b9pausrfansjth5ob3jkdqd4lc 56 86vhrsv86mpbtd3a0akjuqslj8/8njh1sk437gttmep3p70g81aps ``` The directory structure is preserved ``` $ rclone -q ls secret:subdir 8 file2.txt 9 file3.txt 10 subsubdir/file4.txt ``` Without file name encryption `.bin` extensions are added to underlying names. This prevents the cloud provider attempting to interpret file content. ``` $ rclone -q ls remote:path 54 file0.txt.bin 57 subdir/file3.txt.bin 56 subdir/file2.txt.bin 58 subdir/subsubdir/file4.txt.bin 55 file1.txt.bin ``` ### File name encryption modes Off * doesn't hide file names or directory structure * allows for longer file names (~246 characters) * can use sub paths and copy single files Standard * file names encrypted * file names can't be as long (~143 characters) * can use sub paths and copy single files * directory structure visible * identical files names will have identical uploaded names * can use shortcuts to shorten the directory recursion Obfuscation This is a simple "rotate" of the filename, with each file having a rot distance based on the filename. Rclone stores the distance at the beginning of the filename. A file called "hello" may become "53.jgnnq". Obfuscation is not a strong encryption of filenames, but hinders automated scanning tools picking up on filename patterns. It is an intermediate between "off" and "standard" which allows for longer path segment names. There is a possibility with some unicode based filenames that the obfuscation is weak and may map lower case characters to upper case equivalents. Obfuscation cannot be relied upon for strong protection. * file names very lightly obfuscated * file names can be longer than standard encryption * can use sub paths and copy single files * directory structure visible * identical files names will have identical uploaded names Cloud storage systems have limits on file name length and total path length which rclone is more likely to breach using "Standard" file name encryption. Where file names are 143 or fewer characters in length issues should not be encountered, irrespective of cloud storage provider. An experimental advanced option `filename_encoding` is now provided to address this problem to a certain degree. For cloud storage systems with case sensitive file names (e.g. Google Drive), `base64` can be used to reduce file name length. For cloud storage systems using UTF-16 to store file names internally (e.g. OneDrive, Dropbox, Box), `base32768` can be used to drastically reduce file name length. An alternative, future rclone file name encryption mode may tolerate backend provider path length limits. ### Directory name encryption Crypt offers the option of encrypting dir names or leaving them intact. There are two options: True Encrypts the whole file path including directory names Example: `1/12/123.txt` is encrypted to `p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng/qgm4avr35m5loi1th53ato71v0` False Only encrypts file names, skips directory names Example: `1/12/123.txt` is encrypted to `1/12/qgm4avr35m5loi1th53ato71v0` ### Modification times and hashes Crypt stores modification times using the underlying remote so support depends on that. Hashes are not stored for crypt. However the data integrity is protected by an extremely strong crypto authenticator. Use the `rclone cryptcheck` command to check the integrity of an encrypted remote instead of `rclone check` which can't check the checksums properly. ### Standard options Here are the Standard options specific to crypt (Encrypt/Decrypt a remote). #### --crypt-remote Remote to encrypt/decrypt. Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended). Properties: - Config: remote - Env Var: RCLONE_CRYPT_REMOTE - Type: string - Required: true #### --crypt-filename-encryption How to encrypt the filenames. Properties: - Config: filename_encryption - Env Var: RCLONE_CRYPT_FILENAME_ENCRYPTION - Type: string - Default: "standard" - Examples: - "standard" - Encrypt the filenames. - See the docs for the details. - "obfuscate" - Very simple filename obfuscation. - "off" - Don't encrypt the file names. - Adds a ".bin", or "suffix" extension only. #### --crypt-directory-name-encryption Option to either encrypt directory names or leave them intact. NB If filename_encryption is "off" then this option will do nothing. Properties: - Config: directory_name_encryption - Env Var: RCLONE_CRYPT_DIRECTORY_NAME_ENCRYPTION - Type: bool - Default: true - Examples: - "true" - Encrypt directory names. - "false" - Don't encrypt directory names, leave them intact. #### --crypt-password Password or pass phrase for encryption. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: password - Env Var: RCLONE_CRYPT_PASSWORD - Type: string - Required: true #### --crypt-password2 Password or pass phrase for salt. Optional but recommended. Should be different to the previous password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: password2 - Env Var: RCLONE_CRYPT_PASSWORD2 - Type: string - Required: false ### Advanced options Here are the Advanced options specific to crypt (Encrypt/Decrypt a remote). #### --crypt-server-side-across-configs Deprecated: use --server-side-across-configs instead. Allow server-side operations (e.g. copy) to work across different crypt configs. Normally this option is not what you want, but if you have two crypts pointing to the same backend you can use it. This can be used, for example, to change file name encryption type without re-uploading all the data. Just make two crypt backends pointing to two different directories with the single changed parameter and use rclone move to move the files between the crypt remotes. Properties: - Config: server_side_across_configs - Env Var: RCLONE_CRYPT_SERVER_SIDE_ACROSS_CONFIGS - Type: bool - Default: false #### --crypt-show-mapping For all files listed show how the names encrypt. If this flag is set then for each file that the remote is asked to list, it will log (at level INFO) a line stating the decrypted file name and the encrypted file name. This is so you can work out which encrypted names are which decrypted names just in case you need to do something with the encrypted file names, or for debugging purposes. Properties: - Config: show_mapping - Env Var: RCLONE_CRYPT_SHOW_MAPPING - Type: bool - Default: false #### --crypt-no-data-encryption Option to either encrypt file data or leave it unencrypted. Properties: - Config: no_data_encryption - Env Var: RCLONE_CRYPT_NO_DATA_ENCRYPTION - Type: bool - Default: false - Examples: - "true" - Don't encrypt file data, leave it unencrypted. - "false" - Encrypt file data. #### --crypt-pass-bad-blocks If set this will pass bad blocks through as all 0. This should not be set in normal operation, it should only be set if trying to recover an encrypted file with errors and it is desired to recover as much of the file as possible. Properties: - Config: pass_bad_blocks - Env Var: RCLONE_CRYPT_PASS_BAD_BLOCKS - Type: bool - Default: false #### --crypt-strict-names If set, this will raise an error when crypt comes across a filename that can't be decrypted. (By default, rclone will just log a NOTICE and continue as normal.) This can happen if encrypted and unencrypted files are stored in the same directory (which is not recommended.) It may also indicate a more serious problem that should be investigated. Properties: - Config: strict_names - Env Var: RCLONE_CRYPT_STRICT_NAMES - Type: bool - Default: false #### --crypt-filename-encoding How to encode the encrypted filename to text string. This option could help with shortening the encrypted filename. The suitable option would depend on the way your remote count the filename length and if it's case sensitive. Properties: - Config: filename_encoding - Env Var: RCLONE_CRYPT_FILENAME_ENCODING - Type: string - Default: "base32" - Examples: - "base32" - Encode using base32. Suitable for all remote. - "base64" - Encode using base64. Suitable for case sensitive remote. - "base32768" - Encode using base32768. Suitable if your remote counts UTF-16 or - Unicode codepoint instead of UTF-8 byte length. (Eg. Onedrive, Dropbox) #### --crypt-suffix If this is set it will override the default suffix of ".bin". Setting suffix to "none" will result in an empty suffix. This may be useful when the path length is critical. Properties: - Config: suffix - Env Var: RCLONE_CRYPT_SUFFIX - Type: string - Default: ".bin" #### --crypt-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_CRYPT_DESCRIPTION - Type: string - Required: false ### Metadata Any metadata supported by the underlying remote is read and written. See the [metadata](https://rclone.org/docs/#metadata) docs for more info. ## Backend commands Here are the commands specific to the crypt backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the [backend](https://rclone.org/commands/rclone_backend/) command for more info on how to pass options and arguments. These can be run on a running backend using the rc command [backend/command](https://rclone.org/rc/#backend-command). ### encode Encode the given filename(s) rclone backend encode remote: [options] [+] This encodes the filenames given as arguments returning a list of strings of the encoded results. Usage Example: rclone backend encode crypt: file1 [file2...] rclone rc backend/command command=encode fs=crypt: file1 [file2...] ### decode Decode the given filename(s) rclone backend decode remote: [options] [+] This decodes the filenames given as arguments returning a list of strings of the decoded results. It will return an error if any of the inputs are invalid. Usage Example: rclone backend decode crypt: encryptedfile1 [encryptedfile2...] rclone rc backend/command command=decode fs=crypt: encryptedfile1 [encryptedfile2...] ## Backing up an encrypted remote If you wish to backup an encrypted remote, it is recommended that you use `rclone sync` on the encrypted files, and make sure the passwords are the same in the new encrypted remote. This will have the following advantages * `rclone sync` will check the checksums while copying * you can use `rclone check` between the encrypted remotes * you don't decrypt and encrypt unnecessarily For example, let's say you have your original remote at `remote:` with the encrypted version at `eremote:` with path `remote:crypt`. You would then set up the new remote `remote2:` and then the encrypted version `eremote2:` with path `remote2:crypt` using the same passwords as `eremote:`. To sync the two remotes you would do rclone sync --interactive remote:crypt remote2:crypt And to check the integrity you would do rclone check remote:crypt remote2:crypt ## File formats ### File encryption Files are encrypted 1:1 source file to destination object. The file has a header and is divided into chunks. #### Header * 8 bytes magic string `RCLONE\x00\x00` * 24 bytes Nonce (IV) The initial nonce is generated from the operating systems crypto strong random number generator. The nonce is incremented for each chunk read making sure each nonce is unique for each block written. The chance of a nonce being reused is minuscule. If you wrote an exabyte of data (10¹⁸ bytes) you would have a probability of approximately 2×10⁻³² of reusing a nonce. #### Chunk Each chunk will contain 64 KiB of data, except for the last one which may have less data. The data chunk is in standard NaCl SecretBox format. SecretBox uses XSalsa20 and Poly1305 to encrypt and authenticate messages. Each chunk contains: * 16 Bytes of Poly1305 authenticator * 1 - 65536 bytes XSalsa20 encrypted data 64k chunk size was chosen as the best performing chunk size (the authenticator takes too much time below this and the performance drops off due to cache effects above this). Note that these chunks are buffered in memory so they can't be too big. This uses a 32 byte (256 bit key) key derived from the user password. #### Examples 1 byte file will encrypt to * 32 bytes header * 17 bytes data chunk 49 bytes total 1 MiB (1048576 bytes) file will encrypt to * 32 bytes header * 16 chunks of 65568 bytes 1049120 bytes total (a 0.05% overhead). This is the overhead for big files. ### Name encryption File names are encrypted segment by segment - the path is broken up into `/` separated strings and these are encrypted individually. File segments are padded using PKCS#7 to a multiple of 16 bytes before encryption. They are then encrypted with EME using AES with 256 bit key. EME (ECB-Mix-ECB) is a wide-block encryption mode presented in the 2003 paper "A Parallelizable Enciphering Mode" by Halevi and Rogaway. This makes for deterministic encryption which is what we want - the same filename must encrypt to the same thing otherwise we can't find it on the cloud storage system. This means that * filenames with the same name will encrypt the same * filenames which start the same won't have a common prefix This uses a 32 byte key (256 bits) and a 16 byte (128 bits) IV both of which are derived from the user password. After encryption they are written out using a modified version of standard `base32` encoding as described in RFC4648. The standard encoding is modified in two ways: * it becomes lower case (no-one likes upper case filenames!) * we strip the padding character `=` `base32` is used rather than the more efficient `base64` so rclone can be used on case insensitive remotes (e.g. Windows, Box, Dropbox, Onedrive etc). ### Key derivation Rclone uses `scrypt` with parameters `N=16384, r=8, p=1` with an optional user supplied salt (password2) to derive the 32+32+16 = 80 bytes of key material required. If the user doesn't supply a salt then rclone uses an internal one. `scrypt` makes it impractical to mount a dictionary attack on rclone encrypted data. For full protection against this you should always use a salt. ## SEE ALSO * [rclone cryptdecode](https://rclone.org/commands/rclone_cryptdecode/) - Show forward/reverse mapping of encrypted filenames # Compress ## Warning This remote is currently **experimental**. Things may break and data may be lost. Anything you do with this remote is at your own risk. Please understand the risks associated with using experimental code and don't use this remote in critical applications. The `Compress` remote adds compression to another remote. It is best used with remotes containing many large compressible files. ## Configuration To use this remote, all you need to do is specify another remote and a compression mode to use: ``` Current remotes: Name Type ==== ==== remote_to_press sometype e) Edit existing remote $ rclone config n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> n name> compress ... 8 / Compress a remote \ "compress" ... Storage> compress ** See help for compress backend at: https://rclone.org/compress/ ** Remote to compress. Enter a string value. Press Enter for the default (""). remote> remote_to_press:subdir Compression mode. Enter a string value. Press Enter for the default ("gzip"). Choose a number from below, or type in your own value 1 / Gzip compression balanced for speed and compression strength. \ "gzip" compression_mode> gzip Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config -------------------- [compress] type = compress remote = remote_to_press:subdir compression_mode = gzip -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ### Compression Modes Currently only gzip compression is supported. It provides a decent balance between speed and size and is well supported by other applications. Compression strength can further be configured via an advanced setting where 0 is no compression and 9 is strongest compression. ### File types If you open a remote wrapped by compress, you will see that there are many files with an extension corresponding to the compression algorithm you chose. These files are standard files that can be opened by various archive programs, but they have some hidden metadata that allows them to be used by rclone. While you may download and decompress these files at will, do **not** manually delete or rename files. Files without correct metadata files will not be recognized by rclone. ### File names The compressed files will be named `*.###########.gz` where `*` is the base file and the `#` part is base64 encoded size of the uncompressed file. The file names should not be changed by anything other than the rclone compression backend. ### Standard options Here are the Standard options specific to compress (Compress a remote). #### --compress-remote Remote to compress. Properties: - Config: remote - Env Var: RCLONE_COMPRESS_REMOTE - Type: string - Required: true #### --compress-mode Compression mode. Properties: - Config: mode - Env Var: RCLONE_COMPRESS_MODE - Type: string - Default: "gzip" - Examples: - "gzip" - Standard gzip compression with fastest parameters. ### Advanced options Here are the Advanced options specific to compress (Compress a remote). #### --compress-level GZIP compression level (-2 to 9). Generally -1 (default, equivalent to 5) is recommended. Levels 1 to 9 increase compression at the cost of speed. Going past 6 generally offers very little return. Level -2 uses Huffman encoding only. Only use if you know what you are doing. Level 0 turns off compression. Properties: - Config: level - Env Var: RCLONE_COMPRESS_LEVEL - Type: int - Default: -1 #### --compress-ram-cache-limit Some remotes don't allow the upload of files with unknown size. In this case the compressed file will need to be cached to determine it's size. Files smaller than this limit will be cached in RAM, files larger than this limit will be cached on disk. Properties: - Config: ram_cache_limit - Env Var: RCLONE_COMPRESS_RAM_CACHE_LIMIT - Type: SizeSuffix - Default: 20Mi #### --compress-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_COMPRESS_DESCRIPTION - Type: string - Required: false ### Metadata Any metadata supported by the underlying remote is read and written. See the [metadata](https://rclone.org/docs/#metadata) docs for more info. # Combine The `combine` backend joins remotes together into a single directory tree. For example you might have a remote for images on one provider: ``` $ rclone tree s3:imagesbucket / ├── image1.jpg └── image2.jpg ``` And a remote for files on another: ``` $ rclone tree drive:important/files / ├── file1.txt └── file2.txt ``` The `combine` backend can join these together into a synthetic directory structure like this: ``` $ rclone tree combined: / ├── files │ ├── file1.txt │ └── file2.txt └── images ├── image1.jpg └── image2.jpg ``` You'd do this by specifying an `upstreams` parameter in the config like this upstreams = images=s3:imagesbucket files=drive:important/files During the initial setup with `rclone config` you will specify the upstreams remotes as a space separated list. The upstream remotes can either be a local paths or other remotes. ## Configuration Here is an example of how to make a combine called `remote` for the example above. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. ... XX / Combine several remotes into one \ (combine) ... Storage> combine Option upstreams. Upstreams for combining These should be in the form dir=remote:path dir2=remote2:path Where before the = is specified the root directory and after is the remote to put there. Embedded spaces can be added using quotes "dir=remote:path with space" "dir2=remote2:path with space" Enter a fs.SpaceSepList value. upstreams> images=s3:imagesbucket files=drive:important/files Configuration complete. Options: - type: combine - upstreams: images=s3:imagesbucket files=drive:important/files Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ### Configuring for Google Drive Shared Drives Rclone has a convenience feature for making a combine backend for all the shared drives you have access to. Assuming your main (non shared drive) Google drive remote is called `drive:` you would run rclone backend -o config drives drive: This would produce something like this: [My Drive] type = alias remote = drive,team_drive=0ABCDEF-01234567890,root_folder_id=: [Test Drive] type = alias remote = drive,team_drive=0ABCDEFabcdefghijkl,root_folder_id=: [AllDrives] type = combine upstreams = "My Drive=My Drive:" "Test Drive=Test Drive:" If you then add that config to your config file (find it with `rclone config file`) then you can access all the shared drives in one place with the `AllDrives:` remote. See [the Google Drive docs](https://rclone.org/drive/#drives) for full info. ### Standard options Here are the Standard options specific to combine (Combine several remotes into one). #### --combine-upstreams Upstreams for combining These should be in the form dir=remote:path dir2=remote2:path Where before the = is specified the root directory and after is the remote to put there. Embedded spaces can be added using quotes "dir=remote:path with space" "dir2=remote2:path with space" Properties: - Config: upstreams - Env Var: RCLONE_COMBINE_UPSTREAMS - Type: SpaceSepList - Default: ### Advanced options Here are the Advanced options specific to combine (Combine several remotes into one). #### --combine-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_COMBINE_DESCRIPTION - Type: string - Required: false ### Metadata Any metadata supported by the underlying remote is read and written. See the [metadata](https://rclone.org/docs/#metadata) docs for more info. # DOI The DOI remote is a read only remote for reading files from digital object identifiers (DOI). Currently, the DOI backend supports DOIs hosted with: - [InvenioRDM](https://inveniosoftware.org/products/rdm/) - [Zenodo](https://zenodo.org) - [CaltechDATA](https://data.caltech.edu) - [Other InvenioRDM repositories](https://inveniosoftware.org/showcase/) - [Dataverse](https://dataverse.org) - [Harvard Dataverse](https://dataverse.harvard.edu) - [Other Dataverse repositories](https://dataverse.org/installations) Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configuration Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / DOI datasets \ (doi) [snip] Storage> doi Option doi. The DOI or the doi.org URL. Enter a value. doi> 10.5281/zenodo.5876941 Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: doi - doi: 10.5281/zenodo.5876941 Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ### Standard options Here are the Standard options specific to doi (DOI datasets). #### --doi-doi The DOI or the doi.org URL. Properties: - Config: doi - Env Var: RCLONE_DOI_DOI - Type: string - Required: true ### Advanced options Here are the Advanced options specific to doi (DOI datasets). #### --doi-provider DOI provider. The DOI provider can be set when rclone does not automatically recognize a supported DOI provider. Properties: - Config: provider - Env Var: RCLONE_DOI_PROVIDER - Type: string - Required: false - Examples: - "auto" - Auto-detect provider - "zenodo" - Zenodo - "dataverse" - Dataverse - "invenio" - Invenio #### --doi-doi-resolver-api-url The URL of the DOI resolver API to use. The DOI resolver can be set for testing or for cases when the the canonical DOI resolver API cannot be used. Defaults to "https://doi.org/api". Properties: - Config: doi_resolver_api_url - Env Var: RCLONE_DOI_DOI_RESOLVER_API_URL - Type: string - Required: false #### --doi-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_DOI_DESCRIPTION - Type: string - Required: false ## Backend commands Here are the commands specific to the doi backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the [backend](https://rclone.org/commands/rclone_backend/) command for more info on how to pass options and arguments. These can be run on a running backend using the rc command [backend/command](https://rclone.org/rc/#backend-command). ### metadata Show metadata about the DOI. rclone backend metadata remote: [options] [+] This command returns a JSON object with some information about the DOI. rclone backend medatadata doi: It returns a JSON object representing metadata about the DOI. ### set Set command for updating the config parameters. rclone backend set remote: [options] [+] This set command can be used to update the config parameters for a running doi backend. Usage Examples: rclone backend set doi: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=doi: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=doi: -o doi=NEW_DOI The option keys are named as they are in the config file. This rebuilds the connection to the doi backend when it is called with the new parameters. Only new parameters need be passed as the values will default to those currently in use. It doesn't return anything. # Dropbox Paths are specified as `remote:path` Dropbox paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configuration The initial setup for dropbox involves getting a token from Dropbox which you need to do in your browser. `rclone config` walks you through it. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` n) New remote d) Delete remote q) Quit config e/n/d/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Dropbox \ "dropbox" [snip] Storage> dropbox Dropbox App Key - leave blank normally. app_key> Dropbox App Secret - leave blank normally. app_secret> Remote config Please visit: https://www.dropbox.com/1/oauth2/authorize?client_id=XXXXXXXXXXXXXXX&response_type=code Enter the code: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX_XXXXXXXXXX Configuration complete. Options: - type: dropbox - app_key: - app_secret: - token: XXXXXXXXXXXXXXXXXXXXXXXXXXXXX_XXXX_XXXXXXXXXXXXXXXXXXXXXXXXXXXXX Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` See the [remote setup docs](https://rclone.org/remote_setup/) for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Dropbox. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on `http://127.0.0.1:53682/` and it may require you to unblock it temporarily if you are running a host firewall, or use manual mode. You can then use it like this, List directories in top level of your dropbox rclone lsd remote: List all the files in your dropbox rclone ls remote: To copy a local directory to a dropbox directory called backup rclone copy /home/source remote:backup ### Dropbox for business Rclone supports Dropbox for business and Team Folders. When using Dropbox for business `remote:` and `remote:path/to/file` will refer to your personal folder. If you wish to see Team Folders you must use a leading `/` in the path, so `rclone lsd remote:/` will refer to the root and show you all Team Folders and your User Folder. You can then use team folders like this `remote:/TeamFolder` and `remote:/TeamFolder/path/to/file`. A leading `/` for a Dropbox personal account will do nothing, but it will take an extra HTTP transaction so it should be avoided. ### Modification times and hashes Dropbox supports modified times, but the only way to set a modification time is to re-upload the file. This means that if you uploaded your data with an older version of rclone which didn't support the v2 API and modified times, rclone will decide to upload all your old data to fix the modification times. If you don't want this to happen use `--size-only` or `--checksum` flag to stop it. Dropbox supports [its own hash type](https://www.dropbox.com/developers/reference/content-hash) which is checked for all transfers. ### Restricted filename characters | Character | Value | Replacement | | --------- |:-----:|:-----------:| | NUL | 0x00 | ␀ | | / | 0x2F | ／ | | DEL | 0x7F | ␡ | | \ | 0x5C | ＼ | File names can also not end with the following characters. These only get replaced if they are the last character in the name: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | SP | 0x20 | ␠ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Batch mode uploads {#batch-mode} Using batch mode uploads is very important for performance when using the Dropbox API. See [the dropbox performance guide](https://developers.dropbox.com/dbx-performance-guide) for more info. There are 3 modes rclone can use for uploads. #### --dropbox-batch-mode off In this mode rclone will not use upload batching. This was the default before rclone v1.55. It has the disadvantage that it is very likely to encounter `too_many_requests` errors like this NOTICE: too_many_requests/.: Too many requests or write operations. Trying again in 15 seconds. When rclone receives these it has to wait for 15s or sometimes 300s before continuing which really slows down transfers. This will happen especially if `--transfers` is large, so this mode isn't recommended except for compatibility or investigating problems. #### --dropbox-batch-mode sync In this mode rclone will batch up uploads to the size specified by `--dropbox-batch-size` and commit them together. Using this mode means you can use a much higher `--transfers` parameter (32 or 64 works fine) without receiving `too_many_requests` errors. This mode ensures full data integrity. Note that there may be a pause when quitting rclone while rclone finishes up the last batch using this mode. #### --dropbox-batch-mode async In this mode rclone will batch up uploads to the size specified by `--dropbox-batch-size` and commit them together. However it will not wait for the status of the batch to be returned to the caller. This means rclone can use a much bigger batch size (much bigger than `--transfers`), at the cost of not being able to check the status of the upload. This provides the maximum possible upload speed especially with lots of small files, however rclone can't check the file got uploaded properly using this mode. If you are using this mode then using "rclone check" after the transfer completes is recommended. Or you could do an initial transfer with `--dropbox-batch-mode async` then do a final transfer with `--dropbox-batch-mode sync` (the default). Note that there may be a pause when quitting rclone while rclone finishes up the last batch using this mode. ### Exporting files Certain files in Dropbox are "exportable", such as Dropbox Paper documents. These files need to be converted to another format in order to be downloaded. Often multiple formats are available for conversion. When rclone downloads a exportable file, it chooses the format to download based on the `--dropbox-export-formats` setting. By default, the export formats are `html,md`, which are sensible defaults for Dropbox Paper. Rclone chooses the first format ID in the export formats list that Dropbox supports for a given file. If no format in the list is usable, rclone will choose the default format that Dropbox suggests. Rclone will change the extension to correspond to the export format. Here are some examples of how extensions are mapped: | File type | Filename in Dropbox | Filename in rclone | |----------------|---------------------|--------------------| | Paper | mydoc.paper | mydoc.html | | Paper template | mydoc.papert | mydoc.papert.html | | other | mydoc | mydoc.html | _Importing_ exportable files is not yet supported by rclone. Here are the supported export extensions known by rclone. Note that rclone does not currently support other formats not on this list, even if Dropbox supports them. Also, Dropbox could change the list of supported formats at any time. | Format ID | Name | Description | |-----------|----------|----------------------| | html | HTML | HTML document | | md | Markdown | Markdown text format | ### Standard options Here are the Standard options specific to dropbox (Dropbox). #### --dropbox-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_DROPBOX_CLIENT_ID - Type: string - Required: false #### --dropbox-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_DROPBOX_CLIENT_SECRET - Type: string - Required: false ### Advanced options Here are the Advanced options specific to dropbox (Dropbox). #### --dropbox-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_DROPBOX_TOKEN - Type: string - Required: false #### --dropbox-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_DROPBOX_AUTH_URL - Type: string - Required: false #### --dropbox-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_DROPBOX_TOKEN_URL - Type: string - Required: false #### --dropbox-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_DROPBOX_CLIENT_CREDENTIALS - Type: bool - Default: false #### --dropbox-chunk-size Upload chunk size (< 150Mi). Any files larger than this will be uploaded in chunks of this size. Note that chunks are buffered in memory (one at a time) so rclone can deal with retries. Setting this larger will increase the speed slightly (at most 10% for 128 MiB in tests) at the cost of using more memory. It can be set smaller if you are tight on memory. Properties: - Config: chunk_size - Env Var: RCLONE_DROPBOX_CHUNK_SIZE - Type: SizeSuffix - Default: 48Mi #### --dropbox-impersonate Impersonate this user when using a business account. Note that if you want to use impersonate, you should make sure this flag is set when running "rclone config" as this will cause rclone to request the "members.read" scope which it won't normally. This is needed to lookup a members email address into the internal ID that dropbox uses in the API. Using the "members.read" scope will require a Dropbox Team Admin to approve during the OAuth flow. You will have to use your own App (setting your own client_id and client_secret) to use this option as currently rclone's default set of permissions doesn't include "members.read". This can be added once v1.55 or later is in use everywhere. Properties: - Config: impersonate - Env Var: RCLONE_DROPBOX_IMPERSONATE - Type: string - Required: false #### --dropbox-shared-files Instructs rclone to work on individual shared files. In this mode rclone's features are extremely limited - only list (ls, lsl, etc.) operations and read operations (e.g. downloading) are supported in this mode. All other operations will be disabled. Properties: - Config: shared_files - Env Var: RCLONE_DROPBOX_SHARED_FILES - Type: bool - Default: false #### --dropbox-shared-folders Instructs rclone to work on shared folders. When this flag is used with no path only the List operation is supported and all available shared folders will be listed. If you specify a path the first part will be interpreted as the name of shared folder. Rclone will then try to mount this shared to the root namespace. On success shared folder rclone proceeds normally. The shared folder is now pretty much a normal folder and all normal operations are supported. Note that we don't unmount the shared folder afterwards so the --dropbox-shared-folders can be omitted after the first use of a particular shared folder. See also --dropbox-root-namespace for an alternative way to work with shared folders. Properties: - Config: shared_folders - Env Var: RCLONE_DROPBOX_SHARED_FOLDERS - Type: bool - Default: false #### --dropbox-pacer-min-sleep Minimum time to sleep between API calls. Properties: - Config: pacer_min_sleep - Env Var: RCLONE_DROPBOX_PACER_MIN_SLEEP - Type: Duration - Default: 10ms #### --dropbox-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_DROPBOX_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,RightSpace,InvalidUtf8,Dot #### --dropbox-root-namespace Specify a different Dropbox namespace ID to use as the root for all paths. Properties: - Config: root_namespace - Env Var: RCLONE_DROPBOX_ROOT_NAMESPACE - Type: string - Required: false #### --dropbox-export-formats Comma separated list of preferred formats for exporting files Certain Dropbox files can only be accessed by exporting them to another format. These include Dropbox Paper documents. For each such file, rclone will choose the first format on this list that Dropbox considers valid. If none is valid, it will choose Dropbox's default format. Known formats include: "html", "md" (markdown) Properties: - Config: export_formats - Env Var: RCLONE_DROPBOX_EXPORT_FORMATS - Type: CommaSepList - Default: html,md #### --dropbox-skip-exports Skip exportable files in all listings. If given, exportable files practically become invisible to rclone. Properties: - Config: skip_exports - Env Var: RCLONE_DROPBOX_SKIP_EXPORTS - Type: bool - Default: false #### --dropbox-show-all-exports Show all exportable files in listings. Adding this flag will allow all exportable files to be server side copied. Note that rclone doesn't add extensions to the exportable file names in this mode. Do **not** use this flag when trying to download exportable files - rclone will fail to download them. Properties: - Config: show_all_exports - Env Var: RCLONE_DROPBOX_SHOW_ALL_EXPORTS - Type: bool - Default: false #### --dropbox-batch-mode Upload file batching sync|async|off. This sets the batch mode used by rclone. For full info see [the main docs](https://rclone.org/dropbox/#batch-mode) This has 3 possible values - off - no batching - sync - batch uploads and check completion (default) - async - batch upload and don't check completion Rclone will close any outstanding batches when it exits which may make a delay on quit. Properties: - Config: batch_mode - Env Var: RCLONE_DROPBOX_BATCH_MODE - Type: string - Default: "sync" #### --dropbox-batch-size Max number of files in upload batch. This sets the batch size of files to upload. It has to be less than 1000. By default this is 0 which means rclone will calculate the batch size depending on the setting of batch_mode. - batch_mode: async - default batch_size is 100 - batch_mode: sync - default batch_size is the same as --transfers - batch_mode: off - not in use Rclone will close any outstanding batches when it exits which may make a delay on quit. Setting this is a great idea if you are uploading lots of small files as it will make them a lot quicker. You can use --transfers 32 to maximise throughput. Properties: - Config: batch_size - Env Var: RCLONE_DROPBOX_BATCH_SIZE - Type: int - Default: 0 #### --dropbox-batch-timeout Max time to allow an idle upload batch before uploading. If an upload batch is idle for more than this long then it will be uploaded. The default for this is 0 which means rclone will choose a sensible default based on the batch_mode in use. - batch_mode: async - default batch_timeout is 10s - batch_mode: sync - default batch_timeout is 500ms - batch_mode: off - not in use Properties: - Config: batch_timeout - Env Var: RCLONE_DROPBOX_BATCH_TIMEOUT - Type: Duration - Default: 0s #### --dropbox-batch-commit-timeout Max time to wait for a batch to finish committing. (no longer used) Properties: - Config: batch_commit_timeout - Env Var: RCLONE_DROPBOX_BATCH_COMMIT_TIMEOUT - Type: Duration - Default: 10m0s #### --dropbox-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_DROPBOX_DESCRIPTION - Type: string - Required: false ## Limitations Note that Dropbox is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". There are some file names such as `thumbs.db` which Dropbox can't store. There is a full list of them in the ["Ignored Files" section of this document](https://www.dropbox.com/en/help/145). Rclone will issue an error message `File name disallowed - not uploading` if it attempts to upload one of those file names, but the sync won't fail. Some errors may occur if you try to sync copyright-protected files because Dropbox has its own [copyright detector](https://techcrunch.com/2014/03/30/how-dropbox-knows-when-youre-sharing-copyrighted-stuff-without-actually-looking-at-your-stuff/) that prevents this sort of file being downloaded. This will return the error `ERROR : /path/to/your/file: Failed to copy: failed to open source object: path/restricted_content/.` If you have more than 10,000 files in a directory then `rclone purge dropbox:dir` will return the error `Failed to purge: There are too many files involved in this operation`. As a work-around do an `rclone delete dropbox:dir` followed by an `rclone rmdir dropbox:dir`. When using `rclone link` you'll need to set `--expire` if using a non-personal account otherwise the visibility may not be correct. (Note that `--expire` isn't supported on personal accounts). See the [forum discussion](https://forum.rclone.org/t/rclone-link-dropbox-permissions/23211) and the [dropbox SDK issue](https://github.com/dropbox/dropbox-sdk-go-unofficial/issues/75). Modification times for Dropbox Paper documents are not exact, and may not change for some period after the document is edited. To make sure you get recent changes in a sync, either wait an hour or so, or use `--ignore-times` to force a full sync. ## Get your own Dropbox App ID When you use rclone with Dropbox in its default configuration you are using rclone's App ID. This is shared between all the rclone users. Here is how to create your own Dropbox App ID for rclone: 1. Log into the [Dropbox App console](https://www.dropbox.com/developers/apps/create) with your Dropbox Account (It need not to be the same account as the Dropbox you want to access) 2. Choose an API => Usually this should be `Dropbox API` 3. Choose the type of access you want to use => `Full Dropbox` or `App Folder`. If you want to use Team Folders, `Full Dropbox` is required ([see here](https://www.dropboxforum.com/t5/Dropbox-API-Support-Feedback/How-to-create-team-folder-inside-my-app-s-folder/m-p/601005/highlight/true#M27911)). 4. Name your App. The app name is global, so you can't use `rclone` for example 5. Click the button `Create App` 6. Switch to the `Permissions` tab. Enable at least the following permissions: `account_info.read`, `files.metadata.write`, `files.content.write`, `files.content.read`, `sharing.write`. The `files.metadata.read` and `sharing.read` checkboxes will be marked too. Click `Submit` 7. Switch to the `Settings` tab. Fill `OAuth2 - Redirect URIs` as `http://localhost:53682/` and click on `Add` 8. Find the `App key` and `App secret` values on the `Settings` tab. Use these values in rclone config to add a new remote or edit an existing remote. The `App key` setting corresponds to `client_id` in rclone config, the `App secret` corresponds to `client_secret` # Enterprise File Fabric This backend supports [Storage Made Easy's Enterprise File Fabric™](https://storagemadeeasy.com/about/) which provides a software solution to integrate and unify File and Object Storage accessible through a global file system. ## Configuration The initial setup for the Enterprise File Fabric backend involves getting a token from the Enterprise File Fabric which you need to do in your browser. `rclone config` walks you through it. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Enterprise File Fabric \ "filefabric" [snip] Storage> filefabric ** See help for filefabric backend at: https://rclone.org/filefabric/ ** URL of the Enterprise File Fabric to connect to Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Storage Made Easy US \ "https://storagemadeeasy.com" 2 / Storage Made Easy EU \ "https://eu.storagemadeeasy.com" 3 / Connect to your Enterprise File Fabric \ "https://yourfabric.smestorage.com" url> https://yourfabric.smestorage.com/ ID of the root folder Leave blank normally. Fill in to make rclone start with directory of a given ID. Enter a string value. Press Enter for the default (""). root_folder_id> Permanent Authentication Token A Permanent Authentication Token can be created in the Enterprise File Fabric, on the users Dashboard under Security, there is an entry you'll see called "My Authentication Tokens". Click the Manage button to create one. These tokens are normally valid for several years. For more info see: https://docs.storagemadeeasy.com/organisationcloud/api-tokens Enter a string value. Press Enter for the default (""). permanent_token> xxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config Configuration complete. Options: - type: filefabric - url: https://yourfabric.smestorage.com/ - permanent_token: xxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` Once configured you can then use `rclone` like this, List directories in top level of your Enterprise File Fabric rclone lsd remote: List all the files in your Enterprise File Fabric rclone ls remote: To copy a local directory to an Enterprise File Fabric directory called backup rclone copy /home/source remote:backup ### Modification times and hashes The Enterprise File Fabric allows modification times to be set on files accurate to 1 second. These will be used to detect whether objects need syncing or not. The Enterprise File Fabric does not support any data hashes at this time. ### Restricted filename characters The [default restricted characters set](https://rclone.org/overview/#restricted-characters) will be replaced. Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Empty files Empty files aren't supported by the Enterprise File Fabric. Rclone will therefore upload an empty file as a single space with a mime type of `application/vnd.rclone.empty.file` and files with that mime type are treated as empty. ### Root folder ID ### You can set the `root_folder_id` for rclone. This is the directory (identified by its `Folder ID`) that rclone considers to be the root of your Enterprise File Fabric. Normally you will leave this blank and rclone will determine the correct root to use itself. However you can set this to restrict rclone to a specific folder hierarchy. In order to do this you will have to find the `Folder ID` of the directory you wish rclone to display. These aren't displayed in the web interface, but you can use `rclone lsf` to find them, for example ``` $ rclone lsf --dirs-only -Fip --csv filefabric: 120673758,Burnt PDFs/ 120673759,My Quick Uploads/ 120673755,My Syncs/ 120673756,My backups/ 120673757,My contacts/ 120673761,S3 Storage/ ``` The ID for "S3 Storage" would be `120673761`. ### Standard options Here are the Standard options specific to filefabric (Enterprise File Fabric). #### --filefabric-url URL of the Enterprise File Fabric to connect to. Properties: - Config: url - Env Var: RCLONE_FILEFABRIC_URL - Type: string - Required: true - Examples: - "https://storagemadeeasy.com" - Storage Made Easy US - "https://eu.storagemadeeasy.com" - Storage Made Easy EU - "https://yourfabric.smestorage.com" - Connect to your Enterprise File Fabric #### --filefabric-root-folder-id ID of the root folder. Leave blank normally. Fill in to make rclone start with directory of a given ID. Properties: - Config: root_folder_id - Env Var: RCLONE_FILEFABRIC_ROOT_FOLDER_ID - Type: string - Required: false #### --filefabric-permanent-token Permanent Authentication Token. A Permanent Authentication Token can be created in the Enterprise File Fabric, on the users Dashboard under Security, there is an entry you'll see called "My Authentication Tokens". Click the Manage button to create one. These tokens are normally valid for several years. For more info see: https://docs.storagemadeeasy.com/organisationcloud/api-tokens Properties: - Config: permanent_token - Env Var: RCLONE_FILEFABRIC_PERMANENT_TOKEN - Type: string - Required: false ### Advanced options Here are the Advanced options specific to filefabric (Enterprise File Fabric). #### --filefabric-token Session Token. This is a session token which rclone caches in the config file. It is usually valid for 1 hour. Don't set this value - rclone will set it automatically. Properties: - Config: token - Env Var: RCLONE_FILEFABRIC_TOKEN - Type: string - Required: false #### --filefabric-token-expiry Token expiry time. Don't set this value - rclone will set it automatically. Properties: - Config: token_expiry - Env Var: RCLONE_FILEFABRIC_TOKEN_EXPIRY - Type: string - Required: false #### --filefabric-version Version read from the file fabric. Don't set this value - rclone will set it automatically. Properties: - Config: version - Env Var: RCLONE_FILEFABRIC_VERSION - Type: string - Required: false #### --filefabric-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_FILEFABRIC_ENCODING - Type: Encoding - Default: Slash,Del,Ctl,InvalidUtf8,Dot #### --filefabric-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_FILEFABRIC_DESCRIPTION - Type: string - Required: false # FileLu [FileLu](https://filelu.com/) is a reliable cloud storage provider offering features like secure file uploads, downloads, flexible storage options, and sharing capabilities. With support for high storage limits and seamless integration with rclone, FileLu makes managing files in the cloud easy. Its cross-platform file backup services let you upload and back up files from any internet-connected device. ## Configuration Here is an example of how to make a remote called `filelu`. First, run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> filelu Type of storage to configure. Choose a number from below, or type in your own value [snip] xx / FileLu Cloud Storage \ "filelu" [snip] Storage> filelu Enter your FileLu Rclone Key: key> YOUR_FILELU_RCLONE_KEY RC_xxxxxxxxxxxxxxxxxxxxxxxx Configuration complete. Keep this "filelu" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` ### Paths A path without an initial `/` will operate in the `Rclone` directory. A path with an initial `/` will operate at the root where you can see the `Rclone` directory. ``` $ rclone lsf TestFileLu:/ CCTV/ Camera/ Documents/ Music/ Photos/ Rclone/ Vault/ Videos/ ``` ### Example Commands Create a new folder named `foldername` in the `Rclone` directory: rclone mkdir filelu:foldername Delete a folder on FileLu: rclone rmdir filelu:/folder/path/ Delete a file on FileLu: rclone delete filelu:/hello.txt List files from your FileLu account: rclone ls filelu: List all folders: rclone lsd filelu: Copy a specific file to the FileLu root: rclone copy D:\\hello.txt filelu: Copy files from a local directory to a FileLu directory: rclone copy D:/local-folder filelu:/remote-folder/path/ Download a file from FileLu into a local directory: rclone copy filelu:/file-path/hello.txt D:/local-folder Move files from a local directory to a FileLu directory: rclone move D:\\local-folder filelu:/remote-path/ Sync files from a local directory to a FileLu directory: rclone sync --interactive D:/local-folder filelu:/remote-path/ Mount remote to local Linux: rclone mount filelu: /root/mnt --vfs-cache-mode full Mount remote to local Windows: rclone mount filelu: D:/local_mnt --vfs-cache-mode full Get storage info about the FileLu account: rclone about filelu: All the other rclone commands are supported by this backend. ### FolderID instead of folder path We use the FolderID instead of the folder name to prevent errors when users have identical folder names or paths. For example, if a user has two or three folders named "test_folders," the system may become confused and won't know which folder to move. In large storage systems, some clients have hundred of thousands of folders and a few millions of files, duplicate folder names or paths are quite common. ### Modification Times and Hashes FileLu supports both modification times and MD5 hashes. FileLu only supports filenames and folder names up to 255 characters in length, where a character is a Unicode character. ### Duplicated Files When uploading and syncing via Rclone, FileLu does not allow uploading duplicate files within the same directory. However, you can upload duplicate files, provided they are in different directories (folders). ### Failure to Log / Invalid Credentials or KEY Ensure that you have the correct Rclone key, which can be found in [My Account](https://filelu.com/account/). Every time you toggle Rclone OFF and ON in My Account, a new RC_xxxxxxxxxxxxxxxxxxxx key is generated. Be sure to update your Rclone configuration with the new key. If you are connecting to your FileLu remote for the first time and encounter an error such as: ``` Failed to create file system for "my-filelu-remote:": couldn't login: Invalid credentials ``` Ensure your Rclone Key is correct. ### Process `killed` Accounts with large files or extensive metadata may experience significant memory usage during list/sync operations. Ensure the system running `rclone` has sufficient memory and CPU to handle these operations. ### Standard options Here are the Standard options specific to filelu (FileLu Cloud Storage). #### --filelu-key Your FileLu Rclone key from My Account Properties: - Config: key - Env Var: RCLONE_FILELU_KEY - Type: string - Required: true ### Advanced options Here are the Advanced options specific to filelu (FileLu Cloud Storage). #### --filelu-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_FILELU_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,SingleQuote,BackQuote,Dollar,Colon,Question,Asterisk,Pipe,Hash,Percent,BackSlash,CrLf,Del,Ctl,LeftSpace,LeftPeriod,LeftTilde,LeftCrLfHtVt,RightSpace,RightPeriod,RightCrLfHtVt,InvalidUtf8,Dot,SquareBracket,Semicolon,Exclamation #### --filelu-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_FILELU_DESCRIPTION - Type: string - Required: false ## Limitations This backend uses a custom library implementing the FileLu API. While it supports file transfers, some advanced features may not yet be available. Please report any issues to the [rclone forum](https://forum.rclone.org/) for troubleshooting and updates. For further information, visit [FileLu's website](https://filelu.com/). # Files.com [Files.com](https://www.files.com/) is a cloud storage service that provides a secure and easy way to store and share files. The initial setup for filescom involves authenticating with your Files.com account. You can do this by providing your site subdomain, username, and password. Alternatively, you can authenticate using an API Key from [Files.com](https://www.files.com/docs/sdk-and-apis/api-keys/). `rclone config` walks you through it. ## Configuration Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Files.com \ "filescom" [snip] Storage> filescom Option site. Your site subdomain (e.g. mysite) or custom domain (e.g. myfiles.customdomain.com) Enter a value. Press Enter to leave empty. site> mysite Option username. The username used to authenticate with Files.com. Enter a value. Press Enter to leave empty. username> user Option password. The password used to authenticate with Files.com. Choose an alternative below. Press Enter for the default (n). y) Yes, type in my own password g) Generate random password n) No, leave this optional password blank (default) y/g/n> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: filescom - site: mysite - username: user - password: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Once configured you can use rclone. See all files in the top level: rclone lsf remote: Make a new directory in the root: rclone mkdir remote:dir Recursively List the contents: rclone ls remote: Sync `/home/local/directory` to the remote directory, deleting any excess files in the directory. rclone sync --interactive /home/local/directory remote:dir ### Hashes In December 2024 `files.com` started [supporting more checksums](https://www.files.com/blog/2024/11/01/new-modern-checksum-options-now-available-with-opt). However if you want hashes you **must** enable them in your site by visiting the "File Integrity" section in "Data Governance" to configure your settings and select the checksum algorithms that meet your requirements. Rclone currently only support CRC32 and MD5 for use in syncing but selecting more checksums will not affect rclone's operations. For use with rclone, selecting at least MD5 is recommended so rclone can do an end to end integrity check. ### Standard options Here are the Standard options specific to filescom (Files.com). #### --filescom-site Your site subdomain (e.g. mysite) or custom domain (e.g. myfiles.customdomain.com). Properties: - Config: site - Env Var: RCLONE_FILESCOM_SITE - Type: string - Required: false #### --filescom-username The username used to authenticate with Files.com. Properties: - Config: username - Env Var: RCLONE_FILESCOM_USERNAME - Type: string - Required: false #### --filescom-password The password used to authenticate with Files.com. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: password - Env Var: RCLONE_FILESCOM_PASSWORD - Type: string - Required: false ### Advanced options Here are the Advanced options specific to filescom (Files.com). #### --filescom-api-key The API key used to authenticate with Files.com. Properties: - Config: api_key - Env Var: RCLONE_FILESCOM_API_KEY - Type: string - Required: false #### --filescom-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_FILESCOM_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,RightSpace,RightCrLfHtVt,InvalidUtf8,Dot #### --filescom-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_FILESCOM_DESCRIPTION - Type: string - Required: false # FTP FTP is the File Transfer Protocol. Rclone FTP support is provided using the [github.com/jlaffaye/ftp](https://godoc.org/github.com/jlaffaye/ftp) package. [Limitations of Rclone's FTP backend](#limitations) Paths are specified as `remote:path`. If the path does not begin with a `/` it is relative to the home directory of the user. An empty path `remote:` refers to the user's home directory. ## Configuration To create an FTP configuration named `remote`, run rclone config Rclone config guides you through an interactive setup process. A minimal rclone FTP remote definition only requires host, username and password. For an anonymous FTP server, see [below](#anonymous-ftp). ``` No remotes found, make a new one? n) New remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config n/r/c/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / FTP \ "ftp" [snip] Storage> ftp ** See help for ftp backend at: https://rclone.org/ftp/ ** FTP host to connect to Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Connect to ftp.example.com \ "ftp.example.com" host> ftp.example.com FTP username Enter a string value. Press Enter for the default ("$USER"). user> FTP port number Enter a signed integer. Press Enter for the default (21). port> FTP password y) Yes type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Use FTP over TLS (Implicit) Enter a boolean value (true or false). Press Enter for the default ("false"). tls> Use FTP over TLS (Explicit) Enter a boolean value (true or false). Press Enter for the default ("false"). explicit_tls> Remote config Configuration complete. Options: - type: ftp - host: ftp.example.com - pass: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` To see all directories in the home directory of `remote` rclone lsd remote: Make a new directory rclone mkdir remote:path/to/directory List the contents of a directory rclone ls remote:path/to/directory Sync `/home/local/directory` to the remote directory, deleting any excess files in the directory. rclone sync --interactive /home/local/directory remote:directory ### Anonymous FTP When connecting to a FTP server that allows anonymous login, you can use the special "anonymous" username. Traditionally, this user account accepts any string as a password, although it is common to use either the password "anonymous" or "guest". Some servers require the use of a valid e-mail address as password. Using [on-the-fly](#backend-path-to-dir) or [connection string](https://rclone.org/docs/#connection-strings) remotes makes it easy to access such servers, without requiring any configuration in advance. The following are examples of that: rclone lsf :ftp: --ftp-host=speedtest.tele2.net --ftp-user=anonymous --ftp-pass=$(rclone obscure dummy) rclone lsf :ftp,host=speedtest.tele2.net,user=anonymous,pass=$(rclone obscure dummy): The above examples work in Linux shells and in PowerShell, but not Windows Command Prompt. They execute the [rclone obscure](https://rclone.org/commands/rclone_obscure/) command to create a password string in the format required by the [pass](#ftp-pass) option. The following examples are exactly the same, except use an already obscured string representation of the same password "dummy", and therefore works even in Windows Command Prompt: rclone lsf :ftp: --ftp-host=speedtest.tele2.net --ftp-user=anonymous --ftp-pass=IXs2wc8OJOz7SYLBk47Ji1rHTmxM rclone lsf :ftp,host=speedtest.tele2.net,user=anonymous,pass=IXs2wc8OJOz7SYLBk47Ji1rHTmxM: ### Implicit TLS Rlone FTP supports implicit FTP over TLS servers (FTPS). This has to be enabled in the FTP backend config for the remote, or with [`--ftp-tls`](#ftp-tls). The default FTPS port is `990`, not `21` and can be set with [`--ftp-port`](#ftp-port). ## TLS Options TLS options for Implicit and Explicit TLS can be set using the following flags which are specific to the FTP backend: ``` --ftp-no-check-certificate Do not verify the TLS certificate of the server --ftp-disable-tls13 Disable TLS 1.3 (workaround for FTP servers with buggy TLS) --ftp-tls-cache-size int Size of TLS session cache for all control and data connections (default 32) ``` However any of the global TLS flags can also be used such as: ``` --ca-cert stringArray CA certificate used to verify servers --client-cert string Client SSL certificate (PEM) for mutual TLS auth --client-key string Client SSL private key (PEM) for mutual TLS auth --no-check-certificate Do not verify the server SSL certificate (insecure) ``` If these need to be put in the config file so they apply to just the FTP backend then use the `override` syntax, eg ``` override.ca_cert = XXX override.client_cert = XXX override.client_key = XXX ``` ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: File names cannot end with the following characters. Replacement is limited to the last character in a file name: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | SP | 0x20 | ␠ | Not all FTP servers can have all characters in file names, for example: | FTP Server| Forbidden characters | | --------- |:--------------------:| | proftpd | `*` | | pureftpd | `\ [ ]` | This backend's interactive configuration wizard provides a selection of sensible encoding settings for major FTP servers: ProFTPd, PureFTPd, VsFTPd. Just hit a selection number when prompted. ### Standard options Here are the Standard options specific to ftp (FTP). #### --ftp-host FTP host to connect to. E.g. "ftp.example.com". Properties: - Config: host - Env Var: RCLONE_FTP_HOST - Type: string - Required: true #### --ftp-user FTP username. Properties: - Config: user - Env Var: RCLONE_FTP_USER - Type: string - Default: "$USER" #### --ftp-port FTP port number. Properties: - Config: port - Env Var: RCLONE_FTP_PORT - Type: int - Default: 21 #### --ftp-pass FTP password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: pass - Env Var: RCLONE_FTP_PASS - Type: string - Required: false #### --ftp-tls Use Implicit FTPS (FTP over TLS). When using implicit FTP over TLS the client connects using TLS right from the start which breaks compatibility with non-TLS-aware servers. This is usually served over port 990 rather than port 21. Cannot be used in combination with explicit FTPS. Properties: - Config: tls - Env Var: RCLONE_FTP_TLS - Type: bool - Default: false #### --ftp-explicit-tls Use Explicit FTPS (FTP over TLS). When using explicit FTP over TLS the client explicitly requests security from the server in order to upgrade a plain text connection to an encrypted one. Cannot be used in combination with implicit FTPS. Properties: - Config: explicit_tls - Env Var: RCLONE_FTP_EXPLICIT_TLS - Type: bool - Default: false ### Advanced options Here are the Advanced options specific to ftp (FTP). #### --ftp-concurrency Maximum number of FTP simultaneous connections, 0 for unlimited. Note that setting this is very likely to cause deadlocks so it should be used with care. If you are doing a sync or copy then make sure concurrency is one more than the sum of `--transfers` and `--checkers`. If you use `--check-first` then it just needs to be one more than the maximum of `--checkers` and `--transfers`. So for `concurrency 3` you'd use `--checkers 2 --transfers 2 --check-first` or `--checkers 1 --transfers 1`. Properties: - Config: concurrency - Env Var: RCLONE_FTP_CONCURRENCY - Type: int - Default: 0 #### --ftp-no-check-certificate Do not verify the TLS certificate of the server. Properties: - Config: no_check_certificate - Env Var: RCLONE_FTP_NO_CHECK_CERTIFICATE - Type: bool - Default: false #### --ftp-disable-epsv Disable using EPSV even if server advertises support. Properties: - Config: disable_epsv - Env Var: RCLONE_FTP_DISABLE_EPSV - Type: bool - Default: false #### --ftp-disable-mlsd Disable using MLSD even if server advertises support. Properties: - Config: disable_mlsd - Env Var: RCLONE_FTP_DISABLE_MLSD - Type: bool - Default: false #### --ftp-disable-utf8 Disable using UTF-8 even if server advertises support. Properties: - Config: disable_utf8 - Env Var: RCLONE_FTP_DISABLE_UTF8 - Type: bool - Default: false #### --ftp-writing-mdtm Use MDTM to set modification time (VsFtpd quirk) Properties: - Config: writing_mdtm - Env Var: RCLONE_FTP_WRITING_MDTM - Type: bool - Default: false #### --ftp-force-list-hidden Use LIST -a to force listing of hidden files and folders. This will disable the use of MLSD. Properties: - Config: force_list_hidden - Env Var: RCLONE_FTP_FORCE_LIST_HIDDEN - Type: bool - Default: false #### --ftp-idle-timeout Max time before closing idle connections. If no connections have been returned to the connection pool in the time given, rclone will empty the connection pool. Set to 0 to keep connections indefinitely. Properties: - Config: idle_timeout - Env Var: RCLONE_FTP_IDLE_TIMEOUT - Type: Duration - Default: 1m0s #### --ftp-close-timeout Maximum time to wait for a response to close. Properties: - Config: close_timeout - Env Var: RCLONE_FTP_CLOSE_TIMEOUT - Type: Duration - Default: 1m0s #### --ftp-tls-cache-size Size of TLS session cache for all control and data connections. TLS cache allows to resume TLS sessions and reuse PSK between connections. Increase if default size is not enough resulting in TLS resumption errors. Enabled by default. Use 0 to disable. Properties: - Config: tls_cache_size - Env Var: RCLONE_FTP_TLS_CACHE_SIZE - Type: int - Default: 32 #### --ftp-disable-tls13 Disable TLS 1.3 (workaround for FTP servers with buggy TLS) Properties: - Config: disable_tls13 - Env Var: RCLONE_FTP_DISABLE_TLS13 - Type: bool - Default: false #### --ftp-allow-insecure-tls-ciphers 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 Properties: - Config: allow_insecure_tls_ciphers - Env Var: RCLONE_FTP_ALLOW_INSECURE_TLS_CIPHERS - Type: bool - Default: false #### --ftp-shut-timeout Maximum time to wait for data connection closing status. Properties: - Config: shut_timeout - Env Var: RCLONE_FTP_SHUT_TIMEOUT - Type: Duration - Default: 1m0s #### --ftp-ask-password Allow asking for FTP password when needed. If this is set and no password is supplied then rclone will ask for a password Properties: - Config: ask_password - Env Var: RCLONE_FTP_ASK_PASSWORD - Type: bool - Default: false #### --ftp-socks-proxy Socks 5 proxy host. Supports the format user:pass@host:port, user@host:port, host:port. Example: myUser:myPass@localhost:9005 Properties: - Config: socks_proxy - Env Var: RCLONE_FTP_SOCKS_PROXY - Type: string - Required: false #### --ftp-http-proxy URL for HTTP CONNECT proxy Set this to a URL for an HTTP proxy which supports the HTTP CONNECT verb. Properties: - Config: http_proxy - Env Var: RCLONE_FTP_HTTP_PROXY - Type: string - Required: false #### --ftp-no-check-upload Don't check the upload is OK Normally rclone will try to check the upload exists after it has uploaded a file to make sure the size and modification time are as expected. This flag stops rclone doing these checks. This enables uploading to folders which are write only. You will likely need to use the --inplace flag also if uploading to a write only folder. Properties: - Config: no_check_upload - Env Var: RCLONE_FTP_NO_CHECK_UPLOAD - Type: bool - Default: false #### --ftp-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_FTP_ENCODING - Type: Encoding - Default: Slash,Del,Ctl,RightSpace,Dot - Examples: - "Asterisk,Ctl,Dot,Slash" - ProFTPd can't handle '*' in file names - "BackSlash,Ctl,Del,Dot,RightSpace,Slash,SquareBracket" - PureFTPd can't handle '[]' or '*' in file names - "Ctl,LeftPeriod,Slash" - VsFTPd can't handle file names starting with dot #### --ftp-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_FTP_DESCRIPTION - Type: string - Required: false ## Limitations FTP servers acting as rclone remotes must support `passive` mode. The mode cannot be configured as `passive` is the only supported one. Rclone's FTP implementation is not compatible with `active` mode as [the library it uses doesn't support it](https://github.com/jlaffaye/ftp/issues/29). This will likely never be supported due to security concerns. Rclone's FTP backend does not support any checksums but can compare file sizes. `rclone about` is not supported by the FTP backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) The implementation of : `--dump headers`, `--dump bodies`, `--dump auth` for debugging isn't the same as for rclone HTTP based backends - it has less fine grained control. `--timeout` isn't supported (but `--contimeout` is). `--bind` isn't supported. Rclone's FTP backend could support server-side move but does not at present. The `ftp_proxy` environment variable is not currently supported. ### Modification times File modification time (timestamps) is supported to 1 second resolution for major FTP servers: ProFTPd, PureFTPd, VsFTPd, and FileZilla FTP server. The `VsFTPd` server has non-standard implementation of time related protocol commands and needs a special configuration setting: `writing_mdtm = true`. Support for precise file time with other FTP servers varies depending on what protocol extensions they advertise. If all the `MLSD`, `MDTM` and `MFTM` extensions are present, rclone will use them together to provide precise time. Otherwise the times you see on the FTP server through rclone are those of the last file upload. You can use the following command to check whether rclone can use precise time with your FTP server: `rclone backend features your_ftp_remote:` (the trailing colon is important). Look for the number in the line tagged by `Precision` designating the remote time precision expressed as nanoseconds. A value of `1000000000` means that file time precision of 1 second is available. A value of `3153600000000000000` (or another large number) means "unsupported". # Gofile [Gofile](https://gofile.io) is a content storage and distribution platform. Its aim is to provide as much service as possible for free or at a very low price. The initial setup for Gofile involves logging in to the web interface and going to the "My Profile" section. Copy the "Account API token" for use in the config file. Note that if you wish to connect rclone to Gofile you will need a premium account. ## Configuration Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. XX / Gofile \ (gofile) Storage> gofile Option access_token. API Access token You can get this from the web control panel. Enter a value. Press Enter to leave empty. access_token> YOURACCESSTOKEN Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: gofile - access_token: YOURACCESSTOKEN Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` Once configured you can then use `rclone` like this, List directories and files in the top level of your Gofile rclone lsf remote: To copy a local directory to an Gofile directory called backup rclone copy /home/source remote:backup ### Modification times and hashes Gofile supports modification times with a resolution of 1 second. Gofile supports MD5 hashes, so you can use the `--checksum` flag. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | ! | 0x21 | ！ | | " | 0x22 | ＂ | | * | 0x2A | ＊ | | : | 0x3A | ： | | < | 0x3C | ＜ | | > | 0x3E | ＞ | | ? | 0x3F | ？ | | \ | 0x5C | ＼ | | \| | 0x7C | ｜ | File names can also not start or end with the following characters. These only get replaced if they are the first or last character in the name: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | . | 0x2E | ． | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Public Links Gofile supports `rclone link` to make public links to files or directories. If you specify a directory it will download as a `zip` file. You can use the `--expire` flag to specify the time the link should be valid. Note that `rclone link --unlink` removes all the public links for a file. ### Root folder ID You can set the `root_folder_id` for rclone. This is the directory (identified by its `Folder ID`) that rclone considers to be the root of your Gofile drive. Normally you will leave this blank and rclone will determine the correct root to use itself and fill in the value in the config file. However you can set this to restrict rclone to a specific folder hierarchy. In order to do this you will have to find the `Folder ID` of the directory you wish rclone to display. You can do this with rclone ``` $ rclone lsf -Fip --dirs-only remote: d6341f53-ee65-4f29-9f59-d11e8070b2a0;Files/ f4f5c9b8-6ece-478b-b03e-4538edfe5a1c;Photos/ d50e356c-29ca-4b27-a3a7-494d91026e04;Videos/ ``` The ID to use is the part before the `;` so you could set ``` root_folder_id = d6341f53-ee65-4f29-9f59-d11e8070b2a0 ``` To restrict rclone to the `Files` directory. ### Standard options Here are the Standard options specific to gofile (Gofile). #### --gofile-access-token API Access token You can get this from the web control panel. Properties: - Config: access_token - Env Var: RCLONE_GOFILE_ACCESS_TOKEN - Type: string - Required: false ### Advanced options Here are the Advanced options specific to gofile (Gofile). #### --gofile-root-folder-id ID of the root folder Leave this blank normally, rclone will fill it in automatically. If you want rclone to be restricted to a particular folder you can fill it in - see the docs for more info. Properties: - Config: root_folder_id - Env Var: RCLONE_GOFILE_ROOT_FOLDER_ID - Type: string - Required: false #### --gofile-account-id Account ID Leave this blank normally, rclone will fill it in automatically. Properties: - Config: account_id - Env Var: RCLONE_GOFILE_ACCOUNT_ID - Type: string - Required: false #### --gofile-list-chunk Number of items to list in each call Properties: - Config: list_chunk - Env Var: RCLONE_GOFILE_LIST_CHUNK - Type: int - Default: 1000 #### --gofile-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_GOFILE_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,LeftPeriod,RightPeriod,InvalidUtf8,Dot,Exclamation #### --gofile-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_GOFILE_DESCRIPTION - Type: string - Required: false ## Limitations Gofile only supports filenames up to 255 characters in length, where a character is a unicode character. Directories should not be cached for more than 24h otherwise files in the directory may not be downloadable. In practice this means when using a VFS based rclone command such as `rclone mount` you should make sure `--dir-cache-time` is less than `24h`. Note that Gofile is currently limited to a total of 100,000 items. If you attempt to upload more than that you will get `error-limit-100000`. This limit may be lifted in the future. ### Duplicated files Gofile is capable of having files with duplicated file names. For instance two files called `hello.txt` in the same directory. Rclone cannot sync that to a normal file system but it can be fixed with the `rclone dedupe` command. Duplicated files cause problems with the syncing and you will see messages in the log about duplicates. Use `rclone dedupe` to fix duplicated files. # Google Cloud Storage Paths are specified as `remote:bucket` (or `remote:` for the `lsd` command.) You may put subdirectories in too, e.g. `remote:bucket/path/to/dir`. ## Configuration The initial setup for google cloud storage involves getting a token from Google Cloud Storage which you need to do in your browser. `rclone config` walks you through it. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` n) New remote d) Delete remote q) Quit config e/n/d/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Google Cloud Storage (this is not Google Drive) \ "google cloud storage" [snip] Storage> google cloud storage Google Application Client Id - leave blank normally. client_id> Google Application Client Secret - leave blank normally. client_secret> Project number optional - needed only for list/create/delete buckets - see your developer console. project_number> 12345678 Service Account Credentials JSON file path - needed only if you want use SA instead of interactive login. service_account_file> Access Control List for new objects. Choose a number from below, or type in your own value 1 / Object owner gets OWNER access, and all Authenticated Users get READER access. \ "authenticatedRead" 2 / Object owner gets OWNER access, and project team owners get OWNER access. \ "bucketOwnerFullControl" 3 / Object owner gets OWNER access, and project team owners get READER access. \ "bucketOwnerRead" 4 / Object owner gets OWNER access [default if left blank]. \ "private" 5 / Object owner gets OWNER access, and project team members get access according to their roles. \ "projectPrivate" 6 / Object owner gets OWNER access, and all Users get READER access. \ "publicRead" object_acl> 4 Access Control List for new buckets. Choose a number from below, or type in your own value 1 / Project team owners get OWNER access, and all Authenticated Users get READER access. \ "authenticatedRead" 2 / Project team owners get OWNER access [default if left blank]. \ "private" 3 / Project team members get access according to their roles. \ "projectPrivate" 4 / Project team owners get OWNER access, and all Users get READER access. \ "publicRead" 5 / Project team owners get OWNER access, and all Users get WRITER access. \ "publicReadWrite" bucket_acl> 2 Location for the newly created buckets. Choose a number from below, or type in your own value 1 / Empty for default location (US). \ "" 2 / Multi-regional location for Asia. \ "asia" 3 / Multi-regional location for Europe. \ "eu" 4 / Multi-regional location for United States. \ "us" 5 / Taiwan. \ "asia-east1" 6 / Tokyo. \ "asia-northeast1" 7 / Singapore. \ "asia-southeast1" 8 / Sydney. \ "australia-southeast1" 9 / Belgium. \ "europe-west1" 10 / London. \ "europe-west2" 11 / Iowa. \ "us-central1" 12 / South Carolina. \ "us-east1" 13 / Northern Virginia. \ "us-east4" 14 / Oregon. \ "us-west1" location> 12 The storage class to use when storing objects in Google Cloud Storage. Choose a number from below, or type in your own value 1 / Default \ "" 2 / Multi-regional storage class \ "MULTI_REGIONAL" 3 / Regional storage class \ "REGIONAL" 4 / Nearline storage class \ "NEARLINE" 5 / Coldline storage class \ "COLDLINE" 6 / Durable reduced availability storage class \ "DURABLE_REDUCED_AVAILABILITY" storage_class> 5 Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: google cloud storage - client_id: - client_secret: - token: {"AccessToken":"xxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","RefreshToken":"x/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx_xxxxxxxxx","Expiry":"2014-07-17T20:49:14.929208288+01:00","Extra":null} - project_number: 12345678 - object_acl: private - bucket_acl: private Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` See the [remote setup docs](https://rclone.org/remote_setup/) for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Google if using web browser to automatically authenticate. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on `http://127.0.0.1:53682/` and this it may require you to unblock it temporarily if you are running a host firewall, or use manual mode. This remote is called `remote` and can now be used like this See all the buckets in your project rclone lsd remote: Make a new bucket rclone mkdir remote:bucket List the contents of a bucket rclone ls remote:bucket Sync `/home/local/directory` to the remote bucket, deleting any excess files in the bucket. rclone sync --interactive /home/local/directory remote:bucket ### Service Account support You can set up rclone with Google Cloud Storage in an unattended mode, i.e. not tied to a specific end-user Google account. This is useful when you want to synchronise files onto machines that don't have actively logged-in users, for example build machines. To get credentials for Google Cloud Platform [IAM Service Accounts](https://cloud.google.com/iam/docs/service-accounts), please head to the [Service Account](https://console.cloud.google.com/permissions/serviceaccounts) section of the Google Developer Console. Service Accounts behave just like normal `User` permissions in [Google Cloud Storage ACLs](https://cloud.google.com/storage/docs/access-control), so you can limit their access (e.g. make them read only). After creating an account, a JSON file containing the Service Account's credentials will be downloaded onto your machines. These credentials are what rclone will use for authentication. To use a Service Account instead of OAuth2 token flow, enter the path to your Service Account credentials at the `service_account_file` prompt and rclone won't use the browser based authentication flow. If you'd rather stuff the contents of the credentials file into the rclone config file, you can set `service_account_credentials` with the actual contents of the file instead, or set the equivalent environment variable. ### Service Account Authentication with Access Tokens Another option for service account authentication is to use access tokens via *gcloud impersonate-service-account*. Access tokens protect security by avoiding the use of the JSON key file, which can be breached. They also bypass oauth login flow, which is simpler on remote VMs that lack a web browser. If you already have a working service account, skip to step 3. #### 1. Create a service account using gcloud iam service-accounts create gcs-read-only You can re-use an existing service account as well (like the one created above) #### 2. Attach a Viewer (read-only) or User (read-write) role to the service account $ PROJECT_ID=my-project $ gcloud --verbose iam service-accounts add-iam-policy-binding \ gcs-read-only@${PROJECT_ID}.iam.gserviceaccount.com \ --member=serviceAccount:gcs-read-only@${PROJECT_ID}.iam.gserviceaccount.com \ --role=roles/storage.objectViewer Use the Google Cloud console to identify a limited role. Some relevant pre-defined roles: * *roles/storage.objectUser* -- read-write access but no admin privileges * *roles/storage.objectViewer* -- read-only access to objects * *roles/storage.admin* -- create buckets & administrative roles #### 3. Get a temporary access key for the service account $ gcloud auth application-default print-access-token \ --impersonate-service-account \ gcs-read-only@${PROJECT_ID}.iam.gserviceaccount.com ya29.c.c0ASRK0GbAFEewXD [truncated] #### 4. Update `access_token` setting hit `CTRL-C` when you see *waiting for code*. This will save the config without doing oauth flow rclone config update ${REMOTE_NAME} access_token ya29.c.c0Axxxx #### 5. Run rclone as usual rclone ls dev-gcs:${MY_BUCKET}/ ### More Info on Service Accounts * [Official GCS Docs](https://cloud.google.com/compute/docs/access/service-accounts) * [Guide on Service Accounts using Key Files (less secure, but similar concepts)](https://forum.rclone.org/t/access-using-google-service-account/24822/2) ### Anonymous Access For downloads of objects that permit public access you can configure rclone to use anonymous access by setting `anonymous` to `true`. With unauthorized access you can't write or create files but only read or list those buckets and objects that have public read access. ### Application Default Credentials If no other source of credentials is provided, rclone will fall back to [Application Default Credentials](https://cloud.google.com/video-intelligence/docs/common/auth#authenticating_with_application_default_credentials) this is useful both when you already have configured authentication for your developer account, or in production when running on a google compute host. Note that if running in docker, you may need to run additional commands on your google compute machine - [see this page](https://cloud.google.com/container-registry/docs/advanced-authentication#gcloud_as_a_docker_credential_helper). Note that in the case application default credentials are used, there is no need to explicitly configure a project number. ### --fast-list This remote supports `--fast-list` which allows you to use fewer transactions in exchange for more memory. See the [rclone docs](https://rclone.org/docs/#fast-list) for more details. ### Custom upload headers You can set custom upload headers with the `--header-upload` flag. Google Cloud Storage supports the headers as described in the [working with metadata documentation](https://cloud.google.com/storage/docs/gsutil/addlhelp/WorkingWithObjectMetadata) - Cache-Control - Content-Disposition - Content-Encoding - Content-Language - Content-Type - X-Goog-Storage-Class - X-Goog-Meta- Eg `--header-upload "Content-Type text/potato"` Note that the last of these is for setting custom metadata in the form `--header-upload "x-goog-meta-key: value"` ### Modification times Google Cloud Storage stores md5sum natively. Google's [gsutil](https://cloud.google.com/storage/docs/gsutil) tool stores modification time with one-second precision as `goog-reserved-file-mtime` in file metadata. To ensure compatibility with gsutil, rclone stores modification time in 2 separate metadata entries. `mtime` uses RFC3339 format with one-nanosecond precision. `goog-reserved-file-mtime` uses Unix timestamp format with one-second precision. To get modification time from object metadata, rclone reads the metadata in the following order: `mtime`, `goog-reserved-file-mtime`, object updated time. Note that rclone's default modify window is 1ns. Files uploaded by gsutil only contain timestamps with one-second precision. If you use rclone to sync files previously uploaded by gsutil, rclone will attempt to update modification time for all these files. To avoid these possibly unnecessary updates, use `--modify-window 1s`. ### Restricted filename characters | Character | Value | Replacement | | --------- |:-----:|:-----------:| | NUL | 0x00 | ␀ | | LF | 0x0A | ␊ | | CR | 0x0D | ␍ | | / | 0x2F | ／ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Standard options Here are the Standard options specific to google cloud storage (Google Cloud Storage (this is not Google Drive)). #### --gcs-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_GCS_CLIENT_ID - Type: string - Required: false #### --gcs-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_GCS_CLIENT_SECRET - Type: string - Required: false #### --gcs-project-number Project number. Optional - needed only for list/create/delete buckets - see your developer console. Properties: - Config: project_number - Env Var: RCLONE_GCS_PROJECT_NUMBER - Type: string - Required: false #### --gcs-user-project User project. Optional - needed only for requester pays. Properties: - Config: user_project - Env Var: RCLONE_GCS_USER_PROJECT - Type: string - Required: false #### --gcs-service-account-file Service Account Credentials JSON file path. Leave blank normally. Needed only if you want use SA instead of interactive login. Leading `~` will be expanded in the file name as will environment variables such as `${RCLONE_CONFIG_DIR}`. Properties: - Config: service_account_file - Env Var: RCLONE_GCS_SERVICE_ACCOUNT_FILE - Type: string - Required: false #### --gcs-service-account-credentials Service Account Credentials JSON blob. Leave blank normally. Needed only if you want use SA instead of interactive login. Properties: - Config: service_account_credentials - Env Var: RCLONE_GCS_SERVICE_ACCOUNT_CREDENTIALS - Type: string - Required: false #### --gcs-anonymous Access public buckets and objects without credentials. Set to 'true' if you just want to download files and don't configure credentials. Properties: - Config: anonymous - Env Var: RCLONE_GCS_ANONYMOUS - Type: bool - Default: false #### --gcs-object-acl Access Control List for new objects. Properties: - Config: object_acl - Env Var: RCLONE_GCS_OBJECT_ACL - Type: string - Required: false - Examples: - "authenticatedRead" - Object owner gets OWNER access. - All Authenticated Users get READER access. - "bucketOwnerFullControl" - Object owner gets OWNER access. - Project team owners get OWNER access. - "bucketOwnerRead" - Object owner gets OWNER access. - Project team owners get READER access. - "private" - Object owner gets OWNER access. - Default if left blank. - "projectPrivate" - Object owner gets OWNER access. - Project team members get access according to their roles. - "publicRead" - Object owner gets OWNER access. - All Users get READER access. #### --gcs-bucket-acl Access Control List for new buckets. Properties: - Config: bucket_acl - Env Var: RCLONE_GCS_BUCKET_ACL - Type: string - Required: false - Examples: - "authenticatedRead" - Project team owners get OWNER access. - All Authenticated Users get READER access. - "private" - Project team owners get OWNER access. - Default if left blank. - "projectPrivate" - Project team members get access according to their roles. - "publicRead" - Project team owners get OWNER access. - All Users get READER access. - "publicReadWrite" - Project team owners get OWNER access. - All Users get WRITER access. #### --gcs-bucket-policy-only Access checks should use bucket-level IAM policies. If you want to upload objects to a bucket with Bucket Policy Only set then you will need to set this. When it is set, rclone: - ignores ACLs set on buckets - ignores ACLs set on objects - creates buckets with Bucket Policy Only set Docs: https://cloud.google.com/storage/docs/bucket-policy-only Properties: - Config: bucket_policy_only - Env Var: RCLONE_GCS_BUCKET_POLICY_ONLY - Type: bool - Default: false #### --gcs-location Location for the newly created buckets. Properties: - Config: location - Env Var: RCLONE_GCS_LOCATION - Type: string - Required: false - Examples: - "" - Empty for default location (US) - "asia" - Multi-regional location for Asia - "eu" - Multi-regional location for Europe - "us" - Multi-regional location for United States - "asia-east1" - Taiwan - "asia-east2" - Hong Kong - "asia-northeast1" - Tokyo - "asia-northeast2" - Osaka - "asia-northeast3" - Seoul - "asia-south1" - Mumbai - "asia-south2" - Delhi - "asia-southeast1" - Singapore - "asia-southeast2" - Jakarta - "australia-southeast1" - Sydney - "australia-southeast2" - Melbourne - "europe-north1" - Finland - "europe-west1" - Belgium - "europe-west2" - London - "europe-west3" - Frankfurt - "europe-west4" - Netherlands - "europe-west6" - Zürich - "europe-central2" - Warsaw - "us-central1" - Iowa - "us-east1" - South Carolina - "us-east4" - Northern Virginia - "us-west1" - Oregon - "us-west2" - California - "us-west3" - Salt Lake City - "us-west4" - Las Vegas - "northamerica-northeast1" - Montréal - "northamerica-northeast2" - Toronto - "southamerica-east1" - São Paulo - "southamerica-west1" - Santiago - "asia1" - Dual region: asia-northeast1 and asia-northeast2. - "eur4" - Dual region: europe-north1 and europe-west4. - "nam4" - Dual region: us-central1 and us-east1. #### --gcs-storage-class The storage class to use when storing objects in Google Cloud Storage. Properties: - Config: storage_class - Env Var: RCLONE_GCS_STORAGE_CLASS - Type: string - Required: false - Examples: - "" - Default - "MULTI_REGIONAL" - Multi-regional storage class - "REGIONAL" - Regional storage class - "NEARLINE" - Nearline storage class - "COLDLINE" - Coldline storage class - "ARCHIVE" - Archive storage class - "DURABLE_REDUCED_AVAILABILITY" - Durable reduced availability storage class #### --gcs-env-auth Get GCP IAM credentials from runtime (environment variables or instance meta data if no env vars). Only applies if service_account_file and service_account_credentials is blank. Properties: - Config: env_auth - Env Var: RCLONE_GCS_ENV_AUTH - Type: bool - Default: false - Examples: - "false" - Enter credentials in the next step. - "true" - Get GCP IAM credentials from the environment (env vars or IAM). ### Advanced options Here are the Advanced options specific to google cloud storage (Google Cloud Storage (this is not Google Drive)). #### --gcs-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_GCS_TOKEN - Type: string - Required: false #### --gcs-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_GCS_AUTH_URL - Type: string - Required: false #### --gcs-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_GCS_TOKEN_URL - Type: string - Required: false #### --gcs-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_GCS_CLIENT_CREDENTIALS - Type: bool - Default: false #### --gcs-access-token Short-lived access token. Leave blank normally. Needed only if you want use short-lived access token instead of interactive login. Properties: - Config: access_token - Env Var: RCLONE_GCS_ACCESS_TOKEN - Type: string - Required: false #### --gcs-directory-markers Upload an empty object with a trailing slash when a new directory is created Empty folders are unsupported for bucket based remotes, this option creates an empty object ending with "/", to persist the folder. Properties: - Config: directory_markers - Env Var: RCLONE_GCS_DIRECTORY_MARKERS - Type: bool - Default: false #### --gcs-no-check-bucket If set, don't attempt to check the bucket exists or create it. This can be useful when trying to minimise the number of transactions rclone does if you know the bucket exists already. Properties: - Config: no_check_bucket - Env Var: RCLONE_GCS_NO_CHECK_BUCKET - Type: bool - Default: false #### --gcs-decompress If set this will decompress gzip encoded objects. It is possible to upload objects to GCS with "Content-Encoding: gzip" set. Normally rclone will download these files as compressed objects. If this flag is set then rclone will decompress these files with "Content-Encoding: gzip" as they are received. This means that rclone can't check the size and hash but the file contents will be decompressed. Properties: - Config: decompress - Env Var: RCLONE_GCS_DECOMPRESS - Type: bool - Default: false #### --gcs-endpoint Endpoint for the service. Leave blank normally. Properties: - Config: endpoint - Env Var: RCLONE_GCS_ENDPOINT - Type: string - Required: false #### --gcs-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_GCS_ENCODING - Type: Encoding - Default: Slash,CrLf,InvalidUtf8,Dot #### --gcs-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_GCS_DESCRIPTION - Type: string - Required: false ## Limitations `rclone about` is not supported by the Google Cloud Storage backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) # Google Drive Paths are specified as `drive:path` Drive paths may be as deep as required, e.g. `drive:directory/subdirectory`. ## Configuration The initial setup for drive involves getting a token from Google drive which you need to do in your browser. `rclone config` walks you through it. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config n/r/c/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Google Drive \ "drive" [snip] Storage> drive Google Application Client Id - leave blank normally. client_id> Google Application Client Secret - leave blank normally. client_secret> Scope that rclone should use when requesting access from drive. Choose a number from below, or type in your own value 1 / Full access all files, excluding Application Data Folder. \ "drive" 2 / Read-only access to file metadata and file contents. \ "drive.readonly" / Access to files created by rclone only. 3 | These are visible in the drive website. | File authorization is revoked when the user deauthorizes the app. \ "drive.file" / Allows read and write access to the Application Data folder. 4 | This is not visible in the drive website. \ "drive.appfolder" / Allows read-only access to file metadata but 5 | does not allow any access to read or download file content. \ "drive.metadata.readonly" scope> 1 Service Account Credentials JSON file path - needed only if you want use SA instead of interactive login. service_account_file> Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Configure this as a Shared Drive (Team Drive)? y) Yes n) No y/n> n Configuration complete. Options: type: drive - client_id: - client_secret: - scope: drive - root_folder_id: - service_account_file: - token: {"access_token":"XXX","token_type":"Bearer","refresh_token":"XXX","expiry":"2014-03-16T13:57:58.955387075Z"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` See the [remote setup docs](https://rclone.org/remote_setup/) for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Google if using web browser to automatically authenticate. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on `http://127.0.0.1:53682/` and it may require you to unblock it temporarily if you are running a host firewall, or use manual mode. You can then use it like this, List directories in top level of your drive rclone lsd remote: List all the files in your drive rclone ls remote: To copy a local directory to a drive directory called backup rclone copy /home/source remote:backup ### Scopes Rclone allows you to select which scope you would like for rclone to use. This changes what type of token is granted to rclone. [The scopes are defined here](https://developers.google.com/drive/v3/web/about-auth). A comma-separated list is allowed e.g. `drive.readonly,drive.file`. The scope are #### drive This is the default scope and allows full access to all files, except for the Application Data Folder (see below). Choose this one if you aren't sure. #### drive.readonly This allows read only access to all files. Files may be listed and downloaded but not uploaded, renamed or deleted. #### drive.file With this scope rclone can read/view/modify only those files and folders it creates. So if you uploaded files to drive via the web interface (or any other means) they will not be visible to rclone. This can be useful if you are using rclone to backup data and you want to be sure confidential data on your drive is not visible to rclone. Files created with this scope are visible in the web interface. #### drive.appfolder This gives rclone its own private area to store files. Rclone will not be able to see any other files on your drive and you won't be able to see rclone's files from the web interface either. #### drive.metadata.readonly This allows read only access to file names only. It does not allow rclone to download or upload data, or rename or delete files or directories. ### Root folder ID This option has been moved to the advanced section. You can set the `root_folder_id` for rclone. This is the directory (identified by its `Folder ID`) that rclone considers to be the root of your drive. Normally you will leave this blank and rclone will determine the correct root to use itself. However you can set this to restrict rclone to a specific folder hierarchy or to access data within the "Computers" tab on the drive web interface (where files from Google's Backup and Sync desktop program go). In order to do this you will have to find the `Folder ID` of the directory you wish rclone to display. This will be the last segment of the URL when you open the relevant folder in the drive web interface. So if the folder you want rclone to use has a URL which looks like `https://drive.google.com/drive/folders/1XyfxxxxxxxxxxxxxxxxxxxxxxxxxKHCh` in the browser, then you use `1XyfxxxxxxxxxxxxxxxxxxxxxxxxxKHCh` as the `root_folder_id` in the config. **NB** folders under the "Computers" tab seem to be read only (drive gives a 500 error) when using rclone. There doesn't appear to be an API to discover the folder IDs of the "Computers" tab - please contact us if you know otherwise! Note also that rclone can't access any data under the "Backups" tab on the google drive web interface yet. ### Service Account support You can set up rclone with Google Drive in an unattended mode, i.e. not tied to a specific end-user Google account. This is useful when you want to synchronise files onto machines that don't have actively logged-in users, for example build machines. To use a Service Account instead of OAuth2 token flow, enter the path to your Service Account credentials at the `service_account_file` prompt during `rclone config` and rclone won't use the browser based authentication flow. If you'd rather stuff the contents of the credentials file into the rclone config file, you can set `service_account_credentials` with the actual contents of the file instead, or set the equivalent environment variable. #### Use case - Google Workspace account and individual Drive Let's say that you are the administrator of a Google Workspace. The goal is to read or write data on an individual's Drive account, who IS a member of the domain. We'll call the domain **example.com**, and the user **foo@example.com**. There's a few steps we need to go through to accomplish this: ##### 1. Create a service account for example.com - To create a service account and obtain its credentials, go to the [Google Developer Console](https://console.developers.google.com). - You must have a project - create one if you don't and make sure you are on the selected project. - Then go to "IAM & admin" -> "Service Accounts". - Use the "Create Service Account" button. Fill in "Service account name" and "Service account ID" with something that identifies your client. - Select "Create And Continue". Step 2 and 3 are optional. - Click on the newly created service account - Click "Keys" and then "Add Key" and then "Create new key" - Choose type "JSON" and click create - This will download a small JSON file that rclone will use for authentication. If you ever need to remove access, press the "Delete service account key" button. ##### 2. Allowing API access to example.com Google Drive - Go to example.com's [Workspace Admin Console](https://admin.google.com) - Go into "Security" (or use the search bar) - Select "Access and data control" and then "API controls" - Click "Manage domain-wide delegation" - Click "Add new" - In the "Client ID" field enter the service account's "Client ID" - this can be found in the Developer Console under "IAM & Admin" -> "Service Accounts", then "View Client ID" for the newly created service account. It is a ~21 character numerical string. - In the next field, "OAuth Scopes", enter `https://www.googleapis.com/auth/drive` to grant read/write access to Google Drive specifically. You can also use `https://www.googleapis.com/auth/drive.readonly` for read only access. - Click "Authorise" ##### 3. Configure rclone, assuming a new install ``` rclone config n/s/q> n # New name>gdrive # Gdrive is an example name Storage> # Type drive client_id> # Can be left blank client_secret> # Can be left blank scope> # Select the scope use used in step 2 root_folder_id> # Can be left blank service_account_file> /home/foo/myJSONfile.json # Path to the JSON file you downloaded in step 1. y/n> # Auto config, n ``` ##### 4. Verify that it's working - `rclone -v --drive-impersonate foo@example.com lsf gdrive:backup` - The arguments do: - `-v` - verbose logging - `--drive-impersonate foo@example.com` - this is what does the magic, pretending to be user foo. - `lsf` - list files in a parsing friendly way - `gdrive:backup` - use the remote called gdrive, work in the folder named backup. Note: in case you configured a specific root folder on gdrive and rclone is unable to access the contents of that folder when using `--drive-impersonate`, do this instead: - in the gdrive web interface, share your root folder with the user/email of the new Service Account you created/selected at step 1 - use rclone without specifying the `--drive-impersonate` option, like this: `rclone -v lsf gdrive:backup` ### Shared drives (team drives) If you want to configure the remote to point to a Google Shared Drive (previously known as Team Drives) then answer `y` to the question `Configure this as a Shared Drive (Team Drive)?`. This will fetch the list of Shared Drives from google and allow you to configure which one you want to use. You can also type in a Shared Drive ID if you prefer. For example: ``` Configure this as a Shared Drive (Team Drive)? y) Yes n) No y/n> y Fetching Shared Drive list... Choose a number from below, or type in your own value 1 / Rclone Test \ "xxxxxxxxxxxxxxxxxxxx" 2 / Rclone Test 2 \ "yyyyyyyyyyyyyyyyyyyy" 3 / Rclone Test 3 \ "zzzzzzzzzzzzzzzzzzzz" Enter a Shared Drive ID> 1 Configuration complete. Options: - type: drive - client_id: - client_secret: - token: {"AccessToken":"xxxx.x.xxxxx_xxxxxxxxxxx_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","RefreshToken":"1/xxxxxxxxxxxxxxxx_xxxxxxxxxxxxxxxxxxxxxxxxxx","Expiry":"2014-03-16T13:57:58.955387075Z","Extra":null} - team_drive: xxxxxxxxxxxxxxxxxxxx Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` ### --fast-list This remote supports `--fast-list` which allows you to use fewer transactions in exchange for more memory. See the [rclone docs](https://rclone.org/docs/#fast-list) for more details. It does this by combining multiple `list` calls into a single API request. This works by combining many `'%s' in parents` filters into one expression. To list the contents of directories a, b and c, the following requests will be send by the regular `List` function: ``` trashed=false and 'a' in parents trashed=false and 'b' in parents trashed=false and 'c' in parents ``` These can now be combined into a single request: ``` trashed=false and ('a' in parents or 'b' in parents or 'c' in parents) ``` The implementation of `ListR` will put up to 50 `parents` filters into one request. It will use the `--checkers` value to specify the number of requests to run in parallel. In tests, these batch requests were up to 20x faster than the regular method. Running the following command against different sized folders gives: ``` rclone lsjson -vv -R --checkers=6 gdrive:folder ``` small folder (220 directories, 700 files): - without `--fast-list`: 38s - with `--fast-list`: 10s large folder (10600 directories, 39000 files): - without `--fast-list`: 22:05 min - with `--fast-list`: 58s ### Modification times and hashes Google drive stores modification times accurate to 1 ms. Hash algorithms MD5, SHA1 and SHA256 are supported. Note, however, that a small fraction of files uploaded may not have SHA1 or SHA256 hashes especially if they were uploaded before 2018. ### Restricted filename characters Only Invalid UTF-8 bytes will be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. In contrast to other backends, `/` can also be used in names and `.` or `..` are valid names. ### Revisions Google drive stores revisions of files. When you upload a change to an existing file to google drive using rclone it will create a new revision of that file. Revisions follow the standard google policy which at time of writing was * They are deleted after 30 days or 100 revisions (whatever comes first). * They do not count towards a user storage quota. ### Deleting files By default rclone will send all files to the trash when deleting files. If deleting them permanently is required then use the `--drive-use-trash=false` flag, or set the equivalent environment variable. ### Shortcuts In March 2020 Google introduced a new feature in Google Drive called [drive shortcuts](https://support.google.com/drive/answer/9700156) ([API](https://developers.google.com/drive/api/v3/shortcuts)). These will (by September 2020) [replace the ability for files or folders to be in multiple folders at once](https://cloud.google.com/blog/products/g-suite/simplifying-google-drives-folder-structure-and-sharing-models). Shortcuts are files that link to other files on Google Drive somewhat like a symlink in unix, except they point to the underlying file data (e.g. the inode in unix terms) so they don't break if the source is renamed or moved about. By default rclone treats these as follows. For shortcuts pointing to files: - When listing a file shortcut appears as the destination file. - When downloading the contents of the destination file is downloaded. - When updating shortcut file with a non shortcut file, the shortcut is removed then a new file is uploaded in place of the shortcut. - When server-side moving (renaming) the shortcut is renamed, not the destination file. - When server-side copying the shortcut is copied, not the contents of the shortcut. (unless `--drive-copy-shortcut-content` is in use in which case the contents of the shortcut gets copied). - When deleting the shortcut is deleted not the linked file. - When setting the modification time, the modification time of the linked file will be set. For shortcuts pointing to folders: - When listing the shortcut appears as a folder and that folder will contain the contents of the linked folder appear (including any sub folders) - When downloading the contents of the linked folder and sub contents are downloaded - When uploading to a shortcut folder the file will be placed in the linked folder - When server-side moving (renaming) the shortcut is renamed, not the destination folder - When server-side copying the contents of the linked folder is copied, not the shortcut. - When deleting with `rclone rmdir` or `rclone purge` the shortcut is deleted not the linked folder. - **NB** When deleting with `rclone remove` or `rclone mount` the contents of the linked folder will be deleted. The [rclone backend](https://rclone.org/commands/rclone_backend/) command can be used to create shortcuts. Shortcuts can be completely ignored with the `--drive-skip-shortcuts` flag or the corresponding `skip_shortcuts` configuration setting. If you have shortcuts that lead to an infinite recursion in your drive (e.g. a shortcut pointing to a parent folder), `skip_shortcuts` might be mandatory to be able to copy the drive. ### Emptying trash If you wish to empty your trash you can use the `rclone cleanup remote:` command which will permanently delete all your trashed files. This command does not take any path arguments. Note that Google Drive takes some time (minutes to days) to empty the trash even though the command returns within a few seconds. No output is echoed, so there will be no confirmation even using -v or -vv. ### Quota information To view your current quota you can use the `rclone about remote:` command which will display your usage limit (quota), the usage in Google Drive, the size of all files in the Trash and the space used by other Google services such as Gmail. This command does not take any path arguments. #### Import/Export of google documents Google documents can be exported from and uploaded to Google Drive. When rclone downloads a Google doc it chooses a format to download depending upon the `--drive-export-formats` setting. By default the export formats are `docx,xlsx,pptx,svg` which are a sensible default for an editable document. When choosing a format, rclone runs down the list provided in order and chooses the first file format the doc can be exported as from the list. If the file can't be exported to a format on the formats list, then rclone will choose a format from the default list. If you prefer an archive copy then you might use `--drive-export-formats pdf`, or if you prefer openoffice/libreoffice formats you might use `--drive-export-formats ods,odt,odp`. Note that rclone adds the extension to the google doc, so if it is called `My Spreadsheet` on google docs, it will be exported as `My Spreadsheet.xlsx` or `My Spreadsheet.pdf` etc. When importing files into Google Drive, rclone will convert all files with an extension in `--drive-import-formats` to their associated document type. rclone will not convert any files by default, since the conversion is lossy process. The conversion must result in a file with the same extension when the `--drive-export-formats` rules are applied to the uploaded document. Here are some examples for allowed and prohibited conversions. | export-formats | import-formats | Upload Ext | Document Ext | Allowed | | -------------- | -------------- | ---------- | ------------ | ------- | | odt | odt | odt | odt | Yes | | odt | docx,odt | odt | odt | Yes | | | docx | docx | docx | Yes | | | odt | odt | docx | No | | odt,docx | docx,odt | docx | odt | No | | docx,odt | docx,odt | docx | docx | Yes | | docx,odt | docx,odt | odt | docx | No | This limitation can be disabled by specifying `--drive-allow-import-name-change`. When using this flag, rclone can convert multiple files types resulting in the same document type at once, e.g. with `--drive-import-formats docx,odt,txt`, all files having these extension would result in a document represented as a docx file. This brings the additional risk of overwriting a document, if multiple files have the same stem. Many rclone operations will not handle this name change in any way. They assume an equal name when copying files and might copy the file again or delete them when the name changes. Here are the possible export extensions with their corresponding mime types. Most of these can also be used for importing, but there more that are not listed here. Some of these additional ones might only be available when the operating system provides the correct MIME type entries. This list can be changed by Google Drive at any time and might not represent the currently available conversions. | Extension | Mime Type | Description | | --------- |-----------| ------------| | bmp | image/bmp | Windows Bitmap format | | csv | text/csv | Standard CSV format for Spreadsheets | | doc | application/msword | Classic Word file | | docx | application/vnd.openxmlformats-officedocument.wordprocessingml.document | Microsoft Office Document | | epub | application/epub+zip | E-book format | | html | text/html | An HTML Document | | jpg | image/jpeg | A JPEG Image File | | json | application/vnd.google-apps.script+json | JSON Text Format for Google Apps scripts | | md | text/markdown | Markdown Text Format | | odp | application/vnd.oasis.opendocument.presentation | Openoffice Presentation | | ods | application/vnd.oasis.opendocument.spreadsheet | Openoffice Spreadsheet | | ods | application/x-vnd.oasis.opendocument.spreadsheet | Openoffice Spreadsheet | | odt | application/vnd.oasis.opendocument.text | Openoffice Document | | pdf | application/pdf | Adobe PDF Format | | pjpeg | image/pjpeg | Progressive JPEG Image | | png | image/png | PNG Image Format| | pptx | application/vnd.openxmlformats-officedocument.presentationml.presentation | Microsoft Office Powerpoint | | rtf | application/rtf | Rich Text Format | | svg | image/svg+xml | Scalable Vector Graphics Format | | tsv | text/tab-separated-values | Standard TSV format for spreadsheets | | txt | text/plain | Plain Text | | wmf | application/x-msmetafile | Windows Meta File | | xls | application/vnd.ms-excel | Classic Excel file | | xlsx | application/vnd.openxmlformats-officedocument.spreadsheetml.sheet | Microsoft Office Spreadsheet | | zip | application/zip | A ZIP file of HTML, Images CSS | Google documents can also be exported as link files. These files will open a browser window for the Google Docs website of that document when opened. The link file extension has to be specified as a `--drive-export-formats` parameter. They will match all available Google Documents. | Extension | Description | OS Support | | --------- | ----------- | ---------- | | desktop | freedesktop.org specified desktop entry | Linux | | link.html | An HTML Document with a redirect | All | | url | INI style link file | macOS, Windows | | webloc | macOS specific XML format | macOS | ### Standard options Here are the Standard options specific to drive (Google Drive). #### --drive-client-id Google Application Client Id Setting your own is recommended. See https://rclone.org/drive/#making-your-own-client-id for how to create your own. If you leave this blank, it will use an internal key which is low performance. Properties: - Config: client_id - Env Var: RCLONE_DRIVE_CLIENT_ID - Type: string - Required: false #### --drive-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_DRIVE_CLIENT_SECRET - Type: string - Required: false #### --drive-scope Comma separated list of scopes that rclone should use when requesting access from drive. Properties: - Config: scope - Env Var: RCLONE_DRIVE_SCOPE - Type: string - Required: false - Examples: - "drive" - Full access all files, excluding Application Data Folder. - "drive.readonly" - Read-only access to file metadata and file contents. - "drive.file" - Access to files created by rclone only. - These are visible in the drive website. - File authorization is revoked when the user deauthorizes the app. - "drive.appfolder" - Allows read and write access to the Application Data folder. - This is not visible in the drive website. - "drive.metadata.readonly" - Allows read-only access to file metadata but - does not allow any access to read or download file content. #### --drive-service-account-file Service Account Credentials JSON file path. Leave blank normally. Needed only if you want use SA instead of interactive login. Leading `~` will be expanded in the file name as will environment variables such as `${RCLONE_CONFIG_DIR}`. Properties: - Config: service_account_file - Env Var: RCLONE_DRIVE_SERVICE_ACCOUNT_FILE - Type: string - Required: false #### --drive-alternate-export Deprecated: No longer needed. Properties: - Config: alternate_export - Env Var: RCLONE_DRIVE_ALTERNATE_EXPORT - Type: bool - Default: false ### Advanced options Here are the Advanced options specific to drive (Google Drive). #### --drive-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_DRIVE_TOKEN - Type: string - Required: false #### --drive-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_DRIVE_AUTH_URL - Type: string - Required: false #### --drive-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_DRIVE_TOKEN_URL - Type: string - Required: false #### --drive-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_DRIVE_CLIENT_CREDENTIALS - Type: bool - Default: false #### --drive-root-folder-id ID of the root folder. Leave blank normally. Fill in to access "Computers" folders (see docs), or for rclone to use a non root folder as its starting point. Properties: - Config: root_folder_id - Env Var: RCLONE_DRIVE_ROOT_FOLDER_ID - Type: string - Required: false #### --drive-service-account-credentials Service Account Credentials JSON blob. Leave blank normally. Needed only if you want use SA instead of interactive login. Properties: - Config: service_account_credentials - Env Var: RCLONE_DRIVE_SERVICE_ACCOUNT_CREDENTIALS - Type: string - Required: false #### --drive-team-drive ID of the Shared Drive (Team Drive). Properties: - Config: team_drive - Env Var: RCLONE_DRIVE_TEAM_DRIVE - Type: string - Required: false #### --drive-auth-owner-only Only consider files owned by the authenticated user. Properties: - Config: auth_owner_only - Env Var: RCLONE_DRIVE_AUTH_OWNER_ONLY - Type: bool - Default: false #### --drive-use-trash Send files to the trash instead of deleting permanently. Defaults to true, namely sending files to the trash. Use `--drive-use-trash=false` to delete files permanently instead. Properties: - Config: use_trash - Env Var: RCLONE_DRIVE_USE_TRASH - Type: bool - Default: true #### --drive-copy-shortcut-content Server side copy contents of shortcuts instead of the shortcut. When doing server side copies, normally rclone will copy shortcuts as shortcuts. If this flag is used then rclone will copy the contents of shortcuts rather than shortcuts themselves when doing server side copies. Properties: - Config: copy_shortcut_content - Env Var: RCLONE_DRIVE_COPY_SHORTCUT_CONTENT - Type: bool - Default: false #### --drive-skip-gdocs Skip google documents in all listings. If given, gdocs practically become invisible to rclone. Properties: - Config: skip_gdocs - Env Var: RCLONE_DRIVE_SKIP_GDOCS - Type: bool - Default: false #### --drive-show-all-gdocs Show all Google Docs including non-exportable ones in listings. If you try a server side copy on a Google Form without this flag, you will get this error: No export formats found for "application/vnd.google-apps.form" However adding this flag will allow the form to be server side copied. Note that rclone doesn't add extensions to the Google Docs file names in this mode. Do **not** use this flag when trying to download Google Docs - rclone will fail to download them. Properties: - Config: show_all_gdocs - Env Var: RCLONE_DRIVE_SHOW_ALL_GDOCS - Type: bool - Default: false #### --drive-skip-checksum-gphotos Skip checksums on Google photos and videos only. Use this if you get checksum errors when transferring Google photos or videos. Setting this flag will cause Google photos and videos to return a blank checksums. Google photos are identified by being in the "photos" space. Corrupted checksums are caused by Google modifying the image/video but not updating the checksum. Properties: - Config: skip_checksum_gphotos - Env Var: RCLONE_DRIVE_SKIP_CHECKSUM_GPHOTOS - Type: bool - Default: false #### --drive-shared-with-me Only show files that are shared with me. Instructs rclone to operate on your "Shared with me" folder (where Google Drive lets you access the files and folders others have shared with you). This works both with the "list" (lsd, lsl, etc.) and the "copy" commands (copy, sync, etc.), and with all other commands too. Properties: - Config: shared_with_me - Env Var: RCLONE_DRIVE_SHARED_WITH_ME - Type: bool - Default: false #### --drive-trashed-only Only show files that are in the trash. This will show trashed files in their original directory structure. Properties: - Config: trashed_only - Env Var: RCLONE_DRIVE_TRASHED_ONLY - Type: bool - Default: false #### --drive-starred-only Only show files that are starred. Properties: - Config: starred_only - Env Var: RCLONE_DRIVE_STARRED_ONLY - Type: bool - Default: false #### --drive-formats Deprecated: See export_formats. Properties: - Config: formats - Env Var: RCLONE_DRIVE_FORMATS - Type: string - Required: false #### --drive-export-formats Comma separated list of preferred formats for downloading Google docs. Properties: - Config: export_formats - Env Var: RCLONE_DRIVE_EXPORT_FORMATS - Type: string - Default: "docx,xlsx,pptx,svg" #### --drive-import-formats Comma separated list of preferred formats for uploading Google docs. Properties: - Config: import_formats - Env Var: RCLONE_DRIVE_IMPORT_FORMATS - Type: string - Required: false #### --drive-allow-import-name-change Allow the filetype to change when uploading Google docs. E.g. file.doc to file.docx. This will confuse sync and reupload every time. Properties: - Config: allow_import_name_change - Env Var: RCLONE_DRIVE_ALLOW_IMPORT_NAME_CHANGE - Type: bool - Default: false #### --drive-use-created-date Use file created date instead of modified date. Useful when downloading data and you want the creation date used in place of the last modified date. **WARNING**: This flag may have some unexpected consequences. When uploading to your drive all files will be overwritten unless they haven't been modified since their creation. And the inverse will occur while downloading. This side effect can be avoided by using the "--checksum" flag. This feature was implemented to retain photos capture date as recorded by google photos. You will first need to check the "Create a Google Photos folder" option in your google drive settings. You can then copy or move the photos locally and use the date the image was taken (created) set as the modification date. Properties: - Config: use_created_date - Env Var: RCLONE_DRIVE_USE_CREATED_DATE - Type: bool - Default: false #### --drive-use-shared-date Use date file was shared instead of modified date. Note that, as with "--drive-use-created-date", this flag may have unexpected consequences when uploading/downloading files. If both this flag and "--drive-use-created-date" are set, the created date is used. Properties: - Config: use_shared_date - Env Var: RCLONE_DRIVE_USE_SHARED_DATE - Type: bool - Default: false #### --drive-list-chunk Size of listing chunk 100-1000, 0 to disable. Properties: - Config: list_chunk - Env Var: RCLONE_DRIVE_LIST_CHUNK - Type: int - Default: 1000 #### --drive-impersonate Impersonate this user when using a service account. Properties: - Config: impersonate - Env Var: RCLONE_DRIVE_IMPERSONATE - Type: string - Required: false #### --drive-upload-cutoff Cutoff for switching to chunked upload. Properties: - Config: upload_cutoff - Env Var: RCLONE_DRIVE_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 8Mi #### --drive-chunk-size Upload chunk size. Must a power of 2 >= 256k. Making this larger will improve performance, but note that each chunk is buffered in memory one per transfer. Reducing this will reduce memory usage but decrease performance. Properties: - Config: chunk_size - Env Var: RCLONE_DRIVE_CHUNK_SIZE - Type: SizeSuffix - Default: 8Mi #### --drive-acknowledge-abuse Set to allow files which return cannotDownloadAbusiveFile to be downloaded. If downloading a file returns the error "This file has been identified as malware or spam and cannot be downloaded" with the error code "cannotDownloadAbusiveFile" then supply this flag to rclone to indicate you acknowledge the risks of downloading the file and rclone will download it anyway. Note that if you are using service account it will need Manager permission (not Content Manager) to for this flag to work. If the SA does not have the right permission, Google will just ignore the flag. Properties: - Config: acknowledge_abuse - Env Var: RCLONE_DRIVE_ACKNOWLEDGE_ABUSE - Type: bool - Default: false #### --drive-keep-revision-forever Keep new head revision of each file forever. Properties: - Config: keep_revision_forever - Env Var: RCLONE_DRIVE_KEEP_REVISION_FOREVER - Type: bool - Default: false #### --drive-size-as-quota Show sizes as storage quota usage, not actual size. Show the size of a file as the storage quota used. This is the current version plus any older versions that have been set to keep forever. **WARNING**: This flag may have some unexpected consequences. It is not recommended to set this flag in your config - the recommended usage is using the flag form --drive-size-as-quota when doing rclone ls/lsl/lsf/lsjson/etc only. If you do use this flag for syncing (not recommended) then you will need to use --ignore size also. Properties: - Config: size_as_quota - Env Var: RCLONE_DRIVE_SIZE_AS_QUOTA - Type: bool - Default: false #### --drive-v2-download-min-size If Object's are greater, use drive v2 API to download. Properties: - Config: v2_download_min_size - Env Var: RCLONE_DRIVE_V2_DOWNLOAD_MIN_SIZE - Type: SizeSuffix - Default: off #### --drive-pacer-min-sleep Minimum time to sleep between API calls. Properties: - Config: pacer_min_sleep - Env Var: RCLONE_DRIVE_PACER_MIN_SLEEP - Type: Duration - Default: 100ms #### --drive-pacer-burst Number of API calls to allow without sleeping. Properties: - Config: pacer_burst - Env Var: RCLONE_DRIVE_PACER_BURST - Type: int - Default: 100 #### --drive-server-side-across-configs Deprecated: use --server-side-across-configs instead. Allow server-side operations (e.g. copy) to work across different drive configs. This can be useful if you wish to do a server-side copy between two different Google drives. Note that this isn't enabled by default because it isn't easy to tell if it will work between any two configurations. Properties: - Config: server_side_across_configs - Env Var: RCLONE_DRIVE_SERVER_SIDE_ACROSS_CONFIGS - Type: bool - Default: false #### --drive-disable-http2 Disable drive using http2. There is currently an unsolved issue with the google drive backend and HTTP/2. HTTP/2 is therefore disabled by default for the drive backend but can be re-enabled here. When the issue is solved this flag will be removed. See: https://github.com/rclone/rclone/issues/3631 Properties: - Config: disable_http2 - Env Var: RCLONE_DRIVE_DISABLE_HTTP2 - Type: bool - Default: true #### --drive-stop-on-upload-limit Make upload limit errors be fatal. At the time of writing it is only possible to upload 750 GiB of data to Google Drive a day (this is an undocumented limit). When this limit is reached Google Drive produces a slightly different error message. When this flag is set it causes these errors to be fatal. These will stop the in-progress sync. Note that this detection is relying on error message strings which Google don't document so it may break in the future. See: https://github.com/rclone/rclone/issues/3857 Properties: - Config: stop_on_upload_limit - Env Var: RCLONE_DRIVE_STOP_ON_UPLOAD_LIMIT - Type: bool - Default: false #### --drive-stop-on-download-limit Make download limit errors be fatal. At the time of writing it is only possible to download 10 TiB of data from Google Drive a day (this is an undocumented limit). When this limit is reached Google Drive produces a slightly different error message. When this flag is set it causes these errors to be fatal. These will stop the in-progress sync. Note that this detection is relying on error message strings which Google don't document so it may break in the future. Properties: - Config: stop_on_download_limit - Env Var: RCLONE_DRIVE_STOP_ON_DOWNLOAD_LIMIT - Type: bool - Default: false #### --drive-skip-shortcuts If set skip shortcut files. Normally rclone dereferences shortcut files making them appear as if they are the original file (see [the shortcuts section](#shortcuts)). If this flag is set then rclone will ignore shortcut files completely. Properties: - Config: skip_shortcuts - Env Var: RCLONE_DRIVE_SKIP_SHORTCUTS - Type: bool - Default: false #### --drive-skip-dangling-shortcuts If set skip dangling shortcut files. If this is set then rclone will not show any dangling shortcuts in listings. Properties: - Config: skip_dangling_shortcuts - Env Var: RCLONE_DRIVE_SKIP_DANGLING_SHORTCUTS - Type: bool - Default: false #### --drive-resource-key Resource key for accessing a link-shared file. If you need to access files shared with a link like this https://drive.google.com/drive/folders/XXX?resourcekey=YYY&usp=sharing Then you will need to use the first part "XXX" as the "root_folder_id" and the second part "YYY" as the "resource_key" otherwise you will get 404 not found errors when trying to access the directory. See: https://developers.google.com/drive/api/guides/resource-keys This resource key requirement only applies to a subset of old files. Note also that opening the folder once in the web interface (with the user you've authenticated rclone with) seems to be enough so that the resource key is not needed. Properties: - Config: resource_key - Env Var: RCLONE_DRIVE_RESOURCE_KEY - Type: string - Required: false #### --drive-fast-list-bug-fix Work around a bug in Google Drive listing. Normally rclone will work around a bug in Google Drive when using --fast-list (ListR) where the search "(A in parents) or (B in parents)" returns nothing sometimes. See #3114, #4289 and https://issuetracker.google.com/issues/149522397 Rclone detects this by finding no items in more than one directory when listing and retries them as lists of individual directories. This means that if you have a lot of empty directories rclone will end up listing them all individually and this can take many more API calls. This flag allows the work-around to be disabled. This is **not** recommended in normal use - only if you have a particular case you are having trouble with like many empty directories. Properties: - Config: fast_list_bug_fix - Env Var: RCLONE_DRIVE_FAST_LIST_BUG_FIX - Type: bool - Default: true #### --drive-metadata-owner Control whether owner should be read or written in metadata. Owner is a standard part of the file metadata so is easy to read. But it isn't always desirable to set the owner from the metadata. Note that you can't set the owner on Shared Drives, and that setting ownership will generate an email to the new owner (this can't be disabled), and you can't transfer ownership to someone outside your organization. Properties: - Config: metadata_owner - Env Var: RCLONE_DRIVE_METADATA_OWNER - Type: Bits - Default: read - Examples: - "off" - Do not read or write the value - "read" - Read the value only - "write" - Write the value only - "failok" - If writing fails log errors only, don't fail the transfer - "read,write" - Read and Write the value. #### --drive-metadata-permissions Control whether permissions should be read or written in metadata. Reading permissions metadata from files can be done quickly, but it isn't always desirable to set the permissions from the metadata. Note that rclone drops any inherited permissions on Shared Drives and any owner permission on My Drives as these are duplicated in the owner metadata. Properties: - Config: metadata_permissions - Env Var: RCLONE_DRIVE_METADATA_PERMISSIONS - Type: Bits - Default: off - Examples: - "off" - Do not read or write the value - "read" - Read the value only - "write" - Write the value only - "failok" - If writing fails log errors only, don't fail the transfer - "read,write" - Read and Write the value. #### --drive-metadata-labels Control whether labels should be read or written in metadata. Reading labels metadata from files takes an extra API transaction and will slow down listings. It isn't always desirable to set the labels from the metadata. The format of labels is documented in the drive API documentation at https://developers.google.com/drive/api/reference/rest/v3/Label - rclone just provides a JSON dump of this format. When setting labels, the label and fields must already exist - rclone will not create them. This means that if you are transferring labels from two different accounts you will have to create the labels in advance and use the metadata mapper to translate the IDs between the two accounts. Properties: - Config: metadata_labels - Env Var: RCLONE_DRIVE_METADATA_LABELS - Type: Bits - Default: off - Examples: - "off" - Do not read or write the value - "read" - Read the value only - "write" - Write the value only - "failok" - If writing fails log errors only, don't fail the transfer - "read,write" - Read and Write the value. #### --drive-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_DRIVE_ENCODING - Type: Encoding - Default: InvalidUtf8 #### --drive-env-auth Get IAM credentials from runtime (environment variables or instance meta data if no env vars). Only applies if service_account_file and service_account_credentials is blank. Properties: - Config: env_auth - Env Var: RCLONE_DRIVE_ENV_AUTH - Type: bool - Default: false - Examples: - "false" - Enter credentials in the next step. - "true" - Get GCP IAM credentials from the environment (env vars or IAM). #### --drive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_DRIVE_DESCRIPTION - Type: string - Required: false ### Metadata User metadata is stored in the properties field of the drive object. Metadata is supported on files and directories. Here are the possible system metadata items for the drive backend. | Name | Help | Type | Example | Read Only | |------|------|------|---------|-----------| | btime | Time of file birth (creation) with mS accuracy. Note that this is only writable on fresh uploads - it can't be written for updates. | RFC 3339 | 2006-01-02T15:04:05.999Z07:00 | N | | content-type | The MIME type of the file. | string | text/plain | N | | copy-requires-writer-permission | Whether the options to copy, print, or download this file, should be disabled for readers and commenters. | boolean | true | N | | description | A short description of the file. | string | Contract for signing | N | | folder-color-rgb | The color for a folder or a shortcut to a folder as an RGB hex string. | string | 881133 | N | | labels | Labels attached to this file in a JSON dump of Googled drive format. Enable with --drive-metadata-labels. | JSON | [] | N | | mtime | Time of last modification with mS accuracy. | RFC 3339 | 2006-01-02T15:04:05.999Z07:00 | N | | owner | The owner of the file. Usually an email address. Enable with --drive-metadata-owner. | string | user@example.com | N | | permissions | Permissions in a JSON dump of Google drive format. On shared drives these will only be present if they aren't inherited. Enable with --drive-metadata-permissions. | JSON | {} | N | | starred | Whether the user has starred the file. | boolean | false | N | | viewed-by-me | Whether the file has been viewed by this user. | boolean | true | **Y** | | writers-can-share | Whether users with only writer permission can modify the file's permissions. Not populated and ignored when setting for items in shared drives. | boolean | false | N | See the [metadata](https://rclone.org/docs/#metadata) docs for more info. ## Backend commands Here are the commands specific to the drive backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the [backend](https://rclone.org/commands/rclone_backend/) command for more info on how to pass options and arguments. These can be run on a running backend using the rc command [backend/command](https://rclone.org/rc/#backend-command). ### get Get command for fetching the drive config parameters rclone backend get remote: [options] [+] This is a get command which will be used to fetch the various drive config parameters Usage Examples: rclone backend get drive: [-o service_account_file] [-o chunk_size] rclone rc backend/command command=get fs=drive: [-o service_account_file] [-o chunk_size] Options: - "chunk_size": show the current upload chunk size - "service_account_file": show the current service account file ### set Set command for updating the drive config parameters rclone backend set remote: [options] [+] This is a set command which will be used to update the various drive config parameters Usage Examples: rclone backend set drive: [-o service_account_file=sa.json] [-o chunk_size=67108864] rclone rc backend/command command=set fs=drive: [-o service_account_file=sa.json] [-o chunk_size=67108864] Options: - "chunk_size": update the current upload chunk size - "service_account_file": update the current service account file ### shortcut Create shortcuts from files or directories rclone backend shortcut remote: [options] [+] This command creates shortcuts from files or directories. Usage: rclone backend shortcut drive: source_item destination_shortcut rclone backend shortcut drive: source_item -o target=drive2: destination_shortcut In the first example this creates a shortcut from the "source_item" which can be a file or a directory to the "destination_shortcut". The "source_item" and the "destination_shortcut" should be relative paths from "drive:" In the second example this creates a shortcut from the "source_item" relative to "drive:" to the "destination_shortcut" relative to "drive2:". This may fail with a permission error if the user authenticated with "drive2:" can't read files from "drive:". Options: - "target": optional target remote for the shortcut destination ### drives List the Shared Drives available to this account rclone backend drives remote: [options] [+] This command lists the Shared Drives (Team Drives) available to this account. Usage: rclone backend [-o config] drives drive: This will return a JSON list of objects like this [ { "id": "0ABCDEF-01234567890", "kind": "drive#teamDrive", "name": "My Drive" }, { "id": "0ABCDEFabcdefghijkl", "kind": "drive#teamDrive", "name": "Test Drive" } ] With the -o config parameter it will output the list in a format suitable for adding to a config file to make aliases for all the drives found and a combined drive. [My Drive] type = alias remote = drive,team_drive=0ABCDEF-01234567890,root_folder_id=: [Test Drive] type = alias remote = drive,team_drive=0ABCDEFabcdefghijkl,root_folder_id=: [AllDrives] type = combine upstreams = "My Drive=My Drive:" "Test Drive=Test Drive:" Adding this to the rclone config file will cause those team drives to be accessible with the aliases shown. Any illegal characters will be substituted with "_" and duplicate names will have numbers suffixed. It will also add a remote called AllDrives which shows all the shared drives combined into one directory tree. ### untrash Untrash files and directories rclone backend untrash remote: [options] [+] This command untrashes all the files and directories in the directory passed in recursively. Usage: This takes an optional directory to trash which make this easier to use via the API. rclone backend untrash drive:directory rclone backend --interactive untrash drive:directory subdir Use the --interactive/-i or --dry-run flag to see what would be restored before restoring it. Result: { "Untrashed": 17, "Errors": 0 } ### copyid Copy files by ID rclone backend copyid remote: [options] [+] This command copies files by ID Usage: rclone backend copyid drive: ID path rclone backend copyid drive: ID1 path1 ID2 path2 It copies the drive file with ID given to the path (an rclone path which will be passed internally to rclone copyto). The ID and path pairs can be repeated. The path should end with a / to indicate copy the file as named to this directory. If it doesn't end with a / then the last path component will be used as the file name. If the destination is a drive backend then server-side copying will be attempted if possible. Use the --interactive/-i or --dry-run flag to see what would be copied before copying. ### moveid Move files by ID rclone backend moveid remote: [options] [+] This command moves files by ID Usage: rclone backend moveid drive: ID path rclone backend moveid drive: ID1 path1 ID2 path2 It moves the drive file with ID given to the path (an rclone path which will be passed internally to rclone moveto). The path should end with a / to indicate move the file as named to this directory. If it doesn't end with a / then the last path component will be used as the file name. If the destination is a drive backend then server-side moving will be attempted if possible. Use the --interactive/-i or --dry-run flag to see what would be moved beforehand. ### exportformats Dump the export formats for debug purposes rclone backend exportformats remote: [options] [+] ### importformats Dump the import formats for debug purposes rclone backend importformats remote: [options] [+] ### query List files using Google Drive query language rclone backend query remote: [options] [+] This command lists files based on a query Usage: rclone backend query drive: query The query syntax is documented at [Google Drive Search query terms and operators](https://developers.google.com/drive/api/guides/ref-search-terms). For example: rclone backend query drive: "'0ABc9DEFGHIJKLMNop0QRatUVW3X' in parents and name contains 'foo'" If the query contains literal ' or \ characters, these need to be escaped with \ characters. "'" becomes "\'" and "\" becomes "\\\", for example to match a file named "foo ' \.txt": rclone backend query drive: "name = 'foo \' \\\.txt'" The result is a JSON array of matches, for example: [ { "createdTime": "2017-06-29T19:58:28.537Z", "id": "0AxBe_CDEF4zkGHI4d0FjYko2QkD", "md5Checksum": "68518d16be0c6fbfab918be61d658032", "mimeType": "text/plain", "modifiedTime": "2024-02-02T10:40:02.874Z", "name": "foo ' \\.txt", "parents": [ "0BxAe_BCDE4zkFGZpcWJGek0xbzC" ], "resourceKey": "0-ABCDEFGHIXJQpIGqBJq3MC", "sha1Checksum": "8f284fa768bfb4e45d076a579ab3905ab6bfa893", "size": "311", "webViewLink": "https://drive.google.com/file/d/0AxBe_CDEF4zkGHI4d0FjYko2QkD/view?usp=drivesdk\u0026resourcekey=0-ABCDEFGHIXJQpIGqBJq3MC" } ] ### rescue Rescue or delete any orphaned files rclone backend rescue remote: [options] [+] This command rescues or deletes any orphaned files or directories. Sometimes files can get orphaned in Google Drive. This means that they are no longer in any folder in Google Drive. This command finds those files and either rescues them to a directory you specify or deletes them. Usage: This can be used in 3 ways. First, list all orphaned files rclone backend rescue drive: Second rescue all orphaned files to the directory indicated rclone backend rescue drive: "relative/path/to/rescue/directory" e.g. To rescue all orphans to a directory called "Orphans" in the top level rclone backend rescue drive: Orphans Third delete all orphaned files to the trash rclone backend rescue drive: -o delete ## Limitations Drive has quite a lot of rate limiting. This causes rclone to be limited to transferring about 2 files per second only. Individual files may be transferred much faster at 100s of MiB/s but lots of small files can take a long time. Server side copies are also subject to a separate rate limit. If you see User rate limit exceeded errors, wait at least 24 hours and retry. You can disable server-side copies with `--disable copy` to download and upload the files if you prefer. ### Limitations of Google Docs Google docs will appear as size -1 in `rclone ls`, `rclone ncdu` etc, and as size 0 in anything which uses the VFS layer, e.g. `rclone mount` and `rclone serve`. When calculating directory totals, e.g. in `rclone size` and `rclone ncdu`, they will be counted in as empty files. This is because rclone can't find out the size of the Google docs without downloading them. Google docs will transfer correctly with `rclone sync`, `rclone copy` etc as rclone knows to ignore the size when doing the transfer. However an unfortunate consequence of this is that you may not be able to download Google docs using `rclone mount`. If it doesn't work you will get a 0 sized file. If you try again the doc may gain its correct size and be downloadable. Whether it will work on not depends on the application accessing the mount and the OS you are running - experiment to find out if it does work for you! ### Duplicated files Sometimes, for no reason I've been able to track down, drive will duplicate a file that rclone uploads. Drive unlike all the other remotes can have duplicated files. Duplicated files cause problems with the syncing and you will see messages in the log about duplicates. Use `rclone dedupe` to fix duplicated files. Note that this isn't just a problem with rclone, even Google Photos on Android duplicates files on drive sometimes. ### Rclone appears to be re-copying files it shouldn't The most likely cause of this is the duplicated file issue above - run `rclone dedupe` and check your logs for duplicate object or directory messages. This can also be caused by a delay/caching on google drive's end when comparing directory listings. Specifically with team drives used in combination with --fast-list. Files that were uploaded recently may not appear on the directory list sent to rclone when using --fast-list. Waiting a moderate period of time between attempts (estimated to be approximately 1 hour) and/or not using --fast-list both seem to be effective in preventing the problem. ### SHA1 or SHA256 hashes may be missing All files have MD5 hashes, but a small fraction of files uploaded may not have SHA1 or SHA256 hashes especially if they were uploaded before 2018. ## Making your own client_id When you use rclone with Google drive in its default configuration you are using rclone's client_id. This is shared between all the rclone users. There is a global rate limit on the number of queries per second that each client_id can do set by Google. rclone already has a high quota and I will continue to make sure it is high enough by contacting Google. It is strongly recommended to use your own client ID as the default rclone ID is heavily used. If you have multiple services running, it is recommended to use an API key for each service. The default Google quota is 10 transactions per second so it is recommended to stay under that number as if you use more than that, it will cause rclone to rate limit and make things slower. Here is how to create your own Google Drive client ID for rclone: 1. Log into the [Google API Console](https://console.developers.google.com/) with your Google account. It doesn't matter what Google account you use. (It need not be the same account as the Google Drive you want to access) 2. Select a project or create a new project. 3. Under "ENABLE APIS AND SERVICES" search for "Drive", and enable the "Google Drive API". 4. Click "Credentials" in the left-side panel (not "Create credentials", which opens the wizard). 5. If you already configured an "Oauth Consent Screen", then skip to the next step; if not, click on "CONFIGURE CONSENT SCREEN" button (near the top right corner of the right panel), then select "External" and click on "CREATE"; on the next screen, enter an "Application name" ("rclone" is OK); enter "User Support Email" (your own email is OK); enter "Developer Contact Email" (your own email is OK); then click on "Save" (all other data is optional). You will also have to add [some scopes](https://developers.google.com/drive/api/guides/api-specific-auth), including - `https://www.googleapis.com/auth/docs` - `https://www.googleapis.com/auth/drive` in order to be able to edit, create and delete files with RClone. - `https://www.googleapis.com/auth/drive.metadata.readonly` which you may also want to add. - If you want to add all at once, comma separated it would be `https://www.googleapis.com/auth/docs,https://www.googleapis.com/auth/drive,https://www.googleapis.com/auth/drive.metadata.readonly`. 6. After adding scopes, click "Save and continue" to add test users. Be sure to add your own account to the test users. Once you've added yourself as a test user and saved the changes, click again on "Credentials" on the left panel to go back to the "Credentials" screen. (PS: if you are a GSuite user, you could also select "Internal" instead of "External" above, but this will restrict API use to Google Workspace users in your organisation). 7. Click on the "+ CREATE CREDENTIALS" button at the top of the screen, then select "OAuth client ID". 8. Choose an application type of "Desktop app" and click "Create". (the default name is fine) 9. It will show you a client ID and client secret. Make a note of these. (If you selected "External" at Step 5 continue to Step 10. If you chose "Internal" you don't need to publish and can skip straight to Step 11 but your destination drive must be part of the same Google Workspace.) 10. Go to "Oauth consent screen" and then click "PUBLISH APP" button and confirm. You will also want to add yourself as a test user. 11. Provide the noted client ID and client secret to rclone. Be aware that, due to the "enhanced security" recently introduced by Google, you are theoretically expected to "submit your app for verification" and then wait a few weeks(!) for their response; in practice, you can go right ahead and use the client ID and client secret with rclone, the only issue will be a very scary confirmation screen shown when you connect via your browser for rclone to be able to get its token-id (but as this only happens during the remote configuration, it's not such a big deal). Keeping the application in "Testing" will work as well, but the limitation is that any grants will expire after a week, which can be annoying to refresh constantly. If, for whatever reason, a short grant time is not a problem, then keeping the application in testing mode would also be sufficient. (Thanks to @balazer on github for these instructions.) Sometimes, creation of an OAuth consent in Google API Console fails due to an error message “The request failed because changes to one of the field of the resource is not supported”. As a convenient workaround, the necessary Google Drive API key can be created on the [Python Quickstart](https://developers.google.com/drive/api/v3/quickstart/python) page. Just push the Enable the Drive API button to receive the Client ID and Secret. Note that it will automatically create a new project in the API Console. # Google Photos The rclone backend for [Google Photos](https://www.google.com/photos/about/) is a specialized backend for transferring photos and videos to and from Google Photos. **NB** The Google Photos API which rclone uses has quite a few limitations, so please read the [limitations section](#limitations) carefully to make sure it is suitable for your use. **NB** From March 31, 2025 rclone can only download photos it uploaded. This limitation is due to policy changes at Google. You may need to run `rclone config reconnect remote:` to make rclone work again after upgrading to rclone v1.70. ## Configuration The initial setup for google cloud storage involves getting a token from Google Photos which you need to do in your browser. `rclone config` walks you through it. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Google Photos \ "google photos" [snip] Storage> google photos ** See help for google photos backend at: https://rclone.org/googlephotos/ ** Google Application Client Id Leave blank normally. Enter a string value. Press Enter for the default (""). client_id> Google Application Client Secret Leave blank normally. Enter a string value. Press Enter for the default (""). client_secret> Set to make the Google Photos backend read only. If you choose read only then rclone will only request read only access to your photos, otherwise rclone will request full access. Enter a boolean value (true or false). Press Enter for the default ("false"). read_only> Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code *** IMPORTANT: All media items uploaded to Google Photos with rclone *** are stored in full resolution at original quality. These uploads *** will count towards storage in your Google Account. Configuration complete. Options: - type: google photos - token: {"access_token":"XXX","token_type":"Bearer","refresh_token":"XXX","expiry":"2019-06-28T17:38:04.644930156+01:00"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` See the [remote setup docs](https://rclone.org/remote_setup/) for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Google if using web browser to automatically authenticate. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on `http://127.0.0.1:53682/` and this may require you to unblock it temporarily if you are running a host firewall, or use manual mode. This remote is called `remote` and can now be used like this See all the albums in your photos rclone lsd remote:album Make a new album rclone mkdir remote:album/newAlbum List the contents of an album rclone ls remote:album/newAlbum Sync `/home/local/images` to the Google Photos, removing any excess files in the album. rclone sync --interactive /home/local/image remote:album/newAlbum ### Layout As Google Photos is not a general purpose cloud storage system, the backend is laid out to help you navigate it. The directories under `media` show different ways of categorizing the media. Each file will appear multiple times. So if you want to make a backup of your google photos you might choose to backup `remote:media/by-month`. (**NB** `remote:media/by-day` is rather slow at the moment so avoid for syncing.) Note that all your photos and videos will appear somewhere under `media`, but they may not appear under `album` unless you've put them into albums. ``` / - upload - file1.jpg - file2.jpg - ... - media - all - file1.jpg - file2.jpg - ... - by-year - 2000 - file1.jpg - ... - 2001 - file2.jpg - ... - ... - by-month - 2000 - 2000-01 - file1.jpg - ... - 2000-02 - file2.jpg - ... - ... - by-day - 2000 - 2000-01-01 - file1.jpg - ... - 2000-01-02 - file2.jpg - ... - ... - album - album name - album name/sub - shared-album - album name - album name/sub - feature - favorites - file1.jpg - file2.jpg ``` There are two writable parts of the tree, the `upload` directory and sub directories of the `album` directory. The `upload` directory is for uploading files you don't want to put into albums. This will be empty to start with and will contain the files you've uploaded for one rclone session only, becoming empty again when you restart rclone. The use case for this would be if you have a load of files you just want to once off dump into Google Photos. For repeated syncing, uploading to `album` will work better. Directories within the `album` directory are also writeable and you may create new directories (albums) under `album`. If you copy files with a directory hierarchy in there then rclone will create albums with the `/` character in them. For example if you do rclone copy /path/to/images remote:album/images and the images directory contains ``` images - file1.jpg dir file2.jpg dir2 dir3 file3.jpg ``` Then rclone will create the following albums with the following files in - images - file1.jpg - images/dir - file2.jpg - images/dir2/dir3 - file3.jpg This means that you can use the `album` path pretty much like a normal filesystem and it is a good target for repeated syncing. The `shared-album` directory shows albums shared with you or by you. This is similar to the Sharing tab in the Google Photos web interface. ### Standard options Here are the Standard options specific to google photos (Google Photos). #### --gphotos-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_GPHOTOS_CLIENT_ID - Type: string - Required: false #### --gphotos-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_GPHOTOS_CLIENT_SECRET - Type: string - Required: false #### --gphotos-read-only Set to make the Google Photos backend read only. If you choose read only then rclone will only request read only access to your photos, otherwise rclone will request full access. Properties: - Config: read_only - Env Var: RCLONE_GPHOTOS_READ_ONLY - Type: bool - Default: false ### Advanced options Here are the Advanced options specific to google photos (Google Photos). #### --gphotos-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_GPHOTOS_TOKEN - Type: string - Required: false #### --gphotos-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_GPHOTOS_AUTH_URL - Type: string - Required: false #### --gphotos-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_GPHOTOS_TOKEN_URL - Type: string - Required: false #### --gphotos-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_GPHOTOS_CLIENT_CREDENTIALS - Type: bool - Default: false #### --gphotos-read-size Set to read the size of media items. Normally rclone does not read the size of media items since this takes another transaction. This isn't necessary for syncing. However rclone mount needs to know the size of files in advance of reading them, so setting this flag when using rclone mount is recommended if you want to read the media. Properties: - Config: read_size - Env Var: RCLONE_GPHOTOS_READ_SIZE - Type: bool - Default: false #### --gphotos-start-year Year limits the photos to be downloaded to those which are uploaded after the given year. Properties: - Config: start_year - Env Var: RCLONE_GPHOTOS_START_YEAR - Type: int - Default: 2000 #### --gphotos-include-archived Also view and download archived media. By default, rclone does not request archived media. Thus, when syncing, archived media is not visible in directory listings or transferred. Note that media in albums is always visible and synced, no matter their archive status. With this flag, archived media are always visible in directory listings and transferred. Without this flag, archived media will not be visible in directory listings and won't be transferred. Properties: - Config: include_archived - Env Var: RCLONE_GPHOTOS_INCLUDE_ARCHIVED - Type: bool - Default: false #### --gphotos-proxy Use the gphotosdl proxy for downloading the full resolution images The Google API will deliver images and video which aren't full resolution, and/or have EXIF data missing. However if you use the gphotosdl proxy then you can download original, unchanged images. This runs a headless browser in the background. Download the software from [gphotosdl](https://github.com/rclone/gphotosdl) First run with gphotosdl -login Then once you have logged into google photos close the browser window and run gphotosdl Then supply the parameter `--gphotos-proxy "http://localhost:8282"` to make rclone use the proxy. Properties: - Config: proxy - Env Var: RCLONE_GPHOTOS_PROXY - Type: string - Required: false #### --gphotos-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_GPHOTOS_ENCODING - Type: Encoding - Default: Slash,CrLf,InvalidUtf8,Dot #### --gphotos-batch-mode Upload file batching sync|async|off. This sets the batch mode used by rclone. This has 3 possible values - off - no batching - sync - batch uploads and check completion (default) - async - batch upload and don't check completion Rclone will close any outstanding batches when it exits which may make a delay on quit. Properties: - Config: batch_mode - Env Var: RCLONE_GPHOTOS_BATCH_MODE - Type: string - Default: "sync" #### --gphotos-batch-size Max number of files in upload batch. This sets the batch size of files to upload. It has to be less than 50. By default this is 0 which means rclone will calculate the batch size depending on the setting of batch_mode. - batch_mode: async - default batch_size is 50 - batch_mode: sync - default batch_size is the same as --transfers - batch_mode: off - not in use Rclone will close any outstanding batches when it exits which may make a delay on quit. Setting this is a great idea if you are uploading lots of small files as it will make them a lot quicker. You can use --transfers 32 to maximise throughput. Properties: - Config: batch_size - Env Var: RCLONE_GPHOTOS_BATCH_SIZE - Type: int - Default: 0 #### --gphotos-batch-timeout Max time to allow an idle upload batch before uploading. If an upload batch is idle for more than this long then it will be uploaded. The default for this is 0 which means rclone will choose a sensible default based on the batch_mode in use. - batch_mode: async - default batch_timeout is 10s - batch_mode: sync - default batch_timeout is 1s - batch_mode: off - not in use Properties: - Config: batch_timeout - Env Var: RCLONE_GPHOTOS_BATCH_TIMEOUT - Type: Duration - Default: 0s #### --gphotos-batch-commit-timeout Max time to wait for a batch to finish committing. (no longer used) Properties: - Config: batch_commit_timeout - Env Var: RCLONE_GPHOTOS_BATCH_COMMIT_TIMEOUT - Type: Duration - Default: 10m0s #### --gphotos-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_GPHOTOS_DESCRIPTION - Type: string - Required: false ## Limitations Only images and videos can be uploaded. If you attempt to upload non videos or images or formats that Google Photos doesn't understand, rclone will upload the file, then Google Photos will give an error when it is put turned into a media item. **NB** From March 31, 2025 rclone can only download photos it uploaded. This limitation is due to policy changes at Google. You may need to run `rclone config reconnect remote:` to make rclone work again after upgrading to rclone v1.70. Note that all media items uploaded to Google Photos through the API are stored in full resolution at "original quality" and **will** count towards your storage quota in your Google Account. The API does **not** offer a way to upload in "high quality" mode.. `rclone about` is not supported by the Google Photos backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) See [rclone about](https://rclone.org/commands/rclone_about/) ### Downloading Images When Images are downloaded this strips EXIF location (according to the docs and my tests). This is a limitation of the Google Photos API and is covered by [bug #112096115](https://issuetracker.google.com/issues/112096115). **The current google API does not allow photos to be downloaded at original resolution. This is very important if you are, for example, relying on "Google Photos" as a backup of your photos. You will not be able to use rclone to redownload original images. You could use 'google takeout' to recover the original photos as a last resort** **NB** you **can** use the [--gphotos-proxy](#gphotos-proxy) flag to use a headless browser to download images in full resolution. ### Downloading Videos When videos are downloaded they are downloaded in a really compressed version of the video compared to downloading it via the Google Photos web interface. This is covered by [bug #113672044](https://issuetracker.google.com/issues/113672044). **NB** you **can** use the [--gphotos-proxy](#gphotos-proxy) flag to use a headless browser to download images in full resolution. ### Duplicates If a file name is duplicated in a directory then rclone will add the file ID into its name. So two files called `file.jpg` would then appear as `file {123456}.jpg` and `file {ABCDEF}.jpg` (the actual IDs are a lot longer alas!). If you upload the same image (with the same binary data) twice then Google Photos will deduplicate it. However it will retain the filename from the first upload which may confuse rclone. For example if you uploaded an image to `upload` then uploaded the same image to `album/my_album` the filename of the image in `album/my_album` will be what it was uploaded with initially, not what you uploaded it with to `album`. In practise this shouldn't cause too many problems. ### Modification times The date shown of media in Google Photos is the creation date as determined by the EXIF information, or the upload date if that is not known. This is not changeable by rclone and is not the modification date of the media on local disk. This means that rclone cannot use the dates from Google Photos for syncing purposes. ### Size The Google Photos API does not return the size of media. This means that when syncing to Google Photos, rclone can only do a file existence check. It is possible to read the size of the media, but this needs an extra HTTP HEAD request per media item so is **very slow** and uses up a lot of transactions. This can be enabled with the `--gphotos-read-size` option or the `read_size = true` config parameter. If you want to use the backend with `rclone mount` you may need to enable this flag (depending on your OS and application using the photos) otherwise you may not be able to read media off the mount. You'll need to experiment to see if it works for you without the flag. ### Albums Rclone can only upload files to albums it created. This is a [limitation of the Google Photos API](https://developers.google.com/photos/library/guides/manage-albums). Rclone can remove files it uploaded from albums it created only. ### Deleting files Rclone can remove files from albums it created, but note that the Google Photos API does not allow media to be deleted permanently so this media will still remain. See [bug #109759781](https://issuetracker.google.com/issues/109759781). Rclone cannot delete files anywhere except under `album`. ### Deleting albums The Google Photos API does not support deleting albums - see [bug #135714733](https://issuetracker.google.com/issues/135714733). ## Making your own client_id When you use rclone with Google photos in its default configuration you are using rclone's client_id. This is shared between all the rclone users. There is a global rate limit on the number of queries per second that each client_id can do set by Google. If there is a problem with this client_id (eg quota too low or the client_id stops working) then you can make your own. Please follow the steps in [the google drive docs](https://rclone.org/drive/#making-your-own-client-id). You will need these scopes instead of the drive ones detailed: ``` https://www.googleapis.com/auth/photoslibrary.appendonly https://www.googleapis.com/auth/photoslibrary.readonly.appcreateddata https://www.googleapis.com/auth/photoslibrary.edit.appcreateddata ``` # Hasher Hasher is a special overlay backend to create remotes which handle checksums for other remotes. It's main functions include: - Emulate hash types unimplemented by backends - Cache checksums to help with slow hashing of large local or (S)FTP files - Warm up checksum cache from external SUM files ## Getting started To use Hasher, first set up the underlying remote following the configuration instructions for that remote. You can also use a local pathname instead of a remote. Check that your base remote is working. Let's call the base remote `myRemote:path` here. Note that anything inside `myRemote:path` will be handled by hasher and anything outside won't. This means that if you are using a bucket based remote (S3, B2, Swift) then you should put the bucket in the remote `s3:bucket`. Now proceed to interactive or manual configuration. ### Interactive configuration Run `rclone config`: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> Hasher1 Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Handle checksums for other remotes \ "hasher" [snip] Storage> hasher Remote to cache checksums for, like myremote:mypath. Enter a string value. Press Enter for the default (""). remote> myRemote:path Comma separated list of supported checksum types. Enter a string value. Press Enter for the default ("md5,sha1"). hashsums> md5 Maximum time to keep checksums in cache. 0 = no cache, off = cache forever. max_age> off Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config -------------------- [Hasher1] type = hasher remote = myRemote:path hashsums = md5 max_age = off -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` ### Manual configuration Run `rclone config path` to see the path of current active config file, usually `YOURHOME/.config/rclone/rclone.conf`. Open it in your favorite text editor, find section for the base remote and create new section for hasher like in the following examples: ``` [Hasher1] type = hasher remote = myRemote:path hashes = md5 max_age = off [Hasher2] type = hasher remote = /local/path hashes = dropbox,sha1 max_age = 24h ``` Hasher takes basically the following parameters: - `remote` is required, - `hashes` is a comma separated list of supported checksums (by default `md5,sha1`), - `max_age` - maximum time to keep a checksum value in the cache, `0` will disable caching completely, `off` will cache "forever" (that is until the files get changed). Make sure the `remote` has `:` (colon) in. If you specify the remote without a colon then rclone will use a local directory of that name. So if you use a remote of `/local/path` then rclone will handle hashes for that directory. If you use `remote = name` literally then rclone will put files **in a directory called `name` located under current directory**. ## Usage ### Basic operations Now you can use it as `Hasher2:subdir/file` instead of base remote. Hasher will transparently update cache with new checksums when a file is fully read or overwritten, like: ``` rclone copy External:path/file Hasher:dest/path rclone cat Hasher:path/to/file > /dev/null ``` The way to refresh **all** cached checksums (even unsupported by the base backend) for a subtree is to **re-download** all files in the subtree. For example, use `hashsum --download` using **any** supported hashsum on the command line (we just care to re-read): ``` rclone hashsum MD5 --download Hasher:path/to/subtree > /dev/null rclone backend dump Hasher:path/to/subtree ``` You can print or drop hashsum cache using custom backend commands: ``` rclone backend dump Hasher:dir/subdir rclone backend drop Hasher: ``` ### Pre-Seed from a SUM File Hasher supports two backend commands: generic SUM file `import` and faster but less consistent `stickyimport`. ``` rclone backend import Hasher:dir/subdir SHA1 /path/to/SHA1SUM [--checkers 4] ``` Instead of SHA1 it can be any hash supported by the remote. The last argument can point to either a local or an `other-remote:path` text file in SUM format. The command will parse the SUM file, then walk down the path given by the first argument, snapshot current fingerprints and fill in the cache entries correspondingly. - Paths in the SUM file are treated as relative to `hasher:dir/subdir`. - The command will **not** check that supplied values are correct. You **must know** what you are doing. - This is a one-time action. The SUM file will not get "attached" to the remote. Cache entries can still be overwritten later, should the object's fingerprint change. - The tree walk can take long depending on the tree size. You can increase `--checkers` to make it faster. Or use `stickyimport` if you don't care about fingerprints and consistency. ``` rclone backend stickyimport hasher:path/to/data sha1 remote:/path/to/sum.sha1 ``` `stickyimport` is similar to `import` but works much faster because it does not need to stat existing files and skips initial tree walk. Instead of binding cache entries to file fingerprints it creates _sticky_ entries bound to the file name alone ignoring size, modification time etc. Such hash entries can be replaced only by `purge`, `delete`, `backend drop` or by full re-read/re-write of the files. ## Configuration reference ### Standard options Here are the Standard options specific to hasher (Better checksums for other remotes). #### --hasher-remote Remote to cache checksums for (e.g. myRemote:path). Properties: - Config: remote - Env Var: RCLONE_HASHER_REMOTE - Type: string - Required: true #### --hasher-hashes Comma separated list of supported checksum types. Properties: - Config: hashes - Env Var: RCLONE_HASHER_HASHES - Type: CommaSepList - Default: md5,sha1 #### --hasher-max-age Maximum time to keep checksums in cache (0 = no cache, off = cache forever). Properties: - Config: max_age - Env Var: RCLONE_HASHER_MAX_AGE - Type: Duration - Default: off ### Advanced options Here are the Advanced options specific to hasher (Better checksums for other remotes). #### --hasher-auto-size Auto-update checksum for files smaller than this size (disabled by default). Properties: - Config: auto_size - Env Var: RCLONE_HASHER_AUTO_SIZE - Type: SizeSuffix - Default: 0 #### --hasher-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_HASHER_DESCRIPTION - Type: string - Required: false ### Metadata Any metadata supported by the underlying remote is read and written. See the [metadata](https://rclone.org/docs/#metadata) docs for more info. ## Backend commands Here are the commands specific to the hasher backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the [backend](https://rclone.org/commands/rclone_backend/) command for more info on how to pass options and arguments. These can be run on a running backend using the rc command [backend/command](https://rclone.org/rc/#backend-command). ### drop Drop cache rclone backend drop remote: [options] [+] Completely drop checksum cache. Usage Example: rclone backend drop hasher: ### dump Dump the database rclone backend dump remote: [options] [+] Dump cache records covered by the current remote ### fulldump Full dump of the database rclone backend fulldump remote: [options] [+] Dump all cache records in the database ### import Import a SUM file rclone backend import remote: [options] [+] Amend hash cache from a SUM file and bind checksums to files by size/time. Usage Example: rclone backend import hasher:subdir md5 /path/to/sum.md5 ### stickyimport Perform fast import of a SUM file rclone backend stickyimport remote: [options] [+] Fill hash cache from a SUM file without verifying file fingerprints. Usage Example: rclone backend stickyimport hasher:subdir md5 remote:path/to/sum.md5 ## Implementation details (advanced) This section explains how various rclone operations work on a hasher remote. **Disclaimer. This section describes current implementation which can change in future rclone versions!.** ### Hashsum command The `rclone hashsum` (or `md5sum` or `sha1sum`) command will: 1. if requested hash is supported by lower level, just pass it. 2. if object size is below `auto_size` then download object and calculate _requested_ hashes on the fly. 3. if unsupported and the size is big enough, build object `fingerprint` (including size, modtime if supported, first-found _other_ hash if any). 4. if the strict match is found in cache for the requested remote, return the stored hash. 5. if remote found but fingerprint mismatched, then purge the entry and proceed to step 6. 6. if remote not found or had no requested hash type or after step 5: download object, calculate all _supported_ hashes on the fly and store in cache; return requested hash. ### Other operations - any time a hash is requested, follow the logic from 1-4 from `hashsum` above - whenever a file is uploaded or downloaded **in full**, capture the stream to calculate all supported hashes on the fly and update database - server-side `move` will update keys of existing cache entries - `deletefile` will remove a single cache entry - `purge` will remove all cache entries under the purged path Note that setting `max_age = 0` will disable checksum caching completely. If you set `max_age = off`, checksums in cache will never age, unless you fully rewrite or delete the file. ### Cache storage Cached checksums are stored as `bolt` database files under rclone cache directory, usually `~/.cache/rclone/kv/`. Databases are maintained one per _base_ backend, named like `BaseRemote~hasher.bolt`. Checksums for multiple `alias`-es into a single base backend will be stored in the single database. All local paths are treated as aliases into the `local` backend (unless encrypted or chunked) and stored in `~/.cache/rclone/kv/local~hasher.bolt`. Databases can be shared between multiple rclone processes. # HDFS [HDFS](https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-hdfs/HdfsDesign.html) is a distributed file-system, part of the [Apache Hadoop](https://hadoop.apache.org/) framework. Paths are specified as `remote:` or `remote:path/to/dir`. ## Configuration Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [skip] XX / Hadoop distributed file system \ "hdfs" [skip] Storage> hdfs ** See help for hdfs backend at: https://rclone.org/hdfs/ ** hadoop name node and port Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Connect to host namenode at port 8020 \ "namenode:8020" namenode> namenode.hadoop:8020 hadoop user name Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Connect to hdfs as root \ "root" username> root Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config Configuration complete. Options: - type: hdfs - namenode: namenode.hadoop:8020 - username: root Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== hadoop hdfs e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q ``` This remote is called `remote` and can now be used like this See all the top level directories rclone lsd remote: List the contents of a directory rclone ls remote:directory Sync the remote `directory` to `/home/local/directory`, deleting any excess files. rclone sync --interactive remote:directory /home/local/directory ### Setting up your own HDFS instance for testing You may start with a [manual setup](https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-common/SingleCluster.html) or use the docker image from the tests: If you want to build the docker image ``` git clone https://github.com/rclone/rclone.git cd rclone/fstest/testserver/images/test-hdfs docker build --rm -t rclone/test-hdfs . ``` Or you can just use the latest one pushed ``` docker run --rm --name "rclone-hdfs" -p 127.0.0.1:9866:9866 -p 127.0.0.1:8020:8020 --hostname "rclone-hdfs" rclone/test-hdfs ``` **NB** it need few seconds to startup. For this docker image the remote needs to be configured like this: ``` [remote] type = hdfs namenode = 127.0.0.1:8020 username = root ``` You can stop this image with `docker kill rclone-hdfs` (**NB** it does not use volumes, so all data uploaded will be lost.) ### Modification times Time accurate to 1 second is stored. ### Checksum No checksums are implemented. ### Usage information You can use the `rclone about remote:` command which will display filesystem size and current usage. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | : | 0x3A | ： | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8). ### Standard options Here are the Standard options specific to hdfs (Hadoop distributed file system). #### --hdfs-namenode Hadoop name nodes and ports. E.g. "namenode-1:8020,namenode-2:8020,..." to connect to host namenodes at port 8020. Properties: - Config: namenode - Env Var: RCLONE_HDFS_NAMENODE - Type: CommaSepList - Default: #### --hdfs-username Hadoop user name. Properties: - Config: username - Env Var: RCLONE_HDFS_USERNAME - Type: string - Required: false - Examples: - "root" - Connect to hdfs as root. ### Advanced options Here are the Advanced options specific to hdfs (Hadoop distributed file system). #### --hdfs-service-principal-name Kerberos service principal name for the namenode. Enables KERBEROS authentication. Specifies the Service Principal Name (SERVICE/FQDN) for the namenode. E.g. \"hdfs/namenode.hadoop.docker\" for namenode running as service 'hdfs' with FQDN 'namenode.hadoop.docker'. Properties: - Config: service_principal_name - Env Var: RCLONE_HDFS_SERVICE_PRINCIPAL_NAME - Type: string - Required: false #### --hdfs-data-transfer-protection Kerberos data transfer protection: authentication|integrity|privacy. Specifies whether or not authentication, data signature integrity checks, and wire encryption are required when communicating with the datanodes. Possible values are 'authentication', 'integrity' and 'privacy'. Used only with KERBEROS enabled. Properties: - Config: data_transfer_protection - Env Var: RCLONE_HDFS_DATA_TRANSFER_PROTECTION - Type: string - Required: false - Examples: - "privacy" - Ensure authentication, integrity and encryption enabled. #### --hdfs-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_HDFS_ENCODING - Type: Encoding - Default: Slash,Colon,Del,Ctl,InvalidUtf8,Dot #### --hdfs-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_HDFS_DESCRIPTION - Type: string - Required: false ## Limitations - No server-side `Move` or `DirMove`. - Checksums not implemented. # HiDrive Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. The initial setup for hidrive involves getting a token from HiDrive which you need to do in your browser. `rclone config` walks you through it. ## Configuration Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found - make a new one n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / HiDrive \ "hidrive" [snip] Storage> hidrive OAuth Client Id - Leave blank normally. client_id> OAuth Client Secret - Leave blank normally. client_secret> Access permissions that rclone should use when requesting access from HiDrive. Leave blank normally. scope_access> Edit advanced config? y/n> n Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth?state=xxxxxxxxxxxxxxxxxxxxxx Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: hidrive - token: {"access_token":"xxxxxxxxxxxxxxxxxxxx","token_type":"Bearer","refresh_token":"xxxxxxxxxxxxxxxxxxxxxxx","expiry":"xxxxxxxxxxxxxxxxxxxxxxx"} Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` **You should be aware that OAuth-tokens can be used to access your account and hence should not be shared with other persons.** See the [below section](#keeping-your-tokens-safe) for more information. See the [remote setup docs](https://rclone.org/remote_setup/) for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from HiDrive. This only runs from the moment it opens your browser to the moment you get back the verification code. The webserver runs on `http://127.0.0.1:53682/`. If local port `53682` is protected by a firewall you may need to temporarily unblock the firewall to complete authorization. Once configured you can then use `rclone` like this, List directories in top level of your HiDrive root folder rclone lsd remote: List all the files in your HiDrive filesystem rclone ls remote: To copy a local directory to a HiDrive directory called backup rclone copy /home/source remote:backup ### Keeping your tokens safe Any OAuth-tokens will be stored by rclone in the remote's configuration file as unencrypted text. Anyone can use a valid refresh-token to access your HiDrive filesystem without knowing your password. Therefore you should make sure no one else can access your configuration. It is possible to encrypt rclone's configuration file. You can find information on securing your configuration file by viewing the [configuration encryption docs](https://rclone.org/docs/#configuration-encryption). ### Invalid refresh token As can be verified [here](https://developer.hidrive.com/basics-flows/), each `refresh_token` (for Native Applications) is valid for 60 days. If used to access HiDrivei, its validity will be automatically extended. This means that if you * Don't use the HiDrive remote for 60 days then rclone will return an error which includes a text that implies the refresh token is *invalid* or *expired*. To fix this you will need to authorize rclone to access your HiDrive account again. Using rclone config reconnect remote: the process is very similar to the process of initial setup exemplified before. ### Modification times and hashes HiDrive allows modification times to be set on objects accurate to 1 second. HiDrive supports [its own hash type](https://static.hidrive.com/dev/0001) which is used to verify the integrity of file contents after successful transfers. ### Restricted filename characters HiDrive cannot store files or folders that include `/` (0x2F) or null-bytes (0x00) in their name. Any other characters can be used in the names of files or folders. Additionally, files or folders cannot be named either of the following: `.` or `..` Therefore rclone will automatically replace these characters, if files or folders are stored or accessed with such names. You can read about how this filename encoding works in general [here](overview/#restricted-filenames). Keep in mind that HiDrive only supports file or folder names with a length of 255 characters or less. ### Transfers HiDrive limits file sizes per single request to a maximum of 2 GiB. To allow storage of larger files and allow for better upload performance, the hidrive backend will use a chunked transfer for files larger than 96 MiB. Rclone will upload multiple parts/chunks of the file at the same time. Chunks in the process of being uploaded are buffered in memory, so you may want to restrict this behaviour on systems with limited resources. You can customize this behaviour using the following options: * `chunk_size`: size of file parts * `upload_cutoff`: files larger or equal to this in size will use a chunked transfer * `upload_concurrency`: number of file-parts to upload at the same time See the below section about configuration options for more details. ### Root folder You can set the root folder for rclone. This is the directory that rclone considers to be the root of your HiDrive. Usually, you will leave this blank, and rclone will use the root of the account. However, you can set this to restrict rclone to a specific folder hierarchy. This works by prepending the contents of the `root_prefix` option to any paths accessed by rclone. For example, the following two ways to access the home directory are equivalent: rclone lsd --hidrive-root-prefix="/users/test/" remote:path rclone lsd remote:/users/test/path See the below section about configuration options for more details. ### Directory member count By default, rclone will know the number of directory members contained in a directory. For example, `rclone lsd` uses this information. The acquisition of this information will result in additional time costs for HiDrive's API. When dealing with large directory structures, it may be desirable to circumvent this time cost, especially when this information is not explicitly needed. For this, the `disable_fetching_member_count` option can be used. See the below section about configuration options for more details. ### Standard options Here are the Standard options specific to hidrive (HiDrive). #### --hidrive-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_HIDRIVE_CLIENT_ID - Type: string - Required: false #### --hidrive-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_HIDRIVE_CLIENT_SECRET - Type: string - Required: false #### --hidrive-scope-access Access permissions that rclone should use when requesting access from HiDrive. Properties: - Config: scope_access - Env Var: RCLONE_HIDRIVE_SCOPE_ACCESS - Type: string - Default: "rw" - Examples: - "rw" - Read and write access to resources. - "ro" - Read-only access to resources. ### Advanced options Here are the Advanced options specific to hidrive (HiDrive). #### --hidrive-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_HIDRIVE_TOKEN - Type: string - Required: false #### --hidrive-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_HIDRIVE_AUTH_URL - Type: string - Required: false #### --hidrive-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_HIDRIVE_TOKEN_URL - Type: string - Required: false #### --hidrive-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_HIDRIVE_CLIENT_CREDENTIALS - Type: bool - Default: false #### --hidrive-scope-role User-level that rclone should use when requesting access from HiDrive. Properties: - Config: scope_role - Env Var: RCLONE_HIDRIVE_SCOPE_ROLE - Type: string - Default: "user" - Examples: - "user" - User-level access to management permissions. - This will be sufficient in most cases. - "admin" - Extensive access to management permissions. - "owner" - Full access to management permissions. #### --hidrive-root-prefix The root/parent folder for all paths. Fill in to use the specified folder as the parent for all paths given to the remote. This way rclone can use any folder as its starting point. Properties: - Config: root_prefix - Env Var: RCLONE_HIDRIVE_ROOT_PREFIX - Type: string - Default: "/" - Examples: - "/" - The topmost directory accessible by rclone. - This will be equivalent with "root" if rclone uses a regular HiDrive user account. - "root" - The topmost directory of the HiDrive user account - "" - This specifies that there is no root-prefix for your paths. - When using this you will always need to specify paths to this remote with a valid parent e.g. "remote:/path/to/dir" or "remote:root/path/to/dir". #### --hidrive-endpoint Endpoint for the service. This is the URL that API-calls will be made to. Properties: - Config: endpoint - Env Var: RCLONE_HIDRIVE_ENDPOINT - Type: string - Default: "https://api.hidrive.strato.com/2.1" #### --hidrive-disable-fetching-member-count Do not fetch number of objects in directories unless it is absolutely necessary. Requests may be faster if the number of objects in subdirectories is not fetched. Properties: - Config: disable_fetching_member_count - Env Var: RCLONE_HIDRIVE_DISABLE_FETCHING_MEMBER_COUNT - Type: bool - Default: false #### --hidrive-chunk-size Chunksize for chunked uploads. Any files larger than the configured cutoff (or files of unknown size) will be uploaded in chunks of this size. The upper limit for this is 2147483647 bytes (about 2.000Gi). That is the maximum amount of bytes a single upload-operation will support. Setting this above the upper limit or to a negative value will cause uploads to fail. Setting this to larger values may increase the upload speed at the cost of using more memory. It can be set to smaller values smaller to save on memory. Properties: - Config: chunk_size - Env Var: RCLONE_HIDRIVE_CHUNK_SIZE - Type: SizeSuffix - Default: 48Mi #### --hidrive-upload-cutoff Cutoff/Threshold for chunked uploads. Any files larger than this will be uploaded in chunks of the configured chunksize. The upper limit for this is 2147483647 bytes (about 2.000Gi). That is the maximum amount of bytes a single upload-operation will support. Setting this above the upper limit will cause uploads to fail. Properties: - Config: upload_cutoff - Env Var: RCLONE_HIDRIVE_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 96Mi #### --hidrive-upload-concurrency Concurrency for chunked uploads. This is the upper limit for how many transfers for the same file are running concurrently. Setting this above to a value smaller than 1 will cause uploads to deadlock. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. Properties: - Config: upload_concurrency - Env Var: RCLONE_HIDRIVE_UPLOAD_CONCURRENCY - Type: int - Default: 4 #### --hidrive-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_HIDRIVE_ENCODING - Type: Encoding - Default: Slash,Dot #### --hidrive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_HIDRIVE_DESCRIPTION - Type: string - Required: false ## Limitations ### Symbolic links HiDrive is able to store symbolic links (*symlinks*) by design, for example, when unpacked from a zip archive. There exists no direct mechanism to manage native symlinks in remotes. As such this implementation has chosen to ignore any native symlinks present in the remote. rclone will not be able to access or show any symlinks stored in the hidrive-remote. This means symlinks cannot be individually removed, copied, or moved, except when removing, copying, or moving the parent folder. *This does not affect the `.rclonelink`-files that rclone uses to encode and store symbolic links.* ### Sparse files It is possible to store sparse files in HiDrive. Note that copying a sparse file will expand the holes into null-byte (0x00) regions that will then consume disk space. Likewise, when downloading a sparse file, the resulting file will have null-byte regions in the place of file holes. # HTTP The HTTP remote is a read only remote for reading files of a webserver. The webserver should provide file listings which rclone will read and turn into a remote. This has been tested with common webservers such as Apache/Nginx/Caddy and will likely work with file listings from most web servers. (If it doesn't then please file an issue, or send a pull request!) Paths are specified as `remote:` or `remote:path`. The `remote:` represents the configured [url](#http-url), and any path following it will be resolved relative to this url, according to the URL standard. This means with remote url `https://beta.rclone.org/branch` and path `fix`, the resolved URL will be `https://beta.rclone.org/branch/fix`, while with path `/fix` the resolved URL will be `https://beta.rclone.org/fix` as the absolute path is resolved from the root of the domain. If the path following the `remote:` ends with `/` it will be assumed to point to a directory. If the path does not end with `/`, then a HEAD request is sent and the response used to decide if it it is treated as a file or a directory (run with `-vv` to see details). When [--http-no-head](#http-no-head) is specified, a path without ending `/` is always assumed to be a file. If rclone incorrectly assumes the path is a file, the solution is to specify the path with ending `/`. When you know the path is a directory, ending it with `/` is always better as it avoids the initial HEAD request. To just download a single file it is easier to use [copyurl](https://rclone.org/commands/rclone_copyurl/). ## Configuration Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / HTTP \ "http" [snip] Storage> http URL of http host to connect to Choose a number from below, or type in your own value 1 / Connect to example.com \ "https://example.com" url> https://beta.rclone.org Remote config Configuration complete. Options: - type: http - url: https://beta.rclone.org Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== remote http e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q ``` This remote is called `remote` and can now be used like this See all the top level directories rclone lsd remote: List the contents of a directory rclone ls remote:directory Sync the remote `directory` to `/home/local/directory`, deleting any excess files. rclone sync --interactive remote:directory /home/local/directory ### Read only This remote is read only - you can't upload files to an HTTP server. ### Modification times Most HTTP servers store time accurate to 1 second. ### Checksum No checksums are stored. ### Usage without a config file Since the http remote only has one config parameter it is easy to use without a config file: rclone lsd --http-url https://beta.rclone.org :http: or: rclone lsd :http,url='https://beta.rclone.org': ### Standard options Here are the Standard options specific to http (HTTP). #### --http-url URL of HTTP host to connect to. E.g. "https://example.com", or "https://user:pass@example.com" to use a username and password. Properties: - Config: url - Env Var: RCLONE_HTTP_URL - Type: string - Required: true #### --http-no-escape Do not escape URL metacharacters in path names. Properties: - Config: no_escape - Env Var: RCLONE_HTTP_NO_ESCAPE - Type: bool - Default: false ### Advanced options Here are the Advanced options specific to http (HTTP). #### --http-headers Set HTTP headers for all transactions. Use this to set additional HTTP headers for all transactions. The input format is comma separated list of key,value pairs. Standard [CSV encoding](https://godoc.org/encoding/csv) may be used. For example, to set a Cookie use 'Cookie,name=value', or '"Cookie","name=value"'. You can set multiple headers, e.g. '"Cookie","name=value","Authorization","xxx"'. Properties: - Config: headers - Env Var: RCLONE_HTTP_HEADERS - Type: CommaSepList - Default: #### --http-no-slash Set this if the site doesn't end directories with /. Use this if your target website does not use / on the end of directories. A / on the end of a path is how rclone normally tells the difference between files and directories. If this flag is set, then rclone will treat all files with Content-Type: text/html as directories and read URLs from them rather than downloading them. Note that this may cause rclone to confuse genuine HTML files with directories. Properties: - Config: no_slash - Env Var: RCLONE_HTTP_NO_SLASH - Type: bool - Default: false #### --http-no-head Don't use HEAD requests. HEAD requests are mainly used to find file sizes in dir listing. If your site is being very slow to load then you can try this option. Normally rclone does a HEAD request for each potential file in a directory listing to: - find its size - check it really exists - check to see if it is a directory If you set this option, rclone will not do the HEAD request. This will mean that directory listings are much quicker, but rclone won't have the times or sizes of any files, and some files that don't exist may be in the listing. Properties: - Config: no_head - Env Var: RCLONE_HTTP_NO_HEAD - Type: bool - Default: false #### --http-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_HTTP_DESCRIPTION - Type: string - Required: false ## Backend commands Here are the commands specific to the http backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the [backend](https://rclone.org/commands/rclone_backend/) command for more info on how to pass options and arguments. These can be run on a running backend using the rc command [backend/command](https://rclone.org/rc/#backend-command). ### set Set command for updating the config parameters. rclone backend set remote: [options] [+] This set command can be used to update the config parameters for a running http backend. Usage Examples: rclone backend set remote: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=remote: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=remote: -o url=https://example.com The option keys are named as they are in the config file. This rebuilds the connection to the http backend when it is called with the new parameters. Only new parameters need be passed as the values will default to those currently in use. It doesn't return anything. ## Limitations `rclone about` is not supported by the HTTP backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) # ImageKit This is a backend for the [ImageKit.io](https://imagekit.io/) storage service. #### About ImageKit [ImageKit.io](https://imagekit.io/) provides real-time image and video optimizations, transformations, and CDN delivery. Over 1,000 businesses and 70,000 developers trust ImageKit with their images and videos on the web. #### Accounts & Pricing To use this backend, you need to [create an account](https://imagekit.io/registration/) on ImageKit. Start with a free plan with generous usage limits. Then, as your requirements grow, upgrade to a plan that best fits your needs. See [the pricing details](https://imagekit.io/plans). ## Configuration Here is an example of making an imagekit configuration. Firstly create a [ImageKit.io](https://imagekit.io/) account and choose a plan. You will need to log in and get the `publicKey` and `privateKey` for your account from the developer section. Now run ``` rclone config ``` This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter the name for the new remote. name> imagekit-media-library Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / ImageKit.io \ (imagekit) [snip] Storage> imagekit Option endpoint. You can find your ImageKit.io URL endpoint in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) Enter a value. endpoint> https://ik.imagekit.io/imagekit_id Option public_key. You can find your ImageKit.io public key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) Enter a value. public_key> public_**************************** Option private_key. You can find your ImageKit.io private key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) Enter a value. private_key> private_**************************** Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: imagekit - endpoint: https://ik.imagekit.io/imagekit_id - public_key: public_**************************** - private_key: private_**************************** Keep this "imagekit-media-library" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` List directories in the top level of your Media Library ``` rclone lsd imagekit-media-library: ``` Make a new directory. ``` rclone mkdir imagekit-media-library:directory ``` List the contents of a directory. ``` rclone ls imagekit-media-library:directory ``` ### Modified time and hashes ImageKit does not support modification times or hashes yet. ### Checksums No checksums are supported. ### Standard options Here are the Standard options specific to imagekit (ImageKit.io). #### --imagekit-endpoint You can find your ImageKit.io URL endpoint in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) Properties: - Config: endpoint - Env Var: RCLONE_IMAGEKIT_ENDPOINT - Type: string - Required: true #### --imagekit-public-key You can find your ImageKit.io public key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) Properties: - Config: public_key - Env Var: RCLONE_IMAGEKIT_PUBLIC_KEY - Type: string - Required: true #### --imagekit-private-key You can find your ImageKit.io private key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) Properties: - Config: private_key - Env Var: RCLONE_IMAGEKIT_PRIVATE_KEY - Type: string - Required: true ### Advanced options Here are the Advanced options specific to imagekit (ImageKit.io). #### --imagekit-only-signed If you have configured `Restrict unsigned image URLs` in your dashboard settings, set this to true. Properties: - Config: only_signed - Env Var: RCLONE_IMAGEKIT_ONLY_SIGNED - Type: bool - Default: false #### --imagekit-versions Include old versions in directory listings. Properties: - Config: versions - Env Var: RCLONE_IMAGEKIT_VERSIONS - Type: bool - Default: false #### --imagekit-upload-tags Tags to add to the uploaded files, e.g. "tag1,tag2". Properties: - Config: upload_tags - Env Var: RCLONE_IMAGEKIT_UPLOAD_TAGS - Type: string - Required: false #### --imagekit-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_IMAGEKIT_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Dollar,Question,Hash,Percent,BackSlash,Del,Ctl,InvalidUtf8,Dot,SquareBracket #### --imagekit-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_IMAGEKIT_DESCRIPTION - Type: string - Required: false ### Metadata Any metadata supported by the underlying remote is read and written. Here are the possible system metadata items for the imagekit backend. | Name | Help | Type | Example | Read Only | |------|------|------|---------|-----------| | aws-tags | AI generated tags by AWS Rekognition associated with the image | string | tag1,tag2 | **Y** | | btime | Time of file birth (creation) read from Last-Modified header | RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | **Y** | | custom-coordinates | Custom coordinates of the file | string | 0,0,100,100 | **Y** | | file-type | Type of the file | string | image | **Y** | | google-tags | AI generated tags by Google Cloud Vision associated with the image | string | tag1,tag2 | **Y** | | has-alpha | Whether the image has alpha channel or not | bool | | **Y** | | height | Height of the image or video in pixels | int | | **Y** | | is-private-file | Whether the file is private or not | bool | | **Y** | | size | Size of the object in bytes | int64 | | **Y** | | tags | Tags associated with the file | string | tag1,tag2 | **Y** | | width | Width of the image or video in pixels | int | | **Y** | See the [metadata](https://rclone.org/docs/#metadata) docs for more info. # iCloud Drive ## Configuration The initial setup for an iCloud Drive backend involves getting a trust token/session. This can be done by simply using the regular iCloud password, and accepting the code prompt on another iCloud connected device. **IMPORTANT**: At the moment an app specific password won't be accepted. Only use your regular password and 2FA. `rclone config` walks you through the token creation. The trust token is valid for 30 days. After which you will have to reauthenticate with `rclone reconnect` or `rclone config`. Here is an example of how to make a remote called `iclouddrive`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> iclouddrive Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / iCloud Drive \ (iclouddrive) [snip] Storage> iclouddrive Option apple_id. Apple ID. Enter a value. apple_id> APPLEID Option password. Password. Choose an alternative below. y) Yes, type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n Option config_2fa. Two-factor authentication: please enter your 2FA code Enter a value. config_2fa> 2FACODE Remote config -------------------- [iclouddrive] - type: iclouddrive - apple_id: APPLEID - password: *** ENCRYPTED *** - cookies: **************************** - trust_token: **************************** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ## Advanced Data Protection ADP is currently unsupported and need to be disabled On iPhone, Settings `>` Apple Account `>` iCloud `>` 'Access iCloud Data on the Web' must be ON, and 'Advanced Data Protection' OFF. ## Troubleshooting ### Missing PCS cookies from the request This means you have Advanced Data Protection (ADP) turned on. This is not supported at the moment. If you want to use rclone you will have to turn it off. See above for how to turn it off. You will need to clear the `cookies` and the `trust_token` fields in the config. Or you can delete the remote config and start again. You should then run `rclone reconnect remote:`. Note that changing the ADP setting may not take effect immediately - you may need to wait a few hours or a day before you can get rclone to work - keep clearing the config entry and running `rclone reconnect remote:` until rclone functions properly. ### Standard options Here are the Standard options specific to iclouddrive (iCloud Drive). #### --iclouddrive-apple-id Apple ID. Properties: - Config: apple_id - Env Var: RCLONE_ICLOUDDRIVE_APPLE_ID - Type: string - Required: true #### --iclouddrive-password Password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: password - Env Var: RCLONE_ICLOUDDRIVE_PASSWORD - Type: string - Required: true #### --iclouddrive-trust-token Trust token (internal use) Properties: - Config: trust_token - Env Var: RCLONE_ICLOUDDRIVE_TRUST_TOKEN - Type: string - Required: false #### --iclouddrive-cookies cookies (internal use only) Properties: - Config: cookies - Env Var: RCLONE_ICLOUDDRIVE_COOKIES - Type: string - Required: false ### Advanced options Here are the Advanced options specific to iclouddrive (iCloud Drive). #### --iclouddrive-client-id Client id Properties: - Config: client_id - Env Var: RCLONE_ICLOUDDRIVE_CLIENT_ID - Type: string - Default: "d39ba9916b7251055b22c7f910e2ea796ee65e98b2ddecea8f5dde8d9d1a815d" #### --iclouddrive-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_ICLOUDDRIVE_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot #### --iclouddrive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_ICLOUDDRIVE_DESCRIPTION - Type: string - Required: false # Internet Archive The Internet Archive backend utilizes Items on [archive.org](https://archive.org/) Refer to [IAS3 API documentation](https://archive.org/services/docs/api/ias3.html) for the API this backend uses. Paths are specified as `remote:bucket` (or `remote:` for the `lsd` command.) You may put subdirectories in too, e.g. `remote:item/path/to/dir`. Unlike S3, listing up all items uploaded by you isn't supported. Once you have made a remote, you can use it like this: Make a new item rclone mkdir remote:item List the contents of a item rclone ls remote:item Sync `/home/local/directory` to the remote item, deleting any excess files in the item. rclone sync --interactive /home/local/directory remote:item ## Notes Because of Internet Archive's architecture, it enqueues write operations (and extra post-processings) in a per-item queue. You can check item's queue at https://catalogd.archive.org/history/item-name-here . Because of that, all uploads/deletes will not show up immediately and takes some time to be available. The per-item queue is enqueued to an another queue, Item Deriver Queue. [You can check the status of Item Deriver Queue here.](https://catalogd.archive.org/catalog.php?whereami=1) This queue has a limit, and it may block you from uploading, or even deleting. You should avoid uploading a lot of small files for better behavior. You can optionally wait for the server's processing to finish, by setting non-zero value to `wait_archive` key. By making it wait, rclone can do normal file comparison. Make sure to set a large enough value (e.g. `30m0s` for smaller files) as it can take a long time depending on server's queue. ## About metadata This backend supports setting, updating and reading metadata of each file. The metadata will appear as file metadata on Internet Archive. However, some fields are reserved by both Internet Archive and rclone. The following are reserved by Internet Archive: - `name` - `source` - `size` - `md5` - `crc32` - `sha1` - `format` - `old_version` - `viruscheck` - `summation` Trying to set values to these keys is ignored with a warning. Only setting `mtime` is an exception. Doing so make it the identical behavior as setting ModTime. rclone reserves all the keys starting with `rclone-`. Setting value for these keys will give you warnings, but values are set according to request. If there are multiple values for a key, only the first one is returned. This is a limitation of rclone, that supports one value per one key. It can be triggered when you did a server-side copy. Reading metadata will also provide custom (non-standard nor reserved) ones. ## Filtering auto generated files The Internet Archive automatically creates metadata files after upload. These can cause problems when doing an `rclone sync` as rclone will try, and fail, to delete them. These metadata files are not changeable, as they are created by the Internet Archive automatically. These auto-created files can be excluded from the sync using [metadata filtering](https://rclone.org/filtering/#metadata). rclone sync ... --metadata-exclude "source=metadata" --metadata-exclude "format=Metadata" Which excludes from the sync any files which have the `source=metadata` or `format=Metadata` flags which are added to Internet Archive auto-created files. ## Configuration Here is an example of making an internetarchive configuration. Most applies to the other providers as well, any differences are described [below](#providers). First run rclone config This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. XX / InternetArchive Items \ (internetarchive) Storage> internetarchive Option access_key_id. IAS3 Access Key. Leave blank for anonymous access. You can find one here: https://archive.org/account/s3.php Enter a value. Press Enter to leave empty. access_key_id> XXXX Option secret_access_key. IAS3 Secret Key (password). Leave blank for anonymous access. Enter a value. Press Enter to leave empty. secret_access_key> XXXX Edit advanced config? y) Yes n) No (default) y/n> y Option endpoint. IAS3 Endpoint. Leave blank for default value. Enter a string value. Press Enter for the default (https://s3.us.archive.org). endpoint> Option front_endpoint. Host of InternetArchive Frontend. Leave blank for default value. Enter a string value. Press Enter for the default (https://archive.org). front_endpoint> Option disable_checksum. Don't store MD5 checksum with object metadata. Normally rclone will calculate the MD5 checksum of the input before uploading it so it can ask the server to check the object against checksum. This is great for data integrity checking but can cause long delays for large files to start uploading. Enter a boolean value (true or false). Press Enter for the default (true). disable_checksum> true Option encoding. The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Enter a encoder.MultiEncoder value. Press Enter for the default (Slash,Question,Hash,Percent,Del,Ctl,InvalidUtf8,Dot). encoding> Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: internetarchive - access_key_id: XXXX - secret_access_key: XXXX Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ### Standard options Here are the Standard options specific to internetarchive (Internet Archive). #### --internetarchive-access-key-id IAS3 Access Key. Leave blank for anonymous access. You can find one here: https://archive.org/account/s3.php Properties: - Config: access_key_id - Env Var: RCLONE_INTERNETARCHIVE_ACCESS_KEY_ID - Type: string - Required: false #### --internetarchive-secret-access-key IAS3 Secret Key (password). Leave blank for anonymous access. Properties: - Config: secret_access_key - Env Var: RCLONE_INTERNETARCHIVE_SECRET_ACCESS_KEY - Type: string - Required: false #### --internetarchive-item-derive Whether to trigger derive on the IA item or not. If set to false, the item will not be derived by IA upon upload. The derive process produces a number of secondary files from an upload to make an upload more usable on the web. Setting this to false is useful for uploading files that are already in a format that IA can display or reduce burden on IA's infrastructure. Properties: - Config: item_derive - Env Var: RCLONE_INTERNETARCHIVE_ITEM_DERIVE - Type: bool - Default: true ### Advanced options Here are the Advanced options specific to internetarchive (Internet Archive). #### --internetarchive-endpoint IAS3 Endpoint. Leave blank for default value. Properties: - Config: endpoint - Env Var: RCLONE_INTERNETARCHIVE_ENDPOINT - Type: string - Default: "https://s3.us.archive.org" #### --internetarchive-front-endpoint Host of InternetArchive Frontend. Leave blank for default value. Properties: - Config: front_endpoint - Env Var: RCLONE_INTERNETARCHIVE_FRONT_ENDPOINT - Type: string - Default: "https://archive.org" #### --internetarchive-item-metadata Metadata to be set on the IA item, this is different from file-level metadata that can be set using --metadata-set. Format is key=value and the 'x-archive-meta-' prefix is automatically added. Properties: - Config: item_metadata - Env Var: RCLONE_INTERNETARCHIVE_ITEM_METADATA - Type: stringArray - Default: [] #### --internetarchive-disable-checksum Don't ask the server to test against MD5 checksum calculated by rclone. Normally rclone will calculate the MD5 checksum of the input before uploading it so it can ask the server to check the object against checksum. This is great for data integrity checking but can cause long delays for large files to start uploading. Properties: - Config: disable_checksum - Env Var: RCLONE_INTERNETARCHIVE_DISABLE_CHECKSUM - Type: bool - Default: true #### --internetarchive-wait-archive Timeout for waiting the server's processing tasks (specifically archive and book_op) to finish. Only enable if you need to be guaranteed to be reflected after write operations. 0 to disable waiting. No errors to be thrown in case of timeout. Properties: - Config: wait_archive - Env Var: RCLONE_INTERNETARCHIVE_WAIT_ARCHIVE - Type: Duration - Default: 0s #### --internetarchive-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_INTERNETARCHIVE_ENCODING - Type: Encoding - Default: Slash,LtGt,CrLf,Del,Ctl,InvalidUtf8,Dot #### --internetarchive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_INTERNETARCHIVE_DESCRIPTION - Type: string - Required: false ### Metadata Metadata fields provided by Internet Archive. If there are multiple values for a key, only the first one is returned. This is a limitation of Rclone, that supports one value per one key. Owner is able to add custom keys. Metadata feature grabs all the keys including them. Here are the possible system metadata items for the internetarchive backend. | Name | Help | Type | Example | Read Only | |------|------|------|---------|-----------| | crc32 | CRC32 calculated by Internet Archive | string | 01234567 | **Y** | | format | Name of format identified by Internet Archive | string | Comma-Separated Values | **Y** | | md5 | MD5 hash calculated by Internet Archive | string | 01234567012345670123456701234567 | **Y** | | mtime | Time of last modification, managed by Rclone | RFC 3339 | 2006-01-02T15:04:05.999999999Z | **Y** | | name | Full file path, without the bucket part | filename | backend/internetarchive/internetarchive.go | **Y** | | old_version | Whether the file was replaced and moved by keep-old-version flag | boolean | true | **Y** | | rclone-ia-mtime | Time of last modification, managed by Internet Archive | RFC 3339 | 2006-01-02T15:04:05.999999999Z | N | | rclone-mtime | Time of last modification, managed by Rclone | RFC 3339 | 2006-01-02T15:04:05.999999999Z | N | | rclone-update-track | Random value used by Rclone for tracking changes inside Internet Archive | string | aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa | N | | sha1 | SHA1 hash calculated by Internet Archive | string | 0123456701234567012345670123456701234567 | **Y** | | size | File size in bytes | decimal number | 123456 | **Y** | | source | The source of the file | string | original | **Y** | | summation | Check https://forum.rclone.org/t/31922 for how it is used | string | md5 | **Y** | | viruscheck | The last time viruscheck process was run for the file (?) | unixtime | 1654191352 | **Y** | See the [metadata](https://rclone.org/docs/#metadata) docs for more info. # Jottacloud Jottacloud is a cloud storage service provider from a Norwegian company, using its own datacenters in Norway. In addition to the official service at [jottacloud.com](https://www.jottacloud.com/), it also provides white-label solutions to different companies, such as: * Telia * Telia Cloud (cloud.telia.se) * Telia Sky (sky.telia.no) * Tele2 * Tele2 Cloud (mittcloud.tele2.se) * Onlime * Onlime Cloud Storage (onlime.dk) * Elkjøp (with subsidiaries): * Elkjøp Cloud (cloud.elkjop.no) * Elgiganten Sweden (cloud.elgiganten.se) * Elgiganten Denmark (cloud.elgiganten.dk) * Giganti Cloud (cloud.gigantti.fi) * ELKO Cloud (cloud.elko.is) Most of the white-label versions are supported by this backend, although may require different authentication setup - described below. Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Authentication types Some of the whitelabel versions uses a different authentication method than the official service, and you have to choose the correct one when setting up the remote. ### Standard authentication The standard authentication method used by the official service (jottacloud.com), as well as some of the whitelabel services, requires you to generate a single-use personal login token from the account security settings in the service's web interface. Log in to your account, go to "Settings" and then "Security", or use the direct link presented to you by rclone when configuring the remote: . Scroll down to the section "Personal login token", and click the "Generate" button. Note that if you are using a whitelabel service you probably can't use the direct link, you need to find the same page in their dedicated web interface, and also it may be in a different location than described above. To access your account from multiple instances of rclone, you need to configure each of them with a separate personal login token. E.g. you create a Jottacloud remote with rclone in one location, and copy the configuration file to a second location where you also want to run rclone and access the same remote. Then you need to replace the token for one of them, using the [config reconnect](https://rclone.org/commands/rclone_config_reconnect/) command, which requires you to generate a new personal login token and supply as input. If you do not do this, the token may easily end up being invalidated, resulting in both instances failing with an error message something along the lines of: oauth2: cannot fetch token: 400 Bad Request Response: {"error":"invalid_grant","error_description":"Stale token"} When this happens, you need to replace the token as described above to be able to use your remote again. All personal login tokens you have taken into use will be listed in the web interface under "My logged in devices", and from the right side of that list you can click the "X" button to revoke individual tokens. ### Legacy authentication If you are using one of the whitelabel versions (e.g. from Elkjøp) you may not have the option to generate a CLI token. In this case you'll have to use the legacy authentication. To do this select yes when the setup asks for legacy authentication and enter your username and password. The rest of the setup is identical to the default setup. ### Telia Cloud authentication Similar to other whitelabel versions Telia Cloud doesn't offer the option of creating a CLI token, and additionally uses a separate authentication flow where the username is generated internally. To setup rclone to use Telia Cloud, choose Telia Cloud authentication in the setup. The rest of the setup is identical to the default setup. ### Tele2 Cloud authentication As Tele2-Com Hem merger was completed this authentication can be used for former Com Hem Cloud and Tele2 Cloud customers as no support for creating a CLI token exists, and additionally uses a separate authentication flow where the username is generated internally. To setup rclone to use Tele2 Cloud, choose Tele2 Cloud authentication in the setup. The rest of the setup is identical to the default setup. ### Onlime Cloud Storage authentication Onlime has sold access to Jottacloud proper, while providing localized support to Danish Customers, but have recently set up their own hosting, transferring their customers from Jottacloud servers to their own ones. This, of course, necessitates using their servers for authentication, but otherwise functionality and architecture seems equivalent to Jottacloud. To setup rclone to use Onlime Cloud Storage, choose Onlime Cloud authentication in the setup. The rest of the setup is identical to the default setup. ## Configuration Here is an example of how to make a remote called `remote` with the default setup. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Jottacloud \ (jottacloud) [snip] Storage> jottacloud Edit advanced config? y) Yes n) No (default) y/n> n Option config_type. Select authentication type. Choose a number from below, or type in an existing string value. Press Enter for the default (standard). / Standard authentication. 1 | Use this if you're a normal Jottacloud user. \ (standard) / Legacy authentication. 2 | This is only required for certain whitelabel versions of Jottacloud and not recommended for normal users. \ (legacy) / Telia Cloud authentication. 3 | Use this if you are using Telia Cloud. \ (telia) / Tele2 Cloud authentication. 4 | Use this if you are using Tele2 Cloud. \ (tele2) / Onlime Cloud authentication. 5 | Use this if you are using Onlime Cloud. \ (onlime) config_type> 1 Personal login token. Generate here: https://www.jottacloud.com/web/secure Login Token> Use a non-standard device/mountpoint? Choosing no, the default, will let you access the storage used for the archive section of the official Jottacloud client. If you instead want to access the sync or the backup section, for example, you must choose yes. y) Yes n) No (default) y/n> y Option config_device. The device to use. In standard setup the built-in Jotta device is used, which contains predefined mountpoints for archive, sync etc. All other devices are treated as backup devices by the official Jottacloud client. You may create a new by entering a unique name. Choose a number from below, or type in your own string value. Press Enter for the default (DESKTOP-3H31129). 1 > DESKTOP-3H31129 2 > Jotta config_device> 2 Option config_mountpoint. The mountpoint to use for the built-in device Jotta. The standard setup is to use the Archive mountpoint. Most other mountpoints have very limited support in rclone and should generally be avoided. Choose a number from below, or type in an existing string value. Press Enter for the default (Archive). 1 > Archive 2 > Shared 3 > Sync config_mountpoint> 1 Configuration complete. Options: - type: jottacloud - configVersion: 1 - client_id: jottacli - client_secret: - tokenURL: https://id.jottacloud.com/auth/realms/jottacloud/protocol/openid-connect/token - token: {........} - username: 2940e57271a93d987d6f8a21 - device: Jotta - mountpoint: Archive Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` Once configured you can then use `rclone` like this, List directories in top level of your Jottacloud rclone lsd remote: List all the files in your Jottacloud rclone ls remote: To copy a local directory to an Jottacloud directory called backup rclone copy /home/source remote:backup ### Devices and Mountpoints The official Jottacloud client registers a device for each computer you install it on, and shows them in the backup section of the user interface. For each folder you select for backup it will create a mountpoint within this device. A built-in device called Jotta is special, and contains mountpoints Archive, Sync and some others, used for corresponding features in official clients. With rclone you'll want to use the standard Jotta/Archive device/mountpoint in most cases. However, you may for example want to access files from the sync or backup functionality provided by the official clients, and rclone therefore provides the option to select other devices and mountpoints during config. You are allowed to create new devices and mountpoints. All devices except the built-in Jotta device are treated as backup devices by official Jottacloud clients, and the mountpoints on them are individual backup sets. With the built-in Jotta device, only existing, built-in, mountpoints can be selected. In addition to the mentioned Archive and Sync, it may contain several other mountpoints such as: Latest, Links, Shared and Trash. All of these are special mountpoints with a different internal representation than the "regular" mountpoints. Rclone will only to a very limited degree support them. Generally you should avoid these, unless you know what you are doing. ### --fast-list This backend supports `--fast-list` which allows you to use fewer transactions in exchange for more memory. See the [rclone docs](https://rclone.org/docs/#fast-list) for more details. Note that the implementation in Jottacloud always uses only a single API request to get the entire list, so for large folders this could lead to long wait time before the first results are shown. Note also that with rclone version 1.58 and newer, information about [MIME types](https://rclone.org/overview/#mime-type) and metadata item [utime](#metadata) are not available when using `--fast-list`. ### Modification times and hashes Jottacloud allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not. Jottacloud supports MD5 type hashes, so you can use the `--checksum` flag. Note that Jottacloud requires the MD5 hash before upload so if the source does not have an MD5 checksum then the file will be cached temporarily on disk (in location given by [--temp-dir](https://rclone.org/docs/#temp-dir-string)) before it is uploaded. Small files will be cached in memory - see the [--jottacloud-md5-memory-limit](#jottacloud-md5-memory-limit) flag. When uploading from local disk the source checksum is always available, so this does not apply. Starting with rclone version 1.52 the same is true for encrypted remotes (in older versions the crypt backend would not calculate hashes for uploads from local disk, so the Jottacloud backend had to do it as described above). ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | " | 0x22 | ＂ | | * | 0x2A | ＊ | | : | 0x3A | ： | | < | 0x3C | ＜ | | > | 0x3E | ＞ | | ? | 0x3F | ？ | | \| | 0x7C | ｜ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in XML strings. ### Deleting files By default, rclone will send all files to the trash when deleting files. They will be permanently deleted automatically after 30 days. You may bypass the trash and permanently delete files immediately by using the [--jottacloud-hard-delete](#jottacloud-hard-delete) flag, or set the equivalent environment variable. Emptying the trash is supported by the [cleanup](https://rclone.org/commands/rclone_cleanup/) command. ### Versions Jottacloud supports file versioning. When rclone uploads a new version of a file it creates a new version of it. Currently rclone only supports retrieving the current version but older versions can be accessed via the Jottacloud Website. Versioning can be disabled by `--jottacloud-no-versions` option. This is achieved by deleting the remote file prior to uploading a new version. If the upload the fails no version of the file will be available in the remote. ### Quota information To view your current quota you can use the `rclone about remote:` command which will display your usage limit (unless it is unlimited) and the current usage. ### Standard options Here are the Standard options specific to jottacloud (Jottacloud). #### --jottacloud-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_JOTTACLOUD_CLIENT_ID - Type: string - Required: false #### --jottacloud-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_JOTTACLOUD_CLIENT_SECRET - Type: string - Required: false ### Advanced options Here are the Advanced options specific to jottacloud (Jottacloud). #### --jottacloud-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_JOTTACLOUD_TOKEN - Type: string - Required: false #### --jottacloud-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_JOTTACLOUD_AUTH_URL - Type: string - Required: false #### --jottacloud-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_JOTTACLOUD_TOKEN_URL - Type: string - Required: false #### --jottacloud-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_JOTTACLOUD_CLIENT_CREDENTIALS - Type: bool - Default: false #### --jottacloud-md5-memory-limit Files bigger than this will be cached on disk to calculate the MD5 if required. Properties: - Config: md5_memory_limit - Env Var: RCLONE_JOTTACLOUD_MD5_MEMORY_LIMIT - Type: SizeSuffix - Default: 10Mi #### --jottacloud-trashed-only Only show files that are in the trash. This will show trashed files in their original directory structure. Properties: - Config: trashed_only - Env Var: RCLONE_JOTTACLOUD_TRASHED_ONLY - Type: bool - Default: false #### --jottacloud-hard-delete Delete files permanently rather than putting them into the trash. Properties: - Config: hard_delete - Env Var: RCLONE_JOTTACLOUD_HARD_DELETE - Type: bool - Default: false #### --jottacloud-upload-resume-limit Files bigger than this can be resumed if the upload fail's. Properties: - Config: upload_resume_limit - Env Var: RCLONE_JOTTACLOUD_UPLOAD_RESUME_LIMIT - Type: SizeSuffix - Default: 10Mi #### --jottacloud-no-versions Avoid server side versioning by deleting files and recreating files instead of overwriting them. Properties: - Config: no_versions - Env Var: RCLONE_JOTTACLOUD_NO_VERSIONS - Type: bool - Default: false #### --jottacloud-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_JOTTACLOUD_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,Del,Ctl,InvalidUtf8,Dot #### --jottacloud-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_JOTTACLOUD_DESCRIPTION - Type: string - Required: false ### Metadata Jottacloud has limited support for metadata, currently an extended set of timestamps. Here are the possible system metadata items for the jottacloud backend. | Name | Help | Type | Example | Read Only | |------|------|------|---------|-----------| | btime | Time of file birth (creation), read from rclone metadata | RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | N | | content-type | MIME type, also known as media type | string | text/plain | **Y** | | mtime | Time of last modification, read from rclone metadata | RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | N | | utime | Time of last upload, when current revision was created, generated by backend | RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | **Y** | See the [metadata](https://rclone.org/docs/#metadata) docs for more info. ## Limitations Note that Jottacloud is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". There are quite a few characters that can't be in Jottacloud file names. Rclone will map these names to and from an identical looking unicode equivalent. For example if a file has a ? in it will be mapped to ？ instead. Jottacloud only supports filenames up to 255 characters in length. ## Troubleshooting Jottacloud exhibits some inconsistent behaviours regarding deleted files and folders which may cause Copy, Move and DirMove operations to previously deleted paths to fail. Emptying the trash should help in such cases. # Koofr Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configuration The initial setup for Koofr involves creating an application password for rclone. You can do that by opening the Koofr [web application](https://app.koofr.net/app/admin/preferences/password), giving the password a nice name like `rclone` and clicking on generate. Here is an example of how to make a remote called `koofr`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> koofr Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] 22 / Koofr, Digi Storage and other Koofr-compatible storage providers \ (koofr) [snip] Storage> koofr Option provider. Choose your storage provider. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Koofr, https://app.koofr.net/ \ (koofr) 2 / Digi Storage, https://storage.rcs-rds.ro/ \ (digistorage) 3 / Any other Koofr API compatible storage service \ (other) provider> 1 Option user. Your user name. Enter a value. user> USERNAME Option password. Your password for rclone (generate one at https://app.koofr.net/app/admin/preferences/password). Choose an alternative below. y) Yes, type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n Remote config -------------------- [koofr] type = koofr provider = koofr user = USERNAME password = *** ENCRYPTED *** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` You can choose to edit advanced config in order to enter your own service URL if you use an on-premise or white label Koofr instance, or choose an alternative mount instead of your primary storage. Once configured you can then use `rclone` like this, List directories in top level of your Koofr rclone lsd koofr: List all the files in your Koofr rclone ls koofr: To copy a local directory to an Koofr directory called backup rclone copy /home/source koofr:backup ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | \ | 0x5C | ＼ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in XML strings. ### Standard options Here are the Standard options specific to koofr (Koofr, Digi Storage and other Koofr-compatible storage providers). #### --koofr-provider Choose your storage provider. Properties: - Config: provider - Env Var: RCLONE_KOOFR_PROVIDER - Type: string - Required: false - Examples: - "koofr" - Koofr, https://app.koofr.net/ - "digistorage" - Digi Storage, https://storage.rcs-rds.ro/ - "other" - Any other Koofr API compatible storage service #### --koofr-endpoint The Koofr API endpoint to use. Properties: - Config: endpoint - Env Var: RCLONE_KOOFR_ENDPOINT - Provider: other - Type: string - Required: true #### --koofr-user Your user name. Properties: - Config: user - Env Var: RCLONE_KOOFR_USER - Type: string - Required: true #### --koofr-password Your password for rclone generate one at https://app.koofr.net/app/admin/preferences/password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: password - Env Var: RCLONE_KOOFR_PASSWORD - Provider: koofr - Type: string - Required: true ### Advanced options Here are the Advanced options specific to koofr (Koofr, Digi Storage and other Koofr-compatible storage providers). #### --koofr-mountid Mount ID of the mount to use. If omitted, the primary mount is used. Properties: - Config: mountid - Env Var: RCLONE_KOOFR_MOUNTID - Type: string - Required: false #### --koofr-setmtime Does the backend support setting modification time. Set this to false if you use a mount ID that points to a Dropbox or Amazon Drive backend. Properties: - Config: setmtime - Env Var: RCLONE_KOOFR_SETMTIME - Type: bool - Default: true #### --koofr-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_KOOFR_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot #### --koofr-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_KOOFR_DESCRIPTION - Type: string - Required: false ## Limitations Note that Koofr is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". ## Providers ### Koofr This is the original [Koofr](https://koofr.eu) storage provider used as main example and described in the [configuration](#configuration) section above. ### Digi Storage [Digi Storage](https://www.digi.ro/servicii/online/digi-storage) is a cloud storage service run by [Digi.ro](https://www.digi.ro/) that provides a Koofr API. Here is an example of how to make a remote called `ds`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> ds Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] 22 / Koofr, Digi Storage and other Koofr-compatible storage providers \ (koofr) [snip] Storage> koofr Option provider. Choose your storage provider. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Koofr, https://app.koofr.net/ \ (koofr) 2 / Digi Storage, https://storage.rcs-rds.ro/ \ (digistorage) 3 / Any other Koofr API compatible storage service \ (other) provider> 2 Option user. Your user name. Enter a value. user> USERNAME Option password. Your password for rclone (generate one at https://storage.rcs-rds.ro/app/admin/preferences/password). Choose an alternative below. y) Yes, type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n -------------------- [ds] type = koofr provider = digistorage user = USERNAME password = *** ENCRYPTED *** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ### Other You may also want to use another, public or private storage provider that runs a Koofr API compatible service, by simply providing the base URL to connect to. Here is an example of how to make a remote called `other`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> other Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] 22 / Koofr, Digi Storage and other Koofr-compatible storage providers \ (koofr) [snip] Storage> koofr Option provider. Choose your storage provider. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Koofr, https://app.koofr.net/ \ (koofr) 2 / Digi Storage, https://storage.rcs-rds.ro/ \ (digistorage) 3 / Any other Koofr API compatible storage service \ (other) provider> 3 Option endpoint. The Koofr API endpoint to use. Enter a value. endpoint> https://koofr.other.org Option user. Your user name. Enter a value. user> USERNAME Option password. Your password for rclone (generate one at your service's settings page). Choose an alternative below. y) Yes, type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n -------------------- [other] type = koofr provider = other endpoint = https://koofr.other.org user = USERNAME password = *** ENCRYPTED *** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` # Linkbox Linkbox is [a private cloud drive](https://linkbox.to/). ## Configuration Here is an example of making a remote for Linkbox. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. XX / Linkbox \ (linkbox) Storage> XX Option token. Token from https://www.linkbox.to/admin/account Enter a value. token> testFromCLToken Configuration complete. Options: - type: linkbox - token: XXXXXXXXXXX Keep this "linkbox" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ### Standard options Here are the Standard options specific to linkbox (Linkbox). #### --linkbox-token Token from https://www.linkbox.to/admin/account Properties: - Config: token - Env Var: RCLONE_LINKBOX_TOKEN - Type: string - Required: true ### Advanced options Here are the Advanced options specific to linkbox (Linkbox). #### --linkbox-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_LINKBOX_DESCRIPTION - Type: string - Required: false ## Limitations Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. # Mail.ru Cloud [Mail.ru Cloud](https://cloud.mail.ru/) is a cloud storage provided by a Russian internet company [Mail.Ru Group](https://mail.ru). The official desktop client is [Disk-O:](https://disk-o.cloud/en), available on Windows and Mac OS. ## Features highlights - Paths may be as deep as required, e.g. `remote:directory/subdirectory` - Files have a `last modified time` property, directories don't - Deleted files are by default moved to the trash - Files and directories can be shared via public links - Partial uploads or streaming are not supported, file size must be known before upload - Maximum file size is limited to 2G for a free account, unlimited for paid accounts - Storage keeps hash for all files and performs transparent deduplication, the hash algorithm is a modified SHA1 - If a particular file is already present in storage, one can quickly submit file hash instead of long file upload (this optimization is supported by rclone) ## Configuration Here is an example of making a mailru configuration. First create a Mail.ru Cloud account and choose a tariff. You will need to log in and create an app password for rclone. Rclone **will not work** with your normal username and password - it will give an error like `oauth2: server response missing access_token`. - Click on your user icon in the top right - Go to Security / "Пароль и безопасность" - Click password for apps / "Пароли для внешних приложений" - Add the password - give it a name - eg "rclone" - Select the permissions level. For some reason just "Full access to Cloud" (WebDav) doesn't work for Rclone currently. You have to select "Full access to Mail, Cloud and Calendar" (all protocols). ([thread on forum.rclone.org](https://forum.rclone.org/t/failed-to-create-file-system-for-mailru-failed-to-authorize-oauth2-invalid-username-or-password-username-or-password-is-incorrect/49298)) - Copy the password and use this password below - your normal login password won't work. Now run rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Mail.ru Cloud \ "mailru" [snip] Storage> mailru User name (usually email) Enter a string value. Press Enter for the default (""). user> username@mail.ru Password This must be an app password - rclone will not work with your normal password. See the Configuration section in the docs for how to make an app password. y) Yes type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Skip full upload if there is another file with same data hash. This feature is called "speedup" or "put by hash". It is especially efficient in case of generally available files like popular books, video or audio clips [snip] Enter a boolean value (true or false). Press Enter for the default ("true"). Choose a number from below, or type in your own value 1 / Enable \ "true" 2 / Disable \ "false" speedup_enable> 1 Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config Configuration complete. Options: - type: mailru - user: username@mail.ru - pass: *** ENCRYPTED *** - speedup_enable: true Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` Configuration of this backend does not require a local web browser. You can use the configured backend as shown below: See top level directories rclone lsd remote: Make a new directory rclone mkdir remote:directory List the contents of a directory rclone ls remote:directory Sync `/home/local/directory` to the remote path, deleting any excess files in the path. rclone sync --interactive /home/local/directory remote:directory ### Modification times and hashes Files support a modification time attribute with up to 1 second precision. Directories do not have a modification time, which is shown as "Jan 1 1970". File hashes are supported, with a custom Mail.ru algorithm based on SHA1. If file size is less than or equal to the SHA1 block size (20 bytes), its hash is simply its data right-padded with zero bytes. Hashes of a larger file is computed as a SHA1 of the file data bytes concatenated with a decimal representation of the data length. ### Emptying Trash Removing a file or directory actually moves it to the trash, which is not visible to rclone but can be seen in a web browser. The trashed file still occupies part of total quota. If you wish to empty your trash and free some quota, you can use the `rclone cleanup remote:` command, which will permanently delete all your trashed files. This command does not take any path arguments. ### Quota information To view your current quota you can use the `rclone about remote:` command which will display your usage limit (quota) and the current usage. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | " | 0x22 | ＂ | | * | 0x2A | ＊ | | : | 0x3A | ： | | < | 0x3C | ＜ | | > | 0x3E | ＞ | | ? | 0x3F | ？ | | \ | 0x5C | ＼ | | \| | 0x7C | ｜ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Standard options Here are the Standard options specific to mailru (Mail.ru Cloud). #### --mailru-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_MAILRU_CLIENT_ID - Type: string - Required: false #### --mailru-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_MAILRU_CLIENT_SECRET - Type: string - Required: false #### --mailru-user User name (usually email). Properties: - Config: user - Env Var: RCLONE_MAILRU_USER - Type: string - Required: true #### --mailru-pass Password. This must be an app password - rclone will not work with your normal password. See the Configuration section in the docs for how to make an app password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: pass - Env Var: RCLONE_MAILRU_PASS - Type: string - Required: true #### --mailru-speedup-enable Skip full upload if there is another file with same data hash. This feature is called "speedup" or "put by hash". It is especially efficient in case of generally available files like popular books, video or audio clips, because files are searched by hash in all accounts of all mailru users. It is meaningless and ineffective if source file is unique or encrypted. Please note that rclone may need local memory and disk space to calculate content hash in advance and decide whether full upload is required. Also, if rclone does not know file size in advance (e.g. in case of streaming or partial uploads), it will not even try this optimization. Properties: - Config: speedup_enable - Env Var: RCLONE_MAILRU_SPEEDUP_ENABLE - Type: bool - Default: true - Examples: - "true" - Enable - "false" - Disable ### Advanced options Here are the Advanced options specific to mailru (Mail.ru Cloud). #### --mailru-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_MAILRU_TOKEN - Type: string - Required: false #### --mailru-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_MAILRU_AUTH_URL - Type: string - Required: false #### --mailru-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_MAILRU_TOKEN_URL - Type: string - Required: false #### --mailru-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_MAILRU_CLIENT_CREDENTIALS - Type: bool - Default: false #### --mailru-speedup-file-patterns Comma separated list of file name patterns eligible for speedup (put by hash). Patterns are case insensitive and can contain '*' or '?' meta characters. Properties: - Config: speedup_file_patterns - Env Var: RCLONE_MAILRU_SPEEDUP_FILE_PATTERNS - Type: string - Default: "*.mkv,*.avi,*.mp4,*.mp3,*.zip,*.gz,*.rar,*.pdf" - Examples: - "" - Empty list completely disables speedup (put by hash). - "*" - All files will be attempted for speedup. - "*.mkv,*.avi,*.mp4,*.mp3" - Only common audio/video files will be tried for put by hash. - "*.zip,*.gz,*.rar,*.pdf" - Only common archives or PDF books will be tried for speedup. #### --mailru-speedup-max-disk This option allows you to disable speedup (put by hash) for large files. Reason is that preliminary hashing can exhaust your RAM or disk space. Properties: - Config: speedup_max_disk - Env Var: RCLONE_MAILRU_SPEEDUP_MAX_DISK - Type: SizeSuffix - Default: 3Gi - Examples: - "0" - Completely disable speedup (put by hash). - "1G" - Files larger than 1Gb will be uploaded directly. - "3G" - Choose this option if you have less than 3Gb free on local disk. #### --mailru-speedup-max-memory Files larger than the size given below will always be hashed on disk. Properties: - Config: speedup_max_memory - Env Var: RCLONE_MAILRU_SPEEDUP_MAX_MEMORY - Type: SizeSuffix - Default: 32Mi - Examples: - "0" - Preliminary hashing will always be done in a temporary disk location. - "32M" - Do not dedicate more than 32Mb RAM for preliminary hashing. - "256M" - You have at most 256Mb RAM free for hash calculations. #### --mailru-check-hash What should copy do if file checksum is mismatched or invalid. Properties: - Config: check_hash - Env Var: RCLONE_MAILRU_CHECK_HASH - Type: bool - Default: true - Examples: - "true" - Fail with error. - "false" - Ignore and continue. #### --mailru-user-agent HTTP user agent used internally by client. Defaults to "rclone/VERSION" or "--user-agent" provided on command line. Properties: - Config: user_agent - Env Var: RCLONE_MAILRU_USER_AGENT - Type: string - Required: false #### --mailru-quirks Comma separated list of internal maintenance flags. This option must not be used by an ordinary user. It is intended only to facilitate remote troubleshooting of backend issues. Strict meaning of flags is not documented and not guaranteed to persist between releases. Quirks will be removed when the backend grows stable. Supported quirks: atomicmkdir binlist unknowndirs Properties: - Config: quirks - Env Var: RCLONE_MAILRU_QUIRKS - Type: string - Required: false #### --mailru-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_MAILRU_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,InvalidUtf8,Dot #### --mailru-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_MAILRU_DESCRIPTION - Type: string - Required: false ## Limitations File size limits depend on your account. A single file size is limited by 2G for a free account and unlimited for paid tariffs. Please refer to the Mail.ru site for the total uploaded size limits. Note that Mailru is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". # Mega [Mega](https://mega.nz/) is a cloud storage and file hosting service known for its security feature where all files are encrypted locally before they are uploaded. This prevents anyone (including employees of Mega) from accessing the files without knowledge of the key used for encryption. This is an rclone backend for Mega which supports the file transfer features of Mega using the same client side encryption. Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configuration Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Mega \ "mega" [snip] Storage> mega User name user> you@example.com Password. y) Yes type in my own password g) Generate random password n) No leave this optional password blank y/g/n> y Enter the password: password: Confirm the password: password: Remote config Configuration complete. Options: - type: mega - user: you@example.com - pass: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` **NOTE:** The encryption keys need to have been already generated after a regular login via the browser, otherwise attempting to use the credentials in `rclone` will fail. Once configured you can then use `rclone` like this, List directories in top level of your Mega rclone lsd remote: List all the files in your Mega rclone ls remote: To copy a local directory to an Mega directory called backup rclone copy /home/source remote:backup ### Modification times and hashes Mega does not support modification times or hashes yet. ### Restricted filename characters | Character | Value | Replacement | | --------- |:-----:|:-----------:| | NUL | 0x00 | ␀ | | / | 0x2F | ／ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Duplicated files Mega can have two files with exactly the same name and path (unlike a normal file system). Duplicated files cause problems with the syncing and you will see messages in the log about duplicates. Use `rclone dedupe` to fix duplicated files. ### Failure to log-in #### Object not found If you are connecting to your Mega remote for the first time, to test access and synchronization, you may receive an error such as ``` Failed to create file system for "my-mega-remote:": couldn't login: Object (typically, node or user) not found ``` The diagnostic steps often recommended in the [rclone forum](https://forum.rclone.org/search?q=mega) start with the **MEGAcmd** utility. Note that this refers to the official C++ command from https://github.com/meganz/MEGAcmd and not the go language built command from t3rm1n4l/megacmd that is no longer maintained. Follow the instructions for installing MEGAcmd and try accessing your remote as they recommend. You can establish whether or not you can log in using MEGAcmd, and obtain diagnostic information to help you, and search or work with others in the forum. ``` MEGA CMD> login me@example.com Password: Fetching nodes ... Loading transfers from local cache Login complete as me@example.com me@example.com:/$ ``` Note that some have found issues with passwords containing special characters. If you can not log on with rclone, but MEGAcmd logs on just fine, then consider changing your password temporarily to pure alphanumeric characters, in case that helps. #### Repeated commands blocks access Mega remotes seem to get blocked (reject logins) under "heavy use". We haven't worked out the exact blocking rules but it seems to be related to fast paced, successive rclone commands. For example, executing this command 90 times in a row `rclone link remote:file` will cause the remote to become "blocked". This is not an abnormal situation, for example if you wish to get the public links of a directory with hundred of files... After more or less a week, the remote will remote accept rclone logins normally again. You can mitigate this issue by mounting the remote it with `rclone mount`. This will log-in when mounting and a log-out when unmounting only. You can also run `rclone rcd` and then use `rclone rc` to run the commands over the API to avoid logging in each time. Rclone does not currently close mega sessions (you can see them in the web interface), however closing the sessions does not solve the issue. If you space rclone commands by 3 seconds it will avoid blocking the remote. We haven't identified the exact blocking rules, so perhaps one could execute the command 80 times without waiting and avoid blocking by waiting 3 seconds, then continuing... Note that this has been observed by trial and error and might not be set in stone. Other tools seem not to produce this blocking effect, as they use a different working approach (state-based, using sessionIDs instead of log-in) which isn't compatible with the current stateless rclone approach. Note that once blocked, the use of other tools (such as megacmd) is not a sure workaround: following megacmd login times have been observed in succession for blocked remote: 7 minutes, 20 min, 30min, 30 min, 30min. Web access looks unaffected though. Investigation is continuing in relation to workarounds based on timeouts, pacers, retrials and tpslimits - if you discover something relevant, please post on the forum. So, if rclone was working nicely and suddenly you are unable to log-in and you are sure the user and the password are correct, likely you have got the remote blocked for a while. ### Standard options Here are the Standard options specific to mega (Mega). #### --mega-user User name. Properties: - Config: user - Env Var: RCLONE_MEGA_USER - Type: string - Required: true #### --mega-pass Password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: pass - Env Var: RCLONE_MEGA_PASS - Type: string - Required: true ### Advanced options Here are the Advanced options specific to mega (Mega). #### --mega-debug Output more debug from Mega. If this flag is set (along with -vv) it will print further debugging information from the mega backend. Properties: - Config: debug - Env Var: RCLONE_MEGA_DEBUG - Type: bool - Default: false #### --mega-hard-delete Delete files permanently rather than putting them into the trash. Normally the mega backend will put all deletions into the trash rather than permanently deleting them. If you specify this then rclone will permanently delete objects instead. Properties: - Config: hard_delete - Env Var: RCLONE_MEGA_HARD_DELETE - Type: bool - Default: false #### --mega-use-https Use HTTPS for transfers. MEGA uses plain text HTTP connections by default. Some ISPs throttle HTTP connections, this causes transfers to become very slow. Enabling this will force MEGA to use HTTPS for all transfers. HTTPS is normally not necessary since all data is already encrypted anyway. Enabling it will increase CPU usage and add network overhead. Properties: - Config: use_https - Env Var: RCLONE_MEGA_USE_HTTPS - Type: bool - Default: false #### --mega-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_MEGA_ENCODING - Type: Encoding - Default: Slash,InvalidUtf8,Dot #### --mega-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_MEGA_DESCRIPTION - Type: string - Required: false ### Process `killed` On accounts with large files or something else, memory usage can significantly increase when executing list/sync instructions. When running on cloud providers (like AWS with EC2), check if the instance type has sufficient memory/CPU to execute the commands. Use the resource monitoring tools to inspect after sending the commands. Look [at this issue](https://forum.rclone.org/t/rclone-with-mega-appears-to-work-only-in-some-accounts/40233/4). ## Limitations This backend uses the [go-mega go library](https://github.com/t3rm1n4l/go-mega) which is an opensource go library implementing the Mega API. There doesn't appear to be any documentation for the mega protocol beyond the [mega C++ SDK](https://github.com/meganz/sdk) source code so there are likely quite a few errors still remaining in this library. Mega allows duplicate files which may confuse rclone. # Memory The memory backend is an in RAM backend. It does not persist its data - use the local backend for that. The memory backend behaves like a bucket-based remote (e.g. like s3). Because it has no parameters you can just use it with the `:memory:` remote name. ## Configuration You can configure it as a remote like this with `rclone config` too if you want to: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Memory \ "memory" [snip] Storage> memory ** See help for memory backend at: https://rclone.org/memory/ ** Remote config Configuration complete. Options: - type: memory Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` Because the memory backend isn't persistent it is most useful for testing or with an rclone server or rclone mount, e.g. rclone mount :memory: /mnt/tmp rclone serve webdav :memory: rclone serve sftp :memory: ### Modification times and hashes The memory backend supports MD5 hashes and modification times accurate to 1 nS. ### Restricted filename characters The memory backend replaces the [default restricted characters set](https://rclone.org/overview/#restricted-characters). ### Advanced options Here are the Advanced options specific to memory (In memory object storage system.). #### --memory-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_MEMORY_DESCRIPTION - Type: string - Required: false # Akamai NetStorage Paths are specified as `remote:` You may put subdirectories in too, e.g. `remote:/path/to/dir`. If you have a CP code you can use that as the folder after the domain such as \\/\\/\. For example, this is commonly configured with or without a CP code: * **With a CP code**. `[your-domain-prefix]-nsu.akamaihd.net/123456/subdirectory/` * **Without a CP code**. `[your-domain-prefix]-nsu.akamaihd.net` See all buckets rclone lsd remote: The initial setup for Netstorage involves getting an account and secret. Use `rclone config` to walk you through the setup process. ## Configuration Here's an example of how to make a remote called `ns1`. 1. To begin the interactive configuration process, enter this command: ``` rclone config ``` 2. Type `n` to create a new remote. ``` n) New remote d) Delete remote q) Quit config e/n/d/q> n ``` 3. For this example, enter `ns1` when you reach the name> prompt. ``` name> ns1 ``` 4. Enter `netstorage` as the type of storage to configure. ``` Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value XX / NetStorage \ "netstorage" Storage> netstorage ``` 5. Select between the HTTP or HTTPS protocol. Most users should choose HTTPS, which is the default. HTTP is provided primarily for debugging purposes. ``` Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / HTTP protocol \ "http" 2 / HTTPS protocol \ "https" protocol> 1 ``` 6. Specify your NetStorage host, CP code, and any necessary content paths using this format: `///` ``` Enter a string value. Press Enter for the default (""). host> baseball-nsu.akamaihd.net/123456/content/ ``` 7. Set the netstorage account name ``` Enter a string value. Press Enter for the default (""). account> username ``` 8. Set the Netstorage account secret/G2O key which will be used for authentication purposes. Select the `y` option to set your own password then enter your secret. Note: The secret is stored in the `rclone.conf` file with hex-encoded encryption. ``` y) Yes type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: ``` 9. View the summary and confirm your remote configuration. ``` [ns1] type = netstorage protocol = http host = baseball-nsu.akamaihd.net/123456/content/ account = username secret = *** ENCRYPTED *** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` This remote is called `ns1` and can now be used. ## Example operations Get started with rclone and NetStorage with these examples. For additional rclone commands, visit https://rclone.org/commands/. ### See contents of a directory in your project rclone lsd ns1:/974012/testing/ ### Sync the contents local with remote rclone sync . ns1:/974012/testing/ ### Upload local content to remote rclone copy notes.txt ns1:/974012/testing/ ### Delete content on remote rclone delete ns1:/974012/testing/notes.txt ### Move or copy content between CP codes. Your credentials must have access to two CP codes on the same remote. You can't perform operations between different remotes. rclone move ns1:/974012/testing/notes.txt ns1:/974450/testing2/ ## Features ### Symlink Support The Netstorage backend changes the rclone `--links, -l` behavior. When uploading, instead of creating the .rclonelink file, use the "symlink" API in order to create the corresponding symlink on the remote. The .rclonelink file will not be created, the upload will be intercepted and only the symlink file that matches the source file name with no suffix will be created on the remote. This will effectively allow commands like copy/copyto, move/moveto and sync to upload from local to remote and download from remote to local directories with symlinks. Due to internal rclone limitations, it is not possible to upload an individual symlink file to any remote backend. You can always use the "backend symlink" command to create a symlink on the NetStorage server, refer to "symlink" section below. Individual symlink files on the remote can be used with the commands like "cat" to print the destination name, or "delete" to delete symlink, or copy, copy/to and move/moveto to download from the remote to local. Note: individual symlink files on the remote should be specified including the suffix .rclonelink. **Note**: No file with the suffix .rclonelink should ever exist on the server since it is not possible to actually upload/create a file with .rclonelink suffix with rclone, it can only exist if it is manually created through a non-rclone method on the remote. ### Implicit vs. Explicit Directories With NetStorage, directories can exist in one of two forms: 1. **Explicit Directory**. This is an actual, physical directory that you have created in a storage group. 2. **Implicit Directory**. This refers to a directory within a path that has not been physically created. For example, during upload of a file, nonexistent subdirectories can be specified in the target path. NetStorage creates these as "implicit." While the directories aren't physically created, they exist implicitly and the noted path is connected with the uploaded file. Rclone will intercept all file uploads and mkdir commands for the NetStorage remote and will explicitly issue the mkdir command for each directory in the uploading path. This will help with the interoperability with the other Akamai services such as SFTP and the Content Management Shell (CMShell). Rclone will not guarantee correctness of operations with implicit directories which might have been created as a result of using an upload API directly. ### `--fast-list` / ListR support NetStorage remote supports the ListR feature by using the "list" NetStorage API action to return a lexicographical list of all objects within the specified CP code, recursing into subdirectories as they're encountered. * **Rclone will use the ListR method for some commands by default**. Commands such as `lsf -R` will use ListR by default. To disable this, include the `--disable listR` option to use the non-recursive method of listing objects. * **Rclone will not use the ListR method for some commands**. Commands such as `sync` don't use ListR by default. To force using the ListR method, include the `--fast-list` option. There are pros and cons of using the ListR method, refer to [rclone documentation](https://rclone.org/docs/#fast-list). In general, the sync command over an existing deep tree on the remote will run faster with the "--fast-list" flag but with extra memory usage as a side effect. It might also result in higher CPU utilization but the whole task can be completed faster. **Note**: There is a known limitation that "lsf -R" will display number of files in the directory and directory size as -1 when ListR method is used. The workaround is to pass "--disable listR" flag if these numbers are important in the output. ### Purge NetStorage remote supports the purge feature by using the "quick-delete" NetStorage API action. The quick-delete action is disabled by default for security reasons and can be enabled for the account through the Akamai portal. Rclone will first try to use quick-delete action for the purge command and if this functionality is disabled then will fall back to a standard delete method. **Note**: Read the [NetStorage Usage API](https://learn.akamai.com/en-us/webhelp/netstorage/netstorage-http-api-developer-guide/GUID-15836617-9F50-405A-833C-EA2556756A30.html) for considerations when using "quick-delete". In general, using quick-delete method will not delete the tree immediately and objects targeted for quick-delete may still be accessible. ### Standard options Here are the Standard options specific to netstorage (Akamai NetStorage). #### --netstorage-host Domain+path of NetStorage host to connect to. Format should be `/` Properties: - Config: host - Env Var: RCLONE_NETSTORAGE_HOST - Type: string - Required: true #### --netstorage-account Set the NetStorage account name Properties: - Config: account - Env Var: RCLONE_NETSTORAGE_ACCOUNT - Type: string - Required: true #### --netstorage-secret Set the NetStorage account secret/G2O key for authentication. Please choose the 'y' option to set your own password then enter your secret. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: secret - Env Var: RCLONE_NETSTORAGE_SECRET - Type: string - Required: true ### Advanced options Here are the Advanced options specific to netstorage (Akamai NetStorage). #### --netstorage-protocol Select between HTTP or HTTPS protocol. Most users should choose HTTPS, which is the default. HTTP is provided primarily for debugging purposes. Properties: - Config: protocol - Env Var: RCLONE_NETSTORAGE_PROTOCOL - Type: string - Default: "https" - Examples: - "http" - HTTP protocol - "https" - HTTPS protocol #### --netstorage-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_NETSTORAGE_DESCRIPTION - Type: string - Required: false ## Backend commands Here are the commands specific to the netstorage backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the [backend](https://rclone.org/commands/rclone_backend/) command for more info on how to pass options and arguments. These can be run on a running backend using the rc command [backend/command](https://rclone.org/rc/#backend-command). ### du Return disk usage information for a specified directory rclone backend du remote: [options] [+] The usage information returned, includes the targeted directory as well as all files stored in any sub-directories that may exist. ### symlink You can create a symbolic link in ObjectStore with the symlink action. rclone backend symlink remote: [options] [+] The desired path location (including applicable sub-directories) ending in the object that will be the target of the symlink (for example, /links/mylink). Include the file extension for the object, if applicable. `rclone backend symlink ` # Microsoft Azure Blob Storage Paths are specified as `remote:container` (or `remote:` for the `lsd` command.) You may put subdirectories in too, e.g. `remote:container/path/to/dir`. ## Configuration Here is an example of making a Microsoft Azure Blob Storage configuration. For a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Microsoft Azure Blob Storage \ "azureblob" [snip] Storage> azureblob Storage Account Name account> account_name Storage Account Key key> base64encodedkey== Endpoint for the service - leave blank normally. endpoint> Remote config Configuration complete. Options: - type: azureblob - account: account_name - key: base64encodedkey== - endpoint: Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` See all containers rclone lsd remote: Make a new container rclone mkdir remote:container List the contents of a container rclone ls remote:container Sync `/home/local/directory` to the remote container, deleting any excess files in the container. rclone sync --interactive /home/local/directory remote:container ### --fast-list This remote supports `--fast-list` which allows you to use fewer transactions in exchange for more memory. See the [rclone docs](https://rclone.org/docs/#fast-list) for more details. ### Modification times and hashes The modification time is stored as metadata on the object with the `mtime` key. It is stored using RFC3339 Format time with nanosecond precision. The metadata is supplied during directory listings so there is no performance overhead to using it. If you wish to use the Azure standard `LastModified` time stored on the object as the modified time, then use the `--use-server-modtime` flag. Note that rclone can't set `LastModified`, so using the `--update` flag when syncing is recommended if using `--use-server-modtime`. MD5 hashes are stored with blobs. However blobs that were uploaded in chunks only have an MD5 if the source remote was capable of MD5 hashes, e.g. the local disk. ### Performance When uploading large files, increasing the value of `--azureblob-upload-concurrency` will increase performance at the cost of using more memory. The default of 16 is set quite conservatively to use less memory. It maybe be necessary raise it to 64 or higher to fully utilize a 1 GBit/s link with a single file transfer. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | / | 0x2F | ／ | | \ | 0x5C | ＼ | File names can also not end with the following characters. These only get replaced if they are the last character in the name: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | . | 0x2E | ． | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Authentication {#authentication} There are a number of ways of supplying credentials for Azure Blob Storage. Rclone tries them in the order of the sections below. #### Env Auth If the `env_auth` config parameter is `true` then rclone will pull credentials from the environment or runtime. It tries these authentication methods in this order: 1. Environment Variables 2. Managed Service Identity Credentials 3. Azure CLI credentials (as used by the az tool) These are described in the following sections ##### Env Auth: 1. Environment Variables If `env_auth` is set and environment variables are present rclone authenticates a service principal with a secret or certificate, or a user with a password, depending on which environment variable are set. It reads configuration from these variables, in the following order: 1. Service principal with client secret - `AZURE_TENANT_ID`: ID of the service principal's tenant. Also called its "directory" ID. - `AZURE_CLIENT_ID`: the service principal's client ID - `AZURE_CLIENT_SECRET`: one of the service principal's client secrets 2. Service principal with certificate - `AZURE_TENANT_ID`: ID of the service principal's tenant. Also called its "directory" ID. - `AZURE_CLIENT_ID`: the service principal's client ID - `AZURE_CLIENT_CERTIFICATE_PATH`: path to a PEM or PKCS12 certificate file including the private key. - `AZURE_CLIENT_CERTIFICATE_PASSWORD`: (optional) password for the certificate file. - `AZURE_CLIENT_SEND_CERTIFICATE_CHAIN`: (optional) Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to "true" or "1", authentication requests include the x5c header. 3. User with username and password - `AZURE_TENANT_ID`: (optional) tenant to authenticate in. Defaults to "organizations". - `AZURE_CLIENT_ID`: client ID of the application the user will authenticate to - `AZURE_USERNAME`: a username (usually an email address) - `AZURE_PASSWORD`: the user's password 4. Workload Identity - `AZURE_TENANT_ID`: Tenant to authenticate in. - `AZURE_CLIENT_ID`: Client ID of the application the user will authenticate to. - `AZURE_FEDERATED_TOKEN_FILE`: Path to projected service account token file. - `AZURE_AUTHORITY_HOST`: Authority of an Azure Active Directory endpoint (default: login.microsoftonline.com). ##### Env Auth: 2. Managed Service Identity Credentials When using Managed Service Identity if the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default. If the resource has multiple user-assigned identities you will need to unset `env_auth` and set `use_msi` instead. See the [`use_msi` section](#use_msi). If you are operating in disconnected clouds, or private clouds such as Azure Stack you may want to set `disable_instance_discovery = true`. This determines whether rclone requests Microsoft Entra instance metadata from `https://login.microsoft.com/` before authenticating. Setting this to `true` will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy. ##### Env Auth: 3. Azure CLI credentials (as used by the az tool) Credentials created with the `az` tool can be picked up using `env_auth`. For example if you were to login with a service principal like this: az login --service-principal -u XXX -p XXX --tenant XXX Then you could access rclone resources like this: rclone lsf :azureblob,env_auth,account=ACCOUNT:CONTAINER Or rclone lsf --azureblob-env-auth --azureblob-account=ACCOUNT :azureblob:CONTAINER Which is analogous to using the `az` tool: az storage blob list --container-name CONTAINER --account-name ACCOUNT --auth-mode login #### Account and Shared Key This is the most straight forward and least flexible way. Just fill in the `account` and `key` lines and leave the rest blank. #### SAS URL This can be an account level SAS URL or container level SAS URL. To use it leave `account` and `key` blank and fill in `sas_url`. An account level SAS URL or container level SAS URL can be obtained from the Azure portal or the Azure Storage Explorer. To get a container level SAS URL right click on a container in the Azure Blob explorer in the Azure portal. If you use a container level SAS URL, rclone operations are permitted only on a particular container, e.g. rclone ls azureblob:container You can also list the single container from the root. This will only show the container specified by the SAS URL. $ rclone lsd azureblob: container/ Note that you can't see or access any other containers - this will fail rclone ls azureblob:othercontainer Container level SAS URLs are useful for temporarily allowing third parties access to a single container or putting credentials into an untrusted environment such as a CI build server. #### Service principal with client secret If these variables are set, rclone will authenticate with a service principal with a client secret. - `tenant`: ID of the service principal's tenant. Also called its "directory" ID. - `client_id`: the service principal's client ID - `client_secret`: one of the service principal's client secrets The credentials can also be placed in a file using the `service_principal_file` configuration option. #### Service principal with certificate If these variables are set, rclone will authenticate with a service principal with certificate. - `tenant`: ID of the service principal's tenant. Also called its "directory" ID. - `client_id`: the service principal's client ID - `client_certificate_path`: path to a PEM or PKCS12 certificate file including the private key. - `client_certificate_password`: (optional) password for the certificate file. - `client_send_certificate_chain`: (optional) Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to "true" or "1", authentication requests include the x5c header. **NB** `client_certificate_password` must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). #### User with username and password If these variables are set, rclone will authenticate with username and password. - `tenant`: (optional) tenant to authenticate in. Defaults to "organizations". - `client_id`: client ID of the application the user will authenticate to - `username`: a username (usually an email address) - `password`: the user's password Microsoft doesn't recommend this kind of authentication, because it's less secure than other authentication flows. This method is not interactive, so it isn't compatible with any form of multi-factor authentication, and the application must already have user or admin consent. This credential can only authenticate work and school accounts; it can't authenticate Microsoft accounts. **NB** `password` must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). #### Managed Service Identity Credentials {#use_msi} If `use_msi` is set then managed service identity credentials are used. This authentication only works when running in an Azure service. `env_auth` needs to be unset to use this. However if you have multiple user identities to choose from these must be explicitly specified using exactly one of the `msi_object_id`, `msi_client_id`, or `msi_mi_res_id` parameters. If none of `msi_object_id`, `msi_client_id`, or `msi_mi_res_id` is set, this is is equivalent to using `env_auth`. #### Fedrated Identity Credentials If these variables are set, rclone will authenticate with fedrated identity. - `tenant_id`: tenant_id to authenticate in storage - `client_id`: client ID of the application the user will authenticate to storage - `msi_client_id`: managed identity client ID of the application the user will authenticate to By default "api://AzureADTokenExchange" is used as scope for token retrieval over MSI. This token is then exchanged for actual storage token using 'tenant_id' and 'client_id'. #### Azure CLI tool `az` {#use_az} Set to use the [Azure CLI tool `az`](https://learn.microsoft.com/en-us/cli/azure/) as the sole means of authentication. Setting this can be useful if you wish to use the `az` CLI on a host with a System Managed Identity that you do not want to use. Don't set `env_auth` at the same time. #### Anonymous {#anonymous} If you want to access resources with public anonymous access then set `account` only. You can do this without making an rclone config: rclone lsf :azureblob,account=ACCOUNT:CONTAINER ### Standard options Here are the Standard options specific to azureblob (Microsoft Azure Blob Storage). #### --azureblob-account Azure Storage Account Name. Set this to the Azure Storage Account Name in use. Leave blank to use SAS URL or Emulator, otherwise it needs to be set. If this is blank and if env_auth is set it will be read from the environment variable `AZURE_STORAGE_ACCOUNT_NAME` if possible. Properties: - Config: account - Env Var: RCLONE_AZUREBLOB_ACCOUNT - Type: string - Required: false #### --azureblob-env-auth Read credentials from runtime (environment variables, CLI or MSI). See the [authentication docs](/azureblob#authentication) for full info. Properties: - Config: env_auth - Env Var: RCLONE_AZUREBLOB_ENV_AUTH - Type: bool - Default: false #### --azureblob-key Storage Account Shared Key. Leave blank to use SAS URL or Emulator. Properties: - Config: key - Env Var: RCLONE_AZUREBLOB_KEY - Type: string - Required: false #### --azureblob-sas-url SAS URL for container level access only. Leave blank if using account/key or Emulator. Properties: - Config: sas_url - Env Var: RCLONE_AZUREBLOB_SAS_URL - Type: string - Required: false #### --azureblob-tenant ID of the service principal's tenant. Also called its directory ID. Set this if using - Service principal with client secret - Service principal with certificate - User with username and password Properties: - Config: tenant - Env Var: RCLONE_AZUREBLOB_TENANT - Type: string - Required: false #### --azureblob-client-id The ID of the client in use. Set this if using - Service principal with client secret - Service principal with certificate - User with username and password Properties: - Config: client_id - Env Var: RCLONE_AZUREBLOB_CLIENT_ID - Type: string - Required: false #### --azureblob-client-secret One of the service principal's client secrets Set this if using - Service principal with client secret Properties: - Config: client_secret - Env Var: RCLONE_AZUREBLOB_CLIENT_SECRET - Type: string - Required: false #### --azureblob-client-certificate-path Path to a PEM or PKCS12 certificate file including the private key. Set this if using - Service principal with certificate Properties: - Config: client_certificate_path - Env Var: RCLONE_AZUREBLOB_CLIENT_CERTIFICATE_PATH - Type: string - Required: false #### --azureblob-client-certificate-password Password for the certificate file (optional). Optionally set this if using - Service principal with certificate And the certificate has a password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: client_certificate_password - Env Var: RCLONE_AZUREBLOB_CLIENT_CERTIFICATE_PASSWORD - Type: string - Required: false ### Advanced options Here are the Advanced options specific to azureblob (Microsoft Azure Blob Storage). #### --azureblob-client-send-certificate-chain Send the certificate chain when using certificate auth. Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to true, authentication requests include the x5c header. Optionally set this if using - Service principal with certificate Properties: - Config: client_send_certificate_chain - Env Var: RCLONE_AZUREBLOB_CLIENT_SEND_CERTIFICATE_CHAIN - Type: bool - Default: false #### --azureblob-username User name (usually an email address) Set this if using - User with username and password Properties: - Config: username - Env Var: RCLONE_AZUREBLOB_USERNAME - Type: string - Required: false #### --azureblob-password The user's password Set this if using - User with username and password **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: password - Env Var: RCLONE_AZUREBLOB_PASSWORD - Type: string - Required: false #### --azureblob-service-principal-file Path to file containing credentials for use with a service principal. Leave blank normally. Needed only if you want to use a service principal instead of interactive login. $ az ad sp create-for-rbac --name "" \ --role "Storage Blob Data Owner" \ --scopes "/subscriptions//resourceGroups//providers/Microsoft.Storage/storageAccounts//blobServices/default/containers/" \ > azure-principal.json See ["Create an Azure service principal"](https://docs.microsoft.com/en-us/cli/azure/create-an-azure-service-principal-azure-cli) and ["Assign an Azure role for access to blob data"](https://docs.microsoft.com/en-us/azure/storage/common/storage-auth-aad-rbac-cli) pages for more details. It may be more convenient to put the credentials directly into the rclone config file under the `client_id`, `tenant` and `client_secret` keys instead of setting `service_principal_file`. Properties: - Config: service_principal_file - Env Var: RCLONE_AZUREBLOB_SERVICE_PRINCIPAL_FILE - Type: string - Required: false #### --azureblob-disable-instance-discovery Skip requesting Microsoft Entra instance metadata This should be set true only by applications authenticating in disconnected clouds, or private clouds such as Azure Stack. It determines whether rclone requests Microsoft Entra instance metadata from `https://login.microsoft.com/` before authenticating. Setting this to true will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy. Properties: - Config: disable_instance_discovery - Env Var: RCLONE_AZUREBLOB_DISABLE_INSTANCE_DISCOVERY - Type: bool - Default: false #### --azureblob-use-msi Use a managed service identity to authenticate (only works in Azure). When true, use a [managed service identity](https://docs.microsoft.com/en-us/azure/active-directory/managed-identities-azure-resources/) to authenticate to Azure Storage instead of a SAS token or account key. If the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default. If the resource has multiple user-assigned identities, the identity to use must be explicitly specified using exactly one of the msi_object_id, msi_client_id, or msi_mi_res_id parameters. Properties: - Config: use_msi - Env Var: RCLONE_AZUREBLOB_USE_MSI - Type: bool - Default: false #### --azureblob-msi-object-id Object ID of the user-assigned MSI to use, if any. Leave blank if msi_client_id or msi_mi_res_id specified. Properties: - Config: msi_object_id - Env Var: RCLONE_AZUREBLOB_MSI_OBJECT_ID - Type: string - Required: false #### --azureblob-msi-client-id Object ID of the user-assigned MSI to use, if any. Leave blank if msi_object_id or msi_mi_res_id specified. Properties: - Config: msi_client_id - Env Var: RCLONE_AZUREBLOB_MSI_CLIENT_ID - Type: string - Required: false #### --azureblob-msi-mi-res-id Azure resource ID of the user-assigned MSI to use, if any. Leave blank if msi_client_id or msi_object_id specified. Properties: - Config: msi_mi_res_id - Env Var: RCLONE_AZUREBLOB_MSI_MI_RES_ID - Type: string - Required: false #### --azureblob-use-emulator Uses local storage emulator if provided as 'true'. Leave blank if using real azure storage endpoint. Properties: - Config: use_emulator - Env Var: RCLONE_AZUREBLOB_USE_EMULATOR - Type: bool - Default: false #### --azureblob-use-az Use Azure CLI tool az for authentication Set to use the [Azure CLI tool az](https://learn.microsoft.com/en-us/cli/azure/) as the sole means of authentication. Setting this can be useful if you wish to use the az CLI on a host with a System Managed Identity that you do not want to use. Don't set env_auth at the same time. Properties: - Config: use_az - Env Var: RCLONE_AZUREBLOB_USE_AZ - Type: bool - Default: false #### --azureblob-endpoint Endpoint for the service. Leave blank normally. Properties: - Config: endpoint - Env Var: RCLONE_AZUREBLOB_ENDPOINT - Type: string - Required: false #### --azureblob-upload-cutoff Cutoff for switching to chunked upload (<= 256 MiB) (deprecated). Properties: - Config: upload_cutoff - Env Var: RCLONE_AZUREBLOB_UPLOAD_CUTOFF - Type: string - Required: false #### --azureblob-chunk-size Upload chunk size. Note that this is stored in memory and there may be up to "--transfers" * "--azureblob-upload-concurrency" chunks stored at once in memory. Properties: - Config: chunk_size - Env Var: RCLONE_AZUREBLOB_CHUNK_SIZE - Type: SizeSuffix - Default: 4Mi #### --azureblob-upload-concurrency Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. In tests, upload speed increases almost linearly with upload concurrency. For example to fill a gigabit pipe it may be necessary to raise this to 64. Note that this will use more memory. Note that chunks are stored in memory and there may be up to "--transfers" * "--azureblob-upload-concurrency" chunks stored at once in memory. Properties: - Config: upload_concurrency - Env Var: RCLONE_AZUREBLOB_UPLOAD_CONCURRENCY - Type: int - Default: 16 #### --azureblob-copy-cutoff Cutoff for switching to multipart copy. Any files larger than this that need to be server-side copied will be copied in chunks of chunk_size using the put block list API. Files smaller than this limit will be copied with the Copy Blob API. Properties: - Config: copy_cutoff - Env Var: RCLONE_AZUREBLOB_COPY_CUTOFF - Type: SizeSuffix - Default: 8Mi #### --azureblob-copy-concurrency Concurrency for multipart copy. This is the number of chunks of the same file that are copied concurrently. These chunks are not buffered in memory and Microsoft recommends setting this value to greater than 1000 in the azcopy documentation. https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azcopy-optimize#increase-concurrency In tests, copy speed increases almost linearly with copy concurrency. Properties: - Config: copy_concurrency - Env Var: RCLONE_AZUREBLOB_COPY_CONCURRENCY - Type: int - Default: 512 #### --azureblob-use-copy-blob Whether to use the Copy Blob API when copying to the same storage account. If true (the default) then rclone will use the Copy Blob API for copies to the same storage account even when the size is above the copy_cutoff. Rclone assumes that the same storage account means the same config and does not check for the same storage account in different configs. There should be no need to change this value. Properties: - Config: use_copy_blob - Env Var: RCLONE_AZUREBLOB_USE_COPY_BLOB - Type: bool - Default: true #### --azureblob-list-chunk Size of blob list. This sets the number of blobs requested in each listing chunk. Default is the maximum, 5000. "List blobs" requests are permitted 2 minutes per megabyte to complete. If an operation is taking longer than 2 minutes per megabyte on average, it will time out ( [source](https://docs.microsoft.com/en-us/rest/api/storageservices/setting-timeouts-for-blob-service-operations#exceptions-to-default-timeout-interval) ). This can be used to limit the number of blobs items to return, to avoid the time out. Properties: - Config: list_chunk - Env Var: RCLONE_AZUREBLOB_LIST_CHUNK - Type: int - Default: 5000 #### --azureblob-access-tier Access tier of blob: hot, cool, cold or archive. Archived blobs can be restored by setting access tier to hot, cool or cold. Leave blank if you intend to use default access tier, which is set at account level If there is no "access tier" specified, rclone doesn't apply any tier. rclone performs "Set Tier" operation on blobs while uploading, if objects are not modified, specifying "access tier" to new one will have no effect. If blobs are in "archive tier" at remote, trying to perform data transfer operations from remote will not be allowed. User should first restore by tiering blob to "Hot", "Cool" or "Cold". Properties: - Config: access_tier - Env Var: RCLONE_AZUREBLOB_ACCESS_TIER - Type: string - Required: false #### --azureblob-archive-tier-delete Delete archive tier blobs before overwriting. Archive tier blobs cannot be updated. So without this flag, if you attempt to update an archive tier blob, then rclone will produce the error: can't update archive tier blob without --azureblob-archive-tier-delete With this flag set then before rclone attempts to overwrite an archive tier blob, it will delete the existing blob before uploading its replacement. This has the potential for data loss if the upload fails (unlike updating a normal blob) and also may cost more since deleting archive tier blobs early may be chargable. Properties: - Config: archive_tier_delete - Env Var: RCLONE_AZUREBLOB_ARCHIVE_TIER_DELETE - Type: bool - Default: false #### --azureblob-disable-checksum Don't store MD5 checksum with object metadata. Normally rclone will calculate the MD5 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading. Properties: - Config: disable_checksum - Env Var: RCLONE_AZUREBLOB_DISABLE_CHECKSUM - Type: bool - Default: false #### --azureblob-memory-pool-flush-time How often internal memory buffer pools will be flushed. (no longer used) Properties: - Config: memory_pool_flush_time - Env Var: RCLONE_AZUREBLOB_MEMORY_POOL_FLUSH_TIME - Type: Duration - Default: 1m0s #### --azureblob-memory-pool-use-mmap Whether to use mmap buffers in internal memory pool. (no longer used) Properties: - Config: memory_pool_use_mmap - Env Var: RCLONE_AZUREBLOB_MEMORY_POOL_USE_MMAP - Type: bool - Default: false #### --azureblob-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_AZUREBLOB_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,RightPeriod,InvalidUtf8 #### --azureblob-public-access Public access level of a container: blob or container. Properties: - Config: public_access - Env Var: RCLONE_AZUREBLOB_PUBLIC_ACCESS - Type: string - Required: false - Examples: - "" - The container and its blobs can be accessed only with an authorized request. - It's a default value. - "blob" - Blob data within this container can be read via anonymous request. - "container" - Allow full public read access for container and blob data. #### --azureblob-directory-markers Upload an empty object with a trailing slash when a new directory is created Empty folders are unsupported for bucket based remotes, this option creates an empty object ending with "/", to persist the folder. This object also has the metadata "hdi_isfolder = true" to conform to the Microsoft standard. Properties: - Config: directory_markers - Env Var: RCLONE_AZUREBLOB_DIRECTORY_MARKERS - Type: bool - Default: false #### --azureblob-no-check-container If set, don't attempt to check the container exists or create it. This can be useful when trying to minimise the number of transactions rclone does if you know the container exists already. Properties: - Config: no_check_container - Env Var: RCLONE_AZUREBLOB_NO_CHECK_CONTAINER - Type: bool - Default: false #### --azureblob-no-head-object If set, do not do HEAD before GET when getting objects. Properties: - Config: no_head_object - Env Var: RCLONE_AZUREBLOB_NO_HEAD_OBJECT - Type: bool - Default: false #### --azureblob-delete-snapshots Set to specify how to deal with snapshots on blob deletion. Properties: - Config: delete_snapshots - Env Var: RCLONE_AZUREBLOB_DELETE_SNAPSHOTS - Type: string - Required: false - Choices: - "" - By default, the delete operation fails if a blob has snapshots - "include" - Specify 'include' to remove the root blob and all its snapshots - "only" - Specify 'only' to remove only the snapshots but keep the root blob. #### --azureblob-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_AZUREBLOB_DESCRIPTION - Type: string - Required: false ### Custom upload headers You can set custom upload headers with the `--header-upload` flag. - Cache-Control - Content-Disposition - Content-Encoding - Content-Language - Content-Type - X-MS-Tags Eg `--header-upload "Content-Type: text/potato"` or `--header-upload "X-MS-Tags: foo=bar"` ## Limitations MD5 sums are only uploaded with chunked files if the source has an MD5 sum. This will always be the case for a local to azure copy. `rclone about` is not supported by the Microsoft Azure Blob storage backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) ## Azure Storage Emulator Support You can run rclone with the storage emulator (usually _azurite_). To do this, just set up a new remote with `rclone config` following the instructions in the introduction and set `use_emulator` in the advanced settings as `true`. You do not need to provide a default account name nor an account key. But you can override them in the `account` and `key` options. (Prior to v1.61 they were hard coded to _azurite_'s `devstoreaccount1`.) Also, if you want to access a storage emulator instance running on a different machine, you can override the `endpoint` parameter in the advanced settings, setting it to `http(s)://:/devstoreaccount1` (e.g. `http://10.254.2.5:10000/devstoreaccount1`). # Microsoft Azure Files Storage Paths are specified as `remote:` You may put subdirectories in too, e.g. `remote:path/to/dir`. ## Configuration Here is an example of making a Microsoft Azure Files Storage configuration. For a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Microsoft Azure Files Storage \ "azurefiles" [snip] Option account. Azure Storage Account Name. Set this to the Azure Storage Account Name in use. Leave blank to use SAS URL or connection string, otherwise it needs to be set. If this is blank and if env_auth is set it will be read from the environment variable `AZURE_STORAGE_ACCOUNT_NAME` if possible. Enter a value. Press Enter to leave empty. account> account_name Option share_name. Azure Files Share Name. This is required and is the name of the share to access. Enter a value. Press Enter to leave empty. share_name> share_name Option env_auth. Read credentials from runtime (environment variables, CLI or MSI). See the [authentication docs](/azurefiles#authentication) for full info. Enter a boolean value (true or false). Press Enter for the default (false). env_auth> Option key. Storage Account Shared Key. Leave blank to use SAS URL or connection string. Enter a value. Press Enter to leave empty. key> base64encodedkey== Option sas_url. SAS URL. Leave blank if using account/key or connection string. Enter a value. Press Enter to leave empty. sas_url> Option connection_string. Azure Files Connection String. Enter a value. Press Enter to leave empty. connection_string> [snip] Configuration complete. Options: - type: azurefiles - account: account_name - share_name: share_name - key: base64encodedkey== Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> ``` Once configured you can use rclone. See all files in the top level: rclone lsf remote: Make a new directory in the root: rclone mkdir remote:dir Recursively List the contents: rclone ls remote: Sync `/home/local/directory` to the remote directory, deleting any excess files in the directory. rclone sync --interactive /home/local/directory remote:dir ### Modified time The modified time is stored as Azure standard `LastModified` time on files ### Performance When uploading large files, increasing the value of `--azurefiles-upload-concurrency` will increase performance at the cost of using more memory. The default of 16 is set quite conservatively to use less memory. It maybe be necessary raise it to 64 or higher to fully utilize a 1 GBit/s link with a single file transfer. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | " | 0x22 | ＂ | | * | 0x2A | ＊ | | : | 0x3A | ： | | < | 0x3C | ＜ | | > | 0x3E | ＞ | | ? | 0x3F | ？ | | \ | 0x5C | ＼ | | \| | 0x7C | ｜ | File names can also not end with the following characters. These only get replaced if they are the last character in the name: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | . | 0x2E | ． | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Hashes MD5 hashes are stored with files. Not all files will have MD5 hashes as these have to be uploaded with the file. ### Authentication {#authentication} There are a number of ways of supplying credentials for Azure Files Storage. Rclone tries them in the order of the sections below. #### Env Auth If the `env_auth` config parameter is `true` then rclone will pull credentials from the environment or runtime. It tries these authentication methods in this order: 1. Environment Variables 2. Managed Service Identity Credentials 3. Azure CLI credentials (as used by the az tool) These are described in the following sections ##### Env Auth: 1. Environment Variables If `env_auth` is set and environment variables are present rclone authenticates a service principal with a secret or certificate, or a user with a password, depending on which environment variable are set. It reads configuration from these variables, in the following order: 1. Service principal with client secret - `AZURE_TENANT_ID`: ID of the service principal's tenant. Also called its "directory" ID. - `AZURE_CLIENT_ID`: the service principal's client ID - `AZURE_CLIENT_SECRET`: one of the service principal's client secrets 2. Service principal with certificate - `AZURE_TENANT_ID`: ID of the service principal's tenant. Also called its "directory" ID. - `AZURE_CLIENT_ID`: the service principal's client ID - `AZURE_CLIENT_CERTIFICATE_PATH`: path to a PEM or PKCS12 certificate file including the private key. - `AZURE_CLIENT_CERTIFICATE_PASSWORD`: (optional) password for the certificate file. - `AZURE_CLIENT_SEND_CERTIFICATE_CHAIN`: (optional) Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to "true" or "1", authentication requests include the x5c header. 3. User with username and password - `AZURE_TENANT_ID`: (optional) tenant to authenticate in. Defaults to "organizations". - `AZURE_CLIENT_ID`: client ID of the application the user will authenticate to - `AZURE_USERNAME`: a username (usually an email address) - `AZURE_PASSWORD`: the user's password 4. Workload Identity - `AZURE_TENANT_ID`: Tenant to authenticate in. - `AZURE_CLIENT_ID`: Client ID of the application the user will authenticate to. - `AZURE_FEDERATED_TOKEN_FILE`: Path to projected service account token file. - `AZURE_AUTHORITY_HOST`: Authority of an Azure Active Directory endpoint (default: login.microsoftonline.com). ##### Env Auth: 2. Managed Service Identity Credentials When using Managed Service Identity if the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default. If the resource has multiple user-assigned identities you will need to unset `env_auth` and set `use_msi` instead. See the [`use_msi` section](#use_msi). If you are operating in disconnected clouds, or private clouds such as Azure Stack you may want to set `disable_instance_discovery = true`. This determines whether rclone requests Microsoft Entra instance metadata from `https://login.microsoft.com/` before authenticating. Setting this to `true` will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy. ##### Env Auth: 3. Azure CLI credentials (as used by the az tool) Credentials created with the `az` tool can be picked up using `env_auth`. For example if you were to login with a service principal like this: az login --service-principal -u XXX -p XXX --tenant XXX Then you could access rclone resources like this: rclone lsf :azurefiles,env_auth,account=ACCOUNT: Or rclone lsf --azurefiles-env-auth --azurefiles-account=ACCOUNT :azurefiles: #### Account and Shared Key This is the most straight forward and least flexible way. Just fill in the `account` and `key` lines and leave the rest blank. #### SAS URL To use it leave `account`, `key` and `connection_string` blank and fill in `sas_url`. #### Connection String To use it leave `account`, `key` and "sas_url" blank and fill in `connection_string`. #### Service principal with client secret If these variables are set, rclone will authenticate with a service principal with a client secret. - `tenant`: ID of the service principal's tenant. Also called its "directory" ID. - `client_id`: the service principal's client ID - `client_secret`: one of the service principal's client secrets The credentials can also be placed in a file using the `service_principal_file` configuration option. #### Service principal with certificate If these variables are set, rclone will authenticate with a service principal with certificate. - `tenant`: ID of the service principal's tenant. Also called its "directory" ID. - `client_id`: the service principal's client ID - `client_certificate_path`: path to a PEM or PKCS12 certificate file including the private key. - `client_certificate_password`: (optional) password for the certificate file. - `client_send_certificate_chain`: (optional) Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to "true" or "1", authentication requests include the x5c header. **NB** `client_certificate_password` must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). #### User with username and password If these variables are set, rclone will authenticate with username and password. - `tenant`: (optional) tenant to authenticate in. Defaults to "organizations". - `client_id`: client ID of the application the user will authenticate to - `username`: a username (usually an email address) - `password`: the user's password Microsoft doesn't recommend this kind of authentication, because it's less secure than other authentication flows. This method is not interactive, so it isn't compatible with any form of multi-factor authentication, and the application must already have user or admin consent. This credential can only authenticate work and school accounts; it can't authenticate Microsoft accounts. **NB** `password` must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). #### Managed Service Identity Credentials {#use_msi} If `use_msi` is set then managed service identity credentials are used. This authentication only works when running in an Azure service. `env_auth` needs to be unset to use this. However if you have multiple user identities to choose from these must be explicitly specified using exactly one of the `msi_object_id`, `msi_client_id`, or `msi_mi_res_id` parameters. If none of `msi_object_id`, `msi_client_id`, or `msi_mi_res_id` is set, this is is equivalent to using `env_auth`. #### Fedrated Identity Credentials If these variables are set, rclone will authenticate with fedrated identity. - `tenant_id`: tenant_id to authenticate in storage - `client_id`: client ID of the application the user will authenticate to storage - `msi_client_id`: managed identity client ID of the application the user will authenticate to By default "api://AzureADTokenExchange" is used as scope for token retrieval over MSI. This token is then exchanged for actual storage token using 'tenant_id' and 'client_id'. #### Azure CLI tool `az` {#use_az} Set to use the [Azure CLI tool `az`](https://learn.microsoft.com/en-us/cli/azure/) as the sole means of authentication. Setting this can be useful if you wish to use the `az` CLI on a host with a System Managed Identity that you do not want to use. Don't set `env_auth` at the same time. ### Standard options Here are the Standard options specific to azurefiles (Microsoft Azure Files). #### --azurefiles-account Azure Storage Account Name. Set this to the Azure Storage Account Name in use. Leave blank to use SAS URL or connection string, otherwise it needs to be set. If this is blank and if env_auth is set it will be read from the environment variable `AZURE_STORAGE_ACCOUNT_NAME` if possible. Properties: - Config: account - Env Var: RCLONE_AZUREFILES_ACCOUNT - Type: string - Required: false #### --azurefiles-share-name Azure Files Share Name. This is required and is the name of the share to access. Properties: - Config: share_name - Env Var: RCLONE_AZUREFILES_SHARE_NAME - Type: string - Required: false #### --azurefiles-env-auth Read credentials from runtime (environment variables, CLI or MSI). See the [authentication docs](/azurefiles#authentication) for full info. Properties: - Config: env_auth - Env Var: RCLONE_AZUREFILES_ENV_AUTH - Type: bool - Default: false #### --azurefiles-key Storage Account Shared Key. Leave blank to use SAS URL or connection string. Properties: - Config: key - Env Var: RCLONE_AZUREFILES_KEY - Type: string - Required: false #### --azurefiles-sas-url SAS URL. Leave blank if using account/key or connection string. Properties: - Config: sas_url - Env Var: RCLONE_AZUREFILES_SAS_URL - Type: string - Required: false #### --azurefiles-connection-string Azure Files Connection String. Properties: - Config: connection_string - Env Var: RCLONE_AZUREFILES_CONNECTION_STRING - Type: string - Required: false #### --azurefiles-tenant ID of the service principal's tenant. Also called its directory ID. Set this if using - Service principal with client secret - Service principal with certificate - User with username and password Properties: - Config: tenant - Env Var: RCLONE_AZUREFILES_TENANT - Type: string - Required: false #### --azurefiles-client-id The ID of the client in use. Set this if using - Service principal with client secret - Service principal with certificate - User with username and password Properties: - Config: client_id - Env Var: RCLONE_AZUREFILES_CLIENT_ID - Type: string - Required: false #### --azurefiles-client-secret One of the service principal's client secrets Set this if using - Service principal with client secret Properties: - Config: client_secret - Env Var: RCLONE_AZUREFILES_CLIENT_SECRET - Type: string - Required: false #### --azurefiles-client-certificate-path Path to a PEM or PKCS12 certificate file including the private key. Set this if using - Service principal with certificate Properties: - Config: client_certificate_path - Env Var: RCLONE_AZUREFILES_CLIENT_CERTIFICATE_PATH - Type: string - Required: false #### --azurefiles-client-certificate-password Password for the certificate file (optional). Optionally set this if using - Service principal with certificate And the certificate has a password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: client_certificate_password - Env Var: RCLONE_AZUREFILES_CLIENT_CERTIFICATE_PASSWORD - Type: string - Required: false ### Advanced options Here are the Advanced options specific to azurefiles (Microsoft Azure Files). #### --azurefiles-client-send-certificate-chain Send the certificate chain when using certificate auth. Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to true, authentication requests include the x5c header. Optionally set this if using - Service principal with certificate Properties: - Config: client_send_certificate_chain - Env Var: RCLONE_AZUREFILES_CLIENT_SEND_CERTIFICATE_CHAIN - Type: bool - Default: false #### --azurefiles-username User name (usually an email address) Set this if using - User with username and password Properties: - Config: username - Env Var: RCLONE_AZUREFILES_USERNAME - Type: string - Required: false #### --azurefiles-password The user's password Set this if using - User with username and password **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: password - Env Var: RCLONE_AZUREFILES_PASSWORD - Type: string - Required: false #### --azurefiles-service-principal-file Path to file containing credentials for use with a service principal. Leave blank normally. Needed only if you want to use a service principal instead of interactive login. $ az ad sp create-for-rbac --name "" \ --role "Storage Files Data Owner" \ --scopes "/subscriptions//resourceGroups//providers/Microsoft.Storage/storageAccounts//blobServices/default/containers/" \ > azure-principal.json See ["Create an Azure service principal"](https://docs.microsoft.com/en-us/cli/azure/create-an-azure-service-principal-azure-cli) and ["Assign an Azure role for access to files data"](https://docs.microsoft.com/en-us/azure/storage/common/storage-auth-aad-rbac-cli) pages for more details. **NB** this section needs updating for Azure Files - pull requests appreciated! It may be more convenient to put the credentials directly into the rclone config file under the `client_id`, `tenant` and `client_secret` keys instead of setting `service_principal_file`. Properties: - Config: service_principal_file - Env Var: RCLONE_AZUREFILES_SERVICE_PRINCIPAL_FILE - Type: string - Required: false #### --azurefiles-use-msi Use a managed service identity to authenticate (only works in Azure). When true, use a [managed service identity](https://docs.microsoft.com/en-us/azure/active-directory/managed-identities-azure-resources/) to authenticate to Azure Storage instead of a SAS token or account key. If the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default. If the resource has multiple user-assigned identities, the identity to use must be explicitly specified using exactly one of the msi_object_id, msi_client_id, or msi_mi_res_id parameters. Properties: - Config: use_msi - Env Var: RCLONE_AZUREFILES_USE_MSI - Type: bool - Default: false #### --azurefiles-msi-object-id Object ID of the user-assigned MSI to use, if any. Leave blank if msi_client_id or msi_mi_res_id specified. Properties: - Config: msi_object_id - Env Var: RCLONE_AZUREFILES_MSI_OBJECT_ID - Type: string - Required: false #### --azurefiles-msi-client-id Object ID of the user-assigned MSI to use, if any. Leave blank if msi_object_id or msi_mi_res_id specified. Properties: - Config: msi_client_id - Env Var: RCLONE_AZUREFILES_MSI_CLIENT_ID - Type: string - Required: false #### --azurefiles-msi-mi-res-id Azure resource ID of the user-assigned MSI to use, if any. Leave blank if msi_client_id or msi_object_id specified. Properties: - Config: msi_mi_res_id - Env Var: RCLONE_AZUREFILES_MSI_MI_RES_ID - Type: string - Required: false #### --azurefiles-disable-instance-discovery Skip requesting Microsoft Entra instance metadata This should be set true only by applications authenticating in disconnected clouds, or private clouds such as Azure Stack. It determines whether rclone requests Microsoft Entra instance metadata from `https://login.microsoft.com/` before authenticating. Setting this to true will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy. Properties: - Config: disable_instance_discovery - Env Var: RCLONE_AZUREFILES_DISABLE_INSTANCE_DISCOVERY - Type: bool - Default: false #### --azurefiles-use-az Use Azure CLI tool az for authentication Set to use the [Azure CLI tool az](https://learn.microsoft.com/en-us/cli/azure/) as the sole means of authentication. Setting this can be useful if you wish to use the az CLI on a host with a System Managed Identity that you do not want to use. Don't set env_auth at the same time. Properties: - Config: use_az - Env Var: RCLONE_AZUREFILES_USE_AZ - Type: bool - Default: false #### --azurefiles-endpoint Endpoint for the service. Leave blank normally. Properties: - Config: endpoint - Env Var: RCLONE_AZUREFILES_ENDPOINT - Type: string - Required: false #### --azurefiles-chunk-size Upload chunk size. Note that this is stored in memory and there may be up to "--transfers" * "--azurefile-upload-concurrency" chunks stored at once in memory. Properties: - Config: chunk_size - Env Var: RCLONE_AZUREFILES_CHUNK_SIZE - Type: SizeSuffix - Default: 4Mi #### --azurefiles-upload-concurrency Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. Note that chunks are stored in memory and there may be up to "--transfers" * "--azurefile-upload-concurrency" chunks stored at once in memory. Properties: - Config: upload_concurrency - Env Var: RCLONE_AZUREFILES_UPLOAD_CONCURRENCY - Type: int - Default: 16 #### --azurefiles-max-stream-size Max size for streamed files. Azure files needs to know in advance how big the file will be. When rclone doesn't know it uses this value instead. This will be used when rclone is streaming data, the most common uses are: - Uploading files with `--vfs-cache-mode off` with `rclone mount` - Using `rclone rcat` - Copying files with unknown length You will need this much free space in the share as the file will be this size temporarily. Properties: - Config: max_stream_size - Env Var: RCLONE_AZUREFILES_MAX_STREAM_SIZE - Type: SizeSuffix - Default: 10Gi #### --azurefiles-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_AZUREFILES_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,RightPeriod,InvalidUtf8,Dot #### --azurefiles-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_AZUREFILES_DESCRIPTION - Type: string - Required: false ### Custom upload headers You can set custom upload headers with the `--header-upload` flag. - Cache-Control - Content-Disposition - Content-Encoding - Content-Language - Content-Type Eg `--header-upload "Content-Type: text/potato"` ## Limitations MD5 sums are only uploaded with chunked files if the source has an MD5 sum. This will always be the case for a local to azure copy. # Microsoft OneDrive Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configuration The initial setup for OneDrive involves getting a token from Microsoft which you need to do in your browser. `rclone config` walks you through it. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Microsoft OneDrive \ "onedrive" [snip] Storage> onedrive Microsoft App Client Id Leave blank normally. Enter a string value. Press Enter for the default (""). client_id> Microsoft App Client Secret Leave blank normally. Enter a string value. Press Enter for the default (""). client_secret> Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Choose a number from below, or type in an existing value 1 / OneDrive Personal or Business \ "onedrive" 2 / Sharepoint site \ "sharepoint" 3 / Type in driveID \ "driveid" 4 / Type in SiteID \ "siteid" 5 / Search a Sharepoint site \ "search" Your choice> 1 Found 1 drives, please select the one you want to use: 0: OneDrive (business) id=b!Eqwertyuiopasdfghjklzxcvbnm-7mnbvcxzlkjhgfdsapoiuytrewqk Chose drive to use:> 0 Found drive 'root' of type 'business', URL: https://org-my.sharepoint.com/personal/you/Documents Is that okay? y) Yes n) No y/n> y Configuration complete. Options: - type: onedrive - token: {"access_token":"youraccesstoken","token_type":"Bearer","refresh_token":"yourrefreshtoken","expiry":"2018-08-26T22:39:52.486512262+08:00"} - drive_id: b!Eqwertyuiopasdfghjklzxcvbnm-7mnbvcxzlkjhgfdsapoiuytrewqk - drive_type: business Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` See the [remote setup docs](https://rclone.org/remote_setup/) for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Microsoft. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on `http://127.0.0.1:53682/` and this it may require you to unblock it temporarily if you are running a host firewall. Once configured you can then use `rclone` like this, List directories in top level of your OneDrive rclone lsd remote: List all the files in your OneDrive rclone ls remote: To copy a local directory to an OneDrive directory called backup rclone copy /home/source remote:backup ### Getting your own Client ID and Key rclone uses a default Client ID when talking to OneDrive, unless a custom `client_id` is specified in the config. The default Client ID and Key are shared by all rclone users when performing requests. You may choose to create and use your own Client ID, in case the default one does not work well for you. For example, you might see throttling. #### Creating Client ID for OneDrive Personal To create your own Client ID, please follow these steps: 1. Open https://portal.azure.com/?quickstart=true#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/~/Overview and then under the `Add` menu click `App registration`. * If you have not created an Azure account, you will be prompted to. This is free, but you need to provide a phone number, address, and credit card for identity verification. 2. Enter a name for your app, choose account type `Accounts in any organizational directory (Any Azure AD directory - Multitenant) and personal Microsoft accounts (e.g. Skype, Xbox)`, select `Web` in `Redirect URI`, then type (do not copy and paste) `http://localhost:53682/` and click Register. Copy and keep the `Application (client) ID` under the app name for later use. 3. Under `manage` select `Certificates & secrets`, click `New client secret`. Enter a description (can be anything) and set `Expires` to 24 months. Copy and keep that secret _Value_ for later use (you _won't_ be able to see this value afterwards). 4. Under `manage` select `API permissions`, click `Add a permission` and select `Microsoft Graph` then select `delegated permissions`. 5. Search and select the following permissions: `Files.Read`, `Files.ReadWrite`, `Files.Read.All`, `Files.ReadWrite.All`, `offline_access`, `User.Read` and `Sites.Read.All` (if custom access scopes are configured, select the permissions accordingly). Once selected click `Add permissions` at the bottom. Now the application is complete. Run `rclone config` to create or edit a OneDrive remote. Supply the app ID and password as Client ID and Secret, respectively. rclone will walk you through the remaining steps. The access_scopes option allows you to configure the permissions requested by rclone. See [Microsoft Docs](https://docs.microsoft.com/en-us/graph/permissions-reference#files-permissions) for more information about the different scopes. The `Sites.Read.All` permission is required if you need to [search SharePoint sites when configuring the remote](https://github.com/rclone/rclone/pull/5883). However, if that permission is not assigned, you need to exclude `Sites.Read.All` from your access scopes or set `disable_site_permission` option to true in the advanced options. #### Creating Client ID for OneDrive Business The steps for OneDrive Personal may or may not work for OneDrive Business, depending on the security settings of the organization. A common error is that the publisher of the App is not verified. You may try to [verify you account](https://docs.microsoft.com/en-us/azure/active-directory/develop/publisher-verification-overview), or try to limit the App to your organization only, as shown below. 1. Make sure to create the App with your business account. 2. Follow the steps above to create an App. However, we need a different account type here: `Accounts in this organizational directory only (*** - Single tenant)`. Note that you can also change the account type after creating the App. 3. Find the [tenant ID](https://docs.microsoft.com/en-us/azure/active-directory/fundamentals/active-directory-how-to-find-tenant) of your organization. 4. In the rclone config, set `auth_url` to `https://login.microsoftonline.com/YOUR_TENANT_ID/oauth2/v2.0/authorize`. 5. In the rclone config, set `token_url` to `https://login.microsoftonline.com/YOUR_TENANT_ID/oauth2/v2.0/token`. Note: If you have a special region, you may need a different host in step 4 and 5. Here are [some hints](https://github.com/rclone/rclone/blob/bc23bf11db1c78c6ebbf8ea538fbebf7058b4176/backend/onedrive/onedrive.go#L86). ### Using OAuth Client Credential flow OAuth Client Credential flow will allow rclone to use permissions directly associated with the Azure AD Enterprise application, rather that adopting the context of an Azure AD user account. This flow can be enabled by following the steps below: 1. Create the Enterprise App registration in the Azure AD portal and obtain a Client ID and Client Secret as described above. 2. Ensure that the application has the appropriate permissions and they are assigned as *Application Permissions* 3. Configure the remote, ensuring that *Client ID* and *Client Secret* are entered correctly. 4. In the *Advanced Config* section, enter `true` for `client_credentials` and in the `tenant` section enter the tenant ID. When it comes to choosing the type of the connection work with the client credentials flow. In particular the "onedrive" option does not work. You can use the "sharepoint" option or if that does not find the correct drive ID type it in manually with the "driveid" option. **NOTE** Assigning permissions directly to the application means that anyone with the *Client ID* and *Client Secret* can access your OneDrive files. Take care to safeguard these credentials. ### Modification times and hashes OneDrive allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not. OneDrive Personal, OneDrive for Business and Sharepoint Server support [QuickXorHash](https://docs.microsoft.com/en-us/onedrive/developer/code-snippets/quickxorhash). Before rclone 1.62 the default hash for Onedrive Personal was `SHA1`. For rclone 1.62 and above the default for all Onedrive backends is `QuickXorHash`. Starting from July 2023 `SHA1` support is being phased out in Onedrive Personal in favour of `QuickXorHash`. If necessary the `--onedrive-hash-type` flag (or `hash_type` config option) can be used to select `SHA1` during the transition period if this is important your workflow. For all types of OneDrive you can use the `--checksum` flag. ### --fast-list This remote supports `--fast-list` which allows you to use fewer transactions in exchange for more memory. See the [rclone docs](https://rclone.org/docs/#fast-list) for more details. This must be enabled with the `--onedrive-delta` flag (or `delta = true` in the config file) as it can cause performance degradation. It does this by using the delta listing facilities of OneDrive which returns all the files in the remote very efficiently. This is much more efficient than listing directories recursively and is Microsoft's recommended way of reading all the file information from a drive. This can be useful with `rclone mount` and [rclone rc vfs/refresh recursive=true](https://rclone.org/rc/#vfs-refresh)) to very quickly fill the mount with information about all the files. The API used for the recursive listing (`ListR`) only supports listing from the root of the drive. This will become increasingly inefficient the further away you get from the root as rclone will have to discard files outside of the directory you are using. Some commands (like `rclone lsf -R`) will use `ListR` by default - you can turn this off with `--disable ListR` if you need to. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | " | 0x22 | ＂ | | * | 0x2A | ＊ | | : | 0x3A | ： | | < | 0x3C | ＜ | | > | 0x3E | ＞ | | ? | 0x3F | ？ | | \ | 0x5C | ＼ | | \| | 0x7C | ｜ | File names can also not end with the following characters. These only get replaced if they are the last character in the name: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | SP | 0x20 | ␠ | | . | 0x2E | ． | File names can also not begin with the following characters. These only get replaced if they are the first character in the name: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | SP | 0x20 | ␠ | | ~ | 0x7E | ～ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Deleting files Any files you delete with rclone will end up in the trash. Microsoft doesn't provide an API to permanently delete files, nor to empty the trash, so you will have to do that with one of Microsoft's apps or via the OneDrive website. ### Standard options Here are the Standard options specific to onedrive (Microsoft OneDrive). #### --onedrive-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_ONEDRIVE_CLIENT_ID - Type: string - Required: false #### --onedrive-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_ONEDRIVE_CLIENT_SECRET - Type: string - Required: false #### --onedrive-region Choose national cloud region for OneDrive. Properties: - Config: region - Env Var: RCLONE_ONEDRIVE_REGION - Type: string - Default: "global" - Examples: - "global" - Microsoft Cloud Global - "us" - Microsoft Cloud for US Government - "de" - Microsoft Cloud Germany (deprecated - try global region first). - "cn" - Azure and Office 365 operated by Vnet Group in China #### --onedrive-tenant ID of the service principal's tenant. Also called its directory ID. Set this if using - Client Credential flow Properties: - Config: tenant - Env Var: RCLONE_ONEDRIVE_TENANT - Type: string - Required: false ### Advanced options Here are the Advanced options specific to onedrive (Microsoft OneDrive). #### --onedrive-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_ONEDRIVE_TOKEN - Type: string - Required: false #### --onedrive-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_ONEDRIVE_AUTH_URL - Type: string - Required: false #### --onedrive-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_ONEDRIVE_TOKEN_URL - Type: string - Required: false #### --onedrive-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_ONEDRIVE_CLIENT_CREDENTIALS - Type: bool - Default: false #### --onedrive-upload-cutoff Cutoff for switching to chunked upload. Any files larger than this will be uploaded in chunks of chunk_size. This is disabled by default as uploading using single part uploads causes rclone to use twice the storage on Onedrive business as when rclone sets the modification time after the upload Onedrive creates a new version. See: https://github.com/rclone/rclone/issues/1716 Properties: - Config: upload_cutoff - Env Var: RCLONE_ONEDRIVE_UPLOAD_CUTOFF - Type: SizeSuffix - Default: off #### --onedrive-chunk-size Chunk size to upload files with - must be multiple of 320k (327,680 bytes). Above this size files will be chunked - must be multiple of 320k (327,680 bytes) and should not exceed 250M (262,144,000 bytes) else you may encounter \"Microsoft.SharePoint.Client.InvalidClientQueryException: The request message is too big.\" Note that the chunks will be buffered into memory. Properties: - Config: chunk_size - Env Var: RCLONE_ONEDRIVE_CHUNK_SIZE - Type: SizeSuffix - Default: 10Mi #### --onedrive-drive-id The ID of the drive to use. Properties: - Config: drive_id - Env Var: RCLONE_ONEDRIVE_DRIVE_ID - Type: string - Required: false #### --onedrive-drive-type The type of the drive (personal | business | documentLibrary). Properties: - Config: drive_type - Env Var: RCLONE_ONEDRIVE_DRIVE_TYPE - Type: string - Required: false #### --onedrive-root-folder-id ID of the root folder. This isn't normally needed, but in special circumstances you might know the folder ID that you wish to access but not be able to get there through a path traversal. Properties: - Config: root_folder_id - Env Var: RCLONE_ONEDRIVE_ROOT_FOLDER_ID - Type: string - Required: false #### --onedrive-access-scopes Set scopes to be requested by rclone. Choose or manually enter a custom space separated list with all scopes, that rclone should request. Properties: - Config: access_scopes - Env Var: RCLONE_ONEDRIVE_ACCESS_SCOPES - Type: SpaceSepList - Default: Files.Read Files.ReadWrite Files.Read.All Files.ReadWrite.All Sites.Read.All offline_access - Examples: - "Files.Read Files.ReadWrite Files.Read.All Files.ReadWrite.All Sites.Read.All offline_access" - Read and write access to all resources - "Files.Read Files.Read.All Sites.Read.All offline_access" - Read only access to all resources - "Files.Read Files.ReadWrite Files.Read.All Files.ReadWrite.All offline_access" - Read and write access to all resources, without the ability to browse SharePoint sites. - Same as if disable_site_permission was set to true #### --onedrive-disable-site-permission Disable the request for Sites.Read.All permission. If set to true, you will no longer be able to search for a SharePoint site when configuring drive ID, because rclone will not request Sites.Read.All permission. Set it to true if your organization didn't assign Sites.Read.All permission to the application, and your organization disallows users to consent app permission request on their own. Properties: - Config: disable_site_permission - Env Var: RCLONE_ONEDRIVE_DISABLE_SITE_PERMISSION - Type: bool - Default: false #### --onedrive-expose-onenote-files Set to make OneNote files show up in directory listings. By default, rclone will hide OneNote files in directory listings because operations like "Open" and "Update" won't work on them. But this behaviour may also prevent you from deleting them. If you want to delete OneNote files or otherwise want them to show up in directory listing, set this option. Properties: - Config: expose_onenote_files - Env Var: RCLONE_ONEDRIVE_EXPOSE_ONENOTE_FILES - Type: bool - Default: false #### --onedrive-server-side-across-configs Deprecated: use --server-side-across-configs instead. Allow server-side operations (e.g. copy) to work across different onedrive configs. This will work if you are copying between two OneDrive *Personal* drives AND the files to copy are already shared between them. Additionally, it should also function for a user who has access permissions both between Onedrive for *business* and *SharePoint* under the *same tenant*, and between *SharePoint* and another *SharePoint* under the *same tenant*. In other cases, rclone will fall back to normal copy (which will be slightly slower). Properties: - Config: server_side_across_configs - Env Var: RCLONE_ONEDRIVE_SERVER_SIDE_ACROSS_CONFIGS - Type: bool - Default: false #### --onedrive-list-chunk Size of listing chunk. Properties: - Config: list_chunk - Env Var: RCLONE_ONEDRIVE_LIST_CHUNK - Type: int - Default: 1000 #### --onedrive-no-versions Remove all versions on modifying operations. Onedrive for business creates versions when rclone uploads new files overwriting an existing one and when it sets the modification time. These versions take up space out of the quota. This flag checks for versions after file upload and setting modification time and removes all but the last version. **NB** Onedrive personal can't currently delete versions so don't use this flag there. Properties: - Config: no_versions - Env Var: RCLONE_ONEDRIVE_NO_VERSIONS - Type: bool - Default: false #### --onedrive-hard-delete Permanently delete files on removal. Normally files will get sent to the recycle bin on deletion. Setting this flag causes them to be permanently deleted. Use with care. OneDrive personal accounts do not support the permanentDelete API, it only applies to OneDrive for Business and SharePoint document libraries. Properties: - Config: hard_delete - Env Var: RCLONE_ONEDRIVE_HARD_DELETE - Type: bool - Default: false #### --onedrive-link-scope Set the scope of the links created by the link command. Properties: - Config: link_scope - Env Var: RCLONE_ONEDRIVE_LINK_SCOPE - Type: string - Default: "anonymous" - Examples: - "anonymous" - Anyone with the link has access, without needing to sign in. - This may include people outside of your organization. - Anonymous link support may be disabled by an administrator. - "organization" - Anyone signed into your organization (tenant) can use the link to get access. - Only available in OneDrive for Business and SharePoint. #### --onedrive-link-type Set the type of the links created by the link command. Properties: - Config: link_type - Env Var: RCLONE_ONEDRIVE_LINK_TYPE - Type: string - Default: "view" - Examples: - "view" - Creates a read-only link to the item. - "edit" - Creates a read-write link to the item. - "embed" - Creates an embeddable link to the item. #### --onedrive-link-password Set the password for links created by the link command. At the time of writing this only works with OneDrive personal paid accounts. Properties: - Config: link_password - Env Var: RCLONE_ONEDRIVE_LINK_PASSWORD - Type: string - Required: false #### --onedrive-hash-type Specify the hash in use for the backend. This specifies the hash type in use. If set to "auto" it will use the default hash which is QuickXorHash. Before rclone 1.62 an SHA1 hash was used by default for Onedrive Personal. For 1.62 and later the default is to use a QuickXorHash for all onedrive types. If an SHA1 hash is desired then set this option accordingly. From July 2023 QuickXorHash will be the only available hash for both OneDrive for Business and OneDrive Personal. This can be set to "none" to not use any hashes. If the hash requested does not exist on the object, it will be returned as an empty string which is treated as a missing hash by rclone. Properties: - Config: hash_type - Env Var: RCLONE_ONEDRIVE_HASH_TYPE - Type: string - Default: "auto" - Examples: - "auto" - Rclone chooses the best hash - "quickxor" - QuickXor - "sha1" - SHA1 - "sha256" - SHA256 - "crc32" - CRC32 - "none" - None - don't use any hashes #### --onedrive-av-override Allows download of files the server thinks has a virus. The onedrive/sharepoint server may check files uploaded with an Anti Virus checker. If it detects any potential viruses or malware it will block download of the file. In this case you will see a message like this server reports this file is infected with a virus - use --onedrive-av-override to download anyway: Infected (name of virus): 403 Forbidden: If you are 100% sure you want to download this file anyway then use the --onedrive-av-override flag, or av_override = true in the config file. Properties: - Config: av_override - Env Var: RCLONE_ONEDRIVE_AV_OVERRIDE - Type: bool - Default: false #### --onedrive-delta If set rclone will use delta listing to implement recursive listings. If this flag is set the onedrive backend will advertise `ListR` support for recursive listings. Setting this flag speeds up these things greatly: rclone lsf -R onedrive: rclone size onedrive: rclone rc vfs/refresh recursive=true **However** the delta listing API **only** works at the root of the drive. If you use it not at the root then it recurses from the root and discards all the data that is not under the directory you asked for. So it will be correct but may not be very efficient. This is why this flag is not set as the default. As a rule of thumb if nearly all of your data is under rclone's root directory (the `root/directory` in `onedrive:root/directory`) then using this flag will be be a big performance win. If your data is mostly not under the root then using this flag will be a big performance loss. It is recommended if you are mounting your onedrive at the root (or near the root when using crypt) and using rclone `rc vfs/refresh`. Properties: - Config: delta - Env Var: RCLONE_ONEDRIVE_DELTA - Type: bool - Default: false #### --onedrive-metadata-permissions Control whether permissions should be read or written in metadata. Reading permissions metadata from files can be done quickly, but it isn't always desirable to set the permissions from the metadata. Properties: - Config: metadata_permissions - Env Var: RCLONE_ONEDRIVE_METADATA_PERMISSIONS - Type: Bits - Default: off - Examples: - "off" - Do not read or write the value - "read" - Read the value only - "write" - Write the value only - "read,write" - Read and Write the value. - "failok" - If writing fails log errors only, don't fail the transfer #### --onedrive-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_ONEDRIVE_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,LeftSpace,LeftTilde,RightSpace,RightPeriod,InvalidUtf8,Dot #### --onedrive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_ONEDRIVE_DESCRIPTION - Type: string - Required: false ### Metadata OneDrive supports System Metadata (not User Metadata, as of this writing) for both files and directories. Much of the metadata is read-only, and there are some differences between OneDrive Personal and Business (see table below for details). Permissions are also supported, if `--onedrive-metadata-permissions` is set. The accepted values for `--onedrive-metadata-permissions` are "`read`", "`write`", "`read,write`", and "`off`" (the default). "`write`" supports adding new permissions, updating the "role" of existing permissions, and removing permissions. Updating and removing require the Permission ID to be known, so it is recommended to use "`read,write`" instead of "`write`" if you wish to update/remove permissions. Permissions are read/written in JSON format using the same schema as the [OneDrive API](https://learn.microsoft.com/en-us/onedrive/developer/rest-api/resources/permission?view=odsp-graph-online), which differs slightly between OneDrive Personal and Business. Example for OneDrive Personal: ```json [ { "id": "1234567890ABC!123", "grantedTo": { "user": { "id": "ryan@contoso.com" }, "application": {}, "device": {} }, "invitation": { "email": "ryan@contoso.com" }, "link": { "webUrl": "https://1drv.ms/t/s!1234567890ABC" }, "roles": [ "read" ], "shareId": "s!1234567890ABC" } ] ``` Example for OneDrive Business: ```json [ { "id": "48d31887-5fad-4d73-a9f5-3c356e68a038", "grantedToIdentities": [ { "user": { "displayName": "ryan@contoso.com" }, "application": {}, "device": {} } ], "link": { "type": "view", "scope": "users", "webUrl": "https://contoso.sharepoint.com/:w:/t/design/a577ghg9hgh737613bmbjf839026561fmzhsr85ng9f3hjck2t5s" }, "roles": [ "read" ], "shareId": "u!LKj1lkdlals90j1nlkascl" }, { "id": "5D33DD65C6932946", "grantedTo": { "user": { "displayName": "John Doe", "id": "efee1b77-fb3b-4f65-99d6-274c11914d12" }, "application": {}, "device": {} }, "roles": [ "owner" ], "shareId": "FWxc1lasfdbEAGM5fI7B67aB5ZMPDMmQ11U" } ] ``` To write permissions, pass in a "permissions" metadata key using this same format. The [`--metadata-mapper`](https://rclone.org/docs/#metadata-mapper) tool can be very helpful for this. When adding permissions, an email address can be provided in the `User.ID` or `DisplayName` properties of `grantedTo` or `grantedToIdentities`. Alternatively, an ObjectID can be provided in `User.ID`. At least one valid recipient must be provided in order to add a permission for a user. Creating a Public Link is also supported, if `Link.Scope` is set to `"anonymous"`. Example request to add a "read" permission with `--metadata-mapper`: ```json { "Metadata": { "permissions": "[{\"grantedToIdentities\":[{\"user\":{\"id\":\"ryan@contoso.com\"}}],\"roles\":[\"read\"]}]" } } ``` Note that adding a permission can fail if a conflicting permission already exists for the file/folder. To update an existing permission, include both the Permission ID and the new `roles` to be assigned. `roles` is the only property that can be changed. To remove permissions, pass in a blob containing only the permissions you wish to keep (which can be empty, to remove all.) Note that the `owner` role will be ignored, as it cannot be removed. Note that both reading and writing permissions requires extra API calls, so if you don't need to read or write permissions it is recommended to omit `--onedrive-metadata-permissions`. Metadata and permissions are supported for Folders (directories) as well as Files. Note that setting the `mtime` or `btime` on a Folder requires one extra API call on OneDrive Business only. OneDrive does not currently support User Metadata. When writing metadata, only writeable system properties will be written -- any read-only or unrecognized keys passed in will be ignored. TIP: to see the metadata and permissions for any file or folder, run: ``` rclone lsjson remote:path --stat -M --onedrive-metadata-permissions read ``` Here are the possible system metadata items for the onedrive backend. | Name | Help | Type | Example | Read Only | |------|------|------|---------|-----------| | btime | Time of file birth (creation) with S accuracy (mS for OneDrive Personal). | RFC 3339 | 2006-01-02T15:04:05Z | N | | content-type | The MIME type of the file. | string | text/plain | **Y** | | created-by-display-name | Display name of the user that created the item. | string | John Doe | **Y** | | created-by-id | ID of the user that created the item. | string | 48d31887-5fad-4d73-a9f5-3c356e68a038 | **Y** | | description | A short description of the file. Max 1024 characters. Only supported for OneDrive Personal. | string | Contract for signing | N | | id | The unique identifier of the item within OneDrive. | string | 01BYE5RZ6QN3ZWBTUFOFD3GSPGOHDJD36K | **Y** | | last-modified-by-display-name | Display name of the user that last modified the item. | string | John Doe | **Y** | | last-modified-by-id | ID of the user that last modified the item. | string | 48d31887-5fad-4d73-a9f5-3c356e68a038 | **Y** | | malware-detected | Whether OneDrive has detected that the item contains malware. | boolean | true | **Y** | | mtime | Time of last modification with S accuracy (mS for OneDrive Personal). | RFC 3339 | 2006-01-02T15:04:05Z | N | | package-type | If present, indicates that this item is a package instead of a folder or file. Packages are treated like files in some contexts and folders in others. | string | oneNote | **Y** | | permissions | Permissions in a JSON dump of OneDrive format. Enable with --onedrive-metadata-permissions. Properties: id, grantedTo, grantedToIdentities, invitation, inheritedFrom, link, roles, shareId | JSON | {} | N | | shared-by-id | ID of the user that shared the item (if shared). | string | 48d31887-5fad-4d73-a9f5-3c356e68a038 | **Y** | | shared-owner-id | ID of the owner of the shared item (if shared). | string | 48d31887-5fad-4d73-a9f5-3c356e68a038 | **Y** | | shared-scope | If shared, indicates the scope of how the item is shared: anonymous, organization, or users. | string | users | **Y** | | shared-time | Time when the item was shared, with S accuracy (mS for OneDrive Personal). | RFC 3339 | 2006-01-02T15:04:05Z | **Y** | | utime | Time of upload with S accuracy (mS for OneDrive Personal). | RFC 3339 | 2006-01-02T15:04:05Z | **Y** | See the [metadata](https://rclone.org/docs/#metadata) docs for more info. ### Impersonate other users as Admin Unlike Google Drive and impersonating any domain user via service accounts, OneDrive requires you to authenticate as an admin account, and manually setup a remote per user you wish to impersonate. 1. In [Microsoft 365 Admin Center](https://admin.microsoft.com), open each user you need to "impersonate" and go to the OneDrive section. There is a heading called "Get access to files", you need to click to create the link, this creates the link of the format `https://{tenant}-my.sharepoint.com/personal/{user_name_domain_tld}/` but also changes the permissions so you your admin user has access. 2. Then in powershell run the following commands: ```console Install-Module Microsoft.Graph -Scope CurrentUser -Repository PSGallery -Force Import-Module Microsoft.Graph.Files Connect-MgGraph -Scopes "Files.ReadWrite.All" # Follow the steps to allow access to your admin user # Then run this for each user you want to impersonate to get the Drive ID Get-MgUserDefaultDrive -UserId '{emailaddress}' # This will give you output of the format: # Name Id DriveType CreatedDateTime # ---- -- --------- --------------- # OneDrive b!XYZ123 business 14/10/2023 1:00:58 pm ``` 3. Then in rclone add a onedrive remote type, and use the `Type in driveID` with the DriveID you got in the previous step. One remote per user. It will then confirm the drive ID, and hopefully give you a message of `Found drive "root" of type "business"` and then include the URL of the format `https://{tenant}-my.sharepoint.com/personal/{user_name_domain_tld}/Documents` ## Limitations If you don't use rclone for 90 days the refresh token will expire. This will result in authorization problems. This is easy to fix by running the `rclone config reconnect remote:` command to get a new token and refresh token. ### Naming Note that OneDrive is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". There are quite a few characters that can't be in OneDrive file names. These can't occur on Windows platforms, but on non-Windows platforms they are common. Rclone will map these names to and from an identical looking unicode equivalent. For example if a file has a `?` in it will be mapped to `？` instead. ### File sizes The largest allowed file size is 250 GiB for both OneDrive Personal and OneDrive for Business [(Updated 13 Jan 2021)](https://support.microsoft.com/en-us/office/invalid-file-names-and-file-types-in-onedrive-and-sharepoint-64883a5d-228e-48f5-b3d2-eb39e07630fa?ui=en-us&rs=en-us&ad=us#individualfilesize). ### Path length The entire path, including the file name, must contain fewer than 400 characters for OneDrive, OneDrive for Business and SharePoint Online. If you are encrypting file and folder names with rclone, you may want to pay attention to this limitation because the encrypted names are typically longer than the original ones. ### Number of files OneDrive seems to be OK with at least 50,000 files in a folder, but at 100,000 rclone will get errors listing the directory like `couldn’t list files: UnknownError:`. See [#2707](https://github.com/rclone/rclone/issues/2707) for more info. An official document about the limitations for different types of OneDrive can be found [here](https://support.office.com/en-us/article/invalid-file-names-and-file-types-in-onedrive-onedrive-for-business-and-sharepoint-64883a5d-228e-48f5-b3d2-eb39e07630fa). ## Versions Every change in a file OneDrive causes the service to create a new version of the file. This counts against a users quota. For example changing the modification time of a file creates a second version, so the file apparently uses twice the space. For example the `copy` command is affected by this as rclone copies the file and then afterwards sets the modification time to match the source file which uses another version. You can use the `rclone cleanup` command (see below) to remove all old versions. Or you can set the `no_versions` parameter to `true` and rclone will remove versions after operations which create new versions. This takes extra transactions so only enable it if you need it. **Note** At the time of writing Onedrive Personal creates versions (but not for setting the modification time) but the API for removing them returns "API not found" so cleanup and `no_versions` should not be used on Onedrive Personal. ### Disabling versioning Starting October 2018, users will no longer be able to disable versioning by default. This is because Microsoft has brought an [update](https://techcommunity.microsoft.com/t5/Microsoft-OneDrive-Blog/New-Updates-to-OneDrive-and-SharePoint-Team-Site-Versioning/ba-p/204390) to the mechanism. To change this new default setting, a PowerShell command is required to be run by a SharePoint admin. If you are an admin, you can run these commands in PowerShell to change that setting: 1. `Install-Module -Name Microsoft.Online.SharePoint.PowerShell` (in case you haven't installed this already) 2. `Import-Module Microsoft.Online.SharePoint.PowerShell -DisableNameChecking` 3. `Connect-SPOService -Url https://YOURSITE-admin.sharepoint.com -Credential YOU@YOURSITE.COM` (replacing `YOURSITE`, `YOU`, `YOURSITE.COM` with the actual values; this will prompt for your credentials) 4. `Set-SPOTenant -EnableMinimumVersionRequirement $False` 5. `Disconnect-SPOService` (to disconnect from the server) *Below are the steps for normal users to disable versioning. If you don't see the "No Versioning" option, make sure the above requirements are met.* User [Weropol](https://github.com/Weropol) has found a method to disable versioning on OneDrive 1. Open the settings menu by clicking on the gear symbol at the top of the OneDrive Business page. 2. Click Site settings. 3. Once on the Site settings page, navigate to Site Administration > Site libraries and lists. 4. Click Customize "Documents". 5. Click General Settings > Versioning Settings. 6. Under Document Version History select the option No versioning. Note: This will disable the creation of new file versions, but will not remove any previous versions. Your documents are safe. 7. Apply the changes by clicking OK. 8. Use rclone to upload or modify files. (I also use the --no-update-modtime flag) 9. Restore the versioning settings after using rclone. (Optional) ## Cleanup OneDrive supports `rclone cleanup` which causes rclone to look through every file under the path supplied and delete all version but the current version. Because this involves traversing all the files, then querying each file for versions it can be quite slow. Rclone does `--checkers` tests in parallel. The command also supports `--interactive`/`i` or `--dry-run` which is a great way to see what it would do. rclone cleanup --interactive remote:path/subdir # interactively remove all old version for path/subdir rclone cleanup remote:path/subdir # unconditionally remove all old version for path/subdir **NB** Onedrive personal can't currently delete versions ## Troubleshooting ## ### Excessive throttling or blocked on SharePoint If you experience excessive throttling or is being blocked on SharePoint then it may help to set the user agent explicitly with a flag like this: `--user-agent "ISV|rclone.org|rclone/v1.55.1"` The specific details can be found in the Microsoft document: [Avoid getting throttled or blocked in SharePoint Online](https://docs.microsoft.com/en-us/sharepoint/dev/general-development/how-to-avoid-getting-throttled-or-blocked-in-sharepoint-online#how-to-decorate-your-http-traffic-to-avoid-throttling) ### Unexpected file size/hash differences on Sharepoint #### It is a [known](https://github.com/OneDrive/onedrive-api-docs/issues/935#issuecomment-441741631) issue that Sharepoint (not OneDrive or OneDrive for Business) silently modifies uploaded files, mainly Office files (.docx, .xlsx, etc.), causing file size and hash checks to fail. There are also other situations that will cause OneDrive to report inconsistent file sizes. To use rclone with such affected files on Sharepoint, you may disable these checks with the following command line arguments: ``` --ignore-checksum --ignore-size ``` Alternatively, if you have write access to the OneDrive files, it may be possible to fix this problem for certain files, by attempting the steps below. Open the web interface for [OneDrive](https://onedrive.live.com) and find the affected files (which will be in the error messages/log for rclone). Simply click on each of these files, causing OneDrive to open them on the web. This will cause each file to be converted in place to a format that is functionally equivalent but which will no longer trigger the size discrepancy. Once all problematic files are converted you will no longer need the ignore options above. ### Replacing/deleting existing files on Sharepoint gets "item not found" #### It is a [known](https://github.com/OneDrive/onedrive-api-docs/issues/1068) issue that Sharepoint (not OneDrive or OneDrive for Business) may return "item not found" errors when users try to replace or delete uploaded files; this seems to mainly affect Office files (.docx, .xlsx, etc.) and web files (.html, .aspx, etc.). As a workaround, you may use the `--backup-dir ` command line argument so rclone moves the files to be replaced/deleted into a given backup directory (instead of directly replacing/deleting them). For example, to instruct rclone to move the files into the directory `rclone-backup-dir` on backend `mysharepoint`, you may use: ``` --backup-dir mysharepoint:rclone-backup-dir ``` ### access\_denied (AADSTS65005) #### ``` Error: access_denied Code: AADSTS65005 Description: Using application 'rclone' is currently not supported for your organization [YOUR_ORGANIZATION] because it is in an unmanaged state. An administrator needs to claim ownership of the company by DNS validation of [YOUR_ORGANIZATION] before the application rclone can be provisioned. ``` This means that rclone can't use the OneDrive for Business API with your account. You can't do much about it, maybe write an email to your admins. However, there are other ways to interact with your OneDrive account. Have a look at the WebDAV backend: https://rclone.org/webdav/#sharepoint ### invalid\_grant (AADSTS50076) #### ``` Error: invalid_grant Code: AADSTS50076 Description: Due to a configuration change made by your administrator, or because you moved to a new location, you must use multi-factor authentication to access '...'. ``` If you see the error above after enabling multi-factor authentication for your account, you can fix it by refreshing your OAuth refresh token. To do that, run `rclone config`, and choose to edit your OneDrive backend. Then, you don't need to actually make any changes until you reach this question: `Already have a token - refresh?`. For this question, answer `y` and go through the process to refresh your token, just like the first time the backend is configured. After this, rclone should work again for this backend. ### Invalid request when making public links #### On Sharepoint and OneDrive for Business, `rclone link` may return an "Invalid request" error. A possible cause is that the organisation admin didn't allow public links to be made for the organisation/sharepoint library. To fix the permissions as an admin, take a look at the docs: [1](https://docs.microsoft.com/en-us/sharepoint/turn-external-sharing-on-or-off), [2](https://support.microsoft.com/en-us/office/set-up-and-manage-access-requests-94b26e0b-2822-49d4-929a-8455698654b3). ### Can not access `Shared` with me files Shared with me files is not supported by rclone [currently](https://github.com/rclone/rclone/issues/4062), but there is a workaround: 1. Visit [https://onedrive.live.com](https://onedrive.live.com/) 2. Right click a item in `Shared`, then click `Add shortcut to My files` in the context ![make_shortcut](https://user-images.githubusercontent.com/60313789/206118040-7e762b3b-aa61-41a1-8649-cc18889f3572.png "Screenshot (Shared with me)") 3. The shortcut will appear in `My files`, you can access it with rclone, it behaves like a normal folder/file. ![in_my_files](https://i.imgur.com/0S8H3li.png "Screenshot (My Files)") ![rclone_mount](https://i.imgur.com/2Iq66sW.png "Screenshot (rclone mount)") ### Live Photos uploaded from iOS (small video clips in .heic files) The iOS OneDrive app introduced [upload and storage](https://techcommunity.microsoft.com/t5/microsoft-onedrive-blog/live-photos-come-to-onedrive/ba-p/1953452) of [Live Photos](https://support.apple.com/en-gb/HT207310) in 2020. The usage and download of these uploaded Live Photos is unfortunately still work-in-progress and this introduces several issues when copying, synchronising and mounting – both in rclone and in the native OneDrive client on Windows. The root cause can easily be seen if you locate one of your Live Photos in the OneDrive web interface. Then download the photo from the web interface. You will then see that the size of downloaded .heic file is smaller than the size displayed in the web interface. The downloaded file is smaller because it only contains a single frame (still photo) extracted from the Live Photo (movie) stored in OneDrive. The different sizes will cause `rclone copy/sync` to repeatedly recopy unmodified photos something like this: DEBUG : 20230203_123826234_iOS.heic: Sizes differ (src 4470314 vs dst 1298667) DEBUG : 20230203_123826234_iOS.heic: sha1 = fc2edde7863b7a7c93ca6771498ac797f8460750 OK INFO : 20230203_123826234_iOS.heic: Copied (replaced existing) These recopies can be worked around by adding `--ignore-size`. Please note that this workaround only syncs the still-picture not the movie clip, and relies on modification dates being correctly updated on all files in all situations. The different sizes will also cause `rclone check` to report size errors something like this: ERROR : 20230203_123826234_iOS.heic: sizes differ These check errors can be suppressed by adding `--ignore-size`. The different sizes will also cause `rclone mount` to fail downloading with an error something like this: ERROR : 20230203_123826234_iOS.heic: ReadFileHandle.Read error: low level retry 1/10: unexpected EOF or like this when using `--cache-mode=full`: INFO : 20230203_123826234_iOS.heic: vfs cache: downloader: error count now 1: vfs reader: failed to write to cache file: 416 Requested Range Not Satisfiable: ERROR : 20230203_123826234_iOS.heic: vfs cache: failed to download: vfs reader: failed to write to cache file: 416 Requested Range Not Satisfiable: # OpenDrive Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configuration Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` n) New remote d) Delete remote q) Quit config e/n/d/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / OpenDrive \ "opendrive" [snip] Storage> opendrive Username username> Password y) Yes type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Configuration complete. Options: - type: opendrive - username: - password: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` List directories in top level of your OpenDrive rclone lsd remote: List all the files in your OpenDrive rclone ls remote: To copy a local directory to an OpenDrive directory called backup rclone copy /home/source remote:backup ### Modification times and hashes OpenDrive allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not. The MD5 hash algorithm is supported. ### Restricted filename characters | Character | Value | Replacement | | --------- |:-----:|:-----------:| | NUL | 0x00 | ␀ | | / | 0x2F | ／ | | " | 0x22 | ＂ | | * | 0x2A | ＊ | | : | 0x3A | ： | | < | 0x3C | ＜ | | > | 0x3E | ＞ | | ? | 0x3F | ？ | | \ | 0x5C | ＼ | | \| | 0x7C | ｜ | File names can also not begin or end with the following characters. These only get replaced if they are the first or last character in the name: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | SP | 0x20 | ␠ | | HT | 0x09 | ␉ | | LF | 0x0A | ␊ | | VT | 0x0B | ␋ | | CR | 0x0D | ␍ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Standard options Here are the Standard options specific to opendrive (OpenDrive). #### --opendrive-username Username. Properties: - Config: username - Env Var: RCLONE_OPENDRIVE_USERNAME - Type: string - Required: true #### --opendrive-password Password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: password - Env Var: RCLONE_OPENDRIVE_PASSWORD - Type: string - Required: true ### Advanced options Here are the Advanced options specific to opendrive (OpenDrive). #### --opendrive-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_OPENDRIVE_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,LeftSpace,LeftCrLfHtVt,RightSpace,RightCrLfHtVt,InvalidUtf8,Dot #### --opendrive-chunk-size Files will be uploaded in chunks this size. Note that these chunks are buffered in memory so increasing them will increase memory use. Properties: - Config: chunk_size - Env Var: RCLONE_OPENDRIVE_CHUNK_SIZE - Type: SizeSuffix - Default: 10Mi #### --opendrive-access Files and folders will be uploaded with this access permission (default private) Properties: - Config: access - Env Var: RCLONE_OPENDRIVE_ACCESS - Type: string - Default: "private" - Examples: - "private" - The file or folder access can be granted in a way that will allow select users to view, read or write what is absolutely essential for them. - "public" - The file or folder can be downloaded by anyone from a web browser. The link can be shared in any way, - "hidden" - The file or folder can be accessed has the same restrictions as Public if the user knows the URL of the file or folder link in order to access the contents #### --opendrive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_OPENDRIVE_DESCRIPTION - Type: string - Required: false ## Limitations Note that OpenDrive is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". There are quite a few characters that can't be in OpenDrive file names. These can't occur on Windows platforms, but on non-Windows platforms they are common. Rclone will map these names to and from an identical looking unicode equivalent. For example if a file has a `?` in it will be mapped to `？` instead. `rclone about` is not supported by the OpenDrive backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) # Oracle Object Storage - [Oracle Object Storage Overview](https://docs.oracle.com/en-us/iaas/Content/Object/Concepts/objectstorageoverview.htm) - [Oracle Object Storage FAQ](https://www.oracle.com/cloud/storage/object-storage/faq/) - [Oracle Object Storage Limits](https://docs.oracle.com/en-us/iaas/Content/Resources/Assets/whitepapers/oci-object-storage-best-practices.pdf) Paths are specified as `remote:bucket` (or `remote:` for the `lsd` command.) You may put subdirectories in too, e.g. `remote:bucket/path/to/dir`. Sample command to transfer local artifacts to remote:bucket in oracle object storage: `rclone -vvv --progress --stats-one-line --max-stats-groups 10 --log-format date,time,UTC,longfile --fast-list --buffer-size 256Mi --oos-no-check-bucket --oos-upload-cutoff 10Mi --multi-thread-cutoff 16Mi --multi-thread-streams 3000 --transfers 3000 --checkers 64 --retries 2 --oos-chunk-size 10Mi --oos-upload-concurrency 10000 --oos-attempt-resume-upload --oos-leave-parts-on-error sync ./artifacts remote:bucket -vv` ## Configuration Here is an example of making an oracle object storage configuration. `rclone config` walks you through it. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> n Enter name for new remote. name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Oracle Cloud Infrastructure Object Storage \ (oracleobjectstorage) Storage> oracleobjectstorage Option provider. Choose your Auth Provider Choose a number from below, or type in your own string value. Press Enter for the default (env_auth). 1 / automatically pickup the credentials from runtime(env), first one to provide auth wins \ (env_auth) / use an OCI user and an API key for authentication. 2 | you’ll need to put in a config file your tenancy OCID, user OCID, region, the path, fingerprint to an API key. | https://docs.oracle.com/en-us/iaas/Content/API/Concepts/sdkconfig.htm \ (user_principal_auth) / use instance principals to authorize an instance to make API calls. 3 | each instance has its own identity, and authenticates using the certificates that are read from instance metadata. | https://docs.oracle.com/en-us/iaas/Content/Identity/Tasks/callingservicesfrominstances.htm \ (instance_principal_auth) / use workload identity to grant Kubernetes pods policy-driven access to Oracle Cloud 4 | Infrastructure (OCI) resources using OCI Identity and Access Management (IAM). | https://docs.oracle.com/en-us/iaas/Content/ContEng/Tasks/contenggrantingworkloadaccesstoresources.htm \ (workload_identity_auth) 5 / use resource principals to make API calls \ (resource_principal_auth) 6 / no credentials needed, this is typically for reading public buckets \ (no_auth) provider> 2 Option namespace. Object storage namespace Enter a value. namespace> idbamagbg734 Option compartment. Object storage compartment OCID Enter a value. compartment> ocid1.compartment.oc1..aaaaaaaapufkxc7ame3sthry5i7ujrwfc7ejnthhu6bhanm5oqfjpyasjkba Option region. Object storage Region Enter a value. region> us-ashburn-1 Option endpoint. Endpoint for Object storage API. Leave blank to use the default endpoint for the region. Enter a value. Press Enter to leave empty. endpoint> Option config_file. Full Path to OCI config file Choose a number from below, or type in your own string value. Press Enter for the default (~/.oci/config). 1 / oci configuration file location \ (~/.oci/config) config_file> /etc/oci/dev.conf Option config_profile. Profile name inside OCI config file Choose a number from below, or type in your own string value. Press Enter for the default (Default). 1 / Use the default profile \ (Default) config_profile> Test Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: oracleobjectstorage - namespace: idbamagbg734 - compartment: ocid1.compartment.oc1..aaaaaaaapufkxc7ame3sthry5i7ujrwfc7ejnthhu6bhanm5oqfjpyasjkba - region: us-ashburn-1 - provider: user_principal_auth - config_file: /etc/oci/dev.conf - config_profile: Test Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` See all buckets rclone lsd remote: Create a new bucket rclone mkdir remote:bucket List the contents of a bucket rclone ls remote:bucket rclone ls remote:bucket --max-depth 1 ## Authentication Providers OCI has various authentication methods. To learn more about authentication methods please refer [oci authentication methods](https://docs.oracle.com/en-us/iaas/Content/API/Concepts/sdk_authentication_methods.htm) These choices can be specified in the rclone config file. Rclone supports the following OCI authentication provider. User Principal Instance Principal Resource Principal Workload Identity No authentication ### User Principal Sample rclone config file for Authentication Provider User Principal: [oos] type = oracleobjectstorage namespace = id34 compartment = ocid1.compartment.oc1..aaba region = us-ashburn-1 provider = user_principal_auth config_file = /home/opc/.oci/config config_profile = Default Advantages: - One can use this method from any server within OCI or on-premises or from other cloud provider. Considerations: - you need to configure user’s privileges / policy to allow access to object storage - Overhead of managing users and keys. - If the user is deleted, the config file will no longer work and may cause automation regressions that use the user's credentials. ### Instance Principal An OCI compute instance can be authorized to use rclone by using it's identity and certificates as an instance principal. With this approach no credentials have to be stored and managed. Sample rclone configuration file for Authentication Provider Instance Principal: [opc@rclone ~]$ cat ~/.config/rclone/rclone.conf [oos] type = oracleobjectstorage namespace = idfn compartment = ocid1.compartment.oc1..aak7a region = us-ashburn-1 provider = instance_principal_auth Advantages: - With instance principals, you don't need to configure user credentials and transfer/ save it to disk in your compute instances or rotate the credentials. - You don’t need to deal with users and keys. - Greatly helps in automation as you don't have to manage access keys, user private keys, storing them in vault, using kms etc. Considerations: - You need to configure a dynamic group having this instance as member and add policy to read object storage to that dynamic group. - Everyone who has access to this machine can execute the CLI commands. - It is applicable for oci compute instances only. It cannot be used on external instance or resources. ### Resource Principal Resource principal auth is very similar to instance principal auth but used for resources that are not compute instances such as [serverless functions](https://docs.oracle.com/en-us/iaas/Content/Functions/Concepts/functionsoverview.htm). To use resource principal ensure Rclone process is started with these environment variables set in its process. export OCI_RESOURCE_PRINCIPAL_VERSION=2.2 export OCI_RESOURCE_PRINCIPAL_REGION=us-ashburn-1 export OCI_RESOURCE_PRINCIPAL_PRIVATE_PEM=/usr/share/model-server/key.pem export OCI_RESOURCE_PRINCIPAL_RPST=/usr/share/model-server/security_token Sample rclone configuration file for Authentication Provider Resource Principal: [oos] type = oracleobjectstorage namespace = id34 compartment = ocid1.compartment.oc1..aaba region = us-ashburn-1 provider = resource_principal_auth ### Workload Identity Workload Identity auth may be used when running Rclone from Kubernetes pod on a Container Engine for Kubernetes (OKE) cluster. For more details on configuring Workload Identity, see [Granting Workloads Access to OCI Resources](https://docs.oracle.com/en-us/iaas/Content/ContEng/Tasks/contenggrantingworkloadaccesstoresources.htm). To use workload identity, ensure Rclone is started with these environment variables set in its process. export OCI_RESOURCE_PRINCIPAL_VERSION=2.2 export OCI_RESOURCE_PRINCIPAL_REGION=us-ashburn-1 ### No authentication Public buckets do not require any authentication mechanism to read objects. Sample rclone configuration file for No authentication: [oos] type = oracleobjectstorage namespace = id34 compartment = ocid1.compartment.oc1..aaba region = us-ashburn-1 provider = no_auth ### Modification times and hashes The modification time is stored as metadata on the object as `opc-meta-mtime` as floating point since the epoch, accurate to 1 ns. If the modification time needs to be updated rclone will attempt to perform a server side copy to update the modification if the object can be copied in a single part. In the case the object is larger than 5Gb, the object will be uploaded rather than copied. Note that reading this from the object takes an additional `HEAD` request as the metadata isn't returned in object listings. The MD5 hash algorithm is supported. ### Multipart uploads rclone supports multipart uploads with OOS which means that it can upload files bigger than 5 GiB. Note that files uploaded *both* with multipart upload *and* through crypt remotes do not have MD5 sums. rclone switches from single part uploads to multipart uploads at the point specified by `--oos-upload-cutoff`. This can be a maximum of 5 GiB and a minimum of 0 (ie always upload multipart files). The chunk sizes used in the multipart upload are specified by `--oos-chunk-size` and the number of chunks uploaded concurrently is specified by `--oos-upload-concurrency`. Multipart uploads will use `--transfers` * `--oos-upload-concurrency` * `--oos-chunk-size` extra memory. Single part uploads to not use extra memory. Single part transfers can be faster than multipart transfers or slower depending on your latency from oos - the more latency, the more likely single part transfers will be faster. Increasing `--oos-upload-concurrency` will increase throughput (8 would be a sensible value) and increasing `--oos-chunk-size` also increases throughput (16M would be sensible). Increasing either of these will use more memory. The default values are high enough to gain most of the possible performance without using too much memory. ### Standard options Here are the Standard options specific to oracleobjectstorage (Oracle Cloud Infrastructure Object Storage). #### --oos-provider Choose your Auth Provider Properties: - Config: provider - Env Var: RCLONE_OOS_PROVIDER - Type: string - Default: "env_auth" - Examples: - "env_auth" - automatically pickup the credentials from runtime(env), first one to provide auth wins - "user_principal_auth" - use an OCI user and an API key for authentication. - you’ll need to put in a config file your tenancy OCID, user OCID, region, the path, fingerprint to an API key. - https://docs.oracle.com/en-us/iaas/Content/API/Concepts/sdkconfig.htm - "instance_principal_auth" - use instance principals to authorize an instance to make API calls. - each instance has its own identity, and authenticates using the certificates that are read from instance metadata. - https://docs.oracle.com/en-us/iaas/Content/Identity/Tasks/callingservicesfrominstances.htm - "workload_identity_auth" - use workload identity to grant OCI Container Engine for Kubernetes workloads policy-driven access to OCI resources using OCI Identity and Access Management (IAM). - https://docs.oracle.com/en-us/iaas/Content/ContEng/Tasks/contenggrantingworkloadaccesstoresources.htm - "resource_principal_auth" - use resource principals to make API calls - "no_auth" - no credentials needed, this is typically for reading public buckets #### --oos-namespace Object storage namespace Properties: - Config: namespace - Env Var: RCLONE_OOS_NAMESPACE - Type: string - Required: true #### --oos-compartment Specify compartment OCID, if you need to list buckets. List objects works without compartment OCID. Properties: - Config: compartment - Env Var: RCLONE_OOS_COMPARTMENT - Provider: !no_auth - Type: string - Required: false #### --oos-region Object storage Region Properties: - Config: region - Env Var: RCLONE_OOS_REGION - Type: string - Required: true #### --oos-endpoint Endpoint for Object storage API. Leave blank to use the default endpoint for the region. Properties: - Config: endpoint - Env Var: RCLONE_OOS_ENDPOINT - Type: string - Required: false #### --oos-config-file Path to OCI config file Properties: - Config: config_file - Env Var: RCLONE_OOS_CONFIG_FILE - Provider: user_principal_auth - Type: string - Default: "~/.oci/config" - Examples: - "~/.oci/config" - oci configuration file location #### --oos-config-profile Profile name inside the oci config file Properties: - Config: config_profile - Env Var: RCLONE_OOS_CONFIG_PROFILE - Provider: user_principal_auth - Type: string - Default: "Default" - Examples: - "Default" - Use the default profile ### Advanced options Here are the Advanced options specific to oracleobjectstorage (Oracle Cloud Infrastructure Object Storage). #### --oos-storage-tier The storage class to use when storing new objects in storage. https://docs.oracle.com/en-us/iaas/Content/Object/Concepts/understandingstoragetiers.htm Properties: - Config: storage_tier - Env Var: RCLONE_OOS_STORAGE_TIER - Type: string - Default: "Standard" - Examples: - "Standard" - Standard storage tier, this is the default tier - "InfrequentAccess" - InfrequentAccess storage tier - "Archive" - Archive storage tier #### --oos-upload-cutoff Cutoff for switching to chunked upload. Any files larger than this will be uploaded in chunks of chunk_size. The minimum is 0 and the maximum is 5 GiB. Properties: - Config: upload_cutoff - Env Var: RCLONE_OOS_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 200Mi #### --oos-chunk-size Chunk size to use for uploading. When uploading files larger than upload_cutoff or files with unknown size (e.g. from "rclone rcat" or uploaded with "rclone mount" they will be uploaded as multipart uploads using this chunk size. Note that "upload_concurrency" chunks of this size are buffered in memory per transfer. If you are transferring large files over high-speed links and you have enough memory, then increasing this will speed up the transfers. Rclone will automatically increase the chunk size when uploading a large file of known size to stay below the 10,000 chunks limit. Files of unknown size are uploaded with the configured chunk_size. Since the default chunk size is 5 MiB and there can be at most 10,000 chunks, this means that by default the maximum size of a file you can stream upload is 48 GiB. If you wish to stream upload larger files then you will need to increase chunk_size. Increasing the chunk size decreases the accuracy of the progress statistics displayed with "-P" flag. Properties: - Config: chunk_size - Env Var: RCLONE_OOS_CHUNK_SIZE - Type: SizeSuffix - Default: 5Mi #### --oos-max-upload-parts Maximum number of parts in a multipart upload. This option defines the maximum number of multipart chunks to use when doing a multipart upload. OCI has max parts limit of 10,000 chunks. Rclone will automatically increase the chunk size when uploading a large file of a known size to stay below this number of chunks limit. Properties: - Config: max_upload_parts - Env Var: RCLONE_OOS_MAX_UPLOAD_PARTS - Type: int - Default: 10000 #### --oos-upload-concurrency Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. Properties: - Config: upload_concurrency - Env Var: RCLONE_OOS_UPLOAD_CONCURRENCY - Type: int - Default: 10 #### --oos-copy-cutoff Cutoff for switching to multipart copy. Any files larger than this that need to be server-side copied will be copied in chunks of this size. The minimum is 0 and the maximum is 5 GiB. Properties: - Config: copy_cutoff - Env Var: RCLONE_OOS_COPY_CUTOFF - Type: SizeSuffix - Default: 4.656Gi #### --oos-copy-timeout Timeout for copy. Copy is an asynchronous operation, specify timeout to wait for copy to succeed Properties: - Config: copy_timeout - Env Var: RCLONE_OOS_COPY_TIMEOUT - Type: Duration - Default: 1m0s #### --oos-disable-checksum Don't store MD5 checksum with object metadata. Normally rclone will calculate the MD5 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading. Properties: - Config: disable_checksum - Env Var: RCLONE_OOS_DISABLE_CHECKSUM - Type: bool - Default: false #### --oos-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_OOS_ENCODING - Type: Encoding - Default: Slash,InvalidUtf8,Dot #### --oos-leave-parts-on-error If true avoid calling abort upload on a failure, leaving all successfully uploaded parts for manual recovery. It should be set to true for resuming uploads across different sessions. WARNING: Storing parts of an incomplete multipart upload counts towards space usage on object storage and will add additional costs if not cleaned up. Properties: - Config: leave_parts_on_error - Env Var: RCLONE_OOS_LEAVE_PARTS_ON_ERROR - Type: bool - Default: false #### --oos-attempt-resume-upload If true attempt to resume previously started multipart upload for the object. This will be helpful to speed up multipart transfers by resuming uploads from past session. WARNING: If chunk size differs in resumed session from past incomplete session, then the resumed multipart upload is aborted and a new multipart upload is started with the new chunk size. The flag leave_parts_on_error must be true to resume and optimize to skip parts that were already uploaded successfully. Properties: - Config: attempt_resume_upload - Env Var: RCLONE_OOS_ATTEMPT_RESUME_UPLOAD - Type: bool - Default: false #### --oos-no-check-bucket If set, don't attempt to check the bucket exists or create it. This can be useful when trying to minimise the number of transactions rclone does if you know the bucket exists already. It can also be needed if the user you are using does not have bucket creation permissions. Properties: - Config: no_check_bucket - Env Var: RCLONE_OOS_NO_CHECK_BUCKET - Type: bool - Default: false #### --oos-sse-customer-key-file To use SSE-C, a file containing the base64-encoded string of the AES-256 encryption key associated with the object. Please note only one of sse_customer_key_file|sse_customer_key|sse_kms_key_id is needed.' Properties: - Config: sse_customer_key_file - Env Var: RCLONE_OOS_SSE_CUSTOMER_KEY_FILE - Type: string - Required: false - Examples: - "" - None #### --oos-sse-customer-key To use SSE-C, the optional header that specifies the base64-encoded 256-bit encryption key to use to encrypt or decrypt the data. Please note only one of sse_customer_key_file|sse_customer_key|sse_kms_key_id is needed. For more information, see Using Your Own Keys for Server-Side Encryption (https://docs.cloud.oracle.com/Content/Object/Tasks/usingyourencryptionkeys.htm) Properties: - Config: sse_customer_key - Env Var: RCLONE_OOS_SSE_CUSTOMER_KEY - Type: string - Required: false - Examples: - "" - None #### --oos-sse-customer-key-sha256 If using SSE-C, The optional header that specifies the base64-encoded SHA256 hash of the encryption key. This value is used to check the integrity of the encryption key. see Using Your Own Keys for Server-Side Encryption (https://docs.cloud.oracle.com/Content/Object/Tasks/usingyourencryptionkeys.htm). Properties: - Config: sse_customer_key_sha256 - Env Var: RCLONE_OOS_SSE_CUSTOMER_KEY_SHA256 - Type: string - Required: false - Examples: - "" - None #### --oos-sse-kms-key-id if using your own master key in vault, this header specifies the OCID (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of a master encryption key used to call the Key Management service to generate a data encryption key or to encrypt or decrypt a data encryption key. Please note only one of sse_customer_key_file|sse_customer_key|sse_kms_key_id is needed. Properties: - Config: sse_kms_key_id - Env Var: RCLONE_OOS_SSE_KMS_KEY_ID - Type: string - Required: false - Examples: - "" - None #### --oos-sse-customer-algorithm If using SSE-C, the optional header that specifies "AES256" as the encryption algorithm. Object Storage supports "AES256" as the encryption algorithm. For more information, see Using Your Own Keys for Server-Side Encryption (https://docs.cloud.oracle.com/Content/Object/Tasks/usingyourencryptionkeys.htm). Properties: - Config: sse_customer_algorithm - Env Var: RCLONE_OOS_SSE_CUSTOMER_ALGORITHM - Type: string - Required: false - Examples: - "" - None - "AES256" - AES256 #### --oos-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_OOS_DESCRIPTION - Type: string - Required: false ### Metadata User metadata is stored as opc-meta- keys. Here are the possible system metadata items for the oracleobjectstorage backend. | Name | Help | Type | Example | Read Only | |------|------|------|---------|-----------| | opc-meta-atime | Time of last access | ISO 8601 | 2025-06-30T22:27:43-04:00 | N | | opc-meta-btime | Time of file birth (creation) | ISO 8601 | 2025-06-30T22:27:43-04:00 | N | | opc-meta-gid | Group ID of owner | decimal number | 500 | N | | opc-meta-mode | File type and mode | octal, unix style | 0100664 | N | | opc-meta-mtime | Time of last modification | ISO 8601 | 2025-06-30T22:27:43-04:00 | N | | opc-meta-uid | User ID of owner | decimal number | 500 | N | See the [metadata](https://rclone.org/docs/#metadata) docs for more info. ## Backend commands Here are the commands specific to the oracleobjectstorage backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the [backend](https://rclone.org/commands/rclone_backend/) command for more info on how to pass options and arguments. These can be run on a running backend using the rc command [backend/command](https://rclone.org/rc/#backend-command). ### rename change the name of an object rclone backend rename remote: [options] [+] This command can be used to rename a object. Usage Examples: rclone backend rename oos:bucket relative-object-path-under-bucket object-new-name ### list-multipart-uploads List the unfinished multipart uploads rclone backend list-multipart-uploads remote: [options] [+] This command lists the unfinished multipart uploads in JSON format. rclone backend list-multipart-uploads oos:bucket/path/to/object It returns a dictionary of buckets with values as lists of unfinished multipart uploads. You can call it with no bucket in which case it lists all bucket, with a bucket or with a bucket and path. { "test-bucket": [ { "namespace": "test-namespace", "bucket": "test-bucket", "object": "600m.bin", "uploadId": "51dd8114-52a4-b2f2-c42f-5291f05eb3c8", "timeCreated": "2022-07-29T06:21:16.595Z", "storageTier": "Standard" } ] ### cleanup Remove unfinished multipart uploads. rclone backend cleanup remote: [options] [+] This command removes unfinished multipart uploads of age greater than max-age which defaults to 24 hours. Note that you can use --interactive/-i or --dry-run with this command to see what it would do. rclone backend cleanup oos:bucket/path/to/object rclone backend cleanup -o max-age=7w oos:bucket/path/to/object Durations are parsed as per the rest of rclone, 2h, 7d, 7w etc. Options: - "max-age": Max age of upload to delete ### restore Restore objects from Archive to Standard storage rclone backend restore remote: [options] [+] This command can be used to restore one or more objects from Archive to Standard storage. Usage Examples: rclone backend restore oos:bucket/path/to/directory -o hours=HOURS rclone backend restore oos:bucket -o hours=HOURS This flag also obeys the filters. Test first with --interactive/-i or --dry-run flags rclone --interactive backend restore --include "*.txt" oos:bucket/path -o hours=72 All the objects shown will be marked for restore, then rclone backend restore --include "*.txt" oos:bucket/path -o hours=72 It returns a list of status dictionaries with Object Name and Status keys. The Status will be "RESTORED"" if it was successful or an error message if not. [ { "Object": "test.txt" "Status": "RESTORED", }, { "Object": "test/file4.txt" "Status": "RESTORED", } ] Options: - "hours": The number of hours for which this object will be restored. Default is 24 hrs. ## Tutorials ### [Mounting Buckets](https://rclone.org/oracleobjectstorage/tutorial_mount/) # QingStor Paths are specified as `remote:bucket` (or `remote:` for the `lsd` command.) You may put subdirectories in too, e.g. `remote:bucket/path/to/dir`. ## Configuration Here is an example of making an QingStor configuration. First run rclone config This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config n/r/c/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / QingStor Object Storage \ "qingstor" [snip] Storage> qingstor Get QingStor credentials from runtime. Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own value 1 / Enter QingStor credentials in the next step \ "false" 2 / Get QingStor credentials from the environment (env vars or IAM) \ "true" env_auth> 1 QingStor Access Key ID - leave blank for anonymous access or runtime credentials. access_key_id> access_key QingStor Secret Access Key (password) - leave blank for anonymous access or runtime credentials. secret_access_key> secret_key Enter an endpoint URL to connection QingStor API. Leave blank will use the default value "https://qingstor.com:443" endpoint> Zone connect to. Default is "pek3a". Choose a number from below, or type in your own value / The Beijing (China) Three Zone 1 | Needs location constraint pek3a. \ "pek3a" / The Shanghai (China) First Zone 2 | Needs location constraint sh1a. \ "sh1a" zone> 1 Number of connection retry. Leave blank will use the default value "3". connection_retries> Remote config Configuration complete. Options: - type: qingstor - env_auth: false - access_key_id: access_key - secret_access_key: secret_key - endpoint: - zone: pek3a - connection_retries: Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` This remote is called `remote` and can now be used like this See all buckets rclone lsd remote: Make a new bucket rclone mkdir remote:bucket List the contents of a bucket rclone ls remote:bucket Sync `/home/local/directory` to the remote bucket, deleting any excess files in the bucket. rclone sync --interactive /home/local/directory remote:bucket ### --fast-list This remote supports `--fast-list` which allows you to use fewer transactions in exchange for more memory. See the [rclone docs](https://rclone.org/docs/#fast-list) for more details. ### Multipart uploads rclone supports multipart uploads with QingStor which means that it can upload files bigger than 5 GiB. Note that files uploaded with multipart upload don't have an MD5SUM. Note that incomplete multipart uploads older than 24 hours can be removed with `rclone cleanup remote:bucket` just for one bucket `rclone cleanup remote:` for all buckets. QingStor does not ever remove incomplete multipart uploads so it may be necessary to run this from time to time. ### Buckets and Zone With QingStor you can list buckets (`rclone lsd`) using any zone, but you can only access the content of a bucket from the zone it was created in. If you attempt to access a bucket from the wrong zone, you will get an error, `incorrect zone, the bucket is not in 'XXX' zone`. ### Authentication There are two ways to supply `rclone` with a set of QingStor credentials. In order of precedence: - Directly in the rclone configuration file (as configured by `rclone config`) - set `access_key_id` and `secret_access_key` - Runtime configuration: - set `env_auth` to `true` in the config file - Exporting the following environment variables before running `rclone` - Access Key ID: `QS_ACCESS_KEY_ID` or `QS_ACCESS_KEY` - Secret Access Key: `QS_SECRET_ACCESS_KEY` or `QS_SECRET_KEY` ### Restricted filename characters The control characters 0x00-0x1F and / are replaced as in the [default restricted characters set](https://rclone.org/overview/#restricted-characters). Note that 0x7F is not replaced. Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Standard options Here are the Standard options specific to qingstor (QingCloud Object Storage). #### --qingstor-env-auth Get QingStor credentials from runtime. Only applies if access_key_id and secret_access_key is blank. Properties: - Config: env_auth - Env Var: RCLONE_QINGSTOR_ENV_AUTH - Type: bool - Default: false - Examples: - "false" - Enter QingStor credentials in the next step. - "true" - Get QingStor credentials from the environment (env vars or IAM). #### --qingstor-access-key-id QingStor Access Key ID. Leave blank for anonymous access or runtime credentials. Properties: - Config: access_key_id - Env Var: RCLONE_QINGSTOR_ACCESS_KEY_ID - Type: string - Required: false #### --qingstor-secret-access-key QingStor Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Properties: - Config: secret_access_key - Env Var: RCLONE_QINGSTOR_SECRET_ACCESS_KEY - Type: string - Required: false #### --qingstor-endpoint Enter an endpoint URL to connection QingStor API. Leave blank will use the default value "https://qingstor.com:443". Properties: - Config: endpoint - Env Var: RCLONE_QINGSTOR_ENDPOINT - Type: string - Required: false #### --qingstor-zone Zone to connect to. Default is "pek3a". Properties: - Config: zone - Env Var: RCLONE_QINGSTOR_ZONE - Type: string - Required: false - Examples: - "pek3a" - The Beijing (China) Three Zone. - Needs location constraint pek3a. - "sh1a" - The Shanghai (China) First Zone. - Needs location constraint sh1a. - "gd2a" - The Guangdong (China) Second Zone. - Needs location constraint gd2a. ### Advanced options Here are the Advanced options specific to qingstor (QingCloud Object Storage). #### --qingstor-connection-retries Number of connection retries. Properties: - Config: connection_retries - Env Var: RCLONE_QINGSTOR_CONNECTION_RETRIES - Type: int - Default: 3 #### --qingstor-upload-cutoff Cutoff for switching to chunked upload. Any files larger than this will be uploaded in chunks of chunk_size. The minimum is 0 and the maximum is 5 GiB. Properties: - Config: upload_cutoff - Env Var: RCLONE_QINGSTOR_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 200Mi #### --qingstor-chunk-size Chunk size to use for uploading. When uploading files larger than upload_cutoff they will be uploaded as multipart uploads using this chunk size. Note that "--qingstor-upload-concurrency" chunks of this size are buffered in memory per transfer. If you are transferring large files over high-speed links and you have enough memory, then increasing this will speed up the transfers. Properties: - Config: chunk_size - Env Var: RCLONE_QINGSTOR_CHUNK_SIZE - Type: SizeSuffix - Default: 4Mi #### --qingstor-upload-concurrency Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently. NB if you set this to > 1 then the checksums of multipart uploads become corrupted (the uploads themselves are not corrupted though). If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. Properties: - Config: upload_concurrency - Env Var: RCLONE_QINGSTOR_UPLOAD_CONCURRENCY - Type: int - Default: 1 #### --qingstor-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_QINGSTOR_ENCODING - Type: Encoding - Default: Slash,Ctl,InvalidUtf8 #### --qingstor-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_QINGSTOR_DESCRIPTION - Type: string - Required: false ## Limitations `rclone about` is not supported by the qingstor backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) # Quatrix Quatrix by Maytech is [Quatrix Secure Compliant File Sharing | Maytech](https://www.maytech.net/products/quatrix-business). Paths are specified as `remote:path` Paths may be as deep as required, e.g., `remote:directory/subdirectory`. The initial setup for Quatrix involves getting an API Key from Quatrix. You can get the API key in the user's profile at `https:///profile/api-keys` or with the help of the API - https://docs.maytech.net/quatrix/quatrix-api/api-explorer#/API-Key/post_api_key_create. See complete Swagger documentation for Quatrix - https://docs.maytech.net/quatrix/quatrix-api/api-explorer ## Configuration Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Quatrix by Maytech \ "quatrix" [snip] Storage> quatrix API key for accessing Quatrix account. api_key> your_api_key Host name of Quatrix account. host> example.quatrix.it Configuration complete. Options: - type: quatrix - api_key: your_api_key - host: example.quatrix.it Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` Once configured you can then use `rclone` like this, List directories in top level of your Quatrix rclone lsd remote: List all the files in your Quatrix rclone ls remote: To copy a local directory to an Quatrix directory called backup rclone copy /home/source remote:backup ### API key validity API Key is created with no expiration date. It will be valid until you delete or deactivate it in your account. After disabling, the API Key can be enabled back. If the API Key was deleted and a new key was created, you can update it in rclone config. The same happens if the hostname was changed. ``` $ rclone config Current remotes: Name Type ==== ==== remote quatrix e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> e Choose a number from below, or type in an existing value 1 > remote remote> remote Configuration complete. Options: - type: quatrix - host: some_host.quatrix.it - api_key: your_api_key Keep this "remote" remote? Edit remote Option api_key. API key for accessing Quatrix account Enter a string value. Press Enter for the default (your_api_key) api_key> Option host. Host name of Quatrix account Enter a string value. Press Enter for the default (some_host.quatrix.it). Configuration complete. Options: - type: quatrix - host: some_host.quatrix.it - api_key: your_api_key Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` ### Modification times and hashes Quatrix allows modification times to be set on objects accurate to 1 microsecond. These will be used to detect whether objects need syncing or not. Quatrix does not support hashes, so you cannot use the `--checksum` flag. ### Restricted filename characters File names in Quatrix are case sensitive and have limitations like the maximum length of a filename is 255, and the minimum length is 1. A file name cannot be equal to `.` or `..` nor contain `/` , `\` or non-printable ascii. ### Transfers For files above 50 MiB rclone will use a chunked transfer. Rclone will upload up to `--transfers` chunks at the same time (shared among all multipart uploads). Chunks are buffered in memory, and the minimal chunk size is 10_000_000 bytes by default, and it can be changed in the advanced configuration, so increasing `--transfers` will increase the memory use. The chunk size has a maximum size limit, which is set to 100_000_000 bytes by default and can be changed in the advanced configuration. The size of the uploaded chunk will dynamically change depending on the upload speed. The total memory use equals the number of transfers multiplied by the minimal chunk size. In case there's free memory allocated for the upload (which equals the difference of `maximal_summary_chunk_size` and `minimal_chunk_size` * `transfers`), the chunk size may increase in case of high upload speed. As well as it can decrease in case of upload speed problems. If no free memory is available, all chunks will equal `minimal_chunk_size`. ### Deleting files Files you delete with rclone will end up in Trash and be stored there for 30 days. Quatrix also provides an API to permanently delete files and an API to empty the Trash so that you can remove files permanently from your account. ### Standard options Here are the Standard options specific to quatrix (Quatrix by Maytech). #### --quatrix-api-key API key for accessing Quatrix account Properties: - Config: api_key - Env Var: RCLONE_QUATRIX_API_KEY - Type: string - Required: true #### --quatrix-host Host name of Quatrix account Properties: - Config: host - Env Var: RCLONE_QUATRIX_HOST - Type: string - Required: true ### Advanced options Here are the Advanced options specific to quatrix (Quatrix by Maytech). #### --quatrix-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_QUATRIX_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot #### --quatrix-effective-upload-time Wanted upload time for one chunk Properties: - Config: effective_upload_time - Env Var: RCLONE_QUATRIX_EFFECTIVE_UPLOAD_TIME - Type: string - Default: "4s" #### --quatrix-minimal-chunk-size The minimal size for one chunk Properties: - Config: minimal_chunk_size - Env Var: RCLONE_QUATRIX_MINIMAL_CHUNK_SIZE - Type: SizeSuffix - Default: 9.537Mi #### --quatrix-maximal-summary-chunk-size The maximal summary for all chunks. It should not be less than 'transfers'*'minimal_chunk_size' Properties: - Config: maximal_summary_chunk_size - Env Var: RCLONE_QUATRIX_MAXIMAL_SUMMARY_CHUNK_SIZE - Type: SizeSuffix - Default: 95.367Mi #### --quatrix-hard-delete Delete files permanently rather than putting them into the trash Properties: - Config: hard_delete - Env Var: RCLONE_QUATRIX_HARD_DELETE - Type: bool - Default: false #### --quatrix-skip-project-folders Skip project folders in operations Properties: - Config: skip_project_folders - Env Var: RCLONE_QUATRIX_SKIP_PROJECT_FOLDERS - Type: bool - Default: false #### --quatrix-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_QUATRIX_DESCRIPTION - Type: string - Required: false ## Storage usage The storage usage in Quatrix is restricted to the account during the purchase. You can restrict any user with a smaller storage limit. The account limit is applied if the user has no custom storage limit. Once you've reached the limit, the upload of files will fail. This can be fixed by freeing up the space or increasing the quota. ## Server-side operations Quatrix supports server-side operations (copy and move). In case of conflict, files are overwritten during server-side operation. # Sia Sia ([sia.tech](https://sia.tech/)) is a decentralized cloud storage platform based on the [blockchain](https://wikipedia.org/wiki/Blockchain) technology. With rclone you can use it like any other remote filesystem or mount Sia folders locally. The technology behind it involves a number of new concepts such as Siacoins and Wallet, Blockchain and Consensus, Renting and Hosting, and so on. If you are new to it, you'd better first familiarize yourself using their excellent [support documentation](https://support.sia.tech/). ## Introduction Before you can use rclone with Sia, you will need to have a running copy of `Sia-UI` or `siad` (the Sia daemon) locally on your computer or on local network (e.g. a NAS). Please follow the [Get started](https://sia.tech/get-started) guide and install one. rclone interacts with Sia network by talking to the Sia daemon via [HTTP API](https://sia.tech/docs/) which is usually available on port _9980_. By default you will run the daemon locally on the same computer so it's safe to leave the API password blank (the API URL will be `http://127.0.0.1:9980` making external access impossible). However, if you want to access Sia daemon running on another node, for example due to memory constraints or because you want to share single daemon between several rclone and Sia-UI instances, you'll need to make a few more provisions: - Ensure you have _Sia daemon_ installed directly or in a [docker container](https://github.com/SiaFoundation/siad/pkgs/container/siad) because Sia-UI does not support this mode natively. - Run it on externally accessible port, for example provide `--api-addr :9980` and `--disable-api-security` arguments on the daemon command line. - Enforce API password for the `siad` daemon via environment variable `SIA_API_PASSWORD` or text file named `apipassword` in the daemon directory. - Set rclone backend option `api_password` taking it from above locations. Notes: 1. If your wallet is locked, rclone cannot unlock it automatically. You should either unlock it in advance by using Sia-UI or via command line `siac wallet unlock`. Alternatively you can make `siad` unlock your wallet automatically upon startup by running it with environment variable `SIA_WALLET_PASSWORD`. 2. If `siad` cannot find the `SIA_API_PASSWORD` variable or the `apipassword` file in the `SIA_DIR` directory, it will generate a random password and store in the text file named `apipassword` under `YOUR_HOME/.sia/` directory on Unix or `C:\Users\YOUR_HOME\AppData\Local\Sia\apipassword` on Windows. Remember this when you configure password in rclone. 3. The only way to use `siad` without API password is to run it **on localhost** with command line argument `--authorize-api=false`, but this is insecure and **strongly discouraged**. ## Configuration Here is an example of how to make a `sia` remote called `mySia`. First, run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> mySia Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value ... 29 / Sia Decentralized Cloud \ "sia" ... Storage> sia Sia daemon API URL, like http://sia.daemon.host:9980. Note that siad must run with --disable-api-security to open API port for other hosts (not recommended). Keep default if Sia daemon runs on localhost. Enter a string value. Press Enter for the default ("http://127.0.0.1:9980"). api_url> http://127.0.0.1:9980 Sia Daemon API Password. Can be found in the apipassword file located in HOME/.sia/ or in the daemon directory. y) Yes type in my own password g) Generate random password n) No leave this optional password blank (default) y/g/n> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n -------------------- [mySia] type = sia api_url = http://127.0.0.1:9980 api_password = *** ENCRYPTED *** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` Once configured, you can then use `rclone` like this: - List directories in top level of your Sia storage ``` rclone lsd mySia: ``` - List all the files in your Sia storage ``` rclone ls mySia: ``` - Upload a local directory to the Sia directory called _backup_ ``` rclone copy /home/source mySia:backup ``` ### Standard options Here are the Standard options specific to sia (Sia Decentralized Cloud). #### --sia-api-url Sia daemon API URL, like http://sia.daemon.host:9980. Note that siad must run with --disable-api-security to open API port for other hosts (not recommended). Keep default if Sia daemon runs on localhost. Properties: - Config: api_url - Env Var: RCLONE_SIA_API_URL - Type: string - Default: "http://127.0.0.1:9980" #### --sia-api-password Sia Daemon API Password. Can be found in the apipassword file located in HOME/.sia/ or in the daemon directory. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: api_password - Env Var: RCLONE_SIA_API_PASSWORD - Type: string - Required: false ### Advanced options Here are the Advanced options specific to sia (Sia Decentralized Cloud). #### --sia-user-agent Siad User Agent Sia daemon requires the 'Sia-Agent' user agent by default for security Properties: - Config: user_agent - Env Var: RCLONE_SIA_USER_AGENT - Type: string - Default: "Sia-Agent" #### --sia-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_SIA_ENCODING - Type: Encoding - Default: Slash,Question,Hash,Percent,Del,Ctl,InvalidUtf8,Dot #### --sia-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SIA_DESCRIPTION - Type: string - Required: false ## Limitations - Modification times not supported - Checksums not supported - `rclone about` not supported - rclone can work only with _Siad_ or _Sia-UI_ at the moment, the **SkyNet daemon is not supported yet.** - Sia does not allow control characters or symbols like question and pound signs in file names. rclone will transparently [encode](https://rclone.org/overview/#encoding) them for you, but you'd better be aware # Swift Swift refers to [OpenStack Object Storage](https://docs.openstack.org/swift/latest/). Commercial implementations of that being: * [Rackspace Cloud Files](https://www.rackspace.com/cloud/files/) * [Memset Memstore](https://www.memset.com/cloud/storage/) * [OVH Object Storage](https://www.ovhcloud.com/en/public-cloud/object-storage/) * [Oracle Cloud Storage](https://docs.oracle.com/en-us/iaas/integration/doc/configure-object-storage.html) * [Blomp Cloud Storage](https://www.blomp.com/cloud-storage/) * [IBM Bluemix Cloud ObjectStorage Swift](https://console.bluemix.net/docs/infrastructure/objectstorage-swift/index.html) Paths are specified as `remote:container` (or `remote:` for the `lsd` command.) You may put subdirectories in too, e.g. `remote:container/path/to/dir`. ## Configuration Here is an example of making a swift configuration. First run rclone config This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / OpenStack Swift (Rackspace Cloud Files, Blomp Cloud Storage, Memset Memstore, OVH) \ "swift" [snip] Storage> swift Get swift credentials from environment variables in standard OpenStack form. Choose a number from below, or type in your own value 1 / Enter swift credentials in the next step \ "false" 2 / Get swift credentials from environment vars. Leave other fields blank if using this. \ "true" env_auth> true User name to log in (OS_USERNAME). user> API key or password (OS_PASSWORD). key> Authentication URL for server (OS_AUTH_URL). Choose a number from below, or type in your own value 1 / Rackspace US \ "https://auth.api.rackspacecloud.com/v1.0" 2 / Rackspace UK \ "https://lon.auth.api.rackspacecloud.com/v1.0" 3 / Rackspace v2 \ "https://identity.api.rackspacecloud.com/v2.0" 4 / Memset Memstore UK \ "https://auth.storage.memset.com/v1.0" 5 / Memset Memstore UK v2 \ "https://auth.storage.memset.com/v2.0" 6 / OVH \ "https://auth.cloud.ovh.net/v3" 7 / Blomp Cloud Storage \ "https://authenticate.ain.net" auth> User ID to log in - optional - most swift systems use user and leave this blank (v3 auth) (OS_USER_ID). user_id> User domain - optional (v3 auth) (OS_USER_DOMAIN_NAME) domain> Tenant name - optional for v1 auth, this or tenant_id required otherwise (OS_TENANT_NAME or OS_PROJECT_NAME) tenant> Tenant ID - optional for v1 auth, this or tenant required otherwise (OS_TENANT_ID) tenant_id> Tenant domain - optional (v3 auth) (OS_PROJECT_DOMAIN_NAME) tenant_domain> Region name - optional (OS_REGION_NAME) region> Storage URL - optional (OS_STORAGE_URL) storage_url> Auth Token from alternate authentication - optional (OS_AUTH_TOKEN) auth_token> AuthVersion - optional - set to (1,2,3) if your auth URL has no version (ST_AUTH_VERSION) auth_version> Endpoint type to choose from the service catalogue (OS_ENDPOINT_TYPE) Choose a number from below, or type in your own value 1 / Public (default, choose this if not sure) \ "public" 2 / Internal (use internal service net) \ "internal" 3 / Admin \ "admin" endpoint_type> Remote config -------------------- [test] env_auth = true user = key = auth = user_id = domain = tenant = tenant_id = tenant_domain = region = storage_url = auth_token = auth_version = endpoint_type = -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` This remote is called `remote` and can now be used like this See all containers rclone lsd remote: Make a new container rclone mkdir remote:container List the contents of a container rclone ls remote:container Sync `/home/local/directory` to the remote container, deleting any excess files in the container. rclone sync --interactive /home/local/directory remote:container ### Configuration from an OpenStack credentials file An OpenStack credentials file typically looks something something like this (without the comments) ``` export OS_AUTH_URL=https://a.provider.net/v2.0 export OS_TENANT_ID=ffffffffffffffffffffffffffffffff export OS_TENANT_NAME="1234567890123456" export OS_USERNAME="123abc567xy" echo "Please enter your OpenStack Password: " read -sr OS_PASSWORD_INPUT export OS_PASSWORD=$OS_PASSWORD_INPUT export OS_REGION_NAME="SBG1" if [ -z "$OS_REGION_NAME" ]; then unset OS_REGION_NAME; fi ``` The config file needs to look something like this where `$OS_USERNAME` represents the value of the `OS_USERNAME` variable - `123abc567xy` in the example above. ``` [remote] type = swift user = $OS_USERNAME key = $OS_PASSWORD auth = $OS_AUTH_URL tenant = $OS_TENANT_NAME ``` Note that you may (or may not) need to set `region` too - try without first. ### Configuration from the environment If you prefer you can configure rclone to use swift using a standard set of OpenStack environment variables. When you run through the config, make sure you choose `true` for `env_auth` and leave everything else blank. rclone will then set any empty config parameters from the environment using standard OpenStack environment variables. There is [a list of the variables](https://godoc.org/github.com/ncw/swift#Connection.ApplyEnvironment) in the docs for the swift library. ### Using an alternate authentication method If your OpenStack installation uses a non-standard authentication method that might not be yet supported by rclone or the underlying swift library, you can authenticate externally (e.g. calling manually the `openstack` commands to get a token). Then, you just need to pass the two configuration variables ``auth_token`` and ``storage_url``. If they are both provided, the other variables are ignored. rclone will not try to authenticate but instead assume it is already authenticated and use these two variables to access the OpenStack installation. #### Using rclone without a config file You can use rclone with swift without a config file, if desired, like this: ``` source openstack-credentials-file export RCLONE_CONFIG_MYREMOTE_TYPE=swift export RCLONE_CONFIG_MYREMOTE_ENV_AUTH=true rclone lsd myremote: ``` ### --fast-list This remote supports `--fast-list` which allows you to use fewer transactions in exchange for more memory. See the [rclone docs](https://rclone.org/docs/#fast-list) for more details. ### --update and --use-server-modtime As noted below, the modified time is stored on metadata on the object. It is used by default for all operations that require checking the time a file was last updated. It allows rclone to treat the remote more like a true filesystem, but it is inefficient because it requires an extra API call to retrieve the metadata. For many operations, the time the object was last uploaded to the remote is sufficient to determine if it is "dirty". By using `--update` along with `--use-server-modtime`, you can avoid the extra API call and simply upload files whose local modtime is newer than the time it was last uploaded. ### Modification times and hashes The modified time is stored as metadata on the object as `X-Object-Meta-Mtime` as floating point since the epoch accurate to 1 ns. This is a de facto standard (used in the official python-swiftclient amongst others) for storing the modification time for an object. The MD5 hash algorithm is supported. ### Restricted filename characters | Character | Value | Replacement | | --------- |:-----:|:-----------:| | NUL | 0x00 | ␀ | | / | 0x2F | ／ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Standard options Here are the Standard options specific to swift (OpenStack Swift (Rackspace Cloud Files, Blomp Cloud Storage, Memset Memstore, OVH)). #### --swift-env-auth Get swift credentials from environment variables in standard OpenStack form. Properties: - Config: env_auth - Env Var: RCLONE_SWIFT_ENV_AUTH - Type: bool - Default: false - Examples: - "false" - Enter swift credentials in the next step. - "true" - Get swift credentials from environment vars. - Leave other fields blank if using this. #### --swift-user User name to log in (OS_USERNAME). Properties: - Config: user - Env Var: RCLONE_SWIFT_USER - Type: string - Required: false #### --swift-key API key or password (OS_PASSWORD). Properties: - Config: key - Env Var: RCLONE_SWIFT_KEY - Type: string - Required: false #### --swift-auth Authentication URL for server (OS_AUTH_URL). Properties: - Config: auth - Env Var: RCLONE_SWIFT_AUTH - Type: string - Required: false - Examples: - "https://auth.api.rackspacecloud.com/v1.0" - Rackspace US - "https://lon.auth.api.rackspacecloud.com/v1.0" - Rackspace UK - "https://identity.api.rackspacecloud.com/v2.0" - Rackspace v2 - "https://auth.storage.memset.com/v1.0" - Memset Memstore UK - "https://auth.storage.memset.com/v2.0" - Memset Memstore UK v2 - "https://auth.cloud.ovh.net/v3" - OVH - "https://authenticate.ain.net" - Blomp Cloud Storage #### --swift-user-id User ID to log in - optional - most swift systems use user and leave this blank (v3 auth) (OS_USER_ID). Properties: - Config: user_id - Env Var: RCLONE_SWIFT_USER_ID - Type: string - Required: false #### --swift-domain User domain - optional (v3 auth) (OS_USER_DOMAIN_NAME) Properties: - Config: domain - Env Var: RCLONE_SWIFT_DOMAIN - Type: string - Required: false #### --swift-tenant Tenant name - optional for v1 auth, this or tenant_id required otherwise (OS_TENANT_NAME or OS_PROJECT_NAME). Properties: - Config: tenant - Env Var: RCLONE_SWIFT_TENANT - Type: string - Required: false #### --swift-tenant-id Tenant ID - optional for v1 auth, this or tenant required otherwise (OS_TENANT_ID). Properties: - Config: tenant_id - Env Var: RCLONE_SWIFT_TENANT_ID - Type: string - Required: false #### --swift-tenant-domain Tenant domain - optional (v3 auth) (OS_PROJECT_DOMAIN_NAME). Properties: - Config: tenant_domain - Env Var: RCLONE_SWIFT_TENANT_DOMAIN - Type: string - Required: false #### --swift-region Region name - optional (OS_REGION_NAME). Properties: - Config: region - Env Var: RCLONE_SWIFT_REGION - Type: string - Required: false #### --swift-storage-url Storage URL - optional (OS_STORAGE_URL). Properties: - Config: storage_url - Env Var: RCLONE_SWIFT_STORAGE_URL - Type: string - Required: false #### --swift-auth-token Auth Token from alternate authentication - optional (OS_AUTH_TOKEN). Properties: - Config: auth_token - Env Var: RCLONE_SWIFT_AUTH_TOKEN - Type: string - Required: false #### --swift-application-credential-id Application Credential ID (OS_APPLICATION_CREDENTIAL_ID). Properties: - Config: application_credential_id - Env Var: RCLONE_SWIFT_APPLICATION_CREDENTIAL_ID - Type: string - Required: false #### --swift-application-credential-name Application Credential Name (OS_APPLICATION_CREDENTIAL_NAME). Properties: - Config: application_credential_name - Env Var: RCLONE_SWIFT_APPLICATION_CREDENTIAL_NAME - Type: string - Required: false #### --swift-application-credential-secret Application Credential Secret (OS_APPLICATION_CREDENTIAL_SECRET). Properties: - Config: application_credential_secret - Env Var: RCLONE_SWIFT_APPLICATION_CREDENTIAL_SECRET - Type: string - Required: false #### --swift-auth-version AuthVersion - optional - set to (1,2,3) if your auth URL has no version (ST_AUTH_VERSION). Properties: - Config: auth_version - Env Var: RCLONE_SWIFT_AUTH_VERSION - Type: int - Default: 0 #### --swift-endpoint-type Endpoint type to choose from the service catalogue (OS_ENDPOINT_TYPE). Properties: - Config: endpoint_type - Env Var: RCLONE_SWIFT_ENDPOINT_TYPE - Type: string - Default: "public" - Examples: - "public" - Public (default, choose this if not sure) - "internal" - Internal (use internal service net) - "admin" - Admin #### --swift-storage-policy The storage policy to use when creating a new container. This applies the specified storage policy when creating a new container. The policy cannot be changed afterwards. The allowed configuration values and their meaning depend on your Swift storage provider. Properties: - Config: storage_policy - Env Var: RCLONE_SWIFT_STORAGE_POLICY - Type: string - Required: false - Examples: - "" - Default - "pcs" - OVH Public Cloud Storage - "pca" - OVH Public Cloud Archive ### Advanced options Here are the Advanced options specific to swift (OpenStack Swift (Rackspace Cloud Files, Blomp Cloud Storage, Memset Memstore, OVH)). #### --swift-leave-parts-on-error If true avoid calling abort upload on a failure. It should be set to true for resuming uploads across different sessions. Properties: - Config: leave_parts_on_error - Env Var: RCLONE_SWIFT_LEAVE_PARTS_ON_ERROR - Type: bool - Default: false #### --swift-fetch-until-empty-page When paginating, always fetch unless we received an empty page. Consider using this option if rclone listings show fewer objects than expected, or if repeated syncs copy unchanged objects. It is safe to enable this, but rclone may make more API calls than necessary. This is one of a pair of workarounds to handle implementations of the Swift API that do not implement pagination as expected. See also "partial_page_fetch_threshold". Properties: - Config: fetch_until_empty_page - Env Var: RCLONE_SWIFT_FETCH_UNTIL_EMPTY_PAGE - Type: bool - Default: false #### --swift-partial-page-fetch-threshold When paginating, fetch if the current page is within this percentage of the limit. Consider using this option if rclone listings show fewer objects than expected, or if repeated syncs copy unchanged objects. It is safe to enable this, but rclone may make more API calls than necessary. This is one of a pair of workarounds to handle implementations of the Swift API that do not implement pagination as expected. See also "fetch_until_empty_page". Properties: - Config: partial_page_fetch_threshold - Env Var: RCLONE_SWIFT_PARTIAL_PAGE_FETCH_THRESHOLD - Type: int - Default: 0 #### --swift-chunk-size Above this size files will be chunked. Above this size files will be chunked into a a `_segments` container or a `.file-segments` directory. (See the `use_segments_container` option for more info). Default for this is 5 GiB which is its maximum value, which means only files above this size will be chunked. Rclone uploads chunked files as dynamic large objects (DLO). Properties: - Config: chunk_size - Env Var: RCLONE_SWIFT_CHUNK_SIZE - Type: SizeSuffix - Default: 5Gi #### --swift-no-chunk Don't chunk files during streaming upload. When doing streaming uploads (e.g. using `rcat` or `mount` with `--vfs-cache-mode off`) setting this flag will cause the swift backend to not upload chunked files. This will limit the maximum streamed upload size to 5 GiB. This is useful because non chunked files are easier to deal with and have an MD5SUM. Rclone will still chunk files bigger than `chunk_size` when doing normal copy operations. Properties: - Config: no_chunk - Env Var: RCLONE_SWIFT_NO_CHUNK - Type: bool - Default: false #### --swift-no-large-objects Disable support for static and dynamic large objects Swift cannot transparently store files bigger than 5 GiB. There are two schemes for chunking large files, static large objects (SLO) or dynamic large objects (DLO), and the API does not allow rclone to determine whether a file is a static or dynamic large object without doing a HEAD on the object. Since these need to be treated differently, this means rclone has to issue HEAD requests for objects for example when reading checksums. When `no_large_objects` is set, rclone will assume that there are no static or dynamic large objects stored. This means it can stop doing the extra HEAD calls which in turn increases performance greatly especially when doing a swift to swift transfer with `--checksum` set. Setting this option implies `no_chunk` and also that no files will be uploaded in chunks, so files bigger than 5 GiB will just fail on upload. If you set this option and there **are** static or dynamic large objects, then this will give incorrect hashes for them. Downloads will succeed, but other operations such as Remove and Copy will fail. Properties: - Config: no_large_objects - Env Var: RCLONE_SWIFT_NO_LARGE_OBJECTS - Type: bool - Default: false #### --swift-use-segments-container Choose destination for large object segments Swift cannot transparently store files bigger than 5 GiB and rclone will chunk files larger than `chunk_size` (default 5 GiB) in order to upload them. If this value is `true` the chunks will be stored in an additional container named the same as the destination container but with `_segments` appended. This means that there won't be any duplicated data in the original container but having another container may not be acceptable. If this value is `false` the chunks will be stored in a `.file-segments` directory in the root of the container. This directory will be omitted when listing the container. Some providers (eg Blomp) require this mode as creating additional containers isn't allowed. If it is desired to see the `.file-segments` directory in the root then this flag must be set to `true`. If this value is `unset` (the default), then rclone will choose the value to use. It will be `false` unless rclone detects any `auth_url`s that it knows need it to be `true`. In this case you'll see a message in the DEBUG log. Properties: - Config: use_segments_container - Env Var: RCLONE_SWIFT_USE_SEGMENTS_CONTAINER - Type: Tristate - Default: unset #### --swift-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_SWIFT_ENCODING - Type: Encoding - Default: Slash,InvalidUtf8 #### --swift-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SWIFT_DESCRIPTION - Type: string - Required: false ## Limitations The Swift API doesn't return a correct MD5SUM for segmented files (Dynamic or Static Large Objects) so rclone won't check or use the MD5SUM for these. ## Troubleshooting ### Rclone gives Failed to create file system for "remote:": Bad Request Due to an oddity of the underlying swift library, it gives a "Bad Request" error rather than a more sensible error when the authentication fails for Swift. So this most likely means your username / password is wrong. You can investigate further with the `--dump-bodies` flag. This may also be caused by specifying the region when you shouldn't have (e.g. OVH). ### Rclone gives Failed to create file system: Response didn't have storage url and auth token This is most likely caused by forgetting to specify your tenant when setting up a swift remote. ## OVH Cloud Archive To use rclone with OVH cloud archive, first use `rclone config` to set up a `swift` backend with OVH, choosing `pca` as the `storage_policy`. ### Uploading Objects Uploading objects to OVH cloud archive is no different to object storage, you just simply run the command you like (move, copy or sync) to upload the objects. Once uploaded the objects will show in a "Frozen" state within the OVH control panel. ### Retrieving Objects To retrieve objects use `rclone copy` as normal. If the objects are in a frozen state then rclone will ask for them all to be unfrozen and it will wait at the end of the output with a message like the following: `2019/03/23 13:06:33 NOTICE: Received retry after error - sleeping until 2019-03-23T13:16:33.481657164+01:00 (9m59.99985121s)` Rclone will wait for the time specified then retry the copy. # pCloud Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configuration The initial setup for pCloud involves getting a token from pCloud which you need to do in your browser. `rclone config` walks you through it. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Pcloud \ "pcloud" [snip] Storage> pcloud Pcloud App Client Id - leave blank normally. client_id> Pcloud App Client Secret - leave blank normally. client_secret> Edit advanced config? y) Yes n) No (default) y/n> n Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: pcloud - client_id: - client_secret: - token: {"access_token":"XXX","token_type":"bearer","expiry":"0001-01-01T00:00:00Z"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` See the [remote setup docs](https://rclone.org/remote_setup/) for how to set it up on a machine with no Internet browser available. Note if you are using remote config with rclone authorize while your pcloud server is the EU region, you will need to set the hostname in 'Edit advanced config', otherwise you might get a token error. Note that rclone runs a webserver on your local machine to collect the token as returned from pCloud. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on `http://127.0.0.1:53682/` and this it may require you to unblock it temporarily if you are running a host firewall. Once configured you can then use `rclone` like this, List directories in top level of your pCloud rclone lsd remote: List all the files in your pCloud rclone ls remote: To copy a local directory to a pCloud directory called backup rclone copy /home/source remote:backup ### Modification times and hashes pCloud allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not. In order to set a Modification time pCloud requires the object be re-uploaded. pCloud supports MD5 and SHA1 hashes in the US region, and SHA1 and SHA256 hashes in the EU region, so you can use the `--checksum` flag. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | \ | 0x5C | ＼ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Deleting files Deleted files will be moved to the trash. Your subscription level will determine how long items stay in the trash. `rclone cleanup` can be used to empty the trash. ### Emptying the trash Due to an API limitation, the `rclone cleanup` command will only work if you set your username and password in the advanced options for this backend. Since we generally want to avoid storing user passwords in the rclone config file, we advise you to only set this up if you need the `rclone cleanup` command to work. ### Root folder ID You can set the `root_folder_id` for rclone. This is the directory (identified by its `Folder ID`) that rclone considers to be the root of your pCloud drive. Normally you will leave this blank and rclone will determine the correct root to use itself. However you can set this to restrict rclone to a specific folder hierarchy. In order to do this you will have to find the `Folder ID` of the directory you wish rclone to display. This will be the `folder` field of the URL when you open the relevant folder in the pCloud web interface. So if the folder you want rclone to use has a URL which looks like `https://my.pcloud.com/#page=filemanager&folder=5xxxxxxxx8&tpl=foldergrid` in the browser, then you use `5xxxxxxxx8` as the `root_folder_id` in the config. ### Standard options Here are the Standard options specific to pcloud (Pcloud). #### --pcloud-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_PCLOUD_CLIENT_ID - Type: string - Required: false #### --pcloud-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_PCLOUD_CLIENT_SECRET - Type: string - Required: false ### Advanced options Here are the Advanced options specific to pcloud (Pcloud). #### --pcloud-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_PCLOUD_TOKEN - Type: string - Required: false #### --pcloud-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_PCLOUD_AUTH_URL - Type: string - Required: false #### --pcloud-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_PCLOUD_TOKEN_URL - Type: string - Required: false #### --pcloud-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_PCLOUD_CLIENT_CREDENTIALS - Type: bool - Default: false #### --pcloud-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_PCLOUD_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot #### --pcloud-root-folder-id Fill in for rclone to use a non root folder as its starting point. Properties: - Config: root_folder_id - Env Var: RCLONE_PCLOUD_ROOT_FOLDER_ID - Type: string - Default: "d0" #### --pcloud-hostname Hostname to connect to. This is normally set when rclone initially does the oauth connection, however you will need to set it by hand if you are using remote config with rclone authorize. Properties: - Config: hostname - Env Var: RCLONE_PCLOUD_HOSTNAME - Type: string - Default: "api.pcloud.com" - Examples: - "api.pcloud.com" - Original/US region - "eapi.pcloud.com" - EU region #### --pcloud-username Your pcloud username. This is only required when you want to use the cleanup command. Due to a bug in the pcloud API the required API does not support OAuth authentication so we have to rely on user password authentication for it. Properties: - Config: username - Env Var: RCLONE_PCLOUD_USERNAME - Type: string - Required: false #### --pcloud-password Your pcloud password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: password - Env Var: RCLONE_PCLOUD_PASSWORD - Type: string - Required: false #### --pcloud-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PCLOUD_DESCRIPTION - Type: string - Required: false # PikPak PikPak is [a private cloud drive](https://mypikpak.com/). Paths are specified as `remote:path`, and may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configuration Here is an example of making a remote for PikPak. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. XX / PikPak \ (pikpak) Storage> XX Option user. Pikpak username. Enter a value. user> USERNAME Option pass. Pikpak password. Choose an alternative below. y) Yes, type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> Configuration complete. Options: - type: pikpak - user: USERNAME - pass: *** ENCRYPTED *** - token: {"access_token":"eyJ...","token_type":"Bearer","refresh_token":"os...","expiry":"2023-01-26T18:54:32.170582647+09:00"} Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ### Modification times and hashes PikPak keeps modification times on objects, and updates them when uploading objects, but it does not support changing only the modification time The MD5 hash algorithm is supported. ### Standard options Here are the Standard options specific to pikpak (PikPak). #### --pikpak-user Pikpak username. Properties: - Config: user - Env Var: RCLONE_PIKPAK_USER - Type: string - Required: true #### --pikpak-pass Pikpak password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: pass - Env Var: RCLONE_PIKPAK_PASS - Type: string - Required: true ### Advanced options Here are the Advanced options specific to pikpak (PikPak). #### --pikpak-device-id Device ID used for authorization. Properties: - Config: device_id - Env Var: RCLONE_PIKPAK_DEVICE_ID - Type: string - Required: false #### --pikpak-user-agent HTTP user agent for pikpak. Defaults to "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:129.0) Gecko/20100101 Firefox/129.0" or "--pikpak-user-agent" provided on command line. Properties: - Config: user_agent - Env Var: RCLONE_PIKPAK_USER_AGENT - Type: string - Default: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:129.0) Gecko/20100101 Firefox/129.0" #### --pikpak-root-folder-id ID of the root folder. Leave blank normally. Fill in for rclone to use a non root folder as its starting point. Properties: - Config: root_folder_id - Env Var: RCLONE_PIKPAK_ROOT_FOLDER_ID - Type: string - Required: false #### --pikpak-use-trash Send files to the trash instead of deleting permanently. Defaults to true, namely sending files to the trash. Use `--pikpak-use-trash=false` to delete files permanently instead. Properties: - Config: use_trash - Env Var: RCLONE_PIKPAK_USE_TRASH - Type: bool - Default: true #### --pikpak-trashed-only Only show files that are in the trash. This will show trashed files in their original directory structure. Properties: - Config: trashed_only - Env Var: RCLONE_PIKPAK_TRASHED_ONLY - Type: bool - Default: false #### --pikpak-no-media-link Use original file links instead of media links. This avoids issues caused by invalid media links, but may reduce download speeds. Properties: - Config: no_media_link - Env Var: RCLONE_PIKPAK_NO_MEDIA_LINK - Type: bool - Default: false #### --pikpak-hash-memory-limit Files bigger than this will be cached on disk to calculate hash if required. Properties: - Config: hash_memory_limit - Env Var: RCLONE_PIKPAK_HASH_MEMORY_LIMIT - Type: SizeSuffix - Default: 10Mi #### --pikpak-upload-cutoff Cutoff for switching to chunked upload. Any files larger than this will be uploaded in chunks of chunk_size. The minimum is 0 and the maximum is 5 GiB. Properties: - Config: upload_cutoff - Env Var: RCLONE_PIKPAK_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 200Mi #### --pikpak-chunk-size Chunk size for multipart uploads. Large files will be uploaded in chunks of this size. Note that this is stored in memory and there may be up to "--transfers" * "--pikpak-upload-concurrency" chunks stored at once in memory. If you are transferring large files over high-speed links and you have enough memory, then increasing this will speed up the transfers. Rclone will automatically increase the chunk size when uploading a large file of known size to stay below the 10,000 chunks limit. Increasing the chunk size decreases the accuracy of the progress statistics displayed with "-P" flag. Properties: - Config: chunk_size - Env Var: RCLONE_PIKPAK_CHUNK_SIZE - Type: SizeSuffix - Default: 5Mi #### --pikpak-upload-concurrency Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently for multipart uploads. Note that chunks are stored in memory and there may be up to "--transfers" * "--pikpak-upload-concurrency" chunks stored at once in memory. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. Properties: - Config: upload_concurrency - Env Var: RCLONE_PIKPAK_UPLOAD_CONCURRENCY - Type: int - Default: 4 #### --pikpak-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_PIKPAK_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,LeftSpace,RightSpace,RightPeriod,InvalidUtf8,Dot #### --pikpak-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PIKPAK_DESCRIPTION - Type: string - Required: false ## Backend commands Here are the commands specific to the pikpak backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the [backend](https://rclone.org/commands/rclone_backend/) command for more info on how to pass options and arguments. These can be run on a running backend using the rc command [backend/command](https://rclone.org/rc/#backend-command). ### addurl Add offline download task for url rclone backend addurl remote: [options] [+] This command adds offline download task for url. Usage: rclone backend addurl pikpak:dirpath url Downloads will be stored in 'dirpath'. If 'dirpath' is invalid, download will fallback to default 'My Pack' folder. ### decompress Request decompress of a file/files in a folder rclone backend decompress remote: [options] [+] This command requests decompress of file/files in a folder. Usage: rclone backend decompress pikpak:dirpath {filename} -o password=password rclone backend decompress pikpak:dirpath {filename} -o delete-src-file An optional argument 'filename' can be specified for a file located in 'pikpak:dirpath'. You may want to pass '-o password=password' for a password-protected files. Also, pass '-o delete-src-file' to delete source files after decompression finished. Result: { "Decompressed": 17, "SourceDeleted": 0, "Errors": 0 } ## Limitations ### Hashes may be empty PikPak supports MD5 hash, but sometimes given empty especially for user-uploaded files. ### Deleted files still visible with trashed-only Deleted files will still be visible with `--pikpak-trashed-only` even after the trash emptied. This goes away after few days. # Pixeldrain This is the backend for Pixeldrain's premium filesystem feature. This is not the same as pixeldrain's free file sharing product. The filesystem requires either a Pro subscription or the Prepaid plan. [More information on subscriptions](https://pixeldrain.com/#pro). An overview of the filesystem's features and limitations is available in the [filesystem guide](https://pixeldrain.com/filesystem) on pixeldrain. ### Usage with account To use the personal filesystem you will need a [pixeldrain account](https://pixeldrain.com/register) and either the Prepaid plan or one of the Patreon-based subscriptions. After registering and subscribing, your personal filesystem will be available at this link: https://pixeldrain.com/d/me. Go to the [API keys page](https://pixeldrain.com/user/api_keys) on your account and generate a new API key for rclone. Then run `rclone config` and use the API key to create a new backend. Example: ``` No remotes found, make a new one? n) New remote d) Delete remote c) Copy remote s) Set configuration password q) Quit config n/d/c/s/q> n Enter name for new remote. name> pixeldrainfs Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. ... XX / Pixeldrain Filesystem \ (pixeldrain) ... Storage> pixeldrain Option api_key. API key for your pixeldrain account. Found on https://pixeldrain.com/user/api_keys. Enter a value. Press Enter to leave empty. api_key> b1bb1e81-9b7b-406b-986a-c9b20be76e15 Option directory_id. Root of the filesystem to use. Set to 'me' to use your personal filesystem. Set to a shared directory ID to use a shared directory. Enter a string value. Press Enter for the default (me). directory_id> Edit advanced config? y) Yes n) No (default) y/n> Configuration complete. Options: - type: pixeldrain - api_key: b1bb1e81-9b7b-406b-986a-c9b20be76e15 Keep this "pixeldrainfs" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> Current remotes: Name Type ==== ==== pixeldrainfs pixeldrain e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q ``` ### Usage without account It is possible to gain read-only access to publicly shared directories through rclone. For this you only need a directory ID. The directory ID can be found in the URL of a shared directory, the URL will look like this `https://pixeldrain.com/d/abcd1234` where `abcd1234` is the directory ID. Directory IDs in your own filesystem can also be listed with the `lsf` command: `rclone lsf Pixeldrain: --dirs-only -Fpi` This will print directories in your `Pixeldrain` home directory and their public IDs. Enter this directory ID in the rclone config and you will be able to access the directory. ### Standard options Here are the Standard options specific to pixeldrain (Pixeldrain Filesystem). #### --pixeldrain-api-key API key for your pixeldrain account. Found on https://pixeldrain.com/user/api_keys. Properties: - Config: api_key - Env Var: RCLONE_PIXELDRAIN_API_KEY - Type: string - Required: false #### --pixeldrain-root-folder-id Root of the filesystem to use. Set to 'me' to use your personal filesystem. Set to a shared directory ID to use a shared directory. Properties: - Config: root_folder_id - Env Var: RCLONE_PIXELDRAIN_ROOT_FOLDER_ID - Type: string - Default: "me" ### Advanced options Here are the Advanced options specific to pixeldrain (Pixeldrain Filesystem). #### --pixeldrain-api-url The API endpoint to connect to. In the vast majority of cases it's fine to leave this at default. It is only intended to be changed for testing purposes. Properties: - Config: api_url - Env Var: RCLONE_PIXELDRAIN_API_URL - Type: string - Default: "https://pixeldrain.com/api" #### --pixeldrain-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PIXELDRAIN_DESCRIPTION - Type: string - Required: false ### Metadata Pixeldrain supports file modes and creation times. Here are the possible system metadata items for the pixeldrain backend. | Name | Help | Type | Example | Read Only | |------|------|------|---------|-----------| | btime | Time of file birth (creation) | RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | N | | mode | File mode | octal, unix style | 755 | N | | mtime | Time of last modification | RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | N | See the [metadata](https://rclone.org/docs/#metadata) docs for more info. # premiumize.me Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configuration The initial setup for [premiumize.me](https://premiumize.me/) involves getting a token from premiumize.me which you need to do in your browser. `rclone config` walks you through it. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / premiumize.me \ "premiumizeme" [snip] Storage> premiumizeme ** See help for premiumizeme backend at: https://rclone.org/premiumizeme/ ** Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: premiumizeme - token: {"access_token":"XXX","token_type":"Bearer","refresh_token":"XXX","expiry":"2029-08-07T18:44:15.548915378+01:00"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> ``` See the [remote setup docs](https://rclone.org/remote_setup/) for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from premiumize.me. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on `http://127.0.0.1:53682/` and this it may require you to unblock it temporarily if you are running a host firewall. Once configured you can then use `rclone` like this, List directories in top level of your premiumize.me rclone lsd remote: List all the files in your premiumize.me rclone ls remote: To copy a local directory to an premiumize.me directory called backup rclone copy /home/source remote:backup ### Modification times and hashes premiumize.me does not support modification times or hashes, therefore syncing will default to `--size-only` checking. Note that using `--update` will work. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | \ | 0x5C | ＼ | | " | 0x22 | ＂ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Standard options Here are the Standard options specific to premiumizeme (premiumize.me). #### --premiumizeme-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_PREMIUMIZEME_CLIENT_ID - Type: string - Required: false #### --premiumizeme-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_PREMIUMIZEME_CLIENT_SECRET - Type: string - Required: false #### --premiumizeme-api-key API Key. This is not normally used - use oauth instead. Properties: - Config: api_key - Env Var: RCLONE_PREMIUMIZEME_API_KEY - Type: string - Required: false ### Advanced options Here are the Advanced options specific to premiumizeme (premiumize.me). #### --premiumizeme-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_PREMIUMIZEME_TOKEN - Type: string - Required: false #### --premiumizeme-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_PREMIUMIZEME_AUTH_URL - Type: string - Required: false #### --premiumizeme-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_PREMIUMIZEME_TOKEN_URL - Type: string - Required: false #### --premiumizeme-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_PREMIUMIZEME_CLIENT_CREDENTIALS - Type: bool - Default: false #### --premiumizeme-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_PREMIUMIZEME_ENCODING - Type: Encoding - Default: Slash,DoubleQuote,BackSlash,Del,Ctl,InvalidUtf8,Dot #### --premiumizeme-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PREMIUMIZEME_DESCRIPTION - Type: string - Required: false ## Limitations Note that premiumize.me is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". premiumize.me file names can't have the `\` or `"` characters in. rclone maps these to and from an identical looking unicode equivalents `＼` and `＂` premiumize.me only supports filenames up to 255 characters in length. # Proton Drive [Proton Drive](https://proton.me/drive) is an end-to-end encrypted Swiss vault for your files that protects your data. This is an rclone backend for Proton Drive which supports the file transfer features of Proton Drive using the same client-side encryption. Due to the fact that Proton Drive doesn't publish its API documentation, this backend is implemented with best efforts by reading the open-sourced client source code and observing the Proton Drive traffic in the browser. **NB** This backend is currently in Beta. It is believed to be correct and all the integration tests pass. However the Proton Drive protocol has evolved over time there may be accounts it is not compatible with. Please [post on the rclone forum](https://forum.rclone.org/) if you find an incompatibility. Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configurations Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Proton Drive \ "protondrive" [snip] Storage> protondrive User name user> you@protonmail.com Password. y) Yes type in my own password g) Generate random password n) No leave this optional password blank y/g/n> y Enter the password: password: Confirm the password: password: Option 2fa. 2FA code (if the account requires one) Enter a value. Press Enter to leave empty. 2fa> 123456 Remote config Configuration complete. Options: - type: protondrive - user: you@protonmail.com - pass: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` **NOTE:** The Proton Drive encryption keys need to have been already generated after a regular login via the browser, otherwise attempting to use the credentials in `rclone` will fail. Once configured you can then use `rclone` like this, List directories in top level of your Proton Drive rclone lsd remote: List all the files in your Proton Drive rclone ls remote: To copy a local directory to an Proton Drive directory called backup rclone copy /home/source remote:backup ### Modification times and hashes Proton Drive Bridge does not support updating modification times yet. The SHA1 hash algorithm is supported. ### Restricted filename characters Invalid UTF-8 bytes will be [replaced](https://rclone.org/overview/#invalid-utf8), also left and right spaces will be removed ([code reference](https://github.com/ProtonMail/WebClients/blob/b4eba99d241af4fdae06ff7138bd651a40ef5d3c/applications/drive/src/app/store/_links/validation.ts#L51)) ### Duplicated files Proton Drive can not have two files with exactly the same name and path. If the conflict occurs, depending on the advanced config, the file might or might not be overwritten. ### [Mailbox password](https://proton.me/support/the-difference-between-the-mailbox-password-and-login-password) Please set your mailbox password in the advanced config section. ### Caching The cache is currently built for the case when the rclone is the only instance performing operations to the mount point. The event system, which is the proton API system that provides visibility of what has changed on the drive, is yet to be implemented, so updates from other clients won’t be reflected in the cache. Thus, if there are concurrent clients accessing the same mount point, then we might have a problem with caching the stale data. ### Standard options Here are the Standard options specific to protondrive (Proton Drive). #### --protondrive-username The username of your proton account Properties: - Config: username - Env Var: RCLONE_PROTONDRIVE_USERNAME - Type: string - Required: true #### --protondrive-password The password of your proton account. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: password - Env Var: RCLONE_PROTONDRIVE_PASSWORD - Type: string - Required: true #### --protondrive-2fa The 2FA code The value can also be provided with --protondrive-2fa=000000 The 2FA code of your proton drive account if the account is set up with two-factor authentication Properties: - Config: 2fa - Env Var: RCLONE_PROTONDRIVE_2FA - Type: string - Required: false ### Advanced options Here are the Advanced options specific to protondrive (Proton Drive). #### --protondrive-mailbox-password The mailbox password of your two-password proton account. For more information regarding the mailbox password, please check the following official knowledge base article: https://proton.me/support/the-difference-between-the-mailbox-password-and-login-password **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: mailbox_password - Env Var: RCLONE_PROTONDRIVE_MAILBOX_PASSWORD - Type: string - Required: false #### --protondrive-client-uid Client uid key (internal use only) Properties: - Config: client_uid - Env Var: RCLONE_PROTONDRIVE_CLIENT_UID - Type: string - Required: false #### --protondrive-client-access-token Client access token key (internal use only) Properties: - Config: client_access_token - Env Var: RCLONE_PROTONDRIVE_CLIENT_ACCESS_TOKEN - Type: string - Required: false #### --protondrive-client-refresh-token Client refresh token key (internal use only) Properties: - Config: client_refresh_token - Env Var: RCLONE_PROTONDRIVE_CLIENT_REFRESH_TOKEN - Type: string - Required: false #### --protondrive-client-salted-key-pass Client salted key pass key (internal use only) Properties: - Config: client_salted_key_pass - Env Var: RCLONE_PROTONDRIVE_CLIENT_SALTED_KEY_PASS - Type: string - Required: false #### --protondrive-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_PROTONDRIVE_ENCODING - Type: Encoding - Default: Slash,LeftSpace,RightSpace,InvalidUtf8,Dot #### --protondrive-original-file-size Return the file size before encryption The size of the encrypted file will be different from (bigger than) the original file size. Unless there is a reason to return the file size after encryption is performed, otherwise, set this option to true, as features like Open() which will need to be supplied with original content size, will fail to operate properly Properties: - Config: original_file_size - Env Var: RCLONE_PROTONDRIVE_ORIGINAL_FILE_SIZE - Type: bool - Default: true #### --protondrive-app-version The app version string The app version string indicates the client that is currently performing the API request. This information is required and will be sent with every API request. Properties: - Config: app_version - Env Var: RCLONE_PROTONDRIVE_APP_VERSION - Type: string - Default: "macos-drive@1.0.0-alpha.1+rclone" #### --protondrive-replace-existing-draft Create a new revision when filename conflict is detected When a file upload is cancelled or failed before completion, a draft will be created and the subsequent upload of the same file to the same location will be reported as a conflict. The value can also be set by --protondrive-replace-existing-draft=true If the option is set to true, the draft will be replaced and then the upload operation will restart. If there are other clients also uploading at the same file location at the same time, the behavior is currently unknown. Need to set to true for integration tests. If the option is set to false, an error "a draft exist - usually this means a file is being uploaded at another client, or, there was a failed upload attempt" will be returned, and no upload will happen. Properties: - Config: replace_existing_draft - Env Var: RCLONE_PROTONDRIVE_REPLACE_EXISTING_DRAFT - Type: bool - Default: false #### --protondrive-enable-caching Caches the files and folders metadata to reduce API calls Notice: If you are mounting ProtonDrive as a VFS, please disable this feature, as the current implementation doesn't update or clear the cache when there are external changes. The files and folders on ProtonDrive are represented as links with keyrings, which can be cached to improve performance and be friendly to the API server. The cache is currently built for the case when the rclone is the only instance performing operations to the mount point. The event system, which is the proton API system that provides visibility of what has changed on the drive, is yet to be implemented, so updates from other clients won’t be reflected in the cache. Thus, if there are concurrent clients accessing the same mount point, then we might have a problem with caching the stale data. Properties: - Config: enable_caching - Env Var: RCLONE_PROTONDRIVE_ENABLE_CACHING - Type: bool - Default: true #### --protondrive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PROTONDRIVE_DESCRIPTION - Type: string - Required: false ## Limitations This backend uses the [Proton-API-Bridge](https://github.com/henrybear327/Proton-API-Bridge), which is based on [go-proton-api](https://github.com/henrybear327/go-proton-api), a fork of the [official repo](https://github.com/ProtonMail/go-proton-api). There is no official API documentation available from Proton Drive. But, thanks to Proton open sourcing [proton-go-api](https://github.com/ProtonMail/go-proton-api) and the web, iOS, and Android client codebases, we don't need to completely reverse engineer the APIs by observing the web client traffic! [proton-go-api](https://github.com/ProtonMail/go-proton-api) provides the basic building blocks of API calls and error handling, such as 429 exponential back-off, but it is pretty much just a barebone interface to the Proton API. For example, the encryption and decryption of the Proton Drive file are not provided in this library. The Proton-API-Bridge, attempts to bridge the gap, so rclone can be built on top of this quickly. This codebase handles the intricate tasks before and after calling Proton APIs, particularly the complex encryption scheme, allowing developers to implement features for other software on top of this codebase. There are likely quite a few errors in this library, as there isn't official documentation available. # put.io Paths are specified as `remote:path` put.io paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configuration The initial setup for put.io involves getting a token from put.io which you need to do in your browser. `rclone config` walks you through it. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> putio Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Put.io \ "putio" [snip] Storage> putio ** See help for putio backend at: https://rclone.org/putio/ ** Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code -------------------- [putio] type = putio token = {"access_token":"XXXXXXXX","expiry":"0001-01-01T00:00:00Z"} -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== putio putio e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q ``` See the [remote setup docs](https://rclone.org/remote_setup/) for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from put.io if using web browser to automatically authenticate. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on `http://127.0.0.1:53682/` and this it may require you to unblock it temporarily if you are running a host firewall, or use manual mode. You can then use it like this, List directories in top level of your put.io rclone lsd remote: List all the files in your put.io rclone ls remote: To copy a local directory to a put.io directory called backup rclone copy /home/source remote:backup ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | \ | 0x5C | ＼ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Standard options Here are the Standard options specific to putio (Put.io). #### --putio-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_PUTIO_CLIENT_ID - Type: string - Required: false #### --putio-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_PUTIO_CLIENT_SECRET - Type: string - Required: false ### Advanced options Here are the Advanced options specific to putio (Put.io). #### --putio-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_PUTIO_TOKEN - Type: string - Required: false #### --putio-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_PUTIO_AUTH_URL - Type: string - Required: false #### --putio-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_PUTIO_TOKEN_URL - Type: string - Required: false #### --putio-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_PUTIO_CLIENT_CREDENTIALS - Type: bool - Default: false #### --putio-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_PUTIO_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot #### --putio-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PUTIO_DESCRIPTION - Type: string - Required: false ## Limitations put.io has rate limiting. When you hit a limit, rclone automatically retries after waiting the amount of time requested by the server. If you want to avoid ever hitting these limits, you may use the `--tpslimit` flag with a low number. Note that the imposed limits may be different for different operations, and may change over time. # Proton Drive [Proton Drive](https://proton.me/drive) is an end-to-end encrypted Swiss vault for your files that protects your data. This is an rclone backend for Proton Drive which supports the file transfer features of Proton Drive using the same client-side encryption. Due to the fact that Proton Drive doesn't publish its API documentation, this backend is implemented with best efforts by reading the open-sourced client source code and observing the Proton Drive traffic in the browser. **NB** This backend is currently in Beta. It is believed to be correct and all the integration tests pass. However the Proton Drive protocol has evolved over time there may be accounts it is not compatible with. Please [post on the rclone forum](https://forum.rclone.org/) if you find an incompatibility. Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configurations Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Proton Drive \ "protondrive" [snip] Storage> protondrive User name user> you@protonmail.com Password. y) Yes type in my own password g) Generate random password n) No leave this optional password blank y/g/n> y Enter the password: password: Confirm the password: password: Option 2fa. 2FA code (if the account requires one) Enter a value. Press Enter to leave empty. 2fa> 123456 Remote config Configuration complete. Options: - type: protondrive - user: you@protonmail.com - pass: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` **NOTE:** The Proton Drive encryption keys need to have been already generated after a regular login via the browser, otherwise attempting to use the credentials in `rclone` will fail. Once configured you can then use `rclone` like this, List directories in top level of your Proton Drive rclone lsd remote: List all the files in your Proton Drive rclone ls remote: To copy a local directory to an Proton Drive directory called backup rclone copy /home/source remote:backup ### Modification times and hashes Proton Drive Bridge does not support updating modification times yet. The SHA1 hash algorithm is supported. ### Restricted filename characters Invalid UTF-8 bytes will be [replaced](https://rclone.org/overview/#invalid-utf8), also left and right spaces will be removed ([code reference](https://github.com/ProtonMail/WebClients/blob/b4eba99d241af4fdae06ff7138bd651a40ef5d3c/applications/drive/src/app/store/_links/validation.ts#L51)) ### Duplicated files Proton Drive can not have two files with exactly the same name and path. If the conflict occurs, depending on the advanced config, the file might or might not be overwritten. ### [Mailbox password](https://proton.me/support/the-difference-between-the-mailbox-password-and-login-password) Please set your mailbox password in the advanced config section. ### Caching The cache is currently built for the case when the rclone is the only instance performing operations to the mount point. The event system, which is the proton API system that provides visibility of what has changed on the drive, is yet to be implemented, so updates from other clients won’t be reflected in the cache. Thus, if there are concurrent clients accessing the same mount point, then we might have a problem with caching the stale data. ### Standard options Here are the Standard options specific to protondrive (Proton Drive). #### --protondrive-username The username of your proton account Properties: - Config: username - Env Var: RCLONE_PROTONDRIVE_USERNAME - Type: string - Required: true #### --protondrive-password The password of your proton account. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: password - Env Var: RCLONE_PROTONDRIVE_PASSWORD - Type: string - Required: true #### --protondrive-2fa The 2FA code The value can also be provided with --protondrive-2fa=000000 The 2FA code of your proton drive account if the account is set up with two-factor authentication Properties: - Config: 2fa - Env Var: RCLONE_PROTONDRIVE_2FA - Type: string - Required: false ### Advanced options Here are the Advanced options specific to protondrive (Proton Drive). #### --protondrive-mailbox-password The mailbox password of your two-password proton account. For more information regarding the mailbox password, please check the following official knowledge base article: https://proton.me/support/the-difference-between-the-mailbox-password-and-login-password **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: mailbox_password - Env Var: RCLONE_PROTONDRIVE_MAILBOX_PASSWORD - Type: string - Required: false #### --protondrive-client-uid Client uid key (internal use only) Properties: - Config: client_uid - Env Var: RCLONE_PROTONDRIVE_CLIENT_UID - Type: string - Required: false #### --protondrive-client-access-token Client access token key (internal use only) Properties: - Config: client_access_token - Env Var: RCLONE_PROTONDRIVE_CLIENT_ACCESS_TOKEN - Type: string - Required: false #### --protondrive-client-refresh-token Client refresh token key (internal use only) Properties: - Config: client_refresh_token - Env Var: RCLONE_PROTONDRIVE_CLIENT_REFRESH_TOKEN - Type: string - Required: false #### --protondrive-client-salted-key-pass Client salted key pass key (internal use only) Properties: - Config: client_salted_key_pass - Env Var: RCLONE_PROTONDRIVE_CLIENT_SALTED_KEY_PASS - Type: string - Required: false #### --protondrive-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_PROTONDRIVE_ENCODING - Type: Encoding - Default: Slash,LeftSpace,RightSpace,InvalidUtf8,Dot #### --protondrive-original-file-size Return the file size before encryption The size of the encrypted file will be different from (bigger than) the original file size. Unless there is a reason to return the file size after encryption is performed, otherwise, set this option to true, as features like Open() which will need to be supplied with original content size, will fail to operate properly Properties: - Config: original_file_size - Env Var: RCLONE_PROTONDRIVE_ORIGINAL_FILE_SIZE - Type: bool - Default: true #### --protondrive-app-version The app version string The app version string indicates the client that is currently performing the API request. This information is required and will be sent with every API request. Properties: - Config: app_version - Env Var: RCLONE_PROTONDRIVE_APP_VERSION - Type: string - Default: "macos-drive@1.0.0-alpha.1+rclone" #### --protondrive-replace-existing-draft Create a new revision when filename conflict is detected When a file upload is cancelled or failed before completion, a draft will be created and the subsequent upload of the same file to the same location will be reported as a conflict. The value can also be set by --protondrive-replace-existing-draft=true If the option is set to true, the draft will be replaced and then the upload operation will restart. If there are other clients also uploading at the same file location at the same time, the behavior is currently unknown. Need to set to true for integration tests. If the option is set to false, an error "a draft exist - usually this means a file is being uploaded at another client, or, there was a failed upload attempt" will be returned, and no upload will happen. Properties: - Config: replace_existing_draft - Env Var: RCLONE_PROTONDRIVE_REPLACE_EXISTING_DRAFT - Type: bool - Default: false #### --protondrive-enable-caching Caches the files and folders metadata to reduce API calls Notice: If you are mounting ProtonDrive as a VFS, please disable this feature, as the current implementation doesn't update or clear the cache when there are external changes. The files and folders on ProtonDrive are represented as links with keyrings, which can be cached to improve performance and be friendly to the API server. The cache is currently built for the case when the rclone is the only instance performing operations to the mount point. The event system, which is the proton API system that provides visibility of what has changed on the drive, is yet to be implemented, so updates from other clients won’t be reflected in the cache. Thus, if there are concurrent clients accessing the same mount point, then we might have a problem with caching the stale data. Properties: - Config: enable_caching - Env Var: RCLONE_PROTONDRIVE_ENABLE_CACHING - Type: bool - Default: true #### --protondrive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PROTONDRIVE_DESCRIPTION - Type: string - Required: false ## Limitations This backend uses the [Proton-API-Bridge](https://github.com/henrybear327/Proton-API-Bridge), which is based on [go-proton-api](https://github.com/henrybear327/go-proton-api), a fork of the [official repo](https://github.com/ProtonMail/go-proton-api). There is no official API documentation available from Proton Drive. But, thanks to Proton open sourcing [proton-go-api](https://github.com/ProtonMail/go-proton-api) and the web, iOS, and Android client codebases, we don't need to completely reverse engineer the APIs by observing the web client traffic! [proton-go-api](https://github.com/ProtonMail/go-proton-api) provides the basic building blocks of API calls and error handling, such as 429 exponential back-off, but it is pretty much just a barebone interface to the Proton API. For example, the encryption and decryption of the Proton Drive file are not provided in this library. The Proton-API-Bridge, attempts to bridge the gap, so rclone can be built on top of this quickly. This codebase handles the intricate tasks before and after calling Proton APIs, particularly the complex encryption scheme, allowing developers to implement features for other software on top of this codebase. There are likely quite a few errors in this library, as there isn't official documentation available. # Seafile This is a backend for the [Seafile](https://www.seafile.com/) storage service: - It works with both the free community edition or the professional edition. - Seafile versions 6.x, 7.x, 8.x and 9.x are all supported. - Encrypted libraries are also supported. - It supports 2FA enabled users - Using a Library API Token is **not** supported ## Configuration There are two distinct modes you can setup your remote: - you point your remote to the **root of the server**, meaning you don't specify a library during the configuration: Paths are specified as `remote:library`. You may put subdirectories in too, e.g. `remote:library/path/to/dir`. - you point your remote to a specific library during the configuration: Paths are specified as `remote:path/to/dir`. **This is the recommended mode when using encrypted libraries**. (_This mode is possibly slightly faster than the root mode_) ### Configuration in root mode Here is an example of making a seafile configuration for a user with **no** two-factor authentication. First run rclone config This will guide you through an interactive setup process. To authenticate you will need the URL of your server, your email (or username) and your password. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> seafile Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Seafile \ "seafile" [snip] Storage> seafile ** See help for seafile backend at: https://rclone.org/seafile/ ** URL of seafile host to connect to Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Connect to cloud.seafile.com \ "https://cloud.seafile.com/" url> http://my.seafile.server/ User name (usually email address) Enter a string value. Press Enter for the default (""). user> me@example.com Password y) Yes type in my own password g) Generate random password n) No leave this optional password blank (default) y/g> y Enter the password: password: Confirm the password: password: Two-factor authentication ('true' if the account has 2FA enabled) Enter a boolean value (true or false). Press Enter for the default ("false"). 2fa> false Name of the library. Leave blank to access all non-encrypted libraries. Enter a string value. Press Enter for the default (""). library> Library password (for encrypted libraries only). Leave blank if you pass it through the command line. y) Yes type in my own password g) Generate random password n) No leave this optional password blank (default) y/g/n> n Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config Two-factor authentication is not enabled on this account. -------------------- [seafile] type = seafile url = http://my.seafile.server/ user = me@example.com pass = *** ENCRYPTED *** 2fa = false -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` This remote is called `seafile`. It's pointing to the root of your seafile server and can now be used like this: See all libraries rclone lsd seafile: Create a new library rclone mkdir seafile:library List the contents of a library rclone ls seafile:library Sync `/home/local/directory` to the remote library, deleting any excess files in the library. rclone sync --interactive /home/local/directory seafile:library ### Configuration in library mode Here's an example of a configuration in library mode with a user that has the two-factor authentication enabled. Your 2FA code will be asked at the end of the configuration, and will attempt to authenticate you: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> seafile Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Seafile \ "seafile" [snip] Storage> seafile ** See help for seafile backend at: https://rclone.org/seafile/ ** URL of seafile host to connect to Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Connect to cloud.seafile.com \ "https://cloud.seafile.com/" url> http://my.seafile.server/ User name (usually email address) Enter a string value. Press Enter for the default (""). user> me@example.com Password y) Yes type in my own password g) Generate random password n) No leave this optional password blank (default) y/g> y Enter the password: password: Confirm the password: password: Two-factor authentication ('true' if the account has 2FA enabled) Enter a boolean value (true or false). Press Enter for the default ("false"). 2fa> true Name of the library. Leave blank to access all non-encrypted libraries. Enter a string value. Press Enter for the default (""). library> My Library Library password (for encrypted libraries only). Leave blank if you pass it through the command line. y) Yes type in my own password g) Generate random password n) No leave this optional password blank (default) y/g/n> n Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config Two-factor authentication: please enter your 2FA code 2fa code> 123456 Authenticating... Success! -------------------- [seafile] type = seafile url = http://my.seafile.server/ user = me@example.com pass = 2fa = true library = My Library -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` You'll notice your password is blank in the configuration. It's because we only need the password to authenticate you once. You specified `My Library` during the configuration. The root of the remote is pointing at the root of the library `My Library`: See all files in the library: rclone lsd seafile: Create a new directory inside the library rclone mkdir seafile:directory List the contents of a directory rclone ls seafile:directory Sync `/home/local/directory` to the remote library, deleting any excess files in the library. rclone sync --interactive /home/local/directory seafile: ### --fast-list Seafile version 7+ supports `--fast-list` which allows you to use fewer transactions in exchange for more memory. See the [rclone docs](https://rclone.org/docs/#fast-list) for more details. Please note this is not supported on seafile server version 6.x ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | / | 0x2F | ／ | | " | 0x22 | ＂ | | \ | 0x5C | ＼ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Seafile and rclone link Rclone supports generating share links for non-encrypted libraries only. They can either be for a file or a directory: ``` rclone link seafile:seafile-tutorial.doc http://my.seafile.server/f/fdcd8a2f93f84b8b90f4/ ``` or if run on a directory you will get: ``` rclone link seafile:dir http://my.seafile.server/d/9ea2455f6f55478bbb0d/ ``` Please note a share link is unique for each file or directory. If you run a link command on a file/dir that has already been shared, you will get the exact same link. ### Compatibility It has been actively developed using the [seafile docker image](https://github.com/haiwen/seafile-docker) of these versions: - 6.3.4 community edition - 7.0.5 community edition - 7.1.3 community edition - 9.0.10 community edition Versions below 6.0 are not supported. Versions between 6.0 and 6.3 haven't been tested and might not work properly. Each new version of `rclone` is automatically tested against the [latest docker image](https://hub.docker.com/r/seafileltd/seafile-mc/) of the seafile community server. ### Standard options Here are the Standard options specific to seafile (seafile). #### --seafile-url URL of seafile host to connect to. Properties: - Config: url - Env Var: RCLONE_SEAFILE_URL - Type: string - Required: true - Examples: - "https://cloud.seafile.com/" - Connect to cloud.seafile.com. #### --seafile-user User name (usually email address). Properties: - Config: user - Env Var: RCLONE_SEAFILE_USER - Type: string - Required: true #### --seafile-pass Password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: pass - Env Var: RCLONE_SEAFILE_PASS - Type: string - Required: false #### --seafile-2fa Two-factor authentication ('true' if the account has 2FA enabled). Properties: - Config: 2fa - Env Var: RCLONE_SEAFILE_2FA - Type: bool - Default: false #### --seafile-library Name of the library. Leave blank to access all non-encrypted libraries. Properties: - Config: library - Env Var: RCLONE_SEAFILE_LIBRARY - Type: string - Required: false #### --seafile-library-key Library password (for encrypted libraries only). Leave blank if you pass it through the command line. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: library_key - Env Var: RCLONE_SEAFILE_LIBRARY_KEY - Type: string - Required: false #### --seafile-auth-token Authentication token. Properties: - Config: auth_token - Env Var: RCLONE_SEAFILE_AUTH_TOKEN - Type: string - Required: false ### Advanced options Here are the Advanced options specific to seafile (seafile). #### --seafile-create-library Should rclone create a library if it doesn't exist. Properties: - Config: create_library - Env Var: RCLONE_SEAFILE_CREATE_LIBRARY - Type: bool - Default: false #### --seafile-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_SEAFILE_ENCODING - Type: Encoding - Default: Slash,DoubleQuote,BackSlash,Ctl,InvalidUtf8,Dot #### --seafile-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SEAFILE_DESCRIPTION - Type: string - Required: false # SFTP SFTP is the [Secure (or SSH) File Transfer Protocol](https://en.wikipedia.org/wiki/SSH_File_Transfer_Protocol). The SFTP backend can be used with a number of different providers: - Hetzner Storage Box - rsync.net SFTP runs over SSH v2 and is installed as standard with most modern SSH installations. Paths are specified as `remote:path`. If the path does not begin with a `/` it is relative to the home directory of the user. An empty path `remote:` refers to the user's home directory. For example, `rclone lsd remote:` would list the home directory of the user configured in the rclone remote config (`i.e /home/sftpuser`). However, `rclone lsd remote:/` would list the root directory for remote machine (i.e. `/`) Note that some SFTP servers will need the leading / - Synology is a good example of this. rsync.net and Hetzner, on the other hand, requires users to OMIT the leading /. Note that by default rclone will try to execute shell commands on the server, see [shell access considerations](#shell-access-considerations). ## Configuration Here is an example of making an SFTP configuration. First run rclone config This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / SSH/SFTP \ "sftp" [snip] Storage> sftp SSH host to connect to Choose a number from below, or type in your own value 1 / Connect to example.com \ "example.com" host> example.com SSH username Enter a string value. Press Enter for the default ("$USER"). user> sftpuser SSH port number Enter a signed integer. Press Enter for the default (22). port> SSH password, leave blank to use ssh-agent. y) Yes type in my own password g) Generate random password n) No leave this optional password blank y/g/n> n Path to unencrypted PEM-encoded private key file, leave blank to use ssh-agent. key_file> Remote config Configuration complete. Options: - type: sftp - host: example.com - user: sftpuser - port: - pass: - key_file: Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` This remote is called `remote` and can now be used like this: See all directories in the home directory rclone lsd remote: See all directories in the root directory rclone lsd remote:/ Make a new directory rclone mkdir remote:path/to/directory List the contents of a directory rclone ls remote:path/to/directory Sync `/home/local/directory` to the remote directory, deleting any excess files in the directory. rclone sync --interactive /home/local/directory remote:directory Mount the remote path `/srv/www-data/` to the local path `/mnt/www-data` rclone mount remote:/srv/www-data/ /mnt/www-data ### SSH Authentication The SFTP remote supports three authentication methods: * Password * Key file, including certificate signed keys * ssh-agent Key files should be PEM-encoded private key files. For instance `/home/$USER/.ssh/id_rsa`. Only unencrypted OpenSSH or PEM encrypted files are supported. The key file can be specified in either an external file (key_file) or contained within the rclone config file (key_pem). If using key_pem in the config file, the entry should be on a single line with new line ('\n' or '\r\n') separating lines. i.e. key_pem = -----BEGIN RSA PRIVATE KEY-----\nMaMbaIXtE\n0gAMbMbaSsd\nMbaass\n-----END RSA PRIVATE KEY----- This will generate it correctly for key_pem for use in the config: awk '{printf "%s\\n", $0}' < ~/.ssh/id_rsa If you don't specify `pass`, `key_file`, or `key_pem` or `ask_password` then rclone will attempt to contact an ssh-agent. You can also specify `key_use_agent` to force the usage of an ssh-agent. In this case `key_file` or `key_pem` can also be specified to force the usage of a specific key in the ssh-agent. Using an ssh-agent is the only way to load encrypted OpenSSH keys at the moment. If you set the `ask_password` option, rclone will prompt for a password when needed and no password has been configured. #### Certificate-signed keys With traditional key-based authentication, you configure your private key only, and the public key built into it will be used during the authentication process. If you have a certificate you may use it to sign your public key, creating a separate SSH user certificate that should be used instead of the plain public key extracted from the private key. Then you must provide the path to the user certificate public key file in `pubkey_file` or the content of the file in `pubkey`. Note: This is not the traditional public key paired with your private key, typically saved as `/home/$USER/.ssh/id_rsa.pub`. Setting this path in `pubkey_file` will not work. Example: ``` [remote] type = sftp host = example.com user = sftpuser key_file = ~/id_rsa pubkey_file = ~/id_rsa-cert.pub ```` If you concatenate a cert with a private key then you can specify the merged file in both places. Note: the cert must come first in the file. e.g. ``` cat id_rsa-cert.pub id_rsa > merged_key ``` ### Host key validation By default rclone will not check the server's host key for validation. This can allow an attacker to replace a server with their own and if you use password authentication then this can lead to that password being exposed. Host key matching, using standard `known_hosts` files can be turned on by enabling the `known_hosts_file` option. This can point to the file maintained by `OpenSSH` or can point to a unique file. e.g. using the OpenSSH `known_hosts` file: ``` [remote] type = sftp host = example.com user = sftpuser pass = known_hosts_file = ~/.ssh/known_hosts ```` Alternatively you can create your own known hosts file like this: ``` ssh-keyscan -t dsa,rsa,ecdsa,ed25519 example.com >> known_hosts ``` There are some limitations: * `rclone` will not _manage_ this file for you. If the key is missing or wrong then the connection will be refused. * If the server is set up for a certificate host key then the entry in the `known_hosts` file _must_ be the `@cert-authority` entry for the CA If the host key provided by the server does not match the one in the file (or is missing) then the connection will be aborted and an error returned such as NewFs: couldn't connect SSH: ssh: handshake failed: knownhosts: key mismatch or NewFs: couldn't connect SSH: ssh: handshake failed: knownhosts: key is unknown If you see an error such as NewFs: couldn't connect SSH: ssh: handshake failed: ssh: no authorities for hostname: example.com:22 then it is likely the server has presented a CA signed host certificate and you will need to add the appropriate `@cert-authority` entry. The `known_hosts_file` setting can be set during `rclone config` as an advanced option. ### ssh-agent on macOS Note that there seem to be various problems with using an ssh-agent on macOS due to recent changes in the OS. The most effective work-around seems to be to start an ssh-agent in each session, e.g. eval `ssh-agent -s` && ssh-add -A And then at the end of the session eval `ssh-agent -k` These commands can be used in scripts of course. ### Shell access Some functionality of the SFTP backend relies on remote shell access, and the possibility to execute commands. This includes [checksum](#checksum), and in some cases also [about](#about-command). The shell commands that must be executed may be different on different type of shells, and also quoting/escaping of file path arguments containing special characters may be different. Rclone therefore needs to know what type of shell it is, and if shell access is available at all. Most servers run on some version of Unix, and then a basic Unix shell can be assumed, without further distinction. Windows 10, Server 2019, and later can also run a SSH server, which is a port of OpenSSH (see official [installation guide](https://docs.microsoft.com/en-us/windows-server/administration/openssh/openssh_install_firstuse)). On a Windows server the shell handling is different: Although it can also be set up to use a Unix type shell, e.g. Cygwin bash, the default is to use Windows Command Prompt (cmd.exe), and PowerShell is a recommended alternative. All of these have behave differently, which rclone must handle. Rclone tries to auto-detect what type of shell is used on the server, first time you access the SFTP remote. If a remote shell session is successfully created, it will look for indications that it is CMD or PowerShell, with fall-back to Unix if not something else is detected. If unable to even create a remote shell session, then shell command execution will be disabled entirely. The result is stored in the SFTP remote configuration, in option `shell_type`, so that the auto-detection only have to be performed once. If you manually set a value for this option before first run, the auto-detection will be skipped, and if you set a different value later this will override any existing. Value `none` can be set to avoid any attempts at executing shell commands, e.g. if this is not allowed on the server. If you have `shell_type = none` in the configuration then the [ssh](#sftp-ssh) must not be set. When the server is [rclone serve sftp](https://rclone.org/commands/rclone_serve_sftp/), the rclone SFTP remote will detect this as a Unix type shell - even if it is running on Windows. This server does not actually have a shell, but it accepts input commands matching the specific ones that the SFTP backend relies on for Unix shells, e.g. `md5sum` and `df`. Also it handles the string escape rules used for Unix shell. Treating it as a Unix type shell from a SFTP remote will therefore always be correct, and support all features. #### Shell access considerations The shell type auto-detection logic, described above, means that by default rclone will try to run a shell command the first time a new sftp remote is accessed. If you configure a sftp remote without a config file, e.g. an [on the fly](https://rclone.org/docs/#backend-path-to-dir]) remote, rclone will have nowhere to store the result, and it will re-run the command on every access. To avoid this you should explicitly set the `shell_type` option to the correct value, or to `none` if you want to prevent rclone from executing any remote shell commands. It is also important to note that, since the shell type decides how quoting and escaping of file paths used as command-line arguments are performed, configuring the wrong shell type may leave you exposed to command injection exploits. Make sure to confirm the auto-detected shell type, or explicitly set the shell type you know is correct, or disable shell access until you know. ### Checksum SFTP does not natively support checksums (file hash), but rclone is able to use checksumming if the same login has shell access, and can execute remote commands. If there is a command that can calculate compatible checksums on the remote system, Rclone can then be configured to execute this whenever a checksum is needed, and read back the results. By default MD5 and SHA-1 are considered, but also CRC32, SHA-256, BLAKE3, XXH3 and XXH128 are supported, option `hashes` can be set to specify which to consider. Normally this requires an external utility being available on the server. E.g. for MD5 checksums, by default rclone will try commands `md5sum`, `md5` and `rclone md5sum`, and the first one found usable will be picked. These utilities normally need to be in the remote's PATH to be found. In some cases the shell itself is capable of calculating checksums. PowerShell is an example of such a shell. If rclone detects that the remote shell is PowerShell, which means it most probably is a Windows OpenSSH server, rclone will use a predefined script block to produce the checksums for MD5, SHA-1 and SHA-256 when no external checksum commands are found (see [shell access](#shell-access)). This assumes PowerShell version 4.0 or newer. The options `md5sum_command`, `sha1_command`, etc. can be used to customize the commands to be executed for calculation of checksums. You can for example set a specific path to where the md5sum executable are located, or specify some other tool that print checksums in compatible format. The value can include command-line arguments, or even shell script blocks as with PowerShell. Rclone has subcommands [hashsum](https://rclone.org/commands/rclone_hashsum/), [md5sum](https://rclone.org/commands/rclone_md5sum/) and [sha1sum](https://rclone.org/commands/rclone_sha1sum/) that use compatible format, which means if you have an rclone executable on the server it can be used. As mentioned above, they will be automatically picked up if found in PATH, but if not you can set something like `/path/to/rclone md5sum` as the value of option `md5sum_command` to make sure a specific executable is used. Remote checksumming is recommended and enabled by default. First time rclone is using a SFTP remote, if options `md5sum_command` or `sha1_command` are not set, it will check if any of the default commands for each of them, as described above, can be used. The result will be saved in the remote configuration, so next time it will use the same. Value `none` will be set if none of the default commands could be used for a specific algorithm, and this algorithm will not be supported by the remote. Disabling the checksumming completely may be required if you are connecting to SFTP servers which are not under your control, and to which the execution of remote shell commands is prohibited. Set the configuration option `disable_hashcheck` to `true` to disable checksumming entirely (you get the same effect by setting option `hashes` to `none` or options `md5sum_command`, `sha1_command` etc. to `none`). Set option `shell_type` to `none` to not only disable checksumming, but also disable all other functionality that are based on remote shell command execution. ### Modification times and hashes Modified times are stored on the server to 1 second precision. Modified times are used in syncing and are fully supported. Some SFTP servers disable setting/modifying the file modification time after upload (for example, certain configurations of ProFTPd with mod_sftp). If you are using one of these servers, you can set the option `set_modtime = false` in your RClone backend configuration to disable this behaviour. ### About command The `about` command returns the total space, free space, and used space on the remote for the disk of the specified path on the remote or, if not set, the disk of the root on the remote. SFTP usually supports the [about](https://rclone.org/commands/rclone_about/) command, but it depends on the server. If the server implements the vendor-specific VFS statistics extension, which is normally the case with OpenSSH instances, it will be used. If not, but the same login has access to a Unix shell, where the `df` command is available (e.g. in the remote's PATH), then this will be used instead. If the server shell is PowerShell, probably with a Windows OpenSSH server, rclone will use a built-in shell command (see [shell access](#shell-access)). If none of the above is applicable, `about` will fail. ### Standard options Here are the Standard options specific to sftp (SSH/SFTP). #### --sftp-host SSH host to connect to. E.g. "example.com". Properties: - Config: host - Env Var: RCLONE_SFTP_HOST - Type: string - Required: true #### --sftp-user SSH username. Properties: - Config: user - Env Var: RCLONE_SFTP_USER - Type: string - Default: "$USER" #### --sftp-port SSH port number. Properties: - Config: port - Env Var: RCLONE_SFTP_PORT - Type: int - Default: 22 #### --sftp-pass SSH password, leave blank to use ssh-agent. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: pass - Env Var: RCLONE_SFTP_PASS - Type: string - Required: false #### --sftp-key-pem Raw PEM-encoded private key. Note that this should be on a single line with line endings replaced with '\n', eg key_pem = -----BEGIN RSA PRIVATE KEY-----\nMaMbaIXtE\n0gAMbMbaSsd\nMbaass\n-----END RSA PRIVATE KEY----- This will generate the single line correctly: awk '{printf "%s\\n", $0}' < ~/.ssh/id_rsa If specified, it will override the key_file parameter. Properties: - Config: key_pem - Env Var: RCLONE_SFTP_KEY_PEM - Type: string - Required: false #### --sftp-key-file Path to PEM-encoded private key file. Leave blank or set key-use-agent to use ssh-agent. Leading `~` will be expanded in the file name as will environment variables such as `${RCLONE_CONFIG_DIR}`. Properties: - Config: key_file - Env Var: RCLONE_SFTP_KEY_FILE - Type: string - Required: false #### --sftp-key-file-pass The passphrase to decrypt the PEM-encoded private key file. Only PEM encrypted key files (old OpenSSH format) are supported. Encrypted keys in the new OpenSSH format can't be used. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: key_file_pass - Env Var: RCLONE_SFTP_KEY_FILE_PASS - Type: string - Required: false #### --sftp-pubkey SSH public certificate for public certificate based authentication. Set this if you have a signed certificate you want to use for authentication. If specified will override pubkey_file. Properties: - Config: pubkey - Env Var: RCLONE_SFTP_PUBKEY - Type: string - Required: false #### --sftp-pubkey-file Optional path to public key file. Set this if you have a signed certificate you want to use for authentication. Leading `~` will be expanded in the file name as will environment variables such as `${RCLONE_CONFIG_DIR}`. Properties: - Config: pubkey_file - Env Var: RCLONE_SFTP_PUBKEY_FILE - Type: string - Required: false #### --sftp-key-use-agent When set forces the usage of the ssh-agent. When key-file is also set, the ".pub" file of the specified key-file is read and only the associated key is requested from the ssh-agent. This allows to avoid `Too many authentication failures for *username*` errors when the ssh-agent contains many keys. Properties: - Config: key_use_agent - Env Var: RCLONE_SFTP_KEY_USE_AGENT - Type: bool - Default: false #### --sftp-use-insecure-cipher Enable the use of insecure ciphers and key exchange methods. This enables the use of the following insecure ciphers and key exchange methods: - aes128-cbc - aes192-cbc - aes256-cbc - 3des-cbc - diffie-hellman-group-exchange-sha256 - diffie-hellman-group-exchange-sha1 Those algorithms are insecure and may allow plaintext data to be recovered by an attacker. This must be false if you use either ciphers or key_exchange advanced options. Properties: - Config: use_insecure_cipher - Env Var: RCLONE_SFTP_USE_INSECURE_CIPHER - Type: bool - Default: false - Examples: - "false" - Use default Cipher list. - "true" - Enables the use of the aes128-cbc cipher and diffie-hellman-group-exchange-sha256, diffie-hellman-group-exchange-sha1 key exchange. #### --sftp-disable-hashcheck Disable the execution of SSH commands to determine if remote file hashing is available. Leave blank or set to false to enable hashing (recommended), set to true to disable hashing. Properties: - Config: disable_hashcheck - Env Var: RCLONE_SFTP_DISABLE_HASHCHECK - Type: bool - Default: false #### --sftp-ssh Path and arguments to external ssh binary. Normally rclone will use its internal ssh library to connect to the SFTP server. However it does not implement all possible ssh options so it may be desirable to use an external ssh binary. Rclone ignores all the internal config if you use this option and expects you to configure the ssh binary with the user/host/port and any other options you need. **Important** The ssh command must log in without asking for a password so needs to be configured with keys or certificates. Rclone will run the command supplied either with the additional arguments "-s sftp" to access the SFTP subsystem or with commands such as "md5sum /path/to/file" appended to read checksums. Any arguments with spaces in should be surrounded by "double quotes". An example setting might be: ssh -o ServerAliveInterval=20 user@example.com Note that when using an external ssh binary rclone makes a new ssh connection for every hash it calculates. Properties: - Config: ssh - Env Var: RCLONE_SFTP_SSH - Type: SpaceSepList - Default: ### Advanced options Here are the Advanced options specific to sftp (SSH/SFTP). #### --sftp-known-hosts-file Optional path to known_hosts file. Set this value to enable server host key validation. Leading `~` will be expanded in the file name as will environment variables such as `${RCLONE_CONFIG_DIR}`. Properties: - Config: known_hosts_file - Env Var: RCLONE_SFTP_KNOWN_HOSTS_FILE - Type: string - Required: false - Examples: - "~/.ssh/known_hosts" - Use OpenSSH's known_hosts file. #### --sftp-ask-password Allow asking for SFTP password when needed. If this is set and no password is supplied then rclone will: - ask for a password - not contact the ssh agent Properties: - Config: ask_password - Env Var: RCLONE_SFTP_ASK_PASSWORD - Type: bool - Default: false #### --sftp-path-override Override path used by SSH shell commands. This allows checksum calculation when SFTP and SSH paths are different. This issue affects among others Synology NAS boxes. E.g. if shared folders can be found in directories representing volumes: rclone sync /home/local/directory remote:/directory --sftp-path-override /volume2/directory E.g. if home directory can be found in a shared folder called "home": rclone sync /home/local/directory remote:/home/directory --sftp-path-override /volume1/homes/USER/directory To specify only the path to the SFTP remote's root, and allow rclone to add any relative subpaths automatically (including unwrapping/decrypting remotes as necessary), add the '@' character to the beginning of the path. E.g. the first example above could be rewritten as: rclone sync /home/local/directory remote:/directory --sftp-path-override @/volume2 Note that when using this method with Synology "home" folders, the full "/homes/USER" path should be specified instead of "/home". E.g. the second example above should be rewritten as: rclone sync /home/local/directory remote:/homes/USER/directory --sftp-path-override @/volume1 Properties: - Config: path_override - Env Var: RCLONE_SFTP_PATH_OVERRIDE - Type: string - Required: false #### --sftp-set-modtime Set the modified time on the remote if set. Properties: - Config: set_modtime - Env Var: RCLONE_SFTP_SET_MODTIME - Type: bool - Default: true #### --sftp-shell-type The type of SSH shell on remote server, if any. Leave blank for autodetect. Properties: - Config: shell_type - Env Var: RCLONE_SFTP_SHELL_TYPE - Type: string - Required: false - Examples: - "none" - No shell access - "unix" - Unix shell - "powershell" - PowerShell - "cmd" - Windows Command Prompt #### --sftp-hashes Comma separated list of supported checksum types. Properties: - Config: hashes - Env Var: RCLONE_SFTP_HASHES - Type: CommaSepList - Default: #### --sftp-md5sum-command The command used to read MD5 hashes. Leave blank for autodetect. Properties: - Config: md5sum_command - Env Var: RCLONE_SFTP_MD5SUM_COMMAND - Type: string - Required: false #### --sftp-sha1sum-command The command used to read SHA-1 hashes. Leave blank for autodetect. Properties: - Config: sha1sum_command - Env Var: RCLONE_SFTP_SHA1SUM_COMMAND - Type: string - Required: false #### --sftp-crc32sum-command The command used to read CRC-32 hashes. Leave blank for autodetect. Properties: - Config: crc32sum_command - Env Var: RCLONE_SFTP_CRC32SUM_COMMAND - Type: string - Required: false #### --sftp-sha256sum-command The command used to read SHA-256 hashes. Leave blank for autodetect. Properties: - Config: sha256sum_command - Env Var: RCLONE_SFTP_SHA256SUM_COMMAND - Type: string - Required: false #### --sftp-blake3sum-command The command used to read BLAKE3 hashes. Leave blank for autodetect. Properties: - Config: blake3sum_command - Env Var: RCLONE_SFTP_BLAKE3SUM_COMMAND - Type: string - Required: false #### --sftp-xxh3sum-command The command used to read XXH3 hashes. Leave blank for autodetect. Properties: - Config: xxh3sum_command - Env Var: RCLONE_SFTP_XXH3SUM_COMMAND - Type: string - Required: false #### --sftp-xxh128sum-command The command used to read XXH128 hashes. Leave blank for autodetect. Properties: - Config: xxh128sum_command - Env Var: RCLONE_SFTP_XXH128SUM_COMMAND - Type: string - Required: false #### --sftp-skip-links Set to skip any symlinks and any other non regular files. Properties: - Config: skip_links - Env Var: RCLONE_SFTP_SKIP_LINKS - Type: bool - Default: false #### --sftp-subsystem Specifies the SSH2 subsystem on the remote host. Properties: - Config: subsystem - Env Var: RCLONE_SFTP_SUBSYSTEM - Type: string - Default: "sftp" #### --sftp-server-command Specifies the path or command to run a sftp server on the remote host. The subsystem option is ignored when server_command is defined. If adding server_command to the configuration file please note that it should not be enclosed in quotes, since that will make rclone fail. A working example is: [remote_name] type = sftp server_command = sudo /usr/libexec/openssh/sftp-server Properties: - Config: server_command - Env Var: RCLONE_SFTP_SERVER_COMMAND - Type: string - Required: false #### --sftp-use-fstat If set use fstat instead of stat. Some servers limit the amount of open files and calling Stat after opening the file will throw an error from the server. Setting this flag will call Fstat instead of Stat which is called on an already open file handle. It has been found that this helps with IBM Sterling SFTP servers which have "extractability" level set to 1 which means only 1 file can be opened at any given time. Properties: - Config: use_fstat - Env Var: RCLONE_SFTP_USE_FSTAT - Type: bool - Default: false #### --sftp-disable-concurrent-reads If set don't use concurrent reads. Normally concurrent reads are safe to use and not using them will degrade performance, so this option is disabled by default. Some servers limit the amount number of times a file can be downloaded. Using concurrent reads can trigger this limit, so if you have a server which returns Failed to copy: file does not exist Then you may need to enable this flag. If concurrent reads are disabled, the use_fstat option is ignored. Properties: - Config: disable_concurrent_reads - Env Var: RCLONE_SFTP_DISABLE_CONCURRENT_READS - Type: bool - Default: false #### --sftp-disable-concurrent-writes If set don't use concurrent writes. Normally rclone uses concurrent writes to upload files. This improves the performance greatly, especially for distant servers. This option disables concurrent writes should that be necessary. Properties: - Config: disable_concurrent_writes - Env Var: RCLONE_SFTP_DISABLE_CONCURRENT_WRITES - Type: bool - Default: false #### --sftp-idle-timeout Max time before closing idle connections. If no connections have been returned to the connection pool in the time given, rclone will empty the connection pool. Set to 0 to keep connections indefinitely. Properties: - Config: idle_timeout - Env Var: RCLONE_SFTP_IDLE_TIMEOUT - Type: Duration - Default: 1m0s #### --sftp-chunk-size Upload and download chunk size. This controls the maximum size of payload in SFTP protocol packets. The RFC limits this to 32768 bytes (32k), which is the default. However, a lot of servers support larger sizes, typically limited to a maximum total package size of 256k, and setting it larger will increase transfer speed dramatically on high latency links. This includes OpenSSH, and, for example, using the value of 255k works well, leaving plenty of room for overhead while still being within a total packet size of 256k. Make sure to test thoroughly before using a value higher than 32k, and only use it if you always connect to the same server or after sufficiently broad testing. If you get errors such as "failed to send packet payload: EOF", lots of "connection lost", or "corrupted on transfer", when copying a larger file, try lowering the value. The server run by [rclone serve sftp](/commands/rclone_serve_sftp) sends packets with standard 32k maximum payload so you must not set a different chunk_size when downloading files, but it accepts packets up to the 256k total size, so for uploads the chunk_size can be set as for the OpenSSH example above. Properties: - Config: chunk_size - Env Var: RCLONE_SFTP_CHUNK_SIZE - Type: SizeSuffix - Default: 32Ki #### --sftp-concurrency The maximum number of outstanding requests for one file This controls the maximum number of outstanding requests for one file. Increasing it will increase throughput on high latency links at the cost of using more memory. Properties: - Config: concurrency - Env Var: RCLONE_SFTP_CONCURRENCY - Type: int - Default: 64 #### --sftp-connections Maximum number of SFTP simultaneous connections, 0 for unlimited. Note that setting this is very likely to cause deadlocks so it should be used with care. If you are doing a sync or copy then make sure connections is one more than the sum of `--transfers` and `--checkers`. If you use `--check-first` then it just needs to be one more than the maximum of `--checkers` and `--transfers`. So for `connections 3` you'd use `--checkers 2 --transfers 2 --check-first` or `--checkers 1 --transfers 1`. Properties: - Config: connections - Env Var: RCLONE_SFTP_CONNECTIONS - Type: int - Default: 0 #### --sftp-set-env Environment variables to pass to sftp and commands Set environment variables in the form: VAR=value to be passed to the sftp client and to any commands run (eg md5sum). Pass multiple variables space separated, eg VAR1=value VAR2=value and pass variables with spaces in quotes, eg "VAR3=value with space" "VAR4=value with space" VAR5=nospacehere Properties: - Config: set_env - Env Var: RCLONE_SFTP_SET_ENV - Type: SpaceSepList - Default: #### --sftp-ciphers Space separated list of ciphers to be used for session encryption, ordered by preference. At least one must match with server configuration. This can be checked for example using ssh -Q cipher. This must not be set if use_insecure_cipher is true. Example: aes128-ctr aes192-ctr aes256-ctr aes128-gcm@openssh.com aes256-gcm@openssh.com Properties: - Config: ciphers - Env Var: RCLONE_SFTP_CIPHERS - Type: SpaceSepList - Default: #### --sftp-key-exchange Space separated list of key exchange algorithms, ordered by preference. At least one must match with server configuration. This can be checked for example using ssh -Q kex. This must not be set if use_insecure_cipher is true. Example: sntrup761x25519-sha512@openssh.com curve25519-sha256 curve25519-sha256@libssh.org ecdh-sha2-nistp256 Properties: - Config: key_exchange - Env Var: RCLONE_SFTP_KEY_EXCHANGE - Type: SpaceSepList - Default: #### --sftp-macs Space separated list of MACs (message authentication code) algorithms, ordered by preference. At least one must match with server configuration. This can be checked for example using ssh -Q mac. Example: umac-64-etm@openssh.com umac-128-etm@openssh.com hmac-sha2-256-etm@openssh.com Properties: - Config: macs - Env Var: RCLONE_SFTP_MACS - Type: SpaceSepList - Default: #### --sftp-host-key-algorithms Space separated list of host key algorithms, ordered by preference. At least one must match with server configuration. This can be checked for example using ssh -Q HostKeyAlgorithms. Note: This can affect the outcome of key negotiation with the server even if server host key validation is not enabled. Example: ssh-ed25519 ssh-rsa ssh-dss Properties: - Config: host_key_algorithms - Env Var: RCLONE_SFTP_HOST_KEY_ALGORITHMS - Type: SpaceSepList - Default: #### --sftp-socks-proxy Socks 5 proxy host. Supports the format user:pass@host:port, user@host:port, host:port. Example: myUser:myPass@localhost:9005 Properties: - Config: socks_proxy - Env Var: RCLONE_SFTP_SOCKS_PROXY - Type: string - Required: false #### --sftp-http-proxy URL for HTTP CONNECT proxy Set this to a URL for an HTTP proxy which supports the HTTP CONNECT verb. Properties: - Config: http_proxy - Env Var: RCLONE_SFTP_HTTP_PROXY - Type: string - Required: false #### --sftp-copy-is-hardlink Set to enable server side copies using hardlinks. The SFTP protocol does not define a copy command so normally server side copies are not allowed with the sftp backend. However the SFTP protocol does support hardlinking, and if you enable this flag then the sftp backend will support server side copies. These will be implemented by doing a hardlink from the source to the destination. Not all sftp servers support this. Note that hardlinking two files together will use no additional space as the source and the destination will be the same file. This feature may be useful backups made with --copy-dest. Properties: - Config: copy_is_hardlink - Env Var: RCLONE_SFTP_COPY_IS_HARDLINK - Type: bool - Default: false #### --sftp-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SFTP_DESCRIPTION - Type: string - Required: false ## Limitations On some SFTP servers (e.g. Synology) the paths are different for SSH and SFTP so the hashes can't be calculated properly. You can either use [`--sftp-path-override`](#--sftp-path-override) or [`disable_hashcheck`](#--sftp-disable-hashcheck). The only ssh agent supported under Windows is Putty's pageant. The Go SSH library disables the use of the aes128-cbc cipher by default, due to security concerns. This can be re-enabled on a per-connection basis by setting the `use_insecure_cipher` setting in the configuration file to `true`. Further details on the insecurity of this cipher can be found [in this paper](http://www.isg.rhul.ac.uk/~kp/SandPfinal.pdf). SFTP isn't supported under plan9 until [this issue](https://github.com/pkg/sftp/issues/156) is fixed. Note that since SFTP isn't HTTP based the following flags don't work with it: `--dump-headers`, `--dump-bodies`, `--dump-auth`. Note that `--timeout` and `--contimeout` are both supported. ## rsync.net {#rsync-net} rsync.net is supported through the SFTP backend. See [rsync.net's documentation of rclone examples](https://www.rsync.net/products/rclone.html). ## Hetzner Storage Box {#hetzner-storage-box} Hetzner Storage Boxes are supported through the SFTP backend on port 23. See [Hetzner's documentation for details](https://docs.hetzner.com/robot/storage-box/access/access-ssh-rsync-borg#rclone) # SMB SMB is [a communication protocol to share files over network](https://en.wikipedia.org/wiki/Server_Message_Block). This relies on [go-smb2 library](https://github.com/CloudSoda/go-smb2/) for communication with SMB protocol. Paths are specified as `remote:sharename` (or `remote:` for the `lsd` command.) You may put subdirectories in too, e.g. `remote:item/path/to/dir`. ## Notes The first path segment must be the name of the share, which you entered when you started to share on Windows. On smbd, it's the section title in `smb.conf` (usually in `/etc/samba/`) file. You can find shares by querying the root if you're unsure (e.g. `rclone lsd remote:`). You can't access to the shared printers from rclone, obviously. You can't use Anonymous access for logging in. You have to use the `guest` user with an empty password instead. The rclone client tries to avoid 8.3 names when uploading files by encoding trailing spaces and periods. Alternatively, [the local backend](https://rclone.org/local/#paths-on-windows) on Windows can access SMB servers using UNC paths, by `\\server\share`. This doesn't apply to non-Windows OSes, such as Linux and macOS. ## Configuration Here is an example of making a SMB configuration. First run rclone config This will guide you through an interactive setup process. ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. XX / SMB / CIFS \ (smb) Storage> smb Option host. Samba hostname to connect to. E.g. "example.com". Enter a value. host> localhost Option user. Samba username. Enter a string value. Press Enter for the default (lesmi). user> guest Option port. Samba port number. Enter a signed integer. Press Enter for the default (445). port> Option pass. Samba password. Choose an alternative below. Press Enter for the default (n). y) Yes, type in my own password g) Generate random password n) No, leave this optional password blank (default) y/g/n> g Password strength in bits. 64 is just about memorable 128 is secure 1024 is the maximum Bits> 64 Your password is: XXXX Use this password? Please note that an obscured version of this password (and not the password itself) will be stored under your configuration file, so keep this generated password in a safe place. y) Yes (default) n) No y/n> y Option domain. Domain name for NTLM authentication. Enter a string value. Press Enter for the default (WORKGROUP). domain> Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: samba - host: localhost - user: guest - pass: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> d ``` ### Standard options Here are the Standard options specific to smb (SMB / CIFS). #### --smb-host SMB server hostname to connect to. E.g. "example.com". Properties: - Config: host - Env Var: RCLONE_SMB_HOST - Type: string - Required: true #### --smb-user SMB username. Properties: - Config: user - Env Var: RCLONE_SMB_USER - Type: string - Default: "$USER" #### --smb-port SMB port number. Properties: - Config: port - Env Var: RCLONE_SMB_PORT - Type: int - Default: 445 #### --smb-pass SMB password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: pass - Env Var: RCLONE_SMB_PASS - Type: string - Required: false #### --smb-domain Domain name for NTLM authentication. Properties: - Config: domain - Env Var: RCLONE_SMB_DOMAIN - Type: string - Default: "WORKGROUP" #### --smb-spn Service principal name. Rclone presents this name to the server. Some servers use this as further authentication, and it often needs to be set for clusters. For example: cifs/remotehost:1020 Leave blank if not sure. Properties: - Config: spn - Env Var: RCLONE_SMB_SPN - Type: string - Required: false #### --smb-use-kerberos Use Kerberos authentication. If set, rclone will use Kerberos authentication instead of NTLM. This requires a valid Kerberos configuration and credentials cache to be available, either in the default locations or as specified by the KRB5_CONFIG and KRB5CCNAME environment variables. Properties: - Config: use_kerberos - Env Var: RCLONE_SMB_USE_KERBEROS - Type: bool - Default: false ### Advanced options Here are the Advanced options specific to smb (SMB / CIFS). #### --smb-idle-timeout Max time before closing idle connections. If no connections have been returned to the connection pool in the time given, rclone will empty the connection pool. Set to 0 to keep connections indefinitely. Properties: - Config: idle_timeout - Env Var: RCLONE_SMB_IDLE_TIMEOUT - Type: Duration - Default: 1m0s #### --smb-hide-special-share Hide special shares (e.g. print$) which users aren't supposed to access. Properties: - Config: hide_special_share - Env Var: RCLONE_SMB_HIDE_SPECIAL_SHARE - Type: bool - Default: true #### --smb-case-insensitive Whether the server is configured to be case-insensitive. Always true on Windows shares. Properties: - Config: case_insensitive - Env Var: RCLONE_SMB_CASE_INSENSITIVE - Type: bool - Default: true #### --smb-kerberos-ccache Path to the Kerberos credential cache (krb5cc). Overrides the default KRB5CCNAME environment variable and allows this instance of the SMB backend to use a different Kerberos cache file. This is useful when mounting multiple SMB with different credentials or running in multi-user environments. Supported formats: - FILE:/path/to/ccache – Use the specified file. - DIR:/path/to/ccachedir – Use the primary file inside the specified directory. - /path/to/ccache – Interpreted as a file path. Properties: - Config: kerberos_ccache - Env Var: RCLONE_SMB_KERBEROS_CCACHE - Type: string - Required: false #### --smb-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_SMB_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot #### --smb-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SMB_DESCRIPTION - Type: string - Required: false # Storj [Storj](https://storj.io) is redefining the cloud to support the future of data—sustainably and economically. Storj leverages the vast global supply of underutilized resources to deliver better security, durability, and performance services. Experience up to 90% lower costs and carbon reduction with Storj. Storj is an encrypted, secure, and cost-effective object storage service that enables you to store, back up, and archive large amounts of data in a decentralized manner. ## Backend options Storj can be used both with this native backend and with the [s3 backend using the Storj S3 compatible gateway](https://rclone.org/s3/#storj) (shared or private). Use this backend to take advantage of client-side encryption as well as to achieve the best possible download performance. Uploads will be erasure-coded locally, thus a 1gb upload will result in 2.68gb of data being uploaded to storage nodes across the network. Use the s3 backend and one of the S3 compatible Hosted Gateways to increase upload performance and reduce the load on your systems and network. Uploads will be encrypted and erasure-coded server-side, thus a 1GB upload will result in only in 1GB of data being uploaded to storage nodes across the network. Side by side comparison with more details: * Characteristics: * *Storj backend*: Uses native RPC protocol, connects directly to the storage nodes which hosts the data. Requires more CPU resource of encoding/decoding and has network amplification (especially during the upload), uses lots of TCP connections * *S3 backend*: Uses S3 compatible HTTP Rest API via the shared gateways. There is no network amplification, but performance depends on the shared gateways and the secret encryption key is shared with the gateway. * Typical usage: * *Storj backend*: Server environments and desktops with enough resources, internet speed and connectivity - and applications where storjs client-side encryption is required. * *S3 backend*: Desktops and similar with limited resources, internet speed or connectivity. * Security: * *Storj backend*: __strong__. Private encryption key doesn't need to leave the local computer. * *S3 backend*: __weaker__. Private encryption key is [shared with](https://docs.storj.io/dcs/api-reference/s3-compatible-gateway#security-and-encryption) the authentication service of the hosted gateway, where it's stored encrypted. It can be stronger when combining with the rclone [crypt](/crypt) backend. * Bandwidth usage (upload): * *Storj backend*: __higher__. As data is erasure coded on the client side both the original data and the parities should be uploaded. About ~2.7 times more data is required to be uploaded. Client may start to upload with even higher number of nodes (~3.7 times more) and abandon/stop the slow uploads. * *S3 backend*: __normal__. Only the raw data is uploaded, erasure coding happens on the gateway. * Bandwidth usage (download) * *Storj backend*: __almost normal__. Only the minimal number of data is required, but to avoid very slow data providers a few more sources are used and the slowest are ignored (max 1.2x overhead). * *S3 backend*: __normal__. Only the raw data is downloaded, erasure coding happens on the shared gateway. * CPU usage: * *Storj backend*: __higher__, but more predictable. Erasure code and encryption/decryption happens locally which requires significant CPU usage. * *S3 backend*: __less__. Erasure code and encryption/decryption happens on shared s3 gateways (and as is, it depends on the current load on the gateways) * TCP connection usage: * *Storj backend*: __high__. A direct connection is required to each of the Storj nodes resulting in 110 connections on upload and 35 on download per 64 MB segment. Not all the connections are actively used (slow ones are pruned), but they are all opened. [Adjusting the max open file limit](https://rclone.org/storj/#known-issues) may be required. * *S3 backend*: __normal__. Only one connection per download/upload thread is required to the shared gateway. * Overall performance: * *Storj backend*: with enough resources (CPU and bandwidth) *storj* backend can provide even 2x better performance. Data is directly downloaded to / uploaded from to the client instead of the gateway. * *S3 backend*: Can be faster on edge devices where CPU and network bandwidth is limited as the shared S3 compatible gateways take care about the encrypting/decryption and erasure coding and no download/upload amplification. * Decentralization: * *Storj backend*: __high__. Data is downloaded directly from the distributed cloud of storage providers. * *S3 backend*: __low__. Requires a running S3 gateway (either self-hosted or Storj-hosted). * Limitations: * *Storj backend*: `rclone checksum` is not possible without download, as checksum metadata is not calculated during upload * *S3 backend*: secret encryption key is shared with the gateway ## Configuration To make a new Storj configuration you need one of the following: * Access Grant that someone else shared with you. * [API Key](https://documentation.storj.io/getting-started/uploading-your-first-object/create-an-api-key) of a Storj project you are a member of. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ### Setup with access grant ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Storj Decentralized Cloud Storage \ "storj" [snip] Storage> storj ** See help for storj backend at: https://rclone.org/storj/ ** Choose an authentication method. Enter a string value. Press Enter for the default ("existing"). Choose a number from below, or type in your own value 1 / Use an existing access grant. \ "existing" 2 / Create a new access grant from satellite address, API key, and passphrase. \ "new" provider> existing Access Grant. Enter a string value. Press Enter for the default (""). access_grant> your-access-grant-received-by-someone-else Remote config Configuration complete. Options: - type: storj - access_grant: your-access-grant-received-by-someone-else Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ### Setup with API key and passphrase ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Storj Decentralized Cloud Storage \ "storj" [snip] Storage> storj ** See help for storj backend at: https://rclone.org/storj/ ** Choose an authentication method. Enter a string value. Press Enter for the default ("existing"). Choose a number from below, or type in your own value 1 / Use an existing access grant. \ "existing" 2 / Create a new access grant from satellite address, API key, and passphrase. \ "new" provider> new Satellite Address. Custom satellite address should match the format: `@
:`. Enter a string value. Press Enter for the default ("us1.storj.io"). Choose a number from below, or type in your own value 1 / US1 \ "us1.storj.io" 2 / EU1 \ "eu1.storj.io" 3 / AP1 \ "ap1.storj.io" satellite_address> 1 API Key. Enter a string value. Press Enter for the default (""). api_key> your-api-key-for-your-storj-project Encryption Passphrase. To access existing objects enter passphrase used for uploading. Enter a string value. Press Enter for the default (""). passphrase> your-human-readable-encryption-passphrase Remote config Configuration complete. Options: - type: storj - satellite_address: 12EayRS2V1kEsWESU9QMRseFhdxYxKicsiFmxrsLZHeLUtdps3S@us1.storj.io:7777 - api_key: your-api-key-for-your-storj-project - passphrase: your-human-readable-encryption-passphrase - access_grant: the-access-grant-generated-from-the-api-key-and-passphrase Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` ### Standard options Here are the Standard options specific to storj (Storj Decentralized Cloud Storage). #### --storj-provider Choose an authentication method. Properties: - Config: provider - Env Var: RCLONE_STORJ_PROVIDER - Type: string - Default: "existing" - Examples: - "existing" - Use an existing access grant. - "new" - Create a new access grant from satellite address, API key, and passphrase. #### --storj-access-grant Access grant. Properties: - Config: access_grant - Env Var: RCLONE_STORJ_ACCESS_GRANT - Provider: existing - Type: string - Required: false #### --storj-satellite-address Satellite address. Custom satellite address should match the format: `@
:`. Properties: - Config: satellite_address - Env Var: RCLONE_STORJ_SATELLITE_ADDRESS - Provider: new - Type: string - Default: "us1.storj.io" - Examples: - "us1.storj.io" - US1 - "eu1.storj.io" - EU1 - "ap1.storj.io" - AP1 #### --storj-api-key API key. Properties: - Config: api_key - Env Var: RCLONE_STORJ_API_KEY - Provider: new - Type: string - Required: false #### --storj-passphrase Encryption passphrase. To access existing objects enter passphrase used for uploading. Properties: - Config: passphrase - Env Var: RCLONE_STORJ_PASSPHRASE - Provider: new - Type: string - Required: false ### Advanced options Here are the Advanced options specific to storj (Storj Decentralized Cloud Storage). #### --storj-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_STORJ_DESCRIPTION - Type: string - Required: false ## Usage Paths are specified as `remote:bucket` (or `remote:` for the `lsf` command.) You may put subdirectories in too, e.g. `remote:bucket/path/to/dir`. Once configured you can then use `rclone` like this. ### Create a new bucket Use the `mkdir` command to create new bucket, e.g. `bucket`. rclone mkdir remote:bucket ### List all buckets Use the `lsf` command to list all buckets. rclone lsf remote: Note the colon (`:`) character at the end of the command line. ### Delete a bucket Use the `rmdir` command to delete an empty bucket. rclone rmdir remote:bucket Use the `purge` command to delete a non-empty bucket with all its content. rclone purge remote:bucket ### Upload objects Use the `copy` command to upload an object. rclone copy --progress /home/local/directory/file.ext remote:bucket/path/to/dir/ The `--progress` flag is for displaying progress information. Remove it if you don't need this information. Use a folder in the local path to upload all its objects. rclone copy --progress /home/local/directory/ remote:bucket/path/to/dir/ Only modified files will be copied. ### List objects Use the `ls` command to list recursively all objects in a bucket. rclone ls remote:bucket Add the folder to the remote path to list recursively all objects in this folder. rclone ls remote:bucket/path/to/dir/ Use the `lsf` command to list non-recursively all objects in a bucket or a folder. rclone lsf remote:bucket/path/to/dir/ ### Download objects Use the `copy` command to download an object. rclone copy --progress remote:bucket/path/to/dir/file.ext /home/local/directory/ The `--progress` flag is for displaying progress information. Remove it if you don't need this information. Use a folder in the remote path to download all its objects. rclone copy --progress remote:bucket/path/to/dir/ /home/local/directory/ ### Delete objects Use the `deletefile` command to delete a single object. rclone deletefile remote:bucket/path/to/dir/file.ext Use the `delete` command to delete all object in a folder. rclone delete remote:bucket/path/to/dir/ ### Print the total size of objects Use the `size` command to print the total size of objects in a bucket or a folder. rclone size remote:bucket/path/to/dir/ ### Sync two Locations Use the `sync` command to sync the source to the destination, changing the destination only, deleting any excess files. rclone sync --interactive --progress /home/local/directory/ remote:bucket/path/to/dir/ The `--progress` flag is for displaying progress information. Remove it if you don't need this information. Since this can cause data loss, test first with the `--dry-run` flag to see exactly what would be copied and deleted. The sync can be done also from Storj to the local file system. rclone sync --interactive --progress remote:bucket/path/to/dir/ /home/local/directory/ Or between two Storj buckets. rclone sync --interactive --progress remote-us:bucket/path/to/dir/ remote-europe:bucket/path/to/dir/ Or even between another cloud storage and Storj. rclone sync --interactive --progress s3:bucket/path/to/dir/ storj:bucket/path/to/dir/ ## Limitations `rclone about` is not supported by the rclone Storj backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) ## Known issues If you get errors like `too many open files` this usually happens when the default `ulimit` for system max open files is exceeded. Native Storj protocol opens a large number of TCP connections (each of which is counted as an open file). For a single upload stream you can expect 110 TCP connections to be opened. For a single download stream you can expect 35. This batch of connections will be opened for every 64 MiB segment and you should also expect TCP connections to be reused. If you do many transfers you eventually open a connection to most storage nodes (thousands of nodes). To fix these, please raise your system limits. You can do this issuing a `ulimit -n 65536` just before you run rclone. To change the limits more permanently you can add this to your shell startup script, e.g. `$HOME/.bashrc`, or change the system-wide configuration, usually `/etc/sysctl.conf` and/or `/etc/security/limits.conf`, but please refer to your operating system manual. # SugarSync [SugarSync](https://sugarsync.com) is a cloud service that enables active synchronization of files across computers and other devices for file backup, access, syncing, and sharing. ## Configuration The initial setup for SugarSync involves getting a token from SugarSync which you can do with rclone. `rclone config` walks you through it. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Sugarsync \ "sugarsync" [snip] Storage> sugarsync ** See help for sugarsync backend at: https://rclone.org/sugarsync/ ** Sugarsync App ID. Leave blank to use rclone's. Enter a string value. Press Enter for the default (""). app_id> Sugarsync Access Key ID. Leave blank to use rclone's. Enter a string value. Press Enter for the default (""). access_key_id> Sugarsync Private Access Key Leave blank to use rclone's. Enter a string value. Press Enter for the default (""). private_access_key> Permanently delete files if true otherwise put them in the deleted files. Enter a boolean value (true or false). Press Enter for the default ("false"). hard_delete> Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config Username (email address)> nick@craig-wood.com Your Sugarsync password is only required during setup and will not be stored. password: Configuration complete. Options: - type: sugarsync - refresh_token: https://api.sugarsync.com/app-authorization/XXXXXXXXXXXXXXXXXX Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` Note that the config asks for your email and password but doesn't store them, it only uses them to get the initial token. Once configured you can then use `rclone` like this, List directories (sync folders) in top level of your SugarSync rclone lsd remote: List all the files in your SugarSync folder "Test" rclone ls remote:Test To copy a local directory to an SugarSync folder called backup rclone copy /home/source remote:backup Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. **NB** you can't create files in the top level folder you have to create a folder, which rclone will create as a "Sync Folder" with SugarSync. ### Modification times and hashes SugarSync does not support modification times or hashes, therefore syncing will default to `--size-only` checking. Note that using `--update` will work as rclone can read the time files were uploaded. ### Restricted filename characters SugarSync replaces the [default restricted characters set](https://rclone.org/overview/#restricted-characters) except for DEL. Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in XML strings. ### Deleting files Deleted files will be moved to the "Deleted items" folder by default. However you can supply the flag `--sugarsync-hard-delete` or set the config parameter `hard_delete = true` if you would like files to be deleted straight away. ### Standard options Here are the Standard options specific to sugarsync (Sugarsync). #### --sugarsync-app-id Sugarsync App ID. Leave blank to use rclone's. Properties: - Config: app_id - Env Var: RCLONE_SUGARSYNC_APP_ID - Type: string - Required: false #### --sugarsync-access-key-id Sugarsync Access Key ID. Leave blank to use rclone's. Properties: - Config: access_key_id - Env Var: RCLONE_SUGARSYNC_ACCESS_KEY_ID - Type: string - Required: false #### --sugarsync-private-access-key Sugarsync Private Access Key. Leave blank to use rclone's. Properties: - Config: private_access_key - Env Var: RCLONE_SUGARSYNC_PRIVATE_ACCESS_KEY - Type: string - Required: false #### --sugarsync-hard-delete Permanently delete files if true otherwise put them in the deleted files. Properties: - Config: hard_delete - Env Var: RCLONE_SUGARSYNC_HARD_DELETE - Type: bool - Default: false ### Advanced options Here are the Advanced options specific to sugarsync (Sugarsync). #### --sugarsync-refresh-token Sugarsync refresh token. Leave blank normally, will be auto configured by rclone. Properties: - Config: refresh_token - Env Var: RCLONE_SUGARSYNC_REFRESH_TOKEN - Type: string - Required: false #### --sugarsync-authorization Sugarsync authorization. Leave blank normally, will be auto configured by rclone. Properties: - Config: authorization - Env Var: RCLONE_SUGARSYNC_AUTHORIZATION - Type: string - Required: false #### --sugarsync-authorization-expiry Sugarsync authorization expiry. Leave blank normally, will be auto configured by rclone. Properties: - Config: authorization_expiry - Env Var: RCLONE_SUGARSYNC_AUTHORIZATION_EXPIRY - Type: string - Required: false #### --sugarsync-user Sugarsync user. Leave blank normally, will be auto configured by rclone. Properties: - Config: user - Env Var: RCLONE_SUGARSYNC_USER - Type: string - Required: false #### --sugarsync-root-id Sugarsync root id. Leave blank normally, will be auto configured by rclone. Properties: - Config: root_id - Env Var: RCLONE_SUGARSYNC_ROOT_ID - Type: string - Required: false #### --sugarsync-deleted-id Sugarsync deleted folder id. Leave blank normally, will be auto configured by rclone. Properties: - Config: deleted_id - Env Var: RCLONE_SUGARSYNC_DELETED_ID - Type: string - Required: false #### --sugarsync-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_SUGARSYNC_ENCODING - Type: Encoding - Default: Slash,Ctl,InvalidUtf8,Dot #### --sugarsync-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SUGARSYNC_DESCRIPTION - Type: string - Required: false ## Limitations `rclone about` is not supported by the SugarSync backend. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) # Uloz.to Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. The initial setup for Uloz.to involves filling in the user credentials. `rclone config` walks you through it. ## Configuration Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Uloz.to \ "ulozto" [snip] Storage> ulozto Option app_token. The application token identifying the app. An app API key can be either found in the API doc https://uloz.to/upload-resumable-api-beta or obtained from customer service. Enter a value. Press Enter to leave empty. app_token> token_value Option username. The username of the principal to operate as. Enter a value. Press Enter to leave empty. username> user Option password. The password for the user. Choose an alternative below. Press Enter for the default (n). y) Yes, type in my own password g) Generate random password n) No, leave this optional password blank (default) y/g/n> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y ``` Once configured you can then use `rclone` like this, List folders in root level folder: rclone lsd remote: List all the files in your root folder: rclone ls remote: To copy a local folder to a Uloz.to folder called backup: rclone copy /home/source remote:backup ### User credentials The only reliable method is to authenticate the user using username and password. Uloz.to offers an API key as well, but it's reserved for the use of Uloz.to's in-house application and using it in different circumstances is unreliable. ### Modification times and hashes Uloz.to doesn't allow the user to set a custom modification time, or retrieve the hashes after upload. As a result, the integration uses a free form field the API provides to encode client-provided timestamps and hashes. Timestamps are stored with microsecond precision. A server calculated MD5 hash of the file is verified upon upload. Afterwards, the backend only serves the client-side calculated hashes. Hashes can also be retrieved upon creating a file download link, but it's impractical for `list`-like use cases. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | \ | 0x5C | ＼ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Transfers All files are currently uploaded using a single HTTP request, so for uploading large files a stable connection is necessary. Rclone will upload up to `--transfers` chunks at the same time (shared among all uploads). ### Deleting files By default, files are moved to the recycle bin whereas folders are deleted immediately. Trashed files are permanently deleted after 30 days in the recycle bin. Emptying the trash is currently not implemented in rclone. ### Root folder ID You can set the `root_folder_slug` for rclone. This is the folder (identified by its `Folder slug`) that rclone considers to be the root of your Uloz.to drive. Normally you will leave this blank and rclone will determine the correct root to use itself. However you can set this to restrict rclone to a specific folder hierarchy. In order to do this you will have to find the `Folder slug` of the folder you wish to use as root. This will be the last segment of the URL when you open the relevant folder in the Uloz.to web interface. For example, for exploring a folder with URL `https://uloz.to/fm/my-files/foobar`, `foobar` should be used as the root slug. `root_folder_slug` can be used alongside a specific path in the remote path. For example, if your remote's `root_folder_slug` corresponds to `/foo/bar`, `remote:baz/qux` will refer to `ABSOLUTE_ULOZTO_ROOT/foo/bar/baz/qux`. ### Standard options Here are the Standard options specific to ulozto (Uloz.to). #### --ulozto-app-token The application token identifying the app. An app API key can be either found in the API doc https://uloz.to/upload-resumable-api-beta or obtained from customer service. Properties: - Config: app_token - Env Var: RCLONE_ULOZTO_APP_TOKEN - Type: string - Required: false #### --ulozto-username The username of the principal to operate as. Properties: - Config: username - Env Var: RCLONE_ULOZTO_USERNAME - Type: string - Required: false #### --ulozto-password The password for the user. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: password - Env Var: RCLONE_ULOZTO_PASSWORD - Type: string - Required: false ### Advanced options Here are the Advanced options specific to ulozto (Uloz.to). #### --ulozto-root-folder-slug If set, rclone will use this folder as the root folder for all operations. For example, if the slug identifies 'foo/bar/', 'ulozto:baz' is equivalent to 'ulozto:foo/bar/baz' without any root slug set. Properties: - Config: root_folder_slug - Env Var: RCLONE_ULOZTO_ROOT_FOLDER_SLUG - Type: string - Required: false #### --ulozto-list-page-size The size of a single page for list commands. 1-500 Properties: - Config: list_page_size - Env Var: RCLONE_ULOZTO_LIST_PAGE_SIZE - Type: int - Default: 500 #### --ulozto-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_ULOZTO_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot #### --ulozto-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_ULOZTO_DESCRIPTION - Type: string - Required: false ## Limitations Uloz.to file names can't have the `\` character in. rclone maps this to and from an identical looking unicode equivalent `＼` (U+FF3C Fullwidth Reverse Solidus). Uloz.to only supports filenames up to 255 characters in length. Uloz.to rate limits access to the API, but exact details are undisclosed. Practical testing reveals that hitting the rate limit during normal use is very rare, although not impossible with higher number of concurrently uploaded files. `rclone about` is not supported by the Uloz.to backend. Although there's an endpoint to retrieve the information for the UI, it's not exposed in the API. Backends without this capability cannot determine free space for an rclone mount or use policy `mfs` (most free space) as a member of an rclone union remote. See [List of backends that do not support rclone about](https://rclone.org/overview/#optional-features) and [rclone about](https://rclone.org/commands/rclone_about/) # Uptobox This is a Backend for Uptobox file storage service. Uptobox is closer to a one-click hoster than a traditional cloud storage provider and therefore not suitable for long term storage. Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configuration To configure an Uptobox backend you'll need your personal api token. You'll find it in your [account settings](https://uptobox.com/my_account) Here is an example of how to make a remote called `remote` with the default setup. First run: rclone config This will guide you through an interactive setup process: ``` Current remotes: Name Type ==== ==== TestUptobox uptobox e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> n name> uptobox Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [...] 37 / Uptobox \ "uptobox" [...] Storage> uptobox ** See help for uptobox backend at: https://rclone.org/uptobox/ ** Your API Key, get it from https://uptobox.com/my_account Enter a string value. Press Enter for the default (""). api_key> xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config -------------------- [uptobox] type = uptobox api_key = xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> ``` Once configured you can then use `rclone` like this, List directories in top level of your Uptobox rclone lsd remote: List all the files in your Uptobox rclone ls remote: To copy a local directory to an Uptobox directory called backup rclone copy /home/source remote:backup ### Modification times and hashes Uptobox supports neither modified times nor checksums. All timestamps will read as that set by `--default-time`. ### Restricted filename characters In addition to the [default restricted characters set](https://rclone.org/overview/#restricted-characters) the following characters are also replaced: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | " | 0x22 | ＂ | | ` | 0x41 | ｀ | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in XML strings. ### Standard options Here are the Standard options specific to uptobox (Uptobox). #### --uptobox-access-token Your access token. Get it from https://uptobox.com/my_account. Properties: - Config: access_token - Env Var: RCLONE_UPTOBOX_ACCESS_TOKEN - Type: string - Required: false ### Advanced options Here are the Advanced options specific to uptobox (Uptobox). #### --uptobox-private Set to make uploaded files private Properties: - Config: private - Env Var: RCLONE_UPTOBOX_PRIVATE - Type: bool - Default: false #### --uptobox-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_UPTOBOX_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,BackQuote,Del,Ctl,LeftSpace,InvalidUtf8,Dot #### --uptobox-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_UPTOBOX_DESCRIPTION - Type: string - Required: false ## Limitations Uptobox will delete inactive files that have not been accessed in 60 days. `rclone about` is not supported by this backend an overview of used space can however been seen in the uptobox web interface. # Union The `union` backend joins several remotes together to make a single unified view of them. During the initial setup with `rclone config` you will specify the upstream remotes as a space separated list. The upstream remotes can either be a local paths or other remotes. The attributes `:ro`, `:nc` and `:writeback` can be attached to the end of the remote to tag the remote as **read only**, **no create** or **writeback**, e.g. `remote:directory/subdirectory:ro` or `remote:directory/subdirectory:nc`. - `:ro` means files will only be read from here and never written - `:nc` means new files or directories won't be created here - `:writeback` means files found in different remotes will be written back here. See the [writeback section](#writeback) for more info. Subfolders can be used in upstream remotes. Assume a union remote named `backup` with the remotes `mydrive:private/backup`. Invoking `rclone mkdir backup:desktop` is exactly the same as invoking `rclone mkdir mydrive:private/backup/desktop`. There is no special handling of paths containing `..` segments. Invoking `rclone mkdir backup:../desktop` is exactly the same as invoking `rclone mkdir mydrive:private/backup/../desktop`. ## Configuration Here is an example of how to make a union called `remote` for local folders. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Union merges the contents of several remotes \ "union" [snip] Storage> union List of space separated upstreams. Can be 'upstreama:test/dir upstreamb:', '\"upstreama:test/space:ro dir\" upstreamb:', etc. Enter a string value. Press Enter for the default (""). upstreams> remote1:dir1 remote2:dir2 remote3:dir3 Policy to choose upstream on ACTION class. Enter a string value. Press Enter for the default ("epall"). action_policy> Policy to choose upstream on CREATE class. Enter a string value. Press Enter for the default ("epmfs"). create_policy> Policy to choose upstream on SEARCH class. Enter a string value. Press Enter for the default ("ff"). search_policy> Cache time of usage and free space (in seconds). This option is only useful when a path preserving policy is used. Enter a signed integer. Press Enter for the default ("120"). cache_time> Remote config Configuration complete. Options: - type: union - upstreams: remote1:dir1 remote2:dir2 remote3:dir3 Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== remote union e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q ``` Once configured you can then use `rclone` like this, List directories in top level in `remote1:dir1`, `remote2:dir2` and `remote3:dir3` rclone lsd remote: List all the files in `remote1:dir1`, `remote2:dir2` and `remote3:dir3` rclone ls remote: Copy another local directory to the union directory called source, which will be placed into `remote3:dir3` rclone copy C:\source remote:source ### Behavior / Policies The behavior of union backend is inspired by [trapexit/mergerfs](https://github.com/trapexit/mergerfs). All functions are grouped into 3 categories: **action**, **create** and **search**. These functions and categories can be assigned a policy which dictates what file or directory is chosen when performing that behavior. Any policy can be assigned to a function or category though some may not be very useful in practice. For instance: **rand** (random) may be useful for file creation (create) but could lead to very odd behavior if used for `delete` if there were more than one copy of the file. ### Function / Category classifications | Category | Description | Functions | |----------|--------------------------|-------------------------------------------------------------------------------------| | action | Writing Existing file | move, rmdir, rmdirs, delete, purge and copy, sync (as destination when file exist) | | create | Create non-existing file | copy, sync (as destination when file not exist) | | search | Reading and listing file | ls, lsd, lsl, cat, md5sum, sha1sum and copy, sync (as source) | | N/A | | size, about | ### Path Preservation Policies, as described below, are of two basic types. `path preserving` and `non-path preserving`. All policies which start with `ep` (**epff**, **eplfs**, **eplus**, **epmfs**, **eprand**) are `path preserving`. `ep` stands for `existing path`. A path preserving policy will only consider upstreams where the relative path being accessed already exists. When using non-path preserving policies paths will be created in target upstreams as necessary. ### Quota Relevant Policies Some policies rely on quota information. These policies should be used only if your upstreams support the respective quota fields. | Policy | Required Field | |------------|----------------| | lfs, eplfs | Free | | mfs, epmfs | Free | | lus, eplus | Used | | lno, eplno | Objects | To check if your upstream supports the field, run `rclone about remote: [flags]` and see if the required field exists. ### Filters Policies basically search upstream remotes and create a list of files / paths for functions to work on. The policy is responsible for filtering and sorting. The policy type defines the sorting but filtering is mostly uniform as described below. * No **search** policies filter. * All **action** policies will filter out remotes which are tagged as **read-only**. * All **create** policies will filter out remotes which are tagged **read-only** or **no-create**. If all remotes are filtered an error will be returned. ### Policy descriptions The policies definition are inspired by [trapexit/mergerfs](https://github.com/trapexit/mergerfs) but not exactly the same. Some policy definition could be different due to the much larger latency of remote file systems. | Policy | Description | |------------------|------------------------------------------------------------| | all | Search category: same as **epall**. Action category: same as **epall**. Create category: act on all upstreams. | | epall (existing path, all) | Search category: Given this order configured, act on the first one found where the relative path exists. Action category: apply to all found. Create category: act on all upstreams where the relative path exists. | | epff (existing path, first found) | Act on the first one found, by the time upstreams reply, where the relative path exists. | | eplfs (existing path, least free space) | Of all the upstreams on which the relative path exists choose the one with the least free space. | | eplus (existing path, least used space) | Of all the upstreams on which the relative path exists choose the one with the least used space. | | eplno (existing path, least number of objects) | Of all the upstreams on which the relative path exists choose the one with the least number of objects. | | epmfs (existing path, most free space) | Of all the upstreams on which the relative path exists choose the one with the most free space. | | eprand (existing path, random) | Calls **epall** and then randomizes. Returns only one upstream. | | ff (first found) | Search category: same as **epff**. Action category: same as **epff**. Create category: Act on the first one found by the time upstreams reply. | | lfs (least free space) | Search category: same as **eplfs**. Action category: same as **eplfs**. Create category: Pick the upstream with the least available free space. | | lus (least used space) | Search category: same as **eplus**. Action category: same as **eplus**. Create category: Pick the upstream with the least used space. | | lno (least number of objects) | Search category: same as **eplno**. Action category: same as **eplno**. Create category: Pick the upstream with the least number of objects. | | mfs (most free space) | Search category: same as **epmfs**. Action category: same as **epmfs**. Create category: Pick the upstream with the most available free space. | | newest | Pick the file / directory with the largest mtime. | | rand (random) | Calls **all** and then randomizes. Returns only one upstream. | ### Writeback {#writeback} The tag `:writeback` on an upstream remote can be used to make a simple cache system like this: ``` [union] type = union action_policy = all create_policy = all search_policy = ff upstreams = /local:writeback remote:dir ``` When files are opened for read, if the file is in `remote:dir` but not `/local` then rclone will copy the file entirely into `/local` before returning a reference to the file in `/local`. The copy will be done with the equivalent of `rclone copy` so will use `--multi-thread-streams` if configured. Any copies will be logged with an INFO log. When files are written, they will be written to both `remote:dir` and `/local`. As many remotes as desired can be added to `upstreams` but there should only be one `:writeback` tag. Rclone does not manage the `:writeback` remote in any way other than writing files back to it. So if you need to expire old files or manage the size then you will have to do this yourself. ### Standard options Here are the Standard options specific to union (Union merges the contents of several upstream fs). #### --union-upstreams List of space separated upstreams. Can be 'upstreama:test/dir upstreamb:', '"upstreama:test/space:ro dir" upstreamb:', etc. Properties: - Config: upstreams - Env Var: RCLONE_UNION_UPSTREAMS - Type: string - Required: true #### --union-action-policy Policy to choose upstream on ACTION category. Properties: - Config: action_policy - Env Var: RCLONE_UNION_ACTION_POLICY - Type: string - Default: "epall" #### --union-create-policy Policy to choose upstream on CREATE category. Properties: - Config: create_policy - Env Var: RCLONE_UNION_CREATE_POLICY - Type: string - Default: "epmfs" #### --union-search-policy Policy to choose upstream on SEARCH category. Properties: - Config: search_policy - Env Var: RCLONE_UNION_SEARCH_POLICY - Type: string - Default: "ff" #### --union-cache-time Cache time of usage and free space (in seconds). This option is only useful when a path preserving policy is used. Properties: - Config: cache_time - Env Var: RCLONE_UNION_CACHE_TIME - Type: int - Default: 120 ### Advanced options Here are the Advanced options specific to union (Union merges the contents of several upstream fs). #### --union-min-free-space Minimum viable free space for lfs/eplfs policies. If a remote has less than this much free space then it won't be considered for use in lfs or eplfs policies. Properties: - Config: min_free_space - Env Var: RCLONE_UNION_MIN_FREE_SPACE - Type: SizeSuffix - Default: 1Gi #### --union-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_UNION_DESCRIPTION - Type: string - Required: false ### Metadata Any metadata supported by the underlying remote is read and written. See the [metadata](https://rclone.org/docs/#metadata) docs for more info. # WebDAV Paths are specified as `remote:path` Paths may be as deep as required, e.g. `remote:directory/subdirectory`. ## Configuration To configure the WebDAV remote you will need to have a URL for it, and a username and password. If you know what kind of system you are connecting to then rclone can enable extra features. Here is an example of how to make a remote called `remote`. First run: rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / WebDAV \ "webdav" [snip] Storage> webdav URL of http host to connect to Choose a number from below, or type in your own value 1 / Connect to example.com \ "https://example.com" url> https://example.com/remote.php/webdav/ Name of the WebDAV site/service/software you are using Choose a number from below, or type in your own value 1 / Fastmail Files \ (fastmail) 2 / Nextcloud \ (nextcloud) 3 / Owncloud \ (owncloud) 4 / Sharepoint Online, authenticated by Microsoft account \ (sharepoint) 5 / Sharepoint with NTLM authentication, usually self-hosted or on-premises \ (sharepoint-ntlm) 6 / rclone WebDAV server to serve a remote over HTTP via the WebDAV protocol \ (rclone) 7 / Other site/service or software \ (other) vendor> 2 User name user> user Password. y) Yes type in my own password g) Generate random password n) No leave this optional password blank y/g/n> y Enter the password: password: Confirm the password: password: Bearer token instead of user/pass (e.g. a Macaroon) bearer_token> Remote config Configuration complete. Options: - type: webdav - url: https://example.com/remote.php/webdav/ - vendor: nextcloud - user: user - pass: *** ENCRYPTED *** - bearer_token: Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` Once configured you can then use `rclone` like this, List directories in top level of your WebDAV rclone lsd remote: List all the files in your WebDAV rclone ls remote: To copy a local directory to an WebDAV directory called backup rclone copy /home/source remote:backup ### Modification times and hashes Plain WebDAV does not support modified times. However when used with Fastmail Files, ownCloud or Nextcloud rclone will support modified times. Likewise plain WebDAV does not support hashes, however when used with Fastmail Files, ownCloud or Nextcloud rclone will support SHA1 and MD5 hashes. Depending on the exact version of ownCloud or Nextcloud hashes may appear on all objects, or only on objects which had a hash uploaded with them. ### Standard options Here are the Standard options specific to webdav (WebDAV). #### --webdav-url URL of http host to connect to. E.g. https://example.com. Properties: - Config: url - Env Var: RCLONE_WEBDAV_URL - Type: string - Required: true #### --webdav-vendor Name of the WebDAV site/service/software you are using. Properties: - Config: vendor - Env Var: RCLONE_WEBDAV_VENDOR - Type: string - Required: false - Examples: - "fastmail" - Fastmail Files - "nextcloud" - Nextcloud - "owncloud" - Owncloud 10 PHP based WebDAV server - "infinitescale" - ownCloud Infinite Scale - "sharepoint" - Sharepoint Online, authenticated by Microsoft account - "sharepoint-ntlm" - Sharepoint with NTLM authentication, usually self-hosted or on-premises - "rclone" - rclone WebDAV server to serve a remote over HTTP via the WebDAV protocol - "other" - Other site/service or software #### --webdav-user User name. In case NTLM authentication is used, the username should be in the format 'Domain\User'. Properties: - Config: user - Env Var: RCLONE_WEBDAV_USER - Type: string - Required: false #### --webdav-pass Password. **NB** Input to this must be obscured - see [rclone obscure](https://rclone.org/commands/rclone_obscure/). Properties: - Config: pass - Env Var: RCLONE_WEBDAV_PASS - Type: string - Required: false #### --webdav-bearer-token Bearer token instead of user/pass (e.g. a Macaroon). Properties: - Config: bearer_token - Env Var: RCLONE_WEBDAV_BEARER_TOKEN - Type: string - Required: false ### Advanced options Here are the Advanced options specific to webdav (WebDAV). #### --webdav-bearer-token-command Command to run to get a bearer token. Properties: - Config: bearer_token_command - Env Var: RCLONE_WEBDAV_BEARER_TOKEN_COMMAND - Type: string - Required: false #### --webdav-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Default encoding is Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,Hash,Percent,BackSlash,Del,Ctl,LeftSpace,LeftTilde,RightSpace,RightPeriod,InvalidUtf8 for sharepoint-ntlm or identity otherwise. Properties: - Config: encoding - Env Var: RCLONE_WEBDAV_ENCODING - Type: string - Required: false #### --webdav-headers Set HTTP headers for all transactions. Use this to set additional HTTP headers for all transactions The input format is comma separated list of key,value pairs. Standard [CSV encoding](https://godoc.org/encoding/csv) may be used. For example, to set a Cookie use 'Cookie,name=value', or '"Cookie","name=value"'. You can set multiple headers, e.g. '"Cookie","name=value","Authorization","xxx"'. Properties: - Config: headers - Env Var: RCLONE_WEBDAV_HEADERS - Type: CommaSepList - Default: #### --webdav-pacer-min-sleep Minimum time to sleep between API calls. Properties: - Config: pacer_min_sleep - Env Var: RCLONE_WEBDAV_PACER_MIN_SLEEP - Type: Duration - Default: 10ms #### --webdav-nextcloud-chunk-size Nextcloud upload chunk size. We recommend configuring your NextCloud instance to increase the max chunk size to 1 GB for better upload performances. See https://docs.nextcloud.com/server/latest/admin_manual/configuration_files/big_file_upload_configuration.html#adjust-chunk-size-on-nextcloud-side Set to 0 to disable chunked uploading. Properties: - Config: nextcloud_chunk_size - Env Var: RCLONE_WEBDAV_NEXTCLOUD_CHUNK_SIZE - Type: SizeSuffix - Default: 10Mi #### --webdav-owncloud-exclude-shares Exclude ownCloud shares Properties: - Config: owncloud_exclude_shares - Env Var: RCLONE_WEBDAV_OWNCLOUD_EXCLUDE_SHARES - Type: bool - Default: false #### --webdav-owncloud-exclude-mounts Exclude ownCloud mounted storages Properties: - Config: owncloud_exclude_mounts - Env Var: RCLONE_WEBDAV_OWNCLOUD_EXCLUDE_MOUNTS - Type: bool - Default: false #### --webdav-unix-socket Path to a unix domain socket to dial to, instead of opening a TCP connection directly Properties: - Config: unix_socket - Env Var: RCLONE_WEBDAV_UNIX_SOCKET - Type: string - Required: false #### --webdav-auth-redirect Preserve authentication on redirect. If the server redirects rclone to a new domain when it is trying to read a file then normally rclone will drop the Authorization: header from the request. This is standard security practice to avoid sending your credentials to an unknown webserver. However this is desirable in some circumstances. If you are getting an error like "401 Unauthorized" when rclone is attempting to read files from the webdav server then you can try this option. Properties: - Config: auth_redirect - Env Var: RCLONE_WEBDAV_AUTH_REDIRECT - Type: bool - Default: false #### --webdav-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_WEBDAV_DESCRIPTION - Type: string - Required: false ## Provider notes See below for notes on specific providers. ### Fastmail Files Use `https://webdav.fastmail.com/` or a subdirectory as the URL, and your Fastmail email `username@domain.tld` as the username. Follow [this documentation](https://www.fastmail.help/hc/en-us/articles/360058752854-App-passwords) to create an app password with access to `Files (WebDAV)` and use this as the password. Fastmail supports modified times using the `X-OC-Mtime` header. ### ownCloud Click on the settings cog in the bottom right of the page and this will show the WebDAV URL that rclone needs in the config step. It will look something like `https://example.com/remote.php/webdav/`. ownCloud supports modified times using the `X-OC-Mtime` header. ### Nextcloud This is configured in an identical way to ownCloud. Note that Nextcloud initially did not support streaming of files (`rcat`) whereas ownCloud did, but [this](https://github.com/nextcloud/nextcloud-snap/issues/365) seems to be fixed as of 2020-11-27 (tested with rclone v1.53.1 and Nextcloud Server v19). ### ownCloud Infinite Scale The WebDAV URL for Infinite Scale can be found in the details panel of any space in Infinite Scale, if the display was enabled in the personal settings of the user through a checkbox there. Infinite Scale works with the chunking [tus](https://tus.io) upload protocol. The chunk size is currently fixed 10 MB. ### Sharepoint Online Rclone can be used with Sharepoint provided by OneDrive for Business or Office365 Education Accounts. This feature is only needed for a few of these Accounts, mostly Office365 Education ones. These accounts are sometimes not verified by the domain owner [github#1975](https://github.com/rclone/rclone/issues/1975) This means that these accounts can't be added using the official API (other Accounts should work with the "onedrive" option). However, it is possible to access them using webdav. To use a sharepoint remote with rclone, add it like this: First, you need to get your remote's URL: - Go [here](https://onedrive.live.com/about/en-us/signin/) to open your OneDrive or to sign in - Now take a look at your address bar, the URL should look like this: `https://[YOUR-DOMAIN]-my.sharepoint.com/personal/[YOUR-EMAIL]/_layouts/15/onedrive.aspx` You'll only need this URL up to the email address. After that, you'll most likely want to add "/Documents". That subdirectory contains the actual data stored on your OneDrive. Add the remote to rclone like this: Configure the `url` as `https://[YOUR-DOMAIN]-my.sharepoint.com/personal/[YOUR-EMAIL]/Documents` and use your normal account email and password for `user` and `pass`. If you have 2FA enabled, you have to generate an app password. Set the `vendor` to `sharepoint`. Your config file should look like this: ``` [sharepoint] type = webdav url = https://[YOUR-DOMAIN]-my.sharepoint.com/personal/[YOUR-EMAIL]/Documents vendor = sharepoint user = YourEmailAddress pass = encryptedpassword ``` ### Sharepoint with NTLM Authentication Use this option in case your (hosted) Sharepoint is not tied to OneDrive accounts and uses NTLM authentication. To get the `url` configuration, similarly to the above, first navigate to the desired directory in your browser to get the URL, then strip everything after the name of the opened directory. Example: If the URL is: https://example.sharepoint.com/sites/12345/Documents/Forms/AllItems.aspx The configuration to use would be: https://example.sharepoint.com/sites/12345/Documents Set the `vendor` to `sharepoint-ntlm`. NTLM uses domain and user name combination for authentication, set `user` to `DOMAIN\username`. Your config file should look like this: ``` [sharepoint] type = webdav url = https://[YOUR-DOMAIN]/some-path-to/Documents vendor = sharepoint-ntlm user = DOMAIN\user pass = encryptedpassword ``` #### Required Flags for SharePoint As SharePoint does some special things with uploaded documents, you won't be able to use the documents size or the documents hash to compare if a file has been changed since the upload / which file is newer. For Rclone calls copying files (especially Office files such as .docx, .xlsx, etc.) from/to SharePoint (like copy, sync, etc.), you should append these flags to ensure Rclone uses the "Last Modified" datetime property to compare your documents: ``` --ignore-size --ignore-checksum --update ``` ## Rclone Use this option if you are hosting remotes over WebDAV provided by rclone. Read [rclone serve webdav](commands/rclone_serve_webdav/) for more details. rclone serve supports modified times using the `X-OC-Mtime` header. ### dCache dCache is a storage system that supports many protocols and authentication/authorisation schemes. For WebDAV clients, it allows users to authenticate with username and password (BASIC), X.509, Kerberos, and various bearer tokens, including [Macaroons](https://www.dcache.org/manuals/workshop-2017-05-29-Umea/000-Final/anupam_macaroons_v02.pdf) and [OpenID-Connect](https://en.wikipedia.org/wiki/OpenID_Connect) access tokens. Configure as normal using the `other` type. Don't enter a username or password, instead enter your Macaroon as the `bearer_token`. The config will end up looking something like this. ``` [dcache] type = webdav url = https://dcache... vendor = other user = pass = bearer_token = your-macaroon ``` There is a [script](https://github.com/sara-nl/GridScripts/blob/master/get-macaroon) that obtains a Macaroon from a dCache WebDAV endpoint, and creates an rclone config file. Macaroons may also be obtained from the dCacheView web-browser/JavaScript client that comes with dCache. ### OpenID-Connect dCache also supports authenticating with OpenID-Connect access tokens. OpenID-Connect is a protocol (based on OAuth 2.0) that allows services to identify users who have authenticated with some central service. Support for OpenID-Connect in rclone is currently achieved using another software package called [oidc-agent](https://github.com/indigo-dc/oidc-agent). This is a command-line tool that facilitates obtaining an access token. Once installed and configured, an access token is obtained by running the `oidc-token` command. The following example shows a (shortened) access token obtained from the *XDC* OIDC Provider. ``` paul@celebrimbor:~$ oidc-token XDC eyJraWQ[...]QFXDt0 paul@celebrimbor:~$ ``` **Note** Before the `oidc-token` command will work, the refresh token must be loaded into the oidc agent. This is done with the `oidc-add` command (e.g., `oidc-add XDC`). This is typically done once per login session. Full details on this and how to register oidc-agent with your OIDC Provider are provided in the [oidc-agent documentation](https://indigo-dc.gitbooks.io/oidc-agent/). The rclone `bearer_token_command` configuration option is used to fetch the access token from oidc-agent. Configure as a normal WebDAV endpoint, using the 'other' vendor, leaving the username and password empty. When prompted, choose to edit the advanced config and enter the command to get a bearer token (e.g., `oidc-agent XDC`). The following example config shows a WebDAV endpoint that uses oidc-agent to supply an access token from the *XDC* OIDC Provider. ``` [dcache] type = webdav url = https://dcache.example.org/ vendor = other bearer_token_command = oidc-token XDC ``` # Yandex Disk [Yandex Disk](https://disk.yandex.com) is a cloud storage solution created by [Yandex](https://yandex.com). ## Configuration Here is an example of making a yandex configuration. First run rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password n/s> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Yandex Disk \ "yandex" [snip] Storage> yandex Yandex Client Id - leave blank normally. client_id> Yandex Client Secret - leave blank normally. client_secret> Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: yandex - client_id: - client_secret: - token: {"access_token":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","token_type":"OAuth","expiry":"2016-12-29T12:27:11.362788025Z"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ``` See the [remote setup docs](https://rclone.org/remote_setup/) for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Yandex Disk. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on `http://127.0.0.1:53682/` and this it may require you to unblock it temporarily if you are running a host firewall. Once configured you can then use `rclone` like this, See top level directories rclone lsd remote: Make a new directory rclone mkdir remote:directory List the contents of a directory rclone ls remote:directory Sync `/home/local/directory` to the remote path, deleting any excess files in the path. rclone sync --interactive /home/local/directory remote:directory Yandex paths may be as deep as required, e.g. `remote:directory/subdirectory`. ### Modification times and hashes Modified times are supported and are stored accurate to 1 ns in custom metadata called `rclone_modified` in RFC3339 with nanoseconds format. The MD5 hash algorithm is natively supported by Yandex Disk. ### Emptying Trash If you wish to empty your trash you can use the `rclone cleanup remote:` command which will permanently delete all your trashed files. This command does not take any path arguments. ### Quota information To view your current quota you can use the `rclone about remote:` command which will display your usage limit (quota) and the current usage. ### Restricted filename characters The [default restricted characters set](https://rclone.org/overview/#restricted-characters) are replaced. Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be used in JSON strings. ### Standard options Here are the Standard options specific to yandex (Yandex Disk). #### --yandex-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_YANDEX_CLIENT_ID - Type: string - Required: false #### --yandex-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_YANDEX_CLIENT_SECRET - Type: string - Required: false ### Advanced options Here are the Advanced options specific to yandex (Yandex Disk). #### --yandex-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_YANDEX_TOKEN - Type: string - Required: false #### --yandex-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_YANDEX_AUTH_URL - Type: string - Required: false #### --yandex-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_YANDEX_TOKEN_URL - Type: string - Required: false #### --yandex-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_YANDEX_CLIENT_CREDENTIALS - Type: bool - Default: false #### --yandex-hard-delete Delete files permanently rather than putting them into the trash. Properties: - Config: hard_delete - Env Var: RCLONE_YANDEX_HARD_DELETE - Type: bool - Default: false #### --yandex-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_YANDEX_ENCODING - Type: Encoding - Default: Slash,Del,Ctl,InvalidUtf8,Dot #### --yandex-spoof-ua Set the user agent to match an official version of the yandex disk client. May help with upload performance. Properties: - Config: spoof_ua - Env Var: RCLONE_YANDEX_SPOOF_UA - Type: bool - Default: true #### --yandex-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_YANDEX_DESCRIPTION - Type: string - Required: false ## Limitations When uploading very large files (bigger than about 5 GiB) you will need to increase the `--timeout` parameter. This is because Yandex pauses (perhaps to calculate the MD5SUM for the entire file) before returning confirmation that the file has been uploaded. The default handling of timeouts in rclone is to assume a 5 minute pause is an error and close the connection - you'll see `net/http: timeout awaiting response headers` errors in the logs if this is happening. Setting the timeout to twice the max size of file in GiB should be enough, so if you want to upload a 30 GiB file set a timeout of `2 * 30 = 60m`, that is `--timeout 60m`. Having a Yandex Mail account is mandatory to use the Yandex.Disk subscription. Token generation will work without a mail account, but Rclone won't be able to complete any actions. ``` [403 - DiskUnsupportedUserAccountTypeError] User account type is not supported. ``` # Zoho Workdrive [Zoho WorkDrive](https://www.zoho.com/workdrive/) is a cloud storage solution created by [Zoho](https://zoho.com). ## Configuration Here is an example of making a zoho configuration. First run rclone config This will guide you through an interactive setup process: ``` No remotes found, make a new one? n) New remote s) Set configuration password n/s> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Zoho \ "zoho" [snip] Storage> zoho ** See help for zoho backend at: https://rclone.org/zoho/ ** OAuth Client Id Leave blank normally. Enter a string value. Press Enter for the default (""). client_id> OAuth Client Secret Leave blank normally. Enter a string value. Press Enter for the default (""). client_secret> Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes (default) n) No y/n> If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth?state=LVn0IHzxej1ZkmQw31d0wQ Log in and authorize rclone for access Waiting for code... Got code Choose a number from below, or type in your own value 1 / MyTeam \ "4u28602177065ff22426787a6745dba8954eb" Enter a Team ID> 1 Choose a number from below, or type in your own value 1 / General \ "4u2869d2aa6fca04f4f2f896b6539243b85b1" Enter a Workspace ID> 1 Configuration complete. Options: - type: zoho - token: {"access_token":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","token_type":"Zoho-oauthtoken","refresh_token":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","expiry":"2020-10-12T00:54:52.370275223+02:00"} - root_folder_id: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> ``` See the [remote setup docs](https://rclone.org/remote_setup/) for how to set it up on a machine with no Internet browser available. Rclone runs a webserver on your local computer to collect the authorization token from Zoho Workdrive. This is only from the moment your browser is opened until the token is returned. The webserver runs on `http://127.0.0.1:53682/`. If local port `53682` is protected by a firewall you may need to temporarily unblock the firewall to complete authorization. Once configured you can then use `rclone` like this, See top level directories rclone lsd remote: Make a new directory rclone mkdir remote:directory List the contents of a directory rclone ls remote:directory Sync `/home/local/directory` to the remote path, deleting any excess files in the path. rclone sync --interactive /home/local/directory remote:directory Zoho paths may be as deep as required, eg `remote:directory/subdirectory`. ### Modification times and hashes Modified times are currently not supported for Zoho Workdrive No hash algorithms are supported. ### Usage information To view your current quota you can use the `rclone about remote:` command which will display your current usage. ### Restricted filename characters Only control characters and invalid UTF-8 are replaced. In addition most Unicode full-width characters are not supported at all and will be removed from filenames during upload. ### Standard options Here are the Standard options specific to zoho (Zoho). #### --zoho-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_ZOHO_CLIENT_ID - Type: string - Required: false #### --zoho-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_ZOHO_CLIENT_SECRET - Type: string - Required: false #### --zoho-region Zoho region to connect to. You'll have to use the region your organization is registered in. If not sure use the same top level domain as you connect to in your browser. Properties: - Config: region - Env Var: RCLONE_ZOHO_REGION - Type: string - Required: false - Examples: - "com" - United states / Global - "eu" - Europe - "in" - India - "jp" - Japan - "com.cn" - China - "com.au" - Australia ### Advanced options Here are the Advanced options specific to zoho (Zoho). #### --zoho-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_ZOHO_TOKEN - Type: string - Required: false #### --zoho-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_ZOHO_AUTH_URL - Type: string - Required: false #### --zoho-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_ZOHO_TOKEN_URL - Type: string - Required: false #### --zoho-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_ZOHO_CLIENT_CREDENTIALS - Type: bool - Default: false #### --zoho-upload-cutoff Cutoff for switching to large file upload api (>= 10 MiB). Properties: - Config: upload_cutoff - Env Var: RCLONE_ZOHO_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 10Mi #### --zoho-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_ZOHO_ENCODING - Type: Encoding - Default: Del,Ctl,InvalidUtf8 #### --zoho-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_ZOHO_DESCRIPTION - Type: string - Required: false ## Setting up your own client_id For Zoho we advise you to set up your own client_id. To do so you have to complete the following steps. 1. Log in to the [Zoho API Console](https://api-console.zoho.com) 2. Create a new client of type "Server-based Application". The name and website don't matter, but you must add the redirect URL `http://localhost:53682/`. 3. Once the client is created, you can go to the settings tab and enable it in other regions. The client id and client secret can now be used with rclone. # Local Filesystem Local paths are specified as normal filesystem paths, e.g. `/path/to/wherever`, so rclone sync --interactive /home/source /tmp/destination Will sync `/home/source` to `/tmp/destination`. ## Configuration For consistencies sake one can also configure a remote of type `local` in the config file, and access the local filesystem using rclone remote paths, e.g. `remote:path/to/wherever`, but it is probably easier not to. ### Modification times Rclone reads and writes the modification times using an accuracy determined by the OS. Typically this is 1ns on Linux, 10 ns on Windows and 1 Second on OS X. ### Filenames ### Filenames should be encoded in UTF-8 on disk. This is the normal case for Windows and OS X. There is a bit more uncertainty in the Linux world, but new distributions will have UTF-8 encoded files names. If you are using an old Linux filesystem with non UTF-8 file names (e.g. latin1) then you can use the `convmv` tool to convert the filesystem to UTF-8. This tool is available in most distributions' package managers. If an invalid (non-UTF8) filename is read, the invalid characters will be replaced with a quoted representation of the invalid bytes. The name `gro\xdf` will be transferred as `gro‛DF`. `rclone` will emit a debug message in this case (use `-v` to see), e.g. ``` Local file system at .: Replacing invalid UTF-8 characters in "gro\xdf" ``` #### Restricted characters With the local backend, restrictions on the characters that are usable in file or directory names depend on the operating system. To check what rclone will replace by default on your system, run `rclone help flags local-encoding`. On non Windows platforms the following characters are replaced when handling file names. | Character | Value | Replacement | | --------- |:-----:|:-----------:| | NUL | 0x00 | ␀ | | / | 0x2F | ／ | When running on Windows the following characters are replaced. This list is based on the [Windows file naming conventions](https://docs.microsoft.com/de-de/windows/desktop/FileIO/naming-a-file#naming-conventions). | Character | Value | Replacement | | --------- |:-----:|:-----------:| | NUL | 0x00 | ␀ | | SOH | 0x01 | ␁ | | STX | 0x02 | ␂ | | ETX | 0x03 | ␃ | | EOT | 0x04 | ␄ | | ENQ | 0x05 | ␅ | | ACK | 0x06 | ␆ | | BEL | 0x07 | ␇ | | BS | 0x08 | ␈ | | HT | 0x09 | ␉ | | LF | 0x0A | ␊ | | VT | 0x0B | ␋ | | FF | 0x0C | ␌ | | CR | 0x0D | ␍ | | SO | 0x0E | ␎ | | SI | 0x0F | ␏ | | DLE | 0x10 | ␐ | | DC1 | 0x11 | ␑ | | DC2 | 0x12 | ␒ | | DC3 | 0x13 | ␓ | | DC4 | 0x14 | ␔ | | NAK | 0x15 | ␕ | | SYN | 0x16 | ␖ | | ETB | 0x17 | ␗ | | CAN | 0x18 | ␘ | | EM | 0x19 | ␙ | | SUB | 0x1A | ␚ | | ESC | 0x1B | ␛ | | FS | 0x1C | ␜ | | GS | 0x1D | ␝ | | RS | 0x1E | ␞ | | US | 0x1F | ␟ | | / | 0x2F | ／ | | " | 0x22 | ＂ | | * | 0x2A | ＊ | | : | 0x3A | ： | | < | 0x3C | ＜ | | > | 0x3E | ＞ | | ? | 0x3F | ？ | | \ | 0x5C | ＼ | | \| | 0x7C | ｜ | File names on Windows can also not end with the following characters. These only get replaced if they are the last character in the name: | Character | Value | Replacement | | --------- |:-----:|:-----------:| | SP | 0x20 | ␠ | | . | 0x2E | ． | Invalid UTF-8 bytes will also be [replaced](https://rclone.org/overview/#invalid-utf8), as they can't be converted to UTF-16. ### Paths on Windows ### On Windows there are many ways of specifying a path to a file system resource. Local paths can be absolute, like `C:\path\to\wherever`, or relative, like `..\wherever`. Network paths in UNC format, `\\server\share`, are also supported. Path separator can be either `\` (as in `C:\path\to\wherever`) or `/` (as in `C:/path/to/wherever`). Length of these paths are limited to 259 characters for files and 247 characters for directories, but there is an alternative extended-length path format increasing the limit to (approximately) 32,767 characters. This format requires absolute paths and the use of prefix `\\?\`, e.g. `\\?\D:\some\very\long\path`. For convenience rclone will automatically convert regular paths into the corresponding extended-length paths, so in most cases you do not have to worry about this (read more [below](#long-paths)). Using the same prefix `\\?\` it is also possible to specify path to volumes identified by their GUID, e.g. `\\?\Volume{b75e2c83-0000-0000-0000-602f00000000}\some\path`. #### Long paths #### Rclone handles long paths automatically, by converting all paths to [extended-length path format](https://docs.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation), which allows paths up to 32,767 characters. This conversion will ensure paths are absolute and prefix them with the `\\?\`. This is why you will see that your paths, for instance `.\files` is shown as path `\\?\C:\files` in the output, and `\\server\share` as `\\?\UNC\server\share`. However, in rare cases this may cause problems with buggy file system drivers like [EncFS](https://github.com/rclone/rclone/issues/261). To disable UNC conversion globally, add this to your `.rclone.conf` file: ``` [local] nounc = true ``` If you want to selectively disable UNC, you can add it to a separate entry like this: ``` [nounc] type = local nounc = true ``` And use rclone like this: `rclone copy c:\src nounc:z:\dst` This will use UNC paths on `c:\src` but not on `z:\dst`. Of course this will cause problems if the absolute path length of a file exceeds 259 characters on z, so only use this option if you have to. ### Symlinks / Junction points Normally rclone will ignore symlinks or junction points (which behave like symlinks under Windows). If you supply `--copy-links` or `-L` then rclone will follow the symlink and copy the pointed to file or directory. Note that this flag is incompatible with `--links` / `-l`. This flag applies to all commands. For example, supposing you have a directory structure like this ``` $ tree /tmp/a /tmp/a ├── b -> ../b ├── expected -> ../expected ├── one └── two └── three ``` Then you can see the difference with and without the flag like this ``` $ rclone ls /tmp/a 6 one 6 two/three ``` and ``` $ rclone -L ls /tmp/a 4174 expected 6 one 6 two/three 6 b/two 6 b/one ``` #### --local-links, --links, -l Normally rclone will ignore symlinks or junction points (which behave like symlinks under Windows). If you supply this flag then rclone will copy symbolic links from the local storage, and store them as text files, with a `.rclonelink` suffix in the remote storage. The text file will contain the target of the symbolic link (see example). This flag applies to all commands. For example, supposing you have a directory structure like this ``` $ tree /tmp/a /tmp/a ├── file1 -> ./file4 └── file2 -> /home/user/file3 ``` Copying the entire directory with '-l' ``` $ rclone copy -l /tmp/a/ remote:/tmp/a/ ``` The remote files are created with a `.rclonelink` suffix ``` $ rclone ls remote:/tmp/a 5 file1.rclonelink 14 file2.rclonelink ``` The remote files will contain the target of the symbolic links ``` $ rclone cat remote:/tmp/a/file1.rclonelink ./file4 $ rclone cat remote:/tmp/a/file2.rclonelink /home/user/file3 ``` Copying them back with '-l' ``` $ rclone copy -l remote:/tmp/a/ /tmp/b/ $ tree /tmp/b /tmp/b ├── file1 -> ./file4 └── file2 -> /home/user/file3 ``` However, if copied back without '-l' ``` $ rclone copyto remote:/tmp/a/ /tmp/b/ $ tree /tmp/b /tmp/b ├── file1.rclonelink └── file2.rclonelink ``` If you want to copy a single file with `-l` then you must use the `.rclonelink` suffix. ``` $ rclone copy -l remote:/tmp/a/file1.rclonelink /tmp/c $ tree /tmp/c /tmp/c └── file1 -> ./file4 ``` Note that `--local-links` just enables this feature for the local backend. `--links` and `-l` enable the feature for all supported backends and the VFS. Note that this flag is incompatible with `-copy-links` / `-L`. ### Restricting filesystems with --one-file-system Normally rclone will recurse through filesystems as mounted. However if you set `--one-file-system` or `-x` this tells rclone to stay in the filesystem specified by the root and not to recurse into different file systems. For example if you have a directory hierarchy like this ``` root ├── disk1 - disk1 mounted on the root │   └── file3 - stored on disk1 ├── disk2 - disk2 mounted on the root │   └── file4 - stored on disk12 ├── file1 - stored on the root disk └── file2 - stored on the root disk ``` Using `rclone --one-file-system copy root remote:` will only copy `file1` and `file2`. Eg ``` $ rclone -q --one-file-system ls root 0 file1 0 file2 ``` ``` $ rclone -q ls root 0 disk1/file3 0 disk2/file4 0 file1 0 file2 ``` **NB** Rclone (like most unix tools such as `du`, `rsync` and `tar`) treats a bind mount to the same device as being on the same filesystem. **NB** This flag is only available on Unix based systems. On systems where it isn't supported (e.g. Windows) it will be ignored. ### Advanced options Here are the Advanced options specific to local (Local Disk). #### --local-nounc Disable UNC (long path names) conversion on Windows. Properties: - Config: nounc - Env Var: RCLONE_LOCAL_NOUNC - Type: bool - Default: false - Examples: - "true" - Disables long file names. #### --copy-links / -L Follow symlinks and copy the pointed to item. Properties: - Config: copy_links - Env Var: RCLONE_LOCAL_COPY_LINKS - Type: bool - Default: false #### --local-links Translate symlinks to/from regular files with a '.rclonelink' extension for the local backend. Properties: - Config: links - Env Var: RCLONE_LOCAL_LINKS - Type: bool - Default: false #### --skip-links Don't warn about skipped symlinks. This flag disables warning messages on skipped symlinks or junction points, as you explicitly acknowledge that they should be skipped. Properties: - Config: skip_links - Env Var: RCLONE_LOCAL_SKIP_LINKS - Type: bool - Default: false #### --local-zero-size-links Assume the Stat size of links is zero (and read them instead) (deprecated). Rclone used to use the Stat size of links as the link size, but this fails in quite a few places: - Windows - On some virtual filesystems (such ash LucidLink) - Android So rclone now always reads the link. Properties: - Config: zero_size_links - Env Var: RCLONE_LOCAL_ZERO_SIZE_LINKS - Type: bool - Default: false #### --local-unicode-normalization Apply unicode NFC normalization to paths and filenames. This flag can be used to normalize file names into unicode NFC form that are read from the local filesystem. Rclone does not normally touch the encoding of file names it reads from the file system. This can be useful when using macOS as it normally provides decomposed (NFD) unicode which in some language (eg Korean) doesn't display properly on some OSes. Note that rclone compares filenames with unicode normalization in the sync routine so this flag shouldn't normally be used. Properties: - Config: unicode_normalization - Env Var: RCLONE_LOCAL_UNICODE_NORMALIZATION - Type: bool - Default: false #### --local-no-check-updated Don't check to see if the files change during upload. Normally rclone checks the size and modification time of files as they are being uploaded and aborts with a message which starts "can't copy - source file is being updated" if the file changes during upload. However on some file systems this modification time check may fail (e.g. [Glusterfs #2206](https://github.com/rclone/rclone/issues/2206)) so this check can be disabled with this flag. If this flag is set, rclone will use its best efforts to transfer a file which is being updated. If the file is only having things appended to it (e.g. a log) then rclone will transfer the log file with the size it had the first time rclone saw it. If the file is being modified throughout (not just appended to) then the transfer may fail with a hash check failure. In detail, once the file has had stat() called on it for the first time we: - Only transfer the size that stat gave - Only checksum the size that stat gave - Don't update the stat info for the file **NB** do not use this flag on a Windows Volume Shadow (VSS). For some unknown reason, files in a VSS sometimes show different sizes from the directory listing (where the initial stat value comes from on Windows) and when stat is called on them directly. Other copy tools always use the direct stat value and setting this flag will disable that. Properties: - Config: no_check_updated - Env Var: RCLONE_LOCAL_NO_CHECK_UPDATED - Type: bool - Default: false #### --one-file-system / -x Don't cross filesystem boundaries (unix/macOS only). Properties: - Config: one_file_system - Env Var: RCLONE_LOCAL_ONE_FILE_SYSTEM - Type: bool - Default: false #### --local-case-sensitive Force the filesystem to report itself as case sensitive. Normally the local backend declares itself as case insensitive on Windows/macOS and case sensitive for everything else. Use this flag to override the default choice. Properties: - Config: case_sensitive - Env Var: RCLONE_LOCAL_CASE_SENSITIVE - Type: bool - Default: false #### --local-case-insensitive Force the filesystem to report itself as case insensitive. Normally the local backend declares itself as case insensitive on Windows/macOS and case sensitive for everything else. Use this flag to override the default choice. Properties: - Config: case_insensitive - Env Var: RCLONE_LOCAL_CASE_INSENSITIVE - Type: bool - Default: false #### --local-no-clone Disable reflink cloning for server-side copies. Normally, for local-to-local transfers, rclone will "clone" the file when possible, and fall back to "copying" only when cloning is not supported. Cloning creates a shallow copy (or "reflink") which initially shares blocks with the original file. Unlike a "hardlink", the two files are independent and neither will affect the other if subsequently modified. Cloning is usually preferable to copying, as it is much faster and is deduplicated by default (i.e. having two identical files does not consume more storage than having just one.) However, for use cases where data redundancy is preferable, --local-no-clone can be used to disable cloning and force "deep" copies. Currently, cloning is only supported when using APFS on macOS (support for other platforms may be added in the future.) Properties: - Config: no_clone - Env Var: RCLONE_LOCAL_NO_CLONE - Type: bool - Default: false #### --local-no-preallocate Disable preallocation of disk space for transferred files. Preallocation of disk space helps prevent filesystem fragmentation. However, some virtual filesystem layers (such as Google Drive File Stream) may incorrectly set the actual file size equal to the preallocated space, causing checksum and file size checks to fail. Use this flag to disable preallocation. Properties: - Config: no_preallocate - Env Var: RCLONE_LOCAL_NO_PREALLOCATE - Type: bool - Default: false #### --local-no-sparse Disable sparse files for multi-thread downloads. On Windows platforms rclone will make sparse files when doing multi-thread downloads. This avoids long pauses on large files where the OS zeros the file. However sparse files may be undesirable as they cause disk fragmentation and can be slow to work with. Properties: - Config: no_sparse - Env Var: RCLONE_LOCAL_NO_SPARSE - Type: bool - Default: false #### --local-no-set-modtime Disable setting modtime. Normally rclone updates modification time of files after they are done uploading. This can cause permissions issues on Linux platforms when the user rclone is running as does not own the file uploaded, such as when copying to a CIFS mount owned by another user. If this option is enabled, rclone will no longer update the modtime after copying a file. Properties: - Config: no_set_modtime - Env Var: RCLONE_LOCAL_NO_SET_MODTIME - Type: bool - Default: false #### --local-time-type Set what kind of time is returned. Normally rclone does all operations on the mtime or Modification time. If you set this flag then rclone will return the Modified time as whatever you set here. So if you use "rclone lsl --local-time-type ctime" then you will see ctimes in the listing. If the OS doesn't support returning the time_type specified then rclone will silently replace it with the modification time which all OSes support. - mtime is supported by all OSes - atime is supported on all OSes except: plan9, js - btime is only supported on: Windows, macOS, freebsd, netbsd - ctime is supported on all Oses except: Windows, plan9, js Note that setting the time will still set the modified time so this is only useful for reading. Properties: - Config: time_type - Env Var: RCLONE_LOCAL_TIME_TYPE - Type: mtime|atime|btime|ctime - Default: mtime - Examples: - "mtime" - The last modification time. - "atime" - The last access time. - "btime" - The creation time. - "ctime" - The last status change time. #### --local-hashes Comma separated list of supported checksum types. Properties: - Config: hashes - Env Var: RCLONE_LOCAL_HASHES - Type: CommaSepList - Default: #### --local-encoding The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Properties: - Config: encoding - Env Var: RCLONE_LOCAL_ENCODING - Type: Encoding - Default: Slash,Dot #### --local-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_LOCAL_DESCRIPTION - Type: string - Required: false ### Metadata Depending on which OS is in use the local backend may return only some of the system metadata. Setting system metadata is supported on all OSes but setting user metadata is only supported on linux, freebsd, netbsd, macOS and Solaris. It is **not** supported on Windows yet ([see pkg/attrs#47](https://github.com/pkg/xattr/issues/47)). User metadata is stored as extended attributes (which may not be supported by all file systems) under the "user.*" prefix. Metadata is supported on files and directories. Here are the possible system metadata items for the local backend. | Name | Help | Type | Example | Read Only | |------|------|------|---------|-----------| | atime | Time of last access | RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | N | | btime | Time of file birth (creation) | RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | N | | gid | Group ID of owner | decimal number | 500 | N | | mode | File type and mode | octal, unix style | 0100664 | N | | mtime | Time of last modification | RFC 3339 | 2006-01-02T15:04:05.999999999Z07:00 | N | | rdev | Device ID (if special file) | hexadecimal | 1abc | N | | uid | User ID of owner | decimal number | 500 | N | See the [metadata](https://rclone.org/docs/#metadata) docs for more info. ## Backend commands Here are the commands specific to the local backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the [backend](https://rclone.org/commands/rclone_backend/) command for more info on how to pass options and arguments. These can be run on a running backend using the rc command [backend/command](https://rclone.org/rc/#backend-command). ### noop A null operation for testing backend commands rclone backend noop remote: [options] [+] This is a test command which has some options you can try to change the output. Options: - "echo": echo the input arguments - "error": return an error based on option value # Changelog ## v1.71.0 - 2025-08-22 [See commits](https://github.com/rclone/rclone/compare/v1.70.0...v1.71.0) - New S3 providers - [Exaba](https://rclone.org/s3/#exaba) (Nick Craig-Wood) - We've been working with Exaba and they would love early adopters, self-hosters and testers - [OVHcloud Object Storage](https://rclone.org/s3/#ovhcloud) (Florent Vennetier) - [Zata](https://rclone.org/s3/#Zata) ($@M@RTH_) - New Features - Allow [global config to be overriden or set on backend creation](https://rclone.org/docs/#globalconfig) (Nick Craig-Wood) - bisync: Promoted from beta to stable (nielash) - build - Update to go1.25 and make go1.24 the minimum required version (Nick Craig-Wood) - Update all dependencies (Nick Craig-Wood) - Upgrade golangci-lint to v2 and fix code and config (albertony) - Add markdown linting to workflow and fix all the docs (albertony) - Extend check for edits of autogenerated files to all commits in a pull request (albertony) - Set default shell to bash in build.yml (Ross Smith II) - config - Make parsing of `Duration` options consistent (albertony) - Add error if `RCLONE_CONFIG_PASS` was supplied it but didn't decrypt the config (n4n5) - copy, copyto: Implement logger flags to store result of sync (Marvin Rösch) - doc fixes (albertony, Ali Zein Yousuf, Binbin Qian, curlwget, Ed Craig-Wood, jinjingroad, Lucas Bremgartner, n4n5, Nick Craig-Wood) - hash: Add support for BLAKE3, XXH3, XXH128 (albertony) - http - Add `--client-pass` support for encrypted `--client-key` files (Nick Craig-Wood) - Allow setting of `--http-proxy` from the command line (Nick Craig-Wood) - lib/mmap: Convert to using unsafe.Slice to avoid deprecated reflect.SliceHeader (cui) - lib/transform: Avoid empty charmap entry (albertony) - log: Add log rotation options when using [`--log-file`](https://rclone.org/docs/#log-file-string) (Nick Craig-Wood) - move, moveto: Implement logger flags to store result of sync (Marvin Rösch) - pool: Unify memory between multipart and asyncreader to use one pool (Nick Craig-Wood) - purge: Exit with a fatal error if filters are set on `rclone purge` (Nick Craig-Wood) - rc - Add `config/unlock` to unlock the config file (n4n5) - Fix `config/listremotes` to send an empty array instead of nil (n4n5) - Populate transfer snapshot with "what" value (Timothy Jacobs) - serve sftp: Add support for more hashes (crc32, sha256, blake3, xxh3, xxh128) (albertony) - transform: Add `truncate_keep_extension` and `truncate_bytes` (nielash) - Bug Fixes - about: Fix potential overflow of about in various backends (Nick Craig-Wood) - accounting - Fix incorrect stats with `--transfers=1` (Yu Xin) - Fix stats (`speed=0` and `eta=nil`) when starting jobs via rc (Nick Craig-Wood) - bisync - Fix concurrent runs via rc (nielash) - Fix `--no-slow-hash` settings on path2 (nielash) - config: fix problem reading pasted tokens over 4095 bytes (Nick Craig-Wood) - oauthutil: Fix nil pointer crash when started with expired token (Nick Craig-Wood) - operations: Fix too many connections open when using `--max-buffer-memory` (Nick Craig-Wood) - pool: Fix deadlock with `--max-buffer-memory` and multipart transfers (Nick Craig-Wood) - rc: Fix `operations/check` ignoring `oneWay` parameter (houance) - Mount - Fix identification of symlinks in directory listings (huangnauh) - Local - Configurable supported hashes (albertony) - Fix `--copy-links` on Windows when listing Junction points (Anagh Kumar Baranwal) - Azure Blob - Add support for client assertion based authentication (Vikas Bhansali) - Fix deadlock with `--max-connections` with `InvalidBlockOrBlob` errors (Nick Craig-Wood) - Fix double accounting for multipart uploads (Nick Craig-Wood) - Azurefiles - Add support for client assertion based authentication (Vikas Bhansali) - Fix hash getting erased when modtime is set (nielash) - Box - Fix about: cannot unmarshal number 1.0e+18 into Go struct field (Nick Craig-Wood) - Combine - Fix directory not found errors with ListP interface (Nick Craig-Wood) - Filescom - Document that hashes need to be enabled (Nick Craig-Wood) - FTP - Allow insecure TLS ciphers (Anagh Kumar Baranwal) - Make TLS config default to global TLS config (Nick Craig-Wood) - This allows `--ca-cert`, `--client-cert` etc to be used. - This also allows `override.ca_cert = XXX` to be used in the config file. - Googlephotos - Added warning for Google Photos compatability-fixes (raider13209) - Imagekit - Return correct error when attempting to upload zero length files (Nick Craig-Wood) - Don't low level retry uploads (Nick Craig-Wood) - Remove server side Copy method as it was downloading and uploading (Nick Craig-Wood) - Internetarchive - Fix server side copy of files with `&` (Nick Craig-Wood) - Mega - Fix tls handshake failure (necaran) - Oracleobjectstorage - Add read only metadata support (praveen-solanki-oracle) - Pikpak - Rewrite upload to bypass AWS S3 manager (wiserain) - Enhance Move for better handling of error and name collision (wiserain) - Enhance Copy method to handle name collisions and improve error management (wiserain) - Add file name integrity check during upload (wiserain) - S3 - Add `--s3-use-arn-region` flag (Nick Craig-Wood) - Fix memory leak by cloning strings (liubingrun) - Fix multipart upload and server side copy when using bucket policy SSE-C (Albin Parou) - Fix `Content-Type: aws-chunked` causing upload errors with `--metadata` (Nick Craig-Wood) - SFTP - Add support for more hashes (crc32, sha256, blake3, xxh3, xxh128) (albertony) - Smb - Add `--smb-kerberos-ccache` option to set kerberos ccache per smb backend (Sudipto Baral) - Refresh Kerberos credentials when ccache file changes (Sudipto Baral) - Improve multithreaded upload performance using multiple connections (Sudipto Baral) ## v1.70.3 - 2025-07-09 [See commits](https://github.com/rclone/rclone/compare/v1.70.2...v1.70.3) - Bug Fixes - check: Fix difference report (was reporting error counts) (albertony) - march: Fix deadlock when using `--no-traverse` (Nick Craig-Wood) - doc fixes (albertony, Nick Craig-Wood) - Azure Blob - Fix server side copy error "requires exactly one scope" (Nick Craig-Wood) - B2 - Fix finding objects when using `--b2-version-at` (Davide Bizzarri) - Linkbox - Fix upload error "user upload file not exist" (Nick Craig-Wood) - Pikpak - Improve error handling for missing links and unrecoverable 500s (wiserain) - WebDAV - Fix setting modtime to that of local object instead of remote (WeidiDeng) ## v1.70.2 - 2025-06-27 [See commits](https://github.com/rclone/rclone/compare/v1.70.1...v1.70.2) - Bug Fixes - convmv: Make --dry-run logs less noisy (nielash) - sync: Avoid copying dir metadata to itself (nielash) - build: Bump github.com/go-chi/chi/v5 from 5.2.1 to 5.2.2 to fix GHSA-vrw8-fxc6-2r93 (dependabot[bot]) - convmv: Fix moving to unicode-equivalent name (nielash) - log: Fix deadlock when using systemd logging (Nick Craig-Wood) - pacer: Fix nil pointer deref in RetryError (Nick Craig-Wood) - doc fixes (Ali Zein Yousuf, Nick Craig-Wood) - Local - Fix --skip-links on Windows when skipping Junction points (Nick Craig-Wood) ## v1.70.1 - 2025-06-19 [See commits](https://github.com/rclone/rclone/compare/v1.70.0...v1.70.1) - Bug Fixes - convmv: Fix spurious "error running command echo" on Windows (Nick Craig-Wood) - doc fixes (albertony, Ed Craig-Wood, jinjingroad) ## v1.70.0 - 2025-06-17 [See commits](https://github.com/rclone/rclone/compare/v1.69.0...v1.70.0) - New backends - [DOI](https://rclone.org/doi/) (Flora Thiebaut) - [FileLu](https://rclone.org/filelu/) (kingston125) - New S3 providers: - [MEGA S4](https://rclone.org/s3/#mega) (Nick Craig-Wood) - [Pure Storage FlashBlade](https://rclone.org/s3/#pure-storage-flashblade) (Jeremy Daer) - New commands - [convmv](https://rclone.org/commands/rclone_convmv/): for moving and transforming files (nielash) - New Features - Add [`--max-connections`](https://rclone.org/docs/#max-connections-n) to control maximum backend concurrency (Nick Craig-Wood) - Add [`--max-buffer-memory`](https://rclone.org/docs/#max-buffer-memory) to limit total buffer memory usage (Nick Craig-Wood) - Add transform library and [`--name-transform`](https://rclone.org/docs/#name-transform-stringarray) flag (nielash) - sync: Implement [`--list-cutoff`](https://rclone.org/docs/#list-cutoff) to allow on disk sorting for reduced memory use (Nick Craig-Wood) - accounting: Add listed stat for number of directory entries listed (Nick Craig-Wood) - backend: Skip hash calculation when the hashType is None (Oleksiy Stashok) - build - Update to go1.24 and make go1.22 the minimum required version (Nick Craig-Wood) - Disable docker builds on PRs & add missing dockerfile changes (Anagh Kumar Baranwal) - Modernize Go usage (Nick Craig-Wood) - Update all dependencies (Nick Craig-Wood) - cmd/authorize: Show required arguments in help text (simwai) - cmd/config: add `--no-output` option (Jess) - cmd/gitannex - Tweak parsing of "rcloneremotename" config (Dan McArdle) - Permit remotes with options (Dan McArdle) - Reject unknown layout modes in INITREMOTE (Dan McArdle) - docker image: Add label org.opencontainers.image.source for release notes in Renovate dependency updates (Robin Schneider) - doc fixes (albertony, Andrew Kreimer, Ben Boeckel, Christoph Berger, Danny Garside, Dimitri Papadopoulos, eccoisle, Ed Craig-Wood, Fernando Fernández, jack, Jeff Geerling, Jugal Kishore, kingston125, luzpaz, Markus Gerstel, Matt Ickstadt, Michael Kebe, Nick Craig-Wood, PrathameshLakawade, Ser-Bul, simonmcnair, Tim White, Zachary Vorhies) - filter: - Add `--hash-filter` to deterministically select a subset of files (Nick Craig-Wood) - Show `--min-size` and `--max-size` in `--dump` filters (Nick Craig-Wood) - hash: Add SHA512 support for file hashes (Enduriel) - http servers: Add `--user-from-header` to use for authentication (Moises Lima) - lib/batcher: Deprecate unused option: batch_commit_timeout (Dan McArdle) - log: - Remove github.com/sirupsen/logrus and replace with log/slog (Nick Craig-Wood) - Add `--windows-event-log-level` to support Windows Event Log (Nick Craig-Wood) - rc - Add add `short` parameter to `core/stats` to not return transferring and checking (Nick Craig-Wood) - In `options/info` make FieldName contain a "." if it should be nested (Nick Craig-Wood) - Add rc control for serve commands (Nick Craig-Wood) - rcserver: Improve content-type check (Jonathan Giannuzzi) - serve nfs - Update docs to note Windows is not supported (Zachary Vorhies) - Change the format of `--nfs-cache-type symlink` file handles (Nick Craig-Wood) - Make metadata files have special file handles (Nick Craig-Wood) - touch: Make touch obey `--transfers` (Nick Craig-Wood) - version: Add `--deps` flag to show dependencies and other build info (Nick Craig-Wood) - Bug Fixes - serve s3: - Fix ListObjectsV2 response (fhuber) - Remove redundant handler initialization (Tho Neyugn) - stats: Fix goroutine leak and improve stats accounting process (Nathanael Demacon) - VFS - Add `--vfs-metadata-extension` to expose metadata sidecar files (Nick Craig-Wood) - Azure Blob - Add support for `x-ms-tags` header (Trevor Starick) - Cleanup uncommitted blocks on upload errors (Nick Craig-Wood) - Speed up server side copies for small files (Nick Craig-Wood) - Implement multipart server side copy (Nick Craig-Wood) - Remove uncommitted blocks on InvalidBlobOrBlock error (Nick Craig-Wood) - Fix handling of objects with // in (Nick Craig-Wood) - Handle retry error codes more carefully (Nick Craig-Wood) - Fix errors not being retried when doing single part copy (Nick Craig-Wood) - Fix multipart server side copies of 0 sized files (Nick Craig-Wood) - Azurefiles - Add `--azurefiles-use-az` and `--azurefiles-disable-instance-discovery` (b-wimmer) - B2 - Add SkipDestructive handling to backend commands (Pat Patterson) - Use file id from listing when not presented in headers (ahxxm) - Cloudinary - Automatically add/remove known media files extensions (yuval-cloudinary) - Var naming convention (yuval-cloudinary) - Drive - Added `backend moveid` command (Spencer McCullough) - Dropbox - Support Dropbox Paper (Dave Vasilevsky) - FTP - Add `--ftp-http-proxy` to connect via HTTP CONNECT proxy - Gofile - Update to use new direct upload endpoint (wbulot) - Googlephotos - Update read only and read write scopes to meet Google's requirements. (Germán Casares) - Iclouddrive - Fix panic and files potentially downloaded twice (Clément Wehrung) - Internetarchive - Add `--internetarchive-metadata="key=value"` for setting item metadata (Corentin Barreau) - Onedrive - Fix "The upload session was not found" errors (Nick Craig-Wood) - Re-add `--onedrive-upload-cutoff` flag (Nick Craig-Wood) - Fix crash if no metadata was updated (Nick Craig-Wood) - Opendrive - Added `--opendrive-access` flag to handle permissions (Joel K Biju) - Pcloud - Fix "Access denied. You do not have permissions to perform this operation" on large uploads (Nick Craig-Wood) - S3 - Fix handling of objects with // in (Nick Craig-Wood) - Add IBM IAM signer (Alexander Minbaev) - Split the GCS quirks into `--s3-use-x-id` and `--s3-sign-accept-encoding` (Nick Craig-Wood) - Implement paged listing interface ListP (Nick Craig-Wood) - Add Pure Storage FlashBlade provider support (Jeremy Daer) - Require custom endpoint for Lyve Cloud v2 support (PrathameshLakawade) - MEGA S4 support (Nick Craig-Wood) - SFTP - Add `--sftp-http-proxy` to connect via HTTP CONNECT proxy (Nick Craig-Wood) - Smb - Add support for kerberos authentication (Jonathan Giannuzzi) - Improve connection pooling efficiency (Jonathan Giannuzzi) - WebDAV - Retry propfind on 425 status (Jörn Friedrich Dreyer) - Add an ownCloud Infinite Scale vendor that enables tus chunked upload support (Klaas Freitag) ## v1.69.3 - 2025-05-21 [See commits](https://github.com/rclone/rclone/compare/v1.69.2...v1.69.3) - Bug Fixes - build: Reapply update github.com/golang-jwt/jwt/v5 from 5.2.1 to 5.2.2 to fix CVE-2025-30204 (dependabot[bot]) - build: Update github.com/ebitengine/purego to work around bug in go1.24.3 (Nick Craig-Wood) ## v1.69.2 - 2025-05-01 [See commits](https://github.com/rclone/rclone/compare/v1.69.1...v1.69.2) - Bug fixes - accounting: Fix percentDiff calculation -- (Anagh Kumar Baranwal) - build - Update github.com/golang-jwt/jwt/v4 from 4.5.1 to 4.5.2 to fix CVE-2025-30204 (dependabot[bot]) - Update github.com/golang-jwt/jwt/v5 from 5.2.1 to 5.2.2 to fix CVE-2025-30204 (dependabot[bot]) - Update golang.org/x/crypto to v0.35.0 to fix CVE-2025-22869 (Nick Craig-Wood) - Update golang.org/x/net from 0.36.0 to 0.38.0 to fix CVE-2025-22870 (dependabot[bot]) - Update golang.org/x/net to 0.36.0. to fix CVE-2025-22869 (dependabot[bot]) - Stop building with go < go1.23 as security updates forbade it (Nick Craig-Wood) - Fix docker plugin build (Anagh Kumar Baranwal) - cmd: Fix crash if rclone is invoked without any arguments (Janne Hellsten) - config: Read configuration passwords from stdin even when terminated with EOF (Samantha Bowen) - doc fixes (Andrew Kreimer, Danny Garside, eccoisle, Ed Craig-Wood, emyarod, jack, Jugal Kishore, Markus Gerstel, Michael Kebe, Nick Craig-Wood, simonmcnair, simwai, Zachary Vorhies) - fs: Fix corruption of SizeSuffix with "B" suffix in config (eg --min-size) (Nick Craig-Wood) - lib/http: Fix race between Serve() and Shutdown() (Nick Craig-Wood) - object: Fix memory object out of bounds Seek (Nick Craig-Wood) - operations: Fix call fmt.Errorf with wrong err (alingse) - rc - Disable the metrics server when running `rclone rc` (hiddenmarten) - Fix debug/* commands not being available over unix sockets (Nick Craig-Wood) - serve nfs: Fix unlikely crash (Nick Craig-Wood) - stats: Fix the speed not getting updated after a pause in the processing (Anagh Kumar Baranwal) - sync - Fix cpu spinning when empty directory finding with leading slashes (Nick Craig-Wood) - Copy dir modtimes even when copyEmptySrcDirs is false (ll3006) - VFS - Fix directory cache serving stale data (Lorenz Brun) - Fix inefficient directory caching when directory reads are slow (huanghaojun) - Fix integration test failures (Nick Craig-Wood) - Drive - Metadata: fix error when setting copy-requires-writer-permission on a folder (Nick Craig-Wood) - Dropbox - Retry link without expiry (Dave Vasilevsky) - HTTP - Correct root if definitely pointing to a file (nielash) - Iclouddrive - Fix so created files are writable (Ben Alex) - Onedrive - Fix metadata ordering in permissions (Nick Craig-Wood) ## v1.69.1 - 2025-02-14 [See commits](https://github.com/rclone/rclone/compare/v1.69.0...v1.69.1) - Bug Fixes - lib/oauthutil: Fix redirect URL mismatch errors (Nick Craig-Wood) - bisync: Fix listings missing concurrent modifications (nielash) - serve s3: Fix list objects encoding-type (Nick Craig-Wood) - fs: Fix confusing "didn't find section in config file" error (Nick Craig-Wood) - doc fixes (Christoph Berger, Dimitri Papadopoulos, Matt Ickstadt, Nick Craig-Wood, Tim White, Zachary Vorhies) - build: Added parallel docker builds and caching for go build in the container (Anagh Kumar Baranwal) - VFS - Fix the cache failing to upload symlinks when `--links` was specified (Nick Craig-Wood) - Fix race detected by race detector (Nick Craig-Wood) - Close the change notify channel on Shutdown (izouxv) - B2 - Fix "fatal error: concurrent map writes" (Nick Craig-Wood) - Iclouddrive - Add notes on ADP and Missing PCS cookies (Nick Craig-Wood) - Onedrive - Mark German (de) region as deprecated (Nick Craig-Wood) - S3 - Added new storage class to magalu provider (Bruno Fernandes) - Add DigitalOcean regions SFO2, LON1, TOR1, BLR1 (jkpe) - Add latest Linode Object Storage endpoints (jbagwell-akamai) ## v1.69.0 - 2025-01-12 [See commits](https://github.com/rclone/rclone/compare/v1.68.0...v1.69.0) - New backends - [ICloud Drive](https://rclone.org/iclouddrive/) (lostb1t) - [Cloudinary](https://rclone.org/cloudinary/) (yuval-cloudinary) - New S3 providers: - [Outscale](https://rclone.org/s3/#outscale) (Matthias Gatto) - [Selectel](https://rclone.org/s3/#selectel) (Nick Craig-Wood) - Security fixes - serve sftp: Resolve CVE-2024-45337 - Misuse of ServerConfig.PublicKeyCallback may cause authorization bypass (dependabot) - Rclone was **not** vulnerable to this. - See - build: Update golang.org/x/net to v0.33.0 to fix CVE-2024-45338 - Non-linear parsing of case-insensitive content (Nick Craig-Wood) - Rclone was **not** vulnerable to this. - See - New Features - accounting: Write the current bwlimit to the log on SIGUSR2 (Nick Craig-Wood) - bisync: Change exit code from 2 to 7 for critically aborted run (albertony) - build - Update all dependencies (Nick Craig-Wood) - Replace Windows-specific `NewLazyDLL` with `NewLazySystemDLL` (albertony) - cmd: Change exit code from 1 to 2 for syntax and usage errors (albertony) - docker serve: make sure all mount and VFS options are parsed (Nick Craig-Wood) - doc fixes (albertony, Alexandre Hamez, Anthony Metzidis, buengese, Dan McArdle, David Seifert, Francesco Frassinelli, Michael R. Davis, Nick Craig-Wood, Pawel Palucha, Randy Bush, remygrandin, Sam Harrison, shenpengfeng, tgfisher, Thomas ten Cate, ToM, Tony Metzidis, vintagefuture, Yxxx) - fs: Make `--links` flag global and add new `--local-links` and `--vfs-links` flags (Nick Craig-Wood) - http servers: Disable automatic authentication skipping for unix sockets in http servers (Moises Lima) - This was making it impossible to use unix sockets with an proxy - This might now cause rclone to need authentication where it didn't before - oauthutil: add support for OAuth client credential flow (Martin Hassack, Nick Craig-Wood) - operations: make log messages consistent for mkdir/rmdir at INFO level (Nick Craig-Wood) - rc: Add `relative` to [vfs/queue-set-expiry](https://rclone.org/rc/#vfs-queue-set-expiry) (Nick Craig-Wood) - serve dlna: Sort the directory entries by directories first then alphabetically by name (Nick Craig-Wood) - serve nfs - Introduce symlink support (Nick Craig-Wood) - Implement `--nfs-cache-type` symlink (Nick Craig-Wood) - size: Make output compatible with `-P` (Nick Craig-Wood) - test makefiles: Add `--flat` flag for making directories with many entries (Nick Craig-Wood) - Bug Fixes - accounting - Fix global error acounting (Benjamin Legrand) - Fix debug printing when debug wasn't set (Nick Craig-Wood) - Fix race stopping/starting the stats counter (Nick Craig-Wood) - rc/job: Use mutex for adding listeners thread safety (hayden.pan) - serve docker: Fix incorrect GID assignment (TAKEI Yuya) - serve nfs: Fix missing inode numbers which was messing up `ls -laR` (Nick Craig-Wood) - serve s3: Fix `Last-Modified` timestamp (Nick Craig-Wood) - serve sftp: Fix loading of authorized keys file with comment on last line (albertony) - Mount - Introduce symlink support (Filipe Azevedo, Nick Craig-Wood) - Better snap mount error message (divinity76) - mount2: Fix missing `.` and `..` entries (Filipe Azevedo) - VFS - With `--vfs-used-is-size` value is calculated and then thrown away (Ilias Ozgur Can Leonard) - Add symlink support to VFS (Filipe Azevedo, Nick Craig-Wood) - This can be enabled with the specific `--vfs-links` flag or the global `--links` flag - Fix open files disappearing from directory listings (Nick Craig-Wood) - Add remote name to vfs cache log messages (Nick Craig-Wood) - Cache - Fix parent not getting pinned when remote is a file (nielash) - Azure Blob - Add `--azureblob-disable-instance-discovery` (Nick Craig-Wood) - Add `--azureblob-use-az` to force the use of the Azure CLI for auth (Nick Craig-Wood) - Quit multipart uploads if the context is cancelled (Nick Craig-Wood) - Azurefiles - Fix missing x-ms-file-request-intent header (Nick Craig-Wood) - B2 - Add `daysFromStartingToCancelingUnfinishedLargeFiles` to `backend lifecycle` command (Louis Laureys) - Box - Fix server-side copying a file over existing dst (nielash) - Fix panic when decoding corrupted PEM from JWT file (Nick Craig-Wood) - Drive - Add support for markdown format (Noam Ross) - Implement `rclone backend rescue` to rescue orphaned files (Nick Craig-Wood) - Dropbox - Fix server side copying over existing object (Nick Craig-Wood) - Fix return status when full to be fatal error (Nick Craig-Wood) - FTP - Implement `--ftp-no-check-upload` to allow upload to write only dirs (Nick Craig-Wood) - Fix ls commands returning empty on "Microsoft FTP Service" servers (Francesco Frassinelli) - Gofile - Fix server side copying over existing object (Nick Craig-Wood) - Google Cloud Storage - Add access token auth with `--gcs-access-token` (Leandro Piccilli) - Update docs on service account access tokens (Anthony Metzidis) - Googlephotos - Implement `--gphotos-proxy` to allow download of full resolution media (Nick Craig-Wood) - Fix nil pointer crash on upload (Nick Craig-Wood) - HTTP - Fix incorrect URLs with initial slash (Oleg Kunitsyn) - Onedrive - Add support for OAuth client credential flow (Martin Hassack, Nick Craig-Wood) - Fix time precision for OneDrive personal (Nick Craig-Wood) - Fix server side copying over existing object (Nick Craig-Wood) - Opendrive - Add `rclone about` support to backend (quiescens) - Oracle Object Storage - Make specifying `compartmentid` optional (Manoj Ghosh) - Quit multipart uploads if the context is cancelled (Nick Craig-Wood) - Pikpak - Add option to use original file links (wiserain) - Protondrive - Improve performance of Proton Drive backend (Lawrence Murray) - Putio - Fix server side copying over existing object (Nick Craig-Wood) - S3 - Add initial `--s3-directory-bucket` to support AWS Directory Buckets (Nick Craig-Wood) - Add Wasabi `eu-south-1` region (Diego Monti) - Fix download of compressed files from Cloudflare R2 (Nick Craig-Wood) - Rename glacier storage class to flexible retrieval (Henry Lee) - Quit multipart uploads if the context is cancelled (Nick Craig-Wood) - SFTP - Allow inline ssh public certificate for sftp (Dimitar Ivanov) - Fix nil check when using auth proxy (Nick Craig-Wood) - Smb - Add initial support for Kerberos authentication (more work needed). (Francesco Frassinelli) - Fix panic if stat fails (Nick Craig-Wood) - Sugarsync - Fix server side copying over existing object (Nick Craig-Wood) - WebDAV - Nextcloud: implement backoff and retry for 423 LOCKED errors (Nick Craig-Wood) - Make `--webdav-auth-redirect` to fix 401 unauthorized on redirect (Nick Craig-Wood) - Yandex - Fix server side copying over existing object (Nick Craig-Wood) - Zoho - Use download server to accelerate downloads (buengese) - Switch to large file upload API for larger files, fix missing URL encoding of filenames for the upload API (buengese) - Print clear error message when missing oauth scope (buengese) - Try to handle rate limits a bit better (buengese) - Add support for private spaces (buengese) - Make upload cutoff configurable (buengese) ## v1.68.2 - 2024-11-15 [See commits](https://github.com/rclone/rclone/compare/v1.68.1...v1.68.2) - Security fixes - local backend: CVE-2024-52522: fix permission and ownership on symlinks with `--links` and `--metadata` (Nick Craig-Wood) - Only affects users using `--metadata` and `--links` and copying files to the local backend - See - build: bump github.com/golang-jwt/jwt/v4 from 4.5.0 to 4.5.1 (dependabot) - This is an issue in a dependency which is used for JWT certificates - See - Bug Fixes - accounting: Fix wrong message on SIGUSR2 to enable/disable bwlimit (Nick Craig-Wood) - bisync: Fix output capture restoring the wrong output for logrus (Dimitrios Slamaris) - dlna: Fix loggingResponseWriter disregarding log level (Simon Bos) - serve s3: Fix excess locking which was making serve s3 single threaded (Nick Craig-Wood) - doc fixes (Nick Craig-Wood, tgfisher, Alexandre Hamez, Randy Bush) - Local - Fix permission and ownership on symlinks with `--links` and `--metadata` (Nick Craig-Wood) - Fix `--copy-links` on macOS when cloning (nielash) - Onedrive - Fix Retry-After handling to look at 503 errors also (Nick Craig-Wood) - Pikpak - Fix cid/gcid calculations for fs.OverrideRemote (wiserain) - Fix fatal crash on startup with token that can't be refreshed (Nick Craig-Wood) - S3 - Fix crash when using `--s3-download-url` after migration to SDKv2 (Nick Craig-Wood) - Storj provider: fix server-side copy of files bigger than 5GB (Kaloyan Raev) - Fix multitenant multipart uploads with CEPH (Nick Craig-Wood) ## v1.68.1 - 2024-09-24 [See commits](https://github.com/rclone/rclone/compare/v1.68.0...v1.68.1) - Bug Fixes - build: Fix docker release build (ttionya) - doc fixes (Nick Craig-Wood, Pawel Palucha) - fs - Fix `--dump filters` not always appearing (Nick Craig-Wood) - Fix setting `stringArray` config values from environment variables (Nick Craig-Wood) - rc: Fix default value of `--metrics-addr` (Nick Craig-Wood) - serve docker: Add missing `vfs-read-chunk-streams` option in docker volume driver (Divyam) - Onedrive - Fix spurious "Couldn't decode error response: EOF" DEBUG (Nick Craig-Wood) - Pikpak - Fix login issue where token retrieval fails (wiserain) - S3 - Fix rclone ignoring static credentials when `env_auth=true` (Nick Craig-Wood) ## v1.68.0 - 2024-09-08 [See commits](https://github.com/rclone/rclone/compare/v1.67.0...v1.68.0) - New backends - [Files.com](/filescom) (Sam Harrison) - [Gofile](https://rclone.org/gofile/) (Nick Craig-Wood) - [Pixeldrain](https://rclone.org/pixeldrain/) (Fornax) - Changed backends - [S3](https://rclone.org/s3/) backend updated to use [AWS SDKv2](https://github.com/aws/aws-sdk-go-v2) as v1 is now unsupported. - The matrix of providers and auth methods is huge and there could be problems with obscure combinations. - Please report problems in a [new issue](https://github.com/rclone/rclone/issues/new/choose) on Github. - New commands - [config encryption](https://rclone.org/commands/rclone_config_encryption/): set, remove and check to manage config file encryption (Nick Craig-Wood) - New Features - build - Update to go1.23 and make go1.21 the minimum required version (Nick Craig-Wood) - Update all dependencies (Nick Craig-Wood) - Disable wasm/js build due to [go bug #64856](https://github.com/golang/go/issues/64856) (Nick Craig-Wood) - Enable custom linting rules with ruleguard via gocritic (albertony) - Update logging statements to make `--use-json-log` work always (albertony) - Adding new code quality tests and fixing the fallout (albertony) - config - Internal config re-organised to be more consistent and make it available from the rc (Nick Craig-Wood) - Avoid remotes with empty names from the environment (albertony) - Make listing of remotes more consistent (albertony) - Make getting config values more consistent (albertony) - Use `--password-command` to set config file password if supplied (Nick Craig-Wood) - doc fixes (albertony, crystalstall, David Seifert, Eng Zer Jun, Ernie Hershey, Florian Klink, John Oxley, kapitainsky, Mathieu Moreau, Nick Craig-Wood, nipil, Pétr Bozsó, Russ Bubley, Sam Harrison, Thearas, URenko, Will Miles, yuval-cloudinary) - fs: Allow semicolons as well as spaces in `--bwlimit` timetable parsing (Kyle Reynolds) - help - Global flags help command now takes glob filter (albertony) - Make help command output less distracting (albertony) - lib/encoder: Add Raw encoding for use where no encoding at all is required, eg `--local-encoding Raw` (URenko) - listremotes: Added options for filtering, ordering and json output (albertony) - nfsmount - Make the `--sudo` flag work for umount as well as mount (Nick Craig-Wood) - Add `-o tcp` option to NFS mount options to fix mounting under Linux (Nick Craig-Wood) - operations: copy: generate stable partial suffix (Georg Welzel) - rc - Add [options/info](https://rclone.org/rc/#options-info) call to enumerate options (Nick Craig-Wood) - Add option blocks parameter to [options/get](https://rclone.org/rc/#options-get) and [options/info](/rc/#options-info) (Nick Craig-Wood) - Add [vfs/queue](https://rclone.org/rc/#vfs-queue) to show the status of the upload queue (Nick Craig-Wood) - Add [vfs/queue-set-expiry](https://rclone.org/rc/#vfs-queue-set-expiry) to adjust expiry of items in the VFS queue (Nick Craig-Wood) - Add `--unix-socket` option to `rc` command (Florian Klink) - Prevent unmount rc command from sending a `STOPPING=1` sd-notify message (AThePeanut4) - rcserver: Implement [prometheus metrics](https://rclone.org/docs/#metrics) on a dedicated port (Oleg Kunitsyn) - serve dlna - Also look at "Subs" subdirectory (Florian Klink) - Don't swallow `video.{idx,sub}` (Florian Klink) - Set more correct mime type (Florian Klink) - serve nfs - Implement on disk cache for file handles selected with `--nfs-cache-type` (Nick Craig-Wood) - Add tracing to filesystem calls (Nick Craig-Wood) - Mask unimplemented error from chmod (Nick Craig-Wood) - Unify the nfs library logging with rclone's logging better (Nick Craig-Wood) - Fix incorrect user id and group id exported to NFS (Nick Craig-Wood) - serve s3 - Implement `--auth-proxy` (Sawjan Gurung) - Update to AWS SDKv2 by updating `github.com/rclone/gofakes3` (Nick Craig-Wood) - Bug Fixes - bisync: Fix sync time problems with backends that round time (eg Dropbox) (nielash) - serve dlna: Fix panic: invalid argument to Int63n (Nick Craig-Wood) - VFS - Add [--vfs-read-chunk-streams](https://rclone.org/commands/rclone_mount/#vfs-read-chunk-streams-0-1) to parallel read chunks from files (Nick Craig-Wood) - This can increase mount performance on high bandwidth or large latency links - Fix cache encoding with special characters (URenko) - Local - Fix encoding of root path fix (URenko) - Add server-side copy (using clone) with xattrs on macOS (nielash) - `--local-no-clone` flag to disable cloning for server-side copies (nielash) - Support setting custom `--metadata` during server-side Copy (nielash) - Azure Blob - Allow anonymous access for public resources (Nick Craig-Wood) - B2 - Include custom upload headers in large file info (Pat Patterson) - Drive - Fix copying Google Docs to a backend which only supports SHA1 (Nick Craig-Wood) - Fichier - Fix detection of Flood Detected error (Nick Craig-Wood) - Fix server side move (Nick Craig-Wood) - HTTP - Reload client certificates on expiry (Saleh Dindar) - Support listening on passed FDs (Florian Klink) - Jottacloud - Fix setting of metadata on server side move (albertony) - Onedrive - Fix nil pointer error when uploading small files (Nick Craig-Wood) - Pcloud - Implement `SetModTime` (Georg Welzel) - Implement `OpenWriterAt` feature to enable multipart uploads (Georg Welzel) - Fix failing large file uploads (Georg Welzel) - Pikpak - Improve data consistency by ensuring async tasks complete (wiserain) - Implement custom hash to replace wrong sha1 (wiserain) - Fix error with `copyto` command (wiserain) - Optimize file move by removing unnecessary `readMetaData()` call (wiserain) - Non-buffered hash calculation for local source files (wiserain) - Optimize upload by pre-fetching gcid from API (wiserain) - Correct file transfer progress for uploads by hash (wiserain) - Update to using AWS SDK v2 (wiserain) - S3 - Update to using AWS SDK v2 (Nick Craig-Wood) - Add `--s3-sdk-log-mode` to control SDKv2 debugging (Nick Craig-Wood) - Fix incorrect region for Magalu provider (Filipe Herculano) - Allow restoring from intelligent-tiering storage class (Pawel Palucha) - SFTP - Use `uint32` for mtime to save memory (Tomasz Melcer) - Ignore useless errors when closing the connection pool (Nick Craig-Wood) - Support listening on passed FDs (Florian Klink) - Swift - Add workarounds for bad listings in Ceph RGW (Paul Collins) - Add total/free space info in `about` command. (fsantagostinobietti) - Ulozto - Fix upload of > 2GB files on 32 bit platforms (Tobias Markus) - WebDAV - Add `--webdav-unix-socket-path` to connect to a unix socket (Florian Klink) - Yandex - Implement custom user agent to help with upload speeds (Sebastian Bünger) - Zoho - Fix inefficiencies uploading with new API to avoid throttling (Nick Craig-Wood) ## v1.67.0 - 2024-06-14 [See commits](https://github.com/rclone/rclone/compare/v1.66.0...v1.67.0) - New backends - [uloz.to](https://rclone.org/ulozto/) (iotmaestro) - New S3 providers - [Magalu Object Storage](https://rclone.org/s3/#magalu) (Bruno Fernandes) - New commands - [gitannex](https://rclone.org/commands/rclone_gitannex/): Enables git-annex to store and retrieve content from an rclone remote (Dan McArdle) - New Features - accounting: Add deleted files total size to status summary line (Kyle Reynolds) - build - Fix `CVE-2023-45288` by upgrading `golang.org/x/net` (Nick Craig-Wood) - Fix `CVE-2024-35255` by upgrading `github.com/Azure/azure-sdk-for-go/sdk/azidentity` to 1.6.0 (dependabot) - Convert source files with CRLF to LF (albertony) - Update all dependencies (Nick Craig-Wood) - doc updates (albertony, Alex Garel, Dave Nicolson, Dominik Joe Pantůček, Eric Wolf, Erisa A, Evan Harris, Evan McBeth, Gachoud Philippe, hidewrong, jakzoe, jumbi77, kapitainsky, Kyle Reynolds, Lewis Hook, Nick Craig-Wood, overallteach, pawsey-kbuckley, Pieter van Oostrum, psychopatt, racerole, static-moonlight, Warrentheo, yudrywet, yumeiyin ) - ncdu: Do not quit on Esc to aid usability (Katia Esposito) - rcserver: Set `ModTime` for dirs and files served by `--rc-serve` (Nikita Shoshin) - Bug Fixes - bisync: Add integration tests against all backends and fix many many problems (nielash) - config: Fix default value for `description` (Nick Craig-Wood) - copy: Fix `nil` pointer dereference when corrupted on transfer with `nil` dst (nielash) - fs - Improve JSON Unmarshalling for `Duration` types (Kyle Reynolds) - Close the CPU profile on exit (guangwu) - Replace `/bin/bash` with `/usr/bin/env bash` (Florian Klink) - oauthutil: Clear client secret if client ID is set (Michael Terry) - operations - Rework `rcat` so that it doesn't call the `--metadata-mapper` twice (Nick Craig-Wood) - Ensure `SrcFsType` is set correctly when using `--metadata-mapper` (Nick Craig-Wood) - Fix "optional feature not implemented" error with a crypted sftp bug (Nick Craig-Wood) - Fix very long file names when using copy with `--partial` (Nick Craig-Wood) - Fix retries downloading too much data with certain backends (Nick Craig-Wood) - Fix move when dst is nil and fdst is case-insensitive (nielash) - Fix lsjson `--encrypted` when using `--crypt-XXX` parameters (Nick Craig-Wood) - Fix missing metadata for multipart transfers to local disk (Nick Craig-Wood) - Fix incorrect modtime on some multipart transfers (Nick Craig-Wood) - Fix hashing problem in integration tests (Nick Craig-Wood) - rc - Fix stats groups being ignored in `operations/check` (Nick Craig-Wood) - Fix incorrect `Content-Type` in HTTP API (Kyle Reynolds) - serve s3 - Fix `Last-Modified` header format (Butanediol) - Fix in-memory metadata storing wrong modtime (nielash) - Fix XML of error message (Nick Craig-Wood) - serve webdav: Fix webdav with `--baseurl` under Windows (Nick Craig-Wood) - serve dlna: Make `BrowseMetadata` more compliant (albertony) - serve http: Added `Content-Length` header when HTML directory is served (Sunny) - sync - Don't sync directories if they haven't been modified (Nick Craig-Wood) - Don't test reading metadata if we can't write it (Nick Craig-Wood) - Fix case normalisation (problem on on s3) (Nick Craig-Wood) - Fix management of empty directories to make it more accurate (Nick Craig-Wood) - Fix creation of empty directories when `--create-empty-src-dirs=false` (Nick Craig-Wood) - Fix directory modification times not being set (Nick Craig-Wood) - Fix "failed to update directory timestamp or metadata: directory not found" (Nick Craig-Wood) - Fix expecting SFTP to have MkdirMetadata method: optional feature not implemented (Nick Craig-Wood) - test info: Improve cleanup of temp files (Kyle Reynolds) - touch: Fix using `-R` on certain backends (Nick Craig-Wood) - Mount - Add `--direct-io` flag to force uncached access (Nick Craig-Wood) - VFS - Fix download loop when file size shrunk (Nick Craig-Wood) - Fix renaming a directory (nielash) - Local - Add `--local-time-type` to use `mtime`/`atime`/`btime`/`ctime` as the time (Nick Craig-Wood) - Allow `SeBackupPrivilege` and/or `SeRestorePrivilege` to work on Windows (Charles Hamilton) - Azure Blob - Fix encoding issue with dir path comparison (nielash) - B2 - Add new [cleanup](https://rclone.org/b2/#cleanup) and [cleanup-hidden](/b2/#cleanup-hidden) backend commands. (Pat Patterson) - Update B2 URLs to new home (Nick Craig-Wood) - Chunker - Fix startup when root points to composite multi-chunk file without metadata (nielash) - Fix case-insensitive comparison on local without metadata (nielash) - Fix "finalizer already set" error (nielash) - Drive - Add [backend query](https://rclone.org/drive/#query) command for general purpose querying of files (John-Paul Smith) - Stop sending notification emails when setting permissions (Nick Craig-Wood) - Fix server side copy with metadata from my drive to shared drive (Nick Craig-Wood) - Set all metadata permissions and return error summary instead of stopping on the first error (Nick Craig-Wood) - Make errors setting permissions into no retry errors (Nick Craig-Wood) - Fix description being overwritten on server side moves (Nick Craig-Wood) - Allow setting metadata to fail if `failok` flag is set (Nick Craig-Wood) - Fix panic when using `--metadata-mapper` on large google doc files (Nick Craig-Wood) - Dropbox - Add `--dropbox-root-namespace` to override the root namespace (Bill Fraser) - Google Cloud Storage - Fix encoding issue with dir path comparison (nielash) - Hdfs - Fix f.String() not including subpath (nielash) - Http - Add `--http-no-escape` to not escape URL metacharacters in path names (Kyle Reynolds) - Jottacloud - Set metadata on server side copy and move (albertony) - Linkbox - Fix working with names longer than 8-25 Unicode chars. (Vitaly) - Fix list paging and optimized synchronization. (gvitali) - Mailru - Attempt to fix throttling by increasing min sleep to 100ms (Nick Craig-Wood) - Memory - Fix dst mutating src after server-side copy (nielash) - Fix deadlock in operations.Purge (nielash) - Fix incorrect list entries when rooted at subdirectory (nielash) - Onedrive - Add `--onedrive-hard-delete` to permanently delete files (Nick Craig-Wood) - Make server-side copy work in more scenarios (YukiUnHappy) - Fix "unauthenticated: Unauthenticated" errors when downloading (Nick Craig-Wood) - Fix `--metadata-mapper` being called twice if writing permissions (nielash) - Set all metadata permissions and return error summary instead of stopping on the first error (nielash) - Make errors setting permissions into no retry errors (Nick Craig-Wood) - Skip writing permissions with 'owner' role (nielash) - Fix references to deprecated permissions properties (nielash) - Add support for group permissions (nielash) - Allow setting permissions to fail if `failok` flag is set (Nick Craig-Wood) - Pikpak - Make getFile() usage more efficient to avoid the download limit (wiserain) - Improve upload reliability and resolve potential file conflicts (wiserain) - Implement configurable chunk size for multipart upload (wiserain) - Protondrive - Don't auth with an empty access token (Michał Dzienisiewicz) - Qingstor - Disable integration tests as test account suspended (Nick Craig-Wood) - Quatrix - Fix f.String() not including subpath (nielash) - S3 - Add new AWS region `il-central-1` Tel Aviv (yoelvini) - Update Scaleway's configuration options (Alexandre Lavigne) - Ceph: fix quirks when creating buckets to fix trying to create an existing bucket (Thomas Schneider) - Fix encoding issue with dir path comparison (nielash) - Fix 405 error on HEAD for delete marker with versionId (nielash) - Validate `--s3-copy-cutoff` size before copy (hoyho) - SFTP - Add `--sftp-connections` to limit the maximum number of connections (Tomasz Melcer) - Storj - Update `storj.io/uplink` to latest release (JT Olio) - Update bio on request (Nick Craig-Wood) - Swift - Implement `--swift-use-segments-container` to allow >5G files on Blomp (Nick Craig-Wood) - Union - Fix deleting dirs when all remotes can't have empty dirs (Nick Craig-Wood) - WebDAV - Fix setting modification times erasing checksums on owncloud and nextcloud (nielash) - owncloud: Add `--webdav-owncloud-exclude-mounts` which allows excluding mounted folders when listing remote resources (Thomas Müller) - Zoho - Fix throttling problem when uploading files (Nick Craig-Wood) - Use cursor listing for improved performance (Nick Craig-Wood) - Retry reading info after upload if size wasn't returned (Nick Craig-Wood) - Remove simple file names complication which is no longer needed (Nick Craig-Wood) - Sleep for 60 seconds if rate limit error received (Nick Craig-Wood) ## v1.66.0 - 2024-03-10 [See commits](https://github.com/rclone/rclone/compare/v1.65.0...v1.66.0) - Major features - Rclone will now sync directory modification times if the backend supports it. - This can be disabled with [--no-update-dir-modtime](https://rclone.org/docs/#no-update-dir-modtime) - See [the overview](https://rclone.org/overview/#features) and look for the `D` flags in the `ModTime` column to see which backends support it. - Rclone will now sync directory metadata if the backend supports it when `-M`/`--metadata` is in use. - See [the overview](https://rclone.org/overview/#features) and look for the `D` flags in the `Metadata` column to see which backends support it. - Bisync has received many updates see below for more details or [bisync's changelog](https://rclone.org/bisync/#changelog) - Removed backends - amazonclouddrive: Remove Amazon Drive backend code and docs (Nick Craig-Wood) - New Features - backend - Add description field for all backends (Paul Stern) - build - Update to go1.22 and make go1.20 the minimum required version (Nick Craig-Wood) - Fix `CVE-2024-24786` by upgrading `google.golang.org/protobuf` (Nick Craig-Wood) - check: Respect `--no-unicode-normalization` and `--ignore-case-sync` for `--checkfile` (nielash) - cmd: Much improved shell auto completion which reduces the size of the completion file and works faster (Nick Craig-Wood) - doc updates (albertony, ben-ba, Eli, emyarod, huajin tong, Jack Provance, kapitainsky, keongalvin, Nick Craig-Wood, nielash, rarspace01, rzitzer, Tera, Vincent Murphy) - fs: Add more detailed logging for file includes/excludes (Kyle Reynolds) - lsf - Add `--time-format` flag (nielash) - Make metadata appear for directories (Nick Craig-Wood) - lsjson: Make metadata appear for directories (Nick Craig-Wood) - rc - Add `srcFs` and `dstFs` to `core/stats` and `core/transferred` stats (Nick Craig-Wood) - Add `operations/hashsum` to the rc as `rclone hashsum` equivalent (Nick Craig-Wood) - Add `config/paths` to the rc as `rclone config paths` equivalent (Nick Craig-Wood) - sync - Optionally report list of synced paths to file (nielash) - Implement directory sync for mod times and metadata (Nick Craig-Wood) - Don't set directory modtimes if already set (nielash) - Don't sync directory modtimes from backends which don't have directories (Nick Craig-Wood) - Bug Fixes - backend - Make backends which use oauth implement the `Shutdown` and shutdown the oauth properly (rkonfj) - bisync - Handle unicode and case normalization consistently (nielash) - Partial uploads known issue on `local`/`ftp`/`sftp` has been resolved (unless using `--inplace`) (nielash) - Fixed handling of unicode normalization and case insensitivity, support for [`--fix-case`](https://rclone.org/docs/#fix-case), [`--ignore-case-sync`](/docs/#ignore-case-sync), [`--no-unicode-normalization`](/docs/#no-unicode-normalization) (nielash) - Bisync no longer fails to find the correct listing file when configs are overridden with backend-specific flags. (nielash) - nfsmount - Fix exit after external unmount (nielash) - Fix `--volname` being ignored (nielash) - operations - Fix renaming a file on macOS (nielash) - Fix case-insensitive moves in operations.Move (nielash) - Fix TestCaseInsensitiveMoveFileDryRun on chunker integration tests (nielash) - Fix TestMkdirModTime test (Nick Craig-Wood) - Fix TestSetDirModTime for backends with SetDirModTime but not Metadata (Nick Craig-Wood) - Fix typo in log messages (nielash) - serve nfs: Fix writing files via Finder on macOS (nielash) - serve restic: Fix error handling (Michael Eischer) - serve webdav: Fix `--baseurl` without leading / (Nick Craig-Wood) - stats: Fix race between ResetCounters and stopAverageLoop called from time.AfterFunc (Nick Craig-Wood) - sync - `--fix-case` flag to rename case insensitive dest (nielash) - Use operations.DirMove instead of sync.MoveDir for `--fix-case` (nielash) - systemd: Fix detection and switch to the coreos package everywhere rather than having 2 separate libraries (Anagh Kumar Baranwal) - Mount - Fix macOS not noticing errors with `--daemon` (Nick Craig-Wood) - Notice daemon dying much quicker (Nick Craig-Wood) - VFS - Fix unicode normalization on macOS (nielash) - Bisync - Copies and deletes are now handled in one operation instead of two (nielash) - `--track-renames` and `--backup-dir` are now supported (nielash) - Final listings are now generated from sync results, to avoid needing to re-list (nielash) - Bisync is now much more resilient to changes that happen during a bisync run, and far less prone to critical errors / undetected changes (nielash) - Bisync is now capable of rolling a file listing back in cases of uncertainty, essentially marking the file as needing to be rechecked next time. (nielash) - A few basic terminal colors are now supported, controllable with [`--color`](https://rclone.org/docs/#color-autoneveralways) (`AUTO`|`NEVER`|`ALWAYS`) (nielash) - Initial listing snapshots of Path1 and Path2 are now generated concurrently, using the same "march" infrastructure as `check` and `sync`, for performance improvements and less risk of error. (nielash) - `--resync` is now much more efficient (especially for users of `--create-empty-src-dirs`) (nielash) - Google Docs (and other files of unknown size) are now supported (with the same options as in `sync`) (nielash) - Equality checks before a sync conflict rename now fall back to `cryptcheck` (when possible) or `--download`, (nielash) instead of of `--size-only`, when `check` is not available. - Bisync now fully supports comparing based on any combination of size, modtime, and checksum, lifting the prior restriction on backends without modtime support. (nielash) - Bisync now supports a "Graceful Shutdown" mode to cleanly cancel a run early without requiring `--resync`. (nielash) - New `--recover` flag allows robust recovery in the event of interruptions, without requiring `--resync`. (nielash) - A new `--max-lock` setting allows lock files to automatically renew and expire, for better automatic recovery when a run is interrupted. (nielash) - Bisync now supports auto-resolving sync conflicts and customizing rename behavior with new [`--conflict-resolve`](#conflict-resolve), [`--conflict-loser`](#conflict-loser), and [`--conflict-suffix`](#conflict-suffix) flags. (nielash) - A new [`--resync-mode`](#resync-mode) flag allows more control over which version of a file gets kept during a `--resync`. (nielash) - Bisync now supports [`--retries`](https://rclone.org/docs/#retries-int) and [`--retries-sleep`](/docs/#retries-sleep-duration) (when [`--resilient`](#resilient) is set.) (nielash) - Clarify file operation directions in dry-run logs (Kyle Reynolds) - Local - Fix cleanRootPath on Windows after go1.21.4 stdlib update (nielash) - Implement setting modification time on directories (nielash) - Implement modtime and metadata for directories (Nick Craig-Wood) - Fix setting of btime on directories on Windows (Nick Craig-Wood) - Delete backend implementation of Purge to speed up and make stats (Nick Craig-Wood) - Support metadata setting and mapping on server side Move (Nick Craig-Wood) - Cache - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - Crypt - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - Improve handling of undecryptable file names (nielash) - Add missing error check spotted by linter (Nick Craig-Wood) - Azure Blob - Implement `--azureblob-delete-snapshots` (Nick Craig-Wood) - B2 - Clarify exactly what `--b2-download-auth-duration` does in the docs (Nick Craig-Wood) - Chunker - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - Combine - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - Fix directory metadata error on upstream root (nielash) - Fix directory move across upstreams (nielash) - Compress - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - Drive - Implement setting modification time on directories (nielash) - Implement modtime and metadata setting for directories (Nick Craig-Wood) - Support metadata setting and mapping on server side Move,Copy (Nick Craig-Wood) - FTP - Fix mkdir with rsftp which is returning the wrong code (Nick Craig-Wood) - Hasher - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - Fix error from trying to stop an already-stopped db (nielash) - Look for cached hash if passed hash unexpectedly blank (nielash) - Imagekit - Updated docs and web content (Harshit Budhraja) - Updated overview - supported operations (Harshit Budhraja) - Mega - Fix panic with go1.22 (Nick Craig-Wood) - Netstorage - Fix Root to return correct directory when pointing to a file (Nick Craig-Wood) - Onedrive - Add metadata support (nielash) - Opendrive - Fix moving file/folder within the same parent dir (nielash) - Oracle Object Storage - Support `backend restore` command (Nikhil Ahuja) - Support workload identity authentication for OKE (Anders Swanson) - Protondrive - Fix encoding of Root method (Nick Craig-Wood) - Quatrix - Fix `Content-Range` header (Volodymyr) - Add option to skip project folders (Oksana Zhykina) - Fix Root to return correct directory when pointing to a file (Nick Craig-Wood) - S3 - Add `--s3-version-deleted` to show delete markers in listings when using versions. (Nick Craig-Wood) - Add IPv6 support with option `--s3-use-dual-stack` (Anthony Metzidis) - Copy parts in parallel when doing chunked server side copy (Nick Craig-Wood) - GCS provider: fix server side copy of files bigger than 5G (Nick Craig-Wood) - Support metadata setting and mapping on server side Copy (Nick Craig-Wood) - Seafile - Fix download/upload error when `FILE_SERVER_ROOT` is relative (DanielEgbers) - Fix Root to return correct directory when pointing to a file (Nick Craig-Wood) - SFTP - Implement setting modification time on directories (nielash) - Set directory modtimes update on write flag (Nick Craig-Wood) - Shorten wait delay for external ssh binaries now that we are using go1.20 (Nick Craig-Wood) - Swift - Avoid unnecessary container versioning check (Joe Cai) - Union - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - WebDAV - Reduce priority of chunks upload log (Gabriel Ramos) - owncloud: Add config `owncloud_exclude_shares` which allows to exclude shared files and folders when listing remote resources (Thomas Müller) ## v1.65.2 - 2024-01-24 [See commits](https://github.com/rclone/rclone/compare/v1.65.1...v1.65.2) - Bug Fixes - build: bump github.com/cloudflare/circl from 1.3.6 to 1.3.7 (dependabot) - docs updates (Nick Craig-Wood, kapitainsky, nielash, Tera, Harshit Budhraja) - VFS - Fix stale data when using `--vfs-cache-mode` full (Nick Craig-Wood) - Azure Blob - **IMPORTANT** Fix data corruption bug - see [#7590](https://github.com/rclone/rclone/issues/7590) (Nick Craig-Wood) ## v1.65.1 - 2024-01-08 [See commits](https://github.com/rclone/rclone/compare/v1.65.0...v1.65.1) - Bug Fixes - build - Bump golang.org/x/crypto to fix ssh terrapin CVE-2023-48795 (dependabot) - Update to go1.21.5 to fix Windows path problems (Nick Craig-Wood) - Fix docker build on arm/v6 (Nick Craig-Wood) - install.sh: fix harmless error message on install (Nick Craig-Wood) - accounting: fix stats to show server side transfers (Nick Craig-Wood) - doc fixes (albertony, ben-ba, Eli Orzitzer, emyarod, keongalvin, rarspace01) - nfsmount: Compile for all unix oses, add `--sudo` and fix error/option handling (Nick Craig-Wood) - operations: Fix files moved by rclone move not being counted as transfers (Nick Craig-Wood) - oauthutil: Avoid panic when `*token` and `*ts.token` are the same (rkonfj) - serve s3: Fix listing oddities (Nick Craig-Wood) - VFS - Note that `--vfs-refresh` runs in the background (Nick Craig-Wood) - Azurefiles - Fix storage base url (Oksana) - Crypt - Fix rclone move a file over itself deleting the file (Nick Craig-Wood) - Chunker - Fix rclone move a file over itself deleting the file (Nick Craig-Wood) - Compress - Fix rclone move a file over itself deleting the file (Nick Craig-Wood) - Dropbox - Fix used space on dropbox team accounts (Nick Craig-Wood) - FTP - Fix multi-thread copy (WeidiDeng) - Googlephotos - Fix nil pointer exception when batch failed (Nick Craig-Wood) - Hasher - Fix rclone move a file over itself deleting the file (Nick Craig-Wood) - Fix invalid memory address error when MaxAge == 0 (nielash) - Onedrive - Fix error listing: unknown object type `` (Nick Craig-Wood) - Fix "unauthenticated: Unauthenticated" errors when uploading (Nick Craig-Wood) - Oracleobjectstorage - Fix object storage endpoint for custom endpoints (Manoj Ghosh) - Multipart copy create bucket if it doesn't exist. (Manoj Ghosh) - Protondrive - Fix CVE-2023-45286 / GHSA-xwh9-gc39-5298 (Nick Craig-Wood) - S3 - Fix crash if no UploadId in multipart upload (Nick Craig-Wood) - Smb - Fix shares not listed by updating go-smb2 (halms) - Union - Fix rclone move a file over itself deleting the file (Nick Craig-Wood) ## v1.65.0 - 2023-11-26 [See commits](https://github.com/rclone/rclone/compare/v1.64.0...v1.65.0) - New backends - Azure Files (karan, moongdal, Nick Craig-Wood) - ImageKit (Abhinav Dhiman) - Linkbox (viktor, Nick Craig-Wood) - New commands - `serve s3`: Let rclone act as an S3 compatible server (Mikubill, Artur Neumann, Saw-jan, Nick Craig-Wood) - `nfsmount`: mount command to provide mount mechanism on macOS without FUSE (Saleh Dindar) - `serve nfs`: to serve a remote for use by `nfsmount` (Saleh Dindar) - New Features - install.sh: Clean up temp files in install script (Jacob Hands) - build - Update all dependencies (Nick Craig-Wood) - Refactor version info and icon resource handling on windows (albertony) - doc updates (albertony, alfish2000, asdffdsazqqq, Dimitri Papadopoulos, Herby Gillot, Joda Stößer, Manoj Ghosh, Nick Craig-Wood) - Implement `--metadata-mapper` to transform metadata with a user supplied program (Nick Craig-Wood) - Add `ChunkWriterDoesntSeek` feature flag and set it for b2 (Nick Craig-Wood) - lib/http: Export basic go string functions for use in `--template` (Gabriel Espinoza) - makefile: Use POSIX compatible install arguments (Mina Galić) - operations - Use less memory when doing multithread uploads (Nick Craig-Wood) - Implement `--partial-suffix` to control extension of temporary file names (Volodymyr) - rc - Add `operations/check` to the rc API (Nick Craig-Wood) - Always report an error as JSON (Nick Craig-Wood) - Set `Last-Modified` header for files served by `--rc-serve` (Nikita Shoshin) - size: Dont show duplicate object count when less than 1k (albertony) - Bug Fixes - fshttp: Fix `--contimeout` being ignored (你知道未来吗) - march: Fix excessive parallelism when using `--no-traverse` (Nick Craig-Wood) - ncdu: Fix crash when re-entering changed directory after rescan (Nick Craig-Wood) - operations - Fix overwrite of destination when multi-thread transfer fails (Nick Craig-Wood) - Fix invalid UTF-8 when truncating file names when not using `--inplace` (Nick Craig-Wood) - serve dnla: Fix crash on graceful exit (wuxingzhong) - Mount - Disable mount for freebsd and alias cmount as mount on that platform (Nick Craig-Wood) - VFS - Add `--vfs-refresh` flag to read all the directories on start (Beyond Meat) - Implement Name() method in WriteFileHandle and ReadFileHandle (Saleh Dindar) - Add go-billy dependency and make sure vfs.Handle implements billy.File (Saleh Dindar) - Error out early if can't upload 0 length file (Nick Craig-Wood) - Local - Fix copying from Windows Volume Shadows (Nick Craig-Wood) - Azure Blob - Add support for cold tier (Ivan Yanitra) - B2 - Implement "rclone backend lifecycle" to read and set bucket lifecycles (Nick Craig-Wood) - Implement `--b2-lifecycle` to control lifecycle when creating buckets (Nick Craig-Wood) - Fix listing all buckets when not needed (Nick Craig-Wood) - Fix multi-thread upload with copyto going to wrong name (Nick Craig-Wood) - Fix server side chunked copy when file size was exactly `--b2-copy-cutoff` (Nick Craig-Wood) - Fix streaming chunked files an exact multiple of chunk size (Nick Craig-Wood) - Box - Filter more EventIDs when polling (David Sze) - Add more logging for polling (David Sze) - Fix performance problem reading metadata for single files (Nick Craig-Wood) - Drive - Add read/write metadata support (Nick Craig-Wood) - Add support for SHA-1 and SHA-256 checksums (rinsuki) - Add `--drive-show-all-gdocs` to allow unexportable gdocs to be server side copied (Nick Craig-Wood) - Add a note that `--drive-scope` accepts comma-separated list of scopes (Keigo Imai) - Fix error updating created time metadata on existing object (Nick Craig-Wood) - Fix integration tests by enabling metadata support from the context (Nick Craig-Wood) - Dropbox - Factor batcher into lib/batcher (Nick Craig-Wood) - Fix missing encoding for rclone purge (Nick Craig-Wood) - Google Cloud Storage - Fix 400 Bad request errors when using multi-thread copy (Nick Craig-Wood) - Googlephotos - Implement batcher for uploads (Nick Craig-Wood) - Hdfs - Added support for list of namenodes in hdfs remote config (Tayo-pasedaRJ) - HTTP - Implement set backend command to update running backend (Nick Craig-Wood) - Enable methods used with WebDAV (Alen Šiljak) - Jottacloud - Add support for reading and writing metadata (albertony) - Onedrive - Implement ListR method which gives `--fast-list` support (Nick Craig-Wood) - This must be enabled with the `--onedrive-delta` flag - Quatrix - Add partial upload support (Oksana Zhykina) - Overwrite files on conflict during server-side move (Oksana Zhykina) - S3 - Add Linode provider (Nick Craig-Wood) - Add docs on how to add a new provider (Nick Craig-Wood) - Fix no error being returned when creating a bucket we don't own (Nick Craig-Wood) - Emit a debug message if anonymous credentials are in use (Nick Craig-Wood) - Add `--s3-disable-multipart-uploads` flag (Nick Craig-Wood) - Detect looping when using gcs and versions (Nick Craig-Wood) - SFTP - Implement `--sftp-copy-is-hardlink` to server side copy as hardlink (Nick Craig-Wood) - Smb - Fix incorrect `about` size by switching to `github.com/cloudsoda/go-smb2` fork (Nick Craig-Wood) - Fix modtime of multithread uploads by setting PartialUploads (Nick Craig-Wood) - WebDAV - Added an rclone vendor to work with `rclone serve webdav` (Adithya Kumar) ## v1.64.2 - 2023-10-19 [See commits](https://github.com/rclone/rclone/compare/v1.64.1...v1.64.2) - Bug Fixes - selfupdate: Fix "invalid hashsum signature" error (Nick Craig-Wood) - build: Fix docker build running out of space (Nick Craig-Wood) ## v1.64.1 - 2023-10-17 [See commits](https://github.com/rclone/rclone/compare/v1.64.0...v1.64.1) - Bug Fixes - cmd: Make `--progress` output logs in the same format as without (Nick Craig-Wood) - docs fixes (Dimitri Papadopoulos Orfanos, Herby Gillot, Manoj Ghosh, Nick Craig-Wood) - lsjson: Make sure we set the global metadata flag too (Nick Craig-Wood) - operations - Ensure concurrency is no greater than the number of chunks (Pat Patterson) - Fix OpenOptions ignored in copy if operation was a multiThreadCopy (Vitor Gomes) - Fix error message on delete to have file name (Nick Craig-Wood) - serve sftp: Return not supported error for not supported commands (Nick Craig-Wood) - build: Upgrade golang.org/x/net to v0.17.0 to fix HTTP/2 rapid reset (Nick Craig-Wood) - pacer: Fix b2 deadlock by defaulting max connections to unlimited (Nick Craig-Wood) - Mount - Fix automount not detecting drive is ready (Nick Craig-Wood) - VFS - Fix update dir modification time (Saleh Dindar) - Azure Blob - Fix "fatal error: concurrent map writes" (Nick Craig-Wood) - B2 - Fix multipart upload: corrupted on transfer: sizes differ XXX vs 0 (Nick Craig-Wood) - Fix locking window when getting multipart upload URL (Nick Craig-Wood) - Fix server side copies greater than 4GB (Nick Craig-Wood) - Fix chunked streaming uploads (Nick Craig-Wood) - Reduce default `--b2-upload-concurrency` to 4 to reduce memory usage (Nick Craig-Wood) - Onedrive - Fix the configurator to allow `/teams/ID` in the config (Nick Craig-Wood) - Oracleobjectstorage - Fix OpenOptions being ignored in uploadMultipart with chunkWriter (Nick Craig-Wood) - S3 - Fix slice bounds out of range error when listing (Nick Craig-Wood) - Fix OpenOptions being ignored in uploadMultipart with chunkWriter (Vitor Gomes) - Storj - Update storj.io/uplink to v1.12.0 (Kaloyan Raev) ## v1.64.0 - 2023-09-11 [See commits](https://github.com/rclone/rclone/compare/v1.63.0...v1.64.0) - New backends - [Proton Drive](https://rclone.org/protondrive/) (Chun-Hung Tseng) - [Quatrix](https://rclone.org/quatrix/) (Oksana, Volodymyr Kit) - New S3 providers - [Synology C2](https://rclone.org/s3/#synology-c2) (BakaWang) - [Leviia](https://rclone.org/s3/#leviia) (Benjamin) - New Jottacloud providers - [Onlime](https://rclone.org/jottacloud/) (Fjodor42) - [Telia Sky](https://rclone.org/jottacloud/) (NoLooseEnds) - Major changes - Multi-thread transfers (Vitor Gomes, Nick Craig-Wood, Manoj Ghosh, Edwin Mackenzie-Owen) - Multi-thread transfers are now available when transferring to: - `local`, `s3`, `azureblob`, `b2`, `oracleobjectstorage` and `smb` - This greatly improves transfer speed between two network sources. - In memory buffering has been unified between all backends and should share memory better. - See [--multi-thread docs](https://rclone.org/docs/#multi-thread-cutoff) for more info - New commands - `rclone config redacted` support mechanism for showing redacted config (Nick Craig-Wood) - New Features - accounting - Show server side stats in own lines and not as bytes transferred (Nick Craig-Wood) - bisync - Add new `--ignore-listing-checksum` flag to distinguish from `--ignore-checksum` (nielash) - Add experimental `--resilient` mode to allow recovery from self-correctable errors (nielash) - Add support for `--create-empty-src-dirs` (nielash) - Dry runs no longer commit filter changes (nielash) - Enforce `--check-access` during `--resync` (nielash) - Apply filters correctly during deletes (nielash) - Equality check before renaming (leave identical files alone) (nielash) - Fix `dryRun` rc parameter being ignored (nielash) - build - Update to `go1.21` and make `go1.19` the minimum required version (Anagh Kumar Baranwal, Nick Craig-Wood) - Update dependencies (Nick Craig-Wood) - Add snap installation (hideo aoyama) - Change Winget Releaser job to `ubuntu-latest` (sitiom) - cmd: Refactor and use sysdnotify in more commands (eNV25) - config: Add `--multi-thread-chunk-size` flag (Vitor Gomes) - doc updates (antoinetran, Benjamin, Bjørn Smith, Dean Attali, gabriel-suela, James Braza, Justin Hellings, kapitainsky, Mahad, Masamune3210, Nick Craig-Wood, Nihaal Sangha, Niklas Hambüchen, Raymond Berger, r-ricci, Sawada Tsunayoshi, Tiago Boeing, Vladislav Vorobev) - fs - Use atomic types everywhere (Roberto Ricci) - When `--max-transfer` limit is reached exit with code (10) (kapitainsky) - Add rclone completion powershell - basic implementation only (Nick Craig-Wood) - http servers: Allow CORS to be set with `--allow-origin` flag (yuudi) - lib/rest: Remove unnecessary `nil` check (Eng Zer Jun) - ncdu: Add keybinding to rescan filesystem (eNV25) - rc - Add `executeId` to job listings (yuudi) - Add `core/du` to measure local disk usage (Nick Craig-Wood) - Add `operations/settier` to API (Drew Stinnett) - rclone test info: Add `--check-base32768` flag to check can store all base32768 characters (Nick Craig-Wood) - rmdirs: Remove directories concurrently controlled by `--checkers` (Nick Craig-Wood) - Bug Fixes - accounting: Don't stop calculating average transfer speed until the operation is complete (Jacob Hands) - fs: Fix `transferTime` not being set in JSON logs (Jacob Hands) - fshttp: Fix `--bind 0.0.0.0` allowing IPv6 and `--bind ::0` allowing IPv4 (Nick Craig-Wood) - operations: Fix overlapping check on case insensitive file systems (Nick Craig-Wood) - serve dlna: Fix MIME type if backend can't identify it (Nick Craig-Wood) - serve ftp: Fix race condition when using the auth proxy (Nick Craig-Wood) - serve sftp: Fix hash calculations with `--vfs-cache-mode full` (Nick Craig-Wood) - serve webdav: Fix error: Expecting fs.Object or fs.Directory, got `nil` (Nick Craig-Wood) - sync: Fix lockup with `--cutoff-mode=soft` and `--max-duration` (Nick Craig-Wood) - Mount - fix: Mount parsing for linux (Anagh Kumar Baranwal) - VFS - Add `--vfs-cache-min-free-space` to control minimum free space on the disk containing the cache (Nick Craig-Wood) - Added cache cleaner for directories to reduce memory usage (Anagh Kumar Baranwal) - Update parent directory modtimes on vfs actions (David Pedersen) - Keep virtual directory status accurate and reduce deadlock potential (Anagh Kumar Baranwal) - Make sure struct field is aligned for atomic access (Roberto Ricci) - Local - Rmdir return an error if the path is not a dir (zjx20) - Azure Blob - Implement `OpenChunkWriter` and multi-thread uploads (Nick Craig-Wood) - Fix creation of directory markers (Nick Craig-Wood) - Fix purging with directory markers (Nick Craig-Wood) - B2 - Implement `OpenChunkWriter` and multi-thread uploads (Nick Craig-Wood) - Fix rclone link when object path contains special characters (Alishan Ladhani) - Box - Add polling support (David Sze) - Add `--box-impersonate` to impersonate a user ID (Nick Craig-Wood) - Fix unhelpful decoding of error messages into decimal numbers (Nick Craig-Wood) - Chunker - Update documentation to mention issue with small files (Ricardo D'O. Albanus) - Compress - Fix ChangeNotify (Nick Craig-Wood) - Drive - Add `--drive-fast-list-bug-fix` to control ListR bug workaround (Nick Craig-Wood) - Fichier - Implement `DirMove` (Nick Craig-Wood) - Fix error code parsing (alexia) - FTP - Add socks_proxy support for SOCKS5 proxies (Zach) - Fix 425 "TLS session of data connection not resumed" errors (Nick Craig-Wood) - Hdfs - Retry "replication in progress" errors when uploading (Nick Craig-Wood) - Fix uploading to the wrong object on Update with overridden remote name (Nick Craig-Wood) - HTTP - CORS should not be sent if not set (yuudi) - Fix webdav OPTIONS response (yuudi) - Opendrive - Fix List on a just deleted and remade directory (Nick Craig-Wood) - Oracleobjectstorage - Use rclone's rate limiter in multipart transfers (Manoj Ghosh) - Implement `OpenChunkWriter` and multi-thread uploads (Manoj Ghosh) - S3 - Refactor multipart upload to use `OpenChunkWriter` and `ChunkWriter` (Vitor Gomes) - Factor generic multipart upload into `lib/multipart` (Nick Craig-Wood) - Fix purging of root directory with `--s3-directory-markers` (Nick Craig-Wood) - Add `rclone backend set` command to update the running config (Nick Craig-Wood) - Add `rclone backend restore-status` command (Nick Craig-Wood) - SFTP - Stop uploads re-using the same ssh connection to improve performance (Nick Craig-Wood) - Add `--sftp-ssh` to specify an external ssh binary to use (Nick Craig-Wood) - Add socks_proxy support for SOCKS5 proxies (Zach) - Support dynamic `--sftp-path-override` (nielash) - Fix spurious warning when using `--sftp-ssh` (Nick Craig-Wood) - Smb - Implement multi-threaded writes for copies to smb (Edwin Mackenzie-Owen) - Storj - Performance improvement for large file uploads (Kaloyan Raev) - Swift - Fix HEADing 0-length objects when `--swift-no-large-objects` set (Julian Lepinski) - Union - Add `:writback` to act as a simple cache (Nick Craig-Wood) - WebDAV - Nextcloud: fix segment violation in low-level retry (Paul) - Zoho - Remove Range requests workarounds to fix integration tests (Nick Craig-Wood) ## v1.63.1 - 2023-07-17 [See commits](https://github.com/rclone/rclone/compare/v1.63.0...v1.63.1) - Bug Fixes - build: Fix macos builds for versions < 12 (Anagh Kumar Baranwal) - dirtree: Fix performance with large directories of directories and `--fast-list` (Nick Craig-Wood) - operations - Fix deadlock when using `lsd`/`ls` with `--progress` (Nick Craig-Wood) - Fix `.rclonelink` files not being converted back to symlinks (Nick Craig-Wood) - doc fixes (Dean Attali, Mahad, Nick Craig-Wood, Sawada Tsunayoshi, Vladislav Vorobev) - Local - Fix partial directory read for corrupted filesystem (Nick Craig-Wood) - Box - Fix reconnect failing with HTTP 400 Bad Request (albertony) - Smb - Fix "Statfs failed: bucket or container name is needed" when mounting (Nick Craig-Wood) - WebDAV - Nextcloud: fix must use /dav/files/USER endpoint not /webdav error (Paul) - Nextcloud chunking: add more guidance for the user to check the config (darix) ## v1.63.0 - 2023-06-30 [See commits](https://github.com/rclone/rclone/compare/v1.62.0...v1.63.0) - New backends - [Pikpak](https://rclone.org/pikpak/) (wiserain) - New S3 providers - [petabox.io](https://rclone.org/s3/#petabox) (Andrei Smirnov) - [Google Cloud Storage](https://rclone.org/s3/#google-cloud-storage) (Anthony Pessy) - New WebDAV providers - [Fastmail](https://rclone.org/webdav/#fastmail-files) (Arnavion) - Major changes - Files will be copied to a temporary name ending in `.partial` when copying to `local`,`ftp`,`sftp` then renamed at the end of the transfer. (Janne Hellsten, Nick Craig-Wood) - This helps with data integrity as we don't delete the existing file until the new one is complete. - It can be disabled with the [--inplace](https://rclone.org/docs/#inplace) flag. - This behaviour will also happen if the backend is wrapped, for example `sftp` wrapped with `crypt`. - The [s3](https://rclone.org/s3/#s3-directory-markers), [azureblob](/azureblob/#azureblob-directory-markers) and [gcs](/googlecloudstorage/#gcs-directory-markers) backends now support directory markers so empty directories are supported (Jānis Bebrītis, Nick Craig-Wood) - The [--default-time](https://rclone.org/docs/#default-time-time) flag now controls the unknown modification time of files/dirs (Nick Craig-Wood) - If a file or directory does not have a modification time rclone can read then rclone will display this fixed time instead. - For the old behaviour use `--default-time 0s` which will set this time to the time rclone started up. - New Features - build - Modernise linters in use and fixup all affected code (albertony) - Push docker beta to GHCR (GitHub container registry) (Richard Tweed) - cat: Add `--separator` option to cat command (Loren Gordon) - config - Do not remove/overwrite other files during config file save (albertony) - Do not overwrite config file symbolic link (albertony) - Stop `config create` making invalid config files (Nick Craig-Wood) - doc updates (Adam K, Aditya Basu, albertony, asdffdsazqqq, Damo, danielkrajnik, Dimitri Papadopoulos, dlitster, Drew Parsons, jumbi77, kapitainsky, mac-15, Mariusz Suchodolski, Nick Craig-Wood, NickIAm, Rintze Zelle, Stanislav Gromov, Tareq Sharafy, URenko, yuudi, Zach Kipp) - fs - Add `size` to JSON logs when moving or copying an object (Nick Craig-Wood) - Allow boolean features to be enabled with `--disable !Feature` (Nick Craig-Wood) - genautocomplete: Rename to `completion` with alias to the old name (Nick Craig-Wood) - librclone: Added example on using `librclone` with Go (alankrit) - lsjson: Make `--stat` more efficient (Nick Craig-Wood) - operations - Implement `--multi-thread-write-buffer-size` for speed improvements on downloads (Paulo Schreiner) - Reopen downloads on error when using `check --download` and `cat` (Nick Craig-Wood) - rc: `config/listremotes` includes remotes defined with environment variables (kapitainsky) - selfupdate: Obey `--no-check-certificate` flag (Nick Craig-Wood) - serve restic: Trigger systemd notify (Shyim) - serve webdav: Implement owncloud checksum and modtime extensions (WeidiDeng) - sync: `--suffix-keep-extension` preserve 2 part extensions like .tar.gz (Nick Craig-Wood) - Bug Fixes - accounting - Fix Prometheus metrics to be the same as `core/stats` (Nick Craig-Wood) - Bwlimit signal handler should always start (Sam Lai) - bisync: Fix `maxDelete` parameter being ignored via the rc (Nick Craig-Wood) - cmd/ncdu: Fix screen corruption when logging (eNV25) - filter: Fix deadlock with errors on `--files-from` (douchen) - fs - Fix interaction between `--progress` and `--interactive` (Nick Craig-Wood) - Fix infinite recursive call in pacer ModifyCalculator (fixes issue reported by the staticcheck linter) (albertony) - lib/atexit: Ensure OnError only calls cancel function once (Nick Craig-Wood) - lib/rest: Fix problems re-using HTTP connections (Nick Craig-Wood) - rc - Fix `operations/stat` with trailing `/` (Nick Craig-Wood) - Fix missing `--rc` flags (Nick Craig-Wood) - Fix output of Time values in `options/get` (Nick Craig-Wood) - serve dlna: Fix potential data race (Nick Craig-Wood) - version: Fix reported os/kernel version for windows (albertony) - Mount - Add `--mount-case-insensitive` to force the mount to be case insensitive (Nick Craig-Wood) - Removed unnecessary byte slice allocation for reads (Anagh Kumar Baranwal) - Clarify rclone mount error when installed via homebrew (Nick Craig-Wood) - Added _netdev to the example mount so it gets treated as a remote-fs rather than local-fs (Anagh Kumar Baranwal) - Mount2 - Updated go-fuse version (Anagh Kumar Baranwal) - Fixed statfs (Anagh Kumar Baranwal) - Disable xattrs (Anagh Kumar Baranwal) - VFS - Add MkdirAll function to make a directory and all beneath (Nick Craig-Wood) - Fix reload: failed to add virtual dir entry: file does not exist (Nick Craig-Wood) - Fix writing to a read only directory creating spurious directory entries (WeidiDeng) - Fix potential data race (Nick Craig-Wood) - Fix backends being Shutdown too early when startup takes a long time (Nick Craig-Wood) - Local - Fix filtering of symlinks with `-l`/`--links` flag (Nick Craig-Wood) - Fix /path/to/file.rclonelink when `-l`/`--links` is in use (Nick Craig-Wood) - Fix crash with `--metadata` on Android (Nick Craig-Wood) - Cache - Fix backends shutting down when in use when used via the rc (Nick Craig-Wood) - Crypt - Add `--crypt-suffix` option to set a custom suffix for encrypted files (jladbrook) - Add `--crypt-pass-bad-blocks` to allow corrupted file output (Nick Craig-Wood) - Fix reading 0 length files (Nick Craig-Wood) - Try not to return "unexpected EOF" error (Nick Craig-Wood) - Reduce allocations (albertony) - Recommend Dropbox for `base32768` encoding (Nick Craig-Wood) - Azure Blob - Empty directory markers (Nick Craig-Wood) - Support azure workload identities (Tareq Sharafy) - Fix azure blob uploads with multiple bits of metadata (Nick Craig-Wood) - Fix azurite compatibility by sending nil tier if set to empty string (Roel Arents) - Combine - Implement missing methods (Nick Craig-Wood) - Fix goroutine stack overflow on bad object (Nick Craig-Wood) - Drive - Add `--drive-env-auth` to get IAM credentials from runtime (Peter Brunner) - Update drive service account guide (Juang, Yi-Lin) - Fix change notify picking up files outside the root (Nick Craig-Wood) - Fix trailing slash mis-identificaton of folder as file (Nick Craig-Wood) - Fix incorrect remote after Update on object (Nick Craig-Wood) - Dropbox - Implement `--dropbox-pacer-min-sleep` flag (Nick Craig-Wood) - Fix the dropbox batcher stalling (Misty) - Fichier - Add `--ficicher-cdn` option to use the CDN for download (Nick Craig-Wood) - FTP - Lower log message priority when `SetModTime` is not supported to debug (Tobias Gion) - Fix "unsupported LIST line" errors on startup (Nick Craig-Wood) - Fix "501 Not a valid pathname." errors when creating directories (Nick Craig-Wood) - Google Cloud Storage - Empty directory markers (Jānis Bebrītis, Nick Craig-Wood) - Added `--gcs-user-project` needed for requester pays (Christopher Merry) - HTTP - Add client certificate user auth middleware. This can auth `serve restic` from the username in the client cert. (Peter Fern) - Jottacloud - Fix vfs writeback stuck in a failed upload loop with file versioning disabled (albertony) - Onedrive - Add `--onedrive-av-override` flag to download files flagged as virus (Nick Craig-Wood) - Fix quickxorhash on 32 bit architectures (Nick Craig-Wood) - Report any list errors during `rclone cleanup` (albertony) - Putio - Fix uploading to the wrong object on Update with overridden remote name (Nick Craig-Wood) - Fix modification times not being preserved for server side copy and move (Nick Craig-Wood) - Fix server side copy failures (400 errors) (Nick Craig-Wood) - S3 - Empty directory markers (Jānis Bebrītis, Nick Craig-Wood) - Update Scaleway storage classes (Brian Starkey) - Fix `--s3-versions` on individual objects (Nick Craig-Wood) - Fix hang on aborting multipart upload with iDrive e2 (Nick Craig-Wood) - Fix missing "tier" metadata (Nick Craig-Wood) - Fix V3sign: add missing subresource delete (cc) - Fix Arvancloud Domain and region changes and alphabetise the provider (Ehsan Tadayon) - Fix Qiniu KODO quirks virtualHostStyle is false (zzq) - SFTP - Add `--sftp-host-key-algorithms` to allow specifying SSH host key algorithms (Joel) - Fix using `--sftp-key-use-agent` and `--sftp-key-file` together needing private key file (Arnav Singh) - Fix move to allow overwriting existing files (Nick Craig-Wood) - Don't stat directories before listing them (Nick Craig-Wood) - Don't check remote points to a file if it ends with / (Nick Craig-Wood) - Sharefile - Disable streamed transfers as they no longer work (Nick Craig-Wood) - Smb - Code cleanup to avoid overwriting ctx before first use (fixes issue reported by the staticcheck linter) (albertony) - Storj - Fix "uplink: too many requests" errors when uploading to the same file (Nick Craig-Wood) - Fix uploading to the wrong object on Update with overridden remote name (Nick Craig-Wood) - Swift - Ignore 404 error when deleting an object (Nick Craig-Wood) - Union - Implement missing methods (Nick Craig-Wood) - Allow errors to be unwrapped for inspection (Nick Craig-Wood) - Uptobox - Add `--uptobox-private` flag to make all uploaded files private (Nick Craig-Wood) - Fix improper regex (Aaron Gokaslan) - Fix Update returning the wrong object (Nick Craig-Wood) - Fix rmdir declaring that directories weren't empty (Nick Craig-Wood) - WebDAV - nextcloud: Add support for chunked uploads (Paul) - Set modtime using propset for owncloud and nextcloud (WeidiDeng) - Make pacer minSleep configurable with `--webdav-pacer-min-sleep` (ed) - Fix server side copy/move not overwriting (WeidiDeng) - Fix modtime on server side copy for owncloud and nextcloud (Nick Craig-Wood) - Yandex - Fix 400 Bad Request on transfer failure (Nick Craig-Wood) - Zoho - Fix downloads with `Range:` header returning the wrong data (Nick Craig-Wood) ## v1.62.2 - 2023-03-16 [See commits](https://github.com/rclone/rclone/compare/v1.62.1...v1.62.2) - Bug Fixes - docker volume plugin: Add missing fuse3 dependency (Nick Craig-Wood) - docs: Fix size documentation (asdffdsazqqq) - FTP - Fix 426 errors on downloads with vsftpd (Lesmiscore) ## v1.62.1 - 2023-03-15 [See commits](https://github.com/rclone/rclone/compare/v1.62.0...v1.62.1) - Bug Fixes - docker: Add missing fuse3 dependency (cycneuramus) - build: Update release docs to be more careful with the tag (Nick Craig-Wood) - build: Set Github release to draft while uploading binaries (Nick Craig-Wood) ## v1.62.0 - 2023-03-14 [See commits](https://github.com/rclone/rclone/compare/v1.61.0...v1.62.0) - New Features - accounting: Make checkers show what they are doing (Nick Craig-Wood) - authorize: Add support for custom templates (Hunter Wittenborn) - build - Update to go1.20 (Nick Craig-Wood, Anagh Kumar Baranwal) - Add winget releaser workflow (Ryan Caezar Itang) - Add dependabot (Ryan Caezar Itang) - doc updates (albertony, Bryan Kaplan, Gerard Bosch, IMTheNachoMan, Justin Winokur, Manoj Ghosh, Nick Craig-Wood, Ole Frost, Peter Brunner, piyushgarg, Ryan Caezar Itang, Simmon Li, ToBeFree) - filter: Emit INFO message when can't work out directory filters (Nick Craig-Wood) - fs - Added multiple ca certificate support. (alankrit) - Add `--max-delete-size` a delete size threshold (Leandro Sacchet) - fspath: Allow the symbols `@` and `+` in remote names (albertony) - lib/terminal: Enable windows console virtual terminal sequences processing (ANSI/VT100 colors) (albertony) - move: If `--check-first` and `--order-by` are set then delete with perfect ordering (Nick Craig-Wood) - serve http: Support `--auth-proxy` (Matthias Baur) - Bug Fixes - accounting - Avoid negative ETA values for very slow speeds (albertony) - Limit length of ETA string (albertony) - Show human readable elapsed time when longer than a day (albertony) - all: Apply codeql fixes (Aaron Gokaslan) - build - Fix condition for manual workflow run (albertony) - Fix building for ARMv5 and ARMv6 (albertony) - selfupdate: Consider ARM version - install.sh: fix ARMv6 download - version: Report ARM version - deletefile: Return error code 4 if file does not exist (Nick Craig-Wood) - docker: Fix volume plugin does not remount volume on docker restart (logopk) - fs: Fix race conditions in `--max-delete` and `--max-delete-size` (Nick Craig-Wood) - lib/oauthutil: Handle fatal errors better (Alex Chen) - mount2: Fix `--allow-non-empty` (Nick Craig-Wood) - operations: Fix concurrency: use `--checkers` unless transferring files (Nick Craig-Wood) - serve ftp: Fix timestamps older than 1 year in listings (Nick Craig-Wood) - sync: Fix concurrency: use `--checkers` unless transferring files (Nick Craig-Wood) - tree - Fix nil pointer exception on stat failure (Nick Craig-Wood) - Fix colored output on windows (albertony) - Fix display of files with illegal Windows file system names (Nick Craig-Wood) - Mount - Fix creating and renaming files on case insensitive backends (Nick Craig-Wood) - Do not treat `\\?\` prefixed paths as network share paths on windows (albertony) - Fix check for empty mount point on Linux (Nick Craig-Wood) - Fix `--allow-non-empty` (Nick Craig-Wood) - Avoid incorrect or premature overlap check on windows (albertony) - Update to fuse3 after bazil.org/fuse update (Nick Craig-Wood) - VFS - Make uploaded files retain modtime with non-modtime backends (Nick Craig-Wood) - Fix incorrect modtime on fs which don't support setting modtime (Nick Craig-Wood) - Fix rename of directory containing files to be uploaded (Nick Craig-Wood) - Local - Fix `%!w()` in "failed to read directory" error (Marks Polakovs) - Fix exclusion of dangling symlinks with -L/--copy-links (Nick Craig-Wood) - Crypt - Obey `--ignore-checksum` (Nick Craig-Wood) - Fix for unencrypted directory names on case insensitive remotes (Ole Frost) - Azure Blob - Remove workarounds for SDK bugs after v0.6.1 update (Nick Craig-Wood) - B2 - Fix uploading files bigger than 1TiB (Nick Craig-Wood) - Drive - Note that `--drive-acknowledge-abuse` needs SA Manager permission (Nick Craig-Wood) - Make `--drive-stop-on-upload-limit` to respond to storageQuotaExceeded (Ninh Pham) - FTP - Retry 426 errors (Nick Craig-Wood) - Retry errors when initiating downloads (Nick Craig-Wood) - Revert to upstream `github.com/jlaffaye/ftp` now fix is merged (Nick Craig-Wood) - Google Cloud Storage - Add `--gcs-env-auth` to pick up IAM credentials from env/instance (Peter Brunner) - Mega - Add `--mega-use-https` flag (NodudeWasTaken) - Onedrive - Default onedrive personal to QuickXorHash as Microsoft is removing SHA1 (Nick Craig-Wood) - Add `--onedrive-hash-type` to change the hash in use (Nick Craig-Wood) - Improve speed of QuickXorHash (LXY) - Oracle Object Storage - Speed up operations by using S3 pacer and setting minsleep to 10ms (Manoj Ghosh) - Expose the `storage_tier` option in config (Manoj Ghosh) - Bring your own encryption keys (Manoj Ghosh) - S3 - Check multipart upload ETag when `--s3-no-head` is in use (Nick Craig-Wood) - Add `--s3-sts-endpoint` to specify STS endpoint (Nick Craig-Wood) - Fix incorrect tier support for StorJ and IDrive when pointing at a file (Ole Frost) - Fix AWS STS failing if `--s3-endpoint` is set (Nick Craig-Wood) - Make purge remove directory markers too (Nick Craig-Wood) - Seafile - Renew library password (Fred) - SFTP - Fix uploads being 65% slower than they should be with crypt (Nick Craig-Wood) - Smb - Allow SPN (service principal name) to be configured (Nick Craig-Wood) - Check smb connection is closed (happyxhw) - Storj - Implement `rclone link` (Kaloyan Raev) - Implement `rclone purge` (Kaloyan Raev) - Update satellite urls and labels (Kaloyan Raev) - WebDAV - Fix interop with davrods server (Nick Craig-Wood) ## v1.61.1 - 2022-12-23 [See commits](https://github.com/rclone/rclone/compare/v1.61.0...v1.61.1) - Bug Fixes - docs: - Show only significant parts of version number in version introduced label (albertony) - Fix unescaped HTML (Nick Craig-Wood) - lib/http: Shutdown all servers on exit to remove unix socket (Nick Craig-Wood) - rc: Fix `--rc-addr` flag (which is an alternate for `--url`) (Anagh Kumar Baranwal) - serve restic - Don't serve via http if serving via `--stdio` (Nick Craig-Wood) - Fix immediate exit when not using stdio (Nick Craig-Wood) - serve webdav - Fix `--baseurl` handling after `lib/http` refactor (Nick Craig-Wood) - Fix running duplicate Serve call (Nick Craig-Wood) - Azure Blob - Fix "409 Public access is not permitted on this storage account" (Nick Craig-Wood) - S3 - storj: Update endpoints (Kaloyan Raev) ## v1.61.0 - 2022-12-20 [See commits](https://github.com/rclone/rclone/compare/v1.60.0...v1.61.0) - New backends - New S3 providers - [Liara LOS](https://rclone.org/s3/#liara-cloud) (MohammadReza) - New Features - build: Add vulnerability testing using govulncheck (albertony) - cmd: Enable `SIGINFO` (Ctrl-T) handler on FreeBSD, NetBSD, OpenBSD and Dragonfly BSD (x3-apptech) - config: Add [config/setpath](https://rclone.org/rc/#config-setpath) for setting config path via rc/librclone (Nick Craig-Wood) - dedupe - Count Checks in the stats while scanning for duplicates (Nick Craig-Wood) - Make dedupe obey the filters (Nick Craig-Wood) - dlna: Properly attribute code used from (Nick Craig-Wood) - docs - Add minimum versions and status badges to backend and command docs (Nick Craig-Wood, albertony) - Remote names may not start or end with space (albertony) - filter: Add metadata filters [--metadata-include/exclude/filter](https://rclone.org/filtering/#metadata) and friends (Nick Craig-Wood) - fs - Make all duration flags take `y`, `M`, `w`, `d` etc suffixes (Nick Craig-Wood) - Add global flag `--color` to control terminal colors (Kevin Verstaen) - fspath: Allow unicode numbers and letters in remote names (albertony) - lib/file: Improve error message for creating dir on non-existent network host on windows (albertony) - lib/http: Finish port of rclone servers to `lib/http` (Tom Mombourquette, Nick Craig-Wood) - lib/oauthutil: Improved usability of config flows needing web browser (Ole Frost) - ncdu - Add support for modification time (albertony) - Fallback to sort by name also for sort by average size (albertony) - Rework to use tcell directly instead of the termbox wrapper (eNV25) - rc: Add commands to set [GC Percent](https://rclone.org/rc/#debug-set-gc-percent) & [Memory Limit](/rc/#debug-set-soft-memory-limit) (go 1.19+) (Anagh Kumar Baranwal) - rcat: Preserve metadata when Copy falls back to Rcat (Nick Craig-Wood) - rcd: Refactor rclone rc server to use `lib/http` (Nick Craig-Wood) - rcserver: Avoid generating default credentials with htpasswd (Kamui) - restic: Refactor to use `lib/http` (Nolan Woods) - serve http: Support unix sockets and multiple listeners (Tom Mombourquette) - serve webdav: Refactor to use `lib/http` (Nick Craig-Wood) - test: Replace defer cleanup with `t.Cleanup` (Eng Zer Jun) - test memory: Read metadata if `-M` flag is specified (Nick Craig-Wood) - wasm: Comply with `wasm_exec.js` licence terms (Matthew Vernon) - Bug Fixes - build: Update `golang.org/x/net/http2` to fix GO-2022-1144 (Nick Craig-Wood) - restic: Fix typo in docs 'remove' should be 'remote' (asdffdsazqqq) - serve dlna: Fix panic: Logger uninitialized. (Nick Craig-Wood) - Mount - Update cgofuse for FUSE-T support for mounting volumes on Mac (Nick Craig-Wood) - VFS - Windows: fix slow opening of exe files by not truncating files when not necessary (Nick Craig-Wood) - Fix IO Error opening a file with `O_CREATE|O_RDONLY` in `--vfs-cache-mode` not full (Nick Craig-Wood) - Crypt - Fix compress wrapping crypt giving upload errors (Nick Craig-Wood) - Azure Blob - Port to new SDK (Nick Craig-Wood) - Revamp authentication to include all methods and docs (Nick Craig-Wood) - Port old authentication methods to new SDK (Nick Craig-Wood, Brad Ackerman) - Thanks to [Stonebranch](https://www.stonebranch.com/) for sponsoring this work. - Add `--azureblob-no-check-container` to assume container exists (Nick Craig-Wood) - Add `--use-server-modtime` support (Abdullah Saglam) - Add support for custom upload headers (rkettelerij) - Allow emulator account/key override (Roel Arents) - Support simple "environment credentials" (Nathaniel Wesley Filardo) - Ignore `AuthorizationFailure` when trying to create a create a container (Nick Craig-Wood) - Box - Added note on Box API rate limits (Ole Frost) - Drive - Handle shared drives with leading/trailing space in name (related to) (albertony) - FTP - Update help text of implicit/explicit TLS options to refer to FTPS instead of FTP (ycdtosa) - Improve performance to speed up `--files-from` and `NewObject` (Anthony Pessy) - HTTP - Parse GET responses when `no_head` is set (Arnie97) - Do not update object size based on `Range` requests (Arnie97) - Support `Content-Range` response header (Arnie97) - Onedrive - Document workaround for shared with me files (vanplus) - S3 - Add Liara LOS to provider list (MohammadReza) - Add DigitalOcean Spaces regions `sfo3`, `fra1`, `syd1` (Jack) - Avoid privileged `GetBucketLocation` to resolve s3 region (Anthony Pessy) - Stop setting object and bucket ACL to `private` if it is an empty string (Philip Harvey) - If bucket or object ACL is empty string then don't add `X-Amz-Acl:` header (Nick Craig-Wood) - Reduce memory consumption for s3 objects (Erik Agterdenbos) - Fix listing loop when using v2 listing on v1 server (Nick Craig-Wood) - Fix nil pointer exception when using Versions (Nick Craig-Wood) - Fix excess memory usage when using versions (Nick Craig-Wood) - Ignore versionIDs from uploads unless using `--s3-versions` or `--s3-versions-at` (Nick Craig-Wood) - SFTP - Add configuration options to set ssh Ciphers / MACs / KeyExchange (dgouju) - Auto-detect shell type for fish (albertony) - Fix NewObject with leading / (Nick Craig-Wood) - Smb - Fix issue where spurious dot directory is created (albertony) - Storj - Implement server side Copy (Kaloyan Raev) ## v1.60.1 - 2022-11-17 [See commits](https://github.com/rclone/rclone/compare/v1.60.0...v1.60.1) - Bug Fixes - lib/cache: Fix alias backend shutting down too soon (Nick Craig-Wood) - wasm: Fix walltime link error by adding up-to-date wasm_exec.js (João Henrique Franco) - docs - Update faq.md with bisync (Samuel Johnson) - Corrected download links in windows install docs (coultonluke) - Add direct download link for windows arm64 (albertony) - Remove link to rclone slack as it is no longer supported (Nick Craig-Wood) - Faq: how to use a proxy server that requires a username and password (asdffdsazqqq) - Oracle-object-storage: doc fix (Manoj Ghosh) - Fix typo `remove` in rclone_serve_restic command (Joda Stößer) - Fix character that was incorrectly interpreted as markdown (Clément Notin) - VFS - Fix deadlock caused by cache cleaner and upload finishing (Nick Craig-Wood) - Local - Clean absolute paths (albertony) - Fix -L/--copy-links with filters missing directories (Nick Craig-Wood) - Mailru - Note that an app password is now needed (Nick Craig-Wood) - Allow timestamps to be before the epoch 1970-01-01 (Nick Craig-Wood) - S3 - Add provider quirk `--s3-might-gzip` to fix corrupted on transfer: sizes differ (Nick Craig-Wood) - Allow Storj to server side copy since it seems to work now (Nick Craig-Wood) - Fix for unchecked err value in s3 listv2 (Aaron Gokaslan) - Add additional Wasabi locations (techknowlogick) - Smb - Fix `Failed to sync: context canceled` at the end of syncs (Nick Craig-Wood) - WebDAV - Fix Move/Copy/DirMove when using -server-side-across-configs (Nick Craig-Wood) ## v1.60.0 - 2022-10-21 [See commits](https://github.com/rclone/rclone/compare/v1.59.0...v1.60.0) - New backends - [Oracle object storage](https://rclone.org/oracleobjectstorage/) (Manoj Ghosh) - [SMB](https://rclone.org/smb/) / CIFS (Windows file sharing) (Lesmiscore) - New S3 providers - [IONOS Cloud Storage](https://rclone.org/s3/#ionos) (Dmitry Deniskin) - [Qiniu KODO](https://rclone.org/s3/#qiniu) (Bachue Zhou) - New Features - build - Update to go1.19 and make go1.17 the minimum required version (Nick Craig-Wood) - Install.sh: fix arm-v7 download (Ole Frost) - fs: Warn the user when using an existing remote name without a colon (Nick Craig-Wood) - httplib: Add `--xxx-min-tls-version` option to select minimum TLS version for HTTP servers (Robert Newson) - librclone: Add PHP bindings and test program (Jordi Gonzalez Muñoz) - operations - Add `--server-side-across-configs` global flag for any backend (Nick Craig-Wood) - Optimise `--copy-dest` and `--compare-dest` (Nick Craig-Wood) - rc: add `job/stopgroup` to stop group (Evan Spensley) - serve dlna - Add `--announce-interval` to control SSDP Announce Interval (YanceyChiew) - Add `--interface` to Specify SSDP interface names line (Simon Bos) - Add support for more external subtitles (YanceyChiew) - Add verification of addresses (YanceyChiew) - sync: Optimise `--copy-dest` and `--compare-dest` (Nick Craig-Wood) - doc updates (albertony, Alexander Knorr, anonion, João Henrique Franco, Josh Soref, Lorenzo Milesi, Marco Molteni, Mark Trolley, Ole Frost, partev, Ryan Morey, Tom Mombourquette, YFdyh000) - Bug Fixes - filter - Fix incorrect filtering with `UseFilter` context flag and wrapping backends (Nick Craig-Wood) - Make sure we check `--files-from` when looking for a single file (Nick Craig-Wood) - rc - Fix `mount/listmounts` not returning the full Fs entered in `mount/mount` (Tom Mombourquette) - Handle external unmount when mounting (Isaac Aymerich) - Validate Daemon option is not set when mounting a volume via RC (Isaac Aymerich) - sync: Update docs and error messages to reflect fixes to overlap checks (Nick Naumann) - VFS - Reduce memory use by embedding `sync.Cond` (Nick Craig-Wood) - Reduce memory usage by re-ordering commonly used structures (Nick Craig-Wood) - Fix excess CPU used by VFS cache cleaner looping (Nick Craig-Wood) - Local - Obey file filters in listing to fix errors on excluded files (Nick Craig-Wood) - Fix "Failed to read metadata: function not implemented" on old Linux kernels (Nick Craig-Wood) - Compress - Fix crash due to nil metadata (Nick Craig-Wood) - Fix error handling to not use or return nil objects (Nick Craig-Wood) - Drive - Make `--drive-stop-on-upload-limit` obey quota exceeded error (Steve Kowalik) - FTP - Add `--ftp-force-list-hidden` option to show hidden items (Øyvind Heddeland Instefjord) - Fix hang when using ExplicitTLS to certain servers. (Nick Craig-Wood) - Google Cloud Storage - Add `--gcs-endpoint` flag and config parameter (Nick Craig-Wood) - Hubic - Remove backend as service has now shut down (Nick Craig-Wood) - Onedrive - Rename Onedrive(cn) 21Vianet to Vnet Group (Yen Hu) - Disable change notify in China region since it is not supported (Nick Craig-Wood) - S3 - Implement `--s3-versions` flag to show old versions of objects if enabled (Nick Craig-Wood) - Implement `--s3-version-at` flag to show versions of objects at a particular time (Nick Craig-Wood) - Implement `backend versioning` command to get/set bucket versioning (Nick Craig-Wood) - Implement `Purge` to purge versions and `backend cleanup-hidden` (Nick Craig-Wood) - Add `--s3-decompress` flag to decompress gzip-encoded files (Nick Craig-Wood) - Add `--s3-sse-customer-key-base64` to supply keys with binary data (Richard Bateman) - Try to keep the maximum precision in ModTime with `--user-server-modtime` (Nick Craig-Wood) - Drop binary metadata with an ERROR message as it can't be stored (Nick Craig-Wood) - Add `--s3-no-system-metadata` to suppress read and write of system metadata (Nick Craig-Wood) - SFTP - Fix directory creation races (Lesmiscore) - Swift - Add `--swift-no-large-objects` to reduce HEAD requests (Nick Craig-Wood) - Union - Propagate SlowHash feature to fix hasher interaction (Lesmiscore) ## v1.59.2 - 2022-09-15 [See commits](https://github.com/rclone/rclone/compare/v1.59.1...v1.59.2) - Bug Fixes - config: Move locking to fix fatal error: concurrent map read and map write (Nick Craig-Wood) - Local - Disable xattr support if the filesystems indicates it is not supported (Nick Craig-Wood) - Azure Blob - Fix chunksize calculations producing too many parts (Nick Craig-Wood) - B2 - Fix chunksize calculations producing too many parts (Nick Craig-Wood) - S3 - Fix chunksize calculations producing too many parts (Nick Craig-Wood) ## v1.59.1 - 2022-08-08 [See commits](https://github.com/rclone/rclone/compare/v1.59.0...v1.59.1) - Bug Fixes - accounting: Fix panic in core/stats-reset with unknown group (Nick Craig-Wood) - build: Fix android build after GitHub actions change (Nick Craig-Wood) - dlna: Fix SOAP action header parsing (Joram Schrijver) - docs: Fix links to mount command from install docs (albertony) - dropbox: Fix ChangeNotify was unable to decrypt errors (Nick Craig-Wood) - fs: Fix parsing of times and durations of the form "YYYY-MM-DD HH:MM:SS" (Nick Craig-Wood) - serve sftp: Fix checksum detection (Nick Craig-Wood) - sync: Add accidentally missed filter-sensitivity to --backup-dir option (Nick Naumann) - Combine - Fix docs showing `remote=` instead of `upstreams=` (Nick Craig-Wood) - Throw error if duplicate directory name is specified (Nick Craig-Wood) - Fix errors with backends shutting down while in use (Nick Craig-Wood) - Dropbox - Fix hang on quit with --dropbox-batch-mode off (Nick Craig-Wood) - Fix infinite loop on uploading a corrupted file (Nick Craig-Wood) - Internetarchive - Ignore checksums for files using the different method (Lesmiscore) - Handle hash symbol in the middle of filename (Lesmiscore) - Jottacloud - Fix working with whitelabel Elgiganten Cloud - Do not store username in config when using standard auth (albertony) - Mega - Fix nil pointer exception when bad node received (Nick Craig-Wood) - S3 - Fix --s3-no-head panic: reflect: Elem of invalid type s3.PutObjectInput (Nick Craig-Wood) - SFTP - Fix issue with WS_FTP by working around failing RealPath (albertony) - Union - Fix duplicated files when using directories with leading / (Nick Craig-Wood) - Fix multiple files being uploaded when roots don't exist (Nick Craig-Wood) - Fix panic due to misalignment of struct field in 32 bit architectures (r-ricci) ## v1.59.0 - 2022-07-09 [See commits](https://github.com/rclone/rclone/compare/v1.58.0...v1.59.0) - New backends - [Combine](/combine) multiple remotes in one directory tree (Nick Craig-Wood) - [Hidrive](https://rclone.org/hidrive/) (Ovidiu Victor Tatar) - [Internet Archive](https://rclone.org/internetarchive/) (Lesmiscore (Naoya Ozaki)) - New S3 providers - [ArvanCloud AOS](https://rclone.org/s3/#arvan-cloud) (ehsantdy) - [Cloudflare R2](https://rclone.org/s3/#cloudflare-r2) (Nick Craig-Wood) - [Huawei OBS](https://rclone.org/s3/#huawei-obs) (m00594701) - [IDrive e2](https://rclone.org/s3/#idrive-e2) (vyloy) - New commands - [test makefile](https://rclone.org/commands/rclone_test_makefile/): Create a single file for testing (Nick Craig-Wood) - New Features - [Metadata framework](https://rclone.org/docs/#metadata) to read and write system and user metadata on backends (Nick Craig-Wood) - Implemented initially for `local`, `s3` and `internetarchive` backends - `--metadata`/`-M` flag to control whether metadata is copied - `--metadata-set` flag to specify metadata for uploads - Thanks to [Manz Solutions](https://manz-solutions.at/) for sponsoring this work. - build - Update to go1.18 and make go1.16 the minimum required version (Nick Craig-Wood) - Update android go build to 1.18.x and NDK to 23.1.7779620 (Nick Craig-Wood) - All windows binaries now no longer CGO (Nick Craig-Wood) - Add `linux/arm/v6` to docker images (Nick Craig-Wood) - A huge number of fixes found with [staticcheck](https://staticcheck.io/) (albertony) - Configurable version suffix independent of version number (albertony) - check: Implement `--no-traverse` and `--no-unicode-normalization` (Nick Craig-Wood) - config: Readability improvements (albertony) - copyurl: Add `--header-filename` to honor the HTTP header filename directive (J-P Treen) - filter: Allow multiple `--exclude-if-present` flags (albertony) - fshttp: Add `--disable-http-keep-alives` to disable HTTP Keep Alives (Nick Craig-Wood) - install.sh - Set the modes on the files and/or directories on macOS (Michael C Tiernan - MIT-Research Computing Project) - Pre verify sudo authorization `-v` before calling curl. (Michael C Tiernan - MIT-Research Computing Project) - lib/encoder: Add Semicolon encoding (Nick Craig-Wood) - lsf: Add metadata support with `M` flag (Nick Craig-Wood) - lsjson: Add `--metadata`/`-M` flag (Nick Craig-Wood) - ncdu - Implement multi selection (CrossR) - Replace termbox with tcell's termbox wrapper (eNV25) - Display correct path in delete confirmation dialog (Roberto Ricci) - operations - Speed up hash checking by aborting the other hash if first returns nothing (Nick Craig-Wood) - Use correct src/dst in some log messages (zzr93) - rcat: Check checksums by default like copy does (Nick Craig-Wood) - selfupdate: Replace deprecated `x/crypto/openpgp` package with `ProtonMail/go-crypto` (albertony) - serve ftp: Check `--passive-port` arguments are correct (Nick Craig-Wood) - size: Warn about inaccurate results when objects with unknown size (albertony) - sync: Overlap check is now filter-sensitive so `--backup-dir` can be in the root provided it is filtered (Nick) - test info: Check file name lengths using 1,2,3,4 byte unicode characters (Nick Craig-Wood) - test makefile(s): `--sparse`, `--zero`, `--pattern`, `--ascii`, `--chargen` flags to control file contents (Nick Craig-Wood) - Make sure we call the `Shutdown` method on backends (Martin Czygan) - Bug Fixes - accounting: Fix unknown length file transfers counting 3 transfers each (buda) - ncdu: Fix issue where dir size is summed when file sizes are -1 (albertony) - sync/copy/move - Fix `--fast-list` `--create-empty-src-dirs` and `--exclude` (Nick Craig-Wood) - Fix `--max-duration` and `--cutoff-mode soft` (Nick Craig-Wood) - Fix fs cache unpin (Martin Czygan) - Set proper exit code for errors that are not low-level retried (e.g. size/timestamp changing) (albertony) - Mount - Support `windows/arm64` (may still be problems - see [#5828](https://github.com/rclone/rclone/issues/5828)) (Nick Craig-Wood) - Log IO errors at ERROR level (Nick Craig-Wood) - Ignore `_netdev` mount argument (Hugal31) - VFS - Add `--vfs-fast-fingerprint` for less accurate but faster fingerprints (Nick Craig-Wood) - Add `--vfs-disk-space-total-size` option to manually set the total disk space (Claudio Maradonna) - vfscache: Fix fatal error: sync: unlock of unlocked mutex error (Nick Craig-Wood) - Local - Fix parsing of `--local-nounc` flag (Nick Craig-Wood) - Add Metadata support (Nick Craig-Wood) - Crypt - Support metadata (Nick Craig-Wood) - Azure Blob - Calculate Chunksize/blocksize to stay below maxUploadParts (Leroy van Logchem) - Use chunksize lib to determine chunksize dynamically (Derek Battams) - Case insensitive access tier (Rob Pickerill) - Allow remote emulator (azurite) (Lorenzo Maiorfi) - B2 - Add `--b2-version-at` flag to show file versions at time specified (SwazRGB) - Use chunksize lib to determine chunksize dynamically (Derek Battams) - Chunker - Mark as not supporting metadata (Nick Craig-Wood) - Compress - Support metadata (Nick Craig-Wood) - Drive - Make `backend config -o config` add a combined `AllDrives:` remote (Nick Craig-Wood) - Make `--drive-shared-with-me` work with shared drives (Nick Craig-Wood) - Add `--drive-resource-key` for accessing link-shared files (Nick Craig-Wood) - Add backend commands `exportformats` and `importformats` for debugging (Nick Craig-Wood) - Fix 404 errors on copy/server side copy objects from public folder (Nick Craig-Wood) - Update Internal OAuth consent screen docs (Phil Shackleton) - Moved `root_folder_id` to advanced section (Abhiraj) - Dropbox - Migrate from deprecated api (m8rge) - Add logs to show when poll interval limits are exceeded (Nick Craig-Wood) - Fix nil pointer exception on dropbox impersonate user not found (Nick Craig-Wood) - Fichier - Parse api error codes and them accordingly (buengese) - FTP - Add support for `disable_utf8` option (Jason Zheng) - Revert to upstream `github.com/jlaffaye/ftp` from our fork (Nick Craig-Wood) - Google Cloud Storage - Add `--gcs-no-check-bucket` to minimise transactions and perms (Nick Gooding) - Add `--gcs-decompress` flag to decompress gzip-encoded files (Nick Craig-Wood) - by default these will be downloaded compressed (which previously failed) - Hasher - Support metadata (Nick Craig-Wood) - HTTP - Fix missing response when using custom auth handler (albertony) - Jottacloud - Add support for upload to custom device and mountpoint (albertony) - Always store username in config and use it to avoid initial API request (albertony) - Fix issue with server-side copy when destination is in trash (albertony) - Fix listing output of remote with special characters (albertony) - Mailru - Fix timeout by using int instead of time.Duration for keeping number of seconds (albertony) - Mega - Document using MEGAcmd to help with login failures (Art M. Gallagher) - Onedrive - Implement `--poll-interval` for onedrive (Hugo Laloge) - Add access scopes option (Sven Gerber) - Opendrive - Resolve lag and truncate bugs (Scott Grimes) - Pcloud - Fix about with no free space left (buengese) - Fix cleanup (buengese) - S3 - Use PUT Object instead of presigned URLs to upload single part objects (Nick Craig-Wood) - Backend restore command to skip non-GLACIER objects (Vincent Murphy) - Use chunksize lib to determine chunksize dynamically (Derek Battams) - Retry RequestTimeout errors (Nick Craig-Wood) - Implement reading and writing of metadata (Nick Craig-Wood) - SFTP - Add support for about and hashsum on windows server (albertony) - Use vendor-specific VFS statistics extension for about if available (albertony) - Add `--sftp-chunk-size` to control packets sizes for high latency links (Nick Craig-Wood) - Add `--sftp-concurrency` to improve high latency transfers (Nick Craig-Wood) - Add `--sftp-set-env` option to set environment variables (Nick Craig-Wood) - Add Hetzner Storage Boxes to supported sftp backends (Anthrazz) - Storj - Fix put which lead to the file being unreadable when using mount (Erik van Velzen) - Union - Add `min_free_space` option for `lfs`/`eplfs` policies (Nick Craig-Wood) - Fix uploading files to union of all bucket based remotes (Nick Craig-Wood) - Fix get free space for remotes which don't support it (Nick Craig-Wood) - Fix `eplus` policy to select correct entry for existing files (Nick Craig-Wood) - Support metadata (Nick Craig-Wood) - Uptobox - Fix root path handling (buengese) - WebDAV - Add SharePoint in other specific regions support (Noah Hsu) - Yandex - Handle api error on server-side move (albertony) - Zoho - Add Japan and China regions (buengese) ## v1.58.1 - 2022-04-29 [See commits](https://github.com/rclone/rclone/compare/v1.58.0...v1.58.1) - Bug Fixes - build: Update github.com/billziss-gh to github.com/winfsp (Nick Craig-Wood) - filter: Fix timezone of `--min-age`/`-max-age` from UTC to local as documented (Nick Craig-Wood) - rc/js: Correct RC method names (Sơn Trần-Nguyễn) - docs - Fix some links to command pages (albertony) - Add `--multi-thread-streams` note to `--transfers`. (Zsolt Ero) - Mount - Fix `--devname` and fusermount: unknown option 'fsname' when mounting via rc (Nick Craig-Wood) - VFS - Remove wording which suggests VFS is only for mounting (Nick Craig-Wood) - Dropbox - Fix retries of multipart uploads with incorrect_offset error (Nick Craig-Wood) - Google Cloud Storage - Use the s3 pacer to speed up transactions (Nick Craig-Wood) - pacer: Default the Google pacer to a burst of 100 to fix gcs pacing (Nick Craig-Wood) - Jottacloud - Fix scope in token request (albertony) - Netstorage - Fix unescaped HTML in documentation (Nick Craig-Wood) - Make levels of headings consistent (Nick Craig-Wood) - Add support contacts to netstorage doc (Nil Alexandrov) - Onedrive - Note that sharepoint also changes web files (.html, .aspx) (GH) - Putio - Handle rate limit errors (Berkan Teber) - Fix multithread download and other ranged requests (rafma0) - S3 - Add ChinaMobile EOS to provider list (GuoXingbin) - Sync providers in config description with providers (Nick Craig-Wood) - SFTP - Fix OpenSSH 8.8+ RSA keys incompatibility (KARBOWSKI Piotr) - Note that Scaleway C14 is deprecating SFTP in favor of S3 (Adrien Rey-Jarthon) - Storj - Fix bucket creation on Move (Nick Craig-Wood) - WebDAV - Don't override Referer if user sets it (Nick Craig-Wood) ## v1.58.0 - 2022-03-18 [See commits](https://github.com/rclone/rclone/compare/v1.57.0...v1.58.0) - New backends - [Akamai Netstorage](/netstorage) (Nil Alexandrov) - [Seagate Lyve](https://rclone.org/s3/#lyve), [SeaweedFS](/s3/#seaweedfs), [Storj](/s3/#storj), [RackCorp](/s3/#RackCorp) via s3 backend - [Storj](https://rclone.org/storj/) (renamed from Tardigrade - your old config files will continue working) - New commands - [bisync](https://rclone.org/bisync/) - experimental bidirectional cloud sync (Ivan Andreev, Chris Nelson) - New Features - build - Add `windows/arm64` build (`rclone mount` not supported yet) (Nick Craig-Wood) - Raise minimum go version to go1.15 (Nick Craig-Wood) - config: Allow dot in remote names and improve config editing (albertony) - dedupe: Add quit as a choice in interactive mode (albertony) - dlna: Change icons to the newest ones. (Alain Nussbaumer) - filter: Add [`{{ regexp }}` syntax](https://rclone.org/filtering/#regexp) to pattern matches (Nick Craig-Wood) - fshttp: Add prometheus metrics for HTTP status code (Michał Matczuk) - hashsum: Support creating hash from data received on stdin (albertony) - librclone - Allow empty string or null input instead of empty json object (albertony) - Add support for mount commands (albertony) - operations: Add server-side moves to stats (Ole Frost) - rc: Allow user to disable authentication for web gui (negative0) - tree: Remove obsolete `--human` replaced by global `--human-readable` (albertony) - version: Report correct friendly-name for newer Windows 10/11 versions (albertony) - Bug Fixes - build - Fix ARM architecture version in .deb packages after nfpm change (Nick Craig-Wood) - Hard fork `github.com/jlaffaye/ftp` to fix `go get github.com/rclone/rclone` (Nick Craig-Wood) - oauthutil: Fix crash when webbrowser requests `/robots.txt` (Nick Craig-Wood) - operations: Fix goroutine leak in case of copy retry (Ankur Gupta) - rc: - Fix `operations/publiclink` default for `expires` parameter (Nick Craig-Wood) - Fix missing computation of `transferQueueSize` when summing up statistics group (Carlo Mion) - Fix missing `StatsInfo` fields in the computation of the group sum (Carlo Mion) - sync: Fix `--max-duration` so it doesn't retry when the duration is exceeded (Nick Craig-Wood) - touch: Fix issue where a directory is created instead of a file (albertony) - Mount - Add `--devname` to set the device name sent to FUSE for mount display (Nick Craig-Wood) - VFS - Add `vfs/stats` remote control to show statistics (Nick Craig-Wood) - Fix `failed to _ensure cache internal error: downloaders is nil error` (Nick Craig-Wood) - Fix handling of special characters in file names (Bumsu Hyeon) - Local - Fix hash invalidation which caused errors with local crypt mount (Nick Craig-Wood) - Crypt - Add `base64` and `base32768` filename encoding options (Max Sum, Sinan Tan) - Azure Blob - Implement `--azureblob-upload-concurrency` parameter to speed uploads (Nick Craig-Wood) - Remove 100MB upper limit on `chunk_size` as it is no longer needed (Nick Craig-Wood) - Raise `--azureblob-upload-concurrency` to 16 by default (Nick Craig-Wood) - Fix crash with SAS URL and no container (Nick Craig-Wood) - Compress - Fix crash if metadata upload failed (Nick Craig-Wood) - Fix memory leak (Nick Craig-Wood) - Drive - Added `--drive-copy-shortcut-content` (Abhiraj) - Disable OAuth OOB flow (copy a token) due to Google deprecation (Nick Craig-Wood) - See [the deprecation note](https://developers.googleblog.com/2022/02/making-oauth-flows-safer.html#disallowed-oob). - Add `--drive-skip-dangling-shortcuts` flag (Nick Craig-Wood) - When using a link type `--drive-export-formats` shows all doc types (Nick Craig-Wood) - Dropbox - Speed up directory listings by specifying 1000 items in a chunk (Nick Craig-Wood) - Save an API request when at the root (Nick Craig-Wood) - Fichier - Implemented About functionality (Gourav T) - FTP - Add `--ftp-ask-password` to prompt for password when needed (Borna Butkovic) - Google Cloud Storage - Add missing regions (Nick Craig-Wood) - Disable OAuth OOB flow (copy a token) due to Google deprecation (Nick Craig-Wood) - See [the deprecation note](https://developers.googleblog.com/2022/02/making-oauth-flows-safer.html#disallowed-oob). - Googlephotos - Disable OAuth OOB flow (copy a token) due to Google deprecation (Nick Craig-Wood) - See [the deprecation note](https://developers.googleblog.com/2022/02/making-oauth-flows-safer.html#disallowed-oob). - Hasher - Fix crash on object not found (Nick Craig-Wood) - Hdfs - Add file (Move) and directory move (DirMove) support (Andy Jackson) - HTTP - Improved recognition of URL pointing to a single file (albertony) - Jottacloud - Change API used by recursive list (ListR) (Kim) - Add support for Tele2 Cloud (Fredric Arklid) - Koofr - Add Digistorage service as a Koofr provider. (jaKa) - Mailru - Fix int32 overflow on arm32 (Ivan Andreev) - Onedrive - Add config option for oauth scope `Sites.Read.All` (Charlie Jiang) - Minor optimization of quickxorhash (Isaac Levy) - Add `--onedrive-root-folder-id` flag (Nick Craig-Wood) - Do not retry on `400 pathIsTooLong` error (ctrl-q) - Pcloud - Add support for recursive list (ListR) (Niels van de Weem) - Fix pre-1970 time stamps (Nick Craig-Wood) - S3 - Use `ListObjectsV2` for faster listings (Felix Bünemann) - Fallback to `ListObject` v1 on unsupported providers (Nick Craig-Wood) - Use the `ETag` on multipart transfers to verify the transfer was OK (Nick Craig-Wood) - Add `--s3-use-multipart-etag` provider quirk to disable this on unsupported providers (Nick Craig-Wood) - New Providers - RackCorp object storage (bbabich) - Seagate Lyve Cloud storage (Nick Craig-Wood) - SeaweedFS (Chris Lu) - Storj Shared gateways (Márton Elek, Nick Craig-Wood) - Add Wasabi AP Northeast 2 endpoint info (lindwurm) - Add `GLACIER_IR` storage class (Yunhai Luo) - Document `Content-MD5` workaround for object-lock enabled buckets (Paulo Martins) - Fix multipart upload with `--no-head` flag (Nick Craig-Wood) - Simplify content length processing in s3 with download url (Logeshwaran Murugesan) - SFTP - Add rclone to list of supported `md5sum`/`sha1sum` commands to look for (albertony) - Refactor so we only have one way of running remote commands (Nick Craig-Wood) - Fix timeout on hashing large files by sending keepalives (Nick Craig-Wood) - Fix unnecessary seeking when uploading and downloading files (Nick Craig-Wood) - Update docs on how to create `known_hosts` file (Nick Craig-Wood) - Storj - Rename tardigrade backend to storj backend (Nick Craig-Wood) - Implement server side Move for files (Nick Craig-Wood) - Update docs to explain differences between s3 and this backend (Elek, Márton) - Swift - Fix About so it shows info about the current container only (Nick Craig-Wood) - Union - Fix treatment of remotes with `//` in (Nick Craig-Wood) - Fix deadlock when one part of a multi-upload fails (Nick Craig-Wood) - Fix eplus policy returned nil (Vitor Arruda) - Yandex - Add permanent deletion support (deinferno) ## v1.57.0 - 2021-11-01 [See commits](https://github.com/rclone/rclone/compare/v1.56.0...v1.57.0) - New backends - Sia: for Sia decentralized cloud (Ian Levesque, Matthew Sevey, Ivan Andreev) - Hasher: caches hashes and enable hashes for backends that don't support them (Ivan Andreev) - New commands - lsjson --stat: to get info about a single file/dir and `operations/stat` api (Nick Craig-Wood) - config paths: show configured paths (albertony) - New Features - about: Make human-readable output more consistent with other commands (albertony) - build - Use go1.17 for building and make go1.14 the minimum supported (Nick Craig-Wood) - Update Go to 1.16 and NDK to 22b for Android builds (x0b) - config - Support hyphen in remote name from environment variable (albertony) - Make temporary directory user-configurable (albertony) - Convert `--cache-dir` value to an absolute path (albertony) - Do not override MIME types from OS defaults (albertony) - docs - Toc styling and header levels cleanup (albertony) - Extend documentation on valid remote names (albertony) - Mention make for building and cmount tag for macos (Alex Chen) - ...and many more contributions to numerous to mention! - fs: Move with `--ignore-existing` will not delete skipped files (Nathan Collins) - hashsum - Treat hash values in sum file as case insensitive (Ivan Andreev) - Don't put `ERROR` or `UNSUPPORTED` in output (Ivan Andreev) - lib/encoder: Add encoding of square brackets (Ivan Andreev) - lib/file: Improve error message when attempting to create dir on nonexistent drive on windows (albertony) - lib/http: Factor password hash salt into options with default (Nolan Woods) - lib/kv: Add key-value database api (Ivan Andreev) - librclone - Add `RcloneFreeString` function (albertony) - Free strings in python example (albertony) - log: Optionally print pid in logs (Ivan Andreev) - ls: Introduce `--human-readable` global option to print human-readable sizes (albertony) - ncdu: Introduce key `u` to toggle human-readable (albertony) - operations: Add `rmdirs -v` output (Justin Winokur) - serve sftp - Generate an ECDSA server key as well as RSA (Nick Craig-Wood) - Generate an Ed25519 server key as well as ECDSA and RSA (albertony) - serve docker - Allow to customize proxy settings of docker plugin (Ivan Andreev) - Build docker plugin for multiple platforms (Thomas Stachl) - size: Include human-readable count (albertony) - touch: Add support for touching files in directory, with recursive option, filtering and `--dry-run`/`-i` (albertony) - tree: Option to print human-readable sizes removed in favor of global option (albertony) - Bug Fixes - lib/http - Fix bad username check in single auth secret provider (Nolan Woods) - Fix handling of SSL credentials (Nolan Woods) - serve ftp: Ensure modtime is passed as UTC always to fix timezone oddities (Nick Craig-Wood) - serve sftp: Fix generation of server keys on windows (albertony) - serve docker: Fix octal umask (Ivan Andreev) - Mount - Enable rclone to be run as mount helper direct from the fstab (Ivan Andreev) - Use procfs to validate mount on linux (Ivan Andreev) - Correctly daemonize for compatibility with automount (Ivan Andreev) - VFS - Ensure names used in cache path are legal on current OS (albertony) - Ignore `ECLOSED` when truncating file handles to fix intermittent bad file descriptor error (Nick Craig-Wood) - Local - Refactor default OS encoding out from local backend into shared encoder lib (albertony) - Crypt - Return wrapped object even with `--crypt-no-data-encryption` (Ivan Andreev) - Fix uploads with `--crypt-no-data-encryption` (Nick Craig-Wood) - Azure Blob - Add `--azureblob-no-head-object` (Tatsuya Noyori) - Box - Make listings of heavily used directories more reliable (Nick Craig-Wood) - When doing cleanup delete as much as possible (Nick Craig-Wood) - Add `--box-list-chunk` to control listing chunk size (Nick Craig-Wood) - Delete items in parallel in cleanup using `--checkers` threads (Nick Craig-Wood) - Add `--box-owned-by` to only show items owned by the login passed (Nick Craig-Wood) - Retry `operation_blocked_temporary` errors (Nick Craig-Wood) - Chunker - Md5all must create metadata if base hash is slow (Ivan Andreev) - Drive - Speed up directory listings by constraining the API listing using the current filters (fotile96, Ivan Andreev) - Fix buffering for single request upload for files smaller than `--drive-upload-cutoff` (YenForYang) - Add `-o config` option to `backend drives` to make config for all shared drives (Nick Craig-Wood) - Dropbox - Add `--dropbox-batch-commit-timeout` to control batch timeout (Nick Craig-Wood) - Filefabric - Make backoff exponential for error_background to fix errors (Nick Craig-Wood) - Fix directory move after API change (Nick Craig-Wood) - FTP - Enable tls session cache by default (Ivan Andreev) - Add option to disable tls13 (Ivan Andreev) - Fix timeout after long uploads (Ivan Andreev) - Add support for precise time (Ivan Andreev) - Enable CI for ProFtpd, PureFtpd, VsFtpd (Ivan Andreev) - Googlephotos - Use encoder for album names to fix albums with control characters (Parth Shukla) - Jottacloud - Implement `SetModTime` to support modtime-only changes (albertony) - Improved error handling with `SetModTime` and corrupt files in general (albertony) - Add support for `UserInfo` (`rclone config userinfo`) feature (albertony) - Return direct download link from `rclone link` command (albertony) - Koofr - Create direct share link (Dmitry Bogatov) - Pcloud - Add sha256 support (Ken Enrique Morel) - Premiumizeme - Fix directory listing after API changes (Nick Craig-Wood) - Fix server side move after API change (Nick Craig-Wood) - Fix server side directory move after API changes (Nick Craig-Wood) - S3 - Add support to use CDN URL to download the file (Logeshwaran) - Add AWS Snowball Edge to providers examples (r0kk3rz) - Use a combination of SDK retries and rclone retries (Nick Craig-Wood) - Fix IAM Role for Service Account not working and other auth problems (Nick Craig-Wood) - Fix `shared_credentials_file` auth after reverting incorrect fix (Nick Craig-Wood) - Fix corrupted on transfer: sizes differ 0 vs xxxx with Ceph (Nick Craig-Wood) - Seafile - Fix error when not configured for 2fa (Fred) - SFTP - Fix timeout when doing MD5SUM of large file (Nick Craig-Wood) - Swift - Update OCI URL (David Liu) - Document OVH Cloud Archive (HNGamingUK) - Union - Fix rename not working with union of local disk and bucket based remote (Nick Craig-Wood) ## v1.56.2 - 2021-10-01 [See commits](https://github.com/rclone/rclone/compare/v1.56.1...v1.56.2) - Bug Fixes - serve http: Re-add missing auth to http service (Nolan Woods) - build: Update golang.org/x/sys to fix crash on macOS when compiled with go1.17 (Herby Gillot) - FTP - Fix deadlock after failed update when concurrency=1 (Ivan Andreev) ## v1.56.1 - 2021-09-19 [See commits](https://github.com/rclone/rclone/compare/v1.56.0...v1.56.1) - Bug Fixes - accounting: Fix maximum bwlimit by scaling scale max token bucket size (Nick Craig-Wood) - rc: Fix speed does not update in core/stats (negative0) - selfupdate: Fix `--quiet` option, not quite quiet (yedamo) - serve http: Fix `serve http` exiting directly after starting (Cnly) - build - Apply gofmt from golang 1.17 (Ivan Andreev) - Update Go to 1.16 and NDK to 22b for android/any (x0b) - Mount - Fix `--daemon` mode (Ivan Andreev) - VFS - Fix duplicates on rename (Nick Craig-Wood) - Fix crash when truncating a just uploaded object (Nick Craig-Wood) - Fix issue where empty dirs would build up in cache meta dir (albertony) - Drive - Fix instructions for auto config (Greg Sadetsky) - Fix lsf example without drive-impersonate (Greg Sadetsky) - Onedrive - Handle HTTP 400 better in PublicLink (Alex Chen) - Clarification of the process for creating custom client_id (Mariano Absatz) - Pcloud - Return an early error when Put is called with an unknown size (Nick Craig-Wood) - Try harder to delete a failed upload (Nick Craig-Wood) - S3 - Add Wasabi's AP-Northeast endpoint info (hota) - Fix typo in s3 documentation (Greg Sadetsky) - Seafile - Fix 2fa config state machine (Fred) - SFTP - Remove spurious error message on `--sftp-disable-concurrent-reads` (Nick Craig-Wood) - Sugarsync - Fix initial connection after config re-arrangement (Nick Craig-Wood) ## v1.56.0 - 2021-07-20 [See commits](https://github.com/rclone/rclone/compare/v1.55.0...v1.56.0) - New backends - [Uptobox](https://rclone.org/uptobox/) (buengese) - New commands - [serve docker](https://rclone.org/commands/rclone_serve_docker/) (Antoine GIRARD) (Ivan Andreev) - and accompanying [docker volume plugin](https://rclone.org/docker/) - [checksum](https://rclone.org/commands/rclone_checksum/) to check files against a file of checksums (Ivan Andreev) - this is also available as `rclone md5sum -C` etc - [config touch](https://rclone.org/commands/rclone_config_touch/): ensure config exists at configured location (albertony) - [test changenotify](https://rclone.org/commands/rclone_test_changenotify/): command to help debugging changenotify (Nick Craig-Wood) - Deprecations - `dbhashsum`: Remove command deprecated a year ago (Ivan Andreev) - `cache`: Deprecate cache backend (Ivan Andreev) - New Features - rework config system so it can be used non-interactively via cli and rc API. - See docs in [config create](https://rclone.org/commands/rclone_config_create/) - This is a very big change to all the backends so may cause breakages - please file bugs! - librclone - export the rclone RC as a C library (lewisxy) (Nick Craig-Wood) - Link a C-API rclone shared object into your project - Use the RC as an in memory interface - Python example supplied - Also supports Android and gomobile - fs - Add `--disable-http2` for global http2 disable (Nick Craig-Wood) - Make `--dump` imply `-vv` (Alex Chen) - Use binary prefixes for size and rate units (albertony) - Use decimal prefixes for counts (albertony) - Add google search widget to rclone.org (Ivan Andreev) - accounting: Calculate rolling average speed (Haochen Tong) - atexit: Terminate with non-zero status after receiving signal (Michael Hanselmann) - build - Only run event-based workflow scripts under rclone repo with manual override (Mathieu Carbou) - Add Android build with gomobile (x0b) - check: Log the hash in use like cryptcheck does (Nick Craig-Wood) - version: Print os/version, kernel and bitness (Ivan Andreev) - config - Prevent use of Windows reserved names in config file name (albertony) - Create config file in windows appdata directory by default (albertony) - Treat any config file paths with filename notfound as memory-only config (albertony) - Delay load config file (albertony) - Replace defaultConfig with a thread-safe in-memory implementation (Chris Macklin) - Allow `config create` and friends to take `key=value` parameters (Nick Craig-Wood) - Fixed issues with flags/options set by environment vars. (Ole Frost) - fshttp: Implement graceful DSCP error handling (Tyson Moore) - lib/http - provides an abstraction for a central http server that services can bind routes to (Nolan Woods) - Add `--template` config and flags to serve/data (Nolan Woods) - Add default 404 handler (Nolan Woods) - link: Use "off" value for unset expiry (Nick Craig-Wood) - oauthutil: Raise fatal error if token expired without refresh token (Alex Chen) - rcat: Add `--size` flag for more efficient uploads of known size (Nazar Mishturak) - serve sftp: Add `--stdio` flag to serve via stdio (Tom) - sync: Don't warn about `--no-traverse` when `--files-from` is set (Nick Gaya) - `test makefiles` - Add `--seed` flag and make data generated repeatable (Nick Craig-Wood) - Add log levels and speed summary (Nick Craig-Wood) - Bug Fixes - accounting: Fix startTime of statsGroups.sum (Haochen Tong) - cmd/ncdu: Fix out of range panic in delete (buengese) - config - Fix issues with memory-only config file paths (albertony) - Fix in memory config not saving on the fly backend config (Nick Craig-Wood) - fshttp: Fix address parsing for DSCP (Tyson Moore) - ncdu: Update termbox-go library to fix crash (Nick Craig-Wood) - oauthutil: Fix old authorize result not recognised (Cnly) - operations: Don't update timestamps of files in `--compare-dest` (Nick Gaya) - selfupdate: fix archive name on macos (Ivan Andreev) - Mount - Refactor before adding serve docker (Antoine GIRARD) - VFS - Add cache reset for `--vfs-cache-max-size` handling at cache poll interval (Leo Luan) - Fix modtime changing when reading file into cache (Nick Craig-Wood) - Avoid unnecessary subdir in cache path (albertony) - Fix that umask option cannot be set as environment variable (albertony) - Do not print notice about missing poll-interval support when set to 0 (albertony) - Local - Always use readlink to read symlink size for better compatibility (Nick Craig-Wood) - Add `--local-unicode-normalization` (and remove `--local-no-unicode-normalization`) (Nick Craig-Wood) - Skip entries removed concurrently with List() (Ivan Andreev) - Crypt - Support timestamped filenames from `--b2-versions` (Dominik Mydlil) - B2 - Don't include the bucket name in public link file prefixes (Jeffrey Tolar) - Fix versions and .files with no extension (Nick Craig-Wood) - Factor version handling into lib/version (Dominik Mydlil) - Box - Use upload preflight check to avoid listings in file uploads (Nick Craig-Wood) - Return errors instead of calling log.Fatal with them (Nick Craig-Wood) - Drive - Switch to the Drives API for looking up shared drives (Nick Craig-Wood) - Fix some google docs being treated as files (Nick Craig-Wood) - Dropbox - Add `--dropbox-batch-mode` flag to speed up uploading (Nick Craig-Wood) - Read the [batch mode](https://rclone.org/dropbox/#batch-mode) docs for more info - Set visibility in link sharing when `--expire` is set (Nick Craig-Wood) - Simplify chunked uploads (Alexey Ivanov) - Improve "own App IP" instructions (Ivan Andreev) - Fichier - Check if more than one upload link is returned (Nick Craig-Wood) - Support downloading password protected files and folders (Florian Penzkofer) - Make error messages report text from the API (Nick Craig-Wood) - Fix move of files in the same directory (Nick Craig-Wood) - Check that we actually got a download token and retry if we didn't (buengese) - Filefabric - Fix listing after change of from field from "int" to int. (Nick Craig-Wood) - FTP - Make upload error 250 indicate success (Nick Craig-Wood) - GCS - Make compatible with gsutil's mtime metadata (database64128) - Clean up time format constants (database64128) - Google Photos - Fix read only scope not being used properly (Nick Craig-Wood) - HTTP - Replace httplib with lib/http (Nolan Woods) - Clean up Bind to better use middleware (Nolan Woods) - Jottacloud - Fix legacy auth with state based config system (buengese) - Fix invalid url in output from link command (albertony) - Add no versions option (buengese) - Onedrive - Add `list_chunk option` (Nick Gaya) - Also report root error if unable to cancel multipart upload (Cnly) - Fix failed to configure: empty token found error (Nick Craig-Wood) - Make link return direct download link (Xuanchen Wu) - S3 - Add `--s3-no-head-object` (Tatsuya Noyori) - Remove WebIdentityRoleProvider to fix crash on auth (Nick Craig-Wood) - Don't check to see if remote is object if it ends with / (Nick Craig-Wood) - Add SeaweedFS (Chris Lu) - Update Alibaba OSS endpoints (Chuan Zh) - SFTP - Fix performance regression by re-enabling concurrent writes (Nick Craig-Wood) - Expand tilde and environment variables in configured `known_hosts_file` (albertony) - Tardigrade - Upgrade to uplink v1.4.6 (Caleb Case) - Use negative offset (Caleb Case) - Add warning about `too many open files` (acsfer) - WebDAV - Fix sharepoint auth over http (Nick Craig-Wood) - Add headers option (Antoon Prins) ## v1.55.1 - 2021-04-26 [See commits](https://github.com/rclone/rclone/compare/v1.55.0...v1.55.1) - Bug Fixes - selfupdate - Dont detect FUSE if build is static (Ivan Andreev) - Add build tag noselfupdate (Ivan Andreev) - sync: Fix incorrect error reported by graceful cutoff (Nick Craig-Wood) - install.sh: fix macOS arm64 download (Nick Craig-Wood) - build: Fix version numbers in android branch builds (Nick Craig-Wood) - docs - Contributing.md: update setup instructions for go1.16 (Nick Gaya) - WinFsp 2021 is out of beta (albertony) - Minor cleanup of space around code section (albertony) - Fixed some typos (albertony) - VFS - Fix a code path which allows dirty data to be removed causing data loss (Nick Craig-Wood) - Compress - Fix compressed name regexp (buengese) - Drive - Fix backend copyid of google doc to directory (Nick Craig-Wood) - Don't open browser when service account... (Ansh Mittal) - Dropbox - Add missing team_data.member scope for use with --impersonate (Nick Craig-Wood) - Fix About after scopes changes - rclone config reconnect needed (Nick Craig-Wood) - Fix Unable to decrypt returned paths from changeNotify (Nick Craig-Wood) - FTP - Fix implicit TLS (Ivan Andreev) - Onedrive - Work around for random "Unable to initialize RPS" errors (OleFrost) - SFTP - Revert sftp library to v1.12.0 from v1.13.0 to fix performance regression (Nick Craig-Wood) - Fix Update ReadFrom failed: failed to send packet: EOF errors (Nick Craig-Wood) - Zoho - Fix error when region isn't set (buengese) - Do not ask for mountpoint twice when using headless setup (buengese) ## v1.55.0 - 2021-03-31 [See commits](https://github.com/rclone/rclone/compare/v1.54.0...v1.55.0) - New commands - [selfupdate](https://rclone.org/commands/rclone_selfupdate/) (Ivan Andreev) - Allows rclone to update itself in-place or via a package (using `--package` flag) - Reads cryptographically signed signatures for non beta releases - Works on all OSes. - [test](https://rclone.org/commands/rclone_test/) - these are test commands - use with care! - `histogram` - Makes a histogram of file name characters. - `info` - Discovers file name or other limitations for paths. - `makefiles` - Make a random file hierarchy for testing. - `memory` - Load all the objects at remote:path into memory and report memory stats. - New Features - [Connection strings](https://rclone.org/docs/#connection-strings) - Config parameters can now be passed as part of the remote name as a connection string. - For example, to do the equivalent of `--drive-shared-with-me` use `drive,shared_with_me:` - Make sure we don't save on the fly remote config to the config file (Nick Craig-Wood) - Make sure backends with additional config have a different name for caching (Nick Craig-Wood) - This work was sponsored by CERN, through the [CS3MESH4EOSC Project](https://cs3mesh4eosc.eu/). - CS3MESH4EOSC has received funding from the European Union’s Horizon 2020 - research and innovation programme under Grant Agreement no. 863353. - build - Update go build version to go1.16 and raise minimum go version to go1.13 (Nick Craig-Wood) - Make a macOS ARM64 build to support Apple Silicon (Nick Craig-Wood) - Install macfuse 4.x instead of osxfuse 3.x (Nick Craig-Wood) - Use `GO386=softfloat` instead of deprecated `GO386=387` for 386 builds (Nick Craig-Wood) - Disable IOS builds for the time being (Nick Craig-Wood) - Androids builds made with up to date NDK (x0b) - Add an rclone user to the Docker image but don't use it by default (cynthia kwok) - dedupe: Make largest directory primary to minimize data moved (Saksham Khanna) - config - Wrap config library in an interface (Fionera) - Make config file system pluggable (Nick Craig-Wood) - `--config ""` or `"/notfound"` for in memory config only (Nick Craig-Wood) - Clear fs cache of stale entries when altering config (Nick Craig-Wood) - copyurl: Add option to print resulting auto-filename (albertony) - delete: Make `--rmdirs` obey the filters (Nick Craig-Wood) - docs - many fixes and reworks from edwardxml, albertony, pvalls, Ivan Andreev, Evan Harris, buengese, Alexey Tabakman - encoder/filename - add SCSU as tables (Klaus Post) - Add multiple paths support to `--compare-dest` and `--copy-dest` flag (K265) - filter: Make `--exclude "dir/"` equivalent to `--exclude "dir/**"` (Nick Craig-Wood) - fshttp: Add DSCP support with `--dscp` for QoS with differentiated services (Max Sum) - lib/cache: Add Delete and DeletePrefix methods (Nick Craig-Wood) - lib/file - Make pre-allocate detect disk full errors and return them (Nick Craig-Wood) - Don't run preallocate concurrently (Nick Craig-Wood) - Retry preallocate on EINTR (Nick Craig-Wood) - operations: Made copy and sync operations obey a RetryAfterError (Ankur Gupta) - rc - Add string alternatives for setting options over the rc (Nick Craig-Wood) - Add `options/local` to see the options configured in the context (Nick Craig-Wood) - Add `_config` parameter to set global config for just this rc call (Nick Craig-Wood) - Implement passing filter config with `_filter` parameter (Nick Craig-Wood) - Add `fscache/clear` and `fscache/entries` to control the fs cache (Nick Craig-Wood) - Avoid +Inf value for speed in `core/stats` (albertony) - Add a full set of stats to `core/stats` (Nick Craig-Wood) - Allow `fs=` params to be a JSON blob (Nick Craig-Wood) - rcd: Added systemd notification during the `rclone rcd` command. (Naveen Honest Raj) - rmdirs: Make `--rmdirs` obey the filters (Nick Craig-Wood) - version: Show build tags and type of executable (Ivan Andreev) - Bug Fixes - install.sh: make it fail on download errors (Ivan Andreev) - Fix excessive retries missing `--max-duration` timeout (Nick Craig-Wood) - Fix crash when `--low-level-retries=0` (Nick Craig-Wood) - Fix failed token refresh on mounts created via the rc (Nick Craig-Wood) - fshttp: Fix bandwidth limiting after bad merge (Nick Craig-Wood) - lib/atexit - Unregister interrupt handler once it has fired so users can interrupt again (Nick Craig-Wood) - Fix occasional failure to unmount with CTRL-C (Nick Craig-Wood) - Fix deadlock calling Finalise while Run is running (Nick Craig-Wood) - lib/rest: Fix multipart uploads not stopping on context cancel (Nick Craig-Wood) - Mount - Allow mounting to root directory on windows (albertony) - Improved handling of relative paths on windows (albertony) - Fix unicode issues with accented characters on macOS (Nick Craig-Wood) - Docs: document the new FileSecurity option in WinFsp 2021 (albertony) - Docs: add note about volume path syntax on windows (albertony) - Fix caching of old directories after renaming them (Nick Craig-Wood) - Update cgofuse to the latest version to bring in macfuse 4 fix (Nick Craig-Wood) - VFS - `--vfs-used-is-size` to report used space using recursive scan (tYYGH) - Don't set modification time if it was already correct (Nick Craig-Wood) - Fix Create causing windows explorer to truncate files on CTRL-C CTRL-V (Nick Craig-Wood) - Fix modtimes not updating when writing via cache (Nick Craig-Wood) - Fix modtimes changing by fractional seconds after upload (Nick Craig-Wood) - Fix modtime set if `--vfs-cache-mode writes`/`full` and no write (Nick Craig-Wood) - Rename files in cache and cancel uploads on directory rename (Nick Craig-Wood) - Fix directory renaming by renaming dirs cached in memory (Nick Craig-Wood) - Local - Add flag `--local-no-preallocate` (David Sze) - Make `nounc` an advanced option except on Windows (albertony) - Don't ignore preallocate disk full errors (Nick Craig-Wood) - Cache - Add `--fs-cache-expire-duration` to control the fs cache (Nick Craig-Wood) - Crypt - Add option to not encrypt data (Vesnyx) - Log hash ok on upload (albertony) - Azure Blob - Add container public access level support. (Manish Kumar) - B2 - Fix HTML files downloaded via cloudflare (Nick Craig-Wood) - Box - Fix transfers getting stuck on token expiry after API change (Nick Craig-Wood) - Chunker - Partially implement no-rename transactions (Maxwell Calman) - Drive - Don't stop server side copy if couldn't read description (Nick Craig-Wood) - Pass context on to drive SDK - to help with cancellation (Nick Craig-Wood) - Dropbox - Add polling for changes support (Robert Thomas) - Make `--timeout 0` work properly (Nick Craig-Wood) - Raise priority of rate limited message to INFO to make it more noticeable (Nick Craig-Wood) - Fichier - Implement copy & move (buengese) - Implement public link (buengese) - FTP - Implement Shutdown method (Nick Craig-Wood) - Close idle connections after `--ftp-idle-timeout` (1m by default) (Nick Craig-Wood) - Make `--timeout 0` work properly (Nick Craig-Wood) - Add `--ftp-close-timeout` flag for use with awkward ftp servers (Nick Craig-Wood) - Retry connections and logins on 421 errors (Nick Craig-Wood) - Hdfs - Fix permissions for when directory is created (Lucas Messenger) - Onedrive - Make `--timeout 0` work properly (Nick Craig-Wood) - S3 - Fix `--s3-profile` which wasn't working (Nick Craig-Wood) - SFTP - Close idle connections after `--sftp-idle-timeout` (1m by default) (Nick Craig-Wood) - Fix "file not found" errors for read once servers (Nick Craig-Wood) - Fix SetModTime stat failed: object not found with `--sftp-set-modtime=false` (Nick Craig-Wood) - Swift - Update github.com/ncw/swift to v2.0.0 (Nick Craig-Wood) - Implement copying large objects (nguyenhuuluan434) - Union - Fix crash when using epff policy (Nick Craig-Wood) - Fix union attempting to update files on a read only file system (Nick Craig-Wood) - Refactor to use fspath.SplitFs instead of fs.ParseRemote (Nick Craig-Wood) - Fix initialisation broken in refactor (Nick Craig-Wood) - WebDAV - Add support for sharepoint with NTLM authentication (Rauno Ots) - Make sharepoint-ntlm docs more consistent (Alex Chen) - Improve terminology in sharepoint-ntlm docs (Ivan Andreev) - Disable HTTP/2 for NTLM authentication (georne) - Fix sharepoint-ntlm error 401 for parallel actions (Ivan Andreev) - Check that purged directory really exists (Ivan Andreev) - Yandex - Make `--timeout 0` work properly (Nick Craig-Wood) - Zoho - Replace client id - you will need to `rclone config reconnect` after this (buengese) - Add forgotten setupRegion() to NewFs - this finally fixes regions other than EU (buengese) ## v1.54.1 - 2021-03-08 [See commits](https://github.com/rclone/rclone/compare/v1.54.0...v1.54.1) - Bug Fixes - accounting: Fix --bwlimit when up or down is off (Nick Craig-Wood) - docs - Fix nesting of brackets and backticks in ftp docs (edwardxml) - Fix broken link in sftp page (edwardxml) - Fix typo in crypt.md (Romeo Kienzler) - Changelog: Correct link to digitalis.io (Alex JOST) - Replace #file-caching with #vfs-file-caching (Miron Veryanskiy) - Convert bogus example link to code (edwardxml) - Remove dead link from rc.md (edwardxml) - rc: Sync,copy,move: document createEmptySrcDirs parameter (Nick Craig-Wood) - lsjson: Fix unterminated JSON in the presence of errors (Nick Craig-Wood) - Mount - Fix mount dropping on macOS by setting --daemon-timeout 10m (Nick Craig-Wood) - VFS - Document simultaneous usage with the same cache shouldn't be used (Nick Craig-Wood) - B2 - Automatically raise upload cutoff to avoid spurious error (Nick Craig-Wood) - Fix failed to create file system with application key limited to a prefix (Nick Craig-Wood) - Drive - Refer to Shared Drives instead of Team Drives (Nick Craig-Wood) - Dropbox - Add scopes to oauth request and optionally "members.read" (Nick Craig-Wood) - S3 - Fix failed to create file system with folder level permissions policy (Nick Craig-Wood) - Fix Wasabi HEAD requests returning stale data by using only 1 transport (Nick Craig-Wood) - Fix shared_credentials_file auth (Dmitry Chepurovskiy) - Add --s3-no-head to reducing costs docs (Nick Craig-Wood) - Union - Fix mkdir at root with remote:/ (Nick Craig-Wood) - Zoho - Fix custom client id's (buengese) ## v1.54.0 - 2021-02-02 [See commits](https://github.com/rclone/rclone/compare/v1.53.0...v1.54.0) - New backends - Compression remote (experimental) (buengese) - Enterprise File Fabric (Nick Craig-Wood) - This work was sponsored by [Storage Made Easy](https://storagemadeeasy.com/) - HDFS (Hadoop Distributed File System) (Yury Stankevich) - Zoho workdrive (buengese) - New Features - Deglobalise the config (Nick Craig-Wood) - Global config now read from the context - This will enable passing of global config via the rc - This work was sponsored by [Digitalis](https://digitalis.io/) - Add `--bwlimit` for upload and download (Nick Craig-Wood) - Obey bwlimit in http Transport for better limiting - Enhance systemd integration (Hekmon) - log level identification, manual activation with flag, automatic systemd launch detection - Don't compile systemd log integration for non unix systems (Benjamin Gustin) - Add a `--download` flag to md5sum/sha1sum/hashsum to force rclone to download and hash files locally (lostheli) - Add `--progress-terminal-title` to print ETA to terminal title (LaSombra) - Make backend env vars show in help as the defaults for backend flags (Nick Craig-Wood) - build - Raise minimum go version to go1.12 (Nick Craig-Wood) - dedupe - Add `--by-hash` to dedupe on content hash not file name (Nick Craig-Wood) - Add `--dedupe-mode list` to just list dupes, changing nothing (Nick Craig-Wood) - Add warning if used on a remote which can't have duplicate names (Nick Craig-Wood) - fs - Add Shutdown optional method for backends (Nick Craig-Wood) - When using `--files-from` check files concurrently (zhucan) - Accumulate stats when using `--dry-run` (Ingo Weiss) - Always show stats when using `--dry-run` or `--interactive` (Nick Craig-Wood) - Add support for flag `--no-console` on windows to hide the console window (albertony) - genautocomplete: Add support to output to stdout (Ingo) - ncdu - Highlight read errors instead of aborting (Claudio Bantaloukas) - Add sort by average size in directory (Adam Plánský) - Add toggle option for average s3ize in directory - key 'a' (Adam Plánský) - Add empty folder flag into ncdu browser (Adam Plánský) - Add `!` (error) and `.` (unreadable) file flags to go with `e` (empty) (Nick Craig-Wood) - obscure: Make `rclone obscure -` ignore newline at end of line (Nick Craig-Wood) - operations - Add logs when need to upload files to set mod times (Nick Craig-Wood) - Move and copy log name of the destination object in verbose (Adam Plánský) - Add size if known to skipped items and JSON log (Nick Craig-Wood) - rc - Prefer actual listener address if using ":port" or "addr:0" only (Nick Craig-Wood) - Add listener for finished jobs (Aleksandar Jankovic) - serve ftp: Add options to enable TLS (Deepak Sah) - serve http/webdav: Redirect requests to the base url without the / (Nick Craig-Wood) - serve restic: Implement object cache (Nick Craig-Wood) - stats: Add counter for deleted directories (Nick Craig-Wood) - sync: Only print "There was nothing to transfer" if no errors (Nick Craig-Wood) - webui - Prompt user for updating webui if an update is available (Chaitanya Bankanhal) - Fix plugins initialization (negative0) - Bug Fixes - fs - Fix nil pointer on copy & move operations directly to remote (Anagh Kumar Baranwal) - Fix parsing of .. when joining remotes (Nick Craig-Wood) - log: Fix enabling systemd logging when using `--log-file` (Nick Craig-Wood) - check - Make the error count match up in the log message (Nick Craig-Wood) - move: Fix data loss when source and destination are the same object (Nick Craig-Wood) - operations - Fix `--cutoff-mode` hard not cutting off immediately (Nick Craig-Wood) - Fix `--immutable` error message (Nick Craig-Wood) - sync - Fix `--cutoff-mode` soft & cautious so it doesn't end the transfer early (Nick Craig-Wood) - Fix `--immutable` errors retrying many times (Nick Craig-Wood) - Docs - Many fixes and a rewrite of the filtering docs (edwardxml) - Many spelling and grammar fixes (Josh Soref) - Doc fixes for commands delete, purge, rmdir, rmdirs and mount (albertony) - And thanks to these people for many doc fixes too numerous to list - Ameer Dawood, Antoine GIRARD, Bob Bagwill, Christopher Stewart - CokeMine, David, Dov Murik, Durval Menezes, Evan Harris, gtorelly - Ilyess Bachiri, Janne Johansson, Kerry Su, Marcin Zelent, - Martin Michlmayr, Milly, Sơn Trần-Nguyễn - Mount - Update systemd status with cache stats (Hekmon) - Disable bazil/fuse based mount on macOS (Nick Craig-Wood) - Make `rclone mount` actually run `rclone cmount` under macOS (Nick Craig-Wood) - Implement mknod to make NFS file creation work (Nick Craig-Wood) - Make sure we don't call umount more than once (Nick Craig-Wood) - More user friendly mounting as network drive on windows (albertony) - Detect if uid or gid are set in same option string: -o uid=123,gid=456 (albertony) - Don't attempt to unmount if fs has been destroyed already (Nick Craig-Wood) - VFS - Fix virtual entries causing deleted files to still appear (Nick Craig-Wood) - Fix "file already exists" error for stale cache files (Nick Craig-Wood) - Fix file leaks with `--vfs-cache-mode` full and `--buffer-size 0` (Nick Craig-Wood) - Fix invalid cache path on windows when using :backend: as remote (albertony) - Local - Continue listing files/folders when a circular symlink is detected (Manish Gupta) - New flag `--local-zero-size-links` to fix sync on some virtual filesystems (Riccardo Iaconelli) - Azure Blob - Add support for service principals (James Lim) - Add support for managed identities (Brad Ackerman) - Add examples for access tier (Bob Pusateri) - Utilize the streaming capabilities from the SDK for multipart uploads (Denis Neuling) - Fix setting of mime types (Nick Craig-Wood) - Fix crash when listing outside a SAS URL's root (Nick Craig-Wood) - Delete archive tier blobs before update if `--azureblob-archive-tier-delete` (Nick Craig-Wood) - Fix crash on startup (Nick Craig-Wood) - Fix memory usage by upgrading the SDK to v0.13.0 and implementing a TransferManager (Nick Craig-Wood) - Require go1.14+ to compile due to SDK changes (Nick Craig-Wood) - B2 - Make NewObject use less expensive API calls (Nick Craig-Wood) - This will improve `--files-from` and `restic serve` in particular - Fixed crash on an empty file name (lluuaapp) - Box - Fix NewObject for files that differ in case (Nick Craig-Wood) - Fix finding directories in a case insensitive way (Nick Craig-Wood) - Chunker - Skip long local hashing, hash in-transit (fixes) (Ivan Andreev) - Set Features ReadMimeType to false as Object.MimeType not supported (Nick Craig-Wood) - Fix case-insensitive NewObject, test metadata detection (Ivan Andreev) - Drive - Implement `rclone backend copyid` command for copying files by ID (Nick Craig-Wood) - Added flag `--drive-stop-on-download-limit` to stop transfers when the download limit is exceeded (Anagh Kumar Baranwal) - Implement CleanUp workaround for team drives (buengese) - Allow shortcut resolution and creation to be retried (Nick Craig-Wood) - Log that emptying the trash can take some time (Nick Craig-Wood) - Add xdg office icons to xdg desktop files (Pau Rodriguez-Estivill) - Dropbox - Add support for viewing shared files and folders (buengese) - Enable short lived access tokens (Nick Craig-Wood) - Implement IDer on Objects so `rclone lsf` etc can read the IDs (buengese) - Set Features ReadMimeType to false as Object.MimeType not supported (Nick Craig-Wood) - Make malformed_path errors from too long files not retriable (Nick Craig-Wood) - Test file name length before upload to fix upload loop (Nick Craig-Wood) - Fichier - Set Features ReadMimeType to true as Object.MimeType is supported (Nick Craig-Wood) - FTP - Add `--ftp-disable-msld` option to ignore MLSD for really old servers (Nick Craig-Wood) - Make `--tpslimit apply` (Nick Craig-Wood) - Google Cloud Storage - Storage class object header support (Laurens Janssen) - Fix anonymous client to use rclone's HTTP client (Nick Craig-Wood) - Fix `Entry doesn't belong in directory "" (same as directory) - ignoring` (Nick Craig-Wood) - Googlephotos - New flag `--gphotos-include-archived` to show archived photos as well (Nicolas Rueff) - Jottacloud - Don't erroneously report support for writing mime types (buengese) - Add support for Telia Cloud (Patrik Nordlén) - Mailru - Accept special folders eg camera-upload (Ivan Andreev) - Avoid prehashing of large local files (Ivan Andreev) - Fix uploads after recent changes on server (Ivan Andreev) - Fix range requests after June 2020 changes on server (Ivan Andreev) - Fix invalid timestamp on corrupted files (fixes) (Ivan Andreev) - Remove deprecated protocol quirks (Ivan Andreev) - Memory - Fix setting of mime types (Nick Craig-Wood) - Onedrive - Add support for China region operated by 21vianet and other regional suppliers (NyaMisty) - Warn on gateway timeout errors (Nick Craig-Wood) - Fall back to normal copy if server-side copy unavailable (Alex Chen) - Fix server-side copy completely disabled on OneDrive for Business (Cnly) - (business only) workaround to replace existing file on server-side copy (Alex Chen) - Enhance link creation with expiry, scope, type and password (Nick Craig-Wood) - Remove % and # from the set of encoded characters (Alex Chen) - Support addressing site by server-relative URL (kice) - Opendrive - Fix finding directories in a case insensitive way (Nick Craig-Wood) - Pcloud - Fix setting of mime types (Nick Craig-Wood) - Premiumizeme - Fix finding directories in a case insensitive way (Nick Craig-Wood) - Qingstor - Fix error propagation in CleanUp (Nick Craig-Wood) - Fix rclone cleanup (Nick Craig-Wood) - S3 - Added `--s3-disable-http2` to disable http/2 (Anagh Kumar Baranwal) - Complete SSE-C implementation (Nick Craig-Wood) - Fix hashes on small files with AWS:KMS and SSE-C (Nick Craig-Wood) - Add MD5 metadata to objects uploaded with SSE-AWS/SSE-C (Nick Craig-Wood) - Add `--s3-no-head parameter` to minimise transactions on upload (Nick Craig-Wood) - Update docs with a Reducing Costs section (Nick Craig-Wood) - Added error handling for error code 429 indicating too many requests (Anagh Kumar Baranwal) - Add requester pays option (kelv) - Fix copy multipart with v2 auth failing with 'SignatureDoesNotMatch' (Louis Koo) - SFTP - Allow cert based auth via optional pubkey (Stephen Harris) - Allow user to optionally check server hosts key to add security (Stephen Harris) - Defer asking for user passwords until the SSH connection succeeds (Stephen Harris) - Remember entered password in AskPass mode (Stephen Harris) - Implement Shutdown method (Nick Craig-Wood) - Implement keyboard interactive authentication (Nick Craig-Wood) - Make `--tpslimit` apply (Nick Craig-Wood) - Implement `--sftp-use-fstat` for unusual SFTP servers (Nick Craig-Wood) - Sugarsync - Fix NewObject for files that differ in case (Nick Craig-Wood) - Fix finding directories in a case insensitive way (Nick Craig-Wood) - Swift - Fix deletion of parts of Static Large Object (SLO) (Nguyễn Hữu Luân) - Ensure partially uploaded large files are uploaded unless `--swift-leave-parts-on-error` (Nguyễn Hữu Luân) - Tardigrade - Upgrade to uplink v1.4.1 (Caleb Case) - WebDAV - Updated docs to show streaming to nextcloud is working (Durval Menezes) - Yandex - Set Features WriteMimeType to false as Yandex ignores mime types (Nick Craig-Wood) ## v1.53.4 - 2021-01-20 [See commits](https://github.com/rclone/rclone/compare/v1.53.3...v1.53.4) - Bug Fixes - accounting: Fix data race in Transferred() (Maciej Zimnoch) - build - Stop tagged releases making a current beta (Nick Craig-Wood) - Upgrade docker buildx action (Matteo Pietro Dazzi) - Add -buildmode to cross-compile.go (Nick Craig-Wood) - Fix docker build by upgrading ilteoood/docker_buildx (Nick Craig-Wood) - Revert GitHub actions brew fix since this is now fixed (Nick Craig-Wood) - Fix brew install --cask syntax for macOS build (Nick Craig-Wood) - Update nfpm syntax to fix build of .deb/.rpm packages (Nick Craig-Wood) - Fix for Windows build errors (Ivan Andreev) - fs: Parseduration: fixed tests to use UTC time (Ankur Gupta) - fshttp: Prevent overlap of HTTP headers in logs (Nathan Collins) - rc - Fix core/command giving 500 internal error (Nick Craig-Wood) - Add Copy method to rc.Params (Nick Craig-Wood) - Fix 500 error when marshalling errors from core/command (Nick Craig-Wood) - plugins: Create plugins files only if webui is enabled. (negative0) - serve http: Fix serving files of unknown length (Nick Craig-Wood) - serve sftp: Fix authentication on one connection blocking others (Nick Craig-Wood) - Mount - Add optional `brew` tag to throw an error when using mount in the binaries installed via Homebrew (Anagh Kumar Baranwal) - Add "." and ".." to directories to match cmount and expectations (Nick Craig-Wood) - VFS - Make cache dir absolute before using it to fix path too long errors (Nick Craig-Wood) - Chunker - Improve detection of incompatible metadata (Ivan Andreev) - Google Cloud Storage - Fix server side copy of large objects (Nick Craig-Wood) - Jottacloud - Fix token renewer to fix long uploads (Nick Craig-Wood) - Fix token refresh failed: is not a regular file error (Nick Craig-Wood) - Pcloud - Only use SHA1 hashes in EU region (Nick Craig-Wood) - Sharefile - Undo Fix backend due to API swapping integers for strings (Nick Craig-Wood) - WebDAV - Fix Open Range requests to fix 4shared mount (Nick Craig-Wood) - Add "Depth: 0" to GET requests to fix bitrix (Nick Craig-Wood) ## v1.53.3 - 2020-11-19 [See commits](https://github.com/rclone/rclone/compare/v1.53.2...v1.53.3) - Bug Fixes - random: Fix incorrect use of math/rand instead of crypto/rand CVE-2020-28924 (Nick Craig-Wood) - Passwords you have generated with `rclone config` may be insecure - See [issue #4783](https://github.com/rclone/rclone/issues/4783) for more details and a checking tool - random: Seed math/rand in one place with crypto strong seed (Nick Craig-Wood) - VFS - Fix vfs/refresh calls with fs= parameter (Nick Craig-Wood) - Sharefile - Fix backend due to API swapping integers for strings (Nick Craig-Wood) ## v1.53.2 - 2020-10-26 [See commits](https://github.com/rclone/rclone/compare/v1.53.1...v1.53.2) - Bug Fixes - accounting - Fix incorrect speed and transferTime in core/stats (Nick Craig-Wood) - Stabilize display order of transfers on Windows (Nick Craig-Wood) - operations - Fix use of --suffix without --backup-dir (Nick Craig-Wood) - Fix spurious "--checksum is in use but the source and destination have no hashes in common" (Nick Craig-Wood) - build - Work around GitHub actions brew problem (Nick Craig-Wood) - Stop using set-env and set-path in the GitHub actions (Nick Craig-Wood) - Mount - mount2: Fix the swapped UID / GID values (Russell Cattelan) - VFS - Detect and recover from a file being removed externally from the cache (Nick Craig-Wood) - Fix a deadlock vulnerability in downloaders.Close (Leo Luan) - Fix a race condition in retryFailedResets (Leo Luan) - Fix missed concurrency control between some item operations and reset (Leo Luan) - Add exponential backoff during ENOSPC retries (Leo Luan) - Add a missed update of used cache space (Leo Luan) - Fix --no-modtime to not attempt to set modtimes (as documented) (Nick Craig-Wood) - Local - Fix sizes and syncing with --links option on Windows (Nick Craig-Wood) - Chunker - Disable ListR to fix missing files on GDrive (workaround) (Ivan Andreev) - Fix upload over crypt (Ivan Andreev) - Fichier - Increase maximum file size from 100GB to 300GB (gyutw) - Jottacloud - Remove clientSecret from config when upgrading to token based authentication (buengese) - Avoid double url escaping of device/mountpoint (albertony) - Remove DirMove workaround as it's not required anymore - also (buengese) - Mailru - Fix uploads after recent changes on server (Ivan Andreev) - Fix range requests after june changes on server (Ivan Andreev) - Fix invalid timestamp on corrupted files (fixes) (Ivan Andreev) - Onedrive - Fix disk usage for sharepoint (Nick Craig-Wood) - S3 - Add missing regions for AWS (Anagh Kumar Baranwal) - Seafile - Fix accessing libraries > 2GB on 32 bit systems (Muffin King) - SFTP - Always convert the checksum to lower case (buengese) - Union - Create root directories if none exist (Nick Craig-Wood) ## v1.53.1 - 2020-09-13 [See commits](https://github.com/rclone/rclone/compare/v1.53.0...v1.53.1) - Bug Fixes - accounting: Remove new line from end of --stats-one-line display (Nick Craig-Wood) - check - Add back missing --download flag (Nick Craig-Wood) - Fix docs (Nick Craig-Wood) - docs - Note --log-file does append (Nick Craig-Wood) - Add full stops for consistency in rclone --help (edwardxml) - Add Tencent COS to s3 provider list (wjielai) - Updated mount command to reflect that it requires Go 1.13 or newer (Evan Harris) - jottacloud: Mention that uploads from local disk will not need to cache files to disk for md5 calculation (albertony) - Fix formatting of rc docs page (Nick Craig-Wood) - build - Include vendor tar ball in release and fix startdev (Nick Craig-Wood) - Fix "Illegal instruction" error for ARMv6 builds (Nick Craig-Wood) - Fix architecture name in ARMv7 build (Nick Craig-Wood) - VFS - Fix spurious error "vfs cache: failed to _ensure cache EOF" (Nick Craig-Wood) - Log an ERROR if we fail to set the file to be sparse (Nick Craig-Wood) - Local - Log an ERROR if we fail to set the file to be sparse (Nick Craig-Wood) - Drive - Re-adds special oauth help text (Tim Gallant) - Opendrive - Do not retry 400 errors (Evan Harris) ## v1.53.0 - 2020-09-02 [See commits](https://github.com/rclone/rclone/compare/v1.52.0...v1.53.0) - New Features - The [VFS layer](https://rclone.org/commands/rclone_mount/#vfs-virtual-file-system) was heavily reworked for this release - see below for more details - Interactive mode [-i/--interactive](https://rclone.org/docs/#interactive) for destructive operations (fishbullet) - Add [--bwlimit-file](https://rclone.org/docs/#bwlimit-file-bwtimetable) flag to limit speeds of individual file transfers (Nick Craig-Wood) - Transfers are sorted by start time in the stats and progress output (Max Sum) - Make sure backends expand `~` and environment vars in file names they use (Nick Craig-Wood) - Add [--refresh-times](https://rclone.org/docs/#refresh-times) flag to set modtimes on hashless backends (Nick Craig-Wood) - build - Remove vendor directory in favour of Go modules (Nick Craig-Wood) - Build with go1.15.x by default (Nick Craig-Wood) - Drop macOS 386 build as it is no longer supported by go1.15 (Nick Craig-Wood) - Add ARMv7 to the supported builds (Nick Craig-Wood) - Enable `rclone cmount` on macOS (Nick Craig-Wood) - Make rclone build with gccgo (Nick Craig-Wood) - Make rclone build with wasm (Nick Craig-Wood) - Change beta numbering to be semver compatible (Nick Craig-Wood) - Add file properties and icon to Windows executable (albertony) - Add experimental interface for integrating rclone into browsers (Nick Craig-Wood) - lib: Add file name compression (Klaus Post) - rc - Allow installation and use of plugins and test plugins with rclone-webui (Chaitanya Bankanhal) - Add reverse proxy pluginsHandler for serving plugins (Chaitanya Bankanhal) - Add `mount/listmounts` option for listing current mounts (Chaitanya Bankanhal) - Add `operations/uploadfile` to upload a file through rc using encoding multipart/form-data (Chaitanya Bankanhal) - Add `core/command` to execute rclone terminal commands. (Chaitanya Bankanhal) - `rclone check` - Add reporting of filenames for same/missing/changed (Nick Craig-Wood) - Make check command obey `--dry-run`/`-i`/`--interactive` (Nick Craig-Wood) - Make check do `--checkers` files concurrently (Nick Craig-Wood) - Retry downloads if they fail when using the `--download` flag (Nick Craig-Wood) - Make it show stats by default (Nick Craig-Wood) - `rclone obscure`: Allow obscure command to accept password on STDIN (David Ibarra) - `rclone config` - Set RCLONE_CONFIG_DIR for use in config files and subprocesses (Nick Craig-Wood) - Reject remote names starting with a dash. (jtagcat) - `rclone cryptcheck`: Add reporting of filenames for same/missing/changed (Nick Craig-Wood) - `rclone dedupe`: Make it obey the `--size-only` flag for duplicate detection (Nick Craig-Wood) - `rclone link`: Add `--expire` and `--unlink` flags (Roman Kredentser) - `rclone mkdir`: Warn when using mkdir on remotes which can't have empty directories (Nick Craig-Wood) - `rclone rc`: Allow JSON parameters to simplify command line usage (Nick Craig-Wood) - `rclone serve ftp` - Don't compile on < go1.13 after dependency update (Nick Craig-Wood) - Add error message if auth proxy fails (Nick Craig-Wood) - Use refactored goftp.io/server library for binary shrink (Nick Craig-Wood) - `rclone serve restic`: Expose interfaces so that rclone can be used as a library from within restic (Jack) - `rclone sync`: Add `--track-renames-strategy leaf` (Nick Craig-Wood) - `rclone touch`: Add ability to set nanosecond resolution times (Nick Craig-Wood) - `rclone tree`: Remove `-i` shorthand for `--noindent` as it conflicts with `-i`/`--interactive` (Nick Craig-Wood) - Bug Fixes - accounting - Fix documentation for `speed`/`speedAvg` (Nick Craig-Wood) - Fix elapsed time not show actual time since beginning (Chaitanya Bankanhal) - Fix deadlock in stats printing (Nick Craig-Wood) - build - Fix file handle leak in GitHub release tool (Garrett Squire) - `rclone check`: Fix successful retries with `--download` counting errors (Nick Craig-Wood) - `rclone dedupe`: Fix logging to be easier to understand (Nick Craig-Wood) - Mount - Warn macOS users that mount implementation is changing (Nick Craig-Wood) - to test the new implementation use `rclone cmount` instead of `rclone mount` - this is because the library rclone uses has dropped macOS support - rc interface - Add call for unmount all (Chaitanya Bankanhal) - Make `mount/mount` remote control take vfsOpt option (Nick Craig-Wood) - Add mountOpt to `mount/mount` (Nick Craig-Wood) - Add VFS and Mount options to `mount/listmounts` (Nick Craig-Wood) - Catch panics in cgofuse initialization and turn into error messages (Nick Craig-Wood) - Always supply stat information in Readdir (Nick Craig-Wood) - Add support for reading unknown length files using direct IO (Windows) (Nick Craig-Wood) - Fix On Windows don't add `-o uid/gid=-1` if user supplies `-o uid/gid`. (Nick Craig-Wood) - Fix macOS losing directory contents in cmount (Nick Craig-Wood) - Fix volume name broken in recent refactor (Nick Craig-Wood) - VFS - Implement partial reads for `--vfs-cache-mode full` (Nick Craig-Wood) - Add `--vfs-writeback` option to delay writes back to cloud storage (Nick Craig-Wood) - Add `--vfs-read-ahead` parameter for use with `--vfs-cache-mode full` (Nick Craig-Wood) - Restart pending uploads on restart of the cache (Nick Craig-Wood) - Support synchronous cache space recovery upon ENOSPC (Leo Luan) - Allow ReadAt and WriteAt to run concurrently with themselves (Nick Craig-Wood) - Change modtime of file before upload to current (Rob Calistri) - Recommend `--vfs-cache-modes writes` on backends which can't stream (Nick Craig-Wood) - Add an optional `fs` parameter to vfs rc methods (Nick Craig-Wood) - Fix errors when using > 260 char files in the cache in Windows (Nick Craig-Wood) - Fix renaming of items while they are being uploaded (Nick Craig-Wood) - Fix very high load caused by slow directory listings (Nick Craig-Wood) - Fix renamed files not being uploaded with `--vfs-cache-mode minimal` (Nick Craig-Wood) - Fix directory locking caused by slow directory listings (Nick Craig-Wood) - Fix saving from chrome without `--vfs-cache-mode writes` (Nick Craig-Wood) - Local - Add `--local-no-updated` to provide a consistent view of changing objects (Nick Craig-Wood) - Add `--local-no-set-modtime` option to prevent modtime changes (tyhuber1) - Fix race conditions updating and reading Object metadata (Nick Craig-Wood) - Cache - Make any created backends be cached to fix rc problems (Nick Craig-Wood) - Fix dedupe on caches wrapping drives (Nick Craig-Wood) - Crypt - Add `--crypt-server-side-across-configs` flag (Nick Craig-Wood) - Make any created backends be cached to fix rc problems (Nick Craig-Wood) - Alias - Make any created backends be cached to fix rc problems (Nick Craig-Wood) - Azure Blob - Don't compile on < go1.13 after dependency update (Nick Craig-Wood) - B2 - Implement server-side copy for files > 5GB (Nick Craig-Wood) - Cancel in progress multipart uploads and copies on rclone exit (Nick Craig-Wood) - Note that b2's encoding now allows \ but rclone's hasn't changed (Nick Craig-Wood) - Fix transfers when using download_url (Nick Craig-Wood) - Box - Implement rclone cleanup (buengese) - Cancel in progress multipart uploads and copies on rclone exit (Nick Craig-Wood) - Allow authentication with access token (David) - Chunker - Make any created backends be cached to fix rc problems (Nick Craig-Wood) - Drive - Add `rclone backend drives` to list shared drives (teamdrives) (Nick Craig-Wood) - Implement `rclone backend untrash` (Nick Craig-Wood) - Work around drive bug which didn't set modtime of copied docs (Nick Craig-Wood) - Added `--drive-starred-only` to only show starred files (Jay McEntire) - Deprecate `--drive-alternate-export` as it is no longer needed (themylogin) - Fix duplication of Google docs on server-side copy (Nick Craig-Wood) - Fix "panic: send on closed channel" when recycling dir entries (Nick Craig-Wood) - Dropbox - Add copyright detector info in limitations section in the docs (Alex Guerrero) - Fix `rclone link` by removing expires parameter (Nick Craig-Wood) - Fichier - Detect Flood detected: IP Locked error and sleep for 30s (Nick Craig-Wood) - FTP - Add explicit TLS support (Heiko Bornholdt) - Add support for `--dump bodies` and `--dump auth` for debugging (Nick Craig-Wood) - Fix interoperation with pure-ftpd (Nick Craig-Wood) - Google Cloud Storage - Add support for anonymous access (Kai Lüke) - Jottacloud - Bring back legacy authentication for use with whitelabel versions (buengese) - Switch to new api root - also implement a very ugly workaround for the DirMove failures (buengese) - Onedrive - Rework cancel of multipart uploads on rclone exit (Nick Craig-Wood) - Implement rclone cleanup (Nick Craig-Wood) - Add `--onedrive-no-versions` flag to remove old versions (Nick Craig-Wood) - Pcloud - Implement `rclone link` for public link creation (buengese) - Qingstor - Cancel in progress multipart uploads on rclone exit (Nick Craig-Wood) - S3 - Preserve metadata when doing multipart copy (Nick Craig-Wood) - Cancel in progress multipart uploads and copies on rclone exit (Nick Craig-Wood) - Add `rclone link` for public link sharing (Roman Kredentser) - Add `rclone backend restore` command to restore objects from GLACIER (Nick Craig-Wood) - Add `rclone cleanup` and `rclone backend cleanup` to clean unfinished multipart uploads (Nick Craig-Wood) - Add `rclone backend list-multipart-uploads` to list unfinished multipart uploads (Nick Craig-Wood) - Add `--s3-max-upload-parts` support (Kamil Trzciński) - Add `--s3-no-check-bucket` for minimising rclone transactions and perms (Nick Craig-Wood) - Add `--s3-profile` and `--s3-shared-credentials-file` options (Nick Craig-Wood) - Use regional s3 us-east-1 endpoint (David) - Add Scaleway provider (Vincent Feltz) - Update IBM COS endpoints (Egor Margineanu) - Reduce the default `--s3-copy-cutoff` to < 5GB for Backblaze S3 compatibility (Nick Craig-Wood) - Fix detection of bucket existing (Nick Craig-Wood) - SFTP - Use the absolute path instead of the relative path for listing for improved compatibility (Nick Craig-Wood) - Add `--sftp-subsystem` and `--sftp-server-command` options (aus) - Swift - Fix dangling large objects breaking the listing (Nick Craig-Wood) - Fix purge not deleting directory markers (Nick Craig-Wood) - Fix update multipart object removing all of its own parts (Nick Craig-Wood) - Fix missing hash from object returned from upload (Nick Craig-Wood) - Tardigrade - Upgrade to uplink v1.2.0 (Kaloyan Raev) - Union - Fix writing with the all policy (Nick Craig-Wood) - WebDAV - Fix directory creation with 4shared (Nick Craig-Wood) ## v1.52.3 - 2020-08-07 [See commits](https://github.com/rclone/rclone/compare/v1.52.2...v1.52.3) - Bug Fixes - docs - Disable smart typography (e.g. en-dash) in MANUAL.* and man page (Nick Craig-Wood) - Update install.md to reflect minimum Go version (Evan Harris) - Update install from source instructions (Nick Craig-Wood) - make_manual: Support SOURCE_DATE_EPOCH (Morten Linderud) - log: Fix --use-json-log going to stderr not --log-file on Windows (Nick Craig-Wood) - serve dlna: Fix file list on Samsung Series 6+ TVs (Matteo Pietro Dazzi) - sync: Fix deadlock with --track-renames-strategy modtime (Nick Craig-Wood) - Cache - Fix moveto/copyto remote:file remote:file2 (Nick Craig-Wood) - Drive - Stop using root_folder_id as a cache (Nick Craig-Wood) - Make dangling shortcuts appear in listings (Nick Craig-Wood) - Drop "Disabling ListR" messages down to debug (Nick Craig-Wood) - Workaround and policy for Google Drive API (Dmitry Ustalov) - FTP - Add note to docs about home vs root directory selection (Nick Craig-Wood) - Onedrive - Fix reverting to Copy when Move would have worked (Nick Craig-Wood) - Avoid comma rendered in URL in onedrive.md (Kevin) - Pcloud - Fix oauth on European region "eapi.pcloud.com" (Nick Craig-Wood) - S3 - Fix bucket Region auto detection when Region unset in config (Nick Craig-Wood) ## v1.52.2 - 2020-06-24 [See commits](https://github.com/rclone/rclone/compare/v1.52.1...v1.52.2) - Bug Fixes - build - Fix docker release build action (Nick Craig-Wood) - Fix custom timezone in Docker image (NoLooseEnds) - check: Fix misleading message which printed errors instead of differences (Nick Craig-Wood) - errors: Add WSAECONNREFUSED and more to the list of retriable Windows errors (Nick Craig-Wood) - rcd: Fix incorrect prometheus metrics (Gary Kim) - serve restic: Fix flags so they use environment variables (Nick Craig-Wood) - serve webdav: Fix flags so they use environment variables (Nick Craig-Wood) - sync: Fix --track-renames-strategy modtime (Nick Craig-Wood) - Drive - Fix not being able to delete a directory with a trashed shortcut (Nick Craig-Wood) - Fix creating a directory inside a shortcut (Nick Craig-Wood) - Fix --drive-impersonate with cached root_folder_id (Nick Craig-Wood) - SFTP - Fix SSH key PEM loading (Zac Rubin) - Swift - Speed up deletes by not retrying segment container deletes (Nick Craig-Wood) - Tardigrade - Upgrade to uplink v1.1.1 (Caleb Case) - WebDAV - Fix free/used display for rclone about/df for certain backends (Nick Craig-Wood) ## v1.52.1 - 2020-06-10 [See commits](https://github.com/rclone/rclone/compare/v1.52.0...v1.52.1) - Bug Fixes - lib/file: Fix SetSparse on Windows 7 which fixes downloads of files > 250MB (Nick Craig-Wood) - build - Update go.mod to go1.14 to enable -mod=vendor build (Nick Craig-Wood) - Remove quicktest from Dockerfile (Nick Craig-Wood) - Build Docker images with GitHub actions (Matteo Pietro Dazzi) - Update Docker build workflows (Nick Craig-Wood) - Set user_allow_other in /etc/fuse.conf in the Docker image (Nick Craig-Wood) - Fix xgo build after go1.14 go.mod update (Nick Craig-Wood) - docs - Add link to source and modified time to footer of every page (Nick Craig-Wood) - Remove manually set dates and use git dates instead (Nick Craig-Wood) - Minor tense, punctuation, brevity and positivity changes for the home page (edwardxml) - Remove leading slash in page reference in footer when present (Nick Craig-Wood) - Note commands which need obscured input in the docs (Nick Craig-Wood) - obscure: Write more help as we are referencing it elsewhere (Nick Craig-Wood) - VFS - Fix OS vs Unix path confusion - fixes ChangeNotify on Windows (Nick Craig-Wood) - Drive - Fix missing items when listing using --fast-list / ListR (Nick Craig-Wood) - Putio - Fix panic on Object.Open (Cenk Alti) - S3 - Fix upload of single files into buckets without create permission (Nick Craig-Wood) - Fix --header-upload (Nick Craig-Wood) - Tardigrade - Fix listing bug by upgrading to v1.0.7 - Set UserAgent to rclone (Caleb Case) ## v1.52.0 - 2020-05-27 Special thanks to Martin Michlmayr for proof reading and correcting all the docs and Edward Barker for helping re-write the front page. [See commits](https://github.com/rclone/rclone/compare/v1.51.0...v1.52.0) - New backends - [Tardigrade](https://rclone.org/tardigrade/) backend for use with storj.io (Caleb Case) - [Union](https://rclone.org/union/) re-write to have multiple writable remotes (Max Sum) - [Seafile](/seafile) for Seafile server (Fred @creativeprojects) - New commands - backend: command for backend-specific commands (see backends) (Nick Craig-Wood) - cachestats: Deprecate in favour of `rclone backend stats cache:` (Nick Craig-Wood) - dbhashsum: Deprecate in favour of `rclone hashsum DropboxHash` (Nick Craig-Wood) - New Features - Add `--header-download` and `--header-upload` flags for setting HTTP headers when uploading/downloading (Tim Gallant) - Add `--header` flag to add HTTP headers to every HTTP transaction (Nick Craig-Wood) - Add `--check-first` to do all checking before starting transfers (Nick Craig-Wood) - Add `--track-renames-strategy` for configurable matching criteria for `--track-renames` (Bernd Schoolmann) - Add `--cutoff-mode` hard,soft,cautious (Shing Kit Chan & Franklyn Tackitt) - Filter flags (e.g. `--files-from -`) can read from stdin (fishbullet) - Add `--error-on-no-transfer` option (Jon Fautley) - Implement `--order-by xxx,mixed` for copying some small and some big files (Nick Craig-Wood) - Allow `--max-backlog` to be negative meaning as large as possible (Nick Craig-Wood) - Added `--no-unicode-normalization` flag to allow Unicode filenames to remain unique (Ben Zenker) - Allow `--min-age`/`--max-age` to take a date as well as a duration (Nick Craig-Wood) - Add rename statistics for file and directory renames (Nick Craig-Wood) - Add statistics output to JSON log (reddi) - Make stats be printed on non-zero exit code (Nick Craig-Wood) - When running `--password-command` allow use of stdin (Sébastien Gross) - Stop empty strings being a valid remote path (Nick Craig-Wood) - accounting: support WriterTo for less memory copying (Nick Craig-Wood) - build - Update to use go1.14 for the build (Nick Craig-Wood) - Add `-trimpath` to release build for reproduceable builds (Nick Craig-Wood) - Remove GOOS and GOARCH from Dockerfile (Brandon Philips) - config - Fsync the config file after writing to save more reliably (Nick Craig-Wood) - Add `--obscure` and `--no-obscure` flags to `config create`/`update` (Nick Craig-Wood) - Make `config show` take `remote:` as well as `remote` (Nick Craig-Wood) - copyurl: Add `--no-clobber` flag (Denis) - delete: Added `--rmdirs` flag to delete directories as well (Kush) - filter: Added `--files-from-raw` flag (Ankur Gupta) - genautocomplete: Add support for fish shell (Matan Rosenberg) - log: Add support for syslog LOCAL facilities (Patryk Jakuszew) - lsjson: Add `--hash-type` parameter and use it in lsf to speed up hashing (Nick Craig-Wood) - rc - Add `-o`/`--opt` and `-a`/`--arg` for more structured input (Nick Craig-Wood) - Implement `backend/command` for running backend-specific commands remotely (Nick Craig-Wood) - Add `mount/mount` command for starting `rclone mount` via the API (Chaitanya) - rcd: Add Prometheus metrics support (Gary Kim) - serve http - Added a `--template` flag for user defined markup (calistri) - Add Last-Modified headers to files and directories (Nick Craig-Wood) - serve sftp: Add support for multiple host keys by repeating `--key` flag (Maxime Suret) - touch: Add `--localtime` flag to make `--timestamp` localtime not UTC (Nick Craig-Wood) - Bug Fixes - accounting - Restore "Max number of stats groups reached" log line (Michał Matczuk) - Correct exitcode on Transfer Limit Exceeded flag. (Anuar Serdaliyev) - Reset bytes read during copy retry (Ankur Gupta) - Fix race clearing stats (Nick Craig-Wood) - copy: Only create empty directories when they don't exist on the remote (Ishuah Kariuki) - dedupe: Stop dedupe deleting files with identical IDs (Nick Craig-Wood) - oauth - Use custom http client so that `--no-check-certificate` is honored by oauth token fetch (Mark Spieth) - Replace deprecated oauth2.NoContext (Lars Lehtonen) - operations - Fix setting the timestamp on Windows for multithread copy (Nick Craig-Wood) - Make rcat obey `--ignore-checksum` (Nick Craig-Wood) - Make `--max-transfer` more accurate (Nick Craig-Wood) - rc - Fix dropped error (Lars Lehtonen) - Fix misplaced http server config (Xiaoxing Ye) - Disable duplicate log (ElonH) - serve dlna - Cds: don't specify childCount at all when unknown (Dan Walters) - Cds: use modification time as date in dlna metadata (Dan Walters) - serve restic: Fix tests after restic project removed vendoring (Nick Craig-Wood) - sync - Fix incorrect "nothing to transfer" message using `--delete-before` (Nick Craig-Wood) - Only create empty directories when they don't exist on the remote (Ishuah Kariuki) - Mount - Add `--async-read` flag to disable asynchronous reads (Nick Craig-Wood) - Ignore `--allow-root` flag with a warning as it has been removed upstream (Nick Craig-Wood) - Warn if `--allow-non-empty` used on Windows and clarify docs (Nick Craig-Wood) - Constrain to go1.13 or above otherwise bazil.org/fuse fails to compile (Nick Craig-Wood) - Fix fail because of too long volume name (evileye) - Report 1PB free for unknown disk sizes (Nick Craig-Wood) - Map more rclone errors into file systems errors (Nick Craig-Wood) - Fix disappearing cwd problem (Nick Craig-Wood) - Use ReaddirPlus on Windows to improve directory listing performance (Nick Craig-Wood) - Send a hint as to whether the filesystem is case insensitive or not (Nick Craig-Wood) - Add rc command `mount/types` (Nick Craig-Wood) - Change maximum leaf name length to 1024 bytes (Nick Craig-Wood) - VFS - Add `--vfs-read-wait` and `--vfs-write-wait` flags to control time waiting for a sequential read/write (Nick Craig-Wood) - Change default `--vfs-read-wait` to 20ms (it was 5ms and not configurable) (Nick Craig-Wood) - Make `df` output more consistent on a rclone mount. (Yves G) - Report 1PB free for unknown disk sizes (Nick Craig-Wood) - Fix race condition caused by unlocked reading of Dir.path (Nick Craig-Wood) - Make File lock and Dir lock not overlap to avoid deadlock (Nick Craig-Wood) - Implement lock ordering between File and Dir to eliminate deadlocks (Nick Craig-Wood) - Factor the vfs cache into its own package (Nick Craig-Wood) - Pin the Fs in use in the Fs cache (Nick Craig-Wood) - Add SetSys() methods to Node to allow caching stuff on a node (Nick Craig-Wood) - Ignore file not found errors from Hash in Read.Release (Nick Craig-Wood) - Fix hang in read wait code (Nick Craig-Wood) - Local - Speed up multi thread downloads by using sparse files on Windows (Nick Craig-Wood) - Implement `--local-no-sparse` flag for disabling sparse files (Nick Craig-Wood) - Implement `rclone backend noop` for testing purposes (Nick Craig-Wood) - Fix "file not found" errors on post transfer Hash calculation (Nick Craig-Wood) - Cache - Implement `rclone backend stats` command (Nick Craig-Wood) - Fix Server Side Copy with Temp Upload (Brandon McNama) - Remove Unused Functions (Lars Lehtonen) - Disable race tests until bbolt is fixed (Nick Craig-Wood) - Move methods used for testing into test file (greatroar) - Add Pin and Unpin and canonicalised lookup (Nick Craig-Wood) - Use proper import path go.etcd.io/bbolt (Robert-André Mauchin) - Crypt - Calculate hashes for uploads from local disk (Nick Craig-Wood) - This allows encrypted Jottacloud uploads without using local disk - This means encrypted s3/b2 uploads will now have hashes - Added `rclone backend decode`/`encode` commands to replicate functionality of `cryptdecode` (Anagh Kumar Baranwal) - Get rid of the unused Cipher interface as it obfuscated the code (Nick Craig-Wood) - Azure Blob - Implement streaming of unknown sized files so `rcat` is now supported (Nick Craig-Wood) - Implement memory pooling to control memory use (Nick Craig-Wood) - Add `--azureblob-disable-checksum` flag (Nick Craig-Wood) - Retry `InvalidBlobOrBlock` error as it may indicate block concurrency problems (Nick Craig-Wood) - Remove unused `Object.parseTimeString()` (Lars Lehtonen) - Fix permission error on SAS URL limited to container (Nick Craig-Wood) - B2 - Add support for `--header-upload` and `--header-download` (Tim Gallant) - Ignore directory markers at the root also (Nick Craig-Wood) - Force the case of the SHA1 to lowercase (Nick Craig-Wood) - Remove unused `largeUpload.clearUploadURL()` (Lars Lehtonen) - Box - Add support for `--header-upload` and `--header-download` (Tim Gallant) - Implement About to read size used (Nick Craig-Wood) - Add token renew function for jwt auth (David Bramwell) - Added support for interchangeable root folder for Box backend (Sunil Patra) - Remove unnecessary iat from jws claims (David) - Drive - Follow shortcuts by default, skip with `--drive-skip-shortcuts` (Nick Craig-Wood) - Implement `rclone backend shortcut` command for creating shortcuts (Nick Craig-Wood) - Added `rclone backend` command to change `service_account_file` and `chunk_size` (Anagh Kumar Baranwal) - Fix missing files when using `--fast-list` and `--drive-shared-with-me` (Nick Craig-Wood) - Fix duplicate items when using `--drive-shared-with-me` (Nick Craig-Wood) - Extend `--drive-stop-on-upload-limit` to respond to `teamDriveFileLimitExceeded`. (harry) - Don't delete files with multiple parents to avoid data loss (Nick Craig-Wood) - Server side copy docs use default description if empty (Nick Craig-Wood) - Dropbox - Make error insufficient space to be fatal (harry) - Add info about required redirect url (Elan Ruusamäe) - Fichier - Add support for `--header-upload` and `--header-download` (Tim Gallant) - Implement custom pacer to deal with the new rate limiting (buengese) - FTP - Fix lockup when using concurrency limit on failed connections (Nick Craig-Wood) - Fix lockup on failed upload when using concurrency limit (Nick Craig-Wood) - Fix lockup on Close failures when using concurrency limit (Nick Craig-Wood) - Work around pureftp sending spurious 150 messages (Nick Craig-Wood) - Google Cloud Storage - Add support for `--header-upload` and `--header-download` (Nick Craig-Wood) - Add `ARCHIVE` storage class to help (Adam Stroud) - Ignore directory markers at the root (Nick Craig-Wood) - Googlephotos - Make the start year configurable (Daven) - Add support for `--header-upload` and `--header-download` (Tim Gallant) - Create feature/favorites directory (Brandon Philips) - Fix "concurrent map write" error (Nick Craig-Wood) - Don't put an image in error message (Nick Craig-Wood) - HTTP - Improved directory listing with new template from Caddy project (calisro) - Jottacloud - Implement `--jottacloud-trashed-only` (buengese) - Add support for `--header-upload` and `--header-download` (Tim Gallant) - Use `RawURLEncoding` when decoding base64 encoded login token (buengese) - Implement cleanup (buengese) - Update docs regarding cleanup, removed remains from old auth, and added warning about special mountpoints. (albertony) - Mailru - Describe 2FA requirements (valery1707) - Onedrive - Implement `--onedrive-server-side-across-configs` (Nick Craig-Wood) - Add support for `--header-upload` and `--header-download` (Tim Gallant) - Fix occasional 416 errors on multipart uploads (Nick Craig-Wood) - Added maximum chunk size limit warning in the docs (Harry) - Fix missing drive on config (Nick Craig-Wood) - Make error `quotaLimitReached` to be fatal (harry) - Opendrive - Add support for `--header-upload` and `--header-download` (Tim Gallant) - Pcloud - Added support for interchangeable root folder for pCloud backend (Sunil Patra) - Add support for `--header-upload` and `--header-download` (Tim Gallant) - Fix initial config "Auth state doesn't match" message (Nick Craig-Wood) - Premiumizeme - Add support for `--header-upload` and `--header-download` (Tim Gallant) - Prune unused functions (Lars Lehtonen) - Putio - Add support for `--header-upload` and `--header-download` (Nick Craig-Wood) - Make downloading files use the rclone http Client (Nick Craig-Wood) - Fix parsing of remotes with leading and trailing / (Nick Craig-Wood) - Qingstor - Make `rclone cleanup` remove pending multipart uploads older than 24h (Nick Craig-Wood) - Try harder to cancel failed multipart uploads (Nick Craig-Wood) - Prune `multiUploader.list()` (Lars Lehtonen) - Lint fix (Lars Lehtonen) - S3 - Add support for `--header-upload` and `--header-download` (Tim Gallant) - Use memory pool for buffer allocations (Maciej Zimnoch) - Add SSE-C support for AWS, Ceph, and MinIO (Jack Anderson) - Fail fast multipart upload (Michał Matczuk) - Report errors on bucket creation (mkdir) correctly (Nick Craig-Wood) - Specify that Minio supports URL encoding in listings (Nick Craig-Wood) - Added 500 as retryErrorCode (Michał Matczuk) - Use `--low-level-retries` as the number of SDK retries (Aleksandar Janković) - Fix multipart abort context (Aleksandar Jankovic) - Replace deprecated `session.New()` with `session.NewSession()` (Lars Lehtonen) - Use the provided size parameter when allocating a new memory pool (Joachim Brandon LeBlanc) - Use rclone's low level retries instead of AWS SDK to fix listing retries (Nick Craig-Wood) - Ignore directory markers at the root also (Nick Craig-Wood) - Use single memory pool (Michał Matczuk) - Do not resize buf on put to memBuf (Michał Matczuk) - Improve docs for `--s3-disable-checksum` (Nick Craig-Wood) - Don't leak memory or tokens in edge cases for multipart upload (Nick Craig-Wood) - Seafile - Implement 2FA (Fred) - SFTP - Added `--sftp-pem-key` to support inline key files (calisro) - Fix post transfer copies failing with 0 size when using `set_modtime=false` (Nick Craig-Wood) - Sharefile - Add support for `--header-upload` and `--header-download` (Tim Gallant) - Sugarsync - Add support for `--header-upload` and `--header-download` (Tim Gallant) - Swift - Add support for `--header-upload` and `--header-download` (Nick Craig-Wood) - Fix cosmetic issue in error message (Martin Michlmayr) - Union - Implement multiple writable remotes (Max Sum) - Fix server-side copy (Max Sum) - Implement ListR (Max Sum) - Enable ListR when upstreams contain local (Max Sum) - WebDAV - Add support for `--header-upload` and `--header-download` (Tim Gallant) - Fix `X-OC-Mtime` header for Transip compatibility (Nick Craig-Wood) - Report full and consistent usage with `about` (Yves G) - Yandex - Add support for `--header-upload` and `--header-download` (Tim Gallant) ## v1.51.0 - 2020-02-01 - New backends - [Memory](https://rclone.org/memory/) (Nick Craig-Wood) - [Sugarsync](https://rclone.org/sugarsync/) (Nick Craig-Wood) - New Features - Adjust all backends to have `--backend-encoding` parameter (Nick Craig-Wood) - this enables the encoding for special characters to be adjusted or disabled - Add `--max-duration` flag to control the maximum duration of a transfer session (boosh) - Add `--expect-continue-timeout` flag, default 1s (Nick Craig-Wood) - Add `--no-check-dest` flag for copying without testing the destination (Nick Craig-Wood) - Implement `--order-by` flag to order transfers (Nick Craig-Wood) - accounting - Don't show entries in both transferring and checking (Nick Craig-Wood) - Add option to delete stats (Aleksandar Jankovic) - build - Compress the test builds with gzip (Nick Craig-Wood) - Implement a framework for starting test servers during tests (Nick Craig-Wood) - cmd: Always print elapsed time to tenth place seconds in progress (Gary Kim) - config - Add `--password-command` to allow dynamic config password (Damon Permezel) - Give config questions default values (Nick Craig-Wood) - Check a remote exists when creating a new one (Nick Craig-Wood) - copyurl: Add `--stdout` flag to write to stdout (Nick Craig-Wood) - dedupe: Implement keep smallest too (Nick Craig-Wood) - hashsum: Add flag `--base64` flag (landall) - lsf: Speed up on s3/swift/etc by not reading mimetype by default (Nick Craig-Wood) - lsjson: Add `--no-mimetype` flag (Nick Craig-Wood) - rc: Add methods to turn on blocking and mutex profiling (Nick Craig-Wood) - rcd - Adding group parameter to stats (Chaitanya) - Move webgui apart; option to disable browser (Xiaoxing Ye) - serve sftp: Add support for public key with auth proxy (Paul Tinsley) - stats: Show deletes in stats and hide zero stats (anuar45) - Bug Fixes - accounting - Fix error counter counting multiple times (Ankur Gupta) - Fix error count shown as checks (Cnly) - Clear finished transfer in stats-reset (Maciej Zimnoch) - Added StatsInfo locking in statsGroups sum function (Michał Matczuk) - asyncreader: Fix EOF error (buengese) - check: Fix `--one-way` recursing more directories than it needs to (Nick Craig-Wood) - chunkedreader: Disable hash calculation for first segment (Nick Craig-Wood) - config - Do not open browser on headless on drive/gcs/google photos (Xiaoxing Ye) - SetValueAndSave ignore error if config section does not exist yet (buengese) - cmd: Fix completion with an encrypted config (Danil Semelenov) - dbhashsum: Stop it returning UNSUPPORTED on dropbox (Nick Craig-Wood) - dedupe: Add missing modes to help string (Nick Craig-Wood) - operations - Fix dedupe continuing on errors like insufficientFilePersimmon (SezalAgrawal) - Clear accounting before low level retry (Maciej Zimnoch) - Write debug message when hashes could not be checked (Ole Schütt) - Move interface assertion to tests to remove pflag dependency (Nick Craig-Wood) - Make NewOverrideObjectInfo public and factor uses (Nick Craig-Wood) - proxy: Replace use of bcrypt with sha256 (Nick Craig-Wood) - vendor - Update bazil.org/fuse to fix FreeBSD 12.1 (Nick Craig-Wood) - Update github.com/t3rm1n4l/go-mega to fix mega "illegal base64 data at input byte 22" (Nick Craig-Wood) - Update termbox-go to fix ncdu command on FreeBSD (Kuang-che Wu) - Update t3rm1n4l/go-mega - fixes mega: couldn't login: crypto/aes: invalid key size 0 (Nick Craig-Wood) - Mount - Enable async reads for a 20% speedup (Nick Craig-Wood) - Replace use of WriteAt with Write for cache mode >= writes and O_APPEND (Brett Dutro) - Make sure we call unmount when exiting (Nick Craig-Wood) - Don't build on go1.10 as bazil/fuse no longer supports it (Nick Craig-Wood) - When setting dates discard out of range dates (Nick Craig-Wood) - VFS - Add a newly created file straight into the directory (Nick Craig-Wood) - Only calculate one hash for reads for a speedup (Nick Craig-Wood) - Make ReadAt for non cached files work better with non-sequential reads (Nick Craig-Wood) - Fix edge cases when reading ModTime from file (Nick Craig-Wood) - Make sure existing files opened for write show correct size (Nick Craig-Wood) - Don't cache the path in RW file objects to fix renaming (Nick Craig-Wood) - Fix rename of open files when using the VFS cache (Nick Craig-Wood) - When renaming files in the cache, rename the cache item in memory too (Nick Craig-Wood) - Fix open file renaming on drive when using `--vfs-cache-mode writes` (Nick Craig-Wood) - Fix incorrect modtime for mv into mount with `--vfs-cache-modes writes` (Nick Craig-Wood) - On rename, rename in cache too if the file exists (Anagh Kumar Baranwal) - Local - Make source file being updated errors be NoLowLevelRetry errors (Nick Craig-Wood) - Fix update of hidden files on Windows (Nick Craig-Wood) - Cache - Follow move of upstream library github.com/coreos/bbolt github.com/etcd-io/bbolt (Nick Craig-Wood) - Fix `fatal error: concurrent map writes` (Nick Craig-Wood) - Crypt - Reorder the filename encryption options (Thomas Eales) - Correctly handle trailing dot (buengese) - Chunker - Reduce length of temporary suffix (Ivan Andreev) - Drive - Add `--drive-stop-on-upload-limit` flag to stop syncs when upload limit reached (Nick Craig-Wood) - Add `--drive-use-shared-date` to use date file was shared instead of modified date (Garry McNulty) - Make sure invalid auth for teamdrives always reports an error (Nick Craig-Wood) - Fix `--fast-list` when using appDataFolder (Nick Craig-Wood) - Use multipart resumable uploads for streaming and uploads in mount (Nick Craig-Wood) - Log an ERROR if an incomplete search is returned (Nick Craig-Wood) - Hide dangerous config from the configurator (Nick Craig-Wood) - Dropbox - Treat `insufficient_space` errors as non retriable errors (Nick Craig-Wood) - Jottacloud - Use new auth method used by official client (buengese) - Add URL to generate Login Token to config wizard (Nick Craig-Wood) - Add support whitelabel versions (buengese) - Koofr - Use rclone HTTP client. (jaKa) - Onedrive - Add Sites.Read.All permission (Benjamin Richter) - Add support "Retry-After" header (Motonori IWAMURO) - Opendrive - Implement `--opendrive-chunk-size` (Nick Craig-Wood) - S3 - Re-implement multipart upload to fix memory issues (Nick Craig-Wood) - Add `--s3-copy-cutoff` for size to switch to multipart copy (Nick Craig-Wood) - Add new region Asia Pacific (Hong Kong) (Outvi V) - Reduce memory usage streaming files by reducing max stream upload size (Nick Craig-Wood) - Add `--s3-list-chunk` option for bucket listing (Thomas Kriechbaumer) - Force path style bucket access to off for AWS deprecation (Nick Craig-Wood) - Use AWS web identity role provider if available (Tennix) - Add StackPath Object Storage Support (Dave Koston) - Fix ExpiryWindow value (Aleksandar Jankovic) - Fix DisableChecksum condition (Aleksandar Janković) - Fix URL decoding of NextMarker (Nick Craig-Wood) - SFTP - Add `--sftp-skip-links` to skip symlinks and non regular files (Nick Craig-Wood) - Retry Creation of Connection (Sebastian Brandt) - Fix "failed to parse private key file: ssh: not an encrypted key" error (Nick Craig-Wood) - Open files for update write only to fix AWS SFTP interop (Nick Craig-Wood) - Swift - Reserve segments of dynamic large object when delete objects in container what was enabled versioning. (Nguyễn Hữu Luân) - Fix parsing of X-Object-Manifest (Nick Craig-Wood) - Update OVH API endpoint (unbelauscht) - WebDAV - Make nextcloud only upload SHA1 checksums (Nick Craig-Wood) - Fix case of "Bearer" in Authorization: header to agree with RFC (Nick Craig-Wood) - Add Referer header to fix problems with WAFs (Nick Craig-Wood) ## v1.50.2 - 2019-11-19 - Bug Fixes - accounting: Fix memory leak on retries operations (Nick Craig-Wood) - Drive - Fix listing of the root directory with drive.files scope (Nick Craig-Wood) - Fix --drive-root-folder-id with team/shared drives (Nick Craig-Wood) ## v1.50.1 - 2019-11-02 - Bug Fixes - hash: Fix accidentally changed hash names for `DropboxHash` and `CRC-32` (Nick Craig-Wood) - fshttp: Fix error reporting on tpslimit token bucket errors (Nick Craig-Wood) - fshttp: Don't print token bucket errors on context cancelled (Nick Craig-Wood) - Local - Fix listings of . on Windows (Nick Craig-Wood) - Onedrive - Fix DirMove/Move after Onedrive change (Xiaoxing Ye) ## v1.50.0 - 2019-10-26 - New backends - [Citrix Sharefile](https://rclone.org/sharefile/) (Nick Craig-Wood) - [Chunker](https://rclone.org/chunker/) - an overlay backend to split files into smaller parts (Ivan Andreev) - [Mail.ru Cloud](https://rclone.org/mailru/) (Ivan Andreev) - New Features - encodings (Fabian Möller & Nick Craig-Wood) - All backends now use file name encoding to ensure any file name can be written to any backend. - See the [restricted file name docs](https://rclone.org/overview/#restricted-filenames) for more info and the [local backend docs](/local/#filenames). - Some file names may look different in rclone if you are using any control characters in names or [unicode FULLWIDTH symbols](https://en.wikipedia.org/wiki/Halfwidth_and_Fullwidth_Forms_(Unicode_block)). - build - Update to use go1.13 for the build (Nick Craig-Wood) - Drop support for go1.9 (Nick Craig-Wood) - Build rclone with GitHub actions (Nick Craig-Wood) - Convert python scripts to python3 (Nick Craig-Wood) - Swap Azure/go-ansiterm for mattn/go-colorable (Nick Craig-Wood) - Dockerfile fixes (Matei David) - Add [plugin support](https://github.com/rclone/rclone/blob/master/CONTRIBUTING.md#writing-a-plugin) for backends and commands (Richard Patel) - config - Use alternating Red/Green in config to make more obvious (Nick Craig-Wood) - contrib - Add sample DLNA server Docker Compose manifest. (pataquets) - Add sample WebDAV server Docker Compose manifest. (pataquets) - copyurl - Add `--auto-filename` flag for using file name from URL in destination path (Denis) - serve dlna: - Many compatibility improvements (Dan Walters) - Support for external srt subtitles (Dan Walters) - rc - Added command core/quit (Saksham Khanna) - Bug Fixes - sync - Make `--update`/`-u` not transfer files that haven't changed (Nick Craig-Wood) - Free objects after they come out of the transfer pipe to save memory (Nick Craig-Wood) - Fix `--files-from without --no-traverse` doing a recursive scan (Nick Craig-Wood) - operations - Fix accounting for server-side copies (Nick Craig-Wood) - Display 'All duplicates removed' only if dedupe successful (Sezal Agrawal) - Display 'Deleted X extra copies' only if dedupe successful (Sezal Agrawal) - accounting - Only allow up to 100 completed transfers in the accounting list to save memory (Nick Craig-Wood) - Cull the old time ranges when possible to save memory (Nick Craig-Wood) - Fix panic due to server-side copy fallback (Ivan Andreev) - Fix memory leak noticeable for transfers of large numbers of objects (Nick Craig-Wood) - Fix total duration calculation (Nick Craig-Wood) - cmd - Fix environment variables not setting command line flags (Nick Craig-Wood) - Make autocomplete compatible with bash's posix mode for macOS (Danil Semelenov) - Make `--progress` work in git bash on Windows (Nick Craig-Wood) - Fix 'compopt: command not found' on autocomplete on macOS (Danil Semelenov) - config - Fix setting of non top level flags from environment variables (Nick Craig-Wood) - Check config names more carefully and report errors (Nick Craig-Wood) - Remove error: can't use `--size-only` and `--ignore-size` together. (Nick Craig-Wood) - filter: Prevent mixing options when `--files-from` is in use (Michele Caci) - serve sftp: Fix crash on unsupported operations (e.g. Readlink) (Nick Craig-Wood) - Mount - Allow files of unknown size to be read properly (Nick Craig-Wood) - Skip tests on <= 2 CPUs to avoid lockup (Nick Craig-Wood) - Fix panic on File.Open (Nick Craig-Wood) - Fix "mount_fusefs: -o timeout=: option not supported" on FreeBSD (Nick Craig-Wood) - Don't pass huge filenames (>4k) to FUSE as it can't cope (Nick Craig-Wood) - VFS - Add flag `--vfs-case-insensitive` for windows/macOS mounts (Ivan Andreev) - Make objects of unknown size readable through the VFS (Nick Craig-Wood) - Move writeback of dirty data out of close() method into its own method (FlushWrites) and remove close() call from Flush() (Brett Dutro) - Stop empty dirs disappearing when renamed on bucket-based remotes (Nick Craig-Wood) - Stop change notify polling clearing so much of the directory cache (Nick Craig-Wood) - Azure Blob - Disable logging to the Windows event log (Nick Craig-Wood) - B2 - Remove `unverified:` prefix on sha1 to improve interop (e.g. with CyberDuck) (Nick Craig-Wood) - Box - Add options to get access token via JWT auth (David) - Drive - Disable HTTP/2 by default to work around INTERNAL_ERROR problems (Nick Craig-Wood) - Make sure that drive root ID is always canonical (Nick Craig-Wood) - Fix `--drive-shared-with-me` from the root with lsand `--fast-list` (Nick Craig-Wood) - Fix ChangeNotify polling for shared drives (Nick Craig-Wood) - Fix change notify polling when using appDataFolder (Nick Craig-Wood) - Dropbox - Make disallowed filenames errors not retry (Nick Craig-Wood) - Fix nil pointer exception on restricted files (Nick Craig-Wood) - Fichier - Fix accessing files > 2GB on 32 bit systems (Nick Craig-Wood) - FTP - Allow disabling EPSV mode (Jon Fautley) - HTTP - HEAD directory entries in parallel to speedup (Nick Craig-Wood) - Add `--http-no-head` to stop rclone doing HEAD in listings (Nick Craig-Wood) - Putio - Add ability to resume uploads (Cenk Alti) - S3 - Fix signature v2_auth headers (Anthony Rusdi) - Fix encoding for control characters (Nick Craig-Wood) - Only ask for URL encoded directory listings if we need them on Ceph (Nick Craig-Wood) - Add option for multipart failure behaviour (Aleksandar Jankovic) - Support for multipart copy (庄天翼) - Fix nil pointer reference if no metadata returned for object (Nick Craig-Wood) - SFTP - Fix `--sftp-ask-password` trying to contact the ssh agent (Nick Craig-Wood) - Fix hashes of files with backslashes (Nick Craig-Wood) - Include more ciphers with `--sftp-use-insecure-cipher` (Carlos Ferreyra) - WebDAV - Parse and return Sharepoint error response (Henning Surmeier) ## v1.49.5 - 2019-10-05 - Bug Fixes - Revert back to go1.12.x for the v1.49.x builds as go1.13.x was causing issues (Nick Craig-Wood) - Fix rpm packages by using master builds of nfpm (Nick Craig-Wood) - Fix macOS build after brew changes (Nick Craig-Wood) ## v1.49.4 - 2019-09-29 - Bug Fixes - cmd/rcd: Address ZipSlip vulnerability (Richard Patel) - accounting: Fix file handle leak on errors (Nick Craig-Wood) - oauthutil: Fix security problem when running with two users on the same machine (Nick Craig-Wood) - FTP - Fix listing of an empty root returning: error dir not found (Nick Craig-Wood) - S3 - Fix SetModTime on GLACIER/ARCHIVE objects and implement set/get tier (Nick Craig-Wood) ## v1.49.3 - 2019-09-15 - Bug Fixes - accounting - Fix total duration calculation (Aleksandar Jankovic) - Fix "file already closed" on transfer retries (Nick Craig-Wood) ## v1.49.2 - 2019-09-08 - New Features - build: Add Docker workflow support (Alfonso Montero) - Bug Fixes - accounting: Fix locking in Transfer to avoid deadlock with `--progress` (Nick Craig-Wood) - docs: Fix template argument for mktemp in install.sh (Cnly) - operations: Fix `-u`/`--update` with google photos / files of unknown size (Nick Craig-Wood) - rc: Fix docs for config/create /update /password (Nick Craig-Wood) - Google Cloud Storage - Fix need for elevated permissions on SetModTime (Nick Craig-Wood) ## v1.49.1 - 2019-08-28 - Bug Fixes - config: Fix generated passwords being stored as empty password (Nick Craig-Wood) - rcd: Added missing parameter for web-gui info logs. (Chaitanya) - Googlephotos - Fix crash on error response (Nick Craig-Wood) - Onedrive - Fix crash on error response (Nick Craig-Wood) ## v1.49.0 - 2019-08-26 - New backends - [1fichier](https://rclone.org/fichier/) (Laura Hausmann) - [Google Photos](https://rclone.org/googlephotos/) (Nick Craig-Wood) - [Putio](https://rclone.org/putio/) (Cenk Alti) - [premiumize.me](https://rclone.org/premiumizeme/) (Nick Craig-Wood) - New Features - Experimental [web GUI](https://rclone.org/gui/) (Chaitanya Bankanhal) - Implement `--compare-dest` & `--copy-dest` (yparitcher) - Implement `--suffix` without `--backup-dir` for backup to current dir (yparitcher) - `config reconnect` to re-login (re-run the oauth login) for the backend. (Nick Craig-Wood) - `config userinfo` to discover which user you are logged in as. (Nick Craig-Wood) - `config disconnect` to disconnect you (log out) from the backend. (Nick Craig-Wood) - Add `--use-json-log` for JSON logging (justinalin) - Add context propagation to rclone (Aleksandar Jankovic) - Reworking internal statistics interfaces so they work with rc jobs (Aleksandar Jankovic) - Add Higher units for ETA (AbelThar) - Update rclone logos to new design (Andreas Chlupka) - hash: Add CRC-32 support (Cenk Alti) - help showbackend: Fixed advanced option category when there are no standard options (buengese) - ncdu: Display/Copy to Clipboard Current Path (Gary Kim) - operations: - Run hashing operations in parallel (Nick Craig-Wood) - Don't calculate checksums when using `--ignore-checksum` (Nick Craig-Wood) - Check transfer hashes when using `--size-only` mode (Nick Craig-Wood) - Disable multi thread copy for local to local copies (Nick Craig-Wood) - Debug successful hashes as well as failures (Nick Craig-Wood) - rc - Add ability to stop async jobs (Aleksandar Jankovic) - Return current settings if core/bwlimit called without parameters (Nick Craig-Wood) - Rclone-WebUI integration with rclone (Chaitanya Bankanhal) - Added command line parameter to control the cross origin resource sharing (CORS) in the rcd. (Security Improvement) (Chaitanya Bankanhal) - Add anchor tags to the docs so links are consistent (Nick Craig-Wood) - Remove _async key from input parameters after parsing so later operations won't get confused (buengese) - Add call to clear stats (Aleksandar Jankovic) - rcd - Auto-login for web-gui (Chaitanya Bankanhal) - Implement `--baseurl` for rcd and web-gui (Chaitanya Bankanhal) - serve dlna - Only select interfaces which can multicast for SSDP (Nick Craig-Wood) - Add more builtin mime types to cover standard audio/video (Nick Craig-Wood) - Fix missing mime types on Android causing missing videos (Nick Craig-Wood) - serve ftp - Refactor to bring into line with other serve commands (Nick Craig-Wood) - Implement `--auth-proxy` (Nick Craig-Wood) - serve http: Implement `--baseurl` (Nick Craig-Wood) - serve restic: Implement `--baseurl` (Nick Craig-Wood) - serve sftp - Implement auth proxy (Nick Craig-Wood) - Fix detection of whether server is authorized (Nick Craig-Wood) - serve webdav - Implement `--baseurl` (Nick Craig-Wood) - Support `--auth-proxy` (Nick Craig-Wood) - Bug Fixes - Make "bad record MAC" a retriable error (Nick Craig-Wood) - copyurl: Fix copying files that return HTTP errors (Nick Craig-Wood) - march: Fix checking sub-directories when using `--no-traverse` (buengese) - rc - Fix unmarshalable http.AuthFn in options and put in test for marshalability (Nick Craig-Wood) - Move job expire flags to rc to fix initialization problem (Nick Craig-Wood) - Fix `--loopback` with rc/list and others (Nick Craig-Wood) - rcat: Fix slowdown on systems with multiple hashes (Nick Craig-Wood) - rcd: Fix permissions problems on cache directory with web gui download (Nick Craig-Wood) - Mount - Default `--daemon-timeout` to 15 minutes on macOS and FreeBSD (Nick Craig-Wood) - Update docs to show mounting from root OK for bucket-based (Nick Craig-Wood) - Remove nonseekable flag from write files (Nick Craig-Wood) - VFS - Make write without cache more efficient (Nick Craig-Wood) - Fix `--vfs-cache-mode minimal` and `writes` ignoring cached files (Nick Craig-Wood) - Local - Add `--local-case-sensitive` and `--local-case-insensitive` (Nick Craig-Wood) - Avoid polluting page cache when uploading local files to remote backends (Michał Matczuk) - Don't calculate any hashes by default (Nick Craig-Wood) - Fadvise run syscall on a dedicated go routine (Michał Matczuk) - Azure Blob - Azure Storage Emulator support (Sandeep) - Updated config help details to remove connection string references (Sandeep) - Make all operations work from the root (Nick Craig-Wood) - B2 - Implement link sharing (yparitcher) - Enable server-side copy to copy between buckets (Nick Craig-Wood) - Make all operations work from the root (Nick Craig-Wood) - Drive - Fix server-side copy of big files (Nick Craig-Wood) - Update API for teamdrive use (Nick Craig-Wood) - Add error for purge with `--drive-trashed-only` (ginvine) - Fichier - Make FolderID int and adjust related code (buengese) - Google Cloud Storage - Reduce oauth scope requested as suggested by Google (Nick Craig-Wood) - Make all operations work from the root (Nick Craig-Wood) - HTTP - Add `--http-headers` flag for setting arbitrary headers (Nick Craig-Wood) - Jottacloud - Use new api for retrieving internal username (buengese) - Refactor configuration and minor cleanup (buengese) - Koofr - Support setting modification times on Koofr backend. (jaKa) - Opendrive - Refactor to use existing lib/rest facilities for uploads (Nick Craig-Wood) - Qingstor - Upgrade to v3 SDK and fix listing loop (Nick Craig-Wood) - Make all operations work from the root (Nick Craig-Wood) - S3 - Add INTELLIGENT_TIERING storage class (Matti Niemenmaa) - Make all operations work from the root (Nick Craig-Wood) - SFTP - Add missing interface check and fix About (Nick Craig-Wood) - Completely ignore all modtime checks if SetModTime=false (Jon Fautley) - Support md5/sha1 with rsync.net (Nick Craig-Wood) - Save the md5/sha1 command in use to the config file for efficiency (Nick Craig-Wood) - Opt-in support for diffie-hellman-group-exchange-sha256 diffie-hellman-group-exchange-sha1 (Yi FU) - Swift - Use FixRangeOption to fix 0 length files via the VFS (Nick Craig-Wood) - Fix upload when using no_chunk to return the correct size (Nick Craig-Wood) - Make all operations work from the root (Nick Craig-Wood) - Fix segments leak during failed large file uploads. (nguyenhuuluan434) - WebDAV - Add `--webdav-bearer-token-command` (Nick Craig-Wood) - Refresh token when it expires with `--webdav-bearer-token-command` (Nick Craig-Wood) - Add docs for using bearer_token_command with oidc-agent (Paul Millar) ## v1.48.0 - 2019-06-15 - New commands - serve sftp: Serve an rclone remote over SFTP (Nick Craig-Wood) - New Features - Multi threaded downloads to local storage (Nick Craig-Wood) - controlled with `--multi-thread-cutoff` and `--multi-thread-streams` - Use rclone.conf from rclone executable directory to enable portable use (albertony) - Allow sync of a file and a directory with the same name (forgems) - this is common on bucket-based remotes, e.g. s3, gcs - Add `--ignore-case-sync` for forced case insensitivity (garry415) - Implement `--stats-one-line-date` and `--stats-one-line-date-format` (Peter Berbec) - Log an ERROR for all commands which exit with non-zero status (Nick Craig-Wood) - Use go-homedir to read the home directory more reliably (Nick Craig-Wood) - Enable creating encrypted config through external script invocation (Wojciech Smigielski) - build: Drop support for go1.8 (Nick Craig-Wood) - config: Make config create/update encrypt passwords where necessary (Nick Craig-Wood) - copyurl: Honor `--no-check-certificate` (Stefan Breunig) - install: Linux skip man pages if no mandb (didil) - lsf: Support showing the Tier of the object (Nick Craig-Wood) - lsjson - Added EncryptedPath to output (calisro) - Support showing the Tier of the object (Nick Craig-Wood) - Add IsBucket field for bucket-based remote listing of the root (Nick Craig-Wood) - rc - Add `--loopback` flag to run commands directly without a server (Nick Craig-Wood) - Add operations/fsinfo: Return information about the remote (Nick Craig-Wood) - Skip auth for OPTIONS request (Nick Craig-Wood) - cmd/providers: Add DefaultStr, ValueStr and Type fields (Nick Craig-Wood) - jobs: Make job expiry timeouts configurable (Aleksandar Jankovic) - serve dlna reworked and improved (Dan Walters) - serve ftp: add `--ftp-public-ip` flag to specify public IP (calistri) - serve restic: Add support for `--private-repos` in `serve restic` (Florian Apolloner) - serve webdav: Combine serve webdav and serve http (Gary Kim) - size: Ignore negative sizes when calculating total (Garry McNulty) - Bug Fixes - Make move and copy individual files obey `--backup-dir` (Nick Craig-Wood) - If `--ignore-checksum` is in effect, don't calculate checksum (Nick Craig-Wood) - moveto: Fix case-insensitive same remote move (Gary Kim) - rc: Fix serving bucket-based objects with `--rc-serve` (Nick Craig-Wood) - serve webdav: Fix serveDir not being updated with changes from webdav (Gary Kim) - Mount - Fix poll interval documentation (Animosity022) - VFS - Make WriteAt for non cached files work with non-sequential writes (Nick Craig-Wood) - Local - Only calculate the required hashes for big speedup (Nick Craig-Wood) - Log errors when listing instead of returning an error (Nick Craig-Wood) - Fix preallocate warning on Linux with ZFS (Nick Craig-Wood) - Crypt - Make rclone dedupe work through crypt (Nick Craig-Wood) - Fix wrapping of ChangeNotify to decrypt directories properly (Nick Craig-Wood) - Support PublicLink (rclone link) of underlying backend (Nick Craig-Wood) - Implement Optional methods SetTier, GetTier (Nick Craig-Wood) - B2 - Implement server-side copy (Nick Craig-Wood) - Implement SetModTime (Nick Craig-Wood) - Drive - Fix move and copy from TeamDrive to GDrive (Fionera) - Add notes that cleanup works in the background on drive (Nick Craig-Wood) - Add `--drive-server-side-across-configs` to default back to old server-side copy semantics by default (Nick Craig-Wood) - Add `--drive-size-as-quota` to show storage quota usage for file size (Garry McNulty) - FTP - Add FTP List timeout (Jeff Quinn) - Add FTP over TLS support (Gary Kim) - Add `--ftp-no-check-certificate` option for FTPS (Gary Kim) - Google Cloud Storage - Fix upload errors when uploading pre 1970 files (Nick Craig-Wood) - Jottacloud - Add support for selecting device and mountpoint. (buengese) - Mega - Add cleanup support (Gary Kim) - Onedrive - More accurately check if root is found (Cnly) - S3 - Support S3 Accelerated endpoints with `--s3-use-accelerate-endpoint` (Nick Craig-Wood) - Add config info for Wasabi's EU Central endpoint (Robert Marko) - Make SetModTime work for GLACIER while syncing (Philip Harvey) - SFTP - Add About support (Gary Kim) - Fix about parsing of `df` results so it can cope with -ve results (Nick Craig-Wood) - Send custom client version and debug server version (Nick Craig-Wood) - WebDAV - Retry on 423 Locked errors (Nick Craig-Wood) ## v1.47.0 - 2019-04-13 - New backends - Backend for Koofr cloud storage service. (jaKa) - New Features - Resume downloads if the reader fails in copy (Nick Craig-Wood) - this means rclone will restart transfers if the source has an error - this is most useful for downloads or cloud to cloud copies - Use `--fast-list` for listing operations where it won't use more memory (Nick Craig-Wood) - this should speed up the following operations on remotes which support `ListR` - `dedupe`, `serve restic` `lsf`, `ls`, `lsl`, `lsjson`, `lsd`, `md5sum`, `sha1sum`, `hashsum`, `size`, `delete`, `cat`, `settier` - use `--disable ListR` to get old behaviour if required - Make `--files-from` traverse the destination unless `--no-traverse` is set (Nick Craig-Wood) - this fixes `--files-from` with Google drive and excessive API use in general. - Make server-side copy account bytes and obey `--max-transfer` (Nick Craig-Wood) - Add `--create-empty-src-dirs` flag and default to not creating empty dirs (ishuah) - Add client side TLS/SSL flags `--ca-cert`/`--client-cert`/`--client-key` (Nick Craig-Wood) - Implement `--suffix-keep-extension` for use with `--suffix` (Nick Craig-Wood) - build: - Switch to semver compliant version tags to be go modules compliant (Nick Craig-Wood) - Update to use go1.12.x for the build (Nick Craig-Wood) - serve dlna: Add connection manager service description to improve compatibility (Dan Walters) - lsf: Add 'e' format to show encrypted names and 'o' for original IDs (Nick Craig-Wood) - lsjson: Added `--files-only` and `--dirs-only` flags (calistri) - rc: Implement operations/publiclink the equivalent of `rclone link` (Nick Craig-Wood) - Bug Fixes - accounting: Fix total ETA when `--stats-unit bits` is in effect (Nick Craig-Wood) - Bash TAB completion - Use private custom func to fix clash between rclone and kubectl (Nick Craig-Wood) - Fix for remotes with underscores in their names (Six) - Fix completion of remotes (Florian Gamböck) - Fix autocompletion of remote paths with spaces (Danil Semelenov) - serve dlna: Fix root XML service descriptor (Dan Walters) - ncdu: Fix display corruption with Chinese characters (Nick Craig-Wood) - Add SIGTERM to signals which run the exit handlers on unix (Nick Craig-Wood) - rc: Reload filter when the options are set via the rc (Nick Craig-Wood) - VFS / Mount - Fix FreeBSD: Ignore Truncate if called with no readers and already the correct size (Nick Craig-Wood) - Read directory and check for a file before mkdir (Nick Craig-Wood) - Shorten the locking window for vfs/refresh (Nick Craig-Wood) - Azure Blob - Enable MD5 checksums when uploading files bigger than the "Cutoff" (Dr.Rx) - Fix SAS URL support (Nick Craig-Wood) - B2 - Allow manual configuration of backblaze downloadUrl (Vince) - Ignore already_hidden error on remove (Nick Craig-Wood) - Ignore malformed `src_last_modified_millis` (Nick Craig-Wood) - Drive - Add `--skip-checksum-gphotos` to ignore incorrect checksums on Google Photos (Nick Craig-Wood) - Allow server-side move/copy between different remotes. (Fionera) - Add docs on team drives and `--fast-list` eventual consistency (Nestar47) - Fix imports of text files (Nick Craig-Wood) - Fix range requests on 0 length files (Nick Craig-Wood) - Fix creation of duplicates with server-side copy (Nick Craig-Wood) - Dropbox - Retry blank errors to fix long listings (Nick Craig-Wood) - FTP - Add `--ftp-concurrency` to limit maximum number of connections (Nick Craig-Wood) - Google Cloud Storage - Fall back to default application credentials (marcintustin) - Allow bucket policy only buckets (Nick Craig-Wood) - HTTP - Add `--http-no-slash` for websites with directories with no slashes (Nick Craig-Wood) - Remove duplicates from listings (Nick Craig-Wood) - Fix socket leak on 404 errors (Nick Craig-Wood) - Jottacloud - Fix token refresh (Sebastian Bünger) - Add device registration (Oliver Heyme) - Onedrive - Implement graceful cancel of multipart uploads if rclone is interrupted (Cnly) - Always add trailing colon to path when addressing items, (Cnly) - Return errors instead of panic for invalid uploads (Fabian Möller) - S3 - Add support for "Glacier Deep Archive" storage class (Manu) - Update Dreamhost endpoint (Nick Craig-Wood) - Note incompatibility with CEPH Jewel (Nick Craig-Wood) - SFTP - Allow custom ssh client config (Alexandru Bumbacea) - Swift - Obey Retry-After to enable OVH restore from cold storage (Nick Craig-Wood) - Work around token expiry on CEPH (Nick Craig-Wood) - WebDAV - Allow IsCollection property to be integer or boolean (Nick Craig-Wood) - Fix race when creating directories (Nick Craig-Wood) - Fix About/df when reading the available/total returns 0 (Nick Craig-Wood) ## v1.46 - 2019-02-09 - New backends - Support Alibaba Cloud (Aliyun) OSS via the s3 backend (Nick Craig-Wood) - New commands - serve dlna: serves a remove via DLNA for the local network (nicolov) - New Features - copy, move: Restore deprecated `--no-traverse` flag (Nick Craig-Wood) - This is useful for when transferring a small number of files into a large destination - genautocomplete: Add remote path completion for bash completion (Christopher Peterson & Danil Semelenov) - Buffer memory handling reworked to return memory to the OS better (Nick Craig-Wood) - Buffer recycling library to replace sync.Pool - Optionally use memory mapped memory for better memory shrinking - Enable with `--use-mmap` if having memory problems - not default yet - Parallelise reading of files specified by `--files-from` (Nick Craig-Wood) - check: Add stats showing total files matched. (Dario Guzik) - Allow rename/delete open files under Windows (Nick Craig-Wood) - lsjson: Use exactly the correct number of decimal places in the seconds (Nick Craig-Wood) - Add cookie support with cmdline switch `--use-cookies` for all HTTP based remotes (qip) - Warn if `--checksum` is set but there are no hashes available (Nick Craig-Wood) - Rework rate limiting (pacer) to be more accurate and allow bursting (Nick Craig-Wood) - Improve error reporting for too many/few arguments in commands (Nick Craig-Wood) - listremotes: Remove `-l` short flag as it conflicts with the new global flag (weetmuts) - Make http serving with auth generate INFO messages on auth fail (Nick Craig-Wood) - Bug Fixes - Fix layout of stats (Nick Craig-Wood) - Fix `--progress` crash under Windows Jenkins (Nick Craig-Wood) - Fix transfer of google/onedrive docs by calling Rcat in Copy when size is -1 (Cnly) - copyurl: Fix checking of `--dry-run` (Denis Skovpen) - Mount - Check that mountpoint and local directory to mount don't overlap (Nick Craig-Wood) - Fix mount size under 32 bit Windows (Nick Craig-Wood) - VFS - Implement renaming of directories for backends without DirMove (Nick Craig-Wood) - now all backends except b2 support renaming directories - Implement `--vfs-cache-max-size` to limit the total size of the cache (Nick Craig-Wood) - Add `--dir-perms` and `--file-perms` flags to set default permissions (Nick Craig-Wood) - Fix deadlock on concurrent operations on a directory (Nick Craig-Wood) - Fix deadlock between RWFileHandle.close and File.Remove (Nick Craig-Wood) - Fix renaming/deleting open files with cache mode "writes" under Windows (Nick Craig-Wood) - Fix panic on rename with `--dry-run` set (Nick Craig-Wood) - Fix vfs/refresh with recurse=true needing the `--fast-list` flag - Local - Add support for `-l`/`--links` (symbolic link translation) (yair@unicorn) - this works by showing links as `link.rclonelink` - see local backend docs for more info - this errors if used with `-L`/`--copy-links` - Fix renaming/deleting open files on Windows (Nick Craig-Wood) - Crypt - Check for maximum length before decrypting filename to fix panic (Garry McNulty) - Azure Blob - Allow building azureblob backend on *BSD (themylogin) - Use the rclone HTTP client to support `--dump headers`, `--tpslimit`, etc. (Nick Craig-Wood) - Use the s3 pacer for 0 delay in non error conditions (Nick Craig-Wood) - Ignore directory markers (Nick Craig-Wood) - Stop Mkdir attempting to create existing containers (Nick Craig-Wood) - B2 - cleanup: will remove unfinished large files >24hrs old (Garry McNulty) - For a bucket limited application key check the bucket name (Nick Craig-Wood) - before this, rclone would use the authorised bucket regardless of what you put on the command line - Added `--b2-disable-checksum` flag (Wojciech Smigielski) - this enables large files to be uploaded without a SHA-1 hash for speed reasons - Drive - Set default pacer to 100ms for 10 tps (Nick Craig-Wood) - This fits the Google defaults much better and reduces the 403 errors massively - Add `--drive-pacer-min-sleep` and `--drive-pacer-burst` to control the pacer - Improve ChangeNotify support for items with multiple parents (Fabian Möller) - Fix ListR for items with multiple parents - this fixes oddities with `vfs/refresh` (Fabian Möller) - Fix using `--drive-impersonate` and appfolders (Nick Craig-Wood) - Fix google docs in rclone mount for some (not all) applications (Nick Craig-Wood) - Dropbox - Retry-After support for Dropbox backend (Mathieu Carbou) - FTP - Wait for 60 seconds for a connection to Close then declare it dead (Nick Craig-Wood) - helps with indefinite hangs on some FTP servers - Google Cloud Storage - Update google cloud storage endpoints (weetmuts) - HTTP - Add an example with username and password which is supported but wasn't documented (Nick Craig-Wood) - Fix backend with `--files-from` and nonexistent files (Nick Craig-Wood) - Hubic - Make error message more informative if authentication fails (Nick Craig-Wood) - Jottacloud - Resume and deduplication support (Oliver Heyme) - Use token auth for all API requests Don't store password anymore (Sebastian Bünger) - Add support for 2-factor authentication (Sebastian Bünger) - Mega - Implement v2 account login which fixes logins for newer Mega accounts (Nick Craig-Wood) - Return error if an unknown length file is attempted to be uploaded (Nick Craig-Wood) - Add new error codes for better error reporting (Nick Craig-Wood) - Onedrive - Fix broken support for "shared with me" folders (Alex Chen) - Fix root ID not normalised (Cnly) - Return err instead of panic on unknown-sized uploads (Cnly) - Qingstor - Fix go routine leak on multipart upload errors (Nick Craig-Wood) - Add upload chunk size/concurrency/cutoff control (Nick Craig-Wood) - Default `--qingstor-upload-concurrency` to 1 to work around bug (Nick Craig-Wood) - S3 - Implement `--s3-upload-cutoff` for single part uploads below this (Nick Craig-Wood) - Change `--s3-upload-concurrency` default to 4 to increase performance (Nick Craig-Wood) - Add `--s3-bucket-acl` to control bucket ACL (Nick Craig-Wood) - Auto detect region for buckets on operation failure (Nick Craig-Wood) - Add GLACIER storage class (William Cocker) - Add Scaleway to s3 documentation (Rémy Léone) - Add AWS endpoint eu-north-1 (weetmuts) - SFTP - Add support for PEM encrypted private keys (Fabian Möller) - Add option to force the usage of an ssh-agent (Fabian Möller) - Perform environment variable expansion on key-file (Fabian Möller) - Fix rmdir on Windows based servers (e.g. CrushFTP) (Nick Craig-Wood) - Fix rmdir deleting directory contents on some SFTP servers (Nick Craig-Wood) - Fix error on dangling symlinks (Nick Craig-Wood) - Swift - Add `--swift-no-chunk` to disable segmented uploads in rcat/mount (Nick Craig-Wood) - Introduce application credential auth support (kayrus) - Fix memory usage by slimming Object (Nick Craig-Wood) - Fix extra requests on upload (Nick Craig-Wood) - Fix reauth on big files (Nick Craig-Wood) - Union - Fix poll-interval not working (Nick Craig-Wood) - WebDAV - Support About which means rclone mount will show the correct disk size (Nick Craig-Wood) - Support MD5 and SHA1 hashes with Owncloud and Nextcloud (Nick Craig-Wood) - Fail soft on time parsing errors (Nick Craig-Wood) - Fix infinite loop on failed directory creation (Nick Craig-Wood) - Fix identification of directories for Bitrix Site Manager (Nick Craig-Wood) - Fix upload of 0 length files on some servers (Nick Craig-Wood) - Fix if MKCOL fails with 423 Locked assume the directory exists (Nick Craig-Wood) ## v1.45 - 2018-11-24 - New backends - The Yandex backend was re-written - see below for details (Sebastian Bünger) - New commands - rcd: New command just to serve the remote control API (Nick Craig-Wood) - New Features - The remote control API (rc) was greatly expanded to allow full control over rclone (Nick Craig-Wood) - sensitive operations require authorization or the `--rc-no-auth` flag - config/* operations to configure rclone - options/* for reading/setting command line flags - operations/* for all low level operations, e.g. copy file, list directory - sync/* for sync, copy and move - `--rc-files` flag to serve files on the rc http server - this is for building web native GUIs for rclone - Optionally serving objects on the rc http server - Ensure rclone fails to start up if the `--rc` port is in use already - See [the rc docs](https://rclone.org/rc/) for more info - sync/copy/move - Make `--files-from` only read the objects specified and don't scan directories (Nick Craig-Wood) - This is a huge speed improvement for destinations with lots of files - filter: Add `--ignore-case` flag (Nick Craig-Wood) - ncdu: Add remove function ('d' key) (Henning Surmeier) - rc command - Add `--json` flag for structured JSON input (Nick Craig-Wood) - Add `--user` and `--pass` flags and interpret `--rc-user`, `--rc-pass`, `--rc-addr` (Nick Craig-Wood) - build - Require go1.8 or later for compilation (Nick Craig-Wood) - Enable softfloat on MIPS arch (Scott Edlund) - Integration test framework revamped with a better report and better retries (Nick Craig-Wood) - Bug Fixes - cmd: Make `--progress` update the stats correctly at the end (Nick Craig-Wood) - config: Create config directory on save if it is missing (Nick Craig-Wood) - dedupe: Check for existing filename before renaming a dupe file (ssaqua) - move: Don't create directories with `--dry-run` (Nick Craig-Wood) - operations: Fix Purge and Rmdirs when dir is not the root (Nick Craig-Wood) - serve http/webdav/restic: Ensure rclone exits if the port is in use (Nick Craig-Wood) - Mount - Make `--volname` work for Windows and macOS (Nick Craig-Wood) - Azure Blob - Avoid context deadline exceeded error by setting a large TryTimeout value (brused27) - Fix erroneous Rmdir error "directory not empty" (Nick Craig-Wood) - Wait for up to 60s to create a just deleted container (Nick Craig-Wood) - Dropbox - Add dropbox impersonate support (Jake Coggiano) - Jottacloud - Fix bug in `--fast-list` handing of empty folders (albertony) - Opendrive - Fix transfer of files with `+` and `&` in (Nick Craig-Wood) - Fix retries of upload chunks (Nick Craig-Wood) - S3 - Set ACL for server-side copies to that provided by the user (Nick Craig-Wood) - Fix role_arn, credential_source, ... (Erik Swanson) - Add config info for Wasabi's US-West endpoint (Henry Ptasinski) - SFTP - Ensure file hash checking is really disabled (Jon Fautley) - Swift - Add pacer for retries to make swift more reliable (Nick Craig-Wood) - WebDAV - Add Content-Type to PUT requests (Nick Craig-Wood) - Fix config parsing so `--webdav-user` and `--webdav-pass` flags work (Nick Craig-Wood) - Add RFC3339 date format (Ralf Hemberger) - Yandex - The yandex backend was re-written (Sebastian Bünger) - This implements low level retries (Sebastian Bünger) - Copy, Move, DirMove, PublicLink and About optional interfaces (Sebastian Bünger) - Improved general error handling (Sebastian Bünger) - Removed ListR for now due to inconsistent behaviour (Sebastian Bünger) ## v1.44 - 2018-10-15 - New commands - serve ftp: Add ftp server (Antoine GIRARD) - settier: perform storage tier changes on supported remotes (sandeepkru) - New Features - Reworked command line help - Make default help less verbose (Nick Craig-Wood) - Split flags up into global and backend flags (Nick Craig-Wood) - Implement specialised help for flags and backends (Nick Craig-Wood) - Show URL of backend help page when starting config (Nick Craig-Wood) - stats: Long names now split in center (Joanna Marek) - Add `--log-format` flag for more control over log output (dcpu) - rc: Add support for OPTIONS and basic CORS (frenos) - stats: show FatalErrors and NoRetryErrors in stats (Cédric Connes) - Bug Fixes - Fix -P not ending with a new line (Nick Craig-Wood) - config: don't create default config dir when user supplies `--config` (albertony) - Don't print non-ASCII characters with `--progress` on windows (Nick Craig-Wood) - Correct logs for excluded items (ssaqua) - Mount - Remove EXPERIMENTAL tags (Nick Craig-Wood) - VFS - Fix race condition detected by serve ftp tests (Nick Craig-Wood) - Add vfs/poll-interval rc command (Fabian Möller) - Enable rename for nearly all remotes using server-side Move or Copy (Nick Craig-Wood) - Reduce directory cache cleared by poll-interval (Fabian Möller) - Remove EXPERIMENTAL tags (Nick Craig-Wood) - Local - Skip bad symlinks in dir listing with -L enabled (Cédric Connes) - Preallocate files on Windows to reduce fragmentation (Nick Craig-Wood) - Preallocate files on linux with fallocate(2) (Nick Craig-Wood) - Cache - Add cache/fetch rc function (Fabian Möller) - Fix worker scale down (Fabian Möller) - Improve performance by not sending info requests for cached chunks (dcpu) - Fix error return value of cache/fetch rc method (Fabian Möller) - Documentation fix for cache-chunk-total-size (Anagh Kumar Baranwal) - Preserve leading / in wrapped remote path (Fabian Möller) - Add plex_insecure option to skip certificate validation (Fabian Möller) - Remove entries that no longer exist in the source (dcpu) - Crypt - Preserve leading / in wrapped remote path (Fabian Möller) - Alias - Fix handling of Windows network paths (Nick Craig-Wood) - Azure Blob - Add `--azureblob-list-chunk` parameter (Santiago Rodríguez) - Implemented settier command support on azureblob remote. (sandeepkru) - Work around SDK bug which causes errors for chunk-sized files (Nick Craig-Wood) - Box - Implement link sharing. (Sebastian Bünger) - Drive - Add `--drive-import-formats` - google docs can now be imported (Fabian Möller) - Rewrite mime type and extension handling (Fabian Möller) - Add document links (Fabian Möller) - Add support for multipart document extensions (Fabian Möller) - Add support for apps-script to json export (Fabian Möller) - Fix escaped chars in documents during list (Fabian Möller) - Add `--drive-v2-download-min-size` a workaround for slow downloads (Fabian Möller) - Improve directory notifications in ChangeNotify (Fabian Möller) - When listing team drives in config, continue on failure (Nick Craig-Wood) - FTP - Add a small pause after failed upload before deleting file (Nick Craig-Wood) - Google Cloud Storage - Fix service_account_file being ignored (Fabian Möller) - Jottacloud - Minor improvement in quota info (omit if unlimited) (albertony) - Add `--fast-list` support (albertony) - Add permanent delete support: `--jottacloud-hard-delete` (albertony) - Add link sharing support (albertony) - Fix handling of reserved characters. (Sebastian Bünger) - Fix socket leak on Object.Remove (Nick Craig-Wood) - Onedrive - Rework to support Microsoft Graph (Cnly) - **NB** this will require re-authenticating the remote - Removed upload cutoff and always do session uploads (Oliver Heyme) - Use single-part upload for empty files (Cnly) - Fix new fields not saved when editing old config (Alex Chen) - Fix sometimes special chars in filenames not replaced (Alex Chen) - Ignore OneNote files by default (Alex Chen) - Add link sharing support (jackyzy823) - S3 - Use custom pacer, to retry operations when reasonable (Craig Miskell) - Use configured server-side-encryption and storage class options when calling CopyObject() (Paul Kohout) - Make `--s3-v2-auth` flag (Nick Craig-Wood) - Fix v2 auth on files with spaces (Nick Craig-Wood) - Union - Implement union backend which reads from multiple backends (Felix Brucker) - Implement optional interfaces (Move, DirMove, Copy, etc.) (Nick Craig-Wood) - Fix ChangeNotify to support multiple remotes (Fabian Möller) - Fix `--backup-dir` on union backend (Nick Craig-Wood) - WebDAV - Add another time format (Nick Craig-Wood) - Add a small pause after failed upload before deleting file (Nick Craig-Wood) - Add workaround for missing mtime (buergi) - Sharepoint: Renew cookies after 12hrs (Henning Surmeier) - Yandex - Remove redundant nil checks (teresy) ## v1.43.1 - 2018-09-07 Point release to fix hubic and azureblob backends. - Bug Fixes - ncdu: Return error instead of log.Fatal in Show (Fabian Möller) - cmd: Fix crash with `--progress` and `--stats 0` (Nick Craig-Wood) - docs: Tidy website display (Anagh Kumar Baranwal) - Azure Blob: - Fix multi-part uploads. (sandeepkru) - Hubic - Fix uploads (Nick Craig-Wood) - Retry auth fetching if it fails to make hubic more reliable (Nick Craig-Wood) ## v1.43 - 2018-09-01 - New backends - Jottacloud (Sebastian Bünger) - New commands - copyurl: copies a URL to a remote (Denis) - New Features - Reworked config for backends (Nick Craig-Wood) - All backend config can now be supplied by command line, env var or config file - Advanced section in the config wizard for the optional items - A large step towards rclone backends being usable in other go software - Allow on the fly remotes with :backend: syntax - Stats revamp - Add `--progress`/`-P` flag to show interactive progress (Nick Craig-Wood) - Show the total progress of the sync in the stats (Nick Craig-Wood) - Add `--stats-one-line` flag for single line stats (Nick Craig-Wood) - Added weekday schedule into `--bwlimit` (Mateusz) - lsjson: Add option to show the original object IDs (Fabian Möller) - serve webdav: Make Content-Type without reading the file and add `--etag-hash` (Nick Craig-Wood) - build - Build macOS with native compiler (Nick Craig-Wood) - Update to use go1.11 for the build (Nick Craig-Wood) - rc - Added core/stats to return the stats (reddi1) - `version --check`: Prints the current release and beta versions (Nick Craig-Wood) - Bug Fixes - accounting - Fix time to completion estimates (Nick Craig-Wood) - Fix moving average speed for file stats (Nick Craig-Wood) - config: Fix error reading password from piped input (Nick Craig-Wood) - move: Fix `--delete-empty-src-dirs` flag to delete all empty dirs on move (ishuah) - Mount - Implement `--daemon-timeout` flag for OSXFUSE (Nick Craig-Wood) - Fix mount `--daemon` not working with encrypted config (Alex Chen) - Clip the number of blocks to 2^32-1 on macOS - fixes borg backup (Nick Craig-Wood) - VFS - Enable vfs-read-chunk-size by default (Fabian Möller) - Add the vfs/refresh rc command (Fabian Möller) - Add non recursive mode to vfs/refresh rc command (Fabian Möller) - Try to seek buffer on read only files (Fabian Möller) - Local - Fix crash when deprecated `--local-no-unicode-normalization` is supplied (Nick Craig-Wood) - Fix mkdir error when trying to copy files to the root of a drive on windows (Nick Craig-Wood) - Cache - Fix nil pointer deref when using lsjson on cached directory (Nick Craig-Wood) - Fix nil pointer deref for occasional crash on playback (Nick Craig-Wood) - Crypt - Fix accounting when checking hashes on upload (Nick Craig-Wood) - Amazon Cloud Drive - Make very clear in the docs that rclone has no ACD keys (Nick Craig-Wood) - Azure Blob - Add connection string and SAS URL auth (Nick Craig-Wood) - List the container to see if it exists (Nick Craig-Wood) - Port new Azure Blob Storage SDK (sandeepkru) - Added blob tier, tier between Hot, Cool and Archive. (sandeepkru) - Remove leading / from paths (Nick Craig-Wood) - B2 - Support Application Keys (Nick Craig-Wood) - Remove leading / from paths (Nick Craig-Wood) - Box - Fix upload of > 2GB files on 32 bit platforms (Nick Craig-Wood) - Make `--box-commit-retries` flag defaulting to 100 to fix large uploads (Nick Craig-Wood) - Drive - Add `--drive-keep-revision-forever` flag (lewapm) - Handle gdocs when filtering file names in list (Fabian Möller) - Support using `--fast-list` for large speedups (Fabian Möller) - FTP - Fix Put mkParentDir failed: 521 for BunnyCDN (Nick Craig-Wood) - Google Cloud Storage - Fix index out of range error with `--fast-list` (Nick Craig-Wood) - Jottacloud - Fix MD5 error check (Oliver Heyme) - Handle empty time values (Martin Polden) - Calculate missing MD5s (Oliver Heyme) - Docs, fixes and tests for MD5 calculation (Nick Craig-Wood) - Add optional MimeTyper interface. (Sebastian Bünger) - Implement optional About interface (for `df` support). (Sebastian Bünger) - Mega - Wait for events instead of arbitrary sleeping (Nick Craig-Wood) - Add `--mega-hard-delete` flag (Nick Craig-Wood) - Fix failed logins with upper case chars in email (Nick Craig-Wood) - Onedrive - Shared folder support (Yoni Jah) - Implement DirMove (Cnly) - Fix rmdir sometimes deleting directories with contents (Nick Craig-Wood) - Pcloud - Delete half uploaded files on upload error (Nick Craig-Wood) - Qingstor - Remove leading / from paths (Nick Craig-Wood) - S3 - Fix index out of range error with `--fast-list` (Nick Craig-Wood) - Add `--s3-force-path-style` (Nick Craig-Wood) - Add support for KMS Key ID (bsteiss) - Remove leading / from paths (Nick Craig-Wood) - Swift - Add `storage_policy` (Ruben Vandamme) - Make it so just `storage_url` or `auth_token` can be overridden (Nick Craig-Wood) - Fix server-side copy bug for unusual file names (Nick Craig-Wood) - Remove leading / from paths (Nick Craig-Wood) - WebDAV - Ensure we call MKCOL with a URL with a trailing / for QNAP interop (Nick Craig-Wood) - If root ends with / then don't check if it is a file (Nick Craig-Wood) - Don't accept redirects when reading metadata (Nick Craig-Wood) - Add bearer token (Macaroon) support for dCache (Nick Craig-Wood) - Document dCache and Macaroons (Onno Zweers) - Sharepoint recursion with different depth (Henning) - Attempt to remove failed uploads (Nick Craig-Wood) - Yandex - Fix listing/deleting files in the root (Nick Craig-Wood) ## v1.42 - 2018-06-16 - New backends - OpenDrive (Oliver Heyme, Jakub Karlicek, ncw) - New commands - deletefile command (Filip Bartodziej) - New Features - copy, move: Copy single files directly, don't use `--files-from` work-around - this makes them much more efficient - Implement `--max-transfer` flag to quit transferring at a limit - make exit code 8 for `--max-transfer` exceeded - copy: copy empty source directories to destination (Ishuah Kariuki) - check: Add `--one-way` flag (Kasper Byrdal Nielsen) - Add siginfo handler for macOS for ctrl-T stats (kubatasiemski) - rc - add core/gc to run a garbage collection on demand - enable go profiling by default on the `--rc` port - return error from remote on failure - lsf - Add `--absolute` flag to add a leading / onto path names - Add `--csv` flag for compliant CSV output - Add 'm' format specifier to show the MimeType - Implement 'i' format for showing object ID - lsjson - Add MimeType to the output - Add ID field to output to show Object ID - Add `--retries-sleep` flag (Benjamin Joseph Dag) - Oauth tidy up web page and error handling (Henning Surmeier) - Bug Fixes - Password prompt output with `--log-file` fixed for unix (Filip Bartodziej) - Calculate ModifyWindow each time on the fly to fix various problems (Stefan Breunig) - Mount - Only print "File.rename error" if there actually is an error (Stefan Breunig) - Delay rename if file has open writers instead of failing outright (Stefan Breunig) - Ensure atexit gets run on interrupt - macOS enhancements - Make `--noappledouble` `--noapplexattr` - Add `--volname` flag and remove special chars from it - Make Get/List/Set/Remove xattr return ENOSYS for efficiency - Make `--daemon` work for macOS without CGO - VFS - Add `--vfs-read-chunk-size` and `--vfs-read-chunk-size-limit` (Fabian Möller) - Fix ChangeNotify for new or changed folders (Fabian Möller) - Local - Fix symlink/junction point directory handling under Windows - **NB** you will need to add `-L` to your command line to copy files with reparse points - Cache - Add non cached dirs on notifications (Remus Bunduc) - Allow root to be expired from rc (Remus Bunduc) - Clean remaining empty folders from temp upload path (Remus Bunduc) - Cache lists using batch writes (Remus Bunduc) - Use secure websockets for HTTPS Plex addresses (John Clayton) - Reconnect plex websocket on failures (Remus Bunduc) - Fix panic when running without plex configs (Remus Bunduc) - Fix root folder caching (Remus Bunduc) - Crypt - Check the encrypted hash of files when uploading for extra data security - Dropbox - Make Dropbox for business folders accessible using an initial `/` in the path - Google Cloud Storage - Low level retry all operations if necessary - Google Drive - Add `--drive-acknowledge-abuse` to download flagged files - Add `--drive-alternate-export` to fix large doc export - Don't attempt to choose Team Drives when using rclone config create - Fix change list polling with team drives - Fix ChangeNotify for folders (Fabian Möller) - Fix about (and df on a mount) for team drives - Onedrive - Errorhandler for onedrive for business requests (Henning Surmeier) - S3 - Adjust upload concurrency with `--s3-upload-concurrency` (themylogin) - Fix `--s3-chunk-size` which was always using the minimum - SFTP - Add `--ssh-path-override` flag (Piotr Oleszczyk) - Fix slow downloads for long latency connections - Webdav - Add workarounds for biz.mail.ru - Ignore Reason-Phrase in status line to fix 4shared (Rodrigo) - Better error message generation ## v1.41 - 2018-04-28 - New backends - Mega support added - Webdav now supports SharePoint cookie authentication (hensur) - New commands - link: create public link to files and folders (Stefan Breunig) - about: gets quota info from a remote (a-roussos, ncw) - hashsum: a generic tool for any hash to produce md5sum like output - New Features - lsd: Add -R flag and fix and update docs for all ls commands - ncdu: added a "refresh" key - CTRL-L (Keith Goldfarb) - serve restic: Add append-only mode (Steve Kriss) - serve restic: Disallow overwriting files in append-only mode (Alexander Neumann) - serve restic: Print actual listener address (Matt Holt) - size: Add --json flag (Matthew Holt) - sync: implement --ignore-errors (Mateusz Pabian) - dedupe: Add dedupe largest functionality (Richard Yang) - fs: Extend SizeSuffix to include TB and PB for rclone about - fs: add --dump goroutines and --dump openfiles for debugging - rc: implement core/memstats to print internal memory usage info - rc: new call rc/pid (Michael P. Dubner) - Compile - Drop support for go1.6 - Release - Fix `make tarball` (Chih-Hsuan Yen) - Bug Fixes - filter: fix --min-age and --max-age together check - fs: limit MaxIdleConns and MaxIdleConnsPerHost in transport - lsd,lsf: make sure all times we output are in local time - rc: fix setting bwlimit to unlimited - rc: take note of the --rc-addr flag too as per the docs - Mount - Use About to return the correct disk total/used/free (e.g. in `df`) - Set `--attr-timeout default` to `1s` - fixes: - rclone using too much memory - rclone not serving files to samba - excessive time listing directories - Fix `df -i` (upstream fix) - VFS - Filter files `.` and `..` from directory listing - Only make the VFS cache if --vfs-cache-mode > Off - Local - Add --local-no-check-updated to disable updated file checks - Retry remove on Windows sharing violation error - Cache - Flush the memory cache after close - Purge file data on notification - Always forget parent dir for notifications - Integrate with Plex websocket - Add rc cache/stats (seuffert) - Add info log on notification - Box - Fix failure reading large directories - parse file/directory size as float - Dropbox - Fix crypt+obfuscate on dropbox - Fix repeatedly uploading the same files - FTP - Work around strange response from box FTP server - More workarounds for FTP servers to fix mkParentDir error - Fix no error on listing nonexistent directory - Google Cloud Storage - Add service_account_credentials (Matt Holt) - Detect bucket presence by listing it - minimises permissions needed - Ignore zero length directory markers - Google Drive - Add service_account_credentials (Matt Holt) - Fix directory move leaving a hardlinked directory behind - Return proper google errors when Opening files - When initialized with a filepath, optional features used incorrect root path (Stefan Breunig) - HTTP - Fix sync for servers which don't return Content-Length in HEAD - Onedrive - Add QuickXorHash support for OneDrive for business - Fix socket leak in multipart session upload - S3 - Look in S3 named profile files for credentials - Add `--s3-disable-checksum` to disable checksum uploading (Chris Redekop) - Hierarchical configuration support (Giri Badanahatti) - Add in config for all the supported S3 providers - Add One Zone Infrequent Access storage class (Craig Rachel) - Add --use-server-modtime support (Peter Baumgartner) - Add --s3-chunk-size option to control multipart uploads - Ignore zero length directory markers - SFTP - Update docs to match code, fix typos and clarify disable_hashcheck prompt (Michael G. Noll) - Update docs with Synology quirks - Fail soft with a debug on hash failure - Swift - Add --use-server-modtime support (Peter Baumgartner) - Webdav - Support SharePoint cookie authentication (hensur) - Strip leading and trailing / off root ## v1.40 - 2018-03-19 - New backends - Alias backend to create aliases for existing remote names (Fabian Möller) - New commands - `lsf`: list for parsing purposes (Jakub Tasiemski) - by default this is a simple non recursive list of files and directories - it can be configured to add more info in an easy to parse way - `serve restic`: for serving a remote as a Restic REST endpoint - This enables restic to use any backends that rclone can access - Thanks Alexander Neumann for help, patches and review - `rc`: enable the remote control of a running rclone - The running rclone must be started with --rc and related flags. - Currently there is support for bwlimit, and flushing for mount and cache. - New Features - `--max-delete` flag to add a delete threshold (Bjørn Erik Pedersen) - All backends now support RangeOption for ranged Open - `cat`: Use RangeOption for limited fetches to make more efficient - `cryptcheck`: make reading of nonce more efficient with RangeOption - serve http/webdav/restic - support SSL/TLS - add `--user` `--pass` and `--htpasswd` for authentication - `copy`/`move`: detect file size change during copy/move and abort transfer (ishuah) - `cryptdecode`: added option to return encrypted file names. (ishuah) - `lsjson`: add `--encrypted` to show encrypted name (Jakub Tasiemski) - Add `--stats-file-name-length` to specify the printed file name length for stats (Will Gunn) - Compile - Code base was shuffled and factored - backends moved into a backend directory - large packages split up - See the CONTRIBUTING.md doc for info as to what lives where now - Update to using go1.10 as the default go version - Implement daily [full integration tests](https://pub.rclone.org/integration-tests/) - Release - Include a source tarball and sign it and the binaries - Sign the git tags as part of the release process - Add .deb and .rpm packages as part of the build - Make a beta release for all branches on the main repo (but not pull requests) - Bug Fixes - config: fixes errors on nonexistent config by loading config file only on first access - config: retry saving the config after failure (Mateusz) - sync: when using `--backup-dir` don't delete files if we can't set their modtime - this fixes odd behaviour with Dropbox and `--backup-dir` - fshttp: fix idle timeouts for HTTP connections - `serve http`: fix serving files with : in - fixes - Fix `--exclude-if-present` to ignore directories which it doesn't have permission for (Iakov Davydov) - Make accounting work properly with crypt and b2 - remove `--no-traverse` flag because it is obsolete - Mount - Add `--attr-timeout` flag to control attribute caching in kernel - this now defaults to 0 which is correct but less efficient - see [the mount docs](https://rclone.org/commands/rclone_mount/#attribute-caching) for more info - Add `--daemon` flag to allow mount to run in the background (ishuah) - Fix: Return ENOSYS rather than EIO on attempted link - This fixes FileZilla accessing an rclone mount served over sftp. - Fix setting modtime twice - Mount tests now run on CI for Linux (mount & cmount)/Mac/Windows - Many bugs fixed in the VFS layer - see below - VFS - Many fixes for `--vfs-cache-mode` writes and above - Update cached copy if we know it has changed (fixes stale data) - Clean path names before using them in the cache - Disable cache cleaner if `--vfs-cache-poll-interval=0` - Fill and clean the cache immediately on startup - Fix Windows opening every file when it stats the file - Fix applying modtime for an open Write Handle - Fix creation of files when truncating - Write 0 bytes when flushing unwritten handles to avoid race conditions in FUSE - Downgrade "poll-interval is not supported" message to Info - Make OpenFile and friends return EINVAL if O_RDONLY and O_TRUNC - Local - Downgrade "invalid cross-device link: trying copy" to debug - Make DirMove return fs.ErrorCantDirMove to allow fallback to Copy for cross device - Fix race conditions updating the hashes - Cache - Add support for polling - cache will update when remote changes on supported backends - Reduce log level for Plex api - Fix dir cache issue - Implement `--cache-db-wait-time` flag - Improve efficiency with RangeOption and RangeSeek - Fix dirmove with temp fs enabled - Notify vfs when using temp fs - Offline uploading - Remote control support for path flushing - Amazon cloud drive - Rclone no longer has any working keys - disable integration tests - Implement DirChangeNotify to notify cache/vfs/mount of changes - Azureblob - Don't check for bucket/container presence if listing was OK - this makes rclone do one less request per invocation - Improve accounting for chunked uploads - Backblaze B2 - Don't check for bucket/container presence if listing was OK - this makes rclone do one less request per invocation - Box - Improve accounting for chunked uploads - Dropbox - Fix custom oauth client parameters - Google Cloud Storage - Don't check for bucket/container presence if listing was OK - this makes rclone do one less request per invocation - Google Drive - Migrate to api v3 (Fabian Möller) - Add scope configuration and root folder selection - Add `--drive-impersonate` for service accounts - thanks to everyone who tested, explored and contributed docs - Add `--drive-use-created-date` to use created date as modified date (nbuchanan) - Request the export formats only when required - This makes rclone quicker when there are no google docs - Fix finding paths with latin1 chars (a workaround for a drive bug) - Fix copying of a single Google doc file - Fix `--drive-auth-owner-only` to look in all directories - HTTP - Fix handling of directories with & in - Onedrive - Removed upload cutoff and always do session uploads - this stops the creation of multiple versions on business onedrive - Overwrite object size value with real size when reading file. (Victor) - this fixes oddities when onedrive misreports the size of images - Pcloud - Remove unused chunked upload flag and code - Qingstor - Don't check for bucket/container presence if listing was OK - this makes rclone do one less request per invocation - S3 - Support hashes for multipart files (Chris Redekop) - Initial support for IBM COS (S3) (Giri Badanahatti) - Update docs to discourage use of v2 auth with CEPH and others - Don't check for bucket/container presence if listing was OK - this makes rclone do one less request per invocation - Fix server-side copy and set modtime on files with + in - SFTP - Add option to disable remote hash check command execution (Jon Fautley) - Add `--sftp-ask-password` flag to prompt for password when needed (Leo R. Lundgren) - Add `set_modtime` configuration option - Fix following of symlinks - Fix reading config file outside of Fs setup - Fix reading $USER in username fallback not $HOME - Fix running under crontab - Use correct OS way of reading username - Swift - Fix refresh of authentication token - in v1.39 a bug was introduced which ignored new tokens - this fixes it - Fix extra HEAD transaction when uploading a new file - Don't check for bucket/container presence if listing was OK - this makes rclone do one less request per invocation - Webdav - Add new time formats to support mydrive.ch and others ## v1.39 - 2017-12-23 - New backends - WebDAV - tested with nextcloud, owncloud, put.io and others! - Pcloud - cache - wraps a cache around other backends (Remus Bunduc) - useful in combination with mount - NB this feature is in beta so use with care - New commands - serve command with subcommands: - serve webdav: this implements a webdav server for any rclone remote. - serve http: command to serve a remote over HTTP - config: add sub commands for full config file management - create/delete/dump/edit/file/password/providers/show/update - touch: to create or update the timestamp of a file (Jakub Tasiemski) - New Features - curl install for rclone (Filip Bartodziej) - --stats now shows percentage, size, rate and ETA in condensed form (Ishuah Kariuki) - --exclude-if-present to exclude a directory if a file is present (Iakov Davydov) - rmdirs: add --leave-root flag (lewapm) - move: add --delete-empty-src-dirs flag to remove dirs after move (Ishuah Kariuki) - Add --dump flag, introduce --dump requests, responses and remove --dump-auth, --dump-filters - Obscure X-Auth-Token: from headers when dumping too - Document and implement exit codes for different failure modes (Ishuah Kariuki) - Compile - Bug Fixes - Retry lots more different types of errors to make multipart transfers more reliable - Save the config before asking for a token, fixes disappearing oauth config - Warn the user if --include and --exclude are used together (Ernest Borowski) - Fix duplicate files (e.g. on Google drive) causing spurious copies - Allow trailing and leading whitespace for passwords (Jason Rose) - ncdu: fix crashes on empty directories - rcat: fix goroutine leak - moveto/copyto: Fix to allow copying to the same name - Mount - --vfs-cache mode to make writes into mounts more reliable. - this requires caching files on the disk (see --cache-dir) - As this is a new feature, use with care - Use sdnotify to signal systemd the mount is ready (Fabian Möller) - Check if directory is not empty before mounting (Ernest Borowski) - Local - Add error message for cross file system moves - Fix equality check for times - Dropbox - Rework multipart upload - buffer the chunks when uploading large files so they can be retried - change default chunk size to 48MB now we are buffering them in memory - retry every error after the first chunk is done successfully - Fix error when renaming directories - Swift - Fix crash on bad authentication - Google Drive - Add service account support (Tim Cooijmans) - S3 - Make it work properly with Digital Ocean Spaces (Andrew Starr-Bochicchio) - Fix crash if a bad listing is received - Add support for ECS task IAM roles (David Minor) - Backblaze B2 - Fix multipart upload retries - Fix --hard-delete to make it work 100% of the time - Swift - Allow authentication with storage URL and auth key (Giovanni Pizzi) - Add new fields for swift configuration to support IBM Bluemix Swift (Pierre Carlson) - Add OS_TENANT_ID and OS_USER_ID to config - Allow configs with user id instead of user name - Check if swift segments container exists before creating (John Leach) - Fix memory leak in swift transfers (upstream fix) - SFTP - Add option to enable the use of aes128-cbc cipher (Jon Fautley) - Amazon cloud drive - Fix download of large files failing with "Only one auth mechanism allowed" - crypt - Option to encrypt directory names or leave them intact - Implement DirChangeNotify (Fabian Möller) - onedrive - Add option to choose resourceURL during setup of OneDrive Business account if more than one is available for user ## v1.38 - 2017-09-30 - New backends - Azure Blob Storage (thanks Andrei Dragomir) - Box - Onedrive for Business (thanks Oliver Heyme) - QingStor from QingCloud (thanks wuyu) - New commands - `rcat` - read from standard input and stream upload - `tree` - shows a nicely formatted recursive listing - `cryptdecode` - decode encrypted file names (thanks ishuah) - `config show` - print the config file - `config file` - print the config file location - New Features - Empty directories are deleted on `sync` - `dedupe` - implement merging of duplicate directories - `check` and `cryptcheck` made more consistent and use less memory - `cleanup` for remaining remotes (thanks ishuah) - `--immutable` for ensuring that files don't change (thanks Jacob McNamee) - `--user-agent` option (thanks Alex McGrath Kraak) - `--disable` flag to disable optional features - `--bind` flag for choosing the local addr on outgoing connections - Support for zsh auto-completion (thanks bpicode) - Stop normalizing file names but do a normalized compare in `sync` - Compile - Update to using go1.9 as the default go version - Remove snapd build due to maintenance problems - Bug Fixes - Improve retriable error detection which makes multipart uploads better - Make `check` obey `--ignore-size` - Fix bwlimit toggle in conjunction with schedules (thanks cbruegg) - `config` ensures newly written config is on the same mount - Local - Revert to copy when moving file across file system boundaries - `--skip-links` to suppress symlink warnings (thanks Zhiming Wang) - Mount - Reuse `rcat` internals to support uploads from all remotes - Dropbox - Fix "entry doesn't belong in directory" error - Stop using deprecated API methods - Swift - Fix server-side copy to empty container with `--fast-list` - Google Drive - Change the default for `--drive-use-trash` to `true` - S3 - Set session token when using STS (thanks Girish Ramakrishnan) - Glacier docs and error messages (thanks Jan Varho) - Read 1000 (not 1024) items in dir listings to fix Wasabi - Backblaze B2 - Fix SHA1 mismatch when downloading files with no SHA1 - Calculate missing hashes on the fly instead of spooling - `--b2-hard-delete` to permanently delete (not hide) files (thanks John Papandriopoulos) - Hubic - Fix creating containers - no longer have to use the `default` container - Swift - Optionally configure from a standard set of OpenStack environment vars - Add `endpoint_type` config - Google Cloud Storage - Fix bucket creation to work with limited permission users - SFTP - Implement connection pooling for multiple ssh connections - Limit new connections per second - Add support for MD5 and SHA1 hashes where available (thanks Christian Brüggemann) - HTTP - Fix URL encoding issues - Fix directories with `:` in - Fix panic with URL encoded content ## v1.37 - 2017-07-22 - New backends - FTP - thanks to Antonio Messina - HTTP - thanks to Vasiliy Tolstov - New commands - rclone ncdu - for exploring a remote with a text based user interface. - rclone lsjson - for listing with a machine-readable output - rclone dbhashsum - to show Dropbox style hashes of files (local or Dropbox) - New Features - Implement --fast-list flag - This allows remotes to list recursively if they can - This uses less transactions (important if you pay for them) - This may or may not be quicker - This will use more memory as it has to hold the listing in memory - --old-sync-method deprecated - the remaining uses are covered by --fast-list - This involved a major re-write of all the listing code - Add --tpslimit and --tpslimit-burst to limit transactions per second - this is useful in conjunction with `rclone mount` to limit external apps - Add --stats-log-level so can see --stats without -v - Print password prompts to stderr - Hraban Luyat - Warn about duplicate files when syncing - Oauth improvements - allow auth_url and token_url to be set in the config file - Print redirection URI if using own credentials. - Don't Mkdir at the start of sync to save transactions - Compile - Update build to go1.8.3 - Require go1.6 for building rclone - Compile 386 builds with "GO386=387" for maximum compatibility - Bug Fixes - Fix menu selection when no remotes - Config saving reworked to not kill the file if disk gets full - Don't delete remote if name does not change while renaming - moveto, copyto: report transfers and checks as per move and copy - Local - Add --local-no-unicode-normalization flag - Bob Potter - Mount - Now supported on Windows using cgofuse and WinFsp - thanks to Bill Zissimopoulos for much help - Compare checksums on upload/download via FUSE - Unmount when program ends with SIGINT (Ctrl+C) or SIGTERM - Jérôme Vizcaino - On read only open of file, make open pending until first read - Make --read-only reject modify operations - Implement ModTime via FUSE for remotes that support it - Allow modTime to be changed even before all writers are closed - Fix panic on renames - Fix hang on errored upload - Crypt - Report the name:root as specified by the user - Add an "obfuscate" option for filename encryption - Stephen Harris - Amazon Drive - Fix initialization order for token renewer - Remove revoked credentials, allow oauth proxy config and update docs - B2 - Reduce minimum chunk size to 5MB - Drive - Add team drive support - Reduce bandwidth by adding fields for partial responses - Martin Kristensen - Implement --drive-shared-with-me flag to view shared with me files - Danny Tsai - Add --drive-trashed-only to read only the files in the trash - Remove obsolete --drive-full-list - Add missing seek to start on retries of chunked uploads - Fix stats accounting for upload - Convert / in names to a unicode equivalent (／) - Poll for Google Drive changes when mounted - OneDrive - Fix the uploading of files with spaces - Fix initialization order for token renewer - Display speeds accurately when uploading - Yoni Jah - Swap to using `http://localhost:53682/` as redirect URL - Michael Ledin - Retry on token expired error, reset upload body on retry - Yoni Jah - Google Cloud Storage - Add ability to specify location and storage class via config and command line - thanks gdm85 - Create container if necessary on server-side copy - Increase directory listing chunk to 1000 to increase performance - Obtain a refresh token for GCS - Steven Lu - Yandex - Fix the name reported in log messages (was empty) - Correct error return for listing empty directory - Dropbox - Rewritten to use the v2 API - Now supports ModTime - Can only set by uploading the file again - If you uploaded with an old rclone, rclone may upload everything again - Use `--size-only` or `--checksum` to avoid this - Now supports the Dropbox content hashing scheme - Now supports low level retries - S3 - Work around eventual consistency in bucket creation - Create container if necessary on server-side copy - Add us-east-2 (Ohio) and eu-west-2 (London) S3 regions - Zahiar Ahmed - Swift, Hubic - Fix zero length directory markers showing in the subdirectory listing - this caused lots of duplicate transfers - Fix paged directory listings - this caused duplicate directory errors - Create container if necessary on server-side copy - Increase directory listing chunk to 1000 to increase performance - Make sensible error if the user forgets the container - SFTP - Add support for using ssh key files - Fix under Windows - Fix ssh agent on Windows - Adapt to latest version of library - Igor Kharin ## v1.36 - 2017-03-18 - New Features - SFTP remote (Jack Schmidt) - Re-implement sync routine to work a directory at a time reducing memory usage - Logging revamped to be more inline with rsync - now much quieter - -v only shows transfers - -vv is for full debug - --syslog to log to syslog on capable platforms - Implement --backup-dir and --suffix - Implement --track-renames (initial implementation by Bjørn Erik Pedersen) - Add time-based bandwidth limits (Lukas Loesche) - rclone cryptcheck: checks integrity of crypt remotes - Allow all config file variables and options to be set from environment variables - Add --buffer-size parameter to control buffer size for copy - Make --delete-after the default - Add --ignore-checksum flag (fixed by Hisham Zarka) - rclone check: Add --download flag to check all the data, not just hashes - rclone cat: add --head, --tail, --offset, --count and --discard - rclone config: when choosing from a list, allow the value to be entered too - rclone config: allow rename and copy of remotes - rclone obscure: for generating encrypted passwords for rclone's config (T.C. Ferguson) - Comply with XDG Base Directory specification (Dario Giovannetti) - this moves the default location of the config file in a backwards compatible way - Release changes - Ubuntu snap support (Dedsec1) - Compile with go 1.8 - MIPS/Linux big and little endian support - Bug Fixes - Fix copyto copying things to the wrong place if the destination dir didn't exist - Fix parsing of remotes in moveto and copyto - Fix --delete-before deleting files on copy - Fix --files-from with an empty file copying everything - Fix sync: don't update mod times if --dry-run set - Fix MimeType propagation - Fix filters to add ** rules to directory rules - Local - Implement -L, --copy-links flag to allow rclone to follow symlinks - Open files in write only mode so rclone can write to an rclone mount - Fix unnormalised unicode causing problems reading directories - Fix interaction between -x flag and --max-depth - Mount - Implement proper directory handling (mkdir, rmdir, renaming) - Make include and exclude filters apply to mount - Implement read and write async buffers - control with --buffer-size - Fix fsync on for directories - Fix retry on network failure when reading off crypt - Crypt - Add --crypt-show-mapping to show encrypted file mapping - Fix crypt writer getting stuck in a loop - **IMPORTANT** this bug had the potential to cause data corruption when - reading data from a network based remote and - writing to a crypt on Google Drive - Use the cryptcheck command to validate your data if you are concerned - If syncing two crypt remotes, sync the unencrypted remote - Amazon Drive - Fix panics on Move (rename) - Fix panic on token expiry - B2 - Fix inconsistent listings and rclone check - Fix uploading empty files with go1.8 - Constrain memory usage when doing multipart uploads - Fix upload url not being refreshed properly - Drive - Fix Rmdir on directories with trashed files - Fix "Ignoring unknown object" when downloading - Add --drive-list-chunk - Add --drive-skip-gdocs (Károly Oláh) - OneDrive - Implement Move - Fix Copy - Fix overwrite detection in Copy - Fix waitForJob to parse errors correctly - Use token renewer to stop auth errors on long uploads - Fix uploading empty files with go1.8 - Google Cloud Storage - Fix depth 1 directory listings - Yandex - Fix single level directory listing - Dropbox - Normalise the case for single level directory listings - Fix depth 1 listing - S3 - Added ca-central-1 region (Jon Yergatian) ## v1.35 - 2017-01-02 - New Features - moveto and copyto commands for choosing a destination name on copy/move - rmdirs command to recursively delete empty directories - Allow repeated --include/--exclude/--filter options - Only show transfer stats on commands which transfer stuff - show stats on any command using the `--stats` flag - Allow overlapping directories in move when server-side dir move is supported - Add --stats-unit option - thanks Scott McGillivray - Bug Fixes - Fix the config file being overwritten when two rclone instances are running - Make rclone lsd obey the filters properly - Fix compilation on mips - Fix not transferring files that don't differ in size - Fix panic on nil retry/fatal error - Mount - Retry reads on error - should help with reliability a lot - Report the modification times for directories from the remote - Add bandwidth accounting and limiting (fixes --bwlimit) - If --stats provided will show stats and which files are transferring - Support R/W files if truncate is set. - Implement statfs interface so df works - Note that write is now supported on Amazon Drive - Report number of blocks in a file - thanks Stefan Breunig - Crypt - Prevent the user pointing crypt at itself - Fix failed to authenticate decrypted block errors - these will now return the underlying unexpected EOF instead - Amazon Drive - Add support for server-side move and directory move - thanks Stefan Breunig - Fix nil pointer deref on size attribute - B2 - Use new prefix and delimiter parameters in directory listings - This makes --max-depth 1 dir listings as used in mount much faster - Reauth the account while doing uploads too - should help with token expiry - Drive - Make DirMove more efficient and complain about moving the root - Create destination directory on Move() ## v1.34 - 2016-11-06 - New Features - Stop single file and `--files-from` operations iterating through the source bucket. - Stop removing failed upload to cloud storage remotes - Make ContentType be preserved for cloud to cloud copies - Add support to toggle bandwidth limits via SIGUSR2 - thanks Marco Paganini - `rclone check` shows count of hashes that couldn't be checked - `rclone listremotes` command - Support linux/arm64 build - thanks Fredrik Fornwall - Remove `Authorization:` lines from `--dump-headers` output - Bug Fixes - Ignore files with control characters in the names - Fix `rclone move` command - Delete src files which already existed in dst - Fix deletion of src file when dst file older - Fix `rclone check` on encrypted file systems - Make failed uploads not count as "Transferred" - Make sure high level retries show with `-q` - Use a vendor directory with godep for repeatable builds - `rclone mount` - FUSE - Implement FUSE mount options - `--no-modtime`, `--debug-fuse`, `--read-only`, `--allow-non-empty`, `--allow-root`, `--allow-other` - `--default-permissions`, `--write-back-cache`, `--max-read-ahead`, `--umask`, `--uid`, `--gid` - Add `--dir-cache-time` to control caching of directory entries - Implement seek for files opened for read (useful for video players) - with `-no-seek` flag to disable - Fix crash on 32 bit ARM (alignment of 64 bit counter) - ...and many more internal fixes and improvements! - Crypt - Don't show encrypted password in configurator to stop confusion - Amazon Drive - New wait for upload option `--acd-upload-wait-per-gb` - upload timeouts scale by file size and can be disabled - Add 502 Bad Gateway to list of errors we retry - Fix overwriting a file with a zero length file - Fix ACD file size warning limit - thanks Felix Bünemann - Local - Unix: implement `-x`/`--one-file-system` to stay on a single file system - thanks Durval Menezes and Luiz Carlos Rumbelsperger Viana - Windows: ignore the symlink bit on files - Windows: Ignore directory-based junction points - B2 - Make sure each upload has at least one upload slot - fixes strange upload stats - Fix uploads when using crypt - Fix download of large files (sha1 mismatch) - Return error when we try to create a bucket which someone else owns - Update B2 docs with Data usage, and Crypt section - thanks Tomasz Mazur - S3 - Command line and config file support for - Setting/overriding ACL - thanks Radek Šenfeld - Setting storage class - thanks Asko Tamm - Drive - Make exponential backoff work exactly as per Google specification - add `.epub`, `.odp` and `.tsv` as export formats. - Swift - Don't read metadata for directory marker objects ## v1.33 - 2016-08-24 - New Features - Implement encryption - data encrypted in NACL secretbox format - with optional file name encryption - New commands - rclone mount - implements FUSE mounting of remotes (EXPERIMENTAL) - works on Linux, FreeBSD and OS X (need testers for the last 2!) - rclone cat - outputs remote file or files to the terminal - rclone genautocomplete - command to make a bash completion script for rclone - Editing a remote using `rclone config` now goes through the wizard - Compile with go 1.7 - this fixes rclone on macOS Sierra and on 386 processors - Use cobra for sub commands and docs generation - drive - Document how to make your own client_id - s3 - User-configurable Amazon S3 ACL (thanks Radek Šenfeld) - b2 - Fix stats accounting for upload - no more jumping to 100% done - On cleanup delete hide marker if it is the current file - New B2 API endpoint (thanks Per Cederberg) - Set maximum backoff to 5 Minutes - onedrive - Fix URL escaping in file names - e.g. uploading files with `+` in them. - amazon cloud drive - Fix token expiry during large uploads - Work around 408 REQUEST_TIMEOUT and 504 GATEWAY_TIMEOUT errors - local - Fix filenames with invalid UTF-8 not being uploaded - Fix problem with some UTF-8 characters on OS X ## v1.32 - 2016-07-13 - Backblaze B2 - Fix upload of files large files not in root ## v1.31 - 2016-07-13 - New Features - Reduce memory on sync by about 50% - Implement --no-traverse flag to stop copy traversing the destination remote. - This can be used to reduce memory usage down to the smallest possible. - Useful to copy a small number of files into a large destination folder. - Implement cleanup command for emptying trash / removing old versions of files - Currently B2 only - Single file handling improved - Now copied with --files-from - Automatically sets --no-traverse when copying a single file - Info on using installing with ansible - thanks Stefan Weichinger - Implement --no-update-modtime flag to stop rclone fixing the remote modified times. - Bug Fixes - Fix move command - stop it running for overlapping Fses - this was causing data loss. - Local - Fix incomplete hashes - this was causing problems for B2. - Amazon Drive - Rename Amazon Cloud Drive to Amazon Drive - no changes to config file needed. - Swift - Add support for non-default project domain - thanks Antonio Messina. - S3 - Add instructions on how to use rclone with minio. - Add ap-northeast-2 (Seoul) and ap-south-1 (Mumbai) regions. - Skip setting the modified time for objects > 5GB as it isn't possible. - Backblaze B2 - Add --b2-versions flag so old versions can be listed and retrieved. - Treat 403 errors (e.g. cap exceeded) as fatal. - Implement cleanup command for deleting old file versions. - Make error handling compliant with B2 integrations notes. - Fix handling of token expiry. - Implement --b2-test-mode to set `X-Bz-Test-Mode` header. - Set cutoff for chunked upload to 200MB as per B2 guidelines. - Make upload multi-threaded. - Dropbox - Don't retry 461 errors. ## v1.30 - 2016-06-18 - New Features - Directory listing code reworked for more features and better error reporting (thanks to Klaus Post for help). This enables - Directory include filtering for efficiency - --max-depth parameter - Better error reporting - More to come - Retry more errors - Add --ignore-size flag - for uploading images to onedrive - Log -v output to stdout by default - Display the transfer stats in more human-readable form - Make 0 size files specifiable with `--max-size 0b` - Add `b` suffix so we can specify bytes in --bwlimit, --min-size, etc. - Use "password:" instead of "password>" prompt - thanks Klaus Post and Leigh Klotz - Bug Fixes - Fix retry doing one too many retries - Local - Fix problems with OS X and UTF-8 characters - Amazon Drive - Check a file exists before uploading to help with 408 Conflict errors - Reauth on 401 errors - this has been causing a lot of problems - Work around spurious 403 errors - Restart directory listings on error - Google Drive - Check a file exists before uploading to help with duplicates - Fix retry of multipart uploads - Backblaze B2 - Implement large file uploading - S3 - Add AES256 server-side encryption for - thanks Justin R. Wilson - Google Cloud Storage - Make sure we don't use conflicting content types on upload - Add service account support - thanks Michal Witkowski - Swift - Add auth version parameter - Add domain option for openstack (v3 auth) - thanks Fabian Ruff ## v1.29 - 2016-04-18 - New Features - Implement `-I, --ignore-times` for unconditional upload - Improve `dedupe`command - Now removes identical copies without asking - Now obeys `--dry-run` - Implement `--dedupe-mode` for non interactive running - `--dedupe-mode interactive` - interactive the default. - `--dedupe-mode skip` - removes identical files then skips anything left. - `--dedupe-mode first` - removes identical files then keeps the first one. - `--dedupe-mode newest` - removes identical files then keeps the newest one. - `--dedupe-mode oldest` - removes identical files then keeps the oldest one. - `--dedupe-mode rename` - removes identical files then renames the rest to be different. - Bug fixes - Make rclone check obey the `--size-only` flag. - Use "application/octet-stream" if discovered mime type is invalid. - Fix missing "quit" option when there are no remotes. - Google Drive - Increase default chunk size to 8 MB - increases upload speed of big files - Speed up directory listings and make more reliable - Add missing retries for Move and DirMove - increases reliability - Preserve mime type on file update - Backblaze B2 - Enable mod time syncing - This means that B2 will now check modification times - It will upload new files to update the modification times - (there isn't an API to just set the mod time.) - If you want the old behaviour use `--size-only`. - Update API to new version - Fix parsing of mod time when not in metadata - Swift/Hubic - Don't return an MD5SUM for static large objects - S3 - Fix uploading files bigger than 50GB ## v1.28 - 2016-03-01 - New Features - Configuration file encryption - thanks Klaus Post - Improve `rclone config` adding more help and making it easier to understand - Implement `-u`/`--update` so creation times can be used on all remotes - Implement `--low-level-retries` flag - Optionally disable gzip compression on downloads with `--no-gzip-encoding` - Bug fixes - Don't make directories if `--dry-run` set - Fix and document the `move` command - Fix redirecting stderr on unix-like OSes when using `--log-file` - Fix `delete` command to wait until all finished - fixes missing deletes. - Backblaze B2 - Use one upload URL per go routine fixes `more than one upload using auth token` - Add pacing, retries and reauthentication - fixes token expiry problems - Upload without using a temporary file from local (and remotes which support SHA1) - Fix reading metadata for all files when it shouldn't have been - Drive - Fix listing drive documents at root - Disable copy and move for Google docs - Swift - Fix uploading of chunked files with non ASCII characters - Allow setting of `storage_url` in the config - thanks Xavier Lucas - S3 - Allow IAM role and credentials from environment variables - thanks Brian Stengaard - Allow low privilege users to use S3 (check if directory exists during Mkdir) - thanks Jakub Gedeon - Amazon Drive - Retry on more things to make directory listings more reliable ## v1.27 - 2016-01-31 - New Features - Easier headless configuration with `rclone authorize` - Add support for multiple hash types - we now check SHA1 as well as MD5 hashes. - `delete` command which does obey the filters (unlike `purge`) - `dedupe` command to deduplicate a remote. Useful with Google Drive. - Add `--ignore-existing` flag to skip all files that exist on destination. - Add `--delete-before`, `--delete-during`, `--delete-after` flags. - Add `--memprofile` flag to debug memory use. - Warn the user about files with same name but different case - Make `--include` rules add their implicit exclude `*` at the end of the filter list - Deprecate compiling with go1.3 - Amazon Drive - Fix download of files > 10 GB - Fix directory traversal ("Next token is expired") for large directory listings - Remove 409 conflict from error codes we will retry - stops very long pauses - Backblaze B2 - SHA1 hashes now checked by rclone core - Drive - Add `--drive-auth-owner-only` to only consider files owned by the user - thanks Björn Harrtell - Export Google documents - Dropbox - Make file exclusion error controllable with -q - Swift - Fix upload from unprivileged user. - S3 - Fix updating of mod times of files with `+` in. - Local - Add local file system option to disable UNC on Windows. ## v1.26 - 2016-01-02 - New Features - Yandex storage backend - thank you Dmitry Burdeev ("dibu") - Implement Backblaze B2 storage backend - Add --min-age and --max-age flags - thank you Adriano Aurélio Meirelles - Make ls/lsl/md5sum/size/check obey includes and excludes - Fixes - Fix crash in http logging - Upload releases to github too - Swift - Fix sync for chunked files - OneDrive - Re-enable server-side copy - Don't mask HTTP error codes with JSON decode error - S3 - Fix corrupting Content-Type on mod time update (thanks Joseph Spurrier) ## v1.25 - 2015-11-14 - New features - Implement Hubic storage system - Fixes - Fix deletion of some excluded files without --delete-excluded - This could have deleted files unexpectedly on sync - Always check first with `--dry-run`! - Swift - Stop SetModTime losing metadata (e.g. X-Object-Manifest) - This could have caused data loss for files > 5GB in size - Use ContentType from Object to avoid lookups in listings - OneDrive - disable server-side copy as it seems to be broken at Microsoft ## v1.24 - 2015-11-07 - New features - Add support for Microsoft OneDrive - Add `--no-check-certificate` option to disable server certificate verification - Add async readahead buffer for faster transfer of big files - Fixes - Allow spaces in remotes and check remote names for validity at creation time - Allow '&' and disallow ':' in Windows filenames. - Swift - Ignore directory marker objects where appropriate - allows working with Hubic - Don't delete the container if fs wasn't at root - S3 - Don't delete the bucket if fs wasn't at root - Google Cloud Storage - Don't delete the bucket if fs wasn't at root ## v1.23 - 2015-10-03 - New features - Implement `rclone size` for measuring remotes - Fixes - Fix headless config for drive and gcs - Tell the user they should try again if the webserver method failed - Improve output of `--dump-headers` - S3 - Allow anonymous access to public buckets - Swift - Stop chunked operations logging "Failed to read info: Object Not Found" - Use Content-Length on uploads for extra reliability ## v1.22 - 2015-09-28 - Implement rsync like include and exclude flags - swift - Support files > 5GB - thanks Sergey Tolmachev ## v1.21 - 2015-09-22 - New features - Display individual transfer progress - Make lsl output times in localtime - Fixes - Fix allowing user to override credentials again in Drive, GCS and ACD - Amazon Drive - Implement compliant pacing scheme - Google Drive - Make directory reads concurrent for increased speed. ## v1.20 - 2015-09-15 - New features - Amazon Drive support - Oauth support redone - fix many bugs and improve usability - Use "golang.org/x/oauth2" as oauth library of choice - Improve oauth usability for smoother initial signup - drive, googlecloudstorage: optionally use auto config for the oauth token - Implement --dump-headers and --dump-bodies debug flags - Show multiple matched commands if abbreviation too short - Implement server-side move where possible - local - Always use UNC paths internally on Windows - fixes a lot of bugs - dropbox - force use of our custom transport which makes timeouts work - Thanks to Klaus Post for lots of help with this release ## v1.19 - 2015-08-28 - New features - Server side copies for s3/swift/drive/dropbox/gcs - Move command - uses server-side copies if it can - Implement --retries flag - tries 3 times by default - Build for plan9/amd64 and solaris/amd64 too - Fixes - Make a current version download with a fixed URL for scripting - Ignore rmdir in limited fs rather than throwing error - dropbox - Increase chunk size to improve upload speeds massively - Issue an error message when trying to upload bad file name ## v1.18 - 2015-08-17 - drive - Add `--drive-use-trash` flag so rclone trashes instead of deletes - Add "Forbidden to download" message for files with no downloadURL - dropbox - Remove datastore - This was deprecated and it caused a lot of problems - Modification times and MD5SUMs no longer stored - Fix uploading files > 2GB - s3 - use official AWS SDK from github.com/aws/aws-sdk-go - **NB** will most likely require you to delete and recreate remote - enable multipart upload which enables files > 5GB - tested with Ceph / RadosGW / S3 emulation - many thanks to Sam Liston and Brian Haymore at the [Utah Center for High Performance Computing](https://www.chpc.utah.edu/) for a Ceph test account - misc - Show errors when reading the config file - Do not print stats in quiet mode - thanks Leonid Shalupov - Add FAQ - Fix created directories not obeying umask - Linux installation instructions - thanks Shimon Doodkin ## v1.17 - 2015-06-14 - dropbox: fix case insensitivity issues - thanks Leonid Shalupov ## v1.16 - 2015-06-09 - Fix uploading big files which was causing timeouts or panics - Don't check md5sum after download with --size-only ## v1.15 - 2015-06-06 - Add --checksum flag to only discard transfers by MD5SUM - thanks Alex Couper - Implement --size-only flag to sync on size not checksum & modtime - Expand docs and remove duplicated information - Document rclone's limitations with directories - dropbox: update docs about case insensitivity ## v1.14 - 2015-05-21 - local: fix encoding of non utf-8 file names - fixes a duplicate file problem - drive: docs about rate limiting - google cloud storage: Fix compile after API change in "google.golang.org/api/storage/v1" ## v1.13 - 2015-05-10 - Revise documentation (especially sync) - Implement --timeout and --conntimeout - s3: ignore etags from multipart uploads which aren't md5sums ## v1.12 - 2015-03-15 - drive: Use chunked upload for files above a certain size - drive: add --drive-chunk-size and --drive-upload-cutoff parameters - drive: switch to insert from update when a failed copy deletes the upload - core: Log duplicate files if they are detected ## v1.11 - 2015-03-04 - swift: add region parameter - drive: fix crash on failed to update remote mtime - In remote paths, change native directory separators to / - Add synchronization to ls/lsl/lsd output to stop corruptions - Ensure all stats/log messages to go stderr - Add --log-file flag to log everything (including panics) to file - Make it possible to disable stats printing with --stats=0 - Implement --bwlimit to limit data transfer bandwidth ## v1.10 - 2015-02-12 - s3: list an unlimited number of items - Fix getting stuck in the configurator ## v1.09 - 2015-02-07 - windows: Stop drive letters (e.g. C:) getting mixed up with remotes (e.g. drive:) - local: Fix directory separators on Windows - drive: fix rate limit exceeded errors ## v1.08 - 2015-02-04 - drive: fix subdirectory listing to not list entire drive - drive: Fix SetModTime - dropbox: adapt code to recent library changes ## v1.07 - 2014-12-23 - google cloud storage: fix memory leak ## v1.06 - 2014-12-12 - Fix "Couldn't find home directory" on OSX - swift: Add tenant parameter - Use new location of Google API packages ## v1.05 - 2014-08-09 - Improved tests and consequently lots of minor fixes - core: Fix race detected by go race detector - core: Fixes after running errcheck - drive: reset root directory on Rmdir and Purge - fs: Document that Purger returns error on empty directory, test and fix - google cloud storage: fix ListDir on subdirectory - google cloud storage: re-read metadata in SetModTime - s3: make reading metadata more reliable to work around eventual consistency problems - s3: strip trailing / from ListDir() - swift: return directories without / in ListDir ## v1.04 - 2014-07-21 - google cloud storage: Fix crash on Update ## v1.03 - 2014-07-20 - swift, s3, dropbox: fix updated files being marked as corrupted - Make compile with go 1.1 again ## v1.02 - 2014-07-19 - Implement Dropbox remote - Implement Google Cloud Storage remote - Verify Md5sums and Sizes after copies - Remove times from "ls" command - lists sizes only - Add add "lsl" - lists times and sizes - Add "md5sum" command ## v1.01 - 2014-07-04 - drive: fix transfer of big files using up lots of memory ## v1.00 - 2014-07-03 - drive: fix whole second dates ## v0.99 - 2014-06-26 - Fix --dry-run not working - Make compatible with go 1.1 ## v0.98 - 2014-05-30 - s3: Treat missing Content-Length as 0 for some ceph installations - rclonetest: add file with a space in ## v0.97 - 2014-05-05 - Implement copying of single files - s3 & swift: support paths inside containers/buckets ## v0.96 - 2014-04-24 - drive: Fix multiple files of same name being created - drive: Use o.Update and fs.Put to optimise transfers - Add version number, -V and --version ## v0.95 - 2014-03-28 - rclone.org: website, docs and graphics - drive: fix path parsing ## v0.94 - 2014-03-27 - Change remote format one last time - GNU style flags ## v0.93 - 2014-03-16 - drive: store token in config file - cross compile other versions - set strict permissions on config file ## v0.92 - 2014-03-15 - Config fixes and --config option ## v0.91 - 2014-03-15 - Make config file ## v0.90 - 2013-06-27 - Project named rclone ## v0.00 - 2012-11-18 - Project started # Bugs and Limitations ## Limitations ### Directory timestamps aren't preserved on some backends As of `v1.66`, rclone supports syncing directory modtimes, if the backend supports it. Some backends do not support it -- see [overview](https://rclone.org/overview/) for a complete list. Additionally, note that empty directories are not synced by default (this can be enabled with `--create-empty-src-dirs`.) ### Rclone struggles with millions of files in a directory/bucket Currently rclone loads each directory/bucket entirely into memory before using it. Since each rclone object takes 0.5k-1k of memory this can take a very long time and use a large amount of memory. Millions of files in a directory tends to occur on bucket-based remotes (e.g. S3 buckets) since those remotes do not segregate subdirectories within the bucket. ### Bucket-based remotes and folders Bucket-based remotes (e.g. S3/GCS/Swift/B2) do not have a concept of directories. Rclone therefore cannot create directories in them which means that empty directories on a bucket-based remote will tend to disappear. Some software creates empty keys ending in `/` as directory markers. Rclone doesn't do this as it potentially creates more objects and costs more. This ability may be added in the future (probably via a flag/option). ## Bugs Bugs are stored in rclone's GitHub project: - [Reported bugs](https://github.com/rclone/rclone/issues?q=is%3Aopen+is%3Aissue+label%3Abug) - [Known issues](https://github.com/rclone/rclone/issues?q=is%3Aopen+is%3Aissue+milestone%3A%22Known+Problem%22) # Frequently Asked Questions ### Do all cloud storage systems support all rclone commands Yes they do. All the rclone commands (e.g. `sync`, `copy`, etc.) will work on all the remote storage systems. ### Can I copy the config from one machine to another Sure! Rclone stores all of its config in a single file. If you want to find this file, run `rclone config file` which will tell you where it is. See the [remote setup docs](https://rclone.org/remote_setup/) for more info. ### How do I configure rclone on a remote / headless box with no browser? This has now been documented in its own [remote setup page](https://rclone.org/remote_setup/). ### How can I get rid of the "Config file not found" notice? If you see a notice like 'NOTICE: Config file "rclone.conf" not found', this means you have not configured any remotes. If you need to configure a remote, see the [config help docs](https://rclone.org/docs/#configure). If you are using rclone entirely with [on the fly remotes](https://rclone.org/docs/#backend-path-to-dir), you can create an empty config file to get rid of this notice, for example: ```sh rclone config touch ``` ### Can rclone sync directly from drive to s3 Rclone can sync between two remote cloud storage systems just fine. Note that it effectively downloads the file and uploads it again, so the node running rclone would need to have lots of bandwidth. The syncs would be incremental (on a file by file basis). e.g. ```sh rclone sync --interactive drive:Folder s3:bucket ``` ### Using rclone from multiple locations at the same time You can use rclone from multiple places at the same time if you choose different subdirectory for the output, e.g. ```sh Server A> rclone sync --interactive /tmp/whatever remote:ServerA Server B> rclone sync --interactive /tmp/whatever remote:ServerB ``` If you sync to the same directory then you should use rclone copy otherwise the two instances of rclone may delete each other's files, e.g. ```sh Server A> rclone copy /tmp/whatever remote:Backup Server B> rclone copy /tmp/whatever remote:Backup ``` The file names you upload from Server A and Server B should be different in this case, otherwise some file systems (e.g. Drive) may make duplicates. ### Why doesn't rclone support partial transfers / binary diffs like rsync? Rclone stores each file you transfer as a native object on the remote cloud storage system. This means that you can see the files you upload as expected using alternative access methods (e.g. using the Google Drive web interface). There is a 1:1 mapping between files on your hard disk and objects created in the cloud storage system. Cloud storage systems (at least none I've come across yet) don't support partially uploading an object. You can't take an existing object, and change some bytes in the middle of it. It would be possible to make a sync system which stored binary diffs like rsync does, instead of whole objects, but that would break the 1:1 mapping of files on your hard disk to objects in the remote cloud storage system. All the cloud storage systems support partial downloads of content, so it would be possible to make partial downloads work. However to make this work efficiently this would require storing a significant amount of metadata, which breaks the desired 1:1 mapping of files to objects. ### Can rclone do bi-directional sync? Yes, since rclone v1.58.0, [bidirectional cloud sync](https://rclone.org/bisync/) is available. ### Can I use rclone with an HTTP proxy? Yes. rclone will follow the standard environment variables for proxies, similar to cURL and other programs. In general the variables are called `http_proxy` (for services reached over `http`) and `https_proxy` (for services reached over `https`). Most public services will be using `https`, but you may wish to set both. The content of the variable is `protocol://server:port`. The protocol value is the one used to talk to the proxy server, itself, and is commonly either `http` or `socks5`. Slightly annoyingly, there is no *standard* for the name; some applications may use `http_proxy` but another one `HTTP_PROXY`. The `Go` libraries used by `rclone` will try both variations, but you may wish to set all possibilities. So, on Linux, you may end up with code similar to ```sh export http_proxy=http://proxyserver:12345 export https_proxy=$http_proxy export HTTP_PROXY=$http_proxy export HTTPS_PROXY=$http_proxy ``` Note: If the proxy server requires a username and password, then use ```sh export http_proxy=http://username:password@proxyserver:12345 export https_proxy=$http_proxy export HTTP_PROXY=$http_proxy export HTTPS_PROXY=$http_proxy ``` The `NO_PROXY` allows you to disable the proxy for specific hosts. Hosts must be comma separated, and can contain domains or parts. For instance "foo.com" also matches "bar.foo.com". e.g. ```sh export no_proxy=localhost,127.0.0.0/8,my.host.name export NO_PROXY=$no_proxy ``` Note that the FTP backend does not support `ftp_proxy` yet. You can use the command line argument `--http-proxy` to set the proxy, and in turn use an override in the config file if you want it set for a single backend, eg `override.http_proxy = http://...` in the config file. The FTP and SFTP backends have their own `http_proxy` settings to support an HTTP CONNECT proxy ( [--ftp-http-proxy](https://rclone.org/ftp/#ftp-http-proxy) and [--sftp-http-proxy](https://rclone.org/ftp/#sftp-http-proxy) ) ### Rclone gives x509 SSL root certificates error `x509: failed to load system roots and no roots provided` means that `rclone` can't find the SSL root certificates. Likely you are running `rclone` on a NAS with a cut-down Linux OS, or possibly on Solaris. `x509: certificate signed by unknown authority` error may occur on outdated systems, where `rclone` can't verify the server with the SSL root certificates. Rclone (via the Go runtime) tries to load the root certificates from these places on Linux. ```sh "/etc/ssl/certs/ca-certificates.crt", // Debian/Ubuntu/Gentoo etc. "/etc/pki/tls/certs/ca-bundle.crt", // Fedora/RHEL "/etc/ssl/ca-bundle.pem", // OpenSUSE "/etc/pki/tls/cacert.pem", // OpenELEC ``` So doing something like this should fix the problem. It also sets the time which is important for SSL to work properly. ```sh mkdir -p /etc/ssl/certs/ curl -o /etc/ssl/certs/ca-certificates.crt https://raw.githubusercontent.com/bagder/ca-bundle/master/ca-bundle.crt ntpclient -s -h pool.ntp.org ``` The two environment variables `SSL_CERT_FILE` and `SSL_CERT_DIR`, mentioned in the [x509 package](https://godoc.org/crypto/x509), provide an additional way to provide the SSL root certificates on Unix systems other than macOS. Note that you may need to add the `--insecure` option to the `curl` command line if it doesn't work without. ```sh curl --insecure -o /etc/ssl/certs/ca-certificates.crt https://raw.githubusercontent.com/bagder/ca-bundle/master/ca-bundle.crt ``` On macOS, you can install [ca-certificates](https://formulae.brew.sh/formula/ca-certificates) with Homebrew, and specify the SSL root certificates with the [--ca-cert](https://rclone.org/docs/#ca-cert-stringarray) flag. ```sh brew install ca-certificates find $(brew --prefix)/etc/ca-certificates -type f ``` ### Rclone gives Failed to load config file: function not implemented error Likely this means that you are running rclone on Linux version not supported by the go runtime, ie earlier than version 2.6.23. See the [system requirements section in the go install docs](https://golang.org/doc/install) for full details. ### All my uploaded docx/xlsx/pptx files appear as archive/zip This is caused by uploading these files from a Windows computer which hasn't got the Microsoft Office suite installed. The easiest way to fix is to install the Word viewer and the Microsoft Office Compatibility Pack for Word, Excel, and PowerPoint 2007 and later versions' file formats ### tcp lookup some.domain.com no such host This happens when rclone cannot resolve a domain. Please check that your DNS setup is generally working, e.g. ```sh # both should print a long list of possible IP addresses dig www.googleapis.com # resolve using your default DNS dig www.googleapis.com @8.8.8.8 # resolve with Google's DNS server ``` If you are using `systemd-resolved` (default on Arch Linux), ensure it is at version 233 or higher. Previous releases contain a bug which causes not all domains to be resolved properly. The Go resolver decision can be influenced with the `GODEBUG=netdns=...` environment variable. This also allows to resolve certain issues with DNS resolution. On Windows or MacOS systems, try forcing use of the internal Go resolver by setting `GODEBUG=netdns=go` at runtime. On other systems (Linux, \*BSD, etc) try forcing use of the system name resolver by setting `GODEBUG=netdns=cgo` (and recompile rclone from source with CGO enabled if necessary). See the [name resolution section in the go docs](https://golang.org/pkg/net/#hdr-Name_Resolution). ### Failed to start auth webserver on Windows ```text Error: config failed to refresh token: failed to start auth webserver: listen tcp 127.0.0.1:53682: bind: An attempt was made to access a socket in a way forbidden by its access permissions. ... yyyy/mm/dd hh:mm:ss Fatal error: config failed to refresh token: failed to start auth webserver: listen tcp 127.0.0.1:53682: bind: An attempt was made to access a socket in a way forbidden by its access permissions. ``` This is sometimes caused by the Host Network Service causing issues with opening the port on the host. A simple solution may be restarting the Host Network Service with eg. Powershell ```pwsh Restart-Service hns ``` ### The total size reported in the stats for a sync is wrong and keeps changing It is likely you have more than 10,000 files that need to be synced. By default, rclone only gets 10,000 files ahead in a sync so as not to use up too much memory. You can change this default with the [--max-backlog](https://rclone.org/docs/#max-backlog-int) flag. ### Rclone is using too much memory or appears to have a memory leak Rclone is written in Go which uses a garbage collector. The default settings for the garbage collector mean that it runs when the heap size has doubled. However it is possible to tune the garbage collector to use less memory by [setting GOGC](https://dave.cheney.net/tag/gogc) to a lower value, say `export GOGC=20`. This will make the garbage collector work harder, reducing memory size at the expense of CPU usage. The most common cause of rclone using lots of memory is a single directory with millions of files in. Before rclone v1.70 has to load this entirely into memory as rclone objects. Each rclone object takes 0.5k-1k of memory. There is [a workaround for this](https://github.com/rclone/rclone/wiki/Big-syncs-with-millions-of-files) which involves a bit of scripting. However with rclone v1.70 and later rclone will automatically save directory entries to disk when a directory with more than [`--list-cutoff`](https://rclone.org/docs/#list-cutoff) (1,000,000 by default) entries is detected. From v1.70 rclone also has the [--max-buffer-memory](https://rclone.org/docs/#max-buffer-memory) flag which helps particularly when multi-thread transfers are using too much memory. ### Rclone changes fullwidth Unicode punctuation marks in file names For example: On a Windows system, you have a file with name `Test：1.jpg`, where `：` is the Unicode fullwidth colon symbol. When using rclone to copy this to your Google Drive, you will notice that the file gets renamed to `Test:1.jpg`, where `:` is the regular (halfwidth) colon. The reason for such renames is the way rclone handles different [restricted filenames](https://rclone.org/overview/#restricted-filenames) on different cloud storage systems. It tries to avoid ambiguous file names as much and allow moving files between many cloud storage systems transparently, by replacing invalid characters with similar looking Unicode characters when transferring to one storage system, and replacing back again when transferring to a different storage system where the original characters are supported. When the same Unicode characters are intentionally used in file names, this replacement strategy leads to unwanted renames. Read more under section [caveats](https://rclone.org/overview/#restricted-filenames-caveats). # License This is free software under the terms of the MIT license (check the COPYING file included with the source code). ```text Copyright (C) 2019 by Nick Craig-Wood https://www.craig-wood.com/nick/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ``` # Authors and contributors ## Authors - Nick Craig-Wood ## Contributors {{< rem `email addresses removed from here need to be added to bin/.ignore-emails to make sure update-authors.py doesn't immediately put them back in again.` >}} - Alex Couper - Leonid Shalupov - Shimon Doodkin - Colin Nicholson - Klaus Post - Sergey Tolmachev - Adriano Aurélio Meirelles - C. Bess - Dmitry Burdeev - Joseph Spurrier - Björn Harrtell - Xavier Lucas - Werner Beroux - Brian Stengaard - Jakub Gedeon - Jim Tittsler - Michal Witkowski - Fabian Ruff - Leigh Klotz - Romain Lapray - Justin R. Wilson - Antonio Messina - Stefan G. Weichinger - Per Cederberg - Radek Šenfeld - Fredrik Fornwall - Asko Tamm - xor-zz - Tomasz Mazur - Marco Paganini - Felix Bünemann - Durval Menezes - Luiz Carlos Rumbelsperger Viana - Stefan Breunig - Alishan Ladhani - 0xJAKE <0xJAKE@users.noreply.github.com> - Thibault Molleman - Scott McGillivray - Bjørn Erik Pedersen - Lukas Loesche - emyarod - T.C. Ferguson - Brandur - Dario Giovannetti - Károly Oláh - Jon Yergatian - Jack Schmidt - Dedsec1 - Hisham Zarka - Jérôme Vizcaino - Mike Tesch - Marvin Watson - Danny Tsai - Yoni Jah - Stephen Harris - Ihor Dvoretskyi - Jon Craton - Hraban Luyat - Michael Ledin - Martin Kristensen - Too Much IO - Anisse Astier - Zahiar Ahmed - Igor Kharin - Bill Zissimopoulos - Bob Potter - Steven Lu - Sjur Fredriksen - Ruwbin - Fabian Möller - Edward Q. Bridges - Vasiliy Tolstov - Harshavardhana - sainaen - gdm85 - Yaroslav Halchenko - John Papandriopoulos - Zhiming Wang - Andy Pilate - Oliver Heyme - wuyu - Andrei Dragomir - Christian Brüggemann - Alex McGrath Kraak - bpicode - Daniel Jagszent - Josiah White - Ishuah Kariuki - Jan Varho - Girish Ramakrishnan - LingMan - Jacob McNamee - jersou - thierry - Simon Leinen - Dan Dascalescu - Jason Rose - Andrew Starr-Bochicchio - John Leach - Corban Raun - Pierre Carlson - Ernest Borowski - Remus Bunduc - Iakov Davydov - Jakub Tasiemski - David Minor - Tim Cooijmans - Laurence - Giovanni Pizzi - Filip Bartodziej - Jon Fautley - lewapm <32110057+lewapm@users.noreply.github.com> - Yassine Imounachen - Chris Redekop - Jon Fautley - Will Gunn - Lucas Bremgartner - Jody Frankowski - Andreas Roussos - nbuchanan - Durval Menezes - Victor - Mateusz - Daniel Loader - David0rk - Alexander Neumann - Giri Badanahatti - Leo R. Lundgren - wolfv - Dave Pedu - Stefan Lindblom - seuffert - gbadanahatti <37121690+gbadanahatti@users.noreply.github.com> - Keith Goldfarb - Steve Kriss - Chih-Hsuan Yen - Alexander Neumann - Matt Holt - Eri Bastos - Michael P. Dubner - Antoine GIRARD - Mateusz Piotrowski - Animosity022 - Peter Baumgartner - Craig Rachel - Michael G. Noll - hensur - Oliver Heyme - Richard Yang - Piotr Oleszczyk - Rodrigo - NoLooseEnds - Jakub Karlicek - John Clayton - Kasper Byrdal Nielsen - Benjamin Joseph Dag - themylogin - Onno Zweers - Jasper Lievisse Adriaanse - sandeepkru - HerrH - Andrew <4030760+sparkyman215@users.noreply.github.com> - dan smith - Oleg Kovalov - Ruben Vandamme - Cnly - Andres Alvarez <1671935+kir4h@users.noreply.github.com> - reddi1 - Matt Tucker - Sebastian Bünger - Martin Polden - Alex Chen - Denis - bsteiss <35940619+bsteiss@users.noreply.github.com> - Cédric Connes - Dr. Tobias Quathamer - dcpu <42736967+dcpu@users.noreply.github.com> - Sheldon Rupp - albertony <12441419+albertony@users.noreply.github.com> - cron410 - Anagh Kumar Baranwal <6824881+darthShadow@users.noreply.github.com> - Felix Brucker - Santiago Rodríguez - Craig Miskell - Antoine GIRARD - Joanna Marek - frenos - ssaqua - xnaas - Frantisek Fuka - Paul Kohout - dcpu <43330287+dcpu@users.noreply.github.com> - jackyzy823 - David Haguenauer - teresy - buergi - Florian Gamboeck - Ralf Hemberger <10364191+rhemberger@users.noreply.github.com> - Scott Edlund - Erik Swanson - Jake Coggiano - brused27 - Peter Kaminski - Henry Ptasinski - Alexander - Garry McNulty - Mathieu Carbou - Mark Otway - William Cocker <37018962+WilliamCocker@users.noreply.github.com> - François Leurent <131.js@cloudyks.org> - Arkadius Stefanski - Jay - andrea rota - nicolov - Matt Joiner - Dario Guzik - qip - yair@unicorn - Matt Robinson - kayrus - Rémy Léone - Wojciech Smigielski - weetmuts - Jonathan - James Carpenter - Vince - Nestar47 <47841759+Nestar47@users.noreply.github.com> - Six - Alexandru Bumbacea - calisro - Dr.Rx - marcintustin - jaKa Močnik - Fionera - Dan Walters - Danil Semelenov - xopez <28950736+xopez@users.noreply.github.com> - Ben Boeckel - Manu - Kyle E. Mitchell - Gary Kim - Jon - Jeff Quinn - Peter Berbec - didil <1284255+didil@users.noreply.github.com> - id01 - Robert Marko - Philip Harvey <32467456+pharveybattelle@users.noreply.github.com> - JorisE - garry415 - forgems - Florian Apolloner - Aleksandar Janković - Maran - nguyenhuuluan434 - Laura Hausmann - yparitcher - AbelThar - Matti Niemenmaa - Russell Davis - Yi FU - Paul Millar - justinalin - EliEron - justina777 - Chaitanya Bankanhal - Michał Matczuk - Macavirus - Abhinav Sharma - ginvine <34869051+ginvine@users.noreply.github.com> - Patrick Wang - Cenk Alti - Andreas Chlupka - Alfonso Montero - Ivan Andreev - David Baumgold - Lars Lehtonen - Matei David - David - Anthony Rusdi <33247310+antrusd@users.noreply.github.com> - Richard Patel - 庄天翼 - SwitchJS - Raphael - Sezal Agrawal - Tyler - Brett Dutro - Vighnesh SK - Arijit Biswas - Michele Caci - AlexandrBoltris - Bryce Larson - Carlos Ferreyra - Saksham Khanna - dausruddin <5763466+dausruddin@users.noreply.github.com> - zero-24 - Xiaoxing Ye - Barry Muldrey - Sebastian Brandt - Marco Molteni - Ankur Gupta <7876747+ankur0493@users.noreply.github.com> - Maciej Zimnoch - anuar45 - Fernando - David Cole - Wei He - Outvi V <19144373+outloudvi@users.noreply.github.com> - Thomas Kriechbaumer - Tennix - Ole Schütt - Kuang-che Wu - Thomas Eales - Paul Tinsley - Felix Hungenberg - Benjamin Richter - landall - thestigma - jtagcat <38327267+jtagcat@users.noreply.github.com> - Damon Permezel - boosh - unbelauscht <58393353+unbelauscht@users.noreply.github.com> - Motonori IWAMURO - Benjapol Worakan - Dave Koston - Durval Menezes - Tim Gallant - Frederick Zhang - valery1707 - Yves G - Shing Kit Chan - Franklyn Tackitt - Robert-André Mauchin - evileye <48332831+ibiruai@users.noreply.github.com> - Joachim Brandon LeBlanc - Patryk Jakuszew - fishbullet - greatroar <@> - Bernd Schoolmann - Elan Ruusamäe - Max Sum - Mark Spieth - harry - Samantha McVey - Jack Anderson - Michael G - Brandon Philips - Daven - Martin Stone - David Bramwell <13053834+dbramwell@users.noreply.github.com> - Sunil Patra - Adam Stroud - Kush - Matan Rosenberg - gitch1 <63495046+gitch1@users.noreply.github.com> - ElonH - Fred - Sébastien Gross - Maxime Suret <11944422+msuret@users.noreply.github.com> - Caleb Case - Ben Zenker - Martin Michlmayr - Brandon McNama - Daniel Slyman - Alex Guerrero - Matteo Pietro Dazzi - edwardxml <56691903+edwardxml@users.noreply.github.com> - Roman Kredentser - Kamil Trzciński - Zac Rubin - Vincent Feltz - Heiko Bornholdt - Matteo Pietro Dazzi - jtagcat - Petri Salminen - Tim Burke - Kai Lüke - Garrett Squire - Evan Harris - Kevin - Morten Linderud - Dmitry Ustalov - Jack <196648+jdeng@users.noreply.github.com> - kcris - tyhuber1 <68970760+tyhuber1@users.noreply.github.com> - David Ibarra - Tim Gallant - Kaloyan Raev - Jay McEntire - Leo Luan - aus <549081+aus@users.noreply.github.com> - Aaron Gokaslan - Egor Margineanu - Lucas Kanashiro - WarpedPixel - Sam Edwards - wjielai - Muffin King - Christopher Stewart <6573710+1f47a@users.noreply.github.com> - Russell Cattelan - gyutw <30371241+gyutw@users.noreply.github.com> - Hekmon - LaSombra - Dov Murik - Ameer Dawood - Dan Hipschman - Josh Soref <2119212+jsoref@users.noreply.github.com> - David - Ingo - Adam Plánský - Manish Gupta - Deepak Sah - Marcin Zelent - zhucan - James Lim - Laurens Janssen - Bob Bagwill - Nathan Collins - lostheli - kelv - Milly - gtorelly - Brad Ackerman - Mitsuo Heijo - Claudio Bantaloukas - Benjamin Gustin - Ingo Weiss - Kerry Su - Ilyess Bachiri - Yury Stankevich - kice - Denis Neuling - Janne Johansson - Patrik Nordlén - CokeMine - Sơn Trần-Nguyễn - lluuaapp <266615+lluuaapp@users.noreply.github.com> - Zach Kipp - Riccardo Iaconelli - Sakuragawa Misty - Nicolas Rueff - Pau Rodriguez-Estivill - Bob Pusateri - Alex JOST <25005220+dimejo@users.noreply.github.com> - Alexey Tabakman - David Sze - cynthia kwok - Miron Veryanskiy - K265 - Vesnyx - Dmitry Chepurovskiy - Rauno Ots - Georg Neugschwandtner - pvalls - Robert Thomas <31854736+wolveix@users.noreply.github.com> - Romeo Kienzler - tYYGH - georne <77802995+georne@users.noreply.github.com> - Maxwell Calman - Naveen Honest Raj - Lucas Messenger - Manish Kumar - x0b - CERN through the CS3MESH4EOSC Project - Nick Gaya - Ashok Gelal <401055+ashokgelal@users.noreply.github.com> - Dominik Mydlil - Nazar Mishturak - Ansh Mittal - noabody - OleFrost <82263101+olefrost@users.noreply.github.com> - Kenny Parsons - Jeffrey Tolar - jtagcat - Tatsuya Noyori <63089076+public-tatsuya-noyori@users.noreply.github.com> - lewisxy - Nolan Woods - Gautam Kumar <25435568+gautamajay52@users.noreply.github.com> - Chris Macklin - Antoon Prins - Alexey Ivanov - Serge Pouliquen - acsfer - Tom - Tyson Moore - database64128 - Chris Lu - Reid Buzby - darrenrhs - Florian Penzkofer - Xuanchen Wu <117010292@link.cuhk.edu.cn> - partev - Dmitry Sitnikov - Haochen Tong - Michael Hanselmann - Chuan Zh - Antoine GIRARD - Justin Winokur (Jwink3101) - Mariano Absatz (git) - Greg Sadetsky - yedamo - hota - vinibali - Ken Enrique Morel - Justin Hellings - Parth Shukla - wzl - HNGamingUK - Jonta <359397+Jonta@users.noreply.github.com> - YenForYang - SimJoSt / Joda Stößer - Logeshwaran - Rajat Goel - r0kk3rz - Matthew Sevey - Filip Rysavy - Ian Levesque - Thomas Stachl - Dmitry Bogatov - thomae <4493560+thomae@users.noreply.github.com> - trevyn - David Liu - Chris Nelson - Felix Bünemann - Atílio Antônio - Carlo Mion - Chris Lu - Vitor Arruda - bbabich - David - Borna Butkovic - Fredric Arklid - Andy Jackson - Sinan Tan - deinferno <14363193+deinferno@users.noreply.github.com> - rsapkf - Will Holtz - GGG KILLER - Logeshwaran Murugesan - Lu Wang - Bumsu Hyeon - Shmz Ozggrn <98463324+ShmzOzggrn@users.noreply.github.com> - Kim - Niels van de Weem - Koopa - Yunhai Luo - Charlie Jiang - Alain Nussbaumer - Vanessasaurus <814322+vsoch@users.noreply.github.com> - Isaac Levy - Gourav T - Paulo Martins - viveknathani - Eng Zer Jun - Abhiraj - Márton Elek - Vincent Murphy - ctrl-q <34975747+ctrl-q@users.noreply.github.com> - Nil Alexandrov - GuoXingbin <101376330+guoxingbin@users.noreply.github.com> - Berkan Teber - Tobias Klauser - KARBOWSKI Piotr - GH - rafma0 - Adrien Rey-Jarthon - Nick Gooding <73336146+nickgooding@users.noreply.github.com> - Leroy van Logchem - Zsolt Ero - Lesmiscore - ehsantdy - SwazRGB <65694696+swazrgb@users.noreply.github.com> - Mateusz Puczyński - Michael C Tiernan - MIT-Research Computing Project - Kaspian <34658474+KaspianDev@users.noreply.github.com> - Werner - Hugal31 - Christian Galo <36752715+cgalo5758@users.noreply.github.com> - Erik van Velzen - Derek Battams - Paul - SimonLiu - Hugo Laloge - Mr-Kanister <68117355+Mr-Kanister@users.noreply.github.com> - Rob Pickerill - Andrey - Eric Wolf <19wolf@gmail.com> - Nick - Jason Zheng - Matthew Vernon - Noah Hsu - m00594701 - Art M. Gallagher - Sven Gerber <49589423+svengerber@users.noreply.github.com> - CrossR - Maciej Radzikowski - Scott Grimes - Phil Shackleton <71221528+philshacks@users.noreply.github.com> - eNV25 - Caleb - J-P Treen - Martin Czygan <53705+miku@users.noreply.github.com> - buda - mirekphd <36706320+mirekphd@users.noreply.github.com> - vyloy - Anthrazz <25553648+Anthrazz@users.noreply.github.com> - zzr93 <34027824+zzr93@users.noreply.github.com> - Paul Norman - Lorenzo Maiorfi - Claudio Maradonna - Ovidiu Victor Tatar - Evan Spensley - Yen Hu <61753151+0x59656e@users.noreply.github.com> - Steve Kowalik - Jordi Gonzalez Muñoz - Joram Schrijver - Mark Trolley - João Henrique Franco - anonion - Ryan Morey <4590343+rmorey@users.noreply.github.com> - Simon Bos - YFdyh000 - Øyvind Heddeland Instefjord - Dmitry Deniskin <110819396+ddeniskin@users.noreply.github.com> - Alexander Knorr <106825+opexxx@users.noreply.github.com> - Richard Bateman - Dimitri Papadopoulos Orfanos <3234522+DimitriPapadopoulos@users.noreply.github.com> - Lorenzo Milesi - Isaac Aymerich - YanceyChiew <35898533+YanceyChiew@users.noreply.github.com> - Manoj Ghosh - Bachue Zhou - Manoj Ghosh - Tom Mombourquette - Robert Newson - Samuel Johnson - coultonluke - Anthony Pessy - Philip Harvey - dgouju - Clément Notin - x3-apptech <66947598+x3-apptech@users.noreply.github.com> - Arnie97 - Roel Arents <2691308+roelarents@users.noreply.github.com> - Aaron Gokaslan - techknowlogick - rkettelerij - Kamui - asdffdsazqqq <90116442+asdffdsazqqq@users.noreply.github.com> - Nathaniel Wesley Filardo - ycdtosa - Erik Agterdenbos - Kevin Verstaen <48050031+kverstae@users.noreply.github.com> - MohammadReza - vanplus <60313789+vanplus@users.noreply.github.com> - Jack <16779171+jkpe@users.noreply.github.com> - Abdullah Saglam - Marks Polakovs - piyushgarg - Kaloyan Raev - IMTheNachoMan - alankrit - Bryan Kaplan <#@bryankaplan.com> - LXY <767763591@qq.com> - Simmon Li (he/him) - happyxhw <44490504+happyxhw@users.noreply.github.com> - Simmon Li (he/him) - Matthias Baur - Hunter Wittenborn - logopk - Gerard Bosch <30733556+gerardbosch@users.noreply.github.com> - ToBeFree - NodudeWasTaken <75137537+NodudeWasTaken@users.noreply.github.com> - Peter Brunner - Ninh Pham - Ryan Caezar Itang - Peter Brunner - Leandro Sacchet - dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> - cycneuramus <56681631+cycneuramus@users.noreply.github.com> - Arnavion - Christopher Merry - Thibault Coupin - Richard Tweed - Zach Kipp - yuudi <26199752+yuudi@users.noreply.github.com> - NickIAm - Juang, Yi-Lin - jumbi77 - Aditya Basu - ed - Drew Parsons - Joel - wiserain - Roel Arents - Shyim - Rintze Zelle <78232505+rzelle-lallemand@users.noreply.github.com> - Damo - WeidiDeng - Brian Starkey - jladbrook - Loren Gordon - dlitster - Tobias Gion - Jānis Bebrītis - Adam K - Andrei Smirnov - Janne Hellsten - cc <12904584+shvc@users.noreply.github.com> - Tareq Sharafy - kapitainsky - douchen - Sam Lai <70988+slai@users.noreply.github.com> - URenko <18209292+URenko@users.noreply.github.com> - Stanislav Gromov - Paulo Schreiner - Mariusz Suchodolski - danielkrajnik - Peter Fern - zzq - mac-15 - Sawada Tsunayoshi <34431649+TsunayoshiSawada@users.noreply.github.com> - Dean Attali - Fjodor42 - BakaWang - Mahad <56235065+Mahad-lab@users.noreply.github.com> - Vladislav Vorobev - darix - Benjamin <36415086+bbenjamin-sys@users.noreply.github.com> - Chun-Hung Tseng - Ricardo D'O. Albanus - gabriel-suela - Tiago Boeing - Edwin Mackenzie-Owen - Niklas Hambüchen - yuudi - Zach - nielash <31582349+nielash@users.noreply.github.com> - Julian Lepinski - Raymond Berger - Nihaal Sangha - Masamune3210 <1053504+Masamune3210@users.noreply.github.com> - James Braza - antoinetran - alexia - nielash - Vitor Gomes - Jacob Hands - hideo aoyama <100831251+boukendesho@users.noreply.github.com> - Roberto Ricci - Bjørn Smith - Alishan Ladhani <8869764+aladh@users.noreply.github.com> - zjx20 - Oksana <142890647+oks-maytech@users.noreply.github.com> - Volodymyr Kit - David Pedersen - Drew Stinnett - Pat Patterson - Herby Gillot - Nikita Shoshin - rinsuki <428rinsuki+git@gmail.com> - Beyond Meat <51850644+beyondmeat@users.noreply.github.com> - Saleh Dindar - Volodymyr <142890760+vkit-maytech@users.noreply.github.com> - Gabriel Espinoza <31670639+gspinoza@users.noreply.github.com> - Keigo Imai - Ivan Yanitra - alfish2000 - wuxingzhong - Adithya Kumar - Tayo-pasedaRJ <138471223+Tayo-pasedaRJ@users.noreply.github.com> - Peter Kreuser - fotile96 - Luc Ritchie - cynful - wjielai - Jack Deng - Mikubill <31246794+Mikubill@users.noreply.github.com> - Artur Neumann - Saw-jan - Oksana Zhykina - karan - viktor - moongdal - Mina Galić - Alen Šiljak - 你知道未来吗 - Abhinav Dhiman <8640877+ahnv@users.noreply.github.com> - halms <7513146+halms@users.noreply.github.com> - ben-ba - Eli Orzitzer - Anthony Metzidis - keongalvin - rarspace01 - Paul Stern - Nikhil Ahuja - Harshit Budhraja <52413945+harshit-budhraja@users.noreply.github.com> - Tera <24725862+teraa@users.noreply.github.com> - Kyle Reynolds - Michael Eischer - Thomas Müller <1005065+DeepDiver1975@users.noreply.github.com> - DanielEgbers <27849724+DanielEgbers@users.noreply.github.com> - Jack Provance <49460795+njprov@users.noreply.github.com> - Gabriel Ramos <109390599+gabrielramos02@users.noreply.github.com> - Dan McArdle - Joe Cai - Anders Swanson - huajin tong <137764712+thirdkeyword@users.noreply.github.com> - John-Paul Smith - racerole <148756161+racerole@users.noreply.github.com> - Gachoud Philippe - YukiUnHappy - Kyle Reynolds - Lewis Hook - hoyho - Vitaly <9034218+gvitali@users.noreply.github.com> - iotmaestro - psychopatt <66741203+psychopatt@users.noreply.github.com> - Alex Garel - Warrentheo - Alexandre Lavigne - yoelvini <134453420+yoelvini@users.noreply.github.com> - Erisa A - Pieter van Oostrum - jakzoe <155812065+jakzoe@users.noreply.github.com> - guangwu - static-moonlight <107991124+static-moonlight@users.noreply.github.com> - yudrywet - Butanediol - Dave Nicolson - Katia Esposito - pawsey-kbuckley <36438302+pawsey-kbuckley@users.noreply.github.com> - hidewrong <167099254+hidewrong@users.noreply.github.com> - Michael Terry - Sunny <25066078+LoSunny@users.noreply.github.com> - overallteach - JT Olio - Evan McBeth <64177332+AtomicRobotMan0101@users.noreply.github.com> - Dominik Joe Pantůček - yumeiyin <155420652+yumeiyin@users.noreply.github.com> - Bruno Fernandes <54373093+folkzb@users.noreply.github.com> - Thomas Schneider - Charles Hamilton <52973156+chamilton-ccn@users.noreply.github.com> - Tomasz Melcer - Michał Dzienisiewicz - Florian Klink - Bill Fraser - Thearas - Filipe Herculano - Russ Bubley - Paul Collins - Tomasz Melcer - itsHenry <2671230065@qq.com> - Ke Wang - AThePeanut4 <49614525+AThePeanut4@users.noreply.github.com> - Tobias Markus - Ernie Hershey - Will Miles - David Seifert <16636962+SoapGentoo@users.noreply.github.com> - Fornax - Sam Harrison - Péter Bozsó <3806723+peterbozso@users.noreply.github.com> - Georg Welzel - John Oxley - Pawel Palucha - crystalstall - nipil - yuval-cloudinary <46710068+yuval-cloudinary@users.noreply.github.com> - Mathieu Moreau - fsantagostinobietti <6057026+fsantagostinobietti@users.noreply.github.com> - Oleg Kunitsyn <114359669+hiddenmarten@users.noreply.github.com> - Divyam <47589864+divyam234@users.noreply.github.com> - ttionya - quiescens - rishi.sridhar - Lawrence Murray - Leandro Piccilli - Benjamin Legrand - Noam Ross - lostb1t - Matthias Gatto - André Tran - Simon Bos - Alexandre Hamez <199517+ahamez@users.noreply.github.com> - Randy Bush - Diego Monti - tgfisher - Moises Lima - Dimitar Ivanov - shenpengfeng - Dimitrios Slamaris - vintagefuture <39503528+vintagefuture@users.noreply.github.com> - David Seifert - Michael R. Davis - remygrandin - Ilias Ozgur Can Leonard - divinity76 - Martin Hassack - Filipe Azevedo - hayden.pan - Yxxx <45665172+marsjane@users.noreply.github.com> - Thomas ten Cate - Louis Laureys - Henry Lee - ToM - TAKEI Yuya <853320+takei-yuya@users.noreply.github.com> - Francesco Frassinelli - Matt Ickstadt - Spencer McCullough - Jonathan Giannuzzi - Christoph Berger - Tim White - Robin Schneider - izouxv - Moises Lima - Bruno Fernandes - Corentin Barreau - hiddenmarten - Trevor Starick - b-wimmer <132347192+b-wimmer@users.noreply.github.com> - Jess - Zachary Vorhies - Alexander Minbaev - Joel K Biju - ll3006 - jbagwell-akamai <113531113+jbagwell-akamai@users.noreply.github.com> - Michael Kebe - Lorenz Brun - Dave Vasilevsky - luzpaz - jack <9480542+jackusm@users.noreply.github.com> - Jörn Friedrich Dreyer - alingse - Fernando Fernández - eccoisle <167755281+eccoisle@users.noreply.github.com> - Klaas Freitag - Danny Garside - Samantha Bowen - simonmcnair <101189766+simonmcnair@users.noreply.github.com> - huanghaojun - Enduriel - Markus Gerstel - simwai <16225108+simwai@users.noreply.github.com> - Ben Alex - Klaas Freitag - Andrew Kreimer - Ed Craig-Wood <138211970+edc-w@users.noreply.github.com> - Christian Richter <1058116+dragonchaser@users.noreply.github.com> - Ralf Haferkamp - Jugal Kishore - Tho Neyugn - Ben Boeckel - Clément Wehrung - Jeff Geerling - Germán Casares - fhuber - wbulot - Jeremy Daer - Oleksiy Stashok - PrathameshLakawade - Nathanael Demacon <7271496+quantumsheep@users.noreply.github.com> - ahxxm - Flora Thiebaut - kingston125 - Ser-Bul <30335009+Ser-Bul@users.noreply.github.com> - jinjingroad - necaran <55765083+necaran@users.noreply.github.com> - Marvin Rösch - curlwget - $@M@RTH_ <165886349+Samarth1015@users.noreply.github.com> - Ali Zein Yousuf - Davide Bizzarri - Ross Smith II - Vikas Bhansali <64532198+vibhansa-msft@users.noreply.github.com> - Sudipto Baral - Sam Pegg - liubingrun - Albin Parou - n4n5 <56606507+Its-Just-Nans@users.noreply.github.com> - Florent Vennetier - houance <45840516+houance@users.noreply.github.com> - Yu Xin <3188+is@users.noreply.github.com> - Antonin Goude - Timothy Jacobs - praveen-solanki-oracle - huangnauh - Lucas Bremgartner - Binbin Qian - cui <523516579@qq.com> # Contact the rclone project ## Forum Forum for questions and general discussion: - https://forum.rclone.org ## Business support For business support or sponsorship enquiries please see: - https://rclone.com/ - sponsorship@rclone.com ## GitHub repository The project's repository is located at: - https://github.com/rclone/rclone There you can file bug reports or contribute with pull requests. ## Twitter You can also follow Nick on twitter for rclone announcements: - [@njcw](https://twitter.com/njcw) ## Email Or if all else fails or you want to ask something private or confidential - info@rclone.com Please don't email requests for help to this address - those are better directed to the forum unless you'd like to sign up for business support. rclone-v1.71.0/MANUAL.txt000066400000000000000000116700231505210326400147760ustar00rootroot00000000000000rclone(1) User Manual Nick Craig-Wood Aug 22, 2025 NAME rclone - manage files on cloud storage SYNOPSIS Usage: rclone [flags] rclone [command] Available commands: about Get quota information from the remote. authorize Remote authorization. backend Run a backend-specific command. bisync Perform bidirectional synchronization between two paths. cat Concatenates any files and sends them to stdout. check Checks the files in the source and destination match. checksum Checks the files in the destination against a SUM file. cleanup Clean up the remote if possible. completion Output completion script for a given shell. config Enter an interactive configuration session. convmv Convert file and directory names in place. copy Copy files from source to dest, skipping identical files. copyto Copy files from source to dest, skipping identical files. copyurl Copy the contents of the URL supplied content to dest:path. cryptcheck Cryptcheck checks the integrity of an encrypted remote. cryptdecode Cryptdecode returns unencrypted file names. dedupe Interactively find duplicate filenames and delete/rename them. delete Remove the files in path. deletefile Remove a single file from remote. gendocs Output markdown docs for rclone to the directory supplied. gitannex Speaks with git-annex over stdin/stdout. hashsum Produces a hashsum file for all the objects in the path. help Show help for rclone commands, flags and backends. link Generate public link to file/folder. listremotes List all the remotes in the config file and defined in environment variables. ls List the objects in the path with size and path. lsd List all directories/containers/buckets in the path. lsf List directories and objects in remote:path formatted for parsing. lsjson List directories and objects in the path in JSON format. lsl List the objects in path with modification time, size and path. md5sum Produces an md5sum file for all the objects in the path. mkdir Make the path if it doesn't already exist. mount Mount the remote as file system on a mountpoint. move Move files from source to dest. moveto Move file or directory from source to dest. ncdu Explore a remote with a text based user interface. nfsmount Mount the remote as file system on a mountpoint. obscure Obscure password for use in the rclone config file. purge Remove the path and all of its contents. rc Run a command against a running rclone. rcat Copies standard input to file on remote. rcd Run rclone listening to remote control commands only. rmdir Remove the empty directory at path. rmdirs Remove empty directories under the path. selfupdate Update the rclone binary. serve Serve a remote over a protocol. settier Changes storage class/tier of objects in remote. sha1sum Produces an sha1sum file for all the objects in the path. size Prints the total size and number of objects in remote:path. sync Make source and dest identical, modifying destination only. test Run a test command touch Create new file or change file modification time. tree List the contents of the remote in a tree like fashion. version Show the version number. Use "rclone [command] --help" for more information about a command. Use "rclone help flags" for to see the global flags. Use "rclone help backends" for a list of supported services. Rclone syncs your files to cloud storage - About rclone - What can rclone do for you? - What features does rclone have? - What providers does rclone support? - Download - Install - Donate. About rclone Rclone is a command-line program to manage files on cloud storage. It is a feature-rich alternative to cloud vendors' web storage interfaces. Over 70 cloud storage products support rclone including S3 object stores, business & consumer file storage services, as well as standard transfer protocols. Rclone has powerful cloud equivalents to the unix commands rsync, cp, mv, mount, ls, ncdu, tree, rm, and cat. Rclone's familiar syntax includes shell pipeline support, and --dry-run protection. It is used at the command line, in scripts or via its API. Users call rclone "The Swiss army knife of cloud storage", and "Technology indistinguishable from magic". Rclone really looks after your data. It preserves timestamps and verifies checksums at all times. Transfers over limited bandwidth; intermittent connections, or subject to quota can be restarted, from the last good file transferred. You can check the integrity of your files. Where possible, rclone employs server-side transfers to minimise local bandwidth use and transfers from one provider to another without using local disk. Virtual backends wrap local and cloud file systems to apply encryption, compression, chunking, hashing and joining. Rclone mounts any local, cloud or virtual filesystem as a disk on Windows, macOS, linux and FreeBSD, and also serves these over SFTP, HTTP, WebDAV, FTP and DLNA. Rclone is mature, open-source software originally inspired by rsync and written in Go. The friendly support community is familiar with varied use cases. Official Ubuntu, Debian, Fedora, Brew and Chocolatey repos. include rclone. For the latest version downloading from rclone.org is recommended. Rclone is widely used on Linux, Windows and Mac. Third-party developers create innovative backup, restore, GUI and business process solutions using the rclone command line or API. Rclone does the heavy lifting of communicating with cloud storage. What can rclone do for you? Rclone helps you: - Backup (and encrypt) files to cloud storage - Restore (and decrypt) files from cloud storage - Mirror cloud data to other cloud services or locally - Migrate data to the cloud, or between cloud storage vendors - Mount multiple, encrypted, cached or diverse cloud storage as a disk - Analyse and account for data held on cloud storage using lsf, ljson, size, ncdu - Union file systems together to present multiple local and/or cloud file systems as one Features - Transfers - MD5, SHA1 hashes are checked at all times for file integrity - Timestamps are preserved on files - Operations can be restarted at any time - Can be to and from network, e.g. two different cloud providers - Can use multi-threaded downloads to local disk - Copy new or changed files to cloud storage - Sync (one way) to make a directory identical - Bisync (two way) to keep two directories in sync bidirectionally - Move files to cloud storage deleting the local after verification - Check hashes and for missing/extra files - Mount your cloud storage as a network disk - Serve local or remote files over HTTP/WebDav/FTP/SFTP/DLNA - Experimental Web based GUI Supported providers (There are many others, built on standard protocols such as WebDAV or S3, that work out of the box.) - 1Fichier - Akamai Netstorage - Alibaba Cloud (Aliyun) Object Storage System (OSS) - Amazon S3 - Backblaze B2 - Box - Ceph - China Mobile Ecloud Elastic Object Storage (EOS) - Arvan Cloud Object Storage (AOS) - Citrix ShareFile - Cloudflare R2 - Cloudinary - DigitalOcean Spaces - Digi Storage - Dreamhost - Dropbox - Enterprise File Fabric - Exaba - Fastmail Files - FileLu Cloud Storage - Files.com - FlashBlade - FTP - Gofile - Google Cloud Storage - Google Drive - Google Photos - HDFS - Hetzner Storage Box - HiDrive - HTTP - iCloud Drive - ImageKit - Internet Archive - Jottacloud - IBM COS S3 - IDrive e2 - IONOS Cloud - Koofr - Leviia Object Storage - Liara Object Storage - Linkbox - Linode Object Storage - Magalu - Mail.ru Cloud - Memset Memstore - MEGA - MEGA S4 - Memory - Microsoft Azure Blob Storage - Microsoft Azure Files Storage - Microsoft OneDrive - Minio - Nextcloud - Blomp Cloud Storage - OpenDrive - OpenStack Swift - Oracle Cloud Storage Swift - Oracle Object Storage - Outscale - OVHcloud Object Storage (Swift) - OVHcloud Object Storage (S3-compatible) - ownCloud - pCloud - Petabox - PikPak - Pixeldrain - premiumize.me - put.io - Proton Drive - QingStor - Qiniu Cloud Object Storage (Kodo) - Quatrix by Maytech - Rackspace Cloud Files - rsync.net - Scaleway - Seafile - Seagate Lyve Cloud - SeaweedFS - Selectel - SFTP - Sia - SMB / CIFS - StackPath - Storj - Synology - SugarSync - Tencent Cloud Object Storage (COS) - Uloz.to - Uptobox - Wasabi - WebDAV - Yandex Disk - Zoho WorkDrive - Zata - The local filesystem Virtual providers These backends adapt or modify other storage providers: - Alias: Rename existing remotes - Cache: Cache remotes (DEPRECATED) - Chunker: Split large files - Combine: Combine multiple remotes into a directory tree - Compress: Compress files - Crypt: Encrypt files - Hasher: Hash files - Union: Join multiple remotes to work together Links - Home page - GitHub project page for source and bug tracker - Rclone Forum - Downloads Install Rclone is a Go program and comes as a single binary file. Quickstart - Download the relevant binary. - Extract the rclone executable, rclone.exe on Windows, from the archive. - Run rclone config to setup. See rclone config docs for more details. - Optionally configure automatic execution. See below for some expanded Linux / macOS / Windows instructions. See the usage docs for how to use rclone, or run rclone -h. Already installed rclone can be easily updated to the latest version using the rclone selfupdate command. See the release signing docs for how to verify signatures on the release. Script installation To install rclone on Linux/macOS/BSD systems, run: sudo -v ; curl https://rclone.org/install.sh | sudo bash For beta installation, run: sudo -v ; curl https://rclone.org/install.sh | sudo bash -s beta Note that this script checks the version of rclone installed first and won't re-download if not needed. Linux installation Precompiled binary Fetch and unpack curl -O https://downloads.rclone.org/rclone-current-linux-amd64.zip unzip rclone-current-linux-amd64.zip cd rclone-*-linux-amd64 Copy binary file sudo cp rclone /usr/bin/ sudo chown root:root /usr/bin/rclone sudo chmod 755 /usr/bin/rclone Install manpage sudo mkdir -p /usr/local/share/man/man1 sudo cp rclone.1 /usr/local/share/man/man1/ sudo mandb Run rclone config to setup. See rclone config docs for more details. rclone config macOS installation Installation with brew brew install rclone NOTE: This version of rclone will not support mount any more (see #5373). If mounting is wanted on macOS, either install a precompiled binary or enable the relevant option when installing from source. Note that this is a third party installer not controlled by the rclone developers so it may be out of date. Its current version is as below. [Homebrew package] Installation with MacPorts On macOS, rclone can also be installed via MacPorts: sudo port install rclone Note that this is a third party installer not controlled by the rclone developers so it may be out of date. Its current version is as below. [MacPorts port] More information on macports.org. Precompiled binary, using curl To avoid problems with macOS gatekeeper enforcing the binary to be signed and notarized it is enough to download with curl. Download the latest version of rclone. cd && curl -O https://downloads.rclone.org/rclone-current-osx-amd64.zip Unzip the download and cd to the extracted folder. unzip -a rclone-current-osx-amd64.zip && cd rclone-*-osx-amd64 Move rclone to your $PATH. You will be prompted for your password. sudo mkdir -p /usr/local/bin sudo mv rclone /usr/local/bin/ (the mkdir command is safe to run, even if the directory already exists). Remove the leftover files. cd .. && rm -rf rclone-*-osx-amd64 rclone-current-osx-amd64.zip Run rclone config to setup. See rclone config docs for more details. rclone config Precompiled binary, using a web browser When downloading a binary with a web browser, the browser will set the macOS gatekeeper quarantine attribute. Starting from Catalina, when attempting to run rclone, a pop-up will appear saying: "rclone" cannot be opened because the developer cannot be verified. macOS cannot verify that this app is free from malware. The simplest fix is to run xattr -d com.apple.quarantine rclone Windows installation Precompiled binary Fetch the correct binary for your processor type by clicking on these links. If not sure, use the first link. - Intel/AMD - 64 Bit - Intel/AMD - 32 Bit - ARM - 64 Bit Open this file in the Explorer and extract rclone.exe. Rclone is a portable executable so you can place it wherever is convenient. Open a CMD window (or powershell) and run the binary. Note that rclone does not launch a GUI by default, it runs in the CMD Window. - Run rclone.exe config to setup. See rclone config docs for more details. - Optionally configure automatic execution. If you are planning to use the rclone mount feature then you will need to install the third party utility WinFsp also. Windows package manager (Winget) Winget comes pre-installed with the latest versions of Windows. If not, update the App Installer package from the Microsoft store. To install rclone winget install Rclone.Rclone To uninstall rclone winget uninstall Rclone.Rclone --force Chocolatey package manager Make sure you have Choco installed choco search rclone choco install rclone This will install rclone on your Windows machine. If you are planning to use rclone mount then choco install winfsp will install that too. Note that this is a third party installer not controlled by the rclone developers so it may be out of date. Its current version is as below. [Chocolatey package] Scoop package manager Make sure you have Scoop installed scoop install rclone Note that this is a third party installer not controlled by the rclone developers so it may be out of date. Its current version is as below. [Scoop package] Package manager installation Many Linux, Windows, macOS and other OS distributions package and distribute rclone. The distributed versions of rclone are often quite out of date and for this reason we recommend one of the other installation methods if possible. You can get an idea of how up to date or not your OS distribution's package is here. [Packaging status] Docker installation The rclone developers maintain a docker image for rclone. Note: We also now offer a paid version of rclone with enterprise-grade security and zero CVEs through our partner SecureBuild. If you are interested, check out their website and the Rclone SecureBuild Image. These images are built as part of the release process based on a minimal Alpine Linux. The :latest tag will always point to the latest stable release. You can use the :beta tag to get the latest build from master. You can also use version tags, e.g. :1.49.1, :1.49 or :1. $ docker pull rclone/rclone:latest latest: Pulling from rclone/rclone Digest: sha256:0e0ced72671989bb837fea8e88578b3fc48371aa45d209663683e24cfdaa0e11 ... $ docker run --rm rclone/rclone:latest version rclone v1.49.1 - os/arch: linux/amd64 - go version: go1.12.9 There are a few command line options to consider when starting an rclone Docker container from the rclone image. - You need to mount the host rclone config dir at /config/rclone into the Docker container. Due to the fact that rclone updates tokens inside its config file, and that the update process involves a file rename, you need to mount the whole host rclone config dir, not just the single host rclone config file. - You need to mount a host data dir at /data into the Docker container. - By default, the rclone binary inside a Docker container runs with UID=0 (root). As a result, all files created in a run will have UID=0. If your config and data files reside on the host with a non-root UID:GID, you need to pass these on the container start command line. - If you want to access the RC interface (either via the API or the Web UI), it is required to set the --rc-addr to :5572 in order to connect to it from outside the container. An explanation about why this is necessary can be found in an old pythonspeed.com article. - NOTE: Users running this container with the docker network set to host should probably set it to listen to localhost only, with 127.0.0.1:5572 as the value for --rc-addr - It is possible to use rclone mount inside a userspace Docker container, and expose the resulting fuse mount to the host. The exact docker run options to do that might vary slightly between hosts. See, e.g. the discussion in this thread. You also need to mount the host /etc/passwd and /etc/group for fuse to work inside the container. Here are some commands tested on an Ubuntu 18.04.3 host: # config on host at ~/.config/rclone/rclone.conf # data on host at ~/data # add a remote interactively docker run --rm -it \ --volume ~/.config/rclone:/config/rclone \ --user $(id -u):$(id -g) \ rclone/rclone \ config # make sure the config is ok by listing the remotes docker run --rm \ --volume ~/.config/rclone:/config/rclone \ --user $(id -u):$(id -g) \ rclone/rclone \ listremotes # perform mount inside Docker container, expose result to host mkdir -p ~/data/mount docker run --rm \ --volume ~/.config/rclone:/config/rclone \ --volume ~/data:/data:shared \ --user $(id -u):$(id -g) \ --volume /etc/passwd:/etc/passwd:ro --volume /etc/group:/etc/group:ro \ --device /dev/fuse --cap-add SYS_ADMIN --security-opt apparmor:unconfined \ rclone/rclone \ mount dropbox:Photos /data/mount & ls ~/data/mount kill %1 Snap installation [Get it from the Snap Store] Make sure you have Snapd installed sudo snap install rclone Due to the strict confinement of Snap, rclone snap cannot access real /home/$USER/.config/rclone directory, default config path is as below. - Default config directory: - /home/$USER/snap/rclone/current/.config/rclone Note: Due to the strict confinement of Snap, rclone mount feature is not supported. If mounting is wanted, either install a precompiled binary or enable the relevant option when installing from source. Note that this is controlled by community maintainer not the rclone developers so it may be out of date. Its current version is as below. [rclone] Source installation Make sure you have git and Go installed. Go version 1.24 or newer is required, the latest release is recommended. You can get it from your package manager, or download it from golang.org/dl. Then you can run the following: git clone https://github.com/rclone/rclone.git cd rclone go build This will check out the rclone source in subfolder rclone, which you can later modify and send pull requests with. Then it will build the rclone executable in the same folder. As an initial check you can now run ./rclone version (.\rclone version on Windows). Note that on macOS and Windows the mount command will not be available unless you specify an additional build tag cmount. go build -tags cmount This assumes you have a GCC compatible C compiler (GCC or Clang) in your PATH, as it uses cgo. But on Windows, the cgofuse library that the cmount implementation is based on, also supports building without cgo, i.e. by setting environment variable CGO_ENABLED to value 0 (static linking). This is how the official Windows release of rclone is being built, starting with version 1.59. It is still possible to build with cgo on Windows as well, by using the MinGW port of GCC, e.g. by installing it in a MSYS2 distribution (make sure you install it in the classic mingw64 subsystem, the ucrt64 version is not compatible). Additionally, to build with mount on Windows, you must install the third party utility WinFsp, with the "Developer" feature selected. If building with cgo, you must also set environment variable CPATH pointing to the fuse include directory within the WinFsp installation (normally C:\Program Files (x86)\WinFsp\inc\fuse). You may add arguments -ldflags -s to omit symbol table and debug information, making the executable file smaller, and -trimpath to remove references to local file system paths. The official rclone releases are built with both of these. go build -trimpath -ldflags -s -tags cmount If you want to customize the version string, as reported by the rclone version command, you can set one of the variables fs.Version, fs.VersionTag (to keep default suffix but customize the number), or fs.VersionSuffix (to keep default number but customize the suffix). This can be done from the build command, by adding to the -ldflags argument value as shown below. go build -trimpath -ldflags "-s -X github.com/rclone/rclone/fs.Version=v9.9.9-test" -tags cmount On Windows, the official executables also have the version information, as well as a file icon, embedded as binary resources. To get that with your own build you need to run the following command before the build command. It generates a Windows resource system object file, with extension .syso, e.g. resource_windows_amd64.syso, that will be automatically picked up by future build commands. go run bin/resource_windows.go The above command will generate a resource file containing version information based on the fs.Version variable in source at the time you run the command, which means if the value of this variable changes you need to re-run the command for it to be reflected in the version information. Also, if you override this version variable in the build command as described above, you need to do that also when generating the resource file, or else it will still use the value from the source. go run bin/resource_windows.go -version v9.9.9-test Instead of executing the go build command directly, you can run it via the Makefile. The default target changes the version suffix from "-DEV" to "-beta" followed by additional commit details, embeds version information binary resources on Windows, and copies the resulting rclone executable into your GOPATH bin folder ($(go env GOPATH)/bin, which corresponds to ~/go/bin/rclone by default). make To include mount command on macOS and Windows with Makefile build: make GOTAGS=cmount There are other make targets that can be used for more advanced builds, such as cross-compiling for all supported os/architectures, and packaging results into release artifacts. See Makefile and cross-compile.go for details. Another alternative method for source installation is to download the source, build and install rclone - all in one operation, as a regular Go package. The source will be stored it in the Go module cache, and the resulting executable will be in your GOPATH bin folder ($(go env GOPATH)/bin, which corresponds to ~/go/bin/rclone by default). go install github.com/rclone/rclone@latest In some situations, rclone executable size might be too big for deployment in very restricted environments when all backends with large SDKs are included. To limit binary size unused backends can be commented out in backends/all/all.go and unused commands in cmd/all/all.go before building with go build or make Ansible installation This can be done with Stefan Weichinger's ansible role. Instructions 1. git clone https://github.com/stefangweichinger/ansible-rclone.git into your local roles-directory 2. add the role to the hosts you want rclone installed to: - hosts: rclone-hosts roles: - rclone Portable installation As mentioned above, rclone is single executable (rclone, or rclone.exe on Windows) that you can download as a zip archive and extract into a location of your choosing. When executing different commands, it may create files in different locations, such as a configuration file and various temporary files. By default the locations for these are according to your operating system, e.g. configuration file in your user profile directory and temporary files in the standard temporary directory, but you can customize all of them, e.g. to make a completely self-contained, portable installation. Run the config paths command to see the locations that rclone will use. To override them set the corresponding options (as command-line arguments, or as environment variables): - --config - --cache-dir - --temp-dir Autostart After installing and configuring rclone, as described above, you are ready to use rclone as an interactive command line utility. If your goal is to perform periodic operations, such as a regular sync, you will probably want to configure your rclone command in your operating system's scheduler. If you need to expose service-like features, such as remote control, GUI, serve or mount, you will often want an rclone command always running in the background, and configuring it to run in a service infrastructure may be a better option. Below are some alternatives on how to achieve this on different operating systems. NOTE: Before setting up autorun it is highly recommended that you have tested your command manually from a Command Prompt first. Autostart on Windows The most relevant alternatives for autostart on Windows are: - Run at user log on using the Startup folder - Run at user log on, at system startup or at schedule using Task Scheduler - Run at system startup using Windows service Running in background Rclone is a console application, so if not starting from an existing Command Prompt, e.g. when starting rclone.exe from a shortcut, it will open a Command Prompt window. When configuring rclone to run from task scheduler and windows service you are able to set it to run hidden in background. From rclone version 1.54 you can also make it run hidden from anywhere by adding option --no-console (it may still flash briefly when the program starts). Since rclone normally writes information and any error messages to the console, you must redirect this to a file to be able to see it. Rclone has a built-in option --log-file for that. Example command to run a sync in background: c:\rclone\rclone.exe sync c:\files remote:/files --no-console --log-file c:\rclone\logs\sync_files.txt User account As mentioned in the mount documentation, mounted drives created as Administrator are not visible to other accounts, not even the account that was elevated as Administrator. By running the mount command as the built-in SYSTEM user account, it will create drives accessible for everyone on the system. Both scheduled task and Windows service can be used to achieve this. NOTE: Remember that when rclone runs as the SYSTEM user, the user profile that it sees will not be yours. This means that if you normally run rclone with configuration file in the default location, to be able to use the same configuration when running as the system user you must explicitly tell rclone where to find it with the --config option, or else it will look in the system users profile path (C:\Windows\System32\config\systemprofile). To test your command manually from a Command Prompt, you can run it with the PsExec utility from Microsoft's Sysinternals suite, which takes option -s to execute commands as the SYSTEM user. Start from Startup folder To quickly execute an rclone command you can simply create a standard Windows Explorer shortcut for the complete rclone command you want to run. If you store this shortcut in the special "Startup" start-menu folder, Windows will automatically run it at login. To open this folder in Windows Explorer, enter path %APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup, or C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp if you want the command to start for every user that logs in. This is the easiest approach to autostarting of rclone, but it offers no functionality to set it to run as different user, or to set conditions or actions on certain events. Setting up a scheduled task as described below will often give you better results. Start from Task Scheduler Task Scheduler is an administrative tool built into Windows, and it can be used to configure rclone to be started automatically in a highly configurable way, e.g. periodically on a schedule, on user log on, or at system startup. It can run be configured to run as the current user, or for a mount command that needs to be available to all users it can run as the SYSTEM user. For technical information, see Task Scheduler for developers. Run as service For running rclone at system startup, you can create a Windows service that executes your rclone command, as an alternative to scheduled task configured to run at startup. Mount command built-in service integration For mount commands, rclone has a built-in Windows service integration via the third-party WinFsp library it uses. Registering as a regular Windows service easy, as you just have to execute the built-in PowerShell command New-Service (requires administrative privileges). Example of a PowerShell command that creates a Windows service for mounting some remote:/files as drive letter X:, for all users (service will be running as the local system account): New-Service -Name Rclone -BinaryPathName 'c:\rclone\rclone.exe mount remote:/files X: --config c:\rclone\config\rclone.conf --log-file c:\rclone\logs\mount.txt' The WinFsp service infrastructure supports incorporating services for file system implementations, such as rclone, into its own launcher service, as kind of "child services". This has the additional advantage that it also implements a network provider that integrates into Windows standard methods for managing network drives. This is currently not officially supported by Rclone, but with WinFsp version 2019.3 B2 / v1.5B2 or later it should be possible through path rewriting as described in #3340. Third-party service integration To Windows service running any rclone command, the excellent third-party utility NSSM, the "Non-Sucking Service Manager", can be used. It includes some advanced features such as adjusting process priority, defining process environment variables, redirect to file anything written to stdout, and customized response to different exit codes, with a GUI to configure everything from (although it can also be used from command line ). There are also several other alternatives. To mention one more, WinSW, "Windows Service Wrapper", is worth checking out. It requires .NET Framework, but it is preinstalled on newer versions of Windows, and it also provides alternative standalone distributions which includes necessary runtime (.NET 5). WinSW is a command-line only utility, where you have to manually create an XML file with service configuration. This may be a drawback for some, but it can also be an advantage as it is easy to back up and reuse the configuration settings, without having go through manual steps in a GUI. One thing to note is that by default it does not restart the service on error, one have to explicit enable this in the configuration file (via the "onfailure" parameter). Autostart on Linux Start as a service To always run rclone in background, relevant for mount commands etc, you can use systemd to set up rclone as a system or user service. Running as a system service ensures that it is run at startup even if the user it is running as has no active session. Running rclone as a user service ensures that it only starts after the configured user has logged into the system. Run periodically from cron To run a periodic command, such as a copy/sync, you can set up a cron job. Usage Rclone is a command line program to manage files on cloud storage. After download and install, continue here to learn how to use it: Initial configuration, what the basic syntax looks like, describes the various subcommands, the various options, and more. Configure First, you'll need to configure rclone. As the object storage systems have quite complicated authentication these are kept in a config file. (See the --config entry for how to find the config file and choose its location.) The easiest way to make the config is to run rclone with the config option: rclone config See the following for detailed instructions for - 1Fichier - Akamai Netstorage - Alias - Amazon S3 - Backblaze B2 - Box - Chunker - transparently splits large files for other remotes - Citrix ShareFile - Compress - Cloudinary - Combine - Crypt - to encrypt other remotes - DigitalOcean Spaces - Digi Storage - Dropbox - Enterprise File Fabric - FileLu Cloud Storage - Files.com - FTP - Gofile - Google Cloud Storage - Google Drive - Google Photos - Hasher - to handle checksums for other remotes - HDFS - Hetzner Storage Box - HiDrive - HTTP - iCloud Drive - Internet Archive - Jottacloud - Koofr - Linkbox - Mail.ru Cloud - Mega - Memory - Microsoft Azure Blob Storage - Microsoft Azure Files Storage - Microsoft OneDrive - OpenStack Swift / Rackspace Cloudfiles / Blomp Cloud Storage / Memset Memstore - OpenDrive - Oracle Object Storage - Pcloud - PikPak - Pixeldrain - premiumize.me - put.io - Proton Drive - QingStor - Quatrix by Maytech - rsync.net - Seafile - SFTP - Sia - SMB - Storj - SugarSync - Union - Uloz.to - Uptobox - WebDAV - Yandex Disk - Zoho WorkDrive - The local filesystem Basic syntax Rclone syncs a directory tree from one storage system to another. Its syntax is like this rclone subcommand [options] A subcommand is a the rclone operation required, (e.g. sync, copy, ls). An option is a single letter flag (e.g. -v) or a group of single letter flags (e.g. -Pv) or a long flag (e.g. --progress). No options are required. Options can come after the subcommand or in between parameters too or on the end, but only global options can be used before the subcommand. Anything after a -- option will not be interpreted as an option so if you need to add a parameter which starts with a - then put a -- on its own first, eg rclone lsf -- -directory-starting-with-dash A parameter is usually a file path or rclone remote, eg /path/to/file or remote:path/to/file but it can be other things - the subcommand help will tell you what. Source and destination paths are specified by the name you gave the storage system in the config file then the sub path, e.g. "drive:myfolder" to look at "myfolder" in Google drive. You can define as many storage paths as you like in the config file. Please use the --interactive/-i flag while learning rclone to avoid accidental data loss. Subcommands rclone uses a system of subcommands. For example rclone ls remote:path # lists a remote rclone copy /local/path remote:path # copies /local/path to the remote rclone sync --interactive /local/path remote:path # syncs /local/path to the remote rclone config Enter an interactive configuration session. Synopsis Enter an interactive configuration session where you can setup new remotes and manage existing ones. You may also set or remove a password to protect your configuration. rclone config [flags] Options -h, --help help for config See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. - rclone config create - Create a new remote with name, type and options. - rclone config delete - Delete an existing remote. - rclone config disconnect - Disconnects user from remote - rclone config dump - Dump the config file as JSON. - rclone config edit - Enter an interactive configuration session. - rclone config encryption - set, remove and check the encryption for the config file - rclone config file - Show path of configuration file in use. - rclone config password - Update password in an existing remote. - rclone config paths - Show paths used for configuration, cache, temp etc. - rclone config providers - List in JSON format all the providers and options. - rclone config reconnect - Re-authenticates user with remote. - rclone config redacted - Print redacted (decrypted) config file, or the redacted config for a single remote. - rclone config show - Print (decrypted) config file, or the config for a single remote. - rclone config touch - Ensure configuration file exists. - rclone config update - Update options in an existing remote. - rclone config userinfo - Prints info about logged in user of remote. rclone copy Copy files from source to dest, skipping identical files. Synopsis Copy the source to the destination. Does not transfer files that are identical on source and destination, testing by size and modification time or MD5SUM. Doesn't delete files from the destination. If you want to also delete files from destination, to make it match source, use the sync command instead. Note that it is always the contents of the directory that is synced, not the directory itself. So when source:path is a directory, it's the contents of source:path that are copied, not the directory name and contents. To copy single files, use the copyto command instead. If dest:path doesn't exist, it is created and the source:path contents go there. For example rclone copy source:sourcepath dest:destpath Let's say there are two files in sourcepath sourcepath/one.txt sourcepath/two.txt This copies them to destpath/one.txt destpath/two.txt Not to destpath/sourcepath/one.txt destpath/sourcepath/two.txt If you are familiar with rsync, rclone always works as if you had written a trailing / - meaning "copy the contents of this directory". This applies to all commands and whether you are talking about the source or destination. See the --no-traverse option for controlling whether rclone lists the destination directory or not. Supplying this option when copying a small number of files into a large destination can speed transfers up greatly. For example, if you have many files in /path/to/src but only a few of them change every day, you can copy all the files which have changed recently very efficiently like this: rclone copy --max-age 24h --no-traverse /path/to/src remote: Rclone will sync the modification times of files and directories if the backend supports it. If metadata syncing is required then use the --metadata flag. Note that the modification time and metadata for the root directory will not be synced. See https://github.com/rclone/rclone/issues/7652 for more info. Note: Use the -P/--progress flag to view real-time transfer statistics. Note: Use the --dry-run or the --interactive/-i flag to test without copying anything. Logger Flags The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different. The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - = path means path was found in source and destination and was identical - - path means path was missing on the source, so only in the destination - + path means path was missing on the destination, so only in the source - * path means path was present in source and destination but different. - ! path means there was an error reading or hashing the source or dest. The --dest-after flag writes a list file using the same format flags as lsf (including customizable options for hash, modtime, etc.) Conceptually it is similar to rsync's --itemize-changes, but not identical -- it should output an accurate list of what will be on the destination after the command is finished. When the --no-traverse flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing. Note that these logger flags have a few limitations, and certain scenarios are not currently supported: - --max-duration / CutoffModeHard - --compare-dest / --copy-dest - server-side moves of an entire dir at once - High-level retries, because there would be duplicates (use --retries 1 to disable) - Possibly some unusual error scenarios Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.) rclone copy source:path dest:path [flags] Options --absolute Put a leading / in front of path names --combined string Make a combined report of changes to this file --create-empty-src-dirs Create empty source dirs on destination after copy --csv Output in CSV format --dest-after string Report all files that exist on the dest post-sync --differ string Report all non-matching files to this file -d, --dir-slash Append a slash to directory names (default true) --dirs-only Only list directories --error string Report all files with errors (hashing or reading) to this file --files-only Only list files (default true) -F, --format string Output format - see lsf help for details (default "p") --hash h Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5") -h, --help help for copy --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file -s, --separator string Separator for the items in the format (default ";") -t, --timeformat string Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05) Options shared with other commands are described next. See the global flags page for global options not listed here. Copy Options Flags for anything which can copy a file --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone sync Make source and dest identical, modifying destination only. Synopsis Sync the source to the destination, changing the destination only. Doesn't transfer files that are identical on source and destination, testing by size and modification time or MD5SUM. Destination is updated to match source, including deleting files if necessary (except duplicate objects, see below). If you don't want to delete files from destination, use the copy command instead. Important: Since this can cause data loss, test first with the --dry-run or the --interactive/i flag. rclone sync --interactive SOURCE remote:DESTINATION Files in the destination won't be deleted if there were any errors at any point. Duplicate objects (files with the same name, on those providers that support it) are not yet handled. Files that are excluded won't be deleted unless --delete-excluded is used. Symlinks won't be transferred or deleted from local file systems unless --links is used. It is always the contents of the directory that is synced, not the directory itself. So when source:path is a directory, it's the contents of source:path that are copied, not the directory name and contents. See extended explanation in the copy command if unsure. If dest:path doesn't exist, it is created and the source:path contents go there. It is not possible to sync overlapping remotes. However, you may exclude the destination from the sync with a filter rule or by putting an exclude-if-present file inside the destination directory and sync to a destination that is inside the source directory. Rclone will sync the modification times of files and directories if the backend supports it. If metadata syncing is required then use the --metadata flag. Note that the modification time and metadata for the root directory will not be synced. See https://github.com/rclone/rclone/issues/7652 for more info. Note: Use the -P/--progress flag to view real-time transfer statistics Note: Use the rclone dedupe command to deal with "Duplicate object/directory found in source/destination - ignoring" errors. See this forum post for more info. Logger Flags The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different. The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - = path means path was found in source and destination and was identical - - path means path was missing on the source, so only in the destination - + path means path was missing on the destination, so only in the source - * path means path was present in source and destination but different. - ! path means there was an error reading or hashing the source or dest. The --dest-after flag writes a list file using the same format flags as lsf (including customizable options for hash, modtime, etc.) Conceptually it is similar to rsync's --itemize-changes, but not identical -- it should output an accurate list of what will be on the destination after the command is finished. When the --no-traverse flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing. Note that these logger flags have a few limitations, and certain scenarios are not currently supported: - --max-duration / CutoffModeHard - --compare-dest / --copy-dest - server-side moves of an entire dir at once - High-level retries, because there would be duplicates (use --retries 1 to disable) - Possibly some unusual error scenarios Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.) rclone sync source:path dest:path [flags] Options --absolute Put a leading / in front of path names --combined string Make a combined report of changes to this file --create-empty-src-dirs Create empty source dirs on destination after sync --csv Output in CSV format --dest-after string Report all files that exist on the dest post-sync --differ string Report all non-matching files to this file -d, --dir-slash Append a slash to directory names (default true) --dirs-only Only list directories --error string Report all files with errors (hashing or reading) to this file --files-only Only list files (default true) -F, --format string Output format - see lsf help for details (default "p") --hash h Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5") -h, --help help for sync --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file -s, --separator string Separator for the items in the format (default ";") -t, --timeformat string Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05) Options shared with other commands are described next. See the global flags page for global options not listed here. Copy Options Flags for anything which can copy a file --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination Sync Options Flags used for sync commands --backup-dir string Make backups into hierarchy based in DIR --delete-after When synchronizing, delete files on destination after transferring (default) --delete-before When synchronizing, delete files on destination before transferring --delete-during When synchronizing, delete files during transfer --fix-case Force rename of case insensitive dest to match source --ignore-errors Delete even if there are I/O errors --list-cutoff int To save memory, sort directory listings on disk above this threshold (default 1000000) --max-delete int When synchronizing, limit the number of deletes (default -1) --max-delete-size SizeSuffix When synchronizing, limit the total size of deletes (default off) --suffix string Suffix to add to changed files --suffix-keep-extension Preserve the extension when using --suffix --track-renames When synchronizing, track file renames and do a server-side move if possible --track-renames-strategy string Strategies to use when synchronizing using track-renames hash|modtime|leaf (default "hash") Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone move Move files from source to dest. Synopsis Moves the contents of the source directory to the destination directory. Rclone will error if the source and destination overlap and the remote does not support a server-side directory move operation. To move single files, use the moveto command instead. If no filters are in use and if possible this will server-side move source:path into dest:path. After this source:path will no longer exist. Otherwise for each file in source:path selected by the filters (if any) this will move it into dest:path. If possible a server-side move will be used, otherwise it will copy it (server-side if possible) into dest:path then delete the original (if no errors on copy) in source:path. If you want to delete empty source directories after move, use the --delete-empty-src-dirs flag. See the --no-traverse option for controlling whether rclone lists the destination directory or not. Supplying this option when moving a small number of files into a large destination can speed transfers up greatly. Rclone will sync the modification times of files and directories if the backend supports it. If metadata syncing is required then use the --metadata flag. Note that the modification time and metadata for the root directory will not be synced. See https://github.com/rclone/rclone/issues/7652 for more info. Important: Since this can cause data loss, test first with the --dry-run or the --interactive/-i flag. Note: Use the -P/--progress flag to view real-time transfer statistics. Logger Flags The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different. The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - = path means path was found in source and destination and was identical - - path means path was missing on the source, so only in the destination - + path means path was missing on the destination, so only in the source - * path means path was present in source and destination but different. - ! path means there was an error reading or hashing the source or dest. The --dest-after flag writes a list file using the same format flags as lsf (including customizable options for hash, modtime, etc.) Conceptually it is similar to rsync's --itemize-changes, but not identical -- it should output an accurate list of what will be on the destination after the command is finished. When the --no-traverse flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing. Note that these logger flags have a few limitations, and certain scenarios are not currently supported: - --max-duration / CutoffModeHard - --compare-dest / --copy-dest - server-side moves of an entire dir at once - High-level retries, because there would be duplicates (use --retries 1 to disable) - Possibly some unusual error scenarios Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.) rclone move source:path dest:path [flags] Options --absolute Put a leading / in front of path names --combined string Make a combined report of changes to this file --create-empty-src-dirs Create empty source dirs on destination after move --csv Output in CSV format --delete-empty-src-dirs Delete empty source dirs after move --dest-after string Report all files that exist on the dest post-sync --differ string Report all non-matching files to this file -d, --dir-slash Append a slash to directory names (default true) --dirs-only Only list directories --error string Report all files with errors (hashing or reading) to this file --files-only Only list files (default true) -F, --format string Output format - see lsf help for details (default "p") --hash h Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5") -h, --help help for move --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file -s, --separator string Separator for the items in the format (default ";") -t, --timeformat string Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05) Options shared with other commands are described next. See the global flags page for global options not listed here. Copy Options Flags for anything which can copy a file --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone delete Remove the files in path. Synopsis Remove the files in path. Unlike purge it obeys include/exclude filters so can be used to selectively delete files. rclone delete only deletes files but leaves the directory structure alone. If you want to delete a directory and all of its contents use the purge command. If you supply the --rmdirs flag, it will remove all empty directories along with it. You can also use the separate command rmdir or rmdirs to delete empty directories only. For example, to delete all files bigger than 100 MiB, you may first want to check what would be deleted (use either): rclone --min-size 100M lsl remote:path rclone --dry-run --min-size 100M delete remote:path Then proceed with the actual delete: rclone --min-size 100M delete remote:path That reads "delete everything with a minimum size of 100 MiB", hence delete all files bigger than 100 MiB. Important: Since this can cause data loss, test first with the --dry-run or the --interactive/-i flag. rclone delete remote:path [flags] Options -h, --help help for delete --rmdirs rmdirs removes empty directories but leaves root intact Options shared with other commands are described next. See the global flags page for global options not listed here. Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone purge Remove the path and all of its contents. Synopsis Remove the path and all of its contents. Note that this does not obey include/exclude filters - everything will be removed. Use the delete command if you want to selectively delete files. To delete empty directories only, use command rmdir or rmdirs. The concurrency of this operation is controlled by the --checkers global flag. However, some backends will implement this command directly, in which case --checkers will be ignored. Important: Since this can cause data loss, test first with the --dry-run or the --interactive/-i flag. rclone purge remote:path [flags] Options -h, --help help for purge Options shared with other commands are described next. See the global flags page for global options not listed here. Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) See Also - rclone - Show help for rclone commands, flags and backends. rclone mkdir Make the path if it doesn't already exist. rclone mkdir remote:path [flags] Options -h, --help help for mkdir Options shared with other commands are described next. See the global flags page for global options not listed here. Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) See Also - rclone - Show help for rclone commands, flags and backends. rclone rmdir Remove the empty directory at path. Synopsis This removes empty directory given by path. Will not remove the path if it has any objects in it, not even empty subdirectories. Use command rmdirs (or delete with option --rmdirs) to do that. To delete a path and any objects in it, use purge command. rclone rmdir remote:path [flags] Options -h, --help help for rmdir Options shared with other commands are described next. See the global flags page for global options not listed here. Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) See Also - rclone - Show help for rclone commands, flags and backends. rclone check Checks the files in the source and destination match. Synopsis Checks the files in the source and destination match. It compares sizes and hashes (MD5 or SHA1) and logs a report of files that don't match. It doesn't alter the source or destination. For the crypt remote there is a dedicated command, cryptcheck, that are able to check the checksums of the encrypted files. If you supply the --size-only flag, it will only compare the sizes not the hashes as well. Use this for a quick check. If you supply the --download flag, it will download the data from both remotes and check them against each other on the fly. This can be useful for remotes that don't support hashes or if you really want to check all the data. If you supply the --checkfile HASH flag with a valid hash name, the source:path must point to a text file in the SUM format. If you supply the --one-way flag, it will only check that files in the source match the files in the destination, not the other way around. This means that extra files in the destination that are not in the source will not be detected. The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different. The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - = path means path was found in source and destination and was identical - - path means path was missing on the source, so only in the destination - + path means path was missing on the destination, so only in the source - * path means path was present in source and destination but different. - ! path means there was an error reading or hashing the source or dest. The default number of parallel checks is 8. See the --checkers option for more information. rclone check source:path dest:path [flags] Options -C, --checkfile string Treat source:path as a SUM file with hashes of given type --combined string Make a combined report of changes to this file --differ string Report all non-matching files to this file --download Check by downloading rather than with hash --error string Report all files with errors (hashing or reading) to this file -h, --help help for check --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file --one-way Check one way only, source files must exist on remote Options shared with other commands are described next. See the global flags page for global options not listed here. Check Options Flags used for check commands --max-backlog int Maximum number of objects in sync or check backlog (default 10000) Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone ls List the objects in the path with size and path. Synopsis Lists the objects in the source path to standard output in a human readable format with size and path. Recurses by default. Eg $ rclone ls swift:bucket 60295 bevajer5jef 90613 canole 94467 diwogej7 37600 fubuwic Any of the filtering options can be applied to this command. There are several related list commands - ls to list size and path of objects only - lsl to list modification time, size and path of objects only - lsd to list directories only - lsf to list objects and directories in easy to parse format - lsjson to list objects and directories in JSON format ls,lsl,lsd are designed to be human-readable. lsf is designed to be human and machine-readable. lsjson is designed to be machine-readable. Note that ls and lsl recurse by default - use --max-depth 1 to stop the recursion. The other list commands lsd,lsf,lsjson do not recurse by default - use -R to make them recurse. Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes). rclone ls remote:path [flags] Options -h, --help help for ls Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone lsd List all directories/containers/buckets in the path. Synopsis Lists the directories in the source path to standard output. Does not recurse by default. Use the -R flag to recurse. This command lists the total size of the directory (if known, -1 if not), the modification time (if known, the current time if not), the number of objects in the directory (if known, -1 if not) and the name of the directory, Eg $ rclone lsd swift: 494000 2018-04-26 08:43:20 10000 10000files 65 2018-04-26 08:43:20 1 1File Or $ rclone lsd drive:test -1 2016-10-17 17:41:53 -1 1000files -1 2017-01-03 14:40:54 -1 2500files -1 2017-07-08 14:39:28 -1 4000files If you just want the directory names use rclone lsf --dirs-only. Any of the filtering options can be applied to this command. There are several related list commands - ls to list size and path of objects only - lsl to list modification time, size and path of objects only - lsd to list directories only - lsf to list objects and directories in easy to parse format - lsjson to list objects and directories in JSON format ls,lsl,lsd are designed to be human-readable. lsf is designed to be human and machine-readable. lsjson is designed to be machine-readable. Note that ls and lsl recurse by default - use --max-depth 1 to stop the recursion. The other list commands lsd,lsf,lsjson do not recurse by default - use -R to make them recurse. Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes). rclone lsd remote:path [flags] Options -h, --help help for lsd -R, --recursive Recurse into the listing Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone lsl List the objects in path with modification time, size and path. Synopsis Lists the objects in the source path to standard output in a human readable format with modification time, size and path. Recurses by default. Eg $ rclone lsl swift:bucket 60295 2016-06-25 18:55:41.062626927 bevajer5jef 90613 2016-06-25 18:55:43.302607074 canole 94467 2016-06-25 18:55:43.046609333 diwogej7 37600 2016-06-25 18:55:40.814629136 fubuwic Any of the filtering options can be applied to this command. There are several related list commands - ls to list size and path of objects only - lsl to list modification time, size and path of objects only - lsd to list directories only - lsf to list objects and directories in easy to parse format - lsjson to list objects and directories in JSON format ls,lsl,lsd are designed to be human-readable. lsf is designed to be human and machine-readable. lsjson is designed to be machine-readable. Note that ls and lsl recurse by default - use --max-depth 1 to stop the recursion. The other list commands lsd,lsf,lsjson do not recurse by default - use -R to make them recurse. Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes). rclone lsl remote:path [flags] Options -h, --help help for lsl Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone md5sum Produces an md5sum file for all the objects in the path. Synopsis Produces an md5sum file for all the objects in the path. This is in the same format as the standard md5sum tool produces. By default, the hash is requested from the remote. If MD5 is not supported by the remote, no hash will be returned. With the download flag, the file will be downloaded from the remote and hashed locally enabling MD5 for any remote. For other algorithms, see the hashsum command. Running rclone md5sum remote:path is equivalent to running rclone hashsum MD5 remote:path. This command can also hash data received on standard input (stdin), by not passing a remote:path, or by passing a hyphen as remote:path when there is data to read (if not, the hyphen will be treated literally, as a relative path). rclone md5sum remote:path [flags] Options --base64 Output base64 encoded hashsum -C, --checkfile string Validate hashes against a given SUM file instead of printing them --download Download the file and hash it locally; if this flag is not specified, the hash is requested from the remote -h, --help help for md5sum --output-file string Output hashsums to a file rather than the terminal Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone sha1sum Produces an sha1sum file for all the objects in the path. Synopsis Produces an sha1sum file for all the objects in the path. This is in the same format as the standard sha1sum tool produces. By default, the hash is requested from the remote. If SHA-1 is not supported by the remote, no hash will be returned. With the download flag, the file will be downloaded from the remote and hashed locally enabling SHA-1 for any remote. For other algorithms, see the hashsum command. Running rclone sha1sum remote:path is equivalent to running rclone hashsum SHA1 remote:path. This command can also hash data received on standard input (stdin), by not passing a remote:path, or by passing a hyphen as remote:path when there is data to read (if not, the hyphen will be treated literally, as a relative path). This command can also hash data received on STDIN, if not passing a remote:path. rclone sha1sum remote:path [flags] Options --base64 Output base64 encoded hashsum -C, --checkfile string Validate hashes against a given SUM file instead of printing them --download Download the file and hash it locally; if this flag is not specified, the hash is requested from the remote -h, --help help for sha1sum --output-file string Output hashsums to a file rather than the terminal Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone size Prints the total size and number of objects in remote:path. Synopsis Counts objects in the path and calculates the total size. Prints the result to standard output. By default the output is in human-readable format, but shows values in both human-readable format as well as the raw numbers (global option --human-readable is not considered). Use option --json to format output as JSON instead. Recurses by default, use --max-depth 1 to stop the recursion. Some backends do not always provide file sizes, see for example Google Photos and Google Docs. Rclone will then show a notice in the log indicating how many such files were encountered, and count them in as empty files in the output of the size command. rclone size remote:path [flags] Options -h, --help help for size --json Format output as JSON Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone version Show the version number. Synopsis Show the rclone version number, the go version, the build target OS and architecture, the runtime OS and kernel version and bitness, build tags and the type of executable (static or dynamic). For example: $ rclone version rclone v1.55.0 - os/version: ubuntu 18.04 (64 bit) - os/kernel: 4.15.0-136-generic (x86_64) - os/type: linux - os/arch: amd64 - go/version: go1.16 - go/linking: static - go/tags: none Note: before rclone version 1.55 the os/type and os/arch lines were merged, and the "go/version" line was tagged as "go version". If you supply the --check flag, then it will do an online check to compare your version with the latest release and the latest beta. $ rclone version --check yours: 1.42.0.6 latest: 1.42 (released 2018-06-16) beta: 1.42.0.5 (released 2018-06-17) Or $ rclone version --check yours: 1.41 latest: 1.42 (released 2018-06-16) upgrade: https://downloads.rclone.org/v1.42 beta: 1.42.0.5 (released 2018-06-17) upgrade: https://beta.rclone.org/v1.42-005-g56e1e820 If you supply the --deps flag then rclone will print a list of all the packages it depends on and their versions along with some other information about the build. rclone version [flags] Options --check Check for new version --deps Show the Go dependencies -h, --help help for version See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. rclone cleanup Clean up the remote if possible. Synopsis Clean up the remote if possible. Empty the trash or delete old file versions. Not supported by all remotes. rclone cleanup remote:path [flags] Options -h, --help help for cleanup Options shared with other commands are described next. See the global flags page for global options not listed here. Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) See Also - rclone - Show help for rclone commands, flags and backends. rclone dedupe Interactively find duplicate filenames and delete/rename them. Synopsis By default dedupe interactively finds files with duplicate names and offers to delete all but one or rename them to be different. This is known as deduping by name. Deduping by name is only useful with a small group of backends (e.g. Google Drive, Opendrive) that can have duplicate file names. It can be run on wrapping backends (e.g. crypt) if they wrap a backend which supports duplicate file names. However if --by-hash is passed in then dedupe will find files with duplicate hashes instead which will work on any backend which supports at least one hash. This can be used to find files with duplicate content. This is known as deduping by hash. If deduping by name, first rclone will merge directories with the same name. It will do this iteratively until all the identically named directories have been merged. Next, if deduping by name, for every group of duplicate file names / hashes, it will delete all but one identical file it finds without confirmation. This means that for most duplicated files the dedupe command will not be interactive. dedupe considers files to be identical if they have the same file path and the same hash. If the backend does not support hashes (e.g. crypt wrapping Google Drive) then they will never be found to be identical. If you use the --size-only flag then files will be considered identical if they have the same size (any hash will be ignored). This can be useful on crypt backends which do not support hashes. Next rclone will resolve the remaining duplicates. Exactly which action is taken depends on the dedupe mode. By default, rclone will interactively query the user for each one. Important: Since this can cause data loss, test first with the --dry-run or the --interactive/-i flag. Here is an example run. Before - with duplicates $ rclone lsl drive:dupes 6048320 2016-03-05 16:23:16.798000000 one.txt 6048320 2016-03-05 16:23:11.775000000 one.txt 564374 2016-03-05 16:23:06.731000000 one.txt 6048320 2016-03-05 16:18:26.092000000 one.txt 6048320 2016-03-05 16:22:46.185000000 two.txt 1744073 2016-03-05 16:22:38.104000000 two.txt 564374 2016-03-05 16:22:52.118000000 two.txt Now the dedupe session $ rclone dedupe drive:dupes 2016/03/05 16:24:37 Google drive root 'dupes': Looking for duplicates using interactive mode. one.txt: Found 4 files with duplicate names one.txt: Deleting 2/3 identical duplicates (MD5 "1eedaa9fe86fd4b8632e2ac549403b36") one.txt: 2 duplicates remain 1: 6048320 bytes, 2016-03-05 16:23:16.798000000, MD5 1eedaa9fe86fd4b8632e2ac549403b36 2: 564374 bytes, 2016-03-05 16:23:06.731000000, MD5 7594e7dc9fc28f727c42ee3e0749de81 s) Skip and do nothing k) Keep just one (choose which in next step) r) Rename all to be different (by changing file.jpg to file-1.jpg) s/k/r> k Enter the number of the file to keep> 1 one.txt: Deleted 1 extra copies two.txt: Found 3 files with duplicate names two.txt: 3 duplicates remain 1: 564374 bytes, 2016-03-05 16:22:52.118000000, MD5 7594e7dc9fc28f727c42ee3e0749de81 2: 6048320 bytes, 2016-03-05 16:22:46.185000000, MD5 1eedaa9fe86fd4b8632e2ac549403b36 3: 1744073 bytes, 2016-03-05 16:22:38.104000000, MD5 851957f7fb6f0bc4ce76be966d336802 s) Skip and do nothing k) Keep just one (choose which in next step) r) Rename all to be different (by changing file.jpg to file-1.jpg) s/k/r> r two-1.txt: renamed from: two.txt two-2.txt: renamed from: two.txt two-3.txt: renamed from: two.txt The result being $ rclone lsl drive:dupes 6048320 2016-03-05 16:23:16.798000000 one.txt 564374 2016-03-05 16:22:52.118000000 two-1.txt 6048320 2016-03-05 16:22:46.185000000 two-2.txt 1744073 2016-03-05 16:22:38.104000000 two-3.txt Dedupe can be run non interactively using the --dedupe-mode flag or by using an extra parameter with the same value - --dedupe-mode interactive - interactive as above. - --dedupe-mode skip - removes identical files then skips anything left. - --dedupe-mode first - removes identical files then keeps the first one. - --dedupe-mode newest - removes identical files then keeps the newest one. - --dedupe-mode oldest - removes identical files then keeps the oldest one. - --dedupe-mode largest - removes identical files then keeps the largest one. - --dedupe-mode smallest - removes identical files then keeps the smallest one. - --dedupe-mode rename - removes identical files then renames the rest to be different. - --dedupe-mode list - lists duplicate dirs and files only and changes nothing. For example, to rename all the identically named photos in your Google Photos directory, do rclone dedupe --dedupe-mode rename "drive:Google Photos" Or rclone dedupe rename "drive:Google Photos" rclone dedupe [mode] remote:path [flags] Options --by-hash Find identical hashes rather than names --dedupe-mode string Dedupe mode interactive|skip|first|newest|oldest|largest|smallest|rename (default "interactive") -h, --help help for dedupe Options shared with other commands are described next. See the global flags page for global options not listed here. Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) See Also - rclone - Show help for rclone commands, flags and backends. rclone about Get quota information from the remote. Synopsis Prints quota information about a remote to standard output. The output is typically used, free, quota and trash contents. E.g. Typical output from rclone about remote: is: Total: 17 GiB Used: 7.444 GiB Free: 1.315 GiB Trashed: 100.000 MiB Other: 8.241 GiB Where the fields are: - Total: Total size available. - Used: Total size used. - Free: Total space available to this user. - Trashed: Total space used by trash. - Other: Total amount in other storage (e.g. Gmail, Google Photos). - Objects: Total number of objects in the storage. All sizes are in number of bytes. Applying a --full flag to the command prints the bytes in full, e.g. Total: 18253611008 Used: 7993453766 Free: 1411001220 Trashed: 104857602 Other: 8849156022 A --json flag generates conveniently machine-readable output, e.g. { "total": 18253611008, "used": 7993453766, "trashed": 104857602, "other": 8849156022, "free": 1411001220 } Not all backends print all fields. Information is not included if it is not provided by a backend. Where the value is unlimited it is omitted. Some backends does not support the rclone about command at all, see complete list in documentation. rclone about remote: [flags] Options --full Full numbers instead of human-readable -h, --help help for about --json Format output as JSON See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. rclone authorize Remote authorization. Synopsis Remote authorization. Used to authorize a remote or headless rclone from a machine with a browser - use as instructed by rclone config. The command requires 1-3 arguments: - fs name (e.g., "drive", "s3", etc.) - Either a base64 encoded JSON blob obtained from a previous rclone config session - Or a client_id and client_secret pair obtained from the remote service Use --auth-no-open-browser to prevent rclone to open auth link in default browser automatically. Use --template to generate HTML output via a custom Go template. If a blank string is provided as an argument to this flag, the default template is used. rclone authorize [base64_json_blob | client_id client_secret] [flags] Options --auth-no-open-browser Do not automatically open auth link in default browser -h, --help help for authorize --template string The path to a custom Go template for generating HTML responses See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. rclone backend Run a backend-specific command. Synopsis This runs a backend-specific command. The commands themselves (except for "help" and "features") are defined by the backends and you should see the backend docs for definitions. You can discover what commands a backend implements by using rclone backend help remote: rclone backend help You can also discover information about the backend using (see operations/fsinfo in the remote control docs for more info). rclone backend features remote: Pass options to the backend command with -o. This should be key=value or key, e.g.: rclone backend stats remote:path stats -o format=json -o long Pass arguments to the backend by placing them on the end of the line rclone backend cleanup remote:path file1 file2 file3 Note to run these commands on a running backend then see backend/command in the rc docs. rclone backend remote:path [opts] [flags] Options -h, --help help for backend --json Always output in JSON format -o, --option stringArray Option in the form name=value or name Options shared with other commands are described next. See the global flags page for global options not listed here. Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) See Also - rclone - Show help for rclone commands, flags and backends. rclone bisync Perform bidirectional synchronization between two paths. Synopsis Perform bidirectional synchronization between two paths. Bisync provides a bidirectional cloud sync solution in rclone. It retains the Path1 and Path2 filesystem listings from the prior run. On each successive run it will: - list files on Path1 and Path2, and check for changes on each side. Changes include New, Newer, Older, and Deleted files. - Propagate changes on Path1 to Path2, and vice-versa. Bisync is considered an advanced command, so use with care. Make sure you have read and understood the entire manual (especially the Limitations section) before using, or data loss can result. Questions can be asked in the Rclone Forum. See full bisync description for details. rclone bisync remote1:path1 remote2:path2 [flags] Options --backup-dir1 string --backup-dir for Path1. Must be a non-overlapping path on the same remote. --backup-dir2 string --backup-dir for Path2. Must be a non-overlapping path on the same remote. --check-access Ensure expected RCLONE_TEST files are found on both Path1 and Path2 filesystems, else abort. --check-filename string Filename for --check-access (default: RCLONE_TEST) --check-sync string Controls comparison of final listings: true|false|only (default: true) (default "true") --compare string Comma-separated list of bisync-specific compare options ex. 'size,modtime,checksum' (default: 'size,modtime') --conflict-loser ConflictLoserAction Action to take on the loser of a sync conflict (when there is a winner) or on both files (when there is no winner): , num, pathname, delete (default: num) --conflict-resolve string Automatically resolve conflicts by preferring the version that is: none, path1, path2, newer, older, larger, smaller (default: none) (default "none") --conflict-suffix string Suffix to use when renaming a --conflict-loser. Can be either one string or two comma-separated strings to assign different suffixes to Path1/Path2. (default: 'conflict') --create-empty-src-dirs Sync creation and deletion of empty directories. (Not compatible with --remove-empty-dirs) --download-hash Compute hash by downloading when otherwise unavailable. (warning: may be slow and use lots of data!) --filters-file string Read filtering patterns from a file --force Bypass --max-delete safety check and run the sync. Consider using with --verbose -h, --help help for bisync --ignore-listing-checksum Do not use checksums for listings (add --ignore-checksum to additionally skip post-copy checksum checks) --max-lock Duration Consider lock files older than this to be expired (default: 0 (never expire)) (minimum: 2m) (default 0s) --no-cleanup Retain working files (useful for troubleshooting and testing). --no-slow-hash Ignore listing checksums only on backends where they are slow --recover Automatically recover from interruptions without requiring --resync. --remove-empty-dirs Remove ALL empty directories at the final cleanup step. --resilient Allow future runs to retry after certain less-serious errors, instead of requiring --resync. -1, --resync Performs the resync run. Equivalent to --resync-mode path1. Consider using --verbose or --dry-run first. --resync-mode string During resync, prefer the version that is: path1, path2, newer, older, larger, smaller (default: path1 if --resync, otherwise none for no resync.) (default "none") --slow-hash-sync-only Ignore slow checksums for listings and deltas, but still consider them during sync calls. --workdir string Use custom working dir - useful for testing. (default: {WORKDIR}) Options shared with other commands are described next. See the global flags page for global options not listed here. Copy Options Flags for anything which can copy a file --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) See Also - rclone - Show help for rclone commands, flags and backends. rclone cat Concatenates any files and sends them to stdout. Synopsis Sends any files to standard output. You can use it like this to output a single file rclone cat remote:path/to/file Or like this to output any file in dir or its subdirectories. rclone cat remote:path/to/dir Or like this to output any .txt files in dir or its subdirectories. rclone --include "*.txt" cat remote:path/to/dir Use the --head flag to print characters only at the start, --tail for the end and --offset and --count to print a section in the middle. Note that if offset is negative it will count from the end, so --offset -1 --count 1 is equivalent to --tail 1. Use the --separator flag to print a separator value between files. Be sure to shell-escape special characters. For example, to print a newline between files, use: - bash: rclone --include "*.txt" --separator $'\n' cat remote:path/to/dir - powershell: rclone --include "*.txt" --separator "`n" cat remote:path/to/dir rclone cat remote:path [flags] Options --count int Only print N characters (default -1) --discard Discard the output instead of printing --head int Only print the first N characters -h, --help help for cat --offset int Start printing at offset N (or from end if -ve) --separator string Separator to use between objects when printing multiple files --tail int Only print the last N characters Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone checksum Checks the files in the destination against a SUM file. Synopsis Checks that hashsums of destination files match the SUM file. It compares hashes (MD5, SHA1, etc) and logs a report of files which don't match. It doesn't alter the file system. The sumfile is treated as the source and the dst:path is treated as the destination for the purposes of the output. If you supply the --download flag, it will download the data from the remote and calculate the content hash on the fly. This can be useful for remotes that don't support hashes or if you really want to check all the data. Note that hash values in the SUM file are treated as case insensitive. If you supply the --one-way flag, it will only check that files in the source match the files in the destination, not the other way around. This means that extra files in the destination that are not in the source will not be detected. The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different. The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - = path means path was found in source and destination and was identical - - path means path was missing on the source, so only in the destination - + path means path was missing on the destination, so only in the source - * path means path was present in source and destination but different. - ! path means there was an error reading or hashing the source or dest. The default number of parallel checks is 8. See the --checkers option for more information. rclone checksum sumfile dst:path [flags] Options --combined string Make a combined report of changes to this file --differ string Report all non-matching files to this file --download Check by hashing the contents --error string Report all files with errors (hashing or reading) to this file -h, --help help for checksum --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file --one-way Check one way only, source files must exist on remote Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone completion Output completion script for a given shell. Synopsis Generates a shell completion script for rclone. Run with --help to list the supported shells. Options -h, --help help for completion See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. - rclone completion bash - Output bash completion script for rclone. - rclone completion fish - Output fish completion script for rclone. - rclone completion powershell - Output powershell completion script for rclone. - rclone completion zsh - Output zsh completion script for rclone. rclone completion bash Output bash completion script for rclone. Synopsis Generates a bash shell autocompletion script for rclone. By default, when run without any arguments, rclone completion bash the generated script will be written to /etc/bash_completion.d/rclone and so rclone will probably need to be run as root, or with sudo. If you supply a path to a file as the command line argument, then the generated script will be written to that file, in which case you should not need root privileges. If output_file is "-", then the output will be written to stdout. If you have installed the script into the default location, you can logout and login again to use the autocompletion script. Alternatively, you can source the script directly . /path/to/my_bash_completion_scripts/rclone and the autocompletion functionality will be added to your current shell. rclone completion bash [output_file] [flags] Options -h, --help help for bash See the global flags page for global options not listed here. See Also - rclone completion - Output completion script for a given shell. rclone completion fish Output fish completion script for rclone. Synopsis Generates a fish autocompletion script for rclone. This writes to /etc/fish/completions/rclone.fish by default so will probably need to be run with sudo or as root, e.g. sudo rclone completion fish Logout and login again to use the autocompletion scripts, or source them directly . /etc/fish/completions/rclone.fish If you supply a command line argument the script will be written there. If output_file is "-", then the output will be written to stdout. rclone completion fish [output_file] [flags] Options -h, --help help for fish See the global flags page for global options not listed here. See Also - rclone completion - Output completion script for a given shell. rclone completion powershell Output powershell completion script for rclone. Synopsis Generate the autocompletion script for powershell. To load completions in your current shell session: rclone completion powershell | Out-String | Invoke-Expression To load completions for every new session, add the output of the above command to your powershell profile. If output_file is "-" or missing, then the output will be written to stdout. rclone completion powershell [output_file] [flags] Options -h, --help help for powershell See the global flags page for global options not listed here. See Also - rclone completion - Output completion script for a given shell. rclone completion zsh Output zsh completion script for rclone. Synopsis Generates a zsh autocompletion script for rclone. This writes to /usr/share/zsh/vendor-completions/_rclone by default so will probably need to be run with sudo or as root, e.g. sudo rclone completion zsh Logout and login again to use the autocompletion scripts, or source them directly autoload -U compinit && compinit If you supply a command line argument the script will be written there. If output_file is "-", then the output will be written to stdout. rclone completion zsh [output_file] [flags] Options -h, --help help for zsh See the global flags page for global options not listed here. See Also - rclone completion - Output completion script for a given shell. rclone config create Create a new remote with name, type and options. Synopsis Create a new remote of name with type and options. The options should be passed in pairs of key value or as key=value. For example, to make a swift remote of name myremote using auto config you would do: rclone config create myremote swift env_auth true rclone config create myremote swift env_auth=true So for example if you wanted to configure a Google Drive remote but using remote authorization you would do this: rclone config create mydrive drive config_is_local=false Note that if the config process would normally ask a question the default is taken (unless --non-interactive is used). Each time that happens rclone will print or DEBUG a message saying how to affect the value taken. If any of the parameters passed is a password field, then rclone will automatically obscure them if they aren't already obscured before putting them in the config file. NB If the password parameter is 22 characters or longer and consists only of base64 characters then rclone can get confused about whether the password is already obscured or not and put unobscured passwords into the config file. If you want to be 100% certain that the passwords get obscured then use the --obscure flag, or if you are 100% certain you are already passing obscured passwords then use --no-obscure. You can also set obscured passwords using the rclone config password command. The flag --non-interactive is for use by applications that wish to configure rclone themselves, rather than using rclone's text based configuration questions. If this flag is set, and rclone needs to ask the user a question, a JSON blob will be returned with the question in it. This will look something like (some irrelevant detail removed): { "State": "*oauth-islocal,teamdrive,,", "Option": { "Name": "config_is_local", "Help": "Use web browser to automatically authenticate rclone with remote?\n * Say Y if the machine running rclone has a web browser you can use\n * Say N if running rclone on a (remote) machine without web browser access\nIf not sure try Y. If Y failed, try N.\n", "Default": true, "Examples": [ { "Value": "true", "Help": "Yes" }, { "Value": "false", "Help": "No" } ], "Required": false, "IsPassword": false, "Type": "bool", "Exclusive": true, }, "Error": "", } The format of Option is the same as returned by rclone config providers. The question should be asked to the user and returned to rclone as the --result option along with the --state parameter. The keys of Option are used as follows: - Name - name of variable - show to user - Help - help text. Hard wrapped at 80 chars. Any URLs should be clicky. - Default - default value - return this if the user just wants the default. - Examples - the user should be able to choose one of these - Required - the value should be non-empty - IsPassword - the value is a password and should be edited as such - Type - type of value, eg bool, string, int and others - Exclusive - if set no free-form entry allowed only the Examples - Irrelevant keys Provider, ShortOpt, Hide, NoPrefix, Advanced If Error is set then it should be shown to the user at the same time as the question. rclone config update name --continue --state "*oauth-islocal,teamdrive,," --result "true" Note that when using --continue all passwords should be passed in the clear (not obscured). Any default config values should be passed in with each invocation of --continue. At the end of the non interactive process, rclone will return a result with State as empty string. If --all is passed then rclone will ask all the config questions, not just the post config questions. Any parameters are used as defaults for questions as usual. Note that bin/config.py in the rclone source implements this protocol as a readable demonstration. rclone config create name type [key value]* [flags] Options --all Ask the full set of config questions --continue Continue the configuration process with an answer -h, --help help for create --no-obscure Force any passwords not to be obscured --no-output Don't provide any output --non-interactive Don't interact with user and return questions --obscure Force any passwords to be obscured --result string Result - use with --continue --state string State - use with --continue See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config delete Delete an existing remote. rclone config delete name [flags] Options -h, --help help for delete See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config disconnect Disconnects user from remote Synopsis This disconnects the remote: passed in to the cloud storage system. This normally means revoking the oauth token. To reconnect use "rclone config reconnect". rclone config disconnect remote: [flags] Options -h, --help help for disconnect See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config dump Dump the config file as JSON. rclone config dump [flags] Options -h, --help help for dump See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config edit Enter an interactive configuration session. Synopsis Enter an interactive configuration session where you can setup new remotes and manage existing ones. You may also set or remove a password to protect your configuration. rclone config edit [flags] Options -h, --help help for edit See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config encryption set, remove and check the encryption for the config file Synopsis This command sets, clears and checks the encryption for the config file using the subcommands below. Options -h, --help help for encryption See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. - rclone config encryption check - Check that the config file is encrypted - rclone config encryption remove - Remove the config file encryption password - rclone config encryption set - Set or change the config file encryption password rclone config encryption check Check that the config file is encrypted Synopsis This checks the config file is encrypted and that you can decrypt it. It will attempt to decrypt the config using the password you supply. If decryption fails it will return a non-zero exit code if using --password-command, otherwise it will prompt again for the password. If the config file is not encrypted it will return a non zero exit code. rclone config encryption check [flags] Options -h, --help help for check See the global flags page for global options not listed here. See Also - rclone config encryption - set, remove and check the encryption for the config file rclone config encryption remove Remove the config file encryption password Synopsis Remove the config file encryption password This removes the config file encryption, returning it to un-encrypted. If --password-command is in use, this will be called to supply the old config password. If the config was not encrypted then no error will be returned and this command will do nothing. rclone config encryption remove [flags] Options -h, --help help for remove See the global flags page for global options not listed here. See Also - rclone config encryption - set, remove and check the encryption for the config file rclone config encryption set Set or change the config file encryption password Synopsis This command sets or changes the config file encryption password. If there was no config password set then it sets a new one, otherwise it changes the existing config password. Note that if you are changing an encryption password using --password-command then this will be called once to decrypt the config using the old password and then again to read the new password to re-encrypt the config. When --password-command is called to change the password then the environment variable RCLONE_PASSWORD_CHANGE=1 will be set. So if changing passwords programmatically you can use the environment variable to distinguish which password you must supply. Alternatively you can remove the password first (with rclone config encryption remove), then set it again with this command which may be easier if you don't mind the unencrypted config file being on the disk briefly. rclone config encryption set [flags] Options -h, --help help for set See the global flags page for global options not listed here. See Also - rclone config encryption - set, remove and check the encryption for the config file rclone config file Show path of configuration file in use. rclone config file [flags] Options -h, --help help for file See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config password Update password in an existing remote. Synopsis Update an existing remote's password. The password should be passed in pairs of key password or as key=password. The password should be passed in in clear (unobscured). For example, to set password of a remote of name myremote you would do: rclone config password myremote fieldname mypassword rclone config password myremote fieldname=mypassword This command is obsolete now that "config update" and "config create" both support obscuring passwords directly. rclone config password name [key value]+ [flags] Options -h, --help help for password See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config paths Show paths used for configuration, cache, temp etc. rclone config paths [flags] Options -h, --help help for paths See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config providers List in JSON format all the providers and options. rclone config providers [flags] Options -h, --help help for providers See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config reconnect Re-authenticates user with remote. Synopsis This reconnects remote: passed in to the cloud storage system. To disconnect the remote use "rclone config disconnect". This normally means going through the interactive oauth flow again. rclone config reconnect remote: [flags] Options -h, --help help for reconnect See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config redacted Print redacted (decrypted) config file, or the redacted config for a single remote. Synopsis This prints a redacted copy of the config file, either the whole config file or for a given remote. The config file will be redacted by replacing all passwords and other sensitive info with XXX. This makes the config file suitable for posting online for support. It should be double checked before posting as the redaction may not be perfect. rclone config redacted [] [flags] Options -h, --help help for redacted See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config show Print (decrypted) config file, or the config for a single remote. rclone config show [] [flags] Options -h, --help help for show See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config touch Ensure configuration file exists. rclone config touch [flags] Options -h, --help help for touch See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config update Update options in an existing remote. Synopsis Update an existing remote's options. The options should be passed in pairs of key value or as key=value. For example, to update the env_auth field of a remote of name myremote you would do: rclone config update myremote env_auth true rclone config update myremote env_auth=true If the remote uses OAuth the token will be updated, if you don't require this add an extra parameter thus: rclone config update myremote env_auth=true config_refresh_token=false Note that if the config process would normally ask a question the default is taken (unless --non-interactive is used). Each time that happens rclone will print or DEBUG a message saying how to affect the value taken. If any of the parameters passed is a password field, then rclone will automatically obscure them if they aren't already obscured before putting them in the config file. NB If the password parameter is 22 characters or longer and consists only of base64 characters then rclone can get confused about whether the password is already obscured or not and put unobscured passwords into the config file. If you want to be 100% certain that the passwords get obscured then use the --obscure flag, or if you are 100% certain you are already passing obscured passwords then use --no-obscure. You can also set obscured passwords using the rclone config password command. The flag --non-interactive is for use by applications that wish to configure rclone themselves, rather than using rclone's text based configuration questions. If this flag is set, and rclone needs to ask the user a question, a JSON blob will be returned with the question in it. This will look something like (some irrelevant detail removed): { "State": "*oauth-islocal,teamdrive,,", "Option": { "Name": "config_is_local", "Help": "Use web browser to automatically authenticate rclone with remote?\n * Say Y if the machine running rclone has a web browser you can use\n * Say N if running rclone on a (remote) machine without web browser access\nIf not sure try Y. If Y failed, try N.\n", "Default": true, "Examples": [ { "Value": "true", "Help": "Yes" }, { "Value": "false", "Help": "No" } ], "Required": false, "IsPassword": false, "Type": "bool", "Exclusive": true, }, "Error": "", } The format of Option is the same as returned by rclone config providers. The question should be asked to the user and returned to rclone as the --result option along with the --state parameter. The keys of Option are used as follows: - Name - name of variable - show to user - Help - help text. Hard wrapped at 80 chars. Any URLs should be clicky. - Default - default value - return this if the user just wants the default. - Examples - the user should be able to choose one of these - Required - the value should be non-empty - IsPassword - the value is a password and should be edited as such - Type - type of value, eg bool, string, int and others - Exclusive - if set no free-form entry allowed only the Examples - Irrelevant keys Provider, ShortOpt, Hide, NoPrefix, Advanced If Error is set then it should be shown to the user at the same time as the question. rclone config update name --continue --state "*oauth-islocal,teamdrive,," --result "true" Note that when using --continue all passwords should be passed in the clear (not obscured). Any default config values should be passed in with each invocation of --continue. At the end of the non interactive process, rclone will return a result with State as empty string. If --all is passed then rclone will ask all the config questions, not just the post config questions. Any parameters are used as defaults for questions as usual. Note that bin/config.py in the rclone source implements this protocol as a readable demonstration. rclone config update name [key value]+ [flags] Options --all Ask the full set of config questions --continue Continue the configuration process with an answer -h, --help help for update --no-obscure Force any passwords not to be obscured --no-output Don't provide any output --non-interactive Don't interact with user and return questions --obscure Force any passwords to be obscured --result string Result - use with --continue --state string State - use with --continue See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone config userinfo Prints info about logged in user of remote. Synopsis This prints the details of the person logged in to the cloud storage system. rclone config userinfo remote: [flags] Options -h, --help help for userinfo --json Format output as JSON See the global flags page for global options not listed here. See Also - rclone config - Enter an interactive configuration session. rclone convmv Convert file and directory names in place. Synopsis convmv supports advanced path name transformations for converting and renaming files and directories by applying prefixes, suffixes, and other alterations. --------------------------------------------------------------------------------------------- Command Description --------------------------------------------------------- ----------------------------------- --name-transform prefix=XXXX Prepends XXXX to the file name. --name-transform suffix=XXXX Appends XXXX to the file name after the extension. --name-transform suffix_keep_extension=XXXX Appends XXXX to the file name while preserving the original file extension. --name-transform trimprefix=XXXX Removes XXXX if it appears at the start of the file name. --name-transform trimsuffix=XXXX Removes XXXX if it appears at the end of the file name. --name-transform regex=/pattern/replacement/ Applies a regex-based transformation. --name-transform replace=old:new Replaces occurrences of old with new in the file name. --name-transform date={YYYYMMDD} Appends or prefixes the specified date format. --name-transform truncate=N Truncates the file name to a maximum of N characters. --name-transform base64encode Encodes the file name in Base64. --name-transform base64decode Decodes a Base64-encoded file name. --name-transform encoder=ENCODING Converts the file name to the specified encoding (e.g., ISO-8859-1, Windows-1252, Macintosh). --name-transform decoder=ENCODING Decodes the file name from the specified encoding. --name-transform charmap=MAP Applies a character mapping transformation. --name-transform lowercase Converts the file name to lowercase. --name-transform uppercase Converts the file name to UPPERCASE. --name-transform titlecase Converts the file name to Title Case. --name-transform ascii Strips non-ASCII characters. --name-transform url URL-encodes the file name. --name-transform nfc Converts the file name to NFC Unicode normalization form. --name-transform nfd Converts the file name to NFD Unicode normalization form. --name-transform nfkc Converts the file name to NFKC Unicode normalization form. --name-transform nfkd Converts the file name to NFKD Unicode normalization form. --name-transform command=/path/to/my/programfile names. Executes an external program to transform --------------------------------------------------------------------------------------------- Conversion modes: none nfc nfd nfkc nfkd replace prefix suffix suffix_keep_extension trimprefix trimsuffix index date truncate base64encode base64decode encoder decoder ISO-8859-1 Windows-1252 Macintosh charmap lowercase uppercase titlecase ascii url regex command Char maps: IBM-Code-Page-037 IBM-Code-Page-437 IBM-Code-Page-850 IBM-Code-Page-852 IBM-Code-Page-855 Windows-Code-Page-858 IBM-Code-Page-860 IBM-Code-Page-862 IBM-Code-Page-863 IBM-Code-Page-865 IBM-Code-Page-866 IBM-Code-Page-1047 IBM-Code-Page-1140 ISO-8859-1 ISO-8859-2 ISO-8859-3 ISO-8859-4 ISO-8859-5 ISO-8859-6 ISO-8859-7 ISO-8859-8 ISO-8859-9 ISO-8859-10 ISO-8859-13 ISO-8859-14 ISO-8859-15 ISO-8859-16 KOI8-R KOI8-U Macintosh Macintosh-Cyrillic Windows-874 Windows-1250 Windows-1251 Windows-1252 Windows-1253 Windows-1254 Windows-1255 Windows-1256 Windows-1257 Windows-1258 X-User-Defined Encoding masks: Asterisk BackQuote BackSlash Colon CrLf Ctl Del Dollar Dot DoubleQuote Exclamation Hash InvalidUtf8 LeftCrLfHtVt LeftPeriod LeftSpace LeftTilde LtGt None Percent Pipe Question Raw RightCrLfHtVt RightPeriod RightSpace Semicolon SingleQuote Slash SquareBracket Examples: rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,uppercase" // Output: STORIES/THE QUICK BROWN FOX!.TXT rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,replace=Fox:Turtle" --name-transform "all,replace=Quick:Slow" // Output: stories/The Slow Brown Turtle!.txt rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,base64encode" // Output: c3Rvcmllcw==/VGhlIFF1aWNrIEJyb3duIEZveCEudHh0 rclone convmv "c3Rvcmllcw==/VGhlIFF1aWNrIEJyb3duIEZveCEudHh0" --name-transform "all,base64decode" // Output: stories/The Quick Brown Fox!.txt rclone convmv "stories/The Quick Brown 🦊 Fox Went to the Café!.txt" --name-transform "all,nfc" // Output: stories/The Quick Brown 🦊 Fox Went to the Café!.txt rclone convmv "stories/The Quick Brown 🦊 Fox Went to the Café!.txt" --name-transform "all,nfd" // Output: stories/The Quick Brown 🦊 Fox Went to the Café!.txt rclone convmv "stories/The Quick Brown 🦊 Fox!.txt" --name-transform "all,ascii" // Output: stories/The Quick Brown Fox!.txt rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,trimsuffix=.txt" // Output: stories/The Quick Brown Fox! rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,prefix=OLD_" // Output: OLD_stories/OLD_The Quick Brown Fox!.txt rclone convmv "stories/The Quick Brown 🦊 Fox Went to the Café!.txt" --name-transform "all,charmap=ISO-8859-7" // Output: stories/The Quick Brown _ Fox Went to the Caf_!.txt rclone convmv "stories/The Quick Brown Fox: A Memoir [draft].txt" --name-transform "all,encoder=Colon,SquareBracket" // Output: stories/The Quick Brown Fox： A Memoir ［draft］.txt rclone convmv "stories/The Quick Brown 🦊 Fox Went to the Café!.txt" --name-transform "all,truncate=21" // Output: stories/The Quick Brown 🦊 Fox rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,command=echo" // Output: stories/The Quick Brown Fox!.txt rclone convmv "stories/The Quick Brown Fox!" --name-transform "date=-{YYYYMMDD}" // Output: stories/The Quick Brown Fox!-20250618 rclone convmv "stories/The Quick Brown Fox!" --name-transform "date=-{macfriendlytime}" // Output: stories/The Quick Brown Fox!-2025-06-18 0148PM rclone convmv "stories/The Quick Brown Fox!.txt" --name-transform "all,regex=[\\.\\w]/ab" // Output: ababababababab/ababab ababababab ababababab ababab!abababab Multiple transformations can be used in sequence, applied in the order they are specified on the command line. The --name-transform flag is also available in sync, copy, and move. Files vs Directories By default --name-transform will only apply to file names. The means only the leaf file name will be transformed. However some of the transforms would be better applied to the whole path or just directories. To choose which which part of the file path is affected some tags can be added to the --name-transform. ----------------------------------------------------------------------- Tag Effect ----------------------------------- ----------------------------------- file Only transform the leaf name of files (DEFAULT) dir Only transform name of directories - these may appear anywhere in the path all Transform the entire path for files and directories ----------------------------------------------------------------------- This is used by adding the tag into the transform name like this: --name-transform file,prefix=ABC or --name-transform dir,prefix=DEF. For some conversions using all is more likely to be useful, for example --name-transform all,nfc. Note that --name-transform may not add path separators / to the name. This will cause an error. Ordering and Conflicts - Transformations will be applied in the order specified by the user. - If the file tag is in use (the default) then only the leaf name of files will be transformed. - If the dir tag is in use then directories anywhere in the path will be transformed - If the all tag is in use then directories and files anywhere in the path will be transformed - Each transformation will be run one path segment at a time. - If a transformation adds a / or ends up with an empty path segment then that will be an error. - It is up to the user to put the transformations in a sensible order. - Conflicting transformations, such as prefix followed by trimprefix or nfc followed by nfd, are possible. - Instead of enforcing mutual exclusivity, transformations are applied in sequence as specified by the user, allowing for intentional use cases (e.g., trimming one prefix before adding another). - Users should be aware that certain combinations may lead to unexpected results and should verify transformations using --dry-run before execution. Race Conditions and Non-Deterministic Behavior Some transformations, such as replace=old:new, may introduce conflicts where multiple source files map to the same destination name. This can lead to race conditions when performing concurrent transfers. It is up to the user to anticipate these. * If two files from the source are transformed into the same name at the destination, the final state may be non-deterministic. * Running rclone check after a sync using such transformations may erroneously report missing or differing files due to overwritten results. To minimize risks, users should: * Carefully review transformations that may introduce conflicts. * Use --dry-run to inspect changes before executing a sync (but keep in mind that it won't show the effect of non-deterministic transformations). * Avoid transformations that cause multiple distinct source files to map to the same destination name. * Consider disabling concurrency with --transfers=1 if necessary. * Certain transformations (e.g. prefix) will have a multiplying effect every time they are used. Avoid these when using bisync. rclone convmv dest:path --name-transform XXX [flags] Options --create-empty-src-dirs Create empty source dirs on destination after move --delete-empty-src-dirs Delete empty source dirs after move -h, --help help for convmv Options shared with other commands are described next. See the global flags page for global options not listed here. Copy Options Flags for anything which can copy a file --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone copyto Copy files from source to dest, skipping identical files. Synopsis If source:path is a file or directory then it copies it to a file or directory named dest:path. This can be used to upload single files to other than their current name. If the source is a directory then it acts exactly like the copy command. So rclone copyto src dst where src and dst are rclone paths, either remote:path or /path/to/local or C:. This will: if src is file copy it to dst, overwriting an existing file if it exists if src is directory copy it to dst, overwriting existing files if they exist see copy command for full details This doesn't transfer files that are identical on src and dst, testing by size and modification time or MD5SUM. It doesn't delete files from the destination. If you are looking to copy just a byte range of a file, please see 'rclone cat --offset X --count Y' Note: Use the -P/--progress flag to view real-time transfer statistics Logger Flags The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different. The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - = path means path was found in source and destination and was identical - - path means path was missing on the source, so only in the destination - + path means path was missing on the destination, so only in the source - * path means path was present in source and destination but different. - ! path means there was an error reading or hashing the source or dest. The --dest-after flag writes a list file using the same format flags as lsf (including customizable options for hash, modtime, etc.) Conceptually it is similar to rsync's --itemize-changes, but not identical -- it should output an accurate list of what will be on the destination after the command is finished. When the --no-traverse flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing. Note that these logger flags have a few limitations, and certain scenarios are not currently supported: - --max-duration / CutoffModeHard - --compare-dest / --copy-dest - server-side moves of an entire dir at once - High-level retries, because there would be duplicates (use --retries 1 to disable) - Possibly some unusual error scenarios Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.) rclone copyto source:path dest:path [flags] Options --absolute Put a leading / in front of path names --combined string Make a combined report of changes to this file --csv Output in CSV format --dest-after string Report all files that exist on the dest post-sync --differ string Report all non-matching files to this file -d, --dir-slash Append a slash to directory names (default true) --dirs-only Only list directories --error string Report all files with errors (hashing or reading) to this file --files-only Only list files (default true) -F, --format string Output format - see lsf help for details (default "p") --hash h Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5") -h, --help help for copyto --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file -s, --separator string Separator for the items in the format (default ";") -t, --timeformat string Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05) Options shared with other commands are described next. See the global flags page for global options not listed here. Copy Options Flags for anything which can copy a file --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone copyurl Copy the contents of the URL supplied content to dest:path. Synopsis Download a URL's content and copy it to the destination without saving it in temporary storage. Setting --auto-filename will attempt to automatically determine the filename from the URL (after any redirections) and used in the destination path. With --header-filename in addition, if a specific filename is set in HTTP headers, it will be used instead of the name from the URL. With --print-filename in addition, the resulting file name will be printed. Setting --no-clobber will prevent overwriting file on the destination if there is one with the same name. Setting --stdout or making the output file name - will cause the output to be written to standard output. Troubleshooting If you can't get rclone copyurl to work then here are some things you can try: - --disable-http2 rclone will use HTTP2 if available - try disabling it - --bind 0.0.0.0 rclone will use IPv6 if available - try disabling it - --bind ::0 to disable IPv4 - --user agent curl - some sites have whitelists for curl's user-agent - try that - Make sure the site works with curl directly rclone copyurl https://example.com dest:path [flags] Options -a, --auto-filename Get the file name from the URL and use it for destination file path --header-filename Get the file name from the Content-Disposition header -h, --help help for copyurl --no-clobber Prevent overwriting file with same name -p, --print-filename Print the resulting name from --auto-filename --stdout Write the output to stdout rather than a file Options shared with other commands are described next. See the global flags page for global options not listed here. Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) See Also - rclone - Show help for rclone commands, flags and backends. rclone cryptcheck Cryptcheck checks the integrity of an encrypted remote. Synopsis Checks a remote against a crypted remote. This is the equivalent of running rclone check, but able to check the checksums of the encrypted remote. For it to work the underlying remote of the cryptedremote must support some kind of checksum. It works by reading the nonce from each file on the cryptedremote: and using that to encrypt each file on the remote:. It then checks the checksum of the underlying file on the cryptedremote: against the checksum of the file it has just encrypted. Use it like this rclone cryptcheck /path/to/files encryptedremote:path You can use it like this also, but that will involve downloading all the files in remote:path. rclone cryptcheck remote:path encryptedremote:path After it has run it will log the status of the encryptedremote:. If you supply the --one-way flag, it will only check that files in the source match the files in the destination, not the other way around. This means that extra files in the destination that are not in the source will not be detected. The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different. The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - = path means path was found in source and destination and was identical - - path means path was missing on the source, so only in the destination - + path means path was missing on the destination, so only in the source - * path means path was present in source and destination but different. - ! path means there was an error reading or hashing the source or dest. The default number of parallel checks is 8. See the --checkers option for more information. rclone cryptcheck remote:path cryptedremote:path [flags] Options --combined string Make a combined report of changes to this file --differ string Report all non-matching files to this file --error string Report all files with errors (hashing or reading) to this file -h, --help help for cryptcheck --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file --one-way Check one way only, source files must exist on remote Options shared with other commands are described next. See the global flags page for global options not listed here. Check Options Flags used for check commands --max-backlog int Maximum number of objects in sync or check backlog (default 10000) Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone cryptdecode Cryptdecode returns unencrypted file names. Synopsis Returns unencrypted file names when provided with a list of encrypted file names. List limit is 10 items. If you supply the --reverse flag, it will return encrypted file names. use it like this rclone cryptdecode encryptedremote: encryptedfilename1 encryptedfilename2 rclone cryptdecode --reverse encryptedremote: filename1 filename2 Another way to accomplish this is by using the rclone backend encode (or decode) command. See the documentation on the crypt overlay for more info. rclone cryptdecode encryptedremote: encryptedfilename [flags] Options -h, --help help for cryptdecode --reverse Reverse cryptdecode, encrypts filenames See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. rclone deletefile Remove a single file from remote. Synopsis Remove a single file from remote. Unlike delete it cannot be used to remove a directory and it doesn't obey include/exclude filters - if the specified file exists, it will always be removed. rclone deletefile remote:path [flags] Options -h, --help help for deletefile Options shared with other commands are described next. See the global flags page for global options not listed here. Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) See Also - rclone - Show help for rclone commands, flags and backends. rclone gendocs Output markdown docs for rclone to the directory supplied. Synopsis This produces markdown docs for the rclone commands to the directory supplied. These are in a format suitable for hugo to render into the rclone.org website. rclone gendocs output_directory [flags] Options -h, --help help for gendocs See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. rclone gitannex Speaks with git-annex over stdin/stdout. Synopsis Rclone's gitannex subcommand enables git-annex to store and retrieve content from an rclone remote. It is meant to be run by git-annex, not directly by users. Installation on Linux 1. Skip this step if your version of git-annex is 10.20240430 or newer. Otherwise, you must create a symlink somewhere on your PATH with a particular name. This symlink helps git-annex tell rclone it wants to run the "gitannex" subcommand. # Create the helper symlink in "$HOME/bin". ln -s "$(realpath rclone)" "$HOME/bin/git-annex-remote-rclone-builtin" # Verify the new symlink is on your PATH. which git-annex-remote-rclone-builtin 2. Add a new remote to your git-annex repo. This new remote will connect git-annex with the rclone gitannex subcommand. Start by asking git-annex to describe the remote's available configuration parameters. # If you skipped step 1: git annex initremote MyRemote type=rclone --whatelse # If you created a symlink in step 1: git annex initremote MyRemote type=external externaltype=rclone-builtin --whatelse NOTE: If you're porting an existing git-annex-remote-rclone remote to use rclone gitannex, you can probably reuse the configuration parameters verbatim without renaming them. Check parameter synonyms with --whatelse as shown above. The following example creates a new git-annex remote named "MyRemote" that will use the rclone remote named "SomeRcloneRemote". That rclone remote must be one configured in your rclone.conf file, which can be located with rclone config file. git annex initremote MyRemote \ type=external \ externaltype=rclone-builtin \ encryption=none \ rcloneremotename=SomeRcloneRemote \ rcloneprefix=git-annex-content \ rclonelayout=nodir 3. Before you trust this command with your precious data, be sure to test the remote. This command is very new and has not been tested on many rclone backends. Caveat emptor! git annex testremote MyRemote Happy annexing! rclone gitannex [flags] Options -h, --help help for gitannex See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. rclone hashsum Produces a hashsum file for all the objects in the path. Synopsis Produces a hash file for all the objects in the path using the hash named. The output is in the same format as the standard md5sum/sha1sum tool. By default, the hash is requested from the remote. If the hash is not supported by the remote, no hash will be returned. With the download flag, the file will be downloaded from the remote and hashed locally enabling any hash for any remote. For the MD5 and SHA1 algorithms there are also dedicated commands, md5sum and sha1sum. This command can also hash data received on standard input (stdin), by not passing a remote:path, or by passing a hyphen as remote:path when there is data to read (if not, the hyphen will be treated literally, as a relative path). Run without a hash to see the list of all supported hashes, e.g. $ rclone hashsum Supported hashes are: * md5 * sha1 * whirlpool * crc32 * sha256 * sha512 * blake3 * xxh3 * xxh128 Then $ rclone hashsum MD5 remote:path Note that hash names are case insensitive and values are output in lower case. rclone hashsum [ remote:path] [flags] Options --base64 Output base64 encoded hashsum -C, --checkfile string Validate hashes against a given SUM file instead of printing them --download Download the file and hash it locally; if this flag is not specified, the hash is requested from the remote -h, --help help for hashsum --output-file string Output hashsums to a file rather than the terminal Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone link Generate public link to file/folder. Synopsis Create, retrieve or remove a public link to the given file or folder. rclone link remote:path/to/file rclone link remote:path/to/folder/ rclone link --unlink remote:path/to/folder/ rclone link --expire 1d remote:path/to/file If you supply the --expire flag, it will set the expiration time otherwise it will use the default (100 years). Note not all backends support the --expire flag - if the backend doesn't support it then the link returned won't expire. Use the --unlink flag to remove existing public links to the file or folder. Note not all backends support "--unlink" flag - those that don't will just ignore it. If successful, the last line of the output will contain the link. Exact capabilities depend on the remote, but the link will always by default be created with the least constraints – e.g. no expiry, no password protection, accessible without account. rclone link remote:path [flags] Options --expire Duration The amount of time that the link will be valid (default off) -h, --help help for link --unlink Remove existing public link to file/folder See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. rclone listremotes List all the remotes in the config file and defined in environment variables. Synopsis Lists all the available remotes from the config file, or the remotes matching an optional filter. Prints the result in human-readable format by default, and as a simple list of remote names, or if used with flag --long a tabular format including the remote names, types and descriptions. Using flag --json produces machine-readable output instead, which always includes all attributes - including the source (file or environment). Result can be filtered by a filter argument which applies to all attributes, and/or filter flags specific for each attribute. The values must be specified according to regular rclone filtering pattern syntax. rclone listremotes [] [flags] Options --description string Filter remotes by description -h, --help help for listremotes --json Format output as JSON --long Show type and description in addition to name --name string Filter remotes by name --order-by string Instructions on how to order the result, e.g. 'type,name=descending' --source string Filter remotes by source, e.g. 'file' or 'environment' --type string Filter remotes by type See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. rclone lsf List directories and objects in remote:path formatted for parsing. Synopsis List the contents of the source path (directories and objects) to standard output in a form which is easy to parse by scripts. By default this will just be the names of the objects and directories, one per line. The directories will have a / suffix. Eg $ rclone lsf swift:bucket bevajer5jef canole diwogej7 ferejej3gux/ fubuwic Use the --format option to control what gets listed. By default this is just the path, but you can use these parameters to control the output: p - path s - size t - modification time h - hash i - ID of object o - Original ID of underlying object m - MimeType of object if known e - encrypted name T - tier of storage if known, e.g. "Hot" or "Cool" M - Metadata of object in JSON blob format, eg {"key":"value"} So if you wanted the path, size and modification time, you would use --format "pst", or maybe --format "tsp" to put the path last. Eg $ rclone lsf --format "tsp" swift:bucket 2016-06-25 18:55:41;60295;bevajer5jef 2016-06-25 18:55:43;90613;canole 2016-06-25 18:55:43;94467;diwogej7 2018-04-26 08:50:45;0;ferejej3gux/ 2016-06-25 18:55:40;37600;fubuwic If you specify "h" in the format you will get the MD5 hash by default, use the --hash flag to change which hash you want. Note that this can be returned as an empty string if it isn't available on the object (and for directories), "ERROR" if there was an error reading it from the object and "UNSUPPORTED" if that object does not support that hash type. For example, to emulate the md5sum command you can use rclone lsf -R --hash MD5 --format hp --separator " " --files-only . Eg $ rclone lsf -R --hash MD5 --format hp --separator " " --files-only swift:bucket 7908e352297f0f530b84a756f188baa3 bevajer5jef cd65ac234e6fea5925974a51cdd865cc canole 03b5341b4f234b9d984d03ad076bae91 diwogej7 8fd37c3810dd660778137ac3a66cc06d fubuwic 99713e14a4c4ff553acaf1930fad985b gixacuh7ku (Though "rclone md5sum ." is an easier way of typing this.) By default the separator is ";" this can be changed with the --separator flag. Note that separators aren't escaped in the path so putting it last is a good strategy. Eg $ rclone lsf --separator "," --format "tshp" swift:bucket 2016-06-25 18:55:41,60295,7908e352297f0f530b84a756f188baa3,bevajer5jef 2016-06-25 18:55:43,90613,cd65ac234e6fea5925974a51cdd865cc,canole 2016-06-25 18:55:43,94467,03b5341b4f234b9d984d03ad076bae91,diwogej7 2018-04-26 08:52:53,0,,ferejej3gux/ 2016-06-25 18:55:40,37600,8fd37c3810dd660778137ac3a66cc06d,fubuwic You can output in CSV standard format. This will escape things in " if they contain , Eg $ rclone lsf --csv --files-only --format ps remote:path test.log,22355 test.sh,449 "this file contains a comma, in the file name.txt",6 Note that the --absolute parameter is useful for making lists of files to pass to an rclone copy with the --files-from-raw flag. For example, to find all the files modified within one day and copy those only (without traversing the whole directory structure): rclone lsf --absolute --files-only --max-age 1d /path/to/local > new_files rclone copy --files-from-raw new_files /path/to/local remote:path The default time format is '2006-01-02 15:04:05'. Other formats can be specified with the --time-format flag. Examples: rclone lsf remote:path --format pt --time-format 'Jan 2, 2006 at 3:04pm (MST)' rclone lsf remote:path --format pt --time-format '2006-01-02 15:04:05.000000000' rclone lsf remote:path --format pt --time-format '2006-01-02T15:04:05.999999999Z07:00' rclone lsf remote:path --format pt --time-format RFC3339 rclone lsf remote:path --format pt --time-format DateOnly rclone lsf remote:path --format pt --time-format max --time-format max will automatically truncate '2006-01-02 15:04:05.000000000' to the maximum precision supported by the remote. Any of the filtering options can be applied to this command. There are several related list commands - ls to list size and path of objects only - lsl to list modification time, size and path of objects only - lsd to list directories only - lsf to list objects and directories in easy to parse format - lsjson to list objects and directories in JSON format ls,lsl,lsd are designed to be human-readable. lsf is designed to be human and machine-readable. lsjson is designed to be machine-readable. Note that ls and lsl recurse by default - use --max-depth 1 to stop the recursion. The other list commands lsd,lsf,lsjson do not recurse by default - use -R to make them recurse. Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes). rclone lsf remote:path [flags] Options --absolute Put a leading / in front of path names --csv Output in CSV format -d, --dir-slash Append a slash to directory names (default true) --dirs-only Only list directories --files-only Only list files -F, --format string Output format - see help for details (default "p") --hash h Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5") -h, --help help for lsf -R, --recursive Recurse into the listing -s, --separator string Separator for the items in the format (default ";") -t, --time-format string Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05) Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone lsjson List directories and objects in the path in JSON format. Synopsis List directories and objects in the path in JSON format. The output is an array of Items, where each Item looks like this: { "Hashes" : { "SHA-1" : "f572d396fae9206628714fb2ce00f72e94f2258f", "MD5" : "b1946ac92492d2347c6235b4d2611184", "DropboxHash" : "ecb65bb98f9d905b70458986c39fcbad7715e5f2fcc3b1f07767d7c83e2438cc" }, "ID": "y2djkhiujf83u33", "OrigID": "UYOJVTUW00Q1RzTDA", "IsBucket" : false, "IsDir" : false, "MimeType" : "application/octet-stream", "ModTime" : "2017-05-31T16:15:57.034468261+01:00", "Name" : "file.txt", "Encrypted" : "v0qpsdq8anpci8n929v3uu9338", "EncryptedPath" : "kja9098349023498/v0qpsdq8anpci8n929v3uu9338", "Path" : "full/path/goes/here/file.txt", "Size" : 6, "Tier" : "hot", } The exact set of properties included depends on the backend: - The property IsBucket will only be included for bucket-based remotes, and only for directories that are buckets. It will always be omitted when value is not true. - Properties Encrypted and EncryptedPath will only be included for encrypted remotes, and (as mentioned below) only if the --encrypted option is set. Different options may also affect which properties are included: - If --hash is not specified, the Hashes property will be omitted. The types of hash can be specified with the --hash-type parameter (which may be repeated). If --hash-type is set then it implies --hash. - If --no-modtime is specified then ModTime will be blank. This can speed things up on remotes where reading the ModTime takes an extra request (e.g. s3, swift). - If --no-mimetype is specified then MimeType will be blank. This can speed things up on remotes where reading the MimeType takes an extra request (e.g. s3, swift). - If --encrypted is not specified the Encrypted and EncryptedPath properties will be omitted - even for encrypted remotes. - If --metadata is set then an additional Metadata property will be returned. This will have metadata in rclone standard format as a JSON object. The default is to list directories and files/objects, but this can be changed with the following options: - If --dirs-only is specified then directories will be returned only, no files/objects. - If --files-only is specified then files will be returned only, no directories. If --stat is set then the the output is not an array of items, but instead a single JSON blob will be returned about the item pointed to. This will return an error if the item isn't found, however on bucket based backends (like s3, gcs, b2, azureblob etc) if the item isn't found it will return an empty directory, as it isn't possible to tell empty directories from missing directories there. The Path field will only show folders below the remote path being listed. If "remote:path" contains the file "subfolder/file.txt", the Path for "file.txt" will be "subfolder/file.txt", not "remote:path/subfolder/file.txt". When used without --recursive the Path will always be the same as Name. The time is in RFC3339 format with up to nanosecond precision. The number of decimal digits in the seconds will depend on the precision that the remote can hold the times, so if times are accurate to the nearest millisecond (e.g. Google Drive) then 3 digits will always be shown ("2017-05-31T16:15:57.034+01:00") whereas if the times are accurate to the nearest second (Dropbox, Box, WebDav, etc.) no digits will be shown ("2017-05-31T16:15:57+01:00"). The whole output can be processed as a JSON blob, or alternatively it can be processed line by line as each item is written on individual lines (except with --stat). Any of the filtering options can be applied to this command. There are several related list commands - ls to list size and path of objects only - lsl to list modification time, size and path of objects only - lsd to list directories only - lsf to list objects and directories in easy to parse format - lsjson to list objects and directories in JSON format ls,lsl,lsd are designed to be human-readable. lsf is designed to be human and machine-readable. lsjson is designed to be machine-readable. Note that ls and lsl recurse by default - use --max-depth 1 to stop the recursion. The other list commands lsd,lsf,lsjson do not recurse by default - use -R to make them recurse. Listing a nonexistent directory will produce an error except for remotes which can't have empty directories (e.g. s3, swift, or gcs - the bucket-based remotes). rclone lsjson remote:path [flags] Options --dirs-only Show only directories in the listing --encrypted Show the encrypted names --files-only Show only files in the listing --hash Include hashes in the output (may take longer) --hash-type stringArray Show only this hash type (may be repeated) -h, --help help for lsjson -M, --metadata Add metadata to the listing --no-mimetype Don't read the mime type (can speed things up) --no-modtime Don't read the modification time (can speed things up) --original Show the ID of the underlying Object -R, --recursive Recurse into the listing --stat Just return the info for the pointed to file Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone mount Mount the remote as file system on a mountpoint. Synopsis Rclone mount allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE. First set up your remote using rclone config. Check it works with rclone ls etc. On Linux and macOS, you can run mount in either foreground or background (aka daemon) mode. Mount runs in foreground mode by default. Use the --daemon flag to force background mode. On Windows you can run mount in foreground only, the flag is ignored. In background mode rclone acts as a generic Unix mount program: the main program starts, spawns background rclone process to setup and maintain the mount, waits until success or timeout and exits with appropriate code (killing the child process if it fails). On Linux/macOS/FreeBSD start the mount like this, where /path/to/local/mount is an empty existing directory: rclone mount remote:path/to/files /path/to/local/mount On Windows you can start a mount in different ways. See below for details. If foreground mount is used interactively from a console window, rclone will serve the mount and occupy the console so another window should be used to work with the mount until rclone is interrupted e.g. by pressing Ctrl-C. The following examples will mount to an automatically assigned drive, to specific drive letter X:, to path C:\path\parent\mount (where parent directory or drive must exist, and mount must not exist, and is not supported when mounting as a network drive), and the last example will mount as network share \\cloud\remote and map it to an automatically assigned drive: rclone mount remote:path/to/files * rclone mount remote:path/to/files X: rclone mount remote:path/to/files C:\path\parent\mount rclone mount remote:path/to/files \\cloud\remote When the program ends while in foreground mode, either via Ctrl+C or receiving a SIGINT or SIGTERM signal, the mount should be automatically stopped. When running in background mode the user will have to stop the mount manually: # Linux fusermount -u /path/to/local/mount #... or on some systems fusermount3 -u /path/to/local/mount # OS X or Linux when using nfsmount umount /path/to/local/mount The umount operation can fail, for example when the mountpoint is busy. When that happens, it is the user's responsibility to stop the mount manually. The size of the mounted file system will be set according to information retrieved from the remote, the same as returned by the rclone about command. Remotes with unlimited storage may report the used size only, then an additional 1 PiB of free space is assumed. If the remote does not support the about feature at all, then 1 PiB is set as both the total and the free size. Installing on Windows To run rclone mount on Windows, you will need to download and install WinFsp. WinFsp is an open-source Windows File System Proxy which makes it easy to write user space file systems for Windows. It provides a FUSE emulation layer which rclone uses combination with cgofuse. Both of these packages are by Bill Zissimopoulos who was very helpful during the implementation of rclone mount for Windows. Mounting modes on windows Unlike other operating systems, Microsoft Windows provides a different filesystem type for network and fixed drives. It optimises access on the assumption fixed disk drives are fast and reliable, while network drives have relatively high latency and less reliability. Some settings can also be differentiated between the two types, for example that Windows Explorer should just display icons and not create preview thumbnails for image and video files on network drives. In most cases, rclone will mount the remote as a normal, fixed disk drive by default. However, you can also choose to mount it as a remote network drive, often described as a network share. If you mount an rclone remote using the default, fixed drive mode and experience unexpected program errors, freezes or other issues, consider mounting as a network drive instead. When mounting as a fixed disk drive you can either mount to an unused drive letter, or to a path representing a nonexistent subdirectory of an existing parent directory or drive. Using the special value * will tell rclone to automatically assign the next available drive letter, starting with Z: and moving backward. Examples: rclone mount remote:path/to/files * rclone mount remote:path/to/files X: rclone mount remote:path/to/files C:\path\parent\mount rclone mount remote:path/to/files X: Option --volname can be used to set a custom volume name for the mounted file system. The default is to use the remote name and path. To mount as network drive, you can add option --network-mode to your mount command. Mounting to a directory path is not supported in this mode, it is a limitation Windows imposes on junctions, so the remote must always be mounted to a drive letter. rclone mount remote:path/to/files X: --network-mode A volume name specified with --volname will be used to create the network share path. A complete UNC path, such as \\cloud\remote, optionally with path \\cloud\remote\madeup\path, will be used as is. Any other string will be used as the share part, after a default prefix \\server\. If no volume name is specified then \\server\share will be used. You must make sure the volume name is unique when you are mounting more than one drive, or else the mount command will fail. The share name will treated as the volume label for the mapped drive, shown in Windows Explorer etc, while the complete \\server\share will be reported as the remote UNC path by net use etc, just like a normal network drive mapping. If you specify a full network share UNC path with --volname, this will implicitly set the --network-mode option, so the following two examples have same result: rclone mount remote:path/to/files X: --network-mode rclone mount remote:path/to/files X: --volname \\server\share You may also specify the network share UNC path as the mountpoint itself. Then rclone will automatically assign a drive letter, same as with * and use that as mountpoint, and instead use the UNC path specified as the volume name, as if it were specified with the --volname option. This will also implicitly set the --network-mode option. This means the following two examples have same result: rclone mount remote:path/to/files \\cloud\remote rclone mount remote:path/to/files * --volname \\cloud\remote There is yet another way to enable network mode, and to set the share path, and that is to pass the "native" libfuse/WinFsp option directly: --fuse-flag --VolumePrefix=\server\share. Note that the path must be with just a single backslash prefix in this case. Note: In previous versions of rclone this was the only supported method. Read more about drive mapping See also Limitations section below. Windows filesystem permissions The FUSE emulation layer on Windows must convert between the POSIX-based permission model used in FUSE, and the permission model used in Windows, based on access-control lists (ACL). The mounted filesystem will normally get three entries in its access-control list (ACL), representing permissions for the POSIX permission scopes: Owner, group and others. By default, the owner and group will be taken from the current user, and the built-in group "Everyone" will be used to represent others. The user/group can be customized with FUSE options "UserName" and "GroupName", e.g. -o UserName=user123 -o GroupName="Authenticated Users". The permissions on each entry will be set according to options --dir-perms and --file-perms, which takes a value in traditional Unix numeric notation. The default permissions corresponds to --file-perms 0666 --dir-perms 0777, i.e. read and write permissions to everyone. This means you will not be able to start any programs from the mount. To be able to do that you must add execute permissions, e.g. --file-perms 0777 --dir-perms 0777 to add it to everyone. If the program needs to write files, chances are you will have to enable VFS File Caching as well (see also limitations). Note that the default write permission have some restrictions for accounts other than the owner, specifically it lacks the "write extended attributes", as explained next. The mapping of permissions is not always trivial, and the result you see in Windows Explorer may not be exactly like you expected. For example, when setting a value that includes write access for the group or others scope, this will be mapped to individual permissions "write attributes", "write data" and "append data", but not "write extended attributes". Windows will then show this as basic permission "Special" instead of "Write", because "Write" also covers the "write extended attributes" permission. When setting digit 0 for group or others, to indicate no permissions, they will still get individual permissions "read attributes", "read extended attributes" and "read permissions". This is done for compatibility reasons, e.g. to allow users without additional permissions to be able to read basic metadata about files like in Unix. WinFsp 2021 (version 1.9) introduced a new FUSE option "FileSecurity", that allows the complete specification of file security descriptors using SDDL. With this you get detailed control of the resulting permissions, compared to use of the POSIX permissions described above, and no additional permissions will be added automatically for compatibility with Unix. Some example use cases will following. If you set POSIX permissions for only allowing access to the owner, using --file-perms 0600 --dir-perms 0700, the user group and the built-in "Everyone" group will still be given some special permissions, as described above. Some programs may then (incorrectly) interpret this as the file being accessible by everyone, for example an SSH client may warn about "unprotected private key file". You can work around this by specifying -o FileSecurity="D:P(A;;FA;;;OW)", which sets file all access (FA) to the owner (OW), and nothing else. When setting write permissions then, except for the owner, this does not include the "write extended attributes" permission, as mentioned above. This may prevent applications from writing to files, giving permission denied error instead. To set working write permissions for the built-in "Everyone" group, similar to what it gets by default but with the addition of the "write extended attributes", you can specify -o FileSecurity="D:P(A;;FRFW;;;WD)", which sets file read (FR) and file write (FW) to everyone (WD). If file execute (FX) is also needed, then change to -o FileSecurity="D:P(A;;FRFWFX;;;WD)", or set file all access (FA) to get full access permissions, including delete, with -o FileSecurity="D:P(A;;FA;;;WD)". Windows caveats Drives created as Administrator are not visible to other accounts, not even an account that was elevated to Administrator with the User Account Control (UAC) feature. A result of this is that if you mount to a drive letter from a Command Prompt run as Administrator, and then try to access the same drive from Windows Explorer (which does not run as Administrator), you will not be able to see the mounted drive. If you don't need to access the drive from applications running with administrative privileges, the easiest way around this is to always create the mount from a non-elevated command prompt. To make mapped drives available to the user account that created them regardless if elevated or not, there is a special Windows setting called linked connections that can be enabled. It is also possible to make a drive mount available to everyone on the system, by running the process creating it as the built-in SYSTEM account. There are several ways to do this: One is to use the command-line utility PsExec, from Microsoft's Sysinternals suite, which has option -s to start processes as the SYSTEM account. Another alternative is to run the mount command from a Windows Scheduled Task, or a Windows Service, configured to run as the SYSTEM account. A third alternative is to use the WinFsp.Launcher infrastructure). Read more in the install documentation. Note that when running rclone as another user, it will not use the configuration file from your profile unless you tell it to with the --config option. Note also that it is now the SYSTEM account that will have the owner permissions, and other accounts will have permissions according to the group or others scopes. As mentioned above, these will then not get the "write extended attributes" permission, and this may prevent writing to files. You can work around this with the FileSecurity option, see example above. Note that mapping to a directory path, instead of a drive letter, does not suffer from the same limitations. Mounting on macOS Mounting on macOS can be done either via built-in NFS server, macFUSE (also known as osxfuse) or FUSE-T. macFUSE is a traditional FUSE driver utilizing a macOS kernel extension (kext). FUSE-T is an alternative FUSE system which "mounts" via an NFSv4 local server. Unicode Normalization It is highly recommended to keep the default of --no-unicode-normalization=false for all mount and serve commands on macOS. For details, see vfs-case-sensitivity. NFS mount This method spins up an NFS server using serve nfs command and mounts it to the specified mountpoint. If you run this in background mode using |--daemon|, you will need to send SIGTERM signal to the rclone process using |kill| command to stop the mount. Note that --nfs-cache-handle-limit controls the maximum number of cached file handles stored by the nfsmount caching handler. This should not be set too low or you may experience errors when trying to access files. The default is 1000000, but consider lowering this limit if the server's system resource usage causes problems. macFUSE Notes If installing macFUSE using dmg packages from the website, rclone will locate the macFUSE libraries without any further intervention. If however, macFUSE is installed using the macports package manager, the following addition steps are required. sudo mkdir /usr/local/lib cd /usr/local/lib sudo ln -s /opt/local/lib/libfuse.2.dylib FUSE-T Limitations, Caveats, and Notes There are some limitations, caveats, and notes about how it works. These are current as of FUSE-T version 1.0.14. ModTime update on read As per the FUSE-T wiki: File access and modification times cannot be set separately as it seems to be an issue with the NFS client which always modifies both. Can be reproduced with 'touch -m' and 'touch -a' commands This means that viewing files with various tools, notably macOS Finder, will cause rlcone to update the modification time of the file. This may make rclone upload a full new copy of the file. Read Only mounts When mounting with --read-only, attempts to write to files will fail silently as opposed to with a clear warning as in macFUSE. Limitations Without the use of --vfs-cache-mode this can only write files sequentially, it can only seek when reading. This means that many applications won't work with their files on an rclone mount without --vfs-cache-mode writes or --vfs-cache-mode full. See the VFS File Caching section for more info. When using NFS mount on macOS, if you don't specify |--vfs-cache-mode| the mount point will be read-only. Bucket-based remotes - Azure Blob, Swift, S3, Google Cloud Storage and B2 - can't store empty directories. Of these, only Azure Blob, Google Cloud Storage and S3 can preserve them when you add --xxx-directory_markers; otherwise, empty directories will vanish once they drop out of the directory cache. When rclone mount is invoked on Unix with --daemon flag, the main rclone program will wait for the background mount to become ready or until the timeout specified by the --daemon-wait flag. On Linux it can check mount status using ProcFS so the flag in fact sets maximum time to wait, while the real wait can be less. On macOS / BSD the time to wait is constant and the check is performed only at the end. We advise you to set wait time on macOS reasonably. Only supported on Linux, FreeBSD, OS X and Windows at the moment. rclone mount vs rclone sync/copy File systems expect things to be 100% reliable, whereas cloud storage systems are a long way from 100% reliable. The rclone sync/copy commands cope with this with lots of retries. However rclone mount can't use retries in the same way without making local copies of the uploads. Look at the VFS File Caching for solutions to make mount more reliable. Attribute caching You can use the flag --attr-timeout to set the time the kernel caches the attributes (size, modification time, etc.) for directory entries. The default is 1s which caches files just long enough to avoid too many callbacks to rclone from the kernel. In theory 0s should be the correct value for filesystems which can change outside the control of the kernel. However this causes quite a few problems such as rclone using too much memory, rclone not serving files to samba and excessive time listing directories. The kernel can cache the info about a file for the time given by --attr-timeout. You may see corruption if the remote file changes length during this window. It will show up as either a truncated file or a file with garbage on the end. With --attr-timeout 1s this is very unlikely but not impossible. The higher you set --attr-timeout the more likely it is. The default setting of "1s" is the lowest setting which mitigates the problems above. If you set it higher (10s or 1m say) then the kernel will call back to rclone less often making it more efficient, however there is more chance of the corruption issue above. If files don't change on the remote outside of the control of rclone then there is no chance of corruption. This is the same as setting the attr_timeout option in mount.fuse. Filters Note that all the rclone filters can be used to select a subset of the files to be visible in the mount. systemd When running rclone mount as a systemd service, it is possible to use Type=notify. In this case the service will enter the started state after the mountpoint has been successfully set up. Units having the rclone mount service specified as a requirement will see all files and folders immediately in this mode. Note that systemd runs mount units without any environment variables including PATH or HOME. This means that tilde (~) expansion will not work and you should provide --config and --cache-dir explicitly as absolute paths via rclone arguments. Since mounting requires the fusermount or fusermount3 program, rclone will use the fallback PATH of /bin:/usr/bin in this scenario. Please ensure that fusermount/fusermount3 is present on this PATH. Rclone as Unix mount helper The core Unix program /bin/mount normally takes the -t FSTYPE argument then runs the /sbin/mount.FSTYPE helper program passing it mount options as -o key=val,... or --opt=.... Automount (classic or systemd) behaves in a similar way. rclone by default expects GNU-style flags --key val. To run it as a mount helper you should symlink rclone binary to /sbin/mount.rclone and optionally /usr/bin/rclonefs, e.g. ln -s /usr/bin/rclone /sbin/mount.rclone. rclone will detect it and translate command-line arguments appropriately. Now you can run classic mounts like this: mount sftp1:subdir /mnt/data -t rclone -o vfs_cache_mode=writes,sftp_key_file=/path/to/pem or create systemd mount units: # /etc/systemd/system/mnt-data.mount [Unit] Description=Mount for /mnt/data [Mount] Type=rclone What=sftp1:subdir Where=/mnt/data Options=rw,_netdev,allow_other,args2env,vfs-cache-mode=writes,config=/etc/rclone.conf,cache-dir=/var/rclone optionally accompanied by systemd automount unit # /etc/systemd/system/mnt-data.automount [Unit] Description=AutoMount for /mnt/data [Automount] Where=/mnt/data TimeoutIdleSec=600 [Install] WantedBy=multi-user.target or add in /etc/fstab a line like sftp1:subdir /mnt/data rclone rw,noauto,nofail,_netdev,x-systemd.automount,args2env,vfs_cache_mode=writes,config=/etc/rclone.conf,cache_dir=/var/cache/rclone 0 0 or use classic Automountd. Remember to provide explicit config=...,cache-dir=... as a workaround for mount units being run without HOME. Rclone in the mount helper mode will split -o argument(s) by comma, replace _ by - and prepend -- to get the command-line flags. Options containing commas or spaces can be wrapped in single or double quotes. Any inner quotes inside outer quotes of the same type should be doubled. Mount option syntax includes a few extra options treated specially: - env.NAME=VALUE will set an environment variable for the mount process. This helps with Automountd and Systemd.mount which don't allow setting custom environment for mount helpers. Typically you will use env.HTTPS_PROXY=proxy.host:3128 or env.HOME=/root - command=cmount can be used to run cmount or any other rclone command rather than the default mount. - args2env will pass mount options to the mount helper running in background via environment variables instead of command line arguments. This allows to hide secrets from such commands as ps or pgrep. - vv... will be transformed into appropriate --verbose=N - standard mount options like x-systemd.automount, _netdev, nosuid and alike are intended only for Automountd and ignored by rclone. VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. VFS Directory Cache Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir VFS File Buffering The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to --buffer-size * open files. VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable. The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap. --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible - Files can't be opened for both read AND write - Files opened for write can't be seeked - Existing files opened for write must have O_TRUNC set - Files open for read with O_TRUNC will be opened write only - Files open for write only will behave as if O_TRUNC was supplied - Open modes O_APPEND, O_TRUNC are ignored - If an upload fails it can't be retried --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible - Files opened for write only can't be seeked - Existing files opened for write must have O_TRUNC set - Files opened for write only will ignore O_APPEND, O_TRUNC - If an upload fails it can't be retried --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes. When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk. When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required. IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it. If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the --vfs-read-chunk-streams parameter. --vfs-read-chunk-streams == 0 Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading. The chunks will not be buffered in memory. --vfs-read-chunk-streams > 0 Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting. Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput. VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature. In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination. Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer. This scheme is compatible with that used by the local backend with the --local-links flag. The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs. It hasn't been tested with the other rclone serve commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree . ├── dir │   └── file.txt └── linked-dir -> dir The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands. Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync. VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself. WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. VFS Metadata If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the --metadata flag. For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}. rclone mount remote:path /path/to/mountpoint [flags] Options --allow-non-empty Allow mounting over a non-empty directory (not supported on Windows) --allow-other Allow access to other users (not supported on Windows) --allow-root Allow access to root user (not supported on Windows) --async-read Use asynchronous reads (not supported on Windows) (default true) --attr-timeout Duration Time for which file/directory attributes are cached (default 1s) --daemon Run mount in background and exit parent process (as background output is suppressed, use --log-file with --log-format=pid,... to monitor) (not supported on Windows) --daemon-timeout Duration Time limit for rclone to respond to kernel (not supported on Windows) (default 0s) --daemon-wait Duration Time to wait for ready mount from daemon (maximum time on Linux, constant sleep time on OSX/BSD) (not supported on Windows) (default 1m0s) --debug-fuse Debug the FUSE internals - needs -v --default-permissions Makes kernel enforce access control based on the file mode (not supported on Windows) --devname string Set the device name - default is remote:path --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --direct-io Use Direct IO, disables caching of data --file-perms FileMode File permissions (default 666) --fuse-flag stringArray Flags or arguments to be passed direct to libfuse/WinFsp (repeat if required) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for mount --link-perms FileMode Link permissions (default 666) --max-read-ahead SizeSuffix The number of bytes that can be prefetched for sequential reads (not supported on Windows) (default 128Ki) --mount-case-insensitive Tristate Tell the OS the mount is case insensitive (true) or sensitive (false) regardless of the backend (auto) (default unset) --network-mode Mount as remote network drive, instead of fixed disk drive (supported on Windows only) --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --noappledouble Ignore Apple Double (._) and .DS_Store files (supported on OSX only) (default true) --noapplexattr Ignore all "com.apple.*" extended attributes (supported on OSX only) -o, --option stringArray Option for libfuse/WinFsp (repeat if required) --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) --volname string Set the volume name (supported on Windows and OSX only) --write-back-cache Makes kernel buffer writes before sending them to rclone (without this, writethrough caching is used) (not supported on Windows) Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) See Also - rclone - Show help for rclone commands, flags and backends. rclone moveto Move file or directory from source to dest. Synopsis If source:path is a file or directory then it moves it to a file or directory named dest:path. This can be used to rename files or upload single files to other than their existing name. If the source is a directory then it acts exactly like the move command. So rclone moveto src dst where src and dst are rclone paths, either remote:path or /path/to/local or C:. This will: if src is file move it to dst, overwriting an existing file if it exists if src is directory move it to dst, overwriting existing files if they exist see move command for full details This doesn't transfer files that are identical on src and dst, testing by size and modification time or MD5SUM. src will be deleted on successful transfer. Important: Since this can cause data loss, test first with the --dry-run or the --interactive/-i flag. Note: Use the -P/--progress flag to view real-time transfer statistics. Logger Flags The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied. What they write is described in the help below. For example --differ will write all paths which are present on both the source and destination but different. The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - = path means path was found in source and destination and was identical - - path means path was missing on the source, so only in the destination - + path means path was missing on the destination, so only in the source - * path means path was present in source and destination but different. - ! path means there was an error reading or hashing the source or dest. The --dest-after flag writes a list file using the same format flags as lsf (including customizable options for hash, modtime, etc.) Conceptually it is similar to rsync's --itemize-changes, but not identical -- it should output an accurate list of what will be on the destination after the command is finished. When the --no-traverse flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing. Note that these logger flags have a few limitations, and certain scenarios are not currently supported: - --max-duration / CutoffModeHard - --compare-dest / --copy-dest - server-side moves of an entire dir at once - High-level retries, because there would be duplicates (use --retries 1 to disable) - Possibly some unusual error scenarios Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.) rclone moveto source:path dest:path [flags] Options --absolute Put a leading / in front of path names --combined string Make a combined report of changes to this file --csv Output in CSV format --dest-after string Report all files that exist on the dest post-sync --differ string Report all non-matching files to this file -d, --dir-slash Append a slash to directory names (default true) --dirs-only Only list directories --error string Report all files with errors (hashing or reading) to this file --files-only Only list files (default true) -F, --format string Output format - see lsf help for details (default "p") --hash h Use this hash when h is used in the format MD5|SHA-1|DropboxHash (default "md5") -h, --help help for moveto --match string Report all matching files to this file --missing-on-dst string Report all files missing from the destination to this file --missing-on-src string Report all files missing from the source to this file -s, --separator string Separator for the items in the format (default ";") -t, --timeformat string Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05) Options shared with other commands are described next. See the global flags page for global options not listed here. Copy Options Flags for anything which can copy a file --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone ncdu Explore a remote with a text based user interface. Synopsis This displays a text based user interface allowing the navigation of a remote. It is most useful for answering the question - "What is using all my disk space?". To make the user interface it first scans the entire remote given and builds an in memory representation. rclone ncdu can be used during this scanning phase and you will see it building up the directory structure as it goes along. You can interact with the user interface using key presses, press '?' to toggle the help on and off. The supported keys are: ↑,↓ or k,j to Move →,l to enter ←,h to return g toggle graph c toggle counts a toggle average size in directory m toggle modified time u toggle human-readable format n,s,C,A,M sort by name,size,count,asize,mtime d delete file/directory v select file/directory V enter visual select mode D delete selected files/directories y copy current path to clipboard Y display current path ^L refresh screen (fix screen corruption) r recalculate file sizes ? to toggle help on and off ESC to close the menu box q/^c to quit Listed files/directories may be prefixed by a one-character flag, some of them combined with a description in brackets at end of line. These flags have the following meaning: e means this is an empty directory, i.e. contains no files (but may contain empty subdirectories) ~ means this is a directory where some of the files (possibly in subdirectories) have unknown size, and therefore the directory size may be underestimated (and average size inaccurate, as it is average of the files with known sizes). . means an error occurred while reading a subdirectory, and therefore the directory size may be underestimated (and average size inaccurate) ! means an error occurred while reading this directory This an homage to the ncdu tool but for rclone remotes. It is missing lots of features at the moment but is useful as it stands. Unlike ncdu it does not show excluded files. Note that it might take some time to delete big files/directories. The UI won't respond in the meantime since the deletion is done synchronously. For a non-interactive listing of the remote, see the tree command. To just get the total size of the remote you can also use the size command. rclone ncdu remote:path [flags] Options -h, --help help for ncdu Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone nfsmount Mount the remote as file system on a mountpoint. Synopsis Rclone nfsmount allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE. First set up your remote using rclone config. Check it works with rclone ls etc. On Linux and macOS, you can run mount in either foreground or background (aka daemon) mode. Mount runs in foreground mode by default. Use the --daemon flag to force background mode. On Windows you can run mount in foreground only, the flag is ignored. In background mode rclone acts as a generic Unix mount program: the main program starts, spawns background rclone process to setup and maintain the mount, waits until success or timeout and exits with appropriate code (killing the child process if it fails). On Linux/macOS/FreeBSD start the mount like this, where /path/to/local/mount is an empty existing directory: rclone nfsmount remote:path/to/files /path/to/local/mount On Windows you can start a mount in different ways. See below for details. If foreground mount is used interactively from a console window, rclone will serve the mount and occupy the console so another window should be used to work with the mount until rclone is interrupted e.g. by pressing Ctrl-C. The following examples will mount to an automatically assigned drive, to specific drive letter X:, to path C:\path\parent\mount (where parent directory or drive must exist, and mount must not exist, and is not supported when mounting as a network drive), and the last example will mount as network share \\cloud\remote and map it to an automatically assigned drive: rclone nfsmount remote:path/to/files * rclone nfsmount remote:path/to/files X: rclone nfsmount remote:path/to/files C:\path\parent\mount rclone nfsmount remote:path/to/files \\cloud\remote When the program ends while in foreground mode, either via Ctrl+C or receiving a SIGINT or SIGTERM signal, the mount should be automatically stopped. When running in background mode the user will have to stop the mount manually: # Linux fusermount -u /path/to/local/mount #... or on some systems fusermount3 -u /path/to/local/mount # OS X or Linux when using nfsmount umount /path/to/local/mount The umount operation can fail, for example when the mountpoint is busy. When that happens, it is the user's responsibility to stop the mount manually. The size of the mounted file system will be set according to information retrieved from the remote, the same as returned by the rclone about command. Remotes with unlimited storage may report the used size only, then an additional 1 PiB of free space is assumed. If the remote does not support the about feature at all, then 1 PiB is set as both the total and the free size. Installing on Windows To run rclone nfsmount on Windows, you will need to download and install WinFsp. WinFsp is an open-source Windows File System Proxy which makes it easy to write user space file systems for Windows. It provides a FUSE emulation layer which rclone uses combination with cgofuse. Both of these packages are by Bill Zissimopoulos who was very helpful during the implementation of rclone nfsmount for Windows. Mounting modes on windows Unlike other operating systems, Microsoft Windows provides a different filesystem type for network and fixed drives. It optimises access on the assumption fixed disk drives are fast and reliable, while network drives have relatively high latency and less reliability. Some settings can also be differentiated between the two types, for example that Windows Explorer should just display icons and not create preview thumbnails for image and video files on network drives. In most cases, rclone will mount the remote as a normal, fixed disk drive by default. However, you can also choose to mount it as a remote network drive, often described as a network share. If you mount an rclone remote using the default, fixed drive mode and experience unexpected program errors, freezes or other issues, consider mounting as a network drive instead. When mounting as a fixed disk drive you can either mount to an unused drive letter, or to a path representing a nonexistent subdirectory of an existing parent directory or drive. Using the special value * will tell rclone to automatically assign the next available drive letter, starting with Z: and moving backward. Examples: rclone nfsmount remote:path/to/files * rclone nfsmount remote:path/to/files X: rclone nfsmount remote:path/to/files C:\path\parent\mount rclone nfsmount remote:path/to/files X: Option --volname can be used to set a custom volume name for the mounted file system. The default is to use the remote name and path. To mount as network drive, you can add option --network-mode to your nfsmount command. Mounting to a directory path is not supported in this mode, it is a limitation Windows imposes on junctions, so the remote must always be mounted to a drive letter. rclone nfsmount remote:path/to/files X: --network-mode A volume name specified with --volname will be used to create the network share path. A complete UNC path, such as \\cloud\remote, optionally with path \\cloud\remote\madeup\path, will be used as is. Any other string will be used as the share part, after a default prefix \\server\. If no volume name is specified then \\server\share will be used. You must make sure the volume name is unique when you are mounting more than one drive, or else the mount command will fail. The share name will treated as the volume label for the mapped drive, shown in Windows Explorer etc, while the complete \\server\share will be reported as the remote UNC path by net use etc, just like a normal network drive mapping. If you specify a full network share UNC path with --volname, this will implicitly set the --network-mode option, so the following two examples have same result: rclone nfsmount remote:path/to/files X: --network-mode rclone nfsmount remote:path/to/files X: --volname \\server\share You may also specify the network share UNC path as the mountpoint itself. Then rclone will automatically assign a drive letter, same as with * and use that as mountpoint, and instead use the UNC path specified as the volume name, as if it were specified with the --volname option. This will also implicitly set the --network-mode option. This means the following two examples have same result: rclone nfsmount remote:path/to/files \\cloud\remote rclone nfsmount remote:path/to/files * --volname \\cloud\remote There is yet another way to enable network mode, and to set the share path, and that is to pass the "native" libfuse/WinFsp option directly: --fuse-flag --VolumePrefix=\server\share. Note that the path must be with just a single backslash prefix in this case. Note: In previous versions of rclone this was the only supported method. Read more about drive mapping See also Limitations section below. Windows filesystem permissions The FUSE emulation layer on Windows must convert between the POSIX-based permission model used in FUSE, and the permission model used in Windows, based on access-control lists (ACL). The mounted filesystem will normally get three entries in its access-control list (ACL), representing permissions for the POSIX permission scopes: Owner, group and others. By default, the owner and group will be taken from the current user, and the built-in group "Everyone" will be used to represent others. The user/group can be customized with FUSE options "UserName" and "GroupName", e.g. -o UserName=user123 -o GroupName="Authenticated Users". The permissions on each entry will be set according to options --dir-perms and --file-perms, which takes a value in traditional Unix numeric notation. The default permissions corresponds to --file-perms 0666 --dir-perms 0777, i.e. read and write permissions to everyone. This means you will not be able to start any programs from the mount. To be able to do that you must add execute permissions, e.g. --file-perms 0777 --dir-perms 0777 to add it to everyone. If the program needs to write files, chances are you will have to enable VFS File Caching as well (see also limitations). Note that the default write permission have some restrictions for accounts other than the owner, specifically it lacks the "write extended attributes", as explained next. The mapping of permissions is not always trivial, and the result you see in Windows Explorer may not be exactly like you expected. For example, when setting a value that includes write access for the group or others scope, this will be mapped to individual permissions "write attributes", "write data" and "append data", but not "write extended attributes". Windows will then show this as basic permission "Special" instead of "Write", because "Write" also covers the "write extended attributes" permission. When setting digit 0 for group or others, to indicate no permissions, they will still get individual permissions "read attributes", "read extended attributes" and "read permissions". This is done for compatibility reasons, e.g. to allow users without additional permissions to be able to read basic metadata about files like in Unix. WinFsp 2021 (version 1.9) introduced a new FUSE option "FileSecurity", that allows the complete specification of file security descriptors using SDDL. With this you get detailed control of the resulting permissions, compared to use of the POSIX permissions described above, and no additional permissions will be added automatically for compatibility with Unix. Some example use cases will following. If you set POSIX permissions for only allowing access to the owner, using --file-perms 0600 --dir-perms 0700, the user group and the built-in "Everyone" group will still be given some special permissions, as described above. Some programs may then (incorrectly) interpret this as the file being accessible by everyone, for example an SSH client may warn about "unprotected private key file". You can work around this by specifying -o FileSecurity="D:P(A;;FA;;;OW)", which sets file all access (FA) to the owner (OW), and nothing else. When setting write permissions then, except for the owner, this does not include the "write extended attributes" permission, as mentioned above. This may prevent applications from writing to files, giving permission denied error instead. To set working write permissions for the built-in "Everyone" group, similar to what it gets by default but with the addition of the "write extended attributes", you can specify -o FileSecurity="D:P(A;;FRFW;;;WD)", which sets file read (FR) and file write (FW) to everyone (WD). If file execute (FX) is also needed, then change to -o FileSecurity="D:P(A;;FRFWFX;;;WD)", or set file all access (FA) to get full access permissions, including delete, with -o FileSecurity="D:P(A;;FA;;;WD)". Windows caveats Drives created as Administrator are not visible to other accounts, not even an account that was elevated to Administrator with the User Account Control (UAC) feature. A result of this is that if you mount to a drive letter from a Command Prompt run as Administrator, and then try to access the same drive from Windows Explorer (which does not run as Administrator), you will not be able to see the mounted drive. If you don't need to access the drive from applications running with administrative privileges, the easiest way around this is to always create the mount from a non-elevated command prompt. To make mapped drives available to the user account that created them regardless if elevated or not, there is a special Windows setting called linked connections that can be enabled. It is also possible to make a drive mount available to everyone on the system, by running the process creating it as the built-in SYSTEM account. There are several ways to do this: One is to use the command-line utility PsExec, from Microsoft's Sysinternals suite, which has option -s to start processes as the SYSTEM account. Another alternative is to run the mount command from a Windows Scheduled Task, or a Windows Service, configured to run as the SYSTEM account. A third alternative is to use the WinFsp.Launcher infrastructure). Read more in the install documentation. Note that when running rclone as another user, it will not use the configuration file from your profile unless you tell it to with the --config option. Note also that it is now the SYSTEM account that will have the owner permissions, and other accounts will have permissions according to the group or others scopes. As mentioned above, these will then not get the "write extended attributes" permission, and this may prevent writing to files. You can work around this with the FileSecurity option, see example above. Note that mapping to a directory path, instead of a drive letter, does not suffer from the same limitations. Mounting on macOS Mounting on macOS can be done either via built-in NFS server, macFUSE (also known as osxfuse) or FUSE-T. macFUSE is a traditional FUSE driver utilizing a macOS kernel extension (kext). FUSE-T is an alternative FUSE system which "mounts" via an NFSv4 local server. Unicode Normalization It is highly recommended to keep the default of --no-unicode-normalization=false for all mount and serve commands on macOS. For details, see vfs-case-sensitivity. NFS mount This method spins up an NFS server using serve nfs command and mounts it to the specified mountpoint. If you run this in background mode using |--daemon|, you will need to send SIGTERM signal to the rclone process using |kill| command to stop the mount. Note that --nfs-cache-handle-limit controls the maximum number of cached file handles stored by the nfsmount caching handler. This should not be set too low or you may experience errors when trying to access files. The default is 1000000, but consider lowering this limit if the server's system resource usage causes problems. macFUSE Notes If installing macFUSE using dmg packages from the website, rclone will locate the macFUSE libraries without any further intervention. If however, macFUSE is installed using the macports package manager, the following addition steps are required. sudo mkdir /usr/local/lib cd /usr/local/lib sudo ln -s /opt/local/lib/libfuse.2.dylib FUSE-T Limitations, Caveats, and Notes There are some limitations, caveats, and notes about how it works. These are current as of FUSE-T version 1.0.14. ModTime update on read As per the FUSE-T wiki: File access and modification times cannot be set separately as it seems to be an issue with the NFS client which always modifies both. Can be reproduced with 'touch -m' and 'touch -a' commands This means that viewing files with various tools, notably macOS Finder, will cause rlcone to update the modification time of the file. This may make rclone upload a full new copy of the file. Read Only mounts When mounting with --read-only, attempts to write to files will fail silently as opposed to with a clear warning as in macFUSE. Limitations Without the use of --vfs-cache-mode this can only write files sequentially, it can only seek when reading. This means that many applications won't work with their files on an rclone mount without --vfs-cache-mode writes or --vfs-cache-mode full. See the VFS File Caching section for more info. When using NFS mount on macOS, if you don't specify |--vfs-cache-mode| the mount point will be read-only. Bucket-based remotes - Azure Blob, Swift, S3, Google Cloud Storage and B2 - can't store empty directories. Of these, only Azure Blob, Google Cloud Storage and S3 can preserve them when you add --xxx-directory_markers; otherwise, empty directories will vanish once they drop out of the directory cache. When rclone mount is invoked on Unix with --daemon flag, the main rclone program will wait for the background mount to become ready or until the timeout specified by the --daemon-wait flag. On Linux it can check mount status using ProcFS so the flag in fact sets maximum time to wait, while the real wait can be less. On macOS / BSD the time to wait is constant and the check is performed only at the end. We advise you to set wait time on macOS reasonably. Only supported on Linux, FreeBSD, OS X and Windows at the moment. rclone nfsmount vs rclone sync/copy File systems expect things to be 100% reliable, whereas cloud storage systems are a long way from 100% reliable. The rclone sync/copy commands cope with this with lots of retries. However rclone nfsmount can't use retries in the same way without making local copies of the uploads. Look at the VFS File Caching for solutions to make nfsmount more reliable. Attribute caching You can use the flag --attr-timeout to set the time the kernel caches the attributes (size, modification time, etc.) for directory entries. The default is 1s which caches files just long enough to avoid too many callbacks to rclone from the kernel. In theory 0s should be the correct value for filesystems which can change outside the control of the kernel. However this causes quite a few problems such as rclone using too much memory, rclone not serving files to samba and excessive time listing directories. The kernel can cache the info about a file for the time given by --attr-timeout. You may see corruption if the remote file changes length during this window. It will show up as either a truncated file or a file with garbage on the end. With --attr-timeout 1s this is very unlikely but not impossible. The higher you set --attr-timeout the more likely it is. The default setting of "1s" is the lowest setting which mitigates the problems above. If you set it higher (10s or 1m say) then the kernel will call back to rclone less often making it more efficient, however there is more chance of the corruption issue above. If files don't change on the remote outside of the control of rclone then there is no chance of corruption. This is the same as setting the attr_timeout option in mount.fuse. Filters Note that all the rclone filters can be used to select a subset of the files to be visible in the mount. systemd When running rclone nfsmount as a systemd service, it is possible to use Type=notify. In this case the service will enter the started state after the mountpoint has been successfully set up. Units having the rclone nfsmount service specified as a requirement will see all files and folders immediately in this mode. Note that systemd runs mount units without any environment variables including PATH or HOME. This means that tilde (~) expansion will not work and you should provide --config and --cache-dir explicitly as absolute paths via rclone arguments. Since mounting requires the fusermount or fusermount3 program, rclone will use the fallback PATH of /bin:/usr/bin in this scenario. Please ensure that fusermount/fusermount3 is present on this PATH. Rclone as Unix mount helper The core Unix program /bin/mount normally takes the -t FSTYPE argument then runs the /sbin/mount.FSTYPE helper program passing it mount options as -o key=val,... or --opt=.... Automount (classic or systemd) behaves in a similar way. rclone by default expects GNU-style flags --key val. To run it as a mount helper you should symlink rclone binary to /sbin/mount.rclone and optionally /usr/bin/rclonefs, e.g. ln -s /usr/bin/rclone /sbin/mount.rclone. rclone will detect it and translate command-line arguments appropriately. Now you can run classic mounts like this: mount sftp1:subdir /mnt/data -t rclone -o vfs_cache_mode=writes,sftp_key_file=/path/to/pem or create systemd mount units: # /etc/systemd/system/mnt-data.mount [Unit] Description=Mount for /mnt/data [Mount] Type=rclone What=sftp1:subdir Where=/mnt/data Options=rw,_netdev,allow_other,args2env,vfs-cache-mode=writes,config=/etc/rclone.conf,cache-dir=/var/rclone optionally accompanied by systemd automount unit # /etc/systemd/system/mnt-data.automount [Unit] Description=AutoMount for /mnt/data [Automount] Where=/mnt/data TimeoutIdleSec=600 [Install] WantedBy=multi-user.target or add in /etc/fstab a line like sftp1:subdir /mnt/data rclone rw,noauto,nofail,_netdev,x-systemd.automount,args2env,vfs_cache_mode=writes,config=/etc/rclone.conf,cache_dir=/var/cache/rclone 0 0 or use classic Automountd. Remember to provide explicit config=...,cache-dir=... as a workaround for mount units being run without HOME. Rclone in the mount helper mode will split -o argument(s) by comma, replace _ by - and prepend -- to get the command-line flags. Options containing commas or spaces can be wrapped in single or double quotes. Any inner quotes inside outer quotes of the same type should be doubled. Mount option syntax includes a few extra options treated specially: - env.NAME=VALUE will set an environment variable for the mount process. This helps with Automountd and Systemd.mount which don't allow setting custom environment for mount helpers. Typically you will use env.HTTPS_PROXY=proxy.host:3128 or env.HOME=/root - command=cmount can be used to run cmount or any other rclone command rather than the default mount. - args2env will pass mount options to the mount helper running in background via environment variables instead of command line arguments. This allows to hide secrets from such commands as ps or pgrep. - vv... will be transformed into appropriate --verbose=N - standard mount options like x-systemd.automount, _netdev, nosuid and alike are intended only for Automountd and ignored by rclone. VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. VFS Directory Cache Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir VFS File Buffering The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to --buffer-size * open files. VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable. The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap. --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible - Files can't be opened for both read AND write - Files opened for write can't be seeked - Existing files opened for write must have O_TRUNC set - Files open for read with O_TRUNC will be opened write only - Files open for write only will behave as if O_TRUNC was supplied - Open modes O_APPEND, O_TRUNC are ignored - If an upload fails it can't be retried --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible - Files opened for write only can't be seeked - Existing files opened for write must have O_TRUNC set - Files opened for write only will ignore O_APPEND, O_TRUNC - If an upload fails it can't be retried --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes. When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk. When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required. IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it. If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the --vfs-read-chunk-streams parameter. --vfs-read-chunk-streams == 0 Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading. The chunks will not be buffered in memory. --vfs-read-chunk-streams > 0 Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting. Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput. VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature. In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination. Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer. This scheme is compatible with that used by the local backend with the --local-links flag. The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs. It hasn't been tested with the other rclone serve commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree . ├── dir │   └── file.txt └── linked-dir -> dir The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands. Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync. VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself. WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. VFS Metadata If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the --metadata flag. For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}. rclone nfsmount remote:path /path/to/mountpoint [flags] Options --addr string IPaddress:Port or :Port to bind server to --allow-non-empty Allow mounting over a non-empty directory (not supported on Windows) --allow-other Allow access to other users (not supported on Windows) --allow-root Allow access to root user (not supported on Windows) --async-read Use asynchronous reads (not supported on Windows) (default true) --attr-timeout Duration Time for which file/directory attributes are cached (default 1s) --daemon Run mount in background and exit parent process (as background output is suppressed, use --log-file with --log-format=pid,... to monitor) (not supported on Windows) --daemon-timeout Duration Time limit for rclone to respond to kernel (not supported on Windows) (default 0s) --daemon-wait Duration Time to wait for ready mount from daemon (maximum time on Linux, constant sleep time on OSX/BSD) (not supported on Windows) (default 1m0s) --debug-fuse Debug the FUSE internals - needs -v --default-permissions Makes kernel enforce access control based on the file mode (not supported on Windows) --devname string Set the device name - default is remote:path --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --direct-io Use Direct IO, disables caching of data --file-perms FileMode File permissions (default 666) --fuse-flag stringArray Flags or arguments to be passed direct to libfuse/WinFsp (repeat if required) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for nfsmount --link-perms FileMode Link permissions (default 666) --max-read-ahead SizeSuffix The number of bytes that can be prefetched for sequential reads (not supported on Windows) (default 128Ki) --mount-case-insensitive Tristate Tell the OS the mount is case insensitive (true) or sensitive (false) regardless of the backend (auto) (default unset) --network-mode Mount as remote network drive, instead of fixed disk drive (supported on Windows only) --nfs-cache-dir string The directory the NFS handle cache will use if set --nfs-cache-handle-limit int max file handles cached simultaneously (min 5) (default 1000000) --nfs-cache-type memory|disk|symlink Type of NFS handle cache to use (default memory) --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --noappledouble Ignore Apple Double (._) and .DS_Store files (supported on OSX only) (default true) --noapplexattr Ignore all "com.apple.*" extended attributes (supported on OSX only) -o, --option stringArray Option for libfuse/WinFsp (repeat if required) --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --sudo Use sudo to run the mount/umount commands as root. --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) --volname string Set the volume name (supported on Windows and OSX only) --write-back-cache Makes kernel buffer writes before sending them to rclone (without this, writethrough caching is used) (not supported on Windows) Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) See Also - rclone - Show help for rclone commands, flags and backends. rclone obscure Obscure password for use in the rclone config file. Synopsis In the rclone config file, human-readable passwords are obscured. Obscuring them is done by encrypting them and writing them out in base64. This is not a secure way of encrypting these passwords as rclone can decrypt them - it is to prevent "eyedropping" - namely someone seeing a password in the rclone config file by accident. Many equally important things (like access tokens) are not obscured in the config file. However it is very hard to shoulder surf a 64 character hex token. This command can also accept a password through STDIN instead of an argument by passing a hyphen as an argument. This will use the first line of STDIN as the password not including the trailing newline. echo "secretpassword" | rclone obscure - If there is no data on STDIN to read, rclone obscure will default to obfuscating the hyphen itself. If you want to encrypt the config file then please use config file encryption - see rclone config for more info. rclone obscure password [flags] Options -h, --help help for obscure See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. rclone rc Run a command against a running rclone. Synopsis This runs a command against a running rclone. Use the --url flag to specify an non default URL to connect on. This can be either a ":port" which is taken to mean "http://localhost:port" or a "host:port" which is taken to mean "http://host:port" A username and password can be passed in with --user and --pass. Note that --rc-addr, --rc-user, --rc-pass will be read also for --url, --user, --pass. The --unix-socket flag can be used to connect over a unix socket like this # start server on /tmp/my.socket rclone rcd --rc-addr unix:///tmp/my.socket # Connect to it rclone rc --unix-socket /tmp/my.socket core/stats Arguments should be passed in as parameter=value. The result will be returned as a JSON object by default. The --json parameter can be used to pass in a JSON blob as an input instead of key=value arguments. This is the only way of passing in more complicated values. The -o/--opt option can be used to set a key "opt" with key, value options in the form -o key=value or -o key. It can be repeated as many times as required. This is useful for rc commands which take the "opt" parameter which by convention is a dictionary of strings. -o key=value -o key2 Will place this in the "opt" value {"key":"value", "key2","") The -a/--arg option can be used to set strings in the "arg" value. It can be repeated as many times as required. This is useful for rc commands which take the "arg" parameter which by convention is a list of strings. -a value -a value2 Will place this in the "arg" value ["value", "value2"] Use --loopback to connect to the rclone instance running rclone rc. This is very useful for testing commands without having to run an rclone rc server, e.g.: rclone rc --loopback operations/about fs=/ Use rclone rc to see a list of all possible commands. rclone rc commands parameter [flags] Options -a, --arg stringArray Argument placed in the "arg" array -h, --help help for rc --json string Input JSON - use instead of key=value args --loopback If set connect to this rclone instance not via HTTP --no-output If set, don't output the JSON result -o, --opt stringArray Option in the form name=value or name placed in the "opt" array --pass string Password to use to connect to rclone remote control --unix-socket string Path to a unix domain socket to dial to, instead of opening a TCP connection directly --url string URL to connect to rclone remote control (default "http://localhost:5572/") --user string Username to use to rclone remote control See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. rclone rcat Copies standard input to file on remote. Synopsis Reads from standard input (stdin) and copies it to a single remote file. echo "hello world" | rclone rcat remote:path/to/file ffmpeg - | rclone rcat remote:path/to/file If the remote file already exists, it will be overwritten. rcat will try to upload small files in a single request, which is usually more efficient than the streaming/chunked upload endpoints, which use multiple requests. Exact behaviour depends on the remote. What is considered a small file may be set through --streaming-upload-cutoff. Uploading only starts after the cutoff is reached or if the file ends before that. The data must fit into RAM. The cutoff needs to be small enough to adhere the limits of your remote, please see there. Generally speaking, setting this cutoff too high will decrease your performance. Use the --size flag to preallocate the file in advance at the remote end and actually stream it, even if remote backend doesn't support streaming. --size should be the exact size of the input stream in bytes. If the size of the stream is different in length to the --size passed in then the transfer will likely fail. Note that the upload cannot be retried because the data is not stored. If the backend supports multipart uploading then individual chunks can be retried. If you need to transfer a lot of data, you may be better off caching it locally and then rclone move it to the destination which can use retries. rclone rcat remote:path [flags] Options -h, --help help for rcat --size int File size hint to preallocate (default -1) Options shared with other commands are described next. See the global flags page for global options not listed here. Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) See Also - rclone - Show help for rclone commands, flags and backends. rclone rcd Run rclone listening to remote control commands only. Synopsis This runs rclone so that it only listens to remote control commands. This is useful if you are controlling rclone via the rc API. If you pass in a path to a directory, rclone will serve that directory for GET requests on the URL passed in. It will also open the URL in the browser when rclone is run. See the rc documentation for more info on the rc flags. Server options Use --rc-addr to specify which IP address and port the server should listen on, eg --rc-addr 1.2.3.4:8000 or --rc-addr :8080 to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port. If you set --rc-addr to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info. You can use a unix socket by setting the url to unix:///path/to/socket or just by using an absolute path name. --rc-addr may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same. --rc-server-read-timeout and --rc-server-write-timeout can be used to control the timeouts on the server. Note that this is the total time for a transfer. --rc-max-header-bytes controls the maximum number of bytes the server will accept in the HTTP header. --rc-baseurl controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used --rc-baseurl "/rclone" then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on --rc-baseurl, so --rc-baseurl "rclone", --rc-baseurl "/rclone" and --rc-baseurl "/rclone/" are all treated identically. TLS (SSL) By default this will serve over http. If you want you can serve over https. You will need to supply the --rc-cert and --rc-key flags. If you wish to do client side certificate validation then you will need to supply --rc-client-ca also. --rc-cert must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. --rc-key must be set to the path of a file with the PEM encoded private key. If setting --rc-client-ca, it should be set to the path of a file with PEM encoded client certificate authority certificates. --rc-min-tls-version is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0"). Socket activation Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by --rc-addr). This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html Socket activation can be tested ad-hoc with the systemd-socket-activatecommand systemd-socket-activate -l 8000 -- rclone serve This will socket-activate rclone on the first connection to port 8000 over TCP. ### Template --rc-template allows a user to specify a custom markup template for HTTP and WebDAV serve functions. The server exports the following markup to be used within the template to server pages: ----------------------------------------------------------------------- Parameter Description ----------------------------------- ----------------------------------- .Name The full path of a file/directory. .Title Directory listing of .Name .Sort The current sort used. This is changeable via ?sort= parameter Sort Options: namedirfirst,name,size,time (default namedirfirst) .Order The current ordering used. This is changeable via ?order= parameter Order Options: asc,desc (default asc) .Query Currently unused. .Breadcrumb Allows for creating a relative navigation -- .Link The relative to the root link of the Text. -- .Text The Name of the directory. .Entries Information about a specific file/directory. -- .URL The 'url' of an entry. -- .Leaf Currently same as 'URL' but intended to be 'just' the name. -- .IsDir Boolean for if an entry is a directory or not. -- .Size Size in Bytes of the entry. -- .ModTime The UTC timestamp of an entry. ----------------------------------------------------------------------- The server also makes the following functions available so that they can be used within the template. These functions help extend the options for dynamic rendering of HTML. They can be used to render HTML based on specific conditions. ----------------------------------------------------------------------- Function Description ----------------------------------- ----------------------------------- afterEpoch Returns the time since the epoch for the given time. contains Checks whether a given substring is present or not in a given string. hasPrefix Checks whether the given string begins with the specified prefix. hasSuffix Checks whether the given string end with the specified suffix. ----------------------------------------------------------------------- Authentication By default this will serve files without needing a login. You can either use an htpasswd file which can take lots of users, or set a single username and password with the --rc-user and --rc-pass flags. Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with --user-from-header (e.g., --rc---user-from-header=x-remote-user). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access. If either of the above authentication methods is not configured and client certificates are required by the --client-ca flag passed to the server, the client certificate common name will be considered as the username. Use --rc-htpasswd /path/to/htpasswd to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended. To create an htpasswd file: touch htpasswd htpasswd -B htpasswd user htpasswd -B htpasswd anotherUser The password file can be updated while rclone is running. Use --rc-realm to set the authentication realm. Use --rc-salt to change the password hashing salt from the default. rclone rcd * [flags] Options -h, --help help for rcd Options shared with other commands are described next. See the global flags page for global options not listed here. RC Options Flags to control the Remote Control API --rc Enable the remote control server --rc-addr stringArray IPaddress:Port or :Port to bind server to (default localhost:5572) --rc-allow-origin string Origin which cross-domain request (CORS) can be executed from --rc-baseurl string Prefix for URLs - leave blank for root --rc-cert string TLS PEM key (concatenation of certificate and CA certificate) --rc-client-ca string Client certificate authority to verify clients with --rc-enable-metrics Enable the Prometheus metrics path at the remote control server --rc-files string Path to local files to serve on the HTTP server --rc-htpasswd string A htpasswd file - if not provided no authentication is done --rc-job-expire-duration Duration Expire finished async jobs older than this value (default 1m0s) --rc-job-expire-interval Duration Interval to check for expired async jobs (default 10s) --rc-key string TLS PEM Private key --rc-max-header-bytes int Maximum size of request header (default 4096) --rc-min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --rc-no-auth Don't require auth for certain methods --rc-pass string Password for authentication --rc-realm string Realm for authentication --rc-salt string Password hashing salt (default "dlPL2MqE") --rc-serve Enable the serving of remote objects --rc-serve-no-modtime Don't read the modification time (can speed things up) --rc-server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --rc-server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --rc-template string User-specified template --rc-user string User name for authentication --rc-user-from-header string User name from a defined HTTP header --rc-web-fetch-url string URL to fetch the releases for webgui (default "https://api.github.com/repos/rclone/rclone-webui-react/releases/latest") --rc-web-gui Launch WebGUI on localhost --rc-web-gui-force-update Force update to latest version of web gui --rc-web-gui-no-open-browser Don't open the browser automatically --rc-web-gui-update Check and update to latest version of web gui See Also - rclone - Show help for rclone commands, flags and backends. rclone rmdirs Remove empty directories under the path. Synopsis This recursively removes any empty directories (including directories that only contain empty directories), that it finds under the path. The root path itself will also be removed if it is empty, unless you supply the --leave-root flag. Use command rmdir to delete just the empty directory given by path, not recurse. This is useful for tidying up remotes that rclone has left a lot of empty directories in. For example the delete command will delete files but leave the directory structure (unless used with option --rmdirs). This will delete --checkers directories concurrently so if you have thousands of empty directories consider increasing this number. To delete a path and any objects in it, use the purge command. rclone rmdirs remote:path [flags] Options -h, --help help for rmdirs --leave-root Do not remove root directory if empty Options shared with other commands are described next. See the global flags page for global options not listed here. Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) See Also - rclone - Show help for rclone commands, flags and backends. rclone selfupdate Update the rclone binary. Synopsis This command downloads the latest release of rclone and replaces the currently running binary. The download is verified with a hashsum and cryptographically signed signature; see the release signing docs for details. If used without flags (or with implied --stable flag), this command will install the latest stable release. However, some issues may be fixed (or features added) only in the latest beta release. In such cases you should run the command with the --beta flag, i.e. rclone selfupdate --beta. You can check in advance what version would be installed by adding the --check flag, then repeat the command without it when you are satisfied. Sometimes the rclone team may recommend you a concrete beta or stable rclone release to troubleshoot your issue or add a bleeding edge feature. The --version VER flag, if given, will update to the concrete version instead of the latest one. If you omit micro version from VER (for example 1.53), the latest matching micro version will be used. Upon successful update rclone will print a message that contains a previous version number. You will need it if you later decide to revert your update for some reason. Then you'll have to note the previous version and run the following command: rclone selfupdate [--beta] OLDVER. If the old version contains only dots and digits (for example v1.54.0) then it's a stable release so you won't need the --beta flag. Beta releases have an additional information similar to v1.54.0-beta.5111.06f1c0c61. (if you are a developer and use a locally built rclone, the version number will end with -DEV, you will have to rebuild it as it obviously can't be distributed). If you previously installed rclone via a package manager, the package may include local documentation or configure services. You may wish to update with the flag --package deb or --package rpm (whichever is correct for your OS) to update these too. This command with the default --package zip will update only the rclone executable so the local manual may become inaccurate after it. The rclone mount command may or may not support extended FUSE options depending on the build and OS. selfupdate will refuse to update if the capability would be discarded. Note: Windows forbids deletion of a currently running executable so this command will rename the old executable to 'rclone.old.exe' upon success. Please note that this command was not available before rclone version 1.55. If it fails for you with the message unknown command "selfupdate" then you will need to update manually following the install instructions located at https://rclone.org/install/ rclone selfupdate [flags] Options --beta Install beta release --check Check for latest release, do not download -h, --help help for selfupdate --output string Save the downloaded binary at a given path (default: replace running binary) --package string Package format: zip|deb|rpm (default: zip) --stable Install stable release (this is the default) --version string Install the given rclone version (default: latest) See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. rclone serve Serve a remote over a protocol. Synopsis Serve a remote over a given protocol. Requires the use of a subcommand to specify the protocol, e.g. rclone serve http remote: Each subcommand has its own options which you can see in their help. rclone serve [opts] [flags] Options -h, --help help for serve See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. - rclone serve dlna - Serve remote:path over DLNA - rclone serve docker - Serve any remote on docker's volume plugin API. - rclone serve ftp - Serve remote:path over FTP. - rclone serve http - Serve the remote over HTTP. - rclone serve nfs - Serve the remote as an NFS mount - rclone serve restic - Serve the remote for restic's REST API. - rclone serve s3 - Serve remote:path over s3. - rclone serve sftp - Serve the remote over SFTP. - rclone serve webdav - Serve remote:path over WebDAV. rclone serve dlna Serve remote:path over DLNA Synopsis Run a DLNA media server for media stored in an rclone remote. Many devices, such as the Xbox and PlayStation, can automatically discover this server in the LAN and play audio/video from it. VLC is also supported. Service discovery uses UDP multicast packets (SSDP) and will thus only work on LANs. Rclone will list all files present in the remote, without filtering based on media formats or file extensions. Additionally, there is no media transcoding support. This means that some players might show files that they are not able to play back correctly. Rclone will add external subtitle files (.srt) to videos if they have the same filename as the video file itself (except the extension), either in the same directory as the video, or in a "Subs" subdirectory. Server options Use --addr to specify which IP address and port the server should listen on, e.g. --addr 1.2.3.4:8000 or --addr :8080 to listen to all IPs. Use --name to choose the friendly server name, which is by default "rclone (hostname)". Use --log-trace in conjunction with -vv to enable additional debug logging of all UPNP traffic. VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. VFS Directory Cache Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir VFS File Buffering The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to --buffer-size * open files. VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable. The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap. --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible - Files can't be opened for both read AND write - Files opened for write can't be seeked - Existing files opened for write must have O_TRUNC set - Files open for read with O_TRUNC will be opened write only - Files open for write only will behave as if O_TRUNC was supplied - Open modes O_APPEND, O_TRUNC are ignored - If an upload fails it can't be retried --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible - Files opened for write only can't be seeked - Existing files opened for write must have O_TRUNC set - Files opened for write only will ignore O_APPEND, O_TRUNC - If an upload fails it can't be retried --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes. When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk. When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required. IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it. If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the --vfs-read-chunk-streams parameter. --vfs-read-chunk-streams == 0 Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading. The chunks will not be buffered in memory. --vfs-read-chunk-streams > 0 Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting. Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput. VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature. In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination. Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer. This scheme is compatible with that used by the local backend with the --local-links flag. The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs. It hasn't been tested with the other rclone serve commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree . ├── dir │   └── file.txt └── linked-dir -> dir The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands. Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync. VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself. WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. VFS Metadata If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the --metadata flag. For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}. rclone serve dlna remote:path [flags] Options --addr string The ip:port or :port to bind the DLNA http server to (default ":7879") --announce-interval Duration The interval between SSDP announcements (default 12m0s) --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --file-perms FileMode File permissions (default 666) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for dlna --interface stringArray The interface to use for SSDP (repeat as necessary) --link-perms FileMode Link permissions (default 666) --log-trace Enable trace logging of SOAP traffic --name string Name of DLNA server --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) See Also - rclone serve - Serve a remote over a protocol. rclone serve docker Serve any remote on docker's volume plugin API. Synopsis This command implements the Docker volume plugin API allowing docker to use rclone as a data storage mechanism for various cloud providers. rclone provides docker volume plugin based on it. To create a docker plugin, one must create a Unix or TCP socket that Docker will look for when you use the plugin and then it listens for commands from docker daemon and runs the corresponding code when necessary. Docker plugins can run as a managed plugin under control of the docker daemon or as an independent native service. For testing, you can just run it directly from the command line, for example: sudo rclone serve docker --base-dir /tmp/rclone-volumes --socket-addr localhost:8787 -vv Running rclone serve docker will create the said socket, listening for commands from Docker to create the necessary Volumes. Normally you need not give the --socket-addr flag. The API will listen on the unix domain socket at /run/docker/plugins/rclone.sock. In the example above rclone will create a TCP socket and a small file /etc/docker/plugins/rclone.spec containing the socket address. We use sudo because both paths are writeable only by the root user. If you later decide to change listening socket, the docker daemon must be restarted to reconnect to /run/docker/plugins/rclone.sock or parse new /etc/docker/plugins/rclone.spec. Until you restart, any volume related docker commands will timeout trying to access the old socket. Running directly is supported on Linux only, not on Windows or MacOS. This is not a problem with managed plugin mode described in details in the full documentation. The command will create volume mounts under the path given by --base-dir (by default /var/lib/docker-volumes/rclone available only to root) and maintain the JSON formatted file docker-plugin.state in the rclone cache directory with book-keeping records of created and mounted volumes. All mount and VFS options are submitted by the docker daemon via API, but you can also provide defaults on the command line as well as set path to the config file and cache directory or adjust logging verbosity. VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. VFS Directory Cache Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir VFS File Buffering The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to --buffer-size * open files. VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable. The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap. --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible - Files can't be opened for both read AND write - Files opened for write can't be seeked - Existing files opened for write must have O_TRUNC set - Files open for read with O_TRUNC will be opened write only - Files open for write only will behave as if O_TRUNC was supplied - Open modes O_APPEND, O_TRUNC are ignored - If an upload fails it can't be retried --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible - Files opened for write only can't be seeked - Existing files opened for write must have O_TRUNC set - Files opened for write only will ignore O_APPEND, O_TRUNC - If an upload fails it can't be retried --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes. When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk. When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required. IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it. If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the --vfs-read-chunk-streams parameter. --vfs-read-chunk-streams == 0 Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading. The chunks will not be buffered in memory. --vfs-read-chunk-streams > 0 Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting. Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput. VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature. In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination. Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer. This scheme is compatible with that used by the local backend with the --local-links flag. The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs. It hasn't been tested with the other rclone serve commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree . ├── dir │   └── file.txt └── linked-dir -> dir The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands. Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync. VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself. WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. VFS Metadata If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the --metadata flag. For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}. rclone serve docker [flags] Options --allow-non-empty Allow mounting over a non-empty directory (not supported on Windows) --allow-other Allow access to other users (not supported on Windows) --allow-root Allow access to root user (not supported on Windows) --async-read Use asynchronous reads (not supported on Windows) (default true) --attr-timeout Duration Time for which file/directory attributes are cached (default 1s) --base-dir string Base directory for volumes (default "/var/lib/docker-volumes/rclone") --daemon Run mount in background and exit parent process (as background output is suppressed, use --log-file with --log-format=pid,... to monitor) (not supported on Windows) --daemon-timeout Duration Time limit for rclone to respond to kernel (not supported on Windows) (default 0s) --daemon-wait Duration Time to wait for ready mount from daemon (maximum time on Linux, constant sleep time on OSX/BSD) (not supported on Windows) (default 1m0s) --debug-fuse Debug the FUSE internals - needs -v --default-permissions Makes kernel enforce access control based on the file mode (not supported on Windows) --devname string Set the device name - default is remote:path --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --direct-io Use Direct IO, disables caching of data --file-perms FileMode File permissions (default 666) --forget-state Skip restoring previous state --fuse-flag stringArray Flags or arguments to be passed direct to libfuse/WinFsp (repeat if required) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for docker --link-perms FileMode Link permissions (default 666) --max-read-ahead SizeSuffix The number of bytes that can be prefetched for sequential reads (not supported on Windows) (default 128Ki) --mount-case-insensitive Tristate Tell the OS the mount is case insensitive (true) or sensitive (false) regardless of the backend (auto) (default unset) --network-mode Mount as remote network drive, instead of fixed disk drive (supported on Windows only) --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --no-spec Do not write spec file --noappledouble Ignore Apple Double (._) and .DS_Store files (supported on OSX only) (default true) --noapplexattr Ignore all "com.apple.*" extended attributes (supported on OSX only) -o, --option stringArray Option for libfuse/WinFsp (repeat if required) --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --socket-addr string Address or absolute path (default: /run/docker/plugins/rclone.sock) --socket-gid int GID for unix socket (default: current process GID) (default 1000) --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) --volname string Set the volume name (supported on Windows and OSX only) --write-back-cache Makes kernel buffer writes before sending them to rclone (without this, writethrough caching is used) (not supported on Windows) Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) See Also - rclone serve - Serve a remote over a protocol. rclone serve ftp Serve remote:path over FTP. Synopsis Run a basic FTP server to serve a remote over FTP protocol. This can be viewed with a FTP client or you can make a remote of type FTP to read and write it. Server options Use --addr to specify which IP address and port the server should listen on, e.g. --addr 1.2.3.4:8000 or --addr :8080 to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port. If you set --addr to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info. Authentication By default this will serve files without needing a login. You can set a single username and password with the --user and --pass flags. VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. VFS Directory Cache Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir VFS File Buffering The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to --buffer-size * open files. VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable. The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap. --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible - Files can't be opened for both read AND write - Files opened for write can't be seeked - Existing files opened for write must have O_TRUNC set - Files open for read with O_TRUNC will be opened write only - Files open for write only will behave as if O_TRUNC was supplied - Open modes O_APPEND, O_TRUNC are ignored - If an upload fails it can't be retried --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible - Files opened for write only can't be seeked - Existing files opened for write must have O_TRUNC set - Files opened for write only will ignore O_APPEND, O_TRUNC - If an upload fails it can't be retried --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes. When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk. When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required. IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it. If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the --vfs-read-chunk-streams parameter. --vfs-read-chunk-streams == 0 Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading. The chunks will not be buffered in memory. --vfs-read-chunk-streams > 0 Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting. Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput. VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature. In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination. Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer. This scheme is compatible with that used by the local backend with the --local-links flag. The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs. It hasn't been tested with the other rclone serve commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree . ├── dir │   └── file.txt └── linked-dir -> dir The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands. Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync. VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself. WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. VFS Metadata If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the --metadata flag. For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}. Auth Proxy If you supply the parameter --auth-proxy /path/to/program then rclone will use that program to generate backends on the fly which then are used to authenticate incoming requests. This uses a simple JSON based protocol with input on STDIN and output on STDOUT. PLEASE NOTE: --auth-proxy and --authorized-keys cannot be used together, if --auth-proxy is set the authorized keys option will be ignored. There is an example program bin/test_proxy.py in the rclone source code. The program's job is to take a user and pass on the input and turn those into the config for a backend on STDOUT in JSON format. This config will have any default parameters for the backend added, but it won't use configuration from environment variables or command line options - it is the job of the proxy program to make a complete config. This config generated must have this extra parameter - _root - root to use for the backend And it may have this parameter - _obscure - comma separated strings for parameters to obscure If password authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: { "user": "me", "pass": "mypassword" } If public-key authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: { "user": "me", "public_key": "AAAAB3NzaC1yc2EAAAADAQABAAABAQDuwESFdAe14hVS6omeyX7edc...JQdf" } And as an example return this on STDOUT { "type": "sftp", "_root": "", "_obscure": "pass", "user": "me", "pass": "mypassword", "host": "sftp.example.com" } This would mean that an SFTP backend would be created on the fly for the user and pass/public_key returned in the output to the host given. Note that since _obscure is set to pass, rclone will obscure the pass parameter before creating the backend (which is required for sftp backends). The program can manipulate the supplied user in any way, for example to make proxy to many different sftp backends, you could make the user be user@example.com and then set the host to example.com in the output and the user to user. For security you'd probably want to restrict the host to a limited list. Note that an internal cache is keyed on user so only use that for configuration, don't use pass or public_key. This also means that if a user's password or public-key is changed the cache will need to expire (which takes 5 mins) before it takes effect. This can be used to build general purpose proxies to any kind of backend that rclone supports. rclone serve ftp remote:path [flags] Options --addr string IPaddress:Port or :Port to bind server to (default "localhost:2121") --auth-proxy string A program to use to create the backend from the auth --cert string TLS PEM key (concatenation of certificate and CA certificate) --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --file-perms FileMode File permissions (default 666) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for ftp --key string TLS PEM Private key --link-perms FileMode Link permissions (default 666) --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --pass string Password for authentication (empty value allow every password) --passive-port string Passive port range to use (default "30000-32000") --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --public-ip string Public IP address to advertise for passive connections --read-only Only allow read-only access --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --user string User name for authentication (default "anonymous") --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) See Also - rclone serve - Serve a remote over a protocol. rclone serve http Serve the remote over HTTP. Synopsis Run a basic web server to serve a remote over HTTP. This can be viewed in a web browser or you can make a remote of type http read from it. You can use the filter flags (e.g. --include, --exclude) to control what is served. The server will log errors. Use -v to see access logs. --bwlimit will be respected for file transfers. Use --stats to control the stats printing. Server options Use --addr to specify which IP address and port the server should listen on, eg --addr 1.2.3.4:8000 or --addr :8080 to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port. If you set --addr to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info. You can use a unix socket by setting the url to unix:///path/to/socket or just by using an absolute path name. --addr may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same. --server-read-timeout and --server-write-timeout can be used to control the timeouts on the server. Note that this is the total time for a transfer. --max-header-bytes controls the maximum number of bytes the server will accept in the HTTP header. --baseurl controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used --baseurl "/rclone" then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on --baseurl, so --baseurl "rclone", --baseurl "/rclone" and --baseurl "/rclone/" are all treated identically. TLS (SSL) By default this will serve over http. If you want you can serve over https. You will need to supply the --cert and --key flags. If you wish to do client side certificate validation then you will need to supply --client-ca also. --cert must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. --key must be set to the path of a file with the PEM encoded private key. If setting --client-ca, it should be set to the path of a file with PEM encoded client certificate authority certificates. --min-tls-version is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0"). Socket activation Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by --addr). This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html Socket activation can be tested ad-hoc with the systemd-socket-activatecommand systemd-socket-activate -l 8000 -- rclone serve This will socket-activate rclone on the first connection to port 8000 over TCP. ### Template --template allows a user to specify a custom markup template for HTTP and WebDAV serve functions. The server exports the following markup to be used within the template to server pages: ----------------------------------------------------------------------- Parameter Description ----------------------------------- ----------------------------------- .Name The full path of a file/directory. .Title Directory listing of .Name .Sort The current sort used. This is changeable via ?sort= parameter Sort Options: namedirfirst,name,size,time (default namedirfirst) .Order The current ordering used. This is changeable via ?order= parameter Order Options: asc,desc (default asc) .Query Currently unused. .Breadcrumb Allows for creating a relative navigation -- .Link The relative to the root link of the Text. -- .Text The Name of the directory. .Entries Information about a specific file/directory. -- .URL The 'url' of an entry. -- .Leaf Currently same as 'URL' but intended to be 'just' the name. -- .IsDir Boolean for if an entry is a directory or not. -- .Size Size in Bytes of the entry. -- .ModTime The UTC timestamp of an entry. ----------------------------------------------------------------------- The server also makes the following functions available so that they can be used within the template. These functions help extend the options for dynamic rendering of HTML. They can be used to render HTML based on specific conditions. ----------------------------------------------------------------------- Function Description ----------------------------------- ----------------------------------- afterEpoch Returns the time since the epoch for the given time. contains Checks whether a given substring is present or not in a given string. hasPrefix Checks whether the given string begins with the specified prefix. hasSuffix Checks whether the given string end with the specified suffix. ----------------------------------------------------------------------- Authentication By default this will serve files without needing a login. You can either use an htpasswd file which can take lots of users, or set a single username and password with the --user and --pass flags. Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with --user-from-header (e.g., ----user-from-header=x-remote-user). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access. If either of the above authentication methods is not configured and client certificates are required by the --client-ca flag passed to the server, the client certificate common name will be considered as the username. Use --htpasswd /path/to/htpasswd to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended. To create an htpasswd file: touch htpasswd htpasswd -B htpasswd user htpasswd -B htpasswd anotherUser The password file can be updated while rclone is running. Use --realm to set the authentication realm. Use --salt to change the password hashing salt from the default. VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. VFS Directory Cache Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir VFS File Buffering The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to --buffer-size * open files. VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable. The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap. --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible - Files can't be opened for both read AND write - Files opened for write can't be seeked - Existing files opened for write must have O_TRUNC set - Files open for read with O_TRUNC will be opened write only - Files open for write only will behave as if O_TRUNC was supplied - Open modes O_APPEND, O_TRUNC are ignored - If an upload fails it can't be retried --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible - Files opened for write only can't be seeked - Existing files opened for write must have O_TRUNC set - Files opened for write only will ignore O_APPEND, O_TRUNC - If an upload fails it can't be retried --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes. When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk. When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required. IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it. If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the --vfs-read-chunk-streams parameter. --vfs-read-chunk-streams == 0 Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading. The chunks will not be buffered in memory. --vfs-read-chunk-streams > 0 Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting. Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput. VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature. In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination. Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer. This scheme is compatible with that used by the local backend with the --local-links flag. The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs. It hasn't been tested with the other rclone serve commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree . ├── dir │   └── file.txt └── linked-dir -> dir The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands. Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync. VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself. WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. VFS Metadata If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the --metadata flag. For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}. Auth Proxy If you supply the parameter --auth-proxy /path/to/program then rclone will use that program to generate backends on the fly which then are used to authenticate incoming requests. This uses a simple JSON based protocol with input on STDIN and output on STDOUT. PLEASE NOTE: --auth-proxy and --authorized-keys cannot be used together, if --auth-proxy is set the authorized keys option will be ignored. There is an example program bin/test_proxy.py in the rclone source code. The program's job is to take a user and pass on the input and turn those into the config for a backend on STDOUT in JSON format. This config will have any default parameters for the backend added, but it won't use configuration from environment variables or command line options - it is the job of the proxy program to make a complete config. This config generated must have this extra parameter - _root - root to use for the backend And it may have this parameter - _obscure - comma separated strings for parameters to obscure If password authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: { "user": "me", "pass": "mypassword" } If public-key authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: { "user": "me", "public_key": "AAAAB3NzaC1yc2EAAAADAQABAAABAQDuwESFdAe14hVS6omeyX7edc...JQdf" } And as an example return this on STDOUT { "type": "sftp", "_root": "", "_obscure": "pass", "user": "me", "pass": "mypassword", "host": "sftp.example.com" } This would mean that an SFTP backend would be created on the fly for the user and pass/public_key returned in the output to the host given. Note that since _obscure is set to pass, rclone will obscure the pass parameter before creating the backend (which is required for sftp backends). The program can manipulate the supplied user in any way, for example to make proxy to many different sftp backends, you could make the user be user@example.com and then set the host to example.com in the output and the user to user. For security you'd probably want to restrict the host to a limited list. Note that an internal cache is keyed on user so only use that for configuration, don't use pass or public_key. This also means that if a user's password or public-key is changed the cache will need to expire (which takes 5 mins) before it takes effect. This can be used to build general purpose proxies to any kind of backend that rclone supports. rclone serve http remote:path [flags] Options --addr stringArray IPaddress:Port or :Port to bind server to (default 127.0.0.1:8080) --allow-origin string Origin which cross-domain request (CORS) can be executed from --auth-proxy string A program to use to create the backend from the auth --baseurl string Prefix for URLs - leave blank for root --cert string TLS PEM key (concatenation of certificate and CA certificate) --client-ca string Client certificate authority to verify clients with --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --file-perms FileMode File permissions (default 666) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for http --htpasswd string A htpasswd file - if not provided no authentication is done --key string TLS PEM Private key --link-perms FileMode Link permissions (default 666) --max-header-bytes int Maximum size of request header (default 4096) --min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --pass string Password for authentication --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --realm string Realm for authentication --salt string Password hashing salt (default "dlPL2MqE") --server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --template string User-specified template --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --user string User name for authentication --user-from-header string User name from a defined HTTP header --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) See Also - rclone serve - Serve a remote over a protocol. rclone serve nfs Serve the remote as an NFS mount Synopsis Create an NFS server that serves the given remote over the network. This implements an NFSv3 server to serve any rclone remote via NFS. The primary purpose for this command is to enable the mount command on recent macOS versions where installing FUSE is very cumbersome. This server does not implement any authentication so any client will be able to access the data. To limit access, you can use serve nfs on the loopback address or rely on secure tunnels (such as SSH) or use firewalling. For this reason, by default, a random TCP port is chosen and the loopback interface is used for the listening address by default; meaning that it is only available to the local machine. If you want other machines to access the NFS mount over local network, you need to specify the listening address and port using the --addr flag. Modifying files through the NFS protocol requires VFS caching. Usually you will need to specify --vfs-cache-mode in order to be able to write to the mountpoint (full is recommended). If you don't specify VFS cache mode, the mount will be read-only. --nfs-cache-type controls the type of the NFS handle cache. By default this is memory where new handles will be randomly allocated when needed. These are stored in memory. If the server is restarted the handle cache will be lost and connected NFS clients will get stale handle errors. --nfs-cache-type disk uses an on disk NFS handle cache. Rclone hashes the path of the object and stores it in a file named after the hash. These hashes are stored on disk the directory controlled by --cache-dir or the exact directory may be specified with --nfs-cache-dir. Using this means that the NFS server can be restarted at will without affecting the connected clients. --nfs-cache-type symlink is similar to --nfs-cache-type disk in that it uses an on disk cache, but the cache entries are held as symlinks. Rclone will use the handle of the underlying file as the NFS handle which improves performance. This sort of cache can't be backed up and restored as the underlying handles will change. This is Linux only. It requires running rclone as root or with CAP_DAC_READ_SEARCH. You can run rclone with this extra permission by doing this to the rclone binary sudo setcap cap_dac_read_search+ep /path/to/rclone. --nfs-cache-handle-limit controls the maximum number of cached NFS handles stored by the caching handler. This should not be set too low or you may experience errors when trying to access files. The default is 1000000, but consider lowering this limit if the server's system resource usage causes problems. This is only used by the memory type cache. To serve NFS over the network use following command: rclone serve nfs remote: --addr 0.0.0.0:$PORT --vfs-cache-mode=full This specifies a port that can be used in the mount command. To mount the server under Linux/macOS, use the following command: mount -t nfs -o port=$PORT,mountport=$PORT,tcp $HOSTNAME:/ path/to/mountpoint Where $PORT is the same port number used in the serve nfs command and $HOSTNAME is the network address of the machine that serve nfs was run on. If --vfs-metadata-extension is in use then for the --nfs-cache-type disk and --nfs-cache-type cache the metadata files will have the file handle of their parent file suffixed with 0x00, 0x00, 0x00, 0x01. This means they can be looked up directly from the parent file handle is desired. This command is only available on Unix platforms. VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. VFS Directory Cache Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir VFS File Buffering The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to --buffer-size * open files. VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable. The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap. --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible - Files can't be opened for both read AND write - Files opened for write can't be seeked - Existing files opened for write must have O_TRUNC set - Files open for read with O_TRUNC will be opened write only - Files open for write only will behave as if O_TRUNC was supplied - Open modes O_APPEND, O_TRUNC are ignored - If an upload fails it can't be retried --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible - Files opened for write only can't be seeked - Existing files opened for write must have O_TRUNC set - Files opened for write only will ignore O_APPEND, O_TRUNC - If an upload fails it can't be retried --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes. When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk. When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required. IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it. If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the --vfs-read-chunk-streams parameter. --vfs-read-chunk-streams == 0 Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading. The chunks will not be buffered in memory. --vfs-read-chunk-streams > 0 Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting. Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput. VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature. In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination. Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer. This scheme is compatible with that used by the local backend with the --local-links flag. The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs. It hasn't been tested with the other rclone serve commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree . ├── dir │   └── file.txt └── linked-dir -> dir The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands. Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync. VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself. WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. VFS Metadata If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the --metadata flag. For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}. rclone serve nfs remote:path [flags] Options --addr string IPaddress:Port or :Port to bind server to --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --file-perms FileMode File permissions (default 666) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for nfs --link-perms FileMode Link permissions (default 666) --nfs-cache-dir string The directory the NFS handle cache will use if set --nfs-cache-handle-limit int max file handles cached simultaneously (min 5) (default 1000000) --nfs-cache-type memory|disk|symlink Type of NFS handle cache to use (default memory) --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) See Also - rclone serve - Serve a remote over a protocol. rclone serve restic Serve the remote for restic's REST API. Synopsis Run a basic web server to serve a remote over restic's REST backend API over HTTP. This allows restic to use rclone as a data storage mechanism for cloud providers that restic does not support directly. Restic is a command-line program for doing backups. The server will log errors. Use -v to see access logs. --bwlimit will be respected for file transfers. Use --stats to control the stats printing. Setting up rclone for use by restic First set up a remote for your chosen cloud provider. Once you have set up the remote, check it is working with, for example "rclone lsd remote:". You may have called the remote something other than "remote:" - just substitute whatever you called it in the following instructions. Now start the rclone restic server rclone serve restic -v remote:backup Where you can replace "backup" in the above by whatever path in the remote you wish to use. By default this will serve on "localhost:8080" you can change this with use of the --addr flag. You might wish to start this server on boot. Adding --cache-objects=false will cause rclone to stop caching objects returned from the List call. Caching is normally desirable as it speeds up downloading objects, saves transactions and uses very little memory. Setting up restic to use rclone Now you can follow the restic instructions on setting up restic. Note that you will need restic 0.8.2 or later to interoperate with rclone. For the example above you will want to use "http://localhost:8080/" as the URL for the REST server. For example: $ export RESTIC_REPOSITORY=rest:http://localhost:8080/ $ export RESTIC_PASSWORD=yourpassword $ restic init created restic backend 8b1a4b56ae at rest:http://localhost:8080/ Please note that knowledge of your password is required to access the repository. Losing your password means that your data is irrecoverably lost. $ restic backup /path/to/files/to/backup scan [/path/to/files/to/backup] scanned 189 directories, 312 files in 0:00 [0:00] 100.00% 38.128 MiB / 38.128 MiB 501 / 501 items 0 errors ETA 0:00 duration: 0:00 snapshot 45c8fdd8 saved Multiple repositories Note that you can use the endpoint to host multiple repositories. Do this by adding a directory name or path after the URL. Note that these must end with /. Eg $ export RESTIC_REPOSITORY=rest:http://localhost:8080/user1repo/ # backup user1 stuff $ export RESTIC_REPOSITORY=rest:http://localhost:8080/user2repo/ # backup user2 stuff Private repositories The--private-repos flag can be used to limit users to repositories starting with a path of //. Server options Use --addr to specify which IP address and port the server should listen on, eg --addr 1.2.3.4:8000 or --addr :8080 to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port. If you set --addr to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info. You can use a unix socket by setting the url to unix:///path/to/socket or just by using an absolute path name. --addr may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same. --server-read-timeout and --server-write-timeout can be used to control the timeouts on the server. Note that this is the total time for a transfer. --max-header-bytes controls the maximum number of bytes the server will accept in the HTTP header. --baseurl controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used --baseurl "/rclone" then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on --baseurl, so --baseurl "rclone", --baseurl "/rclone" and --baseurl "/rclone/" are all treated identically. TLS (SSL) By default this will serve over http. If you want you can serve over https. You will need to supply the --cert and --key flags. If you wish to do client side certificate validation then you will need to supply --client-ca also. --cert must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. --key must be set to the path of a file with the PEM encoded private key. If setting --client-ca, it should be set to the path of a file with PEM encoded client certificate authority certificates. --min-tls-version is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0"). Socket activation Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by --addr). This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html Socket activation can be tested ad-hoc with the systemd-socket-activatecommand systemd-socket-activate -l 8000 -- rclone serve This will socket-activate rclone on the first connection to port 8000 over TCP. ### Authentication By default this will serve files without needing a login. You can either use an htpasswd file which can take lots of users, or set a single username and password with the --user and --pass flags. Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with --user-from-header (e.g., ----user-from-header=x-remote-user). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access. If either of the above authentication methods is not configured and client certificates are required by the --client-ca flag passed to the server, the client certificate common name will be considered as the username. Use --htpasswd /path/to/htpasswd to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended. To create an htpasswd file: touch htpasswd htpasswd -B htpasswd user htpasswd -B htpasswd anotherUser The password file can be updated while rclone is running. Use --realm to set the authentication realm. Use --salt to change the password hashing salt from the default. rclone serve restic remote:path [flags] Options --addr stringArray IPaddress:Port or :Port to bind server to (default 127.0.0.1:8080) --allow-origin string Origin which cross-domain request (CORS) can be executed from --append-only Disallow deletion of repository data --baseurl string Prefix for URLs - leave blank for root --cache-objects Cache listed objects (default true) --cert string TLS PEM key (concatenation of certificate and CA certificate) --client-ca string Client certificate authority to verify clients with -h, --help help for restic --htpasswd string A htpasswd file - if not provided no authentication is done --key string TLS PEM Private key --max-header-bytes int Maximum size of request header (default 4096) --min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --pass string Password for authentication --private-repos Users can only access their private repo --realm string Realm for authentication --salt string Password hashing salt (default "dlPL2MqE") --server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --stdio Run an HTTP2 server on stdin/stdout --user string User name for authentication --user-from-header string User name from a defined HTTP header See the global flags page for global options not listed here. See Also - rclone serve - Serve a remote over a protocol. rclone serve s3 Serve remote:path over s3. Synopsis serve s3 implements a basic s3 server that serves a remote via s3. This can be viewed with an s3 client, or you can make an s3 type remote to read and write to it with rclone. serve s3 is considered Experimental so use with care. S3 server supports Signature Version 4 authentication. Just use --auth-key accessKey,secretKey and set the Authorization header correctly in the request. (See the AWS docs). --auth-key can be repeated for multiple auth pairs. If --auth-key is not provided then serve s3 will allow anonymous access. Please note that some clients may require HTTPS endpoints. See the SSL docs for more information. This command uses the VFS directory cache. All the functionality will work with --vfs-cache-mode off. Using --vfs-cache-mode full (or writes) can be used to cache objects locally to improve performance. Use --force-path-style=false if you want to use the bucket name as a part of the hostname (such as mybucket.local) Use --etag-hash if you want to change the hash uses for the ETag. Note that using anything other than MD5 (the default) is likely to cause problems for S3 clients which rely on the Etag being the MD5. Quickstart For a simple set up, to serve remote:path over s3, run the server like this: rclone serve s3 --auth-key ACCESS_KEY_ID,SECRET_ACCESS_KEY remote:path For example, to use a simple folder in the filesystem, run the server with a command like this: rclone serve s3 --auth-key ACCESS_KEY_ID,SECRET_ACCESS_KEY local:/path/to/folder The rclone.conf for the server could look like this: [local] type = local The local configuration is optional though. If you run the server with a remote:path like /path/to/folder (without the local: prefix and without an rclone.conf file), rclone will fall back to a default configuration, which will be visible as a warning in the logs. But it will run nonetheless. This will be compatible with an rclone (client) remote configuration which is defined like this: [serves3] type = s3 provider = Rclone endpoint = http://127.0.0.1:8080/ access_key_id = ACCESS_KEY_ID secret_access_key = SECRET_ACCESS_KEY use_multipart_uploads = false Note that setting use_multipart_uploads = false is to work around a bug which will be fixed in due course. Bugs When uploading multipart files serve s3 holds all the parts in memory (see #7453). This is a limitaton of the library rclone uses for serving S3 and will hopefully be fixed at some point. Multipart server side copies do not work (see #7454). These take a very long time and eventually fail. The default threshold for multipart server side copies is 5G which is the maximum it can be, so files above this side will fail to be server side copied. For a current list of serve s3 bugs see the serve s3 bug category on GitHub. Limitations serve s3 will treat all directories in the root as buckets and ignore all files in the root. You can use CreateBucket to create folders under the root, but you can't create empty folders under other folders not in the root. When using PutObject or DeleteObject, rclone will automatically create or clean up empty folders. If you don't want to clean up empty folders automatically, use --no-cleanup. When using ListObjects, rclone will use / when the delimiter is empty. This reduces backend requests with no effect on most operations, but if the delimiter is something other than / and empty, rclone will do a full recursive search of the backend, which can take some time. Versioning is not currently supported. Metadata will only be saved in memory other than the rclone mtime metadata which will be set as the modification time of the file. Supported operations serve s3 currently supports the following operations. - Bucket - ListBuckets - CreateBucket - DeleteBucket - Object - HeadObject - ListObjects - GetObject - PutObject - DeleteObject - DeleteObjects - CreateMultipartUpload - CompleteMultipartUpload - AbortMultipartUpload - CopyObject - UploadPart Other operations will return error Unimplemented. Authentication By default this will serve files without needing a login. You can either use an htpasswd file which can take lots of users, or set a single username and password with the --user and --pass flags. Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with --user-from-header (e.g., ----user-from-header=x-remote-user). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access. If either of the above authentication methods is not configured and client certificates are required by the --client-ca flag passed to the server, the client certificate common name will be considered as the username. Use --htpasswd /path/to/htpasswd to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended. To create an htpasswd file: touch htpasswd htpasswd -B htpasswd user htpasswd -B htpasswd anotherUser The password file can be updated while rclone is running. Use --realm to set the authentication realm. Use --salt to change the password hashing salt from the default. Server options Use --addr to specify which IP address and port the server should listen on, eg --addr 1.2.3.4:8000 or --addr :8080 to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port. If you set --addr to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info. You can use a unix socket by setting the url to unix:///path/to/socket or just by using an absolute path name. --addr may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same. --server-read-timeout and --server-write-timeout can be used to control the timeouts on the server. Note that this is the total time for a transfer. --max-header-bytes controls the maximum number of bytes the server will accept in the HTTP header. --baseurl controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used --baseurl "/rclone" then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on --baseurl, so --baseurl "rclone", --baseurl "/rclone" and --baseurl "/rclone/" are all treated identically. TLS (SSL) By default this will serve over http. If you want you can serve over https. You will need to supply the --cert and --key flags. If you wish to do client side certificate validation then you will need to supply --client-ca also. --cert must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. --key must be set to the path of a file with the PEM encoded private key. If setting --client-ca, it should be set to the path of a file with PEM encoded client certificate authority certificates. --min-tls-version is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0"). Socket activation Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by --addr). This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html Socket activation can be tested ad-hoc with the systemd-socket-activatecommand systemd-socket-activate -l 8000 -- rclone serve This will socket-activate rclone on the first connection to port 8000 over TCP. ## VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. VFS Directory Cache Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir VFS File Buffering The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to --buffer-size * open files. VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable. The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap. --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible - Files can't be opened for both read AND write - Files opened for write can't be seeked - Existing files opened for write must have O_TRUNC set - Files open for read with O_TRUNC will be opened write only - Files open for write only will behave as if O_TRUNC was supplied - Open modes O_APPEND, O_TRUNC are ignored - If an upload fails it can't be retried --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible - Files opened for write only can't be seeked - Existing files opened for write must have O_TRUNC set - Files opened for write only will ignore O_APPEND, O_TRUNC - If an upload fails it can't be retried --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes. When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk. When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required. IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it. If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the --vfs-read-chunk-streams parameter. --vfs-read-chunk-streams == 0 Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading. The chunks will not be buffered in memory. --vfs-read-chunk-streams > 0 Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting. Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput. VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature. In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination. Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer. This scheme is compatible with that used by the local backend with the --local-links flag. The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs. It hasn't been tested with the other rclone serve commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree . ├── dir │   └── file.txt └── linked-dir -> dir The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands. Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync. VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself. WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. VFS Metadata If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the --metadata flag. For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}. rclone serve s3 remote:path [flags] Options --addr stringArray IPaddress:Port or :Port to bind server to (default 127.0.0.1:8080) --allow-origin string Origin which cross-domain request (CORS) can be executed from --auth-key stringArray Set key pair for v4 authorization: access_key_id,secret_access_key --auth-proxy string A program to use to create the backend from the auth --baseurl string Prefix for URLs - leave blank for root --cert string TLS PEM key (concatenation of certificate and CA certificate) --client-ca string Client certificate authority to verify clients with --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --etag-hash string Which hash to use for the ETag, or auto or blank for off (default "MD5") --file-perms FileMode File permissions (default 666) --force-path-style If true use path style access if false use virtual hosted style (default true) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for s3 --htpasswd string A htpasswd file - if not provided no authentication is done --key string TLS PEM Private key --link-perms FileMode Link permissions (default 666) --max-header-bytes int Maximum size of request header (default 4096) --min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --no-checksum Don't compare checksums on up/download --no-cleanup Not to cleanup empty folder after object is deleted --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --pass string Password for authentication --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --realm string Realm for authentication --salt string Password hashing salt (default "dlPL2MqE") --server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --user string User name for authentication --user-from-header string User name from a defined HTTP header --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) See Also - rclone serve - Serve a remote over a protocol. rclone serve sftp Serve the remote over SFTP. Synopsis Run an SFTP server to serve a remote over SFTP. This can be used with an SFTP client or you can make a remote of type sftp to use with it. You can use the filter flags (e.g. --include, --exclude) to control what is served. The server will respond to a small number of shell commands, mainly md5sum, sha1sum and df, which enable it to provide support for checksums and the about feature when accessed from an sftp remote. Note that this server uses standard 32 KiB packet payload size, which means you must not configure the client to expect anything else, e.g. with the chunk_size option on an sftp remote. The server will log errors. Use -v to see access logs. --bwlimit will be respected for file transfers. Use --stats to control the stats printing. You must provide some means of authentication, either with --user/--pass, an authorized keys file (specify location with --authorized-keys - the default is the same as ssh), an --auth-proxy, or set the --no-auth flag for no authentication when logging in. If you don't supply a host --key then rclone will generate rsa, ecdsa and ed25519 variants, and cache them for later use in rclone's cache directory (see rclone help flags cache-dir) in the "serve-sftp" directory. By default the server binds to localhost:2022 - if you want it to be reachable externally then supply --addr :2022 for example. This also supports being run with socket activation, in which case it will listen on the first passed FD. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html Socket activation can be tested ad-hoc with the systemd-socket-activatecommand: systemd-socket-activate -l 2222 -- rclone serve sftp :local:vfs/ This will socket-activate rclone on the first connection to port 2222 over TCP. Note that the default of --vfs-cache-mode off is fine for the rclone sftp backend, but it may not be with other SFTP clients. If --stdio is specified, rclone will serve SFTP over stdio, which can be used with sshd via ~/.ssh/authorized_keys, for example: restrict,command="rclone serve sftp --stdio ./photos" ssh-rsa ... On the client you need to set --transfers 1 when using --stdio. Otherwise multiple instances of the rclone server are started by OpenSSH which can lead to "corrupted on transfer" errors. This is the case because the client chooses indiscriminately which server to send commands to while the servers all have different views of the state of the filing system. The "restrict" in authorized_keys prevents SHA1SUMs and MD5SUMs from being used. Omitting "restrict" and using --sftp-path-override to enable checksumming is possible but less secure and you could use the SFTP server provided by OpenSSH in this case. VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. VFS Directory Cache Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir VFS File Buffering The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to --buffer-size * open files. VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable. The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap. --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible - Files can't be opened for both read AND write - Files opened for write can't be seeked - Existing files opened for write must have O_TRUNC set - Files open for read with O_TRUNC will be opened write only - Files open for write only will behave as if O_TRUNC was supplied - Open modes O_APPEND, O_TRUNC are ignored - If an upload fails it can't be retried --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible - Files opened for write only can't be seeked - Existing files opened for write must have O_TRUNC set - Files opened for write only will ignore O_APPEND, O_TRUNC - If an upload fails it can't be retried --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes. When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk. When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required. IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it. If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the --vfs-read-chunk-streams parameter. --vfs-read-chunk-streams == 0 Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading. The chunks will not be buffered in memory. --vfs-read-chunk-streams > 0 Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting. Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput. VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature. In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination. Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer. This scheme is compatible with that used by the local backend with the --local-links flag. The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs. It hasn't been tested with the other rclone serve commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree . ├── dir │   └── file.txt └── linked-dir -> dir The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands. Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync. VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself. WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. VFS Metadata If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the --metadata flag. For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}. Auth Proxy If you supply the parameter --auth-proxy /path/to/program then rclone will use that program to generate backends on the fly which then are used to authenticate incoming requests. This uses a simple JSON based protocol with input on STDIN and output on STDOUT. PLEASE NOTE: --auth-proxy and --authorized-keys cannot be used together, if --auth-proxy is set the authorized keys option will be ignored. There is an example program bin/test_proxy.py in the rclone source code. The program's job is to take a user and pass on the input and turn those into the config for a backend on STDOUT in JSON format. This config will have any default parameters for the backend added, but it won't use configuration from environment variables or command line options - it is the job of the proxy program to make a complete config. This config generated must have this extra parameter - _root - root to use for the backend And it may have this parameter - _obscure - comma separated strings for parameters to obscure If password authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: { "user": "me", "pass": "mypassword" } If public-key authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: { "user": "me", "public_key": "AAAAB3NzaC1yc2EAAAADAQABAAABAQDuwESFdAe14hVS6omeyX7edc...JQdf" } And as an example return this on STDOUT { "type": "sftp", "_root": "", "_obscure": "pass", "user": "me", "pass": "mypassword", "host": "sftp.example.com" } This would mean that an SFTP backend would be created on the fly for the user and pass/public_key returned in the output to the host given. Note that since _obscure is set to pass, rclone will obscure the pass parameter before creating the backend (which is required for sftp backends). The program can manipulate the supplied user in any way, for example to make proxy to many different sftp backends, you could make the user be user@example.com and then set the host to example.com in the output and the user to user. For security you'd probably want to restrict the host to a limited list. Note that an internal cache is keyed on user so only use that for configuration, don't use pass or public_key. This also means that if a user's password or public-key is changed the cache will need to expire (which takes 5 mins) before it takes effect. This can be used to build general purpose proxies to any kind of backend that rclone supports. rclone serve sftp remote:path [flags] Options --addr string IPaddress:Port or :Port to bind server to (default "localhost:2022") --auth-proxy string A program to use to create the backend from the auth --authorized-keys string Authorized keys file (default "~/.ssh/authorized_keys") --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --file-perms FileMode File permissions (default 666) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for sftp --key stringArray SSH private host key file (Can be multi-valued, leave blank to auto generate) --link-perms FileMode Link permissions (default 666) --no-auth Allow connections with no authentication if set --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --pass string Password for authentication --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --stdio Run an sftp server on stdin/stdout --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --user string User name for authentication --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) See Also - rclone serve - Serve a remote over a protocol. rclone serve webdav Serve remote:path over WebDAV. Synopsis Run a basic WebDAV server to serve a remote over HTTP via the WebDAV protocol. This can be viewed with a WebDAV client, through a web browser, or you can make a remote of type WebDAV to read and write it. WebDAV options --etag-hash This controls the ETag header. Without this flag the ETag will be based on the ModTime and Size of the object. If this flag is set to "auto" then rclone will choose the first supported hash on the backend or you can use a named hash such as "MD5" or "SHA-1". Use the hashsum command to see the full list. Access WebDAV on Windows WebDAV shared folder can be mapped as a drive on Windows, however the default settings prevent it. Windows will fail to connect to the server using insecure Basic authentication. It will not even display any login dialog. Windows requires SSL / HTTPS connection to be used with Basic. If you try to connect via Add Network Location Wizard you will get the following error: "The folder you entered does not appear to be valid. Please choose another". However, you still can connect if you set the following registry key on a client machine: HKEY_LOCAL_MACHINEto 2. The BasicAuthLevel can be set to the following values: 0 - Basic authentication disabled 1 - Basic authentication enabled for SSL connections only 2 - Basic authentication enabled for SSL connections and for non-SSL connections If required, increase the FileSizeLimitInBytes to a higher value. Navigate to the Services interface, then restart the WebClient service. Access Office applications on WebDAV Navigate to following registry HKEY_CURRENT_USER[14.0/15.0/16.0] Create a new DWORD BasicAuthLevel with value 2. 0 - Basic authentication disabled 1 - Basic authentication enabled for SSL connections only 2 - Basic authentication enabled for SSL and for non-SSL connections https://learn.microsoft.com/en-us/office/troubleshoot/powerpoint/office-opens-blank-from-sharepoint Serving over a unix socket You can serve the webdav on a unix socket like this: rclone serve webdav --addr unix:///tmp/my.socket remote:path and connect to it like this using rclone and the webdav backend: rclone --webdav-unix-socket /tmp/my.socket --webdav-url http://localhost lsf :webdav: Note that there is no authentication on http protocol - this is expected to be done by the permissions on the socket. Server options Use --addr to specify which IP address and port the server should listen on, eg --addr 1.2.3.4:8000 or --addr :8080 to listen to all IPs. By default it only listens on localhost. You can use port :0 to let the OS choose an available port. If you set --addr to listen on a public or LAN accessible IP address then using Authentication is advised - see the next section for info. You can use a unix socket by setting the url to unix:///path/to/socket or just by using an absolute path name. --addr may be repeated to listen on multiple IPs/ports/sockets. Socket activation, described further below, can also be used to accomplish the same. --server-read-timeout and --server-write-timeout can be used to control the timeouts on the server. Note that this is the total time for a transfer. --max-header-bytes controls the maximum number of bytes the server will accept in the HTTP header. --baseurl controls the URL prefix that rclone serves from. By default rclone will serve from the root. If you used --baseurl "/rclone" then rclone would serve from a URL starting with "/rclone/". This is useful if you wish to proxy rclone serve. Rclone automatically inserts leading and trailing "/" on --baseurl, so --baseurl "rclone", --baseurl "/rclone" and --baseurl "/rclone/" are all treated identically. TLS (SSL) By default this will serve over http. If you want you can serve over https. You will need to supply the --cert and --key flags. If you wish to do client side certificate validation then you will need to supply --client-ca also. --cert must be set to the path of a file containing either a PEM encoded certificate, or a concatenation of that with the CA certificate. --key must be set to the path of a file with the PEM encoded private key. If setting --client-ca, it should be set to the path of a file with PEM encoded client certificate authority certificates. --min-tls-version is minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0"). Socket activation Instead of the listening addresses specified above, rclone will listen to all FDs passed by the service manager, if any (and ignore any arguments passed by --addr). This allows rclone to be a socket-activated service. It can be configured with .socket and .service unit files as described in https://www.freedesktop.org/software/systemd/man/latest/systemd.socket.html Socket activation can be tested ad-hoc with the systemd-socket-activatecommand systemd-socket-activate -l 8000 -- rclone serve This will socket-activate rclone on the first connection to port 8000 over TCP. ### Template --template allows a user to specify a custom markup template for HTTP and WebDAV serve functions. The server exports the following markup to be used within the template to server pages: ----------------------------------------------------------------------- Parameter Description ----------------------------------- ----------------------------------- .Name The full path of a file/directory. .Title Directory listing of .Name .Sort The current sort used. This is changeable via ?sort= parameter Sort Options: namedirfirst,name,size,time (default namedirfirst) .Order The current ordering used. This is changeable via ?order= parameter Order Options: asc,desc (default asc) .Query Currently unused. .Breadcrumb Allows for creating a relative navigation -- .Link The relative to the root link of the Text. -- .Text The Name of the directory. .Entries Information about a specific file/directory. -- .URL The 'url' of an entry. -- .Leaf Currently same as 'URL' but intended to be 'just' the name. -- .IsDir Boolean for if an entry is a directory or not. -- .Size Size in Bytes of the entry. -- .ModTime The UTC timestamp of an entry. ----------------------------------------------------------------------- The server also makes the following functions available so that they can be used within the template. These functions help extend the options for dynamic rendering of HTML. They can be used to render HTML based on specific conditions. ----------------------------------------------------------------------- Function Description ----------------------------------- ----------------------------------- afterEpoch Returns the time since the epoch for the given time. contains Checks whether a given substring is present or not in a given string. hasPrefix Checks whether the given string begins with the specified prefix. hasSuffix Checks whether the given string end with the specified suffix. ----------------------------------------------------------------------- Authentication By default this will serve files without needing a login. You can either use an htpasswd file which can take lots of users, or set a single username and password with the --user and --pass flags. Alternatively, you can have the reverse proxy manage authentication and use the username provided in the configured header with --user-from-header (e.g., ----user-from-header=x-remote-user). Ensure the proxy is trusted and headers cannot be spoofed, as misconfiguration may lead to unauthorized access. If either of the above authentication methods is not configured and client certificates are required by the --client-ca flag passed to the server, the client certificate common name will be considered as the username. Use --htpasswd /path/to/htpasswd to provide an htpasswd file. This is in standard apache format and supports MD5, SHA1 and BCrypt for basic authentication. Bcrypt is recommended. To create an htpasswd file: touch htpasswd htpasswd -B htpasswd user htpasswd -B htpasswd anotherUser The password file can be updated while rclone is running. Use --realm to set the authentication realm. Use --salt to change the password hashing salt from the default. VFS - Virtual File System This command uses the VFS layer. This adapts the cloud storage objects that rclone uses into something which looks much more like a disk filing system. Cloud storage objects have lots of properties which aren't like disk files - you can't extend them or write to the middle of them, so the VFS layer has to deal with that. Because there is no one right way of doing this there are various options explained below. The VFS layer also implements a directory cache - this caches info about files and directories (but not the data) in memory. VFS Directory Cache Using the --dir-cache-time flag, you can control how long a directory should be considered up to date and not refreshed from the backend. Changes made through the VFS will appear immediately or invalidate the cache. --dir-cache-time duration Time to cache directory entries for (default 5m0s) --poll-interval duration Time to wait between polling for changes. Must be smaller than dir-cache-time. Only on supported remotes. Set to 0 to disable (default 1m0s) However, changes made directly on the cloud storage by the web interface or a different copy of rclone will only be picked up once the directory cache expires if the backend configured does not support polling for changes. If the backend supports polling, changes will be picked up within the polling interval. You can send a SIGHUP signal to rclone for it to flush all directory caches, regardless of how old they are. Assuming only one rclone instance is running, you can reset the cache like this: kill -SIGHUP $(pidof rclone) If you configure rclone with a remote control then you can use rclone rc to flush the whole directory cache: rclone rc vfs/forget Or individual files or directories: rclone rc vfs/forget file=path/to/file dir=path/to/dir VFS File Buffering The --buffer-size flag determines the amount of memory, that will be used to buffer data in advance. Each open file will try to keep the specified amount of data in memory at all times. The buffered data is bound to one open file and won't be shared. This flag is a upper limit for the used memory per open file. The buffer will only use memory for data that is downloaded but not not yet read. If the buffer is empty, only a small amount of memory will be used. The maximum memory used by rclone for buffering can be up to --buffer-size * open files. VFS File Caching These flags control the VFS file caching options. File caching is necessary to make the VFS layer appear compatible with a normal file system. It can be disabled at the cost of some compatibility. For example you'll need to enable VFS caching if you want to read and write simultaneously to a file. See below for more details. Note that the VFS cache is separate from the cache backend and you may find that you need one or the other or both. --cache-dir string Directory rclone will use for caching. --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-max-age duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-poll-interval duration Interval to poll the cache for stale objects (default 1m0s) --vfs-write-back duration Time to writeback files after last use when using cache (default 5s) If run with -vv rclone will print the location of the file cache. The files are stored in the user cache file area which is OS dependent but can be controlled with --cache-dir or setting the appropriate environment variable. The cache has 4 different modes selected by --vfs-cache-mode. The higher the cache mode the more compatible rclone becomes at the cost of using disk space. Note that files are written back to the remote only when they are closed and if they haven't been accessed for --vfs-write-back seconds. If rclone is quit or dies with files that haven't been uploaded, these will be uploaded next time rclone is run with the same flags. If using --vfs-cache-max-size or --vfs-cache-min-free-space note that the cache may exceed these quotas for two reasons. Firstly because it is only checked every --vfs-cache-poll-interval. Secondly because open files cannot be evicted from the cache. When --vfs-cache-max-size or --vfs-cache-min-free-space is exceeded, rclone will attempt to evict the least accessed files from the cache first. rclone will start with files that haven't been accessed for the longest. This cache flushing strategy is efficient and more relevant files are likely to remain cached. The --vfs-cache-max-age will evict files from the cache after the set time since last access has passed. The default value of 1 hour will start evicting files from cache that haven't been accessed for 1 hour. When a cached file is accessed the 1 hour timer is reset to 0 and will wait for 1 more hour before evicting. Specify the time with standard notation, s, m, h, d, w . You should not run two copies of rclone using the same VFS cache with the same or overlapping remotes if using --vfs-cache-mode > off. This can potentially cause data corruption if you do. You can work around this by giving each rclone its own cache hierarchy with --cache-dir. You don't need to worry about this if the remotes in use don't overlap. --vfs-cache-mode off In this mode (the default) the cache will read directly from the remote and write directly to the remote without caching anything on disk. This will mean some operations are not possible - Files can't be opened for both read AND write - Files opened for write can't be seeked - Existing files opened for write must have O_TRUNC set - Files open for read with O_TRUNC will be opened write only - Files open for write only will behave as if O_TRUNC was supplied - Open modes O_APPEND, O_TRUNC are ignored - If an upload fails it can't be retried --vfs-cache-mode minimal This is very similar to "off" except that files opened for read AND write will be buffered to disk. This means that files opened for write will be a lot more compatible, but uses the minimal disk space. These operations are not possible - Files opened for write only can't be seeked - Existing files opened for write must have O_TRUNC set - Files opened for write only will ignore O_APPEND, O_TRUNC - If an upload fails it can't be retried --vfs-cache-mode writes In this mode files opened for read only are still read directly from the remote, write only and read/write files are buffered to disk first. This mode should support all normal file system operations. If an upload fails it will be retried at exponentially increasing intervals up to 1 minute. --vfs-cache-mode full In this mode all reads and writes are buffered to and from disk. When data is read from the remote this is buffered to disk as well. In this mode the files in the cache will be sparse files and rclone will keep track of which bits of the files it has downloaded. So if an application only reads the starts of each file, then rclone will only buffer the start of the file. These files will appear to be their full size in the cache, but they will be sparse files with only the data that has been downloaded present in them. This mode should support all normal file system operations and is otherwise identical to --vfs-cache-mode writes. When reading a file rclone will read --buffer-size plus --vfs-read-ahead bytes ahead. The --buffer-size is buffered in memory whereas the --vfs-read-ahead is buffered on disk. When using this mode it is recommended that --buffer-size is not set too large and --vfs-read-ahead is set large if required. IMPORTANT not all file systems support sparse files. In particular FAT/exFAT do not. Rclone will perform very badly if the cache directory is on a filesystem which doesn't support sparse files and it will log an ERROR message if one is detected. Fingerprinting Various parts of the VFS use fingerprinting to see if a local file copy has changed relative to a remote file. Fingerprints are made from: - size - modification time - hash where available on an object. On some backends some of these attributes are slow to read (they take an extra API call per object, or extra work per object). For example hash is slow with the local and sftp backends as they have to read the entire file and hash it, and modtime is slow with the s3, swift, ftp and qinqstor backends because they need to do an extra API call to fetch it. If you use the --vfs-fast-fingerprint flag then rclone will not include the slow operations in the fingerprint. This makes the fingerprinting less accurate but much faster and will improve the opening time of cached files. If you are running a vfs cache over local, s3 or swift backends then using this flag is recommended. Note that if you change the value of this flag, the fingerprints of the files in the cache may be invalidated and the files will need to be downloaded again. VFS Chunked Reading When rclone reads files from a remote it reads them in chunks. This means that rather than requesting the whole file rclone reads the chunk specified. This can reduce the used download quota for some remotes by requesting only chunks from the remote that are actually read, at the cost of an increased number of requests. These flags control the chunking: --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128M) --vfs-read-chunk-size-limit SizeSuffix Max chunk doubling size (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once The chunking behaves differently depending on the --vfs-read-chunk-streams parameter. --vfs-read-chunk-streams == 0 Rclone will start reading a chunk of size --vfs-read-chunk-size, and then double the size for each read. When --vfs-read-chunk-size-limit is specified, and greater than --vfs-read-chunk-size, the chunk size for each open file will get doubled only until the specified value is reached. If the value is "off", which is the default, the limit is disabled and the chunk size will grow indefinitely. With --vfs-read-chunk-size 100M and --vfs-read-chunk-size-limit 0 the following parts will be downloaded: 0-100M, 100M-200M, 200M-300M, 300M-400M and so on. When --vfs-read-chunk-size-limit 500M is specified, the result would be 0-100M, 100M-300M, 300M-700M, 700M-1200M, 1200M-1700M and so on. Setting --vfs-read-chunk-size to 0 or "off" disables chunked reading. The chunks will not be buffered in memory. --vfs-read-chunk-streams > 0 Rclone reads --vfs-read-chunk-streams chunks of size --vfs-read-chunk-size concurrently. The size for each read will stay constant. This improves performance performance massively on high latency links or very high bandwidth links to high performance object stores. Some experimentation will be needed to find the optimum values of --vfs-read-chunk-size and --vfs-read-chunk-streams as these will depend on the backend in use and the latency to the backend. For high performance object stores (eg AWS S3) a reasonable place to start might be --vfs-read-chunk-streams 16 and --vfs-read-chunk-size 4M. In testing with AWS S3 the performance scaled roughly as the --vfs-read-chunk-streams setting. Similar settings should work for high latency links, but depending on the latency they may need more --vfs-read-chunk-streams in order to get the throughput. VFS Performance These flags may be used to enable/disable features of the VFS for performance or other reasons. See also the chunked reading feature. In particular S3 and Swift benefit hugely from the --no-modtime flag (or use --use-server-modtime for a slightly different effect) as each read of the modification time takes a transaction. --no-checksum Don't compare checksums on up/download. --no-modtime Don't read/write the modification time (can speed things up). --no-seek Don't allow seeking in files. --read-only Only allow read-only access. Sometimes rclone is delivered reads or writes out of order. Rather than seeking rclone will wait a short time for the in sequence read or write to come in. These flags only come into effect when not using an on disk cache file. --vfs-read-wait duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-write-wait duration Time to wait for in-sequence write before giving error (default 1s) When using VFS write caching (--vfs-cache-mode with value writes or full), the global flag --transfers can be set to adjust the number of parallel uploads of modified files from the cache (the related global flag --checkers has no effect on the VFS). --transfers int Number of file transfers to run in parallel (default 4) Symlinks By default the VFS does not support symlinks. However this may be enabled with either of the following flags: --links Translate symlinks to/from regular files with a '.rclonelink' extension. --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS As most cloud storage systems do not support symlinks directly, rclone stores the symlink as a normal file with a special extension. So a file which appears as a symlink link-to-file.txt would be stored on cloud storage as link-to-file.txt.rclonelink and the contents would be the path to the symlink destination. Note that --links enables symlink translation globally in rclone - this includes any backend which supports the concept (for example the local backend). --vfs-links just enables it for the VFS layer. This scheme is compatible with that used by the local backend with the --local-links flag. The --vfs-links flag has been designed for rclone mount, rclone nfsmount and rclone serve nfs. It hasn't been tested with the other rclone serve commands yet. A limitation of the current implementation is that it expects the caller to resolve sub-symlinks. For example given this directory tree . ├── dir │   └── file.txt └── linked-dir -> dir The VFS will correctly resolve linked-dir but not linked-dir/file.txt. This is not a problem for the tested commands but may be for other commands. Note that there is an outstanding issue with symlink support issue #8245 with duplicate files being created when symlinks are moved into directories where there is a file of the same name (or vice versa). VFS Case Sensitivity Linux file systems are case-sensitive: two files can differ only by case, and the exact case must be used when opening a file. File systems in modern Windows are case-insensitive but case-preserving: although existing files can be opened using any case, the exact case used to create the file is preserved and available for programs to query. It is not allowed for two files in the same directory to differ only by case. Usually file systems on macOS are case-insensitive. It is possible to make macOS file systems case-sensitive but that is not the default. The --vfs-case-insensitive VFS flag controls how rclone handles these two cases. If its value is "false", rclone passes file names to the remote as-is. If the flag is "true" (or appears without a value on the command line), rclone may perform a "fixup" as explained below. The user may specify a file name to open/delete/rename/etc with a case different than what is stored on the remote. If an argument refers to an existing file with exactly the same name, then the case of the existing file on the disk will be used. However, if a file name with exactly the same name is not found but a name differing only by case exists, rclone will transparently fixup the name. This fixup happens only when an existing file is requested. Case sensitivity of file names created anew by rclone is controlled by the underlying remote. Note that case sensitivity of the operating system running rclone (the target) may differ from case sensitivity of a file system presented by rclone (the source). The flag controls whether "fixup" is performed to satisfy the target. If the flag is not provided on the command line, then its default value depends on the operating system where rclone runs: "true" on Windows and macOS, "false" otherwise. If the flag is provided without a value, then it is "true". The --no-unicode-normalization flag controls whether a similar "fixup" is performed for filenames that differ but are canonically equivalent with respect to unicode. Unicode normalization can be particularly helpful for users of macOS, which prefers form NFD instead of the NFC used by most other platforms. It is therefore highly recommended to keep the default of false on macOS, to avoid encoding compatibility issues. In the (probably unlikely) event that a directory has multiple duplicate filenames after applying case and unicode normalization, the --vfs-block-norm-dupes flag allows hiding these duplicates. This comes with a performance tradeoff, as rclone will have to scan the entire directory for duplicates when listing a directory. For this reason, it is recommended to leave this disabled if not needed. However, macOS users may wish to consider using it, as otherwise, if a remote directory contains both NFC and NFD versions of the same filename, an odd situation will occur: both versions of the file will be visible in the mount, and both will appear to be editable, however, editing either version will actually result in only the NFD version getting edited under the hood. --vfs-block- norm-dupes prevents this confusion by detecting this scenario, hiding the duplicates, and logging an error, similar to how this is handled in rclone sync. VFS Disk Options This flag allows you to manually set the statistics about the filing system. It can be useful when those statistics cannot be read correctly automatically. --vfs-disk-space-total-size Manually set the total disk space size (example: 256G, default: -1) Alternate report of used bytes Some backends, most notably S3, do not report the amount of bytes used. If you need this information to be available when running df on the filesystem, then pass the flag --vfs-used-is-size to rclone. With this flag set, instead of relying on the backend to report this information, rclone will scan the whole remote similar to rclone size and compute the total used space itself. WARNING. Contrary to rclone size, this flag ignores filters so that the result is accurate. However, this is very inefficient and may cost lots of API calls resulting in extra charges. Use it as a last resort and only with caching. VFS Metadata If you use the --vfs-metadata-extension flag you can get the VFS to expose files which contain the metadata as a JSON blob. These files will not appear in the directory listing, but can be stat-ed and opened and once they have been they will appear in directory listings until the directory cache expires. Note that some backends won't create metadata unless you pass in the --metadata flag. For example, using rclone mount with --metadata --vfs-metadata-extension .metadata we get $ ls -l /mnt/ total 1048577 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G $ cat /mnt/1G.metadata { "atime": "2025-03-04T17:34:22.317069787Z", "btime": "2025-03-03T16:03:37.708253808Z", "gid": "1000", "mode": "100664", "mtime": "2025-03-03T16:03:39.640238323Z", "uid": "1000" } $ ls -l /mnt/ total 1048578 -rw-rw-r-- 1 user user 1073741824 Mar 3 16:03 1G -rw-rw-r-- 1 user user 185 Mar 3 16:03 1G.metadata If the file has no metadata it will be returned as {} and if there is an error reading the metadata the error will be returned as {"error":"error string"}. Auth Proxy If you supply the parameter --auth-proxy /path/to/program then rclone will use that program to generate backends on the fly which then are used to authenticate incoming requests. This uses a simple JSON based protocol with input on STDIN and output on STDOUT. PLEASE NOTE: --auth-proxy and --authorized-keys cannot be used together, if --auth-proxy is set the authorized keys option will be ignored. There is an example program bin/test_proxy.py in the rclone source code. The program's job is to take a user and pass on the input and turn those into the config for a backend on STDOUT in JSON format. This config will have any default parameters for the backend added, but it won't use configuration from environment variables or command line options - it is the job of the proxy program to make a complete config. This config generated must have this extra parameter - _root - root to use for the backend And it may have this parameter - _obscure - comma separated strings for parameters to obscure If password authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: { "user": "me", "pass": "mypassword" } If public-key authentication was used by the client, input to the proxy process (on STDIN) would look similar to this: { "user": "me", "public_key": "AAAAB3NzaC1yc2EAAAADAQABAAABAQDuwESFdAe14hVS6omeyX7edc...JQdf" } And as an example return this on STDOUT { "type": "sftp", "_root": "", "_obscure": "pass", "user": "me", "pass": "mypassword", "host": "sftp.example.com" } This would mean that an SFTP backend would be created on the fly for the user and pass/public_key returned in the output to the host given. Note that since _obscure is set to pass, rclone will obscure the pass parameter before creating the backend (which is required for sftp backends). The program can manipulate the supplied user in any way, for example to make proxy to many different sftp backends, you could make the user be user@example.com and then set the host to example.com in the output and the user to user. For security you'd probably want to restrict the host to a limited list. Note that an internal cache is keyed on user so only use that for configuration, don't use pass or public_key. This also means that if a user's password or public-key is changed the cache will need to expire (which takes 5 mins) before it takes effect. This can be used to build general purpose proxies to any kind of backend that rclone supports. rclone serve webdav remote:path [flags] Options --addr stringArray IPaddress:Port or :Port to bind server to (default 127.0.0.1:8080) --allow-origin string Origin which cross-domain request (CORS) can be executed from --auth-proxy string A program to use to create the backend from the auth --baseurl string Prefix for URLs - leave blank for root --cert string TLS PEM key (concatenation of certificate and CA certificate) --client-ca string Client certificate authority to verify clients with --dir-cache-time Duration Time to cache directory entries for (default 5m0s) --dir-perms FileMode Directory permissions (default 777) --disable-dir-list Disable HTML directory list on GET request for a directory --etag-hash string Which hash to use for the ETag, or auto or blank for off --file-perms FileMode File permissions (default 666) --gid uint32 Override the gid field set by the filesystem (not supported on Windows) (default 1000) -h, --help help for webdav --htpasswd string A htpasswd file - if not provided no authentication is done --key string TLS PEM Private key --link-perms FileMode Link permissions (default 666) --max-header-bytes int Maximum size of request header (default 4096) --min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --no-checksum Don't compare checksums on up/download --no-modtime Don't read/write the modification time (can speed things up) --no-seek Don't allow seeking in files --pass string Password for authentication --poll-interval Duration Time to wait between polling for changes, must be smaller than dir-cache-time and only on supported remotes (set 0 to disable) (default 1m0s) --read-only Only allow read-only access --realm string Realm for authentication --salt string Password hashing salt (default "dlPL2MqE") --server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --template string User-specified template --uid uint32 Override the uid field set by the filesystem (not supported on Windows) (default 1000) --umask FileMode Override the permission bits set by the filesystem (not supported on Windows) (default 002) --user string User name for authentication --user-from-header string User name from a defined HTTP header --vfs-block-norm-dupes If duplicate filenames exist in the same directory (after normalization), log an error and hide the duplicates (may have a performance cost) --vfs-cache-max-age Duration Max time since last access of objects in the cache (default 1h0m0s) --vfs-cache-max-size SizeSuffix Max total size of objects in the cache (default off) --vfs-cache-min-free-space SizeSuffix Target minimum free space on the disk containing the cache (default off) --vfs-cache-mode CacheMode Cache mode off|minimal|writes|full (default off) --vfs-cache-poll-interval Duration Interval to poll the cache for stale objects (default 1m0s) --vfs-case-insensitive If a file name not found, find a case insensitive match --vfs-disk-space-total-size SizeSuffix Specify the total space of disk (default off) --vfs-fast-fingerprint Use fast (less accurate) fingerprints for change detection --vfs-links Translate symlinks to/from regular files with a '.rclonelink' extension for the VFS --vfs-metadata-extension string Set the extension to read metadata from --vfs-read-ahead SizeSuffix Extra read ahead over --buffer-size when using cache-mode full --vfs-read-chunk-size SizeSuffix Read the source objects in chunks (default 128Mi) --vfs-read-chunk-size-limit SizeSuffix If greater than --vfs-read-chunk-size, double the chunk size after each chunk read, until the limit is reached ('off' is unlimited) (default off) --vfs-read-chunk-streams int The number of parallel streams to read at once --vfs-read-wait Duration Time to wait for in-sequence read before seeking (default 20ms) --vfs-refresh Refreshes the directory cache recursively in the background on start --vfs-used-is-size rclone size Use the rclone size algorithm for Used size --vfs-write-back Duration Time to writeback files after last use when using cache (default 5s) --vfs-write-wait Duration Time to wait for in-sequence write before giving error (default 1s) Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) See Also - rclone serve - Serve a remote over a protocol. rclone settier Changes storage class/tier of objects in remote. Synopsis Changes storage tier or class at remote if supported. Few cloud storage services provides different storage classes on objects, for example AWS S3 and Glacier, Azure Blob storage - Hot, Cool and Archive, Google Cloud Storage, Regional Storage, Nearline, Coldline etc. Note that, certain tier changes make objects not available to access immediately. For example tiering to archive in azure blob storage makes objects in frozen state, user can restore by setting tier to Hot/Cool, similarly S3 to Glacier makes object inaccessible.true You can use it to tier single object rclone settier Cool remote:path/file Or use rclone filters to set tier on only specific files rclone --include "*.txt" settier Hot remote:path/dir Or just provide remote directory and all files in directory will be tiered rclone settier tier remote:path/dir rclone settier tier remote:path [flags] Options -h, --help help for settier See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. rclone test Run a test command Synopsis Rclone test is used to run test commands. Select which test command you want with the subcommand, eg rclone test memory remote: Each subcommand has its own options which you can see in their help. NB Be careful running these commands, they may do strange things so reading their documentation first is recommended. Options -h, --help help for test See the global flags page for global options not listed here. See Also - rclone - Show help for rclone commands, flags and backends. - rclone test changenotify - Log any change notify requests for the remote passed in. - rclone test histogram - Makes a histogram of file name characters. - rclone test info - Discovers file name or other limitations for paths. - rclone test makefile - Make files with random contents of the size given - rclone test makefiles - Make a random file hierarchy in a directory - rclone test memory - Load all the objects at remote:path into memory and report memory stats. rclone test changenotify Log any change notify requests for the remote passed in. rclone test changenotify remote: [flags] Options -h, --help help for changenotify --poll-interval Duration Time to wait between polling for changes (default 10s) See the global flags page for global options not listed here. See Also - rclone test - Run a test command rclone test histogram Makes a histogram of file name characters. Synopsis This command outputs JSON which shows the histogram of characters used in filenames in the remote:path specified. The data doesn't contain any identifying information but is useful for the rclone developers when developing filename compression. rclone test histogram [remote:path] [flags] Options -h, --help help for histogram See the global flags page for global options not listed here. See Also - rclone test - Run a test command rclone test info Discovers file name or other limitations for paths. Synopsis Discovers what filenames and upload methods are possible to write to the paths passed in and how long they can be. It can take some time. It will write test files into the remote:path passed in. It outputs a bit of go code for each one. NB this can create undeletable files and other hazards - use with care rclone test info [remote:path]+ [flags] Options --all Run all tests --check-base32768 Check can store all possible base32768 characters --check-control Check control characters --check-length Check max filename length --check-normalization Check UTF-8 Normalization --check-streaming Check uploads with indeterminate file size -h, --help help for info --keep-test-files Keep test files after execution --upload-wait Duration Wait after writing a file (default 0s) --write-json string Write results to file See the global flags page for global options not listed here. See Also - rclone test - Run a test command rclone test makefile Make files with random contents of the size given rclone test makefile []+ [flags] Options --ascii Fill files with random ASCII printable bytes only --chargen Fill files with a ASCII chargen pattern -h, --help help for makefile --pattern Fill files with a periodic pattern --seed int Seed for the random number generator (0 for random) (default 1) --sparse Make the files sparse (appear to be filled with ASCII 0x00) --zero Fill files with ASCII 0x00 See the global flags page for global options not listed here. See Also - rclone test - Run a test command rclone test makefiles Make a random file hierarchy in a directory rclone test makefiles [flags] Options --ascii Fill files with random ASCII printable bytes only --chargen Fill files with a ASCII chargen pattern --files int Number of files to create (default 1000) --files-per-directory int Average number of files per directory (default 10) --flat If set create all files in the root directory -h, --help help for makefiles --max-depth int Maximum depth of directory hierarchy (default 10) --max-file-size SizeSuffix Maximum size of files to create (default 100) --max-name-length int Maximum size of file names (default 12) --min-file-size SizeSuffix Minimum size of file to create --min-name-length int Minimum size of file names (default 4) --pattern Fill files with a periodic pattern --seed int Seed for the random number generator (0 for random) (default 1) --sparse Make the files sparse (appear to be filled with ASCII 0x00) --zero Fill files with ASCII 0x00 See the global flags page for global options not listed here. See Also - rclone test - Run a test command rclone test memory Load all the objects at remote:path into memory and report memory stats. rclone test memory remote:path [flags] Options -h, --help help for memory See the global flags page for global options not listed here. See Also - rclone test - Run a test command rclone touch Create new file or change file modification time. Synopsis Set the modification time on file(s) as specified by remote:path to have the current time. If remote:path does not exist then a zero sized file will be created, unless --no-create or --recursive is provided. If --recursive is used then recursively sets the modification time on all existing files that is found under the path. Filters are supported, and you can test with the --dry-run or the --interactive/-i flag. This will touch --transfers files concurrently. If --timestamp is used then sets the modification time to that time instead of the current time. Times may be specified as one of: - 'YYMMDD' - e.g. 17.10.30 - 'YYYY-MM-DDTHH:MM:SS' - e.g. 2006-01-02T15:04:05 - 'YYYY-MM-DDTHH:MM:SS.SSS' - e.g. 2006-01-02T15:04:05.123456789 Note that value of --timestamp is in UTC. If you want local time then add the --localtime flag. rclone touch remote:path [flags] Options -h, --help help for touch --localtime Use localtime for timestamp, not UTC -C, --no-create Do not create the file if it does not exist (implied with --recursive) -R, --recursive Recursively touch all files -t, --timestamp string Use specified time instead of the current time of day Options shared with other commands are described next. See the global flags page for global options not listed here. Important Options Important flags useful for most commands -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. rclone tree List the contents of the remote in a tree like fashion. Synopsis Lists the contents of a remote in a similar way to the unix tree command. For example $ rclone tree remote:path / ├── file1 ├── file2 ├── file3 └── subdir ├── file4 └── file5 1 directories, 5 files You can use any of the filtering options with the tree command (e.g. --include and --exclude. You can also use --fast-list. The tree command has many options for controlling the listing which are compatible with the tree command, for example you can include file sizes with --size. Note that not all of them have short options as they conflict with rclone's short options. For a more interactive navigation of the remote see the ncdu command. rclone tree remote:path [flags] Options -a, --all All files are listed (list . files too) -d, --dirs-only List directories only --dirsfirst List directories before files (-U disables) --full-path Print the full path prefix for each file -h, --help help for tree --level int Descend only level directories deep -D, --modtime Print the date of last modification. --noindent Don't print indentation lines --noreport Turn off file/directory count at end of tree listing -o, --output string Output to file instead of stdout -p, --protections Print the protections for each file. -Q, --quote Quote filenames with double quotes. -s, --size Print the size in bytes of each file. --sort string Select sort: name,version,size,mtime,ctime --sort-ctime Sort files by last status change time -t, --sort-modtime Sort files by last modification time -r, --sort-reverse Reverse the order of the sort -U, --unsorted Leave files unsorted --version Sort files alphanumerically by version Options shared with other commands are described next. See the global flags page for global options not listed here. Filter Options Flags for filtering directory listings --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Options Flags for listing directories --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions See Also - rclone - Show help for rclone commands, flags and backends. Copying single files rclone normally syncs or copies directories. However, if the source remote points to a file, rclone will just copy that file. The destination remote must point to a directory - rclone will give the error Failed to create file system for "remote:file": is a file not a directory if it isn't. For example, suppose you have a remote with a file in called test.jpg, then you could copy just that file like this rclone copy remote:test.jpg /tmp/download The file test.jpg will be placed inside /tmp/download. This is equivalent to specifying rclone copy --files-from /tmp/files remote: /tmp/download Where /tmp/files contains the single line test.jpg It is recommended to use copy when copying individual files, not sync. They have pretty much the same effect but copy will use a lot less memory. Syntax of remote paths The syntax of the paths passed to the rclone command are as follows. /path/to/dir This refers to the local file system. On Windows \ may be used instead of / in local paths only, non local paths must use /. See local filesystem documentation for more about Windows-specific paths. These paths needn't start with a leading / - if they don't then they will be relative to the current directory. remote:path/to/dir This refers to a directory path/to/dir on remote: as defined in the config file (configured with rclone config). remote:/path/to/dir On most backends this is refers to the same directory as remote:path/to/dir and that format should be preferred. On a very small number of remotes (FTP, SFTP, Dropbox for business) this will refer to a different directory. On these, paths without a leading / will refer to your "home" directory and paths with a leading / will refer to the root. :backend:path/to/dir This is an advanced form for creating remotes on the fly. backend should be the name or prefix of a backend (the type in the config file) and all the configuration for the backend should be provided on the command line (or in environment variables). Here are some examples: rclone lsd --http-url https://pub.rclone.org :http: To list all the directories in the root of https://pub.rclone.org/. rclone lsf --http-url https://example.com :http:path/to/dir To list files and directories in https://example.com/path/to/dir/ rclone copy --http-url https://example.com :http:path/to/dir /tmp/dir To copy files and directories in https://example.com/path/to/dir to /tmp/dir. rclone copy --sftp-host example.com :sftp:path/to/dir /tmp/dir To copy files and directories from example.com in the relative directory path/to/dir to /tmp/dir using sftp. Connection strings The above examples can also be written using a connection string syntax, so instead of providing the arguments as command line parameters --http-url https://pub.rclone.org they are provided as part of the remote specification as a kind of connection string. rclone lsd ":http,url='https://pub.rclone.org':" rclone lsf ":http,url='https://example.com':path/to/dir" rclone copy ":http,url='https://example.com':path/to/dir" /tmp/dir rclone copy :sftp,host=example.com:path/to/dir /tmp/dir These can apply to modify existing remotes as well as create new remotes with the on the fly syntax. This example is equivalent to adding the --drive-shared-with-me parameter to the remote gdrive:. rclone lsf "gdrive,shared_with_me:path/to/dir" The major advantage to using the connection string style syntax is that it only applies to the remote, not to all the remotes of that type of the command line. A common confusion is this attempt to copy a file shared on google drive to the normal drive which does not work because the --drive-shared-with-me flag applies to both the source and the destination. rclone copy --drive-shared-with-me gdrive:shared-file.txt gdrive: However using the connection string syntax, this does work. rclone copy "gdrive,shared_with_me:shared-file.txt" gdrive: Note that the connection string only affects the options of the immediate backend. If for example gdriveCrypt is a crypt based on gdrive, then the following command will not work as intended, because shared_with_me is ignored by the crypt backend: rclone copy "gdriveCrypt,shared_with_me:shared-file.txt" gdriveCrypt: The connection strings have the following syntax remote,parameter=value,parameter2=value2:path/to/dir :backend,parameter=value,parameter2=value2:path/to/dir If the parameter has a : or , then it must be placed in quotes " or ', so remote,parameter="colon:value",parameter2="comma,value":path/to/dir :backend,parameter='colon:value',parameter2='comma,value':path/to/dir If a quoted value needs to include that quote, then it should be doubled, so remote,parameter="with""quote",parameter2='with''quote':path/to/dir This will make parameter be with"quote and parameter2 be with'quote. If you leave off the =parameter then rclone will substitute =true which works very well with flags. For example, to use s3 configured in the environment you could use: rclone lsd :s3,env_auth: Which is equivalent to rclone lsd :s3,env_auth=true: Note that on the command line you might need to surround these connection strings with " or ' to stop the shell interpreting any special characters within them. If you are a shell master then you'll know which strings are OK and which aren't, but if you aren't sure then enclose them in " and use ' as the inside quote. This syntax works on all OSes. rclone copy ":http,url='https://example.com':path/to/dir" /tmp/dir On Linux/macOS some characters are still interpreted inside " strings in the shell (notably \ and $ and ") so if your strings contain those you can swap the roles of " and ' thus. (This syntax does not work on Windows.) rclone copy ':http,url="https://example.com":path/to/dir' /tmp/dir Connection strings, config and logging If you supply extra configuration to a backend by command line flag, environment variable or connection string then rclone will add a suffix based on the hash of the config to the name of the remote, eg rclone -vv lsf --s3-chunk-size 20M s3: Has the log message DEBUG : s3: detected overridden config - adding "{Srj1p}" suffix to name This is so rclone can tell the modified remote apart from the unmodified remote when caching the backends. This should only be noticeable in the logs. This means that on the fly backends such as rclone -vv lsf :s3,env_auth: Will get their own names DEBUG : :s3: detected overridden config - adding "{YTu53}" suffix to name Valid remote names Remote names are case sensitive, and must adhere to the following rules: - May contain number, letter, _, -, ., +, @ and space. - May not start with - or space. - May not end with space. Starting with rclone version 1.61, any Unicode numbers and letters are allowed, while in older versions it was limited to plain ASCII (0-9, A-Z, a-z). If you use the same rclone configuration from different shells, which may be configured with different character encoding, you must be cautious to use characters that are possible to write in all of them. This is mostly a problem on Windows, where the console traditionally uses a non-Unicode character set - defined by the so-called "code page". Do not use single character names on Windows as it creates ambiguity with Windows drives' names, e.g.: remote called C is indistinguishable from C drive. Rclone will always assume that single letter name refers to a drive. Adding global configuration to a remote It is possible to add global configuration to the remote configuration which will be applied just before the remote is created. This can be done in two ways. The first is to use override.var = value in the config file or the connection string for a temporary change, and the second is to use global.var = value in the config file or connection string for a permanent change. This is explained fully below. override.var This is used to override a global variable just for the duration of the remote creation. It won't affect other remotes even if they are created at the same time. This is very useful for overriding networking config needed for just for that remote. For example, say you have a remote which needs --no-check-certificate as it is running on test infrastructure without a proper certificate. You could supply the --no-check-certificate flag to rclone, but this will affect all the remotes. To make it just affect this remote you use an override. You could put this in the config file: [remote] type = XXX ... override.no_check_certificate = true or use it in the connection string remote,override.no_check_certificate=true: (or just remote,override.no_check_certificate:). Note how the global flag name loses its initial -- and gets - replaced with _ and gets an override. prefix. Not all global variables make sense to be overridden like this as the config is only applied during the remote creation. Here is a non exhaustive list of ones which might be useful: - bind_addr - ca_cert - client_cert - client_key - connect_timeout - disable_http2 - disable_http_keep_alives - dump - expect_continue_timeout - headers - http_proxy - low_level_retries - max_connections - no_check_certificate - no_gzip - timeout - traffic_class - use_cookies - use_server_modtime - user_agent An override.var will override all other config methods, but just for the duration of the creation of the remote. global.var This is used to set a global variable for everything. The global variable is set just before the remote is created. This is useful for parameters (eg sync parameters) which can't be set as an override. For example, say you have a remote where you would always like to use the --checksum flag. You could supply the --checksum flag to rclone on every command line, but instead you could put this in the config file: [remote] type = XXX ... global.checksum = true or use it in the connection string remote,global.checksum=true: (or just remote,global.checksum:). This is equivalent to using the --checksum flag. Note how the global flag name loses its initial -- and gets - replaced with _ and gets a global. prefix. Any global variable can be set like this and it is exactly equivalent to using the equivalent flag on the command line. This means it will affect all uses of rclone. If two remotes set the same global variable then the first one instantiated will be overridden by the second one. A global.var will override all other config methods when the remote is created. Quoting and the shell When you are typing commands to your computer you are using something called the command line shell. This interprets various characters in an OS specific way. Here are some gotchas which may help users unfamiliar with the shell rules Linux / macOS If your names have spaces or shell metacharacters (e.g. *, ?, $, ', ", etc.) then you must quote them. Use single quotes ' by default. rclone copy 'Important files?' remote:backup If you want to send a ' you will need to use ", e.g. rclone copy "O'Reilly Reviews" remote:backup The rules for quoting metacharacters are complicated and if you want the full details you'll have to consult the manual page for your shell. Windows If your names have spaces in you need to put them in ", e.g. rclone copy "E:\folder name\folder name\folder name" remote:backup If you are using the root directory on its own then don't quote it (see #464 for why), e.g. rclone copy E:\ remote:backup Copying files or directories with : in the names rclone uses : to mark a remote name. This is, however, a valid filename component in non-Windows OSes. The remote name parser will only search for a : up to the first / so if you need to act on a file or directory like this then use the full path starting with a /, or use ./ as a current directory prefix. So to sync a directory called sync:me to a remote called remote: use rclone sync --interactive ./sync:me remote:path or rclone sync --interactive /full/path/to/sync:me remote:path Server-side copy Most remotes (but not all - see the overview) support server-side copy. This means if you want to copy one folder to another then rclone won't download all the files and re-upload them; it will instruct the server to copy them in place. Eg rclone copy s3:oldbucket s3:newbucket Will copy the contents of oldbucket to newbucket without downloading and re-uploading. Remotes which don't support server-side copy will download and re-upload in this case. Server-side copies are used with sync and copy and will be identified in the log when using the -v flag. The move command may also use them if remote doesn't support server-side move directly. This is done by issuing a server-side copy then a delete which is much quicker than a download and re-upload. Server-side copies will only be attempted if the remote names are the same. This can be used when scripting to make aged backups efficiently, e.g. rclone sync --interactive remote:current-backup remote:previous-backup rclone sync --interactive /path/to/files remote:current-backup Metadata support Metadata is data about a file (or directory) which isn't the contents of the file (or directory). Normally rclone only preserves the modification time and the content (MIME) type where possible. Rclone supports preserving all the available metadata on files and directories when using the --metadata or -M flag. Exactly what metadata is supported and what that support means depends on the backend. Backends that support metadata have a metadata section in their docs and are listed in the features table (Eg local, s3) Some backends don't support metadata, some only support metadata on files and some support metadata on both files and directories. Rclone only supports a one-time sync of metadata. This means that metadata will be synced from the source object to the destination object only when the source object has changed and needs to be re-uploaded. If the metadata subsequently changes on the source object without changing the object itself then it won't be synced to the destination object. This is in line with the way rclone syncs Content-Type without the --metadata flag. Using --metadata when syncing from local to local will preserve file attributes such as file mode, owner, extended attributes (not Windows). Note that arbitrary metadata may be added to objects using the --metadata-set key=value flag when the object is first uploaded. This flag can be repeated as many times as necessary. The --metadata-mapper flag can be used to pass the name of a program in which can transform metadata when it is being copied from source to destination. Rclone supports --metadata-set and --metadata-mapper when doing server-side Move and server-side Copy, but not when doing server side DirMove (renaming a directory) as this would involve recursing into the directory. Note that you can disable DirMove with --disable DirMove and rclone will revert back to using Move for each individual object where --metadata-set and --metadata-mapper are supported. Types of metadata Metadata is divided into two type. System metadata and User metadata. Metadata which the backend uses itself is called system metadata. For example on the local backend the system metadata uid will store the user ID of the file when used on a unix based platform. Arbitrary metadata is called user metadata and this can be set however is desired. When objects are copied from backend to backend, they will attempt to interpret system metadata if it is supplied. Metadata may change from being user metadata to system metadata as objects are copied between different backends. For example copying an object from s3 sets the content-type metadata. In a backend which understands this (like azureblob) this will become the Content-Type of the object. In a backend which doesn't understand this (like the local backend) this will become user metadata. However should the local object be copied back to s3, the Content-Type will be set correctly. Metadata framework Rclone implements a metadata framework which can read metadata from an object and write it to the object when (and only when) it is being uploaded. This metadata is stored as a dictionary with string keys and string values. There are some limits on the names of the keys (these may be clarified further in the future). - must be lower case - may be a-z 0-9 containing . - or _ - length is backend dependent Each backend can provide system metadata that it understands. Some backends can also store arbitrary user metadata. Where possible the key names are standardized, so, for example, it is possible to copy object metadata from s3 to azureblob for example and metadata will be translated appropriately. Some backends have limits on the size of the metadata and rclone will give errors on upload if they are exceeded. Metadata preservation The goal of the implementation is to 1. Preserve metadata if at all possible 2. Interpret metadata if at all possible The consequences of 1 is that you can copy an S3 object to a local disk then back to S3 losslessly. Likewise you can copy a local file with file attributes and xattrs from local disk to s3 and back again losslessly. The consequence of 2 is that you can copy an S3 object with metadata to Azureblob (say) and have the metadata appear on the Azureblob object also. Standard system metadata Here is a table of standard system metadata which, if appropriate, a backend may implement. ---------------------------------------------------------------------------------------------- key description example ---------------------------------- --------------------- ------------------------------------- mode File type and mode: 0100664 octal, unix style uid User ID of owner: 500 decimal number gid Group ID of owner: 500 decimal number rdev Device ID (if special 0 file) => hexadecimal atime Time of last access: 2006-01-02T15:04:05.999999999Z07:00 RFC 3339 mtime Time of last 2006-01-02T15:04:05.999999999Z07:00 modification: RFC 3339 btime Time of file creation 2006-01-02T15:04:05.999999999Z07:00 (birth): RFC 3339 utime Time of file upload: 2006-01-02T15:04:05.999999999Z07:00 RFC 3339 cache-control Cache-Control header no-cache content-disposition Content-Disposition inline header content-encoding Content-Encoding gzip header content-language Content-Language en-US header content-type Content-Type header text/plain ---------------------------------------------------------------------------------------------- The metadata keys mtime and content-type will take precedence if supplied in the metadata over reading the Content-Type or modification time of the source object. Hashes are not included in system metadata as there is a well defined way of reading those already. Options Rclone has a number of options to control its behaviour. These are documented below, and in the flags page. Options that take parameters can have the values passed in two ways, --option=value or --option value. However boolean (true/false) options behave slightly differently to the other options in that --boolean sets the option to true and the absence of the flag sets it to false. It is also possible to specify --boolean=false or --boolean=true. Note that --boolean false is not valid - this is parsed as --boolean and the false is parsed as an extra command line argument for rclone. String values that are recognized as special identifiers, e.g. the name of the log level to set with option --log-level, are case insensitive, e.g. --log-level ERROR and --log-level error are identical. Options documented to take a stringArray parameter accept multiple values. To pass more than one value, repeat the option; for example: --include value1 --include value2. Other options may only accept a single value, and should only be specified once, but where the specified parameter may indicate a list of values separated by space or comma. Such options are documented to take a CommaSepList parameter, if comma separated, and SpaceSepList if space separated, although some may also have different parameters such as DumpFlags or just string and the help text explains that this will be interpreted as a list. Floating-point values with fractional part must use period (.) as decimal separator, common in English-speaking countries, regardless of your configured system locale. Parameter type float accepts decimal and hexadecimal floating-point numbers as defined by the Go syntax for floating-point literals. Time and duration options Options that take a Time or Duration parameter must be specified as a formatted string describing an absolute or relative time. Note that both Time and Duration parameter types can be expressed as either absolute or relative time, just with different interpretations, e.g. a relative time will be treated as an offset from the current time when passed as a Time value. An absolute time can be specified as a string in one of the following formats: - RFC3339 - e.g. 2006-01-02T15:04:05Z or 2006-01-02T15:04:05+07:00 - ISO8601 Date and time, local timezone - 2006-01-02T15:04:05 - ISO8601 Date and time, local timezone - 2006-01-02 15:04:05 - ISO8601 Date - 2006-01-02 (YYYY-MM-DD) A relative time is a string with a, possibly signed, sequence of decimal numbers, each with optional fraction, and each with a unit suffix. If the string only contains a single number, then the unit suffix is optional and will default to seconds, i.e. a plain decimal value will be treated as a number of seconds. The following suffixes are valid: - ms - Milliseconds - s - Seconds - m - Minutes - h - Hours - d - Days - w - Weeks - M - Months - y - Years Examples: "10", "300ms", "-1.5h" or "2h45m". Size options Options that take a SizeSuffix parameter can be specified as an integer value, which will then be assumed to represent a KiB value (multiples of 1024 bytes) by default. The interpretation can be changed by appending a suffix: B for Byte, K for KiB, M for MiB, G for GiB, T for TiB and P for PiB. These are the binary units, e.g. 1, 2**10, 2**20, 2**30 respectively. See also --human-readable. Main options --backup-dir string When using sync, copy or move, any files which would have been overwritten or deleted are moved in their original hierarchy into this directory. If --suffix is set, then the moved files will have the suffix added to them. If there is a file with the same path (after the suffix has been added) in the directory, then it will be overwritten. The remote in use must support server-side move or copy and you must use the same remote as the destination of the sync. The backup directory must not overlap the destination directory without it being excluded by a filter rule. For example rclone sync --interactive /path/to/local remote:current --backup-dir remote:old will sync /path/to/local to remote:current, but for any files which would have been updated or deleted will be stored in remote:old. If running rclone from a script you might want to use today's date as the directory name passed to --backup-dir to store the old files, or you might want to pass --suffix with today's date. See --compare-dest and --copy-dest. --bind string Local address to bind to for outgoing connections. This can be an IPv4 address (1.2.3.4), an IPv6 address (1234::789A) or host name. If the host name doesn't resolve or resolves to more than one IP address it will give an error. You can use --bind 0.0.0.0 to force rclone to use IPv4 addresses and --bind ::0 to force rclone to use IPv6 addresses. --bwlimit BwTimetable This option controls the bandwidth limit. For example --bwlimit 10M would mean limit the upload and download bandwidth to 10 MiB/s. NB this is bytes per second not bits per second. To use a single limit, specify the desired bandwidth in KiB/s, or use a suffix B|K|M|G|T|P. The default is 0 which means to not limit bandwidth. The upload and download bandwidth can be specified separately, as --bwlimit UP:DOWN, so --bwlimit 10M:100k would mean limit the upload bandwidth to 10 MiB/s and the download bandwidth to 100 KiB/s. Either limit can be "off" meaning no limit, so to just limit the upload bandwidth you would use --bwlimit 10M:off this would limit the upload bandwidth to 10 MiB/s but the download bandwidth would be unlimited. When specified as above the bandwidth limits last for the duration of run of the rclone binary. It is also possible to specify a "timetable" of limits, which will cause certain limits to be applied at certain times. To specify a timetable, format your entries as WEEKDAY-HH:MM,BANDWIDTH WEEKDAY-HH:MM,BANDWIDTH... where: WEEKDAY is optional element. - BANDWIDTH can be a single number, e.g.100k or a pair of numbers for upload:download, e.g.10M:1M. - WEEKDAY can be written as the whole word or only using the first 3 characters. It is optional. - HH:MM is an hour from 00:00 to 23:59. Entries can be separated by spaces or semicolons. Note: Semicolons can be used as separators instead of spaces to avoid parsing issues in environments like Docker. An example of a typical timetable to avoid link saturation during daytime working hours could be: Using spaces as separators: --bwlimit "08:00,512k 12:00,10M 13:00,512k 18:00,30M 23:00,off" Using semicolons as separators: --bwlimit "08:00,512k;12:00,10M;13:00,512k;18:00,30M;23:00,off" In these examples, the transfer bandwidth will be set to 512 KiB/s at 8am every day. At noon, it will rise to 10 MiB/s, and drop back to 512 KiB/sec at 1pm. At 6pm, the bandwidth limit will be set to 30 MiB/s, and at 11pm it will be completely disabled (full speed). Anything between 11pm and 8am will remain unlimited. An example of timetable with WEEKDAY could be: Using spaces as separators: --bwlimit "Mon-00:00,512 Fri-23:59,10M Sat-10:00,1M Sun-20:00,off" Using semicolons as separators: --bwlimit "Mon-00:00,512;Fri-23:59,10M;Sat-10:00,1M;Sun-20:00,off" It means that, the transfer bandwidth will be set to 512 KiB/s on Monday. It will rise to 10 MiB/s before the end of Friday. At 10:00 on Saturday it will be set to 1 MiB/s. From 20:00 on Sunday it will be unlimited. Timeslots without WEEKDAY are extended to the whole week. So this example: --bwlimit "Mon-00:00,512 12:00,1M Sun-20:00,off" Is equivalent to this: --bwlimit "Mon-00:00,512Mon-12:00,1M Tue-12:00,1M Wed-12:00,1M Thu-12:00,1M Fri-12:00,1M Sat-12:00,1M Sun-12:00,1M Sun-20:00,off" Bandwidth limit apply to the data transfer for all backends. For most backends the directory listing bandwidth is also included (exceptions being the non HTTP backends, ftp, sftp and storj). Note that the units are Byte/s, not bit/s. Typically connections are measured in bit/s - to convert divide by 8. For example, let's say you have a 10 Mbit/s connection and you wish rclone to use half of it - 5 Mbit/s. This is 5/8 = 0.625 MiB/s so you would use a --bwlimit 0.625M parameter for rclone. On Unix systems (Linux, macOS, …) the bandwidth limiter can be toggled by sending a SIGUSR2 signal to rclone. This allows to remove the limitations of a long running rclone transfer and to restore it back to the value specified with --bwlimit quickly when needed. Assuming there is only one rclone instance running, you can toggle the limiter like this: kill -SIGUSR2 $(pidof rclone) If you configure rclone with a remote control then you can use change the bwlimit dynamically: rclone rc core/bwlimit rate=1M --bwlimit-file BwTimetable This option controls per file bandwidth limit. For the options see the --bwlimit flag. For example use this to allow no transfers to be faster than 1 MiB/s --bwlimit-file 1M This can be used in conjunction with --bwlimit. Note that if a schedule is provided the file will use the schedule in effect at the start of the transfer. --buffer-size SizeSuffix Use this sized buffer to speed up file transfers. Each --transfer will use this much memory for buffering. When using mount or cmount each open file descriptor will use this much memory for buffering. See the mount documentation for more details. Set to 0 to disable the buffering for the minimum memory usage. Note that the memory allocation of the buffers is influenced by the --use-mmap flag. --cache-dir string Specify the directory rclone will use for caching, to override the default. Default value is depending on operating system: - Windows %LocalAppData%\rclone, if LocalAppData is defined. - macOS $HOME/Library/Caches/rclone if HOME is defined. - Unix $XDG_CACHE_HOME/rclone if XDG_CACHE_HOME is defined, else $HOME/.cache/rclone if HOME is defined. - Fallback (on all OS) to $TMPDIR/rclone, where TMPDIR is the value from --temp-dir. You can use the config paths command to see the current value. Cache directory is heavily used by the VFS File Caching mount feature, but also by serve, GUI and other parts of rclone. --check-first If this flag is set then in a sync, copy or move, rclone will do all the checks to see whether files need to be transferred before doing any of the transfers. Normally rclone would start running transfers as soon as possible. This flag can be useful on IO limited systems where transfers interfere with checking. It can also be useful to ensure perfect ordering when using --order-by. If both --check-first and --order-by are set when doing rclone move then rclone will use the transfer thread to delete source files which don't need transferring. This will enable perfect ordering of the transfers and deletes but will cause the transfer stats to have more items in than expected. Using this flag can use more memory as it effectively sets --max-backlog to infinite. This means that all the info on the objects to transfer is held in memory before the transfers start. --checkers int Originally controlling just the number of file checkers to run in parallel, e.g. by rclone copy. Now a fairly universal parallelism control used by rclone in several places. Note: checkers do the equality checking of files during a sync. For some storage systems (e.g. S3, Swift, Dropbox) this can take a significant amount of time so they are run in parallel. The default is to run 8 checkers in parallel. However, in case of slow-reacting backends you may need to lower (rather than increase) this default by setting --checkers to 4 or less threads. This is especially advised if you are experiencing backend server crashes during file checking phase (e.g. on subsequent or top-up backups where little or no file copying is done and checking takes up most of the time). Increase this setting only with utmost care, while monitoring your server health and file checking throughput. -c, --checksum Normally rclone will look at modification time and size of files to see if they are equal. If you set this flag then rclone will check the file hash and size to determine if files are equal. This is useful when the remote doesn't support setting modified time and a more accurate sync is desired than just checking the file size. This is very useful when transferring between remotes which store the same hash type on the object, e.g. Drive and Swift. For details of which remotes support which hash type see the table in the overview section. Eg rclone --checksum sync s3:/bucket swift:/bucket would run much quicker than without the --checksum flag. When using this flag, rclone won't update mtimes of remote files if they are incorrect as it would normally. --color AUTO|NEVER|ALWAYS Specify when colors (and other ANSI codes) should be added to the output. AUTO only allows ANSI codes when the output is a terminal. This is the default. NEVER never allow ANSI codes. ALWAYS always add ANSI codes, regardless of the output format (terminal or file). --compare-dest stringArray When using sync, copy or move, the specified paths are checked in addition to the destination for files. If a file identical to the source is found, that file is not copied from source. This is useful to copy just files that have changed since the last backup. You must use the same remote as the destination of the sync. The compare directory must not overlap the destination directory. See --copy-dest and --backup-dir. --config string Specify the location of the rclone configuration file, to override the default. E.g. rclone config --config="rclone.conf". The exact default is a bit complex to describe, due to changes introduced through different versions of rclone while preserving backwards compatibility, but in most cases it is as simple as: - %APPDATA%/rclone/rclone.conf on Windows - ~/.config/rclone/rclone.conf on other The complete logic is as follows: Rclone will look for an existing configuration file in any of the following locations, in priority order: 1. rclone.conf (in program directory, where rclone executable is) 2. %APPDATA%/rclone/rclone.conf (only on Windows) 3. $XDG_CONFIG_HOME/rclone/rclone.conf (on all systems, including Windows) 4. ~/.config/rclone/rclone.conf (see below for explanation of ~ symbol) 5. ~/.rclone.conf If no existing configuration file is found, then a new one will be created in the following location: - On Windows: Location 2 listed above, except in the unlikely event that APPDATA is not defined, then location 4 is used instead. - On Unix: Location 3 if XDG_CONFIG_HOME is defined, else location 4. - Fallback to location 5 (on all OS), when the rclone directory cannot be created, but if also a home directory was not found then path .rclone.conf relative to current working directory will be used as a final resort. The ~ symbol in paths above represent the home directory of the current user on any OS, and the value is defined as following: - On Windows: %HOME% if defined, else %USERPROFILE%, or else %HOMEDRIVE%\%HOMEPATH%. - On Unix: $HOME if defined, else by looking up current user in OS-specific user database (e.g. passwd file), or else use the result from shell command cd && pwd. If you run rclone config file you will see where the default location is for you. Running rclone config touch will ensure a configuration file exists, creating an empty one in the default location if there is none. The fact that an existing file rclone.conf in the same directory as the rclone executable is always preferred, means that it is easy to run in "portable" mode by downloading rclone executable to a writable directory and then create an empty file rclone.conf in the same directory. If the location is set to empty string "" or path to a file with name notfound, or the os null device represented by value NUL on Windows and /dev/null on Unix systems, then rclone will keep the configuration file in memory only. You may see a log message "Config file not found - using defaults" if there is no configuration file. This can be supressed, e.g. if you are using rclone entirely with on the fly remotes, by using memory-only configuration file or by creating an empty configuration file, as described above. The file format is basic INI: Sections of text, led by a [section] header and followed by key=value entries on separate lines. In rclone each remote is represented by its own section, where the section name defines the name of the remote. Options are specified as the key=value entries, where the key is the option name without the --backend- prefix, in lowercase and with _ instead of -. E.g. option --mega-hard-delete corresponds to key hard_delete. Only backend options can be specified. A special, and required, key type identifies the storage system, where the value is the internal lowercase name as returned by command rclone help backends. Comments are indicated by ; or # at the beginning of a line. Example: [megaremote] type = mega user = you@example.com pass = PDPcQVVjVtzFY-GTdDFozqBhTdsPg3qH Note that passwords are in obscured form. Also, many storage systems uses token-based authentication instead of passwords, and this requires additional steps. It is easier, and safer, to use the interactive command rclone config instead of manually editing the configuration file. The configuration file will typically contain login information, and should therefore have restricted permissions so that only the current user can read it. Rclone tries to ensure this when it writes the file. You may also choose to encrypt the file. When token-based authentication are used, the configuration file must be writable, because rclone needs to update the tokens inside it. To reduce risk of corrupting an existing configuration file, rclone will not write directly to it when saving changes. Instead it will first write to a new, temporary, file. If a configuration file already existed, it will (on Unix systems) try to mirror its permissions to the new file. Then it will rename the existing file to a temporary name as backup. Next, rclone will rename the new file to the correct name, before finally cleaning up by deleting the backup file. If the configuration file path used by rclone is a symbolic link, then this will be evaluated and rclone will write to the resolved path, instead of overwriting the symbolic link. Temporary files used in the process (described above) will be written to the same parent directory as that of the resolved configuration file, but if this directory is also a symbolic link it will not be resolved and the temporary files will be written to the location of the directory symbolic link. --contimeout Duration Set the connection timeout. This should be in go time format which looks like 5s for 5 seconds, 10m for 10 minutes, or 3h30m. The connection timeout is the amount of time rclone will wait for a connection to go through to a remote object storage system. It is 1m by default. --copy-dest stringArray When using sync, copy or move, the specified paths are checked in addition to the destination for files. This part is the same as --compare-dest, but the difference is that with --copy-dest, if a file identical to the source is found, that file is server-side copied from the specified paths to the destination. This is useful for incremental backup. The remote in use must support server-side copy and you must use the same remote as the destination of the sync. The compare directory must not overlap the destination directory. See --compare-dest and --backup-dir. --dedupe-mode interactive|skip|first|newest|oldest|largest|smallest|rename|list Mode to run dedupe command in. One of interactive, skip, first, newest, oldest, largest, smallest, rename list. The default is interactive. See the dedupe command for more information as to what these options mean. --default-time Time If a file or directory does have a modification time rclone can read then rclone will display this fixed time instead. The default is 2000-01-01 00:00:00 UTC. This can be configured in any of the ways shown in time options. For example --default-time 2020-06-01 to set the default time to the 1st of June 2020 or --default-time 0s to set the default time to the time rclone started up. --disable string This disables a comma separated list of optional features. For example to disable server-side move and server-side copy use: --disable move,copy The features can be put in any case. To see a list of which features can be disabled use: --disable help The features a remote has can be seen in JSON format with: rclone backend features remote: See the overview features and optional features to get an idea of which feature does what. Note that some features can be set to true if they are true/false feature flag features by prefixing them with !. For example the CaseInsensitive feature can be forced to false with --disable CaseInsensitive and forced to true with --disable '!CaseInsensitive'. In general it isn't a good idea doing this but it may be useful in extremis. (Note that ! is a shell command which you will need to escape with single quotes or a backslash on unix like platforms.) This flag can be useful for debugging and in exceptional circumstances (e.g. Google Drive limiting the total volume of server-side copies to 100 GiB/day). --disable-http2 This stops rclone from trying to use HTTP/2 if available. This can sometimes speed up transfers due to a problem in the Go standard library. --dscp string Specify a DSCP value or name to use in connections. This could help QoS system to identify traffic class. BE, EF, DF, LE, CSx and AFxx are allowed. See the description of differentiated services to get an idea of this field. Setting this to 1 (LE) to identify the flow to SCAVENGER class can avoid occupying too much bandwidth in a network with DiffServ support (RFC 8622). For example, if you configured QoS on router to handle LE properly. Running: rclone copy --dscp LE from:/from to:/to would make the priority lower than usual internet flows. This option has no effect on Windows (see golang/go#42728). -n, --dry-run Do a trial run with no permanent changes. Use this to see what rclone would do without actually doing it. Useful when setting up the sync command which deletes files in the destination. --expect-continue-timeout Duration This specifies the amount of time to wait for a server's first response headers after fully writing the request headers if the request has an "Expect: 100-continue" header. Not all backends support using this. Zero means no timeout and causes the body to be sent immediately, without waiting for the server to approve. This time does not include the time to send the request header. The default is 1s. Set to 0 to disable. --error-on-no-transfer By default, rclone will exit with return code 0 if there were no errors. This option allows rclone to return exit code 9 if no files were transferred between the source and destination. This allows using rclone in scripts, and triggering follow-on actions if data was copied, or skipping if not. NB: Enabling this option turns a usually non-fatal error into a potentially fatal one - please check and adjust your scripts accordingly! --fix-case Normally, a sync to a case insensitive dest (such as macOS / Windows) will not result in a matching filename if the source and dest filenames have casing differences but are otherwise identical. For example, syncing hello.txt to HELLO.txt will normally result in the dest filename remaining HELLO.txt. If --fix-case is set, then HELLO.txt will be renamed to hello.txt to match the source. NB: - directory names with incorrect casing will also be fixed - --fix-case will be ignored if --immutable is set - using --local-case-sensitive instead is not advisable; it will cause HELLO.txt to get deleted! - the old dest filename must not be excluded by filters. Be especially careful with --files-from, which does not respect --ignore-case! - on remotes that do not support server-side move, --fix-case will require downloading the file and re-uploading it. To avoid this, do not use --fix-case. --fs-cache-expire-duration Duration When using rclone via the API rclone caches created remotes for 5 minutes by default in the "fs cache". This means that if you do repeated actions on the same remote then rclone won't have to build it again from scratch, which makes it more efficient. This flag sets the time that the remotes are cached for. If you set it to 0 (or negative) then rclone won't cache the remotes at all. Note that if you use some flags, eg --backup-dir and if this is set to 0 rclone may build two remotes (one for the source or destination and one for the --backup-dir where it may have only built one before. --fs-cache-expire-interval Duration This controls how often rclone checks for cached remotes to expire. See the --fs-cache-expire-duration documentation above for more info. The default is 60s, set to 0 to disable expiry. --header stringArray Add an HTTP header for all transactions. The flag can be repeated to add multiple headers. If you want to add headers only for uploads use --header-upload and if you want to add headers only for downloads use --header-download. This flag is supported for all HTTP based backends even those not supported by --header-upload and --header-download so may be used as a workaround for those with care. rclone ls remote:test --header "X-Rclone: Foo" --header "X-LetMeIn: Yes" --header-download stringArray Add an HTTP header for all download transactions. The flag can be repeated to add multiple headers. rclone sync --interactive s3:test/src ~/dst --header-download "X-Amz-Meta-Test: Foo" --header-download "X-Amz-Meta-Test2: Bar" See GitHub issue #59 for currently supported backends. --header-upload stringArray Add an HTTP header for all upload transactions. The flag can be repeated to add multiple headers. rclone sync --interactive ~/src s3:test/dst --header-upload "Content-Disposition: attachment; filename='cool.html'" --header-upload "X-Amz-Meta-Test: FooBar" See GitHub issue #59 for currently supported backends. --http-proxy string Use this option to set an HTTP proxy for all HTTP based services to use. Rclone also supports the standard HTTP proxy environment variables which it will pick up automatically. The is the way the HTTP proxy will normally be set but this flag can be used to override it. --human-readable Rclone commands output values for sizes (e.g. number of bytes) and counts (e.g. number of files) either as raw numbers, or in human-readable format. In human-readable format the values are scaled to larger units, indicated with a suffix shown after the value, and rounded to three decimals. Rclone consistently uses binary units (powers of 2) for sizes and decimal units (powers of 10) for counts. The unit prefix for size is according to IEC standard notation, e.g. Ki for kibi. Used with byte unit, 1 KiB means 1024 Byte. In list type of output, only the unit prefix appended to the value (e.g. 9.762Ki), while in more textual output the full unit is shown (e.g. 9.762 KiB). For counts the SI standard notation is used, e.g. prefix k for kilo. Used with file counts, 1k means 1000 files. The various list commands output raw numbers by default. Option --human-readable will make them output values in human-readable format instead (with the short unit prefix). The about command outputs human-readable by default, with a command-specific option --full to output the raw numbers instead. Command size outputs both human-readable and raw numbers in the same output. The tree command also considers --human-readable, but it will not use the exact same notation as the other commands: It rounds to one decimal, and uses single letter suffix, e.g. K instead of Ki. The reason for this is that it relies on an external library. The interactive command ncdu shows human-readable by default, and responds to key u for toggling human-readable format. --ignore-case-sync Using this option will cause rclone to ignore the case of the files when synchronizing so files will not be copied/synced when the existing filenames are the same, even if the casing is different. --ignore-checksum Normally rclone will check that the checksums of transferred files match, and give an error "corrupted on transfer" if they don't. You can use this option to skip that check. You should only use it if you have had the "corrupted on transfer" error message and you are sure you might want to transfer potentially corrupted data. --ignore-existing Using this option will make rclone unconditionally skip all files that exist on the destination, no matter the content of these files. While this isn't a generally recommended option, it can be useful in cases where your files change due to encryption. However, it cannot correct partial transfers in case a transfer was interrupted. When performing a move/moveto command, this flag will leave skipped files in the source location unchanged when a file with the same name exists on the destination. --ignore-size Normally rclone will look at modification time and size of files to see if they are equal. If you set this flag then rclone will check only the modification time. If --checksum is set then it only checks the checksum. It will also cause rclone to skip verifying the sizes are the same after transfer. This can be useful for transferring files to and from OneDrive which occasionally misreports the size of image files (see #399 for more info). -I, --ignore-times Using this option will cause rclone to unconditionally upload all files regardless of the state of files on the destination. Normally rclone would skip any files that have the same modification time and are the same size (or have the same checksum if using --checksum). --immutable Treat source and destination files as immutable and disallow modification. With this option set, files will be created and deleted as requested, but existing files will never be updated. If an existing file does not match between the source and destination, rclone will give the error Source and destination exist but do not match: immutable file modified. Note that only commands which transfer files (e.g. sync, copy or move) are affected by this behavior, and only modification is disallowed. Files may still be deleted explicitly (e.g. delete, purge) or implicitly (e.g. sync, move). Use copy --immutable if it is desired to avoid deletion as well as modification. This can be useful as an additional layer of protection for immutable or append-only data sets (notably backup archives), where modification implies corruption and should not be propagated. --inplace The --inplace flag changes the behaviour of rclone when uploading files to some backends (backends with the PartialUploads feature flag set) such as: - local - ftp - sftp - pcloud Without --inplace (the default) rclone will first upload to a temporary file with an extension like this, where XXXXXX represents a hash of the source file's fingerprint and .partial is --partial-suffix value (.partial by default). original-file-name.XXXXXX.partial (rclone will make sure the final name is no longer than 100 characters by truncating the original-file-name part if necessary). When the upload is complete, rclone will rename the .partial file to the correct name, overwriting any existing file at that point. If the upload fails then the .partial file will be deleted. This prevents other users of the backend from seeing partially uploaded files in their new names and prevents overwriting the old file until the new one is completely uploaded. If the --inplace flag is supplied, rclone will upload directly to the final name without creating a .partial file. This means that an incomplete file will be visible in the directory listings while the upload is in progress and any existing files will be overwritten as soon as the upload starts. If the transfer fails then the file will be deleted. This can cause data loss of the existing file if the transfer fails. Note that on the local file system if you don't use --inplace hard links (Unix only) will be broken. And if you do use --inplace you won't be able to update in use executables. Note also that versions of rclone prior to v1.63.0 behave as if the --inplace flag is always supplied. -i, --interactive This flag can be used to tell rclone that you wish a manual confirmation before destructive operations. It is recommended that you use this flag while learning rclone especially with rclone sync. For example $ rclone delete --interactive /tmp/dir rclone: delete "important-file.txt"? y) Yes, this is OK (default) n) No, skip this s) Skip all delete operations with no more questions !) Do all delete operations with no more questions q) Exit rclone now. y/n/s/!/q> n The options mean - y: Yes, this operation should go ahead. You can also press Return for this to happen. You'll be asked every time unless you choose s or !. - n: No, do not do this operation. You'll be asked every time unless you choose s or !. - s: Skip all the following operations of this type with no more questions. This takes effect until rclone exits. If there are any different kind of operations you'll be prompted for them. - !: Do all the following operations with no more questions. Useful if you've decided that you don't mind rclone doing that kind of operation. This takes effect until rclone exits . If there are any different kind of operations you'll be prompted for them. - q: Quit rclone now, just in case! --leave-root During rmdirs it will not remove root directory, even if it's empty. -l, --links Normally rclone will ignore symlinks or junction points (which behave like symlinks under Windows). Ignored files won't be copied, moved or deleted in a sync. If you supply this flag then rclone will copy symbolic links from any supported backend backend, and store them as text files, with a .rclonelink suffix in the destination. The text file will contain the target of the symbolic link. The --links / -l flag enables this feature for all supported backends and the VFS. There are individual flags for just enabling it for the VFS --vfs-links and the local backend --local-links if required. --list-cutoff int When syncing rclone needs to sort directory entries before comparing them. Below this threshold (1,000,000) by default, rclone will store the directory entries in memory. 1,000,000 entries will take approx 1GB of RAM to store. Above this threshold rclone will store directory entries on disk and sort them without using a lot of memory. Doing this is slightly less efficient then sorting them in memory and will only work well for the bucket based backends (eg s3, b2, azureblob, swift) but these are the only backends likely to have millions of entries in a directory. --log-file string Log all of rclone's output to a file. This is not active by default. This can be useful for tracking down problems with syncs in combination with the -v flag. See the logging section for more info. If the file exists, then rclone will append to it. Note that if you are using the logrotate program to manage rclone's logs, then you should use the copytruncate option as rclone doesn't have a signal to rotate logs. Alternatively you can use the options below to manage rclone's built in log rotation. --log-file-max-size SizeSuffix Maximum size of the log file before it's rotated (eg 10M). This SizeSuffix is rounded to the nearest MiB or 1 MiB if lower. If --log-file is not set then this option will be ignored. If this option is not set, then the other log rotation options will be ignored. For example if the following flags are in use rclone --log-file rclone.log --log-file-max-size 1M --log-file-max-backups 3 Then this will create log files which look like this $ ls -l -rw------- 1 user user 1048491 Apr 11 17:15 rclone-2025-04-11T17-15-29.998.log -rw------- 1 user user 1048511 Apr 11 17:15 rclone-2025-04-11T17-15-30.467.log -rw------- 1 user user 1048559 Apr 11 17:15 rclone-2025-04-11T17-15-30.543.log -rw------- 1 user user 521602 Apr 11 17:15 rclone.log The file rclone.log being the current one. --log-file-compress If set, compress rotated log files using gzip. This changes the extension of the old log files to .log.gz. Defaults to false - don't compress log files. --log-file-max-age Duration Maximum duration to retain old log files (eg 7d). This is rounded to the dearest day, or 1 day if lower. The default is to retain all old log files. --log-file-max-backups int Maximum number of old log files to retain The default is to retain all old log files. --log-format string Comma separated list of log format options. The accepted options are: - date - Add a date in the format YYYY/MM/YY to the log. - time - Add a time to the log in format HH:MM:SS. - microseconds - Add microseconds to the time in format HH:MM:SS.SSSSSS. - UTC - Make the logs in UTC not localtime. - longfile - Adds the source file and line number of the log statement. - shortfile - Adds the source file and line number of the log statement. - pid - Add the process ID to the log - useful with rclone mount --daemon. - nolevel - Don't add the level to the log. - json - Equivalent to adding --use-json-log They are added to the log line in the order above. The default log format is "date,time". --log-level LogLevel This sets the log level for rclone. The default log level is NOTICE. DEBUG is equivalent to -vv. It outputs lots of debug info - useful for bug reports and really finding out what rclone is doing. INFO is equivalent to -v. It outputs information about each transfer and prints stats once a minute by default. NOTICE is the default log level if no logging flags are supplied. It outputs very little when things are working normally. It outputs warnings and significant events. ERROR is equivalent to -q. It only outputs error messages. See also the logging section. --windows-event-log LogLevel If this is configured (the default is OFF) then logs of this level and above will be logged to the Windows event log in addition to the normal logs. These will be logged in JSON format as described below regardless of what format the main logs are configured for. The Windows event log only has 3 levels of severity Info, Warning and Error. If enabled we map rclone levels like this. - Error ← ERROR (and above) - Warning ← WARNING (note that this level is defined but not currently used). - Info ← NOTICE, INFO and DEBUG. Rclone will declare its log source as "rclone" if it is has enough permissions to create the registry key needed. If not then logs will appear as "Application". You can run rclone version --windows-event-log DEBUG once as administrator to create the registry key in advance. Note that the --windows-event-log level must be greater (more severe) than or equal to the --log-level. For example to log DEBUG to a log file but ERRORs to the event log you would use --log-file rclone.log --log-level DEBUG --windows-event-log ERROR This option is only supported Windows platforms. --use-json-log This switches the log format to JSON. The log messages are then streamed as individual JSON objects, with fields: level, msg, source, and time. The resulting format is what is sometimes referred to as newline-delimited JSON (NDJSON), or JSON Lines (JSONL). This is well suited for processing by traditional line-oriented tools and shell pipelines, but a complete log file is not strictly valid JSON and needs a parser that can handle it. The JSON logs will be printed on a single line, but are shown expanded here for clarity. { "time": "2025-05-13T17:30:51.036237518+01:00", "level": "debug", "msg": "4 go routines active\n", "source": "cmd/cmd.go:298" } Completed data transfer logs will have extra size information. Logs which are about a particular object will have object and objectType fields also. { "time": "2025-05-13T17:38:05.540846352+01:00", "level": "info", "msg": "Copied (new) to: file2.txt", "size": 6, "object": "file.txt", "objectType": "*local.Object", "source": "operations/copy.go:368" } Stats logs will contain a stats field which is the same as returned from the rc call core/stats. { "time": "2025-05-13T17:38:05.540912847+01:00", "level": "info", "msg": "...text version of the stats...", "stats": { "bytes": 6, "checks": 0, "deletedDirs": 0, "deletes": 0, "elapsedTime": 0.000904825, ...truncated for clarity... "totalBytes": 6, "totalChecks": 0, "totalTransfers": 1, "transferTime": 0.000882794, "transfers": 1 }, "source": "accounting/stats.go:569" } --low-level-retries int This controls the number of low level retries rclone does. A low level retry is used to retry a failing operation - typically one HTTP request. This might be uploading a chunk of a big file for example. You will see low level retries in the log with the -v flag. This shouldn't need to be changed from the default in normal operations. However, if you get a lot of low level retries you may wish to reduce the value so rclone moves on to a high level retry (see the --retries flag) quicker. Disable low level retries with --low-level-retries 1. --max-backlog int This is the maximum allowable backlog of files in a sync/copy/move queued for being checked or transferred. This can be set arbitrarily large. It will only use memory when the queue is in use. Note that it will use in the order of N KiB of memory when the backlog is in use. Setting this large allows rclone to calculate how many files are pending more accurately, give a more accurate estimated finish time and make --order-by work more accurately. Setting this small will make rclone more synchronous to the listings of the remote which may be desirable. Setting this to a negative number will make the backlog as large as possible. --max-buffer-memory SizeSuffix If set, don't allocate more than given amount of memory as buffers. If not set or set to 0 or off this will not limit the amount of memory in use. This includes memory used by buffers created by the --buffer flag and buffers used by multi-thread transfers. Most multi-thread transfers do not take additional memory, but some do depending on the backend (eg the s3 backend for uploads). This means there is a tension between total setting --transfers as high as possible and memory use. Setting --max-buffer-memory allows the buffer memory to be controlled so that it doesn't overwhelm the machine and allows --transfers to be set large. --max-connections int This sets the maximum number of concurrent calls to the backend API. It may not map 1:1 to TCP or HTTP connections depending on the backend in use and the use of HTTP1 vs HTTP2. When downloading files, backends only limit the initial opening of the stream. The bulk data download is not counted as a connection. This means that the --max--connections flag won't limit the total number of downloads. Note that it is possible to cause deadlocks with this setting so it should be used with care. If you are doing a sync or copy then make sure --max-connections is one more than the sum of --transfers and --checkers. If you use --check-first then --max-connections just needs to be one more than the maximum of --checkers and --transfers. So for --max-connections 3 you'd use --checkers 2 --transfers 2 --check-first or --checkers 1 --transfers 1. Setting this flag can be useful for backends which do multipart uploads to limit the number of simultaneous parts being transferred. --max-delete int This tells rclone not to delete more than N files. If that limit is exceeded then a fatal error will be generated and rclone will stop the operation in progress. --max-delete-size SizeSuffix Rclone will stop deleting files when the total size of deletions has reached the size specified. It defaults to off. If that limit is exceeded then a fatal error will be generated and rclone will stop the operation in progress. --max-depth int This modifies the recursion depth for all the commands except purge. So if you do rclone --max-depth 1 ls remote:path you will see only the files in the top level directory. Using --max-depth 2 means you will see all the files in first two directory levels and so on. For historical reasons the lsd command defaults to using a --max-depth of 1 - you can override this with the command line flag. You can use this command to disable recursion (with --max-depth 1). Note that if you use this with sync and --delete-excluded the files not recursed through are considered excluded and will be deleted on the destination. Test first with --dry-run if you are not sure what will happen. --max-duration Duration Rclone will stop transferring when it has run for the duration specified. Defaults to off. When the limit is reached all transfers will stop immediately. Use --cutoff-mode to modify this behaviour. Rclone will exit with exit code 10 if the duration limit is reached. --max-transfer SizeSuffix Rclone will stop transferring when it has reached the size specified. Defaults to off. When the limit is reached all transfers will stop immediately. Use --cutoff-mode to modify this behaviour. Rclone will exit with exit code 8 if the transfer limit is reached. --cutoff-mode HARD|SOFT|CAUTIOUS Configure the behavior of --max-transfer and --max-duration. HARD will stop transferring immediately when rclone reaches the limit. This is the default. SOFT will stop starting new transfers when rclone reaches the limit. CAUTIOUS will try to prevent rclone from reaching the limit. Only applicable for --max-transfer. -M, --metadata Setting this flag enables rclone to copy the metadata from the source to the destination. For local backends this is ownership, permissions, xattr etc. See the metadata section for more info. --metadata-mapper SpaceSepList If you supply the parameter --metadata-mapper /path/to/program then rclone will use that program to map metadata from source object to destination object. The argument to this flag should be a command with an optional space separated list of arguments. If one of the arguments has a space in then enclose it in ", if you want a literal " in an argument then enclose the argument in " and double the ". See CSV encoding for more info. --metadata-mapper "python bin/test_metadata_mapper.py" --metadata-mapper 'python bin/test_metadata_mapper.py "argument with a space"' --metadata-mapper 'python bin/test_metadata_mapper.py "argument with ""two"" quotes"' This uses a simple JSON based protocol with input on STDIN and output on STDOUT. This will be called for every file and directory copied and may be called concurrently. The program's job is to take a metadata blob on the input and turn it into a metadata blob on the output suitable for the destination backend. Input to the program (via STDIN) might look like this. This provides some context for the Metadata which may be important. - SrcFs is the config string for the remote that the object is currently on. - SrcFsType is the name of the source backend. - DstFs is the config string for the remote that the object is being copied to - DstFsType is the name of the destination backend. - Remote is the path of the object relative to the root. - Size, MimeType, ModTime are attributes of the object. - IsDir is true if this is a directory (not yet implemented). - ID is the source ID of the object if known. - Metadata is the backend specific metadata as described in the backend docs. { "SrcFs": "gdrive:", "SrcFsType": "drive", "DstFs": "newdrive:user", "DstFsType": "onedrive", "Remote": "test.txt", "Size": 6, "MimeType": "text/plain; charset=utf-8", "ModTime": "2022-10-11T17:53:10.286745272+01:00", "IsDir": false, "ID": "xyz", "Metadata": { "btime": "2022-10-11T16:53:11Z", "content-type": "text/plain; charset=utf-8", "mtime": "2022-10-11T17:53:10.286745272+01:00", "owner": "user1@domain1.com", "permissions": "...", "description": "my nice file", "starred": "false" } } The program should then modify the input as desired and send it to STDOUT. The returned Metadata field will be used in its entirety for the destination object. Any other fields will be ignored. Note in this example we translate user names and permissions and add something to the description: { "Metadata": { "btime": "2022-10-11T16:53:11Z", "content-type": "text/plain; charset=utf-8", "mtime": "2022-10-11T17:53:10.286745272+01:00", "owner": "user1@domain2.com", "permissions": "...", "description": "my nice file [migrated from domain1]", "starred": "false" } } Metadata can be removed here too. An example python program might look something like this to implement the above transformations. import sys, json i = json.load(sys.stdin) metadata = i["Metadata"] # Add tag to description if "description" in metadata: metadata["description"] += " [migrated from domain1]" else: metadata["description"] = "[migrated from domain1]" # Modify owner if "owner" in metadata: metadata["owner"] = metadata["owner"].replace("domain1.com", "domain2.com") o = { "Metadata": metadata } json.dump(o, sys.stdout, indent="\t") You can find this example (slightly expanded) in the rclone source code at bin/test_metadata_mapper.py. If you want to see the input to the metadata mapper and the output returned from it in the log you can use -vv --dump mapper. See the metadata section for more info. --metadata-set stringArray Specify value as string in format key=value to add metadata key with value value when uploading. This can be repeated as many times as required. See the metadata section for more info. --modify-window Duration When checking whether a file has been modified, this is the maximum allowed time difference that a file can have and still be considered equivalent. The default is 1ns unless this is overridden by a remote. For example OS X only stores modification times to the nearest second so if you are reading and writing to an OS X filing system this will be 1s by default. This command line flag allows you to override that computed default. --multi-thread-write-buffer-size SizeSuffix When transferring with multiple threads, rclone will buffer the specified number of bytes in memory before writing to disk for each thread. This can improve performance if the underlying filesystem does not deal well with a lot of small writes in different positions of the file, so if you see transfers being limited by disk write speed, you might want to experiment with different values. Specially for magnetic drives and remote file systems a higher value can be useful. Nevertheless, the default of 128k should be fine for almost all use cases, so before changing it ensure that network is not really your bottleneck. As a final hint, size is not the only factor: block size (or similar concept) can have an impact. In one case, we observed that exact multiples of 16k performed much better than other values. --multi-thread-chunk-size SizeSuffix Normally the chunk size for multi thread transfers is set by the backend. However some backends such as local and smb (which implement OpenWriterAt but not OpenChunkWriter) don't have a natural chunk size. In this case the value of this option is used (default 64Mi). --multi-thread-cutoff SizeSuffix When transferring files above specified size to capable backends, rclone will use multiple threads to transfer the file (default 256M). Capable backends are marked in the overview as MultithreadUpload. (They need to implement either the OpenWriterAt or OpenChunkWriter internal interfaces). These include include, local, s3, azureblob, b2, oracleobjectstorage and smb at the time of writing. On the local disk, rclone preallocates the file (using fallocate(FALLOC_FL_KEEP_SIZE) on unix or NTSetInformationFile on Windows both of which takes no time) then each thread writes directly into the file at the correct place. This means that rclone won't create fragmented or sparse files and there won't be any assembly time at the end of the transfer. The number of threads used to transfer is controlled by --multi-thread-streams. Use -vv if you wish to see info about the threads. This will work with the sync, copy and move commands, and friends copyto, moveto. Multi thread transfers will be used with rclone mount and rclone serve if --vfs-cache-mode is set to writes or above. Most multi-thread transfers do not take additional memory, but some do (for example uploading to s3). In the worst case memory usage can be at maximum --transfers * --multi-thread-chunk-size * --multi-thread-streams or specifically for the s3 backend --transfers * --s3-chunk-size * --s3-concurrency. However you can use the the --max-buffer-memory flag to control the maximum memory used here. NB that this only works with supported backends as the destination but will work with any backend as the source. NB that multi-thread copies are disabled for local to local copies as they are faster without unless --multi-thread-streams is set explicitly. NB on Windows using multi-thread transfers to the local disk will cause the resulting files to be sparse. Use --local-no-sparse to disable sparse files (which may cause long delays at the start of transfers) or disable multi-thread transfers with --multi-thread-streams 0 --multi-thread-streams int When using multi thread transfers (see above --multi-thread-cutoff) this sets the number of streams to use. Set to 0 to disable multi thread transfers (Default 4). If the backend has a --backend-upload-concurrency setting (eg --s3-upload-concurrency) then this setting will be used as the number of transfers instead if it is larger than the value of --multi-thread-streams or --multi-thread-streams isn't set. --name-transform stringArray --name-transform introduces path name transformations for rclone copy, rclone sync, and rclone move. These transformations enable modifications to source and destination file names by applying prefixes, suffixes, and other alterations during transfer operations. For detailed docs and examples, see convmv. --no-check-dest The --no-check-dest can be used with move or copy and it causes rclone not to check the destination at all when copying files. This means that: - the destination is not listed minimising the API calls - files are always transferred - this can cause duplicates on remotes which allow it (e.g. Google Drive) - --retries 1 is recommended otherwise you'll transfer everything again on a retry This flag is useful to minimise the transactions if you know that none of the files are on the destination. This is a specialized flag which should be ignored by most users! --no-gzip-encoding Don't set Accept-Encoding: gzip. This means that rclone won't ask the server for compressed files automatically. Useful if you've set the server to return files with Content-Encoding: gzip but you uploaded compressed files. There is no need to set this in normal operation, and doing so will decrease the network transfer efficiency of rclone. --no-traverse The --no-traverse flag controls whether the destination file system is traversed when using the copy or move commands. --no-traverse is not compatible with sync and will be ignored if you supply it with sync. If you are only copying a small number of files (or are filtering most of the files) and/or have a large number of files on the destination then --no-traverse will stop rclone listing the destination and save time. However, if you are copying a large number of files, especially if you are doing a copy where lots of the files under consideration haven't changed and won't need copying then you shouldn't use --no-traverse. See rclone copy for an example of how to use it. --no-unicode-normalization Don't normalize unicode characters in filenames during the sync routine. Sometimes, an operating system will store filenames containing unicode parts in their decomposed form (particularly macOS). Some cloud storage systems will then recompose the unicode, resulting in duplicate files if the data is ever copied back to a local filesystem. Using this flag will disable that functionality, treating each unicode character as unique. For example, by default é and é will be normalized into the same character. With --no-unicode-normalization they will be treated as unique characters. --no-update-modtime When using this flag, rclone won't update modification times of remote files if they are incorrect as it would normally. This can be used if the remote is being synced with another tool also (e.g. the Google Drive client). --no-update-dir-modtime When using this flag, rclone won't update modification times of remote directories if they are incorrect as it would normally. --order-by string The --order-by flag controls the order in which files in the backlog are processed in rclone sync, rclone copy and rclone move. The order by string is constructed like this. The first part describes what aspect is being measured: - size - order by the size of the files - name - order by the full path of the files - modtime - order by the modification date of the files This can have a modifier appended with a comma: - ascending or asc - order so that the smallest (or oldest) is processed first - descending or desc - order so that the largest (or newest) is processed first - mixed - order so that the smallest is processed first for some threads and the largest for others If the modifier is mixed then it can have an optional percentage (which defaults to 50), e.g. size,mixed,25 which means that 25% of the threads should be taking the smallest items and 75% the largest. The threads which take the smallest first will always take the smallest first and likewise the largest first threads. The mixed mode can be useful to minimise the transfer time when you are transferring a mixture of large and small files - the large files are guaranteed upload threads and bandwidth and the small files will be processed continuously. If no modifier is supplied then the order is ascending. For example - --order-by size,desc - send the largest files first - --order-by modtime,ascending - send the oldest files first - --order-by name - send the files with alphabetically by path first If the --order-by flag is not supplied or it is supplied with an empty string then the default ordering will be used which is as scanned. With --checkers 1 this is mostly alphabetical, however with the default --checkers 8 it is somewhat random. Limitations The --order-by flag does not do a separate pass over the data. This means that it may transfer some files out of the order specified if - there are no files in the backlog or the source has not been fully scanned yet - there are more than --max-backlog files in the backlog Rclone will do its best to transfer the best file it has so in practice this should not cause a problem. Think of --order-by as being more of a best efforts flag rather than a perfect ordering. If you want perfect ordering then you will need to specify --check-first which will find all the files which need transferring first before transferring any. --partial-suffix string When --inplace is not used, it causes rclone to use the --partial-suffix as suffix for temporary files. Suffix length limit is 16 characters. The default is .partial. --password-command SpaceSepList This flag supplies a program which should supply the config password when run. This is an alternative to rclone prompting for the password or setting the RCLONE_CONFIG_PASS variable. It is also used when setting the config password for the first time. The argument to this should be a command with a space separated list of arguments. If one of the arguments has a space in then enclose it in ", if you want a literal " in an argument then enclose the argument in " and double the ". See CSV encoding for more info. Eg --password-command "echo hello" --password-command 'echo "hello with space"' --password-command 'echo "hello with ""quotes"" and space"' Note that when changing the configuration password the environment variable RCLONE_PASSWORD_CHANGE=1 will be set. This can be used to distinguish initial decryption of the config file from the new password. See the Configuration Encryption for more info. See a Windows PowerShell example on the Wiki. -P, --progress This flag makes rclone update the stats in a static block in the terminal providing a realtime overview of the transfer. Any log messages will scroll above the static block. Log messages will push the static block down to the bottom of the terminal where it will stay. Normally this is updated every 500mS but this period can be overridden with the --stats flag. This can be used with the --stats-one-line flag for a simpler display. To change the display length of filenames (for different terminal widths), see the --stats-file-name-length option. The default output is formatted for 80 character wide terminals. Note: On Windows until this bug is fixed all non-ASCII characters will be replaced with . when --progress is in use. --progress-terminal-title This flag, when used with -P/--progress, will print the string ETA: %s to the terminal title. -q, --quiet This flag will limit rclone's output to error messages only. --refresh-times The --refresh-times flag can be used to update modification times of existing files when they are out of sync on backends which don't support hashes. This is useful if you uploaded files with the incorrect timestamps and you now wish to correct them. This flag is only useful for destinations which don't support hashes (e.g. crypt). This can be used any of the sync commands sync, copy or move. To use this flag you will need to be doing a modification time sync (so not using --size-only or --checksum). The flag will have no effect when using --size-only or --checksum. If this flag is used when rclone comes to upload a file it will check to see if there is an existing file on the destination. If this file matches the source with size (and checksum if available) but has a differing timestamp then instead of re-uploading it, rclone will update the timestamp on the destination file. If the checksum does not match rclone will upload the new file. If the checksum is absent (e.g. on a crypt backend) then rclone will update the timestamp. Note that some remotes can't set the modification time without re-uploading the file so this flag is less useful on them. Normally if you are doing a modification time sync rclone will update modification times without --refresh-times provided that the remote supports checksums and the checksums match on the file. However if the checksums are absent then rclone will upload the file rather than setting the timestamp as this is the safe behaviour. --retries int Retry the entire sync if it fails this many times it fails (default 3). Some remotes can be unreliable and a few retries help pick up the files which didn't get transferred because of errors. Disable retries with --retries 1. --retries-sleep Duration This sets the interval between each retry specified by --retries The default is 0. Use 0 to disable. --server-side-across-configs Allow server-side operations (e.g. copy or move) to work across different configurations. This can be useful if you wish to do a server-side copy or move between two remotes which use the same backend but are configured differently. Note that this isn't enabled by default because it isn't easy for rclone to tell if it will work between any two configurations. --size-only Normally rclone will look at modification time and size of files to see if they are equal. If you set this flag then rclone will check only the size. This can be useful transferring files from Dropbox which have been modified by the desktop sync client which doesn't set checksums of modification times in the same way as rclone. --stats Duration Commands which transfer data (sync, copy, copyto, move, moveto) will print data transfer stats at regular intervals to show their progress. This sets the interval. The default is 1m. Use 0 to disable. If you set the stats interval then all commands can show stats. This can be useful when running other commands, check or mount for example. Stats are logged at INFO level by default which means they won't show at default log level NOTICE. Use --stats-log-level NOTICE or -v to make them show. See the logging section for more info on log levels. Note that on macOS you can send a SIGINFO (which is normally ctrl-T in the terminal) to make the stats print immediately. --stats-file-name-length int By default, the --stats output will truncate file names and paths longer than 40 characters. This is equivalent to providing --stats-file-name-length 40. Use --stats-file-name-length 0 to disable any truncation of file names printed by stats. --stats-log-level LogLevel Log level to show --stats output at. This can be DEBUG, INFO, NOTICE, or ERROR. The default is INFO. This means at the default level of logging, which is NOTICE, the stats won't show - if you want them to then use --stats-log-level NOTICE. See the logging section for more details on log levels. --stats-one-line When this is specified, rclone condenses the stats into a single line showing the most important stats only. --stats-one-line-date When this is specified, rclone enables the single-line stats and prepends the display with a date string. The default is 2006/01/02 15:04:05 - --stats-one-line-date-format string When this is specified, rclone enables the single-line stats and prepends the display with a user-supplied date string. The date string MUST be enclosed in quotes. Follow golang specs for date formatting syntax. --stats-unit string By default, data transfer rates will be printed in bytes per second, corresponding to --stats-unit bytes. This option allows the data rate to be printed in bits per second, by specifying --stats-unit bits. Data transfer volume will still be reported in bytes. The rate is reported as a binary unit, not SI unit. So 1 Mbit/s equals 1,048,576 bit/s and not 1,000,000 bit/s. --suffix string When using sync, copy or move any files which would have been overwritten or deleted will have the suffix added to them. If there is a file with the same path (after the suffix has been added), then it will be overwritten. The remote in use must support server-side move or copy and you must use the same remote as the destination of the sync. This is for use with files to add the suffix in the current directory or with --backup-dir. See --backup-dir for more info. For example rclone copy --interactive /path/to/local/file remote:current --suffix .bak will copy /path/to/local to remote:current, but for any files which would have been updated or deleted have .bak added. If using rclone sync with --suffix and without --backup-dir then it is recommended to put a filter rule in excluding the suffix otherwise the sync will delete the backup files. rclone sync --interactive /path/to/local/file remote:current --suffix .bak --exclude "*.bak" --suffix-keep-extension When using --suffix, setting this causes rclone put the SUFFIX before the extension of the files that it backs up rather than after. So let's say we had --suffix -2019-01-01, without the flag file.txt would be backed up to file.txt-2019-01-01 and with the flag it would be backed up to file-2019-01-01.txt. This can be helpful to make sure the suffixed files can still be opened. If a file has two (or more) extensions and the second (or subsequent) extension is recognised as a valid mime type, then the suffix will go before that extension. So file.tar.gz would be backed up to file-2019-01-01.tar.gz whereas file.badextension.gz would be backed up to file.badextension-2019-01-01.gz. --syslog On capable OSes (not Windows or Plan9) send all log output to syslog. This can be useful for running rclone in a script or rclone mount. --syslog-facility string If using --syslog this sets the syslog facility (e.g. KERN, USER). See man syslog for a list of possible facilities. The default facility is DAEMON. --temp-dir string Specify the directory rclone will use for temporary files, to override the default. Make sure the directory exists and have accessible permissions. By default the operating system's temp directory will be used: - On Unix systems, $TMPDIR if non-empty, else /tmp. - On Windows, the first non-empty value from %TMP%, %TEMP%, %USERPROFILE%, or the Windows directory. When overriding the default with this option, the specified path will be set as value of environment variable TMPDIR on Unix systems and TMP and TEMP on Windows. You can use the config paths command to see the current value. --tpslimit float Limit transactions per second to this number. Default is 0 which is used to mean unlimited transactions per second. A transaction is roughly defined as an API call; its exact meaning will depend on the backend. For HTTP based backends it is an HTTP PUT/GET/POST/etc and its response. For FTP/SFTP it is a round trip transaction over TCP. For example, to limit rclone to 10 transactions per second use --tpslimit 10, or to 1 transaction every 2 seconds use --tpslimit 0.5. Use this when the number of transactions per second from rclone is causing a problem with the cloud storage provider (e.g. getting you banned or rate limited). This can be very useful for rclone mount to control the behaviour of applications using it. This limit applies to all HTTP based backends and to the FTP and SFTP backends. It does not apply to the local backend or the Storj backend. See also --tpslimit-burst. --tpslimit-burst int Max burst of transactions for --tpslimit (default 1). Normally --tpslimit will do exactly the number of transaction per second specified. However if you supply --tps-burst then rclone can save up some transactions from when it was idle giving a burst of up to the parameter supplied. For example if you provide --tpslimit-burst 10 then if rclone has been idle for more than 10*--tpslimit then it can do 10 transactions very quickly before they are limited again. This may be used to increase performance of --tpslimit without changing the long term average number of transactions per second. --track-renames By default, rclone doesn't keep track of renamed files, so if you rename a file locally then sync it to a remote, rclone will delete the old file on the remote and upload a new copy. An rclone sync with --track-renames runs like a normal sync, but keeps track of objects which exist in the destination but not in the source (which would normally be deleted), and which objects exist in the source but not the destination (which would normally be transferred). These objects are then candidates for renaming. After the sync, rclone matches up the source only and destination only objects using the --track-renames-strategy specified and either renames the destination object or transfers the source and deletes the destination object. --track-renames is stateless like all of rclone's syncs. To use this flag the destination must support server-side copy or server-side move, and to use a hash based --track-renames-strategy (the default) the source and the destination must have a compatible hash. If the destination does not support server-side copy or move, rclone will fall back to the default behaviour and log an error level message to the console. Encrypted destinations are not currently supported by --track-renames if --track-renames-strategy includes hash. Note that --track-renames is incompatible with --no-traverse and that it uses extra memory to keep track of all the rename candidates. Note also that --track-renames is incompatible with --delete-before and will select --delete-after instead of --delete-during. --track-renames-strategy string This option changes the file matching criteria for --track-renames. The matching is controlled by a comma separated selection of these tokens: - modtime - the modification time of the file - not supported on all backends - hash - the hash of the file contents - not supported on all backends - leaf - the name of the file not including its directory name - size - the size of the file (this is always enabled) The default option is hash. Using --track-renames-strategy modtime,leaf would match files based on modification time, the leaf of the file name and the size only. Using --track-renames-strategy modtime or leaf can enable --track-renames support for encrypted destinations. Note that the hash strategy is not supported with encrypted destinations. --delete-(before,during,after) This option allows you to specify when files on your destination are deleted when you sync folders. Specifying the value --delete-before will delete all files present on the destination, but not on the source before starting the transfer of any new or updated files. This uses two passes through the file systems, one for the deletions and one for the copies. Specifying --delete-during will delete files while checking and uploading files. This is the fastest option and uses the least memory. Specifying --delete-after (the default value) will delay deletion of files until all new/updated files have been successfully transferred. The files to be deleted are collected in the copy pass then deleted after the copy pass has completed successfully. The files to be deleted are held in memory so this mode may use more memory. This is the safest mode as it will only delete files if there have been no errors subsequent to that. If there have been errors before the deletions start then you will get the message not deleting files as there were IO errors. --fast-list When doing anything which involves a directory listing (e.g. sync, copy, ls - in fact nearly every command), rclone has different strategies to choose from. The basic strategy is to list one directory and processes it before using more directory lists to process any subdirectories. This is a mandatory backend feature, called List, which means it is supported by all backends. This strategy uses small amount of memory, and because it can be parallelised it is fast for operations involving processing of the list results. Some backends provide the support for an alternative strategy, where all files beneath a directory can be listed in one (or a small number) of transactions. Rclone supports this alternative strategy through an optional backend feature called ListR. You can see in the storage system overview documentation's optional features section which backends it is enabled for (these tend to be the bucket-based ones, e.g. S3, B2, GCS, Swift). This strategy requires fewer transactions for highly recursive operations, which is important on backends where this is charged or heavily rate limited. It may be faster (due to fewer transactions) or slower (because it can't be parallelized) depending on different parameters, and may require more memory if rclone has to keep the whole listing in memory. Which listing strategy rclone picks for a given operation is complicated, but in general it tries to choose the best possible. It will prefer ListR in situations where it doesn't need to store the listed files in memory, e.g. for unlimited recursive ls command variants. In other situations it will prefer List, e.g. for sync and copy, where it needs to keep the listed files in memory, and is performing operations on them where parallelization may be a huge advantage. Rclone is not able to take all relevant parameters into account for deciding the best strategy, and therefore allows you to influence the choice in two ways: You can stop rclone from using ListR by disabling the feature, using the --disable option (--disable ListR), or you can allow rclone to use ListR where it would normally choose not to do so due to higher memory usage, using the --fast-list option. Rclone should always produce identical results either way. Using --disable ListR or --fast-list on a remote which doesn't support ListR does nothing, rclone will just ignore it. A rule of thumb is that if you pay for transactions and can fit your entire sync listing into memory, then --fast-list is recommended. If you have a very big sync to do, then don't use --fast-list, otherwise you will run out of memory. Run some tests and compare before you decide, and if in doubt then just leave the default, let rclone decide, i.e. not use --fast-list. --timeout Duration This sets the IO idle timeout. If a transfer has started but then becomes idle for this long it is considered broken and disconnected. The default is 5m. Set to 0 to disable. --transfers int The number of file transfers to run in parallel. It can sometimes be useful to set this to a smaller number if the remote is giving a lot of timeouts or bigger if you have lots of bandwidth and a fast remote. The default is to run 4 file transfers in parallel. Look at --multi-thread-streams if you would like to control single file transfers. -u, --update This forces rclone to skip any files which exist on the destination and have a modified time that is newer than the source file. This can be useful in avoiding needless transfers when transferring to a remote which doesn't support modification times directly (or when using --use-server-modtime to avoid extra API calls) as it is more accurate than a --size-only check and faster than using --checksum. On such remotes (or when using --use-server-modtime) the time checked will be the uploaded time. If an existing destination file has a modification time older than the source file's, it will be updated if the sizes are different. If the sizes are the same, it will be updated if the checksum is different or not available. If an existing destination file has a modification time equal (within the computed modify window) to the source file's, it will be updated if the sizes are different. The checksum will not be checked in this case unless the --checksum flag is provided. In all other cases the file will not be updated. Consider using the --modify-window flag to compensate for time skews between the source and the backend, for backends that do not support mod times, and instead use uploaded times. However, if the backend does not support checksums, note that syncing or copying within the time skew window may still result in additional transfers for safety. --use-mmap If this flag is set then rclone will use anonymous memory allocated by mmap on Unix based platforms and VirtualAlloc on Windows for its transfer buffers (size controlled by --buffer-size). Memory allocated like this does not go on the Go heap and can be returned to the OS immediately when it is finished with. If this flag is not set then rclone will allocate and free the buffers using the Go memory allocator which may use more memory as memory pages are returned less aggressively to the OS. It is possible this does not work well on all platforms so it is disabled by default; in the future it may be enabled by default. --use-server-modtime Some object-store backends (e.g, Swift, S3) do not preserve file modification times (modtime). On these backends, rclone stores the original modtime as additional metadata on the object. By default it will make an API call to retrieve the metadata when the modtime is needed by an operation. Use this flag to disable the extra API call and rely instead on the server's modified time. In cases such as a local to remote sync using --update, knowing the local file is newer than the time it was last uploaded to the remote is sufficient. In those cases, this flag can speed up the process and reduce the number of API calls necessary. Using this flag on a sync operation without also using --update would cause all files modified at any time other than the last upload time to be uploaded again, which is probably not what you want. -v, -vv, --verbose With -v rclone will tell you about each file that is transferred and a small number of significant events. With -vv rclone will become very verbose telling you about every file it considers and transfers. Please send bug reports with a log with this setting. When setting verbosity as an environment variable, use RCLONE_VERBOSE=1 or RCLONE_VERBOSE=2 for -v and -vv respectively. -V, --version Prints the version number SSL/TLS options The outgoing SSL/TLS connections rclone makes can be controlled with these options. For example this can be very useful with the HTTP or WebDAV backends. Rclone HTTP servers have their own set of configuration for SSL/TLS which you can find in their documentation. --ca-cert stringArray This loads the PEM encoded certificate authority certificates and uses it to verify the certificates of the servers rclone connects to. If you have generated certificates signed with a local CA then you will need this flag to connect to servers using those certificates. --client-cert string This loads the PEM encoded client side certificate. This is used for mutual TLS authentication. The --client-key flag is required too when using this. --client-key string This loads the PEM encoded client side private key used for mutual TLS authentication. Used in conjunction with --client-cert. Supported types are: - Unencrypted PKCS#1 ("BEGIN RSA PRIVATE KEY") - Unencrypted PKCS#8 ("BEGIN PRIVATE KEY") - Encrypted PKCS#8 ("BEGIN ENCRYPTED PRIVATE KEY") - Legacy PEM encryption (e.g., DEK-Info headers), which are automatically detected. --client-pass string This can be used to supply an optional password to decrypt the client key file. NB the password should be obscured so it should be the output of rclone obscure YOURPASSWORD. --no-check-certificate --no-check-certificate controls whether a client verifies the server's certificate chain and host name. If --no-check-certificate is true, TLS accepts any certificate presented by the server and any host name in that certificate. In this mode, TLS is susceptible to man-in-the-middle attacks. This option defaults to false. This should be used only for testing. Configuration encryption Your configuration file contains information for logging in to your cloud services. This means that you should keep your rclone.conf file in a secure location. If you are in an environment where that isn't possible, you can add a password to your configuration. This means that you will have to supply the password every time you start rclone. To add a password to your rclone configuration, execute rclone config. $ rclone config Current remotes: e) Edit existing remote n) New remote d) Delete remote s) Set configuration password q) Quit config e/n/d/s/q> Go into s, Set configuration password: e/n/d/s/q> s Your configuration is not encrypted. If you add a password, you will protect your login information to cloud services. a) Add Password q) Quit to main menu a/q> a Enter NEW configuration password: password: Confirm NEW password: password: Password set Your configuration is encrypted. c) Change Password u) Unencrypt configuration q) Quit to main menu c/u/q> Your configuration is now encrypted, and every time you start rclone you will have to supply the password. See below for details. In the same menu, you can change the password or completely remove encryption from your configuration. There is no way to recover the configuration if you lose your password. You can also use - rclone config encryption set to set the config encryption directly - rclone config encryption remove to remove it - rclone config encryption check to check that it is encrypted properly. rclone uses nacl secretbox which in turn uses XSalsa20 and Poly1305 to encrypt and authenticate your configuration with secret-key cryptography. The password is SHA-256 hashed, which produces the key for secretbox. The hashed password is not stored. While this provides very good security, we do not recommend storing your encrypted rclone configuration in public if it contains sensitive information, maybe except if you use a very strong password. If it is safe in your environment, you can set the RCLONE_CONFIG_PASS environment variable to contain your password, in which case it will be used for decrypting the configuration. You can set this for a session from a script. For unix like systems save this to a file called set-rclone-password: #!/bin/echo Source this file don't run it read -s RCLONE_CONFIG_PASS export RCLONE_CONFIG_PASS Then source the file when you want to use it. From the shell you would do source set-rclone-password. It will then ask you for the password and set it in the environment variable. An alternate means of supplying the password is to provide a script which will retrieve the password and print on standard output. This script should have a fully specified path name and not rely on any environment variables. The script is supplied either via --password-command="..." command line argument or via the RCLONE_PASSWORD_COMMAND environment variable. One useful example of this is using the passwordstore application to retrieve the password: export RCLONE_PASSWORD_COMMAND="pass rclone/config" If the passwordstore password manager holds the password for the rclone configuration, using the script method means the password is primarily protected by the passwordstore system, and is never embedded in the clear in scripts, nor available for examination using the standard commands available. It is quite possible with long running rclone sessions for copies of passwords to be innocently captured in log files or terminal scroll buffers, etc. Using the script method of supplying the password enhances the security of the config password considerably. If you are running rclone inside a script, unless you are using the --password-command method, you might want to disable password prompts. To do that, pass the parameter --ask-password=false to rclone. This will make rclone fail instead of asking for a password if RCLONE_CONFIG_PASS doesn't contain a valid password, and --password-command has not been supplied. Whenever running commands that may be affected by options in a configuration file, rclone will look for an existing file according to the rules described above, and load any it finds. If an encrypted file is found, this includes decrypting it, with the possible consequence of a password prompt. When executing a command line that you know are not actually using anything from such a configuration file, you can avoid it being loaded by overriding the location, e.g. with one of the documented special values for memory-only configuration. Since only backend options can be stored in configuration files, this is normally unnecessary for commands that do not operate on backends, e.g. completion. However, it will be relevant for commands that do operate on backends in general, but are used without referencing a stored remote, e.g. listing local filesystem paths, or connection strings: rclone --config="" ls . Configuration encryption cheatsheet You can quickly apply a configuration encryption without plain-text at rest or transfer. Detailed instructions for popular OSes: Mac - Generate and store a password security add-generic-password -a rclone -s config -w $(openssl rand -base64 40) - Add the retrieval instruction to your .zprofile / .profile export RCLONE_PASSWORD_COMMAND="/usr/bin/security find-generic-password -a rclone -s config -w" Linux - Prerequisite: Linux doesn't come with a default password manager. Let's install the "pass" utility using a package manager, e.g. apt install pass, yum install pass, etc.; then initialize a password store: pass init rclone. - Generate and store a password echo $(openssl rand -base64 40) | pass insert -m rclone/config - Add the retrieval instruction export RCLONE_PASSWORD_COMMAND="/usr/bin/pass rclone/config" Windows - Generate and store a password New-Object -TypeName PSCredential -ArgumentList "rclone", (ConvertTo-SecureString -String ([System.Web.Security.Membership]::GeneratePassword(40, 10)) -AsPlainText -Force) | Export-Clixml -Path "rclone-credential.xml" - Add the password retrieval instruction [Environment]::SetEnvironmentVariable("RCLONE_PASSWORD_COMMAND", "[System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToBSTR((Import-Clixml -Path "rclone-credential.xml").Password))") Encrypt the config file (all systems) - Execute rclone config, and select option s) Set configuration password - Add/update the password from previous steps Developer options These options are useful when developing or debugging rclone. There are also some more remote specific options which aren't documented here which are used for testing. These start with remote name e.g. --drive-test-option - see the docs for the remote in question. --cpuprofile string Write CPU profile to a file. This can be analysed with go tool pprof. --memprofile string Write memory profile to a file. This can be analysed with go tool pprof. --dump DumpFlags The --dump flag takes a comma separated list of flags to dump info about. Note that some headers, such as Accept-Encoding, may not be correct as shown in the request, and the response may not show Content-Encoding if the go standard libraries auto gzip encoding was in effect. In this case the body of the request will be gunzipped before showing it. The available flags are: - headers dumps HTTP headers. Any Authorization: headers will be excluded, but output may still contain sensitive information. Can be very verbose. Useful for debugging only. Use auth if you do want the Authorization: headers. - auth dumps HTTP headers like headers, but also includes any Authorization: headers. This means the output will probably contain sensitive information. Use headers to dump without Authorization: headers. Can be very verbose. Useful for debugging only. - bodies dumps HTTP headers and bodies. May contain sensitive info. Can be very verbose. Useful for debugging only. Note that the bodies are buffered in memory so don't use this for enormous files. - requests is similar to bodies, but dumps the request bodies and the response headers. Useful for debugging download problems. - responses is similar to bodies, but dumps the response bodies and the request headers. Useful for debugging upload problems. - filters dumps the filters. Useful to see exactly what include and exclude options are filtering on. - goroutines dumps a list of the running go-routines at the end of the command. - openfiles dumps a list of the open files at the end of the command. It uses the lsof Unix command to do that, so you'll need that installed to use it. - mapper dumps the JSON blobs being sent to the program supplied with --metadata-mapper and received from it. It can be useful for debugging the metadata mapper interface. Filtering For the filtering options - --delete-excluded - --filter - --filter-from - --exclude - --exclude-from - --exclude-if-present - --include - --include-from - --files-from - --files-from-raw - --min-size - --max-size - --min-age - --max-age - --hash-filter - --dump filters - --metadata-include - --metadata-include-from - --metadata-exclude - --metadata-exclude-from - --metadata-filter - --metadata-filter-from See the filtering section. Remote control For the remote control options and for instructions on how to remote control rclone: - --rc - Anything starting with --rc- See the remote control section. Logging rclone has 4 levels of logging, ERROR, NOTICE, INFO and DEBUG. By default, rclone logs to standard error. This means you can redirect standard error and still see the normal output of rclone commands (e.g. rclone ls). By default, rclone will produce Error and Notice level messages. If you use the -q flag, rclone will only produce Error messages. If you use the -v flag, rclone will produce Error, Notice and Info messages. If you use the -vv flag, rclone will produce Error, Notice, Info and Debug messages. You can also control the log levels with the --log-level flag. If you use the --log-file option, rclone will redirect Error, Info and Debug messages along with standard error to a file. If you use the --syslog flag then rclone will log to syslog and the --syslog-facility control which facility it uses. Rclone prefixes all log messages with their level in capitals, e.g. INFO which makes it easy to grep the log file for different kinds of information. Metrics Rclone can publish metrics in the OpenMetrics/Prometheus format. To enable the metrics endpoint, use the --metrics-addr flag. Metrics can also be published on the --rc-addr port if the --rc flag and --rc-enable-metrics flags are supplied or if using rclone rcd --rc-enable-metrics Rclone provides extensive configuration options for the metrics HTTP endpoint. These settings are grouped under the Metrics section and have a prefix --metrics-*. When metrics are enabled with --rc-enable-metrics, they will be published on the same port as the rc API. In this case, the --metrics-* flags will be ignored, and the HTTP endpoint configuration will be managed by the --rc-* parameters. Exit code If any errors occur during the command execution, rclone will exit with a non-zero exit code. This allows scripts to detect when rclone operations have failed. During the startup phase, rclone will exit immediately if an error is detected in the configuration. There will always be a log message immediately before exiting. When rclone is running it will accumulate errors as it goes along, and only exit with a non-zero exit code if (after retries) there were still failed transfers. For every error counted there will be a high priority log message (visible with -q) showing the message and which file caused the problem. A high priority message is also shown when starting a retry so the user can see that any previous error messages may not be valid after the retry. If rclone has done a retry it will log a high priority message if the retry was successful. List of exit codes - 0 - Success - 1 - Error not otherwise categorised - 2 - Syntax or usage error - 3 - Directory not found - 4 - File not found - 5 - Temporary error (one that more retries might fix) (Retry errors) - 6 - Less serious errors (like 461 errors from dropbox) (NoRetry errors) - 7 - Fatal error (one that more retries won't fix, like account suspended) (Fatal errors) - 8 - Transfer exceeded - limit set by --max-transfer reached - 9 - Operation successful, but no files transferred (Requires --error-on-no-transfer) - 10 - Duration exceeded - limit set by --max-duration reached Environment variables Rclone can be configured entirely using environment variables. These can be used to set defaults for options or config file entries. Options Every option in rclone can have its default set by environment variable. To find the name of the environment variable, first, take the long option name, strip the leading --, change - to _, make upper case and prepend RCLONE_. For example, to always set --stats 5s, set the environment variable RCLONE_STATS=5s. If you set stats on the command line this will override the environment variable setting. Or to always use the trash in drive --drive-use-trash, set RCLONE_DRIVE_USE_TRASH=true. Verbosity is slightly different, the environment variable equivalent of --verbose or -v is RCLONE_VERBOSE=1, or for -vv, RCLONE_VERBOSE=2. The same parser is used for the options and the environment variables so they take exactly the same form. The options set by environment variables can be seen with the -vv flag, e.g. rclone version -vv. Options that can appear multiple times (type stringArray) are treated slightly differently as environment variables can only be defined once. In order to allow a simple mechanism for adding one or many items, the input is treated as a CSV encoded string. For example ---------------------------------------------------------------------------------------- Environment variable Equivalent options ------------------------------------------------------ --------------------------------- RCLONE_EXCLUDE="*.jpg" --exclude "*.jpg" RCLONE_EXCLUDE="*.jpg,*.png" --exclude "*.jpg" --exclude "*.png" RCLONE_EXCLUDE='"*.jpg","*.png"' --exclude "*.jpg" --exclude "*.png" RCLONE_EXCLUDE='"/directory with comma , in it /**"' `--exclude "/directory with comma , in it /**" ---------------------------------------------------------------------------------------- If stringArray options are defined as environment variables and options on the command line then all the values will be used. Config file You can set defaults for values in the config file on an individual remote basis. The names of the config items are documented in the page for each backend. To find the name of the environment variable, you need to set, take RCLONE_CONFIG_ + name of remote + _ + name of config file option and make it all uppercase. Note one implication here is the remote's name must be convertible into a valid environment variable name, so it can only contain letters, digits, or the _ (underscore) character. For example, to configure an S3 remote named mys3: without a config file (using unix ways of setting environment variables): $ export RCLONE_CONFIG_MYS3_TYPE=s3 $ export RCLONE_CONFIG_MYS3_ACCESS_KEY_ID=XXX $ export RCLONE_CONFIG_MYS3_SECRET_ACCESS_KEY=XXX $ rclone lsd mys3: -1 2016-09-21 12:54:21 -1 my-bucket $ rclone listremotes | grep mys3 mys3: Note that if you want to create a remote using environment variables you must create the ..._TYPE variable as above. Note that the name of a remote created using environment variable is case insensitive, in contrast to regular remotes stored in config file as documented above. You must write the name in uppercase in the environment variable, but as seen from example above it will be listed and can be accessed in lowercase, while you can also refer to the same remote in uppercase: $ rclone lsd mys3: -1 2016-09-21 12:54:21 -1 my-bucket $ rclone lsd MYS3: -1 2016-09-21 12:54:21 -1 my-bucket Note that you can only set the options of the immediate backend, so RCLONE_CONFIG_MYS3CRYPT_ACCESS_KEY_ID has no effect, if myS3Crypt is a crypt remote based on an S3 remote. However RCLONE_S3_ACCESS_KEY_ID will set the access key of all remotes using S3, including myS3Crypt. Note also that now rclone has connection strings, it is probably easier to use those instead which makes the above example rclone lsd :s3,access_key_id=XXX,secret_access_key=XXX: Precedence The various different methods of backend configuration are read in this order and the first one with a value is used. - Parameters in connection strings, e.g. myRemote,skip_links: - Flag values as supplied on the command line, e.g. --skip-links - Remote specific environment vars, e.g. RCLONE_CONFIG_MYREMOTE_SKIP_LINKS (see above). - Backend-specific environment vars, e.g. RCLONE_LOCAL_SKIP_LINKS. - Backend generic environment vars, e.g. RCLONE_SKIP_LINKS. - Config file, e.g. skip_links = true. - Default values, e.g. false - these can't be changed. So if both --skip-links is supplied on the command line and an environment variable RCLONE_LOCAL_SKIP_LINKS is set, the command line flag will take preference. The backend configurations set by environment variables can be seen with the -vv flag, e.g. rclone about myRemote: -vv. For non backend configuration the order is as follows: - Flag values as supplied on the command line, e.g. --stats 5s. - Environment vars, e.g. RCLONE_STATS=5s. - Default values, e.g. 1m - these can't be changed. Other environment variables - RCLONE_CONFIG_PASS set to contain your config file password (see Configuration Encryption section) - HTTP_PROXY, HTTPS_PROXY and NO_PROXY (or the lowercase versions thereof). - HTTPS_PROXY takes precedence over HTTP_PROXY for https requests. - The environment values may be either a complete URL or a "host[:port]" for, in which case the "http" scheme is assumed. - USER and LOGNAME values are used as fallbacks for current username. The primary method for looking up username is OS-specific: Windows API on Windows, real user ID in /etc/passwd on Unix systems. In the documentation the current username is simply referred to as $USER. - RCLONE_CONFIG_DIR - rclone sets this variable for use in config files and sub processes to point to the directory holding the config file. The options set by environment variables can be seen with the -vv and --log-level=DEBUG flags, e.g. rclone version -vv. Configuring rclone on a remote / headless machine Some of the configurations (those involving oauth2) require an Internet connected web browser. If you are trying to set rclone up on a remote or headless box with no browser available on it (e.g. a NAS or a server in a datacenter) then you will need to use an alternative means of configuration. There are two ways of doing it, described below. Configuring using rclone authorize On the headless box run rclone config but answer N to the Use auto config? question. Use auto config? * Say Y if not sure * Say N if you are working on a remote or headless machine y) Yes (default) n) No y/n> n Option config_token. For this to work, you will need rclone available on a machine that has a web browser available. For more help and alternate methods see: https://rclone.org/remote_setup/ Execute the following on the machine with the web browser (same rclone version recommended): rclone authorize "onedrive" Then paste the result. Enter a value. config_token> Then on your main desktop machine rclone authorize "onedrive" If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Paste the following into your remote machine ---> SECRET_TOKEN <---End paste Then back to the headless box, paste in the code config_token> SECRET_TOKEN -------------------- [acd12] client_id = client_secret = token = SECRET_TOKEN -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> Configuring by copying the config file Rclone stores all of its config in a single configuration file. This can easily be copied to configure a remote rclone. So first configure rclone on your desktop machine with rclone config to set up the config file. Find the config file by running rclone config file, for example $ rclone config file Configuration file is stored at: /home/user/.rclone.conf Now transfer it to the remote box (scp, cut paste, ftp, sftp, etc.) and place it in the correct place (use rclone config file on the remote box to find out where). Configuring using SSH Tunnel Linux and MacOS users can utilize SSH Tunnel to redirect the headless box port 53682 to local machine by using the following command: ssh -L localhost:53682:localhost:53682 username@remote_server Then on the headless box run rclone config and answer Y to the Use auto config? question. Use auto config? * Say Y if not sure * Say N if you are working on a remote or headless machine y) Yes (default) n) No y/n> y Then copy and paste the auth url http://127.0.0.1:53682/auth?state=xxxxxxxxxxxx to the browser on your local machine, complete the auth and it is done. Filtering, includes and excludes Filter flags determine which files rclone sync, move, ls, lsl, md5sum, sha1sum, size, delete, check and similar commands apply to. They are specified in terms of path/file name patterns; path/file lists; file age and size, or presence of a file in a directory. Bucket based remotes without the concept of directory apply filters to object key, age and size in an analogous way. Rclone purge does not obey filters. To test filters without risk of damage to data, apply them to rclone ls, or with the --dry-run and -vv flags. Rclone filter patterns can only be used in filter command line options, not in the specification of a remote. E.g. rclone copy "remote:dir*.jpg" /path/to/dir does not have a filter effect. rclone copy remote:dir /path/to/dir --include "*.jpg" does. Important Avoid mixing any two of --include..., --exclude... or --filter... flags in an rclone command. The results might not be what you expect. Instead use a --filter... flag. Patterns for matching path/file names Pattern syntax Here is a formal definition of the pattern syntax, examples are below. Rclone matching rules follow a glob style: * matches any sequence of non-separator (/) characters ** matches any sequence of characters including / separators ? matches any single non-separator (/) character [ [ ! ] { character-range } ] character class (must be non-empty) { pattern-list } pattern alternatives {{ regexp }} regular expression to match c matches character c (c != *, **, ?, \, [, {, }) \c matches reserved character c (c = *, **, ?, \, [, {, }) or character class character-range: c matches character c (c != \, -, ]) \c matches reserved character c (c = \, -, ]) lo - hi matches character c for lo <= c <= hi pattern-list: pattern { , pattern } comma-separated (without spaces) patterns character classes (see Go regular expression reference) include: Named character classes (e.g. [\d], [^\d], [\D], [^\D]) Perl character classes (e.g. \s, \S, \w, \W) ASCII character classes (e.g. [[:alnum:]], [[:alpha:]], [[:punct:]], [[:xdigit:]]) regexp for advanced users to insert a regular expression - see below for more info: Any re2 regular expression not containing `}}` If the filter pattern starts with a / then it only matches at the top level of the directory tree, relative to the root of the remote (not necessarily the root of the drive). If it does not start with / then it is matched starting at the end of the path/file name but it only matches a complete path element - it must match from a / separator or the beginning of the path/file. file.jpg - matches "file.jpg" - matches "directory/file.jpg" - doesn't match "afile.jpg" - doesn't match "directory/afile.jpg" /file.jpg - matches "file.jpg" in the root directory of the remote - doesn't match "afile.jpg" - doesn't match "directory/file.jpg" The top level of the remote might not be the top level of the drive. E.g. for a Microsoft Windows local directory structure F: ├── bkp ├── data │ ├── excl │ │ ├── 123.jpg │ │ └── 456.jpg │ ├── incl │ │ └── document.pdf To copy the contents of folder data into folder bkp excluding the contents of subfolder exclthe following command treats F:\data and F:\bkp as top level for filtering. rclone copy F:\data\ F:\bkp\ --exclude=/excl/** Important Use / in path/file name patterns and not \ even if running on Microsoft Windows. Simple patterns are case sensitive unless the --ignore-case flag is used. Without --ignore-case (default) potato - matches "potato" - doesn't match "POTATO" With --ignore-case potato - matches "potato" - matches "POTATO" Using regular expressions in filter patterns The syntax of filter patterns is glob style matching (like bash uses) to make things easy for users. However this does not provide absolute control over the matching, so for advanced users rclone also provides a regular expression syntax. The regular expressions used are as defined in the Go regular expression reference. Regular expressions should be enclosed in {{ }}. They will match only the last path segment if the glob doesn't start with / or the whole path name if it does. Note that rclone does not attempt to parse the supplied regular expression, meaning that using any regular expression filter will prevent rclone from using directory filter rules, as it will instead check every path against the supplied regular expression(s). Here is how the {{regexp}} is transformed into an full regular expression to match the entire path: {{regexp}} becomes (^|/)(regexp)$ /{{regexp}} becomes ^(regexp)$ Regexp syntax can be mixed with glob syntax, for example *.{{jpe?g}} to match file.jpg, file.jpeg but not file.png You can also use regexp flags - to set case insensitive, for example *.{{(?i)jpg}} to match file.jpg, file.JPG but not file.png Be careful with wildcards in regular expressions - you don't want them to match path separators normally. To match any file name starting with start and ending with end write {{start[^/]*end\.jpg}} Not {{start.*end\.jpg}} Which will match a directory called start with a file called end.jpg in it as the .* will match / characters. Note that you can use -vv --dump filters to show the filter patterns in regexp format - rclone implements the glob patterns by transforming them into regular expressions. Filter pattern examples --------------------------------------------------------------------------------------------- Description Pattern Matches Does not match ------------------- ---------------- ------------------------------- ------------------------ Wildcard *.jpg /file.jpg /file.png /dir/file.jpg /dir/file.png Rooted /*.jpg /file.jpg /file.png /file2.jpg /dir/file.jpg Alternates *.{jpg,png} /file.jpg /file.gif /dir/file.png /dir/file.gif Path Wildcard dir/** /dir/anyfile file.png /subdir/dir/subsubdir/anyfile /subdir/file.png Any Char *.t?t /file.txt /file.qxt /dir/file.tzt /dir/file.png Range *.[a-z] /file.a /file.0 /dir/file.b /dir/file.1 Escape *.\?\?\? /file.??? /file.abc /dir/file.??? /dir/file.def Class *.\d\d\d /file.012 /file.abc /dir/file.345 /dir/file.def Regexp *.{{jpe?g}} /file.jpeg /file.png /dir/file.jpg /dir/file.jpeeg Rooted Regexp /{{.*\.jpe?g}} /file.jpeg /file.png /file.jpg /dir/file.jpg --------------------------------------------------------------------------------------------- How filter rules are applied to files Rclone path/file name filters are made up of one or more of the following flags: - --include - --include-from - --exclude - --exclude-from - --filter - --filter-from There can be more than one instance of individual flags. Rclone internally uses a combined list of all the include and exclude rules. The order in which rules are processed can influence the result of the filter. All flags of the same type are processed together in the order above, regardless of what order the different types of flags are included on the command line. Multiple instances of the same flag are processed from left to right according to their position in the command line. To mix up the order of processing includes and excludes use --filter... flags. Within --include-from, --exclude-from and --filter-from flags rules are processed from top to bottom of the referenced file. If there is an --include or --include-from flag specified, rclone implies a - ** rule which it adds to the bottom of the internal rule list. Specifying a + rule with a --filter... flag does not imply that rule. Each path/file name passed through rclone is matched against the combined filter list. At first match to a rule the path/file name is included or excluded and no further filter rules are processed for that path/file. If rclone does not find a match, after testing against all rules (including the implied rule if appropriate), the path/file name is included. Any path/file included at that stage is processed by the rclone command. --files-from and --files-from-raw flags over-ride and cannot be combined with other filter options. To see the internal combined rule list, in regular expression form, for a command add the --dump filters flag. Running an rclone command with --dump filters and -vv flags lists the internal filter elements and shows how they are applied to each source path/file. There is not currently a means provided to pass regular expression filter options into rclone directly though character class filter rules contain character classes. Go regular expression reference How filter rules are applied to directories Rclone commands are applied to path/file names not directories. The entire contents of a directory can be matched to a filter by the pattern directory/* or recursively by directory/**. Directory filter rules are defined with a closing / separator. E.g. /directory/subdirectory/ is an rclone directory filter rule. Rclone commands can use directory filter rules to determine whether they recurse into subdirectories. This potentially optimises access to a remote by avoiding listing unnecessary directories. Whether optimisation is desirable depends on the specific filter rules and source remote content. If any regular expression filters are in use, then no directory recursion optimisation is possible, as rclone must check every path against the supplied regular expression(s). Directory recursion optimisation occurs if either: - A source remote does not support the rclone ListR primitive. local, sftp, Microsoft OneDrive and WebDAV do not support ListR. Google Drive and most bucket type storage do. Full list - On other remotes (those that support ListR), if the rclone command is not naturally recursive, and provided it is not run with the --fast-list flag. ls, lsf -R and size are naturally recursive but sync, copy and move are not. - Whenever the --disable ListR flag is applied to an rclone command. Rclone commands imply directory filter rules from path/file filter rules. To view the directory filter rules rclone has implied for a command specify the --dump filters flag. E.g. for an include rule /a/*.jpg Rclone implies the directory include rule /a/ Directory filter rules specified in an rclone command can limit the scope of an rclone command but path/file filters still have to be specified. E.g. rclone ls remote: --include /directory/ will not match any files. Because it is an --include option the --exclude ** rule is implied, and the /directory/ pattern serves only to optimise access to the remote by ignoring everything outside of that directory. E.g. rclone ls remote: --filter-from filter-list.txt with a file filter-list.txt: - /dir1/ - /dir2/ + *.pdf - ** All files in directories dir1 or dir2 or their subdirectories are completely excluded from the listing. Only files of suffix pdf in the root of remote: or its subdirectories are listed. The - ** rule prevents listing of any path/files not previously matched by the rules above. Option exclude-if-present creates a directory exclude rule based on the presence of a file in a directory and takes precedence over other rclone directory filter rules. When using pattern list syntax, if a pattern item contains either / or **, then rclone will not able to imply a directory filter rule from this pattern list. E.g. for an include rule {dir1/**,dir2/**} Rclone will match files below directories dir1 or dir2 only, but will not be able to use this filter to exclude a directory dir3 from being traversed. Directory recursion optimisation may affect performance, but normally not the result. One exception to this is sync operations with option --create-empty-src-dirs, where any traversed empty directories will be created. With the pattern list example {dir1/**,dir2/**} above, this would create an empty directory dir3 on destination (when it exists on source). Changing the filter to {dir1,dir2}/**, or splitting it into two include rules --include dir1/** --include dir2/**, will match the same files while also filtering directories, with the result that an empty directory dir3 will no longer be created. --exclude - Exclude files matching pattern Excludes path/file names from an rclone command based on a single exclude rule. This flag can be repeated. See above for the order filter flags are processed in. --exclude should not be used with --include, --include-from, --filter or --filter-from flags. --exclude has no effect when combined with --files-from or --files-from-raw flags. E.g. rclone ls remote: --exclude *.bak excludes all .bak files from listing. E.g. rclone size remote: --exclude "/dir/**" returns the total size of all files on remote: excluding those in root directory dir and sub directories. E.g. on Microsoft Windows rclone ls remote: --exclude "*\[{JP,KR,HK}\]*" lists the files in remote: without [JP] or [KR] or [HK] in their name. Quotes prevent the shell from interpreting the \ characters.\ characters escape the [ and ] so an rclone filter treats them literally rather than as a character-range. The { and } define an rclone pattern list. For other operating systems single quotes are required ie rclone ls remote: --exclude '*\[{JP,KR,HK}\]*' --exclude-from - Read exclude patterns from file Excludes path/file names from an rclone command based on rules in a named file. The file contains a list of remarks and pattern rules. For an example exclude-file.txt: # a sample exclude rule file *.bak file2.jpg rclone ls remote: --exclude-from exclude-file.txt lists the files on remote: except those named file2.jpg or with a suffix .bak. That is equivalent to rclone ls remote: --exclude file2.jpg --exclude "*.bak". This flag can be repeated. See above for the order filter flags are processed in. The --exclude-from flag is useful where multiple exclude filter rules are applied to an rclone command. --exclude-from should not be used with --include, --include-from, --filter or --filter-from flags. --exclude-from has no effect when combined with --files-from or --files-from-raw flags. --exclude-from followed by - reads filter rules from standard input. --include - Include files matching pattern Adds a single include rule based on path/file names to an rclone command. This flag can be repeated. See above for the order filter flags are processed in. --include has no effect when combined with --files-from or --files-from-raw flags. --include implies --exclude ** at the end of an rclone internal filter list. Therefore if you mix --include and --include-from flags with --exclude, --exclude-from, --filter or --filter-from, you must use include rules for all the files you want in the include statement. For more flexibility use the --filter-from flag. E.g. rclone ls remote: --include "*.{png,jpg}" lists the files on remote: with suffix .png and .jpg. All other files are excluded. E.g. multiple rclone copy commands can be combined with --include and a pattern-list. rclone copy /vol1/A remote:A rclone copy /vol1/B remote:B is equivalent to: rclone copy /vol1 remote: --include "{A,B}/**" E.g. rclone ls remote:/wheat --include "??[^[:punct:]]*" lists the files remote: directory wheat (and subdirectories) whose third character is not punctuation. This example uses an ASCII character class. --include-from - Read include patterns from file Adds path/file names to an rclone command based on rules in a named file. The file contains a list of remarks and pattern rules. For an example include-file.txt: # a sample include rule file *.jpg file2.avi rclone ls remote: --include-from include-file.txt lists the files on remote: with name file2.avi or suffix .jpg. That is equivalent to rclone ls remote: --include file2.avi --include "*.jpg". This flag can be repeated. See above for the order filter flags are processed in. The --include-from flag is useful where multiple include filter rules are applied to an rclone command. --include-from implies --exclude ** at the end of an rclone internal filter list. Therefore if you mix --include and --include-from flags with --exclude, --exclude-from, --filter or --filter-from, you must use include rules for all the files you want in the include statement. For more flexibility use the --filter-from flag. --include-from has no effect when combined with --files-from or --files-from-raw flags. --include-from followed by - reads filter rules from standard input. --filter - Add a file-filtering rule Specifies path/file names to an rclone command, based on a single include or exclude rule, in + or - format. This flag can be repeated. See above for the order filter flags are processed in. --filter + differs from --include. In the case of --include rclone implies an --exclude * rule which it adds to the bottom of the internal rule list. --filter...+ does not imply that rule. --filter has no effect when combined with --files-from or --files-from-raw flags. --filter should not be used with --include, --include-from, --exclude or --exclude-from flags. E.g. rclone ls remote: --filter "- *.bak" excludes all .bak files from a list of remote:. --filter-from - Read filtering patterns from a file Adds path/file names to an rclone command based on rules in a named file. The file contains a list of remarks and pattern rules. Include rules start with + and exclude rules with -. ! clears existing rules. Rules are processed in the order they are defined. This flag can be repeated. See above for the order filter flags are processed in. Arrange the order of filter rules with the most restrictive first and work down. Lines starting with # or ; are ignored, and can be used to write comments. Inline comments are not supported. Use -vv --dump filters to see how they appear in the final regexp. E.g. for filter-file.txt: # a sample filter rule file - secret*.jpg + *.jpg + *.png + file2.avi - /dir/tmp/** # WARNING! This text will be treated as part of the path. - /dir/Trash/** + /dir/** # exclude everything else - * rclone ls remote: --filter-from filter-file.txt lists the path/files on remote: including all jpg and png files, excluding any matching secret*.jpg and including file2.avi. It also includes everything in the directory dir at the root of remote, except remote:dir/Trash which it excludes. Everything else is excluded. E.g. for an alternative filter-file.txt: - secret*.jpg + *.jpg + *.png + file2.avi - * Files file1.jpg, file3.png and file2.avi are listed whilst secret17.jpg and files without the suffix .jpg or .png are excluded. E.g. for an alternative filter-file.txt: + *.jpg + *.gif ! + 42.doc - * Only file 42.doc is listed. Prior rules are cleared by the !. --files-from - Read list of source-file names Adds path/files to an rclone command from a list in a named file. Rclone processes the path/file names in the order of the list, and no others. Other filter flags (--include, --include-from, --exclude, --exclude-from, --filter and --filter-from) are ignored when --files-from is used. --files-from expects a list of files as its input. Leading or trailing whitespace is stripped from the input lines. Lines starting with # or ; are ignored. --files-from followed by - reads the list of files from standard input. Rclone commands with a --files-from flag traverse the remote, treating the names in --files-from as a set of filters. If the --no-traverse and --files-from flags are used together an rclone command does not traverse the remote. Instead it addresses each path/file named in the file individually. For each path/file name, that requires typically 1 API call. This can be efficient for a short --files-from list and a remote containing many files. Rclone commands do not error if any names in the --files-from file are missing from the source remote. The --files-from flag can be repeated in a single rclone command to read path/file names from more than one file. The files are read from left to right along the command line. Paths within the --files-from file are interpreted as starting with the root specified in the rclone command. Leading / separators are ignored. See --files-from-raw if you need the input to be processed in a raw manner. E.g. for a file files-from.txt: # comment file1.jpg subdir/file2.jpg rclone copy --files-from files-from.txt /home/me/pics remote:pics copies the following, if they exist, and only those files. /home/me/pics/file1.jpg → remote:pics/file1.jpg /home/me/pics/subdir/file2.jpg → remote:pics/subdir/file2.jpg E.g. to copy the following files referenced by their absolute paths: /home/user1/42 /home/user1/dir/ford /home/user2/prefect First find a common subdirectory - in this case /home and put the remaining files in files-from.txt with or without leading /, e.g. user1/42 user1/dir/ford user2/prefect Then copy these to a remote: rclone copy --files-from files-from.txt /home remote:backup The three files are transferred as follows: /home/user1/42 → remote:backup/user1/important /home/user1/dir/ford → remote:backup/user1/dir/file /home/user2/prefect → remote:backup/user2/stuff Alternatively if / is chosen as root files-from.txt will be: /home/user1/42 /home/user1/dir/ford /home/user2/prefect The copy command will be: rclone copy --files-from files-from.txt / remote:backup Then there will be an extra home directory on the remote: /home/user1/42 → remote:backup/home/user1/42 /home/user1/dir/ford → remote:backup/home/user1/dir/ford /home/user2/prefect → remote:backup/home/user2/prefect --files-from-raw - Read list of source-file names without any processing This flag is the same as --files-from except that input is read in a raw manner. Lines with leading / trailing whitespace, and lines starting with ; or # are read without any processing. rclone lsf has a compatible format that can be used to export file lists from remotes for input to --files-from-raw. --ignore-case - make searches case insensitive By default, rclone filter patterns are case sensitive. The --ignore-case flag makes all of the filters patterns on the command line case insensitive. E.g. --include "zaphod.txt" does not match a file Zaphod.txt. With --ignore-case a match is made. Quoting shell metacharacters Rclone commands with filter patterns containing shell metacharacters may not as work as expected in your shell and may require quoting. E.g. linux, OSX (* metacharacter) - --include \*.jpg - --include '*.jpg' - --include='*.jpg' Microsoft Windows expansion is done by the command, not shell, so --include *.jpg does not require quoting. If the rclone error Command .... needs .... arguments maximum: you provided .... non flag arguments: is encountered, the cause is commonly spaces within the name of a remote or flag value. The fix then is to quote values containing spaces. Other filters --min-size - Don't transfer any file smaller than this Controls the minimum size file within the scope of an rclone command. Default units are KiB but abbreviations B, K, M, G, T or P are valid. E.g. rclone ls remote: --min-size 50k lists files on remote: of 50 KiB size or larger. See the size option docs for more info. --max-size - Don't transfer any file larger than this Controls the maximum size file within the scope of an rclone command. Default units are KiB but abbreviations B, K, M, G, T or P are valid. E.g. rclone ls remote: --max-size 1G lists files on remote: of 1 GiB size or smaller. See the size option docs for more info. --max-age - Don't transfer any file older than this Controls the maximum age of files within the scope of an rclone command. --max-age applies only to files and not to directories. E.g. rclone ls remote: --max-age 2d lists files on remote: of 2 days old or less. See the time option docs for valid formats. --min-age - Don't transfer any file younger than this Controls the minimum age of files within the scope of an rclone command. (see --max-age for valid formats) --min-age applies only to files and not to directories. E.g. rclone ls remote: --min-age 2d lists files on remote: of 2 days old or more. See the time option docs for valid formats. --hash-filter - Deterministically select a subset of files The --hash-filter flag enables selecting a deterministic subset of files, useful for: 1. Running large sync operations across multiple machines. 2. Checking a subset of files for bitrot. 3. Any other operations where a sample of files is required. Syntax The flag takes two parameters expressed as a fraction: --hash-filter K/N - N: The total number of partitions (must be a positive integer). - K: The specific partition to select (an integer from 0 to N). For example: - --hash-filter 1/3: Selects the first third of the files. - --hash-filter 2/3 and --hash-filter 3/3: Select the second and third partitions, respectively. Each partition is non-overlapping, ensuring all files are covered without duplication. Random Partition Selection Use @ as K to randomly select a partition: --hash-filter @/M For example, --hash-filter @/3 will randomly select a number between 0 and 2. This will stay constant across retries. How It Works - Rclone takes each file's full path, normalizes it to lowercase, and applies Unicode normalization. - It then hashes the normalized path into a 64 bit number. - The hash result is reduced modulo N to assign the file to a partition. - If the calculated partition does not match K the file is excluded. - Other filters may apply if the file is not excluded. Important: Rclone will traverse all directories to apply the filter. Usage Notes - Safe to use with rclone sync; source and destination selections will match. - Do not use with --delete-excluded, as this could delete unselected files. - Ignored if --files-from is used. Examples Dividing files into 4 partitions Assuming the current directory contains file1.jpg through file9.jpg: $ rclone lsf --hash-filter 0/4 . file1.jpg file5.jpg $ rclone lsf --hash-filter 1/4 . file3.jpg file6.jpg file9.jpg $ rclone lsf --hash-filter 2/4 . file2.jpg file4.jpg $ rclone lsf --hash-filter 3/4 . file7.jpg file8.jpg $ rclone lsf --hash-filter 4/4 . # the same as --hash-filter 0/4 file1.jpg file5.jpg Syncing the first quarter of files rclone sync --hash-filter 1/4 source:path destination:path Checking a random 1% of files for integrity rclone check --download --hash-filter @/100 source:path destination:path Other flags --delete-excluded - Delete files on dest excluded from sync Important this flag is dangerous to your data - use with --dry-run and -v first. In conjunction with rclone sync, --delete-excluded deletes any files on the destination which are excluded from the command. E.g. the scope of rclone sync --interactive A: B: can be restricted: rclone --min-size 50k --delete-excluded sync A: B: All files on B: which are less than 50 KiB are deleted because they are excluded from the rclone sync command. --dump filters - dump the filters to the output Dumps the defined filters to standard output in regular expression format. Useful for debugging. Exclude directory based on a file The --exclude-if-present flag controls whether a directory is within the scope of an rclone command based on the presence of a named file within it. The flag can be repeated to check for multiple file names, presence of any of them will exclude the directory. This flag has a priority over other filter flags. E.g. for the following directory structure: dir1/file1 dir1/dir2/file2 dir1/dir2/dir3/file3 dir1/dir2/dir3/.ignore The command rclone ls --exclude-if-present .ignore dir1 does not list dir3, file3 or .ignore. Metadata filters The metadata filters work in a very similar way to the normal file name filters, except they match metadata on the object. The metadata should be specified as key=value patterns. This may be wildcarded using the normal filter patterns or regular expressions. For example if you wished to list only local files with a mode of 100664 you could do that with: rclone lsf -M --files-only --metadata-include "mode=100664" . Or if you wished to show files with an atime, mtime or btime at a given date: rclone lsf -M --files-only --metadata-include "[abm]time=2022-12-16*" . Like file filtering, metadata filtering only applies to files not to directories. The filters can be applied using these flags. - --metadata-include - Include metadatas matching pattern - --metadata-include-from - Read metadata include patterns from file (use - to read from stdin) - --metadata-exclude - Exclude metadatas matching pattern - --metadata-exclude-from - Read metadata exclude patterns from file (use - to read from stdin) - --metadata-filter - Add a metadata filtering rule - --metadata-filter-from - Read metadata filtering patterns from a file (use - to read from stdin) Each flag can be repeated. See the section on how filter rules are applied for more details - these flags work in an identical way to the file name filtering flags, but instead of file name patterns have metadata patterns. Common pitfalls The most frequent filter support issues on the rclone forum are: - Not using paths relative to the root of the remote - Not using / to match from the root of a remote - Not using ** to match the contents of a directory GUI (Experimental) Rclone can serve a web based GUI (graphical user interface). This is somewhat experimental at the moment so things may be subject to change. Run this command in a terminal and rclone will download and then display the GUI in a web browser. rclone rcd --rc-web-gui This will produce logs like this and rclone needs to continue to run to serve the GUI: 2019/08/25 11:40:14 NOTICE: A new release for gui is present at https://github.com/rclone/rclone-webui-react/releases/download/v0.0.6/currentbuild.zip 2019/08/25 11:40:14 NOTICE: Downloading webgui binary. Please wait. [Size: 3813937, Path : /home/USER/.cache/rclone/webgui/v0.0.6.zip] 2019/08/25 11:40:16 NOTICE: Unzipping 2019/08/25 11:40:16 NOTICE: Serving remote control on http://127.0.0.1:5572/ This assumes you are running rclone locally on your machine. It is possible to separate the rclone and the GUI - see below for details. If you wish to check for updates then you can add --rc-web-gui-update to the command line. If you find your GUI broken, you may force it to update by add --rc-web-gui-force-update. By default, rclone will open your browser. Add --rc-web-gui-no-open-browser to disable this feature. Using the GUI Once the GUI opens, you will be looking at the dashboard which has an overall overview. On the left hand side you will see a series of view buttons you can click on: - Dashboard - main overview - Configs - examine and create new configurations - Explorer - view, download and upload files to the cloud storage systems - Backend - view or alter the backend config - Log out (More docs and walkthrough video to come!) How it works When you run the rclone rcd --rc-web-gui this is what happens - Rclone starts but only runs the remote control API ("rc"). - The API is bound to localhost with an auto-generated username and password. - If the API bundle is missing then rclone will download it. - rclone will start serving the files from the API bundle over the same port as the API - rclone will open the browser with a login_token so it can log straight in. Advanced use The rclone rcd may use any of the flags documented on the rc page. The flag --rc-web-gui is shorthand for - Download the web GUI if necessary - Check we are using some authentication - --rc-user gui - --rc-pass - --rc-serve These flags can be overridden as desired. See also the rclone rcd documentation. Example: Running a public GUI For example the GUI could be served on a public port over SSL using an htpasswd file using the following flags: - --rc-web-gui - --rc-addr :443 - --rc-htpasswd /path/to/htpasswd - --rc-cert /path/to/ssl.crt - --rc-key /path/to/ssl.key Example: Running a GUI behind a proxy If you want to run the GUI behind a proxy at /rclone you could use these flags: - --rc-web-gui - --rc-baseurl rclone - --rc-htpasswd /path/to/htpasswd Or instead of htpasswd if you just want a single user and password: - --rc-user me - --rc-pass mypassword Project The GUI is being developed in the: rclone/rclone-webui-react repository. Bug reports and contributions are very welcome :-) If you have questions then please ask them on the rclone forum. Remote controlling rclone with its API If rclone is run with the --rc flag then it starts an HTTP server which can be used to remote control rclone using its API. You can either use the rc command to access the API or use HTTP directly. If you just want to run a remote control then see the rcd command. Supported parameters --rc Flag to start the http server listen on remote requests. --rc-addr=IP IPaddress:Port or :Port to bind server to. (default "localhost:5572"). --rc-cert=KEY SSL PEM key (concatenation of certificate and CA certificate). --rc-client-ca=PATH Client certificate authority to verify clients with. --rc-htpasswd=PATH htpasswd file - if not provided no authentication is done. --rc-key=PATH TLS PEM private key file. --rc-max-header-bytes=VALUE Maximum size of request header (default 4096). --rc-min-tls-version=VALUE The minimum TLS version that is acceptable. Valid values are "tls1.0", "tls1.1", "tls1.2" and "tls1.3" (default "tls1.0"). --rc-user=VALUE User name for authentication. --rc-pass=VALUE Password for authentication. --rc-realm=VALUE Realm for authentication (default "rclone"). --rc-server-read-timeout=DURATION Timeout for server reading data (default 1h0m0s). --rc-server-write-timeout=DURATION Timeout for server writing data (default 1h0m0s). --rc-serve Enable the serving of remote objects via the HTTP interface. This means objects will be accessible at http://127.0.0.1:5572/ by default, so you can browse to http://127.0.0.1:5572/ or http://127.0.0.1:5572/* to see a listing of the remotes. Objects may be requested from remotes using this syntax http://127.0.0.1:5572/[remote:path]/path/to/object Default Off. --rc-serve-no-modtime Set this flag to skip reading the modification time (can speed things up). Default Off. --rc-files /path/to/directory Path to local files to serve on the HTTP server. If this is set then rclone will serve the files in that directory. It will also open the root in the web browser if specified. This is for implementing browser based GUIs for rclone functions. If --rc-user or --rc-pass is set then the URL that is opened will have the authorization in the URL in the http://user:pass@localhost/ style. Default Off. --rc-enable-metrics Enable OpenMetrics/Prometheus compatible endpoint at /metrics. If more control over the metrics is desired (for example running it on a different port or with different auth) then endpoint can be enabled with the --metrics-* flags instead. Default Off. --rc-web-gui Set this flag to serve the default web gui on the same port as rclone. Default Off. --rc-allow-origin Set the allowed Access-Control-Allow-Origin for rc requests. Can be used with --rc-web-gui if the rclone is running on different IP than the web-gui. Default is IP address on which rc is running. --rc-web-fetch-url Set the URL to fetch the rclone-web-gui files from. Default https://api.github.com/repos/rclone/rclone-webui-react/releases/latest. --rc-web-gui-update Set this flag to check and update rclone-webui-react from the rc-web-fetch-url. Default Off. --rc-web-gui-force-update Set this flag to force update rclone-webui-react from the rc-web-fetch-url. Default Off. --rc-web-gui-no-open-browser Set this flag to disable opening browser automatically when using web-gui. Default Off. --rc-job-expire-duration=DURATION Expire finished async jobs older than DURATION (default 60s). --rc-job-expire-interval=DURATION Interval duration to check for expired async jobs (default 10s). --rc-no-auth By default rclone will require authorisation to have been set up on the rc interface in order to use any methods which access any rclone remotes. Eg operations/list is denied as it involved creating a remote as is sync/copy. If this is set then no authorisation will be required on the server to use these methods. The alternative is to use --rc-user and --rc-pass and use these credentials in the request. Default Off. --rc-baseurl Prefix for URLs. Default is root --rc-template User-specified template. Accessing the remote control via the rclone rc command Rclone itself implements the remote control protocol in its rclone rc command. You can use it like this: $ rclone rc rc/noop param1=one param2=two { "param1": "one", "param2": "two" } If the remote is running on a different URL than the default http://localhost:5572/, use the --url option to specify it: rclone rc --url http://some.remote:1234/ rc/noop Or, if the remote is listening on a Unix socket, use the --unix-socket option instead: rclone rc --unix-socket /tmp/rclone.sock rc/noop Run rclone rc on its own, without any commands, to see the help for the installed remote control commands. Note that this also needs to connect to the remote server. JSON input rclone rc also supports a --json flag which can be used to send more complicated input parameters. $ rclone rc --json '{ "p1": [1,"2",null,4], "p2": { "a":1, "b":2 } }' rc/noop { "p1": [ 1, "2", null, 4 ], "p2": { "a": 1, "b": 2 } } If the parameter being passed is an object then it can be passed as a JSON string rather than using the --json flag which simplifies the command line. rclone rc operations/list fs=/tmp remote=test opt='{"showHash": true}' Rather than rclone rc operations/list --json '{"fs": "/tmp", "remote": "test", "opt": {"showHash": true}}' Special parameters The rc interface supports some special parameters which apply to all commands. These start with _ to show they are different. Running asynchronous jobs with _async = true Each rc call is classified as a job and it is assigned its own id. By default jobs are executed immediately as they are created or synchronously. If _async has a true value when supplied to an rc call then it will return immediately with a job id and the task will be run in the background. The job/status call can be used to get information of the background job. The job can be queried for up to 1 minute after it has finished. It is recommended that potentially long running jobs, e.g. sync/sync, sync/copy, sync/move, operations/purge are run with the _async flag to avoid any potential problems with the HTTP request and response timing out. Starting a job with the _async flag: $ rclone rc --json '{ "p1": [1,"2",null,4], "p2": { "a":1, "b":2 }, "_async": true }' rc/noop { "jobid": 2 } Query the status to see if the job has finished. For more information on the meaning of these return parameters see the job/status call. $ rclone rc --json '{ "jobid":2 }' job/status { "duration": 0.000124163, "endTime": "2018-10-27T11:38:07.911245881+01:00", "error": "", "finished": true, "id": 2, "output": { "_async": true, "p1": [ 1, "2", null, 4 ], "p2": { "a": 1, "b": 2 } }, "startTime": "2018-10-27T11:38:07.911121728+01:00", "success": true } job/list can be used to show the running or recently completed jobs $ rclone rc job/list { "jobids": [ 2 ] } Setting config flags with _config If you wish to set config (the equivalent of the global flags) for the duration of an rc call only then pass in the _config parameter. This should be in the same format as the main key returned by options/get. rclone rc --loopback options/get blocks=main You can see more help on these options with this command (see the options blocks section for more info). rclone rc --loopback options/info blocks=main For example, if you wished to run a sync with the --checksum parameter, you would pass this parameter in your JSON blob. "_config":{"CheckSum": true} If using rclone rc this could be passed as rclone rc sync/sync ... _config='{"CheckSum": true}' Any config parameters you don't set will inherit the global defaults which were set with command line flags or environment variables. Note that it is possible to set some values as strings or integers - see data types for more info. Here is an example setting the equivalent of --buffer-size in string or integer format. "_config":{"BufferSize": "42M"} "_config":{"BufferSize": 44040192} If you wish to check the _config assignment has worked properly then calling options/local will show what the value got set to. Setting filter flags with _filter If you wish to set filters for the duration of an rc call only then pass in the _filter parameter. This should be in the same format as the filter key returned by options/get. rclone rc --loopback options/get blocks=filter You can see more help on these options with this command (see the options blocks section for more info). rclone rc --loopback options/info blocks=filter For example, if you wished to run a sync with these flags --max-size 1M --max-age 42s --include "a" --include "b" you would pass this parameter in your JSON blob. "_filter":{"MaxSize":"1M", "IncludeRule":["a","b"], "MaxAge":"42s"} If using rclone rc this could be passed as rclone rc ... _filter='{"MaxSize":"1M", "IncludeRule":["a","b"], "MaxAge":"42s"}' Any filter parameters you don't set will inherit the global defaults which were set with command line flags or environment variables. Note that it is possible to set some values as strings or integers - see data types for more info. Here is an example setting the equivalent of --buffer-size in string or integer format. "_filter":{"MinSize": "42M"} "_filter":{"MinSize": 44040192} If you wish to check the _filter assignment has worked properly then calling options/local will show what the value got set to. Assigning operations to groups with _group = value Each rc call has its own stats group for tracking its metrics. By default grouping is done by the composite group name from prefix job/ and id of the job like so job/1. If _group has a value then stats for that request will be grouped under that value. This allows caller to group stats under their own name. Stats for specific group can be accessed by passing group to core/stats: $ rclone rc --json '{ "group": "job/1" }' core/stats { "speed": 12345 ... } Data types When the API returns types, these will mostly be straight forward integer, string or boolean types. However some of the types returned by the options/get call and taken by the options/set calls as well as the vfsOpt, mountOpt and the _config parameters. - Duration - these are returned as an integer duration in nanoseconds. They may be set as an integer, or they may be set with time string, eg "5s". See the options section for more info. - Size - these are returned as an integer number of bytes. They may be set as an integer or they may be set with a size suffix string, eg "10M". See the options section for more info. - Enumerated type (such as CutoffMode, DumpFlags, LogLevel, VfsCacheMode - these will be returned as an integer and may be set as an integer but more conveniently they can be set as a string, eg "HARD" for CutoffMode or DEBUG for LogLevel. - BandwidthSpec - this will be set and returned as a string, eg "1M". Option blocks The calls options/info (for the main config) and config/providers (for the backend config) may be used to get information on the rclone configuration options. This can be used to build user interfaces for displaying and setting any rclone option. These consist of arrays of Option blocks. These have the following format. Each block describes a single option. ------------------------------------------------------------------------ Field Type Optional Description ------------- ------------ ------------------- ------------------------- Name string N name of the option in snake_case FieldName string N name of the field used in the rc - if blank use Name. May contain "." for nested fields. Help string N help, started with a single sentence on a single line Groups string Y groups this option belongs to - comma separated string for options classification Provider string Y set to filter on provider Default any N default value, if set (and not to nil or "") then Required does nothing Value any N value to be set by flags Examples Examples Y predefined values that can be selected from list (multiple-choice option) ShortOpt string Y the short command line option for this Hide Visibility N if non zero, this option is hidden from the configurator or the command line Required bool N this option is required, meaning value cannot be empty unless there is a default IsPassword bool N set if the option is a password NoPrefix bool N set if the option for this should not use the backend prefix Advanced bool N set if this is an advanced config option Exclusive bool N set if the answer can only be one of the examples (empty string allowed unless Required or Default is set) Sensitive bool N set if this option should be redacted when using rclone config redacted ------------------------------------------------------------------------ An example of this might be the --log-level flag. Note that the Name of the option becomes the command line flag with _ replaced with -. { "Advanced": false, "Default": 5, "DefaultStr": "NOTICE", "Examples": [ { "Help": "", "Value": "EMERGENCY" }, { "Help": "", "Value": "ALERT" }, ... ], "Exclusive": true, "FieldName": "LogLevel", "Groups": "Logging", "Help": "Log level DEBUG|INFO|NOTICE|ERROR", "Hide": 0, "IsPassword": false, "Name": "log_level", "NoPrefix": true, "Required": true, "Sensitive": false, "Type": "LogLevel", "Value": null, "ValueStr": "NOTICE" }, Note that the Help may be multiple lines separated by \n. The first line will always be a short sentence and this is the sentence shown when running rclone help flags. Specifying remotes to work on Remotes are specified with the fs=, srcFs=, dstFs= parameters depending on the command being used. The parameters can be a string as per the rest of rclone, eg s3:bucket/path or :sftp:/my/dir. They can also be specified as JSON blobs. If specifying a JSON blob it should be a object mapping strings to strings. These values will be used to configure the remote. There are 3 special values which may be set: - type - set to type to specify a remote called :type: - _name - set to name to specify a remote called name: - _root - sets the root of the remote - may be empty One of _name or type should normally be set. If the local backend is desired then type should be set to local. If _root isn't specified then it defaults to the root of the remote. For example this JSON is equivalent to remote:/tmp { "_name": "remote", "_root": "/tmp" } And this is equivalent to :sftp,host='example.com':/tmp { "type": "sftp", "host": "example.com", "_root": "/tmp" } And this is equivalent to /tmp/dir { "type": "local", "_root": "/tmp/dir" } Supported commands backend/command: Runs a backend command. This takes the following parameters: - command - a string with the command name - fs - a remote name string e.g. "drive:" - arg - a list of arguments for the backend command - opt - a map of string to string of options Returns: - result - result from the backend command Example: rclone rc backend/command command=noop fs=. -o echo=yes -o blue -a path1 -a path2 Returns { "result": { "arg": [ "path1", "path2" ], "name": "noop", "opt": { "blue": "", "echo": "yes" } } } Note that this is the direct equivalent of using this "backend" command: rclone backend noop . -o echo=yes -o blue path1 path2 Note that arguments must be preceded by the "-a" flag See the backend command for more information. Authentication is required for this call. cache/expire: Purge a remote from cache Purge a remote from the cache backend. Supports either a directory or a file. Params: - remote = path to remote (required) - withData = true/false to delete cached data (chunks) as well (optional) Eg rclone rc cache/expire remote=path/to/sub/folder/ rclone rc cache/expire remote=/ withData=true cache/fetch: Fetch file chunks Ensure the specified file chunks are cached on disk. The chunks= parameter specifies the file chunks to check. It takes a comma separated list of array slice indices. The slice indices are similar to Python slices: start[:end] start is the 0 based chunk number from the beginning of the file to fetch inclusive. end is 0 based chunk number from the beginning of the file to fetch exclusive. Both values can be negative, in which case they count from the back of the file. The value "-5:" represents the last 5 chunks of a file. Some valid examples are: ":5,-5:" -> the first and last five chunks "0,-2" -> the first and the second last chunk "0:10" -> the first ten chunks Any parameter with a key that starts with "file" can be used to specify files to fetch, e.g. rclone rc cache/fetch chunks=0 file=hello file2=home/goodbye File names will automatically be encrypted when the a crypt remote is used on top of the cache. cache/stats: Get cache stats Show statistics for the cache remote. config/create: create the config for a remote. This takes the following parameters: - name - name of remote - parameters - a map of { "key": "value" } pairs - type - type of the new remote - opt - a dictionary of options to control the configuration - obscure - declare passwords are plain and need obscuring - noObscure - declare passwords are already obscured and don't need obscuring - noOutput - don't print anything to stdout - nonInteractive - don't interact with a user, return questions - continue - continue the config process with an answer - all - ask all the config questions not just the post config ones - state - state to restart with - used with continue - result - result to restart with - used with continue See the config create command for more information on the above. Authentication is required for this call. config/delete: Delete a remote in the config file. Parameters: - name - name of remote to delete See the config delete command for more information on the above. Authentication is required for this call. config/dump: Dumps the config file. Returns a JSON object: - key: value Where keys are remote names and values are the config parameters. See the config dump command for more information on the above. Authentication is required for this call. config/get: Get a remote in the config file. Parameters: - name - name of remote to get See the config dump command for more information on the above. Authentication is required for this call. config/listremotes: Lists the remotes in the config file and defined in environment variables. Returns - remotes - array of remote names See the listremotes command for more information on the above. Authentication is required for this call. config/password: password the config for a remote. This takes the following parameters: - name - name of remote - parameters - a map of { "key": "value" } pairs See the config password command for more information on the above. Authentication is required for this call. config/paths: Reads the config file path and other important paths. Returns a JSON object with the following keys: - config: path to config file - cache: path to root of cache directory - temp: path to root of temporary directory Eg { "cache": "/home/USER/.cache/rclone", "config": "/home/USER/.rclone.conf", "temp": "/tmp" } See the config paths command for more information on the above. Authentication is required for this call. config/providers: Shows how providers are configured in the config file. Returns a JSON object: - providers - array of objects See the config providers command for more information on the above. Note that the Options blocks are in the same format as returned by "options/info". They are described in the option blocks section. Authentication is required for this call. config/setpath: Set the path of the config file Parameters: - path - path to the config file to use Authentication is required for this call. config/unlock: Unlock the config file. Unlocks the config file if it is locked. Parameters: - 'config_password' - password to unlock the config file A good idea is to disable AskPassword before making this call Authentication is required for this call. config/update: update the config for a remote. This takes the following parameters: - name - name of remote - parameters - a map of { "key": "value" } pairs - opt - a dictionary of options to control the configuration - obscure - declare passwords are plain and need obscuring - noObscure - declare passwords are already obscured and don't need obscuring - noOutput - don't print anything to stdout - nonInteractive - don't interact with a user, return questions - continue - continue the config process with an answer - all - ask all the config questions not just the post config ones - state - state to restart with - used with continue - result - result to restart with - used with continue See the config update command for more information on the above. Authentication is required for this call. core/bwlimit: Set the bandwidth limit. This sets the bandwidth limit to the string passed in. This should be a single bandwidth limit entry or a pair of upload:download bandwidth. Eg rclone rc core/bwlimit rate=off { "bytesPerSecond": -1, "bytesPerSecondTx": -1, "bytesPerSecondRx": -1, "rate": "off" } rclone rc core/bwlimit rate=1M { "bytesPerSecond": 1048576, "bytesPerSecondTx": 1048576, "bytesPerSecondRx": 1048576, "rate": "1M" } rclone rc core/bwlimit rate=1M:100k { "bytesPerSecond": 1048576, "bytesPerSecondTx": 1048576, "bytesPerSecondRx": 131072, "rate": "1M" } If the rate parameter is not supplied then the bandwidth is queried rclone rc core/bwlimit { "bytesPerSecond": 1048576, "bytesPerSecondTx": 1048576, "bytesPerSecondRx": 1048576, "rate": "1M" } The format of the parameter is exactly the same as passed to --bwlimit except only one bandwidth may be specified. In either case "rate" is returned as a human-readable string, and "bytesPerSecond" is returned as a number. core/command: Run a rclone terminal command over rc. This takes the following parameters: - command - a string with the command name. - arg - a list of arguments for the backend command. - opt - a map of string to string of options. - returnType - one of ("COMBINED_OUTPUT", "STREAM", "STREAM_ONLY_STDOUT", "STREAM_ONLY_STDERR"). - Defaults to "COMBINED_OUTPUT" if not set. - The STREAM returnTypes will write the output to the body of the HTTP message. - The COMBINED_OUTPUT will write the output to the "result" parameter. Returns: - result - result from the backend command. - Only set when using returnType "COMBINED_OUTPUT". - error - set if rclone exits with an error code. - returnType - one of ("COMBINED_OUTPUT", "STREAM", "STREAM_ONLY_STDOUT", "STREAM_ONLY_STDERR"). Example: rclone rc core/command command=ls -a mydrive:/ -o max-depth=1 rclone rc core/command -a ls -a mydrive:/ -o max-depth=1 Returns: { "error": false, "result": "" } OR { "error": true, "result": "" } Authentication is required for this call. core/du: Returns disk usage of a locally attached disk. This returns the disk usage for the local directory passed in as dir. If the directory is not passed in, it defaults to the directory pointed to by --cache-dir. - dir - string (optional) Returns: { "dir": "/", "info": { "Available": 361769115648, "Free": 361785892864, "Total": 982141468672 } } core/gc: Runs a garbage collection. This tells the go runtime to do a garbage collection run. It isn't necessary to call this normally, but it can be useful for debugging memory problems. core/group-list: Returns list of stats. This returns list of stats groups currently in memory. Returns the following values: { "groups": an array of group names: [ "group1", "group2", ... ] } core/memstats: Returns the memory statistics This returns the memory statistics of the running program. What the values mean are explained in the go docs: https://golang.org/pkg/runtime/#MemStats The most interesting values for most people are: - HeapAlloc - this is the amount of memory rclone is actually using - HeapSys - this is the amount of memory rclone has obtained from the OS - Sys - this is the total amount of memory requested from the OS - It is virtual memory so may include unused memory core/obscure: Obscures a string passed in. Pass a clear string and rclone will obscure it for the config file: - clear - string Returns: - obscured - string core/pid: Return PID of current process This returns PID of current process. Useful for stopping rclone process. core/quit: Terminates the app. (Optional) Pass an exit code to be used for terminating the app: - exitCode - int core/stats: Returns stats about current transfers. This returns all available stats: rclone rc core/stats If group is not provided then summed up stats for all groups will be returned. Parameters - group - name of the stats group (string, optional) - short - if true will not return the transferring and checking arrays (boolean, optional) Returns the following values: { "bytes": total transferred bytes since the start of the group, "checks": number of files checked, "deletes" : number of files deleted, "elapsedTime": time in floating point seconds since rclone was started, "errors": number of errors, "eta": estimated time in seconds until the group completes, "fatalError": boolean whether there has been at least one fatal error, "lastError": last error string, "renames" : number of files renamed, "listed" : number of directory entries listed, "retryError": boolean showing whether there has been at least one non-NoRetryError, "serverSideCopies": number of server side copies done, "serverSideCopyBytes": number bytes server side copied, "serverSideMoves": number of server side moves done, "serverSideMoveBytes": number bytes server side moved, "speed": average speed in bytes per second since start of the group, "totalBytes": total number of bytes in the group, "totalChecks": total number of checks in the group, "totalTransfers": total number of transfers in the group, "transferTime" : total time spent on running jobs, "transfers": number of transferred files, "transferring": an array of currently active file transfers: [ { "bytes": total transferred bytes for this file, "eta": estimated time in seconds until file transfer completion "name": name of the file, "percentage": progress of the file transfer in percent, "speed": average speed over the whole transfer in bytes per second, "speedAvg": current speed in bytes per second as an exponentially weighted moving average, "size": size of the file in bytes } ], "checking": an array of names of currently active file checks [] } Values for "transferring", "checking" and "lastError" are only assigned if data is available. The value for "eta" is null if an eta cannot be determined. core/stats-delete: Delete stats group. This deletes entire stats group. Parameters - group - name of the stats group (string) core/stats-reset: Reset stats. This clears counters, errors and finished transfers for all stats or specific stats group if group is provided. Parameters - group - name of the stats group (string) core/transferred: Returns stats about completed transfers. This returns stats about completed transfers: rclone rc core/transferred If group is not provided then completed transfers for all groups will be returned. Note only the last 100 completed transfers are returned. Parameters - group - name of the stats group (string) Returns the following values: { "transferred": an array of completed transfers (including failed ones): [ { "name": name of the file, "size": size of the file in bytes, "bytes": total transferred bytes for this file, "checked": if the transfer is only checked (skipped, deleted), "what": the purpose of the transfer (transferring, deleting, checking, importing, hashing, merging, listing, moving, renaming), "timestamp": integer representing millisecond unix epoch, "error": string description of the error (empty if successful), "jobid": id of the job that this transfer belongs to } ] } core/version: Shows the current version of rclone and the go runtime. This shows the current version of go and the go runtime: - version - rclone version, e.g. "v1.53.0" - decomposed - version number as [major, minor, patch] - isGit - boolean - true if this was compiled from the git version - isBeta - boolean - true if this is a beta version - os - OS in use as according to Go - arch - cpu architecture in use according to Go - goVersion - version of Go runtime in use - linking - type of rclone executable (static or dynamic) - goTags - space separated build tags or "none" debug/set-block-profile-rate: Set runtime.SetBlockProfileRate for blocking profiling. SetBlockProfileRate controls the fraction of goroutine blocking events that are reported in the blocking profile. The profiler aims to sample an average of one blocking event per rate nanoseconds spent blocked. To include every blocking event in the profile, pass rate = 1. To turn off profiling entirely, pass rate <= 0. After calling this you can use this to see the blocking profile: go tool pprof http://localhost:5572/debug/pprof/block Parameters: - rate - int debug/set-gc-percent: Call runtime/debug.SetGCPercent for setting the garbage collection target percentage. SetGCPercent sets the garbage collection target percentage: a collection is triggered when the ratio of freshly allocated data to live data remaining after the previous collection reaches this percentage. SetGCPercent returns the previous setting. The initial setting is the value of the GOGC environment variable at startup, or 100 if the variable is not set. This setting may be effectively reduced in order to maintain a memory limit. A negative percentage effectively disables garbage collection, unless the memory limit is reached. See https://pkg.go.dev/runtime/debug#SetMemoryLimit for more details. Parameters: - gc-percent - int debug/set-mutex-profile-fraction: Set runtime.SetMutexProfileFraction for mutex profiling. SetMutexProfileFraction controls the fraction of mutex contention events that are reported in the mutex profile. On average 1/rate events are reported. The previous rate is returned. To turn off profiling entirely, pass rate 0. To just read the current rate, pass rate < 0. (For n>1 the details of sampling may change.) Once this is set you can look use this to profile the mutex contention: go tool pprof http://localhost:5572/debug/pprof/mutex Parameters: - rate - int Results: - previousRate - int debug/set-soft-memory-limit: Call runtime/debug.SetMemoryLimit for setting a soft memory limit for the runtime. SetMemoryLimit provides the runtime with a soft memory limit. The runtime undertakes several processes to try to respect this memory limit, including adjustments to the frequency of garbage collections and returning memory to the underlying system more aggressively. This limit will be respected even if GOGC=off (or, if SetGCPercent(-1) is executed). The input limit is provided as bytes, and includes all memory mapped, managed, and not released by the Go runtime. Notably, it does not account for space used by the Go binary and memory external to Go, such as memory managed by the underlying system on behalf of the process, or memory managed by non-Go code inside the same process. Examples of excluded memory sources include: OS kernel memory held on behalf of the process, memory allocated by C code, and memory mapped by syscall.Mmap (because it is not managed by the Go runtime). A zero limit or a limit that's lower than the amount of memory used by the Go runtime may cause the garbage collector to run nearly continuously. However, the application may still make progress. The memory limit is always respected by the Go runtime, so to effectively disable this behavior, set the limit very high. math.MaxInt64 is the canonical value for disabling the limit, but values much greater than the available memory on the underlying system work just as well. See https://go.dev/doc/gc-guide for a detailed guide explaining the soft memory limit in more detail, as well as a variety of common use-cases and scenarios. SetMemoryLimit returns the previously set memory limit. A negative input does not adjust the limit, and allows for retrieval of the currently set memory limit. Parameters: - mem-limit - int fscache/clear: Clear the Fs cache. This clears the fs cache. This is where remotes created from backends are cached for a short while to make repeated rc calls more efficient. If you change the parameters of a backend then you may want to call this to clear an existing remote out of the cache before re-creating it. Authentication is required for this call. fscache/entries: Returns the number of entries in the fs cache. This returns the number of entries in the fs cache. Returns - entries - number of items in the cache Authentication is required for this call. job/list: Lists the IDs of the running jobs Parameters: None. Results: - executeId - string id of rclone executing (change after restart) - jobids - array of integer job ids (starting at 1 on each restart) job/status: Reads the status of the job ID Parameters: - jobid - id of the job (integer). Results: - finished - boolean - duration - time in seconds that the job ran for - endTime - time the job finished (e.g. "2018-10-26T18:50:20.528746884+01:00") - error - error from the job or empty string for no error - finished - boolean whether the job has finished or not - id - as passed in above - startTime - time the job started (e.g. "2018-10-26T18:50:20.528336039+01:00") - success - boolean - true for success false otherwise - output - output of the job as would have been returned if called synchronously - progress - output of the progress related to the underlying job job/stop: Stop the running job Parameters: - jobid - id of the job (integer). job/stopgroup: Stop all running jobs in a group Parameters: - group - name of the group (string). mount/listmounts: Show current mount points This shows currently mounted points, which can be used for performing an unmount. This takes no parameters and returns - mountPoints: list of current mount points Eg rclone rc mount/listmounts Authentication is required for this call. mount/mount: Create a new mount point rclone allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE. If no mountType is provided, the priority is given as follows: 1. mount 2.cmount 3.mount2 This takes the following parameters: - fs - a remote path to be mounted (required) - mountPoint: valid path on the local machine (required) - mountType: one of the values (mount, cmount, mount2) specifies the mount implementation to use - mountOpt: a JSON object with Mount options in. - vfsOpt: a JSON object with VFS options in. Example: rclone rc mount/mount fs=mydrive: mountPoint=/home//mountPoint rclone rc mount/mount fs=mydrive: mountPoint=/home//mountPoint mountType=mount rclone rc mount/mount fs=TestDrive: mountPoint=/mnt/tmp vfsOpt='{"CacheMode": 2}' mountOpt='{"AllowOther": true}' The vfsOpt are as described in options/get and can be seen in the the "vfs" section when running and the mountOpt can be seen in the "mount" section: rclone rc options/get Authentication is required for this call. mount/types: Show all possible mount types This shows all possible mount types and returns them as a list. This takes no parameters and returns - mountTypes: list of mount types The mount types are strings like "mount", "mount2", "cmount" and can be passed to mount/mount as the mountType parameter. Eg rclone rc mount/types Authentication is required for this call. mount/unmount: Unmount selected active mount rclone allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE. This takes the following parameters: - mountPoint: valid path on the local machine where the mount was created (required) Example: rclone rc mount/unmount mountPoint=/home//mountPoint Authentication is required for this call. mount/unmountall: Unmount all active mounts rclone allows Linux, FreeBSD, macOS and Windows to mount any of Rclone's cloud storage systems as a file system with FUSE. This takes no parameters and returns error if unmount does not succeed. Eg rclone rc mount/unmountall Authentication is required for this call. operations/about: Return the space used on the remote This takes the following parameters: - fs - a remote name string e.g. "drive:" The result is as returned from rclone about --json See the about command for more information on the above. Authentication is required for this call. operations/check: check the source and destination are the same Checks the files in the source and destination match. It compares sizes and hashes and logs a report of files that don't match. It doesn't alter the source or destination. This takes the following parameters: - srcFs - a remote name string e.g. "drive:" for the source, "/" for local filesystem - dstFs - a remote name string e.g. "drive2:" for the destination, "/" for local filesystem - download - check by downloading rather than with hash - checkFileHash - treat checkFileFs:checkFileRemote as a SUM file with hashes of given type - checkFileFs - treat checkFileFs:checkFileRemote as a SUM file with hashes of given type - checkFileRemote - treat checkFileFs:checkFileRemote as a SUM file with hashes of given type - oneWay - check one way only, source files must exist on remote - combined - make a combined report of changes (default false) - missingOnSrc - report all files missing from the source (default true) - missingOnDst - report all files missing from the destination (default true) - match - report all matching files (default false) - differ - report all non-matching files (default true) - error - report all files with errors (hashing or reading) (default true) If you supply the download flag, it will download the data from both remotes and check them against each other on the fly. This can be useful for remotes that don't support hashes or if you really want to check all the data. If you supply the size-only global flag, it will only compare the sizes not the hashes as well. Use this for a quick check. If you supply the checkFileHash option with a valid hash name, the checkFileFs:checkFileRemote must point to a text file in the SUM format. This treats the checksum file as the source and dstFs as the destination. Note that srcFs is not used and should not be supplied in this case. Returns: - success - true if no error, false otherwise - status - textual summary of check, OK or text string - hashType - hash used in check, may be missing - combined - array of strings of combined report of changes - missingOnSrc - array of strings of all files missing from the source - missingOnDst - array of strings of all files missing from the destination - match - array of strings of all matching files - differ - array of strings of all non-matching files - error - array of strings of all files with errors (hashing or reading) Authentication is required for this call. operations/cleanup: Remove trashed files in the remote or path This takes the following parameters: - fs - a remote name string e.g. "drive:" See the cleanup command for more information on the above. Authentication is required for this call. operations/copyfile: Copy a file from source remote to destination remote This takes the following parameters: - srcFs - a remote name string e.g. "drive:" for the source, "/" for local filesystem - srcRemote - a path within that remote e.g. "file.txt" for the source - dstFs - a remote name string e.g. "drive2:" for the destination, "/" for local filesystem - dstRemote - a path within that remote e.g. "file2.txt" for the destination Authentication is required for this call. operations/copyurl: Copy the URL to the object This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" - url - string, URL to read from - autoFilename - boolean, set to true to retrieve destination file name from url See the copyurl command for more information on the above. Authentication is required for this call. operations/delete: Remove files in the path This takes the following parameters: - fs - a remote name string e.g. "drive:" See the delete command for more information on the above. Authentication is required for this call. operations/deletefile: Remove the single file pointed to This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" See the deletefile command for more information on the above. Authentication is required for this call. operations/fsinfo: Return information about the remote This takes the following parameters: - fs - a remote name string e.g. "drive:" This returns info about the remote passed in; { // optional features and whether they are available or not "Features": { "About": true, "BucketBased": false, "BucketBasedRootOK": false, "CanHaveEmptyDirectories": true, "CaseInsensitive": false, "ChangeNotify": false, "CleanUp": false, "Command": true, "Copy": false, "DirCacheFlush": false, "DirMove": true, "Disconnect": false, "DuplicateFiles": false, "GetTier": false, "IsLocal": true, "ListR": false, "MergeDirs": false, "MetadataInfo": true, "Move": true, "OpenWriterAt": true, "PublicLink": false, "Purge": true, "PutStream": true, "PutUnchecked": false, "ReadMetadata": true, "ReadMimeType": false, "ServerSideAcrossConfigs": false, "SetTier": false, "SetWrapper": false, "Shutdown": false, "SlowHash": true, "SlowModTime": false, "UnWrap": false, "UserInfo": false, "UserMetadata": true, "WrapFs": false, "WriteMetadata": true, "WriteMimeType": false }, // Names of hashes available "Hashes": [ "md5", "sha1", "whirlpool", "crc32", "sha256", "dropbox", "mailru", "quickxor" ], "Name": "local", // Name as created "Precision": 1, // Precision of timestamps in ns "Root": "/", // Path as created "String": "Local file system at /", // how the remote will appear in logs // Information about the system metadata for this backend "MetadataInfo": { "System": { "atime": { "Help": "Time of last access", "Type": "RFC 3339", "Example": "2006-01-02T15:04:05.999999999Z07:00" }, "btime": { "Help": "Time of file birth (creation)", "Type": "RFC 3339", "Example": "2006-01-02T15:04:05.999999999Z07:00" }, "gid": { "Help": "Group ID of owner", "Type": "decimal number", "Example": "500" }, "mode": { "Help": "File type and mode", "Type": "octal, unix style", "Example": "0100664" }, "mtime": { "Help": "Time of last modification", "Type": "RFC 3339", "Example": "2006-01-02T15:04:05.999999999Z07:00" }, "rdev": { "Help": "Device ID (if special file)", "Type": "hexadecimal", "Example": "1abc" }, "uid": { "Help": "User ID of owner", "Type": "decimal number", "Example": "500" } }, "Help": "Textual help string\n" } } This command does not have a command line equivalent so use this instead: rclone rc --loopback operations/fsinfo fs=remote: operations/hashsum: Produces a hashsum file for all the objects in the path. Produces a hash file for all the objects in the path using the hash named. The output is in the same format as the standard md5sum/sha1sum tool. This takes the following parameters: - fs - a remote name string e.g. "drive:" for the source, "/" for local filesystem - this can point to a file and just that file will be returned in the listing. - hashType - type of hash to be used - download - check by downloading rather than with hash (boolean) - base64 - output the hashes in base64 rather than hex (boolean) If you supply the download flag, it will download the data from the remote and create the hash on the fly. This can be useful for remotes that don't support the given hash or if you really want to check all the data. Note that if you wish to supply a checkfile to check hashes against the current files then you should use operations/check instead of operations/hashsum. Returns: - hashsum - array of strings of the hashes - hashType - type of hash used Example: $ rclone rc --loopback operations/hashsum fs=bin hashType=MD5 download=true base64=true { "hashType": "md5", "hashsum": [ "WTSVLpuiXyJO_kGzJerRLg== backend-versions.sh", "v1b_OlWCJO9LtNq3EIKkNQ== bisect-go-rclone.sh", "VHbmHzHh4taXzgag8BAIKQ== bisect-rclone.sh", ] } See the hashsum command for more information on the above. Authentication is required for this call. operations/list: List the given remote and path in JSON format This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" - opt - a dictionary of options to control the listing (optional) - recurse - If set recurse directories - noModTime - If set return modification time - showEncrypted - If set show decrypted names - showOrigIDs - If set show the IDs for each item if known - showHash - If set return a dictionary of hashes - noMimeType - If set don't show mime types - dirsOnly - If set only show directories - filesOnly - If set only show files - metadata - If set return metadata of objects also - hashTypes - array of strings of hash types to show if showHash set Returns: - list - This is an array of objects as described in the lsjson command See the lsjson command for more information on the above and examples. Authentication is required for this call. operations/mkdir: Make a destination directory or container This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" See the mkdir command for more information on the above. Authentication is required for this call. operations/movefile: Move a file from source remote to destination remote This takes the following parameters: - srcFs - a remote name string e.g. "drive:" for the source, "/" for local filesystem - srcRemote - a path within that remote e.g. "file.txt" for the source - dstFs - a remote name string e.g. "drive2:" for the destination, "/" for local filesystem - dstRemote - a path within that remote e.g. "file2.txt" for the destination Authentication is required for this call. operations/publiclink: Create or retrieve a public link to the given file or folder. This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" - unlink - boolean - if set removes the link rather than adding it (optional) - expire - string - the expiry time of the link e.g. "1d" (optional) Returns: - url - URL of the resource See the link command for more information on the above. Authentication is required for this call. operations/purge: Remove a directory or container and all of its contents This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" See the purge command for more information on the above. Authentication is required for this call. operations/rmdir: Remove an empty directory or container This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" See the rmdir command for more information on the above. Authentication is required for this call. operations/rmdirs: Remove all the empty directories in the path This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" - leaveRoot - boolean, set to true not to delete the root See the rmdirs command for more information on the above. Authentication is required for this call. operations/settier: Changes storage tier or class on all files in the path This takes the following parameters: - fs - a remote name string e.g. "drive:" See the settier command for more information on the above. Authentication is required for this call. operations/settierfile: Changes storage tier or class on the single file pointed to This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" See the settierfile command for more information on the above. Authentication is required for this call. operations/size: Count the number of bytes and files in remote This takes the following parameters: - fs - a remote name string e.g. "drive:path/to/dir" Returns: - count - number of files - bytes - number of bytes in those files See the size command for more information on the above. Authentication is required for this call. operations/stat: Give information about the supplied file or directory This takes the following parameters - fs - a remote name string eg "drive:" - remote - a path within that remote eg "dir" - opt - a dictionary of options to control the listing (optional) - see operations/list for the options The result is - item - an object as described in the lsjson command. Will be null if not found. Note that if you are only interested in files then it is much more efficient to set the filesOnly flag in the options. See the lsjson command for more information on the above and examples. Authentication is required for this call. operations/uploadfile: Upload file using multiform/form-data This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" - each part in body represents a file to be uploaded See the uploadfile command for more information on the above. Authentication is required for this call. options/blocks: List all the option blocks Returns: - options - a list of the options block names options/get: Get all the global options Returns an object where keys are option block names and values are an object with the current option values in. Parameters: - blocks: optional string of comma separated blocks to include - all are included if this is missing or "" Note that these are the global options which are unaffected by use of the _config and _filter parameters. If you wish to read the parameters set in _config or _filter use options/local. This shows the internal names of the option within rclone which should map to the external options very easily with a few exceptions. options/info: Get info about all the global options Returns an object where keys are option block names and values are an array of objects with info about each options. Parameters: - blocks: optional string of comma separated blocks to include - all are included if this is missing or "" These objects are in the same format as returned by "config/providers". They are described in the option blocks section. options/local: Get the currently active config for this call Returns an object with the keys "config" and "filter". The "config" key contains the local config and the "filter" key contains the local filters. Note that these are the local options specific to this rc call. If _config was not supplied then they will be the global options. Likewise with "_filter". This call is mostly useful for seeing if _config and _filter passing is working. This shows the internal names of the option within rclone which should map to the external options very easily with a few exceptions. options/set: Set an option Parameters: - option block name containing an object with - key: value Repeated as often as required. Only supply the options you wish to change. If an option is unknown it will be silently ignored. Not all options will have an effect when changed like this. For example: This sets DEBUG level logs (-vv) (these can be set by number or string) rclone rc options/set --json '{"main": {"LogLevel": "DEBUG"}}' rclone rc options/set --json '{"main": {"LogLevel": 8}}' And this sets INFO level logs (-v) rclone rc options/set --json '{"main": {"LogLevel": "INFO"}}' And this sets NOTICE level logs (normal without -v) rclone rc options/set --json '{"main": {"LogLevel": "NOTICE"}}' pluginsctl/addPlugin: Add a plugin using url Used for adding a plugin to the webgui. This takes the following parameters: - url - http url of the github repo where the plugin is hosted (http://github.com/rclone/rclone-webui-react). Example: rclone rc pluginsctl/addPlugin Authentication is required for this call. pluginsctl/getPluginsForType: Get plugins with type criteria This shows all possible plugins by a mime type. This takes the following parameters: - type - supported mime type by a loaded plugin e.g. (video/mp4, audio/mp3). - pluginType - filter plugins based on their type e.g. (DASHBOARD, FILE_HANDLER, TERMINAL). Returns: - loadedPlugins - list of current production plugins. - testPlugins - list of temporarily loaded development plugins, usually running on a different server. Example: rclone rc pluginsctl/getPluginsForType type=video/mp4 Authentication is required for this call. pluginsctl/listPlugins: Get the list of currently loaded plugins This allows you to get the currently enabled plugins and their details. This takes no parameters and returns: - loadedPlugins - list of current production plugins. - testPlugins - list of temporarily loaded development plugins, usually running on a different server. E.g. rclone rc pluginsctl/listPlugins Authentication is required for this call. pluginsctl/listTestPlugins: Show currently loaded test plugins Allows listing of test plugins with the rclone.test set to true in package.json of the plugin. This takes no parameters and returns: - loadedTestPlugins - list of currently available test plugins. E.g. rclone rc pluginsctl/listTestPlugins Authentication is required for this call. pluginsctl/removePlugin: Remove a loaded plugin This allows you to remove a plugin using it's name. This takes parameters: - name - name of the plugin in the format author/plugin_name. E.g. rclone rc pluginsctl/removePlugin name=rclone/video-plugin Authentication is required for this call. pluginsctl/removeTestPlugin: Remove a test plugin This allows you to remove a plugin using it's name. This takes the following parameters: - name - name of the plugin in the format author/plugin_name. Example: rclone rc pluginsctl/removeTestPlugin name=rclone/rclone-webui-react Authentication is required for this call. rc/error: This returns an error This returns an error with the input as part of its error string. Useful for testing error handling. rc/list: List all the registered remote control commands This lists all the registered remote control commands as a JSON map in the commands response. rc/noop: Echo the input to the output parameters This echoes the input parameters to the output parameters for testing purposes. It can be used to check that rclone is still alive and to check that parameter passing is working properly. rc/noopauth: Echo the input to the output parameters requiring auth This echoes the input parameters to the output parameters for testing purposes. It can be used to check that rclone is still alive and to check that parameter passing is working properly. Authentication is required for this call. serve/list: Show running servers Show running servers with IDs. This takes no parameters and returns - list: list of running serve commands Each list element will have - id: ID of the server - addr: address the server is running on - params: parameters used to start the server Eg rclone rc serve/list Returns { "list": [ { "addr": "[::]:4321", "id": "nfs-ffc2a4e5", "params": { "fs": "remote:", "opt": { "ListenAddr": ":4321" }, "type": "nfs", "vfsOpt": { "CacheMode": "full" } } } ] } Authentication is required for this call. serve/start: Create a new server Create a new server with the specified parameters. This takes the following parameters: - type - type of server: http, webdav, ftp, sftp, nfs, etc. - fs - remote storage path to serve - addr - the ip:port to run the server on, eg ":1234" or "localhost:1234" Other parameters are as described in the documentation for the relevant rclone serve command line options. To translate a command line option to an rc parameter, remove the leading -- and replace - with _, so --vfs-cache-mode becomes vfs_cache_mode. Note that global parameters must be set with _config and _filter as described above. Examples: rclone rc serve/start type=nfs fs=remote: addr=:4321 vfs_cache_mode=full rclone rc serve/start --json '{"type":"nfs","fs":"remote:","addr":":1234","vfs_cache_mode":"full"}' This will give the reply { "addr": "[::]:4321", // Address the server was started on "id": "nfs-ecfc6852" // Unique identifier for the server instance } Or an error if it failed to start. Stop the server with serve/stop and list the running servers with serve/list. Authentication is required for this call. serve/stop: Unserve selected active serve Stops a running serve instance by ID. This takes the following parameters: - id: as returned by serve/start This will give an empty response if successful or an error if not. Example: rclone rc serve/stop id=12345 Authentication is required for this call. serve/stopall: Stop all active servers Stop all active servers. This will stop all active servers. rclone rc serve/stopall Authentication is required for this call. serve/types: Show all possible serve types This shows all possible serve types and returns them as a list. This takes no parameters and returns - types: list of serve types, eg "nfs", "sftp", etc The serve types are strings like "serve", "serve2", "cserve" and can be passed to serve/start as the serveType parameter. Eg rclone rc serve/types Returns { "types": [ "http", "sftp", "nfs" ] } Authentication is required for this call. sync/bisync: Perform bidirectional synchronization between two paths. This takes the following parameters - path1 - a remote directory string e.g. drive:path1 - path2 - a remote directory string e.g. drive:path2 - dryRun - dry-run mode - resync - performs the resync run - checkAccess - abort if RCLONE_TEST files are not found on both filesystems - checkFilename - file name for checkAccess (default: RCLONE_TEST) - maxDelete - abort sync if percentage of deleted files is above this threshold (default: 50) - force - Bypass maxDelete safety check and run the sync - checkSync - true by default, false disables comparison of final listings, only will skip sync, only compare listings from the last run - createEmptySrcDirs - Sync creation and deletion of empty directories. (Not compatible with --remove-empty-dirs) - removeEmptyDirs - remove empty directories at the final cleanup step - filtersFile - read filtering patterns from a file - ignoreListingChecksum - Do not use checksums for listings - resilient - Allow future runs to retry after certain less-serious errors, instead of requiring resync. - workdir - server directory for history files (default: ~/.cache/rclone/bisync) - backupdir1 - --backup-dir for Path1. Must be a non-overlapping path on the same remote. - backupdir2 - --backup-dir for Path2. Must be a non-overlapping path on the same remote. - noCleanup - retain working files See bisync command help and full bisync description for more information. Authentication is required for this call. sync/copy: copy a directory from source remote to destination remote This takes the following parameters: - srcFs - a remote name string e.g. "drive:src" for the source - dstFs - a remote name string e.g. "drive:dst" for the destination - createEmptySrcDirs - create empty src directories on destination if set See the copy command for more information on the above. Authentication is required for this call. sync/move: move a directory from source remote to destination remote This takes the following parameters: - srcFs - a remote name string e.g. "drive:src" for the source - dstFs - a remote name string e.g. "drive:dst" for the destination - createEmptySrcDirs - create empty src directories on destination if set - deleteEmptySrcDirs - delete empty src directories if set See the move command for more information on the above. Authentication is required for this call. sync/sync: sync a directory from source remote to destination remote This takes the following parameters: - srcFs - a remote name string e.g. "drive:src" for the source - dstFs - a remote name string e.g. "drive:dst" for the destination - createEmptySrcDirs - create empty src directories on destination if set See the sync command for more information on the above. Authentication is required for this call. vfs/forget: Forget files or directories in the directory cache. This forgets the paths in the directory cache causing them to be re-read from the remote when needed. If no paths are passed in then it will forget all the paths in the directory cache. rclone rc vfs/forget Otherwise pass files or dirs in as file=path or dir=path. Any parameter key starting with file will forget that file and any starting with dir will forget that dir, e.g. rclone rc vfs/forget file=hello file2=goodbye dir=home/junk This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied. vfs/list: List active VFSes. This lists the active VFSes. It returns a list under the key "vfses" where the values are the VFS names that could be passed to the other VFS commands in the "fs" parameter. vfs/poll-interval: Get the status or update the value of the poll-interval option. Without any parameter given this returns the current status of the poll-interval setting. When the interval=duration parameter is set, the poll-interval value is updated and the polling function is notified. Setting interval=0 disables poll-interval. rclone rc vfs/poll-interval interval=5m The timeout=duration parameter can be used to specify a time to wait for the current poll function to apply the new value. If timeout is less or equal 0, which is the default, wait indefinitely. The new poll-interval value will only be active when the timeout is not reached. If poll-interval is updated or disabled temporarily, some changes might not get picked up by the polling function, depending on the used remote. This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied. vfs/queue: Queue info for a VFS. This returns info about the upload queue for the selected VFS. This is only useful if --vfs-cache-mode > off. If you call it when the --vfs-cache-mode is off, it will return an empty result. { "queued": // an array of files queued for upload [ { "name": "file", // string: name (full path) of the file, "id": 123, // integer: id of this item in the queue, "size": 79, // integer: size of the file in bytes "expiry": 1.5 // float: time until file is eligible for transfer, lowest goes first "tries": 1, // integer: number of times we have tried to upload "delay": 5.0, // float: seconds between upload attempts "uploading": false, // boolean: true if item is being uploaded }, ], } The expiry time is the time until the file is eligible for being uploaded in floating point seconds. This may go negative. As rclone only transfers --transfers files at once, only the lowest --transfers expiry times will have uploading as true. So there may be files with negative expiry times for which uploading is false. This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied. vfs/queue-set-expiry: Set the expiry time for an item queued for upload. Use this to adjust the expiry time for an item in the upload queue. You will need to read the id of the item using vfs/queue before using this call. You can then set expiry to a floating point number of seconds from now when the item is eligible for upload. If you want the item to be uploaded as soon as possible then set it to a large negative number (eg -1000000000). If you want the upload of the item to be delayed for a long time then set it to a large positive number. Setting the expiry of an item which has already has started uploading will have no effect - the item will carry on being uploaded. This will return an error if called with --vfs-cache-mode off or if the id passed is not found. This takes the following parameters - fs - select the VFS in use (optional) - id - a numeric ID as returned from vfs/queue - expiry - a new expiry time as floating point seconds - relative - if set, expiry is to be treated as relative to the current expiry (optional, boolean) This returns an empty result on success, or an error. This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied. vfs/refresh: Refresh the directory cache. This reads the directories for the specified paths and freshens the directory cache. If no paths are passed in then it will refresh the root directory. rclone rc vfs/refresh Otherwise pass directories in as dir=path. Any parameter key starting with dir will refresh that directory, e.g. rclone rc vfs/refresh dir=home/junk dir2=data/misc If the parameter recursive=true is given the whole directory tree will get refreshed. This refresh will use --fast-list if enabled. This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied. vfs/stats: Stats for a VFS. This returns stats for the selected VFS. { // Status of the disk cache - only present if --vfs-cache-mode > off "diskCache": { "bytesUsed": 0, "erroredFiles": 0, "files": 0, "hashType": 1, "outOfSpace": false, "path": "/home/user/.cache/rclone/vfs/local/mnt/a", "pathMeta": "/home/user/.cache/rclone/vfsMeta/local/mnt/a", "uploadsInProgress": 0, "uploadsQueued": 0 }, "fs": "/mnt/a", "inUse": 1, // Status of the in memory metadata cache "metadataCache": { "dirs": 1, "files": 0 }, // Options as returned by options/get "opt": { "CacheMaxAge": 3600000000000, // ... "WriteWait": 1000000000 } } This command takes an "fs" parameter. If this parameter is not supplied and if there is only one VFS in use then that VFS will be used. If there is more than one VFS in use then the "fs" parameter must be supplied. Accessing the remote control via HTTP Rclone implements a simple HTTP based protocol. Each endpoint takes an JSON object and returns a JSON object or an error. The JSON objects are essentially a map of string names to values. All calls must made using POST. The input objects can be supplied using URL parameters, POST parameters or by supplying "Content-Type: application/json" and a JSON blob in the body. There are examples of these below using curl. The response will be a JSON blob in the body of the response. This is formatted to be reasonably human-readable. Error returns If an error occurs then there will be an HTTP error status (e.g. 500) and the body of the response will contain a JSON encoded error object, e.g. { "error": "Expecting string value for key \"remote\" (was float64)", "input": { "fs": "/tmp", "remote": 3 }, "status": 400, "path": "operations/rmdir" } The keys in the error response are: - error - error string - input - the input parameters to the call - status - the HTTP status code - path - the path of the call CORS The sever implements basic CORS support and allows all origins for that. The response to a preflight OPTIONS request will echo the requested "Access-Control-Request-Headers" back. Using POST with URL parameters only curl -X POST 'http://localhost:5572/rc/noop?potato=1&sausage=2' Response { "potato": "1", "sausage": "2" } Here is what an error response looks like: curl -X POST 'http://localhost:5572/rc/error?potato=1&sausage=2' { "error": "arbitrary error on input map[potato:1 sausage:2]", "input": { "potato": "1", "sausage": "2" } } Note that curl doesn't return errors to the shell unless you use the -f option $ curl -f -X POST 'http://localhost:5572/rc/error?potato=1&sausage=2' curl: (22) The requested URL returned error: 400 Bad Request $ echo $? 22 Using POST with a form curl --data "potato=1" --data "sausage=2" http://localhost:5572/rc/noop Response { "potato": "1", "sausage": "2" } Note that you can combine these with URL parameters too with the POST parameters taking precedence. curl --data "potato=1" --data "sausage=2" "http://localhost:5572/rc/noop?rutabaga=3&sausage=4" Response { "potato": "1", "rutabaga": "3", "sausage": "4" } Using POST with a JSON blob curl -H "Content-Type: application/json" -X POST -d '{"potato":2,"sausage":1}' http://localhost:5572/rc/noop response { "password": "xyz", "username": "xyz" } This can be combined with URL parameters too if required. The JSON blob takes precedence. curl -H "Content-Type: application/json" -X POST -d '{"potato":2,"sausage":1}' 'http://localhost:5572/rc/noop?rutabaga=3&potato=4' { "potato": 2, "rutabaga": "3", "sausage": 1 } Debugging rclone with pprof If you use the --rc flag this will also enable the use of the go profiling tools on the same port. To use these, first install go. Debugging memory use To profile rclone's memory use you can run: go tool pprof -web http://localhost:5572/debug/pprof/heap This should open a page in your browser showing what is using what memory. You can also use the -text flag to produce a textual summary $ go tool pprof -text http://localhost:5572/debug/pprof/heap Showing nodes accounting for 1537.03kB, 100% of 1537.03kB total flat flat% sum% cum cum% 1024.03kB 66.62% 66.62% 1024.03kB 66.62% github.com/rclone/rclone/vendor/golang.org/x/net/http2/hpack.addDecoderNode 513kB 33.38% 100% 513kB 33.38% net/http.newBufioWriterSize 0 0% 100% 1024.03kB 66.62% github.com/rclone/rclone/cmd/all.init 0 0% 100% 1024.03kB 66.62% github.com/rclone/rclone/cmd/serve.init 0 0% 100% 1024.03kB 66.62% github.com/rclone/rclone/cmd/serve/restic.init 0 0% 100% 1024.03kB 66.62% github.com/rclone/rclone/vendor/golang.org/x/net/http2.init 0 0% 100% 1024.03kB 66.62% github.com/rclone/rclone/vendor/golang.org/x/net/http2/hpack.init 0 0% 100% 1024.03kB 66.62% github.com/rclone/rclone/vendor/golang.org/x/net/http2/hpack.init.0 0 0% 100% 1024.03kB 66.62% main.init 0 0% 100% 513kB 33.38% net/http.(*conn).readRequest 0 0% 100% 513kB 33.38% net/http.(*conn).serve 0 0% 100% 1024.03kB 66.62% runtime.main Debugging go routine leaks Memory leaks are most often caused by go routine leaks keeping memory alive which should have been garbage collected. See all active go routines using curl http://localhost:5572/debug/pprof/goroutine?debug=1 Or go to http://localhost:5572/debug/pprof/goroutine?debug=1 in your browser. Other profiles to look at You can see a summary of profiles available at http://localhost:5572/debug/pprof/ Here is how to use some of them: - Memory: go tool pprof http://localhost:5572/debug/pprof/heap - Go routines: curl http://localhost:5572/debug/pprof/goroutine?debug=1 - 30-second CPU profile: go tool pprof http://localhost:5572/debug/pprof/profile - 5-second execution trace: wget http://localhost:5572/debug/pprof/trace?seconds=5 - Goroutine blocking profile - Enable first with: rclone rc debug/set-block-profile-rate rate=1 (docs) - go tool pprof http://localhost:5572/debug/pprof/block - Contended mutexes: - Enable first with: rclone rc debug/set-mutex-profile-fraction rate=1 (docs) - go tool pprof http://localhost:5572/debug/pprof/mutex See the net/http/pprof docs for more info on how to use the profiling and for a general overview see the Go team's blog post on profiling go programs. The profiling hook is zero overhead unless it is used. Overview of cloud storage systems Each cloud storage system is slightly different. Rclone attempts to provide a unified interface to them, but some underlying differences show through. Features Here is an overview of the major features of each cloud storage system. -------------------------------------------------------------------------------------- Name Hash ModTime Case Duplicate MIME Metadata Insensitive Files Type ----------------- -------------- --------- ------------- ----------- ------ ---------- 1Fichier Whirlpool - No Yes R - Akamai Netstorage MD5, SHA256 R/W No No R - Amazon S3 (or S3 MD5 R/W No No R/W RWU compatible) Backblaze B2 SHA1 R/W No No R/W - Box SHA1 R/W Yes No - - Citrix ShareFile MD5 R/W Yes No - - Cloudinary MD5 R No Yes - - Dropbox DBHASH ¹ R Yes No - - Enterprise File - R/W Yes No R/W - Fabric FileLu Cloud MD5 R/W No Yes R - Storage Files.com MD5, CRC32 DR/W Yes No R - FTP - R/W ¹⁰ No No - - Gofile MD5 DR/W No Yes R - Google Cloud MD5 R/W No No R/W - Storage Google Drive MD5, SHA1, DR/W No Yes R/W DRWU SHA256 Google Photos - - No Yes R - HDFS - R/W No No - - HiDrive HiDrive ¹² R/W No No - - HTTP - R No No R - iCloud Drive - R No No - - Internet Archive MD5, SHA1, R/W ¹¹ No No - RWU CRC32 Jottacloud MD5 R/W Yes No R RW Koofr MD5 - Yes No - - Linkbox - R No No - - Mail.ru Cloud Mailru ⁶ R/W Yes No - - Mega - - No Yes - - Memory MD5 R/W No No - - Microsoft Azure MD5 R/W No No R/W - Blob Storage Microsoft Azure MD5 R/W Yes No R/W - Files Storage Microsoft QuickXorHash ⁵ DR/W Yes No R DRW OneDrive OpenDrive MD5 R/W Yes Partial ⁸ - - OpenStack Swift MD5 R/W No No R/W - Oracle Object MD5 R/W No No R/W RU Storage pCloud MD5, SHA1 ⁷ R/W No No W - PikPak MD5 R No No R - Pixeldrain SHA256 R/W No No R RW premiumize.me - - Yes No R - put.io CRC-32 R/W No Yes R - Proton Drive SHA1 R/W No No R - QingStor MD5 - ⁹ No No R/W - Quatrix by - R/W No No - - Maytech Seafile - - No No - - SFTP MD5, SHA1 ² DR/W Depends No - - Sia - - No No - - SMB - R/W Yes No - - SugarSync - - No No - - Storj - R No No - - Uloz.to MD5, SHA256 ¹³ - No Yes - - Uptobox - - No Yes - - WebDAV MD5, SHA1 ³ R ⁴ Depends No - - Yandex Disk MD5 R/W No No R - Zoho WorkDrive - - No No - - The local All DR/W Depends No - DRWU filesystem -------------------------------------------------------------------------------------- ¹ Dropbox supports its own custom hash. This is an SHA256 sum of all the 4 MiB block SHA256s. ² SFTP supports checksums if the same login has shell access and md5sum or sha1sum as well as echo are in the remote's PATH. ³ WebDAV supports hashes when used with Fastmail Files, Owncloud and Nextcloud only. ⁴ WebDAV supports modtimes when used with Fastmail Files, Owncloud and Nextcloud only. ⁵ QuickXorHash is Microsoft's own hash. ⁶ Mail.ru uses its own modified SHA1 hash ⁷ pCloud only supports SHA1 (not MD5) in its EU region ⁸ Opendrive does not support creation of duplicate files using their web client interface or other stock clients, but the underlying storage platform has been determined to allow duplicate files, and it is possible to create them with rclone. It may be that this is a mistake or an unsupported feature. ⁹ QingStor does not support SetModTime for objects bigger than 5 GiB. ¹⁰ FTP supports modtimes for the major FTP servers, and also others if they advertised required protocol extensions. See this for more details. ¹¹ Internet Archive requires option wait_archive to be set to a non-zero value for full modtime support. ¹² HiDrive supports its own custom hash. It combines SHA1 sums for each 4 KiB block hierarchically to a single top-level sum. ¹³ Uloz.to provides server-calculated MD5 hash upon file upload. MD5 and SHA256 hashes are client-calculated and stored as metadata fields. Hash The cloud storage system supports various hash types of the objects. The hashes are used when transferring data as an integrity check and can be specifically used with the --checksum flag in syncs and in the check command. To use the verify checksums when transferring between cloud storage systems they must support a common hash type. ModTime Almost all cloud storage systems store some sort of timestamp on objects, but several of them not something that is appropriate to use for syncing. E.g. some backends will only write a timestamp that represents the time of the upload. To be relevant for syncing it should be able to store the modification time of the source object. If this is not the case, rclone will only check the file size by default, though can be configured to check the file hash (with the --checksum flag). Ideally it should also be possible to change the timestamp of an existing file without having to re-upload it. ----------------------------------------------------------------------- Key Explanation ------------------- --------------------------------------------------- - ModTimes not supported - times likely the upload time R ModTimes supported on files but can't be changed without re-upload R/W Read and Write ModTimes fully supported on files DR ModTimes supported on files and directories but can't be changed without re-upload DR/W Read and Write ModTimes fully supported on files and directories ----------------------------------------------------------------------- Storage systems with a - in the ModTime column, means the modification read on objects is not the modification time of the file when uploaded. It is most likely the time the file was uploaded, or possibly something else (like the time the picture was taken in Google Photos). Storage systems with a R (for read-only) in the ModTime column, means the it keeps modification times on objects, and updates them when uploading objects, but it does not support changing only the modification time (SetModTime operation) without re-uploading, possibly not even without deleting existing first. Some operations in rclone, such as copy and sync commands, will automatically check for SetModTime support and re-upload if necessary to keep the modification times in sync. Other commands will not work without SetModTime support, e.g. touch command on an existing file will fail, and changes to modification time only on a files in a mount will be silently ignored. Storage systems with R/W (for read/write) in the ModTime column, means they do also support modtime-only operations. Storage systems with D in the ModTime column means that the following symbols apply to directories as well as files. Case Insensitive If a cloud storage systems is case sensitive then it is possible to have two files which differ only in case, e.g. file.txt and FILE.txt. If a cloud storage system is case insensitive then that isn't possible. This can cause problems when syncing between a case insensitive system and a case sensitive system. The symptom of this is that no matter how many times you run the sync it never completes fully. The local filesystem and SFTP may or may not be case sensitive depending on OS. - Windows - usually case insensitive, though case is preserved - OSX - usually case insensitive, though it is possible to format case sensitive - Linux - usually case sensitive, but there are case insensitive file systems (e.g. FAT formatted USB keys) Most of the time this doesn't cause any problems as people tend to avoid files whose name differs only by case even on case sensitive systems. Duplicate files If a cloud storage system allows duplicate files then it can have two objects with the same name. This confuses rclone greatly when syncing - use the rclone dedupe command to rename or remove duplicates. Restricted filenames Some cloud storage systems might have restrictions on the characters that are usable in file or directory names. When rclone detects such a name during a file upload, it will transparently replace the restricted characters with similar looking Unicode characters. To handle the different sets of restricted characters for different backends, rclone uses something it calls encoding. This process is designed to avoid ambiguous file names as much as possible and allow to move files between many cloud storage systems transparently. The name shown by rclone to the user or during log output will only contain a minimal set of replaced characters to ensure correct formatting and not necessarily the actual name used on the cloud storage. This transformation is reversed when downloading a file or parsing rclone arguments. For example, when uploading a file named my file?.txt to Onedrive, it will be displayed as my file?.txt on the console, but stored as my file？.txt to Onedrive (the ? gets replaced by the similar looking ？ character, the so-called "fullwidth question mark"). The reverse transformation allows to read a file unusual/name.txt from Google Drive, by passing the name unusual／name.txt on the command line (the / needs to be replaced by the similar looking ／ character). Caveats The filename encoding system works well in most cases, at least where file names are written in English or similar languages. You might not even notice it: It just works. In some cases it may lead to issues, though. E.g. when file names are written in Chinese, or Japanese, where it is always the Unicode fullwidth variants of the punctuation marks that are used. On Windows, the characters :, * and ? are examples of restricted characters. If these are used in filenames on a remote that supports it, Rclone will transparently convert them to their fullwidth Unicode variants ＊, ？ and ： when downloading to Windows, and back again when uploading. This way files with names that are not allowed on Windows can still be stored. However, if you have files on your Windows system originally with these same Unicode characters in their names, they will be included in the same conversion process. E.g. if you create a file in your Windows filesystem with name Test：1.jpg, where ： is the Unicode fullwidth colon symbol, and use rclone to upload it to Google Drive, which supports regular : (halfwidth question mark), rclone will replace the fullwidth : with the halfwidth : and store the file as Test:1.jpg in Google Drive. Since both Windows and Google Drive allows the name Test：1.jpg, it would probably be better if rclone just kept the name as is in this case. With the opposite situation; if you have a file named Test:1.jpg, in your Google Drive, e.g. uploaded from a Linux system where : is valid in file names. Then later use rclone to copy this file to your Windows computer you will notice that on your local disk it gets renamed to Test：1.jpg. The original filename is not legal on Windows, due to the :, and rclone therefore renames it to make the copy possible. That is all good. However, this can also lead to an issue: If you already had a different file named Test：1.jpg on Windows, and then use rclone to copy either way. Rclone will then treat the file originally named Test:1.jpg on Google Drive and the file originally named Test：1.jpg on Windows as the same file, and replace the contents from one with the other. Its virtually impossible to handle all cases like these correctly in all situations, but by customizing the encoding option, changing the set of characters that rclone should convert, you should be able to create a configuration that works well for your specific situation. See also the example below. (Windows was used as an example of a file system with many restricted characters, and Google drive a storage system with few.) Default restricted characters The table below shows the characters that are replaced by default. When a replacement character is found in a filename, this character will be escaped with the ‛ character to avoid ambiguous file names. (e.g. a file named ␀.txt would shown as ‛␀.txt) Each cloud storage backend can use a different set of characters, which will be specified in the documentation for each backend. Character Value Replacement ----------- ------- ------------- NUL 0x00 ␀ SOH 0x01 ␁ STX 0x02 ␂ ETX 0x03 ␃ EOT 0x04 ␄ ENQ 0x05 ␅ ACK 0x06 ␆ BEL 0x07 ␇ BS 0x08 ␈ HT 0x09 ␉ LF 0x0A ␊ VT 0x0B ␋ FF 0x0C ␌ CR 0x0D ␍ SO 0x0E ␎ SI 0x0F ␏ DLE 0x10 ␐ DC1 0x11 ␑ DC2 0x12 ␒ DC3 0x13 ␓ DC4 0x14 ␔ NAK 0x15 ␕ SYN 0x16 ␖ ETB 0x17 ␗ CAN 0x18 ␘ EM 0x19 ␙ SUB 0x1A ␚ ESC 0x1B ␛ FS 0x1C ␜ GS 0x1D ␝ RS 0x1E ␞ US 0x1F ␟ / 0x2F ／ DEL 0x7F ␡ The default encoding will also encode these file names as they are problematic with many cloud storage systems. File name Replacement ----------- ------------- . ． .. ．． Invalid UTF-8 bytes Some backends only support a sequence of well formed UTF-8 bytes as file or directory names. In this case all invalid UTF-8 bytes will be replaced with a quoted representation of the byte value to allow uploading a file to such a backend. For example, the invalid byte 0xFE will be encoded as ‛FE. A common source of invalid UTF-8 bytes are local filesystems, that store names in a different encoding than UTF-8 or UTF-16, like latin1. See the local filenames section for details. Encoding option Most backends have an encoding option, specified as a flag --backend-encoding where backend is the name of the backend, or as a config parameter encoding (you'll need to select the Advanced config in rclone config to see it). This will have default value which encodes and decodes characters in such a way as to preserve the maximum number of characters (see above). However this can be incorrect in some scenarios, for example if you have a Windows file system with Unicode fullwidth characters ＊, ？ or ：, that you want to remain as those characters on the remote rather than being translated to regular (halfwidth) *, ? and :. The --backend-encoding flags allow you to change that. You can disable the encoding completely with --backend-encoding Raw or set encoding = Raw in the config file. Encoding takes a comma separated list of encodings. You can see the list of all possible values by passing an invalid value to this flag, e.g. --local-encoding "help". The command rclone help flags encoding will show you the defaults for the backends. ---------------------------------------------------------------------------------- Encoding Characters Encoded as ---------------------- ------------------------ ---------------------------------- Asterisk * ＊ BackQuote ` ｀ BackSlash \ ＼ Colon : ： CrLf CR 0x0D, LF 0x0A ␍, ␊ Ctl All control characters ␀␁␂␃␄␅␆␇␈␉␊␋␌␍␎␏␐␑␒␓␔␕␖␗␘␙␚␛␜␝␞␟ 0x00-0x1F Del DEL 0x7F ␡ Dollar $ ＄ Dot . or .. as entire string ．, ．． DoubleQuote " ＂ Exclamation ! ！ Hash # ＃ InvalidUtf8 An invalid UTF-8 � character (e.g. latin1) LeftCrLfHtVt CR 0x0D, LF 0x0A, HT ␍, ␊, ␉, ␋ 0x09, VT 0x0B on the left of a string LeftPeriod . on the left of a . string LeftSpace SPACE on the left of a ␠ string LeftTilde ~ on the left of a ～ string LtGt <, > ＜, ＞ None ¹ NUL 0x00 ␀ Percent % ％ Pipe | ｜ Question ? ？ RightCrLfHtVt CR 0x0D, LF 0x0A, HT ␍, ␊, ␉, ␋ 0x09, VT 0x0B on the right of a string RightPeriod . on the right of a . string RightSpace SPACE on the right of a ␠ string Semicolon ; ； SingleQuote ' ＇ Slash / ／ SquareBracket [, ] ［, ］ ---------------------------------------------------------------------------------- ¹ Encoding from NUL 0x00 to ␀ is always implicit except when using Raw. It was previously incorrectly documented as disabling encoding, and to maintain backward compatibility, its behavior has not been changed. Encoding example: FTP To take a specific example, the FTP backend's default encoding is --ftp-encoding "Slash,Del,Ctl,RightSpace,Dot" However, let's say the FTP server is running on Windows and can't have any of the invalid Windows characters in file names. You are backing up Linux servers to this FTP server which do have those characters in file names. So you would add the Windows set which are Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot to the existing ones, giving: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot,Del,RightSpace This can be specified using the --ftp-encoding flag or using an encoding parameter in the config file. Encoding example: Windows As a nother example, take a Windows system where there is a file with name Test：1.jpg, where ： is the Unicode fullwidth colon symbol. When using rclone to copy this to a remote which supports :, the regular (halfwidth) colon (such as Google Drive), you will notice that the file gets renamed to Test:1.jpg. To avoid this you can change the set of characters rclone should convert for the local filesystem, using command-line argument --local-encoding. Rclone's default behavior on Windows corresponds to --local-encoding "Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot" If you want to use fullwidth characters ：, ＊ and ？ in your filenames without rclone changing them when uploading to a remote, then set the same as the default value but without Colon,Question,Asterisk: --local-encoding "Slash,LtGt,DoubleQuote,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot" Alternatively, you can disable the conversion of any characters with --local-encoding Raw. Instead of using command-line argument --local-encoding, you may also set it as environment variable RCLONE_LOCAL_ENCODING, or configure a remote of type local in your config, and set the encoding option there. The risk by doing this is that if you have a filename with the regular (halfwidth) :, * and ? in your cloud storage, and you try to download it to your Windows filesystem, this will fail. These characters are not valid in filenames on Windows, and you have told rclone not to work around this by converting them to valid fullwidth variants. MIME Type MIME types (also known as media types) classify types of documents using a simple text classification, e.g. text/html or application/pdf. Some cloud storage systems support reading (R) the MIME type of objects and some support writing (W) the MIME type of objects. The MIME type can be important if you are serving files directly to HTTP from the storage system. If you are copying from a remote which supports reading (R) to a remote which supports writing (W) then rclone will preserve the MIME types. Otherwise they will be guessed from the extension, or the remote itself may assign the MIME type. Metadata Backends may or may support reading or writing metadata. They may support reading and writing system metadata (metadata intrinsic to that backend) and/or user metadata (general purpose metadata). The levels of metadata support are ----------------------------------------------------------------------- Key Explanation ------------------- --------------------------------------------------- R Read only System Metadata on files only RW Read and write System Metadata on files only RWU Read and write System Metadata and read and write User Metadata on files only DR Read only System Metadata on files and directories DRW Read and write System Metadata on files and directories DRWU Read and write System Metadata and read and write User Metadata on files and directories ----------------------------------------------------------------------- See the metadata docs for more info. Optional Features All rclone remotes support a base command set. Other features depend upon backend-specific capabilities. ------------------------------------------------------------------------------------------------------------------------------------- Name Purge Copy Move DirMove CleanUp ListR StreamUpload MultithreadUpload LinkSharing About EmptyDir --------------- ------- ------ ------ --------- --------- ------- -------------- ------------------- ------------- ------- ---------- 1Fichier No Yes Yes No No No No No Yes No Yes Akamai Yes No No No No Yes Yes No No No Yes Netstorage Amazon S3 (or No Yes No No Yes Yes Yes Yes Yes No No S3 compatible) Backblaze B2 No Yes No No Yes Yes Yes Yes Yes No No Box Yes Yes Yes Yes Yes No Yes No Yes Yes Yes Citrix Yes Yes Yes Yes No No No No No No Yes ShareFile Dropbox Yes Yes Yes Yes No No Yes No Yes Yes Yes Cloudinary No No No No No No Yes No No No No Enterprise File Yes Yes Yes Yes Yes No No No No No Yes Fabric Files.com Yes Yes Yes Yes No No Yes No Yes No Yes FTP No No Yes Yes No No Yes No No No Yes Gofile Yes Yes Yes Yes No No Yes No Yes Yes Yes Google Cloud Yes Yes No No No No Yes No No No No Storage Google Drive Yes Yes Yes Yes Yes Yes Yes No Yes Yes Yes Google Photos No No No No No No No No No No No HDFS Yes No Yes Yes No No Yes No No Yes Yes HiDrive Yes Yes Yes Yes No No Yes No No No Yes HTTP No No No No No No No No No No Yes iCloud Drive Yes Yes Yes Yes No No No No No No Yes ImageKit Yes No Yes No No No No No No No Yes Internet No Yes No No Yes Yes No No Yes Yes No Archive Jottacloud Yes Yes Yes Yes Yes Yes No No Yes Yes Yes Koofr Yes Yes Yes Yes No No Yes No Yes Yes Yes Mail.ru Cloud Yes Yes Yes Yes Yes No No No Yes Yes Yes Mega Yes No Yes Yes Yes No No No Yes Yes Yes Memory No Yes No No No Yes Yes No No No No Microsoft Azure Yes Yes No No No Yes Yes Yes No No No Blob Storage Microsoft Azure No Yes Yes Yes No No Yes Yes No Yes Yes Files Storage Microsoft Yes Yes Yes Yes Yes Yes ⁵ No No Yes Yes Yes OneDrive OpenDrive Yes Yes Yes Yes No No No No No Yes Yes OpenStack Swift Yes ¹ Yes No No No Yes Yes No No Yes No Oracle Object No Yes No No Yes Yes Yes Yes No No No Storage pCloud Yes Yes Yes Yes Yes No No No Yes Yes Yes PikPak Yes Yes Yes Yes Yes No No No Yes Yes Yes Pixeldrain Yes No Yes Yes No No Yes No Yes Yes Yes premiumize.me Yes No Yes Yes No No No No Yes Yes Yes put.io Yes No Yes Yes Yes No Yes No No Yes Yes Proton Drive Yes No Yes Yes Yes No No No No Yes Yes QingStor No Yes No No Yes Yes No No No No No Quatrix by Yes Yes Yes Yes No No No No No Yes Yes Maytech Seafile Yes Yes Yes Yes Yes Yes Yes No Yes Yes Yes SFTP No Yes ⁴ Yes Yes No No Yes No No Yes Yes Sia No No No No No No Yes No No No Yes SMB No No Yes Yes No No Yes Yes No No Yes SugarSync Yes Yes Yes Yes No No Yes No Yes No Yes Storj Yes ² Yes Yes No No Yes Yes No Yes No No Uloz.to No No Yes Yes No No No No No No Yes Uptobox No Yes Yes Yes No No No No No No No WebDAV Yes Yes Yes Yes No No Yes ³ No No Yes Yes Yandex Disk Yes Yes Yes Yes Yes No Yes No Yes Yes Yes Zoho WorkDrive Yes Yes Yes Yes No No No No No Yes Yes The local No No Yes Yes No No Yes Yes No Yes Yes filesystem ------------------------------------------------------------------------------------------------------------------------------------- ¹ Note Swift implements this in order to delete directory markers but it doesn't actually have a quicker way of deleting files other than deleting them individually. ² Storj implements this efficiently only for entire buckets. If purging a directory inside a bucket, files are deleted individually. ³ StreamUpload is not supported with Nextcloud ⁴ Use the --sftp-copy-is-hardlink flag to enable. ⁵ Use the --onedrive-delta flag to enable. Purge This deletes a directory quicker than just deleting all the files in the directory. Copy Used when copying an object to and from the same remote. This known as a server-side copy so you can copy a file without downloading it and uploading it again. It is used if you use rclone copy or rclone move if the remote doesn't support Move directly. If the server doesn't support Copy directly then for copy operations the file is downloaded then re-uploaded. Move Used when moving/renaming an object on the same remote. This is known as a server-side move of a file. This is used in rclone move if the server doesn't support DirMove. If the server isn't capable of Move then rclone simulates it with Copy then delete. If the server doesn't support Copy then rclone will download the file and re-upload it. DirMove This is used to implement rclone move to move a directory if possible. If it isn't then it will use Move on each file (which falls back to Copy then download and upload - see Move section). CleanUp This is used for emptying the trash for a remote by rclone cleanup. If the server can't do CleanUp then rclone cleanup will return an error. ‡‡ Note that while Box implements this it has to delete every file individually so it will be slower than emptying the trash via the WebUI ListR The remote supports a recursive list to list all the contents beneath a directory quickly. This enables the --fast-list flag to work. See the rclone docs for more details. StreamUpload Some remotes allow files to be uploaded without knowing the file size in advance. This allows certain operations to work without spooling the file to local disk first, e.g. rclone rcat. MultithreadUpload Some remotes allow transfers to the remote to be sent as chunks in parallel. If this is supported then rclone will use multi-thread copying to transfer files much faster. LinkSharing Sets the necessary permissions on a file or folder and prints a link that allows others to access them, even if they don't have an account on the particular cloud provider. About Rclone about prints quota information for a remote. Typical output includes bytes used, free, quota and in trash. If a remote lacks about capability rclone about remote:returns an error. Backends without about capability cannot determine free space for an rclone mount, or use policy mfs (most free space) as a member of an rclone union remote. See rclone about command EmptyDir The remote supports empty directories. See Limitations for details. Most Object/Bucket-based remotes do not support this. Global Flags This describes the global flags available to every rclone command split into groups. Copy Flags for anything which can copy a file. --check-first Do all the checks before starting transfers -c, --checksum Check for changes with size & checksum (if available, or fallback to size only) --compare-dest stringArray Include additional server-side paths during comparison --copy-dest stringArray Implies --compare-dest but also copies files from paths into destination --cutoff-mode HARD|SOFT|CAUTIOUS Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS (default HARD) --ignore-case-sync Ignore case when synchronizing --ignore-checksum Skip post copy check of checksums --ignore-existing Skip all files that exist on destination --ignore-size Ignore size when skipping use modtime or checksum -I, --ignore-times Don't skip items that match size and time - transfer all unconditionally --immutable Do not modify files, fail if existing files have been modified --inplace Download directly to destination file instead of atomic download to temp/rename -l, --links Translate symlinks to/from regular files with a '.rclonelink' extension --max-backlog int Maximum number of objects in sync or check backlog (default 10000) --max-duration Duration Maximum duration rclone will transfer data for (default 0s) --max-transfer SizeSuffix Maximum size of data to transfer (default off) -M, --metadata If set, preserve metadata when copying objects --modify-window Duration Max time diff to be considered the same (default 1ns) --multi-thread-chunk-size SizeSuffix Chunk size for multi-thread downloads / uploads, if not set by filesystem (default 64Mi) --multi-thread-cutoff SizeSuffix Use multi-thread downloads for files above this size (default 256Mi) --multi-thread-streams int Number of streams to use for multi-thread downloads (default 4) --multi-thread-write-buffer-size SizeSuffix In memory buffer size for writing when in multi-thread mode (default 128Ki) --name-transform stringArray Transform paths during the copy process --no-check-dest Don't check the destination, copy regardless --no-traverse Don't traverse destination file system on copy --no-update-dir-modtime Don't update directory modification times --no-update-modtime Don't update destination modtime if files identical --order-by string Instructions on how to order the transfers, e.g. 'size,descending' --partial-suffix string Add partial-suffix to temporary file name when --inplace is not used (default ".partial") --refresh-times Refresh the modtime of remote files --server-side-across-configs Allow server-side operations (e.g. copy) to work across different configs --size-only Skip based on size only, not modtime or checksum --streaming-upload-cutoff SizeSuffix Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends (default 100Ki) -u, --update Skip files that are newer on the destination Sync Flags used for sync commands. --backup-dir string Make backups into hierarchy based in DIR --delete-after When synchronizing, delete files on destination after transferring (default) --delete-before When synchronizing, delete files on destination before transferring --delete-during When synchronizing, delete files during transfer --fix-case Force rename of case insensitive dest to match source --ignore-errors Delete even if there are I/O errors --list-cutoff int To save memory, sort directory listings on disk above this threshold (default 1000000) --max-delete int When synchronizing, limit the number of deletes (default -1) --max-delete-size SizeSuffix When synchronizing, limit the total size of deletes (default off) --suffix string Suffix to add to changed files --suffix-keep-extension Preserve the extension when using --suffix --track-renames When synchronizing, track file renames and do a server-side move if possible --track-renames-strategy string Strategies to use when synchronizing using track-renames hash|modtime|leaf (default "hash") Important Important flags useful for most commands. -n, --dry-run Do a trial run with no permanent changes -i, --interactive Enable interactive mode -v, --verbose count Print lots more stuff (repeat for more) Check Flags used for check commands. --max-backlog int Maximum number of objects in sync or check backlog (default 10000) Networking Flags for general networking and HTTP stuff. --bind string Local address to bind to for outgoing connections, IPv4, IPv6 or name --bwlimit BwTimetable Bandwidth limit in KiB/s, or use suffix B|K|M|G|T|P or a full timetable --bwlimit-file BwTimetable Bandwidth limit per file in KiB/s, or use suffix B|K|M|G|T|P or a full timetable --ca-cert stringArray CA certificate used to verify servers --client-cert string Client SSL certificate (PEM) for mutual TLS auth --client-key string Client SSL private key (PEM) for mutual TLS auth --client-pass string Password for client SSL private key (PEM) for mutual TLS auth (obscured) (obscured) --contimeout Duration Connect timeout (default 1m0s) --disable-http-keep-alives Disable HTTP keep-alives and use each connection once --disable-http2 Disable HTTP/2 in the global transport --dscp string Set DSCP value to connections, value or name, e.g. CS1, LE, DF, AF21 --expect-continue-timeout Duration Timeout when using expect / 100-continue in HTTP (default 1s) --header stringArray Set HTTP header for all transactions --header-download stringArray Set HTTP header for download transactions --header-upload stringArray Set HTTP header for upload transactions --http-proxy string HTTP proxy URL --max-connections int Maximum number of simultaneous backend API connections, 0 for unlimited --no-check-certificate Do not verify the server SSL certificate (insecure) --no-gzip-encoding Don't set Accept-Encoding: gzip --timeout Duration IO idle timeout (default 5m0s) --tpslimit float Limit HTTP transactions per second to this --tpslimit-burst int Max burst of transactions for --tpslimit (default 1) --use-cookies Enable session cookiejar --user-agent string Set the user-agent to a specified string (default "rclone/v1.71.0") Performance Flags helpful for increasing performance. --buffer-size SizeSuffix In memory buffer size when reading files for each --transfer (default 16Mi) --checkers int Number of checkers to run in parallel (default 8) --transfers int Number of file transfers to run in parallel (default 4) Config Flags for general configuration of rclone. --ask-password Allow prompt for password for encrypted configuration (default true) --auto-confirm If enabled, do not request console confirmation --cache-dir string Directory rclone will use for caching (default "$HOME/.cache/rclone") --color AUTO|NEVER|ALWAYS When to show colors (and other ANSI codes) AUTO|NEVER|ALWAYS (default AUTO) --config string Config file (default "$HOME/.config/rclone/rclone.conf") --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --disable string Disable a comma separated list of features (use --disable help to see a list) -n, --dry-run Do a trial run with no permanent changes --error-on-no-transfer Sets exit code 9 if no files are transferred, useful in scripts --fs-cache-expire-duration Duration Cache remotes for this long (0 to disable caching) (default 5m0s) --fs-cache-expire-interval Duration Interval to check for expired remotes (default 1m0s) --human-readable Print numbers in a human-readable format, sizes with suffix Ki|Mi|Gi|Ti|Pi -i, --interactive Enable interactive mode --kv-lock-time Duration Maximum time to keep key-value database locked by process (default 1s) --low-level-retries int Number of low level retries to do (default 10) --max-buffer-memory SizeSuffix If set, don't allocate more than this amount of memory as buffers (default off) --no-console Hide console window (supported on Windows only) --no-unicode-normalization Don't normalize unicode characters in filenames --password-command SpaceSepList Command for supplying password for encrypted configuration --retries int Retry operations this many times if they fail (default 3) --retries-sleep Duration Interval between retrying operations if they fail, e.g. 500ms, 60s, 5m (0 to disable) (default 0s) --temp-dir string Directory rclone will use for temporary files (default "/tmp") --use-mmap Use mmap allocator (see docs) --use-server-modtime Use server modified time instead of object metadata Debugging Flags for developers. --cpuprofile string Write cpu profile to file --dump DumpFlags List of items to dump from: headers, bodies, requests, responses, auth, filters, goroutines, openfiles, mapper --dump-bodies Dump HTTP headers and bodies - may contain sensitive info --dump-headers Dump HTTP headers - may contain sensitive info --memprofile string Write memory profile to file Filter Flags for filtering directory listings. --delete-excluded Delete files on dest excluded from sync --exclude stringArray Exclude files matching pattern --exclude-from stringArray Read file exclude patterns from file (use - to read from stdin) --exclude-if-present stringArray Exclude directories if filename is present --files-from stringArray Read list of source-file names from file (use - to read from stdin) --files-from-raw stringArray Read list of source-file names from file without any processing of lines (use - to read from stdin) -f, --filter stringArray Add a file filtering rule --filter-from stringArray Read file filtering patterns from a file (use - to read from stdin) --hash-filter string Partition filenames by hash k/n or randomly @/n --ignore-case Ignore case in filters (case insensitive) --include stringArray Include files matching pattern --include-from stringArray Read file include patterns from file (use - to read from stdin) --max-age Duration Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y (default off) --max-depth int If set limits the recursion depth to this (default -1) --max-size SizeSuffix Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P (default off) --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --min-age Duration Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y (default off) --min-size SizeSuffix Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P (default off) Listing Flags for listing directories. --default-time Time Time to show if modtime is unknown for files and directories (default 2000-01-01T00:00:00Z) --fast-list Use recursive list if available; uses more memory but fewer transactions Logging Flags for logging and statistics. --log-file string Log everything to this file --log-file-compress If set, compress rotated log files using gzip --log-file-max-age Duration Maximum duration to retain old log files (eg "7d") (default 0s) --log-file-max-backups int Maximum number of old log files to retain --log-file-max-size SizeSuffix Maximum size of the log file before it's rotated (eg "10M") (default off) --log-format Bits Comma separated list of log format options (default date,time) --log-level LogLevel Log level DEBUG|INFO|NOTICE|ERROR (default NOTICE) --log-systemd Activate systemd integration for the logger --max-stats-groups int Maximum number of stats groups to keep in memory, on max oldest is discarded (default 1000) -P, --progress Show progress during transfer --progress-terminal-title Show progress on the terminal title (requires -P/--progress) -q, --quiet Print as little stuff as possible --stats Duration Interval between printing stats, e.g. 500ms, 60s, 5m (0 to disable) (default 1m0s) --stats-file-name-length int Max file name length in stats (0 for no limit) (default 45) --stats-log-level LogLevel Log level to show --stats output DEBUG|INFO|NOTICE|ERROR (default INFO) --stats-one-line Make the stats fit on one line --stats-one-line-date Enable --stats-one-line and add current date/time prefix --stats-one-line-date-format string Enable --stats-one-line-date and use custom formatted date: Enclose date string in double quotes ("), see https://golang.org/pkg/time/#Time.Format --stats-unit string Show data rate in stats as either 'bits' or 'bytes' per second (default "bytes") --syslog Use Syslog for logging --syslog-facility string Facility for syslog, e.g. KERN,USER (default "DAEMON") --use-json-log Use json log format -v, --verbose count Print lots more stuff (repeat for more) Metadata Flags to control metadata. -M, --metadata If set, preserve metadata when copying objects --metadata-exclude stringArray Exclude metadatas matching pattern --metadata-exclude-from stringArray Read metadata exclude patterns from file (use - to read from stdin) --metadata-filter stringArray Add a metadata filtering rule --metadata-filter-from stringArray Read metadata filtering patterns from a file (use - to read from stdin) --metadata-include stringArray Include metadatas matching pattern --metadata-include-from stringArray Read metadata include patterns from file (use - to read from stdin) --metadata-mapper SpaceSepList Program to run to transforming metadata before upload --metadata-set stringArray Add metadata key=value when uploading RC Flags to control the Remote Control API. --rc Enable the remote control server --rc-addr stringArray IPaddress:Port or :Port to bind server to (default localhost:5572) --rc-allow-origin string Origin which cross-domain request (CORS) can be executed from --rc-baseurl string Prefix for URLs - leave blank for root --rc-cert string TLS PEM key (concatenation of certificate and CA certificate) --rc-client-ca string Client certificate authority to verify clients with --rc-enable-metrics Enable the Prometheus metrics path at the remote control server --rc-files string Path to local files to serve on the HTTP server --rc-htpasswd string A htpasswd file - if not provided no authentication is done --rc-job-expire-duration Duration Expire finished async jobs older than this value (default 1m0s) --rc-job-expire-interval Duration Interval to check for expired async jobs (default 10s) --rc-key string TLS PEM Private key --rc-max-header-bytes int Maximum size of request header (default 4096) --rc-min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --rc-no-auth Don't require auth for certain methods --rc-pass string Password for authentication --rc-realm string Realm for authentication --rc-salt string Password hashing salt (default "dlPL2MqE") --rc-serve Enable the serving of remote objects --rc-serve-no-modtime Don't read the modification time (can speed things up) --rc-server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --rc-server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --rc-template string User-specified template --rc-user string User name for authentication --rc-user-from-header string User name from a defined HTTP header --rc-web-fetch-url string URL to fetch the releases for webgui (default "https://api.github.com/repos/rclone/rclone-webui-react/releases/latest") --rc-web-gui Launch WebGUI on localhost --rc-web-gui-force-update Force update to latest version of web gui --rc-web-gui-no-open-browser Don't open the browser automatically --rc-web-gui-update Check and update to latest version of web gui Metrics Flags to control the Metrics HTTP endpoint.. --metrics-addr stringArray IPaddress:Port or :Port to bind metrics server to --metrics-allow-origin string Origin which cross-domain request (CORS) can be executed from --metrics-baseurl string Prefix for URLs - leave blank for root --metrics-cert string TLS PEM key (concatenation of certificate and CA certificate) --metrics-client-ca string Client certificate authority to verify clients with --metrics-htpasswd string A htpasswd file - if not provided no authentication is done --metrics-key string TLS PEM Private key --metrics-max-header-bytes int Maximum size of request header (default 4096) --metrics-min-tls-version string Minimum TLS version that is acceptable (default "tls1.0") --metrics-pass string Password for authentication --metrics-realm string Realm for authentication --metrics-salt string Password hashing salt (default "dlPL2MqE") --metrics-server-read-timeout Duration Timeout for server reading data (default 1h0m0s) --metrics-server-write-timeout Duration Timeout for server writing data (default 1h0m0s) --metrics-template string User-specified template --metrics-user string User name for authentication --metrics-user-from-header string User name from a defined HTTP header --rc-enable-metrics Enable the Prometheus metrics path at the remote control server Backend Backend-only flags (these can be set in the config file also). --alias-description string Description of the remote --alias-remote string Remote or path to alias --azureblob-access-tier string Access tier of blob: hot, cool, cold or archive --azureblob-account string Azure Storage Account Name --azureblob-archive-tier-delete Delete archive tier blobs before overwriting --azureblob-chunk-size SizeSuffix Upload chunk size (default 4Mi) --azureblob-client-certificate-password string Password for the certificate file (optional) (obscured) --azureblob-client-certificate-path string Path to a PEM or PKCS12 certificate file including the private key --azureblob-client-id string The ID of the client in use --azureblob-client-secret string One of the service principal's client secrets --azureblob-client-send-certificate-chain Send the certificate chain when using certificate auth --azureblob-copy-concurrency int Concurrency for multipart copy (default 512) --azureblob-copy-cutoff SizeSuffix Cutoff for switching to multipart copy (default 8Mi) --azureblob-delete-snapshots string Set to specify how to deal with snapshots on blob deletion --azureblob-description string Description of the remote --azureblob-directory-markers Upload an empty object with a trailing slash when a new directory is created --azureblob-disable-checksum Don't store MD5 checksum with object metadata --azureblob-disable-instance-discovery Skip requesting Microsoft Entra instance metadata --azureblob-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,RightPeriod,InvalidUtf8) --azureblob-endpoint string Endpoint for the service --azureblob-env-auth Read credentials from runtime (environment variables, CLI or MSI) --azureblob-key string Storage Account Shared Key --azureblob-list-chunk int Size of blob list (default 5000) --azureblob-msi-client-id string Object ID of the user-assigned MSI to use, if any --azureblob-msi-mi-res-id string Azure resource ID of the user-assigned MSI to use, if any --azureblob-msi-object-id string Object ID of the user-assigned MSI to use, if any --azureblob-no-check-container If set, don't attempt to check the container exists or create it --azureblob-no-head-object If set, do not do HEAD before GET when getting objects --azureblob-password string The user's password (obscured) --azureblob-public-access string Public access level of a container: blob or container --azureblob-sas-url string SAS URL for container level access only --azureblob-service-principal-file string Path to file containing credentials for use with a service principal --azureblob-tenant string ID of the service principal's tenant. Also called its directory ID --azureblob-upload-concurrency int Concurrency for multipart uploads (default 16) --azureblob-upload-cutoff string Cutoff for switching to chunked upload (<= 256 MiB) (deprecated) --azureblob-use-az Use Azure CLI tool az for authentication --azureblob-use-copy-blob Whether to use the Copy Blob API when copying to the same storage account (default true) --azureblob-use-emulator Uses local storage emulator if provided as 'true' --azureblob-use-msi Use a managed service identity to authenticate (only works in Azure) --azureblob-username string User name (usually an email address) --azurefiles-account string Azure Storage Account Name --azurefiles-chunk-size SizeSuffix Upload chunk size (default 4Mi) --azurefiles-client-certificate-password string Password for the certificate file (optional) (obscured) --azurefiles-client-certificate-path string Path to a PEM or PKCS12 certificate file including the private key --azurefiles-client-id string The ID of the client in use --azurefiles-client-secret string One of the service principal's client secrets --azurefiles-client-send-certificate-chain Send the certificate chain when using certificate auth --azurefiles-connection-string string Azure Files Connection String --azurefiles-description string Description of the remote --azurefiles-disable-instance-discovery Skip requesting Microsoft Entra instance metadata --azurefiles-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,RightPeriod,InvalidUtf8,Dot) --azurefiles-endpoint string Endpoint for the service --azurefiles-env-auth Read credentials from runtime (environment variables, CLI or MSI) --azurefiles-key string Storage Account Shared Key --azurefiles-max-stream-size SizeSuffix Max size for streamed files (default 10Gi) --azurefiles-msi-client-id string Object ID of the user-assigned MSI to use, if any --azurefiles-msi-mi-res-id string Azure resource ID of the user-assigned MSI to use, if any --azurefiles-msi-object-id string Object ID of the user-assigned MSI to use, if any --azurefiles-password string The user's password (obscured) --azurefiles-sas-url string SAS URL --azurefiles-service-principal-file string Path to file containing credentials for use with a service principal --azurefiles-share-name string Azure Files Share Name --azurefiles-tenant string ID of the service principal's tenant. Also called its directory ID --azurefiles-upload-concurrency int Concurrency for multipart uploads (default 16) --azurefiles-use-az Use Azure CLI tool az for authentication --azurefiles-use-msi Use a managed service identity to authenticate (only works in Azure) --azurefiles-username string User name (usually an email address) --b2-account string Account ID or Application Key ID --b2-chunk-size SizeSuffix Upload chunk size (default 96Mi) --b2-copy-cutoff SizeSuffix Cutoff for switching to multipart copy (default 4Gi) --b2-description string Description of the remote --b2-disable-checksum Disable checksums for large (> upload cutoff) files --b2-download-auth-duration Duration Time before the public link authorization token will expire in s or suffix ms|s|m|h|d (default 1w) --b2-download-url string Custom endpoint for downloads --b2-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --b2-endpoint string Endpoint for the service --b2-hard-delete Permanently delete files on remote removal, otherwise hide files --b2-key string Application Key --b2-lifecycle int Set the number of days deleted files should be kept when creating a bucket --b2-test-mode string A flag string for X-Bz-Test-Mode header for debugging --b2-upload-concurrency int Concurrency for multipart uploads (default 4) --b2-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default 200Mi) --b2-version-at Time Show file versions as they were at the specified time (default off) --b2-versions Include old versions in directory listings --box-access-token string Box App Primary Access Token --box-auth-url string Auth server URL --box-box-config-file string Box App config.json location --box-box-sub-type string (default "user") --box-client-credentials Use client credentials OAuth flow --box-client-id string OAuth Client Id --box-client-secret string OAuth Client Secret --box-commit-retries int Max number of times to try committing a multipart file (default 100) --box-description string Description of the remote --box-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot) --box-impersonate string Impersonate this user ID when using a service account --box-list-chunk int Size of listing chunk 1-1000 (default 1000) --box-owned-by string Only show items owned by the login (email address) passed in --box-root-folder-id string Fill in for rclone to use a non root folder as its starting point --box-token string OAuth Access Token as a JSON blob --box-token-url string Token server url --box-upload-cutoff SizeSuffix Cutoff for switching to multipart upload (>= 50 MiB) (default 50Mi) --cache-chunk-clean-interval Duration How often should the cache perform cleanups of the chunk storage (default 1m0s) --cache-chunk-no-memory Disable the in-memory cache for storing chunks during streaming --cache-chunk-path string Directory to cache chunk files (default "$HOME/.cache/rclone/cache-backend") --cache-chunk-size SizeSuffix The size of a chunk (partial file data) (default 5Mi) --cache-chunk-total-size SizeSuffix The total size that the chunks can take up on the local disk (default 10Gi) --cache-db-path string Directory to store file structure metadata DB (default "$HOME/.cache/rclone/cache-backend") --cache-db-purge Clear all the cached data for this remote on start --cache-db-wait-time Duration How long to wait for the DB to be available - 0 is unlimited (default 1s) --cache-description string Description of the remote --cache-info-age Duration How long to cache file structure information (directory listings, file size, times, etc.) (default 6h0m0s) --cache-plex-insecure string Skip all certificate verification when connecting to the Plex server --cache-plex-password string The password of the Plex user (obscured) --cache-plex-url string The URL of the Plex server --cache-plex-username string The username of the Plex user --cache-read-retries int How many times to retry a read from a cache storage (default 10) --cache-remote string Remote to cache --cache-rps int Limits the number of requests per second to the source FS (-1 to disable) (default -1) --cache-tmp-upload-path string Directory to keep temporary files until they are uploaded --cache-tmp-wait-time Duration How long should files be stored in local cache before being uploaded (default 15s) --cache-workers int How many workers should run in parallel to download chunks (default 4) --cache-writes Cache file data on writes through the FS --chunker-chunk-size SizeSuffix Files larger than chunk size will be split in chunks (default 2Gi) --chunker-description string Description of the remote --chunker-fail-hard Choose how chunker should handle files with missing or invalid chunks --chunker-hash-type string Choose how chunker handles hash sums (default "md5") --chunker-remote string Remote to chunk/unchunk --cloudinary-adjust-media-files-extensions Cloudinary handles media formats as a file attribute and strips it from the name, which is unlike most other file systems (default true) --cloudinary-api-key string Cloudinary API Key --cloudinary-api-secret string Cloudinary API Secret --cloudinary-cloud-name string Cloudinary Environment Name --cloudinary-description string Description of the remote --cloudinary-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Question,Asterisk,Pipe,Hash,Percent,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot) --cloudinary-eventually-consistent-delay Duration Wait N seconds for eventual consistency of the databases that support the backend operation (default 0s) --cloudinary-media-extensions stringArray Cloudinary supported media extensions (default 3ds,3g2,3gp,ai,arw,avi,avif,bmp,bw,cr2,cr3,djvu,dng,eps3,fbx,flif,flv,gif,glb,gltf,hdp,heic,heif,ico,indd,jp2,jpe,jpeg,jpg,jxl,jxr,m2ts,mov,mp4,mpeg,mts,mxf,obj,ogv,pdf,ply,png,psd,svg,tga,tif,tiff,ts,u3ma,usdz,wdp,webm,webp,wmv) --cloudinary-upload-prefix string Specify the API endpoint for environments out of the US --cloudinary-upload-preset string Upload Preset to select asset manipulation on upload --combine-description string Description of the remote --combine-upstreams SpaceSepList Upstreams for combining --compress-description string Description of the remote --compress-level int GZIP compression level (-2 to 9) (default -1) --compress-mode string Compression mode (default "gzip") --compress-ram-cache-limit SizeSuffix Some remotes don't allow the upload of files with unknown size (default 20Mi) --compress-remote string Remote to compress -L, --copy-links Follow symlinks and copy the pointed to item --crypt-description string Description of the remote --crypt-directory-name-encryption Option to either encrypt directory names or leave them intact (default true) --crypt-filename-encoding string How to encode the encrypted filename to text string (default "base32") --crypt-filename-encryption string How to encrypt the filenames (default "standard") --crypt-no-data-encryption Option to either encrypt file data or leave it unencrypted --crypt-pass-bad-blocks If set this will pass bad blocks through as all 0 --crypt-password string Password or pass phrase for encryption (obscured) --crypt-password2 string Password or pass phrase for salt (obscured) --crypt-remote string Remote to encrypt/decrypt --crypt-server-side-across-configs Deprecated: use --server-side-across-configs instead --crypt-show-mapping For all files listed show how the names encrypt --crypt-strict-names If set, this will raise an error when crypt comes across a filename that can't be decrypted --crypt-suffix string If this is set it will override the default suffix of ".bin" (default ".bin") --doi-description string Description of the remote --doi-doi string The DOI or the doi.org URL --doi-doi-resolver-api-url string The URL of the DOI resolver API to use --doi-provider string DOI provider --drive-acknowledge-abuse Set to allow files which return cannotDownloadAbusiveFile to be downloaded --drive-allow-import-name-change Allow the filetype to change when uploading Google docs --drive-auth-owner-only Only consider files owned by the authenticated user --drive-auth-url string Auth server URL --drive-chunk-size SizeSuffix Upload chunk size (default 8Mi) --drive-client-credentials Use client credentials OAuth flow --drive-client-id string Google Application Client Id --drive-client-secret string OAuth Client Secret --drive-copy-shortcut-content Server side copy contents of shortcuts instead of the shortcut --drive-description string Description of the remote --drive-disable-http2 Disable drive using http2 (default true) --drive-encoding Encoding The encoding for the backend (default InvalidUtf8) --drive-env-auth Get IAM credentials from runtime (environment variables or instance meta data if no env vars) --drive-export-formats string Comma separated list of preferred formats for downloading Google docs (default "docx,xlsx,pptx,svg") --drive-fast-list-bug-fix Work around a bug in Google Drive listing (default true) --drive-formats string Deprecated: See export_formats --drive-impersonate string Impersonate this user when using a service account --drive-import-formats string Comma separated list of preferred formats for uploading Google docs --drive-keep-revision-forever Keep new head revision of each file forever --drive-list-chunk int Size of listing chunk 100-1000, 0 to disable (default 1000) --drive-metadata-labels Bits Control whether labels should be read or written in metadata (default off) --drive-metadata-owner Bits Control whether owner should be read or written in metadata (default read) --drive-metadata-permissions Bits Control whether permissions should be read or written in metadata (default off) --drive-pacer-burst int Number of API calls to allow without sleeping (default 100) --drive-pacer-min-sleep Duration Minimum time to sleep between API calls (default 100ms) --drive-resource-key string Resource key for accessing a link-shared file --drive-root-folder-id string ID of the root folder --drive-scope string Comma separated list of scopes that rclone should use when requesting access from drive --drive-server-side-across-configs Deprecated: use --server-side-across-configs instead --drive-service-account-credentials string Service Account Credentials JSON blob --drive-service-account-file string Service Account Credentials JSON file path --drive-shared-with-me Only show files that are shared with me --drive-show-all-gdocs Show all Google Docs including non-exportable ones in listings --drive-size-as-quota Show sizes as storage quota usage, not actual size --drive-skip-checksum-gphotos Skip checksums on Google photos and videos only --drive-skip-dangling-shortcuts If set skip dangling shortcut files --drive-skip-gdocs Skip google documents in all listings --drive-skip-shortcuts If set skip shortcut files --drive-starred-only Only show files that are starred --drive-stop-on-download-limit Make download limit errors be fatal --drive-stop-on-upload-limit Make upload limit errors be fatal --drive-team-drive string ID of the Shared Drive (Team Drive) --drive-token string OAuth Access Token as a JSON blob --drive-token-url string Token server url --drive-trashed-only Only show files that are in the trash --drive-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default 8Mi) --drive-use-created-date Use file created date instead of modified date --drive-use-shared-date Use date file was shared instead of modified date --drive-use-trash Send files to the trash instead of deleting permanently (default true) --drive-v2-download-min-size SizeSuffix If Object's are greater, use drive v2 API to download (default off) --dropbox-auth-url string Auth server URL --dropbox-batch-mode string Upload file batching sync|async|off (default "sync") --dropbox-batch-size int Max number of files in upload batch --dropbox-batch-timeout Duration Max time to allow an idle upload batch before uploading (default 0s) --dropbox-chunk-size SizeSuffix Upload chunk size (< 150Mi) (default 48Mi) --dropbox-client-credentials Use client credentials OAuth flow --dropbox-client-id string OAuth Client Id --dropbox-client-secret string OAuth Client Secret --dropbox-description string Description of the remote --dropbox-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,RightSpace,InvalidUtf8,Dot) --dropbox-export-formats CommaSepList Comma separated list of preferred formats for exporting files (default html,md) --dropbox-impersonate string Impersonate this user when using a business account --dropbox-pacer-min-sleep Duration Minimum time to sleep between API calls (default 10ms) --dropbox-root-namespace string Specify a different Dropbox namespace ID to use as the root for all paths --dropbox-shared-files Instructs rclone to work on individual shared files --dropbox-shared-folders Instructs rclone to work on shared folders --dropbox-show-all-exports Show all exportable files in listings --dropbox-skip-exports Skip exportable files in all listings --dropbox-token string OAuth Access Token as a JSON blob --dropbox-token-url string Token server url --fichier-api-key string Your API Key, get it from https://1fichier.com/console/params.pl --fichier-cdn Set if you wish to use CDN download links --fichier-description string Description of the remote --fichier-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,SingleQuote,BackQuote,Dollar,BackSlash,Del,Ctl,LeftSpace,RightSpace,InvalidUtf8,Dot) --fichier-file-password string If you want to download a shared file that is password protected, add this parameter (obscured) --fichier-folder-password string If you want to list the files in a shared folder that is password protected, add this parameter (obscured) --fichier-shared-folder string If you want to download a shared folder, add this parameter --filefabric-description string Description of the remote --filefabric-encoding Encoding The encoding for the backend (default Slash,Del,Ctl,InvalidUtf8,Dot) --filefabric-permanent-token string Permanent Authentication Token --filefabric-root-folder-id string ID of the root folder --filefabric-token string Session Token --filefabric-token-expiry string Token expiry time --filefabric-url string URL of the Enterprise File Fabric to connect to --filefabric-version string Version read from the file fabric --filelu-description string Description of the remote --filelu-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,SingleQuote,BackQuote,Dollar,Colon,Question,Asterisk,Pipe,Hash,Percent,BackSlash,CrLf,Del,Ctl,LeftSpace,LeftPeriod,LeftTilde,LeftCrLfHtVt,RightSpace,RightPeriod,RightCrLfHtVt,InvalidUtf8,Dot,SquareBracket,Semicolon,Exclamation) --filelu-key string Your FileLu Rclone key from My Account --filescom-api-key string The API key used to authenticate with Files.com --filescom-description string Description of the remote --filescom-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,RightSpace,RightCrLfHtVt,InvalidUtf8,Dot) --filescom-password string The password used to authenticate with Files.com (obscured) --filescom-site string Your site subdomain (e.g. mysite) or custom domain (e.g. myfiles.customdomain.com) --filescom-username string The username used to authenticate with Files.com --ftp-allow-insecure-tls-ciphers Allow insecure TLS ciphers --ftp-ask-password Allow asking for FTP password when needed --ftp-close-timeout Duration Maximum time to wait for a response to close (default 1m0s) --ftp-concurrency int Maximum number of FTP simultaneous connections, 0 for unlimited --ftp-description string Description of the remote --ftp-disable-epsv Disable using EPSV even if server advertises support --ftp-disable-mlsd Disable using MLSD even if server advertises support --ftp-disable-tls13 Disable TLS 1.3 (workaround for FTP servers with buggy TLS) --ftp-disable-utf8 Disable using UTF-8 even if server advertises support --ftp-encoding Encoding The encoding for the backend (default Slash,Del,Ctl,RightSpace,Dot) --ftp-explicit-tls Use Explicit FTPS (FTP over TLS) --ftp-force-list-hidden Use LIST -a to force listing of hidden files and folders. This will disable the use of MLSD --ftp-host string FTP host to connect to --ftp-http-proxy string URL for HTTP CONNECT proxy --ftp-idle-timeout Duration Max time before closing idle connections (default 1m0s) --ftp-no-check-certificate Do not verify the TLS certificate of the server --ftp-no-check-upload Don't check the upload is OK --ftp-pass string FTP password (obscured) --ftp-port int FTP port number (default 21) --ftp-shut-timeout Duration Maximum time to wait for data connection closing status (default 1m0s) --ftp-socks-proxy string Socks 5 proxy host --ftp-tls Use Implicit FTPS (FTP over TLS) --ftp-tls-cache-size int Size of TLS session cache for all control and data connections (default 32) --ftp-user string FTP username (default "$USER") --ftp-writing-mdtm Use MDTM to set modification time (VsFtpd quirk) --gcs-access-token string Short-lived access token --gcs-anonymous Access public buckets and objects without credentials --gcs-auth-url string Auth server URL --gcs-bucket-acl string Access Control List for new buckets --gcs-bucket-policy-only Access checks should use bucket-level IAM policies --gcs-client-credentials Use client credentials OAuth flow --gcs-client-id string OAuth Client Id --gcs-client-secret string OAuth Client Secret --gcs-decompress If set this will decompress gzip encoded objects --gcs-description string Description of the remote --gcs-directory-markers Upload an empty object with a trailing slash when a new directory is created --gcs-encoding Encoding The encoding for the backend (default Slash,CrLf,InvalidUtf8,Dot) --gcs-endpoint string Endpoint for the service --gcs-env-auth Get GCP IAM credentials from runtime (environment variables or instance meta data if no env vars) --gcs-location string Location for the newly created buckets --gcs-no-check-bucket If set, don't attempt to check the bucket exists or create it --gcs-object-acl string Access Control List for new objects --gcs-project-number string Project number --gcs-service-account-file string Service Account Credentials JSON file path --gcs-storage-class string The storage class to use when storing objects in Google Cloud Storage --gcs-token string OAuth Access Token as a JSON blob --gcs-token-url string Token server url --gcs-user-project string User project --gofile-access-token string API Access token --gofile-account-id string Account ID --gofile-description string Description of the remote --gofile-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,LeftPeriod,RightPeriod,InvalidUtf8,Dot,Exclamation) --gofile-list-chunk int Number of items to list in each call (default 1000) --gofile-root-folder-id string ID of the root folder --gphotos-auth-url string Auth server URL --gphotos-batch-mode string Upload file batching sync|async|off (default "sync") --gphotos-batch-size int Max number of files in upload batch --gphotos-batch-timeout Duration Max time to allow an idle upload batch before uploading (default 0s) --gphotos-client-credentials Use client credentials OAuth flow --gphotos-client-id string OAuth Client Id --gphotos-client-secret string OAuth Client Secret --gphotos-description string Description of the remote --gphotos-encoding Encoding The encoding for the backend (default Slash,CrLf,InvalidUtf8,Dot) --gphotos-include-archived Also view and download archived media --gphotos-proxy string Use the gphotosdl proxy for downloading the full resolution images --gphotos-read-only Set to make the Google Photos backend read only --gphotos-read-size Set to read the size of media items --gphotos-start-year int Year limits the photos to be downloaded to those which are uploaded after the given year (default 2000) --gphotos-token string OAuth Access Token as a JSON blob --gphotos-token-url string Token server url --hasher-auto-size SizeSuffix Auto-update checksum for files smaller than this size (disabled by default) --hasher-description string Description of the remote --hasher-hashes CommaSepList Comma separated list of supported checksum types (default md5,sha1) --hasher-max-age Duration Maximum time to keep checksums in cache (0 = no cache, off = cache forever) (default off) --hasher-remote string Remote to cache checksums for (e.g. myRemote:path) --hdfs-data-transfer-protection string Kerberos data transfer protection: authentication|integrity|privacy --hdfs-description string Description of the remote --hdfs-encoding Encoding The encoding for the backend (default Slash,Colon,Del,Ctl,InvalidUtf8,Dot) --hdfs-namenode CommaSepList Hadoop name nodes and ports --hdfs-service-principal-name string Kerberos service principal name for the namenode --hdfs-username string Hadoop user name --hidrive-auth-url string Auth server URL --hidrive-chunk-size SizeSuffix Chunksize for chunked uploads (default 48Mi) --hidrive-client-credentials Use client credentials OAuth flow --hidrive-client-id string OAuth Client Id --hidrive-client-secret string OAuth Client Secret --hidrive-description string Description of the remote --hidrive-disable-fetching-member-count Do not fetch number of objects in directories unless it is absolutely necessary --hidrive-encoding Encoding The encoding for the backend (default Slash,Dot) --hidrive-endpoint string Endpoint for the service (default "https://api.hidrive.strato.com/2.1") --hidrive-root-prefix string The root/parent folder for all paths (default "/") --hidrive-scope-access string Access permissions that rclone should use when requesting access from HiDrive (default "rw") --hidrive-scope-role string User-level that rclone should use when requesting access from HiDrive (default "user") --hidrive-token string OAuth Access Token as a JSON blob --hidrive-token-url string Token server url --hidrive-upload-concurrency int Concurrency for chunked uploads (default 4) --hidrive-upload-cutoff SizeSuffix Cutoff/Threshold for chunked uploads (default 96Mi) --http-description string Description of the remote --http-headers CommaSepList Set HTTP headers for all transactions --http-no-escape Do not escape URL metacharacters in path names --http-no-head Don't use HEAD requests --http-no-slash Set this if the site doesn't end directories with / --http-url string URL of HTTP host to connect to --iclouddrive-apple-id string Apple ID --iclouddrive-client-id string Client id (default "d39ba9916b7251055b22c7f910e2ea796ee65e98b2ddecea8f5dde8d9d1a815d") --iclouddrive-description string Description of the remote --iclouddrive-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --iclouddrive-password string Password (obscured) --imagekit-description string Description of the remote --imagekit-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Dollar,Question,Hash,Percent,BackSlash,Del,Ctl,InvalidUtf8,Dot,SquareBracket) --imagekit-endpoint string You can find your ImageKit.io URL endpoint in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) --imagekit-only-signed Restrict unsigned image URLs If you have configured Restrict unsigned image URLs in your dashboard settings, set this to true --imagekit-private-key string You can find your ImageKit.io private key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) --imagekit-public-key string You can find your ImageKit.io public key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) --imagekit-upload-tags string Tags to add to the uploaded files, e.g. "tag1,tag2" --imagekit-versions Include old versions in directory listings --internetarchive-access-key-id string IAS3 Access Key --internetarchive-description string Description of the remote --internetarchive-disable-checksum Don't ask the server to test against MD5 checksum calculated by rclone (default true) --internetarchive-encoding Encoding The encoding for the backend (default Slash,LtGt,CrLf,Del,Ctl,InvalidUtf8,Dot) --internetarchive-endpoint string IAS3 Endpoint (default "https://s3.us.archive.org") --internetarchive-front-endpoint string Host of InternetArchive Frontend (default "https://archive.org") --internetarchive-item-derive Whether to trigger derive on the IA item or not. If set to false, the item will not be derived by IA upon upload (default true) --internetarchive-item-metadata stringArray Metadata to be set on the IA item, this is different from file-level metadata that can be set using --metadata-set --internetarchive-secret-access-key string IAS3 Secret Key (password) --internetarchive-wait-archive Duration Timeout for waiting the server's processing tasks (specifically archive and book_op) to finish (default 0s) --jottacloud-auth-url string Auth server URL --jottacloud-client-credentials Use client credentials OAuth flow --jottacloud-client-id string OAuth Client Id --jottacloud-client-secret string OAuth Client Secret --jottacloud-description string Description of the remote --jottacloud-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,Del,Ctl,InvalidUtf8,Dot) --jottacloud-hard-delete Delete files permanently rather than putting them into the trash --jottacloud-md5-memory-limit SizeSuffix Files bigger than this will be cached on disk to calculate the MD5 if required (default 10Mi) --jottacloud-no-versions Avoid server side versioning by deleting files and recreating files instead of overwriting them --jottacloud-token string OAuth Access Token as a JSON blob --jottacloud-token-url string Token server url --jottacloud-trashed-only Only show files that are in the trash --jottacloud-upload-resume-limit SizeSuffix Files bigger than this can be resumed if the upload fail's (default 10Mi) --koofr-description string Description of the remote --koofr-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --koofr-endpoint string The Koofr API endpoint to use --koofr-mountid string Mount ID of the mount to use --koofr-password string Your password for rclone generate one at https://app.koofr.net/app/admin/preferences/password (obscured) --koofr-provider string Choose your storage provider --koofr-setmtime Does the backend support setting modification time (default true) --koofr-user string Your user name --linkbox-description string Description of the remote --linkbox-token string Token from https://www.linkbox.to/admin/account --local-case-insensitive Force the filesystem to report itself as case insensitive --local-case-sensitive Force the filesystem to report itself as case sensitive --local-description string Description of the remote --local-encoding Encoding The encoding for the backend (default Slash,Dot) --local-hashes CommaSepList Comma separated list of supported checksum types --local-links Translate symlinks to/from regular files with a '.rclonelink' extension for the local backend --local-no-check-updated Don't check to see if the files change during upload --local-no-clone Disable reflink cloning for server-side copies --local-no-preallocate Disable preallocation of disk space for transferred files --local-no-set-modtime Disable setting modtime --local-no-sparse Disable sparse files for multi-thread downloads --local-nounc Disable UNC (long path names) conversion on Windows --local-time-type mtime|atime|btime|ctime Set what kind of time is returned (default mtime) --local-unicode-normalization Apply unicode NFC normalization to paths and filenames --local-zero-size-links Assume the Stat size of links is zero (and read them instead) (deprecated) --mailru-auth-url string Auth server URL --mailru-check-hash What should copy do if file checksum is mismatched or invalid (default true) --mailru-client-credentials Use client credentials OAuth flow --mailru-client-id string OAuth Client Id --mailru-client-secret string OAuth Client Secret --mailru-description string Description of the remote --mailru-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,InvalidUtf8,Dot) --mailru-pass string Password (obscured) --mailru-speedup-enable Skip full upload if there is another file with same data hash (default true) --mailru-speedup-file-patterns string Comma separated list of file name patterns eligible for speedup (put by hash) (default "*.mkv,*.avi,*.mp4,*.mp3,*.zip,*.gz,*.rar,*.pdf") --mailru-speedup-max-disk SizeSuffix This option allows you to disable speedup (put by hash) for large files (default 3Gi) --mailru-speedup-max-memory SizeSuffix Files larger than the size given below will always be hashed on disk (default 32Mi) --mailru-token string OAuth Access Token as a JSON blob --mailru-token-url string Token server url --mailru-user string User name (usually email) --mega-debug Output more debug from Mega --mega-description string Description of the remote --mega-encoding Encoding The encoding for the backend (default Slash,InvalidUtf8,Dot) --mega-hard-delete Delete files permanently rather than putting them into the trash --mega-pass string Password (obscured) --mega-use-https Use HTTPS for transfers --mega-user string User name --memory-description string Description of the remote --netstorage-account string Set the NetStorage account name --netstorage-description string Description of the remote --netstorage-host string Domain+path of NetStorage host to connect to --netstorage-protocol string Select between HTTP or HTTPS protocol (default "https") --netstorage-secret string Set the NetStorage account secret/G2O key for authentication (obscured) -x, --one-file-system Don't cross filesystem boundaries (unix/macOS only) --onedrive-access-scopes SpaceSepList Set scopes to be requested by rclone (default Files.Read Files.ReadWrite Files.Read.All Files.ReadWrite.All Sites.Read.All offline_access) --onedrive-auth-url string Auth server URL --onedrive-av-override Allows download of files the server thinks has a virus --onedrive-chunk-size SizeSuffix Chunk size to upload files with - must be multiple of 320k (327,680 bytes) (default 10Mi) --onedrive-client-credentials Use client credentials OAuth flow --onedrive-client-id string OAuth Client Id --onedrive-client-secret string OAuth Client Secret --onedrive-delta If set rclone will use delta listing to implement recursive listings --onedrive-description string Description of the remote --onedrive-drive-id string The ID of the drive to use --onedrive-drive-type string The type of the drive (personal | business | documentLibrary) --onedrive-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,LeftSpace,LeftTilde,RightSpace,RightPeriod,InvalidUtf8,Dot) --onedrive-expose-onenote-files Set to make OneNote files show up in directory listings --onedrive-hard-delete Permanently delete files on removal --onedrive-hash-type string Specify the hash in use for the backend (default "auto") --onedrive-link-password string Set the password for links created by the link command --onedrive-link-scope string Set the scope of the links created by the link command (default "anonymous") --onedrive-link-type string Set the type of the links created by the link command (default "view") --onedrive-list-chunk int Size of listing chunk (default 1000) --onedrive-metadata-permissions Bits Control whether permissions should be read or written in metadata (default off) --onedrive-no-versions Remove all versions on modifying operations --onedrive-region string Choose national cloud region for OneDrive (default "global") --onedrive-root-folder-id string ID of the root folder --onedrive-server-side-across-configs Deprecated: use --server-side-across-configs instead --onedrive-tenant string ID of the service principal's tenant. Also called its directory ID --onedrive-token string OAuth Access Token as a JSON blob --onedrive-token-url string Token server url --onedrive-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default off) --oos-attempt-resume-upload If true attempt to resume previously started multipart upload for the object --oos-chunk-size SizeSuffix Chunk size to use for uploading (default 5Mi) --oos-compartment string Specify compartment OCID, if you need to list buckets --oos-config-file string Path to OCI config file (default "~/.oci/config") --oos-config-profile string Profile name inside the oci config file (default "Default") --oos-copy-cutoff SizeSuffix Cutoff for switching to multipart copy (default 4.656Gi) --oos-copy-timeout Duration Timeout for copy (default 1m0s) --oos-description string Description of the remote --oos-disable-checksum Don't store MD5 checksum with object metadata --oos-encoding Encoding The encoding for the backend (default Slash,InvalidUtf8,Dot) --oos-endpoint string Endpoint for Object storage API --oos-leave-parts-on-error If true avoid calling abort upload on a failure, leaving all successfully uploaded parts for manual recovery --oos-max-upload-parts int Maximum number of parts in a multipart upload (default 10000) --oos-namespace string Object storage namespace --oos-no-check-bucket If set, don't attempt to check the bucket exists or create it --oos-provider string Choose your Auth Provider (default "env_auth") --oos-region string Object storage Region --oos-sse-customer-algorithm string If using SSE-C, the optional header that specifies "AES256" as the encryption algorithm --oos-sse-customer-key string To use SSE-C, the optional header that specifies the base64-encoded 256-bit encryption key to use to --oos-sse-customer-key-file string To use SSE-C, a file containing the base64-encoded string of the AES-256 encryption key associated --oos-sse-customer-key-sha256 string If using SSE-C, The optional header that specifies the base64-encoded SHA256 hash of the encryption --oos-sse-kms-key-id string if using your own master key in vault, this header specifies the --oos-storage-tier string The storage class to use when storing new objects in storage. https://docs.oracle.com/en-us/iaas/Content/Object/Concepts/understandingstoragetiers.htm (default "Standard") --oos-upload-concurrency int Concurrency for multipart uploads (default 10) --oos-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default 200Mi) --opendrive-access string Files and folders will be uploaded with this access permission (default private) (default "private") --opendrive-chunk-size SizeSuffix Files will be uploaded in chunks this size (default 10Mi) --opendrive-description string Description of the remote --opendrive-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,LeftSpace,LeftCrLfHtVt,RightSpace,RightCrLfHtVt,InvalidUtf8,Dot) --opendrive-password string Password (obscured) --opendrive-username string Username --pcloud-auth-url string Auth server URL --pcloud-client-credentials Use client credentials OAuth flow --pcloud-client-id string OAuth Client Id --pcloud-client-secret string OAuth Client Secret --pcloud-description string Description of the remote --pcloud-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --pcloud-hostname string Hostname to connect to (default "api.pcloud.com") --pcloud-password string Your pcloud password (obscured) --pcloud-root-folder-id string Fill in for rclone to use a non root folder as its starting point (default "d0") --pcloud-token string OAuth Access Token as a JSON blob --pcloud-token-url string Token server url --pcloud-username string Your pcloud username --pikpak-chunk-size SizeSuffix Chunk size for multipart uploads (default 5Mi) --pikpak-description string Description of the remote --pikpak-device-id string Device ID used for authorization --pikpak-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,LeftSpace,RightSpace,RightPeriod,InvalidUtf8,Dot) --pikpak-hash-memory-limit SizeSuffix Files bigger than this will be cached on disk to calculate hash if required (default 10Mi) --pikpak-no-media-link Use original file links instead of media links --pikpak-pass string Pikpak password (obscured) --pikpak-root-folder-id string ID of the root folder --pikpak-trashed-only Only show files that are in the trash --pikpak-upload-concurrency int Concurrency for multipart uploads (default 4) --pikpak-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default 200Mi) --pikpak-use-trash Send files to the trash instead of deleting permanently (default true) --pikpak-user string Pikpak username --pikpak-user-agent string HTTP user agent for pikpak (default "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:129.0) Gecko/20100101 Firefox/129.0") --pixeldrain-api-key string API key for your pixeldrain account --pixeldrain-api-url string The API endpoint to connect to. In the vast majority of cases it's fine to leave (default "https://pixeldrain.com/api") --pixeldrain-description string Description of the remote --pixeldrain-root-folder-id string Root of the filesystem to use (default "me") --premiumizeme-auth-url string Auth server URL --premiumizeme-client-credentials Use client credentials OAuth flow --premiumizeme-client-id string OAuth Client Id --premiumizeme-client-secret string OAuth Client Secret --premiumizeme-description string Description of the remote --premiumizeme-encoding Encoding The encoding for the backend (default Slash,DoubleQuote,BackSlash,Del,Ctl,InvalidUtf8,Dot) --premiumizeme-token string OAuth Access Token as a JSON blob --premiumizeme-token-url string Token server url --protondrive-2fa string The 2FA code --protondrive-app-version string The app version string (default "macos-drive@1.0.0-alpha.1+rclone") --protondrive-description string Description of the remote --protondrive-enable-caching Caches the files and folders metadata to reduce API calls (default true) --protondrive-encoding Encoding The encoding for the backend (default Slash,LeftSpace,RightSpace,InvalidUtf8,Dot) --protondrive-mailbox-password string The mailbox password of your two-password proton account (obscured) --protondrive-original-file-size Return the file size before encryption (default true) --protondrive-password string The password of your proton account (obscured) --protondrive-replace-existing-draft Create a new revision when filename conflict is detected --protondrive-username string The username of your proton account --putio-auth-url string Auth server URL --putio-client-credentials Use client credentials OAuth flow --putio-client-id string OAuth Client Id --putio-client-secret string OAuth Client Secret --putio-description string Description of the remote --putio-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --putio-token string OAuth Access Token as a JSON blob --putio-token-url string Token server url --qingstor-access-key-id string QingStor Access Key ID --qingstor-chunk-size SizeSuffix Chunk size to use for uploading (default 4Mi) --qingstor-connection-retries int Number of connection retries (default 3) --qingstor-description string Description of the remote --qingstor-encoding Encoding The encoding for the backend (default Slash,Ctl,InvalidUtf8) --qingstor-endpoint string Enter an endpoint URL to connection QingStor API --qingstor-env-auth Get QingStor credentials from runtime --qingstor-secret-access-key string QingStor Secret Access Key (password) --qingstor-upload-concurrency int Concurrency for multipart uploads (default 1) --qingstor-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default 200Mi) --qingstor-zone string Zone to connect to --quatrix-api-key string API key for accessing Quatrix account --quatrix-description string Description of the remote --quatrix-effective-upload-time string Wanted upload time for one chunk (default "4s") --quatrix-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --quatrix-hard-delete Delete files permanently rather than putting them into the trash --quatrix-host string Host name of Quatrix account --quatrix-maximal-summary-chunk-size SizeSuffix The maximal summary for all chunks. It should not be less than 'transfers'*'minimal_chunk_size' (default 95.367Mi) --quatrix-minimal-chunk-size SizeSuffix The minimal size for one chunk (default 9.537Mi) --quatrix-skip-project-folders Skip project folders in operations --s3-access-key-id string AWS Access Key ID --s3-acl string Canned ACL used when creating buckets and storing or copying objects --s3-bucket-acl string Canned ACL used when creating buckets --s3-chunk-size SizeSuffix Chunk size to use for uploading (default 5Mi) --s3-copy-cutoff SizeSuffix Cutoff for switching to multipart copy (default 4.656Gi) --s3-decompress If set this will decompress gzip encoded objects --s3-description string Description of the remote --s3-directory-bucket Set to use AWS Directory Buckets --s3-directory-markers Upload an empty object with a trailing slash when a new directory is created --s3-disable-checksum Don't store MD5 checksum with object metadata --s3-disable-http2 Disable usage of http2 for S3 backends --s3-download-url string Custom endpoint for downloads --s3-encoding Encoding The encoding for the backend (default Slash,InvalidUtf8,Dot) --s3-endpoint string Endpoint for S3 API --s3-env-auth Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars) --s3-force-path-style If true use path style access if false use virtual hosted style (default true) --s3-ibm-api-key string IBM API Key to be used to obtain IAM token --s3-ibm-resource-instance-id string IBM service instance id --s3-leave-parts-on-error If true avoid calling abort upload on a failure, leaving all successfully uploaded parts on S3 for manual recovery --s3-list-chunk int Size of listing chunk (response list for each ListObject S3 request) (default 1000) --s3-list-url-encode Tristate Whether to url encode listings: true/false/unset (default unset) --s3-list-version int Version of ListObjects to use: 1,2 or 0 for auto --s3-location-constraint string Location constraint - must be set to match the Region --s3-max-upload-parts int Maximum number of parts in a multipart upload (default 10000) --s3-might-gzip Tristate Set this if the backend might gzip objects (default unset) --s3-no-check-bucket If set, don't attempt to check the bucket exists or create it --s3-no-head If set, don't HEAD uploaded objects to check integrity --s3-no-head-object If set, do not do HEAD before GET when getting objects --s3-no-system-metadata Suppress setting and reading of system metadata --s3-profile string Profile to use in the shared credentials file --s3-provider string Choose your S3 provider --s3-region string Region to connect to --s3-requester-pays Enables requester pays option when interacting with S3 bucket --s3-sdk-log-mode Bits Set to debug the SDK (default Off) --s3-secret-access-key string AWS Secret Access Key (password) --s3-server-side-encryption string The server-side encryption algorithm used when storing this object in S3 --s3-session-token string An AWS session token --s3-shared-credentials-file string Path to the shared credentials file --s3-sign-accept-encoding Tristate Set if rclone should include Accept-Encoding as part of the signature (default unset) --s3-sse-customer-algorithm string If using SSE-C, the server-side encryption algorithm used when storing this object in S3 --s3-sse-customer-key string To use SSE-C you may provide the secret encryption key used to encrypt/decrypt your data --s3-sse-customer-key-base64 string If using SSE-C you must provide the secret encryption key encoded in base64 format to encrypt/decrypt your data --s3-sse-customer-key-md5 string If using SSE-C you may provide the secret encryption key MD5 checksum (optional) --s3-sse-kms-key-id string If using KMS ID you must provide the ARN of Key --s3-storage-class string The storage class to use when storing new objects in S3 --s3-upload-concurrency int Concurrency for multipart uploads and copies (default 4) --s3-upload-cutoff SizeSuffix Cutoff for switching to chunked upload (default 200Mi) --s3-use-accelerate-endpoint If true use the AWS S3 accelerated endpoint --s3-use-accept-encoding-gzip Accept-Encoding: gzip Whether to send Accept-Encoding: gzip header (default unset) --s3-use-already-exists Tristate Set if rclone should report BucketAlreadyExists errors on bucket creation (default unset) --s3-use-arn-region If true, enables arn region support for the service --s3-use-dual-stack If true use AWS S3 dual-stack endpoint (IPv6 support) --s3-use-multipart-etag Tristate Whether to use ETag in multipart uploads for verification (default unset) --s3-use-multipart-uploads Tristate Set if rclone should use multipart uploads (default unset) --s3-use-presigned-request Whether to use a presigned request or PutObject for single part uploads --s3-use-unsigned-payload Tristate Whether to use an unsigned payload in PutObject (default unset) --s3-use-x-id Tristate Set if rclone should add x-id URL parameters (default unset) --s3-v2-auth If true use v2 authentication --s3-version-at Time Show file versions as they were at the specified time (default off) --s3-version-deleted Show deleted file markers when using versions --s3-versions Include old versions in directory listings --seafile-2fa Two-factor authentication ('true' if the account has 2FA enabled) --seafile-create-library Should rclone create a library if it doesn't exist --seafile-description string Description of the remote --seafile-encoding Encoding The encoding for the backend (default Slash,DoubleQuote,BackSlash,Ctl,InvalidUtf8,Dot) --seafile-library string Name of the library --seafile-library-key string Library password (for encrypted libraries only) (obscured) --seafile-pass string Password (obscured) --seafile-url string URL of seafile host to connect to --seafile-user string User name (usually email address) --sftp-ask-password Allow asking for SFTP password when needed --sftp-blake3sum-command string The command used to read BLAKE3 hashes --sftp-chunk-size SizeSuffix Upload and download chunk size (default 32Ki) --sftp-ciphers SpaceSepList Space separated list of ciphers to be used for session encryption, ordered by preference --sftp-concurrency int The maximum number of outstanding requests for one file (default 64) --sftp-connections int Maximum number of SFTP simultaneous connections, 0 for unlimited --sftp-copy-is-hardlink Set to enable server side copies using hardlinks --sftp-crc32sum-command string The command used to read CRC-32 hashes --sftp-description string Description of the remote --sftp-disable-concurrent-reads If set don't use concurrent reads --sftp-disable-concurrent-writes If set don't use concurrent writes --sftp-disable-hashcheck Disable the execution of SSH commands to determine if remote file hashing is available --sftp-hashes CommaSepList Comma separated list of supported checksum types --sftp-host string SSH host to connect to --sftp-host-key-algorithms SpaceSepList Space separated list of host key algorithms, ordered by preference --sftp-http-proxy string URL for HTTP CONNECT proxy --sftp-idle-timeout Duration Max time before closing idle connections (default 1m0s) --sftp-key-exchange SpaceSepList Space separated list of key exchange algorithms, ordered by preference --sftp-key-file string Path to PEM-encoded private key file --sftp-key-file-pass string The passphrase to decrypt the PEM-encoded private key file (obscured) --sftp-key-pem string Raw PEM-encoded private key --sftp-key-use-agent When set forces the usage of the ssh-agent --sftp-known-hosts-file string Optional path to known_hosts file --sftp-macs SpaceSepList Space separated list of MACs (message authentication code) algorithms, ordered by preference --sftp-md5sum-command string The command used to read MD5 hashes --sftp-pass string SSH password, leave blank to use ssh-agent (obscured) --sftp-path-override string Override path used by SSH shell commands --sftp-port int SSH port number (default 22) --sftp-pubkey string SSH public certificate for public certificate based authentication --sftp-pubkey-file string Optional path to public key file --sftp-server-command string Specifies the path or command to run a sftp server on the remote host --sftp-set-env SpaceSepList Environment variables to pass to sftp and commands --sftp-set-modtime Set the modified time on the remote if set (default true) --sftp-sha1sum-command string The command used to read SHA-1 hashes --sftp-sha256sum-command string The command used to read SHA-256 hashes --sftp-shell-type string The type of SSH shell on remote server, if any --sftp-skip-links Set to skip any symlinks and any other non regular files --sftp-socks-proxy string Socks 5 proxy host --sftp-ssh SpaceSepList Path and arguments to external ssh binary --sftp-subsystem string Specifies the SSH2 subsystem on the remote host (default "sftp") --sftp-use-fstat If set use fstat instead of stat --sftp-use-insecure-cipher Enable the use of insecure ciphers and key exchange methods --sftp-user string SSH username (default "$USER") --sftp-xxh128sum-command string The command used to read XXH128 hashes --sftp-xxh3sum-command string The command used to read XXH3 hashes --sharefile-auth-url string Auth server URL --sharefile-chunk-size SizeSuffix Upload chunk size (default 64Mi) --sharefile-client-credentials Use client credentials OAuth flow --sharefile-client-id string OAuth Client Id --sharefile-client-secret string OAuth Client Secret --sharefile-description string Description of the remote --sharefile-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,LeftSpace,LeftPeriod,RightSpace,RightPeriod,InvalidUtf8,Dot) --sharefile-endpoint string Endpoint for API calls --sharefile-root-folder-id string ID of the root folder --sharefile-token string OAuth Access Token as a JSON blob --sharefile-token-url string Token server url --sharefile-upload-cutoff SizeSuffix Cutoff for switching to multipart upload (default 128Mi) --sia-api-password string Sia Daemon API Password (obscured) --sia-api-url string Sia daemon API URL, like http://sia.daemon.host:9980 (default "http://127.0.0.1:9980") --sia-description string Description of the remote --sia-encoding Encoding The encoding for the backend (default Slash,Question,Hash,Percent,Del,Ctl,InvalidUtf8,Dot) --sia-user-agent string Siad User Agent (default "Sia-Agent") --skip-links Don't warn about skipped symlinks --smb-case-insensitive Whether the server is configured to be case-insensitive (default true) --smb-description string Description of the remote --smb-domain string Domain name for NTLM authentication (default "WORKGROUP") --smb-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot) --smb-hide-special-share Hide special shares (e.g. print$) which users aren't supposed to access (default true) --smb-host string SMB server hostname to connect to --smb-idle-timeout Duration Max time before closing idle connections (default 1m0s) --smb-kerberos-ccache string Path to the Kerberos credential cache (krb5cc) --smb-pass string SMB password (obscured) --smb-port int SMB port number (default 445) --smb-spn string Service principal name --smb-use-kerberos Use Kerberos authentication --smb-user string SMB username (default "$USER") --storj-access-grant string Access grant --storj-api-key string API key --storj-description string Description of the remote --storj-passphrase string Encryption passphrase --storj-provider string Choose an authentication method (default "existing") --storj-satellite-address string Satellite address (default "us1.storj.io") --sugarsync-access-key-id string Sugarsync Access Key ID --sugarsync-app-id string Sugarsync App ID --sugarsync-authorization string Sugarsync authorization --sugarsync-authorization-expiry string Sugarsync authorization expiry --sugarsync-deleted-id string Sugarsync deleted folder id --sugarsync-description string Description of the remote --sugarsync-encoding Encoding The encoding for the backend (default Slash,Ctl,InvalidUtf8,Dot) --sugarsync-hard-delete Permanently delete files if true --sugarsync-private-access-key string Sugarsync Private Access Key --sugarsync-refresh-token string Sugarsync refresh token --sugarsync-root-id string Sugarsync root id --sugarsync-user string Sugarsync user --swift-application-credential-id string Application Credential ID (OS_APPLICATION_CREDENTIAL_ID) --swift-application-credential-name string Application Credential Name (OS_APPLICATION_CREDENTIAL_NAME) --swift-application-credential-secret string Application Credential Secret (OS_APPLICATION_CREDENTIAL_SECRET) --swift-auth string Authentication URL for server (OS_AUTH_URL) --swift-auth-token string Auth Token from alternate authentication - optional (OS_AUTH_TOKEN) --swift-auth-version int AuthVersion - optional - set to (1,2,3) if your auth URL has no version (ST_AUTH_VERSION) --swift-chunk-size SizeSuffix Above this size files will be chunked (default 5Gi) --swift-description string Description of the remote --swift-domain string User domain - optional (v3 auth) (OS_USER_DOMAIN_NAME) --swift-encoding Encoding The encoding for the backend (default Slash,InvalidUtf8) --swift-endpoint-type string Endpoint type to choose from the service catalogue (OS_ENDPOINT_TYPE) (default "public") --swift-env-auth Get swift credentials from environment variables in standard OpenStack form --swift-fetch-until-empty-page When paginating, always fetch unless we received an empty page --swift-key string API key or password (OS_PASSWORD) --swift-leave-parts-on-error If true avoid calling abort upload on a failure --swift-no-chunk Don't chunk files during streaming upload --swift-no-large-objects Disable support for static and dynamic large objects --swift-partial-page-fetch-threshold int When paginating, fetch if the current page is within this percentage of the limit --swift-region string Region name - optional (OS_REGION_NAME) --swift-storage-policy string The storage policy to use when creating a new container --swift-storage-url string Storage URL - optional (OS_STORAGE_URL) --swift-tenant string Tenant name - optional for v1 auth, this or tenant_id required otherwise (OS_TENANT_NAME or OS_PROJECT_NAME) --swift-tenant-domain string Tenant domain - optional (v3 auth) (OS_PROJECT_DOMAIN_NAME) --swift-tenant-id string Tenant ID - optional for v1 auth, this or tenant required otherwise (OS_TENANT_ID) --swift-use-segments-container Tristate Choose destination for large object segments (default unset) --swift-user string User name to log in (OS_USERNAME) --swift-user-id string User ID to log in - optional - most swift systems use user and leave this blank (v3 auth) (OS_USER_ID) --ulozto-app-token string The application token identifying the app. An app API key can be either found in the API --ulozto-description string Description of the remote --ulozto-encoding Encoding The encoding for the backend (default Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot) --ulozto-list-page-size int The size of a single page for list commands. 1-500 (default 500) --ulozto-password string The password for the user (obscured) --ulozto-root-folder-slug string If set, rclone will use this folder as the root folder for all operations. For example, --ulozto-username string The username of the principal to operate as --union-action-policy string Policy to choose upstream on ACTION category (default "epall") --union-cache-time int Cache time of usage and free space (in seconds) (default 120) --union-create-policy string Policy to choose upstream on CREATE category (default "epmfs") --union-description string Description of the remote --union-min-free-space SizeSuffix Minimum viable free space for lfs/eplfs policies (default 1Gi) --union-search-policy string Policy to choose upstream on SEARCH category (default "ff") --union-upstreams string List of space separated upstreams --uptobox-access-token string Your access token --uptobox-description string Description of the remote --uptobox-encoding Encoding The encoding for the backend (default Slash,LtGt,DoubleQuote,BackQuote,Del,Ctl,LeftSpace,InvalidUtf8,Dot) --uptobox-private Set to make uploaded files private --webdav-auth-redirect Preserve authentication on redirect --webdav-bearer-token string Bearer token instead of user/pass (e.g. a Macaroon) --webdav-bearer-token-command string Command to run to get a bearer token --webdav-description string Description of the remote --webdav-encoding string The encoding for the backend --webdav-headers CommaSepList Set HTTP headers for all transactions --webdav-nextcloud-chunk-size SizeSuffix Nextcloud upload chunk size (default 10Mi) --webdav-owncloud-exclude-mounts Exclude ownCloud mounted storages --webdav-owncloud-exclude-shares Exclude ownCloud shares --webdav-pacer-min-sleep Duration Minimum time to sleep between API calls (default 10ms) --webdav-pass string Password (obscured) --webdav-unix-socket string Path to a unix domain socket to dial to, instead of opening a TCP connection directly --webdav-url string URL of http host to connect to --webdav-user string User name --webdav-vendor string Name of the WebDAV site/service/software you are using --yandex-auth-url string Auth server URL --yandex-client-credentials Use client credentials OAuth flow --yandex-client-id string OAuth Client Id --yandex-client-secret string OAuth Client Secret --yandex-description string Description of the remote --yandex-encoding Encoding The encoding for the backend (default Slash,Del,Ctl,InvalidUtf8,Dot) --yandex-hard-delete Delete files permanently rather than putting them into the trash --yandex-spoof-ua Set the user agent to match an official version of the yandex disk client. May help with upload performance (default true) --yandex-token string OAuth Access Token as a JSON blob --yandex-token-url string Token server url --zoho-auth-url string Auth server URL --zoho-client-credentials Use client credentials OAuth flow --zoho-client-id string OAuth Client Id --zoho-client-secret string OAuth Client Secret --zoho-description string Description of the remote --zoho-encoding Encoding The encoding for the backend (default Del,Ctl,InvalidUtf8) --zoho-region string Zoho region to connect to --zoho-token string OAuth Access Token as a JSON blob --zoho-token-url string Token server url --zoho-upload-cutoff SizeSuffix Cutoff for switching to large file upload api (>= 10 MiB) (default 10Mi) Docker Volume Plugin Introduction Docker 1.9 has added support for creating named volumes via command-line interface and mounting them in containers as a way to share data between them. Since Docker 1.10 you can create named volumes with Docker Compose by descriptions in docker-compose.yml files for use by container groups on a single host. As of Docker 1.12 volumes are supported by Docker Swarm included with Docker Engine and created from descriptions in swarm compose v3 files for use with swarm stacks across multiple cluster nodes. Docker Volume Plugins augment the default local volume driver included in Docker with stateful volumes shared across containers and hosts. Unlike local volumes, your data will not be deleted when such volume is removed. Plugins can run managed by the docker daemon, as a native system service (under systemd, sysv or upstart) or as a standalone executable. Rclone can run as docker volume plugin in all these modes. It interacts with the local docker daemon via plugin API and handles mounting of remote file systems into docker containers so it must run on the same host as the docker daemon or on every Swarm node. Getting started In the first example we will use the SFTP rclone volume with Docker engine on a standalone Ubuntu machine. Start from installing Docker on the host. The FUSE driver is a prerequisite for rclone mounting and should be installed on host: sudo apt-get -y install fuse3 Create two directories required by rclone docker plugin: sudo mkdir -p /var/lib/docker-plugins/rclone/config sudo mkdir -p /var/lib/docker-plugins/rclone/cache Install the managed rclone docker plugin for your architecture (here amd64): docker plugin install rclone/docker-volume-rclone:amd64 args="-v" --alias rclone --grant-all-permissions docker plugin list Create your SFTP volume: docker volume create firstvolume -d rclone -o type=sftp -o sftp-host=_hostname_ -o sftp-user=_username_ -o sftp-pass=_password_ -o allow-other=true Note that since all options are static, you don't even have to run rclone config or create the rclone.conf file (but the config directory should still be present). In the simplest case you can use localhost as hostname and your SSH credentials as username and password. You can also change the remote path to your home directory on the host, for example -o path=/home/username. Time to create a test container and mount the volume into it: docker run --rm -it -v firstvolume:/mnt --workdir /mnt ubuntu:latest bash If all goes well, you will enter the new container and change right to the mounted SFTP remote. You can type ls to list the mounted directory or otherwise play with it. Type exit when you are done. The container will stop but the volume will stay, ready to be reused. When it's not needed anymore, remove it: docker volume list docker volume remove firstvolume Now let us try something more elaborate: Google Drive volume on multi-node Docker Swarm. You should start from installing Docker and FUSE, creating plugin directories and installing rclone plugin on every swarm node. Then setup the Swarm. Google Drive volumes need an access token which can be setup via web browser and will be periodically renewed by rclone. The managed plugin cannot run a browser so we will use a technique similar to the rclone setup on a headless box. Run rclone config on another machine equipped with web browser and graphical user interface. Create the Google Drive remote. When done, transfer the resulting rclone.conf to the Swarm cluster and save as /var/lib/docker-plugins/rclone/config/rclone.conf on every node. By default this location is accessible only to the root user so you will need appropriate privileges. The resulting config will look like this: [gdrive] type = drive scope = drive drive_id = 1234567... root_folder_id = 0Abcd... token = {"access_token":...} Now create the file named example.yml with a swarm stack description like this: version: '3' services: heimdall: image: linuxserver/heimdall:latest ports: [8080:80] volumes: [configdata:/config] volumes: configdata: driver: rclone driver_opts: remote: 'gdrive:heimdall' allow_other: 'true' vfs_cache_mode: full poll_interval: 0 and run the stack: docker stack deploy example -c ./example.yml After a few seconds docker will spread the parsed stack description over cluster, create the example_heimdall service on port 8080, run service containers on one or more cluster nodes and request the example_configdata volume from rclone plugins on the node hosts. You can use the following commands to confirm results: docker service ls docker service ps example_heimdall docker volume ls Point your browser to http://cluster.host.address:8080 and play with the service. Stop it with docker stack remove example when you are done. Note that the example_configdata volume(s) created on demand at the cluster nodes will not be automatically removed together with the stack but stay for future reuse. You can remove them manually by invoking the docker volume remove example_configdata command on every node. Creating Volumes via CLI Volumes can be created with docker volume create. Here are a few examples: docker volume create vol1 -d rclone -o remote=storj: -o vfs-cache-mode=full docker volume create vol2 -d rclone -o remote=:storj,access_grant=xxx:heimdall docker volume create vol3 -d rclone -o type=storj -o path=heimdall -o storj-access-grant=xxx -o poll-interval=0 Note the -d rclone flag that tells docker to request volume from the rclone driver. This works even if you installed managed driver by its full name rclone/docker-volume-rclone because you provided the --alias rclone option. Volumes can be inspected as follows: docker volume list docker volume inspect vol1 Volume Configuration Rclone flags and volume options are set via the -o flag to the docker volume create command. They include backend-specific parameters as well as mount and VFS options. Also there are a few special -o options: remote, fs, type, path, mount-type and persist. remote determines an existing remote name from the config file, with trailing colon and optionally with a remote path. See the full syntax in the rclone documentation. This option can be aliased as fs to prevent confusion with the remote parameter of such backends as crypt or alias. The remote=:backend:dir/subdir syntax can be used to create on-the-fly (config-less) remotes, while the type and path options provide a simpler alternative for this. Using two split options -o type=backend -o path=dir/subdir is equivalent to the combined syntax -o remote=:backend:dir/subdir but is arguably easier to parameterize in scripts. The path part is optional. Mount and VFS options as well as backend parameters are named like their twin command-line flags without the -- CLI prefix. Optionally you can use underscores instead of dashes in option names. For example, --vfs-cache-mode full becomes -o vfs-cache-mode=full or -o vfs_cache_mode=full. Boolean CLI flags without value will gain the true value, e.g. --allow-other becomes -o allow-other=true or -o allow_other=true. Please note that you can provide parameters only for the backend immediately referenced by the backend type of mounted remote. If this is a wrapping backend like alias, chunker or crypt, you cannot provide options for the referred to remote or backend. This limitation is imposed by the rclone connection string parser. The only workaround is to feed plugin with rclone.conf or configure plugin arguments (see below). Special Volume Options mount-type determines the mount method and in general can be one of: mount, cmount, or mount2. This can be aliased as mount_type. It should be noted that the managed rclone docker plugin currently does not support the cmount method and mount2 is rarely needed. This option defaults to the first found method, which is usually mount so you generally won't need it. persist is a reserved boolean (true/false) option. In future it will allow to persist on-the-fly remotes in the plugin rclone.conf file. Connection Strings The remote value can be extended with connection strings as an alternative way to supply backend parameters. This is equivalent to the -o backend options with one syntactic difference. Inside connection string the backend prefix must be dropped from parameter names but in the -o param=value array it must be present. For instance, compare the following option array -o remote=:sftp:/home -o sftp-host=localhost with equivalent connection string: -o remote=:sftp,host=localhost:/home This difference exists because flag options -o key=val include not only backend parameters but also mount/VFS flags and possibly other settings. Also it allows to discriminate the remote option from the crypt-remote (or similarly named backend parameters) and arguably simplifies scripting due to clearer value substitution. Using with Swarm or Compose Both Docker Swarm and Docker Compose use YAML-formatted text files to describe groups (stacks) of containers, their properties, networks and volumes. Compose uses the compose v2 format, Swarm uses the compose v3 format. They are mostly similar, differences are explained in the docker documentation. Volumes are described by the children of the top-level volumes: node. Each of them should be named after its volume and have at least two elements, the self-explanatory driver: rclone value and the driver_opts: structure playing the same role as -o key=val CLI flags: volumes: volume_name_1: driver: rclone driver_opts: remote: 'gdrive:' allow_other: 'true' vfs_cache_mode: full token: '{"type": "borrower", "expires": "2021-12-31"}' poll_interval: 0 Notice a few important details: - YAML prefers _ in option names instead of -. - YAML treats single and double quotes interchangeably. Simple strings and integers can be left unquoted. - Boolean values must be quoted like 'true' or "false" because these two words are reserved by YAML. - The filesystem string is keyed with remote (or with fs). Normally you can omit quotes here, but if the string ends with colon, you must quote it like remote: "storage_box:". - YAML is picky about surrounding braces in values as this is in fact another syntax for key/value mappings. For example, JSON access tokens usually contain double quotes and surrounding braces, so you must put them in single quotes. Installing as Managed Plugin Docker daemon can install plugins from an image registry and run them managed. We maintain the docker-volume-rclone plugin image on Docker Hub. Rclone volume plugin requires Docker Engine >= 19.03.15 The plugin requires presence of two directories on the host before it can be installed. Note that plugin will not create them automatically. By default they must exist on host at the following locations (though you can tweak the paths): - /var/lib/docker-plugins/rclone/config is reserved for the rclone.conf config file and must exist even if it's empty and the config file is not present. - /var/lib/docker-plugins/rclone/cache holds the plugin state file as well as optional VFS caches. You can install managed plugin with default settings as follows: docker plugin install rclone/docker-volume-rclone:amd64 --grant-all-permissions --alias rclone The :amd64 part of the image specification after colon is called a tag. Usually you will want to install the latest plugin for your architecture. In this case the tag will just name it, like amd64 above. The following plugin architectures are currently available: - amd64 - arm64 - arm-v7 Sometimes you might want a concrete plugin version, not the latest one. Then you should use image tag in the form :ARCHITECTURE-VERSION. For example, to install plugin version v1.56.2 on architecture arm64 you will use tag arm64-1.56.2 (note the removed v) so the full image specification becomes rclone/docker-volume-rclone:arm64-1.56.2. We also provide the latest plugin tag, but since docker does not support multi-architecture plugins as of the time of this writing, this tag is currently an alias for amd64. By convention the latest tag is the default one and can be omitted, thus both rclone/docker-volume-rclone:latest and just rclone/docker-volume-rclone will refer to the latest plugin release for the amd64 platform. Also the amd64 part can be omitted from the versioned rclone plugin tags. For example, rclone image reference rclone/docker-volume-rclone:amd64-1.56.2 can be abbreviated as rclone/docker-volume-rclone:1.56.2 for convenience. However, for non-intel architectures you still have to use the full tag as amd64 or latest will fail to start. Managed plugin is in fact a special container running in a namespace separate from normal docker containers. Inside it runs the rclone serve docker command. The config and cache directories are bind-mounted into the container at start. The docker daemon connects to a unix socket created by the command inside the container. The command creates on-demand remote mounts right inside, then docker machinery propagates them through kernel mount namespaces and bind-mounts into requesting user containers. You can tweak a few plugin settings after installation when it's disabled (not in use), for instance: docker plugin disable rclone docker plugin set rclone RCLONE_VERBOSE=2 config=/etc/rclone args="--vfs-cache-mode=writes --allow-other" docker plugin enable rclone docker plugin inspect rclone Note that if docker refuses to disable the plugin, you should find and remove all active volumes connected with it as well as containers and swarm services that use them. This is rather tedious so please carefully plan in advance. You can tweak the following settings: args, config, cache, HTTP_PROXY, HTTPS_PROXY, NO_PROXY and RCLONE_VERBOSE. It's your task to keep plugin settings in sync across swarm cluster nodes. args sets command-line arguments for the rclone serve docker command (none by default). Arguments should be separated by space so you will normally want to put them in quotes on the docker plugin set command line. Both serve docker flags and generic rclone flags are supported, including backend parameters that will be used as defaults for volume creation. Note that plugin will fail (due to this docker bug) if the args value is empty. Use e.g. args="-v" as a workaround. config=/host/dir sets alternative host location for the config directory. Plugin will look for rclone.conf here. It's not an error if the config file is not present but the directory must exist. Please note that plugin can periodically rewrite the config file, for example when it renews storage access tokens. Keep this in mind and try to avoid races between the plugin and other instances of rclone on the host that might try to change the config simultaneously resulting in corrupted rclone.conf. You can also put stuff like private key files for SFTP remotes in this directory. Just note that it's bind-mounted inside the plugin container at the predefined path /data/config. For example, if your key file is named sftp-box1.key on the host, the corresponding volume config option should read -o sftp-key-file=/data/config/sftp-box1.key. cache=/host/dir sets alternative host location for the cache directory. The plugin will keep VFS caches here. Also it will create and maintain the docker-plugin.state file in this directory. When the plugin is restarted or reinstalled, it will look in this file to recreate any volumes that existed previously. However, they will not be re-mounted into consuming containers after restart. Usually this is not a problem as the docker daemon normally will restart affected user containers after failures, daemon restarts or host reboots. RCLONE_VERBOSE sets plugin verbosity from 0 (errors only, by default) to 2 (debugging). Verbosity can be also tweaked via args="-v [-v] ...". Since arguments are more generic, you will rarely need this setting. The plugin output by default feeds the docker daemon log on local host. Log entries are reflected as errors in the docker log but retain their actual level assigned by rclone in the encapsulated message string. HTTP_PROXY, HTTPS_PROXY, NO_PROXY customize the plugin proxy settings. You can set custom plugin options right when you install it, in one go: docker plugin remove rclone docker plugin install rclone/docker-volume-rclone:amd64 \ --alias rclone --grant-all-permissions \ args="-v --allow-other" config=/etc/rclone docker plugin inspect rclone Healthchecks The docker plugin volume protocol doesn't provide a way for plugins to inform the docker daemon that a volume is (un-)available. As a workaround you can setup a healthcheck to verify that the mount is responding, for example: services: my_service: image: my_image healthcheck: test: ls /path/to/rclone/mount || exit 1 interval: 1m timeout: 15s retries: 3 start_period: 15s Running Plugin under Systemd In most cases you should prefer managed mode. Moreover, MacOS and Windows do not support native Docker plugins. Please use managed mode on these systems. Proceed further only if you are on Linux. First, install rclone. You can just run it (type rclone serve docker and hit enter) for the test. Install FUSE: sudo apt-get -y install fuse Download two systemd configuration files: docker-volume-rclone.service and docker-volume-rclone.socket. Put them to the /etc/systemd/system/ directory: cp docker-volume-plugin.service /etc/systemd/system/ cp docker-volume-plugin.socket /etc/systemd/system/ Please note that all commands in this section must be run as root but we omit sudo prefix for brevity. Now create directories required by the service: mkdir -p /var/lib/docker-volumes/rclone mkdir -p /var/lib/docker-plugins/rclone/config mkdir -p /var/lib/docker-plugins/rclone/cache Run the docker plugin service in the socket activated mode: systemctl daemon-reload systemctl start docker-volume-rclone.service systemctl enable docker-volume-rclone.socket systemctl start docker-volume-rclone.socket systemctl restart docker Or run the service directly: - run systemctl daemon-reload to let systemd pick up new config - run systemctl enable docker-volume-rclone.service to make the new service start automatically when you power on your machine. - run systemctl start docker-volume-rclone.service to start the service now. - run systemctl restart docker to restart docker daemon and let it detect the new plugin socket. Note that this step is not needed in managed mode where docker knows about plugin state changes. The two methods are equivalent from the user perspective, but I personally prefer socket activation. Troubleshooting You can see managed plugin settings with docker plugin list docker plugin inspect rclone Note that docker (including latest 20.10.7) will not show actual values of args, just the defaults. Use journalctl --unit docker to see managed plugin output as part of the docker daemon log. Note that docker reflects plugin lines as errors but their actual level can be seen from encapsulated message string. You will usually install the latest version of managed plugin for your platform. Use the following commands to print the actual installed version: PLUGID=$(docker plugin list --no-trunc | awk '/rclone/{print$1}') sudo runc --root /run/docker/runtime-runc/plugins.moby exec $PLUGID rclone version You can even use runc to run shell inside the plugin container: sudo runc --root /run/docker/runtime-runc/plugins.moby exec --tty $PLUGID bash Also you can use curl to check the plugin socket connectivity: docker plugin list --no-trunc PLUGID=123abc... sudo curl -H Content-Type:application/json -XPOST -d {} --unix-socket /run/docker/plugins/$PLUGID/rclone.sock http://localhost/Plugin.Activate though this is rarely needed. If the plugin fails to work properly, and only as a last resort after you tried diagnosing with the above methods, you can try clearing the state of the plugin. Note that all existing rclone docker volumes will probably have to be recreated. This might be needed because a reinstall don't cleanup existing state files to allow for easy restoration, as stated above. docker plugin disable rclone # disable the plugin to ensure no interference sudo rm /var/lib/docker-plugins/rclone/cache/docker-plugin.state # removing the plugin state docker plugin enable rclone # re-enable the plugin afterward Caveats Finally I'd like to mention a caveat with updating volume settings. Docker CLI does not have a dedicated command like docker volume update. It may be tempting to invoke docker volume create with updated options on existing volume, but there is a gotcha. The command will do nothing, it won't even return an error. I hope that docker maintainers will fix this some day. In the meantime be aware that you must remove your volume before recreating it with new settings: docker volume remove my_vol docker volume create my_vol -d rclone -o opt1=new_val1 ... and verify that settings did update: docker volume list docker volume inspect my_vol If docker refuses to remove the volume, you should find containers or swarm services that use it and stop them first. Bisync bisync is considered an advanced command, so use with care. Make sure you have read and understood the entire manual (especially the Limitations section) before using, or data loss can result. Questions can be asked in the Rclone Forum. Getting started - Install rclone and setup your remotes. - Bisync will create its working directory at ~/.cache/rclone/bisync on Linux, /Users/yourusername/Library/Caches/rclone/bisync on Mac, or C:\Users\MyLogin\AppData\Local\rclone\bisync on Windows. Make sure that this location is writable. - Run bisync with the --resync flag, specifying the paths to the local and remote sync directory roots. - For successive sync runs, leave off the --resync flag. (Important!) - Consider using a filters file for excluding unnecessary files and directories from the sync. - Consider setting up the --check-access feature for safety. - On Linux or Mac, consider setting up a crontab entry. bisync can safely run in concurrent cron jobs thanks to lock files it maintains. For example, your first command might look like this: rclone bisync remote1:path1 remote2:path2 --create-empty-src-dirs --compare size,modtime,checksum --slow-hash-sync-only --resilient -MvP --drive-skip-gdocs --fix-case --resync --dry-run If all looks good, run it again without --dry-run. After that, remove --resync as well. Here is a typical run log (with timestamps removed for clarity): rclone bisync /testdir/path1/ /testdir/path2/ --verbose INFO : Synching Path1 "/testdir/path1/" with Path2 "/testdir/path2/" INFO : Path1 checking for diffs INFO : - Path1 File is new - file11.txt INFO : - Path1 File is newer - file2.txt INFO : - Path1 File is newer - file5.txt INFO : - Path1 File is newer - file7.txt INFO : - Path1 File was deleted - file4.txt INFO : - Path1 File was deleted - file6.txt INFO : - Path1 File was deleted - file8.txt INFO : Path1: 7 changes: 1 new, 3 newer, 0 older, 3 deleted INFO : Path2 checking for diffs INFO : - Path2 File is new - file10.txt INFO : - Path2 File is newer - file1.txt INFO : - Path2 File is newer - file5.txt INFO : - Path2 File is newer - file6.txt INFO : - Path2 File was deleted - file3.txt INFO : - Path2 File was deleted - file7.txt INFO : - Path2 File was deleted - file8.txt INFO : Path2: 7 changes: 1 new, 3 newer, 0 older, 3 deleted INFO : Applying changes INFO : - Path1 Queue copy to Path2 - /testdir/path2/file11.txt INFO : - Path1 Queue copy to Path2 - /testdir/path2/file2.txt INFO : - Path2 Queue delete - /testdir/path2/file4.txt NOTICE: - WARNING New or changed in both paths - file5.txt NOTICE: - Path1 Renaming Path1 copy - /testdir/path1/file5.txt..path1 NOTICE: - Path1 Queue copy to Path2 - /testdir/path2/file5.txt..path1 NOTICE: - Path2 Renaming Path2 copy - /testdir/path2/file5.txt..path2 NOTICE: - Path2 Queue copy to Path1 - /testdir/path1/file5.txt..path2 INFO : - Path2 Queue copy to Path1 - /testdir/path1/file6.txt INFO : - Path1 Queue copy to Path2 - /testdir/path2/file7.txt INFO : - Path2 Queue copy to Path1 - /testdir/path1/file1.txt INFO : - Path2 Queue copy to Path1 - /testdir/path1/file10.txt INFO : - Path1 Queue delete - /testdir/path1/file3.txt INFO : - Path2 Do queued copies to - Path1 INFO : - Path1 Do queued copies to - Path2 INFO : - Do queued deletes on - Path1 INFO : - Do queued deletes on - Path2 INFO : Updating listings INFO : Validating listings for Path1 "/testdir/path1/" vs Path2 "/testdir/path2/" INFO : Bisync successful Command line syntax $ rclone bisync --help Usage: rclone bisync remote1:path1 remote2:path2 [flags] Positional arguments: Path1, Path2 Local path, or remote storage with ':' plus optional path. Type 'rclone listremotes' for list of configured remotes. Optional Flags: --backup-dir1 string --backup-dir for Path1. Must be a non-overlapping path on the same remote. --backup-dir2 string --backup-dir for Path2. Must be a non-overlapping path on the same remote. --check-access Ensure expected RCLONE_TEST files are found on both Path1 and Path2 filesystems, else abort. --check-filename string Filename for --check-access (default: RCLONE_TEST) --check-sync string Controls comparison of final listings: true|false|only (default: true) (default "true") --compare string Comma-separated list of bisync-specific compare options ex. 'size,modtime,checksum' (default: 'size,modtime') --conflict-loser ConflictLoserAction Action to take on the loser of a sync conflict (when there is a winner) or on both files (when there is no winner): , num, pathname, delete (default: num) --conflict-resolve string Automatically resolve conflicts by preferring the version that is: none, path1, path2, newer, older, larger, smaller (default: none) (default "none") --conflict-suffix string Suffix to use when renaming a --conflict-loser. Can be either one string or two comma-separated strings to assign different suffixes to Path1/Path2. (default: 'conflict') --create-empty-src-dirs Sync creation and deletion of empty directories. (Not compatible with --remove-empty-dirs) --download-hash Compute hash by downloading when otherwise unavailable. (warning: may be slow and use lots of data!) --filters-file string Read filtering patterns from a file --force Bypass --max-delete safety check and run the sync. Consider using with --verbose -h, --help help for bisync --ignore-listing-checksum Do not use checksums for listings (add --ignore-checksum to additionally skip post-copy checksum checks) --max-lock Duration Consider lock files older than this to be expired (default: 0 (never expire)) (minimum: 2m) (default 0s) --no-cleanup Retain working files (useful for troubleshooting and testing). --no-slow-hash Ignore listing checksums only on backends where they are slow --recover Automatically recover from interruptions without requiring --resync. --remove-empty-dirs Remove ALL empty directories at the final cleanup step. --resilient Allow future runs to retry after certain less-serious errors, instead of requiring --resync. -1, --resync Performs the resync run. Equivalent to --resync-mode path1. Consider using --verbose or --dry-run first. --resync-mode string During resync, prefer the version that is: path1, path2, newer, older, larger, smaller (default: path1 if --resync, otherwise none for no resync.) (default "none") --retries int Retry operations this many times if they fail (requires --resilient). (default 3) --retries-sleep Duration Interval between retrying operations if they fail, e.g. 500ms, 60s, 5m (0 to disable) (default 0s) --slow-hash-sync-only Ignore slow checksums for listings and deltas, but still consider them during sync calls. --workdir string Use custom working dir - useful for testing. (default: {WORKDIR}) --max-delete PERCENT Safety check on maximum percentage of deleted files allowed. If exceeded, the bisync run will abort. (default: 50%) -n, --dry-run Go through the motions - No files are copied/deleted. -v, --verbose Increases logging verbosity. May be specified more than once for more details. Arbitrary rclone flags may be specified on the bisync command line, for example rclone bisync ./testdir/path1/ gdrive:testdir/path2/ --drive-skip-gdocs -v -v --timeout 10s Note that interactions of various rclone flags with bisync process flow has not been fully tested yet. Paths Path1 and Path2 arguments may be references to any mix of local directory paths (absolute or relative), UNC paths (//server/share/path), Windows drive paths (with a drive letter and :) or configured remotes with optional subdirectory paths. Cloud references are distinguished by having a : in the argument (see Windows support below). Path1 and Path2 are treated equally, in that neither has priority for file changes (except during --resync), and access efficiency does not change whether a remote is on Path1 or Path2. The listings in bisync working directory (default: ~/.cache/rclone/bisync) are named based on the Path1 and Path2 arguments so that separate syncs to individual directories within the tree may be set up, e.g.: path_to_local_tree..dropbox_subdir.lst. Any empty directories after the sync on both the Path1 and Path2 filesystems are not deleted by default, unless --create-empty-src-dirs is specified. If the --remove-empty-dirs flag is specified, then both paths will have ALL empty directories purged as the last step in the process. Command-line flags --resync This will effectively make both Path1 and Path2 filesystems contain a matching superset of all files. By default, Path2 files that do not exist in Path1 will be copied to Path1, and the process will then copy the Path1 tree to Path2. The --resync sequence is roughly equivalent to the following (but see --resync-mode for other options): rclone copy Path2 Path1 --ignore-existing [--create-empty-src-dirs] rclone copy Path1 Path2 [--create-empty-src-dirs] The base directories on both Path1 and Path2 filesystems must exist or bisync will fail. This is required for safety - that bisync can verify that both paths are valid. When using --resync, a newer version of a file on the Path2 filesystem will (by default) be overwritten by the Path1 filesystem version. (Note that this is NOT entirely symmetrical, and more symmetrical options can be specified with the --resync-mode flag.) Carefully evaluate deltas using --dry-run. For a resync run, one of the paths may be empty (no files in the path tree). The resync run should result in files on both paths, else a normal non-resync run will fail. For a non-resync run, either path being empty (no files in the tree) fails with Empty current PathN listing. Cannot sync to an empty directory: X.pathN.lst This is a safety check that an unexpected empty path does not result in deleting everything in the other path. Note that --resync implies --resync-mode path1 unless a different --resync-mode is explicitly specified. It is not necessary to use both the --resync and --resync-mode flags -- either one is sufficient without the other. Note: --resync (including --resync-mode) should only be used under three specific (rare) circumstances: 1. It is your first bisync run (between these two paths) 2. You've just made changes to your bisync settings (such as editing the contents of your --filters-file) 3. There was an error on the prior run, and as a result, bisync now requires --resync to recover The rest of the time, you should omit --resync. The reason is because --resync will only copy (not sync) each side to the other. Therefore, if you included --resync for every bisync run, it would never be possible to delete a file -- the deleted file would always keep reappearing at the end of every run (because it's being copied from the other side where it still exists). Similarly, renaming a file would always result in a duplicate copy (both old and new name) on both sides. If you find that frequent interruptions from #3 are an issue, rather than automatically running --resync, the recommended alternative is to use the --resilient, --recover, and --conflict-resolve flags, (along with Graceful Shutdown mode, when needed) for a very robust "set-it-and-forget-it" bisync setup that can automatically bounce back from almost any interruption it might encounter. Consider adding something like the following: --resilient --recover --max-lock 2m --conflict-resolve newer --resync-mode CHOICE In the event that a file differs on both sides during a --resync, --resync-mode controls which version will overwrite the other. The supported options are similar to --conflict-resolve. For all of the following options, the version that is kept is referred to as the "winner", and the version that is overwritten (deleted) is referred to as the "loser". The options are named after the "winner": - path1 - (the default) - the version from Path1 is unconditionally considered the winner (regardless of modtime and size, if any). This can be useful if one side is more trusted or up-to-date than the other, at the time of the --resync. - path2 - same as path1, except the path2 version is considered the winner. - newer - the newer file (by modtime) is considered the winner, regardless of which side it came from. This may result in having a mix of some winners from Path1, and some winners from Path2. (The implementation is analogous to running rclone copy --update in both directions.) - older - same as newer, except the older file is considered the winner, and the newer file is considered the loser. - larger - the larger file (by size) is considered the winner (regardless of modtime, if any). This can be a useful option for remotes without modtime support, or with the kinds of files (such as logs) that tend to grow but not shrink, over time. - smaller - the smaller file (by size) is considered the winner (regardless of modtime, if any). For all of the above options, note the following: - If either of the underlying remotes lacks support for the chosen method, it will be ignored and will fall back to the default of path1. (For example, if --resync-mode newer is set, but one of the paths uses a remote that doesn't support modtime.) - If a winner can't be determined because the chosen method's attribute is missing or equal, it will be ignored, and bisync will instead try to determine whether the files differ by looking at the other --compare methods in effect. (For example, if --resync-mode newer is set, but the Path1 and Path2 modtimes are identical, bisync will compare the sizes.) If bisync concludes that they differ, preference is given to whichever is the "source" at that moment. (In practice, this gives a slight advantage to Path2, as the 2to1 copy comes before the 1to2 copy.) If the files do not differ, nothing is copied (as both sides are already correct). - These options apply only to files that exist on both sides (with the same name and relative path). Files that exist only on one side and not the other are always copied to the other, during --resync (this is one of the main differences between resync and non-resync runs.). - --conflict-resolve, --conflict-loser, and --conflict-suffix do not apply during --resync, and unlike these flags, nothing is renamed during --resync. When a file differs on both sides during --resync, one version always overwrites the other (much like in rclone copy.) (Consider using --backup-dir to retain a backup of the losing version.) - Unlike for --conflict-resolve, --resync-mode none is not a valid option (or rather, it will be interpreted as "no resync", unless --resync has also been specified, in which case it will be ignored.) - Winners and losers are decided at the individual file-level only (there is not currently an option to pick an entire winning directory atomically, although the path1 and path2 options typically produce a similar result.) - To maintain backward-compatibility, the --resync flag implies --resync-mode path1 unless a different --resync-mode is explicitly specified. Similarly, all --resync-mode options (except none) imply --resync, so it is not necessary to use both the --resync and --resync-mode flags simultaneously -- either one is sufficient without the other. --check-access Access check files are an additional safety measure against data loss. bisync will ensure it can find matching RCLONE_TEST files in the same places in the Path1 and Path2 filesystems. RCLONE_TEST files are not generated automatically. For --check-access to succeed, you must first either: A) Place one or more RCLONE_TEST files in both systems, or B) Set --check-filename to a filename already in use in various locations throughout your sync'd fileset. Recommended methods for A) include: - rclone touch Path1/RCLONE_TEST (create a new file) - rclone copyto Path1/RCLONE_TEST Path2/RCLONE_TEST (copy an existing file) - rclone copy Path1/RCLONE_TEST Path2/RCLONE_TEST --include "RCLONE_TEST" (copy multiple files at once, recursively) - create the files manually (outside of rclone) - run bisync once without --check-access to set matching files on both filesystems will also work, but is not preferred, due to potential for user error (you are temporarily disabling the safety feature). Note that --check-access is still enforced on --resync, so bisync --resync --check-access will not work as a method of initially setting the files (this is to ensure that bisync can't inadvertently circumvent its own safety switch.) Time stamps and file contents for RCLONE_TEST files are not important, just the names and locations. If you have symbolic links in your sync tree it is recommended to place RCLONE_TEST files in the linked-to directory tree to protect against bisync assuming a bunch of deleted files if the linked-to tree should not be accessible. See also the --check-filename flag. --check-filename Name of the file(s) used in access health validation. The default --check-filename is RCLONE_TEST. One or more files having this filename must exist, synchronized between your source and destination filesets, in order for --check-access to succeed. See --check-access for additional details. --compare As of v1.66, bisync fully supports comparing based on any combination of size, modtime, and checksum (lifting the prior restriction on backends without modtime support.) By default (without the --compare flag), bisync inherits the same comparison options as sync (that is: size and modtime by default, unless modified with flags such as --checksum or --size-only.) If the --compare flag is set, it will override these defaults. This can be useful if you wish to compare based on combinations not currently supported in sync, such as comparing all three of size AND modtime AND checksum simultaneously (or just modtime AND checksum). --compare takes a comma-separated list, with the currently supported values being size, modtime, and checksum. For example, if you want to compare size and checksum, but not modtime, you would do: --compare size,checksum Or if you want to compare all three: --compare size,modtime,checksum --compare overrides any conflicting flags. For example, if you set the conflicting flags --compare checksum --size-only, --size-only will be ignored, and bisync will compare checksum and not size. To avoid confusion, it is recommended to use either --compare or the normal sync flags, but not both. If --compare includes checksum and both remotes support checksums but have no hash types in common with each other, checksums will be considered only for comparisons within the same side (to determine what has changed since the prior sync), but not for comparisons against the opposite side. If one side supports checksums and the other does not, checksums will only be considered on the side that supports them. When comparing with checksum and/or size without modtime, bisync cannot determine whether a file is newer or older -- only whether it is changed or unchanged. (If it is changed on both sides, bisync still does the standard equality-check to avoid declaring a sync conflict unless it absolutely has to.) It is recommended to do a --resync when changing --compare settings, as otherwise your prior listing files may not contain the attributes you wish to compare (for example, they will not have stored checksums if you were not previously comparing checksums.) --ignore-listing-checksum When --checksum or --compare checksum is set, bisync will retrieve (or generate) checksums (for backends that support them) when creating the listings for both paths, and store the checksums in the listing files. --ignore-listing-checksum will disable this behavior, which may speed things up considerably, especially on backends (such as local) where hashes must be computed on the fly instead of retrieved. Please note the following: - As of v1.66, --ignore-listing-checksum is now automatically set when neither --checksum nor --compare checksum are in use (as the checksums would not be used for anything.) - --ignore-listing-checksum is NOT the same as --ignore-checksum, and you may wish to use one or the other, or both. In a nutshell: --ignore-listing-checksum controls whether checksums are considered when scanning for diffs, while --ignore-checksum controls whether checksums are considered during the copy/sync operations that follow, if there ARE diffs. - Unless --ignore-listing-checksum is passed, bisync currently computes hashes for one path even when there's no common hash with the other path (for example, a crypt remote.) This can still be beneficial, as the hashes will still be used to detect changes within the same side (if --checksum or --compare checksum is set), even if they can't be used to compare against the opposite side. - If you wish to ignore listing checksums only on remotes where they are slow to compute, consider using --no-slow-hash (or --slow-hash-sync-only) instead of --ignore-listing-checksum. - If --ignore-listing-checksum is used simultaneously with --compare checksum (or --checksum), checksums will be ignored for bisync deltas, but still considered during the sync operations that follow (if deltas are detected based on modtime and/or size.) --no-slow-hash On some remotes (notably local), checksums can dramatically slow down a bisync run, because hashes cannot be stored and need to be computed in real-time when they are requested. On other remotes (such as drive), they add practically no time at all. The --no-slow-hash flag will automatically skip checksums on remotes where they are slow, while still comparing them on others (assuming --compare includes checksum.) This can be useful when one of your bisync paths is slow but you still want to check checksums on the other, for a more robust sync. --slow-hash-sync-only Same as --no-slow-hash, except slow hashes are still considered during sync calls. They are still NOT considered for determining deltas, nor or they included in listings. They are also skipped during --resync. The main use case for this flag is when you have a large number of files, but relatively few of them change from run to run -- so you don't want to check your entire tree every time (it would take too long), but you still want to consider checksums for the smaller group of files for which a modtime or size change was detected. Keep in mind that this speed savings comes with a safety trade-off: if a file's content were to change without a change to its modtime or size, bisync would not detect it, and it would not be synced. --slow-hash-sync-only is only useful if both remotes share a common hash type (if they don't, bisync will automatically fall back to --no-slow-hash.) Both --no-slow-hash and --slow-hash-sync-only have no effect without --compare checksum (or --checksum). --download-hash If --download-hash is set, bisync will use best efforts to obtain an MD5 checksum by downloading and computing on-the-fly, when checksums are not otherwise available (for example, a remote that doesn't support them.) Note that since rclone has to download the entire file, this may dramatically slow down your bisync runs, and is also likely to use a lot of data, so it is probably not practical for bisync paths with a large total file size. However, it can be a good option for syncing small-but-important files with maximum accuracy (for example, a source code repo on a crypt remote.) An additional advantage over methods like cryptcheck is that the original file is not required for comparison (for example, --download-hash can be used to bisync two different crypt remotes with different passwords.) When --download-hash is set, bisync still looks for more efficient checksums first, and falls back to downloading only when none are found. It takes priority over conflicting flags such as --no-slow-hash. --download-hash is not suitable for Google Docs and other files of unknown size, as their checksums would change from run to run (due to small variances in the internals of the generated export file.) Therefore, bisync automatically skips --download-hash for files with a size less than 0. See also: Hasher backend, cryptcheck command, rclone check --download option, md5sum command --max-delete As a safety check, if greater than the --max-delete percent of files were deleted on either the Path1 or Path2 filesystem, then bisync will abort with a warning message, without making any changes. The default --max-delete is 50%. One way to trigger this limit is to rename a directory that contains more than half of your files. This will appear to bisync as a bunch of deleted files and a bunch of new files. This safety check is intended to block bisync from deleting all of the files on both filesystems due to a temporary network access issue, or if the user had inadvertently deleted the files on one side or the other. To force the sync, either set a different delete percentage limit, e.g. --max-delete 75 (allows up to 75% deletion), or use --force to bypass the check. Also see the all files changed check. --filters-file By using rclone filter features you can exclude file types or directory sub-trees from the sync. See the bisync filters section and generic --filter-from documentation. An example filters file contains filters for non-allowed files for syncing with Dropbox. If you make changes to your filters file then bisync requires a run with --resync. This is a safety feature, which prevents existing files on the Path1 and/or Path2 side from seeming to disappear from view (since they are excluded in the new listings), which would fool bisync into seeing them as deleted (as compared to the prior run listings), and then bisync would proceed to delete them for real. To block this from happening, bisync calculates an MD5 hash of the filters file and stores the hash in a .md5 file in the same place as your filters file. On the next run with --filters-file set, bisync re-calculates the MD5 hash of the current filters file and compares it to the hash stored in the .md5 file. If they don't match, the run aborts with a critical error and thus forces you to do a --resync, likely avoiding a disaster. --conflict-resolve CHOICE In bisync, a "conflict" is a file that is new or changed on both sides (relative to the prior run) AND is not currently identical on both sides. --conflict-resolve controls how bisync handles such a scenario. The currently supported options are: - none - (the default) - do not attempt to pick a winner, keep and rename both files according to --conflict-loser and --conflict-suffix settings. For example, with the default settings, file.txt on Path1 is renamed file.txt.conflict1 and file.txt on Path2 is renamed file.txt.conflict2. Both are copied to the opposite path during the run, so both sides end up with a copy of both files. (As none is the default, it is not necessary to specify --conflict-resolve none -- you can just omit the flag.) - newer - the newer file (by modtime) is considered the winner and is copied without renaming. The older file (the "loser") is handled according to --conflict-loser and --conflict-suffix settings (either renamed or deleted.) For example, if file.txt on Path1 is newer than file.txt on Path2, the result on both sides (with other default settings) will be file.txt (winner from Path1) and file.txt.conflict1 (loser from Path2). - older - same as newer, except the older file is considered the winner, and the newer file is considered the loser. - larger - the larger file (by size) is considered the winner (regardless of modtime, if any). - smaller - the smaller file (by size) is considered the winner (regardless of modtime, if any). - path1 - the version from Path1 is unconditionally considered the winner (regardless of modtime and size, if any). This can be useful if one side is usually more trusted or up-to-date than the other. - path2 - same as path1, except the path2 version is considered the winner. For all of the above options, note the following: - If either of the underlying remotes lacks support for the chosen method, it will be ignored and fall back to none. (For example, if --conflict-resolve newer is set, but one of the paths uses a remote that doesn't support modtime.) - If a winner can't be determined because the chosen method's attribute is missing or equal, it will be ignored and fall back to none. (For example, if --conflict-resolve newer is set, but the Path1 and Path2 modtimes are identical, even if the sizes may differ.) - If the file's content is currently identical on both sides, it is not considered a "conflict", even if new or changed on both sides since the prior sync. (For example, if you made a change on one side and then synced it to the other side by other means.) Therefore, none of the conflict resolution flags apply in this scenario. - The conflict resolution flags do not apply during a --resync, as there is no "prior run" to speak of (but see --resync-mode for similar options.) --conflict-loser CHOICE --conflict-loser determines what happens to the "loser" of a sync conflict (when --conflict-resolve determines a winner) or to both files (when there is no winner.) The currently supported options are: - num - (the default) - auto-number the conflicts by automatically appending the next available number to the --conflict-suffix, in chronological order. For example, with the default settings, the first conflict for file.txt will be renamed file.txt.conflict1. If file.txt.conflict1 already exists, file.txt.conflict2 will be used instead (etc., up to a maximum of 9223372036854775807 conflicts.) - pathname - rename the conflicts according to which side they came from, which was the default behavior prior to v1.66. For example, with --conflict-suffix path, file.txt from Path1 will be renamed file.txt.path1, and file.txt from Path2 will be renamed file.txt.path2. If two non-identical suffixes are provided (ex. --conflict-suffix cloud,local), the trailing digit is omitted. Importantly, note that with pathname, there is no auto-numbering beyond 2, so if file.txt.path2 somehow already exists, it will be overwritten. Using a dynamic date variable in your --conflict-suffix (see below) is one possible way to avoid this. Note also that conflicts-of-conflicts are possible, if the original conflict is not manually resolved -- for example, if for some reason you edited file.txt.path1 on both sides, and those edits were different, the result would be file.txt.path1.path1 and file.txt.path1.path2 (in addition to file.txt.path2.) - delete - keep the winner only and delete the loser, instead of renaming it. If a winner cannot be determined (see --conflict-resolve for details on how this could happen), delete is ignored and the default num is used instead (i.e. both versions are kept and renamed, and neither is deleted.) delete is inherently the most destructive option, so use it only with care. For all of the above options, note that if a winner cannot be determined (see --conflict-resolve for details on how this could happen), or if --conflict-resolve is not in use, both files will be renamed. --conflict-suffix STRING[,STRING] --conflict-suffix controls the suffix that is appended when bisync renames a --conflict-loser (default: conflict). --conflict-suffix will accept either one string or two comma-separated strings to assign different suffixes to Path1 vs. Path2. This may be helpful later in identifying the source of the conflict. (For example, --conflict-suffix dropboxconflict,laptopconflict) With --conflict-loser num, a number is always appended to the suffix. With --conflict-loser pathname, a number is appended only when one suffix is specified (or when two identical suffixes are specified.) i.e. with --conflict-loser pathname, all of the following would produce exactly the same result: --conflict-suffix path --conflict-suffix path,path --conflict-suffix path1,path2 Suffixes may be as short as 1 character. By default, the suffix is appended after any other extensions (ex. file.jpg.conflict1), however, this can be changed with the --suffix-keep-extension flag (i.e. to instead result in file.conflict1.jpg). --conflict-suffix supports several dynamic date variables when enclosed in curly braces as globs. This can be helpful to track the date and/or time that each conflict was handled by bisync. For example: --conflict-suffix {DateOnly}-conflict // result: myfile.txt.2006-01-02-conflict1 All of the formats described here (go Time.Layout constants) and here (go Time.Format examples) are supported, but take care to ensure that your chosen format does not use any characters that are illegal on your remotes (for example, macOS does not allow colons in filenames, and slashes are also best avoided as they are often interpreted as directory separators.) To address this particular issue, an additional {MacFriendlyTime} (or just {mac}) option is supported, which results in 2006-01-02 0304PM. Note that --conflict-suffix is entirely separate from rclone's main --sufix flag. This is intentional, as users may wish to use both flags simultaneously, if also using --backup-dir. Finally, note that the default in bisync prior to v1.66 was to rename conflicts with ..path1 and ..path2 (with two periods, and path instead of conflict.) Bisync now defaults to a single dot instead of a double dot, but additional dots can be added by including them in the specified suffix string. For example, for behavior equivalent to the previous default, use: [--conflict-resolve none] --conflict-loser pathname --conflict-suffix .path --check-sync Enabled by default, the check-sync function checks that all of the same files exist in both the Path1 and Path2 history listings. This check-sync integrity check is performed at the end of the sync run by default. Any untrapped failing copy/deletes between the two paths might result in differences between the two listings and in the untracked file content differences between the two paths. A resync run would correct the error. Note that the default-enabled integrity check locally executes a load of both the final Path1 and Path2 listings, and thus adds to the run time of a sync. Using --check-sync=false will disable it and may significantly reduce the sync run times for very large numbers of files. The check may be run manually with --check-sync=only. It runs only the integrity check and terminates without actually syncing. Note that currently, --check-sync only checks listing snapshots and NOT the actual files on the remotes. Note also that the listing snapshots will not know about any changes that happened during or after the latest bisync run, as those will be discovered on the next run. Therefore, while listings should always match each other at the end of a bisync run, it is expected that they will not match the underlying remotes, nor will the remotes match each other, if there were changes during or after the run. This is normal, and any differences will be detected and synced on the next run. For a robust integrity check of the current state of the remotes (as opposed to just their listing snapshots), consider using check (or cryptcheck, if at least one path is a crypt remote) instead of --check-sync, keeping in mind that differences are expected if files changed during or after your last bisync run. For example, a possible sequence could look like this: 1. Normally scheduled bisync run: rclone bisync Path1 Path2 -MPc --check-access --max-delete 10 --filters-file /path/to/filters.txt -v --no-cleanup --ignore-listing-checksum --disable ListR --checkers=16 --drive-pacer-min-sleep=10ms --create-empty-src-dirs --resilient 2. Periodic independent integrity check (perhaps scheduled nightly or weekly): rclone check -MvPc Path1 Path2 --filter-from /path/to/filters.txt 3. If diffs are found, you have some choices to correct them. If one side is more up-to-date and you want to make the other side match it, you could run: rclone sync Path1 Path2 --filter-from /path/to/filters.txt --create-empty-src-dirs -MPc -v (or switch Path1 and Path2 to make Path2 the source-of-truth) Or, if neither side is totally up-to-date, you could run a --resync to bring them back into agreement (but remember that this could cause deleted files to re-appear.) *Note also that rclone check does not currently include empty directories, so if you want to know if any empty directories are out of sync, consider alternatively running the above rclone sync command with --dry-run added. See also: Concurrent modifications, --resilient --resilient By default, most errors or interruptions will cause bisync to abort and require --resync to recover. This is a safety feature, to prevent bisync from running again until a user checks things out. However, in some cases, bisync can go too far and enforce a lockout when one isn't actually necessary, like for certain less-serious errors that might resolve themselves on the next run. When --resilient is specified, bisync tries its best to recover and self-correct, and only requires --resync as a last resort when a human's involvement is absolutely necessary. The intended use case is for running bisync as a background process (such as via scheduled cron). When using --resilient mode, bisync will still report the error and abort, however it will not lock out future runs -- allowing the possibility of retrying at the next normally scheduled time, without requiring a --resync first. Examples of such retryable errors include access test failures, missing listing files, and filter change detections. These safety features will still prevent the current run from proceeding -- the difference is that if conditions have improved by the time of the next run, that next run will be allowed to proceed. Certain more serious errors will still enforce a --resync lockout, even in --resilient mode, to prevent data loss. Behavior of --resilient may change in a future version. (See also: --recover, --max-lock, Graceful Shutdown) --recover If --recover is set, in the event of a sudden interruption or other un-graceful shutdown, bisync will attempt to automatically recover on the next run, instead of requiring --resync. Bisync is able to recover robustly by keeping one "backup" listing at all times, representing the state of both paths after the last known successful sync. Bisync can then compare the current state with this snapshot to determine which changes it needs to retry. Changes that were synced after this snapshot (during the run that was later interrupted) will appear to bisync as if they are "new or changed on both sides", but in most cases this is not a problem, as bisync will simply do its usual "equality check" and learn that no action needs to be taken on these files, since they are already identical on both sides. In the rare event that a file is synced successfully during a run that later aborts, and then that same file changes AGAIN before the next run, bisync will think it is a sync conflict, and handle it accordingly. (From bisync's perspective, the file has changed on both sides since the last trusted sync, and the files on either side are not currently identical.) Therefore, --recover carries with it a slightly increased chance of having conflicts -- though in practice this is pretty rare, as the conditions required to cause it are quite specific. This risk can be reduced by using bisync's "Graceful Shutdown" mode (triggered by sending SIGINT or Ctrl+C), when you have the choice, instead of forcing a sudden termination. --recover and --resilient are similar, but distinct -- the main difference is that --resilient is about retrying, while --recover is about recovering. Most users will probably want both. --resilient allows retrying when bisync has chosen to abort itself due to safety features such as failing --check-access or detecting a filter change. --resilient does not cover external interruptions such as a user shutting down their computer in the middle of a sync -- that is what --recover is for. --max-lock Bisync uses lock files as a safety feature to prevent interference from other bisync runs while it is running. Bisync normally removes these lock files at the end of a run, but if bisync is abruptly interrupted, these files will be left behind. By default, they will lock out all future runs, until the user has a chance to manually check things out and remove the lock. As an alternative, --max-lock can be used to make them automatically expire after a certain period of time, so that future runs are not locked out forever, and auto-recovery is possible. --max-lock can be any duration 2m or greater (or 0 to disable). If set, lock files older than this will be considered "expired", and future runs will be allowed to disregard them and proceed. (Note that the --max-lock duration must be set by the process that left the lock file -- not the later one interpreting it.) If set, bisync will also "renew" these lock files every --max-lock minus one minute throughout a run, for extra safety. (For example, with --max-lock 5m, bisync would renew the lock file (for another 5 minutes) every 4 minutes until the run has completed.) In other words, it should not be possible for a lock file to pass its expiration time while the process that created it is still running -- and you can therefore be reasonably sure that any expired lock file you may find was left there by an interrupted run, not one that is still running and just taking awhile. If --max-lock is 0 or not set, the default is that lock files will never expire, and will block future runs (of these same two bisync paths) indefinitely. For maximum resilience from disruptions, consider setting a relatively short duration like --max-lock 2m along with --resilient and --recover, and a relatively frequent cron schedule. The result will be a very robust "set-it-and-forget-it" bisync run that can automatically bounce back from almost any interruption it might encounter, without requiring the user to get involved and run a --resync. (See also: Graceful Shutdown mode) --backup-dir1 and --backup-dir2 As of v1.66, --backup-dir is supported in bisync. Because --backup-dir must be a non-overlapping path on the same remote, Bisync has introduced new --backup-dir1 and --backup-dir2 flags to support separate backup-dirs for Path1 and Path2 (bisyncing between different remotes with --backup-dir would not otherwise be possible.) --backup-dir1 and --backup-dir2 can use different remotes from each other, but --backup-dir1 must use the same remote as Path1, and --backup-dir2 must use the same remote as Path2. Each backup directory must not overlap its respective bisync Path without being excluded by a filter rule. The standard --backup-dir will also work, if both paths use the same remote (but note that deleted files from both paths would be mixed together in the same dir). If either --backup-dir1 and --backup-dir2 are set, they will override --backup-dir. Example: rclone bisync /Users/someuser/some/local/path/Bisync gdrive:Bisync --backup-dir1 /Users/someuser/some/local/path/BackupDir --backup-dir2 gdrive:BackupDir --suffix -2023-08-26 --suffix-keep-extension --check-access --max-delete 10 --filters-file /Users/someuser/some/local/path/bisync_filters.txt --no-cleanup --ignore-listing-checksum --checkers=16 --drive-pacer-min-sleep=10ms --create-empty-src-dirs --resilient -MvP --drive-skip-gdocs --fix-case In this example, if the user deletes a file in /Users/someuser/some/local/path/Bisync, bisync will propagate the delete to the other side by moving the corresponding file from gdrive:Bisync to gdrive:BackupDir. If the user deletes a file from gdrive:Bisync, bisync moves it from /Users/someuser/some/local/path/Bisync to /Users/someuser/some/local/path/BackupDir. In the event of a rename due to a sync conflict, the rename is not considered a delete, unless a previous conflict with the same name already exists and would get overwritten. See also: --suffix, --suffix-keep-extension Operation Runtime flow details bisync retains the listings of the Path1 and Path2 filesystems from the prior run. On each successive run it will: - list files on path1 and path2, and check for changes on each side. Changes include New, Newer, Older, and Deleted files. - Propagate changes on path1 to path2, and vice-versa. Safety measures - Lock file prevents multiple simultaneous runs when taking a while. This can be particularly useful if bisync is run by cron scheduler. - Handle change conflicts non-destructively by creating .conflict1, .conflict2, etc. file versions, according to --conflict-resolve, --conflict-loser, and --conflict-suffix settings. - File system access health check using RCLONE_TEST files (see the --check-access flag). - Abort on excessive deletes - protects against a failed listing being interpreted as all the files were deleted. See the --max-delete and --force flags. - If something evil happens, bisync goes into a safe state to block damage by later runs. (See Error Handling) Normal sync checks ------------------------------------------------------------------------ Type Description Result Implementation --------- ---------------------------- --------------- ----------------- Path2 new File is new on Path2, does Path2 version rclone copy Path2 not exist on Path1 survives to Path1 Path2 File is newer on Path2, Path2 version rclone copy Path2 newer unchanged on Path1 survives to Path1 Path2 File is deleted on Path2, File is deleted rclone delete deleted unchanged on Path1 Path1 Path1 new File is new on Path1, does Path1 version rclone copy Path1 not exist on Path2 survives to Path2 Path1 File is newer on Path1, Path1 version rclone copy Path1 newer unchanged on Path2 survives to Path2 Path1 File is older on Path1, Path1 version rclone copy Path1 older unchanged on Path2 survives to Path2 Path2 File is older on Path2, Path2 version rclone copy Path2 older unchanged on Path1 survives to Path1 Path1 File no longer exists on File is deleted rclone delete deleted Path1 Path2 ------------------------------------------------------------------------ Unusual sync checks ------------------------------------------------------------------------------ Type Description Result Implementation ----------------- --------------------- -------------------- ----------------- Path1 new/changed File is new/changed No change None AND Path2 on Path1 AND new/changed AND new/changed on Path2 Path1 == Path2 AND Path1 version is currently identical to Path2 Path1 new AND File is new on Path1 Conflicts handled default: Path2 new AND new on Path2 (and according to rclone copy Path1 version is NOT --conflict-resolve & renamed identical to Path2) --conflict-loser Path2.conflict2 settings file to Path1, rclone copy renamed Path1.conflict1 file to Path2 Path2 newer AND File is newer on Conflicts handled default: Path1 changed Path2 AND also according to rclone copy changed --conflict-resolve & renamed (newer/older/size) on --conflict-loser Path2.conflict2 Path1 (and Path1 settings file to Path1, version is NOT rclone copy identical to Path2) renamed Path1.conflict1 file to Path2 Path2 newer AND File is newer on Path2 version rclone copy Path2 Path1 deleted Path2 AND also survives to Path1 deleted on Path1 Path2 deleted AND File is deleted on Path1 version rclone copy Path1 Path1 changed Path2 AND changed survives to Path2 (newer/older/size) on Path1 Path1 deleted AND File is deleted on Path2 version rclone copy Path2 Path2 changed Path1 AND changed survives to Path1 (newer/older/size) on Path2 ------------------------------------------------------------------------------ As of rclone v1.64, bisync is now better at detecting false positive sync conflicts, which would previously have resulted in unnecessary renames and duplicates. Now, when bisync comes to a file that it wants to rename (because it is new/changed on both sides), it first checks whether the Path1 and Path2 versions are currently identical (using the same underlying function as check.) If bisync concludes that the files are identical, it will skip them and move on. Otherwise, it will create renamed duplicates, as before. This behavior also improves the experience of renaming directories, as a --resync is no longer required, so long as the same change has been made on both sides. All files changed check If all prior existing files on either of the filesystems have changed (e.g. timestamps have changed due to changing the system's timezone) then bisync will abort without making any changes. Any new files are not considered for this check. You could use --force to force the sync (whichever side has the changed timestamp files wins). Alternately, a --resync may be used (Path1 versions will be pushed to Path2). Consider the situation carefully and perhaps use --dry-run before you commit to the changes. Modification times By default, bisync compares files by modification time and size. If you or your application should change the content of a file without changing the modification time and size, then bisync will not notice the change, and thus will not copy it to the other side. As an alternative, consider comparing by checksum (if your remotes support it). See --compare for details. Error handling Certain bisync critical errors, such as file copy/move failing, will result in a bisync lockout of following runs. The lockout is asserted because the sync status and history of the Path1 and Path2 filesystems cannot be trusted, so it is safer to block any further changes until someone checks things out. The recovery is to do a --resync again. It is recommended to use --resync --dry-run --verbose initially and carefully review what changes will be made before running the --resync without --dry-run. Most of these events come up due to an error status from an internal call. On such a critical error the {...}.path1.lst and {...}.path2.lst listing files are renamed to extension .lst-err, which blocks any future bisync runs (since the normal .lst files are not found). Bisync keeps them under bisync subdirectory of the rclone cache directory, typically at ${HOME}/.cache/rclone/bisync/ on Linux. Some errors are considered temporary and re-running the bisync is not blocked. The critical return blocks further bisync runs. See also: --resilient, --recover, --max-lock, Graceful Shutdown Lock file When bisync is running, a lock file is created in the bisync working directory, typically at ~/.cache/rclone/bisync/PATH1..PATH2.lck on Linux. If bisync should crash or hang, the lock file will remain in place and block any further runs of bisync for the same paths. Delete the lock file as part of debugging the situation. The lock file effectively blocks follow-on (e.g., scheduled by cron) runs when the prior invocation is taking a long time. The lock file contains PID of the blocking process, which may help in debug. Lock files can be set to automatically expire after a certain amount of time, using the --max-lock flag. Note that while concurrent bisync runs are allowed, be very cautious that there is no overlap in the trees being synched between concurrent runs, lest there be replicated files, deleted files and general mayhem. Exit codes rclone bisync returns the following codes to calling program: - 0 on a successful run, - 1 for a non-critical failing run (a rerun may be successful), - 2 on syntax or usage error, - 7 for a critically aborted run (requires a --resync to recover). See also the section about exit codes in main docs. Graceful Shutdown Bisync has a "Graceful Shutdown" mode which is activated by sending SIGINT or pressing Ctrl+C during a run. Once triggered, bisync will use best efforts to exit cleanly before the timer runs out. If bisync is in the middle of transferring files, it will attempt to cleanly empty its queue by finishing what it has started but not taking more. If it cannot do so within 30 seconds, it will cancel the in-progress transfers at that point and then give itself a maximum of 60 seconds to wrap up, save its state for next time, and exit. With the -vP flags you will see constant status updates and a final confirmation of whether or not the graceful shutdown was successful. At any point during the "Graceful Shutdown" sequence, a second SIGINT or Ctrl+C will trigger an immediate, un-graceful exit, which will leave things in a messier state. Usually a robust recovery will still be possible if using --recover mode, otherwise you will need to do a --resync. If you plan to use Graceful Shutdown mode, it is recommended to use --resilient and --recover, and it is important to NOT use --inplace, otherwise you risk leaving partially-written files on one side, which may be confused for real files on the next run. Note also that in the event of an abrupt interruption, a lock file will be left behind to block concurrent runs. You will need to delete it before you can proceed with the next run (or wait for it to expire on its own, if using --max-lock.) Limitations Supported backends Bisync is integration-tested against all rclone backends to verify compatibility. Most backends (including all backends not listed below) are deemed fully supported with no known issues. Occasionally, however, these tests reveal issues with particular backends, usually related to a provider-specific limitation beyond rclone's control (for example, disallowed special characters and filename encodings.) The following backends have known issues that need more investigation: - TestGoFile (gofile) - TestBisyncRemoteLocal/all_changed - TestBisyncRemoteLocal/backupdir - TestBisyncRemoteLocal/basic - TestBisyncRemoteLocal/changes - TestBisyncRemoteLocal/check_access - 78 more - Updated: 2025-08-21-010015 The following backends either have not been tested recently or have known issues that are deemed unfixable for the time being: - TestCache (cache) - TestFileLu (filelu) - TestFilesCom (filescom) - TestImageKit (imagekit) - TestJottacloud (jottacloud) - TestLinkbox (linkbox) - TestMailru (mailru) - TestMega (mega) - TestOpenDrive (opendrive) - TestOracleObjectStorage (oracleobjectstorage) - TestPikPak (pikpak) - TestPixeldrain (pixeldrain) - TestProtonDrive (protondrive) - TestPutio (putio) - TestQuatrix (quatrix) - TestS3GCS (s3) - TestBisyncRemoteRemote/extended_filenames - TestS3Rclone (s3) - TestSFTPRsyncNet (sftp) - TestStorj (storj) - TestWebdavInfiniteScale (webdav) - TestWebdavNextcloud (webdav) - TestWebdavOwncloud (webdav) - TestnStorage (netstorage) (more info) The above lists are updated for each stable release of rclone. For test results updated nightly based on the latest beta, visit rclone's integration test status page. Early beta versions of rclone bisync required both underlying backends to support modification times, and refused to run otherwise. This limitation has been lifted as of v1.66, as bisync now supports comparing checksum and/or size instead of (or in addition to) modtime. See --compare for details. Concurrent modifications When using Local, FTP or SFTP remotes with --inplace, rclone does not create temporary files at the destination when copying, and thus if the connection is lost the created file may be corrupt, which will likely propagate back to the original path on the next sync, resulting in data loss. It is therefore recommended to omit --inplace. Files that change during a bisync run may result in data loss. Prior to rclone v1.66, this was commonly seen in highly dynamic environments, where the filesystem was getting hammered by running processes during the sync. As of rclone v1.66, bisync was redesigned to use a "snapshot" model, greatly reducing the risks from changes during a sync. Changes that are not detected during the current sync will now be detected during the following sync, and will no longer cause the entire run to throw a critical error. There is additionally a mechanism to mark files as needing to be internally rechecked next time, for added safety. It should therefore no longer be necessary to sync only at quiet times -- however, note that an error can still occur if a file happens to change at the exact moment it's being read/written by bisync (same as would happen in rclone sync.) (See also: --ignore-checksum, --local-no-check-updated) Empty directories By default, new/deleted empty directories on one path are not propagated to the other side. This is because bisync (and rclone) natively works on files, not directories. However, this can be changed with the --create-empty-src-dirs flag, which works in much the same way as in sync and copy. When used, empty directories created or deleted on one side will also be created or deleted on the other side. The following should be noted: - --create-empty-src-dirs is not compatible with --remove-empty-dirs. Use only one or the other (or neither). - It is not recommended to switch back and forth between --create-empty-src-dirs and the default (no --create-empty-src-dirs) without running -- resync. This is because it may appear as though all directories (not just the empty ones) were created/deleted, when actually you've just toggled between making them visible/invisible to bisync. It looks scarier than it is, but it's still probably best to stick to one or the other, and use --resync when you need to switch. Renamed directories By default, renaming a folder on the Path1 side results in deleting all files on the Path2 side and then copying all files again from Path1 to Path2. Bisync sees this as all files in the old directory name as deleted and all files in the new directory name as new. A recommended solution is to use --track-renames, which is now supported in bisync as of rclone v1.66. Note that --track-renames is not available during --resync, as --resync does not delete anything (--track-renames only supports sync, not copy.) Otherwise, the most effective and efficient method of renaming a directory is to rename it to the same name on both sides. (As of rclone v1.64, a --resync is no longer required after doing so, as bisync will automatically detect that Path1 and Path2 are in agreement.) --fast-list used by default Unlike most other rclone commands, bisync uses --fast-list by default, for backends that support it. In many cases this is desirable, however, there are some scenarios in which bisync could be faster without --fast-list, and there is also a known issue concerning Google Drive users with many empty directories. For now, the recommended way to avoid using --fast-list is to add --disable ListR to all bisync commands. The default behavior may change in a future version. Case (and unicode) sensitivity As of v1.66, case and unicode form differences no longer cause critical errors, and normalization (when comparing between filesystems) is handled according to the same flags and defaults as rclone sync. See the following options (all of which are supported by bisync) to control this behavior more granularly: - --fix-case - --ignore-case-sync - --no-unicode-normalization - --local-unicode-normalization and --local-case-sensitive (caution: these are normally not what you want.) Note that in the (probably rare) event that --fix-case is used AND a file is new/changed on both sides AND the checksums match AND the filename case does not match, the Path1 filename is considered the winner, for the purposes of --fix-case (Path2 will be renamed to match it). Windows support Bisync has been tested on Windows 8.1, Windows 10 Pro 64-bit and on Windows GitHub runners. Drive letters are allowed, including drive letters mapped to network drives (rclone bisync J:\localsync GDrive:). If a drive letter is omitted, the shell current drive is the default. Drive letters are a single character follows by :, so cloud names must be more than one character long. Absolute paths (with or without a drive letter), and relative paths (with or without a drive letter) are supported. Working directory is created at C:\Users\MyLogin\AppData\Local\rclone\bisync. Note that bisync output may show a mix of forward / and back \ slashes. Be careful of case independent directory and file naming on Windows vs. case dependent Linux Filtering See filtering documentation for how filter rules are written and interpreted. Bisync's --filters-file flag slightly extends the rclone's --filter-from filtering mechanism. For a given bisync run you may provide only one --filters-file. The --include*, --exclude*, and --filter flags are also supported. How to filter directories Filtering portions of the directory tree is a critical feature for syncing. Examples of directory trees (always beneath the Path1/Path2 root level) you may want to exclude from your sync: - Directory trees containing only software build intermediate files. - Directory trees containing application temporary files and data such as the Windows C:\Users\MyLogin\AppData\ tree. - Directory trees containing files that are large, less important, or are getting thrashed continuously by ongoing processes. On the other hand, there may be only select directories that you actually want to sync, and exclude all others. See the Example include-style filters for Windows user directories below. Filters file writing guidelines 1. Begin with excluding directory trees: - e.g. - /AppData/ - ** on the end is not necessary. Once a given directory level is excluded then everything beneath it won't be looked at by rclone. - Exclude such directories that are unneeded, are big, dynamically thrashed, or where there may be access permission issues. - Excluding such dirs first will make rclone operations (much) faster. - Specific files may also be excluded, as with the Dropbox exclusions example below. 2. Decide if it's easier (or cleaner) to: - Include select directories and therefore exclude everything else -- or -- - Exclude select directories and therefore include everything else 3. Include select directories: - Add lines like: + /Documents/PersonalFiles/** to select which directories to include in the sync. - ** on the end specifies to include the full depth of the specified tree. - With Include-style filters, files at the Path1/Path2 root are not included. They may be included with + /*. - Place RCLONE_TEST files within these included directory trees. They will only be looked for in these directory trees. - Finish by excluding everything else by adding - ** at the end of the filters file. - Disregard step 4. 4. Exclude select directories: - Add more lines like in step 1. For example: -/Desktop/tempfiles/, or - /testdir/. Again, a ** on the end is not necessary. - Do not add a - ** in the file. Without this line, everything will be included that has not been explicitly excluded. - Disregard step 3. A few rules for the syntax of a filter file expanding on filtering documentation: - Lines may start with spaces and tabs - rclone strips leading whitespace. - If the first non-whitespace character is a # then the line is a comment and will be ignored. - Blank lines are ignored. - The first non-whitespace character on a filter line must be a + or -. - Exactly 1 space is allowed between the +/- and the path term. - Only forward slashes (/) are used in path terms, even on Windows. - The rest of the line is taken as the path term. Trailing whitespace is taken literally, and probably is an error. Example include-style filters for Windows user directories This Windows include-style example is based on the sync root (Path1) set to C:\Users\MyLogin. The strategy is to select specific directories to be synched with a network drive (Path2). - - /AppData/ excludes an entire tree of Windows stored stuff that need not be synched. In my case, AppData has >11 GB of stuff I don't care about, and there are some subdirectories beneath AppData that are not accessible to my user login, resulting in bisync critical aborts. - Windows creates cache files starting with both upper and lowercase NTUSER at C:\Users\MyLogin. These files may be dynamic, locked, and are generally don't care. - There are just a few directories with my data that I do want synched, in the form of + /. By selecting only the directory trees I want to avoid the dozen plus directories that various apps make at C:\Users\MyLogin\Documents. - Include files in the root of the sync point, C:\Users\MyLogin, by adding the + /* line. - This is an Include-style filters file, therefore it ends with - ** which excludes everything not explicitly included. - /AppData/ - NTUSER* - ntuser* + /Documents/Family/** + /Documents/Sketchup/** + /Documents/Microcapture_Photo/** + /Documents/Microcapture_Video/** + /Desktop/** + /Pictures/** + /* - ** Note also that Windows implements several "library" links such as C:\Users\MyLogin\My Documents\My Music pointing to C:\Users\MyLogin\Music. rclone sees these as links, so you must add --links to the bisync command line if you which to follow these links. I find that I get permission errors in trying to follow the links, so I don't include the rclone --links flag, but then you get lots of Can't follow symlink… noise from rclone about not following the links. This noise can be quashed by adding --quiet to the bisync command line. Example exclude-style filters files for use with Dropbox - Dropbox disallows syncing the listed temporary and configuration/data files. The - filters exclude these files where ever they may occur in the sync tree. Consider adding similar exclusions for file types you don't need to sync, such as core dump and software build files. - bisync testing creates /testdir/ at the top level of the sync tree, and usually deletes the tree after the test. If a normal sync should run while the /testdir/ tree exists the --check-access phase may fail due to unbalanced RCLONE_TEST files. The - /testdir/ filter blocks this tree from being synched. You don't need this exclusion if you are not doing bisync development testing. - Everything else beneath the Path1/Path2 root will be synched. - RCLONE_TEST files may be placed anywhere within the tree, including the root. Example filters file for Dropbox # Filter file for use with bisync # See https://rclone.org/filtering/ for filtering rules # NOTICE: If you make changes to this file you MUST do a --resync run. # Run with --dry-run to see what changes will be made. # Dropbox won't sync some files so filter them away here. # See https://help.dropbox.com/installs-integrations/sync-uploads/files-not-syncing - .dropbox.attr - ~*.tmp - ~$* - .~* - desktop.ini - .dropbox # Used for bisync testing, so excluded from normal runs - /testdir/ # Other example filters #- /TiBU/ #- /Photos/ How --check-access handles filters At the start of a bisync run, listings are gathered for Path1 and Path2 while using the user's --filters-file. During the check access phase, bisync scans these listings for RCLONE_TEST files. Any RCLONE_TEST files hidden by the --filters-file are not in the listings and thus not checked during the check access phase. Troubleshooting Reading bisync logs Here are two normal runs. The first one has a newer file on the remote. The second has no deltas between local and remote. 2021/05/16 00:24:38 INFO : Synching Path1 "/path/to/local/tree/" with Path2 "dropbox:/" 2021/05/16 00:24:38 INFO : Path1 checking for diffs 2021/05/16 00:24:38 INFO : - Path1 File is new - file.txt 2021/05/16 00:24:38 INFO : Path1: 1 changes: 1 new, 0 newer, 0 older, 0 deleted 2021/05/16 00:24:38 INFO : Path2 checking for diffs 2021/05/16 00:24:38 INFO : Applying changes 2021/05/16 00:24:38 INFO : - Path1 Queue copy to Path2 - dropbox:/file.txt 2021/05/16 00:24:38 INFO : - Path1 Do queued copies to - Path2 2021/05/16 00:24:38 INFO : Updating listings 2021/05/16 00:24:38 INFO : Validating listings for Path1 "/path/to/local/tree/" vs Path2 "dropbox:/" 2021/05/16 00:24:38 INFO : Bisync successful 2021/05/16 00:36:52 INFO : Synching Path1 "/path/to/local/tree/" with Path2 "dropbox:/" 2021/05/16 00:36:52 INFO : Path1 checking for diffs 2021/05/16 00:36:52 INFO : Path2 checking for diffs 2021/05/16 00:36:52 INFO : No changes found 2021/05/16 00:36:52 INFO : Updating listings 2021/05/16 00:36:52 INFO : Validating listings for Path1 "/path/to/local/tree/" vs Path2 "dropbox:/" 2021/05/16 00:36:52 INFO : Bisync successful Dry run oddity The --dry-run messages may indicate that it would try to delete some files. For example, if a file is new on Path2 and does not exist on Path1 then it would normally be copied to Path1, but with --dry-run enabled those copies don't happen, which leads to the attempted delete on Path2, blocked again by --dry-run: ... Not deleting as --dry-run. This whole confusing situation is an artifact of the --dry-run flag. Scrutinize the proposed deletes carefully, and if the files would have been copied to Path1 then the threatened deletes on Path2 may be disregarded. Retries Rclone has built-in retries. If you run with --verbose you'll see error and retry messages such as shown below. This is usually not a bug. If at the end of the run, you see Bisync successful and not Bisync critical error or Bisync aborted then the run was successful, and you can ignore the error messages. The following run shows an intermittent fail. Lines 5 and 6 are low-level messages. Line 6 is a bubbled-up warning message, conveying the error. Rclone normally retries failing commands, so there may be numerous such messages in the log. Since there are no final error/warning messages on line 7, rclone has recovered from failure after a retry, and the overall sync was successful. 1: 2021/05/14 00:44:12 INFO : Synching Path1 "/path/to/local/tree" with Path2 "dropbox:" 2: 2021/05/14 00:44:12 INFO : Path1 checking for diffs 3: 2021/05/14 00:44:12 INFO : Path2 checking for diffs 4: 2021/05/14 00:44:12 INFO : Path2: 113 changes: 22 new, 0 newer, 0 older, 91 deleted 5: 2021/05/14 00:44:12 ERROR : /path/to/local/tree/objects/af: error listing: unexpected end of JSON input 6: 2021/05/14 00:44:12 NOTICE: WARNING listing try 1 failed. - dropbox: 7: 2021/05/14 00:44:12 INFO : Bisync successful This log shows a Critical failure which requires a --resync to recover from. See the Runtime Error Handling section. 2021/05/12 00:49:40 INFO : Google drive root '': Waiting for checks to finish 2021/05/12 00:49:40 INFO : Google drive root '': Waiting for transfers to finish 2021/05/12 00:49:40 INFO : Google drive root '': not deleting files as there were IO errors 2021/05/12 00:49:40 ERROR : Attempt 3/3 failed with 3 errors and: not deleting files as there were IO errors 2021/05/12 00:49:40 ERROR : Failed to sync: not deleting files as there were IO errors 2021/05/12 00:49:40 NOTICE: WARNING rclone sync try 3 failed. - /path/to/local/tree/ 2021/05/12 00:49:40 ERROR : Bisync aborted. Must run --resync to recover. Denied downloads of "infected" or "abusive" files Google Drive has a filter for certain file types (.exe, .apk, et cetera) that by default cannot be copied from Google Drive to the local filesystem. If you are having problems, run with --verbose to see specifically which files are generating complaints. If the error is This file has been identified as malware or spam and cannot be downloaded, consider using the flag --drive-acknowledge-abuse. Google Docs (and other files of unknown size) As of v1.66, Google Docs (including Google Sheets, Slides, etc.) are now supported in bisync, subject to the same options, defaults, and limitations as in rclone sync. When bisyncing drive with non-drive backends, the drive -> non-drive direction is controlled by --drive-export-formats (default "docx,xlsx,pptx,svg") and the non-drive -> drive direction is controlled by --drive-import-formats (default none.) For example, with the default export/import formats, a Google Sheet on the drive side will be synced to an .xlsx file on the non-drive side. In the reverse direction, .xlsx files with filenames that match an existing Google Sheet will be synced to that Google Sheet, while .xlsx files that do NOT match an existing Google Sheet will be copied to drive as normal .xlsx files (without conversion to Sheets, although the Google Drive web browser UI may still give you the option to open it as one.) If --drive-import-formats is set (it's not, by default), then all of the specified formats will be converted to Google Docs, if there is no existing Google Doc with a matching name. Caution: such conversion can be quite lossy, and in most cases it's probably not what you want! To bisync Google Docs as URL shortcut links (in a manner similar to "Drive for Desktop"), use: --drive-export-formats url (or alternatives.) Note that these link files cannot be edited on the non-drive side -- you will get errors if you try to sync an edited link file back to drive. They CAN be deleted (it will result in deleting the corresponding Google Doc.) If you create a .url file on the non-drive side that does not match an existing Google Doc, bisyncing it will just result in copying the literal .url file over to drive (no Google Doc will be created.) So, as a general rule of thumb, think of them as read-only placeholders on the non-drive side, and make all your changes on the drive side. Likewise, even with other export-formats, it is best to only move/rename Google Docs on the drive side. This is because otherwise, bisync will interpret this as a file deleted and another created, and accordingly, it will delete the Google Doc and create a new file at the new path. (Whether or not that new file is a Google Doc depends on --drive-import-formats.) Lastly, take note that all Google Docs on the drive side have a size of -1 and no checksum. Therefore, they cannot be reliably synced with the --checksum or --size-only flags. (To be exact: they will still get created/deleted, and bisync's delta engine will notice changes and queue them for syncing, but the underlying sync function will consider them identical and skip them.) To work around this, use the default (modtime and size) instead of --checksum or --size-only. To ignore Google Docs entirely, use --drive-skip-gdocs. Usage examples Cron Rclone does not yet have a built-in capability to monitor the local file system for changes and must be blindly run periodically. On Windows this can be done using a Task Scheduler, on Linux you can use Cron which is described below. The 1st example runs a sync every 5 minutes between a local directory and an OwnCloud server, with output logged to a runlog file: # Minute (0-59) # Hour (0-23) # Day of Month (1-31) # Month (1-12 or Jan-Dec) # Day of Week (0-6 or Sun-Sat) # Command */5 * * * * /path/to/rclone bisync /local/files MyCloud: --check-access --filters-file /path/to/bysync-filters.txt --log-file /path/to//bisync.log See crontab syntax for the details of crontab time interval expressions. If you run rclone bisync as a cron job, redirect stdout/stderr to a file. The 2nd example runs a sync to Dropbox every hour and logs all stdout (via the >>) and stderr (via 2>&1) to a log file. 0 * * * * /path/to/rclone bisync /path/to/local/dropbox Dropbox: --check-access --filters-file /home/user/filters.txt >> /path/to/logs/dropbox-run.log 2>&1 Sharing an encrypted folder tree between hosts bisync can keep a local folder in sync with a cloud service, but what if you have some highly sensitive files to be synched? Usage of a cloud service is for exchanging both routine and sensitive personal files between one's home network, one's personal notebook when on the road, and with one's work computer. The routine data is not sensitive. For the sensitive data, configure an rclone crypt remote to point to a subdirectory within the local disk tree that is bisync'd to Dropbox, and then set up an bisync for this local crypt directory to a directory outside of the main sync tree. Linux server setup - /path/to/DBoxroot is the root of my local sync tree. There are numerous subdirectories. - /path/to/DBoxroot/crypt is the root subdirectory for files that are encrypted. This local directory target is setup as an rclone crypt remote named Dropcrypt:. See rclone.conf snippet below. - /path/to/my/unencrypted/files is the root of my sensitive files - not encrypted, not within the tree synched to Dropbox. - To sync my local unencrypted files with the encrypted Dropbox versions I manually run bisync /path/to/my/unencrypted/files DropCrypt:. This step could be bundled into a script to run before and after the full Dropbox tree sync in the last step, thus actively keeping the sensitive files in sync. - bisync /path/to/DBoxroot Dropbox: runs periodically via cron, keeping my full local sync tree in sync with Dropbox. Windows notebook setup - The Dropbox client runs keeping the local tree C:\Users\MyLogin\Dropbox always in sync with Dropbox. I could have used rclone bisync instead. - A separate directory tree at C:\Users\MyLogin\Documents\DropLocal hosts the tree of unencrypted files/folders. - To sync my local unencrypted files with the encrypted Dropbox versions I manually run the following command: rclone bisync C:\Users\MyLogin\Documents\DropLocal Dropcrypt:. - The Dropbox client then syncs the changes with Dropbox. rclone.conf snippet [Dropbox] type = dropbox ... [Dropcrypt] type = crypt remote = /path/to/DBoxroot/crypt # on the Linux server remote = C:\Users\MyLogin\Dropbox\crypt # on the Windows notebook filename_encryption = standard directory_name_encryption = true password = ... ... Testing You should read this section only if you are developing for rclone. You need to have rclone source code locally to work with bisync tests. Bisync has a dedicated test framework implemented in the bisync_test.go file located in the rclone source tree. The test suite is based on the go test command. Series of tests are stored in subdirectories below the cmd/bisync/testdata directory. Individual tests can be invoked by their directory name, e.g. go test . -case basic -remote local -remote2 gdrive: -v Tests will make a temporary folder on remote and purge it afterwards. If during test run there are intermittent errors and rclone retries, these errors will be captured and flagged as invalid MISCOMPAREs. Rerunning the test will let it pass. Consider such failures as noise. Test command syntax usage: go test ./cmd/bisync [options...] Options: -case NAME Name(s) of the test case(s) to run. Multiple names should be separated by commas. You can remove the `test_` prefix and replace `_` by `-` in test name for convenience. If not `all`, the name(s) should map to a directory under `./cmd/bisync/testdata`. Use `all` to run all tests (default: all) -remote PATH1 `local` or name of cloud service with `:` (default: local) -remote2 PATH2 `local` or name of cloud service with `:` (default: local) -no-compare Disable comparing test results with the golden directory (default: compare) -no-cleanup Disable cleanup of Path1 and Path2 testdirs. Useful for troubleshooting. (default: cleanup) -golden Store results in the golden directory (default: false) This flag can be used with multiple tests. -debug Print debug messages -stop-at NUM Stop test after given step number. (default: run to the end) Implies `-no-compare` and `-no-cleanup`, if the test really ends prematurely. Only meaningful for a single test case. -refresh-times Force refreshing the target modtime, useful for Dropbox (default: false) -verbose Run tests verbosely Note: unlike rclone flags which must be prefixed by double dash (--), the test command flags can be equally prefixed by a single - or double dash. Running tests - go test . -case basic -remote local -remote2 local runs the test_basic test case using only the local filesystem, syncing one local directory with another local directory. Test script output is to the console, while commands within scenario.txt have their output sent to the .../workdir/test.log file, which is finally compared to the golden copy. - The first argument after go test should be a relative name of the directory containing bisync source code. If you run tests right from there, the argument will be . (current directory) as in most examples below. If you run bisync tests from the rclone source directory, the command should be go test ./cmd/bisync .... - The test engine will mangle rclone output to ensure comparability with golden listings and logs. - Test scenarios are located in ./cmd/bisync/testdata. The test -case argument should match the full name of a subdirectory under that directory. Every test subdirectory name on disk must start with test_, this prefix can be omitted on command line for brevity. Also, underscores in the name can be replaced by dashes for convenience. - go test . -remote local -remote2 local -case all runs all tests. - Path1 and Path2 may either be the keyword local or may be names of configured cloud services. go test . -remote gdrive: -remote2 dropbox: -case basic will run the test between these two services, without transferring any files to the local filesystem. - Test run stdout and stderr console output may be directed to a file, e.g. go test . -remote gdrive: -remote2 local -case all > runlog.txt 2>&1 Test execution flow 1. The base setup in the initial directory of the testcase is applied on the Path1 and Path2 filesystems (via rclone copy the initial directory to Path1, then rclone sync Path1 to Path2). 2. The commands in the scenario.txt file are applied, with output directed to the test.log file in the test working directory. Typically, the first actual command in the scenario.txt file is to do a --resync, which establishes the baseline {...}.path1.lst and {...}.path2.lst files in the test working directory (.../workdir/ relative to the temporary test directory). Various commands and listing snapshots are done within the test. 3. Finally, the contents of the test working directory are compared to the contents of the testcase's golden directory. Notes about testing - Test cases are in individual directories beneath ./cmd/bisync/testdata. A command line reference to a test is understood to reference a directory beneath testdata. For example, go test ./cmd/bisync -case dry-run -remote gdrive: -remote2 local refers to the test case in ./cmd/bisync/testdata/test_dry_run. - The test working directory is located at .../workdir relative to a temporary test directory, usually under /tmp on Linux. - The local test sync tree is created at a temporary directory named like bisync.XXX under system temporary directory. - The remote test sync tree is located at a temporary directory under /bisync.XXX/. - path1 and/or path2 subdirectories are created in a temporary directory under the respective local or cloud test remote. - By default, the Path1 and Path2 test dirs and workdir will be deleted after each test run. The -no-cleanup flag disables purging these directories when validating and debugging a given test. These directories will be flushed before running another test, independent of the -no-cleanup usage. - You will likely want to add - /testdir/ to your normal bisync --filters-file so that normal syncs do not attempt to sync the test temporary directories, which may have RCLONE_TEST miscompares in some testcases which would otherwise trip the --check-access system. The --check-access mechanism is hard-coded to ignore RCLONE_TEST files beneath bisync/testdata, so the test cases may reside on the synched tree even if there are check file mismatches in the test tree. - Some Dropbox tests can fail, notably printing the following message: src and dst identical but can't set mod time without deleting and re-uploading This is expected and happens due to the way Dropbox handles modification times. You should use the -refresh-times test flag to make up for this. - If Dropbox tests hit request limit for you and print error message too_many_requests/...: Too many requests or write operations. then follow the Dropbox App ID instructions. Updating golden results Sometimes even a slight change in the bisync source can cause little changes spread around many log files. Updating them manually would be a nightmare. The -golden flag will store the test.log and *.lst listings from each test case into respective golden directories. Golden results will automatically contain generic strings instead of local or cloud paths which means that they should match when run with a different cloud service. Your normal workflow might be as follows: 1. Git-clone the rclone sources locally 2. Modify bisync source and check that it builds 3. Run the whole test suite go test ./cmd/bisync -remote local 4. If some tests show log difference, recheck them individually, e.g.: go test ./cmd/bisync -remote local -case basic 5. If you are convinced with the difference, goldenize all tests at once: go test ./cmd/bisync -remote local -golden 6. Use word diff: git diff --word-diff ./cmd/bisync/testdata/. Please note that normal line-level diff is generally useless here. 7. Check the difference carefully! 8. Commit the change (git commit) only if you are sure. If unsure, save your code changes then wipe the log diffs from git: git reset [--hard]. Structure of test scenarios - /initial/ contains a tree of files that will be set as the initial condition on both Path1 and Path2 testdirs. - /modfiles/ contains files that will be used to modify the Path1 and/or Path2 filesystems. - /golden/ contains the expected content of the test working directory (workdir) at the completion of the testcase. - /scenario.txt contains the body of the test, in the form of various commands to modify files, run bisync, and snapshot listings. Output from these commands is captured to .../workdir/test.log for comparison to the golden files. Supported test commands - test Print the line to the console and to the test.log: test sync is working correctly with options x, y, z - copy-listings Save a copy of all .lst listings in the test working directory with the specified prefix: save-listings exclude-pass-run - move-listings Similar to copy-listings but removes the source - purge-children This will delete all child files and purge all child subdirs under given directory but keep the parent intact. This behavior is important for tests with Google Drive because removing and re-creating the parent would change its ID. - delete-file Delete a single file. - delete-glob Delete a group of files located one level deep in the given directory with names matching a given glob pattern. - touch-glob YYYY-MM-DD Change modification time on a group of files. - touch-copy YYYY-MM-DD Change file modification time then copy it to destination. - copy-file Copy a single file to given directory. - copy-as Similar to above but destination must include both directory and the new file name at destination. - copy-dir and sync-dir Copy/sync a directory. Equivalent of rclone copy and rclone sync. - list-dirs Equivalent to rclone lsf -R --dirs-only - bisync [options] Runs bisync against -remote and -remote2. Supported substitution terms - {testdir/} - the root dir of the testcase - {datadir/} - the modfiles dir under the testcase root - {workdir/} - the temporary test working directory - {path1/} - the root of the Path1 test directory tree - {path2/} - the root of the Path2 test directory tree - {session} - base name of the test listings - {/} - OS-specific path separator - {spc}, {tab}, {eol} - whitespace - {chr:HH} - raw byte with given hexadecimal code Substitution results of the terms named like {dir/} will end with / (or backslash on Windows), so it is not necessary to include slash in the usage, for example delete-file {path1/}file1.txt. Benchmarks This section is work in progress. Here are a few data points for scale, execution times, and memory usage. The first set of data was taken between a local disk to Dropbox. The speedtest.net download speed was ~170 Mbps, and upload speed was ~10 Mbps. 500 files (~9.5 MB each) had been already synched. 50 files were added in a new directory, each ~9.5 MB, ~475 MB total. ------------------------------------------------------------------------ Change Operations and times Overall run time ------------------------ ----------------------------------- ----------- 500 files synched 1x listings for Path1 & Path2 1.5 sec (nothing to move) 500 files synched with 1x listings for Path1 & Path2 1.5 sec --check-access 50 new files on remote Queued 50 copies down: 27 sec 29 sec Moved local dir Queued 50 copies up: 410 sec, 50 421 sec deletes up: 9 sec Moved remote dir Queued 50 copies down: 31 sec, 50 33 sec deletes down: <1 sec Delete local dir Queued 50 deletes up: 9 sec 13 sec ------------------------------------------------------------------------ This next data is from a user's application. They had ~400GB of data over 1.96 million files being sync'ed between a Windows local disk and some remote cloud. The file full path length was on average 35 characters (which factors into load time and RAM required). - Loading the prior listing into memory (1.96 million files, listing file size 140 MB) took ~30 sec and occupied about 1 GB of RAM. - Getting a fresh listing of the local file system (producing the 140 MB output file) took about XXX sec. - Getting a fresh listing of the remote file system (producing the 140 MB output file) took about XXX sec. The network download speed was measured at XXX Mb/s. - Once the prior and current Path1 and Path2 listings were loaded (a total of four to be loaded, two at a time), determining the deltas was pretty quick (a few seconds for this test case), and the transfer time for any files to be copied was dominated by the network bandwidth. References rclone's bisync implementation was derived from the rclonesync-V2 project, including documentation and test mechanisms, with @cjnaz's full support and encouragement. rclone bisync is similar in nature to a range of other projects: - unison - syncthing - cjnaz/rclonesync - ConorWilliams/rsinc - jwink3101/syncrclone - DavideRossi/upback Bisync adopts the differential synchronization technique, which is based on keeping history of changes performed by both synchronizing sides. See the Dual Shadow Method section in Neil Fraser's article. Also note a number of academic publications by Benjamin Pierce about Unison and synchronization in general. Changelog v1.71 - bisync is now officially released from beta. - Fixed an issue causing hash type to be set incorrectly if path2 had slow hashes and --no-slow-hash or --slow-hash-sync-only was in use. - Fixed an issue causing errors when running concurrent bisync runs through the rc. v1.69.1 - Fixed an issue causing listings to not capture concurrent modifications under certain conditions v1.68 - Fixed an issue affecting backends that round modtimes to a lower precision. v1.67 - Added integration tests against all backends. v1.66 - Copies and deletes are now handled in one operation instead of two - --track-renames and --backup-dir are now supported - Partial uploads known issue on local/ftp/sftp has been resolved (unless using --inplace) - Final listings are now generated from sync results, to avoid needing to re-list - Bisync is now much more resilient to changes that happen during a bisync run, and far less prone to critical errors / undetected changes - Bisync is now capable of rolling a file listing back in cases of uncertainty, essentially marking the file as needing to be rechecked next time. - A few basic terminal colors are now supported, controllable with --color (AUTO|NEVER|ALWAYS) - Initial listing snapshots of Path1 and Path2 are now generated concurrently, using the same "march" infrastructure as check and sync, for performance improvements and less risk of error. - Fixed handling of unicode normalization and case insensitivity, support for --fix-case, --ignore-case-sync, --no-unicode-normalization - --resync is now much more efficient (especially for users of --create-empty-src-dirs) - Google Docs (and other files of unknown size) are now supported (with the same options as in sync) - Equality checks before a sync conflict rename now fall back to cryptcheck (when possible) or --download, instead of of --size-only, when check is not available. - Bisync no longer fails to find the correct listing file when configs are overridden with backend-specific flags. - Bisync now fully supports comparing based on any combination of size, modtime, and checksum, lifting the prior restriction on backends without modtime support. - Bisync now supports a "Graceful Shutdown" mode to cleanly cancel a run early without requiring --resync. - New --recover flag allows robust recovery in the event of interruptions, without requiring --resync. - A new --max-lock setting allows lock files to automatically renew and expire, for better automatic recovery when a run is interrupted. - Bisync now supports auto-resolving sync conflicts and customizing rename behavior with new --conflict-resolve, --conflict-loser, and --conflict-suffix flags. - A new --resync-mode flag allows more control over which version of a file gets kept during a --resync. - Bisync now supports --retries and --retries-sleep (when --resilient is set.) v1.64 - Fixed an issue causing dry runs to inadvertently commit filter changes - Fixed an issue causing --resync to erroneously delete empty folders and duplicate files unique to Path2 - --check-access is now enforced during --resync, preventing data loss in certain user error scenarios - Fixed an issue causing bisync to consider more files than necessary due to overbroad filters during delete operations - Improved detection of false positive change conflicts (identical files are now left alone instead of renamed) - Added support for --create-empty-src-dirs - Added experimental --resilient mode to allow recovery from self-correctable errors - Added new --ignore-listing-checksum flag to distinguish from --ignore-checksum - Performance improvements for large remotes - Documentation and testing improvements Release signing The hashes of the binary artefacts of the rclone release are signed with a public PGP/GPG key. This can be verified manually as described below. The same mechanism is also used by rclone selfupdate to verify that the release has not been tampered with before the new update is installed. This checks the SHA256 hash and the signature with a public key compiled into the rclone binary. Release signing key You may obtain the release signing key from: - From KEYS on this website - this file contains all past signing keys also. - The git repository hosted on GitHub - https://github.com/rclone/rclone/blob/master/docs/content/KEYS - gpg --keyserver hkps://keys.openpgp.org --search nick@craig-wood.com - gpg --keyserver hkps://keyserver.ubuntu.com --search nick@craig-wood.com - https://www.craig-wood.com/nick/pub/pgp-key.txt After importing the key, verify that the fingerprint of one of the keys matches: FBF737ECE9F8AB18604BD2AC93935E02FF3B54FA as this key is used for signing. We recommend that you cross-check the fingerprint shown above through the domains listed below. By cross-checking the integrity of the fingerprint across multiple domains you can be confident that you obtained the correct key. - The source for this page on GitHub. - Through DNS dig key.rclone.org txt If you find anything that doesn't not match, please contact the developers at once. How to verify the release In the release directory you will see the release files and some files called MD5SUMS, SHA1SUMS and SHA256SUMS. $ rclone lsf --http-url https://downloads.rclone.org/v1.63.1 :http: MD5SUMS SHA1SUMS SHA256SUMS rclone-v1.63.1-freebsd-386.zip rclone-v1.63.1-freebsd-amd64.zip ... rclone-v1.63.1-windows-arm64.zip rclone-v1.63.1.tar.gz version.txt The MD5SUMS, SHA1SUMS and SHA256SUMS contain hashes of the binary files in the release directory along with a signature. For example: $ rclone cat --http-url https://downloads.rclone.org/v1.63.1 :http:SHA256SUMS -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 f6d1b2d7477475ce681bdce8cb56f7870f174cb6b2a9ac5d7b3764296ea4a113 rclone-v1.63.1-freebsd-386.zip 7266febec1f01a25d6575de51c44ddf749071a4950a6384e4164954dff7ac37e rclone-v1.63.1-freebsd-amd64.zip ... 66ca083757fb22198309b73879831ed2b42309892394bf193ff95c75dff69c73 rclone-v1.63.1-windows-amd64.zip bbb47c16882b6c5f2e8c1b04229378e28f68734c613321ef0ea2263760f74cd0 rclone-v1.63.1-windows-arm64.zip -----BEGIN PGP SIGNATURE----- iF0EARECAB0WIQT79zfs6firGGBL0qyTk14C/ztU+gUCZLVKJQAKCRCTk14C/ztU +pZuAJ0XJ+QWLP/3jCtkmgcgc4KAwd/rrwCcCRZQ7E+oye1FPY46HOVzCFU3L7g= =8qrL -----END PGP SIGNATURE----- Download the files The first step is to download the binary and SUMs file and verify that the SUMs you have downloaded match. Here we download rclone-v1.63.1-windows-amd64.zip - choose the binary (or binaries) appropriate to your architecture. We've also chosen the SHA256SUMS as these are the most secure. You could verify the other types of hash also for extra security. rclone selfupdate verifies just the SHA256SUMS. $ mkdir /tmp/check $ cd /tmp/check $ rclone copy --http-url https://downloads.rclone.org/v1.63.1 :http:SHA256SUMS . $ rclone copy --http-url https://downloads.rclone.org/v1.63.1 :http:rclone-v1.63.1-windows-amd64.zip . Verify the signatures First verify the signatures on the SHA256 file. Import the key. See above for ways to verify this key is correct. $ gpg --keyserver keyserver.ubuntu.com --receive-keys FBF737ECE9F8AB18604BD2AC93935E02FF3B54FA gpg: key 93935E02FF3B54FA: public key "Nick Craig-Wood " imported gpg: Total number processed: 1 gpg: imported: 1 Then check the signature: $ gpg --verify SHA256SUMS gpg: Signature made Mon 17 Jul 2023 15:03:17 BST gpg: using DSA key FBF737ECE9F8AB18604BD2AC93935E02FF3B54FA gpg: Good signature from "Nick Craig-Wood " [ultimate] Verify the signature was good and is using the fingerprint shown above. Repeat for MD5SUMS and SHA1SUMS if desired. Verify the hashes Now that we know the signatures on the hashes are OK we can verify the binaries match the hashes, completing the verification. $ sha256sum -c SHA256SUMS 2>&1 | grep OK rclone-v1.63.1-windows-amd64.zip: OK Or do the check with rclone $ rclone hashsum sha256 -C SHA256SUMS rclone-v1.63.1-windows-amd64.zip 2023/09/11 10:53:58 NOTICE: SHA256SUMS: improperly formatted checksum line 0 2023/09/11 10:53:58 NOTICE: SHA256SUMS: improperly formatted checksum line 1 2023/09/11 10:53:58 NOTICE: SHA256SUMS: improperly formatted checksum line 49 2023/09/11 10:53:58 NOTICE: SHA256SUMS: 4 warning(s) suppressed... = rclone-v1.63.1-windows-amd64.zip 2023/09/11 10:53:58 NOTICE: Local file system at /tmp/check: 0 differences found 2023/09/11 10:53:58 NOTICE: Local file system at /tmp/check: 1 matching files Verify signatures and hashes together You can verify the signatures and hashes in one command line like this: $ h=$(gpg --decrypt SHA256SUMS) && echo "$h" | sha256sum - -c --ignore-missing gpg: Signature made Mon 17 Jul 2023 15:03:17 BST gpg: using DSA key FBF737ECE9F8AB18604BD2AC93935E02FF3B54FA gpg: Good signature from "Nick Craig-Wood " [ultimate] gpg: aka "Nick Craig-Wood " [unknown] rclone-v1.63.1-windows-amd64.zip: OK 1Fichier This is a backend for the 1fichier cloud storage service. Note that a Premium subscription is required to use the API. Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. Configuration The initial setup for 1Fichier involves getting the API key from the website which you need to do in your browser. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / 1Fichier \ "fichier" [snip] Storage> fichier ** See help for fichier backend at: https://rclone.org/fichier/ ** Your API Key, get it from https://1fichier.com/console/params.pl Enter a string value. Press Enter for the default (""). api_key> example_key Edit advanced config? (y/n) y) Yes n) No y/n> Remote config Configuration complete. Options: - type: fichier - api_key: example_key Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Once configured you can then use rclone like this, List directories in top level of your 1Fichier account rclone lsd remote: List all the files in your 1Fichier account rclone ls remote: To copy a local directory to a 1Fichier directory called backup rclone copy /home/source remote:backup Modification times and hashes 1Fichier does not support modification times. It supports the Whirlpool hash algorithm. Duplicated files 1Fichier can have two files with exactly the same name and path (unlike a normal file system). Duplicated files cause problems with the syncing and you will see messages in the log about duplicates. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- \ 0x5C ＼ < 0x3C ＜ > 0x3E ＞ " 0x22 ＂ $ 0x24 ＄ ` 0x60 ｀ ' 0x27 ＇ File names can also not start or end with the following characters. These only get replaced if they are the first or last character in the name: Character Value Replacement ----------- ------- ------------- SP 0x20 ␠ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Standard options Here are the Standard options specific to fichier (1Fichier). --fichier-api-key Your API Key, get it from https://1fichier.com/console/params.pl. Properties: - Config: api_key - Env Var: RCLONE_FICHIER_API_KEY - Type: string - Required: false Advanced options Here are the Advanced options specific to fichier (1Fichier). --fichier-shared-folder If you want to download a shared folder, add this parameter. Properties: - Config: shared_folder - Env Var: RCLONE_FICHIER_SHARED_FOLDER - Type: string - Required: false --fichier-file-password If you want to download a shared file that is password protected, add this parameter. NB Input to this must be obscured - see rclone obscure. Properties: - Config: file_password - Env Var: RCLONE_FICHIER_FILE_PASSWORD - Type: string - Required: false --fichier-folder-password If you want to list the files in a shared folder that is password protected, add this parameter. NB Input to this must be obscured - see rclone obscure. Properties: - Config: folder_password - Env Var: RCLONE_FICHIER_FOLDER_PASSWORD - Type: string - Required: false --fichier-cdn Set if you wish to use CDN download links. Properties: - Config: cdn - Env Var: RCLONE_FICHIER_CDN - Type: bool - Default: false --fichier-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_FICHIER_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,SingleQuote,BackQuote,Dollar,BackSlash,Del,Ctl,LeftSpace,RightSpace,InvalidUtf8,Dot --fichier-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_FICHIER_DESCRIPTION - Type: string - Required: false Limitations rclone about is not supported by the 1Fichier backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about Alias The alias remote provides a new name for another remote. Paths may be as deep as required or a local path, e.g. remote:directory/subdirectory or /directory/subdirectory. During the initial setup with rclone config you will specify the target remote. The target remote can either be a local path or another remote. Subfolders can be used in target remote. Assume an alias remote named backup with the target mydrive:private/backup. Invoking rclone mkdir backup:desktop is exactly the same as invoking rclone mkdir mydrive:private/backup/desktop. There will be no special handling of paths containing .. segments. Invoking rclone mkdir backup:../desktop is exactly the same as invoking rclone mkdir mydrive:private/backup/../desktop. The empty path is not allowed as a remote. To alias the current directory use . instead. The target remote can also be a connection string. This can be used to modify the config of a remote for different uses, e.g. the alias myDriveTrash with the target remote myDrive,trashed_only: can be used to only show the trashed files in myDrive. Configuration Here is an example of how to make an alias called remote for local folder. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Alias for an existing remote \ "alias" [snip] Storage> alias Remote or path to alias. Can be "myremote:path/to/dir", "myremote:bucket", "myremote:" or "/local/path". remote> /mnt/storage/backup Remote config Configuration complete. Options: - type: alias - remote: /mnt/storage/backup Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== remote alias e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q Once configured you can then use rclone like this, List directories in top level in /mnt/storage/backup rclone lsd remote: List all the files in /mnt/storage/backup rclone ls remote: Copy another local directory to the alias directory called source rclone copy /home/source remote:source Standard options Here are the Standard options specific to alias (Alias for an existing remote). --alias-remote Remote or path to alias. Can be "myremote:path/to/dir", "myremote:bucket", "myremote:" or "/local/path". Properties: - Config: remote - Env Var: RCLONE_ALIAS_REMOTE - Type: string - Required: true Advanced options Here are the Advanced options specific to alias (Alias for an existing remote). --alias-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_ALIAS_DESCRIPTION - Type: string - Required: false Amazon S3 Storage Providers The S3 backend can be used with a number of different providers: - AWS S3 - Alibaba Cloud (Aliyun) Object Storage System (OSS) - Ceph - China Mobile Ecloud Elastic Object Storage (EOS) - Cloudflare R2 - Arvan Cloud Object Storage (AOS) - DigitalOcean Spaces - Dreamhost - Exaba - GCS - Huawei OBS - IBM COS S3 - IDrive e2 - IONOS Cloud - Leviia Object Storage - Liara Object Storage - Linode Object Storage - Magalu Object Storage - MEGA S4 Object Storage - Minio - Outscale - OVHcloud - Petabox - Pure Storage FlashBlade - Qiniu Cloud Object Storage (Kodo) - RackCorp Object Storage - Rclone Serve S3 - Scaleway - Seagate Lyve Cloud - SeaweedFS - Selectel - StackPath - Storj - Synology C2 Object Storage - Tencent Cloud Object Storage (COS) - Wasabi - Zata Paths are specified as remote:bucket (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:bucket/path/to/dir. Once you have made a remote (see the provider specific section above) you can use it like this: See all buckets rclone lsd remote: Make a new bucket rclone mkdir remote:bucket List the contents of a bucket rclone ls remote:bucket Sync /home/local/directory to the remote bucket, deleting any excess files in the bucket. rclone sync --interactive /home/local/directory remote:bucket Configuration Here is an example of making an s3 configuration for the AWS S3 provider. Most applies to the other providers as well, any differences are described below. First run rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ "s3" [snip] Storage> s3 Choose your S3 provider. Choose a number from below, or type in your own value 1 / Amazon Web Services (AWS) S3 \ "AWS" 2 / Ceph Object Storage \ "Ceph" 3 / DigitalOcean Spaces \ "DigitalOcean" 4 / Dreamhost DreamObjects \ "Dreamhost" 5 / IBM COS S3 \ "IBMCOS" 6 / Minio Object Storage \ "Minio" 7 / Wasabi Object Storage \ "Wasabi" 8 / Any other S3 compatible provider \ "Other" provider> 1 Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID - leave blank for anonymous access or runtime credentials. access_key_id> XXX AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials. secret_access_key> YYY Region to connect to. Choose a number from below, or type in your own value / The default endpoint - a good choice if you are unsure. 1 | US Region, Northern Virginia, or Pacific Northwest. | Leave location constraint empty. \ "us-east-1" / US East (Ohio) Region 2 | Needs location constraint us-east-2. \ "us-east-2" / US West (Oregon) Region 3 | Needs location constraint us-west-2. \ "us-west-2" / US West (Northern California) Region 4 | Needs location constraint us-west-1. \ "us-west-1" / Canada (Central) Region 5 | Needs location constraint ca-central-1. \ "ca-central-1" / EU (Ireland) Region 6 | Needs location constraint EU or eu-west-1. \ "eu-west-1" / EU (London) Region 7 | Needs location constraint eu-west-2. \ "eu-west-2" / EU (Frankfurt) Region 8 | Needs location constraint eu-central-1. \ "eu-central-1" / Asia Pacific (Singapore) Region 9 | Needs location constraint ap-southeast-1. \ "ap-southeast-1" / Asia Pacific (Sydney) Region 10 | Needs location constraint ap-southeast-2. \ "ap-southeast-2" / Asia Pacific (Tokyo) Region 11 | Needs location constraint ap-northeast-1. \ "ap-northeast-1" / Asia Pacific (Seoul) 12 | Needs location constraint ap-northeast-2. \ "ap-northeast-2" / Asia Pacific (Mumbai) 13 | Needs location constraint ap-south-1. \ "ap-south-1" / Asia Pacific (Hong Kong) Region 14 | Needs location constraint ap-east-1. \ "ap-east-1" / South America (Sao Paulo) Region 15 | Needs location constraint sa-east-1. \ "sa-east-1" region> 1 Endpoint for S3 API. Leave blank if using AWS to use the default endpoint for the region. endpoint> Location constraint - must be set to match the Region. Used when creating buckets only. Choose a number from below, or type in your own value 1 / Empty for US Region, Northern Virginia, or Pacific Northwest. \ "" 2 / US East (Ohio) Region. \ "us-east-2" 3 / US West (Oregon) Region. \ "us-west-2" 4 / US West (Northern California) Region. \ "us-west-1" 5 / Canada (Central) Region. \ "ca-central-1" 6 / EU (Ireland) Region. \ "eu-west-1" 7 / EU (London) Region. \ "eu-west-2" 8 / EU Region. \ "EU" 9 / Asia Pacific (Singapore) Region. \ "ap-southeast-1" 10 / Asia Pacific (Sydney) Region. \ "ap-southeast-2" 11 / Asia Pacific (Tokyo) Region. \ "ap-northeast-1" 12 / Asia Pacific (Seoul) \ "ap-northeast-2" 13 / Asia Pacific (Mumbai) \ "ap-south-1" 14 / Asia Pacific (Hong Kong) \ "ap-east-1" 15 / South America (Sao Paulo) Region. \ "sa-east-1" location_constraint> 1 Canned ACL used when creating buckets and/or storing objects in S3. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Choose a number from below, or type in your own value 1 / Owner gets FULL_CONTROL. No one else has access rights (default). \ "private" 2 / Owner gets FULL_CONTROL. The AllUsers group gets READ access. \ "public-read" / Owner gets FULL_CONTROL. The AllUsers group gets READ and WRITE access. 3 | Granting this on a bucket is generally not recommended. \ "public-read-write" 4 / Owner gets FULL_CONTROL. The AuthenticatedUsers group gets READ access. \ "authenticated-read" / Object owner gets FULL_CONTROL. Bucket owner gets READ access. 5 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ "bucket-owner-read" / Both the object owner and the bucket owner get FULL_CONTROL over the object. 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ "bucket-owner-full-control" acl> 1 The server-side encryption algorithm used when storing this object in S3. Choose a number from below, or type in your own value 1 / None \ "" 2 / AES256 \ "AES256" server_side_encryption> 1 The storage class to use when storing objects in S3. Choose a number from below, or type in your own value 1 / Default \ "" 2 / Standard storage class \ "STANDARD" 3 / Reduced redundancy storage class \ "REDUCED_REDUNDANCY" 4 / Standard Infrequent Access storage class \ "STANDARD_IA" 5 / One Zone Infrequent Access storage class \ "ONEZONE_IA" 6 / Glacier Flexible Retrieval storage class \ "GLACIER" 7 / Glacier Deep Archive storage class \ "DEEP_ARCHIVE" 8 / Intelligent-Tiering storage class \ "INTELLIGENT_TIERING" 9 / Glacier Instant Retrieval storage class \ "GLACIER_IR" storage_class> 1 Remote config Configuration complete. Options: - type: s3 - provider: AWS - env_auth: false - access_key_id: XXX - secret_access_key: YYY - region: us-east-1 - endpoint: - location_constraint: - acl: private - server_side_encryption: - storage_class: Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> Modification times and hashes Modification times The modified time is stored as metadata on the object as X-Amz-Meta-Mtime as floating point since the epoch, accurate to 1 ns. If the modification time needs to be updated rclone will attempt to perform a server side copy to update the modification if the object can be copied in a single part. In the case the object is larger than 5Gb or is in Glacier or Glacier Deep Archive storage the object will be uploaded rather than copied. Note that reading this from the object takes an additional HEAD request as the metadata isn't returned in object listings. Hashes For small objects which weren't uploaded as multipart uploads (objects sized below --s3-upload-cutoff if uploaded with rclone) rclone uses the ETag: header as an MD5 checksum. However for objects which were uploaded as multipart uploads or with server side encryption (SSE-AWS or SSE-C) the ETag header is no longer the MD5 sum of the data, so rclone adds an additional piece of metadata X-Amz-Meta-Md5chksum which is a base64 encoded MD5 hash (in the same format as is required for Content-MD5). You can use base64 -d and hexdump to check this value manually: echo 'VWTGdNx3LyXQDfA0e2Edxw==' | base64 -d | hexdump or you can use rclone check to verify the hashes are OK. For large objects, calculating this hash can take some time so the addition of this hash can be disabled with --s3-disable-checksum. This will mean that these objects do not have an MD5 checksum. Note that reading this from the object takes an additional HEAD request as the metadata isn't returned in object listings. Reducing costs Avoiding HEAD requests to read the modification time By default, rclone will use the modification time of objects stored in S3 for syncing. This is stored in object metadata which unfortunately takes an extra HEAD request to read which can be expensive (in time and money). The modification time is used by default for all operations that require checking the time a file was last updated. It allows rclone to treat the remote more like a true filesystem, but it is inefficient on S3 because it requires an extra API call to retrieve the metadata. The extra API calls can be avoided when syncing (using rclone sync or rclone copy) in a few different ways, each with its own tradeoffs. - --size-only - Only checks the size of files. - Uses no extra transactions. - If the file doesn't change size then rclone won't detect it has changed. - rclone sync --size-only /path/to/source s3:bucket - --checksum - Checks the size and MD5 checksum of files. - Uses no extra transactions. - The most accurate detection of changes possible. - Will cause the source to read an MD5 checksum which, if it is a local disk, will cause lots of disk activity. - If the source and destination are both S3 this is the recommended flag to use for maximum efficiency. - rclone sync --checksum /path/to/source s3:bucket - --update --use-server-modtime - Uses no extra transactions. - Modification time becomes the time the object was uploaded. - For many operations this is sufficient to determine if it needs uploading. - Using --update along with --use-server-modtime, avoids the extra API call and uploads files whose local modification time is newer than the time it was last uploaded. - Files created with timestamps in the past will be missed by the sync. - rclone sync --update --use-server-modtime /path/to/source s3:bucket These flags can and should be used in combination with --fast-list - see below. If using rclone mount or any command using the VFS (eg rclone serve) commands then you might want to consider using the VFS flag --no-modtime which will stop rclone reading the modification time for every object. You could also use --use-server-modtime if you are happy with the modification times of the objects being the time of upload. Avoiding GET requests to read directory listings Rclone's default directory traversal is to process each directory individually. This takes one API call per directory. Using the --fast-list flag will read all info about the objects into memory first using a smaller number of API calls (one per 1000 objects). See the rclone docs for more details. rclone sync --fast-list --checksum /path/to/source s3:bucket --fast-list trades off API transactions for memory use. As a rough guide rclone uses 1k of memory per object stored, so using --fast-list on a sync of a million objects will use roughly 1 GiB of RAM. If you are only copying a small number of files into a big repository then using --no-traverse is a good idea. This finds objects directly instead of through directory listings. You can do a "top-up" sync very cheaply by using --max-age and --no-traverse to copy only recent files, eg rclone copy --max-age 24h --no-traverse /path/to/source s3:bucket You'd then do a full rclone sync less often. Note that --fast-list isn't required in the top-up sync. Avoiding HEAD requests after PUT By default, rclone will HEAD every object it uploads. It does this to check the object got uploaded correctly. You can disable this with the --s3-no-head option - see there for more details. Setting this flag increases the chance for undetected upload failures. Increasing performance Using server-side copy If you are copying objects between S3 buckets in the same region, you should use server-side copy. This is much faster than downloading and re-uploading the objects, as no data is transferred. For rclone to use server-side copy, you must use the same remote for the source and destination. rclone copy s3:source-bucket s3:destination-bucket When using server-side copy, the performance is limited by the rate at which rclone issues API requests to S3. See below for how to increase the number of API requests rclone makes. Increasing the rate of API requests You can increase the rate of API requests to S3 by increasing the parallelism using --transfers and --checkers options. Rclone uses a very conservative defaults for these settings, as not all providers support high rates of requests. Depending on your provider, you can increase significantly the number of transfers and checkers. For example, with AWS S3, if you can increase the number of checkers to values like 200. If you are doing a server-side copy, you can also increase the number of transfers to 200. rclone sync --transfers 200 --checkers 200 --checksum s3:source-bucket s3:destination-bucket You will need to experiment with these values to find the optimal settings for your setup. Data integrity Rclone does its best to verify every part of an upload or download to the s3 provider using various hashes. Every HTTP transaction to/from the provider has a X-Amz-Content-Sha256 or a Content-Md5 header to guard against corruption of the HTTP body. The HTTP Header is protected by the signature passed in the Authorization header. All communications with the provider is done over https for encryption and additional error protection. Single part uploads - Rclone uploads single part uploads with a Content-Md5 using the MD5 hash read from the source. The provider checks this is correct on receipt of the data. - Rclone then does a HEAD request (disable with --s3-no-head) to read the ETag back which is the MD5 of the file and checks that with what it sent. Note that if the source does not have an MD5 then the single part uploads will not have hash protection. In this case it is recommended to use --s3-upload-cutoff 0 so all files are uploaded as multipart uploads. Multipart uploads For files above --s3-upload-cutoff rclone splits the file into multiple parts for upload. - Each part is protected with both an X-Amz-Content-Sha256 and a Content-Md5 When rclone has finished the upload of all the parts it then completes the upload by sending: - The MD5 hash of each part - The number of parts - This info is all protected with a X-Amz-Content-Sha256 The provider checks the MD5 for all the parts it has received against what rclone sends and if it is good it returns OK. Rclone then does a HEAD request (disable with --s3-no-head) and checks the ETag is what it expects (in this case it should be the MD5 sum of all the MD5 sums of all the parts with the number of parts on the end). If the source has an MD5 sum then rclone will attach the X-Amz-Meta-Md5chksum with it as the ETag for a multipart upload can't easily be checked against the file as the chunk size must be known in order to calculate it. Downloads Rclone checks the MD5 hash of the data downloaded against either the ETag or the X-Amz-Meta-Md5chksum metadata (if present) which rclone uploads with multipart uploads. Further checking At each stage rclone and the provider are sending and checking hashes of everything. Rclone deliberately HEADs each object after upload to check it arrived safely for extra security. (You can disable this with --s3-no-head). If you require further assurance that your data is intact you can use rclone check to check the hashes locally vs the remote. And if you are feeling ultimately paranoid use rclone check --download which will download the files and check them against the local copies. (Note that this doesn't use disk to do this - it streams them in memory). Versions When bucket versioning is enabled (this can be done with rclone with the rclone backend versioning command) when rclone uploads a new version of a file it creates a new version of it Likewise when you delete a file, the old version will be marked hidden and still be available. Old versions of files, where available, are visible using the --s3-versions flag. It is also possible to view a bucket as it was at a certain point in time, using the --s3-version-at flag. This will show the file versions as they were at that time, showing files that have been deleted afterwards, and hiding files that were created since. If you wish to remove all the old versions then you can use the rclone backend cleanup-hidden remote:bucket command which will delete all the old hidden versions of files, leaving the current ones intact. You can also supply a path and only old versions under that path will be deleted, e.g. rclone backend cleanup-hidden remote:bucket/path/to/stuff. When you purge a bucket, the current and the old versions will be deleted then the bucket will be deleted. However delete will cause the current versions of the files to become hidden old versions. Here is a session showing the listing and retrieval of an old version followed by a cleanup of the old versions. Show current version and all the versions with --s3-versions flag. $ rclone -q ls s3:cleanup-test 9 one.txt $ rclone -q --s3-versions ls s3:cleanup-test 9 one.txt 8 one-v2016-07-04-141032-000.txt 16 one-v2016-07-04-141003-000.txt 15 one-v2016-07-02-155621-000.txt Retrieve an old version $ rclone -q --s3-versions copy s3:cleanup-test/one-v2016-07-04-141003-000.txt /tmp $ ls -l /tmp/one-v2016-07-04-141003-000.txt -rw-rw-r-- 1 ncw ncw 16 Jul 2 17:46 /tmp/one-v2016-07-04-141003-000.txt Clean up all the old versions and show that they've gone. $ rclone -q backend cleanup-hidden s3:cleanup-test $ rclone -q ls s3:cleanup-test 9 one.txt $ rclone -q --s3-versions ls s3:cleanup-test 9 one.txt Versions naming caveat When using --s3-versions flag rclone is relying on the file name to work out whether the objects are versions or not. Versions' names are created by inserting timestamp between file name and its extension. 9 file.txt 8 file-v2023-07-17-161032-000.txt 16 file-v2023-06-15-141003-000.txt If there are real files present with the same names as versions, then behaviour of --s3-versions can be unpredictable. Cleanup If you run rclone cleanup s3:bucket then it will remove all pending multipart uploads older than 24 hours. You can use the --interactive/i or --dry-run flag to see exactly what it will do. If you want more control over the expiry date then run rclone backend cleanup s3:bucket -o max-age=1h to expire all uploads older than one hour. You can use rclone backend list-multipart-uploads s3:bucket to see the pending multipart uploads. Restricted filename characters S3 allows any valid UTF-8 string as a key. Invalid UTF-8 bytes will be replaced, as they can't be used in XML. The following characters are replaced since these are problematic when dealing with the REST API: Character Value Replacement ----------- ------- ------------- NUL 0x00 ␀ / 0x2F ／ The encoding will also encode these file names as they don't seem to work with the SDK properly: File name Replacement ----------- ------------- . ． .. ．． Multipart uploads rclone supports multipart uploads with S3 which means that it can upload files bigger than 5 GiB. Note that files uploaded both with multipart upload and through crypt remotes do not have MD5 sums. rclone switches from single part uploads to multipart uploads at the point specified by --s3-upload-cutoff. This can be a maximum of 5 GiB and a minimum of 0 (ie always upload multipart files). The chunk sizes used in the multipart upload are specified by --s3-chunk-size and the number of chunks uploaded concurrently is specified by --s3-upload-concurrency. Multipart uploads will use --transfers * --s3-upload-concurrency * --s3-chunk-size extra memory. Single part uploads to not use extra memory. Single part transfers can be faster than multipart transfers or slower depending on your latency from S3 - the more latency, the more likely single part transfers will be faster. Increasing --s3-upload-concurrency will increase throughput (8 would be a sensible value) and increasing --s3-chunk-size also increases throughput (16M would be sensible). Increasing either of these will use more memory. The default values are high enough to gain most of the possible performance without using too much memory. Buckets and Regions With Amazon S3 you can list buckets (rclone lsd) using any region, but you can only access the content of a bucket from the region it was created in. If you attempt to access a bucket from the wrong region, you will get an error, incorrect region, the bucket is not in 'XXX' region. Authentication There are a number of ways to supply rclone with a set of AWS credentials, with and without using the environment. The different authentication methods are tried in this order: - Directly in the rclone configuration file (env_auth = false in the config file): - access_key_id and secret_access_key are required. - session_token can be optionally set when using AWS STS. - Runtime configuration (env_auth = true in the config file): - Export the following environment variables before running rclone: - Access Key ID: AWS_ACCESS_KEY_ID or AWS_ACCESS_KEY - Secret Access Key: AWS_SECRET_ACCESS_KEY or AWS_SECRET_KEY - Session Token: AWS_SESSION_TOKEN (optional) - Or, use a named profile: - Profile files are standard files used by AWS CLI tools - By default it will use the profile in your home directory (e.g. ~/.aws/credentials on unix based systems) file and the "default" profile, to change set these environment variables or config keys: - AWS_SHARED_CREDENTIALS_FILE to control which file or the shared_credentials_file config key. - AWS_PROFILE to control which profile to use or the profile config key. - Or, run rclone in an ECS task with an IAM role (AWS only). - Or, run rclone on an EC2 instance with an IAM role (AWS only). - Or, run rclone in an EKS pod with an IAM role that is associated with a service account (AWS only). - Or, use process credentials to read config from an external program. With env_auth = true rclone (which uses the SDK for Go v2) should support all authentication methods that the aws CLI tool does and the other AWS SDKs. If none of these option actually end up providing rclone with AWS credentials then S3 interaction will be non-authenticated (see the anonymous access section for more info). S3 Permissions When using the sync subcommand of rclone the following minimum permissions are required to be available on the bucket being written to: - ListBucket - DeleteObject - GetObject - PutObject - PutObjectACL - CreateBucket (unless using s3-no-check-bucket) When using the lsd subcommand, the ListAllMyBuckets permission is required. Example policy: { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::USER_SID:user/USER_NAME" }, "Action": [ "s3:ListBucket", "s3:DeleteObject", "s3:GetObject", "s3:PutObject", "s3:PutObjectAcl" ], "Resource": [ "arn:aws:s3:::BUCKET_NAME/*", "arn:aws:s3:::BUCKET_NAME" ] }, { "Effect": "Allow", "Action": "s3:ListAllMyBuckets", "Resource": "arn:aws:s3:::*" } ] } Notes on above: 1. This is a policy that can be used when creating bucket. It assumes that USER_NAME has been created. 2. The Resource entry must include both resource ARNs, as one implies the bucket and the other implies the bucket's objects. 3. When using s3-no-check-bucket and the bucket already exists, the "arn:aws:s3:::BUCKET_NAME" doesn't have to be included. For reference, here's an Ansible script that will generate one or more buckets that will work with rclone sync. Key Management System (KMS) If you are using server-side encryption with KMS then you must make sure rclone is configured with server_side_encryption = aws:kms otherwise you will find you can't transfer small objects - these will create checksum errors. Glacier and Glacier Deep Archive You can upload objects using the glacier storage class or transition them to glacier using a lifecycle policy. The bucket can still be synced or copied into normally, but if rclone tries to access data from the glacier storage class you will see an error like below. 2017/09/11 19:07:43 Failed to sync: failed to open source object: Object in GLACIER, restore first: path/to/file In this case you need to restore the object(s) in question before accessing object contents. The restore section below shows how to do this with rclone. Note that rclone only speaks the S3 API it does not speak the Glacier Vault API, so rclone cannot directly access Glacier Vaults. Object-lock enabled S3 bucket According to AWS's documentation on S3 Object Lock: If you configure a default retention period on a bucket, requests to upload objects in such a bucket must include the Content-MD5 header. As mentioned in the Modification times and hashes section, small files that are not uploaded as multipart, use a different tag, causing the upload to fail. A simple solution is to set the --s3-upload-cutoff 0 and force all the files to be uploaded as multipart. Standard options Here are the Standard options specific to s3 (Amazon S3 Compliant Storage Providers including AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, Exaba, FlashBlade, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, Magalu, Mega, Minio, Netease, Outscale, OVHcloud, Petabox, RackCorp, Rclone, Scaleway, SeaweedFS, Selectel, StackPath, Storj, Synology, TencentCOS, Wasabi, Qiniu, Zata and others). --s3-provider Choose your S3 provider. Properties: - Config: provider - Env Var: RCLONE_S3_PROVIDER - Type: string - Required: false - Examples: - "AWS" - Amazon Web Services (AWS) S3 - "Alibaba" - Alibaba Cloud Object Storage System (OSS) formerly Aliyun - "ArvanCloud" - Arvan Cloud Object Storage (AOS) - "Ceph" - Ceph Object Storage - "ChinaMobile" - China Mobile Ecloud Elastic Object Storage (EOS) - "Cloudflare" - Cloudflare R2 Storage - "DigitalOcean" - DigitalOcean Spaces - "Dreamhost" - Dreamhost DreamObjects - "Exaba" - Exaba Object Storage - "FlashBlade" - Pure Storage FlashBlade Object Storage - "GCS" - Google Cloud Storage - "HuaweiOBS" - Huawei Object Storage Service - "IBMCOS" - IBM COS S3 - "IDrive" - IDrive e2 - "IONOS" - IONOS Cloud - "LyveCloud" - Seagate Lyve Cloud - "Leviia" - Leviia Object Storage - "Liara" - Liara Object Storage - "Linode" - Linode Object Storage - "Magalu" - Magalu Object Storage - "Mega" - MEGA S4 Object Storage - "Minio" - Minio Object Storage - "Netease" - Netease Object Storage (NOS) - "Outscale" - OUTSCALE Object Storage (OOS) - "OVHcloud" - OVHcloud Object Storage - "Petabox" - Petabox Object Storage - "RackCorp" - RackCorp Object Storage - "Rclone" - Rclone S3 Server - "Scaleway" - Scaleway Object Storage - "SeaweedFS" - SeaweedFS S3 - "Selectel" - Selectel Object Storage - "StackPath" - StackPath Object Storage - "Storj" - Storj (S3 Compatible Gateway) - "Synology" - Synology C2 Object Storage - "TencentCOS" - Tencent Cloud Object Storage (COS) - "Wasabi" - Wasabi Object Storage - "Qiniu" - Qiniu Object Storage (Kodo) - "Zata" - Zata (S3 compatible Gateway) - "Other" - Any other S3 compatible provider --s3-env-auth Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Properties: - Config: env_auth - Env Var: RCLONE_S3_ENV_AUTH - Type: bool - Default: false - Examples: - "false" - Enter AWS credentials in the next step. - "true" - Get AWS credentials from the environment (env vars or IAM). --s3-access-key-id AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Properties: - Config: access_key_id - Env Var: RCLONE_S3_ACCESS_KEY_ID - Type: string - Required: false --s3-secret-access-key AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Properties: - Config: secret_access_key - Env Var: RCLONE_S3_SECRET_ACCESS_KEY - Type: string - Required: false --s3-region Region to connect to. Properties: - Config: region - Env Var: RCLONE_S3_REGION - Provider: AWS - Type: string - Required: false - Examples: - "us-east-1" - The default endpoint - a good choice if you are unsure. - US Region, Northern Virginia, or Pacific Northwest. - Leave location constraint empty. - "us-east-2" - US East (Ohio) Region. - Needs location constraint us-east-2. - "us-west-1" - US West (Northern California) Region. - Needs location constraint us-west-1. - "us-west-2" - US West (Oregon) Region. - Needs location constraint us-west-2. - "ca-central-1" - Canada (Central) Region. - Needs location constraint ca-central-1. - "eu-west-1" - EU (Ireland) Region. - Needs location constraint EU or eu-west-1. - "eu-west-2" - EU (London) Region. - Needs location constraint eu-west-2. - "eu-west-3" - EU (Paris) Region. - Needs location constraint eu-west-3. - "eu-north-1" - EU (Stockholm) Region. - Needs location constraint eu-north-1. - "eu-south-1" - EU (Milan) Region. - Needs location constraint eu-south-1. - "eu-central-1" - EU (Frankfurt) Region. - Needs location constraint eu-central-1. - "ap-southeast-1" - Asia Pacific (Singapore) Region. - Needs location constraint ap-southeast-1. - "ap-southeast-2" - Asia Pacific (Sydney) Region. - Needs location constraint ap-southeast-2. - "ap-northeast-1" - Asia Pacific (Tokyo) Region. - Needs location constraint ap-northeast-1. - "ap-northeast-2" - Asia Pacific (Seoul). - Needs location constraint ap-northeast-2. - "ap-northeast-3" - Asia Pacific (Osaka-Local). - Needs location constraint ap-northeast-3. - "ap-south-1" - Asia Pacific (Mumbai). - Needs location constraint ap-south-1. - "ap-east-1" - Asia Pacific (Hong Kong) Region. - Needs location constraint ap-east-1. - "sa-east-1" - South America (Sao Paulo) Region. - Needs location constraint sa-east-1. - "il-central-1" - Israel (Tel Aviv) Region. - Needs location constraint il-central-1. - "me-south-1" - Middle East (Bahrain) Region. - Needs location constraint me-south-1. - "af-south-1" - Africa (Cape Town) Region. - Needs location constraint af-south-1. - "cn-north-1" - China (Beijing) Region. - Needs location constraint cn-north-1. - "cn-northwest-1" - China (Ningxia) Region. - Needs location constraint cn-northwest-1. - "us-gov-east-1" - AWS GovCloud (US-East) Region. - Needs location constraint us-gov-east-1. - "us-gov-west-1" - AWS GovCloud (US) Region. - Needs location constraint us-gov-west-1. --s3-endpoint Endpoint for S3 API. Leave blank if using AWS to use the default endpoint for the region. Properties: - Config: endpoint - Env Var: RCLONE_S3_ENDPOINT - Provider: AWS - Type: string - Required: false --s3-location-constraint Location constraint - must be set to match the Region. Used when creating buckets only. Properties: - Config: location_constraint - Env Var: RCLONE_S3_LOCATION_CONSTRAINT - Provider: AWS - Type: string - Required: false - Examples: - "" - Empty for US Region, Northern Virginia, or Pacific Northwest - "us-east-2" - US East (Ohio) Region - "us-west-1" - US West (Northern California) Region - "us-west-2" - US West (Oregon) Region - "ca-central-1" - Canada (Central) Region - "eu-west-1" - EU (Ireland) Region - "eu-west-2" - EU (London) Region - "eu-west-3" - EU (Paris) Region - "eu-north-1" - EU (Stockholm) Region - "eu-south-1" - EU (Milan) Region - "EU" - EU Region - "ap-southeast-1" - Asia Pacific (Singapore) Region - "ap-southeast-2" - Asia Pacific (Sydney) Region - "ap-northeast-1" - Asia Pacific (Tokyo) Region - "ap-northeast-2" - Asia Pacific (Seoul) Region - "ap-northeast-3" - Asia Pacific (Osaka-Local) Region - "ap-south-1" - Asia Pacific (Mumbai) Region - "ap-east-1" - Asia Pacific (Hong Kong) Region - "sa-east-1" - South America (Sao Paulo) Region - "il-central-1" - Israel (Tel Aviv) Region - "me-south-1" - Middle East (Bahrain) Region - "af-south-1" - Africa (Cape Town) Region - "cn-north-1" - China (Beijing) Region - "cn-northwest-1" - China (Ningxia) Region - "us-gov-east-1" - AWS GovCloud (US-East) Region - "us-gov-west-1" - AWS GovCloud (US) Region --s3-acl Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Properties: - Config: acl - Env Var: RCLONE_S3_ACL - Provider: !Storj,Selectel,Synology,Cloudflare,FlashBlade,Mega - Type: string - Required: false - Examples: - "default" - Owner gets Full_CONTROL. - No one else has access rights (default). - "private" - Owner gets FULL_CONTROL. - No one else has access rights (default). - "public-read" - Owner gets FULL_CONTROL. - The AllUsers group gets READ access. - "public-read-write" - Owner gets FULL_CONTROL. - The AllUsers group gets READ and WRITE access. - Granting this on a bucket is generally not recommended. - "authenticated-read" - Owner gets FULL_CONTROL. - The AuthenticatedUsers group gets READ access. - "bucket-owner-read" - Object owner gets FULL_CONTROL. - Bucket owner gets READ access. - If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. - "bucket-owner-full-control" - Both the object owner and the bucket owner get FULL_CONTROL over the object. - If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. - "private" - Owner gets FULL_CONTROL. - No one else has access rights (default). - This acl is available on IBM Cloud (Infra), IBM Cloud (Storage), On-Premise COS. - "public-read" - Owner gets FULL_CONTROL. - The AllUsers group gets READ access. - This acl is available on IBM Cloud (Infra), IBM Cloud (Storage), On-Premise IBM COS. - "public-read-write" - Owner gets FULL_CONTROL. - The AllUsers group gets READ and WRITE access. - This acl is available on IBM Cloud (Infra), On-Premise IBM COS. - "authenticated-read" - Owner gets FULL_CONTROL. - The AuthenticatedUsers group gets READ access. - Not supported on Buckets. - This acl is available on IBM Cloud (Infra) and On-Premise IBM COS. --s3-server-side-encryption The server-side encryption algorithm used when storing this object in S3. Properties: - Config: server_side_encryption - Env Var: RCLONE_S3_SERVER_SIDE_ENCRYPTION - Provider: AWS,Ceph,ChinaMobile,Minio - Type: string - Required: false - Examples: - "" - None - "AES256" - AES256 - "aws:kms" - aws:kms --s3-sse-kms-key-id If using KMS ID you must provide the ARN of Key. Properties: - Config: sse_kms_key_id - Env Var: RCLONE_S3_SSE_KMS_KEY_ID - Provider: AWS,Ceph,Minio - Type: string - Required: false - Examples: - "" - None - "arn:aws:kms:us-east-1:*" - arn:aws:kms:* --s3-storage-class The storage class to use when storing new objects in S3. Properties: - Config: storage_class - Env Var: RCLONE_S3_STORAGE_CLASS - Provider: AWS - Type: string - Required: false - Examples: - "" - Default - "STANDARD" - Standard storage class - "REDUCED_REDUNDANCY" - Reduced redundancy storage class - "STANDARD_IA" - Standard Infrequent Access storage class - "ONEZONE_IA" - One Zone Infrequent Access storage class - "GLACIER" - Glacier Flexible Retrieval storage class - "DEEP_ARCHIVE" - Glacier Deep Archive storage class - "INTELLIGENT_TIERING" - Intelligent-Tiering storage class - "GLACIER_IR" - Glacier Instant Retrieval storage class --s3-ibm-api-key IBM API Key to be used to obtain IAM token Properties: - Config: ibm_api_key - Env Var: RCLONE_S3_IBM_API_KEY - Provider: IBMCOS - Type: string - Required: false --s3-ibm-resource-instance-id IBM service instance id Properties: - Config: ibm_resource_instance_id - Env Var: RCLONE_S3_IBM_RESOURCE_INSTANCE_ID - Provider: IBMCOS - Type: string - Required: false Advanced options Here are the Advanced options specific to s3 (Amazon S3 Compliant Storage Providers including AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, Exaba, FlashBlade, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, Magalu, Mega, Minio, Netease, Outscale, OVHcloud, Petabox, RackCorp, Rclone, Scaleway, SeaweedFS, Selectel, StackPath, Storj, Synology, TencentCOS, Wasabi, Qiniu, Zata and others). --s3-bucket-acl Canned ACL used when creating buckets. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when only when creating buckets. If it isn't set then "acl" is used instead. If the "acl" and "bucket_acl" are empty strings then no X-Amz-Acl: header is added and the default (private) will be used. Properties: - Config: bucket_acl - Env Var: RCLONE_S3_BUCKET_ACL - Provider: !Storj,Selectel,Synology,Cloudflare,FlashBlade - Type: string - Required: false - Examples: - "private" - Owner gets FULL_CONTROL. - No one else has access rights (default). - "public-read" - Owner gets FULL_CONTROL. - The AllUsers group gets READ access. - "public-read-write" - Owner gets FULL_CONTROL. - The AllUsers group gets READ and WRITE access. - Granting this on a bucket is generally not recommended. - "authenticated-read" - Owner gets FULL_CONTROL. - The AuthenticatedUsers group gets READ access. --s3-requester-pays Enables requester pays option when interacting with S3 bucket. Properties: - Config: requester_pays - Env Var: RCLONE_S3_REQUESTER_PAYS - Provider: AWS - Type: bool - Default: false --s3-sse-customer-algorithm If using SSE-C, the server-side encryption algorithm used when storing this object in S3. Properties: - Config: sse_customer_algorithm - Env Var: RCLONE_S3_SSE_CUSTOMER_ALGORITHM - Provider: AWS,Ceph,ChinaMobile,Minio - Type: string - Required: false - Examples: - "" - None - "AES256" - AES256 --s3-sse-customer-key To use SSE-C you may provide the secret encryption key used to encrypt/decrypt your data. Alternatively you can provide --sse-customer-key-base64. Properties: - Config: sse_customer_key - Env Var: RCLONE_S3_SSE_CUSTOMER_KEY - Provider: AWS,Ceph,ChinaMobile,Minio - Type: string - Required: false - Examples: - "" - None --s3-sse-customer-key-base64 If using SSE-C you must provide the secret encryption key encoded in base64 format to encrypt/decrypt your data. Alternatively you can provide --sse-customer-key. Properties: - Config: sse_customer_key_base64 - Env Var: RCLONE_S3_SSE_CUSTOMER_KEY_BASE64 - Provider: AWS,Ceph,ChinaMobile,Minio - Type: string - Required: false - Examples: - "" - None --s3-sse-customer-key-md5 If using SSE-C you may provide the secret encryption key MD5 checksum (optional). If you leave it blank, this is calculated automatically from the sse_customer_key provided. Properties: - Config: sse_customer_key_md5 - Env Var: RCLONE_S3_SSE_CUSTOMER_KEY_MD5 - Provider: AWS,Ceph,ChinaMobile,Minio - Type: string - Required: false - Examples: - "" - None --s3-upload-cutoff Cutoff for switching to chunked upload. Any files larger than this will be uploaded in chunks of chunk_size. The minimum is 0 and the maximum is 5 GiB. Properties: - Config: upload_cutoff - Env Var: RCLONE_S3_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 200Mi --s3-chunk-size Chunk size to use for uploading. When uploading files larger than upload_cutoff or files with unknown size (e.g. from "rclone rcat" or uploaded with "rclone mount" or google photos or google docs) they will be uploaded as multipart uploads using this chunk size. Note that "--s3-upload-concurrency" chunks of this size are buffered in memory per transfer. If you are transferring large files over high-speed links and you have enough memory, then increasing this will speed up the transfers. Rclone will automatically increase the chunk size when uploading a large file of known size to stay below the 10,000 chunks limit. Files of unknown size are uploaded with the configured chunk_size. Since the default chunk size is 5 MiB and there can be at most 10,000 chunks, this means that by default the maximum size of a file you can stream upload is 48 GiB. If you wish to stream upload larger files then you will need to increase chunk_size. Increasing the chunk size decreases the accuracy of the progress statistics displayed with "-P" flag. Rclone treats chunk as sent when it's buffered by the AWS SDK, when in fact it may still be uploading. A bigger chunk size means a bigger AWS SDK buffer and progress reporting more deviating from the truth. Properties: - Config: chunk_size - Env Var: RCLONE_S3_CHUNK_SIZE - Type: SizeSuffix - Default: 5Mi --s3-max-upload-parts Maximum number of parts in a multipart upload. This option defines the maximum number of multipart chunks to use when doing a multipart upload. This can be useful if a service does not support the AWS S3 specification of 10,000 chunks. Rclone will automatically increase the chunk size when uploading a large file of a known size to stay below this number of chunks limit. Properties: - Config: max_upload_parts - Env Var: RCLONE_S3_MAX_UPLOAD_PARTS - Type: int - Default: 10000 --s3-copy-cutoff Cutoff for switching to multipart copy. Any files larger than this that need to be server-side copied will be copied in chunks of this size. The minimum is 0 and the maximum is 5 GiB. Properties: - Config: copy_cutoff - Env Var: RCLONE_S3_COPY_CUTOFF - Type: SizeSuffix - Default: 4.656Gi --s3-disable-checksum Don't store MD5 checksum with object metadata. Normally rclone will calculate the MD5 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading. Properties: - Config: disable_checksum - Env Var: RCLONE_S3_DISABLE_CHECKSUM - Type: bool - Default: false --s3-shared-credentials-file Path to the shared credentials file. If env_auth = true then rclone can use a shared credentials file. If this variable is empty rclone will look for the "AWS_SHARED_CREDENTIALS_FILE" env variable. If the env value is empty it will default to the current user's home directory. Linux/OSX: "$HOME/.aws/credentials" Windows: "%USERPROFILE%\.aws\credentials" Properties: - Config: shared_credentials_file - Env Var: RCLONE_S3_SHARED_CREDENTIALS_FILE - Type: string - Required: false --s3-profile Profile to use in the shared credentials file. If env_auth = true then rclone can use a shared credentials file. This variable controls which profile is used in that file. If empty it will default to the environment variable "AWS_PROFILE" or "default" if that environment variable is also not set. Properties: - Config: profile - Env Var: RCLONE_S3_PROFILE - Type: string - Required: false --s3-session-token An AWS session token. Properties: - Config: session_token - Env Var: RCLONE_S3_SESSION_TOKEN - Type: string - Required: false --s3-upload-concurrency Concurrency for multipart uploads and copies. This is the number of chunks of the same file that are uploaded concurrently for multipart uploads and copies. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. Properties: - Config: upload_concurrency - Env Var: RCLONE_S3_UPLOAD_CONCURRENCY - Type: int - Default: 4 --s3-force-path-style If true use path style access if false use virtual hosted style. If this is true (the default) then rclone will use path style access, if false then rclone will use virtual path style. See the AWS S3 docs for more info. Some providers (e.g. AWS, Aliyun OSS, Netease COS, or Tencent COS) require this set to false - rclone will do this automatically based on the provider setting. Note that if your bucket isn't a valid DNS name, i.e. has '.' or '_' in, you'll need to set this to true. Properties: - Config: force_path_style - Env Var: RCLONE_S3_FORCE_PATH_STYLE - Type: bool - Default: true --s3-v2-auth If true use v2 authentication. If this is false (the default) then rclone will use v4 authentication. If it is set then rclone will use v2 authentication. Use this only if v4 signatures don't work, e.g. pre Jewel/v10 CEPH. Properties: - Config: v2_auth - Env Var: RCLONE_S3_V2_AUTH - Type: bool - Default: false --s3-use-dual-stack If true use AWS S3 dual-stack endpoint (IPv6 support). See AWS Docs on Dualstack Endpoints Properties: - Config: use_dual_stack - Env Var: RCLONE_S3_USE_DUAL_STACK - Type: bool - Default: false --s3-use-accelerate-endpoint If true use the AWS S3 accelerated endpoint. See: AWS S3 Transfer acceleration Properties: - Config: use_accelerate_endpoint - Env Var: RCLONE_S3_USE_ACCELERATE_ENDPOINT - Provider: AWS - Type: bool - Default: false --s3-use-arn-region If true, enables arn region support for the service. Properties: - Config: use_arn_region - Env Var: RCLONE_S3_USE_ARN_REGION - Type: bool - Default: false --s3-leave-parts-on-error If true avoid calling abort upload on a failure, leaving all successfully uploaded parts on S3 for manual recovery. It should be set to true for resuming uploads across different sessions. WARNING: Storing parts of an incomplete multipart upload counts towards space usage on S3 and will add additional costs if not cleaned up. Properties: - Config: leave_parts_on_error - Env Var: RCLONE_S3_LEAVE_PARTS_ON_ERROR - Provider: AWS - Type: bool - Default: false --s3-list-chunk Size of listing chunk (response list for each ListObject S3 request). This option is also known as "MaxKeys", "max-items", or "page-size" from the AWS S3 specification. Most services truncate the response list to 1000 objects even if requested more than that. In AWS S3 this is a global maximum and cannot be changed, see AWS S3. In Ceph, this can be increased with the "rgw list buckets max chunk" option. Properties: - Config: list_chunk - Env Var: RCLONE_S3_LIST_CHUNK - Type: int - Default: 1000 --s3-list-version Version of ListObjects to use: 1,2 or 0 for auto. When S3 originally launched it only provided the ListObjects call to enumerate objects in a bucket. However in May 2016 the ListObjectsV2 call was introduced. This is much higher performance and should be used if at all possible. If set to the default, 0, rclone will guess according to the provider set which list objects method to call. If it guesses wrong, then it may be set manually here. Properties: - Config: list_version - Env Var: RCLONE_S3_LIST_VERSION - Type: int - Default: 0 --s3-list-url-encode Whether to url encode listings: true/false/unset Some providers support URL encoding listings and where this is available this is more reliable when using control characters in file names. If this is set to unset (the default) then rclone will choose according to the provider setting what to apply, but you can override rclone's choice here. Properties: - Config: list_url_encode - Env Var: RCLONE_S3_LIST_URL_ENCODE - Type: Tristate - Default: unset --s3-no-check-bucket If set, don't attempt to check the bucket exists or create it. This can be useful when trying to minimise the number of transactions rclone does if you know the bucket exists already. It can also be needed if the user you are using does not have bucket creation permissions. Before v1.52.0 this would have passed silently due to a bug. Properties: - Config: no_check_bucket - Env Var: RCLONE_S3_NO_CHECK_BUCKET - Type: bool - Default: false --s3-no-head If set, don't HEAD uploaded objects to check integrity. This can be useful when trying to minimise the number of transactions rclone does. Setting it means that if rclone receives a 200 OK message after uploading an object with PUT then it will assume that it got uploaded properly. In particular it will assume: - the metadata, including modtime, storage class and content type was as uploaded - the size was as uploaded It reads the following items from the response for a single part PUT: - the MD5SUM - The uploaded date For multipart uploads these items aren't read. If an source object of unknown length is uploaded then rclone will do a HEAD request. Setting this flag increases the chance for undetected upload failures, in particular an incorrect size, so it isn't recommended for normal operation. In practice the chance of an undetected upload failure is very small even with this flag. Properties: - Config: no_head - Env Var: RCLONE_S3_NO_HEAD - Type: bool - Default: false --s3-no-head-object If set, do not do HEAD before GET when getting objects. Properties: - Config: no_head_object - Env Var: RCLONE_S3_NO_HEAD_OBJECT - Type: bool - Default: false --s3-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_S3_ENCODING - Type: Encoding - Default: Slash,InvalidUtf8,Dot --s3-memory-pool-flush-time How often internal memory buffer pools will be flushed. (no longer used) Properties: - Config: memory_pool_flush_time - Env Var: RCLONE_S3_MEMORY_POOL_FLUSH_TIME - Type: Duration - Default: 1m0s --s3-memory-pool-use-mmap Whether to use mmap buffers in internal memory pool. (no longer used) Properties: - Config: memory_pool_use_mmap - Env Var: RCLONE_S3_MEMORY_POOL_USE_MMAP - Type: bool - Default: false --s3-disable-http2 Disable usage of http2 for S3 backends. There is currently an unsolved issue with the s3 (specifically minio) backend and HTTP/2. HTTP/2 is enabled by default for the s3 backend but can be disabled here. When the issue is solved this flag will be removed. See: https://github.com/rclone/rclone/issues/4673, https://github.com/rclone/rclone/issues/3631 Properties: - Config: disable_http2 - Env Var: RCLONE_S3_DISABLE_HTTP2 - Type: bool - Default: false --s3-download-url Custom endpoint for downloads. This is usually set to a CloudFront CDN URL as AWS S3 offers cheaper egress for data downloaded through the CloudFront network. Properties: - Config: download_url - Env Var: RCLONE_S3_DOWNLOAD_URL - Type: string - Required: false --s3-directory-markers Upload an empty object with a trailing slash when a new directory is created Empty folders are unsupported for bucket based remotes, this option creates an empty object ending with "/", to persist the folder. Properties: - Config: directory_markers - Env Var: RCLONE_S3_DIRECTORY_MARKERS - Type: bool - Default: false --s3-use-multipart-etag Whether to use ETag in multipart uploads for verification This should be true, false or left unset to use the default for the provider. Properties: - Config: use_multipart_etag - Env Var: RCLONE_S3_USE_MULTIPART_ETAG - Type: Tristate - Default: unset --s3-use-unsigned-payload Whether to use an unsigned payload in PutObject Rclone has to avoid the AWS SDK seeking the body when calling PutObject. The AWS provider can add checksums in the trailer to avoid seeking but other providers can't. This should be true, false or left unset to use the default for the provider. Properties: - Config: use_unsigned_payload - Env Var: RCLONE_S3_USE_UNSIGNED_PAYLOAD - Type: Tristate - Default: unset --s3-use-presigned-request Whether to use a presigned request or PutObject for single part uploads If this is false rclone will use PutObject from the AWS SDK to upload an object. Versions of rclone < 1.59 use presigned requests to upload a single part object and setting this flag to true will re-enable that functionality. This shouldn't be necessary except in exceptional circumstances or for testing. Properties: - Config: use_presigned_request - Env Var: RCLONE_S3_USE_PRESIGNED_REQUEST - Type: bool - Default: false --s3-versions Include old versions in directory listings. Properties: - Config: versions - Env Var: RCLONE_S3_VERSIONS - Type: bool - Default: false --s3-version-at Show file versions as they were at the specified time. The parameter should be a date, "2006-01-02", datetime "2006-01-02 15:04:05" or a duration for that long ago, eg "100d" or "1h". Note that when using this no file write operations are permitted, so you can't upload files or delete them. See the time option docs for valid formats. Properties: - Config: version_at - Env Var: RCLONE_S3_VERSION_AT - Type: Time - Default: off --s3-version-deleted Show deleted file markers when using versions. This shows deleted file markers in the listing when using versions. These will appear as 0 size files. The only operation which can be performed on them is deletion. Deleting a delete marker will reveal the previous version. Deleted files will always show with a timestamp. Properties: - Config: version_deleted - Env Var: RCLONE_S3_VERSION_DELETED - Type: bool - Default: false --s3-decompress If set this will decompress gzip encoded objects. It is possible to upload objects to S3 with "Content-Encoding: gzip" set. Normally rclone will download these files as compressed objects. If this flag is set then rclone will decompress these files with "Content-Encoding: gzip" as they are received. This means that rclone can't check the size and hash but the file contents will be decompressed. Properties: - Config: decompress - Env Var: RCLONE_S3_DECOMPRESS - Type: bool - Default: false --s3-might-gzip Set this if the backend might gzip objects. Normally providers will not alter objects when they are downloaded. If an object was not uploaded with Content-Encoding: gzip then it won't be set on download. However some providers may gzip objects even if they weren't uploaded with Content-Encoding: gzip (eg Cloudflare). A symptom of this would be receiving errors like ERROR corrupted on transfer: sizes differ NNN vs MMM If you set this flag and rclone downloads an object with Content-Encoding: gzip set and chunked transfer encoding, then rclone will decompress the object on the fly. If this is set to unset (the default) then rclone will choose according to the provider setting what to apply, but you can override rclone's choice here. Properties: - Config: might_gzip - Env Var: RCLONE_S3_MIGHT_GZIP - Type: Tristate - Default: unset --s3-use-accept-encoding-gzip Whether to send Accept-Encoding: gzip header. By default, rclone will append Accept-Encoding: gzip to the request to download compressed objects whenever possible. However some providers such as Google Cloud Storage may alter the HTTP headers, breaking the signature of the request. A symptom of this would be receiving errors like SignatureDoesNotMatch: The request signature we calculated does not match the signature you provided. In this case, you might want to try disabling this option. Properties: - Config: use_accept_encoding_gzip - Env Var: RCLONE_S3_USE_ACCEPT_ENCODING_GZIP - Type: Tristate - Default: unset --s3-no-system-metadata Suppress setting and reading of system metadata Properties: - Config: no_system_metadata - Env Var: RCLONE_S3_NO_SYSTEM_METADATA - Type: bool - Default: false --s3-sts-endpoint Endpoint for STS (deprecated). Leave blank if using AWS to use the default endpoint for the region. Properties: - Config: sts_endpoint - Env Var: RCLONE_S3_STS_ENDPOINT - Provider: AWS - Type: string - Required: false --s3-use-already-exists Set if rclone should report BucketAlreadyExists errors on bucket creation. At some point during the evolution of the s3 protocol, AWS started returning an AlreadyOwnedByYou error when attempting to create a bucket that the user already owned, rather than a BucketAlreadyExists error. Unfortunately exactly what has been implemented by s3 clones is a little inconsistent, some return AlreadyOwnedByYou, some return BucketAlreadyExists and some return no error at all. This is important to rclone because it ensures the bucket exists by creating it on quite a lot of operations (unless --s3-no-check-bucket is used). If rclone knows the provider can return AlreadyOwnedByYou or returns no error then it can report BucketAlreadyExists errors when the user attempts to create a bucket not owned by them. Otherwise rclone ignores the BucketAlreadyExists error which can lead to confusion. This should be automatically set correctly for all providers rclone knows about - please make a bug report if not. Properties: - Config: use_already_exists - Env Var: RCLONE_S3_USE_ALREADY_EXISTS - Type: Tristate - Default: unset --s3-use-multipart-uploads Set if rclone should use multipart uploads. You can change this if you want to disable the use of multipart uploads. This shouldn't be necessary in normal operation. This should be automatically set correctly for all providers rclone knows about - please make a bug report if not. Properties: - Config: use_multipart_uploads - Env Var: RCLONE_S3_USE_MULTIPART_UPLOADS - Type: Tristate - Default: unset --s3-use-x-id Set if rclone should add x-id URL parameters. You can change this if you want to disable the AWS SDK from adding x-id URL parameters. This shouldn't be necessary in normal operation. This should be automatically set correctly for all providers rclone knows about - please make a bug report if not. Properties: - Config: use_x_id - Env Var: RCLONE_S3_USE_X_ID - Type: Tristate - Default: unset --s3-sign-accept-encoding Set if rclone should include Accept-Encoding as part of the signature. You can change this if you want to stop rclone including Accept-Encoding as part of the signature. This shouldn't be necessary in normal operation. This should be automatically set correctly for all providers rclone knows about - please make a bug report if not. Properties: - Config: sign_accept_encoding - Env Var: RCLONE_S3_SIGN_ACCEPT_ENCODING - Type: Tristate - Default: unset --s3-directory-bucket Set to use AWS Directory Buckets If you are using an AWS Directory Bucket then set this flag. This will ensure no Content-Md5 headers are sent and ensure ETag headers are not interpreted as MD5 sums. X-Amz-Meta-Md5chksum will be set on all objects whether single or multipart uploaded. This also sets no_check_bucket = true. Note that Directory Buckets do not support: - Versioning - Content-Encoding: gzip Rclone limitations with Directory Buckets: - rclone does not support creating Directory Buckets with rclone mkdir - ... or removing them with rclone rmdir yet - Directory Buckets do not appear when doing rclone lsf at the top level. - Rclone can't remove auto created directories yet. In theory this should work with directory_markers = true but it doesn't. - Directories don't seem to appear in recursive (ListR) listings. Properties: - Config: directory_bucket - Env Var: RCLONE_S3_DIRECTORY_BUCKET - Provider: AWS - Type: bool - Default: false --s3-sdk-log-mode Set to debug the SDK This can be set to a comma separated list of the following functions: - Signing - Retries - Request - RequestWithBody - Response - ResponseWithBody - DeprecatedUsage - RequestEventMessage - ResponseEventMessage Use Off to disable and All to set all log levels. You will need to use -vv to see the debug level logs. Properties: - Config: sdk_log_mode - Env Var: RCLONE_S3_SDK_LOG_MODE - Type: Bits - Default: Off --s3-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_S3_DESCRIPTION - Type: string - Required: false Metadata User metadata is stored as x-amz-meta- keys. S3 metadata keys are case insensitive and are always returned in lower case. Here are the possible system metadata items for the s3 backend. ------------------------------------------------------------------------------------------------------------------ Name Help Type Example Read Only --------------------- --------------------- ----------- ------------------------------------- -------------------- btime Time of file birth RFC 3339 2006-01-02T15:04:05.999999999Z07:00 Y (creation) read from Last-Modified header cache-control Cache-Control header string no-cache N content-disposition Content-Disposition string inline N header content-encoding Content-Encoding string gzip N header content-language Content-Language string en-US N header content-type Content-Type header string text/plain N mtime Time of last RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N modification, read from rclone metadata tier Tier of the object string GLACIER Y ------------------------------------------------------------------------------------------------------------------ See the metadata docs for more info. Backend commands Here are the commands specific to the s3 backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the backend command for more info on how to pass options and arguments. These can be run on a running backend using the rc command backend/command. restore Restore objects from GLACIER or INTELLIGENT-TIERING archive tier rclone backend restore remote: [options] [+] This command can be used to restore one or more objects from GLACIER to normal storage or from INTELLIGENT-TIERING Archive Access / Deep Archive Access tier to the Frequent Access tier. Usage Examples: rclone backend restore s3:bucket/path/to/ --include /object -o priority=PRIORITY -o lifetime=DAYS rclone backend restore s3:bucket/path/to/directory -o priority=PRIORITY -o lifetime=DAYS rclone backend restore s3:bucket -o priority=PRIORITY -o lifetime=DAYS rclone backend restore s3:bucket/path/to/directory -o priority=PRIORITY This flag also obeys the filters. Test first with --interactive/-i or --dry-run flags rclone --interactive backend restore --include "*.txt" s3:bucket/path -o priority=Standard -o lifetime=1 All the objects shown will be marked for restore, then rclone backend restore --include "*.txt" s3:bucket/path -o priority=Standard -o lifetime=1 It returns a list of status dictionaries with Remote and Status keys. The Status will be OK if it was successful or an error message if not. [ { "Status": "OK", "Remote": "test.txt" }, { "Status": "OK", "Remote": "test/file4.txt" } ] Options: - "description": The optional description for the job. - "lifetime": Lifetime of the active copy in days, ignored for INTELLIGENT-TIERING storage - "priority": Priority of restore: Standard|Expedited|Bulk restore-status Show the restore status for objects being restored from GLACIER or INTELLIGENT-TIERING storage rclone backend restore-status remote: [options] [+] This command can be used to show the status for objects being restored from GLACIER to normal storage or from INTELLIGENT-TIERING Archive Access / Deep Archive Access tier to the Frequent Access tier. Usage Examples: rclone backend restore-status s3:bucket/path/to/object rclone backend restore-status s3:bucket/path/to/directory rclone backend restore-status -o all s3:bucket/path/to/directory This command does not obey the filters. It returns a list of status dictionaries. [ { "Remote": "file.txt", "VersionID": null, "RestoreStatus": { "IsRestoreInProgress": true, "RestoreExpiryDate": "2023-09-06T12:29:19+01:00" }, "StorageClass": "GLACIER" }, { "Remote": "test.pdf", "VersionID": null, "RestoreStatus": { "IsRestoreInProgress": false, "RestoreExpiryDate": "2023-09-06T12:29:19+01:00" }, "StorageClass": "DEEP_ARCHIVE" }, { "Remote": "test.gz", "VersionID": null, "RestoreStatus": { "IsRestoreInProgress": true, "RestoreExpiryDate": "null" }, "StorageClass": "INTELLIGENT_TIERING" } ] Options: - "all": if set then show all objects, not just ones with restore status list-multipart-uploads List the unfinished multipart uploads rclone backend list-multipart-uploads remote: [options] [+] This command lists the unfinished multipart uploads in JSON format. rclone backend list-multipart s3:bucket/path/to/object It returns a dictionary of buckets with values as lists of unfinished multipart uploads. You can call it with no bucket in which case it lists all bucket, with a bucket or with a bucket and path. { "rclone": [ { "Initiated": "2020-06-26T14:20:36Z", "Initiator": { "DisplayName": "XXX", "ID": "arn:aws:iam::XXX:user/XXX" }, "Key": "KEY", "Owner": { "DisplayName": null, "ID": "XXX" }, "StorageClass": "STANDARD", "UploadId": "XXX" } ], "rclone-1000files": [], "rclone-dst": [] } cleanup Remove unfinished multipart uploads. rclone backend cleanup remote: [options] [+] This command removes unfinished multipart uploads of age greater than max-age which defaults to 24 hours. Note that you can use --interactive/-i or --dry-run with this command to see what it would do. rclone backend cleanup s3:bucket/path/to/object rclone backend cleanup -o max-age=7w s3:bucket/path/to/object Durations are parsed as per the rest of rclone, 2h, 7d, 7w etc. Options: - "max-age": Max age of upload to delete cleanup-hidden Remove old versions of files. rclone backend cleanup-hidden remote: [options] [+] This command removes any old hidden versions of files on a versions enabled bucket. Note that you can use --interactive/-i or --dry-run with this command to see what it would do. rclone backend cleanup-hidden s3:bucket/path/to/dir versioning Set/get versioning support for a bucket. rclone backend versioning remote: [options] [+] This command sets versioning support if a parameter is passed and then returns the current versioning status for the bucket supplied. rclone backend versioning s3:bucket # read status only rclone backend versioning s3:bucket Enabled rclone backend versioning s3:bucket Suspended It may return "Enabled", "Suspended" or "Unversioned". Note that once versioning has been enabled the status can't be set back to "Unversioned". set Set command for updating the config parameters. rclone backend set remote: [options] [+] This set command can be used to update the config parameters for a running s3 backend. Usage Examples: rclone backend set s3: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=s3: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=s3: -o session_token=X -o access_key_id=X -o secret_access_key=X The option keys are named as they are in the config file. This rebuilds the connection to the s3 backend when it is called with the new parameters. Only new parameters need be passed as the values will default to those currently in use. It doesn't return anything. Anonymous access to public buckets If you want to use rclone to access a public bucket, configure with a blank access_key_id and secret_access_key. Your config should end up looking like this: [anons3] type = s3 provider = AWS Then use it as normal with the name of the public bucket, e.g. rclone lsd anons3:1000genomes You will be able to list and copy data but not upload it. You can also do this entirely on the command line rclone lsd :s3,provider=AWS:1000genomes Providers AWS S3 This is the provider used as main example and described in the configuration section above. AWS Directory Buckets From rclone v1.69 Directory Buckets are supported. You will need to set the directory_buckets = true config parameter or use --s3-directory-buckets. Note that rclone cannot yet: - Create directory buckets - List directory buckets See the --s3-directory-buckets flag for more info AWS Snowball Edge AWS Snowball is a hardware appliance used for transferring bulk data back to AWS. Its main software interface is S3 object storage. To use rclone with AWS Snowball Edge devices, configure as standard for an 'S3 Compatible Service'. If using rclone pre v1.59 be sure to set upload_cutoff = 0 otherwise you will run into authentication header issues as the snowball device does not support query parameter based authentication. With rclone v1.59 or later setting upload_cutoff should not be necessary. eg. [snowball] type = s3 provider = Other access_key_id = YOUR_ACCESS_KEY secret_access_key = YOUR_SECRET_KEY endpoint = http://[IP of Snowball]:8080 upload_cutoff = 0 Alibaba OSS Here is an example of making an Alibaba Cloud (Aliyun) OSS configuration. First run: rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> oss Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ "s3" [snip] Storage> s3 Choose your S3 provider. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Amazon Web Services (AWS) S3 \ "AWS" 2 / Alibaba Cloud Object Storage System (OSS) formerly Aliyun \ "Alibaba" 3 / Ceph Object Storage \ "Ceph" [snip] provider> Alibaba Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Enter a boolean value (true or false). Press Enter for the default ("false"). Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). access_key_id> accesskeyid AWS Secret Access Key (password) Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). secret_access_key> secretaccesskey Endpoint for OSS API. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / East China 1 (Hangzhou) \ "oss-cn-hangzhou.aliyuncs.com" 2 / East China 2 (Shanghai) \ "oss-cn-shanghai.aliyuncs.com" 3 / North China 1 (Qingdao) \ "oss-cn-qingdao.aliyuncs.com" [snip] endpoint> 1 Canned ACL used when creating buckets and storing or copying objects. Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Owner gets FULL_CONTROL. No one else has access rights (default). \ "private" 2 / Owner gets FULL_CONTROL. The AllUsers group gets READ access. \ "public-read" / Owner gets FULL_CONTROL. The AllUsers group gets READ and WRITE access. [snip] acl> 1 The storage class to use when storing new objects in OSS. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Default \ "" 2 / Standard storage class \ "STANDARD" 3 / Archive storage mode. \ "GLACIER" 4 / Infrequent access storage mode. \ "STANDARD_IA" storage_class> 1 Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config -------------------- [oss] type = s3 provider = Alibaba env_auth = false access_key_id = accesskeyid secret_access_key = secretaccesskey endpoint = oss-cn-hangzhou.aliyuncs.com acl = private storage_class = Standard -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y ArvanCloud ArvanCloud ArvanCloud Object Storage goes beyond the limited traditional file storage. It gives you access to backup and archived files and allows sharing. Files like profile image in the app, images sent by users or scanned documents can be stored securely and easily in our Object Storage service. ArvanCloud provides an S3 interface which can be configured for use with rclone like this. No remotes found, make a new one? n) New remote s) Set configuration password n/s> n name> ArvanCloud Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Amazon S3 (also Dreamhost, Ceph, ChinaMobile, ArvanCloud, Liara, Minio) \ "s3" [snip] Storage> s3 Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID - leave blank for anonymous access or runtime credentials. access_key_id> YOURACCESSKEY AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials. secret_access_key> YOURSECRETACCESSKEY Region to connect to. Choose a number from below, or type in your own value / The default endpoint - a good choice if you are unsure. 1 | US Region, Northern Virginia, or Pacific Northwest. | Leave location constraint empty. \ "us-east-1" [snip] region> Endpoint for S3 API. Leave blank if using ArvanCloud to use the default endpoint for the region. Specify if using an S3 clone such as Ceph. endpoint> s3.arvanstorage.com Location constraint - must be set to match the Region. Used when creating buckets only. Choose a number from below, or type in your own value 1 / Empty for Iran-Tehran Region. \ "" [snip] location_constraint> Canned ACL used when creating buckets and/or storing objects in S3. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Choose a number from below, or type in your own value 1 / Owner gets FULL_CONTROL. No one else has access rights (default). \ "private" [snip] acl> The server-side encryption algorithm used when storing this object in S3. Choose a number from below, or type in your own value 1 / None \ "" 2 / AES256 \ "AES256" server_side_encryption> The storage class to use when storing objects in S3. Choose a number from below, or type in your own value 1 / Default \ "" 2 / Standard storage class \ "STANDARD" storage_class> Remote config -------------------- [ArvanCloud] env_auth = false access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY region = ir-thr-at1 endpoint = s3.arvanstorage.com location_constraint = acl = server_side_encryption = storage_class = -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y This will leave the config file looking like this. [ArvanCloud] type = s3 provider = ArvanCloud env_auth = false access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY region = endpoint = s3.arvanstorage.com location_constraint = acl = server_side_encryption = storage_class = Ceph Ceph is an open-source, unified, distributed storage system designed for excellent performance, reliability and scalability. It has an S3 compatible object storage interface. To use rclone with Ceph, configure as above but leave the region blank and set the endpoint. You should end up with something like this in your config: [ceph] type = s3 provider = Ceph env_auth = false access_key_id = XXX secret_access_key = YYY region = endpoint = https://ceph.endpoint.example.com location_constraint = acl = server_side_encryption = storage_class = If you are using an older version of CEPH (e.g. 10.2.x Jewel) and a version of rclone before v1.59 then you may need to supply the parameter --s3-upload-cutoff 0 or put this in the config file as upload_cutoff 0 to work around a bug which causes uploading of small files to fail. Note also that Ceph sometimes puts / in the passwords it gives users. If you read the secret access key using the command line tools you will get a JSON blob with the / escaped as \/. Make sure you only write / in the secret access key. Eg the dump from Ceph looks something like this (irrelevant keys removed). { "user_id": "xxx", "display_name": "xxxx", "keys": [ { "user": "xxx", "access_key": "xxxxxx", "secret_key": "xxxxxx\/xxxx" } ], } Because this is a json dump, it is encoding the / as \/, so if you use the secret key as xxxxxx/xxxx it will work fine. China Mobile Ecloud Elastic Object Storage (EOS) Here is an example of making an China Mobile Ecloud Elastic Object Storage (EOS) configuration. First run: rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> ChinaMobile Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. ... XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) ... Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. ... 4 / China Mobile Ecloud Elastic Object Storage (EOS) \ (ChinaMobile) ... provider> ChinaMobile Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> accesskeyid Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> secretaccesskey Option endpoint. Endpoint for China Mobile Ecloud Elastic Object Storage (EOS) API. Choose a number from below, or type in your own value. Press Enter to leave empty. / The default endpoint - a good choice if you are unsure. 1 | East China (Suzhou) \ (eos-wuxi-1.cmecloud.cn) 2 / East China (Jinan) \ (eos-jinan-1.cmecloud.cn) 3 / East China (Hangzhou) \ (eos-ningbo-1.cmecloud.cn) 4 / East China (Shanghai-1) \ (eos-shanghai-1.cmecloud.cn) 5 / Central China (Zhengzhou) \ (eos-zhengzhou-1.cmecloud.cn) 6 / Central China (Changsha-1) \ (eos-hunan-1.cmecloud.cn) 7 / Central China (Changsha-2) \ (eos-zhuzhou-1.cmecloud.cn) 8 / South China (Guangzhou-2) \ (eos-guangzhou-1.cmecloud.cn) 9 / South China (Guangzhou-3) \ (eos-dongguan-1.cmecloud.cn) 10 / North China (Beijing-1) \ (eos-beijing-1.cmecloud.cn) 11 / North China (Beijing-2) \ (eos-beijing-2.cmecloud.cn) 12 / North China (Beijing-3) \ (eos-beijing-4.cmecloud.cn) 13 / North China (Huhehaote) \ (eos-huhehaote-1.cmecloud.cn) 14 / Southwest China (Chengdu) \ (eos-chengdu-1.cmecloud.cn) 15 / Southwest China (Chongqing) \ (eos-chongqing-1.cmecloud.cn) 16 / Southwest China (Guiyang) \ (eos-guiyang-1.cmecloud.cn) 17 / Nouthwest China (Xian) \ (eos-xian-1.cmecloud.cn) 18 / Yunnan China (Kunming) \ (eos-yunnan.cmecloud.cn) 19 / Yunnan China (Kunming-2) \ (eos-yunnan-2.cmecloud.cn) 20 / Tianjin China (Tianjin) \ (eos-tianjin-1.cmecloud.cn) 21 / Jilin China (Changchun) \ (eos-jilin-1.cmecloud.cn) 22 / Hubei China (Xiangyan) \ (eos-hubei-1.cmecloud.cn) 23 / Jiangxi China (Nanchang) \ (eos-jiangxi-1.cmecloud.cn) 24 / Gansu China (Lanzhou) \ (eos-gansu-1.cmecloud.cn) 25 / Shanxi China (Taiyuan) \ (eos-shanxi-1.cmecloud.cn) 26 / Liaoning China (Shenyang) \ (eos-liaoning-1.cmecloud.cn) 27 / Hebei China (Shijiazhuang) \ (eos-hebei-1.cmecloud.cn) 28 / Fujian China (Xiamen) \ (eos-fujian-1.cmecloud.cn) 29 / Guangxi China (Nanning) \ (eos-guangxi-1.cmecloud.cn) 30 / Anhui China (Huainan) \ (eos-anhui-1.cmecloud.cn) endpoint> 1 Option location_constraint. Location constraint - must match endpoint. Used when creating buckets only. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / East China (Suzhou) \ (wuxi1) 2 / East China (Jinan) \ (jinan1) 3 / East China (Hangzhou) \ (ningbo1) 4 / East China (Shanghai-1) \ (shanghai1) 5 / Central China (Zhengzhou) \ (zhengzhou1) 6 / Central China (Changsha-1) \ (hunan1) 7 / Central China (Changsha-2) \ (zhuzhou1) 8 / South China (Guangzhou-2) \ (guangzhou1) 9 / South China (Guangzhou-3) \ (dongguan1) 10 / North China (Beijing-1) \ (beijing1) 11 / North China (Beijing-2) \ (beijing2) 12 / North China (Beijing-3) \ (beijing4) 13 / North China (Huhehaote) \ (huhehaote1) 14 / Southwest China (Chengdu) \ (chengdu1) 15 / Southwest China (Chongqing) \ (chongqing1) 16 / Southwest China (Guiyang) \ (guiyang1) 17 / Nouthwest China (Xian) \ (xian1) 18 / Yunnan China (Kunming) \ (yunnan) 19 / Yunnan China (Kunming-2) \ (yunnan2) 20 / Tianjin China (Tianjin) \ (tianjin1) 21 / Jilin China (Changchun) \ (jilin1) 22 / Hubei China (Xiangyan) \ (hubei1) 23 / Jiangxi China (Nanchang) \ (jiangxi1) 24 / Gansu China (Lanzhou) \ (gansu1) 25 / Shanxi China (Taiyuan) \ (shanxi1) 26 / Liaoning China (Shenyang) \ (liaoning1) 27 / Hebei China (Shijiazhuang) \ (hebei1) 28 / Fujian China (Xiamen) \ (fujian1) 29 / Guangxi China (Nanning) \ (guangxi1) 30 / Anhui China (Huainan) \ (anhui1) location_constraint> 1 Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) / Owner gets FULL_CONTROL. 3 | The AllUsers group gets READ and WRITE access. | Granting this on a bucket is generally not recommended. \ (public-read-write) / Owner gets FULL_CONTROL. 4 | The AuthenticatedUsers group gets READ access. \ (authenticated-read) / Object owner gets FULL_CONTROL. acl> private Option server_side_encryption. The server-side encryption algorithm used when storing this object in S3. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / None \ () 2 / AES256 \ (AES256) server_side_encryption> Option storage_class. The storage class to use when storing new objects in ChinaMobile. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Default \ () 2 / Standard storage class \ (STANDARD) 3 / Archive storage mode \ (GLACIER) 4 / Infrequent access storage mode \ (STANDARD_IA) storage_class> Edit advanced config? y) Yes n) No (default) y/n> n -------------------- [ChinaMobile] type = s3 provider = ChinaMobile access_key_id = accesskeyid secret_access_key = secretaccesskey endpoint = eos-wuxi-1.cmecloud.cn location_constraint = wuxi1 acl = private -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Cloudflare R2 Cloudflare R2 Storage allows developers to store large amounts of unstructured data without the costly egress bandwidth fees associated with typical cloud storage services. Here is an example of making a Cloudflare R2 configuration. First run: rclone config This will guide you through an interactive setup process. Note that all buckets are private, and all are stored in the same "auto" region. It is necessary to use Cloudflare workers to share the content of a bucket publicly. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> r2 Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. ... XX / Amazon S3 Compliant Storage Providers including AWS, Alibaba, Ceph, China Mobile, Cloudflare, ArvanCloud, DigitalOcean, Dreamhost, Huawei OBS, IBM COS, Lyve Cloud, Minio, Magalu, Netease, RackCorp, Scaleway, SeaweedFS, StackPath, Storj, Synology, Tencent COS and Wasabi \ (s3) ... Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. ... XX / Cloudflare R2 Storage \ (Cloudflare) ... provider> Cloudflare Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> ACCESS_KEY Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> SECRET_ACCESS_KEY Option region. Region to connect to. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / R2 buckets are automatically distributed across Cloudflare's data centers for low latency. \ (auto) region> 1 Option endpoint. Endpoint for S3 API. Required when using an S3 clone. Enter a value. Press Enter to leave empty. endpoint> https://ACCOUNT_ID.r2.cloudflarestorage.com Edit advanced config? y) Yes n) No (default) y/n> n -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y This will leave your config looking something like: [r2] type = s3 provider = Cloudflare access_key_id = ACCESS_KEY secret_access_key = SECRET_ACCESS_KEY region = auto endpoint = https://ACCOUNT_ID.r2.cloudflarestorage.com acl = private Now run rclone lsf r2: to see your buckets and rclone lsf r2:bucket to look within a bucket. For R2 tokens with the "Object Read & Write" permission, you may also need to add no_check_bucket = true for object uploads to work correctly. Note that Cloudflare decompresses files uploaded with Content-Encoding: gzip by default which is a deviation from what AWS does. If this is causing a problem then upload the files with --header-upload "Cache-Control: no-transform" A consequence of this is that Content-Encoding: gzip will never appear in the metadata on Cloudflare. DigitalOcean Spaces Spaces is an S3-interoperable object storage service from cloud provider DigitalOcean. To connect to DigitalOcean Spaces you will need an access key and secret key. These can be retrieved on the "Applications & API" page of the DigitalOcean control panel. They will be needed when prompted by rclone config for your access_key_id and secret_access_key. When prompted for a region or location_constraint, press enter to use the default value. The region must be included in the endpoint setting (e.g. nyc3.digitaloceanspaces.com). The default values can be used for other settings. Going through the whole process of creating a new remote by running rclone config, each prompt should be answered as shown below: Storage> s3 env_auth> 1 access_key_id> YOUR_ACCESS_KEY secret_access_key> YOUR_SECRET_KEY region> endpoint> nyc3.digitaloceanspaces.com location_constraint> acl> storage_class> The resulting configuration file should look like: [spaces] type = s3 provider = DigitalOcean env_auth = false access_key_id = YOUR_ACCESS_KEY secret_access_key = YOUR_SECRET_KEY region = endpoint = nyc3.digitaloceanspaces.com location_constraint = acl = server_side_encryption = storage_class = Once configured, you can create a new Space and begin copying files. For example: rclone mkdir spaces:my-new-space rclone copy /path/to/files spaces:my-new-space Dreamhost Dreamhost DreamObjects is an object storage system based on CEPH. To use rclone with Dreamhost, configure as above but leave the region blank and set the endpoint. You should end up with something like this in your config: [dreamobjects] type = s3 provider = DreamHost env_auth = false access_key_id = your_access_key secret_access_key = your_secret_key region = endpoint = objects-us-west-1.dream.io location_constraint = acl = private server_side_encryption = storage_class = Exaba Exaba is an on-premises, S3-compatible storage for service providers and large enterprises. It is quick to deploy, with dynamic node management, tenant accounting, and a built-in key management system. It delivers secure, high-performance data storage with flexible, usage-based pricing. A container version exaba/exaba is free for end-users and on that page you can find instructions on how to set it up. You will need to log into the admin first (on port 9006 by default) to set up the container, then you can use the service on port 9000. You can also join the exaba support slack if you need more help. An rclone config walkthrough might look like this but details may vary depending exactly on how you have set up the container. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> exaba Option Storage. Type of storage to configure. Storage> s3 Option provider. Choose your S3 provider. provider> Exaba Option env_auth. env_auth> 1 Option access_key_id. access_key_id> XXX Option secret_access_key. secret_access_key> YYY Option region. region> Option endpoint. endpoint> http://127.0.0.1:9000/ Option location_constraint. location_constraint> Option acl. acl> Edit advanced config? y) Yes n) No (default) y/n> n And the config generated will end up looking like this: [exaba] type = s3 provider = Exaba access_key_id = XXX secret_access_key = XXX endpoint = http://127.0.0.1:9000/ Google Cloud Storage GoogleCloudStorage is an S3-interoperable object storage service from Google Cloud Platform. To connect to Google Cloud Storage you will need an access key and secret key. These can be retrieved by creating an HMAC key. [gs] type = s3 provider = GCS access_key_id = your_access_key secret_access_key = your_secret_key endpoint = https://storage.googleapis.com Note that --s3-versions does not work with GCS when it needs to do directory paging. Rclone will return the error: s3 protocol error: received versions listing with IsTruncated set with no NextKeyMarker This is Google bug #312292516. Huawei OBS Object Storage Service (OBS) provides stable, secure, efficient, and easy-to-use cloud storage that lets you store virtually any volume of unstructured data in any format and access it from anywhere. OBS provides an S3 interface, you can copy and modify the following configuration and add it to your rclone configuration file. [obs] type = s3 provider = HuaweiOBS access_key_id = your-access-key-id secret_access_key = your-secret-access-key region = af-south-1 endpoint = obs.af-south-1.myhuaweicloud.com acl = private Or you can also configure via the interactive command line: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> obs Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] 9 / Huawei Object Storage Service \ (HuaweiOBS) [snip] provider> 9 Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> your-access-key-id Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> your-secret-access-key Option region. Region to connect to. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / AF-Johannesburg \ (af-south-1) 2 / AP-Bangkok \ (ap-southeast-2) [snip] region> 1 Option endpoint. Endpoint for OBS API. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / AF-Johannesburg \ (obs.af-south-1.myhuaweicloud.com) 2 / AP-Bangkok \ (obs.ap-southeast-2.myhuaweicloud.com) [snip] endpoint> 1 Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) [snip] acl> 1 Edit advanced config? y) Yes n) No (default) y/n> -------------------- [obs] type = s3 provider = HuaweiOBS access_key_id = your-access-key-id secret_access_key = your-secret-access-key region = af-south-1 endpoint = obs.af-south-1.myhuaweicloud.com acl = private -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== obs s3 e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q IBM COS (S3) Information stored with IBM Cloud Object Storage is encrypted and dispersed across multiple geographic locations, and accessed through an implementation of the S3 API. This service makes use of the distributed storage technologies provided by IBM’s Cloud Object Storage System (formerly Cleversafe). For more information visit: (http://www.ibm.com/cloud/object-storage) To configure access to IBM COS S3, follow the steps below: 1. Run rclone config and select n for a new remote. 2018/02/14 14:13:11 NOTICE: Config file "C:\\Users\\a\\.config\\rclone\\rclone.conf" not found - using defaults No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n 2. Enter the name for the configuration name> 3. Select "s3" storage. Choose a number from below, or type in your own value [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ "s3" [snip] Storage> s3 4. Select IBM COS as the S3 Storage Provider. Choose the S3 provider. Choose a number from below, or type in your own value 1 / Choose this option to configure Storage to AWS S3 \ "AWS" 2 / Choose this option to configure Storage to Ceph Systems \ "Ceph" 3 / Choose this option to configure Storage to Dreamhost \ "Dreamhost" 4 / Choose this option to the configure Storage to IBM COS S3 \ "IBMCOS" 5 / Choose this option to the configure Storage to Minio \ "Minio" Provider>4 5. Enter the Access Key and Secret. AWS Access Key ID - leave blank for anonymous access or runtime credentials. access_key_id> <> AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials. secret_access_key> <> 6. Specify the endpoint for IBM COS. For Public IBM COS, choose from the option below. For On Premise IBM COS, enter an endpoint address. Endpoint for IBM COS S3 API. Specify if using an IBM COS On Premise. Choose a number from below, or type in your own value 1 / US Cross Region Endpoint \ "s3-api.us-geo.objectstorage.softlayer.net" 2 / US Cross Region Dallas Endpoint \ "s3-api.dal.us-geo.objectstorage.softlayer.net" 3 / US Cross Region Washington DC Endpoint \ "s3-api.wdc-us-geo.objectstorage.softlayer.net" 4 / US Cross Region San Jose Endpoint \ "s3-api.sjc-us-geo.objectstorage.softlayer.net" 5 / US Cross Region Private Endpoint \ "s3-api.us-geo.objectstorage.service.networklayer.com" 6 / US Cross Region Dallas Private Endpoint \ "s3-api.dal-us-geo.objectstorage.service.networklayer.com" 7 / US Cross Region Washington DC Private Endpoint \ "s3-api.wdc-us-geo.objectstorage.service.networklayer.com" 8 / US Cross Region San Jose Private Endpoint \ "s3-api.sjc-us-geo.objectstorage.service.networklayer.com" 9 / US Region East Endpoint \ "s3.us-east.objectstorage.softlayer.net" 10 / US Region East Private Endpoint \ "s3.us-east.objectstorage.service.networklayer.com" 11 / US Region South Endpoint [snip] 34 / Toronto Single Site Private Endpoint \ "s3.tor01.objectstorage.service.networklayer.com" endpoint>1 7. Specify a IBM COS Location Constraint. The location constraint must match endpoint when using IBM Cloud Public. For on-prem COS, do not make a selection from this list, hit enter 1 / US Cross Region Standard \ "us-standard" 2 / US Cross Region Vault \ "us-vault" 3 / US Cross Region Cold \ "us-cold" 4 / US Cross Region Flex \ "us-flex" 5 / US East Region Standard \ "us-east-standard" 6 / US East Region Vault \ "us-east-vault" 7 / US East Region Cold \ "us-east-cold" 8 / US East Region Flex \ "us-east-flex" 9 / US South Region Standard \ "us-south-standard" 10 / US South Region Vault \ "us-south-vault" [snip] 32 / Toronto Flex \ "tor01-flex" location_constraint>1 8. Specify a canned ACL. IBM Cloud (Storage) supports "public-read" and "private". IBM Cloud(Infra) supports all the canned ACLs. On-Premise COS supports all the canned ACLs. Canned ACL used when creating buckets and/or storing objects in S3. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Choose a number from below, or type in your own value 1 / Owner gets FULL_CONTROL. No one else has access rights (default). This acl is available on IBM Cloud (Infra), IBM Cloud (Storage), On-Premise COS \ "private" 2 / Owner gets FULL_CONTROL. The AllUsers group gets READ access. This acl is available on IBM Cloud (Infra), IBM Cloud (Storage), On-Premise IBM COS \ "public-read" 3 / Owner gets FULL_CONTROL. The AllUsers group gets READ and WRITE access. This acl is available on IBM Cloud (Infra), On-Premise IBM COS \ "public-read-write" 4 / Owner gets FULL_CONTROL. The AuthenticatedUsers group gets READ access. Not supported on Buckets. This acl is available on IBM Cloud (Infra) and On-Premise IBM COS \ "authenticated-read" acl> 1 9. Review the displayed configuration and accept to save the "remote" then quit. The config file should look like this [xxx] type = s3 Provider = IBMCOS access_key_id = xxx secret_access_key = yyy endpoint = s3-api.us-geo.objectstorage.softlayer.net location_constraint = us-standard acl = private 10. Execute rclone commands 1) Create a bucket. rclone mkdir IBM-COS-XREGION:newbucket 2) List available buckets. rclone lsd IBM-COS-XREGION: -1 2017-11-08 21:16:22 -1 test -1 2018-02-14 20:16:39 -1 newbucket 3) List contents of a bucket. rclone ls IBM-COS-XREGION:newbucket 18685952 test.exe 4) Copy a file from local to remote. rclone copy /Users/file.txt IBM-COS-XREGION:newbucket 5) Copy a file from remote to local. rclone copy IBM-COS-XREGION:newbucket/file.txt . 6) Delete a file on remote. rclone delete IBM-COS-XREGION:newbucket/file.txt IBM IAM authentication If using IBM IAM authentication with IBM API KEY you need to fill in these additional parameters 1. Select false for env_auth 2. Leave access_key_id and secret_access_key blank 3. Paste your ibm_api_key Option ibm_api_key. IBM API Key to be used to obtain IAM token Enter a value of type string. Press Enter for the default (1). ibm_api_key> 4. Paste your ibm_resource_instance_id Option ibm_resource_instance_id. IBM service instance id Enter a value of type string. Press Enter for the default (2). ibm_resource_instance_id> 5. In advanced settings type true for v2_auth Option v2_auth. If true use v2 authentication. If this is false (the default) then rclone will use v4 authentication. If it is set then rclone will use v2 authentication. Use this only if v4 signatures don't work, e.g. pre Jewel/v10 CEPH. Enter a boolean value (true or false). Press Enter for the default (true). v2_auth> IDrive e2 Here is an example of making an IDrive e2 configuration. First run: rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> e2 Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / IDrive e2 \ (IDrive) [snip] provider> IDrive Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> YOUR_ACCESS_KEY Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> YOUR_SECRET_KEY Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) / Owner gets FULL_CONTROL. 3 | The AllUsers group gets READ and WRITE access. | Granting this on a bucket is generally not recommended. \ (public-read-write) / Owner gets FULL_CONTROL. 4 | The AuthenticatedUsers group gets READ access. \ (authenticated-read) / Object owner gets FULL_CONTROL. 5 | Bucket owner gets READ access. | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-read) / Both the object owner and the bucket owner get FULL_CONTROL over the object. 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-full-control) acl> Edit advanced config? y) Yes n) No (default) y/n> Configuration complete. Options: - type: s3 - provider: IDrive - access_key_id: YOUR_ACCESS_KEY - secret_access_key: YOUR_SECRET_KEY - endpoint: q9d9.la12.idrivee2-5.com Keep this "e2" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y IONOS Cloud IONOS S3 Object Storage is a service offered by IONOS for storing and accessing unstructured data. To connect to the service, you will need an access key and a secret key. These can be found in the Data Center Designer, by selecting Manager resources > Object Storage Key Manager. Here is an example of a configuration. First, run rclone config. This will walk you through an interactive setup process. Type n to add the new remote, and then enter a name: Enter name for new remote. name> ionos-fra Type s3 to choose the connection type: Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) [snip] Storage> s3 Type IONOS: Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / IONOS Cloud \ (IONOS) [snip] provider> IONOS Press Enter to choose the default option Enter AWS credentials in the next step: Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> Enter your Access Key and Secret key. These can be retrieved in the Data Center Designer, click on the menu “Manager resources” / "Object Storage Key Manager". Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> YOUR_ACCESS_KEY Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> YOUR_SECRET_KEY Choose the region where your bucket is located: Option region. Region where your bucket will be created and your data stored. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Frankfurt, Germany \ (de) 2 / Berlin, Germany \ (eu-central-2) 3 / Logrono, Spain \ (eu-south-2) region> 2 Choose the endpoint from the same region: Option endpoint. Endpoint for IONOS S3 Object Storage. Specify the endpoint from the same region. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Frankfurt, Germany \ (s3-eu-central-1.ionoscloud.com) 2 / Berlin, Germany \ (s3-eu-central-2.ionoscloud.com) 3 / Logrono, Spain \ (s3-eu-south-2.ionoscloud.com) endpoint> 1 Press Enter to choose the default option or choose the desired ACL setting: Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. [snip] acl> Press Enter to skip the advanced config: Edit advanced config? y) Yes n) No (default) y/n> Press Enter to save the configuration, and then q to quit the configuration process: Configuration complete. Options: - type: s3 - provider: IONOS - access_key_id: YOUR_ACCESS_KEY - secret_access_key: YOUR_SECRET_KEY - endpoint: s3-eu-central-1.ionoscloud.com Keep this "ionos-fra" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Done! Now you can try some commands (for macOS, use ./rclone instead of rclone). 1) Create a bucket (the name must be unique within the whole IONOS S3) rclone mkdir ionos-fra:my-bucket 2) List available buckets rclone lsd ionos-fra: 4) Copy a file from local to remote rclone copy /Users/file.txt ionos-fra:my-bucket 3) List contents of a bucket rclone ls ionos-fra:my-bucket 5) Copy a file from remote to local rclone copy ionos-fra:my-bucket/file.txt Leviia Cloud Object Storage Leviia Object Storage, backup and secure your data in a 100% French cloud, independent of GAFAM.. To configure access to Leviia, follow the steps below: 1. Run rclone config and select n for a new remote. rclone config No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n 2. Give the name of the configuration. For example, name it 'leviia'. name> leviia 3. Select s3 storage. Choose a number from below, or type in your own value [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) [snip] Storage> s3 4. Select Leviia provider. Choose a number from below, or type in your own value 1 / Amazon Web Services (AWS) S3 \ "AWS" [snip] 15 / Leviia Object Storage \ (Leviia) [snip] provider> Leviia 5. Enter your SecretId and SecretKey of Leviia. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Enter a boolean value (true or false). Press Enter for the default ("false"). Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). access_key_id> ZnIx.xxxxxxxxxxxxxxx AWS Secret Access Key (password) Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). secret_access_key> xxxxxxxxxxx 6. Select endpoint for Leviia. / The default endpoint 1 | Leviia. \ (s3.leviia.com) [snip] endpoint> 1 7. Choose acl. Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) [snip] acl> 1 Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config -------------------- [leviia] - type: s3 - provider: Leviia - access_key_id: ZnIx.xxxxxxx - secret_access_key: xxxxxxxx - endpoint: s3.leviia.com - acl: private -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== leviia s3 Liara Here is an example of making a Liara Object Storage configuration. First run: rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password n/s> n name> Liara Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Amazon S3 (also Dreamhost, Ceph, ChinaMobile, ArvanCloud, Liara, Minio) \ "s3" [snip] Storage> s3 Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID - leave blank for anonymous access or runtime credentials. access_key_id> YOURACCESSKEY AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials. secret_access_key> YOURSECRETACCESSKEY Region to connect to. Choose a number from below, or type in your own value / The default endpoint 1 | US Region, Northern Virginia, or Pacific Northwest. | Leave location constraint empty. \ "us-east-1" [snip] region> Endpoint for S3 API. Leave blank if using Liara to use the default endpoint for the region. Specify if using an S3 clone such as Ceph. endpoint> storage.iran.liara.space Canned ACL used when creating buckets and/or storing objects in S3. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Choose a number from below, or type in your own value 1 / Owner gets FULL_CONTROL. No one else has access rights (default). \ "private" [snip] acl> The server-side encryption algorithm used when storing this object in S3. Choose a number from below, or type in your own value 1 / None \ "" 2 / AES256 \ "AES256" server_side_encryption> The storage class to use when storing objects in S3. Choose a number from below, or type in your own value 1 / Default \ "" 2 / Standard storage class \ "STANDARD" storage_class> Remote config -------------------- [Liara] env_auth = false access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY endpoint = storage.iran.liara.space location_constraint = acl = server_side_encryption = storage_class = -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y This will leave the config file looking like this. [Liara] type = s3 provider = Liara env_auth = false access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY region = endpoint = storage.iran.liara.space location_constraint = acl = server_side_encryption = storage_class = Linode Here is an example of making a Linode Object Storage configuration. First run: rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> linode Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ...Linode, ...and others \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / Linode Object Storage \ (Linode) [snip] provider> Linode Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> ACCESS_KEY Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> SECRET_ACCESS_KEY Option endpoint. Endpoint for Linode Object Storage API. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Amsterdam (Netherlands), nl-ams-1 \ (nl-ams-1.linodeobjects.com) 2 / Atlanta, GA (USA), us-southeast-1 \ (us-southeast-1.linodeobjects.com) 3 / Chennai (India), in-maa-1 \ (in-maa-1.linodeobjects.com) 4 / Chicago, IL (USA), us-ord-1 \ (us-ord-1.linodeobjects.com) 5 / Frankfurt (Germany), eu-central-1 \ (eu-central-1.linodeobjects.com) 6 / Jakarta (Indonesia), id-cgk-1 \ (id-cgk-1.linodeobjects.com) 7 / London 2 (Great Britain), gb-lon-1 \ (gb-lon-1.linodeobjects.com) 8 / Los Angeles, CA (USA), us-lax-1 \ (us-lax-1.linodeobjects.com) 9 / Madrid (Spain), es-mad-1 \ (es-mad-1.linodeobjects.com) 10 / Melbourne (Australia), au-mel-1 \ (au-mel-1.linodeobjects.com) 11 / Miami, FL (USA), us-mia-1 \ (us-mia-1.linodeobjects.com) 12 / Milan (Italy), it-mil-1 \ (it-mil-1.linodeobjects.com) 13 / Newark, NJ (USA), us-east-1 \ (us-east-1.linodeobjects.com) 14 / Osaka (Japan), jp-osa-1 \ (jp-osa-1.linodeobjects.com) 15 / Paris (France), fr-par-1 \ (fr-par-1.linodeobjects.com) 16 / São Paulo (Brazil), br-gru-1 \ (br-gru-1.linodeobjects.com) 17 / Seattle, WA (USA), us-sea-1 \ (us-sea-1.linodeobjects.com) 18 / Singapore, ap-south-1 \ (ap-south-1.linodeobjects.com) 19 / Singapore 2, sg-sin-1 \ (sg-sin-1.linodeobjects.com) 20 / Stockholm (Sweden), se-sto-1 \ (se-sto-1.linodeobjects.com) 21 / Washington, DC, (USA), us-iad-1 \ (us-iad-1.linodeobjects.com) endpoint> 5 Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) [snip] acl> Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: s3 - provider: Linode - access_key_id: ACCESS_KEY - secret_access_key: SECRET_ACCESS_KEY - endpoint: eu-central-1.linodeobjects.com Keep this "linode" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y This will leave the config file looking like this. [linode] type = s3 provider = Linode access_key_id = ACCESS_KEY secret_access_key = SECRET_ACCESS_KEY endpoint = eu-central-1.linodeobjects.com Magalu Here is an example of making a Magalu Object Storage configuration. First run: rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> magalu Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ...Magalu, ...and others \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / Magalu Object Storage \ (Magalu) [snip] provider> Magalu Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> ACCESS_KEY Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> SECRET_ACCESS_KEY Option endpoint. Endpoint for Magalu Object Storage API. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / São Paulo, SP (BR), br-se1 \ (br-se1.magaluobjects.com) 2 / Fortaleza, CE (BR), br-ne1 \ (br-ne1.magaluobjects.com) endpoint> 2 Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) [snip] acl> Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: s3 - provider: magalu - access_key_id: ACCESS_KEY - secret_access_key: SECRET_ACCESS_KEY - endpoint: br-ne1.magaluobjects.com Keep this "magalu" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y This will leave the config file looking like this. [magalu] type = s3 provider = Magalu access_key_id = ACCESS_KEY secret_access_key = SECRET_ACCESS_KEY endpoint = br-ne1.magaluobjects.com MEGA S4 MEGA S4 Object Storage is an S3 compatible object storage system. It has a single pricing tier with no additional charges for data transfers or API requests and it is included in existing Pro plans. Here is an example of making a configuration. First run: rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> megas4 Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS,... Mega, ... \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / MEGA S4 Object Storage \ (Mega) [snip] provider> Mega Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> XXX Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> XXX Option endpoint. Endpoint for S3 API. Required when using an S3 clone. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Mega S4 eu-central-1 (Amsterdam) \ (s3.eu-central-1.s4.mega.io) 2 / Mega S4 eu-central-2 (Bettembourg) \ (s3.eu-central-2.s4.mega.io) 3 / Mega S4 ca-central-1 (Montreal) \ (s3.ca-central-1.s4.mega.io) 4 / Mega S4 ca-west-1 (Vancouver) \ (s3.ca-west-1.s4.mega.io) endpoint> 1 Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: s3 - provider: Mega - access_key_id: XXX - secret_access_key: XXX - endpoint: s3.eu-central-1.s4.mega.io Keep this "megas4" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y This will leave the config file looking like this. [megas4] type = s3 provider = Mega access_key_id = XXX secret_access_key = XXX endpoint = s3.eu-central-1.s4.mega.io Minio Minio is an object storage server built for cloud application developers and devops. It is very easy to install and provides an S3 compatible server which can be used by rclone. To use it, install Minio following the instructions here. When it configures itself Minio will print something like this Endpoint: http://192.168.1.106:9000 http://172.23.0.1:9000 AccessKey: USWUXHGYZQYFYFFIT3RE SecretKey: MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03 Region: us-east-1 SQS ARNs: arn:minio:sqs:us-east-1:1:redis arn:minio:sqs:us-east-1:2:redis Browser Access: http://192.168.1.106:9000 http://172.23.0.1:9000 Command-line Access: https://docs.minio.io/docs/minio-client-quickstart-guide $ mc config host add myminio http://192.168.1.106:9000 USWUXHGYZQYFYFFIT3RE MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03 Object API (Amazon S3 compatible): Go: https://docs.minio.io/docs/golang-client-quickstart-guide Java: https://docs.minio.io/docs/java-client-quickstart-guide Python: https://docs.minio.io/docs/python-client-quickstart-guide JavaScript: https://docs.minio.io/docs/javascript-client-quickstart-guide .NET: https://docs.minio.io/docs/dotnet-client-quickstart-guide Drive Capacity: 26 GiB Free, 165 GiB Total These details need to go into rclone config like this. Note that it is important to put the region in as stated above. env_auth> 1 access_key_id> USWUXHGYZQYFYFFIT3RE secret_access_key> MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03 region> us-east-1 endpoint> http://192.168.1.106:9000 location_constraint> server_side_encryption> Which makes the config file look like this [minio] type = s3 provider = Minio env_auth = false access_key_id = USWUXHGYZQYFYFFIT3RE secret_access_key = MOJRH0mkL1IPauahWITSVvyDrQbEEIwljvmxdq03 region = us-east-1 endpoint = http://192.168.1.106:9000 location_constraint = server_side_encryption = So once set up, for example, to copy files into a bucket rclone copy /path/to/files minio:bucket Netease NOS For Netease NOS configure as per the configurator rclone config setting the provider Netease. This will automatically set force_path_style = false which is necessary for it to run properly. Outscale OUTSCALE Object Storage (OOS) is an enterprise-grade, S3-compatible storage service provided by OUTSCALE, a brand of Dassault Systèmes. For more information about OOS, see the official documentation. Here is an example of an OOS configuration that you can paste into your rclone configuration file: [outscale] type = s3 provider = Outscale env_auth = false access_key_id = ABCDEFGHIJ0123456789 secret_access_key = XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX region = eu-west-2 endpoint = oos.eu-west-2.outscale.com acl = private You can also run rclone config to go through the interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> outscale Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] X / Amazon S3 Compliant Storage Providers including AWS, ...Outscale, ...and others \ (s3) [snip] Storage> outscale Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / OUTSCALE Object Storage (OOS) \ (Outscale) [snip] provider> Outscale Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> ABCDEFGHIJ0123456789 Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX Option region. Region where your bucket will be created and your data stored. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Paris, France \ (eu-west-2) 2 / New Jersey, USA \ (us-east-2) 3 / California, USA \ (us-west-1) 4 / SecNumCloud, Paris, France \ (cloudgouv-eu-west-1) 5 / Tokyo, Japan \ (ap-northeast-1) region> 1 Option endpoint. Endpoint for S3 API. Required when using an S3 clone. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Outscale EU West 2 (Paris) \ (oos.eu-west-2.outscale.com) 2 / Outscale US east 2 (New Jersey) \ (oos.us-east-2.outscale.com) 3 / Outscale EU West 1 (California) \ (oos.us-west-1.outscale.com) 4 / Outscale SecNumCloud (Paris) \ (oos.cloudgouv-eu-west-1.outscale.com) 5 / Outscale AP Northeast 1 (Japan) \ (oos.ap-northeast-1.outscale.com) endpoint> 1 Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) [snip] acl> 1 Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: s3 - provider: Outscale - access_key_id: ABCDEFGHIJ0123456789 - secret_access_key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX - endpoint: oos.eu-west-2.outscale.com Keep this "outscale" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y OVHcloud OVHcloud Object Storage is an S3-compatible general-purpose object storage platform available in all OVHcloud regions. To use the platform, you will need an access key and secret key. To know more about it and how to interact with the platform, take a look at the documentation. Here is an example of making an OVHcloud Object Storage configuration with rclone config: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> ovhcloud-rbx Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [...] XX / Amazon S3 Compliant Storage Providers including AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, Magalu, Minio, Netease, Outscale, OVHcloud, Petabox, RackCorp, Rclone, Scaleway, SeaweedFS, Selectel, StackPath, Storj, Synology, TencentCOS, Wasabi, Qiniu and others \ (s3) [...] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [...] XX / OVHcloud Object Storage \ (OVHcloud) [...] provider> OVHcloud Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> my_access Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> my_secret Option region. Region where your bucket will be created and your data stored. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Gravelines, France \ (gra) 2 / Roubaix, France \ (rbx) 3 / Strasbourg, France \ (sbg) 4 / Paris, France (3AZ) \ (eu-west-par) 5 / Frankfurt, Germany \ (de) 6 / London, United Kingdom \ (uk) 7 / Warsaw, Poland \ (waw) 8 / Beauharnois, Canada \ (bhs) 9 / Toronto, Canada \ (ca-east-tor) 10 / Singapore \ (sgp) 11 / Sydney, Australia \ (ap-southeast-syd) 12 / Mumbai, India \ (ap-south-mum) 13 / Vint Hill, Virginia, USA \ (us-east-va) 14 / Hillsboro, Oregon, USA \ (us-west-or) 15 / Roubaix, France (Cold Archive) \ (rbx-archive) region> 2 Option endpoint. Endpoint for OVHcloud Object Storage. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / OVHcloud Gravelines, France \ (s3.gra.io.cloud.ovh.net) 2 / OVHcloud Roubaix, France \ (s3.rbx.io.cloud.ovh.net) 3 / OVHcloud Strasbourg, France \ (s3.sbg.io.cloud.ovh.net) 4 / OVHcloud Paris, France (3AZ) \ (s3.eu-west-par.io.cloud.ovh.net) 5 / OVHcloud Frankfurt, Germany \ (s3.de.io.cloud.ovh.net) 6 / OVHcloud London, United Kingdom \ (s3.uk.io.cloud.ovh.net) 7 / OVHcloud Warsaw, Poland \ (s3.waw.io.cloud.ovh.net) 8 / OVHcloud Beauharnois, Canada \ (s3.bhs.io.cloud.ovh.net) 9 / OVHcloud Toronto, Canada \ (s3.ca-east-tor.io.cloud.ovh.net) 10 / OVHcloud Singapore \ (s3.sgp.io.cloud.ovh.net) 11 / OVHcloud Sydney, Australia \ (s3.ap-southeast-syd.io.cloud.ovh.net) 12 / OVHcloud Mumbai, India \ (s3.ap-south-mum.io.cloud.ovh.net) 13 / OVHcloud Vint Hill, Virginia, USA \ (s3.us-east-va.io.cloud.ovh.us) 14 / OVHcloud Hillsboro, Oregon, USA \ (s3.us-west-or.io.cloud.ovh.us) 15 / OVHcloud Roubaix, France (Cold Archive) \ (s3.rbx-archive.io.cloud.ovh.net) endpoint> 2 Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) / Owner gets FULL_CONTROL. 3 | The AllUsers group gets READ and WRITE access. | Granting this on a bucket is generally not recommended. \ (public-read-write) / Owner gets FULL_CONTROL. 4 | The AuthenticatedUsers group gets READ access. \ (authenticated-read) / Object owner gets FULL_CONTROL. 5 | Bucket owner gets READ access. | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-read) / Both the object owner and the bucket owner get FULL_CONTROL over the object. 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-full-control) acl> 1 Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: s3 - provider: OVHcloud - access_key_id: my_access - secret_access_key: my_secret - region: rbx - endpoint: s3.rbx.io.cloud.ovh.net - acl: private Keep this "ovhcloud-rbx" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Your configuration file should now look like this: [ovhcloud-rbx] type = s3 provider = OVHcloud access_key_id = my_access secret_access_key = my_secret region = rbx endpoint = s3.rbx.io.cloud.ovh.net acl = private Petabox Here is an example of making a Petabox configuration. First run: rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password n/s> n Enter name for new remote. name> My Petabox Storage Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ "s3" [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / Petabox Object Storage \ (Petabox) [snip] provider> Petabox Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> YOUR_ACCESS_KEY_ID Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> YOUR_SECRET_ACCESS_KEY Option region. Region where your bucket will be created and your data stored. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / US East (N. Virginia) \ (us-east-1) 2 / Europe (Frankfurt) \ (eu-central-1) 3 / Asia Pacific (Singapore) \ (ap-southeast-1) 4 / Middle East (Bahrain) \ (me-south-1) 5 / South America (São Paulo) \ (sa-east-1) region> 1 Option endpoint. Endpoint for Petabox S3 Object Storage. Specify the endpoint from the same region. Choose a number from below, or type in your own value. 1 / US East (N. Virginia) \ (s3.petabox.io) 2 / US East (N. Virginia) \ (s3.us-east-1.petabox.io) 3 / Europe (Frankfurt) \ (s3.eu-central-1.petabox.io) 4 / Asia Pacific (Singapore) \ (s3.ap-southeast-1.petabox.io) 5 / Middle East (Bahrain) \ (s3.me-south-1.petabox.io) 6 / South America (São Paulo) \ (s3.sa-east-1.petabox.io) endpoint> 1 Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) / Owner gets FULL_CONTROL. 3 | The AllUsers group gets READ and WRITE access. | Granting this on a bucket is generally not recommended. \ (public-read-write) / Owner gets FULL_CONTROL. 4 | The AuthenticatedUsers group gets READ access. \ (authenticated-read) / Object owner gets FULL_CONTROL. 5 | Bucket owner gets READ access. | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-read) / Both the object owner and the bucket owner get FULL_CONTROL over the object. 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-full-control) acl> 1 Edit advanced config? y) Yes n) No (default) y/n> No Configuration complete. Options: - type: s3 - provider: Petabox - access_key_id: YOUR_ACCESS_KEY_ID - secret_access_key: YOUR_SECRET_ACCESS_KEY - region: us-east-1 - endpoint: s3.petabox.io Keep this "My Petabox Storage" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y This will leave the config file looking like this. [My Petabox Storage] type = s3 provider = Petabox access_key_id = YOUR_ACCESS_KEY_ID secret_access_key = YOUR_SECRET_ACCESS_KEY region = us-east-1 endpoint = s3.petabox.io Pure Storage FlashBlade Pure Storage FlashBlade is a high performance S3-compatible object store. FlashBlade supports most modern S3 features including: - ListObjectsV2 - Multipart uploads with AWS-compatible ETags - Advanced checksum algorithms (SHA256, CRC32, CRC32C) with trailer support (Purity//FB 4.4.2+) - Object versioning and lifecycle management - Virtual hosted-style requests (requires DNS configuration) To configure rclone for Pure Storage FlashBlade: First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> flashblade Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] 4 / Amazon S3 Compliant Storage Providers including AWS, Alibaba, ArvanCloud, Ceph, ChinaMobile, Cloudflare, DigitalOcean, Dreamhost, FlashBlade, GCS, HuaweiOBS, IBMCOS, IDrive, IONOS, LyveCloud, Leviia, Liara, Linode, Magalu, Minio, Netease, Outscale, Petabox, RackCorp, Rclone, Scaleway, SeaweedFS, Selectel, StackPath, Storj, Synology, TencentCOS, Wasabi, Qiniu and others \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] 9 / Pure Storage FlashBlade Object Storage \ (FlashBlade) [snip] provider> FlashBlade Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> ACCESS_KEY_ID Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> SECRET_ACCESS_KEY Option endpoint. Endpoint for S3 API. Required when using an S3 clone. Enter a value. Press Enter to leave empty. endpoint> https://s3.flashblade.example.com Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: s3 - provider: FlashBlade - access_key_id: ACCESS_KEY_ID - secret_access_key: SECRET_ACCESS_KEY - endpoint: https://s3.flashblade.example.com Keep this "flashblade" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y This results in the following configuration being stored in ~/.config/rclone/rclone.conf: [flashblade] type = s3 provider = FlashBlade access_key_id = ACCESS_KEY_ID secret_access_key = SECRET_ACCESS_KEY endpoint = https://s3.flashblade.example.com Note: The FlashBlade endpoint should be the S3 data VIP. For virtual-hosted style requests, ensure proper DNS configuration: subdomains of the endpoint hostname should resolve to a FlashBlade data VIP. For example, if your endpoint is https://s3.flashblade.example.com, then bucket-name.s3.flashblade.example.com should also resolve to the data VIP. Qiniu Cloud Object Storage (Kodo) Qiniu Cloud Object Storage (Kodo), a completely independent-researched core technology which is proven by repeated customer experience has occupied absolute leading market leader position. Kodo can be widely applied to mass data management. To configure access to Qiniu Kodo, follow the steps below: 1. Run rclone config and select n for a new remote. rclone config No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n 2. Give the name of the configuration. For example, name it 'qiniu'. name> qiniu 3. Select s3 storage. Choose a number from below, or type in your own value [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) [snip] Storage> s3 4. Select Qiniu provider. Choose a number from below, or type in your own value 1 / Amazon Web Services (AWS) S3 \ "AWS" [snip] 22 / Qiniu Object Storage (Kodo) \ (Qiniu) [snip] provider> Qiniu 5. Enter your SecretId and SecretKey of Qiniu Kodo. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Enter a boolean value (true or false). Press Enter for the default ("false"). Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). access_key_id> AKIDxxxxxxxxxx AWS Secret Access Key (password) Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). secret_access_key> xxxxxxxxxxx 6. Select endpoint for Qiniu Kodo. This is the standard endpoint for different region. / The default endpoint - a good choice if you are unsure. 1 | East China Region 1. | Needs location constraint cn-east-1. \ (cn-east-1) / East China Region 2. 2 | Needs location constraint cn-east-2. \ (cn-east-2) / North China Region 1. 3 | Needs location constraint cn-north-1. \ (cn-north-1) / South China Region 1. 4 | Needs location constraint cn-south-1. \ (cn-south-1) / North America Region. 5 | Needs location constraint us-north-1. \ (us-north-1) / Southeast Asia Region 1. 6 | Needs location constraint ap-southeast-1. \ (ap-southeast-1) / Northeast Asia Region 1. 7 | Needs location constraint ap-northeast-1. \ (ap-northeast-1) [snip] endpoint> 1 Option endpoint. Endpoint for Qiniu Object Storage. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / East China Endpoint 1 \ (s3-cn-east-1.qiniucs.com) 2 / East China Endpoint 2 \ (s3-cn-east-2.qiniucs.com) 3 / North China Endpoint 1 \ (s3-cn-north-1.qiniucs.com) 4 / South China Endpoint 1 \ (s3-cn-south-1.qiniucs.com) 5 / North America Endpoint 1 \ (s3-us-north-1.qiniucs.com) 6 / Southeast Asia Endpoint 1 \ (s3-ap-southeast-1.qiniucs.com) 7 / Northeast Asia Endpoint 1 \ (s3-ap-northeast-1.qiniucs.com) endpoint> 1 Option location_constraint. Location constraint - must be set to match the Region. Used when creating buckets only. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / East China Region 1 \ (cn-east-1) 2 / East China Region 2 \ (cn-east-2) 3 / North China Region 1 \ (cn-north-1) 4 / South China Region 1 \ (cn-south-1) 5 / North America Region 1 \ (us-north-1) 6 / Southeast Asia Region 1 \ (ap-southeast-1) 7 / Northeast Asia Region 1 \ (ap-northeast-1) location_constraint> 1 7. Choose acl and storage class. Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) [snip] acl> 2 The storage class to use when storing new objects in Tencent COS. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Standard storage class \ (STANDARD) 2 / Infrequent access storage mode \ (LINE) 3 / Archive storage mode \ (GLACIER) 4 / Deep archive storage mode \ (DEEP_ARCHIVE) [snip] storage_class> 1 Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config -------------------- [qiniu] - type: s3 - provider: Qiniu - access_key_id: xxx - secret_access_key: xxx - region: cn-east-1 - endpoint: s3-cn-east-1.qiniucs.com - location_constraint: cn-east-1 - acl: public-read - storage_class: STANDARD -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== qiniu s3 RackCorp RackCorp Object Storage is an S3 compatible object storage platform from your friendly cloud provider RackCorp. The service is fast, reliable, well priced and located in many strategic locations unserviced by others, to ensure you can maintain data sovereignty. Before you can use RackCorp Object Storage, you'll need to "sign up" for an account on our "portal". Next you can create an access key, a secret key and buckets, in your location of choice with ease. These details are required for the next steps of configuration, when rclone config asks for your access_key_id and secret_access_key. Your config should end up looking a bit like this: [RCS3-demo-config] type = s3 provider = RackCorp env_auth = true access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY region = au-nsw endpoint = s3.rackcorp.com location_constraint = au-nsw Rclone Serve S3 Rclone can serve any remote over the S3 protocol. For details see the rclone serve s3 documentation. For example, to serve remote:path over s3, run the server like this: rclone serve s3 --auth-key ACCESS_KEY_ID,SECRET_ACCESS_KEY remote:path This will be compatible with an rclone remote which is defined like this: [serves3] type = s3 provider = Rclone endpoint = http://127.0.0.1:8080/ access_key_id = ACCESS_KEY_ID secret_access_key = SECRET_ACCESS_KEY use_multipart_uploads = false Note that setting use_multipart_uploads = false is to work around a bug which will be fixed in due course. Scaleway Scaleway The Object Storage platform allows you to store anything from backups, logs and web assets to documents and photos. Files can be dropped from the Scaleway console or transferred through our API and CLI or using any S3-compatible tool. Scaleway provides an S3 interface which can be configured for use with rclone like this: [scaleway] type = s3 provider = Scaleway env_auth = false endpoint = s3.nl-ams.scw.cloud access_key_id = SCWXXXXXXXXXXXXXX secret_access_key = 1111111-2222-3333-44444-55555555555555 region = nl-ams location_constraint = nl-ams acl = private upload_cutoff = 5M chunk_size = 5M copy_cutoff = 5M Scaleway Glacier is the low-cost S3 Glacier alternative from Scaleway and it works the same way as on S3 by accepting the "GLACIER" storage_class. So you can configure your remote with the storage_class = GLACIER option to upload directly to Scaleway Glacier. Don't forget that in this state you can't read files back after, you will need to restore them to "STANDARD" storage_class first before being able to read them (see "restore" section above) Seagate Lyve Cloud Seagate Lyve Cloud is an S3 compatible object storage platform from Seagate intended for enterprise use. Here is a config run through for a remote called remote - you may choose a different name of course. Note that to create an access key and secret key you will need to create a service account first. $ rclone config No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Choose s3 backend Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) [snip] Storage> s3 Choose LyveCloud as S3 provider Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / Seagate Lyve Cloud \ (LyveCloud) [snip] provider> LyveCloud Take the default (just press enter) to enter access key and secret in the config file. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> XXX AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> YYY Leave region blank Region to connect to. Leave blank if you are using an S3 clone and you don't have a region. Choose a number from below, or type in your own value. Press Enter to leave empty. / Use this if unsure. 1 | Will use v4 signatures and an empty region. \ () / Use this only if v4 signatures don't work. 2 | E.g. pre Jewel/v10 CEPH. \ (other-v2-signature) region> Enter your Lyve Cloud endpoint. This field cannot be kept empty. Endpoint for Lyve Cloud S3 API. Required when using an S3 clone. Please type in your LyveCloud endpoint. Examples: - s3.us-west-1.{account_name}.lyve.seagate.com (US West 1 - California) - s3.eu-west-1.{account_name}.lyve.seagate.com (US West 1 - Ireland) Enter a value. endpoint> s3.us-west-1.global.lyve.seagate.com Leave location constraint blank Location constraint - must be set to match the Region. Leave blank if not sure. Used when creating buckets only. Enter a value. Press Enter to leave empty. location_constraint> Choose default ACL (private). Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) [snip] acl> And the config file should end up looking like this: [remote] type = s3 provider = LyveCloud access_key_id = XXX secret_access_key = YYY endpoint = s3.us-east-1.lyvecloud.seagate.com SeaweedFS SeaweedFS is a distributed storage system for blobs, objects, files, and data lake, with O(1) disk seek and a scalable file metadata store. It has an S3 compatible object storage interface. SeaweedFS can also act as a gateway to remote S3 compatible object store to cache data and metadata with asynchronous write back, for fast local speed and minimize access cost. Assuming the SeaweedFS are configured with weed shell as such: > s3.bucket.create -name foo > s3.configure -access_key=any -secret_key=any -buckets=foo -user=me -actions=Read,Write,List,Tagging,Admin -apply { "identities": [ { "name": "me", "credentials": [ { "accessKey": "any", "secretKey": "any" } ], "actions": [ "Read:foo", "Write:foo", "List:foo", "Tagging:foo", "Admin:foo" ] } ] } To use rclone with SeaweedFS, above configuration should end up with something like this in your config: [seaweedfs_s3] type = s3 provider = SeaweedFS access_key_id = any secret_access_key = any endpoint = localhost:8333 So once set up, for example to copy files into a bucket rclone copy /path/to/files seaweedfs_s3:foo Selectel Selectel Cloud Storage is an S3 compatible storage system which features triple redundancy storage, automatic scaling, high availability and a comprehensive IAM system. Selectel have a section on their website for configuring rclone which shows how to make the right API keys. From rclone v1.69 Selectel is a supported operator - please choose the Selectel provider type. Note that you should use "vHosted" access for the buckets (which is the recommended default), not "path style". You can use rclone config to make a new provider like this No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> selectel Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Amazon S3 Compliant Storage Providers including ..., Selectel, ... \ (s3) [snip] Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. [snip] XX / Selectel Object Storage \ (Selectel) [snip] provider> Selectel Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> ACCESS_KEY Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> SECRET_ACCESS_KEY Option region. Region where your data stored. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / St. Petersburg \ (ru-1) region> 1 Option endpoint. Endpoint for Selectel Object Storage. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Saint Petersburg \ (s3.ru-1.storage.selcloud.ru) endpoint> 1 Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: s3 - provider: Selectel - access_key_id: ACCESS_KEY - secret_access_key: SECRET_ACCESS_KEY - region: ru-1 - endpoint: s3.ru-1.storage.selcloud.ru Keep this "selectel" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y And your config should end up looking like this: [selectel] type = s3 provider = Selectel access_key_id = ACCESS_KEY secret_access_key = SECRET_ACCESS_KEY region = ru-1 endpoint = s3.ru-1.storage.selcloud.ru Storj Storj is a decentralized cloud storage which can be used through its native protocol or an S3 compatible gateway. The S3 compatible gateway is configured using rclone config with a type of s3 and with a provider name of Storj. Here is an example run of the configurator. Type of storage to configure. Storage> s3 Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> 1 Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> XXXX (as shown when creating the access grant) Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> XXXX (as shown when creating the access grant) Option endpoint. Endpoint of the Shared Gateway. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / EU1 Shared Gateway \ (gateway.eu1.storjshare.io) 2 / US1 Shared Gateway \ (gateway.us1.storjshare.io) 3 / Asia-Pacific Shared Gateway \ (gateway.ap1.storjshare.io) endpoint> 1 (as shown when creating the access grant) Edit advanced config? y) Yes n) No (default) y/n> n Note that s3 credentials are generated when you create an access grant. Backend quirks - --chunk-size is forced to be 64 MiB or greater. This will use more memory than the default of 5 MiB. - Server side copy is disabled as it isn't currently supported in the gateway. - GetTier and SetTier are not supported. Backend bugs Due to issue #39 uploading multipart files via the S3 gateway causes them to lose their metadata. For rclone's purpose this means that the modification time is not stored, nor is any MD5SUM (if one is available from the source). This has the following consequences: - Using rclone rcat will fail as the metadata doesn't match after upload - Uploading files with rclone mount will fail for the same reason - This can worked around by using --vfs-cache-mode writes or --vfs-cache-mode full or setting --s3-upload-cutoff large - Files uploaded via a multipart upload won't have their modtimes - This will mean that rclone sync will likely keep trying to upload files bigger than --s3-upload-cutoff - This can be worked around with --checksum or --size-only or setting --s3-upload-cutoff large - The maximum value for --s3-upload-cutoff is 5GiB though One general purpose workaround is to set --s3-upload-cutoff 5G. This means that rclone will upload files smaller than 5GiB as single parts. Note that this can be set in the config file with upload_cutoff = 5G or configured in the advanced settings. If you regularly transfer files larger than 5G then using --checksum or --size-only in rclone sync is the recommended workaround. Comparison with the native protocol Use the the native protocol to take advantage of client-side encryption as well as to achieve the best possible download performance. Uploads will be erasure-coded locally, thus a 1gb upload will result in 2.68gb of data being uploaded to storage nodes across the network. Use this backend and the S3 compatible Hosted Gateway to increase upload performance and reduce the load on your systems and network. Uploads will be encrypted and erasure-coded server-side, thus a 1GB upload will result in only in 1GB of data being uploaded to storage nodes across the network. For more detailed comparison please check the documentation of the storj backend. Synology C2 Object Storage Synology C2 Object Storage provides a secure, S3-compatible, and cost-effective cloud storage solution without API request, download fees, and deletion penalty. The S3 compatible gateway is configured using rclone config with a type of s3 and with a provider name of Synology. Here is an example run of the configurator. First run: rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote.1 name> syno Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value XX / Amazon S3 Compliant Storage Providers including AWS, ... \ "s3" Storage> s3 Choose your S3 provider. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 24 / Synology C2 Object Storage \ (Synology) provider> Synology Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Enter a boolean value (true or false). Press Enter for the default ("false"). Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). access_key_id> accesskeyid AWS Secret Access Key (password) Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). secret_access_key> secretaccesskey Region where your data stored. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Europe Region 1 \ (eu-001) 2 / Europe Region 2 \ (eu-002) 3 / US Region 1 \ (us-001) 4 / US Region 2 \ (us-002) 5 / Asia (Taiwan) \ (tw-001) region > 1 Option endpoint. Endpoint for Synology C2 Object Storage API. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / EU Endpoint 1 \ (eu-001.s3.synologyc2.net) 2 / US Endpoint 1 \ (us-001.s3.synologyc2.net) 3 / TW Endpoint 1 \ (tw-001.s3.synologyc2.net) endpoint> 1 Option location_constraint. Location constraint - must be set to match the Region. Leave blank if not sure. Used when creating buckets only. Enter a value. Press Enter to leave empty. location_constraint> Edit advanced config? (y/n) y) Yes n) No y/n> y Option no_check_bucket. If set, don't attempt to check the bucket exists or create it. This can be useful when trying to minimise the number of transactions rclone does if you know the bucket exists already. It can also be needed if the user you are using does not have bucket creation permissions. Before v1.52.0 this would have passed silently due to a bug. Enter a boolean value (true or false). Press Enter for the default (true). no_check_bucket> true Configuration complete. Options: - type: s3 - provider: Synology - region: eu-001 - endpoint: eu-001.s3.synologyc2.net - no_check_bucket: true Keep this "syno" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Tencent COS Tencent Cloud Object Storage (COS) is a distributed storage service offered by Tencent Cloud for unstructured data. It is secure, stable, massive, convenient, low-delay and low-cost. To configure access to Tencent COS, follow the steps below: 1. Run rclone config and select n for a new remote. rclone config No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n 2. Give the name of the configuration. For example, name it 'cos'. name> cos 3. Select s3 storage. Choose a number from below, or type in your own value [snip] XX / Amazon S3 Compliant Storage Providers including AWS, ... \ "s3" [snip] Storage> s3 4. Select TencentCOS provider. Choose a number from below, or type in your own value 1 / Amazon Web Services (AWS) S3 \ "AWS" [snip] 11 / Tencent Cloud Object Storage (COS) \ "TencentCOS" [snip] provider> TencentCOS 5. Enter your SecretId and SecretKey of Tencent Cloud. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Enter a boolean value (true or false). Press Enter for the default ("false"). Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). access_key_id> AKIDxxxxxxxxxx AWS Secret Access Key (password) Leave blank for anonymous access or runtime credentials. Enter a string value. Press Enter for the default (""). secret_access_key> xxxxxxxxxxx 6. Select endpoint for Tencent COS. This is the standard endpoint for different region. 1 / Beijing Region. \ "cos.ap-beijing.myqcloud.com" 2 / Nanjing Region. \ "cos.ap-nanjing.myqcloud.com" 3 / Shanghai Region. \ "cos.ap-shanghai.myqcloud.com" 4 / Guangzhou Region. \ "cos.ap-guangzhou.myqcloud.com" [snip] endpoint> 4 7. Choose acl and storage class. Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Owner gets Full_CONTROL. No one else has access rights (default). \ "default" [snip] acl> 1 The storage class to use when storing new objects in Tencent COS. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Default \ "" [snip] storage_class> 1 Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config -------------------- [cos] type = s3 provider = TencentCOS env_auth = false access_key_id = xxx secret_access_key = xxx endpoint = cos.ap-guangzhou.myqcloud.com acl = default -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== cos s3 Wasabi Wasabi is a cloud-based object storage service for a broad range of applications and use cases. Wasabi is designed for individuals and organizations that require a high-performance, reliable, and secure data storage infrastructure at minimal cost. Wasabi provides an S3 interface which can be configured for use with rclone like this. No remotes found, make a new one? n) New remote s) Set configuration password n/s> n name> wasabi Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Amazon S3 (also Dreamhost, Ceph, ChinaMobile, ArvanCloud, Minio, Liara) \ "s3" [snip] Storage> s3 Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own value 1 / Enter AWS credentials in the next step \ "false" 2 / Get AWS credentials from the environment (env vars or IAM) \ "true" env_auth> 1 AWS Access Key ID - leave blank for anonymous access or runtime credentials. access_key_id> YOURACCESSKEY AWS Secret Access Key (password) - leave blank for anonymous access or runtime credentials. secret_access_key> YOURSECRETACCESSKEY Region to connect to. Choose a number from below, or type in your own value / The default endpoint - a good choice if you are unsure. 1 | US Region, Northern Virginia, or Pacific Northwest. | Leave location constraint empty. \ "us-east-1" [snip] region> us-east-1 Endpoint for S3 API. Leave blank if using AWS to use the default endpoint for the region. Specify if using an S3 clone such as Ceph. endpoint> s3.wasabisys.com Location constraint - must be set to match the Region. Used when creating buckets only. Choose a number from below, or type in your own value 1 / Empty for US Region, Northern Virginia, or Pacific Northwest. \ "" [snip] location_constraint> Canned ACL used when creating buckets and/or storing objects in S3. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Choose a number from below, or type in your own value 1 / Owner gets FULL_CONTROL. No one else has access rights (default). \ "private" [snip] acl> The server-side encryption algorithm used when storing this object in S3. Choose a number from below, or type in your own value 1 / None \ "" 2 / AES256 \ "AES256" server_side_encryption> The storage class to use when storing objects in S3. Choose a number from below, or type in your own value 1 / Default \ "" 2 / Standard storage class \ "STANDARD" 3 / Reduced redundancy storage class \ "REDUCED_REDUNDANCY" 4 / Standard Infrequent Access storage class \ "STANDARD_IA" storage_class> Remote config -------------------- [wasabi] env_auth = false access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY region = us-east-1 endpoint = s3.wasabisys.com location_constraint = acl = server_side_encryption = storage_class = -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y This will leave the config file looking like this. [wasabi] type = s3 provider = Wasabi env_auth = false access_key_id = YOURACCESSKEY secret_access_key = YOURSECRETACCESSKEY region = endpoint = s3.wasabisys.com location_constraint = acl = server_side_encryption = storage_class = Zata Object Storage Zata Object Storage provides a secure, S3-compatible cloud storage solution designed for scalability and performance, ideal for a variety of data storage needs. First run: rclone config This will guide you through an interactive setup process: e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> n Enter name for new remote. name> my zata storage Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. XX / Amazon S3 Compliant Storage Providers including AWS, ... \ (s3) Storage> s3 Option provider. Choose your S3 provider. Choose a number from below, or type in your own value. Press Enter to leave empty. XX / Zata (S3 compatible Gateway) \ (Zata) provider> Zata Option env_auth. Get AWS credentials from runtime (environment variables or EC2/ECS meta data if no env vars). Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own boolean value (true or false). Press Enter for the default (false). 1 / Enter AWS credentials in the next step. \ (false) 2 / Get AWS credentials from the environment (env vars or IAM). \ (true) env_auth> Option access_key_id. AWS Access Key ID. Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. access_key_id> "your key" Option secret_access_key. AWS Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Enter a value. Press Enter to leave empty. secret_access_key> "your secret key" Option region. Region where you can connect with. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Indore, Madhya Pradesh, India \ (us-east-1) region> 1 Option endpoint. Endpoint for Zata Object Storage. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / South Asia Endpoint \ (idr01.zata.ai) endpoint> 1 Option location_constraint. Location constraint - must be set to match the Region. Leave blank if not sure. Used when creating buckets only. Enter a value. Press Enter to leave empty. location_constraint> Option acl. Canned ACL used when creating buckets and storing or copying objects. This ACL is used for creating objects and if bucket_acl isn't set, for creating buckets too. For more info visit https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl Note that this ACL is applied when server-side copying objects as S3 doesn't copy the ACL from the source but rather writes a fresh one. If the acl is an empty string then no X-Amz-Acl: header is added and the default (private) will be used. Choose a number from below, or type in your own value. Press Enter to leave empty. / Owner gets FULL_CONTROL. 1 | No one else has access rights (default). \ (private) / Owner gets FULL_CONTROL. 2 | The AllUsers group gets READ access. \ (public-read) / Owner gets FULL_CONTROL. 3 | The AllUsers group gets READ and WRITE access. | Granting this on a bucket is generally not recommended. \ (public-read-write) / Owner gets FULL_CONTROL. 4 | The AuthenticatedUsers group gets READ access. \ (authenticated-read) / Object owner gets FULL_CONTROL. 5 | Bucket owner gets READ access. | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-read) / Both the object owner and the bucket owner get FULL_CONTROL over the object. 6 | If you specify this canned ACL when creating a bucket, Amazon S3 ignores it. \ (bucket-owner-full-control) acl> Edit advanced config? y) Yes n) No (default) y/n> Configuration complete. Options: - type: s3 - provider: Zata - access_key_id: xxx - secret_access_key: xxx - region: us-east-1 - endpoint: idr01.zata.ai Keep this "my zata storage" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> This will leave the config file looking like this. [my zata storage] type = s3 provider = Zata access_key_id = xxx secret_access_key = xxx region = us-east-1 endpoint = idr01.zata.ai Memory usage The most common cause of rclone using lots of memory is a single directory with millions of files in. Despite s3 not really having the concepts of directories, rclone does the sync on a directory by directory basis to be compatible with normal filing systems. Rclone loads each directory into memory as rclone objects. Each rclone object takes 0.5k-1k of memory, so approximately 1GB per 1,000,000 files, and the sync for that directory does not begin until it is entirely loaded in memory. So the sync can take a long time to start for large directories. To sync a directory with 100,000,000 files in you would need approximately 100 GB of memory. At some point the amount of memory becomes difficult to provide so there is a workaround for this which involves a bit of scripting. At some point rclone will gain a sync mode which is effectively this workaround but built in to rclone. Limitations rclone about is not supported by the S3 backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about Backblaze B2 B2 is Backblaze's cloud storage system. Paths are specified as remote:bucket (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:bucket/path/to/dir. Configuration Here is an example of making a b2 configuration. First run rclone config This will guide you through an interactive setup process. To authenticate you will either need your Account ID (a short hex number) and Master Application Key (a long hex number) OR an Application Key, which is the recommended method. See below for further details on generating and using an Application Key. No remotes found, make a new one? n) New remote q) Quit config n/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Backblaze B2 \ "b2" [snip] Storage> b2 Account ID or Application Key ID account> 123456789abc Application Key key> 0123456789abcdef0123456789abcdef0123456789 Endpoint for the service - leave blank normally. endpoint> Remote config Configuration complete. Options: - type: b2 - account: 123456789abc - key: 0123456789abcdef0123456789abcdef0123456789 - endpoint: Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y This remote is called remote and can now be used like this See all buckets rclone lsd remote: Create a new bucket rclone mkdir remote:bucket List the contents of a bucket rclone ls remote:bucket Sync /home/local/directory to the remote bucket, deleting any excess files in the bucket. rclone sync --interactive /home/local/directory remote:bucket Application Keys B2 supports multiple Application Keys for different access permission to B2 Buckets. You can use these with rclone too; you will need to use rclone version 1.43 or later. Follow Backblaze's docs to create an Application Key with the required permission and add the applicationKeyId as the account and the Application Key itself as the key. Note that you must put the applicationKeyId as the account – you can't use the master Account ID. If you try then B2 will return 401 errors. --fast-list This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details. Modification times The modification time is stored as metadata on the object as X-Bz-Info-src_last_modified_millis as milliseconds since 1970-01-01 in the Backblaze standard. Other tools should be able to use this as a modified time. Modified times are used in syncing and are fully supported. Note that if a modification time needs to be updated on an object then it will create a new version of the object. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- \ 0x5C ＼ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Note that in 2020-05 Backblaze started allowing  characters in file names. Rclone hasn't changed its encoding as this could cause syncs to re-transfer files. If you want rclone not to replace  then see the --b2-encoding flag below and remove the BackSlash from the string. This can be set in the config. SHA1 checksums The SHA1 checksums of the files are checked on upload and download and will be used in the syncing process. Large files (bigger than the limit in --b2-upload-cutoff) which are uploaded in chunks will store their SHA1 on the object as X-Bz-Info-large_file_sha1 as recommended by Backblaze. For a large file to be uploaded with an SHA1 checksum, the source needs to support SHA1 checksums. The local disk supports SHA1 checksums so large file transfers from local disk will have an SHA1. See the overview for exactly which remotes support SHA1. Sources which don't support SHA1, in particular crypt will upload large files without SHA1 checksums. This may be fixed in the future (see #1767). Files sizes below --b2-upload-cutoff will always have an SHA1 regardless of the source. Transfers Backblaze recommends that you do lots of transfers simultaneously for maximum speed. In tests from my SSD equipped laptop the optimum setting is about --transfers 32 though higher numbers may be used for a slight speed improvement. The optimum number for you may vary depending on your hardware, how big the files are, how much you want to load your computer, etc. The default of --transfers 4 is definitely too low for Backblaze B2 though. Note that uploading big files (bigger than 200 MiB by default) will use a 96 MiB RAM buffer by default. There can be at most --transfers of these in use at any moment, so this sets the upper limit on the memory used. Versions The default setting of B2 is to keep old versions of files. This means when rclone uploads a new version of a file it creates a new version of it. Likewise when you delete a file, the old version will be marked hidden and still be available. Whether B2 keeps old versions of files or not can be adjusted on a per bucket basis using the "Lifecycle settings" on the B2 control panel or when creating the bucket using the --b2-lifecycle flag or after creation using the rclone backend lifecycle command. You may opt in to a "hard delete" of files with the --b2-hard-delete flag which permanently removes files on deletion instead of hiding them. Old versions of files, where available, are visible using the --b2-versions flag. It is also possible to view a bucket as it was at a certain point in time, using the --b2-version-at flag. This will show the file versions as they were at that time, showing files that have been deleted afterwards, and hiding files that were created since. If you wish to remove all the old versions, and unfinished large file uploads, then you can use the rclone cleanup remote:bucket command which will delete all the old versions of files, leaving the current ones intact. You can also supply a path and only old versions under that path will be deleted, e.g. rclone cleanup remote:bucket/path/to/stuff. Note that cleanup will remove partially uploaded files from the bucket if they are more than a day old. If you want more control over the expiry date then run rclone backend cleanup b2:bucket -o max-age=1h to remove all unfinished large file uploads older than one hour, leaving old versions intact. If you wish to remove all the old versions, leaving current files and unfinished large files intact, then you can use the rclone backend cleanup-hidden remote:bucket command. You can also supply a path and only old versions under that path will be deleted, e.g. rclone backend cleanup-hidden remote:bucket/path/to/stuff. When you purge a bucket, the current and the old versions will be deleted then the bucket will be deleted. However delete will cause the current versions of the files to become hidden old versions. Here is a session showing the listing and retrieval of an old version followed by a cleanup of the old versions. Show current version and all the versions with --b2-versions flag. $ rclone -q ls b2:cleanup-test 9 one.txt $ rclone -q --b2-versions ls b2:cleanup-test 9 one.txt 8 one-v2016-07-04-141032-000.txt 16 one-v2016-07-04-141003-000.txt 15 one-v2016-07-02-155621-000.txt Retrieve an old version $ rclone -q --b2-versions copy b2:cleanup-test/one-v2016-07-04-141003-000.txt /tmp $ ls -l /tmp/one-v2016-07-04-141003-000.txt -rw-rw-r-- 1 ncw ncw 16 Jul 2 17:46 /tmp/one-v2016-07-04-141003-000.txt Clean up all the old versions and show that they've gone. $ rclone -q cleanup b2:cleanup-test $ rclone -q ls b2:cleanup-test 9 one.txt $ rclone -q --b2-versions ls b2:cleanup-test 9 one.txt Versions naming caveat When using --b2-versions flag rclone is relying on the file name to work out whether the objects are versions or not. Versions' names are created by inserting timestamp between file name and its extension. 9 file.txt 8 file-v2023-07-17-161032-000.txt 16 file-v2023-06-15-141003-000.txt If there are real files present with the same names as versions, then behaviour of --b2-versions can be unpredictable. Data usage It is useful to know how many requests are sent to the server in different scenarios. All copy commands send the following 4 requests: /b2api/v1/b2_authorize_account /b2api/v1/b2_create_bucket /b2api/v1/b2_list_buckets /b2api/v1/b2_list_file_names The b2_list_file_names request will be sent once for every 1k files in the remote path, providing the checksum and modification time of the listed files. As of version 1.33 issue #818 causes extra requests to be sent when using B2 with Crypt. When a copy operation does not require any files to be uploaded, no more requests will be sent. Uploading files that do not require chunking, will send 2 requests per file upload: /b2api/v1/b2_get_upload_url /b2api/v1/b2_upload_file/ Uploading files requiring chunking, will send 2 requests (one each to start and finish the upload) and another 2 requests for each chunk: /b2api/v1/b2_start_large_file /b2api/v1/b2_get_upload_part_url /b2api/v1/b2_upload_part/ /b2api/v1/b2_finish_large_file Versions Versions can be viewed with the --b2-versions flag. When it is set rclone will show and act on older versions of files. For example Listing without --b2-versions $ rclone -q ls b2:cleanup-test 9 one.txt And with $ rclone -q --b2-versions ls b2:cleanup-test 9 one.txt 8 one-v2016-07-04-141032-000.txt 16 one-v2016-07-04-141003-000.txt 15 one-v2016-07-02-155621-000.txt Showing that the current version is unchanged but older versions can be seen. These have the UTC date that they were uploaded to the server to the nearest millisecond appended to them. Note that when using --b2-versions no file write operations are permitted, so you can't upload files or delete them. B2 and rclone link Rclone supports generating file share links for private B2 buckets. They can either be for a file for example: ./rclone link B2:bucket/path/to/file.txt https://f002.backblazeb2.com/file/bucket/path/to/file.txt?Authorization=xxxxxxxx or if run on a directory you will get: ./rclone link B2:bucket/path https://f002.backblazeb2.com/file/bucket/path?Authorization=xxxxxxxx you can then use the authorization token (the part of the url from the ?Authorization= on) on any file path under that directory. For example: https://f002.backblazeb2.com/file/bucket/path/to/file1?Authorization=xxxxxxxx https://f002.backblazeb2.com/file/bucket/path/file2?Authorization=xxxxxxxx https://f002.backblazeb2.com/file/bucket/path/folder/file3?Authorization=xxxxxxxx Standard options Here are the Standard options specific to b2 (Backblaze B2). --b2-account Account ID or Application Key ID. Properties: - Config: account - Env Var: RCLONE_B2_ACCOUNT - Type: string - Required: true --b2-key Application Key. Properties: - Config: key - Env Var: RCLONE_B2_KEY - Type: string - Required: true --b2-hard-delete Permanently delete files on remote removal, otherwise hide files. Properties: - Config: hard_delete - Env Var: RCLONE_B2_HARD_DELETE - Type: bool - Default: false Advanced options Here are the Advanced options specific to b2 (Backblaze B2). --b2-endpoint Endpoint for the service. Leave blank normally. Properties: - Config: endpoint - Env Var: RCLONE_B2_ENDPOINT - Type: string - Required: false --b2-test-mode A flag string for X-Bz-Test-Mode header for debugging. This is for debugging purposes only. Setting it to one of the strings below will cause b2 to return specific errors: - "fail_some_uploads" - "expire_some_account_authorization_tokens" - "force_cap_exceeded" These will be set in the "X-Bz-Test-Mode" header which is documented in the b2 integrations checklist. Properties: - Config: test_mode - Env Var: RCLONE_B2_TEST_MODE - Type: string - Required: false --b2-versions Include old versions in directory listings. Note that when using this no file write operations are permitted, so you can't upload files or delete them. Properties: - Config: versions - Env Var: RCLONE_B2_VERSIONS - Type: bool - Default: false --b2-version-at Show file versions as they were at the specified time. Note that when using this no file write operations are permitted, so you can't upload files or delete them. Properties: - Config: version_at - Env Var: RCLONE_B2_VERSION_AT - Type: Time - Default: off --b2-upload-cutoff Cutoff for switching to chunked upload. Files above this size will be uploaded in chunks of "--b2-chunk-size". This value should be set no larger than 4.657 GiB (== 5 GB). Properties: - Config: upload_cutoff - Env Var: RCLONE_B2_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 200Mi --b2-copy-cutoff Cutoff for switching to multipart copy. Any files larger than this that need to be server-side copied will be copied in chunks of this size. The minimum is 0 and the maximum is 4.6 GiB. Properties: - Config: copy_cutoff - Env Var: RCLONE_B2_COPY_CUTOFF - Type: SizeSuffix - Default: 4Gi --b2-chunk-size Upload chunk size. When uploading large files, chunk the file into this size. Must fit in memory. These chunks are buffered in memory and there might a maximum of "--transfers" chunks in progress at once. 5,000,000 Bytes is the minimum size. Properties: - Config: chunk_size - Env Var: RCLONE_B2_CHUNK_SIZE - Type: SizeSuffix - Default: 96Mi --b2-upload-concurrency Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently. Note that chunks are stored in memory and there may be up to "--transfers" * "--b2-upload-concurrency" chunks stored at once in memory. Properties: - Config: upload_concurrency - Env Var: RCLONE_B2_UPLOAD_CONCURRENCY - Type: int - Default: 4 --b2-disable-checksum Disable checksums for large (> upload cutoff) files. Normally rclone will calculate the SHA1 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading. Properties: - Config: disable_checksum - Env Var: RCLONE_B2_DISABLE_CHECKSUM - Type: bool - Default: false --b2-download-url Custom endpoint for downloads. This is usually set to a Cloudflare CDN URL as Backblaze offers free egress for data downloaded through the Cloudflare network. Rclone works with private buckets by sending an "Authorization" header. If the custom endpoint rewrites the requests for authentication, e.g., in Cloudflare Workers, this header needs to be handled properly. Leave blank if you want to use the endpoint provided by Backblaze. The URL provided here SHOULD have the protocol and SHOULD NOT have a trailing slash or specify the /file/bucket subpath as rclone will request files with "{download_url}/file/{bucket_name}/{path}". Example: > https://mysubdomain.mydomain.tld (No trailing "/", "file" or "bucket") Properties: - Config: download_url - Env Var: RCLONE_B2_DOWNLOAD_URL - Type: string - Required: false --b2-download-auth-duration Time before the public link authorization token will expire in s or suffix ms|s|m|h|d. This is used in combination with "rclone link" for making files accessible to the public and sets the duration before the download authorization token will expire. The minimum value is 1 second. The maximum value is one week. Properties: - Config: download_auth_duration - Env Var: RCLONE_B2_DOWNLOAD_AUTH_DURATION - Type: Duration - Default: 1w --b2-memory-pool-flush-time How often internal memory buffer pools will be flushed. (no longer used) Properties: - Config: memory_pool_flush_time - Env Var: RCLONE_B2_MEMORY_POOL_FLUSH_TIME - Type: Duration - Default: 1m0s --b2-memory-pool-use-mmap Whether to use mmap buffers in internal memory pool. (no longer used) Properties: - Config: memory_pool_use_mmap - Env Var: RCLONE_B2_MEMORY_POOL_USE_MMAP - Type: bool - Default: false --b2-lifecycle Set the number of days deleted files should be kept when creating a bucket. On bucket creation, this parameter is used to create a lifecycle rule for the entire bucket. If lifecycle is 0 (the default) it does not create a lifecycle rule so the default B2 behaviour applies. This is to create versions of files on delete and overwrite and to keep them indefinitely. If lifecycle is >0 then it creates a single rule setting the number of days before a file that is deleted or overwritten is deleted permanently. This is known as daysFromHidingToDeleting in the b2 docs. The minimum value for this parameter is 1 day. You can also enable hard_delete in the config also which will mean deletions won't cause versions but overwrites will still cause versions to be made. See: rclone backend lifecycle for setting lifecycles after bucket creation. Properties: - Config: lifecycle - Env Var: RCLONE_B2_LIFECYCLE - Type: int - Default: 0 --b2-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_B2_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot --b2-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_B2_DESCRIPTION - Type: string - Required: false Backend commands Here are the commands specific to the b2 backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the backend command for more info on how to pass options and arguments. These can be run on a running backend using the rc command backend/command. lifecycle Read or set the lifecycle for a bucket rclone backend lifecycle remote: [options] [+] This command can be used to read or set the lifecycle for a bucket. Usage Examples: To show the current lifecycle rules: rclone backend lifecycle b2:bucket This will dump something like this showing the lifecycle rules. [ { "daysFromHidingToDeleting": 1, "daysFromUploadingToHiding": null, "daysFromStartingToCancelingUnfinishedLargeFiles": null, "fileNamePrefix": "" } ] If there are no lifecycle rules (the default) then it will just return []. To reset the current lifecycle rules: rclone backend lifecycle b2:bucket -o daysFromHidingToDeleting=30 rclone backend lifecycle b2:bucket -o daysFromUploadingToHiding=5 -o daysFromHidingToDeleting=1 This will run and then print the new lifecycle rules as above. Rclone only lets you set lifecycles for the whole bucket with the fileNamePrefix = "". You can't disable versioning with B2. The best you can do is to set the daysFromHidingToDeleting to 1 day. You can enable hard_delete in the config also which will mean deletions won't cause versions but overwrites will still cause versions to be made. rclone backend lifecycle b2:bucket -o daysFromHidingToDeleting=1 See: https://www.backblaze.com/docs/cloud-storage-lifecycle-rules Options: - "daysFromHidingToDeleting": After a file has been hidden for this many days it is deleted. 0 is off. - "daysFromStartingToCancelingUnfinishedLargeFiles": Cancels any unfinished large file versions after this many days - "daysFromUploadingToHiding": This many days after uploading a file is hidden cleanup Remove unfinished large file uploads. rclone backend cleanup remote: [options] [+] This command removes unfinished large file uploads of age greater than max-age, which defaults to 24 hours. Note that you can use --interactive/-i or --dry-run with this command to see what it would do. rclone backend cleanup b2:bucket/path/to/object rclone backend cleanup -o max-age=7w b2:bucket/path/to/object Durations are parsed as per the rest of rclone, 2h, 7d, 7w etc. Options: - "max-age": Max age of upload to delete cleanup-hidden Remove old versions of files. rclone backend cleanup-hidden remote: [options] [+] This command removes any old hidden versions of files. Note that you can use --interactive/-i or --dry-run with this command to see what it would do. rclone backend cleanup-hidden b2:bucket/path/to/dir Limitations rclone about is not supported by the B2 backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about Box Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. The initial setup for Box involves getting a token from Box which you can do either in your browser, or with a config.json downloaded from Box to use JWT authentication. rclone config walks you through it. Configuration Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Box \ "box" [snip] Storage> box Box App Client Id - leave blank normally. client_id> Box App Client Secret - leave blank normally. client_secret> Box App config.json location Leave blank normally. Enter a string value. Press Enter for the default (""). box_config_file> Box App Primary Access Token Leave blank normally. Enter a string value. Press Enter for the default (""). access_token> Enter a string value. Press Enter for the default ("user"). Choose a number from below, or type in your own value 1 / Rclone should act on behalf of a user \ "user" 2 / Rclone should act on behalf of a service account \ "enterprise" box_sub_type> Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth?state=XXXXXXXXXXXXXXXXXXXXXX Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: box - client_id: - client_secret: - token: {"access_token":"XXX","token_type":"bearer","refresh_token":"XXX","expiry":"XXX"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y See the remote setup docs for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Box. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this may require you to unblock it temporarily if you are running a host firewall. Once configured you can then use rclone like this, List directories in top level of your Box rclone lsd remote: List all the files in your Box rclone ls remote: To copy a local directory to an Box directory called backup rclone copy /home/source remote:backup Using rclone with an Enterprise account with SSO If you have an "Enterprise" account type with Box with single sign on (SSO), you need to create a password to use Box with rclone. This can be done at your Enterprise Box account by going to Settings, "Account" Tab, and then set the password in the "Authentication" field. Once you have done this, you can setup your Enterprise Box account using the same procedure detailed above in the, using the password you have just set. Invalid refresh token According to the box docs: Each refresh_token is valid for one use in 60 days. This means that if you - Don't use the box remote for 60 days - Copy the config file with a box refresh token in and use it in two places - Get an error on a token refresh then rclone will return an error which includes the text Invalid refresh token. To fix this you will need to use oauth2 again to update the refresh token. You can use the methods in the remote setup docs, bearing in mind that if you use the copy the config file method, you should not use that remote on the computer you did the authentication on. Here is how to do it. $ rclone config Current remotes: Name Type ==== ==== remote box e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> e Choose a number from below, or type in an existing value 1 > remote remote> remote Configuration complete. Options: - type: box - token: {"access_token":"XXX","token_type":"bearer","refresh_token":"XXX","expiry":"2017-07-08T23:40:08.059167677+01:00"} Keep this "remote" remote? Edit remote Value "client_id" = "" Edit? (y/n)> y) Yes n) No y/n> n Value "client_secret" = "" Edit? (y/n)> y) Yes n) No y/n> n Remote config Already have a token - refresh? y) Yes n) No y/n> y Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: box - token: {"access_token":"YYY","token_type":"bearer","refresh_token":"YYY","expiry":"2017-07-23T12:22:29.259137901+01:00"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Modification times and hashes Box allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not. Box supports SHA1 type hashes, so you can use the --checksum flag. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- \ 0x5C ＼ File names can also not end with the following characters. These only get replaced if they are the last character in the name: Character Value Replacement ----------- ------- ------------- SP 0x20 ␠ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Transfers For files above 50 MiB rclone will use a chunked transfer. Rclone will upload up to --transfers chunks at the same time (shared among all the multipart uploads). Chunks are buffered in memory and are normally 8 MiB so increasing --transfers will increase memory use. Deleting files Depending on the enterprise settings for your user, the item will either be actually deleted from Box or moved to the trash. Emptying the trash is supported via the rclone however cleanup command however this deletes every trashed file and folder individually so it may take a very long time. Emptying the trash via the WebUI does not have this limitation so it is advised to empty the trash via the WebUI. Root folder ID You can set the root_folder_id for rclone. This is the directory (identified by its Folder ID) that rclone considers to be the root of your Box drive. Normally you will leave this blank and rclone will determine the correct root to use itself. However you can set this to restrict rclone to a specific folder hierarchy. In order to do this you will have to find the Folder ID of the directory you wish rclone to display. This will be the last segment of the URL when you open the relevant folder in the Box web interface. So if the folder you want rclone to use has a URL which looks like https://app.box.com/folder/11xxxxxxxxx8 in the browser, then you use 11xxxxxxxxx8 as the root_folder_id in the config. Standard options Here are the Standard options specific to box (Box). --box-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_BOX_CLIENT_ID - Type: string - Required: false --box-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_BOX_CLIENT_SECRET - Type: string - Required: false --box-box-config-file Box App config.json location Leave blank normally. Leading ~ will be expanded in the file name as will environment variables such as ${RCLONE_CONFIG_DIR}. Properties: - Config: box_config_file - Env Var: RCLONE_BOX_BOX_CONFIG_FILE - Type: string - Required: false --box-access-token Box App Primary Access Token Leave blank normally. Properties: - Config: access_token - Env Var: RCLONE_BOX_ACCESS_TOKEN - Type: string - Required: false --box-box-sub-type Properties: - Config: box_sub_type - Env Var: RCLONE_BOX_BOX_SUB_TYPE - Type: string - Default: "user" - Examples: - "user" - Rclone should act on behalf of a user. - "enterprise" - Rclone should act on behalf of a service account. Advanced options Here are the Advanced options specific to box (Box). --box-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_BOX_TOKEN - Type: string - Required: false --box-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_BOX_AUTH_URL - Type: string - Required: false --box-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_BOX_TOKEN_URL - Type: string - Required: false --box-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_BOX_CLIENT_CREDENTIALS - Type: bool - Default: false --box-root-folder-id Fill in for rclone to use a non root folder as its starting point. Properties: - Config: root_folder_id - Env Var: RCLONE_BOX_ROOT_FOLDER_ID - Type: string - Default: "0" --box-upload-cutoff Cutoff for switching to multipart upload (>= 50 MiB). Properties: - Config: upload_cutoff - Env Var: RCLONE_BOX_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 50Mi --box-commit-retries Max number of times to try committing a multipart file. Properties: - Config: commit_retries - Env Var: RCLONE_BOX_COMMIT_RETRIES - Type: int - Default: 100 --box-list-chunk Size of listing chunk 1-1000. Properties: - Config: list_chunk - Env Var: RCLONE_BOX_LIST_CHUNK - Type: int - Default: 1000 --box-owned-by Only show items owned by the login (email address) passed in. Properties: - Config: owned_by - Env Var: RCLONE_BOX_OWNED_BY - Type: string - Required: false --box-impersonate Impersonate this user ID when using a service account. Setting this flag allows rclone, when using a JWT service account, to act on behalf of another user by setting the as-user header. The user ID is the Box identifier for a user. User IDs can found for any user via the GET /users endpoint, which is only available to admins, or by calling the GET /users/me endpoint with an authenticated user session. See: https://developer.box.com/guides/authentication/jwt/as-user/ Properties: - Config: impersonate - Env Var: RCLONE_BOX_IMPERSONATE - Type: string - Required: false --box-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_BOX_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot --box-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_BOX_DESCRIPTION - Type: string - Required: false Limitations Note that Box is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". Box file names can't have the \ character in. rclone maps this to and from an identical looking unicode equivalent ＼ (U+FF3C Fullwidth Reverse Solidus). Box only supports filenames up to 255 characters in length. Box has API rate limits that sometimes reduce the speed of rclone. rclone about is not supported by the Box backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about Get your own Box App ID Here is how to create your own Box App ID for rclone: 1. Go to the Box Developer Console and login, then click My Apps on the sidebar. Click Create New App and select Custom App. 2. In the first screen on the box that pops up, you can pretty much enter whatever you want. The App Name can be whatever. For Purpose choose automation to avoid having to fill out anything else. Click Next. 3. In the second screen of the creation screen, select User Authentication (OAuth 2.0). Then click Create App. 4. You should now be on the Configuration tab of your new app. If not, click on it at the top of the webpage. Copy down Client ID and Client Secret, you'll need those for rclone. 5. Under "OAuth 2.0 Redirect URI", add http://127.0.0.1:53682/ 6. For Application Scopes, select Read all files and folders stored in Box and Write all files and folders stored in box (assuming you want to do both). Leave others unchecked. Click Save Changes at the top right. Cache The cache remote wraps another existing remote and stores file structure and its data for long running tasks like rclone mount. Status The cache backend code is working but it currently doesn't have a maintainer so there are outstanding bugs which aren't getting fixed. The cache backend is due to be phased out in favour of the VFS caching layer eventually which is more tightly integrated into rclone. Until this happens we recommend only using the cache backend if you find you can't work without it. There are many docs online describing the use of the cache backend to minimize API hits and by-and-large these are out of date and the cache backend isn't needed in those scenarios any more. Configuration To get started you just need to have an existing remote which can be configured with cache. Here is an example of how to make a remote called test-cache. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config n/r/c/s/q> n name> test-cache Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Cache a remote \ "cache" [snip] Storage> cache Remote to cache. Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended). remote> local:/test Optional: The URL of the Plex server plex_url> http://127.0.0.1:32400 Optional: The username of the Plex user plex_username> dummyusername Optional: The password of the Plex user y) Yes type in my own password g) Generate random password n) No leave this optional password blank y/g/n> y Enter the password: password: Confirm the password: password: The size of a chunk. Lower value good for slow connections but can affect seamless reading. Default: 5M Choose a number from below, or type in your own value 1 / 1 MiB \ "1M" 2 / 5 MiB \ "5M" 3 / 10 MiB \ "10M" chunk_size> 2 How much time should object info (file size, file hashes, etc.) be stored in cache. Use a very high value if you don't plan on changing the source FS from outside the cache. Accepted units are: "s", "m", "h". Default: 5m Choose a number from below, or type in your own value 1 / 1 hour \ "1h" 2 / 24 hours \ "24h" 3 / 24 hours \ "48h" info_age> 2 The maximum size of stored chunks. When the storage grows beyond this size, the oldest chunks will be deleted. Default: 10G Choose a number from below, or type in your own value 1 / 500 MiB \ "500M" 2 / 1 GiB \ "1G" 3 / 10 GiB \ "10G" chunk_total_size> 3 Remote config -------------------- [test-cache] remote = local:/test plex_url = http://127.0.0.1:32400 plex_username = dummyusername plex_password = *** ENCRYPTED *** chunk_size = 5M info_age = 48h chunk_total_size = 10G You can then use it like this, List directories in top level of your drive rclone lsd test-cache: List all the files in your drive rclone ls test-cache: To start a cached mount rclone mount --allow-other test-cache: /var/tmp/test-cache Write Features Offline uploading In an effort to make writing through cache more reliable, the backend now supports this feature which can be activated by specifying a cache-tmp-upload-path. A files goes through these states when using this feature: 1. An upload is started (usually by copying a file on the cache remote) 2. When the copy to the temporary location is complete the file is part of the cached remote and looks and behaves like any other file (reading included) 3. After cache-tmp-wait-time passes and the file is next in line, rclone move is used to move the file to the cloud provider 4. Reading the file still works during the upload but most modifications on it will be prohibited 5. Once the move is complete the file is unlocked for modifications as it becomes as any other regular file 6. If the file is being read through cache when it's actually deleted from the temporary path then cache will simply swap the source to the cloud provider without interrupting the reading (small blip can happen though) Files are uploaded in sequence and only one file is uploaded at a time. Uploads will be stored in a queue and be processed based on the order they were added. The queue and the temporary storage is persistent across restarts but can be cleared on startup with the --cache-db-purge flag. Write Support Writes are supported through cache. One caveat is that a mounted cache remote does not add any retry or fallback mechanism to the upload operation. This will depend on the implementation of the wrapped remote. Consider using Offline uploading for reliable writes. One special case is covered with cache-writes which will cache the file data at the same time as the upload when it is enabled making it available from the cache store immediately once the upload is finished. Read Features Multiple connections To counter the high latency between a local PC where rclone is running and cloud providers, the cache remote can split multiple requests to the cloud provider for smaller file chunks and combines them together locally where they can be available almost immediately before the reader usually needs them. This is similar to buffering when media files are played online. Rclone will stay around the current marker but always try its best to stay ahead and prepare the data before. Plex Integration There is a direct integration with Plex which allows cache to detect during reading if the file is in playback or not. This helps cache to adapt how it queries the cloud provider depending on what is needed for. Scans will have a minimum amount of workers (1) while in a confirmed playback cache will deploy the configured number of workers. This integration opens the doorway to additional performance improvements which will be explored in the near future. Note: If Plex options are not configured, cache will function with its configured options without adapting any of its settings. How to enable? Run rclone config and add all the Plex options (endpoint, username and password) in your remote and it will be automatically enabled. Affected settings: - cache-workers: Configured value during confirmed playback or 1 all the other times Certificate Validation When the Plex server is configured to only accept secure connections, it is possible to use .plex.direct URLs to ensure certificate validation succeeds. These URLs are used by Plex internally to connect to the Plex server securely. The format for these URLs is the following: https://ip-with-dots-replaced.server-hash.plex.direct:32400/ The ip-with-dots-replaced part can be any IPv4 address, where the dots have been replaced with dashes, e.g. 127.0.0.1 becomes 127-0-0-1. To get the server-hash part, the easiest way is to visit https://plex.tv/api/resources?includeHttps=1&X-Plex-Token=your-plex-token This page will list all the available Plex servers for your account with at least one .plex.direct link for each. Copy one URL and replace the IP address with the desired address. This can be used as the plex_url value. Known issues Mount and --dir-cache-time --dir-cache-time controls the first layer of directory caching which works at the mount layer. Being an independent caching mechanism from the cache backend, it will manage its own entries based on the configured time. To avoid getting in a scenario where dir cache has obsolete data and cache would have the correct one, try to set --dir-cache-time to a lower time than --cache-info-age. Default values are already configured in this way. Windows support - Experimental There are a couple of issues with Windows mount functionality that still require some investigations. It should be considered as experimental thus far as fixes come in for this OS. Most of the issues seem to be related to the difference between filesystems on Linux flavors and Windows as cache is heavily dependent on them. Any reports or feedback on how cache behaves on this OS is greatly appreciated. - https://github.com/rclone/rclone/issues/1935 - https://github.com/rclone/rclone/issues/1907 - https://github.com/rclone/rclone/issues/1834 Risk of throttling Future iterations of the cache backend will make use of the pooling functionality of the cloud provider to synchronize and at the same time make writing through it more tolerant to failures. There are a couple of enhancements in track to add these but in the meantime there is a valid concern that the expiring cache listings can lead to cloud provider throttles or bans due to repeated queries on it for very large mounts. Some recommendations: - don't use a very small interval for entry information (--cache-info-age) - while writes aren't yet optimised, you can still write through cache which gives you the advantage of adding the file in the cache at the same time if configured to do so. Future enhancements: - https://github.com/rclone/rclone/issues/1937 - https://github.com/rclone/rclone/issues/1936 cache and crypt One common scenario is to keep your data encrypted in the cloud provider using the crypt remote. crypt uses a similar technique to wrap around an existing remote and handles this translation in a seamless way. There is an issue with wrapping the remotes in this order: cloud remote -> crypt -> cache During testing, I experienced a lot of bans with the remotes in this order. I suspect it might be related to how crypt opens files on the cloud provider which makes it think we're downloading the full file instead of small chunks. Organizing the remotes in this order yields better results: cloud remote -> cache -> crypt absolute remote paths cache can not differentiate between relative and absolute paths for the wrapped remote. Any path given in the remote config setting and on the command line will be passed to the wrapped remote as is, but for storing the chunks on disk the path will be made relative by removing any leading / character. This behavior is irrelevant for most backend types, but there are backends where a leading / changes the effective directory, e.g. in the sftp backend paths starting with a / are relative to the root of the SSH server and paths without are relative to the user home directory. As a result sftp:bin and sftp:/bin will share the same cache folder, even if they represent a different directory on the SSH server. Cache and Remote Control (--rc) Cache supports the new --rc mode in rclone and can be remote controlled through the following end points: By default, the listener is disabled if you do not add the flag. rc cache/expire Purge a remote from the cache backend. Supports either a directory or a file. It supports both encrypted and unencrypted file names if cache is wrapped by crypt. Params: - remote = path to remote (required) - withData = true/false to delete cached data (chunks) as well (optional, false by default) Standard options Here are the Standard options specific to cache (Cache a remote). --cache-remote Remote to cache. Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended). Properties: - Config: remote - Env Var: RCLONE_CACHE_REMOTE - Type: string - Required: true --cache-plex-url The URL of the Plex server. Properties: - Config: plex_url - Env Var: RCLONE_CACHE_PLEX_URL - Type: string - Required: false --cache-plex-username The username of the Plex user. Properties: - Config: plex_username - Env Var: RCLONE_CACHE_PLEX_USERNAME - Type: string - Required: false --cache-plex-password The password of the Plex user. NB Input to this must be obscured - see rclone obscure. Properties: - Config: plex_password - Env Var: RCLONE_CACHE_PLEX_PASSWORD - Type: string - Required: false --cache-chunk-size The size of a chunk (partial file data). Use lower numbers for slower connections. If the chunk size is changed, any downloaded chunks will be invalid and cache-chunk-path will need to be cleared or unexpected EOF errors will occur. Properties: - Config: chunk_size - Env Var: RCLONE_CACHE_CHUNK_SIZE - Type: SizeSuffix - Default: 5Mi - Examples: - "1M" - 1 MiB - "5M" - 5 MiB - "10M" - 10 MiB --cache-info-age How long to cache file structure information (directory listings, file size, times, etc.). If all write operations are done through the cache then you can safely make this value very large as the cache store will also be updated in real time. Properties: - Config: info_age - Env Var: RCLONE_CACHE_INFO_AGE - Type: Duration - Default: 6h0m0s - Examples: - "1h" - 1 hour - "24h" - 24 hours - "48h" - 48 hours --cache-chunk-total-size The total size that the chunks can take up on the local disk. If the cache exceeds this value then it will start to delete the oldest chunks until it goes under this value. Properties: - Config: chunk_total_size - Env Var: RCLONE_CACHE_CHUNK_TOTAL_SIZE - Type: SizeSuffix - Default: 10Gi - Examples: - "500M" - 500 MiB - "1G" - 1 GiB - "10G" - 10 GiB Advanced options Here are the Advanced options specific to cache (Cache a remote). --cache-plex-token The plex token for authentication - auto set normally. Properties: - Config: plex_token - Env Var: RCLONE_CACHE_PLEX_TOKEN - Type: string - Required: false --cache-plex-insecure Skip all certificate verification when connecting to the Plex server. Properties: - Config: plex_insecure - Env Var: RCLONE_CACHE_PLEX_INSECURE - Type: string - Required: false --cache-db-path Directory to store file structure metadata DB. The remote name is used as the DB file name. Properties: - Config: db_path - Env Var: RCLONE_CACHE_DB_PATH - Type: string - Default: "$HOME/.cache/rclone/cache-backend" --cache-chunk-path Directory to cache chunk files. Path to where partial file data (chunks) are stored locally. The remote name is appended to the final path. This config follows the "--cache-db-path". If you specify a custom location for "--cache-db-path" and don't specify one for "--cache-chunk-path" then "--cache-chunk-path" will use the same path as "--cache-db-path". Properties: - Config: chunk_path - Env Var: RCLONE_CACHE_CHUNK_PATH - Type: string - Default: "$HOME/.cache/rclone/cache-backend" --cache-db-purge Clear all the cached data for this remote on start. Properties: - Config: db_purge - Env Var: RCLONE_CACHE_DB_PURGE - Type: bool - Default: false --cache-chunk-clean-interval How often should the cache perform cleanups of the chunk storage. The default value should be ok for most people. If you find that the cache goes over "cache-chunk-total-size" too often then try to lower this value to force it to perform cleanups more often. Properties: - Config: chunk_clean_interval - Env Var: RCLONE_CACHE_CHUNK_CLEAN_INTERVAL - Type: Duration - Default: 1m0s --cache-read-retries How many times to retry a read from a cache storage. Since reading from a cache stream is independent from downloading file data, readers can get to a point where there's no more data in the cache. Most of the times this can indicate a connectivity issue if cache isn't able to provide file data anymore. For really slow connections, increase this to a point where the stream is able to provide data but your experience will be very stuttering. Properties: - Config: read_retries - Env Var: RCLONE_CACHE_READ_RETRIES - Type: int - Default: 10 --cache-workers How many workers should run in parallel to download chunks. Higher values will mean more parallel processing (better CPU needed) and more concurrent requests on the cloud provider. This impacts several aspects like the cloud provider API limits, more stress on the hardware that rclone runs on but it also means that streams will be more fluid and data will be available much more faster to readers. Note: If the optional Plex integration is enabled then this setting will adapt to the type of reading performed and the value specified here will be used as a maximum number of workers to use. Properties: - Config: workers - Env Var: RCLONE_CACHE_WORKERS - Type: int - Default: 4 --cache-chunk-no-memory Disable the in-memory cache for storing chunks during streaming. By default, cache will keep file data during streaming in RAM as well to provide it to readers as fast as possible. This transient data is evicted as soon as it is read and the number of chunks stored doesn't exceed the number of workers. However, depending on other settings like "cache-chunk-size" and "cache-workers" this footprint can increase if there are parallel streams too (multiple files being read at the same time). If the hardware permits it, use this feature to provide an overall better performance during streaming but it can also be disabled if RAM is not available on the local machine. Properties: - Config: chunk_no_memory - Env Var: RCLONE_CACHE_CHUNK_NO_MEMORY - Type: bool - Default: false --cache-rps Limits the number of requests per second to the source FS (-1 to disable). This setting places a hard limit on the number of requests per second that cache will be doing to the cloud provider remote and try to respect that value by setting waits between reads. If you find that you're getting banned or limited on the cloud provider through cache and know that a smaller number of requests per second will allow you to work with it then you can use this setting for that. A good balance of all the other settings should make this setting useless but it is available to set for more special cases. NOTE: This will limit the number of requests during streams but other API calls to the cloud provider like directory listings will still pass. Properties: - Config: rps - Env Var: RCLONE_CACHE_RPS - Type: int - Default: -1 --cache-writes Cache file data on writes through the FS. If you need to read files immediately after you upload them through cache you can enable this flag to have their data stored in the cache store at the same time during upload. Properties: - Config: writes - Env Var: RCLONE_CACHE_WRITES - Type: bool - Default: false --cache-tmp-upload-path Directory to keep temporary files until they are uploaded. This is the path where cache will use as a temporary storage for new files that need to be uploaded to the cloud provider. Specifying a value will enable this feature. Without it, it is completely disabled and files will be uploaded directly to the cloud provider Properties: - Config: tmp_upload_path - Env Var: RCLONE_CACHE_TMP_UPLOAD_PATH - Type: string - Required: false --cache-tmp-wait-time How long should files be stored in local cache before being uploaded. This is the duration that a file must wait in the temporary location cache-tmp-upload-path before it is selected for upload. Note that only one file is uploaded at a time and it can take longer to start the upload if a queue formed for this purpose. Properties: - Config: tmp_wait_time - Env Var: RCLONE_CACHE_TMP_WAIT_TIME - Type: Duration - Default: 15s --cache-db-wait-time How long to wait for the DB to be available - 0 is unlimited. Only one process can have the DB open at any one time, so rclone waits for this duration for the DB to become available before it gives an error. If you set it to 0 then it will wait forever. Properties: - Config: db_wait_time - Env Var: RCLONE_CACHE_DB_WAIT_TIME - Type: Duration - Default: 1s --cache-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_CACHE_DESCRIPTION - Type: string - Required: false Backend commands Here are the commands specific to the cache backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the backend command for more info on how to pass options and arguments. These can be run on a running backend using the rc command backend/command. stats Print stats on the cache backend in JSON format. rclone backend stats remote: [options] [+] Chunker The chunker overlay transparently splits large files into smaller chunks during upload to wrapped remote and transparently assembles them back when the file is downloaded. This allows to effectively overcome size limits imposed by storage providers. Configuration To use it, first set up the underlying remote following the configuration instructions for that remote. You can also use a local pathname instead of a remote. First check your chosen remote is working - we'll call it remote:path here. Note that anything inside remote:path will be chunked and anything outside won't. This means that if you are using a bucket-based remote (e.g. S3, B2, swift) then you should probably put the bucket in the remote s3:bucket. Now configure chunker using rclone config. We will call this one overlay to separate it from the remote itself. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> overlay Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Transparently chunk/split large files \ "chunker" [snip] Storage> chunker Remote to chunk/unchunk. Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended). Enter a string value. Press Enter for the default (""). remote> remote:path Files larger than chunk size will be split in chunks. Enter a size with suffix K,M,G,T. Press Enter for the default ("2G"). chunk_size> 100M Choose how chunker handles hash sums. All modes but "none" require metadata. Enter a string value. Press Enter for the default ("md5"). Choose a number from below, or type in your own value 1 / Pass any hash supported by wrapped remote for non-chunked files, return nothing otherwise \ "none" 2 / MD5 for composite files \ "md5" 3 / SHA1 for composite files \ "sha1" 4 / MD5 for all files \ "md5all" 5 / SHA1 for all files \ "sha1all" 6 / Copying a file to chunker will request MD5 from the source falling back to SHA1 if unsupported \ "md5quick" 7 / Similar to "md5quick" but prefers SHA1 over MD5 \ "sha1quick" hash_type> md5 Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config -------------------- [overlay] type = chunker remote = remote:bucket chunk_size = 100M hash_type = md5 -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Specifying the remote In normal use, make sure the remote has a : in. If you specify the remote without a : then rclone will use a local directory of that name. So if you use a remote of /path/to/secret/files then rclone will chunk stuff in that directory. If you use a remote of name then rclone will put files in a directory called name in the current directory. Chunking When rclone starts a file upload, chunker checks the file size. If it doesn't exceed the configured chunk size, chunker will just pass the file to the wrapped remote (however, see caveat below). If a file is large, chunker will transparently cut data in pieces with temporary names and stream them one by one, on the fly. Each data chunk will contain the specified number of bytes, except for the last one which may have less data. If file size is unknown in advance (this is called a streaming upload), chunker will internally create a temporary copy, record its size and repeat the above process. When upload completes, temporary chunk files are finally renamed. This scheme guarantees that operations can be run in parallel and look from outside as atomic. A similar method with hidden temporary chunks is used for other operations (copy/move/rename, etc.). If an operation fails, hidden chunks are normally destroyed, and the target composite file stays intact. When a composite file download is requested, chunker transparently assembles it by concatenating data chunks in order. As the split is trivial one could even manually concatenate data chunks together to obtain the original content. When the list rclone command scans a directory on wrapped remote, the potential chunk files are accounted for, grouped and assembled into composite directory entries. Any temporary chunks are hidden. List and other commands can sometimes come across composite files with missing or invalid chunks, e.g. shadowed by like-named directory or another file. This usually means that wrapped file system has been directly tampered with or damaged. If chunker detects a missing chunk it will by default print warning, skip the whole incomplete group of chunks but proceed with current command. You can set the --chunker-fail-hard flag to have commands abort with error message in such cases. Caveat: As it is now, chunker will always create a temporary file in the backend and then rename it, even if the file is below the chunk threshold. This will result in unnecessary API calls and can severely restrict throughput when handling transfers primarily composed of small files on some backends (e.g. Box). A workaround to this issue is to use chunker only for files above the chunk threshold via --min-size and then perform a separate call without chunker on the remaining files. Chunk names The default chunk name format is *.rclone_chunk.###, hence by default chunk names are BIG_FILE_NAME.rclone_chunk.001, BIG_FILE_NAME.rclone_chunk.002 etc. You can configure another name format using the name_format configuration file option. The format uses asterisk * as a placeholder for the base file name and one or more consecutive hash characters # as a placeholder for sequential chunk number. There must be one and only one asterisk. The number of consecutive hash characters defines the minimum length of a string representing a chunk number. If decimal chunk number has less digits than the number of hashes, it is left-padded by zeros. If the decimal string is longer, it is left intact. By default numbering starts from 1 but there is another option that allows user to start from 0, e.g. for compatibility with legacy software. For example, if name format is big_*-##.part and original file name is data.txt and numbering starts from 0, then the first chunk will be named big_data.txt-00.part, the 99th chunk will be big_data.txt-98.part and the 302nd chunk will become big_data.txt-301.part. Note that list assembles composite directory entries only when chunk names match the configured format and treats non-conforming file names as normal non-chunked files. When using norename transactions, chunk names will additionally have a unique file version suffix. For example, BIG_FILE_NAME.rclone_chunk.001_bp562k. Metadata Besides data chunks chunker will by default create metadata object for a composite file. The object is named after the original file. Chunker allows user to disable metadata completely (the none format). Note that metadata is normally not created for files smaller than the configured chunk size. This may change in future rclone releases. Simple JSON metadata format This is the default format. It supports hash sums and chunk validation for composite files. Meta objects carry the following fields: - ver - version of format, currently 1 - size - total size of composite file - nchunks - number of data chunks in file - md5 - MD5 hashsum of composite file (if present) - sha1 - SHA1 hashsum (if present) - txn - identifies current version of the file There is no field for composite file name as it's simply equal to the name of meta object on the wrapped remote. Please refer to respective sections for details on hashsums and modified time handling. No metadata You can disable meta objects by setting the meta format option to none. In this mode chunker will scan directory for all files that follow configured chunk name format, group them by detecting chunks with the same base name and show group names as virtual composite files. This method is more prone to missing chunk errors (especially missing last chunk) than format with metadata enabled. Hashsums Chunker supports hashsums only when a compatible metadata is present. Hence, if you choose metadata format of none, chunker will report hashsum as UNSUPPORTED. Please note that by default metadata is stored only for composite files. If a file is smaller than configured chunk size, chunker will transparently redirect hash requests to wrapped remote, so support depends on that. You will see the empty string as a hashsum of requested type for small files if the wrapped remote doesn't support it. Many storage backends support MD5 and SHA1 hash types, so does chunker. With chunker you can choose one or another but not both. MD5 is set by default as the most supported type. Since chunker keeps hashes for composite files and falls back to the wrapped remote hash for non-chunked ones, we advise you to choose the same hash type as supported by wrapped remote so that your file listings look coherent. If your storage backend does not support MD5 or SHA1 but you need consistent file hashing, configure chunker with md5all or sha1all. These two modes guarantee given hash for all files. If wrapped remote doesn't support it, chunker will then add metadata to all files, even small. However, this can double the amount of small files in storage and incur additional service charges. You can even use chunker to force md5/sha1 support in any other remote at expense of sidecar meta objects by setting e.g. hash_type=sha1all to force hashsums and chunk_size=1P to effectively disable chunking. Normally, when a file is copied to chunker controlled remote, chunker will ask the file source for compatible file hash and revert to on-the-fly calculation if none is found. This involves some CPU overhead but provides a guarantee that given hashsum is available. Also, chunker will reject a server-side copy or move operation if source and destination hashsum types are different resulting in the extra network bandwidth, too. In some rare cases this may be undesired, so chunker provides two optional choices: sha1quick and md5quick. If the source does not support primary hash type and the quick mode is enabled, chunker will try to fall back to the secondary type. This will save CPU and bandwidth but can result in empty hashsums at destination. Beware of consequences: the sync command will revert (sometimes silently) to time/size comparison if compatible hashsums between source and target are not found. Modification times Chunker stores modification times using the wrapped remote so support depends on that. For a small non-chunked file the chunker overlay simply manipulates modification time of the wrapped remote file. For a composite file with metadata chunker will get and set modification time of the metadata object on the wrapped remote. If file is chunked but metadata format is none then chunker will use modification time of the first data chunk. Migrations The idiomatic way to migrate to a different chunk size, hash type, transaction style or chunk naming scheme is to: - Collect all your chunked files under a directory and have your chunker remote point to it. - Create another directory (most probably on the same cloud storage) and configure a new remote with desired metadata format, hash type, chunk naming etc. - Now run rclone sync --interactive oldchunks: newchunks: and all your data will be transparently converted in transfer. This may take some time, yet chunker will try server-side copy if possible. - After checking data integrity you may remove configuration section of the old remote. If rclone gets killed during a long operation on a big composite file, hidden temporary chunks may stay in the directory. They will not be shown by the list command but will eat up your account quota. Please note that the deletefile command deletes only active chunks of a file. As a workaround, you can use remote of the wrapped file system to see them. An easy way to get rid of hidden garbage is to copy littered directory somewhere using the chunker remote and purge the original directory. The copy command will copy only active chunks while the purge will remove everything including garbage. Caveats and Limitations Chunker requires wrapped remote to support server-side move (or copy + delete) operations, otherwise it will explicitly refuse to start. This is because it internally renames temporary chunk files to their final names when an operation completes successfully. Chunker encodes chunk number in file name, so with default name_format setting it adds 17 characters. Also chunker adds 7 characters of temporary suffix during operations. Many file systems limit base file name without path by 255 characters. Using rclone's crypt remote as a base file system limits file name by 143 characters. Thus, maximum name length is 231 for most files and 119 for chunker-over-crypt. A user in need can change name format to e.g. *.rcc## and save 10 characters (provided at most 99 chunks per file). Note that a move implemented using the copy-and-delete method may incur double charging with some cloud storage providers. Chunker will not automatically rename existing chunks when you run rclone config on a live remote and change the chunk name format. Beware that in result of this some files which have been treated as chunks before the change can pop up in directory listings as normal files and vice versa. The same warning holds for the chunk size. If you desperately need to change critical chunking settings, you should run data migration as described above. If wrapped remote is case insensitive, the chunker overlay will inherit that property (so you can't have a file called "Hello.doc" and "hello.doc" in the same directory). Chunker included in rclone releases up to v1.54 can sometimes fail to detect metadata produced by recent versions of rclone. We recommend users to keep rclone up-to-date to avoid data corruption. Changing transactions is dangerous and requires explicit migration. Standard options Here are the Standard options specific to chunker (Transparently chunk/split large files). --chunker-remote Remote to chunk/unchunk. Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended). Properties: - Config: remote - Env Var: RCLONE_CHUNKER_REMOTE - Type: string - Required: true --chunker-chunk-size Files larger than chunk size will be split in chunks. Properties: - Config: chunk_size - Env Var: RCLONE_CHUNKER_CHUNK_SIZE - Type: SizeSuffix - Default: 2Gi --chunker-hash-type Choose how chunker handles hash sums. All modes but "none" require metadata. Properties: - Config: hash_type - Env Var: RCLONE_CHUNKER_HASH_TYPE - Type: string - Default: "md5" - Examples: - "none" - Pass any hash supported by wrapped remote for non-chunked files. - Return nothing otherwise. - "md5" - MD5 for composite files. - "sha1" - SHA1 for composite files. - "md5all" - MD5 for all files. - "sha1all" - SHA1 for all files. - "md5quick" - Copying a file to chunker will request MD5 from the source. - Falling back to SHA1 if unsupported. - "sha1quick" - Similar to "md5quick" but prefers SHA1 over MD5. Advanced options Here are the Advanced options specific to chunker (Transparently chunk/split large files). --chunker-name-format String format of chunk file names. The two placeholders are: base file name (*) and chunk number (#...). There must be one and only one asterisk and one or more consecutive hash characters. If chunk number has less digits than the number of hashes, it is left-padded by zeros. If there are more digits in the number, they are left as is. Possible chunk files are ignored if their name does not match given format. Properties: - Config: name_format - Env Var: RCLONE_CHUNKER_NAME_FORMAT - Type: string - Default: "*.rclone_chunk.###" --chunker-start-from Minimum valid chunk number. Usually 0 or 1. By default chunk numbers start from 1. Properties: - Config: start_from - Env Var: RCLONE_CHUNKER_START_FROM - Type: int - Default: 1 --chunker-meta-format Format of the metadata object or "none". By default "simplejson". Metadata is a small JSON file named after the composite file. Properties: - Config: meta_format - Env Var: RCLONE_CHUNKER_META_FORMAT - Type: string - Default: "simplejson" - Examples: - "none" - Do not use metadata files at all. - Requires hash type "none". - "simplejson" - Simple JSON supports hash sums and chunk validation. - - It has the following fields: ver, size, nchunks, md5, sha1. --chunker-fail-hard Choose how chunker should handle files with missing or invalid chunks. Properties: - Config: fail_hard - Env Var: RCLONE_CHUNKER_FAIL_HARD - Type: bool - Default: false - Examples: - "true" - Report errors and abort current command. - "false" - Warn user, skip incomplete file and proceed. --chunker-transactions Choose how chunker should handle temporary files during transactions. Properties: - Config: transactions - Env Var: RCLONE_CHUNKER_TRANSACTIONS - Type: string - Default: "rename" - Examples: - "rename" - Rename temporary files after a successful transaction. - "norename" - Leave temporary file names and write transaction ID to metadata file. - Metadata is required for no rename transactions (meta format cannot be "none"). - If you are using norename transactions you should be careful not to downgrade Rclone - as older versions of Rclone don't support this transaction style and will misinterpret - files manipulated by norename transactions. - This method is EXPERIMENTAL, don't use on production systems. - "auto" - Rename or norename will be used depending on capabilities of the backend. - If meta format is set to "none", rename transactions will always be used. - This method is EXPERIMENTAL, don't use on production systems. --chunker-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_CHUNKER_DESCRIPTION - Type: string - Required: false Cloudinary This is a backend for the Cloudinary platform About Cloudinary Cloudinary is an image and video API platform. Trusted by 1.5 million developers and 10,000 enterprise and hyper-growth companies as a critical part of their tech stack to deliver visually engaging experiences. Accounts & Pricing To use this backend, you need to create a free account on Cloudinary. Start with a free plan with generous usage limits. Then, as your requirements grow, upgrade to a plan that best fits your needs. See the pricing details. Securing Your Credentials Please refer to the docs Configuration Here is an example of making a Cloudinary configuration. First, create a cloudinary.com account and choose a plan. You will need to log in and get the API Key and API Secret for your account from the developer section. Now run rclone config Follow the interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter the name for the new remote. name> cloudinary-media-library Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / cloudinary.com \ (cloudinary) [snip] Storage> cloudinary Option cloud_name. You can find your cloudinary.com cloud_name in your [dashboard](https://console.cloudinary.com/pm/developer-dashboard) Enter a value. cloud_name> **************************** Option api_key. You can find your cloudinary.com api key in your [dashboard](https://console.cloudinary.com/pm/developer-dashboard) Enter a value. api_key> **************************** Option api_secret. You can find your cloudinary.com api secret in your [dashboard](https://console.cloudinary.com/pm/developer-dashboard) This value must be a single character, one of the following: y, g. y/g> y Enter a value. api_secret> **************************** Option upload_prefix. [Upload prefix](https://cloudinary.com/documentation/cloudinary_sdks#configuration_parameters) to specify alternative data center Enter a value. upload_prefix> Option upload_preset. [Upload presets](https://cloudinary.com/documentation/upload_presets) can be defined for different upload profiles Enter a value. upload_preset> Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: cloudinary - api_key: **************************** - api_secret: **************************** - cloud_name: **************************** - upload_prefix: - upload_preset: Keep this "cloudinary-media-library" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y List directories in the top level of your Media Library rclone lsd cloudinary-media-library: Make a new directory. rclone mkdir cloudinary-media-library:directory List the contents of a directory. rclone ls cloudinary-media-library:directory Modified time and hashes Cloudinary stores md5 and timestamps for any successful Put automatically and read-only. Standard options Here are the Standard options specific to cloudinary (Cloudinary). --cloudinary-cloud-name Cloudinary Environment Name Properties: - Config: cloud_name - Env Var: RCLONE_CLOUDINARY_CLOUD_NAME - Type: string - Required: true --cloudinary-api-key Cloudinary API Key Properties: - Config: api_key - Env Var: RCLONE_CLOUDINARY_API_KEY - Type: string - Required: true --cloudinary-api-secret Cloudinary API Secret Properties: - Config: api_secret - Env Var: RCLONE_CLOUDINARY_API_SECRET - Type: string - Required: true --cloudinary-upload-prefix Specify the API endpoint for environments out of the US Properties: - Config: upload_prefix - Env Var: RCLONE_CLOUDINARY_UPLOAD_PREFIX - Type: string - Required: false --cloudinary-upload-preset Upload Preset to select asset manipulation on upload Properties: - Config: upload_preset - Env Var: RCLONE_CLOUDINARY_UPLOAD_PRESET - Type: string - Required: false Advanced options Here are the Advanced options specific to cloudinary (Cloudinary). --cloudinary-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_CLOUDINARY_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Question,Asterisk,Pipe,Hash,Percent,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot --cloudinary-eventually-consistent-delay Wait N seconds for eventual consistency of the databases that support the backend operation Properties: - Config: eventually_consistent_delay - Env Var: RCLONE_CLOUDINARY_EVENTUALLY_CONSISTENT_DELAY - Type: Duration - Default: 0s --cloudinary-adjust-media-files-extensions Cloudinary handles media formats as a file attribute and strips it from the name, which is unlike most other file systems Properties: - Config: adjust_media_files_extensions - Env Var: RCLONE_CLOUDINARY_ADJUST_MEDIA_FILES_EXTENSIONS - Type: bool - Default: true --cloudinary-media-extensions Cloudinary supported media extensions Properties: - Config: media_extensions - Env Var: RCLONE_CLOUDINARY_MEDIA_EXTENSIONS - Type: stringArray - Default: [3ds 3g2 3gp ai arw avi avif bmp bw cr2 cr3 djvu dng eps3 fbx flif flv gif glb gltf hdp heic heif ico indd jp2 jpe jpeg jpg jxl jxr m2ts mov mp4 mpeg mts mxf obj ogv pdf ply png psd svg tga tif tiff ts u3ma usdz wdp webm webp wmv] --cloudinary-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_CLOUDINARY_DESCRIPTION - Type: string - Required: false Citrix ShareFile Citrix ShareFile is a secure file sharing and transfer service aimed as business. Configuration The initial setup for Citrix ShareFile involves getting a token from Citrix ShareFile which you can in your browser. rclone config walks you through it. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value XX / Citrix Sharefile \ "sharefile" Storage> sharefile ** See help for sharefile backend at: https://rclone.org/sharefile/ ** ID of the root folder Leave blank to access "Personal Folders". You can use one of the standard values here or any folder ID (long hex number ID). Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Access the Personal Folders. (Default) \ "" 2 / Access the Favorites folder. \ "favorites" 3 / Access all the shared folders. \ "allshared" 4 / Access all the individual connectors. \ "connectors" 5 / Access the home, favorites, and shared folders as well as the connectors. \ "top" root_folder_id> Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth?state=XXX Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: sharefile - endpoint: https://XXX.sharefile.com - token: {"access_token":"XXX","token_type":"bearer","refresh_token":"XXX","expiry":"2019-09-30T19:41:45.878561877+01:00"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y See the remote setup docs for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Citrix ShareFile. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall. Once configured you can then use rclone like this, List directories in top level of your ShareFile rclone lsd remote: List all the files in your ShareFile rclone ls remote: To copy a local directory to an ShareFile directory called backup rclone copy /home/source remote:backup Paths may be as deep as required, e.g. remote:directory/subdirectory. Modification times and hashes ShareFile allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not. ShareFile supports MD5 type hashes, so you can use the --checksum flag. Transfers For files above 128 MiB rclone will use a chunked transfer. Rclone will upload up to --transfers chunks at the same time (shared among all the multipart uploads). Chunks are buffered in memory and are normally 64 MiB so increasing --transfers will increase memory use. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- \ 0x5C ＼ * 0x2A ＊ < 0x3C ＜ > 0x3E ＞ ? 0x3F ？ : 0x3A ： | 0x7C ｜ " 0x22 ＂ File names can also not start or end with the following characters. These only get replaced if they are the first or last character in the name: Character Value Replacement ----------- ------- ------------- SP 0x20 ␠ . 0x2E ． Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Standard options Here are the Standard options specific to sharefile (Citrix Sharefile). --sharefile-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_SHAREFILE_CLIENT_ID - Type: string - Required: false --sharefile-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_SHAREFILE_CLIENT_SECRET - Type: string - Required: false --sharefile-root-folder-id ID of the root folder. Leave blank to access "Personal Folders". You can use one of the standard values here or any folder ID (long hex number ID). Properties: - Config: root_folder_id - Env Var: RCLONE_SHAREFILE_ROOT_FOLDER_ID - Type: string - Required: false - Examples: - "" - Access the Personal Folders (default). - "favorites" - Access the Favorites folder. - "allshared" - Access all the shared folders. - "connectors" - Access all the individual connectors. - "top" - Access the home, favorites, and shared folders as well as the connectors. Advanced options Here are the Advanced options specific to sharefile (Citrix Sharefile). --sharefile-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_SHAREFILE_TOKEN - Type: string - Required: false --sharefile-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_SHAREFILE_AUTH_URL - Type: string - Required: false --sharefile-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_SHAREFILE_TOKEN_URL - Type: string - Required: false --sharefile-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_SHAREFILE_CLIENT_CREDENTIALS - Type: bool - Default: false --sharefile-upload-cutoff Cutoff for switching to multipart upload. Properties: - Config: upload_cutoff - Env Var: RCLONE_SHAREFILE_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 128Mi --sharefile-chunk-size Upload chunk size. Must a power of 2 >= 256k. Making this larger will improve performance, but note that each chunk is buffered in memory one per transfer. Reducing this will reduce memory usage but decrease performance. Properties: - Config: chunk_size - Env Var: RCLONE_SHAREFILE_CHUNK_SIZE - Type: SizeSuffix - Default: 64Mi --sharefile-endpoint Endpoint for API calls. This is usually auto discovered as part of the oauth process, but can be set manually to something like: https://XXX.sharefile.com Properties: - Config: endpoint - Env Var: RCLONE_SHAREFILE_ENDPOINT - Type: string - Required: false --sharefile-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_SHAREFILE_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,LeftSpace,LeftPeriod,RightSpace,RightPeriod,InvalidUtf8,Dot --sharefile-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SHAREFILE_DESCRIPTION - Type: string - Required: false Limitations Note that ShareFile is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". ShareFile only supports filenames up to 256 characters in length. rclone about is not supported by the Citrix ShareFile backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about Crypt Rclone crypt remotes encrypt and decrypt other remotes. A remote of type crypt does not access a storage system directly, but instead wraps another remote, which in turn accesses the storage system. This is similar to how alias, union, chunker and a few others work. It makes the usage very flexible, as you can add a layer, in this case an encryption layer, on top of any other backend, even in multiple layers. Rclone's functionality can be used as with any other remote, for example you can mount a crypt remote. Accessing a storage system through a crypt remote realizes client-side encryption, which makes it safe to keep your data in a location you do not trust will not get compromised. When working against the crypt remote, rclone will automatically encrypt (before uploading) and decrypt (after downloading) on your local system as needed on the fly, leaving the data encrypted at rest in the wrapped remote. If you access the storage system using an application other than rclone, or access the wrapped remote directly using rclone, there will not be any encryption/decryption: Downloading existing content will just give you the encrypted (scrambled) format, and anything you upload will not become encrypted. The encryption is a secret-key encryption (also called symmetric key encryption) algorithm, where a password (or pass phrase) is used to generate real encryption key. The password can be supplied by user, or you may chose to let rclone generate one. It will be stored in the configuration file, in a lightly obscured form. If you are in an environment where you are not able to keep your configuration secured, you should add configuration encryption as protection. As long as you have this configuration file, you will be able to decrypt your data. Without the configuration file, as long as you remember the password (or keep it in a safe place), you can re-create the configuration and gain access to the existing data. You may also configure a corresponding remote in a different installation to access the same data. See below for guidance to changing password. Encryption uses cryptographic salt, to permute the encryption key so that the same string may be encrypted in different ways. When configuring the crypt remote it is optional to enter a salt, or to let rclone generate a unique salt. If omitted, rclone uses a built-in unique string. Normally in cryptography, the salt is stored together with the encrypted content, and do not have to be memorized by the user. This is not the case in rclone, because rclone does not store any additional information on the remotes. Use of custom salt is effectively a second password that must be memorized. File content encryption is performed using NaCl SecretBox, based on XSalsa20 cipher and Poly1305 for integrity. Names (file- and directory names) are also encrypted by default, but this has some implications and is therefore possible to be turned off. Configuration Here is an example of how to make a remote called secret. To use crypt, first set up the underlying remote. Follow the rclone config instructions for the specific backend. Before configuring the crypt remote, check the underlying remote is working. In this example the underlying remote is called remote. We will configure a path path within this remote to contain the encrypted content. Anything inside remote:path will be encrypted and anything outside will not. Configure crypt using rclone config. In this example the crypt remote is called secret, to differentiate it from the underlying remote. When you are done you can use the crypt remote named secret just as you would with any other remote, e.g. rclone copy D:\docs secret:\docs, and rclone will encrypt and decrypt as needed on the fly. If you access the wrapped remote remote:path directly you will bypass the encryption, and anything you read will be in encrypted form, and anything you write will be unencrypted. To avoid issues it is best to configure a dedicated path for encrypted content, and access it exclusively through a crypt remote. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> secret Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Encrypt/Decrypt a remote \ "crypt" [snip] Storage> crypt ** See help for crypt backend at: https://rclone.org/crypt/ ** Remote to encrypt/decrypt. Normally should contain a ':' and a path, eg "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended). Enter a string value. Press Enter for the default (""). remote> remote:path How to encrypt the filenames. Enter a string value. Press Enter for the default ("standard"). Choose a number from below, or type in your own value. / Encrypt the filenames. 1 | See the docs for the details. \ "standard" 2 / Very simple filename obfuscation. \ "obfuscate" / Don't encrypt the file names. 3 | Adds a ".bin" extension only. \ "off" filename_encryption> Option to either encrypt directory names or leave them intact. NB If filename_encryption is "off" then this option will do nothing. Enter a boolean value (true or false). Press Enter for the default ("true"). Choose a number from below, or type in your own value 1 / Encrypt directory names. \ "true" 2 / Don't encrypt directory names, leave them intact. \ "false" directory_name_encryption> Password or pass phrase for encryption. y) Yes type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Password or pass phrase for salt. Optional but recommended. Should be different to the previous password. y) Yes type in my own password g) Generate random password n) No leave this optional password blank (default) y/g/n> g Password strength in bits. 64 is just about memorable 128 is secure 1024 is the maximum Bits> 128 Your password is: JAsJvRcgR-_veXNfy_sGmQ Use this password? Please note that an obscured version of this password (and not the password itself) will be stored under your configuration file, so keep this generated password in a safe place. y) Yes (default) n) No y/n> Edit advanced config? (y/n) y) Yes n) No (default) y/n> Remote config -------------------- [secret] type = crypt remote = remote:path password = *** ENCRYPTED *** password2 = *** ENCRYPTED *** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> Important The crypt password stored in rclone.conf is lightly obscured. That only protects it from cursory inspection. It is not secure unless configuration encryption of rclone.conf is specified. A long passphrase is recommended, or rclone config can generate a random one. The obscured password is created using AES-CTR with a static key. The IV (nonce) is stored verbatim at the beginning of the obscured password. This static key is shared between all versions of rclone. If you reconfigure rclone with the same passwords/passphrases elsewhere it will be compatible, but the obscured version will be different due to the different salt. Rclone does not encrypt - file length - this can be calculated within 16 bytes - modification time - used for syncing Specifying the remote When configuring the remote to encrypt/decrypt, you may specify any string that rclone accepts as a source/destination of other commands. The primary use case is to specify the path into an already configured remote (e.g. remote:path/to/dir or remote:bucket), such that data in a remote untrusted location can be stored encrypted. You may also specify a local filesystem path, such as /path/to/dir on Linux, C:\path\to\dir on Windows. By creating a crypt remote pointing to such a local filesystem path, you can use rclone as a utility for pure local file encryption, for example to keep encrypted files on a removable USB drive. Note: A string which do not contain a : will by rclone be treated as a relative path in the local filesystem. For example, if you enter the name remote without the trailing :, it will be treated as a subdirectory of the current directory with name "remote". If a path remote:path/to/dir is specified, rclone stores encrypted files in path/to/dir on the remote. With file name encryption, files saved to secret:subdir/subfile are stored in the unencrypted path path/to/dir but the subdir/subpath element is encrypted. The path you specify does not have to exist, rclone will create it when needed. If you intend to use the wrapped remote both directly for keeping unencrypted content, as well as through a crypt remote for encrypted content, it is recommended to point the crypt remote to a separate directory within the wrapped remote. If you use a bucket-based storage system (e.g. Swift, S3, Google Compute Storage, B2) it is generally advisable to wrap the crypt remote around a specific bucket (s3:bucket). If wrapping around the entire root of the storage (s3:), and use the optional file name encryption, rclone will encrypt the bucket name. Changing password Should the password, or the configuration file containing a lightly obscured form of the password, be compromised, you need to re-encrypt your data with a new password. Since rclone uses secret-key encryption, where the encryption key is generated directly from the password kept on the client, it is not possible to change the password/key of already encrypted content. Just changing the password configured for an existing crypt remote means you will no longer able to decrypt any of the previously encrypted content. The only possibility is to re-upload everything via a crypt remote configured with your new password. Depending on the size of your data, your bandwidth, storage quota etc, there are different approaches you can take: - If you have everything in a different location, for example on your local system, you could remove all of the prior encrypted files, change the password for your configured crypt remote (or delete and re-create the crypt configuration), and then re-upload everything from the alternative location. - If you have enough space on the storage system you can create a new crypt remote pointing to a separate directory on the same backend, and then use rclone to copy everything from the original crypt remote to the new, effectively decrypting everything on the fly using the old password and re-encrypting using the new password. When done, delete the original crypt remote directory and finally the rclone crypt configuration with the old password. All data will be streamed from the storage system and back, so you will get half the bandwidth and be charged twice if you have upload and download quota on the storage system. Note: A security problem related to the random password generator was fixed in rclone version 1.53.3 (released 2020-11-19). Passwords generated by rclone config in version 1.49.0 (released 2019-08-26) to 1.53.2 (released 2020-10-26) are not considered secure and should be changed. If you made up your own password, or used rclone version older than 1.49.0 or newer than 1.53.2 to generate it, you are not affected by this issue. See issue #4783 for more details, and a tool you can use to check if you are affected. Example Create the following file structure using "standard" file name encryption. plaintext/ ├── file0.txt ├── file1.txt └── subdir ├── file2.txt ├── file3.txt └── subsubdir └── file4.txt Copy these to the remote, and list them $ rclone -q copy plaintext secret: $ rclone -q ls secret: 7 file1.txt 6 file0.txt 8 subdir/file2.txt 10 subdir/subsubdir/file4.txt 9 subdir/file3.txt The crypt remote looks like $ rclone -q ls remote:path 55 hagjclgavj2mbiqm6u6cnjjqcg 54 v05749mltvv1tf4onltun46gls 57 86vhrsv86mpbtd3a0akjuqslj8/dlj7fkq4kdq72emafg7a7s41uo 58 86vhrsv86mpbtd3a0akjuqslj8/7uu829995du6o42n32otfhjqp4/b9pausrfansjth5ob3jkdqd4lc 56 86vhrsv86mpbtd3a0akjuqslj8/8njh1sk437gttmep3p70g81aps The directory structure is preserved $ rclone -q ls secret:subdir 8 file2.txt 9 file3.txt 10 subsubdir/file4.txt Without file name encryption .bin extensions are added to underlying names. This prevents the cloud provider attempting to interpret file content. $ rclone -q ls remote:path 54 file0.txt.bin 57 subdir/file3.txt.bin 56 subdir/file2.txt.bin 58 subdir/subsubdir/file4.txt.bin 55 file1.txt.bin File name encryption modes Off - doesn't hide file names or directory structure - allows for longer file names (~246 characters) - can use sub paths and copy single files Standard - file names encrypted - file names can't be as long (~143 characters) - can use sub paths and copy single files - directory structure visible - identical files names will have identical uploaded names - can use shortcuts to shorten the directory recursion Obfuscation This is a simple "rotate" of the filename, with each file having a rot distance based on the filename. Rclone stores the distance at the beginning of the filename. A file called "hello" may become "53.jgnnq". Obfuscation is not a strong encryption of filenames, but hinders automated scanning tools picking up on filename patterns. It is an intermediate between "off" and "standard" which allows for longer path segment names. There is a possibility with some unicode based filenames that the obfuscation is weak and may map lower case characters to upper case equivalents. Obfuscation cannot be relied upon for strong protection. - file names very lightly obfuscated - file names can be longer than standard encryption - can use sub paths and copy single files - directory structure visible - identical files names will have identical uploaded names Cloud storage systems have limits on file name length and total path length which rclone is more likely to breach using "Standard" file name encryption. Where file names are 143 or fewer characters in length issues should not be encountered, irrespective of cloud storage provider. An experimental advanced option filename_encoding is now provided to address this problem to a certain degree. For cloud storage systems with case sensitive file names (e.g. Google Drive), base64 can be used to reduce file name length. For cloud storage systems using UTF-16 to store file names internally (e.g. OneDrive, Dropbox, Box), base32768 can be used to drastically reduce file name length. An alternative, future rclone file name encryption mode may tolerate backend provider path length limits. Directory name encryption Crypt offers the option of encrypting dir names or leaving them intact. There are two options: True Encrypts the whole file path including directory names Example: 1/12/123.txt is encrypted to p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng/qgm4avr35m5loi1th53ato71v0 False Only encrypts file names, skips directory names Example: 1/12/123.txt is encrypted to 1/12/qgm4avr35m5loi1th53ato71v0 Modification times and hashes Crypt stores modification times using the underlying remote so support depends on that. Hashes are not stored for crypt. However the data integrity is protected by an extremely strong crypto authenticator. Use the rclone cryptcheck command to check the integrity of an encrypted remote instead of rclone check which can't check the checksums properly. Standard options Here are the Standard options specific to crypt (Encrypt/Decrypt a remote). --crypt-remote Remote to encrypt/decrypt. Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended). Properties: - Config: remote - Env Var: RCLONE_CRYPT_REMOTE - Type: string - Required: true --crypt-filename-encryption How to encrypt the filenames. Properties: - Config: filename_encryption - Env Var: RCLONE_CRYPT_FILENAME_ENCRYPTION - Type: string - Default: "standard" - Examples: - "standard" - Encrypt the filenames. - See the docs for the details. - "obfuscate" - Very simple filename obfuscation. - "off" - Don't encrypt the file names. - Adds a ".bin", or "suffix" extension only. --crypt-directory-name-encryption Option to either encrypt directory names or leave them intact. NB If filename_encryption is "off" then this option will do nothing. Properties: - Config: directory_name_encryption - Env Var: RCLONE_CRYPT_DIRECTORY_NAME_ENCRYPTION - Type: bool - Default: true - Examples: - "true" - Encrypt directory names. - "false" - Don't encrypt directory names, leave them intact. --crypt-password Password or pass phrase for encryption. NB Input to this must be obscured - see rclone obscure. Properties: - Config: password - Env Var: RCLONE_CRYPT_PASSWORD - Type: string - Required: true --crypt-password2 Password or pass phrase for salt. Optional but recommended. Should be different to the previous password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: password2 - Env Var: RCLONE_CRYPT_PASSWORD2 - Type: string - Required: false Advanced options Here are the Advanced options specific to crypt (Encrypt/Decrypt a remote). --crypt-server-side-across-configs Deprecated: use --server-side-across-configs instead. Allow server-side operations (e.g. copy) to work across different crypt configs. Normally this option is not what you want, but if you have two crypts pointing to the same backend you can use it. This can be used, for example, to change file name encryption type without re-uploading all the data. Just make two crypt backends pointing to two different directories with the single changed parameter and use rclone move to move the files between the crypt remotes. Properties: - Config: server_side_across_configs - Env Var: RCLONE_CRYPT_SERVER_SIDE_ACROSS_CONFIGS - Type: bool - Default: false --crypt-show-mapping For all files listed show how the names encrypt. If this flag is set then for each file that the remote is asked to list, it will log (at level INFO) a line stating the decrypted file name and the encrypted file name. This is so you can work out which encrypted names are which decrypted names just in case you need to do something with the encrypted file names, or for debugging purposes. Properties: - Config: show_mapping - Env Var: RCLONE_CRYPT_SHOW_MAPPING - Type: bool - Default: false --crypt-no-data-encryption Option to either encrypt file data or leave it unencrypted. Properties: - Config: no_data_encryption - Env Var: RCLONE_CRYPT_NO_DATA_ENCRYPTION - Type: bool - Default: false - Examples: - "true" - Don't encrypt file data, leave it unencrypted. - "false" - Encrypt file data. --crypt-pass-bad-blocks If set this will pass bad blocks through as all 0. This should not be set in normal operation, it should only be set if trying to recover an encrypted file with errors and it is desired to recover as much of the file as possible. Properties: - Config: pass_bad_blocks - Env Var: RCLONE_CRYPT_PASS_BAD_BLOCKS - Type: bool - Default: false --crypt-strict-names If set, this will raise an error when crypt comes across a filename that can't be decrypted. (By default, rclone will just log a NOTICE and continue as normal.) This can happen if encrypted and unencrypted files are stored in the same directory (which is not recommended.) It may also indicate a more serious problem that should be investigated. Properties: - Config: strict_names - Env Var: RCLONE_CRYPT_STRICT_NAMES - Type: bool - Default: false --crypt-filename-encoding How to encode the encrypted filename to text string. This option could help with shortening the encrypted filename. The suitable option would depend on the way your remote count the filename length and if it's case sensitive. Properties: - Config: filename_encoding - Env Var: RCLONE_CRYPT_FILENAME_ENCODING - Type: string - Default: "base32" - Examples: - "base32" - Encode using base32. Suitable for all remote. - "base64" - Encode using base64. Suitable for case sensitive remote. - "base32768" - Encode using base32768. Suitable if your remote counts UTF-16 or - Unicode codepoint instead of UTF-8 byte length. (Eg. Onedrive, Dropbox) --crypt-suffix If this is set it will override the default suffix of ".bin". Setting suffix to "none" will result in an empty suffix. This may be useful when the path length is critical. Properties: - Config: suffix - Env Var: RCLONE_CRYPT_SUFFIX - Type: string - Default: ".bin" --crypt-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_CRYPT_DESCRIPTION - Type: string - Required: false Metadata Any metadata supported by the underlying remote is read and written. See the metadata docs for more info. Backend commands Here are the commands specific to the crypt backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the backend command for more info on how to pass options and arguments. These can be run on a running backend using the rc command backend/command. encode Encode the given filename(s) rclone backend encode remote: [options] [+] This encodes the filenames given as arguments returning a list of strings of the encoded results. Usage Example: rclone backend encode crypt: file1 [file2...] rclone rc backend/command command=encode fs=crypt: file1 [file2...] decode Decode the given filename(s) rclone backend decode remote: [options] [+] This decodes the filenames given as arguments returning a list of strings of the decoded results. It will return an error if any of the inputs are invalid. Usage Example: rclone backend decode crypt: encryptedfile1 [encryptedfile2...] rclone rc backend/command command=decode fs=crypt: encryptedfile1 [encryptedfile2...] Backing up an encrypted remote If you wish to backup an encrypted remote, it is recommended that you use rclone sync on the encrypted files, and make sure the passwords are the same in the new encrypted remote. This will have the following advantages - rclone sync will check the checksums while copying - you can use rclone check between the encrypted remotes - you don't decrypt and encrypt unnecessarily For example, let's say you have your original remote at remote: with the encrypted version at eremote: with path remote:crypt. You would then set up the new remote remote2: and then the encrypted version eremote2: with path remote2:crypt using the same passwords as eremote:. To sync the two remotes you would do rclone sync --interactive remote:crypt remote2:crypt And to check the integrity you would do rclone check remote:crypt remote2:crypt File formats File encryption Files are encrypted 1:1 source file to destination object. The file has a header and is divided into chunks. Header - 8 bytes magic string RCLONE\x00\x00 - 24 bytes Nonce (IV) The initial nonce is generated from the operating systems crypto strong random number generator. The nonce is incremented for each chunk read making sure each nonce is unique for each block written. The chance of a nonce being reused is minuscule. If you wrote an exabyte of data (10¹⁸ bytes) you would have a probability of approximately 2×10⁻³² of reusing a nonce. Chunk Each chunk will contain 64 KiB of data, except for the last one which may have less data. The data chunk is in standard NaCl SecretBox format. SecretBox uses XSalsa20 and Poly1305 to encrypt and authenticate messages. Each chunk contains: - 16 Bytes of Poly1305 authenticator - 1 - 65536 bytes XSalsa20 encrypted data 64k chunk size was chosen as the best performing chunk size (the authenticator takes too much time below this and the performance drops off due to cache effects above this). Note that these chunks are buffered in memory so they can't be too big. This uses a 32 byte (256 bit key) key derived from the user password. Examples 1 byte file will encrypt to - 32 bytes header - 17 bytes data chunk 49 bytes total 1 MiB (1048576 bytes) file will encrypt to - 32 bytes header - 16 chunks of 65568 bytes 1049120 bytes total (a 0.05% overhead). This is the overhead for big files. Name encryption File names are encrypted segment by segment - the path is broken up into / separated strings and these are encrypted individually. File segments are padded using PKCS#7 to a multiple of 16 bytes before encryption. They are then encrypted with EME using AES with 256 bit key. EME (ECB-Mix-ECB) is a wide-block encryption mode presented in the 2003 paper "A Parallelizable Enciphering Mode" by Halevi and Rogaway. This makes for deterministic encryption which is what we want - the same filename must encrypt to the same thing otherwise we can't find it on the cloud storage system. This means that - filenames with the same name will encrypt the same - filenames which start the same won't have a common prefix This uses a 32 byte key (256 bits) and a 16 byte (128 bits) IV both of which are derived from the user password. After encryption they are written out using a modified version of standard base32 encoding as described in RFC4648. The standard encoding is modified in two ways: - it becomes lower case (no-one likes upper case filenames!) - we strip the padding character = base32 is used rather than the more efficient base64 so rclone can be used on case insensitive remotes (e.g. Windows, Box, Dropbox, Onedrive etc). Key derivation Rclone uses scrypt with parameters N=16384, r=8, p=1 with an optional user supplied salt (password2) to derive the 32+32+16 = 80 bytes of key material required. If the user doesn't supply a salt then rclone uses an internal one. scrypt makes it impractical to mount a dictionary attack on rclone encrypted data. For full protection against this you should always use a salt. SEE ALSO - rclone cryptdecode - Show forward/reverse mapping of encrypted filenames Compress Warning This remote is currently experimental. Things may break and data may be lost. Anything you do with this remote is at your own risk. Please understand the risks associated with using experimental code and don't use this remote in critical applications. The Compress remote adds compression to another remote. It is best used with remotes containing many large compressible files. Configuration To use this remote, all you need to do is specify another remote and a compression mode to use: Current remotes: Name Type ==== ==== remote_to_press sometype e) Edit existing remote $ rclone config n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> n name> compress ... 8 / Compress a remote \ "compress" ... Storage> compress ** See help for compress backend at: https://rclone.org/compress/ ** Remote to compress. Enter a string value. Press Enter for the default (""). remote> remote_to_press:subdir Compression mode. Enter a string value. Press Enter for the default ("gzip"). Choose a number from below, or type in your own value 1 / Gzip compression balanced for speed and compression strength. \ "gzip" compression_mode> gzip Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config -------------------- [compress] type = compress remote = remote_to_press:subdir compression_mode = gzip -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Compression Modes Currently only gzip compression is supported. It provides a decent balance between speed and size and is well supported by other applications. Compression strength can further be configured via an advanced setting where 0 is no compression and 9 is strongest compression. File types If you open a remote wrapped by compress, you will see that there are many files with an extension corresponding to the compression algorithm you chose. These files are standard files that can be opened by various archive programs, but they have some hidden metadata that allows them to be used by rclone. While you may download and decompress these files at will, do not manually delete or rename files. Files without correct metadata files will not be recognized by rclone. File names The compressed files will be named *.###########.gz where * is the base file and the # part is base64 encoded size of the uncompressed file. The file names should not be changed by anything other than the rclone compression backend. Standard options Here are the Standard options specific to compress (Compress a remote). --compress-remote Remote to compress. Properties: - Config: remote - Env Var: RCLONE_COMPRESS_REMOTE - Type: string - Required: true --compress-mode Compression mode. Properties: - Config: mode - Env Var: RCLONE_COMPRESS_MODE - Type: string - Default: "gzip" - Examples: - "gzip" - Standard gzip compression with fastest parameters. Advanced options Here are the Advanced options specific to compress (Compress a remote). --compress-level GZIP compression level (-2 to 9). Generally -1 (default, equivalent to 5) is recommended. Levels 1 to 9 increase compression at the cost of speed. Going past 6 generally offers very little return. Level -2 uses Huffman encoding only. Only use if you know what you are doing. Level 0 turns off compression. Properties: - Config: level - Env Var: RCLONE_COMPRESS_LEVEL - Type: int - Default: -1 --compress-ram-cache-limit Some remotes don't allow the upload of files with unknown size. In this case the compressed file will need to be cached to determine it's size. Files smaller than this limit will be cached in RAM, files larger than this limit will be cached on disk. Properties: - Config: ram_cache_limit - Env Var: RCLONE_COMPRESS_RAM_CACHE_LIMIT - Type: SizeSuffix - Default: 20Mi --compress-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_COMPRESS_DESCRIPTION - Type: string - Required: false Metadata Any metadata supported by the underlying remote is read and written. See the metadata docs for more info. Combine The combine backend joins remotes together into a single directory tree. For example you might have a remote for images on one provider: $ rclone tree s3:imagesbucket / ├── image1.jpg └── image2.jpg And a remote for files on another: $ rclone tree drive:important/files / ├── file1.txt └── file2.txt The combine backend can join these together into a synthetic directory structure like this: $ rclone tree combined: / ├── files │ ├── file1.txt │ └── file2.txt └── images ├── image1.jpg └── image2.jpg You'd do this by specifying an upstreams parameter in the config like this upstreams = images=s3:imagesbucket files=drive:important/files During the initial setup with rclone config you will specify the upstreams remotes as a space separated list. The upstream remotes can either be a local paths or other remotes. Configuration Here is an example of how to make a combine called remote for the example above. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. ... XX / Combine several remotes into one \ (combine) ... Storage> combine Option upstreams. Upstreams for combining These should be in the form dir=remote:path dir2=remote2:path Where before the = is specified the root directory and after is the remote to put there. Embedded spaces can be added using quotes "dir=remote:path with space" "dir2=remote2:path with space" Enter a fs.SpaceSepList value. upstreams> images=s3:imagesbucket files=drive:important/files Configuration complete. Options: - type: combine - upstreams: images=s3:imagesbucket files=drive:important/files Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Configuring for Google Drive Shared Drives Rclone has a convenience feature for making a combine backend for all the shared drives you have access to. Assuming your main (non shared drive) Google drive remote is called drive: you would run rclone backend -o config drives drive: This would produce something like this: [My Drive] type = alias remote = drive,team_drive=0ABCDEF-01234567890,root_folder_id=: [Test Drive] type = alias remote = drive,team_drive=0ABCDEFabcdefghijkl,root_folder_id=: [AllDrives] type = combine upstreams = "My Drive=My Drive:" "Test Drive=Test Drive:" If you then add that config to your config file (find it with rclone config file) then you can access all the shared drives in one place with the AllDrives: remote. See the Google Drive docs for full info. Standard options Here are the Standard options specific to combine (Combine several remotes into one). --combine-upstreams Upstreams for combining These should be in the form dir=remote:path dir2=remote2:path Where before the = is specified the root directory and after is the remote to put there. Embedded spaces can be added using quotes "dir=remote:path with space" "dir2=remote2:path with space" Properties: - Config: upstreams - Env Var: RCLONE_COMBINE_UPSTREAMS - Type: SpaceSepList - Default: Advanced options Here are the Advanced options specific to combine (Combine several remotes into one). --combine-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_COMBINE_DESCRIPTION - Type: string - Required: false Metadata Any metadata supported by the underlying remote is read and written. See the metadata docs for more info. DOI The DOI remote is a read only remote for reading files from digital object identifiers (DOI). Currently, the DOI backend supports DOIs hosted with: - InvenioRDM - Zenodo - CaltechDATA - Other InvenioRDM repositories - Dataverse - Harvard Dataverse - Other Dataverse repositories Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. Configuration Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / DOI datasets \ (doi) [snip] Storage> doi Option doi. The DOI or the doi.org URL. Enter a value. doi> 10.5281/zenodo.5876941 Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: doi - doi: 10.5281/zenodo.5876941 Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Standard options Here are the Standard options specific to doi (DOI datasets). --doi-doi The DOI or the doi.org URL. Properties: - Config: doi - Env Var: RCLONE_DOI_DOI - Type: string - Required: true Advanced options Here are the Advanced options specific to doi (DOI datasets). --doi-provider DOI provider. The DOI provider can be set when rclone does not automatically recognize a supported DOI provider. Properties: - Config: provider - Env Var: RCLONE_DOI_PROVIDER - Type: string - Required: false - Examples: - "auto" - Auto-detect provider - "zenodo" - Zenodo - "dataverse" - Dataverse - "invenio" - Invenio --doi-doi-resolver-api-url The URL of the DOI resolver API to use. The DOI resolver can be set for testing or for cases when the the canonical DOI resolver API cannot be used. Defaults to "https://doi.org/api". Properties: - Config: doi_resolver_api_url - Env Var: RCLONE_DOI_DOI_RESOLVER_API_URL - Type: string - Required: false --doi-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_DOI_DESCRIPTION - Type: string - Required: false Backend commands Here are the commands specific to the doi backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the backend command for more info on how to pass options and arguments. These can be run on a running backend using the rc command backend/command. metadata Show metadata about the DOI. rclone backend metadata remote: [options] [+] This command returns a JSON object with some information about the DOI. rclone backend medatadata doi: It returns a JSON object representing metadata about the DOI. set Set command for updating the config parameters. rclone backend set remote: [options] [+] This set command can be used to update the config parameters for a running doi backend. Usage Examples: rclone backend set doi: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=doi: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=doi: -o doi=NEW_DOI The option keys are named as they are in the config file. This rebuilds the connection to the doi backend when it is called with the new parameters. Only new parameters need be passed as the values will default to those currently in use. It doesn't return anything. Dropbox Paths are specified as remote:path Dropbox paths may be as deep as required, e.g. remote:directory/subdirectory. Configuration The initial setup for dropbox involves getting a token from Dropbox which you need to do in your browser. rclone config walks you through it. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: n) New remote d) Delete remote q) Quit config e/n/d/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Dropbox \ "dropbox" [snip] Storage> dropbox Dropbox App Key - leave blank normally. app_key> Dropbox App Secret - leave blank normally. app_secret> Remote config Please visit: https://www.dropbox.com/1/oauth2/authorize?client_id=XXXXXXXXXXXXXXX&response_type=code Enter the code: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX_XXXXXXXXXX Configuration complete. Options: - type: dropbox - app_key: - app_secret: - token: XXXXXXXXXXXXXXXXXXXXXXXXXXXXX_XXXX_XXXXXXXXXXXXXXXXXXXXXXXXXXXXX Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y See the remote setup docs for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Dropbox. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and it may require you to unblock it temporarily if you are running a host firewall, or use manual mode. You can then use it like this, List directories in top level of your dropbox rclone lsd remote: List all the files in your dropbox rclone ls remote: To copy a local directory to a dropbox directory called backup rclone copy /home/source remote:backup Dropbox for business Rclone supports Dropbox for business and Team Folders. When using Dropbox for business remote: and remote:path/to/file will refer to your personal folder. If you wish to see Team Folders you must use a leading / in the path, so rclone lsd remote:/ will refer to the root and show you all Team Folders and your User Folder. You can then use team folders like this remote:/TeamFolder and remote:/TeamFolder/path/to/file. A leading / for a Dropbox personal account will do nothing, but it will take an extra HTTP transaction so it should be avoided. Modification times and hashes Dropbox supports modified times, but the only way to set a modification time is to re-upload the file. This means that if you uploaded your data with an older version of rclone which didn't support the v2 API and modified times, rclone will decide to upload all your old data to fix the modification times. If you don't want this to happen use --size-only or --checksum flag to stop it. Dropbox supports its own hash type which is checked for all transfers. Restricted filename characters Character Value Replacement ----------- ------- ------------- NUL 0x00 ␀ / 0x2F ／ DEL 0x7F ␡ \ 0x5C ＼ File names can also not end with the following characters. These only get replaced if they are the last character in the name: Character Value Replacement ----------- ------- ------------- SP 0x20 ␠ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Batch mode uploads Using batch mode uploads is very important for performance when using the Dropbox API. See the dropbox performance guide for more info. There are 3 modes rclone can use for uploads. --dropbox-batch-mode off In this mode rclone will not use upload batching. This was the default before rclone v1.55. It has the disadvantage that it is very likely to encounter too_many_requests errors like this NOTICE: too_many_requests/.: Too many requests or write operations. Trying again in 15 seconds. When rclone receives these it has to wait for 15s or sometimes 300s before continuing which really slows down transfers. This will happen especially if --transfers is large, so this mode isn't recommended except for compatibility or investigating problems. --dropbox-batch-mode sync In this mode rclone will batch up uploads to the size specified by --dropbox-batch-size and commit them together. Using this mode means you can use a much higher --transfers parameter (32 or 64 works fine) without receiving too_many_requests errors. This mode ensures full data integrity. Note that there may be a pause when quitting rclone while rclone finishes up the last batch using this mode. --dropbox-batch-mode async In this mode rclone will batch up uploads to the size specified by --dropbox-batch-size and commit them together. However it will not wait for the status of the batch to be returned to the caller. This means rclone can use a much bigger batch size (much bigger than --transfers), at the cost of not being able to check the status of the upload. This provides the maximum possible upload speed especially with lots of small files, however rclone can't check the file got uploaded properly using this mode. If you are using this mode then using "rclone check" after the transfer completes is recommended. Or you could do an initial transfer with --dropbox-batch-mode async then do a final transfer with --dropbox-batch-mode sync (the default). Note that there may be a pause when quitting rclone while rclone finishes up the last batch using this mode. Exporting files Certain files in Dropbox are "exportable", such as Dropbox Paper documents. These files need to be converted to another format in order to be downloaded. Often multiple formats are available for conversion. When rclone downloads a exportable file, it chooses the format to download based on the --dropbox-export-formats setting. By default, the export formats are html,md, which are sensible defaults for Dropbox Paper. Rclone chooses the first format ID in the export formats list that Dropbox supports for a given file. If no format in the list is usable, rclone will choose the default format that Dropbox suggests. Rclone will change the extension to correspond to the export format. Here are some examples of how extensions are mapped: File type Filename in Dropbox Filename in rclone ---------------- --------------------- -------------------- Paper mydoc.paper mydoc.html Paper template mydoc.papert mydoc.papert.html other mydoc mydoc.html Importing exportable files is not yet supported by rclone. Here are the supported export extensions known by rclone. Note that rclone does not currently support other formats not on this list, even if Dropbox supports them. Also, Dropbox could change the list of supported formats at any time. Format ID Name Description ----------- ---------- ---------------------- html HTML HTML document md Markdown Markdown text format Standard options Here are the Standard options specific to dropbox (Dropbox). --dropbox-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_DROPBOX_CLIENT_ID - Type: string - Required: false --dropbox-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_DROPBOX_CLIENT_SECRET - Type: string - Required: false Advanced options Here are the Advanced options specific to dropbox (Dropbox). --dropbox-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_DROPBOX_TOKEN - Type: string - Required: false --dropbox-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_DROPBOX_AUTH_URL - Type: string - Required: false --dropbox-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_DROPBOX_TOKEN_URL - Type: string - Required: false --dropbox-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_DROPBOX_CLIENT_CREDENTIALS - Type: bool - Default: false --dropbox-chunk-size Upload chunk size (< 150Mi). Any files larger than this will be uploaded in chunks of this size. Note that chunks are buffered in memory (one at a time) so rclone can deal with retries. Setting this larger will increase the speed slightly (at most 10% for 128 MiB in tests) at the cost of using more memory. It can be set smaller if you are tight on memory. Properties: - Config: chunk_size - Env Var: RCLONE_DROPBOX_CHUNK_SIZE - Type: SizeSuffix - Default: 48Mi --dropbox-impersonate Impersonate this user when using a business account. Note that if you want to use impersonate, you should make sure this flag is set when running "rclone config" as this will cause rclone to request the "members.read" scope which it won't normally. This is needed to lookup a members email address into the internal ID that dropbox uses in the API. Using the "members.read" scope will require a Dropbox Team Admin to approve during the OAuth flow. You will have to use your own App (setting your own client_id and client_secret) to use this option as currently rclone's default set of permissions doesn't include "members.read". This can be added once v1.55 or later is in use everywhere. Properties: - Config: impersonate - Env Var: RCLONE_DROPBOX_IMPERSONATE - Type: string - Required: false --dropbox-shared-files Instructs rclone to work on individual shared files. In this mode rclone's features are extremely limited - only list (ls, lsl, etc.) operations and read operations (e.g. downloading) are supported in this mode. All other operations will be disabled. Properties: - Config: shared_files - Env Var: RCLONE_DROPBOX_SHARED_FILES - Type: bool - Default: false --dropbox-shared-folders Instructs rclone to work on shared folders. When this flag is used with no path only the List operation is supported and all available shared folders will be listed. If you specify a path the first part will be interpreted as the name of shared folder. Rclone will then try to mount this shared to the root namespace. On success shared folder rclone proceeds normally. The shared folder is now pretty much a normal folder and all normal operations are supported. Note that we don't unmount the shared folder afterwards so the --dropbox-shared-folders can be omitted after the first use of a particular shared folder. See also --dropbox-root-namespace for an alternative way to work with shared folders. Properties: - Config: shared_folders - Env Var: RCLONE_DROPBOX_SHARED_FOLDERS - Type: bool - Default: false --dropbox-pacer-min-sleep Minimum time to sleep between API calls. Properties: - Config: pacer_min_sleep - Env Var: RCLONE_DROPBOX_PACER_MIN_SLEEP - Type: Duration - Default: 10ms --dropbox-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_DROPBOX_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,RightSpace,InvalidUtf8,Dot --dropbox-root-namespace Specify a different Dropbox namespace ID to use as the root for all paths. Properties: - Config: root_namespace - Env Var: RCLONE_DROPBOX_ROOT_NAMESPACE - Type: string - Required: false --dropbox-export-formats Comma separated list of preferred formats for exporting files Certain Dropbox files can only be accessed by exporting them to another format. These include Dropbox Paper documents. For each such file, rclone will choose the first format on this list that Dropbox considers valid. If none is valid, it will choose Dropbox's default format. Known formats include: "html", "md" (markdown) Properties: - Config: export_formats - Env Var: RCLONE_DROPBOX_EXPORT_FORMATS - Type: CommaSepList - Default: html,md --dropbox-skip-exports Skip exportable files in all listings. If given, exportable files practically become invisible to rclone. Properties: - Config: skip_exports - Env Var: RCLONE_DROPBOX_SKIP_EXPORTS - Type: bool - Default: false --dropbox-show-all-exports Show all exportable files in listings. Adding this flag will allow all exportable files to be server side copied. Note that rclone doesn't add extensions to the exportable file names in this mode. Do not use this flag when trying to download exportable files - rclone will fail to download them. Properties: - Config: show_all_exports - Env Var: RCLONE_DROPBOX_SHOW_ALL_EXPORTS - Type: bool - Default: false --dropbox-batch-mode Upload file batching sync|async|off. This sets the batch mode used by rclone. For full info see the main docs This has 3 possible values - off - no batching - sync - batch uploads and check completion (default) - async - batch upload and don't check completion Rclone will close any outstanding batches when it exits which may make a delay on quit. Properties: - Config: batch_mode - Env Var: RCLONE_DROPBOX_BATCH_MODE - Type: string - Default: "sync" --dropbox-batch-size Max number of files in upload batch. This sets the batch size of files to upload. It has to be less than 1000. By default this is 0 which means rclone will calculate the batch size depending on the setting of batch_mode. - batch_mode: async - default batch_size is 100 - batch_mode: sync - default batch_size is the same as --transfers - batch_mode: off - not in use Rclone will close any outstanding batches when it exits which may make a delay on quit. Setting this is a great idea if you are uploading lots of small files as it will make them a lot quicker. You can use --transfers 32 to maximise throughput. Properties: - Config: batch_size - Env Var: RCLONE_DROPBOX_BATCH_SIZE - Type: int - Default: 0 --dropbox-batch-timeout Max time to allow an idle upload batch before uploading. If an upload batch is idle for more than this long then it will be uploaded. The default for this is 0 which means rclone will choose a sensible default based on the batch_mode in use. - batch_mode: async - default batch_timeout is 10s - batch_mode: sync - default batch_timeout is 500ms - batch_mode: off - not in use Properties: - Config: batch_timeout - Env Var: RCLONE_DROPBOX_BATCH_TIMEOUT - Type: Duration - Default: 0s --dropbox-batch-commit-timeout Max time to wait for a batch to finish committing. (no longer used) Properties: - Config: batch_commit_timeout - Env Var: RCLONE_DROPBOX_BATCH_COMMIT_TIMEOUT - Type: Duration - Default: 10m0s --dropbox-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_DROPBOX_DESCRIPTION - Type: string - Required: false Limitations Note that Dropbox is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". There are some file names such as thumbs.db which Dropbox can't store. There is a full list of them in the "Ignored Files" section of this document. Rclone will issue an error message File name disallowed - not uploading if it attempts to upload one of those file names, but the sync won't fail. Some errors may occur if you try to sync copyright-protected files because Dropbox has its own copyright detector that prevents this sort of file being downloaded. This will return the error ERROR : /path/to/your/file: Failed to copy: failed to open source object: path/restricted_content/. If you have more than 10,000 files in a directory then rclone purge dropbox:dir will return the error Failed to purge: There are too many files involved in this operation. As a work-around do an rclone delete dropbox:dir followed by an rclone rmdir dropbox:dir. When using rclone link you'll need to set --expire if using a non-personal account otherwise the visibility may not be correct. (Note that --expire isn't supported on personal accounts). See the forum discussion and the dropbox SDK issue. Modification times for Dropbox Paper documents are not exact, and may not change for some period after the document is edited. To make sure you get recent changes in a sync, either wait an hour or so, or use --ignore-times to force a full sync. Get your own Dropbox App ID When you use rclone with Dropbox in its default configuration you are using rclone's App ID. This is shared between all the rclone users. Here is how to create your own Dropbox App ID for rclone: 1. Log into the Dropbox App console with your Dropbox Account (It need not to be the same account as the Dropbox you want to access) 2. Choose an API => Usually this should be Dropbox API 3. Choose the type of access you want to use => Full Dropbox or App Folder. If you want to use Team Folders, Full Dropbox is required (see here). 4. Name your App. The app name is global, so you can't use rclone for example 5. Click the button Create App 6. Switch to the Permissions tab. Enable at least the following permissions: account_info.read, files.metadata.write, files.content.write, files.content.read, sharing.write. The files.metadata.read and sharing.read checkboxes will be marked too. Click Submit 7. Switch to the Settings tab. Fill OAuth2 - Redirect URIs as http://localhost:53682/ and click on Add 8. Find the App key and App secret values on the Settings tab. Use these values in rclone config to add a new remote or edit an existing remote. The App key setting corresponds to client_id in rclone config, the App secret corresponds to client_secret Enterprise File Fabric This backend supports Storage Made Easy's Enterprise File Fabric™ which provides a software solution to integrate and unify File and Object Storage accessible through a global file system. Configuration The initial setup for the Enterprise File Fabric backend involves getting a token from the Enterprise File Fabric which you need to do in your browser. rclone config walks you through it. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Enterprise File Fabric \ "filefabric" [snip] Storage> filefabric ** See help for filefabric backend at: https://rclone.org/filefabric/ ** URL of the Enterprise File Fabric to connect to Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Storage Made Easy US \ "https://storagemadeeasy.com" 2 / Storage Made Easy EU \ "https://eu.storagemadeeasy.com" 3 / Connect to your Enterprise File Fabric \ "https://yourfabric.smestorage.com" url> https://yourfabric.smestorage.com/ ID of the root folder Leave blank normally. Fill in to make rclone start with directory of a given ID. Enter a string value. Press Enter for the default (""). root_folder_id> Permanent Authentication Token A Permanent Authentication Token can be created in the Enterprise File Fabric, on the users Dashboard under Security, there is an entry you'll see called "My Authentication Tokens". Click the Manage button to create one. These tokens are normally valid for several years. For more info see: https://docs.storagemadeeasy.com/organisationcloud/api-tokens Enter a string value. Press Enter for the default (""). permanent_token> xxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config Configuration complete. Options: - type: filefabric - url: https://yourfabric.smestorage.com/ - permanent_token: xxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Once configured you can then use rclone like this, List directories in top level of your Enterprise File Fabric rclone lsd remote: List all the files in your Enterprise File Fabric rclone ls remote: To copy a local directory to an Enterprise File Fabric directory called backup rclone copy /home/source remote:backup Modification times and hashes The Enterprise File Fabric allows modification times to be set on files accurate to 1 second. These will be used to detect whether objects need syncing or not. The Enterprise File Fabric does not support any data hashes at this time. Restricted filename characters The default restricted characters set will be replaced. Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Empty files Empty files aren't supported by the Enterprise File Fabric. Rclone will therefore upload an empty file as a single space with a mime type of application/vnd.rclone.empty.file and files with that mime type are treated as empty. Root folder ID You can set the root_folder_id for rclone. This is the directory (identified by its Folder ID) that rclone considers to be the root of your Enterprise File Fabric. Normally you will leave this blank and rclone will determine the correct root to use itself. However you can set this to restrict rclone to a specific folder hierarchy. In order to do this you will have to find the Folder ID of the directory you wish rclone to display. These aren't displayed in the web interface, but you can use rclone lsf to find them, for example $ rclone lsf --dirs-only -Fip --csv filefabric: 120673758,Burnt PDFs/ 120673759,My Quick Uploads/ 120673755,My Syncs/ 120673756,My backups/ 120673757,My contacts/ 120673761,S3 Storage/ The ID for "S3 Storage" would be 120673761. Standard options Here are the Standard options specific to filefabric (Enterprise File Fabric). --filefabric-url URL of the Enterprise File Fabric to connect to. Properties: - Config: url - Env Var: RCLONE_FILEFABRIC_URL - Type: string - Required: true - Examples: - "https://storagemadeeasy.com" - Storage Made Easy US - "https://eu.storagemadeeasy.com" - Storage Made Easy EU - "https://yourfabric.smestorage.com" - Connect to your Enterprise File Fabric --filefabric-root-folder-id ID of the root folder. Leave blank normally. Fill in to make rclone start with directory of a given ID. Properties: - Config: root_folder_id - Env Var: RCLONE_FILEFABRIC_ROOT_FOLDER_ID - Type: string - Required: false --filefabric-permanent-token Permanent Authentication Token. A Permanent Authentication Token can be created in the Enterprise File Fabric, on the users Dashboard under Security, there is an entry you'll see called "My Authentication Tokens". Click the Manage button to create one. These tokens are normally valid for several years. For more info see: https://docs.storagemadeeasy.com/organisationcloud/api-tokens Properties: - Config: permanent_token - Env Var: RCLONE_FILEFABRIC_PERMANENT_TOKEN - Type: string - Required: false Advanced options Here are the Advanced options specific to filefabric (Enterprise File Fabric). --filefabric-token Session Token. This is a session token which rclone caches in the config file. It is usually valid for 1 hour. Don't set this value - rclone will set it automatically. Properties: - Config: token - Env Var: RCLONE_FILEFABRIC_TOKEN - Type: string - Required: false --filefabric-token-expiry Token expiry time. Don't set this value - rclone will set it automatically. Properties: - Config: token_expiry - Env Var: RCLONE_FILEFABRIC_TOKEN_EXPIRY - Type: string - Required: false --filefabric-version Version read from the file fabric. Don't set this value - rclone will set it automatically. Properties: - Config: version - Env Var: RCLONE_FILEFABRIC_VERSION - Type: string - Required: false --filefabric-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_FILEFABRIC_ENCODING - Type: Encoding - Default: Slash,Del,Ctl,InvalidUtf8,Dot --filefabric-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_FILEFABRIC_DESCRIPTION - Type: string - Required: false FileLu FileLu is a reliable cloud storage provider offering features like secure file uploads, downloads, flexible storage options, and sharing capabilities. With support for high storage limits and seamless integration with rclone, FileLu makes managing files in the cloud easy. Its cross-platform file backup services let you upload and back up files from any internet-connected device. Configuration Here is an example of how to make a remote called filelu. First, run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> filelu Type of storage to configure. Choose a number from below, or type in your own value [snip] xx / FileLu Cloud Storage \ "filelu" [snip] Storage> filelu Enter your FileLu Rclone Key: key> YOUR_FILELU_RCLONE_KEY RC_xxxxxxxxxxxxxxxxxxxxxxxx Configuration complete. Keep this "filelu" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Paths A path without an initial / will operate in the Rclone directory. A path with an initial / will operate at the root where you can see the Rclone directory. $ rclone lsf TestFileLu:/ CCTV/ Camera/ Documents/ Music/ Photos/ Rclone/ Vault/ Videos/ Example Commands Create a new folder named foldername in the Rclone directory: rclone mkdir filelu:foldername Delete a folder on FileLu: rclone rmdir filelu:/folder/path/ Delete a file on FileLu: rclone delete filelu:/hello.txt List files from your FileLu account: rclone ls filelu: List all folders: rclone lsd filelu: Copy a specific file to the FileLu root: rclone copy D:\\hello.txt filelu: Copy files from a local directory to a FileLu directory: rclone copy D:/local-folder filelu:/remote-folder/path/ Download a file from FileLu into a local directory: rclone copy filelu:/file-path/hello.txt D:/local-folder Move files from a local directory to a FileLu directory: rclone move D:\\local-folder filelu:/remote-path/ Sync files from a local directory to a FileLu directory: rclone sync --interactive D:/local-folder filelu:/remote-path/ Mount remote to local Linux: rclone mount filelu: /root/mnt --vfs-cache-mode full Mount remote to local Windows: rclone mount filelu: D:/local_mnt --vfs-cache-mode full Get storage info about the FileLu account: rclone about filelu: All the other rclone commands are supported by this backend. FolderID instead of folder path We use the FolderID instead of the folder name to prevent errors when users have identical folder names or paths. For example, if a user has two or three folders named "test_folders," the system may become confused and won't know which folder to move. In large storage systems, some clients have hundred of thousands of folders and a few millions of files, duplicate folder names or paths are quite common. Modification Times and Hashes FileLu supports both modification times and MD5 hashes. FileLu only supports filenames and folder names up to 255 characters in length, where a character is a Unicode character. Duplicated Files When uploading and syncing via Rclone, FileLu does not allow uploading duplicate files within the same directory. However, you can upload duplicate files, provided they are in different directories (folders). Failure to Log / Invalid Credentials or KEY Ensure that you have the correct Rclone key, which can be found in My Account. Every time you toggle Rclone OFF and ON in My Account, a new RC_xxxxxxxxxxxxxxxxxxxx key is generated. Be sure to update your Rclone configuration with the new key. If you are connecting to your FileLu remote for the first time and encounter an error such as: Failed to create file system for "my-filelu-remote:": couldn't login: Invalid credentials Ensure your Rclone Key is correct. Process killed Accounts with large files or extensive metadata may experience significant memory usage during list/sync operations. Ensure the system running rclone has sufficient memory and CPU to handle these operations. Standard options Here are the Standard options specific to filelu (FileLu Cloud Storage). --filelu-key Your FileLu Rclone key from My Account Properties: - Config: key - Env Var: RCLONE_FILELU_KEY - Type: string - Required: true Advanced options Here are the Advanced options specific to filelu (FileLu Cloud Storage). --filelu-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_FILELU_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,SingleQuote,BackQuote,Dollar,Colon,Question,Asterisk,Pipe,Hash,Percent,BackSlash,CrLf,Del,Ctl,LeftSpace,LeftPeriod,LeftTilde,LeftCrLfHtVt,RightSpace,RightPeriod,RightCrLfHtVt,InvalidUtf8,Dot,SquareBracket,Semicolon,Exclamation --filelu-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_FILELU_DESCRIPTION - Type: string - Required: false Limitations This backend uses a custom library implementing the FileLu API. While it supports file transfers, some advanced features may not yet be available. Please report any issues to the rclone forum for troubleshooting and updates. For further information, visit FileLu's website. Files.com Files.com is a cloud storage service that provides a secure and easy way to store and share files. The initial setup for filescom involves authenticating with your Files.com account. You can do this by providing your site subdomain, username, and password. Alternatively, you can authenticate using an API Key from Files.com. rclone config walks you through it. Configuration Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Files.com \ "filescom" [snip] Storage> filescom Option site. Your site subdomain (e.g. mysite) or custom domain (e.g. myfiles.customdomain.com) Enter a value. Press Enter to leave empty. site> mysite Option username. The username used to authenticate with Files.com. Enter a value. Press Enter to leave empty. username> user Option password. The password used to authenticate with Files.com. Choose an alternative below. Press Enter for the default (n). y) Yes, type in my own password g) Generate random password n) No, leave this optional password blank (default) y/g/n> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: filescom - site: mysite - username: user - password: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Once configured you can use rclone. See all files in the top level: rclone lsf remote: Make a new directory in the root: rclone mkdir remote:dir Recursively List the contents: rclone ls remote: Sync /home/local/directory to the remote directory, deleting any excess files in the directory. rclone sync --interactive /home/local/directory remote:dir Hashes In December 2024 files.com started supporting more checksums. However if you want hashes you must enable them in your site by visiting the "File Integrity" section in "Data Governance" to configure your settings and select the checksum algorithms that meet your requirements. Rclone currently only support CRC32 and MD5 for use in syncing but selecting more checksums will not affect rclone's operations. For use with rclone, selecting at least MD5 is recommended so rclone can do an end to end integrity check. Standard options Here are the Standard options specific to filescom (Files.com). --filescom-site Your site subdomain (e.g. mysite) or custom domain (e.g. myfiles.customdomain.com). Properties: - Config: site - Env Var: RCLONE_FILESCOM_SITE - Type: string - Required: false --filescom-username The username used to authenticate with Files.com. Properties: - Config: username - Env Var: RCLONE_FILESCOM_USERNAME - Type: string - Required: false --filescom-password The password used to authenticate with Files.com. NB Input to this must be obscured - see rclone obscure. Properties: - Config: password - Env Var: RCLONE_FILESCOM_PASSWORD - Type: string - Required: false Advanced options Here are the Advanced options specific to filescom (Files.com). --filescom-api-key The API key used to authenticate with Files.com. Properties: - Config: api_key - Env Var: RCLONE_FILESCOM_API_KEY - Type: string - Required: false --filescom-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_FILESCOM_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,RightSpace,RightCrLfHtVt,InvalidUtf8,Dot --filescom-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_FILESCOM_DESCRIPTION - Type: string - Required: false FTP FTP is the File Transfer Protocol. Rclone FTP support is provided using the github.com/jlaffaye/ftp package. Limitations of Rclone's FTP backend Paths are specified as remote:path. If the path does not begin with a / it is relative to the home directory of the user. An empty path remote: refers to the user's home directory. Configuration To create an FTP configuration named remote, run rclone config Rclone config guides you through an interactive setup process. A minimal rclone FTP remote definition only requires host, username and password. For an anonymous FTP server, see below. No remotes found, make a new one? n) New remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config n/r/c/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / FTP \ "ftp" [snip] Storage> ftp ** See help for ftp backend at: https://rclone.org/ftp/ ** FTP host to connect to Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Connect to ftp.example.com \ "ftp.example.com" host> ftp.example.com FTP username Enter a string value. Press Enter for the default ("$USER"). user> FTP port number Enter a signed integer. Press Enter for the default (21). port> FTP password y) Yes type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Use FTP over TLS (Implicit) Enter a boolean value (true or false). Press Enter for the default ("false"). tls> Use FTP over TLS (Explicit) Enter a boolean value (true or false). Press Enter for the default ("false"). explicit_tls> Remote config Configuration complete. Options: - type: ftp - host: ftp.example.com - pass: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y To see all directories in the home directory of remote rclone lsd remote: Make a new directory rclone mkdir remote:path/to/directory List the contents of a directory rclone ls remote:path/to/directory Sync /home/local/directory to the remote directory, deleting any excess files in the directory. rclone sync --interactive /home/local/directory remote:directory Anonymous FTP When connecting to a FTP server that allows anonymous login, you can use the special "anonymous" username. Traditionally, this user account accepts any string as a password, although it is common to use either the password "anonymous" or "guest". Some servers require the use of a valid e-mail address as password. Using on-the-fly or connection string remotes makes it easy to access such servers, without requiring any configuration in advance. The following are examples of that: rclone lsf :ftp: --ftp-host=speedtest.tele2.net --ftp-user=anonymous --ftp-pass=$(rclone obscure dummy) rclone lsf :ftp,host=speedtest.tele2.net,user=anonymous,pass=$(rclone obscure dummy): The above examples work in Linux shells and in PowerShell, but not Windows Command Prompt. They execute the rclone obscure command to create a password string in the format required by the pass option. The following examples are exactly the same, except use an already obscured string representation of the same password "dummy", and therefore works even in Windows Command Prompt: rclone lsf :ftp: --ftp-host=speedtest.tele2.net --ftp-user=anonymous --ftp-pass=IXs2wc8OJOz7SYLBk47Ji1rHTmxM rclone lsf :ftp,host=speedtest.tele2.net,user=anonymous,pass=IXs2wc8OJOz7SYLBk47Ji1rHTmxM: Implicit TLS Rlone FTP supports implicit FTP over TLS servers (FTPS). This has to be enabled in the FTP backend config for the remote, or with --ftp-tls. The default FTPS port is 990, not 21 and can be set with --ftp-port. TLS Options TLS options for Implicit and Explicit TLS can be set using the following flags which are specific to the FTP backend: --ftp-no-check-certificate Do not verify the TLS certificate of the server --ftp-disable-tls13 Disable TLS 1.3 (workaround for FTP servers with buggy TLS) --ftp-tls-cache-size int Size of TLS session cache for all control and data connections (default 32) However any of the global TLS flags can also be used such as: --ca-cert stringArray CA certificate used to verify servers --client-cert string Client SSL certificate (PEM) for mutual TLS auth --client-key string Client SSL private key (PEM) for mutual TLS auth --no-check-certificate Do not verify the server SSL certificate (insecure) If these need to be put in the config file so they apply to just the FTP backend then use the override syntax, eg override.ca_cert = XXX override.client_cert = XXX override.client_key = XXX Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: File names cannot end with the following characters. Replacement is limited to the last character in a file name: Character Value Replacement ----------- ------- ------------- SP 0x20 ␠ Not all FTP servers can have all characters in file names, for example: FTP Server Forbidden characters ------------ ---------------------- proftpd * pureftpd \ [ ] This backend's interactive configuration wizard provides a selection of sensible encoding settings for major FTP servers: ProFTPd, PureFTPd, VsFTPd. Just hit a selection number when prompted. Standard options Here are the Standard options specific to ftp (FTP). --ftp-host FTP host to connect to. E.g. "ftp.example.com". Properties: - Config: host - Env Var: RCLONE_FTP_HOST - Type: string - Required: true --ftp-user FTP username. Properties: - Config: user - Env Var: RCLONE_FTP_USER - Type: string - Default: "$USER" --ftp-port FTP port number. Properties: - Config: port - Env Var: RCLONE_FTP_PORT - Type: int - Default: 21 --ftp-pass FTP password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: pass - Env Var: RCLONE_FTP_PASS - Type: string - Required: false --ftp-tls Use Implicit FTPS (FTP over TLS). When using implicit FTP over TLS the client connects using TLS right from the start which breaks compatibility with non-TLS-aware servers. This is usually served over port 990 rather than port 21. Cannot be used in combination with explicit FTPS. Properties: - Config: tls - Env Var: RCLONE_FTP_TLS - Type: bool - Default: false --ftp-explicit-tls Use Explicit FTPS (FTP over TLS). When using explicit FTP over TLS the client explicitly requests security from the server in order to upgrade a plain text connection to an encrypted one. Cannot be used in combination with implicit FTPS. Properties: - Config: explicit_tls - Env Var: RCLONE_FTP_EXPLICIT_TLS - Type: bool - Default: false Advanced options Here are the Advanced options specific to ftp (FTP). --ftp-concurrency Maximum number of FTP simultaneous connections, 0 for unlimited. Note that setting this is very likely to cause deadlocks so it should be used with care. If you are doing a sync or copy then make sure concurrency is one more than the sum of --transfers and --checkers. If you use --check-first then it just needs to be one more than the maximum of --checkers and --transfers. So for concurrency 3 you'd use --checkers 2 --transfers 2 --check-first or --checkers 1 --transfers 1. Properties: - Config: concurrency - Env Var: RCLONE_FTP_CONCURRENCY - Type: int - Default: 0 --ftp-no-check-certificate Do not verify the TLS certificate of the server. Properties: - Config: no_check_certificate - Env Var: RCLONE_FTP_NO_CHECK_CERTIFICATE - Type: bool - Default: false --ftp-disable-epsv Disable using EPSV even if server advertises support. Properties: - Config: disable_epsv - Env Var: RCLONE_FTP_DISABLE_EPSV - Type: bool - Default: false --ftp-disable-mlsd Disable using MLSD even if server advertises support. Properties: - Config: disable_mlsd - Env Var: RCLONE_FTP_DISABLE_MLSD - Type: bool - Default: false --ftp-disable-utf8 Disable using UTF-8 even if server advertises support. Properties: - Config: disable_utf8 - Env Var: RCLONE_FTP_DISABLE_UTF8 - Type: bool - Default: false --ftp-writing-mdtm Use MDTM to set modification time (VsFtpd quirk) Properties: - Config: writing_mdtm - Env Var: RCLONE_FTP_WRITING_MDTM - Type: bool - Default: false --ftp-force-list-hidden Use LIST -a to force listing of hidden files and folders. This will disable the use of MLSD. Properties: - Config: force_list_hidden - Env Var: RCLONE_FTP_FORCE_LIST_HIDDEN - Type: bool - Default: false --ftp-idle-timeout Max time before closing idle connections. If no connections have been returned to the connection pool in the time given, rclone will empty the connection pool. Set to 0 to keep connections indefinitely. Properties: - Config: idle_timeout - Env Var: RCLONE_FTP_IDLE_TIMEOUT - Type: Duration - Default: 1m0s --ftp-close-timeout Maximum time to wait for a response to close. Properties: - Config: close_timeout - Env Var: RCLONE_FTP_CLOSE_TIMEOUT - Type: Duration - Default: 1m0s --ftp-tls-cache-size Size of TLS session cache for all control and data connections. TLS cache allows to resume TLS sessions and reuse PSK between connections. Increase if default size is not enough resulting in TLS resumption errors. Enabled by default. Use 0 to disable. Properties: - Config: tls_cache_size - Env Var: RCLONE_FTP_TLS_CACHE_SIZE - Type: int - Default: 32 --ftp-disable-tls13 Disable TLS 1.3 (workaround for FTP servers with buggy TLS) Properties: - Config: disable_tls13 - Env Var: RCLONE_FTP_DISABLE_TLS13 - Type: bool - Default: false --ftp-allow-insecure-tls-ciphers 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 Properties: - Config: allow_insecure_tls_ciphers - Env Var: RCLONE_FTP_ALLOW_INSECURE_TLS_CIPHERS - Type: bool - Default: false --ftp-shut-timeout Maximum time to wait for data connection closing status. Properties: - Config: shut_timeout - Env Var: RCLONE_FTP_SHUT_TIMEOUT - Type: Duration - Default: 1m0s --ftp-ask-password Allow asking for FTP password when needed. If this is set and no password is supplied then rclone will ask for a password Properties: - Config: ask_password - Env Var: RCLONE_FTP_ASK_PASSWORD - Type: bool - Default: false --ftp-socks-proxy Socks 5 proxy host. Supports the format user:pass@host:port, user@host:port, host:port. Example: myUser:myPass@localhost:9005 Properties: - Config: socks_proxy - Env Var: RCLONE_FTP_SOCKS_PROXY - Type: string - Required: false --ftp-http-proxy URL for HTTP CONNECT proxy Set this to a URL for an HTTP proxy which supports the HTTP CONNECT verb. Properties: - Config: http_proxy - Env Var: RCLONE_FTP_HTTP_PROXY - Type: string - Required: false --ftp-no-check-upload Don't check the upload is OK Normally rclone will try to check the upload exists after it has uploaded a file to make sure the size and modification time are as expected. This flag stops rclone doing these checks. This enables uploading to folders which are write only. You will likely need to use the --inplace flag also if uploading to a write only folder. Properties: - Config: no_check_upload - Env Var: RCLONE_FTP_NO_CHECK_UPLOAD - Type: bool - Default: false --ftp-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_FTP_ENCODING - Type: Encoding - Default: Slash,Del,Ctl,RightSpace,Dot - Examples: - "Asterisk,Ctl,Dot,Slash" - ProFTPd can't handle '*' in file names - "BackSlash,Ctl,Del,Dot,RightSpace,Slash,SquareBracket" - PureFTPd can't handle '[]' or '*' in file names - "Ctl,LeftPeriod,Slash" - VsFTPd can't handle file names starting with dot --ftp-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_FTP_DESCRIPTION - Type: string - Required: false Limitations FTP servers acting as rclone remotes must support passive mode. The mode cannot be configured as passive is the only supported one. Rclone's FTP implementation is not compatible with active mode as the library it uses doesn't support it. This will likely never be supported due to security concerns. Rclone's FTP backend does not support any checksums but can compare file sizes. rclone about is not supported by the FTP backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about The implementation of : --dump headers, --dump bodies, --dump auth for debugging isn't the same as for rclone HTTP based backends - it has less fine grained control. --timeout isn't supported (but --contimeout is). --bind isn't supported. Rclone's FTP backend could support server-side move but does not at present. The ftp_proxy environment variable is not currently supported. Modification times File modification time (timestamps) is supported to 1 second resolution for major FTP servers: ProFTPd, PureFTPd, VsFTPd, and FileZilla FTP server. The VsFTPd server has non-standard implementation of time related protocol commands and needs a special configuration setting: writing_mdtm = true. Support for precise file time with other FTP servers varies depending on what protocol extensions they advertise. If all the MLSD, MDTM and MFTM extensions are present, rclone will use them together to provide precise time. Otherwise the times you see on the FTP server through rclone are those of the last file upload. You can use the following command to check whether rclone can use precise time with your FTP server: rclone backend features your_ftp_remote: (the trailing colon is important). Look for the number in the line tagged by Precision designating the remote time precision expressed as nanoseconds. A value of 1000000000 means that file time precision of 1 second is available. A value of 3153600000000000000 (or another large number) means "unsupported". Gofile Gofile is a content storage and distribution platform. Its aim is to provide as much service as possible for free or at a very low price. The initial setup for Gofile involves logging in to the web interface and going to the "My Profile" section. Copy the "Account API token" for use in the config file. Note that if you wish to connect rclone to Gofile you will need a premium account. Configuration Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. XX / Gofile \ (gofile) Storage> gofile Option access_token. API Access token You can get this from the web control panel. Enter a value. Press Enter to leave empty. access_token> YOURACCESSTOKEN Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: gofile - access_token: YOURACCESSTOKEN Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Once configured you can then use rclone like this, List directories and files in the top level of your Gofile rclone lsf remote: To copy a local directory to an Gofile directory called backup rclone copy /home/source remote:backup Modification times and hashes Gofile supports modification times with a resolution of 1 second. Gofile supports MD5 hashes, so you can use the --checksum flag. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- ! 0x21 ！ " 0x22 ＂ * 0x2A ＊ : 0x3A ： < 0x3C ＜ > 0x3E ＞ ? 0x3F ？ \ 0x5C ＼ | 0x7C ｜ File names can also not start or end with the following characters. These only get replaced if they are the first or last character in the name: Character Value Replacement ----------- ------- ------------- . 0x2E ． Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Public Links Gofile supports rclone link to make public links to files or directories. If you specify a directory it will download as a zip file. You can use the --expire flag to specify the time the link should be valid. Note that rclone link --unlink removes all the public links for a file. Root folder ID You can set the root_folder_id for rclone. This is the directory (identified by its Folder ID) that rclone considers to be the root of your Gofile drive. Normally you will leave this blank and rclone will determine the correct root to use itself and fill in the value in the config file. However you can set this to restrict rclone to a specific folder hierarchy. In order to do this you will have to find the Folder ID of the directory you wish rclone to display. You can do this with rclone $ rclone lsf -Fip --dirs-only remote: d6341f53-ee65-4f29-9f59-d11e8070b2a0;Files/ f4f5c9b8-6ece-478b-b03e-4538edfe5a1c;Photos/ d50e356c-29ca-4b27-a3a7-494d91026e04;Videos/ The ID to use is the part before the ; so you could set root_folder_id = d6341f53-ee65-4f29-9f59-d11e8070b2a0 To restrict rclone to the Files directory. Standard options Here are the Standard options specific to gofile (Gofile). --gofile-access-token API Access token You can get this from the web control panel. Properties: - Config: access_token - Env Var: RCLONE_GOFILE_ACCESS_TOKEN - Type: string - Required: false Advanced options Here are the Advanced options specific to gofile (Gofile). --gofile-root-folder-id ID of the root folder Leave this blank normally, rclone will fill it in automatically. If you want rclone to be restricted to a particular folder you can fill it in - see the docs for more info. Properties: - Config: root_folder_id - Env Var: RCLONE_GOFILE_ROOT_FOLDER_ID - Type: string - Required: false --gofile-account-id Account ID Leave this blank normally, rclone will fill it in automatically. Properties: - Config: account_id - Env Var: RCLONE_GOFILE_ACCOUNT_ID - Type: string - Required: false --gofile-list-chunk Number of items to list in each call Properties: - Config: list_chunk - Env Var: RCLONE_GOFILE_LIST_CHUNK - Type: int - Default: 1000 --gofile-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_GOFILE_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,LeftPeriod,RightPeriod,InvalidUtf8,Dot,Exclamation --gofile-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_GOFILE_DESCRIPTION - Type: string - Required: false Limitations Gofile only supports filenames up to 255 characters in length, where a character is a unicode character. Directories should not be cached for more than 24h otherwise files in the directory may not be downloadable. In practice this means when using a VFS based rclone command such as rclone mount you should make sure --dir-cache-time is less than 24h. Note that Gofile is currently limited to a total of 100,000 items. If you attempt to upload more than that you will get error-limit-100000. This limit may be lifted in the future. Duplicated files Gofile is capable of having files with duplicated file names. For instance two files called hello.txt in the same directory. Rclone cannot sync that to a normal file system but it can be fixed with the rclone dedupe command. Duplicated files cause problems with the syncing and you will see messages in the log about duplicates. Use rclone dedupe to fix duplicated files. Google Cloud Storage Paths are specified as remote:bucket (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:bucket/path/to/dir. Configuration The initial setup for google cloud storage involves getting a token from Google Cloud Storage which you need to do in your browser. rclone config walks you through it. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: n) New remote d) Delete remote q) Quit config e/n/d/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Google Cloud Storage (this is not Google Drive) \ "google cloud storage" [snip] Storage> google cloud storage Google Application Client Id - leave blank normally. client_id> Google Application Client Secret - leave blank normally. client_secret> Project number optional - needed only for list/create/delete buckets - see your developer console. project_number> 12345678 Service Account Credentials JSON file path - needed only if you want use SA instead of interactive login. service_account_file> Access Control List for new objects. Choose a number from below, or type in your own value 1 / Object owner gets OWNER access, and all Authenticated Users get READER access. \ "authenticatedRead" 2 / Object owner gets OWNER access, and project team owners get OWNER access. \ "bucketOwnerFullControl" 3 / Object owner gets OWNER access, and project team owners get READER access. \ "bucketOwnerRead" 4 / Object owner gets OWNER access [default if left blank]. \ "private" 5 / Object owner gets OWNER access, and project team members get access according to their roles. \ "projectPrivate" 6 / Object owner gets OWNER access, and all Users get READER access. \ "publicRead" object_acl> 4 Access Control List for new buckets. Choose a number from below, or type in your own value 1 / Project team owners get OWNER access, and all Authenticated Users get READER access. \ "authenticatedRead" 2 / Project team owners get OWNER access [default if left blank]. \ "private" 3 / Project team members get access according to their roles. \ "projectPrivate" 4 / Project team owners get OWNER access, and all Users get READER access. \ "publicRead" 5 / Project team owners get OWNER access, and all Users get WRITER access. \ "publicReadWrite" bucket_acl> 2 Location for the newly created buckets. Choose a number from below, or type in your own value 1 / Empty for default location (US). \ "" 2 / Multi-regional location for Asia. \ "asia" 3 / Multi-regional location for Europe. \ "eu" 4 / Multi-regional location for United States. \ "us" 5 / Taiwan. \ "asia-east1" 6 / Tokyo. \ "asia-northeast1" 7 / Singapore. \ "asia-southeast1" 8 / Sydney. \ "australia-southeast1" 9 / Belgium. \ "europe-west1" 10 / London. \ "europe-west2" 11 / Iowa. \ "us-central1" 12 / South Carolina. \ "us-east1" 13 / Northern Virginia. \ "us-east4" 14 / Oregon. \ "us-west1" location> 12 The storage class to use when storing objects in Google Cloud Storage. Choose a number from below, or type in your own value 1 / Default \ "" 2 / Multi-regional storage class \ "MULTI_REGIONAL" 3 / Regional storage class \ "REGIONAL" 4 / Nearline storage class \ "NEARLINE" 5 / Coldline storage class \ "COLDLINE" 6 / Durable reduced availability storage class \ "DURABLE_REDUCED_AVAILABILITY" storage_class> 5 Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: google cloud storage - client_id: - client_secret: - token: {"AccessToken":"xxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","RefreshToken":"x/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx_xxxxxxxxx","Expiry":"2014-07-17T20:49:14.929208288+01:00","Extra":null} - project_number: 12345678 - object_acl: private - bucket_acl: private Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y See the remote setup docs for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Google if using web browser to automatically authenticate. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall, or use manual mode. This remote is called remote and can now be used like this See all the buckets in your project rclone lsd remote: Make a new bucket rclone mkdir remote:bucket List the contents of a bucket rclone ls remote:bucket Sync /home/local/directory to the remote bucket, deleting any excess files in the bucket. rclone sync --interactive /home/local/directory remote:bucket Service Account support You can set up rclone with Google Cloud Storage in an unattended mode, i.e. not tied to a specific end-user Google account. This is useful when you want to synchronise files onto machines that don't have actively logged-in users, for example build machines. To get credentials for Google Cloud Platform IAM Service Accounts, please head to the Service Account section of the Google Developer Console. Service Accounts behave just like normal User permissions in Google Cloud Storage ACLs, so you can limit their access (e.g. make them read only). After creating an account, a JSON file containing the Service Account's credentials will be downloaded onto your machines. These credentials are what rclone will use for authentication. To use a Service Account instead of OAuth2 token flow, enter the path to your Service Account credentials at the service_account_file prompt and rclone won't use the browser based authentication flow. If you'd rather stuff the contents of the credentials file into the rclone config file, you can set service_account_credentials with the actual contents of the file instead, or set the equivalent environment variable. Service Account Authentication with Access Tokens Another option for service account authentication is to use access tokens via gcloud impersonate-service-account. Access tokens protect security by avoiding the use of the JSON key file, which can be breached. They also bypass oauth login flow, which is simpler on remote VMs that lack a web browser. If you already have a working service account, skip to step 3. 1. Create a service account using gcloud iam service-accounts create gcs-read-only You can re-use an existing service account as well (like the one created above) 2. Attach a Viewer (read-only) or User (read-write) role to the service account $ PROJECT_ID=my-project $ gcloud --verbose iam service-accounts add-iam-policy-binding \ gcs-read-only@${PROJECT_ID}.iam.gserviceaccount.com \ --member=serviceAccount:gcs-read-only@${PROJECT_ID}.iam.gserviceaccount.com \ --role=roles/storage.objectViewer Use the Google Cloud console to identify a limited role. Some relevant pre-defined roles: - roles/storage.objectUser -- read-write access but no admin privileges - roles/storage.objectViewer -- read-only access to objects - roles/storage.admin -- create buckets & administrative roles 3. Get a temporary access key for the service account $ gcloud auth application-default print-access-token \ --impersonate-service-account \ gcs-read-only@${PROJECT_ID}.iam.gserviceaccount.com ya29.c.c0ASRK0GbAFEewXD [truncated] 4. Update access_token setting hit CTRL-C when you see waiting for code. This will save the config without doing oauth flow rclone config update ${REMOTE_NAME} access_token ya29.c.c0Axxxx 5. Run rclone as usual rclone ls dev-gcs:${MY_BUCKET}/ More Info on Service Accounts - Official GCS Docs - Guide on Service Accounts using Key Files (less secure, but similar concepts) Anonymous Access For downloads of objects that permit public access you can configure rclone to use anonymous access by setting anonymous to true. With unauthorized access you can't write or create files but only read or list those buckets and objects that have public read access. Application Default Credentials If no other source of credentials is provided, rclone will fall back to Application Default Credentials this is useful both when you already have configured authentication for your developer account, or in production when running on a google compute host. Note that if running in docker, you may need to run additional commands on your google compute machine - see this page. Note that in the case application default credentials are used, there is no need to explicitly configure a project number. --fast-list This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details. Custom upload headers You can set custom upload headers with the --header-upload flag. Google Cloud Storage supports the headers as described in the working with metadata documentation - Cache-Control - Content-Disposition - Content-Encoding - Content-Language - Content-Type - X-Goog-Storage-Class - X-Goog-Meta- Eg --header-upload "Content-Type text/potato" Note that the last of these is for setting custom metadata in the form --header-upload "x-goog-meta-key: value" Modification times Google Cloud Storage stores md5sum natively. Google's gsutil tool stores modification time with one-second precision as goog-reserved-file-mtime in file metadata. To ensure compatibility with gsutil, rclone stores modification time in 2 separate metadata entries. mtime uses RFC3339 format with one-nanosecond precision. goog-reserved-file-mtime uses Unix timestamp format with one-second precision. To get modification time from object metadata, rclone reads the metadata in the following order: mtime, goog-reserved-file-mtime, object updated time. Note that rclone's default modify window is 1ns. Files uploaded by gsutil only contain timestamps with one-second precision. If you use rclone to sync files previously uploaded by gsutil, rclone will attempt to update modification time for all these files. To avoid these possibly unnecessary updates, use --modify-window 1s. Restricted filename characters Character Value Replacement ----------- ------- ------------- NUL 0x00 ␀ LF 0x0A ␊ CR 0x0D ␍ / 0x2F ／ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Standard options Here are the Standard options specific to google cloud storage (Google Cloud Storage (this is not Google Drive)). --gcs-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_GCS_CLIENT_ID - Type: string - Required: false --gcs-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_GCS_CLIENT_SECRET - Type: string - Required: false --gcs-project-number Project number. Optional - needed only for list/create/delete buckets - see your developer console. Properties: - Config: project_number - Env Var: RCLONE_GCS_PROJECT_NUMBER - Type: string - Required: false --gcs-user-project User project. Optional - needed only for requester pays. Properties: - Config: user_project - Env Var: RCLONE_GCS_USER_PROJECT - Type: string - Required: false --gcs-service-account-file Service Account Credentials JSON file path. Leave blank normally. Needed only if you want use SA instead of interactive login. Leading ~ will be expanded in the file name as will environment variables such as ${RCLONE_CONFIG_DIR}. Properties: - Config: service_account_file - Env Var: RCLONE_GCS_SERVICE_ACCOUNT_FILE - Type: string - Required: false --gcs-service-account-credentials Service Account Credentials JSON blob. Leave blank normally. Needed only if you want use SA instead of interactive login. Properties: - Config: service_account_credentials - Env Var: RCLONE_GCS_SERVICE_ACCOUNT_CREDENTIALS - Type: string - Required: false --gcs-anonymous Access public buckets and objects without credentials. Set to 'true' if you just want to download files and don't configure credentials. Properties: - Config: anonymous - Env Var: RCLONE_GCS_ANONYMOUS - Type: bool - Default: false --gcs-object-acl Access Control List for new objects. Properties: - Config: object_acl - Env Var: RCLONE_GCS_OBJECT_ACL - Type: string - Required: false - Examples: - "authenticatedRead" - Object owner gets OWNER access. - All Authenticated Users get READER access. - "bucketOwnerFullControl" - Object owner gets OWNER access. - Project team owners get OWNER access. - "bucketOwnerRead" - Object owner gets OWNER access. - Project team owners get READER access. - "private" - Object owner gets OWNER access. - Default if left blank. - "projectPrivate" - Object owner gets OWNER access. - Project team members get access according to their roles. - "publicRead" - Object owner gets OWNER access. - All Users get READER access. --gcs-bucket-acl Access Control List for new buckets. Properties: - Config: bucket_acl - Env Var: RCLONE_GCS_BUCKET_ACL - Type: string - Required: false - Examples: - "authenticatedRead" - Project team owners get OWNER access. - All Authenticated Users get READER access. - "private" - Project team owners get OWNER access. - Default if left blank. - "projectPrivate" - Project team members get access according to their roles. - "publicRead" - Project team owners get OWNER access. - All Users get READER access. - "publicReadWrite" - Project team owners get OWNER access. - All Users get WRITER access. --gcs-bucket-policy-only Access checks should use bucket-level IAM policies. If you want to upload objects to a bucket with Bucket Policy Only set then you will need to set this. When it is set, rclone: - ignores ACLs set on buckets - ignores ACLs set on objects - creates buckets with Bucket Policy Only set Docs: https://cloud.google.com/storage/docs/bucket-policy-only Properties: - Config: bucket_policy_only - Env Var: RCLONE_GCS_BUCKET_POLICY_ONLY - Type: bool - Default: false --gcs-location Location for the newly created buckets. Properties: - Config: location - Env Var: RCLONE_GCS_LOCATION - Type: string - Required: false - Examples: - "" - Empty for default location (US) - "asia" - Multi-regional location for Asia - "eu" - Multi-regional location for Europe - "us" - Multi-regional location for United States - "asia-east1" - Taiwan - "asia-east2" - Hong Kong - "asia-northeast1" - Tokyo - "asia-northeast2" - Osaka - "asia-northeast3" - Seoul - "asia-south1" - Mumbai - "asia-south2" - Delhi - "asia-southeast1" - Singapore - "asia-southeast2" - Jakarta - "australia-southeast1" - Sydney - "australia-southeast2" - Melbourne - "europe-north1" - Finland - "europe-west1" - Belgium - "europe-west2" - London - "europe-west3" - Frankfurt - "europe-west4" - Netherlands - "europe-west6" - Zürich - "europe-central2" - Warsaw - "us-central1" - Iowa - "us-east1" - South Carolina - "us-east4" - Northern Virginia - "us-west1" - Oregon - "us-west2" - California - "us-west3" - Salt Lake City - "us-west4" - Las Vegas - "northamerica-northeast1" - Montréal - "northamerica-northeast2" - Toronto - "southamerica-east1" - São Paulo - "southamerica-west1" - Santiago - "asia1" - Dual region: asia-northeast1 and asia-northeast2. - "eur4" - Dual region: europe-north1 and europe-west4. - "nam4" - Dual region: us-central1 and us-east1. --gcs-storage-class The storage class to use when storing objects in Google Cloud Storage. Properties: - Config: storage_class - Env Var: RCLONE_GCS_STORAGE_CLASS - Type: string - Required: false - Examples: - "" - Default - "MULTI_REGIONAL" - Multi-regional storage class - "REGIONAL" - Regional storage class - "NEARLINE" - Nearline storage class - "COLDLINE" - Coldline storage class - "ARCHIVE" - Archive storage class - "DURABLE_REDUCED_AVAILABILITY" - Durable reduced availability storage class --gcs-env-auth Get GCP IAM credentials from runtime (environment variables or instance meta data if no env vars). Only applies if service_account_file and service_account_credentials is blank. Properties: - Config: env_auth - Env Var: RCLONE_GCS_ENV_AUTH - Type: bool - Default: false - Examples: - "false" - Enter credentials in the next step. - "true" - Get GCP IAM credentials from the environment (env vars or IAM). Advanced options Here are the Advanced options specific to google cloud storage (Google Cloud Storage (this is not Google Drive)). --gcs-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_GCS_TOKEN - Type: string - Required: false --gcs-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_GCS_AUTH_URL - Type: string - Required: false --gcs-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_GCS_TOKEN_URL - Type: string - Required: false --gcs-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_GCS_CLIENT_CREDENTIALS - Type: bool - Default: false --gcs-access-token Short-lived access token. Leave blank normally. Needed only if you want use short-lived access token instead of interactive login. Properties: - Config: access_token - Env Var: RCLONE_GCS_ACCESS_TOKEN - Type: string - Required: false --gcs-directory-markers Upload an empty object with a trailing slash when a new directory is created Empty folders are unsupported for bucket based remotes, this option creates an empty object ending with "/", to persist the folder. Properties: - Config: directory_markers - Env Var: RCLONE_GCS_DIRECTORY_MARKERS - Type: bool - Default: false --gcs-no-check-bucket If set, don't attempt to check the bucket exists or create it. This can be useful when trying to minimise the number of transactions rclone does if you know the bucket exists already. Properties: - Config: no_check_bucket - Env Var: RCLONE_GCS_NO_CHECK_BUCKET - Type: bool - Default: false --gcs-decompress If set this will decompress gzip encoded objects. It is possible to upload objects to GCS with "Content-Encoding: gzip" set. Normally rclone will download these files as compressed objects. If this flag is set then rclone will decompress these files with "Content-Encoding: gzip" as they are received. This means that rclone can't check the size and hash but the file contents will be decompressed. Properties: - Config: decompress - Env Var: RCLONE_GCS_DECOMPRESS - Type: bool - Default: false --gcs-endpoint Endpoint for the service. Leave blank normally. Properties: - Config: endpoint - Env Var: RCLONE_GCS_ENDPOINT - Type: string - Required: false --gcs-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_GCS_ENCODING - Type: Encoding - Default: Slash,CrLf,InvalidUtf8,Dot --gcs-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_GCS_DESCRIPTION - Type: string - Required: false Limitations rclone about is not supported by the Google Cloud Storage backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about Google Drive Paths are specified as drive:path Drive paths may be as deep as required, e.g. drive:directory/subdirectory. Configuration The initial setup for drive involves getting a token from Google drive which you need to do in your browser. rclone config walks you through it. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config n/r/c/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Google Drive \ "drive" [snip] Storage> drive Google Application Client Id - leave blank normally. client_id> Google Application Client Secret - leave blank normally. client_secret> Scope that rclone should use when requesting access from drive. Choose a number from below, or type in your own value 1 / Full access all files, excluding Application Data Folder. \ "drive" 2 / Read-only access to file metadata and file contents. \ "drive.readonly" / Access to files created by rclone only. 3 | These are visible in the drive website. | File authorization is revoked when the user deauthorizes the app. \ "drive.file" / Allows read and write access to the Application Data folder. 4 | This is not visible in the drive website. \ "drive.appfolder" / Allows read-only access to file metadata but 5 | does not allow any access to read or download file content. \ "drive.metadata.readonly" scope> 1 Service Account Credentials JSON file path - needed only if you want use SA instead of interactive login. service_account_file> Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Configure this as a Shared Drive (Team Drive)? y) Yes n) No y/n> n Configuration complete. Options: type: drive - client_id: - client_secret: - scope: drive - root_folder_id: - service_account_file: - token: {"access_token":"XXX","token_type":"Bearer","refresh_token":"XXX","expiry":"2014-03-16T13:57:58.955387075Z"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y See the remote setup docs for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Google if using web browser to automatically authenticate. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and it may require you to unblock it temporarily if you are running a host firewall, or use manual mode. You can then use it like this, List directories in top level of your drive rclone lsd remote: List all the files in your drive rclone ls remote: To copy a local directory to a drive directory called backup rclone copy /home/source remote:backup Scopes Rclone allows you to select which scope you would like for rclone to use. This changes what type of token is granted to rclone. The scopes are defined here. A comma-separated list is allowed e.g. drive.readonly,drive.file. The scope are drive This is the default scope and allows full access to all files, except for the Application Data Folder (see below). Choose this one if you aren't sure. drive.readonly This allows read only access to all files. Files may be listed and downloaded but not uploaded, renamed or deleted. drive.file With this scope rclone can read/view/modify only those files and folders it creates. So if you uploaded files to drive via the web interface (or any other means) they will not be visible to rclone. This can be useful if you are using rclone to backup data and you want to be sure confidential data on your drive is not visible to rclone. Files created with this scope are visible in the web interface. drive.appfolder This gives rclone its own private area to store files. Rclone will not be able to see any other files on your drive and you won't be able to see rclone's files from the web interface either. drive.metadata.readonly This allows read only access to file names only. It does not allow rclone to download or upload data, or rename or delete files or directories. Root folder ID This option has been moved to the advanced section. You can set the root_folder_id for rclone. This is the directory (identified by its Folder ID) that rclone considers to be the root of your drive. Normally you will leave this blank and rclone will determine the correct root to use itself. However you can set this to restrict rclone to a specific folder hierarchy or to access data within the "Computers" tab on the drive web interface (where files from Google's Backup and Sync desktop program go). In order to do this you will have to find the Folder ID of the directory you wish rclone to display. This will be the last segment of the URL when you open the relevant folder in the drive web interface. So if the folder you want rclone to use has a URL which looks like https://drive.google.com/drive/folders/1XyfxxxxxxxxxxxxxxxxxxxxxxxxxKHCh in the browser, then you use 1XyfxxxxxxxxxxxxxxxxxxxxxxxxxKHCh as the root_folder_id in the config. NB folders under the "Computers" tab seem to be read only (drive gives a 500 error) when using rclone. There doesn't appear to be an API to discover the folder IDs of the "Computers" tab - please contact us if you know otherwise! Note also that rclone can't access any data under the "Backups" tab on the google drive web interface yet. Service Account support You can set up rclone with Google Drive in an unattended mode, i.e. not tied to a specific end-user Google account. This is useful when you want to synchronise files onto machines that don't have actively logged-in users, for example build machines. To use a Service Account instead of OAuth2 token flow, enter the path to your Service Account credentials at the service_account_file prompt during rclone config and rclone won't use the browser based authentication flow. If you'd rather stuff the contents of the credentials file into the rclone config file, you can set service_account_credentials with the actual contents of the file instead, or set the equivalent environment variable. Use case - Google Workspace account and individual Drive Let's say that you are the administrator of a Google Workspace. The goal is to read or write data on an individual's Drive account, who IS a member of the domain. We'll call the domain example.com, and the user foo@example.com. There's a few steps we need to go through to accomplish this: 1. Create a service account for example.com - To create a service account and obtain its credentials, go to the Google Developer Console. - You must have a project - create one if you don't and make sure you are on the selected project. - Then go to "IAM & admin" -> "Service Accounts". - Use the "Create Service Account" button. Fill in "Service account name" and "Service account ID" with something that identifies your client. - Select "Create And Continue". Step 2 and 3 are optional. - Click on the newly created service account - Click "Keys" and then "Add Key" and then "Create new key" - Choose type "JSON" and click create - This will download a small JSON file that rclone will use for authentication. If you ever need to remove access, press the "Delete service account key" button. 2. Allowing API access to example.com Google Drive - Go to example.com's Workspace Admin Console - Go into "Security" (or use the search bar) - Select "Access and data control" and then "API controls" - Click "Manage domain-wide delegation" - Click "Add new" - In the "Client ID" field enter the service account's "Client ID" - this can be found in the Developer Console under "IAM & Admin" -> "Service Accounts", then "View Client ID" for the newly created service account. It is a ~21 character numerical string. - In the next field, "OAuth Scopes", enter https://www.googleapis.com/auth/drive to grant read/write access to Google Drive specifically. You can also use https://www.googleapis.com/auth/drive.readonly for read only access. - Click "Authorise" 3. Configure rclone, assuming a new install rclone config n/s/q> n # New name>gdrive # Gdrive is an example name Storage> # Type drive client_id> # Can be left blank client_secret> # Can be left blank scope> # Select the scope use used in step 2 root_folder_id> # Can be left blank service_account_file> /home/foo/myJSONfile.json # Path to the JSON file you downloaded in step 1. y/n> # Auto config, n 4. Verify that it's working - rclone -v --drive-impersonate foo@example.com lsf gdrive:backup - The arguments do: - -v - verbose logging - --drive-impersonate foo@example.com - this is what does the magic, pretending to be user foo. - lsf - list files in a parsing friendly way - gdrive:backup - use the remote called gdrive, work in the folder named backup. Note: in case you configured a specific root folder on gdrive and rclone is unable to access the contents of that folder when using --drive-impersonate, do this instead: - in the gdrive web interface, share your root folder with the user/email of the new Service Account you created/selected at step 1 - use rclone without specifying the --drive-impersonate option, like this: rclone -v lsf gdrive:backup Shared drives (team drives) If you want to configure the remote to point to a Google Shared Drive (previously known as Team Drives) then answer y to the question Configure this as a Shared Drive (Team Drive)?. This will fetch the list of Shared Drives from google and allow you to configure which one you want to use. You can also type in a Shared Drive ID if you prefer. For example: Configure this as a Shared Drive (Team Drive)? y) Yes n) No y/n> y Fetching Shared Drive list... Choose a number from below, or type in your own value 1 / Rclone Test \ "xxxxxxxxxxxxxxxxxxxx" 2 / Rclone Test 2 \ "yyyyyyyyyyyyyyyyyyyy" 3 / Rclone Test 3 \ "zzzzzzzzzzzzzzzzzzzz" Enter a Shared Drive ID> 1 Configuration complete. Options: - type: drive - client_id: - client_secret: - token: {"AccessToken":"xxxx.x.xxxxx_xxxxxxxxxxx_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","RefreshToken":"1/xxxxxxxxxxxxxxxx_xxxxxxxxxxxxxxxxxxxxxxxxxx","Expiry":"2014-03-16T13:57:58.955387075Z","Extra":null} - team_drive: xxxxxxxxxxxxxxxxxxxx Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y --fast-list This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details. It does this by combining multiple list calls into a single API request. This works by combining many '%s' in parents filters into one expression. To list the contents of directories a, b and c, the following requests will be send by the regular List function: trashed=false and 'a' in parents trashed=false and 'b' in parents trashed=false and 'c' in parents These can now be combined into a single request: trashed=false and ('a' in parents or 'b' in parents or 'c' in parents) The implementation of ListR will put up to 50 parents filters into one request. It will use the --checkers value to specify the number of requests to run in parallel. In tests, these batch requests were up to 20x faster than the regular method. Running the following command against different sized folders gives: rclone lsjson -vv -R --checkers=6 gdrive:folder small folder (220 directories, 700 files): - without --fast-list: 38s - with --fast-list: 10s large folder (10600 directories, 39000 files): - without --fast-list: 22:05 min - with --fast-list: 58s Modification times and hashes Google drive stores modification times accurate to 1 ms. Hash algorithms MD5, SHA1 and SHA256 are supported. Note, however, that a small fraction of files uploaded may not have SHA1 or SHA256 hashes especially if they were uploaded before 2018. Restricted filename characters Only Invalid UTF-8 bytes will be replaced, as they can't be used in JSON strings. In contrast to other backends, / can also be used in names and . or .. are valid names. Revisions Google drive stores revisions of files. When you upload a change to an existing file to google drive using rclone it will create a new revision of that file. Revisions follow the standard google policy which at time of writing was - They are deleted after 30 days or 100 revisions (whatever comes first). - They do not count towards a user storage quota. Deleting files By default rclone will send all files to the trash when deleting files. If deleting them permanently is required then use the --drive-use-trash=false flag, or set the equivalent environment variable. Shortcuts In March 2020 Google introduced a new feature in Google Drive called drive shortcuts (API). These will (by September 2020) replace the ability for files or folders to be in multiple folders at once. Shortcuts are files that link to other files on Google Drive somewhat like a symlink in unix, except they point to the underlying file data (e.g. the inode in unix terms) so they don't break if the source is renamed or moved about. By default rclone treats these as follows. For shortcuts pointing to files: - When listing a file shortcut appears as the destination file. - When downloading the contents of the destination file is downloaded. - When updating shortcut file with a non shortcut file, the shortcut is removed then a new file is uploaded in place of the shortcut. - When server-side moving (renaming) the shortcut is renamed, not the destination file. - When server-side copying the shortcut is copied, not the contents of the shortcut. (unless --drive-copy-shortcut-content is in use in which case the contents of the shortcut gets copied). - When deleting the shortcut is deleted not the linked file. - When setting the modification time, the modification time of the linked file will be set. For shortcuts pointing to folders: - When listing the shortcut appears as a folder and that folder will contain the contents of the linked folder appear (including any sub folders) - When downloading the contents of the linked folder and sub contents are downloaded - When uploading to a shortcut folder the file will be placed in the linked folder - When server-side moving (renaming) the shortcut is renamed, not the destination folder - When server-side copying the contents of the linked folder is copied, not the shortcut. - When deleting with rclone rmdir or rclone purge the shortcut is deleted not the linked folder. - NB When deleting with rclone remove or rclone mount the contents of the linked folder will be deleted. The rclone backend command can be used to create shortcuts. Shortcuts can be completely ignored with the --drive-skip-shortcuts flag or the corresponding skip_shortcuts configuration setting. If you have shortcuts that lead to an infinite recursion in your drive (e.g. a shortcut pointing to a parent folder), skip_shortcuts might be mandatory to be able to copy the drive. Emptying trash If you wish to empty your trash you can use the rclone cleanup remote: command which will permanently delete all your trashed files. This command does not take any path arguments. Note that Google Drive takes some time (minutes to days) to empty the trash even though the command returns within a few seconds. No output is echoed, so there will be no confirmation even using -v or -vv. Quota information To view your current quota you can use the rclone about remote: command which will display your usage limit (quota), the usage in Google Drive, the size of all files in the Trash and the space used by other Google services such as Gmail. This command does not take any path arguments. Import/Export of google documents Google documents can be exported from and uploaded to Google Drive. When rclone downloads a Google doc it chooses a format to download depending upon the --drive-export-formats setting. By default the export formats are docx,xlsx,pptx,svg which are a sensible default for an editable document. When choosing a format, rclone runs down the list provided in order and chooses the first file format the doc can be exported as from the list. If the file can't be exported to a format on the formats list, then rclone will choose a format from the default list. If you prefer an archive copy then you might use --drive-export-formats pdf, or if you prefer openoffice/libreoffice formats you might use --drive-export-formats ods,odt,odp. Note that rclone adds the extension to the google doc, so if it is called My Spreadsheet on google docs, it will be exported as My Spreadsheet.xlsx or My Spreadsheet.pdf etc. When importing files into Google Drive, rclone will convert all files with an extension in --drive-import-formats to their associated document type. rclone will not convert any files by default, since the conversion is lossy process. The conversion must result in a file with the same extension when the --drive-export-formats rules are applied to the uploaded document. Here are some examples for allowed and prohibited conversions. ------------------------------------------------------------------------- export-formats import-formats Upload Ext Document Ext Allowed ----------------- ----------------- ------------ -------------- --------- odt odt odt odt Yes odt docx,odt odt odt Yes docx docx docx Yes odt odt docx No odt,docx docx,odt docx odt No docx,odt docx,odt docx docx Yes docx,odt docx,odt odt docx No ------------------------------------------------------------------------- This limitation can be disabled by specifying --drive-allow-import-name-change. When using this flag, rclone can convert multiple files types resulting in the same document type at once, e.g. with --drive-import-formats docx,odt,txt, all files having these extension would result in a document represented as a docx file. This brings the additional risk of overwriting a document, if multiple files have the same stem. Many rclone operations will not handle this name change in any way. They assume an equal name when copying files and might copy the file again or delete them when the name changes. Here are the possible export extensions with their corresponding mime types. Most of these can also be used for importing, but there more that are not listed here. Some of these additional ones might only be available when the operating system provides the correct MIME type entries. This list can be changed by Google Drive at any time and might not represent the currently available conversions. -------------------------------------------------------------------------------------------------------------------------- Extension Mime Type Description ------------------- --------------------------------------------------------------------------- -------------------------- bmp image/bmp Windows Bitmap format csv text/csv Standard CSV format for Spreadsheets doc application/msword Classic Word file docx application/vnd.openxmlformats-officedocument.wordprocessingml.document Microsoft Office Document epub application/epub+zip E-book format html text/html An HTML Document jpg image/jpeg A JPEG Image File json application/vnd.google-apps.script+json JSON Text Format for Google Apps scripts md text/markdown Markdown Text Format odp application/vnd.oasis.opendocument.presentation Openoffice Presentation ods application/vnd.oasis.opendocument.spreadsheet Openoffice Spreadsheet ods application/x-vnd.oasis.opendocument.spreadsheet Openoffice Spreadsheet odt application/vnd.oasis.opendocument.text Openoffice Document pdf application/pdf Adobe PDF Format pjpeg image/pjpeg Progressive JPEG Image png image/png PNG Image Format pptx application/vnd.openxmlformats-officedocument.presentationml.presentation Microsoft Office Powerpoint rtf application/rtf Rich Text Format svg image/svg+xml Scalable Vector Graphics Format tsv text/tab-separated-values Standard TSV format for spreadsheets txt text/plain Plain Text wmf application/x-msmetafile Windows Meta File xls application/vnd.ms-excel Classic Excel file xlsx application/vnd.openxmlformats-officedocument.spreadsheetml.sheet Microsoft Office Spreadsheet zip application/zip A ZIP file of HTML, Images CSS -------------------------------------------------------------------------------------------------------------------------- Google documents can also be exported as link files. These files will open a browser window for the Google Docs website of that document when opened. The link file extension has to be specified as a --drive-export-formats parameter. They will match all available Google Documents. Extension Description OS Support ----------- ----------------------------------------- ---------------- desktop freedesktop.org specified desktop entry Linux link.html An HTML Document with a redirect All url INI style link file macOS, Windows webloc macOS specific XML format macOS Standard options Here are the Standard options specific to drive (Google Drive). --drive-client-id Google Application Client Id Setting your own is recommended. See https://rclone.org/drive/#making-your-own-client-id for how to create your own. If you leave this blank, it will use an internal key which is low performance. Properties: - Config: client_id - Env Var: RCLONE_DRIVE_CLIENT_ID - Type: string - Required: false --drive-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_DRIVE_CLIENT_SECRET - Type: string - Required: false --drive-scope Comma separated list of scopes that rclone should use when requesting access from drive. Properties: - Config: scope - Env Var: RCLONE_DRIVE_SCOPE - Type: string - Required: false - Examples: - "drive" - Full access all files, excluding Application Data Folder. - "drive.readonly" - Read-only access to file metadata and file contents. - "drive.file" - Access to files created by rclone only. - These are visible in the drive website. - File authorization is revoked when the user deauthorizes the app. - "drive.appfolder" - Allows read and write access to the Application Data folder. - This is not visible in the drive website. - "drive.metadata.readonly" - Allows read-only access to file metadata but - does not allow any access to read or download file content. --drive-service-account-file Service Account Credentials JSON file path. Leave blank normally. Needed only if you want use SA instead of interactive login. Leading ~ will be expanded in the file name as will environment variables such as ${RCLONE_CONFIG_DIR}. Properties: - Config: service_account_file - Env Var: RCLONE_DRIVE_SERVICE_ACCOUNT_FILE - Type: string - Required: false --drive-alternate-export Deprecated: No longer needed. Properties: - Config: alternate_export - Env Var: RCLONE_DRIVE_ALTERNATE_EXPORT - Type: bool - Default: false Advanced options Here are the Advanced options specific to drive (Google Drive). --drive-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_DRIVE_TOKEN - Type: string - Required: false --drive-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_DRIVE_AUTH_URL - Type: string - Required: false --drive-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_DRIVE_TOKEN_URL - Type: string - Required: false --drive-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_DRIVE_CLIENT_CREDENTIALS - Type: bool - Default: false --drive-root-folder-id ID of the root folder. Leave blank normally. Fill in to access "Computers" folders (see docs), or for rclone to use a non root folder as its starting point. Properties: - Config: root_folder_id - Env Var: RCLONE_DRIVE_ROOT_FOLDER_ID - Type: string - Required: false --drive-service-account-credentials Service Account Credentials JSON blob. Leave blank normally. Needed only if you want use SA instead of interactive login. Properties: - Config: service_account_credentials - Env Var: RCLONE_DRIVE_SERVICE_ACCOUNT_CREDENTIALS - Type: string - Required: false --drive-team-drive ID of the Shared Drive (Team Drive). Properties: - Config: team_drive - Env Var: RCLONE_DRIVE_TEAM_DRIVE - Type: string - Required: false --drive-auth-owner-only Only consider files owned by the authenticated user. Properties: - Config: auth_owner_only - Env Var: RCLONE_DRIVE_AUTH_OWNER_ONLY - Type: bool - Default: false --drive-use-trash Send files to the trash instead of deleting permanently. Defaults to true, namely sending files to the trash. Use --drive-use-trash=false to delete files permanently instead. Properties: - Config: use_trash - Env Var: RCLONE_DRIVE_USE_TRASH - Type: bool - Default: true --drive-copy-shortcut-content Server side copy contents of shortcuts instead of the shortcut. When doing server side copies, normally rclone will copy shortcuts as shortcuts. If this flag is used then rclone will copy the contents of shortcuts rather than shortcuts themselves when doing server side copies. Properties: - Config: copy_shortcut_content - Env Var: RCLONE_DRIVE_COPY_SHORTCUT_CONTENT - Type: bool - Default: false --drive-skip-gdocs Skip google documents in all listings. If given, gdocs practically become invisible to rclone. Properties: - Config: skip_gdocs - Env Var: RCLONE_DRIVE_SKIP_GDOCS - Type: bool - Default: false --drive-show-all-gdocs Show all Google Docs including non-exportable ones in listings. If you try a server side copy on a Google Form without this flag, you will get this error: No export formats found for "application/vnd.google-apps.form" However adding this flag will allow the form to be server side copied. Note that rclone doesn't add extensions to the Google Docs file names in this mode. Do not use this flag when trying to download Google Docs - rclone will fail to download them. Properties: - Config: show_all_gdocs - Env Var: RCLONE_DRIVE_SHOW_ALL_GDOCS - Type: bool - Default: false --drive-skip-checksum-gphotos Skip checksums on Google photos and videos only. Use this if you get checksum errors when transferring Google photos or videos. Setting this flag will cause Google photos and videos to return a blank checksums. Google photos are identified by being in the "photos" space. Corrupted checksums are caused by Google modifying the image/video but not updating the checksum. Properties: - Config: skip_checksum_gphotos - Env Var: RCLONE_DRIVE_SKIP_CHECKSUM_GPHOTOS - Type: bool - Default: false --drive-shared-with-me Only show files that are shared with me. Instructs rclone to operate on your "Shared with me" folder (where Google Drive lets you access the files and folders others have shared with you). This works both with the "list" (lsd, lsl, etc.) and the "copy" commands (copy, sync, etc.), and with all other commands too. Properties: - Config: shared_with_me - Env Var: RCLONE_DRIVE_SHARED_WITH_ME - Type: bool - Default: false --drive-trashed-only Only show files that are in the trash. This will show trashed files in their original directory structure. Properties: - Config: trashed_only - Env Var: RCLONE_DRIVE_TRASHED_ONLY - Type: bool - Default: false --drive-starred-only Only show files that are starred. Properties: - Config: starred_only - Env Var: RCLONE_DRIVE_STARRED_ONLY - Type: bool - Default: false --drive-formats Deprecated: See export_formats. Properties: - Config: formats - Env Var: RCLONE_DRIVE_FORMATS - Type: string - Required: false --drive-export-formats Comma separated list of preferred formats for downloading Google docs. Properties: - Config: export_formats - Env Var: RCLONE_DRIVE_EXPORT_FORMATS - Type: string - Default: "docx,xlsx,pptx,svg" --drive-import-formats Comma separated list of preferred formats for uploading Google docs. Properties: - Config: import_formats - Env Var: RCLONE_DRIVE_IMPORT_FORMATS - Type: string - Required: false --drive-allow-import-name-change Allow the filetype to change when uploading Google docs. E.g. file.doc to file.docx. This will confuse sync and reupload every time. Properties: - Config: allow_import_name_change - Env Var: RCLONE_DRIVE_ALLOW_IMPORT_NAME_CHANGE - Type: bool - Default: false --drive-use-created-date Use file created date instead of modified date. Useful when downloading data and you want the creation date used in place of the last modified date. WARNING: This flag may have some unexpected consequences. When uploading to your drive all files will be overwritten unless they haven't been modified since their creation. And the inverse will occur while downloading. This side effect can be avoided by using the "--checksum" flag. This feature was implemented to retain photos capture date as recorded by google photos. You will first need to check the "Create a Google Photos folder" option in your google drive settings. You can then copy or move the photos locally and use the date the image was taken (created) set as the modification date. Properties: - Config: use_created_date - Env Var: RCLONE_DRIVE_USE_CREATED_DATE - Type: bool - Default: false --drive-use-shared-date Use date file was shared instead of modified date. Note that, as with "--drive-use-created-date", this flag may have unexpected consequences when uploading/downloading files. If both this flag and "--drive-use-created-date" are set, the created date is used. Properties: - Config: use_shared_date - Env Var: RCLONE_DRIVE_USE_SHARED_DATE - Type: bool - Default: false --drive-list-chunk Size of listing chunk 100-1000, 0 to disable. Properties: - Config: list_chunk - Env Var: RCLONE_DRIVE_LIST_CHUNK - Type: int - Default: 1000 --drive-impersonate Impersonate this user when using a service account. Properties: - Config: impersonate - Env Var: RCLONE_DRIVE_IMPERSONATE - Type: string - Required: false --drive-upload-cutoff Cutoff for switching to chunked upload. Properties: - Config: upload_cutoff - Env Var: RCLONE_DRIVE_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 8Mi --drive-chunk-size Upload chunk size. Must a power of 2 >= 256k. Making this larger will improve performance, but note that each chunk is buffered in memory one per transfer. Reducing this will reduce memory usage but decrease performance. Properties: - Config: chunk_size - Env Var: RCLONE_DRIVE_CHUNK_SIZE - Type: SizeSuffix - Default: 8Mi --drive-acknowledge-abuse Set to allow files which return cannotDownloadAbusiveFile to be downloaded. If downloading a file returns the error "This file has been identified as malware or spam and cannot be downloaded" with the error code "cannotDownloadAbusiveFile" then supply this flag to rclone to indicate you acknowledge the risks of downloading the file and rclone will download it anyway. Note that if you are using service account it will need Manager permission (not Content Manager) to for this flag to work. If the SA does not have the right permission, Google will just ignore the flag. Properties: - Config: acknowledge_abuse - Env Var: RCLONE_DRIVE_ACKNOWLEDGE_ABUSE - Type: bool - Default: false --drive-keep-revision-forever Keep new head revision of each file forever. Properties: - Config: keep_revision_forever - Env Var: RCLONE_DRIVE_KEEP_REVISION_FOREVER - Type: bool - Default: false --drive-size-as-quota Show sizes as storage quota usage, not actual size. Show the size of a file as the storage quota used. This is the current version plus any older versions that have been set to keep forever. WARNING: This flag may have some unexpected consequences. It is not recommended to set this flag in your config - the recommended usage is using the flag form --drive-size-as-quota when doing rclone ls/lsl/lsf/lsjson/etc only. If you do use this flag for syncing (not recommended) then you will need to use --ignore size also. Properties: - Config: size_as_quota - Env Var: RCLONE_DRIVE_SIZE_AS_QUOTA - Type: bool - Default: false --drive-v2-download-min-size If Object's are greater, use drive v2 API to download. Properties: - Config: v2_download_min_size - Env Var: RCLONE_DRIVE_V2_DOWNLOAD_MIN_SIZE - Type: SizeSuffix - Default: off --drive-pacer-min-sleep Minimum time to sleep between API calls. Properties: - Config: pacer_min_sleep - Env Var: RCLONE_DRIVE_PACER_MIN_SLEEP - Type: Duration - Default: 100ms --drive-pacer-burst Number of API calls to allow without sleeping. Properties: - Config: pacer_burst - Env Var: RCLONE_DRIVE_PACER_BURST - Type: int - Default: 100 --drive-server-side-across-configs Deprecated: use --server-side-across-configs instead. Allow server-side operations (e.g. copy) to work across different drive configs. This can be useful if you wish to do a server-side copy between two different Google drives. Note that this isn't enabled by default because it isn't easy to tell if it will work between any two configurations. Properties: - Config: server_side_across_configs - Env Var: RCLONE_DRIVE_SERVER_SIDE_ACROSS_CONFIGS - Type: bool - Default: false --drive-disable-http2 Disable drive using http2. There is currently an unsolved issue with the google drive backend and HTTP/2. HTTP/2 is therefore disabled by default for the drive backend but can be re-enabled here. When the issue is solved this flag will be removed. See: https://github.com/rclone/rclone/issues/3631 Properties: - Config: disable_http2 - Env Var: RCLONE_DRIVE_DISABLE_HTTP2 - Type: bool - Default: true --drive-stop-on-upload-limit Make upload limit errors be fatal. At the time of writing it is only possible to upload 750 GiB of data to Google Drive a day (this is an undocumented limit). When this limit is reached Google Drive produces a slightly different error message. When this flag is set it causes these errors to be fatal. These will stop the in-progress sync. Note that this detection is relying on error message strings which Google don't document so it may break in the future. See: https://github.com/rclone/rclone/issues/3857 Properties: - Config: stop_on_upload_limit - Env Var: RCLONE_DRIVE_STOP_ON_UPLOAD_LIMIT - Type: bool - Default: false --drive-stop-on-download-limit Make download limit errors be fatal. At the time of writing it is only possible to download 10 TiB of data from Google Drive a day (this is an undocumented limit). When this limit is reached Google Drive produces a slightly different error message. When this flag is set it causes these errors to be fatal. These will stop the in-progress sync. Note that this detection is relying on error message strings which Google don't document so it may break in the future. Properties: - Config: stop_on_download_limit - Env Var: RCLONE_DRIVE_STOP_ON_DOWNLOAD_LIMIT - Type: bool - Default: false --drive-skip-shortcuts If set skip shortcut files. Normally rclone dereferences shortcut files making them appear as if they are the original file (see the shortcuts section). If this flag is set then rclone will ignore shortcut files completely. Properties: - Config: skip_shortcuts - Env Var: RCLONE_DRIVE_SKIP_SHORTCUTS - Type: bool - Default: false --drive-skip-dangling-shortcuts If set skip dangling shortcut files. If this is set then rclone will not show any dangling shortcuts in listings. Properties: - Config: skip_dangling_shortcuts - Env Var: RCLONE_DRIVE_SKIP_DANGLING_SHORTCUTS - Type: bool - Default: false --drive-resource-key Resource key for accessing a link-shared file. If you need to access files shared with a link like this https://drive.google.com/drive/folders/XXX?resourcekey=YYY&usp=sharing Then you will need to use the first part "XXX" as the "root_folder_id" and the second part "YYY" as the "resource_key" otherwise you will get 404 not found errors when trying to access the directory. See: https://developers.google.com/drive/api/guides/resource-keys This resource key requirement only applies to a subset of old files. Note also that opening the folder once in the web interface (with the user you've authenticated rclone with) seems to be enough so that the resource key is not needed. Properties: - Config: resource_key - Env Var: RCLONE_DRIVE_RESOURCE_KEY - Type: string - Required: false --drive-fast-list-bug-fix Work around a bug in Google Drive listing. Normally rclone will work around a bug in Google Drive when using --fast-list (ListR) where the search "(A in parents) or (B in parents)" returns nothing sometimes. See #3114, #4289 and https://issuetracker.google.com/issues/149522397 Rclone detects this by finding no items in more than one directory when listing and retries them as lists of individual directories. This means that if you have a lot of empty directories rclone will end up listing them all individually and this can take many more API calls. This flag allows the work-around to be disabled. This is not recommended in normal use - only if you have a particular case you are having trouble with like many empty directories. Properties: - Config: fast_list_bug_fix - Env Var: RCLONE_DRIVE_FAST_LIST_BUG_FIX - Type: bool - Default: true --drive-metadata-owner Control whether owner should be read or written in metadata. Owner is a standard part of the file metadata so is easy to read. But it isn't always desirable to set the owner from the metadata. Note that you can't set the owner on Shared Drives, and that setting ownership will generate an email to the new owner (this can't be disabled), and you can't transfer ownership to someone outside your organization. Properties: - Config: metadata_owner - Env Var: RCLONE_DRIVE_METADATA_OWNER - Type: Bits - Default: read - Examples: - "off" - Do not read or write the value - "read" - Read the value only - "write" - Write the value only - "failok" - If writing fails log errors only, don't fail the transfer - "read,write" - Read and Write the value. --drive-metadata-permissions Control whether permissions should be read or written in metadata. Reading permissions metadata from files can be done quickly, but it isn't always desirable to set the permissions from the metadata. Note that rclone drops any inherited permissions on Shared Drives and any owner permission on My Drives as these are duplicated in the owner metadata. Properties: - Config: metadata_permissions - Env Var: RCLONE_DRIVE_METADATA_PERMISSIONS - Type: Bits - Default: off - Examples: - "off" - Do not read or write the value - "read" - Read the value only - "write" - Write the value only - "failok" - If writing fails log errors only, don't fail the transfer - "read,write" - Read and Write the value. --drive-metadata-labels Control whether labels should be read or written in metadata. Reading labels metadata from files takes an extra API transaction and will slow down listings. It isn't always desirable to set the labels from the metadata. The format of labels is documented in the drive API documentation at https://developers.google.com/drive/api/reference/rest/v3/Label - rclone just provides a JSON dump of this format. When setting labels, the label and fields must already exist - rclone will not create them. This means that if you are transferring labels from two different accounts you will have to create the labels in advance and use the metadata mapper to translate the IDs between the two accounts. Properties: - Config: metadata_labels - Env Var: RCLONE_DRIVE_METADATA_LABELS - Type: Bits - Default: off - Examples: - "off" - Do not read or write the value - "read" - Read the value only - "write" - Write the value only - "failok" - If writing fails log errors only, don't fail the transfer - "read,write" - Read and Write the value. --drive-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_DRIVE_ENCODING - Type: Encoding - Default: InvalidUtf8 --drive-env-auth Get IAM credentials from runtime (environment variables or instance meta data if no env vars). Only applies if service_account_file and service_account_credentials is blank. Properties: - Config: env_auth - Env Var: RCLONE_DRIVE_ENV_AUTH - Type: bool - Default: false - Examples: - "false" - Enter credentials in the next step. - "true" - Get GCP IAM credentials from the environment (env vars or IAM). --drive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_DRIVE_DESCRIPTION - Type: string - Required: false Metadata User metadata is stored in the properties field of the drive object. Metadata is supported on files and directories. Here are the possible system metadata items for the drive backend. ---------------------------------------------------------------------------------------------------------------------------------- Name Help Type Example Read Only --------------------------------- ------------------------------- ----------- ------------------------------- -------------------- btime Time of file birth (creation) RFC 3339 2006-01-02T15:04:05.999Z07:00 N with mS accuracy. Note that this is only writable on fresh uploads - it can't be written for updates. content-type The MIME type of the file. string text/plain N copy-requires-writer-permission Whether the options to copy, boolean true N print, or download this file, should be disabled for readers and commenters. description A short description of the string Contract for signing N file. folder-color-rgb The color for a folder or a string 881133 N shortcut to a folder as an RGB hex string. labels Labels attached to this file in JSON [] N a JSON dump of Googled drive format. Enable with --drive-metadata-labels. mtime Time of last modification with RFC 3339 2006-01-02T15:04:05.999Z07:00 N mS accuracy. owner The owner of the file. Usually string user@example.com N an email address. Enable with --drive-metadata-owner. permissions Permissions in a JSON dump of JSON {} N Google drive format. On shared drives these will only be present if they aren't inherited. Enable with --drive-metadata-permissions. starred Whether the user has starred boolean false N the file. viewed-by-me Whether the file has been boolean true Y viewed by this user. writers-can-share Whether users with only writer boolean false N permission can modify the file's permissions. Not populated and ignored when setting for items in shared drives. ---------------------------------------------------------------------------------------------------------------------------------- See the metadata docs for more info. Backend commands Here are the commands specific to the drive backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the backend command for more info on how to pass options and arguments. These can be run on a running backend using the rc command backend/command. get Get command for fetching the drive config parameters rclone backend get remote: [options] [+] This is a get command which will be used to fetch the various drive config parameters Usage Examples: rclone backend get drive: [-o service_account_file] [-o chunk_size] rclone rc backend/command command=get fs=drive: [-o service_account_file] [-o chunk_size] Options: - "chunk_size": show the current upload chunk size - "service_account_file": show the current service account file set Set command for updating the drive config parameters rclone backend set remote: [options] [+] This is a set command which will be used to update the various drive config parameters Usage Examples: rclone backend set drive: [-o service_account_file=sa.json] [-o chunk_size=67108864] rclone rc backend/command command=set fs=drive: [-o service_account_file=sa.json] [-o chunk_size=67108864] Options: - "chunk_size": update the current upload chunk size - "service_account_file": update the current service account file shortcut Create shortcuts from files or directories rclone backend shortcut remote: [options] [+] This command creates shortcuts from files or directories. Usage: rclone backend shortcut drive: source_item destination_shortcut rclone backend shortcut drive: source_item -o target=drive2: destination_shortcut In the first example this creates a shortcut from the "source_item" which can be a file or a directory to the "destination_shortcut". The "source_item" and the "destination_shortcut" should be relative paths from "drive:" In the second example this creates a shortcut from the "source_item" relative to "drive:" to the "destination_shortcut" relative to "drive2:". This may fail with a permission error if the user authenticated with "drive2:" can't read files from "drive:". Options: - "target": optional target remote for the shortcut destination drives List the Shared Drives available to this account rclone backend drives remote: [options] [+] This command lists the Shared Drives (Team Drives) available to this account. Usage: rclone backend [-o config] drives drive: This will return a JSON list of objects like this [ { "id": "0ABCDEF-01234567890", "kind": "drive#teamDrive", "name": "My Drive" }, { "id": "0ABCDEFabcdefghijkl", "kind": "drive#teamDrive", "name": "Test Drive" } ] With the -o config parameter it will output the list in a format suitable for adding to a config file to make aliases for all the drives found and a combined drive. [My Drive] type = alias remote = drive,team_drive=0ABCDEF-01234567890,root_folder_id=: [Test Drive] type = alias remote = drive,team_drive=0ABCDEFabcdefghijkl,root_folder_id=: [AllDrives] type = combine upstreams = "My Drive=My Drive:" "Test Drive=Test Drive:" Adding this to the rclone config file will cause those team drives to be accessible with the aliases shown. Any illegal characters will be substituted with "_" and duplicate names will have numbers suffixed. It will also add a remote called AllDrives which shows all the shared drives combined into one directory tree. untrash Untrash files and directories rclone backend untrash remote: [options] [+] This command untrashes all the files and directories in the directory passed in recursively. Usage: This takes an optional directory to trash which make this easier to use via the API. rclone backend untrash drive:directory rclone backend --interactive untrash drive:directory subdir Use the --interactive/-i or --dry-run flag to see what would be restored before restoring it. Result: { "Untrashed": 17, "Errors": 0 } copyid Copy files by ID rclone backend copyid remote: [options] [+] This command copies files by ID Usage: rclone backend copyid drive: ID path rclone backend copyid drive: ID1 path1 ID2 path2 It copies the drive file with ID given to the path (an rclone path which will be passed internally to rclone copyto). The ID and path pairs can be repeated. The path should end with a / to indicate copy the file as named to this directory. If it doesn't end with a / then the last path component will be used as the file name. If the destination is a drive backend then server-side copying will be attempted if possible. Use the --interactive/-i or --dry-run flag to see what would be copied before copying. moveid Move files by ID rclone backend moveid remote: [options] [+] This command moves files by ID Usage: rclone backend moveid drive: ID path rclone backend moveid drive: ID1 path1 ID2 path2 It moves the drive file with ID given to the path (an rclone path which will be passed internally to rclone moveto). The path should end with a / to indicate move the file as named to this directory. If it doesn't end with a / then the last path component will be used as the file name. If the destination is a drive backend then server-side moving will be attempted if possible. Use the --interactive/-i or --dry-run flag to see what would be moved beforehand. exportformats Dump the export formats for debug purposes rclone backend exportformats remote: [options] [+] importformats Dump the import formats for debug purposes rclone backend importformats remote: [options] [+] query List files using Google Drive query language rclone backend query remote: [options] [+] This command lists files based on a query Usage: rclone backend query drive: query The query syntax is documented at Google Drive Search query terms and operators. For example: rclone backend query drive: "'0ABc9DEFGHIJKLMNop0QRatUVW3X' in parents and name contains 'foo'" If the query contains literal ' or  characters, these need to be escaped with  characters. "'" becomes "'" and "" becomes "\", for example to match a file named "foo ' .txt": rclone backend query drive: "name = 'foo \' \\\.txt'" The result is a JSON array of matches, for example: [ { "createdTime": "2017-06-29T19:58:28.537Z", "id": "0AxBe_CDEF4zkGHI4d0FjYko2QkD", "md5Checksum": "68518d16be0c6fbfab918be61d658032", "mimeType": "text/plain", "modifiedTime": "2024-02-02T10:40:02.874Z", "name": "foo ' \\.txt", "parents": [ "0BxAe_BCDE4zkFGZpcWJGek0xbzC" ], "resourceKey": "0-ABCDEFGHIXJQpIGqBJq3MC", "sha1Checksum": "8f284fa768bfb4e45d076a579ab3905ab6bfa893", "size": "311", "webViewLink": "https://drive.google.com/file/d/0AxBe_CDEF4zkGHI4d0FjYko2QkD/view?usp=drivesdk\u0026resourcekey=0-ABCDEFGHIXJQpIGqBJq3MC" } ] rescue Rescue or delete any orphaned files rclone backend rescue remote: [options] [+] This command rescues or deletes any orphaned files or directories. Sometimes files can get orphaned in Google Drive. This means that they are no longer in any folder in Google Drive. This command finds those files and either rescues them to a directory you specify or deletes them. Usage: This can be used in 3 ways. First, list all orphaned files rclone backend rescue drive: Second rescue all orphaned files to the directory indicated rclone backend rescue drive: "relative/path/to/rescue/directory" e.g. To rescue all orphans to a directory called "Orphans" in the top level rclone backend rescue drive: Orphans Third delete all orphaned files to the trash rclone backend rescue drive: -o delete Limitations Drive has quite a lot of rate limiting. This causes rclone to be limited to transferring about 2 files per second only. Individual files may be transferred much faster at 100s of MiB/s but lots of small files can take a long time. Server side copies are also subject to a separate rate limit. If you see User rate limit exceeded errors, wait at least 24 hours and retry. You can disable server-side copies with --disable copy to download and upload the files if you prefer. Limitations of Google Docs Google docs will appear as size -1 in rclone ls, rclone ncdu etc, and as size 0 in anything which uses the VFS layer, e.g. rclone mount and rclone serve. When calculating directory totals, e.g. in rclone size and rclone ncdu, they will be counted in as empty files. This is because rclone can't find out the size of the Google docs without downloading them. Google docs will transfer correctly with rclone sync, rclone copy etc as rclone knows to ignore the size when doing the transfer. However an unfortunate consequence of this is that you may not be able to download Google docs using rclone mount. If it doesn't work you will get a 0 sized file. If you try again the doc may gain its correct size and be downloadable. Whether it will work on not depends on the application accessing the mount and the OS you are running - experiment to find out if it does work for you! Duplicated files Sometimes, for no reason I've been able to track down, drive will duplicate a file that rclone uploads. Drive unlike all the other remotes can have duplicated files. Duplicated files cause problems with the syncing and you will see messages in the log about duplicates. Use rclone dedupe to fix duplicated files. Note that this isn't just a problem with rclone, even Google Photos on Android duplicates files on drive sometimes. Rclone appears to be re-copying files it shouldn't The most likely cause of this is the duplicated file issue above - run rclone dedupe and check your logs for duplicate object or directory messages. This can also be caused by a delay/caching on google drive's end when comparing directory listings. Specifically with team drives used in combination with --fast-list. Files that were uploaded recently may not appear on the directory list sent to rclone when using --fast-list. Waiting a moderate period of time between attempts (estimated to be approximately 1 hour) and/or not using --fast-list both seem to be effective in preventing the problem. SHA1 or SHA256 hashes may be missing All files have MD5 hashes, but a small fraction of files uploaded may not have SHA1 or SHA256 hashes especially if they were uploaded before 2018. Making your own client_id When you use rclone with Google drive in its default configuration you are using rclone's client_id. This is shared between all the rclone users. There is a global rate limit on the number of queries per second that each client_id can do set by Google. rclone already has a high quota and I will continue to make sure it is high enough by contacting Google. It is strongly recommended to use your own client ID as the default rclone ID is heavily used. If you have multiple services running, it is recommended to use an API key for each service. The default Google quota is 10 transactions per second so it is recommended to stay under that number as if you use more than that, it will cause rclone to rate limit and make things slower. Here is how to create your own Google Drive client ID for rclone: 1. Log into the Google API Console with your Google account. It doesn't matter what Google account you use. (It need not be the same account as the Google Drive you want to access) 2. Select a project or create a new project. 3. Under "ENABLE APIS AND SERVICES" search for "Drive", and enable the "Google Drive API". 4. Click "Credentials" in the left-side panel (not "Create credentials", which opens the wizard). 5. If you already configured an "Oauth Consent Screen", then skip to the next step; if not, click on "CONFIGURE CONSENT SCREEN" button (near the top right corner of the right panel), then select "External" and click on "CREATE"; on the next screen, enter an "Application name" ("rclone" is OK); enter "User Support Email" (your own email is OK); enter "Developer Contact Email" (your own email is OK); then click on "Save" (all other data is optional). You will also have to add some scopes, including - https://www.googleapis.com/auth/docs - https://www.googleapis.com/auth/drive in order to be able to edit, create and delete files with RClone. - https://www.googleapis.com/auth/drive.metadata.readonly which you may also want to add. - If you want to add all at once, comma separated it would be https://www.googleapis.com/auth/docs,https://www.googleapis.com/auth/drive,https://www.googleapis.com/auth/drive.metadata.readonly. 6. After adding scopes, click "Save and continue" to add test users. Be sure to add your own account to the test users. Once you've added yourself as a test user and saved the changes, click again on "Credentials" on the left panel to go back to the "Credentials" screen. (PS: if you are a GSuite user, you could also select "Internal" instead of "External" above, but this will restrict API use to Google Workspace users in your organisation). 7. Click on the "+ CREATE CREDENTIALS" button at the top of the screen, then select "OAuth client ID". 8. Choose an application type of "Desktop app" and click "Create". (the default name is fine) 9. It will show you a client ID and client secret. Make a note of these. (If you selected "External" at Step 5 continue to Step 10. If you chose "Internal" you don't need to publish and can skip straight to Step 11 but your destination drive must be part of the same Google Workspace.) 10. Go to "Oauth consent screen" and then click "PUBLISH APP" button and confirm. You will also want to add yourself as a test user. 11. Provide the noted client ID and client secret to rclone. Be aware that, due to the "enhanced security" recently introduced by Google, you are theoretically expected to "submit your app for verification" and then wait a few weeks(!) for their response; in practice, you can go right ahead and use the client ID and client secret with rclone, the only issue will be a very scary confirmation screen shown when you connect via your browser for rclone to be able to get its token-id (but as this only happens during the remote configuration, it's not such a big deal). Keeping the application in "Testing" will work as well, but the limitation is that any grants will expire after a week, which can be annoying to refresh constantly. If, for whatever reason, a short grant time is not a problem, then keeping the application in testing mode would also be sufficient. (Thanks to @balazer on github for these instructions.) Sometimes, creation of an OAuth consent in Google API Console fails due to an error message “The request failed because changes to one of the field of the resource is not supported”. As a convenient workaround, the necessary Google Drive API key can be created on the Python Quickstart page. Just push the Enable the Drive API button to receive the Client ID and Secret. Note that it will automatically create a new project in the API Console. Google Photos The rclone backend for Google Photos is a specialized backend for transferring photos and videos to and from Google Photos. NB The Google Photos API which rclone uses has quite a few limitations, so please read the limitations section carefully to make sure it is suitable for your use. NB From March 31, 2025 rclone can only download photos it uploaded. This limitation is due to policy changes at Google. You may need to run rclone config reconnect remote: to make rclone work again after upgrading to rclone v1.70. Configuration The initial setup for google cloud storage involves getting a token from Google Photos which you need to do in your browser. rclone config walks you through it. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Google Photos \ "google photos" [snip] Storage> google photos ** See help for google photos backend at: https://rclone.org/googlephotos/ ** Google Application Client Id Leave blank normally. Enter a string value. Press Enter for the default (""). client_id> Google Application Client Secret Leave blank normally. Enter a string value. Press Enter for the default (""). client_secret> Set to make the Google Photos backend read only. If you choose read only then rclone will only request read only access to your photos, otherwise rclone will request full access. Enter a boolean value (true or false). Press Enter for the default ("false"). read_only> Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code *** IMPORTANT: All media items uploaded to Google Photos with rclone *** are stored in full resolution at original quality. These uploads *** will count towards storage in your Google Account. Configuration complete. Options: - type: google photos - token: {"access_token":"XXX","token_type":"Bearer","refresh_token":"XXX","expiry":"2019-06-28T17:38:04.644930156+01:00"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y See the remote setup docs for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Google if using web browser to automatically authenticate. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this may require you to unblock it temporarily if you are running a host firewall, or use manual mode. This remote is called remote and can now be used like this See all the albums in your photos rclone lsd remote:album Make a new album rclone mkdir remote:album/newAlbum List the contents of an album rclone ls remote:album/newAlbum Sync /home/local/images to the Google Photos, removing any excess files in the album. rclone sync --interactive /home/local/image remote:album/newAlbum Layout As Google Photos is not a general purpose cloud storage system, the backend is laid out to help you navigate it. The directories under media show different ways of categorizing the media. Each file will appear multiple times. So if you want to make a backup of your google photos you might choose to backup remote:media/by-month. (NB remote:media/by-day is rather slow at the moment so avoid for syncing.) Note that all your photos and videos will appear somewhere under media, but they may not appear under album unless you've put them into albums. / - upload - file1.jpg - file2.jpg - ... - media - all - file1.jpg - file2.jpg - ... - by-year - 2000 - file1.jpg - ... - 2001 - file2.jpg - ... - ... - by-month - 2000 - 2000-01 - file1.jpg - ... - 2000-02 - file2.jpg - ... - ... - by-day - 2000 - 2000-01-01 - file1.jpg - ... - 2000-01-02 - file2.jpg - ... - ... - album - album name - album name/sub - shared-album - album name - album name/sub - feature - favorites - file1.jpg - file2.jpg There are two writable parts of the tree, the upload directory and sub directories of the album directory. The upload directory is for uploading files you don't want to put into albums. This will be empty to start with and will contain the files you've uploaded for one rclone session only, becoming empty again when you restart rclone. The use case for this would be if you have a load of files you just want to once off dump into Google Photos. For repeated syncing, uploading to album will work better. Directories within the album directory are also writeable and you may create new directories (albums) under album. If you copy files with a directory hierarchy in there then rclone will create albums with the / character in them. For example if you do rclone copy /path/to/images remote:album/images and the images directory contains images - file1.jpg dir file2.jpg dir2 dir3 file3.jpg Then rclone will create the following albums with the following files in - images - file1.jpg - images/dir - file2.jpg - images/dir2/dir3 - file3.jpg This means that you can use the album path pretty much like a normal filesystem and it is a good target for repeated syncing. The shared-album directory shows albums shared with you or by you. This is similar to the Sharing tab in the Google Photos web interface. Standard options Here are the Standard options specific to google photos (Google Photos). --gphotos-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_GPHOTOS_CLIENT_ID - Type: string - Required: false --gphotos-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_GPHOTOS_CLIENT_SECRET - Type: string - Required: false --gphotos-read-only Set to make the Google Photos backend read only. If you choose read only then rclone will only request read only access to your photos, otherwise rclone will request full access. Properties: - Config: read_only - Env Var: RCLONE_GPHOTOS_READ_ONLY - Type: bool - Default: false Advanced options Here are the Advanced options specific to google photos (Google Photos). --gphotos-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_GPHOTOS_TOKEN - Type: string - Required: false --gphotos-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_GPHOTOS_AUTH_URL - Type: string - Required: false --gphotos-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_GPHOTOS_TOKEN_URL - Type: string - Required: false --gphotos-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_GPHOTOS_CLIENT_CREDENTIALS - Type: bool - Default: false --gphotos-read-size Set to read the size of media items. Normally rclone does not read the size of media items since this takes another transaction. This isn't necessary for syncing. However rclone mount needs to know the size of files in advance of reading them, so setting this flag when using rclone mount is recommended if you want to read the media. Properties: - Config: read_size - Env Var: RCLONE_GPHOTOS_READ_SIZE - Type: bool - Default: false --gphotos-start-year Year limits the photos to be downloaded to those which are uploaded after the given year. Properties: - Config: start_year - Env Var: RCLONE_GPHOTOS_START_YEAR - Type: int - Default: 2000 --gphotos-include-archived Also view and download archived media. By default, rclone does not request archived media. Thus, when syncing, archived media is not visible in directory listings or transferred. Note that media in albums is always visible and synced, no matter their archive status. With this flag, archived media are always visible in directory listings and transferred. Without this flag, archived media will not be visible in directory listings and won't be transferred. Properties: - Config: include_archived - Env Var: RCLONE_GPHOTOS_INCLUDE_ARCHIVED - Type: bool - Default: false --gphotos-proxy Use the gphotosdl proxy for downloading the full resolution images The Google API will deliver images and video which aren't full resolution, and/or have EXIF data missing. However if you use the gphotosdl proxy then you can download original, unchanged images. This runs a headless browser in the background. Download the software from gphotosdl First run with gphotosdl -login Then once you have logged into google photos close the browser window and run gphotosdl Then supply the parameter --gphotos-proxy "http://localhost:8282" to make rclone use the proxy. Properties: - Config: proxy - Env Var: RCLONE_GPHOTOS_PROXY - Type: string - Required: false --gphotos-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_GPHOTOS_ENCODING - Type: Encoding - Default: Slash,CrLf,InvalidUtf8,Dot --gphotos-batch-mode Upload file batching sync|async|off. This sets the batch mode used by rclone. This has 3 possible values - off - no batching - sync - batch uploads and check completion (default) - async - batch upload and don't check completion Rclone will close any outstanding batches when it exits which may make a delay on quit. Properties: - Config: batch_mode - Env Var: RCLONE_GPHOTOS_BATCH_MODE - Type: string - Default: "sync" --gphotos-batch-size Max number of files in upload batch. This sets the batch size of files to upload. It has to be less than 50. By default this is 0 which means rclone will calculate the batch size depending on the setting of batch_mode. - batch_mode: async - default batch_size is 50 - batch_mode: sync - default batch_size is the same as --transfers - batch_mode: off - not in use Rclone will close any outstanding batches when it exits which may make a delay on quit. Setting this is a great idea if you are uploading lots of small files as it will make them a lot quicker. You can use --transfers 32 to maximise throughput. Properties: - Config: batch_size - Env Var: RCLONE_GPHOTOS_BATCH_SIZE - Type: int - Default: 0 --gphotos-batch-timeout Max time to allow an idle upload batch before uploading. If an upload batch is idle for more than this long then it will be uploaded. The default for this is 0 which means rclone will choose a sensible default based on the batch_mode in use. - batch_mode: async - default batch_timeout is 10s - batch_mode: sync - default batch_timeout is 1s - batch_mode: off - not in use Properties: - Config: batch_timeout - Env Var: RCLONE_GPHOTOS_BATCH_TIMEOUT - Type: Duration - Default: 0s --gphotos-batch-commit-timeout Max time to wait for a batch to finish committing. (no longer used) Properties: - Config: batch_commit_timeout - Env Var: RCLONE_GPHOTOS_BATCH_COMMIT_TIMEOUT - Type: Duration - Default: 10m0s --gphotos-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_GPHOTOS_DESCRIPTION - Type: string - Required: false Limitations Only images and videos can be uploaded. If you attempt to upload non videos or images or formats that Google Photos doesn't understand, rclone will upload the file, then Google Photos will give an error when it is put turned into a media item. NB From March 31, 2025 rclone can only download photos it uploaded. This limitation is due to policy changes at Google. You may need to run rclone config reconnect remote: to make rclone work again after upgrading to rclone v1.70. Note that all media items uploaded to Google Photos through the API are stored in full resolution at "original quality" and will count towards your storage quota in your Google Account. The API does not offer a way to upload in "high quality" mode.. rclone about is not supported by the Google Photos backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about See rclone about Downloading Images When Images are downloaded this strips EXIF location (according to the docs and my tests). This is a limitation of the Google Photos API and is covered by bug #112096115. The current google API does not allow photos to be downloaded at original resolution. This is very important if you are, for example, relying on "Google Photos" as a backup of your photos. You will not be able to use rclone to redownload original images. You could use 'google takeout' to recover the original photos as a last resort NB you can use the --gphotos-proxy flag to use a headless browser to download images in full resolution. Downloading Videos When videos are downloaded they are downloaded in a really compressed version of the video compared to downloading it via the Google Photos web interface. This is covered by bug #113672044. NB you can use the --gphotos-proxy flag to use a headless browser to download images in full resolution. Duplicates If a file name is duplicated in a directory then rclone will add the file ID into its name. So two files called file.jpg would then appear as file {123456}.jpg and file {ABCDEF}.jpg (the actual IDs are a lot longer alas!). If you upload the same image (with the same binary data) twice then Google Photos will deduplicate it. However it will retain the filename from the first upload which may confuse rclone. For example if you uploaded an image to upload then uploaded the same image to album/my_album the filename of the image in album/my_album will be what it was uploaded with initially, not what you uploaded it with to album. In practise this shouldn't cause too many problems. Modification times The date shown of media in Google Photos is the creation date as determined by the EXIF information, or the upload date if that is not known. This is not changeable by rclone and is not the modification date of the media on local disk. This means that rclone cannot use the dates from Google Photos for syncing purposes. Size The Google Photos API does not return the size of media. This means that when syncing to Google Photos, rclone can only do a file existence check. It is possible to read the size of the media, but this needs an extra HTTP HEAD request per media item so is very slow and uses up a lot of transactions. This can be enabled with the --gphotos-read-size option or the read_size = true config parameter. If you want to use the backend with rclone mount you may need to enable this flag (depending on your OS and application using the photos) otherwise you may not be able to read media off the mount. You'll need to experiment to see if it works for you without the flag. Albums Rclone can only upload files to albums it created. This is a limitation of the Google Photos API. Rclone can remove files it uploaded from albums it created only. Deleting files Rclone can remove files from albums it created, but note that the Google Photos API does not allow media to be deleted permanently so this media will still remain. See bug #109759781. Rclone cannot delete files anywhere except under album. Deleting albums The Google Photos API does not support deleting albums - see bug #135714733. Making your own client_id When you use rclone with Google photos in its default configuration you are using rclone's client_id. This is shared between all the rclone users. There is a global rate limit on the number of queries per second that each client_id can do set by Google. If there is a problem with this client_id (eg quota too low or the client_id stops working) then you can make your own. Please follow the steps in the google drive docs. You will need these scopes instead of the drive ones detailed: https://www.googleapis.com/auth/photoslibrary.appendonly https://www.googleapis.com/auth/photoslibrary.readonly.appcreateddata https://www.googleapis.com/auth/photoslibrary.edit.appcreateddata Hasher Hasher is a special overlay backend to create remotes which handle checksums for other remotes. It's main functions include: - Emulate hash types unimplemented by backends - Cache checksums to help with slow hashing of large local or (S)FTP files - Warm up checksum cache from external SUM files Getting started To use Hasher, first set up the underlying remote following the configuration instructions for that remote. You can also use a local pathname instead of a remote. Check that your base remote is working. Let's call the base remote myRemote:path here. Note that anything inside myRemote:path will be handled by hasher and anything outside won't. This means that if you are using a bucket based remote (S3, B2, Swift) then you should put the bucket in the remote s3:bucket. Now proceed to interactive or manual configuration. Interactive configuration Run rclone config: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> Hasher1 Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Handle checksums for other remotes \ "hasher" [snip] Storage> hasher Remote to cache checksums for, like myremote:mypath. Enter a string value. Press Enter for the default (""). remote> myRemote:path Comma separated list of supported checksum types. Enter a string value. Press Enter for the default ("md5,sha1"). hashsums> md5 Maximum time to keep checksums in cache. 0 = no cache, off = cache forever. max_age> off Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config -------------------- [Hasher1] type = hasher remote = myRemote:path hashsums = md5 max_age = off -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Manual configuration Run rclone config path to see the path of current active config file, usually YOURHOME/.config/rclone/rclone.conf. Open it in your favorite text editor, find section for the base remote and create new section for hasher like in the following examples: [Hasher1] type = hasher remote = myRemote:path hashes = md5 max_age = off [Hasher2] type = hasher remote = /local/path hashes = dropbox,sha1 max_age = 24h Hasher takes basically the following parameters: - remote is required, - hashes is a comma separated list of supported checksums (by default md5,sha1), - max_age - maximum time to keep a checksum value in the cache, 0 will disable caching completely, off will cache "forever" (that is until the files get changed). Make sure the remote has : (colon) in. If you specify the remote without a colon then rclone will use a local directory of that name. So if you use a remote of /local/path then rclone will handle hashes for that directory. If you use remote = name literally then rclone will put files in a directory called name located under current directory. Usage Basic operations Now you can use it as Hasher2:subdir/file instead of base remote. Hasher will transparently update cache with new checksums when a file is fully read or overwritten, like: rclone copy External:path/file Hasher:dest/path rclone cat Hasher:path/to/file > /dev/null The way to refresh all cached checksums (even unsupported by the base backend) for a subtree is to re-download all files in the subtree. For example, use hashsum --download using any supported hashsum on the command line (we just care to re-read): rclone hashsum MD5 --download Hasher:path/to/subtree > /dev/null rclone backend dump Hasher:path/to/subtree You can print or drop hashsum cache using custom backend commands: rclone backend dump Hasher:dir/subdir rclone backend drop Hasher: Pre-Seed from a SUM File Hasher supports two backend commands: generic SUM file import and faster but less consistent stickyimport. rclone backend import Hasher:dir/subdir SHA1 /path/to/SHA1SUM [--checkers 4] Instead of SHA1 it can be any hash supported by the remote. The last argument can point to either a local or an other-remote:path text file in SUM format. The command will parse the SUM file, then walk down the path given by the first argument, snapshot current fingerprints and fill in the cache entries correspondingly. - Paths in the SUM file are treated as relative to hasher:dir/subdir. - The command will not check that supplied values are correct. You must know what you are doing. - This is a one-time action. The SUM file will not get "attached" to the remote. Cache entries can still be overwritten later, should the object's fingerprint change. - The tree walk can take long depending on the tree size. You can increase --checkers to make it faster. Or use stickyimport if you don't care about fingerprints and consistency. rclone backend stickyimport hasher:path/to/data sha1 remote:/path/to/sum.sha1 stickyimport is similar to import but works much faster because it does not need to stat existing files and skips initial tree walk. Instead of binding cache entries to file fingerprints it creates sticky entries bound to the file name alone ignoring size, modification time etc. Such hash entries can be replaced only by purge, delete, backend drop or by full re-read/re-write of the files. Configuration reference Standard options Here are the Standard options specific to hasher (Better checksums for other remotes). --hasher-remote Remote to cache checksums for (e.g. myRemote:path). Properties: - Config: remote - Env Var: RCLONE_HASHER_REMOTE - Type: string - Required: true --hasher-hashes Comma separated list of supported checksum types. Properties: - Config: hashes - Env Var: RCLONE_HASHER_HASHES - Type: CommaSepList - Default: md5,sha1 --hasher-max-age Maximum time to keep checksums in cache (0 = no cache, off = cache forever). Properties: - Config: max_age - Env Var: RCLONE_HASHER_MAX_AGE - Type: Duration - Default: off Advanced options Here are the Advanced options specific to hasher (Better checksums for other remotes). --hasher-auto-size Auto-update checksum for files smaller than this size (disabled by default). Properties: - Config: auto_size - Env Var: RCLONE_HASHER_AUTO_SIZE - Type: SizeSuffix - Default: 0 --hasher-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_HASHER_DESCRIPTION - Type: string - Required: false Metadata Any metadata supported by the underlying remote is read and written. See the metadata docs for more info. Backend commands Here are the commands specific to the hasher backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the backend command for more info on how to pass options and arguments. These can be run on a running backend using the rc command backend/command. drop Drop cache rclone backend drop remote: [options] [+] Completely drop checksum cache. Usage Example: rclone backend drop hasher: dump Dump the database rclone backend dump remote: [options] [+] Dump cache records covered by the current remote fulldump Full dump of the database rclone backend fulldump remote: [options] [+] Dump all cache records in the database import Import a SUM file rclone backend import remote: [options] [+] Amend hash cache from a SUM file and bind checksums to files by size/time. Usage Example: rclone backend import hasher:subdir md5 /path/to/sum.md5 stickyimport Perform fast import of a SUM file rclone backend stickyimport remote: [options] [+] Fill hash cache from a SUM file without verifying file fingerprints. Usage Example: rclone backend stickyimport hasher:subdir md5 remote:path/to/sum.md5 Implementation details (advanced) This section explains how various rclone operations work on a hasher remote. Disclaimer. This section describes current implementation which can change in future rclone versions!. Hashsum command The rclone hashsum (or md5sum or sha1sum) command will: 1. if requested hash is supported by lower level, just pass it. 2. if object size is below auto_size then download object and calculate requested hashes on the fly. 3. if unsupported and the size is big enough, build object fingerprint (including size, modtime if supported, first-found other hash if any). 4. if the strict match is found in cache for the requested remote, return the stored hash. 5. if remote found but fingerprint mismatched, then purge the entry and proceed to step 6. 6. if remote not found or had no requested hash type or after step 5: download object, calculate all supported hashes on the fly and store in cache; return requested hash. Other operations - any time a hash is requested, follow the logic from 1-4 from hashsum above - whenever a file is uploaded or downloaded in full, capture the stream to calculate all supported hashes on the fly and update database - server-side move will update keys of existing cache entries - deletefile will remove a single cache entry - purge will remove all cache entries under the purged path Note that setting max_age = 0 will disable checksum caching completely. If you set max_age = off, checksums in cache will never age, unless you fully rewrite or delete the file. Cache storage Cached checksums are stored as bolt database files under rclone cache directory, usually ~/.cache/rclone/kv/. Databases are maintained one per base backend, named like BaseRemote~hasher.bolt. Checksums for multiple alias-es into a single base backend will be stored in the single database. All local paths are treated as aliases into the local backend (unless encrypted or chunked) and stored in ~/.cache/rclone/kv/local~hasher.bolt. Databases can be shared between multiple rclone processes. HDFS HDFS is a distributed file-system, part of the Apache Hadoop framework. Paths are specified as remote: or remote:path/to/dir. Configuration Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [skip] XX / Hadoop distributed file system \ "hdfs" [skip] Storage> hdfs ** See help for hdfs backend at: https://rclone.org/hdfs/ ** hadoop name node and port Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Connect to host namenode at port 8020 \ "namenode:8020" namenode> namenode.hadoop:8020 hadoop user name Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Connect to hdfs as root \ "root" username> root Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config Configuration complete. Options: - type: hdfs - namenode: namenode.hadoop:8020 - username: root Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== hadoop hdfs e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q This remote is called remote and can now be used like this See all the top level directories rclone lsd remote: List the contents of a directory rclone ls remote:directory Sync the remote directory to /home/local/directory, deleting any excess files. rclone sync --interactive remote:directory /home/local/directory Setting up your own HDFS instance for testing You may start with a manual setup or use the docker image from the tests: If you want to build the docker image git clone https://github.com/rclone/rclone.git cd rclone/fstest/testserver/images/test-hdfs docker build --rm -t rclone/test-hdfs . Or you can just use the latest one pushed docker run --rm --name "rclone-hdfs" -p 127.0.0.1:9866:9866 -p 127.0.0.1:8020:8020 --hostname "rclone-hdfs" rclone/test-hdfs NB it need few seconds to startup. For this docker image the remote needs to be configured like this: [remote] type = hdfs namenode = 127.0.0.1:8020 username = root You can stop this image with docker kill rclone-hdfs (NB it does not use volumes, so all data uploaded will be lost.) Modification times Time accurate to 1 second is stored. Checksum No checksums are implemented. Usage information You can use the rclone about remote: command which will display filesystem size and current usage. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- : 0x3A ： Invalid UTF-8 bytes will also be replaced. Standard options Here are the Standard options specific to hdfs (Hadoop distributed file system). --hdfs-namenode Hadoop name nodes and ports. E.g. "namenode-1:8020,namenode-2:8020,..." to connect to host namenodes at port 8020. Properties: - Config: namenode - Env Var: RCLONE_HDFS_NAMENODE - Type: CommaSepList - Default: --hdfs-username Hadoop user name. Properties: - Config: username - Env Var: RCLONE_HDFS_USERNAME - Type: string - Required: false - Examples: - "root" - Connect to hdfs as root. Advanced options Here are the Advanced options specific to hdfs (Hadoop distributed file system). --hdfs-service-principal-name Kerberos service principal name for the namenode. Enables KERBEROS authentication. Specifies the Service Principal Name (SERVICE/FQDN) for the namenode. E.g. "hdfs/namenode.hadoop.docker" for namenode running as service 'hdfs' with FQDN 'namenode.hadoop.docker'. Properties: - Config: service_principal_name - Env Var: RCLONE_HDFS_SERVICE_PRINCIPAL_NAME - Type: string - Required: false --hdfs-data-transfer-protection Kerberos data transfer protection: authentication|integrity|privacy. Specifies whether or not authentication, data signature integrity checks, and wire encryption are required when communicating with the datanodes. Possible values are 'authentication', 'integrity' and 'privacy'. Used only with KERBEROS enabled. Properties: - Config: data_transfer_protection - Env Var: RCLONE_HDFS_DATA_TRANSFER_PROTECTION - Type: string - Required: false - Examples: - "privacy" - Ensure authentication, integrity and encryption enabled. --hdfs-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_HDFS_ENCODING - Type: Encoding - Default: Slash,Colon,Del,Ctl,InvalidUtf8,Dot --hdfs-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_HDFS_DESCRIPTION - Type: string - Required: false Limitations - No server-side Move or DirMove. - Checksums not implemented. HiDrive Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. The initial setup for hidrive involves getting a token from HiDrive which you need to do in your browser. rclone config walks you through it. Configuration Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found - make a new one n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / HiDrive \ "hidrive" [snip] Storage> hidrive OAuth Client Id - Leave blank normally. client_id> OAuth Client Secret - Leave blank normally. client_secret> Access permissions that rclone should use when requesting access from HiDrive. Leave blank normally. scope_access> Edit advanced config? y/n> n Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth?state=xxxxxxxxxxxxxxxxxxxxxx Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: hidrive - token: {"access_token":"xxxxxxxxxxxxxxxxxxxx","token_type":"Bearer","refresh_token":"xxxxxxxxxxxxxxxxxxxxxxx","expiry":"xxxxxxxxxxxxxxxxxxxxxxx"} Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y You should be aware that OAuth-tokens can be used to access your account and hence should not be shared with other persons. See the below section for more information. See the remote setup docs for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from HiDrive. This only runs from the moment it opens your browser to the moment you get back the verification code. The webserver runs on http://127.0.0.1:53682/. If local port 53682 is protected by a firewall you may need to temporarily unblock the firewall to complete authorization. Once configured you can then use rclone like this, List directories in top level of your HiDrive root folder rclone lsd remote: List all the files in your HiDrive filesystem rclone ls remote: To copy a local directory to a HiDrive directory called backup rclone copy /home/source remote:backup Keeping your tokens safe Any OAuth-tokens will be stored by rclone in the remote's configuration file as unencrypted text. Anyone can use a valid refresh-token to access your HiDrive filesystem without knowing your password. Therefore you should make sure no one else can access your configuration. It is possible to encrypt rclone's configuration file. You can find information on securing your configuration file by viewing the configuration encryption docs. Invalid refresh token As can be verified here, each refresh_token (for Native Applications) is valid for 60 days. If used to access HiDrivei, its validity will be automatically extended. This means that if you - Don't use the HiDrive remote for 60 days then rclone will return an error which includes a text that implies the refresh token is invalid or expired. To fix this you will need to authorize rclone to access your HiDrive account again. Using rclone config reconnect remote: the process is very similar to the process of initial setup exemplified before. Modification times and hashes HiDrive allows modification times to be set on objects accurate to 1 second. HiDrive supports its own hash type which is used to verify the integrity of file contents after successful transfers. Restricted filename characters HiDrive cannot store files or folders that include / (0x2F) or null-bytes (0x00) in their name. Any other characters can be used in the names of files or folders. Additionally, files or folders cannot be named either of the following: . or .. Therefore rclone will automatically replace these characters, if files or folders are stored or accessed with such names. You can read about how this filename encoding works in general here. Keep in mind that HiDrive only supports file or folder names with a length of 255 characters or less. Transfers HiDrive limits file sizes per single request to a maximum of 2 GiB. To allow storage of larger files and allow for better upload performance, the hidrive backend will use a chunked transfer for files larger than 96 MiB. Rclone will upload multiple parts/chunks of the file at the same time. Chunks in the process of being uploaded are buffered in memory, so you may want to restrict this behaviour on systems with limited resources. You can customize this behaviour using the following options: - chunk_size: size of file parts - upload_cutoff: files larger or equal to this in size will use a chunked transfer - upload_concurrency: number of file-parts to upload at the same time See the below section about configuration options for more details. Root folder You can set the root folder for rclone. This is the directory that rclone considers to be the root of your HiDrive. Usually, you will leave this blank, and rclone will use the root of the account. However, you can set this to restrict rclone to a specific folder hierarchy. This works by prepending the contents of the root_prefix option to any paths accessed by rclone. For example, the following two ways to access the home directory are equivalent: rclone lsd --hidrive-root-prefix="/users/test/" remote:path rclone lsd remote:/users/test/path See the below section about configuration options for more details. Directory member count By default, rclone will know the number of directory members contained in a directory. For example, rclone lsd uses this information. The acquisition of this information will result in additional time costs for HiDrive's API. When dealing with large directory structures, it may be desirable to circumvent this time cost, especially when this information is not explicitly needed. For this, the disable_fetching_member_count option can be used. See the below section about configuration options for more details. Standard options Here are the Standard options specific to hidrive (HiDrive). --hidrive-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_HIDRIVE_CLIENT_ID - Type: string - Required: false --hidrive-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_HIDRIVE_CLIENT_SECRET - Type: string - Required: false --hidrive-scope-access Access permissions that rclone should use when requesting access from HiDrive. Properties: - Config: scope_access - Env Var: RCLONE_HIDRIVE_SCOPE_ACCESS - Type: string - Default: "rw" - Examples: - "rw" - Read and write access to resources. - "ro" - Read-only access to resources. Advanced options Here are the Advanced options specific to hidrive (HiDrive). --hidrive-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_HIDRIVE_TOKEN - Type: string - Required: false --hidrive-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_HIDRIVE_AUTH_URL - Type: string - Required: false --hidrive-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_HIDRIVE_TOKEN_URL - Type: string - Required: false --hidrive-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_HIDRIVE_CLIENT_CREDENTIALS - Type: bool - Default: false --hidrive-scope-role User-level that rclone should use when requesting access from HiDrive. Properties: - Config: scope_role - Env Var: RCLONE_HIDRIVE_SCOPE_ROLE - Type: string - Default: "user" - Examples: - "user" - User-level access to management permissions. - This will be sufficient in most cases. - "admin" - Extensive access to management permissions. - "owner" - Full access to management permissions. --hidrive-root-prefix The root/parent folder for all paths. Fill in to use the specified folder as the parent for all paths given to the remote. This way rclone can use any folder as its starting point. Properties: - Config: root_prefix - Env Var: RCLONE_HIDRIVE_ROOT_PREFIX - Type: string - Default: "/" - Examples: - "/" - The topmost directory accessible by rclone. - This will be equivalent with "root" if rclone uses a regular HiDrive user account. - "root" - The topmost directory of the HiDrive user account - "" - This specifies that there is no root-prefix for your paths. - When using this you will always need to specify paths to this remote with a valid parent e.g. "remote:/path/to/dir" or "remote:root/path/to/dir". --hidrive-endpoint Endpoint for the service. This is the URL that API-calls will be made to. Properties: - Config: endpoint - Env Var: RCLONE_HIDRIVE_ENDPOINT - Type: string - Default: "https://api.hidrive.strato.com/2.1" --hidrive-disable-fetching-member-count Do not fetch number of objects in directories unless it is absolutely necessary. Requests may be faster if the number of objects in subdirectories is not fetched. Properties: - Config: disable_fetching_member_count - Env Var: RCLONE_HIDRIVE_DISABLE_FETCHING_MEMBER_COUNT - Type: bool - Default: false --hidrive-chunk-size Chunksize for chunked uploads. Any files larger than the configured cutoff (or files of unknown size) will be uploaded in chunks of this size. The upper limit for this is 2147483647 bytes (about 2.000Gi). That is the maximum amount of bytes a single upload-operation will support. Setting this above the upper limit or to a negative value will cause uploads to fail. Setting this to larger values may increase the upload speed at the cost of using more memory. It can be set to smaller values smaller to save on memory. Properties: - Config: chunk_size - Env Var: RCLONE_HIDRIVE_CHUNK_SIZE - Type: SizeSuffix - Default: 48Mi --hidrive-upload-cutoff Cutoff/Threshold for chunked uploads. Any files larger than this will be uploaded in chunks of the configured chunksize. The upper limit for this is 2147483647 bytes (about 2.000Gi). That is the maximum amount of bytes a single upload-operation will support. Setting this above the upper limit will cause uploads to fail. Properties: - Config: upload_cutoff - Env Var: RCLONE_HIDRIVE_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 96Mi --hidrive-upload-concurrency Concurrency for chunked uploads. This is the upper limit for how many transfers for the same file are running concurrently. Setting this above to a value smaller than 1 will cause uploads to deadlock. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. Properties: - Config: upload_concurrency - Env Var: RCLONE_HIDRIVE_UPLOAD_CONCURRENCY - Type: int - Default: 4 --hidrive-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_HIDRIVE_ENCODING - Type: Encoding - Default: Slash,Dot --hidrive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_HIDRIVE_DESCRIPTION - Type: string - Required: false Limitations Symbolic links HiDrive is able to store symbolic links (symlinks) by design, for example, when unpacked from a zip archive. There exists no direct mechanism to manage native symlinks in remotes. As such this implementation has chosen to ignore any native symlinks present in the remote. rclone will not be able to access or show any symlinks stored in the hidrive-remote. This means symlinks cannot be individually removed, copied, or moved, except when removing, copying, or moving the parent folder. This does not affect the .rclonelink-files that rclone uses to encode and store symbolic links. Sparse files It is possible to store sparse files in HiDrive. Note that copying a sparse file will expand the holes into null-byte (0x00) regions that will then consume disk space. Likewise, when downloading a sparse file, the resulting file will have null-byte regions in the place of file holes. HTTP The HTTP remote is a read only remote for reading files of a webserver. The webserver should provide file listings which rclone will read and turn into a remote. This has been tested with common webservers such as Apache/Nginx/Caddy and will likely work with file listings from most web servers. (If it doesn't then please file an issue, or send a pull request!) Paths are specified as remote: or remote:path. The remote: represents the configured url, and any path following it will be resolved relative to this url, according to the URL standard. This means with remote url https://beta.rclone.org/branch and path fix, the resolved URL will be https://beta.rclone.org/branch/fix, while with path /fix the resolved URL will be https://beta.rclone.org/fix as the absolute path is resolved from the root of the domain. If the path following the remote: ends with / it will be assumed to point to a directory. If the path does not end with /, then a HEAD request is sent and the response used to decide if it it is treated as a file or a directory (run with -vv to see details). When --http-no-head is specified, a path without ending / is always assumed to be a file. If rclone incorrectly assumes the path is a file, the solution is to specify the path with ending /. When you know the path is a directory, ending it with / is always better as it avoids the initial HEAD request. To just download a single file it is easier to use copyurl. Configuration Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / HTTP \ "http" [snip] Storage> http URL of http host to connect to Choose a number from below, or type in your own value 1 / Connect to example.com \ "https://example.com" url> https://beta.rclone.org Remote config Configuration complete. Options: - type: http - url: https://beta.rclone.org Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== remote http e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q This remote is called remote and can now be used like this See all the top level directories rclone lsd remote: List the contents of a directory rclone ls remote:directory Sync the remote directory to /home/local/directory, deleting any excess files. rclone sync --interactive remote:directory /home/local/directory Read only This remote is read only - you can't upload files to an HTTP server. Modification times Most HTTP servers store time accurate to 1 second. Checksum No checksums are stored. Usage without a config file Since the http remote only has one config parameter it is easy to use without a config file: rclone lsd --http-url https://beta.rclone.org :http: or: rclone lsd :http,url='https://beta.rclone.org': Standard options Here are the Standard options specific to http (HTTP). --http-url URL of HTTP host to connect to. E.g. "https://example.com", or "https://user:pass@example.com" to use a username and password. Properties: - Config: url - Env Var: RCLONE_HTTP_URL - Type: string - Required: true --http-no-escape Do not escape URL metacharacters in path names. Properties: - Config: no_escape - Env Var: RCLONE_HTTP_NO_ESCAPE - Type: bool - Default: false Advanced options Here are the Advanced options specific to http (HTTP). --http-headers Set HTTP headers for all transactions. Use this to set additional HTTP headers for all transactions. The input format is comma separated list of key,value pairs. Standard CSV encoding may be used. For example, to set a Cookie use 'Cookie,name=value', or '"Cookie","name=value"'. You can set multiple headers, e.g. '"Cookie","name=value","Authorization","xxx"'. Properties: - Config: headers - Env Var: RCLONE_HTTP_HEADERS - Type: CommaSepList - Default: --http-no-slash Set this if the site doesn't end directories with /. Use this if your target website does not use / on the end of directories. A / on the end of a path is how rclone normally tells the difference between files and directories. If this flag is set, then rclone will treat all files with Content-Type: text/html as directories and read URLs from them rather than downloading them. Note that this may cause rclone to confuse genuine HTML files with directories. Properties: - Config: no_slash - Env Var: RCLONE_HTTP_NO_SLASH - Type: bool - Default: false --http-no-head Don't use HEAD requests. HEAD requests are mainly used to find file sizes in dir listing. If your site is being very slow to load then you can try this option. Normally rclone does a HEAD request for each potential file in a directory listing to: - find its size - check it really exists - check to see if it is a directory If you set this option, rclone will not do the HEAD request. This will mean that directory listings are much quicker, but rclone won't have the times or sizes of any files, and some files that don't exist may be in the listing. Properties: - Config: no_head - Env Var: RCLONE_HTTP_NO_HEAD - Type: bool - Default: false --http-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_HTTP_DESCRIPTION - Type: string - Required: false Backend commands Here are the commands specific to the http backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the backend command for more info on how to pass options and arguments. These can be run on a running backend using the rc command backend/command. set Set command for updating the config parameters. rclone backend set remote: [options] [+] This set command can be used to update the config parameters for a running http backend. Usage Examples: rclone backend set remote: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=remote: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=remote: -o url=https://example.com The option keys are named as they are in the config file. This rebuilds the connection to the http backend when it is called with the new parameters. Only new parameters need be passed as the values will default to those currently in use. It doesn't return anything. Limitations rclone about is not supported by the HTTP backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about ImageKit This is a backend for the ImageKit.io storage service. About ImageKit ImageKit.io provides real-time image and video optimizations, transformations, and CDN delivery. Over 1,000 businesses and 70,000 developers trust ImageKit with their images and videos on the web. Accounts & Pricing To use this backend, you need to create an account on ImageKit. Start with a free plan with generous usage limits. Then, as your requirements grow, upgrade to a plan that best fits your needs. See the pricing details. Configuration Here is an example of making an imagekit configuration. Firstly create a ImageKit.io account and choose a plan. You will need to log in and get the publicKey and privateKey for your account from the developer section. Now run rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter the name for the new remote. name> imagekit-media-library Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / ImageKit.io \ (imagekit) [snip] Storage> imagekit Option endpoint. You can find your ImageKit.io URL endpoint in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) Enter a value. endpoint> https://ik.imagekit.io/imagekit_id Option public_key. You can find your ImageKit.io public key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) Enter a value. public_key> public_**************************** Option private_key. You can find your ImageKit.io private key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys) Enter a value. private_key> private_**************************** Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: imagekit - endpoint: https://ik.imagekit.io/imagekit_id - public_key: public_**************************** - private_key: private_**************************** Keep this "imagekit-media-library" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y List directories in the top level of your Media Library rclone lsd imagekit-media-library: Make a new directory. rclone mkdir imagekit-media-library:directory List the contents of a directory. rclone ls imagekit-media-library:directory Modified time and hashes ImageKit does not support modification times or hashes yet. Checksums No checksums are supported. Standard options Here are the Standard options specific to imagekit (ImageKit.io). --imagekit-endpoint You can find your ImageKit.io URL endpoint in your dashboard Properties: - Config: endpoint - Env Var: RCLONE_IMAGEKIT_ENDPOINT - Type: string - Required: true --imagekit-public-key You can find your ImageKit.io public key in your dashboard Properties: - Config: public_key - Env Var: RCLONE_IMAGEKIT_PUBLIC_KEY - Type: string - Required: true --imagekit-private-key You can find your ImageKit.io private key in your dashboard Properties: - Config: private_key - Env Var: RCLONE_IMAGEKIT_PRIVATE_KEY - Type: string - Required: true Advanced options Here are the Advanced options specific to imagekit (ImageKit.io). --imagekit-only-signed If you have configured Restrict unsigned image URLs in your dashboard settings, set this to true. Properties: - Config: only_signed - Env Var: RCLONE_IMAGEKIT_ONLY_SIGNED - Type: bool - Default: false --imagekit-versions Include old versions in directory listings. Properties: - Config: versions - Env Var: RCLONE_IMAGEKIT_VERSIONS - Type: bool - Default: false --imagekit-upload-tags Tags to add to the uploaded files, e.g. "tag1,tag2". Properties: - Config: upload_tags - Env Var: RCLONE_IMAGEKIT_UPLOAD_TAGS - Type: string - Required: false --imagekit-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_IMAGEKIT_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Dollar,Question,Hash,Percent,BackSlash,Del,Ctl,InvalidUtf8,Dot,SquareBracket --imagekit-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_IMAGEKIT_DESCRIPTION - Type: string - Required: false Metadata Any metadata supported by the underlying remote is read and written. Here are the possible system metadata items for the imagekit backend. ----------------------------------------------------------------------------------------------------------- Name Help Type Example Read Only -------------------- --------------- ----------- ------------------------------------- -------------------- aws-tags AI generated string tag1,tag2 Y tags by AWS Rekognition associated with the image btime Time of file RFC 3339 2006-01-02T15:04:05.999999999Z07:00 Y birth (creation) read from Last-Modified header custom-coordinates Custom string 0,0,100,100 Y coordinates of the file file-type Type of the string image Y file google-tags AI generated string tag1,tag2 Y tags by Google Cloud Vision associated with the image has-alpha Whether the bool Y image has alpha channel or not height Height of the int Y image or video in pixels is-private-file Whether the bool Y file is private or not size Size of the int64 Y object in bytes tags Tags associated string tag1,tag2 Y with the file width Width of the int Y image or video in pixels ----------------------------------------------------------------------------------------------------------- See the metadata docs for more info. iCloud Drive Configuration The initial setup for an iCloud Drive backend involves getting a trust token/session. This can be done by simply using the regular iCloud password, and accepting the code prompt on another iCloud connected device. IMPORTANT: At the moment an app specific password won't be accepted. Only use your regular password and 2FA. rclone config walks you through the token creation. The trust token is valid for 30 days. After which you will have to reauthenticate with rclone reconnect or rclone config. Here is an example of how to make a remote called iclouddrive. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> iclouddrive Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / iCloud Drive \ (iclouddrive) [snip] Storage> iclouddrive Option apple_id. Apple ID. Enter a value. apple_id> APPLEID Option password. Password. Choose an alternative below. y) Yes, type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n Option config_2fa. Two-factor authentication: please enter your 2FA code Enter a value. config_2fa> 2FACODE Remote config -------------------- [iclouddrive] - type: iclouddrive - apple_id: APPLEID - password: *** ENCRYPTED *** - cookies: **************************** - trust_token: **************************** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Advanced Data Protection ADP is currently unsupported and need to be disabled On iPhone, Settings > Apple Account > iCloud > 'Access iCloud Data on the Web' must be ON, and 'Advanced Data Protection' OFF. Troubleshooting Missing PCS cookies from the request This means you have Advanced Data Protection (ADP) turned on. This is not supported at the moment. If you want to use rclone you will have to turn it off. See above for how to turn it off. You will need to clear the cookies and the trust_token fields in the config. Or you can delete the remote config and start again. You should then run rclone reconnect remote:. Note that changing the ADP setting may not take effect immediately - you may need to wait a few hours or a day before you can get rclone to work - keep clearing the config entry and running rclone reconnect remote: until rclone functions properly. Standard options Here are the Standard options specific to iclouddrive (iCloud Drive). --iclouddrive-apple-id Apple ID. Properties: - Config: apple_id - Env Var: RCLONE_ICLOUDDRIVE_APPLE_ID - Type: string - Required: true --iclouddrive-password Password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: password - Env Var: RCLONE_ICLOUDDRIVE_PASSWORD - Type: string - Required: true --iclouddrive-trust-token Trust token (internal use) Properties: - Config: trust_token - Env Var: RCLONE_ICLOUDDRIVE_TRUST_TOKEN - Type: string - Required: false --iclouddrive-cookies cookies (internal use only) Properties: - Config: cookies - Env Var: RCLONE_ICLOUDDRIVE_COOKIES - Type: string - Required: false Advanced options Here are the Advanced options specific to iclouddrive (iCloud Drive). --iclouddrive-client-id Client id Properties: - Config: client_id - Env Var: RCLONE_ICLOUDDRIVE_CLIENT_ID - Type: string - Default: "d39ba9916b7251055b22c7f910e2ea796ee65e98b2ddecea8f5dde8d9d1a815d" --iclouddrive-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_ICLOUDDRIVE_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot --iclouddrive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_ICLOUDDRIVE_DESCRIPTION - Type: string - Required: false Internet Archive The Internet Archive backend utilizes Items on archive.org Refer to IAS3 API documentation for the API this backend uses. Paths are specified as remote:bucket (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:item/path/to/dir. Unlike S3, listing up all items uploaded by you isn't supported. Once you have made a remote, you can use it like this: Make a new item rclone mkdir remote:item List the contents of a item rclone ls remote:item Sync /home/local/directory to the remote item, deleting any excess files in the item. rclone sync --interactive /home/local/directory remote:item Notes Because of Internet Archive's architecture, it enqueues write operations (and extra post-processings) in a per-item queue. You can check item's queue at https://catalogd.archive.org/history/item-name-here . Because of that, all uploads/deletes will not show up immediately and takes some time to be available. The per-item queue is enqueued to an another queue, Item Deriver Queue. You can check the status of Item Deriver Queue here. This queue has a limit, and it may block you from uploading, or even deleting. You should avoid uploading a lot of small files for better behavior. You can optionally wait for the server's processing to finish, by setting non-zero value to wait_archive key. By making it wait, rclone can do normal file comparison. Make sure to set a large enough value (e.g. 30m0s for smaller files) as it can take a long time depending on server's queue. About metadata This backend supports setting, updating and reading metadata of each file. The metadata will appear as file metadata on Internet Archive. However, some fields are reserved by both Internet Archive and rclone. The following are reserved by Internet Archive: - name - source - size - md5 - crc32 - sha1 - format - old_version - viruscheck - summation Trying to set values to these keys is ignored with a warning. Only setting mtime is an exception. Doing so make it the identical behavior as setting ModTime. rclone reserves all the keys starting with rclone-. Setting value for these keys will give you warnings, but values are set according to request. If there are multiple values for a key, only the first one is returned. This is a limitation of rclone, that supports one value per one key. It can be triggered when you did a server-side copy. Reading metadata will also provide custom (non-standard nor reserved) ones. Filtering auto generated files The Internet Archive automatically creates metadata files after upload. These can cause problems when doing an rclone sync as rclone will try, and fail, to delete them. These metadata files are not changeable, as they are created by the Internet Archive automatically. These auto-created files can be excluded from the sync using metadata filtering. rclone sync ... --metadata-exclude "source=metadata" --metadata-exclude "format=Metadata" Which excludes from the sync any files which have the source=metadata or format=Metadata flags which are added to Internet Archive auto-created files. Configuration Here is an example of making an internetarchive configuration. Most applies to the other providers as well, any differences are described below. First run rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. XX / InternetArchive Items \ (internetarchive) Storage> internetarchive Option access_key_id. IAS3 Access Key. Leave blank for anonymous access. You can find one here: https://archive.org/account/s3.php Enter a value. Press Enter to leave empty. access_key_id> XXXX Option secret_access_key. IAS3 Secret Key (password). Leave blank for anonymous access. Enter a value. Press Enter to leave empty. secret_access_key> XXXX Edit advanced config? y) Yes n) No (default) y/n> y Option endpoint. IAS3 Endpoint. Leave blank for default value. Enter a string value. Press Enter for the default (https://s3.us.archive.org). endpoint> Option front_endpoint. Host of InternetArchive Frontend. Leave blank for default value. Enter a string value. Press Enter for the default (https://archive.org). front_endpoint> Option disable_checksum. Don't store MD5 checksum with object metadata. Normally rclone will calculate the MD5 checksum of the input before uploading it so it can ask the server to check the object against checksum. This is great for data integrity checking but can cause long delays for large files to start uploading. Enter a boolean value (true or false). Press Enter for the default (true). disable_checksum> true Option encoding. The encoding for the backend. See the [encoding section in the overview](https://rclone.org/overview/#encoding) for more info. Enter a encoder.MultiEncoder value. Press Enter for the default (Slash,Question,Hash,Percent,Del,Ctl,InvalidUtf8,Dot). encoding> Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: internetarchive - access_key_id: XXXX - secret_access_key: XXXX Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Standard options Here are the Standard options specific to internetarchive (Internet Archive). --internetarchive-access-key-id IAS3 Access Key. Leave blank for anonymous access. You can find one here: https://archive.org/account/s3.php Properties: - Config: access_key_id - Env Var: RCLONE_INTERNETARCHIVE_ACCESS_KEY_ID - Type: string - Required: false --internetarchive-secret-access-key IAS3 Secret Key (password). Leave blank for anonymous access. Properties: - Config: secret_access_key - Env Var: RCLONE_INTERNETARCHIVE_SECRET_ACCESS_KEY - Type: string - Required: false --internetarchive-item-derive Whether to trigger derive on the IA item or not. If set to false, the item will not be derived by IA upon upload. The derive process produces a number of secondary files from an upload to make an upload more usable on the web. Setting this to false is useful for uploading files that are already in a format that IA can display or reduce burden on IA's infrastructure. Properties: - Config: item_derive - Env Var: RCLONE_INTERNETARCHIVE_ITEM_DERIVE - Type: bool - Default: true Advanced options Here are the Advanced options specific to internetarchive (Internet Archive). --internetarchive-endpoint IAS3 Endpoint. Leave blank for default value. Properties: - Config: endpoint - Env Var: RCLONE_INTERNETARCHIVE_ENDPOINT - Type: string - Default: "https://s3.us.archive.org" --internetarchive-front-endpoint Host of InternetArchive Frontend. Leave blank for default value. Properties: - Config: front_endpoint - Env Var: RCLONE_INTERNETARCHIVE_FRONT_ENDPOINT - Type: string - Default: "https://archive.org" --internetarchive-item-metadata Metadata to be set on the IA item, this is different from file-level metadata that can be set using --metadata-set. Format is key=value and the 'x-archive-meta-' prefix is automatically added. Properties: - Config: item_metadata - Env Var: RCLONE_INTERNETARCHIVE_ITEM_METADATA - Type: stringArray - Default: [] --internetarchive-disable-checksum Don't ask the server to test against MD5 checksum calculated by rclone. Normally rclone will calculate the MD5 checksum of the input before uploading it so it can ask the server to check the object against checksum. This is great for data integrity checking but can cause long delays for large files to start uploading. Properties: - Config: disable_checksum - Env Var: RCLONE_INTERNETARCHIVE_DISABLE_CHECKSUM - Type: bool - Default: true --internetarchive-wait-archive Timeout for waiting the server's processing tasks (specifically archive and book_op) to finish. Only enable if you need to be guaranteed to be reflected after write operations. 0 to disable waiting. No errors to be thrown in case of timeout. Properties: - Config: wait_archive - Env Var: RCLONE_INTERNETARCHIVE_WAIT_ARCHIVE - Type: Duration - Default: 0s --internetarchive-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_INTERNETARCHIVE_ENCODING - Type: Encoding - Default: Slash,LtGt,CrLf,Del,Ctl,InvalidUtf8,Dot --internetarchive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_INTERNETARCHIVE_DESCRIPTION - Type: string - Required: false Metadata Metadata fields provided by Internet Archive. If there are multiple values for a key, only the first one is returned. This is a limitation of Rclone, that supports one value per one key. Owner is able to add custom keys. Metadata feature grabs all the keys including them. Here are the possible system metadata items for the internetarchive backend. -------------------------------------------------------------------------------------------------------------------------------------- Name Help Type Example Read Only --------------------- ---------------------------------- ----------- -------------------------------------------- -------------------- crc32 CRC32 calculated by Internet string 01234567 Y Archive format Name of format identified by string Comma-Separated Values Y Internet Archive md5 MD5 hash calculated by Internet string 01234567012345670123456701234567 Y Archive mtime Time of last modification, managed RFC 3339 2006-01-02T15:04:05.999999999Z Y by Rclone name Full file path, without the bucket filename backend/internetarchive/internetarchive.go Y part old_version Whether the file was replaced and boolean true Y moved by keep-old-version flag rclone-ia-mtime Time of last modification, managed RFC 3339 2006-01-02T15:04:05.999999999Z N by Internet Archive rclone-mtime Time of last modification, managed RFC 3339 2006-01-02T15:04:05.999999999Z N by Rclone rclone-update-track Random value used by Rclone for string aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa N tracking changes inside Internet Archive sha1 SHA1 hash calculated by Internet string 0123456701234567012345670123456701234567 Y Archive size File size in bytes decimal 123456 Y number source The source of the file string original Y summation Check string md5 Y https://forum.rclone.org/t/31922 for how it is used viruscheck The last time viruscheck process unixtime 1654191352 Y was run for the file (?) -------------------------------------------------------------------------------------------------------------------------------------- See the metadata docs for more info. Jottacloud Jottacloud is a cloud storage service provider from a Norwegian company, using its own datacenters in Norway. In addition to the official service at jottacloud.com, it also provides white-label solutions to different companies, such as: * Telia * Telia Cloud (cloud.telia.se) * Telia Sky (sky.telia.no) * Tele2 * Tele2 Cloud (mittcloud.tele2.se) * Onlime * Onlime Cloud Storage (onlime.dk) * Elkjøp (with subsidiaries): * Elkjøp Cloud (cloud.elkjop.no) * Elgiganten Sweden (cloud.elgiganten.se) * Elgiganten Denmark (cloud.elgiganten.dk) * Giganti Cloud (cloud.gigantti.fi) * ELKO Cloud (cloud.elko.is) Most of the white-label versions are supported by this backend, although may require different authentication setup - described below. Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. Authentication types Some of the whitelabel versions uses a different authentication method than the official service, and you have to choose the correct one when setting up the remote. Standard authentication The standard authentication method used by the official service (jottacloud.com), as well as some of the whitelabel services, requires you to generate a single-use personal login token from the account security settings in the service's web interface. Log in to your account, go to "Settings" and then "Security", or use the direct link presented to you by rclone when configuring the remote: https://www.jottacloud.com/web/secure. Scroll down to the section "Personal login token", and click the "Generate" button. Note that if you are using a whitelabel service you probably can't use the direct link, you need to find the same page in their dedicated web interface, and also it may be in a different location than described above. To access your account from multiple instances of rclone, you need to configure each of them with a separate personal login token. E.g. you create a Jottacloud remote with rclone in one location, and copy the configuration file to a second location where you also want to run rclone and access the same remote. Then you need to replace the token for one of them, using the config reconnect command, which requires you to generate a new personal login token and supply as input. If you do not do this, the token may easily end up being invalidated, resulting in both instances failing with an error message something along the lines of: oauth2: cannot fetch token: 400 Bad Request Response: {"error":"invalid_grant","error_description":"Stale token"} When this happens, you need to replace the token as described above to be able to use your remote again. All personal login tokens you have taken into use will be listed in the web interface under "My logged in devices", and from the right side of that list you can click the "X" button to revoke individual tokens. Legacy authentication If you are using one of the whitelabel versions (e.g. from Elkjøp) you may not have the option to generate a CLI token. In this case you'll have to use the legacy authentication. To do this select yes when the setup asks for legacy authentication and enter your username and password. The rest of the setup is identical to the default setup. Telia Cloud authentication Similar to other whitelabel versions Telia Cloud doesn't offer the option of creating a CLI token, and additionally uses a separate authentication flow where the username is generated internally. To setup rclone to use Telia Cloud, choose Telia Cloud authentication in the setup. The rest of the setup is identical to the default setup. Tele2 Cloud authentication As Tele2-Com Hem merger was completed this authentication can be used for former Com Hem Cloud and Tele2 Cloud customers as no support for creating a CLI token exists, and additionally uses a separate authentication flow where the username is generated internally. To setup rclone to use Tele2 Cloud, choose Tele2 Cloud authentication in the setup. The rest of the setup is identical to the default setup. Onlime Cloud Storage authentication Onlime has sold access to Jottacloud proper, while providing localized support to Danish Customers, but have recently set up their own hosting, transferring their customers from Jottacloud servers to their own ones. This, of course, necessitates using their servers for authentication, but otherwise functionality and architecture seems equivalent to Jottacloud. To setup rclone to use Onlime Cloud Storage, choose Onlime Cloud authentication in the setup. The rest of the setup is identical to the default setup. Configuration Here is an example of how to make a remote called remote with the default setup. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Jottacloud \ (jottacloud) [snip] Storage> jottacloud Edit advanced config? y) Yes n) No (default) y/n> n Option config_type. Select authentication type. Choose a number from below, or type in an existing string value. Press Enter for the default (standard). / Standard authentication. 1 | Use this if you're a normal Jottacloud user. \ (standard) / Legacy authentication. 2 | This is only required for certain whitelabel versions of Jottacloud and not recommended for normal users. \ (legacy) / Telia Cloud authentication. 3 | Use this if you are using Telia Cloud. \ (telia) / Tele2 Cloud authentication. 4 | Use this if you are using Tele2 Cloud. \ (tele2) / Onlime Cloud authentication. 5 | Use this if you are using Onlime Cloud. \ (onlime) config_type> 1 Personal login token. Generate here: https://www.jottacloud.com/web/secure Login Token> Use a non-standard device/mountpoint? Choosing no, the default, will let you access the storage used for the archive section of the official Jottacloud client. If you instead want to access the sync or the backup section, for example, you must choose yes. y) Yes n) No (default) y/n> y Option config_device. The device to use. In standard setup the built-in Jotta device is used, which contains predefined mountpoints for archive, sync etc. All other devices are treated as backup devices by the official Jottacloud client. You may create a new by entering a unique name. Choose a number from below, or type in your own string value. Press Enter for the default (DESKTOP-3H31129). 1 > DESKTOP-3H31129 2 > Jotta config_device> 2 Option config_mountpoint. The mountpoint to use for the built-in device Jotta. The standard setup is to use the Archive mountpoint. Most other mountpoints have very limited support in rclone and should generally be avoided. Choose a number from below, or type in an existing string value. Press Enter for the default (Archive). 1 > Archive 2 > Shared 3 > Sync config_mountpoint> 1 Configuration complete. Options: - type: jottacloud - configVersion: 1 - client_id: jottacli - client_secret: - tokenURL: https://id.jottacloud.com/auth/realms/jottacloud/protocol/openid-connect/token - token: {........} - username: 2940e57271a93d987d6f8a21 - device: Jotta - mountpoint: Archive Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Once configured you can then use rclone like this, List directories in top level of your Jottacloud rclone lsd remote: List all the files in your Jottacloud rclone ls remote: To copy a local directory to an Jottacloud directory called backup rclone copy /home/source remote:backup Devices and Mountpoints The official Jottacloud client registers a device for each computer you install it on, and shows them in the backup section of the user interface. For each folder you select for backup it will create a mountpoint within this device. A built-in device called Jotta is special, and contains mountpoints Archive, Sync and some others, used for corresponding features in official clients. With rclone you'll want to use the standard Jotta/Archive device/mountpoint in most cases. However, you may for example want to access files from the sync or backup functionality provided by the official clients, and rclone therefore provides the option to select other devices and mountpoints during config. You are allowed to create new devices and mountpoints. All devices except the built-in Jotta device are treated as backup devices by official Jottacloud clients, and the mountpoints on them are individual backup sets. With the built-in Jotta device, only existing, built-in, mountpoints can be selected. In addition to the mentioned Archive and Sync, it may contain several other mountpoints such as: Latest, Links, Shared and Trash. All of these are special mountpoints with a different internal representation than the "regular" mountpoints. Rclone will only to a very limited degree support them. Generally you should avoid these, unless you know what you are doing. --fast-list This backend supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details. Note that the implementation in Jottacloud always uses only a single API request to get the entire list, so for large folders this could lead to long wait time before the first results are shown. Note also that with rclone version 1.58 and newer, information about MIME types and metadata item utime are not available when using --fast-list. Modification times and hashes Jottacloud allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not. Jottacloud supports MD5 type hashes, so you can use the --checksum flag. Note that Jottacloud requires the MD5 hash before upload so if the source does not have an MD5 checksum then the file will be cached temporarily on disk (in location given by --temp-dir) before it is uploaded. Small files will be cached in memory - see the --jottacloud-md5-memory-limit flag. When uploading from local disk the source checksum is always available, so this does not apply. Starting with rclone version 1.52 the same is true for encrypted remotes (in older versions the crypt backend would not calculate hashes for uploads from local disk, so the Jottacloud backend had to do it as described above). Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- " 0x22 ＂ * 0x2A ＊ : 0x3A ： < 0x3C ＜ > 0x3E ＞ ? 0x3F ？ | 0x7C ｜ Invalid UTF-8 bytes will also be replaced, as they can't be used in XML strings. Deleting files By default, rclone will send all files to the trash when deleting files. They will be permanently deleted automatically after 30 days. You may bypass the trash and permanently delete files immediately by using the --jottacloud-hard-delete flag, or set the equivalent environment variable. Emptying the trash is supported by the cleanup command. Versions Jottacloud supports file versioning. When rclone uploads a new version of a file it creates a new version of it. Currently rclone only supports retrieving the current version but older versions can be accessed via the Jottacloud Website. Versioning can be disabled by --jottacloud-no-versions option. This is achieved by deleting the remote file prior to uploading a new version. If the upload the fails no version of the file will be available in the remote. Quota information To view your current quota you can use the rclone about remote: command which will display your usage limit (unless it is unlimited) and the current usage. Standard options Here are the Standard options specific to jottacloud (Jottacloud). --jottacloud-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_JOTTACLOUD_CLIENT_ID - Type: string - Required: false --jottacloud-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_JOTTACLOUD_CLIENT_SECRET - Type: string - Required: false Advanced options Here are the Advanced options specific to jottacloud (Jottacloud). --jottacloud-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_JOTTACLOUD_TOKEN - Type: string - Required: false --jottacloud-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_JOTTACLOUD_AUTH_URL - Type: string - Required: false --jottacloud-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_JOTTACLOUD_TOKEN_URL - Type: string - Required: false --jottacloud-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_JOTTACLOUD_CLIENT_CREDENTIALS - Type: bool - Default: false --jottacloud-md5-memory-limit Files bigger than this will be cached on disk to calculate the MD5 if required. Properties: - Config: md5_memory_limit - Env Var: RCLONE_JOTTACLOUD_MD5_MEMORY_LIMIT - Type: SizeSuffix - Default: 10Mi --jottacloud-trashed-only Only show files that are in the trash. This will show trashed files in their original directory structure. Properties: - Config: trashed_only - Env Var: RCLONE_JOTTACLOUD_TRASHED_ONLY - Type: bool - Default: false --jottacloud-hard-delete Delete files permanently rather than putting them into the trash. Properties: - Config: hard_delete - Env Var: RCLONE_JOTTACLOUD_HARD_DELETE - Type: bool - Default: false --jottacloud-upload-resume-limit Files bigger than this can be resumed if the upload fail's. Properties: - Config: upload_resume_limit - Env Var: RCLONE_JOTTACLOUD_UPLOAD_RESUME_LIMIT - Type: SizeSuffix - Default: 10Mi --jottacloud-no-versions Avoid server side versioning by deleting files and recreating files instead of overwriting them. Properties: - Config: no_versions - Env Var: RCLONE_JOTTACLOUD_NO_VERSIONS - Type: bool - Default: false --jottacloud-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_JOTTACLOUD_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,Del,Ctl,InvalidUtf8,Dot --jottacloud-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_JOTTACLOUD_DESCRIPTION - Type: string - Required: false Metadata Jottacloud has limited support for metadata, currently an extended set of timestamps. Here are the possible system metadata items for the jottacloud backend. ----------------------------------------------------------------------------------------------------- Name Help Type Example Read Only -------------- --------------- ----------- ------------------------------------- -------------------- btime Time of file RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N birth (creation), read from rclone metadata content-type MIME type, also string text/plain Y known as media type mtime Time of last RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N modification, read from rclone metadata utime Time of last RFC 3339 2006-01-02T15:04:05.999999999Z07:00 Y upload, when current revision was created, generated by backend ----------------------------------------------------------------------------------------------------- See the metadata docs for more info. Limitations Note that Jottacloud is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". There are quite a few characters that can't be in Jottacloud file names. Rclone will map these names to and from an identical looking unicode equivalent. For example if a file has a ? in it will be mapped to ？ instead. Jottacloud only supports filenames up to 255 characters in length. Troubleshooting Jottacloud exhibits some inconsistent behaviours regarding deleted files and folders which may cause Copy, Move and DirMove operations to previously deleted paths to fail. Emptying the trash should help in such cases. Koofr Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. Configuration The initial setup for Koofr involves creating an application password for rclone. You can do that by opening the Koofr web application, giving the password a nice name like rclone and clicking on generate. Here is an example of how to make a remote called koofr. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> koofr Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] 22 / Koofr, Digi Storage and other Koofr-compatible storage providers \ (koofr) [snip] Storage> koofr Option provider. Choose your storage provider. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Koofr, https://app.koofr.net/ \ (koofr) 2 / Digi Storage, https://storage.rcs-rds.ro/ \ (digistorage) 3 / Any other Koofr API compatible storage service \ (other) provider> 1 Option user. Your user name. Enter a value. user> USERNAME Option password. Your password for rclone (generate one at https://app.koofr.net/app/admin/preferences/password). Choose an alternative below. y) Yes, type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n Remote config -------------------- [koofr] type = koofr provider = koofr user = USERNAME password = *** ENCRYPTED *** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y You can choose to edit advanced config in order to enter your own service URL if you use an on-premise or white label Koofr instance, or choose an alternative mount instead of your primary storage. Once configured you can then use rclone like this, List directories in top level of your Koofr rclone lsd koofr: List all the files in your Koofr rclone ls koofr: To copy a local directory to an Koofr directory called backup rclone copy /home/source koofr:backup Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- \ 0x5C ＼ Invalid UTF-8 bytes will also be replaced, as they can't be used in XML strings. Standard options Here are the Standard options specific to koofr (Koofr, Digi Storage and other Koofr-compatible storage providers). --koofr-provider Choose your storage provider. Properties: - Config: provider - Env Var: RCLONE_KOOFR_PROVIDER - Type: string - Required: false - Examples: - "koofr" - Koofr, https://app.koofr.net/ - "digistorage" - Digi Storage, https://storage.rcs-rds.ro/ - "other" - Any other Koofr API compatible storage service --koofr-endpoint The Koofr API endpoint to use. Properties: - Config: endpoint - Env Var: RCLONE_KOOFR_ENDPOINT - Provider: other - Type: string - Required: true --koofr-user Your user name. Properties: - Config: user - Env Var: RCLONE_KOOFR_USER - Type: string - Required: true --koofr-password Your password for rclone generate one at https://app.koofr.net/app/admin/preferences/password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: password - Env Var: RCLONE_KOOFR_PASSWORD - Provider: koofr - Type: string - Required: true Advanced options Here are the Advanced options specific to koofr (Koofr, Digi Storage and other Koofr-compatible storage providers). --koofr-mountid Mount ID of the mount to use. If omitted, the primary mount is used. Properties: - Config: mountid - Env Var: RCLONE_KOOFR_MOUNTID - Type: string - Required: false --koofr-setmtime Does the backend support setting modification time. Set this to false if you use a mount ID that points to a Dropbox or Amazon Drive backend. Properties: - Config: setmtime - Env Var: RCLONE_KOOFR_SETMTIME - Type: bool - Default: true --koofr-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_KOOFR_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot --koofr-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_KOOFR_DESCRIPTION - Type: string - Required: false Limitations Note that Koofr is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". Providers Koofr This is the original Koofr storage provider used as main example and described in the configuration section above. Digi Storage Digi Storage is a cloud storage service run by Digi.ro that provides a Koofr API. Here is an example of how to make a remote called ds. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> ds Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] 22 / Koofr, Digi Storage and other Koofr-compatible storage providers \ (koofr) [snip] Storage> koofr Option provider. Choose your storage provider. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Koofr, https://app.koofr.net/ \ (koofr) 2 / Digi Storage, https://storage.rcs-rds.ro/ \ (digistorage) 3 / Any other Koofr API compatible storage service \ (other) provider> 2 Option user. Your user name. Enter a value. user> USERNAME Option password. Your password for rclone (generate one at https://storage.rcs-rds.ro/app/admin/preferences/password). Choose an alternative below. y) Yes, type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n -------------------- [ds] type = koofr provider = digistorage user = USERNAME password = *** ENCRYPTED *** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Other You may also want to use another, public or private storage provider that runs a Koofr API compatible service, by simply providing the base URL to connect to. Here is an example of how to make a remote called other. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> other Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] 22 / Koofr, Digi Storage and other Koofr-compatible storage providers \ (koofr) [snip] Storage> koofr Option provider. Choose your storage provider. Choose a number from below, or type in your own value. Press Enter to leave empty. 1 / Koofr, https://app.koofr.net/ \ (koofr) 2 / Digi Storage, https://storage.rcs-rds.ro/ \ (digistorage) 3 / Any other Koofr API compatible storage service \ (other) provider> 3 Option endpoint. The Koofr API endpoint to use. Enter a value. endpoint> https://koofr.other.org Option user. Your user name. Enter a value. user> USERNAME Option password. Your password for rclone (generate one at your service's settings page). Choose an alternative below. y) Yes, type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n -------------------- [other] type = koofr provider = other endpoint = https://koofr.other.org user = USERNAME password = *** ENCRYPTED *** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Linkbox Linkbox is a private cloud drive. Configuration Here is an example of making a remote for Linkbox. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. XX / Linkbox \ (linkbox) Storage> XX Option token. Token from https://www.linkbox.to/admin/account Enter a value. token> testFromCLToken Configuration complete. Options: - type: linkbox - token: XXXXXXXXXXX Keep this "linkbox" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Standard options Here are the Standard options specific to linkbox (Linkbox). --linkbox-token Token from https://www.linkbox.to/admin/account Properties: - Config: token - Env Var: RCLONE_LINKBOX_TOKEN - Type: string - Required: true Advanced options Here are the Advanced options specific to linkbox (Linkbox). --linkbox-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_LINKBOX_DESCRIPTION - Type: string - Required: false Limitations Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Mail.ru Cloud Mail.ru Cloud is a cloud storage provided by a Russian internet company Mail.Ru Group. The official desktop client is Disk-O:, available on Windows and Mac OS. Features highlights - Paths may be as deep as required, e.g. remote:directory/subdirectory - Files have a last modified time property, directories don't - Deleted files are by default moved to the trash - Files and directories can be shared via public links - Partial uploads or streaming are not supported, file size must be known before upload - Maximum file size is limited to 2G for a free account, unlimited for paid accounts - Storage keeps hash for all files and performs transparent deduplication, the hash algorithm is a modified SHA1 - If a particular file is already present in storage, one can quickly submit file hash instead of long file upload (this optimization is supported by rclone) Configuration Here is an example of making a mailru configuration. First create a Mail.ru Cloud account and choose a tariff. You will need to log in and create an app password for rclone. Rclone will not work with your normal username and password - it will give an error like oauth2: server response missing access_token. - Click on your user icon in the top right - Go to Security / "Пароль и безопасность" - Click password for apps / "Пароли для внешних приложений" - Add the password - give it a name - eg "rclone" - Select the permissions level. For some reason just "Full access to Cloud" (WebDav) doesn't work for Rclone currently. You have to select "Full access to Mail, Cloud and Calendar" (all protocols). (thread on forum.rclone.org) - Copy the password and use this password below - your normal login password won't work. Now run rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Mail.ru Cloud \ "mailru" [snip] Storage> mailru User name (usually email) Enter a string value. Press Enter for the default (""). user> username@mail.ru Password This must be an app password - rclone will not work with your normal password. See the Configuration section in the docs for how to make an app password. y) Yes type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Skip full upload if there is another file with same data hash. This feature is called "speedup" or "put by hash". It is especially efficient in case of generally available files like popular books, video or audio clips [snip] Enter a boolean value (true or false). Press Enter for the default ("true"). Choose a number from below, or type in your own value 1 / Enable \ "true" 2 / Disable \ "false" speedup_enable> 1 Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config Configuration complete. Options: - type: mailru - user: username@mail.ru - pass: *** ENCRYPTED *** - speedup_enable: true Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Configuration of this backend does not require a local web browser. You can use the configured backend as shown below: See top level directories rclone lsd remote: Make a new directory rclone mkdir remote:directory List the contents of a directory rclone ls remote:directory Sync /home/local/directory to the remote path, deleting any excess files in the path. rclone sync --interactive /home/local/directory remote:directory Modification times and hashes Files support a modification time attribute with up to 1 second precision. Directories do not have a modification time, which is shown as "Jan 1 1970". File hashes are supported, with a custom Mail.ru algorithm based on SHA1. If file size is less than or equal to the SHA1 block size (20 bytes), its hash is simply its data right-padded with zero bytes. Hashes of a larger file is computed as a SHA1 of the file data bytes concatenated with a decimal representation of the data length. Emptying Trash Removing a file or directory actually moves it to the trash, which is not visible to rclone but can be seen in a web browser. The trashed file still occupies part of total quota. If you wish to empty your trash and free some quota, you can use the rclone cleanup remote: command, which will permanently delete all your trashed files. This command does not take any path arguments. Quota information To view your current quota you can use the rclone about remote: command which will display your usage limit (quota) and the current usage. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- " 0x22 ＂ * 0x2A ＊ : 0x3A ： < 0x3C ＜ > 0x3E ＞ ? 0x3F ？ \ 0x5C ＼ | 0x7C ｜ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Standard options Here are the Standard options specific to mailru (Mail.ru Cloud). --mailru-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_MAILRU_CLIENT_ID - Type: string - Required: false --mailru-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_MAILRU_CLIENT_SECRET - Type: string - Required: false --mailru-user User name (usually email). Properties: - Config: user - Env Var: RCLONE_MAILRU_USER - Type: string - Required: true --mailru-pass Password. This must be an app password - rclone will not work with your normal password. See the Configuration section in the docs for how to make an app password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: pass - Env Var: RCLONE_MAILRU_PASS - Type: string - Required: true --mailru-speedup-enable Skip full upload if there is another file with same data hash. This feature is called "speedup" or "put by hash". It is especially efficient in case of generally available files like popular books, video or audio clips, because files are searched by hash in all accounts of all mailru users. It is meaningless and ineffective if source file is unique or encrypted. Please note that rclone may need local memory and disk space to calculate content hash in advance and decide whether full upload is required. Also, if rclone does not know file size in advance (e.g. in case of streaming or partial uploads), it will not even try this optimization. Properties: - Config: speedup_enable - Env Var: RCLONE_MAILRU_SPEEDUP_ENABLE - Type: bool - Default: true - Examples: - "true" - Enable - "false" - Disable Advanced options Here are the Advanced options specific to mailru (Mail.ru Cloud). --mailru-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_MAILRU_TOKEN - Type: string - Required: false --mailru-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_MAILRU_AUTH_URL - Type: string - Required: false --mailru-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_MAILRU_TOKEN_URL - Type: string - Required: false --mailru-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_MAILRU_CLIENT_CREDENTIALS - Type: bool - Default: false --mailru-speedup-file-patterns Comma separated list of file name patterns eligible for speedup (put by hash). Patterns are case insensitive and can contain '*' or '?' meta characters. Properties: - Config: speedup_file_patterns - Env Var: RCLONE_MAILRU_SPEEDUP_FILE_PATTERNS - Type: string - Default: ".mkv,.avi,.mp4,.mp3,.zip,.gz,.rar,.pdf" - Examples: - "" - Empty list completely disables speedup (put by hash). - "*" - All files will be attempted for speedup. - ".mkv,.avi,.mp4,.mp3" - Only common audio/video files will be tried for put by hash. - ".zip,.gz,.rar,.pdf" - Only common archives or PDF books will be tried for speedup. --mailru-speedup-max-disk This option allows you to disable speedup (put by hash) for large files. Reason is that preliminary hashing can exhaust your RAM or disk space. Properties: - Config: speedup_max_disk - Env Var: RCLONE_MAILRU_SPEEDUP_MAX_DISK - Type: SizeSuffix - Default: 3Gi - Examples: - "0" - Completely disable speedup (put by hash). - "1G" - Files larger than 1Gb will be uploaded directly. - "3G" - Choose this option if you have less than 3Gb free on local disk. --mailru-speedup-max-memory Files larger than the size given below will always be hashed on disk. Properties: - Config: speedup_max_memory - Env Var: RCLONE_MAILRU_SPEEDUP_MAX_MEMORY - Type: SizeSuffix - Default: 32Mi - Examples: - "0" - Preliminary hashing will always be done in a temporary disk location. - "32M" - Do not dedicate more than 32Mb RAM for preliminary hashing. - "256M" - You have at most 256Mb RAM free for hash calculations. --mailru-check-hash What should copy do if file checksum is mismatched or invalid. Properties: - Config: check_hash - Env Var: RCLONE_MAILRU_CHECK_HASH - Type: bool - Default: true - Examples: - "true" - Fail with error. - "false" - Ignore and continue. --mailru-user-agent HTTP user agent used internally by client. Defaults to "rclone/VERSION" or "--user-agent" provided on command line. Properties: - Config: user_agent - Env Var: RCLONE_MAILRU_USER_AGENT - Type: string - Required: false --mailru-quirks Comma separated list of internal maintenance flags. This option must not be used by an ordinary user. It is intended only to facilitate remote troubleshooting of backend issues. Strict meaning of flags is not documented and not guaranteed to persist between releases. Quirks will be removed when the backend grows stable. Supported quirks: atomicmkdir binlist unknowndirs Properties: - Config: quirks - Env Var: RCLONE_MAILRU_QUIRKS - Type: string - Required: false --mailru-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_MAILRU_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,InvalidUtf8,Dot --mailru-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_MAILRU_DESCRIPTION - Type: string - Required: false Limitations File size limits depend on your account. A single file size is limited by 2G for a free account and unlimited for paid tariffs. Please refer to the Mail.ru site for the total uploaded size limits. Note that Mailru is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". Mega Mega is a cloud storage and file hosting service known for its security feature where all files are encrypted locally before they are uploaded. This prevents anyone (including employees of Mega) from accessing the files without knowledge of the key used for encryption. This is an rclone backend for Mega which supports the file transfer features of Mega using the same client side encryption. Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. Configuration Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Mega \ "mega" [snip] Storage> mega User name user> you@example.com Password. y) Yes type in my own password g) Generate random password n) No leave this optional password blank y/g/n> y Enter the password: password: Confirm the password: password: Remote config Configuration complete. Options: - type: mega - user: you@example.com - pass: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y NOTE: The encryption keys need to have been already generated after a regular login via the browser, otherwise attempting to use the credentials in rclone will fail. Once configured you can then use rclone like this, List directories in top level of your Mega rclone lsd remote: List all the files in your Mega rclone ls remote: To copy a local directory to an Mega directory called backup rclone copy /home/source remote:backup Modification times and hashes Mega does not support modification times or hashes yet. Restricted filename characters Character Value Replacement ----------- ------- ------------- NUL 0x00 ␀ / 0x2F ／ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Duplicated files Mega can have two files with exactly the same name and path (unlike a normal file system). Duplicated files cause problems with the syncing and you will see messages in the log about duplicates. Use rclone dedupe to fix duplicated files. Failure to log-in Object not found If you are connecting to your Mega remote for the first time, to test access and synchronization, you may receive an error such as Failed to create file system for "my-mega-remote:": couldn't login: Object (typically, node or user) not found The diagnostic steps often recommended in the rclone forum start with the MEGAcmd utility. Note that this refers to the official C++ command from https://github.com/meganz/MEGAcmd and not the go language built command from t3rm1n4l/megacmd that is no longer maintained. Follow the instructions for installing MEGAcmd and try accessing your remote as they recommend. You can establish whether or not you can log in using MEGAcmd, and obtain diagnostic information to help you, and search or work with others in the forum. MEGA CMD> login me@example.com Password: Fetching nodes ... Loading transfers from local cache Login complete as me@example.com me@example.com:/$ Note that some have found issues with passwords containing special characters. If you can not log on with rclone, but MEGAcmd logs on just fine, then consider changing your password temporarily to pure alphanumeric characters, in case that helps. Repeated commands blocks access Mega remotes seem to get blocked (reject logins) under "heavy use". We haven't worked out the exact blocking rules but it seems to be related to fast paced, successive rclone commands. For example, executing this command 90 times in a row rclone link remote:file will cause the remote to become "blocked". This is not an abnormal situation, for example if you wish to get the public links of a directory with hundred of files... After more or less a week, the remote will remote accept rclone logins normally again. You can mitigate this issue by mounting the remote it with rclone mount. This will log-in when mounting and a log-out when unmounting only. You can also run rclone rcd and then use rclone rc to run the commands over the API to avoid logging in each time. Rclone does not currently close mega sessions (you can see them in the web interface), however closing the sessions does not solve the issue. If you space rclone commands by 3 seconds it will avoid blocking the remote. We haven't identified the exact blocking rules, so perhaps one could execute the command 80 times without waiting and avoid blocking by waiting 3 seconds, then continuing... Note that this has been observed by trial and error and might not be set in stone. Other tools seem not to produce this blocking effect, as they use a different working approach (state-based, using sessionIDs instead of log-in) which isn't compatible with the current stateless rclone approach. Note that once blocked, the use of other tools (such as megacmd) is not a sure workaround: following megacmd login times have been observed in succession for blocked remote: 7 minutes, 20 min, 30min, 30 min, 30min. Web access looks unaffected though. Investigation is continuing in relation to workarounds based on timeouts, pacers, retrials and tpslimits - if you discover something relevant, please post on the forum. So, if rclone was working nicely and suddenly you are unable to log-in and you are sure the user and the password are correct, likely you have got the remote blocked for a while. Standard options Here are the Standard options specific to mega (Mega). --mega-user User name. Properties: - Config: user - Env Var: RCLONE_MEGA_USER - Type: string - Required: true --mega-pass Password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: pass - Env Var: RCLONE_MEGA_PASS - Type: string - Required: true Advanced options Here are the Advanced options specific to mega (Mega). --mega-debug Output more debug from Mega. If this flag is set (along with -vv) it will print further debugging information from the mega backend. Properties: - Config: debug - Env Var: RCLONE_MEGA_DEBUG - Type: bool - Default: false --mega-hard-delete Delete files permanently rather than putting them into the trash. Normally the mega backend will put all deletions into the trash rather than permanently deleting them. If you specify this then rclone will permanently delete objects instead. Properties: - Config: hard_delete - Env Var: RCLONE_MEGA_HARD_DELETE - Type: bool - Default: false --mega-use-https Use HTTPS for transfers. MEGA uses plain text HTTP connections by default. Some ISPs throttle HTTP connections, this causes transfers to become very slow. Enabling this will force MEGA to use HTTPS for all transfers. HTTPS is normally not necessary since all data is already encrypted anyway. Enabling it will increase CPU usage and add network overhead. Properties: - Config: use_https - Env Var: RCLONE_MEGA_USE_HTTPS - Type: bool - Default: false --mega-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_MEGA_ENCODING - Type: Encoding - Default: Slash,InvalidUtf8,Dot --mega-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_MEGA_DESCRIPTION - Type: string - Required: false Process killed On accounts with large files or something else, memory usage can significantly increase when executing list/sync instructions. When running on cloud providers (like AWS with EC2), check if the instance type has sufficient memory/CPU to execute the commands. Use the resource monitoring tools to inspect after sending the commands. Look at this issue. Limitations This backend uses the go-mega go library which is an opensource go library implementing the Mega API. There doesn't appear to be any documentation for the mega protocol beyond the mega C++ SDK source code so there are likely quite a few errors still remaining in this library. Mega allows duplicate files which may confuse rclone. Memory The memory backend is an in RAM backend. It does not persist its data - use the local backend for that. The memory backend behaves like a bucket-based remote (e.g. like s3). Because it has no parameters you can just use it with the :memory: remote name. Configuration You can configure it as a remote like this with rclone config too if you want to: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Memory \ "memory" [snip] Storage> memory ** See help for memory backend at: https://rclone.org/memory/ ** Remote config Configuration complete. Options: - type: memory Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Because the memory backend isn't persistent it is most useful for testing or with an rclone server or rclone mount, e.g. rclone mount :memory: /mnt/tmp rclone serve webdav :memory: rclone serve sftp :memory: Modification times and hashes The memory backend supports MD5 hashes and modification times accurate to 1 nS. Restricted filename characters The memory backend replaces the default restricted characters set. Advanced options Here are the Advanced options specific to memory (In memory object storage system.). --memory-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_MEMORY_DESCRIPTION - Type: string - Required: false Akamai NetStorage Paths are specified as remote: You may put subdirectories in too, e.g. remote:/path/to/dir. If you have a CP code you can use that as the folder after the domain such as //. For example, this is commonly configured with or without a CP code: * With a CP code. [your-domain-prefix]-nsu.akamaihd.net/123456/subdirectory/ * Without a CP code. [your-domain-prefix]-nsu.akamaihd.net See all buckets rclone lsd remote: The initial setup for Netstorage involves getting an account and secret. Use rclone config to walk you through the setup process. Configuration Here's an example of how to make a remote called ns1. 1. To begin the interactive configuration process, enter this command: rclone config 2. Type n to create a new remote. n) New remote d) Delete remote q) Quit config e/n/d/q> n 3. For this example, enter ns1 when you reach the name> prompt. name> ns1 4. Enter netstorage as the type of storage to configure. Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value XX / NetStorage \ "netstorage" Storage> netstorage 5. Select between the HTTP or HTTPS protocol. Most users should choose HTTPS, which is the default. HTTP is provided primarily for debugging purposes. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / HTTP protocol \ "http" 2 / HTTPS protocol \ "https" protocol> 1 6. Specify your NetStorage host, CP code, and any necessary content paths using this format: /// Enter a string value. Press Enter for the default (""). host> baseball-nsu.akamaihd.net/123456/content/ 7. Set the netstorage account name Enter a string value. Press Enter for the default (""). account> username 8. Set the Netstorage account secret/G2O key which will be used for authentication purposes. Select the y option to set your own password then enter your secret. Note: The secret is stored in the rclone.conf file with hex-encoded encryption. y) Yes type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: 9. View the summary and confirm your remote configuration. [ns1] type = netstorage protocol = http host = baseball-nsu.akamaihd.net/123456/content/ account = username secret = *** ENCRYPTED *** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y This remote is called ns1 and can now be used. Example operations Get started with rclone and NetStorage with these examples. For additional rclone commands, visit https://rclone.org/commands/. See contents of a directory in your project rclone lsd ns1:/974012/testing/ Sync the contents local with remote rclone sync . ns1:/974012/testing/ Upload local content to remote rclone copy notes.txt ns1:/974012/testing/ Delete content on remote rclone delete ns1:/974012/testing/notes.txt Move or copy content between CP codes. Your credentials must have access to two CP codes on the same remote. You can't perform operations between different remotes. rclone move ns1:/974012/testing/notes.txt ns1:/974450/testing2/ Features Symlink Support The Netstorage backend changes the rclone --links, -l behavior. When uploading, instead of creating the .rclonelink file, use the "symlink" API in order to create the corresponding symlink on the remote. The .rclonelink file will not be created, the upload will be intercepted and only the symlink file that matches the source file name with no suffix will be created on the remote. This will effectively allow commands like copy/copyto, move/moveto and sync to upload from local to remote and download from remote to local directories with symlinks. Due to internal rclone limitations, it is not possible to upload an individual symlink file to any remote backend. You can always use the "backend symlink" command to create a symlink on the NetStorage server, refer to "symlink" section below. Individual symlink files on the remote can be used with the commands like "cat" to print the destination name, or "delete" to delete symlink, or copy, copy/to and move/moveto to download from the remote to local. Note: individual symlink files on the remote should be specified including the suffix .rclonelink. Note: No file with the suffix .rclonelink should ever exist on the server since it is not possible to actually upload/create a file with .rclonelink suffix with rclone, it can only exist if it is manually created through a non-rclone method on the remote. Implicit vs. Explicit Directories With NetStorage, directories can exist in one of two forms: 1. Explicit Directory. This is an actual, physical directory that you have created in a storage group. 2. Implicit Directory. This refers to a directory within a path that has not been physically created. For example, during upload of a file, nonexistent subdirectories can be specified in the target path. NetStorage creates these as "implicit." While the directories aren't physically created, they exist implicitly and the noted path is connected with the uploaded file. Rclone will intercept all file uploads and mkdir commands for the NetStorage remote and will explicitly issue the mkdir command for each directory in the uploading path. This will help with the interoperability with the other Akamai services such as SFTP and the Content Management Shell (CMShell). Rclone will not guarantee correctness of operations with implicit directories which might have been created as a result of using an upload API directly. --fast-list / ListR support NetStorage remote supports the ListR feature by using the "list" NetStorage API action to return a lexicographical list of all objects within the specified CP code, recursing into subdirectories as they're encountered. - Rclone will use the ListR method for some commands by default. Commands such as lsf -R will use ListR by default. To disable this, include the --disable listR option to use the non-recursive method of listing objects. - Rclone will not use the ListR method for some commands. Commands such as sync don't use ListR by default. To force using the ListR method, include the --fast-list option. There are pros and cons of using the ListR method, refer to rclone documentation. In general, the sync command over an existing deep tree on the remote will run faster with the "--fast-list" flag but with extra memory usage as a side effect. It might also result in higher CPU utilization but the whole task can be completed faster. Note: There is a known limitation that "lsf -R" will display number of files in the directory and directory size as -1 when ListR method is used. The workaround is to pass "--disable listR" flag if these numbers are important in the output. Purge NetStorage remote supports the purge feature by using the "quick-delete" NetStorage API action. The quick-delete action is disabled by default for security reasons and can be enabled for the account through the Akamai portal. Rclone will first try to use quick-delete action for the purge command and if this functionality is disabled then will fall back to a standard delete method. Note: Read the NetStorage Usage API for considerations when using "quick-delete". In general, using quick-delete method will not delete the tree immediately and objects targeted for quick-delete may still be accessible. Standard options Here are the Standard options specific to netstorage (Akamai NetStorage). --netstorage-host Domain+path of NetStorage host to connect to. Format should be / Properties: - Config: host - Env Var: RCLONE_NETSTORAGE_HOST - Type: string - Required: true --netstorage-account Set the NetStorage account name Properties: - Config: account - Env Var: RCLONE_NETSTORAGE_ACCOUNT - Type: string - Required: true --netstorage-secret Set the NetStorage account secret/G2O key for authentication. Please choose the 'y' option to set your own password then enter your secret. NB Input to this must be obscured - see rclone obscure. Properties: - Config: secret - Env Var: RCLONE_NETSTORAGE_SECRET - Type: string - Required: true Advanced options Here are the Advanced options specific to netstorage (Akamai NetStorage). --netstorage-protocol Select between HTTP or HTTPS protocol. Most users should choose HTTPS, which is the default. HTTP is provided primarily for debugging purposes. Properties: - Config: protocol - Env Var: RCLONE_NETSTORAGE_PROTOCOL - Type: string - Default: "https" - Examples: - "http" - HTTP protocol - "https" - HTTPS protocol --netstorage-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_NETSTORAGE_DESCRIPTION - Type: string - Required: false Backend commands Here are the commands specific to the netstorage backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the backend command for more info on how to pass options and arguments. These can be run on a running backend using the rc command backend/command. du Return disk usage information for a specified directory rclone backend du remote: [options] [+] The usage information returned, includes the targeted directory as well as all files stored in any sub-directories that may exist. symlink You can create a symbolic link in ObjectStore with the symlink action. rclone backend symlink remote: [options] [+] The desired path location (including applicable sub-directories) ending in the object that will be the target of the symlink (for example, /links/mylink). Include the file extension for the object, if applicable. rclone backend symlink Microsoft Azure Blob Storage Paths are specified as remote:container (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:container/path/to/dir. Configuration Here is an example of making a Microsoft Azure Blob Storage configuration. For a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Microsoft Azure Blob Storage \ "azureblob" [snip] Storage> azureblob Storage Account Name account> account_name Storage Account Key key> base64encodedkey== Endpoint for the service - leave blank normally. endpoint> Remote config Configuration complete. Options: - type: azureblob - account: account_name - key: base64encodedkey== - endpoint: Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y See all containers rclone lsd remote: Make a new container rclone mkdir remote:container List the contents of a container rclone ls remote:container Sync /home/local/directory to the remote container, deleting any excess files in the container. rclone sync --interactive /home/local/directory remote:container --fast-list This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details. Modification times and hashes The modification time is stored as metadata on the object with the mtime key. It is stored using RFC3339 Format time with nanosecond precision. The metadata is supplied during directory listings so there is no performance overhead to using it. If you wish to use the Azure standard LastModified time stored on the object as the modified time, then use the --use-server-modtime flag. Note that rclone can't set LastModified, so using the --update flag when syncing is recommended if using --use-server-modtime. MD5 hashes are stored with blobs. However blobs that were uploaded in chunks only have an MD5 if the source remote was capable of MD5 hashes, e.g. the local disk. Performance When uploading large files, increasing the value of --azureblob-upload-concurrency will increase performance at the cost of using more memory. The default of 16 is set quite conservatively to use less memory. It maybe be necessary raise it to 64 or higher to fully utilize a 1 GBit/s link with a single file transfer. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- / 0x2F ／ \ 0x5C ＼ File names can also not end with the following characters. These only get replaced if they are the last character in the name: Character Value Replacement ----------- ------- ------------- . 0x2E ． Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Authentication There are a number of ways of supplying credentials for Azure Blob Storage. Rclone tries them in the order of the sections below. Env Auth If the env_auth config parameter is true then rclone will pull credentials from the environment or runtime. It tries these authentication methods in this order: 1. Environment Variables 2. Managed Service Identity Credentials 3. Azure CLI credentials (as used by the az tool) These are described in the following sections Env Auth: 1. Environment Variables If env_auth is set and environment variables are present rclone authenticates a service principal with a secret or certificate, or a user with a password, depending on which environment variable are set. It reads configuration from these variables, in the following order: 1. Service principal with client secret - AZURE_TENANT_ID: ID of the service principal's tenant. Also called its "directory" ID. - AZURE_CLIENT_ID: the service principal's client ID - AZURE_CLIENT_SECRET: one of the service principal's client secrets 2. Service principal with certificate - AZURE_TENANT_ID: ID of the service principal's tenant. Also called its "directory" ID. - AZURE_CLIENT_ID: the service principal's client ID - AZURE_CLIENT_CERTIFICATE_PATH: path to a PEM or PKCS12 certificate file including the private key. - AZURE_CLIENT_CERTIFICATE_PASSWORD: (optional) password for the certificate file. - AZURE_CLIENT_SEND_CERTIFICATE_CHAIN: (optional) Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to "true" or "1", authentication requests include the x5c header. 3. User with username and password - AZURE_TENANT_ID: (optional) tenant to authenticate in. Defaults to "organizations". - AZURE_CLIENT_ID: client ID of the application the user will authenticate to - AZURE_USERNAME: a username (usually an email address) - AZURE_PASSWORD: the user's password 4. Workload Identity - AZURE_TENANT_ID: Tenant to authenticate in. - AZURE_CLIENT_ID: Client ID of the application the user will authenticate to. - AZURE_FEDERATED_TOKEN_FILE: Path to projected service account token file. - AZURE_AUTHORITY_HOST: Authority of an Azure Active Directory endpoint (default: login.microsoftonline.com). Env Auth: 2. Managed Service Identity Credentials When using Managed Service Identity if the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default. If the resource has multiple user-assigned identities you will need to unset env_auth and set use_msi instead. See the use_msi section. If you are operating in disconnected clouds, or private clouds such as Azure Stack you may want to set disable_instance_discovery = true. This determines whether rclone requests Microsoft Entra instance metadata from https://login.microsoft.com/ before authenticating. Setting this to true will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy. Env Auth: 3. Azure CLI credentials (as used by the az tool) Credentials created with the az tool can be picked up using env_auth. For example if you were to login with a service principal like this: az login --service-principal -u XXX -p XXX --tenant XXX Then you could access rclone resources like this: rclone lsf :azureblob,env_auth,account=ACCOUNT:CONTAINER Or rclone lsf --azureblob-env-auth --azureblob-account=ACCOUNT :azureblob:CONTAINER Which is analogous to using the az tool: az storage blob list --container-name CONTAINER --account-name ACCOUNT --auth-mode login Account and Shared Key This is the most straight forward and least flexible way. Just fill in the account and key lines and leave the rest blank. SAS URL This can be an account level SAS URL or container level SAS URL. To use it leave account and key blank and fill in sas_url. An account level SAS URL or container level SAS URL can be obtained from the Azure portal or the Azure Storage Explorer. To get a container level SAS URL right click on a container in the Azure Blob explorer in the Azure portal. If you use a container level SAS URL, rclone operations are permitted only on a particular container, e.g. rclone ls azureblob:container You can also list the single container from the root. This will only show the container specified by the SAS URL. $ rclone lsd azureblob: container/ Note that you can't see or access any other containers - this will fail rclone ls azureblob:othercontainer Container level SAS URLs are useful for temporarily allowing third parties access to a single container or putting credentials into an untrusted environment such as a CI build server. Service principal with client secret If these variables are set, rclone will authenticate with a service principal with a client secret. - tenant: ID of the service principal's tenant. Also called its "directory" ID. - client_id: the service principal's client ID - client_secret: one of the service principal's client secrets The credentials can also be placed in a file using the service_principal_file configuration option. Service principal with certificate If these variables are set, rclone will authenticate with a service principal with certificate. - tenant: ID of the service principal's tenant. Also called its "directory" ID. - client_id: the service principal's client ID - client_certificate_path: path to a PEM or PKCS12 certificate file including the private key. - client_certificate_password: (optional) password for the certificate file. - client_send_certificate_chain: (optional) Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to "true" or "1", authentication requests include the x5c header. NB client_certificate_password must be obscured - see rclone obscure. User with username and password If these variables are set, rclone will authenticate with username and password. - tenant: (optional) tenant to authenticate in. Defaults to "organizations". - client_id: client ID of the application the user will authenticate to - username: a username (usually an email address) - password: the user's password Microsoft doesn't recommend this kind of authentication, because it's less secure than other authentication flows. This method is not interactive, so it isn't compatible with any form of multi-factor authentication, and the application must already have user or admin consent. This credential can only authenticate work and school accounts; it can't authenticate Microsoft accounts. NB password must be obscured - see rclone obscure. Managed Service Identity Credentials If use_msi is set then managed service identity credentials are used. This authentication only works when running in an Azure service. env_auth needs to be unset to use this. However if you have multiple user identities to choose from these must be explicitly specified using exactly one of the msi_object_id, msi_client_id, or msi_mi_res_id parameters. If none of msi_object_id, msi_client_id, or msi_mi_res_id is set, this is is equivalent to using env_auth. Fedrated Identity Credentials If these variables are set, rclone will authenticate with fedrated identity. - tenant_id: tenant_id to authenticate in storage - client_id: client ID of the application the user will authenticate to storage - msi_client_id: managed identity client ID of the application the user will authenticate to By default "api://AzureADTokenExchange" is used as scope for token retrieval over MSI. This token is then exchanged for actual storage token using 'tenant_id' and 'client_id'. Azure CLI tool az Set to use the Azure CLI tool az as the sole means of authentication. Setting this can be useful if you wish to use the az CLI on a host with a System Managed Identity that you do not want to use. Don't set env_auth at the same time. Anonymous If you want to access resources with public anonymous access then set account only. You can do this without making an rclone config: rclone lsf :azureblob,account=ACCOUNT:CONTAINER Standard options Here are the Standard options specific to azureblob (Microsoft Azure Blob Storage). --azureblob-account Azure Storage Account Name. Set this to the Azure Storage Account Name in use. Leave blank to use SAS URL or Emulator, otherwise it needs to be set. If this is blank and if env_auth is set it will be read from the environment variable AZURE_STORAGE_ACCOUNT_NAME if possible. Properties: - Config: account - Env Var: RCLONE_AZUREBLOB_ACCOUNT - Type: string - Required: false --azureblob-env-auth Read credentials from runtime (environment variables, CLI or MSI). See the authentication docs for full info. Properties: - Config: env_auth - Env Var: RCLONE_AZUREBLOB_ENV_AUTH - Type: bool - Default: false --azureblob-key Storage Account Shared Key. Leave blank to use SAS URL or Emulator. Properties: - Config: key - Env Var: RCLONE_AZUREBLOB_KEY - Type: string - Required: false --azureblob-sas-url SAS URL for container level access only. Leave blank if using account/key or Emulator. Properties: - Config: sas_url - Env Var: RCLONE_AZUREBLOB_SAS_URL - Type: string - Required: false --azureblob-tenant ID of the service principal's tenant. Also called its directory ID. Set this if using - Service principal with client secret - Service principal with certificate - User with username and password Properties: - Config: tenant - Env Var: RCLONE_AZUREBLOB_TENANT - Type: string - Required: false --azureblob-client-id The ID of the client in use. Set this if using - Service principal with client secret - Service principal with certificate - User with username and password Properties: - Config: client_id - Env Var: RCLONE_AZUREBLOB_CLIENT_ID - Type: string - Required: false --azureblob-client-secret One of the service principal's client secrets Set this if using - Service principal with client secret Properties: - Config: client_secret - Env Var: RCLONE_AZUREBLOB_CLIENT_SECRET - Type: string - Required: false --azureblob-client-certificate-path Path to a PEM or PKCS12 certificate file including the private key. Set this if using - Service principal with certificate Properties: - Config: client_certificate_path - Env Var: RCLONE_AZUREBLOB_CLIENT_CERTIFICATE_PATH - Type: string - Required: false --azureblob-client-certificate-password Password for the certificate file (optional). Optionally set this if using - Service principal with certificate And the certificate has a password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: client_certificate_password - Env Var: RCLONE_AZUREBLOB_CLIENT_CERTIFICATE_PASSWORD - Type: string - Required: false Advanced options Here are the Advanced options specific to azureblob (Microsoft Azure Blob Storage). --azureblob-client-send-certificate-chain Send the certificate chain when using certificate auth. Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to true, authentication requests include the x5c header. Optionally set this if using - Service principal with certificate Properties: - Config: client_send_certificate_chain - Env Var: RCLONE_AZUREBLOB_CLIENT_SEND_CERTIFICATE_CHAIN - Type: bool - Default: false --azureblob-username User name (usually an email address) Set this if using - User with username and password Properties: - Config: username - Env Var: RCLONE_AZUREBLOB_USERNAME - Type: string - Required: false --azureblob-password The user's password Set this if using - User with username and password NB Input to this must be obscured - see rclone obscure. Properties: - Config: password - Env Var: RCLONE_AZUREBLOB_PASSWORD - Type: string - Required: false --azureblob-service-principal-file Path to file containing credentials for use with a service principal. Leave blank normally. Needed only if you want to use a service principal instead of interactive login. $ az ad sp create-for-rbac --name "" \ --role "Storage Blob Data Owner" \ --scopes "/subscriptions//resourceGroups//providers/Microsoft.Storage/storageAccounts//blobServices/default/containers/" \ > azure-principal.json See "Create an Azure service principal" and "Assign an Azure role for access to blob data" pages for more details. It may be more convenient to put the credentials directly into the rclone config file under the client_id, tenant and client_secret keys instead of setting service_principal_file. Properties: - Config: service_principal_file - Env Var: RCLONE_AZUREBLOB_SERVICE_PRINCIPAL_FILE - Type: string - Required: false --azureblob-disable-instance-discovery Skip requesting Microsoft Entra instance metadata This should be set true only by applications authenticating in disconnected clouds, or private clouds such as Azure Stack. It determines whether rclone requests Microsoft Entra instance metadata from https://login.microsoft.com/ before authenticating. Setting this to true will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy. Properties: - Config: disable_instance_discovery - Env Var: RCLONE_AZUREBLOB_DISABLE_INSTANCE_DISCOVERY - Type: bool - Default: false --azureblob-use-msi Use a managed service identity to authenticate (only works in Azure). When true, use a managed service identity to authenticate to Azure Storage instead of a SAS token or account key. If the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default. If the resource has multiple user-assigned identities, the identity to use must be explicitly specified using exactly one of the msi_object_id, msi_client_id, or msi_mi_res_id parameters. Properties: - Config: use_msi - Env Var: RCLONE_AZUREBLOB_USE_MSI - Type: bool - Default: false --azureblob-msi-object-id Object ID of the user-assigned MSI to use, if any. Leave blank if msi_client_id or msi_mi_res_id specified. Properties: - Config: msi_object_id - Env Var: RCLONE_AZUREBLOB_MSI_OBJECT_ID - Type: string - Required: false --azureblob-msi-client-id Object ID of the user-assigned MSI to use, if any. Leave blank if msi_object_id or msi_mi_res_id specified. Properties: - Config: msi_client_id - Env Var: RCLONE_AZUREBLOB_MSI_CLIENT_ID - Type: string - Required: false --azureblob-msi-mi-res-id Azure resource ID of the user-assigned MSI to use, if any. Leave blank if msi_client_id or msi_object_id specified. Properties: - Config: msi_mi_res_id - Env Var: RCLONE_AZUREBLOB_MSI_MI_RES_ID - Type: string - Required: false --azureblob-use-emulator Uses local storage emulator if provided as 'true'. Leave blank if using real azure storage endpoint. Properties: - Config: use_emulator - Env Var: RCLONE_AZUREBLOB_USE_EMULATOR - Type: bool - Default: false --azureblob-use-az Use Azure CLI tool az for authentication Set to use the Azure CLI tool az as the sole means of authentication. Setting this can be useful if you wish to use the az CLI on a host with a System Managed Identity that you do not want to use. Don't set env_auth at the same time. Properties: - Config: use_az - Env Var: RCLONE_AZUREBLOB_USE_AZ - Type: bool - Default: false --azureblob-endpoint Endpoint for the service. Leave blank normally. Properties: - Config: endpoint - Env Var: RCLONE_AZUREBLOB_ENDPOINT - Type: string - Required: false --azureblob-upload-cutoff Cutoff for switching to chunked upload (<= 256 MiB) (deprecated). Properties: - Config: upload_cutoff - Env Var: RCLONE_AZUREBLOB_UPLOAD_CUTOFF - Type: string - Required: false --azureblob-chunk-size Upload chunk size. Note that this is stored in memory and there may be up to "--transfers" * "--azureblob-upload-concurrency" chunks stored at once in memory. Properties: - Config: chunk_size - Env Var: RCLONE_AZUREBLOB_CHUNK_SIZE - Type: SizeSuffix - Default: 4Mi --azureblob-upload-concurrency Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. In tests, upload speed increases almost linearly with upload concurrency. For example to fill a gigabit pipe it may be necessary to raise this to 64. Note that this will use more memory. Note that chunks are stored in memory and there may be up to "--transfers" * "--azureblob-upload-concurrency" chunks stored at once in memory. Properties: - Config: upload_concurrency - Env Var: RCLONE_AZUREBLOB_UPLOAD_CONCURRENCY - Type: int - Default: 16 --azureblob-copy-cutoff Cutoff for switching to multipart copy. Any files larger than this that need to be server-side copied will be copied in chunks of chunk_size using the put block list API. Files smaller than this limit will be copied with the Copy Blob API. Properties: - Config: copy_cutoff - Env Var: RCLONE_AZUREBLOB_COPY_CUTOFF - Type: SizeSuffix - Default: 8Mi --azureblob-copy-concurrency Concurrency for multipart copy. This is the number of chunks of the same file that are copied concurrently. These chunks are not buffered in memory and Microsoft recommends setting this value to greater than 1000 in the azcopy documentation. https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azcopy-optimize#increase-concurrency In tests, copy speed increases almost linearly with copy concurrency. Properties: - Config: copy_concurrency - Env Var: RCLONE_AZUREBLOB_COPY_CONCURRENCY - Type: int - Default: 512 --azureblob-use-copy-blob Whether to use the Copy Blob API when copying to the same storage account. If true (the default) then rclone will use the Copy Blob API for copies to the same storage account even when the size is above the copy_cutoff. Rclone assumes that the same storage account means the same config and does not check for the same storage account in different configs. There should be no need to change this value. Properties: - Config: use_copy_blob - Env Var: RCLONE_AZUREBLOB_USE_COPY_BLOB - Type: bool - Default: true --azureblob-list-chunk Size of blob list. This sets the number of blobs requested in each listing chunk. Default is the maximum, 5000. "List blobs" requests are permitted 2 minutes per megabyte to complete. If an operation is taking longer than 2 minutes per megabyte on average, it will time out ( source ). This can be used to limit the number of blobs items to return, to avoid the time out. Properties: - Config: list_chunk - Env Var: RCLONE_AZUREBLOB_LIST_CHUNK - Type: int - Default: 5000 --azureblob-access-tier Access tier of blob: hot, cool, cold or archive. Archived blobs can be restored by setting access tier to hot, cool or cold. Leave blank if you intend to use default access tier, which is set at account level If there is no "access tier" specified, rclone doesn't apply any tier. rclone performs "Set Tier" operation on blobs while uploading, if objects are not modified, specifying "access tier" to new one will have no effect. If blobs are in "archive tier" at remote, trying to perform data transfer operations from remote will not be allowed. User should first restore by tiering blob to "Hot", "Cool" or "Cold". Properties: - Config: access_tier - Env Var: RCLONE_AZUREBLOB_ACCESS_TIER - Type: string - Required: false --azureblob-archive-tier-delete Delete archive tier blobs before overwriting. Archive tier blobs cannot be updated. So without this flag, if you attempt to update an archive tier blob, then rclone will produce the error: can't update archive tier blob without --azureblob-archive-tier-delete With this flag set then before rclone attempts to overwrite an archive tier blob, it will delete the existing blob before uploading its replacement. This has the potential for data loss if the upload fails (unlike updating a normal blob) and also may cost more since deleting archive tier blobs early may be chargable. Properties: - Config: archive_tier_delete - Env Var: RCLONE_AZUREBLOB_ARCHIVE_TIER_DELETE - Type: bool - Default: false --azureblob-disable-checksum Don't store MD5 checksum with object metadata. Normally rclone will calculate the MD5 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading. Properties: - Config: disable_checksum - Env Var: RCLONE_AZUREBLOB_DISABLE_CHECKSUM - Type: bool - Default: false --azureblob-memory-pool-flush-time How often internal memory buffer pools will be flushed. (no longer used) Properties: - Config: memory_pool_flush_time - Env Var: RCLONE_AZUREBLOB_MEMORY_POOL_FLUSH_TIME - Type: Duration - Default: 1m0s --azureblob-memory-pool-use-mmap Whether to use mmap buffers in internal memory pool. (no longer used) Properties: - Config: memory_pool_use_mmap - Env Var: RCLONE_AZUREBLOB_MEMORY_POOL_USE_MMAP - Type: bool - Default: false --azureblob-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_AZUREBLOB_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,RightPeriod,InvalidUtf8 --azureblob-public-access Public access level of a container: blob or container. Properties: - Config: public_access - Env Var: RCLONE_AZUREBLOB_PUBLIC_ACCESS - Type: string - Required: false - Examples: - "" - The container and its blobs can be accessed only with an authorized request. - It's a default value. - "blob" - Blob data within this container can be read via anonymous request. - "container" - Allow full public read access for container and blob data. --azureblob-directory-markers Upload an empty object with a trailing slash when a new directory is created Empty folders are unsupported for bucket based remotes, this option creates an empty object ending with "/", to persist the folder. This object also has the metadata "hdi_isfolder = true" to conform to the Microsoft standard. Properties: - Config: directory_markers - Env Var: RCLONE_AZUREBLOB_DIRECTORY_MARKERS - Type: bool - Default: false --azureblob-no-check-container If set, don't attempt to check the container exists or create it. This can be useful when trying to minimise the number of transactions rclone does if you know the container exists already. Properties: - Config: no_check_container - Env Var: RCLONE_AZUREBLOB_NO_CHECK_CONTAINER - Type: bool - Default: false --azureblob-no-head-object If set, do not do HEAD before GET when getting objects. Properties: - Config: no_head_object - Env Var: RCLONE_AZUREBLOB_NO_HEAD_OBJECT - Type: bool - Default: false --azureblob-delete-snapshots Set to specify how to deal with snapshots on blob deletion. Properties: - Config: delete_snapshots - Env Var: RCLONE_AZUREBLOB_DELETE_SNAPSHOTS - Type: string - Required: false - Choices: - "" - By default, the delete operation fails if a blob has snapshots - "include" - Specify 'include' to remove the root blob and all its snapshots - "only" - Specify 'only' to remove only the snapshots but keep the root blob. --azureblob-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_AZUREBLOB_DESCRIPTION - Type: string - Required: false Custom upload headers You can set custom upload headers with the --header-upload flag. - Cache-Control - Content-Disposition - Content-Encoding - Content-Language - Content-Type - X-MS-Tags Eg --header-upload "Content-Type: text/potato" or --header-upload "X-MS-Tags: foo=bar" Limitations MD5 sums are only uploaded with chunked files if the source has an MD5 sum. This will always be the case for a local to azure copy. rclone about is not supported by the Microsoft Azure Blob storage backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about Azure Storage Emulator Support You can run rclone with the storage emulator (usually azurite). To do this, just set up a new remote with rclone config following the instructions in the introduction and set use_emulator in the advanced settings as true. You do not need to provide a default account name nor an account key. But you can override them in the account and key options. (Prior to v1.61 they were hard coded to azurite's devstoreaccount1.) Also, if you want to access a storage emulator instance running on a different machine, you can override the endpoint parameter in the advanced settings, setting it to http(s)://:/devstoreaccount1 (e.g. http://10.254.2.5:10000/devstoreaccount1). Microsoft Azure Files Storage Paths are specified as remote: You may put subdirectories in too, e.g. remote:path/to/dir. Configuration Here is an example of making a Microsoft Azure Files Storage configuration. For a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Microsoft Azure Files Storage \ "azurefiles" [snip] Option account. Azure Storage Account Name. Set this to the Azure Storage Account Name in use. Leave blank to use SAS URL or connection string, otherwise it needs to be set. If this is blank and if env_auth is set it will be read from the environment variable `AZURE_STORAGE_ACCOUNT_NAME` if possible. Enter a value. Press Enter to leave empty. account> account_name Option share_name. Azure Files Share Name. This is required and is the name of the share to access. Enter a value. Press Enter to leave empty. share_name> share_name Option env_auth. Read credentials from runtime (environment variables, CLI or MSI). See the [authentication docs](/azurefiles#authentication) for full info. Enter a boolean value (true or false). Press Enter for the default (false). env_auth> Option key. Storage Account Shared Key. Leave blank to use SAS URL or connection string. Enter a value. Press Enter to leave empty. key> base64encodedkey== Option sas_url. SAS URL. Leave blank if using account/key or connection string. Enter a value. Press Enter to leave empty. sas_url> Option connection_string. Azure Files Connection String. Enter a value. Press Enter to leave empty. connection_string> [snip] Configuration complete. Options: - type: azurefiles - account: account_name - share_name: share_name - key: base64encodedkey== Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> Once configured you can use rclone. See all files in the top level: rclone lsf remote: Make a new directory in the root: rclone mkdir remote:dir Recursively List the contents: rclone ls remote: Sync /home/local/directory to the remote directory, deleting any excess files in the directory. rclone sync --interactive /home/local/directory remote:dir Modified time The modified time is stored as Azure standard LastModified time on files Performance When uploading large files, increasing the value of --azurefiles-upload-concurrency will increase performance at the cost of using more memory. The default of 16 is set quite conservatively to use less memory. It maybe be necessary raise it to 64 or higher to fully utilize a 1 GBit/s link with a single file transfer. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- " 0x22 ＂ * 0x2A ＊ : 0x3A ： < 0x3C ＜ > 0x3E ＞ ? 0x3F ？ \ 0x5C ＼ | 0x7C ｜ File names can also not end with the following characters. These only get replaced if they are the last character in the name: Character Value Replacement ----------- ------- ------------- . 0x2E ． Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Hashes MD5 hashes are stored with files. Not all files will have MD5 hashes as these have to be uploaded with the file. Authentication There are a number of ways of supplying credentials for Azure Files Storage. Rclone tries them in the order of the sections below. Env Auth If the env_auth config parameter is true then rclone will pull credentials from the environment or runtime. It tries these authentication methods in this order: 1. Environment Variables 2. Managed Service Identity Credentials 3. Azure CLI credentials (as used by the az tool) These are described in the following sections Env Auth: 1. Environment Variables If env_auth is set and environment variables are present rclone authenticates a service principal with a secret or certificate, or a user with a password, depending on which environment variable are set. It reads configuration from these variables, in the following order: 1. Service principal with client secret - AZURE_TENANT_ID: ID of the service principal's tenant. Also called its "directory" ID. - AZURE_CLIENT_ID: the service principal's client ID - AZURE_CLIENT_SECRET: one of the service principal's client secrets 2. Service principal with certificate - AZURE_TENANT_ID: ID of the service principal's tenant. Also called its "directory" ID. - AZURE_CLIENT_ID: the service principal's client ID - AZURE_CLIENT_CERTIFICATE_PATH: path to a PEM or PKCS12 certificate file including the private key. - AZURE_CLIENT_CERTIFICATE_PASSWORD: (optional) password for the certificate file. - AZURE_CLIENT_SEND_CERTIFICATE_CHAIN: (optional) Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to "true" or "1", authentication requests include the x5c header. 3. User with username and password - AZURE_TENANT_ID: (optional) tenant to authenticate in. Defaults to "organizations". - AZURE_CLIENT_ID: client ID of the application the user will authenticate to - AZURE_USERNAME: a username (usually an email address) - AZURE_PASSWORD: the user's password 4. Workload Identity - AZURE_TENANT_ID: Tenant to authenticate in. - AZURE_CLIENT_ID: Client ID of the application the user will authenticate to. - AZURE_FEDERATED_TOKEN_FILE: Path to projected service account token file. - AZURE_AUTHORITY_HOST: Authority of an Azure Active Directory endpoint (default: login.microsoftonline.com). Env Auth: 2. Managed Service Identity Credentials When using Managed Service Identity if the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default. If the resource has multiple user-assigned identities you will need to unset env_auth and set use_msi instead. See the use_msi section. If you are operating in disconnected clouds, or private clouds such as Azure Stack you may want to set disable_instance_discovery = true. This determines whether rclone requests Microsoft Entra instance metadata from https://login.microsoft.com/ before authenticating. Setting this to true will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy. Env Auth: 3. Azure CLI credentials (as used by the az tool) Credentials created with the az tool can be picked up using env_auth. For example if you were to login with a service principal like this: az login --service-principal -u XXX -p XXX --tenant XXX Then you could access rclone resources like this: rclone lsf :azurefiles,env_auth,account=ACCOUNT: Or rclone lsf --azurefiles-env-auth --azurefiles-account=ACCOUNT :azurefiles: Account and Shared Key This is the most straight forward and least flexible way. Just fill in the account and key lines and leave the rest blank. SAS URL To use it leave account, key and connection_string blank and fill in sas_url. Connection String To use it leave account, key and "sas_url" blank and fill in connection_string. Service principal with client secret If these variables are set, rclone will authenticate with a service principal with a client secret. - tenant: ID of the service principal's tenant. Also called its "directory" ID. - client_id: the service principal's client ID - client_secret: one of the service principal's client secrets The credentials can also be placed in a file using the service_principal_file configuration option. Service principal with certificate If these variables are set, rclone will authenticate with a service principal with certificate. - tenant: ID of the service principal's tenant. Also called its "directory" ID. - client_id: the service principal's client ID - client_certificate_path: path to a PEM or PKCS12 certificate file including the private key. - client_certificate_password: (optional) password for the certificate file. - client_send_certificate_chain: (optional) Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to "true" or "1", authentication requests include the x5c header. NB client_certificate_password must be obscured - see rclone obscure. User with username and password If these variables are set, rclone will authenticate with username and password. - tenant: (optional) tenant to authenticate in. Defaults to "organizations". - client_id: client ID of the application the user will authenticate to - username: a username (usually an email address) - password: the user's password Microsoft doesn't recommend this kind of authentication, because it's less secure than other authentication flows. This method is not interactive, so it isn't compatible with any form of multi-factor authentication, and the application must already have user or admin consent. This credential can only authenticate work and school accounts; it can't authenticate Microsoft accounts. NB password must be obscured - see rclone obscure. Managed Service Identity Credentials If use_msi is set then managed service identity credentials are used. This authentication only works when running in an Azure service. env_auth needs to be unset to use this. However if you have multiple user identities to choose from these must be explicitly specified using exactly one of the msi_object_id, msi_client_id, or msi_mi_res_id parameters. If none of msi_object_id, msi_client_id, or msi_mi_res_id is set, this is is equivalent to using env_auth. Fedrated Identity Credentials If these variables are set, rclone will authenticate with fedrated identity. - tenant_id: tenant_id to authenticate in storage - client_id: client ID of the application the user will authenticate to storage - msi_client_id: managed identity client ID of the application the user will authenticate to By default "api://AzureADTokenExchange" is used as scope for token retrieval over MSI. This token is then exchanged for actual storage token using 'tenant_id' and 'client_id'. Azure CLI tool az Set to use the Azure CLI tool az as the sole means of authentication. Setting this can be useful if you wish to use the az CLI on a host with a System Managed Identity that you do not want to use. Don't set env_auth at the same time. Standard options Here are the Standard options specific to azurefiles (Microsoft Azure Files). --azurefiles-account Azure Storage Account Name. Set this to the Azure Storage Account Name in use. Leave blank to use SAS URL or connection string, otherwise it needs to be set. If this is blank and if env_auth is set it will be read from the environment variable AZURE_STORAGE_ACCOUNT_NAME if possible. Properties: - Config: account - Env Var: RCLONE_AZUREFILES_ACCOUNT - Type: string - Required: false --azurefiles-share-name Azure Files Share Name. This is required and is the name of the share to access. Properties: - Config: share_name - Env Var: RCLONE_AZUREFILES_SHARE_NAME - Type: string - Required: false --azurefiles-env-auth Read credentials from runtime (environment variables, CLI or MSI). See the authentication docs for full info. Properties: - Config: env_auth - Env Var: RCLONE_AZUREFILES_ENV_AUTH - Type: bool - Default: false --azurefiles-key Storage Account Shared Key. Leave blank to use SAS URL or connection string. Properties: - Config: key - Env Var: RCLONE_AZUREFILES_KEY - Type: string - Required: false --azurefiles-sas-url SAS URL. Leave blank if using account/key or connection string. Properties: - Config: sas_url - Env Var: RCLONE_AZUREFILES_SAS_URL - Type: string - Required: false --azurefiles-connection-string Azure Files Connection String. Properties: - Config: connection_string - Env Var: RCLONE_AZUREFILES_CONNECTION_STRING - Type: string - Required: false --azurefiles-tenant ID of the service principal's tenant. Also called its directory ID. Set this if using - Service principal with client secret - Service principal with certificate - User with username and password Properties: - Config: tenant - Env Var: RCLONE_AZUREFILES_TENANT - Type: string - Required: false --azurefiles-client-id The ID of the client in use. Set this if using - Service principal with client secret - Service principal with certificate - User with username and password Properties: - Config: client_id - Env Var: RCLONE_AZUREFILES_CLIENT_ID - Type: string - Required: false --azurefiles-client-secret One of the service principal's client secrets Set this if using - Service principal with client secret Properties: - Config: client_secret - Env Var: RCLONE_AZUREFILES_CLIENT_SECRET - Type: string - Required: false --azurefiles-client-certificate-path Path to a PEM or PKCS12 certificate file including the private key. Set this if using - Service principal with certificate Properties: - Config: client_certificate_path - Env Var: RCLONE_AZUREFILES_CLIENT_CERTIFICATE_PATH - Type: string - Required: false --azurefiles-client-certificate-password Password for the certificate file (optional). Optionally set this if using - Service principal with certificate And the certificate has a password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: client_certificate_password - Env Var: RCLONE_AZUREFILES_CLIENT_CERTIFICATE_PASSWORD - Type: string - Required: false Advanced options Here are the Advanced options specific to azurefiles (Microsoft Azure Files). --azurefiles-client-send-certificate-chain Send the certificate chain when using certificate auth. Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to true, authentication requests include the x5c header. Optionally set this if using - Service principal with certificate Properties: - Config: client_send_certificate_chain - Env Var: RCLONE_AZUREFILES_CLIENT_SEND_CERTIFICATE_CHAIN - Type: bool - Default: false --azurefiles-username User name (usually an email address) Set this if using - User with username and password Properties: - Config: username - Env Var: RCLONE_AZUREFILES_USERNAME - Type: string - Required: false --azurefiles-password The user's password Set this if using - User with username and password NB Input to this must be obscured - see rclone obscure. Properties: - Config: password - Env Var: RCLONE_AZUREFILES_PASSWORD - Type: string - Required: false --azurefiles-service-principal-file Path to file containing credentials for use with a service principal. Leave blank normally. Needed only if you want to use a service principal instead of interactive login. $ az ad sp create-for-rbac --name "" \ --role "Storage Files Data Owner" \ --scopes "/subscriptions//resourceGroups//providers/Microsoft.Storage/storageAccounts//blobServices/default/containers/" \ > azure-principal.json See "Create an Azure service principal" and "Assign an Azure role for access to files data" pages for more details. NB this section needs updating for Azure Files - pull requests appreciated! It may be more convenient to put the credentials directly into the rclone config file under the client_id, tenant and client_secret keys instead of setting service_principal_file. Properties: - Config: service_principal_file - Env Var: RCLONE_AZUREFILES_SERVICE_PRINCIPAL_FILE - Type: string - Required: false --azurefiles-use-msi Use a managed service identity to authenticate (only works in Azure). When true, use a managed service identity to authenticate to Azure Storage instead of a SAS token or account key. If the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default. If the resource has multiple user-assigned identities, the identity to use must be explicitly specified using exactly one of the msi_object_id, msi_client_id, or msi_mi_res_id parameters. Properties: - Config: use_msi - Env Var: RCLONE_AZUREFILES_USE_MSI - Type: bool - Default: false --azurefiles-msi-object-id Object ID of the user-assigned MSI to use, if any. Leave blank if msi_client_id or msi_mi_res_id specified. Properties: - Config: msi_object_id - Env Var: RCLONE_AZUREFILES_MSI_OBJECT_ID - Type: string - Required: false --azurefiles-msi-client-id Object ID of the user-assigned MSI to use, if any. Leave blank if msi_object_id or msi_mi_res_id specified. Properties: - Config: msi_client_id - Env Var: RCLONE_AZUREFILES_MSI_CLIENT_ID - Type: string - Required: false --azurefiles-msi-mi-res-id Azure resource ID of the user-assigned MSI to use, if any. Leave blank if msi_client_id or msi_object_id specified. Properties: - Config: msi_mi_res_id - Env Var: RCLONE_AZUREFILES_MSI_MI_RES_ID - Type: string - Required: false --azurefiles-disable-instance-discovery Skip requesting Microsoft Entra instance metadata This should be set true only by applications authenticating in disconnected clouds, or private clouds such as Azure Stack. It determines whether rclone requests Microsoft Entra instance metadata from https://login.microsoft.com/ before authenticating. Setting this to true will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy. Properties: - Config: disable_instance_discovery - Env Var: RCLONE_AZUREFILES_DISABLE_INSTANCE_DISCOVERY - Type: bool - Default: false --azurefiles-use-az Use Azure CLI tool az for authentication Set to use the Azure CLI tool az as the sole means of authentication. Setting this can be useful if you wish to use the az CLI on a host with a System Managed Identity that you do not want to use. Don't set env_auth at the same time. Properties: - Config: use_az - Env Var: RCLONE_AZUREFILES_USE_AZ - Type: bool - Default: false --azurefiles-endpoint Endpoint for the service. Leave blank normally. Properties: - Config: endpoint - Env Var: RCLONE_AZUREFILES_ENDPOINT - Type: string - Required: false --azurefiles-chunk-size Upload chunk size. Note that this is stored in memory and there may be up to "--transfers" * "--azurefile-upload-concurrency" chunks stored at once in memory. Properties: - Config: chunk_size - Env Var: RCLONE_AZUREFILES_CHUNK_SIZE - Type: SizeSuffix - Default: 4Mi --azurefiles-upload-concurrency Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. Note that chunks are stored in memory and there may be up to "--transfers" * "--azurefile-upload-concurrency" chunks stored at once in memory. Properties: - Config: upload_concurrency - Env Var: RCLONE_AZUREFILES_UPLOAD_CONCURRENCY - Type: int - Default: 16 --azurefiles-max-stream-size Max size for streamed files. Azure files needs to know in advance how big the file will be. When rclone doesn't know it uses this value instead. This will be used when rclone is streaming data, the most common uses are: - Uploading files with --vfs-cache-mode off with rclone mount - Using rclone rcat - Copying files with unknown length You will need this much free space in the share as the file will be this size temporarily. Properties: - Config: max_stream_size - Env Var: RCLONE_AZUREFILES_MAX_STREAM_SIZE - Type: SizeSuffix - Default: 10Gi --azurefiles-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_AZUREFILES_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,RightPeriod,InvalidUtf8,Dot --azurefiles-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_AZUREFILES_DESCRIPTION - Type: string - Required: false Custom upload headers You can set custom upload headers with the --header-upload flag. - Cache-Control - Content-Disposition - Content-Encoding - Content-Language - Content-Type Eg --header-upload "Content-Type: text/potato" Limitations MD5 sums are only uploaded with chunked files if the source has an MD5 sum. This will always be the case for a local to azure copy. Microsoft OneDrive Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. Configuration The initial setup for OneDrive involves getting a token from Microsoft which you need to do in your browser. rclone config walks you through it. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Microsoft OneDrive \ "onedrive" [snip] Storage> onedrive Microsoft App Client Id Leave blank normally. Enter a string value. Press Enter for the default (""). client_id> Microsoft App Client Secret Leave blank normally. Enter a string value. Press Enter for the default (""). client_secret> Edit advanced config? (y/n) y) Yes n) No y/n> n Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Choose a number from below, or type in an existing value 1 / OneDrive Personal or Business \ "onedrive" 2 / Sharepoint site \ "sharepoint" 3 / Type in driveID \ "driveid" 4 / Type in SiteID \ "siteid" 5 / Search a Sharepoint site \ "search" Your choice> 1 Found 1 drives, please select the one you want to use: 0: OneDrive (business) id=b!Eqwertyuiopasdfghjklzxcvbnm-7mnbvcxzlkjhgfdsapoiuytrewqk Chose drive to use:> 0 Found drive 'root' of type 'business', URL: https://org-my.sharepoint.com/personal/you/Documents Is that okay? y) Yes n) No y/n> y Configuration complete. Options: - type: onedrive - token: {"access_token":"youraccesstoken","token_type":"Bearer","refresh_token":"yourrefreshtoken","expiry":"2018-08-26T22:39:52.486512262+08:00"} - drive_id: b!Eqwertyuiopasdfghjklzxcvbnm-7mnbvcxzlkjhgfdsapoiuytrewqk - drive_type: business Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y See the remote setup docs for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Microsoft. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall. Once configured you can then use rclone like this, List directories in top level of your OneDrive rclone lsd remote: List all the files in your OneDrive rclone ls remote: To copy a local directory to an OneDrive directory called backup rclone copy /home/source remote:backup Getting your own Client ID and Key rclone uses a default Client ID when talking to OneDrive, unless a custom client_id is specified in the config. The default Client ID and Key are shared by all rclone users when performing requests. You may choose to create and use your own Client ID, in case the default one does not work well for you. For example, you might see throttling. Creating Client ID for OneDrive Personal To create your own Client ID, please follow these steps: 1. Open https://portal.azure.com/?quickstart=true#view/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/~/Overview and then under the Add menu click App registration. - If you have not created an Azure account, you will be prompted to. This is free, but you need to provide a phone number, address, and credit card for identity verification. 2. Enter a name for your app, choose account type Accounts in any organizational directory (Any Azure AD directory - Multitenant) and personal Microsoft accounts (e.g. Skype, Xbox), select Web in Redirect URI, then type (do not copy and paste) http://localhost:53682/ and click Register. Copy and keep the Application (client) ID under the app name for later use. 3. Under manage select Certificates & secrets, click New client secret. Enter a description (can be anything) and set Expires to 24 months. Copy and keep that secret Value for later use (you won't be able to see this value afterwards). 4. Under manage select API permissions, click Add a permission and select Microsoft Graph then select delegated permissions. 5. Search and select the following permissions: Files.Read, Files.ReadWrite, Files.Read.All, Files.ReadWrite.All, offline_access, User.Read and Sites.Read.All (if custom access scopes are configured, select the permissions accordingly). Once selected click Add permissions at the bottom. Now the application is complete. Run rclone config to create or edit a OneDrive remote. Supply the app ID and password as Client ID and Secret, respectively. rclone will walk you through the remaining steps. The access_scopes option allows you to configure the permissions requested by rclone. See Microsoft Docs for more information about the different scopes. The Sites.Read.All permission is required if you need to search SharePoint sites when configuring the remote. However, if that permission is not assigned, you need to exclude Sites.Read.All from your access scopes or set disable_site_permission option to true in the advanced options. Creating Client ID for OneDrive Business The steps for OneDrive Personal may or may not work for OneDrive Business, depending on the security settings of the organization. A common error is that the publisher of the App is not verified. You may try to verify you account, or try to limit the App to your organization only, as shown below. 1. Make sure to create the App with your business account. 2. Follow the steps above to create an App. However, we need a different account type here: Accounts in this organizational directory only (*** - Single tenant). Note that you can also change the account type after creating the App. 3. Find the tenant ID of your organization. 4. In the rclone config, set auth_url to https://login.microsoftonline.com/YOUR_TENANT_ID/oauth2/v2.0/authorize. 5. In the rclone config, set token_url to https://login.microsoftonline.com/YOUR_TENANT_ID/oauth2/v2.0/token. Note: If you have a special region, you may need a different host in step 4 and 5. Here are some hints. Using OAuth Client Credential flow OAuth Client Credential flow will allow rclone to use permissions directly associated with the Azure AD Enterprise application, rather that adopting the context of an Azure AD user account. This flow can be enabled by following the steps below: 1. Create the Enterprise App registration in the Azure AD portal and obtain a Client ID and Client Secret as described above. 2. Ensure that the application has the appropriate permissions and they are assigned as Application Permissions 3. Configure the remote, ensuring that Client ID and Client Secret are entered correctly. 4. In the Advanced Config section, enter true for client_credentials and in the tenant section enter the tenant ID. When it comes to choosing the type of the connection work with the client credentials flow. In particular the "onedrive" option does not work. You can use the "sharepoint" option or if that does not find the correct drive ID type it in manually with the "driveid" option. NOTE Assigning permissions directly to the application means that anyone with the Client ID and Client Secret can access your OneDrive files. Take care to safeguard these credentials. Modification times and hashes OneDrive allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not. OneDrive Personal, OneDrive for Business and Sharepoint Server support QuickXorHash. Before rclone 1.62 the default hash for Onedrive Personal was SHA1. For rclone 1.62 and above the default for all Onedrive backends is QuickXorHash. Starting from July 2023 SHA1 support is being phased out in Onedrive Personal in favour of QuickXorHash. If necessary the --onedrive-hash-type flag (or hash_type config option) can be used to select SHA1 during the transition period if this is important your workflow. For all types of OneDrive you can use the --checksum flag. --fast-list This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details. This must be enabled with the --onedrive-delta flag (or delta = true in the config file) as it can cause performance degradation. It does this by using the delta listing facilities of OneDrive which returns all the files in the remote very efficiently. This is much more efficient than listing directories recursively and is Microsoft's recommended way of reading all the file information from a drive. This can be useful with rclone mount and rclone rc vfs/refresh recursive=true) to very quickly fill the mount with information about all the files. The API used for the recursive listing (ListR) only supports listing from the root of the drive. This will become increasingly inefficient the further away you get from the root as rclone will have to discard files outside of the directory you are using. Some commands (like rclone lsf -R) will use ListR by default - you can turn this off with --disable ListR if you need to. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- " 0x22 ＂ * 0x2A ＊ : 0x3A ： < 0x3C ＜ > 0x3E ＞ ? 0x3F ？ \ 0x5C ＼ | 0x7C ｜ File names can also not end with the following characters. These only get replaced if they are the last character in the name: Character Value Replacement ----------- ------- ------------- SP 0x20 ␠ . 0x2E ． File names can also not begin with the following characters. These only get replaced if they are the first character in the name: Character Value Replacement ----------- ------- ------------- SP 0x20 ␠ ~ 0x7E ～ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Deleting files Any files you delete with rclone will end up in the trash. Microsoft doesn't provide an API to permanently delete files, nor to empty the trash, so you will have to do that with one of Microsoft's apps or via the OneDrive website. Standard options Here are the Standard options specific to onedrive (Microsoft OneDrive). --onedrive-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_ONEDRIVE_CLIENT_ID - Type: string - Required: false --onedrive-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_ONEDRIVE_CLIENT_SECRET - Type: string - Required: false --onedrive-region Choose national cloud region for OneDrive. Properties: - Config: region - Env Var: RCLONE_ONEDRIVE_REGION - Type: string - Default: "global" - Examples: - "global" - Microsoft Cloud Global - "us" - Microsoft Cloud for US Government - "de" - Microsoft Cloud Germany (deprecated - try global region first). - "cn" - Azure and Office 365 operated by Vnet Group in China --onedrive-tenant ID of the service principal's tenant. Also called its directory ID. Set this if using - Client Credential flow Properties: - Config: tenant - Env Var: RCLONE_ONEDRIVE_TENANT - Type: string - Required: false Advanced options Here are the Advanced options specific to onedrive (Microsoft OneDrive). --onedrive-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_ONEDRIVE_TOKEN - Type: string - Required: false --onedrive-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_ONEDRIVE_AUTH_URL - Type: string - Required: false --onedrive-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_ONEDRIVE_TOKEN_URL - Type: string - Required: false --onedrive-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_ONEDRIVE_CLIENT_CREDENTIALS - Type: bool - Default: false --onedrive-upload-cutoff Cutoff for switching to chunked upload. Any files larger than this will be uploaded in chunks of chunk_size. This is disabled by default as uploading using single part uploads causes rclone to use twice the storage on Onedrive business as when rclone sets the modification time after the upload Onedrive creates a new version. See: https://github.com/rclone/rclone/issues/1716 Properties: - Config: upload_cutoff - Env Var: RCLONE_ONEDRIVE_UPLOAD_CUTOFF - Type: SizeSuffix - Default: off --onedrive-chunk-size Chunk size to upload files with - must be multiple of 320k (327,680 bytes). Above this size files will be chunked - must be multiple of 320k (327,680 bytes) and should not exceed 250M (262,144,000 bytes) else you may encounter "Microsoft.SharePoint.Client.InvalidClientQueryException: The request message is too big." Note that the chunks will be buffered into memory. Properties: - Config: chunk_size - Env Var: RCLONE_ONEDRIVE_CHUNK_SIZE - Type: SizeSuffix - Default: 10Mi --onedrive-drive-id The ID of the drive to use. Properties: - Config: drive_id - Env Var: RCLONE_ONEDRIVE_DRIVE_ID - Type: string - Required: false --onedrive-drive-type The type of the drive (personal | business | documentLibrary). Properties: - Config: drive_type - Env Var: RCLONE_ONEDRIVE_DRIVE_TYPE - Type: string - Required: false --onedrive-root-folder-id ID of the root folder. This isn't normally needed, but in special circumstances you might know the folder ID that you wish to access but not be able to get there through a path traversal. Properties: - Config: root_folder_id - Env Var: RCLONE_ONEDRIVE_ROOT_FOLDER_ID - Type: string - Required: false --onedrive-access-scopes Set scopes to be requested by rclone. Choose or manually enter a custom space separated list with all scopes, that rclone should request. Properties: - Config: access_scopes - Env Var: RCLONE_ONEDRIVE_ACCESS_SCOPES - Type: SpaceSepList - Default: Files.Read Files.ReadWrite Files.Read.All Files.ReadWrite.All Sites.Read.All offline_access - Examples: - "Files.Read Files.ReadWrite Files.Read.All Files.ReadWrite.All Sites.Read.All offline_access" - Read and write access to all resources - "Files.Read Files.Read.All Sites.Read.All offline_access" - Read only access to all resources - "Files.Read Files.ReadWrite Files.Read.All Files.ReadWrite.All offline_access" - Read and write access to all resources, without the ability to browse SharePoint sites. - Same as if disable_site_permission was set to true --onedrive-disable-site-permission Disable the request for Sites.Read.All permission. If set to true, you will no longer be able to search for a SharePoint site when configuring drive ID, because rclone will not request Sites.Read.All permission. Set it to true if your organization didn't assign Sites.Read.All permission to the application, and your organization disallows users to consent app permission request on their own. Properties: - Config: disable_site_permission - Env Var: RCLONE_ONEDRIVE_DISABLE_SITE_PERMISSION - Type: bool - Default: false --onedrive-expose-onenote-files Set to make OneNote files show up in directory listings. By default, rclone will hide OneNote files in directory listings because operations like "Open" and "Update" won't work on them. But this behaviour may also prevent you from deleting them. If you want to delete OneNote files or otherwise want them to show up in directory listing, set this option. Properties: - Config: expose_onenote_files - Env Var: RCLONE_ONEDRIVE_EXPOSE_ONENOTE_FILES - Type: bool - Default: false --onedrive-server-side-across-configs Deprecated: use --server-side-across-configs instead. Allow server-side operations (e.g. copy) to work across different onedrive configs. This will work if you are copying between two OneDrive Personal drives AND the files to copy are already shared between them. Additionally, it should also function for a user who has access permissions both between Onedrive for business and SharePoint under the same tenant, and between SharePoint and another SharePoint under the same tenant. In other cases, rclone will fall back to normal copy (which will be slightly slower). Properties: - Config: server_side_across_configs - Env Var: RCLONE_ONEDRIVE_SERVER_SIDE_ACROSS_CONFIGS - Type: bool - Default: false --onedrive-list-chunk Size of listing chunk. Properties: - Config: list_chunk - Env Var: RCLONE_ONEDRIVE_LIST_CHUNK - Type: int - Default: 1000 --onedrive-no-versions Remove all versions on modifying operations. Onedrive for business creates versions when rclone uploads new files overwriting an existing one and when it sets the modification time. These versions take up space out of the quota. This flag checks for versions after file upload and setting modification time and removes all but the last version. NB Onedrive personal can't currently delete versions so don't use this flag there. Properties: - Config: no_versions - Env Var: RCLONE_ONEDRIVE_NO_VERSIONS - Type: bool - Default: false --onedrive-hard-delete Permanently delete files on removal. Normally files will get sent to the recycle bin on deletion. Setting this flag causes them to be permanently deleted. Use with care. OneDrive personal accounts do not support the permanentDelete API, it only applies to OneDrive for Business and SharePoint document libraries. Properties: - Config: hard_delete - Env Var: RCLONE_ONEDRIVE_HARD_DELETE - Type: bool - Default: false --onedrive-link-scope Set the scope of the links created by the link command. Properties: - Config: link_scope - Env Var: RCLONE_ONEDRIVE_LINK_SCOPE - Type: string - Default: "anonymous" - Examples: - "anonymous" - Anyone with the link has access, without needing to sign in. - This may include people outside of your organization. - Anonymous link support may be disabled by an administrator. - "organization" - Anyone signed into your organization (tenant) can use the link to get access. - Only available in OneDrive for Business and SharePoint. --onedrive-link-type Set the type of the links created by the link command. Properties: - Config: link_type - Env Var: RCLONE_ONEDRIVE_LINK_TYPE - Type: string - Default: "view" - Examples: - "view" - Creates a read-only link to the item. - "edit" - Creates a read-write link to the item. - "embed" - Creates an embeddable link to the item. --onedrive-link-password Set the password for links created by the link command. At the time of writing this only works with OneDrive personal paid accounts. Properties: - Config: link_password - Env Var: RCLONE_ONEDRIVE_LINK_PASSWORD - Type: string - Required: false --onedrive-hash-type Specify the hash in use for the backend. This specifies the hash type in use. If set to "auto" it will use the default hash which is QuickXorHash. Before rclone 1.62 an SHA1 hash was used by default for Onedrive Personal. For 1.62 and later the default is to use a QuickXorHash for all onedrive types. If an SHA1 hash is desired then set this option accordingly. From July 2023 QuickXorHash will be the only available hash for both OneDrive for Business and OneDrive Personal. This can be set to "none" to not use any hashes. If the hash requested does not exist on the object, it will be returned as an empty string which is treated as a missing hash by rclone. Properties: - Config: hash_type - Env Var: RCLONE_ONEDRIVE_HASH_TYPE - Type: string - Default: "auto" - Examples: - "auto" - Rclone chooses the best hash - "quickxor" - QuickXor - "sha1" - SHA1 - "sha256" - SHA256 - "crc32" - CRC32 - "none" - None - don't use any hashes --onedrive-av-override Allows download of files the server thinks has a virus. The onedrive/sharepoint server may check files uploaded with an Anti Virus checker. If it detects any potential viruses or malware it will block download of the file. In this case you will see a message like this server reports this file is infected with a virus - use --onedrive-av-override to download anyway: Infected (name of virus): 403 Forbidden: If you are 100% sure you want to download this file anyway then use the --onedrive-av-override flag, or av_override = true in the config file. Properties: - Config: av_override - Env Var: RCLONE_ONEDRIVE_AV_OVERRIDE - Type: bool - Default: false --onedrive-delta If set rclone will use delta listing to implement recursive listings. If this flag is set the onedrive backend will advertise ListR support for recursive listings. Setting this flag speeds up these things greatly: rclone lsf -R onedrive: rclone size onedrive: rclone rc vfs/refresh recursive=true However the delta listing API only works at the root of the drive. If you use it not at the root then it recurses from the root and discards all the data that is not under the directory you asked for. So it will be correct but may not be very efficient. This is why this flag is not set as the default. As a rule of thumb if nearly all of your data is under rclone's root directory (the root/directory in onedrive:root/directory) then using this flag will be be a big performance win. If your data is mostly not under the root then using this flag will be a big performance loss. It is recommended if you are mounting your onedrive at the root (or near the root when using crypt) and using rclone rc vfs/refresh. Properties: - Config: delta - Env Var: RCLONE_ONEDRIVE_DELTA - Type: bool - Default: false --onedrive-metadata-permissions Control whether permissions should be read or written in metadata. Reading permissions metadata from files can be done quickly, but it isn't always desirable to set the permissions from the metadata. Properties: - Config: metadata_permissions - Env Var: RCLONE_ONEDRIVE_METADATA_PERMISSIONS - Type: Bits - Default: off - Examples: - "off" - Do not read or write the value - "read" - Read the value only - "write" - Write the value only - "read,write" - Read and Write the value. - "failok" - If writing fails log errors only, don't fail the transfer --onedrive-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_ONEDRIVE_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Del,Ctl,LeftSpace,LeftTilde,RightSpace,RightPeriod,InvalidUtf8,Dot --onedrive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_ONEDRIVE_DESCRIPTION - Type: string - Required: false Metadata OneDrive supports System Metadata (not User Metadata, as of this writing) for both files and directories. Much of the metadata is read-only, and there are some differences between OneDrive Personal and Business (see table below for details). Permissions are also supported, if --onedrive-metadata-permissions is set. The accepted values for --onedrive-metadata-permissions are "read", "write", "read,write", and "off" (the default). "write" supports adding new permissions, updating the "role" of existing permissions, and removing permissions. Updating and removing require the Permission ID to be known, so it is recommended to use "read,write" instead of "write" if you wish to update/remove permissions. Permissions are read/written in JSON format using the same schema as the OneDrive API, which differs slightly between OneDrive Personal and Business. Example for OneDrive Personal: [ { "id": "1234567890ABC!123", "grantedTo": { "user": { "id": "ryan@contoso.com" }, "application": {}, "device": {} }, "invitation": { "email": "ryan@contoso.com" }, "link": { "webUrl": "https://1drv.ms/t/s!1234567890ABC" }, "roles": [ "read" ], "shareId": "s!1234567890ABC" } ] Example for OneDrive Business: [ { "id": "48d31887-5fad-4d73-a9f5-3c356e68a038", "grantedToIdentities": [ { "user": { "displayName": "ryan@contoso.com" }, "application": {}, "device": {} } ], "link": { "type": "view", "scope": "users", "webUrl": "https://contoso.sharepoint.com/:w:/t/design/a577ghg9hgh737613bmbjf839026561fmzhsr85ng9f3hjck2t5s" }, "roles": [ "read" ], "shareId": "u!LKj1lkdlals90j1nlkascl" }, { "id": "5D33DD65C6932946", "grantedTo": { "user": { "displayName": "John Doe", "id": "efee1b77-fb3b-4f65-99d6-274c11914d12" }, "application": {}, "device": {} }, "roles": [ "owner" ], "shareId": "FWxc1lasfdbEAGM5fI7B67aB5ZMPDMmQ11U" } ] To write permissions, pass in a "permissions" metadata key using this same format. The --metadata-mapper tool can be very helpful for this. When adding permissions, an email address can be provided in the User.ID or DisplayName properties of grantedTo or grantedToIdentities. Alternatively, an ObjectID can be provided in User.ID. At least one valid recipient must be provided in order to add a permission for a user. Creating a Public Link is also supported, if Link.Scope is set to "anonymous". Example request to add a "read" permission with --metadata-mapper: { "Metadata": { "permissions": "[{\"grantedToIdentities\":[{\"user\":{\"id\":\"ryan@contoso.com\"}}],\"roles\":[\"read\"]}]" } } Note that adding a permission can fail if a conflicting permission already exists for the file/folder. To update an existing permission, include both the Permission ID and the new roles to be assigned. roles is the only property that can be changed. To remove permissions, pass in a blob containing only the permissions you wish to keep (which can be empty, to remove all.) Note that the owner role will be ignored, as it cannot be removed. Note that both reading and writing permissions requires extra API calls, so if you don't need to read or write permissions it is recommended to omit --onedrive-metadata-permissions. Metadata and permissions are supported for Folders (directories) as well as Files. Note that setting the mtime or btime on a Folder requires one extra API call on OneDrive Business only. OneDrive does not currently support User Metadata. When writing metadata, only writeable system properties will be written -- any read-only or unrecognized keys passed in will be ignored. TIP: to see the metadata and permissions for any file or folder, run: rclone lsjson remote:path --stat -M --onedrive-metadata-permissions read Here are the possible system metadata items for the onedrive backend. ------------------------------------------------------------------------------------------------------------------------------------------ Name Help Type Example Read Only ------------------------------- ---------------------------------- ----------- -------------------------------------- -------------------- btime Time of file birth (creation) with RFC 3339 2006-01-02T15:04:05Z N S accuracy (mS for OneDrive Personal). content-type The MIME type of the file. string text/plain Y created-by-display-name Display name of the user that string John Doe Y created the item. created-by-id ID of the user that created the string 48d31887-5fad-4d73-a9f5-3c356e68a038 Y item. description A short description of the file. string Contract for signing N Max 1024 characters. Only supported for OneDrive Personal. id The unique identifier of the item string 01BYE5RZ6QN3ZWBTUFOFD3GSPGOHDJD36K Y within OneDrive. last-modified-by-display-name Display name of the user that last string John Doe Y modified the item. last-modified-by-id ID of the user that last modified string 48d31887-5fad-4d73-a9f5-3c356e68a038 Y the item. malware-detected Whether OneDrive has detected that boolean true Y the item contains malware. mtime Time of last modification with S RFC 3339 2006-01-02T15:04:05Z N accuracy (mS for OneDrive Personal). package-type If present, indicates that this string oneNote Y item is a package instead of a folder or file. Packages are treated like files in some contexts and folders in others. permissions Permissions in a JSON dump of JSON {} N OneDrive format. Enable with --onedrive-metadata-permissions. Properties: id, grantedTo, grantedToIdentities, invitation, inheritedFrom, link, roles, shareId shared-by-id ID of the user that shared the string 48d31887-5fad-4d73-a9f5-3c356e68a038 Y item (if shared). shared-owner-id ID of the owner of the shared item string 48d31887-5fad-4d73-a9f5-3c356e68a038 Y (if shared). shared-scope If shared, indicates the scope of string users Y how the item is shared: anonymous, organization, or users. shared-time Time when the item was shared, RFC 3339 2006-01-02T15:04:05Z Y with S accuracy (mS for OneDrive Personal). utime Time of upload with S accuracy (mS RFC 3339 2006-01-02T15:04:05Z Y for OneDrive Personal). ------------------------------------------------------------------------------------------------------------------------------------------ See the metadata docs for more info. Impersonate other users as Admin Unlike Google Drive and impersonating any domain user via service accounts, OneDrive requires you to authenticate as an admin account, and manually setup a remote per user you wish to impersonate. 1. In Microsoft 365 Admin Center, open each user you need to "impersonate" and go to the OneDrive section. There is a heading called "Get access to files", you need to click to create the link, this creates the link of the format https://{tenant}-my.sharepoint.com/personal/{user_name_domain_tld}/ but also changes the permissions so you your admin user has access. 2. Then in powershell run the following commands: Install-Module Microsoft.Graph -Scope CurrentUser -Repository PSGallery -Force Import-Module Microsoft.Graph.Files Connect-MgGraph -Scopes "Files.ReadWrite.All" # Follow the steps to allow access to your admin user # Then run this for each user you want to impersonate to get the Drive ID Get-MgUserDefaultDrive -UserId '{emailaddress}' # This will give you output of the format: # Name Id DriveType CreatedDateTime # ---- -- --------- --------------- # OneDrive b!XYZ123 business 14/10/2023 1:00:58 pm 3. Then in rclone add a onedrive remote type, and use the Type in driveID with the DriveID you got in the previous step. One remote per user. It will then confirm the drive ID, and hopefully give you a message of Found drive "root" of type "business" and then include the URL of the format https://{tenant}-my.sharepoint.com/personal/{user_name_domain_tld}/Documents Limitations If you don't use rclone for 90 days the refresh token will expire. This will result in authorization problems. This is easy to fix by running the rclone config reconnect remote: command to get a new token and refresh token. Naming Note that OneDrive is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". There are quite a few characters that can't be in OneDrive file names. These can't occur on Windows platforms, but on non-Windows platforms they are common. Rclone will map these names to and from an identical looking unicode equivalent. For example if a file has a ? in it will be mapped to ？ instead. File sizes The largest allowed file size is 250 GiB for both OneDrive Personal and OneDrive for Business (Updated 13 Jan 2021). Path length The entire path, including the file name, must contain fewer than 400 characters for OneDrive, OneDrive for Business and SharePoint Online. If you are encrypting file and folder names with rclone, you may want to pay attention to this limitation because the encrypted names are typically longer than the original ones. Number of files OneDrive seems to be OK with at least 50,000 files in a folder, but at 100,000 rclone will get errors listing the directory like couldn’t list files: UnknownError:. See #2707 for more info. An official document about the limitations for different types of OneDrive can be found here. Versions Every change in a file OneDrive causes the service to create a new version of the file. This counts against a users quota. For example changing the modification time of a file creates a second version, so the file apparently uses twice the space. For example the copy command is affected by this as rclone copies the file and then afterwards sets the modification time to match the source file which uses another version. You can use the rclone cleanup command (see below) to remove all old versions. Or you can set the no_versions parameter to true and rclone will remove versions after operations which create new versions. This takes extra transactions so only enable it if you need it. Note At the time of writing Onedrive Personal creates versions (but not for setting the modification time) but the API for removing them returns "API not found" so cleanup and no_versions should not be used on Onedrive Personal. Disabling versioning Starting October 2018, users will no longer be able to disable versioning by default. This is because Microsoft has brought an update to the mechanism. To change this new default setting, a PowerShell command is required to be run by a SharePoint admin. If you are an admin, you can run these commands in PowerShell to change that setting: 1. Install-Module -Name Microsoft.Online.SharePoint.PowerShell (in case you haven't installed this already) 2. Import-Module Microsoft.Online.SharePoint.PowerShell -DisableNameChecking 3. Connect-SPOService -Url https://YOURSITE-admin.sharepoint.com -Credential YOU@YOURSITE.COM (replacing YOURSITE, YOU, YOURSITE.COM with the actual values; this will prompt for your credentials) 4. Set-SPOTenant -EnableMinimumVersionRequirement $False 5. Disconnect-SPOService (to disconnect from the server) Below are the steps for normal users to disable versioning. If you don't see the "No Versioning" option, make sure the above requirements are met. User Weropol has found a method to disable versioning on OneDrive 1. Open the settings menu by clicking on the gear symbol at the top of the OneDrive Business page. 2. Click Site settings. 3. Once on the Site settings page, navigate to Site Administration > Site libraries and lists. 4. Click Customize "Documents". 5. Click General Settings > Versioning Settings. 6. Under Document Version History select the option No versioning. Note: This will disable the creation of new file versions, but will not remove any previous versions. Your documents are safe. 7. Apply the changes by clicking OK. 8. Use rclone to upload or modify files. (I also use the --no-update-modtime flag) 9. Restore the versioning settings after using rclone. (Optional) Cleanup OneDrive supports rclone cleanup which causes rclone to look through every file under the path supplied and delete all version but the current version. Because this involves traversing all the files, then querying each file for versions it can be quite slow. Rclone does --checkers tests in parallel. The command also supports --interactive/i or --dry-run which is a great way to see what it would do. rclone cleanup --interactive remote:path/subdir # interactively remove all old version for path/subdir rclone cleanup remote:path/subdir # unconditionally remove all old version for path/subdir NB Onedrive personal can't currently delete versions Troubleshooting Excessive throttling or blocked on SharePoint If you experience excessive throttling or is being blocked on SharePoint then it may help to set the user agent explicitly with a flag like this: --user-agent "ISV|rclone.org|rclone/v1.55.1" The specific details can be found in the Microsoft document: Avoid getting throttled or blocked in SharePoint Online Unexpected file size/hash differences on Sharepoint It is a known issue that Sharepoint (not OneDrive or OneDrive for Business) silently modifies uploaded files, mainly Office files (.docx, .xlsx, etc.), causing file size and hash checks to fail. There are also other situations that will cause OneDrive to report inconsistent file sizes. To use rclone with such affected files on Sharepoint, you may disable these checks with the following command line arguments: --ignore-checksum --ignore-size Alternatively, if you have write access to the OneDrive files, it may be possible to fix this problem for certain files, by attempting the steps below. Open the web interface for OneDrive and find the affected files (which will be in the error messages/log for rclone). Simply click on each of these files, causing OneDrive to open them on the web. This will cause each file to be converted in place to a format that is functionally equivalent but which will no longer trigger the size discrepancy. Once all problematic files are converted you will no longer need the ignore options above. Replacing/deleting existing files on Sharepoint gets "item not found" It is a known issue that Sharepoint (not OneDrive or OneDrive for Business) may return "item not found" errors when users try to replace or delete uploaded files; this seems to mainly affect Office files (.docx, .xlsx, etc.) and web files (.html, .aspx, etc.). As a workaround, you may use the --backup-dir command line argument so rclone moves the files to be replaced/deleted into a given backup directory (instead of directly replacing/deleting them). For example, to instruct rclone to move the files into the directory rclone-backup-dir on backend mysharepoint, you may use: --backup-dir mysharepoint:rclone-backup-dir access_denied (AADSTS65005) Error: access_denied Code: AADSTS65005 Description: Using application 'rclone' is currently not supported for your organization [YOUR_ORGANIZATION] because it is in an unmanaged state. An administrator needs to claim ownership of the company by DNS validation of [YOUR_ORGANIZATION] before the application rclone can be provisioned. This means that rclone can't use the OneDrive for Business API with your account. You can't do much about it, maybe write an email to your admins. However, there are other ways to interact with your OneDrive account. Have a look at the WebDAV backend: https://rclone.org/webdav/#sharepoint invalid_grant (AADSTS50076) Error: invalid_grant Code: AADSTS50076 Description: Due to a configuration change made by your administrator, or because you moved to a new location, you must use multi-factor authentication to access '...'. If you see the error above after enabling multi-factor authentication for your account, you can fix it by refreshing your OAuth refresh token. To do that, run rclone config, and choose to edit your OneDrive backend. Then, you don't need to actually make any changes until you reach this question: Already have a token - refresh?. For this question, answer y and go through the process to refresh your token, just like the first time the backend is configured. After this, rclone should work again for this backend. Invalid request when making public links On Sharepoint and OneDrive for Business, rclone link may return an "Invalid request" error. A possible cause is that the organisation admin didn't allow public links to be made for the organisation/sharepoint library. To fix the permissions as an admin, take a look at the docs: 1, 2. Can not access Shared with me files Shared with me files is not supported by rclone currently, but there is a workaround: 1. Visit https://onedrive.live.com 2. Right click a item in Shared, then click Add shortcut to My files in the context [make_shortcut] 3. The shortcut will appear in My files, you can access it with rclone, it behaves like a normal folder/file. [in_my_files] [rclone_mount] Live Photos uploaded from iOS (small video clips in .heic files) The iOS OneDrive app introduced upload and storage of Live Photos in 2020. The usage and download of these uploaded Live Photos is unfortunately still work-in-progress and this introduces several issues when copying, synchronising and mounting – both in rclone and in the native OneDrive client on Windows. The root cause can easily be seen if you locate one of your Live Photos in the OneDrive web interface. Then download the photo from the web interface. You will then see that the size of downloaded .heic file is smaller than the size displayed in the web interface. The downloaded file is smaller because it only contains a single frame (still photo) extracted from the Live Photo (movie) stored in OneDrive. The different sizes will cause rclone copy/sync to repeatedly recopy unmodified photos something like this: DEBUG : 20230203_123826234_iOS.heic: Sizes differ (src 4470314 vs dst 1298667) DEBUG : 20230203_123826234_iOS.heic: sha1 = fc2edde7863b7a7c93ca6771498ac797f8460750 OK INFO : 20230203_123826234_iOS.heic: Copied (replaced existing) These recopies can be worked around by adding --ignore-size. Please note that this workaround only syncs the still-picture not the movie clip, and relies on modification dates being correctly updated on all files in all situations. The different sizes will also cause rclone check to report size errors something like this: ERROR : 20230203_123826234_iOS.heic: sizes differ These check errors can be suppressed by adding --ignore-size. The different sizes will also cause rclone mount to fail downloading with an error something like this: ERROR : 20230203_123826234_iOS.heic: ReadFileHandle.Read error: low level retry 1/10: unexpected EOF or like this when using --cache-mode=full: INFO : 20230203_123826234_iOS.heic: vfs cache: downloader: error count now 1: vfs reader: failed to write to cache file: 416 Requested Range Not Satisfiable: ERROR : 20230203_123826234_iOS.heic: vfs cache: failed to download: vfs reader: failed to write to cache file: 416 Requested Range Not Satisfiable: OpenDrive Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. Configuration Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: n) New remote d) Delete remote q) Quit config e/n/d/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / OpenDrive \ "opendrive" [snip] Storage> opendrive Username username> Password y) Yes type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Configuration complete. Options: - type: opendrive - username: - password: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y List directories in top level of your OpenDrive rclone lsd remote: List all the files in your OpenDrive rclone ls remote: To copy a local directory to an OpenDrive directory called backup rclone copy /home/source remote:backup Modification times and hashes OpenDrive allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not. The MD5 hash algorithm is supported. Restricted filename characters Character Value Replacement ----------- ------- ------------- NUL 0x00 ␀ / 0x2F ／ " 0x22 ＂ * 0x2A ＊ : 0x3A ： < 0x3C ＜ > 0x3E ＞ ? 0x3F ？ \ 0x5C ＼ | 0x7C ｜ File names can also not begin or end with the following characters. These only get replaced if they are the first or last character in the name: Character Value Replacement ----------- ------- ------------- SP 0x20 ␠ HT 0x09 ␉ LF 0x0A ␊ VT 0x0B ␋ CR 0x0D ␍ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Standard options Here are the Standard options specific to opendrive (OpenDrive). --opendrive-username Username. Properties: - Config: username - Env Var: RCLONE_OPENDRIVE_USERNAME - Type: string - Required: true --opendrive-password Password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: password - Env Var: RCLONE_OPENDRIVE_PASSWORD - Type: string - Required: true Advanced options Here are the Advanced options specific to opendrive (OpenDrive). --opendrive-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_OPENDRIVE_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,LeftSpace,LeftCrLfHtVt,RightSpace,RightCrLfHtVt,InvalidUtf8,Dot --opendrive-chunk-size Files will be uploaded in chunks this size. Note that these chunks are buffered in memory so increasing them will increase memory use. Properties: - Config: chunk_size - Env Var: RCLONE_OPENDRIVE_CHUNK_SIZE - Type: SizeSuffix - Default: 10Mi --opendrive-access Files and folders will be uploaded with this access permission (default private) Properties: - Config: access - Env Var: RCLONE_OPENDRIVE_ACCESS - Type: string - Default: "private" - Examples: - "private" - The file or folder access can be granted in a way that will allow select users to view, read or write what is absolutely essential for them. - "public" - The file or folder can be downloaded by anyone from a web browser. The link can be shared in any way, - "hidden" - The file or folder can be accessed has the same restrictions as Public if the user knows the URL of the file or folder link in order to access the contents --opendrive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_OPENDRIVE_DESCRIPTION - Type: string - Required: false Limitations Note that OpenDrive is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". There are quite a few characters that can't be in OpenDrive file names. These can't occur on Windows platforms, but on non-Windows platforms they are common. Rclone will map these names to and from an identical looking unicode equivalent. For example if a file has a ? in it will be mapped to ？ instead. rclone about is not supported by the OpenDrive backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about Oracle Object Storage - Oracle Object Storage Overview - Oracle Object Storage FAQ - Oracle Object Storage Limits Paths are specified as remote:bucket (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:bucket/path/to/dir. Sample command to transfer local artifacts to remote:bucket in oracle object storage: rclone -vvv --progress --stats-one-line --max-stats-groups 10 --log-format date,time,UTC,longfile --fast-list --buffer-size 256Mi --oos-no-check-bucket --oos-upload-cutoff 10Mi --multi-thread-cutoff 16Mi --multi-thread-streams 3000 --transfers 3000 --checkers 64 --retries 2 --oos-chunk-size 10Mi --oos-upload-concurrency 10000 --oos-attempt-resume-upload --oos-leave-parts-on-error sync ./artifacts remote:bucket -vv Configuration Here is an example of making an oracle object storage configuration. rclone config walks you through it. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> n Enter name for new remote. name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. [snip] XX / Oracle Cloud Infrastructure Object Storage \ (oracleobjectstorage) Storage> oracleobjectstorage Option provider. Choose your Auth Provider Choose a number from below, or type in your own string value. Press Enter for the default (env_auth). 1 / automatically pickup the credentials from runtime(env), first one to provide auth wins \ (env_auth) / use an OCI user and an API key for authentication. 2 | you’ll need to put in a config file your tenancy OCID, user OCID, region, the path, fingerprint to an API key. | https://docs.oracle.com/en-us/iaas/Content/API/Concepts/sdkconfig.htm \ (user_principal_auth) / use instance principals to authorize an instance to make API calls. 3 | each instance has its own identity, and authenticates using the certificates that are read from instance metadata. | https://docs.oracle.com/en-us/iaas/Content/Identity/Tasks/callingservicesfrominstances.htm \ (instance_principal_auth) / use workload identity to grant Kubernetes pods policy-driven access to Oracle Cloud 4 | Infrastructure (OCI) resources using OCI Identity and Access Management (IAM). | https://docs.oracle.com/en-us/iaas/Content/ContEng/Tasks/contenggrantingworkloadaccesstoresources.htm \ (workload_identity_auth) 5 / use resource principals to make API calls \ (resource_principal_auth) 6 / no credentials needed, this is typically for reading public buckets \ (no_auth) provider> 2 Option namespace. Object storage namespace Enter a value. namespace> idbamagbg734 Option compartment. Object storage compartment OCID Enter a value. compartment> ocid1.compartment.oc1..aaaaaaaapufkxc7ame3sthry5i7ujrwfc7ejnthhu6bhanm5oqfjpyasjkba Option region. Object storage Region Enter a value. region> us-ashburn-1 Option endpoint. Endpoint for Object storage API. Leave blank to use the default endpoint for the region. Enter a value. Press Enter to leave empty. endpoint> Option config_file. Full Path to OCI config file Choose a number from below, or type in your own string value. Press Enter for the default (~/.oci/config). 1 / oci configuration file location \ (~/.oci/config) config_file> /etc/oci/dev.conf Option config_profile. Profile name inside OCI config file Choose a number from below, or type in your own string value. Press Enter for the default (Default). 1 / Use the default profile \ (Default) config_profile> Test Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: oracleobjectstorage - namespace: idbamagbg734 - compartment: ocid1.compartment.oc1..aaaaaaaapufkxc7ame3sthry5i7ujrwfc7ejnthhu6bhanm5oqfjpyasjkba - region: us-ashburn-1 - provider: user_principal_auth - config_file: /etc/oci/dev.conf - config_profile: Test Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y See all buckets rclone lsd remote: Create a new bucket rclone mkdir remote:bucket List the contents of a bucket rclone ls remote:bucket rclone ls remote:bucket --max-depth 1 Authentication Providers OCI has various authentication methods. To learn more about authentication methods please refer oci authentication methods These choices can be specified in the rclone config file. Rclone supports the following OCI authentication provider. User Principal Instance Principal Resource Principal Workload Identity No authentication User Principal Sample rclone config file for Authentication Provider User Principal: [oos] type = oracleobjectstorage namespace = id34 compartment = ocid1.compartment.oc1..aaba region = us-ashburn-1 provider = user_principal_auth config_file = /home/opc/.oci/config config_profile = Default Advantages: - One can use this method from any server within OCI or on-premises or from other cloud provider. Considerations: - you need to configure user’s privileges / policy to allow access to object storage - Overhead of managing users and keys. - If the user is deleted, the config file will no longer work and may cause automation regressions that use the user's credentials. Instance Principal An OCI compute instance can be authorized to use rclone by using it's identity and certificates as an instance principal. With this approach no credentials have to be stored and managed. Sample rclone configuration file for Authentication Provider Instance Principal: [opc@rclone ~]$ cat ~/.config/rclone/rclone.conf [oos] type = oracleobjectstorage namespace = idfn compartment = ocid1.compartment.oc1..aak7a region = us-ashburn-1 provider = instance_principal_auth Advantages: - With instance principals, you don't need to configure user credentials and transfer/ save it to disk in your compute instances or rotate the credentials. - You don’t need to deal with users and keys. - Greatly helps in automation as you don't have to manage access keys, user private keys, storing them in vault, using kms etc. Considerations: - You need to configure a dynamic group having this instance as member and add policy to read object storage to that dynamic group. - Everyone who has access to this machine can execute the CLI commands. - It is applicable for oci compute instances only. It cannot be used on external instance or resources. Resource Principal Resource principal auth is very similar to instance principal auth but used for resources that are not compute instances such as serverless functions. To use resource principal ensure Rclone process is started with these environment variables set in its process. export OCI_RESOURCE_PRINCIPAL_VERSION=2.2 export OCI_RESOURCE_PRINCIPAL_REGION=us-ashburn-1 export OCI_RESOURCE_PRINCIPAL_PRIVATE_PEM=/usr/share/model-server/key.pem export OCI_RESOURCE_PRINCIPAL_RPST=/usr/share/model-server/security_token Sample rclone configuration file for Authentication Provider Resource Principal: [oos] type = oracleobjectstorage namespace = id34 compartment = ocid1.compartment.oc1..aaba region = us-ashburn-1 provider = resource_principal_auth Workload Identity Workload Identity auth may be used when running Rclone from Kubernetes pod on a Container Engine for Kubernetes (OKE) cluster. For more details on configuring Workload Identity, see Granting Workloads Access to OCI Resources. To use workload identity, ensure Rclone is started with these environment variables set in its process. export OCI_RESOURCE_PRINCIPAL_VERSION=2.2 export OCI_RESOURCE_PRINCIPAL_REGION=us-ashburn-1 No authentication Public buckets do not require any authentication mechanism to read objects. Sample rclone configuration file for No authentication: [oos] type = oracleobjectstorage namespace = id34 compartment = ocid1.compartment.oc1..aaba region = us-ashburn-1 provider = no_auth Modification times and hashes The modification time is stored as metadata on the object as opc-meta-mtime as floating point since the epoch, accurate to 1 ns. If the modification time needs to be updated rclone will attempt to perform a server side copy to update the modification if the object can be copied in a single part. In the case the object is larger than 5Gb, the object will be uploaded rather than copied. Note that reading this from the object takes an additional HEAD request as the metadata isn't returned in object listings. The MD5 hash algorithm is supported. Multipart uploads rclone supports multipart uploads with OOS which means that it can upload files bigger than 5 GiB. Note that files uploaded both with multipart upload and through crypt remotes do not have MD5 sums. rclone switches from single part uploads to multipart uploads at the point specified by --oos-upload-cutoff. This can be a maximum of 5 GiB and a minimum of 0 (ie always upload multipart files). The chunk sizes used in the multipart upload are specified by --oos-chunk-size and the number of chunks uploaded concurrently is specified by --oos-upload-concurrency. Multipart uploads will use --transfers * --oos-upload-concurrency * --oos-chunk-size extra memory. Single part uploads to not use extra memory. Single part transfers can be faster than multipart transfers or slower depending on your latency from oos - the more latency, the more likely single part transfers will be faster. Increasing --oos-upload-concurrency will increase throughput (8 would be a sensible value) and increasing --oos-chunk-size also increases throughput (16M would be sensible). Increasing either of these will use more memory. The default values are high enough to gain most of the possible performance without using too much memory. Standard options Here are the Standard options specific to oracleobjectstorage (Oracle Cloud Infrastructure Object Storage). --oos-provider Choose your Auth Provider Properties: - Config: provider - Env Var: RCLONE_OOS_PROVIDER - Type: string - Default: "env_auth" - Examples: - "env_auth" - automatically pickup the credentials from runtime(env), first one to provide auth wins - "user_principal_auth" - use an OCI user and an API key for authentication. - you’ll need to put in a config file your tenancy OCID, user OCID, region, the path, fingerprint to an API key. - https://docs.oracle.com/en-us/iaas/Content/API/Concepts/sdkconfig.htm - "instance_principal_auth" - use instance principals to authorize an instance to make API calls. - each instance has its own identity, and authenticates using the certificates that are read from instance metadata. - https://docs.oracle.com/en-us/iaas/Content/Identity/Tasks/callingservicesfrominstances.htm - "workload_identity_auth" - use workload identity to grant OCI Container Engine for Kubernetes workloads policy-driven access to OCI resources using OCI Identity and Access Management (IAM). - https://docs.oracle.com/en-us/iaas/Content/ContEng/Tasks/contenggrantingworkloadaccesstoresources.htm - "resource_principal_auth" - use resource principals to make API calls - "no_auth" - no credentials needed, this is typically for reading public buckets --oos-namespace Object storage namespace Properties: - Config: namespace - Env Var: RCLONE_OOS_NAMESPACE - Type: string - Required: true --oos-compartment Specify compartment OCID, if you need to list buckets. List objects works without compartment OCID. Properties: - Config: compartment - Env Var: RCLONE_OOS_COMPARTMENT - Provider: !no_auth - Type: string - Required: false --oos-region Object storage Region Properties: - Config: region - Env Var: RCLONE_OOS_REGION - Type: string - Required: true --oos-endpoint Endpoint for Object storage API. Leave blank to use the default endpoint for the region. Properties: - Config: endpoint - Env Var: RCLONE_OOS_ENDPOINT - Type: string - Required: false --oos-config-file Path to OCI config file Properties: - Config: config_file - Env Var: RCLONE_OOS_CONFIG_FILE - Provider: user_principal_auth - Type: string - Default: "~/.oci/config" - Examples: - "~/.oci/config" - oci configuration file location --oos-config-profile Profile name inside the oci config file Properties: - Config: config_profile - Env Var: RCLONE_OOS_CONFIG_PROFILE - Provider: user_principal_auth - Type: string - Default: "Default" - Examples: - "Default" - Use the default profile Advanced options Here are the Advanced options specific to oracleobjectstorage (Oracle Cloud Infrastructure Object Storage). --oos-storage-tier The storage class to use when storing new objects in storage. https://docs.oracle.com/en-us/iaas/Content/Object/Concepts/understandingstoragetiers.htm Properties: - Config: storage_tier - Env Var: RCLONE_OOS_STORAGE_TIER - Type: string - Default: "Standard" - Examples: - "Standard" - Standard storage tier, this is the default tier - "InfrequentAccess" - InfrequentAccess storage tier - "Archive" - Archive storage tier --oos-upload-cutoff Cutoff for switching to chunked upload. Any files larger than this will be uploaded in chunks of chunk_size. The minimum is 0 and the maximum is 5 GiB. Properties: - Config: upload_cutoff - Env Var: RCLONE_OOS_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 200Mi --oos-chunk-size Chunk size to use for uploading. When uploading files larger than upload_cutoff or files with unknown size (e.g. from "rclone rcat" or uploaded with "rclone mount" they will be uploaded as multipart uploads using this chunk size. Note that "upload_concurrency" chunks of this size are buffered in memory per transfer. If you are transferring large files over high-speed links and you have enough memory, then increasing this will speed up the transfers. Rclone will automatically increase the chunk size when uploading a large file of known size to stay below the 10,000 chunks limit. Files of unknown size are uploaded with the configured chunk_size. Since the default chunk size is 5 MiB and there can be at most 10,000 chunks, this means that by default the maximum size of a file you can stream upload is 48 GiB. If you wish to stream upload larger files then you will need to increase chunk_size. Increasing the chunk size decreases the accuracy of the progress statistics displayed with "-P" flag. Properties: - Config: chunk_size - Env Var: RCLONE_OOS_CHUNK_SIZE - Type: SizeSuffix - Default: 5Mi --oos-max-upload-parts Maximum number of parts in a multipart upload. This option defines the maximum number of multipart chunks to use when doing a multipart upload. OCI has max parts limit of 10,000 chunks. Rclone will automatically increase the chunk size when uploading a large file of a known size to stay below this number of chunks limit. Properties: - Config: max_upload_parts - Env Var: RCLONE_OOS_MAX_UPLOAD_PARTS - Type: int - Default: 10000 --oos-upload-concurrency Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. Properties: - Config: upload_concurrency - Env Var: RCLONE_OOS_UPLOAD_CONCURRENCY - Type: int - Default: 10 --oos-copy-cutoff Cutoff for switching to multipart copy. Any files larger than this that need to be server-side copied will be copied in chunks of this size. The minimum is 0 and the maximum is 5 GiB. Properties: - Config: copy_cutoff - Env Var: RCLONE_OOS_COPY_CUTOFF - Type: SizeSuffix - Default: 4.656Gi --oos-copy-timeout Timeout for copy. Copy is an asynchronous operation, specify timeout to wait for copy to succeed Properties: - Config: copy_timeout - Env Var: RCLONE_OOS_COPY_TIMEOUT - Type: Duration - Default: 1m0s --oos-disable-checksum Don't store MD5 checksum with object metadata. Normally rclone will calculate the MD5 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading. Properties: - Config: disable_checksum - Env Var: RCLONE_OOS_DISABLE_CHECKSUM - Type: bool - Default: false --oos-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_OOS_ENCODING - Type: Encoding - Default: Slash,InvalidUtf8,Dot --oos-leave-parts-on-error If true avoid calling abort upload on a failure, leaving all successfully uploaded parts for manual recovery. It should be set to true for resuming uploads across different sessions. WARNING: Storing parts of an incomplete multipart upload counts towards space usage on object storage and will add additional costs if not cleaned up. Properties: - Config: leave_parts_on_error - Env Var: RCLONE_OOS_LEAVE_PARTS_ON_ERROR - Type: bool - Default: false --oos-attempt-resume-upload If true attempt to resume previously started multipart upload for the object. This will be helpful to speed up multipart transfers by resuming uploads from past session. WARNING: If chunk size differs in resumed session from past incomplete session, then the resumed multipart upload is aborted and a new multipart upload is started with the new chunk size. The flag leave_parts_on_error must be true to resume and optimize to skip parts that were already uploaded successfully. Properties: - Config: attempt_resume_upload - Env Var: RCLONE_OOS_ATTEMPT_RESUME_UPLOAD - Type: bool - Default: false --oos-no-check-bucket If set, don't attempt to check the bucket exists or create it. This can be useful when trying to minimise the number of transactions rclone does if you know the bucket exists already. It can also be needed if the user you are using does not have bucket creation permissions. Properties: - Config: no_check_bucket - Env Var: RCLONE_OOS_NO_CHECK_BUCKET - Type: bool - Default: false --oos-sse-customer-key-file To use SSE-C, a file containing the base64-encoded string of the AES-256 encryption key associated with the object. Please note only one of sse_customer_key_file|sse_customer_key|sse_kms_key_id is needed.' Properties: - Config: sse_customer_key_file - Env Var: RCLONE_OOS_SSE_CUSTOMER_KEY_FILE - Type: string - Required: false - Examples: - "" - None --oos-sse-customer-key To use SSE-C, the optional header that specifies the base64-encoded 256-bit encryption key to use to encrypt or decrypt the data. Please note only one of sse_customer_key_file|sse_customer_key|sse_kms_key_id is needed. For more information, see Using Your Own Keys for Server-Side Encryption (https://docs.cloud.oracle.com/Content/Object/Tasks/usingyourencryptionkeys.htm) Properties: - Config: sse_customer_key - Env Var: RCLONE_OOS_SSE_CUSTOMER_KEY - Type: string - Required: false - Examples: - "" - None --oos-sse-customer-key-sha256 If using SSE-C, The optional header that specifies the base64-encoded SHA256 hash of the encryption key. This value is used to check the integrity of the encryption key. see Using Your Own Keys for Server-Side Encryption (https://docs.cloud.oracle.com/Content/Object/Tasks/usingyourencryptionkeys.htm). Properties: - Config: sse_customer_key_sha256 - Env Var: RCLONE_OOS_SSE_CUSTOMER_KEY_SHA256 - Type: string - Required: false - Examples: - "" - None --oos-sse-kms-key-id if using your own master key in vault, this header specifies the OCID (https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm) of a master encryption key used to call the Key Management service to generate a data encryption key or to encrypt or decrypt a data encryption key. Please note only one of sse_customer_key_file|sse_customer_key|sse_kms_key_id is needed. Properties: - Config: sse_kms_key_id - Env Var: RCLONE_OOS_SSE_KMS_KEY_ID - Type: string - Required: false - Examples: - "" - None --oos-sse-customer-algorithm If using SSE-C, the optional header that specifies "AES256" as the encryption algorithm. Object Storage supports "AES256" as the encryption algorithm. For more information, see Using Your Own Keys for Server-Side Encryption (https://docs.cloud.oracle.com/Content/Object/Tasks/usingyourencryptionkeys.htm). Properties: - Config: sse_customer_algorithm - Env Var: RCLONE_OOS_SSE_CUSTOMER_ALGORITHM - Type: string - Required: false - Examples: - "" - None - "AES256" - AES256 --oos-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_OOS_DESCRIPTION - Type: string - Required: false Metadata User metadata is stored as opc-meta- keys. Here are the possible system metadata items for the oracleobjectstorage backend. -------------------------------------------------------------------------------------------- Name Help Type Example Read Only ---------------- -------------- ----------- --------------------------- -------------------- opc-meta-atime Time of last ISO 8601 2025-06-30T22:27:43-04:00 N access opc-meta-btime Time of file ISO 8601 2025-06-30T22:27:43-04:00 N birth (creation) opc-meta-gid Group ID of decimal 500 N owner number opc-meta-mode File type and octal, unix 0100664 N mode style opc-meta-mtime Time of last ISO 8601 2025-06-30T22:27:43-04:00 N modification opc-meta-uid User ID of decimal 500 N owner number -------------------------------------------------------------------------------------------- See the metadata docs for more info. Backend commands Here are the commands specific to the oracleobjectstorage backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the backend command for more info on how to pass options and arguments. These can be run on a running backend using the rc command backend/command. rename change the name of an object rclone backend rename remote: [options] [+] This command can be used to rename a object. Usage Examples: rclone backend rename oos:bucket relative-object-path-under-bucket object-new-name list-multipart-uploads List the unfinished multipart uploads rclone backend list-multipart-uploads remote: [options] [+] This command lists the unfinished multipart uploads in JSON format. rclone backend list-multipart-uploads oos:bucket/path/to/object It returns a dictionary of buckets with values as lists of unfinished multipart uploads. You can call it with no bucket in which case it lists all bucket, with a bucket or with a bucket and path. { "test-bucket": [ { "namespace": "test-namespace", "bucket": "test-bucket", "object": "600m.bin", "uploadId": "51dd8114-52a4-b2f2-c42f-5291f05eb3c8", "timeCreated": "2022-07-29T06:21:16.595Z", "storageTier": "Standard" } ] cleanup Remove unfinished multipart uploads. rclone backend cleanup remote: [options] [+] This command removes unfinished multipart uploads of age greater than max-age which defaults to 24 hours. Note that you can use --interactive/-i or --dry-run with this command to see what it would do. rclone backend cleanup oos:bucket/path/to/object rclone backend cleanup -o max-age=7w oos:bucket/path/to/object Durations are parsed as per the rest of rclone, 2h, 7d, 7w etc. Options: - "max-age": Max age of upload to delete restore Restore objects from Archive to Standard storage rclone backend restore remote: [options] [+] This command can be used to restore one or more objects from Archive to Standard storage. Usage Examples: rclone backend restore oos:bucket/path/to/directory -o hours=HOURS rclone backend restore oos:bucket -o hours=HOURS This flag also obeys the filters. Test first with --interactive/-i or --dry-run flags rclone --interactive backend restore --include "*.txt" oos:bucket/path -o hours=72 All the objects shown will be marked for restore, then rclone backend restore --include "*.txt" oos:bucket/path -o hours=72 It returns a list of status dictionaries with Object Name and Status keys. The Status will be "RESTORED"" if it was successful or an error message if not. [ { "Object": "test.txt" "Status": "RESTORED", }, { "Object": "test/file4.txt" "Status": "RESTORED", } ] Options: - "hours": The number of hours for which this object will be restored. Default is 24 hrs. Tutorials Mounting Buckets QingStor Paths are specified as remote:bucket (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:bucket/path/to/dir. Configuration Here is an example of making an QingStor configuration. First run rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config n/r/c/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / QingStor Object Storage \ "qingstor" [snip] Storage> qingstor Get QingStor credentials from runtime. Only applies if access_key_id and secret_access_key is blank. Choose a number from below, or type in your own value 1 / Enter QingStor credentials in the next step \ "false" 2 / Get QingStor credentials from the environment (env vars or IAM) \ "true" env_auth> 1 QingStor Access Key ID - leave blank for anonymous access or runtime credentials. access_key_id> access_key QingStor Secret Access Key (password) - leave blank for anonymous access or runtime credentials. secret_access_key> secret_key Enter an endpoint URL to connection QingStor API. Leave blank will use the default value "https://qingstor.com:443" endpoint> Zone connect to. Default is "pek3a". Choose a number from below, or type in your own value / The Beijing (China) Three Zone 1 | Needs location constraint pek3a. \ "pek3a" / The Shanghai (China) First Zone 2 | Needs location constraint sh1a. \ "sh1a" zone> 1 Number of connection retry. Leave blank will use the default value "3". connection_retries> Remote config Configuration complete. Options: - type: qingstor - env_auth: false - access_key_id: access_key - secret_access_key: secret_key - endpoint: - zone: pek3a - connection_retries: Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y This remote is called remote and can now be used like this See all buckets rclone lsd remote: Make a new bucket rclone mkdir remote:bucket List the contents of a bucket rclone ls remote:bucket Sync /home/local/directory to the remote bucket, deleting any excess files in the bucket. rclone sync --interactive /home/local/directory remote:bucket --fast-list This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details. Multipart uploads rclone supports multipart uploads with QingStor which means that it can upload files bigger than 5 GiB. Note that files uploaded with multipart upload don't have an MD5SUM. Note that incomplete multipart uploads older than 24 hours can be removed with rclone cleanup remote:bucket just for one bucket rclone cleanup remote: for all buckets. QingStor does not ever remove incomplete multipart uploads so it may be necessary to run this from time to time. Buckets and Zone With QingStor you can list buckets (rclone lsd) using any zone, but you can only access the content of a bucket from the zone it was created in. If you attempt to access a bucket from the wrong zone, you will get an error, incorrect zone, the bucket is not in 'XXX' zone. Authentication There are two ways to supply rclone with a set of QingStor credentials. In order of precedence: - Directly in the rclone configuration file (as configured by rclone config) - set access_key_id and secret_access_key - Runtime configuration: - set env_auth to true in the config file - Exporting the following environment variables before running rclone - Access Key ID: QS_ACCESS_KEY_ID or QS_ACCESS_KEY - Secret Access Key: QS_SECRET_ACCESS_KEY or QS_SECRET_KEY Restricted filename characters The control characters 0x00-0x1F and / are replaced as in the default restricted characters set. Note that 0x7F is not replaced. Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Standard options Here are the Standard options specific to qingstor (QingCloud Object Storage). --qingstor-env-auth Get QingStor credentials from runtime. Only applies if access_key_id and secret_access_key is blank. Properties: - Config: env_auth - Env Var: RCLONE_QINGSTOR_ENV_AUTH - Type: bool - Default: false - Examples: - "false" - Enter QingStor credentials in the next step. - "true" - Get QingStor credentials from the environment (env vars or IAM). --qingstor-access-key-id QingStor Access Key ID. Leave blank for anonymous access or runtime credentials. Properties: - Config: access_key_id - Env Var: RCLONE_QINGSTOR_ACCESS_KEY_ID - Type: string - Required: false --qingstor-secret-access-key QingStor Secret Access Key (password). Leave blank for anonymous access or runtime credentials. Properties: - Config: secret_access_key - Env Var: RCLONE_QINGSTOR_SECRET_ACCESS_KEY - Type: string - Required: false --qingstor-endpoint Enter an endpoint URL to connection QingStor API. Leave blank will use the default value "https://qingstor.com:443". Properties: - Config: endpoint - Env Var: RCLONE_QINGSTOR_ENDPOINT - Type: string - Required: false --qingstor-zone Zone to connect to. Default is "pek3a". Properties: - Config: zone - Env Var: RCLONE_QINGSTOR_ZONE - Type: string - Required: false - Examples: - "pek3a" - The Beijing (China) Three Zone. - Needs location constraint pek3a. - "sh1a" - The Shanghai (China) First Zone. - Needs location constraint sh1a. - "gd2a" - The Guangdong (China) Second Zone. - Needs location constraint gd2a. Advanced options Here are the Advanced options specific to qingstor (QingCloud Object Storage). --qingstor-connection-retries Number of connection retries. Properties: - Config: connection_retries - Env Var: RCLONE_QINGSTOR_CONNECTION_RETRIES - Type: int - Default: 3 --qingstor-upload-cutoff Cutoff for switching to chunked upload. Any files larger than this will be uploaded in chunks of chunk_size. The minimum is 0 and the maximum is 5 GiB. Properties: - Config: upload_cutoff - Env Var: RCLONE_QINGSTOR_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 200Mi --qingstor-chunk-size Chunk size to use for uploading. When uploading files larger than upload_cutoff they will be uploaded as multipart uploads using this chunk size. Note that "--qingstor-upload-concurrency" chunks of this size are buffered in memory per transfer. If you are transferring large files over high-speed links and you have enough memory, then increasing this will speed up the transfers. Properties: - Config: chunk_size - Env Var: RCLONE_QINGSTOR_CHUNK_SIZE - Type: SizeSuffix - Default: 4Mi --qingstor-upload-concurrency Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently. NB if you set this to > 1 then the checksums of multipart uploads become corrupted (the uploads themselves are not corrupted though). If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. Properties: - Config: upload_concurrency - Env Var: RCLONE_QINGSTOR_UPLOAD_CONCURRENCY - Type: int - Default: 1 --qingstor-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_QINGSTOR_ENCODING - Type: Encoding - Default: Slash,Ctl,InvalidUtf8 --qingstor-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_QINGSTOR_DESCRIPTION - Type: string - Required: false Limitations rclone about is not supported by the qingstor backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about Quatrix Quatrix by Maytech is Quatrix Secure Compliant File Sharing | Maytech. Paths are specified as remote:path Paths may be as deep as required, e.g., remote:directory/subdirectory. The initial setup for Quatrix involves getting an API Key from Quatrix. You can get the API key in the user's profile at https:///profile/api-keys or with the help of the API - https://docs.maytech.net/quatrix/quatrix-api/api-explorer#/API-Key/post_api_key_create. See complete Swagger documentation for Quatrix - https://docs.maytech.net/quatrix/quatrix-api/api-explorer Configuration Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Quatrix by Maytech \ "quatrix" [snip] Storage> quatrix API key for accessing Quatrix account. api_key> your_api_key Host name of Quatrix account. host> example.quatrix.it Configuration complete. Options: - type: quatrix - api_key: your_api_key - host: example.quatrix.it Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Once configured you can then use rclone like this, List directories in top level of your Quatrix rclone lsd remote: List all the files in your Quatrix rclone ls remote: To copy a local directory to an Quatrix directory called backup rclone copy /home/source remote:backup API key validity API Key is created with no expiration date. It will be valid until you delete or deactivate it in your account. After disabling, the API Key can be enabled back. If the API Key was deleted and a new key was created, you can update it in rclone config. The same happens if the hostname was changed. $ rclone config Current remotes: Name Type ==== ==== remote quatrix e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> e Choose a number from below, or type in an existing value 1 > remote remote> remote Configuration complete. Options: - type: quatrix - host: some_host.quatrix.it - api_key: your_api_key Keep this "remote" remote? Edit remote Option api_key. API key for accessing Quatrix account Enter a string value. Press Enter for the default (your_api_key) api_key> Option host. Host name of Quatrix account Enter a string value. Press Enter for the default (some_host.quatrix.it). Configuration complete. Options: - type: quatrix - host: some_host.quatrix.it - api_key: your_api_key Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Modification times and hashes Quatrix allows modification times to be set on objects accurate to 1 microsecond. These will be used to detect whether objects need syncing or not. Quatrix does not support hashes, so you cannot use the --checksum flag. Restricted filename characters File names in Quatrix are case sensitive and have limitations like the maximum length of a filename is 255, and the minimum length is 1. A file name cannot be equal to . or .. nor contain / , \ or non-printable ascii. Transfers For files above 50 MiB rclone will use a chunked transfer. Rclone will upload up to --transfers chunks at the same time (shared among all multipart uploads). Chunks are buffered in memory, and the minimal chunk size is 10_000_000 bytes by default, and it can be changed in the advanced configuration, so increasing --transfers will increase the memory use. The chunk size has a maximum size limit, which is set to 100_000_000 bytes by default and can be changed in the advanced configuration. The size of the uploaded chunk will dynamically change depending on the upload speed. The total memory use equals the number of transfers multiplied by the minimal chunk size. In case there's free memory allocated for the upload (which equals the difference of maximal_summary_chunk_size and minimal_chunk_size * transfers), the chunk size may increase in case of high upload speed. As well as it can decrease in case of upload speed problems. If no free memory is available, all chunks will equal minimal_chunk_size. Deleting files Files you delete with rclone will end up in Trash and be stored there for 30 days. Quatrix also provides an API to permanently delete files and an API to empty the Trash so that you can remove files permanently from your account. Standard options Here are the Standard options specific to quatrix (Quatrix by Maytech). --quatrix-api-key API key for accessing Quatrix account Properties: - Config: api_key - Env Var: RCLONE_QUATRIX_API_KEY - Type: string - Required: true --quatrix-host Host name of Quatrix account Properties: - Config: host - Env Var: RCLONE_QUATRIX_HOST - Type: string - Required: true Advanced options Here are the Advanced options specific to quatrix (Quatrix by Maytech). --quatrix-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_QUATRIX_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot --quatrix-effective-upload-time Wanted upload time for one chunk Properties: - Config: effective_upload_time - Env Var: RCLONE_QUATRIX_EFFECTIVE_UPLOAD_TIME - Type: string - Default: "4s" --quatrix-minimal-chunk-size The minimal size for one chunk Properties: - Config: minimal_chunk_size - Env Var: RCLONE_QUATRIX_MINIMAL_CHUNK_SIZE - Type: SizeSuffix - Default: 9.537Mi --quatrix-maximal-summary-chunk-size The maximal summary for all chunks. It should not be less than 'transfers'*'minimal_chunk_size' Properties: - Config: maximal_summary_chunk_size - Env Var: RCLONE_QUATRIX_MAXIMAL_SUMMARY_CHUNK_SIZE - Type: SizeSuffix - Default: 95.367Mi --quatrix-hard-delete Delete files permanently rather than putting them into the trash Properties: - Config: hard_delete - Env Var: RCLONE_QUATRIX_HARD_DELETE - Type: bool - Default: false --quatrix-skip-project-folders Skip project folders in operations Properties: - Config: skip_project_folders - Env Var: RCLONE_QUATRIX_SKIP_PROJECT_FOLDERS - Type: bool - Default: false --quatrix-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_QUATRIX_DESCRIPTION - Type: string - Required: false Storage usage The storage usage in Quatrix is restricted to the account during the purchase. You can restrict any user with a smaller storage limit. The account limit is applied if the user has no custom storage limit. Once you've reached the limit, the upload of files will fail. This can be fixed by freeing up the space or increasing the quota. Server-side operations Quatrix supports server-side operations (copy and move). In case of conflict, files are overwritten during server-side operation. Sia Sia (sia.tech) is a decentralized cloud storage platform based on the blockchain technology. With rclone you can use it like any other remote filesystem or mount Sia folders locally. The technology behind it involves a number of new concepts such as Siacoins and Wallet, Blockchain and Consensus, Renting and Hosting, and so on. If you are new to it, you'd better first familiarize yourself using their excellent support documentation. Introduction Before you can use rclone with Sia, you will need to have a running copy of Sia-UI or siad (the Sia daemon) locally on your computer or on local network (e.g. a NAS). Please follow the Get started guide and install one. rclone interacts with Sia network by talking to the Sia daemon via HTTP API which is usually available on port 9980. By default you will run the daemon locally on the same computer so it's safe to leave the API password blank (the API URL will be http://127.0.0.1:9980 making external access impossible). However, if you want to access Sia daemon running on another node, for example due to memory constraints or because you want to share single daemon between several rclone and Sia-UI instances, you'll need to make a few more provisions: - Ensure you have Sia daemon installed directly or in a docker container because Sia-UI does not support this mode natively. - Run it on externally accessible port, for example provide --api-addr :9980 and --disable-api-security arguments on the daemon command line. - Enforce API password for the siad daemon via environment variable SIA_API_PASSWORD or text file named apipassword in the daemon directory. - Set rclone backend option api_password taking it from above locations. Notes: 1. If your wallet is locked, rclone cannot unlock it automatically. You should either unlock it in advance by using Sia-UI or via command line siac wallet unlock. Alternatively you can make siad unlock your wallet automatically upon startup by running it with environment variable SIA_WALLET_PASSWORD. 2. If siad cannot find the SIA_API_PASSWORD variable or the apipassword file in the SIA_DIR directory, it will generate a random password and store in the text file named apipassword under YOUR_HOME/.sia/ directory on Unix or C:\Users\YOUR_HOME\AppData\Local\Sia\apipassword on Windows. Remember this when you configure password in rclone. 3. The only way to use siad without API password is to run it on localhost with command line argument --authorize-api=false, but this is insecure and strongly discouraged. Configuration Here is an example of how to make a sia remote called mySia. First, run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> mySia Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value ... 29 / Sia Decentralized Cloud \ "sia" ... Storage> sia Sia daemon API URL, like http://sia.daemon.host:9980. Note that siad must run with --disable-api-security to open API port for other hosts (not recommended). Keep default if Sia daemon runs on localhost. Enter a string value. Press Enter for the default ("http://127.0.0.1:9980"). api_url> http://127.0.0.1:9980 Sia Daemon API Password. Can be found in the apipassword file located in HOME/.sia/ or in the daemon directory. y) Yes type in my own password g) Generate random password n) No leave this optional password blank (default) y/g/n> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n -------------------- [mySia] type = sia api_url = http://127.0.0.1:9980 api_password = *** ENCRYPTED *** -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Once configured, you can then use rclone like this: - List directories in top level of your Sia storage rclone lsd mySia: - List all the files in your Sia storage rclone ls mySia: - Upload a local directory to the Sia directory called backup rclone copy /home/source mySia:backup Standard options Here are the Standard options specific to sia (Sia Decentralized Cloud). --sia-api-url Sia daemon API URL, like http://sia.daemon.host:9980. Note that siad must run with --disable-api-security to open API port for other hosts (not recommended). Keep default if Sia daemon runs on localhost. Properties: - Config: api_url - Env Var: RCLONE_SIA_API_URL - Type: string - Default: "http://127.0.0.1:9980" --sia-api-password Sia Daemon API Password. Can be found in the apipassword file located in HOME/.sia/ or in the daemon directory. NB Input to this must be obscured - see rclone obscure. Properties: - Config: api_password - Env Var: RCLONE_SIA_API_PASSWORD - Type: string - Required: false Advanced options Here are the Advanced options specific to sia (Sia Decentralized Cloud). --sia-user-agent Siad User Agent Sia daemon requires the 'Sia-Agent' user agent by default for security Properties: - Config: user_agent - Env Var: RCLONE_SIA_USER_AGENT - Type: string - Default: "Sia-Agent" --sia-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_SIA_ENCODING - Type: Encoding - Default: Slash,Question,Hash,Percent,Del,Ctl,InvalidUtf8,Dot --sia-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SIA_DESCRIPTION - Type: string - Required: false Limitations - Modification times not supported - Checksums not supported - rclone about not supported - rclone can work only with Siad or Sia-UI at the moment, the SkyNet daemon is not supported yet. - Sia does not allow control characters or symbols like question and pound signs in file names. rclone will transparently encode them for you, but you'd better be aware Swift Swift refers to OpenStack Object Storage. Commercial implementations of that being: - Rackspace Cloud Files - Memset Memstore - OVH Object Storage - Oracle Cloud Storage - Blomp Cloud Storage - IBM Bluemix Cloud ObjectStorage Swift Paths are specified as remote:container (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:container/path/to/dir. Configuration Here is an example of making a swift configuration. First run rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / OpenStack Swift (Rackspace Cloud Files, Blomp Cloud Storage, Memset Memstore, OVH) \ "swift" [snip] Storage> swift Get swift credentials from environment variables in standard OpenStack form. Choose a number from below, or type in your own value 1 / Enter swift credentials in the next step \ "false" 2 / Get swift credentials from environment vars. Leave other fields blank if using this. \ "true" env_auth> true User name to log in (OS_USERNAME). user> API key or password (OS_PASSWORD). key> Authentication URL for server (OS_AUTH_URL). Choose a number from below, or type in your own value 1 / Rackspace US \ "https://auth.api.rackspacecloud.com/v1.0" 2 / Rackspace UK \ "https://lon.auth.api.rackspacecloud.com/v1.0" 3 / Rackspace v2 \ "https://identity.api.rackspacecloud.com/v2.0" 4 / Memset Memstore UK \ "https://auth.storage.memset.com/v1.0" 5 / Memset Memstore UK v2 \ "https://auth.storage.memset.com/v2.0" 6 / OVH \ "https://auth.cloud.ovh.net/v3" 7 / Blomp Cloud Storage \ "https://authenticate.ain.net" auth> User ID to log in - optional - most swift systems use user and leave this blank (v3 auth) (OS_USER_ID). user_id> User domain - optional (v3 auth) (OS_USER_DOMAIN_NAME) domain> Tenant name - optional for v1 auth, this or tenant_id required otherwise (OS_TENANT_NAME or OS_PROJECT_NAME) tenant> Tenant ID - optional for v1 auth, this or tenant required otherwise (OS_TENANT_ID) tenant_id> Tenant domain - optional (v3 auth) (OS_PROJECT_DOMAIN_NAME) tenant_domain> Region name - optional (OS_REGION_NAME) region> Storage URL - optional (OS_STORAGE_URL) storage_url> Auth Token from alternate authentication - optional (OS_AUTH_TOKEN) auth_token> AuthVersion - optional - set to (1,2,3) if your auth URL has no version (ST_AUTH_VERSION) auth_version> Endpoint type to choose from the service catalogue (OS_ENDPOINT_TYPE) Choose a number from below, or type in your own value 1 / Public (default, choose this if not sure) \ "public" 2 / Internal (use internal service net) \ "internal" 3 / Admin \ "admin" endpoint_type> Remote config -------------------- [test] env_auth = true user = key = auth = user_id = domain = tenant = tenant_id = tenant_domain = region = storage_url = auth_token = auth_version = endpoint_type = -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y This remote is called remote and can now be used like this See all containers rclone lsd remote: Make a new container rclone mkdir remote:container List the contents of a container rclone ls remote:container Sync /home/local/directory to the remote container, deleting any excess files in the container. rclone sync --interactive /home/local/directory remote:container Configuration from an OpenStack credentials file An OpenStack credentials file typically looks something something like this (without the comments) export OS_AUTH_URL=https://a.provider.net/v2.0 export OS_TENANT_ID=ffffffffffffffffffffffffffffffff export OS_TENANT_NAME="1234567890123456" export OS_USERNAME="123abc567xy" echo "Please enter your OpenStack Password: " read -sr OS_PASSWORD_INPUT export OS_PASSWORD=$OS_PASSWORD_INPUT export OS_REGION_NAME="SBG1" if [ -z "$OS_REGION_NAME" ]; then unset OS_REGION_NAME; fi The config file needs to look something like this where $OS_USERNAME represents the value of the OS_USERNAME variable - 123abc567xy in the example above. [remote] type = swift user = $OS_USERNAME key = $OS_PASSWORD auth = $OS_AUTH_URL tenant = $OS_TENANT_NAME Note that you may (or may not) need to set region too - try without first. Configuration from the environment If you prefer you can configure rclone to use swift using a standard set of OpenStack environment variables. When you run through the config, make sure you choose true for env_auth and leave everything else blank. rclone will then set any empty config parameters from the environment using standard OpenStack environment variables. There is a list of the variables in the docs for the swift library. Using an alternate authentication method If your OpenStack installation uses a non-standard authentication method that might not be yet supported by rclone or the underlying swift library, you can authenticate externally (e.g. calling manually the openstack commands to get a token). Then, you just need to pass the two configuration variables auth_token and storage_url. If they are both provided, the other variables are ignored. rclone will not try to authenticate but instead assume it is already authenticated and use these two variables to access the OpenStack installation. Using rclone without a config file You can use rclone with swift without a config file, if desired, like this: source openstack-credentials-file export RCLONE_CONFIG_MYREMOTE_TYPE=swift export RCLONE_CONFIG_MYREMOTE_ENV_AUTH=true rclone lsd myremote: --fast-list This remote supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details. --update and --use-server-modtime As noted below, the modified time is stored on metadata on the object. It is used by default for all operations that require checking the time a file was last updated. It allows rclone to treat the remote more like a true filesystem, but it is inefficient because it requires an extra API call to retrieve the metadata. For many operations, the time the object was last uploaded to the remote is sufficient to determine if it is "dirty". By using --update along with --use-server-modtime, you can avoid the extra API call and simply upload files whose local modtime is newer than the time it was last uploaded. Modification times and hashes The modified time is stored as metadata on the object as X-Object-Meta-Mtime as floating point since the epoch accurate to 1 ns. This is a de facto standard (used in the official python-swiftclient amongst others) for storing the modification time for an object. The MD5 hash algorithm is supported. Restricted filename characters Character Value Replacement ----------- ------- ------------- NUL 0x00 ␀ / 0x2F ／ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Standard options Here are the Standard options specific to swift (OpenStack Swift (Rackspace Cloud Files, Blomp Cloud Storage, Memset Memstore, OVH)). --swift-env-auth Get swift credentials from environment variables in standard OpenStack form. Properties: - Config: env_auth - Env Var: RCLONE_SWIFT_ENV_AUTH - Type: bool - Default: false - Examples: - "false" - Enter swift credentials in the next step. - "true" - Get swift credentials from environment vars. - Leave other fields blank if using this. --swift-user User name to log in (OS_USERNAME). Properties: - Config: user - Env Var: RCLONE_SWIFT_USER - Type: string - Required: false --swift-key API key or password (OS_PASSWORD). Properties: - Config: key - Env Var: RCLONE_SWIFT_KEY - Type: string - Required: false --swift-auth Authentication URL for server (OS_AUTH_URL). Properties: - Config: auth - Env Var: RCLONE_SWIFT_AUTH - Type: string - Required: false - Examples: - "https://auth.api.rackspacecloud.com/v1.0" - Rackspace US - "https://lon.auth.api.rackspacecloud.com/v1.0" - Rackspace UK - "https://identity.api.rackspacecloud.com/v2.0" - Rackspace v2 - "https://auth.storage.memset.com/v1.0" - Memset Memstore UK - "https://auth.storage.memset.com/v2.0" - Memset Memstore UK v2 - "https://auth.cloud.ovh.net/v3" - OVH - "https://authenticate.ain.net" - Blomp Cloud Storage --swift-user-id User ID to log in - optional - most swift systems use user and leave this blank (v3 auth) (OS_USER_ID). Properties: - Config: user_id - Env Var: RCLONE_SWIFT_USER_ID - Type: string - Required: false --swift-domain User domain - optional (v3 auth) (OS_USER_DOMAIN_NAME) Properties: - Config: domain - Env Var: RCLONE_SWIFT_DOMAIN - Type: string - Required: false --swift-tenant Tenant name - optional for v1 auth, this or tenant_id required otherwise (OS_TENANT_NAME or OS_PROJECT_NAME). Properties: - Config: tenant - Env Var: RCLONE_SWIFT_TENANT - Type: string - Required: false --swift-tenant-id Tenant ID - optional for v1 auth, this or tenant required otherwise (OS_TENANT_ID). Properties: - Config: tenant_id - Env Var: RCLONE_SWIFT_TENANT_ID - Type: string - Required: false --swift-tenant-domain Tenant domain - optional (v3 auth) (OS_PROJECT_DOMAIN_NAME). Properties: - Config: tenant_domain - Env Var: RCLONE_SWIFT_TENANT_DOMAIN - Type: string - Required: false --swift-region Region name - optional (OS_REGION_NAME). Properties: - Config: region - Env Var: RCLONE_SWIFT_REGION - Type: string - Required: false --swift-storage-url Storage URL - optional (OS_STORAGE_URL). Properties: - Config: storage_url - Env Var: RCLONE_SWIFT_STORAGE_URL - Type: string - Required: false --swift-auth-token Auth Token from alternate authentication - optional (OS_AUTH_TOKEN). Properties: - Config: auth_token - Env Var: RCLONE_SWIFT_AUTH_TOKEN - Type: string - Required: false --swift-application-credential-id Application Credential ID (OS_APPLICATION_CREDENTIAL_ID). Properties: - Config: application_credential_id - Env Var: RCLONE_SWIFT_APPLICATION_CREDENTIAL_ID - Type: string - Required: false --swift-application-credential-name Application Credential Name (OS_APPLICATION_CREDENTIAL_NAME). Properties: - Config: application_credential_name - Env Var: RCLONE_SWIFT_APPLICATION_CREDENTIAL_NAME - Type: string - Required: false --swift-application-credential-secret Application Credential Secret (OS_APPLICATION_CREDENTIAL_SECRET). Properties: - Config: application_credential_secret - Env Var: RCLONE_SWIFT_APPLICATION_CREDENTIAL_SECRET - Type: string - Required: false --swift-auth-version AuthVersion - optional - set to (1,2,3) if your auth URL has no version (ST_AUTH_VERSION). Properties: - Config: auth_version - Env Var: RCLONE_SWIFT_AUTH_VERSION - Type: int - Default: 0 --swift-endpoint-type Endpoint type to choose from the service catalogue (OS_ENDPOINT_TYPE). Properties: - Config: endpoint_type - Env Var: RCLONE_SWIFT_ENDPOINT_TYPE - Type: string - Default: "public" - Examples: - "public" - Public (default, choose this if not sure) - "internal" - Internal (use internal service net) - "admin" - Admin --swift-storage-policy The storage policy to use when creating a new container. This applies the specified storage policy when creating a new container. The policy cannot be changed afterwards. The allowed configuration values and their meaning depend on your Swift storage provider. Properties: - Config: storage_policy - Env Var: RCLONE_SWIFT_STORAGE_POLICY - Type: string - Required: false - Examples: - "" - Default - "pcs" - OVH Public Cloud Storage - "pca" - OVH Public Cloud Archive Advanced options Here are the Advanced options specific to swift (OpenStack Swift (Rackspace Cloud Files, Blomp Cloud Storage, Memset Memstore, OVH)). --swift-leave-parts-on-error If true avoid calling abort upload on a failure. It should be set to true for resuming uploads across different sessions. Properties: - Config: leave_parts_on_error - Env Var: RCLONE_SWIFT_LEAVE_PARTS_ON_ERROR - Type: bool - Default: false --swift-fetch-until-empty-page When paginating, always fetch unless we received an empty page. Consider using this option if rclone listings show fewer objects than expected, or if repeated syncs copy unchanged objects. It is safe to enable this, but rclone may make more API calls than necessary. This is one of a pair of workarounds to handle implementations of the Swift API that do not implement pagination as expected. See also "partial_page_fetch_threshold". Properties: - Config: fetch_until_empty_page - Env Var: RCLONE_SWIFT_FETCH_UNTIL_EMPTY_PAGE - Type: bool - Default: false --swift-partial-page-fetch-threshold When paginating, fetch if the current page is within this percentage of the limit. Consider using this option if rclone listings show fewer objects than expected, or if repeated syncs copy unchanged objects. It is safe to enable this, but rclone may make more API calls than necessary. This is one of a pair of workarounds to handle implementations of the Swift API that do not implement pagination as expected. See also "fetch_until_empty_page". Properties: - Config: partial_page_fetch_threshold - Env Var: RCLONE_SWIFT_PARTIAL_PAGE_FETCH_THRESHOLD - Type: int - Default: 0 --swift-chunk-size Above this size files will be chunked. Above this size files will be chunked into a a _segments container or a .file-segments directory. (See the use_segments_container option for more info). Default for this is 5 GiB which is its maximum value, which means only files above this size will be chunked. Rclone uploads chunked files as dynamic large objects (DLO). Properties: - Config: chunk_size - Env Var: RCLONE_SWIFT_CHUNK_SIZE - Type: SizeSuffix - Default: 5Gi --swift-no-chunk Don't chunk files during streaming upload. When doing streaming uploads (e.g. using rcat or mount with --vfs-cache-mode off) setting this flag will cause the swift backend to not upload chunked files. This will limit the maximum streamed upload size to 5 GiB. This is useful because non chunked files are easier to deal with and have an MD5SUM. Rclone will still chunk files bigger than chunk_size when doing normal copy operations. Properties: - Config: no_chunk - Env Var: RCLONE_SWIFT_NO_CHUNK - Type: bool - Default: false --swift-no-large-objects Disable support for static and dynamic large objects Swift cannot transparently store files bigger than 5 GiB. There are two schemes for chunking large files, static large objects (SLO) or dynamic large objects (DLO), and the API does not allow rclone to determine whether a file is a static or dynamic large object without doing a HEAD on the object. Since these need to be treated differently, this means rclone has to issue HEAD requests for objects for example when reading checksums. When no_large_objects is set, rclone will assume that there are no static or dynamic large objects stored. This means it can stop doing the extra HEAD calls which in turn increases performance greatly especially when doing a swift to swift transfer with --checksum set. Setting this option implies no_chunk and also that no files will be uploaded in chunks, so files bigger than 5 GiB will just fail on upload. If you set this option and there are static or dynamic large objects, then this will give incorrect hashes for them. Downloads will succeed, but other operations such as Remove and Copy will fail. Properties: - Config: no_large_objects - Env Var: RCLONE_SWIFT_NO_LARGE_OBJECTS - Type: bool - Default: false --swift-use-segments-container Choose destination for large object segments Swift cannot transparently store files bigger than 5 GiB and rclone will chunk files larger than chunk_size (default 5 GiB) in order to upload them. If this value is true the chunks will be stored in an additional container named the same as the destination container but with _segments appended. This means that there won't be any duplicated data in the original container but having another container may not be acceptable. If this value is false the chunks will be stored in a .file-segments directory in the root of the container. This directory will be omitted when listing the container. Some providers (eg Blomp) require this mode as creating additional containers isn't allowed. If it is desired to see the .file-segments directory in the root then this flag must be set to true. If this value is unset (the default), then rclone will choose the value to use. It will be false unless rclone detects any auth_urls that it knows need it to be true. In this case you'll see a message in the DEBUG log. Properties: - Config: use_segments_container - Env Var: RCLONE_SWIFT_USE_SEGMENTS_CONTAINER - Type: Tristate - Default: unset --swift-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_SWIFT_ENCODING - Type: Encoding - Default: Slash,InvalidUtf8 --swift-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SWIFT_DESCRIPTION - Type: string - Required: false Limitations The Swift API doesn't return a correct MD5SUM for segmented files (Dynamic or Static Large Objects) so rclone won't check or use the MD5SUM for these. Troubleshooting Rclone gives Failed to create file system for "remote:": Bad Request Due to an oddity of the underlying swift library, it gives a "Bad Request" error rather than a more sensible error when the authentication fails for Swift. So this most likely means your username / password is wrong. You can investigate further with the --dump-bodies flag. This may also be caused by specifying the region when you shouldn't have (e.g. OVH). Rclone gives Failed to create file system: Response didn't have storage url and auth token This is most likely caused by forgetting to specify your tenant when setting up a swift remote. OVH Cloud Archive To use rclone with OVH cloud archive, first use rclone config to set up a swift backend with OVH, choosing pca as the storage_policy. Uploading Objects Uploading objects to OVH cloud archive is no different to object storage, you just simply run the command you like (move, copy or sync) to upload the objects. Once uploaded the objects will show in a "Frozen" state within the OVH control panel. Retrieving Objects To retrieve objects use rclone copy as normal. If the objects are in a frozen state then rclone will ask for them all to be unfrozen and it will wait at the end of the output with a message like the following: 2019/03/23 13:06:33 NOTICE: Received retry after error - sleeping until 2019-03-23T13:16:33.481657164+01:00 (9m59.99985121s) Rclone will wait for the time specified then retry the copy. pCloud Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. Configuration The initial setup for pCloud involves getting a token from pCloud which you need to do in your browser. rclone config walks you through it. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Pcloud \ "pcloud" [snip] Storage> pcloud Pcloud App Client Id - leave blank normally. client_id> Pcloud App Client Secret - leave blank normally. client_secret> Edit advanced config? y) Yes n) No (default) y/n> n Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: pcloud - client_id: - client_secret: - token: {"access_token":"XXX","token_type":"bearer","expiry":"0001-01-01T00:00:00Z"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y See the remote setup docs for how to set it up on a machine with no Internet browser available. Note if you are using remote config with rclone authorize while your pcloud server is the EU region, you will need to set the hostname in 'Edit advanced config', otherwise you might get a token error. Note that rclone runs a webserver on your local machine to collect the token as returned from pCloud. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall. Once configured you can then use rclone like this, List directories in top level of your pCloud rclone lsd remote: List all the files in your pCloud rclone ls remote: To copy a local directory to a pCloud directory called backup rclone copy /home/source remote:backup Modification times and hashes pCloud allows modification times to be set on objects accurate to 1 second. These will be used to detect whether objects need syncing or not. In order to set a Modification time pCloud requires the object be re-uploaded. pCloud supports MD5 and SHA1 hashes in the US region, and SHA1 and SHA256 hashes in the EU region, so you can use the --checksum flag. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- \ 0x5C ＼ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Deleting files Deleted files will be moved to the trash. Your subscription level will determine how long items stay in the trash. rclone cleanup can be used to empty the trash. Emptying the trash Due to an API limitation, the rclone cleanup command will only work if you set your username and password in the advanced options for this backend. Since we generally want to avoid storing user passwords in the rclone config file, we advise you to only set this up if you need the rclone cleanup command to work. Root folder ID You can set the root_folder_id for rclone. This is the directory (identified by its Folder ID) that rclone considers to be the root of your pCloud drive. Normally you will leave this blank and rclone will determine the correct root to use itself. However you can set this to restrict rclone to a specific folder hierarchy. In order to do this you will have to find the Folder ID of the directory you wish rclone to display. This will be the folder field of the URL when you open the relevant folder in the pCloud web interface. So if the folder you want rclone to use has a URL which looks like https://my.pcloud.com/#page=filemanager&folder=5xxxxxxxx8&tpl=foldergrid in the browser, then you use 5xxxxxxxx8 as the root_folder_id in the config. Standard options Here are the Standard options specific to pcloud (Pcloud). --pcloud-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_PCLOUD_CLIENT_ID - Type: string - Required: false --pcloud-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_PCLOUD_CLIENT_SECRET - Type: string - Required: false Advanced options Here are the Advanced options specific to pcloud (Pcloud). --pcloud-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_PCLOUD_TOKEN - Type: string - Required: false --pcloud-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_PCLOUD_AUTH_URL - Type: string - Required: false --pcloud-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_PCLOUD_TOKEN_URL - Type: string - Required: false --pcloud-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_PCLOUD_CLIENT_CREDENTIALS - Type: bool - Default: false --pcloud-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_PCLOUD_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot --pcloud-root-folder-id Fill in for rclone to use a non root folder as its starting point. Properties: - Config: root_folder_id - Env Var: RCLONE_PCLOUD_ROOT_FOLDER_ID - Type: string - Default: "d0" --pcloud-hostname Hostname to connect to. This is normally set when rclone initially does the oauth connection, however you will need to set it by hand if you are using remote config with rclone authorize. Properties: - Config: hostname - Env Var: RCLONE_PCLOUD_HOSTNAME - Type: string - Default: "api.pcloud.com" - Examples: - "api.pcloud.com" - Original/US region - "eapi.pcloud.com" - EU region --pcloud-username Your pcloud username. This is only required when you want to use the cleanup command. Due to a bug in the pcloud API the required API does not support OAuth authentication so we have to rely on user password authentication for it. Properties: - Config: username - Env Var: RCLONE_PCLOUD_USERNAME - Type: string - Required: false --pcloud-password Your pcloud password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: password - Env Var: RCLONE_PCLOUD_PASSWORD - Type: string - Required: false --pcloud-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PCLOUD_DESCRIPTION - Type: string - Required: false PikPak PikPak is a private cloud drive. Paths are specified as remote:path, and may be as deep as required, e.g. remote:directory/subdirectory. Configuration Here is an example of making a remote for PikPak. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n Enter name for new remote. name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. XX / PikPak \ (pikpak) Storage> XX Option user. Pikpak username. Enter a value. user> USERNAME Option pass. Pikpak password. Choose an alternative below. y) Yes, type in my own password g) Generate random password y/g> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> Configuration complete. Options: - type: pikpak - user: USERNAME - pass: *** ENCRYPTED *** - token: {"access_token":"eyJ...","token_type":"Bearer","refresh_token":"os...","expiry":"2023-01-26T18:54:32.170582647+09:00"} Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Modification times and hashes PikPak keeps modification times on objects, and updates them when uploading objects, but it does not support changing only the modification time The MD5 hash algorithm is supported. Standard options Here are the Standard options specific to pikpak (PikPak). --pikpak-user Pikpak username. Properties: - Config: user - Env Var: RCLONE_PIKPAK_USER - Type: string - Required: true --pikpak-pass Pikpak password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: pass - Env Var: RCLONE_PIKPAK_PASS - Type: string - Required: true Advanced options Here are the Advanced options specific to pikpak (PikPak). --pikpak-device-id Device ID used for authorization. Properties: - Config: device_id - Env Var: RCLONE_PIKPAK_DEVICE_ID - Type: string - Required: false --pikpak-user-agent HTTP user agent for pikpak. Defaults to "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:129.0) Gecko/20100101 Firefox/129.0" or "--pikpak-user-agent" provided on command line. Properties: - Config: user_agent - Env Var: RCLONE_PIKPAK_USER_AGENT - Type: string - Default: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:129.0) Gecko/20100101 Firefox/129.0" --pikpak-root-folder-id ID of the root folder. Leave blank normally. Fill in for rclone to use a non root folder as its starting point. Properties: - Config: root_folder_id - Env Var: RCLONE_PIKPAK_ROOT_FOLDER_ID - Type: string - Required: false --pikpak-use-trash Send files to the trash instead of deleting permanently. Defaults to true, namely sending files to the trash. Use --pikpak-use-trash=false to delete files permanently instead. Properties: - Config: use_trash - Env Var: RCLONE_PIKPAK_USE_TRASH - Type: bool - Default: true --pikpak-trashed-only Only show files that are in the trash. This will show trashed files in their original directory structure. Properties: - Config: trashed_only - Env Var: RCLONE_PIKPAK_TRASHED_ONLY - Type: bool - Default: false --pikpak-no-media-link Use original file links instead of media links. This avoids issues caused by invalid media links, but may reduce download speeds. Properties: - Config: no_media_link - Env Var: RCLONE_PIKPAK_NO_MEDIA_LINK - Type: bool - Default: false --pikpak-hash-memory-limit Files bigger than this will be cached on disk to calculate hash if required. Properties: - Config: hash_memory_limit - Env Var: RCLONE_PIKPAK_HASH_MEMORY_LIMIT - Type: SizeSuffix - Default: 10Mi --pikpak-upload-cutoff Cutoff for switching to chunked upload. Any files larger than this will be uploaded in chunks of chunk_size. The minimum is 0 and the maximum is 5 GiB. Properties: - Config: upload_cutoff - Env Var: RCLONE_PIKPAK_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 200Mi --pikpak-chunk-size Chunk size for multipart uploads. Large files will be uploaded in chunks of this size. Note that this is stored in memory and there may be up to "--transfers" * "--pikpak-upload-concurrency" chunks stored at once in memory. If you are transferring large files over high-speed links and you have enough memory, then increasing this will speed up the transfers. Rclone will automatically increase the chunk size when uploading a large file of known size to stay below the 10,000 chunks limit. Increasing the chunk size decreases the accuracy of the progress statistics displayed with "-P" flag. Properties: - Config: chunk_size - Env Var: RCLONE_PIKPAK_CHUNK_SIZE - Type: SizeSuffix - Default: 5Mi --pikpak-upload-concurrency Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently for multipart uploads. Note that chunks are stored in memory and there may be up to "--transfers" * "--pikpak-upload-concurrency" chunks stored at once in memory. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. Properties: - Config: upload_concurrency - Env Var: RCLONE_PIKPAK_UPLOAD_CONCURRENCY - Type: int - Default: 4 --pikpak-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_PIKPAK_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,LeftSpace,RightSpace,RightPeriod,InvalidUtf8,Dot --pikpak-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PIKPAK_DESCRIPTION - Type: string - Required: false Backend commands Here are the commands specific to the pikpak backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the backend command for more info on how to pass options and arguments. These can be run on a running backend using the rc command backend/command. addurl Add offline download task for url rclone backend addurl remote: [options] [+] This command adds offline download task for url. Usage: rclone backend addurl pikpak:dirpath url Downloads will be stored in 'dirpath'. If 'dirpath' is invalid, download will fallback to default 'My Pack' folder. decompress Request decompress of a file/files in a folder rclone backend decompress remote: [options] [+] This command requests decompress of file/files in a folder. Usage: rclone backend decompress pikpak:dirpath {filename} -o password=password rclone backend decompress pikpak:dirpath {filename} -o delete-src-file An optional argument 'filename' can be specified for a file located in 'pikpak:dirpath'. You may want to pass '-o password=password' for a password-protected files. Also, pass '-o delete-src-file' to delete source files after decompression finished. Result: { "Decompressed": 17, "SourceDeleted": 0, "Errors": 0 } Limitations Hashes may be empty PikPak supports MD5 hash, but sometimes given empty especially for user-uploaded files. Deleted files still visible with trashed-only Deleted files will still be visible with --pikpak-trashed-only even after the trash emptied. This goes away after few days. Pixeldrain This is the backend for Pixeldrain's premium filesystem feature. This is not the same as pixeldrain's free file sharing product. The filesystem requires either a Pro subscription or the Prepaid plan. More information on subscriptions. An overview of the filesystem's features and limitations is available in the filesystem guide on pixeldrain. Usage with account To use the personal filesystem you will need a pixeldrain account and either the Prepaid plan or one of the Patreon-based subscriptions. After registering and subscribing, your personal filesystem will be available at this link: https://pixeldrain.com/d/me. Go to the API keys page on your account and generate a new API key for rclone. Then run rclone config and use the API key to create a new backend. Example: No remotes found, make a new one? n) New remote d) Delete remote c) Copy remote s) Set configuration password q) Quit config n/d/c/s/q> n Enter name for new remote. name> pixeldrainfs Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. ... XX / Pixeldrain Filesystem \ (pixeldrain) ... Storage> pixeldrain Option api_key. API key for your pixeldrain account. Found on https://pixeldrain.com/user/api_keys. Enter a value. Press Enter to leave empty. api_key> b1bb1e81-9b7b-406b-986a-c9b20be76e15 Option directory_id. Root of the filesystem to use. Set to 'me' to use your personal filesystem. Set to a shared directory ID to use a shared directory. Enter a string value. Press Enter for the default (me). directory_id> Edit advanced config? y) Yes n) No (default) y/n> Configuration complete. Options: - type: pixeldrain - api_key: b1bb1e81-9b7b-406b-986a-c9b20be76e15 Keep this "pixeldrainfs" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> Current remotes: Name Type ==== ==== pixeldrainfs pixeldrain e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q Usage without account It is possible to gain read-only access to publicly shared directories through rclone. For this you only need a directory ID. The directory ID can be found in the URL of a shared directory, the URL will look like this https://pixeldrain.com/d/abcd1234 where abcd1234 is the directory ID. Directory IDs in your own filesystem can also be listed with the lsf command: rclone lsf Pixeldrain: --dirs-only -Fpi This will print directories in your Pixeldrain home directory and their public IDs. Enter this directory ID in the rclone config and you will be able to access the directory. Standard options Here are the Standard options specific to pixeldrain (Pixeldrain Filesystem). --pixeldrain-api-key API key for your pixeldrain account. Found on https://pixeldrain.com/user/api_keys. Properties: - Config: api_key - Env Var: RCLONE_PIXELDRAIN_API_KEY - Type: string - Required: false --pixeldrain-root-folder-id Root of the filesystem to use. Set to 'me' to use your personal filesystem. Set to a shared directory ID to use a shared directory. Properties: - Config: root_folder_id - Env Var: RCLONE_PIXELDRAIN_ROOT_FOLDER_ID - Type: string - Default: "me" Advanced options Here are the Advanced options specific to pixeldrain (Pixeldrain Filesystem). --pixeldrain-api-url The API endpoint to connect to. In the vast majority of cases it's fine to leave this at default. It is only intended to be changed for testing purposes. Properties: - Config: api_url - Env Var: RCLONE_PIXELDRAIN_API_URL - Type: string - Default: "https://pixeldrain.com/api" --pixeldrain-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PIXELDRAIN_DESCRIPTION - Type: string - Required: false Metadata Pixeldrain supports file modes and creation times. Here are the possible system metadata items for the pixeldrain backend. ------------------------------------------------------------------------------------------------- Name Help Type Example Read Only ----------- -------------- ----------- ------------------------------------- -------------------- btime Time of file RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N birth (creation) mode File mode octal, unix 755 N style mtime Time of last RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N modification ------------------------------------------------------------------------------------------------- See the metadata docs for more info. premiumize.me Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. Configuration The initial setup for premiumize.me involves getting a token from premiumize.me which you need to do in your browser. rclone config walks you through it. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / premiumize.me \ "premiumizeme" [snip] Storage> premiumizeme ** See help for premiumizeme backend at: https://rclone.org/premiumizeme/ ** Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: premiumizeme - token: {"access_token":"XXX","token_type":"Bearer","refresh_token":"XXX","expiry":"2029-08-07T18:44:15.548915378+01:00"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> See the remote setup docs for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from premiumize.me. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall. Once configured you can then use rclone like this, List directories in top level of your premiumize.me rclone lsd remote: List all the files in your premiumize.me rclone ls remote: To copy a local directory to an premiumize.me directory called backup rclone copy /home/source remote:backup Modification times and hashes premiumize.me does not support modification times or hashes, therefore syncing will default to --size-only checking. Note that using --update will work. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- \ 0x5C ＼ " 0x22 ＂ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Standard options Here are the Standard options specific to premiumizeme (premiumize.me). --premiumizeme-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_PREMIUMIZEME_CLIENT_ID - Type: string - Required: false --premiumizeme-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_PREMIUMIZEME_CLIENT_SECRET - Type: string - Required: false --premiumizeme-api-key API Key. This is not normally used - use oauth instead. Properties: - Config: api_key - Env Var: RCLONE_PREMIUMIZEME_API_KEY - Type: string - Required: false Advanced options Here are the Advanced options specific to premiumizeme (premiumize.me). --premiumizeme-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_PREMIUMIZEME_TOKEN - Type: string - Required: false --premiumizeme-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_PREMIUMIZEME_AUTH_URL - Type: string - Required: false --premiumizeme-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_PREMIUMIZEME_TOKEN_URL - Type: string - Required: false --premiumizeme-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_PREMIUMIZEME_CLIENT_CREDENTIALS - Type: bool - Default: false --premiumizeme-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_PREMIUMIZEME_ENCODING - Type: Encoding - Default: Slash,DoubleQuote,BackSlash,Del,Ctl,InvalidUtf8,Dot --premiumizeme-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PREMIUMIZEME_DESCRIPTION - Type: string - Required: false Limitations Note that premiumize.me is case insensitive so you can't have a file called "Hello.doc" and one called "hello.doc". premiumize.me file names can't have the \ or " characters in. rclone maps these to and from an identical looking unicode equivalents ＼ and ＂ premiumize.me only supports filenames up to 255 characters in length. Proton Drive Proton Drive is an end-to-end encrypted Swiss vault for your files that protects your data. This is an rclone backend for Proton Drive which supports the file transfer features of Proton Drive using the same client-side encryption. Due to the fact that Proton Drive doesn't publish its API documentation, this backend is implemented with best efforts by reading the open-sourced client source code and observing the Proton Drive traffic in the browser. NB This backend is currently in Beta. It is believed to be correct and all the integration tests pass. However the Proton Drive protocol has evolved over time there may be accounts it is not compatible with. Please post on the rclone forum if you find an incompatibility. Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. Configurations Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Proton Drive \ "protondrive" [snip] Storage> protondrive User name user> you@protonmail.com Password. y) Yes type in my own password g) Generate random password n) No leave this optional password blank y/g/n> y Enter the password: password: Confirm the password: password: Option 2fa. 2FA code (if the account requires one) Enter a value. Press Enter to leave empty. 2fa> 123456 Remote config Configuration complete. Options: - type: protondrive - user: you@protonmail.com - pass: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y NOTE: The Proton Drive encryption keys need to have been already generated after a regular login via the browser, otherwise attempting to use the credentials in rclone will fail. Once configured you can then use rclone like this, List directories in top level of your Proton Drive rclone lsd remote: List all the files in your Proton Drive rclone ls remote: To copy a local directory to an Proton Drive directory called backup rclone copy /home/source remote:backup Modification times and hashes Proton Drive Bridge does not support updating modification times yet. The SHA1 hash algorithm is supported. Restricted filename characters Invalid UTF-8 bytes will be replaced, also left and right spaces will be removed (code reference) Duplicated files Proton Drive can not have two files with exactly the same name and path. If the conflict occurs, depending on the advanced config, the file might or might not be overwritten. Mailbox password Please set your mailbox password in the advanced config section. Caching The cache is currently built for the case when the rclone is the only instance performing operations to the mount point. The event system, which is the proton API system that provides visibility of what has changed on the drive, is yet to be implemented, so updates from other clients won’t be reflected in the cache. Thus, if there are concurrent clients accessing the same mount point, then we might have a problem with caching the stale data. Standard options Here are the Standard options specific to protondrive (Proton Drive). --protondrive-username The username of your proton account Properties: - Config: username - Env Var: RCLONE_PROTONDRIVE_USERNAME - Type: string - Required: true --protondrive-password The password of your proton account. NB Input to this must be obscured - see rclone obscure. Properties: - Config: password - Env Var: RCLONE_PROTONDRIVE_PASSWORD - Type: string - Required: true --protondrive-2fa The 2FA code The value can also be provided with --protondrive-2fa=000000 The 2FA code of your proton drive account if the account is set up with two-factor authentication Properties: - Config: 2fa - Env Var: RCLONE_PROTONDRIVE_2FA - Type: string - Required: false Advanced options Here are the Advanced options specific to protondrive (Proton Drive). --protondrive-mailbox-password The mailbox password of your two-password proton account. For more information regarding the mailbox password, please check the following official knowledge base article: https://proton.me/support/the-difference-between-the-mailbox-password-and-login-password NB Input to this must be obscured - see rclone obscure. Properties: - Config: mailbox_password - Env Var: RCLONE_PROTONDRIVE_MAILBOX_PASSWORD - Type: string - Required: false --protondrive-client-uid Client uid key (internal use only) Properties: - Config: client_uid - Env Var: RCLONE_PROTONDRIVE_CLIENT_UID - Type: string - Required: false --protondrive-client-access-token Client access token key (internal use only) Properties: - Config: client_access_token - Env Var: RCLONE_PROTONDRIVE_CLIENT_ACCESS_TOKEN - Type: string - Required: false --protondrive-client-refresh-token Client refresh token key (internal use only) Properties: - Config: client_refresh_token - Env Var: RCLONE_PROTONDRIVE_CLIENT_REFRESH_TOKEN - Type: string - Required: false --protondrive-client-salted-key-pass Client salted key pass key (internal use only) Properties: - Config: client_salted_key_pass - Env Var: RCLONE_PROTONDRIVE_CLIENT_SALTED_KEY_PASS - Type: string - Required: false --protondrive-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_PROTONDRIVE_ENCODING - Type: Encoding - Default: Slash,LeftSpace,RightSpace,InvalidUtf8,Dot --protondrive-original-file-size Return the file size before encryption The size of the encrypted file will be different from (bigger than) the original file size. Unless there is a reason to return the file size after encryption is performed, otherwise, set this option to true, as features like Open() which will need to be supplied with original content size, will fail to operate properly Properties: - Config: original_file_size - Env Var: RCLONE_PROTONDRIVE_ORIGINAL_FILE_SIZE - Type: bool - Default: true --protondrive-app-version The app version string The app version string indicates the client that is currently performing the API request. This information is required and will be sent with every API request. Properties: - Config: app_version - Env Var: RCLONE_PROTONDRIVE_APP_VERSION - Type: string - Default: "macos-drive@1.0.0-alpha.1+rclone" --protondrive-replace-existing-draft Create a new revision when filename conflict is detected When a file upload is cancelled or failed before completion, a draft will be created and the subsequent upload of the same file to the same location will be reported as a conflict. The value can also be set by --protondrive-replace-existing-draft=true If the option is set to true, the draft will be replaced and then the upload operation will restart. If there are other clients also uploading at the same file location at the same time, the behavior is currently unknown. Need to set to true for integration tests. If the option is set to false, an error "a draft exist - usually this means a file is being uploaded at another client, or, there was a failed upload attempt" will be returned, and no upload will happen. Properties: - Config: replace_existing_draft - Env Var: RCLONE_PROTONDRIVE_REPLACE_EXISTING_DRAFT - Type: bool - Default: false --protondrive-enable-caching Caches the files and folders metadata to reduce API calls Notice: If you are mounting ProtonDrive as a VFS, please disable this feature, as the current implementation doesn't update or clear the cache when there are external changes. The files and folders on ProtonDrive are represented as links with keyrings, which can be cached to improve performance and be friendly to the API server. The cache is currently built for the case when the rclone is the only instance performing operations to the mount point. The event system, which is the proton API system that provides visibility of what has changed on the drive, is yet to be implemented, so updates from other clients won’t be reflected in the cache. Thus, if there are concurrent clients accessing the same mount point, then we might have a problem with caching the stale data. Properties: - Config: enable_caching - Env Var: RCLONE_PROTONDRIVE_ENABLE_CACHING - Type: bool - Default: true --protondrive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PROTONDRIVE_DESCRIPTION - Type: string - Required: false Limitations This backend uses the Proton-API-Bridge, which is based on go-proton-api, a fork of the official repo. There is no official API documentation available from Proton Drive. But, thanks to Proton open sourcing proton-go-api and the web, iOS, and Android client codebases, we don't need to completely reverse engineer the APIs by observing the web client traffic! proton-go-api provides the basic building blocks of API calls and error handling, such as 429 exponential back-off, but it is pretty much just a barebone interface to the Proton API. For example, the encryption and decryption of the Proton Drive file are not provided in this library. The Proton-API-Bridge, attempts to bridge the gap, so rclone can be built on top of this quickly. This codebase handles the intricate tasks before and after calling Proton APIs, particularly the complex encryption scheme, allowing developers to implement features for other software on top of this codebase. There are likely quite a few errors in this library, as there isn't official documentation available. put.io Paths are specified as remote:path put.io paths may be as deep as required, e.g. remote:directory/subdirectory. Configuration The initial setup for put.io involves getting a token from put.io which you need to do in your browser. rclone config walks you through it. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> putio Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Put.io \ "putio" [snip] Storage> putio ** See help for putio backend at: https://rclone.org/putio/ ** Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code -------------------- [putio] type = putio token = {"access_token":"XXXXXXXX","expiry":"0001-01-01T00:00:00Z"} -------------------- y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== putio putio e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q See the remote setup docs for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from put.io if using web browser to automatically authenticate. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall, or use manual mode. You can then use it like this, List directories in top level of your put.io rclone lsd remote: List all the files in your put.io rclone ls remote: To copy a local directory to a put.io directory called backup rclone copy /home/source remote:backup Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- \ 0x5C ＼ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Standard options Here are the Standard options specific to putio (Put.io). --putio-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_PUTIO_CLIENT_ID - Type: string - Required: false --putio-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_PUTIO_CLIENT_SECRET - Type: string - Required: false Advanced options Here are the Advanced options specific to putio (Put.io). --putio-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_PUTIO_TOKEN - Type: string - Required: false --putio-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_PUTIO_AUTH_URL - Type: string - Required: false --putio-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_PUTIO_TOKEN_URL - Type: string - Required: false --putio-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_PUTIO_CLIENT_CREDENTIALS - Type: bool - Default: false --putio-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_PUTIO_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot --putio-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PUTIO_DESCRIPTION - Type: string - Required: false Limitations put.io has rate limiting. When you hit a limit, rclone automatically retries after waiting the amount of time requested by the server. If you want to avoid ever hitting these limits, you may use the --tpslimit flag with a low number. Note that the imposed limits may be different for different operations, and may change over time. Proton Drive Proton Drive is an end-to-end encrypted Swiss vault for your files that protects your data. This is an rclone backend for Proton Drive which supports the file transfer features of Proton Drive using the same client-side encryption. Due to the fact that Proton Drive doesn't publish its API documentation, this backend is implemented with best efforts by reading the open-sourced client source code and observing the Proton Drive traffic in the browser. NB This backend is currently in Beta. It is believed to be correct and all the integration tests pass. However the Proton Drive protocol has evolved over time there may be accounts it is not compatible with. Please post on the rclone forum if you find an incompatibility. Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. Configurations Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Proton Drive \ "protondrive" [snip] Storage> protondrive User name user> you@protonmail.com Password. y) Yes type in my own password g) Generate random password n) No leave this optional password blank y/g/n> y Enter the password: password: Confirm the password: password: Option 2fa. 2FA code (if the account requires one) Enter a value. Press Enter to leave empty. 2fa> 123456 Remote config Configuration complete. Options: - type: protondrive - user: you@protonmail.com - pass: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y NOTE: The Proton Drive encryption keys need to have been already generated after a regular login via the browser, otherwise attempting to use the credentials in rclone will fail. Once configured you can then use rclone like this, List directories in top level of your Proton Drive rclone lsd remote: List all the files in your Proton Drive rclone ls remote: To copy a local directory to an Proton Drive directory called backup rclone copy /home/source remote:backup Modification times and hashes Proton Drive Bridge does not support updating modification times yet. The SHA1 hash algorithm is supported. Restricted filename characters Invalid UTF-8 bytes will be replaced, also left and right spaces will be removed (code reference) Duplicated files Proton Drive can not have two files with exactly the same name and path. If the conflict occurs, depending on the advanced config, the file might or might not be overwritten. Mailbox password Please set your mailbox password in the advanced config section. Caching The cache is currently built for the case when the rclone is the only instance performing operations to the mount point. The event system, which is the proton API system that provides visibility of what has changed on the drive, is yet to be implemented, so updates from other clients won’t be reflected in the cache. Thus, if there are concurrent clients accessing the same mount point, then we might have a problem with caching the stale data. Standard options Here are the Standard options specific to protondrive (Proton Drive). --protondrive-username The username of your proton account Properties: - Config: username - Env Var: RCLONE_PROTONDRIVE_USERNAME - Type: string - Required: true --protondrive-password The password of your proton account. NB Input to this must be obscured - see rclone obscure. Properties: - Config: password - Env Var: RCLONE_PROTONDRIVE_PASSWORD - Type: string - Required: true --protondrive-2fa The 2FA code The value can also be provided with --protondrive-2fa=000000 The 2FA code of your proton drive account if the account is set up with two-factor authentication Properties: - Config: 2fa - Env Var: RCLONE_PROTONDRIVE_2FA - Type: string - Required: false Advanced options Here are the Advanced options specific to protondrive (Proton Drive). --protondrive-mailbox-password The mailbox password of your two-password proton account. For more information regarding the mailbox password, please check the following official knowledge base article: https://proton.me/support/the-difference-between-the-mailbox-password-and-login-password NB Input to this must be obscured - see rclone obscure. Properties: - Config: mailbox_password - Env Var: RCLONE_PROTONDRIVE_MAILBOX_PASSWORD - Type: string - Required: false --protondrive-client-uid Client uid key (internal use only) Properties: - Config: client_uid - Env Var: RCLONE_PROTONDRIVE_CLIENT_UID - Type: string - Required: false --protondrive-client-access-token Client access token key (internal use only) Properties: - Config: client_access_token - Env Var: RCLONE_PROTONDRIVE_CLIENT_ACCESS_TOKEN - Type: string - Required: false --protondrive-client-refresh-token Client refresh token key (internal use only) Properties: - Config: client_refresh_token - Env Var: RCLONE_PROTONDRIVE_CLIENT_REFRESH_TOKEN - Type: string - Required: false --protondrive-client-salted-key-pass Client salted key pass key (internal use only) Properties: - Config: client_salted_key_pass - Env Var: RCLONE_PROTONDRIVE_CLIENT_SALTED_KEY_PASS - Type: string - Required: false --protondrive-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_PROTONDRIVE_ENCODING - Type: Encoding - Default: Slash,LeftSpace,RightSpace,InvalidUtf8,Dot --protondrive-original-file-size Return the file size before encryption The size of the encrypted file will be different from (bigger than) the original file size. Unless there is a reason to return the file size after encryption is performed, otherwise, set this option to true, as features like Open() which will need to be supplied with original content size, will fail to operate properly Properties: - Config: original_file_size - Env Var: RCLONE_PROTONDRIVE_ORIGINAL_FILE_SIZE - Type: bool - Default: true --protondrive-app-version The app version string The app version string indicates the client that is currently performing the API request. This information is required and will be sent with every API request. Properties: - Config: app_version - Env Var: RCLONE_PROTONDRIVE_APP_VERSION - Type: string - Default: "macos-drive@1.0.0-alpha.1+rclone" --protondrive-replace-existing-draft Create a new revision when filename conflict is detected When a file upload is cancelled or failed before completion, a draft will be created and the subsequent upload of the same file to the same location will be reported as a conflict. The value can also be set by --protondrive-replace-existing-draft=true If the option is set to true, the draft will be replaced and then the upload operation will restart. If there are other clients also uploading at the same file location at the same time, the behavior is currently unknown. Need to set to true for integration tests. If the option is set to false, an error "a draft exist - usually this means a file is being uploaded at another client, or, there was a failed upload attempt" will be returned, and no upload will happen. Properties: - Config: replace_existing_draft - Env Var: RCLONE_PROTONDRIVE_REPLACE_EXISTING_DRAFT - Type: bool - Default: false --protondrive-enable-caching Caches the files and folders metadata to reduce API calls Notice: If you are mounting ProtonDrive as a VFS, please disable this feature, as the current implementation doesn't update or clear the cache when there are external changes. The files and folders on ProtonDrive are represented as links with keyrings, which can be cached to improve performance and be friendly to the API server. The cache is currently built for the case when the rclone is the only instance performing operations to the mount point. The event system, which is the proton API system that provides visibility of what has changed on the drive, is yet to be implemented, so updates from other clients won’t be reflected in the cache. Thus, if there are concurrent clients accessing the same mount point, then we might have a problem with caching the stale data. Properties: - Config: enable_caching - Env Var: RCLONE_PROTONDRIVE_ENABLE_CACHING - Type: bool - Default: true --protondrive-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_PROTONDRIVE_DESCRIPTION - Type: string - Required: false Limitations This backend uses the Proton-API-Bridge, which is based on go-proton-api, a fork of the official repo. There is no official API documentation available from Proton Drive. But, thanks to Proton open sourcing proton-go-api and the web, iOS, and Android client codebases, we don't need to completely reverse engineer the APIs by observing the web client traffic! proton-go-api provides the basic building blocks of API calls and error handling, such as 429 exponential back-off, but it is pretty much just a barebone interface to the Proton API. For example, the encryption and decryption of the Proton Drive file are not provided in this library. The Proton-API-Bridge, attempts to bridge the gap, so rclone can be built on top of this quickly. This codebase handles the intricate tasks before and after calling Proton APIs, particularly the complex encryption scheme, allowing developers to implement features for other software on top of this codebase. There are likely quite a few errors in this library, as there isn't official documentation available. Seafile This is a backend for the Seafile storage service: - It works with both the free community edition or the professional edition. - Seafile versions 6.x, 7.x, 8.x and 9.x are all supported. - Encrypted libraries are also supported. - It supports 2FA enabled users - Using a Library API Token is not supported Configuration There are two distinct modes you can setup your remote: - you point your remote to the root of the server, meaning you don't specify a library during the configuration: Paths are specified as remote:library. You may put subdirectories in too, e.g. remote:library/path/to/dir. - you point your remote to a specific library during the configuration: Paths are specified as remote:path/to/dir. This is the recommended mode when using encrypted libraries. (This mode is possibly slightly faster than the root mode) Configuration in root mode Here is an example of making a seafile configuration for a user with no two-factor authentication. First run rclone config This will guide you through an interactive setup process. To authenticate you will need the URL of your server, your email (or username) and your password. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> seafile Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Seafile \ "seafile" [snip] Storage> seafile ** See help for seafile backend at: https://rclone.org/seafile/ ** URL of seafile host to connect to Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Connect to cloud.seafile.com \ "https://cloud.seafile.com/" url> http://my.seafile.server/ User name (usually email address) Enter a string value. Press Enter for the default (""). user> me@example.com Password y) Yes type in my own password g) Generate random password n) No leave this optional password blank (default) y/g> y Enter the password: password: Confirm the password: password: Two-factor authentication ('true' if the account has 2FA enabled) Enter a boolean value (true or false). Press Enter for the default ("false"). 2fa> false Name of the library. Leave blank to access all non-encrypted libraries. Enter a string value. Press Enter for the default (""). library> Library password (for encrypted libraries only). Leave blank if you pass it through the command line. y) Yes type in my own password g) Generate random password n) No leave this optional password blank (default) y/g/n> n Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config Two-factor authentication is not enabled on this account. -------------------- [seafile] type = seafile url = http://my.seafile.server/ user = me@example.com pass = *** ENCRYPTED *** 2fa = false -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y This remote is called seafile. It's pointing to the root of your seafile server and can now be used like this: See all libraries rclone lsd seafile: Create a new library rclone mkdir seafile:library List the contents of a library rclone ls seafile:library Sync /home/local/directory to the remote library, deleting any excess files in the library. rclone sync --interactive /home/local/directory seafile:library Configuration in library mode Here's an example of a configuration in library mode with a user that has the two-factor authentication enabled. Your 2FA code will be asked at the end of the configuration, and will attempt to authenticate you: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> seafile Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Seafile \ "seafile" [snip] Storage> seafile ** See help for seafile backend at: https://rclone.org/seafile/ ** URL of seafile host to connect to Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value 1 / Connect to cloud.seafile.com \ "https://cloud.seafile.com/" url> http://my.seafile.server/ User name (usually email address) Enter a string value. Press Enter for the default (""). user> me@example.com Password y) Yes type in my own password g) Generate random password n) No leave this optional password blank (default) y/g> y Enter the password: password: Confirm the password: password: Two-factor authentication ('true' if the account has 2FA enabled) Enter a boolean value (true or false). Press Enter for the default ("false"). 2fa> true Name of the library. Leave blank to access all non-encrypted libraries. Enter a string value. Press Enter for the default (""). library> My Library Library password (for encrypted libraries only). Leave blank if you pass it through the command line. y) Yes type in my own password g) Generate random password n) No leave this optional password blank (default) y/g/n> n Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config Two-factor authentication: please enter your 2FA code 2fa code> 123456 Authenticating... Success! -------------------- [seafile] type = seafile url = http://my.seafile.server/ user = me@example.com pass = 2fa = true library = My Library -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y You'll notice your password is blank in the configuration. It's because we only need the password to authenticate you once. You specified My Library during the configuration. The root of the remote is pointing at the root of the library My Library: See all files in the library: rclone lsd seafile: Create a new directory inside the library rclone mkdir seafile:directory List the contents of a directory rclone ls seafile:directory Sync /home/local/directory to the remote library, deleting any excess files in the library. rclone sync --interactive /home/local/directory seafile: --fast-list Seafile version 7+ supports --fast-list which allows you to use fewer transactions in exchange for more memory. See the rclone docs for more details. Please note this is not supported on seafile server version 6.x Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- / 0x2F ／ " 0x22 ＂ \ 0x5C ＼ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Seafile and rclone link Rclone supports generating share links for non-encrypted libraries only. They can either be for a file or a directory: rclone link seafile:seafile-tutorial.doc http://my.seafile.server/f/fdcd8a2f93f84b8b90f4/ or if run on a directory you will get: rclone link seafile:dir http://my.seafile.server/d/9ea2455f6f55478bbb0d/ Please note a share link is unique for each file or directory. If you run a link command on a file/dir that has already been shared, you will get the exact same link. Compatibility It has been actively developed using the seafile docker image of these versions: - 6.3.4 community edition - 7.0.5 community edition - 7.1.3 community edition - 9.0.10 community edition Versions below 6.0 are not supported. Versions between 6.0 and 6.3 haven't been tested and might not work properly. Each new version of rclone is automatically tested against the latest docker image of the seafile community server. Standard options Here are the Standard options specific to seafile (seafile). --seafile-url URL of seafile host to connect to. Properties: - Config: url - Env Var: RCLONE_SEAFILE_URL - Type: string - Required: true - Examples: - "https://cloud.seafile.com/" - Connect to cloud.seafile.com. --seafile-user User name (usually email address). Properties: - Config: user - Env Var: RCLONE_SEAFILE_USER - Type: string - Required: true --seafile-pass Password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: pass - Env Var: RCLONE_SEAFILE_PASS - Type: string - Required: false --seafile-2fa Two-factor authentication ('true' if the account has 2FA enabled). Properties: - Config: 2fa - Env Var: RCLONE_SEAFILE_2FA - Type: bool - Default: false --seafile-library Name of the library. Leave blank to access all non-encrypted libraries. Properties: - Config: library - Env Var: RCLONE_SEAFILE_LIBRARY - Type: string - Required: false --seafile-library-key Library password (for encrypted libraries only). Leave blank if you pass it through the command line. NB Input to this must be obscured - see rclone obscure. Properties: - Config: library_key - Env Var: RCLONE_SEAFILE_LIBRARY_KEY - Type: string - Required: false --seafile-auth-token Authentication token. Properties: - Config: auth_token - Env Var: RCLONE_SEAFILE_AUTH_TOKEN - Type: string - Required: false Advanced options Here are the Advanced options specific to seafile (seafile). --seafile-create-library Should rclone create a library if it doesn't exist. Properties: - Config: create_library - Env Var: RCLONE_SEAFILE_CREATE_LIBRARY - Type: bool - Default: false --seafile-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_SEAFILE_ENCODING - Type: Encoding - Default: Slash,DoubleQuote,BackSlash,Ctl,InvalidUtf8,Dot --seafile-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SEAFILE_DESCRIPTION - Type: string - Required: false SFTP SFTP is the Secure (or SSH) File Transfer Protocol. The SFTP backend can be used with a number of different providers: - Hetzner Storage Box - rsync.net SFTP runs over SSH v2 and is installed as standard with most modern SSH installations. Paths are specified as remote:path. If the path does not begin with a / it is relative to the home directory of the user. An empty path remote: refers to the user's home directory. For example, rclone lsd remote: would list the home directory of the user configured in the rclone remote config (i.e /home/sftpuser). However, rclone lsd remote:/ would list the root directory for remote machine (i.e. /) Note that some SFTP servers will need the leading / - Synology is a good example of this. rsync.net and Hetzner, on the other hand, requires users to OMIT the leading /. Note that by default rclone will try to execute shell commands on the server, see shell access considerations. Configuration Here is an example of making an SFTP configuration. First run rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / SSH/SFTP \ "sftp" [snip] Storage> sftp SSH host to connect to Choose a number from below, or type in your own value 1 / Connect to example.com \ "example.com" host> example.com SSH username Enter a string value. Press Enter for the default ("$USER"). user> sftpuser SSH port number Enter a signed integer. Press Enter for the default (22). port> SSH password, leave blank to use ssh-agent. y) Yes type in my own password g) Generate random password n) No leave this optional password blank y/g/n> n Path to unencrypted PEM-encoded private key file, leave blank to use ssh-agent. key_file> Remote config Configuration complete. Options: - type: sftp - host: example.com - user: sftpuser - port: - pass: - key_file: Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y This remote is called remote and can now be used like this: See all directories in the home directory rclone lsd remote: See all directories in the root directory rclone lsd remote:/ Make a new directory rclone mkdir remote:path/to/directory List the contents of a directory rclone ls remote:path/to/directory Sync /home/local/directory to the remote directory, deleting any excess files in the directory. rclone sync --interactive /home/local/directory remote:directory Mount the remote path /srv/www-data/ to the local path /mnt/www-data rclone mount remote:/srv/www-data/ /mnt/www-data SSH Authentication The SFTP remote supports three authentication methods: - Password - Key file, including certificate signed keys - ssh-agent Key files should be PEM-encoded private key files. For instance /home/$USER/.ssh/id_rsa. Only unencrypted OpenSSH or PEM encrypted files are supported. The key file can be specified in either an external file (key_file) or contained within the rclone config file (key_pem). If using key_pem in the config file, the entry should be on a single line with new line ('' or '') separating lines. i.e. key_pem = -----BEGIN RSA PRIVATE KEY-----\nMaMbaIXtE\n0gAMbMbaSsd\nMbaass\n-----END RSA PRIVATE KEY----- This will generate it correctly for key_pem for use in the config: awk '{printf "%s\\n", $0}' < ~/.ssh/id_rsa If you don't specify pass, key_file, or key_pem or ask_password then rclone will attempt to contact an ssh-agent. You can also specify key_use_agent to force the usage of an ssh-agent. In this case key_file or key_pem can also be specified to force the usage of a specific key in the ssh-agent. Using an ssh-agent is the only way to load encrypted OpenSSH keys at the moment. If you set the ask_password option, rclone will prompt for a password when needed and no password has been configured. Certificate-signed keys With traditional key-based authentication, you configure your private key only, and the public key built into it will be used during the authentication process. If you have a certificate you may use it to sign your public key, creating a separate SSH user certificate that should be used instead of the plain public key extracted from the private key. Then you must provide the path to the user certificate public key file in pubkey_file or the content of the file in pubkey. Note: This is not the traditional public key paired with your private key, typically saved as /home/$USER/.ssh/id_rsa.pub. Setting this path in pubkey_file will not work. Example: [remote] type = sftp host = example.com user = sftpuser key_file = ~/id_rsa pubkey_file = ~/id_rsa-cert.pub If you concatenate a cert with a private key then you can specify the merged file in both places. Note: the cert must come first in the file. e.g. cat id_rsa-cert.pub id_rsa > merged_key Host key validation By default rclone will not check the server's host key for validation. This can allow an attacker to replace a server with their own and if you use password authentication then this can lead to that password being exposed. Host key matching, using standard known_hosts files can be turned on by enabling the known_hosts_file option. This can point to the file maintained by OpenSSH or can point to a unique file. e.g. using the OpenSSH known_hosts file: [remote] type = sftp host = example.com user = sftpuser pass = known_hosts_file = ~/.ssh/known_hosts Alternatively you can create your own known hosts file like this: ssh-keyscan -t dsa,rsa,ecdsa,ed25519 example.com >> known_hosts There are some limitations: - rclone will not manage this file for you. If the key is missing or wrong then the connection will be refused. - If the server is set up for a certificate host key then the entry in the known_hosts file must be the @cert-authority entry for the CA If the host key provided by the server does not match the one in the file (or is missing) then the connection will be aborted and an error returned such as NewFs: couldn't connect SSH: ssh: handshake failed: knownhosts: key mismatch or NewFs: couldn't connect SSH: ssh: handshake failed: knownhosts: key is unknown If you see an error such as NewFs: couldn't connect SSH: ssh: handshake failed: ssh: no authorities for hostname: example.com:22 then it is likely the server has presented a CA signed host certificate and you will need to add the appropriate @cert-authority entry. The known_hosts_file setting can be set during rclone config as an advanced option. ssh-agent on macOS Note that there seem to be various problems with using an ssh-agent on macOS due to recent changes in the OS. The most effective work-around seems to be to start an ssh-agent in each session, e.g. eval `ssh-agent -s` && ssh-add -A And then at the end of the session eval `ssh-agent -k` These commands can be used in scripts of course. Shell access Some functionality of the SFTP backend relies on remote shell access, and the possibility to execute commands. This includes checksum, and in some cases also about. The shell commands that must be executed may be different on different type of shells, and also quoting/escaping of file path arguments containing special characters may be different. Rclone therefore needs to know what type of shell it is, and if shell access is available at all. Most servers run on some version of Unix, and then a basic Unix shell can be assumed, without further distinction. Windows 10, Server 2019, and later can also run a SSH server, which is a port of OpenSSH (see official installation guide). On a Windows server the shell handling is different: Although it can also be set up to use a Unix type shell, e.g. Cygwin bash, the default is to use Windows Command Prompt (cmd.exe), and PowerShell is a recommended alternative. All of these have behave differently, which rclone must handle. Rclone tries to auto-detect what type of shell is used on the server, first time you access the SFTP remote. If a remote shell session is successfully created, it will look for indications that it is CMD or PowerShell, with fall-back to Unix if not something else is detected. If unable to even create a remote shell session, then shell command execution will be disabled entirely. The result is stored in the SFTP remote configuration, in option shell_type, so that the auto-detection only have to be performed once. If you manually set a value for this option before first run, the auto-detection will be skipped, and if you set a different value later this will override any existing. Value none can be set to avoid any attempts at executing shell commands, e.g. if this is not allowed on the server. If you have shell_type = none in the configuration then the ssh must not be set. When the server is rclone serve sftp, the rclone SFTP remote will detect this as a Unix type shell - even if it is running on Windows. This server does not actually have a shell, but it accepts input commands matching the specific ones that the SFTP backend relies on for Unix shells, e.g. md5sum and df. Also it handles the string escape rules used for Unix shell. Treating it as a Unix type shell from a SFTP remote will therefore always be correct, and support all features. Shell access considerations The shell type auto-detection logic, described above, means that by default rclone will try to run a shell command the first time a new sftp remote is accessed. If you configure a sftp remote without a config file, e.g. an on the fly remote, rclone will have nowhere to store the result, and it will re-run the command on every access. To avoid this you should explicitly set the shell_type option to the correct value, or to none if you want to prevent rclone from executing any remote shell commands. It is also important to note that, since the shell type decides how quoting and escaping of file paths used as command-line arguments are performed, configuring the wrong shell type may leave you exposed to command injection exploits. Make sure to confirm the auto-detected shell type, or explicitly set the shell type you know is correct, or disable shell access until you know. Checksum SFTP does not natively support checksums (file hash), but rclone is able to use checksumming if the same login has shell access, and can execute remote commands. If there is a command that can calculate compatible checksums on the remote system, Rclone can then be configured to execute this whenever a checksum is needed, and read back the results. By default MD5 and SHA-1 are considered, but also CRC32, SHA-256, BLAKE3, XXH3 and XXH128 are supported, option hashes can be set to specify which to consider. Normally this requires an external utility being available on the server. E.g. for MD5 checksums, by default rclone will try commands md5sum, md5 and rclone md5sum, and the first one found usable will be picked. These utilities normally need to be in the remote's PATH to be found. In some cases the shell itself is capable of calculating checksums. PowerShell is an example of such a shell. If rclone detects that the remote shell is PowerShell, which means it most probably is a Windows OpenSSH server, rclone will use a predefined script block to produce the checksums for MD5, SHA-1 and SHA-256 when no external checksum commands are found (see shell access). This assumes PowerShell version 4.0 or newer. The options md5sum_command, sha1_command, etc. can be used to customize the commands to be executed for calculation of checksums. You can for example set a specific path to where the md5sum executable are located, or specify some other tool that print checksums in compatible format. The value can include command-line arguments, or even shell script blocks as with PowerShell. Rclone has subcommands hashsum, md5sum and sha1sum that use compatible format, which means if you have an rclone executable on the server it can be used. As mentioned above, they will be automatically picked up if found in PATH, but if not you can set something like /path/to/rclone md5sum as the value of option md5sum_command to make sure a specific executable is used. Remote checksumming is recommended and enabled by default. First time rclone is using a SFTP remote, if options md5sum_command or sha1_command are not set, it will check if any of the default commands for each of them, as described above, can be used. The result will be saved in the remote configuration, so next time it will use the same. Value none will be set if none of the default commands could be used for a specific algorithm, and this algorithm will not be supported by the remote. Disabling the checksumming completely may be required if you are connecting to SFTP servers which are not under your control, and to which the execution of remote shell commands is prohibited. Set the configuration option disable_hashcheck to true to disable checksumming entirely (you get the same effect by setting option hashes to none or options md5sum_command, sha1_command etc. to none). Set option shell_type to none to not only disable checksumming, but also disable all other functionality that are based on remote shell command execution. Modification times and hashes Modified times are stored on the server to 1 second precision. Modified times are used in syncing and are fully supported. Some SFTP servers disable setting/modifying the file modification time after upload (for example, certain configurations of ProFTPd with mod_sftp). If you are using one of these servers, you can set the option set_modtime = false in your RClone backend configuration to disable this behaviour. About command The about command returns the total space, free space, and used space on the remote for the disk of the specified path on the remote or, if not set, the disk of the root on the remote. SFTP usually supports the about command, but it depends on the server. If the server implements the vendor-specific VFS statistics extension, which is normally the case with OpenSSH instances, it will be used. If not, but the same login has access to a Unix shell, where the df command is available (e.g. in the remote's PATH), then this will be used instead. If the server shell is PowerShell, probably with a Windows OpenSSH server, rclone will use a built-in shell command (see shell access). If none of the above is applicable, about will fail. Standard options Here are the Standard options specific to sftp (SSH/SFTP). --sftp-host SSH host to connect to. E.g. "example.com". Properties: - Config: host - Env Var: RCLONE_SFTP_HOST - Type: string - Required: true --sftp-user SSH username. Properties: - Config: user - Env Var: RCLONE_SFTP_USER - Type: string - Default: "$USER" --sftp-port SSH port number. Properties: - Config: port - Env Var: RCLONE_SFTP_PORT - Type: int - Default: 22 --sftp-pass SSH password, leave blank to use ssh-agent. NB Input to this must be obscured - see rclone obscure. Properties: - Config: pass - Env Var: RCLONE_SFTP_PASS - Type: string - Required: false --sftp-key-pem Raw PEM-encoded private key. Note that this should be on a single line with line endings replaced with '', eg key_pem = -----BEGIN RSA PRIVATE KEY-----\nMaMbaIXtE\n0gAMbMbaSsd\nMbaass\n-----END RSA PRIVATE KEY----- This will generate the single line correctly: awk '{printf "%s\\n", $0}' < ~/.ssh/id_rsa If specified, it will override the key_file parameter. Properties: - Config: key_pem - Env Var: RCLONE_SFTP_KEY_PEM - Type: string - Required: false --sftp-key-file Path to PEM-encoded private key file. Leave blank or set key-use-agent to use ssh-agent. Leading ~ will be expanded in the file name as will environment variables such as ${RCLONE_CONFIG_DIR}. Properties: - Config: key_file - Env Var: RCLONE_SFTP_KEY_FILE - Type: string - Required: false --sftp-key-file-pass The passphrase to decrypt the PEM-encoded private key file. Only PEM encrypted key files (old OpenSSH format) are supported. Encrypted keys in the new OpenSSH format can't be used. NB Input to this must be obscured - see rclone obscure. Properties: - Config: key_file_pass - Env Var: RCLONE_SFTP_KEY_FILE_PASS - Type: string - Required: false --sftp-pubkey SSH public certificate for public certificate based authentication. Set this if you have a signed certificate you want to use for authentication. If specified will override pubkey_file. Properties: - Config: pubkey - Env Var: RCLONE_SFTP_PUBKEY - Type: string - Required: false --sftp-pubkey-file Optional path to public key file. Set this if you have a signed certificate you want to use for authentication. Leading ~ will be expanded in the file name as will environment variables such as ${RCLONE_CONFIG_DIR}. Properties: - Config: pubkey_file - Env Var: RCLONE_SFTP_PUBKEY_FILE - Type: string - Required: false --sftp-key-use-agent When set forces the usage of the ssh-agent. When key-file is also set, the ".pub" file of the specified key-file is read and only the associated key is requested from the ssh-agent. This allows to avoid Too many authentication failures for *username* errors when the ssh-agent contains many keys. Properties: - Config: key_use_agent - Env Var: RCLONE_SFTP_KEY_USE_AGENT - Type: bool - Default: false --sftp-use-insecure-cipher Enable the use of insecure ciphers and key exchange methods. This enables the use of the following insecure ciphers and key exchange methods: - aes128-cbc - aes192-cbc - aes256-cbc - 3des-cbc - diffie-hellman-group-exchange-sha256 - diffie-hellman-group-exchange-sha1 Those algorithms are insecure and may allow plaintext data to be recovered by an attacker. This must be false if you use either ciphers or key_exchange advanced options. Properties: - Config: use_insecure_cipher - Env Var: RCLONE_SFTP_USE_INSECURE_CIPHER - Type: bool - Default: false - Examples: - "false" - Use default Cipher list. - "true" - Enables the use of the aes128-cbc cipher and diffie-hellman-group-exchange-sha256, diffie-hellman-group-exchange-sha1 key exchange. --sftp-disable-hashcheck Disable the execution of SSH commands to determine if remote file hashing is available. Leave blank or set to false to enable hashing (recommended), set to true to disable hashing. Properties: - Config: disable_hashcheck - Env Var: RCLONE_SFTP_DISABLE_HASHCHECK - Type: bool - Default: false --sftp-ssh Path and arguments to external ssh binary. Normally rclone will use its internal ssh library to connect to the SFTP server. However it does not implement all possible ssh options so it may be desirable to use an external ssh binary. Rclone ignores all the internal config if you use this option and expects you to configure the ssh binary with the user/host/port and any other options you need. Important The ssh command must log in without asking for a password so needs to be configured with keys or certificates. Rclone will run the command supplied either with the additional arguments "-s sftp" to access the SFTP subsystem or with commands such as "md5sum /path/to/file" appended to read checksums. Any arguments with spaces in should be surrounded by "double quotes". An example setting might be: ssh -o ServerAliveInterval=20 user@example.com Note that when using an external ssh binary rclone makes a new ssh connection for every hash it calculates. Properties: - Config: ssh - Env Var: RCLONE_SFTP_SSH - Type: SpaceSepList - Default: Advanced options Here are the Advanced options specific to sftp (SSH/SFTP). --sftp-known-hosts-file Optional path to known_hosts file. Set this value to enable server host key validation. Leading ~ will be expanded in the file name as will environment variables such as ${RCLONE_CONFIG_DIR}. Properties: - Config: known_hosts_file - Env Var: RCLONE_SFTP_KNOWN_HOSTS_FILE - Type: string - Required: false - Examples: - "~/.ssh/known_hosts" - Use OpenSSH's known_hosts file. --sftp-ask-password Allow asking for SFTP password when needed. If this is set and no password is supplied then rclone will: - ask for a password - not contact the ssh agent Properties: - Config: ask_password - Env Var: RCLONE_SFTP_ASK_PASSWORD - Type: bool - Default: false --sftp-path-override Override path used by SSH shell commands. This allows checksum calculation when SFTP and SSH paths are different. This issue affects among others Synology NAS boxes. E.g. if shared folders can be found in directories representing volumes: rclone sync /home/local/directory remote:/directory --sftp-path-override /volume2/directory E.g. if home directory can be found in a shared folder called "home": rclone sync /home/local/directory remote:/home/directory --sftp-path-override /volume1/homes/USER/directory To specify only the path to the SFTP remote's root, and allow rclone to add any relative subpaths automatically (including unwrapping/decrypting remotes as necessary), add the '@' character to the beginning of the path. E.g. the first example above could be rewritten as: rclone sync /home/local/directory remote:/directory --sftp-path-override @/volume2 Note that when using this method with Synology "home" folders, the full "/homes/USER" path should be specified instead of "/home". E.g. the second example above should be rewritten as: rclone sync /home/local/directory remote:/homes/USER/directory --sftp-path-override @/volume1 Properties: - Config: path_override - Env Var: RCLONE_SFTP_PATH_OVERRIDE - Type: string - Required: false --sftp-set-modtime Set the modified time on the remote if set. Properties: - Config: set_modtime - Env Var: RCLONE_SFTP_SET_MODTIME - Type: bool - Default: true --sftp-shell-type The type of SSH shell on remote server, if any. Leave blank for autodetect. Properties: - Config: shell_type - Env Var: RCLONE_SFTP_SHELL_TYPE - Type: string - Required: false - Examples: - "none" - No shell access - "unix" - Unix shell - "powershell" - PowerShell - "cmd" - Windows Command Prompt --sftp-hashes Comma separated list of supported checksum types. Properties: - Config: hashes - Env Var: RCLONE_SFTP_HASHES - Type: CommaSepList - Default: --sftp-md5sum-command The command used to read MD5 hashes. Leave blank for autodetect. Properties: - Config: md5sum_command - Env Var: RCLONE_SFTP_MD5SUM_COMMAND - Type: string - Required: false --sftp-sha1sum-command The command used to read SHA-1 hashes. Leave blank for autodetect. Properties: - Config: sha1sum_command - Env Var: RCLONE_SFTP_SHA1SUM_COMMAND - Type: string - Required: false --sftp-crc32sum-command The command used to read CRC-32 hashes. Leave blank for autodetect. Properties: - Config: crc32sum_command - Env Var: RCLONE_SFTP_CRC32SUM_COMMAND - Type: string - Required: false --sftp-sha256sum-command The command used to read SHA-256 hashes. Leave blank for autodetect. Properties: - Config: sha256sum_command - Env Var: RCLONE_SFTP_SHA256SUM_COMMAND - Type: string - Required: false --sftp-blake3sum-command The command used to read BLAKE3 hashes. Leave blank for autodetect. Properties: - Config: blake3sum_command - Env Var: RCLONE_SFTP_BLAKE3SUM_COMMAND - Type: string - Required: false --sftp-xxh3sum-command The command used to read XXH3 hashes. Leave blank for autodetect. Properties: - Config: xxh3sum_command - Env Var: RCLONE_SFTP_XXH3SUM_COMMAND - Type: string - Required: false --sftp-xxh128sum-command The command used to read XXH128 hashes. Leave blank for autodetect. Properties: - Config: xxh128sum_command - Env Var: RCLONE_SFTP_XXH128SUM_COMMAND - Type: string - Required: false --sftp-skip-links Set to skip any symlinks and any other non regular files. Properties: - Config: skip_links - Env Var: RCLONE_SFTP_SKIP_LINKS - Type: bool - Default: false --sftp-subsystem Specifies the SSH2 subsystem on the remote host. Properties: - Config: subsystem - Env Var: RCLONE_SFTP_SUBSYSTEM - Type: string - Default: "sftp" --sftp-server-command Specifies the path or command to run a sftp server on the remote host. The subsystem option is ignored when server_command is defined. If adding server_command to the configuration file please note that it should not be enclosed in quotes, since that will make rclone fail. A working example is: [remote_name] type = sftp server_command = sudo /usr/libexec/openssh/sftp-server Properties: - Config: server_command - Env Var: RCLONE_SFTP_SERVER_COMMAND - Type: string - Required: false --sftp-use-fstat If set use fstat instead of stat. Some servers limit the amount of open files and calling Stat after opening the file will throw an error from the server. Setting this flag will call Fstat instead of Stat which is called on an already open file handle. It has been found that this helps with IBM Sterling SFTP servers which have "extractability" level set to 1 which means only 1 file can be opened at any given time. Properties: - Config: use_fstat - Env Var: RCLONE_SFTP_USE_FSTAT - Type: bool - Default: false --sftp-disable-concurrent-reads If set don't use concurrent reads. Normally concurrent reads are safe to use and not using them will degrade performance, so this option is disabled by default. Some servers limit the amount number of times a file can be downloaded. Using concurrent reads can trigger this limit, so if you have a server which returns Failed to copy: file does not exist Then you may need to enable this flag. If concurrent reads are disabled, the use_fstat option is ignored. Properties: - Config: disable_concurrent_reads - Env Var: RCLONE_SFTP_DISABLE_CONCURRENT_READS - Type: bool - Default: false --sftp-disable-concurrent-writes If set don't use concurrent writes. Normally rclone uses concurrent writes to upload files. This improves the performance greatly, especially for distant servers. This option disables concurrent writes should that be necessary. Properties: - Config: disable_concurrent_writes - Env Var: RCLONE_SFTP_DISABLE_CONCURRENT_WRITES - Type: bool - Default: false --sftp-idle-timeout Max time before closing idle connections. If no connections have been returned to the connection pool in the time given, rclone will empty the connection pool. Set to 0 to keep connections indefinitely. Properties: - Config: idle_timeout - Env Var: RCLONE_SFTP_IDLE_TIMEOUT - Type: Duration - Default: 1m0s --sftp-chunk-size Upload and download chunk size. This controls the maximum size of payload in SFTP protocol packets. The RFC limits this to 32768 bytes (32k), which is the default. However, a lot of servers support larger sizes, typically limited to a maximum total package size of 256k, and setting it larger will increase transfer speed dramatically on high latency links. This includes OpenSSH, and, for example, using the value of 255k works well, leaving plenty of room for overhead while still being within a total packet size of 256k. Make sure to test thoroughly before using a value higher than 32k, and only use it if you always connect to the same server or after sufficiently broad testing. If you get errors such as "failed to send packet payload: EOF", lots of "connection lost", or "corrupted on transfer", when copying a larger file, try lowering the value. The server run by rclone serve sftp sends packets with standard 32k maximum payload so you must not set a different chunk_size when downloading files, but it accepts packets up to the 256k total size, so for uploads the chunk_size can be set as for the OpenSSH example above. Properties: - Config: chunk_size - Env Var: RCLONE_SFTP_CHUNK_SIZE - Type: SizeSuffix - Default: 32Ki --sftp-concurrency The maximum number of outstanding requests for one file This controls the maximum number of outstanding requests for one file. Increasing it will increase throughput on high latency links at the cost of using more memory. Properties: - Config: concurrency - Env Var: RCLONE_SFTP_CONCURRENCY - Type: int - Default: 64 --sftp-connections Maximum number of SFTP simultaneous connections, 0 for unlimited. Note that setting this is very likely to cause deadlocks so it should be used with care. If you are doing a sync or copy then make sure connections is one more than the sum of --transfers and --checkers. If you use --check-first then it just needs to be one more than the maximum of --checkers and --transfers. So for connections 3 you'd use --checkers 2 --transfers 2 --check-first or --checkers 1 --transfers 1. Properties: - Config: connections - Env Var: RCLONE_SFTP_CONNECTIONS - Type: int - Default: 0 --sftp-set-env Environment variables to pass to sftp and commands Set environment variables in the form: VAR=value to be passed to the sftp client and to any commands run (eg md5sum). Pass multiple variables space separated, eg VAR1=value VAR2=value and pass variables with spaces in quotes, eg "VAR3=value with space" "VAR4=value with space" VAR5=nospacehere Properties: - Config: set_env - Env Var: RCLONE_SFTP_SET_ENV - Type: SpaceSepList - Default: --sftp-ciphers Space separated list of ciphers to be used for session encryption, ordered by preference. At least one must match with server configuration. This can be checked for example using ssh -Q cipher. This must not be set if use_insecure_cipher is true. Example: aes128-ctr aes192-ctr aes256-ctr aes128-gcm@openssh.com aes256-gcm@openssh.com Properties: - Config: ciphers - Env Var: RCLONE_SFTP_CIPHERS - Type: SpaceSepList - Default: --sftp-key-exchange Space separated list of key exchange algorithms, ordered by preference. At least one must match with server configuration. This can be checked for example using ssh -Q kex. This must not be set if use_insecure_cipher is true. Example: sntrup761x25519-sha512@openssh.com curve25519-sha256 curve25519-sha256@libssh.org ecdh-sha2-nistp256 Properties: - Config: key_exchange - Env Var: RCLONE_SFTP_KEY_EXCHANGE - Type: SpaceSepList - Default: --sftp-macs Space separated list of MACs (message authentication code) algorithms, ordered by preference. At least one must match with server configuration. This can be checked for example using ssh -Q mac. Example: umac-64-etm@openssh.com umac-128-etm@openssh.com hmac-sha2-256-etm@openssh.com Properties: - Config: macs - Env Var: RCLONE_SFTP_MACS - Type: SpaceSepList - Default: --sftp-host-key-algorithms Space separated list of host key algorithms, ordered by preference. At least one must match with server configuration. This can be checked for example using ssh -Q HostKeyAlgorithms. Note: This can affect the outcome of key negotiation with the server even if server host key validation is not enabled. Example: ssh-ed25519 ssh-rsa ssh-dss Properties: - Config: host_key_algorithms - Env Var: RCLONE_SFTP_HOST_KEY_ALGORITHMS - Type: SpaceSepList - Default: --sftp-socks-proxy Socks 5 proxy host. Supports the format user:pass@host:port, user@host:port, host:port. Example: myUser:myPass@localhost:9005 Properties: - Config: socks_proxy - Env Var: RCLONE_SFTP_SOCKS_PROXY - Type: string - Required: false --sftp-http-proxy URL for HTTP CONNECT proxy Set this to a URL for an HTTP proxy which supports the HTTP CONNECT verb. Properties: - Config: http_proxy - Env Var: RCLONE_SFTP_HTTP_PROXY - Type: string - Required: false --sftp-copy-is-hardlink Set to enable server side copies using hardlinks. The SFTP protocol does not define a copy command so normally server side copies are not allowed with the sftp backend. However the SFTP protocol does support hardlinking, and if you enable this flag then the sftp backend will support server side copies. These will be implemented by doing a hardlink from the source to the destination. Not all sftp servers support this. Note that hardlinking two files together will use no additional space as the source and the destination will be the same file. This feature may be useful backups made with --copy-dest. Properties: - Config: copy_is_hardlink - Env Var: RCLONE_SFTP_COPY_IS_HARDLINK - Type: bool - Default: false --sftp-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SFTP_DESCRIPTION - Type: string - Required: false Limitations On some SFTP servers (e.g. Synology) the paths are different for SSH and SFTP so the hashes can't be calculated properly. You can either use --sftp-path-override or disable_hashcheck. The only ssh agent supported under Windows is Putty's pageant. The Go SSH library disables the use of the aes128-cbc cipher by default, due to security concerns. This can be re-enabled on a per-connection basis by setting the use_insecure_cipher setting in the configuration file to true. Further details on the insecurity of this cipher can be found in this paper. SFTP isn't supported under plan9 until this issue is fixed. Note that since SFTP isn't HTTP based the following flags don't work with it: --dump-headers, --dump-bodies, --dump-auth. Note that --timeout and --contimeout are both supported. rsync.net rsync.net is supported through the SFTP backend. See rsync.net's documentation of rclone examples. Hetzner Storage Box Hetzner Storage Boxes are supported through the SFTP backend on port 23. See Hetzner's documentation for details SMB SMB is a communication protocol to share files over network. This relies on go-smb2 library for communication with SMB protocol. Paths are specified as remote:sharename (or remote: for the lsd command.) You may put subdirectories in too, e.g. remote:item/path/to/dir. Notes The first path segment must be the name of the share, which you entered when you started to share on Windows. On smbd, it's the section title in smb.conf (usually in /etc/samba/) file. You can find shares by querying the root if you're unsure (e.g. rclone lsd remote:). You can't access to the shared printers from rclone, obviously. You can't use Anonymous access for logging in. You have to use the guest user with an empty password instead. The rclone client tries to avoid 8.3 names when uploading files by encoding trailing spaces and periods. Alternatively, the local backend on Windows can access SMB servers using UNC paths, by \\server\share. This doesn't apply to non-Windows OSes, such as Linux and macOS. Configuration Here is an example of making a SMB configuration. First run rclone config This will guide you through an interactive setup process. No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Option Storage. Type of storage to configure. Choose a number from below, or type in your own value. XX / SMB / CIFS \ (smb) Storage> smb Option host. Samba hostname to connect to. E.g. "example.com". Enter a value. host> localhost Option user. Samba username. Enter a string value. Press Enter for the default (lesmi). user> guest Option port. Samba port number. Enter a signed integer. Press Enter for the default (445). port> Option pass. Samba password. Choose an alternative below. Press Enter for the default (n). y) Yes, type in my own password g) Generate random password n) No, leave this optional password blank (default) y/g/n> g Password strength in bits. 64 is just about memorable 128 is secure 1024 is the maximum Bits> 64 Your password is: XXXX Use this password? Please note that an obscured version of this password (and not the password itself) will be stored under your configuration file, so keep this generated password in a safe place. y) Yes (default) n) No y/n> y Option domain. Domain name for NTLM authentication. Enter a string value. Press Enter for the default (WORKGROUP). domain> Edit advanced config? y) Yes n) No (default) y/n> n Configuration complete. Options: - type: samba - host: localhost - user: guest - pass: *** ENCRYPTED *** Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> d Standard options Here are the Standard options specific to smb (SMB / CIFS). --smb-host SMB server hostname to connect to. E.g. "example.com". Properties: - Config: host - Env Var: RCLONE_SMB_HOST - Type: string - Required: true --smb-user SMB username. Properties: - Config: user - Env Var: RCLONE_SMB_USER - Type: string - Default: "$USER" --smb-port SMB port number. Properties: - Config: port - Env Var: RCLONE_SMB_PORT - Type: int - Default: 445 --smb-pass SMB password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: pass - Env Var: RCLONE_SMB_PASS - Type: string - Required: false --smb-domain Domain name for NTLM authentication. Properties: - Config: domain - Env Var: RCLONE_SMB_DOMAIN - Type: string - Default: "WORKGROUP" --smb-spn Service principal name. Rclone presents this name to the server. Some servers use this as further authentication, and it often needs to be set for clusters. For example: cifs/remotehost:1020 Leave blank if not sure. Properties: - Config: spn - Env Var: RCLONE_SMB_SPN - Type: string - Required: false --smb-use-kerberos Use Kerberos authentication. If set, rclone will use Kerberos authentication instead of NTLM. This requires a valid Kerberos configuration and credentials cache to be available, either in the default locations or as specified by the KRB5_CONFIG and KRB5CCNAME environment variables. Properties: - Config: use_kerberos - Env Var: RCLONE_SMB_USE_KERBEROS - Type: bool - Default: false Advanced options Here are the Advanced options specific to smb (SMB / CIFS). --smb-idle-timeout Max time before closing idle connections. If no connections have been returned to the connection pool in the time given, rclone will empty the connection pool. Set to 0 to keep connections indefinitely. Properties: - Config: idle_timeout - Env Var: RCLONE_SMB_IDLE_TIMEOUT - Type: Duration - Default: 1m0s --smb-hide-special-share Hide special shares (e.g. print$) which users aren't supposed to access. Properties: - Config: hide_special_share - Env Var: RCLONE_SMB_HIDE_SPECIAL_SHARE - Type: bool - Default: true --smb-case-insensitive Whether the server is configured to be case-insensitive. Always true on Windows shares. Properties: - Config: case_insensitive - Env Var: RCLONE_SMB_CASE_INSENSITIVE - Type: bool - Default: true --smb-kerberos-ccache Path to the Kerberos credential cache (krb5cc). Overrides the default KRB5CCNAME environment variable and allows this instance of the SMB backend to use a different Kerberos cache file. This is useful when mounting multiple SMB with different credentials or running in multi-user environments. Supported formats: - FILE:/path/to/ccache – Use the specified file. - DIR:/path/to/ccachedir – Use the primary file inside the specified directory. - /path/to/ccache – Interpreted as a file path. Properties: - Config: kerberos_ccache - Env Var: RCLONE_SMB_KERBEROS_CCACHE - Type: string - Required: false --smb-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_SMB_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,BackSlash,Ctl,RightSpace,RightPeriod,InvalidUtf8,Dot --smb-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SMB_DESCRIPTION - Type: string - Required: false Storj Storj is redefining the cloud to support the future of data—sustainably and economically. Storj leverages the vast global supply of underutilized resources to deliver better security, durability, and performance services. Experience up to 90% lower costs and carbon reduction with Storj. Storj is an encrypted, secure, and cost-effective object storage service that enables you to store, back up, and archive large amounts of data in a decentralized manner. Backend options Storj can be used both with this native backend and with the s3 backend using the Storj S3 compatible gateway (shared or private). Use this backend to take advantage of client-side encryption as well as to achieve the best possible download performance. Uploads will be erasure-coded locally, thus a 1gb upload will result in 2.68gb of data being uploaded to storage nodes across the network. Use the s3 backend and one of the S3 compatible Hosted Gateways to increase upload performance and reduce the load on your systems and network. Uploads will be encrypted and erasure-coded server-side, thus a 1GB upload will result in only in 1GB of data being uploaded to storage nodes across the network. Side by side comparison with more details: - Characteristics: - Storj backend: Uses native RPC protocol, connects directly to the storage nodes which hosts the data. Requires more CPU resource of encoding/decoding and has network amplification (especially during the upload), uses lots of TCP connections - S3 backend: Uses S3 compatible HTTP Rest API via the shared gateways. There is no network amplification, but performance depends on the shared gateways and the secret encryption key is shared with the gateway. - Typical usage: - Storj backend: Server environments and desktops with enough resources, internet speed and connectivity - and applications where storjs client-side encryption is required. - S3 backend: Desktops and similar with limited resources, internet speed or connectivity. - Security: - Storj backend: strong. Private encryption key doesn't need to leave the local computer. - S3 backend: weaker. Private encryption key is shared with the authentication service of the hosted gateway, where it's stored encrypted. It can be stronger when combining with the rclone crypt backend. - Bandwidth usage (upload): - Storj backend: higher. As data is erasure coded on the client side both the original data and the parities should be uploaded. About ~2.7 times more data is required to be uploaded. Client may start to upload with even higher number of nodes (~3.7 times more) and abandon/stop the slow uploads. - S3 backend: normal. Only the raw data is uploaded, erasure coding happens on the gateway. - Bandwidth usage (download) - Storj backend: almost normal. Only the minimal number of data is required, but to avoid very slow data providers a few more sources are used and the slowest are ignored (max 1.2x overhead). - S3 backend: normal. Only the raw data is downloaded, erasure coding happens on the shared gateway. - CPU usage: - Storj backend: higher, but more predictable. Erasure code and encryption/decryption happens locally which requires significant CPU usage. - S3 backend: less. Erasure code and encryption/decryption happens on shared s3 gateways (and as is, it depends on the current load on the gateways) - TCP connection usage: - Storj backend: high. A direct connection is required to each of the Storj nodes resulting in 110 connections on upload and 35 on download per 64 MB segment. Not all the connections are actively used (slow ones are pruned), but they are all opened. Adjusting the max open file limit may be required. - S3 backend: normal. Only one connection per download/upload thread is required to the shared gateway. - Overall performance: - Storj backend: with enough resources (CPU and bandwidth) storj backend can provide even 2x better performance. Data is directly downloaded to / uploaded from to the client instead of the gateway. - S3 backend: Can be faster on edge devices where CPU and network bandwidth is limited as the shared S3 compatible gateways take care about the encrypting/decryption and erasure coding and no download/upload amplification. - Decentralization: - Storj backend: high. Data is downloaded directly from the distributed cloud of storage providers. - S3 backend: low. Requires a running S3 gateway (either self-hosted or Storj-hosted). - Limitations: - Storj backend: rclone checksum is not possible without download, as checksum metadata is not calculated during upload - S3 backend: secret encryption key is shared with the gateway Configuration To make a new Storj configuration you need one of the following: * Access Grant that someone else shared with you. * API Key of a Storj project you are a member of. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: Setup with access grant No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Storj Decentralized Cloud Storage \ "storj" [snip] Storage> storj ** See help for storj backend at: https://rclone.org/storj/ ** Choose an authentication method. Enter a string value. Press Enter for the default ("existing"). Choose a number from below, or type in your own value 1 / Use an existing access grant. \ "existing" 2 / Create a new access grant from satellite address, API key, and passphrase. \ "new" provider> existing Access Grant. Enter a string value. Press Enter for the default (""). access_grant> your-access-grant-received-by-someone-else Remote config Configuration complete. Options: - type: storj - access_grant: your-access-grant-received-by-someone-else Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Setup with API key and passphrase No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Storj Decentralized Cloud Storage \ "storj" [snip] Storage> storj ** See help for storj backend at: https://rclone.org/storj/ ** Choose an authentication method. Enter a string value. Press Enter for the default ("existing"). Choose a number from below, or type in your own value 1 / Use an existing access grant. \ "existing" 2 / Create a new access grant from satellite address, API key, and passphrase. \ "new" provider> new Satellite Address. Custom satellite address should match the format: `@
:`. Enter a string value. Press Enter for the default ("us1.storj.io"). Choose a number from below, or type in your own value 1 / US1 \ "us1.storj.io" 2 / EU1 \ "eu1.storj.io" 3 / AP1 \ "ap1.storj.io" satellite_address> 1 API Key. Enter a string value. Press Enter for the default (""). api_key> your-api-key-for-your-storj-project Encryption Passphrase. To access existing objects enter passphrase used for uploading. Enter a string value. Press Enter for the default (""). passphrase> your-human-readable-encryption-passphrase Remote config Configuration complete. Options: - type: storj - satellite_address: 12EayRS2V1kEsWESU9QMRseFhdxYxKicsiFmxrsLZHeLUtdps3S@us1.storj.io:7777 - api_key: your-api-key-for-your-storj-project - passphrase: your-human-readable-encryption-passphrase - access_grant: the-access-grant-generated-from-the-api-key-and-passphrase Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Standard options Here are the Standard options specific to storj (Storj Decentralized Cloud Storage). --storj-provider Choose an authentication method. Properties: - Config: provider - Env Var: RCLONE_STORJ_PROVIDER - Type: string - Default: "existing" - Examples: - "existing" - Use an existing access grant. - "new" - Create a new access grant from satellite address, API key, and passphrase. --storj-access-grant Access grant. Properties: - Config: access_grant - Env Var: RCLONE_STORJ_ACCESS_GRANT - Provider: existing - Type: string - Required: false --storj-satellite-address Satellite address. Custom satellite address should match the format: @
:. Properties: - Config: satellite_address - Env Var: RCLONE_STORJ_SATELLITE_ADDRESS - Provider: new - Type: string - Default: "us1.storj.io" - Examples: - "us1.storj.io" - US1 - "eu1.storj.io" - EU1 - "ap1.storj.io" - AP1 --storj-api-key API key. Properties: - Config: api_key - Env Var: RCLONE_STORJ_API_KEY - Provider: new - Type: string - Required: false --storj-passphrase Encryption passphrase. To access existing objects enter passphrase used for uploading. Properties: - Config: passphrase - Env Var: RCLONE_STORJ_PASSPHRASE - Provider: new - Type: string - Required: false Advanced options Here are the Advanced options specific to storj (Storj Decentralized Cloud Storage). --storj-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_STORJ_DESCRIPTION - Type: string - Required: false Usage Paths are specified as remote:bucket (or remote: for the lsf command.) You may put subdirectories in too, e.g. remote:bucket/path/to/dir. Once configured you can then use rclone like this. Create a new bucket Use the mkdir command to create new bucket, e.g. bucket. rclone mkdir remote:bucket List all buckets Use the lsf command to list all buckets. rclone lsf remote: Note the colon (:) character at the end of the command line. Delete a bucket Use the rmdir command to delete an empty bucket. rclone rmdir remote:bucket Use the purge command to delete a non-empty bucket with all its content. rclone purge remote:bucket Upload objects Use the copy command to upload an object. rclone copy --progress /home/local/directory/file.ext remote:bucket/path/to/dir/ The --progress flag is for displaying progress information. Remove it if you don't need this information. Use a folder in the local path to upload all its objects. rclone copy --progress /home/local/directory/ remote:bucket/path/to/dir/ Only modified files will be copied. List objects Use the ls command to list recursively all objects in a bucket. rclone ls remote:bucket Add the folder to the remote path to list recursively all objects in this folder. rclone ls remote:bucket/path/to/dir/ Use the lsf command to list non-recursively all objects in a bucket or a folder. rclone lsf remote:bucket/path/to/dir/ Download objects Use the copy command to download an object. rclone copy --progress remote:bucket/path/to/dir/file.ext /home/local/directory/ The --progress flag is for displaying progress information. Remove it if you don't need this information. Use a folder in the remote path to download all its objects. rclone copy --progress remote:bucket/path/to/dir/ /home/local/directory/ Delete objects Use the deletefile command to delete a single object. rclone deletefile remote:bucket/path/to/dir/file.ext Use the delete command to delete all object in a folder. rclone delete remote:bucket/path/to/dir/ Print the total size of objects Use the size command to print the total size of objects in a bucket or a folder. rclone size remote:bucket/path/to/dir/ Sync two Locations Use the sync command to sync the source to the destination, changing the destination only, deleting any excess files. rclone sync --interactive --progress /home/local/directory/ remote:bucket/path/to/dir/ The --progress flag is for displaying progress information. Remove it if you don't need this information. Since this can cause data loss, test first with the --dry-run flag to see exactly what would be copied and deleted. The sync can be done also from Storj to the local file system. rclone sync --interactive --progress remote:bucket/path/to/dir/ /home/local/directory/ Or between two Storj buckets. rclone sync --interactive --progress remote-us:bucket/path/to/dir/ remote-europe:bucket/path/to/dir/ Or even between another cloud storage and Storj. rclone sync --interactive --progress s3:bucket/path/to/dir/ storj:bucket/path/to/dir/ Limitations rclone about is not supported by the rclone Storj backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about Known issues If you get errors like too many open files this usually happens when the default ulimit for system max open files is exceeded. Native Storj protocol opens a large number of TCP connections (each of which is counted as an open file). For a single upload stream you can expect 110 TCP connections to be opened. For a single download stream you can expect 35. This batch of connections will be opened for every 64 MiB segment and you should also expect TCP connections to be reused. If you do many transfers you eventually open a connection to most storage nodes (thousands of nodes). To fix these, please raise your system limits. You can do this issuing a ulimit -n 65536 just before you run rclone. To change the limits more permanently you can add this to your shell startup script, e.g. $HOME/.bashrc, or change the system-wide configuration, usually /etc/sysctl.conf and/or /etc/security/limits.conf, but please refer to your operating system manual. SugarSync SugarSync is a cloud service that enables active synchronization of files across computers and other devices for file backup, access, syncing, and sharing. Configuration The initial setup for SugarSync involves getting a token from SugarSync which you can do with rclone. rclone config walks you through it. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Sugarsync \ "sugarsync" [snip] Storage> sugarsync ** See help for sugarsync backend at: https://rclone.org/sugarsync/ ** Sugarsync App ID. Leave blank to use rclone's. Enter a string value. Press Enter for the default (""). app_id> Sugarsync Access Key ID. Leave blank to use rclone's. Enter a string value. Press Enter for the default (""). access_key_id> Sugarsync Private Access Key Leave blank to use rclone's. Enter a string value. Press Enter for the default (""). private_access_key> Permanently delete files if true otherwise put them in the deleted files. Enter a boolean value (true or false). Press Enter for the default ("false"). hard_delete> Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config Username (email address)> nick@craig-wood.com Your Sugarsync password is only required during setup and will not be stored. password: Configuration complete. Options: - type: sugarsync - refresh_token: https://api.sugarsync.com/app-authorization/XXXXXXXXXXXXXXXXXX Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Note that the config asks for your email and password but doesn't store them, it only uses them to get the initial token. Once configured you can then use rclone like this, List directories (sync folders) in top level of your SugarSync rclone lsd remote: List all the files in your SugarSync folder "Test" rclone ls remote:Test To copy a local directory to an SugarSync folder called backup rclone copy /home/source remote:backup Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. NB you can't create files in the top level folder you have to create a folder, which rclone will create as a "Sync Folder" with SugarSync. Modification times and hashes SugarSync does not support modification times or hashes, therefore syncing will default to --size-only checking. Note that using --update will work as rclone can read the time files were uploaded. Restricted filename characters SugarSync replaces the default restricted characters set except for DEL. Invalid UTF-8 bytes will also be replaced, as they can't be used in XML strings. Deleting files Deleted files will be moved to the "Deleted items" folder by default. However you can supply the flag --sugarsync-hard-delete or set the config parameter hard_delete = true if you would like files to be deleted straight away. Standard options Here are the Standard options specific to sugarsync (Sugarsync). --sugarsync-app-id Sugarsync App ID. Leave blank to use rclone's. Properties: - Config: app_id - Env Var: RCLONE_SUGARSYNC_APP_ID - Type: string - Required: false --sugarsync-access-key-id Sugarsync Access Key ID. Leave blank to use rclone's. Properties: - Config: access_key_id - Env Var: RCLONE_SUGARSYNC_ACCESS_KEY_ID - Type: string - Required: false --sugarsync-private-access-key Sugarsync Private Access Key. Leave blank to use rclone's. Properties: - Config: private_access_key - Env Var: RCLONE_SUGARSYNC_PRIVATE_ACCESS_KEY - Type: string - Required: false --sugarsync-hard-delete Permanently delete files if true otherwise put them in the deleted files. Properties: - Config: hard_delete - Env Var: RCLONE_SUGARSYNC_HARD_DELETE - Type: bool - Default: false Advanced options Here are the Advanced options specific to sugarsync (Sugarsync). --sugarsync-refresh-token Sugarsync refresh token. Leave blank normally, will be auto configured by rclone. Properties: - Config: refresh_token - Env Var: RCLONE_SUGARSYNC_REFRESH_TOKEN - Type: string - Required: false --sugarsync-authorization Sugarsync authorization. Leave blank normally, will be auto configured by rclone. Properties: - Config: authorization - Env Var: RCLONE_SUGARSYNC_AUTHORIZATION - Type: string - Required: false --sugarsync-authorization-expiry Sugarsync authorization expiry. Leave blank normally, will be auto configured by rclone. Properties: - Config: authorization_expiry - Env Var: RCLONE_SUGARSYNC_AUTHORIZATION_EXPIRY - Type: string - Required: false --sugarsync-user Sugarsync user. Leave blank normally, will be auto configured by rclone. Properties: - Config: user - Env Var: RCLONE_SUGARSYNC_USER - Type: string - Required: false --sugarsync-root-id Sugarsync root id. Leave blank normally, will be auto configured by rclone. Properties: - Config: root_id - Env Var: RCLONE_SUGARSYNC_ROOT_ID - Type: string - Required: false --sugarsync-deleted-id Sugarsync deleted folder id. Leave blank normally, will be auto configured by rclone. Properties: - Config: deleted_id - Env Var: RCLONE_SUGARSYNC_DELETED_ID - Type: string - Required: false --sugarsync-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_SUGARSYNC_ENCODING - Type: Encoding - Default: Slash,Ctl,InvalidUtf8,Dot --sugarsync-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_SUGARSYNC_DESCRIPTION - Type: string - Required: false Limitations rclone about is not supported by the SugarSync backend. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about Uloz.to Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. The initial setup for Uloz.to involves filling in the user credentials. rclone config walks you through it. Configuration Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Uloz.to \ "ulozto" [snip] Storage> ulozto Option app_token. The application token identifying the app. An app API key can be either found in the API doc https://uloz.to/upload-resumable-api-beta or obtained from customer service. Enter a value. Press Enter to leave empty. app_token> token_value Option username. The username of the principal to operate as. Enter a value. Press Enter to leave empty. username> user Option password. The password for the user. Choose an alternative below. Press Enter for the default (n). y) Yes, type in my own password g) Generate random password n) No, leave this optional password blank (default) y/g/n> y Enter the password: password: Confirm the password: password: Edit advanced config? y) Yes n) No (default) y/n> n Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> y Once configured you can then use rclone like this, List folders in root level folder: rclone lsd remote: List all the files in your root folder: rclone ls remote: To copy a local folder to a Uloz.to folder called backup: rclone copy /home/source remote:backup User credentials The only reliable method is to authenticate the user using username and password. Uloz.to offers an API key as well, but it's reserved for the use of Uloz.to's in-house application and using it in different circumstances is unreliable. Modification times and hashes Uloz.to doesn't allow the user to set a custom modification time, or retrieve the hashes after upload. As a result, the integration uses a free form field the API provides to encode client-provided timestamps and hashes. Timestamps are stored with microsecond precision. A server calculated MD5 hash of the file is verified upon upload. Afterwards, the backend only serves the client-side calculated hashes. Hashes can also be retrieved upon creating a file download link, but it's impractical for list-like use cases. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- \ 0x5C ＼ Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Transfers All files are currently uploaded using a single HTTP request, so for uploading large files a stable connection is necessary. Rclone will upload up to --transfers chunks at the same time (shared among all uploads). Deleting files By default, files are moved to the recycle bin whereas folders are deleted immediately. Trashed files are permanently deleted after 30 days in the recycle bin. Emptying the trash is currently not implemented in rclone. Root folder ID You can set the root_folder_slug for rclone. This is the folder (identified by its Folder slug) that rclone considers to be the root of your Uloz.to drive. Normally you will leave this blank and rclone will determine the correct root to use itself. However you can set this to restrict rclone to a specific folder hierarchy. In order to do this you will have to find the Folder slug of the folder you wish to use as root. This will be the last segment of the URL when you open the relevant folder in the Uloz.to web interface. For example, for exploring a folder with URL https://uloz.to/fm/my-files/foobar, foobar should be used as the root slug. root_folder_slug can be used alongside a specific path in the remote path. For example, if your remote's root_folder_slug corresponds to /foo/bar, remote:baz/qux will refer to ABSOLUTE_ULOZTO_ROOT/foo/bar/baz/qux. Standard options Here are the Standard options specific to ulozto (Uloz.to). --ulozto-app-token The application token identifying the app. An app API key can be either found in the API doc https://uloz.to/upload-resumable-api-beta or obtained from customer service. Properties: - Config: app_token - Env Var: RCLONE_ULOZTO_APP_TOKEN - Type: string - Required: false --ulozto-username The username of the principal to operate as. Properties: - Config: username - Env Var: RCLONE_ULOZTO_USERNAME - Type: string - Required: false --ulozto-password The password for the user. NB Input to this must be obscured - see rclone obscure. Properties: - Config: password - Env Var: RCLONE_ULOZTO_PASSWORD - Type: string - Required: false Advanced options Here are the Advanced options specific to ulozto (Uloz.to). --ulozto-root-folder-slug If set, rclone will use this folder as the root folder for all operations. For example, if the slug identifies 'foo/bar/', 'ulozto:baz' is equivalent to 'ulozto:foo/bar/baz' without any root slug set. Properties: - Config: root_folder_slug - Env Var: RCLONE_ULOZTO_ROOT_FOLDER_SLUG - Type: string - Required: false --ulozto-list-page-size The size of a single page for list commands. 1-500 Properties: - Config: list_page_size - Env Var: RCLONE_ULOZTO_LIST_PAGE_SIZE - Type: int - Default: 500 --ulozto-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_ULOZTO_ENCODING - Type: Encoding - Default: Slash,BackSlash,Del,Ctl,InvalidUtf8,Dot --ulozto-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_ULOZTO_DESCRIPTION - Type: string - Required: false Limitations Uloz.to file names can't have the \ character in. rclone maps this to and from an identical looking unicode equivalent ＼ (U+FF3C Fullwidth Reverse Solidus). Uloz.to only supports filenames up to 255 characters in length. Uloz.to rate limits access to the API, but exact details are undisclosed. Practical testing reveals that hitting the rate limit during normal use is very rare, although not impossible with higher number of concurrently uploaded files. rclone about is not supported by the Uloz.to backend. Although there's an endpoint to retrieve the information for the UI, it's not exposed in the API. Backends without this capability cannot determine free space for an rclone mount or use policy mfs (most free space) as a member of an rclone union remote. See List of backends that do not support rclone about and rclone about Uptobox This is a Backend for Uptobox file storage service. Uptobox is closer to a one-click hoster than a traditional cloud storage provider and therefore not suitable for long term storage. Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. Configuration To configure an Uptobox backend you'll need your personal api token. You'll find it in your account settings Here is an example of how to make a remote called remote with the default setup. First run: rclone config This will guide you through an interactive setup process: Current remotes: Name Type ==== ==== TestUptobox uptobox e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> n name> uptobox Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [...] 37 / Uptobox \ "uptobox" [...] Storage> uptobox ** See help for uptobox backend at: https://rclone.org/uptobox/ ** Your API Key, get it from https://uptobox.com/my_account Enter a string value. Press Enter for the default (""). api_key> xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config -------------------- [uptobox] type = uptobox api_key = xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx -------------------- y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> Once configured you can then use rclone like this, List directories in top level of your Uptobox rclone lsd remote: List all the files in your Uptobox rclone ls remote: To copy a local directory to an Uptobox directory called backup rclone copy /home/source remote:backup Modification times and hashes Uptobox supports neither modified times nor checksums. All timestamps will read as that set by --default-time. Restricted filename characters In addition to the default restricted characters set the following characters are also replaced: Character Value Replacement ----------- ------- ------------- " 0x22 ＂ ` 0x41 ｀ Invalid UTF-8 bytes will also be replaced, as they can't be used in XML strings. Standard options Here are the Standard options specific to uptobox (Uptobox). --uptobox-access-token Your access token. Get it from https://uptobox.com/my_account. Properties: - Config: access_token - Env Var: RCLONE_UPTOBOX_ACCESS_TOKEN - Type: string - Required: false Advanced options Here are the Advanced options specific to uptobox (Uptobox). --uptobox-private Set to make uploaded files private Properties: - Config: private - Env Var: RCLONE_UPTOBOX_PRIVATE - Type: bool - Default: false --uptobox-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_UPTOBOX_ENCODING - Type: Encoding - Default: Slash,LtGt,DoubleQuote,BackQuote,Del,Ctl,LeftSpace,InvalidUtf8,Dot --uptobox-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_UPTOBOX_DESCRIPTION - Type: string - Required: false Limitations Uptobox will delete inactive files that have not been accessed in 60 days. rclone about is not supported by this backend an overview of used space can however been seen in the uptobox web interface. Union The union backend joins several remotes together to make a single unified view of them. During the initial setup with rclone config you will specify the upstream remotes as a space separated list. The upstream remotes can either be a local paths or other remotes. The attributes :ro, :nc and :writeback can be attached to the end of the remote to tag the remote as read only, no create or writeback, e.g. remote:directory/subdirectory:ro or remote:directory/subdirectory:nc. - :ro means files will only be read from here and never written - :nc means new files or directories won't be created here - :writeback means files found in different remotes will be written back here. See the writeback section for more info. Subfolders can be used in upstream remotes. Assume a union remote named backup with the remotes mydrive:private/backup. Invoking rclone mkdir backup:desktop is exactly the same as invoking rclone mkdir mydrive:private/backup/desktop. There is no special handling of paths containing .. segments. Invoking rclone mkdir backup:../desktop is exactly the same as invoking rclone mkdir mydrive:private/backup/../desktop. Configuration Here is an example of how to make a union called remote for local folders. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Union merges the contents of several remotes \ "union" [snip] Storage> union List of space separated upstreams. Can be 'upstreama:test/dir upstreamb:', '\"upstreama:test/space:ro dir\" upstreamb:', etc. Enter a string value. Press Enter for the default (""). upstreams> remote1:dir1 remote2:dir2 remote3:dir3 Policy to choose upstream on ACTION class. Enter a string value. Press Enter for the default ("epall"). action_policy> Policy to choose upstream on CREATE class. Enter a string value. Press Enter for the default ("epmfs"). create_policy> Policy to choose upstream on SEARCH class. Enter a string value. Press Enter for the default ("ff"). search_policy> Cache time of usage and free space (in seconds). This option is only useful when a path preserving policy is used. Enter a signed integer. Press Enter for the default ("120"). cache_time> Remote config Configuration complete. Options: - type: union - upstreams: remote1:dir1 remote2:dir2 remote3:dir3 Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Current remotes: Name Type ==== ==== remote union e) Edit existing remote n) New remote d) Delete remote r) Rename remote c) Copy remote s) Set configuration password q) Quit config e/n/d/r/c/s/q> q Once configured you can then use rclone like this, List directories in top level in remote1:dir1, remote2:dir2 and remote3:dir3 rclone lsd remote: List all the files in remote1:dir1, remote2:dir2 and remote3:dir3 rclone ls remote: Copy another local directory to the union directory called source, which will be placed into remote3:dir3 rclone copy C:\source remote:source Behavior / Policies The behavior of union backend is inspired by trapexit/mergerfs. All functions are grouped into 3 categories: action, create and search. These functions and categories can be assigned a policy which dictates what file or directory is chosen when performing that behavior. Any policy can be assigned to a function or category though some may not be very useful in practice. For instance: rand (random) may be useful for file creation (create) but could lead to very odd behavior if used for delete if there were more than one copy of the file. Function / Category classifications ---------------------------------------------------------------------------- Category Description Functions ---------- --------------- ------------------------------------------------- action Writing move, rmdir, rmdirs, delete, purge and copy, sync Existing file (as destination when file exist) create Create copy, sync (as destination when file not exist) non-existing file search Reading and ls, lsd, lsl, cat, md5sum, sha1sum and copy, sync listing file (as source) N/A size, about ---------------------------------------------------------------------------- Path Preservation Policies, as described below, are of two basic types. path preserving and non-path preserving. All policies which start with ep (epff, eplfs, eplus, epmfs, eprand) are path preserving. ep stands for existing path. A path preserving policy will only consider upstreams where the relative path being accessed already exists. When using non-path preserving policies paths will be created in target upstreams as necessary. Quota Relevant Policies Some policies rely on quota information. These policies should be used only if your upstreams support the respective quota fields. Policy Required Field ------------ ---------------- lfs, eplfs Free mfs, epmfs Free lus, eplus Used lno, eplno Objects To check if your upstream supports the field, run rclone about remote: [flags] and see if the required field exists. Filters Policies basically search upstream remotes and create a list of files / paths for functions to work on. The policy is responsible for filtering and sorting. The policy type defines the sorting but filtering is mostly uniform as described below. - No search policies filter. - All action policies will filter out remotes which are tagged as read-only. - All create policies will filter out remotes which are tagged read-only or no-create. If all remotes are filtered an error will be returned. Policy descriptions The policies definition are inspired by trapexit/mergerfs but not exactly the same. Some policy definition could be different due to the much larger latency of remote file systems. ----------------------------------------------------------------------- Policy Description ---------------- ------------------------------------------------------ all Search category: same as epall. Action category: same as epall. Create category: act on all upstreams. epall (existing Search category: Given this order configured, act on path, all) the first one found where the relative path exists. Action category: apply to all found. Create category: act on all upstreams where the relative path exists. epff (existing Act on the first one found, by the time upstreams path, first reply, where the relative path exists. found) eplfs (existing Of all the upstreams on which the relative path exists path, least free choose the one with the least free space. space) eplus (existing Of all the upstreams on which the relative path exists path, least used choose the one with the least used space. space) eplno (existing Of all the upstreams on which the relative path exists path, least choose the one with the least number of objects. number of objects) epmfs (existing Of all the upstreams on which the relative path exists path, most free choose the one with the most free space. space) eprand (existing Calls epall and then randomizes. Returns only one path, random) upstream. ff (first found) Search category: same as epff. Action category: same as epff. Create category: Act on the first one found by the time upstreams reply. lfs (least free Search category: same as eplfs. Action category: same space) as eplfs. Create category: Pick the upstream with the least available free space. lus (least used Search category: same as eplus. Action category: same space) as eplus. Create category: Pick the upstream with the least used space. lno (least Search category: same as eplno. Action category: same number of as eplno. Create category: Pick the upstream with the objects) least number of objects. mfs (most free Search category: same as epmfs. Action category: same space) as epmfs. Create category: Pick the upstream with the most available free space. newest Pick the file / directory with the largest mtime. rand (random) Calls all and then randomizes. Returns only one upstream. ----------------------------------------------------------------------- Writeback The tag :writeback on an upstream remote can be used to make a simple cache system like this: [union] type = union action_policy = all create_policy = all search_policy = ff upstreams = /local:writeback remote:dir When files are opened for read, if the file is in remote:dir but not /local then rclone will copy the file entirely into /local before returning a reference to the file in /local. The copy will be done with the equivalent of rclone copy so will use --multi-thread-streams if configured. Any copies will be logged with an INFO log. When files are written, they will be written to both remote:dir and /local. As many remotes as desired can be added to upstreams but there should only be one :writeback tag. Rclone does not manage the :writeback remote in any way other than writing files back to it. So if you need to expire old files or manage the size then you will have to do this yourself. Standard options Here are the Standard options specific to union (Union merges the contents of several upstream fs). --union-upstreams List of space separated upstreams. Can be 'upstreama:test/dir upstreamb:', '"upstreama:test/space:ro dir" upstreamb:', etc. Properties: - Config: upstreams - Env Var: RCLONE_UNION_UPSTREAMS - Type: string - Required: true --union-action-policy Policy to choose upstream on ACTION category. Properties: - Config: action_policy - Env Var: RCLONE_UNION_ACTION_POLICY - Type: string - Default: "epall" --union-create-policy Policy to choose upstream on CREATE category. Properties: - Config: create_policy - Env Var: RCLONE_UNION_CREATE_POLICY - Type: string - Default: "epmfs" --union-search-policy Policy to choose upstream on SEARCH category. Properties: - Config: search_policy - Env Var: RCLONE_UNION_SEARCH_POLICY - Type: string - Default: "ff" --union-cache-time Cache time of usage and free space (in seconds). This option is only useful when a path preserving policy is used. Properties: - Config: cache_time - Env Var: RCLONE_UNION_CACHE_TIME - Type: int - Default: 120 Advanced options Here are the Advanced options specific to union (Union merges the contents of several upstream fs). --union-min-free-space Minimum viable free space for lfs/eplfs policies. If a remote has less than this much free space then it won't be considered for use in lfs or eplfs policies. Properties: - Config: min_free_space - Env Var: RCLONE_UNION_MIN_FREE_SPACE - Type: SizeSuffix - Default: 1Gi --union-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_UNION_DESCRIPTION - Type: string - Required: false Metadata Any metadata supported by the underlying remote is read and written. See the metadata docs for more info. WebDAV Paths are specified as remote:path Paths may be as deep as required, e.g. remote:directory/subdirectory. Configuration To configure the WebDAV remote you will need to have a URL for it, and a username and password. If you know what kind of system you are connecting to then rclone can enable extra features. Here is an example of how to make a remote called remote. First run: rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password q) Quit config n/s/q> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / WebDAV \ "webdav" [snip] Storage> webdav URL of http host to connect to Choose a number from below, or type in your own value 1 / Connect to example.com \ "https://example.com" url> https://example.com/remote.php/webdav/ Name of the WebDAV site/service/software you are using Choose a number from below, or type in your own value 1 / Fastmail Files \ (fastmail) 2 / Nextcloud \ (nextcloud) 3 / Owncloud \ (owncloud) 4 / Sharepoint Online, authenticated by Microsoft account \ (sharepoint) 5 / Sharepoint with NTLM authentication, usually self-hosted or on-premises \ (sharepoint-ntlm) 6 / rclone WebDAV server to serve a remote over HTTP via the WebDAV protocol \ (rclone) 7 / Other site/service or software \ (other) vendor> 2 User name user> user Password. y) Yes type in my own password g) Generate random password n) No leave this optional password blank y/g/n> y Enter the password: password: Confirm the password: password: Bearer token instead of user/pass (e.g. a Macaroon) bearer_token> Remote config Configuration complete. Options: - type: webdav - url: https://example.com/remote.php/webdav/ - vendor: nextcloud - user: user - pass: *** ENCRYPTED *** - bearer_token: Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y Once configured you can then use rclone like this, List directories in top level of your WebDAV rclone lsd remote: List all the files in your WebDAV rclone ls remote: To copy a local directory to an WebDAV directory called backup rclone copy /home/source remote:backup Modification times and hashes Plain WebDAV does not support modified times. However when used with Fastmail Files, ownCloud or Nextcloud rclone will support modified times. Likewise plain WebDAV does not support hashes, however when used with Fastmail Files, ownCloud or Nextcloud rclone will support SHA1 and MD5 hashes. Depending on the exact version of ownCloud or Nextcloud hashes may appear on all objects, or only on objects which had a hash uploaded with them. Standard options Here are the Standard options specific to webdav (WebDAV). --webdav-url URL of http host to connect to. E.g. https://example.com. Properties: - Config: url - Env Var: RCLONE_WEBDAV_URL - Type: string - Required: true --webdav-vendor Name of the WebDAV site/service/software you are using. Properties: - Config: vendor - Env Var: RCLONE_WEBDAV_VENDOR - Type: string - Required: false - Examples: - "fastmail" - Fastmail Files - "nextcloud" - Nextcloud - "owncloud" - Owncloud 10 PHP based WebDAV server - "infinitescale" - ownCloud Infinite Scale - "sharepoint" - Sharepoint Online, authenticated by Microsoft account - "sharepoint-ntlm" - Sharepoint with NTLM authentication, usually self-hosted or on-premises - "rclone" - rclone WebDAV server to serve a remote over HTTP via the WebDAV protocol - "other" - Other site/service or software --webdav-user User name. In case NTLM authentication is used, the username should be in the format 'Domain'. Properties: - Config: user - Env Var: RCLONE_WEBDAV_USER - Type: string - Required: false --webdav-pass Password. NB Input to this must be obscured - see rclone obscure. Properties: - Config: pass - Env Var: RCLONE_WEBDAV_PASS - Type: string - Required: false --webdav-bearer-token Bearer token instead of user/pass (e.g. a Macaroon). Properties: - Config: bearer_token - Env Var: RCLONE_WEBDAV_BEARER_TOKEN - Type: string - Required: false Advanced options Here are the Advanced options specific to webdav (WebDAV). --webdav-bearer-token-command Command to run to get a bearer token. Properties: - Config: bearer_token_command - Env Var: RCLONE_WEBDAV_BEARER_TOKEN_COMMAND - Type: string - Required: false --webdav-encoding The encoding for the backend. See the encoding section in the overview for more info. Default encoding is Slash,LtGt,DoubleQuote,Colon,Question,Asterisk,Pipe,Hash,Percent,BackSlash,Del,Ctl,LeftSpace,LeftTilde,RightSpace,RightPeriod,InvalidUtf8 for sharepoint-ntlm or identity otherwise. Properties: - Config: encoding - Env Var: RCLONE_WEBDAV_ENCODING - Type: string - Required: false --webdav-headers Set HTTP headers for all transactions. Use this to set additional HTTP headers for all transactions The input format is comma separated list of key,value pairs. Standard CSV encoding may be used. For example, to set a Cookie use 'Cookie,name=value', or '"Cookie","name=value"'. You can set multiple headers, e.g. '"Cookie","name=value","Authorization","xxx"'. Properties: - Config: headers - Env Var: RCLONE_WEBDAV_HEADERS - Type: CommaSepList - Default: --webdav-pacer-min-sleep Minimum time to sleep between API calls. Properties: - Config: pacer_min_sleep - Env Var: RCLONE_WEBDAV_PACER_MIN_SLEEP - Type: Duration - Default: 10ms --webdav-nextcloud-chunk-size Nextcloud upload chunk size. We recommend configuring your NextCloud instance to increase the max chunk size to 1 GB for better upload performances. See https://docs.nextcloud.com/server/latest/admin_manual/configuration_files/big_file_upload_configuration.html#adjust-chunk-size-on-nextcloud-side Set to 0 to disable chunked uploading. Properties: - Config: nextcloud_chunk_size - Env Var: RCLONE_WEBDAV_NEXTCLOUD_CHUNK_SIZE - Type: SizeSuffix - Default: 10Mi --webdav-owncloud-exclude-shares Exclude ownCloud shares Properties: - Config: owncloud_exclude_shares - Env Var: RCLONE_WEBDAV_OWNCLOUD_EXCLUDE_SHARES - Type: bool - Default: false --webdav-owncloud-exclude-mounts Exclude ownCloud mounted storages Properties: - Config: owncloud_exclude_mounts - Env Var: RCLONE_WEBDAV_OWNCLOUD_EXCLUDE_MOUNTS - Type: bool - Default: false --webdav-unix-socket Path to a unix domain socket to dial to, instead of opening a TCP connection directly Properties: - Config: unix_socket - Env Var: RCLONE_WEBDAV_UNIX_SOCKET - Type: string - Required: false --webdav-auth-redirect Preserve authentication on redirect. If the server redirects rclone to a new domain when it is trying to read a file then normally rclone will drop the Authorization: header from the request. This is standard security practice to avoid sending your credentials to an unknown webserver. However this is desirable in some circumstances. If you are getting an error like "401 Unauthorized" when rclone is attempting to read files from the webdav server then you can try this option. Properties: - Config: auth_redirect - Env Var: RCLONE_WEBDAV_AUTH_REDIRECT - Type: bool - Default: false --webdav-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_WEBDAV_DESCRIPTION - Type: string - Required: false Provider notes See below for notes on specific providers. Fastmail Files Use https://webdav.fastmail.com/ or a subdirectory as the URL, and your Fastmail email username@domain.tld as the username. Follow this documentation to create an app password with access to Files (WebDAV) and use this as the password. Fastmail supports modified times using the X-OC-Mtime header. ownCloud Click on the settings cog in the bottom right of the page and this will show the WebDAV URL that rclone needs in the config step. It will look something like https://example.com/remote.php/webdav/. ownCloud supports modified times using the X-OC-Mtime header. Nextcloud This is configured in an identical way to ownCloud. Note that Nextcloud initially did not support streaming of files (rcat) whereas ownCloud did, but this seems to be fixed as of 2020-11-27 (tested with rclone v1.53.1 and Nextcloud Server v19). ownCloud Infinite Scale The WebDAV URL for Infinite Scale can be found in the details panel of any space in Infinite Scale, if the display was enabled in the personal settings of the user through a checkbox there. Infinite Scale works with the chunking tus upload protocol. The chunk size is currently fixed 10 MB. Sharepoint Online Rclone can be used with Sharepoint provided by OneDrive for Business or Office365 Education Accounts. This feature is only needed for a few of these Accounts, mostly Office365 Education ones. These accounts are sometimes not verified by the domain owner github#1975 This means that these accounts can't be added using the official API (other Accounts should work with the "onedrive" option). However, it is possible to access them using webdav. To use a sharepoint remote with rclone, add it like this: First, you need to get your remote's URL: - Go here to open your OneDrive or to sign in - Now take a look at your address bar, the URL should look like this: https://[YOUR-DOMAIN]-my.sharepoint.com/personal/[YOUR-EMAIL]/_layouts/15/onedrive.aspx You'll only need this URL up to the email address. After that, you'll most likely want to add "/Documents". That subdirectory contains the actual data stored on your OneDrive. Add the remote to rclone like this: Configure the url as https://[YOUR-DOMAIN]-my.sharepoint.com/personal/[YOUR-EMAIL]/Documents and use your normal account email and password for user and pass. If you have 2FA enabled, you have to generate an app password. Set the vendor to sharepoint. Your config file should look like this: [sharepoint] type = webdav url = https://[YOUR-DOMAIN]-my.sharepoint.com/personal/[YOUR-EMAIL]/Documents vendor = sharepoint user = YourEmailAddress pass = encryptedpassword Sharepoint with NTLM Authentication Use this option in case your (hosted) Sharepoint is not tied to OneDrive accounts and uses NTLM authentication. To get the url configuration, similarly to the above, first navigate to the desired directory in your browser to get the URL, then strip everything after the name of the opened directory. Example: If the URL is: https://example.sharepoint.com/sites/12345/Documents/Forms/AllItems.aspx The configuration to use would be: https://example.sharepoint.com/sites/12345/Documents Set the vendor to sharepoint-ntlm. NTLM uses domain and user name combination for authentication, set user to DOMAIN\username. Your config file should look like this: [sharepoint] type = webdav url = https://[YOUR-DOMAIN]/some-path-to/Documents vendor = sharepoint-ntlm user = DOMAIN\user pass = encryptedpassword Required Flags for SharePoint As SharePoint does some special things with uploaded documents, you won't be able to use the documents size or the documents hash to compare if a file has been changed since the upload / which file is newer. For Rclone calls copying files (especially Office files such as .docx, .xlsx, etc.) from/to SharePoint (like copy, sync, etc.), you should append these flags to ensure Rclone uses the "Last Modified" datetime property to compare your documents: --ignore-size --ignore-checksum --update Rclone Use this option if you are hosting remotes over WebDAV provided by rclone. Read rclone serve webdav for more details. rclone serve supports modified times using the X-OC-Mtime header. dCache dCache is a storage system that supports many protocols and authentication/authorisation schemes. For WebDAV clients, it allows users to authenticate with username and password (BASIC), X.509, Kerberos, and various bearer tokens, including Macaroons and OpenID-Connect access tokens. Configure as normal using the other type. Don't enter a username or password, instead enter your Macaroon as the bearer_token. The config will end up looking something like this. [dcache] type = webdav url = https://dcache... vendor = other user = pass = bearer_token = your-macaroon There is a script that obtains a Macaroon from a dCache WebDAV endpoint, and creates an rclone config file. Macaroons may also be obtained from the dCacheView web-browser/JavaScript client that comes with dCache. OpenID-Connect dCache also supports authenticating with OpenID-Connect access tokens. OpenID-Connect is a protocol (based on OAuth 2.0) that allows services to identify users who have authenticated with some central service. Support for OpenID-Connect in rclone is currently achieved using another software package called oidc-agent. This is a command-line tool that facilitates obtaining an access token. Once installed and configured, an access token is obtained by running the oidc-token command. The following example shows a (shortened) access token obtained from the XDC OIDC Provider. paul@celebrimbor:~$ oidc-token XDC eyJraWQ[...]QFXDt0 paul@celebrimbor:~$ Note Before the oidc-token command will work, the refresh token must be loaded into the oidc agent. This is done with the oidc-add command (e.g., oidc-add XDC). This is typically done once per login session. Full details on this and how to register oidc-agent with your OIDC Provider are provided in the oidc-agent documentation. The rclone bearer_token_command configuration option is used to fetch the access token from oidc-agent. Configure as a normal WebDAV endpoint, using the 'other' vendor, leaving the username and password empty. When prompted, choose to edit the advanced config and enter the command to get a bearer token (e.g., oidc-agent XDC). The following example config shows a WebDAV endpoint that uses oidc-agent to supply an access token from the XDC OIDC Provider. [dcache] type = webdav url = https://dcache.example.org/ vendor = other bearer_token_command = oidc-token XDC Yandex Disk Yandex Disk is a cloud storage solution created by Yandex. Configuration Here is an example of making a yandex configuration. First run rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password n/s> n name> remote Type of storage to configure. Choose a number from below, or type in your own value [snip] XX / Yandex Disk \ "yandex" [snip] Storage> yandex Yandex Client Id - leave blank normally. client_id> Yandex Client Secret - leave blank normally. client_secret> Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes n) No y/n> y If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth Log in and authorize rclone for access Waiting for code... Got code Configuration complete. Options: - type: yandex - client_id: - client_secret: - token: {"access_token":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","token_type":"OAuth","expiry":"2016-12-29T12:27:11.362788025Z"} Keep this "remote" remote? y) Yes this is OK e) Edit this remote d) Delete this remote y/e/d> y See the remote setup docs for how to set it up on a machine with no Internet browser available. Note that rclone runs a webserver on your local machine to collect the token as returned from Yandex Disk. This only runs from the moment it opens your browser to the moment you get back the verification code. This is on http://127.0.0.1:53682/ and this it may require you to unblock it temporarily if you are running a host firewall. Once configured you can then use rclone like this, See top level directories rclone lsd remote: Make a new directory rclone mkdir remote:directory List the contents of a directory rclone ls remote:directory Sync /home/local/directory to the remote path, deleting any excess files in the path. rclone sync --interactive /home/local/directory remote:directory Yandex paths may be as deep as required, e.g. remote:directory/subdirectory. Modification times and hashes Modified times are supported and are stored accurate to 1 ns in custom metadata called rclone_modified in RFC3339 with nanoseconds format. The MD5 hash algorithm is natively supported by Yandex Disk. Emptying Trash If you wish to empty your trash you can use the rclone cleanup remote: command which will permanently delete all your trashed files. This command does not take any path arguments. Quota information To view your current quota you can use the rclone about remote: command which will display your usage limit (quota) and the current usage. Restricted filename characters The default restricted characters set are replaced. Invalid UTF-8 bytes will also be replaced, as they can't be used in JSON strings. Standard options Here are the Standard options specific to yandex (Yandex Disk). --yandex-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_YANDEX_CLIENT_ID - Type: string - Required: false --yandex-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_YANDEX_CLIENT_SECRET - Type: string - Required: false Advanced options Here are the Advanced options specific to yandex (Yandex Disk). --yandex-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_YANDEX_TOKEN - Type: string - Required: false --yandex-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_YANDEX_AUTH_URL - Type: string - Required: false --yandex-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_YANDEX_TOKEN_URL - Type: string - Required: false --yandex-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_YANDEX_CLIENT_CREDENTIALS - Type: bool - Default: false --yandex-hard-delete Delete files permanently rather than putting them into the trash. Properties: - Config: hard_delete - Env Var: RCLONE_YANDEX_HARD_DELETE - Type: bool - Default: false --yandex-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_YANDEX_ENCODING - Type: Encoding - Default: Slash,Del,Ctl,InvalidUtf8,Dot --yandex-spoof-ua Set the user agent to match an official version of the yandex disk client. May help with upload performance. Properties: - Config: spoof_ua - Env Var: RCLONE_YANDEX_SPOOF_UA - Type: bool - Default: true --yandex-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_YANDEX_DESCRIPTION - Type: string - Required: false Limitations When uploading very large files (bigger than about 5 GiB) you will need to increase the --timeout parameter. This is because Yandex pauses (perhaps to calculate the MD5SUM for the entire file) before returning confirmation that the file has been uploaded. The default handling of timeouts in rclone is to assume a 5 minute pause is an error and close the connection - you'll see net/http: timeout awaiting response headers errors in the logs if this is happening. Setting the timeout to twice the max size of file in GiB should be enough, so if you want to upload a 30 GiB file set a timeout of 2 * 30 = 60m, that is --timeout 60m. Having a Yandex Mail account is mandatory to use the Yandex.Disk subscription. Token generation will work without a mail account, but Rclone won't be able to complete any actions. [403 - DiskUnsupportedUserAccountTypeError] User account type is not supported. Zoho Workdrive Zoho WorkDrive is a cloud storage solution created by Zoho. Configuration Here is an example of making a zoho configuration. First run rclone config This will guide you through an interactive setup process: No remotes found, make a new one? n) New remote s) Set configuration password n/s> n name> remote Type of storage to configure. Enter a string value. Press Enter for the default (""). Choose a number from below, or type in your own value [snip] XX / Zoho \ "zoho" [snip] Storage> zoho ** See help for zoho backend at: https://rclone.org/zoho/ ** OAuth Client Id Leave blank normally. Enter a string value. Press Enter for the default (""). client_id> OAuth Client Secret Leave blank normally. Enter a string value. Press Enter for the default (""). client_secret> Edit advanced config? (y/n) y) Yes n) No (default) y/n> n Remote config Use web browser to automatically authenticate rclone with remote? * Say Y if the machine running rclone has a web browser you can use * Say N if running rclone on a (remote) machine without web browser access If not sure try Y. If Y failed, try N. y) Yes (default) n) No y/n> If your browser doesn't open automatically go to the following link: http://127.0.0.1:53682/auth?state=LVn0IHzxej1ZkmQw31d0wQ Log in and authorize rclone for access Waiting for code... Got code Choose a number from below, or type in your own value 1 / MyTeam \ "4u28602177065ff22426787a6745dba8954eb" Enter a Team ID> 1 Choose a number from below, or type in your own value 1 / General \ "4u2869d2aa6fca04f4f2f896b6539243b85b1" Enter a Workspace ID> 1 Configuration complete. Options: - type: zoho - token: {"access_token":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","token_type":"Zoho-oauthtoken","refresh_token":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx","expiry":"2020-10-12T00:54:52.370275223+02:00"} - root_folder_id: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx Keep this "remote" remote? y) Yes this is OK (default) e) Edit this remote d) Delete this remote y/e/d> See the remote setup docs for how to set it up on a machine with no Internet browser available. Rclone runs a webserver on your local computer to collect the authorization token from Zoho Workdrive. This is only from the moment your browser is opened until the token is returned. The webserver runs on http://127.0.0.1:53682/. If local port 53682 is protected by a firewall you may need to temporarily unblock the firewall to complete authorization. Once configured you can then use rclone like this, See top level directories rclone lsd remote: Make a new directory rclone mkdir remote:directory List the contents of a directory rclone ls remote:directory Sync /home/local/directory to the remote path, deleting any excess files in the path. rclone sync --interactive /home/local/directory remote:directory Zoho paths may be as deep as required, eg remote:directory/subdirectory. Modification times and hashes Modified times are currently not supported for Zoho Workdrive No hash algorithms are supported. Usage information To view your current quota you can use the rclone about remote: command which will display your current usage. Restricted filename characters Only control characters and invalid UTF-8 are replaced. In addition most Unicode full-width characters are not supported at all and will be removed from filenames during upload. Standard options Here are the Standard options specific to zoho (Zoho). --zoho-client-id OAuth Client Id. Leave blank normally. Properties: - Config: client_id - Env Var: RCLONE_ZOHO_CLIENT_ID - Type: string - Required: false --zoho-client-secret OAuth Client Secret. Leave blank normally. Properties: - Config: client_secret - Env Var: RCLONE_ZOHO_CLIENT_SECRET - Type: string - Required: false --zoho-region Zoho region to connect to. You'll have to use the region your organization is registered in. If not sure use the same top level domain as you connect to in your browser. Properties: - Config: region - Env Var: RCLONE_ZOHO_REGION - Type: string - Required: false - Examples: - "com" - United states / Global - "eu" - Europe - "in" - India - "jp" - Japan - "com.cn" - China - "com.au" - Australia Advanced options Here are the Advanced options specific to zoho (Zoho). --zoho-token OAuth Access Token as a JSON blob. Properties: - Config: token - Env Var: RCLONE_ZOHO_TOKEN - Type: string - Required: false --zoho-auth-url Auth server URL. Leave blank to use the provider defaults. Properties: - Config: auth_url - Env Var: RCLONE_ZOHO_AUTH_URL - Type: string - Required: false --zoho-token-url Token server url. Leave blank to use the provider defaults. Properties: - Config: token_url - Env Var: RCLONE_ZOHO_TOKEN_URL - Type: string - Required: false --zoho-client-credentials Use client credentials OAuth flow. This will use the OAUTH2 client Credentials Flow as described in RFC 6749. Note that this option is NOT supported by all backends. Properties: - Config: client_credentials - Env Var: RCLONE_ZOHO_CLIENT_CREDENTIALS - Type: bool - Default: false --zoho-upload-cutoff Cutoff for switching to large file upload api (>= 10 MiB). Properties: - Config: upload_cutoff - Env Var: RCLONE_ZOHO_UPLOAD_CUTOFF - Type: SizeSuffix - Default: 10Mi --zoho-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_ZOHO_ENCODING - Type: Encoding - Default: Del,Ctl,InvalidUtf8 --zoho-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_ZOHO_DESCRIPTION - Type: string - Required: false Setting up your own client_id For Zoho we advise you to set up your own client_id. To do so you have to complete the following steps. 1. Log in to the Zoho API Console 2. Create a new client of type "Server-based Application". The name and website don't matter, but you must add the redirect URL http://localhost:53682/. 3. Once the client is created, you can go to the settings tab and enable it in other regions. The client id and client secret can now be used with rclone. Local Filesystem Local paths are specified as normal filesystem paths, e.g. /path/to/wherever, so rclone sync --interactive /home/source /tmp/destination Will sync /home/source to /tmp/destination. Configuration For consistencies sake one can also configure a remote of type local in the config file, and access the local filesystem using rclone remote paths, e.g. remote:path/to/wherever, but it is probably easier not to. Modification times Rclone reads and writes the modification times using an accuracy determined by the OS. Typically this is 1ns on Linux, 10 ns on Windows and 1 Second on OS X. Filenames Filenames should be encoded in UTF-8 on disk. This is the normal case for Windows and OS X. There is a bit more uncertainty in the Linux world, but new distributions will have UTF-8 encoded files names. If you are using an old Linux filesystem with non UTF-8 file names (e.g. latin1) then you can use the convmv tool to convert the filesystem to UTF-8. This tool is available in most distributions' package managers. If an invalid (non-UTF8) filename is read, the invalid characters will be replaced with a quoted representation of the invalid bytes. The name gro\xdf will be transferred as gro‛DF. rclone will emit a debug message in this case (use -v to see), e.g. Local file system at .: Replacing invalid UTF-8 characters in "gro\xdf" Restricted characters With the local backend, restrictions on the characters that are usable in file or directory names depend on the operating system. To check what rclone will replace by default on your system, run rclone help flags local-encoding. On non Windows platforms the following characters are replaced when handling file names. Character Value Replacement ----------- ------- ------------- NUL 0x00 ␀ / 0x2F ／ When running on Windows the following characters are replaced. This list is based on the Windows file naming conventions. Character Value Replacement ----------- ------- ------------- NUL 0x00 ␀ SOH 0x01 ␁ STX 0x02 ␂ ETX 0x03 ␃ EOT 0x04 ␄ ENQ 0x05 ␅ ACK 0x06 ␆ BEL 0x07 ␇ BS 0x08 ␈ HT 0x09 ␉ LF 0x0A ␊ VT 0x0B ␋ FF 0x0C ␌ CR 0x0D ␍ SO 0x0E ␎ SI 0x0F ␏ DLE 0x10 ␐ DC1 0x11 ␑ DC2 0x12 ␒ DC3 0x13 ␓ DC4 0x14 ␔ NAK 0x15 ␕ SYN 0x16 ␖ ETB 0x17 ␗ CAN 0x18 ␘ EM 0x19 ␙ SUB 0x1A ␚ ESC 0x1B ␛ FS 0x1C ␜ GS 0x1D ␝ RS 0x1E ␞ US 0x1F ␟ / 0x2F ／ " 0x22 ＂ * 0x2A ＊ : 0x3A ： < 0x3C ＜ > 0x3E ＞ ? 0x3F ？ \ 0x5C ＼ | 0x7C ｜ File names on Windows can also not end with the following characters. These only get replaced if they are the last character in the name: Character Value Replacement ----------- ------- ------------- SP 0x20 ␠ . 0x2E ． Invalid UTF-8 bytes will also be replaced, as they can't be converted to UTF-16. Paths on Windows On Windows there are many ways of specifying a path to a file system resource. Local paths can be absolute, like C:\path\to\wherever, or relative, like ..\wherever. Network paths in UNC format, \\server\share, are also supported. Path separator can be either \ (as in C:\path\to\wherever) or / (as in C:/path/to/wherever). Length of these paths are limited to 259 characters for files and 247 characters for directories, but there is an alternative extended-length path format increasing the limit to (approximately) 32,767 characters. This format requires absolute paths and the use of prefix \\?\, e.g. \\?\D:\some\very\long\path. For convenience rclone will automatically convert regular paths into the corresponding extended-length paths, so in most cases you do not have to worry about this (read more below). Using the same prefix \\?\ it is also possible to specify path to volumes identified by their GUID, e.g. \\?\Volume{b75e2c83-0000-0000-0000-602f00000000}\some\path. Long paths Rclone handles long paths automatically, by converting all paths to extended-length path format, which allows paths up to 32,767 characters. This conversion will ensure paths are absolute and prefix them with the \\?\. This is why you will see that your paths, for instance .\files is shown as path \\?\C:\files in the output, and \\server\share as \\?\UNC\server\share. However, in rare cases this may cause problems with buggy file system drivers like EncFS. To disable UNC conversion globally, add this to your .rclone.conf file: [local] nounc = true If you want to selectively disable UNC, you can add it to a separate entry like this: [nounc] type = local nounc = true And use rclone like this: rclone copy c:\src nounc:z:\dst This will use UNC paths on c:\src but not on z:\dst. Of course this will cause problems if the absolute path length of a file exceeds 259 characters on z, so only use this option if you have to. Symlinks / Junction points Normally rclone will ignore symlinks or junction points (which behave like symlinks under Windows). If you supply --copy-links or -L then rclone will follow the symlink and copy the pointed to file or directory. Note that this flag is incompatible with --links / -l. This flag applies to all commands. For example, supposing you have a directory structure like this $ tree /tmp/a /tmp/a ├── b -> ../b ├── expected -> ../expected ├── one └── two └── three Then you can see the difference with and without the flag like this $ rclone ls /tmp/a 6 one 6 two/three and $ rclone -L ls /tmp/a 4174 expected 6 one 6 two/three 6 b/two 6 b/one --local-links, --links, -l Normally rclone will ignore symlinks or junction points (which behave like symlinks under Windows). If you supply this flag then rclone will copy symbolic links from the local storage, and store them as text files, with a .rclonelink suffix in the remote storage. The text file will contain the target of the symbolic link (see example). This flag applies to all commands. For example, supposing you have a directory structure like this $ tree /tmp/a /tmp/a ├── file1 -> ./file4 └── file2 -> /home/user/file3 Copying the entire directory with '-l' $ rclone copy -l /tmp/a/ remote:/tmp/a/ The remote files are created with a .rclonelink suffix $ rclone ls remote:/tmp/a 5 file1.rclonelink 14 file2.rclonelink The remote files will contain the target of the symbolic links $ rclone cat remote:/tmp/a/file1.rclonelink ./file4 $ rclone cat remote:/tmp/a/file2.rclonelink /home/user/file3 Copying them back with '-l' $ rclone copy -l remote:/tmp/a/ /tmp/b/ $ tree /tmp/b /tmp/b ├── file1 -> ./file4 └── file2 -> /home/user/file3 However, if copied back without '-l' $ rclone copyto remote:/tmp/a/ /tmp/b/ $ tree /tmp/b /tmp/b ├── file1.rclonelink └── file2.rclonelink If you want to copy a single file with -l then you must use the .rclonelink suffix. $ rclone copy -l remote:/tmp/a/file1.rclonelink /tmp/c $ tree /tmp/c /tmp/c └── file1 -> ./file4 Note that --local-links just enables this feature for the local backend. --links and -l enable the feature for all supported backends and the VFS. Note that this flag is incompatible with -copy-links / -L. Restricting filesystems with --one-file-system Normally rclone will recurse through filesystems as mounted. However if you set --one-file-system or -x this tells rclone to stay in the filesystem specified by the root and not to recurse into different file systems. For example if you have a directory hierarchy like this root ├── disk1 - disk1 mounted on the root │   └── file3 - stored on disk1 ├── disk2 - disk2 mounted on the root │   └── file4 - stored on disk12 ├── file1 - stored on the root disk └── file2 - stored on the root disk Using rclone --one-file-system copy root remote: will only copy file1 and file2. Eg $ rclone -q --one-file-system ls root 0 file1 0 file2 $ rclone -q ls root 0 disk1/file3 0 disk2/file4 0 file1 0 file2 NB Rclone (like most unix tools such as du, rsync and tar) treats a bind mount to the same device as being on the same filesystem. NB This flag is only available on Unix based systems. On systems where it isn't supported (e.g. Windows) it will be ignored. Advanced options Here are the Advanced options specific to local (Local Disk). --local-nounc Disable UNC (long path names) conversion on Windows. Properties: - Config: nounc - Env Var: RCLONE_LOCAL_NOUNC - Type: bool - Default: false - Examples: - "true" - Disables long file names. --copy-links / -L Follow symlinks and copy the pointed to item. Properties: - Config: copy_links - Env Var: RCLONE_LOCAL_COPY_LINKS - Type: bool - Default: false --local-links Translate symlinks to/from regular files with a '.rclonelink' extension for the local backend. Properties: - Config: links - Env Var: RCLONE_LOCAL_LINKS - Type: bool - Default: false --skip-links Don't warn about skipped symlinks. This flag disables warning messages on skipped symlinks or junction points, as you explicitly acknowledge that they should be skipped. Properties: - Config: skip_links - Env Var: RCLONE_LOCAL_SKIP_LINKS - Type: bool - Default: false --local-zero-size-links Assume the Stat size of links is zero (and read them instead) (deprecated). Rclone used to use the Stat size of links as the link size, but this fails in quite a few places: - Windows - On some virtual filesystems (such ash LucidLink) - Android So rclone now always reads the link. Properties: - Config: zero_size_links - Env Var: RCLONE_LOCAL_ZERO_SIZE_LINKS - Type: bool - Default: false --local-unicode-normalization Apply unicode NFC normalization to paths and filenames. This flag can be used to normalize file names into unicode NFC form that are read from the local filesystem. Rclone does not normally touch the encoding of file names it reads from the file system. This can be useful when using macOS as it normally provides decomposed (NFD) unicode which in some language (eg Korean) doesn't display properly on some OSes. Note that rclone compares filenames with unicode normalization in the sync routine so this flag shouldn't normally be used. Properties: - Config: unicode_normalization - Env Var: RCLONE_LOCAL_UNICODE_NORMALIZATION - Type: bool - Default: false --local-no-check-updated Don't check to see if the files change during upload. Normally rclone checks the size and modification time of files as they are being uploaded and aborts with a message which starts "can't copy - source file is being updated" if the file changes during upload. However on some file systems this modification time check may fail (e.g. Glusterfs #2206) so this check can be disabled with this flag. If this flag is set, rclone will use its best efforts to transfer a file which is being updated. If the file is only having things appended to it (e.g. a log) then rclone will transfer the log file with the size it had the first time rclone saw it. If the file is being modified throughout (not just appended to) then the transfer may fail with a hash check failure. In detail, once the file has had stat() called on it for the first time we: - Only transfer the size that stat gave - Only checksum the size that stat gave - Don't update the stat info for the file NB do not use this flag on a Windows Volume Shadow (VSS). For some unknown reason, files in a VSS sometimes show different sizes from the directory listing (where the initial stat value comes from on Windows) and when stat is called on them directly. Other copy tools always use the direct stat value and setting this flag will disable that. Properties: - Config: no_check_updated - Env Var: RCLONE_LOCAL_NO_CHECK_UPDATED - Type: bool - Default: false --one-file-system / -x Don't cross filesystem boundaries (unix/macOS only). Properties: - Config: one_file_system - Env Var: RCLONE_LOCAL_ONE_FILE_SYSTEM - Type: bool - Default: false --local-case-sensitive Force the filesystem to report itself as case sensitive. Normally the local backend declares itself as case insensitive on Windows/macOS and case sensitive for everything else. Use this flag to override the default choice. Properties: - Config: case_sensitive - Env Var: RCLONE_LOCAL_CASE_SENSITIVE - Type: bool - Default: false --local-case-insensitive Force the filesystem to report itself as case insensitive. Normally the local backend declares itself as case insensitive on Windows/macOS and case sensitive for everything else. Use this flag to override the default choice. Properties: - Config: case_insensitive - Env Var: RCLONE_LOCAL_CASE_INSENSITIVE - Type: bool - Default: false --local-no-clone Disable reflink cloning for server-side copies. Normally, for local-to-local transfers, rclone will "clone" the file when possible, and fall back to "copying" only when cloning is not supported. Cloning creates a shallow copy (or "reflink") which initially shares blocks with the original file. Unlike a "hardlink", the two files are independent and neither will affect the other if subsequently modified. Cloning is usually preferable to copying, as it is much faster and is deduplicated by default (i.e. having two identical files does not consume more storage than having just one.) However, for use cases where data redundancy is preferable, --local-no-clone can be used to disable cloning and force "deep" copies. Currently, cloning is only supported when using APFS on macOS (support for other platforms may be added in the future.) Properties: - Config: no_clone - Env Var: RCLONE_LOCAL_NO_CLONE - Type: bool - Default: false --local-no-preallocate Disable preallocation of disk space for transferred files. Preallocation of disk space helps prevent filesystem fragmentation. However, some virtual filesystem layers (such as Google Drive File Stream) may incorrectly set the actual file size equal to the preallocated space, causing checksum and file size checks to fail. Use this flag to disable preallocation. Properties: - Config: no_preallocate - Env Var: RCLONE_LOCAL_NO_PREALLOCATE - Type: bool - Default: false --local-no-sparse Disable sparse files for multi-thread downloads. On Windows platforms rclone will make sparse files when doing multi-thread downloads. This avoids long pauses on large files where the OS zeros the file. However sparse files may be undesirable as they cause disk fragmentation and can be slow to work with. Properties: - Config: no_sparse - Env Var: RCLONE_LOCAL_NO_SPARSE - Type: bool - Default: false --local-no-set-modtime Disable setting modtime. Normally rclone updates modification time of files after they are done uploading. This can cause permissions issues on Linux platforms when the user rclone is running as does not own the file uploaded, such as when copying to a CIFS mount owned by another user. If this option is enabled, rclone will no longer update the modtime after copying a file. Properties: - Config: no_set_modtime - Env Var: RCLONE_LOCAL_NO_SET_MODTIME - Type: bool - Default: false --local-time-type Set what kind of time is returned. Normally rclone does all operations on the mtime or Modification time. If you set this flag then rclone will return the Modified time as whatever you set here. So if you use "rclone lsl --local-time-type ctime" then you will see ctimes in the listing. If the OS doesn't support returning the time_type specified then rclone will silently replace it with the modification time which all OSes support. - mtime is supported by all OSes - atime is supported on all OSes except: plan9, js - btime is only supported on: Windows, macOS, freebsd, netbsd - ctime is supported on all Oses except: Windows, plan9, js Note that setting the time will still set the modified time so this is only useful for reading. Properties: - Config: time_type - Env Var: RCLONE_LOCAL_TIME_TYPE - Type: mtime|atime|btime|ctime - Default: mtime - Examples: - "mtime" - The last modification time. - "atime" - The last access time. - "btime" - The creation time. - "ctime" - The last status change time. --local-hashes Comma separated list of supported checksum types. Properties: - Config: hashes - Env Var: RCLONE_LOCAL_HASHES - Type: CommaSepList - Default: --local-encoding The encoding for the backend. See the encoding section in the overview for more info. Properties: - Config: encoding - Env Var: RCLONE_LOCAL_ENCODING - Type: Encoding - Default: Slash,Dot --local-description Description of the remote. Properties: - Config: description - Env Var: RCLONE_LOCAL_DESCRIPTION - Type: string - Required: false Metadata Depending on which OS is in use the local backend may return only some of the system metadata. Setting system metadata is supported on all OSes but setting user metadata is only supported on linux, freebsd, netbsd, macOS and Solaris. It is not supported on Windows yet (see pkg/attrs#47). User metadata is stored as extended attributes (which may not be supported by all file systems) under the "user.*" prefix. Metadata is supported on files and directories. Here are the possible system metadata items for the local backend. --------------------------------------------------------------------------------------------------- Name Help Type Example Read Only ----------- -------------- ------------- ------------------------------------- -------------------- atime Time of last RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N access btime Time of file RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N birth (creation) gid Group ID of decimal 500 N owner number mode File type and octal, unix 0100664 N mode style mtime Time of last RFC 3339 2006-01-02T15:04:05.999999999Z07:00 N modification rdev Device ID (if hexadecimal 1abc N special file) uid User ID of decimal 500 N owner number --------------------------------------------------------------------------------------------------- See the metadata docs for more info. Backend commands Here are the commands specific to the local backend. Run them with rclone backend COMMAND remote: The help below will explain what arguments each command takes. See the backend command for more info on how to pass options and arguments. These can be run on a running backend using the rc command backend/command. noop A null operation for testing backend commands rclone backend noop remote: [options] [+] This is a test command which has some options you can try to change the output. Options: - "echo": echo the input arguments - "error": return an error based on option value Changelog v1.71.0 - 2025-08-22 See commits - New S3 providers - Exaba (Nick Craig-Wood) - We've been working with Exaba and they would love early adopters, self-hosters and testers - OVHcloud Object Storage (Florent Vennetier) - Zata ($@M@RTH_) - New Features - Allow global config to be overriden or set on backend creation (Nick Craig-Wood) - bisync: Promoted from beta to stable (nielash) - build - Update to go1.25 and make go1.24 the minimum required version (Nick Craig-Wood) - Update all dependencies (Nick Craig-Wood) - Upgrade golangci-lint to v2 and fix code and config (albertony) - Add markdown linting to workflow and fix all the docs (albertony) - Extend check for edits of autogenerated files to all commits in a pull request (albertony) - Set default shell to bash in build.yml (Ross Smith II) - config - Make parsing of Duration options consistent (albertony) - Add error if RCLONE_CONFIG_PASS was supplied it but didn't decrypt the config (n4n5) - copy, copyto: Implement logger flags to store result of sync (Marvin Rösch) - doc fixes (albertony, Ali Zein Yousuf, Binbin Qian, curlwget, Ed Craig-Wood, jinjingroad, Lucas Bremgartner, n4n5, Nick Craig-Wood) - hash: Add support for BLAKE3, XXH3, XXH128 (albertony) - http - Add --client-pass support for encrypted --client-key files (Nick Craig-Wood) - Allow setting of --http-proxy from the command line (Nick Craig-Wood) - lib/mmap: Convert to using unsafe.Slice to avoid deprecated reflect.SliceHeader (cui) - lib/transform: Avoid empty charmap entry (albertony) - log: Add log rotation options when using --log-file (Nick Craig-Wood) - move, moveto: Implement logger flags to store result of sync (Marvin Rösch) - pool: Unify memory between multipart and asyncreader to use one pool (Nick Craig-Wood) - purge: Exit with a fatal error if filters are set on rclone purge (Nick Craig-Wood) - rc - Add config/unlock to unlock the config file (n4n5) - Fix config/listremotes to send an empty array instead of nil (n4n5) - Populate transfer snapshot with "what" value (Timothy Jacobs) - serve sftp: Add support for more hashes (crc32, sha256, blake3, xxh3, xxh128) (albertony) - transform: Add truncate_keep_extension and truncate_bytes (nielash) - Bug Fixes - about: Fix potential overflow of about in various backends (Nick Craig-Wood) - accounting - Fix incorrect stats with --transfers=1 (Yu Xin) - Fix stats (speed=0 and eta=nil) when starting jobs via rc (Nick Craig-Wood) - bisync - Fix concurrent runs via rc (nielash) - Fix --no-slow-hash settings on path2 (nielash) - config: fix problem reading pasted tokens over 4095 bytes (Nick Craig-Wood) - oauthutil: Fix nil pointer crash when started with expired token (Nick Craig-Wood) - operations: Fix too many connections open when using --max-buffer-memory (Nick Craig-Wood) - pool: Fix deadlock with --max-buffer-memory and multipart transfers (Nick Craig-Wood) - rc: Fix operations/check ignoring oneWay parameter (houance) - Mount - Fix identification of symlinks in directory listings (huangnauh) - Local - Configurable supported hashes (albertony) - Fix --copy-links on Windows when listing Junction points (Anagh Kumar Baranwal) - Azure Blob - Add support for client assertion based authentication (Vikas Bhansali) - Fix deadlock with --max-connections with InvalidBlockOrBlob errors (Nick Craig-Wood) - Fix double accounting for multipart uploads (Nick Craig-Wood) - Azurefiles - Add support for client assertion based authentication (Vikas Bhansali) - Fix hash getting erased when modtime is set (nielash) - Box - Fix about: cannot unmarshal number 1.0e+18 into Go struct field (Nick Craig-Wood) - Combine - Fix directory not found errors with ListP interface (Nick Craig-Wood) - Filescom - Document that hashes need to be enabled (Nick Craig-Wood) - FTP - Allow insecure TLS ciphers (Anagh Kumar Baranwal) - Make TLS config default to global TLS config (Nick Craig-Wood) - This allows --ca-cert, --client-cert etc to be used. - This also allows override.ca_cert = XXX to be used in the config file. - Googlephotos - Added warning for Google Photos compatability-fixes (raider13209) - Imagekit - Return correct error when attempting to upload zero length files (Nick Craig-Wood) - Don't low level retry uploads (Nick Craig-Wood) - Remove server side Copy method as it was downloading and uploading (Nick Craig-Wood) - Internetarchive - Fix server side copy of files with & (Nick Craig-Wood) - Mega - Fix tls handshake failure (necaran) - Oracleobjectstorage - Add read only metadata support (praveen-solanki-oracle) - Pikpak - Rewrite upload to bypass AWS S3 manager (wiserain) - Enhance Move for better handling of error and name collision (wiserain) - Enhance Copy method to handle name collisions and improve error management (wiserain) - Add file name integrity check during upload (wiserain) - S3 - Add --s3-use-arn-region flag (Nick Craig-Wood) - Fix memory leak by cloning strings (liubingrun) - Fix multipart upload and server side copy when using bucket policy SSE-C (Albin Parou) - Fix Content-Type: aws-chunked causing upload errors with --metadata (Nick Craig-Wood) - SFTP - Add support for more hashes (crc32, sha256, blake3, xxh3, xxh128) (albertony) - Smb - Add --smb-kerberos-ccache option to set kerberos ccache per smb backend (Sudipto Baral) - Refresh Kerberos credentials when ccache file changes (Sudipto Baral) - Improve multithreaded upload performance using multiple connections (Sudipto Baral) v1.70.3 - 2025-07-09 See commits - Bug Fixes - check: Fix difference report (was reporting error counts) (albertony) - march: Fix deadlock when using --no-traverse (Nick Craig-Wood) - doc fixes (albertony, Nick Craig-Wood) - Azure Blob - Fix server side copy error "requires exactly one scope" (Nick Craig-Wood) - B2 - Fix finding objects when using --b2-version-at (Davide Bizzarri) - Linkbox - Fix upload error "user upload file not exist" (Nick Craig-Wood) - Pikpak - Improve error handling for missing links and unrecoverable 500s (wiserain) - WebDAV - Fix setting modtime to that of local object instead of remote (WeidiDeng) v1.70.2 - 2025-06-27 See commits - Bug Fixes - convmv: Make --dry-run logs less noisy (nielash) - sync: Avoid copying dir metadata to itself (nielash) - build: Bump github.com/go-chi/chi/v5 from 5.2.1 to 5.2.2 to fix GHSA-vrw8-fxc6-2r93 (dependabot[bot]) - convmv: Fix moving to unicode-equivalent name (nielash) - log: Fix deadlock when using systemd logging (Nick Craig-Wood) - pacer: Fix nil pointer deref in RetryError (Nick Craig-Wood) - doc fixes (Ali Zein Yousuf, Nick Craig-Wood) - Local - Fix --skip-links on Windows when skipping Junction points (Nick Craig-Wood) v1.70.1 - 2025-06-19 See commits - Bug Fixes - convmv: Fix spurious "error running command echo" on Windows (Nick Craig-Wood) - doc fixes (albertony, Ed Craig-Wood, jinjingroad) v1.70.0 - 2025-06-17 See commits - New backends - DOI (Flora Thiebaut) - FileLu (kingston125) - New S3 providers: - MEGA S4 (Nick Craig-Wood) - Pure Storage FlashBlade (Jeremy Daer) - New commands - convmv: for moving and transforming files (nielash) - New Features - Add --max-connections to control maximum backend concurrency (Nick Craig-Wood) - Add --max-buffer-memory to limit total buffer memory usage (Nick Craig-Wood) - Add transform library and --name-transform flag (nielash) - sync: Implement --list-cutoff to allow on disk sorting for reduced memory use (Nick Craig-Wood) - accounting: Add listed stat for number of directory entries listed (Nick Craig-Wood) - backend: Skip hash calculation when the hashType is None (Oleksiy Stashok) - build - Update to go1.24 and make go1.22 the minimum required version (Nick Craig-Wood) - Disable docker builds on PRs & add missing dockerfile changes (Anagh Kumar Baranwal) - Modernize Go usage (Nick Craig-Wood) - Update all dependencies (Nick Craig-Wood) - cmd/authorize: Show required arguments in help text (simwai) - cmd/config: add --no-output option (Jess) - cmd/gitannex - Tweak parsing of "rcloneremotename" config (Dan McArdle) - Permit remotes with options (Dan McArdle) - Reject unknown layout modes in INITREMOTE (Dan McArdle) - docker image: Add label org.opencontainers.image.source for release notes in Renovate dependency updates (Robin Schneider) - doc fixes (albertony, Andrew Kreimer, Ben Boeckel, Christoph Berger, Danny Garside, Dimitri Papadopoulos, eccoisle, Ed Craig-Wood, Fernando Fernández, jack, Jeff Geerling, Jugal Kishore, kingston125, luzpaz, Markus Gerstel, Matt Ickstadt, Michael Kebe, Nick Craig-Wood, PrathameshLakawade, Ser-Bul, simonmcnair, Tim White, Zachary Vorhies) - filter: - Add --hash-filter to deterministically select a subset of files (Nick Craig-Wood) - Show --min-size and --max-size in --dump filters (Nick Craig-Wood) - hash: Add SHA512 support for file hashes (Enduriel) - http servers: Add --user-from-header to use for authentication (Moises Lima) - lib/batcher: Deprecate unused option: batch_commit_timeout (Dan McArdle) - log: - Remove github.com/sirupsen/logrus and replace with log/slog (Nick Craig-Wood) - Add --windows-event-log-level to support Windows Event Log (Nick Craig-Wood) - rc - Add add short parameter to core/stats to not return transferring and checking (Nick Craig-Wood) - In options/info make FieldName contain a "." if it should be nested (Nick Craig-Wood) - Add rc control for serve commands (Nick Craig-Wood) - rcserver: Improve content-type check (Jonathan Giannuzzi) - serve nfs - Update docs to note Windows is not supported (Zachary Vorhies) - Change the format of --nfs-cache-type symlink file handles (Nick Craig-Wood) - Make metadata files have special file handles (Nick Craig-Wood) - touch: Make touch obey --transfers (Nick Craig-Wood) - version: Add --deps flag to show dependencies and other build info (Nick Craig-Wood) - Bug Fixes - serve s3: - Fix ListObjectsV2 response (fhuber) - Remove redundant handler initialization (Tho Neyugn) - stats: Fix goroutine leak and improve stats accounting process (Nathanael Demacon) - VFS - Add --vfs-metadata-extension to expose metadata sidecar files (Nick Craig-Wood) - Azure Blob - Add support for x-ms-tags header (Trevor Starick) - Cleanup uncommitted blocks on upload errors (Nick Craig-Wood) - Speed up server side copies for small files (Nick Craig-Wood) - Implement multipart server side copy (Nick Craig-Wood) - Remove uncommitted blocks on InvalidBlobOrBlock error (Nick Craig-Wood) - Fix handling of objects with // in (Nick Craig-Wood) - Handle retry error codes more carefully (Nick Craig-Wood) - Fix errors not being retried when doing single part copy (Nick Craig-Wood) - Fix multipart server side copies of 0 sized files (Nick Craig-Wood) - Azurefiles - Add --azurefiles-use-az and --azurefiles-disable-instance-discovery (b-wimmer) - B2 - Add SkipDestructive handling to backend commands (Pat Patterson) - Use file id from listing when not presented in headers (ahxxm) - Cloudinary - Automatically add/remove known media files extensions (yuval-cloudinary) - Var naming convention (yuval-cloudinary) - Drive - Added backend moveid command (Spencer McCullough) - Dropbox - Support Dropbox Paper (Dave Vasilevsky) - FTP - Add --ftp-http-proxy to connect via HTTP CONNECT proxy - Gofile - Update to use new direct upload endpoint (wbulot) - Googlephotos - Update read only and read write scopes to meet Google's requirements. (Germán Casares) - Iclouddrive - Fix panic and files potentially downloaded twice (Clément Wehrung) - Internetarchive - Add --internetarchive-metadata="key=value" for setting item metadata (Corentin Barreau) - Onedrive - Fix "The upload session was not found" errors (Nick Craig-Wood) - Re-add --onedrive-upload-cutoff flag (Nick Craig-Wood) - Fix crash if no metadata was updated (Nick Craig-Wood) - Opendrive - Added --opendrive-access flag to handle permissions (Joel K Biju) - Pcloud - Fix "Access denied. You do not have permissions to perform this operation" on large uploads (Nick Craig-Wood) - S3 - Fix handling of objects with // in (Nick Craig-Wood) - Add IBM IAM signer (Alexander Minbaev) - Split the GCS quirks into --s3-use-x-id and --s3-sign-accept-encoding (Nick Craig-Wood) - Implement paged listing interface ListP (Nick Craig-Wood) - Add Pure Storage FlashBlade provider support (Jeremy Daer) - Require custom endpoint for Lyve Cloud v2 support (PrathameshLakawade) - MEGA S4 support (Nick Craig-Wood) - SFTP - Add --sftp-http-proxy to connect via HTTP CONNECT proxy (Nick Craig-Wood) - Smb - Add support for kerberos authentication (Jonathan Giannuzzi) - Improve connection pooling efficiency (Jonathan Giannuzzi) - WebDAV - Retry propfind on 425 status (Jörn Friedrich Dreyer) - Add an ownCloud Infinite Scale vendor that enables tus chunked upload support (Klaas Freitag) v1.69.3 - 2025-05-21 See commits - Bug Fixes - build: Reapply update github.com/golang-jwt/jwt/v5 from 5.2.1 to 5.2.2 to fix CVE-2025-30204 (dependabot[bot]) - build: Update github.com/ebitengine/purego to work around bug in go1.24.3 (Nick Craig-Wood) v1.69.2 - 2025-05-01 See commits - Bug fixes - accounting: Fix percentDiff calculation -- (Anagh Kumar Baranwal) - build - Update github.com/golang-jwt/jwt/v4 from 4.5.1 to 4.5.2 to fix CVE-2025-30204 (dependabot[bot]) - Update github.com/golang-jwt/jwt/v5 from 5.2.1 to 5.2.2 to fix CVE-2025-30204 (dependabot[bot]) - Update golang.org/x/crypto to v0.35.0 to fix CVE-2025-22869 (Nick Craig-Wood) - Update golang.org/x/net from 0.36.0 to 0.38.0 to fix CVE-2025-22870 (dependabot[bot]) - Update golang.org/x/net to 0.36.0. to fix CVE-2025-22869 (dependabot[bot]) - Stop building with go < go1.23 as security updates forbade it (Nick Craig-Wood) - Fix docker plugin build (Anagh Kumar Baranwal) - cmd: Fix crash if rclone is invoked without any arguments (Janne Hellsten) - config: Read configuration passwords from stdin even when terminated with EOF (Samantha Bowen) - doc fixes (Andrew Kreimer, Danny Garside, eccoisle, Ed Craig-Wood, emyarod, jack, Jugal Kishore, Markus Gerstel, Michael Kebe, Nick Craig-Wood, simonmcnair, simwai, Zachary Vorhies) - fs: Fix corruption of SizeSuffix with "B" suffix in config (eg --min-size) (Nick Craig-Wood) - lib/http: Fix race between Serve() and Shutdown() (Nick Craig-Wood) - object: Fix memory object out of bounds Seek (Nick Craig-Wood) - operations: Fix call fmt.Errorf with wrong err (alingse) - rc - Disable the metrics server when running rclone rc (hiddenmarten) - Fix debug/* commands not being available over unix sockets (Nick Craig-Wood) - serve nfs: Fix unlikely crash (Nick Craig-Wood) - stats: Fix the speed not getting updated after a pause in the processing (Anagh Kumar Baranwal) - sync - Fix cpu spinning when empty directory finding with leading slashes (Nick Craig-Wood) - Copy dir modtimes even when copyEmptySrcDirs is false (ll3006) - VFS - Fix directory cache serving stale data (Lorenz Brun) - Fix inefficient directory caching when directory reads are slow (huanghaojun) - Fix integration test failures (Nick Craig-Wood) - Drive - Metadata: fix error when setting copy-requires-writer-permission on a folder (Nick Craig-Wood) - Dropbox - Retry link without expiry (Dave Vasilevsky) - HTTP - Correct root if definitely pointing to a file (nielash) - Iclouddrive - Fix so created files are writable (Ben Alex) - Onedrive - Fix metadata ordering in permissions (Nick Craig-Wood) v1.69.1 - 2025-02-14 See commits - Bug Fixes - lib/oauthutil: Fix redirect URL mismatch errors (Nick Craig-Wood) - bisync: Fix listings missing concurrent modifications (nielash) - serve s3: Fix list objects encoding-type (Nick Craig-Wood) - fs: Fix confusing "didn't find section in config file" error (Nick Craig-Wood) - doc fixes (Christoph Berger, Dimitri Papadopoulos, Matt Ickstadt, Nick Craig-Wood, Tim White, Zachary Vorhies) - build: Added parallel docker builds and caching for go build in the container (Anagh Kumar Baranwal) - VFS - Fix the cache failing to upload symlinks when --links was specified (Nick Craig-Wood) - Fix race detected by race detector (Nick Craig-Wood) - Close the change notify channel on Shutdown (izouxv) - B2 - Fix "fatal error: concurrent map writes" (Nick Craig-Wood) - Iclouddrive - Add notes on ADP and Missing PCS cookies (Nick Craig-Wood) - Onedrive - Mark German (de) region as deprecated (Nick Craig-Wood) - S3 - Added new storage class to magalu provider (Bruno Fernandes) - Add DigitalOcean regions SFO2, LON1, TOR1, BLR1 (jkpe) - Add latest Linode Object Storage endpoints (jbagwell-akamai) v1.69.0 - 2025-01-12 See commits - New backends - ICloud Drive (lostb1t) - Cloudinary (yuval-cloudinary) - New S3 providers: - Outscale (Matthias Gatto) - Selectel (Nick Craig-Wood) - Security fixes - serve sftp: Resolve CVE-2024-45337 - Misuse of ServerConfig.PublicKeyCallback may cause authorization bypass (dependabot) - Rclone was not vulnerable to this. - See https://github.com/advisories/GHSA-v778-237x-gjrc - build: Update golang.org/x/net to v0.33.0 to fix CVE-2024-45338 - Non-linear parsing of case-insensitive content (Nick Craig-Wood) - Rclone was not vulnerable to this. - See https://github.com/advisories/GHSA-w32m-9786-jp63 - New Features - accounting: Write the current bwlimit to the log on SIGUSR2 (Nick Craig-Wood) - bisync: Change exit code from 2 to 7 for critically aborted run (albertony) - build - Update all dependencies (Nick Craig-Wood) - Replace Windows-specific NewLazyDLL with NewLazySystemDLL (albertony) - cmd: Change exit code from 1 to 2 for syntax and usage errors (albertony) - docker serve: make sure all mount and VFS options are parsed (Nick Craig-Wood) - doc fixes (albertony, Alexandre Hamez, Anthony Metzidis, buengese, Dan McArdle, David Seifert, Francesco Frassinelli, Michael R. Davis, Nick Craig-Wood, Pawel Palucha, Randy Bush, remygrandin, Sam Harrison, shenpengfeng, tgfisher, Thomas ten Cate, ToM, Tony Metzidis, vintagefuture, Yxxx) - fs: Make --links flag global and add new --local-links and --vfs-links flags (Nick Craig-Wood) - http servers: Disable automatic authentication skipping for unix sockets in http servers (Moises Lima) - This was making it impossible to use unix sockets with an proxy - This might now cause rclone to need authentication where it didn't before - oauthutil: add support for OAuth client credential flow (Martin Hassack, Nick Craig-Wood) - operations: make log messages consistent for mkdir/rmdir at INFO level (Nick Craig-Wood) - rc: Add relative to vfs/queue-set-expiry (Nick Craig-Wood) - serve dlna: Sort the directory entries by directories first then alphabetically by name (Nick Craig-Wood) - serve nfs - Introduce symlink support (Nick Craig-Wood) - Implement --nfs-cache-type symlink (Nick Craig-Wood) - size: Make output compatible with -P (Nick Craig-Wood) - test makefiles: Add --flat flag for making directories with many entries (Nick Craig-Wood) - Bug Fixes - accounting - Fix global error acounting (Benjamin Legrand) - Fix debug printing when debug wasn't set (Nick Craig-Wood) - Fix race stopping/starting the stats counter (Nick Craig-Wood) - rc/job: Use mutex for adding listeners thread safety (hayden.pan) - serve docker: Fix incorrect GID assignment (TAKEI Yuya) - serve nfs: Fix missing inode numbers which was messing up ls -laR (Nick Craig-Wood) - serve s3: Fix Last-Modified timestamp (Nick Craig-Wood) - serve sftp: Fix loading of authorized keys file with comment on last line (albertony) - Mount - Introduce symlink support (Filipe Azevedo, Nick Craig-Wood) - Better snap mount error message (divinity76) - mount2: Fix missing . and .. entries (Filipe Azevedo) - VFS - With --vfs-used-is-size value is calculated and then thrown away (Ilias Ozgur Can Leonard) - Add symlink support to VFS (Filipe Azevedo, Nick Craig-Wood) - This can be enabled with the specific --vfs-links flag or the global --links flag - Fix open files disappearing from directory listings (Nick Craig-Wood) - Add remote name to vfs cache log messages (Nick Craig-Wood) - Cache - Fix parent not getting pinned when remote is a file (nielash) - Azure Blob - Add --azureblob-disable-instance-discovery (Nick Craig-Wood) - Add --azureblob-use-az to force the use of the Azure CLI for auth (Nick Craig-Wood) - Quit multipart uploads if the context is cancelled (Nick Craig-Wood) - Azurefiles - Fix missing x-ms-file-request-intent header (Nick Craig-Wood) - B2 - Add daysFromStartingToCancelingUnfinishedLargeFiles to backend lifecycle command (Louis Laureys) - Box - Fix server-side copying a file over existing dst (nielash) - Fix panic when decoding corrupted PEM from JWT file (Nick Craig-Wood) - Drive - Add support for markdown format (Noam Ross) - Implement rclone backend rescue to rescue orphaned files (Nick Craig-Wood) - Dropbox - Fix server side copying over existing object (Nick Craig-Wood) - Fix return status when full to be fatal error (Nick Craig-Wood) - FTP - Implement --ftp-no-check-upload to allow upload to write only dirs (Nick Craig-Wood) - Fix ls commands returning empty on "Microsoft FTP Service" servers (Francesco Frassinelli) - Gofile - Fix server side copying over existing object (Nick Craig-Wood) - Google Cloud Storage - Add access token auth with --gcs-access-token (Leandro Piccilli) - Update docs on service account access tokens (Anthony Metzidis) - Googlephotos - Implement --gphotos-proxy to allow download of full resolution media (Nick Craig-Wood) - Fix nil pointer crash on upload (Nick Craig-Wood) - HTTP - Fix incorrect URLs with initial slash (Oleg Kunitsyn) - Onedrive - Add support for OAuth client credential flow (Martin Hassack, Nick Craig-Wood) - Fix time precision for OneDrive personal (Nick Craig-Wood) - Fix server side copying over existing object (Nick Craig-Wood) - Opendrive - Add rclone about support to backend (quiescens) - Oracle Object Storage - Make specifying compartmentid optional (Manoj Ghosh) - Quit multipart uploads if the context is cancelled (Nick Craig-Wood) - Pikpak - Add option to use original file links (wiserain) - Protondrive - Improve performance of Proton Drive backend (Lawrence Murray) - Putio - Fix server side copying over existing object (Nick Craig-Wood) - S3 - Add initial --s3-directory-bucket to support AWS Directory Buckets (Nick Craig-Wood) - Add Wasabi eu-south-1 region (Diego Monti) - Fix download of compressed files from Cloudflare R2 (Nick Craig-Wood) - Rename glacier storage class to flexible retrieval (Henry Lee) - Quit multipart uploads if the context is cancelled (Nick Craig-Wood) - SFTP - Allow inline ssh public certificate for sftp (Dimitar Ivanov) - Fix nil check when using auth proxy (Nick Craig-Wood) - Smb - Add initial support for Kerberos authentication (more work needed). (Francesco Frassinelli) - Fix panic if stat fails (Nick Craig-Wood) - Sugarsync - Fix server side copying over existing object (Nick Craig-Wood) - WebDAV - Nextcloud: implement backoff and retry for 423 LOCKED errors (Nick Craig-Wood) - Make --webdav-auth-redirect to fix 401 unauthorized on redirect (Nick Craig-Wood) - Yandex - Fix server side copying over existing object (Nick Craig-Wood) - Zoho - Use download server to accelerate downloads (buengese) - Switch to large file upload API for larger files, fix missing URL encoding of filenames for the upload API (buengese) - Print clear error message when missing oauth scope (buengese) - Try to handle rate limits a bit better (buengese) - Add support for private spaces (buengese) - Make upload cutoff configurable (buengese) v1.68.2 - 2024-11-15 See commits - Security fixes - local backend: CVE-2024-52522: fix permission and ownership on symlinks with --links and --metadata (Nick Craig-Wood) - Only affects users using --metadata and --links and copying files to the local backend - See https://github.com/rclone/rclone/security/advisories/GHSA-hrxh-9w67-g4cv - build: bump github.com/golang-jwt/jwt/v4 from 4.5.0 to 4.5.1 (dependabot) - This is an issue in a dependency which is used for JWT certificates - See https://github.com/golang-jwt/jwt/security/advisories/GHSA-29wx-vh33-7x7r - Bug Fixes - accounting: Fix wrong message on SIGUSR2 to enable/disable bwlimit (Nick Craig-Wood) - bisync: Fix output capture restoring the wrong output for logrus (Dimitrios Slamaris) - dlna: Fix loggingResponseWriter disregarding log level (Simon Bos) - serve s3: Fix excess locking which was making serve s3 single threaded (Nick Craig-Wood) - doc fixes (Nick Craig-Wood, tgfisher, Alexandre Hamez, Randy Bush) - Local - Fix permission and ownership on symlinks with --links and --metadata (Nick Craig-Wood) - Fix --copy-links on macOS when cloning (nielash) - Onedrive - Fix Retry-After handling to look at 503 errors also (Nick Craig-Wood) - Pikpak - Fix cid/gcid calculations for fs.OverrideRemote (wiserain) - Fix fatal crash on startup with token that can't be refreshed (Nick Craig-Wood) - S3 - Fix crash when using --s3-download-url after migration to SDKv2 (Nick Craig-Wood) - Storj provider: fix server-side copy of files bigger than 5GB (Kaloyan Raev) - Fix multitenant multipart uploads with CEPH (Nick Craig-Wood) v1.68.1 - 2024-09-24 See commits - Bug Fixes - build: Fix docker release build (ttionya) - doc fixes (Nick Craig-Wood, Pawel Palucha) - fs - Fix --dump filters not always appearing (Nick Craig-Wood) - Fix setting stringArray config values from environment variables (Nick Craig-Wood) - rc: Fix default value of --metrics-addr (Nick Craig-Wood) - serve docker: Add missing vfs-read-chunk-streams option in docker volume driver (Divyam) - Onedrive - Fix spurious "Couldn't decode error response: EOF" DEBUG (Nick Craig-Wood) - Pikpak - Fix login issue where token retrieval fails (wiserain) - S3 - Fix rclone ignoring static credentials when env_auth=true (Nick Craig-Wood) v1.68.0 - 2024-09-08 See commits - New backends - Files.com (Sam Harrison) - Gofile (Nick Craig-Wood) - Pixeldrain (Fornax) - Changed backends - S3 backend updated to use AWS SDKv2 as v1 is now unsupported. - The matrix of providers and auth methods is huge and there could be problems with obscure combinations. - Please report problems in a new issue on Github. - New commands - config encryption: set, remove and check to manage config file encryption (Nick Craig-Wood) - New Features - build - Update to go1.23 and make go1.21 the minimum required version (Nick Craig-Wood) - Update all dependencies (Nick Craig-Wood) - Disable wasm/js build due to go bug #64856 (Nick Craig-Wood) - Enable custom linting rules with ruleguard via gocritic (albertony) - Update logging statements to make --use-json-log work always (albertony) - Adding new code quality tests and fixing the fallout (albertony) - config - Internal config re-organised to be more consistent and make it available from the rc (Nick Craig-Wood) - Avoid remotes with empty names from the environment (albertony) - Make listing of remotes more consistent (albertony) - Make getting config values more consistent (albertony) - Use --password-command to set config file password if supplied (Nick Craig-Wood) - doc fixes (albertony, crystalstall, David Seifert, Eng Zer Jun, Ernie Hershey, Florian Klink, John Oxley, kapitainsky, Mathieu Moreau, Nick Craig-Wood, nipil, Pétr Bozsó, Russ Bubley, Sam Harrison, Thearas, URenko, Will Miles, yuval-cloudinary) - fs: Allow semicolons as well as spaces in --bwlimit timetable parsing (Kyle Reynolds) - help - Global flags help command now takes glob filter (albertony) - Make help command output less distracting (albertony) - lib/encoder: Add Raw encoding for use where no encoding at all is required, eg --local-encoding Raw (URenko) - listremotes: Added options for filtering, ordering and json output (albertony) - nfsmount - Make the --sudo flag work for umount as well as mount (Nick Craig-Wood) - Add -o tcp option to NFS mount options to fix mounting under Linux (Nick Craig-Wood) - operations: copy: generate stable partial suffix (Georg Welzel) - rc - Add options/info call to enumerate options (Nick Craig-Wood) - Add option blocks parameter to options/get and options/info (Nick Craig-Wood) - Add vfs/queue to show the status of the upload queue (Nick Craig-Wood) - Add vfs/queue-set-expiry to adjust expiry of items in the VFS queue (Nick Craig-Wood) - Add --unix-socket option to rc command (Florian Klink) - Prevent unmount rc command from sending a STOPPING=1 sd-notify message (AThePeanut4) - rcserver: Implement prometheus metrics on a dedicated port (Oleg Kunitsyn) - serve dlna - Also look at "Subs" subdirectory (Florian Klink) - Don't swallow video.{idx,sub} (Florian Klink) - Set more correct mime type (Florian Klink) - serve nfs - Implement on disk cache for file handles selected with --nfs-cache-type (Nick Craig-Wood) - Add tracing to filesystem calls (Nick Craig-Wood) - Mask unimplemented error from chmod (Nick Craig-Wood) - Unify the nfs library logging with rclone's logging better (Nick Craig-Wood) - Fix incorrect user id and group id exported to NFS (Nick Craig-Wood) - serve s3 - Implement --auth-proxy (Sawjan Gurung) - Update to AWS SDKv2 by updating github.com/rclone/gofakes3 (Nick Craig-Wood) - Bug Fixes - bisync: Fix sync time problems with backends that round time (eg Dropbox) (nielash) - serve dlna: Fix panic: invalid argument to Int63n (Nick Craig-Wood) - VFS - Add --vfs-read-chunk-streams to parallel read chunks from files (Nick Craig-Wood) - This can increase mount performance on high bandwidth or large latency links - Fix cache encoding with special characters (URenko) - Local - Fix encoding of root path fix (URenko) - Add server-side copy (using clone) with xattrs on macOS (nielash) - --local-no-clone flag to disable cloning for server-side copies (nielash) - Support setting custom --metadata during server-side Copy (nielash) - Azure Blob - Allow anonymous access for public resources (Nick Craig-Wood) - B2 - Include custom upload headers in large file info (Pat Patterson) - Drive - Fix copying Google Docs to a backend which only supports SHA1 (Nick Craig-Wood) - Fichier - Fix detection of Flood Detected error (Nick Craig-Wood) - Fix server side move (Nick Craig-Wood) - HTTP - Reload client certificates on expiry (Saleh Dindar) - Support listening on passed FDs (Florian Klink) - Jottacloud - Fix setting of metadata on server side move (albertony) - Onedrive - Fix nil pointer error when uploading small files (Nick Craig-Wood) - Pcloud - Implement SetModTime (Georg Welzel) - Implement OpenWriterAt feature to enable multipart uploads (Georg Welzel) - Fix failing large file uploads (Georg Welzel) - Pikpak - Improve data consistency by ensuring async tasks complete (wiserain) - Implement custom hash to replace wrong sha1 (wiserain) - Fix error with copyto command (wiserain) - Optimize file move by removing unnecessary readMetaData() call (wiserain) - Non-buffered hash calculation for local source files (wiserain) - Optimize upload by pre-fetching gcid from API (wiserain) - Correct file transfer progress for uploads by hash (wiserain) - Update to using AWS SDK v2 (wiserain) - S3 - Update to using AWS SDK v2 (Nick Craig-Wood) - Add --s3-sdk-log-mode to control SDKv2 debugging (Nick Craig-Wood) - Fix incorrect region for Magalu provider (Filipe Herculano) - Allow restoring from intelligent-tiering storage class (Pawel Palucha) - SFTP - Use uint32 for mtime to save memory (Tomasz Melcer) - Ignore useless errors when closing the connection pool (Nick Craig-Wood) - Support listening on passed FDs (Florian Klink) - Swift - Add workarounds for bad listings in Ceph RGW (Paul Collins) - Add total/free space info in about command. (fsantagostinobietti) - Ulozto - Fix upload of > 2GB files on 32 bit platforms (Tobias Markus) - WebDAV - Add --webdav-unix-socket-path to connect to a unix socket (Florian Klink) - Yandex - Implement custom user agent to help with upload speeds (Sebastian Bünger) - Zoho - Fix inefficiencies uploading with new API to avoid throttling (Nick Craig-Wood) v1.67.0 - 2024-06-14 See commits - New backends - uloz.to (iotmaestro) - New S3 providers - Magalu Object Storage (Bruno Fernandes) - New commands - gitannex: Enables git-annex to store and retrieve content from an rclone remote (Dan McArdle) - New Features - accounting: Add deleted files total size to status summary line (Kyle Reynolds) - build - Fix CVE-2023-45288 by upgrading golang.org/x/net (Nick Craig-Wood) - Fix CVE-2024-35255 by upgrading github.com/Azure/azure-sdk-for-go/sdk/azidentity to 1.6.0 (dependabot) - Convert source files with CRLF to LF (albertony) - Update all dependencies (Nick Craig-Wood) - doc updates (albertony, Alex Garel, Dave Nicolson, Dominik Joe Pantůček, Eric Wolf, Erisa A, Evan Harris, Evan McBeth, Gachoud Philippe, hidewrong, jakzoe, jumbi77, kapitainsky, Kyle Reynolds, Lewis Hook, Nick Craig-Wood, overallteach, pawsey-kbuckley, Pieter van Oostrum, psychopatt, racerole, static-moonlight, Warrentheo, yudrywet, yumeiyin ) - ncdu: Do not quit on Esc to aid usability (Katia Esposito) - rcserver: Set ModTime for dirs and files served by --rc-serve (Nikita Shoshin) - Bug Fixes - bisync: Add integration tests against all backends and fix many many problems (nielash) - config: Fix default value for description (Nick Craig-Wood) - copy: Fix nil pointer dereference when corrupted on transfer with nil dst (nielash) - fs - Improve JSON Unmarshalling for Duration types (Kyle Reynolds) - Close the CPU profile on exit (guangwu) - Replace /bin/bash with /usr/bin/env bash (Florian Klink) - oauthutil: Clear client secret if client ID is set (Michael Terry) - operations - Rework rcat so that it doesn't call the --metadata-mapper twice (Nick Craig-Wood) - Ensure SrcFsType is set correctly when using --metadata-mapper (Nick Craig-Wood) - Fix "optional feature not implemented" error with a crypted sftp bug (Nick Craig-Wood) - Fix very long file names when using copy with --partial (Nick Craig-Wood) - Fix retries downloading too much data with certain backends (Nick Craig-Wood) - Fix move when dst is nil and fdst is case-insensitive (nielash) - Fix lsjson --encrypted when using --crypt-XXX parameters (Nick Craig-Wood) - Fix missing metadata for multipart transfers to local disk (Nick Craig-Wood) - Fix incorrect modtime on some multipart transfers (Nick Craig-Wood) - Fix hashing problem in integration tests (Nick Craig-Wood) - rc - Fix stats groups being ignored in operations/check (Nick Craig-Wood) - Fix incorrect Content-Type in HTTP API (Kyle Reynolds) - serve s3 - Fix Last-Modified header format (Butanediol) - Fix in-memory metadata storing wrong modtime (nielash) - Fix XML of error message (Nick Craig-Wood) - serve webdav: Fix webdav with --baseurl under Windows (Nick Craig-Wood) - serve dlna: Make BrowseMetadata more compliant (albertony) - serve http: Added Content-Length header when HTML directory is served (Sunny) - sync - Don't sync directories if they haven't been modified (Nick Craig-Wood) - Don't test reading metadata if we can't write it (Nick Craig-Wood) - Fix case normalisation (problem on on s3) (Nick Craig-Wood) - Fix management of empty directories to make it more accurate (Nick Craig-Wood) - Fix creation of empty directories when --create-empty-src-dirs=false (Nick Craig-Wood) - Fix directory modification times not being set (Nick Craig-Wood) - Fix "failed to update directory timestamp or metadata: directory not found" (Nick Craig-Wood) - Fix expecting SFTP to have MkdirMetadata method: optional feature not implemented (Nick Craig-Wood) - test info: Improve cleanup of temp files (Kyle Reynolds) - touch: Fix using -R on certain backends (Nick Craig-Wood) - Mount - Add --direct-io flag to force uncached access (Nick Craig-Wood) - VFS - Fix download loop when file size shrunk (Nick Craig-Wood) - Fix renaming a directory (nielash) - Local - Add --local-time-type to use mtime/atime/btime/ctime as the time (Nick Craig-Wood) - Allow SeBackupPrivilege and/or SeRestorePrivilege to work on Windows (Charles Hamilton) - Azure Blob - Fix encoding issue with dir path comparison (nielash) - B2 - Add new cleanup and cleanup-hidden backend commands. (Pat Patterson) - Update B2 URLs to new home (Nick Craig-Wood) - Chunker - Fix startup when root points to composite multi-chunk file without metadata (nielash) - Fix case-insensitive comparison on local without metadata (nielash) - Fix "finalizer already set" error (nielash) - Drive - Add backend query command for general purpose querying of files (John-Paul Smith) - Stop sending notification emails when setting permissions (Nick Craig-Wood) - Fix server side copy with metadata from my drive to shared drive (Nick Craig-Wood) - Set all metadata permissions and return error summary instead of stopping on the first error (Nick Craig-Wood) - Make errors setting permissions into no retry errors (Nick Craig-Wood) - Fix description being overwritten on server side moves (Nick Craig-Wood) - Allow setting metadata to fail if failok flag is set (Nick Craig-Wood) - Fix panic when using --metadata-mapper on large google doc files (Nick Craig-Wood) - Dropbox - Add --dropbox-root-namespace to override the root namespace (Bill Fraser) - Google Cloud Storage - Fix encoding issue with dir path comparison (nielash) - Hdfs - Fix f.String() not including subpath (nielash) - Http - Add --http-no-escape to not escape URL metacharacters in path names (Kyle Reynolds) - Jottacloud - Set metadata on server side copy and move (albertony) - Linkbox - Fix working with names longer than 8-25 Unicode chars. (Vitaly) - Fix list paging and optimized synchronization. (gvitali) - Mailru - Attempt to fix throttling by increasing min sleep to 100ms (Nick Craig-Wood) - Memory - Fix dst mutating src after server-side copy (nielash) - Fix deadlock in operations.Purge (nielash) - Fix incorrect list entries when rooted at subdirectory (nielash) - Onedrive - Add --onedrive-hard-delete to permanently delete files (Nick Craig-Wood) - Make server-side copy work in more scenarios (YukiUnHappy) - Fix "unauthenticated: Unauthenticated" errors when downloading (Nick Craig-Wood) - Fix --metadata-mapper being called twice if writing permissions (nielash) - Set all metadata permissions and return error summary instead of stopping on the first error (nielash) - Make errors setting permissions into no retry errors (Nick Craig-Wood) - Skip writing permissions with 'owner' role (nielash) - Fix references to deprecated permissions properties (nielash) - Add support for group permissions (nielash) - Allow setting permissions to fail if failok flag is set (Nick Craig-Wood) - Pikpak - Make getFile() usage more efficient to avoid the download limit (wiserain) - Improve upload reliability and resolve potential file conflicts (wiserain) - Implement configurable chunk size for multipart upload (wiserain) - Protondrive - Don't auth with an empty access token (Michał Dzienisiewicz) - Qingstor - Disable integration tests as test account suspended (Nick Craig-Wood) - Quatrix - Fix f.String() not including subpath (nielash) - S3 - Add new AWS region il-central-1 Tel Aviv (yoelvini) - Update Scaleway's configuration options (Alexandre Lavigne) - Ceph: fix quirks when creating buckets to fix trying to create an existing bucket (Thomas Schneider) - Fix encoding issue with dir path comparison (nielash) - Fix 405 error on HEAD for delete marker with versionId (nielash) - Validate --s3-copy-cutoff size before copy (hoyho) - SFTP - Add --sftp-connections to limit the maximum number of connections (Tomasz Melcer) - Storj - Update storj.io/uplink to latest release (JT Olio) - Update bio on request (Nick Craig-Wood) - Swift - Implement --swift-use-segments-container to allow >5G files on Blomp (Nick Craig-Wood) - Union - Fix deleting dirs when all remotes can't have empty dirs (Nick Craig-Wood) - WebDAV - Fix setting modification times erasing checksums on owncloud and nextcloud (nielash) - owncloud: Add --webdav-owncloud-exclude-mounts which allows excluding mounted folders when listing remote resources (Thomas Müller) - Zoho - Fix throttling problem when uploading files (Nick Craig-Wood) - Use cursor listing for improved performance (Nick Craig-Wood) - Retry reading info after upload if size wasn't returned (Nick Craig-Wood) - Remove simple file names complication which is no longer needed (Nick Craig-Wood) - Sleep for 60 seconds if rate limit error received (Nick Craig-Wood) v1.66.0 - 2024-03-10 See commits - Major features - Rclone will now sync directory modification times if the backend supports it. - This can be disabled with --no-update-dir-modtime - See the overview and look for the D flags in the ModTime column to see which backends support it. - Rclone will now sync directory metadata if the backend supports it when -M/--metadata is in use. - See the overview and look for the D flags in the Metadata column to see which backends support it. - Bisync has received many updates see below for more details or bisync's changelog - Removed backends - amazonclouddrive: Remove Amazon Drive backend code and docs (Nick Craig-Wood) - New Features - backend - Add description field for all backends (Paul Stern) - build - Update to go1.22 and make go1.20 the minimum required version (Nick Craig-Wood) - Fix CVE-2024-24786 by upgrading google.golang.org/protobuf (Nick Craig-Wood) - check: Respect --no-unicode-normalization and --ignore-case-sync for --checkfile (nielash) - cmd: Much improved shell auto completion which reduces the size of the completion file and works faster (Nick Craig-Wood) - doc updates (albertony, ben-ba, Eli, emyarod, huajin tong, Jack Provance, kapitainsky, keongalvin, Nick Craig-Wood, nielash, rarspace01, rzitzer, Tera, Vincent Murphy) - fs: Add more detailed logging for file includes/excludes (Kyle Reynolds) - lsf - Add --time-format flag (nielash) - Make metadata appear for directories (Nick Craig-Wood) - lsjson: Make metadata appear for directories (Nick Craig-Wood) - rc - Add srcFs and dstFs to core/stats and core/transferred stats (Nick Craig-Wood) - Add operations/hashsum to the rc as rclone hashsum equivalent (Nick Craig-Wood) - Add config/paths to the rc as rclone config paths equivalent (Nick Craig-Wood) - sync - Optionally report list of synced paths to file (nielash) - Implement directory sync for mod times and metadata (Nick Craig-Wood) - Don't set directory modtimes if already set (nielash) - Don't sync directory modtimes from backends which don't have directories (Nick Craig-Wood) - Bug Fixes - backend - Make backends which use oauth implement the Shutdown and shutdown the oauth properly (rkonfj) - bisync - Handle unicode and case normalization consistently (nielash) - Partial uploads known issue on local/ftp/sftp has been resolved (unless using --inplace) (nielash) - Fixed handling of unicode normalization and case insensitivity, support for --fix-case, --ignore-case-sync, --no-unicode-normalization (nielash) - Bisync no longer fails to find the correct listing file when configs are overridden with backend-specific flags. (nielash) - nfsmount - Fix exit after external unmount (nielash) - Fix --volname being ignored (nielash) - operations - Fix renaming a file on macOS (nielash) - Fix case-insensitive moves in operations.Move (nielash) - Fix TestCaseInsensitiveMoveFileDryRun on chunker integration tests (nielash) - Fix TestMkdirModTime test (Nick Craig-Wood) - Fix TestSetDirModTime for backends with SetDirModTime but not Metadata (Nick Craig-Wood) - Fix typo in log messages (nielash) - serve nfs: Fix writing files via Finder on macOS (nielash) - serve restic: Fix error handling (Michael Eischer) - serve webdav: Fix --baseurl without leading / (Nick Craig-Wood) - stats: Fix race between ResetCounters and stopAverageLoop called from time.AfterFunc (Nick Craig-Wood) - sync - --fix-case flag to rename case insensitive dest (nielash) - Use operations.DirMove instead of sync.MoveDir for --fix-case (nielash) - systemd: Fix detection and switch to the coreos package everywhere rather than having 2 separate libraries (Anagh Kumar Baranwal) - Mount - Fix macOS not noticing errors with --daemon (Nick Craig-Wood) - Notice daemon dying much quicker (Nick Craig-Wood) - VFS - Fix unicode normalization on macOS (nielash) - Bisync - Copies and deletes are now handled in one operation instead of two (nielash) - --track-renames and --backup-dir are now supported (nielash) - Final listings are now generated from sync results, to avoid needing to re-list (nielash) - Bisync is now much more resilient to changes that happen during a bisync run, and far less prone to critical errors / undetected changes (nielash) - Bisync is now capable of rolling a file listing back in cases of uncertainty, essentially marking the file as needing to be rechecked next time. (nielash) - A few basic terminal colors are now supported, controllable with --color (AUTO|NEVER|ALWAYS) (nielash) - Initial listing snapshots of Path1 and Path2 are now generated concurrently, using the same "march" infrastructure as check and sync, for performance improvements and less risk of error. (nielash) - --resync is now much more efficient (especially for users of --create-empty-src-dirs) (nielash) - Google Docs (and other files of unknown size) are now supported (with the same options as in sync) (nielash) - Equality checks before a sync conflict rename now fall back to cryptcheck (when possible) or --download, (nielash) instead of of --size-only, when check is not available. - Bisync now fully supports comparing based on any combination of size, modtime, and checksum, lifting the prior restriction on backends without modtime support. (nielash) - Bisync now supports a "Graceful Shutdown" mode to cleanly cancel a run early without requiring --resync. (nielash) - New --recover flag allows robust recovery in the event of interruptions, without requiring --resync. (nielash) - A new --max-lock setting allows lock files to automatically renew and expire, for better automatic recovery when a run is interrupted. (nielash) - Bisync now supports auto-resolving sync conflicts and customizing rename behavior with new --conflict-resolve, --conflict-loser, and --conflict-suffix flags. (nielash) - A new --resync-mode flag allows more control over which version of a file gets kept during a --resync. (nielash) - Bisync now supports --retries and --retries-sleep (when --resilient is set.) (nielash) - Clarify file operation directions in dry-run logs (Kyle Reynolds) - Local - Fix cleanRootPath on Windows after go1.21.4 stdlib update (nielash) - Implement setting modification time on directories (nielash) - Implement modtime and metadata for directories (Nick Craig-Wood) - Fix setting of btime on directories on Windows (Nick Craig-Wood) - Delete backend implementation of Purge to speed up and make stats (Nick Craig-Wood) - Support metadata setting and mapping on server side Move (Nick Craig-Wood) - Cache - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - Crypt - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - Improve handling of undecryptable file names (nielash) - Add missing error check spotted by linter (Nick Craig-Wood) - Azure Blob - Implement --azureblob-delete-snapshots (Nick Craig-Wood) - B2 - Clarify exactly what --b2-download-auth-duration does in the docs (Nick Craig-Wood) - Chunker - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - Combine - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - Fix directory metadata error on upstream root (nielash) - Fix directory move across upstreams (nielash) - Compress - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - Drive - Implement setting modification time on directories (nielash) - Implement modtime and metadata setting for directories (Nick Craig-Wood) - Support metadata setting and mapping on server side Move,Copy (Nick Craig-Wood) - FTP - Fix mkdir with rsftp which is returning the wrong code (Nick Craig-Wood) - Hasher - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - Fix error from trying to stop an already-stopped db (nielash) - Look for cached hash if passed hash unexpectedly blank (nielash) - Imagekit - Updated docs and web content (Harshit Budhraja) - Updated overview - supported operations (Harshit Budhraja) - Mega - Fix panic with go1.22 (Nick Craig-Wood) - Netstorage - Fix Root to return correct directory when pointing to a file (Nick Craig-Wood) - Onedrive - Add metadata support (nielash) - Opendrive - Fix moving file/folder within the same parent dir (nielash) - Oracle Object Storage - Support backend restore command (Nikhil Ahuja) - Support workload identity authentication for OKE (Anders Swanson) - Protondrive - Fix encoding of Root method (Nick Craig-Wood) - Quatrix - Fix Content-Range header (Volodymyr) - Add option to skip project folders (Oksana Zhykina) - Fix Root to return correct directory when pointing to a file (Nick Craig-Wood) - S3 - Add --s3-version-deleted to show delete markers in listings when using versions. (Nick Craig-Wood) - Add IPv6 support with option --s3-use-dual-stack (Anthony Metzidis) - Copy parts in parallel when doing chunked server side copy (Nick Craig-Wood) - GCS provider: fix server side copy of files bigger than 5G (Nick Craig-Wood) - Support metadata setting and mapping on server side Copy (Nick Craig-Wood) - Seafile - Fix download/upload error when FILE_SERVER_ROOT is relative (DanielEgbers) - Fix Root to return correct directory when pointing to a file (Nick Craig-Wood) - SFTP - Implement setting modification time on directories (nielash) - Set directory modtimes update on write flag (Nick Craig-Wood) - Shorten wait delay for external ssh binaries now that we are using go1.20 (Nick Craig-Wood) - Swift - Avoid unnecessary container versioning check (Joe Cai) - Union - Implement setting modification time on directories (if supported by wrapped remote) (nielash) - Implement setting metadata on directories (Nick Craig-Wood) - WebDAV - Reduce priority of chunks upload log (Gabriel Ramos) - owncloud: Add config owncloud_exclude_shares which allows to exclude shared files and folders when listing remote resources (Thomas Müller) v1.65.2 - 2024-01-24 See commits - Bug Fixes - build: bump github.com/cloudflare/circl from 1.3.6 to 1.3.7 (dependabot) - docs updates (Nick Craig-Wood, kapitainsky, nielash, Tera, Harshit Budhraja) - VFS - Fix stale data when using --vfs-cache-mode full (Nick Craig-Wood) - Azure Blob - IMPORTANT Fix data corruption bug - see #7590 (Nick Craig-Wood) v1.65.1 - 2024-01-08 See commits - Bug Fixes - build - Bump golang.org/x/crypto to fix ssh terrapin CVE-2023-48795 (dependabot) - Update to go1.21.5 to fix Windows path problems (Nick Craig-Wood) - Fix docker build on arm/v6 (Nick Craig-Wood) - install.sh: fix harmless error message on install (Nick Craig-Wood) - accounting: fix stats to show server side transfers (Nick Craig-Wood) - doc fixes (albertony, ben-ba, Eli Orzitzer, emyarod, keongalvin, rarspace01) - nfsmount: Compile for all unix oses, add --sudo and fix error/option handling (Nick Craig-Wood) - operations: Fix files moved by rclone move not being counted as transfers (Nick Craig-Wood) - oauthutil: Avoid panic when *token and *ts.token are the same (rkonfj) - serve s3: Fix listing oddities (Nick Craig-Wood) - VFS - Note that --vfs-refresh runs in the background (Nick Craig-Wood) - Azurefiles - Fix storage base url (Oksana) - Crypt - Fix rclone move a file over itself deleting the file (Nick Craig-Wood) - Chunker - Fix rclone move a file over itself deleting the file (Nick Craig-Wood) - Compress - Fix rclone move a file over itself deleting the file (Nick Craig-Wood) - Dropbox - Fix used space on dropbox team accounts (Nick Craig-Wood) - FTP - Fix multi-thread copy (WeidiDeng) - Googlephotos - Fix nil pointer exception when batch failed (Nick Craig-Wood) - Hasher - Fix rclone move a file over itself deleting the file (Nick Craig-Wood) - Fix invalid memory address error when MaxAge == 0 (nielash) - Onedrive - Fix error listing: unknown object type (Nick Craig-Wood) - Fix "unauthenticated: Unauthenticated" errors when uploading (Nick Craig-Wood) - Oracleobjectstorage - Fix object storage endpoint for custom endpoints (Manoj Ghosh) - Multipart copy create bucket if it doesn't exist. (Manoj Ghosh) - Protondrive - Fix CVE-2023-45286 / GHSA-xwh9-gc39-5298 (Nick Craig-Wood) - S3 - Fix crash if no UploadId in multipart upload (Nick Craig-Wood) - Smb - Fix shares not listed by updating go-smb2 (halms) - Union - Fix rclone move a file over itself deleting the file (Nick Craig-Wood) v1.65.0 - 2023-11-26 See commits - New backends - Azure Files (karan, moongdal, Nick Craig-Wood) - ImageKit (Abhinav Dhiman) - Linkbox (viktor, Nick Craig-Wood) - New commands - serve s3: Let rclone act as an S3 compatible server (Mikubill, Artur Neumann, Saw-jan, Nick Craig-Wood) - nfsmount: mount command to provide mount mechanism on macOS without FUSE (Saleh Dindar) - serve nfs: to serve a remote for use by nfsmount (Saleh Dindar) - New Features - install.sh: Clean up temp files in install script (Jacob Hands) - build - Update all dependencies (Nick Craig-Wood) - Refactor version info and icon resource handling on windows (albertony) - doc updates (albertony, alfish2000, asdffdsazqqq, Dimitri Papadopoulos, Herby Gillot, Joda Stößer, Manoj Ghosh, Nick Craig-Wood) - Implement --metadata-mapper to transform metadata with a user supplied program (Nick Craig-Wood) - Add ChunkWriterDoesntSeek feature flag and set it for b2 (Nick Craig-Wood) - lib/http: Export basic go string functions for use in --template (Gabriel Espinoza) - makefile: Use POSIX compatible install arguments (Mina Galić) - operations - Use less memory when doing multithread uploads (Nick Craig-Wood) - Implement --partial-suffix to control extension of temporary file names (Volodymyr) - rc - Add operations/check to the rc API (Nick Craig-Wood) - Always report an error as JSON (Nick Craig-Wood) - Set Last-Modified header for files served by --rc-serve (Nikita Shoshin) - size: Dont show duplicate object count when less than 1k (albertony) - Bug Fixes - fshttp: Fix --contimeout being ignored (你知道未来吗) - march: Fix excessive parallelism when using --no-traverse (Nick Craig-Wood) - ncdu: Fix crash when re-entering changed directory after rescan (Nick Craig-Wood) - operations - Fix overwrite of destination when multi-thread transfer fails (Nick Craig-Wood) - Fix invalid UTF-8 when truncating file names when not using --inplace (Nick Craig-Wood) - serve dnla: Fix crash on graceful exit (wuxingzhong) - Mount - Disable mount for freebsd and alias cmount as mount on that platform (Nick Craig-Wood) - VFS - Add --vfs-refresh flag to read all the directories on start (Beyond Meat) - Implement Name() method in WriteFileHandle and ReadFileHandle (Saleh Dindar) - Add go-billy dependency and make sure vfs.Handle implements billy.File (Saleh Dindar) - Error out early if can't upload 0 length file (Nick Craig-Wood) - Local - Fix copying from Windows Volume Shadows (Nick Craig-Wood) - Azure Blob - Add support for cold tier (Ivan Yanitra) - B2 - Implement "rclone backend lifecycle" to read and set bucket lifecycles (Nick Craig-Wood) - Implement --b2-lifecycle to control lifecycle when creating buckets (Nick Craig-Wood) - Fix listing all buckets when not needed (Nick Craig-Wood) - Fix multi-thread upload with copyto going to wrong name (Nick Craig-Wood) - Fix server side chunked copy when file size was exactly --b2-copy-cutoff (Nick Craig-Wood) - Fix streaming chunked files an exact multiple of chunk size (Nick Craig-Wood) - Box - Filter more EventIDs when polling (David Sze) - Add more logging for polling (David Sze) - Fix performance problem reading metadata for single files (Nick Craig-Wood) - Drive - Add read/write metadata support (Nick Craig-Wood) - Add support for SHA-1 and SHA-256 checksums (rinsuki) - Add --drive-show-all-gdocs to allow unexportable gdocs to be server side copied (Nick Craig-Wood) - Add a note that --drive-scope accepts comma-separated list of scopes (Keigo Imai) - Fix error updating created time metadata on existing object (Nick Craig-Wood) - Fix integration tests by enabling metadata support from the context (Nick Craig-Wood) - Dropbox - Factor batcher into lib/batcher (Nick Craig-Wood) - Fix missing encoding for rclone purge (Nick Craig-Wood) - Google Cloud Storage - Fix 400 Bad request errors when using multi-thread copy (Nick Craig-Wood) - Googlephotos - Implement batcher for uploads (Nick Craig-Wood) - Hdfs - Added support for list of namenodes in hdfs remote config (Tayo-pasedaRJ) - HTTP - Implement set backend command to update running backend (Nick Craig-Wood) - Enable methods used with WebDAV (Alen Šiljak) - Jottacloud - Add support for reading and writing metadata (albertony) - Onedrive - Implement ListR method which gives --fast-list support (Nick Craig-Wood) - This must be enabled with the --onedrive-delta flag - Quatrix - Add partial upload support (Oksana Zhykina) - Overwrite files on conflict during server-side move (Oksana Zhykina) - S3 - Add Linode provider (Nick Craig-Wood) - Add docs on how to add a new provider (Nick Craig-Wood) - Fix no error being returned when creating a bucket we don't own (Nick Craig-Wood) - Emit a debug message if anonymous credentials are in use (Nick Craig-Wood) - Add --s3-disable-multipart-uploads flag (Nick Craig-Wood) - Detect looping when using gcs and versions (Nick Craig-Wood) - SFTP - Implement --sftp-copy-is-hardlink to server side copy as hardlink (Nick Craig-Wood) - Smb - Fix incorrect about size by switching to github.com/cloudsoda/go-smb2 fork (Nick Craig-Wood) - Fix modtime of multithread uploads by setting PartialUploads (Nick Craig-Wood) - WebDAV - Added an rclone vendor to work with rclone serve webdav (Adithya Kumar) v1.64.2 - 2023-10-19 See commits - Bug Fixes - selfupdate: Fix "invalid hashsum signature" error (Nick Craig-Wood) - build: Fix docker build running out of space (Nick Craig-Wood) v1.64.1 - 2023-10-17 See commits - Bug Fixes - cmd: Make --progress output logs in the same format as without (Nick Craig-Wood) - docs fixes (Dimitri Papadopoulos Orfanos, Herby Gillot, Manoj Ghosh, Nick Craig-Wood) - lsjson: Make sure we set the global metadata flag too (Nick Craig-Wood) - operations - Ensure concurrency is no greater than the number of chunks (Pat Patterson) - Fix OpenOptions ignored in copy if operation was a multiThreadCopy (Vitor Gomes) - Fix error message on delete to have file name (Nick Craig-Wood) - serve sftp: Return not supported error for not supported commands (Nick Craig-Wood) - build: Upgrade golang.org/x/net to v0.17.0 to fix HTTP/2 rapid reset (Nick Craig-Wood) - pacer: Fix b2 deadlock by defaulting max connections to unlimited (Nick Craig-Wood) - Mount - Fix automount not detecting drive is ready (Nick Craig-Wood) - VFS - Fix update dir modification time (Saleh Dindar) - Azure Blob - Fix "fatal error: concurrent map writes" (Nick Craig-Wood) - B2 - Fix multipart upload: corrupted on transfer: sizes differ XXX vs 0 (Nick Craig-Wood) - Fix locking window when getting multipart upload URL (Nick Craig-Wood) - Fix server side copies greater than 4GB (Nick Craig-Wood) - Fix chunked streaming uploads (Nick Craig-Wood) - Reduce default --b2-upload-concurrency to 4 to reduce memory usage (Nick Craig-Wood) - Onedrive - Fix the configurator to allow /teams/ID in the config (Nick Craig-Wood) - Oracleobjectstorage - Fix OpenOptions being ignored in uploadMultipart with chunkWriter (Nick Craig-Wood) - S3 - Fix slice bounds out of range error when listing (Nick Craig-Wood) - Fix OpenOptions being ignored in uploadMultipart with chunkWriter (Vitor Gomes) - Storj - Update storj.io/uplink to v1.12.0 (Kaloyan Raev) v1.64.0 - 2023-09-11 See commits - New backends - Proton Drive (Chun-Hung Tseng) - Quatrix (Oksana, Volodymyr Kit) - New S3 providers - Synology C2 (BakaWang) - Leviia (Benjamin) - New Jottacloud providers - Onlime (Fjodor42) - Telia Sky (NoLooseEnds) - Major changes - Multi-thread transfers (Vitor Gomes, Nick Craig-Wood, Manoj Ghosh, Edwin Mackenzie-Owen) - Multi-thread transfers are now available when transferring to: - local, s3, azureblob, b2, oracleobjectstorage and smb - This greatly improves transfer speed between two network sources. - In memory buffering has been unified between all backends and should share memory better. - See --multi-thread docs for more info - New commands - rclone config redacted support mechanism for showing redacted config (Nick Craig-Wood) - New Features - accounting - Show server side stats in own lines and not as bytes transferred (Nick Craig-Wood) - bisync - Add new --ignore-listing-checksum flag to distinguish from --ignore-checksum (nielash) - Add experimental --resilient mode to allow recovery from self-correctable errors (nielash) - Add support for --create-empty-src-dirs (nielash) - Dry runs no longer commit filter changes (nielash) - Enforce --check-access during --resync (nielash) - Apply filters correctly during deletes (nielash) - Equality check before renaming (leave identical files alone) (nielash) - Fix dryRun rc parameter being ignored (nielash) - build - Update to go1.21 and make go1.19 the minimum required version (Anagh Kumar Baranwal, Nick Craig-Wood) - Update dependencies (Nick Craig-Wood) - Add snap installation (hideo aoyama) - Change Winget Releaser job to ubuntu-latest (sitiom) - cmd: Refactor and use sysdnotify in more commands (eNV25) - config: Add --multi-thread-chunk-size flag (Vitor Gomes) - doc updates (antoinetran, Benjamin, Bjørn Smith, Dean Attali, gabriel-suela, James Braza, Justin Hellings, kapitainsky, Mahad, Masamune3210, Nick Craig-Wood, Nihaal Sangha, Niklas Hambüchen, Raymond Berger, r-ricci, Sawada Tsunayoshi, Tiago Boeing, Vladislav Vorobev) - fs - Use atomic types everywhere (Roberto Ricci) - When --max-transfer limit is reached exit with code (10) (kapitainsky) - Add rclone completion powershell - basic implementation only (Nick Craig-Wood) - http servers: Allow CORS to be set with --allow-origin flag (yuudi) - lib/rest: Remove unnecessary nil check (Eng Zer Jun) - ncdu: Add keybinding to rescan filesystem (eNV25) - rc - Add executeId to job listings (yuudi) - Add core/du to measure local disk usage (Nick Craig-Wood) - Add operations/settier to API (Drew Stinnett) - rclone test info: Add --check-base32768 flag to check can store all base32768 characters (Nick Craig-Wood) - rmdirs: Remove directories concurrently controlled by --checkers (Nick Craig-Wood) - Bug Fixes - accounting: Don't stop calculating average transfer speed until the operation is complete (Jacob Hands) - fs: Fix transferTime not being set in JSON logs (Jacob Hands) - fshttp: Fix --bind 0.0.0.0 allowing IPv6 and --bind ::0 allowing IPv4 (Nick Craig-Wood) - operations: Fix overlapping check on case insensitive file systems (Nick Craig-Wood) - serve dlna: Fix MIME type if backend can't identify it (Nick Craig-Wood) - serve ftp: Fix race condition when using the auth proxy (Nick Craig-Wood) - serve sftp: Fix hash calculations with --vfs-cache-mode full (Nick Craig-Wood) - serve webdav: Fix error: Expecting fs.Object or fs.Directory, got nil (Nick Craig-Wood) - sync: Fix lockup with --cutoff-mode=soft and --max-duration (Nick Craig-Wood) - Mount - fix: Mount parsing for linux (Anagh Kumar Baranwal) - VFS - Add --vfs-cache-min-free-space to control minimum free space on the disk containing the cache (Nick Craig-Wood) - Added cache cleaner for directories to reduce memory usage (Anagh Kumar Baranwal) - Update parent directory modtimes on vfs actions (David Pedersen) - Keep virtual directory status accurate and reduce deadlock potential (Anagh Kumar Baranwal) - Make sure struct field is aligned for atomic access (Roberto Ricci) - Local - Rmdir return an error if the path is not a dir (zjx20) - Azure Blob - Implement OpenChunkWriter and multi-thread uploads (Nick Craig-Wood) - Fix creation of directory markers (Nick Craig-Wood) - Fix purging with directory markers (Nick Craig-Wood) - B2 - Implement OpenChunkWriter and multi-thread uploads (Nick Craig-Wood) - Fix rclone link when object path contains special characters (Alishan Ladhani) - Box - Add polling support (David Sze) - Add --box-impersonate to impersonate a user ID (Nick Craig-Wood) - Fix unhelpful decoding of error messages into decimal numbers (Nick Craig-Wood) - Chunker - Update documentation to mention issue with small files (Ricardo D'O. Albanus) - Compress - Fix ChangeNotify (Nick Craig-Wood) - Drive - Add --drive-fast-list-bug-fix to control ListR bug workaround (Nick Craig-Wood) - Fichier - Implement DirMove (Nick Craig-Wood) - Fix error code parsing (alexia) - FTP - Add socks_proxy support for SOCKS5 proxies (Zach) - Fix 425 "TLS session of data connection not resumed" errors (Nick Craig-Wood) - Hdfs - Retry "replication in progress" errors when uploading (Nick Craig-Wood) - Fix uploading to the wrong object on Update with overridden remote name (Nick Craig-Wood) - HTTP - CORS should not be sent if not set (yuudi) - Fix webdav OPTIONS response (yuudi) - Opendrive - Fix List on a just deleted and remade directory (Nick Craig-Wood) - Oracleobjectstorage - Use rclone's rate limiter in multipart transfers (Manoj Ghosh) - Implement OpenChunkWriter and multi-thread uploads (Manoj Ghosh) - S3 - Refactor multipart upload to use OpenChunkWriter and ChunkWriter (Vitor Gomes) - Factor generic multipart upload into lib/multipart (Nick Craig-Wood) - Fix purging of root directory with --s3-directory-markers (Nick Craig-Wood) - Add rclone backend set command to update the running config (Nick Craig-Wood) - Add rclone backend restore-status command (Nick Craig-Wood) - SFTP - Stop uploads re-using the same ssh connection to improve performance (Nick Craig-Wood) - Add --sftp-ssh to specify an external ssh binary to use (Nick Craig-Wood) - Add socks_proxy support for SOCKS5 proxies (Zach) - Support dynamic --sftp-path-override (nielash) - Fix spurious warning when using --sftp-ssh (Nick Craig-Wood) - Smb - Implement multi-threaded writes for copies to smb (Edwin Mackenzie-Owen) - Storj - Performance improvement for large file uploads (Kaloyan Raev) - Swift - Fix HEADing 0-length objects when --swift-no-large-objects set (Julian Lepinski) - Union - Add :writback to act as a simple cache (Nick Craig-Wood) - WebDAV - Nextcloud: fix segment violation in low-level retry (Paul) - Zoho - Remove Range requests workarounds to fix integration tests (Nick Craig-Wood) v1.63.1 - 2023-07-17 See commits - Bug Fixes - build: Fix macos builds for versions < 12 (Anagh Kumar Baranwal) - dirtree: Fix performance with large directories of directories and --fast-list (Nick Craig-Wood) - operations - Fix deadlock when using lsd/ls with --progress (Nick Craig-Wood) - Fix .rclonelink files not being converted back to symlinks (Nick Craig-Wood) - doc fixes (Dean Attali, Mahad, Nick Craig-Wood, Sawada Tsunayoshi, Vladislav Vorobev) - Local - Fix partial directory read for corrupted filesystem (Nick Craig-Wood) - Box - Fix reconnect failing with HTTP 400 Bad Request (albertony) - Smb - Fix "Statfs failed: bucket or container name is needed" when mounting (Nick Craig-Wood) - WebDAV - Nextcloud: fix must use /dav/files/USER endpoint not /webdav error (Paul) - Nextcloud chunking: add more guidance for the user to check the config (darix) v1.63.0 - 2023-06-30 See commits - New backends - Pikpak (wiserain) - New S3 providers - petabox.io (Andrei Smirnov) - Google Cloud Storage (Anthony Pessy) - New WebDAV providers - Fastmail (Arnavion) - Major changes - Files will be copied to a temporary name ending in .partial when copying to local,ftp,sftp then renamed at the end of the transfer. (Janne Hellsten, Nick Craig-Wood) - This helps with data integrity as we don't delete the existing file until the new one is complete. - It can be disabled with the --inplace flag. - This behaviour will also happen if the backend is wrapped, for example sftp wrapped with crypt. - The s3, azureblob and gcs backends now support directory markers so empty directories are supported (Jānis Bebrītis, Nick Craig-Wood) - The --default-time flag now controls the unknown modification time of files/dirs (Nick Craig-Wood) - If a file or directory does not have a modification time rclone can read then rclone will display this fixed time instead. - For the old behaviour use --default-time 0s which will set this time to the time rclone started up. - New Features - build - Modernise linters in use and fixup all affected code (albertony) - Push docker beta to GHCR (GitHub container registry) (Richard Tweed) - cat: Add --separator option to cat command (Loren Gordon) - config - Do not remove/overwrite other files during config file save (albertony) - Do not overwrite config file symbolic link (albertony) - Stop config create making invalid config files (Nick Craig-Wood) - doc updates (Adam K, Aditya Basu, albertony, asdffdsazqqq, Damo, danielkrajnik, Dimitri Papadopoulos, dlitster, Drew Parsons, jumbi77, kapitainsky, mac-15, Mariusz Suchodolski, Nick Craig-Wood, NickIAm, Rintze Zelle, Stanislav Gromov, Tareq Sharafy, URenko, yuudi, Zach Kipp) - fs - Add size to JSON logs when moving or copying an object (Nick Craig-Wood) - Allow boolean features to be enabled with --disable !Feature (Nick Craig-Wood) - genautocomplete: Rename to completion with alias to the old name (Nick Craig-Wood) - librclone: Added example on using librclone with Go (alankrit) - lsjson: Make --stat more efficient (Nick Craig-Wood) - operations - Implement --multi-thread-write-buffer-size for speed improvements on downloads (Paulo Schreiner) - Reopen downloads on error when using check --download and cat (Nick Craig-Wood) - rc: config/listremotes includes remotes defined with environment variables (kapitainsky) - selfupdate: Obey --no-check-certificate flag (Nick Craig-Wood) - serve restic: Trigger systemd notify (Shyim) - serve webdav: Implement owncloud checksum and modtime extensions (WeidiDeng) - sync: --suffix-keep-extension preserve 2 part extensions like .tar.gz (Nick Craig-Wood) - Bug Fixes - accounting - Fix Prometheus metrics to be the same as core/stats (Nick Craig-Wood) - Bwlimit signal handler should always start (Sam Lai) - bisync: Fix maxDelete parameter being ignored via the rc (Nick Craig-Wood) - cmd/ncdu: Fix screen corruption when logging (eNV25) - filter: Fix deadlock with errors on --files-from (douchen) - fs - Fix interaction between --progress and --interactive (Nick Craig-Wood) - Fix infinite recursive call in pacer ModifyCalculator (fixes issue reported by the staticcheck linter) (albertony) - lib/atexit: Ensure OnError only calls cancel function once (Nick Craig-Wood) - lib/rest: Fix problems re-using HTTP connections (Nick Craig-Wood) - rc - Fix operations/stat with trailing / (Nick Craig-Wood) - Fix missing --rc flags (Nick Craig-Wood) - Fix output of Time values in options/get (Nick Craig-Wood) - serve dlna: Fix potential data race (Nick Craig-Wood) - version: Fix reported os/kernel version for windows (albertony) - Mount - Add --mount-case-insensitive to force the mount to be case insensitive (Nick Craig-Wood) - Removed unnecessary byte slice allocation for reads (Anagh Kumar Baranwal) - Clarify rclone mount error when installed via homebrew (Nick Craig-Wood) - Added _netdev to the example mount so it gets treated as a remote-fs rather than local-fs (Anagh Kumar Baranwal) - Mount2 - Updated go-fuse version (Anagh Kumar Baranwal) - Fixed statfs (Anagh Kumar Baranwal) - Disable xattrs (Anagh Kumar Baranwal) - VFS - Add MkdirAll function to make a directory and all beneath (Nick Craig-Wood) - Fix reload: failed to add virtual dir entry: file does not exist (Nick Craig-Wood) - Fix writing to a read only directory creating spurious directory entries (WeidiDeng) - Fix potential data race (Nick Craig-Wood) - Fix backends being Shutdown too early when startup takes a long time (Nick Craig-Wood) - Local - Fix filtering of symlinks with -l/--links flag (Nick Craig-Wood) - Fix /path/to/file.rclonelink when -l/--links is in use (Nick Craig-Wood) - Fix crash with --metadata on Android (Nick Craig-Wood) - Cache - Fix backends shutting down when in use when used via the rc (Nick Craig-Wood) - Crypt - Add --crypt-suffix option to set a custom suffix for encrypted files (jladbrook) - Add --crypt-pass-bad-blocks to allow corrupted file output (Nick Craig-Wood) - Fix reading 0 length files (Nick Craig-Wood) - Try not to return "unexpected EOF" error (Nick Craig-Wood) - Reduce allocations (albertony) - Recommend Dropbox for base32768 encoding (Nick Craig-Wood) - Azure Blob - Empty directory markers (Nick Craig-Wood) - Support azure workload identities (Tareq Sharafy) - Fix azure blob uploads with multiple bits of metadata (Nick Craig-Wood) - Fix azurite compatibility by sending nil tier if set to empty string (Roel Arents) - Combine - Implement missing methods (Nick Craig-Wood) - Fix goroutine stack overflow on bad object (Nick Craig-Wood) - Drive - Add --drive-env-auth to get IAM credentials from runtime (Peter Brunner) - Update drive service account guide (Juang, Yi-Lin) - Fix change notify picking up files outside the root (Nick Craig-Wood) - Fix trailing slash mis-identificaton of folder as file (Nick Craig-Wood) - Fix incorrect remote after Update on object (Nick Craig-Wood) - Dropbox - Implement --dropbox-pacer-min-sleep flag (Nick Craig-Wood) - Fix the dropbox batcher stalling (Misty) - Fichier - Add --ficicher-cdn option to use the CDN for download (Nick Craig-Wood) - FTP - Lower log message priority when SetModTime is not supported to debug (Tobias Gion) - Fix "unsupported LIST line" errors on startup (Nick Craig-Wood) - Fix "501 Not a valid pathname." errors when creating directories (Nick Craig-Wood) - Google Cloud Storage - Empty directory markers (Jānis Bebrītis, Nick Craig-Wood) - Added --gcs-user-project needed for requester pays (Christopher Merry) - HTTP - Add client certificate user auth middleware. This can auth serve restic from the username in the client cert. (Peter Fern) - Jottacloud - Fix vfs writeback stuck in a failed upload loop with file versioning disabled (albertony) - Onedrive - Add --onedrive-av-override flag to download files flagged as virus (Nick Craig-Wood) - Fix quickxorhash on 32 bit architectures (Nick Craig-Wood) - Report any list errors during rclone cleanup (albertony) - Putio - Fix uploading to the wrong object on Update with overridden remote name (Nick Craig-Wood) - Fix modification times not being preserved for server side copy and move (Nick Craig-Wood) - Fix server side copy failures (400 errors) (Nick Craig-Wood) - S3 - Empty directory markers (Jānis Bebrītis, Nick Craig-Wood) - Update Scaleway storage classes (Brian Starkey) - Fix --s3-versions on individual objects (Nick Craig-Wood) - Fix hang on aborting multipart upload with iDrive e2 (Nick Craig-Wood) - Fix missing "tier" metadata (Nick Craig-Wood) - Fix V3sign: add missing subresource delete (cc) - Fix Arvancloud Domain and region changes and alphabetise the provider (Ehsan Tadayon) - Fix Qiniu KODO quirks virtualHostStyle is false (zzq) - SFTP - Add --sftp-host-key-algorithms to allow specifying SSH host key algorithms (Joel) - Fix using --sftp-key-use-agent and --sftp-key-file together needing private key file (Arnav Singh) - Fix move to allow overwriting existing files (Nick Craig-Wood) - Don't stat directories before listing them (Nick Craig-Wood) - Don't check remote points to a file if it ends with / (Nick Craig-Wood) - Sharefile - Disable streamed transfers as they no longer work (Nick Craig-Wood) - Smb - Code cleanup to avoid overwriting ctx before first use (fixes issue reported by the staticcheck linter) (albertony) - Storj - Fix "uplink: too many requests" errors when uploading to the same file (Nick Craig-Wood) - Fix uploading to the wrong object on Update with overridden remote name (Nick Craig-Wood) - Swift - Ignore 404 error when deleting an object (Nick Craig-Wood) - Union - Implement missing methods (Nick Craig-Wood) - Allow errors to be unwrapped for inspection (Nick Craig-Wood) - Uptobox - Add --uptobox-private flag to make all uploaded files private (Nick Craig-Wood) - Fix improper regex (Aaron Gokaslan) - Fix Update returning the wrong object (Nick Craig-Wood) - Fix rmdir declaring that directories weren't empty (Nick Craig-Wood) - WebDAV - nextcloud: Add support for chunked uploads (Paul) - Set modtime using propset for owncloud and nextcloud (WeidiDeng) - Make pacer minSleep configurable with --webdav-pacer-min-sleep (ed) - Fix server side copy/move not overwriting (WeidiDeng) - Fix modtime on server side copy for owncloud and nextcloud (Nick Craig-Wood) - Yandex - Fix 400 Bad Request on transfer failure (Nick Craig-Wood) - Zoho - Fix downloads with Range: header returning the wrong data (Nick Craig-Wood) v1.62.2 - 2023-03-16 See commits - Bug Fixes - docker volume plugin: Add missing fuse3 dependency (Nick Craig-Wood) - docs: Fix size documentation (asdffdsazqqq) - FTP - Fix 426 errors on downloads with vsftpd (Lesmiscore) v1.62.1 - 2023-03-15 See commits - Bug Fixes - docker: Add missing fuse3 dependency (cycneuramus) - build: Update release docs to be more careful with the tag (Nick Craig-Wood) - build: Set Github release to draft while uploading binaries (Nick Craig-Wood) v1.62.0 - 2023-03-14 See commits - New Features - accounting: Make checkers show what they are doing (Nick Craig-Wood) - authorize: Add support for custom templates (Hunter Wittenborn) - build - Update to go1.20 (Nick Craig-Wood, Anagh Kumar Baranwal) - Add winget releaser workflow (Ryan Caezar Itang) - Add dependabot (Ryan Caezar Itang) - doc updates (albertony, Bryan Kaplan, Gerard Bosch, IMTheNachoMan, Justin Winokur, Manoj Ghosh, Nick Craig-Wood, Ole Frost, Peter Brunner, piyushgarg, Ryan Caezar Itang, Simmon Li, ToBeFree) - filter: Emit INFO message when can't work out directory filters (Nick Craig-Wood) - fs - Added multiple ca certificate support. (alankrit) - Add --max-delete-size a delete size threshold (Leandro Sacchet) - fspath: Allow the symbols @ and + in remote names (albertony) - lib/terminal: Enable windows console virtual terminal sequences processing (ANSI/VT100 colors) (albertony) - move: If --check-first and --order-by are set then delete with perfect ordering (Nick Craig-Wood) - serve http: Support --auth-proxy (Matthias Baur) - Bug Fixes - accounting - Avoid negative ETA values for very slow speeds (albertony) - Limit length of ETA string (albertony) - Show human readable elapsed time when longer than a day (albertony) - all: Apply codeql fixes (Aaron Gokaslan) - build - Fix condition for manual workflow run (albertony) - Fix building for ARMv5 and ARMv6 (albertony) - selfupdate: Consider ARM version - install.sh: fix ARMv6 download - version: Report ARM version - deletefile: Return error code 4 if file does not exist (Nick Craig-Wood) - docker: Fix volume plugin does not remount volume on docker restart (logopk) - fs: Fix race conditions in --max-delete and --max-delete-size (Nick Craig-Wood) - lib/oauthutil: Handle fatal errors better (Alex Chen) - mount2: Fix --allow-non-empty (Nick Craig-Wood) - operations: Fix concurrency: use --checkers unless transferring files (Nick Craig-Wood) - serve ftp: Fix timestamps older than 1 year in listings (Nick Craig-Wood) - sync: Fix concurrency: use --checkers unless transferring files (Nick Craig-Wood) - tree - Fix nil pointer exception on stat failure (Nick Craig-Wood) - Fix colored output on windows (albertony) - Fix display of files with illegal Windows file system names (Nick Craig-Wood) - Mount - Fix creating and renaming files on case insensitive backends (Nick Craig-Wood) - Do not treat \\?\ prefixed paths as network share paths on windows (albertony) - Fix check for empty mount point on Linux (Nick Craig-Wood) - Fix --allow-non-empty (Nick Craig-Wood) - Avoid incorrect or premature overlap check on windows (albertony) - Update to fuse3 after bazil.org/fuse update (Nick Craig-Wood) - VFS - Make uploaded files retain modtime with non-modtime backends (Nick Craig-Wood) - Fix incorrect modtime on fs which don't support setting modtime (Nick Craig-Wood) - Fix rename of directory containing files to be uploaded (Nick Craig-Wood) - Local - Fix %!w() in "failed to read directory" error (Marks Polakovs) - Fix exclusion of dangling symlinks with -L/--copy-links (Nick Craig-Wood) - Crypt - Obey --ignore-checksum (Nick Craig-Wood) - Fix for unencrypted directory names on case insensitive remotes (Ole Frost) - Azure Blob - Remove workarounds for SDK bugs after v0.6.1 update (Nick Craig-Wood) - B2 - Fix uploading files bigger than 1TiB (Nick Craig-Wood) - Drive - Note that --drive-acknowledge-abuse needs SA Manager permission (Nick Craig-Wood) - Make --drive-stop-on-upload-limit to respond to storageQuotaExceeded (Ninh Pham) - FTP - Retry 426 errors (Nick Craig-Wood) - Retry errors when initiating downloads (Nick Craig-Wood) - Revert to upstream github.com/jlaffaye/ftp now fix is merged (Nick Craig-Wood) - Google Cloud Storage - Add --gcs-env-auth to pick up IAM credentials from env/instance (Peter Brunner) - Mega - Add --mega-use-https flag (NodudeWasTaken) - Onedrive - Default onedrive personal to QuickXorHash as Microsoft is removing SHA1 (Nick Craig-Wood) - Add --onedrive-hash-type to change the hash in use (Nick Craig-Wood) - Improve speed of QuickXorHash (LXY) - Oracle Object Storage - Speed up operations by using S3 pacer and setting minsleep to 10ms (Manoj Ghosh) - Expose the storage_tier option in config (Manoj Ghosh) - Bring your own encryption keys (Manoj Ghosh) - S3 - Check multipart upload ETag when --s3-no-head is in use (Nick Craig-Wood) - Add --s3-sts-endpoint to specify STS endpoint (Nick Craig-Wood) - Fix incorrect tier support for StorJ and IDrive when pointing at a file (Ole Frost) - Fix AWS STS failing if --s3-endpoint is set (Nick Craig-Wood) - Make purge remove directory markers too (Nick Craig-Wood) - Seafile - Renew library password (Fred) - SFTP - Fix uploads being 65% slower than they should be with crypt (Nick Craig-Wood) - Smb - Allow SPN (service principal name) to be configured (Nick Craig-Wood) - Check smb connection is closed (happyxhw) - Storj - Implement rclone link (Kaloyan Raev) - Implement rclone purge (Kaloyan Raev) - Update satellite urls and labels (Kaloyan Raev) - WebDAV - Fix interop with davrods server (Nick Craig-Wood) v1.61.1 - 2022-12-23 See commits - Bug Fixes - docs: - Show only significant parts of version number in version introduced label (albertony) - Fix unescaped HTML (Nick Craig-Wood) - lib/http: Shutdown all servers on exit to remove unix socket (Nick Craig-Wood) - rc: Fix --rc-addr flag (which is an alternate for --url) (Anagh Kumar Baranwal) - serve restic - Don't serve via http if serving via --stdio (Nick Craig-Wood) - Fix immediate exit when not using stdio (Nick Craig-Wood) - serve webdav - Fix --baseurl handling after lib/http refactor (Nick Craig-Wood) - Fix running duplicate Serve call (Nick Craig-Wood) - Azure Blob - Fix "409 Public access is not permitted on this storage account" (Nick Craig-Wood) - S3 - storj: Update endpoints (Kaloyan Raev) v1.61.0 - 2022-12-20 See commits - New backends - New S3 providers - Liara LOS (MohammadReza) - New Features - build: Add vulnerability testing using govulncheck (albertony) - cmd: Enable SIGINFO (Ctrl-T) handler on FreeBSD, NetBSD, OpenBSD and Dragonfly BSD (x3-apptech) - config: Add config/setpath for setting config path via rc/librclone (Nick Craig-Wood) - dedupe - Count Checks in the stats while scanning for duplicates (Nick Craig-Wood) - Make dedupe obey the filters (Nick Craig-Wood) - dlna: Properly attribute code used from https://github.com/anacrolix/dms (Nick Craig-Wood) - docs - Add minimum versions and status badges to backend and command docs (Nick Craig-Wood, albertony) - Remote names may not start or end with space (albertony) - filter: Add metadata filters --metadata-include/exclude/filter and friends (Nick Craig-Wood) - fs - Make all duration flags take y, M, w, d etc suffixes (Nick Craig-Wood) - Add global flag --color to control terminal colors (Kevin Verstaen) - fspath: Allow unicode numbers and letters in remote names (albertony) - lib/file: Improve error message for creating dir on non-existent network host on windows (albertony) - lib/http: Finish port of rclone servers to lib/http (Tom Mombourquette, Nick Craig-Wood) - lib/oauthutil: Improved usability of config flows needing web browser (Ole Frost) - ncdu - Add support for modification time (albertony) - Fallback to sort by name also for sort by average size (albertony) - Rework to use tcell directly instead of the termbox wrapper (eNV25) - rc: Add commands to set GC Percent & Memory Limit (go 1.19+) (Anagh Kumar Baranwal) - rcat: Preserve metadata when Copy falls back to Rcat (Nick Craig-Wood) - rcd: Refactor rclone rc server to use lib/http (Nick Craig-Wood) - rcserver: Avoid generating default credentials with htpasswd (Kamui) - restic: Refactor to use lib/http (Nolan Woods) - serve http: Support unix sockets and multiple listeners (Tom Mombourquette) - serve webdav: Refactor to use lib/http (Nick Craig-Wood) - test: Replace defer cleanup with t.Cleanup (Eng Zer Jun) - test memory: Read metadata if -M flag is specified (Nick Craig-Wood) - wasm: Comply with wasm_exec.js licence terms (Matthew Vernon) - Bug Fixes - build: Update golang.org/x/net/http2 to fix GO-2022-1144 (Nick Craig-Wood) - restic: Fix typo in docs 'remove' should be 'remote' (asdffdsazqqq) - serve dlna: Fix panic: Logger uninitialized. (Nick Craig-Wood) - Mount - Update cgofuse for FUSE-T support for mounting volumes on Mac (Nick Craig-Wood) - VFS - Windows: fix slow opening of exe files by not truncating files when not necessary (Nick Craig-Wood) - Fix IO Error opening a file with O_CREATE|O_RDONLY in --vfs-cache-mode not full (Nick Craig-Wood) - Crypt - Fix compress wrapping crypt giving upload errors (Nick Craig-Wood) - Azure Blob - Port to new SDK (Nick Craig-Wood) - Revamp authentication to include all methods and docs (Nick Craig-Wood) - Port old authentication methods to new SDK (Nick Craig-Wood, Brad Ackerman) - Thanks to Stonebranch for sponsoring this work. - Add --azureblob-no-check-container to assume container exists (Nick Craig-Wood) - Add --use-server-modtime support (Abdullah Saglam) - Add support for custom upload headers (rkettelerij) - Allow emulator account/key override (Roel Arents) - Support simple "environment credentials" (Nathaniel Wesley Filardo) - Ignore AuthorizationFailure when trying to create a create a container (Nick Craig-Wood) - Box - Added note on Box API rate limits (Ole Frost) - Drive - Handle shared drives with leading/trailing space in name (related to) (albertony) - FTP - Update help text of implicit/explicit TLS options to refer to FTPS instead of FTP (ycdtosa) - Improve performance to speed up --files-from and NewObject (Anthony Pessy) - HTTP - Parse GET responses when no_head is set (Arnie97) - Do not update object size based on Range requests (Arnie97) - Support Content-Range response header (Arnie97) - Onedrive - Document workaround for shared with me files (vanplus) - S3 - Add Liara LOS to provider list (MohammadReza) - Add DigitalOcean Spaces regions sfo3, fra1, syd1 (Jack) - Avoid privileged GetBucketLocation to resolve s3 region (Anthony Pessy) - Stop setting object and bucket ACL to private if it is an empty string (Philip Harvey) - If bucket or object ACL is empty string then don't add X-Amz-Acl: header (Nick Craig-Wood) - Reduce memory consumption for s3 objects (Erik Agterdenbos) - Fix listing loop when using v2 listing on v1 server (Nick Craig-Wood) - Fix nil pointer exception when using Versions (Nick Craig-Wood) - Fix excess memory usage when using versions (Nick Craig-Wood) - Ignore versionIDs from uploads unless using --s3-versions or --s3-versions-at (Nick Craig-Wood) - SFTP - Add configuration options to set ssh Ciphers / MACs / KeyExchange (dgouju) - Auto-detect shell type for fish (albertony) - Fix NewObject with leading / (Nick Craig-Wood) - Smb - Fix issue where spurious dot directory is created (albertony) - Storj - Implement server side Copy (Kaloyan Raev) v1.60.1 - 2022-11-17 See commits - Bug Fixes - lib/cache: Fix alias backend shutting down too soon (Nick Craig-Wood) - wasm: Fix walltime link error by adding up-to-date wasm_exec.js (João Henrique Franco) - docs - Update faq.md with bisync (Samuel Johnson) - Corrected download links in windows install docs (coultonluke) - Add direct download link for windows arm64 (albertony) - Remove link to rclone slack as it is no longer supported (Nick Craig-Wood) - Faq: how to use a proxy server that requires a username and password (asdffdsazqqq) - Oracle-object-storage: doc fix (Manoj Ghosh) - Fix typo remove in rclone_serve_restic command (Joda Stößer) - Fix character that was incorrectly interpreted as markdown (Clément Notin) - VFS - Fix deadlock caused by cache cleaner and upload finishing (Nick Craig-Wood) - Local - Clean absolute paths (albertony) - Fix -L/--copy-links with filters missing directories (Nick Craig-Wood) - Mailru - Note that an app password is now needed (Nick Craig-Wood) - Allow timestamps to be before the epoch 1970-01-01 (Nick Craig-Wood) - S3 - Add provider quirk --s3-might-gzip to fix corrupted on transfer: sizes differ (Nick Craig-Wood) - Allow Storj to server side copy since it seems to work now (Nick Craig-Wood) - Fix for unchecked err value in s3 listv2 (Aaron Gokaslan) - Add additional Wasabi locations (techknowlogick) - Smb - Fix Failed to sync: context canceled at the end of syncs (Nick Craig-Wood) - WebDAV - Fix Move/Copy/DirMove when using -server-side-across-configs (Nick Craig-Wood) v1.60.0 - 2022-10-21 See commits - New backends - Oracle object storage (Manoj Ghosh) - SMB / CIFS (Windows file sharing) (Lesmiscore) - New S3 providers - IONOS Cloud Storage (Dmitry Deniskin) - Qiniu KODO (Bachue Zhou) - New Features - build - Update to go1.19 and make go1.17 the minimum required version (Nick Craig-Wood) - Install.sh: fix arm-v7 download (Ole Frost) - fs: Warn the user when using an existing remote name without a colon (Nick Craig-Wood) - httplib: Add --xxx-min-tls-version option to select minimum TLS version for HTTP servers (Robert Newson) - librclone: Add PHP bindings and test program (Jordi Gonzalez Muñoz) - operations - Add --server-side-across-configs global flag for any backend (Nick Craig-Wood) - Optimise --copy-dest and --compare-dest (Nick Craig-Wood) - rc: add job/stopgroup to stop group (Evan Spensley) - serve dlna - Add --announce-interval to control SSDP Announce Interval (YanceyChiew) - Add --interface to Specify SSDP interface names line (Simon Bos) - Add support for more external subtitles (YanceyChiew) - Add verification of addresses (YanceyChiew) - sync: Optimise --copy-dest and --compare-dest (Nick Craig-Wood) - doc updates (albertony, Alexander Knorr, anonion, João Henrique Franco, Josh Soref, Lorenzo Milesi, Marco Molteni, Mark Trolley, Ole Frost, partev, Ryan Morey, Tom Mombourquette, YFdyh000) - Bug Fixes - filter - Fix incorrect filtering with UseFilter context flag and wrapping backends (Nick Craig-Wood) - Make sure we check --files-from when looking for a single file (Nick Craig-Wood) - rc - Fix mount/listmounts not returning the full Fs entered in mount/mount (Tom Mombourquette) - Handle external unmount when mounting (Isaac Aymerich) - Validate Daemon option is not set when mounting a volume via RC (Isaac Aymerich) - sync: Update docs and error messages to reflect fixes to overlap checks (Nick Naumann) - VFS - Reduce memory use by embedding sync.Cond (Nick Craig-Wood) - Reduce memory usage by re-ordering commonly used structures (Nick Craig-Wood) - Fix excess CPU used by VFS cache cleaner looping (Nick Craig-Wood) - Local - Obey file filters in listing to fix errors on excluded files (Nick Craig-Wood) - Fix "Failed to read metadata: function not implemented" on old Linux kernels (Nick Craig-Wood) - Compress - Fix crash due to nil metadata (Nick Craig-Wood) - Fix error handling to not use or return nil objects (Nick Craig-Wood) - Drive - Make --drive-stop-on-upload-limit obey quota exceeded error (Steve Kowalik) - FTP - Add --ftp-force-list-hidden option to show hidden items (Øyvind Heddeland Instefjord) - Fix hang when using ExplicitTLS to certain servers. (Nick Craig-Wood) - Google Cloud Storage - Add --gcs-endpoint flag and config parameter (Nick Craig-Wood) - Hubic - Remove backend as service has now shut down (Nick Craig-Wood) - Onedrive - Rename Onedrive(cn) 21Vianet to Vnet Group (Yen Hu) - Disable change notify in China region since it is not supported (Nick Craig-Wood) - S3 - Implement --s3-versions flag to show old versions of objects if enabled (Nick Craig-Wood) - Implement --s3-version-at flag to show versions of objects at a particular time (Nick Craig-Wood) - Implement backend versioning command to get/set bucket versioning (Nick Craig-Wood) - Implement Purge to purge versions and backend cleanup-hidden (Nick Craig-Wood) - Add --s3-decompress flag to decompress gzip-encoded files (Nick Craig-Wood) - Add --s3-sse-customer-key-base64 to supply keys with binary data (Richard Bateman) - Try to keep the maximum precision in ModTime with --user-server-modtime (Nick Craig-Wood) - Drop binary metadata with an ERROR message as it can't be stored (Nick Craig-Wood) - Add --s3-no-system-metadata to suppress read and write of system metadata (Nick Craig-Wood) - SFTP - Fix directory creation races (Lesmiscore) - Swift - Add --swift-no-large-objects to reduce HEAD requests (Nick Craig-Wood) - Union - Propagate SlowHash feature to fix hasher interaction (Lesmiscore) v1.59.2 - 2022-09-15 See commits - Bug Fixes - config: Move locking to fix fatal error: concurrent map read and map write (Nick Craig-Wood) - Local - Disable xattr support if the filesystems indicates it is not supported (Nick Craig-Wood) - Azure Blob - Fix chunksize calculations producing too many parts (Nick Craig-Wood) - B2 - Fix chunksize calculations producing too many parts (Nick Craig-Wood) - S3 - Fix chunksize calculations producing too many parts (Nick Craig-Wood) v1.59.1 - 2022-08-08 See commits - Bug Fixes - accounting: Fix panic in core/stats-reset with unknown group (Nick Craig-Wood) - build: Fix android build after GitHub actions change (Nick Craig-Wood) - dlna: Fix SOAP action header parsing (Joram Schrijver) - docs: Fix links to mount command from install docs (albertony) - dropbox: Fix ChangeNotify was unable to decrypt errors (Nick Craig-Wood) - fs: Fix parsing of times and durations of the form "YYYY-MM-DD HH:MM:SS" (Nick Craig-Wood) - serve sftp: Fix checksum detection (Nick Craig-Wood) - sync: Add accidentally missed filter-sensitivity to --backup-dir option (Nick Naumann) - Combine - Fix docs showing remote= instead of upstreams= (Nick Craig-Wood) - Throw error if duplicate directory name is specified (Nick Craig-Wood) - Fix errors with backends shutting down while in use (Nick Craig-Wood) - Dropbox - Fix hang on quit with --dropbox-batch-mode off (Nick Craig-Wood) - Fix infinite loop on uploading a corrupted file (Nick Craig-Wood) - Internetarchive - Ignore checksums for files using the different method (Lesmiscore) - Handle hash symbol in the middle of filename (Lesmiscore) - Jottacloud - Fix working with whitelabel Elgiganten Cloud - Do not store username in config when using standard auth (albertony) - Mega - Fix nil pointer exception when bad node received (Nick Craig-Wood) - S3 - Fix --s3-no-head panic: reflect: Elem of invalid type s3.PutObjectInput (Nick Craig-Wood) - SFTP - Fix issue with WS_FTP by working around failing RealPath (albertony) - Union - Fix duplicated files when using directories with leading / (Nick Craig-Wood) - Fix multiple files being uploaded when roots don't exist (Nick Craig-Wood) - Fix panic due to misalignment of struct field in 32 bit architectures (r-ricci) v1.59.0 - 2022-07-09 See commits - New backends - Combine multiple remotes in one directory tree (Nick Craig-Wood) - Hidrive (Ovidiu Victor Tatar) - Internet Archive (Lesmiscore (Naoya Ozaki)) - New S3 providers - ArvanCloud AOS (ehsantdy) - Cloudflare R2 (Nick Craig-Wood) - Huawei OBS (m00594701) - IDrive e2 (vyloy) - New commands - test makefile: Create a single file for testing (Nick Craig-Wood) - New Features - Metadata framework to read and write system and user metadata on backends (Nick Craig-Wood) - Implemented initially for local, s3 and internetarchive backends - --metadata/-M flag to control whether metadata is copied - --metadata-set flag to specify metadata for uploads - Thanks to Manz Solutions for sponsoring this work. - build - Update to go1.18 and make go1.16 the minimum required version (Nick Craig-Wood) - Update android go build to 1.18.x and NDK to 23.1.7779620 (Nick Craig-Wood) - All windows binaries now no longer CGO (Nick Craig-Wood) - Add linux/arm/v6 to docker images (Nick Craig-Wood) - A huge number of fixes found with staticcheck (albertony) - Configurable version suffix independent of version number (albertony) - check: Implement --no-traverse and --no-unicode-normalization (Nick Craig-Wood) - config: Readability improvements (albertony) - copyurl: Add --header-filename to honor the HTTP header filename directive (J-P Treen) - filter: Allow multiple --exclude-if-present flags (albertony) - fshttp: Add --disable-http-keep-alives to disable HTTP Keep Alives (Nick Craig-Wood) - install.sh - Set the modes on the files and/or directories on macOS (Michael C Tiernan - MIT-Research Computing Project) - Pre verify sudo authorization -v before calling curl. (Michael C Tiernan - MIT-Research Computing Project) - lib/encoder: Add Semicolon encoding (Nick Craig-Wood) - lsf: Add metadata support with M flag (Nick Craig-Wood) - lsjson: Add --metadata/-M flag (Nick Craig-Wood) - ncdu - Implement multi selection (CrossR) - Replace termbox with tcell's termbox wrapper (eNV25) - Display correct path in delete confirmation dialog (Roberto Ricci) - operations - Speed up hash checking by aborting the other hash if first returns nothing (Nick Craig-Wood) - Use correct src/dst in some log messages (zzr93) - rcat: Check checksums by default like copy does (Nick Craig-Wood) - selfupdate: Replace deprecated x/crypto/openpgp package with ProtonMail/go-crypto (albertony) - serve ftp: Check --passive-port arguments are correct (Nick Craig-Wood) - size: Warn about inaccurate results when objects with unknown size (albertony) - sync: Overlap check is now filter-sensitive so --backup-dir can be in the root provided it is filtered (Nick) - test info: Check file name lengths using 1,2,3,4 byte unicode characters (Nick Craig-Wood) - test makefile(s): --sparse, --zero, --pattern, --ascii, --chargen flags to control file contents (Nick Craig-Wood) - Make sure we call the Shutdown method on backends (Martin Czygan) - Bug Fixes - accounting: Fix unknown length file transfers counting 3 transfers each (buda) - ncdu: Fix issue where dir size is summed when file sizes are -1 (albertony) - sync/copy/move - Fix --fast-list --create-empty-src-dirs and --exclude (Nick Craig-Wood) - Fix --max-duration and --cutoff-mode soft (Nick Craig-Wood) - Fix fs cache unpin (Martin Czygan) - Set proper exit code for errors that are not low-level retried (e.g. size/timestamp changing) (albertony) - Mount - Support windows/arm64 (may still be problems - see #5828) (Nick Craig-Wood) - Log IO errors at ERROR level (Nick Craig-Wood) - Ignore _netdev mount argument (Hugal31) - VFS - Add --vfs-fast-fingerprint for less accurate but faster fingerprints (Nick Craig-Wood) - Add --vfs-disk-space-total-size option to manually set the total disk space (Claudio Maradonna) - vfscache: Fix fatal error: sync: unlock of unlocked mutex error (Nick Craig-Wood) - Local - Fix parsing of --local-nounc flag (Nick Craig-Wood) - Add Metadata support (Nick Craig-Wood) - Crypt - Support metadata (Nick Craig-Wood) - Azure Blob - Calculate Chunksize/blocksize to stay below maxUploadParts (Leroy van Logchem) - Use chunksize lib to determine chunksize dynamically (Derek Battams) - Case insensitive access tier (Rob Pickerill) - Allow remote emulator (azurite) (Lorenzo Maiorfi) - B2 - Add --b2-version-at flag to show file versions at time specified (SwazRGB) - Use chunksize lib to determine chunksize dynamically (Derek Battams) - Chunker - Mark as not supporting metadata (Nick Craig-Wood) - Compress - Support metadata (Nick Craig-Wood) - Drive - Make backend config -o config add a combined AllDrives: remote (Nick Craig-Wood) - Make --drive-shared-with-me work with shared drives (Nick Craig-Wood) - Add --drive-resource-key for accessing link-shared files (Nick Craig-Wood) - Add backend commands exportformats and importformats for debugging (Nick Craig-Wood) - Fix 404 errors on copy/server side copy objects from public folder (Nick Craig-Wood) - Update Internal OAuth consent screen docs (Phil Shackleton) - Moved root_folder_id to advanced section (Abhiraj) - Dropbox - Migrate from deprecated api (m8rge) - Add logs to show when poll interval limits are exceeded (Nick Craig-Wood) - Fix nil pointer exception on dropbox impersonate user not found (Nick Craig-Wood) - Fichier - Parse api error codes and them accordingly (buengese) - FTP - Add support for disable_utf8 option (Jason Zheng) - Revert to upstream github.com/jlaffaye/ftp from our fork (Nick Craig-Wood) - Google Cloud Storage - Add --gcs-no-check-bucket to minimise transactions and perms (Nick Gooding) - Add --gcs-decompress flag to decompress gzip-encoded files (Nick Craig-Wood) - by default these will be downloaded compressed (which previously failed) - Hasher - Support metadata (Nick Craig-Wood) - HTTP - Fix missing response when using custom auth handler (albertony) - Jottacloud - Add support for upload to custom device and mountpoint (albertony) - Always store username in config and use it to avoid initial API request (albertony) - Fix issue with server-side copy when destination is in trash (albertony) - Fix listing output of remote with special characters (albertony) - Mailru - Fix timeout by using int instead of time.Duration for keeping number of seconds (albertony) - Mega - Document using MEGAcmd to help with login failures (Art M. Gallagher) - Onedrive - Implement --poll-interval for onedrive (Hugo Laloge) - Add access scopes option (Sven Gerber) - Opendrive - Resolve lag and truncate bugs (Scott Grimes) - Pcloud - Fix about with no free space left (buengese) - Fix cleanup (buengese) - S3 - Use PUT Object instead of presigned URLs to upload single part objects (Nick Craig-Wood) - Backend restore command to skip non-GLACIER objects (Vincent Murphy) - Use chunksize lib to determine chunksize dynamically (Derek Battams) - Retry RequestTimeout errors (Nick Craig-Wood) - Implement reading and writing of metadata (Nick Craig-Wood) - SFTP - Add support for about and hashsum on windows server (albertony) - Use vendor-specific VFS statistics extension for about if available (albertony) - Add --sftp-chunk-size to control packets sizes for high latency links (Nick Craig-Wood) - Add --sftp-concurrency to improve high latency transfers (Nick Craig-Wood) - Add --sftp-set-env option to set environment variables (Nick Craig-Wood) - Add Hetzner Storage Boxes to supported sftp backends (Anthrazz) - Storj - Fix put which lead to the file being unreadable when using mount (Erik van Velzen) - Union - Add min_free_space option for lfs/eplfs policies (Nick Craig-Wood) - Fix uploading files to union of all bucket based remotes (Nick Craig-Wood) - Fix get free space for remotes which don't support it (Nick Craig-Wood) - Fix eplus policy to select correct entry for existing files (Nick Craig-Wood) - Support metadata (Nick Craig-Wood) - Uptobox - Fix root path handling (buengese) - WebDAV - Add SharePoint in other specific regions support (Noah Hsu) - Yandex - Handle api error on server-side move (albertony) - Zoho - Add Japan and China regions (buengese) v1.58.1 - 2022-04-29 See commits - Bug Fixes - build: Update github.com/billziss-gh to github.com/winfsp (Nick Craig-Wood) - filter: Fix timezone of --min-age/-max-age from UTC to local as documented (Nick Craig-Wood) - rc/js: Correct RC method names (Sơn Trần-Nguyễn) - docs - Fix some links to command pages (albertony) - Add --multi-thread-streams note to --transfers. (Zsolt Ero) - Mount - Fix --devname and fusermount: unknown option 'fsname' when mounting via rc (Nick Craig-Wood) - VFS - Remove wording which suggests VFS is only for mounting (Nick Craig-Wood) - Dropbox - Fix retries of multipart uploads with incorrect_offset error (Nick Craig-Wood) - Google Cloud Storage - Use the s3 pacer to speed up transactions (Nick Craig-Wood) - pacer: Default the Google pacer to a burst of 100 to fix gcs pacing (Nick Craig-Wood) - Jottacloud - Fix scope in token request (albertony) - Netstorage - Fix unescaped HTML in documentation (Nick Craig-Wood) - Make levels of headings consistent (Nick Craig-Wood) - Add support contacts to netstorage doc (Nil Alexandrov) - Onedrive - Note that sharepoint also changes web files (.html, .aspx) (GH) - Putio - Handle rate limit errors (Berkan Teber) - Fix multithread download and other ranged requests (rafma0) - S3 - Add ChinaMobile EOS to provider list (GuoXingbin) - Sync providers in config description with providers (Nick Craig-Wood) - SFTP - Fix OpenSSH 8.8+ RSA keys incompatibility (KARBOWSKI Piotr) - Note that Scaleway C14 is deprecating SFTP in favor of S3 (Adrien Rey-Jarthon) - Storj - Fix bucket creation on Move (Nick Craig-Wood) - WebDAV - Don't override Referer if user sets it (Nick Craig-Wood) v1.58.0 - 2022-03-18 See commits - New backends - Akamai Netstorage (Nil Alexandrov) - Seagate Lyve, SeaweedFS, Storj, RackCorp via s3 backend - Storj (renamed from Tardigrade - your old config files will continue working) - New commands - bisync - experimental bidirectional cloud sync (Ivan Andreev, Chris Nelson) - New Features - build - Add windows/arm64 build (rclone mount not supported yet) (Nick Craig-Wood) - Raise minimum go version to go1.15 (Nick Craig-Wood) - config: Allow dot in remote names and improve config editing (albertony) - dedupe: Add quit as a choice in interactive mode (albertony) - dlna: Change icons to the newest ones. (Alain Nussbaumer) - filter: Add {{ regexp }} syntax to pattern matches (Nick Craig-Wood) - fshttp: Add prometheus metrics for HTTP status code (Michał Matczuk) - hashsum: Support creating hash from data received on stdin (albertony) - librclone - Allow empty string or null input instead of empty json object (albertony) - Add support for mount commands (albertony) - operations: Add server-side moves to stats (Ole Frost) - rc: Allow user to disable authentication for web gui (negative0) - tree: Remove obsolete --human replaced by global --human-readable (albertony) - version: Report correct friendly-name for newer Windows 10/11 versions (albertony) - Bug Fixes - build - Fix ARM architecture version in .deb packages after nfpm change (Nick Craig-Wood) - Hard fork github.com/jlaffaye/ftp to fix go get github.com/rclone/rclone (Nick Craig-Wood) - oauthutil: Fix crash when webbrowser requests /robots.txt (Nick Craig-Wood) - operations: Fix goroutine leak in case of copy retry (Ankur Gupta) - rc: - Fix operations/publiclink default for expires parameter (Nick Craig-Wood) - Fix missing computation of transferQueueSize when summing up statistics group (Carlo Mion) - Fix missing StatsInfo fields in the computation of the group sum (Carlo Mion) - sync: Fix --max-duration so it doesn't retry when the duration is exceeded (Nick Craig-Wood) - touch: Fix issue where a directory is created instead of a file (albertony) - Mount - Add --devname to set the device name sent to FUSE for mount display (Nick Craig-Wood) - VFS - Add vfs/stats remote control to show statistics (Nick Craig-Wood) - Fix failed to _ensure cache internal error: downloaders is nil error (Nick Craig-Wood) - Fix handling of special characters in file names (Bumsu Hyeon) - Local - Fix hash invalidation which caused errors with local crypt mount (Nick Craig-Wood) - Crypt - Add base64 and base32768 filename encoding options (Max Sum, Sinan Tan) - Azure Blob - Implement --azureblob-upload-concurrency parameter to speed uploads (Nick Craig-Wood) - Remove 100MB upper limit on chunk_size as it is no longer needed (Nick Craig-Wood) - Raise --azureblob-upload-concurrency to 16 by default (Nick Craig-Wood) - Fix crash with SAS URL and no container (Nick Craig-Wood) - Compress - Fix crash if metadata upload failed (Nick Craig-Wood) - Fix memory leak (Nick Craig-Wood) - Drive - Added --drive-copy-shortcut-content (Abhiraj) - Disable OAuth OOB flow (copy a token) due to Google deprecation (Nick Craig-Wood) - See the deprecation note. - Add --drive-skip-dangling-shortcuts flag (Nick Craig-Wood) - When using a link type --drive-export-formats shows all doc types (Nick Craig-Wood) - Dropbox - Speed up directory listings by specifying 1000 items in a chunk (Nick Craig-Wood) - Save an API request when at the root (Nick Craig-Wood) - Fichier - Implemented About functionality (Gourav T) - FTP - Add --ftp-ask-password to prompt for password when needed (Borna Butkovic) - Google Cloud Storage - Add missing regions (Nick Craig-Wood) - Disable OAuth OOB flow (copy a token) due to Google deprecation (Nick Craig-Wood) - See the deprecation note. - Googlephotos - Disable OAuth OOB flow (copy a token) due to Google deprecation (Nick Craig-Wood) - See the deprecation note. - Hasher - Fix crash on object not found (Nick Craig-Wood) - Hdfs - Add file (Move) and directory move (DirMove) support (Andy Jackson) - HTTP - Improved recognition of URL pointing to a single file (albertony) - Jottacloud - Change API used by recursive list (ListR) (Kim) - Add support for Tele2 Cloud (Fredric Arklid) - Koofr - Add Digistorage service as a Koofr provider. (jaKa) - Mailru - Fix int32 overflow on arm32 (Ivan Andreev) - Onedrive - Add config option for oauth scope Sites.Read.All (Charlie Jiang) - Minor optimization of quickxorhash (Isaac Levy) - Add --onedrive-root-folder-id flag (Nick Craig-Wood) - Do not retry on 400 pathIsTooLong error (ctrl-q) - Pcloud - Add support for recursive list (ListR) (Niels van de Weem) - Fix pre-1970 time stamps (Nick Craig-Wood) - S3 - Use ListObjectsV2 for faster listings (Felix Bünemann) - Fallback to ListObject v1 on unsupported providers (Nick Craig-Wood) - Use the ETag on multipart transfers to verify the transfer was OK (Nick Craig-Wood) - Add --s3-use-multipart-etag provider quirk to disable this on unsupported providers (Nick Craig-Wood) - New Providers - RackCorp object storage (bbabich) - Seagate Lyve Cloud storage (Nick Craig-Wood) - SeaweedFS (Chris Lu) - Storj Shared gateways (Márton Elek, Nick Craig-Wood) - Add Wasabi AP Northeast 2 endpoint info (lindwurm) - Add GLACIER_IR storage class (Yunhai Luo) - Document Content-MD5 workaround for object-lock enabled buckets (Paulo Martins) - Fix multipart upload with --no-head flag (Nick Craig-Wood) - Simplify content length processing in s3 with download url (Logeshwaran Murugesan) - SFTP - Add rclone to list of supported md5sum/sha1sum commands to look for (albertony) - Refactor so we only have one way of running remote commands (Nick Craig-Wood) - Fix timeout on hashing large files by sending keepalives (Nick Craig-Wood) - Fix unnecessary seeking when uploading and downloading files (Nick Craig-Wood) - Update docs on how to create known_hosts file (Nick Craig-Wood) - Storj - Rename tardigrade backend to storj backend (Nick Craig-Wood) - Implement server side Move for files (Nick Craig-Wood) - Update docs to explain differences between s3 and this backend (Elek, Márton) - Swift - Fix About so it shows info about the current container only (Nick Craig-Wood) - Union - Fix treatment of remotes with // in (Nick Craig-Wood) - Fix deadlock when one part of a multi-upload fails (Nick Craig-Wood) - Fix eplus policy returned nil (Vitor Arruda) - Yandex - Add permanent deletion support (deinferno) v1.57.0 - 2021-11-01 See commits - New backends - Sia: for Sia decentralized cloud (Ian Levesque, Matthew Sevey, Ivan Andreev) - Hasher: caches hashes and enable hashes for backends that don't support them (Ivan Andreev) - New commands - lsjson --stat: to get info about a single file/dir and operations/stat api (Nick Craig-Wood) - config paths: show configured paths (albertony) - New Features - about: Make human-readable output more consistent with other commands (albertony) - build - Use go1.17 for building and make go1.14 the minimum supported (Nick Craig-Wood) - Update Go to 1.16 and NDK to 22b for Android builds (x0b) - config - Support hyphen in remote name from environment variable (albertony) - Make temporary directory user-configurable (albertony) - Convert --cache-dir value to an absolute path (albertony) - Do not override MIME types from OS defaults (albertony) - docs - Toc styling and header levels cleanup (albertony) - Extend documentation on valid remote names (albertony) - Mention make for building and cmount tag for macos (Alex Chen) - ...and many more contributions to numerous to mention! - fs: Move with --ignore-existing will not delete skipped files (Nathan Collins) - hashsum - Treat hash values in sum file as case insensitive (Ivan Andreev) - Don't put ERROR or UNSUPPORTED in output (Ivan Andreev) - lib/encoder: Add encoding of square brackets (Ivan Andreev) - lib/file: Improve error message when attempting to create dir on nonexistent drive on windows (albertony) - lib/http: Factor password hash salt into options with default (Nolan Woods) - lib/kv: Add key-value database api (Ivan Andreev) - librclone - Add RcloneFreeString function (albertony) - Free strings in python example (albertony) - log: Optionally print pid in logs (Ivan Andreev) - ls: Introduce --human-readable global option to print human-readable sizes (albertony) - ncdu: Introduce key u to toggle human-readable (albertony) - operations: Add rmdirs -v output (Justin Winokur) - serve sftp - Generate an ECDSA server key as well as RSA (Nick Craig-Wood) - Generate an Ed25519 server key as well as ECDSA and RSA (albertony) - serve docker - Allow to customize proxy settings of docker plugin (Ivan Andreev) - Build docker plugin for multiple platforms (Thomas Stachl) - size: Include human-readable count (albertony) - touch: Add support for touching files in directory, with recursive option, filtering and --dry-run/-i (albertony) - tree: Option to print human-readable sizes removed in favor of global option (albertony) - Bug Fixes - lib/http - Fix bad username check in single auth secret provider (Nolan Woods) - Fix handling of SSL credentials (Nolan Woods) - serve ftp: Ensure modtime is passed as UTC always to fix timezone oddities (Nick Craig-Wood) - serve sftp: Fix generation of server keys on windows (albertony) - serve docker: Fix octal umask (Ivan Andreev) - Mount - Enable rclone to be run as mount helper direct from the fstab (Ivan Andreev) - Use procfs to validate mount on linux (Ivan Andreev) - Correctly daemonize for compatibility with automount (Ivan Andreev) - VFS - Ensure names used in cache path are legal on current OS (albertony) - Ignore ECLOSED when truncating file handles to fix intermittent bad file descriptor error (Nick Craig-Wood) - Local - Refactor default OS encoding out from local backend into shared encoder lib (albertony) - Crypt - Return wrapped object even with --crypt-no-data-encryption (Ivan Andreev) - Fix uploads with --crypt-no-data-encryption (Nick Craig-Wood) - Azure Blob - Add --azureblob-no-head-object (Tatsuya Noyori) - Box - Make listings of heavily used directories more reliable (Nick Craig-Wood) - When doing cleanup delete as much as possible (Nick Craig-Wood) - Add --box-list-chunk to control listing chunk size (Nick Craig-Wood) - Delete items in parallel in cleanup using --checkers threads (Nick Craig-Wood) - Add --box-owned-by to only show items owned by the login passed (Nick Craig-Wood) - Retry operation_blocked_temporary errors (Nick Craig-Wood) - Chunker - Md5all must create metadata if base hash is slow (Ivan Andreev) - Drive - Speed up directory listings by constraining the API listing using the current filters (fotile96, Ivan Andreev) - Fix buffering for single request upload for files smaller than --drive-upload-cutoff (YenForYang) - Add -o config option to backend drives to make config for all shared drives (Nick Craig-Wood) - Dropbox - Add --dropbox-batch-commit-timeout to control batch timeout (Nick Craig-Wood) - Filefabric - Make backoff exponential for error_background to fix errors (Nick Craig-Wood) - Fix directory move after API change (Nick Craig-Wood) - FTP - Enable tls session cache by default (Ivan Andreev) - Add option to disable tls13 (Ivan Andreev) - Fix timeout after long uploads (Ivan Andreev) - Add support for precise time (Ivan Andreev) - Enable CI for ProFtpd, PureFtpd, VsFtpd (Ivan Andreev) - Googlephotos - Use encoder for album names to fix albums with control characters (Parth Shukla) - Jottacloud - Implement SetModTime to support modtime-only changes (albertony) - Improved error handling with SetModTime and corrupt files in general (albertony) - Add support for UserInfo (rclone config userinfo) feature (albertony) - Return direct download link from rclone link command (albertony) - Koofr - Create direct share link (Dmitry Bogatov) - Pcloud - Add sha256 support (Ken Enrique Morel) - Premiumizeme - Fix directory listing after API changes (Nick Craig-Wood) - Fix server side move after API change (Nick Craig-Wood) - Fix server side directory move after API changes (Nick Craig-Wood) - S3 - Add support to use CDN URL to download the file (Logeshwaran) - Add AWS Snowball Edge to providers examples (r0kk3rz) - Use a combination of SDK retries and rclone retries (Nick Craig-Wood) - Fix IAM Role for Service Account not working and other auth problems (Nick Craig-Wood) - Fix shared_credentials_file auth after reverting incorrect fix (Nick Craig-Wood) - Fix corrupted on transfer: sizes differ 0 vs xxxx with Ceph (Nick Craig-Wood) - Seafile - Fix error when not configured for 2fa (Fred) - SFTP - Fix timeout when doing MD5SUM of large file (Nick Craig-Wood) - Swift - Update OCI URL (David Liu) - Document OVH Cloud Archive (HNGamingUK) - Union - Fix rename not working with union of local disk and bucket based remote (Nick Craig-Wood) v1.56.2 - 2021-10-01 See commits - Bug Fixes - serve http: Re-add missing auth to http service (Nolan Woods) - build: Update golang.org/x/sys to fix crash on macOS when compiled with go1.17 (Herby Gillot) - FTP - Fix deadlock after failed update when concurrency=1 (Ivan Andreev) v1.56.1 - 2021-09-19 See commits - Bug Fixes - accounting: Fix maximum bwlimit by scaling scale max token bucket size (Nick Craig-Wood) - rc: Fix speed does not update in core/stats (negative0) - selfupdate: Fix --quiet option, not quite quiet (yedamo) - serve http: Fix serve http exiting directly after starting (Cnly) - build - Apply gofmt from golang 1.17 (Ivan Andreev) - Update Go to 1.16 and NDK to 22b for android/any (x0b) - Mount - Fix --daemon mode (Ivan Andreev) - VFS - Fix duplicates on rename (Nick Craig-Wood) - Fix crash when truncating a just uploaded object (Nick Craig-Wood) - Fix issue where empty dirs would build up in cache meta dir (albertony) - Drive - Fix instructions for auto config (Greg Sadetsky) - Fix lsf example without drive-impersonate (Greg Sadetsky) - Onedrive - Handle HTTP 400 better in PublicLink (Alex Chen) - Clarification of the process for creating custom client_id (Mariano Absatz) - Pcloud - Return an early error when Put is called with an unknown size (Nick Craig-Wood) - Try harder to delete a failed upload (Nick Craig-Wood) - S3 - Add Wasabi's AP-Northeast endpoint info (hota) - Fix typo in s3 documentation (Greg Sadetsky) - Seafile - Fix 2fa config state machine (Fred) - SFTP - Remove spurious error message on --sftp-disable-concurrent-reads (Nick Craig-Wood) - Sugarsync - Fix initial connection after config re-arrangement (Nick Craig-Wood) v1.56.0 - 2021-07-20 See commits - New backends - Uptobox (buengese) - New commands - serve docker (Antoine GIRARD) (Ivan Andreev) - and accompanying docker volume plugin - checksum to check files against a file of checksums (Ivan Andreev) - this is also available as rclone md5sum -C etc - config touch: ensure config exists at configured location (albertony) - test changenotify: command to help debugging changenotify (Nick Craig-Wood) - Deprecations - dbhashsum: Remove command deprecated a year ago (Ivan Andreev) - cache: Deprecate cache backend (Ivan Andreev) - New Features - rework config system so it can be used non-interactively via cli and rc API. - See docs in config create - This is a very big change to all the backends so may cause breakages - please file bugs! - librclone - export the rclone RC as a C library (lewisxy) (Nick Craig-Wood) - Link a C-API rclone shared object into your project - Use the RC as an in memory interface - Python example supplied - Also supports Android and gomobile - fs - Add --disable-http2 for global http2 disable (Nick Craig-Wood) - Make --dump imply -vv (Alex Chen) - Use binary prefixes for size and rate units (albertony) - Use decimal prefixes for counts (albertony) - Add google search widget to rclone.org (Ivan Andreev) - accounting: Calculate rolling average speed (Haochen Tong) - atexit: Terminate with non-zero status after receiving signal (Michael Hanselmann) - build - Only run event-based workflow scripts under rclone repo with manual override (Mathieu Carbou) - Add Android build with gomobile (x0b) - check: Log the hash in use like cryptcheck does (Nick Craig-Wood) - version: Print os/version, kernel and bitness (Ivan Andreev) - config - Prevent use of Windows reserved names in config file name (albertony) - Create config file in windows appdata directory by default (albertony) - Treat any config file paths with filename notfound as memory-only config (albertony) - Delay load config file (albertony) - Replace defaultConfig with a thread-safe in-memory implementation (Chris Macklin) - Allow config create and friends to take key=value parameters (Nick Craig-Wood) - Fixed issues with flags/options set by environment vars. (Ole Frost) - fshttp: Implement graceful DSCP error handling (Tyson Moore) - lib/http - provides an abstraction for a central http server that services can bind routes to (Nolan Woods) - Add --template config and flags to serve/data (Nolan Woods) - Add default 404 handler (Nolan Woods) - link: Use "off" value for unset expiry (Nick Craig-Wood) - oauthutil: Raise fatal error if token expired without refresh token (Alex Chen) - rcat: Add --size flag for more efficient uploads of known size (Nazar Mishturak) - serve sftp: Add --stdio flag to serve via stdio (Tom) - sync: Don't warn about --no-traverse when --files-from is set (Nick Gaya) - test makefiles - Add --seed flag and make data generated repeatable (Nick Craig-Wood) - Add log levels and speed summary (Nick Craig-Wood) - Bug Fixes - accounting: Fix startTime of statsGroups.sum (Haochen Tong) - cmd/ncdu: Fix out of range panic in delete (buengese) - config - Fix issues with memory-only config file paths (albertony) - Fix in memory config not saving on the fly backend config (Nick Craig-Wood) - fshttp: Fix address parsing for DSCP (Tyson Moore) - ncdu: Update termbox-go library to fix crash (Nick Craig-Wood) - oauthutil: Fix old authorize result not recognised (Cnly) - operations: Don't update timestamps of files in --compare-dest (Nick Gaya) - selfupdate: fix archive name on macos (Ivan Andreev) - Mount - Refactor before adding serve docker (Antoine GIRARD) - VFS - Add cache reset for --vfs-cache-max-size handling at cache poll interval (Leo Luan) - Fix modtime changing when reading file into cache (Nick Craig-Wood) - Avoid unnecessary subdir in cache path (albertony) - Fix that umask option cannot be set as environment variable (albertony) - Do not print notice about missing poll-interval support when set to 0 (albertony) - Local - Always use readlink to read symlink size for better compatibility (Nick Craig-Wood) - Add --local-unicode-normalization (and remove --local-no-unicode-normalization) (Nick Craig-Wood) - Skip entries removed concurrently with List() (Ivan Andreev) - Crypt - Support timestamped filenames from --b2-versions (Dominik Mydlil) - B2 - Don't include the bucket name in public link file prefixes (Jeffrey Tolar) - Fix versions and .files with no extension (Nick Craig-Wood) - Factor version handling into lib/version (Dominik Mydlil) - Box - Use upload preflight check to avoid listings in file uploads (Nick Craig-Wood) - Return errors instead of calling log.Fatal with them (Nick Craig-Wood) - Drive - Switch to the Drives API for looking up shared drives (Nick Craig-Wood) - Fix some google docs being treated as files (Nick Craig-Wood) - Dropbox - Add --dropbox-batch-mode flag to speed up uploading (Nick Craig-Wood) - Read the batch mode docs for more info - Set visibility in link sharing when --expire is set (Nick Craig-Wood) - Simplify chunked uploads (Alexey Ivanov) - Improve "own App IP" instructions (Ivan Andreev) - Fichier - Check if more than one upload link is returned (Nick Craig-Wood) - Support downloading password protected files and folders (Florian Penzkofer) - Make error messages report text from the API (Nick Craig-Wood) - Fix move of files in the same directory (Nick Craig-Wood) - Check that we actually got a download token and retry if we didn't (buengese) - Filefabric - Fix listing after change of from field from "int" to int. (Nick Craig-Wood) - FTP - Make upload error 250 indicate success (Nick Craig-Wood) - GCS - Make compatible with gsutil's mtime metadata (database64128) - Clean up time format constants (database64128) - Google Photos - Fix read only scope not being used properly (Nick Craig-Wood) - HTTP - Replace httplib with lib/http (Nolan Woods) - Clean up Bind to better use middleware (Nolan Woods) - Jottacloud - Fix legacy auth with state based config system (buengese) - Fix invalid url in output from link command (albertony) - Add no versions option (buengese) - Onedrive - Add list_chunk option (Nick Gaya) - Also report root error if unable to cancel multipart upload (Cnly) - Fix failed to configure: empty token found error (Nick Craig-Wood) - Make link return direct download link (Xuanchen Wu) - S3 - Add --s3-no-head-object (Tatsuya Noyori) - Remove WebIdentityRoleProvider to fix crash on auth (Nick Craig-Wood) - Don't check to see if remote is object if it ends with / (Nick Craig-Wood) - Add SeaweedFS (Chris Lu) - Update Alibaba OSS endpoints (Chuan Zh) - SFTP - Fix performance regression by re-enabling concurrent writes (Nick Craig-Wood) - Expand tilde and environment variables in configured known_hosts_file (albertony) - Tardigrade - Upgrade to uplink v1.4.6 (Caleb Case) - Use negative offset (Caleb Case) - Add warning about too many open files (acsfer) - WebDAV - Fix sharepoint auth over http (Nick Craig-Wood) - Add headers option (Antoon Prins) v1.55.1 - 2021-04-26 See commits - Bug Fixes - selfupdate - Dont detect FUSE if build is static (Ivan Andreev) - Add build tag noselfupdate (Ivan Andreev) - sync: Fix incorrect error reported by graceful cutoff (Nick Craig-Wood) - install.sh: fix macOS arm64 download (Nick Craig-Wood) - build: Fix version numbers in android branch builds (Nick Craig-Wood) - docs - Contributing.md: update setup instructions for go1.16 (Nick Gaya) - WinFsp 2021 is out of beta (albertony) - Minor cleanup of space around code section (albertony) - Fixed some typos (albertony) - VFS - Fix a code path which allows dirty data to be removed causing data loss (Nick Craig-Wood) - Compress - Fix compressed name regexp (buengese) - Drive - Fix backend copyid of google doc to directory (Nick Craig-Wood) - Don't open browser when service account... (Ansh Mittal) - Dropbox - Add missing team_data.member scope for use with --impersonate (Nick Craig-Wood) - Fix About after scopes changes - rclone config reconnect needed (Nick Craig-Wood) - Fix Unable to decrypt returned paths from changeNotify (Nick Craig-Wood) - FTP - Fix implicit TLS (Ivan Andreev) - Onedrive - Work around for random "Unable to initialize RPS" errors (OleFrost) - SFTP - Revert sftp library to v1.12.0 from v1.13.0 to fix performance regression (Nick Craig-Wood) - Fix Update ReadFrom failed: failed to send packet: EOF errors (Nick Craig-Wood) - Zoho - Fix error when region isn't set (buengese) - Do not ask for mountpoint twice when using headless setup (buengese) v1.55.0 - 2021-03-31 See commits - New commands - selfupdate (Ivan Andreev) - Allows rclone to update itself in-place or via a package (using --package flag) - Reads cryptographically signed signatures for non beta releases - Works on all OSes. - test - these are test commands - use with care! - histogram - Makes a histogram of file name characters. - info - Discovers file name or other limitations for paths. - makefiles - Make a random file hierarchy for testing. - memory - Load all the objects at remote:path into memory and report memory stats. - New Features - Connection strings - Config parameters can now be passed as part of the remote name as a connection string. - For example, to do the equivalent of --drive-shared-with-me use drive,shared_with_me: - Make sure we don't save on the fly remote config to the config file (Nick Craig-Wood) - Make sure backends with additional config have a different name for caching (Nick Craig-Wood) - This work was sponsored by CERN, through the CS3MESH4EOSC Project. - CS3MESH4EOSC has received funding from the European Union’s Horizon 2020 - research and innovation programme under Grant Agreement no. 863353. - build - Update go build version to go1.16 and raise minimum go version to go1.13 (Nick Craig-Wood) - Make a macOS ARM64 build to support Apple Silicon (Nick Craig-Wood) - Install macfuse 4.x instead of osxfuse 3.x (Nick Craig-Wood) - Use GO386=softfloat instead of deprecated GO386=387 for 386 builds (Nick Craig-Wood) - Disable IOS builds for the time being (Nick Craig-Wood) - Androids builds made with up to date NDK (x0b) - Add an rclone user to the Docker image but don't use it by default (cynthia kwok) - dedupe: Make largest directory primary to minimize data moved (Saksham Khanna) - config - Wrap config library in an interface (Fionera) - Make config file system pluggable (Nick Craig-Wood) - --config "" or "/notfound" for in memory config only (Nick Craig-Wood) - Clear fs cache of stale entries when altering config (Nick Craig-Wood) - copyurl: Add option to print resulting auto-filename (albertony) - delete: Make --rmdirs obey the filters (Nick Craig-Wood) - docs - many fixes and reworks from edwardxml, albertony, pvalls, Ivan Andreev, Evan Harris, buengese, Alexey Tabakman - encoder/filename - add SCSU as tables (Klaus Post) - Add multiple paths support to --compare-dest and --copy-dest flag (K265) - filter: Make --exclude "dir/" equivalent to --exclude "dir/**" (Nick Craig-Wood) - fshttp: Add DSCP support with --dscp for QoS with differentiated services (Max Sum) - lib/cache: Add Delete and DeletePrefix methods (Nick Craig-Wood) - lib/file - Make pre-allocate detect disk full errors and return them (Nick Craig-Wood) - Don't run preallocate concurrently (Nick Craig-Wood) - Retry preallocate on EINTR (Nick Craig-Wood) - operations: Made copy and sync operations obey a RetryAfterError (Ankur Gupta) - rc - Add string alternatives for setting options over the rc (Nick Craig-Wood) - Add options/local to see the options configured in the context (Nick Craig-Wood) - Add _config parameter to set global config for just this rc call (Nick Craig-Wood) - Implement passing filter config with _filter parameter (Nick Craig-Wood) - Add fscache/clear and fscache/entries to control the fs cache (Nick Craig-Wood) - Avoid +Inf value for speed in core/stats (albertony) - Add a full set of stats to core/stats (Nick Craig-Wood) - Allow fs= params to be a JSON blob (Nick Craig-Wood) - rcd: Added systemd notification during the rclone rcd command. (Naveen Honest Raj) - rmdirs: Make --rmdirs obey the filters (Nick Craig-Wood) - version: Show build tags and type of executable (Ivan Andreev) - Bug Fixes - install.sh: make it fail on download errors (Ivan Andreev) - Fix excessive retries missing --max-duration timeout (Nick Craig-Wood) - Fix crash when --low-level-retries=0 (Nick Craig-Wood) - Fix failed token refresh on mounts created via the rc (Nick Craig-Wood) - fshttp: Fix bandwidth limiting after bad merge (Nick Craig-Wood) - lib/atexit - Unregister interrupt handler once it has fired so users can interrupt again (Nick Craig-Wood) - Fix occasional failure to unmount with CTRL-C (Nick Craig-Wood) - Fix deadlock calling Finalise while Run is running (Nick Craig-Wood) - lib/rest: Fix multipart uploads not stopping on context cancel (Nick Craig-Wood) - Mount - Allow mounting to root directory on windows (albertony) - Improved handling of relative paths on windows (albertony) - Fix unicode issues with accented characters on macOS (Nick Craig-Wood) - Docs: document the new FileSecurity option in WinFsp 2021 (albertony) - Docs: add note about volume path syntax on windows (albertony) - Fix caching of old directories after renaming them (Nick Craig-Wood) - Update cgofuse to the latest version to bring in macfuse 4 fix (Nick Craig-Wood) - VFS - --vfs-used-is-size to report used space using recursive scan (tYYGH) - Don't set modification time if it was already correct (Nick Craig-Wood) - Fix Create causing windows explorer to truncate files on CTRL-C CTRL-V (Nick Craig-Wood) - Fix modtimes not updating when writing via cache (Nick Craig-Wood) - Fix modtimes changing by fractional seconds after upload (Nick Craig-Wood) - Fix modtime set if --vfs-cache-mode writes/full and no write (Nick Craig-Wood) - Rename files in cache and cancel uploads on directory rename (Nick Craig-Wood) - Fix directory renaming by renaming dirs cached in memory (Nick Craig-Wood) - Local - Add flag --local-no-preallocate (David Sze) - Make nounc an advanced option except on Windows (albertony) - Don't ignore preallocate disk full errors (Nick Craig-Wood) - Cache - Add --fs-cache-expire-duration to control the fs cache (Nick Craig-Wood) - Crypt - Add option to not encrypt data (Vesnyx) - Log hash ok on upload (albertony) - Azure Blob - Add container public access level support. (Manish Kumar) - B2 - Fix HTML files downloaded via cloudflare (Nick Craig-Wood) - Box - Fix transfers getting stuck on token expiry after API change (Nick Craig-Wood) - Chunker - Partially implement no-rename transactions (Maxwell Calman) - Drive - Don't stop server side copy if couldn't read description (Nick Craig-Wood) - Pass context on to drive SDK - to help with cancellation (Nick Craig-Wood) - Dropbox - Add polling for changes support (Robert Thomas) - Make --timeout 0 work properly (Nick Craig-Wood) - Raise priority of rate limited message to INFO to make it more noticeable (Nick Craig-Wood) - Fichier - Implement copy & move (buengese) - Implement public link (buengese) - FTP - Implement Shutdown method (Nick Craig-Wood) - Close idle connections after --ftp-idle-timeout (1m by default) (Nick Craig-Wood) - Make --timeout 0 work properly (Nick Craig-Wood) - Add --ftp-close-timeout flag for use with awkward ftp servers (Nick Craig-Wood) - Retry connections and logins on 421 errors (Nick Craig-Wood) - Hdfs - Fix permissions for when directory is created (Lucas Messenger) - Onedrive - Make --timeout 0 work properly (Nick Craig-Wood) - S3 - Fix --s3-profile which wasn't working (Nick Craig-Wood) - SFTP - Close idle connections after --sftp-idle-timeout (1m by default) (Nick Craig-Wood) - Fix "file not found" errors for read once servers (Nick Craig-Wood) - Fix SetModTime stat failed: object not found with --sftp-set-modtime=false (Nick Craig-Wood) - Swift - Update github.com/ncw/swift to v2.0.0 (Nick Craig-Wood) - Implement copying large objects (nguyenhuuluan434) - Union - Fix crash when using epff policy (Nick Craig-Wood) - Fix union attempting to update files on a read only file system (Nick Craig-Wood) - Refactor to use fspath.SplitFs instead of fs.ParseRemote (Nick Craig-Wood) - Fix initialisation broken in refactor (Nick Craig-Wood) - WebDAV - Add support for sharepoint with NTLM authentication (Rauno Ots) - Make sharepoint-ntlm docs more consistent (Alex Chen) - Improve terminology in sharepoint-ntlm docs (Ivan Andreev) - Disable HTTP/2 for NTLM authentication (georne) - Fix sharepoint-ntlm error 401 for parallel actions (Ivan Andreev) - Check that purged directory really exists (Ivan Andreev) - Yandex - Make --timeout 0 work properly (Nick Craig-Wood) - Zoho - Replace client id - you will need to rclone config reconnect after this (buengese) - Add forgotten setupRegion() to NewFs - this finally fixes regions other than EU (buengese) v1.54.1 - 2021-03-08 See commits - Bug Fixes - accounting: Fix --bwlimit when up or down is off (Nick Craig-Wood) - docs - Fix nesting of brackets and backticks in ftp docs (edwardxml) - Fix broken link in sftp page (edwardxml) - Fix typo in crypt.md (Romeo Kienzler) - Changelog: Correct link to digitalis.io (Alex JOST) - Replace #file-caching with #vfs-file-caching (Miron Veryanskiy) - Convert bogus example link to code (edwardxml) - Remove dead link from rc.md (edwardxml) - rc: Sync,copy,move: document createEmptySrcDirs parameter (Nick Craig-Wood) - lsjson: Fix unterminated JSON in the presence of errors (Nick Craig-Wood) - Mount - Fix mount dropping on macOS by setting --daemon-timeout 10m (Nick Craig-Wood) - VFS - Document simultaneous usage with the same cache shouldn't be used (Nick Craig-Wood) - B2 - Automatically raise upload cutoff to avoid spurious error (Nick Craig-Wood) - Fix failed to create file system with application key limited to a prefix (Nick Craig-Wood) - Drive - Refer to Shared Drives instead of Team Drives (Nick Craig-Wood) - Dropbox - Add scopes to oauth request and optionally "members.read" (Nick Craig-Wood) - S3 - Fix failed to create file system with folder level permissions policy (Nick Craig-Wood) - Fix Wasabi HEAD requests returning stale data by using only 1 transport (Nick Craig-Wood) - Fix shared_credentials_file auth (Dmitry Chepurovskiy) - Add --s3-no-head to reducing costs docs (Nick Craig-Wood) - Union - Fix mkdir at root with remote:/ (Nick Craig-Wood) - Zoho - Fix custom client id's (buengese) v1.54.0 - 2021-02-02 See commits - New backends - Compression remote (experimental) (buengese) - Enterprise File Fabric (Nick Craig-Wood) - This work was sponsored by Storage Made Easy - HDFS (Hadoop Distributed File System) (Yury Stankevich) - Zoho workdrive (buengese) - New Features - Deglobalise the config (Nick Craig-Wood) - Global config now read from the context - This will enable passing of global config via the rc - This work was sponsored by Digitalis - Add --bwlimit for upload and download (Nick Craig-Wood) - Obey bwlimit in http Transport for better limiting - Enhance systemd integration (Hekmon) - log level identification, manual activation with flag, automatic systemd launch detection - Don't compile systemd log integration for non unix systems (Benjamin Gustin) - Add a --download flag to md5sum/sha1sum/hashsum to force rclone to download and hash files locally (lostheli) - Add --progress-terminal-title to print ETA to terminal title (LaSombra) - Make backend env vars show in help as the defaults for backend flags (Nick Craig-Wood) - build - Raise minimum go version to go1.12 (Nick Craig-Wood) - dedupe - Add --by-hash to dedupe on content hash not file name (Nick Craig-Wood) - Add --dedupe-mode list to just list dupes, changing nothing (Nick Craig-Wood) - Add warning if used on a remote which can't have duplicate names (Nick Craig-Wood) - fs - Add Shutdown optional method for backends (Nick Craig-Wood) - When using --files-from check files concurrently (zhucan) - Accumulate stats when using --dry-run (Ingo Weiss) - Always show stats when using --dry-run or --interactive (Nick Craig-Wood) - Add support for flag --no-console on windows to hide the console window (albertony) - genautocomplete: Add support to output to stdout (Ingo) - ncdu - Highlight read errors instead of aborting (Claudio Bantaloukas) - Add sort by average size in directory (Adam Plánský) - Add toggle option for average s3ize in directory - key 'a' (Adam Plánský) - Add empty folder flag into ncdu browser (Adam Plánský) - Add ! (error) and . (unreadable) file flags to go with e (empty) (Nick Craig-Wood) - obscure: Make rclone obscure - ignore newline at end of line (Nick Craig-Wood) - operations - Add logs when need to upload files to set mod times (Nick Craig-Wood) - Move and copy log name of the destination object in verbose (Adam Plánský) - Add size if known to skipped items and JSON log (Nick Craig-Wood) - rc - Prefer actual listener address if using ":port" or "addr:0" only (Nick Craig-Wood) - Add listener for finished jobs (Aleksandar Jankovic) - serve ftp: Add options to enable TLS (Deepak Sah) - serve http/webdav: Redirect requests to the base url without the / (Nick Craig-Wood) - serve restic: Implement object cache (Nick Craig-Wood) - stats: Add counter for deleted directories (Nick Craig-Wood) - sync: Only print "There was nothing to transfer" if no errors (Nick Craig-Wood) - webui - Prompt user for updating webui if an update is available (Chaitanya Bankanhal) - Fix plugins initialization (negative0) - Bug Fixes - fs - Fix nil pointer on copy & move operations directly to remote (Anagh Kumar Baranwal) - Fix parsing of .. when joining remotes (Nick Craig-Wood) - log: Fix enabling systemd logging when using --log-file (Nick Craig-Wood) - check - Make the error count match up in the log message (Nick Craig-Wood) - move: Fix data loss when source and destination are the same object (Nick Craig-Wood) - operations - Fix --cutoff-mode hard not cutting off immediately (Nick Craig-Wood) - Fix --immutable error message (Nick Craig-Wood) - sync - Fix --cutoff-mode soft & cautious so it doesn't end the transfer early (Nick Craig-Wood) - Fix --immutable errors retrying many times (Nick Craig-Wood) - Docs - Many fixes and a rewrite of the filtering docs (edwardxml) - Many spelling and grammar fixes (Josh Soref) - Doc fixes for commands delete, purge, rmdir, rmdirs and mount (albertony) - And thanks to these people for many doc fixes too numerous to list - Ameer Dawood, Antoine GIRARD, Bob Bagwill, Christopher Stewart - CokeMine, David, Dov Murik, Durval Menezes, Evan Harris, gtorelly - Ilyess Bachiri, Janne Johansson, Kerry Su, Marcin Zelent, - Martin Michlmayr, Milly, Sơn Trần-Nguyễn - Mount - Update systemd status with cache stats (Hekmon) - Disable bazil/fuse based mount on macOS (Nick Craig-Wood) - Make rclone mount actually run rclone cmount under macOS (Nick Craig-Wood) - Implement mknod to make NFS file creation work (Nick Craig-Wood) - Make sure we don't call umount more than once (Nick Craig-Wood) - More user friendly mounting as network drive on windows (albertony) - Detect if uid or gid are set in same option string: -o uid=123,gid=456 (albertony) - Don't attempt to unmount if fs has been destroyed already (Nick Craig-Wood) - VFS - Fix virtual entries causing deleted files to still appear (Nick Craig-Wood) - Fix "file already exists" error for stale cache files (Nick Craig-Wood) - Fix file leaks with --vfs-cache-mode full and --buffer-size 0 (Nick Craig-Wood) - Fix invalid cache path on windows when using :backend: as remote (albertony) - Local - Continue listing files/folders when a circular symlink is detected (Manish Gupta) - New flag --local-zero-size-links to fix sync on some virtual filesystems (Riccardo Iaconelli) - Azure Blob - Add support for service principals (James Lim) - Add support for managed identities (Brad Ackerman) - Add examples for access tier (Bob Pusateri) - Utilize the streaming capabilities from the SDK for multipart uploads (Denis Neuling) - Fix setting of mime types (Nick Craig-Wood) - Fix crash when listing outside a SAS URL's root (Nick Craig-Wood) - Delete archive tier blobs before update if --azureblob-archive-tier-delete (Nick Craig-Wood) - Fix crash on startup (Nick Craig-Wood) - Fix memory usage by upgrading the SDK to v0.13.0 and implementing a TransferManager (Nick Craig-Wood) - Require go1.14+ to compile due to SDK changes (Nick Craig-Wood) - B2 - Make NewObject use less expensive API calls (Nick Craig-Wood) - This will improve --files-from and restic serve in particular - Fixed crash on an empty file name (lluuaapp) - Box - Fix NewObject for files that differ in case (Nick Craig-Wood) - Fix finding directories in a case insensitive way (Nick Craig-Wood) - Chunker - Skip long local hashing, hash in-transit (fixes) (Ivan Andreev) - Set Features ReadMimeType to false as Object.MimeType not supported (Nick Craig-Wood) - Fix case-insensitive NewObject, test metadata detection (Ivan Andreev) - Drive - Implement rclone backend copyid command for copying files by ID (Nick Craig-Wood) - Added flag --drive-stop-on-download-limit to stop transfers when the download limit is exceeded (Anagh Kumar Baranwal) - Implement CleanUp workaround for team drives (buengese) - Allow shortcut resolution and creation to be retried (Nick Craig-Wood) - Log that emptying the trash can take some time (Nick Craig-Wood) - Add xdg office icons to xdg desktop files (Pau Rodriguez-Estivill) - Dropbox - Add support for viewing shared files and folders (buengese) - Enable short lived access tokens (Nick Craig-Wood) - Implement IDer on Objects so rclone lsf etc can read the IDs (buengese) - Set Features ReadMimeType to false as Object.MimeType not supported (Nick Craig-Wood) - Make malformed_path errors from too long files not retriable (Nick Craig-Wood) - Test file name length before upload to fix upload loop (Nick Craig-Wood) - Fichier - Set Features ReadMimeType to true as Object.MimeType is supported (Nick Craig-Wood) - FTP - Add --ftp-disable-msld option to ignore MLSD for really old servers (Nick Craig-Wood) - Make --tpslimit apply (Nick Craig-Wood) - Google Cloud Storage - Storage class object header support (Laurens Janssen) - Fix anonymous client to use rclone's HTTP client (Nick Craig-Wood) - Fix Entry doesn't belong in directory "" (same as directory) - ignoring (Nick Craig-Wood) - Googlephotos - New flag --gphotos-include-archived to show archived photos as well (Nicolas Rueff) - Jottacloud - Don't erroneously report support for writing mime types (buengese) - Add support for Telia Cloud (Patrik Nordlén) - Mailru - Accept special folders eg camera-upload (Ivan Andreev) - Avoid prehashing of large local files (Ivan Andreev) - Fix uploads after recent changes on server (Ivan Andreev) - Fix range requests after June 2020 changes on server (Ivan Andreev) - Fix invalid timestamp on corrupted files (fixes) (Ivan Andreev) - Remove deprecated protocol quirks (Ivan Andreev) - Memory - Fix setting of mime types (Nick Craig-Wood) - Onedrive - Add support for China region operated by 21vianet and other regional suppliers (NyaMisty) - Warn on gateway timeout errors (Nick Craig-Wood) - Fall back to normal copy if server-side copy unavailable (Alex Chen) - Fix server-side copy completely disabled on OneDrive for Business (Cnly) - (business only) workaround to replace existing file on server-side copy (Alex Chen) - Enhance link creation with expiry, scope, type and password (Nick Craig-Wood) - Remove % and # from the set of encoded characters (Alex Chen) - Support addressing site by server-relative URL (kice) - Opendrive - Fix finding directories in a case insensitive way (Nick Craig-Wood) - Pcloud - Fix setting of mime types (Nick Craig-Wood) - Premiumizeme - Fix finding directories in a case insensitive way (Nick Craig-Wood) - Qingstor - Fix error propagation in CleanUp (Nick Craig-Wood) - Fix rclone cleanup (Nick Craig-Wood) - S3 - Added --s3-disable-http2 to disable http/2 (Anagh Kumar Baranwal) - Complete SSE-C implementation (Nick Craig-Wood) - Fix hashes on small files with AWS:KMS and SSE-C (Nick Craig-Wood) - Add MD5 metadata to objects uploaded with SSE-AWS/SSE-C (Nick Craig-Wood) - Add --s3-no-head parameter to minimise transactions on upload (Nick Craig-Wood) - Update docs with a Reducing Costs section (Nick Craig-Wood) - Added error handling for error code 429 indicating too many requests (Anagh Kumar Baranwal) - Add requester pays option (kelv) - Fix copy multipart with v2 auth failing with 'SignatureDoesNotMatch' (Louis Koo) - SFTP - Allow cert based auth via optional pubkey (Stephen Harris) - Allow user to optionally check server hosts key to add security (Stephen Harris) - Defer asking for user passwords until the SSH connection succeeds (Stephen Harris) - Remember entered password in AskPass mode (Stephen Harris) - Implement Shutdown method (Nick Craig-Wood) - Implement keyboard interactive authentication (Nick Craig-Wood) - Make --tpslimit apply (Nick Craig-Wood) - Implement --sftp-use-fstat for unusual SFTP servers (Nick Craig-Wood) - Sugarsync - Fix NewObject for files that differ in case (Nick Craig-Wood) - Fix finding directories in a case insensitive way (Nick Craig-Wood) - Swift - Fix deletion of parts of Static Large Object (SLO) (Nguyễn Hữu Luân) - Ensure partially uploaded large files are uploaded unless --swift-leave-parts-on-error (Nguyễn Hữu Luân) - Tardigrade - Upgrade to uplink v1.4.1 (Caleb Case) - WebDAV - Updated docs to show streaming to nextcloud is working (Durval Menezes) - Yandex - Set Features WriteMimeType to false as Yandex ignores mime types (Nick Craig-Wood) v1.53.4 - 2021-01-20 See commits - Bug Fixes - accounting: Fix data race in Transferred() (Maciej Zimnoch) - build - Stop tagged releases making a current beta (Nick Craig-Wood) - Upgrade docker buildx action (Matteo Pietro Dazzi) - Add -buildmode to cross-compile.go (Nick Craig-Wood) - Fix docker build by upgrading ilteoood/docker_buildx (Nick Craig-Wood) - Revert GitHub actions brew fix since this is now fixed (Nick Craig-Wood) - Fix brew install --cask syntax for macOS build (Nick Craig-Wood) - Update nfpm syntax to fix build of .deb/.rpm packages (Nick Craig-Wood) - Fix for Windows build errors (Ivan Andreev) - fs: Parseduration: fixed tests to use UTC time (Ankur Gupta) - fshttp: Prevent overlap of HTTP headers in logs (Nathan Collins) - rc - Fix core/command giving 500 internal error (Nick Craig-Wood) - Add Copy method to rc.Params (Nick Craig-Wood) - Fix 500 error when marshalling errors from core/command (Nick Craig-Wood) - plugins: Create plugins files only if webui is enabled. (negative0) - serve http: Fix serving files of unknown length (Nick Craig-Wood) - serve sftp: Fix authentication on one connection blocking others (Nick Craig-Wood) - Mount - Add optional brew tag to throw an error when using mount in the binaries installed via Homebrew (Anagh Kumar Baranwal) - Add "." and ".." to directories to match cmount and expectations (Nick Craig-Wood) - VFS - Make cache dir absolute before using it to fix path too long errors (Nick Craig-Wood) - Chunker - Improve detection of incompatible metadata (Ivan Andreev) - Google Cloud Storage - Fix server side copy of large objects (Nick Craig-Wood) - Jottacloud - Fix token renewer to fix long uploads (Nick Craig-Wood) - Fix token refresh failed: is not a regular file error (Nick Craig-Wood) - Pcloud - Only use SHA1 hashes in EU region (Nick Craig-Wood) - Sharefile - Undo Fix backend due to API swapping integers for strings (Nick Craig-Wood) - WebDAV - Fix Open Range requests to fix 4shared mount (Nick Craig-Wood) - Add "Depth: 0" to GET requests to fix bitrix (Nick Craig-Wood) v1.53.3 - 2020-11-19 See commits - Bug Fixes - random: Fix incorrect use of math/rand instead of crypto/rand CVE-2020-28924 (Nick Craig-Wood) - Passwords you have generated with rclone config may be insecure - See issue #4783 for more details and a checking tool - random: Seed math/rand in one place with crypto strong seed (Nick Craig-Wood) - VFS - Fix vfs/refresh calls with fs= parameter (Nick Craig-Wood) - Sharefile - Fix backend due to API swapping integers for strings (Nick Craig-Wood) v1.53.2 - 2020-10-26 See commits - Bug Fixes - accounting - Fix incorrect speed and transferTime in core/stats (Nick Craig-Wood) - Stabilize display order of transfers on Windows (Nick Craig-Wood) - operations - Fix use of --suffix without --backup-dir (Nick Craig-Wood) - Fix spurious "--checksum is in use but the source and destination have no hashes in common" (Nick Craig-Wood) - build - Work around GitHub actions brew problem (Nick Craig-Wood) - Stop using set-env and set-path in the GitHub actions (Nick Craig-Wood) - Mount - mount2: Fix the swapped UID / GID values (Russell Cattelan) - VFS - Detect and recover from a file being removed externally from the cache (Nick Craig-Wood) - Fix a deadlock vulnerability in downloaders.Close (Leo Luan) - Fix a race condition in retryFailedResets (Leo Luan) - Fix missed concurrency control between some item operations and reset (Leo Luan) - Add exponential backoff during ENOSPC retries (Leo Luan) - Add a missed update of used cache space (Leo Luan) - Fix --no-modtime to not attempt to set modtimes (as documented) (Nick Craig-Wood) - Local - Fix sizes and syncing with --links option on Windows (Nick Craig-Wood) - Chunker - Disable ListR to fix missing files on GDrive (workaround) (Ivan Andreev) - Fix upload over crypt (Ivan Andreev) - Fichier - Increase maximum file size from 100GB to 300GB (gyutw) - Jottacloud - Remove clientSecret from config when upgrading to token based authentication (buengese) - Avoid double url escaping of device/mountpoint (albertony) - Remove DirMove workaround as it's not required anymore - also (buengese) - Mailru - Fix uploads after recent changes on server (Ivan Andreev) - Fix range requests after june changes on server (Ivan Andreev) - Fix invalid timestamp on corrupted files (fixes) (Ivan Andreev) - Onedrive - Fix disk usage for sharepoint (Nick Craig-Wood) - S3 - Add missing regions for AWS (Anagh Kumar Baranwal) - Seafile - Fix accessing libraries > 2GB on 32 bit systems (Muffin King) - SFTP - Always convert the checksum to lower case (buengese) - Union - Create root directories if none exist (Nick Craig-Wood) v1.53.1 - 2020-09-13 See commits - Bug Fixes - accounting: Remove new line from end of --stats-one-line display (Nick Craig-Wood) - check - Add back missing --download flag (Nick Craig-Wood) - Fix docs (Nick Craig-Wood) - docs - Note --log-file does append (Nick Craig-Wood) - Add full stops for consistency in rclone --help (edwardxml) - Add Tencent COS to s3 provider list (wjielai) - Updated mount command to reflect that it requires Go 1.13 or newer (Evan Harris) - jottacloud: Mention that uploads from local disk will not need to cache files to disk for md5 calculation (albertony) - Fix formatting of rc docs page (Nick Craig-Wood) - build - Include vendor tar ball in release and fix startdev (Nick Craig-Wood) - Fix "Illegal instruction" error for ARMv6 builds (Nick Craig-Wood) - Fix architecture name in ARMv7 build (Nick Craig-Wood) - VFS - Fix spurious error "vfs cache: failed to _ensure cache EOF" (Nick Craig-Wood) - Log an ERROR if we fail to set the file to be sparse (Nick Craig-Wood) - Local - Log an ERROR if we fail to set the file to be sparse (Nick Craig-Wood) - Drive - Re-adds special oauth help text (Tim Gallant) - Opendrive - Do not retry 400 errors (Evan Harris) v1.53.0 - 2020-09-02 See commits - New Features - The VFS layer was heavily reworked for this release - see below for more details - Interactive mode -i/--interactive for destructive operations (fishbullet) - Add --bwlimit-file flag to limit speeds of individual file transfers (Nick Craig-Wood) - Transfers are sorted by start time in the stats and progress output (Max Sum) - Make sure backends expand ~ and environment vars in file names they use (Nick Craig-Wood) - Add --refresh-times flag to set modtimes on hashless backends (Nick Craig-Wood) - build - Remove vendor directory in favour of Go modules (Nick Craig-Wood) - Build with go1.15.x by default (Nick Craig-Wood) - Drop macOS 386 build as it is no longer supported by go1.15 (Nick Craig-Wood) - Add ARMv7 to the supported builds (Nick Craig-Wood) - Enable rclone cmount on macOS (Nick Craig-Wood) - Make rclone build with gccgo (Nick Craig-Wood) - Make rclone build with wasm (Nick Craig-Wood) - Change beta numbering to be semver compatible (Nick Craig-Wood) - Add file properties and icon to Windows executable (albertony) - Add experimental interface for integrating rclone into browsers (Nick Craig-Wood) - lib: Add file name compression (Klaus Post) - rc - Allow installation and use of plugins and test plugins with rclone-webui (Chaitanya Bankanhal) - Add reverse proxy pluginsHandler for serving plugins (Chaitanya Bankanhal) - Add mount/listmounts option for listing current mounts (Chaitanya Bankanhal) - Add operations/uploadfile to upload a file through rc using encoding multipart/form-data (Chaitanya Bankanhal) - Add core/command to execute rclone terminal commands. (Chaitanya Bankanhal) - rclone check - Add reporting of filenames for same/missing/changed (Nick Craig-Wood) - Make check command obey --dry-run/-i/--interactive (Nick Craig-Wood) - Make check do --checkers files concurrently (Nick Craig-Wood) - Retry downloads if they fail when using the --download flag (Nick Craig-Wood) - Make it show stats by default (Nick Craig-Wood) - rclone obscure: Allow obscure command to accept password on STDIN (David Ibarra) - rclone config - Set RCLONE_CONFIG_DIR for use in config files and subprocesses (Nick Craig-Wood) - Reject remote names starting with a dash. (jtagcat) - rclone cryptcheck: Add reporting of filenames for same/missing/changed (Nick Craig-Wood) - rclone dedupe: Make it obey the --size-only flag for duplicate detection (Nick Craig-Wood) - rclone link: Add --expire and --unlink flags (Roman Kredentser) - rclone mkdir: Warn when using mkdir on remotes which can't have empty directories (Nick Craig-Wood) - rclone rc: Allow JSON parameters to simplify command line usage (Nick Craig-Wood) - rclone serve ftp - Don't compile on < go1.13 after dependency update (Nick Craig-Wood) - Add error message if auth proxy fails (Nick Craig-Wood) - Use refactored goftp.io/server library for binary shrink (Nick Craig-Wood) - rclone serve restic: Expose interfaces so that rclone can be used as a library from within restic (Jack) - rclone sync: Add --track-renames-strategy leaf (Nick Craig-Wood) - rclone touch: Add ability to set nanosecond resolution times (Nick Craig-Wood) - rclone tree: Remove -i shorthand for --noindent as it conflicts with -i/--interactive (Nick Craig-Wood) - Bug Fixes - accounting - Fix documentation for speed/speedAvg (Nick Craig-Wood) - Fix elapsed time not show actual time since beginning (Chaitanya Bankanhal) - Fix deadlock in stats printing (Nick Craig-Wood) - build - Fix file handle leak in GitHub release tool (Garrett Squire) - rclone check: Fix successful retries with --download counting errors (Nick Craig-Wood) - rclone dedupe: Fix logging to be easier to understand (Nick Craig-Wood) - Mount - Warn macOS users that mount implementation is changing (Nick Craig-Wood) - to test the new implementation use rclone cmount instead of rclone mount - this is because the library rclone uses has dropped macOS support - rc interface - Add call for unmount all (Chaitanya Bankanhal) - Make mount/mount remote control take vfsOpt option (Nick Craig-Wood) - Add mountOpt to mount/mount (Nick Craig-Wood) - Add VFS and Mount options to mount/listmounts (Nick Craig-Wood) - Catch panics in cgofuse initialization and turn into error messages (Nick Craig-Wood) - Always supply stat information in Readdir (Nick Craig-Wood) - Add support for reading unknown length files using direct IO (Windows) (Nick Craig-Wood) - Fix On Windows don't add -o uid/gid=-1 if user supplies -o uid/gid. (Nick Craig-Wood) - Fix macOS losing directory contents in cmount (Nick Craig-Wood) - Fix volume name broken in recent refactor (Nick Craig-Wood) - VFS - Implement partial reads for --vfs-cache-mode full (Nick Craig-Wood) - Add --vfs-writeback option to delay writes back to cloud storage (Nick Craig-Wood) - Add --vfs-read-ahead parameter for use with --vfs-cache-mode full (Nick Craig-Wood) - Restart pending uploads on restart of the cache (Nick Craig-Wood) - Support synchronous cache space recovery upon ENOSPC (Leo Luan) - Allow ReadAt and WriteAt to run concurrently with themselves (Nick Craig-Wood) - Change modtime of file before upload to current (Rob Calistri) - Recommend --vfs-cache-modes writes on backends which can't stream (Nick Craig-Wood) - Add an optional fs parameter to vfs rc methods (Nick Craig-Wood) - Fix errors when using > 260 char files in the cache in Windows (Nick Craig-Wood) - Fix renaming of items while they are being uploaded (Nick Craig-Wood) - Fix very high load caused by slow directory listings (Nick Craig-Wood) - Fix renamed files not being uploaded with --vfs-cache-mode minimal (Nick Craig-Wood) - Fix directory locking caused by slow directory listings (Nick Craig-Wood) - Fix saving from chrome without --vfs-cache-mode writes (Nick Craig-Wood) - Local - Add --local-no-updated to provide a consistent view of changing objects (Nick Craig-Wood) - Add --local-no-set-modtime option to prevent modtime changes (tyhuber1) - Fix race conditions updating and reading Object metadata (Nick Craig-Wood) - Cache - Make any created backends be cached to fix rc problems (Nick Craig-Wood) - Fix dedupe on caches wrapping drives (Nick Craig-Wood) - Crypt - Add --crypt-server-side-across-configs flag (Nick Craig-Wood) - Make any created backends be cached to fix rc problems (Nick Craig-Wood) - Alias - Make any created backends be cached to fix rc problems (Nick Craig-Wood) - Azure Blob - Don't compile on < go1.13 after dependency update (Nick Craig-Wood) - B2 - Implement server-side copy for files > 5GB (Nick Craig-Wood) - Cancel in progress multipart uploads and copies on rclone exit (Nick Craig-Wood) - Note that b2's encoding now allows  but rclone's hasn't changed (Nick Craig-Wood) - Fix transfers when using download_url (Nick Craig-Wood) - Box - Implement rclone cleanup (buengese) - Cancel in progress multipart uploads and copies on rclone exit (Nick Craig-Wood) - Allow authentication with access token (David) - Chunker - Make any created backends be cached to fix rc problems (Nick Craig-Wood) - Drive - Add rclone backend drives to list shared drives (teamdrives) (Nick Craig-Wood) - Implement rclone backend untrash (Nick Craig-Wood) - Work around drive bug which didn't set modtime of copied docs (Nick Craig-Wood) - Added --drive-starred-only to only show starred files (Jay McEntire) - Deprecate --drive-alternate-export as it is no longer needed (themylogin) - Fix duplication of Google docs on server-side copy (Nick Craig-Wood) - Fix "panic: send on closed channel" when recycling dir entries (Nick Craig-Wood) - Dropbox - Add copyright detector info in limitations section in the docs (Alex Guerrero) - Fix rclone link by removing expires parameter (Nick Craig-Wood) - Fichier - Detect Flood detected: IP Locked error and sleep for 30s (Nick Craig-Wood) - FTP - Add explicit TLS support (Heiko Bornholdt) - Add support for --dump bodies and --dump auth for debugging (Nick Craig-Wood) - Fix interoperation with pure-ftpd (Nick Craig-Wood) - Google Cloud Storage - Add support for anonymous access (Kai Lüke) - Jottacloud - Bring back legacy authentication for use with whitelabel versions (buengese) - Switch to new api root - also implement a very ugly workaround for the DirMove failures (buengese) - Onedrive - Rework cancel of multipart uploads on rclone exit (Nick Craig-Wood) - Implement rclone cleanup (Nick Craig-Wood) - Add --onedrive-no-versions flag to remove old versions (Nick Craig-Wood) - Pcloud - Implement rclone link for public link creation (buengese) - Qingstor - Cancel in progress multipart uploads on rclone exit (Nick Craig-Wood) - S3 - Preserve metadata when doing multipart copy (Nick Craig-Wood) - Cancel in progress multipart uploads and copies on rclone exit (Nick Craig-Wood) - Add rclone link for public link sharing (Roman Kredentser) - Add rclone backend restore command to restore objects from GLACIER (Nick Craig-Wood) - Add rclone cleanup and rclone backend cleanup to clean unfinished multipart uploads (Nick Craig-Wood) - Add rclone backend list-multipart-uploads to list unfinished multipart uploads (Nick Craig-Wood) - Add --s3-max-upload-parts support (Kamil Trzciński) - Add --s3-no-check-bucket for minimising rclone transactions and perms (Nick Craig-Wood) - Add --s3-profile and --s3-shared-credentials-file options (Nick Craig-Wood) - Use regional s3 us-east-1 endpoint (David) - Add Scaleway provider (Vincent Feltz) - Update IBM COS endpoints (Egor Margineanu) - Reduce the default --s3-copy-cutoff to < 5GB for Backblaze S3 compatibility (Nick Craig-Wood) - Fix detection of bucket existing (Nick Craig-Wood) - SFTP - Use the absolute path instead of the relative path for listing for improved compatibility (Nick Craig-Wood) - Add --sftp-subsystem and --sftp-server-command options (aus) - Swift - Fix dangling large objects breaking the listing (Nick Craig-Wood) - Fix purge not deleting directory markers (Nick Craig-Wood) - Fix update multipart object removing all of its own parts (Nick Craig-Wood) - Fix missing hash from object returned from upload (Nick Craig-Wood) - Tardigrade - Upgrade to uplink v1.2.0 (Kaloyan Raev) - Union - Fix writing with the all policy (Nick Craig-Wood) - WebDAV - Fix directory creation with 4shared (Nick Craig-Wood) v1.52.3 - 2020-08-07 See commits - Bug Fixes - docs - Disable smart typography (e.g. en-dash) in MANUAL.* and man page (Nick Craig-Wood) - Update install.md to reflect minimum Go version (Evan Harris) - Update install from source instructions (Nick Craig-Wood) - make_manual: Support SOURCE_DATE_EPOCH (Morten Linderud) - log: Fix --use-json-log going to stderr not --log-file on Windows (Nick Craig-Wood) - serve dlna: Fix file list on Samsung Series 6+ TVs (Matteo Pietro Dazzi) - sync: Fix deadlock with --track-renames-strategy modtime (Nick Craig-Wood) - Cache - Fix moveto/copyto remote:file remote:file2 (Nick Craig-Wood) - Drive - Stop using root_folder_id as a cache (Nick Craig-Wood) - Make dangling shortcuts appear in listings (Nick Craig-Wood) - Drop "Disabling ListR" messages down to debug (Nick Craig-Wood) - Workaround and policy for Google Drive API (Dmitry Ustalov) - FTP - Add note to docs about home vs root directory selection (Nick Craig-Wood) - Onedrive - Fix reverting to Copy when Move would have worked (Nick Craig-Wood) - Avoid comma rendered in URL in onedrive.md (Kevin) - Pcloud - Fix oauth on European region "eapi.pcloud.com" (Nick Craig-Wood) - S3 - Fix bucket Region auto detection when Region unset in config (Nick Craig-Wood) v1.52.2 - 2020-06-24 See commits - Bug Fixes - build - Fix docker release build action (Nick Craig-Wood) - Fix custom timezone in Docker image (NoLooseEnds) - check: Fix misleading message which printed errors instead of differences (Nick Craig-Wood) - errors: Add WSAECONNREFUSED and more to the list of retriable Windows errors (Nick Craig-Wood) - rcd: Fix incorrect prometheus metrics (Gary Kim) - serve restic: Fix flags so they use environment variables (Nick Craig-Wood) - serve webdav: Fix flags so they use environment variables (Nick Craig-Wood) - sync: Fix --track-renames-strategy modtime (Nick Craig-Wood) - Drive - Fix not being able to delete a directory with a trashed shortcut (Nick Craig-Wood) - Fix creating a directory inside a shortcut (Nick Craig-Wood) - Fix --drive-impersonate with cached root_folder_id (Nick Craig-Wood) - SFTP - Fix SSH key PEM loading (Zac Rubin) - Swift - Speed up deletes by not retrying segment container deletes (Nick Craig-Wood) - Tardigrade - Upgrade to uplink v1.1.1 (Caleb Case) - WebDAV - Fix free/used display for rclone about/df for certain backends (Nick Craig-Wood) v1.52.1 - 2020-06-10 See commits - Bug Fixes - lib/file: Fix SetSparse on Windows 7 which fixes downloads of files > 250MB (Nick Craig-Wood) - build - Update go.mod to go1.14 to enable -mod=vendor build (Nick Craig-Wood) - Remove quicktest from Dockerfile (Nick Craig-Wood) - Build Docker images with GitHub actions (Matteo Pietro Dazzi) - Update Docker build workflows (Nick Craig-Wood) - Set user_allow_other in /etc/fuse.conf in the Docker image (Nick Craig-Wood) - Fix xgo build after go1.14 go.mod update (Nick Craig-Wood) - docs - Add link to source and modified time to footer of every page (Nick Craig-Wood) - Remove manually set dates and use git dates instead (Nick Craig-Wood) - Minor tense, punctuation, brevity and positivity changes for the home page (edwardxml) - Remove leading slash in page reference in footer when present (Nick Craig-Wood) - Note commands which need obscured input in the docs (Nick Craig-Wood) - obscure: Write more help as we are referencing it elsewhere (Nick Craig-Wood) - VFS - Fix OS vs Unix path confusion - fixes ChangeNotify on Windows (Nick Craig-Wood) - Drive - Fix missing items when listing using --fast-list / ListR (Nick Craig-Wood) - Putio - Fix panic on Object.Open (Cenk Alti) - S3 - Fix upload of single files into buckets without create permission (Nick Craig-Wood) - Fix --header-upload (Nick Craig-Wood) - Tardigrade - Fix listing bug by upgrading to v1.0.7 - Set UserAgent to rclone (Caleb Case) v1.52.0 - 2020-05-27 Special thanks to Martin Michlmayr for proof reading and correcting all the docs and Edward Barker for helping re-write the front page. See commits - New backends - Tardigrade backend for use with storj.io (Caleb Case) - Union re-write to have multiple writable remotes (Max Sum) - Seafile for Seafile server (Fred @creativeprojects) - New commands - backend: command for backend-specific commands (see backends) (Nick Craig-Wood) - cachestats: Deprecate in favour of rclone backend stats cache: (Nick Craig-Wood) - dbhashsum: Deprecate in favour of rclone hashsum DropboxHash (Nick Craig-Wood) - New Features - Add --header-download and --header-upload flags for setting HTTP headers when uploading/downloading (Tim Gallant) - Add --header flag to add HTTP headers to every HTTP transaction (Nick Craig-Wood) - Add --check-first to do all checking before starting transfers (Nick Craig-Wood) - Add --track-renames-strategy for configurable matching criteria for --track-renames (Bernd Schoolmann) - Add --cutoff-mode hard,soft,cautious (Shing Kit Chan & Franklyn Tackitt) - Filter flags (e.g. --files-from -) can read from stdin (fishbullet) - Add --error-on-no-transfer option (Jon Fautley) - Implement --order-by xxx,mixed for copying some small and some big files (Nick Craig-Wood) - Allow --max-backlog to be negative meaning as large as possible (Nick Craig-Wood) - Added --no-unicode-normalization flag to allow Unicode filenames to remain unique (Ben Zenker) - Allow --min-age/--max-age to take a date as well as a duration (Nick Craig-Wood) - Add rename statistics for file and directory renames (Nick Craig-Wood) - Add statistics output to JSON log (reddi) - Make stats be printed on non-zero exit code (Nick Craig-Wood) - When running --password-command allow use of stdin (Sébastien Gross) - Stop empty strings being a valid remote path (Nick Craig-Wood) - accounting: support WriterTo for less memory copying (Nick Craig-Wood) - build - Update to use go1.14 for the build (Nick Craig-Wood) - Add -trimpath to release build for reproduceable builds (Nick Craig-Wood) - Remove GOOS and GOARCH from Dockerfile (Brandon Philips) - config - Fsync the config file after writing to save more reliably (Nick Craig-Wood) - Add --obscure and --no-obscure flags to config create/update (Nick Craig-Wood) - Make config show take remote: as well as remote (Nick Craig-Wood) - copyurl: Add --no-clobber flag (Denis) - delete: Added --rmdirs flag to delete directories as well (Kush) - filter: Added --files-from-raw flag (Ankur Gupta) - genautocomplete: Add support for fish shell (Matan Rosenberg) - log: Add support for syslog LOCAL facilities (Patryk Jakuszew) - lsjson: Add --hash-type parameter and use it in lsf to speed up hashing (Nick Craig-Wood) - rc - Add -o/--opt and -a/--arg for more structured input (Nick Craig-Wood) - Implement backend/command for running backend-specific commands remotely (Nick Craig-Wood) - Add mount/mount command for starting rclone mount via the API (Chaitanya) - rcd: Add Prometheus metrics support (Gary Kim) - serve http - Added a --template flag for user defined markup (calistri) - Add Last-Modified headers to files and directories (Nick Craig-Wood) - serve sftp: Add support for multiple host keys by repeating --key flag (Maxime Suret) - touch: Add --localtime flag to make --timestamp localtime not UTC (Nick Craig-Wood) - Bug Fixes - accounting - Restore "Max number of stats groups reached" log line (Michał Matczuk) - Correct exitcode on Transfer Limit Exceeded flag. (Anuar Serdaliyev) - Reset bytes read during copy retry (Ankur Gupta) - Fix race clearing stats (Nick Craig-Wood) - copy: Only create empty directories when they don't exist on the remote (Ishuah Kariuki) - dedupe: Stop dedupe deleting files with identical IDs (Nick Craig-Wood) - oauth - Use custom http client so that --no-check-certificate is honored by oauth token fetch (Mark Spieth) - Replace deprecated oauth2.NoContext (Lars Lehtonen) - operations - Fix setting the timestamp on Windows for multithread copy (Nick Craig-Wood) - Make rcat obey --ignore-checksum (Nick Craig-Wood) - Make --max-transfer more accurate (Nick Craig-Wood) - rc - Fix dropped error (Lars Lehtonen) - Fix misplaced http server config (Xiaoxing Ye) - Disable duplicate log (ElonH) - serve dlna - Cds: don't specify childCount at all when unknown (Dan Walters) - Cds: use modification time as date in dlna metadata (Dan Walters) - serve restic: Fix tests after restic project removed vendoring (Nick Craig-Wood) - sync - Fix incorrect "nothing to transfer" message using --delete-before (Nick Craig-Wood) - Only create empty directories when they don't exist on the remote (Ishuah Kariuki) - Mount - Add --async-read flag to disable asynchronous reads (Nick Craig-Wood) - Ignore --allow-root flag with a warning as it has been removed upstream (Nick Craig-Wood) - Warn if --allow-non-empty used on Windows and clarify docs (Nick Craig-Wood) - Constrain to go1.13 or above otherwise bazil.org/fuse fails to compile (Nick Craig-Wood) - Fix fail because of too long volume name (evileye) - Report 1PB free for unknown disk sizes (Nick Craig-Wood) - Map more rclone errors into file systems errors (Nick Craig-Wood) - Fix disappearing cwd problem (Nick Craig-Wood) - Use ReaddirPlus on Windows to improve directory listing performance (Nick Craig-Wood) - Send a hint as to whether the filesystem is case insensitive or not (Nick Craig-Wood) - Add rc command mount/types (Nick Craig-Wood) - Change maximum leaf name length to 1024 bytes (Nick Craig-Wood) - VFS - Add --vfs-read-wait and --vfs-write-wait flags to control time waiting for a sequential read/write (Nick Craig-Wood) - Change default --vfs-read-wait to 20ms (it was 5ms and not configurable) (Nick Craig-Wood) - Make df output more consistent on a rclone mount. (Yves G) - Report 1PB free for unknown disk sizes (Nick Craig-Wood) - Fix race condition caused by unlocked reading of Dir.path (Nick Craig-Wood) - Make File lock and Dir lock not overlap to avoid deadlock (Nick Craig-Wood) - Implement lock ordering between File and Dir to eliminate deadlocks (Nick Craig-Wood) - Factor the vfs cache into its own package (Nick Craig-Wood) - Pin the Fs in use in the Fs cache (Nick Craig-Wood) - Add SetSys() methods to Node to allow caching stuff on a node (Nick Craig-Wood) - Ignore file not found errors from Hash in Read.Release (Nick Craig-Wood) - Fix hang in read wait code (Nick Craig-Wood) - Local - Speed up multi thread downloads by using sparse files on Windows (Nick Craig-Wood) - Implement --local-no-sparse flag for disabling sparse files (Nick Craig-Wood) - Implement rclone backend noop for testing purposes (Nick Craig-Wood) - Fix "file not found" errors on post transfer Hash calculation (Nick Craig-Wood) - Cache - Implement rclone backend stats command (Nick Craig-Wood) - Fix Server Side Copy with Temp Upload (Brandon McNama) - Remove Unused Functions (Lars Lehtonen) - Disable race tests until bbolt is fixed (Nick Craig-Wood) - Move methods used for testing into test file (greatroar) - Add Pin and Unpin and canonicalised lookup (Nick Craig-Wood) - Use proper import path go.etcd.io/bbolt (Robert-André Mauchin) - Crypt - Calculate hashes for uploads from local disk (Nick Craig-Wood) - This allows encrypted Jottacloud uploads without using local disk - This means encrypted s3/b2 uploads will now have hashes - Added rclone backend decode/encode commands to replicate functionality of cryptdecode (Anagh Kumar Baranwal) - Get rid of the unused Cipher interface as it obfuscated the code (Nick Craig-Wood) - Azure Blob - Implement streaming of unknown sized files so rcat is now supported (Nick Craig-Wood) - Implement memory pooling to control memory use (Nick Craig-Wood) - Add --azureblob-disable-checksum flag (Nick Craig-Wood) - Retry InvalidBlobOrBlock error as it may indicate block concurrency problems (Nick Craig-Wood) - Remove unused Object.parseTimeString() (Lars Lehtonen) - Fix permission error on SAS URL limited to container (Nick Craig-Wood) - B2 - Add support for --header-upload and --header-download (Tim Gallant) - Ignore directory markers at the root also (Nick Craig-Wood) - Force the case of the SHA1 to lowercase (Nick Craig-Wood) - Remove unused largeUpload.clearUploadURL() (Lars Lehtonen) - Box - Add support for --header-upload and --header-download (Tim Gallant) - Implement About to read size used (Nick Craig-Wood) - Add token renew function for jwt auth (David Bramwell) - Added support for interchangeable root folder for Box backend (Sunil Patra) - Remove unnecessary iat from jws claims (David) - Drive - Follow shortcuts by default, skip with --drive-skip-shortcuts (Nick Craig-Wood) - Implement rclone backend shortcut command for creating shortcuts (Nick Craig-Wood) - Added rclone backend command to change service_account_file and chunk_size (Anagh Kumar Baranwal) - Fix missing files when using --fast-list and --drive-shared-with-me (Nick Craig-Wood) - Fix duplicate items when using --drive-shared-with-me (Nick Craig-Wood) - Extend --drive-stop-on-upload-limit to respond to teamDriveFileLimitExceeded. (harry) - Don't delete files with multiple parents to avoid data loss (Nick Craig-Wood) - Server side copy docs use default description if empty (Nick Craig-Wood) - Dropbox - Make error insufficient space to be fatal (harry) - Add info about required redirect url (Elan Ruusamäe) - Fichier - Add support for --header-upload and --header-download (Tim Gallant) - Implement custom pacer to deal with the new rate limiting (buengese) - FTP - Fix lockup when using concurrency limit on failed connections (Nick Craig-Wood) - Fix lockup on failed upload when using concurrency limit (Nick Craig-Wood) - Fix lockup on Close failures when using concurrency limit (Nick Craig-Wood) - Work around pureftp sending spurious 150 messages (Nick Craig-Wood) - Google Cloud Storage - Add support for --header-upload and --header-download (Nick Craig-Wood) - Add ARCHIVE storage class to help (Adam Stroud) - Ignore directory markers at the root (Nick Craig-Wood) - Googlephotos - Make the start year configurable (Daven) - Add support for --header-upload and --header-download (Tim Gallant) - Create feature/favorites directory (Brandon Philips) - Fix "concurrent map write" error (Nick Craig-Wood) - Don't put an image in error message (Nick Craig-Wood) - HTTP - Improved directory listing with new template from Caddy project (calisro) - Jottacloud - Implement --jottacloud-trashed-only (buengese) - Add support for --header-upload and --header-download (Tim Gallant) - Use RawURLEncoding when decoding base64 encoded login token (buengese) - Implement cleanup (buengese) - Update docs regarding cleanup, removed remains from old auth, and added warning about special mountpoints. (albertony) - Mailru - Describe 2FA requirements (valery1707) - Onedrive - Implement --onedrive-server-side-across-configs (Nick Craig-Wood) - Add support for --header-upload and --header-download (Tim Gallant) - Fix occasional 416 errors on multipart uploads (Nick Craig-Wood) - Added maximum chunk size limit warning in the docs (Harry) - Fix missing drive on config (Nick Craig-Wood) - Make error quotaLimitReached to be fatal (harry) - Opendrive - Add support for --header-upload and --header-download (Tim Gallant) - Pcloud - Added support for interchangeable root folder for pCloud backend (Sunil Patra) - Add support for --header-upload and --header-download (Tim Gallant) - Fix initial config "Auth state doesn't match" message (Nick Craig-Wood) - Premiumizeme - Add support for --header-upload and --header-download (Tim Gallant) - Prune unused functions (Lars Lehtonen) - Putio - Add support for --header-upload and --header-download (Nick Craig-Wood) - Make downloading files use the rclone http Client (Nick Craig-Wood) - Fix parsing of remotes with leading and trailing / (Nick Craig-Wood) - Qingstor - Make rclone cleanup remove pending multipart uploads older than 24h (Nick Craig-Wood) - Try harder to cancel failed multipart uploads (Nick Craig-Wood) - Prune multiUploader.list() (Lars Lehtonen) - Lint fix (Lars Lehtonen) - S3 - Add support for --header-upload and --header-download (Tim Gallant) - Use memory pool for buffer allocations (Maciej Zimnoch) - Add SSE-C support for AWS, Ceph, and MinIO (Jack Anderson) - Fail fast multipart upload (Michał Matczuk) - Report errors on bucket creation (mkdir) correctly (Nick Craig-Wood) - Specify that Minio supports URL encoding in listings (Nick Craig-Wood) - Added 500 as retryErrorCode (Michał Matczuk) - Use --low-level-retries as the number of SDK retries (Aleksandar Janković) - Fix multipart abort context (Aleksandar Jankovic) - Replace deprecated session.New() with session.NewSession() (Lars Lehtonen) - Use the provided size parameter when allocating a new memory pool (Joachim Brandon LeBlanc) - Use rclone's low level retries instead of AWS SDK to fix listing retries (Nick Craig-Wood) - Ignore directory markers at the root also (Nick Craig-Wood) - Use single memory pool (Michał Matczuk) - Do not resize buf on put to memBuf (Michał Matczuk) - Improve docs for --s3-disable-checksum (Nick Craig-Wood) - Don't leak memory or tokens in edge cases for multipart upload (Nick Craig-Wood) - Seafile - Implement 2FA (Fred) - SFTP - Added --sftp-pem-key to support inline key files (calisro) - Fix post transfer copies failing with 0 size when using set_modtime=false (Nick Craig-Wood) - Sharefile - Add support for --header-upload and --header-download (Tim Gallant) - Sugarsync - Add support for --header-upload and --header-download (Tim Gallant) - Swift - Add support for --header-upload and --header-download (Nick Craig-Wood) - Fix cosmetic issue in error message (Martin Michlmayr) - Union - Implement multiple writable remotes (Max Sum) - Fix server-side copy (Max Sum) - Implement ListR (Max Sum) - Enable ListR when upstreams contain local (Max Sum) - WebDAV - Add support for --header-upload and --header-download (Tim Gallant) - Fix X-OC-Mtime header for Transip compatibility (Nick Craig-Wood) - Report full and consistent usage with about (Yves G) - Yandex - Add support for --header-upload and --header-download (Tim Gallant) v1.51.0 - 2020-02-01 - New backends - Memory (Nick Craig-Wood) - Sugarsync (Nick Craig-Wood) - New Features - Adjust all backends to have --backend-encoding parameter (Nick Craig-Wood) - this enables the encoding for special characters to be adjusted or disabled - Add --max-duration flag to control the maximum duration of a transfer session (boosh) - Add --expect-continue-timeout flag, default 1s (Nick Craig-Wood) - Add --no-check-dest flag for copying without testing the destination (Nick Craig-Wood) - Implement --order-by flag to order transfers (Nick Craig-Wood) - accounting - Don't show entries in both transferring and checking (Nick Craig-Wood) - Add option to delete stats (Aleksandar Jankovic) - build - Compress the test builds with gzip (Nick Craig-Wood) - Implement a framework for starting test servers during tests (Nick Craig-Wood) - cmd: Always print elapsed time to tenth place seconds in progress (Gary Kim) - config - Add --password-command to allow dynamic config password (Damon Permezel) - Give config questions default values (Nick Craig-Wood) - Check a remote exists when creating a new one (Nick Craig-Wood) - copyurl: Add --stdout flag to write to stdout (Nick Craig-Wood) - dedupe: Implement keep smallest too (Nick Craig-Wood) - hashsum: Add flag --base64 flag (landall) - lsf: Speed up on s3/swift/etc by not reading mimetype by default (Nick Craig-Wood) - lsjson: Add --no-mimetype flag (Nick Craig-Wood) - rc: Add methods to turn on blocking and mutex profiling (Nick Craig-Wood) - rcd - Adding group parameter to stats (Chaitanya) - Move webgui apart; option to disable browser (Xiaoxing Ye) - serve sftp: Add support for public key with auth proxy (Paul Tinsley) - stats: Show deletes in stats and hide zero stats (anuar45) - Bug Fixes - accounting - Fix error counter counting multiple times (Ankur Gupta) - Fix error count shown as checks (Cnly) - Clear finished transfer in stats-reset (Maciej Zimnoch) - Added StatsInfo locking in statsGroups sum function (Michał Matczuk) - asyncreader: Fix EOF error (buengese) - check: Fix --one-way recursing more directories than it needs to (Nick Craig-Wood) - chunkedreader: Disable hash calculation for first segment (Nick Craig-Wood) - config - Do not open browser on headless on drive/gcs/google photos (Xiaoxing Ye) - SetValueAndSave ignore error if config section does not exist yet (buengese) - cmd: Fix completion with an encrypted config (Danil Semelenov) - dbhashsum: Stop it returning UNSUPPORTED on dropbox (Nick Craig-Wood) - dedupe: Add missing modes to help string (Nick Craig-Wood) - operations - Fix dedupe continuing on errors like insufficientFilePersimmon (SezalAgrawal) - Clear accounting before low level retry (Maciej Zimnoch) - Write debug message when hashes could not be checked (Ole Schütt) - Move interface assertion to tests to remove pflag dependency (Nick Craig-Wood) - Make NewOverrideObjectInfo public and factor uses (Nick Craig-Wood) - proxy: Replace use of bcrypt with sha256 (Nick Craig-Wood) - vendor - Update bazil.org/fuse to fix FreeBSD 12.1 (Nick Craig-Wood) - Update github.com/t3rm1n4l/go-mega to fix mega "illegal base64 data at input byte 22" (Nick Craig-Wood) - Update termbox-go to fix ncdu command on FreeBSD (Kuang-che Wu) - Update t3rm1n4l/go-mega - fixes mega: couldn't login: crypto/aes: invalid key size 0 (Nick Craig-Wood) - Mount - Enable async reads for a 20% speedup (Nick Craig-Wood) - Replace use of WriteAt with Write for cache mode >= writes and O_APPEND (Brett Dutro) - Make sure we call unmount when exiting (Nick Craig-Wood) - Don't build on go1.10 as bazil/fuse no longer supports it (Nick Craig-Wood) - When setting dates discard out of range dates (Nick Craig-Wood) - VFS - Add a newly created file straight into the directory (Nick Craig-Wood) - Only calculate one hash for reads for a speedup (Nick Craig-Wood) - Make ReadAt for non cached files work better with non-sequential reads (Nick Craig-Wood) - Fix edge cases when reading ModTime from file (Nick Craig-Wood) - Make sure existing files opened for write show correct size (Nick Craig-Wood) - Don't cache the path in RW file objects to fix renaming (Nick Craig-Wood) - Fix rename of open files when using the VFS cache (Nick Craig-Wood) - When renaming files in the cache, rename the cache item in memory too (Nick Craig-Wood) - Fix open file renaming on drive when using --vfs-cache-mode writes (Nick Craig-Wood) - Fix incorrect modtime for mv into mount with --vfs-cache-modes writes (Nick Craig-Wood) - On rename, rename in cache too if the file exists (Anagh Kumar Baranwal) - Local - Make source file being updated errors be NoLowLevelRetry errors (Nick Craig-Wood) - Fix update of hidden files on Windows (Nick Craig-Wood) - Cache - Follow move of upstream library github.com/coreos/bbolt github.com/etcd-io/bbolt (Nick Craig-Wood) - Fix fatal error: concurrent map writes (Nick Craig-Wood) - Crypt - Reorder the filename encryption options (Thomas Eales) - Correctly handle trailing dot (buengese) - Chunker - Reduce length of temporary suffix (Ivan Andreev) - Drive - Add --drive-stop-on-upload-limit flag to stop syncs when upload limit reached (Nick Craig-Wood) - Add --drive-use-shared-date to use date file was shared instead of modified date (Garry McNulty) - Make sure invalid auth for teamdrives always reports an error (Nick Craig-Wood) - Fix --fast-list when using appDataFolder (Nick Craig-Wood) - Use multipart resumable uploads for streaming and uploads in mount (Nick Craig-Wood) - Log an ERROR if an incomplete search is returned (Nick Craig-Wood) - Hide dangerous config from the configurator (Nick Craig-Wood) - Dropbox - Treat insufficient_space errors as non retriable errors (Nick Craig-Wood) - Jottacloud - Use new auth method used by official client (buengese) - Add URL to generate Login Token to config wizard (Nick Craig-Wood) - Add support whitelabel versions (buengese) - Koofr - Use rclone HTTP client. (jaKa) - Onedrive - Add Sites.Read.All permission (Benjamin Richter) - Add support "Retry-After" header (Motonori IWAMURO) - Opendrive - Implement --opendrive-chunk-size (Nick Craig-Wood) - S3 - Re-implement multipart upload to fix memory issues (Nick Craig-Wood) - Add --s3-copy-cutoff for size to switch to multipart copy (Nick Craig-Wood) - Add new region Asia Pacific (Hong Kong) (Outvi V) - Reduce memory usage streaming files by reducing max stream upload size (Nick Craig-Wood) - Add --s3-list-chunk option for bucket listing (Thomas Kriechbaumer) - Force path style bucket access to off for AWS deprecation (Nick Craig-Wood) - Use AWS web identity role provider if available (Tennix) - Add StackPath Object Storage Support (Dave Koston) - Fix ExpiryWindow value (Aleksandar Jankovic) - Fix DisableChecksum condition (Aleksandar Janković) - Fix URL decoding of NextMarker (Nick Craig-Wood) - SFTP - Add --sftp-skip-links to skip symlinks and non regular files (Nick Craig-Wood) - Retry Creation of Connection (Sebastian Brandt) - Fix "failed to parse private key file: ssh: not an encrypted key" error (Nick Craig-Wood) - Open files for update write only to fix AWS SFTP interop (Nick Craig-Wood) - Swift - Reserve segments of dynamic large object when delete objects in container what was enabled versioning. (Nguyễn Hữu Luân) - Fix parsing of X-Object-Manifest (Nick Craig-Wood) - Update OVH API endpoint (unbelauscht) - WebDAV - Make nextcloud only upload SHA1 checksums (Nick Craig-Wood) - Fix case of "Bearer" in Authorization: header to agree with RFC (Nick Craig-Wood) - Add Referer header to fix problems with WAFs (Nick Craig-Wood) v1.50.2 - 2019-11-19 - Bug Fixes - accounting: Fix memory leak on retries operations (Nick Craig-Wood) - Drive - Fix listing of the root directory with drive.files scope (Nick Craig-Wood) - Fix --drive-root-folder-id with team/shared drives (Nick Craig-Wood) v1.50.1 - 2019-11-02 - Bug Fixes - hash: Fix accidentally changed hash names for DropboxHash and CRC-32 (Nick Craig-Wood) - fshttp: Fix error reporting on tpslimit token bucket errors (Nick Craig-Wood) - fshttp: Don't print token bucket errors on context cancelled (Nick Craig-Wood) - Local - Fix listings of . on Windows (Nick Craig-Wood) - Onedrive - Fix DirMove/Move after Onedrive change (Xiaoxing Ye) v1.50.0 - 2019-10-26 - New backends - Citrix Sharefile (Nick Craig-Wood) - Chunker - an overlay backend to split files into smaller parts (Ivan Andreev) - Mail.ru Cloud (Ivan Andreev) - New Features - encodings (Fabian Möller & Nick Craig-Wood) - All backends now use file name encoding to ensure any file name can be written to any backend. - See the restricted file name docs for more info and the local backend docs. - Some file names may look different in rclone if you are using any control characters in names or unicode FULLWIDTH symbols. - build - Update to use go1.13 for the build (Nick Craig-Wood) - Drop support for go1.9 (Nick Craig-Wood) - Build rclone with GitHub actions (Nick Craig-Wood) - Convert python scripts to python3 (Nick Craig-Wood) - Swap Azure/go-ansiterm for mattn/go-colorable (Nick Craig-Wood) - Dockerfile fixes (Matei David) - Add plugin support for backends and commands (Richard Patel) - config - Use alternating Red/Green in config to make more obvious (Nick Craig-Wood) - contrib - Add sample DLNA server Docker Compose manifest. (pataquets) - Add sample WebDAV server Docker Compose manifest. (pataquets) - copyurl - Add --auto-filename flag for using file name from URL in destination path (Denis) - serve dlna: - Many compatibility improvements (Dan Walters) - Support for external srt subtitles (Dan Walters) - rc - Added command core/quit (Saksham Khanna) - Bug Fixes - sync - Make --update/-u not transfer files that haven't changed (Nick Craig-Wood) - Free objects after they come out of the transfer pipe to save memory (Nick Craig-Wood) - Fix --files-from without --no-traverse doing a recursive scan (Nick Craig-Wood) - operations - Fix accounting for server-side copies (Nick Craig-Wood) - Display 'All duplicates removed' only if dedupe successful (Sezal Agrawal) - Display 'Deleted X extra copies' only if dedupe successful (Sezal Agrawal) - accounting - Only allow up to 100 completed transfers in the accounting list to save memory (Nick Craig-Wood) - Cull the old time ranges when possible to save memory (Nick Craig-Wood) - Fix panic due to server-side copy fallback (Ivan Andreev) - Fix memory leak noticeable for transfers of large numbers of objects (Nick Craig-Wood) - Fix total duration calculation (Nick Craig-Wood) - cmd - Fix environment variables not setting command line flags (Nick Craig-Wood) - Make autocomplete compatible with bash's posix mode for macOS (Danil Semelenov) - Make --progress work in git bash on Windows (Nick Craig-Wood) - Fix 'compopt: command not found' on autocomplete on macOS (Danil Semelenov) - config - Fix setting of non top level flags from environment variables (Nick Craig-Wood) - Check config names more carefully and report errors (Nick Craig-Wood) - Remove error: can't use --size-only and --ignore-size together. (Nick Craig-Wood) - filter: Prevent mixing options when --files-from is in use (Michele Caci) - serve sftp: Fix crash on unsupported operations (e.g. Readlink) (Nick Craig-Wood) - Mount - Allow files of unknown size to be read properly (Nick Craig-Wood) - Skip tests on <= 2 CPUs to avoid lockup (Nick Craig-Wood) - Fix panic on File.Open (Nick Craig-Wood) - Fix "mount_fusefs: -o timeout=: option not supported" on FreeBSD (Nick Craig-Wood) - Don't pass huge filenames (>4k) to FUSE as it can't cope (Nick Craig-Wood) - VFS - Add flag --vfs-case-insensitive for windows/macOS mounts (Ivan Andreev) - Make objects of unknown size readable through the VFS (Nick Craig-Wood) - Move writeback of dirty data out of close() method into its own method (FlushWrites) and remove close() call from Flush() (Brett Dutro) - Stop empty dirs disappearing when renamed on bucket-based remotes (Nick Craig-Wood) - Stop change notify polling clearing so much of the directory cache (Nick Craig-Wood) - Azure Blob - Disable logging to the Windows event log (Nick Craig-Wood) - B2 - Remove unverified: prefix on sha1 to improve interop (e.g. with CyberDuck) (Nick Craig-Wood) - Box - Add options to get access token via JWT auth (David) - Drive - Disable HTTP/2 by default to work around INTERNAL_ERROR problems (Nick Craig-Wood) - Make sure that drive root ID is always canonical (Nick Craig-Wood) - Fix --drive-shared-with-me from the root with lsand --fast-list (Nick Craig-Wood) - Fix ChangeNotify polling for shared drives (Nick Craig-Wood) - Fix change notify polling when using appDataFolder (Nick Craig-Wood) - Dropbox - Make disallowed filenames errors not retry (Nick Craig-Wood) - Fix nil pointer exception on restricted files (Nick Craig-Wood) - Fichier - Fix accessing files > 2GB on 32 bit systems (Nick Craig-Wood) - FTP - Allow disabling EPSV mode (Jon Fautley) - HTTP - HEAD directory entries in parallel to speedup (Nick Craig-Wood) - Add --http-no-head to stop rclone doing HEAD in listings (Nick Craig-Wood) - Putio - Add ability to resume uploads (Cenk Alti) - S3 - Fix signature v2_auth headers (Anthony Rusdi) - Fix encoding for control characters (Nick Craig-Wood) - Only ask for URL encoded directory listings if we need them on Ceph (Nick Craig-Wood) - Add option for multipart failure behaviour (Aleksandar Jankovic) - Support for multipart copy (庄天翼) - Fix nil pointer reference if no metadata returned for object (Nick Craig-Wood) - SFTP - Fix --sftp-ask-password trying to contact the ssh agent (Nick Craig-Wood) - Fix hashes of files with backslashes (Nick Craig-Wood) - Include more ciphers with --sftp-use-insecure-cipher (Carlos Ferreyra) - WebDAV - Parse and return Sharepoint error response (Henning Surmeier) v1.49.5 - 2019-10-05 - Bug Fixes - Revert back to go1.12.x for the v1.49.x builds as go1.13.x was causing issues (Nick Craig-Wood) - Fix rpm packages by using master builds of nfpm (Nick Craig-Wood) - Fix macOS build after brew changes (Nick Craig-Wood) v1.49.4 - 2019-09-29 - Bug Fixes - cmd/rcd: Address ZipSlip vulnerability (Richard Patel) - accounting: Fix file handle leak on errors (Nick Craig-Wood) - oauthutil: Fix security problem when running with two users on the same machine (Nick Craig-Wood) - FTP - Fix listing of an empty root returning: error dir not found (Nick Craig-Wood) - S3 - Fix SetModTime on GLACIER/ARCHIVE objects and implement set/get tier (Nick Craig-Wood) v1.49.3 - 2019-09-15 - Bug Fixes - accounting - Fix total duration calculation (Aleksandar Jankovic) - Fix "file already closed" on transfer retries (Nick Craig-Wood) v1.49.2 - 2019-09-08 - New Features - build: Add Docker workflow support (Alfonso Montero) - Bug Fixes - accounting: Fix locking in Transfer to avoid deadlock with --progress (Nick Craig-Wood) - docs: Fix template argument for mktemp in install.sh (Cnly) - operations: Fix -u/--update with google photos / files of unknown size (Nick Craig-Wood) - rc: Fix docs for config/create /update /password (Nick Craig-Wood) - Google Cloud Storage - Fix need for elevated permissions on SetModTime (Nick Craig-Wood) v1.49.1 - 2019-08-28 - Bug Fixes - config: Fix generated passwords being stored as empty password (Nick Craig-Wood) - rcd: Added missing parameter for web-gui info logs. (Chaitanya) - Googlephotos - Fix crash on error response (Nick Craig-Wood) - Onedrive - Fix crash on error response (Nick Craig-Wood) v1.49.0 - 2019-08-26 - New backends - 1fichier (Laura Hausmann) - Google Photos (Nick Craig-Wood) - Putio (Cenk Alti) - premiumize.me (Nick Craig-Wood) - New Features - Experimental web GUI (Chaitanya Bankanhal) - Implement --compare-dest & --copy-dest (yparitcher) - Implement --suffix without --backup-dir for backup to current dir (yparitcher) - config reconnect to re-login (re-run the oauth login) for the backend. (Nick Craig-Wood) - config userinfo to discover which user you are logged in as. (Nick Craig-Wood) - config disconnect to disconnect you (log out) from the backend. (Nick Craig-Wood) - Add --use-json-log for JSON logging (justinalin) - Add context propagation to rclone (Aleksandar Jankovic) - Reworking internal statistics interfaces so they work with rc jobs (Aleksandar Jankovic) - Add Higher units for ETA (AbelThar) - Update rclone logos to new design (Andreas Chlupka) - hash: Add CRC-32 support (Cenk Alti) - help showbackend: Fixed advanced option category when there are no standard options (buengese) - ncdu: Display/Copy to Clipboard Current Path (Gary Kim) - operations: - Run hashing operations in parallel (Nick Craig-Wood) - Don't calculate checksums when using --ignore-checksum (Nick Craig-Wood) - Check transfer hashes when using --size-only mode (Nick Craig-Wood) - Disable multi thread copy for local to local copies (Nick Craig-Wood) - Debug successful hashes as well as failures (Nick Craig-Wood) - rc - Add ability to stop async jobs (Aleksandar Jankovic) - Return current settings if core/bwlimit called without parameters (Nick Craig-Wood) - Rclone-WebUI integration with rclone (Chaitanya Bankanhal) - Added command line parameter to control the cross origin resource sharing (CORS) in the rcd. (Security Improvement) (Chaitanya Bankanhal) - Add anchor tags to the docs so links are consistent (Nick Craig-Wood) - Remove _async key from input parameters after parsing so later operations won't get confused (buengese) - Add call to clear stats (Aleksandar Jankovic) - rcd - Auto-login for web-gui (Chaitanya Bankanhal) - Implement --baseurl for rcd and web-gui (Chaitanya Bankanhal) - serve dlna - Only select interfaces which can multicast for SSDP (Nick Craig-Wood) - Add more builtin mime types to cover standard audio/video (Nick Craig-Wood) - Fix missing mime types on Android causing missing videos (Nick Craig-Wood) - serve ftp - Refactor to bring into line with other serve commands (Nick Craig-Wood) - Implement --auth-proxy (Nick Craig-Wood) - serve http: Implement --baseurl (Nick Craig-Wood) - serve restic: Implement --baseurl (Nick Craig-Wood) - serve sftp - Implement auth proxy (Nick Craig-Wood) - Fix detection of whether server is authorized (Nick Craig-Wood) - serve webdav - Implement --baseurl (Nick Craig-Wood) - Support --auth-proxy (Nick Craig-Wood) - Bug Fixes - Make "bad record MAC" a retriable error (Nick Craig-Wood) - copyurl: Fix copying files that return HTTP errors (Nick Craig-Wood) - march: Fix checking sub-directories when using --no-traverse (buengese) - rc - Fix unmarshalable http.AuthFn in options and put in test for marshalability (Nick Craig-Wood) - Move job expire flags to rc to fix initialization problem (Nick Craig-Wood) - Fix --loopback with rc/list and others (Nick Craig-Wood) - rcat: Fix slowdown on systems with multiple hashes (Nick Craig-Wood) - rcd: Fix permissions problems on cache directory with web gui download (Nick Craig-Wood) - Mount - Default --daemon-timeout to 15 minutes on macOS and FreeBSD (Nick Craig-Wood) - Update docs to show mounting from root OK for bucket-based (Nick Craig-Wood) - Remove nonseekable flag from write files (Nick Craig-Wood) - VFS - Make write without cache more efficient (Nick Craig-Wood) - Fix --vfs-cache-mode minimal and writes ignoring cached files (Nick Craig-Wood) - Local - Add --local-case-sensitive and --local-case-insensitive (Nick Craig-Wood) - Avoid polluting page cache when uploading local files to remote backends (Michał Matczuk) - Don't calculate any hashes by default (Nick Craig-Wood) - Fadvise run syscall on a dedicated go routine (Michał Matczuk) - Azure Blob - Azure Storage Emulator support (Sandeep) - Updated config help details to remove connection string references (Sandeep) - Make all operations work from the root (Nick Craig-Wood) - B2 - Implement link sharing (yparitcher) - Enable server-side copy to copy between buckets (Nick Craig-Wood) - Make all operations work from the root (Nick Craig-Wood) - Drive - Fix server-side copy of big files (Nick Craig-Wood) - Update API for teamdrive use (Nick Craig-Wood) - Add error for purge with --drive-trashed-only (ginvine) - Fichier - Make FolderID int and adjust related code (buengese) - Google Cloud Storage - Reduce oauth scope requested as suggested by Google (Nick Craig-Wood) - Make all operations work from the root (Nick Craig-Wood) - HTTP - Add --http-headers flag for setting arbitrary headers (Nick Craig-Wood) - Jottacloud - Use new api for retrieving internal username (buengese) - Refactor configuration and minor cleanup (buengese) - Koofr - Support setting modification times on Koofr backend. (jaKa) - Opendrive - Refactor to use existing lib/rest facilities for uploads (Nick Craig-Wood) - Qingstor - Upgrade to v3 SDK and fix listing loop (Nick Craig-Wood) - Make all operations work from the root (Nick Craig-Wood) - S3 - Add INTELLIGENT_TIERING storage class (Matti Niemenmaa) - Make all operations work from the root (Nick Craig-Wood) - SFTP - Add missing interface check and fix About (Nick Craig-Wood) - Completely ignore all modtime checks if SetModTime=false (Jon Fautley) - Support md5/sha1 with rsync.net (Nick Craig-Wood) - Save the md5/sha1 command in use to the config file for efficiency (Nick Craig-Wood) - Opt-in support for diffie-hellman-group-exchange-sha256 diffie-hellman-group-exchange-sha1 (Yi FU) - Swift - Use FixRangeOption to fix 0 length files via the VFS (Nick Craig-Wood) - Fix upload when using no_chunk to return the correct size (Nick Craig-Wood) - Make all operations work from the root (Nick Craig-Wood) - Fix segments leak during failed large file uploads. (nguyenhuuluan434) - WebDAV - Add --webdav-bearer-token-command (Nick Craig-Wood) - Refresh token when it expires with --webdav-bearer-token-command (Nick Craig-Wood) - Add docs for using bearer_token_command with oidc-agent (Paul Millar) v1.48.0 - 2019-06-15 - New commands - serve sftp: Serve an rclone remote over SFTP (Nick Craig-Wood) - New Features - Multi threaded downloads to local storage (Nick Craig-Wood) - controlled with --multi-thread-cutoff and --multi-thread-streams - Use rclone.conf from rclone executable directory to enable portable use (albertony) - Allow sync of a file and a directory with the same name (forgems) - this is common on bucket-based remotes, e.g. s3, gcs - Add --ignore-case-sync for forced case insensitivity (garry415) - Implement --stats-one-line-date and --stats-one-line-date-format (Peter Berbec) - Log an ERROR for all commands which exit with non-zero status (Nick Craig-Wood) - Use go-homedir to read the home directory more reliably (Nick Craig-Wood) - Enable creating encrypted config through external script invocation (Wojciech Smigielski) - build: Drop support for go1.8 (Nick Craig-Wood) - config: Make config create/update encrypt passwords where necessary (Nick Craig-Wood) - copyurl: Honor --no-check-certificate (Stefan Breunig) - install: Linux skip man pages if no mandb (didil) - lsf: Support showing the Tier of the object (Nick Craig-Wood) - lsjson - Added EncryptedPath to output (calisro) - Support showing the Tier of the object (Nick Craig-Wood) - Add IsBucket field for bucket-based remote listing of the root (Nick Craig-Wood) - rc - Add --loopback flag to run commands directly without a server (Nick Craig-Wood) - Add operations/fsinfo: Return information about the remote (Nick Craig-Wood) - Skip auth for OPTIONS request (Nick Craig-Wood) - cmd/providers: Add DefaultStr, ValueStr and Type fields (Nick Craig-Wood) - jobs: Make job expiry timeouts configurable (Aleksandar Jankovic) - serve dlna reworked and improved (Dan Walters) - serve ftp: add --ftp-public-ip flag to specify public IP (calistri) - serve restic: Add support for --private-repos in serve restic (Florian Apolloner) - serve webdav: Combine serve webdav and serve http (Gary Kim) - size: Ignore negative sizes when calculating total (Garry McNulty) - Bug Fixes - Make move and copy individual files obey --backup-dir (Nick Craig-Wood) - If --ignore-checksum is in effect, don't calculate checksum (Nick Craig-Wood) - moveto: Fix case-insensitive same remote move (Gary Kim) - rc: Fix serving bucket-based objects with --rc-serve (Nick Craig-Wood) - serve webdav: Fix serveDir not being updated with changes from webdav (Gary Kim) - Mount - Fix poll interval documentation (Animosity022) - VFS - Make WriteAt for non cached files work with non-sequential writes (Nick Craig-Wood) - Local - Only calculate the required hashes for big speedup (Nick Craig-Wood) - Log errors when listing instead of returning an error (Nick Craig-Wood) - Fix preallocate warning on Linux with ZFS (Nick Craig-Wood) - Crypt - Make rclone dedupe work through crypt (Nick Craig-Wood) - Fix wrapping of ChangeNotify to decrypt directories properly (Nick Craig-Wood) - Support PublicLink (rclone link) of underlying backend (Nick Craig-Wood) - Implement Optional methods SetTier, GetTier (Nick Craig-Wood) - B2 - Implement server-side copy (Nick Craig-Wood) - Implement SetModTime (Nick Craig-Wood) - Drive - Fix move and copy from TeamDrive to GDrive (Fionera) - Add notes that cleanup works in the background on drive (Nick Craig-Wood) - Add --drive-server-side-across-configs to default back to old server-side copy semantics by default (Nick Craig-Wood) - Add --drive-size-as-quota to show storage quota usage for file size (Garry McNulty) - FTP - Add FTP List timeout (Jeff Quinn) - Add FTP over TLS support (Gary Kim) - Add --ftp-no-check-certificate option for FTPS (Gary Kim) - Google Cloud Storage - Fix upload errors when uploading pre 1970 files (Nick Craig-Wood) - Jottacloud - Add support for selecting device and mountpoint. (buengese) - Mega - Add cleanup support (Gary Kim) - Onedrive - More accurately check if root is found (Cnly) - S3 - Support S3 Accelerated endpoints with --s3-use-accelerate-endpoint (Nick Craig-Wood) - Add config info for Wasabi's EU Central endpoint (Robert Marko) - Make SetModTime work for GLACIER while syncing (Philip Harvey) - SFTP - Add About support (Gary Kim) - Fix about parsing of df results so it can cope with -ve results (Nick Craig-Wood) - Send custom client version and debug server version (Nick Craig-Wood) - WebDAV - Retry on 423 Locked errors (Nick Craig-Wood) v1.47.0 - 2019-04-13 - New backends - Backend for Koofr cloud storage service. (jaKa) - New Features - Resume downloads if the reader fails in copy (Nick Craig-Wood) - this means rclone will restart transfers if the source has an error - this is most useful for downloads or cloud to cloud copies - Use --fast-list for listing operations where it won't use more memory (Nick Craig-Wood) - this should speed up the following operations on remotes which support ListR - dedupe, serve restic lsf, ls, lsl, lsjson, lsd, md5sum, sha1sum, hashsum, size, delete, cat, settier - use --disable ListR to get old behaviour if required - Make --files-from traverse the destination unless --no-traverse is set (Nick Craig-Wood) - this fixes --files-from with Google drive and excessive API use in general. - Make server-side copy account bytes and obey --max-transfer (Nick Craig-Wood) - Add --create-empty-src-dirs flag and default to not creating empty dirs (ishuah) - Add client side TLS/SSL flags --ca-cert/--client-cert/--client-key (Nick Craig-Wood) - Implement --suffix-keep-extension for use with --suffix (Nick Craig-Wood) - build: - Switch to semver compliant version tags to be go modules compliant (Nick Craig-Wood) - Update to use go1.12.x for the build (Nick Craig-Wood) - serve dlna: Add connection manager service description to improve compatibility (Dan Walters) - lsf: Add 'e' format to show encrypted names and 'o' for original IDs (Nick Craig-Wood) - lsjson: Added --files-only and --dirs-only flags (calistri) - rc: Implement operations/publiclink the equivalent of rclone link (Nick Craig-Wood) - Bug Fixes - accounting: Fix total ETA when --stats-unit bits is in effect (Nick Craig-Wood) - Bash TAB completion - Use private custom func to fix clash between rclone and kubectl (Nick Craig-Wood) - Fix for remotes with underscores in their names (Six) - Fix completion of remotes (Florian Gamböck) - Fix autocompletion of remote paths with spaces (Danil Semelenov) - serve dlna: Fix root XML service descriptor (Dan Walters) - ncdu: Fix display corruption with Chinese characters (Nick Craig-Wood) - Add SIGTERM to signals which run the exit handlers on unix (Nick Craig-Wood) - rc: Reload filter when the options are set via the rc (Nick Craig-Wood) - VFS / Mount - Fix FreeBSD: Ignore Truncate if called with no readers and already the correct size (Nick Craig-Wood) - Read directory and check for a file before mkdir (Nick Craig-Wood) - Shorten the locking window for vfs/refresh (Nick Craig-Wood) - Azure Blob - Enable MD5 checksums when uploading files bigger than the "Cutoff" (Dr.Rx) - Fix SAS URL support (Nick Craig-Wood) - B2 - Allow manual configuration of backblaze downloadUrl (Vince) - Ignore already_hidden error on remove (Nick Craig-Wood) - Ignore malformed src_last_modified_millis (Nick Craig-Wood) - Drive - Add --skip-checksum-gphotos to ignore incorrect checksums on Google Photos (Nick Craig-Wood) - Allow server-side move/copy between different remotes. (Fionera) - Add docs on team drives and --fast-list eventual consistency (Nestar47) - Fix imports of text files (Nick Craig-Wood) - Fix range requests on 0 length files (Nick Craig-Wood) - Fix creation of duplicates with server-side copy (Nick Craig-Wood) - Dropbox - Retry blank errors to fix long listings (Nick Craig-Wood) - FTP - Add --ftp-concurrency to limit maximum number of connections (Nick Craig-Wood) - Google Cloud Storage - Fall back to default application credentials (marcintustin) - Allow bucket policy only buckets (Nick Craig-Wood) - HTTP - Add --http-no-slash for websites with directories with no slashes (Nick Craig-Wood) - Remove duplicates from listings (Nick Craig-Wood) - Fix socket leak on 404 errors (Nick Craig-Wood) - Jottacloud - Fix token refresh (Sebastian Bünger) - Add device registration (Oliver Heyme) - Onedrive - Implement graceful cancel of multipart uploads if rclone is interrupted (Cnly) - Always add trailing colon to path when addressing items, (Cnly) - Return errors instead of panic for invalid uploads (Fabian Möller) - S3 - Add support for "Glacier Deep Archive" storage class (Manu) - Update Dreamhost endpoint (Nick Craig-Wood) - Note incompatibility with CEPH Jewel (Nick Craig-Wood) - SFTP - Allow custom ssh client config (Alexandru Bumbacea) - Swift - Obey Retry-After to enable OVH restore from cold storage (Nick Craig-Wood) - Work around token expiry on CEPH (Nick Craig-Wood) - WebDAV - Allow IsCollection property to be integer or boolean (Nick Craig-Wood) - Fix race when creating directories (Nick Craig-Wood) - Fix About/df when reading the available/total returns 0 (Nick Craig-Wood) v1.46 - 2019-02-09 - New backends - Support Alibaba Cloud (Aliyun) OSS via the s3 backend (Nick Craig-Wood) - New commands - serve dlna: serves a remove via DLNA for the local network (nicolov) - New Features - copy, move: Restore deprecated --no-traverse flag (Nick Craig-Wood) - This is useful for when transferring a small number of files into a large destination - genautocomplete: Add remote path completion for bash completion (Christopher Peterson & Danil Semelenov) - Buffer memory handling reworked to return memory to the OS better (Nick Craig-Wood) - Buffer recycling library to replace sync.Pool - Optionally use memory mapped memory for better memory shrinking - Enable with --use-mmap if having memory problems - not default yet - Parallelise reading of files specified by --files-from (Nick Craig-Wood) - check: Add stats showing total files matched. (Dario Guzik) - Allow rename/delete open files under Windows (Nick Craig-Wood) - lsjson: Use exactly the correct number of decimal places in the seconds (Nick Craig-Wood) - Add cookie support with cmdline switch --use-cookies for all HTTP based remotes (qip) - Warn if --checksum is set but there are no hashes available (Nick Craig-Wood) - Rework rate limiting (pacer) to be more accurate and allow bursting (Nick Craig-Wood) - Improve error reporting for too many/few arguments in commands (Nick Craig-Wood) - listremotes: Remove -l short flag as it conflicts with the new global flag (weetmuts) - Make http serving with auth generate INFO messages on auth fail (Nick Craig-Wood) - Bug Fixes - Fix layout of stats (Nick Craig-Wood) - Fix --progress crash under Windows Jenkins (Nick Craig-Wood) - Fix transfer of google/onedrive docs by calling Rcat in Copy when size is -1 (Cnly) - copyurl: Fix checking of --dry-run (Denis Skovpen) - Mount - Check that mountpoint and local directory to mount don't overlap (Nick Craig-Wood) - Fix mount size under 32 bit Windows (Nick Craig-Wood) - VFS - Implement renaming of directories for backends without DirMove (Nick Craig-Wood) - now all backends except b2 support renaming directories - Implement --vfs-cache-max-size to limit the total size of the cache (Nick Craig-Wood) - Add --dir-perms and --file-perms flags to set default permissions (Nick Craig-Wood) - Fix deadlock on concurrent operations on a directory (Nick Craig-Wood) - Fix deadlock between RWFileHandle.close and File.Remove (Nick Craig-Wood) - Fix renaming/deleting open files with cache mode "writes" under Windows (Nick Craig-Wood) - Fix panic on rename with --dry-run set (Nick Craig-Wood) - Fix vfs/refresh with recurse=true needing the --fast-list flag - Local - Add support for -l/--links (symbolic link translation) (yair@unicorn) - this works by showing links as link.rclonelink - see local backend docs for more info - this errors if used with -L/--copy-links - Fix renaming/deleting open files on Windows (Nick Craig-Wood) - Crypt - Check for maximum length before decrypting filename to fix panic (Garry McNulty) - Azure Blob - Allow building azureblob backend on *BSD (themylogin) - Use the rclone HTTP client to support --dump headers, --tpslimit, etc. (Nick Craig-Wood) - Use the s3 pacer for 0 delay in non error conditions (Nick Craig-Wood) - Ignore directory markers (Nick Craig-Wood) - Stop Mkdir attempting to create existing containers (Nick Craig-Wood) - B2 - cleanup: will remove unfinished large files >24hrs old (Garry McNulty) - For a bucket limited application key check the bucket name (Nick Craig-Wood) - before this, rclone would use the authorised bucket regardless of what you put on the command line - Added --b2-disable-checksum flag (Wojciech Smigielski) - this enables large files to be uploaded without a SHA-1 hash for speed reasons - Drive - Set default pacer to 100ms for 10 tps (Nick Craig-Wood) - This fits the Google defaults much better and reduces the 403 errors massively - Add --drive-pacer-min-sleep and --drive-pacer-burst to control the pacer - Improve ChangeNotify support for items with multiple parents (Fabian Möller) - Fix ListR for items with multiple parents - this fixes oddities with vfs/refresh (Fabian Möller) - Fix using --drive-impersonate and appfolders (Nick Craig-Wood) - Fix google docs in rclone mount for some (not all) applications (Nick Craig-Wood) - Dropbox - Retry-After support for Dropbox backend (Mathieu Carbou) - FTP - Wait for 60 seconds for a connection to Close then declare it dead (Nick Craig-Wood) - helps with indefinite hangs on some FTP servers - Google Cloud Storage - Update google cloud storage endpoints (weetmuts) - HTTP - Add an example with username and password which is supported but wasn't documented (Nick Craig-Wood) - Fix backend with --files-from and nonexistent files (Nick Craig-Wood) - Hubic - Make error message more informative if authentication fails (Nick Craig-Wood) - Jottacloud - Resume and deduplication support (Oliver Heyme) - Use token auth for all API requests Don't store password anymore (Sebastian Bünger) - Add support for 2-factor authentication (Sebastian Bünger) - Mega - Implement v2 account login which fixes logins for newer Mega accounts (Nick Craig-Wood) - Return error if an unknown length file is attempted to be uploaded (Nick Craig-Wood) - Add new error codes for better error reporting (Nick Craig-Wood) - Onedrive - Fix broken support for "shared with me" folders (Alex Chen) - Fix root ID not normalised (Cnly) - Return err instead of panic on unknown-sized uploads (Cnly) - Qingstor - Fix go routine leak on multipart upload errors (Nick Craig-Wood) - Add upload chunk size/concurrency/cutoff control (Nick Craig-Wood) - Default --qingstor-upload-concurrency to 1 to work around bug (Nick Craig-Wood) - S3 - Implement --s3-upload-cutoff for single part uploads below this (Nick Craig-Wood) - Change --s3-upload-concurrency default to 4 to increase performance (Nick Craig-Wood) - Add --s3-bucket-acl to control bucket ACL (Nick Craig-Wood) - Auto detect region for buckets on operation failure (Nick Craig-Wood) - Add GLACIER storage class (William Cocker) - Add Scaleway to s3 documentation (Rémy Léone) - Add AWS endpoint eu-north-1 (weetmuts) - SFTP - Add support for PEM encrypted private keys (Fabian Möller) - Add option to force the usage of an ssh-agent (Fabian Möller) - Perform environment variable expansion on key-file (Fabian Möller) - Fix rmdir on Windows based servers (e.g. CrushFTP) (Nick Craig-Wood) - Fix rmdir deleting directory contents on some SFTP servers (Nick Craig-Wood) - Fix error on dangling symlinks (Nick Craig-Wood) - Swift - Add --swift-no-chunk to disable segmented uploads in rcat/mount (Nick Craig-Wood) - Introduce application credential auth support (kayrus) - Fix memory usage by slimming Object (Nick Craig-Wood) - Fix extra requests on upload (Nick Craig-Wood) - Fix reauth on big files (Nick Craig-Wood) - Union - Fix poll-interval not working (Nick Craig-Wood) - WebDAV - Support About which means rclone mount will show the correct disk size (Nick Craig-Wood) - Support MD5 and SHA1 hashes with Owncloud and Nextcloud (Nick Craig-Wood) - Fail soft on time parsing errors (Nick Craig-Wood) - Fix infinite loop on failed directory creation (Nick Craig-Wood) - Fix identification of directories for Bitrix Site Manager (Nick Craig-Wood) - Fix upload of 0 length files on some servers (Nick Craig-Wood) - Fix if MKCOL fails with 423 Locked assume the directory exists (Nick Craig-Wood) v1.45 - 2018-11-24 - New backends - The Yandex backend was re-written - see below for details (Sebastian Bünger) - New commands - rcd: New command just to serve the remote control API (Nick Craig-Wood) - New Features - The remote control API (rc) was greatly expanded to allow full control over rclone (Nick Craig-Wood) - sensitive operations require authorization or the --rc-no-auth flag - config/* operations to configure rclone - options/* for reading/setting command line flags - operations/* for all low level operations, e.g. copy file, list directory - sync/* for sync, copy and move - --rc-files flag to serve files on the rc http server - this is for building web native GUIs for rclone - Optionally serving objects on the rc http server - Ensure rclone fails to start up if the --rc port is in use already - See the rc docs for more info - sync/copy/move - Make --files-from only read the objects specified and don't scan directories (Nick Craig-Wood) - This is a huge speed improvement for destinations with lots of files - filter: Add --ignore-case flag (Nick Craig-Wood) - ncdu: Add remove function ('d' key) (Henning Surmeier) - rc command - Add --json flag for structured JSON input (Nick Craig-Wood) - Add --user and --pass flags and interpret --rc-user, --rc-pass, --rc-addr (Nick Craig-Wood) - build - Require go1.8 or later for compilation (Nick Craig-Wood) - Enable softfloat on MIPS arch (Scott Edlund) - Integration test framework revamped with a better report and better retries (Nick Craig-Wood) - Bug Fixes - cmd: Make --progress update the stats correctly at the end (Nick Craig-Wood) - config: Create config directory on save if it is missing (Nick Craig-Wood) - dedupe: Check for existing filename before renaming a dupe file (ssaqua) - move: Don't create directories with --dry-run (Nick Craig-Wood) - operations: Fix Purge and Rmdirs when dir is not the root (Nick Craig-Wood) - serve http/webdav/restic: Ensure rclone exits if the port is in use (Nick Craig-Wood) - Mount - Make --volname work for Windows and macOS (Nick Craig-Wood) - Azure Blob - Avoid context deadline exceeded error by setting a large TryTimeout value (brused27) - Fix erroneous Rmdir error "directory not empty" (Nick Craig-Wood) - Wait for up to 60s to create a just deleted container (Nick Craig-Wood) - Dropbox - Add dropbox impersonate support (Jake Coggiano) - Jottacloud - Fix bug in --fast-list handing of empty folders (albertony) - Opendrive - Fix transfer of files with + and & in (Nick Craig-Wood) - Fix retries of upload chunks (Nick Craig-Wood) - S3 - Set ACL for server-side copies to that provided by the user (Nick Craig-Wood) - Fix role_arn, credential_source, ... (Erik Swanson) - Add config info for Wasabi's US-West endpoint (Henry Ptasinski) - SFTP - Ensure file hash checking is really disabled (Jon Fautley) - Swift - Add pacer for retries to make swift more reliable (Nick Craig-Wood) - WebDAV - Add Content-Type to PUT requests (Nick Craig-Wood) - Fix config parsing so --webdav-user and --webdav-pass flags work (Nick Craig-Wood) - Add RFC3339 date format (Ralf Hemberger) - Yandex - The yandex backend was re-written (Sebastian Bünger) - This implements low level retries (Sebastian Bünger) - Copy, Move, DirMove, PublicLink and About optional interfaces (Sebastian Bünger) - Improved general error handling (Sebastian Bünger) - Removed ListR for now due to inconsistent behaviour (Sebastian Bünger) v1.44 - 2018-10-15 - New commands - serve ftp: Add ftp server (Antoine GIRARD) - settier: perform storage tier changes on supported remotes (sandeepkru) - New Features - Reworked command line help - Make default help less verbose (Nick Craig-Wood) - Split flags up into global and backend flags (Nick Craig-Wood) - Implement specialised help for flags and backends (Nick Craig-Wood) - Show URL of backend help page when starting config (Nick Craig-Wood) - stats: Long names now split in center (Joanna Marek) - Add --log-format flag for more control over log output (dcpu) - rc: Add support for OPTIONS and basic CORS (frenos) - stats: show FatalErrors and NoRetryErrors in stats (Cédric Connes) - Bug Fixes - Fix -P not ending with a new line (Nick Craig-Wood) - config: don't create default config dir when user supplies --config (albertony) - Don't print non-ASCII characters with --progress on windows (Nick Craig-Wood) - Correct logs for excluded items (ssaqua) - Mount - Remove EXPERIMENTAL tags (Nick Craig-Wood) - VFS - Fix race condition detected by serve ftp tests (Nick Craig-Wood) - Add vfs/poll-interval rc command (Fabian Möller) - Enable rename for nearly all remotes using server-side Move or Copy (Nick Craig-Wood) - Reduce directory cache cleared by poll-interval (Fabian Möller) - Remove EXPERIMENTAL tags (Nick Craig-Wood) - Local - Skip bad symlinks in dir listing with -L enabled (Cédric Connes) - Preallocate files on Windows to reduce fragmentation (Nick Craig-Wood) - Preallocate files on linux with fallocate(2) (Nick Craig-Wood) - Cache - Add cache/fetch rc function (Fabian Möller) - Fix worker scale down (Fabian Möller) - Improve performance by not sending info requests for cached chunks (dcpu) - Fix error return value of cache/fetch rc method (Fabian Möller) - Documentation fix for cache-chunk-total-size (Anagh Kumar Baranwal) - Preserve leading / in wrapped remote path (Fabian Möller) - Add plex_insecure option to skip certificate validation (Fabian Möller) - Remove entries that no longer exist in the source (dcpu) - Crypt - Preserve leading / in wrapped remote path (Fabian Möller) - Alias - Fix handling of Windows network paths (Nick Craig-Wood) - Azure Blob - Add --azureblob-list-chunk parameter (Santiago Rodríguez) - Implemented settier command support on azureblob remote. (sandeepkru) - Work around SDK bug which causes errors for chunk-sized files (Nick Craig-Wood) - Box - Implement link sharing. (Sebastian Bünger) - Drive - Add --drive-import-formats - google docs can now be imported (Fabian Möller) - Rewrite mime type and extension handling (Fabian Möller) - Add document links (Fabian Möller) - Add support for multipart document extensions (Fabian Möller) - Add support for apps-script to json export (Fabian Möller) - Fix escaped chars in documents during list (Fabian Möller) - Add --drive-v2-download-min-size a workaround for slow downloads (Fabian Möller) - Improve directory notifications in ChangeNotify (Fabian Möller) - When listing team drives in config, continue on failure (Nick Craig-Wood) - FTP - Add a small pause after failed upload before deleting file (Nick Craig-Wood) - Google Cloud Storage - Fix service_account_file being ignored (Fabian Möller) - Jottacloud - Minor improvement in quota info (omit if unlimited) (albertony) - Add --fast-list support (albertony) - Add permanent delete support: --jottacloud-hard-delete (albertony) - Add link sharing support (albertony) - Fix handling of reserved characters. (Sebastian Bünger) - Fix socket leak on Object.Remove (Nick Craig-Wood) - Onedrive - Rework to support Microsoft Graph (Cnly) - NB this will require re-authenticating the remote - Removed upload cutoff and always do session uploads (Oliver Heyme) - Use single-part upload for empty files (Cnly) - Fix new fields not saved when editing old config (Alex Chen) - Fix sometimes special chars in filenames not replaced (Alex Chen) - Ignore OneNote files by default (Alex Chen) - Add link sharing support (jackyzy823) - S3 - Use custom pacer, to retry operations when reasonable (Craig Miskell) - Use configured server-side-encryption and storage class options when calling CopyObject() (Paul Kohout) - Make --s3-v2-auth flag (Nick Craig-Wood) - Fix v2 auth on files with spaces (Nick Craig-Wood) - Union - Implement union backend which reads from multiple backends (Felix Brucker) - Implement optional interfaces (Move, DirMove, Copy, etc.) (Nick Craig-Wood) - Fix ChangeNotify to support multiple remotes (Fabian Möller) - Fix --backup-dir on union backend (Nick Craig-Wood) - WebDAV - Add another time format (Nick Craig-Wood) - Add a small pause after failed upload before deleting file (Nick Craig-Wood) - Add workaround for missing mtime (buergi) - Sharepoint: Renew cookies after 12hrs (Henning Surmeier) - Yandex - Remove redundant nil checks (teresy) v1.43.1 - 2018-09-07 Point release to fix hubic and azureblob backends. - Bug Fixes - ncdu: Return error instead of log.Fatal in Show (Fabian Möller) - cmd: Fix crash with --progress and --stats 0 (Nick Craig-Wood) - docs: Tidy website display (Anagh Kumar Baranwal) - Azure Blob: - Fix multi-part uploads. (sandeepkru) - Hubic - Fix uploads (Nick Craig-Wood) - Retry auth fetching if it fails to make hubic more reliable (Nick Craig-Wood) v1.43 - 2018-09-01 - New backends - Jottacloud (Sebastian Bünger) - New commands - copyurl: copies a URL to a remote (Denis) - New Features - Reworked config for backends (Nick Craig-Wood) - All backend config can now be supplied by command line, env var or config file - Advanced section in the config wizard for the optional items - A large step towards rclone backends being usable in other go software - Allow on the fly remotes with :backend: syntax - Stats revamp - Add --progress/-P flag to show interactive progress (Nick Craig-Wood) - Show the total progress of the sync in the stats (Nick Craig-Wood) - Add --stats-one-line flag for single line stats (Nick Craig-Wood) - Added weekday schedule into --bwlimit (Mateusz) - lsjson: Add option to show the original object IDs (Fabian Möller) - serve webdav: Make Content-Type without reading the file and add --etag-hash (Nick Craig-Wood) - build - Build macOS with native compiler (Nick Craig-Wood) - Update to use go1.11 for the build (Nick Craig-Wood) - rc - Added core/stats to return the stats (reddi1) - version --check: Prints the current release and beta versions (Nick Craig-Wood) - Bug Fixes - accounting - Fix time to completion estimates (Nick Craig-Wood) - Fix moving average speed for file stats (Nick Craig-Wood) - config: Fix error reading password from piped input (Nick Craig-Wood) - move: Fix --delete-empty-src-dirs flag to delete all empty dirs on move (ishuah) - Mount - Implement --daemon-timeout flag for OSXFUSE (Nick Craig-Wood) - Fix mount --daemon not working with encrypted config (Alex Chen) - Clip the number of blocks to 2^32-1 on macOS - fixes borg backup (Nick Craig-Wood) - VFS - Enable vfs-read-chunk-size by default (Fabian Möller) - Add the vfs/refresh rc command (Fabian Möller) - Add non recursive mode to vfs/refresh rc command (Fabian Möller) - Try to seek buffer on read only files (Fabian Möller) - Local - Fix crash when deprecated --local-no-unicode-normalization is supplied (Nick Craig-Wood) - Fix mkdir error when trying to copy files to the root of a drive on windows (Nick Craig-Wood) - Cache - Fix nil pointer deref when using lsjson on cached directory (Nick Craig-Wood) - Fix nil pointer deref for occasional crash on playback (Nick Craig-Wood) - Crypt - Fix accounting when checking hashes on upload (Nick Craig-Wood) - Amazon Cloud Drive - Make very clear in the docs that rclone has no ACD keys (Nick Craig-Wood) - Azure Blob - Add connection string and SAS URL auth (Nick Craig-Wood) - List the container to see if it exists (Nick Craig-Wood) - Port new Azure Blob Storage SDK (sandeepkru) - Added blob tier, tier between Hot, Cool and Archive. (sandeepkru) - Remove leading / from paths (Nick Craig-Wood) - B2 - Support Application Keys (Nick Craig-Wood) - Remove leading / from paths (Nick Craig-Wood) - Box - Fix upload of > 2GB files on 32 bit platforms (Nick Craig-Wood) - Make --box-commit-retries flag defaulting to 100 to fix large uploads (Nick Craig-Wood) - Drive - Add --drive-keep-revision-forever flag (lewapm) - Handle gdocs when filtering file names in list (Fabian Möller) - Support using --fast-list for large speedups (Fabian Möller) - FTP - Fix Put mkParentDir failed: 521 for BunnyCDN (Nick Craig-Wood) - Google Cloud Storage - Fix index out of range error with --fast-list (Nick Craig-Wood) - Jottacloud - Fix MD5 error check (Oliver Heyme) - Handle empty time values (Martin Polden) - Calculate missing MD5s (Oliver Heyme) - Docs, fixes and tests for MD5 calculation (Nick Craig-Wood) - Add optional MimeTyper interface. (Sebastian Bünger) - Implement optional About interface (for df support). (Sebastian Bünger) - Mega - Wait for events instead of arbitrary sleeping (Nick Craig-Wood) - Add --mega-hard-delete flag (Nick Craig-Wood) - Fix failed logins with upper case chars in email (Nick Craig-Wood) - Onedrive - Shared folder support (Yoni Jah) - Implement DirMove (Cnly) - Fix rmdir sometimes deleting directories with contents (Nick Craig-Wood) - Pcloud - Delete half uploaded files on upload error (Nick Craig-Wood) - Qingstor - Remove leading / from paths (Nick Craig-Wood) - S3 - Fix index out of range error with --fast-list (Nick Craig-Wood) - Add --s3-force-path-style (Nick Craig-Wood) - Add support for KMS Key ID (bsteiss) - Remove leading / from paths (Nick Craig-Wood) - Swift - Add storage_policy (Ruben Vandamme) - Make it so just storage_url or auth_token can be overridden (Nick Craig-Wood) - Fix server-side copy bug for unusual file names (Nick Craig-Wood) - Remove leading / from paths (Nick Craig-Wood) - WebDAV - Ensure we call MKCOL with a URL with a trailing / for QNAP interop (Nick Craig-Wood) - If root ends with / then don't check if it is a file (Nick Craig-Wood) - Don't accept redirects when reading metadata (Nick Craig-Wood) - Add bearer token (Macaroon) support for dCache (Nick Craig-Wood) - Document dCache and Macaroons (Onno Zweers) - Sharepoint recursion with different depth (Henning) - Attempt to remove failed uploads (Nick Craig-Wood) - Yandex - Fix listing/deleting files in the root (Nick Craig-Wood) v1.42 - 2018-06-16 - New backends - OpenDrive (Oliver Heyme, Jakub Karlicek, ncw) - New commands - deletefile command (Filip Bartodziej) - New Features - copy, move: Copy single files directly, don't use --files-from work-around - this makes them much more efficient - Implement --max-transfer flag to quit transferring at a limit - make exit code 8 for --max-transfer exceeded - copy: copy empty source directories to destination (Ishuah Kariuki) - check: Add --one-way flag (Kasper Byrdal Nielsen) - Add siginfo handler for macOS for ctrl-T stats (kubatasiemski) - rc - add core/gc to run a garbage collection on demand - enable go profiling by default on the --rc port - return error from remote on failure - lsf - Add --absolute flag to add a leading / onto path names - Add --csv flag for compliant CSV output - Add 'm' format specifier to show the MimeType - Implement 'i' format for showing object ID - lsjson - Add MimeType to the output - Add ID field to output to show Object ID - Add --retries-sleep flag (Benjamin Joseph Dag) - Oauth tidy up web page and error handling (Henning Surmeier) - Bug Fixes - Password prompt output with --log-file fixed for unix (Filip Bartodziej) - Calculate ModifyWindow each time on the fly to fix various problems (Stefan Breunig) - Mount - Only print "File.rename error" if there actually is an error (Stefan Breunig) - Delay rename if file has open writers instead of failing outright (Stefan Breunig) - Ensure atexit gets run on interrupt - macOS enhancements - Make --noappledouble --noapplexattr - Add --volname flag and remove special chars from it - Make Get/List/Set/Remove xattr return ENOSYS for efficiency - Make --daemon work for macOS without CGO - VFS - Add --vfs-read-chunk-size and --vfs-read-chunk-size-limit (Fabian Möller) - Fix ChangeNotify for new or changed folders (Fabian Möller) - Local - Fix symlink/junction point directory handling under Windows - NB you will need to add -L to your command line to copy files with reparse points - Cache - Add non cached dirs on notifications (Remus Bunduc) - Allow root to be expired from rc (Remus Bunduc) - Clean remaining empty folders from temp upload path (Remus Bunduc) - Cache lists using batch writes (Remus Bunduc) - Use secure websockets for HTTPS Plex addresses (John Clayton) - Reconnect plex websocket on failures (Remus Bunduc) - Fix panic when running without plex configs (Remus Bunduc) - Fix root folder caching (Remus Bunduc) - Crypt - Check the encrypted hash of files when uploading for extra data security - Dropbox - Make Dropbox for business folders accessible using an initial / in the path - Google Cloud Storage - Low level retry all operations if necessary - Google Drive - Add --drive-acknowledge-abuse to download flagged files - Add --drive-alternate-export to fix large doc export - Don't attempt to choose Team Drives when using rclone config create - Fix change list polling with team drives - Fix ChangeNotify for folders (Fabian Möller) - Fix about (and df on a mount) for team drives - Onedrive - Errorhandler for onedrive for business requests (Henning Surmeier) - S3 - Adjust upload concurrency with --s3-upload-concurrency (themylogin) - Fix --s3-chunk-size which was always using the minimum - SFTP - Add --ssh-path-override flag (Piotr Oleszczyk) - Fix slow downloads for long latency connections - Webdav - Add workarounds for biz.mail.ru - Ignore Reason-Phrase in status line to fix 4shared (Rodrigo) - Better error message generation v1.41 - 2018-04-28 - New backends - Mega support added - Webdav now supports SharePoint cookie authentication (hensur) - New commands - link: create public link to files and folders (Stefan Breunig) - about: gets quota info from a remote (a-roussos, ncw) - hashsum: a generic tool for any hash to produce md5sum like output - New Features - lsd: Add -R flag and fix and update docs for all ls commands - ncdu: added a "refresh" key - CTRL-L (Keith Goldfarb) - serve restic: Add append-only mode (Steve Kriss) - serve restic: Disallow overwriting files in append-only mode (Alexander Neumann) - serve restic: Print actual listener address (Matt Holt) - size: Add --json flag (Matthew Holt) - sync: implement --ignore-errors (Mateusz Pabian) - dedupe: Add dedupe largest functionality (Richard Yang) - fs: Extend SizeSuffix to include TB and PB for rclone about - fs: add --dump goroutines and --dump openfiles for debugging - rc: implement core/memstats to print internal memory usage info - rc: new call rc/pid (Michael P. Dubner) - Compile - Drop support for go1.6 - Release - Fix make tarball (Chih-Hsuan Yen) - Bug Fixes - filter: fix --min-age and --max-age together check - fs: limit MaxIdleConns and MaxIdleConnsPerHost in transport - lsd,lsf: make sure all times we output are in local time - rc: fix setting bwlimit to unlimited - rc: take note of the --rc-addr flag too as per the docs - Mount - Use About to return the correct disk total/used/free (e.g. in df) - Set --attr-timeout default to 1s - fixes: - rclone using too much memory - rclone not serving files to samba - excessive time listing directories - Fix df -i (upstream fix) - VFS - Filter files . and .. from directory listing - Only make the VFS cache if --vfs-cache-mode > Off - Local - Add --local-no-check-updated to disable updated file checks - Retry remove on Windows sharing violation error - Cache - Flush the memory cache after close - Purge file data on notification - Always forget parent dir for notifications - Integrate with Plex websocket - Add rc cache/stats (seuffert) - Add info log on notification - Box - Fix failure reading large directories - parse file/directory size as float - Dropbox - Fix crypt+obfuscate on dropbox - Fix repeatedly uploading the same files - FTP - Work around strange response from box FTP server - More workarounds for FTP servers to fix mkParentDir error - Fix no error on listing nonexistent directory - Google Cloud Storage - Add service_account_credentials (Matt Holt) - Detect bucket presence by listing it - minimises permissions needed - Ignore zero length directory markers - Google Drive - Add service_account_credentials (Matt Holt) - Fix directory move leaving a hardlinked directory behind - Return proper google errors when Opening files - When initialized with a filepath, optional features used incorrect root path (Stefan Breunig) - HTTP - Fix sync for servers which don't return Content-Length in HEAD - Onedrive - Add QuickXorHash support for OneDrive for business - Fix socket leak in multipart session upload - S3 - Look in S3 named profile files for credentials - Add --s3-disable-checksum to disable checksum uploading (Chris Redekop) - Hierarchical configuration support (Giri Badanahatti) - Add in config for all the supported S3 providers - Add One Zone Infrequent Access storage class (Craig Rachel) - Add --use-server-modtime support (Peter Baumgartner) - Add --s3-chunk-size option to control multipart uploads - Ignore zero length directory markers - SFTP - Update docs to match code, fix typos and clarify disable_hashcheck prompt (Michael G. Noll) - Update docs with Synology quirks - Fail soft with a debug on hash failure - Swift - Add --use-server-modtime support (Peter Baumgartner) - Webdav - Support SharePoint cookie authentication (hensur) - Strip leading and trailing / off root v1.40 - 2018-03-19 - New backends - Alias backend to create aliases for existing remote names (Fabian Möller) - New commands - lsf: list for parsing purposes (Jakub Tasiemski) - by default this is a simple non recursive list of files and directories - it can be configured to add more info in an easy to parse way - serve restic: for serving a remote as a Restic REST endpoint - This enables restic to use any backends that rclone can access - Thanks Alexander Neumann for help, patches and review - rc: enable the remote control of a running rclone - The running rclone must be started with --rc and related flags. - Currently there is support for bwlimit, and flushing for mount and cache. - New Features - --max-delete flag to add a delete threshold (Bjørn Erik Pedersen) - All backends now support RangeOption for ranged Open - cat: Use RangeOption for limited fetches to make more efficient - cryptcheck: make reading of nonce more efficient with RangeOption - serve http/webdav/restic - support SSL/TLS - add --user --pass and --htpasswd for authentication - copy/move: detect file size change during copy/move and abort transfer (ishuah) - cryptdecode: added option to return encrypted file names. (ishuah) - lsjson: add --encrypted to show encrypted name (Jakub Tasiemski) - Add --stats-file-name-length to specify the printed file name length for stats (Will Gunn) - Compile - Code base was shuffled and factored - backends moved into a backend directory - large packages split up - See the CONTRIBUTING.md doc for info as to what lives where now - Update to using go1.10 as the default go version - Implement daily full integration tests - Release - Include a source tarball and sign it and the binaries - Sign the git tags as part of the release process - Add .deb and .rpm packages as part of the build - Make a beta release for all branches on the main repo (but not pull requests) - Bug Fixes - config: fixes errors on nonexistent config by loading config file only on first access - config: retry saving the config after failure (Mateusz) - sync: when using --backup-dir don't delete files if we can't set their modtime - this fixes odd behaviour with Dropbox and --backup-dir - fshttp: fix idle timeouts for HTTP connections - serve http: fix serving files with : in - fixes - Fix --exclude-if-present to ignore directories which it doesn't have permission for (Iakov Davydov) - Make accounting work properly with crypt and b2 - remove --no-traverse flag because it is obsolete - Mount - Add --attr-timeout flag to control attribute caching in kernel - this now defaults to 0 which is correct but less efficient - see the mount docs for more info - Add --daemon flag to allow mount to run in the background (ishuah) - Fix: Return ENOSYS rather than EIO on attempted link - This fixes FileZilla accessing an rclone mount served over sftp. - Fix setting modtime twice - Mount tests now run on CI for Linux (mount & cmount)/Mac/Windows - Many bugs fixed in the VFS layer - see below - VFS - Many fixes for --vfs-cache-mode writes and above - Update cached copy if we know it has changed (fixes stale data) - Clean path names before using them in the cache - Disable cache cleaner if --vfs-cache-poll-interval=0 - Fill and clean the cache immediately on startup - Fix Windows opening every file when it stats the file - Fix applying modtime for an open Write Handle - Fix creation of files when truncating - Write 0 bytes when flushing unwritten handles to avoid race conditions in FUSE - Downgrade "poll-interval is not supported" message to Info - Make OpenFile and friends return EINVAL if O_RDONLY and O_TRUNC - Local - Downgrade "invalid cross-device link: trying copy" to debug - Make DirMove return fs.ErrorCantDirMove to allow fallback to Copy for cross device - Fix race conditions updating the hashes - Cache - Add support for polling - cache will update when remote changes on supported backends - Reduce log level for Plex api - Fix dir cache issue - Implement --cache-db-wait-time flag - Improve efficiency with RangeOption and RangeSeek - Fix dirmove with temp fs enabled - Notify vfs when using temp fs - Offline uploading - Remote control support for path flushing - Amazon cloud drive - Rclone no longer has any working keys - disable integration tests - Implement DirChangeNotify to notify cache/vfs/mount of changes - Azureblob - Don't check for bucket/container presence if listing was OK - this makes rclone do one less request per invocation - Improve accounting for chunked uploads - Backblaze B2 - Don't check for bucket/container presence if listing was OK - this makes rclone do one less request per invocation - Box - Improve accounting for chunked uploads - Dropbox - Fix custom oauth client parameters - Google Cloud Storage - Don't check for bucket/container presence if listing was OK - this makes rclone do one less request per invocation - Google Drive - Migrate to api v3 (Fabian Möller) - Add scope configuration and root folder selection - Add --drive-impersonate for service accounts - thanks to everyone who tested, explored and contributed docs - Add --drive-use-created-date to use created date as modified date (nbuchanan) - Request the export formats only when required - This makes rclone quicker when there are no google docs - Fix finding paths with latin1 chars (a workaround for a drive bug) - Fix copying of a single Google doc file - Fix --drive-auth-owner-only to look in all directories - HTTP - Fix handling of directories with & in - Onedrive - Removed upload cutoff and always do session uploads - this stops the creation of multiple versions on business onedrive - Overwrite object size value with real size when reading file. (Victor) - this fixes oddities when onedrive misreports the size of images - Pcloud - Remove unused chunked upload flag and code - Qingstor - Don't check for bucket/container presence if listing was OK - this makes rclone do one less request per invocation - S3 - Support hashes for multipart files (Chris Redekop) - Initial support for IBM COS (S3) (Giri Badanahatti) - Update docs to discourage use of v2 auth with CEPH and others - Don't check for bucket/container presence if listing was OK - this makes rclone do one less request per invocation - Fix server-side copy and set modtime on files with + in - SFTP - Add option to disable remote hash check command execution (Jon Fautley) - Add --sftp-ask-password flag to prompt for password when needed (Leo R. Lundgren) - Add set_modtime configuration option - Fix following of symlinks - Fix reading config file outside of Fs setup - Fix reading $USER in username fallback not $HOME - Fix running under crontab - Use correct OS way of reading username - Swift - Fix refresh of authentication token - in v1.39 a bug was introduced which ignored new tokens - this fixes it - Fix extra HEAD transaction when uploading a new file - Don't check for bucket/container presence if listing was OK - this makes rclone do one less request per invocation - Webdav - Add new time formats to support mydrive.ch and others v1.39 - 2017-12-23 - New backends - WebDAV - tested with nextcloud, owncloud, put.io and others! - Pcloud - cache - wraps a cache around other backends (Remus Bunduc) - useful in combination with mount - NB this feature is in beta so use with care - New commands - serve command with subcommands: - serve webdav: this implements a webdav server for any rclone remote. - serve http: command to serve a remote over HTTP - config: add sub commands for full config file management - create/delete/dump/edit/file/password/providers/show/update - touch: to create or update the timestamp of a file (Jakub Tasiemski) - New Features - curl install for rclone (Filip Bartodziej) - --stats now shows percentage, size, rate and ETA in condensed form (Ishuah Kariuki) - --exclude-if-present to exclude a directory if a file is present (Iakov Davydov) - rmdirs: add --leave-root flag (lewapm) - move: add --delete-empty-src-dirs flag to remove dirs after move (Ishuah Kariuki) - Add --dump flag, introduce --dump requests, responses and remove --dump-auth, --dump-filters - Obscure X-Auth-Token: from headers when dumping too - Document and implement exit codes for different failure modes (Ishuah Kariuki) - Compile - Bug Fixes - Retry lots more different types of errors to make multipart transfers more reliable - Save the config before asking for a token, fixes disappearing oauth config - Warn the user if --include and --exclude are used together (Ernest Borowski) - Fix duplicate files (e.g. on Google drive) causing spurious copies - Allow trailing and leading whitespace for passwords (Jason Rose) - ncdu: fix crashes on empty directories - rcat: fix goroutine leak - moveto/copyto: Fix to allow copying to the same name - Mount - --vfs-cache mode to make writes into mounts more reliable. - this requires caching files on the disk (see --cache-dir) - As this is a new feature, use with care - Use sdnotify to signal systemd the mount is ready (Fabian Möller) - Check if directory is not empty before mounting (Ernest Borowski) - Local - Add error message for cross file system moves - Fix equality check for times - Dropbox - Rework multipart upload - buffer the chunks when uploading large files so they can be retried - change default chunk size to 48MB now we are buffering them in memory - retry every error after the first chunk is done successfully - Fix error when renaming directories - Swift - Fix crash on bad authentication - Google Drive - Add service account support (Tim Cooijmans) - S3 - Make it work properly with Digital Ocean Spaces (Andrew Starr-Bochicchio) - Fix crash if a bad listing is received - Add support for ECS task IAM roles (David Minor) - Backblaze B2 - Fix multipart upload retries - Fix --hard-delete to make it work 100% of the time - Swift - Allow authentication with storage URL and auth key (Giovanni Pizzi) - Add new fields for swift configuration to support IBM Bluemix Swift (Pierre Carlson) - Add OS_TENANT_ID and OS_USER_ID to config - Allow configs with user id instead of user name - Check if swift segments container exists before creating (John Leach) - Fix memory leak in swift transfers (upstream fix) - SFTP - Add option to enable the use of aes128-cbc cipher (Jon Fautley) - Amazon cloud drive - Fix download of large files failing with "Only one auth mechanism allowed" - crypt - Option to encrypt directory names or leave them intact - Implement DirChangeNotify (Fabian Möller) - onedrive - Add option to choose resourceURL during setup of OneDrive Business account if more than one is available for user v1.38 - 2017-09-30 - New backends - Azure Blob Storage (thanks Andrei Dragomir) - Box - Onedrive for Business (thanks Oliver Heyme) - QingStor from QingCloud (thanks wuyu) - New commands - rcat - read from standard input and stream upload - tree - shows a nicely formatted recursive listing - cryptdecode - decode encrypted file names (thanks ishuah) - config show - print the config file - config file - print the config file location - New Features - Empty directories are deleted on sync - dedupe - implement merging of duplicate directories - check and cryptcheck made more consistent and use less memory - cleanup for remaining remotes (thanks ishuah) - --immutable for ensuring that files don't change (thanks Jacob McNamee) - --user-agent option (thanks Alex McGrath Kraak) - --disable flag to disable optional features - --bind flag for choosing the local addr on outgoing connections - Support for zsh auto-completion (thanks bpicode) - Stop normalizing file names but do a normalized compare in sync - Compile - Update to using go1.9 as the default go version - Remove snapd build due to maintenance problems - Bug Fixes - Improve retriable error detection which makes multipart uploads better - Make check obey --ignore-size - Fix bwlimit toggle in conjunction with schedules (thanks cbruegg) - config ensures newly written config is on the same mount - Local - Revert to copy when moving file across file system boundaries - --skip-links to suppress symlink warnings (thanks Zhiming Wang) - Mount - Reuse rcat internals to support uploads from all remotes - Dropbox - Fix "entry doesn't belong in directory" error - Stop using deprecated API methods - Swift - Fix server-side copy to empty container with --fast-list - Google Drive - Change the default for --drive-use-trash to true - S3 - Set session token when using STS (thanks Girish Ramakrishnan) - Glacier docs and error messages (thanks Jan Varho) - Read 1000 (not 1024) items in dir listings to fix Wasabi - Backblaze B2 - Fix SHA1 mismatch when downloading files with no SHA1 - Calculate missing hashes on the fly instead of spooling - --b2-hard-delete to permanently delete (not hide) files (thanks John Papandriopoulos) - Hubic - Fix creating containers - no longer have to use the default container - Swift - Optionally configure from a standard set of OpenStack environment vars - Add endpoint_type config - Google Cloud Storage - Fix bucket creation to work with limited permission users - SFTP - Implement connection pooling for multiple ssh connections - Limit new connections per second - Add support for MD5 and SHA1 hashes where available (thanks Christian Brüggemann) - HTTP - Fix URL encoding issues - Fix directories with : in - Fix panic with URL encoded content v1.37 - 2017-07-22 - New backends - FTP - thanks to Antonio Messina - HTTP - thanks to Vasiliy Tolstov - New commands - rclone ncdu - for exploring a remote with a text based user interface. - rclone lsjson - for listing with a machine-readable output - rclone dbhashsum - to show Dropbox style hashes of files (local or Dropbox) - New Features - Implement --fast-list flag - This allows remotes to list recursively if they can - This uses less transactions (important if you pay for them) - This may or may not be quicker - This will use more memory as it has to hold the listing in memory - --old-sync-method deprecated - the remaining uses are covered by --fast-list - This involved a major re-write of all the listing code - Add --tpslimit and --tpslimit-burst to limit transactions per second - this is useful in conjunction with rclone mount to limit external apps - Add --stats-log-level so can see --stats without -v - Print password prompts to stderr - Hraban Luyat - Warn about duplicate files when syncing - Oauth improvements - allow auth_url and token_url to be set in the config file - Print redirection URI if using own credentials. - Don't Mkdir at the start of sync to save transactions - Compile - Update build to go1.8.3 - Require go1.6 for building rclone - Compile 386 builds with "GO386=387" for maximum compatibility - Bug Fixes - Fix menu selection when no remotes - Config saving reworked to not kill the file if disk gets full - Don't delete remote if name does not change while renaming - moveto, copyto: report transfers and checks as per move and copy - Local - Add --local-no-unicode-normalization flag - Bob Potter - Mount - Now supported on Windows using cgofuse and WinFsp - thanks to Bill Zissimopoulos for much help - Compare checksums on upload/download via FUSE - Unmount when program ends with SIGINT (Ctrl+C) or SIGTERM - Jérôme Vizcaino - On read only open of file, make open pending until first read - Make --read-only reject modify operations - Implement ModTime via FUSE for remotes that support it - Allow modTime to be changed even before all writers are closed - Fix panic on renames - Fix hang on errored upload - Crypt - Report the name:root as specified by the user - Add an "obfuscate" option for filename encryption - Stephen Harris - Amazon Drive - Fix initialization order for token renewer - Remove revoked credentials, allow oauth proxy config and update docs - B2 - Reduce minimum chunk size to 5MB - Drive - Add team drive support - Reduce bandwidth by adding fields for partial responses - Martin Kristensen - Implement --drive-shared-with-me flag to view shared with me files - Danny Tsai - Add --drive-trashed-only to read only the files in the trash - Remove obsolete --drive-full-list - Add missing seek to start on retries of chunked uploads - Fix stats accounting for upload - Convert / in names to a unicode equivalent (／) - Poll for Google Drive changes when mounted - OneDrive - Fix the uploading of files with spaces - Fix initialization order for token renewer - Display speeds accurately when uploading - Yoni Jah - Swap to using http://localhost:53682/ as redirect URL - Michael Ledin - Retry on token expired error, reset upload body on retry - Yoni Jah - Google Cloud Storage - Add ability to specify location and storage class via config and command line - thanks gdm85 - Create container if necessary on server-side copy - Increase directory listing chunk to 1000 to increase performance - Obtain a refresh token for GCS - Steven Lu - Yandex - Fix the name reported in log messages (was empty) - Correct error return for listing empty directory - Dropbox - Rewritten to use the v2 API - Now supports ModTime - Can only set by uploading the file again - If you uploaded with an old rclone, rclone may upload everything again - Use --size-only or --checksum to avoid this - Now supports the Dropbox content hashing scheme - Now supports low level retries - S3 - Work around eventual consistency in bucket creation - Create container if necessary on server-side copy - Add us-east-2 (Ohio) and eu-west-2 (London) S3 regions - Zahiar Ahmed - Swift, Hubic - Fix zero length directory markers showing in the subdirectory listing - this caused lots of duplicate transfers - Fix paged directory listings - this caused duplicate directory errors - Create container if necessary on server-side copy - Increase directory listing chunk to 1000 to increase performance - Make sensible error if the user forgets the container - SFTP - Add support for using ssh key files - Fix under Windows - Fix ssh agent on Windows - Adapt to latest version of library - Igor Kharin v1.36 - 2017-03-18 - New Features - SFTP remote (Jack Schmidt) - Re-implement sync routine to work a directory at a time reducing memory usage - Logging revamped to be more inline with rsync - now much quieter - -v only shows transfers - -vv is for full debug - --syslog to log to syslog on capable platforms - Implement --backup-dir and --suffix - Implement --track-renames (initial implementation by Bjørn Erik Pedersen) - Add time-based bandwidth limits (Lukas Loesche) - rclone cryptcheck: checks integrity of crypt remotes - Allow all config file variables and options to be set from environment variables - Add --buffer-size parameter to control buffer size for copy - Make --delete-after the default - Add --ignore-checksum flag (fixed by Hisham Zarka) - rclone check: Add --download flag to check all the data, not just hashes - rclone cat: add --head, --tail, --offset, --count and --discard - rclone config: when choosing from a list, allow the value to be entered too - rclone config: allow rename and copy of remotes - rclone obscure: for generating encrypted passwords for rclone's config (T.C. Ferguson) - Comply with XDG Base Directory specification (Dario Giovannetti) - this moves the default location of the config file in a backwards compatible way - Release changes - Ubuntu snap support (Dedsec1) - Compile with go 1.8 - MIPS/Linux big and little endian support - Bug Fixes - Fix copyto copying things to the wrong place if the destination dir didn't exist - Fix parsing of remotes in moveto and copyto - Fix --delete-before deleting files on copy - Fix --files-from with an empty file copying everything - Fix sync: don't update mod times if --dry-run set - Fix MimeType propagation - Fix filters to add ** rules to directory rules - Local - Implement -L, --copy-links flag to allow rclone to follow symlinks - Open files in write only mode so rclone can write to an rclone mount - Fix unnormalised unicode causing problems reading directories - Fix interaction between -x flag and --max-depth - Mount - Implement proper directory handling (mkdir, rmdir, renaming) - Make include and exclude filters apply to mount - Implement read and write async buffers - control with --buffer-size - Fix fsync on for directories - Fix retry on network failure when reading off crypt - Crypt - Add --crypt-show-mapping to show encrypted file mapping - Fix crypt writer getting stuck in a loop - IMPORTANT this bug had the potential to cause data corruption when - reading data from a network based remote and - writing to a crypt on Google Drive - Use the cryptcheck command to validate your data if you are concerned - If syncing two crypt remotes, sync the unencrypted remote - Amazon Drive - Fix panics on Move (rename) - Fix panic on token expiry - B2 - Fix inconsistent listings and rclone check - Fix uploading empty files with go1.8 - Constrain memory usage when doing multipart uploads - Fix upload url not being refreshed properly - Drive - Fix Rmdir on directories with trashed files - Fix "Ignoring unknown object" when downloading - Add --drive-list-chunk - Add --drive-skip-gdocs (Károly Oláh) - OneDrive - Implement Move - Fix Copy - Fix overwrite detection in Copy - Fix waitForJob to parse errors correctly - Use token renewer to stop auth errors on long uploads - Fix uploading empty files with go1.8 - Google Cloud Storage - Fix depth 1 directory listings - Yandex - Fix single level directory listing - Dropbox - Normalise the case for single level directory listings - Fix depth 1 listing - S3 - Added ca-central-1 region (Jon Yergatian) v1.35 - 2017-01-02 - New Features - moveto and copyto commands for choosing a destination name on copy/move - rmdirs command to recursively delete empty directories - Allow repeated --include/--exclude/--filter options - Only show transfer stats on commands which transfer stuff - show stats on any command using the --stats flag - Allow overlapping directories in move when server-side dir move is supported - Add --stats-unit option - thanks Scott McGillivray - Bug Fixes - Fix the config file being overwritten when two rclone instances are running - Make rclone lsd obey the filters properly - Fix compilation on mips - Fix not transferring files that don't differ in size - Fix panic on nil retry/fatal error - Mount - Retry reads on error - should help with reliability a lot - Report the modification times for directories from the remote - Add bandwidth accounting and limiting (fixes --bwlimit) - If --stats provided will show stats and which files are transferring - Support R/W files if truncate is set. - Implement statfs interface so df works - Note that write is now supported on Amazon Drive - Report number of blocks in a file - thanks Stefan Breunig - Crypt - Prevent the user pointing crypt at itself - Fix failed to authenticate decrypted block errors - these will now return the underlying unexpected EOF instead - Amazon Drive - Add support for server-side move and directory move - thanks Stefan Breunig - Fix nil pointer deref on size attribute - B2 - Use new prefix and delimiter parameters in directory listings - This makes --max-depth 1 dir listings as used in mount much faster - Reauth the account while doing uploads too - should help with token expiry - Drive - Make DirMove more efficient and complain about moving the root - Create destination directory on Move() v1.34 - 2016-11-06 - New Features - Stop single file and --files-from operations iterating through the source bucket. - Stop removing failed upload to cloud storage remotes - Make ContentType be preserved for cloud to cloud copies - Add support to toggle bandwidth limits via SIGUSR2 - thanks Marco Paganini - rclone check shows count of hashes that couldn't be checked - rclone listremotes command - Support linux/arm64 build - thanks Fredrik Fornwall - Remove Authorization: lines from --dump-headers output - Bug Fixes - Ignore files with control characters in the names - Fix rclone move command - Delete src files which already existed in dst - Fix deletion of src file when dst file older - Fix rclone check on encrypted file systems - Make failed uploads not count as "Transferred" - Make sure high level retries show with -q - Use a vendor directory with godep for repeatable builds - rclone mount - FUSE - Implement FUSE mount options - --no-modtime, --debug-fuse, --read-only, --allow-non-empty, --allow-root, --allow-other - --default-permissions, --write-back-cache, --max-read-ahead, --umask, --uid, --gid - Add --dir-cache-time to control caching of directory entries - Implement seek for files opened for read (useful for video players) - with -no-seek flag to disable - Fix crash on 32 bit ARM (alignment of 64 bit counter) - ...and many more internal fixes and improvements! - Crypt - Don't show encrypted password in configurator to stop confusion - Amazon Drive - New wait for upload option --acd-upload-wait-per-gb - upload timeouts scale by file size and can be disabled - Add 502 Bad Gateway to list of errors we retry - Fix overwriting a file with a zero length file - Fix ACD file size warning limit - thanks Felix Bünemann - Local - Unix: implement -x/--one-file-system to stay on a single file system - thanks Durval Menezes and Luiz Carlos Rumbelsperger Viana - Windows: ignore the symlink bit on files - Windows: Ignore directory-based junction points - B2 - Make sure each upload has at least one upload slot - fixes strange upload stats - Fix uploads when using crypt - Fix download of large files (sha1 mismatch) - Return error when we try to create a bucket which someone else owns - Update B2 docs with Data usage, and Crypt section - thanks Tomasz Mazur - S3 - Command line and config file support for - Setting/overriding ACL - thanks Radek Šenfeld - Setting storage class - thanks Asko Tamm - Drive - Make exponential backoff work exactly as per Google specification - add .epub, .odp and .tsv as export formats. - Swift - Don't read metadata for directory marker objects v1.33 - 2016-08-24 - New Features - Implement encryption - data encrypted in NACL secretbox format - with optional file name encryption - New commands - rclone mount - implements FUSE mounting of remotes (EXPERIMENTAL) - works on Linux, FreeBSD and OS X (need testers for the last 2!) - rclone cat - outputs remote file or files to the terminal - rclone genautocomplete - command to make a bash completion script for rclone - Editing a remote using rclone config now goes through the wizard - Compile with go 1.7 - this fixes rclone on macOS Sierra and on 386 processors - Use cobra for sub commands and docs generation - drive - Document how to make your own client_id - s3 - User-configurable Amazon S3 ACL (thanks Radek Šenfeld) - b2 - Fix stats accounting for upload - no more jumping to 100% done - On cleanup delete hide marker if it is the current file - New B2 API endpoint (thanks Per Cederberg) - Set maximum backoff to 5 Minutes - onedrive - Fix URL escaping in file names - e.g. uploading files with + in them. - amazon cloud drive - Fix token expiry during large uploads - Work around 408 REQUEST_TIMEOUT and 504 GATEWAY_TIMEOUT errors - local - Fix filenames with invalid UTF-8 not being uploaded - Fix problem with some UTF-8 characters on OS X v1.32 - 2016-07-13 - Backblaze B2 - Fix upload of files large files not in root v1.31 - 2016-07-13 - New Features - Reduce memory on sync by about 50% - Implement --no-traverse flag to stop copy traversing the destination remote. - This can be used to reduce memory usage down to the smallest possible. - Useful to copy a small number of files into a large destination folder. - Implement cleanup command for emptying trash / removing old versions of files - Currently B2 only - Single file handling improved - Now copied with --files-from - Automatically sets --no-traverse when copying a single file - Info on using installing with ansible - thanks Stefan Weichinger - Implement --no-update-modtime flag to stop rclone fixing the remote modified times. - Bug Fixes - Fix move command - stop it running for overlapping Fses - this was causing data loss. - Local - Fix incomplete hashes - this was causing problems for B2. - Amazon Drive - Rename Amazon Cloud Drive to Amazon Drive - no changes to config file needed. - Swift - Add support for non-default project domain - thanks Antonio Messina. - S3 - Add instructions on how to use rclone with minio. - Add ap-northeast-2 (Seoul) and ap-south-1 (Mumbai) regions. - Skip setting the modified time for objects > 5GB as it isn't possible. - Backblaze B2 - Add --b2-versions flag so old versions can be listed and retrieved. - Treat 403 errors (e.g. cap exceeded) as fatal. - Implement cleanup command for deleting old file versions. - Make error handling compliant with B2 integrations notes. - Fix handling of token expiry. - Implement --b2-test-mode to set X-Bz-Test-Mode header. - Set cutoff for chunked upload to 200MB as per B2 guidelines. - Make upload multi-threaded. - Dropbox - Don't retry 461 errors. v1.30 - 2016-06-18 - New Features - Directory listing code reworked for more features and better error reporting (thanks to Klaus Post for help). This enables - Directory include filtering for efficiency - --max-depth parameter - Better error reporting - More to come - Retry more errors - Add --ignore-size flag - for uploading images to onedrive - Log -v output to stdout by default - Display the transfer stats in more human-readable form - Make 0 size files specifiable with --max-size 0b - Add b suffix so we can specify bytes in --bwlimit, --min-size, etc. - Use "password:" instead of "password>" prompt - thanks Klaus Post and Leigh Klotz - Bug Fixes - Fix retry doing one too many retries - Local - Fix problems with OS X and UTF-8 characters - Amazon Drive - Check a file exists before uploading to help with 408 Conflict errors - Reauth on 401 errors - this has been causing a lot of problems - Work around spurious 403 errors - Restart directory listings on error - Google Drive - Check a file exists before uploading to help with duplicates - Fix retry of multipart uploads - Backblaze B2 - Implement large file uploading - S3 - Add AES256 server-side encryption for - thanks Justin R. Wilson - Google Cloud Storage - Make sure we don't use conflicting content types on upload - Add service account support - thanks Michal Witkowski - Swift - Add auth version parameter - Add domain option for openstack (v3 auth) - thanks Fabian Ruff v1.29 - 2016-04-18 - New Features - Implement -I, --ignore-times for unconditional upload - Improve dedupecommand - Now removes identical copies without asking - Now obeys --dry-run - Implement --dedupe-mode for non interactive running - --dedupe-mode interactive - interactive the default. - --dedupe-mode skip - removes identical files then skips anything left. - --dedupe-mode first - removes identical files then keeps the first one. - --dedupe-mode newest - removes identical files then keeps the newest one. - --dedupe-mode oldest - removes identical files then keeps the oldest one. - --dedupe-mode rename - removes identical files then renames the rest to be different. - Bug fixes - Make rclone check obey the --size-only flag. - Use "application/octet-stream" if discovered mime type is invalid. - Fix missing "quit" option when there are no remotes. - Google Drive - Increase default chunk size to 8 MB - increases upload speed of big files - Speed up directory listings and make more reliable - Add missing retries for Move and DirMove - increases reliability - Preserve mime type on file update - Backblaze B2 - Enable mod time syncing - This means that B2 will now check modification times - It will upload new files to update the modification times - (there isn't an API to just set the mod time.) - If you want the old behaviour use --size-only. - Update API to new version - Fix parsing of mod time when not in metadata - Swift/Hubic - Don't return an MD5SUM for static large objects - S3 - Fix uploading files bigger than 50GB v1.28 - 2016-03-01 - New Features - Configuration file encryption - thanks Klaus Post - Improve rclone config adding more help and making it easier to understand - Implement -u/--update so creation times can be used on all remotes - Implement --low-level-retries flag - Optionally disable gzip compression on downloads with --no-gzip-encoding - Bug fixes - Don't make directories if --dry-run set - Fix and document the move command - Fix redirecting stderr on unix-like OSes when using --log-file - Fix delete command to wait until all finished - fixes missing deletes. - Backblaze B2 - Use one upload URL per go routine fixes more than one upload using auth token - Add pacing, retries and reauthentication - fixes token expiry problems - Upload without using a temporary file from local (and remotes which support SHA1) - Fix reading metadata for all files when it shouldn't have been - Drive - Fix listing drive documents at root - Disable copy and move for Google docs - Swift - Fix uploading of chunked files with non ASCII characters - Allow setting of storage_url in the config - thanks Xavier Lucas - S3 - Allow IAM role and credentials from environment variables - thanks Brian Stengaard - Allow low privilege users to use S3 (check if directory exists during Mkdir) - thanks Jakub Gedeon - Amazon Drive - Retry on more things to make directory listings more reliable v1.27 - 2016-01-31 - New Features - Easier headless configuration with rclone authorize - Add support for multiple hash types - we now check SHA1 as well as MD5 hashes. - delete command which does obey the filters (unlike purge) - dedupe command to deduplicate a remote. Useful with Google Drive. - Add --ignore-existing flag to skip all files that exist on destination. - Add --delete-before, --delete-during, --delete-after flags. - Add --memprofile flag to debug memory use. - Warn the user about files with same name but different case - Make --include rules add their implicit exclude * at the end of the filter list - Deprecate compiling with go1.3 - Amazon Drive - Fix download of files > 10 GB - Fix directory traversal ("Next token is expired") for large directory listings - Remove 409 conflict from error codes we will retry - stops very long pauses - Backblaze B2 - SHA1 hashes now checked by rclone core - Drive - Add --drive-auth-owner-only to only consider files owned by the user - thanks Björn Harrtell - Export Google documents - Dropbox - Make file exclusion error controllable with -q - Swift - Fix upload from unprivileged user. - S3 - Fix updating of mod times of files with + in. - Local - Add local file system option to disable UNC on Windows. v1.26 - 2016-01-02 - New Features - Yandex storage backend - thank you Dmitry Burdeev ("dibu") - Implement Backblaze B2 storage backend - Add --min-age and --max-age flags - thank you Adriano Aurélio Meirelles - Make ls/lsl/md5sum/size/check obey includes and excludes - Fixes - Fix crash in http logging - Upload releases to github too - Swift - Fix sync for chunked files - OneDrive - Re-enable server-side copy - Don't mask HTTP error codes with JSON decode error - S3 - Fix corrupting Content-Type on mod time update (thanks Joseph Spurrier) v1.25 - 2015-11-14 - New features - Implement Hubic storage system - Fixes - Fix deletion of some excluded files without --delete-excluded - This could have deleted files unexpectedly on sync - Always check first with --dry-run! - Swift - Stop SetModTime losing metadata (e.g. X-Object-Manifest) - This could have caused data loss for files > 5GB in size - Use ContentType from Object to avoid lookups in listings - OneDrive - disable server-side copy as it seems to be broken at Microsoft v1.24 - 2015-11-07 - New features - Add support for Microsoft OneDrive - Add --no-check-certificate option to disable server certificate verification - Add async readahead buffer for faster transfer of big files - Fixes - Allow spaces in remotes and check remote names for validity at creation time - Allow '&' and disallow ':' in Windows filenames. - Swift - Ignore directory marker objects where appropriate - allows working with Hubic - Don't delete the container if fs wasn't at root - S3 - Don't delete the bucket if fs wasn't at root - Google Cloud Storage - Don't delete the bucket if fs wasn't at root v1.23 - 2015-10-03 - New features - Implement rclone size for measuring remotes - Fixes - Fix headless config for drive and gcs - Tell the user they should try again if the webserver method failed - Improve output of --dump-headers - S3 - Allow anonymous access to public buckets - Swift - Stop chunked operations logging "Failed to read info: Object Not Found" - Use Content-Length on uploads for extra reliability v1.22 - 2015-09-28 - Implement rsync like include and exclude flags - swift - Support files > 5GB - thanks Sergey Tolmachev v1.21 - 2015-09-22 - New features - Display individual transfer progress - Make lsl output times in localtime - Fixes - Fix allowing user to override credentials again in Drive, GCS and ACD - Amazon Drive - Implement compliant pacing scheme - Google Drive - Make directory reads concurrent for increased speed. v1.20 - 2015-09-15 - New features - Amazon Drive support - Oauth support redone - fix many bugs and improve usability - Use "golang.org/x/oauth2" as oauth library of choice - Improve oauth usability for smoother initial signup - drive, googlecloudstorage: optionally use auto config for the oauth token - Implement --dump-headers and --dump-bodies debug flags - Show multiple matched commands if abbreviation too short - Implement server-side move where possible - local - Always use UNC paths internally on Windows - fixes a lot of bugs - dropbox - force use of our custom transport which makes timeouts work - Thanks to Klaus Post for lots of help with this release v1.19 - 2015-08-28 - New features - Server side copies for s3/swift/drive/dropbox/gcs - Move command - uses server-side copies if it can - Implement --retries flag - tries 3 times by default - Build for plan9/amd64 and solaris/amd64 too - Fixes - Make a current version download with a fixed URL for scripting - Ignore rmdir in limited fs rather than throwing error - dropbox - Increase chunk size to improve upload speeds massively - Issue an error message when trying to upload bad file name v1.18 - 2015-08-17 - drive - Add --drive-use-trash flag so rclone trashes instead of deletes - Add "Forbidden to download" message for files with no downloadURL - dropbox - Remove datastore - This was deprecated and it caused a lot of problems - Modification times and MD5SUMs no longer stored - Fix uploading files > 2GB - s3 - use official AWS SDK from github.com/aws/aws-sdk-go - NB will most likely require you to delete and recreate remote - enable multipart upload which enables files > 5GB - tested with Ceph / RadosGW / S3 emulation - many thanks to Sam Liston and Brian Haymore at the Utah Center for High Performance Computing for a Ceph test account - misc - Show errors when reading the config file - Do not print stats in quiet mode - thanks Leonid Shalupov - Add FAQ - Fix created directories not obeying umask - Linux installation instructions - thanks Shimon Doodkin v1.17 - 2015-06-14 - dropbox: fix case insensitivity issues - thanks Leonid Shalupov v1.16 - 2015-06-09 - Fix uploading big files which was causing timeouts or panics - Don't check md5sum after download with --size-only v1.15 - 2015-06-06 - Add --checksum flag to only discard transfers by MD5SUM - thanks Alex Couper - Implement --size-only flag to sync on size not checksum & modtime - Expand docs and remove duplicated information - Document rclone's limitations with directories - dropbox: update docs about case insensitivity v1.14 - 2015-05-21 - local: fix encoding of non utf-8 file names - fixes a duplicate file problem - drive: docs about rate limiting - google cloud storage: Fix compile after API change in "google.golang.org/api/storage/v1" v1.13 - 2015-05-10 - Revise documentation (especially sync) - Implement --timeout and --conntimeout - s3: ignore etags from multipart uploads which aren't md5sums v1.12 - 2015-03-15 - drive: Use chunked upload for files above a certain size - drive: add --drive-chunk-size and --drive-upload-cutoff parameters - drive: switch to insert from update when a failed copy deletes the upload - core: Log duplicate files if they are detected v1.11 - 2015-03-04 - swift: add region parameter - drive: fix crash on failed to update remote mtime - In remote paths, change native directory separators to / - Add synchronization to ls/lsl/lsd output to stop corruptions - Ensure all stats/log messages to go stderr - Add --log-file flag to log everything (including panics) to file - Make it possible to disable stats printing with --stats=0 - Implement --bwlimit to limit data transfer bandwidth v1.10 - 2015-02-12 - s3: list an unlimited number of items - Fix getting stuck in the configurator v1.09 - 2015-02-07 - windows: Stop drive letters (e.g. C:) getting mixed up with remotes (e.g. drive:) - local: Fix directory separators on Windows - drive: fix rate limit exceeded errors v1.08 - 2015-02-04 - drive: fix subdirectory listing to not list entire drive - drive: Fix SetModTime - dropbox: adapt code to recent library changes v1.07 - 2014-12-23 - google cloud storage: fix memory leak v1.06 - 2014-12-12 - Fix "Couldn't find home directory" on OSX - swift: Add tenant parameter - Use new location of Google API packages v1.05 - 2014-08-09 - Improved tests and consequently lots of minor fixes - core: Fix race detected by go race detector - core: Fixes after running errcheck - drive: reset root directory on Rmdir and Purge - fs: Document that Purger returns error on empty directory, test and fix - google cloud storage: fix ListDir on subdirectory - google cloud storage: re-read metadata in SetModTime - s3: make reading metadata more reliable to work around eventual consistency problems - s3: strip trailing / from ListDir() - swift: return directories without / in ListDir v1.04 - 2014-07-21 - google cloud storage: Fix crash on Update v1.03 - 2014-07-20 - swift, s3, dropbox: fix updated files being marked as corrupted - Make compile with go 1.1 again v1.02 - 2014-07-19 - Implement Dropbox remote - Implement Google Cloud Storage remote - Verify Md5sums and Sizes after copies - Remove times from "ls" command - lists sizes only - Add add "lsl" - lists times and sizes - Add "md5sum" command v1.01 - 2014-07-04 - drive: fix transfer of big files using up lots of memory v1.00 - 2014-07-03 - drive: fix whole second dates v0.99 - 2014-06-26 - Fix --dry-run not working - Make compatible with go 1.1 v0.98 - 2014-05-30 - s3: Treat missing Content-Length as 0 for some ceph installations - rclonetest: add file with a space in v0.97 - 2014-05-05 - Implement copying of single files - s3 & swift: support paths inside containers/buckets v0.96 - 2014-04-24 - drive: Fix multiple files of same name being created - drive: Use o.Update and fs.Put to optimise transfers - Add version number, -V and --version v0.95 - 2014-03-28 - rclone.org: website, docs and graphics - drive: fix path parsing v0.94 - 2014-03-27 - Change remote format one last time - GNU style flags v0.93 - 2014-03-16 - drive: store token in config file - cross compile other versions - set strict permissions on config file v0.92 - 2014-03-15 - Config fixes and --config option v0.91 - 2014-03-15 - Make config file v0.90 - 2013-06-27 - Project named rclone v0.00 - 2012-11-18 - Project started Bugs and Limitations Limitations Directory timestamps aren't preserved on some backends As of v1.66, rclone supports syncing directory modtimes, if the backend supports it. Some backends do not support it -- see overview for a complete list. Additionally, note that empty directories are not synced by default (this can be enabled with --create-empty-src-dirs.) Rclone struggles with millions of files in a directory/bucket Currently rclone loads each directory/bucket entirely into memory before using it. Since each rclone object takes 0.5k-1k of memory this can take a very long time and use a large amount of memory. Millions of files in a directory tends to occur on bucket-based remotes (e.g. S3 buckets) since those remotes do not segregate subdirectories within the bucket. Bucket-based remotes and folders Bucket-based remotes (e.g. S3/GCS/Swift/B2) do not have a concept of directories. Rclone therefore cannot create directories in them which means that empty directories on a bucket-based remote will tend to disappear. Some software creates empty keys ending in / as directory markers. Rclone doesn't do this as it potentially creates more objects and costs more. This ability may be added in the future (probably via a flag/option). Bugs Bugs are stored in rclone's GitHub project: - Reported bugs - Known issues Frequently Asked Questions Do all cloud storage systems support all rclone commands Yes they do. All the rclone commands (e.g. sync, copy, etc.) will work on all the remote storage systems. Can I copy the config from one machine to another Sure! Rclone stores all of its config in a single file. If you want to find this file, run rclone config file which will tell you where it is. See the remote setup docs for more info. How do I configure rclone on a remote / headless box with no browser? This has now been documented in its own remote setup page. How can I get rid of the "Config file not found" notice? If you see a notice like 'NOTICE: Config file "rclone.conf" not found', this means you have not configured any remotes. If you need to configure a remote, see the config help docs. If you are using rclone entirely with on the fly remotes, you can create an empty config file to get rid of this notice, for example: rclone config touch Can rclone sync directly from drive to s3 Rclone can sync between two remote cloud storage systems just fine. Note that it effectively downloads the file and uploads it again, so the node running rclone would need to have lots of bandwidth. The syncs would be incremental (on a file by file basis). e.g. rclone sync --interactive drive:Folder s3:bucket Using rclone from multiple locations at the same time You can use rclone from multiple places at the same time if you choose different subdirectory for the output, e.g. Server A> rclone sync --interactive /tmp/whatever remote:ServerA Server B> rclone sync --interactive /tmp/whatever remote:ServerB If you sync to the same directory then you should use rclone copy otherwise the two instances of rclone may delete each other's files, e.g. Server A> rclone copy /tmp/whatever remote:Backup Server B> rclone copy /tmp/whatever remote:Backup The file names you upload from Server A and Server B should be different in this case, otherwise some file systems (e.g. Drive) may make duplicates. Why doesn't rclone support partial transfers / binary diffs like rsync? Rclone stores each file you transfer as a native object on the remote cloud storage system. This means that you can see the files you upload as expected using alternative access methods (e.g. using the Google Drive web interface). There is a 1:1 mapping between files on your hard disk and objects created in the cloud storage system. Cloud storage systems (at least none I've come across yet) don't support partially uploading an object. You can't take an existing object, and change some bytes in the middle of it. It would be possible to make a sync system which stored binary diffs like rsync does, instead of whole objects, but that would break the 1:1 mapping of files on your hard disk to objects in the remote cloud storage system. All the cloud storage systems support partial downloads of content, so it would be possible to make partial downloads work. However to make this work efficiently this would require storing a significant amount of metadata, which breaks the desired 1:1 mapping of files to objects. Can rclone do bi-directional sync? Yes, since rclone v1.58.0, bidirectional cloud sync is available. Can I use rclone with an HTTP proxy? Yes. rclone will follow the standard environment variables for proxies, similar to cURL and other programs. In general the variables are called http_proxy (for services reached over http) and https_proxy (for services reached over https). Most public services will be using https, but you may wish to set both. The content of the variable is protocol://server:port. The protocol value is the one used to talk to the proxy server, itself, and is commonly either http or socks5. Slightly annoyingly, there is no standard for the name; some applications may use http_proxy but another one HTTP_PROXY. The Go libraries used by rclone will try both variations, but you may wish to set all possibilities. So, on Linux, you may end up with code similar to export http_proxy=http://proxyserver:12345 export https_proxy=$http_proxy export HTTP_PROXY=$http_proxy export HTTPS_PROXY=$http_proxy Note: If the proxy server requires a username and password, then use export http_proxy=http://username:password@proxyserver:12345 export https_proxy=$http_proxy export HTTP_PROXY=$http_proxy export HTTPS_PROXY=$http_proxy The NO_PROXY allows you to disable the proxy for specific hosts. Hosts must be comma separated, and can contain domains or parts. For instance "foo.com" also matches "bar.foo.com". e.g. export no_proxy=localhost,127.0.0.0/8,my.host.name export NO_PROXY=$no_proxy Note that the FTP backend does not support ftp_proxy yet. You can use the command line argument --http-proxy to set the proxy, and in turn use an override in the config file if you want it set for a single backend, eg override.http_proxy = http://... in the config file. The FTP and SFTP backends have their own http_proxy settings to support an HTTP CONNECT proxy ( --ftp-http-proxy and --sftp-http-proxy ) Rclone gives x509 SSL root certificates error x509: failed to load system roots and no roots provided means that rclone can't find the SSL root certificates. Likely you are running rclone on a NAS with a cut-down Linux OS, or possibly on Solaris. x509: certificate signed by unknown authority error may occur on outdated systems, where rclone can't verify the server with the SSL root certificates. Rclone (via the Go runtime) tries to load the root certificates from these places on Linux. "/etc/ssl/certs/ca-certificates.crt", // Debian/Ubuntu/Gentoo etc. "/etc/pki/tls/certs/ca-bundle.crt", // Fedora/RHEL "/etc/ssl/ca-bundle.pem", // OpenSUSE "/etc/pki/tls/cacert.pem", // OpenELEC So doing something like this should fix the problem. It also sets the time which is important for SSL to work properly. mkdir -p /etc/ssl/certs/ curl -o /etc/ssl/certs/ca-certificates.crt https://raw.githubusercontent.com/bagder/ca-bundle/master/ca-bundle.crt ntpclient -s -h pool.ntp.org The two environment variables SSL_CERT_FILE and SSL_CERT_DIR, mentioned in the x509 package, provide an additional way to provide the SSL root certificates on Unix systems other than macOS. Note that you may need to add the --insecure option to the curl command line if it doesn't work without. curl --insecure -o /etc/ssl/certs/ca-certificates.crt https://raw.githubusercontent.com/bagder/ca-bundle/master/ca-bundle.crt On macOS, you can install ca-certificates with Homebrew, and specify the SSL root certificates with the --ca-cert flag. brew install ca-certificates find $(brew --prefix)/etc/ca-certificates -type f Rclone gives Failed to load config file: function not implemented error Likely this means that you are running rclone on Linux version not supported by the go runtime, ie earlier than version 2.6.23. See the system requirements section in the go install docs for full details. All my uploaded docx/xlsx/pptx files appear as archive/zip This is caused by uploading these files from a Windows computer which hasn't got the Microsoft Office suite installed. The easiest way to fix is to install the Word viewer and the Microsoft Office Compatibility Pack for Word, Excel, and PowerPoint 2007 and later versions' file formats tcp lookup some.domain.com no such host This happens when rclone cannot resolve a domain. Please check that your DNS setup is generally working, e.g. # both should print a long list of possible IP addresses dig www.googleapis.com # resolve using your default DNS dig www.googleapis.com @8.8.8.8 # resolve with Google's DNS server If you are using systemd-resolved (default on Arch Linux), ensure it is at version 233 or higher. Previous releases contain a bug which causes not all domains to be resolved properly. The Go resolver decision can be influenced with the GODEBUG=netdns=... environment variable. This also allows to resolve certain issues with DNS resolution. On Windows or MacOS systems, try forcing use of the internal Go resolver by setting GODEBUG=netdns=go at runtime. On other systems (Linux, *BSD, etc) try forcing use of the system name resolver by setting GODEBUG=netdns=cgo (and recompile rclone from source with CGO enabled if necessary). See the name resolution section in the go docs. Failed to start auth webserver on Windows Error: config failed to refresh token: failed to start auth webserver: listen tcp 127.0.0.1:53682: bind: An attempt was made to access a socket in a way forbidden by its access permissions. ... yyyy/mm/dd hh:mm:ss Fatal error: config failed to refresh token: failed to start auth webserver: listen tcp 127.0.0.1:53682: bind: An attempt was made to access a socket in a way forbidden by its access permissions. This is sometimes caused by the Host Network Service causing issues with opening the port on the host. A simple solution may be restarting the Host Network Service with eg. Powershell Restart-Service hns The total size reported in the stats for a sync is wrong and keeps changing It is likely you have more than 10,000 files that need to be synced. By default, rclone only gets 10,000 files ahead in a sync so as not to use up too much memory. You can change this default with the --max-backlog flag. Rclone is using too much memory or appears to have a memory leak Rclone is written in Go which uses a garbage collector. The default settings for the garbage collector mean that it runs when the heap size has doubled. However it is possible to tune the garbage collector to use less memory by setting GOGC to a lower value, say export GOGC=20. This will make the garbage collector work harder, reducing memory size at the expense of CPU usage. The most common cause of rclone using lots of memory is a single directory with millions of files in. Before rclone v1.70 has to load this entirely into memory as rclone objects. Each rclone object takes 0.5k-1k of memory. There is a workaround for this which involves a bit of scripting. However with rclone v1.70 and later rclone will automatically save directory entries to disk when a directory with more than --list-cutoff (1,000,000 by default) entries is detected. From v1.70 rclone also has the --max-buffer-memory flag which helps particularly when multi-thread transfers are using too much memory. Rclone changes fullwidth Unicode punctuation marks in file names For example: On a Windows system, you have a file with name Test：1.jpg, where ： is the Unicode fullwidth colon symbol. When using rclone to copy this to your Google Drive, you will notice that the file gets renamed to Test:1.jpg, where : is the regular (halfwidth) colon. The reason for such renames is the way rclone handles different restricted filenames on different cloud storage systems. It tries to avoid ambiguous file names as much and allow moving files between many cloud storage systems transparently, by replacing invalid characters with similar looking Unicode characters when transferring to one storage system, and replacing back again when transferring to a different storage system where the original characters are supported. When the same Unicode characters are intentionally used in file names, this replacement strategy leads to unwanted renames. Read more under section caveats. License This is free software under the terms of the MIT license (check the COPYING file included with the source code). Copyright (C) 2019 by Nick Craig-Wood https://www.craig-wood.com/nick/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Authors and contributors Authors - Nick Craig-Wood nick@craig-wood.com Contributors {{< rem email addresses removed from here need to be added to bin/.ignore-emails to make sure update-authors.py doesn't immediately put them back in again. >}} - Alex Couper amcouper@gmail.com - Leonid Shalupov leonid@shalupov.com shalupov@diverse.org.ru - Shimon Doodkin helpmepro1@gmail.com - Colin Nicholson colin@colinn.com - Klaus Post klauspost@gmail.com - Sergey Tolmachev tolsi.ru@gmail.com - Adriano Aurélio Meirelles adriano@atinge.com - C. Bess cbess@users.noreply.github.com - Dmitry Burdeev dibu28@gmail.com - Joseph Spurrier github@josephspurrier.com - Björn Harrtell bjorn@wololo.org - Xavier Lucas xavier.lucas@corp.ovh.com - Werner Beroux werner@beroux.com - Brian Stengaard brian@stengaard.eu - Jakub Gedeon jgedeon@sofi.com - Jim Tittsler jwt@onjapan.net - Michal Witkowski michal@improbable.io - Fabian Ruff fabian.ruff@sap.com - Leigh Klotz klotz@quixey.com - Romain Lapray lapray.romain@gmail.com - Justin R. Wilson jrw972@gmail.com - Antonio Messina antonio.s.messina@gmail.com - Stefan G. Weichinger office@oops.co.at - Per Cederberg cederberg@gmail.com - Radek Šenfeld rush@logic.cz - Fredrik Fornwall fredrik@fornwall.net - Asko Tamm asko@deekit.net - xor-zz xor@gstocco.com - Tomasz Mazur tmazur90@gmail.com - Marco Paganini paganini@paganini.net - Felix Bünemann buenemann@louis.info - Durval Menezes jmrclone@durval.com - Luiz Carlos Rumbelsperger Viana maxd13_luiz_carlos@hotmail.com - Stefan Breunig stefan-github@yrden.de - Alishan Ladhani ali-l@users.noreply.github.com - 0xJAKE 0xJAKE@users.noreply.github.com - Thibault Molleman thibaultmol@users.noreply.github.com - Scott McGillivray scott.mcgillivray@gmail.com - Bjørn Erik Pedersen bjorn.erik.pedersen@gmail.com - Lukas Loesche lukas@mesosphere.io - emyarod emyarod@users.noreply.github.com - T.C. Ferguson tcf909@gmail.com - Brandur brandur@mutelight.org - Dario Giovannetti dev@dariogiovannetti.net - Károly Oláh okaresz@aol.com - Jon Yergatian jon@macfanatic.ca - Jack Schmidt github@mowsey.org - Dedsec1 Dedsec1@users.noreply.github.com - Hisham Zarka hzarka@gmail.com - Jérôme Vizcaino jerome.vizcaino@gmail.com - Mike Tesch mjt6129@rit.edu - Marvin Watson marvwatson@users.noreply.github.com - Danny Tsai danny8376@gmail.com - Yoni Jah yonjah+git@gmail.com yonjah+github@gmail.com - Stephen Harris github@spuddy.org sweharris@users.noreply.github.com - Ihor Dvoretskyi ihor.dvoretskyi@gmail.com - Jon Craton jncraton@gmail.com - Hraban Luyat hraban@0brg.net - Michael Ledin mledin89@gmail.com - Martin Kristensen me@azgul.com - Too Much IO toomuchio@users.noreply.github.com - Anisse Astier anisse@astier.eu - Zahiar Ahmed zahiar@live.com - Igor Kharin igorkharin@gmail.com - Bill Zissimopoulos billziss@navimatics.com - Bob Potter bobby.potter@gmail.com - Steven Lu tacticalazn@gmail.com - Sjur Fredriksen sjurtf@ifi.uio.no - Ruwbin hubus12345@gmail.com - Fabian Möller fabianm88@gmail.com f.moeller@nynex.de - Edward Q. Bridges github@eqbridges.com - Vasiliy Tolstov v.tolstov@selfip.ru - Harshavardhana harsha@minio.io - sainaen sainaen@gmail.com - gdm85 gdm85@users.noreply.github.com - Yaroslav Halchenko debian@onerussian.com - John Papandriopoulos jpap@users.noreply.github.com - Zhiming Wang zmwangx@gmail.com - Andy Pilate cubox@cubox.me - Oliver Heyme olihey@googlemail.com olihey@users.noreply.github.com de8olihe@lego.com - wuyu wuyu@yunify.com - Andrei Dragomir adragomi@adobe.com - Christian Brüggemann mail@cbruegg.com - Alex McGrath Kraak amkdude@gmail.com - bpicode bjoern.pirnay@googlemail.com - Daniel Jagszent daniel@jagszent.de - Josiah White thegenius2009@gmail.com - Ishuah Kariuki kariuki@ishuah.com ishuah91@gmail.com - Jan Varho jan@varho.org - Girish Ramakrishnan girish@cloudron.io - LingMan LingMan@users.noreply.github.com - Jacob McNamee jacobmcnamee@gmail.com - jersou jertux@gmail.com - thierry thierry@substantiel.fr - Simon Leinen simon.leinen@gmail.com ubuntu@s3-test.novalocal - Dan Dascalescu ddascalescu+github@gmail.com - Jason Rose jason@jro.io - Andrew Starr-Bochicchio a.starr.b@gmail.com - John Leach john@johnleach.co.uk - Corban Raun craun@instructure.com - Pierre Carlson mpcarl@us.ibm.com - Ernest Borowski er.borowski@gmail.com - Remus Bunduc remus.bunduc@gmail.com - Iakov Davydov iakov.davydov@unil.ch dav05.gith@myths.ru - Jakub Tasiemski tasiemski@gmail.com - David Minor dminor@saymedia.com - Tim Cooijmans cooijmans.tim@gmail.com - Laurence liuxy6@gmail.com - Giovanni Pizzi gio.piz@gmail.com - Filip Bartodziej filipbartodziej@gmail.com - Jon Fautley jon@dead.li - lewapm 32110057+lewapm@users.noreply.github.com - Yassine Imounachen yassine256@gmail.com - Chris Redekop chris-redekop@users.noreply.github.com chris.redekop@gmail.com - Jon Fautley jon@adenoid.appstal.co.uk - Will Gunn WillGunn@users.noreply.github.com - Lucas Bremgartner lucas@bremis.ch - Jody Frankowski jody.frankowski@gmail.com - Andreas Roussos arouss1980@gmail.com - nbuchanan nbuchanan@utah.gov - Durval Menezes rclone@durval.com - Victor vb-github@viblo.se - Mateusz pabian.mateusz@gmail.com - Daniel Loader spicypixel@gmail.com - David0rk davidork@gmail.com - Alexander Neumann alexander@bumpern.de - Giri Badanahatti gbadanahatti@us.ibm.com@Giris-MacBook-Pro.local - Leo R. Lundgren leo@finalresort.org - wolfv wolfv6@users.noreply.github.com - Dave Pedu dave@davepedu.com - Stefan Lindblom lindblom@spotify.com - seuffert oliver@seuffert.biz - gbadanahatti 37121690+gbadanahatti@users.noreply.github.com - Keith Goldfarb barkofdelight@gmail.com - Steve Kriss steve@heptio.com - Chih-Hsuan Yen yan12125@gmail.com - Alexander Neumann fd0@users.noreply.github.com - Matt Holt mholt@users.noreply.github.com - Eri Bastos bastos.eri@gmail.com - Michael P. Dubner pywebmail@list.ru - Antoine GIRARD sapk@users.noreply.github.com - Mateusz Piotrowski mpp302@gmail.com - Animosity022 animosity22@users.noreply.github.com earl.texter@gmail.com - Peter Baumgartner pete@lincolnloop.com - Craig Rachel craig@craigrachel.com - Michael G. Noll miguno@users.noreply.github.com - hensur me@hensur.de - Oliver Heyme de8olihe@lego.com - Richard Yang richard@yenforyang.com - Piotr Oleszczyk piotr.oleszczyk@gmail.com - Rodrigo rodarima@gmail.com - NoLooseEnds NoLooseEnds@users.noreply.github.com - Jakub Karlicek jakub@karlicek.me - John Clayton john@codemonkeylabs.com - Kasper Byrdal Nielsen byrdal76@gmail.com - Benjamin Joseph Dag bjdag1234@users.noreply.github.com - themylogin themylogin@gmail.com - Onno Zweers onno.zweers@surfsara.nl - Jasper Lievisse Adriaanse jasper@humppa.nl - sandeepkru sandeep.ummadi@gmail.com sandeepkru@users.noreply.github.com - HerrH atomtigerzoo@users.noreply.github.com - Andrew 4030760+sparkyman215@users.noreply.github.com - dan smith XX1011@gmail.com - Oleg Kovalov iamolegkovalov@gmail.com - Ruben Vandamme github-com-00ff86@vandamme.email - Cnly minecnly@gmail.com - Andres Alvarez 1671935+kir4h@users.noreply.github.com - reddi1 xreddi@gmail.com - Matt Tucker matthewtckr@gmail.com - Sebastian Bünger buengese@gmail.com buengese@protonmail.com - Martin Polden mpolden@mpolden.no - Alex Chen Cnly@users.noreply.github.com - Denis deniskovpen@gmail.com - bsteiss 35940619+bsteiss@users.noreply.github.com - Cédric Connes cedric.connes@gmail.com - Dr. Tobias Quathamer toddy15@users.noreply.github.com - dcpu 42736967+dcpu@users.noreply.github.com - Sheldon Rupp me@shel.io - albertony 12441419+albertony@users.noreply.github.com - cron410 cron410@gmail.com - Anagh Kumar Baranwal 6824881+darthShadow@users.noreply.github.com - Felix Brucker felix@felixbrucker.com - Santiago Rodríguez scollazo@users.noreply.github.com - Craig Miskell craig.miskell@fluxfederation.com - Antoine GIRARD sapk@sapk.fr - Joanna Marek joanna.marek@u2i.com - frenos frenos@users.noreply.github.com - ssaqua ssaqua@users.noreply.github.com - xnaas me@xnaas.info - Frantisek Fuka fuka@fuxoft.cz - Paul Kohout pauljkohout@yahoo.com - dcpu 43330287+dcpu@users.noreply.github.com - jackyzy823 jackyzy823@gmail.com - David Haguenauer ml@kurokatta.org - teresy hi.teresy@gmail.com - buergi patbuergi@gmx.de - Florian Gamboeck mail@floga.de - Ralf Hemberger 10364191+rhemberger@users.noreply.github.com - Scott Edlund sedlund@users.noreply.github.com - Erik Swanson erik@retailnext.net - Jake Coggiano jake@stripe.com - brused27 brused27@noemailaddress - Peter Kaminski kaminski@istori.com - Henry Ptasinski henry@logout.com - Alexander kharkovalexander@gmail.com - Garry McNulty garrmcnu@gmail.com - Mathieu Carbou mathieu.carbou@gmail.com - Mark Otway mark@otway.com - William Cocker 37018962+WilliamCocker@users.noreply.github.com - François Leurent 131.js@cloudyks.org - Arkadius Stefanski arkste@gmail.com - Jay dev@jaygoel.com - andrea rota a@xelera.eu - nicolov nicolov@users.noreply.github.com - Matt Joiner anacrolix@gmail.com - Dario Guzik dario@guzik.com.ar - qip qip@users.noreply.github.com - yair@unicorn yair@unicorn - Matt Robinson brimstone@the.narro.ws - kayrus kay.diam@gmail.com - Rémy Léone remy.leone@gmail.com - Wojciech Smigielski wojciech.hieronim.smigielski@gmail.com - weetmuts oehrstroem@gmail.com - Jonathan vanillajonathan@users.noreply.github.com - James Carpenter orbsmiv@users.noreply.github.com - Vince vince0villamora@gmail.com - Nestar47 47841759+Nestar47@users.noreply.github.com - Six brbsix@gmail.com - Alexandru Bumbacea alexandru.bumbacea@booking.com - calisro robert.calistri@gmail.com - Dr.Rx david.rey@nventive.com - marcintustin marcintustin@users.noreply.github.com - jaKa Močnik jaka@koofr.net - Fionera fionera@fionera.de - Dan Walters dan@walters.io - Danil Semelenov sgtpep@users.noreply.github.com - xopez 28950736+xopez@users.noreply.github.com - Ben Boeckel mathstuf@gmail.com - Manu manu@snapdragon.cc - Kyle E. Mitchell kyle@kemitchell.com - Gary Kim gary@garykim.dev - Jon jonathn@github.com - Jeff Quinn jeffrey.quinn@bluevoyant.com - Peter Berbec peter@berbec.com - didil 1284255+didil@users.noreply.github.com - id01 gaviniboom@gmail.com - Robert Marko robimarko@gmail.com - Philip Harvey 32467456+pharveybattelle@users.noreply.github.com - JorisE JorisE@users.noreply.github.com - garry415 garry.415@gmail.com - forgems forgems@gmail.com - Florian Apolloner florian@apolloner.eu - Aleksandar Janković office@ajankovic.com ajankovic@users.noreply.github.com - Maran maran@protonmail.com - nguyenhuuluan434 nguyenhuuluan434@gmail.com - Laura Hausmann zotan@zotan.pw laura@hausmann.dev - yparitcher y@paritcher.com - AbelThar abela.tharen@gmail.com - Matti Niemenmaa matti.niemenmaa+git@iki.fi - Russell Davis russelldavis@users.noreply.github.com - Yi FU yi.fu@tink.se - Paul Millar paul.millar@desy.de - justinalin justinalin@qnap.com - EliEron subanimehd@gmail.com - justina777 chiahuei.lin@gmail.com - Chaitanya Bankanhal bchaitanya15@gmail.com - Michał Matczuk michal@scylladb.com - Macavirus macavirus@zoho.com - Abhinav Sharma abhi18av@outlook.com - ginvine 34869051+ginvine@users.noreply.github.com - Patrick Wang mail6543210@yahoo.com.tw - Cenk Alti cenkalti@gmail.com - Andreas Chlupka andy@chlupka.com - Alfonso Montero amontero@tinet.org - Ivan Andreev ivandeex@gmail.com - David Baumgold david@davidbaumgold.com - Lars Lehtonen lars.lehtonen@gmail.com - Matei David matei.david@gmail.com - David david.bramwell@endemolshine.com - Anthony Rusdi 33247310+antrusd@users.noreply.github.com - Richard Patel me@terorie.dev - 庄天翼 zty0826@gmail.com - SwitchJS dev@switchjs.com - Raphael PowershellNinja@users.noreply.github.com - Sezal Agrawal sezalagrawal@gmail.com - Tyler TylerNakamura@users.noreply.github.com - Brett Dutro brett.dutro@gmail.com - Vighnesh SK booterror99@gmail.com - Arijit Biswas dibbyo456@gmail.com - Michele Caci michele.caci@gmail.com - AlexandrBoltris ua2fgb@gmail.com - Bryce Larson blarson@saltstack.com - Carlos Ferreyra crypticmind@gmail.com - Saksham Khanna sakshamkhanna@outlook.com - dausruddin 5763466+dausruddin@users.noreply.github.com - zero-24 zero-24@users.noreply.github.com - Xiaoxing Ye ye@xiaoxing.us - Barry Muldrey barry@muldrey.net - Sebastian Brandt sebastian.brandt@friday.de - Marco Molteni marco.molteni@mailbox.org - Ankur Gupta 7876747+ankur0493@users.noreply.github.com - Maciej Zimnoch maciej@scylladb.com - anuar45 serdaliyev.anuar@gmail.com - Fernando ferferga@users.noreply.github.com - David Cole david.cole@sohonet.com - Wei He git@weispot.com - Outvi V 19144373+outloudvi@users.noreply.github.com - Thomas Kriechbaumer thomas@kriechbaumer.name - Tennix tennix@users.noreply.github.com - Ole Schütt ole@schuett.name - Kuang-che Wu kcwu@csie.org - Thomas Eales wingsuit@users.noreply.github.com - Paul Tinsley paul.tinsley@vitalsource.com - Felix Hungenberg git@shiftgeist.com - Benjamin Richter github@dev.telepath.de - landall cst_zf@qq.com - thestigma thestigma@gmail.com - jtagcat 38327267+jtagcat@users.noreply.github.com - Damon Permezel permezel@me.com - boosh boosh@users.noreply.github.com - unbelauscht 58393353+unbelauscht@users.noreply.github.com - Motonori IWAMURO vmi@nifty.com - Benjapol Worakan benwrk@live.com - Dave Koston dave.koston@stackpath.com - Durval Menezes DurvalMenezes@users.noreply.github.com - Tim Gallant me@timgallant.us - Frederick Zhang frederick888@tsundere.moe - valery1707 valery1707@gmail.com - Yves G theYinYeti@yalis.fr - Shing Kit Chan chanshingkit@gmail.com - Franklyn Tackitt franklyn@tackitt.net - Robert-André Mauchin zebob.m@gmail.com - evileye 48332831+ibiruai@users.noreply.github.com - Joachim Brandon LeBlanc brandon@leblanc.codes - Patryk Jakuszew patryk.jakuszew@gmail.com - fishbullet shindu666@gmail.com - greatroar <@> - Bernd Schoolmann mail@quexten.com - Elan Ruusamäe glen@pld-linux.org - Max Sum max@lolyculture.com - Mark Spieth mspieth@users.noreply.github.com - harry me@harry.plus - Samantha McVey samantham@posteo.net - Jack Anderson jack.anderson@metaswitch.com - Michael G draget@speciesm.net - Brandon Philips brandon@ifup.org - Daven dooven@users.noreply.github.com - Martin Stone martin@d7415.co.uk - David Bramwell 13053834+dbramwell@users.noreply.github.com - Sunil Patra snl_su@live.com - Adam Stroud adam.stroud@gmail.com - Kush kushsharma@users.noreply.github.com - Matan Rosenberg matan129@gmail.com - gitch1 63495046+gitch1@users.noreply.github.com - ElonH elonhhuang@gmail.com - Fred fred@creativeprojects.tech - Sébastien Gross renard@users.noreply.github.com - Maxime Suret 11944422+msuret@users.noreply.github.com - Caleb Case caleb@storj.io calebcase@gmail.com - Ben Zenker imbenzenker@gmail.com - Martin Michlmayr tbm@cyrius.com - Brandon McNama bmcnama@pagerduty.com - Daniel Slyman github@skylayer.eu - Alex Guerrero guerrero@users.noreply.github.com - Matteo Pietro Dazzi matteopietro.dazzi@gft.com - edwardxml 56691903+edwardxml@users.noreply.github.com - Roman Kredentser shareed2k@gmail.com - Kamil Trzciński ayufan@ayufan.eu - Zac Rubin z-0@users.noreply.github.com - Vincent Feltz - Heiko Bornholdt bornholdt@informatik.uni-hamburg.de - Matteo Pietro Dazzi matteopietro.dazzi@gmail.com - jtagcat gitlab@c7.ee - Petri Salminen petri@salminen.dev - Tim Burke tim.burke@gmail.com - Kai Lüke kai@kinvolk.io - Garrett Squire github@garrettsquire.com - Evan Harris eharris@puremagic.com - Kevin keyam@microsoft.com - Morten Linderud morten@linderud.pw - Dmitry Ustalov dmitry.ustalov@gmail.com - Jack 196648+jdeng@users.noreply.github.com - kcris cristian.tarsoaga@gmail.com - tyhuber1 68970760+tyhuber1@users.noreply.github.com - David Ibarra david.ibarra@realty.com - Tim Gallant tim@lilt.com - Kaloyan Raev kaloyan@storj.io - Jay McEntire jay.mcentire@gmail.com - Leo Luan leoluan@us.ibm.com - aus 549081+aus@users.noreply.github.com - Aaron Gokaslan agokaslan@fb.com - Egor Margineanu egmar@users.noreply.github.com - Lucas Kanashiro lucas.kanashiro@canonical.com - WarpedPixel WarpedPixel@users.noreply.github.com - Sam Edwards sam@samedwards.ca - wjielai gouki0123@gmail.com - Muffin King jinxz_k@live.com - Christopher Stewart 6573710+1f47a@users.noreply.github.com - Russell Cattelan cattelan@digitalelves.com - gyutw 30371241+gyutw@users.noreply.github.com - Hekmon edouardhur@gmail.com - LaSombra lasombra@users.noreply.github.com - Dov Murik dov.murik@gmail.com - Ameer Dawood ameer1234567890@gmail.com - Dan Hipschman dan.hipschman@opendoor.com - Josh Soref jsoref@users.noreply.github.com 2119212+jsoref@users.noreply.github.com - David david@staron.nl - Ingo ingo@hoffmann.cx - Adam Plánský adamplansky@users.noreply.github.com adamplansky@gmail.com - Manish Gupta manishgupta.ait@gmail.com - Deepak Sah sah.sslpu@gmail.com - Marcin Zelent marcin@zelent.net - zhucan zhucan.k8s@gmail.com - James Lim james.lim@samsara.com - Laurens Janssen BD69BM@insim.biz - Bob Bagwill bobbagwill@gmail.com - Nathan Collins colli372@msu.edu - lostheli - kelv kelvin@acks.org - Milly milly.ca@gmail.com - gtorelly gtorelly@gmail.com - Brad Ackerman brad@facefault.org - Mitsuo Heijo mitsuo.heijo@gmail.com - Claudio Bantaloukas rockdreamer@gmail.com - Benjamin Gustin gustin.ben@gmail.com - Ingo Weiss ingo@redhat.com - Kerry Su me@sshockwave.net - Ilyess Bachiri ilyess.bachiri@sonder.com - Yury Stankevich urykhy@gmail.com - kice wslikerqs@gmail.com - Denis Neuling denisneuling@gmail.com - Janne Johansson icepic.dz@gmail.com - Patrik Nordlén patriki@gmail.com - CokeMine aptx4561@gmail.com - Sơn Trần-Nguyễn github@sntran.com - lluuaapp 266615+lluuaapp@users.noreply.github.com - Zach Kipp kipp.zach@gmail.com - Riccardo Iaconelli riccardo@kde.org - Sakuragawa Misty gyc990326@gmail.com - Nicolas Rueff nicolas@rueff.fr - Pau Rodriguez-Estivill prodrigestivill@gmail.com - Bob Pusateri BobPusateri@users.noreply.github.com - Alex JOST 25005220+dimejo@users.noreply.github.com - Alexey Tabakman samosad.ru@gmail.com - David Sze sze.david@gmail.com - cynthia kwok cynthia.m.kwok@gmail.com - Miron Veryanskiy MironVeryanskiy@gmail.com - K265 k.265@qq.com - Vesnyx Vesnyx@users.noreply.github.com - Dmitry Chepurovskiy me@dm3ch.net - Rauno Ots rauno.ots@cgi.com - Georg Neugschwandtner georg.neugschwandtner@gmx.net - pvalls polvallsrue@gmail.com - Robert Thomas 31854736+wolveix@users.noreply.github.com - Romeo Kienzler romeo.kienzler@gmail.com - tYYGH tYYGH@users.noreply.github.com - georne 77802995+georne@users.noreply.github.com - Maxwell Calman mcalman@MacBook-Pro.local - Naveen Honest Raj naveendurai19@gmail.com - Lucas Messenger lmesseng@cisco.com - Manish Kumar krmanish260@gmail.com - x0b x0bdev@gmail.com - CERN through the CS3MESH4EOSC Project - Nick Gaya nicholasgaya+github@gmail.com - Ashok Gelal 401055+ashokgelal@users.noreply.github.com - Dominik Mydlil dominik.mydlil@outlook.com - Nazar Mishturak nazarmx@gmail.com - Ansh Mittal iamAnshMittal@gmail.com - noabody noabody@yahoo.com - OleFrost 82263101+olefrost@users.noreply.github.com - Kenny Parsons kennyparsons93@gmail.com - Jeffrey Tolar tolar.jeffrey@gmail.com - jtagcat git-514635f7@jtag.cat - Tatsuya Noyori 63089076+public-tatsuya-noyori@users.noreply.github.com - lewisxy lewisxy@users.noreply.github.com - Nolan Woods nolan_w@sfu.ca - Gautam Kumar 25435568+gautamajay52@users.noreply.github.com - Chris Macklin chris.macklin@10xgenomics.com - Antoon Prins antoon.prins@surfsara.nl - Alexey Ivanov rbtz@dropbox.com - Serge Pouliquen sp31415@free.fr - acsfer carlos@reendex.com - Tom tom@tom-fitzhenry.me.uk - Tyson Moore tyson@tyson.me - database64128 free122448@hotmail.com - Chris Lu chrislusf@users.noreply.github.com - Reid Buzby reid@rethink.software - darrenrhs darrenrhs@gmail.com - Florian Penzkofer fp@nullptr.de - Xuanchen Wu 117010292@link.cuhk.edu.cn - partev petrosyan@gmail.com - Dmitry Sitnikov fo2@inbox.ru - Haochen Tong i@hexchain.org - Michael Hanselmann public@hansmi.ch - Chuan Zh zhchuan7@gmail.com - Antoine GIRARD antoine.girard@sapk.fr - Justin Winokur (Jwink3101) Jwink3101@users.noreply.github.com - Mariano Absatz (git) scm@baby.com.ar - Greg Sadetsky lepetitg@gmail.com - yedamo logindaveye@gmail.com - hota lindwurm.q@gmail.com - vinibali vinibali1@gmail.com - Ken Enrique Morel ken.morel.santana@gmail.com - Justin Hellings justin.hellings@gmail.com - Parth Shukla pparth@pparth.net - wzl wangzl31@outlook.com - HNGamingUK connor@earnshawhome.co.uk - Jonta 359397+Jonta@users.noreply.github.com - YenForYang YenForYang@users.noreply.github.com - SimJoSt / Joda Stößer git@simjo.st - Logeshwaran waranlogesh@gmail.com - Rajat Goel rajat@dropbox.com - r0kk3rz r0kk3rz@gmail.com - Matthew Sevey mjsevey@gmail.com - Filip Rysavy fil@siasky.net - Ian Levesque ian@ianlevesque.org - Thomas Stachl thomas@stachl.me - Dmitry Bogatov git#v1@kaction.cc - thomae 4493560+thomae@users.noreply.github.com - trevyn trevyn-git@protonmail.com - David Liu david.yx.liu@oracle.com - Chris Nelson stuff@cjnaz.com - Felix Bünemann felix.buenemann@gmail.com - Atílio Antônio atiliodadalto@hotmail.com - Carlo Mion mion00@gmail.com - Chris Lu chris.lu@gmail.com - Vitor Arruda vitor.pimenta.arruda@gmail.com - bbabich bbabich@datamossa.com - David dp.davide.palma@gmail.com - Borna Butkovic borna@favicode.net - Fredric Arklid fredric.arklid@consid.se - Andy Jackson Andrew.Jackson@bl.uk - Sinan Tan i@tinytangent.com - deinferno 14363193+deinferno@users.noreply.github.com - rsapkf rsapkfff@pm.me - Will Holtz wholtz@gmail.com - GGG KILLER gggkiller2@gmail.com - Logeshwaran Murugesan logeshwaran@testpress.in - Lu Wang coolwanglu@gmail.com - Bumsu Hyeon ksitht@gmail.com - Shmz Ozggrn 98463324+ShmzOzggrn@users.noreply.github.com - Kim kim@jotta.no - Niels van de Weem n.van.de.weem@smile.nl - Koopa codingkoopa@gmail.com - Yunhai Luo yunhai-luo@hotmail.com - Charlie Jiang w@chariri.moe - Alain Nussbaumer alain.nussbaumer@alleluia.ch - Vanessasaurus 814322+vsoch@users.noreply.github.com - Isaac Levy isaac.r.levy@gmail.com - Gourav T workflowautomation@protonmail.com - Paulo Martins paulo.pontes.m@gmail.com - viveknathani viveknathani2402@gmail.com - Eng Zer Jun engzerjun@gmail.com - Abhiraj abhiraj.official15@gmail.com - Márton Elek elek@apache.org elek@users.noreply.github.com - Vincent Murphy vdm@vdm.ie - ctrl-q 34975747+ctrl-q@users.noreply.github.com - Nil Alexandrov nalexand@akamai.com - GuoXingbin 101376330+guoxingbin@users.noreply.github.com - Berkan Teber berkan@berkanteber.com - Tobias Klauser tklauser@distanz.ch - KARBOWSKI Piotr piotr.karbowski@gmail.com - GH geeklihui@foxmail.com - rafma0 int.main@gmail.com - Adrien Rey-Jarthon jobs@adrienjarthon.com - Nick Gooding 73336146+nickgooding@users.noreply.github.com - Leroy van Logchem lr.vanlogchem@gmail.com - Zsolt Ero zsolt.ero@gmail.com - Lesmiscore nao20010128@gmail.com - ehsantdy ehsan.tadayon@arvancloud.com ehsantadayon85@gmail.com - SwazRGB 65694696+swazrgb@users.noreply.github.com - Mateusz Puczyński mati6095@gmail.com - Michael C Tiernan - MIT-Research Computing Project mtiernan@mit.edu - Kaspian 34658474+KaspianDev@users.noreply.github.com - Werner EvilOlaf@users.noreply.github.com - Hugal31 hugo.laloge@gmail.com - Christian Galo 36752715+cgalo5758@users.noreply.github.com - Erik van Velzen erik@evanv.nl - Derek Battams derek@battams.ca - Paul devnoname120@gmail.com - SimonLiu simonliu009@users.noreply.github.com - Hugo Laloge hla@lescompanions.com - Mr-Kanister 68117355+Mr-Kanister@users.noreply.github.com - Rob Pickerill r.pickerill@gmail.com - Andrey to.merge@gmail.com - Eric Wolf 19wolf@gmail.com - Nick nick.naumann@mailbox.tu-dresden.de - Jason Zheng jszheng17@gmail.com - Matthew Vernon mvernon@wikimedia.org - Noah Hsu i@nn.ci - m00594701 mengpengbo@huawei.com - Art M. Gallagher artmg50@gmail.com - Sven Gerber 49589423+svengerber@users.noreply.github.com - CrossR r.cross@lancaster.ac.uk - Maciej Radzikowski maciej@radzikowski.com.pl - Scott Grimes scott.grimes@spaciq.com - Phil Shackleton 71221528+philshacks@users.noreply.github.com - eNV25 env252525@gmail.com - Caleb inventor96@users.noreply.github.com - J-P Treen jp@wraptious.com - Martin Czygan 53705+miku@users.noreply.github.com - buda sandrojijavadze@protonmail.com - mirekphd 36706320+mirekphd@users.noreply.github.com - vyloy vyloy@qq.com - Anthrazz 25553648+Anthrazz@users.noreply.github.com - zzr93 34027824+zzr93@users.noreply.github.com - Paul Norman penorman@mac.com - Lorenzo Maiorfi maiorfi@gmail.com - Claudio Maradonna penguyman@stronzi.org - Ovidiu Victor Tatar ovi.tatar@googlemail.com - Evan Spensley epspensley@gmail.com - Yen Hu 61753151+0x59656e@users.noreply.github.com - Steve Kowalik steven@wedontsleep.org - Jordi Gonzalez Muñoz jordigonzm@gmail.com - Joram Schrijver i@joram.io - Mark Trolley marktrolley@gmail.com - João Henrique Franco joaohenrique.franco@gmail.com - anonion aman207@users.noreply.github.com - Ryan Morey 4590343+rmorey@users.noreply.github.com - Simon Bos simonbos9@gmail.com - YFdyh000 yfdyh000@gmail.com - Øyvind Heddeland Instefjord instefjord@outlook.com - Dmitry Deniskin 110819396+ddeniskin@users.noreply.github.com - Alexander Knorr 106825+opexxx@users.noreply.github.com - Richard Bateman richard@batemansr.us - Dimitri Papadopoulos Orfanos 3234522+DimitriPapadopoulos@users.noreply.github.com - Lorenzo Milesi lorenzo.milesi@yetopen.com - Isaac Aymerich isaac.aymerich@gmail.com - YanceyChiew 35898533+YanceyChiew@users.noreply.github.com - Manoj Ghosh msays2000@gmail.com - Bachue Zhou bachue.shu@gmail.com - Manoj Ghosh manoj.ghosh@oracle.com - Tom Mombourquette tom@devnode.com - Robert Newson rnewson@apache.org - Samuel Johnson esamueljohnson@gmail.com - coultonluke luke@luke.org.uk - Anthony Pessy anthony@cogniteev.com - Philip Harvey pharvey@battelleecology.org - dgouju dgouju@users.noreply.github.com - Clément Notin clement.notin@gmail.com - x3-apptech 66947598+x3-apptech@users.noreply.github.com - Arnie97 arnie97@gmail.com - Roel Arents 2691308+roelarents@users.noreply.github.com - Aaron Gokaslan aaronGokaslan@gmail.com - techknowlogick matti@mdranta.net - rkettelerij richard@mindloops.nl - Kamui fin-kamui@pm.me - asdffdsazqqq 90116442+asdffdsazqqq@users.noreply.github.com - Nathaniel Wesley Filardo nfilardo@microsoft.com - ycdtosa ycdtosa@users.noreply.github.com - Erik Agterdenbos agterdenbos@users.noreply.github.com - Kevin Verstaen 48050031+kverstae@users.noreply.github.com - MohammadReza mrvashian@gmail.com - vanplus 60313789+vanplus@users.noreply.github.com - Jack 16779171+jkpe@users.noreply.github.com - Abdullah Saglam abdullah.saglam@stonebranch.com - Marks Polakovs github@markspolakovs.me - piyushgarg piyushgarg80@gmail.com - Kaloyan Raev kaloyan-raev@users.noreply.github.com - IMTheNachoMan imthenachoman@gmail.com - alankrit alankrit@google.com - Bryan Kaplan <#@bryankaplan.com> - LXY 767763591@qq.com - Simmon Li (he/him) li.simmon@gmail.com - happyxhw 44490504+happyxhw@users.noreply.github.com - Simmon Li (he/him) hello@crespire.dev - Matthias Baur baurmatt@users.noreply.github.com - Hunter Wittenborn hunter@hunterwittenborn.com - logopk peter@kreuser.name - Gerard Bosch 30733556+gerardbosch@users.noreply.github.com - ToBeFree github@tfrei.de - NodudeWasTaken 75137537+NodudeWasTaken@users.noreply.github.com - Peter Brunner peter@lugoues.net - Ninh Pham dongian.rapclubkhtn@gmail.com - Ryan Caezar Itang sitiom@proton.me - Peter Brunner peter@psykhe.com - Leandro Sacchet leandro.sacchet@animati.com.br - dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> - cycneuramus 56681631+cycneuramus@users.noreply.github.com - Arnavion me@arnavion.dev - Christopher Merry christopher.merry@mlb.com - Thibault Coupin thibault.coupin@gmail.com - Richard Tweed RichardoC@users.noreply.github.com - Zach Kipp Zacho2@users.noreply.github.com - yuudi 26199752+yuudi@users.noreply.github.com - NickIAm NickIAm@users.noreply.github.com - Juang, Yi-Lin frankyjuang@gmail.com - jumbi77 jumbi77@users.noreply.github.com - Aditya Basu ab.aditya.basu@gmail.com - ed s@ocv.me - Drew Parsons dparsons@emerall.com - Joel joelnb@users.noreply.github.com - wiserain mail275@gmail.com - Roel Arents roel.arents@kadaster.nl - Shyim github@shyim.de - Rintze Zelle 78232505+rzelle-lallemand@users.noreply.github.com - Damo damoclark@users.noreply.github.com - WeidiDeng weidi_deng@icloud.com - Brian Starkey stark3y@gmail.com - jladbrook jhladbrook@gmail.com - Loren Gordon lorengordon@users.noreply.github.com - dlitster davidlitster@gmail.com - Tobias Gion tobias@gion.io - Jānis Bebrītis janis.bebritis@wunder.io - Adam K github.com@ak.tidy.email - Andrei Smirnov smirnov.captain@gmail.com - Janne Hellsten jjhellst@gmail.com - cc 12904584+shvc@users.noreply.github.com - Tareq Sharafy tareq.sha@gmail.com - kapitainsky dariuszb@me.com - douchen playgoobug@gmail.com - Sam Lai 70988+slai@users.noreply.github.com - URenko 18209292+URenko@users.noreply.github.com - Stanislav Gromov kullfar@gmail.com - Paulo Schreiner paulo.schreiner@delivion.de - Mariusz Suchodolski mariusz@suchodol.ski - danielkrajnik dan94kra@gmail.com - Peter Fern github@0xc0dedbad.com - zzq i@zhangzqs.cn - mac-15 usman.ilamdin@phpstudios.com - Sawada Tsunayoshi 34431649+TsunayoshiSawada@users.noreply.github.com - Dean Attali daattali@gmail.com - Fjodor42 molgaard@gmail.com - BakaWang wa11579@hotmail.com - Mahad 56235065+Mahad-lab@users.noreply.github.com - Vladislav Vorobev x.miere@gmail.com - darix darix@users.noreply.github.com - Benjamin 36415086+bbenjamin-sys@users.noreply.github.com - Chun-Hung Tseng henrybear327@users.noreply.github.com - Ricardo D'O. Albanus rdalbanus@users.noreply.github.com - gabriel-suela gscsuela@gmail.com - Tiago Boeing contato@tiagoboeing.com - Edwin Mackenzie-Owen edwin.mowen@gmail.com - Niklas Hambüchen mail@nh2.me - yuudi yuudi@users.noreply.github.com - Zach github@prozach.org - nielash 31582349+nielash@users.noreply.github.com - Julian Lepinski lepinsk@users.noreply.github.com - Raymond Berger RayBB@users.noreply.github.com - Nihaal Sangha nihaal.git@gmail.com - Masamune3210 1053504+Masamune3210@users.noreply.github.com - James Braza jamesbraza@gmail.com - antoinetran antoinetran@users.noreply.github.com - alexia me@alexia.lol - nielash nielronash@gmail.com - Vitor Gomes vitor.gomes@delivion.de mail@vitorgomes.com - Jacob Hands jacob@gogit.io - hideo aoyama 100831251+boukendesho@users.noreply.github.com - Roberto Ricci io@r-ricci.it - Bjørn Smith bjornsmith@gmail.com - Alishan Ladhani 8869764+aladh@users.noreply.github.com - zjx20 zhoujianxiong2@gmail.com - Oksana 142890647+oks-maytech@users.noreply.github.com - Volodymyr Kit v.kit@maytech.net - David Pedersen limero@me.com - Drew Stinnett drew@drewlink.com - Pat Patterson pat@backblaze.com - Herby Gillot herby.gillot@gmail.com - Nikita Shoshin shoshin_nikita@fastmail.com - rinsuki 428rinsuki+git@gmail.com - Beyond Meat 51850644+beyondmeat@users.noreply.github.com - Saleh Dindar salh@fb.com - Volodymyr 142890760+vkit-maytech@users.noreply.github.com - Gabriel Espinoza 31670639+gspinoza@users.noreply.github.com - Keigo Imai keigo.imai@gmail.com - Ivan Yanitra iyanitra@tesla-consulting.com - alfish2000 alfish2000@gmail.com - wuxingzhong qq330332812@gmail.com - Adithya Kumar akumar42@protonmail.com - Tayo-pasedaRJ 138471223+Tayo-pasedaRJ@users.noreply.github.com - Peter Kreuser logo@kreuser.name - fotile96 fotile96@users.noreply.github.com - Luc Ritchie luc.ritchie@gmail.com - cynful cynful@users.noreply.github.com - wjielai wjielai@tencent.com - Jack Deng jackdeng@gmail.com - Mikubill 31246794+Mikubill@users.noreply.github.com - Artur Neumann artur@jankaritech.com - Saw-jan saw.jan.grg3e@gmail.com - Oksana Zhykina o.zhykina@maytech.net - karan karan.gupta92@gmail.com - viktor viktor@yakovchuk.net - moongdal moongdal@tutanota.com - Mina Galić freebsd@igalic.co - Alen Šiljak dev@alensiljak.eu.org - 你知道未来吗 rkonfj@gmail.com - Abhinav Dhiman 8640877+ahnv@users.noreply.github.com - halms 7513146+halms@users.noreply.github.com - ben-ba benjamin.brauner@gmx.de - Eli Orzitzer e_orz@yahoo.com - Anthony Metzidis anthony.metzidis@gmail.com - keongalvin keongalvin@gmail.com - rarspace01 rarspace01@users.noreply.github.com - Paul Stern paulstern45@gmail.com - Nikhil Ahuja nikhilahuja@live.com - Harshit Budhraja 52413945+harshit-budhraja@users.noreply.github.com - Tera 24725862+teraa@users.noreply.github.com - Kyle Reynolds kylereynoldsdev@gmail.com - Michael Eischer michael.eischer@gmx.de - Thomas Müller 1005065+DeepDiver1975@users.noreply.github.com - DanielEgbers 27849724+DanielEgbers@users.noreply.github.com - Jack Provance 49460795+njprov@users.noreply.github.com - Gabriel Ramos 109390599+gabrielramos02@users.noreply.github.com - Dan McArdle d@nmcardle.com - Joe Cai joe.cai@bigcommerce.com - Anders Swanson anders.swanson@oracle.com - huajin tong 137764712+thirdkeyword@users.noreply.github.com - John-Paul Smith john-paulsmith@users.noreply.github.com - racerole 148756161+racerole@users.noreply.github.com - Gachoud Philippe ph.gachoud@gmail.com - YukiUnHappy saberhana@yandex.com - Kyle Reynolds kyle.reynolds@bridgerphotonics.com - Lewis Hook lewis@hook.im - hoyho luohaihao@gmail.com - Vitaly 9034218+gvitali@users.noreply.github.com - iotmaestro iotmaestro@proton.me - psychopatt 66741203+psychopatt@users.noreply.github.com - Alex Garel alex@garel.org - Warrentheo warrentheo@hotmail.com - Alexandre Lavigne lavigne958@gmail.com - yoelvini 134453420+yoelvini@users.noreply.github.com - Erisa A erisa@cloudflare.com - Pieter van Oostrum pieter@vanoostrum.org - jakzoe 155812065+jakzoe@users.noreply.github.com - guangwu guoguangwu@magic-shield.com - static-moonlight 107991124+static-moonlight@users.noreply.github.com - yudrywet yudeyao@yeah.net - Butanediol git@xnh.app - Dave Nicolson david.nicolson@gmail.com - Katia Esposito katia@linux.com - pawsey-kbuckley 36438302+pawsey-kbuckley@users.noreply.github.com - hidewrong 167099254+hidewrong@users.noreply.github.com - Michael Terry mike@mterry.name - Sunny 25066078+LoSunny@users.noreply.github.com - overallteach cricis@foxmail.com - JT Olio jt@olio.lol - Evan McBeth 64177332+AtomicRobotMan0101@users.noreply.github.com - Dominik Joe Pantůček dominik.pantucek@trustica.cz - yumeiyin 155420652+yumeiyin@users.noreply.github.com - Bruno Fernandes 54373093+folkzb@users.noreply.github.com - Thomas Schneider tspam.github@brainfuck.space - Charles Hamilton 52973156+chamilton-ccn@users.noreply.github.com - Tomasz Melcer tomasz@melcer.pl - Michał Dzienisiewicz michal.piotr.dz@gmail.com - Florian Klink flokli@flokli.de - Bill Fraser bill@wfraser.dev - Thearas thearas850@gmail.com - Filipe Herculano fifo_@live.com - Russ Bubley russ.bubley@googlemail.com - Paul Collins paul.collins@canonical.com - Tomasz Melcer liori@exroot.org - itsHenry 2671230065@qq.com - Ke Wang me@ke.wang - AThePeanut4 49614525+AThePeanut4@users.noreply.github.com - Tobias Markus tobbi.bugs@googlemail.com - Ernie Hershey github@ernie.org - Will Miles wmiles@sgl.com - David Seifert 16636962+SoapGentoo@users.noreply.github.com - Fornax wimbrand96@gmail.com - Sam Harrison sam.harrison@files.com - Péter Bozsó 3806723+peterbozso@users.noreply.github.com - Georg Welzel gwelzel@mailbox.org - John Oxley john.oxley@gmail.com joxley@meta.com - Pawel Palucha pawel.palucha@aetion.com - crystalstall crystalruby@qq.com - nipil nipil@users.noreply.github.com - yuval-cloudinary 46710068+yuval-cloudinary@users.noreply.github.com - Mathieu Moreau mrx23dot@users.noreply.github.com - fsantagostinobietti 6057026+fsantagostinobietti@users.noreply.github.com - Oleg Kunitsyn 114359669+hiddenmarten@users.noreply.github.com - Divyam 47589864+divyam234@users.noreply.github.com - ttionya ttionya@users.noreply.github.com - quiescens quiescens@gmail.com - rishi.sridhar rishi.sridhar@zohocorp.com - Lawrence Murray lawrence@indii.org - Leandro Piccilli leandro.piccilli@thalesgroup.com - Benjamin Legrand benjamin.legrand@seagate.com - Noam Ross noam.ross@gmail.com - lostb1t coding-mosses0z@icloud.com - Matthias Gatto matthias.gatto@outscale.com - André Tran andre.tran@outscale.com - Simon Bos simon@simonbos.be - Alexandre Hamez 199517+ahamez@users.noreply.github.com - Randy Bush randy@psg.com - Diego Monti diegmonti@users.noreply.github.com - tgfisher tgfisher@stanford.edu - Moises Lima mozlima@gmail.com - Dimitar Ivanov mimiteto@gmail.com - shenpengfeng xinhangzhou@icloud.com - Dimitrios Slamaris dim0x69@users.noreply.github.com - vintagefuture 39503528+vintagefuture@users.noreply.github.com - David Seifert soap@gentoo.org - Michael R. Davis mrdvt92@users.noreply.github.com - remygrandin remy.gr@ndin.fr - Ilias Ozgur Can Leonard iscilyas@gmail.com - divinity76 divinity76@gmail.com - Martin Hassack martin@redmaple.tech - Filipe Azevedo pasnox@gmail.com - hayden.pan hayden.pan@outlook.com - Yxxx 45665172+marsjane@users.noreply.github.com - Thomas ten Cate ttencate@gmail.com - Louis Laureys louis@laureys.me - Henry Lee contact@nynxz.com - ToM thomas.faucher@bibliosansfrontieres.org - TAKEI Yuya 853320+takei-yuya@users.noreply.github.com - Francesco Frassinelli fraph24@gmail.com francesco.frassinelli@nina.no - Matt Ickstadt mattico8@gmail.com matt@beckenterprises.com - Spencer McCullough mccullough.spencer@gmail.com - Jonathan Giannuzzi jonathan@giannuzzi.me - Christoph Berger github@christophberger.com - Tim White tim.white@su.org.au - Robin Schneider robin.schneider@stackit.cloud - izouxv izouxv@users.noreply.github.com - Moises Lima mozlima@users.noreply.github.com - Bruno Fernandes bruno.fernandes1996@hotmail.com - Corentin Barreau corentin@archive.org - hiddenmarten hiddenmarten@gmail.com - Trevor Starick trevor.starick@gmail.com - b-wimmer 132347192+b-wimmer@users.noreply.github.com - Jess jess@jessie.cafe - Zachary Vorhies zachvorhies@protonmail.com - Alexander Minbaev minbaev@gmail.com - Joel K Biju joelkbiju18@gmail.com - ll3006 doublel3006@gmail.com - jbagwell-akamai 113531113+jbagwell-akamai@users.noreply.github.com - Michael Kebe michael.kebe@gmail.com - Lorenz Brun lorenz@brun.one - Dave Vasilevsky djvasi@gmail.com dave@vasilevsky.ca - luzpaz luzpaz@users.noreply.github.com - jack 9480542+jackusm@users.noreply.github.com - Jörn Friedrich Dreyer jfd@butonic.de - alingse alingse@foxmail.com - Fernando Fernández ferferga@hotmail.com - eccoisle 167755281+eccoisle@users.noreply.github.com - Klaas Freitag kraft@freisturz.de - Danny Garside dannygarside@outlook.com - Samantha Bowen sam@bbowen.net - simonmcnair 101189766+simonmcnair@users.noreply.github.com - huanghaojun jasen.huang@ugreen.com - Enduriel endur1el@protonmail.com - Markus Gerstel markus.gerstel@osirium.com - simwai 16225108+simwai@users.noreply.github.com - Ben Alex ben.alex@acegi.com.au - Klaas Freitag opensource@freisturz.de klaas.freitag@kiteworks.com - Andrew Kreimer algonell@gmail.com - Ed Craig-Wood 138211970+edc-w@users.noreply.github.com - Christian Richter crichter@owncloud.com 1058116+dragonchaser@users.noreply.github.com - Ralf Haferkamp r.haferkamp@opencloud.eu - Jugal Kishore me@devjugal.com - Tho Neyugn nguyentruongtho@users.noreply.github.com - Ben Boeckel mathstuf@users.noreply.github.com - Clément Wehrung cwehrung@nurves.com - Jeff Geerling geerlingguy@mac.com - Germán Casares german.casares.march+github@gmail.com - fhuber florian.huber@noris.de - wbulot wbulot@hotmail.com - Jeremy Daer jeremydaer@gmail.com - Oleksiy Stashok ostashok@tesla.com - PrathameshLakawade prathameshlakawade@gmail.com - Nathanael Demacon 7271496+quantumsheep@users.noreply.github.com - ahxxm ahxxm@users.noreply.github.com - Flora Thiebaut johann.thiebaut@gmail.com - kingston125 support@filelu.com - Ser-Bul 30335009+Ser-Bul@users.noreply.github.com - jinjingroad jinjingroad@sina.com - necaran 55765083+necaran@users.noreply.github.com - Marvin Rösch marvinroesch99@gmail.com - curlwget curlwget@icloud.com - $@M@RTH_ 165886349+Samarth1015@users.noreply.github.com - Ali Zein Yousuf azy5030@gmail.com - Davide Bizzarri davide.bizzarri@willhaben.at - Ross Smith II ross@smithii.com - Vikas Bhansali 64532198+vibhansa-msft@users.noreply.github.com - Sudipto Baral sudiptobaral.me@gmail.com - Sam Pegg samrpegg@gmail.com - liubingrun liubr1@chinatelecom.cn - Albin Parou fumesover@gmail.com - n4n5 56606507+Its-Just-Nans@users.noreply.github.com - Florent Vennetier florent.vennetier@ovhcloud.com - houance 45840516+houance@users.noreply.github.com - Yu Xin 3188+is@users.noreply.github.com - Antonin Goude antonin.goude@ovhcloud.com - Timothy Jacobs timothy@ironbounddesigns.com - praveen-solanki-oracle praveen.solanki@oracle.com - huangnauh huanglibo2010@gmail.com - Lucas Bremgartner breml@users.noreply.github.com - Binbin Qian qianbinbin@hotmail.com - cui 523516579@qq.com Contact the rclone project Forum Forum for questions and general discussion: - https://forum.rclone.org Business support For business support or sponsorship enquiries please see: - https://rclone.com/ - sponsorship@rclone.com GitHub repository The project's repository is located at: - https://github.com/rclone/rclone There you can file bug reports or contribute with pull requests. Twitter You can also follow Nick on twitter for rclone announcements: - @njcw Email Or if all else fails or you want to ask something private or confidential - info@rclone.com Please don't email requests for help to this address - those are better directed to the forum unless you'd like to sign up for business support. rclone-v1.71.0/Makefile000066400000000000000000000263211505210326400147120ustar00rootroot00000000000000SHELL = bash # Branch we are working on BRANCH := $(or $(BUILD_SOURCEBRANCHNAME),$(lastword $(subst /, ,$(GITHUB_REF))),$(shell git rev-parse --abbrev-ref HEAD)) # Tag of the current commit, if any. If this is not "" then we are building a release RELEASE_TAG := $(shell git tag -l --points-at HEAD) # Version of last release (may not be on this branch) VERSION := $(shell cat VERSION) # Last tag on this branch LAST_TAG := $(shell git describe --tags --abbrev=0) # Next version NEXT_VERSION := $(shell echo $(VERSION) | awk -F. -v OFS=. '{print $$1,$$2+1,0}') NEXT_PATCH_VERSION := $(shell echo $(VERSION) | awk -F. -v OFS=. '{print $$1,$$2,$$3+1}') # If we are working on a release, override branch to master ifdef RELEASE_TAG BRANCH := master LAST_TAG := $(shell git describe --abbrev=0 --tags $(VERSION)^) endif TAG_BRANCH := .$(BRANCH) BRANCH_PATH := branch/$(BRANCH)/ # If building HEAD or master then unset TAG_BRANCH and BRANCH_PATH ifeq ($(subst HEAD,,$(subst master,,$(BRANCH))),) TAG_BRANCH := BRANCH_PATH := endif # Make version suffix -beta.NNNN.CCCCCCCC (N=Commit number, C=Commit) VERSION_SUFFIX := -beta.$(shell git rev-list --count HEAD).$(shell git show --no-patch --no-notes --pretty='%h' HEAD) # TAG is current version + commit number + commit + branch TAG := $(VERSION)$(VERSION_SUFFIX)$(TAG_BRANCH) ifdef RELEASE_TAG TAG := $(RELEASE_TAG) endif GO_VERSION := $(shell go version) GO_OS := $(shell go env GOOS) ifdef BETA_SUBDIR BETA_SUBDIR := /$(BETA_SUBDIR) endif BETA_PATH := $(BRANCH_PATH)$(TAG)$(BETA_SUBDIR) BETA_URL := https://beta.rclone.org/$(BETA_PATH)/ BETA_UPLOAD_ROOT := beta.rclone.org: BETA_UPLOAD := $(BETA_UPLOAD_ROOT)/$(BETA_PATH) # Pass in GOTAGS=xyz on the make command line to set build tags ifdef GOTAGS BUILDTAGS=-tags "$(GOTAGS)" LINTTAGS=--build-tags "$(GOTAGS)" endif LDFLAGS=--ldflags "-s -X github.com/rclone/rclone/fs.Version=$(TAG)" .PHONY: rclone test_all vars version rclone: ifeq ($(GO_OS),windows) go run bin/resource_windows.go -version $(TAG) -syso resource_windows_`go env GOARCH`.syso endif go build -v $(LDFLAGS) $(BUILDTAGS) $(BUILD_ARGS) ifeq ($(GO_OS),windows) rm resource_windows_`go env GOARCH`.syso endif mkdir -p `go env GOPATH`/bin/ cp -av rclone`go env GOEXE` `go env GOPATH`/bin/rclone`go env GOEXE`.new mv -v `go env GOPATH`/bin/rclone`go env GOEXE`.new `go env GOPATH`/bin/rclone`go env GOEXE` test_all: go install $(LDFLAGS) $(BUILDTAGS) $(BUILD_ARGS) github.com/rclone/rclone/fstest/test_all vars: @echo SHELL="'$(SHELL)'" @echo BRANCH="'$(BRANCH)'" @echo TAG="'$(TAG)'" @echo VERSION="'$(VERSION)'" @echo GO_VERSION="'$(GO_VERSION)'" @echo BETA_URL="'$(BETA_URL)'" btest: @echo "[$(TAG)]($(BETA_URL)) on branch [$(BRANCH)](https://github.com/rclone/rclone/tree/$(BRANCH)) (uploaded in 15-30 mins)" | xclip -r -sel clip @echo "Copied markdown of beta release to clip board" btesth: @echo "$(TAG) on branch $(BRANCH) (uploaded in 15-30 mins)" | xclip -r -sel clip -t text/html @echo "Copied beta release in HTML to clip board" version: @echo '$(TAG)' # Full suite of integration tests test: rclone test_all -test_all 2>&1 | tee test_all.log @echo "Written logs in test_all.log" # Quick test quicktest: RCLONE_CONFIG="/notfound" go test $(LDFLAGS) $(BUILDTAGS) ./... racequicktest: RCLONE_CONFIG="/notfound" go test $(LDFLAGS) $(BUILDTAGS) -cpu=2 -race ./... compiletest: RCLONE_CONFIG="/notfound" go test $(LDFLAGS) $(BUILDTAGS) -run XXX ./... # Do source code quality checks check: rclone @echo "-- START CODE QUALITY REPORT -------------------------------" @golangci-lint run $(LINTTAGS) ./... @echo "-- END CODE QUALITY REPORT ---------------------------------" # Get the build dependencies build_dep: go run bin/get-github-release.go -use-api -extract golangci-lint golangci/golangci-lint 'golangci-lint-.*\.tar\.gz' # Get the release dependencies we only install on linux release_dep_linux: go install github.com/goreleaser/nfpm/v2/cmd/nfpm@latest # Update dependencies showupdates: @echo "*** Direct dependencies that could be updated ***" @GO111MODULE=on go list -u -f '{{if (and (not (or .Main .Indirect)) .Update)}}{{.Path}}: {{.Version}} -> {{.Update.Version}}{{end}}' -m all 2> /dev/null # Update direct dependencies only updatedirect: GO111MODULE=on go get -d $$(go list -m -f '{{if not (or .Main .Indirect)}}{{.Path}}{{end}}' all) GO111MODULE=on go mod tidy # Update direct and indirect dependencies and test dependencies update: GO111MODULE=on go get -d -u -t ./... GO111MODULE=on go mod tidy # Tidy the module dependencies tidy: GO111MODULE=on go mod tidy doc: rclone.1 MANUAL.html MANUAL.txt rcdocs commanddocs rclone.1: MANUAL.md pandoc -s --from markdown-smart --to man MANUAL.md -o rclone.1 MANUAL.md: bin/make_manual.py docs/content/*.md commanddocs backenddocs rcdocs ./bin/make_manual.py MANUAL.html: MANUAL.md pandoc -s --from markdown-smart --to html MANUAL.md -o MANUAL.html MANUAL.txt: MANUAL.md pandoc -s --from markdown-smart --to plain MANUAL.md -o MANUAL.txt commanddocs: rclone -@rmdir -p '$$HOME/.config/rclone' XDG_CACHE_HOME="" XDG_CONFIG_HOME="" HOME="\$$HOME" USER="\$$USER" rclone gendocs --config=/notfound docs/content/ @[ ! -e '$$HOME' ] || (echo 'Error: created unwanted directory named $$HOME' && exit 1) backenddocs: rclone bin/make_backend_docs.py -@rmdir -p '$$HOME/.config/rclone' XDG_CACHE_HOME="" XDG_CONFIG_HOME="" HOME="\$$HOME" USER="\$$USER" ./bin/make_backend_docs.py @[ ! -e '$$HOME' ] || (echo 'Error: created unwanted directory named $$HOME' && exit 1) rcdocs: rclone bin/make_rc_docs.sh install: rclone install -d ${DESTDIR}/usr/bin install ${GOPATH}/bin/rclone ${DESTDIR}/usr/bin clean: go clean ./... find . -name \*~ | xargs -r rm -f rm -rf build docs/public rm -f rclone fs/operations/operations.test fs/sync/sync.test fs/test_all.log test.log website: rm -rf docs/public cd docs && hugo @if grep -R "raw HTML omitted" docs/public ; then echo "ERROR: found unescaped HTML - fix the markdown source" ; fi upload_website: website rclone -v sync docs/public www.rclone.org: upload_test_website: website rclone -P sync docs/public test-rclone-org: validate_website: website find docs/public -type f -name "*.html" | xargs tidy --mute-id yes -errors --gnu-emacs yes --drop-empty-elements no --warn-proprietary-attributes no --mute MISMATCHED_ATTRIBUTE_WARN tarball: git archive -9 --format=tar.gz --prefix=rclone-$(TAG)/ -o build/rclone-$(TAG).tar.gz $(TAG) vendorball: go mod vendor tar -zcf build/rclone-$(TAG)-vendor.tar.gz vendor rm -rf vendor sign_upload: cd build && md5sum rclone-v* | gpg --clearsign > MD5SUMS cd build && sha1sum rclone-v* | gpg --clearsign > SHA1SUMS cd build && sha256sum rclone-v* | gpg --clearsign > SHA256SUMS check_sign: cd build && gpg --verify MD5SUMS && gpg --decrypt MD5SUMS | md5sum -c cd build && gpg --verify SHA1SUMS && gpg --decrypt SHA1SUMS | sha1sum -c cd build && gpg --verify SHA256SUMS && gpg --decrypt SHA256SUMS | sha256sum -c upload: rclone -P copy build/ downloads.rclone.org:/$(TAG) rclone lsf build --files-only --include '*.{zip,deb,rpm}' --include version.txt | xargs -i bash -c 'i={}; j="$$i"; [[ $$i =~ (.*)(-v[0-9\.]+-)(.*) ]] && j=$${BASH_REMATCH[1]}-current-$${BASH_REMATCH[3]}; rclone copyto -v "downloads.rclone.org:/$(TAG)/$$i" "downloads.rclone.org:/$$j"' upload_github: ./bin/upload-github $(TAG) cross: doc go run bin/cross-compile.go -release current $(BUILD_FLAGS) $(BUILDTAGS) $(BUILD_ARGS) $(TAG) beta: go run bin/cross-compile.go $(BUILD_FLAGS) $(BUILDTAGS) $(BUILD_ARGS) $(TAG) rclone -v copy build/ pub.rclone.org:/$(TAG) @echo Beta release ready at https://pub.rclone.org/$(TAG)/ log_since_last_release: git log $(LAST_TAG).. compile_all: go run bin/cross-compile.go -compile-only $(BUILD_FLAGS) $(BUILDTAGS) $(BUILD_ARGS) $(TAG) ci_upload: sudo chown -R $$USER build find build -type l -delete gzip -r9v build ./rclone --no-check-dest --config bin/ci.rclone.conf -v copy build/ $(BETA_UPLOAD)/testbuilds ifeq ($(or $(BRANCH_PATH),$(RELEASE_TAG)),) ./rclone --no-check-dest --config bin/ci.rclone.conf -v copy build/ $(BETA_UPLOAD_ROOT)/test/testbuilds-latest endif @echo Beta release ready at $(BETA_URL)/testbuilds ci_beta: git log $(LAST_TAG).. > /tmp/git-log.txt go run bin/cross-compile.go -release beta-latest -git-log /tmp/git-log.txt $(BUILD_FLAGS) $(BUILDTAGS) $(BUILD_ARGS) $(TAG) rclone --no-check-dest --config bin/ci.rclone.conf -v copy --exclude '*beta-latest*' build/ $(BETA_UPLOAD) ifeq ($(or $(BRANCH_PATH),$(RELEASE_TAG)),) rclone --no-check-dest --config bin/ci.rclone.conf -v copy --include '*beta-latest*' --include version.txt build/ $(BETA_UPLOAD_ROOT)$(BETA_SUBDIR) endif @echo Beta release ready at $(BETA_URL) # Fetch the binary builds from GitHub actions fetch_binaries: rclone -P sync --exclude "/testbuilds/**" --delete-excluded $(BETA_UPLOAD) build/ serve: website cd docs && hugo server --logLevel info -w --disableFastRender --ignoreCache tag: retag doc bin/make_changelog.py $(LAST_TAG) $(VERSION) > docs/content/changelog.md.new mv docs/content/changelog.md.new docs/content/changelog.md @echo "Edit the new changelog in docs/content/changelog.md" @echo "Then commit all the changes" @echo git commit -m \"Version $(VERSION)\" -a -v @echo "And finally run make retag before make cross, etc." retag: @echo "Version is $(VERSION)" git tag -f -s -m "Version $(VERSION)" $(VERSION) startdev: @echo "Version is $(VERSION)" @echo "Next version is $(NEXT_VERSION)" echo -e "package fs\n\n// VersionTag of rclone\nvar VersionTag = \"$(NEXT_VERSION)\"\n" | gofmt > fs/versiontag.go echo -n "$(NEXT_VERSION)" > docs/layouts/partials/version.html echo "$(NEXT_VERSION)" > VERSION git commit -m "Start $(NEXT_VERSION)-DEV development" fs/versiontag.go VERSION docs/layouts/partials/version.html startstable: @echo "Version is $(VERSION)" @echo "Next stable version is $(NEXT_PATCH_VERSION)" echo -e "package fs\n\n// VersionTag of rclone\nvar VersionTag = \"$(NEXT_PATCH_VERSION)\"\n" | gofmt > fs/versiontag.go echo -n "$(NEXT_PATCH_VERSION)" > docs/layouts/partials/version.html echo "$(NEXT_PATCH_VERSION)" > VERSION git commit -m "Start $(NEXT_PATCH_VERSION)-DEV development" fs/versiontag.go VERSION docs/layouts/partials/version.html winzip: zip -9 rclone-$(TAG).zip rclone.exe # docker volume plugin PLUGIN_USER ?= rclone PLUGIN_TAG ?= latest PLUGIN_BASE_TAG ?= latest PLUGIN_ARCH ?= amd64 PLUGIN_IMAGE := $(PLUGIN_USER)/docker-volume-rclone:$(PLUGIN_TAG) PLUGIN_BASE := $(PLUGIN_USER)/rclone:$(PLUGIN_BASE_TAG) PLUGIN_BUILD_DIR := ./build/docker-plugin PLUGIN_CONTRIB_DIR := ./contrib/docker-plugin/managed docker-plugin-create: docker buildx inspect |grep -q /${PLUGIN_ARCH} || \ docker run --rm --privileged tonistiigi/binfmt --install all rm -rf ${PLUGIN_BUILD_DIR} docker buildx build \ --no-cache --pull \ --build-arg BASE_IMAGE=${PLUGIN_BASE} \ --platform linux/${PLUGIN_ARCH} \ --output ${PLUGIN_BUILD_DIR}/rootfs \ ${PLUGIN_CONTRIB_DIR} cp ${PLUGIN_CONTRIB_DIR}/config.json ${PLUGIN_BUILD_DIR} docker plugin rm --force ${PLUGIN_IMAGE} 2>/dev/null || true docker plugin create ${PLUGIN_IMAGE} ${PLUGIN_BUILD_DIR} docker-plugin-push: docker plugin push ${PLUGIN_IMAGE} docker plugin rm ${PLUGIN_IMAGE} docker-plugin: docker-plugin-create docker-plugin-push rclone-v1.71.0/README.md000066400000000000000000000237571505210326400145430ustar00rootroot00000000000000 [rclone logo](https://rclone.org/#gh-light-mode-only) [rclone logo](https://rclone.org/#gh-dark-mode-only) [Website](https://rclone.org) | [Documentation](https://rclone.org/docs/) | [Download](https://rclone.org/downloads/) | [Contributing](CONTRIBUTING.md) | [Changelog](https://rclone.org/changelog/) | [Installation](https://rclone.org/install/) | [Forum](https://forum.rclone.org/) [![Build Status](https://github.com/rclone/rclone/workflows/build/badge.svg)](https://github.com/rclone/rclone/actions?query=workflow%3Abuild) [![Go Report Card](https://goreportcard.com/badge/github.com/rclone/rclone)](https://goreportcard.com/report/github.com/rclone/rclone) [![GoDoc](https://godoc.org/github.com/rclone/rclone?status.svg)](https://godoc.org/github.com/rclone/rclone) [![Docker Pulls](https://img.shields.io/docker/pulls/rclone/rclone)](https://hub.docker.com/r/rclone/rclone) # Rclone 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/) Please see [the full list of all storage providers and their features](https://rclone.org/overview/) ### Virtual storage providers 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/) ## 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 ## 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 ## Downloads - ## License This is free software under the terms of the MIT license (check the [COPYING file](/COPYING) included in this package). rclone-v1.71.0/RELEASE.md000066400000000000000000000132141505210326400146510ustar00rootroot00000000000000# Release 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 ## 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 ## 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"` If the `make updatedirect` upgrades the version of go in the `go.mod` ```text go 1.22.0 ``` then go to manual mode. `go1.22` here is the lowest supported version in the `go.mod`. 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 ``` 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 ``` And try again. 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` Note that `make update` updates all direct and indirect dependencies and there can occasionally be forwards compatibility problems with doing that so it may be necessary to roll back dependencies to the version specified by `make updatedirect` in order to get rclone to build. Once it compiles locally, push it on a test branch and commit fixes until the tests pass. ### Major versions 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 ``` Expect API breakage when updating major versions. ## Tidy beta At some point after the release run ```sh bin/tidy-beta v1.55 ``` where the version number is that of a couple ago to remove old beta binaries. ## Making a point release 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 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 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 ## Sponsor logos 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 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 ``` 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 ``` Create the changes, check them in, test with `make serve` then ```sh make upload_test_website ``` Check out and when happy ```sh make upload_website ``` Cherry pick any changes back to master and the stable branch if it is active. ## Making a manual build of docker 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 . ``` 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 . ``` rclone-v1.71.0/VERSION000066400000000000000000000000101505210326400143050ustar00rootroot00000000000000v1.71.0 rclone-v1.71.0/backend/000077500000000000000000000000001505210326400146355ustar00rootroot00000000000000rclone-v1.71.0/backend/alias/000077500000000000000000000000001505210326400157265ustar00rootroot00000000000000rclone-v1.71.0/backend/alias/alias.go000066400000000000000000000027451505210326400173560ustar00rootroot00000000000000// Package alias implements a virtual provider to rename existing remotes. package alias import ( "context" "errors" "strings" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fspath" ) // Register with Fs func init() { fsi := &fs.RegInfo{ Name: "alias", Description: "Alias for an existing remote", NewFs: NewFs, Options: []fs.Option{{ Name: "remote", Help: "Remote or path to alias.\n\nCan be \"myremote:path/to/dir\", \"myremote:bucket\", \"myremote:\" or \"/local/path\".", Required: true, }}, } fs.Register(fsi) } // Options defines the configuration for this backend type Options struct { Remote string `config:"remote"` } // NewFs constructs an Fs from the path. // // The returned Fs is the actual Fs, referenced by remote in the config func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } if opt.Remote == "" { return nil, errors.New("alias can't point to an empty remote - check the value of the remote setting") } if strings.HasPrefix(opt.Remote, name+":") { return nil, errors.New("can't point alias remote at itself - check the value of the remote setting") } return cache.Get(ctx, fspath.JoinRootPath(opt.Remote, root)) } rclone-v1.71.0/backend/alias/alias_internal_test.go000066400000000000000000000052611505210326400223050ustar00rootroot00000000000000package alias import ( "context" "fmt" "path" "path/filepath" "sort" "testing" _ "github.com/rclone/rclone/backend/local" // pull in test backend "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configfile" "github.com/stretchr/testify/require" ) var ( remoteName = "TestAlias" ) func prepare(t *testing.T, root string) { configfile.Install() // Configure the remote config.FileSetValue(remoteName, "type", "alias") config.FileSetValue(remoteName, "remote", root) } func TestNewFS(t *testing.T) { type testEntry struct { remote string size int64 isDir bool } for testi, test := range []struct { remoteRoot string fsRoot string fsList string wantOK bool entries []testEntry }{ {"", "", "", true, []testEntry{ {"four", -1, true}, {"one%.txt", 6, false}, {"three", -1, true}, {"two.html", 7, false}, }}, {"", "four", "", true, []testEntry{ {"five", -1, true}, {"under four.txt", 9, false}, }}, {"", "", "four", true, []testEntry{ {"four/five", -1, true}, {"four/under four.txt", 9, false}, }}, {"four", "..", "", true, []testEntry{ {"five", -1, true}, {"under four.txt", 9, false}, }}, {"", "../../three", "", true, []testEntry{ {"underthree.txt", 9, false}, }}, {"four", "../../five", "", true, []testEntry{ {"underfive.txt", 6, false}, }}, } { what := fmt.Sprintf("test %d remoteRoot=%q, fsRoot=%q, fsList=%q", testi, test.remoteRoot, test.fsRoot, test.fsList) remoteRoot, err := filepath.Abs(filepath.FromSlash(path.Join("test/files", test.remoteRoot))) require.NoError(t, err, what) prepare(t, remoteRoot) f, err := fs.NewFs(context.Background(), fmt.Sprintf("%s:%s", remoteName, test.fsRoot)) require.NoError(t, err, what) gotEntries, err := f.List(context.Background(), test.fsList) require.NoError(t, err, what) sort.Sort(gotEntries) require.Equal(t, len(test.entries), len(gotEntries), what) for i, gotEntry := range gotEntries { what := fmt.Sprintf("%s, entry=%d", what, i) wantEntry := test.entries[i] _, isDir := gotEntry.(fs.Directory) require.Equal(t, wantEntry.remote, gotEntry.Remote(), what) if !isDir { require.Equal(t, wantEntry.size, gotEntry.Size(), what) } require.Equal(t, wantEntry.isDir, isDir, what) } } } func TestNewFSNoRemote(t *testing.T) { prepare(t, "") f, err := fs.NewFs(context.Background(), fmt.Sprintf("%s:", remoteName)) require.Error(t, err) require.Nil(t, f) } func TestNewFSInvalidRemote(t *testing.T) { prepare(t, "not_existing_test_remote:") f, err := fs.NewFs(context.Background(), fmt.Sprintf("%s:", remoteName)) require.Error(t, err) require.Nil(t, f) } rclone-v1.71.0/backend/alias/test/000077500000000000000000000000001505210326400167055ustar00rootroot00000000000000rclone-v1.71.0/backend/alias/test/files/000077500000000000000000000000001505210326400200075ustar00rootroot00000000000000rclone-v1.71.0/backend/alias/test/files/four/000077500000000000000000000000001505210326400207625ustar00rootroot00000000000000rclone-v1.71.0/backend/alias/test/files/four/five/000077500000000000000000000000001505210326400217135ustar00rootroot00000000000000rclone-v1.71.0/backend/alias/test/files/four/five/underfive.txt000066400000000000000000000000061505210326400244370ustar00rootroot00000000000000apple rclone-v1.71.0/backend/alias/test/files/four/under four.txt000066400000000000000000000000111505210326400235640ustar00rootroot00000000000000beetroot rclone-v1.71.0/backend/alias/test/files/one%.txt000066400000000000000000000000061505210326400213720ustar00rootroot00000000000000hello rclone-v1.71.0/backend/alias/test/files/three/000077500000000000000000000000001505210326400211165ustar00rootroot00000000000000rclone-v1.71.0/backend/alias/test/files/three/underthree.txt000066400000000000000000000000111505210326400240140ustar00rootroot00000000000000rutabaga rclone-v1.71.0/backend/alias/test/files/two.html000066400000000000000000000000071505210326400215030ustar00rootroot00000000000000potato rclone-v1.71.0/backend/all/000077500000000000000000000000001505210326400154055ustar00rootroot00000000000000rclone-v1.71.0/backend/all/all.go000066400000000000000000000056571505210326400165210ustar00rootroot00000000000000// Package all imports all the backends package all import ( // Active file systems _ "github.com/rclone/rclone/backend/alias" _ "github.com/rclone/rclone/backend/azureblob" _ "github.com/rclone/rclone/backend/azurefiles" _ "github.com/rclone/rclone/backend/b2" _ "github.com/rclone/rclone/backend/box" _ "github.com/rclone/rclone/backend/cache" _ "github.com/rclone/rclone/backend/chunker" _ "github.com/rclone/rclone/backend/cloudinary" _ "github.com/rclone/rclone/backend/combine" _ "github.com/rclone/rclone/backend/compress" _ "github.com/rclone/rclone/backend/crypt" _ "github.com/rclone/rclone/backend/doi" _ "github.com/rclone/rclone/backend/drive" _ "github.com/rclone/rclone/backend/dropbox" _ "github.com/rclone/rclone/backend/fichier" _ "github.com/rclone/rclone/backend/filefabric" _ "github.com/rclone/rclone/backend/filelu" _ "github.com/rclone/rclone/backend/filescom" _ "github.com/rclone/rclone/backend/ftp" _ "github.com/rclone/rclone/backend/gofile" _ "github.com/rclone/rclone/backend/googlecloudstorage" _ "github.com/rclone/rclone/backend/googlephotos" _ "github.com/rclone/rclone/backend/hasher" _ "github.com/rclone/rclone/backend/hdfs" _ "github.com/rclone/rclone/backend/hidrive" _ "github.com/rclone/rclone/backend/http" _ "github.com/rclone/rclone/backend/iclouddrive" _ "github.com/rclone/rclone/backend/imagekit" _ "github.com/rclone/rclone/backend/internetarchive" _ "github.com/rclone/rclone/backend/jottacloud" _ "github.com/rclone/rclone/backend/koofr" _ "github.com/rclone/rclone/backend/linkbox" _ "github.com/rclone/rclone/backend/local" _ "github.com/rclone/rclone/backend/mailru" _ "github.com/rclone/rclone/backend/mega" _ "github.com/rclone/rclone/backend/memory" _ "github.com/rclone/rclone/backend/netstorage" _ "github.com/rclone/rclone/backend/onedrive" _ "github.com/rclone/rclone/backend/opendrive" _ "github.com/rclone/rclone/backend/oracleobjectstorage" _ "github.com/rclone/rclone/backend/pcloud" _ "github.com/rclone/rclone/backend/pikpak" _ "github.com/rclone/rclone/backend/pixeldrain" _ "github.com/rclone/rclone/backend/premiumizeme" _ "github.com/rclone/rclone/backend/protondrive" _ "github.com/rclone/rclone/backend/putio" _ "github.com/rclone/rclone/backend/qingstor" _ "github.com/rclone/rclone/backend/quatrix" _ "github.com/rclone/rclone/backend/s3" _ "github.com/rclone/rclone/backend/seafile" _ "github.com/rclone/rclone/backend/sftp" _ "github.com/rclone/rclone/backend/sharefile" _ "github.com/rclone/rclone/backend/sia" _ "github.com/rclone/rclone/backend/smb" _ "github.com/rclone/rclone/backend/storj" _ "github.com/rclone/rclone/backend/sugarsync" _ "github.com/rclone/rclone/backend/swift" _ "github.com/rclone/rclone/backend/ulozto" _ "github.com/rclone/rclone/backend/union" _ "github.com/rclone/rclone/backend/uptobox" _ "github.com/rclone/rclone/backend/webdav" _ "github.com/rclone/rclone/backend/yandex" _ "github.com/rclone/rclone/backend/zoho" ) rclone-v1.71.0/backend/azureblob/000077500000000000000000000000001505210326400166225ustar00rootroot00000000000000rclone-v1.71.0/backend/azureblob/azureblob.go000066400000000000000000003105171505210326400211450ustar00rootroot00000000000000//go:build !plan9 && !solaris && !js // Package azureblob provides an interface to the Microsoft Azure blob object storage system package azureblob import ( "bytes" "context" "crypto/md5" "crypto/rand" "encoding/base64" "encoding/binary" "encoding/hex" "encoding/json" "errors" "fmt" "io" "net/http" "net/url" "os" "path" "slices" "sort" "strconv" "strings" "sync" "time" "github.com/Azure/azure-sdk-for-go/sdk/azcore" "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" "github.com/Azure/azure-sdk-for-go/sdk/azidentity" "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/blob" "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/bloberror" "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/blockblob" "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/container" "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/sas" "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/service" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/chunksize" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/lib/atexit" "github.com/rclone/rclone/lib/bucket" "github.com/rclone/rclone/lib/encoder" "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" ) const ( minSleep = 10 * time.Millisecond maxSleep = 10 * time.Second decayConstant = 1 // bigger for slower decay, exponential maxListChunkSize = 5000 // number of items to read at once modTimeKey = "mtime" dirMetaKey = "hdi_isfolder" dirMetaValue = "true" timeFormatIn = time.RFC3339 timeFormatOut = "2006-01-02T15:04:05.000000000Z07:00" storageDefaultBaseURL = "blob.core.windows.net" defaultChunkSize = 4 * fs.Mebi defaultAccessTier = blob.AccessTier("") // FIXME AccessTierNone // Default storage account, key and blob endpoint for emulator support, // though it is a base64 key checked in here, it is publicly available secret. emulatorAccount = "devstoreaccount1" emulatorAccountKey = "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==" emulatorBlobEndpoint = "http://127.0.0.1:10000/devstoreaccount1" sasCopyValidity = time.Hour // how long SAS should last when doing server side copy ) var ( errCantUpdateArchiveTierBlobs = fserrors.NoRetryError(errors.New("can't update archive tier blob without --azureblob-archive-tier-delete")) // Take this when changing or reading metadata. // // It acts as global metadata lock so we don't bloat Object // with an extra lock that will only very rarely be contended. metadataMu sync.Mutex ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "azureblob", Description: "Microsoft Azure Blob Storage", NewFs: NewFs, Options: []fs.Option{{ Name: "account", Help: `Azure Storage Account Name. Set this to the Azure Storage Account Name in use. Leave blank to use SAS URL or Emulator, otherwise it needs to be set. If this is blank and if env_auth is set it will be read from the environment variable ` + "`AZURE_STORAGE_ACCOUNT_NAME`" + ` if possible. `, Sensitive: true, }, { Name: "env_auth", Help: `Read credentials from runtime (environment variables, CLI or MSI). See the [authentication docs](/azureblob#authentication) for full info.`, Default: false, }, { Name: "key", Help: `Storage Account Shared Key. Leave blank to use SAS URL or Emulator.`, Sensitive: true, }, { Name: "sas_url", Help: `SAS URL for container level access only. Leave blank if using account/key or Emulator.`, Sensitive: true, }, { Name: "tenant", Help: `ID of the service principal's tenant. Also called its directory ID. Set this if using - Service principal with client secret - Service principal with certificate - User with username and password `, Sensitive: true, }, { Name: "client_id", Help: `The ID of the client in use. Set this if using - Service principal with client secret - Service principal with certificate - User with username and password `, Sensitive: true, }, { Name: "client_secret", Help: `One of the service principal's client secrets Set this if using - Service principal with client secret `, Sensitive: true, }, { Name: "client_certificate_path", Help: `Path to a PEM or PKCS12 certificate file including the private key. Set this if using - Service principal with certificate `, }, { Name: "client_certificate_password", Help: `Password for the certificate file (optional). Optionally set this if using - Service principal with certificate And the certificate has a password. `, IsPassword: true, }, { Name: "client_send_certificate_chain", Help: `Send the certificate chain when using certificate auth. Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to true, authentication requests include the x5c header. Optionally set this if using - Service principal with certificate `, Default: false, Advanced: true, }, { Name: "username", Help: `User name (usually an email address) Set this if using - User with username and password `, Advanced: true, Sensitive: true, }, { Name: "password", Help: `The user's password Set this if using - User with username and password `, IsPassword: true, Advanced: true, }, { Name: "service_principal_file", Help: `Path to file containing credentials for use with a service principal. Leave blank normally. Needed only if you want to use a service principal instead of interactive login. $ az ad sp create-for-rbac --name "" \ --role "Storage Blob Data Owner" \ --scopes "/subscriptions//resourceGroups//providers/Microsoft.Storage/storageAccounts//blobServices/default/containers/" \ > azure-principal.json See ["Create an Azure service principal"](https://docs.microsoft.com/en-us/cli/azure/create-an-azure-service-principal-azure-cli) and ["Assign an Azure role for access to blob data"](https://docs.microsoft.com/en-us/azure/storage/common/storage-auth-aad-rbac-cli) pages for more details. It may be more convenient to put the credentials directly into the rclone config file under the ` + "`client_id`, `tenant` and `client_secret`" + ` keys instead of setting ` + "`service_principal_file`" + `. `, Advanced: true, }, { Name: "disable_instance_discovery", Help: `Skip requesting Microsoft Entra instance metadata This should be set true only by applications authenticating in disconnected clouds, or private clouds such as Azure Stack. It determines whether rclone requests Microsoft Entra instance metadata from ` + "`https://login.microsoft.com/`" + ` before authenticating. Setting this to true will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy. `, Default: false, Advanced: true, }, { Name: "use_msi", Help: `Use a managed service identity to authenticate (only works in Azure). When true, use a [managed service identity](https://docs.microsoft.com/en-us/azure/active-directory/managed-identities-azure-resources/) to authenticate to Azure Storage instead of a SAS token or account key. If the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default. If the resource has multiple user-assigned identities, the identity to use must be explicitly specified using exactly one of the msi_object_id, msi_client_id, or msi_mi_res_id parameters.`, Default: false, Advanced: true, }, { Name: "msi_object_id", Help: "Object ID of the user-assigned MSI to use, if any.\n\nLeave blank if msi_client_id or msi_mi_res_id specified.", Advanced: true, Sensitive: true, }, { Name: "msi_client_id", Help: "Object ID of the user-assigned MSI to use, if any.\n\nLeave blank if msi_object_id or msi_mi_res_id specified.", Advanced: true, Sensitive: true, }, { Name: "msi_mi_res_id", Help: "Azure resource ID of the user-assigned MSI to use, if any.\n\nLeave blank if msi_client_id or msi_object_id specified.", Advanced: true, Sensitive: true, }, { Name: "use_emulator", Help: "Uses local storage emulator if provided as 'true'.\n\nLeave blank if using real azure storage endpoint.", Default: false, Advanced: true, }, { Name: "use_az", Help: `Use Azure CLI tool az for authentication Set to use the [Azure CLI tool az](https://learn.microsoft.com/en-us/cli/azure/) as the sole means of authentication. Setting this can be useful if you wish to use the az CLI on a host with a System Managed Identity that you do not want to use. Don't set env_auth at the same time. `, Default: false, Advanced: true, }, { Name: "endpoint", Help: "Endpoint for the service.\n\nLeave blank normally.", Advanced: true, }, { Name: "upload_cutoff", Help: "Cutoff for switching to chunked upload (<= 256 MiB) (deprecated).", Advanced: true, }, { Name: "chunk_size", Help: `Upload chunk size. Note that this is stored in memory and there may be up to "--transfers" * "--azureblob-upload-concurrency" chunks stored at once in memory.`, Default: defaultChunkSize, Advanced: true, }, { Name: "upload_concurrency", Help: `Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. In tests, upload speed increases almost linearly with upload concurrency. For example to fill a gigabit pipe it may be necessary to raise this to 64. Note that this will use more memory. Note that chunks are stored in memory and there may be up to "--transfers" * "--azureblob-upload-concurrency" chunks stored at once in memory.`, Default: 16, Advanced: true, }, { Name: "copy_cutoff", Help: `Cutoff for switching to multipart copy. Any files larger than this that need to be server-side copied will be copied in chunks of chunk_size using the put block list API. Files smaller than this limit will be copied with the Copy Blob API.`, Default: 8 * fs.Mebi, Advanced: true, }, { Name: "copy_concurrency", Help: `Concurrency for multipart copy. This is the number of chunks of the same file that are copied concurrently. These chunks are not buffered in memory and Microsoft recommends setting this value to greater than 1000 in the azcopy documentation. https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azcopy-optimize#increase-concurrency In tests, copy speed increases almost linearly with copy concurrency.`, Default: 512, Advanced: true, }, { Name: "use_copy_blob", Help: `Whether to use the Copy Blob API when copying to the same storage account. If true (the default) then rclone will use the Copy Blob API for copies to the same storage account even when the size is above the copy_cutoff. Rclone assumes that the same storage account means the same config and does not check for the same storage account in different configs. There should be no need to change this value. `, Default: true, Advanced: true, }, { Name: "list_chunk", Help: `Size of blob list. This sets the number of blobs requested in each listing chunk. Default is the maximum, 5000. "List blobs" requests are permitted 2 minutes per megabyte to complete. If an operation is taking longer than 2 minutes per megabyte on average, it will time out ( [source](https://docs.microsoft.com/en-us/rest/api/storageservices/setting-timeouts-for-blob-service-operations#exceptions-to-default-timeout-interval) ). This can be used to limit the number of blobs items to return, to avoid the time out.`, Default: maxListChunkSize, Advanced: true, }, { Name: "access_tier", Help: `Access tier of blob: hot, cool, cold or archive. Archived blobs can be restored by setting access tier to hot, cool or cold. Leave blank if you intend to use default access tier, which is set at account level If there is no "access tier" specified, rclone doesn't apply any tier. rclone performs "Set Tier" operation on blobs while uploading, if objects are not modified, specifying "access tier" to new one will have no effect. If blobs are in "archive tier" at remote, trying to perform data transfer operations from remote will not be allowed. User should first restore by tiering blob to "Hot", "Cool" or "Cold".`, Advanced: true, }, { Name: "archive_tier_delete", Default: false, Help: fmt.Sprintf(`Delete archive tier blobs before overwriting. Archive tier blobs cannot be updated. So without this flag, if you attempt to update an archive tier blob, then rclone will produce the error: %v With this flag set then before rclone attempts to overwrite an archive tier blob, it will delete the existing blob before uploading its replacement. This has the potential for data loss if the upload fails (unlike updating a normal blob) and also may cost more since deleting archive tier blobs early may be chargable. `, errCantUpdateArchiveTierBlobs), Advanced: true, }, { Name: "disable_checksum", Help: `Don't store MD5 checksum with object metadata. Normally rclone will calculate the MD5 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading.`, Default: false, Advanced: true, }, { Name: "memory_pool_flush_time", Default: fs.Duration(time.Minute), Advanced: true, Hide: fs.OptionHideBoth, Help: `How often internal memory buffer pools will be flushed. (no longer used)`, }, { Name: "memory_pool_use_mmap", Default: false, Advanced: true, Hide: fs.OptionHideBoth, Help: `Whether to use mmap buffers in internal memory pool. (no longer used)`, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: (encoder.EncodeInvalidUtf8 | encoder.EncodeSlash | encoder.EncodeCtl | encoder.EncodeDel | encoder.EncodeBackSlash | encoder.EncodeRightPeriod), }, { Name: "public_access", Help: "Public access level of a container: blob or container.", Default: "", Examples: []fs.OptionExample{ { Value: "", Help: "The container and its blobs can be accessed only with an authorized request.\nIt's a default value.", }, { Value: string(container.PublicAccessTypeBlob), Help: "Blob data within this container can be read via anonymous request.", }, { Value: string(container.PublicAccessTypeContainer), Help: "Allow full public read access for container and blob data.", }, }, Advanced: true, }, { Name: "directory_markers", Default: false, Advanced: true, Help: `Upload an empty object with a trailing slash when a new directory is created Empty folders are unsupported for bucket based remotes, this option creates an empty object ending with "/", to persist the folder. This object also has the metadata "` + dirMetaKey + ` = ` + dirMetaValue + `" to conform to the Microsoft standard. `, }, { Name: "no_check_container", Help: `If set, don't attempt to check the container exists or create it. This can be useful when trying to minimise the number of transactions rclone does if you know the container exists already. `, Default: false, Advanced: true, }, { Name: "no_head_object", Help: `If set, do not do HEAD before GET when getting objects.`, Default: false, Advanced: true, }, { Name: "delete_snapshots", Help: `Set to specify how to deal with snapshots on blob deletion.`, Examples: []fs.OptionExample{ { Value: "", Help: "By default, the delete operation fails if a blob has snapshots", }, { Value: string(blob.DeleteSnapshotsOptionTypeInclude), Help: "Specify 'include' to remove the root blob and all its snapshots", }, { Value: string(blob.DeleteSnapshotsOptionTypeOnly), Help: "Specify 'only' to remove only the snapshots but keep the root blob.", }, }, Default: "", Exclusive: true, Advanced: true, }}, }) } // Options defines the configuration for this backend type Options struct { Account string `config:"account"` EnvAuth bool `config:"env_auth"` Key string `config:"key"` SASURL string `config:"sas_url"` Tenant string `config:"tenant"` ClientID string `config:"client_id"` ClientSecret string `config:"client_secret"` ClientCertificatePath string `config:"client_certificate_path"` ClientCertificatePassword string `config:"client_certificate_password"` ClientSendCertificateChain bool `config:"client_send_certificate_chain"` Username string `config:"username"` Password string `config:"password"` ServicePrincipalFile string `config:"service_principal_file"` DisableInstanceDiscovery bool `config:"disable_instance_discovery"` UseMSI bool `config:"use_msi"` MSIObjectID string `config:"msi_object_id"` MSIClientID string `config:"msi_client_id"` MSIResourceID string `config:"msi_mi_res_id"` UseAZ bool `config:"use_az"` Endpoint string `config:"endpoint"` ChunkSize fs.SizeSuffix `config:"chunk_size"` CopyCutoff fs.SizeSuffix `config:"copy_cutoff"` CopyConcurrency int `config:"copy_concurrency"` UseCopyBlob bool `config:"use_copy_blob"` UploadConcurrency int `config:"upload_concurrency"` ListChunkSize uint `config:"list_chunk"` AccessTier string `config:"access_tier"` ArchiveTierDelete bool `config:"archive_tier_delete"` UseEmulator bool `config:"use_emulator"` DisableCheckSum bool `config:"disable_checksum"` Enc encoder.MultiEncoder `config:"encoding"` PublicAccess string `config:"public_access"` DirectoryMarkers bool `config:"directory_markers"` NoCheckContainer bool `config:"no_check_container"` NoHeadObject bool `config:"no_head_object"` DeleteSnapshots string `config:"delete_snapshots"` } // Fs represents a remote azure server type Fs struct { name string // name of this remote root string // the path we are working on if any opt Options // parsed config options ci *fs.ConfigInfo // global config features *fs.Features // optional features cntSVCcacheMu sync.Mutex // mutex to protect cntSVCcache cntSVCcache map[string]*container.Client // reference to containerClient per container svc *service.Client // client to access azblob cred azcore.TokenCredential // how to generate tokens (may be nil) sharedKeyCred *service.SharedKeyCredential // shared key credentials (may be nil) anonymous bool // if this is anonymous access rootContainer string // container part of root (if any) rootDirectory string // directory part of root (if any) isLimited bool // if limited to one container cache *bucket.Cache // cache for container creation status pacer *fs.Pacer // To pace and retry the API calls uploadToken *pacer.TokenDispenser // control concurrency publicAccess container.PublicAccessType // Container Public Access Level // user delegation cache userDelegationMu sync.Mutex userDelegation *service.UserDelegationCredential userDelegationExpiry time.Time } // Object describes an azure object type Object struct { fs *Fs // what this object is part of remote string // The remote path modTime time.Time // The modified time of the object if known md5 string // MD5 hash if known size int64 // Size of the object mimeType string // Content-Type of the object accessTier blob.AccessTier // Blob Access Tier meta map[string]string // blob metadata - take metadataMu when accessing tags map[string]string // blob tags } // ------------------------------------------------------------ // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { if f.rootContainer == "" { return "Azure root" } if f.rootDirectory == "" { return fmt.Sprintf("Azure container %s", f.rootContainer) } return fmt.Sprintf("Azure container %s path %s", f.rootContainer, f.rootDirectory) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // parsePath parses a remote 'url' func parsePath(path string) (root string) { root = strings.Trim(path, "/") return } // split returns container and containerPath from the rootRelativePath // relative to f.root func (f *Fs) split(rootRelativePath string) (containerName, containerPath string) { containerName, containerPath = bucket.Split(bucket.Join(f.root, rootRelativePath)) if f.opt.DirectoryMarkers && strings.HasSuffix(containerPath, "//") { containerPath = containerPath[:len(containerPath)-1] } return f.opt.Enc.FromStandardName(containerName), f.opt.Enc.FromStandardPath(containerPath) } // split returns container and containerPath from the object func (o *Object) split() (container, containerPath string) { return o.fs.split(o.remote) } // validateAccessTier checks if azureblob supports user supplied tier func validateAccessTier(tier string) bool { return strings.EqualFold(tier, string(blob.AccessTierHot)) || strings.EqualFold(tier, string(blob.AccessTierCool)) || strings.EqualFold(tier, string(blob.AccessTierCold)) || strings.EqualFold(tier, string(blob.AccessTierArchive)) } // validatePublicAccess checks if azureblob supports use supplied public access level func validatePublicAccess(publicAccess string) bool { switch publicAccess { case "", string(container.PublicAccessTypeBlob), string(container.PublicAccessTypeContainer): // valid cases return true default: return false } } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 401, // Unauthorized (e.g. "Token has expired") 408, // Request Timeout 429, // Rate exceeded. 500, // Get occasional 500 Internal Server Error 503, // Service Unavailable 504, // Gateway Time-out } // shouldRetry returns a boolean as to whether this resp and err // deserve to be retried. It returns the err as a convenience func (f *Fs) shouldRetry(ctx context.Context, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } var storageErr *azcore.ResponseError if errors.As(err, &storageErr) { // General errors from: // https://learn.microsoft.com/en-us/rest/api/storageservices/common-rest-api-error-codes // Blob specific errors from: // https://learn.microsoft.com/en-us/rest/api/storageservices/blob-service-error-codes switch storageErr.ErrorCode { case "InvalidBlobOrBlock": // These errors happen sometimes in multipart uploads // because of block concurrency issues return true, err case "InternalError": // The server encountered an internal error. Please retry the request. return true, err case "OperationTimedOut": // The operation could not be completed within the permitted time. The // operation may or may not have succeeded on the server side. Please query // the server state before retrying the operation. return true, err case "ServerBusy": // The server is currently unable to receive requests. Please retry your // request. return true, err } statusCode := storageErr.StatusCode if slices.Contains(retryErrorCodes, statusCode) { return true, err } } return fserrors.ShouldRetry(err), err } func checkUploadChunkSize(cs fs.SizeSuffix) error { const minChunkSize = fs.SizeSuffixBase if cs < minChunkSize { return fmt.Errorf("%s is less than %s", cs, minChunkSize) } return nil } func (f *Fs) setUploadChunkSize(cs fs.SizeSuffix) (old fs.SizeSuffix, err error) { err = checkUploadChunkSize(cs) if err == nil { old, f.opt.ChunkSize = f.opt.ChunkSize, cs } return } func (f *Fs) setCopyCutoff(cs fs.SizeSuffix) (old fs.SizeSuffix, err error) { err = checkUploadChunkSize(cs) if err == nil { old, f.opt.CopyCutoff = f.opt.CopyCutoff, cs } return } type servicePrincipalCredentials struct { AppID string `json:"appId"` Password string `json:"password"` Tenant string `json:"tenant"` } // parseServicePrincipalCredentials unmarshals a service principal credentials JSON file as generated by az cli. func parseServicePrincipalCredentials(ctx context.Context, credentialsData []byte) (*servicePrincipalCredentials, error) { var spCredentials servicePrincipalCredentials if err := json.Unmarshal(credentialsData, &spCredentials); err != nil { return nil, fmt.Errorf("error parsing credentials from JSON file: %w", err) } // TODO: support certificate credentials // Validate all fields present if spCredentials.AppID == "" || spCredentials.Password == "" || spCredentials.Tenant == "" { return nil, fmt.Errorf("missing fields in credentials file") } return &spCredentials, nil } // setRoot changes the root of the Fs func (f *Fs) setRoot(root string) { f.root = parsePath(root) f.rootContainer, f.rootDirectory = bucket.Split(f.root) } // Wrap the http.Transport to satisfy the Transporter interface type transporter struct { http.RoundTripper } // Make a new transporter func newTransporter(ctx context.Context) transporter { return transporter{ RoundTripper: fshttp.NewTransport(ctx), } } // Do sends the HTTP request and returns the HTTP response or error. func (tr transporter) Do(req *http.Request) (*http.Response, error) { return tr.RoundTripper.RoundTrip(req) } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } err = checkUploadChunkSize(opt.ChunkSize) if err != nil { return nil, fmt.Errorf("chunk size: %w", err) } if opt.ListChunkSize > maxListChunkSize { return nil, fmt.Errorf("blob list size can't be greater than %v - was %v", maxListChunkSize, opt.ListChunkSize) } if opt.AccessTier == "" { opt.AccessTier = string(defaultAccessTier) } else if !validateAccessTier(opt.AccessTier) { return nil, fmt.Errorf("supported access tiers are %s, %s, %s and %s", string(blob.AccessTierHot), string(blob.AccessTierCool), string(blob.AccessTierCold), string(blob.AccessTierArchive)) } if !validatePublicAccess((opt.PublicAccess)) { return nil, fmt.Errorf("supported public access level are %s and %s", string(container.PublicAccessTypeBlob), string(container.PublicAccessTypeContainer)) } ci := fs.GetConfig(ctx) f := &Fs{ name: name, opt: *opt, ci: ci, pacer: fs.NewPacer(ctx, pacer.NewS3(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), uploadToken: pacer.NewTokenDispenser(ci.Transfers), cache: bucket.NewCache(), cntSVCcache: make(map[string]*container.Client, 1), } f.publicAccess = container.PublicAccessType(opt.PublicAccess) f.setRoot(root) f.features = (&fs.Features{ ReadMimeType: true, WriteMimeType: true, BucketBased: true, BucketBasedRootOK: true, SetTier: true, GetTier: true, ServerSideAcrossConfigs: true, DoubleSlash: true, }).Fill(ctx, f) if opt.DirectoryMarkers { f.features.CanHaveEmptyDirectories = true fs.Debugf(f, "Using directory markers") } // Client options specifying our own transport policyClientOptions := policy.ClientOptions{ Transport: newTransporter(ctx), } clientOpt := service.ClientOptions{ ClientOptions: policyClientOptions, } // Here we auth by setting one of f.cred, f.sharedKeyCred, f.svc or f.anonymous switch { case opt.EnvAuth: // Read account from environment if needed if opt.Account == "" { opt.Account, _ = os.LookupEnv("AZURE_STORAGE_ACCOUNT_NAME") } // Read credentials from the environment options := azidentity.DefaultAzureCredentialOptions{ ClientOptions: policyClientOptions, DisableInstanceDiscovery: opt.DisableInstanceDiscovery, } f.cred, err = azidentity.NewDefaultAzureCredential(&options) if err != nil { return nil, fmt.Errorf("create azure environment credential failed: %w", err) } case opt.UseEmulator: if opt.Account == "" { opt.Account = emulatorAccount } if opt.Key == "" { opt.Key = emulatorAccountKey } if opt.Endpoint == "" { opt.Endpoint = emulatorBlobEndpoint } f.sharedKeyCred, err = service.NewSharedKeyCredential(opt.Account, opt.Key) if err != nil { return nil, fmt.Errorf("create new shared key credential for emulator failed: %w", err) } case opt.Account != "" && opt.Key != "": f.sharedKeyCred, err = service.NewSharedKeyCredential(opt.Account, opt.Key) if err != nil { return nil, fmt.Errorf("create new shared key credential failed: %w", err) } case opt.SASURL != "": parts, err := sas.ParseURL(opt.SASURL) if err != nil { return nil, fmt.Errorf("failed to parse SAS URL: %w", err) } endpoint := opt.SASURL containerName := parts.ContainerName // Check if we have container level SAS or account level SAS if containerName != "" { // Container level SAS if f.rootContainer != "" && containerName != f.rootContainer { return nil, fmt.Errorf("container name in SAS URL (%q) and container provided in command (%q) do not match", containerName, f.rootContainer) } // Rewrite the endpoint string to be without the container parts.ContainerName = "" endpoint = parts.String() } f.svc, err = service.NewClientWithNoCredential(endpoint, &clientOpt) if err != nil { return nil, fmt.Errorf("unable to create SAS URL client: %w", err) } // if using Container level SAS put the container client into the cache if containerName != "" { _ = f.cntSVC(containerName) f.isLimited = true } case opt.ClientID != "" && opt.Tenant != "" && opt.ClientSecret != "": // Service principal with client secret options := azidentity.ClientSecretCredentialOptions{ ClientOptions: policyClientOptions, } f.cred, err = azidentity.NewClientSecretCredential(opt.Tenant, opt.ClientID, opt.ClientSecret, &options) if err != nil { return nil, fmt.Errorf("error creating a client secret credential: %w", err) } case opt.ClientID != "" && opt.Tenant != "" && opt.ClientCertificatePath != "": // Service principal with certificate // // Read the certificate data, err := os.ReadFile(env.ShellExpand(opt.ClientCertificatePath)) if err != nil { return nil, fmt.Errorf("error reading client certificate file: %w", err) } // NewClientCertificateCredential requires at least one *x509.Certificate, and a // crypto.PrivateKey. // // ParseCertificates returns these given certificate data in PEM or PKCS12 format. // It handles common scenarios but has limitations, for example it doesn't load PEM // encrypted private keys. var password []byte if opt.ClientCertificatePassword != "" { pw, err := obscure.Reveal(opt.Password) if err != nil { return nil, fmt.Errorf("certificate password decode failed - did you obscure it?: %w", err) } password = []byte(pw) } certs, key, err := azidentity.ParseCertificates(data, password) if err != nil { return nil, fmt.Errorf("failed to parse client certificate file: %w", err) } options := azidentity.ClientCertificateCredentialOptions{ ClientOptions: policyClientOptions, SendCertificateChain: opt.ClientSendCertificateChain, } f.cred, err = azidentity.NewClientCertificateCredential( opt.Tenant, opt.ClientID, certs, key, &options, ) if err != nil { return nil, fmt.Errorf("create azure service principal with client certificate credential failed: %w", err) } case opt.ClientID != "" && opt.Tenant != "" && opt.Username != "" && opt.Password != "": // User with username and password //nolint:staticcheck // this is deprecated due to Azure policy options := azidentity.UsernamePasswordCredentialOptions{ ClientOptions: policyClientOptions, } password, err := obscure.Reveal(opt.Password) if err != nil { return nil, fmt.Errorf("user password decode failed - did you obscure it?: %w", err) } f.cred, err = azidentity.NewUsernamePasswordCredential( opt.Tenant, opt.ClientID, opt.Username, password, &options, ) if err != nil { return nil, fmt.Errorf("authenticate user with password failed: %w", err) } case opt.ServicePrincipalFile != "": // Loading service principal credentials from file. loadedCreds, err := os.ReadFile(env.ShellExpand(opt.ServicePrincipalFile)) if err != nil { return nil, fmt.Errorf("error opening service principal credentials file: %w", err) } parsedCreds, err := parseServicePrincipalCredentials(ctx, loadedCreds) if err != nil { return nil, fmt.Errorf("error parsing service principal credentials file: %w", err) } options := azidentity.ClientSecretCredentialOptions{ ClientOptions: policyClientOptions, } f.cred, err = azidentity.NewClientSecretCredential(parsedCreds.Tenant, parsedCreds.AppID, parsedCreds.Password, &options) if err != nil { return nil, fmt.Errorf("error creating a client secret credential: %w", err) } 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.) 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") } var options azidentity.ManagedIdentityCredentialOptions switch { case opt.MSIClientID != "": options.ID = azidentity.ClientID(opt.MSIClientID) case opt.MSIObjectID != "": // FIXME this doesn't appear to be in the new SDK? return nil, fmt.Errorf("MSI object ID is currently unsupported") case opt.MSIResourceID != "": options.ID = azidentity.ResourceID(opt.MSIResourceID) } f.cred, err = azidentity.NewManagedIdentityCredential(&options) if err != nil { return nil, fmt.Errorf("failed to acquire MSI token: %w", err) } case opt.ClientID != "" && opt.Tenant != "" && opt.MSIClientID != "": // Workload Identity based authentication var options azidentity.ManagedIdentityCredentialOptions options.ID = azidentity.ClientID(opt.MSIClientID) msiCred, err := azidentity.NewManagedIdentityCredential(&options) if err != nil { return nil, fmt.Errorf("failed to acquire MSI token: %w", err) } getClientAssertions := func(context.Context) (string, error) { 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) } return token.Token, nil } assertOpts := &azidentity.ClientAssertionCredentialOptions{} f.cred, err = azidentity.NewClientAssertionCredential( opt.Tenant, opt.ClientID, getClientAssertions, assertOpts) if err != nil { return nil, fmt.Errorf("failed to acquire client assertion token: %w", err) } case opt.UseAZ: var options = azidentity.AzureCLICredentialOptions{} f.cred, err = azidentity.NewAzureCLICredential(&options) if err != nil { return nil, fmt.Errorf("failed to create Azure CLI credentials: %w", err) } case opt.Account != "": // Anonymous access f.anonymous = true default: return nil, errors.New("no authentication method configured") } // Make the client if not already created if f.svc == nil { // Work out what the endpoint is if it is still unset if opt.Endpoint == "" { if opt.Account == "" { return nil, fmt.Errorf("account must be set: can't make service URL") } u, err := url.Parse(fmt.Sprintf("https://%s.%s", opt.Account, storageDefaultBaseURL)) if err != nil { return nil, fmt.Errorf("failed to make azure storage URL from account: %w", err) } opt.Endpoint = u.String() } if f.sharedKeyCred != nil { // Shared key cred f.svc, err = service.NewClientWithSharedKeyCredential(opt.Endpoint, f.sharedKeyCred, &clientOpt) if err != nil { return nil, fmt.Errorf("create client with shared key failed: %w", err) } } else if f.cred != nil { // Azidentity cred f.svc, err = service.NewClient(opt.Endpoint, f.cred, &clientOpt) if err != nil { return nil, fmt.Errorf("create client failed: %w", err) } } else if f.anonymous { // Anonymous public access f.svc, err = service.NewClientWithNoCredential(opt.Endpoint, &clientOpt) if err != nil { return nil, fmt.Errorf("create public client failed: %w", err) } } } if f.svc == nil { return nil, fmt.Errorf("internal error: auth failed to make credentials or client") } if f.rootContainer != "" && f.rootDirectory != "" { // Check to see if the (container,directory) is actually an existing file oldRoot := f.root newRoot, leaf := path.Split(oldRoot) f.setRoot(newRoot) _, err := f.NewObject(ctx, leaf) if err != nil { if err == fs.ErrorObjectNotFound || err == fs.ErrorNotAFile { // File doesn't exist or is a directory so return old f f.setRoot(oldRoot) return f, nil } return nil, err } // return an error with an fs which points to the parent return f, fs.ErrorIsFile } return f, nil } // return the container client for the container passed in func (f *Fs) cntSVC(containerName string) (containerClient *container.Client) { f.cntSVCcacheMu.Lock() defer f.cntSVCcacheMu.Unlock() var ok bool if containerClient, ok = f.cntSVCcache[containerName]; !ok { containerClient = f.svc.NewContainerClient(containerName) f.cntSVCcache[containerName] = containerClient } return containerClient } // Return an Object from a path // // If it can't be found it returns the error fs.ErrorObjectNotFound. func (f *Fs) newObjectWithInfo(ctx context.Context, remote string, info *container.BlobItem) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } if info != nil { err := o.decodeMetaDataFromBlob(info) if err != nil { return nil, err } } else if !o.fs.opt.NoHeadObject { err := o.readMetaData(ctx) // reads info and headers, returning an error if err != nil { return nil, err } } return o, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return f.newObjectWithInfo(ctx, remote, nil) } // getBlobSVC creates a blob client func (f *Fs) getBlobSVC(container, containerPath string) *blob.Client { return f.cntSVC(container).NewBlobClient(containerPath) } // getBlockBlobSVC creates a block blob client func (f *Fs) getBlockBlobSVC(container, containerPath string) *blockblob.Client { return f.cntSVC(container).NewBlockBlobClient(containerPath) } // updateMetadataWithModTime adds the modTime passed in to o.meta. func (o *Object) updateMetadataWithModTime(modTime time.Time) { metadataMu.Lock() defer metadataMu.Unlock() // Make sure o.meta is not nil if o.meta == nil { o.meta = make(map[string]string, 1) } // Set modTimeKey in it o.meta[modTimeKey] = modTime.Format(timeFormatOut) } // Returns whether file is a directory marker or not func isDirectoryMarker(size int64, metadata map[string]*string, remote string) bool { // Directory markers are 0 length if size == 0 { endsWithSlash := strings.HasSuffix(remote, "/") if endsWithSlash || remote == "" { return true } // Note that metadata with hdi_isfolder = true seems to be a // defacto standard for marking blobs as directories. // Note also that the metadata hasn't been normalised to lower case yet for k, v := range metadata { if v != nil && strings.EqualFold(k, dirMetaKey) && *v == dirMetaValue { return true } } } return false } // listFn is called from list to handle an object type listFn func(remote string, object *container.BlobItem, isDirectory bool) error // list lists the objects into the function supplied from // the container and root supplied // // dir is the starting directory, "" for root // // The remote has prefix removed from it and if addContainer is set then // it adds the container to the start. func (f *Fs) list(ctx context.Context, containerName, directory, prefix string, addContainer bool, recurse bool, maxResults int32, fn listFn) error { if f.cache.IsDeleted(containerName) { return fs.ErrorDirNotFound } if prefix != "" { prefix += "/" } if directory != "" && (prefix == "" && !bucket.IsAllSlashes(directory) || prefix != "" && !strings.HasSuffix(directory, "/")) { directory += "/" } delimiter := "" if !recurse { delimiter = "/" } pager := f.cntSVC(containerName).NewListBlobsHierarchyPager(delimiter, &container.ListBlobsHierarchyOptions{ // Copy, Metadata, Snapshots, UncommittedBlobs, Deleted, Tags, Versions, LegalHold, ImmutabilityPolicy, DeletedWithVersions bool Include: container.ListBlobsInclude{ Copy: false, Metadata: true, Snapshots: false, UncommittedBlobs: false, Deleted: false, }, Prefix: &directory, MaxResults: &maxResults, }) foundItems := 0 for pager.More() { var response container.ListBlobsHierarchyResponse err := f.pacer.Call(func() (bool, error) { var err error response, err = pager.NextPage(ctx) //response, err = f.srv.ListBlobsHierarchySegment(ctx, marker, delimiter, options) return f.shouldRetry(ctx, err) }) if err != nil { // Check http error code along with service code, current SDK doesn't populate service code correctly sometimes if storageErr, ok := err.(*azcore.ResponseError); ok && (storageErr.ErrorCode == string(bloberror.ContainerNotFound) || storageErr.StatusCode == http.StatusNotFound) { return fs.ErrorDirNotFound } return err } // Advance marker to next // marker = response.NextMarker foundItems += len(response.Segment.BlobItems) for i := range response.Segment.BlobItems { file := response.Segment.BlobItems[i] // Finish if file name no longer has prefix // if prefix != "" && !strings.HasPrefix(file.Name, prefix) { // return nil // } if file.Name == nil { fs.Debugf(f, "Nil name received") continue } remote := f.opt.Enc.ToStandardPath(*file.Name) if !strings.HasPrefix(remote, prefix) { fs.Debugf(f, "Odd name received %q", remote) continue } isDirectory := isDirectoryMarker(*file.Properties.ContentLength, file.Metadata, remote) if isDirectory { // Don't insert the root directory if remote == f.opt.Enc.ToStandardPath(directory) { continue } // process directory markers as directories remote, _ = strings.CutSuffix(remote, "/") } remote = remote[len(prefix):] if addContainer { remote = path.Join(containerName, remote) } // Send object err = fn(remote, file, isDirectory) if err != nil { return err } } // Send the subdirectories foundItems += len(response.Segment.BlobPrefixes) for _, blobPrefix := range response.Segment.BlobPrefixes { if blobPrefix.Name == nil { fs.Debugf(f, "Nil prefix received") continue } remote := f.opt.Enc.ToStandardPath(*blobPrefix.Name) if !strings.HasPrefix(remote, prefix) { fs.Debugf(f, "Odd directory name received %q", remote) continue } remote = remote[len(prefix):] // Trim one slash off the remote name remote, _ = strings.CutSuffix(remote, "/") if remote == "" || bucket.IsAllSlashes(remote) { remote += "/" } if addContainer { remote = path.Join(containerName, remote) } // Send object err = fn(remote, nil, true) if err != nil { return err } } } if f.opt.DirectoryMarkers && foundItems == 0 && directory != "" { // Determine whether the directory exists or not by whether it has a marker _, err := f.readMetaData(ctx, containerName, directory) if err != nil { if err == fs.ErrorObjectNotFound { return fs.ErrorDirNotFound } return err } } return nil } // Convert a list item into a DirEntry func (f *Fs) itemToDirEntry(ctx context.Context, remote string, object *container.BlobItem, isDirectory bool) (fs.DirEntry, error) { if isDirectory { d := fs.NewDir(remote, time.Time{}) return d, nil } o, err := f.newObjectWithInfo(ctx, remote, object) if err != nil { return nil, err } return o, nil } // Check to see if this is a limited container and the container is not found func (f *Fs) containerOK(container string) bool { if !f.isLimited { return true } f.cntSVCcacheMu.Lock() defer f.cntSVCcacheMu.Unlock() for limitedContainer := range f.cntSVCcache { if container == limitedContainer { return true } } return false } // listDir lists a single directory func (f *Fs) listDir(ctx context.Context, containerName, directory, prefix string, addContainer bool) (entries fs.DirEntries, err error) { if !f.containerOK(containerName) { return nil, fs.ErrorDirNotFound } err = f.list(ctx, containerName, directory, prefix, addContainer, false, int32(f.opt.ListChunkSize), func(remote string, object *container.BlobItem, isDirectory bool) error { entry, err := f.itemToDirEntry(ctx, remote, object, isDirectory) if err != nil { return err } if entry != nil { entries = append(entries, entry) } return nil }) if err != nil { return nil, err } // container must be present if listing succeeded f.cache.MarkOK(containerName) return entries, nil } // listContainers returns all the containers to out func (f *Fs) listContainers(ctx context.Context) (entries fs.DirEntries, err error) { if f.isLimited { f.cntSVCcacheMu.Lock() for container := range f.cntSVCcache { d := fs.NewDir(container, time.Time{}) entries = append(entries, d) } f.cntSVCcacheMu.Unlock() return entries, nil } err = f.listContainersToFn(func(Name string, LastModified time.Time) error { d := fs.NewDir(f.opt.Enc.ToStandardName(Name), LastModified) f.cache.MarkOK(Name) entries = append(entries, d) return nil }) if err != nil { return nil, err } return entries, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { container, directory := f.split(dir) if container == "" { if directory != "" { return nil, fs.ErrorListBucketRequired } return f.listContainers(ctx) } return f.listDir(ctx, container, directory, f.rootDirectory, f.rootContainer == "") } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively that doing a directory traversal. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { containerName, directory := f.split(dir) list := list.NewHelper(callback) listR := func(containerName, directory, prefix string, addContainer bool) error { return f.list(ctx, containerName, directory, prefix, addContainer, true, int32(f.opt.ListChunkSize), func(remote string, object *container.BlobItem, isDirectory bool) error { entry, err := f.itemToDirEntry(ctx, remote, object, isDirectory) if err != nil { return err } return list.Add(entry) }) } if containerName == "" { entries, err := f.listContainers(ctx) if err != nil { return err } for _, entry := range entries { err = list.Add(entry) if err != nil { return err } container := entry.Remote() err = listR(container, "", f.rootDirectory, true) if err != nil { return err } // container must be present if listing succeeded f.cache.MarkOK(container) } } else { if !f.containerOK(containerName) { return fs.ErrorDirNotFound } err = listR(containerName, directory, f.rootDirectory, f.rootContainer == "") if err != nil { return err } // container must be present if listing succeeded f.cache.MarkOK(containerName) } return list.Flush() } // listContainerFn is called from listContainersToFn to handle a container type listContainerFn func(Name string, LastModified time.Time) error // listContainersToFn lists the containers to the function supplied func (f *Fs) listContainersToFn(fn listContainerFn) error { max := int32(f.opt.ListChunkSize) pager := f.svc.NewListContainersPager(&service.ListContainersOptions{ Include: service.ListContainersInclude{Metadata: true, Deleted: true}, MaxResults: &max, }) ctx := context.Background() for pager.More() { var response service.ListContainersResponse err := f.pacer.Call(func() (bool, error) { var err error response, err = pager.NextPage(ctx) return f.shouldRetry(ctx, err) }) if err != nil { return err } for _, cnt := range response.ContainerItems { if cnt == nil || cnt.Name == nil || cnt.Properties == nil || cnt.Properties.LastModified == nil { fs.Debugf(f, "nil returned in container info") } err = fn(*cnt.Name, *cnt.Properties.LastModified) if err != nil { return err } } } return nil } // Put the object into the container // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { // Temporary Object under construction fs := &Object{ fs: f, remote: src.Remote(), } return fs, fs.Update(ctx, in, src, options...) } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } // Create directory marker file and parents func (f *Fs) createDirectoryMarker(ctx context.Context, container, dir string) error { if !f.opt.DirectoryMarkers || container == "" { return nil } // Object to be uploaded o := &Object{ fs: f, modTime: time.Now(), meta: map[string]string{ dirMetaKey: dirMetaValue, }, } for { _, containerPath := f.split(dir) // Don't create the directory marker if it is the bucket or at the very root if containerPath == "" { break } o.remote = dir + "/" // Check to see if object already exists _, err := f.readMetaData(ctx, container, containerPath+"/") if err == nil { return nil } // Upload it if not fs.Debugf(o, "Creating directory marker") content := io.Reader(strings.NewReader("")) err = o.Update(ctx, content, o) if err != nil { return fmt.Errorf("creating directory marker failed: %w", err) } // Now check parent directory exists dir = path.Dir(dir) if dir == "/" || dir == "." { break } } return nil } // Mkdir creates the container if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) error { container, _ := f.split(dir) e := f.makeContainer(ctx, container) if e != nil { return e } return f.createDirectoryMarker(ctx, container, dir) } // mkdirParent creates the parent bucket/directory if it doesn't exist func (f *Fs) mkdirParent(ctx context.Context, remote string) error { remote, _ = strings.CutSuffix(remote, "/") dir := path.Dir(remote) if dir == "/" || dir == "." { dir = "" } return f.Mkdir(ctx, dir) } // makeContainer creates the container if it doesn't exist func (f *Fs) makeContainer(ctx context.Context, container string) error { if f.opt.NoCheckContainer { return nil } return f.cache.Create(container, func() error { // If this is a SAS URL limited to a container then assume it is already created if f.isLimited { return nil } opt := service.CreateContainerOptions{ // Optional. Specifies a user-defined name-value pair associated with the blob. //Metadata map[string]string // Optional. Specifies the encryption scope settings to set on the container. //CpkScopeInfo *CpkScopeInfo } if f.publicAccess != "" { // Specifies whether data in the container may be accessed publicly and the level of access opt.Access = &f.publicAccess } // now try to create the container return f.pacer.Call(func() (bool, error) { _, err := f.svc.CreateContainer(ctx, container, &opt) if err != nil { if storageErr, ok := err.(*azcore.ResponseError); ok { switch bloberror.Code(storageErr.ErrorCode) { case bloberror.ContainerAlreadyExists: return false, nil case bloberror.ContainerBeingDeleted: // From https://docs.microsoft.com/en-us/rest/api/storageservices/delete-container // When a container is deleted, a container with the same name cannot be created // for at least 30 seconds; the container may not be available for more than 30 // seconds if the service is still processing the request. time.Sleep(12 * time.Second) // default 10 retries will be 120 seconds f.cache.MarkDeleted(container) return true, err case bloberror.AuthorizationFailure: // Assume that the user does not have permission to // create the container and carry on anyway. fs.Debugf(f, "Tried to create container but got %s error - carrying on assuming container exists. Use no_check_container to stop this check..", storageErr.ErrorCode) return false, nil } } } return f.shouldRetry(ctx, err) }) }, nil) } // isEmpty checks to see if a given (container, directory) is empty and returns an error if not func (f *Fs) isEmpty(ctx context.Context, containerName, directory string) (err error) { empty := true err = f.list(ctx, containerName, directory, f.rootDirectory, f.rootContainer == "", true, 1, func(remote string, object *container.BlobItem, isDirectory bool) error { empty = false return nil }) if err != nil { return err } if !empty { return fs.ErrorDirectoryNotEmpty } return nil } // deleteContainer deletes the container. It can delete a full // container so use isEmpty if you don't want that. func (f *Fs) deleteContainer(ctx context.Context, containerName string) error { return f.cache.Remove(containerName, func() error { getOptions := container.GetPropertiesOptions{} delOptions := container.DeleteOptions{} return f.pacer.Call(func() (bool, error) { _, err := f.cntSVC(containerName).GetProperties(ctx, &getOptions) if err == nil { _, err = f.cntSVC(containerName).Delete(ctx, &delOptions) } if err != nil { // Check http error code along with service code, current SDK doesn't populate service code correctly sometimes if storageErr, ok := err.(*azcore.ResponseError); ok && (storageErr.ErrorCode == string(bloberror.ContainerNotFound) || storageErr.StatusCode == http.StatusNotFound) { return false, fs.ErrorDirNotFound } return f.shouldRetry(ctx, err) } return f.shouldRetry(ctx, err) }) }) } // Rmdir deletes the container if the fs is at the root // // Returns an error if it isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { container, directory := f.split(dir) // Remove directory marker file if f.opt.DirectoryMarkers && container != "" && directory != "" { o := &Object{ fs: f, remote: dir + "/", } fs.Debugf(o, "Removing directory marker") err := o.Remove(ctx) if err != nil { return fmt.Errorf("removing directory marker failed: %w", err) } } if container == "" || directory != "" { return nil } err := f.isEmpty(ctx, container, directory) if err != nil { return err } return f.deleteContainer(ctx, container) } // Precision of the remote func (f *Fs) Precision() time.Duration { return time.Nanosecond } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hash.MD5) } // Purge deletes all the files and directories including the old versions. func (f *Fs) Purge(ctx context.Context, dir string) error { container, directory := f.split(dir) if container == "" { return errors.New("can't purge from root") } if directory != "" { // Delegate to caller if not root of a container return fs.ErrorCantPurge } return f.deleteContainer(ctx, container) } // Get a user delegation which is valid for at least sasCopyValidity // // This value is cached in f func (f *Fs) getUserDelegation(ctx context.Context) (*service.UserDelegationCredential, error) { f.userDelegationMu.Lock() defer f.userDelegationMu.Unlock() if f.userDelegation != nil && time.Until(f.userDelegationExpiry) > sasCopyValidity { return f.userDelegation, nil } // Validity window start := time.Now().UTC() expiry := start.Add(2 * sasCopyValidity) startStr := start.Format(time.RFC3339) expiryStr := expiry.Format(time.RFC3339) // Acquire user delegation key from the service client info := service.KeyInfo{ Start: &startStr, Expiry: &expiryStr, } userDelegationKey, err := f.svc.GetUserDelegationCredential(ctx, info, nil) if err != nil { return nil, fmt.Errorf("failed to get user delegation key: %w", err) } f.userDelegation = userDelegationKey f.userDelegationExpiry = expiry return f.userDelegation, nil } // getAuth gets auth to copy o. // // tokenOK is used to signal that token based auth (Microsoft Entra // ID) is acceptable. // // This will return srcURL to read the object, which may be a SAS URL. // // If noAuth is set then the srcURL returned will be a plain object // URL (not a SAS) and token will be empty. // // If tokenOK is true it may also return a token for the auth. func (o *Object) getAuth(ctx context.Context, noAuth bool) (srcURL string, err error) { f := o.fs srcBlobSVC := o.getBlobSVC() srcURL = srcBlobSVC.URL() switch { case noAuth: // If same storage account then no auth needed case f.cred != nil: // Generate a User Delegation SAS URL using Azure AD credentials userDelegationKey, err := f.getUserDelegation(ctx) if err != nil { return "", fmt.Errorf("sas creation: %w", err) } // Build the SAS values perms := sas.BlobPermissions{Read: true} container, containerPath := o.split() start := time.Now().UTC() expiry := start.Add(sasCopyValidity) vals := sas.BlobSignatureValues{ StartTime: start, ExpiryTime: expiry, Permissions: perms.String(), ContainerName: container, BlobName: containerPath, } // Sign with the delegation key queryParameters, err := vals.SignWithUserDelegation(userDelegationKey) if err != nil { return "", fmt.Errorf("signing SAS with user delegation failed: %w", err) } // Append the SAS to the URL srcURL = srcBlobSVC.URL() + "?" + queryParameters.Encode() case f.sharedKeyCred != nil: // Generate a short lived SAS URL if using shared key credentials expiry := time.Now().Add(sasCopyValidity) sasOptions := blob.GetSASURLOptions{} srcURL, err = srcBlobSVC.GetSASURL(sas.BlobPermissions{Read: true}, expiry, &sasOptions) if err != nil { return srcURL, fmt.Errorf("failed to create SAS URL: %w", err) } case f.anonymous || f.opt.SASURL != "": // If using a SASURL or anonymous, no need for any extra auth default: return srcURL, errors.New("unknown authentication type") } return srcURL, nil } // Do multipart parallel copy. // // This uses these APIs: // // - PutBlockFromURL - https://learn.microsoft.com/en-us/rest/api/storageservices/put-block-from-url // - PutBlockList - https://learn.microsoft.com/en-us/rest/api/storageservices/put-block-list func (f *Fs) copyMultipart(ctx context.Context, remote, dstContainer, dstPath string, src *Object) (dst fs.Object, err error) { srcProperties, err := src.readMetaDataAlways(ctx) if err != nil { return nil, fmt.Errorf("multipart copy: failed to read source object: %w", err) } // Create the dst object by altering a copy of the src object obj := *src o := &obj o.fs = f o.remote = remote srcURL, err := src.getAuth(ctx, false) if err != nil { return nil, fmt.Errorf("multipart copy: %w", err) } bic, err := newBlockIDCreator() if err != nil { return nil, err } dstBlockBlobSVC := f.getBlockBlobSVC(dstContainer, dstPath) defer atexit.OnError(&err, func() { // Try to abort the upload, but ignore the error. fs.Debugf(o, "Cancelling multipart copy") _ = o.clearUncommittedBlocks(ctx) })() var ( srcSize = src.size partSize = int64(chunksize.Calculator(o, src.size, blockblob.MaxBlocks, f.opt.ChunkSize)) numParts = (srcSize + partSize - 1) / partSize blockIDs = make([]string, numParts) // list of blocks for finalize g, gCtx = errgroup.WithContext(ctx) checker = newCheckForInvalidBlockOrBlob("copy", o) ) g.SetLimit(f.opt.CopyConcurrency) fs.Debugf(o, "Starting multipart copy with %d parts of size %v", numParts, fs.SizeSuffix(partSize)) for partNum := uint64(0); partNum < uint64(numParts); partNum++ { // Fail fast, in case an errgroup managed function returns an error // gCtx is cancelled. There is no point in uploading all the other parts. if gCtx.Err() != nil { break } partNum := partNum // for closure g.Go(func() error { blockID := bic.newBlockID(partNum) options := blockblob.StageBlockFromURLOptions{ Range: blob.HTTPRange{ Offset: int64(partNum) * partSize, Count: partSize, }, // Specifies the authorization scheme and signature for the copy source. // We use SAS URLs as this doesn't seem to work always // CopySourceAuthorization: token, // CPKInfo *blob.CPKInfo // CPKScopeInfo *blob.CPKScopeInfo } // Partial last block if remaining := srcSize - options.Range.Offset; remaining < options.Range.Count { options.Range.Count = remaining } fs.Debugf(o, "multipart copy: starting chunk %d size %v offset %v/%v", partNum, fs.SizeSuffix(options.Range.Count), fs.SizeSuffix(options.Range.Offset), fs.SizeSuffix(srcSize)) err := f.pacer.Call(func() (bool, error) { checker.start() _, err := dstBlockBlobSVC.StageBlockFromURL(ctx, blockID, srcURL, &options) checker.stop() if err != nil { if checker.checkErr(ctx, err) { return true, err } return f.shouldRetry(ctx, err) } return false, nil }) if err != nil { return fmt.Errorf("multipart copy: failed to copy chunk %d with %v bytes: %w", partNum+1, -1, err) } blockIDs[partNum] = blockID return nil }) } err = g.Wait() if err != nil { return nil, err } // Convert metadata from source object options := blockblob.CommitBlockListOptions{ Metadata: srcProperties.Metadata, Tier: parseTier(f.opt.AccessTier), HTTPHeaders: &blob.HTTPHeaders{ BlobCacheControl: srcProperties.CacheControl, BlobContentDisposition: srcProperties.ContentDisposition, BlobContentEncoding: srcProperties.ContentEncoding, BlobContentLanguage: srcProperties.ContentLanguage, BlobContentMD5: srcProperties.ContentMD5, BlobContentType: srcProperties.ContentType, }, } // Finalise the upload session err = f.pacer.Call(func() (bool, error) { _, err := dstBlockBlobSVC.CommitBlockList(ctx, blockIDs, &options) return f.shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("failed to complete multipart copy: %w", err) } fs.Debugf(o, "multipart copy finished") return f.NewObject(ctx, remote) } // Do single part copy. // // This uses these APIs: // // - Copy Blob - https://docs.microsoft.com/rest/api/storageservices/copy-blob // - Get Blob Properties - https://docs.microsoft.com/rest/api/storageservices/get-blob-properties func (f *Fs) copySinglepart(ctx context.Context, remote, dstContainer, dstPath string, src *Object) (dst fs.Object, err error) { dstBlobSVC := f.getBlobSVC(dstContainer, dstPath) // Get the source auth - none needed for same storage account srcURL, err := src.getAuth(ctx, f == src.fs) if err != nil { return nil, fmt.Errorf("single part copy: source auth: %w", err) } // Start the copy options := blob.StartCopyFromURLOptions{ Tier: parseTier(f.opt.AccessTier), } var startCopy blob.StartCopyFromURLResponse err = f.pacer.Call(func() (bool, error) { startCopy, err = dstBlobSVC.StartCopyFromURL(ctx, srcURL, &options) return f.shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("single part copy: copy blob: %w", err) } // Poll for completion if necessary // // The for loop is never executed for same storage account copies. copyStatus := startCopy.CopyStatus getOptions := blob.GetPropertiesOptions{} pollTime := 100 * time.Millisecond for copyStatus != nil && string(*copyStatus) == string(container.CopyStatusTypePending) { time.Sleep(pollTime) var getMetadata blob.GetPropertiesResponse err = f.pacer.Call(func() (bool, error) { getMetadata, err = dstBlobSVC.GetProperties(ctx, &getOptions) return f.shouldRetry(ctx, err) }) if err != nil { return nil, err } copyStatus = getMetadata.CopyStatus pollTime = min(2*pollTime, time.Second) } return f.NewObject(ctx, remote) } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { dstContainer, dstPath := f.split(remote) err := f.mkdirParent(ctx, remote) if err != nil { return nil, err } srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't copy - not same remote type") return nil, fs.ErrorCantCopy } // Assume we are copying to a different storage account if we // are copying across configs. sameStorageAccount := f == srcObj.fs // If we are using Microsoft Entra ID token based auth then // copySinglepart does not work usingEntraID := f.cred != nil // Use multipart copy if size > cutoff // or using Entra ID and we are not using the same storage account useMultiPart := srcObj.size >= int64(f.opt.CopyCutoff) || (usingEntraID && !sameStorageAccount) // Force the use of copy blob if on the same storage account // and the user hasn't forbidden it. if f.opt.UseCopyBlob && sameStorageAccount { useMultiPart = false } if useMultiPart { return f.copyMultipart(ctx, remote, dstContainer, dstPath, srcObj) } return f.copySinglepart(ctx, remote, dstContainer, dstPath, srcObj) } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Hash returns the MD5 of an object returning a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if t != hash.MD5 { return "", hash.ErrUnsupported } // Convert base64 encoded md5 into lower case hex if o.md5 == "" { return "", nil } data, err := base64.StdEncoding.DecodeString(o.md5) if err != nil { return "", fmt.Errorf("failed to decode Content-MD5: %q: %w", o.md5, err) } return hex.EncodeToString(data), nil } // Size returns the size of an object in bytes func (o *Object) Size() int64 { return o.size } // Set o.metadata from metadata func (o *Object) setMetadata(metadata map[string]*string) { metadataMu.Lock() defer metadataMu.Unlock() if len(metadata) > 0 { // Lower case the metadata o.meta = make(map[string]string, len(metadata)) for k, v := range metadata { if v != nil { o.meta[strings.ToLower(k)] = *v } } // Set o.modTime from metadata if it exists and // UseServerModTime isn't in use. if modTime, ok := o.meta[modTimeKey]; !o.fs.ci.UseServerModTime && ok { when, err := time.Parse(timeFormatIn, modTime) if err != nil { fs.Debugf(o, "Couldn't parse %v = %q: %v", modTimeKey, modTime, err) } o.modTime = when } } else { o.meta = nil } } // Get metadata from o.meta func (o *Object) getMetadata() (metadata map[string]*string) { metadataMu.Lock() defer metadataMu.Unlock() if len(o.meta) == 0 { return nil } metadata = make(map[string]*string, len(o.meta)) for k, v := range o.meta { v := v metadata[k] = &v } return metadata } // decodeMetaDataFromPropertiesResponse sets the metadata from the data passed in // // Sets // // o.id // o.modTime // o.size // o.md5 // o.meta func (o *Object) decodeMetaDataFromPropertiesResponse(info *blob.GetPropertiesResponse) (err error) { metadata := info.Metadata var size int64 if info.ContentLength == nil { size = -1 } else { size = *info.ContentLength } if isDirectoryMarker(size, metadata, o.remote) { return fs.ErrorNotAFile } // NOTE - Client library always returns MD5 as base64 decoded string, Object needs to maintain // this as base64 encoded string. o.md5 = base64.StdEncoding.EncodeToString(info.ContentMD5) if info.ContentType == nil { o.mimeType = "" } else { o.mimeType = *info.ContentType } o.size = size if info.LastModified == nil { o.modTime = time.Now() } else { o.modTime = *info.LastModified } if info.AccessTier == nil { o.accessTier = blob.AccessTier("") } else { o.accessTier = blob.AccessTier(*info.AccessTier) } o.setMetadata(metadata) return nil } func (o *Object) decodeMetaDataFromDownloadResponse(info *blob.DownloadStreamResponse) (err error) { metadata := info.Metadata var size int64 if info.ContentLength == nil { size = -1 } else { size = *info.ContentLength } if isDirectoryMarker(size, metadata, o.remote) { return fs.ErrorNotAFile } // NOTE - Client library always returns MD5 as base64 decoded string, Object needs to maintain // this as base64 encoded string. o.md5 = base64.StdEncoding.EncodeToString(info.ContentMD5) if info.ContentType == nil { o.mimeType = "" } else { o.mimeType = *info.ContentType } o.size = size if info.LastModified == nil { o.modTime = time.Now() } else { o.modTime = *info.LastModified } // FIXME response doesn't appear to have AccessTier in? // if info.AccessTier == nil { // o.accessTier = blob.AccessTier("") // } else { // o.accessTier = blob.AccessTier(*info.AccessTier) // } o.setMetadata(metadata) // If it was a Range request, the size is wrong, so correct it if info.ContentRange != nil { contentRange := *info.ContentRange slash := strings.IndexRune(contentRange, '/') if slash >= 0 { i, err := strconv.ParseInt(contentRange[slash+1:], 10, 64) if err == nil { o.size = i } else { fs.Debugf(o, "Failed to find parse integer from in %q: %v", contentRange, err) } } else { fs.Debugf(o, "Failed to find length in %q", contentRange) } } return nil } func (o *Object) decodeMetaDataFromBlob(info *container.BlobItem) (err error) { if info.Properties == nil { return errors.New("nil Properties in decodeMetaDataFromBlob") } metadata := info.Metadata var size int64 if info.Properties.ContentLength == nil { size = -1 } else { size = *info.Properties.ContentLength } if isDirectoryMarker(size, metadata, o.remote) { return fs.ErrorNotAFile } // NOTE - Client library always returns MD5 as base64 decoded string, Object needs to maintain // this as base64 encoded string. o.md5 = base64.StdEncoding.EncodeToString(info.Properties.ContentMD5) if info.Properties.ContentType == nil { o.mimeType = "" } else { o.mimeType = *info.Properties.ContentType } o.size = size if info.Properties.LastModified == nil { o.modTime = time.Now() } else { o.modTime = *info.Properties.LastModified } if info.Properties.AccessTier == nil { o.accessTier = blob.AccessTier("") } else { o.accessTier = *info.Properties.AccessTier } o.setMetadata(metadata) return nil } func (o *Object) getTags() (tags map[string]string) { if o.tags != nil { return o.tags } return map[string]string{} } // getBlobSVC creates a blob client func (o *Object) getBlobSVC() *blob.Client { container, directory := o.split() return o.fs.getBlobSVC(container, directory) } // getBlockBlobSVC creates a block blob client func (o *Object) getBlockBlobSVC() *blockblob.Client { container, directory := o.split() return o.fs.getBlockBlobSVC(container, directory) } // clearMetaData clears enough metadata so readMetaData will re-read it func (o *Object) clearMetaData() { o.modTime = time.Time{} } // readMetaData gets the metadata if it hasn't already been fetched func (f *Fs) readMetaData(ctx context.Context, container, containerPath string) (blobProperties *blob.GetPropertiesResponse, err error) { if !f.containerOK(container) { return nil, fs.ErrorObjectNotFound } blb := f.getBlobSVC(container, containerPath) // Read metadata (this includes metadata) options := blob.GetPropertiesOptions{} var resp blob.GetPropertiesResponse err = f.pacer.Call(func() (bool, error) { resp, err = blb.GetProperties(ctx, &options) return f.shouldRetry(ctx, err) }) if err != nil { // On directories - GetProperties does not work and current SDK does not populate service code correctly hence check regular http response as well if storageErr, ok := err.(*azcore.ResponseError); ok && (storageErr.ErrorCode == string(bloberror.BlobNotFound) || storageErr.StatusCode == http.StatusNotFound) { return nil, fs.ErrorObjectNotFound } return nil, err } return &resp, nil } // readMetaDataAlways gets the metadata unconditionally and also the blob properties. // // Sets // // o.id // o.modTime // o.size // o.md5 func (o *Object) readMetaDataAlways(ctx context.Context) (blobProperties *blob.GetPropertiesResponse, err error) { container, containerPath := o.split() blobProperties, err = o.fs.readMetaData(ctx, container, containerPath) if err != nil { return nil, err } err = o.decodeMetaDataFromPropertiesResponse(blobProperties) if err != nil { return nil, err } return blobProperties, nil } // readMetaData gets the metadata if it hasn't already been fetched // // Sets // // o.id // o.modTime // o.size // o.md5 func (o *Object) readMetaData(ctx context.Context) (err error) { if !o.modTime.IsZero() { return nil } _, err = o.readMetaDataAlways(ctx) return err } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers func (o *Object) ModTime(ctx context.Context) (result time.Time) { // The error is logged in readMetaData _ = o.readMetaData(ctx) return o.modTime } // SetModTime sets the modification time of the local fs object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { o.updateMetadataWithModTime(modTime) blb := o.getBlobSVC() opt := blob.SetMetadataOptions{} err := o.fs.pacer.Call(func() (bool, error) { _, err := blb.SetMetadata(ctx, o.getMetadata(), &opt) return o.fs.shouldRetry(ctx, err) }) if err != nil { return err } o.modTime = modTime return nil } // Storable returns if this object is storable func (o *Object) Storable() bool { return true } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { // Offset and Count for range download var offset int64 var count int64 if o.AccessTier() == blob.AccessTierArchive { return nil, fmt.Errorf("blob in archive tier, you need to set tier to hot, cool, cold first") } fs.FixRangeOption(options, o.size) for _, option := range options { switch x := option.(type) { case *fs.RangeOption: offset, count = x.Decode(o.size) if count < 0 { count = o.size - offset } case *fs.SeekOption: offset = x.Offset default: if option.Mandatory() { fs.Logf(o, "Unsupported mandatory option: %v", option) } } } blb := o.getBlobSVC() opt := blob.DownloadStreamOptions{ // When set to true and specified together with the Range, the service returns the MD5 hash for the range, as long as the // range is less than or equal to 4 MB in size. //RangeGetContentMD5 *bool // Range specifies a range of bytes. The default value is all bytes. //Range HTTPRange Range: blob.HTTPRange{ Offset: offset, Count: count, }, // AccessConditions *AccessConditions // CpkInfo *CpkInfo // CpkScopeInfo *CpkScopeInfo } var downloadResponse blob.DownloadStreamResponse err = o.fs.pacer.Call(func() (bool, error) { downloadResponse, err = blb.DownloadStream(ctx, &opt) return o.fs.shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("failed to open for download: %w", err) } err = o.decodeMetaDataFromDownloadResponse(&downloadResponse) if err != nil { return nil, fmt.Errorf("failed to decode metadata for download: %w", err) } return downloadResponse.Body, nil } // Converts a string into a pointer to a string func pString(s string) *string { return &s } // readSeekCloser joins an io.Reader and an io.Seeker and provides a no-op io.Closer type readSeekCloser struct { io.Reader io.Seeker } // Close does nothing func (rs *readSeekCloser) Close() error { return nil } // a creator for blockIDs with an incrementing part and a random part // // The random part is to make sure that blockIDs don't collide between // uploads. We need block IDs not to be shared between upload attempts // so we can remove the uncommitted blocks properly on errors. type blockIDCreator struct { random [8]byte // randomness to make sure blocks don't collide } // create a new blockID creator with a random suffix func newBlockIDCreator() (bic *blockIDCreator, err error) { bic = &blockIDCreator{} n, err := rand.Read(bic.random[:]) if err != nil { return nil, fmt.Errorf("crypto rand failed: %w", err) } if n != len(bic.random) { return nil, errors.New("crypto rand failed: short read") } return bic, nil } // create a new block ID for chunkNumber func (bic *blockIDCreator) newBlockID(chunkNumber uint64) string { var binaryBlockID [16]byte // block counter as LSB first 8 bytes binary.BigEndian.PutUint64(binaryBlockID[:8], chunkNumber) // random bits at the end copy(binaryBlockID[8:], bic.random[:]) // return base64 encoded value return base64.StdEncoding.EncodeToString(binaryBlockID[:]) } // Check the chunkNumber is correct in the id func (bic *blockIDCreator) checkID(chunkNumber uint64, id string) error { binaryBlockID, err := base64.StdEncoding.DecodeString(id) if err != nil { return fmt.Errorf("internal error: bad block ID: %w", err) } if len(binaryBlockID) != 16 { return errors.New("internal error: bad block ID length") } gotChunkNumber := binary.BigEndian.Uint64(binaryBlockID[:8]) if chunkNumber != gotChunkNumber { return fmt.Errorf("internal error: expecting decoded chunkNumber %d but got %d", chunkNumber, gotChunkNumber) } if !bytes.Equal(binaryBlockID[8:], bic.random[:]) { return fmt.Errorf("internal error: random bytes are incorrect") } return nil } // record chunk number and id for Close type azBlock struct { chunkNumber uint64 id string } // Implements the fs.ChunkWriter interface type azChunkWriter struct { chunkSize int64 size int64 f *Fs ui uploadInfo blocksMu sync.Mutex // protects the below blocks []azBlock // list of blocks for finalize o *Object bic *blockIDCreator checker *checkForInvalidBlockOrBlob } // OpenChunkWriter returns the chunk size and a ChunkWriter // // Pass in the remote and the src object // You can also use options to hint at the desired chunk size func (f *Fs) OpenChunkWriter(ctx context.Context, remote string, src fs.ObjectInfo, options ...fs.OpenOption) (info fs.ChunkWriterInfo, writer fs.ChunkWriter, err error) { // Temporary Object under construction o := &Object{ fs: f, remote: remote, } ui, err := o.prepareUpload(ctx, src, options) if err != nil { return info, nil, fmt.Errorf("failed to prepare upload: %w", err) } // Calculate correct partSize partSize := f.opt.ChunkSize totalParts := -1 size := src.Size() // Note that the max size of file is 4.75 TB (100 MB X 50,000 // blocks) and this is bigger than the max uncommitted block // size (9.52 TB) so we do not need to part commit block lists // or garbage collect uncommitted blocks. // // See: https://docs.microsoft.com/en-gb/rest/api/storageservices/put-block // size can be -1 here meaning we don't know the size of the incoming file. We use ChunkSize // buffers here (default 4MB). With a maximum number of parts (50,000) this will be a file of // 195GB which seems like a not too unreasonable limit. if size == -1 { warnStreamUpload.Do(func() { fs.Logf(f, "Streaming uploads using chunk size %v will have maximum file size of %v", f.opt.ChunkSize, partSize*fs.SizeSuffix(blockblob.MaxBlocks)) }) } else { partSize = chunksize.Calculator(remote, size, blockblob.MaxBlocks, f.opt.ChunkSize) if partSize > fs.SizeSuffix(blockblob.MaxStageBlockBytes) { return info, nil, fmt.Errorf("can't upload as it is too big %v - takes more than %d chunks of %v", fs.SizeSuffix(size), fs.SizeSuffix(blockblob.MaxBlocks), fs.SizeSuffix(blockblob.MaxStageBlockBytes)) } totalParts = int(fs.SizeSuffix(size) / partSize) if fs.SizeSuffix(size)%partSize != 0 { totalParts++ } } fs.Debugf(o, "Multipart upload session started for %d parts of size %v", totalParts, partSize) chunkWriter := &azChunkWriter{ chunkSize: int64(partSize), size: size, f: f, ui: ui, o: o, checker: newCheckForInvalidBlockOrBlob("upload", o), } info = fs.ChunkWriterInfo{ ChunkSize: int64(partSize), Concurrency: o.fs.opt.UploadConcurrency, //LeavePartsOnError: o.fs.opt.LeavePartsOnError, } chunkWriter.bic, err = newBlockIDCreator() if err != nil { return info, nil, err } fs.Debugf(o, "open chunk writer: started multipart upload") return info, chunkWriter, nil } // isInvalidBlockOrBlob looks for the InvalidBlockOrBlob error in err // returning true if it is found func isInvalidBlockOrBlob(err error) bool { var storageErr *azcore.ResponseError if errors.As(err, &storageErr) { return storageErr.ErrorCode == string(bloberror.InvalidBlobOrBlock) } return false } // Struct to hold state for checking for InvalidBlockOrBlob type checkForInvalidBlockOrBlob struct { startMu sync.Mutex // hold when starting transactions inFlight sync.WaitGroup // transactions in flight what string // "copy" or "upload" o *Object // object we are working on cleared bool // set if we have cleared the uncommitted blocks - we only do this once } // Make InvalidBlockOrBlob checker func newCheckForInvalidBlockOrBlob(what string, o *Object) *checkForInvalidBlockOrBlob { return &checkForInvalidBlockOrBlob{ what: what, o: o, } } // start marks that there is a transaction in progress func (c *checkForInvalidBlockOrBlob) start() { c.startMu.Lock() defer c.startMu.Unlock() c.inFlight.Add(1) } // stop marks that this transaction has finished func (c *checkForInvalidBlockOrBlob) stop() { c.inFlight.Done() } // checkErr looks for the InvalidBlockOrBlob error in err, and if it // is found, it clears uncommitted blocks in o to clear the error. // // It returns a bool indicating whether the error was found or not. // // See https://gauravmantri.com/2013/05/18/windows-azure-blob-storage-dealing-with-the-specified-blob-or-block-content-is-invalid-error/ func (c *checkForInvalidBlockOrBlob) checkErr(ctx context.Context, err error) (result bool) { // defer log.Trace(c.o, "err=%#v, what=%q", err, c.what)("result=%v", &result) if !isInvalidBlockOrBlob(err) { return false } // Prevent more transactions starting c.startMu.Lock() defer c.startMu.Unlock() if c.cleared { fs.Debugf(c.o, "multipart %s: received %s error: already cleared", c.what, bloberror.InvalidBlobOrBlock) return true } // Wait for any other outstanding transactions to finish c.inFlight.Wait() // Clear uncommitted blocks fs.Debugf(c.o, "multipart %s: received %s error: clearing uncommitted blocks and retrying", c.what, bloberror.InvalidBlobOrBlock) clearErr := c.o.clearUncommittedBlocks(ctx) if clearErr != nil { fs.Debugf(c.o, "multipart %s: error fixing %s: %v", c.what, bloberror.InvalidBlobOrBlock, clearErr) } fs.Debugf(c.o, "multipart %s: fixed %s", c.what, bloberror.InvalidBlobOrBlock) c.cleared = true return true } // WriteChunk will write chunk number with reader bytes, where chunk number >= 0 func (w *azChunkWriter) WriteChunk(ctx context.Context, chunkNumber int, reader io.ReadSeeker) (int64, error) { if chunkNumber < 0 { err := fmt.Errorf("invalid chunk number provided: %v", chunkNumber) 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) if err != nil { return -1, err } // If no data read, don't write the chunk if currentChunkSize == 0 { return 0, nil } md5sum := m.Sum(nil) // Create a new blockID blockID := w.bic.newBlockID(uint64(chunkNumber)) // Save the blockID for the commit w.blocksMu.Lock() w.blocks = append(w.blocks, azBlock{ chunkNumber: uint64(chunkNumber), id: blockID, }) w.blocksMu.Unlock() err = w.f.pacer.Call(func() (bool, error) { // rewind the reader on retry and after reading md5 _, err = reader.Seek(0, io.SeekStart) if err != nil { return false, err } options := blockblob.StageBlockOptions{ // Specify the transactional md5 for the body, to be validated by the service. TransactionalValidation: blob.TransferValidationTypeMD5(md5sum), } w.checker.start() _, err = w.ui.blb.StageBlock(ctx, blockID, &readSeekCloser{Reader: reader, Seeker: reader}, &options) w.checker.stop() if err != nil { if w.checker.checkErr(ctx, err) { return true, err } if chunkNumber <= 8 { return w.f.shouldRetry(ctx, err) } if fserrors.ContextError(ctx, &err) { return false, err } // retry all chunks once have done the first few return true, err } return false, nil }) if err != nil { return -1, fmt.Errorf("failed to upload chunk %d with %v bytes: %w", chunkNumber+1, currentChunkSize, err) } fs.Debugf(w.o, "multipart upload wrote chunk %d with %v bytes", chunkNumber+1, currentChunkSize) return currentChunkSize, err } // Clear uncommitted blocks // // There isn't an API to clear uncommitted blocks. // // However they are released when a Commit is called. Doing this will // instantiate the object so we don't want to overwrite an existing // object. // // We will use this algorithm: // // Attempt to read committed blocks from the object // If the object exists // - Commit the existing blocks again // - This should get rid of the uncommitted blocks without changing the existing object // If the object does not exist then // - Commit an empty block list // - This will get rid of the uncommitted blocks // - This will also create a 0 length blob // - So delete the 0 length blob func (o *Object) clearUncommittedBlocks(ctx context.Context) (err error) { fs.Debugf(o, "Clearing uncommitted blocks") var ( blockBlobSVC = o.getBlockBlobSVC() objectExists = true blockIDs []string 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) if err == fs.ErrorObjectNotFound { objectExists = false } else if err != nil { return fmt.Errorf("clear uncommitted blocks: failed to read metadata: %w", err) } if objectExists { // Get the committed block list err = pacer.Call(func() (bool, error) { blockList, err = blockBlobSVC.GetBlockList(ctx, blockblob.BlockListTypeAll, nil) return o.fs.shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("clear uncommitted blocks: failed to read uncommitted block list: %w", err) } if len(blockList.UncommittedBlocks) == 0 { fs.Debugf(o, "No uncommitted blocks - exiting") return nil } fs.Debugf(o, "%d Uncommitted blocks found", len(blockList.UncommittedBlocks)) objectExists = true uncommittedBlocks := make(map[string]struct{}, len(blockList.UncommittedBlocks)) for _, block := range blockList.UncommittedBlocks { uncommittedBlocks[*block.Name] = struct{}{} } for _, block := range blockList.CommittedBlocks { name := *block.Name if _, found := uncommittedBlocks[name]; found { return fmt.Errorf("clear uncommitted blocks: can't safely clear uncommitted blocks as committed and uncommitted IDs overlap. Delete the existing object to clear the uncommitted blocks") } blockIDs = append(blockIDs, name) } // Reconstruct metadata from existing object as CommitBlockList overwrites it options = &blockblob.CommitBlockListOptions{ Metadata: properties.Metadata, Tier: (*blob.AccessTier)(properties.AccessTier), HTTPHeaders: &blob.HTTPHeaders{ BlobCacheControl: properties.CacheControl, BlobContentDisposition: properties.ContentDisposition, BlobContentEncoding: properties.ContentEncoding, BlobContentLanguage: properties.ContentLanguage, BlobContentMD5: properties.ContentMD5, BlobContentType: properties.ContentType, }, } } // Commit only the committed blocks fs.Debugf(o, "Committing %d blocks to remove uncommitted blocks", len(blockIDs)) err = pacer.Call(func() (bool, error) { _, err := blockBlobSVC.CommitBlockList(ctx, blockIDs, options) return o.fs.shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("clear uncommitted blocks: failed to commit block list: %w", err) } // If object didn't exist before, then delete it if !objectExists { fs.Debugf(o, "Removing empty object") err = o.Remove(ctx) if err != nil { return fmt.Errorf("clear uncommitted blocks: failed to remove empty object: %w", err) } } return nil } // Abort the multipart upload. func (w *azChunkWriter) Abort(ctx context.Context) error { return w.o.clearUncommittedBlocks(ctx) } // Close and finalise the multipart upload func (w *azChunkWriter) Close(ctx context.Context) (err error) { // sort the completed parts by part number sort.Slice(w.blocks, func(i, j int) bool { return w.blocks[i].chunkNumber < w.blocks[j].chunkNumber }) // Create and check a list of block IDs blockIDs := make([]string, len(w.blocks)) for i := range w.blocks { if w.blocks[i].chunkNumber != uint64(i) { return fmt.Errorf("internal error: expecting chunkNumber %d but got %d", i, w.blocks[i].chunkNumber) } err := w.bic.checkID(w.blocks[i].chunkNumber, w.blocks[i].id) if err != nil { return err } blockIDs[i] = w.blocks[i].id } options := blockblob.CommitBlockListOptions{ Metadata: w.o.getMetadata(), Tags: w.o.getTags(), Tier: parseTier(w.f.opt.AccessTier), HTTPHeaders: &w.ui.httpHeaders, } // Finalise the upload session err = w.f.pacer.Call(func() (bool, error) { _, err := w.ui.blb.CommitBlockList(ctx, blockIDs, &options) return w.f.shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("failed to complete multipart upload: %w", err) } fs.Debugf(w.o, "multipart upload finished") return err } var warnStreamUpload sync.Once // uploadMultipart uploads a file using multipart upload // // Write a larger blob, using CreateBlockBlob, PutBlock, and PutBlockList. func (o *Object) uploadMultipart(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (ui uploadInfo, err error) { chunkWriter, err := multipart.UploadMultipart(ctx, src, in, multipart.UploadMultipartOptions{ Open: o.fs, OpenOptions: options, }) if err != nil { return ui, err } return chunkWriter.(*azChunkWriter).ui, nil } // uploadSinglepart uploads a short blob using a single part upload func (o *Object) uploadSinglepart(ctx context.Context, in io.Reader, size int64, ui uploadInfo) (err error) { chunkSize := int64(o.fs.opt.ChunkSize) // fs.Debugf(o, "Single part upload starting of object %d bytes", size) if size > chunkSize || size < 0 { return fmt.Errorf("internal error: single part upload size too big %d > %d", size, chunkSize) } rw := multipart.NewRW() defer fs.CheckClose(rw, &err) n, err := io.CopyN(rw, in, size+1) if err != nil && err != io.EOF { return fmt.Errorf("single part upload read failed: %w", err) } if n != size { return fmt.Errorf("single part upload: expecting to read %d bytes but read %d", size, n) } rs := &readSeekCloser{Reader: rw, Seeker: rw} options := blockblob.UploadOptions{ Metadata: o.getMetadata(), Tags: o.getTags(), Tier: parseTier(o.fs.opt.AccessTier), HTTPHeaders: &ui.httpHeaders, } return o.fs.pacer.Call(func() (bool, error) { // rewind the reader on retry _, err = rs.Seek(0, io.SeekStart) if err != nil { return false, err } _, err = ui.blb.Upload(ctx, rs, &options) return o.fs.shouldRetry(ctx, err) }) } // Info needed for an upload type uploadInfo struct { blb *blockblob.Client httpHeaders blob.HTTPHeaders isDirMarker bool } // Prepare the object for upload func (o *Object) prepareUpload(ctx context.Context, src fs.ObjectInfo, options []fs.OpenOption) (ui uploadInfo, err error) { container, containerPath := o.split() if container == "" || containerPath == "" { return ui, fmt.Errorf("can't upload to root - need a container") } // Create parent dir/bucket if not saving directory marker metadataMu.Lock() _, ui.isDirMarker = o.meta[dirMetaKey] metadataMu.Unlock() if !ui.isDirMarker { err = o.fs.mkdirParent(ctx, o.remote) if err != nil { return ui, err } } // if ui.isDirMarker && strings.HasSuffix(containerPath, "//") { // containerPath = containerPath[:len(containerPath)-1] // } // Update Mod time o.updateMetadataWithModTime(src.ModTime(ctx)) if err != nil { return ui, err } // Create the HTTP headers for the upload ui.httpHeaders = blob.HTTPHeaders{ BlobContentType: pString(fs.MimeType(ctx, src)), } // Compute the Content-MD5 of the file. As we stream all uploads it // will be set in PutBlockList API call using the 'x-ms-blob-content-md5' header if !o.fs.opt.DisableCheckSum { if sourceMD5, _ := src.Hash(ctx, hash.MD5); sourceMD5 != "" { sourceMD5bytes, err := hex.DecodeString(sourceMD5) if err == nil { ui.httpHeaders.BlobContentMD5 = sourceMD5bytes } else { fs.Debugf(o, "Failed to decode %q as MD5: %v", sourceMD5, err) } } } // Apply upload options (also allows one to overwrite content-type) for _, option := range options { key, value := option.Header() lowerKey := strings.ToLower(key) switch lowerKey { case "": // ignore case "x-ms-tags": if o.tags == nil { o.tags = make(map[string]string) } tags := strings.Split(value, ",") for _, tag := range tags { parts := strings.SplitN(tag, "=", 2) if len(parts) != 2 { return ui, fmt.Errorf("invalid tag %q", tag) } o.tags[parts[0]] = parts[1] } case "cache-control": ui.httpHeaders.BlobCacheControl = pString(value) case "content-disposition": ui.httpHeaders.BlobContentDisposition = pString(value) case "content-encoding": ui.httpHeaders.BlobContentEncoding = pString(value) case "content-language": ui.httpHeaders.BlobContentLanguage = pString(value) case "content-type": ui.httpHeaders.BlobContentType = pString(value) } } ui.blb = o.fs.getBlockBlobSVC(container, containerPath) return ui, nil } // Update the object with the contents of the io.Reader, modTime and size // // The new object may have been created if an error is returned func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { if o.accessTier == blob.AccessTierArchive { if o.fs.opt.ArchiveTierDelete { fs.Debugf(o, "deleting archive tier blob before updating") err = o.Remove(ctx) if err != nil { return fmt.Errorf("failed to delete archive blob before updating: %w", err) } } else { return errCantUpdateArchiveTierBlobs } } size := src.Size() multipartUpload := size < 0 || size > int64(o.fs.opt.ChunkSize) var ui uploadInfo if multipartUpload { ui, err = o.uploadMultipart(ctx, in, src, options...) } else { ui, err = o.prepareUpload(ctx, src, options) if err != nil { return fmt.Errorf("failed to prepare upload: %w", err) } err = o.uploadSinglepart(ctx, in, size, ui) } if err != nil { return err } // Refresh metadata on object if !ui.isDirMarker { o.clearMetaData() err = o.readMetaData(ctx) if err != nil { return err } } // If tier is not changed or not specified, do not attempt to invoke `SetBlobTier` operation if o.fs.opt.AccessTier == string(defaultAccessTier) || o.fs.opt.AccessTier == string(o.AccessTier()) { return nil } // Now, set blob tier based on configured access tier return o.SetTier(o.fs.opt.AccessTier) } // Remove an object func (o *Object) Remove(ctx context.Context) error { blb := o.getBlobSVC() opt := blob.DeleteOptions{} if o.fs.opt.DeleteSnapshots != "" { action := blob.DeleteSnapshotsOptionType(o.fs.opt.DeleteSnapshots) opt.DeleteSnapshots = &action } return o.fs.pacer.Call(func() (bool, error) { _, err := blb.Delete(ctx, &opt) return o.fs.shouldRetry(ctx, err) }) } // MimeType of an Object if known, "" otherwise func (o *Object) MimeType(ctx context.Context) string { return o.mimeType } // AccessTier of an object, default is of type none func (o *Object) AccessTier() blob.AccessTier { return o.accessTier } // SetTier performs changing object tier func (o *Object) SetTier(tier string) error { if !validateAccessTier(tier) { return fmt.Errorf("tier %s not supported by Azure Blob Storage", tier) } // Check if current tier already matches with desired tier if o.GetTier() == tier { return nil } desiredAccessTier := blob.AccessTier(tier) blb := o.getBlobSVC() ctx := context.Background() priority := blob.RehydratePriorityStandard opt := blob.SetTierOptions{ RehydratePriority: &priority, } err := o.fs.pacer.Call(func() (bool, error) { _, err := blb.SetTier(ctx, desiredAccessTier, &opt) return o.fs.shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("failed to set Blob Tier: %w", err) } // Set access tier on local object also, this typically // gets updated on get blob properties o.accessTier = desiredAccessTier fs.Debugf(o, "Successfully changed object tier to %s", tier) return nil } // GetTier returns object tier in azure as string func (o *Object) GetTier() string { return string(o.accessTier) } func parseTier(tier string) *blob.AccessTier { if tier == "" { return nil } msTier := blob.AccessTier(tier) return &msTier } // Check the interfaces are satisfied var ( _ fs.Fs = &Fs{} _ fs.Copier = &Fs{} _ fs.PutStreamer = &Fs{} _ fs.Purger = &Fs{} _ fs.ListRer = &Fs{} _ fs.OpenChunkWriter = &Fs{} _ fs.Object = &Object{} _ fs.MimeTyper = &Object{} _ fs.GetTierer = &Object{} _ fs.SetTierer = &Object{} ) rclone-v1.71.0/backend/azureblob/azureblob_internal_test.go000066400000000000000000000112721505210326400240740ustar00rootroot00000000000000//go:build !plan9 && !solaris && !js package azureblob import ( "context" "encoding/base64" "strings" "testing" "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/blockblob" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" "github.com/rclone/rclone/lib/random" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestBlockIDCreator(t *testing.T) { // Check creation and random number bic, err := newBlockIDCreator() require.NoError(t, err) bic2, err := newBlockIDCreator() require.NoError(t, err) assert.NotEqual(t, bic.random, bic2.random) assert.NotEqual(t, bic.random, [8]byte{}) // Set random to known value for tests bic.random = [8]byte{1, 2, 3, 4, 5, 6, 7, 8} chunkNumber := uint64(0xFEDCBA9876543210) // Check creation of ID want := base64.StdEncoding.EncodeToString([]byte{0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10, 1, 2, 3, 4, 5, 6, 7, 8}) assert.Equal(t, "/ty6mHZUMhABAgMEBQYHCA==", want) got := bic.newBlockID(chunkNumber) assert.Equal(t, want, got) assert.Equal(t, "/ty6mHZUMhABAgMEBQYHCA==", got) // Test checkID is working assert.NoError(t, bic.checkID(chunkNumber, got)) assert.ErrorContains(t, bic.checkID(chunkNumber, "$"+got), "illegal base64") assert.ErrorContains(t, bic.checkID(chunkNumber, "AAAA"+got), "bad block ID length") assert.ErrorContains(t, bic.checkID(chunkNumber+1, got), "expecting decoded") assert.ErrorContains(t, bic2.checkID(chunkNumber, got), "random bytes") } func (f *Fs) testFeatures(t *testing.T) { // Check first feature flags are set on this remote enabled := f.Features().SetTier assert.True(t, enabled) enabled = f.Features().GetTier assert.True(t, enabled) } type ReadSeekCloser struct { *strings.Reader } func (r *ReadSeekCloser) Close() error { return nil } // Stage a block at remote but don't commit it func (f *Fs) stageBlockWithoutCommit(ctx context.Context, t *testing.T, remote string) { var ( containerName, blobPath = f.split(remote) containerClient = f.cntSVC(containerName) blobClient = containerClient.NewBlockBlobClient(blobPath) data = "uncommitted data" blockID = "1" blockIDBase64 = base64.StdEncoding.EncodeToString([]byte(blockID)) ) r := &ReadSeekCloser{strings.NewReader(data)} _, err := blobClient.StageBlock(ctx, blockIDBase64, r, nil) require.NoError(t, err) // Verify the block is staged but not committed blockList, err := blobClient.GetBlockList(ctx, blockblob.BlockListTypeAll, nil) require.NoError(t, err) found := false for _, block := range blockList.UncommittedBlocks { if *block.Name == blockIDBase64 { found = true break } } require.True(t, found, "Block ID not found in uncommitted blocks") } // This tests uploading a blob where it has uncommitted blocks with a different ID size. // // https://gauravmantri.com/2013/05/18/windows-azure-blob-storage-dealing-with-the-specified-blob-or-block-content-is-invalid-error/ // // TestIntegration/FsMkdir/FsPutFiles/Internal/WriteUncommittedBlocks func (f *Fs) testWriteUncommittedBlocks(t *testing.T) { var ( ctx = context.Background() remote = "testBlob" ) // Multipart copy the blob please oldUseCopyBlob, oldCopyCutoff := f.opt.UseCopyBlob, f.opt.CopyCutoff f.opt.UseCopyBlob = false f.opt.CopyCutoff = f.opt.ChunkSize defer func() { f.opt.UseCopyBlob, f.opt.CopyCutoff = oldUseCopyBlob, oldCopyCutoff }() // Create a blob with uncommitted blocks f.stageBlockWithoutCommit(ctx, t, remote) // Now attempt to overwrite the block with a different sized block ID to provoke this error // Check the object does not exist _, err := f.NewObject(ctx, remote) require.Equal(t, fs.ErrorObjectNotFound, err) // Upload a multipart file over the block with uncommitted chunks of a different ID size size := 4*int(f.opt.ChunkSize) - 1 contents := random.String(size) item := fstest.NewItem(remote, contents, fstest.Time("2001-05-06T04:05:06.499Z")) o := fstests.PutTestContents(ctx, t, f, &item, contents, true) // Check size assert.Equal(t, int64(size), o.Size()) // Create a new blob with uncommitted blocks newRemote := "testBlob2" f.stageBlockWithoutCommit(ctx, t, newRemote) // Copy over that block dst, err := f.Copy(ctx, o, newRemote) require.NoError(t, err) // Check basics assert.Equal(t, int64(size), dst.Size()) assert.Equal(t, newRemote, dst.Remote()) // Check contents gotContents := fstests.ReadObject(ctx, t, dst, -1) assert.Equal(t, contents, gotContents) // Remove the object require.NoError(t, dst.Remove(ctx)) } func (f *Fs) InternalTest(t *testing.T) { t.Run("Features", f.testFeatures) t.Run("WriteUncommittedBlocks", f.testWriteUncommittedBlocks) } rclone-v1.71.0/backend/azureblob/azureblob_test.go000066400000000000000000000041171505210326400222000ustar00rootroot00000000000000// Test AzureBlob filesystem interface //go:build !plan9 && !solaris && !js package azureblob import ( "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" "github.com/stretchr/testify/assert" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { name := "TestAzureBlob" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":", NilObject: (*Object)(nil), TiersToTest: []string{"Hot", "Cool", "Cold"}, ChunkedUpload: fstests.ChunkedUploadConfig{ MinChunkSize: defaultChunkSize, }, ExtraConfig: []fstests.ExtraConfigItem{ {Name: name, Key: "use_copy_blob", Value: "false"}, }, }) } // TestIntegration2 runs integration tests against the remote func TestIntegration2(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("Skipping as -remote set") } name := "TestAzureBlob" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":", NilObject: (*Object)(nil), TiersToTest: []string{"Hot", "Cool", "Cold"}, ChunkedUpload: fstests.ChunkedUploadConfig{ MinChunkSize: defaultChunkSize, }, ExtraConfig: []fstests.ExtraConfigItem{ {Name: name, Key: "directory_markers", Value: "true"}, {Name: name, Key: "use_copy_blob", Value: "false"}, }, }) } func (f *Fs) SetUploadChunkSize(cs fs.SizeSuffix) (fs.SizeSuffix, error) { return f.setUploadChunkSize(cs) } func (f *Fs) SetCopyCutoff(cs fs.SizeSuffix) (fs.SizeSuffix, error) { return f.setCopyCutoff(cs) } var ( _ fstests.SetUploadChunkSizer = (*Fs)(nil) _ fstests.SetCopyCutoffer = (*Fs)(nil) ) func TestValidateAccessTier(t *testing.T) { tests := map[string]struct { accessTier string want bool }{ "hot": {"hot", true}, "HOT": {"HOT", true}, "Hot": {"Hot", true}, "cool": {"cool", true}, "cold": {"cold", true}, "archive": {"archive", true}, "empty": {"", false}, "unknown": {"unknown", false}, } for name, test := range tests { t.Run(name, func(t *testing.T) { got := validateAccessTier(test.accessTier) assert.Equal(t, test.want, got) }) } } rclone-v1.71.0/backend/azureblob/azureblob_unsupported.go000066400000000000000000000004041505210326400236040ustar00rootroot00000000000000// Build for azureblob for unsupported platforms to stop go complaining // about "no buildable Go source files " //go:build plan9 || solaris || js // Package azureblob provides an interface to the Microsoft Azure blob object storage system package azureblob rclone-v1.71.0/backend/azurefiles/000077500000000000000000000000001505210326400170065ustar00rootroot00000000000000rclone-v1.71.0/backend/azurefiles/azurefiles.go000066400000000000000000001311111505210326400215040ustar00rootroot00000000000000//go:build !plan9 && !js // Package azurefiles provides an interface to Microsoft Azure Files package azurefiles /* TODO This uses LastWriteTime which seems to work. The API return also has LastModified - needs investigation Needs pacer to have retries HTTP headers need to be passed Could support Metadata FIXME write mime type See FIXME markers Optional interfaces for Object - ID */ import ( "bytes" "context" "crypto/md5" "encoding/hex" "encoding/json" "errors" "fmt" "io" "net/http" "net/url" "os" "path" "strings" "sync" "time" "github.com/Azure/azure-sdk-for-go/sdk/azcore" "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" "github.com/Azure/azure-sdk-for-go/sdk/azidentity" "github.com/Azure/azure-sdk-for-go/sdk/storage/azfile/directory" "github.com/Azure/azure-sdk-for-go/sdk/storage/azfile/file" "github.com/Azure/azure-sdk-for-go/sdk/storage/azfile/fileerror" "github.com/Azure/azure-sdk-for-go/sdk/storage/azfile/service" "github.com/Azure/azure-sdk-for-go/sdk/storage/azfile/share" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/env" "github.com/rclone/rclone/lib/readers" ) const ( maxFileSize = 4 * fs.Tebi defaultChunkSize = 4 * fs.Mebi storageDefaultBaseURL = "file.core.windows.net" ) func init() { fs.Register(&fs.RegInfo{ Name: "azurefiles", Description: "Microsoft Azure Files", NewFs: NewFs, Options: []fs.Option{{ Name: "account", Help: `Azure Storage Account Name. Set this to the Azure Storage Account Name in use. Leave blank to use SAS URL or connection string, otherwise it needs to be set. If this is blank and if env_auth is set it will be read from the environment variable ` + "`AZURE_STORAGE_ACCOUNT_NAME`" + ` if possible. `, Sensitive: true, }, { Name: "share_name", Help: `Azure Files Share Name. This is required and is the name of the share to access. `, }, { Name: "env_auth", Help: `Read credentials from runtime (environment variables, CLI or MSI). See the [authentication docs](/azurefiles#authentication) for full info.`, Default: false, }, { Name: "key", Help: `Storage Account Shared Key. Leave blank to use SAS URL or connection string.`, Sensitive: true, }, { Name: "sas_url", Help: `SAS URL. Leave blank if using account/key or connection string.`, Sensitive: true, }, { Name: "connection_string", Help: `Azure Files Connection String.`, Sensitive: true, }, { Name: "tenant", Help: `ID of the service principal's tenant. Also called its directory ID. Set this if using - Service principal with client secret - Service principal with certificate - User with username and password `, Sensitive: true, }, { Name: "client_id", Help: `The ID of the client in use. Set this if using - Service principal with client secret - Service principal with certificate - User with username and password `, Sensitive: true, }, { Name: "client_secret", Help: `One of the service principal's client secrets Set this if using - Service principal with client secret `, Sensitive: true, }, { Name: "client_certificate_path", Help: `Path to a PEM or PKCS12 certificate file including the private key. Set this if using - Service principal with certificate `, }, { Name: "client_certificate_password", Help: `Password for the certificate file (optional). Optionally set this if using - Service principal with certificate And the certificate has a password. `, IsPassword: true, }, { Name: "client_send_certificate_chain", Help: `Send the certificate chain when using certificate auth. Specifies whether an authentication request will include an x5c header to support subject name / issuer based authentication. When set to true, authentication requests include the x5c header. Optionally set this if using - Service principal with certificate `, Default: false, Advanced: true, }, { Name: "username", Help: `User name (usually an email address) Set this if using - User with username and password `, Advanced: true, Sensitive: true, }, { Name: "password", Help: `The user's password Set this if using - User with username and password `, IsPassword: true, Advanced: true, }, { Name: "service_principal_file", Help: `Path to file containing credentials for use with a service principal. Leave blank normally. Needed only if you want to use a service principal instead of interactive login. $ az ad sp create-for-rbac --name "" \ --role "Storage Files Data Owner" \ --scopes "/subscriptions//resourceGroups//providers/Microsoft.Storage/storageAccounts//blobServices/default/containers/" \ > azure-principal.json See ["Create an Azure service principal"](https://docs.microsoft.com/en-us/cli/azure/create-an-azure-service-principal-azure-cli) and ["Assign an Azure role for access to files data"](https://docs.microsoft.com/en-us/azure/storage/common/storage-auth-aad-rbac-cli) pages for more details. **NB** this section needs updating for Azure Files - pull requests appreciated! It may be more convenient to put the credentials directly into the rclone config file under the ` + "`client_id`, `tenant` and `client_secret`" + ` keys instead of setting ` + "`service_principal_file`" + `. `, Advanced: true, }, { Name: "use_msi", Help: `Use a managed service identity to authenticate (only works in Azure). When true, use a [managed service identity](https://docs.microsoft.com/en-us/azure/active-directory/managed-identities-azure-resources/) to authenticate to Azure Storage instead of a SAS token or account key. If the VM(SS) on which this program is running has a system-assigned identity, it will be used by default. If the resource has no system-assigned but exactly one user-assigned identity, the user-assigned identity will be used by default. If the resource has multiple user-assigned identities, the identity to use must be explicitly specified using exactly one of the msi_object_id, msi_client_id, or msi_mi_res_id parameters.`, Default: false, Advanced: true, }, { Name: "msi_object_id", Help: "Object ID of the user-assigned MSI to use, if any.\n\nLeave blank if msi_client_id or msi_mi_res_id specified.", Advanced: true, Sensitive: true, }, { Name: "msi_client_id", Help: "Object ID of the user-assigned MSI to use, if any.\n\nLeave blank if msi_object_id or msi_mi_res_id specified.", Advanced: true, Sensitive: true, }, { Name: "msi_mi_res_id", Help: "Azure resource ID of the user-assigned MSI to use, if any.\n\nLeave blank if msi_client_id or msi_object_id specified.", Advanced: true, Sensitive: true, }, { Name: "disable_instance_discovery", Help: `Skip requesting Microsoft Entra instance metadata This should be set true only by applications authenticating in disconnected clouds, or private clouds such as Azure Stack. It determines whether rclone requests Microsoft Entra instance metadata from ` + "`https://login.microsoft.com/`" + ` before authenticating. Setting this to true will skip this request, making you responsible for ensuring the configured authority is valid and trustworthy. `, Default: false, Advanced: true, }, { Name: "use_az", Help: `Use Azure CLI tool az for authentication Set to use the [Azure CLI tool az](https://learn.microsoft.com/en-us/cli/azure/) as the sole means of authentication. Setting this can be useful if you wish to use the az CLI on a host with a System Managed Identity that you do not want to use. Don't set env_auth at the same time. `, Default: false, Advanced: true, }, { Name: "endpoint", Help: "Endpoint for the service.\n\nLeave blank normally.", Advanced: true, }, { Name: "chunk_size", Help: `Upload chunk size. Note that this is stored in memory and there may be up to "--transfers" * "--azurefile-upload-concurrency" chunks stored at once in memory.`, Default: defaultChunkSize, Advanced: true, }, { Name: "upload_concurrency", Help: `Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers. Note that chunks are stored in memory and there may be up to "--transfers" * "--azurefile-upload-concurrency" chunks stored at once in memory.`, Default: 16, Advanced: true, }, { Name: "max_stream_size", Help: strings.ReplaceAll(`Max size for streamed files. Azure files needs to know in advance how big the file will be. When rclone doesn't know it uses this value instead. This will be used when rclone is streaming data, the most common uses are: - Uploading files with |--vfs-cache-mode off| with |rclone mount| - Using |rclone rcat| - Copying files with unknown length You will need this much free space in the share as the file will be this size temporarily. `, "|", "`"), Default: 10 * fs.Gibi, Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: (encoder.EncodeDoubleQuote | encoder.EncodeBackSlash | encoder.EncodeSlash | encoder.EncodeColon | encoder.EncodePipe | encoder.EncodeLtGt | encoder.EncodeAsterisk | encoder.EncodeQuestion | encoder.EncodeInvalidUtf8 | encoder.EncodeCtl | encoder.EncodeDel | encoder.EncodeDot | encoder.EncodeRightPeriod), }}, }) } // Options defines the configuration for this backend type Options struct { Account string `config:"account"` ShareName string `config:"share_name"` EnvAuth bool `config:"env_auth"` Key string `config:"key"` SASURL string `config:"sas_url"` ConnectionString string `config:"connection_string"` Tenant string `config:"tenant"` ClientID string `config:"client_id"` ClientSecret string `config:"client_secret"` ClientCertificatePath string `config:"client_certificate_path"` ClientCertificatePassword string `config:"client_certificate_password"` ClientSendCertificateChain bool `config:"client_send_certificate_chain"` Username string `config:"username"` Password string `config:"password"` ServicePrincipalFile string `config:"service_principal_file"` DisableInstanceDiscovery bool `config:"disable_instance_discovery"` UseMSI bool `config:"use_msi"` MSIObjectID string `config:"msi_object_id"` MSIClientID string `config:"msi_client_id"` MSIResourceID string `config:"msi_mi_res_id"` UseAZ bool `config:"use_az"` Endpoint string `config:"endpoint"` ChunkSize fs.SizeSuffix `config:"chunk_size"` MaxStreamSize fs.SizeSuffix `config:"max_stream_size"` UploadConcurrency int `config:"upload_concurrency"` Enc encoder.MultiEncoder `config:"encoding"` } // Fs represents a root directory inside a share. The root directory can be "" type Fs struct { name string // name of this remote root string // the path we are working on if any opt Options // parsed config options features *fs.Features // optional features shareClient *share.Client // a client for the share itself svc *directory.Client // the root service } // Object describes a Azure File Share File type Object struct { fs *Fs // what this object is part of remote string // The remote path size int64 // Size of the object md5 []byte // MD5 hash if known modTime time.Time // The modified time of the object if known contentType string // content type if known } // Wrap the http.Transport to satisfy the Transporter interface type transporter struct { http.RoundTripper } // Make a new transporter func newTransporter(ctx context.Context) transporter { return transporter{ RoundTripper: fshttp.NewTransport(ctx), } } // Do sends the HTTP request and returns the HTTP response or error. func (tr transporter) Do(req *http.Request) (*http.Response, error) { return tr.RoundTripper.RoundTrip(req) } type servicePrincipalCredentials struct { AppID string `json:"appId"` Password string `json:"password"` Tenant string `json:"tenant"` } // parseServicePrincipalCredentials unmarshals a service principal credentials JSON file as generated by az cli. func parseServicePrincipalCredentials(ctx context.Context, credentialsData []byte) (*servicePrincipalCredentials, error) { var spCredentials servicePrincipalCredentials if err := json.Unmarshal(credentialsData, &spCredentials); err != nil { return nil, fmt.Errorf("error parsing credentials from JSON file: %w", err) } // TODO: support certificate credentials // Validate all fields present if spCredentials.AppID == "" || spCredentials.Password == "" || spCredentials.Tenant == "" { return nil, fmt.Errorf("missing fields in credentials file") } return &spCredentials, nil } // Factored out from NewFs so that it can be tested with opt *Options and without m configmap.Mapper func newFsFromOptions(ctx context.Context, name, root string, opt *Options) (fs.Fs, error) { // Client options specifying our own transport policyClientOptions := policy.ClientOptions{ Transport: newTransporter(ctx), } backup := service.ShareTokenIntentBackup clientOpt := service.ClientOptions{ ClientOptions: policyClientOptions, FileRequestIntent: &backup, } // Here we auth by setting one of cred, sharedKeyCred or f.client var ( cred azcore.TokenCredential sharedKeyCred *service.SharedKeyCredential client *service.Client err error ) switch { case opt.EnvAuth: // Read account from environment if needed if opt.Account == "" { opt.Account, _ = os.LookupEnv("AZURE_STORAGE_ACCOUNT_NAME") } // Read credentials from the environment options := azidentity.DefaultAzureCredentialOptions{ ClientOptions: policyClientOptions, DisableInstanceDiscovery: opt.DisableInstanceDiscovery, } cred, err = azidentity.NewDefaultAzureCredential(&options) if err != nil { return nil, fmt.Errorf("create azure environment credential failed: %w", err) } case opt.Account != "" && opt.Key != "": sharedKeyCred, err = service.NewSharedKeyCredential(opt.Account, opt.Key) if err != nil { return nil, fmt.Errorf("create new shared key credential failed: %w", err) } case opt.UseAZ: options := azidentity.AzureCLICredentialOptions{} cred, err = azidentity.NewAzureCLICredential(&options) fmt.Println(cred) if err != nil { return nil, fmt.Errorf("failed to create Azure CLI credentials: %w", err) } case opt.SASURL != "": client, err = service.NewClientWithNoCredential(opt.SASURL, &clientOpt) if err != nil { return nil, fmt.Errorf("unable to create SAS URL client: %w", err) } case opt.ConnectionString != "": client, err = service.NewClientFromConnectionString(opt.ConnectionString, &clientOpt) if err != nil { return nil, fmt.Errorf("unable to create connection string client: %w", err) } case opt.ClientID != "" && opt.Tenant != "" && opt.ClientSecret != "": // Service principal with client secret options := azidentity.ClientSecretCredentialOptions{ ClientOptions: policyClientOptions, } cred, err = azidentity.NewClientSecretCredential(opt.Tenant, opt.ClientID, opt.ClientSecret, &options) if err != nil { return nil, fmt.Errorf("error creating a client secret credential: %w", err) } case opt.ClientID != "" && opt.Tenant != "" && opt.ClientCertificatePath != "": // Service principal with certificate // // Read the certificate data, err := os.ReadFile(env.ShellExpand(opt.ClientCertificatePath)) if err != nil { return nil, fmt.Errorf("error reading client certificate file: %w", err) } // NewClientCertificateCredential requires at least one *x509.Certificate, and a // crypto.PrivateKey. // // ParseCertificates returns these given certificate data in PEM or PKCS12 format. // It handles common scenarios but has limitations, for example it doesn't load PEM // encrypted private keys. var password []byte if opt.ClientCertificatePassword != "" { pw, err := obscure.Reveal(opt.Password) if err != nil { return nil, fmt.Errorf("certificate password decode failed - did you obscure it?: %w", err) } password = []byte(pw) } certs, key, err := azidentity.ParseCertificates(data, password) if err != nil { return nil, fmt.Errorf("failed to parse client certificate file: %w", err) } options := azidentity.ClientCertificateCredentialOptions{ ClientOptions: policyClientOptions, SendCertificateChain: opt.ClientSendCertificateChain, } cred, err = azidentity.NewClientCertificateCredential( opt.Tenant, opt.ClientID, certs, key, &options, ) if err != nil { return nil, fmt.Errorf("create azure service principal with client certificate credential failed: %w", err) } case opt.ClientID != "" && opt.Tenant != "" && opt.Username != "" && opt.Password != "": // User with username and password //nolint:staticcheck // this is deprecated due to Azure policy options := azidentity.UsernamePasswordCredentialOptions{ ClientOptions: policyClientOptions, } password, err := obscure.Reveal(opt.Password) if err != nil { return nil, fmt.Errorf("user password decode failed - did you obscure it?: %w", err) } cred, err = azidentity.NewUsernamePasswordCredential( opt.Tenant, opt.ClientID, opt.Username, password, &options, ) if err != nil { return nil, fmt.Errorf("authenticate user with password failed: %w", err) } case opt.ServicePrincipalFile != "": // Loading service principal credentials from file. loadedCreds, err := os.ReadFile(env.ShellExpand(opt.ServicePrincipalFile)) if err != nil { return nil, fmt.Errorf("error opening service principal credentials file: %w", err) } parsedCreds, err := parseServicePrincipalCredentials(ctx, loadedCreds) if err != nil { return nil, fmt.Errorf("error parsing service principal credentials file: %w", err) } options := azidentity.ClientSecretCredentialOptions{ ClientOptions: policyClientOptions, } cred, err = azidentity.NewClientSecretCredential(parsedCreds.Tenant, parsedCreds.AppID, parsedCreds.Password, &options) if err != nil { return nil, fmt.Errorf("error creating a client secret credential: %w", err) } 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} 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") } var options azidentity.ManagedIdentityCredentialOptions switch { case opt.MSIClientID != "": options.ID = azidentity.ClientID(opt.MSIClientID) case opt.MSIObjectID != "": // FIXME this doesn't appear to be in the new SDK? return nil, fmt.Errorf("MSI object ID is currently unsupported") case opt.MSIResourceID != "": options.ID = azidentity.ResourceID(opt.MSIResourceID) } cred, err = azidentity.NewManagedIdentityCredential(&options) if err != nil { return nil, fmt.Errorf("failed to acquire MSI token: %w", err) } case opt.ClientID != "" && opt.Tenant != "" && opt.MSIClientID != "": // Workload Identity based authentication var options azidentity.ManagedIdentityCredentialOptions options.ID = azidentity.ClientID(opt.MSIClientID) msiCred, err := azidentity.NewManagedIdentityCredential(&options) if err != nil { return nil, fmt.Errorf("failed to acquire MSI token: %w", err) } getClientAssertions := func(context.Context) (string, error) { 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) } return token.Token, nil } assertOpts := &azidentity.ClientAssertionCredentialOptions{} cred, err = azidentity.NewClientAssertionCredential( opt.Tenant, opt.ClientID, getClientAssertions, assertOpts) if err != nil { return nil, fmt.Errorf("failed to acquire client assertion token: %w", err) } default: return nil, errors.New("no authentication method configured") } // Make the client if not already created if client == nil { // Work out what the endpoint is if it is still unset if opt.Endpoint == "" { if opt.Account == "" { return nil, fmt.Errorf("account must be set: can't make service URL") } u, err := url.Parse(fmt.Sprintf("https://%s.%s", opt.Account, storageDefaultBaseURL)) if err != nil { return nil, fmt.Errorf("failed to make azure storage URL from account: %w", err) } opt.Endpoint = u.String() } if sharedKeyCred != nil { // Shared key cred client, err = service.NewClientWithSharedKeyCredential(opt.Endpoint, sharedKeyCred, &clientOpt) if err != nil { return nil, fmt.Errorf("create client with shared key failed: %w", err) } } else if cred != nil { // Azidentity cred client, err = service.NewClient(opt.Endpoint, cred, &clientOpt) if err != nil { return nil, fmt.Errorf("create client failed: %w", err) } } } if client == nil { return nil, fmt.Errorf("internal error: auth failed to make credentials or client") } shareClient := client.NewShareClient(opt.ShareName) svc := shareClient.NewRootDirectoryClient() f := &Fs{ shareClient: shareClient, svc: svc, name: name, root: root, opt: *opt, } f.features = (&fs.Features{ CanHaveEmptyDirectories: true, PartialUploads: true, // files are visible as they are being uploaded CaseInsensitive: true, SlowHash: true, // calling Hash() generally takes an extra transaction ReadMimeType: true, WriteMimeType: true, }).Fill(ctx, f) // Check whether a file exists at this location _, propsErr := f.fileClient("").GetProperties(ctx, nil) if propsErr == nil { f.root = path.Dir(root) return f, fs.ErrorIsFile } return f, nil } // NewFs constructs an Fs from the root func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } return newFsFromOptions(ctx, name, root, opt) } // ------------------------------------------------------------ // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("azurefiles root '%s'", f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // Precision return the precision of this Fs // // One second. FileREST API times are in RFC1123 which in the example shows a precision of seconds // Source: https://learn.microsoft.com/en-us/rest/api/storageservices/representation-of-date-time-values-in-headers func (f *Fs) Precision() time.Duration { return time.Second } // Hashes returns the supported hash sets. // // MD5: since it is listed as header in the response for file properties // Source: https://learn.microsoft.com/en-us/rest/api/storageservices/get-file-properties func (f *Fs) Hashes() hash.Set { return hash.NewHashSet(hash.MD5) } // Encode remote and turn it into an absolute path in the share func (f *Fs) absPath(remote string) string { return f.opt.Enc.FromStandardPath(path.Join(f.root, remote)) } // Make a directory client from the dir func (f *Fs) dirClient(dir string) *directory.Client { return f.svc.NewSubdirectoryClient(f.absPath(dir)) } // Make a file client from the remote func (f *Fs) fileClient(remote string) *file.Client { return f.svc.NewFileClient(f.absPath(remote)) } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. // // Does not return ErrorIsDir when a directory exists instead of file. since the documentation // for [rclone.fs.Fs.NewObject] rqeuires no extra work to determine whether it is directory // // This initiates a network request and returns an error if object is not found. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { resp, err := f.fileClient(remote).GetProperties(ctx, nil) if fileerror.HasCode(err, fileerror.ParentNotFound, fileerror.ResourceNotFound) { return nil, fs.ErrorObjectNotFound } else if err != nil { return nil, fmt.Errorf("unable to find object remote %q: %w", remote, err) } o := &Object{ fs: f, remote: remote, } o.setMetadata(&resp) return o, nil } // Make a directory using the absolute path from the root of the share // // This recursiely creating parent directories all the way to the root // of the share. func (f *Fs) absMkdir(ctx context.Context, absPath string) error { if absPath == "" { return nil } dirClient := f.svc.NewSubdirectoryClient(absPath) // now := time.Now() // smbProps := &file.SMBProperties{ // LastWriteTime: &now, // } // dirCreateOptions := &directory.CreateOptions{ // FileSMBProperties: smbProps, // } _, createDirErr := dirClient.Create(ctx, nil) if fileerror.HasCode(createDirErr, fileerror.ParentNotFound) { parentDir := path.Dir(absPath) if parentDir == absPath { return fmt.Errorf("internal error: infinite recursion since parent and remote are equal") } makeParentErr := f.absMkdir(ctx, parentDir) if makeParentErr != nil { return fmt.Errorf("could not make parent of %q: %w", absPath, makeParentErr) } return f.absMkdir(ctx, absPath) } else if fileerror.HasCode(createDirErr, fileerror.ResourceAlreadyExists) { return nil } else if createDirErr != nil { return fmt.Errorf("unable to MkDir: %w", createDirErr) } return nil } // Mkdir creates nested directories func (f *Fs) Mkdir(ctx context.Context, remote string) error { return f.absMkdir(ctx, f.absPath(remote)) } // Make the parent directory of remote func (f *Fs) mkParentDir(ctx context.Context, remote string) error { // Can't make the parent of root if remote == "" { return nil } return f.Mkdir(ctx, path.Dir(remote)) } // Rmdir deletes the root folder // // Returns an error if it isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { dirClient := f.dirClient(dir) _, err := dirClient.Delete(ctx, nil) if err != nil { if fileerror.HasCode(err, fileerror.DirectoryNotEmpty) { return fs.ErrorDirectoryNotEmpty } else if fileerror.HasCode(err, fileerror.ResourceNotFound) { return fs.ErrorDirNotFound } return fmt.Errorf("could not rmdir dir %q: %w", dir, err) } return nil } // Put the object // // Copies the reader in to the new object. This new object is returned. // // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { // Temporary Object under construction fs := &Object{ fs: f, remote: src.Remote(), } return fs, fs.Update(ctx, in, src, options...) } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } // List the objects and directories in dir into entries. The entries can be // returned in any order but should be for a complete directory. // // dir should be "" to list the root, and should not have trailing slashes. // // This should return ErrDirNotFound if the directory isn't found. func (f *Fs) List(ctx context.Context, dir string) (fs.DirEntries, error) { var entries fs.DirEntries subDirClient := f.dirClient(dir) // Checking whether directory exists _, err := subDirClient.GetProperties(ctx, nil) if fileerror.HasCode(err, fileerror.ParentNotFound, fileerror.ResourceNotFound) { return entries, fs.ErrorDirNotFound } else if err != nil { return entries, err } opt := &directory.ListFilesAndDirectoriesOptions{ Include: directory.ListFilesInclude{ Timestamps: true, }, } pager := subDirClient.NewListFilesAndDirectoriesPager(opt) for pager.More() { resp, err := pager.NextPage(ctx) if err != nil { return entries, err } for _, directory := range resp.Segment.Directories { // Name *string `xml:"Name"` // Attributes *string `xml:"Attributes"` // ID *string `xml:"FileId"` // PermissionKey *string `xml:"PermissionKey"` // Properties.ContentLength *int64 `xml:"Content-Length"` // Properties.ChangeTime *time.Time `xml:"ChangeTime"` // Properties.CreationTime *time.Time `xml:"CreationTime"` // Properties.ETag *azcore.ETag `xml:"Etag"` // Properties.LastAccessTime *time.Time `xml:"LastAccessTime"` // Properties.LastModified *time.Time `xml:"Last-Modified"` // Properties.LastWriteTime *time.Time `xml:"LastWriteTime"` var modTime time.Time if directory.Properties.LastWriteTime != nil { modTime = *directory.Properties.LastWriteTime } leaf := f.opt.Enc.ToStandardPath(*directory.Name) entry := fs.NewDir(path.Join(dir, leaf), modTime) if directory.ID != nil { entry.SetID(*directory.ID) } if directory.Properties.ContentLength != nil { entry.SetSize(*directory.Properties.ContentLength) } entries = append(entries, entry) } for _, file := range resp.Segment.Files { leaf := f.opt.Enc.ToStandardPath(*file.Name) entry := &Object{ fs: f, remote: path.Join(dir, leaf), } if file.Properties.ContentLength != nil { entry.size = *file.Properties.ContentLength } if file.Properties.LastWriteTime != nil { entry.modTime = *file.Properties.LastWriteTime } entries = append(entries, entry) } } return entries, nil } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Size of object in bytes func (o *Object) Size() int64 { return o.size } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // fileClient makes a specialized client for this object func (o *Object) fileClient() *file.Client { return o.fs.fileClient(o.remote) } // set the metadata from file.GetPropertiesResponse func (o *Object) setMetadata(resp *file.GetPropertiesResponse) { if resp.ContentLength != nil { o.size = *resp.ContentLength } o.md5 = resp.ContentMD5 if resp.FileLastWriteTime != nil { o.modTime = *resp.FileLastWriteTime } if resp.ContentType != nil { o.contentType = *resp.ContentType } } // getMetadata gets the metadata if it hasn't already been fetched func (o *Object) getMetadata(ctx context.Context) error { resp, err := o.fileClient().GetProperties(ctx, nil) if err != nil { return fmt.Errorf("failed to fetch properties: %w", err) } o.setMetadata(&resp) return nil } // Hash returns the MD5 of an object returning a lowercase hex string // // May make a network request because the [fs.List] method does not // return MD5 hashes for DirEntry func (o *Object) Hash(ctx context.Context, ty hash.Type) (string, error) { if ty != hash.MD5 { return "", hash.ErrUnsupported } if len(o.md5) == 0 { err := o.getMetadata(ctx) if err != nil { return "", err } } return hex.EncodeToString(o.md5), nil } // MimeType returns the content type of the Object if // known, or "" if not func (o *Object) MimeType(ctx context.Context) string { if o.contentType == "" { err := o.getMetadata(ctx) if err != nil { fs.Errorf(o, "Failed to fetch Content-Type") } } return o.contentType } // Storable returns a boolean showing whether this object storable func (o *Object) Storable() bool { return true } // ModTime returns the modification time of the object // // Returns time.Now() if not present func (o *Object) ModTime(ctx context.Context) time.Time { if o.modTime.IsZero() { return time.Now() } return o.modTime } // SetModTime sets the modification time func (o *Object) SetModTime(ctx context.Context, t time.Time) error { opt := file.SetHTTPHeadersOptions{ SMBProperties: &file.SMBProperties{ LastWriteTime: &t, }, HTTPHeaders: &file.HTTPHeaders{ ContentMD5: o.md5, ContentType: &o.contentType, }, } _, err := o.fileClient().SetHTTPHeaders(ctx, &opt) if err != nil { return fmt.Errorf("unable to set modTime: %w", err) } o.modTime = t return nil } // Remove an object func (o *Object) Remove(ctx context.Context) error { if _, err := o.fileClient().Delete(ctx, nil); err != nil { return fmt.Errorf("unable to delete remote %q: %w", o.remote, err) } return nil } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { // Offset and Count for range download var offset int64 var count int64 fs.FixRangeOption(options, o.size) for _, option := range options { switch x := option.(type) { case *fs.RangeOption: offset, count = x.Decode(o.size) if count < 0 { count = o.size - offset } case *fs.SeekOption: offset = x.Offset default: if option.Mandatory() { fs.Logf(o, "Unsupported mandatory option: %v", option) } } } opt := file.DownloadStreamOptions{ Range: file.HTTPRange{ Offset: offset, Count: count, }, } resp, err := o.fileClient().DownloadStream(ctx, &opt) if err != nil { return nil, fmt.Errorf("could not open remote %q: %w", o.remote, err) } return resp.Body, nil } // Returns a pointer to t - useful for returning pointers to constants func ptr[T any](t T) *T { return &t } var warnStreamUpload sync.Once // Update the object with the contents of the io.Reader, modTime, size and MD5 hash func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { var ( size = src.Size() sizeUnknown = false hashUnknown = true fc = o.fileClient() isNewlyCreated = o.modTime.IsZero() counter *readers.CountingReader md5Hash []byte hasher = md5.New() ) if size > int64(maxFileSize) { return fmt.Errorf("update: max supported file size is %vB. provided size is %vB", maxFileSize, fs.SizeSuffix(size)) } else if size < 0 { size = int64(o.fs.opt.MaxStreamSize) sizeUnknown = true warnStreamUpload.Do(func() { fs.Logf(o.fs, "Streaming uploads will have maximum file size of %v - adjust with --azurefiles-max-stream-size", o.fs.opt.MaxStreamSize) }) } if isNewlyCreated { // Make parent directory if mkDirErr := o.fs.mkParentDir(ctx, src.Remote()); mkDirErr != nil { return fmt.Errorf("update: unable to make parent directories: %w", mkDirErr) } // Create the file at the size given if _, createErr := fc.Create(ctx, size, nil); createErr != nil { return fmt.Errorf("update: unable to create file: %w", createErr) } } else if size != o.Size() { // Resize the file if needed if _, resizeErr := fc.Resize(ctx, size, nil); resizeErr != nil { return fmt.Errorf("update: unable to resize while trying to update: %w ", resizeErr) } } // Measure the size if it is unknown if sizeUnknown { counter = readers.NewCountingReader(in) in = counter } // Check we have a source MD5 hash... if hashStr, err := src.Hash(ctx, hash.MD5); err == nil && hashStr != "" { md5Hash, err = hex.DecodeString(hashStr) if err == nil { hashUnknown = false } else { fs.Errorf(o, "internal error: decoding hex encoded md5 %q: %v", hashStr, err) } } // ...if not calculate one if hashUnknown { in = io.TeeReader(in, hasher) } // Upload the file opt := file.UploadStreamOptions{ ChunkSize: int64(o.fs.opt.ChunkSize), Concurrency: o.fs.opt.UploadConcurrency, } if err := fc.UploadStream(ctx, in, &opt); err != nil { // Remove partially uploaded file on error if isNewlyCreated { if _, delErr := fc.Delete(ctx, nil); delErr != nil { fs.Errorf(o, "failed to delete partially uploaded file: %v", delErr) } } return fmt.Errorf("update: failed to upload stream: %w", err) } if sizeUnknown { // Read the uploaded size - the file will be truncated to that size by updateSizeHashModTime size = int64(counter.BytesRead()) } if hashUnknown { md5Hash = hasher.Sum(nil) } // Update the properties modTime := src.ModTime(ctx) contentType := fs.MimeType(ctx, src) httpHeaders := file.HTTPHeaders{ ContentMD5: md5Hash, ContentType: &contentType, } // Apply upload options (also allows one to overwrite content-type) for _, option := range options { key, value := option.Header() lowerKey := strings.ToLower(key) switch lowerKey { case "cache-control": httpHeaders.CacheControl = &value case "content-disposition": httpHeaders.ContentDisposition = &value case "content-encoding": httpHeaders.ContentEncoding = &value case "content-language": httpHeaders.ContentLanguage = &value case "content-type": httpHeaders.ContentType = &value } } _, err = fc.SetHTTPHeaders(ctx, &file.SetHTTPHeadersOptions{ FileContentLength: &size, SMBProperties: &file.SMBProperties{ LastWriteTime: &modTime, }, HTTPHeaders: &httpHeaders, }) if err != nil { return fmt.Errorf("update: failed to set properties: %w", err) } // Make sure Object is in sync o.size = size o.md5 = md5Hash o.modTime = modTime o.contentType = contentType return nil } // Move src to this remote using server-side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't move - not same remote type") return nil, fs.ErrorCantMove } err := f.mkParentDir(ctx, remote) if err != nil { return nil, fmt.Errorf("Move: mkParentDir failed: %w", err) } opt := file.RenameOptions{ IgnoreReadOnly: ptr(true), ReplaceIfExists: ptr(true), } dstAbsPath := f.absPath(remote) fc := srcObj.fileClient() _, err = fc.Rename(ctx, dstAbsPath, &opt) if err != nil { return nil, fmt.Errorf("Move: Rename failed: %w", err) } dstObj, err := f.NewObject(ctx, remote) if err != nil { return nil, fmt.Errorf("Move: NewObject failed: %w", err) } return dstObj, nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { dstFs := f srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } _, err := dstFs.dirClient(dstRemote).GetProperties(ctx, nil) if err == nil { return fs.ErrorDirExists } if !fileerror.HasCode(err, fileerror.ParentNotFound, fileerror.ResourceNotFound) { return fmt.Errorf("DirMove: failed to get status of destination directory: %w", err) } err = dstFs.mkParentDir(ctx, dstRemote) if err != nil { return fmt.Errorf("DirMove: mkParentDir failed: %w", err) } opt := directory.RenameOptions{ IgnoreReadOnly: ptr(false), ReplaceIfExists: ptr(false), } dstAbsPath := dstFs.absPath(dstRemote) dirClient := srcFs.dirClient(srcRemote) _, err = dirClient.Rename(ctx, dstAbsPath, &opt) if err != nil { if fileerror.HasCode(err, fileerror.ResourceAlreadyExists) { return fs.ErrorDirExists } return fmt.Errorf("DirMove: Rename failed: %w", err) } return nil } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't copy - not same remote type") return nil, fs.ErrorCantCopy } err := f.mkParentDir(ctx, remote) if err != nil { return nil, fmt.Errorf("Copy: mkParentDir failed: %w", err) } opt := file.StartCopyFromURLOptions{ CopyFileSMBInfo: &file.CopyFileSMBInfo{ Attributes: file.SourceCopyFileAttributes{}, ChangeTime: file.SourceCopyFileChangeTime{}, CreationTime: file.SourceCopyFileCreationTime{}, LastWriteTime: file.SourceCopyFileLastWriteTime{}, PermissionCopyMode: ptr(file.PermissionCopyModeTypeSource), IgnoreReadOnly: ptr(true), }, } srcURL := srcObj.fileClient().URL() fc := f.fileClient(remote) _, err = fc.StartCopyFromURL(ctx, srcURL, &opt) if err != nil { return nil, fmt.Errorf("Copy failed: %w", err) } dstObj, err := f.NewObject(ctx, remote) if err != nil { return nil, fmt.Errorf("Copy: NewObject failed: %w", err) } return dstObj, nil } // Implementation of WriterAt type writerAt struct { ctx context.Context f *Fs fc *file.Client mu sync.Mutex // protects variables below size int64 } // Adaptor to add a Close method to bytes.Reader type bytesReaderCloser struct { *bytes.Reader } // Close the bytesReaderCloser func (bytesReaderCloser) Close() error { return nil } // WriteAt writes len(p) bytes from p to the underlying data stream // at offset off. It returns the number of bytes written from p (0 <= n <= len(p)) // and any error encountered that caused the write to stop early. // WriteAt must return a non-nil error if it returns n < len(p). // // If WriteAt is writing to a destination with a seek offset, // WriteAt should not affect nor be affected by the underlying // seek offset. // // Clients of WriteAt can execute parallel WriteAt calls on the same // destination if the ranges do not overlap. // // Implementations must not retain p. func (w *writerAt) WriteAt(p []byte, off int64) (n int, err error) { endOffset := off + int64(len(p)) w.mu.Lock() if w.size < endOffset { _, err = w.fc.Resize(w.ctx, endOffset, nil) if err != nil { w.mu.Unlock() return 0, fmt.Errorf("WriteAt: failed to resize file: %w ", err) } w.size = endOffset } w.mu.Unlock() in := bytesReaderCloser{bytes.NewReader(p)} _, err = w.fc.UploadRange(w.ctx, off, in, nil) if err != nil { return 0, err } return len(p), nil } // Close the writer func (w *writerAt) Close() error { // FIXME should we be doing something here? 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) { err := f.mkParentDir(ctx, remote) if err != nil { return nil, fmt.Errorf("OpenWriterAt: failed to create parent directory: %w", err) } fc := f.fileClient(remote) if size < 0 { size = 0 } _, err = fc.Create(ctx, size, nil) if err != nil { return nil, fmt.Errorf("OpenWriterAt: unable to create file: %w", err) } w := &writerAt{ ctx: ctx, f: f, fc: fc, size: size, } return w, nil } // About gets quota information func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { stats, err := f.shareClient.GetStatistics(ctx, nil) if err != nil { return nil, fmt.Errorf("failed to read share statistics: %w", err) } usage := &fs.Usage{ Used: stats.ShareUsageBytes, // bytes in use } return usage, nil } // Check the interfaces are satisfied var ( _ fs.Fs = &Fs{} _ fs.PutStreamer = &Fs{} _ fs.Abouter = &Fs{} _ fs.Mover = &Fs{} _ fs.DirMover = &Fs{} _ fs.Copier = &Fs{} _ fs.OpenWriterAter = &Fs{} _ fs.Object = &Object{} _ fs.MimeTyper = &Object{} ) rclone-v1.71.0/backend/azurefiles/azurefiles_internal_test.go000066400000000000000000000026451505210326400244500ustar00rootroot00000000000000//go:build !plan9 && !js package azurefiles import ( "context" "math/rand" "strings" "testing" "github.com/rclone/rclone/fstest/fstests" "github.com/stretchr/testify/assert" ) func (f *Fs) InternalTest(t *testing.T) { t.Run("Authentication", f.InternalTestAuth) } var _ fstests.InternalTester = (*Fs)(nil) func (f *Fs) InternalTestAuth(t *testing.T) { t.Skip("skipping since this requires authentication credentials which are not part of repo") shareName := "test-rclone-oct-2023" testCases := []struct { name string options *Options }{ { name: "ConnectionString", options: &Options{ ShareName: shareName, ConnectionString: "", }, }, { name: "AccountAndKey", options: &Options{ ShareName: shareName, Account: "", Key: "", }}, { name: "SASUrl", options: &Options{ ShareName: shareName, SASURL: "", }}, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { fs, err := newFsFromOptions(context.TODO(), "TestAzureFiles", "", tc.options) assert.NoError(t, err) dirName := randomString(10) assert.NoError(t, fs.Mkdir(context.TODO(), dirName)) }) } } const chars = "abcdefghijklmnopqrstuvwzyxABCDEFGHIJKLMNOPQRSTUVWZYX" func randomString(charCount int) string { strBldr := strings.Builder{} for range charCount { randPos := rand.Int63n(52) strBldr.WriteByte(chars[randPos]) } return strBldr.String() } rclone-v1.71.0/backend/azurefiles/azurefiles_test.go000066400000000000000000000004051505210326400225440ustar00rootroot00000000000000//go:build !plan9 && !js package azurefiles import ( "testing" "github.com/rclone/rclone/fstest/fstests" ) func TestIntegration(t *testing.T) { var objPtr *Object fstests.Run(t, &fstests.Opt{ RemoteName: "TestAzureFiles:", NilObject: objPtr, }) } rclone-v1.71.0/backend/azurefiles/azurefiles_unsupported.go000066400000000000000000000003431505210326400241560ustar00rootroot00000000000000// Build for azurefiles for unsupported platforms to stop go complaining // about "no buildable Go source files " //go:build plan9 || js // Package azurefiles provides an interface to Microsoft Azure Files package azurefiles rclone-v1.71.0/backend/b2/000077500000000000000000000000001505210326400151405ustar00rootroot00000000000000rclone-v1.71.0/backend/b2/api/000077500000000000000000000000001505210326400157115ustar00rootroot00000000000000rclone-v1.71.0/backend/b2/api/types.go000066400000000000000000000515571505210326400174210ustar00rootroot00000000000000// Package api provides types used by the Backblaze B2 API. package api import ( "fmt" "strconv" "time" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/lib/version" ) // Error describes a B2 error response type Error struct { Status int `json:"status"` // The numeric HTTP status code. Always matches the status in the HTTP response. Code string `json:"code"` // A single-identifier code that identifies the error. Message string `json:"message"` // A human-readable message, in English, saying what went wrong. } // Error satisfies the error interface func (e *Error) Error() string { return fmt.Sprintf("%s (%d %s)", e.Message, e.Status, e.Code) } // Fatal satisfies the Fatal interface // // It indicates which errors should be treated as fatal func (e *Error) Fatal() bool { return e.Status == 403 // 403 errors shouldn't be retried } var _ fserrors.Fataler = (*Error)(nil) // Bucket describes a B2 bucket type Bucket struct { ID string `json:"bucketId"` AccountID string `json:"accountId"` Name string `json:"bucketName"` Type string `json:"bucketType"` LifecycleRules []LifecycleRule `json:"lifecycleRules,omitempty"` } // LifecycleRule is a single lifecycle rule type LifecycleRule struct { DaysFromHidingToDeleting *int `json:"daysFromHidingToDeleting"` DaysFromUploadingToHiding *int `json:"daysFromUploadingToHiding"` DaysFromStartingToCancelingUnfinishedLargeFiles *int `json:"daysFromStartingToCancelingUnfinishedLargeFiles"` FileNamePrefix string `json:"fileNamePrefix"` } // Timestamp is a UTC time when this file was uploaded. It is a base // 10 number of milliseconds since midnight, January 1, 1970 UTC. This // fits in a 64 bit integer such as the type "long" in the programming // language Java. It is intended to be compatible with Java's time // long. For example, it can be passed directly into the java call // Date.setTime(long time). type Timestamp time.Time // MarshalJSON turns a Timestamp into JSON (in UTC) func (t *Timestamp) MarshalJSON() (out []byte, err error) { timestamp := (*time.Time)(t).UTC().UnixNano() return []byte(strconv.FormatInt(timestamp/1e6, 10)), nil } // UnmarshalJSON turns JSON into a Timestamp func (t *Timestamp) UnmarshalJSON(data []byte) error { timestamp, err := strconv.ParseInt(string(data), 10, 64) if err != nil { return err } *t = Timestamp(time.Unix(timestamp/1e3, (timestamp%1e3)*1e6).UTC()) return nil } // HasVersion returns true if it looks like the passed filename has a timestamp on it. // // Note that the passed filename's timestamp may still be invalid even if this // function returns true. func HasVersion(remote string) bool { return version.Match(remote) } // AddVersion adds the timestamp as a version string into the filename passed in. func (t Timestamp) AddVersion(remote string) string { return version.Add(remote, time.Time(t)) } // RemoveVersion removes the timestamp from a filename as a version string. // // It returns the new file name and a timestamp, or the old filename // and a zero timestamp. func RemoveVersion(remote string) (t Timestamp, newRemote string) { time, newRemote := version.Remove(remote) t = Timestamp(time) return } // IsZero returns true if the timestamp is uninitialized func (t Timestamp) IsZero() bool { return time.Time(t).IsZero() } // Equal compares two timestamps // // If either are !IsZero then it returns false func (t Timestamp) Equal(s Timestamp) bool { if time.Time(t).IsZero() { return false } if time.Time(s).IsZero() { return false } return time.Time(t).Equal(time.Time(s)) } // File is info about a file type File struct { ID string `json:"fileId"` // The unique identifier for this version of this file. Used with b2_get_file_info, b2_download_file_by_id, and b2_delete_file_version. Name string `json:"fileName"` // The name of this file, which can be used with b2_download_file_by_name. Action string `json:"action"` // Either "upload" or "hide". "upload" means a file that was uploaded to B2 Cloud Storage. "hide" means a file version marking the file as hidden, so that it will not show up in b2_list_file_names. The result of b2_list_file_names will contain only "upload". The result of b2_list_file_versions may have both. Size int64 `json:"size"` // The number of bytes in the file. UploadTimestamp Timestamp `json:"uploadTimestamp"` // This is a UTC time when this file was uploaded. SHA1 string `json:"contentSha1"` // The SHA1 of the bytes stored in the file. ContentType string `json:"contentType"` // The MIME type of the file. Info map[string]string `json:"fileInfo"` // The custom information that was uploaded with the file. This is a JSON object, holding the name/value pairs that were uploaded with the file. } // AuthorizeAccountResponse is as returned from the b2_authorize_account call type AuthorizeAccountResponse struct { AbsoluteMinimumPartSize int `json:"absoluteMinimumPartSize"` // The smallest possible size of a part of a large file. AccountID string `json:"accountId"` // The identifier for the account. Allowed struct { // An object (see below) containing the capabilities of this auth token, and any restrictions on using it. BucketID string `json:"bucketId"` // When present, access is restricted to one bucket. BucketName string `json:"bucketName"` // When present, name of bucket - may be empty Capabilities []string `json:"capabilities"` // A list of strings, each one naming a capability the key has. NamePrefix any `json:"namePrefix"` // When present, access is restricted to files whose names start with the prefix } `json:"allowed"` APIURL string `json:"apiUrl"` // The base URL to use for all API calls except for uploading and downloading files. AuthorizationToken string `json:"authorizationToken"` // An authorization token to use with all calls, other than b2_authorize_account, that need an Authorization header. DownloadURL string `json:"downloadUrl"` // The base URL to use for downloading files. MinimumPartSize int `json:"minimumPartSize"` // DEPRECATED: This field will always have the same value as recommendedPartSize. Use recommendedPartSize instead. RecommendedPartSize int `json:"recommendedPartSize"` // The recommended size for each part of a large file. We recommend using this part size for optimal upload performance. } // ListBucketsRequest is parameters for b2_list_buckets call type ListBucketsRequest struct { AccountID string `json:"accountId"` // The identifier for the account. BucketID string `json:"bucketId,omitempty"` // When specified, the result will be a list containing just this bucket. BucketName string `json:"bucketName,omitempty"` // When specified, the result will be a list containing just this bucket. BucketTypes []string `json:"bucketTypes,omitempty"` // If present, B2 will use it as a filter for bucket types returned in the list buckets response. } // ListBucketsResponse is as returned from the b2_list_buckets call type ListBucketsResponse struct { Buckets []Bucket `json:"buckets"` } // ListFileNamesRequest is as passed to b2_list_file_names or b2_list_file_versions type ListFileNamesRequest struct { BucketID string `json:"bucketId"` // required - The bucket to look for file names in. StartFileName string `json:"startFileName,omitempty"` // optional - The first file name to return. If there is a file with this name, it will be returned in the list. If not, the first file name after this the first one after this name. MaxFileCount int `json:"maxFileCount,omitempty"` // optional - The maximum number of files to return from this call. The default value is 100, and the maximum allowed is 1000. StartFileID string `json:"startFileId,omitempty"` // optional - What to pass in to startFileId for the next search to continue where this one left off. Prefix string `json:"prefix,omitempty"` // optional - Files returned will be limited to those with the given prefix. Defaults to the empty string, which matches all files. Delimiter string `json:"delimiter,omitempty"` // Files returned will be limited to those within the top folder, or any one subfolder. Defaults to NULL. Folder names will also be returned. The delimiter character will be used to "break" file names into folders. } // ListFileNamesResponse is as received from b2_list_file_names or b2_list_file_versions type ListFileNamesResponse struct { Files []File `json:"files"` // An array of objects, each one describing one file. NextFileName *string `json:"nextFileName"` // What to pass in to startFileName for the next search to continue where this one left off, or null if there are no more files. NextFileID *string `json:"nextFileId"` // What to pass in to startFileId for the next search to continue where this one left off, or null if there are no more files. } // GetUploadURLRequest is passed to b2_get_upload_url type GetUploadURLRequest struct { BucketID string `json:"bucketId"` // The ID of the bucket that you want to upload to. } // GetUploadURLResponse is received from b2_get_upload_url type GetUploadURLResponse struct { BucketID string `json:"bucketId"` // The unique ID of the bucket. UploadURL string `json:"uploadUrl"` // The URL that can be used to upload files to this bucket, see b2_upload_file. AuthorizationToken string `json:"authorizationToken"` // The authorizationToken that must be used when uploading files to this bucket, see b2_upload_file. } // GetDownloadAuthorizationRequest is passed to b2_get_download_authorization type GetDownloadAuthorizationRequest struct { BucketID string `json:"bucketId"` // The ID of the bucket that you want to upload to. FileNamePrefix string `json:"fileNamePrefix"` // The file name prefix of files the download authorization token will allow access to. ValidDurationInSeconds int64 `json:"validDurationInSeconds"` // The number of seconds before the authorization token will expire. The minimum value is 1 second. The maximum value is 604800 which is one week in seconds. B2ContentDisposition string `json:"b2ContentDisposition,omitempty"` // optional - If this is present, download requests using the returned authorization must include the same value for b2ContentDisposition. } // GetDownloadAuthorizationResponse is received from b2_get_download_authorization type GetDownloadAuthorizationResponse struct { BucketID string `json:"bucketId"` // The unique ID of the bucket. FileNamePrefix string `json:"fileNamePrefix"` // The file name prefix of files the download authorization token will allow access to. AuthorizationToken string `json:"authorizationToken"` // The authorizationToken that must be used when downloading files, see b2_download_file_by_name. } // FileInfo is received from b2_upload_file, b2_get_file_info and b2_finish_large_file type FileInfo struct { ID string `json:"fileId"` // The unique identifier for this version of this file. Used with b2_get_file_info, b2_download_file_by_id, and b2_delete_file_version. Name string `json:"fileName"` // The name of this file, which can be used with b2_download_file_by_name. Action string `json:"action"` // Either "upload" or "hide". "upload" means a file that was uploaded to B2 Cloud Storage. "hide" means a file version marking the file as hidden, so that it will not show up in b2_list_file_names. The result of b2_list_file_names will contain only "upload". The result of b2_list_file_versions may have both. AccountID string `json:"accountId"` // Your account ID. BucketID string `json:"bucketId"` // The bucket that the file is in. Size int64 `json:"contentLength"` // The number of bytes stored in the file. UploadTimestamp Timestamp `json:"uploadTimestamp"` // This is a UTC time when this file was uploaded. SHA1 string `json:"contentSha1"` // The SHA1 of the bytes stored in the file. ContentType string `json:"contentType"` // The MIME type of the file. Info map[string]string `json:"fileInfo"` // The custom information that was uploaded with the file. This is a JSON object, holding the name/value pairs that were uploaded with the file. } // CreateBucketRequest is used to create a bucket type CreateBucketRequest struct { AccountID string `json:"accountId"` Name string `json:"bucketName"` Type string `json:"bucketType"` LifecycleRules []LifecycleRule `json:"lifecycleRules,omitempty"` } // DeleteBucketRequest is used to create a bucket type DeleteBucketRequest struct { ID string `json:"bucketId"` AccountID string `json:"accountId"` } // DeleteFileRequest is used to delete a file version type DeleteFileRequest struct { ID string `json:"fileId"` // The ID of the file, as returned by b2_upload_file, b2_list_file_names, or b2_list_file_versions. Name string `json:"fileName"` // The name of this file. } // HideFileRequest is used to delete a file type HideFileRequest struct { BucketID string `json:"bucketId"` // The bucket containing the file to hide. Name string `json:"fileName"` // The name of the file to hide. } // GetFileInfoRequest is used to return a FileInfo struct with b2_get_file_info type GetFileInfoRequest struct { ID string `json:"fileId"` // The ID of the file, as returned by b2_upload_file, b2_list_file_names, or b2_list_file_versions. } // StartLargeFileRequest (b2_start_large_file) Prepares for uploading the parts of a large file. // // If the original source of the file being uploaded has a last // modified time concept, Backblaze recommends using // src_last_modified_millis as the name, and a string holding the base // 10 number of milliseconds since midnight, January 1, 1970 // UTC. This fits in a 64 bit integer such as the type "long" in the // programming language Java. It is intended to be compatible with // Java's time long. For example, it can be passed directly into the // Java call Date.setTime(long time). // // If the caller knows the SHA1 of the entire large file being // uploaded, Backblaze recommends using large_file_sha1 as the name, // and a 40 byte hex string representing the SHA1. // // Example: { "src_last_modified_millis" : "1452802803026", "large_file_sha1" : "a3195dc1e7b46a2ff5da4b3c179175b75671e80d", "color": "blue" } type StartLargeFileRequest struct { BucketID string `json:"bucketId"` //The ID of the bucket that the file will go in. Name string `json:"fileName"` // The name of the file. See Files for requirements on file names. ContentType string `json:"contentType"` // The MIME type of the content of the file, which will be returned in the Content-Type header when downloading the file. Use the Content-Type b2/x-auto to automatically set the stored Content-Type post upload. In the case where a file extension is absent or the lookup fails, the Content-Type is set to application/octet-stream. Info map[string]string `json:"fileInfo"` // A JSON object holding the name/value pairs for the custom file info. } // StartLargeFileResponse is the response to StartLargeFileRequest type StartLargeFileResponse struct { ID string `json:"fileId"` // The unique identifier for this version of this file. Used with b2_get_file_info, b2_download_file_by_id, and b2_delete_file_version. Name string `json:"fileName"` // The name of this file, which can be used with b2_download_file_by_name. AccountID string `json:"accountId"` // The identifier for the account. BucketID string `json:"bucketId"` // The unique ID of the bucket. ContentType string `json:"contentType"` // The MIME type of the file. Info map[string]string `json:"fileInfo"` // The custom information that was uploaded with the file. This is a JSON object, holding the name/value pairs that were uploaded with the file. UploadTimestamp Timestamp `json:"uploadTimestamp"` // This is a UTC time when this file was uploaded. } // GetUploadPartURLRequest is passed to b2_get_upload_part_url type GetUploadPartURLRequest struct { ID string `json:"fileId"` // The unique identifier of the file being uploaded. } // GetUploadPartURLResponse is received from b2_get_upload_url type GetUploadPartURLResponse struct { ID string `json:"fileId"` // The unique identifier of the file being uploaded. UploadURL string `json:"uploadUrl"` // The URL that can be used to upload files to this bucket, see b2_upload_part. AuthorizationToken string `json:"authorizationToken"` // The authorizationToken that must be used when uploading files to this bucket, see b2_upload_part. } // UploadPartResponse is the response to b2_upload_part type UploadPartResponse struct { ID string `json:"fileId"` // The unique identifier of the file being uploaded. PartNumber int64 `json:"partNumber"` // Which part this is (starting from 1) Size int64 `json:"contentLength"` // The number of bytes stored in the file. SHA1 string `json:"contentSha1"` // The SHA1 of the bytes stored in the file. } // FinishLargeFileRequest is passed to b2_finish_large_file // // The response is a FileInfo object (with extra AccountID and BucketID fields which we ignore). // // Large files do not have a SHA1 checksum. The value will always be "none". type FinishLargeFileRequest struct { ID string `json:"fileId"` // The unique identifier of the file being uploaded. SHA1s []string `json:"partSha1Array"` // A JSON array of hex SHA1 checksums of the parts of the large file. This is a double-check that the right parts were uploaded in the right order, and that none were missed. Note that the part numbers start at 1, and the SHA1 of the part 1 is the first string in the array, at index 0. } // CancelLargeFileRequest is passed to b2_finish_large_file // // The response is a CancelLargeFileResponse type CancelLargeFileRequest struct { ID string `json:"fileId"` // The unique identifier of the file being uploaded. } // CancelLargeFileResponse is the response to CancelLargeFileRequest type CancelLargeFileResponse struct { ID string `json:"fileId"` // The unique identifier of the file being uploaded. Name string `json:"fileName"` // The name of this file. AccountID string `json:"accountId"` // The identifier for the account. BucketID string `json:"bucketId"` // The unique ID of the bucket. } // CopyFileRequest is as passed to b2_copy_file type CopyFileRequest struct { SourceID string `json:"sourceFileId"` // The ID of the source file being copied. Name string `json:"fileName"` // The name of the new file being created. Range string `json:"range,omitempty"` // The range of bytes to copy. If not provided, the whole source file will be copied. MetadataDirective string `json:"metadataDirective,omitempty"` // The strategy for how to populate metadata for the new file: COPY or REPLACE ContentType string `json:"contentType,omitempty"` // The MIME type of the content of the file (REPLACE only) Info map[string]string `json:"fileInfo,omitempty"` // This field stores the metadata that will be stored with the file. (REPLACE only) DestBucketID string `json:"destinationBucketId,omitempty"` // The destination ID of the bucket if set, if not the source bucket will be used } // CopyPartRequest is the request for b2_copy_part - the response is UploadPartResponse type CopyPartRequest struct { SourceID string `json:"sourceFileId"` // The ID of the source file being copied. LargeFileID string `json:"largeFileId"` // The ID of the large file the part will belong to, as returned by b2_start_large_file. PartNumber int64 `json:"partNumber"` // Which part this is (starting from 1) Range string `json:"range,omitempty"` // The range of bytes to copy. If not provided, the whole source file will be copied. } // UpdateBucketRequest describes a request to modify a B2 bucket type UpdateBucketRequest struct { ID string `json:"bucketId"` AccountID string `json:"accountId"` Type string `json:"bucketType,omitempty"` LifecycleRules []LifecycleRule `json:"lifecycleRules,omitempty"` } rclone-v1.71.0/backend/b2/api/types_test.go000066400000000000000000000032631505210326400204470ustar00rootroot00000000000000package api_test import ( "testing" "time" "github.com/rclone/rclone/backend/b2/api" "github.com/rclone/rclone/fstest" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var ( emptyT api.Timestamp t0 = api.Timestamp(fstest.Time("1970-01-01T01:01:01.123456789Z")) t1 = api.Timestamp(fstest.Time("2001-02-03T04:05:06.123000000Z")) ) func TestTimestampMarshalJSON(t *testing.T) { resB, err := t0.MarshalJSON() res := string(resB) require.NoError(t, err) assert.Equal(t, "3661123", res) resB, err = t1.MarshalJSON() res = string(resB) require.NoError(t, err) assert.Equal(t, "981173106123", res) } func TestTimestampUnmarshalJSON(t *testing.T) { var tActual api.Timestamp err := tActual.UnmarshalJSON([]byte("981173106123")) require.NoError(t, err) assert.Equal(t, (time.Time)(t1), (time.Time)(tActual)) } func TestTimestampIsZero(t *testing.T) { assert.True(t, emptyT.IsZero()) assert.False(t, t0.IsZero()) assert.False(t, t1.IsZero()) } func TestTimestampEqual(t *testing.T) { assert.False(t, emptyT.Equal(emptyT)) //nolint:gocritic // Don't include gocritic when running golangci-lint to avoid dupArg: suspicious method call with the same argument and receiver assert.False(t, t0.Equal(emptyT)) assert.False(t, emptyT.Equal(t0)) assert.False(t, t0.Equal(t1)) assert.False(t, t1.Equal(t0)) assert.True(t, t0.Equal(t0)) //nolint:gocritic // Don't include gocritic when running golangci-lint to avoid dupArg: suspicious method call with the same argument and receiver assert.True(t, t1.Equal(t1)) //nolint:gocritic // Don't include gocritic when running golangci-lint to avoid dupArg: suspicious method call with the same argument and receiver } rclone-v1.71.0/backend/b2/b2.go000066400000000000000000002212201505210326400157710ustar00rootroot00000000000000// Package b2 provides an interface to the Backblaze B2 object storage system. package b2 // FIXME should we remove sha1 checks from here as rclone now supports // checking SHA1s? import ( "bufio" "bytes" "context" "crypto/sha1" "encoding/json" "errors" "fmt" gohash "hash" "io" "net/http" "path" "slices" "strconv" "strings" "sync" "time" "github.com/rclone/rclone/backend/b2/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/lib/bucket" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/multipart" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/pool" "github.com/rclone/rclone/lib/rest" ) const ( defaultEndpoint = "https://api.backblazeb2.com" headerPrefix = "x-bz-info-" // lower case as that is what the server returns timeKey = "src_last_modified_millis" timeHeader = headerPrefix + timeKey sha1Key = "large_file_sha1" sha1Header = "X-Bz-Content-Sha1" testModeHeader = "X-Bz-Test-Mode" idHeader = "X-Bz-File-Id" nameHeader = "X-Bz-File-Name" timestampHeader = "X-Bz-Upload-Timestamp" retryAfterHeader = "Retry-After" minSleep = 10 * time.Millisecond maxSleep = 5 * time.Minute decayConstant = 1 // bigger for slower decay, exponential maxParts = 10000 maxVersions = 100 // maximum number of versions we search in --b2-versions mode minChunkSize = 5 * fs.Mebi defaultChunkSize = 96 * fs.Mebi defaultUploadCutoff = 200 * fs.Mebi largeFileCopyCutoff = 4 * fs.Gibi // 5E9 is the max defaultMaxAge = 24 * time.Hour ) // Globals var ( errNotWithVersions = errors.New("can't modify or delete files in --b2-versions mode") errNotWithVersionAt = errors.New("can't modify or delete files in --b2-version-at mode") ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "b2", Description: "Backblaze B2", NewFs: NewFs, CommandHelp: commandHelp, Options: []fs.Option{{ Name: "account", Help: "Account ID or Application Key ID.", Required: true, Sensitive: true, }, { Name: "key", Help: "Application Key.", Required: true, Sensitive: true, }, { Name: "endpoint", Help: "Endpoint for the service.\n\nLeave blank normally.", Advanced: true, }, { Name: "test_mode", Help: `A flag string for X-Bz-Test-Mode header for debugging. This is for debugging purposes only. Setting it to one of the strings below will cause b2 to return specific errors: * "fail_some_uploads" * "expire_some_account_authorization_tokens" * "force_cap_exceeded" These will be set in the "X-Bz-Test-Mode" header which is documented in the [b2 integrations checklist](https://www.backblaze.com/docs/cloud-storage-integration-checklist).`, Default: "", Hide: fs.OptionHideConfigurator, Advanced: true, }, { Name: "versions", Help: "Include old versions in directory listings.\n\nNote that when using this no file write operations are permitted,\nso you can't upload files or delete them.", Default: false, Advanced: true, }, { Name: "version_at", Help: "Show file versions as they were at the specified time.\n\nNote that when using this no file write operations are permitted,\nso you can't upload files or delete them.", Default: fs.Time{}, Advanced: true, }, { Name: "hard_delete", Help: "Permanently delete files on remote removal, otherwise hide files.", Default: false, }, { Name: "upload_cutoff", Help: `Cutoff for switching to chunked upload. Files above this size will be uploaded in chunks of "--b2-chunk-size". This value should be set no larger than 4.657 GiB (== 5 GB).`, Default: defaultUploadCutoff, Advanced: true, }, { Name: "copy_cutoff", Help: `Cutoff for switching to multipart copy. Any files larger than this that need to be server-side copied will be copied in chunks of this size. The minimum is 0 and the maximum is 4.6 GiB.`, Default: largeFileCopyCutoff, Advanced: true, }, { Name: "chunk_size", Help: `Upload chunk size. When uploading large files, chunk the file into this size. Must fit in memory. These chunks are buffered in memory and there might a maximum of "--transfers" chunks in progress at once. 5,000,000 Bytes is the minimum size.`, Default: defaultChunkSize, Advanced: true, }, { Name: "upload_concurrency", Help: `Concurrency for multipart uploads. This is the number of chunks of the same file that are uploaded concurrently. Note that chunks are stored in memory and there may be up to "--transfers" * "--b2-upload-concurrency" chunks stored at once in memory.`, Default: 4, Advanced: true, }, { Name: "disable_checksum", Help: `Disable checksums for large (> upload cutoff) files. Normally rclone will calculate the SHA1 checksum of the input before uploading it so it can add it to metadata on the object. This is great for data integrity checking but can cause long delays for large files to start uploading.`, Default: false, Advanced: true, }, { Name: "download_url", Help: `Custom endpoint for downloads. This is usually set to a Cloudflare CDN URL as Backblaze offers free egress for data downloaded through the Cloudflare network. Rclone works with private buckets by sending an "Authorization" header. If the custom endpoint rewrites the requests for authentication, e.g., in Cloudflare Workers, this header needs to be handled properly. Leave blank if you want to use the endpoint provided by Backblaze. The URL provided here SHOULD have the protocol and SHOULD NOT have a trailing slash or specify the /file/bucket subpath as rclone will request files with "{download_url}/file/{bucket_name}/{path}". Example: > https://mysubdomain.mydomain.tld (No trailing "/", "file" or "bucket")`, Advanced: true, }, { Name: "download_auth_duration", Help: `Time before the public link authorization token will expire in s or suffix ms|s|m|h|d. This is used in combination with "rclone link" for making files accessible to the public and sets the duration before the download authorization token will expire. The minimum value is 1 second. The maximum value is one week.`, Default: fs.Duration(7 * 24 * time.Hour), Advanced: true, }, { Name: "memory_pool_flush_time", Default: fs.Duration(time.Minute), Advanced: true, Hide: fs.OptionHideBoth, Help: `How often internal memory buffer pools will be flushed. (no longer used)`, }, { Name: "memory_pool_use_mmap", Default: false, Advanced: true, Hide: fs.OptionHideBoth, Help: `Whether to use mmap buffers in internal memory pool. (no longer used)`, }, { Name: "lifecycle", Help: `Set the number of days deleted files should be kept when creating a bucket. On bucket creation, this parameter is used to create a lifecycle rule for the entire bucket. If lifecycle is 0 (the default) it does not create a lifecycle rule so the default B2 behaviour applies. This is to create versions of files on delete and overwrite and to keep them indefinitely. If lifecycle is >0 then it creates a single rule setting the number of days before a file that is deleted or overwritten is deleted permanently. This is known as daysFromHidingToDeleting in the b2 docs. The minimum value for this parameter is 1 day. You can also enable hard_delete in the config also which will mean deletions won't cause versions but overwrites will still cause versions to be made. See: [rclone backend lifecycle](#lifecycle) for setting lifecycles after bucket creation. `, Default: 0, Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, // See: https://www.backblaze.com/docs/cloud-storage-files // Encode invalid UTF-8 bytes as json doesn't handle them properly. // FIXME: allow /, but not leading, trailing or double Default: (encoder.Display | encoder.EncodeBackSlash | encoder.EncodeInvalidUtf8), }}, }) } // Options defines the configuration for this backend type Options struct { Account string `config:"account"` Key string `config:"key"` Endpoint string `config:"endpoint"` TestMode string `config:"test_mode"` Versions bool `config:"versions"` VersionAt fs.Time `config:"version_at"` HardDelete bool `config:"hard_delete"` UploadCutoff fs.SizeSuffix `config:"upload_cutoff"` CopyCutoff fs.SizeSuffix `config:"copy_cutoff"` ChunkSize fs.SizeSuffix `config:"chunk_size"` UploadConcurrency int `config:"upload_concurrency"` DisableCheckSum bool `config:"disable_checksum"` DownloadURL string `config:"download_url"` DownloadAuthorizationDuration fs.Duration `config:"download_auth_duration"` Lifecycle int `config:"lifecycle"` Enc encoder.MultiEncoder `config:"encoding"` } // Fs represents a remote b2 server type Fs struct { name string // name of this remote root string // the path we are working on if any opt Options // parsed config options ci *fs.ConfigInfo // global config features *fs.Features // optional features srv *rest.Client // the connection to the b2 server rootBucket string // bucket part of root (if any) rootDirectory string // directory part of root (if any) cache *bucket.Cache // cache for bucket creation status bucketIDMutex sync.Mutex // mutex to protect _bucketID _bucketID map[string]string // the ID of the bucket we are working on bucketTypeMutex sync.Mutex // mutex to protect _bucketType _bucketType map[string]string // the Type of the bucket we are working on info api.AuthorizeAccountResponse // result of authorize call uploadMu sync.Mutex // lock for upload variable uploads map[string][]*api.GetUploadURLResponse // Upload URLs by buckedID authMu sync.Mutex // lock for authorizing the account pacer *fs.Pacer // To pace and retry the API calls uploadToken *pacer.TokenDispenser // control concurrency } // Object describes a b2 object type Object struct { fs *Fs // what this object is part of remote string // The remote path id string // b2 id of the file modTime time.Time // The modified time of the object if known sha1 string // SHA-1 hash if known size int64 // Size of the object mimeType string // Content-Type of the object } // ------------------------------------------------------------ // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { if f.rootBucket == "" { return "B2 root" } if f.rootDirectory == "" { return fmt.Sprintf("B2 bucket %s", f.rootBucket) } return fmt.Sprintf("B2 bucket %s path %s", f.rootBucket, f.rootDirectory) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // parsePath parses a remote 'url' func parsePath(path string) (root string) { root = strings.Trim(path, "/") return } // split returns bucket and bucketPath from the rootRelativePath // relative to f.root func (f *Fs) split(rootRelativePath string) (bucketName, bucketPath string) { return bucket.Split(path.Join(f.root, rootRelativePath)) } // split returns bucket and bucketPath from the object func (o *Object) split() (bucket, bucketPath string) { return o.fs.split(o.remote) } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 401, // Unauthorized (e.g. "Token has expired") 408, // Request Timeout 429, // Rate exceeded. 500, // Get occasional 500 Internal Server Error 503, // Service Unavailable 504, // Gateway Time-out } // shouldRetryNoReauth returns a boolean as to whether this resp and err // deserve to be retried. It returns the err as a convenience func (f *Fs) shouldRetryNoReauth(ctx context.Context, resp *http.Response, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } // For 429 or 503 errors look at the Retry-After: header and // set the retry appropriately, starting with a minimum of 1 // second if it isn't set. if resp != nil && (resp.StatusCode == 429 || resp.StatusCode == 503) { var retryAfter = 1 retryAfterString := resp.Header.Get(retryAfterHeader) if retryAfterString != "" { var err error retryAfter, err = strconv.Atoi(retryAfterString) if err != nil { fs.Errorf(f, "Malformed %s header %q: %v", retryAfterHeader, retryAfterString, err) } } return true, pacer.RetryAfterError(err, time.Duration(retryAfter)*time.Second) } return fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(resp, retryErrorCodes), err } // shouldRetry returns a boolean as to whether this resp and err // deserve to be retried. It returns the err as a convenience func (f *Fs) shouldRetry(ctx context.Context, resp *http.Response, err error) (bool, error) { if resp != nil && resp.StatusCode == 401 { fs.Debugf(f, "Unauthorized: %v", err) // Reauth authErr := f.authorizeAccount(ctx) if authErr != nil { err = authErr } return true, err } return f.shouldRetryNoReauth(ctx, resp, err) } // errorHandler parses a non 2xx error response into an error func errorHandler(resp *http.Response) error { body, err := rest.ReadBody(resp) if err != nil { fs.Errorf(nil, "Couldn't read error out of body: %v", err) body = nil } // Decode error response if there was one - they can be blank errResponse := new(api.Error) if len(body) > 0 { err = json.Unmarshal(body, errResponse) if err != nil { fs.Errorf(nil, "Couldn't decode error response: %v", err) } } if errResponse.Code == "" { errResponse.Code = "unknown" } if errResponse.Status == 0 { errResponse.Status = resp.StatusCode } if errResponse.Message == "" { errResponse.Message = "Unknown " + resp.Status } return errResponse } func checkUploadChunkSize(cs fs.SizeSuffix) error { if cs < minChunkSize { return fmt.Errorf("%s is less than %s", cs, minChunkSize) } return nil } func (f *Fs) setUploadChunkSize(cs fs.SizeSuffix) (old fs.SizeSuffix, err error) { err = checkUploadChunkSize(cs) if err == nil { old, f.opt.ChunkSize = f.opt.ChunkSize, cs } return } func checkUploadCutoff(opt *Options, cs fs.SizeSuffix) error { if cs < opt.ChunkSize { return fmt.Errorf("%v is less than chunk size %v", cs, opt.ChunkSize) } return nil } func (f *Fs) setUploadCutoff(cs fs.SizeSuffix) (old fs.SizeSuffix, err error) { err = checkUploadCutoff(&f.opt, cs) if err == nil { old, f.opt.UploadCutoff = f.opt.UploadCutoff, cs } return } func (f *Fs) setCopyCutoff(cs fs.SizeSuffix) (old fs.SizeSuffix, err error) { err = checkUploadChunkSize(cs) if err == nil { old, f.opt.CopyCutoff = f.opt.CopyCutoff, cs } return } // setRoot changes the root of the Fs func (f *Fs) setRoot(root string) { f.root = parsePath(root) f.rootBucket, f.rootDirectory = bucket.Split(f.root) } // NewFs constructs an Fs from the path, bucket:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } if opt.UploadCutoff < opt.ChunkSize { opt.UploadCutoff = opt.ChunkSize fs.Infof(nil, "b2: raising upload cutoff to chunk size: %v", opt.UploadCutoff) } err = checkUploadCutoff(opt, opt.UploadCutoff) if err != nil { return nil, fmt.Errorf("b2: upload cutoff: %w", err) } err = checkUploadChunkSize(opt.ChunkSize) if err != nil { return nil, fmt.Errorf("b2: chunk size: %w", err) } if opt.Account == "" { return nil, errors.New("account not found") } if opt.Key == "" { return nil, errors.New("key not found") } if opt.Endpoint == "" { opt.Endpoint = defaultEndpoint } ci := fs.GetConfig(ctx) f := &Fs{ name: name, opt: *opt, ci: ci, srv: rest.NewClient(fshttp.NewClient(ctx)).SetErrorHandler(errorHandler), cache: bucket.NewCache(), _bucketID: make(map[string]string, 1), _bucketType: make(map[string]string, 1), uploads: make(map[string][]*api.GetUploadURLResponse), pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), uploadToken: pacer.NewTokenDispenser(ci.Transfers), } f.setRoot(root) f.features = (&fs.Features{ ReadMimeType: true, WriteMimeType: true, BucketBased: true, BucketBasedRootOK: true, ChunkWriterDoesntSeek: true, }).Fill(ctx, f) // Set the test flag if required if opt.TestMode != "" { testMode := strings.TrimSpace(opt.TestMode) f.srv.SetHeader(testModeHeader, testMode) fs.Debugf(f, "Setting test header \"%s: %s\"", testModeHeader, testMode) } err = f.authorizeAccount(ctx) if err != nil { return nil, fmt.Errorf("failed to authorize account: %w", err) } // If this is a key limited to a single bucket, it must exist already if f.rootBucket != "" && f.info.Allowed.BucketID != "" { allowedBucket := f.opt.Enc.ToStandardName(f.info.Allowed.BucketName) if allowedBucket == "" { return nil, errors.New("bucket that application key is restricted to no longer exists") } if allowedBucket != f.rootBucket { return nil, fmt.Errorf("you must use bucket %q with this application key", allowedBucket) } f.cache.MarkOK(f.rootBucket) f.setBucketID(f.rootBucket, f.info.Allowed.BucketID) } if f.rootBucket != "" && f.rootDirectory != "" { // Check to see if the (bucket,directory) is actually an existing file oldRoot := f.root newRoot, leaf := path.Split(oldRoot) f.setRoot(newRoot) _, err := f.NewObject(ctx, leaf) if err != nil { // File doesn't exist so return old f f.setRoot(oldRoot) return f, nil } // return an error with an fs which points to the parent return f, fs.ErrorIsFile } return f, nil } // authorizeAccount gets the API endpoint and auth token. Can be used // for reauthentication too. func (f *Fs) authorizeAccount(ctx context.Context) error { f.authMu.Lock() defer f.authMu.Unlock() opts := rest.Opts{ Method: "GET", Path: "/b2api/v1/b2_authorize_account", RootURL: f.opt.Endpoint, UserName: f.opt.Account, Password: f.opt.Key, ExtraHeaders: map[string]string{"Authorization": ""}, // unset the Authorization for this request } err := f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, nil, &f.info) return f.shouldRetryNoReauth(ctx, resp, err) }) if err != nil { return fmt.Errorf("failed to authenticate: %w", err) } f.srv.SetRoot(f.info.APIURL+"/b2api/v1").SetHeader("Authorization", f.info.AuthorizationToken) return nil } // hasPermission returns if the current AuthorizationToken has the selected permission func (f *Fs) hasPermission(permission string) bool { return slices.Contains(f.info.Allowed.Capabilities, permission) } // getUploadURL returns the upload info with the UploadURL and the AuthorizationToken // // This should be returned with returnUploadURL when finished func (f *Fs) getUploadURL(ctx context.Context, bucket string) (upload *api.GetUploadURLResponse, err error) { f.uploadMu.Lock() defer f.uploadMu.Unlock() bucketID, err := f.getBucketID(ctx, bucket) if err != nil { return nil, err } // look for a stored upload URL for the correct bucketID uploads := f.uploads[bucketID] if len(uploads) > 0 { upload, uploads = uploads[0], uploads[1:] f.uploads[bucketID] = uploads return upload, nil } // get a new upload URL since not found opts := rest.Opts{ Method: "POST", Path: "/b2_get_upload_url", } var request = api.GetUploadURLRequest{ BucketID: bucketID, } err = f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, &request, &upload) return f.shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("failed to get upload URL: %w", err) } return upload, nil } // returnUploadURL returns the UploadURL to the cache func (f *Fs) returnUploadURL(upload *api.GetUploadURLResponse) { if upload == nil { return } f.uploadMu.Lock() f.uploads[upload.BucketID] = append(f.uploads[upload.BucketID], upload) f.uploadMu.Unlock() } // clearUploadURL clears the current UploadURL and the AuthorizationToken func (f *Fs) clearUploadURL(bucketID string) { f.uploadMu.Lock() delete(f.uploads, bucketID) f.uploadMu.Unlock() } // getRW gets a RW buffer and an upload token // // If noBuf is set then it just gets an upload token func (f *Fs) getRW(noBuf bool) (rw *pool.RW) { f.uploadToken.Get() if !noBuf { rw = multipart.NewRW() } return rw } // putRW returns a RW buffer to the memory pool and returns an upload // token // // If buf is nil then it just returns the upload token func (f *Fs) putRW(rw *pool.RW) { if rw != nil { _ = rw.Close() } f.uploadToken.Put() } // Return an Object from a path // // If it can't be found it returns the error fs.ErrorObjectNotFound. func (f *Fs) newObjectWithInfo(ctx context.Context, remote string, info *api.File) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } if info != nil { err := o.decodeMetaData(info) if err != nil { return nil, err } } else { err := o.readMetaData(ctx) // reads info and headers, returning an error if err != nil { return nil, err } } return o, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return f.newObjectWithInfo(ctx, remote, nil) } // listFn is called from list to handle an object type listFn func(remote string, object *api.File, isDirectory bool) error // errEndList is a sentinel used to end the list iteration now. // listFn should return it to end the iteration with no errors. var errEndList = errors.New("end list") // list lists the objects into the function supplied from // the bucket and root supplied // // (bucket, directory) is the starting directory // // If prefix is set then it is removed from all file names. // // If addBucket is set then it adds the bucket to the start of the // remotes generated. // // If recurse is set the function will recursively list. // // If limit is > 0 then it limits to that many files (must be less // than 1000). // // If hidden is set then it will list the hidden (deleted) files too. // // if findFile is set it will look for files called (bucket, directory) func (f *Fs) list(ctx context.Context, bucket, directory, prefix string, addBucket bool, recurse bool, limit int, hidden bool, findFile bool, fn listFn) error { if !findFile { if prefix != "" { prefix += "/" } if directory != "" { directory += "/" } } delimiter := "" if !recurse { delimiter = "/" } bucketID, err := f.getBucketID(ctx, bucket) if err != nil { return err } chunkSize := 1000 if limit > 0 { chunkSize = limit } var request = api.ListFileNamesRequest{ BucketID: bucketID, MaxFileCount: chunkSize, Prefix: f.opt.Enc.FromStandardPath(directory), Delimiter: delimiter, } if directory != "" { request.StartFileName = f.opt.Enc.FromStandardPath(directory) } opts := rest.Opts{ Method: "POST", Path: "/b2_list_file_names", } if hidden || f.opt.VersionAt.IsSet() { opts.Path = "/b2_list_file_versions" } lastFileName := "" for { var response api.ListFileNamesResponse err := f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, &request, &response) return f.shouldRetry(ctx, resp, err) }) if err != nil { return err } for i := range response.Files { file := &response.Files[i] file.Name = f.opt.Enc.ToStandardPath(file.Name) // Finish if file name no longer has prefix if prefix != "" && !strings.HasPrefix(file.Name, prefix) { return nil } if !strings.HasPrefix(file.Name, prefix) { fs.Debugf(f, "Odd name received %q", file.Name) continue } remote := file.Name[len(prefix):] // Check for directory isDirectory := remote == "" || strings.HasSuffix(remote, "/") if isDirectory && len(remote) > 1 { remote = remote[:len(remote)-1] } if addBucket { remote = path.Join(bucket, remote) } if f.opt.VersionAt.IsSet() { if time.Time(file.UploadTimestamp).After(time.Time(f.opt.VersionAt)) { // Ignore versions that were created after the specified time continue } if file.Name == lastFileName { // Ignore versions before the already returned version continue } } // Send object lastFileName = file.Name err = fn(remote, file, isDirectory) if err != nil { if err == errEndList { return nil } return err } } // end if no NextFileName if response.NextFileName == nil { break } request.StartFileName = *response.NextFileName if response.NextFileID != nil { request.StartFileID = *response.NextFileID } } return nil } // Convert a list item into a DirEntry func (f *Fs) itemToDirEntry(ctx context.Context, remote string, object *api.File, isDirectory bool, last *string) (fs.DirEntry, error) { if isDirectory { d := fs.NewDir(remote, time.Time{}) return d, nil } if remote == *last { remote = object.UploadTimestamp.AddVersion(remote) } else { *last = remote } // hide objects represent deleted files which we don't list if object.Action == "hide" { return nil, nil } o, err := f.newObjectWithInfo(ctx, remote, object) if err != nil { return nil, err } return o, nil } // listDir lists a single directory func (f *Fs) listDir(ctx context.Context, bucket, directory, prefix string, addBucket bool) (entries fs.DirEntries, err error) { last := "" err = f.list(ctx, bucket, directory, prefix, f.rootBucket == "", false, 0, f.opt.Versions, false, func(remote string, object *api.File, isDirectory bool) error { entry, err := f.itemToDirEntry(ctx, remote, object, isDirectory, &last) if err != nil { return err } if entry != nil { entries = append(entries, entry) } return nil }) if err != nil { return nil, err } // bucket must be present if listing succeeded f.cache.MarkOK(bucket) return entries, nil } // listBuckets returns all the buckets to out func (f *Fs) listBuckets(ctx context.Context) (entries fs.DirEntries, err error) { err = f.listBucketsToFn(ctx, "", func(bucket *api.Bucket) error { d := fs.NewDir(bucket.Name, time.Time{}) entries = append(entries, d) return nil }) if err != nil { return nil, err } return entries, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { bucket, directory := f.split(dir) if bucket == "" { if directory != "" { return nil, fs.ErrorListBucketRequired } return f.listBuckets(ctx) } return f.listDir(ctx, bucket, directory, f.rootDirectory, f.rootBucket == "") } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively that doing a directory traversal. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { bucket, directory := f.split(dir) list := list.NewHelper(callback) listR := func(bucket, directory, prefix string, addBucket bool) error { last := "" return f.list(ctx, bucket, directory, prefix, addBucket, true, 0, f.opt.Versions, false, func(remote string, object *api.File, isDirectory bool) error { entry, err := f.itemToDirEntry(ctx, remote, object, isDirectory, &last) if err != nil { return err } return list.Add(entry) }) } if bucket == "" { entries, err := f.listBuckets(ctx) if err != nil { return err } for _, entry := range entries { err = list.Add(entry) if err != nil { return err } bucket := entry.Remote() err = listR(bucket, "", f.rootDirectory, true) if err != nil { return err } // bucket must be present if listing succeeded f.cache.MarkOK(bucket) } } else { err = listR(bucket, directory, f.rootDirectory, f.rootBucket == "") if err != nil { return err } // bucket must be present if listing succeeded f.cache.MarkOK(bucket) } return list.Flush() } // listBucketFn is called from listBucketsToFn to handle a bucket type listBucketFn func(*api.Bucket) error // listBucketsToFn lists the buckets to the function supplied func (f *Fs) listBucketsToFn(ctx context.Context, bucketName string, fn listBucketFn) error { var account = api.ListBucketsRequest{ AccountID: f.info.AccountID, BucketID: f.info.Allowed.BucketID, } if bucketName != "" && account.BucketID == "" { account.BucketName = f.opt.Enc.FromStandardName(bucketName) } var response api.ListBucketsResponse opts := rest.Opts{ Method: "POST", Path: "/b2_list_buckets", } err := f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, &account, &response) return f.shouldRetry(ctx, resp, err) }) if err != nil { return err } f.bucketIDMutex.Lock() f.bucketTypeMutex.Lock() f._bucketID = make(map[string]string, 1) f._bucketType = make(map[string]string, 1) for i := range response.Buckets { bucket := &response.Buckets[i] bucket.Name = f.opt.Enc.ToStandardName(bucket.Name) f.cache.MarkOK(bucket.Name) f._bucketID[bucket.Name] = bucket.ID f._bucketType[bucket.Name] = bucket.Type } f.bucketTypeMutex.Unlock() f.bucketIDMutex.Unlock() for i := range response.Buckets { bucket := &response.Buckets[i] err = fn(bucket) if err != nil { return err } } return nil } // getbucketType finds the bucketType for the current bucket name // can be one of allPublic. allPrivate, or snapshot func (f *Fs) getbucketType(ctx context.Context, bucket string) (bucketType string, err error) { f.bucketTypeMutex.Lock() bucketType = f._bucketType[bucket] f.bucketTypeMutex.Unlock() if bucketType != "" { return bucketType, nil } err = f.listBucketsToFn(ctx, bucket, func(bucket *api.Bucket) error { // listBucketsToFn reads bucket Types return nil }) f.bucketTypeMutex.Lock() bucketType = f._bucketType[bucket] f.bucketTypeMutex.Unlock() if bucketType == "" { err = fs.ErrorDirNotFound } return bucketType, err } // setBucketType sets the Type for the current bucket name func (f *Fs) setBucketType(bucket string, Type string) { f.bucketTypeMutex.Lock() f._bucketType[bucket] = Type f.bucketTypeMutex.Unlock() } // clearBucketType clears the Type for the current bucket name func (f *Fs) clearBucketType(bucket string) { f.bucketTypeMutex.Lock() delete(f._bucketType, bucket) f.bucketTypeMutex.Unlock() } // getBucketID finds the ID for the current bucket name func (f *Fs) getBucketID(ctx context.Context, bucket string) (bucketID string, err error) { f.bucketIDMutex.Lock() bucketID = f._bucketID[bucket] f.bucketIDMutex.Unlock() if bucketID != "" { return bucketID, nil } err = f.listBucketsToFn(ctx, bucket, func(bucket *api.Bucket) error { // listBucketsToFn sets IDs return nil }) f.bucketIDMutex.Lock() bucketID = f._bucketID[bucket] f.bucketIDMutex.Unlock() if bucketID == "" { err = fs.ErrorDirNotFound } return bucketID, err } // setBucketID sets the ID for the current bucket name func (f *Fs) setBucketID(bucket, ID string) { f.bucketIDMutex.Lock() f._bucketID[bucket] = ID f.bucketIDMutex.Unlock() } // clearBucketID clears the ID for the current bucket name func (f *Fs) clearBucketID(bucket string) { f.bucketIDMutex.Lock() delete(f._bucketID, bucket) f.bucketIDMutex.Unlock() } // Put the object into the bucket // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { // Temporary Object under construction fs := &Object{ fs: f, remote: src.Remote(), } return fs, fs.Update(ctx, in, src, options...) } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } // Mkdir creates the bucket if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) error { bucket, _ := f.split(dir) return f.makeBucket(ctx, bucket) } // makeBucket creates the bucket if it doesn't exist func (f *Fs) makeBucket(ctx context.Context, bucket string) error { return f.cache.Create(bucket, func() error { opts := rest.Opts{ Method: "POST", Path: "/b2_create_bucket", } var request = api.CreateBucketRequest{ AccountID: f.info.AccountID, Name: f.opt.Enc.FromStandardName(bucket), Type: "allPrivate", } if f.opt.Lifecycle > 0 { request.LifecycleRules = []api.LifecycleRule{{ DaysFromHidingToDeleting: &f.opt.Lifecycle, }} } var response api.Bucket err := f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, &request, &response) return f.shouldRetry(ctx, resp, err) }) if err != nil { if apiErr, ok := err.(*api.Error); ok { if apiErr.Code == "duplicate_bucket_name" { // Check this is our bucket - buckets are globally unique and this // might be someone elses. _, getBucketErr := f.getBucketID(ctx, bucket) if getBucketErr == nil { // found so it is our bucket return nil } if getBucketErr != fs.ErrorDirNotFound { fs.Debugf(f, "Error checking bucket exists: %v", getBucketErr) } } } return fmt.Errorf("failed to create bucket: %w", err) } f.setBucketID(bucket, response.ID) f.setBucketType(bucket, response.Type) return nil }, nil) } // Rmdir deletes the bucket if the fs is at the root // // Returns an error if it isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { bucket, directory := f.split(dir) if bucket == "" || directory != "" { return nil } return f.cache.Remove(bucket, func() error { opts := rest.Opts{ Method: "POST", Path: "/b2_delete_bucket", } bucketID, err := f.getBucketID(ctx, bucket) if err != nil { return err } var request = api.DeleteBucketRequest{ ID: bucketID, AccountID: f.info.AccountID, } var response api.Bucket err = f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, &request, &response) return f.shouldRetry(ctx, resp, err) }) if err != nil { return fmt.Errorf("failed to delete bucket: %w", err) } f.clearBucketID(bucket) f.clearBucketType(bucket) f.clearUploadURL(bucketID) return nil }) } // Precision of the remote func (f *Fs) Precision() time.Duration { return time.Millisecond } // hide hides a file on the remote func (f *Fs) hide(ctx context.Context, bucket, bucketPath string) error { bucketID, err := f.getBucketID(ctx, bucket) if err != nil { return err } opts := rest.Opts{ Method: "POST", Path: "/b2_hide_file", } var request = api.HideFileRequest{ BucketID: bucketID, Name: f.opt.Enc.FromStandardPath(bucketPath), } var response api.File err = f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, &request, &response) return f.shouldRetry(ctx, resp, err) }) if err != nil { if apiErr, ok := err.(*api.Error); ok { if apiErr.Code == "already_hidden" { // sometimes eventual consistency causes this, so // ignore this error since it is harmless return nil } } return fmt.Errorf("failed to hide %q: %w", bucketPath, err) } return nil } // deleteByID deletes a file version given Name and ID func (f *Fs) deleteByID(ctx context.Context, ID, Name string) error { opts := rest.Opts{ Method: "POST", Path: "/b2_delete_file_version", } var request = api.DeleteFileRequest{ ID: ID, Name: f.opt.Enc.FromStandardPath(Name), } var response api.File err := f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, &request, &response) return f.shouldRetry(ctx, resp, err) }) if err != nil { return fmt.Errorf("failed to delete %q: %w", Name, err) } return nil } // purge deletes all the files and directories // // if oldOnly is true then it deletes only non current files. // // Implemented here so we can make sure we delete old versions. func (f *Fs) purge(ctx context.Context, dir string, oldOnly bool, deleteHidden bool, deleteUnfinished bool, maxAge time.Duration) error { bucket, directory := f.split(dir) if bucket == "" { return errors.New("can't purge from root") } var errReturn error var checkErrMutex sync.Mutex var checkErr = func(err error) { if err == nil { return } checkErrMutex.Lock() defer checkErrMutex.Unlock() if errReturn == nil { errReturn = err } } var isUnfinishedUploadStale = func(timestamp api.Timestamp) bool { return time.Since(time.Time(timestamp)) > maxAge } // Delete Config.Transfers in parallel toBeDeleted := make(chan *api.File, f.ci.Transfers) var wg sync.WaitGroup wg.Add(f.ci.Transfers) for range f.ci.Transfers { go func() { defer wg.Done() for object := range toBeDeleted { oi, err := f.newObjectWithInfo(ctx, object.Name, object) if err != nil { fs.Errorf(object.Name, "Can't create object %v", err) continue } tr := accounting.Stats(ctx).NewCheckingTransfer(oi, "deleting") err = f.deleteByID(ctx, object.ID, object.Name) checkErr(err) tr.Done(ctx, err) } }() } if oldOnly { if deleteHidden && deleteUnfinished { fs.Infof(f, "cleaning bucket %q of all hidden files, and pending multipart uploads older than %v", bucket, maxAge) } else if deleteHidden { fs.Infof(f, "cleaning bucket %q of all hidden files", bucket) } else if deleteUnfinished { fs.Infof(f, "cleaning bucket %q of pending multipart uploads older than %v", bucket, maxAge) } else { fs.Errorf(f, "cleaning bucket %q of nothing. This should never happen!", bucket) return nil } } else { fs.Infof(f, "cleaning bucket %q of all files", bucket) } last := "" checkErr(f.list(ctx, bucket, directory, f.rootDirectory, f.rootBucket == "", true, 0, true, false, func(remote string, object *api.File, isDirectory bool) error { if !isDirectory { oi, err := f.newObjectWithInfo(ctx, object.Name, object) if err != nil { fs.Errorf(object, "Can't create object %+v", err) } tr := accounting.Stats(ctx).NewCheckingTransfer(oi, "checking") if oldOnly && last != remote { // Check current version of the file if deleteHidden && object.Action == "hide" { fs.Debugf(remote, "Deleting current version (id %q) as it is a hide marker", object.ID) if !operations.SkipDestructive(ctx, object.Name, "remove hide marker") { toBeDeleted <- object } } else if deleteUnfinished && object.Action == "start" && isUnfinishedUploadStale(object.UploadTimestamp) { fs.Debugf(remote, "Deleting current version (id %q) as it is a start marker (upload started at %s)", object.ID, time.Time(object.UploadTimestamp).Local()) if !operations.SkipDestructive(ctx, object.Name, "remove pending upload") { toBeDeleted <- object } } else { fs.Debugf(remote, "Not deleting current version (id %q) %q dated %v (%v ago)", object.ID, object.Action, time.Time(object.UploadTimestamp).Local(), time.Since(time.Time(object.UploadTimestamp))) } } else { fs.Debugf(remote, "Deleting (id %q)", object.ID) if !operations.SkipDestructive(ctx, object.Name, "delete") { toBeDeleted <- object } } last = remote tr.Done(ctx, nil) } return nil })) close(toBeDeleted) wg.Wait() if !oldOnly { checkErr(f.Rmdir(ctx, dir)) } return errReturn } // Purge deletes all the files and directories including the old versions. func (f *Fs) Purge(ctx context.Context, dir string) error { return f.purge(ctx, dir, false, false, false, defaultMaxAge) } // CleanUp deletes all hidden files and pending multipart uploads older than 24 hours. func (f *Fs) CleanUp(ctx context.Context) error { return f.purge(ctx, "", true, true, true, defaultMaxAge) } // cleanUp deletes all hidden files and/or pending multipart uploads older than the specified age. func (f *Fs) cleanUp(ctx context.Context, deleteHidden bool, deleteUnfinished bool, maxAge time.Duration) (err error) { return f.purge(ctx, "", true, deleteHidden, deleteUnfinished, maxAge) } // copy does a server-side copy from dstObj <- srcObj // // If newInfo is nil then the metadata will be copied otherwise it // will be replaced with newInfo func (f *Fs) copy(ctx context.Context, dstObj *Object, srcObj *Object, newInfo *api.File) (err error) { if srcObj.size > int64(f.opt.CopyCutoff) { if newInfo == nil { newInfo, err = srcObj.getMetaData(ctx) if err != nil { return err } } up, err := f.newLargeUpload(ctx, dstObj, nil, srcObj, f.opt.CopyCutoff, true, newInfo) if err != nil { return err } err = up.Copy(ctx) if err != nil { return err } return dstObj.decodeMetaDataFileInfo(up.info) } dstBucket, dstPath := dstObj.split() err = f.makeBucket(ctx, dstBucket) if err != nil { return err } destBucketID, err := f.getBucketID(ctx, dstBucket) if err != nil { return err } opts := rest.Opts{ Method: "POST", Path: "/b2_copy_file", } var request = api.CopyFileRequest{ SourceID: srcObj.id, Name: f.opt.Enc.FromStandardPath(dstPath), DestBucketID: destBucketID, } if newInfo == nil { request.MetadataDirective = "COPY" } else { request.MetadataDirective = "REPLACE" request.ContentType = newInfo.ContentType request.Info = newInfo.Info } var response api.FileInfo err = f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, &request, &response) return f.shouldRetry(ctx, resp, err) }) if err != nil { return err } return dstObj.decodeMetaDataFileInfo(&response) } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't copy - not same remote type") return nil, fs.ErrorCantCopy } // Temporary Object under construction dstObj := &Object{ fs: f, remote: remote, } err := f.copy(ctx, dstObj, srcObj, nil) if err != nil { return nil, err } return dstObj, nil } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hash.SHA1) } // getDownloadAuthorization returns authorization token for downloading // without account. func (f *Fs) getDownloadAuthorization(ctx context.Context, bucket, remote string) (authorization string, err error) { validDurationInSeconds := time.Duration(f.opt.DownloadAuthorizationDuration).Nanoseconds() / 1e9 if validDurationInSeconds <= 0 || validDurationInSeconds > 604800 { return "", errors.New("--b2-download-auth-duration must be between 1 sec and 1 week") } if !f.hasPermission("shareFiles") { return "", errors.New("sharing a file link requires the shareFiles permission") } bucketID, err := f.getBucketID(ctx, bucket) if err != nil { return "", err } opts := rest.Opts{ Method: "POST", Path: "/b2_get_download_authorization", } var request = api.GetDownloadAuthorizationRequest{ BucketID: bucketID, FileNamePrefix: f.opt.Enc.FromStandardPath(path.Join(f.rootDirectory, remote)), ValidDurationInSeconds: validDurationInSeconds, } var response api.GetDownloadAuthorizationResponse err = f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, &request, &response) return f.shouldRetry(ctx, resp, err) }) if err != nil { return "", fmt.Errorf("failed to get download authorization: %w", err) } return response.AuthorizationToken, nil } // PublicLink returns a link for downloading without account func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (link string, err error) { bucket, bucketPath := f.split(remote) var RootURL string if f.opt.DownloadURL == "" { RootURL = f.info.DownloadURL } else { RootURL = f.opt.DownloadURL } _, err = f.NewObject(ctx, remote) if err == fs.ErrorObjectNotFound || err == fs.ErrorNotAFile { err2 := f.list(ctx, bucket, bucketPath, f.rootDirectory, f.rootBucket == "", false, 1, f.opt.Versions, false, func(remote string, object *api.File, isDirectory bool) error { err = nil return nil }) if err2 != nil { return "", err2 } } if err != nil { return "", err } absPath := "/" + urlEncode(bucketPath) link = RootURL + "/file/" + urlEncode(bucket) + absPath bucketType, err := f.getbucketType(ctx, bucket) if err != nil { return "", err } if bucketType == "allPrivate" || bucketType == "snapshot" { AuthorizationToken, err := f.getDownloadAuthorization(ctx, bucket, remote) if err != nil { return "", err } link += "?Authorization=" + AuthorizationToken } return link, nil } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Hash returns the Sha-1 of an object returning a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if t != hash.SHA1 { return "", hash.ErrUnsupported } if o.sha1 == "" { // Error is logged in readMetaData err := o.readMetaData(ctx) if err != nil { return "", err } } return o.sha1, nil } // Size returns the size of an object in bytes func (o *Object) Size() int64 { return o.size } // Clean the SHA1 // // Make sure it is lower case. // // Remove unverified prefix - see https://www.backblaze.com/docs/cloud-storage-upload-files-with-the-native-api // Some tools (e.g. Cyberduck) use this func cleanSHA1(sha1 string) string { const unverified = "unverified:" return strings.TrimPrefix(strings.ToLower(sha1), unverified) } // decodeMetaDataRaw sets the metadata from the data passed in // // Sets // // o.id // o.modTime // o.size // o.sha1 func (o *Object) decodeMetaDataRaw(ID, SHA1 string, Size int64, UploadTimestamp api.Timestamp, Info map[string]string, mimeType string) (err error) { o.id = ID o.sha1 = SHA1 o.mimeType = mimeType // Read SHA1 from metadata if it exists and isn't set if o.sha1 == "" || o.sha1 == "none" { o.sha1 = Info[sha1Key] } o.sha1 = cleanSHA1(o.sha1) o.size = Size // Use the UploadTimestamp if can't get file info o.modTime = time.Time(UploadTimestamp) err = o.parseTimeString(Info[timeKey]) if err != nil { return err } return nil } // decodeMetaData sets the metadata in the object from an api.File // // Sets // // o.id // o.modTime // o.size // o.sha1 func (o *Object) decodeMetaData(info *api.File) (err error) { return o.decodeMetaDataRaw(info.ID, info.SHA1, info.Size, info.UploadTimestamp, info.Info, info.ContentType) } // decodeMetaDataFileInfo sets the metadata in the object from an api.FileInfo // // Sets // // o.id // o.modTime // o.size // o.sha1 func (o *Object) decodeMetaDataFileInfo(info *api.FileInfo) (err error) { return o.decodeMetaDataRaw(info.ID, info.SHA1, info.Size, info.UploadTimestamp, info.Info, info.ContentType) } // getMetaDataListing gets the metadata from the object unconditionally from the listing // // Note that listing is a class C transaction which costs more than // the B transaction used in getMetaData func (o *Object) getMetaDataListing(ctx context.Context) (info *api.File, err error) { bucket, bucketPath := o.split() maxSearched := 1 var timestamp api.Timestamp if o.fs.opt.Versions { timestamp, bucketPath = api.RemoveVersion(bucketPath) maxSearched = maxVersions } err = o.fs.list(ctx, bucket, bucketPath, "", false, true, maxSearched, o.fs.opt.Versions, true, func(remote string, object *api.File, isDirectory bool) error { if isDirectory { return nil } if remote == bucketPath { if !timestamp.IsZero() && !timestamp.Equal(object.UploadTimestamp) { return nil } info = object } return errEndList // read only 1 item }) if err != nil { if err == fs.ErrorDirNotFound { return nil, fs.ErrorObjectNotFound } return nil, err } if info == nil { return nil, fs.ErrorObjectNotFound } return info, nil } // getMetaData gets the metadata from the object unconditionally func (o *Object) getMetaData(ctx context.Context) (info *api.File, err error) { // If using versions and have a version suffix, need to list the directory to find the correct versions if o.fs.opt.Versions { timestamp, _ := api.RemoveVersion(o.remote) if !timestamp.IsZero() { return o.getMetaDataListing(ctx) } } // If using versionAt we need to list the find the correct version. if o.fs.opt.VersionAt.IsSet() { info, err := o.getMetaDataListing(ctx) if err != nil { return nil, err } if info.Action == "hide" { // Rerturn object not found error if the current version is deleted. return nil, fs.ErrorObjectNotFound } return info, nil } _, info, err = o.getOrHead(ctx, "HEAD", nil) return info, err } // readMetaData gets the metadata if it hasn't already been fetched // // Sets // // o.id // o.modTime // o.size // o.sha1 func (o *Object) readMetaData(ctx context.Context) (err error) { if o.id != "" { return nil } info, err := o.getMetaData(ctx) if err != nil { return err } return o.decodeMetaData(info) } // timeString returns modTime as the number of milliseconds // elapsed since January 1, 1970 UTC as a decimal string. func timeString(modTime time.Time) string { return strconv.FormatInt(modTime.UnixNano()/1e6, 10) } // parseTimeStringHelper converts a decimal string number of milliseconds // elapsed since January 1, 1970 UTC into a time.Time func parseTimeStringHelper(timeString string) (time.Time, error) { unixMilliseconds, err := strconv.ParseInt(timeString, 10, 64) if err != nil { return time.Time{}, err } return time.Unix(unixMilliseconds/1e3, (unixMilliseconds%1e3)*1e6).UTC(), nil } // parseTimeString converts a decimal string number of milliseconds // elapsed since January 1, 1970 UTC into a time.Time and stores it in // the modTime variable. func (o *Object) parseTimeString(timeString string) (err error) { if timeString == "" { return nil } modTime, err := parseTimeStringHelper(timeString) if err != nil { fs.Debugf(o, "Failed to parse mod time string %q: %v", timeString, err) return nil } o.modTime = modTime return nil } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers // // SHA-1 will also be updated once the request has completed. func (o *Object) ModTime(ctx context.Context) (result time.Time) { // The error is logged in readMetaData _ = o.readMetaData(ctx) return o.modTime } // SetModTime sets the modification time of the Object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { info, err := o.getMetaData(ctx) if err != nil { return err } info.Info[timeKey] = timeString(modTime) // Copy to the same name, overwriting the metadata only return o.fs.copy(ctx, o, o, info) } // Storable returns if this object is storable func (o *Object) Storable() bool { return true } // openFile represents an Object open for reading type openFile struct { o *Object // Object we are reading for resp *http.Response // response of the GET body io.Reader // reading from here hash gohash.Hash // currently accumulating SHA1 bytes int64 // number of bytes read on this connection eof bool // whether we have read end of file } // newOpenFile wraps an io.ReadCloser and checks the sha1sum func newOpenFile(o *Object, resp *http.Response) *openFile { file := &openFile{ o: o, resp: resp, hash: sha1.New(), } file.body = io.TeeReader(resp.Body, file.hash) return file } // Read bytes from the object - see io.Reader func (file *openFile) Read(p []byte) (n int, err error) { n, err = file.body.Read(p) file.bytes += int64(n) if err == io.EOF { file.eof = true } return } // Close the object and checks the length and SHA1 if all the object // was read func (file *openFile) Close() (err error) { // Close the body at the end defer fs.CheckClose(file.resp.Body, &err) // If not end of file then can't check SHA1 if !file.eof { return nil } // Check to see we read the correct number of bytes if file.o.Size() != file.bytes { return fmt.Errorf("corrupted on transfer: lengths differ want %d vs got %d", file.o.Size(), file.bytes) } // Check the SHA1 receivedSHA1 := file.o.sha1 calculatedSHA1 := fmt.Sprintf("%x", file.hash.Sum(nil)) if receivedSHA1 != "" && receivedSHA1 != calculatedSHA1 { return fmt.Errorf("corrupted on transfer: SHA1 hashes differ want %q vs got %q", receivedSHA1, calculatedSHA1) } return nil } // Check it satisfies the interfaces var _ io.ReadCloser = &openFile{} func (o *Object) getOrHead(ctx context.Context, method string, options []fs.OpenOption) (resp *http.Response, info *api.File, err error) { opts := rest.Opts{ Method: method, Options: options, NoResponse: method == "HEAD", } // Use downloadUrl from backblaze if downloadUrl is not set // otherwise use the custom downloadUrl if o.fs.opt.DownloadURL == "" { opts.RootURL = o.fs.info.DownloadURL } else { opts.RootURL = o.fs.opt.DownloadURL } // Download by id if set and not using DownloadURL otherwise by name if o.id != "" && o.fs.opt.DownloadURL == "" { opts.Path += "/b2api/v1/b2_download_file_by_id?fileId=" + urlEncode(o.id) } else { bucket, bucketPath := o.split() opts.Path += "/file/" + urlEncode(o.fs.opt.Enc.FromStandardName(bucket)) + "/" + urlEncode(o.fs.opt.Enc.FromStandardPath(bucketPath)) } err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.Call(ctx, &opts) return o.fs.shouldRetry(ctx, resp, err) }) if err != nil { // 404 for files, 400 for directories if resp != nil && (resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusBadRequest) { return nil, nil, fs.ErrorObjectNotFound } return nil, nil, fmt.Errorf("failed to %s for download: %w", method, err) } // NB resp may be Open here - don't return err != nil without closing // Convert the Headers into an api.File var uploadTimestamp api.Timestamp err = uploadTimestamp.UnmarshalJSON([]byte(resp.Header.Get(timestampHeader))) if err != nil { fs.Debugf(o, "Bad "+timestampHeader+" header: %v", err) } var Info = make(map[string]string) for k, vs := range resp.Header { k = strings.ToLower(k) for _, v := range vs { if strings.HasPrefix(k, headerPrefix) { Info[k[len(headerPrefix):]] = v } } } info = &api.File{ ID: resp.Header.Get(idHeader), Name: resp.Header.Get(nameHeader), Action: "upload", Size: resp.ContentLength, UploadTimestamp: uploadTimestamp, SHA1: resp.Header.Get(sha1Header), ContentType: resp.Header.Get("Content-Type"), Info: Info, } // When reading files from B2 via cloudflare using // --b2-download-url cloudflare strips the Content-Length // headers (presumably so it can inject stuff) so use the old // length read from the listing. // Additionally, the official examples return S3 headers // instead of native, i.e. no file ID, use ones from listing. if info.Size < 0 { info.Size = o.size } if info.ID == "" { info.ID = o.id } return resp, info, nil } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { fs.FixRangeOption(options, o.size) resp, info, err := o.getOrHead(ctx, "GET", options) if err != nil { return nil, err } // Don't check length or hash or metadata on partial content if resp.StatusCode == http.StatusPartialContent { return resp.Body, nil } err = o.decodeMetaData(info) if err != nil { _ = resp.Body.Close() return nil, err } return newOpenFile(o, resp), nil } // dontEncode is the characters that do not need percent-encoding // // The characters that do not need percent-encoding are a subset of // the printable ASCII characters: upper-case letters, lower-case // letters, digits, ".", "_", "-", "/", "~", "!", "$", "'", "(", ")", // "*", ";", "=", ":", and "@". All other byte values in a UTF-8 must // be replaced with "%" and the two-digit hex value of the byte. const dontEncode = (`abcdefghijklmnopqrstuvwxyz` + `ABCDEFGHIJKLMNOPQRSTUVWXYZ` + `0123456789` + `._-/~!$'()*;=:@`) // noNeedToEncode is a bitmap of characters which don't need % encoding var noNeedToEncode [256]bool func init() { for _, c := range dontEncode { noNeedToEncode[c] = true } } // urlEncode encodes in with % encoding func urlEncode(in string) string { var out bytes.Buffer for i := range len(in) { c := in[i] if noNeedToEncode[c] { _ = out.WriteByte(c) } else { _, _ = out.WriteString(fmt.Sprintf("%%%2X", c)) } } return out.String() } // Update the object with the contents of the io.Reader, modTime and size // // The new object may have been created if an error is returned func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { if o.fs.opt.Versions { return errNotWithVersions } if o.fs.opt.VersionAt.IsSet() { return errNotWithVersionAt } size := src.Size() bucket, bucketPath := o.split() err = o.fs.makeBucket(ctx, bucket) if err != nil { return err } if size < 0 { // Check if the file is large enough for a chunked upload (needs to be at least two chunks) rw := o.fs.getRW(false) n, err := io.CopyN(rw, in, int64(o.fs.opt.ChunkSize)) if err == nil { bufReader := bufio.NewReader(in) in = bufReader _, err = bufReader.Peek(1) } if err == nil { fs.Debugf(o, "File is big enough for chunked streaming") up, err := o.fs.newLargeUpload(ctx, o, in, src, o.fs.opt.ChunkSize, false, nil, options...) if err != nil { o.fs.putRW(rw) return err } // NB Stream returns the buffer and token err = up.Stream(ctx, rw) if err != nil { return err } return o.decodeMetaDataFileInfo(up.info) } else if err == io.EOF { fs.Debugf(o, "File has %d bytes, which makes only one chunk. Using direct upload.", n) defer o.fs.putRW(rw) size = n in = rw } else { o.fs.putRW(rw) return err } } else if size > int64(o.fs.opt.UploadCutoff) { chunkWriter, err := multipart.UploadMultipart(ctx, src, in, multipart.UploadMultipartOptions{ Open: o.fs, OpenOptions: options, }) if err != nil { return err } up := chunkWriter.(*largeUpload) return o.decodeMetaDataFileInfo(up.info) } modTime, err := o.getModTime(ctx, src, options) if err != nil { return err } calculatedSha1, _ := src.Hash(ctx, hash.SHA1) if calculatedSha1 == "" { calculatedSha1 = "hex_digits_at_end" har := newHashAppendingReader(in, sha1.New()) size += int64(har.AdditionalLength()) in = har } // Get upload URL upload, err := o.fs.getUploadURL(ctx, bucket) if err != nil { return err } defer func() { // return it like this because we might nil it out o.fs.returnUploadURL(upload) }() // Headers for upload file // // Authorization // required // An upload authorization token, from b2_get_upload_url. // // X-Bz-File-Name // required // // The name of the file, in percent-encoded UTF-8. See Files for requirements on file names. See String Encoding. // // Content-Type // required // // The MIME type of the content of the file, which will be returned in // the Content-Type header when downloading the file. Use the // Content-Type b2/x-auto to automatically set the stored Content-Type // post upload. In the case where a file extension is absent or the // lookup fails, the Content-Type is set to application/octet-stream. The // Content-Type mappings can be pursued here. // // X-Bz-Content-Sha1 // required // // The SHA1 checksum of the content of the file. B2 will check this when // the file is uploaded, to make sure that the file arrived correctly. It // will be returned in the X-Bz-Content-Sha1 header when the file is // downloaded. // // X-Bz-Info-src_last_modified_millis // optional // // If the original source of the file being uploaded has a last modified // time concept, Backblaze recommends using this spelling of one of your // ten X-Bz-Info-* headers (see below). Using a standard spelling allows // different B2 clients and the B2 web user interface to interoperate // correctly. The value should be a base 10 number which represents a UTC // time when the original source file was last modified. It is a base 10 // number of milliseconds since midnight, January 1, 1970 UTC. This fits // in a 64 bit integer such as the type "long" in the programming // language Java. It is intended to be compatible with Java's time // long. For example, it can be passed directly into the Java call // Date.setTime(long time). // // X-Bz-Info-* // optional // // Up to 10 of these headers may be present. The * part of the header // name is replace with the name of a custom field in the file // information stored with the file, and the value is an arbitrary UTF-8 // string, percent-encoded. The same info headers sent with the upload // will be returned with the download. opts := rest.Opts{ Method: "POST", RootURL: upload.UploadURL, Body: in, Options: options, ExtraHeaders: map[string]string{ "Authorization": upload.AuthorizationToken, "X-Bz-File-Name": urlEncode(o.fs.opt.Enc.FromStandardPath(bucketPath)), "Content-Type": fs.MimeType(ctx, src), sha1Header: calculatedSha1, timeHeader: timeString(modTime), }, ContentLength: &size, } var response api.FileInfo // Don't retry, return a retry error instead err = o.fs.pacer.CallNoRetry(func() (bool, error) { resp, err := o.fs.srv.CallJSON(ctx, &opts, nil, &response) retry, err := o.fs.shouldRetry(ctx, resp, err) // On retryable error clear UploadURL if retry { fs.Debugf(o, "Clearing upload URL because of error: %v", err) upload = nil } return retry, err }) if err != nil { return err } return o.decodeMetaDataFileInfo(&response) } // Get modTime from the source; if --metadata is set, fetch the src metadata and get it from there. // When metadata support is added to b2, this method will need a more generic name func (o *Object) getModTime(ctx context.Context, src fs.ObjectInfo, options []fs.OpenOption) (time.Time, error) { modTime := src.ModTime(ctx) // Fetch metadata if --metadata is in use meta, err := fs.GetMetadataOptions(ctx, o.fs, src, options) if err != nil { return time.Time{}, fmt.Errorf("failed to read metadata from source object: %w", err) } // merge metadata into request and user metadata for k, v := range meta { k = strings.ToLower(k) // For now, the only metadata we're concerned with is "mtime" switch k { case "mtime": // mtime in meta overrides source ModTime metaModTime, err := time.Parse(time.RFC3339Nano, v) if err != nil { fs.Debugf(o, "failed to parse metadata %s: %q: %v", k, v, err) } else { modTime = metaModTime } default: // Do nothing for now } } return modTime, nil } // OpenChunkWriter returns the chunk size and a ChunkWriter // // Pass in the remote and the src object // You can also use options to hint at the desired chunk size func (f *Fs) OpenChunkWriter(ctx context.Context, remote string, src fs.ObjectInfo, options ...fs.OpenOption) (info fs.ChunkWriterInfo, writer fs.ChunkWriter, err error) { // FIXME what if file is smaller than 1 chunk? if f.opt.Versions { return info, nil, errNotWithVersions } if f.opt.VersionAt.IsSet() { return info, nil, errNotWithVersionAt } //size := src.Size() // Temporary Object under construction o := &Object{ fs: f, remote: remote, } bucket, _ := o.split() err = f.makeBucket(ctx, bucket) if err != nil { return info, nil, err } info = fs.ChunkWriterInfo{ ChunkSize: int64(f.opt.ChunkSize), Concurrency: o.fs.opt.UploadConcurrency, //LeavePartsOnError: o.fs.opt.LeavePartsOnError, } up, err := f.newLargeUpload(ctx, o, nil, src, f.opt.ChunkSize, false, nil, options...) return info, up, err } // Remove an object func (o *Object) Remove(ctx context.Context) error { bucket, bucketPath := o.split() if o.fs.opt.Versions { return errNotWithVersions } if o.fs.opt.VersionAt.IsSet() { return errNotWithVersionAt } if o.fs.opt.HardDelete { return o.fs.deleteByID(ctx, o.id, bucketPath) } return o.fs.hide(ctx, bucket, bucketPath) } // MimeType of an Object if known, "" otherwise func (o *Object) MimeType(ctx context.Context) string { return o.mimeType } // ID returns the ID of the Object if known, or "" if not func (o *Object) ID() string { return o.id } var lifecycleHelp = fs.CommandHelp{ Name: "lifecycle", Short: "Read or set the lifecycle for a bucket", Long: `This command can be used to read or set the lifecycle for a bucket. Usage Examples: To show the current lifecycle rules: rclone backend lifecycle b2:bucket This will dump something like this showing the lifecycle rules. [ { "daysFromHidingToDeleting": 1, "daysFromUploadingToHiding": null, "daysFromStartingToCancelingUnfinishedLargeFiles": null, "fileNamePrefix": "" } ] If there are no lifecycle rules (the default) then it will just return []. To reset the current lifecycle rules: rclone backend lifecycle b2:bucket -o daysFromHidingToDeleting=30 rclone backend lifecycle b2:bucket -o daysFromUploadingToHiding=5 -o daysFromHidingToDeleting=1 This will run and then print the new lifecycle rules as above. Rclone only lets you set lifecycles for the whole bucket with the fileNamePrefix = "". You can't disable versioning with B2. The best you can do is to set the daysFromHidingToDeleting to 1 day. You can enable hard_delete in the config also which will mean deletions won't cause versions but overwrites will still cause versions to be made. rclone backend lifecycle b2:bucket -o daysFromHidingToDeleting=1 See: https://www.backblaze.com/docs/cloud-storage-lifecycle-rules `, Opts: map[string]string{ "daysFromHidingToDeleting": "After a file has been hidden for this many days it is deleted. 0 is off.", "daysFromUploadingToHiding": "This many days after uploading a file is hidden", "daysFromStartingToCancelingUnfinishedLargeFiles": "Cancels any unfinished large file versions after this many days", }, } func (f *Fs) lifecycleCommand(ctx context.Context, name string, arg []string, opt map[string]string) (out any, err error) { var newRule api.LifecycleRule if daysStr := opt["daysFromHidingToDeleting"]; daysStr != "" { days, err := strconv.Atoi(daysStr) if err != nil { return nil, fmt.Errorf("bad daysFromHidingToDeleting: %w", err) } newRule.DaysFromHidingToDeleting = &days } if daysStr := opt["daysFromUploadingToHiding"]; daysStr != "" { days, err := strconv.Atoi(daysStr) if err != nil { return nil, fmt.Errorf("bad daysFromUploadingToHiding: %w", err) } newRule.DaysFromUploadingToHiding = &days } if daysStr := opt["daysFromStartingToCancelingUnfinishedLargeFiles"]; daysStr != "" { days, err := strconv.Atoi(daysStr) if err != nil { return nil, fmt.Errorf("bad daysFromStartingToCancelingUnfinishedLargeFiles: %w", err) } newRule.DaysFromStartingToCancelingUnfinishedLargeFiles = &days } bucketName, _ := f.split("") if bucketName == "" { return nil, errors.New("bucket required") } skip := operations.SkipDestructive(ctx, name, "update lifecycle rules") var bucket *api.Bucket if !skip && (newRule.DaysFromHidingToDeleting != nil || newRule.DaysFromUploadingToHiding != nil || newRule.DaysFromStartingToCancelingUnfinishedLargeFiles != nil) { bucketID, err := f.getBucketID(ctx, bucketName) if err != nil { return nil, err } opts := rest.Opts{ Method: "POST", Path: "/b2_update_bucket", } var request = api.UpdateBucketRequest{ ID: bucketID, AccountID: f.info.AccountID, LifecycleRules: []api.LifecycleRule{newRule}, } var response api.Bucket err = f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, &request, &response) return f.shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } bucket = &response } else { err = f.listBucketsToFn(ctx, bucketName, func(b *api.Bucket) error { bucket = b return nil }) if err != nil { return nil, err } } if bucket == nil { return nil, fs.ErrorDirNotFound } return bucket.LifecycleRules, nil } var cleanupHelp = fs.CommandHelp{ Name: "cleanup", Short: "Remove unfinished large file uploads.", Long: `This command removes unfinished large file uploads of age greater than max-age, which defaults to 24 hours. Note that you can use --interactive/-i or --dry-run with this command to see what it would do. rclone backend cleanup b2:bucket/path/to/object rclone backend cleanup -o max-age=7w b2:bucket/path/to/object Durations are parsed as per the rest of rclone, 2h, 7d, 7w etc. `, Opts: map[string]string{ "max-age": "Max age of upload to delete", }, } func (f *Fs) cleanupCommand(ctx context.Context, name string, arg []string, opt map[string]string) (out any, err error) { maxAge := defaultMaxAge if opt["max-age"] != "" { maxAge, err = fs.ParseDuration(opt["max-age"]) if err != nil { return nil, fmt.Errorf("bad max-age: %w", err) } } return nil, f.cleanUp(ctx, false, true, maxAge) } var cleanupHiddenHelp = fs.CommandHelp{ Name: "cleanup-hidden", Short: "Remove old versions of files.", Long: `This command removes any old hidden versions of files. Note that you can use --interactive/-i or --dry-run with this command to see what it would do. rclone backend cleanup-hidden b2:bucket/path/to/dir `, } func (f *Fs) cleanupHiddenCommand(ctx context.Context, name string, arg []string, opt map[string]string) (out any, err error) { return nil, f.cleanUp(ctx, true, false, 0) } var commandHelp = []fs.CommandHelp{ lifecycleHelp, cleanupHelp, cleanupHiddenHelp, } // Command the backend to run a named command // // The command run is name // args may be used to read arguments from // opts may be used to read optional arguments from // // The result should be capable of being JSON encoded // If it is a string or a []string it will be shown to the user // otherwise it will be JSON encoded and shown to the user like that func (f *Fs) Command(ctx context.Context, name string, arg []string, opt map[string]string) (out any, err error) { switch name { case "lifecycle": return f.lifecycleCommand(ctx, name, arg, opt) case "cleanup": return f.cleanupCommand(ctx, name, arg, opt) case "cleanup-hidden": return f.cleanupHiddenCommand(ctx, name, arg, opt) default: return nil, fs.ErrorCommandNotFound } } // Check the interfaces are satisfied var ( _ fs.Fs = &Fs{} _ fs.Purger = &Fs{} _ fs.Copier = &Fs{} _ fs.PutStreamer = &Fs{} _ fs.CleanUpper = &Fs{} _ fs.ListRer = &Fs{} _ fs.PublicLinker = &Fs{} _ fs.OpenChunkWriter = &Fs{} _ fs.Commander = &Fs{} _ fs.Object = &Object{} _ fs.MimeTyper = &Object{} _ fs.IDer = &Object{} ) rclone-v1.71.0/backend/b2/b2_internal_test.go000066400000000000000000000536761505210326400207460ustar00rootroot00000000000000package b2 import ( "context" "crypto/sha1" "fmt" "path" "sort" "strings" "testing" "time" "github.com/rclone/rclone/backend/b2/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/object" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" "github.com/rclone/rclone/lib/bucket" "github.com/rclone/rclone/lib/random" "github.com/rclone/rclone/lib/version" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Test b2 string encoding // https://www.backblaze.com/docs/cloud-storage-native-api-string-encoding var encodeTest = []struct { fullyEncoded string minimallyEncoded string plainText string }{ {fullyEncoded: "%20", minimallyEncoded: "+", plainText: " "}, {fullyEncoded: "%21", minimallyEncoded: "!", plainText: "!"}, {fullyEncoded: "%22", minimallyEncoded: "%22", plainText: "\""}, {fullyEncoded: "%23", minimallyEncoded: "%23", plainText: "#"}, {fullyEncoded: "%24", minimallyEncoded: "$", plainText: "$"}, {fullyEncoded: "%25", minimallyEncoded: "%25", plainText: "%"}, {fullyEncoded: "%26", minimallyEncoded: "%26", plainText: "&"}, {fullyEncoded: "%27", minimallyEncoded: "'", plainText: "'"}, {fullyEncoded: "%28", minimallyEncoded: "(", plainText: "("}, {fullyEncoded: "%29", minimallyEncoded: ")", plainText: ")"}, {fullyEncoded: "%2A", minimallyEncoded: "*", plainText: "*"}, {fullyEncoded: "%2B", minimallyEncoded: "%2B", plainText: "+"}, {fullyEncoded: "%2C", minimallyEncoded: "%2C", plainText: ","}, {fullyEncoded: "%2D", minimallyEncoded: "-", plainText: "-"}, {fullyEncoded: "%2E", minimallyEncoded: ".", plainText: "."}, {fullyEncoded: "%2F", minimallyEncoded: "/", plainText: "/"}, {fullyEncoded: "%30", minimallyEncoded: "0", plainText: "0"}, {fullyEncoded: "%31", minimallyEncoded: "1", plainText: "1"}, {fullyEncoded: "%32", minimallyEncoded: "2", plainText: "2"}, {fullyEncoded: "%33", minimallyEncoded: "3", plainText: "3"}, {fullyEncoded: "%34", minimallyEncoded: "4", plainText: "4"}, {fullyEncoded: "%35", minimallyEncoded: "5", plainText: "5"}, {fullyEncoded: "%36", minimallyEncoded: "6", plainText: "6"}, {fullyEncoded: "%37", minimallyEncoded: "7", plainText: "7"}, {fullyEncoded: "%38", minimallyEncoded: "8", plainText: "8"}, {fullyEncoded: "%39", minimallyEncoded: "9", plainText: "9"}, {fullyEncoded: "%3A", minimallyEncoded: ":", plainText: ":"}, {fullyEncoded: "%3B", minimallyEncoded: ";", plainText: ";"}, {fullyEncoded: "%3C", minimallyEncoded: "%3C", plainText: "<"}, {fullyEncoded: "%3D", minimallyEncoded: "=", plainText: "="}, {fullyEncoded: "%3E", minimallyEncoded: "%3E", plainText: ">"}, {fullyEncoded: "%3F", minimallyEncoded: "%3F", plainText: "?"}, {fullyEncoded: "%40", minimallyEncoded: "@", plainText: "@"}, {fullyEncoded: "%41", minimallyEncoded: "A", plainText: "A"}, {fullyEncoded: "%42", minimallyEncoded: "B", plainText: "B"}, {fullyEncoded: "%43", minimallyEncoded: "C", plainText: "C"}, {fullyEncoded: "%44", minimallyEncoded: "D", plainText: "D"}, {fullyEncoded: "%45", minimallyEncoded: "E", plainText: "E"}, {fullyEncoded: "%46", minimallyEncoded: "F", plainText: "F"}, {fullyEncoded: "%47", minimallyEncoded: "G", plainText: "G"}, {fullyEncoded: "%48", minimallyEncoded: "H", plainText: "H"}, {fullyEncoded: "%49", minimallyEncoded: "I", plainText: "I"}, {fullyEncoded: "%4A", minimallyEncoded: "J", plainText: "J"}, {fullyEncoded: "%4B", minimallyEncoded: "K", plainText: "K"}, {fullyEncoded: "%4C", minimallyEncoded: "L", plainText: "L"}, {fullyEncoded: "%4D", minimallyEncoded: "M", plainText: "M"}, {fullyEncoded: "%4E", minimallyEncoded: "N", plainText: "N"}, {fullyEncoded: "%4F", minimallyEncoded: "O", plainText: "O"}, {fullyEncoded: "%50", minimallyEncoded: "P", plainText: "P"}, {fullyEncoded: "%51", minimallyEncoded: "Q", plainText: "Q"}, {fullyEncoded: "%52", minimallyEncoded: "R", plainText: "R"}, {fullyEncoded: "%53", minimallyEncoded: "S", plainText: "S"}, {fullyEncoded: "%54", minimallyEncoded: "T", plainText: "T"}, {fullyEncoded: "%55", minimallyEncoded: "U", plainText: "U"}, {fullyEncoded: "%56", minimallyEncoded: "V", plainText: "V"}, {fullyEncoded: "%57", minimallyEncoded: "W", plainText: "W"}, {fullyEncoded: "%58", minimallyEncoded: "X", plainText: "X"}, {fullyEncoded: "%59", minimallyEncoded: "Y", plainText: "Y"}, {fullyEncoded: "%5A", minimallyEncoded: "Z", plainText: "Z"}, {fullyEncoded: "%5B", minimallyEncoded: "%5B", plainText: "["}, {fullyEncoded: "%5C", minimallyEncoded: "%5C", plainText: "\\"}, {fullyEncoded: "%5D", minimallyEncoded: "%5D", plainText: "]"}, {fullyEncoded: "%5E", minimallyEncoded: "%5E", plainText: "^"}, {fullyEncoded: "%5F", minimallyEncoded: "_", plainText: "_"}, {fullyEncoded: "%60", minimallyEncoded: "%60", plainText: "`"}, {fullyEncoded: "%61", minimallyEncoded: "a", plainText: "a"}, {fullyEncoded: "%62", minimallyEncoded: "b", plainText: "b"}, {fullyEncoded: "%63", minimallyEncoded: "c", plainText: "c"}, {fullyEncoded: "%64", minimallyEncoded: "d", plainText: "d"}, {fullyEncoded: "%65", minimallyEncoded: "e", plainText: "e"}, {fullyEncoded: "%66", minimallyEncoded: "f", plainText: "f"}, {fullyEncoded: "%67", minimallyEncoded: "g", plainText: "g"}, {fullyEncoded: "%68", minimallyEncoded: "h", plainText: "h"}, {fullyEncoded: "%69", minimallyEncoded: "i", plainText: "i"}, {fullyEncoded: "%6A", minimallyEncoded: "j", plainText: "j"}, {fullyEncoded: "%6B", minimallyEncoded: "k", plainText: "k"}, {fullyEncoded: "%6C", minimallyEncoded: "l", plainText: "l"}, {fullyEncoded: "%6D", minimallyEncoded: "m", plainText: "m"}, {fullyEncoded: "%6E", minimallyEncoded: "n", plainText: "n"}, {fullyEncoded: "%6F", minimallyEncoded: "o", plainText: "o"}, {fullyEncoded: "%70", minimallyEncoded: "p", plainText: "p"}, {fullyEncoded: "%71", minimallyEncoded: "q", plainText: "q"}, {fullyEncoded: "%72", minimallyEncoded: "r", plainText: "r"}, {fullyEncoded: "%73", minimallyEncoded: "s", plainText: "s"}, {fullyEncoded: "%74", minimallyEncoded: "t", plainText: "t"}, {fullyEncoded: "%75", minimallyEncoded: "u", plainText: "u"}, {fullyEncoded: "%76", minimallyEncoded: "v", plainText: "v"}, {fullyEncoded: "%77", minimallyEncoded: "w", plainText: "w"}, {fullyEncoded: "%78", minimallyEncoded: "x", plainText: "x"}, {fullyEncoded: "%79", minimallyEncoded: "y", plainText: "y"}, {fullyEncoded: "%7A", minimallyEncoded: "z", plainText: "z"}, {fullyEncoded: "%7B", minimallyEncoded: "%7B", plainText: "{"}, {fullyEncoded: "%7C", minimallyEncoded: "%7C", plainText: "|"}, {fullyEncoded: "%7D", minimallyEncoded: "%7D", plainText: "}"}, {fullyEncoded: "%7E", minimallyEncoded: "~", plainText: "~"}, {fullyEncoded: "%7F", minimallyEncoded: "%7F", plainText: "\u007f"}, {fullyEncoded: "%E8%87%AA%E7%94%B1", minimallyEncoded: "%E8%87%AA%E7%94%B1", plainText: "自由"}, {fullyEncoded: "%F0%90%90%80", minimallyEncoded: "%F0%90%90%80", plainText: "𐐀"}, } func TestUrlEncode(t *testing.T) { for _, test := range encodeTest { got := urlEncode(test.plainText) if got != test.minimallyEncoded && got != test.fullyEncoded { t.Errorf("urlEncode(%q) got %q wanted %q or %q", test.plainText, got, test.minimallyEncoded, test.fullyEncoded) } } } func TestTimeString(t *testing.T) { for _, test := range []struct { in time.Time want string }{ {fstest.Time("1970-01-01T00:00:00.000000000Z"), "0"}, {fstest.Time("2001-02-03T04:05:10.123123123Z"), "981173110123"}, {fstest.Time("2001-02-03T05:05:10.123123123+01:00"), "981173110123"}, } { got := timeString(test.in) if test.want != got { t.Logf("%v: want %v got %v", test.in, test.want, got) } } } func TestParseTimeString(t *testing.T) { for _, test := range []struct { in string want time.Time wantError string }{ {"0", fstest.Time("1970-01-01T00:00:00.000000000Z"), ""}, {"981173110123", fstest.Time("2001-02-03T04:05:10.123000000Z"), ""}, {"", time.Time{}, ""}, {"potato", time.Time{}, `strconv.ParseInt: parsing "potato": invalid syntax`}, } { o := Object{} err := o.parseTimeString(test.in) got := o.modTime var gotError string if err != nil { gotError = err.Error() } if test.want != got { t.Logf("%v: want %v got %v", test.in, test.want, got) } if test.wantError != gotError { t.Logf("%v: want error %v got error %v", test.in, test.wantError, gotError) } } } // Return a map of the headers in the options with keys stripped of the "x-bz-info-" prefix func OpenOptionToMetaData(options []fs.OpenOption) map[string]string { var headers = make(map[string]string) for _, option := range options { k, v := option.Header() k = strings.ToLower(k) if strings.HasPrefix(k, headerPrefix) { headers[k[len(headerPrefix):]] = v } } return headers } func (f *Fs) internalTestMetadata(t *testing.T, size string, uploadCutoff string, chunkSize string) { what := fmt.Sprintf("Size%s/UploadCutoff%s/ChunkSize%s", size, uploadCutoff, chunkSize) t.Run(what, func(t *testing.T) { ctx := context.Background() ss := fs.SizeSuffix(0) err := ss.Set(size) require.NoError(t, err) original := random.String(int(ss)) contents := fstest.Gz(t, original) mimeType := "text/html" if chunkSize != "" { ss := fs.SizeSuffix(0) err := ss.Set(chunkSize) require.NoError(t, err) _, err = f.SetUploadChunkSize(ss) require.NoError(t, err) } if uploadCutoff != "" { ss := fs.SizeSuffix(0) err := ss.Set(uploadCutoff) require.NoError(t, err) _, err = f.SetUploadCutoff(ss) require.NoError(t, err) } item := fstest.NewItem("test-metadata", contents, fstest.Time("2001-05-06T04:05:06.499Z")) btime := time.Now() metadata := fs.Metadata{ // Just mtime for now - limit to milliseconds since x-bz-info-src_last_modified_millis can't support any "mtime": "2009-05-06T04:05:06.499Z", } // Need to specify HTTP options with the header prefix since they are passed as-is options := []fs.OpenOption{ &fs.HTTPOption{Key: "X-Bz-Info-a", Value: "1"}, &fs.HTTPOption{Key: "X-Bz-Info-b", Value: "2"}, } obj := fstests.PutTestContentsMetadata(ctx, t, f, &item, true, contents, true, mimeType, metadata, options...) defer func() { assert.NoError(t, obj.Remove(ctx)) }() o := obj.(*Object) gotMetadata, err := o.getMetaData(ctx) require.NoError(t, err) // X-Bz-Info-a & X-Bz-Info-b optMetadata := OpenOptionToMetaData(options) for k, v := range optMetadata { got := gotMetadata.Info[k] assert.Equal(t, v, got, k) } assert.Equal(t, mimeType, gotMetadata.ContentType, "Content-Type") // Modification time from the x-bz-info-src_last_modified_millis header var mtime api.Timestamp err = mtime.UnmarshalJSON([]byte(gotMetadata.Info[timeKey])) if err != nil { fs.Debugf(o, "Bad "+timeHeader+" header: %v", err) } assert.Equal(t, item.ModTime, time.Time(mtime), "Modification time") // Upload time gotBtime := time.Time(gotMetadata.UploadTimestamp) dt := gotBtime.Sub(btime) assert.True(t, dt < time.Minute && dt > -time.Minute, fmt.Sprintf("btime more than 1 minute out want %v got %v delta %v", btime, gotBtime, dt)) t.Run("GzipEncoding", func(t *testing.T) { // Test that the gzipped file we uploaded can be // downloaded checkDownload := func(wantContents string, wantSize int64, wantHash string) { gotContents := fstests.ReadObject(ctx, t, o, -1) assert.Equal(t, wantContents, gotContents) assert.Equal(t, wantSize, o.Size()) gotHash, err := o.Hash(ctx, hash.SHA1) require.NoError(t, err) assert.Equal(t, wantHash, gotHash) } t.Run("NoDecompress", func(t *testing.T) { checkDownload(contents, int64(len(contents)), sha1Sum(t, contents)) }) }) }) } func (f *Fs) InternalTestMetadata(t *testing.T) { // 1 kB regular file f.internalTestMetadata(t, "1kiB", "", "") // 10 MiB large file f.internalTestMetadata(t, "10MiB", "6MiB", "6MiB") } func sha1Sum(t *testing.T, s string) string { hash := sha1.Sum([]byte(s)) return fmt.Sprintf("%x", hash) } // This is adapted from the s3 equivalent. func (f *Fs) InternalTestVersions(t *testing.T) { ctx := context.Background() // Small pause to make the LastModified different since AWS // only seems to track them to 1 second granularity time.Sleep(2 * time.Second) // Create an object const dirName = "versions" const fileName = dirName + "/" + "test-versions.txt" contents := random.String(100) item := fstest.NewItem(fileName, contents, fstest.Time("2001-05-06T04:05:06.499999999Z")) obj := fstests.PutTestContents(ctx, t, f, &item, contents, true) defer func() { assert.NoError(t, obj.Remove(ctx)) }() objMetadata, err := obj.(*Object).getMetaData(ctx) require.NoError(t, err) // Small pause time.Sleep(2 * time.Second) // Remove it assert.NoError(t, obj.Remove(ctx)) // Small pause to make the LastModified different since AWS only seems to track them to 1 second granularity time.Sleep(2 * time.Second) // And create it with different size and contents newContents := random.String(101) newItem := fstest.NewItem(fileName, newContents, fstest.Time("2002-05-06T04:05:06.499999999Z")) newObj := fstests.PutTestContents(ctx, t, f, &newItem, newContents, true) newObjMetadata, err := newObj.(*Object).getMetaData(ctx) require.NoError(t, err) t.Run("Versions", func(t *testing.T) { // Set --b2-versions for this test f.opt.Versions = true defer func() { f.opt.Versions = false }() // Read the contents entries, err := f.List(ctx, dirName) require.NoError(t, err) tests := 0 var fileNameVersion string for _, entry := range entries { t.Log(entry) remote := entry.Remote() if remote == fileName { t.Run("ReadCurrent", func(t *testing.T) { assert.Equal(t, newContents, fstests.ReadObject(ctx, t, entry.(fs.Object), -1)) }) tests++ } else if versionTime, p := version.Remove(remote); !versionTime.IsZero() && p == fileName { t.Run("ReadVersion", func(t *testing.T) { assert.Equal(t, contents, fstests.ReadObject(ctx, t, entry.(fs.Object), -1)) }) assert.WithinDuration(t, time.Time(objMetadata.UploadTimestamp), versionTime, time.Second, "object time must be with 1 second of version time") fileNameVersion = remote tests++ } } assert.Equal(t, 2, tests, "object missing from listing") // Check we can read the object with a version suffix t.Run("NewObject", func(t *testing.T) { o, err := f.NewObject(ctx, fileNameVersion) require.NoError(t, err) require.NotNil(t, o) assert.Equal(t, int64(100), o.Size(), o.Remote()) }) // Check we can make a NewFs from that object with a version suffix t.Run("NewFs", func(t *testing.T) { newPath := bucket.Join(fs.ConfigStringFull(f), fileNameVersion) // Make sure --b2-versions is set in the config of the new remote fs.Debugf(nil, "oldPath = %q", newPath) lastColon := strings.LastIndex(newPath, ":") require.True(t, lastColon >= 0) newPath = newPath[:lastColon] + ",versions" + newPath[lastColon:] fs.Debugf(nil, "newPath = %q", newPath) fNew, err := cache.Get(ctx, newPath) // This should return pointing to a file require.Equal(t, fs.ErrorIsFile, err) require.NotNil(t, fNew) // With the directory above assert.Equal(t, dirName, path.Base(fs.ConfigStringFull(fNew))) }) }) t.Run("VersionAt", func(t *testing.T) { // We set --b2-version-at for this test so make sure we reset it at the end defer func() { f.opt.VersionAt = fs.Time{} }() var ( firstObjectTime = time.Time(objMetadata.UploadTimestamp) secondObjectTime = time.Time(newObjMetadata.UploadTimestamp) ) for _, test := range []struct { what string at time.Time want []fstest.Item wantErr error wantSize int64 }{ { what: "Before", at: firstObjectTime.Add(-time.Second), want: fstests.InternalTestFiles, wantErr: fs.ErrorObjectNotFound, }, { what: "AfterOne", at: firstObjectTime.Add(time.Second), want: append([]fstest.Item{item}, fstests.InternalTestFiles...), wantSize: 100, }, { what: "AfterDelete", at: secondObjectTime.Add(-time.Second), want: fstests.InternalTestFiles, wantErr: fs.ErrorObjectNotFound, }, { what: "AfterTwo", at: secondObjectTime.Add(time.Second), want: append([]fstest.Item{newItem}, fstests.InternalTestFiles...), wantSize: 101, }, } { t.Run(test.what, func(t *testing.T) { f.opt.VersionAt = fs.Time(test.at) t.Run("List", func(t *testing.T) { fstest.CheckListing(t, f, test.want) }) t.Run("NewObject", func(t *testing.T) { gotObj, gotErr := f.NewObject(ctx, fileName) assert.Equal(t, test.wantErr, gotErr) if gotErr == nil { assert.Equal(t, test.wantSize, gotObj.Size()) } }) }) } }) t.Run("Cleanup", func(t *testing.T) { t.Run("DryRun", func(t *testing.T) { f.opt.Versions = true defer func() { f.opt.Versions = false }() // Listing should be unchanged after dry run before := listAllFiles(ctx, t, f, dirName) ctx, ci := fs.AddConfig(ctx) ci.DryRun = true require.NoError(t, f.cleanUp(ctx, true, false, 0)) after := listAllFiles(ctx, t, f, dirName) assert.Equal(t, before, after) }) t.Run("RealThing", func(t *testing.T) { f.opt.Versions = true defer func() { f.opt.Versions = false }() // Listing should reflect current state after cleanup require.NoError(t, f.cleanUp(ctx, true, false, 0)) items := append([]fstest.Item{newItem}, fstests.InternalTestFiles...) fstest.CheckListing(t, f, items) }) }) // Purge gets tested later } func (f *Fs) InternalTestCleanupUnfinished(t *testing.T) { ctx := context.Background() // B2CleanupHidden tests cleaning up hidden files t.Run("CleanupUnfinished", func(t *testing.T) { dirName := "unfinished" fileCount := 5 expectedFiles := []string{} for i := 1; i < fileCount; i++ { fileName := fmt.Sprintf("%s/unfinished-%d", dirName, i) expectedFiles = append(expectedFiles, fileName) obj := &Object{ fs: f, remote: fileName, } objInfo := object.NewStaticObjectInfo(fileName, fstest.Time("2002-02-03T04:05:06.499999999Z"), -1, true, nil, nil) _, err := f.newLargeUpload(ctx, obj, nil, objInfo, f.opt.ChunkSize, false, nil) require.NoError(t, err) } checkListing(ctx, t, f, dirName, expectedFiles) t.Run("DryRun", func(t *testing.T) { // Listing should not change after dry run ctx, ci := fs.AddConfig(ctx) ci.DryRun = true require.NoError(t, f.cleanUp(ctx, false, true, 0)) checkListing(ctx, t, f, dirName, expectedFiles) }) t.Run("RealThing", func(t *testing.T) { // Listing should be empty after real cleanup require.NoError(t, f.cleanUp(ctx, false, true, 0)) checkListing(ctx, t, f, dirName, []string{}) }) }) } func listAllFiles(ctx context.Context, t *testing.T, f *Fs, dirName string) []string { bucket, directory := f.split(dirName) foundFiles := []string{} require.NoError(t, f.list(ctx, bucket, directory, "", false, true, 0, true, false, func(remote string, object *api.File, isDirectory bool) error { if !isDirectory { foundFiles = append(foundFiles, object.Name) } return nil })) sort.Strings(foundFiles) return foundFiles } func checkListing(ctx context.Context, t *testing.T, f *Fs, dirName string, expectedFiles []string) { foundFiles := listAllFiles(ctx, t, f, dirName) sort.Strings(expectedFiles) assert.Equal(t, expectedFiles, foundFiles) } func (f *Fs) InternalTestLifecycleRules(t *testing.T) { ctx := context.Background() opt := map[string]string{} t.Run("InitState", func(t *testing.T) { // There should be no lifecycle rules at the outset lifecycleRulesIf, err := f.lifecycleCommand(ctx, "lifecycle", nil, opt) lifecycleRules := lifecycleRulesIf.([]api.LifecycleRule) require.NoError(t, err) assert.Equal(t, 0, len(lifecycleRules)) }) t.Run("DryRun", func(t *testing.T) { // There should still be no lifecycle rules after each dry run operation ctx, ci := fs.AddConfig(ctx) ci.DryRun = true opt["daysFromHidingToDeleting"] = "30" lifecycleRulesIf, err := f.lifecycleCommand(ctx, "lifecycle", nil, opt) lifecycleRules := lifecycleRulesIf.([]api.LifecycleRule) require.NoError(t, err) assert.Equal(t, 0, len(lifecycleRules)) delete(opt, "daysFromHidingToDeleting") opt["daysFromUploadingToHiding"] = "40" lifecycleRulesIf, err = f.lifecycleCommand(ctx, "lifecycle", nil, opt) lifecycleRules = lifecycleRulesIf.([]api.LifecycleRule) require.NoError(t, err) assert.Equal(t, 0, len(lifecycleRules)) opt["daysFromHidingToDeleting"] = "30" lifecycleRulesIf, err = f.lifecycleCommand(ctx, "lifecycle", nil, opt) lifecycleRules = lifecycleRulesIf.([]api.LifecycleRule) require.NoError(t, err) assert.Equal(t, 0, len(lifecycleRules)) }) t.Run("RealThing", func(t *testing.T) { opt["daysFromHidingToDeleting"] = "30" lifecycleRulesIf, err := f.lifecycleCommand(ctx, "lifecycle", nil, opt) lifecycleRules := lifecycleRulesIf.([]api.LifecycleRule) require.NoError(t, err) assert.Equal(t, 1, len(lifecycleRules)) assert.Equal(t, 30, *lifecycleRules[0].DaysFromHidingToDeleting) delete(opt, "daysFromHidingToDeleting") opt["daysFromUploadingToHiding"] = "40" lifecycleRulesIf, err = f.lifecycleCommand(ctx, "lifecycle", nil, opt) lifecycleRules = lifecycleRulesIf.([]api.LifecycleRule) require.NoError(t, err) assert.Equal(t, 1, len(lifecycleRules)) assert.Equal(t, 40, *lifecycleRules[0].DaysFromUploadingToHiding) opt["daysFromHidingToDeleting"] = "30" lifecycleRulesIf, err = f.lifecycleCommand(ctx, "lifecycle", nil, opt) lifecycleRules = lifecycleRulesIf.([]api.LifecycleRule) require.NoError(t, err) assert.Equal(t, 1, len(lifecycleRules)) assert.Equal(t, 30, *lifecycleRules[0].DaysFromHidingToDeleting) assert.Equal(t, 40, *lifecycleRules[0].DaysFromUploadingToHiding) }) } // -run TestIntegration/FsMkdir/FsPutFiles/Internal func (f *Fs) InternalTest(t *testing.T) { t.Run("Metadata", f.InternalTestMetadata) t.Run("Versions", f.InternalTestVersions) t.Run("CleanupUnfinished", f.InternalTestCleanupUnfinished) t.Run("LifecycleRules", f.InternalTestLifecycleRules) } var _ fstests.InternalTester = (*Fs)(nil) rclone-v1.71.0/backend/b2/b2_test.go000066400000000000000000000016121505210326400170310ustar00rootroot00000000000000// Test B2 filesystem interface package b2 import ( "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestB2:", NilObject: (*Object)(nil), ChunkedUpload: fstests.ChunkedUploadConfig{ MinChunkSize: minChunkSize, NeedMultipleChunks: true, }, }) } func (f *Fs) SetUploadChunkSize(cs fs.SizeSuffix) (fs.SizeSuffix, error) { return f.setUploadChunkSize(cs) } func (f *Fs) SetUploadCutoff(cs fs.SizeSuffix) (fs.SizeSuffix, error) { return f.setUploadCutoff(cs) } func (f *Fs) SetCopyCutoff(cs fs.SizeSuffix) (fs.SizeSuffix, error) { return f.setCopyCutoff(cs) } var ( _ fstests.SetUploadChunkSizer = (*Fs)(nil) _ fstests.SetUploadCutoffer = (*Fs)(nil) _ fstests.SetCopyCutoffer = (*Fs)(nil) ) rclone-v1.71.0/backend/b2/upload.go000066400000000000000000000355601505210326400167640ustar00rootroot00000000000000// Upload large files for b2 // // Docs - https://www.backblaze.com/docs/cloud-storage-large-files package b2 import ( "context" "crypto/sha1" "encoding/hex" "fmt" gohash "hash" "io" "strings" "sync" "github.com/rclone/rclone/backend/b2/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/chunksize" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/atexit" "github.com/rclone/rclone/lib/pool" "github.com/rclone/rclone/lib/rest" "golang.org/x/sync/errgroup" ) type hashAppendingReader struct { h gohash.Hash in io.Reader hexSum string hexReader io.Reader } // Read returns bytes all bytes from the original reader, then the hex sum // of what was read so far, then EOF. func (har *hashAppendingReader) Read(b []byte) (int, error) { if har.hexReader == nil { n, err := har.in.Read(b) if err == io.EOF { har.in = nil // allow GC err = nil // allow reading hexSum before EOF har.hexSum = hex.EncodeToString(har.h.Sum(nil)) har.hexReader = strings.NewReader(har.hexSum) } return n, err } return har.hexReader.Read(b) } // AdditionalLength returns how many bytes the appended hex sum will take up. func (har *hashAppendingReader) AdditionalLength() int { return hex.EncodedLen(har.h.Size()) } // HexSum returns the hash sum as hex. It's only available after the original // reader has EOF'd. It's an empty string before that. func (har *hashAppendingReader) HexSum() string { return har.hexSum } // newHashAppendingReader takes a Reader and a Hash and will append the hex sum // after the original reader reaches EOF. The increased size depends on the // given hash, which may be queried through AdditionalLength() func newHashAppendingReader(in io.Reader, h gohash.Hash) *hashAppendingReader { withHash := io.TeeReader(in, h) return &hashAppendingReader{h: h, in: withHash} } // largeUpload is used to control the upload of large files which need chunking type largeUpload struct { f *Fs // parent Fs o *Object // object being uploaded doCopy bool // doing copy rather than upload what string // text name of operation for logs in io.Reader // read the data from here wrap accounting.WrapFn // account parts being transferred id string // ID of the file being uploaded size int64 // total size parts int // calculated number of parts, if known sha1smu sync.Mutex // mutex to protect sha1s sha1s []string // slice of SHA1s for each part uploadMu sync.Mutex // lock for upload variable uploads []*api.GetUploadPartURLResponse // result of get upload URL calls chunkSize int64 // chunk size to use src *Object // if copying, object we are reading from info *api.FileInfo // final response with info about the object } // newLargeUpload starts an upload of object o from in with metadata in src // // If newInfo is set then metadata from that will be used instead of reading it from src func (f *Fs) newLargeUpload(ctx context.Context, o *Object, in io.Reader, src fs.ObjectInfo, defaultChunkSize fs.SizeSuffix, doCopy bool, newInfo *api.File, options ...fs.OpenOption) (up *largeUpload, err error) { size := src.Size() parts := 0 chunkSize := defaultChunkSize if size == -1 { fs.Debugf(o, "Streaming upload with --b2-chunk-size %s allows uploads of up to %s and will fail only when that limit is reached.", f.opt.ChunkSize, maxParts*f.opt.ChunkSize) } else { chunkSize = chunksize.Calculator(o, size, maxParts, defaultChunkSize) parts = int(size / int64(chunkSize)) if size%int64(chunkSize) != 0 { parts++ } } bucket, bucketPath := o.split() bucketID, err := f.getBucketID(ctx, bucket) if err != nil { return nil, err } var request = api.StartLargeFileRequest{ BucketID: bucketID, Name: f.opt.Enc.FromStandardPath(bucketPath), } optionsToSend := make([]fs.OpenOption, 0, len(options)) if newInfo == nil { modTime, err := o.getModTime(ctx, src, options) if err != nil { return nil, err } request.ContentType = fs.MimeType(ctx, src) request.Info = map[string]string{ timeKey: timeString(modTime), } // Custom upload headers - remove header prefix since they are sent in the body for _, option := range options { k, v := option.Header() k = strings.ToLower(k) if strings.HasPrefix(k, headerPrefix) { request.Info[k[len(headerPrefix):]] = v } else { optionsToSend = append(optionsToSend, option) } } // Set the SHA1 if known if !o.fs.opt.DisableCheckSum || doCopy { if calculatedSha1, err := src.Hash(ctx, hash.SHA1); err == nil && calculatedSha1 != "" { request.Info[sha1Key] = calculatedSha1 } } } else { request.ContentType = newInfo.ContentType request.Info = newInfo.Info } opts := rest.Opts{ Method: "POST", Path: "/b2_start_large_file", Options: optionsToSend, } var response api.StartLargeFileResponse err = f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, &request, &response) return f.shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } up = &largeUpload{ f: f, o: o, doCopy: doCopy, what: "upload", id: response.ID, size: size, parts: parts, sha1s: make([]string, 0, 16), chunkSize: int64(chunkSize), } // unwrap the accounting from the input, we use wrap to put it // back on after the buffering if doCopy { up.what = "copy" up.src = src.(*Object) } else { up.in, up.wrap = accounting.UnWrap(in) } return up, nil } // getUploadURL returns the upload info with the UploadURL and the AuthorizationToken // // This should be returned with returnUploadURL when finished func (up *largeUpload) getUploadURL(ctx context.Context) (upload *api.GetUploadPartURLResponse, err error) { up.uploadMu.Lock() if len(up.uploads) > 0 { upload, up.uploads = up.uploads[0], up.uploads[1:] up.uploadMu.Unlock() return upload, nil } up.uploadMu.Unlock() opts := rest.Opts{ Method: "POST", Path: "/b2_get_upload_part_url", } var request = api.GetUploadPartURLRequest{ ID: up.id, } err = up.f.pacer.Call(func() (bool, error) { resp, err := up.f.srv.CallJSON(ctx, &opts, &request, &upload) return up.f.shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("failed to get upload URL: %w", err) } return upload, nil } // returnUploadURL returns the UploadURL to the cache func (up *largeUpload) returnUploadURL(upload *api.GetUploadPartURLResponse) { if upload == nil { return } up.uploadMu.Lock() up.uploads = append(up.uploads, upload) up.uploadMu.Unlock() } // Add an sha1 to the being built up sha1s func (up *largeUpload) addSha1(chunkNumber int, sha1 string) { up.sha1smu.Lock() defer up.sha1smu.Unlock() if len(up.sha1s) < chunkNumber+1 { up.sha1s = append(up.sha1s, make([]string, chunkNumber+1-len(up.sha1s))...) } up.sha1s[chunkNumber] = sha1 } // WriteChunk will write chunk number with reader bytes, where chunk number >= 0 func (up *largeUpload) WriteChunk(ctx context.Context, chunkNumber int, reader io.ReadSeeker) (size int64, err error) { // 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(1) } err = up.f.pacer.Call(func() (bool, error) { // Discover the size by seeking to the end size, err = reader.Seek(0, io.SeekEnd) if err != nil { return false, err } // rewind the reader on retry and after reading size _, err = reader.Seek(0, io.SeekStart) if err != nil { return false, err } fs.Debugf(up.o, "Sending chunk %d length %d", chunkNumber, size) // Get upload URL upload, err := up.getUploadURL(ctx) if err != nil { return false, err } in := newHashAppendingReader(reader, sha1.New()) sizeWithHash := size + int64(in.AdditionalLength()) // Authorization // // An upload authorization token, from b2_get_upload_part_url. // // X-Bz-Part-Number // // A number from 1 to 10000. The parts uploaded for one file // must have contiguous numbers, starting with 1. // // Content-Length // // The number of bytes in the file being uploaded. Note that // this header is required; you cannot leave it out and just // use chunked encoding. The minimum size of every part but // the last one is 100 MB (100,000,000 bytes) // // X-Bz-Content-Sha1 // // The SHA1 checksum of the this part of the file. B2 will // check this when the part is uploaded, to make sure that the // data arrived correctly. The same SHA1 checksum must be // passed to b2_finish_large_file. opts := rest.Opts{ Method: "POST", RootURL: upload.UploadURL, Body: up.wrap(in), ExtraHeaders: map[string]string{ "Authorization": upload.AuthorizationToken, "X-Bz-Part-Number": fmt.Sprintf("%d", chunkNumber+1), sha1Header: "hex_digits_at_end", }, ContentLength: &sizeWithHash, } var response api.UploadPartResponse resp, err := up.f.srv.CallJSON(ctx, &opts, nil, &response) retry, err := up.f.shouldRetry(ctx, resp, err) if err != nil { fs.Debugf(up.o, "Error sending chunk %d (retry=%v): %v: %#v", chunkNumber, retry, err, err) } // On retryable error clear PartUploadURL if retry { fs.Debugf(up.o, "Clearing part upload URL because of error: %v", err) upload = nil } up.returnUploadURL(upload) up.addSha1(chunkNumber, in.HexSum()) return retry, err }) if err != nil { fs.Debugf(up.o, "Error sending chunk %d: %v", chunkNumber, err) } else { fs.Debugf(up.o, "Done sending chunk %d", chunkNumber) } return size, err } // Copy a chunk func (up *largeUpload) copyChunk(ctx context.Context, part int, partSize int64) error { err := up.f.pacer.Call(func() (bool, error) { fs.Debugf(up.o, "Copying chunk %d length %d", part, partSize) opts := rest.Opts{ Method: "POST", Path: "/b2_copy_part", } offset := int64(part) * up.chunkSize // where we are in the source file var request = api.CopyPartRequest{ SourceID: up.src.id, LargeFileID: up.id, PartNumber: int64(part + 1), Range: fmt.Sprintf("bytes=%d-%d", offset, offset+partSize-1), } var response api.UploadPartResponse resp, err := up.f.srv.CallJSON(ctx, &opts, &request, &response) retry, err := up.f.shouldRetry(ctx, resp, err) if err != nil { fs.Debugf(up.o, "Error copying chunk %d (retry=%v): %v: %#v", part, retry, err, err) } up.addSha1(part, response.SHA1) return retry, err }) if err != nil { fs.Debugf(up.o, "Error copying chunk %d: %v", part, err) } else { fs.Debugf(up.o, "Done copying chunk %d", part) } return err } // Close closes off the large upload func (up *largeUpload) Close(ctx context.Context) error { fs.Debugf(up.o, "Finishing large file %s with %d parts", up.what, up.parts) opts := rest.Opts{ Method: "POST", Path: "/b2_finish_large_file", } var request = api.FinishLargeFileRequest{ ID: up.id, SHA1s: up.sha1s, } var response api.FileInfo err := up.f.pacer.Call(func() (bool, error) { resp, err := up.f.srv.CallJSON(ctx, &opts, &request, &response) return up.f.shouldRetry(ctx, resp, err) }) if err != nil { return err } up.info = &response return nil } // Abort aborts the large upload func (up *largeUpload) Abort(ctx context.Context) error { fs.Debugf(up.o, "Cancelling large file %s", up.what) opts := rest.Opts{ Method: "POST", Path: "/b2_cancel_large_file", } var request = api.CancelLargeFileRequest{ ID: up.id, } var response api.CancelLargeFileResponse err := up.f.pacer.Call(func() (bool, error) { resp, err := up.f.srv.CallJSON(ctx, &opts, &request, &response) return up.f.shouldRetry(ctx, resp, err) }) if err != nil { fs.Errorf(up.o, "Failed to cancel large file %s: %v", up.what, err) } return err } // Stream uploads the chunks from the input, starting with a required initial // chunk. Assumes the file size is unknown and will upload until the input // reaches EOF. // // Note that initialUploadBlock must be returned to f.putBuf() func (up *largeUpload) Stream(ctx context.Context, initialUploadBlock *pool.RW) (err error) { defer atexit.OnError(&err, func() { _ = up.Abort(ctx) })() fs.Debugf(up.o, "Starting streaming of large file (id %q)", up.id) var ( g, gCtx = errgroup.WithContext(ctx) hasMoreParts = true ) up.size = initialUploadBlock.Size() up.parts = 0 for part := 0; hasMoreParts; part++ { // Get a block of memory from the pool and token which limits concurrency. var rw *pool.RW if part == 0 { rw = initialUploadBlock } else { rw = up.f.getRW(false) } // Fail fast, in case an errgroup managed function returns an error // gCtx is cancelled. There is no point in uploading all the other parts. if gCtx.Err() != nil { up.f.putRW(rw) break } // Read the chunk var n int64 if part == 0 { n = rw.Size() } else { n, err = io.CopyN(rw, up.in, up.chunkSize) if err == io.EOF { if n == 0 { fs.Debugf(up.o, "Not sending empty chunk after EOF - ending.") up.f.putRW(rw) break } else { fs.Debugf(up.o, "Read less than a full chunk %d, making this the last one.", n) } hasMoreParts = false } else if err != nil { // other kinds of errors indicate failure up.f.putRW(rw) return err } } // Keep stats up to date up.parts += 1 up.size += n if part > maxParts { up.f.putRW(rw) return fmt.Errorf("%q too big (%d bytes so far) makes too many parts %d > %d - increase --b2-chunk-size", up.o, up.size, up.parts, maxParts) } part := part // for the closure g.Go(func() (err error) { defer up.f.putRW(rw) _, err = up.WriteChunk(gCtx, part, rw) return err }) } err = g.Wait() if err != nil { return err } return up.Close(ctx) } // Copy the chunks from the source to the destination func (up *largeUpload) Copy(ctx context.Context) (err error) { defer atexit.OnError(&err, func() { _ = up.Abort(ctx) })() fs.Debugf(up.o, "Starting %s of large file in %d chunks (id %q)", up.what, up.parts, up.id) var ( g, gCtx = errgroup.WithContext(ctx) remaining = up.size ) g.SetLimit(up.f.opt.UploadConcurrency) for part := range up.parts { // Fail fast, in case an errgroup managed function returns an error // gCtx is cancelled. There is no point in copying all the other parts. if gCtx.Err() != nil { break } reqSize := min(remaining, up.chunkSize) part := part // for the closure g.Go(func() (err error) { return up.copyChunk(gCtx, part, reqSize) }) remaining -= reqSize } err = g.Wait() if err != nil { return err } return up.Close(ctx) } rclone-v1.71.0/backend/box/000077500000000000000000000000001505210326400154255ustar00rootroot00000000000000rclone-v1.71.0/backend/box/api/000077500000000000000000000000001505210326400161765ustar00rootroot00000000000000rclone-v1.71.0/backend/box/api/types.go000066400000000000000000000224701505210326400176760ustar00rootroot00000000000000// Package api has type definitions for box // // Converted from the API docs with help from https://mholt.github.io/json-to-go/ package api import ( "encoding/json" "fmt" "time" ) const ( // 2017-05-03T07:26:10-07:00 timeFormat = `"` + time.RFC3339 + `"` ) // Time represents date and time information for the // box API, by using RFC3339 type Time time.Time // MarshalJSON turns a Time into JSON (in UTC) func (t *Time) MarshalJSON() (out []byte, err error) { timeString := (*time.Time)(t).Format(timeFormat) return []byte(timeString), nil } // UnmarshalJSON turns JSON into a Time func (t *Time) UnmarshalJSON(data []byte) error { newT, err := time.Parse(timeFormat, string(data)) if err != nil { return err } *t = Time(newT) return nil } // Error is returned from box when things go wrong type Error struct { Type string `json:"type"` Status int `json:"status"` Code string `json:"code"` ContextInfo json.RawMessage `json:"context_info"` HelpURL string `json:"help_url"` Message string `json:"message"` RequestID string `json:"request_id"` } // Error returns a string for the error and satisfies the error interface func (e *Error) Error() string { out := fmt.Sprintf("Error %q (%d)", e.Code, e.Status) if e.Message != "" { out += ": " + e.Message } if e.ContextInfo != nil { out += fmt.Sprintf(" (%s)", string(e.ContextInfo)) } return out } // Check Error satisfies the error interface var _ error = (*Error)(nil) // ItemFields are the fields needed for FileInfo var ItemFields = "type,id,sequence_id,etag,sha1,name,size,created_at,modified_at,content_created_at,content_modified_at,item_status,shared_link,owned_by" // Types of things in Item/ItemMini const ( ItemTypeFolder = "folder" ItemTypeFile = "file" ItemStatusActive = "active" ItemStatusTrashed = "trashed" ItemStatusDeleted = "deleted" ) // ItemMini is a subset of the elements in a full Item returned by some API calls type ItemMini struct { Type string `json:"type"` ID string `json:"id"` SequenceID int64 `json:"sequence_id,string"` Etag string `json:"etag"` SHA1 string `json:"sha1"` Name string `json:"name"` } // Item describes a folder or a file as returned by Get Folder Items and others type Item struct { Type string `json:"type"` ID string `json:"id"` SequenceID int64 `json:"sequence_id,string"` Etag string `json:"etag"` SHA1 string `json:"sha1"` Name string `json:"name"` Size float64 `json:"size"` // box returns this in xEyy format for very large numbers - see #2261 CreatedAt Time `json:"created_at"` ModifiedAt Time `json:"modified_at"` ContentCreatedAt Time `json:"content_created_at"` ContentModifiedAt Time `json:"content_modified_at"` ItemStatus string `json:"item_status"` // active, trashed if the file has been moved to the trash, and deleted if the file has been permanently deleted Parent ItemMini `json:"parent"` SharedLink struct { URL string `json:"url,omitempty"` Access string `json:"access,omitempty"` } `json:"shared_link"` OwnedBy struct { Type string `json:"type"` ID string `json:"id"` Name string `json:"name"` Login string `json:"login"` } `json:"owned_by"` } // ModTime returns the modification time of the item func (i *Item) ModTime() (t time.Time) { t = time.Time(i.ContentModifiedAt) if t.IsZero() { t = time.Time(i.ModifiedAt) } return t } // FolderItems is returned from the GetFolderItems call type FolderItems struct { TotalCount int `json:"total_count"` Entries []Item `json:"entries"` Offset int `json:"offset"` Limit int `json:"limit"` NextMarker *string `json:"next_marker,omitempty"` Order []struct { By string `json:"by"` Direction string `json:"direction"` } `json:"order"` } // Parent defined the ID of the parent directory type Parent struct { ID string `json:"id"` } // CreateFolder is the request for Create Folder type CreateFolder struct { Name string `json:"name"` Parent Parent `json:"parent"` } // UploadFile is the request for Upload File type UploadFile struct { Name string `json:"name"` Parent Parent `json:"parent"` ContentCreatedAt Time `json:"content_created_at"` ContentModifiedAt Time `json:"content_modified_at"` } // PreUploadCheck is the request for upload preflight check type PreUploadCheck struct { Name string `json:"name"` Parent Parent `json:"parent"` Size *int64 `json:"size,omitempty"` } // PreUploadCheckResponse is the response from upload preflight check // if successful type PreUploadCheckResponse struct { UploadToken string `json:"upload_token"` UploadURL string `json:"upload_url"` } // PreUploadCheckConflict is returned in the ContextInfo error field // from PreUploadCheck when the error code is "item_name_in_use" type PreUploadCheckConflict struct { Conflicts ItemMini `json:"conflicts"` } // UpdateFileModTime is used in Update File Info type UpdateFileModTime struct { ContentModifiedAt Time `json:"content_modified_at"` } // UpdateFileMove is the request for Upload File to change name and parent type UpdateFileMove struct { Name string `json:"name"` Parent Parent `json:"parent"` } // CopyFile is the request for Copy File type CopyFile struct { Name string `json:"name"` Parent Parent `json:"parent"` } // CreateSharedLink is the request for Public Link type CreateSharedLink struct { SharedLink struct { URL string `json:"url,omitempty"` Access string `json:"access,omitempty"` } `json:"shared_link"` } // UploadSessionRequest is uses in Create Upload Session type UploadSessionRequest struct { FolderID string `json:"folder_id,omitempty"` // don't pass for update FileSize int64 `json:"file_size"` FileName string `json:"file_name,omitempty"` // optional for update } // UploadSessionResponse is returned from Create Upload Session type UploadSessionResponse struct { TotalParts int `json:"total_parts"` PartSize int64 `json:"part_size"` SessionEndpoints struct { ListParts string `json:"list_parts"` Commit string `json:"commit"` UploadPart string `json:"upload_part"` Status string `json:"status"` Abort string `json:"abort"` } `json:"session_endpoints"` SessionExpiresAt Time `json:"session_expires_at"` ID string `json:"id"` Type string `json:"type"` NumPartsProcessed int `json:"num_parts_processed"` } // Part defines the return from upload part call which are passed to commit upload also type Part struct { PartID string `json:"part_id"` Offset int64 `json:"offset"` Size int64 `json:"size"` Sha1 string `json:"sha1"` } // UploadPartResponse is returned from the upload part call type UploadPartResponse struct { Part Part `json:"part"` } // CommitUpload is used in the Commit Upload call type CommitUpload struct { Parts []Part `json:"parts"` Attributes struct { ContentCreatedAt Time `json:"content_created_at"` ContentModifiedAt Time `json:"content_modified_at"` } `json:"attributes"` } // ConfigJSON defines the shape of a box config.json type ConfigJSON struct { BoxAppSettings AppSettings `json:"boxAppSettings"` EnterpriseID string `json:"enterpriseID"` } // AppSettings defines the shape of the boxAppSettings within box config.json type AppSettings struct { ClientID string `json:"clientID"` ClientSecret string `json:"clientSecret"` AppAuth AppAuth `json:"appAuth"` } // AppAuth defines the shape of the appAuth within boxAppSettings in config.json type AppAuth struct { PublicKeyID string `json:"publicKeyID"` PrivateKey string `json:"privateKey"` Passphrase string `json:"passphrase"` } // User is returned from /users/me type User struct { Type string `json:"type"` ID string `json:"id"` Name string `json:"name"` Login string `json:"login"` CreatedAt time.Time `json:"created_at"` 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"` Status string `json:"status"` JobTitle string `json:"job_title"` Phone string `json:"phone"` Address string `json:"address"` AvatarURL string `json:"avatar_url"` } // FileTreeChangeEventTypes are the events that can require cache invalidation var FileTreeChangeEventTypes = map[string]struct{}{ "ITEM_COPY": {}, "ITEM_CREATE": {}, "ITEM_MAKE_CURRENT_VERSION": {}, "ITEM_MODIFY": {}, "ITEM_MOVE": {}, "ITEM_RENAME": {}, "ITEM_TRASH": {}, "ITEM_UNDELETE_VIA_TRASH": {}, "ITEM_UPLOAD": {}, } // Event is an array element in the response returned from /events type Event struct { EventType string `json:"event_type"` EventID string `json:"event_id"` Source Item `json:"source"` } // Events is returned from /events type Events struct { ChunkSize int64 `json:"chunk_size"` Entries []Event `json:"entries"` NextStreamPosition int64 `json:"next_stream_position"` } rclone-v1.71.0/backend/box/box.go000066400000000000000000001461701505210326400165550ustar00rootroot00000000000000// Package box provides an interface to the Box // object storage system. package box // FIXME Box only supports file names of 255 characters or less. Names // that will not be supported are those that contain non-printable // ascii, / or \, names with trailing spaces, and the special names // “.” and “..”. // FIXME box can copy a directory import ( "context" "crypto/rsa" "encoding/json" "encoding/pem" "errors" "fmt" "io" "net/http" "net/url" "os" "path" "strconv" "strings" "sync" "sync/atomic" "time" "github.com/golang-jwt/jwt/v4" "github.com/rclone/rclone/backend/box/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/dircache" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/env" "github.com/rclone/rclone/lib/jwtutil" "github.com/rclone/rclone/lib/oauthutil" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/random" "github.com/rclone/rclone/lib/rest" "github.com/youmark/pkcs8" ) const ( rcloneClientID = "d0374ba6pgmaguie02ge15sv1mllndho" rcloneEncryptedClientSecret = "sYbJYm99WB8jzeaLPU0OPDMJKIkZvD2qOn3SyEMfiJr03RdtDt3xcZEIudRhbIDL" minSleep = 10 * time.Millisecond maxSleep = 2 * time.Second decayConstant = 2 // bigger for slower decay, exponential rootURL = "https://api.box.com/2.0" uploadURL = "https://upload.box.com/api/2.0" minUploadCutoff = 50000000 // upload cutoff can be no lower than this defaultUploadCutoff = 50 * 1024 * 1024 tokenURL = "https://api.box.com/oauth2/token" ) // Globals var ( // Description of how to auth for this app oauthConfig = &oauthutil.Config{ Scopes: nil, AuthURL: "https://app.box.com/api/oauth2/authorize", TokenURL: "https://app.box.com/api/oauth2/token", ClientID: rcloneClientID, ClientSecret: obscure.MustReveal(rcloneEncryptedClientSecret), RedirectURL: oauthutil.RedirectURL, } ) type boxCustomClaims struct { jwt.StandardClaims BoxSubType string `json:"box_sub_type,omitempty"` } // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "box", Description: "Box", NewFs: NewFs, Config: func(ctx context.Context, name string, m configmap.Mapper, config fs.ConfigIn) (*fs.ConfigOut, error) { jsonFile, ok := m.Get("box_config_file") boxSubType, boxSubTypeOk := m.Get("box_sub_type") boxAccessToken, boxAccessTokenOk := m.Get("access_token") var err error // If using box config.json, use JWT auth if ok && boxSubTypeOk && jsonFile != "" && boxSubType != "" { err = refreshJWTToken(ctx, jsonFile, boxSubType, name, m) if err != nil { return nil, fmt.Errorf("failed to configure token with jwt authentication: %w", err) } // Else, if not using an access token, use oauth2 } else if boxAccessToken == "" || !boxAccessTokenOk { return oauthutil.ConfigOut("", &oauthutil.Options{ OAuth2Config: oauthConfig, }) } return nil, nil }, Options: append(oauthutil.SharedOptions, []fs.Option{{ Name: "root_folder_id", Help: "Fill in for rclone to use a non root folder as its starting point.", Default: "0", Advanced: true, Sensitive: true, }, { Name: "box_config_file", Help: "Box App config.json location\n\nLeave blank normally." + env.ShellExpandHelp, }, { Name: "access_token", Help: "Box App Primary Access Token\n\nLeave blank normally.", Sensitive: true, }, { Name: "box_sub_type", Default: "user", Examples: []fs.OptionExample{{ Value: "user", Help: "Rclone should act on behalf of a user.", }, { Value: "enterprise", Help: "Rclone should act on behalf of a service account.", }}, }, { Name: "upload_cutoff", Help: "Cutoff for switching to multipart upload (>= 50 MiB).", Default: fs.SizeSuffix(defaultUploadCutoff), Advanced: true, }, { Name: "commit_retries", Help: "Max number of times to try committing a multipart file.", Default: 100, Advanced: true, }, { Name: "list_chunk", Default: 1000, Help: "Size of listing chunk 1-1000.", Advanced: true, }, { Name: "owned_by", Default: "", Help: "Only show items owned by the login (email address) passed in.", Advanced: true, }, { Name: "impersonate", Default: "", Help: `Impersonate this user ID when using a service account. Setting this flag allows rclone, when using a JWT service account, to act on behalf of another user by setting the as-user header. The user ID is the Box identifier for a user. User IDs can found for any user via the GET /users endpoint, which is only available to admins, or by calling the GET /users/me endpoint with an authenticated user session. See: https://developer.box.com/guides/authentication/jwt/as-user/ `, Advanced: true, Sensitive: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, // From https://developer.box.com/docs/error-codes#section-400-bad-request : // > Box only supports file or folder names that are 255 characters or less. // > File names containing non-printable ascii, "/" or "\", names with leading // > or trailing spaces, and the special names “.” and “..” are also unsupported. // // Testing revealed names with leading spaces work fine. // Also encode invalid UTF-8 bytes as json doesn't handle them properly. Default: (encoder.Display | encoder.EncodeBackSlash | encoder.EncodeRightSpace | encoder.EncodeInvalidUtf8), }}...), }) } func refreshJWTToken(ctx context.Context, jsonFile string, boxSubType string, name string, m configmap.Mapper) error { jsonFile = env.ShellExpand(jsonFile) boxConfig, err := getBoxConfig(jsonFile) if err != nil { return fmt.Errorf("get box config: %w", err) } privateKey, err := getDecryptedPrivateKey(boxConfig) if err != nil { return fmt.Errorf("get decrypted private key: %w", err) } claims, err := getClaims(boxConfig, boxSubType) if err != nil { return fmt.Errorf("get claims: %w", err) } signingHeaders := getSigningHeaders(boxConfig) queryParams := getQueryParams(boxConfig) client := fshttp.NewClient(ctx) err = jwtutil.Config("box", name, tokenURL, *claims, signingHeaders, queryParams, privateKey, m, client) return err } func getBoxConfig(configFile string) (boxConfig *api.ConfigJSON, err error) { file, err := os.ReadFile(configFile) if err != nil { return nil, fmt.Errorf("box: failed to read Box config: %w", err) } err = json.Unmarshal(file, &boxConfig) if err != nil { return nil, fmt.Errorf("box: failed to parse Box config: %w", err) } return boxConfig, nil } func getClaims(boxConfig *api.ConfigJSON, boxSubType string) (claims *boxCustomClaims, err error) { val, err := jwtutil.RandomHex(20) if err != nil { return nil, fmt.Errorf("box: failed to generate random string for jti: %w", err) } claims = &boxCustomClaims{ //lint:ignore SA1019 since we need to use jwt.StandardClaims even if deprecated in jwt-go v4 until a more permanent solution is ready in time before jwt-go v5 where it is removed entirely //nolint:staticcheck // Don't include staticcheck when running golangci-lint to avoid SA1019 StandardClaims: jwt.StandardClaims{ Id: val, Issuer: boxConfig.BoxAppSettings.ClientID, Subject: boxConfig.EnterpriseID, Audience: tokenURL, ExpiresAt: time.Now().Add(time.Second * 45).Unix(), }, BoxSubType: boxSubType, } return claims, nil } func getSigningHeaders(boxConfig *api.ConfigJSON) map[string]any { signingHeaders := map[string]any{ "kid": boxConfig.BoxAppSettings.AppAuth.PublicKeyID, } return signingHeaders } func getQueryParams(boxConfig *api.ConfigJSON) map[string]string { queryParams := map[string]string{ "client_id": boxConfig.BoxAppSettings.ClientID, "client_secret": boxConfig.BoxAppSettings.ClientSecret, } return queryParams } func getDecryptedPrivateKey(boxConfig *api.ConfigJSON) (key *rsa.PrivateKey, err error) { block, rest := pem.Decode([]byte(boxConfig.BoxAppSettings.AppAuth.PrivateKey)) if block == nil { return nil, errors.New("box: failed to PEM decode private key") } if len(rest) > 0 { return nil, fmt.Errorf("box: extra data included in private key: %w", err) } rsaKey, err := pkcs8.ParsePKCS8PrivateKey(block.Bytes, []byte(boxConfig.BoxAppSettings.AppAuth.Passphrase)) if err != nil { return nil, fmt.Errorf("box: failed to decrypt private key: %w", err) } return rsaKey.(*rsa.PrivateKey), nil } // Options defines the configuration for this backend type Options struct { UploadCutoff fs.SizeSuffix `config:"upload_cutoff"` CommitRetries int `config:"commit_retries"` Enc encoder.MultiEncoder `config:"encoding"` RootFolderID string `config:"root_folder_id"` AccessToken string `config:"access_token"` ListChunk int `config:"list_chunk"` OwnedBy string `config:"owned_by"` Impersonate string `config:"impersonate"` } // ItemMeta defines metadata we cache for each Item ID type ItemMeta struct { SequenceID int64 // the most recent event processed for this item ParentID string // ID of the parent directory of this item Name string // leaf name of this item } // Fs represents a remote box type Fs struct { name string // name of this remote root string // the path we are working on opt Options // parsed options features *fs.Features // optional features srv *rest.Client // the connection to the server dirCache *dircache.DirCache // Map of directory path to directory id pacer *fs.Pacer // pacer for API calls tokenRenewer *oauthutil.Renew // renew the token on expiry uploadToken *pacer.TokenDispenser // control concurrency itemMetaCacheMu *sync.Mutex // protects itemMetaCache itemMetaCache map[string]ItemMeta // map of Item ID to selected metadata } // Object describes a box object // // Will definitely have info but maybe not meta type Object struct { fs *Fs // what this object is part of remote string // The remote path hasMetaData bool // whether info below has been set size int64 // size of the object modTime time.Time // modification time of the object id string // ID of the object publicLink string // Public Link for the object sha1 string // SHA-1 of the object content } // ------------------------------------------------------------ // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("box root '%s'", f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // parsePath parses a box 'url' func parsePath(path string) (root string) { root = strings.Trim(path, "/") return } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 429, // Too Many Requests. 500, // Internal Server Error 502, // Bad Gateway 503, // Service Unavailable 504, // Gateway Timeout 509, // Bandwidth Limit Exceeded } // shouldRetry returns a boolean as to whether this resp and err // deserve to be retried. It returns the err as a convenience func shouldRetry(ctx context.Context, resp *http.Response, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } authRetry := false if resp != nil && resp.StatusCode == 401 && strings.Contains(resp.Header.Get("Www-Authenticate"), "expired_token") { authRetry = true fs.Debugf(nil, "Should retry: %v", err) } // Box API errors which should be retries if apiErr, ok := err.(*api.Error); ok && apiErr.Code == "operation_blocked_temporary" { fs.Debugf(nil, "Retrying API error %v", err) return true, err } return authRetry || fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(resp, retryErrorCodes), err } // readMetaDataForPath reads the metadata from the path func (f *Fs) readMetaDataForPath(ctx context.Context, path string) (info *api.Item, err error) { // defer log.Trace(f, "path=%q", path)("info=%+v, err=%v", &info, &err) leaf, directoryID, err := f.dirCache.FindPath(ctx, path, false) if err != nil { if err == fs.ErrorDirNotFound { return nil, fs.ErrorObjectNotFound } return nil, err } // Use preupload to find the ID itemMini, err := f.preUploadCheck(ctx, leaf, directoryID, -1) if err != nil { return nil, err } if itemMini == nil { return nil, fs.ErrorObjectNotFound } // Now we have the ID we can look up the object proper opts := rest.Opts{ Method: "GET", Path: "/files/" + itemMini.ID, Parameters: fieldsValue(), } var item api.Item err = f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, nil, &item) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } return &item, nil } // errorHandler parses a non 2xx error response into an error func errorHandler(resp *http.Response) error { // Decode error response errResponse := new(api.Error) err := rest.DecodeJSON(resp, &errResponse) if err != nil { fs.Debugf(nil, "Couldn't decode error response: %v", err) } if errResponse.Code == "" { errResponse.Code = resp.Status } if errResponse.Status == 0 { errResponse.Status = resp.StatusCode } return errResponse } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } if opt.UploadCutoff < minUploadCutoff { return nil, fmt.Errorf("box: upload cutoff (%v) must be greater than equal to %v", opt.UploadCutoff, fs.SizeSuffix(minUploadCutoff)) } root = parsePath(root) client := fshttp.NewClient(ctx) var ts *oauthutil.TokenSource // If not using an accessToken, create an oauth client and tokensource if opt.AccessToken == "" { client, ts, err = oauthutil.NewClient(ctx, name, m, oauthConfig) if err != nil { return nil, fmt.Errorf("failed to configure Box: %w", err) } } ci := fs.GetConfig(ctx) f := &Fs{ name: name, root: root, opt: *opt, srv: rest.NewClient(client).SetRoot(rootURL), pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), uploadToken: pacer.NewTokenDispenser(ci.Transfers), itemMetaCacheMu: new(sync.Mutex), itemMetaCache: make(map[string]ItemMeta), } f.features = (&fs.Features{ CaseInsensitive: true, CanHaveEmptyDirectories: true, }).Fill(ctx, f) f.srv.SetErrorHandler(errorHandler) // If using an accessToken, set the Authorization header if f.opt.AccessToken != "" { f.srv.SetHeader("Authorization", "Bearer "+f.opt.AccessToken) } // If using impersonate set an as-user header if f.opt.Impersonate != "" { f.srv.SetHeader("as-user", f.opt.Impersonate) } jsonFile, ok := m.Get("box_config_file") boxSubType, boxSubTypeOk := m.Get("box_sub_type") if ts != nil { // If using box config.json and JWT, renewing should just refresh the token and // should do so whether there are uploads pending or not. if ok && boxSubTypeOk && jsonFile != "" && boxSubType != "" { f.tokenRenewer = oauthutil.NewRenew(f.String(), ts, func() error { err := refreshJWTToken(ctx, jsonFile, boxSubType, name, m) return err }) f.tokenRenewer.Start() } else { // Renew the token in the background f.tokenRenewer = oauthutil.NewRenew(f.String(), ts, func() error { _, err := f.readMetaDataForPath(ctx, "") return err }) } } // Get rootFolderID rootID := f.opt.RootFolderID f.dirCache = dircache.New(root, rootID, f) // Find the current root err = f.dirCache.FindRoot(ctx, false) if err != nil { // Assume it is a file newRoot, remote := dircache.SplitPath(root) tempF := *f tempF.dirCache = dircache.New(newRoot, rootID, &tempF) tempF.root = newRoot // Make new Fs which is the parent err = tempF.dirCache.FindRoot(ctx, false) if err != nil { // No root so return old f return f, nil } _, err := tempF.newObjectWithInfo(ctx, remote, nil) if err != nil { if err == fs.ErrorObjectNotFound { // File doesn't exist so return old f return f, nil } return nil, err } f.features.Fill(ctx, &tempF) // XXX: update the old f here instead of returning tempF, since // `features` were already filled with functions having *f as a receiver. // See https://github.com/rclone/rclone/issues/2182 f.dirCache = tempF.dirCache f.root = tempF.root // return an error with an fs which points to the parent return f, fs.ErrorIsFile } return f, nil } // rootSlash returns root with a slash on if it is empty, otherwise empty string func (f *Fs) rootSlash() string { if f.root == "" { return f.root } return f.root + "/" } // Return an Object from a path // // If it can't be found it returns the error fs.ErrorObjectNotFound. func (f *Fs) newObjectWithInfo(ctx context.Context, remote string, info *api.Item) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } var err error if info != nil { // Set info err = o.setMetaData(info) } else { err = o.readMetaData(ctx) // reads info and meta, returning an error } if err != nil { return nil, err } return o, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return f.newObjectWithInfo(ctx, remote, nil) } // FindLeaf finds a directory of name leaf in the folder with ID pathID func (f *Fs) FindLeaf(ctx context.Context, pathID, leaf string) (pathIDOut string, found bool, err error) { // Find the leaf in pathID found, err = f.listAll(ctx, pathID, true, false, true, func(item *api.Item) bool { if strings.EqualFold(item.Name, leaf) { pathIDOut = item.ID return true } return false }) return pathIDOut, found, err } // fieldsValue creates a url.Values with fields set to those in api.Item func fieldsValue() url.Values { values := url.Values{} values.Set("fields", api.ItemFields) return values } // CreateDir makes a directory with pathID as parent and name leaf func (f *Fs) CreateDir(ctx context.Context, pathID, leaf string) (newID string, err error) { // fs.Debugf(f, "CreateDir(%q, %q)\n", pathID, leaf) var resp *http.Response var info *api.Item opts := rest.Opts{ Method: "POST", Path: "/folders", Parameters: fieldsValue(), } mkdir := api.CreateFolder{ Name: f.opt.Enc.FromStandardName(leaf), Parent: api.Parent{ ID: pathID, }, } err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, &mkdir, &info) return shouldRetry(ctx, resp, err) }) if err != nil { // fmt.Printf("...Error %v\n", err) return "", err } // fmt.Printf("...Id %q\n", *info.Id) return info.ID, nil } // list the objects into the function supplied // // If directories is set it only sends directories // User function to process a File item from listAll // // Should return true to finish processing type listAllFn func(*api.Item) bool // Lists the directory required calling the user function on each item found // // If the user fn ever returns true then it early exits with found = true func (f *Fs) listAll(ctx context.Context, dirID string, directoriesOnly bool, filesOnly bool, activeOnly bool, fn listAllFn) (found bool, err error) { opts := rest.Opts{ Method: "GET", Path: "/folders/" + dirID + "/items", Parameters: fieldsValue(), } opts.Parameters.Set("limit", strconv.Itoa(f.opt.ListChunk)) opts.Parameters.Set("usemarker", "true") var marker *string OUTER: for { if marker != nil { opts.Parameters.Set("marker", *marker) } var result api.FolderItems var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, resp, err) }) if err != nil { return found, fmt.Errorf("couldn't list files: %w", err) } for i := range result.Entries { item := &result.Entries[i] if item.Type == api.ItemTypeFolder { if filesOnly { continue } } else if item.Type == api.ItemTypeFile { if directoriesOnly { continue } } else { fs.Debugf(f, "Ignoring %q - unknown type %q", item.Name, item.Type) continue } if activeOnly && item.ItemStatus != api.ItemStatusActive { continue } if f.opt.OwnedBy != "" && f.opt.OwnedBy != item.OwnedBy.Login { continue } item.Name = f.opt.Enc.ToStandardName(item.Name) if fn(item) { found = true break OUTER } } marker = result.NextMarker if marker == nil { break } } return } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { directoryID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { return nil, err } var iErr error _, err = f.listAll(ctx, directoryID, false, false, true, func(info *api.Item) bool { remote := path.Join(dir, info.Name) if info.Type == api.ItemTypeFolder { // cache the directory ID for later lookups f.dirCache.Put(remote, info.ID) d := fs.NewDir(remote, info.ModTime()).SetID(info.ID) // FIXME more info from dir? entries = append(entries, d) } else if info.Type == api.ItemTypeFile { o, err := f.newObjectWithInfo(ctx, remote, info) if err != nil { iErr = err return true } entries = append(entries, o) } // Cache some metadata for this Item to help us process events later // on. In particular, the box event API does not provide the old path // of the Item when it is renamed/deleted/moved/etc. f.itemMetaCacheMu.Lock() cachedItemMeta, found := f.itemMetaCache[info.ID] if !found || cachedItemMeta.SequenceID < info.SequenceID { f.itemMetaCache[info.ID] = ItemMeta{SequenceID: info.SequenceID, ParentID: directoryID, Name: info.Name} } f.itemMetaCacheMu.Unlock() return false }) if err != nil { return nil, err } if iErr != nil { return nil, iErr } return entries, nil } // Creates from the parameters passed in a half finished Object which // must have setMetaData called on it // // Returns the object, leaf, directoryID and error. // // Used to create new objects func (f *Fs) createObject(ctx context.Context, remote string, modTime time.Time, size int64) (o *Object, leaf string, directoryID string, err error) { // Create the directory for the object if it doesn't exist leaf, directoryID, err = f.dirCache.FindPath(ctx, remote, true) if err != nil { return } // Temporary Object under construction o = &Object{ fs: f, remote: remote, } return o, leaf, directoryID, nil } // preUploadCheck checks to see if a file can be uploaded // // It returns "", nil if the file is good to go // It returns "ID", nil if the file must be updated func (f *Fs) preUploadCheck(ctx context.Context, leaf, directoryID string, size int64) (item *api.ItemMini, err error) { check := api.PreUploadCheck{ Name: f.opt.Enc.FromStandardName(leaf), Parent: api.Parent{ ID: directoryID, }, } if size >= 0 { check.Size = &size } opts := rest.Opts{ Method: "OPTIONS", Path: "/files/content/", } var result api.PreUploadCheckResponse var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, &check, &result) return shouldRetry(ctx, resp, err) }) if err != nil { if apiErr, ok := err.(*api.Error); ok && apiErr.Code == "item_name_in_use" { var conflict api.PreUploadCheckConflict err = json.Unmarshal(apiErr.ContextInfo, &conflict) if err != nil { return nil, fmt.Errorf("pre-upload check: JSON decode failed: %w", err) } if conflict.Conflicts.Type != api.ItemTypeFile { return nil, fs.ErrorIsDir } return &conflict.Conflicts, nil } return nil, fmt.Errorf("pre-upload check: %w", err) } return nil, nil } // Put the object // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { // If directory doesn't exist, file doesn't exist so can upload remote := src.Remote() leaf, directoryID, err := f.dirCache.FindPath(ctx, remote, false) if err != nil { if err == fs.ErrorDirNotFound { return f.PutUnchecked(ctx, in, src, options...) } return nil, err } // Preflight check the upload, which returns the ID if the // object already exists item, err := f.preUploadCheck(ctx, leaf, directoryID, src.Size()) if err != nil { return nil, err } if item == nil { return f.PutUnchecked(ctx, in, src, options...) } // If object exists then create a skeleton one with just id o := &Object{ fs: f, remote: remote, id: item.ID, } return o, o.Update(ctx, in, src, options...) } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } // PutUnchecked the object into the container // // This will produce an error if the object already exists. // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) PutUnchecked(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { remote := src.Remote() size := src.Size() modTime := src.ModTime(ctx) o, _, _, err := f.createObject(ctx, remote, modTime, size) if err != nil { return nil, err } return o, o.Update(ctx, in, src, options...) } // Mkdir creates the container if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) error { _, err := f.dirCache.FindDir(ctx, dir, true) return err } // deleteObject removes an object by ID func (f *Fs) deleteObject(ctx context.Context, id string) error { opts := rest.Opts{ Method: "DELETE", Path: "/files/" + id, NoResponse: true, } return f.pacer.Call(func() (bool, error) { resp, err := f.srv.Call(ctx, &opts) return shouldRetry(ctx, resp, err) }) } // 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 { root := path.Join(f.root, dir) if root == "" { return errors.New("can't purge root directory") } dc := f.dirCache rootID, err := dc.FindDir(ctx, dir, false) if err != nil { return err } opts := rest.Opts{ Method: "DELETE", Path: "/folders/" + rootID, Parameters: url.Values{}, NoResponse: true, } opts.Parameters.Set("recursive", strconv.FormatBool(!check)) var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.Call(ctx, &opts) return shouldRetry(ctx, resp, err) }) if err != nil { return fmt.Errorf("rmdir failed: %w", err) } f.dirCache.FlushDir(dir) if err != nil { return err } return nil } // Rmdir deletes the root folder // // Returns an error if it isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, true) } // Precision return the precision of this Fs func (f *Fs) Precision() time.Duration { return time.Second } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (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) if err != nil { return nil, err } srcPath := srcObj.fs.rootSlash() + srcObj.remote dstPath := f.rootSlash() + remote if strings.EqualFold(srcPath, dstPath) { return nil, fmt.Errorf("can't copy %q -> %q as are same name when lowercase", srcPath, dstPath) } // Create temporary object dstObj, leaf, directoryID, err := f.createObject(ctx, remote, srcObj.modTime, srcObj.size) if err != nil { return nil, err } // check if dest already exists item, err := f.preUploadCheck(ctx, leaf, directoryID, src.Size()) if err != nil { return nil, err } if item != nil { // dest already exists, need to copy to temp name and then move tempSuffix := "-rclone-copy-" + random.String(8) fs.Debugf(remote, "dst already exists, copying to temp name %v", remote+tempSuffix) tempObj, err := f.Copy(ctx, src, remote+tempSuffix) if err != nil { return nil, err } fs.Debugf(remote+tempSuffix, "moving to real name %v", remote) err = f.deleteObject(ctx, item.ID) if err != nil { return nil, err } return f.Move(ctx, tempObj, remote) } // Copy the object opts := rest.Opts{ Method: "POST", Path: "/files/" + srcObj.id + "/copy", Parameters: fieldsValue(), } copyFile := api.CopyFile{ Name: f.opt.Enc.FromStandardName(leaf), Parent: api.Parent{ ID: directoryID, }, } var resp *http.Response var info *api.Item err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, ©File, &info) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } err = dstObj.setMetaData(info) if err != nil { return nil, err } return dstObj, nil } // Purge deletes all the files and the container // // Optional interface: Only implement this if you have a way of // deleting all the files quicker than just running Remove() on the // result of List() func (f *Fs) Purge(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, false) } // move a file or folder func (f *Fs) move(ctx context.Context, endpoint, id, leaf, directoryID string) (info *api.Item, err error) { // Move the object opts := rest.Opts{ Method: "PUT", Path: endpoint + id, Parameters: fieldsValue(), } move := api.UpdateFileMove{ Name: f.opt.Enc.FromStandardName(leaf), Parent: api.Parent{ ID: directoryID, }, } var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, &move, &info) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } return info, nil } // About gets quota information func (f *Fs) About(ctx context.Context) (usage *fs.Usage, err error) { opts := rest.Opts{ Method: "GET", Path: "/users/me", } var user api.User var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, nil, &user) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("failed to read user info: %w", err) } // FIXME max upload size would be useful to use in Update usage = &fs.Usage{ Used: fs.NewUsageValue(user.SpaceUsed), // bytes in use Total: fs.NewUsageValue(user.SpaceAmount), // bytes total Free: fs.NewUsageValue(user.SpaceAmount - user.SpaceUsed), // bytes free } return usage, nil } // Move src to this remote using server-side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't move - not same remote type") return nil, fs.ErrorCantMove } // Create temporary object dstObj, leaf, directoryID, err := f.createObject(ctx, remote, srcObj.modTime, srcObj.size) if err != nil { return nil, err } // Do the move info, err := f.move(ctx, "/files/", srcObj.id, leaf, directoryID) if err != nil { return nil, err } err = dstObj.setMetaData(info) if err != nil { return nil, err } return dstObj, nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } srcID, _, _, dstDirectoryID, dstLeaf, err := f.dirCache.DirMove(ctx, srcFs.dirCache, srcFs.root, srcRemote, f.root, dstRemote) if err != nil { return err } // Do the move _, err = f.move(ctx, "/folders/", srcID, dstLeaf, dstDirectoryID) if err != nil { return err } srcFs.dirCache.FlushDir(srcRemote) return nil } // PublicLink adds a "readable by anyone with link" permission on the given file or folder. func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (string, error) { id, err := f.dirCache.FindDir(ctx, remote, false) var opts rest.Opts if err == nil { fs.Debugf(f, "attempting to share directory '%s'", remote) opts = rest.Opts{ Method: "PUT", Path: "/folders/" + id, Parameters: fieldsValue(), } } else { fs.Debugf(f, "attempting to share single file '%s'", remote) o, err := f.NewObject(ctx, remote) if err != nil { return "", err } if o.(*Object).publicLink != "" { return o.(*Object).publicLink, nil } opts = rest.Opts{ Method: "PUT", Path: "/files/" + o.(*Object).id, Parameters: fieldsValue(), } } shareLink := api.CreateSharedLink{} var info api.Item var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, &shareLink, &info) return shouldRetry(ctx, resp, err) }) return info.SharedLink.URL, err } // deletePermanently permanently deletes a trashed file func (f *Fs) deletePermanently(ctx context.Context, itemType, id string) error { opts := rest.Opts{ Method: "DELETE", NoResponse: true, } if itemType == api.ItemTypeFile { opts.Path = "/files/" + id + "/trash" } else { opts.Path = "/folders/" + id + "/trash" } return f.pacer.Call(func() (bool, error) { resp, err := f.srv.Call(ctx, &opts) return shouldRetry(ctx, resp, err) }) } // CleanUp empties the trash func (f *Fs) CleanUp(ctx context.Context) (err error) { var ( deleteErrors atomic.Uint64 concurrencyControl = make(chan struct{}, fs.GetConfig(ctx).Checkers) wg sync.WaitGroup ) _, err = f.listAll(ctx, "trash", false, false, false, func(item *api.Item) bool { if item.Type == api.ItemTypeFolder || item.Type == api.ItemTypeFile { wg.Add(1) concurrencyControl <- struct{}{} go func() { defer func() { <-concurrencyControl wg.Done() }() err := f.deletePermanently(ctx, item.Type, item.ID) if err != nil { fs.Errorf(f, "failed to delete trash item %q (%q): %v", item.Name, item.ID, err) deleteErrors.Add(1) } }() } else { fs.Debugf(f, "Ignoring %q - unknown type %q", item.Name, item.Type) } return false }) wg.Wait() if deleteErrors.Load() != 0 { return fmt.Errorf("failed to delete %d trash items", deleteErrors.Load()) } return err } // Shutdown shutdown the fs func (f *Fs) Shutdown(ctx context.Context) error { f.tokenRenewer.Shutdown() return nil } // ChangeNotify calls the passed function with a path that has had changes. // If the implementation uses polling, it should adhere to the given interval. // // Automatically restarts itself in case of unexpected behavior of the remote. // // Close the returned channel to stop being notified. func (f *Fs) ChangeNotify(ctx context.Context, notifyFunc func(string, fs.EntryType), pollIntervalChan <-chan time.Duration) { go func() { // get the `stream_position` early so all changes from now on get processed streamPosition, err := f.changeNotifyStreamPosition(ctx) if err != nil { fs.Infof(f, "Failed to get StreamPosition: %s", err) } // box can send duplicate Event IDs. Use this map to track and filter // the ones we've already processed. processedEventIDs := make(map[string]time.Time) var ticker *time.Ticker var tickerC <-chan time.Time for { select { case pollInterval, ok := <-pollIntervalChan: if !ok { if ticker != nil { ticker.Stop() } return } if ticker != nil { ticker.Stop() ticker, tickerC = nil, nil } if pollInterval != 0 { ticker = time.NewTicker(pollInterval) tickerC = ticker.C } case <-tickerC: if streamPosition == "" { streamPosition, err = f.changeNotifyStreamPosition(ctx) if err != nil { fs.Infof(f, "Failed to get StreamPosition: %s", err) continue } } // Garbage collect EventIDs older than 1 minute for eventID, timestamp := range processedEventIDs { if time.Since(timestamp) > time.Minute { delete(processedEventIDs, eventID) } } streamPosition, err = f.changeNotifyRunner(ctx, notifyFunc, streamPosition, processedEventIDs) if err != nil { fs.Infof(f, "Change notify listener failure: %s", err) } } } }() } func (f *Fs) changeNotifyStreamPosition(ctx context.Context) (streamPosition string, err error) { opts := rest.Opts{ Method: "GET", Path: "/events", Parameters: fieldsValue(), } opts.Parameters.Set("stream_position", "now") opts.Parameters.Set("stream_type", "changes") var result api.Events var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, resp, err) }) if err != nil { return "", err } return strconv.FormatInt(result.NextStreamPosition, 10), nil } // Attempts to construct the full path for an object, given the ID of its // parent directory and the name of the object. // // Can return "" if the parentID is not currently in the directory cache. func (f *Fs) getFullPath(parentID string, childName string) (fullPath string) { fullPath = "" name := f.opt.Enc.ToStandardName(childName) if parentID != "" { if parentDir, ok := f.dirCache.GetInv(parentID); ok { if len(parentDir) > 0 { fullPath = parentDir + "/" + name } else { fullPath = name } } } else { // No parent, this object is at the root fullPath = name } return fullPath } func (f *Fs) changeNotifyRunner(ctx context.Context, notifyFunc func(string, fs.EntryType), streamPosition string, processedEventIDs map[string]time.Time) (nextStreamPosition string, err error) { nextStreamPosition = streamPosition for { // box only allows a max of 500 events limit := min(f.opt.ListChunk, 500) opts := rest.Opts{ Method: "GET", Path: "/events", Parameters: fieldsValue(), } opts.Parameters.Set("stream_position", nextStreamPosition) opts.Parameters.Set("stream_type", "changes") opts.Parameters.Set("limit", strconv.Itoa(limit)) var result api.Events var resp *http.Response fs.Debugf(f, "Checking for changes on remote (next_stream_position: %q)", nextStreamPosition) err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, resp, err) }) if err != nil { return "", err } if result.ChunkSize != int64(len(result.Entries)) { return "", fmt.Errorf("invalid response to event request, chunk_size (%v) not equal to number of entries (%v)", result.ChunkSize, len(result.Entries)) } nextStreamPosition = strconv.FormatInt(result.NextStreamPosition, 10) if result.ChunkSize == 0 { return nextStreamPosition, nil } type pathToClear struct { path string entryType fs.EntryType } var pathsToClear []pathToClear newEventIDs := 0 for _, entry := range result.Entries { eventDetails := fmt.Sprintf("[%q(%d)|%s|%s|%s|%s]", entry.Source.Name, entry.Source.SequenceID, entry.Source.Type, entry.EventType, entry.Source.ID, entry.EventID) if entry.EventID == "" { fs.Debugf(f, "%s ignored due to missing EventID", eventDetails) continue } if _, ok := processedEventIDs[entry.EventID]; ok { fs.Debugf(f, "%s ignored due to duplicate EventID", eventDetails) continue } processedEventIDs[entry.EventID] = time.Now() newEventIDs++ if entry.Source.ID == "" { // missing File or Folder ID fs.Debugf(f, "%s ignored due to missing SourceID", eventDetails) continue } if entry.Source.Type != api.ItemTypeFile && entry.Source.Type != api.ItemTypeFolder { // event is not for a file or folder fs.Debugf(f, "%s ignored due to unsupported SourceType", eventDetails) continue } // Only interested in event types that result in a file tree change if _, found := api.FileTreeChangeEventTypes[entry.EventType]; !found { fs.Debugf(f, "%s ignored due to unsupported EventType", eventDetails) continue } f.itemMetaCacheMu.Lock() itemMeta, cachedItemMetaFound := f.itemMetaCache[entry.Source.ID] if cachedItemMetaFound { if itemMeta.SequenceID >= entry.Source.SequenceID { // Item in the cache has the same or newer SequenceID than // this event. Ignore this event, it must be old. f.itemMetaCacheMu.Unlock() fs.Debugf(f, "%s ignored due to old SequenceID (%q)", eventDetails, itemMeta.SequenceID) continue } // This event is newer. Delete its entry from the cache, // we'll notify about its change below, then it's up to a // future list operation to repopulate the cache. delete(f.itemMetaCache, entry.Source.ID) } f.itemMetaCacheMu.Unlock() entryType := fs.EntryDirectory if entry.Source.Type == api.ItemTypeFile { entryType = fs.EntryObject } // The box event only includes the new path for the object (e.g. // the path after the object was moved). If there was an old path // saved in our cache, it must be cleared. if cachedItemMetaFound { path := f.getFullPath(itemMeta.ParentID, itemMeta.Name) if path != "" { fs.Debugf(f, "%s added old path (%q) for notify", eventDetails, path) pathsToClear = append(pathsToClear, pathToClear{path: path, entryType: entryType}) } else { fs.Debugf(f, "%s old parent not cached", eventDetails) } // If this is a directory, also delete it from the dir cache. // This will effectively invalidate the item metadata cache // entries for all descendents of this directory, since we // will no longer be able to construct a full path for them. // This is exactly what we want, since we don't want to notify // on the paths of these descendents if one of their ancestors // has been renamed/deleted. if entry.Source.Type == api.ItemTypeFolder { f.dirCache.FlushDir(path) } } // If the item is "active", then it is not trashed or deleted, so // it potentially has a valid parent. // // Construct the new path of the object, based on the Parent ID // and its name. If we get an empty result, it means we don't // currently know about this object so notification is unnecessary. if entry.Source.ItemStatus == api.ItemStatusActive { path := f.getFullPath(entry.Source.Parent.ID, entry.Source.Name) if path != "" { fs.Debugf(f, "%s added new path (%q) for notify", eventDetails, path) pathsToClear = append(pathsToClear, pathToClear{path: path, entryType: entryType}) } else { fs.Debugf(f, "%s new parent not found", eventDetails) } } } // box can sometimes repeatedly return the same Event IDs within a // short period of time. If it stops giving us new ones, treat it // the same as if it returned us none at all. if newEventIDs == 0 { return nextStreamPosition, nil } notifiedPaths := make(map[string]bool) for _, p := range pathsToClear { if _, ok := notifiedPaths[p.path]; ok { continue } notifiedPaths[p.path] = true notifyFunc(p.path, p.entryType) } fs.Debugf(f, "Received %v events, resulting in %v paths and %v notifications", len(result.Entries), len(pathsToClear), len(notifiedPaths)) } } // DirCacheFlush resets the directory cache - used in testing as an // optional interface func (f *Fs) DirCacheFlush() { f.dirCache.ResetRoot() } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hash.SHA1) } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Hash returns the SHA-1 of an object returning a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if t != hash.SHA1 { return "", hash.ErrUnsupported } return o.sha1, nil } // Size returns the size of an object in bytes func (o *Object) Size() int64 { err := o.readMetaData(context.TODO()) if err != nil { fs.Logf(o, "Failed to read metadata: %v", err) return 0 } return o.size } // setMetaData sets the metadata from info func (o *Object) setMetaData(info *api.Item) (err error) { if info.Type == api.ItemTypeFolder { return fs.ErrorIsDir } if info.Type != api.ItemTypeFile { return fmt.Errorf("%q is %q: %w", o.remote, info.Type, fs.ErrorNotAFile) } o.hasMetaData = true o.size = int64(info.Size) o.sha1 = info.SHA1 o.modTime = info.ModTime() o.id = info.ID o.publicLink = info.SharedLink.URL return nil } // readMetaData gets the metadata if it hasn't already been fetched // // it also sets the info func (o *Object) readMetaData(ctx context.Context) (err error) { if o.hasMetaData { return nil } info, err := o.fs.readMetaDataForPath(ctx, o.remote) if err != nil { if apiErr, ok := err.(*api.Error); ok { if apiErr.Code == "not_found" || apiErr.Code == "trashed" { return fs.ErrorObjectNotFound } } return err } return o.setMetaData(info) } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers func (o *Object) ModTime(ctx context.Context) time.Time { err := o.readMetaData(ctx) if err != nil { fs.Logf(o, "Failed to read metadata: %v", err) return time.Now() } return o.modTime } // setModTime sets the modification time of the local fs object func (o *Object) setModTime(ctx context.Context, modTime time.Time) (*api.Item, error) { opts := rest.Opts{ Method: "PUT", Path: "/files/" + o.id, Parameters: fieldsValue(), } update := api.UpdateFileModTime{ ContentModifiedAt: api.Time(modTime), } var info *api.Item err := o.fs.pacer.Call(func() (bool, error) { resp, err := o.fs.srv.CallJSON(ctx, &opts, &update, &info) return shouldRetry(ctx, resp, err) }) return info, err } // SetModTime sets the modification time of the local fs object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { info, err := o.setModTime(ctx, modTime) if err != nil { return err } return o.setMetaData(info) } // Storable returns a boolean showing whether this object storable func (o *Object) Storable() bool { return true } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { if o.id == "" { return nil, errors.New("can't download - no id") } fs.FixRangeOption(options, o.size) var resp *http.Response opts := rest.Opts{ Method: "GET", Path: "/files/" + o.id + "/content", Options: options, } err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.Call(ctx, &opts) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } return resp.Body, err } // upload does a single non-multipart upload // // This is recommended for less than 50 MiB of content func (o *Object) upload(ctx context.Context, in io.Reader, leaf, directoryID string, modTime time.Time, options ...fs.OpenOption) (err error) { upload := api.UploadFile{ Name: o.fs.opt.Enc.FromStandardName(leaf), ContentModifiedAt: api.Time(modTime), ContentCreatedAt: api.Time(modTime), Parent: api.Parent{ ID: directoryID, }, } var resp *http.Response var result api.FolderItems opts := rest.Opts{ Method: "POST", Body: in, MultipartMetadataName: "attributes", MultipartContentName: "contents", MultipartFileName: upload.Name, RootURL: uploadURL, Options: options, } // If object has an ID then it is existing so create a new version if o.id != "" { opts.Path = "/files/" + o.id + "/content" } else { opts.Path = "/files/content" } err = o.fs.pacer.CallNoRetry(func() (bool, error) { resp, err = o.fs.srv.CallJSON(ctx, &opts, &upload, &result) return shouldRetry(ctx, resp, err) }) if err != nil { return err } if result.TotalCount != 1 || len(result.Entries) != 1 { return fmt.Errorf("failed to upload %v - not sure why", o) } return o.setMetaData(&result.Entries[0]) } // Update the object with the contents of the io.Reader, modTime and size // // If existing is set then it updates the object rather than creating a new one. // // The new object may have been created if an error is returned. func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { if o.fs.tokenRenewer != nil { o.fs.tokenRenewer.Start() defer o.fs.tokenRenewer.Stop() } size := src.Size() modTime := src.ModTime(ctx) remote := o.Remote() // Create the directory for the object if it doesn't exist leaf, directoryID, err := o.fs.dirCache.FindPath(ctx, remote, true) if err != nil { return err } // Upload with simple or multipart if size <= int64(o.fs.opt.UploadCutoff) { err = o.upload(ctx, in, leaf, directoryID, modTime, options...) } else { err = o.uploadMultipart(ctx, in, leaf, directoryID, size, modTime, options...) } return err } // Remove an object func (o *Object) Remove(ctx context.Context) error { return o.fs.deleteObject(ctx, o.id) } // ID returns the ID of the Object if known, or "" if not func (o *Object) ID() string { return o.id } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.DirCacheFlusher = (*Fs)(nil) _ fs.PublicLinker = (*Fs)(nil) _ fs.CleanUpper = (*Fs)(nil) _ fs.Shutdowner = (*Fs)(nil) _ fs.Object = (*Object)(nil) _ fs.IDer = (*Object)(nil) ) rclone-v1.71.0/backend/box/box_test.go000066400000000000000000000005401505210326400176020ustar00rootroot00000000000000// Test Box filesystem interface package box_test import ( "testing" "github.com/rclone/rclone/backend/box" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestBox:", NilObject: (*box.Object)(nil), }) } rclone-v1.71.0/backend/box/upload.go000066400000000000000000000175051505210326400172500ustar00rootroot00000000000000// multipart upload for box package box import ( "bytes" "context" "crypto/sha1" "encoding/base64" "encoding/json" "errors" "fmt" "io" "net/http" "strconv" "sync" "time" "github.com/rclone/rclone/backend/box/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/lib/atexit" "github.com/rclone/rclone/lib/rest" ) // createUploadSession creates an upload session for the object func (o *Object) createUploadSession(ctx context.Context, leaf, directoryID string, size int64) (response *api.UploadSessionResponse, err error) { opts := rest.Opts{ Method: "POST", Path: "/files/upload_sessions", RootURL: uploadURL, } request := api.UploadSessionRequest{ FileSize: size, } // If object has an ID then it is existing so create a new version if o.id != "" { opts.Path = "/files/" + o.id + "/upload_sessions" } else { opts.Path = "/files/upload_sessions" request.FolderID = directoryID request.FileName = o.fs.opt.Enc.FromStandardName(leaf) } var resp *http.Response err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.CallJSON(ctx, &opts, &request, &response) return shouldRetry(ctx, resp, err) }) return } // sha1Digest produces a digest using sha1 as per RFC3230 func sha1Digest(digest []byte) string { return "sha=" + base64.StdEncoding.EncodeToString(digest) } // uploadPart uploads a part in an upload session func (o *Object) uploadPart(ctx context.Context, SessionID string, offset, totalSize int64, chunk []byte, wrap accounting.WrapFn, options ...fs.OpenOption) (response *api.UploadPartResponse, err error) { chunkSize := int64(len(chunk)) sha1sum := sha1.Sum(chunk) opts := rest.Opts{ Method: "PUT", Path: "/files/upload_sessions/" + SessionID, RootURL: uploadURL, ContentType: "application/octet-stream", ContentLength: &chunkSize, ContentRange: fmt.Sprintf("bytes %d-%d/%d", offset, offset+chunkSize-1, totalSize), Options: options, ExtraHeaders: map[string]string{ "Digest": sha1Digest(sha1sum[:]), }, } var resp *http.Response err = o.fs.pacer.Call(func() (bool, error) { opts.Body = wrap(bytes.NewReader(chunk)) resp, err = o.fs.srv.CallJSON(ctx, &opts, nil, &response) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } return response, nil } // commitUpload finishes an upload session func (o *Object) commitUpload(ctx context.Context, SessionID string, parts []api.Part, modTime time.Time, sha1sum []byte) (result *api.FolderItems, err error) { opts := rest.Opts{ Method: "POST", Path: "/files/upload_sessions/" + SessionID + "/commit", RootURL: uploadURL, ExtraHeaders: map[string]string{ "Digest": sha1Digest(sha1sum), }, } request := api.CommitUpload{ Parts: parts, } request.Attributes.ContentModifiedAt = api.Time(modTime) request.Attributes.ContentCreatedAt = api.Time(modTime) var body []byte var resp *http.Response // For discussion of this value see: // https://github.com/rclone/rclone/issues/2054 maxTries := o.fs.opt.CommitRetries const defaultDelay = 10 var tries int outer: for tries = range maxTries { err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.CallJSON(ctx, &opts, &request, nil) if err != nil { return shouldRetry(ctx, resp, err) } body, err = rest.ReadBody(resp) return shouldRetry(ctx, resp, err) }) delay := defaultDelay var why string if err != nil { // Sometimes we get 400 Error with // parts_mismatch immediately after uploading // the last part. Ignore this error and wait. if boxErr, ok := err.(*api.Error); ok && boxErr.Code == "parts_mismatch" { why = err.Error() } else { return nil, err } } else { switch resp.StatusCode { case http.StatusOK, http.StatusCreated: break outer case http.StatusAccepted: why = "not ready yet" delayString := resp.Header.Get("Retry-After") if delayString != "" { delay, err = strconv.Atoi(delayString) if err != nil { fs.Debugf(o, "Couldn't decode Retry-After header %q: %v", delayString, err) delay = defaultDelay } } default: return nil, fmt.Errorf("unknown HTTP status return %q (%d)", resp.Status, resp.StatusCode) } } fs.Debugf(o, "commit multipart upload failed %d/%d - trying again in %d seconds (%s)", tries+1, maxTries, delay, why) time.Sleep(time.Duration(delay) * time.Second) } if tries >= maxTries { return nil, errors.New("too many tries to commit multipart upload - increase --low-level-retries") } err = json.Unmarshal(body, &result) if err != nil { return nil, fmt.Errorf("couldn't decode commit response: %q: %w", body, err) } return result, nil } // abortUpload cancels an upload session func (o *Object) abortUpload(ctx context.Context, SessionID string) (err error) { opts := rest.Opts{ Method: "DELETE", Path: "/files/upload_sessions/" + SessionID, RootURL: uploadURL, NoResponse: true, } var resp *http.Response err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.Call(ctx, &opts) return shouldRetry(ctx, resp, err) }) return err } // uploadMultipart uploads a file using multipart upload func (o *Object) uploadMultipart(ctx context.Context, in io.Reader, leaf, directoryID string, size int64, modTime time.Time, options ...fs.OpenOption) (err error) { // Create upload session session, err := o.createUploadSession(ctx, leaf, directoryID, size) if err != nil { return fmt.Errorf("multipart upload create session failed: %w", err) } chunkSize := session.PartSize fs.Debugf(o, "Multipart upload session started for %d parts of size %v", session.TotalParts, fs.SizeSuffix(chunkSize)) // Cancel the session if something went wrong defer atexit.OnError(&err, func() { fs.Debugf(o, "Cancelling multipart upload: %v", err) cancelErr := o.abortUpload(ctx, session.ID) if cancelErr != nil { fs.Logf(o, "Failed to cancel multipart upload: %v", cancelErr) } })() // unwrap the accounting from the input, we use wrap to put it // back on after the buffering in, wrap := accounting.UnWrap(in) // Upload the chunks remaining := size position := int64(0) parts := make([]api.Part, session.TotalParts) hash := sha1.New() errs := make(chan error, 1) var wg sync.WaitGroup outer: for part := range session.TotalParts { // Check any errors select { case err = <-errs: break outer default: } reqSize := min(remaining, chunkSize) // Make a block of memory buf := make([]byte, reqSize) // Read the chunk _, err = io.ReadFull(in, buf) if err != nil { err = fmt.Errorf("multipart upload failed to read source: %w", err) break outer } // Make the global hash (must be done sequentially) _, _ = hash.Write(buf) // Transfer the chunk wg.Add(1) o.fs.uploadToken.Get() go func(part int, position int64) { defer wg.Done() defer o.fs.uploadToken.Put() fs.Debugf(o, "Uploading part %d/%d offset %v/%v part size %v", part+1, session.TotalParts, fs.SizeSuffix(position), fs.SizeSuffix(size), fs.SizeSuffix(chunkSize)) partResponse, err := o.uploadPart(ctx, session.ID, position, size, buf, wrap, options...) if err != nil { err = fmt.Errorf("multipart upload failed to upload part: %w", err) select { case errs <- err: default: } return } parts[part] = partResponse.Part }(part, position) // ready for next block remaining -= chunkSize position += chunkSize } wg.Wait() if err == nil { select { case err = <-errs: default: } } if err != nil { return err } // Finalise the upload session result, err := o.commitUpload(ctx, session.ID, parts, modTime, hash.Sum(nil)) if err != nil { return fmt.Errorf("multipart upload failed to finalize: %w", err) } if result.TotalCount != 1 || len(result.Entries) != 1 { return fmt.Errorf("multipart upload failed %v - not sure why", o) } return o.setMetaData(&result.Entries[0]) } rclone-v1.71.0/backend/cache/000077500000000000000000000000001505210326400157005ustar00rootroot00000000000000rclone-v1.71.0/backend/cache/cache.go000066400000000000000000001644771505210326400173150ustar00rootroot00000000000000//go:build !plan9 && !js // Package cache implements a virtual provider to cache existing remotes. package cache import ( "context" "errors" "fmt" "io" "math" "os" "os/signal" "path" "path/filepath" "sort" "strconv" "strings" "sync" "syscall" "time" "github.com/rclone/rclone/backend/crypt" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fspath" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/fs/rc" "github.com/rclone/rclone/fs/walk" "github.com/rclone/rclone/lib/atexit" "golang.org/x/time/rate" ) const ( // DefCacheChunkSize is the default value for chunk size DefCacheChunkSize = fs.SizeSuffix(5 * 1024 * 1024) // DefCacheTotalChunkSize is the default value for the maximum size of stored chunks DefCacheTotalChunkSize = fs.SizeSuffix(10 * 1024 * 1024 * 1024) // DefCacheChunkCleanInterval is the interval at which chunks are cleaned DefCacheChunkCleanInterval = fs.Duration(time.Minute) // DefCacheInfoAge is the default value for object info age DefCacheInfoAge = fs.Duration(6 * time.Hour) // DefCacheReadRetries is the default value for read retries DefCacheReadRetries = 10 // DefCacheTotalWorkers is how many workers run in parallel to download chunks DefCacheTotalWorkers = 4 // DefCacheChunkNoMemory will enable or disable in-memory storage for chunks DefCacheChunkNoMemory = false // DefCacheRps limits the number of requests per second to the source FS DefCacheRps = -1 // DefCacheWrites will cache file data on writes through the cache DefCacheWrites = false // DefCacheTmpWaitTime says how long should files be stored in local cache before being uploaded DefCacheTmpWaitTime = fs.Duration(15 * time.Second) // DefCacheDbWaitTime defines how long the cache backend should wait for the DB to be available DefCacheDbWaitTime = fs.Duration(1 * time.Second) ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "cache", Description: "Cache a remote", NewFs: NewFs, CommandHelp: commandHelp, Options: []fs.Option{{ Name: "remote", Help: "Remote to cache.\n\nNormally should contain a ':' and a path, e.g. \"myremote:path/to/dir\",\n\"myremote:bucket\" or maybe \"myremote:\" (not recommended).", Required: true, }, { Name: "plex_url", Help: "The URL of the Plex server.", }, { Name: "plex_username", Help: "The username of the Plex user.", Sensitive: true, }, { Name: "plex_password", Help: "The password of the Plex user.", IsPassword: true, }, { Name: "plex_token", Help: "The plex token for authentication - auto set normally.", Hide: fs.OptionHideBoth, Advanced: true, Sensitive: true, }, { Name: "plex_insecure", Help: "Skip all certificate verification when connecting to the Plex server.", Advanced: true, }, { Name: "chunk_size", Help: `The size of a chunk (partial file data). Use lower numbers for slower connections. If the chunk size is changed, any downloaded chunks will be invalid and cache-chunk-path will need to be cleared or unexpected EOF errors will occur.`, Default: DefCacheChunkSize, Examples: []fs.OptionExample{{ Value: "1M", Help: "1 MiB", }, { Value: "5M", Help: "5 MiB", }, { Value: "10M", Help: "10 MiB", }}, }, { Name: "info_age", Help: `How long to cache file structure information (directory listings, file size, times, etc.). If all write operations are done through the cache then you can safely make this value very large as the cache store will also be updated in real time.`, Default: DefCacheInfoAge, Examples: []fs.OptionExample{{ Value: "1h", Help: "1 hour", }, { Value: "24h", Help: "24 hours", }, { Value: "48h", Help: "48 hours", }}, }, { Name: "chunk_total_size", Help: `The total size that the chunks can take up on the local disk. If the cache exceeds this value then it will start to delete the oldest chunks until it goes under this value.`, Default: DefCacheTotalChunkSize, Examples: []fs.OptionExample{{ Value: "500M", Help: "500 MiB", }, { Value: "1G", Help: "1 GiB", }, { Value: "10G", Help: "10 GiB", }}, }, { Name: "db_path", Default: filepath.Join(config.GetCacheDir(), "cache-backend"), Help: "Directory to store file structure metadata DB.\n\nThe remote name is used as the DB file name.", Advanced: true, }, { Name: "chunk_path", Default: filepath.Join(config.GetCacheDir(), "cache-backend"), Help: `Directory to cache chunk files. Path to where partial file data (chunks) are stored locally. The remote name is appended to the final path. This config follows the "--cache-db-path". If you specify a custom location for "--cache-db-path" and don't specify one for "--cache-chunk-path" then "--cache-chunk-path" will use the same path as "--cache-db-path".`, Advanced: true, }, { Name: "db_purge", Default: false, Help: "Clear all the cached data for this remote on start.", Hide: fs.OptionHideConfigurator, Advanced: true, }, { Name: "chunk_clean_interval", Default: DefCacheChunkCleanInterval, Help: `How often should the cache perform cleanups of the chunk storage. The default value should be ok for most people. If you find that the cache goes over "cache-chunk-total-size" too often then try to lower this value to force it to perform cleanups more often.`, Advanced: true, }, { Name: "read_retries", Default: DefCacheReadRetries, Help: `How many times to retry a read from a cache storage. Since reading from a cache stream is independent from downloading file data, readers can get to a point where there's no more data in the cache. Most of the times this can indicate a connectivity issue if cache isn't able to provide file data anymore. For really slow connections, increase this to a point where the stream is able to provide data but your experience will be very stuttering.`, Advanced: true, }, { Name: "workers", Default: DefCacheTotalWorkers, Help: `How many workers should run in parallel to download chunks. Higher values will mean more parallel processing (better CPU needed) and more concurrent requests on the cloud provider. This impacts several aspects like the cloud provider API limits, more stress on the hardware that rclone runs on but it also means that streams will be more fluid and data will be available much more faster to readers. **Note**: If the optional Plex integration is enabled then this setting will adapt to the type of reading performed and the value specified here will be used as a maximum number of workers to use.`, Advanced: true, }, { Name: "chunk_no_memory", Default: DefCacheChunkNoMemory, Help: `Disable the in-memory cache for storing chunks during streaming. By default, cache will keep file data during streaming in RAM as well to provide it to readers as fast as possible. This transient data is evicted as soon as it is read and the number of chunks stored doesn't exceed the number of workers. However, depending on other settings like "cache-chunk-size" and "cache-workers" this footprint can increase if there are parallel streams too (multiple files being read at the same time). If the hardware permits it, use this feature to provide an overall better performance during streaming but it can also be disabled if RAM is not available on the local machine.`, Advanced: true, }, { Name: "rps", Default: int(DefCacheRps), Help: `Limits the number of requests per second to the source FS (-1 to disable). This setting places a hard limit on the number of requests per second that cache will be doing to the cloud provider remote and try to respect that value by setting waits between reads. If you find that you're getting banned or limited on the cloud provider through cache and know that a smaller number of requests per second will allow you to work with it then you can use this setting for that. A good balance of all the other settings should make this setting useless but it is available to set for more special cases. **NOTE**: This will limit the number of requests during streams but other API calls to the cloud provider like directory listings will still pass.`, Advanced: true, }, { Name: "writes", Default: DefCacheWrites, Help: `Cache file data on writes through the FS. If you need to read files immediately after you upload them through cache you can enable this flag to have their data stored in the cache store at the same time during upload.`, Advanced: true, }, { Name: "tmp_upload_path", Default: "", Help: `Directory to keep temporary files until they are uploaded. This is the path where cache will use as a temporary storage for new files that need to be uploaded to the cloud provider. Specifying a value will enable this feature. Without it, it is completely disabled and files will be uploaded directly to the cloud provider`, Advanced: true, }, { Name: "tmp_wait_time", Default: DefCacheTmpWaitTime, Help: `How long should files be stored in local cache before being uploaded. This is the duration that a file must wait in the temporary location _cache-tmp-upload-path_ before it is selected for upload. Note that only one file is uploaded at a time and it can take longer to start the upload if a queue formed for this purpose.`, Advanced: true, }, { Name: "db_wait_time", Default: DefCacheDbWaitTime, Help: `How long to wait for the DB to be available - 0 is unlimited. Only one process can have the DB open at any one time, so rclone waits for this duration for the DB to become available before it gives an error. If you set it to 0 then it will wait forever.`, Advanced: true, }}, }) } // Options defines the configuration for this backend type Options struct { Remote string `config:"remote"` PlexURL string `config:"plex_url"` PlexUsername string `config:"plex_username"` PlexPassword string `config:"plex_password"` PlexToken string `config:"plex_token"` PlexInsecure bool `config:"plex_insecure"` ChunkSize fs.SizeSuffix `config:"chunk_size"` InfoAge fs.Duration `config:"info_age"` ChunkTotalSize fs.SizeSuffix `config:"chunk_total_size"` DbPath string `config:"db_path"` ChunkPath string `config:"chunk_path"` DbPurge bool `config:"db_purge"` ChunkCleanInterval fs.Duration `config:"chunk_clean_interval"` ReadRetries int `config:"read_retries"` TotalWorkers int `config:"workers"` ChunkNoMemory bool `config:"chunk_no_memory"` Rps int `config:"rps"` StoreWrites bool `config:"writes"` TempWritePath string `config:"tmp_upload_path"` TempWaitTime fs.Duration `config:"tmp_wait_time"` DbWaitTime fs.Duration `config:"db_wait_time"` } // Fs represents a wrapped fs.Fs type Fs struct { fs.Fs wrapper fs.Fs name string root string opt Options // parsed options features *fs.Features // optional features cache *Persistent tempFs fs.Fs lastChunkCleanup time.Time cleanupMu sync.Mutex rateLimiter *rate.Limiter plexConnector *plexConnector backgroundRunner *backgroundWriter cleanupChan chan bool parentsForgetFn []func(string, fs.EntryType) notifiedRemotes map[string]bool notifiedMu sync.Mutex parentsForgetMu sync.Mutex } // parseRootPath returns a cleaned root path and a nil error or "" and an error when the path is invalid func parseRootPath(path string) (string, error) { return strings.Trim(path, "/"), nil } var warnDeprecated sync.Once // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, rootPath string, m configmap.Mapper) (fs.Fs, error) { warnDeprecated.Do(func() { fs.Logf(nil, "WARNING: Cache backend is deprecated and may be removed in future. Please use VFS instead.") }) // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } if opt.ChunkTotalSize < opt.ChunkSize*fs.SizeSuffix(opt.TotalWorkers) { return nil, fmt.Errorf("don't set cache-chunk-total-size(%v) less than cache-chunk-size(%v) * cache-workers(%v)", opt.ChunkTotalSize, opt.ChunkSize, opt.TotalWorkers) } if strings.HasPrefix(opt.Remote, name+":") { return nil, errors.New("can't point cache remote at itself - check the value of the remote setting") } rpath, err := parseRootPath(rootPath) if err != nil { return nil, fmt.Errorf("failed to clean root path %q: %w", rootPath, err) } remotePath := fspath.JoinRootPath(opt.Remote, rootPath) wrappedFs, wrapErr := cache.Get(ctx, remotePath) if wrapErr != nil && wrapErr != fs.ErrorIsFile { return nil, fmt.Errorf("failed to make remote %q to wrap: %w", remotePath, wrapErr) } var fsErr error fs.Debugf(name, "wrapped %v:%v at root %v", wrappedFs.Name(), wrappedFs.Root(), rpath) if wrapErr == fs.ErrorIsFile { fsErr = fs.ErrorIsFile rpath = cleanPath(path.Dir(rpath)) } // configure cache backend if opt.DbPurge { fs.Debugf(name, "Purging the DB") } f := &Fs{ Fs: wrappedFs, name: name, root: rpath, opt: *opt, lastChunkCleanup: time.Now().Truncate(time.Hour * 24 * 30), cleanupChan: make(chan bool, 1), notifiedRemotes: make(map[string]bool), } cache.PinUntilFinalized(f.Fs, f) rps := rate.Inf if opt.Rps > 0 { rps = rate.Limit(float64(opt.Rps)) } f.rateLimiter = rate.NewLimiter(rps, opt.TotalWorkers) f.plexConnector = &plexConnector{} if opt.PlexURL != "" { if opt.PlexToken != "" { f.plexConnector, err = newPlexConnectorWithToken(f, opt.PlexURL, opt.PlexToken, opt.PlexInsecure) if err != nil { return nil, fmt.Errorf("failed to connect to the Plex API %v: %w", opt.PlexURL, err) } } else if opt.PlexPassword != "" && opt.PlexUsername != "" { decPass, err := obscure.Reveal(opt.PlexPassword) if err != nil { decPass = opt.PlexPassword } f.plexConnector, err = newPlexConnector(f, opt.PlexURL, opt.PlexUsername, decPass, opt.PlexInsecure, func(token string) { m.Set("plex_token", token) }) if err != nil { return nil, fmt.Errorf("failed to connect to the Plex API %v: %w", opt.PlexURL, err) } } } dbPath := f.opt.DbPath chunkPath := f.opt.ChunkPath // if the dbPath is non default but the chunk path is default, we overwrite the last to follow the same one as dbPath if dbPath != filepath.Join(config.GetCacheDir(), "cache-backend") && chunkPath == filepath.Join(config.GetCacheDir(), "cache-backend") { chunkPath = dbPath } if filepath.Ext(dbPath) != "" { dbPath = filepath.Dir(dbPath) } if filepath.Ext(chunkPath) != "" { chunkPath = filepath.Dir(chunkPath) } err = os.MkdirAll(dbPath, os.ModePerm) if err != nil { return nil, fmt.Errorf("failed to create cache directory %v: %w", dbPath, err) } err = os.MkdirAll(chunkPath, os.ModePerm) if err != nil { return nil, fmt.Errorf("failed to create cache directory %v: %w", chunkPath, err) } dbPath = filepath.Join(dbPath, name+".db") chunkPath = filepath.Join(chunkPath, name) fs.Infof(name, "Cache DB path: %v", dbPath) fs.Infof(name, "Cache chunk path: %v", chunkPath) f.cache, err = GetPersistent(dbPath, chunkPath, &Features{ PurgeDb: opt.DbPurge, DbWaitTime: time.Duration(opt.DbWaitTime), }) if err != nil { return nil, fmt.Errorf("failed to start cache db: %w", err) } // Trap SIGINT and SIGTERM to close the DB handle gracefully c := make(chan os.Signal, 1) signal.Notify(c, syscall.SIGHUP) atexit.Register(func() { if opt.PlexURL != "" { f.plexConnector.closeWebsocket() } f.StopBackgroundRunners() }) go func() { for { s := <-c if s == syscall.SIGHUP { fs.Infof(f, "Clearing cache from signal") f.DirCacheFlush() } } }() fs.Infof(name, "Chunk Memory: %v", !f.opt.ChunkNoMemory) fs.Infof(name, "Chunk Size: %v", f.opt.ChunkSize) fs.Infof(name, "Chunk Total Size: %v", f.opt.ChunkTotalSize) fs.Infof(name, "Chunk Clean Interval: %v", f.opt.ChunkCleanInterval) fs.Infof(name, "Workers: %v", f.opt.TotalWorkers) fs.Infof(name, "File Age: %v", f.opt.InfoAge) if f.opt.StoreWrites { fs.Infof(name, "Cache Writes: enabled") } if f.opt.TempWritePath != "" { err = os.MkdirAll(f.opt.TempWritePath, os.ModePerm) if err != nil { return nil, fmt.Errorf("failed to create cache directory %v: %w", f.opt.TempWritePath, err) } f.opt.TempWritePath = filepath.ToSlash(f.opt.TempWritePath) f.tempFs, err = cache.Get(ctx, f.opt.TempWritePath) if err != nil { return nil, fmt.Errorf("failed to create temp fs: %w", err) } fs.Infof(name, "Upload Temp Rest Time: %v", f.opt.TempWaitTime) fs.Infof(name, "Upload Temp FS: %v", f.opt.TempWritePath) f.backgroundRunner, _ = initBackgroundUploader(f) go f.backgroundRunner.run() } go func() { for { time.Sleep(time.Duration(f.opt.ChunkCleanInterval)) select { case <-f.cleanupChan: fs.Infof(f, "stopping cleanup") return default: fs.Debugf(f, "starting cleanup") f.CleanUpCache(false) } } }() if doChangeNotify := wrappedFs.Features().ChangeNotify; doChangeNotify != nil { pollInterval := make(chan time.Duration, 1) pollInterval <- time.Duration(f.opt.ChunkCleanInterval) doChangeNotify(ctx, f.receiveChangeNotify, pollInterval) } f.features = (&fs.Features{ CanHaveEmptyDirectories: true, DuplicateFiles: false, // storage doesn't permit this }).Fill(ctx, f).Mask(ctx, wrappedFs).WrapsFs(f, wrappedFs) // override only those features that use a temp fs and it doesn't support them //f.features.ChangeNotify = f.ChangeNotify if f.opt.TempWritePath != "" { if f.tempFs.Features().Move == nil { f.features.Move = nil } if f.tempFs.Features().Move == nil { f.features.Move = nil } if f.tempFs.Features().DirMove == nil { f.features.DirMove = nil } if f.tempFs.Features().MergeDirs == nil { f.features.MergeDirs = nil } } // even if the wrapped fs doesn't support it, we still want it f.features.DirCacheFlush = f.DirCacheFlush rc.Add(rc.Call{ Path: "cache/expire", Fn: f.httpExpireRemote, Title: "Purge a remote from cache", Help: ` Purge a remote from the cache backend. Supports either a directory or a file. Params: - remote = path to remote (required) - withData = true/false to delete cached data (chunks) as well (optional) Eg rclone rc cache/expire remote=path/to/sub/folder/ rclone rc cache/expire remote=/ withData=true `, }) rc.Add(rc.Call{ Path: "cache/stats", Fn: f.httpStats, Title: "Get cache stats", Help: ` Show statistics for the cache remote. `, }) rc.Add(rc.Call{ Path: "cache/fetch", Fn: f.rcFetch, Title: "Fetch file chunks", Help: ` Ensure the specified file chunks are cached on disk. The chunks= parameter specifies the file chunks to check. It takes a comma separated list of array slice indices. The slice indices are similar to Python slices: start[:end] start is the 0 based chunk number from the beginning of the file to fetch inclusive. end is 0 based chunk number from the beginning of the file to fetch exclusive. Both values can be negative, in which case they count from the back of the file. The value "-5:" represents the last 5 chunks of a file. Some valid examples are: ":5,-5:" -> the first and last five chunks "0,-2" -> the first and the second last chunk "0:10" -> the first ten chunks Any parameter with a key that starts with "file" can be used to specify files to fetch, e.g. rclone rc cache/fetch chunks=0 file=hello file2=home/goodbye File names will automatically be encrypted when the a crypt remote is used on top of the cache. `, }) return f, fsErr } func (f *Fs) httpStats(ctx context.Context, in rc.Params) (out rc.Params, err error) { out = make(rc.Params) m, err := f.Stats() if err != nil { return out, fmt.Errorf("error while getting cache stats") } out["status"] = "ok" out["stats"] = m return out, nil } func (f *Fs) unwrapRemote(remote string) string { remote = cleanPath(remote) if remote != "" { // if it's wrapped by crypt we need to check what format we got if cryptFs, yes := f.isWrappedByCrypt(); yes { _, err := cryptFs.DecryptFileName(remote) // if it failed to decrypt then it is a decrypted format and we need to encrypt it if err != nil { return cryptFs.EncryptFileName(remote) } // else it's an encrypted format and we can use it as it is } } return remote } func (f *Fs) httpExpireRemote(ctx context.Context, in rc.Params) (out rc.Params, err error) { out = make(rc.Params) remoteInt, ok := in["remote"] if !ok { return out, fmt.Errorf("remote is needed") } remote := remoteInt.(string) withData := false _, ok = in["withData"] if ok { withData = true } remote = f.unwrapRemote(remote) if !f.cache.HasEntry(path.Join(f.Root(), remote)) { return out, fmt.Errorf("%s doesn't exist in cache", remote) } co := NewObject(f, remote) err = f.cache.GetObject(co) if err != nil { // it could be a dir cd := NewDirectory(f, remote) err := f.cache.ExpireDir(cd) if err != nil { return out, fmt.Errorf("error expiring directory: %w", err) } // notify vfs too f.notifyChangeUpstream(cd.Remote(), fs.EntryDirectory) out["status"] = "ok" out["message"] = fmt.Sprintf("cached directory cleared: %v", remote) return out, nil } // expire the entry err = f.cache.ExpireObject(co, withData) if err != nil { return out, fmt.Errorf("error expiring file: %w", err) } // notify vfs too f.notifyChangeUpstream(co.Remote(), fs.EntryObject) out["status"] = "ok" out["message"] = fmt.Sprintf("cached file cleared: %v", remote) return out, nil } func (f *Fs) rcFetch(ctx context.Context, in rc.Params) (rc.Params, error) { type chunkRange struct { start, end int64 } parseChunks := func(ranges string) (crs []chunkRange, err error) { for _, part := range strings.Split(ranges, ",") { var start, end int64 = 0, math.MaxInt64 switch ints := strings.Split(part, ":"); len(ints) { case 1: start, err = strconv.ParseInt(ints[0], 10, 64) if err != nil { return nil, fmt.Errorf("invalid range: %q", part) } end = start + 1 case 2: if ints[0] != "" { start, err = strconv.ParseInt(ints[0], 10, 64) if err != nil { return nil, fmt.Errorf("invalid range: %q", part) } } if ints[1] != "" { end, err = strconv.ParseInt(ints[1], 10, 64) if err != nil { return nil, fmt.Errorf("invalid range: %q", part) } } default: return nil, fmt.Errorf("invalid range: %q", part) } crs = append(crs, chunkRange{start: start, end: end}) } return } walkChunkRange := func(cr chunkRange, size int64, cb func(chunk int64)) { if size <= 0 { return } chunks := (size-1)/f.ChunkSize() + 1 start, end := cr.start, cr.end if start < 0 { start += chunks } if end <= 0 { end += chunks } if end <= start { return } switch { case start < 0: start = 0 case start >= chunks: return } switch { case end <= start: end = start + 1 case end >= chunks: end = chunks } for i := start; i < end; i++ { cb(i) } } walkChunkRanges := func(crs []chunkRange, size int64, cb func(chunk int64)) { for _, cr := range crs { walkChunkRange(cr, size, cb) } } v, ok := in["chunks"] if !ok { return nil, errors.New("missing chunks parameter") } s, ok := v.(string) if !ok { return nil, errors.New("invalid chunks parameter") } delete(in, "chunks") crs, err := parseChunks(s) if err != nil { return nil, fmt.Errorf("invalid chunks parameter: %w", err) } var files [][2]string for k, v := range in { if !strings.HasPrefix(k, "file") { return nil, fmt.Errorf("invalid parameter %s=%s", k, v) } switch v := v.(type) { case string: files = append(files, [2]string{v, f.unwrapRemote(v)}) default: return nil, fmt.Errorf("invalid parameter %s=%s", k, v) } } type fileStatus struct { Error string FetchedChunks int } fetchedChunks := make(map[string]fileStatus, len(files)) for _, pair := range files { file, remote := pair[0], pair[1] var status fileStatus o, err := f.NewObject(ctx, remote) if err != nil { fetchedChunks[file] = fileStatus{Error: err.Error()} continue } co := o.(*Object) err = co.refreshFromSource(ctx, true) if err != nil { fetchedChunks[file] = fileStatus{Error: err.Error()} continue } handle := NewObjectHandle(ctx, co, f) handle.UseMemory = false handle.scaleWorkers(1) walkChunkRanges(crs, co.Size(), func(chunk int64) { _, err := handle.getChunk(chunk * f.ChunkSize()) if err != nil { if status.Error == "" { status.Error = err.Error() } } else { status.FetchedChunks++ } }) fetchedChunks[file] = status } return rc.Params{"status": fetchedChunks}, nil } // receiveChangeNotify is a wrapper to notifications sent from the wrapped FS about changed files func (f *Fs) receiveChangeNotify(forgetPath string, entryType fs.EntryType) { if crypt, yes := f.isWrappedByCrypt(); yes { decryptedPath, err := crypt.DecryptFileName(forgetPath) if err == nil { fs.Infof(decryptedPath, "received cache expiry notification") } else { fs.Infof(forgetPath, "received cache expiry notification") } } else { fs.Infof(forgetPath, "received cache expiry notification") } // notify upstreams too (vfs) f.notifyChangeUpstream(forgetPath, entryType) var cd *Directory if entryType == fs.EntryObject { co := NewObject(f, forgetPath) err := f.cache.GetObject(co) if err != nil { fs.Debugf(f, "got change notification for non cached entry %v", co) } err = f.cache.ExpireObject(co, true) if err != nil { fs.Debugf(forgetPath, "notify: error expiring '%v': %v", co, err) } cd = NewDirectory(f, cleanPath(path.Dir(co.Remote()))) } else { cd = NewDirectory(f, forgetPath) } // we expire the dir err := f.cache.ExpireDir(cd) if err != nil { fs.Debugf(forgetPath, "notify: error expiring '%v': %v", cd, err) } else { fs.Debugf(forgetPath, "notify: expired '%v'", cd) } f.notifiedMu.Lock() defer f.notifiedMu.Unlock() f.notifiedRemotes[forgetPath] = true f.notifiedRemotes[cd.Remote()] = true } // notifyChangeUpstreamIfNeeded will check if the wrapped remote doesn't notify on changes // or if we use a temp fs func (f *Fs) notifyChangeUpstreamIfNeeded(remote string, entryType fs.EntryType) { if f.Fs.Features().ChangeNotify == nil || f.opt.TempWritePath != "" { f.notifyChangeUpstream(remote, entryType) } } // notifyChangeUpstream will loop through all the upstreams and notify // of the provided remote (should be only a dir) func (f *Fs) notifyChangeUpstream(remote string, entryType fs.EntryType) { f.parentsForgetMu.Lock() defer f.parentsForgetMu.Unlock() if len(f.parentsForgetFn) > 0 { for _, fn := range f.parentsForgetFn { fn(remote, entryType) } } } // ChangeNotify can subscribe multiple callers // this is coupled with the wrapped fs ChangeNotify (if it supports it) // and also notifies other caches (i.e VFS) to clear out whenever something changes func (f *Fs) ChangeNotify(ctx context.Context, notifyFunc func(string, fs.EntryType), pollInterval <-chan time.Duration) { f.parentsForgetMu.Lock() defer f.parentsForgetMu.Unlock() fs.Debugf(f, "subscribing to ChangeNotify") f.parentsForgetFn = append(f.parentsForgetFn, notifyFunc) go func() { for range pollInterval { } }() } // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // String returns a description of the FS func (f *Fs) String() string { return fmt.Sprintf("Cache remote %s:%s", f.name, f.root) } // ChunkSize returns the configured chunk size func (f *Fs) ChunkSize() int64 { return int64(f.opt.ChunkSize) } // InfoAge returns the configured file age func (f *Fs) InfoAge() time.Duration { return time.Duration(f.opt.InfoAge) } // TempUploadWaitTime returns the configured temp file upload wait time func (f *Fs) TempUploadWaitTime() time.Duration { return time.Duration(f.opt.TempWaitTime) } // NewObject finds the Object at remote. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { var err error fs.Debugf(f, "new object '%s'", remote) co := NewObject(f, remote) // search for entry in cache and validate it err = f.cache.GetObject(co) if err != nil { fs.Debugf(remote, "find: error: %v", err) } else if time.Now().After(co.CacheTs.Add(time.Duration(f.opt.InfoAge))) { fs.Debugf(co, "find: cold object: %+v", co) } else { fs.Debugf(co, "find: warm object: %v, expiring on: %v", co, co.CacheTs.Add(time.Duration(f.opt.InfoAge))) return co, nil } // search for entry in source or temp fs var obj fs.Object if f.opt.TempWritePath != "" { obj, err = f.tempFs.NewObject(ctx, remote) // not found in temp fs if err != nil { fs.Debugf(remote, "find: not found in local cache fs") obj, err = f.Fs.NewObject(ctx, remote) } else { fs.Debugf(obj, "find: found in local cache fs") } } else { obj, err = f.Fs.NewObject(ctx, remote) } // not found in either fs if err != nil { fs.Debugf(obj, "find failed: not found in either local or remote fs") return nil, err } // cache the new entry co = ObjectFromOriginal(ctx, f, obj).persist() fs.Debugf(co, "find: cached object") return co, nil } // List the objects and directories in dir into entries func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { fs.Debugf(f, "list '%s'", dir) cd := ShallowDirectory(f, dir) // search for cached dir entries and validate them entries, err = f.cache.GetDirEntries(cd) if err != nil { fs.Debugf(dir, "list: error: %v", err) } else if time.Now().After(cd.CacheTs.Add(time.Duration(f.opt.InfoAge))) { fs.Debugf(dir, "list: cold listing: %v", cd.CacheTs) } else if len(entries) == 0 { // TODO: read empty dirs from source? fs.Debugf(dir, "list: empty listing") } else { fs.Debugf(dir, "list: warm %v from cache for: %v, expiring on: %v", len(entries), cd.abs(), cd.CacheTs.Add(time.Duration(f.opt.InfoAge))) fs.Debugf(dir, "list: cached entries: %v", entries) return entries, nil } // we first search any temporary files stored locally var cachedEntries fs.DirEntries if f.opt.TempWritePath != "" { queuedEntries, err := f.cache.searchPendingUploadFromDir(cd.abs()) if err != nil { fs.Errorf(dir, "list: error getting pending uploads: %v", err) } else { fs.Debugf(dir, "list: read %v from temp fs", len(queuedEntries)) fs.Debugf(dir, "list: temp fs entries: %v", queuedEntries) for _, queuedRemote := range queuedEntries { queuedEntry, err := f.tempFs.NewObject(ctx, f.cleanRootFromPath(queuedRemote)) if err != nil { fs.Debugf(dir, "list: temp file not found in local fs: %v", err) continue } co := ObjectFromOriginal(ctx, f, queuedEntry).persist() fs.Debugf(co, "list: cached temp object") cachedEntries = append(cachedEntries, co) } } } // search from the source sourceEntries, err := f.Fs.List(ctx, dir) if err != nil { return nil, err } fs.Debugf(dir, "list: read %v from source", len(sourceEntries)) fs.Debugf(dir, "list: source entries: %v", sourceEntries) sort.Sort(sourceEntries) for _, entry := range entries { entryRemote := entry.Remote() i := sort.Search(len(sourceEntries), func(i int) bool { return sourceEntries[i].Remote() >= entryRemote }) if i < len(sourceEntries) && sourceEntries[i].Remote() == entryRemote { continue } fp := path.Join(f.Root(), entryRemote) switch entry.(type) { case fs.Object: _ = f.cache.RemoveObject(fp) case fs.Directory: _ = f.cache.RemoveDir(fp) } fs.Debugf(dir, "list: remove entry: %v", entryRemote) } entries = nil //nolint:ineffassign // and then iterate over the ones from source (temp Objects will override source ones) var batchDirectories []*Directory sort.Sort(cachedEntries) tmpCnt := len(cachedEntries) for _, entry := range sourceEntries { switch o := entry.(type) { case fs.Object: // skip over temporary objects (might be uploading) oRemote := o.Remote() i := sort.Search(tmpCnt, func(i int) bool { return cachedEntries[i].Remote() >= oRemote }) if i < tmpCnt && cachedEntries[i].Remote() == oRemote { continue } co := ObjectFromOriginal(ctx, f, o).persist() cachedEntries = append(cachedEntries, co) fs.Debugf(dir, "list: cached object: %v", co) case fs.Directory: cdd := DirectoryFromOriginal(ctx, f, o) // check if the dir isn't expired and add it in cache if it isn't if cdd2, err := f.cache.GetDir(cdd.abs()); err != nil || time.Now().Before(cdd2.CacheTs.Add(time.Duration(f.opt.InfoAge))) { batchDirectories = append(batchDirectories, cdd) } cachedEntries = append(cachedEntries, cdd) default: fs.Debugf(entry, "list: Unknown object type %T", entry) } } err = f.cache.AddBatchDir(batchDirectories) if err != nil { fs.Errorf(dir, "list: error caching directories from listing %v", dir) } else { fs.Debugf(dir, "list: cached directories: %v", len(batchDirectories)) } // cache dir meta t := time.Now() cd.CacheTs = &t err = f.cache.AddDir(cd) if err != nil { fs.Errorf(cd, "list: save error: '%v'", err) } else { fs.Debugf(dir, "list: cached dir: '%v', cache ts: %v", cd.abs(), cd.CacheTs) } return cachedEntries, nil } func (f *Fs) recurse(ctx context.Context, dir string, list *list.Helper) error { entries, err := f.List(ctx, dir) if err != nil { return err } for i := range entries { innerDir, ok := entries[i].(fs.Directory) if ok { err := f.recurse(ctx, innerDir.Remote(), list) if err != nil { return err } } err := list.Add(entries[i]) if err != nil { return err } } return nil } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { fs.Debugf(f, "list recursively from '%s'", dir) // we check if the source FS supports ListR // if it does, we'll use that to get all the entries, cache them and return do := f.Fs.Features().ListR if do != nil { return do(ctx, dir, func(entries fs.DirEntries) error { // we got called back with a set of entries so let's cache them and call the original callback for _, entry := range entries { switch o := entry.(type) { case fs.Object: _ = f.cache.AddObject(ObjectFromOriginal(ctx, f, o)) case fs.Directory: _ = f.cache.AddDir(DirectoryFromOriginal(ctx, f, o)) default: return fmt.Errorf("unknown object type %T", entry) } } // call the original callback return callback(entries) }) } // if we're here, we're gonna do a standard recursive traversal and cache everything list := list.NewHelper(callback) err = f.recurse(ctx, dir, list) if err != nil { return err } return list.Flush() } // Mkdir makes the directory (container, bucket) func (f *Fs) Mkdir(ctx context.Context, dir string) error { fs.Debugf(f, "mkdir '%s'", dir) err := f.Fs.Mkdir(ctx, dir) if err != nil { return err } fs.Debugf(dir, "mkdir: created dir in source fs") cd := NewDirectory(f, cleanPath(dir)) err = f.cache.AddDir(cd) if err != nil { fs.Errorf(dir, "mkdir: add error: %v", err) } else { fs.Debugf(cd, "mkdir: added to cache") } // expire parent of new dir parentCd := NewDirectory(f, cleanPath(path.Dir(dir))) err = f.cache.ExpireDir(parentCd) if err != nil { fs.Errorf(parentCd, "mkdir: cache expire error: %v", err) } else { fs.Infof(parentCd, "mkdir: cache expired") } // advertise to ChangeNotify if wrapped doesn't do that f.notifyChangeUpstreamIfNeeded(parentCd.Remote(), fs.EntryDirectory) return nil } // Rmdir removes the directory (container, bucket) if empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { fs.Debugf(f, "rmdir '%s'", dir) if f.opt.TempWritePath != "" { // pause background uploads f.backgroundRunner.pause() defer f.backgroundRunner.play() // we check if the source exists on the remote and make the same move on it too if it does // otherwise, we skip this step _, err := f.UnWrap().List(ctx, dir) if err == nil { err := f.Fs.Rmdir(ctx, dir) if err != nil { return err } fs.Debugf(dir, "rmdir: removed dir in source fs") } var queuedEntries []*Object err = walk.ListR(ctx, f.tempFs, dir, true, -1, walk.ListObjects, func(entries fs.DirEntries) error { for _, o := range entries { if oo, ok := o.(fs.Object); ok { co := ObjectFromOriginal(ctx, f, oo) queuedEntries = append(queuedEntries, co) } } return nil }) if err != nil { fs.Errorf(dir, "rmdir: error getting pending uploads: %v", err) } else { fs.Debugf(dir, "rmdir: read %v from temp fs", len(queuedEntries)) fs.Debugf(dir, "rmdir: temp fs entries: %v", queuedEntries) if len(queuedEntries) > 0 { fs.Errorf(dir, "rmdir: temporary dir not empty: %v", queuedEntries) return fs.ErrorDirectoryNotEmpty } } } else { err := f.Fs.Rmdir(ctx, dir) if err != nil { return err } fs.Debugf(dir, "rmdir: removed dir in source fs") } // remove dir data d := NewDirectory(f, dir) err := f.cache.RemoveDir(d.abs()) if err != nil { fs.Errorf(dir, "rmdir: remove error: %v", err) } else { fs.Debugf(d, "rmdir: removed from cache") } // expire parent parentCd := NewDirectory(f, cleanPath(path.Dir(dir))) err = f.cache.ExpireDir(parentCd) if err != nil { fs.Errorf(dir, "rmdir: cache expire error: %v", err) } else { fs.Infof(parentCd, "rmdir: cache expired") } // advertise to ChangeNotify if wrapped doesn't do that f.notifyChangeUpstreamIfNeeded(parentCd.Remote(), fs.EntryDirectory) return nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { fs.Debugf(f, "move dir '%s'/'%s' -> '%s'/'%s'", src.Root(), srcRemote, f.Root(), dstRemote) do := f.Fs.Features().DirMove if do == nil { return fs.ErrorCantDirMove } srcFs, ok := src.(*Fs) if !ok { fs.Errorf(srcFs, "can't move directory - not same remote type") return fs.ErrorCantDirMove } if srcFs.Fs.Name() != f.Fs.Name() { fs.Errorf(srcFs, "can't move directory - not wrapping same remotes") return fs.ErrorCantDirMove } if f.opt.TempWritePath != "" { // pause background uploads f.backgroundRunner.pause() defer f.backgroundRunner.play() _, errInWrap := srcFs.UnWrap().List(ctx, srcRemote) _, errInTemp := f.tempFs.List(ctx, srcRemote) // not found in either fs if errInWrap != nil && errInTemp != nil { return fs.ErrorDirNotFound } // we check if the source exists on the remote and make the same move on it too if it does // otherwise, we skip this step if errInWrap == nil { err := do(ctx, srcFs.UnWrap(), srcRemote, dstRemote) if err != nil { return err } fs.Debugf(srcRemote, "movedir: dir moved in the source fs") } // we need to check if the directory exists in the temp fs // and skip the move if it doesn't if errInTemp != nil { goto cleanup } var queuedEntries []*Object err := walk.ListR(ctx, f.tempFs, srcRemote, true, -1, walk.ListObjects, func(entries fs.DirEntries) error { for _, o := range entries { if oo, ok := o.(fs.Object); ok { co := ObjectFromOriginal(ctx, f, oo) queuedEntries = append(queuedEntries, co) if co.tempFileStartedUpload() { fs.Errorf(co, "can't move - upload has already started. need to finish that") return fs.ErrorCantDirMove } } } return nil }) if err != nil { return err } fs.Debugf(srcRemote, "dirmove: read %v from temp fs", len(queuedEntries)) fs.Debugf(srcRemote, "dirmove: temp fs entries: %v", queuedEntries) do := f.tempFs.Features().DirMove if do == nil { fs.Errorf(srcRemote, "dirmove: can't move dir in temp fs") return fs.ErrorCantDirMove } err = do(ctx, f.tempFs, srcRemote, dstRemote) if err != nil { return err } err = f.cache.ReconcileTempUploads(ctx, f) if err != nil { return err } } else { err := do(ctx, srcFs.UnWrap(), srcRemote, dstRemote) if err != nil { return err } fs.Debugf(srcRemote, "movedir: dir moved in the source fs") } cleanup: // delete src dir from cache along with all chunks srcDir := NewDirectory(srcFs, srcRemote) err := f.cache.RemoveDir(srcDir.abs()) if err != nil { fs.Errorf(srcDir, "dirmove: remove error: %v", err) } else { fs.Debugf(srcDir, "dirmove: removed cached dir") } // expire src parent srcParent := NewDirectory(f, cleanPath(path.Dir(srcRemote))) err = f.cache.ExpireDir(srcParent) if err != nil { fs.Errorf(srcParent, "dirmove: cache expire error: %v", err) } else { fs.Debugf(srcParent, "dirmove: cache expired") } // advertise to ChangeNotify if wrapped doesn't do that f.notifyChangeUpstreamIfNeeded(srcParent.Remote(), fs.EntryDirectory) // expire parent dir at the destination path dstParent := NewDirectory(f, cleanPath(path.Dir(dstRemote))) err = f.cache.ExpireDir(dstParent) if err != nil { fs.Errorf(dstParent, "dirmove: cache expire error: %v", err) } else { fs.Debugf(dstParent, "dirmove: cache expired") } // advertise to ChangeNotify if wrapped doesn't do that f.notifyChangeUpstreamIfNeeded(dstParent.Remote(), fs.EntryDirectory) // TODO: precache dst dir and save the chunks return nil } // cacheReader will split the stream of a reader to be cached at the same time it is read by the original source func (f *Fs) cacheReader(u io.Reader, src fs.ObjectInfo, originalRead func(inn io.Reader)) { // create the pipe and tee reader pr, pw := io.Pipe() tr := io.TeeReader(u, pw) // create channel to synchronize done := make(chan bool) defer close(done) go func() { // notify the cache reader that we're complete after the source FS finishes defer func() { _ = pw.Close() }() // process original reading originalRead(tr) // signal complete done <- true }() go func() { var offset int64 for { chunk := make([]byte, f.opt.ChunkSize) readSize, err := io.ReadFull(pr, chunk) // we ignore 3 failures which are ok: // 1. EOF - original reading finished and we got a full buffer too // 2. ErrUnexpectedEOF - original reading finished and partial buffer // 3. ErrClosedPipe - source remote reader was closed (usually means it reached the end) and we need to stop too // if we have a different error: we're going to error out the original reading too and stop this if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF && err != io.ErrClosedPipe { fs.Errorf(src, "error saving new data in cache. offset: %v, err: %v", offset, err) _ = pr.CloseWithError(err) break } // if we have some bytes we cache them if readSize > 0 { chunk = chunk[:readSize] err2 := f.cache.AddChunk(cleanPath(path.Join(f.root, src.Remote())), chunk, offset) if err2 != nil { fs.Errorf(src, "error saving new data in cache '%v'", err2) _ = pr.CloseWithError(err2) break } offset += int64(readSize) } // stuff should be closed but let's be sure if err == io.EOF || err == io.ErrUnexpectedEOF || err == io.ErrClosedPipe { _ = pr.Close() break } } // signal complete done <- true }() // wait until both are done for range 2 { <-done } } type putFn func(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) // put in to the remote path func (f *Fs) put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options []fs.OpenOption, put putFn) (fs.Object, error) { var err error var obj fs.Object // queue for upload and store in temp fs if configured if f.opt.TempWritePath != "" { // we need to clear the caches before a put through temp fs parentCd := NewDirectory(f, cleanPath(path.Dir(src.Remote()))) _ = f.cache.ExpireDir(parentCd) f.notifyChangeUpstreamIfNeeded(parentCd.Remote(), fs.EntryDirectory) obj, err = f.tempFs.Put(ctx, in, src, options...) if err != nil { fs.Errorf(obj, "put: failed to upload in temp fs: %v", err) return nil, err } fs.Infof(obj, "put: uploaded in temp fs") err = f.cache.addPendingUpload(path.Join(f.Root(), src.Remote()), false) if err != nil { fs.Errorf(obj, "put: failed to queue for upload: %v", err) return nil, err } fs.Infof(obj, "put: queued for upload") // if cache writes is enabled write it first through cache } else if f.opt.StoreWrites { f.cacheReader(in, src, func(inn io.Reader) { obj, err = put(ctx, inn, src, options...) }) if err == nil { fs.Debugf(obj, "put: uploaded to remote fs and saved in cache") } // last option: save it directly in remote fs } else { obj, err = put(ctx, in, src, options...) if err == nil { fs.Debugf(obj, "put: uploaded to remote fs") } } // validate and stop if errors are found if err != nil { fs.Errorf(src, "put: error uploading: %v", err) return nil, err } // cache the new file cachedObj := ObjectFromOriginal(ctx, f, obj) // deleting cached chunks and info to be replaced with new ones _ = f.cache.RemoveObject(cachedObj.abs()) cachedObj.persist() fs.Debugf(cachedObj, "put: added to cache") // expire parent parentCd := NewDirectory(f, cleanPath(path.Dir(cachedObj.Remote()))) err = f.cache.ExpireDir(parentCd) if err != nil { fs.Errorf(cachedObj, "put: cache expire error: %v", err) } else { fs.Infof(parentCd, "put: cache expired") } // advertise to ChangeNotify f.notifyChangeUpstreamIfNeeded(parentCd.Remote(), fs.EntryDirectory) return cachedObj, nil } // Put in to the remote path with the modTime given of the given size func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { fs.Debugf(f, "put data at '%s'", src.Remote()) return f.put(ctx, in, src, options, f.Fs.Put) } // PutUnchecked uploads the object func (f *Fs) PutUnchecked(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { do := f.Fs.Features().PutUnchecked if do == nil { return nil, errors.New("can't PutUnchecked") } fs.Debugf(f, "put data unchecked in '%s'", src.Remote()) return f.put(ctx, in, src, options, do) } // PutStream uploads the object func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { do := f.Fs.Features().PutStream if do == nil { return nil, errors.New("can't PutStream") } fs.Debugf(f, "put data streaming in '%s'", src.Remote()) return f.put(ctx, in, src, options, do) } // Copy src to this remote using server-side copy operations. func (f *Fs) Copy(ctx context.Context, src fs.Object, remote string) (fs.Object, error) { fs.Debugf(f, "copy obj '%s' -> '%s'", src, remote) do := f.Fs.Features().Copy if do == nil { fs.Errorf(src, "source remote (%v) doesn't support Copy", src.Fs()) return nil, fs.ErrorCantCopy } if f.opt.TempWritePath != "" && src.Fs() == f.tempFs { return nil, fs.ErrorCantCopy } // the source must be a cached object or we abort srcObj, ok := src.(*Object) if !ok { fs.Errorf(srcObj, "can't copy - not same remote type") return nil, fs.ErrorCantCopy } // both the source cache fs and this cache fs need to wrap the same remote if srcObj.CacheFs.Fs.Name() != f.Fs.Name() { fs.Errorf(srcObj, "can't copy - not wrapping same remotes") return nil, fs.ErrorCantCopy } // refresh from source or abort if err := srcObj.refreshFromSource(ctx, false); err != nil { fs.Errorf(f, "can't copy %v - %v", src, err) return nil, fs.ErrorCantCopy } if srcObj.isTempFile() { // we check if the feature is still active if f.opt.TempWritePath == "" { fs.Errorf(srcObj, "can't copy - this is a local cached file but this feature is turned off this run") return nil, fs.ErrorCantCopy } do = srcObj.ParentFs.Features().Copy if do == nil { fs.Errorf(src, "parent remote (%v) doesn't support Copy", srcObj.ParentFs) return nil, fs.ErrorCantCopy } } obj, err := do(ctx, srcObj.Object, remote) if err != nil { fs.Errorf(srcObj, "error moving in cache: %v", err) return nil, err } fs.Debugf(obj, "copy: file copied") // persist new co := ObjectFromOriginal(ctx, f, obj).persist() fs.Debugf(co, "copy: added to cache") // expire the destination path parentCd := NewDirectory(f, cleanPath(path.Dir(co.Remote()))) err = f.cache.ExpireDir(parentCd) if err != nil { fs.Errorf(parentCd, "copy: cache expire error: %v", err) } else { fs.Infof(parentCd, "copy: cache expired") } // advertise to ChangeNotify if wrapped doesn't do that f.notifyChangeUpstreamIfNeeded(parentCd.Remote(), fs.EntryDirectory) // expire src parent srcParent := NewDirectory(f, cleanPath(path.Dir(src.Remote()))) err = f.cache.ExpireDir(srcParent) if err != nil { fs.Errorf(srcParent, "copy: cache expire error: %v", err) } else { fs.Infof(srcParent, "copy: cache expired") } // advertise to ChangeNotify if wrapped doesn't do that f.notifyChangeUpstreamIfNeeded(srcParent.Remote(), fs.EntryDirectory) return co, nil } // Move src to this remote using server-side move operations. func (f *Fs) Move(ctx context.Context, src fs.Object, remote string) (fs.Object, error) { fs.Debugf(f, "moving obj '%s' -> %s", src, remote) // if source fs doesn't support move abort do := f.Fs.Features().Move if do == nil { fs.Errorf(src, "source remote (%v) doesn't support Move", src.Fs()) return nil, fs.ErrorCantMove } // the source must be a cached object or we abort srcObj, ok := src.(*Object) if !ok { fs.Errorf(srcObj, "can't move - not same remote type") return nil, fs.ErrorCantMove } // both the source cache fs and this cache fs need to wrap the same remote if srcObj.CacheFs.Fs.Name() != f.Fs.Name() { fs.Errorf(srcObj, "can't move - not wrapping same remote types") return nil, fs.ErrorCantMove } // refresh from source or abort if err := srcObj.refreshFromSource(ctx, false); err != nil { fs.Errorf(f, "can't move %v - %v", src, err) return nil, fs.ErrorCantMove } // if this is a temp object then we perform the changes locally if srcObj.isTempFile() { // we check if the feature is still active if f.opt.TempWritePath == "" { fs.Errorf(srcObj, "can't move - this is a local cached file but this feature is turned off this run") return nil, fs.ErrorCantMove } // pause background uploads f.backgroundRunner.pause() defer f.backgroundRunner.play() // started uploads can't be moved until they complete if srcObj.tempFileStartedUpload() { fs.Errorf(srcObj, "can't move - upload has already started. need to finish that") return nil, fs.ErrorCantMove } do = f.tempFs.Features().Move // we must also update the pending queue err := f.cache.updatePendingUpload(srcObj.abs(), func(item *tempUploadInfo) error { item.DestPath = path.Join(f.Root(), remote) item.AddedOn = time.Now() return nil }) if err != nil { fs.Errorf(srcObj, "failed to rename queued file for upload: %v", err) return nil, fs.ErrorCantMove } fs.Debugf(srcObj, "move: queued file moved to %v", remote) } obj, err := do(ctx, srcObj.Object, remote) if err != nil { fs.Errorf(srcObj, "error moving: %v", err) return nil, err } fs.Debugf(obj, "move: file moved") // remove old err = f.cache.RemoveObject(srcObj.abs()) if err != nil { fs.Errorf(srcObj, "move: remove error: %v", err) } else { fs.Debugf(srcObj, "move: removed from cache") } // expire old parent parentCd := NewDirectory(f, cleanPath(path.Dir(srcObj.Remote()))) err = f.cache.ExpireDir(parentCd) if err != nil { fs.Errorf(parentCd, "move: parent cache expire error: %v", err) } else { fs.Infof(parentCd, "move: cache expired") } // advertise to ChangeNotify if wrapped doesn't do that f.notifyChangeUpstreamIfNeeded(parentCd.Remote(), fs.EntryDirectory) // persist new cachedObj := ObjectFromOriginal(ctx, f, obj).persist() fs.Debugf(cachedObj, "move: added to cache") // expire new parent parentCd = NewDirectory(f, cleanPath(path.Dir(cachedObj.Remote()))) err = f.cache.ExpireDir(parentCd) if err != nil { fs.Errorf(parentCd, "move: expire error: %v", err) } else { fs.Infof(parentCd, "move: cache expired") } // advertise to ChangeNotify if wrapped doesn't do that f.notifyChangeUpstreamIfNeeded(parentCd.Remote(), fs.EntryDirectory) return cachedObj, nil } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return f.Fs.Hashes() } // Purge all files in the directory func (f *Fs) Purge(ctx context.Context, dir string) error { if dir == "" { // FIXME this isn't quite right as it should purge the dir prefix fs.Infof(f, "purging cache") f.cache.Purge() } do := f.Fs.Features().Purge if do == nil { return fs.ErrorCantPurge } err := do(ctx, dir) if err != nil { return err } return nil } // CleanUp the trash in the Fs func (f *Fs) CleanUp(ctx context.Context) error { f.CleanUpCache(false) do := f.Fs.Features().CleanUp if do == nil { return nil } return do(ctx) } // About gets quota information from the Fs func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { do := f.Fs.Features().About if do == nil { return nil, errors.New("not supported by underlying remote") } return do(ctx) } // Stats returns stats about the cache storage func (f *Fs) Stats() (map[string]map[string]any, error) { return f.cache.Stats() } // openRateLimited will execute a closure under a rate limiter watch func (f *Fs) openRateLimited(fn func() (io.ReadCloser, error)) (io.ReadCloser, error) { var err error ctx, cancel := context.WithTimeout(context.Background(), time.Second*10) defer cancel() start := time.Now() if err = f.rateLimiter.Wait(ctx); err != nil { return nil, err } elapsed := time.Since(start) if elapsed > time.Second*2 { fs.Debugf(f, "rate limited: %s", elapsed) } return fn() } // CleanUpCache will cleanup only the cache data that is expired func (f *Fs) CleanUpCache(ignoreLastTs bool) { f.cleanupMu.Lock() defer f.cleanupMu.Unlock() if ignoreLastTs || time.Now().After(f.lastChunkCleanup.Add(time.Duration(f.opt.ChunkCleanInterval))) { f.cache.CleanChunksBySize(int64(f.opt.ChunkTotalSize)) f.lastChunkCleanup = time.Now() } } // StopBackgroundRunners will signal all the runners to stop their work // can be triggered from a terminate signal or from testing between runs func (f *Fs) StopBackgroundRunners() { f.cleanupChan <- false if f.opt.TempWritePath != "" && f.backgroundRunner != nil && f.backgroundRunner.isRunning() { f.backgroundRunner.close() } f.cache.Close() fs.Debugf(f, "Services stopped") } // UnWrap returns the Fs that this Fs is wrapping func (f *Fs) UnWrap() fs.Fs { return f.Fs } // WrapFs returns the Fs that is wrapping this Fs func (f *Fs) WrapFs() fs.Fs { return f.wrapper } // SetWrapper sets the Fs that is wrapping this Fs func (f *Fs) SetWrapper(wrapper fs.Fs) { f.wrapper = wrapper } // isWrappedByCrypt checks if this is wrapped by a crypt remote func (f *Fs) isWrappedByCrypt() (*crypt.Fs, bool) { if f.wrapper == nil { return nil, false } c, ok := f.wrapper.(*crypt.Fs) return c, ok } // cleanRootFromPath trims the root of the current fs from a path func (f *Fs) cleanRootFromPath(p string) string { if f.Root() != "" { p = p[len(f.Root()):] // trim out root if len(p) > 0 { // remove first separator p = p[1:] } } return p } func (f *Fs) isRootInPath(p string) bool { if f.Root() == "" { return true } return strings.HasPrefix(p, f.Root()+"/") } // MergeDirs merges the contents of all the directories passed // in into the first one and rmdirs the other directories. func (f *Fs) MergeDirs(ctx context.Context, dirs []fs.Directory) error { do := f.Fs.Features().MergeDirs if do == nil { return errors.New("MergeDirs not supported") } for _, dir := range dirs { _ = f.cache.RemoveDir(dir.Remote()) } return do(ctx, dirs) } // DirCacheFlush flushes the dir cache func (f *Fs) DirCacheFlush() { _ = f.cache.RemoveDir("") } // GetBackgroundUploadChannel returns a channel that can be listened to for remote activities that happen // in the background func (f *Fs) GetBackgroundUploadChannel() chan BackgroundUploadState { if f.opt.TempWritePath != "" { return f.backgroundRunner.notifyCh } return nil } func (f *Fs) isNotifiedRemote(remote string) bool { f.notifiedMu.Lock() defer f.notifiedMu.Unlock() n, ok := f.notifiedRemotes[remote] if !ok || !n { return false } delete(f.notifiedRemotes, remote) return n } func cleanPath(p string) string { p = path.Clean(p) if p == "." || p == "/" { p = "" } return p } // UserInfo returns info about the connected user func (f *Fs) UserInfo(ctx context.Context) (map[string]string, error) { do := f.Fs.Features().UserInfo if do == nil { return nil, fs.ErrorNotImplemented } return do(ctx) } // Disconnect the current user func (f *Fs) Disconnect(ctx context.Context) error { do := f.Fs.Features().Disconnect if do == nil { return fs.ErrorNotImplemented } return do(ctx) } // Shutdown the backend, closing any background tasks and any // cached connections. func (f *Fs) Shutdown(ctx context.Context) error { do := f.Fs.Features().Shutdown if do == nil { return nil } return do(ctx) } var commandHelp = []fs.CommandHelp{ { Name: "stats", Short: "Print stats on the cache backend in JSON format.", }, } // Command the backend to run a named command // // The command run is name // args may be used to read arguments from // opts may be used to read optional arguments from // // The result should be capable of being JSON encoded // If it is a string or a []string it will be shown to the user // otherwise it will be JSON encoded and shown to the user like that func (f *Fs) Command(ctx context.Context, name string, arg []string, opt map[string]string) (any, error) { switch name { case "stats": return f.Stats() default: return nil, fs.ErrorCommandNotFound } } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.PutUncheckeder = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.CleanUpper = (*Fs)(nil) _ fs.UnWrapper = (*Fs)(nil) _ fs.Wrapper = (*Fs)(nil) _ fs.ListRer = (*Fs)(nil) _ fs.ChangeNotifier = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.UserInfoer = (*Fs)(nil) _ fs.Disconnecter = (*Fs)(nil) _ fs.Commander = (*Fs)(nil) _ fs.MergeDirser = (*Fs)(nil) _ fs.Shutdowner = (*Fs)(nil) ) rclone-v1.71.0/backend/cache/cache_internal_test.go000066400000000000000000001223671505210326400222400ustar00rootroot00000000000000//go:build !plan9 && !js && !race package cache_test import ( "bytes" "context" "encoding/base64" "errors" goflag "flag" "fmt" "io" "math/rand" "os" "path" "path/filepath" "runtime" "runtime/debug" "strings" "testing" "time" "github.com/rclone/rclone/backend/cache" "github.com/rclone/rclone/backend/crypt" _ "github.com/rclone/rclone/backend/drive" "github.com/rclone/rclone/backend/local" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/object" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/testy" "github.com/rclone/rclone/lib/random" "github.com/rclone/rclone/vfs/vfscommon" "github.com/stretchr/testify/require" ) const ( // these 2 passwords are test random cryptPassword1 = "3XcvMMdsV3d-HGAReTMdNH-5FcX5q32_lUeA" // oGJdUbQc7s8 cryptPassword2 = "NlgTBEIe-qibA7v-FoMfuX6Cw8KlLai_aMvV" // mv4mZW572HM cryptedTextBase64 = "UkNMT05FAAC320i2xIee0BiNyknSPBn+Qcw3q9FhIFp3tvq6qlqvbsno3PnxmEFeJG3jDBnR/wku2gHWeQ==" // one content cryptedText2Base64 = "UkNMT05FAAATcQkVsgjBh8KafCKcr0wdTa1fMmV0U8hsCLGFoqcvxKVmvv7wx3Hf5EXxFcki2FFV4sdpmSrb9Q==" // updated content cryptedText3Base64 = "UkNMT05FAAB/f7YtYKbPfmk9+OX/ffN3qG3OEdWT+z74kxCX9V/YZwJ4X2DN3HOnUC3gKQ4Gcoud5UtNvQ==" // test content letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" ) var ( remoteName string uploadDir string runInstance *run errNotSupported = errors.New("not supported") decryptedToEncryptedRemotes = map[string]string{ "one": "lm4u7jjt3c85bf56vjqgeenuno", "second": "qvt1ochrkcfbptp5mu9ugb2l14", "test": "jn4tegjtpqro30t3o11thb4b5s", "test2": "qakvqnh8ttei89e0gc76crpql4", "data.bin": "0q2847tfko6mhj3dag3r809qbc", "ticw/data.bin": "5mv97b0ule6pht33srae5pice8/0q2847tfko6mhj3dag3r809qbc", "tiuufo/test/one": "vi6u1olqhirqv14cd8qlej1mgo/jn4tegjtpqro30t3o11thb4b5s/lm4u7jjt3c85bf56vjqgeenuno", "tiuufo/test/second": "vi6u1olqhirqv14cd8qlej1mgo/jn4tegjtpqro30t3o11thb4b5s/qvt1ochrkcfbptp5mu9ugb2l14", "tiutfo/test/one": "legd371aa8ol36tjfklt347qnc/jn4tegjtpqro30t3o11thb4b5s/lm4u7jjt3c85bf56vjqgeenuno", "tiutfo/second/one": "legd371aa8ol36tjfklt347qnc/qvt1ochrkcfbptp5mu9ugb2l14/lm4u7jjt3c85bf56vjqgeenuno", "second/one": "qvt1ochrkcfbptp5mu9ugb2l14/lm4u7jjt3c85bf56vjqgeenuno", "test/one": "jn4tegjtpqro30t3o11thb4b5s/lm4u7jjt3c85bf56vjqgeenuno", "test/second": "jn4tegjtpqro30t3o11thb4b5s/qvt1ochrkcfbptp5mu9ugb2l14", "one/test": "lm4u7jjt3c85bf56vjqgeenuno/jn4tegjtpqro30t3o11thb4b5s", "one/test/data.bin": "lm4u7jjt3c85bf56vjqgeenuno/jn4tegjtpqro30t3o11thb4b5s/0q2847tfko6mhj3dag3r809qbc", "second/test/data.bin": "qvt1ochrkcfbptp5mu9ugb2l14/jn4tegjtpqro30t3o11thb4b5s/0q2847tfko6mhj3dag3r809qbc", "test/third": "jn4tegjtpqro30t3o11thb4b5s/2nd7fjiop5h3ihfj1vl953aa5g", "test/0.bin": "jn4tegjtpqro30t3o11thb4b5s/e6frddt058b6kvbpmlstlndmtk", "test/1.bin": "jn4tegjtpqro30t3o11thb4b5s/kck472nt1k7qbmob0mt1p1crgc", "test/2.bin": "jn4tegjtpqro30t3o11thb4b5s/744oe9ven2rmak4u27if51qk24", "test/3.bin": "jn4tegjtpqro30t3o11thb4b5s/2bjd8kef0u5lmsu6qhqll34bcs", "test/4.bin": "jn4tegjtpqro30t3o11thb4b5s/cvjs73iv0a82v0c7r67avllh7s", "test/5.bin": "jn4tegjtpqro30t3o11thb4b5s/0plkdo790b6bnmt33qsdqmhv9c", "test/6.bin": "jn4tegjtpqro30t3o11thb4b5s/s5r633srnjtbh83893jovjt5d0", "test/7.bin": "jn4tegjtpqro30t3o11thb4b5s/6rq45tr9bjsammku622flmqsu4", "test/8.bin": "jn4tegjtpqro30t3o11thb4b5s/37bc6tcl3e31qb8cadvjb749vk", "test/9.bin": "jn4tegjtpqro30t3o11thb4b5s/t4pr35hnls32789o8fk0chk1ec", } ) func init() { goflag.StringVar(&remoteName, "remote-internal", "TestInternalCache", "Remote to test with, defaults to local filesystem") goflag.StringVar(&uploadDir, "upload-dir-internal", "", "") } // TestMain drives the tests func TestMain(m *testing.M) { goflag.Parse() var rc int fs.Logf(nil, "Running with the following params: \n remote: %v", remoteName) runInstance = newRun() rc = m.Run() os.Exit(rc) } func TestInternalListRootAndInnerRemotes(t *testing.T) { id := fmt.Sprintf("tilrair%v", time.Now().Unix()) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, true, true, nil) // Instantiate inner fs innerFolder := "inner" runInstance.mkdir(t, rootFs, innerFolder) rootFs2, _ := runInstance.newCacheFs(t, remoteName, id+"/"+innerFolder, true, true, nil) runInstance.writeObjectString(t, rootFs2, "one", "content") listRoot, err := runInstance.list(t, rootFs, "") require.NoError(t, err) listRootInner, err := runInstance.list(t, rootFs, innerFolder) require.NoError(t, err) listInner, err := rootFs2.List(context.Background(), "") require.NoError(t, err) require.Len(t, listRoot, 1) require.Len(t, listRootInner, 1) require.Len(t, listInner, 1) } /* TODO: is this testing something? func TestInternalVfsCache(t *testing.T) { vfscommon.Opt.DirCacheTime = time.Second * 30 testSize := int64(524288000) vfscommon.Opt.CacheMode = vfs.CacheModeWrites id := "tiuufo" rootFs, boltDb := runInstance.newCacheFs(t, remoteName, id, true, true, nil, map[string]string{"writes": "true", "info_age": "1h"}) defer runInstance.cleanupFs(t, rootFs, boltDb) err := rootFs.Mkdir(context.Background(), "test") require.NoError(t, err) runInstance.writeObjectString(t, rootFs, "test/second", "content") _, err = rootFs.List(context.Background(), "test") require.NoError(t, err) testReader := runInstance.randomReader(t, testSize) writeCh := make(chan interface{}) //write2Ch := make(chan interface{}) readCh := make(chan interface{}) cacheCh := make(chan interface{}) // write the main file go func() { defer func() { writeCh <- true }() log.Printf("========== started writing file 'test/one'") runInstance.writeRemoteReader(t, rootFs, "test/one", testReader) log.Printf("========== done writing file 'test/one'") }() // routine to check which cache has what, autostarts go func() { for { select { case <-cacheCh: log.Printf("========== finished checking caches") return default: } li2 := [2]string{path.Join("test", "one"), path.Join("test", "second")} for _, r := range li2 { var err error ci, err := os.ReadDir(path.Join(runInstance.chunkPath, runInstance.encryptRemoteIfNeeded(t, path.Join(id, r)))) if err != nil || len(ci) == 0 { log.Printf("========== '%v' not in cache", r) } else { log.Printf("========== '%v' IN CACHE", r) } _, err = os.Stat(path.Join(runInstance.vfsCachePath, id, r)) if err != nil { log.Printf("========== '%v' not in vfs", r) } else { log.Printf("========== '%v' IN VFS", r) } } time.Sleep(time.Second * 10) } }() // routine to list, autostarts go func() { for { select { case <-readCh: log.Printf("========== finished checking listings and readings") return default: } li, err := runInstance.list(t, rootFs, "test") if err != nil { log.Printf("========== error listing 'test' folder: %v", err) } else { log.Printf("========== list 'test' folder count: %v", len(li)) } time.Sleep(time.Second * 10) } }() // wait for main file to be written <-writeCh log.Printf("========== waiting for VFS to expire") time.Sleep(time.Second * 120) // try a final read li2 := [2]string{"test/one", "test/second"} for _, r := range li2 { _, err := runInstance.readDataFromRemote(t, rootFs, r, int64(0), int64(2), false) if err != nil { log.Printf("========== error reading '%v': %v", r, err) } else { log.Printf("========== read '%v'", r) } } // close the cache and list checkers cacheCh <- true readCh <- true } */ func TestInternalObjWrapFsFound(t *testing.T) { id := fmt.Sprintf("tiowff%v", time.Now().Unix()) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, true, true, nil) cfs, err := runInstance.getCacheFs(rootFs) require.NoError(t, err) wrappedFs := cfs.UnWrap() var testData []byte if runInstance.rootIsCrypt { testData, err = base64.StdEncoding.DecodeString(cryptedTextBase64) require.NoError(t, err) } else { testData = []byte("test content") } runInstance.writeObjectBytes(t, wrappedFs, runInstance.encryptRemoteIfNeeded(t, "test"), testData) listRoot, err := runInstance.list(t, rootFs, "") require.NoError(t, err) require.Len(t, listRoot, 1) cachedData, err := runInstance.readDataFromRemote(t, rootFs, "test", 0, int64(len([]byte("test content"))), false) require.NoError(t, err) require.Equal(t, "test content", string(cachedData)) err = runInstance.rm(t, rootFs, "test") require.NoError(t, err) listRoot, err = runInstance.list(t, rootFs, "") require.NoError(t, err) require.Len(t, listRoot, 0) } func TestInternalObjNotFound(t *testing.T) { id := fmt.Sprintf("tionf%v", time.Now().Unix()) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, false, true, nil) obj, err := rootFs.NewObject(context.Background(), "404") require.Error(t, err) require.Nil(t, obj) } func TestInternalCachedWrittenContentMatches(t *testing.T) { testy.SkipUnreliable(t) id := fmt.Sprintf("ticwcm%v", time.Now().Unix()) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, false, true, nil) cfs, err := runInstance.getCacheFs(rootFs) require.NoError(t, err) chunkSize := cfs.ChunkSize() // create some rand test data testData := randStringBytes(int(chunkSize*4 + chunkSize/2)) // write the object runInstance.writeRemoteBytes(t, rootFs, "data.bin", testData) // check sample of data from in-file sampleStart := chunkSize / 2 sampleEnd := chunkSize testSample := testData[sampleStart:sampleEnd] checkSample, err := runInstance.readDataFromRemote(t, rootFs, "data.bin", sampleStart, sampleEnd, false) require.NoError(t, err) require.Equal(t, int64(len(checkSample)), sampleEnd-sampleStart) require.Equal(t, checkSample, testSample) } func TestInternalDoubleWrittenContentMatches(t *testing.T) { if runtime.GOOS == "windows" && runtime.GOARCH == "386" { t.Skip("Skip test on windows/386") } id := fmt.Sprintf("tidwcm%v", time.Now().Unix()) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, false, true, nil) // write the object runInstance.writeRemoteString(t, rootFs, "one", "one content") err := runInstance.updateData(t, rootFs, "one", "one content", " updated") require.NoError(t, err) err = runInstance.updateData(t, rootFs, "one", "one content updated", " double") require.NoError(t, err) // check sample of data from in-file data, err := runInstance.readDataFromRemote(t, rootFs, "one", int64(0), int64(len("one content updated double")), true) require.NoError(t, err) require.Equal(t, "one content updated double", string(data)) } func TestInternalCachedUpdatedContentMatches(t *testing.T) { testy.SkipUnreliable(t) id := fmt.Sprintf("ticucm%v", time.Now().Unix()) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, false, true, nil) var err error // create some rand test data var testData1 []byte var testData2 []byte if runInstance.rootIsCrypt { testData1, err = base64.StdEncoding.DecodeString(cryptedTextBase64) require.NoError(t, err) testData2, err = base64.StdEncoding.DecodeString(cryptedText2Base64) require.NoError(t, err) } else { testData1 = []byte(random.String(100)) testData2 = []byte(random.String(200)) } // write the object o := runInstance.updateObjectRemote(t, rootFs, "data.bin", testData1, testData2) require.Equal(t, o.Size(), int64(len(testData2))) // check data from in-file checkSample, err := runInstance.readDataFromRemote(t, rootFs, "data.bin", 0, int64(len(testData2)), false) require.NoError(t, err) require.Equal(t, checkSample, testData2) } func TestInternalWrappedWrittenContentMatches(t *testing.T) { id := fmt.Sprintf("tiwwcm%v", time.Now().Unix()) vfscommon.Opt.DirCacheTime = fs.Duration(time.Second) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, true, true, nil) if runInstance.rootIsCrypt { t.Skip("test skipped with crypt remote") } cfs, err := runInstance.getCacheFs(rootFs) require.NoError(t, err) chunkSize := cfs.ChunkSize() // create some rand test data testSize := chunkSize*4 + chunkSize/2 testData := randStringBytes(int(testSize)) // write the object o := runInstance.writeObjectBytes(t, cfs.UnWrap(), "data.bin", testData) require.Equal(t, o.Size(), testSize) time.Sleep(time.Second * 3) checkSample, err := runInstance.readDataFromRemote(t, rootFs, "data.bin", 0, testSize, false) require.NoError(t, err) require.Equal(t, int64(len(checkSample)), o.Size()) for i := range checkSample { require.Equal(t, testData[i], checkSample[i]) } } func TestInternalLargeWrittenContentMatches(t *testing.T) { id := fmt.Sprintf("tilwcm%v", time.Now().Unix()) vfscommon.Opt.DirCacheTime = fs.Duration(time.Second) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, true, true, nil) if runInstance.rootIsCrypt { t.Skip("test skipped with crypt remote") } cfs, err := runInstance.getCacheFs(rootFs) require.NoError(t, err) chunkSize := cfs.ChunkSize() // create some rand test data testSize := chunkSize*10 + chunkSize/2 testData := randStringBytes(int(testSize)) // write the object runInstance.writeObjectBytes(t, cfs.UnWrap(), "data.bin", testData) time.Sleep(time.Second * 3) readData, err := runInstance.readDataFromRemote(t, rootFs, "data.bin", 0, testSize, false) require.NoError(t, err) for i := range readData { require.Equalf(t, testData[i], readData[i], "at byte %v", i) } } func TestInternalWrappedFsChangeNotSeen(t *testing.T) { id := fmt.Sprintf("tiwfcns%v", time.Now().Unix()) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, false, true, nil) cfs, err := runInstance.getCacheFs(rootFs) require.NoError(t, err) chunkSize := cfs.ChunkSize() // create some rand test data testData := randStringBytes(int(chunkSize*4 + chunkSize/2)) runInstance.writeRemoteBytes(t, rootFs, "data.bin", testData) // update in the wrapped fs originalSize, err := runInstance.size(t, rootFs, "data.bin") require.NoError(t, err) fs.Logf(nil, "original size: %v", originalSize) o, err := cfs.UnWrap().NewObject(context.Background(), runInstance.encryptRemoteIfNeeded(t, "data.bin")) require.NoError(t, err) expectedSize := int64(len([]byte("test content"))) var data2 []byte if runInstance.rootIsCrypt { data2, err = base64.StdEncoding.DecodeString(cryptedText3Base64) require.NoError(t, err) expectedSize++ // FIXME newline gets in, likely test data issue } else { data2 = []byte("test content") } objInfo := object.NewStaticObjectInfo(runInstance.encryptRemoteIfNeeded(t, "data.bin"), time.Now(), int64(len(data2)), true, nil, cfs.UnWrap()) err = o.Update(context.Background(), bytes.NewReader(data2), objInfo) require.NoError(t, err) require.Equal(t, int64(len(data2)), o.Size()) fs.Logf(nil, "updated size: %v", len(data2)) // get a new instance from the cache if runInstance.wrappedIsExternal { err = runInstance.retryBlock(func() error { coSize, err := runInstance.size(t, rootFs, "data.bin") if err != nil { return err } if coSize != expectedSize { return fmt.Errorf("%v <> %v", coSize, expectedSize) } return nil }, 12, time.Second*10) require.NoError(t, err) } else { coSize, err := runInstance.size(t, rootFs, "data.bin") require.NoError(t, err) require.NotEqual(t, coSize, expectedSize) } } func TestInternalMoveWithNotify(t *testing.T) { id := fmt.Sprintf("timwn%v", time.Now().Unix()) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, false, true, nil) if !runInstance.wrappedIsExternal { t.Skipf("Not external") } cfs, err := runInstance.getCacheFs(rootFs) require.NoError(t, err) srcName := runInstance.encryptRemoteIfNeeded(t, "test") + "/" + runInstance.encryptRemoteIfNeeded(t, "one") + "/" + runInstance.encryptRemoteIfNeeded(t, "data.bin") dstName := runInstance.encryptRemoteIfNeeded(t, "test") + "/" + runInstance.encryptRemoteIfNeeded(t, "second") + "/" + runInstance.encryptRemoteIfNeeded(t, "data.bin") // create some rand test data var testData []byte if runInstance.rootIsCrypt { testData, err = base64.StdEncoding.DecodeString(cryptedTextBase64) require.NoError(t, err) } else { testData = []byte("test content") } _ = cfs.UnWrap().Mkdir(context.Background(), runInstance.encryptRemoteIfNeeded(t, "test")) _ = cfs.UnWrap().Mkdir(context.Background(), runInstance.encryptRemoteIfNeeded(t, "test/one")) _ = cfs.UnWrap().Mkdir(context.Background(), runInstance.encryptRemoteIfNeeded(t, "test/second")) srcObj := runInstance.writeObjectBytes(t, cfs.UnWrap(), srcName, testData) // list in mount _, err = runInstance.list(t, rootFs, "test") require.NoError(t, err) _, err = runInstance.list(t, rootFs, "test/one") require.NoError(t, err) // move file _, err = cfs.UnWrap().Features().Move(context.Background(), srcObj, dstName) require.NoError(t, err) err = runInstance.retryBlock(func() error { li, err := runInstance.list(t, rootFs, "test") if err != nil { fs.Logf(nil, "err: %v", err) return err } if len(li) != 2 { fs.Logf(nil, "not expected listing /test: %v", li) return fmt.Errorf("not expected listing /test: %v", li) } li, err = runInstance.list(t, rootFs, "test/one") if err != nil { fs.Logf(nil, "err: %v", err) return err } if len(li) != 0 { fs.Logf(nil, "not expected listing /test/one: %v", li) return fmt.Errorf("not expected listing /test/one: %v", li) } li, err = runInstance.list(t, rootFs, "test/second") if err != nil { fs.Logf(nil, "err: %v", err) return err } if len(li) != 1 { fs.Logf(nil, "not expected listing /test/second: %v", li) return fmt.Errorf("not expected listing /test/second: %v", li) } if fi, ok := li[0].(os.FileInfo); ok { if fi.Name() != "data.bin" { fs.Logf(nil, "not expected name: %v", fi.Name()) return fmt.Errorf("not expected name: %v", fi.Name()) } } else if di, ok := li[0].(fs.DirEntry); ok { if di.Remote() != "test/second/data.bin" { fs.Logf(nil, "not expected remote: %v", di.Remote()) return fmt.Errorf("not expected remote: %v", di.Remote()) } } else { fs.Logf(nil, "unexpected listing: %v", li) return fmt.Errorf("unexpected listing: %v", li) } fs.Logf(nil, "complete listing: %v", li) return nil }, 12, time.Second*10) require.NoError(t, err) } func TestInternalNotifyCreatesEmptyParts(t *testing.T) { id := fmt.Sprintf("tincep%v", time.Now().Unix()) rootFs, boltDb := runInstance.newCacheFs(t, remoteName, id, false, true, nil) if !runInstance.wrappedIsExternal { t.Skipf("Not external") } cfs, err := runInstance.getCacheFs(rootFs) require.NoError(t, err) srcName := runInstance.encryptRemoteIfNeeded(t, "test") + "/" + runInstance.encryptRemoteIfNeeded(t, "one") + "/" + runInstance.encryptRemoteIfNeeded(t, "test") dstName := runInstance.encryptRemoteIfNeeded(t, "test") + "/" + runInstance.encryptRemoteIfNeeded(t, "one") + "/" + runInstance.encryptRemoteIfNeeded(t, "test2") // create some rand test data var testData []byte if runInstance.rootIsCrypt { testData, err = base64.StdEncoding.DecodeString(cryptedTextBase64) require.NoError(t, err) } else { testData = []byte("test content") } err = rootFs.Mkdir(context.Background(), "test") require.NoError(t, err) err = rootFs.Mkdir(context.Background(), "test/one") require.NoError(t, err) srcObj := runInstance.writeObjectBytes(t, cfs.UnWrap(), srcName, testData) // list in mount _, err = runInstance.list(t, rootFs, "test") require.NoError(t, err) _, err = runInstance.list(t, rootFs, "test/one") require.NoError(t, err) found := boltDb.HasEntry(path.Join(cfs.Root(), runInstance.encryptRemoteIfNeeded(t, "test"))) require.True(t, found) boltDb.Purge() found = boltDb.HasEntry(path.Join(cfs.Root(), runInstance.encryptRemoteIfNeeded(t, "test"))) require.False(t, found) // move file _, err = cfs.UnWrap().Features().Move(context.Background(), srcObj, dstName) require.NoError(t, err) err = runInstance.retryBlock(func() error { found = boltDb.HasEntry(path.Join(cfs.Root(), runInstance.encryptRemoteIfNeeded(t, "test"))) if !found { fs.Logf(nil, "not found /test") return fmt.Errorf("not found /test") } found = boltDb.HasEntry(path.Join(cfs.Root(), runInstance.encryptRemoteIfNeeded(t, "test"), runInstance.encryptRemoteIfNeeded(t, "one"))) if !found { fs.Logf(nil, "not found /test/one") return fmt.Errorf("not found /test/one") } found = boltDb.HasEntry(path.Join(cfs.Root(), runInstance.encryptRemoteIfNeeded(t, "test"), runInstance.encryptRemoteIfNeeded(t, "one"), runInstance.encryptRemoteIfNeeded(t, "test2"))) if !found { fs.Logf(nil, "not found /test/one/test2") return fmt.Errorf("not found /test/one/test2") } li, err := runInstance.list(t, rootFs, "test/one") if err != nil { fs.Logf(nil, "err: %v", err) return err } if len(li) != 1 { fs.Logf(nil, "not expected listing /test/one: %v", li) return fmt.Errorf("not expected listing /test/one: %v", li) } if fi, ok := li[0].(os.FileInfo); ok { if fi.Name() != "test2" { fs.Logf(nil, "not expected name: %v", fi.Name()) return fmt.Errorf("not expected name: %v", fi.Name()) } } else if di, ok := li[0].(fs.DirEntry); ok { if di.Remote() != "test/one/test2" { fs.Logf(nil, "not expected remote: %v", di.Remote()) return fmt.Errorf("not expected remote: %v", di.Remote()) } } else { fs.Logf(nil, "unexpected listing: %v", li) return fmt.Errorf("unexpected listing: %v", li) } fs.Logf(nil, "complete listing /test/one/test2") return nil }, 12, time.Second*10) require.NoError(t, err) } func TestInternalChangeSeenAfterDirCacheFlush(t *testing.T) { id := fmt.Sprintf("ticsadcf%v", time.Now().Unix()) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, false, true, nil) cfs, err := runInstance.getCacheFs(rootFs) require.NoError(t, err) chunkSize := cfs.ChunkSize() // create some rand test data testData := randStringBytes(int(chunkSize*4 + chunkSize/2)) runInstance.writeRemoteBytes(t, rootFs, "data.bin", testData) // update in the wrapped fs o, err := cfs.UnWrap().NewObject(context.Background(), runInstance.encryptRemoteIfNeeded(t, "data.bin")) require.NoError(t, err) wrappedTime := time.Now().Add(-1 * time.Hour) err = o.SetModTime(context.Background(), wrappedTime) require.NoError(t, err) // get a new instance from the cache co, err := rootFs.NewObject(context.Background(), "data.bin") require.NoError(t, err) require.NotEqual(t, o.ModTime(context.Background()).String(), co.ModTime(context.Background()).String()) cfs.DirCacheFlush() // flush the cache // get a new instance from the cache co, err = rootFs.NewObject(context.Background(), "data.bin") require.NoError(t, err) require.Equal(t, wrappedTime.Unix(), co.ModTime(context.Background()).Unix()) } func TestInternalCacheWrites(t *testing.T) { id := "ticw" rootFs, boltDb := runInstance.newCacheFs(t, remoteName, id, false, true, map[string]string{"writes": "true"}) cfs, err := runInstance.getCacheFs(rootFs) require.NoError(t, err) chunkSize := cfs.ChunkSize() // create some rand test data earliestTime := time.Now() testData := randStringBytes(int(chunkSize*4 + chunkSize/2)) runInstance.writeRemoteBytes(t, rootFs, "data.bin", testData) expectedTs := time.Now() ts, err := boltDb.GetChunkTs(runInstance.encryptRemoteIfNeeded(t, path.Join(rootFs.Root(), "data.bin")), 0) require.NoError(t, err) require.WithinDuration(t, expectedTs, ts, expectedTs.Sub(earliestTime)) } func TestInternalMaxChunkSizeRespected(t *testing.T) { if runtime.GOOS == "windows" && runtime.GOARCH == "386" { t.Skip("Skip test on windows/386") } id := fmt.Sprintf("timcsr%v", time.Now().Unix()) rootFs, boltDb := runInstance.newCacheFs(t, remoteName, id, false, true, map[string]string{"workers": "1"}) cfs, err := runInstance.getCacheFs(rootFs) require.NoError(t, err) chunkSize := cfs.ChunkSize() totalChunks := 20 // create some rand test data testData := randStringBytes(int(int64(totalChunks-1)*chunkSize + chunkSize/2)) runInstance.writeRemoteBytes(t, rootFs, "data.bin", testData) o, err := cfs.NewObject(context.Background(), runInstance.encryptRemoteIfNeeded(t, "data.bin")) require.NoError(t, err) co, ok := o.(*cache.Object) require.True(t, ok) for i := range 4 { // read first 4 _ = runInstance.readDataFromObj(t, co, chunkSize*int64(i), chunkSize*int64(i+1), false) } cfs.CleanUpCache(true) // the last 2 **must** be in the cache require.True(t, boltDb.HasChunk(co, chunkSize*2)) require.True(t, boltDb.HasChunk(co, chunkSize*3)) for i := 4; i < 6; i++ { // read next 2 _ = runInstance.readDataFromObj(t, co, chunkSize*int64(i), chunkSize*int64(i+1), false) } cfs.CleanUpCache(true) // the last 2 **must** be in the cache require.True(t, boltDb.HasChunk(co, chunkSize*4)) require.True(t, boltDb.HasChunk(co, chunkSize*5)) } func TestInternalExpiredEntriesRemoved(t *testing.T) { id := fmt.Sprintf("tieer%v", time.Now().Unix()) vfscommon.Opt.DirCacheTime = fs.Duration(time.Second * 4) // needs to be lower than the defined rootFs, _ := runInstance.newCacheFs(t, remoteName, id, true, true, nil) cfs, err := runInstance.getCacheFs(rootFs) require.NoError(t, err) // create some rand test data runInstance.writeRemoteString(t, rootFs, "one", "one content") runInstance.mkdir(t, rootFs, "test") runInstance.writeRemoteString(t, rootFs, "test/second", "second content") l, err := runInstance.list(t, rootFs, "test") require.NoError(t, err) require.Len(t, l, 1) err = cfs.UnWrap().Mkdir(context.Background(), runInstance.encryptRemoteIfNeeded(t, "test/third")) require.NoError(t, err) l, err = runInstance.list(t, rootFs, "test") require.NoError(t, err) require.Len(t, l, 1) err = runInstance.retryBlock(func() error { l, err = runInstance.list(t, rootFs, "test") if err != nil { return err } if len(l) != 2 { return errors.New("list is not 2") } return nil }, 10, time.Second) require.NoError(t, err) } func TestInternalBug2117(t *testing.T) { vfscommon.Opt.DirCacheTime = fs.Duration(time.Second * 10) id := fmt.Sprintf("tib2117%v", time.Now().Unix()) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, false, true, map[string]string{"info_age": "72h", "chunk_clean_interval": "15m"}) if runInstance.rootIsCrypt { t.Skipf("skipping crypt") } cfs, err := runInstance.getCacheFs(rootFs) require.NoError(t, err) err = cfs.UnWrap().Mkdir(context.Background(), "test") require.NoError(t, err) for i := 1; i <= 4; i++ { err = cfs.UnWrap().Mkdir(context.Background(), fmt.Sprintf("test/dir%d", i)) require.NoError(t, err) for j := 1; j <= 4; j++ { err = cfs.UnWrap().Mkdir(context.Background(), fmt.Sprintf("test/dir%d/dir%d", i, j)) require.NoError(t, err) runInstance.writeObjectString(t, cfs.UnWrap(), fmt.Sprintf("test/dir%d/dir%d/test.txt", i, j), "test") } } di, err := runInstance.list(t, rootFs, "test/dir1/dir2") require.NoError(t, err) fs.Logf(nil, "len: %v", len(di)) require.Len(t, di, 1) time.Sleep(time.Second * 30) di, err = runInstance.list(t, rootFs, "test/dir1/dir2") require.NoError(t, err) fs.Logf(nil, "len: %v", len(di)) require.Len(t, di, 1) di, err = runInstance.list(t, rootFs, "test/dir1") require.NoError(t, err) fs.Logf(nil, "len: %v", len(di)) require.Len(t, di, 4) di, err = runInstance.list(t, rootFs, "test") require.NoError(t, err) fs.Logf(nil, "len: %v", len(di)) require.Len(t, di, 4) } // run holds the remotes for a test run type run struct { okDiff time.Duration runDefaultCfgMap configmap.Simple tmpUploadDir string rootIsCrypt bool wrappedIsExternal bool tempFiles []*os.File dbPath string chunkPath string vfsCachePath string } func newRun() *run { var err error r := &run{ okDiff: time.Second * 9, // really big diff here but the build machines seem to be slow. need a different way for this } // Read in all the defaults for all the options fsInfo, err := fs.Find("cache") if err != nil { panic(fmt.Sprintf("Couldn't find cache remote: %v", err)) } r.runDefaultCfgMap = configmap.Simple{} for _, option := range fsInfo.Options { r.runDefaultCfgMap.Set(option.Name, fmt.Sprint(option.Default)) } if uploadDir == "" { r.tmpUploadDir, err = os.MkdirTemp("", "rclonecache-tmp") if err != nil { panic(fmt.Sprintf("Failed to create temp dir: %v", err)) } } else { r.tmpUploadDir = uploadDir } fs.Logf(nil, "Temp Upload Dir: %v", r.tmpUploadDir) return r } func (r *run) encryptRemoteIfNeeded(t *testing.T, remote string) string { if !runInstance.rootIsCrypt || len(decryptedToEncryptedRemotes) == 0 { return remote } enc, ok := decryptedToEncryptedRemotes[remote] if !ok { t.Fatalf("Failed to find decrypted -> encrypted mapping for '%v'", remote) return remote } return enc } func (r *run) newCacheFs(t *testing.T, remote, id string, needRemote, purge bool, flags map[string]string) (fs.Fs, *cache.Persistent) { fstest.Initialise() remoteExists := false for _, s := range config.GetRemotes() { if s.Name == remote { remoteExists = true } } if !remoteExists && needRemote { t.Skipf("Need remote (%v) to exist", remote) return nil, nil } // Config to pass to NewFs m := configmap.Simple{} for k, v := range r.runDefaultCfgMap { m.Set(k, v) } for k, v := range flags { m.Set(k, v) } // if the remote doesn't exist, create a new one with a local one for it // identify which is the cache remote (it can be wrapped by a crypt too) rootIsCrypt := false cacheRemote := remote if !remoteExists { localRemote := remote + "-local" config.FileSetValue(localRemote, "type", "local") config.FileSetValue(localRemote, "nounc", "true") m.Set("type", "cache") m.Set("remote", localRemote+":"+filepath.Join(os.TempDir(), localRemote)) } else { remoteType := config.GetValue(remote, "type") if remoteType == "" { t.Skipf("skipped due to invalid remote type for %v", remote) return nil, nil } if remoteType != "cache" { if remoteType == "crypt" { rootIsCrypt = true m.Set("password", cryptPassword1) m.Set("password2", cryptPassword2) } remoteRemote := config.GetValue(remote, "remote") if remoteRemote == "" { t.Skipf("skipped due to invalid remote wrapper for %v", remote) return nil, nil } remoteRemoteParts := strings.Split(remoteRemote, ":") remoteWrapping := remoteRemoteParts[0] remoteType := config.GetValue(remoteWrapping, "type") if remoteType != "cache" { t.Skipf("skipped due to invalid remote type for %v: '%v'", remoteWrapping, remoteType) return nil, nil } cacheRemote = remoteWrapping } } runInstance.rootIsCrypt = rootIsCrypt runInstance.dbPath = filepath.Join(config.GetCacheDir(), "cache-backend", cacheRemote+".db") runInstance.chunkPath = filepath.Join(config.GetCacheDir(), "cache-backend", cacheRemote) runInstance.vfsCachePath = filepath.Join(config.GetCacheDir(), "vfs", remote) boltDb, err := cache.GetPersistent(runInstance.dbPath, runInstance.chunkPath, &cache.Features{PurgeDb: true}) require.NoError(t, err) ci := fs.GetConfig(context.Background()) ci.LowLevelRetries = 1 // Instantiate root if purge { boltDb.PurgeTempUploads() _ = os.RemoveAll(path.Join(runInstance.tmpUploadDir, id)) } f, err := cache.NewFs(context.Background(), remote, id, m) require.NoError(t, err) cfs, err := r.getCacheFs(f) require.NoError(t, err) _, isCache := cfs.Features().UnWrap().(*cache.Fs) _, isCrypt := cfs.Features().UnWrap().(*crypt.Fs) _, isLocal := cfs.Features().UnWrap().(*local.Fs) if isCache || isCrypt || isLocal { r.wrappedIsExternal = false } else { r.wrappedIsExternal = true } if purge { _ = operations.Purge(context.Background(), f, "") } err = f.Mkdir(context.Background(), "") require.NoError(t, err) t.Cleanup(func() { runInstance.cleanupFs(t, f) }) return f, boltDb } func (r *run) cleanupFs(t *testing.T, f fs.Fs) { err := operations.Purge(context.Background(), f, "") require.NoError(t, err) cfs, err := r.getCacheFs(f) require.NoError(t, err) cfs.StopBackgroundRunners() err = os.RemoveAll(r.tmpUploadDir) require.NoError(t, err) for _, f := range r.tempFiles { _ = f.Close() _ = os.Remove(f.Name()) } r.tempFiles = nil debug.FreeOSMemory() } func (r *run) randomReader(t *testing.T, size int64) io.ReadCloser { chunk := int64(1024) cnt := size / chunk left := size % chunk f, err := os.CreateTemp("", "rclonecache-tempfile") require.NoError(t, err) for range int(cnt) { data := randStringBytes(int(chunk)) _, _ = f.Write(data) } data := randStringBytes(int(left)) _, _ = f.Write(data) _, _ = f.Seek(int64(0), io.SeekStart) r.tempFiles = append(r.tempFiles, f) return f } func (r *run) writeRemoteString(t *testing.T, f fs.Fs, remote, content string) { r.writeRemoteBytes(t, f, remote, []byte(content)) } func (r *run) writeObjectString(t *testing.T, f fs.Fs, remote, content string) fs.Object { return r.writeObjectBytes(t, f, remote, []byte(content)) } func (r *run) writeRemoteBytes(t *testing.T, f fs.Fs, remote string, data []byte) { r.writeObjectBytes(t, f, remote, data) } func (r *run) writeRemoteReader(t *testing.T, f fs.Fs, remote string, in io.ReadCloser) { r.writeObjectReader(t, f, remote, in) } func (r *run) writeObjectBytes(t *testing.T, f fs.Fs, remote string, data []byte) fs.Object { in := bytes.NewReader(data) _ = r.writeObjectReader(t, f, remote, in) o, err := f.NewObject(context.Background(), remote) require.NoError(t, err) require.Equal(t, int64(len(data)), o.Size()) return o } func (r *run) writeObjectReader(t *testing.T, f fs.Fs, remote string, in io.Reader) fs.Object { modTime := time.Now() objInfo := object.NewStaticObjectInfo(remote, modTime, -1, true, nil, f) obj, err := f.Put(context.Background(), in, objInfo) require.NoError(t, err) return obj } func (r *run) updateObjectRemote(t *testing.T, f fs.Fs, remote string, data1 []byte, data2 []byte) fs.Object { var err error var obj fs.Object in1 := bytes.NewReader(data1) in2 := bytes.NewReader(data2) objInfo1 := object.NewStaticObjectInfo(remote, time.Now(), int64(len(data1)), true, nil, f) objInfo2 := object.NewStaticObjectInfo(remote, time.Now(), int64(len(data2)), true, nil, f) _, err = f.Put(context.Background(), in1, objInfo1) require.NoError(t, err) obj, err = f.NewObject(context.Background(), remote) require.NoError(t, err) err = obj.Update(context.Background(), in2, objInfo2) require.NoError(t, err) return obj } func (r *run) readDataFromRemote(t *testing.T, f fs.Fs, remote string, offset, end int64, noLengthCheck bool) ([]byte, error) { size := end - offset checkSample := make([]byte, size) co, err := f.NewObject(context.Background(), remote) if err != nil { return checkSample, err } checkSample = r.readDataFromObj(t, co, offset, end, noLengthCheck) if !noLengthCheck && size != int64(len(checkSample)) { return checkSample, fmt.Errorf("read size doesn't match expected: %v <> %v", len(checkSample), size) } return checkSample, nil } func (r *run) readDataFromObj(t *testing.T, o fs.Object, offset, end int64, noLengthCheck bool) []byte { size := end - offset checkSample := make([]byte, size) reader, err := o.Open(context.Background(), &fs.SeekOption{Offset: offset}) require.NoError(t, err) totalRead, err := io.ReadFull(reader, checkSample) if (err == io.EOF || err == io.ErrUnexpectedEOF) && noLengthCheck { err = nil checkSample = checkSample[:totalRead] } require.NoError(t, err, "with string -%v-", string(checkSample)) _ = reader.Close() return checkSample } func (r *run) mkdir(t *testing.T, f fs.Fs, remote string) { err := f.Mkdir(context.Background(), remote) require.NoError(t, err) } func (r *run) rm(t *testing.T, f fs.Fs, remote string) error { var err error var obj fs.Object obj, err = f.NewObject(context.Background(), remote) if err != nil { err = f.Rmdir(context.Background(), remote) } else { err = obj.Remove(context.Background()) } return err } func (r *run) list(t *testing.T, f fs.Fs, remote string) ([]any, error) { var err error var l []any var list fs.DirEntries list, err = f.List(context.Background(), remote) for _, ll := range list { l = append(l, ll) } return l, err } func (r *run) dirMove(t *testing.T, rootFs fs.Fs, src, dst string) error { var err error if rootFs.Features().DirMove != nil { err = rootFs.Features().DirMove(context.Background(), rootFs, src, dst) if err != nil { return err } } else { t.Logf("DirMove not supported by %v", rootFs) return errNotSupported } return err } func (r *run) move(t *testing.T, rootFs fs.Fs, src, dst string) error { var err error if rootFs.Features().Move != nil { obj1, err := rootFs.NewObject(context.Background(), src) if err != nil { return err } _, err = rootFs.Features().Move(context.Background(), obj1, dst) if err != nil { return err } } else { t.Logf("Move not supported by %v", rootFs) return errNotSupported } return err } func (r *run) copy(t *testing.T, rootFs fs.Fs, src, dst string) error { var err error if rootFs.Features().Copy != nil { obj, err := rootFs.NewObject(context.Background(), src) if err != nil { return err } _, err = rootFs.Features().Copy(context.Background(), obj, dst) if err != nil { return err } } else { t.Logf("Copy not supported by %v", rootFs) return errNotSupported } return err } func (r *run) modTime(t *testing.T, rootFs fs.Fs, src string) (time.Time, error) { var err error obj1, err := rootFs.NewObject(context.Background(), src) if err != nil { return time.Time{}, err } return obj1.ModTime(context.Background()), nil } func (r *run) size(t *testing.T, rootFs fs.Fs, src string) (int64, error) { var err error obj1, err := rootFs.NewObject(context.Background(), src) if err != nil { return int64(0), err } return obj1.Size(), nil } func (r *run) updateData(t *testing.T, rootFs fs.Fs, src, data, append string) error { var err error var obj1 fs.Object obj1, err = rootFs.NewObject(context.Background(), src) if err != nil { return err } data1 := []byte(data + append) reader := bytes.NewReader(data1) objInfo1 := object.NewStaticObjectInfo(src, time.Now(), int64(len(data1)), true, nil, rootFs) err = obj1.Update(context.Background(), reader, objInfo1) return err } func (r *run) cleanSize(t *testing.T, size int64) int64 { if r.rootIsCrypt { denominator := int64(65536 + 16) size -= 32 quotient := size / denominator remainder := size % denominator return (quotient*65536 + remainder - 16) } return size } func (r *run) listenForBackgroundUpload(t *testing.T, f fs.Fs, remote string) chan error { cfs, err := r.getCacheFs(f) require.NoError(t, err) buCh := cfs.GetBackgroundUploadChannel() require.NotNil(t, buCh) maxDuration := time.Minute * 3 if r.wrappedIsExternal { maxDuration = time.Minute * 10 } waitCh := make(chan error) go func() { var err error var state cache.BackgroundUploadState for range 2 { select { case state = <-buCh: // continue case <-time.After(maxDuration): waitCh <- fmt.Errorf("Timed out waiting for background upload: %v", remote) return } checkRemote := state.Remote if r.rootIsCrypt { cryptFs := f.(*crypt.Fs) checkRemote, err = cryptFs.DecryptFileName(checkRemote) if err != nil { waitCh <- err return } } if checkRemote == remote && cache.BackgroundUploadStarted != state.Status { waitCh <- state.Error return } } waitCh <- fmt.Errorf("Too many attempts to wait for the background upload: %v", remote) }() return waitCh } func (r *run) completeBackgroundUpload(t *testing.T, remote string, waitCh chan error) { var err error maxDuration := time.Minute * 3 if r.wrappedIsExternal { maxDuration = time.Minute * 10 } select { case err = <-waitCh: // continue case <-time.After(maxDuration): t.Fatalf("Timed out waiting to complete the background upload %v", remote) return } require.NoError(t, err) } func (r *run) completeAllBackgroundUploads(t *testing.T, f fs.Fs, lastRemote string) { var state cache.BackgroundUploadState var err error maxDuration := time.Minute * 5 if r.wrappedIsExternal { maxDuration = time.Minute * 15 } cfs, err := r.getCacheFs(f) require.NoError(t, err) buCh := cfs.GetBackgroundUploadChannel() require.NotNil(t, buCh) for { select { case state = <-buCh: checkRemote := state.Remote if r.rootIsCrypt { cryptFs := f.(*crypt.Fs) checkRemote, err = cryptFs.DecryptFileName(checkRemote) require.NoError(t, err) } if checkRemote == lastRemote && cache.BackgroundUploadCompleted == state.Status { require.NoError(t, state.Error) return } case <-time.After(maxDuration): t.Fatalf("Timed out waiting to complete the background upload %v", lastRemote) return } } } func (r *run) retryBlock(block func() error, maxRetries int, rate time.Duration) error { var err error for range maxRetries { err = block() if err == nil { return nil } time.Sleep(rate) } return err } func (r *run) getCacheFs(f fs.Fs) (*cache.Fs, error) { cfs, ok := f.(*cache.Fs) if ok { return cfs, nil } if f.Features().UnWrap != nil { cfs, ok := f.Features().UnWrap().(*cache.Fs) if ok { return cfs, nil } } return nil, errors.New("didn't found a cache fs") } func randStringBytes(n int) []byte { b := make([]byte, n) for i := range b { b[i] = letterBytes[rand.Intn(len(letterBytes))] } return b } var ( _ fs.Fs = (*cache.Fs)(nil) _ fs.Fs = (*local.Fs)(nil) ) rclone-v1.71.0/backend/cache/cache_test.go000066400000000000000000000016001505210326400203260ustar00rootroot00000000000000// Test Cache filesystem interface //go:build !plan9 && !js && !race package cache_test import ( "testing" "github.com/rclone/rclone/backend/cache" _ "github.com/rclone/rclone/backend/local" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestCache:", NilObject: (*cache.Object)(nil), UnimplementableFsMethods: []string{"PublicLink", "OpenWriterAt", "OpenChunkWriter", "DirSetModTime", "MkdirMetadata", "ListP"}, UnimplementableObjectMethods: []string{"MimeType", "ID", "GetTier", "SetTier", "Metadata", "SetMetadata"}, UnimplementableDirectoryMethods: []string{"Metadata", "SetMetadata", "SetModTime"}, SkipInvalidUTF8: true, // invalid UTF-8 confuses the cache }) } rclone-v1.71.0/backend/cache/cache_unsupported.go000066400000000000000000000003361505210326400217440ustar00rootroot00000000000000// Build for cache for unsupported platforms to stop go complaining // about "no buildable Go source files " //go:build plan9 || js // Package cache implements a virtual provider to cache existing remotes. package cache rclone-v1.71.0/backend/cache/cache_upload_test.go000066400000000000000000000426241505210326400217050ustar00rootroot00000000000000//go:build !plan9 && !js && !race package cache_test import ( "context" "fmt" "math/rand" "os" "path" "strconv" "testing" "time" "github.com/rclone/rclone/backend/cache" _ "github.com/rclone/rclone/backend/drive" "github.com/rclone/rclone/fs" "github.com/stretchr/testify/require" ) func TestInternalUploadTempDirCreated(t *testing.T) { id := fmt.Sprintf("tiutdc%v", time.Now().Unix()) runInstance.newCacheFs(t, remoteName, id, false, true, map[string]string{"tmp_upload_path": path.Join(runInstance.tmpUploadDir, id)}) _, err := os.Stat(path.Join(runInstance.tmpUploadDir, id)) require.NoError(t, err) } func testInternalUploadQueueOneFile(t *testing.T, id string, rootFs fs.Fs, boltDb *cache.Persistent) { // create some rand test data testSize := int64(524288000) testReader := runInstance.randomReader(t, testSize) bu := runInstance.listenForBackgroundUpload(t, rootFs, "one") runInstance.writeRemoteReader(t, rootFs, "one", testReader) // validate that it exists in temp fs ti, err := os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "one"))) require.NoError(t, err) if runInstance.rootIsCrypt { require.Equal(t, int64(524416032), ti.Size()) } else { require.Equal(t, testSize, ti.Size()) } de1, err := runInstance.list(t, rootFs, "") require.NoError(t, err) require.Len(t, de1, 1) runInstance.completeBackgroundUpload(t, "one", bu) // check if it was removed from temp fs _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "one"))) require.True(t, os.IsNotExist(err)) // check if it can be read data2, err := runInstance.readDataFromRemote(t, rootFs, "one", 0, int64(1024), false) require.NoError(t, err) require.Len(t, data2, 1024) } func TestInternalUploadQueueOneFileNoRest(t *testing.T) { id := fmt.Sprintf("tiuqofnr%v", time.Now().Unix()) rootFs, boltDb := runInstance.newCacheFs(t, remoteName, id, true, true, map[string]string{"tmp_upload_path": path.Join(runInstance.tmpUploadDir, id), "tmp_wait_time": "0s"}) testInternalUploadQueueOneFile(t, id, rootFs, boltDb) } func TestInternalUploadQueueOneFileWithRest(t *testing.T) { id := fmt.Sprintf("tiuqofwr%v", time.Now().Unix()) rootFs, boltDb := runInstance.newCacheFs(t, remoteName, id, true, true, map[string]string{"tmp_upload_path": path.Join(runInstance.tmpUploadDir, id), "tmp_wait_time": "1m"}) testInternalUploadQueueOneFile(t, id, rootFs, boltDb) } func TestInternalUploadMoveExistingFile(t *testing.T) { id := fmt.Sprintf("tiumef%v", time.Now().Unix()) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, true, true, map[string]string{"tmp_upload_path": path.Join(runInstance.tmpUploadDir, id), "tmp_wait_time": "3s"}) err := rootFs.Mkdir(context.Background(), "one") require.NoError(t, err) err = rootFs.Mkdir(context.Background(), "one/test") require.NoError(t, err) err = rootFs.Mkdir(context.Background(), "second") require.NoError(t, err) // create some rand test data testSize := int64(10485760) testReader := runInstance.randomReader(t, testSize) runInstance.writeObjectReader(t, rootFs, "one/test/data.bin", testReader) runInstance.completeAllBackgroundUploads(t, rootFs, "one/test/data.bin") de1, err := runInstance.list(t, rootFs, "one/test") require.NoError(t, err) require.Len(t, de1, 1) time.Sleep(time.Second * 5) //_ = os.Remove(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "one/test"))) //require.NoError(t, err) err = runInstance.dirMove(t, rootFs, "one/test", "second/test") require.NoError(t, err) // check if it can be read de1, err = runInstance.list(t, rootFs, "second/test") require.NoError(t, err) require.Len(t, de1, 1) } func TestInternalUploadTempPathCleaned(t *testing.T) { id := fmt.Sprintf("tiutpc%v", time.Now().Unix()) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, true, true, map[string]string{"cache-tmp-upload-path": path.Join(runInstance.tmpUploadDir, id), "cache-tmp-wait-time": "5s"}) err := rootFs.Mkdir(context.Background(), "one") require.NoError(t, err) err = rootFs.Mkdir(context.Background(), "one/test") require.NoError(t, err) err = rootFs.Mkdir(context.Background(), "second") require.NoError(t, err) // create some rand test data testSize := int64(1048576) testReader := runInstance.randomReader(t, testSize) testReader2 := runInstance.randomReader(t, testSize) runInstance.writeObjectReader(t, rootFs, "one/test/data.bin", testReader) runInstance.writeObjectReader(t, rootFs, "second/data.bin", testReader2) runInstance.completeAllBackgroundUploads(t, rootFs, "one/test/data.bin") _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "one/test"))) require.True(t, os.IsNotExist(err)) _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "one"))) require.True(t, os.IsNotExist(err)) _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "second"))) require.False(t, os.IsNotExist(err)) runInstance.completeAllBackgroundUploads(t, rootFs, "second/data.bin") _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "second/data.bin"))) require.True(t, os.IsNotExist(err)) de1, err := runInstance.list(t, rootFs, "one/test") require.NoError(t, err) require.Len(t, de1, 1) // check if it can be read de1, err = runInstance.list(t, rootFs, "second") require.NoError(t, err) require.Len(t, de1, 1) } func TestInternalUploadQueueMoreFiles(t *testing.T) { id := fmt.Sprintf("tiuqmf%v", time.Now().Unix()) rootFs, _ := runInstance.newCacheFs(t, remoteName, id, true, true, map[string]string{"tmp_upload_path": path.Join(runInstance.tmpUploadDir, id), "tmp_wait_time": "1s"}) err := rootFs.Mkdir(context.Background(), "test") require.NoError(t, err) minSize := 5242880 maxSize := 10485760 totalFiles := 10 randInstance := rand.New(rand.NewSource(time.Now().Unix())) lastFile := "" for i := range totalFiles { size := int64(randInstance.Intn(maxSize-minSize) + minSize) testReader := runInstance.randomReader(t, size) remote := "test/" + strconv.Itoa(i) + ".bin" runInstance.writeRemoteReader(t, rootFs, remote, testReader) // validate that it exists in temp fs ti, err := os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, remote))) require.NoError(t, err) require.Equal(t, size, runInstance.cleanSize(t, ti.Size())) if runInstance.wrappedIsExternal && i < totalFiles-1 { time.Sleep(time.Second * 3) } lastFile = remote } // check if cache lists all files, likely temp upload didn't finish yet de1, err := runInstance.list(t, rootFs, "test") require.NoError(t, err) require.Len(t, de1, totalFiles) // wait for background uploader to do its thing runInstance.completeAllBackgroundUploads(t, rootFs, lastFile) // retry until we have no more temp files and fail if they don't go down to 0 _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test"))) require.True(t, os.IsNotExist(err)) // check if cache lists all files de1, err = runInstance.list(t, rootFs, "test") require.NoError(t, err) require.Len(t, de1, totalFiles) } func TestInternalUploadTempFileOperations(t *testing.T) { id := "tiutfo" rootFs, boltDb := runInstance.newCacheFs(t, remoteName, id, true, true, map[string]string{"tmp_upload_path": path.Join(runInstance.tmpUploadDir, id), "tmp_wait_time": "1h"}) boltDb.PurgeTempUploads() // create some rand test data runInstance.mkdir(t, rootFs, "test") runInstance.writeRemoteString(t, rootFs, "test/one", "one content") // check if it can be read data1, err := runInstance.readDataFromRemote(t, rootFs, "test/one", 0, int64(len([]byte("one content"))), false) require.NoError(t, err) require.Equal(t, []byte("one content"), data1) // validate that it exists in temp fs _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) require.NoError(t, err) // test DirMove - allowed err = runInstance.dirMove(t, rootFs, "test", "second") if err != errNotSupported { require.NoError(t, err) _, err = rootFs.NewObject(context.Background(), "test/one") require.Error(t, err) _, err = rootFs.NewObject(context.Background(), "second/one") require.NoError(t, err) // validate that it exists in temp fs _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) require.Error(t, err) _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "second/one"))) require.NoError(t, err) _, err = boltDb.SearchPendingUpload(runInstance.encryptRemoteIfNeeded(t, path.Join(id, "test/one"))) require.Error(t, err) var started bool started, err = boltDb.SearchPendingUpload(runInstance.encryptRemoteIfNeeded(t, path.Join(id, "second/one"))) require.NoError(t, err) require.False(t, started) runInstance.mkdir(t, rootFs, "test") runInstance.writeRemoteString(t, rootFs, "test/one", "one content") } // test Rmdir - allowed err = runInstance.rm(t, rootFs, "test") require.Error(t, err) require.Contains(t, err.Error(), "directory not empty") _, err = rootFs.NewObject(context.Background(), "test/one") require.NoError(t, err) // validate that it exists in temp fs _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) require.NoError(t, err) started, err := boltDb.SearchPendingUpload(runInstance.encryptRemoteIfNeeded(t, path.Join(id, "test/one"))) require.False(t, started) require.NoError(t, err) // test Move/Rename -- allowed err = runInstance.move(t, rootFs, path.Join("test", "one"), path.Join("test", "second")) if err != errNotSupported { require.NoError(t, err) // try to read from it _, err = rootFs.NewObject(context.Background(), "test/one") require.Error(t, err) _, err = rootFs.NewObject(context.Background(), "test/second") require.NoError(t, err) data2, err := runInstance.readDataFromRemote(t, rootFs, "test/second", 0, int64(len([]byte("one content"))), false) require.NoError(t, err) require.Equal(t, []byte("one content"), data2) // validate that it exists in temp fs _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) require.Error(t, err) _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/second"))) require.NoError(t, err) runInstance.writeRemoteString(t, rootFs, "test/one", "one content") } // test Copy -- allowed err = runInstance.copy(t, rootFs, path.Join("test", "one"), path.Join("test", "third")) if err != errNotSupported { require.NoError(t, err) _, err = rootFs.NewObject(context.Background(), "test/one") require.NoError(t, err) _, err = rootFs.NewObject(context.Background(), "test/third") require.NoError(t, err) data2, err := runInstance.readDataFromRemote(t, rootFs, "test/third", 0, int64(len([]byte("one content"))), false) require.NoError(t, err) require.Equal(t, []byte("one content"), data2) // validate that it exists in temp fs _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) require.NoError(t, err) _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/third"))) require.NoError(t, err) } // test Remove -- allowed err = runInstance.rm(t, rootFs, "test/one") require.NoError(t, err) _, err = rootFs.NewObject(context.Background(), "test/one") require.Error(t, err) // validate that it doesn't exist in temp fs _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) require.Error(t, err) runInstance.writeRemoteString(t, rootFs, "test/one", "one content") // test Update -- allowed firstModTime, err := runInstance.modTime(t, rootFs, "test/one") require.NoError(t, err) err = runInstance.updateData(t, rootFs, "test/one", "one content", " updated") require.NoError(t, err) obj2, err := rootFs.NewObject(context.Background(), "test/one") require.NoError(t, err) data2 := runInstance.readDataFromObj(t, obj2, 0, int64(len("one content updated")), false) require.Equal(t, "one content updated", string(data2)) tmpInfo, err := os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) require.NoError(t, err) if runInstance.rootIsCrypt { require.Equal(t, int64(67), tmpInfo.Size()) } else { require.Equal(t, int64(len(data2)), tmpInfo.Size()) } // test SetModTime -- allowed secondModTime, err := runInstance.modTime(t, rootFs, "test/one") require.NoError(t, err) require.NotEqual(t, secondModTime, firstModTime) require.NotEqual(t, time.Time{}, firstModTime) require.NotEqual(t, time.Time{}, secondModTime) } func TestInternalUploadUploadingFileOperations(t *testing.T) { id := "tiuufo" rootFs, boltDb := runInstance.newCacheFs(t, remoteName, id, true, true, map[string]string{"tmp_upload_path": path.Join(runInstance.tmpUploadDir, id), "tmp_wait_time": "1h"}) boltDb.PurgeTempUploads() // create some rand test data runInstance.mkdir(t, rootFs, "test") runInstance.writeRemoteString(t, rootFs, "test/one", "one content") // check if it can be read data1, err := runInstance.readDataFromRemote(t, rootFs, "test/one", 0, int64(len([]byte("one content"))), false) require.NoError(t, err) require.Equal(t, []byte("one content"), data1) // validate that it exists in temp fs _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) require.NoError(t, err) err = boltDb.SetPendingUploadToStarted(runInstance.encryptRemoteIfNeeded(t, path.Join(rootFs.Root(), "test/one"))) require.NoError(t, err) // test DirMove err = runInstance.dirMove(t, rootFs, "test", "second") if err != errNotSupported { require.Error(t, err) _, err = rootFs.NewObject(context.Background(), "test/one") require.NoError(t, err) // validate that it exists in temp fs _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) require.NoError(t, err) _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "second/one"))) require.Error(t, err) } // test Rmdir err = runInstance.rm(t, rootFs, "test") require.Error(t, err) _, err = rootFs.NewObject(context.Background(), "test/one") require.NoError(t, err) // validate that it doesn't exist in temp fs _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) require.NoError(t, err) // test Move/Rename err = runInstance.move(t, rootFs, path.Join("test", "one"), path.Join("test", "second")) if err != errNotSupported { require.Error(t, err) // try to read from it _, err = rootFs.NewObject(context.Background(), "test/one") require.NoError(t, err) _, err = rootFs.NewObject(context.Background(), "test/second") require.Error(t, err) // validate that it exists in temp fs _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) require.NoError(t, err) _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/second"))) require.Error(t, err) } // test Copy -- allowed err = runInstance.copy(t, rootFs, path.Join("test", "one"), path.Join("test", "third")) if err != errNotSupported { require.NoError(t, err) _, err = rootFs.NewObject(context.Background(), "test/one") require.NoError(t, err) _, err = rootFs.NewObject(context.Background(), "test/third") require.NoError(t, err) data2, err := runInstance.readDataFromRemote(t, rootFs, "test/third", 0, int64(len([]byte("one content"))), false) require.NoError(t, err) require.Equal(t, []byte("one content"), data2) // validate that it exists in temp fs _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) require.NoError(t, err) _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/third"))) require.NoError(t, err) } // test Remove err = runInstance.rm(t, rootFs, "test/one") require.Error(t, err) _, err = rootFs.NewObject(context.Background(), "test/one") require.NoError(t, err) // validate that it doesn't exist in temp fs _, err = os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) require.NoError(t, err) runInstance.writeRemoteString(t, rootFs, "test/one", "one content") // test Update - this seems to work. Why? FIXME //firstModTime, err := runInstance.modTime(t, rootFs, "test/one") //require.NoError(t, err) //err = runInstance.updateData(t, rootFs, "test/one", "one content", " updated", func() { // data2 := runInstance.readDataFromRemote(t, rootFs, "test/one", 0, int64(len("one content updated")), true) // require.Equal(t, "one content", string(data2)) // // tmpInfo, err := os.Stat(path.Join(runInstance.tmpUploadDir, id, runInstance.encryptRemoteIfNeeded(t, "test/one"))) // require.NoError(t, err) // if runInstance.rootIsCrypt { // require.Equal(t, int64(67), tmpInfo.Size()) // } else { // require.Equal(t, int64(len(data2)), tmpInfo.Size()) // } //}) //require.Error(t, err) // test SetModTime -- seems to work cause of previous //secondModTime, err := runInstance.modTime(t, rootFs, "test/one") //require.NoError(t, err) //require.Equal(t, secondModTime, firstModTime) //require.NotEqual(t, time.Time{}, firstModTime) //require.NotEqual(t, time.Time{}, secondModTime) } rclone-v1.71.0/backend/cache/directory.go000066400000000000000000000060531505210326400202370ustar00rootroot00000000000000//go:build !plan9 && !js package cache import ( "context" "path" "time" "github.com/rclone/rclone/fs" ) // Directory is a generic dir that stores basic information about it type Directory struct { Directory fs.Directory `json:"-"` // can be nil CacheFs *Fs `json:"-"` // cache fs Name string `json:"name"` // name of the directory Dir string `json:"dir"` // abs path of the directory CacheModTime int64 `json:"modTime"` // modification or creation time - IsZero for unknown CacheSize int64 `json:"size"` // size of directory and contents or -1 if unknown CacheItems int64 `json:"items"` // number of objects or -1 for unknown CacheType string `json:"cacheType"` // object type CacheTs *time.Time `json:",omitempty"` } // NewDirectory builds an empty dir which will be used to unmarshal data in it func NewDirectory(f *Fs, remote string) *Directory { cd := ShallowDirectory(f, remote) t := time.Now() cd.CacheTs = &t return cd } // ShallowDirectory builds an empty dir which will be used to unmarshal data in it func ShallowDirectory(f *Fs, remote string) *Directory { var cd *Directory fullRemote := cleanPath(path.Join(f.Root(), remote)) // build a new one dir := cleanPath(path.Dir(fullRemote)) name := cleanPath(path.Base(fullRemote)) cd = &Directory{ CacheFs: f, Name: name, Dir: dir, CacheModTime: time.Now().UnixNano(), CacheSize: 0, CacheItems: 0, CacheType: "Directory", } return cd } // DirectoryFromOriginal builds one from a generic fs.Directory func DirectoryFromOriginal(ctx context.Context, f *Fs, d fs.Directory) *Directory { var cd *Directory fullRemote := path.Join(f.Root(), d.Remote()) dir := cleanPath(path.Dir(fullRemote)) name := cleanPath(path.Base(fullRemote)) t := time.Now() cd = &Directory{ Directory: d, CacheFs: f, Name: name, Dir: dir, CacheModTime: d.ModTime(ctx).UnixNano(), CacheSize: d.Size(), CacheItems: d.Items(), CacheType: "Directory", CacheTs: &t, } return cd } // Fs returns its FS info func (d *Directory) Fs() fs.Info { return d.CacheFs } // String returns a human friendly name for this object func (d *Directory) String() string { if d == nil { return "" } return d.Remote() } // Remote returns the remote path func (d *Directory) Remote() string { return d.CacheFs.cleanRootFromPath(d.abs()) } // abs returns the absolute path to the dir func (d *Directory) abs() string { return cleanPath(path.Join(d.Dir, d.Name)) } // ModTime returns the cached ModTime func (d *Directory) ModTime(ctx context.Context) time.Time { return time.Unix(0, d.CacheModTime) } // Size returns the cached Size func (d *Directory) Size() int64 { return d.CacheSize } // Items returns the cached Items func (d *Directory) Items() int64 { return d.CacheItems } // ID returns the ID of the cached directory if known func (d *Directory) ID() string { if d.Directory == nil { return "" } return d.Directory.ID() } var ( _ fs.Directory = (*Directory)(nil) ) rclone-v1.71.0/backend/cache/handle.go000066400000000000000000000375351505210326400174770ustar00rootroot00000000000000//go:build !plan9 && !js package cache import ( "context" "errors" "fmt" "io" "path" "runtime" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/operations" ) var uploaderMap = make(map[string]*backgroundWriter) var uploaderMapMx sync.Mutex // initBackgroundUploader returns a single instance func initBackgroundUploader(fs *Fs) (*backgroundWriter, error) { // write lock to create one uploaderMapMx.Lock() defer uploaderMapMx.Unlock() if b, ok := uploaderMap[fs.String()]; ok { // if it was already started we close it so that it can be started again if b.running { b.close() } else { return b, nil } } bb := newBackgroundWriter(fs) uploaderMap[fs.String()] = bb return uploaderMap[fs.String()], nil } // Handle is managing the read/write/seek operations on an open handle type Handle struct { ctx context.Context cachedObject *Object cfs *Fs memory *Memory preloadQueue chan int64 preloadOffset int64 offset int64 seenOffsets map[int64]bool mu sync.Mutex workersWg sync.WaitGroup confirmReading chan bool workers int maxWorkerID int UseMemory bool closed bool reading bool } // NewObjectHandle returns a new Handle for an existing Object func NewObjectHandle(ctx context.Context, o *Object, cfs *Fs) *Handle { r := &Handle{ ctx: ctx, cachedObject: o, cfs: cfs, offset: 0, preloadOffset: -1, // -1 to trigger the first preload UseMemory: !cfs.opt.ChunkNoMemory, reading: false, } r.seenOffsets = make(map[int64]bool) r.memory = NewMemory(-1) // create a larger buffer to queue up requests r.preloadQueue = make(chan int64, r.cfs.opt.TotalWorkers*10) r.confirmReading = make(chan bool) r.startReadWorkers() return r } // cacheFs is a convenience method to get the parent cache FS of the object's manager func (r *Handle) cacheFs() *Fs { return r.cfs } // storage is a convenience method to get the persistent storage of the object's manager func (r *Handle) storage() *Persistent { return r.cacheFs().cache } // String representation of this reader func (r *Handle) String() string { return r.cachedObject.abs() } // startReadWorkers will start the worker pool func (r *Handle) startReadWorkers() { if r.workers > 0 { return } totalWorkers := r.cacheFs().opt.TotalWorkers if r.cacheFs().plexConnector.isConfigured() { if !r.cacheFs().plexConnector.isConnected() { err := r.cacheFs().plexConnector.authenticate() if err != nil { fs.Errorf(r, "failed to authenticate to Plex: %v", err) } } if r.cacheFs().plexConnector.isConnected() { totalWorkers = 1 } } r.scaleWorkers(totalWorkers) } // scaleWorkers will increase the worker pool count by the provided amount func (r *Handle) scaleWorkers(desired int) { current := r.workers if current == desired { return } if current > desired { // scale in gracefully for r.workers > desired { r.preloadQueue <- -1 r.workers-- } } else { // scale out for r.workers < desired { w := &worker{ r: r, id: r.maxWorkerID, } r.workersWg.Add(1) r.workers++ r.maxWorkerID++ go w.run() } } // ignore first scale out from 0 if current != 0 { fs.Debugf(r, "scale workers to %v", desired) } } func (r *Handle) confirmExternalReading() { // if we have a max value of workers // then we skip this step if r.workers > 1 || !r.cacheFs().plexConnector.isConfigured() { return } if !r.cacheFs().plexConnector.isPlaying(r.cachedObject) { return } fs.Infof(r, "confirmed reading by external reader") r.scaleWorkers(r.cacheFs().opt.TotalWorkers) } // queueOffset will send an offset to the workers if it's different from the last one func (r *Handle) queueOffset(offset int64) { if offset != r.preloadOffset { // clean past in-memory chunks if r.UseMemory { go r.memory.CleanChunksByNeed(offset) } r.confirmExternalReading() r.preloadOffset = offset // clear the past seen chunks // they will remain in our persistent storage but will be removed from transient // so they need to be picked up by a worker for k := range r.seenOffsets { if k < offset { r.seenOffsets[k] = false } } for i := range r.workers { o := r.preloadOffset + int64(r.cacheFs().opt.ChunkSize)*int64(i) if o < 0 || o >= r.cachedObject.Size() { continue } if v, ok := r.seenOffsets[o]; ok && v { continue } r.seenOffsets[o] = true r.preloadQueue <- o } } } // getChunk is called by the FS to retrieve a specific chunk of known start and size from where it can find it // it can be from transient or persistent cache // it will also build the chunk from the cache's specific chunk boundaries and build the final desired chunk in a buffer func (r *Handle) getChunk(chunkStart int64) ([]byte, error) { var data []byte var err error // we calculate the modulus of the requested offset with the size of a chunk offset := chunkStart % int64(r.cacheFs().opt.ChunkSize) // we align the start offset of the first chunk to a likely chunk in the storage chunkStart -= offset r.queueOffset(chunkStart) found := false if r.UseMemory { data, err = r.memory.GetChunk(r.cachedObject, chunkStart) if err == nil { found = true } } if !found { // we're gonna give the workers a chance to pickup the chunk // and retry a couple of times for i := range r.cacheFs().opt.ReadRetries * 8 { data, err = r.storage().GetChunk(r.cachedObject, chunkStart) if err == nil { found = true break } fs.Debugf(r, "%v: chunk retry storage: %v", chunkStart, i) time.Sleep(time.Millisecond * 500) } } // not found in ram or // the worker didn't managed to download the chunk in time so we abort and close the stream if err != nil || len(data) == 0 || !found { if r.workers == 0 { fs.Errorf(r, "out of workers") return nil, io.ErrUnexpectedEOF } return nil, fmt.Errorf("chunk not found %v", chunkStart) } // first chunk will be aligned with the start if offset > 0 { if offset > int64(len(data)) { fs.Errorf(r, "unexpected conditions during reading. current position: %v, current chunk position: %v, current chunk size: %v, offset: %v, chunk size: %v, file size: %v", r.offset, chunkStart, len(data), offset, r.cacheFs().opt.ChunkSize, r.cachedObject.Size()) return nil, io.ErrUnexpectedEOF } data = data[int(offset):] } return data, nil } // Read a chunk from storage or len(p) func (r *Handle) Read(p []byte) (n int, err error) { r.mu.Lock() defer r.mu.Unlock() var buf []byte // first reading if !r.reading { r.reading = true } // reached EOF if r.offset >= r.cachedObject.Size() { return 0, io.EOF } currentOffset := r.offset buf, err = r.getChunk(currentOffset) if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF { fs.Errorf(r, "(%v/%v) error (%v) response", currentOffset, r.cachedObject.Size(), err) } if len(buf) == 0 && err != io.ErrUnexpectedEOF { return 0, io.EOF } readSize := copy(p, buf) newOffset := currentOffset + int64(readSize) r.offset = newOffset return readSize, err } // Close will tell the workers to stop func (r *Handle) Close() error { r.mu.Lock() defer r.mu.Unlock() if r.closed { return errors.New("file already closed") } close(r.preloadQueue) r.closed = true // wait for workers to complete their jobs before returning r.workersWg.Wait() r.memory.db.Flush() fs.Debugf(r, "cache reader closed %v", r.offset) return nil } // Seek will move the current offset based on whence and instruct the workers to move there too func (r *Handle) Seek(offset int64, whence int) (int64, error) { r.mu.Lock() defer r.mu.Unlock() var err error switch whence { case io.SeekStart: fs.Debugf(r, "moving offset set from %v to %v", r.offset, offset) r.offset = offset case io.SeekCurrent: fs.Debugf(r, "moving offset cur from %v to %v", r.offset, r.offset+offset) r.offset += offset case io.SeekEnd: fs.Debugf(r, "moving offset end (%v) from %v to %v", r.cachedObject.Size(), r.offset, r.cachedObject.Size()+offset) r.offset = r.cachedObject.Size() + offset default: err = fmt.Errorf("cache: unimplemented seek whence %v", whence) } chunkStart := r.offset - (r.offset % int64(r.cacheFs().opt.ChunkSize)) if chunkStart >= int64(r.cacheFs().opt.ChunkSize) { chunkStart -= int64(r.cacheFs().opt.ChunkSize) } r.queueOffset(chunkStart) return r.offset, err } type worker struct { r *Handle rc io.ReadCloser id int } // String is a representation of this worker func (w *worker) String() string { return fmt.Sprintf("worker-%v <%v>", w.id, w.r.cachedObject.Name) } // reader will return a reader depending on the capabilities of the source reader: // - if it supports seeking it will seek to the desired offset and return the same reader // - if it doesn't support seeking it will close a possible existing one and open at the desired offset // - if there's no reader associated with this worker, it will create one func (w *worker) reader(offset, end int64, closeOpen bool) (io.ReadCloser, error) { var err error r := w.rc if w.rc == nil { r, err = w.r.cacheFs().openRateLimited(func() (io.ReadCloser, error) { return w.r.cachedObject.Object.Open(w.r.ctx, &fs.RangeOption{Start: offset, End: end - 1}) }) if err != nil { return nil, err } return r, nil } if !closeOpen { if do, ok := r.(fs.RangeSeeker); ok { _, err = do.RangeSeek(w.r.ctx, offset, io.SeekStart, end-offset) return r, err } else if do, ok := r.(io.Seeker); ok { _, err = do.Seek(offset, io.SeekStart) return r, err } } _ = w.rc.Close() return w.r.cacheFs().openRateLimited(func() (io.ReadCloser, error) { r, err = w.r.cachedObject.Object.Open(w.r.ctx, &fs.RangeOption{Start: offset, End: end - 1}) if err != nil { return nil, err } return r, nil }) } // run is the main loop for the worker which receives offsets to preload func (w *worker) run() { var err error var data []byte defer func() { if w.rc != nil { _ = w.rc.Close() } w.r.workersWg.Done() }() for { chunkStart, open := <-w.r.preloadQueue if chunkStart < 0 || !open { break } // skip if it exists if w.r.UseMemory { if w.r.memory.HasChunk(w.r.cachedObject, chunkStart) { continue } // add it in ram if it's in the persistent storage data, err = w.r.storage().GetChunk(w.r.cachedObject, chunkStart) if err == nil { err = w.r.memory.AddChunk(w.r.cachedObject.abs(), data, chunkStart) if err != nil { fs.Errorf(w, "failed caching chunk in ram %v: %v", chunkStart, err) } else { continue } } } else if w.r.storage().HasChunk(w.r.cachedObject, chunkStart) { continue } chunkEnd := chunkStart + int64(w.r.cacheFs().opt.ChunkSize) // TODO: Remove this comment if it proves to be reliable for #1896 //if chunkEnd > w.r.cachedObject.Size() { // chunkEnd = w.r.cachedObject.Size() //} w.download(chunkStart, chunkEnd, 0) } } func (w *worker) download(chunkStart, chunkEnd int64, retry int) { var err error var data []byte // stop retries if retry >= w.r.cacheFs().opt.ReadRetries { return } // back-off between retries if retry > 0 { time.Sleep(time.Second * time.Duration(retry)) } closeOpen := false if retry > 0 { closeOpen = true } w.rc, err = w.reader(chunkStart, chunkEnd, closeOpen) // we seem to be getting only errors so we abort if err != nil { fs.Errorf(w, "object open failed %v: %v", chunkStart, err) err = w.r.cachedObject.refreshFromSource(w.r.ctx, true) if err != nil { fs.Errorf(w, "%v", err) } w.download(chunkStart, chunkEnd, retry+1) return } data = make([]byte, chunkEnd-chunkStart) var sourceRead int sourceRead, err = io.ReadFull(w.rc, data) if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF { fs.Errorf(w, "failed to read chunk %v: %v", chunkStart, err) err = w.r.cachedObject.refreshFromSource(w.r.ctx, true) if err != nil { fs.Errorf(w, "%v", err) } w.download(chunkStart, chunkEnd, retry+1) return } data = data[:sourceRead] // reslice to remove extra garbage if err == io.ErrUnexpectedEOF { fs.Debugf(w, "partial downloaded chunk %v", fs.SizeSuffix(chunkStart)) } else { fs.Debugf(w, "downloaded chunk %v", chunkStart) } if w.r.UseMemory { err = w.r.memory.AddChunk(w.r.cachedObject.abs(), data, chunkStart) if err != nil { fs.Errorf(w, "failed caching chunk in ram %v: %v", chunkStart, err) } } err = w.r.storage().AddChunk(w.r.cachedObject.abs(), data, chunkStart) if err != nil { fs.Errorf(w, "failed caching chunk in storage %v: %v", chunkStart, err) } } const ( // BackgroundUploadStarted is a state for a temp file that has started upload BackgroundUploadStarted = iota // BackgroundUploadCompleted is a state for a temp file that has completed upload BackgroundUploadCompleted // BackgroundUploadError is a state for a temp file that has an error upload BackgroundUploadError ) // BackgroundUploadState is an entity that maps to an existing file which is stored on the temp fs type BackgroundUploadState struct { Remote string Status int Error error } type backgroundWriter struct { fs *Fs stateCh chan int running bool notifyCh chan BackgroundUploadState mu sync.Mutex } func newBackgroundWriter(f *Fs) *backgroundWriter { b := &backgroundWriter{ fs: f, stateCh: make(chan int), notifyCh: make(chan BackgroundUploadState), } return b } func (b *backgroundWriter) close() { b.stateCh <- 2 b.mu.Lock() defer b.mu.Unlock() b.running = false } func (b *backgroundWriter) pause() { b.stateCh <- 1 } func (b *backgroundWriter) play() { b.stateCh <- 0 } func (b *backgroundWriter) isRunning() bool { b.mu.Lock() defer b.mu.Unlock() return b.running } func (b *backgroundWriter) notify(remote string, status int, err error) { state := BackgroundUploadState{ Remote: remote, Status: status, Error: err, } select { case b.notifyCh <- state: fs.Debugf(remote, "notified background upload state: %v", state.Status) default: } } func (b *backgroundWriter) run() { state := 0 for { b.mu.Lock() b.running = true b.mu.Unlock() select { case s := <-b.stateCh: state = s default: // } switch state { case 1: runtime.Gosched() time.Sleep(time.Millisecond * 500) continue case 2: return } absPath, err := b.fs.cache.getPendingUpload(b.fs.Root(), time.Duration(b.fs.opt.TempWaitTime)) if err != nil || absPath == "" || !b.fs.isRootInPath(absPath) { time.Sleep(time.Second) continue } remote := b.fs.cleanRootFromPath(absPath) b.notify(remote, BackgroundUploadStarted, nil) fs.Infof(remote, "background upload: started upload") err = operations.MoveFile(context.TODO(), b.fs.UnWrap(), b.fs.tempFs, remote, remote) if err != nil { b.notify(remote, BackgroundUploadError, err) _ = b.fs.cache.rollbackPendingUpload(absPath) fs.Errorf(remote, "background upload: %v", err) continue } // clean empty dirs up to root thisDir := cleanPath(path.Dir(remote)) for thisDir != "" { thisList, err := b.fs.tempFs.List(context.TODO(), thisDir) if err != nil { break } if len(thisList) > 0 { break } err = b.fs.tempFs.Rmdir(context.TODO(), thisDir) fs.Debugf(thisDir, "cleaned from temp path") if err != nil { break } thisDir = cleanPath(path.Dir(thisDir)) } fs.Infof(remote, "background upload: uploaded entry") err = b.fs.cache.removePendingUpload(absPath) if err != nil && !strings.Contains(err.Error(), "pending upload not found") { fs.Errorf(remote, "background upload: %v", err) } parentCd := NewDirectory(b.fs, cleanPath(path.Dir(remote))) err = b.fs.cache.ExpireDir(parentCd) if err != nil { fs.Errorf(parentCd, "background upload: cache expire error: %v", err) } b.fs.notifyChangeUpstream(remote, fs.EntryObject) fs.Infof(remote, "finished background upload") b.notify(remote, BackgroundUploadCompleted, nil) } } // Check the interfaces are satisfied var ( _ io.ReadCloser = (*Handle)(nil) _ io.Seeker = (*Handle)(nil) ) rclone-v1.71.0/backend/cache/object.go000066400000000000000000000234321505210326400175010ustar00rootroot00000000000000//go:build !plan9 && !js package cache import ( "context" "fmt" "io" "path" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/readers" ) const ( objectInCache = "Object" objectPendingUpload = "TempObject" ) // Object is a generic file like object that stores basic information about it type Object struct { fs.Object `json:"-"` ParentFs fs.Fs `json:"-"` // parent fs CacheFs *Fs `json:"-"` // cache fs Name string `json:"name"` // name of the directory Dir string `json:"dir"` // abs path of the object CacheModTime int64 `json:"modTime"` // modification or creation time - IsZero for unknown CacheSize int64 `json:"size"` // size of directory and contents or -1 if unknown CacheStorable bool `json:"storable"` // says whether this object can be stored CacheType string `json:"cacheType"` CacheTs time.Time `json:"cacheTs"` cacheHashesMu sync.Mutex CacheHashes map[hash.Type]string // all supported hashes cached refreshMutex sync.Mutex } // NewObject builds one from a generic fs.Object func NewObject(f *Fs, remote string) *Object { fullRemote := path.Join(f.Root(), remote) dir, name := path.Split(fullRemote) cacheType := objectInCache parentFs := f.UnWrap() if f.opt.TempWritePath != "" { _, err := f.cache.SearchPendingUpload(fullRemote) if err == nil { // queued for upload cacheType = objectPendingUpload parentFs = f.tempFs fs.Debugf(fullRemote, "pending upload found") } } co := &Object{ ParentFs: parentFs, CacheFs: f, Name: cleanPath(name), Dir: cleanPath(dir), CacheModTime: time.Now().UnixNano(), CacheSize: 0, CacheStorable: false, CacheType: cacheType, CacheTs: time.Now(), } return co } // ObjectFromOriginal builds one from a generic fs.Object func ObjectFromOriginal(ctx context.Context, f *Fs, o fs.Object) *Object { var co *Object fullRemote := cleanPath(path.Join(f.Root(), o.Remote())) dir, name := path.Split(fullRemote) cacheType := objectInCache parentFs := f.UnWrap() if f.opt.TempWritePath != "" { _, err := f.cache.SearchPendingUpload(fullRemote) if err == nil { // queued for upload cacheType = objectPendingUpload parentFs = f.tempFs fs.Debugf(fullRemote, "pending upload found") } } co = &Object{ ParentFs: parentFs, CacheFs: f, Name: cleanPath(name), Dir: cleanPath(dir), CacheType: cacheType, CacheTs: time.Now(), } co.updateData(ctx, o) return co } func (o *Object) updateData(ctx context.Context, source fs.Object) { o.Object = source o.CacheModTime = source.ModTime(ctx).UnixNano() o.CacheSize = source.Size() o.CacheStorable = source.Storable() o.CacheTs = time.Now() o.cacheHashesMu.Lock() o.CacheHashes = make(map[hash.Type]string) o.cacheHashesMu.Unlock() } // Fs returns its FS info func (o *Object) Fs() fs.Info { return o.CacheFs } // String returns a human friendly name for this object func (o *Object) String() string { if o == nil { return "" } return o.Remote() } // Remote returns the remote path func (o *Object) Remote() string { p := path.Join(o.Dir, o.Name) return o.CacheFs.cleanRootFromPath(p) } // abs returns the absolute path to the object func (o *Object) abs() string { return path.Join(o.Dir, o.Name) } // ModTime returns the cached ModTime func (o *Object) ModTime(ctx context.Context) time.Time { _ = o.refresh(ctx) return time.Unix(0, o.CacheModTime) } // Size returns the cached Size func (o *Object) Size() int64 { _ = o.refresh(context.TODO()) return o.CacheSize } // Storable returns the cached Storable func (o *Object) Storable() bool { _ = o.refresh(context.TODO()) return o.CacheStorable } // refresh will check if the object info is expired and request the info from source if it is // all these conditions must be true to ignore a refresh // 1. cache ts didn't expire yet // 2. is not pending a notification from the wrapped fs func (o *Object) refresh(ctx context.Context) error { isNotified := o.CacheFs.isNotifiedRemote(o.Remote()) isExpired := time.Now().After(o.CacheTs.Add(time.Duration(o.CacheFs.opt.InfoAge))) if !isExpired && !isNotified { return nil } return o.refreshFromSource(ctx, true) } // refreshFromSource requests the original FS for the object in case it comes from a cached entry func (o *Object) refreshFromSource(ctx context.Context, force bool) error { o.refreshMutex.Lock() defer o.refreshMutex.Unlock() var err error var liveObject fs.Object if o.Object != nil && !force { return nil } if o.isTempFile() { liveObject, err = o.ParentFs.NewObject(ctx, o.Remote()) if err != nil { err = fmt.Errorf("in parent fs %v: %w", o.ParentFs, err) } } else { liveObject, err = o.CacheFs.Fs.NewObject(ctx, o.Remote()) if err != nil { err = fmt.Errorf("in cache fs %v: %w", o.CacheFs.Fs, err) } } if err != nil { fs.Errorf(o, "error refreshing object in : %v", err) return err } o.updateData(ctx, liveObject) o.persist() return nil } // SetModTime sets the ModTime of this object func (o *Object) SetModTime(ctx context.Context, t time.Time) error { if err := o.refreshFromSource(ctx, false); err != nil { return err } err := o.Object.SetModTime(ctx, t) if err != nil { return err } o.CacheModTime = t.UnixNano() o.persist() fs.Debugf(o, "updated ModTime: %v", t) return nil } // Open is used to request a specific part of the file using fs.RangeOption func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { var err error if o.Object == nil { err = o.refreshFromSource(ctx, true) } else { err = o.refresh(ctx) } if err != nil { return nil, err } cacheReader := NewObjectHandle(ctx, o, o.CacheFs) var offset, limit int64 = 0, -1 for _, option := range options { switch x := option.(type) { case *fs.SeekOption: offset = x.Offset case *fs.RangeOption: offset, limit = x.Decode(o.Size()) } _, err = cacheReader.Seek(offset, io.SeekStart) if err != nil { return nil, err } } return readers.NewLimitedReadCloser(cacheReader, limit), nil } // Update will change the object data func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { if err := o.refreshFromSource(ctx, false); err != nil { return err } // pause background uploads if active if o.CacheFs.opt.TempWritePath != "" { o.CacheFs.backgroundRunner.pause() defer o.CacheFs.backgroundRunner.play() // don't allow started uploads if o.isTempFile() && o.tempFileStartedUpload() { return fmt.Errorf("%v is currently uploading, can't update", o) } } fs.Debugf(o, "updating object contents with size %v", src.Size()) // FIXME use reliable upload err := o.Object.Update(ctx, in, src, options...) if err != nil { fs.Errorf(o, "error updating source: %v", err) return err } // deleting cached chunks and info to be replaced with new ones _ = o.CacheFs.cache.RemoveObject(o.abs()) // advertise to ChangeNotify if wrapped doesn't do that o.CacheFs.notifyChangeUpstreamIfNeeded(o.Remote(), fs.EntryObject) o.CacheModTime = src.ModTime(ctx).UnixNano() o.CacheSize = src.Size() o.cacheHashesMu.Lock() o.CacheHashes = make(map[hash.Type]string) o.cacheHashesMu.Unlock() o.CacheTs = time.Now() o.persist() return nil } // Remove deletes the object from both the cache and the source func (o *Object) Remove(ctx context.Context) error { if err := o.refreshFromSource(ctx, false); err != nil { return err } // pause background uploads if active if o.CacheFs.opt.TempWritePath != "" { o.CacheFs.backgroundRunner.pause() defer o.CacheFs.backgroundRunner.play() // don't allow started uploads if o.isTempFile() && o.tempFileStartedUpload() { return fmt.Errorf("%v is currently uploading, can't delete", o) } } err := o.Object.Remove(ctx) if err != nil { return err } fs.Debugf(o, "removing object") _ = o.CacheFs.cache.RemoveObject(o.abs()) _ = o.CacheFs.cache.removePendingUpload(o.abs()) parentCd := NewDirectory(o.CacheFs, cleanPath(path.Dir(o.Remote()))) _ = o.CacheFs.cache.ExpireDir(parentCd) // advertise to ChangeNotify if wrapped doesn't do that o.CacheFs.notifyChangeUpstreamIfNeeded(parentCd.Remote(), fs.EntryDirectory) return nil } // Hash requests a hash of the object and stores in the cache // since it might or might not be called, this is lazy loaded func (o *Object) Hash(ctx context.Context, ht hash.Type) (string, error) { _ = o.refresh(ctx) o.cacheHashesMu.Lock() if o.CacheHashes == nil { o.CacheHashes = make(map[hash.Type]string) } cachedHash, found := o.CacheHashes[ht] o.cacheHashesMu.Unlock() if found { return cachedHash, nil } if err := o.refreshFromSource(ctx, false); err != nil { return "", err } liveHash, err := o.Object.Hash(ctx, ht) if err != nil { return "", err } o.cacheHashesMu.Lock() o.CacheHashes[ht] = liveHash o.cacheHashesMu.Unlock() o.persist() fs.Debugf(o, "object hash cached: %v", liveHash) return liveHash, nil } // persist adds this object to the persistent cache func (o *Object) persist() *Object { err := o.CacheFs.cache.AddObject(o) if err != nil { fs.Errorf(o, "failed to cache object: %v", err) } return o } func (o *Object) isTempFile() bool { _, err := o.CacheFs.cache.SearchPendingUpload(o.abs()) if err != nil { o.CacheType = objectInCache return false } o.CacheType = objectPendingUpload return true } func (o *Object) tempFileStartedUpload() bool { started, err := o.CacheFs.cache.SearchPendingUpload(o.abs()) if err != nil { return false } return started } // UnWrap returns the Object that this Object is wrapping or // nil if it isn't wrapping anything func (o *Object) UnWrap() fs.Object { return o.Object } var ( _ fs.Object = (*Object)(nil) _ fs.ObjectUnWrapper = (*Object)(nil) ) rclone-v1.71.0/backend/cache/plex.go000066400000000000000000000163171505210326400172070ustar00rootroot00000000000000//go:build !plan9 && !js package cache import ( "bytes" "crypto/tls" "encoding/json" "fmt" "io" "net/http" "net/url" "strings" "sync" "time" cache "github.com/patrickmn/go-cache" "github.com/rclone/rclone/fs" "golang.org/x/net/websocket" ) const ( // defPlexLoginURL is the default URL for Plex login defPlexLoginURL = "https://plex.tv/users/sign_in.json" defPlexNotificationURL = "%s/:/websockets/notifications?X-Plex-Token=%s" ) // PlaySessionStateNotification is part of the API response of Plex type PlaySessionStateNotification struct { SessionKey string `json:"sessionKey"` GUID string `json:"guid"` Key string `json:"key"` ViewOffset int64 `json:"viewOffset"` State string `json:"state"` TranscodeSession string `json:"transcodeSession"` } // NotificationContainer is part of the API response of Plex type NotificationContainer struct { Type string `json:"type"` Size int `json:"size"` PlaySessionState []PlaySessionStateNotification `json:"PlaySessionStateNotification"` } // PlexNotification is part of the API response of Plex type PlexNotification struct { Container NotificationContainer `json:"NotificationContainer"` } // plexConnector is managing the cache integration with Plex type plexConnector struct { url *url.URL username string password string token string insecure bool f *Fs mu sync.Mutex running bool runningMu sync.Mutex stateCache *cache.Cache saveToken func(string) } // newPlexConnector connects to a Plex server and generates a token func newPlexConnector(f *Fs, plexURL, username, password string, insecure bool, saveToken func(string)) (*plexConnector, error) { u, err := url.ParseRequestURI(strings.TrimRight(plexURL, "/")) if err != nil { return nil, err } pc := &plexConnector{ f: f, url: u, username: username, password: password, token: "", insecure: insecure, stateCache: cache.New(time.Hour, time.Minute), saveToken: saveToken, } return pc, nil } // newPlexConnector connects to a Plex server and generates a token func newPlexConnectorWithToken(f *Fs, plexURL, token string, insecure bool) (*plexConnector, error) { u, err := url.ParseRequestURI(strings.TrimRight(plexURL, "/")) if err != nil { return nil, err } pc := &plexConnector{ f: f, url: u, token: token, insecure: insecure, stateCache: cache.New(time.Hour, time.Minute), } pc.listenWebsocket() return pc, nil } func (p *plexConnector) closeWebsocket() { p.runningMu.Lock() defer p.runningMu.Unlock() fs.Infof("plex", "stopped Plex watcher") p.running = false } func (p *plexConnector) websocketDial() (*websocket.Conn, error) { u := strings.TrimRight(strings.Replace(strings.Replace( p.url.String(), "http://", "ws://", 1), "https://", "wss://", 1), "/") url := fmt.Sprintf(defPlexNotificationURL, u, p.token) config, err := websocket.NewConfig(url, "http://localhost") if err != nil { return nil, err } if p.insecure { config.TlsConfig = &tls.Config{InsecureSkipVerify: true} } return websocket.DialConfig(config) } func (p *plexConnector) listenWebsocket() { p.runningMu.Lock() defer p.runningMu.Unlock() conn, err := p.websocketDial() if err != nil { fs.Errorf("plex", "%v", err) return } p.running = true go func() { for { if !p.isConnected() { break } notif := &PlexNotification{} err := websocket.JSON.Receive(conn, notif) if err != nil { fs.Debugf("plex", "%v", err) p.closeWebsocket() break } // we're only interested in play events if notif.Container.Type == "playing" { // we loop through each of them for _, v := range notif.Container.PlaySessionState { // event type of playing if v.State == "playing" { // if it's not cached get the details and cache them if _, found := p.stateCache.Get(v.Key); !found { req, err := http.NewRequest("GET", fmt.Sprintf("%s%s", p.url.String(), v.Key), nil) if err != nil { continue } p.fillDefaultHeaders(req) resp, err := http.DefaultClient.Do(req) if err != nil { continue } var data []byte data, err = io.ReadAll(resp.Body) if err != nil { continue } p.stateCache.Set(v.Key, data, cache.DefaultExpiration) } } else if v.State == "stopped" { p.stateCache.Delete(v.Key) } } } } }() } // fillDefaultHeaders will add common headers to requests func (p *plexConnector) fillDefaultHeaders(req *http.Request) { req.Header.Add("X-Plex-Client-Identifier", fmt.Sprintf("rclone (%v)", p.f.String())) req.Header.Add("X-Plex-Product", fmt.Sprintf("rclone (%v)", p.f.Name())) req.Header.Add("X-Plex-Version", fs.Version) req.Header.Add("Accept", "application/json") if p.token != "" { req.Header.Add("X-Plex-Token", p.token) } } // authenticate will generate a token based on a username/password func (p *plexConnector) authenticate() error { p.mu.Lock() defer p.mu.Unlock() form := url.Values{} form.Set("user[login]", p.username) form.Add("user[password]", p.password) req, err := http.NewRequest("POST", defPlexLoginURL, strings.NewReader(form.Encode())) if err != nil { return err } p.fillDefaultHeaders(req) resp, err := http.DefaultClient.Do(req) if err != nil { return err } var data map[string]any err = json.NewDecoder(resp.Body).Decode(&data) if err != nil { return fmt.Errorf("failed to obtain token: %w", err) } tokenGen, ok := get(data, "user", "authToken") if !ok { return fmt.Errorf("failed to obtain token: %v", data) } token, ok := tokenGen.(string) if !ok { return fmt.Errorf("failed to obtain token: %v", data) } p.token = token if p.token != "" { if p.saveToken != nil { p.saveToken(p.token) } fs.Infof(p.f.Name(), "Connected to Plex server: %v", p.url.String()) } p.listenWebsocket() return nil } // isConnected checks if this rclone is authenticated to Plex func (p *plexConnector) isConnected() bool { p.runningMu.Lock() defer p.runningMu.Unlock() return p.running } // isConfigured checks if this rclone is configured to use a Plex server func (p *plexConnector) isConfigured() bool { return p.url != nil } func (p *plexConnector) isPlaying(co *Object) bool { var err error if !p.isConnected() { p.listenWebsocket() } remote := co.Remote() if cr, yes := p.f.isWrappedByCrypt(); yes { remote, err = cr.DecryptFileName(co.Remote()) if err != nil { fs.Debugf("plex", "can not decrypt wrapped file: %v", err) return false } } isPlaying := false for _, v := range p.stateCache.Items() { if bytes.Contains(v.Object.([]byte), []byte(remote)) { isPlaying = true break } } return isPlaying } // adapted from: https://stackoverflow.com/a/28878037 (credit) func get(m any, path ...any) (any, bool) { for _, p := range path { switch idx := p.(type) { case string: if mm, ok := m.(map[string]any); ok { if val, found := mm[idx]; found { m = val continue } } return nil, false case int: if mm, ok := m.([]any); ok { if len(mm) > idx { m = mm[idx] continue } } return nil, false } } return m, true } rclone-v1.71.0/backend/cache/storage_memory.go000066400000000000000000000050171505210326400212660ustar00rootroot00000000000000//go:build !plan9 && !js package cache import ( "fmt" "strconv" "strings" "time" cache "github.com/patrickmn/go-cache" "github.com/rclone/rclone/fs" ) // Memory is a wrapper of transient storage for a go-cache store type Memory struct { db *cache.Cache } // NewMemory builds this cache storage // defaultExpiration will set the expiry time of chunks in this storage func NewMemory(defaultExpiration time.Duration) *Memory { mem := &Memory{} err := mem.Connect(defaultExpiration) if err != nil { fs.Errorf("cache", "can't open ram connection: %v", err) } return mem } // Connect will create a connection for the storage func (m *Memory) Connect(defaultExpiration time.Duration) error { m.db = cache.New(defaultExpiration, -1) return nil } // HasChunk confirms the existence of a single chunk of an object func (m *Memory) HasChunk(cachedObject *Object, offset int64) bool { key := cachedObject.abs() + "-" + strconv.FormatInt(offset, 10) _, found := m.db.Get(key) return found } // GetChunk will retrieve a single chunk which belongs to a cached object or an error if it doesn't find it func (m *Memory) GetChunk(cachedObject *Object, offset int64) ([]byte, error) { key := cachedObject.abs() + "-" + strconv.FormatInt(offset, 10) var data []byte if x, found := m.db.Get(key); found { data = x.([]byte) return data, nil } return nil, fmt.Errorf("couldn't get cached object data at offset %v", offset) } // AddChunk adds a new chunk of a cached object func (m *Memory) AddChunk(fp string, data []byte, offset int64) error { return m.AddChunkAhead(fp, data, offset, time.Second) } // AddChunkAhead adds a new chunk of a cached object func (m *Memory) AddChunkAhead(fp string, data []byte, offset int64, t time.Duration) error { key := fp + "-" + strconv.FormatInt(offset, 10) m.db.Set(key, data, cache.DefaultExpiration) return nil } // CleanChunksByAge will cleanup on a cron basis func (m *Memory) CleanChunksByAge(chunkAge time.Duration) { m.db.DeleteExpired() } // CleanChunksByNeed will cleanup chunks after the FS passes a specific chunk func (m *Memory) CleanChunksByNeed(offset int64) { for key := range m.db.Items() { sepIdx := strings.LastIndex(key, "-") keyOffset, err := strconv.ParseInt(key[sepIdx+1:], 10, 64) if err != nil { fs.Errorf("cache", "couldn't parse offset entry %v", key) continue } if keyOffset < offset { m.db.Delete(key) } } } // CleanChunksBySize will cleanup chunks after the total size passes a certain point func (m *Memory) CleanChunksBySize(maxSize int64) { // NOOP } rclone-v1.71.0/backend/cache/storage_persistent.go000066400000000000000000000666741505210326400221760ustar00rootroot00000000000000//go:build !plan9 && !js package cache import ( "bytes" "context" "encoding/binary" "encoding/json" "fmt" "os" "path" "strconv" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/walk" bolt "go.etcd.io/bbolt" "go.etcd.io/bbolt/errors" ) // Constants const ( RootBucket = "root" RootTsBucket = "rootTs" DataTsBucket = "dataTs" tempBucket = "pending" ) // Features flags for this storage type type Features struct { PurgeDb bool // purge the db before starting DbWaitTime time.Duration // time to wait for DB to be available } var boltMap = make(map[string]*Persistent) var boltMapMx sync.Mutex // GetPersistent returns a single instance for the specific store func GetPersistent(dbPath, chunkPath string, f *Features) (*Persistent, error) { // write lock to create one boltMapMx.Lock() defer boltMapMx.Unlock() if b, ok := boltMap[dbPath]; ok { if !b.open { err := b.connect() if err != nil { return nil, err } } return b, nil } bb, err := newPersistent(dbPath, chunkPath, f) if err != nil { return nil, err } boltMap[dbPath] = bb return boltMap[dbPath], nil } type chunkInfo struct { Path string Offset int64 Size int64 } type tempUploadInfo struct { DestPath string AddedOn time.Time Started bool } // String representation of a tempUploadInfo func (t *tempUploadInfo) String() string { return fmt.Sprintf("%v - %v (%v)", t.DestPath, t.Started, t.AddedOn) } // Persistent is a wrapper of persistent storage for a bolt.DB file type Persistent struct { dbPath string dataPath string open bool db *bolt.DB cleanupMux sync.Mutex tempQueueMux sync.Mutex features *Features } // newPersistent builds a new wrapper and connects to the bolt.DB file func newPersistent(dbPath, chunkPath string, f *Features) (*Persistent, error) { b := &Persistent{ dbPath: dbPath, dataPath: chunkPath, features: f, } err := b.connect() if err != nil { fs.Errorf(dbPath, "Error opening storage cache. Is there another rclone running on the same remote? %v", err) return nil, err } return b, nil } // String will return a human friendly string for this DB (currently the dbPath) func (b *Persistent) String() string { return " " + b.dbPath } // connect creates a connection to the configured file // refreshDb will delete the file before to create an empty DB if it's set to true func (b *Persistent) connect() error { var err error err = os.MkdirAll(b.dataPath, os.ModePerm) if err != nil { return fmt.Errorf("failed to create a data directory %q: %w", b.dataPath, err) } b.db, err = bolt.Open(b.dbPath, 0644, &bolt.Options{Timeout: b.features.DbWaitTime}) if err != nil { return fmt.Errorf("failed to open a cache connection to %q: %w", b.dbPath, err) } if b.features.PurgeDb { b.Purge() } _ = b.db.Update(func(tx *bolt.Tx) error { _, _ = tx.CreateBucketIfNotExists([]byte(RootBucket)) _, _ = tx.CreateBucketIfNotExists([]byte(RootTsBucket)) _, _ = tx.CreateBucketIfNotExists([]byte(DataTsBucket)) _, _ = tx.CreateBucketIfNotExists([]byte(tempBucket)) return nil }) b.open = true return nil } // getBucket prepares and cleans a specific path of the form: /var/tmp and will iterate through each path component // to get to the nested bucket of the final part (in this example: tmp) func (b *Persistent) getBucket(dir string, createIfMissing bool, tx *bolt.Tx) *bolt.Bucket { cleanPath(dir) entries := strings.FieldsFunc(dir, func(c rune) bool { // cover Windows where rclone still uses '/' as path separator // this should be safe as '/' is not a valid Windows character return (os.PathSeparator == c || c == rune('/')) }) bucket := tx.Bucket([]byte(RootBucket)) for _, entry := range entries { if createIfMissing { bucket, _ = bucket.CreateBucketIfNotExists([]byte(entry)) } else { bucket = bucket.Bucket([]byte(entry)) } if bucket == nil { return nil } } return bucket } // GetDir will retrieve data of a cached directory func (b *Persistent) GetDir(remote string) (*Directory, error) { cd := &Directory{} err := b.db.View(func(tx *bolt.Tx) error { bucket := b.getBucket(remote, false, tx) if bucket == nil { return fmt.Errorf("couldn't open bucket (%v)", remote) } data := bucket.Get([]byte(".")) if data != nil { return json.Unmarshal(data, cd) } return fmt.Errorf("%v not found", remote) }) return cd, err } // AddDir will update a CachedDirectory metadata and all its entries func (b *Persistent) AddDir(cachedDir *Directory) error { return b.AddBatchDir([]*Directory{cachedDir}) } // AddBatchDir will update a list of CachedDirectory metadata and all their entries func (b *Persistent) AddBatchDir(cachedDirs []*Directory) error { if len(cachedDirs) == 0 { return nil } return b.db.Update(func(tx *bolt.Tx) error { var bucket *bolt.Bucket if cachedDirs[0].Dir == "" { bucket = tx.Bucket([]byte(RootBucket)) } else { bucket = b.getBucket(cachedDirs[0].Dir, true, tx) } if bucket == nil { return fmt.Errorf("couldn't open bucket (%v)", cachedDirs[0].Dir) } for _, cachedDir := range cachedDirs { var b *bolt.Bucket var err error if cachedDir.Name == "" { b = bucket } else { b, err = bucket.CreateBucketIfNotExists([]byte(cachedDir.Name)) } if err != nil { return err } encoded, err := json.Marshal(cachedDir) if err != nil { return fmt.Errorf("couldn't marshal object (%v): %v", cachedDir, err) } err = b.Put([]byte("."), encoded) if err != nil { return err } } return nil }) } // GetDirEntries will return a CachedDirectory, its list of dir entries and/or an error if it encountered issues func (b *Persistent) GetDirEntries(cachedDir *Directory) (fs.DirEntries, error) { var dirEntries fs.DirEntries err := b.db.View(func(tx *bolt.Tx) error { bucket := b.getBucket(cachedDir.abs(), false, tx) if bucket == nil { return fmt.Errorf("couldn't open bucket (%v)", cachedDir.abs()) } val := bucket.Get([]byte(".")) if val != nil { err := json.Unmarshal(val, cachedDir) if err != nil { return fmt.Errorf("error during unmarshalling obj: %w", err) } } else { return fmt.Errorf("missing cached dir: %v", cachedDir) } c := bucket.Cursor() for k, v := c.First(); k != nil; k, v = c.Next() { // ignore metadata key: . if bytes.Equal(k, []byte(".")) { continue } entryPath := path.Join(cachedDir.Remote(), string(k)) if v == nil { // directory // we try to find a cached meta for the dir currentBucket := c.Bucket().Bucket(k) if currentBucket == nil { return fmt.Errorf("couldn't open bucket (%v)", string(k)) } metaKey := currentBucket.Get([]byte(".")) d := NewDirectory(cachedDir.CacheFs, entryPath) if metaKey != nil { //if we don't find it, we create an empty dir err := json.Unmarshal(metaKey, d) if err != nil { // if even this fails, we fallback to an empty dir fs.Debugf(string(k), "error during unmarshalling obj: %v", err) } } dirEntries = append(dirEntries, d) } else { // object o := NewObject(cachedDir.CacheFs, entryPath) err := json.Unmarshal(v, o) if err != nil { fs.Debugf(string(k), "error during unmarshalling obj: %v", err) continue } dirEntries = append(dirEntries, o) } } return nil }) return dirEntries, err } // RemoveDir will delete a CachedDirectory, all its objects and all the chunks stored for it func (b *Persistent) RemoveDir(fp string) error { var err error parentDir, dirName := path.Split(fp) if fp == "" { err = b.db.Update(func(tx *bolt.Tx) error { err := tx.DeleteBucket([]byte(RootBucket)) if err != nil { fs.Debugf(fp, "couldn't delete from cache: %v", err) return err } _, _ = tx.CreateBucketIfNotExists([]byte(RootBucket)) return nil }) } else { err = b.db.Update(func(tx *bolt.Tx) error { bucket := b.getBucket(cleanPath(parentDir), false, tx) if bucket == nil { return fmt.Errorf("couldn't open bucket (%v)", fp) } // delete the cached dir err := bucket.DeleteBucket([]byte(cleanPath(dirName))) if err != nil { fs.Debugf(fp, "couldn't delete from cache: %v", err) } return nil }) } // delete chunks on disk // safe to ignore as the files might not have been open if err == nil { _ = os.RemoveAll(path.Join(b.dataPath, fp)) _ = os.MkdirAll(b.dataPath, os.ModePerm) } return err } // ExpireDir will flush a CachedDirectory and all its objects from the objects // chunks will remain as they are func (b *Persistent) ExpireDir(cd *Directory) error { t := time.Now().Add(time.Duration(-cd.CacheFs.opt.InfoAge)) cd.CacheTs = &t // expire all parents return b.db.Update(func(tx *bolt.Tx) error { // expire all the parents currentDir := cd.abs() for { // until we get to the root bucket := b.getBucket(currentDir, false, tx) if bucket != nil { val := bucket.Get([]byte(".")) if val != nil { cd2 := &Directory{CacheFs: cd.CacheFs} err := json.Unmarshal(val, cd2) if err == nil { fs.Debugf(cd, "cache: expired %v", currentDir) cd2.CacheTs = &t enc2, _ := json.Marshal(cd2) _ = bucket.Put([]byte("."), enc2) } } } if currentDir == "" { break } currentDir = cleanPath(path.Dir(currentDir)) } return nil }) } // GetObject will return a CachedObject from its parent directory or an error if it doesn't find it func (b *Persistent) GetObject(cachedObject *Object) (err error) { return b.db.View(func(tx *bolt.Tx) error { bucket := b.getBucket(cachedObject.Dir, false, tx) if bucket == nil { return fmt.Errorf("couldn't open parent bucket for %v", cachedObject.Dir) } val := bucket.Get([]byte(cachedObject.Name)) if val != nil { return json.Unmarshal(val, cachedObject) } return fmt.Errorf("couldn't find object (%v)", cachedObject.Name) }) } // AddObject will create a cached object in its parent directory func (b *Persistent) AddObject(cachedObject *Object) error { return b.db.Update(func(tx *bolt.Tx) error { bucket := b.getBucket(cachedObject.Dir, true, tx) if bucket == nil { return fmt.Errorf("couldn't open parent bucket for %v", cachedObject) } // cache Object Info encoded, err := json.Marshal(cachedObject) if err != nil { return fmt.Errorf("couldn't marshal object (%v) info: %v", cachedObject, err) } err = bucket.Put([]byte(cachedObject.Name), encoded) if err != nil { return fmt.Errorf("couldn't cache object (%v) info: %v", cachedObject, err) } return nil }) } // RemoveObject will delete a single cached object and all the chunks which belong to it func (b *Persistent) RemoveObject(fp string) error { parentDir, objName := path.Split(fp) return b.db.Update(func(tx *bolt.Tx) error { bucket := b.getBucket(cleanPath(parentDir), false, tx) if bucket == nil { return fmt.Errorf("couldn't open parent bucket for %v", cleanPath(parentDir)) } err := bucket.Delete([]byte(cleanPath(objName))) if err != nil { fs.Debugf(fp, "couldn't delete obj from storage: %v", err) } // delete chunks on disk // safe to ignore as the file might not have been open _ = os.RemoveAll(path.Join(b.dataPath, fp)) return nil }) } // ExpireObject will flush an Object and all its data if desired func (b *Persistent) ExpireObject(co *Object, withData bool) error { co.CacheTs = time.Now().Add(time.Duration(-co.CacheFs.opt.InfoAge)) err := b.AddObject(co) if withData { _ = os.RemoveAll(path.Join(b.dataPath, co.abs())) } return err } // HasEntry confirms the existence of a single entry (dir or object) func (b *Persistent) HasEntry(remote string) bool { dir, name := path.Split(remote) dir = cleanPath(dir) name = cleanPath(name) err := b.db.View(func(tx *bolt.Tx) error { bucket := b.getBucket(dir, false, tx) if bucket == nil { return fmt.Errorf("couldn't open parent bucket for %v", remote) } if f := bucket.Bucket([]byte(name)); f != nil { return nil } if f := bucket.Get([]byte(name)); f != nil { return nil } return fmt.Errorf("couldn't find object (%v)", remote) }) return err == nil } // HasChunk confirms the existence of a single chunk of an object func (b *Persistent) HasChunk(cachedObject *Object, offset int64) bool { fp := path.Join(b.dataPath, cachedObject.abs(), strconv.FormatInt(offset, 10)) if _, err := os.Stat(fp); !os.IsNotExist(err) { return true } return false } // GetChunk will retrieve a single chunk which belongs to a cached object or an error if it doesn't find it func (b *Persistent) GetChunk(cachedObject *Object, offset int64) ([]byte, error) { var data []byte fp := path.Join(b.dataPath, cachedObject.abs(), strconv.FormatInt(offset, 10)) data, err := os.ReadFile(fp) if err != nil { return nil, err } return data, err } // AddChunk adds a new chunk of a cached object func (b *Persistent) AddChunk(fp string, data []byte, offset int64) error { _ = os.MkdirAll(path.Join(b.dataPath, fp), os.ModePerm) filePath := path.Join(b.dataPath, fp, strconv.FormatInt(offset, 10)) err := os.WriteFile(filePath, data, os.ModePerm) if err != nil { return err } return b.db.Update(func(tx *bolt.Tx) error { tsBucket := tx.Bucket([]byte(DataTsBucket)) ts := time.Now() found := false // delete (older) timestamps for the same object c := tsBucket.Cursor() for k, v := c.First(); k != nil; k, v = c.Next() { var ci chunkInfo err = json.Unmarshal(v, &ci) if err != nil { continue } if ci.Path == fp && ci.Offset == offset { if tsInCache := time.Unix(0, btoi(k)); tsInCache.After(ts) && !found { found = true continue } err := c.Delete() if err != nil { fs.Debugf(fp, "failed to clean chunk: %v", err) } } } // don't overwrite if a newer one is already there if found { return nil } enc, err := json.Marshal(chunkInfo{Path: fp, Offset: offset, Size: int64(len(data))}) if err != nil { fs.Debugf(fp, "failed to timestamp chunk: %v", err) } err = tsBucket.Put(itob(ts.UnixNano()), enc) if err != nil { fs.Debugf(fp, "failed to timestamp chunk: %v", err) } return nil }) } // CleanChunksByAge will cleanup on a cron basis func (b *Persistent) CleanChunksByAge(chunkAge time.Duration) { // NOOP } // CleanChunksByNeed is a noop for this implementation func (b *Persistent) CleanChunksByNeed(offset int64) { // noop: we want to clean a Bolt DB by time only } // CleanChunksBySize will cleanup chunks after the total size passes a certain point func (b *Persistent) CleanChunksBySize(maxSize int64) { b.cleanupMux.Lock() defer b.cleanupMux.Unlock() var cntChunks int var roughlyCleaned fs.SizeSuffix err := b.db.Update(func(tx *bolt.Tx) error { dataTsBucket := tx.Bucket([]byte(DataTsBucket)) if dataTsBucket == nil { return fmt.Errorf("couldn't open (%v) bucket", DataTsBucket) } // iterate through ts c := dataTsBucket.Cursor() totalSize := int64(0) for k, v := c.First(); k != nil; k, v = c.Next() { var ci chunkInfo err := json.Unmarshal(v, &ci) if err != nil { continue } totalSize += ci.Size } if totalSize > maxSize { needToClean := totalSize - maxSize roughlyCleaned = fs.SizeSuffix(needToClean) for k, v := c.First(); k != nil; k, v = c.Next() { var ci chunkInfo err := json.Unmarshal(v, &ci) if err != nil { continue } // delete this ts entry err = c.Delete() if err != nil { fs.Errorf(ci.Path, "failed deleting chunk ts during cleanup (%v): %v", ci.Offset, err) continue } err = os.Remove(path.Join(b.dataPath, ci.Path, strconv.FormatInt(ci.Offset, 10))) if err == nil { cntChunks++ needToClean -= ci.Size if needToClean <= 0 { break } } } } if cntChunks > 0 { fs.Infof("cache-cleanup", "chunks %v, est. size: %v", cntChunks, roughlyCleaned.String()) } return nil }) if err != nil { if err == errors.ErrDatabaseNotOpen { // we're likely a late janitor and we need to end quietly as there's no guarantee of what exists anymore return } fs.Errorf("cache", "cleanup failed: %v", err) } } // Stats returns a go map with the stats key values func (b *Persistent) Stats() (map[string]map[string]any, error) { r := make(map[string]map[string]any) r["data"] = make(map[string]any) r["data"]["oldest-ts"] = time.Now() r["data"]["oldest-file"] = "" r["data"]["newest-ts"] = time.Now() r["data"]["newest-file"] = "" r["data"]["total-chunks"] = 0 r["data"]["total-size"] = int64(0) r["files"] = make(map[string]any) r["files"]["oldest-ts"] = time.Now() r["files"]["oldest-name"] = "" r["files"]["newest-ts"] = time.Now() r["files"]["newest-name"] = "" r["files"]["total-files"] = 0 _ = b.db.View(func(tx *bolt.Tx) error { dataTsBucket := tx.Bucket([]byte(DataTsBucket)) rootTsBucket := tx.Bucket([]byte(RootTsBucket)) var totalDirs int var totalFiles int _ = b.iterateBuckets(tx.Bucket([]byte(RootBucket)), func(name string) { totalDirs++ }, func(key string, val []byte) { totalFiles++ }) r["files"]["total-dir"] = totalDirs r["files"]["total-files"] = totalFiles c := dataTsBucket.Cursor() totalChunks := 0 totalSize := int64(0) for k, v := c.First(); k != nil; k, v = c.Next() { var ci chunkInfo err := json.Unmarshal(v, &ci) if err != nil { continue } totalChunks++ totalSize += ci.Size } r["data"]["total-chunks"] = totalChunks r["data"]["total-size"] = totalSize if k, v := c.First(); k != nil { var ci chunkInfo _ = json.Unmarshal(v, &ci) r["data"]["oldest-ts"] = time.Unix(0, btoi(k)) r["data"]["oldest-file"] = ci.Path } if k, v := c.Last(); k != nil { var ci chunkInfo _ = json.Unmarshal(v, &ci) r["data"]["newest-ts"] = time.Unix(0, btoi(k)) r["data"]["newest-file"] = ci.Path } c = rootTsBucket.Cursor() if k, v := c.First(); k != nil { // split to get (abs path - offset) r["files"]["oldest-ts"] = time.Unix(0, btoi(k)) r["files"]["oldest-name"] = string(v) } if k, v := c.Last(); k != nil { r["files"]["newest-ts"] = time.Unix(0, btoi(k)) r["files"]["newest-name"] = string(v) } return nil }) return r, nil } // Purge will flush the entire cache func (b *Persistent) Purge() { b.cleanupMux.Lock() defer b.cleanupMux.Unlock() _ = b.db.Update(func(tx *bolt.Tx) error { _ = tx.DeleteBucket([]byte(RootBucket)) _ = tx.DeleteBucket([]byte(RootTsBucket)) _ = tx.DeleteBucket([]byte(DataTsBucket)) _, _ = tx.CreateBucketIfNotExists([]byte(RootBucket)) _, _ = tx.CreateBucketIfNotExists([]byte(RootTsBucket)) _, _ = tx.CreateBucketIfNotExists([]byte(DataTsBucket)) return nil }) err := os.RemoveAll(b.dataPath) if err != nil { fs.Errorf(b, "issue removing data folder: %v", err) } err = os.MkdirAll(b.dataPath, os.ModePerm) if err != nil { fs.Errorf(b, "issue removing data folder: %v", err) } } // GetChunkTs retrieves the current timestamp of this chunk func (b *Persistent) GetChunkTs(path string, offset int64) (time.Time, error) { var t time.Time err := b.db.View(func(tx *bolt.Tx) error { tsBucket := tx.Bucket([]byte(DataTsBucket)) c := tsBucket.Cursor() for k, v := c.First(); k != nil; k, v = c.Next() { var ci chunkInfo err := json.Unmarshal(v, &ci) if err != nil { continue } if ci.Path == path && ci.Offset == offset { t = time.Unix(0, btoi(k)) return nil } } return fmt.Errorf("not found %v-%v", path, offset) }) return t, err } func (b *Persistent) iterateBuckets(buk *bolt.Bucket, bucketFn func(name string), kvFn func(key string, val []byte)) error { err := b.db.View(func(tx *bolt.Tx) error { var c *bolt.Cursor if buk == nil { c = tx.Cursor() } else { c = buk.Cursor() } for k, v := c.First(); k != nil; k, v = c.Next() { if v == nil { var buk2 *bolt.Bucket if buk == nil { buk2 = tx.Bucket(k) } else { buk2 = buk.Bucket(k) } bucketFn(string(k)) _ = b.iterateBuckets(buk2, bucketFn, kvFn) } else { kvFn(string(k), v) } } return nil }) return err } // addPendingUpload adds a new file to the pending queue of uploads func (b *Persistent) addPendingUpload(destPath string, started bool) error { return b.db.Update(func(tx *bolt.Tx) error { bucket, err := tx.CreateBucketIfNotExists([]byte(tempBucket)) if err != nil { return fmt.Errorf("couldn't bucket for %v", tempBucket) } tempObj := &tempUploadInfo{ DestPath: destPath, AddedOn: time.Now(), Started: started, } // cache Object Info encoded, err := json.Marshal(tempObj) if err != nil { return fmt.Errorf("couldn't marshal object (%v) info: %v", destPath, err) } err = bucket.Put([]byte(destPath), encoded) if err != nil { return fmt.Errorf("couldn't cache object (%v) info: %v", destPath, err) } return nil }) } // getPendingUpload returns the next file from the pending queue of uploads func (b *Persistent) getPendingUpload(inRoot string, waitTime time.Duration) (destPath string, err error) { b.tempQueueMux.Lock() defer b.tempQueueMux.Unlock() err = b.db.Update(func(tx *bolt.Tx) error { bucket, err := tx.CreateBucketIfNotExists([]byte(tempBucket)) if err != nil { return fmt.Errorf("couldn't bucket for %v", tempBucket) } c := bucket.Cursor() for k, v := c.Seek([]byte(inRoot)); k != nil && bytes.HasPrefix(k, []byte(inRoot)); k, v = c.Next() { //for k, v := c.First(); k != nil; k, v = c.Next() { var tempObj = &tempUploadInfo{} err = json.Unmarshal(v, tempObj) if err != nil { fs.Errorf(b, "failed to read pending upload: %v", err) continue } // skip over started uploads if tempObj.Started || time.Now().Before(tempObj.AddedOn.Add(waitTime)) { continue } tempObj.Started = true v2, err := json.Marshal(tempObj) if err != nil { fs.Errorf(b, "failed to update pending upload: %v", err) continue } err = bucket.Put(k, v2) if err != nil { fs.Errorf(b, "failed to update pending upload: %v", err) continue } destPath = tempObj.DestPath return nil } return fmt.Errorf("no pending upload found") }) return destPath, err } // SearchPendingUpload returns the file info from the pending queue of uploads func (b *Persistent) SearchPendingUpload(remote string) (started bool, err error) { err = b.db.View(func(tx *bolt.Tx) error { bucket := tx.Bucket([]byte(tempBucket)) if bucket == nil { return fmt.Errorf("couldn't bucket for %v", tempBucket) } var tempObj = &tempUploadInfo{} v := bucket.Get([]byte(remote)) err = json.Unmarshal(v, tempObj) if err != nil { return fmt.Errorf("pending upload (%v) not found %v", remote, err) } started = tempObj.Started return nil }) return started, err } // searchPendingUploadFromDir files currently pending upload from a single dir func (b *Persistent) searchPendingUploadFromDir(dir string) (remotes []string, err error) { err = b.db.View(func(tx *bolt.Tx) error { bucket := tx.Bucket([]byte(tempBucket)) if bucket == nil { return fmt.Errorf("couldn't bucket for %v", tempBucket) } c := bucket.Cursor() for k, v := c.First(); k != nil; k, v = c.Next() { var tempObj = &tempUploadInfo{} err = json.Unmarshal(v, tempObj) if err != nil { fs.Errorf(b, "failed to read pending upload: %v", err) continue } parentDir := cleanPath(path.Dir(tempObj.DestPath)) if dir == parentDir { remotes = append(remotes, tempObj.DestPath) } } return nil }) return remotes, err } func (b *Persistent) rollbackPendingUpload(remote string) error { b.tempQueueMux.Lock() defer b.tempQueueMux.Unlock() return b.db.Update(func(tx *bolt.Tx) error { bucket, err := tx.CreateBucketIfNotExists([]byte(tempBucket)) if err != nil { return fmt.Errorf("couldn't bucket for %v", tempBucket) } var tempObj = &tempUploadInfo{} v := bucket.Get([]byte(remote)) err = json.Unmarshal(v, tempObj) if err != nil { return fmt.Errorf("pending upload (%v) not found: %w", remote, err) } tempObj.Started = false v2, err := json.Marshal(tempObj) if err != nil { return fmt.Errorf("pending upload not updated: %w", err) } err = bucket.Put([]byte(tempObj.DestPath), v2) if err != nil { return fmt.Errorf("pending upload not updated: %w", err) } return nil }) } func (b *Persistent) removePendingUpload(remote string) error { b.tempQueueMux.Lock() defer b.tempQueueMux.Unlock() return b.db.Update(func(tx *bolt.Tx) error { bucket, err := tx.CreateBucketIfNotExists([]byte(tempBucket)) if err != nil { return fmt.Errorf("couldn't bucket for %v", tempBucket) } return bucket.Delete([]byte(remote)) }) } // updatePendingUpload allows to update an existing item in the queue while checking if it's not started in the same // transaction. If it is started, it will not allow the update func (b *Persistent) updatePendingUpload(remote string, fn func(item *tempUploadInfo) error) error { b.tempQueueMux.Lock() defer b.tempQueueMux.Unlock() return b.db.Update(func(tx *bolt.Tx) error { bucket, err := tx.CreateBucketIfNotExists([]byte(tempBucket)) if err != nil { return fmt.Errorf("couldn't bucket for %v", tempBucket) } var tempObj = &tempUploadInfo{} v := bucket.Get([]byte(remote)) err = json.Unmarshal(v, tempObj) if err != nil { return fmt.Errorf("pending upload (%v) not found %v", remote, err) } if tempObj.Started { return fmt.Errorf("pending upload already started %v", remote) } err = fn(tempObj) if err != nil { return err } if remote != tempObj.DestPath { err := bucket.Delete([]byte(remote)) if err != nil { return err } // if this is removed then the entry can be removed too if tempObj.DestPath == "" { return nil } } v2, err := json.Marshal(tempObj) if err != nil { return fmt.Errorf("pending upload not updated: %w", err) } err = bucket.Put([]byte(tempObj.DestPath), v2) if err != nil { return fmt.Errorf("pending upload not updated: %w", err) } return nil }) } // ReconcileTempUploads will recursively look for all the files in the temp directory and add them to the queue func (b *Persistent) ReconcileTempUploads(ctx context.Context, cacheFs *Fs) error { return b.db.Update(func(tx *bolt.Tx) error { _ = tx.DeleteBucket([]byte(tempBucket)) bucket, err := tx.CreateBucketIfNotExists([]byte(tempBucket)) if err != nil { return err } var queuedEntries []fs.Object err = walk.ListR(ctx, cacheFs.tempFs, "", true, -1, walk.ListObjects, func(entries fs.DirEntries) error { for _, o := range entries { if oo, ok := o.(fs.Object); ok { queuedEntries = append(queuedEntries, oo) } } return nil }) if err != nil { return err } fs.Debugf(cacheFs, "reconciling temporary uploads") for _, queuedEntry := range queuedEntries { destPath := path.Join(cacheFs.Root(), queuedEntry.Remote()) tempObj := &tempUploadInfo{ DestPath: destPath, AddedOn: time.Now(), Started: false, } // cache Object Info encoded, err := json.Marshal(tempObj) if err != nil { return fmt.Errorf("couldn't marshal object (%v) info: %v", queuedEntry, err) } err = bucket.Put([]byte(destPath), encoded) if err != nil { return fmt.Errorf("couldn't cache object (%v) info: %v", destPath, err) } fs.Debugf(cacheFs, "reconciled temporary upload: %v", destPath) } return nil }) } // Close should be called when the program ends gracefully func (b *Persistent) Close() { b.cleanupMux.Lock() defer b.cleanupMux.Unlock() err := b.db.Close() if err != nil { fs.Errorf(b, "closing handle: %v", err) } b.open = false } // itob returns an 8-byte big endian representation of v. func itob(v int64) []byte { b := make([]byte, 8) binary.BigEndian.PutUint64(b, uint64(v)) return b } func btoi(d []byte) int64 { return int64(binary.BigEndian.Uint64(d)) } rclone-v1.71.0/backend/cache/utils_test.go000066400000000000000000000012741505210326400204320ustar00rootroot00000000000000//go:build !plan9 && !js // +build !plan9,!js package cache import bolt "go.etcd.io/bbolt" // PurgeTempUploads will remove all the pending uploads from the queue func (b *Persistent) PurgeTempUploads() { b.tempQueueMux.Lock() defer b.tempQueueMux.Unlock() _ = b.db.Update(func(tx *bolt.Tx) error { _ = tx.DeleteBucket([]byte(tempBucket)) _, _ = tx.CreateBucketIfNotExists([]byte(tempBucket)) return nil }) } // SetPendingUploadToStarted is a way to mark an entry as started (even if it's not already) func (b *Persistent) SetPendingUploadToStarted(remote string) error { return b.updatePendingUpload(remote, func(item *tempUploadInfo) error { item.Started = true return nil }) } rclone-v1.71.0/backend/chunker/000077500000000000000000000000001505210326400162745ustar00rootroot00000000000000rclone-v1.71.0/backend/chunker/chunker.go000066400000000000000000002346671505210326400203040ustar00rootroot00000000000000// Package chunker provides wrappers for Fs and Object which split large files in chunks package chunker import ( "bytes" "context" "crypto/md5" "crypto/sha1" "encoding/hex" "encoding/json" "errors" "fmt" gohash "hash" "io" "math/rand" "path" "regexp" "sort" "strconv" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fspath" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/lib/encoder" ) // Chunker's composite files have one or more chunks // and optional metadata object. If it's present, // meta object is named after the original file. // // The only supported metadata format is simplejson atm. // It supports only per-file meta objects that are rudimentary, // used mostly for consistency checks (lazily for performance reasons). // Other formats can be developed that use an external meta store // free of these limitations, but this needs some support from // rclone core (e.g. metadata store interfaces). // // The following types of chunks are supported: // data and control, active and temporary. // Chunk type is identified by matching chunk file name // based on the chunk name format configured by user and transaction // style being used. // // Both data and control chunks can be either temporary (aka hidden) // or active (non-temporary aka normal aka permanent). // An operation creates temporary chunks while it runs. // By completion it removes temporary and leaves active chunks. // // Temporary chunks have a special hardcoded suffix in addition // to the configured name pattern. // Temporary suffix includes so called transaction identifier // (abbreviated as `xactID` below), a generic non-negative base-36 "number" // used by parallel operations to share a composite object. // Chunker also accepts the longer decimal temporary suffix (obsolete), // which is transparently converted to the new format. In its maximum // length of 13 decimals it makes a 7-digit base-36 number. // // When transactions is set to the norename style, data chunks will // keep their temporary chunk names (with the transaction identifier // suffix). To distinguish them from temporary chunks, the txn field // of the metadata file is set to match the transaction identifier of // the data chunks. // // Chunker can tell data chunks from control chunks by the characters // located in the "hash placeholder" position of configured format. // Data chunks have decimal digits there. // Control chunks have in that position a short lowercase alphanumeric // string (starting with a letter) prepended by underscore. // // Metadata format v1 does not define any control chunk types, // they are currently ignored aka reserved. // In future they can be used to implement resumable uploads etc. const ( ctrlTypeRegStr = `[a-z][a-z0-9]{2,6}` tempSuffixFormat = `_%04s` tempSuffixRegStr = `_([0-9a-z]{4,9})` tempSuffixRegOld = `\.\.tmp_([0-9]{10,13})` ) var ( // regular expressions to validate control type and temporary suffix ctrlTypeRegexp = regexp.MustCompile(`^` + ctrlTypeRegStr + `$`) tempSuffixRegexp = regexp.MustCompile(`^` + tempSuffixRegStr + `$`) ) // Normally metadata is a small piece of JSON (about 100-300 bytes). // The size of valid metadata must never exceed this limit. // Current maximum provides a reasonable room for future extensions. // // Please refrain from increasing it, this can cause old rclone versions // to fail, or worse, treat meta object as a normal file (see NewObject). // If more room is needed please bump metadata version forcing previous // releases to ask for upgrade, and offload extra info to a control chunk. // // And still chunker's primary function is to chunk large files // rather than serve as a generic metadata container. const ( maxMetadataSize = 1023 maxMetadataSizeWritten = 255 ) // Current/highest supported metadata format. const metadataVersion = 2 // optimizeFirstChunk enables the following optimization in the Put: // If a single chunk is expected, put the first chunk using the // base target name instead of a temporary name, thus avoiding // extra rename operation. // Warning: this optimization is not transaction safe. const optimizeFirstChunk = false // revealHidden is a stub until chunker lands the `reveal hidden` option. const revealHidden = false // Prevent memory overflow due to specially crafted chunk name const maxSafeChunkNumber = 10000000 // Number of attempts to find unique transaction identifier const maxTransactionProbes = 100 // standard chunker errors var ( ErrChunkOverflow = errors.New("chunk number overflow") ErrMetaTooBig = errors.New("metadata is too big") ErrMetaUnknown = errors.New("unknown metadata, please upgrade rclone") ) // variants of baseMove's parameter delMode const ( delNever = 0 // don't delete, just move delAlways = 1 // delete destination before moving delFailed = 2 // move, then delete and try again if failed ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "chunker", Description: "Transparently chunk/split large files", NewFs: NewFs, Options: []fs.Option{{ Name: "remote", Required: true, Help: `Remote to chunk/unchunk. Normally should contain a ':' and a path, e.g. "myremote:path/to/dir", "myremote:bucket" or maybe "myremote:" (not recommended).`, }, { Name: "chunk_size", Advanced: false, Default: fs.SizeSuffix(2147483648), // 2 GiB Help: `Files larger than chunk size will be split in chunks.`, }, { Name: "name_format", Advanced: true, Hide: fs.OptionHideCommandLine, Default: `*.rclone_chunk.###`, Help: `String format of chunk file names. The two placeholders are: base file name (*) and chunk number (#...). There must be one and only one asterisk and one or more consecutive hash characters. If chunk number has less digits than the number of hashes, it is left-padded by zeros. If there are more digits in the number, they are left as is. Possible chunk files are ignored if their name does not match given format.`, }, { Name: "start_from", Advanced: true, Hide: fs.OptionHideCommandLine, Default: 1, Help: `Minimum valid chunk number. Usually 0 or 1. By default chunk numbers start from 1.`, }, { Name: "meta_format", Advanced: true, Hide: fs.OptionHideCommandLine, Default: "simplejson", Help: `Format of the metadata object or "none". By default "simplejson". Metadata is a small JSON file named after the composite file.`, Examples: []fs.OptionExample{{ Value: "none", Help: `Do not use metadata files at all. Requires hash type "none".`, }, { Value: "simplejson", Help: `Simple JSON supports hash sums and chunk validation. It has the following fields: ver, size, nchunks, md5, sha1.`, }}, }, { Name: "hash_type", Advanced: false, Default: "md5", Help: `Choose how chunker handles hash sums. All modes but "none" require metadata.`, Examples: []fs.OptionExample{{ Value: "none", Help: `Pass any hash supported by wrapped remote for non-chunked files. Return nothing otherwise.`, }, { Value: "md5", Help: `MD5 for composite files.`, }, { Value: "sha1", Help: `SHA1 for composite files.`, }, { Value: "md5all", Help: `MD5 for all files.`, }, { Value: "sha1all", Help: `SHA1 for all files.`, }, { Value: "md5quick", Help: `Copying a file to chunker will request MD5 from the source. Falling back to SHA1 if unsupported.`, }, { Value: "sha1quick", Help: `Similar to "md5quick" but prefers SHA1 over MD5.`, }}, }, { Name: "fail_hard", Advanced: true, Default: false, Help: `Choose how chunker should handle files with missing or invalid chunks.`, Examples: []fs.OptionExample{ { Value: "true", Help: "Report errors and abort current command.", }, { Value: "false", Help: "Warn user, skip incomplete file and proceed.", }, }, }, { Name: "transactions", Advanced: true, Default: "rename", Help: `Choose how chunker should handle temporary files during transactions.`, Hide: fs.OptionHideCommandLine, Examples: []fs.OptionExample{ { Value: "rename", Help: "Rename temporary files after a successful transaction.", }, { Value: "norename", Help: `Leave temporary file names and write transaction ID to metadata file. Metadata is required for no rename transactions (meta format cannot be "none"). If you are using norename transactions you should be careful not to downgrade Rclone as older versions of Rclone don't support this transaction style and will misinterpret files manipulated by norename transactions. This method is EXPERIMENTAL, don't use on production systems.`, }, { Value: "auto", Help: `Rename or norename will be used depending on capabilities of the backend. If meta format is set to "none", rename transactions will always be used. This method is EXPERIMENTAL, don't use on production systems.`, }, }, }}, }) } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, rpath string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } if opt.StartFrom < 0 { return nil, errors.New("start_from must be non-negative") } remote := opt.Remote if strings.HasPrefix(remote, name+":") { return nil, errors.New("can't point remote at itself - check the value of the remote setting") } baseName, basePath, err := fspath.SplitFs(remote) if err != nil { return nil, fmt.Errorf("failed to parse remote %q to wrap: %w", remote, err) } // Look for a file first remotePath := fspath.JoinRootPath(basePath, rpath) baseFs, err := cache.Get(ctx, baseName+remotePath) if err != fs.ErrorIsFile && err != nil { return nil, fmt.Errorf("failed to make remote %q to wrap: %w", baseName+remotePath, err) } if !operations.CanServerSideMove(baseFs) { return nil, errors.New("can't use chunker on a backend which doesn't support server-side move or copy") } f := &Fs{ base: baseFs, name: name, root: rpath, opt: *opt, } f.dirSort = true // processEntries requires that meta Objects prerun data chunks atm. if err := f.configure(opt.NameFormat, opt.MetaFormat, opt.HashType, opt.Transactions); err != nil { return nil, err } // Handle the tricky case detected by FsMkdir/FsPutFiles/FsIsFile // when `rpath` points to a composite multi-chunk file without metadata, // i.e. `rpath` does not exist in the wrapped remote, but chunker // detects a composite file because it finds the first chunk! // (yet can't satisfy fstest.CheckListing, will ignore) if err == nil && !f.useMeta { firstChunkPath := f.makeChunkName(remotePath, 0, "", "") newBase, testErr := cache.Get(ctx, baseName+firstChunkPath) if testErr == fs.ErrorIsFile { f.base = newBase err = testErr } } cache.PinUntilFinalized(f.base, f) // Correct root if definitely pointing to a file if err == fs.ErrorIsFile { f.root = path.Dir(f.root) if f.root == "." || f.root == "/" { f.root = "" } } // Note 1: the features here are ones we could support, and they are // ANDed with the ones from wrappedFs. // Note 2: features.Fill() points features.PutStream to our PutStream, // but features.Mask() will nullify it if wrappedFs does not have it. f.features = (&fs.Features{ CaseInsensitive: true, DuplicateFiles: true, ReadMimeType: false, // Object.MimeType not supported WriteMimeType: true, BucketBased: true, CanHaveEmptyDirectories: true, ServerSideAcrossConfigs: true, ReadDirMetadata: true, WriteDirMetadata: true, WriteDirSetModTime: true, UserDirMetadata: true, DirModTimeUpdatesOnWrite: true, }).Fill(ctx, f).Mask(ctx, baseFs).WrapsFs(f, baseFs) f.features.ListR = nil // Recursive listing may cause chunker skip files f.features.ListP = nil // ListP not supported yet return f, err } // Options defines the configuration for this backend type Options struct { Remote string `config:"remote"` ChunkSize fs.SizeSuffix `config:"chunk_size"` NameFormat string `config:"name_format"` StartFrom int `config:"start_from"` MetaFormat string `config:"meta_format"` HashType string `config:"hash_type"` FailHard bool `config:"fail_hard"` Transactions string `config:"transactions"` } // Fs represents a wrapped fs.Fs type Fs struct { name string root string base fs.Fs // remote wrapped by chunker overlay wrapper fs.Fs // wrapper is used by SetWrapper useMeta bool // false if metadata format is 'none' useMD5 bool // mutually exclusive with useSHA1 useSHA1 bool // mutually exclusive with useMD5 hashFallback bool // allows fallback from MD5 to SHA1 and vice versa hashAll bool // hash all files, mutually exclusive with hashFallback dataNameFmt string // name format of data chunks ctrlNameFmt string // name format of control chunks nameRegexp *regexp.Regexp // regular expression to match chunk names xactIDRand *rand.Rand // generator of random transaction identifiers xactIDMutex sync.Mutex // mutex for the source of randomness opt Options // copy of Options features *fs.Features // optional features dirSort bool // reserved for future, ignored useNoRename bool // can be set with the transactions option } // configure sets up chunker for given name format, meta format and hash type. // It also seeds the source of random transaction identifiers. // configure must be called only from NewFs or by unit tests. func (f *Fs) configure(nameFormat, metaFormat, hashType, transactionMode string) error { if err := f.setChunkNameFormat(nameFormat); err != nil { return fmt.Errorf("invalid name format '%s': %w", nameFormat, err) } if err := f.setMetaFormat(metaFormat); err != nil { return err } if err := f.setHashType(hashType); err != nil { return err } if err := f.setTransactionMode(transactionMode); err != nil { return err } randomSeed := time.Now().UnixNano() f.xactIDRand = rand.New(rand.NewSource(randomSeed)) return nil } func (f *Fs) setMetaFormat(metaFormat string) error { switch metaFormat { case "none": f.useMeta = false case "simplejson": f.useMeta = true default: return fmt.Errorf("unsupported meta format '%s'", metaFormat) } return nil } // setHashType // must be called *after* setMetaFormat. // // In the "All" mode chunker will force metadata on all files // if the wrapped remote can't provide given hashsum. func (f *Fs) setHashType(hashType string) error { f.useMD5 = false f.useSHA1 = false f.hashFallback = false f.hashAll = false requireMetaHash := true switch hashType { case "none": requireMetaHash = false case "md5": f.useMD5 = true case "sha1": f.useSHA1 = true case "md5quick": f.useMD5 = true f.hashFallback = true case "sha1quick": f.useSHA1 = true f.hashFallback = true case "md5all": f.useMD5 = true f.hashAll = !f.base.Hashes().Contains(hash.MD5) || f.base.Features().SlowHash case "sha1all": f.useSHA1 = true f.hashAll = !f.base.Hashes().Contains(hash.SHA1) || f.base.Features().SlowHash default: return fmt.Errorf("unsupported hash type '%s'", hashType) } if requireMetaHash && !f.useMeta { return fmt.Errorf("hash type '%s' requires compatible meta format", hashType) } return nil } func (f *Fs) setTransactionMode(transactionMode string) error { switch transactionMode { case "rename": f.useNoRename = false case "norename": if !f.useMeta { return errors.New("incompatible transaction options") } f.useNoRename = true case "auto": f.useNoRename = !f.CanQuickRename() if f.useNoRename && !f.useMeta { f.useNoRename = false return errors.New("using norename transactions requires metadata") } default: return fmt.Errorf("unsupported transaction mode '%s'", transactionMode) } return nil } // setChunkNameFormat converts pattern based chunk name format // into Printf format and Regular expressions for data and // control chunks. func (f *Fs) setChunkNameFormat(pattern string) error { // validate pattern if strings.Count(pattern, "*") != 1 { return errors.New("pattern must have exactly one asterisk (*)") } numDigits := strings.Count(pattern, "#") if numDigits < 1 { return errors.New("pattern must have a hash character (#)") } if strings.Index(pattern, "*") > strings.Index(pattern, "#") { return errors.New("asterisk (*) in pattern must come before hashes (#)") } if ok, _ := regexp.MatchString("^[^#]*[#]+[^#]*$", pattern); !ok { return errors.New("hashes (#) in pattern must be consecutive") } if dir, _ := path.Split(pattern); dir != "" { return errors.New("directory separator prohibited") } if pattern[0] != '*' { return errors.New("pattern must start with asterisk") // to be lifted later } // craft a unified regular expression for all types of chunks reHashes := regexp.MustCompile("[#]+") reDigits := "[0-9]+" if numDigits > 1 { reDigits = fmt.Sprintf("[0-9]{%d,}", numDigits) } reDataOrCtrl := fmt.Sprintf("(?:(%s)|_(%s))", reDigits, ctrlTypeRegStr) // this must be non-greedy or else it could eat up temporary suffix const mainNameRegStr = "(.+?)" strRegex := regexp.QuoteMeta(pattern) strRegex = reHashes.ReplaceAllLiteralString(strRegex, reDataOrCtrl) strRegex = strings.ReplaceAll(strRegex, "\\*", mainNameRegStr) strRegex = fmt.Sprintf("^%s(?:%s|%s)?$", strRegex, tempSuffixRegStr, tempSuffixRegOld) f.nameRegexp = regexp.MustCompile(strRegex) // craft printf formats for active data/control chunks fmtDigits := "%d" if numDigits > 1 { fmtDigits = fmt.Sprintf("%%0%dd", numDigits) } strFmt := strings.ReplaceAll(pattern, "%", "%%") strFmt = strings.Replace(strFmt, "*", "%s", 1) f.dataNameFmt = reHashes.ReplaceAllLiteralString(strFmt, fmtDigits) f.ctrlNameFmt = reHashes.ReplaceAllLiteralString(strFmt, "_%s") return nil } // makeChunkName produces chunk name (or path) for a given file. // // filePath can be name, relative or absolute path of main file. // // chunkNo must be a zero based index of data chunk. // Negative chunkNo e.g. -1 indicates a control chunk. // ctrlType is type of control chunk (must be valid). // ctrlType must be "" for data chunks. // // xactID is a transaction identifier. Empty xactID denotes active chunk, // otherwise temporary chunk name is produced. func (f *Fs) makeChunkName(filePath string, chunkNo int, ctrlType, xactID string) string { dir, parentName := path.Split(filePath) var name, tempSuffix string switch { case chunkNo >= 0 && ctrlType == "": name = fmt.Sprintf(f.dataNameFmt, parentName, chunkNo+f.opt.StartFrom) case chunkNo < 0 && ctrlTypeRegexp.MatchString(ctrlType): name = fmt.Sprintf(f.ctrlNameFmt, parentName, ctrlType) default: panic("makeChunkName: invalid argument") // must not produce something we can't consume } if xactID != "" { tempSuffix = fmt.Sprintf(tempSuffixFormat, xactID) if !tempSuffixRegexp.MatchString(tempSuffix) { panic("makeChunkName: invalid argument") } } return dir + name + tempSuffix } // parseChunkName checks whether given file path belongs to // a chunk and extracts chunk name parts. // // filePath can be name, relative or absolute path of a file. // // Returned parentPath is path of the composite file owning the chunk. // It's a non-empty string if valid chunk name is detected // or "" if it's not a chunk. // Other returned values depend on detected chunk type: // data or control, active or temporary: // // data chunk - the returned chunkNo is non-negative and ctrlType is "" // control chunk - the chunkNo is -1 and ctrlType is a non-empty string // active chunk - the returned xactID is "" // temporary chunk - the xactID is a non-empty string func (f *Fs) parseChunkName(filePath string) (parentPath string, chunkNo int, ctrlType, xactID string) { dir, name := path.Split(filePath) match := f.nameRegexp.FindStringSubmatch(name) if match == nil || match[1] == "" { return "", -1, "", "" } var err error chunkNo = -1 if match[2] != "" { if chunkNo, err = strconv.Atoi(match[2]); err != nil { chunkNo = -1 } if chunkNo -= f.opt.StartFrom; chunkNo < 0 { fs.Infof(f, "invalid data chunk number in file %q", name) return "", -1, "", "" } } if match[4] != "" { xactID = match[4] } if match[5] != "" { // old-style temporary suffix number, err := strconv.ParseInt(match[5], 10, 64) if err != nil || number < 0 { fs.Infof(f, "invalid old-style transaction number in file %q", name) return "", -1, "", "" } // convert old-style transaction number to base-36 transaction ID xactID = fmt.Sprintf(tempSuffixFormat, strconv.FormatInt(number, 36)) xactID = xactID[1:] // strip leading underscore } parentPath = dir + match[1] ctrlType = match[3] return } // forbidChunk prints error message or raises error if file is chunk. // First argument sets log prefix, use `false` to suppress message. func (f *Fs) forbidChunk(o any, filePath string) error { if parentPath, _, _, _ := f.parseChunkName(filePath); parentPath != "" { if f.opt.FailHard { return fmt.Errorf("chunk overlap with %q", parentPath) } if boolVal, isBool := o.(bool); !isBool || boolVal { fs.Errorf(o, "chunk overlap with %q", parentPath) } } return nil } // newXactID produces a sufficiently random transaction identifier. // // The temporary suffix mask allows identifiers consisting of 4-9 // base-36 digits (ie. digits 0-9 or lowercase letters a-z). // The identifiers must be unique between transactions running on // the single file in parallel. // // Currently the function produces 6-character identifiers. // Together with underscore this makes a 7-character temporary suffix. // // The first 4 characters isolate groups of transactions by time intervals. // The maximum length of interval is base-36 "zzzz" ie. 1,679,615 seconds. // The function rather takes a maximum prime closest to this number // (see https://primes.utm.edu) as the interval length to better safeguard // against repeating pseudo-random sequences in cases when rclone is // invoked from a periodic scheduler like unix cron. // Thus, the interval is slightly more than 19 days 10 hours 33 minutes. // // The remaining 2 base-36 digits (in the range from 0 to 1295 inclusive) // are taken from the local random source. // This provides about 0.1% collision probability for two parallel // operations started at the same second and working on the same file. // // Non-empty filePath argument enables probing for existing temporary chunk // to further eliminate collisions. func (f *Fs) newXactID(ctx context.Context, filePath string) (xactID string, err error) { const closestPrimeZzzzSeconds = 1679609 const maxTwoBase36Digits = 1295 unixSec := time.Now().Unix() if unixSec < 0 { unixSec = -unixSec // unlikely but the number must be positive } circleSec := unixSec % closestPrimeZzzzSeconds first4chars := strconv.FormatInt(circleSec, 36) for range maxTransactionProbes { f.xactIDMutex.Lock() randomness := f.xactIDRand.Int63n(maxTwoBase36Digits + 1) f.xactIDMutex.Unlock() last2chars := strconv.FormatInt(randomness, 36) xactID = fmt.Sprintf("%04s%02s", first4chars, last2chars) if filePath == "" { return } probeChunk := f.makeChunkName(filePath, 0, "", xactID) _, probeErr := f.base.NewObject(ctx, probeChunk) if probeErr != nil { return } } return "", fmt.Errorf("can't setup transaction for %s", filePath) } // List the objects and directories in dir into entries. // The entries can be returned in any order but should be // for a complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't found. // // Commands normally cleanup all temporary chunks in case of a failure. // However, if rclone dies unexpectedly, it can leave behind a bunch of // hidden temporary chunks. List and its underlying chunkEntries() // silently skip all temporary chunks in the directory. It's okay if // they belong to an unfinished command running in parallel. // // However, there is no way to discover dead temporary chunks atm. // As a workaround users can use `purge` to forcibly remove the whole // directory together with dead chunks. // In future a flag named like `--chunker-list-hidden` may be added to // rclone that will tell List to reveal hidden chunks. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { entries, err = f.base.List(ctx, dir) if err != nil { return nil, err } return f.processEntries(ctx, entries, dir) } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively than doing a directory traversal. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { do := f.base.Features().ListR return do(ctx, dir, func(entries fs.DirEntries) error { newEntries, err := f.processEntries(ctx, entries, dir) if err != nil { return err } return callback(newEntries) }) } // processEntries assembles chunk entries into composite entries func (f *Fs) processEntries(ctx context.Context, origEntries fs.DirEntries, dirPath string) (newEntries fs.DirEntries, err error) { var sortedEntries fs.DirEntries if f.dirSort { // sort entries so that meta objects go before their chunks sortedEntries = make(fs.DirEntries, len(origEntries)) copy(sortedEntries, origEntries) sort.Sort(sortedEntries) } else { sortedEntries = origEntries } byRemote := make(map[string]*Object) badEntry := make(map[string]bool) isSubdir := make(map[string]bool) txnByRemote := map[string]string{} var tempEntries fs.DirEntries for _, dirOrObject := range sortedEntries { switch entry := dirOrObject.(type) { case fs.Object: remote := entry.Remote() mainRemote, chunkNo, ctrlType, xactID := f.parseChunkName(remote) if mainRemote == "" { // this is meta object or standalone file object := f.newObject("", entry, nil) byRemote[remote] = object tempEntries = append(tempEntries, object) if f.useNoRename { txnByRemote[remote], err = object.readXactID(ctx) if err != nil { return nil, err } } break } // this is some kind of chunk // metobject should have been created above if present mainObject := byRemote[mainRemote] isSpecial := xactID != txnByRemote[mainRemote] || ctrlType != "" if mainObject == nil && f.useMeta && !isSpecial { fs.Debugf(f, "skip orphan data chunk %q", remote) break } if mainObject == nil && !f.useMeta { // this is the "nometa" case // create dummy chunked object without metadata mainObject = f.newObject(mainRemote, nil, nil) byRemote[mainRemote] = mainObject if !badEntry[mainRemote] { tempEntries = append(tempEntries, mainObject) } } if isSpecial { if revealHidden { fs.Infof(f, "ignore non-data chunk %q", remote) } // need to read metadata to ensure actual object type // no need to read if metaobject is too big or absent, // use the fact that before calling validate() // the `size` field caches metaobject size, if any if f.useMeta && mainObject != nil && mainObject.size <= maxMetadataSize { mainObject.unsure = true } break } if err := mainObject.addChunk(entry, chunkNo); err != nil { if f.opt.FailHard { return nil, err } badEntry[mainRemote] = true } case fs.Directory: isSubdir[entry.Remote()] = true wrapDir := fs.NewDirWrapper(entry.Remote(), entry) tempEntries = append(tempEntries, wrapDir) default: if f.opt.FailHard { return nil, fmt.Errorf("unknown object type %T", entry) } fs.Debugf(f, "unknown object type %T", entry) } } for _, entry := range tempEntries { if object, ok := entry.(*Object); ok { remote := object.Remote() if isSubdir[remote] { if f.opt.FailHard { return nil, fmt.Errorf("%q is both meta object and directory", remote) } badEntry[remote] = true // fall thru } if badEntry[remote] { fs.Debugf(f, "invalid directory entry %q", remote) continue } if err := object.validate(); err != nil { if f.opt.FailHard { return nil, err } fs.Debugf(f, "invalid chunks in object %q", remote) continue } } newEntries = append(newEntries, entry) } if f.dirSort { sort.Sort(newEntries) } return newEntries, nil } // NewObject finds the Object at remote. // // Please note that every NewObject invocation will scan the whole directory. // Using here something like fs.DirCache might improve performance // (yet making the logic more complex). // // Note that chunker prefers analyzing file names rather than reading // the content of meta object assuming that directory scans are fast // but opening even a small file can be slow on some backends. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return f.scanObject(ctx, remote, false) } // scanObject is like NewObject with optional quick scan mode. // The quick mode avoids directory requests other than `List`, // ignores non-chunked objects and skips chunk size checks. func (f *Fs) scanObject(ctx context.Context, remote string, quickScan bool) (fs.Object, error) { if err := f.forbidChunk(false, remote); err != nil { return nil, fmt.Errorf("can't access: %w", err) } var ( o *Object baseObj fs.Object currentXactID string err error sameMain bool ) if f.useMeta { baseObj, err = f.base.NewObject(ctx, remote) if err != nil { return nil, err } remote = baseObj.Remote() // Chunker's meta object cannot be large and maxMetadataSize acts // as a hard limit. Anything larger than that is treated as a // non-chunked file without even checking its contents, so it's // paramount to prevent metadata from exceeding the maximum size. // Anything smaller is additionally checked for format. o = f.newObject("", baseObj, nil) if o.size > maxMetadataSize { return o, nil } } else { // Metadata is disabled, hence this is either a multi-chunk // composite file without meta object or a non-chunked file. // Create an empty wrapper here, scan directory to determine // which case it is and postpone reading if it's the latter one. o = f.newObject(remote, nil, nil) } // If the object is small, it's probably a meta object. // However, composite file must have data chunks besides it. // Scan directory for possible data chunks now and decide later on. dir := path.Dir(strings.TrimRight(remote, "/")) if dir == "." { dir = "" } entries, err := f.base.List(ctx, dir) switch err { case nil: // OK, fall thru case fs.ErrorDirNotFound: entries = nil default: return nil, fmt.Errorf("can't detect composite file: %w", err) } if f.useNoRename { currentXactID, err = o.readXactID(ctx) if err != nil { return nil, err } } caseInsensitive := f.features.CaseInsensitive for _, dirOrObject := range entries { entry, ok := dirOrObject.(fs.Object) if !ok { continue } entryRemote := entry.Remote() if !caseInsensitive && !strings.Contains(entryRemote, remote) { continue // bypass regexp to save cpu } mainRemote, chunkNo, ctrlType, xactID := f.parseChunkName(entryRemote) if mainRemote == "" { continue // skip non-chunks } if caseInsensitive { sameMain = strings.EqualFold(mainRemote, remote) if sameMain && f.base.Features().IsLocal { // on local, make sure the EqualFold still holds true when accounting for encoding. // sometimes paths with special characters will only normalize the same way in Standard Encoding. sameMain = strings.EqualFold(encoder.OS.FromStandardPath(mainRemote), encoder.OS.FromStandardPath(remote)) } } else { sameMain = mainRemote == remote } if !sameMain { continue // skip alien chunks } if ctrlType != "" || xactID != currentXactID { if f.useMeta { // temporary/control chunk calls for lazy metadata read o.unsure = true } continue } // fs.Debugf(f, "%q belongs to %q as chunk %d", entryRemote, mainRemote, chunkNo) if err := o.addChunk(entry, chunkNo); err != nil { return nil, err } } if o.main == nil && len(o.chunks) == 0 { // Scanning hasn't found data chunks with conforming names. if f.useMeta || quickScan { // Metadata is required but absent and there are no chunks. return nil, fs.ErrorObjectNotFound } // Data chunks are not found and metadata is disabled. // Thus, we are in the "latter case" from above. // Let's try the postponed reading of a non-chunked file and add it // as a single chunk to the empty composite wrapper created above // with nil metadata. baseObj, err = f.base.NewObject(ctx, remote) if err == nil { err = o.addChunk(baseObj, 0) } if err != nil { return nil, err } } // This is either a composite object with metadata or a non-chunked // file without metadata. Validate it and update the total data size. // As an optimization, skip metadata reading here - we will call // readMetadata lazily when needed (reading can be expensive). if !quickScan { if err := o.validate(); err != nil { return nil, err } } return o, nil } // readMetadata reads composite object metadata and caches results, // in case of critical errors metadata is not cached. // Returns ErrMetaUnknown if an unsupported metadata format is detected. // If object is not chunked but marked by List or NewObject for recheck, // readMetadata will attempt to parse object as composite with fallback // to non-chunked representation if the attempt fails. func (o *Object) readMetadata(ctx context.Context) error { // return quickly if metadata is absent or has been already cached if !o.f.useMeta { o.isFull = true } if o.isFull { return nil } if !o.isComposite() && !o.unsure { // this for sure is a non-chunked standalone file o.isFull = true return nil } // validate metadata metaObject := o.main if metaObject.Size() > maxMetadataSize { if o.unsure { // this is not metadata but a foreign object o.unsure = false o.chunks = nil // make isComposite return false o.isFull = true // cache results return nil } return ErrMetaTooBig } // size is within limits, perform consistency checks reader, err := metaObject.Open(ctx) if err != nil { return err } metadata, err := io.ReadAll(reader) _ = reader.Close() // ensure file handle is freed on windows if err != nil { return err } switch o.f.opt.MetaFormat { case "simplejson": metaInfo, madeByChunker, err := unmarshalSimpleJSON(ctx, metaObject, metadata) if o.unsure { o.unsure = false if !madeByChunker { // this is not metadata but a foreign object o.chunks = nil // make isComposite return false o.isFull = true // cache results return nil } } switch err { case nil: // fall thru case ErrMetaTooBig, ErrMetaUnknown: return err // return these errors unwrapped for unit tests default: return fmt.Errorf("invalid metadata: %w", err) } if o.size != metaInfo.Size() || len(o.chunks) != metaInfo.nChunks { return errors.New("metadata doesn't match file size") } o.md5 = metaInfo.md5 o.sha1 = metaInfo.sha1 o.xactID = metaInfo.xactID } o.isFull = true // cache results o.xIDCached = true return nil } // readXactID returns the transaction ID stored in the passed metadata object func (o *Object) readXactID(ctx context.Context) (xactID string, err error) { // if xactID has already been read and cached return it now if o.xIDCached { return o.xactID, nil } // Avoid reading metadata for backends that don't use xactID to identify permanent chunks if !o.f.useNoRename { return "", errors.New("readXactID requires norename transactions") } if o.main == nil { return "", errors.New("readXactID requires valid metaobject") } if o.main.Size() > maxMetadataSize { return "", nil // this was likely not a metadata object, return empty xactID but don't throw error } reader, err := o.main.Open(ctx) if err != nil { return "", err } data, err := io.ReadAll(reader) _ = reader.Close() // ensure file handle is freed on windows if err != nil { return "", err } switch o.f.opt.MetaFormat { case "simplejson": if len(data) > maxMetadataSizeWritten { return "", nil // this was likely not a metadata object, return empty xactID but don't throw error } var metadata metaSimpleJSON err = json.Unmarshal(data, &metadata) if err != nil { return "", nil // this was likely not a metadata object, return empty xactID but don't throw error } xactID = metadata.XactID } o.xactID = xactID o.xIDCached = true return xactID, nil } // put implements Put, PutStream, PutUnchecked, Update func (f *Fs) put( ctx context.Context, in io.Reader, src fs.ObjectInfo, remote string, options []fs.OpenOption, basePut putFn, action string, target fs.Object, ) (obj fs.Object, err error) { // Perform consistency checks if err := f.forbidChunk(src, remote); err != nil { return nil, fmt.Errorf("%s refused: %w", action, err) } if target == nil { // Get target object with a quick directory scan // skip metadata check if target object does not exist. // ignore not-chunked objects, skip chunk size checks. if obj, err := f.scanObject(ctx, remote, true); err == nil { target = obj } } if target != nil { obj := target.(*Object) if err := obj.readMetadata(ctx); err == ErrMetaUnknown { // refuse to update a file of unsupported format return nil, fmt.Errorf("refusing to %s: %w", action, err) } } // Prepare to upload c := f.newChunkingReader(src) wrapIn := c.wrapStream(ctx, in, src) var metaObject fs.Object defer func() { if err != nil { c.rollback(ctx, metaObject) } }() baseRemote := remote xactID, errXact := f.newXactID(ctx, baseRemote) if errXact != nil { return nil, errXact } // Transfer chunks data for c.chunkNo = 0; !c.done; c.chunkNo++ { if c.chunkNo > maxSafeChunkNumber { return nil, ErrChunkOverflow } tempRemote := f.makeChunkName(baseRemote, c.chunkNo, "", xactID) size := min(c.sizeLeft, c.chunkSize) savedReadCount := c.readCount // If a single chunk is expected, avoid the extra rename operation chunkRemote := tempRemote if c.expectSingle && c.chunkNo == 0 && optimizeFirstChunk { chunkRemote = baseRemote } info := f.wrapInfo(src, chunkRemote, size) // Refill chunkLimit and let basePut repeatedly call chunkingReader.Read() c.chunkLimit = c.chunkSize // TODO: handle range/limit options chunk, errChunk := basePut(ctx, wrapIn, info, options...) if errChunk != nil { return nil, errChunk } if size > 0 && c.readCount == savedReadCount && c.expectSingle { // basePut returned success but didn't call chunkingReader's Read. // This is possible if wrapped remote has performed the put by hash // because chunker bridges Hash from source for non-chunked files. // Hence, force Read here to update accounting and hashsums. if err := c.dummyRead(wrapIn, size); err != nil { return nil, err } } if c.sizeLeft == 0 && !c.done { // The file has been apparently put by hash, force completion. c.done = true } // Expected a single chunk but more to come, so name it as usual. if !c.done && chunkRemote != tempRemote { fs.Infof(chunk, "Expected single chunk, got more") chunkMoved, errMove := f.baseMove(ctx, chunk, tempRemote, delFailed) if errMove != nil { silentlyRemove(ctx, chunk) return nil, errMove } chunk = chunkMoved } // Wrapped remote may or may not have seen EOF from chunking reader, // e.g. the box multi-uploader reads exactly the chunk size specified // and skips the "EOF" read. Hence, switch to next limit here. if !(c.chunkLimit == 0 || c.chunkLimit == c.chunkSize || c.sizeTotal == -1 || c.done) { silentlyRemove(ctx, chunk) return nil, fmt.Errorf("destination ignored %d data bytes", c.chunkLimit) } c.chunkLimit = c.chunkSize c.chunks = append(c.chunks, chunk) } // Validate uploaded size if c.sizeTotal != -1 && c.readCount != c.sizeTotal { return nil, fmt.Errorf("incorrect upload size %d != %d", c.readCount, c.sizeTotal) } // Check for input that looks like valid metadata needMeta := len(c.chunks) > 1 if c.readCount <= maxMetadataSize && len(c.chunks) == 1 { _, madeByChunker, _ := unmarshalSimpleJSON(ctx, c.chunks[0], c.smallHead) needMeta = madeByChunker } // Finalize small object as non-chunked. // This can be bypassed, and single chunk with metadata will be // created if forced by consistent hashing or due to unsafe input. if !needMeta && !f.hashAll && f.useMeta { // If previous object was chunked, remove its chunks f.removeOldChunks(ctx, baseRemote) // Rename single data chunk in place chunk := c.chunks[0] if chunk.Remote() != baseRemote { chunkMoved, errMove := f.baseMove(ctx, chunk, baseRemote, delAlways) if errMove != nil { silentlyRemove(ctx, chunk) return nil, errMove } chunk = chunkMoved } return f.newObject("", chunk, nil), nil } // Validate total size of data chunks var sizeTotal int64 for _, chunk := range c.chunks { sizeTotal += chunk.Size() } if sizeTotal != c.readCount { return nil, fmt.Errorf("incorrect chunks size %d != %d", sizeTotal, c.readCount) } // If previous object was chunked, remove its chunks f.removeOldChunks(ctx, baseRemote) if !f.useNoRename { // The transaction suffix will be removed for backends with quick rename operations for chunkNo, chunk := range c.chunks { chunkRemote := f.makeChunkName(baseRemote, chunkNo, "", "") chunkMoved, errMove := f.baseMove(ctx, chunk, chunkRemote, delFailed) if errMove != nil { return nil, errMove } c.chunks[chunkNo] = chunkMoved } xactID = "" } if !f.useMeta { // Remove stale metadata, if any oldMeta, errOldMeta := f.base.NewObject(ctx, baseRemote) if errOldMeta == nil { silentlyRemove(ctx, oldMeta) } o := f.newObject(baseRemote, nil, c.chunks) o.size = sizeTotal return o, nil } // Update meta object var metadata []byte switch f.opt.MetaFormat { case "simplejson": c.updateHashes() metadata, err = marshalSimpleJSON(ctx, sizeTotal, len(c.chunks), c.md5, c.sha1, xactID) } if err == nil { metaInfo := f.wrapInfo(src, baseRemote, int64(len(metadata))) metaObject, err = basePut(ctx, bytes.NewReader(metadata), metaInfo) } if err != nil { return nil, err } o := f.newObject("", metaObject, c.chunks) o.size = sizeTotal o.xactID = xactID return o, nil } type putFn func(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) type chunkingReader struct { baseReader io.Reader sizeTotal int64 sizeLeft int64 readCount int64 chunkSize int64 chunkLimit int64 chunkNo int err error done bool chunks []fs.Object expectSingle bool smallHead []byte fs *Fs hasher gohash.Hash md5 string sha1 string } func (f *Fs) newChunkingReader(src fs.ObjectInfo) *chunkingReader { c := &chunkingReader{ fs: f, chunkSize: int64(f.opt.ChunkSize), sizeTotal: src.Size(), } c.chunkLimit = c.chunkSize c.sizeLeft = c.sizeTotal c.expectSingle = c.sizeTotal >= 0 && c.sizeTotal <= c.chunkSize return c } func (c *chunkingReader) wrapStream(ctx context.Context, in io.Reader, src fs.ObjectInfo) io.Reader { baseIn, wrapBack := accounting.UnWrap(in) switch { case c.fs.useMD5: srcObj := fs.UnWrapObjectInfo(src) if srcObj != nil && srcObj.Fs().Features().SlowHash { fs.Debugf(src, "skip slow MD5 on source file, hashing in-transit") c.hasher = md5.New() break } if c.md5, _ = src.Hash(ctx, hash.MD5); c.md5 == "" { if c.fs.hashFallback { c.sha1, _ = src.Hash(ctx, hash.SHA1) } else { c.hasher = md5.New() } } case c.fs.useSHA1: srcObj := fs.UnWrapObjectInfo(src) if srcObj != nil && srcObj.Fs().Features().SlowHash { fs.Debugf(src, "skip slow SHA1 on source file, hashing in-transit") c.hasher = sha1.New() break } if c.sha1, _ = src.Hash(ctx, hash.SHA1); c.sha1 == "" { if c.fs.hashFallback { c.md5, _ = src.Hash(ctx, hash.MD5) } else { c.hasher = sha1.New() } } } if c.hasher != nil { baseIn = io.TeeReader(baseIn, c.hasher) } c.baseReader = baseIn return wrapBack(c) } func (c *chunkingReader) updateHashes() { if c.hasher == nil { return } switch { case c.fs.useMD5: c.md5 = hex.EncodeToString(c.hasher.Sum(nil)) case c.fs.useSHA1: c.sha1 = hex.EncodeToString(c.hasher.Sum(nil)) } } // Note: Read is not called if wrapped remote performs put by hash. func (c *chunkingReader) Read(buf []byte) (bytesRead int, err error) { if c.chunkLimit <= 0 { // Chunk complete - switch to next one. // Note #1: // We might not get here because some remotes (e.g. box multi-uploader) // read the specified size exactly and skip the concluding EOF Read. // Then a check in the put loop will kick in. // Note #2: // The crypt backend after receiving EOF here will call Read again // and we must insist on returning EOF, so we postpone refilling // chunkLimit to the main loop. return 0, io.EOF } if int64(len(buf)) > c.chunkLimit { buf = buf[0:c.chunkLimit] } bytesRead, err = c.baseReader.Read(buf) if err != nil && err != io.EOF { c.err = err c.done = true return } c.accountBytes(int64(bytesRead)) if c.chunkNo == 0 && c.expectSingle && bytesRead > 0 && c.readCount <= maxMetadataSize { c.smallHead = append(c.smallHead, buf[:bytesRead]...) } if bytesRead == 0 && c.sizeLeft == 0 { err = io.EOF // Force EOF when no data left. } if err == io.EOF { c.done = true } return } func (c *chunkingReader) accountBytes(bytesRead int64) { c.readCount += bytesRead c.chunkLimit -= bytesRead if c.sizeLeft != -1 { c.sizeLeft -= bytesRead } } // dummyRead updates accounting, hashsums, etc. by simulating reads func (c *chunkingReader) dummyRead(in io.Reader, size int64) error { if c.hasher == nil && c.readCount+size > maxMetadataSize { c.accountBytes(size) return nil } const bufLen = 1048576 // 1 MiB buf := make([]byte, bufLen) for size > 0 { n := min(size, bufLen) if _, err := io.ReadFull(in, buf[0:n]); err != nil { return err } size -= n } return nil } // rollback removes uploaded temporary chunks func (c *chunkingReader) rollback(ctx context.Context, metaObject fs.Object) { if metaObject != nil { c.chunks = append(c.chunks, metaObject) } for _, chunk := range c.chunks { if err := chunk.Remove(ctx); err != nil { fs.Errorf(chunk, "Failed to remove temporary chunk: %v", err) } } } func (f *Fs) removeOldChunks(ctx context.Context, remote string) { oldFsObject, err := f.NewObject(ctx, remote) if err == nil { oldObject := oldFsObject.(*Object) for _, chunk := range oldObject.chunks { if err := chunk.Remove(ctx); err != nil { fs.Errorf(chunk, "Failed to remove old chunk: %v", err) } } } } // Put into the remote path with the given modTime and size. // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.put(ctx, in, src, src.Remote(), options, f.base.Put, "put", nil) } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.put(ctx, in, src, src.Remote(), options, f.base.Features().PutStream, "upload", nil) } // Update in to the object with the modTime given of the given size func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { basePut := o.f.base.Put if src.Size() < 0 { basePut = o.f.base.Features().PutStream if basePut == nil { return errors.New("wrapped file system does not support streaming uploads") } } oNew, err := o.f.put(ctx, in, src, o.Remote(), options, basePut, "update", o) if err == nil { *o = *oNew.(*Object) } return err } // PutUnchecked uploads the object // // This will create a duplicate if we upload a new file without // checking to see if there is one already - use Put() for that. func (f *Fs) PutUnchecked(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { do := f.base.Features().PutUnchecked if do == nil { return nil, errors.New("can't PutUnchecked") } // TODO: handle range/limit options and really chunk stream here! o, err := do(ctx, in, f.wrapInfo(src, "", -1)) if err != nil { return nil, err } return f.newObject("", o, nil), nil } // Hashes returns the supported hash sets. // Chunker advertises a hash type if and only if it can be calculated // for files of any size, non-chunked or composite. func (f *Fs) Hashes() hash.Set { // composites AND no fallback AND (chunker OR wrapped Fs will hash all non-chunked's) if f.useMD5 && !f.hashFallback && (f.hashAll || f.base.Hashes().Contains(hash.MD5)) { return hash.NewHashSet(hash.MD5) } if f.useSHA1 && !f.hashFallback && (f.hashAll || f.base.Hashes().Contains(hash.SHA1)) { return hash.NewHashSet(hash.SHA1) } return hash.NewHashSet() // can't provide strong guarantees } // Mkdir makes the directory (container, bucket) // // Shouldn't return an error if it already exists func (f *Fs) Mkdir(ctx context.Context, dir string) error { if err := f.forbidChunk(dir, dir); err != nil { return fmt.Errorf("can't mkdir: %w", err) } return f.base.Mkdir(ctx, dir) } // MkdirMetadata makes the root directory of the Fs object func (f *Fs) MkdirMetadata(ctx context.Context, dir string, metadata fs.Metadata) (fs.Directory, error) { if do := f.base.Features().MkdirMetadata; do != nil { return do(ctx, dir, metadata) } return nil, fs.ErrorNotImplemented } // Rmdir removes the directory (container, bucket) if empty // // Return an error if it doesn't exist or isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { return f.base.Rmdir(ctx, dir) } // Purge all files in the directory // // Implement this if you have a way of deleting all the files // quicker than just running Remove() on the result of List() // // Return an error if it doesn't exist. // // This command will chain to `purge` from wrapped remote. // As a result it removes not only composite chunker files with their // active chunks but also all hidden temporary chunks in the directory. func (f *Fs) Purge(ctx context.Context, dir string) error { do := f.base.Features().Purge if do == nil { return fs.ErrorCantPurge } return do(ctx, dir) } // Remove an object (chunks and metadata, if any) // // Remove deletes only active chunks of the composite object. // It does not try to look for temporary chunks because they could belong // to another command modifying this composite file in parallel. // // Commands normally cleanup all temporary chunks in case of a failure. // However, if rclone dies unexpectedly, it can leave hidden temporary // chunks, which cannot be discovered using the `list` command. // Remove does not try to search for such chunks or to delete them. // Sometimes this can lead to strange results e.g. when `list` shows that // directory is empty but `rmdir` refuses to remove it because on the // level of wrapped remote it's actually *not* empty. // As a workaround users can use `purge` to forcibly remove it. // // In future, a flag `--chunker-delete-hidden` may be added which tells // Remove to search directory for hidden chunks and remove them too // (at the risk of breaking parallel commands). // // Remove is the only operation allowed on the composite files with // invalid or future metadata format. // We don't let user copy/move/update unsupported composite files. // Let's at least let her get rid of them, just complain loudly. // // This can litter directory with orphan chunks of unsupported types, // but as long as we remove meta object, even future releases will // treat the composite file as removed and refuse to act upon it. // // Disclaimer: corruption can still happen if unsupported file is removed // and then recreated with the same name. // Unsupported control chunks will get re-picked by a more recent // rclone version with unexpected results. This can be helped by // the `delete hidden` flag above or at least the user has been warned. func (o *Object) Remove(ctx context.Context) (err error) { if err := o.f.forbidChunk(o, o.Remote()); err != nil { // operations.Move can still call Remove if chunker's Move refuses // to corrupt file in hard mode. Hence, refuse to Remove, too. return fmt.Errorf("refuse to corrupt: %w", err) } if err := o.readMetadata(ctx); err == ErrMetaUnknown { // Proceed but warn user that unexpected things can happen. fs.Errorf(o, "Removing a file with unsupported metadata: %v", err) } // Remove non-chunked file or meta object of a composite file. if o.main != nil { err = o.main.Remove(ctx) } // Remove only active data chunks, ignore any temporary chunks that // might probably be created in parallel by other transactions. for _, chunk := range o.chunks { chunkErr := chunk.Remove(ctx) if err == nil { err = chunkErr } } // There are no known control chunks to remove atm. return err } // copyOrMove implements copy or move func (f *Fs) copyOrMove(ctx context.Context, o *Object, remote string, do copyMoveFn, md5, sha1, opName string) (fs.Object, error) { if err := f.forbidChunk(o, remote); err != nil { return nil, fmt.Errorf("can't %s: %w", opName, err) } if err := o.readMetadata(ctx); err != nil { // Refuse to copy/move composite files with invalid or future // metadata format which might involve unsupported chunk types. return nil, fmt.Errorf("can't %s this file: %w", opName, err) } if !o.isComposite() { fs.Debugf(o, "%s non-chunked object...", opName) oResult, err := do(ctx, o.mainChunk(), remote) // chain operation to a single wrapped chunk if err != nil { return nil, err } return f.newObject("", oResult, nil), nil } fs.Debugf(o, "%s %d data chunks...", opName, len(o.chunks)) mainRemote := o.remote var newChunks []fs.Object var err error // Copy/move active data chunks. // Ignore possible temporary chunks being created by parallel operations. for _, chunk := range o.chunks { chunkRemote := chunk.Remote() if !strings.HasPrefix(chunkRemote, mainRemote) { err = fmt.Errorf("invalid chunk name %q", chunkRemote) break } chunkSuffix := chunkRemote[len(mainRemote):] chunkResult, err := do(ctx, chunk, remote+chunkSuffix) if err != nil { break } newChunks = append(newChunks, chunkResult) } // Copy or move old metadata. // There are no known control chunks to move/copy atm. var metaObject fs.Object if err == nil && o.main != nil { metaObject, err = do(ctx, o.main, remote) } if err != nil { for _, chunk := range newChunks { silentlyRemove(ctx, chunk) } return nil, err } // Create wrapping object, calculate and validate total size newObj := f.newObject(remote, metaObject, newChunks) err = newObj.validate() if err != nil { silentlyRemove(ctx, newObj) return nil, err } // Update metadata var metadata []byte switch f.opt.MetaFormat { case "simplejson": metadata, err = marshalSimpleJSON(ctx, newObj.size, len(newChunks), md5, sha1, o.xactID) if err == nil { metaInfo := f.wrapInfo(metaObject, "", int64(len(metadata))) err = newObj.main.Update(ctx, bytes.NewReader(metadata), metaInfo) } case "none": if newObj.main != nil { err = newObj.main.Remove(ctx) } } // Return the composite object if err != nil { silentlyRemove(ctx, newObj) return nil, err } return newObj, nil } type copyMoveFn func(context.Context, fs.Object, string) (fs.Object, error) func (f *Fs) okForServerSide(ctx context.Context, src fs.Object, opName string) (obj *Object, md5, sha1 string, ok bool) { var diff string obj, ok = src.(*Object) switch { case !ok: diff = "remote types" case !operations.SameConfig(f.base, obj.f.base): diff = "wrapped remotes" case f.opt.ChunkSize != obj.f.opt.ChunkSize: diff = "chunk sizes" case f.opt.NameFormat != obj.f.opt.NameFormat: diff = "chunk name formats" case f.opt.StartFrom != obj.f.opt.StartFrom: diff = "chunk numbering" case f.opt.MetaFormat != obj.f.opt.MetaFormat: diff = "meta formats" } if diff != "" { fs.Debugf(src, "Can't %s - different %s", opName, diff) ok = false return } if obj.unsure { // ensure object is composite if need to re-read metadata _ = obj.readMetadata(ctx) } requireMetaHash := obj.isComposite() && f.opt.MetaFormat == "simplejson" if !requireMetaHash && !f.hashAll { ok = true // hash is not required for metadata return } switch { case f.useMD5: md5, _ = obj.Hash(ctx, hash.MD5) ok = md5 != "" if !ok && f.hashFallback { sha1, _ = obj.Hash(ctx, hash.SHA1) ok = sha1 != "" } case f.useSHA1: sha1, _ = obj.Hash(ctx, hash.SHA1) ok = sha1 != "" if !ok && f.hashFallback { md5, _ = obj.Hash(ctx, hash.MD5) ok = md5 != "" } default: ok = false } if !ok { fs.Debugf(src, "Can't %s - required hash not found", opName) } return } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { baseCopy := f.base.Features().Copy if baseCopy == nil { return nil, fs.ErrorCantCopy } obj, md5, sha1, ok := f.okForServerSide(ctx, src, "copy") if !ok { return nil, fs.ErrorCantCopy } return f.copyOrMove(ctx, obj, remote, baseCopy, md5, sha1, "copy") } // Move src to this remote using server-side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { baseMove := func(ctx context.Context, src fs.Object, remote string) (fs.Object, error) { return f.baseMove(ctx, src, remote, delNever) } obj, md5, sha1, ok := f.okForServerSide(ctx, src, "move") if !ok { return nil, fs.ErrorCantMove } return f.copyOrMove(ctx, obj, remote, baseMove, md5, sha1, "move") } // baseMove chains to the wrapped Move or simulates it by Copy+Delete func (f *Fs) baseMove(ctx context.Context, src fs.Object, remote string, delMode int) (fs.Object, error) { ctx, ci := fs.AddConfig(ctx) ci.NameTransform = nil // ensure operations.Move does not double-transform here var ( dest fs.Object err error ) switch delMode { case delAlways: dest, err = f.base.NewObject(ctx, remote) case delFailed: dest, err = operations.Move(ctx, f.base, nil, remote, src) if err == nil { return dest, err } dest, err = f.base.NewObject(ctx, remote) case delNever: // fall thru, the default } if err != nil { dest = nil } return operations.Move(ctx, f.base, dest, remote, src) } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { do := f.base.Features().DirMove if do == nil { return fs.ErrorCantDirMove } srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } return do(ctx, srcFs.base, srcRemote, dstRemote) } // DirSetModTime sets the directory modtime for dir func (f *Fs) DirSetModTime(ctx context.Context, dir string, modTime time.Time) error { if do := f.base.Features().DirSetModTime; do != nil { return do(ctx, dir, modTime) } return fs.ErrorNotImplemented } // CleanUp the trash in the Fs // // Implement this if you have a way of emptying the trash or // otherwise cleaning up old versions of files. func (f *Fs) CleanUp(ctx context.Context) error { do := f.base.Features().CleanUp if do == nil { return errors.New("not supported by underlying remote") } return do(ctx) } // About gets quota information from the Fs func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { do := f.base.Features().About if do == nil { return nil, errors.New("not supported by underlying remote") } return do(ctx) } // UnWrap returns the Fs that this Fs is wrapping func (f *Fs) UnWrap() fs.Fs { return f.base } // WrapFs returns the Fs that is wrapping this Fs func (f *Fs) WrapFs() fs.Fs { return f.wrapper } // SetWrapper sets the Fs that is wrapping this Fs func (f *Fs) SetWrapper(wrapper fs.Fs) { f.wrapper = wrapper } // ChangeNotify calls the passed function with a path // that has had changes. If the implementation // uses polling, it should adhere to the given interval. // // Replace data chunk names by the name of composite file. // Ignore temporary and control chunks. func (f *Fs) ChangeNotify(ctx context.Context, notifyFunc func(string, fs.EntryType), pollIntervalChan <-chan time.Duration) { do := f.base.Features().ChangeNotify if do == nil { return } wrappedNotifyFunc := func(path string, entryType fs.EntryType) { // fs.Debugf(f, "ChangeNotify: path %q entryType %d", path, entryType) if entryType == fs.EntryObject { mainPath, _, _, xactID := f.parseChunkName(path) metaXactID := "" if f.useNoRename { metaObject, _ := f.base.NewObject(ctx, mainPath) dummyObject := f.newObject("", metaObject, nil) metaXactID, _ = dummyObject.readXactID(ctx) } if mainPath != "" && xactID == metaXactID { path = mainPath } } notifyFunc(path, entryType) } do(ctx, wrappedNotifyFunc, pollIntervalChan) } // Shutdown the backend, closing any background tasks and any // cached connections. func (f *Fs) Shutdown(ctx context.Context) error { do := f.base.Features().Shutdown if do == nil { return nil } return do(ctx) } // Object represents a composite file wrapping one or more data chunks type Object struct { remote string main fs.Object // meta object if file is composite, or wrapped non-chunked file, nil if meta format is 'none' chunks []fs.Object // active data chunks if file is composite, or wrapped file as a single chunk if meta format is 'none' size int64 // cached total size of chunks in a composite file or -1 for non-chunked files isFull bool // true if metadata has been read xIDCached bool // true if xactID has been read unsure bool // true if need to read metadata to detect object type xactID string // transaction ID for "norename" or empty string for "renamed" chunks md5 string sha1 string f *Fs } func (o *Object) addChunk(chunk fs.Object, chunkNo int) error { if chunkNo < 0 { return fmt.Errorf("invalid chunk number %d", chunkNo+o.f.opt.StartFrom) } if chunkNo == len(o.chunks) { o.chunks = append(o.chunks, chunk) return nil } if chunkNo > maxSafeChunkNumber { return ErrChunkOverflow } if chunkNo > len(o.chunks) { newChunks := make([]fs.Object, (chunkNo + 1), (chunkNo+1)*2) copy(newChunks, o.chunks) o.chunks = newChunks } if o.chunks[chunkNo] != nil { return fmt.Errorf("duplicate chunk number %d", chunkNo+o.f.opt.StartFrom) } o.chunks[chunkNo] = chunk return nil } // validate verifies the object internals and updates total size func (o *Object) validate() error { if !o.isComposite() { _ = o.mainChunk() // verify that single wrapped chunk exists return nil } metaObject := o.main // this file is composite - o.main refers to meta object (or nil if meta format is 'none') if metaObject != nil && metaObject.Size() > maxMetadataSize { // metadata of a chunked file must be a tiny piece of json o.size = -1 return fmt.Errorf("%q metadata is too large", o.remote) } var totalSize int64 for _, chunk := range o.chunks { if chunk == nil { o.size = -1 return fmt.Errorf("%q has missing chunks", o) } totalSize += chunk.Size() } o.size = totalSize // cache up the total data size return nil } func (f *Fs) newObject(remote string, main fs.Object, chunks []fs.Object) *Object { var size int64 = -1 if main != nil { size = main.Size() if remote == "" { remote = main.Remote() } } return &Object{ remote: remote, main: main, size: size, f: f, chunks: chunks, } } // mainChunk returns: // - a wrapped object for non-chunked files // - meta object for chunked files with metadata // - first chunk for chunked files without metadata // Never returns nil. func (o *Object) mainChunk() fs.Object { if o.main != nil { return o.main // meta object or non-chunked wrapped file } if o.chunks != nil { return o.chunks[0] // first chunk of a chunked composite file } panic("invalid chunked object") // very unlikely } func (o *Object) isComposite() bool { return o.chunks != nil } // Fs returns read only access to the Fs that this object is part of func (o *Object) Fs() fs.Info { return o.f } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Size returns the size of the file func (o *Object) Size() int64 { if o.isComposite() { return o.size // total size of data chunks in a composite file } return o.mainChunk().Size() // size of wrapped non-chunked file } // Storable returns whether object is storable func (o *Object) Storable() bool { return o.mainChunk().Storable() } // ModTime returns the modification time of the file func (o *Object) ModTime(ctx context.Context) time.Time { return o.mainChunk().ModTime(ctx) } // SetModTime sets the modification time of the file func (o *Object) SetModTime(ctx context.Context, mtime time.Time) error { if err := o.readMetadata(ctx); err != nil { return err // refuse to act on unsupported format } return o.mainChunk().SetModTime(ctx, mtime) } // Hash returns the selected checksum of the file. // If no checksum is available it returns "". // // Hash won't fail with `unsupported` error but return empty // hash string if a particular hashsum type is not supported // // Hash takes hashsum from metadata if available or requests it // from wrapped remote for non-chunked files. // Metadata (if meta format is not 'none') is by default kept // only for composite files. In the "All" hashing mode chunker // will force metadata on all files if particular hashsum type // is not supported by wrapped remote. // // Note that Hash prefers the wrapped hashsum for non-chunked // file, then tries to read it from metadata. This in theory // handles the unusual case when a small file has been tampered // on the level of wrapped remote but chunker is unaware of that. func (o *Object) Hash(ctx context.Context, hashType hash.Type) (string, error) { if err := o.readMetadata(ctx); err != nil { return "", err // valid metadata is required to get hash, abort } if !o.isComposite() { // First, chain to the wrapped non-chunked file if possible. if value, err := o.mainChunk().Hash(ctx, hashType); err == nil && value != "" { return value, nil } } // Try hash from metadata if the file is composite or if wrapped remote fails. switch hashType { case hash.MD5: if o.md5 == "" { return "", nil } return o.md5, nil case hash.SHA1: if o.sha1 == "" { return "", nil } return o.sha1, nil default: return "", hash.ErrUnsupported } } // UnWrap returns the wrapped Object func (o *Object) UnWrap() fs.Object { return o.mainChunk() } // Open opens the file for read. Call Close() on the returned io.ReadCloser func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (rc io.ReadCloser, err error) { if err := o.readMetadata(ctx); err != nil { // refuse to open unsupported format return nil, fmt.Errorf("can't open: %w", err) } if !o.isComposite() { return o.mainChunk().Open(ctx, options...) // chain to wrapped non-chunked file } var openOptions []fs.OpenOption var offset, limit int64 = 0, -1 for _, option := range options { switch opt := option.(type) { case *fs.SeekOption: offset = opt.Offset case *fs.RangeOption: offset, limit = opt.Decode(o.size) default: // pass Options on to the wrapped open, if appropriate openOptions = append(openOptions, option) } } if offset < 0 { return nil, errors.New("invalid offset") } if limit < 0 { limit = o.size - offset } return o.newLinearReader(ctx, offset, limit, openOptions) } // linearReader opens and reads file chunks sequentially, without read-ahead type linearReader struct { ctx context.Context chunks []fs.Object options []fs.OpenOption limit int64 count int64 pos int reader io.ReadCloser err error } func (o *Object) newLinearReader(ctx context.Context, offset, limit int64, options []fs.OpenOption) (io.ReadCloser, error) { r := &linearReader{ ctx: ctx, chunks: o.chunks, options: options, limit: limit, } // skip to chunk for given offset err := io.EOF for offset >= 0 && err != nil { offset, err = r.nextChunk(offset) } if err == nil || err == io.EOF { r.err = err return r, nil } return nil, err } func (r *linearReader) nextChunk(offset int64) (int64, error) { if r.err != nil { return -1, r.err } if r.pos >= len(r.chunks) || r.limit <= 0 || offset < 0 { return -1, io.EOF } chunk := r.chunks[r.pos] count := chunk.Size() r.pos++ if offset >= count { return offset - count, io.EOF } count -= offset if r.limit < count { count = r.limit } options := append(r.options, &fs.RangeOption{Start: offset, End: offset + count - 1}) if err := r.Close(); err != nil { return -1, err } reader, err := chunk.Open(r.ctx, options...) if err != nil { return -1, err } r.reader = reader r.count = count return offset, nil } func (r *linearReader) Read(p []byte) (n int, err error) { if r.err != nil { return 0, r.err } if r.limit <= 0 { r.err = io.EOF return 0, io.EOF } for r.count <= 0 { // current chunk has been read completely or its size is zero off, err := r.nextChunk(0) if off < 0 { r.err = err return 0, err } } n, err = r.reader.Read(p) if err == nil || err == io.EOF { r.count -= int64(n) r.limit -= int64(n) if r.limit > 0 { err = nil // more data to read } } r.err = err return } func (r *linearReader) Close() (err error) { if r.reader != nil { err = r.reader.Close() r.reader = nil } return } // ObjectInfo describes a wrapped fs.ObjectInfo for being the source type ObjectInfo struct { src fs.ObjectInfo fs *Fs nChunks int // number of data chunks xactID string // transaction ID for "norename" or empty string for "renamed" chunks size int64 // overrides source size by the total size of data chunks remote string // overrides remote name md5 string // overrides MD5 checksum sha1 string // overrides SHA1 checksum } func (f *Fs) wrapInfo(src fs.ObjectInfo, newRemote string, totalSize int64) *ObjectInfo { return &ObjectInfo{ src: src, fs: f, size: totalSize, remote: newRemote, } } // Fs returns read only access to the Fs that this object is part of func (oi *ObjectInfo) Fs() fs.Info { if oi.fs == nil { panic("stub ObjectInfo") } return oi.fs } // String returns string representation func (oi *ObjectInfo) String() string { return oi.src.String() } // Storable returns whether object is storable func (oi *ObjectInfo) Storable() bool { return oi.src.Storable() } // Remote returns the remote path func (oi *ObjectInfo) Remote() string { if oi.remote != "" { return oi.remote } return oi.src.Remote() } // Size returns the size of the file func (oi *ObjectInfo) Size() int64 { if oi.size != -1 { return oi.size } return oi.src.Size() } // ModTime returns the modification time func (oi *ObjectInfo) ModTime(ctx context.Context) time.Time { return oi.src.ModTime(ctx) } // Hash returns the selected checksum of the wrapped file // It returns "" if no checksum is available or if this // info doesn't wrap the complete file. func (oi *ObjectInfo) Hash(ctx context.Context, hashType hash.Type) (string, error) { var errUnsupported error switch hashType { case hash.MD5: if oi.md5 != "" { return oi.md5, nil } case hash.SHA1: if oi.sha1 != "" { return oi.sha1, nil } default: errUnsupported = hash.ErrUnsupported } if oi.Size() != oi.src.Size() { // fail if this info wraps only a part of the file return "", errUnsupported } // chain to full source if possible value, err := oi.src.Hash(ctx, hashType) if err == hash.ErrUnsupported { return "", errUnsupported } return value, err } // ID returns the ID of the Object if known, or "" if not func (o *Object) ID() string { if doer, ok := o.mainChunk().(fs.IDer); ok { return doer.ID() } return "" } // Meta format `simplejson` type metaSimpleJSON struct { // required core fields Version *int `json:"ver"` Size *int64 `json:"size"` // total size of data chunks ChunkNum *int `json:"nchunks"` // number of data chunks // optional extra fields MD5 string `json:"md5,omitempty"` SHA1 string `json:"sha1,omitempty"` XactID string `json:"txn,omitempty"` // transaction ID for norename transactions } // marshalSimpleJSON // // Current implementation creates metadata in three cases: // - for files larger than chunk size // - if file contents can be mistaken as meta object // - if consistent hashing is On but wrapped remote can't provide given hash func marshalSimpleJSON(ctx context.Context, size int64, nChunks int, md5, sha1, xactID string) ([]byte, error) { version := metadataVersion if xactID == "" && version == 2 { version = 1 } metadata := metaSimpleJSON{ // required core fields Version: &version, Size: &size, ChunkNum: &nChunks, // optional extra fields MD5: md5, SHA1: sha1, XactID: xactID, } data, err := json.Marshal(&metadata) if err == nil && data != nil && len(data) >= maxMetadataSizeWritten { // be a nitpicker, never produce something you can't consume return nil, errors.New("metadata can't be this big, please report to rclone developers") } return data, err } // unmarshalSimpleJSON parses metadata. // // In case of errors returns a flag telling whether input has been // produced by incompatible version of rclone vs wasn't metadata at all. // Only metadata format version 1 is supported atm. // Future releases will transparently migrate older metadata objects. // New format will have a higher version number and cannot be correctly // handled by current implementation. // The version check below will then explicitly ask user to upgrade rclone. func unmarshalSimpleJSON(ctx context.Context, metaObject fs.Object, data []byte) (info *ObjectInfo, madeByChunker bool, err error) { // Be strict about JSON format // to reduce possibility that a random small file resembles metadata. if len(data) > maxMetadataSizeWritten { return nil, false, ErrMetaTooBig } if len(data) < 2 || data[0] != '{' || data[len(data)-1] != '}' { return nil, false, errors.New("invalid json") } var metadata metaSimpleJSON err = json.Unmarshal(data, &metadata) if err != nil { return nil, false, err } // Basic fields are strictly required // to reduce possibility that a random small file resembles metadata. if metadata.Version == nil || metadata.Size == nil || metadata.ChunkNum == nil { return nil, false, errors.New("missing required field") } // Perform strict checks, avoid corruption of future metadata formats. if *metadata.Version < 1 { return nil, false, errors.New("wrong version") } if *metadata.Size < 0 { return nil, false, errors.New("negative file size") } if *metadata.ChunkNum < 0 { return nil, false, errors.New("negative number of chunks") } if *metadata.ChunkNum > maxSafeChunkNumber { return nil, true, ErrChunkOverflow // produced by incompatible version of rclone } if metadata.MD5 != "" { _, err = hex.DecodeString(metadata.MD5) if len(metadata.MD5) != 32 || err != nil { return nil, false, errors.New("wrong md5 hash") } } if metadata.SHA1 != "" { _, err = hex.DecodeString(metadata.SHA1) if len(metadata.SHA1) != 40 || err != nil { return nil, false, errors.New("wrong sha1 hash") } } // ChunkNum is allowed to be 0 in future versions if *metadata.ChunkNum < 1 && *metadata.Version <= metadataVersion { return nil, false, errors.New("wrong number of chunks") } // Non-strict mode also accepts future metadata versions if *metadata.Version > metadataVersion { return nil, true, ErrMetaUnknown // produced by incompatible version of rclone } var nilFs *Fs // nil object triggers appropriate type method info = nilFs.wrapInfo(metaObject, "", *metadata.Size) info.nChunks = *metadata.ChunkNum info.md5 = metadata.MD5 info.sha1 = metadata.SHA1 info.xactID = metadata.XactID return info, true, nil } func silentlyRemove(ctx context.Context, o fs.Object) { _ = o.Remove(ctx) // ignore error } // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // String returns a description of the FS func (f *Fs) String() string { return fmt.Sprintf("Chunked '%s:%s'", f.name, f.root) } // Precision returns the precision of this Fs func (f *Fs) Precision() time.Duration { return f.base.Precision() } // CanQuickRename returns true if the Fs supports a quick rename operation func (f *Fs) CanQuickRename() bool { return f.base.Features().Move != nil } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.DirSetModTimer = (*Fs)(nil) _ fs.MkdirMetadataer = (*Fs)(nil) _ fs.PutUncheckeder = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.CleanUpper = (*Fs)(nil) _ fs.UnWrapper = (*Fs)(nil) _ fs.ListRer = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.Wrapper = (*Fs)(nil) _ fs.ChangeNotifier = (*Fs)(nil) _ fs.Shutdowner = (*Fs)(nil) _ fs.ObjectInfo = (*ObjectInfo)(nil) _ fs.Object = (*Object)(nil) _ fs.ObjectUnWrapper = (*Object)(nil) _ fs.IDer = (*Object)(nil) ) rclone-v1.71.0/backend/chunker/chunker_internal_test.go000066400000000000000000001061761505210326400232300ustar00rootroot00000000000000package chunker import ( "bytes" "context" "flag" "fmt" "io" "path" "regexp" "strings" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/fspath" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/object" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" "github.com/rclone/rclone/lib/random" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Command line flags var ( UploadKilobytes = flag.Int("upload-kilobytes", 0, "Upload size in Kilobytes, set this to test large uploads") ) // test that chunking does not break large uploads func testPutLarge(t *testing.T, f *Fs, kilobytes int) { t.Run(fmt.Sprintf("PutLarge%dk", kilobytes), func(t *testing.T) { fstests.TestPutLarge(context.Background(), t, f, &fstest.Item{ ModTime: fstest.Time("2001-02-03T04:05:06.499999999Z"), Path: fmt.Sprintf("chunker-upload-%dk", kilobytes), Size: int64(kilobytes) * int64(fs.Kibi), }) }) } type settings map[string]any func deriveFs(ctx context.Context, t *testing.T, f fs.Fs, path string, opts settings) fs.Fs { fsName := strings.Split(f.Name(), "{")[0] // strip off hash configMap := configmap.Simple{} for key, val := range opts { configMap[key] = fmt.Sprintf("%v", val) } rpath := fspath.JoinRootPath(f.Root(), path) remote := fmt.Sprintf("%s,%s:%s", fsName, configMap.String(), rpath) fixFs, err := fs.NewFs(ctx, remote) require.NoError(t, err) return fixFs } var mtime1 = fstest.Time("2001-02-03T04:05:06.499999999Z") func testPutFile(ctx context.Context, t *testing.T, f fs.Fs, name, contents, message string, check bool) fs.Object { item := fstest.Item{Path: name, ModTime: mtime1} obj := fstests.PutTestContents(ctx, t, f, &item, contents, check) assert.NotNil(t, obj, message) return obj } // test chunk name parser func testChunkNameFormat(t *testing.T, f *Fs) { saveOpt := f.opt defer func() { // restore original settings (f is pointer, f.opt is struct) f.opt = saveOpt _ = f.setChunkNameFormat(f.opt.NameFormat) }() assertFormat := func(pattern, wantDataFormat, wantCtrlFormat, wantNameRegexp string) { err := f.setChunkNameFormat(pattern) assert.NoError(t, err) assert.Equal(t, wantDataFormat, f.dataNameFmt) assert.Equal(t, wantCtrlFormat, f.ctrlNameFmt) assert.Equal(t, wantNameRegexp, f.nameRegexp.String()) } assertFormatValid := func(pattern string) { err := f.setChunkNameFormat(pattern) assert.NoError(t, err) } assertFormatInvalid := func(pattern string) { err := f.setChunkNameFormat(pattern) assert.Error(t, err) } assertMakeName := func(wantChunkName, mainName string, chunkNo int, ctrlType, xactID string) { gotChunkName := "" assert.NotPanics(t, func() { gotChunkName = f.makeChunkName(mainName, chunkNo, ctrlType, xactID) }, "makeChunkName(%q,%d,%q,%q) must not panic", mainName, chunkNo, ctrlType, xactID) if gotChunkName != "" { assert.Equal(t, wantChunkName, gotChunkName) } } assertMakeNamePanics := func(mainName string, chunkNo int, ctrlType, xactID string) { assert.Panics(t, func() { _ = f.makeChunkName(mainName, chunkNo, ctrlType, xactID) }, "makeChunkName(%q,%d,%q,%q) should panic", mainName, chunkNo, ctrlType, xactID) } assertParseName := func(fileName, wantMainName string, wantChunkNo int, wantCtrlType, wantXactID string) { gotMainName, gotChunkNo, gotCtrlType, gotXactID := f.parseChunkName(fileName) assert.Equal(t, wantMainName, gotMainName) assert.Equal(t, wantChunkNo, gotChunkNo) assert.Equal(t, wantCtrlType, gotCtrlType) assert.Equal(t, wantXactID, gotXactID) } const newFormatSupported = false // support for patterns not starting with base name (*) // valid formats assertFormat(`*.rclone_chunk.###`, `%s.rclone_chunk.%03d`, `%s.rclone_chunk._%s`, `^(.+?)\.rclone_chunk\.(?:([0-9]{3,})|_([a-z][a-z0-9]{2,6}))(?:_([0-9a-z]{4,9})|\.\.tmp_([0-9]{10,13}))?$`) assertFormat(`*.rclone_chunk.#`, `%s.rclone_chunk.%d`, `%s.rclone_chunk._%s`, `^(.+?)\.rclone_chunk\.(?:([0-9]+)|_([a-z][a-z0-9]{2,6}))(?:_([0-9a-z]{4,9})|\.\.tmp_([0-9]{10,13}))?$`) assertFormat(`*_chunk_#####`, `%s_chunk_%05d`, `%s_chunk__%s`, `^(.+?)_chunk_(?:([0-9]{5,})|_([a-z][a-z0-9]{2,6}))(?:_([0-9a-z]{4,9})|\.\.tmp_([0-9]{10,13}))?$`) assertFormat(`*-chunk-#`, `%s-chunk-%d`, `%s-chunk-_%s`, `^(.+?)-chunk-(?:([0-9]+)|_([a-z][a-z0-9]{2,6}))(?:_([0-9a-z]{4,9})|\.\.tmp_([0-9]{10,13}))?$`) assertFormat(`*-chunk-#-%^$()[]{}.+-!?:\`, `%s-chunk-%d-%%^$()[]{}.+-!?:\`, `%s-chunk-_%s-%%^$()[]{}.+-!?:\`, `^(.+?)-chunk-(?:([0-9]+)|_([a-z][a-z0-9]{2,6}))-%\^\$\(\)\[\]\{\}\.\+-!\?:\\(?:_([0-9a-z]{4,9})|\.\.tmp_([0-9]{10,13}))?$`) if newFormatSupported { assertFormat(`_*-chunk-##,`, `_%s-chunk-%02d,`, `_%s-chunk-_%s,`, `^_(.+?)-chunk-(?:([0-9]{2,})|_([a-z][a-z0-9]{2,6})),(?:_([0-9a-z]{4,9})|\.\.tmp_([0-9]{10,13}))?$`) } // invalid formats assertFormatInvalid(`chunk-#`) assertFormatInvalid(`*-chunk`) assertFormatInvalid(`*-*-chunk-#`) assertFormatInvalid(`*-chunk-#-#`) assertFormatInvalid(`#-chunk-*`) assertFormatInvalid(`*/#`) assertFormatValid(`*#`) assertFormatInvalid(`**#`) assertFormatInvalid(`#*`) assertFormatInvalid(``) assertFormatInvalid(`-`) // quick tests if newFormatSupported { assertFormat(`part_*_#`, `part_%s_%d`, `part_%s__%s`, `^part_(.+?)_(?:([0-9]+)|_([a-z][a-z0-9]{2,6}))(?:_([0-9][0-9a-z]{3,8})\.\.tmp_([0-9]{10,13}))?$`) f.opt.StartFrom = 1 assertMakeName(`part_fish_1`, "fish", 0, "", "") assertParseName(`part_fish_43`, "fish", 42, "", "") assertMakeName(`part_fish__locks`, "fish", -2, "locks", "") assertParseName(`part_fish__locks`, "fish", -1, "locks", "") assertMakeName(`part_fish__x2y`, "fish", -2, "x2y", "") assertParseName(`part_fish__x2y`, "fish", -1, "x2y", "") assertMakeName(`part_fish_3_0004`, "fish", 2, "", "4") assertParseName(`part_fish_4_0005`, "fish", 3, "", "0005") assertMakeName(`part_fish__blkinfo_jj5fvo3wr`, "fish", -3, "blkinfo", "jj5fvo3wr") assertParseName(`part_fish__blkinfo_zz9fvo3wr`, "fish", -1, "blkinfo", "zz9fvo3wr") // old-style temporary suffix (parse only) assertParseName(`part_fish_4..tmp_0000000011`, "fish", 3, "", "000b") assertParseName(`part_fish__blkinfo_jj5fvo3wr`, "fish", -1, "blkinfo", "jj5fvo3wr") } // prepare format for long tests assertFormat(`*.chunk.###`, `%s.chunk.%03d`, `%s.chunk._%s`, `^(.+?)\.chunk\.(?:([0-9]{3,})|_([a-z][a-z0-9]{2,6}))(?:_([0-9a-z]{4,9})|\.\.tmp_([0-9]{10,13}))?$`) f.opt.StartFrom = 2 // valid data chunks assertMakeName(`fish.chunk.003`, "fish", 1, "", "") assertParseName(`fish.chunk.003`, "fish", 1, "", "") assertMakeName(`fish.chunk.021`, "fish", 19, "", "") assertParseName(`fish.chunk.021`, "fish", 19, "", "") // valid temporary data chunks assertMakeName(`fish.chunk.011_4321`, "fish", 9, "", "4321") assertParseName(`fish.chunk.011_4321`, "fish", 9, "", "4321") assertMakeName(`fish.chunk.011_00bc`, "fish", 9, "", "00bc") assertParseName(`fish.chunk.011_00bc`, "fish", 9, "", "00bc") assertMakeName(`fish.chunk.1916_5jjfvo3wr`, "fish", 1914, "", "5jjfvo3wr") assertParseName(`fish.chunk.1916_5jjfvo3wr`, "fish", 1914, "", "5jjfvo3wr") assertMakeName(`fish.chunk.1917_zz9fvo3wr`, "fish", 1915, "", "zz9fvo3wr") assertParseName(`fish.chunk.1917_zz9fvo3wr`, "fish", 1915, "", "zz9fvo3wr") // valid temporary data chunks (old temporary suffix, only parse) assertParseName(`fish.chunk.004..tmp_0000000047`, "fish", 2, "", "001b") assertParseName(`fish.chunk.323..tmp_9994567890123`, "fish", 321, "", "3jjfvo3wr") // parsing invalid data chunk names assertParseName(`fish.chunk.3`, "", -1, "", "") assertParseName(`fish.chunk.001`, "", -1, "", "") assertParseName(`fish.chunk.21`, "", -1, "", "") assertParseName(`fish.chunk.-21`, "", -1, "", "") assertParseName(`fish.chunk.004abcd`, "", -1, "", "") // missing underscore delimiter assertParseName(`fish.chunk.004__1234`, "", -1, "", "") // extra underscore delimiter assertParseName(`fish.chunk.004_123`, "", -1, "", "") // too short temporary suffix assertParseName(`fish.chunk.004_1234567890`, "", -1, "", "") // too long temporary suffix assertParseName(`fish.chunk.004_-1234`, "", -1, "", "") // temporary suffix must be positive assertParseName(`fish.chunk.004_123E`, "", -1, "", "") // uppercase not allowed assertParseName(`fish.chunk.004_12.3`, "", -1, "", "") // punctuation not allowed // parsing invalid data chunk names (old temporary suffix) assertParseName(`fish.chunk.004.tmp_0000000021`, "", -1, "", "") assertParseName(`fish.chunk.003..tmp_123456789`, "", -1, "", "") assertParseName(`fish.chunk.003..tmp_012345678901234567890123456789`, "", -1, "", "") assertParseName(`fish.chunk.323..tmp_12345678901234`, "", -1, "", "") assertParseName(`fish.chunk.003..tmp_-1`, "", -1, "", "") // valid control chunks assertMakeName(`fish.chunk._info`, "fish", -1, "info", "") assertMakeName(`fish.chunk._locks`, "fish", -2, "locks", "") assertMakeName(`fish.chunk._blkinfo`, "fish", -3, "blkinfo", "") assertMakeName(`fish.chunk._x2y`, "fish", -4, "x2y", "") assertParseName(`fish.chunk._info`, "fish", -1, "info", "") assertParseName(`fish.chunk._locks`, "fish", -1, "locks", "") assertParseName(`fish.chunk._blkinfo`, "fish", -1, "blkinfo", "") assertParseName(`fish.chunk._x2y`, "fish", -1, "x2y", "") // valid temporary control chunks assertMakeName(`fish.chunk._info_0001`, "fish", -1, "info", "1") assertMakeName(`fish.chunk._locks_4321`, "fish", -2, "locks", "4321") assertMakeName(`fish.chunk._uploads_abcd`, "fish", -3, "uploads", "abcd") assertMakeName(`fish.chunk._blkinfo_xyzabcdef`, "fish", -4, "blkinfo", "xyzabcdef") assertMakeName(`fish.chunk._x2y_1aaa`, "fish", -5, "x2y", "1aaa") assertParseName(`fish.chunk._info_0001`, "fish", -1, "info", "0001") assertParseName(`fish.chunk._locks_4321`, "fish", -1, "locks", "4321") assertParseName(`fish.chunk._uploads_9abc`, "fish", -1, "uploads", "9abc") assertParseName(`fish.chunk._blkinfo_xyzabcdef`, "fish", -1, "blkinfo", "xyzabcdef") assertParseName(`fish.chunk._x2y_1aaa`, "fish", -1, "x2y", "1aaa") // valid temporary control chunks (old temporary suffix, parse only) assertParseName(`fish.chunk._info..tmp_0000000047`, "fish", -1, "info", "001b") assertParseName(`fish.chunk._locks..tmp_0000054321`, "fish", -1, "locks", "15wx") assertParseName(`fish.chunk._uploads..tmp_0000000000`, "fish", -1, "uploads", "0000") assertParseName(`fish.chunk._blkinfo..tmp_9994567890123`, "fish", -1, "blkinfo", "3jjfvo3wr") assertParseName(`fish.chunk._x2y..tmp_0000000000`, "fish", -1, "x2y", "0000") // parsing invalid control chunk names assertParseName(`fish.chunk.metadata`, "", -1, "", "") // must be prepended by underscore assertParseName(`fish.chunk.info`, "", -1, "", "") assertParseName(`fish.chunk.locks`, "", -1, "", "") assertParseName(`fish.chunk.uploads`, "", -1, "", "") assertParseName(`fish.chunk._os`, "", -1, "", "") // too short assertParseName(`fish.chunk._metadata`, "", -1, "", "") // too long assertParseName(`fish.chunk._blockinfo`, "", -1, "", "") // way too long assertParseName(`fish.chunk._4me`, "", -1, "", "") // cannot start with digit assertParseName(`fish.chunk._567`, "", -1, "", "") // cannot be all digits assertParseName(`fish.chunk._me_ta`, "", -1, "", "") // punctuation not allowed assertParseName(`fish.chunk._in-fo`, "", -1, "", "") assertParseName(`fish.chunk._.bin`, "", -1, "", "") assertParseName(`fish.chunk._.2xy`, "", -1, "", "") // parsing invalid temporary control chunks assertParseName(`fish.chunk._blkinfo1234`, "", -1, "", "") // missing underscore delimiter assertParseName(`fish.chunk._info__1234`, "", -1, "", "") // extra underscore delimiter assertParseName(`fish.chunk._info_123`, "", -1, "", "") // too short temporary suffix assertParseName(`fish.chunk._info_1234567890`, "", -1, "", "") // too long temporary suffix assertParseName(`fish.chunk._info_-1234`, "", -1, "", "") // temporary suffix must be positive assertParseName(`fish.chunk._info_123E`, "", -1, "", "") // uppercase not allowed assertParseName(`fish.chunk._info_12.3`, "", -1, "", "") // punctuation not allowed assertParseName(`fish.chunk._locks..tmp_123456789`, "", -1, "", "") assertParseName(`fish.chunk._meta..tmp_-1`, "", -1, "", "") assertParseName(`fish.chunk._blockinfo..tmp_012345678901234567890123456789`, "", -1, "", "") // short control chunk names: 3 letters ok, 1-2 letters not allowed assertMakeName(`fish.chunk._ext`, "fish", -1, "ext", "") assertParseName(`fish.chunk._int`, "fish", -1, "int", "") assertMakeNamePanics("fish", -1, "in", "") assertMakeNamePanics("fish", -1, "up", "4") assertMakeNamePanics("fish", -1, "x", "") assertMakeNamePanics("fish", -1, "c", "1z") assertMakeName(`fish.chunk._ext_0000`, "fish", -1, "ext", "0") assertMakeName(`fish.chunk._ext_0026`, "fish", -1, "ext", "26") assertMakeName(`fish.chunk._int_0abc`, "fish", -1, "int", "abc") assertMakeName(`fish.chunk._int_9xyz`, "fish", -1, "int", "9xyz") assertMakeName(`fish.chunk._out_jj5fvo3wr`, "fish", -1, "out", "jj5fvo3wr") assertMakeName(`fish.chunk._out_jj5fvo3wr`, "fish", -1, "out", "jj5fvo3wr") assertParseName(`fish.chunk._ext_0000`, "fish", -1, "ext", "0000") assertParseName(`fish.chunk._ext_0026`, "fish", -1, "ext", "0026") assertParseName(`fish.chunk._int_0abc`, "fish", -1, "int", "0abc") assertParseName(`fish.chunk._int_9xyz`, "fish", -1, "int", "9xyz") assertParseName(`fish.chunk._out_jj5fvo3wr`, "fish", -1, "out", "jj5fvo3wr") assertParseName(`fish.chunk._out_jj5fvo3wr`, "fish", -1, "out", "jj5fvo3wr") // base file name can sometimes look like a valid chunk name assertParseName(`fish.chunk.003.chunk.004`, "fish.chunk.003", 2, "", "") assertParseName(`fish.chunk.003.chunk._info`, "fish.chunk.003", -1, "info", "") assertParseName(`fish.chunk.003.chunk._Meta`, "", -1, "", "") assertParseName(`fish.chunk._info.chunk.004`, "fish.chunk._info", 2, "", "") assertParseName(`fish.chunk._info.chunk._info`, "fish.chunk._info", -1, "info", "") assertParseName(`fish.chunk._info.chunk._info.chunk._Meta`, "", -1, "", "") // base file name looking like a valid chunk name (old temporary suffix) assertParseName(`fish.chunk.003.chunk.005..tmp_0000000022`, "fish.chunk.003", 3, "", "000m") assertParseName(`fish.chunk.003.chunk._x..tmp_0000054321`, "", -1, "", "") assertParseName(`fish.chunk._info.chunk.005..tmp_0000000023`, "fish.chunk._info", 3, "", "000n") assertParseName(`fish.chunk._info.chunk._info.chunk._x..tmp_0000054321`, "", -1, "", "") assertParseName(`fish.chunk.003.chunk._blkinfo..tmp_9994567890123`, "fish.chunk.003", -1, "blkinfo", "3jjfvo3wr") assertParseName(`fish.chunk._info.chunk._blkinfo..tmp_9994567890123`, "fish.chunk._info", -1, "blkinfo", "3jjfvo3wr") assertParseName(`fish.chunk.004..tmp_0000000021.chunk.004`, "fish.chunk.004..tmp_0000000021", 2, "", "") assertParseName(`fish.chunk.004..tmp_0000000021.chunk.005..tmp_0000000025`, "fish.chunk.004..tmp_0000000021", 3, "", "000p") assertParseName(`fish.chunk.004..tmp_0000000021.chunk._info`, "fish.chunk.004..tmp_0000000021", -1, "info", "") assertParseName(`fish.chunk.004..tmp_0000000021.chunk._blkinfo..tmp_9994567890123`, "fish.chunk.004..tmp_0000000021", -1, "blkinfo", "3jjfvo3wr") assertParseName(`fish.chunk.004..tmp_0000000021.chunk._Meta`, "", -1, "", "") assertParseName(`fish.chunk.004..tmp_0000000021.chunk._x..tmp_0000054321`, "", -1, "", "") assertParseName(`fish.chunk._blkinfo..tmp_9994567890123.chunk.004`, "fish.chunk._blkinfo..tmp_9994567890123", 2, "", "") assertParseName(`fish.chunk._blkinfo..tmp_9994567890123.chunk.005..tmp_0000000026`, "fish.chunk._blkinfo..tmp_9994567890123", 3, "", "000q") assertParseName(`fish.chunk._blkinfo..tmp_9994567890123.chunk._info`, "fish.chunk._blkinfo..tmp_9994567890123", -1, "info", "") assertParseName(`fish.chunk._blkinfo..tmp_9994567890123.chunk._blkinfo..tmp_9994567890123`, "fish.chunk._blkinfo..tmp_9994567890123", -1, "blkinfo", "3jjfvo3wr") assertParseName(`fish.chunk._blkinfo..tmp_9994567890123.chunk._info.chunk._Meta`, "", -1, "", "") assertParseName(`fish.chunk._blkinfo..tmp_9994567890123.chunk._info.chunk._x..tmp_0000054321`, "", -1, "", "") assertParseName(`fish.chunk._blkinfo..tmp_1234567890123456789.chunk.004`, "fish.chunk._blkinfo..tmp_1234567890123456789", 2, "", "") assertParseName(`fish.chunk._blkinfo..tmp_1234567890123456789.chunk.005..tmp_0000000022`, "fish.chunk._blkinfo..tmp_1234567890123456789", 3, "", "000m") assertParseName(`fish.chunk._blkinfo..tmp_1234567890123456789.chunk._info`, "fish.chunk._blkinfo..tmp_1234567890123456789", -1, "info", "") assertParseName(`fish.chunk._blkinfo..tmp_1234567890123456789.chunk._blkinfo..tmp_9994567890123`, "fish.chunk._blkinfo..tmp_1234567890123456789", -1, "blkinfo", "3jjfvo3wr") assertParseName(`fish.chunk._blkinfo..tmp_1234567890123456789.chunk._info.chunk._Meta`, "", -1, "", "") assertParseName(`fish.chunk._blkinfo..tmp_1234567890123456789.chunk._info.chunk._x..tmp_0000054321`, "", -1, "", "") // attempts to make invalid chunk names assertMakeNamePanics("fish", -1, "", "") // neither data nor control assertMakeNamePanics("fish", 0, "info", "") // both data and control assertMakeNamePanics("fish", -1, "metadata", "") // control type too long assertMakeNamePanics("fish", -1, "blockinfo", "") // control type way too long assertMakeNamePanics("fish", -1, "2xy", "") // first digit not allowed assertMakeNamePanics("fish", -1, "123", "") // all digits not allowed assertMakeNamePanics("fish", -1, "Meta", "") // only lower case letters allowed assertMakeNamePanics("fish", -1, "in-fo", "") // punctuation not allowed assertMakeNamePanics("fish", -1, "_info", "") assertMakeNamePanics("fish", -1, "info_", "") assertMakeNamePanics("fish", -2, ".bind", "") assertMakeNamePanics("fish", -2, "bind.", "") assertMakeNamePanics("fish", -1, "", "1") // neither data nor control assertMakeNamePanics("fish", 0, "info", "23") // both data and control assertMakeNamePanics("fish", -1, "metadata", "45") // control type too long assertMakeNamePanics("fish", -1, "blockinfo", "7") // control type way too long assertMakeNamePanics("fish", -1, "2xy", "abc") // first digit not allowed assertMakeNamePanics("fish", -1, "123", "def") // all digits not allowed assertMakeNamePanics("fish", -1, "Meta", "mnk") // only lower case letters allowed assertMakeNamePanics("fish", -1, "in-fo", "xyz") // punctuation not allowed assertMakeNamePanics("fish", -1, "_info", "5678") assertMakeNamePanics("fish", -1, "info_", "999") assertMakeNamePanics("fish", -2, ".bind", "0") assertMakeNamePanics("fish", -2, "bind.", "0") assertMakeNamePanics("fish", 0, "", "1234567890") // temporary suffix too long assertMakeNamePanics("fish", 0, "", "123F4") // uppercase not allowed assertMakeNamePanics("fish", 0, "", "123.") // punctuation not allowed assertMakeNamePanics("fish", 0, "", "_123") } func testSmallFileInternals(t *testing.T, f *Fs) { const dir = "small" ctx := context.Background() saveOpt := f.opt defer func() { f.opt.FailHard = false _ = operations.Purge(ctx, f.base, dir) f.opt = saveOpt }() f.opt.FailHard = false modTime := fstest.Time("2001-02-03T04:05:06.499999999Z") checkSmallFileInternals := func(obj fs.Object) { assert.NotNil(t, obj) o, ok := obj.(*Object) assert.True(t, ok) assert.NotNil(t, o) if o == nil { return } switch { case !f.useMeta: // If meta format is "none", non-chunked file (even empty) // internally is a single chunk without meta object. assert.Nil(t, o.main) assert.True(t, o.isComposite()) // sorry, sometimes a name is misleading assert.Equal(t, 1, len(o.chunks)) case f.hashAll: // Consistent hashing forces meta object on small files too assert.NotNil(t, o.main) assert.True(t, o.isComposite()) assert.Equal(t, 1, len(o.chunks)) default: // normally non-chunked file is kept in the Object's main field assert.NotNil(t, o.main) assert.False(t, o.isComposite()) assert.Equal(t, 0, len(o.chunks)) } } checkContents := func(obj fs.Object, contents string) { assert.NotNil(t, obj) assert.Equal(t, int64(len(contents)), obj.Size()) r, err := obj.Open(ctx) assert.NoError(t, err) assert.NotNil(t, r) if r == nil { return } data, err := io.ReadAll(r) assert.NoError(t, err) assert.Equal(t, contents, string(data)) _ = r.Close() } checkHashsum := func(obj fs.Object) { var ht hash.Type switch { case !f.hashAll: return case f.useMD5: ht = hash.MD5 case f.useSHA1: ht = hash.SHA1 default: return } // even empty files must have hashsum in consistent mode sum, err := obj.Hash(ctx, ht) assert.NoError(t, err) assert.NotEqual(t, sum, "") } checkSmallFile := func(name, contents string) { filename := path.Join(dir, name) item := fstest.Item{Path: filename, ModTime: modTime} put := fstests.PutTestContents(ctx, t, f, &item, contents, false) assert.NotNil(t, put) checkSmallFileInternals(put) checkContents(put, contents) checkHashsum(put) // objects returned by Put and NewObject must have similar structure obj, err := f.NewObject(ctx, filename) assert.NoError(t, err) assert.NotNil(t, obj) checkSmallFileInternals(obj) checkContents(obj, contents) checkHashsum(obj) _ = obj.Remove(ctx) _ = put.Remove(ctx) // for good } checkSmallFile("emptyfile", "") checkSmallFile("smallfile", "Ok") } func testPreventCorruption(t *testing.T, f *Fs) { if f.opt.ChunkSize > 50 { t.Skip("this test requires small chunks") } const dir = "corrupted" ctx := context.Background() saveOpt := f.opt defer func() { f.opt.FailHard = false _ = operations.Purge(ctx, f.base, dir) f.opt = saveOpt }() f.opt.FailHard = true contents := random.String(250) modTime := fstest.Time("2001-02-03T04:05:06.499999999Z") const overlapMessage = "chunk overlap" assertOverlapError := func(err error) { assert.Error(t, err) if err != nil { assert.Contains(t, err.Error(), overlapMessage) } } newFile := func(name string) fs.Object { item := fstest.Item{Path: path.Join(dir, name), ModTime: modTime} obj := fstests.PutTestContents(ctx, t, f, &item, contents, true) require.NotNil(t, obj) return obj } billyObj := newFile("billy") billyTxn := billyObj.(*Object).xactID if f.useNoRename { require.True(t, billyTxn != "") } else { require.True(t, billyTxn == "") } billyChunkName := func(chunkNo int) string { return f.makeChunkName(billyObj.Remote(), chunkNo, "", billyTxn) } err := f.Mkdir(ctx, billyChunkName(1)) assertOverlapError(err) _, err = f.Move(ctx, newFile("silly1"), billyChunkName(2)) assert.Error(t, err) assert.True(t, err == fs.ErrorCantMove || (err != nil && strings.Contains(err.Error(), overlapMessage))) _, err = f.Copy(ctx, newFile("silly2"), billyChunkName(3)) assert.Error(t, err) assert.True(t, err == fs.ErrorCantCopy || (err != nil && strings.Contains(err.Error(), overlapMessage))) // accessing chunks in strict mode is prohibited f.opt.FailHard = true billyChunk4Name := billyChunkName(4) _, err = f.base.NewObject(ctx, billyChunk4Name) require.NoError(t, err) _, err = f.NewObject(ctx, billyChunk4Name) assertOverlapError(err) f.opt.FailHard = false billyChunk4, err := f.NewObject(ctx, billyChunk4Name) assert.NoError(t, err) require.NotNil(t, billyChunk4) f.opt.FailHard = true _, err = f.Put(ctx, bytes.NewBufferString(contents), billyChunk4) assertOverlapError(err) // you can freely read chunks (if you have an object) r, err := billyChunk4.Open(ctx) assert.NoError(t, err) var chunkContents []byte assert.NotPanics(t, func() { chunkContents, err = io.ReadAll(r) _ = r.Close() }) assert.NoError(t, err) assert.NotEqual(t, contents, string(chunkContents)) // but you can't change them err = billyChunk4.Update(ctx, bytes.NewBufferString(contents), newFile("silly3")) assertOverlapError(err) // Remove isn't special, you can't corrupt files even if you have an object err = billyChunk4.Remove(ctx) assertOverlapError(err) // recreate billy in case it was anyhow corrupted willyObj := newFile("willy") willyTxn := willyObj.(*Object).xactID willyChunkName := f.makeChunkName(willyObj.Remote(), 1, "", willyTxn) f.opt.FailHard = false willyChunk, err := f.NewObject(ctx, willyChunkName) f.opt.FailHard = true assert.NoError(t, err) require.NotNil(t, willyChunk) _, err = operations.Copy(ctx, f, willyChunk, willyChunkName, newFile("silly4")) assertOverlapError(err) // operations.Move will return error when chunker's Move refused // to corrupt target file, but reverts to copy/delete method // still trying to delete target chunk. Chunker must come to rescue. _, err = operations.Move(ctx, f, willyChunk, willyChunkName, newFile("silly5")) assertOverlapError(err) r, err = willyChunk.Open(ctx) assert.NoError(t, err) assert.NotPanics(t, func() { _, err = io.ReadAll(r) _ = r.Close() }) assert.NoError(t, err) } func testChunkNumberOverflow(t *testing.T, f *Fs) { if f.opt.ChunkSize > 50 { t.Skip("this test requires small chunks") } const dir = "wreaked" const wreakNumber = 10200300 ctx := context.Background() saveOpt := f.opt defer func() { f.opt.FailHard = false _ = operations.Purge(ctx, f.base, dir) f.opt = saveOpt }() modTime := fstest.Time("2001-02-03T04:05:06.499999999Z") contents := random.String(100) newFile := func(f fs.Fs, name string) (obj fs.Object, filename string, txnID string) { filename = path.Join(dir, name) item := fstest.Item{Path: filename, ModTime: modTime} obj = fstests.PutTestContents(ctx, t, f, &item, contents, true) require.NotNil(t, obj) if chunkObj, isChunkObj := obj.(*Object); isChunkObj { txnID = chunkObj.xactID } return } f.opt.FailHard = false file, fileName, fileTxn := newFile(f, "wreaker") wreak, _, _ := newFile(f.base, f.makeChunkName("wreaker", wreakNumber, "", fileTxn)) f.opt.FailHard = false fstest.CheckListingWithRoot(t, f, dir, nil, nil, f.Precision()) _, err := f.NewObject(ctx, fileName) assert.Error(t, err) f.opt.FailHard = true _, err = f.List(ctx, dir) assert.Error(t, err) _, err = f.NewObject(ctx, fileName) assert.Error(t, err) f.opt.FailHard = false _ = wreak.Remove(ctx) _ = file.Remove(ctx) } func testMetadataInput(t *testing.T, f *Fs) { const minChunkForTest = 50 if f.opt.ChunkSize < minChunkForTest { t.Skip("this test requires chunks that fit metadata") } const dir = "usermeta" ctx := context.Background() saveOpt := f.opt defer func() { f.opt.FailHard = false _ = operations.Purge(ctx, f.base, dir) f.opt = saveOpt }() f.opt.FailHard = false runSubtest := func(contents, name string) { description := fmt.Sprintf("file with %s metadata", name) filename := path.Join(dir, name) require.True(t, len(contents) > 2 && len(contents) < minChunkForTest, description+" test data is correct") part := testPutFile(ctx, t, f.base, f.makeChunkName(filename, 0, "", ""), "oops", "", true) _ = testPutFile(ctx, t, f, filename, contents, "upload "+description, false) obj, err := f.NewObject(ctx, filename) assert.NoError(t, err, "access "+description) assert.NotNil(t, obj) assert.Equal(t, int64(len(contents)), obj.Size(), "size "+description) o, ok := obj.(*Object) assert.NotNil(t, ok) if o != nil { assert.True(t, o.isComposite() && len(o.chunks) == 1, description+" is forced composite") o = nil } defer func() { _ = obj.Remove(ctx) _ = part.Remove(ctx) }() r, err := obj.Open(ctx) assert.NoError(t, err, "open "+description) assert.NotNil(t, r, "open stream of "+description) if err == nil && r != nil { data, err := io.ReadAll(r) assert.NoError(t, err, "read all of "+description) assert.Equal(t, contents, string(data), description+" contents is ok") _ = r.Close() } } metaData, err := marshalSimpleJSON(ctx, 3, 1, "", "", "") require.NoError(t, err) todaysMeta := string(metaData) runSubtest(todaysMeta, "today") pastMeta := regexp.MustCompile(`"ver":[0-9]+`).ReplaceAllLiteralString(todaysMeta, `"ver":1`) pastMeta = regexp.MustCompile(`"size":[0-9]+`).ReplaceAllLiteralString(pastMeta, `"size":0`) runSubtest(pastMeta, "past") futureMeta := regexp.MustCompile(`"ver":[0-9]+`).ReplaceAllLiteralString(todaysMeta, `"ver":999`) futureMeta = regexp.MustCompile(`"nchunks":[0-9]+`).ReplaceAllLiteralString(futureMeta, `"nchunks":0,"x":"y"`) runSubtest(futureMeta, "future") } // Test that chunker refuses to change on objects with future/unknown metadata func testFutureProof(t *testing.T, f *Fs) { if !f.useMeta { t.Skip("this test requires metadata support") } saveOpt := f.opt ctx := context.Background() f.opt.FailHard = true const dir = "future" const file = dir + "/test" defer func() { f.opt.FailHard = false _ = operations.Purge(ctx, f.base, dir) f.opt = saveOpt }() modTime := fstest.Time("2001-02-03T04:05:06.499999999Z") putPart := func(name string, part int, data, msg string) { if part > 0 { name = f.makeChunkName(name, part-1, "", "") } item := fstest.Item{Path: name, ModTime: modTime} obj := fstests.PutTestContents(ctx, t, f.base, &item, data, true) assert.NotNil(t, obj, msg) } // simulate chunked object from future meta := `{"ver":999,"nchunks":3,"size":9,"garbage":"litter","sha1":"0707f2970043f9f7c22029482db27733deaec029"}` putPart(file, 0, meta, "metaobject") putPart(file, 1, "abc", "chunk1") putPart(file, 2, "def", "chunk2") putPart(file, 3, "ghi", "chunk3") // List should succeed ls, err := f.List(ctx, dir) assert.NoError(t, err) assert.Equal(t, 1, len(ls)) assert.Equal(t, int64(9), ls[0].Size()) // NewObject should succeed obj, err := f.NewObject(ctx, file) assert.NoError(t, err) assert.Equal(t, file, obj.Remote()) assert.Equal(t, int64(9), obj.Size()) // Hash must fail _, err = obj.Hash(ctx, hash.SHA1) assert.Equal(t, ErrMetaUnknown, err) // Move must fail mobj, err := operations.Move(ctx, f, nil, file+"2", obj) assert.Nil(t, mobj) assert.Error(t, err) if err != nil { assert.Contains(t, err.Error(), "please upgrade rclone") } // Put must fail oi := object.NewStaticObjectInfo(file, modTime, 3, true, nil, nil) buf := bytes.NewBufferString("abc") _, err = f.Put(ctx, buf, oi) assert.Error(t, err) // Rcat must fail in := io.NopCloser(bytes.NewBufferString("abc")) robj, err := operations.Rcat(ctx, f, file, in, modTime, nil) assert.Nil(t, robj) assert.NotNil(t, err) if err != nil { assert.Contains(t, err.Error(), "please upgrade rclone") } } // The newer method of doing transactions without renaming should still be able to correctly process chunks that were created with renaming // If you attempt to do the inverse, however, the data chunks will be ignored causing commands to perform incorrectly func testBackwardsCompatibility(t *testing.T, f *Fs) { if !f.useMeta { t.Skip("Can't do norename transactions without metadata") } const dir = "backcomp" ctx := context.Background() saveOpt := f.opt saveUseNoRename := f.useNoRename defer func() { f.opt.FailHard = false _ = operations.Purge(ctx, f.base, dir) f.opt = saveOpt f.useNoRename = saveUseNoRename }() f.opt.ChunkSize = fs.SizeSuffix(10) modTime := fstest.Time("2001-02-03T04:05:06.499999999Z") contents := random.String(250) newFile := func(f fs.Fs, name string) (fs.Object, string) { filename := path.Join(dir, name) item := fstest.Item{Path: filename, ModTime: modTime} obj := fstests.PutTestContents(ctx, t, f, &item, contents, true) require.NotNil(t, obj) return obj, filename } f.opt.FailHard = false f.useNoRename = false file, fileName := newFile(f, "renamefile") f.opt.FailHard = false item := fstest.NewItem(fileName, contents, modTime) var items []fstest.Item items = append(items, item) f.useNoRename = true fstest.CheckListingWithRoot(t, f, dir, items, nil, f.Precision()) _, err := f.NewObject(ctx, fileName) assert.NoError(t, err) f.opt.FailHard = true _, err = f.List(ctx, dir) assert.NoError(t, err) f.opt.FailHard = false _ = file.Remove(ctx) } func testChunkerServerSideMove(t *testing.T, f *Fs) { if !f.useMeta { t.Skip("Can't test norename transactions without metadata") } ctx := context.Background() const dir = "servermovetest" subRemote := fmt.Sprintf("%s:%s/%s", f.Name(), f.Root(), dir) subFs1, err := fs.NewFs(ctx, subRemote+"/subdir1") assert.NoError(t, err) fs1, isChunkerFs := subFs1.(*Fs) assert.True(t, isChunkerFs) fs1.useNoRename = false fs1.opt.ChunkSize = fs.SizeSuffix(3) subFs2, err := fs.NewFs(ctx, subRemote+"/subdir2") assert.NoError(t, err) fs2, isChunkerFs := subFs2.(*Fs) assert.True(t, isChunkerFs) fs2.useNoRename = true fs2.opt.ChunkSize = fs.SizeSuffix(3) modTime := fstest.Time("2001-02-03T04:05:06.499999999Z") item := fstest.Item{Path: "movefile", ModTime: modTime} contents := "abcdef" file := fstests.PutTestContents(ctx, t, fs1, &item, contents, true) dstOverwritten, _ := fs2.NewObject(ctx, "movefile") dstFile, err := operations.Move(ctx, fs2, dstOverwritten, "movefile", file) assert.NoError(t, err) assert.Equal(t, int64(len(contents)), dstFile.Size()) r, err := dstFile.Open(ctx) assert.NoError(t, err) assert.NotNil(t, r) data, err := io.ReadAll(r) assert.NoError(t, err) assert.Equal(t, contents, string(data)) _ = r.Close() _ = operations.Purge(ctx, f.base, dir) } // Test that md5all creates metadata even for small files func testMD5AllSlow(t *testing.T, f *Fs) { ctx := context.Background() fsResult := deriveFs(ctx, t, f, "md5all", settings{ "chunk_size": "1P", "name_format": "*.#", "hash_type": "md5all", "transactions": "rename", "meta_format": "simplejson", }) chunkFs, ok := fsResult.(*Fs) require.True(t, ok, "fs must be a chunker remote") baseFs := chunkFs.base if !baseFs.Features().SlowHash { t.Skipf("this test needs a base fs with slow hash, e.g. local") } assert.True(t, chunkFs.useMD5, "must use md5") assert.True(t, chunkFs.hashAll, "must hash all files") _ = testPutFile(ctx, t, chunkFs, "file", "-", "error", true) obj, err := chunkFs.NewObject(ctx, "file") require.NoError(t, err) sum, err := obj.Hash(ctx, hash.MD5) assert.NoError(t, err) assert.Equal(t, "336d5ebc5436534e61d16e63ddfca327", sum) list, err := baseFs.List(ctx, "") require.NoError(t, err) assert.Equal(t, 2, len(list)) _, err = baseFs.NewObject(ctx, "file") assert.NoError(t, err, "metadata must be created") _, err = baseFs.NewObject(ctx, "file.1") assert.NoError(t, err, "first chunk must be created") require.NoError(t, operations.Purge(ctx, baseFs, "")) } // InternalTest dispatches all internal tests func (f *Fs) InternalTest(t *testing.T) { t.Run("PutLarge", func(t *testing.T) { if *UploadKilobytes <= 0 { t.Skip("-upload-kilobytes is not set") } testPutLarge(t, f, *UploadKilobytes) }) t.Run("ChunkNameFormat", func(t *testing.T) { testChunkNameFormat(t, f) }) t.Run("SmallFileInternals", func(t *testing.T) { testSmallFileInternals(t, f) }) t.Run("PreventCorruption", func(t *testing.T) { testPreventCorruption(t, f) }) t.Run("ChunkNumberOverflow", func(t *testing.T) { testChunkNumberOverflow(t, f) }) t.Run("MetadataInput", func(t *testing.T) { testMetadataInput(t, f) }) t.Run("FutureProof", func(t *testing.T) { testFutureProof(t, f) }) t.Run("BackwardsCompatibility", func(t *testing.T) { testBackwardsCompatibility(t, f) }) t.Run("ChunkerServerSideMove", func(t *testing.T) { testChunkerServerSideMove(t, f) }) t.Run("MD5AllSlow", func(t *testing.T) { testMD5AllSlow(t, f) }) } var _ fstests.InternalTester = (*Fs)(nil) rclone-v1.71.0/backend/chunker/chunker_test.go000066400000000000000000000035231505210326400213240ustar00rootroot00000000000000// Test the Chunker filesystem interface package chunker_test import ( "flag" "os" "path/filepath" "testing" _ "github.com/rclone/rclone/backend/all" // for integration tests "github.com/rclone/rclone/backend/chunker" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" ) // Command line flags var ( // Invalid characters are not supported by some remotes, e.g. Mailru. // We enable testing with invalid characters when -remote is not set, so // chunker overlays a local directory, but invalid characters are disabled // by default when -remote is set, e.g. when test_all runs backend tests. // You can still test with invalid characters using the below flag. UseBadChars = flag.Bool("bad-chars", false, "Set to test bad characters in file names when -remote is set") ) // TestIntegration runs integration tests against a concrete remote // set by the -remote flag. If the flag is not set, it creates a // dynamic chunker overlay wrapping a local temporary directory. func TestIntegration(t *testing.T) { opt := fstests.Opt{ RemoteName: *fstest.RemoteName, NilObject: (*chunker.Object)(nil), SkipBadWindowsCharacters: !*UseBadChars, UnimplementableObjectMethods: []string{ "MimeType", "GetTier", "SetTier", "Metadata", "SetMetadata", }, UnimplementableFsMethods: []string{ "PublicLink", "OpenWriterAt", "OpenChunkWriter", "MergeDirs", "DirCacheFlush", "UserInfo", "Disconnect", "ListP", }, } if *fstest.RemoteName == "" { name := "TestChunker" opt.RemoteName = name + ":" tempDir := filepath.Join(os.TempDir(), "rclone-chunker-test-standard") opt.ExtraConfig = []fstests.ExtraConfigItem{ {Name: name, Key: "type", Value: "chunker"}, {Name: name, Key: "remote", Value: tempDir}, } opt.QuickTestOK = true } fstests.Run(t, &opt) } rclone-v1.71.0/backend/cloudinary/000077500000000000000000000000001505210326400170065ustar00rootroot00000000000000rclone-v1.71.0/backend/cloudinary/api/000077500000000000000000000000001505210326400175575ustar00rootroot00000000000000rclone-v1.71.0/backend/cloudinary/api/types.go000066400000000000000000000030201505210326400212450ustar00rootroot00000000000000// Package api has type definitions for cloudinary package api import ( "fmt" ) // CloudinaryEncoder extends the built-in encoder type CloudinaryEncoder interface { // FromStandardPath takes a / separated path in Standard encoding // and converts it to a / separated path in this encoding. FromStandardPath(string) string // FromStandardName takes name in Standard encoding and converts // it in this encoding. FromStandardName(string) string // ToStandardPath takes a / separated path in this encoding // and converts it to a / separated path in Standard encoding. ToStandardPath(string) string // ToStandardName takes name in this encoding and converts // it in Standard encoding. ToStandardName(string, string) string // Encoded root of the remote (as passed into NewFs) FromStandardFullPath(string) string } // UpdateOptions was created to pass options from Update to Put type UpdateOptions struct { PublicID string ResourceType string DeliveryType string AssetFolder string DisplayName string } // Header formats the option as a string func (o *UpdateOptions) Header() (string, string) { return "UpdateOption", fmt.Sprintf("%s/%s/%s", o.ResourceType, o.DeliveryType, o.PublicID) } // Mandatory returns whether the option must be parsed or can be ignored func (o *UpdateOptions) Mandatory() bool { return false } // String formats the option into human-readable form func (o *UpdateOptions) String() string { return fmt.Sprintf("Fully qualified Public ID: %s/%s/%s", o.ResourceType, o.DeliveryType, o.PublicID) } rclone-v1.71.0/backend/cloudinary/cloudinary.go000066400000000000000000000525051505210326400215150ustar00rootroot00000000000000// Package cloudinary provides an interface to the Cloudinary DAM package cloudinary import ( "context" "encoding/hex" "errors" "fmt" "io" "net/http" "net/url" "path" "slices" "strconv" "strings" "time" "github.com/cloudinary/cloudinary-go/v2" SDKApi "github.com/cloudinary/cloudinary-go/v2/api" "github.com/cloudinary/cloudinary-go/v2/api/admin" "github.com/cloudinary/cloudinary-go/v2/api/admin/search" "github.com/cloudinary/cloudinary-go/v2/api/uploader" "github.com/rclone/rclone/backend/cloudinary/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/rest" "github.com/zeebo/blake3" ) // Cloudinary shouldn't have a trailing dot if there is no path func cldPathDir(somePath string) string { if somePath == "" || somePath == "." { return somePath } dir := path.Dir(somePath) if dir == "." { return "" } return dir } // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "cloudinary", Description: "Cloudinary", NewFs: NewFs, Options: []fs.Option{ { Name: "cloud_name", Help: "Cloudinary Environment Name", Required: true, Sensitive: true, }, { Name: "api_key", Help: "Cloudinary API Key", Required: true, Sensitive: true, }, { Name: "api_secret", Help: "Cloudinary API Secret", Required: true, Sensitive: true, }, { Name: "upload_prefix", Help: "Specify the API endpoint for environments out of the US", }, { Name: "upload_preset", Help: "Upload Preset to select asset manipulation on upload", }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: (encoder.Base | // Slash,LtGt,DoubleQuote,Question,Asterisk,Pipe,Hash,Percent,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot encoder.EncodeSlash | encoder.EncodeLtGt | encoder.EncodeDoubleQuote | encoder.EncodeQuestion | encoder.EncodeAsterisk | encoder.EncodePipe | encoder.EncodeHash | encoder.EncodePercent | encoder.EncodeBackSlash | encoder.EncodeDel | encoder.EncodeCtl | encoder.EncodeRightSpace | encoder.EncodeInvalidUtf8 | encoder.EncodeDot), }, { Name: "eventually_consistent_delay", Default: fs.Duration(0), Advanced: true, Help: "Wait N seconds for eventual consistency of the databases that support the backend operation", }, { Name: "adjust_media_files_extensions", Default: true, Advanced: true, Help: "Cloudinary handles media formats as a file attribute and strips it from the name, which is unlike most other file systems", }, { Name: "media_extensions", Default: []string{ "3ds", "3g2", "3gp", "ai", "arw", "avi", "avif", "bmp", "bw", "cr2", "cr3", "djvu", "dng", "eps3", "fbx", "flif", "flv", "gif", "glb", "gltf", "hdp", "heic", "heif", "ico", "indd", "jp2", "jpe", "jpeg", "jpg", "jxl", "jxr", "m2ts", "mov", "mp4", "mpeg", "mts", "mxf", "obj", "ogv", "pdf", "ply", "png", "psd", "svg", "tga", "tif", "tiff", "ts", "u3ma", "usdz", "wdp", "webm", "webp", "wmv"}, Advanced: true, Help: "Cloudinary supported media extensions", }, }, }) } // Options defines the configuration for this backend type Options struct { CloudName string `config:"cloud_name"` APIKey string `config:"api_key"` APISecret string `config:"api_secret"` UploadPrefix string `config:"upload_prefix"` UploadPreset string `config:"upload_preset"` Enc encoder.MultiEncoder `config:"encoding"` EventuallyConsistentDelay fs.Duration `config:"eventually_consistent_delay"` MediaExtensions []string `config:"media_extensions"` AdjustMediaFilesExtensions bool `config:"adjust_media_files_extensions"` } // Fs represents a remote cloudinary server type Fs struct { name string root string opt Options features *fs.Features pacer *fs.Pacer srv *rest.Client // For downloading assets via the Cloudinary CDN cld *cloudinary.Cloudinary // API calls are going through the Cloudinary SDK lastCRUD time.Time } // Object describes a cloudinary object type Object struct { fs *Fs remote string size int64 modTime time.Time url string md5sum string publicID string resourceType string deliveryType string } // NewFs constructs an Fs from the path, bucket:path func NewFs(ctx context.Context, name string, root string, m configmap.Mapper) (fs.Fs, error) { opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } // Initialize the Cloudinary client cld, err := cloudinary.NewFromParams(opt.CloudName, opt.APIKey, opt.APISecret) if err != nil { return nil, fmt.Errorf("failed to create Cloudinary client: %w", err) } cld.Admin.Client = *fshttp.NewClient(ctx) cld.Upload.Client = *fshttp.NewClient(ctx) if opt.UploadPrefix != "" { cld.Config.API.UploadPrefix = opt.UploadPrefix } client := fshttp.NewClient(ctx) f := &Fs{ name: name, root: root, opt: *opt, cld: cld, pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(1000), pacer.MaxSleep(10000), pacer.DecayConstant(2))), srv: rest.NewClient(client), } f.features = (&fs.Features{ CanHaveEmptyDirectories: true, }).Fill(ctx, f) if root != "" { // Check to see if the root actually an existing file remote := path.Base(root) f.root = cldPathDir(root) _, err := f.NewObject(ctx, remote) if err != nil { if err == fs.ErrorObjectNotFound || errors.Is(err, fs.ErrorNotAFile) { // File doesn't exist so return the previous root f.root = root return f, nil } return nil, err } // return an error with an fs which points to the parent return f, fs.ErrorIsFile } return f, nil } // ------------------------------------------------------------ // FromStandardPath implementation of the api.CloudinaryEncoder func (f *Fs) FromStandardPath(s string) string { return strings.ReplaceAll(f.opt.Enc.FromStandardPath(s), "&", "\uFF06") } // FromStandardName implementation of the api.CloudinaryEncoder func (f *Fs) FromStandardName(s string) string { if f.opt.AdjustMediaFilesExtensions { parsedURL, err := url.Parse(s) ext := "" if err != nil { fs.Logf(nil, "Error parsing URL: %v", err) } else { ext = path.Ext(parsedURL.Path) if slices.Contains(f.opt.MediaExtensions, strings.ToLower(strings.TrimPrefix(ext, "."))) { s = strings.TrimSuffix(parsedURL.Path, ext) } } } return strings.ReplaceAll(f.opt.Enc.FromStandardName(s), "&", "\uFF06") } // ToStandardPath implementation of the api.CloudinaryEncoder func (f *Fs) ToStandardPath(s string) string { return strings.ReplaceAll(f.opt.Enc.ToStandardPath(s), "\uFF06", "&") } // ToStandardName implementation of the api.CloudinaryEncoder func (f *Fs) ToStandardName(s string, assetURL string) string { ext := "" if f.opt.AdjustMediaFilesExtensions { parsedURL, err := url.Parse(assetURL) if err != nil { fs.Logf(nil, "Error parsing URL: %v", err) } else { ext = path.Ext(parsedURL.Path) if !slices.Contains(f.opt.MediaExtensions, strings.ToLower(strings.TrimPrefix(ext, "."))) { ext = "" } } } return strings.ReplaceAll(f.opt.Enc.ToStandardName(s), "\uFF06", "&") + ext } // FromStandardFullPath encodes a full path to Cloudinary standard func (f *Fs) FromStandardFullPath(dir string) string { return path.Join(api.CloudinaryEncoder.FromStandardPath(f, f.root), api.CloudinaryEncoder.FromStandardPath(f, dir)) } // ToAssetFolderAPI encodes folders as expected by the Cloudinary SDK func (f *Fs) ToAssetFolderAPI(dir string) string { return strings.ReplaceAll(dir, "%", "%25") } // ToDisplayNameElastic encodes a special case of elasticsearch func (f *Fs) ToDisplayNameElastic(dir string) string { return strings.ReplaceAll(dir, "!", "\\!") } // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // WaitEventuallyConsistent waits till the FS is eventually consistent func (f *Fs) WaitEventuallyConsistent() { if f.opt.EventuallyConsistentDelay == fs.Duration(0) { return } delay := time.Duration(f.opt.EventuallyConsistentDelay) timeSinceLastCRUD := time.Since(f.lastCRUD) if timeSinceLastCRUD < delay { time.Sleep(delay - timeSinceLastCRUD) } } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("Cloudinary root '%s'", f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // List the objects and directories in dir into entries func (f *Fs) List(ctx context.Context, dir string) (fs.DirEntries, error) { remotePrefix := f.FromStandardFullPath(dir) if remotePrefix != "" && !strings.HasSuffix(remotePrefix, "/") { remotePrefix += "/" } var entries fs.DirEntries dirs := make(map[string]struct{}) nextCursor := "" f.WaitEventuallyConsistent() for { // user the folders api to list folders. folderParams := admin.SubFoldersParams{ Folder: f.ToAssetFolderAPI(remotePrefix), MaxResults: 500, } if nextCursor != "" { folderParams.NextCursor = nextCursor } results, err := f.cld.Admin.SubFolders(ctx, folderParams) if err != nil { return nil, fmt.Errorf("failed to list sub-folders: %w", err) } if results.Error.Message != "" { if strings.HasPrefix(results.Error.Message, "Can't find folder with path") { return nil, fs.ErrorDirNotFound } return nil, fmt.Errorf("failed to list sub-folders: %s", results.Error.Message) } for _, folder := range results.Folders { relativePath := api.CloudinaryEncoder.ToStandardPath(f, strings.TrimPrefix(folder.Path, remotePrefix)) parts := strings.Split(relativePath, "/") // It's a directory dirName := parts[len(parts)-1] if _, found := dirs[dirName]; !found { d := fs.NewDir(path.Join(dir, dirName), time.Time{}) entries = append(entries, d) dirs[dirName] = struct{}{} } } // Break if there are no more results if results.NextCursor == "" { break } nextCursor = results.NextCursor } for { // Use the assets.AssetsByAssetFolder API to list assets assetsParams := admin.AssetsByAssetFolderParams{ AssetFolder: remotePrefix, MaxResults: 500, } if nextCursor != "" { assetsParams.NextCursor = nextCursor } results, err := f.cld.Admin.AssetsByAssetFolder(ctx, assetsParams) if err != nil { return nil, fmt.Errorf("failed to list assets: %w", err) } for _, asset := range results.Assets { remote := path.Join(dir, api.CloudinaryEncoder.ToStandardName(f, asset.DisplayName, asset.SecureURL)) o := &Object{ fs: f, remote: remote, size: int64(asset.Bytes), modTime: asset.CreatedAt, url: asset.SecureURL, publicID: asset.PublicID, resourceType: asset.AssetType, deliveryType: asset.Type, } entries = append(entries, o) } // Break if there are no more results if results.NextCursor == "" { break } nextCursor = results.NextCursor } return entries, nil } // NewObject finds the Object at remote. If it can't be found it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { searchParams := search.Query{ Expression: fmt.Sprintf("asset_folder:\"%s\" AND display_name:\"%s\"", f.FromStandardFullPath(cldPathDir(remote)), f.ToDisplayNameElastic(api.CloudinaryEncoder.FromStandardName(f, path.Base(remote)))), SortBy: []search.SortByField{{"uploaded_at": "desc"}}, MaxResults: 2, } var results *admin.SearchResult f.WaitEventuallyConsistent() err := f.pacer.Call(func() (bool, error) { var err1 error results, err1 = f.cld.Admin.Search(ctx, searchParams) if err1 == nil && results.TotalCount != len(results.Assets) { err1 = errors.New("partial response so waiting for eventual consistency") } return shouldRetry(ctx, nil, err1) }) if err != nil { return nil, fs.ErrorObjectNotFound } if results.TotalCount == 0 || len(results.Assets) == 0 { return nil, fs.ErrorObjectNotFound } asset := results.Assets[0] o := &Object{ fs: f, remote: remote, size: int64(asset.Bytes), modTime: asset.UploadedAt, url: asset.SecureURL, md5sum: asset.Etag, publicID: asset.PublicID, resourceType: asset.ResourceType, deliveryType: asset.Type, } return o, nil } func (f *Fs) getSuggestedPublicID(assetFolder string, displayName string, modTime time.Time) string { payload := []byte(path.Join(assetFolder, displayName)) hash := blake3.Sum256(payload) return hex.EncodeToString(hash[:]) } // Put uploads content to Cloudinary func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { if src.Size() == 0 { return nil, fs.ErrorCantUploadEmptyFiles } params := uploader.UploadParams{ UploadPreset: f.opt.UploadPreset, } updateObject := false var modTime time.Time for _, option := range options { if updateOptions, ok := option.(*api.UpdateOptions); ok { if updateOptions.PublicID != "" { updateObject = true params.Overwrite = SDKApi.Bool(true) params.Invalidate = SDKApi.Bool(true) params.PublicID = updateOptions.PublicID params.ResourceType = updateOptions.ResourceType params.Type = SDKApi.DeliveryType(updateOptions.DeliveryType) params.AssetFolder = updateOptions.AssetFolder params.DisplayName = updateOptions.DisplayName modTime = src.ModTime(ctx) } } } if !updateObject { params.AssetFolder = f.FromStandardFullPath(cldPathDir(src.Remote())) params.DisplayName = api.CloudinaryEncoder.FromStandardName(f, path.Base(src.Remote())) // We want to conform to the unique asset ID of rclone, which is (asset_folder,display_name,last_modified). // We also want to enable customers to choose their own public_id, in case duplicate names are not a crucial use case. // Upload_presets that apply randomness to the public ID would not work well with rclone duplicate assets support. params.FilenameOverride = f.getSuggestedPublicID(params.AssetFolder, params.DisplayName, src.ModTime(ctx)) } uploadResult, err := f.cld.Upload.Upload(ctx, in, params) f.lastCRUD = time.Now() if err != nil { return nil, fmt.Errorf("failed to upload to Cloudinary: %w", err) } if !updateObject { modTime = uploadResult.CreatedAt } if uploadResult.Error.Message != "" { return nil, errors.New(uploadResult.Error.Message) } o := &Object{ fs: f, remote: src.Remote(), size: int64(uploadResult.Bytes), modTime: modTime, url: uploadResult.SecureURL, md5sum: uploadResult.Etag, publicID: uploadResult.PublicID, resourceType: uploadResult.ResourceType, deliveryType: uploadResult.Type, } return o, nil } // Precision of the remote func (f *Fs) Precision() time.Duration { return fs.ModTimeNotSupported } // Hashes returns the supported hash sets func (f *Fs) Hashes() hash.Set { return hash.Set(hash.MD5) } // Mkdir creates empty folders func (f *Fs) Mkdir(ctx context.Context, dir string) error { params := admin.CreateFolderParams{Folder: f.ToAssetFolderAPI(f.FromStandardFullPath(dir))} res, err := f.cld.Admin.CreateFolder(ctx, params) f.lastCRUD = time.Now() if err != nil { return err } if res.Error.Message != "" { return errors.New(res.Error.Message) } return nil } // Rmdir deletes empty folders func (f *Fs) Rmdir(ctx context.Context, dir string) error { // Additional test because Cloudinary will delete folders without // assets, regardless of empty sub-folders folder := f.ToAssetFolderAPI(f.FromStandardFullPath(dir)) folderParams := admin.SubFoldersParams{ Folder: folder, MaxResults: 1, } results, err := f.cld.Admin.SubFolders(ctx, folderParams) if err != nil { return err } if results.TotalCount > 0 { return fs.ErrorDirectoryNotEmpty } params := admin.DeleteFolderParams{Folder: folder} res, err := f.cld.Admin.DeleteFolder(ctx, params) f.lastCRUD = time.Now() if err != nil { return err } if res.Error.Message != "" { if strings.HasPrefix(res.Error.Message, "Can't find folder with path") { return fs.ErrorDirNotFound } return errors.New(res.Error.Message) } return nil } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 420, // Too Many Requests (legacy) 429, // Too Many Requests 500, // Internal Server Error 502, // Bad Gateway 503, // Service Unavailable 504, // Gateway Timeout 509, // Bandwidth Limit Exceeded } // shouldRetry returns a boolean as to whether this resp and err // deserve to be retried. It returns the err as a convenience func shouldRetry(ctx context.Context, resp *http.Response, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } if err != nil { tryAgain := "Try again on " if idx := strings.Index(err.Error(), tryAgain); idx != -1 { layout := "2006-01-02 15:04:05 UTC" dateStr := err.Error()[idx+len(tryAgain) : idx+len(tryAgain)+len(layout)] timestamp, err2 := time.Parse(layout, dateStr) if err2 == nil { return true, fserrors.NewErrorRetryAfter(time.Until(timestamp)) } } fs.Debugf(nil, "Retrying API error %v", err) return true, err } return fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(resp, retryErrorCodes), err } // ------------------------------------------------------------ // Hash returns the MD5 of an object func (o *Object) Hash(ctx context.Context, ty hash.Type) (string, error) { if ty != hash.MD5 { return "", hash.ErrUnsupported } return o.md5sum, nil } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // ModTime returns the modification time of the object func (o *Object) ModTime(ctx context.Context) time.Time { return o.modTime } // Size of object in bytes func (o *Object) Size() int64 { return o.size } // Storable returns if this object is storable func (o *Object) Storable() bool { return true } // SetModTime sets the modification time of the local fs object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { return fs.ErrorCantSetModTime } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { var resp *http.Response opts := rest.Opts{ Method: "GET", RootURL: o.url, Options: options, } var offset int64 var count int64 var key string var value string fs.FixRangeOption(options, o.size) for _, option := range options { switch x := option.(type) { case *fs.RangeOption: offset, count = x.Decode(o.size) if count < 0 { count = o.size - offset } key, value = option.Header() case *fs.SeekOption: offset = x.Offset count = o.size - offset key, value = option.Header() default: if option.Mandatory() { fs.Logf(o, "Unsupported mandatory option: %v", option) } } } if key != "" && value != "" { opts.ExtraHeaders = make(map[string]string) opts.ExtraHeaders[key] = value } // Make sure that the asset is fully available err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.Call(ctx, &opts) if err == nil { cl, clErr := strconv.Atoi(resp.Header.Get("content-length")) if clErr == nil && count == int64(cl) { return false, nil } } return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("failed download of \"%s\": %w", o.url, err) } return resp.Body, err } // Update the object with the contents of the io.Reader func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { options = append(options, &api.UpdateOptions{ PublicID: o.publicID, ResourceType: o.resourceType, DeliveryType: o.deliveryType, DisplayName: api.CloudinaryEncoder.FromStandardName(o.fs, path.Base(o.Remote())), AssetFolder: o.fs.FromStandardFullPath(cldPathDir(o.Remote())), }) updatedObj, err := o.fs.Put(ctx, in, src, options...) if err != nil { return err } if uo, ok := updatedObj.(*Object); ok { o.size = uo.size o.modTime = time.Now() // Skipping uo.modTime because the API returns the create time o.url = uo.url o.md5sum = uo.md5sum o.publicID = uo.publicID o.resourceType = uo.resourceType o.deliveryType = uo.deliveryType } return nil } // Remove an object func (o *Object) Remove(ctx context.Context) error { params := uploader.DestroyParams{ PublicID: o.publicID, ResourceType: o.resourceType, Type: o.deliveryType, } res, dErr := o.fs.cld.Upload.Destroy(ctx, params) o.fs.lastCRUD = time.Now() if dErr != nil { return dErr } if res.Error.Message != "" { return errors.New(res.Error.Message) } if res.Result != "ok" { return errors.New(res.Result) } return nil } rclone-v1.71.0/backend/cloudinary/cloudinary_test.go000066400000000000000000000010521505210326400225430ustar00rootroot00000000000000// Test Cloudinary filesystem interface package cloudinary_test import ( "testing" "github.com/rclone/rclone/backend/cloudinary" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { name := "TestCloudinary" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":", NilObject: (*cloudinary.Object)(nil), SkipInvalidUTF8: true, ExtraConfig: []fstests.ExtraConfigItem{ {Name: name, Key: "eventually_consistent_delay", Value: "7"}, }, }) } rclone-v1.71.0/backend/combine/000077500000000000000000000000001505210326400162515ustar00rootroot00000000000000rclone-v1.71.0/backend/combine/combine.go000066400000000000000000000752671505210326400202350ustar00rootroot00000000000000// Package combine implements a backend to combine multiple remotes in a directory tree package combine /* Have API to add/remove branches in the combine */ import ( "context" "errors" "fmt" "io" "path" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fs/walk" "golang.org/x/sync/errgroup" ) // Register with Fs func init() { fsi := &fs.RegInfo{ Name: "combine", Description: "Combine several remotes into one", NewFs: NewFs, MetadataInfo: &fs.MetadataInfo{ Help: `Any metadata supported by the underlying remote is read and written.`, }, Options: []fs.Option{{ Name: "upstreams", Help: `Upstreams for combining These should be in the form dir=remote:path dir2=remote2:path Where before the = is specified the root directory and after is the remote to put there. Embedded spaces can be added using quotes "dir=remote:path with space" "dir2=remote2:path with space" `, Required: true, Default: fs.SpaceSepList(nil), }}, } fs.Register(fsi) } // Options defines the configuration for this backend type Options struct { Upstreams fs.SpaceSepList `config:"upstreams"` } // Fs represents a combine of upstreams type Fs struct { name string // name of this remote features *fs.Features // optional features opt Options // options for this Fs root string // the path we are working on hashSet hash.Set // common hashes when time.Time // directory times upstreams map[string]*upstream // map of upstreams } // adjustment stores the info to add a prefix to a path or chop characters off type adjustment struct { root string rootSlash string mountpoint string mountpointSlash string } // newAdjustment makes a new path adjustment adjusting between mountpoint and root // // mountpoint is the point the upstream is mounted and root is the combine root func newAdjustment(root, mountpoint string) (a adjustment) { return adjustment{ root: root, rootSlash: root + "/", mountpoint: mountpoint, mountpointSlash: mountpoint + "/", } } var errNotUnderRoot = errors.New("file not under root") // do makes the adjustment on s, mapping an upstream path into a combine path func (a *adjustment) do(s string) (string, error) { absPath := join(a.mountpoint, s) if a.root == "" { return absPath, nil } if absPath == a.root { return "", nil } if !strings.HasPrefix(absPath, a.rootSlash) { return "", errNotUnderRoot } return absPath[len(a.rootSlash):], nil } // undo makes the adjustment on s, mapping a combine path into an upstream path func (a *adjustment) undo(s string) (string, error) { absPath := join(a.root, s) if absPath == a.mountpoint { return "", nil } if !strings.HasPrefix(absPath, a.mountpointSlash) { return "", errNotUnderRoot } return absPath[len(a.mountpointSlash):], nil } // upstream represents an upstream Fs type upstream struct { f fs.Fs parent *Fs dir string // directory the upstream is mounted pathAdjustment adjustment // how to fiddle with the path } // Create an upstream from the directory it is mounted on and the remote func (f *Fs) newUpstream(ctx context.Context, dir, remote string) (*upstream, error) { uFs, err := cache.Get(ctx, remote) if err == fs.ErrorIsFile { return nil, fmt.Errorf("can't combine files yet, only directories %q: %w", remote, err) } if err != nil { return nil, fmt.Errorf("failed to create upstream %q: %w", remote, err) } u := &upstream{ f: uFs, parent: f, dir: dir, pathAdjustment: newAdjustment(f.root, dir), } cache.PinUntilFinalized(u.f, u) return u, nil } // NewFs constructs an Fs from the path. // // The returned Fs is the actual Fs, referenced by remote in the config func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (outFs fs.Fs, err error) { // defer log.Trace(nil, "name=%q, root=%q, m=%v", name, root, m)("f=%+v, err=%v", &outFs, &err) // Parse config into Options struct opt := new(Options) err = configstruct.Set(m, opt) if err != nil { return nil, err } // Backward compatible to old config if len(opt.Upstreams) == 0 { return nil, errors.New("combine can't point to an empty upstream - check the value of the upstreams setting") } for _, u := range opt.Upstreams { if strings.HasPrefix(u, name+":") { return nil, errors.New("can't point combine remote at itself - check the value of the upstreams setting") } } isDir := false for strings.HasSuffix(root, "/") { root = root[:len(root)-1] isDir = true } f := &Fs{ name: name, root: root, opt: *opt, upstreams: make(map[string]*upstream, len(opt.Upstreams)), when: time.Now(), } g, gCtx := errgroup.WithContext(ctx) var mu sync.Mutex for _, upstream := range opt.Upstreams { upstream := upstream g.Go(func() (err error) { equal := strings.IndexRune(upstream, '=') if equal < 0 { return fmt.Errorf("no \"=\" in upstream definition %q", upstream) } dir, remote := upstream[:equal], upstream[equal+1:] if dir == "" { return fmt.Errorf("empty dir in upstream definition %q", upstream) } if remote == "" { return fmt.Errorf("empty remote in upstream definition %q", upstream) } if strings.ContainsRune(dir, '/') { return fmt.Errorf("dirs can't contain / (yet): %q", dir) } u, err := f.newUpstream(gCtx, dir, remote) if err != nil { return err } mu.Lock() if _, found := f.upstreams[dir]; found { err = fmt.Errorf("duplicate directory name %q", dir) } else { f.upstreams[dir] = u } mu.Unlock() return err }) } err = g.Wait() if err != nil { return nil, err } // check features var features = (&fs.Features{ CaseInsensitive: true, DuplicateFiles: false, ReadMimeType: true, WriteMimeType: true, CanHaveEmptyDirectories: true, BucketBased: true, SetTier: true, GetTier: true, ReadMetadata: true, WriteMetadata: true, UserMetadata: true, ReadDirMetadata: true, WriteDirMetadata: true, WriteDirSetModTime: true, UserDirMetadata: true, DirModTimeUpdatesOnWrite: true, PartialUploads: true, }).Fill(ctx, f) canMove := true for _, u := range f.upstreams { features = features.Mask(ctx, u.f) // Mask all upstream fs if !operations.CanServerSideMove(u.f) { canMove = false } } // We can move if all remotes support Move or Copy if canMove { features.Move = f.Move } // Enable ListR when upstreams either support ListR or is local // But not when all upstreams are local if features.ListR == nil { for _, u := range f.upstreams { if u.f.Features().ListR != nil { features.ListR = f.ListR } else if !u.f.Features().IsLocal { features.ListR = nil break } } } // Enable ListP always features.ListP = f.ListP // Enable Purge when any upstreams support it if features.Purge == nil { for _, u := range f.upstreams { if u.f.Features().Purge != nil { features.Purge = f.Purge break } } } // Enable Shutdown when any upstreams support it if features.Shutdown == nil { for _, u := range f.upstreams { if u.f.Features().Shutdown != nil { features.Shutdown = f.Shutdown break } } } // Enable DirCacheFlush when any upstreams support it if features.DirCacheFlush == nil { for _, u := range f.upstreams { if u.f.Features().DirCacheFlush != nil { features.DirCacheFlush = f.DirCacheFlush break } } } // Enable CleanUp when any upstreams support it if features.CleanUp == nil { for _, u := range f.upstreams { if u.f.Features().CleanUp != nil { features.CleanUp = f.CleanUp break } } } // Enable ChangeNotify when any upstreams support it if features.ChangeNotify == nil { for _, u := range f.upstreams { if u.f.Features().ChangeNotify != nil { features.ChangeNotify = f.ChangeNotify break } } } // show that we wrap other backends features.Overlay = true f.features = features // Get common intersection of hashes var hashSet hash.Set var first = true for _, u := range f.upstreams { if first { hashSet = u.f.Hashes() first = false } else { hashSet = hashSet.Overlap(u.f.Hashes()) } } f.hashSet = hashSet // Check to see if the root is actually a file if f.root != "" && !isDir { _, err := f.NewObject(ctx, "") if err != nil { if err == fs.ErrorObjectNotFound || err == fs.ErrorNotAFile || err == fs.ErrorIsDir { // File doesn't exist or is a directory so return old f return f, nil } return nil, err } // Check to see if the root path is actually an existing file f.root = path.Dir(f.root) if f.root == "." { f.root = "" } // Adjust path adjustment to remove leaf for _, u := range f.upstreams { u.pathAdjustment = newAdjustment(f.root, u.dir) } return f, fs.ErrorIsFile } return f, nil } // Run a function over all the upstreams in parallel func (f *Fs) multithread(ctx context.Context, fn func(context.Context, *upstream) error) error { g, gCtx := errgroup.WithContext(ctx) for _, u := range f.upstreams { u := u g.Go(func() (err error) { return fn(gCtx, u) }) } return g.Wait() } // join the elements together but unlike path.Join return empty string func join(elem ...string) string { result := path.Join(elem...) if result == "." { return "" } if len(result) > 0 && result[0] == '/' { result = result[1:] } return result } // find the upstream for the remote passed in, returning the upstream and the adjusted path func (f *Fs) findUpstream(remote string) (u *upstream, uRemote string, err error) { // defer log.Trace(remote, "")("f=%v, uRemote=%q, err=%v", &u, &uRemote, &err) for _, u := range f.upstreams { uRemote, err = u.pathAdjustment.undo(remote) if err == nil { return u, uRemote, nil } } return nil, "", fmt.Errorf("combine for remote %q: %w", remote, fs.ErrorDirNotFound) } // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("combine root '%s'", f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // Rmdir removes the root directory of the Fs object func (f *Fs) Rmdir(ctx context.Context, dir string) error { // The root always exists if f.root == "" && dir == "" { return nil } u, uRemote, err := f.findUpstream(dir) if err != nil { return err } return u.f.Rmdir(ctx, uRemote) } // Hashes returns hash.HashNone to indicate remote hashing is unavailable func (f *Fs) Hashes() hash.Set { return f.hashSet } // Mkdir makes the root directory of the Fs object func (f *Fs) Mkdir(ctx context.Context, dir string) error { // The root always exists if f.root == "" && dir == "" { return nil } u, uRemote, err := f.findUpstream(dir) if err != nil { return err } return u.f.Mkdir(ctx, uRemote) } // MkdirMetadata makes the root directory of the Fs object func (f *Fs) MkdirMetadata(ctx context.Context, dir string, metadata fs.Metadata) (fs.Directory, error) { u, uRemote, err := f.findUpstream(dir) if err != nil { return nil, err } do := u.f.Features().MkdirMetadata if do == nil { return nil, fs.ErrorNotImplemented } newDir, err := do(ctx, uRemote, metadata) if err != nil { return nil, err } entries := fs.DirEntries{newDir} entries, err = u.wrapEntries(ctx, entries) if err != nil { return nil, err } newDir, ok := entries[0].(fs.Directory) if !ok { return nil, fmt.Errorf("internal error: expecting %T to be fs.Directory", entries[0]) } return newDir, nil } // purge the upstream or fallback to a slow way func (u *upstream) purge(ctx context.Context, dir string) (err error) { if do := u.f.Features().Purge; do != nil { err = do(ctx, dir) } else { err = operations.Purge(ctx, u.f, dir) } return err } // Purge all files in the directory // // Implement this if you have a way of deleting all the files // quicker than just running Remove() on the result of List() // // Return an error if it doesn't exist func (f *Fs) Purge(ctx context.Context, dir string) error { if f.root == "" && dir == "" { return f.multithread(ctx, func(ctx context.Context, u *upstream) error { return u.purge(ctx, "") }) } u, uRemote, err := f.findUpstream(dir) if err != nil { return err } return u.purge(ctx, uRemote) } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't copy - not same remote type") return nil, fs.ErrorCantCopy } dstU, dstRemote, err := f.findUpstream(remote) if err != nil { return nil, err } do := dstU.f.Features().Copy if do == nil { return nil, fs.ErrorCantCopy } o, err := do(ctx, srcObj.Object, dstRemote) if err != nil { return nil, err } return dstU.newObject(o), nil } // Move src to this remote using server-side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't move - not same remote type") return nil, fs.ErrorCantMove } dstU, dstRemote, err := f.findUpstream(remote) if err != nil { return nil, err } do := dstU.f.Features().Move useCopy := false if do == nil { do = dstU.f.Features().Copy if do == nil { return nil, fs.ErrorCantMove } useCopy = true } o, err := do(ctx, srcObj.Object, dstRemote) if err != nil { return nil, err } // If did Copy then remove the source object if useCopy { err = srcObj.Remove(ctx) if err != nil { return nil, err } } return dstU.newObject(o), nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) (err error) { // defer log.Trace(f, "src=%v, srcRemote=%q, dstRemote=%q", src, srcRemote, dstRemote)("err=%v", &err) srcFs, ok := src.(*Fs) if !ok { fs.Debugf(src, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } dstU, dstURemote, err := f.findUpstream(dstRemote) if err != nil { return err } srcU, srcURemote, err := srcFs.findUpstream(srcRemote) if err != nil { return err } do := dstU.f.Features().DirMove if do == nil { return fs.ErrorCantDirMove } fs.Logf(dstU.f, "srcU.f=%v, srcURemote=%q, dstURemote=%q", srcU.f, srcURemote, dstURemote) return do(ctx, srcU.f, srcURemote, dstURemote) } // ChangeNotify calls the passed function with a path // that has had changes. If the implementation // uses polling, it should adhere to the given interval. // At least one value will be written to the channel, // specifying the initial value and updated values might // follow. A 0 Duration should pause the polling. // The ChangeNotify implementation must empty the channel // regularly. When the channel gets closed, the implementation // should stop polling and release resources. func (f *Fs) ChangeNotify(ctx context.Context, notifyFunc func(string, fs.EntryType), ch <-chan time.Duration) { var uChans []chan time.Duration for _, u := range f.upstreams { u := u if do := u.f.Features().ChangeNotify; do != nil { ch := make(chan time.Duration) uChans = append(uChans, ch) wrappedNotifyFunc := func(path string, entryType fs.EntryType) { newPath, err := u.pathAdjustment.do(path) if err != nil { fs.Logf(f, "ChangeNotify: unable to process %q: %s", path, err) return } fs.Debugf(f, "ChangeNotify: path %q entryType %d", newPath, entryType) notifyFunc(newPath, entryType) } do(ctx, wrappedNotifyFunc, ch) } } go func() { for i := range ch { for _, c := range uChans { c <- i } } for _, c := range uChans { close(c) } }() } // DirCacheFlush resets the directory cache - used in testing // as an optional interface func (f *Fs) DirCacheFlush() { ctx := context.Background() _ = f.multithread(ctx, func(ctx context.Context, u *upstream) error { if do := u.f.Features().DirCacheFlush; do != nil { do() } return nil }) } func (f *Fs) put(ctx context.Context, in io.Reader, src fs.ObjectInfo, stream bool, options ...fs.OpenOption) (fs.Object, error) { srcPath := src.Remote() u, uRemote, err := f.findUpstream(srcPath) if err != nil { return nil, err } uSrc := fs.NewOverrideRemote(src, uRemote) var o fs.Object if stream { o, err = u.f.Features().PutStream(ctx, in, uSrc, options...) } else { o, err = u.f.Put(ctx, in, uSrc, options...) } if err != nil { return nil, err } return u.newObject(o), nil } // Put in to the remote path with the modTime given of the given size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { o, err := f.NewObject(ctx, src.Remote()) switch err { case nil: return o, o.Update(ctx, in, src, options...) case fs.ErrorObjectNotFound: return f.put(ctx, in, src, false, options...) default: return nil, err } } // PutStream uploads to the remote path with the modTime given of indeterminate size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { o, err := f.NewObject(ctx, src.Remote()) switch err { case nil: return o, o.Update(ctx, in, src, options...) case fs.ErrorObjectNotFound: return f.put(ctx, in, src, true, options...) default: return nil, err } } // About gets quota information from the Fs func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { usage := &fs.Usage{ Total: new(int64), Used: new(int64), Trashed: new(int64), Other: new(int64), Free: new(int64), Objects: new(int64), } for _, u := range f.upstreams { doAbout := u.f.Features().About if doAbout == nil { continue } usg, err := doAbout(ctx) if errors.Is(err, fs.ErrorDirNotFound) { continue } if err != nil { return nil, err } if usg.Total != nil && usage.Total != nil { *usage.Total += *usg.Total } else { usage.Total = nil } if usg.Used != nil && usage.Used != nil { *usage.Used += *usg.Used } else { usage.Used = nil } if usg.Trashed != nil && usage.Trashed != nil { *usage.Trashed += *usg.Trashed } else { usage.Trashed = nil } if usg.Other != nil && usage.Other != nil { *usage.Other += *usg.Other } else { usage.Other = nil } if usg.Free != nil && usage.Free != nil { *usage.Free += *usg.Free } else { usage.Free = nil } if usg.Objects != nil && usage.Objects != nil { *usage.Objects += *usg.Objects } else { usage.Objects = nil } } return usage, nil } // Wraps entries for this upstream func (u *upstream) wrapEntries(ctx context.Context, entries fs.DirEntries) (fs.DirEntries, error) { for i, entry := range entries { switch x := entry.(type) { case fs.Object: entries[i] = u.newObject(x) case fs.Directory: newPath, err := u.pathAdjustment.do(x.Remote()) if err != nil { return nil, err } newDir := fs.NewDirWrapper(newPath, x) entries[i] = newDir default: return nil, fmt.Errorf("unknown entry type %T", entry) } } return entries, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { return list.WithListP(ctx, dir, f) } // ListP lists the objects and directories of the Fs starting // from dir non recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. func (f *Fs) ListP(ctx context.Context, dir string, callback fs.ListRCallback) error { // defer log.Trace(f, "dir=%q", dir)("entries = %v, err=%v", &entries, &err) if f.root == "" && dir == "" { entries := make(fs.DirEntries, 0, len(f.upstreams)) for combineDir := range f.upstreams { d := fs.NewLimitedDirWrapper(combineDir, fs.NewDir(combineDir, f.when)) entries = append(entries, d) } return callback(entries) } u, uRemote, err := f.findUpstream(dir) if err != nil { return err } wrappedCallback := func(entries fs.DirEntries) error { entries, err := u.wrapEntries(ctx, entries) if err != nil { return err } return callback(entries) } listP := u.f.Features().ListP if listP == nil { entries, err := u.f.List(ctx, uRemote) if err != nil { return err } return wrappedCallback(entries) } return listP(ctx, uRemote, wrappedCallback) } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively that doing a directory traversal. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { // defer log.Trace(f, "dir=%q, callback=%v", dir, callback)("err=%v", &err) if f.root == "" && dir == "" { rootEntries, err := f.List(ctx, "") if err != nil { return err } err = callback(rootEntries) if err != nil { return err } var mu sync.Mutex syncCallback := func(entries fs.DirEntries) error { mu.Lock() defer mu.Unlock() return callback(entries) } err = f.multithread(ctx, func(ctx context.Context, u *upstream) error { return f.ListR(ctx, u.dir, syncCallback) }) if err != nil { return err } return nil } u, uRemote, err := f.findUpstream(dir) if err != nil { return err } wrapCallback := func(entries fs.DirEntries) error { entries, err := u.wrapEntries(ctx, entries) if err != nil { return err } return callback(entries) } if do := u.f.Features().ListR; do != nil { err = do(ctx, uRemote, wrapCallback) } else { err = walk.ListR(ctx, u.f, uRemote, true, -1, walk.ListAll, wrapCallback) } if err == fs.ErrorDirNotFound { err = nil } return err } // NewObject creates a new remote combine file object func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { u, uRemote, err := f.findUpstream(remote) if err != nil { return nil, err } if uRemote == "" || strings.HasSuffix(uRemote, "/") { return nil, fs.ErrorIsDir } o, err := u.f.NewObject(ctx, uRemote) if err != nil { return nil, err } return u.newObject(o), nil } // Precision is the greatest Precision of all upstreams func (f *Fs) Precision() time.Duration { var greatestPrecision time.Duration for _, u := range f.upstreams { uPrecision := u.f.Precision() if uPrecision > greatestPrecision { greatestPrecision = uPrecision } } return greatestPrecision } // Shutdown the backend, closing any background tasks and any // cached connections. func (f *Fs) Shutdown(ctx context.Context) error { return f.multithread(ctx, func(ctx context.Context, u *upstream) error { if do := u.f.Features().Shutdown; do != nil { return do(ctx) } return nil }) } // PublicLink generates a public link to the remote path (usually readable by anyone) func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (string, error) { u, uRemote, err := f.findUpstream(remote) if err != nil { return "", err } do := u.f.Features().PublicLink if do == nil { return "", fs.ErrorNotImplemented } return do(ctx, uRemote, expire, unlink) } // PutUnchecked in to the remote path with the modTime given of the given size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error // // May create duplicates or return errors if src already // exists. func (f *Fs) PutUnchecked(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { srcPath := src.Remote() u, uRemote, err := f.findUpstream(srcPath) if err != nil { return nil, err } do := u.f.Features().PutUnchecked if do == nil { return nil, fs.ErrorNotImplemented } uSrc := fs.NewOverrideRemote(src, uRemote) return do(ctx, in, uSrc, options...) } // MergeDirs merges the contents of all the directories passed // in into the first one and rmdirs the other directories. func (f *Fs) MergeDirs(ctx context.Context, dirs []fs.Directory) error { if len(dirs) == 0 { return nil } var ( u *upstream uDirs []fs.Directory ) for _, dir := range dirs { uNew, uDir, err := f.findUpstream(dir.Remote()) if err != nil { return err } if u == nil { u = uNew } else if u != uNew { return fmt.Errorf("can't merge directories from different upstreams") } uDirs = append(uDirs, fs.NewOverrideDirectory(dir, uDir)) } do := u.f.Features().MergeDirs if do == nil { return fs.ErrorNotImplemented } return do(ctx, uDirs) } // DirSetModTime sets the directory modtime for dir func (f *Fs) DirSetModTime(ctx context.Context, dir string, modTime time.Time) error { u, uDir, err := f.findUpstream(dir) if err != nil { return err } if uDir == "" { fs.Debugf(dir, "Can't set modtime on upstream root. skipping.") return nil } if do := u.f.Features().DirSetModTime; do != nil { return do(ctx, uDir, modTime) } return fs.ErrorNotImplemented } // CleanUp the trash in the Fs // // Implement this if you have a way of emptying the trash or // otherwise cleaning up old versions of files. func (f *Fs) CleanUp(ctx context.Context) error { return f.multithread(ctx, func(ctx context.Context, u *upstream) error { if do := u.f.Features().CleanUp; do != nil { return do(ctx) } 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) { u, uRemote, err := f.findUpstream(remote) if err != nil { return nil, err } do := u.f.Features().OpenWriterAt if do == nil { return nil, fs.ErrorNotImplemented } return do(ctx, uRemote, size) } // Object describes a wrapped Object // // This is a wrapped Object which knows its path prefix type Object struct { fs.Object u *upstream } func (u *upstream) newObject(o fs.Object) *Object { return &Object{ Object: o, u: u, } } // Fs returns read only access to the Fs that this object is part of func (o *Object) Fs() fs.Info { return o.u.parent } // String returns the remote path func (o *Object) String() string { return o.Remote() } // Remote returns the remote path func (o *Object) Remote() string { newPath, err := o.u.pathAdjustment.do(o.Object.String()) if err != nil { fs.Errorf(o.Object, "Bad object: %v", err) return err.Error() } return newPath } // MimeType returns the content type of the Object if known func (o *Object) MimeType(ctx context.Context) (mimeType string) { if do, ok := o.Object.(fs.MimeTyper); ok { mimeType = do.MimeType(ctx) } return mimeType } // UnWrap returns the Object that this Object is wrapping or // nil if it isn't wrapping anything func (o *Object) UnWrap() fs.Object { return o.Object } // GetTier returns storage tier or class of the Object func (o *Object) GetTier() string { do, ok := o.Object.(fs.GetTierer) if !ok { return "" } return do.GetTier() } // ID returns the ID of the Object if known, or "" if not func (o *Object) ID() string { do, ok := o.Object.(fs.IDer) if !ok { return "" } return do.ID() } // Metadata returns metadata for an object // // It should return nil if there is no Metadata func (o *Object) Metadata(ctx context.Context) (fs.Metadata, error) { do, ok := o.Object.(fs.Metadataer) if !ok { return nil, nil } return do.Metadata(ctx) } // SetMetadata sets metadata for an Object // // It should return fs.ErrorNotImplemented if it can't set metadata func (o *Object) SetMetadata(ctx context.Context, metadata fs.Metadata) error { do, ok := o.Object.(fs.SetMetadataer) if !ok { return fs.ErrorNotImplemented } return do.SetMetadata(ctx, metadata) } // SetTier performs changing storage tier of the Object if // multiple storage classes supported func (o *Object) SetTier(tier string) error { do, ok := o.Object.(fs.SetTierer) if !ok { return errors.New("underlying remote does not support SetTier") } return do.SetTier(tier) } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.DirCacheFlusher = (*Fs)(nil) _ fs.ChangeNotifier = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.ListRer = (*Fs)(nil) _ fs.Shutdowner = (*Fs)(nil) _ fs.PublicLinker = (*Fs)(nil) _ fs.PutUncheckeder = (*Fs)(nil) _ fs.MergeDirser = (*Fs)(nil) _ fs.DirSetModTimer = (*Fs)(nil) _ fs.MkdirMetadataer = (*Fs)(nil) _ fs.CleanUpper = (*Fs)(nil) _ fs.OpenWriterAter = (*Fs)(nil) _ fs.FullObject = (*Object)(nil) ) rclone-v1.71.0/backend/combine/combine_internal_test.go000066400000000000000000000037141505210326400231540ustar00rootroot00000000000000package combine import ( "fmt" "testing" "github.com/stretchr/testify/assert" ) func TestAdjustmentDo(t *testing.T) { for _, test := range []struct { root string mountpoint string in string want string wantErr error }{ { root: "", mountpoint: "mountpoint", in: "path/to/file.txt", want: "mountpoint/path/to/file.txt", }, { root: "mountpoint", mountpoint: "mountpoint", in: "path/to/file.txt", want: "path/to/file.txt", }, { root: "mountpoint/path", mountpoint: "mountpoint", in: "path/to/file.txt", want: "to/file.txt", }, { root: "mountpoint/path", mountpoint: "mountpoint", in: "wrongpath/to/file.txt", want: "", wantErr: errNotUnderRoot, }, } { what := fmt.Sprintf("%+v", test) a := newAdjustment(test.root, test.mountpoint) got, gotErr := a.do(test.in) assert.Equal(t, test.wantErr, gotErr) assert.Equal(t, test.want, got, what) } } func TestAdjustmentUndo(t *testing.T) { for _, test := range []struct { root string mountpoint string in string want string wantErr error }{ { root: "", mountpoint: "mountpoint", in: "mountpoint/path/to/file.txt", want: "path/to/file.txt", }, { root: "mountpoint", mountpoint: "mountpoint", in: "path/to/file.txt", want: "path/to/file.txt", }, { root: "mountpoint/path", mountpoint: "mountpoint", in: "to/file.txt", want: "path/to/file.txt", }, { root: "wrongmountpoint/path", mountpoint: "mountpoint", in: "to/file.txt", want: "", wantErr: errNotUnderRoot, }, } { what := fmt.Sprintf("%+v", test) a := newAdjustment(test.root, test.mountpoint) got, gotErr := a.undo(test.in) assert.Equal(t, test.wantErr, gotErr) assert.Equal(t, test.want, got, what) } } rclone-v1.71.0/backend/combine/combine_test.go000066400000000000000000000053011505210326400212520ustar00rootroot00000000000000// Test Combine filesystem interface package combine_test import ( "testing" _ "github.com/rclone/rclone/backend/local" _ "github.com/rclone/rclone/backend/memory" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" ) var ( unimplementableFsMethods = []string{"UnWrap", "WrapFs", "SetWrapper", "UserInfo", "Disconnect", "OpenChunkWriter"} unimplementableObjectMethods = []string{} ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { if *fstest.RemoteName == "" { t.Skip("Skipping as -remote not set") } fstests.Run(t, &fstests.Opt{ RemoteName: *fstest.RemoteName, UnimplementableFsMethods: unimplementableFsMethods, UnimplementableObjectMethods: unimplementableObjectMethods, }) } func TestLocal(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("Skipping as -remote set") } dirs := MakeTestDirs(t, 3) upstreams := "dir1=" + dirs[0] + " dir2=" + dirs[1] + " dir3=" + dirs[2] name := "TestCombineLocal" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":dir1", ExtraConfig: []fstests.ExtraConfigItem{ {Name: name, Key: "type", Value: "combine"}, {Name: name, Key: "upstreams", Value: upstreams}, }, QuickTestOK: true, UnimplementableFsMethods: unimplementableFsMethods, UnimplementableObjectMethods: unimplementableObjectMethods, }) } func TestMemory(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("Skipping as -remote set") } upstreams := "dir1=:memory:dir1 dir2=:memory:dir2 dir3=:memory:dir3" name := "TestCombineMemory" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":dir1", ExtraConfig: []fstests.ExtraConfigItem{ {Name: name, Key: "type", Value: "combine"}, {Name: name, Key: "upstreams", Value: upstreams}, }, QuickTestOK: true, UnimplementableFsMethods: unimplementableFsMethods, UnimplementableObjectMethods: unimplementableObjectMethods, }) } func TestMixed(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("Skipping as -remote set") } dirs := MakeTestDirs(t, 2) upstreams := "dir1=" + dirs[0] + " dir2=" + dirs[1] + " dir3=:memory:dir3" name := "TestCombineMixed" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":dir1", ExtraConfig: []fstests.ExtraConfigItem{ {Name: name, Key: "type", Value: "combine"}, {Name: name, Key: "upstreams", Value: upstreams}, }, UnimplementableFsMethods: unimplementableFsMethods, UnimplementableObjectMethods: unimplementableObjectMethods, }) } // MakeTestDirs makes directories in /tmp for testing func MakeTestDirs(t *testing.T, n int) (dirs []string) { for i := 1; i <= n; i++ { dir := t.TempDir() dirs = append(dirs, dir) } return dirs } rclone-v1.71.0/backend/compress/000077500000000000000000000000001505210326400164705ustar00rootroot00000000000000rclone-v1.71.0/backend/compress/.gitignore000066400000000000000000000000051505210326400204530ustar00rootroot00000000000000test rclone-v1.71.0/backend/compress/compress.go000066400000000000000000001334421505210326400206610ustar00rootroot00000000000000// Package compress provides wrappers for Fs and Object which implement compression. package compress import ( "bufio" "bytes" "context" "crypto/md5" "encoding/base64" "encoding/binary" "encoding/hex" "encoding/json" "errors" "fmt" "io" "os" "path" "regexp" "strings" "time" "github.com/buengese/sgzip" "github.com/gabriel-vasile/mimetype" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/chunkedreader" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fspath" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/fs/log" "github.com/rclone/rclone/fs/object" "github.com/rclone/rclone/fs/operations" ) // Globals const ( initialChunkSize = 262144 // Initial and max sizes of chunks when reading parts of the file. Currently maxChunkSize = 8388608 // at 256 KiB and 8 MiB. chunkStreams = 0 // Streams to use for reading bufferSize = 8388608 heuristicBytes = 1048576 minCompressionRatio = 1.1 gzFileExt = ".gz" metaFileExt = ".json" uncompressedFileExt = ".bin" ) // Compression modes const ( Uncompressed = 0 Gzip = 2 ) var nameRegexp = regexp.MustCompile(`^(.+?)\.([A-Za-z0-9-_]{11})$`) // Register with Fs func init() { // Build compression mode options. compressionModeOptions := []fs.OptionExample{ { // Default compression mode options { Value: "gzip", Help: "Standard gzip compression with fastest parameters.", }, } // Register our remote fs.Register(&fs.RegInfo{ Name: "compress", Description: "Compress a remote", NewFs: NewFs, MetadataInfo: &fs.MetadataInfo{ Help: `Any metadata supported by the underlying remote is read and written.`, }, Options: []fs.Option{{ Name: "remote", Help: "Remote to compress.", Required: true, }, { Name: "mode", Help: "Compression mode.", Default: "gzip", Examples: compressionModeOptions, }, { Name: "level", Help: `GZIP compression level (-2 to 9). Generally -1 (default, equivalent to 5) is recommended. Levels 1 to 9 increase compression at the cost of speed. Going past 6 generally offers very little return. Level -2 uses Huffman encoding only. Only use if you know what you are doing. Level 0 turns off compression.`, Default: sgzip.DefaultCompression, Advanced: true, }, { Name: "ram_cache_limit", Help: `Some remotes don't allow the upload of files with unknown size. In this case the compressed file will need to be cached to determine it's size. Files smaller than this limit will be cached in RAM, files larger than this limit will be cached on disk.`, Default: fs.SizeSuffix(20 * 1024 * 1024), Advanced: true, }}, }) } // Options defines the configuration for this backend type Options struct { Remote string `config:"remote"` CompressionMode string `config:"mode"` CompressionLevel int `config:"level"` RAMCacheLimit fs.SizeSuffix `config:"ram_cache_limit"` } /*** FILESYSTEM FUNCTIONS ***/ // Fs represents a wrapped fs.Fs type Fs struct { fs.Fs wrapper fs.Fs name string root string opt Options mode int // compression mode id features *fs.Features // optional features } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, rpath string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } remote := opt.Remote if strings.HasPrefix(remote, name+":") { return nil, errors.New("can't point press remote at itself - check the value of the remote setting") } wInfo, wName, wPath, wConfig, err := fs.ConfigFs(remote) if err != nil { return nil, fmt.Errorf("failed to parse remote %q to wrap: %w", remote, err) } // Strip trailing slashes if they exist in rpath rpath = strings.TrimRight(rpath, "\\/") // First, check for a file // If a metadata file was found, return an error. Otherwise, check for a directory remotePath := fspath.JoinRootPath(wPath, makeMetadataName(rpath)) wrappedFs, err := wInfo.NewFs(ctx, wName, remotePath, wConfig) if err != fs.ErrorIsFile { remotePath = fspath.JoinRootPath(wPath, rpath) wrappedFs, err = wInfo.NewFs(ctx, wName, remotePath, wConfig) } if err != nil && err != fs.ErrorIsFile { return nil, fmt.Errorf("failed to make remote %s:%q to wrap: %w", wName, remotePath, err) } // Create the wrapping fs f := &Fs{ Fs: wrappedFs, name: name, root: rpath, opt: *opt, mode: compressionModeFromName(opt.CompressionMode), } // Correct root if definitely pointing to a file if err == fs.ErrorIsFile { f.root = path.Dir(f.root) if f.root == "." || f.root == "/" { f.root = "" } } // the features here are ones we could support, and they are // ANDed with the ones from wrappedFs f.features = (&fs.Features{ CaseInsensitive: true, DuplicateFiles: false, ReadMimeType: false, WriteMimeType: false, GetTier: true, SetTier: true, BucketBased: true, CanHaveEmptyDirectories: true, ReadMetadata: true, WriteMetadata: true, UserMetadata: true, ReadDirMetadata: true, WriteDirMetadata: true, WriteDirSetModTime: true, UserDirMetadata: true, DirModTimeUpdatesOnWrite: true, PartialUploads: true, }).Fill(ctx, f).Mask(ctx, wrappedFs).WrapsFs(f, wrappedFs) // We support reading MIME types no matter the wrapped fs f.features.ReadMimeType = true // We can only support putstream if we have serverside copy or move if !operations.CanServerSideMove(wrappedFs) { f.features.Disable("PutStream") } // Enable ListP always f.features.ListP = f.ListP return f, err } func compressionModeFromName(name string) int { switch name { case "gzip": return Gzip default: return Uncompressed } } // Converts an int64 to base64 func int64ToBase64(number int64) string { intBytes := make([]byte, 8) binary.LittleEndian.PutUint64(intBytes, uint64(number)) return base64.RawURLEncoding.EncodeToString(intBytes) } // Converts base64 to int64 func base64ToInt64(str string) (int64, error) { intBytes, err := base64.RawURLEncoding.DecodeString(str) if err != nil { return 0, err } return int64(binary.LittleEndian.Uint64(intBytes)), nil } // Processes a file name for a compressed file. Returns the original file name, the extension, and the size of the original file. // Returns -2 for the original size if the file is uncompressed. func processFileName(compressedFileName string) (origFileName string, extension string, origSize int64, err error) { // Separate the filename and size from the extension extensionPos := strings.LastIndex(compressedFileName, ".") if extensionPos == -1 { return "", "", 0, errors.New("file name has no extension") } extension = compressedFileName[extensionPos:] nameWithSize := compressedFileName[:extensionPos] if extension == uncompressedFileExt { return nameWithSize, extension, -2, nil } match := nameRegexp.FindStringSubmatch(nameWithSize) if match == nil || len(match) != 3 { return "", "", 0, errors.New("invalid filename") } size, err := base64ToInt64(match[2]) if err != nil { return "", "", 0, errors.New("could not decode size") } return match[1], gzFileExt, size, nil } // Generates the file name for a metadata file func makeMetadataName(remote string) (newRemote string) { return remote + metaFileExt } // Checks whether a file is a metadata file func isMetadataFile(filename string) bool { return strings.HasSuffix(filename, metaFileExt) } // Checks whether a file is a metadata file and returns the original // file name and a flag indicating whether it was a metadata file or // not. func unwrapMetadataFile(filename string) (string, bool) { if !isMetadataFile(filename) { return "", false } return filename[:len(filename)-len(metaFileExt)], true } // makeDataName generates the file name for a data file with specified compression mode func makeDataName(remote string, size int64, mode int) (newRemote string) { if mode != Uncompressed { newRemote = remote + "." + int64ToBase64(size) + gzFileExt } else { newRemote = remote + uncompressedFileExt } return newRemote } // dataName generates the file name for data file func (f *Fs) dataName(remote string, size int64, compressed bool) (name string) { if !compressed { return makeDataName(remote, size, Uncompressed) } return makeDataName(remote, size, f.mode) } // addData parses an object and adds it to the DirEntries func (f *Fs) addData(entries *fs.DirEntries, o fs.Object) { origFileName, _, size, err := processFileName(o.Remote()) if err != nil { fs.Errorf(o, "Error on parsing file name: %v", err) return } if size == -2 { // File is uncompressed size = o.Size() } metaName := makeMetadataName(origFileName) *entries = append(*entries, f.newObjectSizeAndNameOnly(o, metaName, size)) } // addDir adds a dir to the dir entries func (f *Fs) addDir(entries *fs.DirEntries, dir fs.Directory) { *entries = append(*entries, f.newDir(dir)) } // newDir returns a dir func (f *Fs) newDir(dir fs.Directory) fs.Directory { return dir // We're using the same dir } // processEntries parses the file names and adds metadata to the dir entries func (f *Fs) processEntries(entries fs.DirEntries) (newEntries fs.DirEntries, err error) { newEntries = entries[:0] // in place filter for _, entry := range entries { switch x := entry.(type) { case fs.Object: if !isMetadataFile(x.Remote()) { f.addData(&newEntries, x) // Only care about data files for now; metadata files are redundant. } case fs.Directory: f.addDir(&newEntries, x) default: return nil, fmt.Errorf("unknown object type %T", entry) } } return newEntries, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // List entries and process them func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { return list.WithListP(ctx, dir, f) } // ListP lists the objects and directories of the Fs starting // from dir non recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. func (f *Fs) ListP(ctx context.Context, dir string, callback fs.ListRCallback) error { wrappedCallback := func(entries fs.DirEntries) error { entries, err := f.processEntries(entries) if err != nil { return err } return callback(entries) } listP := f.Fs.Features().ListP if listP == nil { entries, err := f.Fs.List(ctx, dir) if err != nil { return err } return wrappedCallback(entries) } return listP(ctx, dir, wrappedCallback) } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively that doing a directory traversal. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { return f.Fs.Features().ListR(ctx, dir, func(entries fs.DirEntries) error { newEntries, err := f.processEntries(entries) if err != nil { return err } return callback(newEntries) }) } // NewObject finds the Object at remote. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { // Read metadata from metadata object mo, err := f.Fs.NewObject(ctx, makeMetadataName(remote)) if err != nil { return nil, err } meta, err := readMetadata(ctx, mo) if err != nil { return nil, fmt.Errorf("error decoding metadata: %w", err) } // Create our Object o, err := f.Fs.NewObject(ctx, makeDataName(remote, meta.CompressionMetadata.Size, meta.Mode)) if err != nil { return nil, err } return f.newObject(o, mo, meta), nil } // checkCompressAndType checks if an object is compressible and determines it's mime type // returns a multireader with the bytes that were read to determine mime type func checkCompressAndType(in io.Reader) (newReader io.Reader, compressible bool, mimeType string, err error) { in, wrap := accounting.UnWrap(in) buf := make([]byte, heuristicBytes) n, err := in.Read(buf) buf = buf[:n] if err != nil && err != io.EOF { return nil, false, "", err } mime := mimetype.Detect(buf) compressible, err = isCompressible(bytes.NewReader(buf)) if err != nil { return nil, false, "", err } in = io.MultiReader(bytes.NewReader(buf), in) return wrap(in), compressible, mime.String(), nil } // isCompressible checks the compression ratio of the provided data and returns true if the ratio exceeds // the configured threshold func isCompressible(r io.Reader) (bool, error) { var b bytes.Buffer w, err := sgzip.NewWriterLevel(&b, sgzip.DefaultCompression) if err != nil { return false, err } n, err := io.Copy(w, r) if err != nil { return false, err } err = w.Close() if err != nil { return false, err } ratio := float64(n) / float64(b.Len()) return ratio > minCompressionRatio, nil } // verifyObjectHash verifies the Objects hash func (f *Fs) verifyObjectHash(ctx context.Context, o fs.Object, hasher *hash.MultiHasher, ht hash.Type) error { srcHash := hasher.Sums()[ht] dstHash, err := o.Hash(ctx, ht) if err != nil { return fmt.Errorf("failed to read destination hash: %w", err) } if srcHash != "" && dstHash != "" && srcHash != dstHash { // remove object err = o.Remove(ctx) if err != nil { fs.Errorf(o, "Failed to remove corrupted object: %v", err) } return fmt.Errorf("corrupted on transfer: %v compressed hashes differ src(%s) %q vs dst(%s) %q", ht, f.Fs, srcHash, o.Fs(), dstHash) } return nil } type putFn func(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) type compressionResult struct { err error meta sgzip.GzipMetadata } // replicating some of operations.Rcat functionality because we want to support remotes without streaming // support and of course cannot know the size of a compressed file before compressing it. func (f *Fs) rcat(ctx context.Context, dstFileName string, in io.ReadCloser, modTime time.Time, options []fs.OpenOption) (o fs.Object, err error) { // cache small files in memory and do normal upload buf := make([]byte, f.opt.RAMCacheLimit) if n, err := io.ReadFull(in, buf); err == io.EOF || err == io.ErrUnexpectedEOF { src := object.NewStaticObjectInfo(dstFileName, modTime, int64(len(buf[:n])), false, nil, f.Fs) return f.Fs.Put(ctx, bytes.NewBuffer(buf[:n]), src, options...) } // Need to include what we already read in = &ReadCloserWrapper{ Reader: io.MultiReader(bytes.NewReader(buf), in), Closer: in, } canStream := f.Fs.Features().PutStream != nil if canStream { src := object.NewStaticObjectInfo(dstFileName, modTime, -1, false, nil, f.Fs) return f.Fs.Features().PutStream(ctx, in, src, options...) } fs.Debugf(f, "Target remote doesn't support streaming uploads, creating temporary local file") tempFile, err := os.CreateTemp("", "rclone-press-") defer func() { // these errors should be relatively uncritical and the upload should've succeeded so it's okay-ish // to ignore them _ = tempFile.Close() _ = os.Remove(tempFile.Name()) }() if err != nil { return nil, fmt.Errorf("failed to create temporary local FS to spool file: %w", err) } if _, err = io.Copy(tempFile, in); err != nil { return nil, fmt.Errorf("failed to write temporary local file: %w", err) } if _, err = tempFile.Seek(0, 0); err != nil { return nil, err } finfo, err := tempFile.Stat() if err != nil { return nil, err } return f.Fs.Put(ctx, tempFile, object.NewStaticObjectInfo(dstFileName, modTime, finfo.Size(), false, nil, f.Fs)) } // Put a compressed version of a file. Returns a wrappable object and metadata. func (f *Fs) putCompress(ctx context.Context, in io.Reader, src fs.ObjectInfo, options []fs.OpenOption, mimeType string) (fs.Object, *ObjectMetadata, error) { // Unwrap reader accounting in, wrap := accounting.UnWrap(in) // Add the metadata hasher metaHasher := md5.New() in = io.TeeReader(in, metaHasher) // Compress the file pipeReader, pipeWriter := io.Pipe() results := make(chan compressionResult) go func() { gz, err := sgzip.NewWriterLevel(pipeWriter, f.opt.CompressionLevel) if err != nil { results <- compressionResult{err: err, meta: sgzip.GzipMetadata{}} return } _, err = io.Copy(gz, in) gzErr := gz.Close() if gzErr != nil { fs.Errorf(nil, "Failed to close compress: %v", gzErr) if err == nil { err = gzErr } } closeErr := pipeWriter.Close() if closeErr != nil { fs.Errorf(nil, "Failed to close pipe: %v", closeErr) if err == nil { err = closeErr } } results <- compressionResult{err: err, meta: gz.MetaData()} }() wrappedIn := wrap(bufio.NewReaderSize(pipeReader, bufferSize)) // Probably no longer needed as sgzip has it's own buffering // Find a hash the destination supports to compute a hash of // the compressed data. ht := f.Fs.Hashes().GetOne() var hasher *hash.MultiHasher var err error if ht != hash.None { // unwrap the accounting again wrappedIn, wrap = accounting.UnWrap(wrappedIn) hasher, err = hash.NewMultiHasherTypes(hash.NewHashSet(ht)) if err != nil { return nil, nil, err } // add the hasher and re-wrap the accounting wrappedIn = io.TeeReader(wrappedIn, hasher) wrappedIn = wrap(wrappedIn) } // Transfer the data o, err := f.rcat(ctx, makeDataName(src.Remote(), src.Size(), f.mode), io.NopCloser(wrappedIn), src.ModTime(ctx), options) //o, err := operations.Rcat(ctx, f.Fs, makeDataName(src.Remote(), src.Size(), f.mode), io.NopCloser(wrappedIn), src.ModTime(ctx)) if err != nil { if o != nil { removeErr := o.Remove(ctx) if removeErr != nil { fs.Errorf(o, "Failed to remove partially transferred object: %v", err) } } return nil, nil, err } // Check whether we got an error during compression result := <-results err = result.err if err != nil { if o != nil { removeErr := o.Remove(ctx) if removeErr != nil { fs.Errorf(o, "Failed to remove partially compressed object: %v", err) } } return nil, nil, err } // Generate metadata meta := newMetadata(result.meta.Size, f.mode, result.meta, hex.EncodeToString(metaHasher.Sum(nil)), mimeType) // Check the hashes of the compressed data if we were comparing them if ht != hash.None && hasher != nil { err = f.verifyObjectHash(ctx, o, hasher, ht) if err != nil { return nil, nil, err } } return o, meta, nil } // Put an uncompressed version of a file. Returns a wrappable object and metadata. func (f *Fs) putUncompress(ctx context.Context, in io.Reader, src fs.ObjectInfo, put putFn, options []fs.OpenOption, mimeType string) (fs.Object, *ObjectMetadata, error) { // Unwrap the accounting, add our metadata hasher, then wrap it back on in, wrap := accounting.UnWrap(in) hs := hash.NewHashSet(hash.MD5) ht := f.Fs.Hashes().GetOne() if !hs.Contains(ht) { hs.Add(ht) } metaHasher, err := hash.NewMultiHasherTypes(hs) if err != nil { return nil, nil, err } in = io.TeeReader(in, metaHasher) wrappedIn := wrap(in) // Put the object o, err := put(ctx, wrappedIn, f.wrapInfo(src, makeDataName(src.Remote(), src.Size(), Uncompressed), src.Size()), options...) if err != nil { if o != nil { removeErr := o.Remove(ctx) if removeErr != nil { fs.Errorf(o, "Failed to remove partially transferred object: %v", err) } } return nil, nil, err } // Check the hashes of the compressed data if we were comparing them if ht != hash.None { err := f.verifyObjectHash(ctx, o, metaHasher, ht) if err != nil { return nil, nil, err } } // Return our object and metadata sum, err := metaHasher.Sum(hash.MD5) if err != nil { return nil, nil, err } return o, newMetadata(o.Size(), Uncompressed, sgzip.GzipMetadata{}, hex.EncodeToString(sum), mimeType), nil } // This function will write a metadata struct to a metadata Object for an src. Returns a wrappable metadata object. func (f *Fs) putMetadata(ctx context.Context, meta *ObjectMetadata, src fs.ObjectInfo, options []fs.OpenOption, put putFn) (mo fs.Object, err error) { // Generate the metadata contents data, err := json.Marshal(meta) if err != nil { return nil, err } metaReader := bytes.NewReader(data) // Put the data mo, err = put(ctx, metaReader, f.wrapInfo(src, makeMetadataName(src.Remote()), int64(len(data))), options...) if err != nil { if mo != nil { removeErr := mo.Remove(ctx) if removeErr != nil { fs.Errorf(mo, "Failed to remove partially transferred object: %v", err) } } return nil, err } return mo, nil } // This function will put both the data and metadata for an Object. // putData is the function used for data, while putMeta is the function used for metadata. // The putData function will only be used when the object is not compressible if the // data is compressible this parameter will be ignored. func (f *Fs) putWithCustomFunctions(ctx context.Context, in io.Reader, src fs.ObjectInfo, options []fs.OpenOption, putData putFn, putMeta putFn, compressible bool, mimeType string) (*Object, error) { // Put file then metadata var dataObject fs.Object var meta *ObjectMetadata var err error if compressible { dataObject, meta, err = f.putCompress(ctx, in, src, options, mimeType) } else { dataObject, meta, err = f.putUncompress(ctx, in, src, putData, options, mimeType) } if err != nil { return nil, err } mo, err := f.putMetadata(ctx, meta, src, options, putMeta) // meta data upload may fail. in this case we try to remove the original object if err != nil { removeError := dataObject.Remove(ctx) if removeError != nil { return nil, removeError } return nil, err } return f.newObject(dataObject, mo, meta), nil } // Put in to the remote path with the modTime given of the given size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { // If there's already an existent objects we need to make sure to explicitly update it to make sure we don't leave // orphaned data. Alternatively we could also deleted (which would simpler) but has the disadvantage that it // destroys all server-side versioning. o, err := f.NewObject(ctx, src.Remote()) if err == fs.ErrorObjectNotFound { // Get our file compressibility in, compressible, mimeType, err := checkCompressAndType(in) if err != nil { return nil, err } return f.putWithCustomFunctions(ctx, in, src, options, f.Fs.Put, f.Fs.Put, compressible, mimeType) } if err != nil { return nil, err } return o, o.Update(ctx, in, src, options...) } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { oldObj, err := f.NewObject(ctx, src.Remote()) if err != nil && err != fs.ErrorObjectNotFound { return nil, err } found := err == nil in, compressible, mimeType, err := checkCompressAndType(in) if err != nil { return nil, err } newObj, err := f.putWithCustomFunctions(ctx, in, src, options, f.Fs.Features().PutStream, f.Fs.Put, compressible, mimeType) if err != nil { return nil, err } // Our transfer is now complete. We have to make sure to remove the old object because our new object will // have a different name except when both the old and the new object where uncompressed. if found && (oldObj.(*Object).meta.Mode != Uncompressed || compressible) { err = oldObj.(*Object).Object.Remove(ctx) if err != nil { return nil, fmt.Errorf("couldn't remove original object: %w", err) } } // If our new object is compressed we have to rename it with the correct size. // Uncompressed objects don't store the size in the name so we they'll already have the correct name. if compressible { wrapObj, err := operations.Move(ctx, f.Fs, nil, f.dataName(src.Remote(), newObj.size, compressible), newObj.Object) if err != nil { return nil, fmt.Errorf("couldn't rename streamed object: %w", err) } newObj.Object = wrapObj } return newObj, nil } // Temporarily disabled. There might be a way to implement this correctly but with the current handling metadata duplicate objects // will break stuff. Right no I can't think of a way to make this work. // PutUnchecked uploads the object // // This will create a duplicate if we upload a new file without // checking to see if there is one already - use Put() for that. // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hash.MD5) } // Mkdir makes the directory (container, bucket) // // Shouldn't return an error if it already exists func (f *Fs) Mkdir(ctx context.Context, dir string) error { return f.Fs.Mkdir(ctx, dir) } // MkdirMetadata makes the root directory of the Fs object func (f *Fs) MkdirMetadata(ctx context.Context, dir string, metadata fs.Metadata) (fs.Directory, error) { if do := f.Fs.Features().MkdirMetadata; do != nil { return do(ctx, dir, metadata) } return nil, fs.ErrorNotImplemented } // Rmdir removes the directory (container, bucket) if empty // // Return an error if it doesn't exist or isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { return f.Fs.Rmdir(ctx, dir) } // Purge all files in the root and the root directory // // Implement this if you have a way of deleting all the files // quicker than just running Remove() on the result of List() // // Return an error if it doesn't exist func (f *Fs) Purge(ctx context.Context, dir string) error { do := f.Fs.Features().Purge if do == nil { return fs.ErrorCantPurge } return do(ctx, dir) } // Copy src to this remote using server side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { do := f.Fs.Features().Copy if do == nil { return nil, fs.ErrorCantCopy } o, ok := src.(*Object) if !ok { return nil, fs.ErrorCantCopy } // We might be trying to overwrite a file with a newer version but due to size difference the name // is different. Therefore we have to remove the old file first (if it exists). dstFile, err := f.NewObject(ctx, remote) if err != nil && err != fs.ErrorObjectNotFound { return nil, err } if err == nil { err := dstFile.Remove(ctx) if err != nil { return nil, err } } // Copy over metadata err = o.loadMetadataIfNotLoaded(ctx) if err != nil { return nil, err } newFilename := makeMetadataName(remote) moResult, err := do(ctx, o.mo, newFilename) if err != nil { return nil, err } // Copy over data newFilename = makeDataName(remote, src.Size(), o.meta.Mode) oResult, err := do(ctx, o.Object, newFilename) if err != nil { return nil, err } return f.newObject(oResult, moResult, o.meta), nil } // Move src to this remote using server side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { do := f.Fs.Features().Move if do == nil { return nil, fs.ErrorCantMove } o, ok := src.(*Object) if !ok { return nil, fs.ErrorCantMove } // We might be trying to overwrite a file with a newer version but due to size difference the name // is different. Therefore we have to remove the old file first (if it exists). dstFile, err := f.NewObject(ctx, remote) if err != nil && err != fs.ErrorObjectNotFound { return nil, err } if err == nil { err := dstFile.Remove(ctx) if err != nil { return nil, err } } // Move metadata err = o.loadMetadataIfNotLoaded(ctx) if err != nil { return nil, err } newFilename := makeMetadataName(remote) moResult, err := do(ctx, o.mo, newFilename) if err != nil { return nil, err } // Move data newFilename = makeDataName(remote, src.Size(), o.meta.Mode) oResult, err := do(ctx, o.Object, newFilename) if err != nil { return nil, err } return f.newObject(oResult, moResult, o.meta), nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { do := f.Fs.Features().DirMove if do == nil { return fs.ErrorCantDirMove } srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } return do(ctx, srcFs.Fs, srcRemote, dstRemote) } // DirSetModTime sets the directory modtime for dir func (f *Fs) DirSetModTime(ctx context.Context, dir string, modTime time.Time) error { if do := f.Fs.Features().DirSetModTime; do != nil { return do(ctx, dir, modTime) } return fs.ErrorNotImplemented } // CleanUp the trash in the Fs // // Implement this if you have a way of emptying the trash or // otherwise cleaning up old versions of files. func (f *Fs) CleanUp(ctx context.Context) error { do := f.Fs.Features().CleanUp if do == nil { return errors.New("not supported by underlying remote") } return do(ctx) } // About gets quota information from the Fs func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { do := f.Fs.Features().About if do == nil { return nil, errors.New("not supported by underlying remote") } return do(ctx) } // UnWrap returns the Fs that this Fs is wrapping func (f *Fs) UnWrap() fs.Fs { return f.Fs } // WrapFs returns the Fs that is wrapping this Fs func (f *Fs) WrapFs() fs.Fs { return f.wrapper } // SetWrapper sets the Fs that is wrapping this Fs func (f *Fs) SetWrapper(wrapper fs.Fs) { f.wrapper = wrapper } // MergeDirs merges the contents of all the directories passed // in into the first one and rmdirs the other directories. func (f *Fs) MergeDirs(ctx context.Context, dirs []fs.Directory) error { do := f.Fs.Features().MergeDirs if do == nil { return errors.New("MergeDirs not supported") } out := make([]fs.Directory, len(dirs)) for i, dir := range dirs { out[i] = fs.NewDirCopy(ctx, dir).SetRemote(dir.Remote()) } return do(ctx, out) } // DirCacheFlush resets the directory cache - used in testing // as an optional interface func (f *Fs) DirCacheFlush() { do := f.Fs.Features().DirCacheFlush if do != nil { do() } } // ChangeNotify calls the passed function with a path // that has had changes. If the implementation // uses polling, it should adhere to the given interval. func (f *Fs) ChangeNotify(ctx context.Context, notifyFunc func(string, fs.EntryType), pollIntervalChan <-chan time.Duration) { do := f.Fs.Features().ChangeNotify if do == nil { return } wrappedNotifyFunc := func(path string, entryType fs.EntryType) { fs.Logf(f, "path %q entryType %d", path, entryType) var ( wrappedPath string isMetadataFile bool ) switch entryType { case fs.EntryDirectory: wrappedPath = path case fs.EntryObject: // Note: All we really need to do to monitor the object is to check whether the metadata changed, // as the metadata contains the hash. This will work unless there's a hash collision and the sizes stay the same. wrappedPath, isMetadataFile = unwrapMetadataFile(path) if !isMetadataFile { return } default: fs.Errorf(path, "press ChangeNotify: ignoring unknown EntryType %d", entryType) return } notifyFunc(wrappedPath, entryType) } do(ctx, wrappedNotifyFunc, pollIntervalChan) } // PublicLink generates a public link to the remote path (usually readable by anyone) func (f *Fs) PublicLink(ctx context.Context, remote string, duration fs.Duration, unlink bool) (string, error) { do := f.Fs.Features().PublicLink if do == nil { return "", errors.New("can't PublicLink: not supported by underlying remote") } o, err := f.NewObject(ctx, remote) if err != nil { // assume it is a directory return do(ctx, remote, duration, unlink) } return do(ctx, o.(*Object).Object.Remote(), duration, unlink) } /*** OBJECT FUNCTIONS ***/ // ObjectMetadata describes the metadata for an Object. type ObjectMetadata struct { Mode int // Compression mode of the file. Size int64 // Size of the object. MD5 string // MD5 hash of the file. MimeType string // Mime type of the file CompressionMetadata sgzip.GzipMetadata } // Object with external metadata type Object struct { fs.Object // Wraps around data object for this object f *Fs // Filesystem object is in mo fs.Object // Metadata object for this object moName string // Metadata file name for this object size int64 // Size of this object meta *ObjectMetadata // Metadata struct for this object (nil if not loaded) } // This function generates a metadata object func newMetadata(size int64, mode int, cmeta sgzip.GzipMetadata, md5 string, mimeType string) *ObjectMetadata { meta := new(ObjectMetadata) meta.Size = size meta.Mode = mode meta.CompressionMetadata = cmeta meta.MD5 = md5 meta.MimeType = mimeType return meta } // This function will read the metadata from a metadata object. func readMetadata(ctx context.Context, mo fs.Object) (meta *ObjectMetadata, err error) { // Open our meradata object rc, err := mo.Open(ctx) if err != nil { return nil, err } defer fs.CheckClose(rc, &err) jr := json.NewDecoder(rc) meta = new(ObjectMetadata) if err = jr.Decode(meta); err != nil { return nil, err } return meta, nil } // Remove removes this object func (o *Object) Remove(ctx context.Context) error { err := o.loadMetadataObjectIfNotLoaded(ctx) if err != nil { return err } err = o.mo.Remove(ctx) objErr := o.Object.Remove(ctx) if err != nil { return err } return objErr } // ReadCloserWrapper combines a Reader and a Closer to a ReadCloser type ReadCloserWrapper struct { io.Reader io.Closer } // Update in to the object with the modTime given of the given size func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { err = o.loadMetadataIfNotLoaded(ctx) // Loads metadata object too if err != nil { return err } // Function that updates metadata object updateMeta := func(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return o.mo, o.mo.Update(ctx, in, src, options...) } in, compressible, mimeType, err := checkCompressAndType(in) if err != nil { return err } // Since we are storing the filesize in the name the new object may have different name than the old // We'll make sure to delete the old object in this case var newObject *Object origName := o.Remote() if o.meta.Mode != Uncompressed || compressible { newObject, err = o.f.putWithCustomFunctions(ctx, in, o.f.wrapInfo(src, origName, src.Size()), options, o.f.Fs.Put, updateMeta, compressible, mimeType) if err != nil { return err } if newObject.Object.Remote() != o.Object.Remote() { if removeErr := o.Object.Remove(ctx); removeErr != nil { return removeErr } } } else { // We can only support update when BOTH the old and the new object are uncompressed because only then // the filesize will be known beforehand and name will stay the same update := func(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return o.Object, o.Object.Update(ctx, in, src, options...) } // If we are, just update the object and metadata newObject, err = o.f.putWithCustomFunctions(ctx, in, src, options, update, updateMeta, compressible, mimeType) if err != nil { return err } } // Update object metadata and return o.Object = newObject.Object o.meta = newObject.meta o.size = newObject.size return nil } // This will initialize the variables of a new press Object. The metadata object, mo, and metadata struct, meta, must be specified. func (f *Fs) newObject(o fs.Object, mo fs.Object, meta *ObjectMetadata) *Object { if o == nil { log.Trace(nil, "newObject(%#v, %#v, %#v) called with nil o", o, mo, meta) } return &Object{ Object: o, f: f, mo: mo, moName: mo.Remote(), size: meta.Size, meta: meta, } } // This initializes the variables of a press Object with only the size. The metadata will be loaded later on demand. func (f *Fs) newObjectSizeAndNameOnly(o fs.Object, moName string, size int64) *Object { if o == nil { log.Trace(nil, "newObjectSizeAndNameOnly(%#v, %#v, %#v) called with nil o", o, moName, size) } return &Object{ Object: o, f: f, mo: nil, moName: moName, size: size, meta: nil, } } // Shutdown the backend, closing any background tasks and any // cached connections. func (f *Fs) Shutdown(ctx context.Context) error { do := f.Fs.Features().Shutdown if do == nil { return nil } return do(ctx) } // This loads the metadata of a press Object if it's not loaded yet func (o *Object) loadMetadataIfNotLoaded(ctx context.Context) (err error) { err = o.loadMetadataObjectIfNotLoaded(ctx) if err != nil { return err } if o.meta == nil { o.meta, err = readMetadata(ctx, o.mo) } return err } // This loads the metadata object of a press Object if it's not loaded yet func (o *Object) loadMetadataObjectIfNotLoaded(ctx context.Context) (err error) { if o.mo == nil { o.mo, err = o.f.Fs.NewObject(ctx, o.moName) } return err } // Fs returns read only access to the Fs that this object is part of func (o *Object) Fs() fs.Info { return o.f } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.Remote() } // Remote returns the remote path func (o *Object) Remote() string { origFileName, _, _, err := processFileName(o.Object.Remote()) if err != nil { fs.Errorf(o.f, "Could not get remote path for: %s", o.Object.Remote()) return o.Object.Remote() } return origFileName } // Size returns the size of the file func (o *Object) Size() int64 { if o.meta == nil { return o.size } return o.meta.Size } // MimeType returns the MIME type of the file func (o *Object) MimeType(ctx context.Context) string { err := o.loadMetadataIfNotLoaded(ctx) if err != nil { return "error/error" } return o.meta.MimeType } // Metadata returns metadata for an object // // It should return nil if there is no Metadata func (o *Object) Metadata(ctx context.Context) (fs.Metadata, error) { err := o.loadMetadataIfNotLoaded(ctx) if err != nil { return nil, err } do, ok := o.mo.(fs.Metadataer) if !ok { return nil, nil } return do.Metadata(ctx) } // SetMetadata sets metadata for an Object // // It should return fs.ErrorNotImplemented if it can't set metadata func (o *Object) SetMetadata(ctx context.Context, metadata fs.Metadata) error { do, ok := o.Object.(fs.SetMetadataer) if !ok { return fs.ErrorNotImplemented } return do.SetMetadata(ctx, metadata) } // Hash returns the selected checksum of the file // If no checksum is available it returns "" func (o *Object) Hash(ctx context.Context, ht hash.Type) (string, error) { if ht != hash.MD5 { return "", hash.ErrUnsupported } err := o.loadMetadataIfNotLoaded(ctx) if err != nil { return "", err } return o.meta.MD5, nil } // SetTier performs changing storage tier of the Object if // multiple storage classes supported func (o *Object) SetTier(tier string) error { do, ok := o.Object.(fs.SetTierer) mdo, mok := o.mo.(fs.SetTierer) if !(ok && mok) { return errors.New("press: underlying remote does not support SetTier") } if err := mdo.SetTier(tier); err != nil { return err } return do.SetTier(tier) } // GetTier returns storage tier or class of the Object func (o *Object) GetTier() string { do, ok := o.mo.(fs.GetTierer) if !ok { return "" } return do.GetTier() } // UnWrap returns the wrapped Object func (o *Object) UnWrap() fs.Object { return o.Object } // Open opens the file for read. Call Close() on the returned io.ReadCloser. Note that this call requires quite a bit of overhead. func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (rc io.ReadCloser, err error) { err = o.loadMetadataIfNotLoaded(ctx) if err != nil { return nil, err } // If we're uncompressed, just pass this to the underlying object if o.meta.Mode == Uncompressed { return o.Object.Open(ctx, options...) } // Get offset and limit from OpenOptions, pass the rest to the underlying remote var openOptions = []fs.OpenOption{&fs.SeekOption{Offset: 0}} var offset, limit int64 = 0, -1 for _, option := range options { switch x := option.(type) { case *fs.SeekOption: offset = x.Offset case *fs.RangeOption: offset, limit = x.Decode(o.Size()) default: openOptions = append(openOptions, option) } } // Get a chunkedreader for the wrapped object chunkedReader := chunkedreader.New(ctx, o.Object, initialChunkSize, maxChunkSize, chunkStreams) // Get file handle var file io.Reader if offset != 0 { file, err = sgzip.NewReaderAt(chunkedReader, &o.meta.CompressionMetadata, offset) } else { file, err = sgzip.NewReader(chunkedReader) } if err != nil { return nil, err } var fileReader io.Reader if limit != -1 { fileReader = io.LimitReader(file, limit) } else { fileReader = file } // Return a ReadCloser return ReadCloserWrapper{Reader: fileReader, Closer: chunkedReader}, nil } // ObjectInfo describes a wrapped fs.ObjectInfo for being the source type ObjectInfo struct { src fs.ObjectInfo fs *Fs remote string size int64 } func (f *Fs) wrapInfo(src fs.ObjectInfo, newRemote string, size int64) *ObjectInfo { return &ObjectInfo{ src: src, fs: f, remote: newRemote, size: size, } } // Fs returns read only access to the Fs that this object is part of func (o *ObjectInfo) Fs() fs.Info { if o.fs == nil { panic("stub ObjectInfo") } return o.fs } // String returns string representation func (o *ObjectInfo) String() string { return o.src.String() } // Storable returns whether object is storable func (o *ObjectInfo) Storable() bool { return o.src.Storable() } // Remote returns the remote path func (o *ObjectInfo) Remote() string { if o.remote != "" { return o.remote } return o.src.Remote() } // Size returns the size of the file func (o *ObjectInfo) Size() int64 { return o.size } // ModTime returns the modification time func (o *ObjectInfo) ModTime(ctx context.Context) time.Time { return o.src.ModTime(ctx) } // Hash returns the selected checksum of the file // If no checksum is available it returns "" func (o *ObjectInfo) Hash(ctx context.Context, ht hash.Type) (string, error) { return "", nil // cannot know the checksum } // ID returns the ID of the Object if known, or "" if not func (o *ObjectInfo) ID() string { do, ok := o.src.(fs.IDer) if !ok { return "" } return do.ID() } // MimeType returns the content type of the Object if // known, or "" if not func (o *ObjectInfo) MimeType(ctx context.Context) string { do, ok := o.src.(fs.MimeTyper) if !ok { return "" } return do.MimeType(ctx) } // UnWrap returns the Object that this Object is wrapping or // nil if it isn't wrapping anything func (o *ObjectInfo) UnWrap() fs.Object { return fs.UnWrapObjectInfo(o.src) } // Metadata returns metadata for an object // // It should return nil if there is no Metadata func (o *ObjectInfo) Metadata(ctx context.Context) (fs.Metadata, error) { do, ok := o.src.(fs.Metadataer) if !ok { return nil, nil } return do.Metadata(ctx) } // GetTier returns storage tier or class of the Object func (o *ObjectInfo) GetTier() string { do, ok := o.src.(fs.GetTierer) if !ok { return "" } return do.GetTier() } // ID returns the ID of the Object if known, or "" if not func (o *Object) ID() string { do, ok := o.Object.(fs.IDer) if !ok { return "" } return do.ID() } // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // Return a string version func (f *Fs) String() string { return fmt.Sprintf("Compressed: %s:%s", f.name, f.root) } // Precision returns the precision of this Fs func (f *Fs) Precision() time.Duration { return f.Fs.Precision() } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.DirSetModTimer = (*Fs)(nil) _ fs.MkdirMetadataer = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.CleanUpper = (*Fs)(nil) _ fs.UnWrapper = (*Fs)(nil) _ fs.ListRer = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.Wrapper = (*Fs)(nil) _ fs.MergeDirser = (*Fs)(nil) _ fs.DirCacheFlusher = (*Fs)(nil) _ fs.ChangeNotifier = (*Fs)(nil) _ fs.PublicLinker = (*Fs)(nil) _ fs.Shutdowner = (*Fs)(nil) _ fs.FullObjectInfo = (*ObjectInfo)(nil) _ fs.FullObject = (*Object)(nil) ) rclone-v1.71.0/backend/compress/compress_test.go000066400000000000000000000025711505210326400217160ustar00rootroot00000000000000// Test Crypt filesystem interface package compress import ( "os" "path/filepath" "testing" _ "github.com/rclone/rclone/backend/drive" _ "github.com/rclone/rclone/backend/local" _ "github.com/rclone/rclone/backend/s3" _ "github.com/rclone/rclone/backend/swift" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" ) var defaultOpt = fstests.Opt{ RemoteName: "TestCompress:", NilObject: (*Object)(nil), UnimplementableFsMethods: []string{ "OpenWriterAt", "OpenChunkWriter", "MergeDirs", "DirCacheFlush", "PutUnchecked", "PutStream", "UserInfo", "Disconnect", }, TiersToTest: []string{"STANDARD", "STANDARD_IA"}, UnimplementableObjectMethods: []string{}, } // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &defaultOpt) } // TestRemoteGzip tests GZIP compression func TestRemoteGzip(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("Skipping as -remote set") } tempdir := filepath.Join(os.TempDir(), "rclone-compress-test-gzip") name := "TestCompressGzip" opt := defaultOpt opt.RemoteName = name + ":" opt.ExtraConfig = []fstests.ExtraConfigItem{ {Name: name, Key: "type", Value: "compress"}, {Name: name, Key: "remote", Value: tempdir}, {Name: name, Key: "compression_mode", Value: "gzip"}, } opt.QuickTestOK = true fstests.Run(t, &opt) } rclone-v1.71.0/backend/crypt/000077500000000000000000000000001505210326400157765ustar00rootroot00000000000000rclone-v1.71.0/backend/crypt/cipher.go000066400000000000000000000753671505210326400176210ustar00rootroot00000000000000package crypt import ( "bytes" "context" "crypto/aes" gocipher "crypto/cipher" "crypto/rand" "encoding/base32" "encoding/base64" "errors" "fmt" "io" "strconv" "strings" "sync" "time" "unicode/utf8" "github.com/Max-Sum/base32768" "github.com/rclone/rclone/backend/crypt/pkcs7" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/lib/readers" "github.com/rclone/rclone/lib/version" "github.com/rfjakob/eme" "golang.org/x/crypto/nacl/secretbox" "golang.org/x/crypto/scrypt" ) // Constants const ( nameCipherBlockSize = aes.BlockSize fileMagic = "RCLONE\x00\x00" fileMagicSize = len(fileMagic) fileNonceSize = 24 fileHeaderSize = fileMagicSize + fileNonceSize blockHeaderSize = secretbox.Overhead blockDataSize = 64 * 1024 blockSize = blockHeaderSize + blockDataSize ) // Errors returned by cipher var ( ErrorBadDecryptUTF8 = errors.New("bad decryption - utf-8 invalid") ErrorBadDecryptControlChar = errors.New("bad decryption - contains control chars") ErrorNotAMultipleOfBlocksize = errors.New("not a multiple of blocksize") ErrorTooShortAfterDecode = errors.New("too short after base32 decode") ErrorTooLongAfterDecode = errors.New("too long after base32 decode") ErrorEncryptedFileTooShort = errors.New("file is too short to be encrypted") ErrorEncryptedFileBadHeader = errors.New("file has truncated block header") ErrorEncryptedBadMagic = errors.New("not an encrypted file - bad magic string") ErrorEncryptedBadBlock = errors.New("failed to authenticate decrypted block - bad password?") ErrorBadBase32Encoding = errors.New("bad base32 filename encoding") ErrorFileClosed = errors.New("file already closed") ErrorNotAnEncryptedFile = errors.New("not an encrypted file - does not match suffix") ErrorBadSeek = errors.New("Seek beyond end of file") ErrorSuffixMissingDot = errors.New("suffix config setting should include a '.'") defaultSalt = []byte{0xA8, 0x0D, 0xF4, 0x3A, 0x8F, 0xBD, 0x03, 0x08, 0xA7, 0xCA, 0xB8, 0x3E, 0x58, 0x1F, 0x86, 0xB1} obfuscQuoteRune = '!' ) // Global variables var ( fileMagicBytes = []byte(fileMagic) ) // ReadSeekCloser is the interface of the read handles type ReadSeekCloser interface { io.Reader io.Seeker io.Closer fs.RangeSeeker } // OpenRangeSeek opens the file handle at the offset with the limit given type OpenRangeSeek func(ctx context.Context, offset, limit int64) (io.ReadCloser, error) // NameEncryptionMode is the type of file name encryption in use type NameEncryptionMode int // NameEncryptionMode levels const ( NameEncryptionOff NameEncryptionMode = iota NameEncryptionStandard NameEncryptionObfuscated ) // NewNameEncryptionMode turns a string into a NameEncryptionMode func NewNameEncryptionMode(s string) (mode NameEncryptionMode, err error) { s = strings.ToLower(s) switch s { case "off": mode = NameEncryptionOff case "standard": mode = NameEncryptionStandard case "obfuscate": mode = NameEncryptionObfuscated default: err = fmt.Errorf("unknown file name encryption mode %q", s) } return mode, err } // String turns mode into a human-readable string func (mode NameEncryptionMode) String() (out string) { switch mode { case NameEncryptionOff: out = "off" case NameEncryptionStandard: out = "standard" case NameEncryptionObfuscated: out = "obfuscate" default: out = fmt.Sprintf("Unknown mode #%d", mode) } return out } // fileNameEncoding are the encoding methods dealing with encrypted file names type fileNameEncoding interface { EncodeToString(src []byte) string DecodeString(s string) ([]byte, error) } // caseInsensitiveBase32Encoding defines a file name encoding // using a modified version of standard base32 as described in // RFC4648 // // The standard encoding is modified in two ways // - it becomes lower case (no-one likes upper case filenames!) // - we strip the padding character `=` type caseInsensitiveBase32Encoding struct{} // EncodeToString encodes a string using the modified version of // base32 encoding. func (caseInsensitiveBase32Encoding) EncodeToString(src []byte) string { encoded := base32.HexEncoding.EncodeToString(src) encoded = strings.TrimRight(encoded, "=") return strings.ToLower(encoded) } // DecodeString decodes a string as encoded by EncodeToString func (caseInsensitiveBase32Encoding) DecodeString(s string) ([]byte, error) { if strings.HasSuffix(s, "=") { return nil, ErrorBadBase32Encoding } // First figure out how many padding characters to add roundUpToMultipleOf8 := (len(s) + 7) &^ 7 equals := roundUpToMultipleOf8 - len(s) s = strings.ToUpper(s) + "========"[:equals] return base32.HexEncoding.DecodeString(s) } // NewNameEncoding creates a NameEncoding from a string func NewNameEncoding(s string) (enc fileNameEncoding, err error) { s = strings.ToLower(s) switch s { case "base32": enc = caseInsensitiveBase32Encoding{} case "base64": enc = base64.RawURLEncoding case "base32768": enc = base32768.SafeEncoding default: err = fmt.Errorf("unknown file name encoding mode %q", s) } return enc, err } // Cipher defines an encoding and decoding cipher for the crypt backend type Cipher struct { dataKey [32]byte // Key for secretbox nameKey [32]byte // 16,24 or 32 bytes nameTweak [nameCipherBlockSize]byte // used to tweak the name crypto block gocipher.Block mode NameEncryptionMode fileNameEnc fileNameEncoding buffers sync.Pool // encrypt/decrypt buffers cryptoRand io.Reader // read crypto random numbers from here dirNameEncrypt bool passBadBlocks bool // if set passed bad blocks as zeroed blocks encryptedSuffix string } // newCipher initialises the cipher. If salt is "" then it uses a built in salt val func newCipher(mode NameEncryptionMode, password, salt string, dirNameEncrypt bool, enc fileNameEncoding) (*Cipher, error) { c := &Cipher{ mode: mode, fileNameEnc: enc, cryptoRand: rand.Reader, dirNameEncrypt: dirNameEncrypt, encryptedSuffix: ".bin", } c.buffers.New = func() any { return new([blockSize]byte) } err := c.Key(password, salt) if err != nil { return nil, err } return c, nil } // setEncryptedSuffix set suffix, or an empty string func (c *Cipher) setEncryptedSuffix(suffix string) { if strings.EqualFold(suffix, "none") { c.encryptedSuffix = "" return } if !strings.HasPrefix(suffix, ".") { fs.Errorf(nil, "crypt: bad suffix: %v", ErrorSuffixMissingDot) suffix = "." + suffix } c.encryptedSuffix = suffix } // Call to set bad block pass through func (c *Cipher) setPassBadBlocks(passBadBlocks bool) { c.passBadBlocks = passBadBlocks } // Key creates all the internal keys from the password passed in using // scrypt. // // If salt is "" we use a fixed salt just to make attackers lives // slightly harder than using no salt. // // Note that empty password makes all 0x00 keys which is used in the // tests. func (c *Cipher) Key(password, salt string) (err error) { const keySize = len(c.dataKey) + len(c.nameKey) + len(c.nameTweak) var saltBytes = defaultSalt if salt != "" { saltBytes = []byte(salt) } var key []byte if password == "" { key = make([]byte, keySize) } else { key, err = scrypt.Key([]byte(password), saltBytes, 16384, 8, 1, keySize) if err != nil { return err } } copy(c.dataKey[:], key) copy(c.nameKey[:], key[len(c.dataKey):]) copy(c.nameTweak[:], key[len(c.dataKey)+len(c.nameKey):]) // Key the name cipher c.block, err = aes.NewCipher(c.nameKey[:]) return err } // getBlock gets a block from the pool of size blockSize func (c *Cipher) getBlock() *[blockSize]byte { return c.buffers.Get().(*[blockSize]byte) } // putBlock returns a block to the pool of size blockSize func (c *Cipher) putBlock(buf *[blockSize]byte) { c.buffers.Put(buf) } // encryptSegment encrypts a path segment // // This uses EME with AES. // // EME (ECB-Mix-ECB) is a wide-block encryption mode presented in the // 2003 paper "A Parallelizable Enciphering Mode" by Halevi and // Rogaway. // // This makes for deterministic encryption which is what we want - the // same filename must encrypt to the same thing. // // This means that // - filenames with the same name will encrypt the same // - filenames which start the same won't have a common prefix func (c *Cipher) encryptSegment(plaintext string) string { if plaintext == "" { return "" } paddedPlaintext := pkcs7.Pad(nameCipherBlockSize, []byte(plaintext)) ciphertext := eme.Transform(c.block, c.nameTweak[:], paddedPlaintext, eme.DirectionEncrypt) return c.fileNameEnc.EncodeToString(ciphertext) } // decryptSegment decrypts a path segment func (c *Cipher) decryptSegment(ciphertext string) (string, error) { if ciphertext == "" { return "", nil } rawCiphertext, err := c.fileNameEnc.DecodeString(ciphertext) if err != nil { return "", err } if len(rawCiphertext)%nameCipherBlockSize != 0 { return "", ErrorNotAMultipleOfBlocksize } if len(rawCiphertext) == 0 { // not possible if decodeFilename() working correctly return "", ErrorTooShortAfterDecode } if len(rawCiphertext) > 2048 { return "", ErrorTooLongAfterDecode } paddedPlaintext := eme.Transform(c.block, c.nameTweak[:], rawCiphertext, eme.DirectionDecrypt) plaintext, err := pkcs7.Unpad(nameCipherBlockSize, paddedPlaintext) if err != nil { return "", err } return string(plaintext), err } // Simple obfuscation routines func (c *Cipher) obfuscateSegment(plaintext string) string { if plaintext == "" { return "" } // If the string isn't valid UTF8 then don't rotate; just // prepend a !. if !utf8.ValidString(plaintext) { return "!." + plaintext } // Calculate a simple rotation based on the filename and // the nameKey var dir int for _, runeValue := range plaintext { dir += int(runeValue) } dir %= 256 // We'll use this number to store in the result filename... var result bytes.Buffer _, _ = result.WriteString(strconv.Itoa(dir) + ".") // but we'll augment it with the nameKey for real calculation for i := range len(c.nameKey) { dir += int(c.nameKey[i]) } // Now for each character, depending on the range it is in // we will actually rotate a different amount for _, runeValue := range plaintext { switch { case runeValue == obfuscQuoteRune: // Quote the Quote character _, _ = result.WriteRune(obfuscQuoteRune) _, _ = result.WriteRune(obfuscQuoteRune) case runeValue >= '0' && runeValue <= '9': // Number thisdir := (dir % 9) + 1 newRune := '0' + (int(runeValue)-'0'+thisdir)%10 _, _ = result.WriteRune(rune(newRune)) case (runeValue >= 'A' && runeValue <= 'Z') || (runeValue >= 'a' && runeValue <= 'z'): // ASCII letter. Try to avoid trivial A->a mappings thisdir := dir%25 + 1 // Calculate the offset of this character in A-Za-z pos := int(runeValue - 'A') if pos >= 26 { pos -= 6 // It's lower case } // Rotate the character to the new location pos = (pos + thisdir) % 52 if pos >= 26 { pos += 6 // and handle lower case offset again } _, _ = result.WriteRune(rune('A' + pos)) case runeValue >= 0xA0 && runeValue <= 0xFF: // Latin 1 supplement thisdir := (dir % 95) + 1 newRune := 0xA0 + (int(runeValue)-0xA0+thisdir)%96 _, _ = result.WriteRune(rune(newRune)) case runeValue >= 0x100: // Some random Unicode range; we have no good rules here thisdir := (dir % 127) + 1 base := int(runeValue - runeValue%256) newRune := rune(base + (int(runeValue)-base+thisdir)%256) // If the new character isn't a valid UTF8 char // then don't rotate it. Quote it instead if !utf8.ValidRune(newRune) { _, _ = result.WriteRune(obfuscQuoteRune) _, _ = result.WriteRune(runeValue) } else { _, _ = result.WriteRune(newRune) } default: // Leave character untouched _, _ = result.WriteRune(runeValue) } } return result.String() } func (c *Cipher) deobfuscateSegment(ciphertext string) (string, error) { if ciphertext == "" { return "", nil } pos := strings.Index(ciphertext, ".") if pos == -1 { return "", ErrorNotAnEncryptedFile } // No . num := ciphertext[:pos] if num == "!" { // No rotation; probably original was not valid unicode return ciphertext[pos+1:], nil } dir, err := strconv.Atoi(num) if err != nil { return "", ErrorNotAnEncryptedFile // Not a number } // add the nameKey to get the real rotate distance for i := range len(c.nameKey) { dir += int(c.nameKey[i]) } var result bytes.Buffer inQuote := false for _, runeValue := range ciphertext[pos+1:] { switch { case inQuote: _, _ = result.WriteRune(runeValue) inQuote = false case runeValue == obfuscQuoteRune: inQuote = true case runeValue >= '0' && runeValue <= '9': // Number thisdir := (dir % 9) + 1 newRune := '0' + int(runeValue) - '0' - thisdir if newRune < '0' { newRune += 10 } _, _ = result.WriteRune(rune(newRune)) case (runeValue >= 'A' && runeValue <= 'Z') || (runeValue >= 'a' && runeValue <= 'z'): thisdir := dir%25 + 1 pos := int(runeValue - 'A') if pos >= 26 { pos -= 6 } pos -= thisdir if pos < 0 { pos += 52 } if pos >= 26 { pos += 6 } _, _ = result.WriteRune(rune('A' + pos)) case runeValue >= 0xA0 && runeValue <= 0xFF: thisdir := (dir % 95) + 1 newRune := 0xA0 + int(runeValue) - 0xA0 - thisdir if newRune < 0xA0 { newRune += 96 } _, _ = result.WriteRune(rune(newRune)) case runeValue >= 0x100: thisdir := (dir % 127) + 1 base := int(runeValue - runeValue%256) newRune := rune(base + (int(runeValue) - base - thisdir)) if int(newRune) < base { newRune += 256 } _, _ = result.WriteRune(newRune) default: _, _ = result.WriteRune(runeValue) } } return result.String(), nil } // encryptFileName encrypts a file path func (c *Cipher) encryptFileName(in string) string { segments := strings.Split(in, "/") for i := range segments { // Skip directory name encryption if the user chose to // leave them intact if !c.dirNameEncrypt && i != (len(segments)-1) { continue } // Strip version string so that only the non-versioned part // of the file name gets encrypted/obfuscated hasVersion := false var t time.Time if i == (len(segments)-1) && version.Match(segments[i]) { var s string t, s = version.Remove(segments[i]) // version.Remove can fail, in which case it returns segments[i] if s != segments[i] { segments[i] = s hasVersion = true } } if c.mode == NameEncryptionStandard { segments[i] = c.encryptSegment(segments[i]) } else { segments[i] = c.obfuscateSegment(segments[i]) } // Add back a version to the encrypted/obfuscated // file name, if we stripped it off earlier if hasVersion { segments[i] = version.Add(segments[i], t) } } return strings.Join(segments, "/") } // EncryptFileName encrypts a file path func (c *Cipher) EncryptFileName(in string) string { if c.mode == NameEncryptionOff { return in + c.encryptedSuffix } return c.encryptFileName(in) } // EncryptDirName encrypts a directory path func (c *Cipher) EncryptDirName(in string) string { if c.mode == NameEncryptionOff || !c.dirNameEncrypt { return in } return c.encryptFileName(in) } // decryptFileName decrypts a file path func (c *Cipher) decryptFileName(in string) (string, error) { segments := strings.Split(in, "/") for i := range segments { var err error // Skip directory name decryption if the user chose to // leave them intact if !c.dirNameEncrypt && i != (len(segments)-1) { continue } // Strip version string so that only the non-versioned part // of the file name gets decrypted/deobfuscated hasVersion := false var t time.Time if i == (len(segments)-1) && version.Match(segments[i]) { var s string t, s = version.Remove(segments[i]) // version.Remove can fail, in which case it returns segments[i] if s != segments[i] { segments[i] = s hasVersion = true } } if c.mode == NameEncryptionStandard { segments[i], err = c.decryptSegment(segments[i]) } else { segments[i], err = c.deobfuscateSegment(segments[i]) } if err != nil { return "", err } // Add back a version to the decrypted/deobfuscated // file name, if we stripped it off earlier if hasVersion { segments[i] = version.Add(segments[i], t) } } return strings.Join(segments, "/"), nil } // DecryptFileName decrypts a file path func (c *Cipher) DecryptFileName(in string) (string, error) { if c.mode == NameEncryptionOff { remainingLength := len(in) - len(c.encryptedSuffix) if remainingLength == 0 || !strings.HasSuffix(in, c.encryptedSuffix) { return "", ErrorNotAnEncryptedFile } decrypted := in[:remainingLength] if version.Match(decrypted) { _, unversioned := version.Remove(decrypted) if unversioned == "" { return "", ErrorNotAnEncryptedFile } } // Leave the version string on, if it was there return decrypted, nil } return c.decryptFileName(in) } // DecryptDirName decrypts a directory path func (c *Cipher) DecryptDirName(in string) (string, error) { if c.mode == NameEncryptionOff || !c.dirNameEncrypt { return in, nil } return c.decryptFileName(in) } // NameEncryptionMode returns the encryption mode in use for names func (c *Cipher) NameEncryptionMode() NameEncryptionMode { return c.mode } // nonce is an NACL secretbox nonce type nonce [fileNonceSize]byte // pointer returns the nonce as a *[24]byte for secretbox func (n *nonce) pointer() *[fileNonceSize]byte { return (*[fileNonceSize]byte)(n) } // fromReader fills the nonce from an io.Reader - normally the OSes // crypto random number generator func (n *nonce) fromReader(in io.Reader) error { read, err := readers.ReadFill(in, (*n)[:]) if read != fileNonceSize { return fmt.Errorf("short read of nonce: %w", err) } return nil } // fromBuf fills the nonce from the buffer passed in func (n *nonce) fromBuf(buf []byte) { read := copy((*n)[:], buf) if read != fileNonceSize { panic("buffer to short to read nonce") } } // carry 1 up the nonce from position i func (n *nonce) carry(i int) { for ; i < len(*n); i++ { digit := (*n)[i] newDigit := digit + 1 (*n)[i] = newDigit if newDigit >= digit { // exit if no carry break } } } // increment to add 1 to the nonce func (n *nonce) increment() { n.carry(0) } // add a uint64 to the nonce func (n *nonce) add(x uint64) { carry := uint16(0) for i := range 8 { digit := (*n)[i] xDigit := byte(x) x >>= 8 carry += uint16(digit) + uint16(xDigit) (*n)[i] = byte(carry) carry >>= 8 } if carry != 0 { n.carry(8) } } // encrypter encrypts an io.Reader on the fly type encrypter struct { mu sync.Mutex in io.Reader c *Cipher nonce nonce buf *[blockSize]byte readBuf *[blockSize]byte bufIndex int bufSize int err error } // newEncrypter creates a new file handle encrypting on the fly func (c *Cipher) newEncrypter(in io.Reader, nonce *nonce) (*encrypter, error) { fh := &encrypter{ in: in, c: c, buf: c.getBlock(), readBuf: c.getBlock(), bufSize: fileHeaderSize, } // Initialise nonce if nonce != nil { fh.nonce = *nonce } else { err := fh.nonce.fromReader(c.cryptoRand) if err != nil { return nil, err } } // Copy magic into buffer copy((*fh.buf)[:], fileMagicBytes) // Copy nonce into buffer copy((*fh.buf)[fileMagicSize:], fh.nonce[:]) return fh, nil } // Read as per io.Reader func (fh *encrypter) Read(p []byte) (n int, err error) { fh.mu.Lock() defer fh.mu.Unlock() if fh.err != nil { return 0, fh.err } if fh.bufIndex >= fh.bufSize { // Read data // FIXME should overlap the reads with a go-routine and 2 buffers? readBuf := (*fh.readBuf)[:blockDataSize] n, err = readers.ReadFill(fh.in, readBuf) if n == 0 { return fh.finish(err) } // possibly err != nil here, but we will process the // data and the next call to ReadFill will return 0, err // Encrypt the block using the nonce secretbox.Seal((*fh.buf)[:0], readBuf[:n], fh.nonce.pointer(), &fh.c.dataKey) fh.bufIndex = 0 fh.bufSize = blockHeaderSize + n fh.nonce.increment() } n = copy(p, (*fh.buf)[fh.bufIndex:fh.bufSize]) fh.bufIndex += n return n, nil } // finish sets the final error and tidies up func (fh *encrypter) finish(err error) (int, error) { if fh.err != nil { return 0, fh.err } fh.err = err fh.c.putBlock(fh.buf) fh.buf = nil fh.c.putBlock(fh.readBuf) fh.readBuf = nil return 0, err } // Encrypt data encrypts the data stream func (c *Cipher) encryptData(in io.Reader) (io.Reader, *encrypter, error) { in, wrap := accounting.UnWrap(in) // unwrap the accounting off the Reader out, err := c.newEncrypter(in, nil) if err != nil { return nil, nil, err } return wrap(out), out, nil // and wrap the accounting back on } // EncryptData encrypts the data stream func (c *Cipher) EncryptData(in io.Reader) (io.Reader, error) { out, _, err := c.encryptData(in) return out, err } // decrypter decrypts an io.ReaderCloser on the fly type decrypter struct { mu sync.Mutex rc io.ReadCloser nonce nonce initialNonce nonce c *Cipher buf *[blockSize]byte readBuf *[blockSize]byte bufIndex int bufSize int err error limit int64 // limit of bytes to read, -1 for unlimited open OpenRangeSeek } // newDecrypter creates a new file handle decrypting on the fly func (c *Cipher) newDecrypter(rc io.ReadCloser) (*decrypter, error) { fh := &decrypter{ rc: rc, c: c, buf: c.getBlock(), readBuf: c.getBlock(), limit: -1, } // Read file header (magic + nonce) readBuf := (*fh.readBuf)[:fileHeaderSize] n, err := readers.ReadFill(fh.rc, readBuf) if n < fileHeaderSize && err == io.EOF { // This read from 0..fileHeaderSize-1 bytes return nil, fh.finishAndClose(ErrorEncryptedFileTooShort) } else if err != io.EOF && err != nil { return nil, fh.finishAndClose(err) } // check the magic if !bytes.Equal(readBuf[:fileMagicSize], fileMagicBytes) { return nil, fh.finishAndClose(ErrorEncryptedBadMagic) } // retrieve the nonce fh.nonce.fromBuf(readBuf[fileMagicSize:]) fh.initialNonce = fh.nonce return fh, nil } // newDecrypterSeek creates a new file handle decrypting on the fly func (c *Cipher) newDecrypterSeek(ctx context.Context, open OpenRangeSeek, offset, limit int64) (fh *decrypter, err error) { var rc io.ReadCloser doRangeSeek := false setLimit := false // Open initially with no seek if offset == 0 && limit < 0 { // If no offset or limit then open whole file rc, err = open(ctx, 0, -1) } else if offset == 0 { // If no offset open the header + limit worth of the file _, underlyingLimit, _, _ := calculateUnderlying(offset, limit) rc, err = open(ctx, 0, int64(fileHeaderSize)+underlyingLimit) setLimit = true } else { // Otherwise just read the header to start with rc, err = open(ctx, 0, int64(fileHeaderSize)) doRangeSeek = true } if err != nil { return nil, err } // Open the stream which fills in the nonce fh, err = c.newDecrypter(rc) if err != nil { return nil, err } fh.open = open // will be called by fh.RangeSeek if doRangeSeek { _, err = fh.RangeSeek(ctx, offset, io.SeekStart, limit) if err != nil { _ = fh.Close() return nil, err } } if setLimit { fh.limit = limit } return fh, nil } // read data into internal buffer - call with fh.mu held func (fh *decrypter) fillBuffer() (err error) { // FIXME should overlap the reads with a go-routine and 2 buffers? readBuf := fh.readBuf n, err := readers.ReadFill(fh.rc, (*readBuf)[:]) if n == 0 { return err } // possibly err != nil here, but we will process the data and // the next call to ReadFull will return 0, err // Check header + 1 byte exists if n <= blockHeaderSize { if err != nil && err != io.EOF { return err // return pending error as it is likely more accurate } return ErrorEncryptedFileBadHeader } // Decrypt the block using the nonce _, ok := secretbox.Open((*fh.buf)[:0], (*readBuf)[:n], fh.nonce.pointer(), &fh.c.dataKey) if !ok { if err != nil && err != io.EOF { return err // return pending error as it is likely more accurate } if !fh.c.passBadBlocks { return ErrorEncryptedBadBlock } fs.Errorf(nil, "crypt: ignoring: %v", ErrorEncryptedBadBlock) // Zero out the bad block and continue for i := range (*fh.buf)[:n] { fh.buf[i] = 0 } } fh.bufIndex = 0 fh.bufSize = n - blockHeaderSize fh.nonce.increment() return nil } // Read as per io.Reader func (fh *decrypter) Read(p []byte) (n int, err error) { fh.mu.Lock() defer fh.mu.Unlock() if fh.err != nil { return 0, fh.err } if fh.bufIndex >= fh.bufSize { err = fh.fillBuffer() if err != nil { return 0, fh.finish(err) } } toCopy := fh.bufSize - fh.bufIndex if fh.limit >= 0 && fh.limit < int64(toCopy) { toCopy = int(fh.limit) } n = copy(p, (*fh.buf)[fh.bufIndex:fh.bufIndex+toCopy]) fh.bufIndex += n if fh.limit >= 0 { fh.limit -= int64(n) if fh.limit == 0 { return n, fh.finish(io.EOF) } } return n, nil } // calculateUnderlying converts an (offset, limit) in an encrypted file // into an (underlyingOffset, underlyingLimit) for the underlying file. // // It also returns number of bytes to discard after reading the first // block and number of blocks this is from the start so the nonce can // be incremented. func calculateUnderlying(offset, limit int64) (underlyingOffset, underlyingLimit, discard, blocks int64) { // blocks we need to seek, plus bytes we need to discard blocks, discard = offset/blockDataSize, offset%blockDataSize // Offset in underlying stream we need to seek underlyingOffset = int64(fileHeaderSize) + blocks*(blockHeaderSize+blockDataSize) // work out how many blocks we need to read underlyingLimit = int64(-1) if limit >= 0 { // bytes to read beyond the first block bytesToRead := limit - (blockDataSize - discard) // Read the first block blocksToRead := int64(1) if bytesToRead > 0 { // Blocks that need to be read plus left over blocks extraBlocksToRead, endBytes := bytesToRead/blockDataSize, bytesToRead%blockDataSize if endBytes != 0 { // If left over bytes must read another block extraBlocksToRead++ } blocksToRead += extraBlocksToRead } // Must read a whole number of blocks underlyingLimit = blocksToRead * (blockHeaderSize + blockDataSize) } return } // RangeSeek behaves like a call to Seek(offset int64, whence // int) with the output wrapped in an io.LimitedReader // limiting the total length to limit. // // RangeSeek with a limit of < 0 is equivalent to a regular Seek. func (fh *decrypter) RangeSeek(ctx context.Context, offset int64, whence int, limit int64) (int64, error) { fh.mu.Lock() defer fh.mu.Unlock() if fh.open == nil { return 0, fh.finish(errors.New("can't seek - not initialised with newDecrypterSeek")) } if whence != io.SeekStart { return 0, fh.finish(errors.New("can only seek from the start")) } // Reset error or return it if not EOF if fh.err == io.EOF { fh.unFinish() } else if fh.err != nil { return 0, fh.err } underlyingOffset, underlyingLimit, discard, blocks := calculateUnderlying(offset, limit) // Move the nonce on the correct number of blocks from the start fh.nonce = fh.initialNonce fh.nonce.add(uint64(blocks)) // Can we seek underlying stream directly? if do, ok := fh.rc.(fs.RangeSeeker); ok { // Seek underlying stream directly _, err := do.RangeSeek(ctx, underlyingOffset, 0, underlyingLimit) if err != nil { return 0, fh.finish(err) } } else { // if not reopen with seek _ = fh.rc.Close() // close underlying file fh.rc = nil // Re-open the underlying object with the offset given rc, err := fh.open(ctx, underlyingOffset, underlyingLimit) if err != nil { return 0, fh.finish(fmt.Errorf("couldn't reopen file with offset and limit: %w", err)) } // Set the file handle fh.rc = rc } // Fill the buffer err := fh.fillBuffer() if err != nil { return 0, fh.finish(err) } // Discard bytes from the buffer if int(discard) > fh.bufSize { return 0, fh.finish(ErrorBadSeek) } fh.bufIndex = int(discard) // Set the limit fh.limit = limit return offset, nil } // Seek implements the io.Seeker interface func (fh *decrypter) Seek(offset int64, whence int) (int64, error) { return fh.RangeSeek(context.TODO(), offset, whence, -1) } // finish sets the final error and tidies up func (fh *decrypter) finish(err error) error { if fh.err != nil { return fh.err } fh.err = err fh.c.putBlock(fh.buf) fh.buf = nil fh.c.putBlock(fh.readBuf) fh.readBuf = nil return err } // unFinish undoes the effects of finish func (fh *decrypter) unFinish() { // Clear error fh.err = nil // reinstate the buffers fh.buf = fh.c.getBlock() fh.readBuf = fh.c.getBlock() // Empty the buffer fh.bufIndex = 0 fh.bufSize = 0 } // Close func (fh *decrypter) Close() error { fh.mu.Lock() defer fh.mu.Unlock() // Check already closed if fh.err == ErrorFileClosed { return fh.err } // Closed before reading EOF so not finish()ed yet if fh.err == nil { _ = fh.finish(io.EOF) } // Show file now closed fh.err = ErrorFileClosed if fh.rc == nil { return nil } return fh.rc.Close() } // finishAndClose does finish then Close() // // Used when we are returning a nil fh from new func (fh *decrypter) finishAndClose(err error) error { _ = fh.finish(err) _ = fh.Close() return err } // DecryptData decrypts the data stream func (c *Cipher) DecryptData(rc io.ReadCloser) (io.ReadCloser, error) { out, err := c.newDecrypter(rc) if err != nil { return nil, err } return out, nil } // DecryptDataSeek decrypts the data stream from offset // // The open function must return a ReadCloser opened to the offset supplied. // // You must use this form of DecryptData if you might want to Seek the file handle func (c *Cipher) DecryptDataSeek(ctx context.Context, open OpenRangeSeek, offset, limit int64) (ReadSeekCloser, error) { out, err := c.newDecrypterSeek(ctx, open, offset, limit) if err != nil { return nil, err } return out, nil } // EncryptedSize calculates the size of the data when encrypted func (c *Cipher) EncryptedSize(size int64) int64 { blocks, residue := size/blockDataSize, size%blockDataSize encryptedSize := int64(fileHeaderSize) + blocks*(blockHeaderSize+blockDataSize) if residue != 0 { encryptedSize += blockHeaderSize + residue } return encryptedSize } // DecryptedSize calculates the size of the data when decrypted func (c *Cipher) DecryptedSize(size int64) (int64, error) { size -= int64(fileHeaderSize) if size < 0 { return 0, ErrorEncryptedFileTooShort } blocks, residue := size/blockSize, size%blockSize decryptedSize := blocks * blockDataSize if residue != 0 { residue -= blockHeaderSize if residue <= 0 { return 0, ErrorEncryptedFileBadHeader } } decryptedSize += residue return decryptedSize, nil } // check interfaces var ( _ io.ReadCloser = (*decrypter)(nil) _ io.Seeker = (*decrypter)(nil) _ fs.RangeSeeker = (*decrypter)(nil) _ io.Reader = (*encrypter)(nil) ) rclone-v1.71.0/backend/crypt/cipher_test.go000066400000000000000000001734031505210326400206460ustar00rootroot00000000000000package crypt import ( "bytes" "context" "encoding/base32" "encoding/base64" "errors" "fmt" "io" "strings" "testing" "github.com/Max-Sum/base32768" "github.com/rclone/rclone/backend/crypt/pkcs7" "github.com/rclone/rclone/lib/readers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestNewNameEncryptionMode(t *testing.T) { for _, test := range []struct { in string expected NameEncryptionMode expectedErr string }{ {"off", NameEncryptionOff, ""}, {"standard", NameEncryptionStandard, ""}, {"obfuscate", NameEncryptionObfuscated, ""}, {"potato", NameEncryptionOff, "unknown file name encryption mode \"potato\""}, } { actual, actualErr := NewNameEncryptionMode(test.in) assert.Equal(t, actual, test.expected) if test.expectedErr == "" { assert.NoError(t, actualErr) } else { assert.EqualError(t, actualErr, test.expectedErr) } } } func TestNewNameEncryptionModeString(t *testing.T) { assert.Equal(t, NameEncryptionOff.String(), "off") assert.Equal(t, NameEncryptionStandard.String(), "standard") assert.Equal(t, NameEncryptionObfuscated.String(), "obfuscate") assert.Equal(t, NameEncryptionMode(3).String(), "Unknown mode #3") } type EncodingTestCase struct { in string expected string } func testEncodeFileName(t *testing.T, encoding string, testCases []EncodingTestCase, caseInsensitive bool) { for _, test := range testCases { enc, err := NewNameEncoding(encoding) assert.NoError(t, err, "There should be no error creating name encoder for base32.") actual := enc.EncodeToString([]byte(test.in)) assert.Equal(t, actual, test.expected, fmt.Sprintf("in=%q", test.in)) recovered, err := enc.DecodeString(test.expected) assert.NoError(t, err) assert.Equal(t, string(recovered), test.in, fmt.Sprintf("reverse=%q", test.expected)) if caseInsensitive { in := strings.ToUpper(test.expected) recovered, err = enc.DecodeString(in) assert.NoError(t, err) assert.Equal(t, string(recovered), test.in, fmt.Sprintf("reverse=%q", in)) } } } func TestEncodeFileNameBase32(t *testing.T) { testEncodeFileName(t, "base32", []EncodingTestCase{ {"", ""}, {"1", "64"}, {"12", "64p0"}, {"123", "64p36"}, {"1234", "64p36d0"}, {"12345", "64p36d1l"}, {"123456", "64p36d1l6o"}, {"1234567", "64p36d1l6org"}, {"12345678", "64p36d1l6orjg"}, {"123456789", "64p36d1l6orjge8"}, {"1234567890", "64p36d1l6orjge9g"}, {"12345678901", "64p36d1l6orjge9g64"}, {"123456789012", "64p36d1l6orjge9g64p0"}, {"1234567890123", "64p36d1l6orjge9g64p36"}, {"12345678901234", "64p36d1l6orjge9g64p36d0"}, {"123456789012345", "64p36d1l6orjge9g64p36d1l"}, {"1234567890123456", "64p36d1l6orjge9g64p36d1l6o"}, }, true) } func TestEncodeFileNameBase64(t *testing.T) { testEncodeFileName(t, "base64", []EncodingTestCase{ {"", ""}, {"1", "MQ"}, {"12", "MTI"}, {"123", "MTIz"}, {"1234", "MTIzNA"}, {"12345", "MTIzNDU"}, {"123456", "MTIzNDU2"}, {"1234567", "MTIzNDU2Nw"}, {"12345678", "MTIzNDU2Nzg"}, {"123456789", "MTIzNDU2Nzg5"}, {"1234567890", "MTIzNDU2Nzg5MA"}, {"12345678901", "MTIzNDU2Nzg5MDE"}, {"123456789012", "MTIzNDU2Nzg5MDEy"}, {"1234567890123", "MTIzNDU2Nzg5MDEyMw"}, {"12345678901234", "MTIzNDU2Nzg5MDEyMzQ"}, {"123456789012345", "MTIzNDU2Nzg5MDEyMzQ1"}, {"1234567890123456", "MTIzNDU2Nzg5MDEyMzQ1Ng"}, }, false) } func TestEncodeFileNameBase32768(t *testing.T) { testEncodeFileName(t, "base32768", []EncodingTestCase{ {"", ""}, {"1", "㼿"}, {"12", "㻙ɟ"}, {"123", "㻙ⲿ"}, {"1234", "㻙ⲍƟ"}, {"12345", "㻙ⲍ⍟"}, {"123456", "㻙ⲍ⍆ʏ"}, {"1234567", "㻙ⲍ⍆觟"}, {"12345678", "㻙ⲍ⍆觓ɧ"}, {"123456789", "㻙ⲍ⍆觓栯"}, {"1234567890", "㻙ⲍ⍆觓栩ɣ"}, {"12345678901", "㻙ⲍ⍆觓栩朧"}, {"123456789012", "㻙ⲍ⍆觓栩朤ʅ"}, {"1234567890123", "㻙ⲍ⍆觓栩朤談"}, {"12345678901234", "㻙ⲍ⍆觓栩朤諆ɔ"}, {"123456789012345", "㻙ⲍ⍆觓栩朤諆媕"}, {"1234567890123456", "㻙ⲍ⍆觓栩朤諆媕䆿"}, }, false) } func TestDecodeFileNameBase32(t *testing.T) { enc, err := NewNameEncoding("base32") assert.NoError(t, err, "There should be no error creating name encoder for base32.") // We've tested decoding the valid ones above, now concentrate on the invalid ones for _, test := range []struct { in string expectedErr error }{ {"64=", ErrorBadBase32Encoding}, {"!", base32.CorruptInputError(0)}, {"hello=hello", base32.CorruptInputError(5)}, } { actual, actualErr := enc.DecodeString(test.in) assert.Equal(t, test.expectedErr, actualErr, fmt.Sprintf("in=%q got actual=%q, err = %v %T", test.in, actual, actualErr, actualErr)) } } func TestDecodeFileNameBase64(t *testing.T) { enc, err := NewNameEncoding("base64") assert.NoError(t, err, "There should be no error creating name encoder for base32.") // We've tested decoding the valid ones above, now concentrate on the invalid ones for _, test := range []struct { in string expectedErr error }{ {"64=", base64.CorruptInputError(2)}, {"!", base64.CorruptInputError(0)}, {"Hello=Hello", base64.CorruptInputError(5)}, } { actual, actualErr := enc.DecodeString(test.in) assert.Equal(t, test.expectedErr, actualErr, fmt.Sprintf("in=%q got actual=%q, err = %v %T", test.in, actual, actualErr, actualErr)) } } func TestDecodeFileNameBase32768(t *testing.T) { enc, err := NewNameEncoding("base32768") assert.NoError(t, err, "There should be no error creating name encoder for base32.") // We've tested decoding the valid ones above, now concentrate on the invalid ones for _, test := range []struct { in string expectedErr error }{ {"㼿c", base32768.CorruptInputError(1)}, {"!", base32768.CorruptInputError(0)}, {"㻙ⲿ=㻙ⲿ", base32768.CorruptInputError(2)}, } { actual, actualErr := enc.DecodeString(test.in) assert.Equal(t, test.expectedErr, actualErr, fmt.Sprintf("in=%q got actual=%q, err = %v %T", test.in, actual, actualErr, actualErr)) } } func testEncryptSegment(t *testing.T, encoding string, testCases []EncodingTestCase, caseInsensitive bool) { enc, _ := NewNameEncoding(encoding) c, _ := newCipher(NameEncryptionStandard, "", "", true, enc) for _, test := range testCases { actual := c.encryptSegment(test.in) assert.Equal(t, test.expected, actual, fmt.Sprintf("Testing %q", test.in)) recovered, err := c.decryptSegment(test.expected) assert.NoError(t, err, fmt.Sprintf("Testing reverse %q", test.expected)) assert.Equal(t, test.in, recovered, fmt.Sprintf("Testing reverse %q", test.expected)) if caseInsensitive { in := strings.ToUpper(test.expected) recovered, err = c.decryptSegment(in) assert.NoError(t, err, fmt.Sprintf("Testing reverse %q", in)) assert.Equal(t, test.in, recovered, fmt.Sprintf("Testing reverse %q", in)) } } } func TestEncryptSegmentBase32(t *testing.T) { testEncryptSegment(t, "base32", []EncodingTestCase{ {"", ""}, {"1", "p0e52nreeaj0a5ea7s64m4j72s"}, {"12", "l42g6771hnv3an9cgc8cr2n1ng"}, {"123", "qgm4avr35m5loi1th53ato71v0"}, {"1234", "8ivr2e9plj3c3esisjpdisikos"}, {"12345", "rh9vu63q3o29eqmj4bg6gg7s44"}, {"123456", "bn717l3alepn75b2fb2ejmi4b4"}, {"1234567", "n6bo9jmb1qe3b1ogtj5qkf19k8"}, {"12345678", "u9t24j7uaq94dh5q53m3s4t9ok"}, {"123456789", "37hn305g6j12d1g0kkrl7ekbs4"}, {"1234567890", "ot8d91eplaglb62k2b1trm2qv0"}, {"12345678901", "h168vvrgb53qnrtvvmb378qrcs"}, {"123456789012", "s3hsdf9e29ithrqbjqu01t8q2s"}, {"1234567890123", "cf3jimlv1q2oc553mv7s3mh3eo"}, {"12345678901234", "moq0uqdlqrblrc5pa5u5c7hq9g"}, {"123456789012345", "eeam3li4rnommi3a762h5n7meg"}, {"1234567890123456", "mijbj0frqf6ms7frcr6bd9h0env53jv96pjaaoirk7forcgpt70g"}, }, true) } func TestEncryptSegmentBase64(t *testing.T) { testEncryptSegment(t, "base64", []EncodingTestCase{ {"", ""}, {"1", "yBxRX25ypgUVyj8MSxJnFw"}, {"12", "qQUDHOGN_jVdLIMQzYrhvA"}, {"123", "1CxFf2Mti1xIPYlGruDh-A"}, {"1234", "RL-xOTmsxsG7kuTy2XJUxw"}, {"12345", "3FP_GHoeBJdq0yLgaED8IQ"}, {"123456", "Xc4T1Gqrs3OVYnrE6dpEWQ"}, {"1234567", "uZeEzssOnDWHEOzLqjwpog"}, {"12345678", "8noiTP5WkkbEuijsPhOpxQ"}, {"123456789", "GeNxgLA0wiaGAKU3U7qL4Q"}, {"1234567890", "x1DUhdmqoVWYVBLD3dha-A"}, {"12345678901", "iEyP_3BZR6vvv_2WM6NbZw"}, {"123456789012", "4OPGvS4SZdjvS568APUaFw"}, {"1234567890123", "Y8c5Wr8OhYYUo7fPwdojdg"}, {"12345678901234", "tjQPabXW112wuVF8Vh46TA"}, {"123456789012345", "c5Vh1kTd8WtIajmFEtz2dA"}, {"1234567890123456", "tKa5gfvTzW4d-2bMtqYgdf5Rz-k2ZqViW6HfjbIZ6cE"}, }, false) } func TestEncryptSegmentBase32768(t *testing.T) { testEncryptSegment(t, "base32768", []EncodingTestCase{ {"", ""}, {"1", "詮㪗鐮僀伎作㻖㢧⪟"}, {"12", "竢朧䉱虃光塬䟛⣡蓟"}, {"123", "遶㞟鋅缕袡鲅ⵝ蝁ꌟ"}, {"1234", "䢟銮䵵狌㐜燳谒颴詟"}, {"12345", "钉Ꞇ㖃蚩憶狫朰杜㜿"}, {"123456", "啇ᚵⵕ憗䋫➫➓肤卟"}, {"1234567", "茫螓翁連劘樓㶔抉矟"}, {"12345678", "龝☳䘊辄岅較络㧩襟"}, {"123456789", "ⲱ苀㱆犂媐Ꮤ锇惫靟"}, {"1234567890", "計宁憕偵匢皫╛纺ꌟ"}, {"12345678901", "檆䨿鑫㪺藝ꡖ勇䦛婟"}, {"123456789012", "雑頏䰂䲝淚哚鹡魺⪟"}, {"1234567890123", "塃璶繁躸圅㔟䗃肃懟"}, {"12345678901234", "腺ᕚ崚鏕鏥讥鼌䑺䲿"}, {"123456789012345", "怪绕滻蕶肣但⠥荖惟"}, {"1234567890123456", "肳哀旚挶靏鏻㾭䱠慟㪳ꏆ賊兲铧敻塹魀ʟ"}, }, false) } func TestDecryptSegmentBase32(t *testing.T) { // We've tested the forwards above, now concentrate on the errors longName := make([]byte, 3328) for i := range longName { longName[i] = 'a' } enc, _ := NewNameEncoding("base32") c, _ := newCipher(NameEncryptionStandard, "", "", true, enc) for _, test := range []struct { in string expectedErr error }{ {"64=", ErrorBadBase32Encoding}, {"!", base32.CorruptInputError(0)}, {string(longName), ErrorTooLongAfterDecode}, {enc.EncodeToString([]byte("a")), ErrorNotAMultipleOfBlocksize}, {enc.EncodeToString([]byte("123456789abcdef")), ErrorNotAMultipleOfBlocksize}, {enc.EncodeToString([]byte("123456789abcdef0")), pkcs7.ErrorPaddingTooLong}, } { actual, actualErr := c.decryptSegment(test.in) assert.Equal(t, test.expectedErr, actualErr, fmt.Sprintf("in=%q got actual=%q, err = %v %T", test.in, actual, actualErr, actualErr)) } } func TestDecryptSegmentBase64(t *testing.T) { // We've tested the forwards above, now concentrate on the errors longName := make([]byte, 2816) for i := range longName { longName[i] = 'a' } enc, _ := NewNameEncoding("base64") c, _ := newCipher(NameEncryptionStandard, "", "", true, enc) for _, test := range []struct { in string expectedErr error }{ {"6H=", base64.CorruptInputError(2)}, {"!", base64.CorruptInputError(0)}, {string(longName), ErrorTooLongAfterDecode}, {enc.EncodeToString([]byte("a")), ErrorNotAMultipleOfBlocksize}, {enc.EncodeToString([]byte("123456789abcdef")), ErrorNotAMultipleOfBlocksize}, {enc.EncodeToString([]byte("123456789abcdef0")), pkcs7.ErrorPaddingTooLong}, } { actual, actualErr := c.decryptSegment(test.in) assert.Equal(t, test.expectedErr, actualErr, fmt.Sprintf("in=%q got actual=%q, err = %v %T", test.in, actual, actualErr, actualErr)) } } func TestDecryptSegmentBase32768(t *testing.T) { // We've tested the forwards above, now concentrate on the errors longName := strings.Repeat("怪", 1280) enc, _ := NewNameEncoding("base32768") c, _ := newCipher(NameEncryptionStandard, "", "", true, enc) for _, test := range []struct { in string expectedErr error }{ {"怪=", base32768.CorruptInputError(1)}, {"!", base32768.CorruptInputError(0)}, {longName, ErrorTooLongAfterDecode}, {enc.EncodeToString([]byte("a")), ErrorNotAMultipleOfBlocksize}, {enc.EncodeToString([]byte("123456789abcdef")), ErrorNotAMultipleOfBlocksize}, {enc.EncodeToString([]byte("123456789abcdef0")), pkcs7.ErrorPaddingTooLong}, } { actual, actualErr := c.decryptSegment(test.in) assert.Equal(t, test.expectedErr, actualErr, fmt.Sprintf("in=%q got actual=%q, err = %v %T", test.in, actual, actualErr, actualErr)) } } func testStandardEncryptFileName(t *testing.T, encoding string, testCasesEncryptDir []EncodingTestCase, testCasesNoEncryptDir []EncodingTestCase) { // First standard mode enc, _ := NewNameEncoding(encoding) c, _ := newCipher(NameEncryptionStandard, "", "", true, enc) for _, test := range testCasesEncryptDir { assert.Equal(t, test.expected, c.EncryptFileName(test.in)) } // Standard mode with directory name encryption off c, _ = newCipher(NameEncryptionStandard, "", "", false, enc) for _, test := range testCasesNoEncryptDir { assert.Equal(t, test.expected, c.EncryptFileName(test.in)) } } func TestStandardEncryptFileNameBase32(t *testing.T) { testStandardEncryptFileName(t, "base32", []EncodingTestCase{ {"1", "p0e52nreeaj0a5ea7s64m4j72s"}, {"1/12", "p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng"}, {"1/12/123", "p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng/qgm4avr35m5loi1th53ato71v0"}, {"1-v2001-02-03-040506-123", "p0e52nreeaj0a5ea7s64m4j72s-v2001-02-03-040506-123"}, {"1/12-v2001-02-03-040506-123", "p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng-v2001-02-03-040506-123"}, }, []EncodingTestCase{ {"1", "p0e52nreeaj0a5ea7s64m4j72s"}, {"1/12", "1/l42g6771hnv3an9cgc8cr2n1ng"}, {"1/12/123", "1/12/qgm4avr35m5loi1th53ato71v0"}, {"1-v2001-02-03-040506-123", "p0e52nreeaj0a5ea7s64m4j72s-v2001-02-03-040506-123"}, {"1/12-v2001-02-03-040506-123", "1/l42g6771hnv3an9cgc8cr2n1ng-v2001-02-03-040506-123"}, }) } func TestStandardEncryptFileNameBase64(t *testing.T) { testStandardEncryptFileName(t, "base64", []EncodingTestCase{ {"1", "yBxRX25ypgUVyj8MSxJnFw"}, {"1/12", "yBxRX25ypgUVyj8MSxJnFw/qQUDHOGN_jVdLIMQzYrhvA"}, {"1/12/123", "yBxRX25ypgUVyj8MSxJnFw/qQUDHOGN_jVdLIMQzYrhvA/1CxFf2Mti1xIPYlGruDh-A"}, {"1-v2001-02-03-040506-123", "yBxRX25ypgUVyj8MSxJnFw-v2001-02-03-040506-123"}, {"1/12-v2001-02-03-040506-123", "yBxRX25ypgUVyj8MSxJnFw/qQUDHOGN_jVdLIMQzYrhvA-v2001-02-03-040506-123"}, }, []EncodingTestCase{ {"1", "yBxRX25ypgUVyj8MSxJnFw"}, {"1/12", "1/qQUDHOGN_jVdLIMQzYrhvA"}, {"1/12/123", "1/12/1CxFf2Mti1xIPYlGruDh-A"}, {"1-v2001-02-03-040506-123", "yBxRX25ypgUVyj8MSxJnFw-v2001-02-03-040506-123"}, {"1/12-v2001-02-03-040506-123", "1/qQUDHOGN_jVdLIMQzYrhvA-v2001-02-03-040506-123"}, }) } func TestStandardEncryptFileNameBase32768(t *testing.T) { testStandardEncryptFileName(t, "base32768", []EncodingTestCase{ {"1", "詮㪗鐮僀伎作㻖㢧⪟"}, {"1/12", "詮㪗鐮僀伎作㻖㢧⪟/竢朧䉱虃光塬䟛⣡蓟"}, {"1/12/123", "詮㪗鐮僀伎作㻖㢧⪟/竢朧䉱虃光塬䟛⣡蓟/遶㞟鋅缕袡鲅ⵝ蝁ꌟ"}, {"1-v2001-02-03-040506-123", "詮㪗鐮僀伎作㻖㢧⪟-v2001-02-03-040506-123"}, {"1/12-v2001-02-03-040506-123", "詮㪗鐮僀伎作㻖㢧⪟/竢朧䉱虃光塬䟛⣡蓟-v2001-02-03-040506-123"}, }, []EncodingTestCase{ {"1", "詮㪗鐮僀伎作㻖㢧⪟"}, {"1/12", "1/竢朧䉱虃光塬䟛⣡蓟"}, {"1/12/123", "1/12/遶㞟鋅缕袡鲅ⵝ蝁ꌟ"}, {"1-v2001-02-03-040506-123", "詮㪗鐮僀伎作㻖㢧⪟-v2001-02-03-040506-123"}, {"1/12-v2001-02-03-040506-123", "1/竢朧䉱虃光塬䟛⣡蓟-v2001-02-03-040506-123"}, }) } func TestNonStandardEncryptFileName(t *testing.T) { // Off mode c, _ := newCipher(NameEncryptionOff, "", "", true, nil) assert.Equal(t, "1/12/123.bin", c.EncryptFileName("1/12/123")) // Off mode with custom suffix c, _ = newCipher(NameEncryptionOff, "", "", true, nil) c.setEncryptedSuffix(".jpg") assert.Equal(t, "1/12/123.jpg", c.EncryptFileName("1/12/123")) // Off mode with empty suffix c.setEncryptedSuffix("none") assert.Equal(t, "1/12/123", c.EncryptFileName("1/12/123")) // Obfuscation mode c, _ = newCipher(NameEncryptionObfuscated, "", "", true, nil) assert.Equal(t, "49.6/99.23/150.890/53.!!lipps", c.EncryptFileName("1/12/123/!hello")) assert.Equal(t, "49.6/99.23/150.890/53-v2001-02-03-040506-123.!!lipps", c.EncryptFileName("1/12/123/!hello-v2001-02-03-040506-123")) assert.Equal(t, "49.6/99.23/150.890/162.uryyB-v2001-02-03-040506-123.GKG", c.EncryptFileName("1/12/123/hello-v2001-02-03-040506-123.txt")) assert.Equal(t, "161.\u00e4", c.EncryptFileName("\u00a1")) assert.Equal(t, "160.\u03c2", c.EncryptFileName("\u03a0")) // Obfuscation mode with directory name encryption off c, _ = newCipher(NameEncryptionObfuscated, "", "", false, nil) assert.Equal(t, "1/12/123/53.!!lipps", c.EncryptFileName("1/12/123/!hello")) assert.Equal(t, "1/12/123/53-v2001-02-03-040506-123.!!lipps", c.EncryptFileName("1/12/123/!hello-v2001-02-03-040506-123")) assert.Equal(t, "161.\u00e4", c.EncryptFileName("\u00a1")) assert.Equal(t, "160.\u03c2", c.EncryptFileName("\u03a0")) } func testStandardDecryptFileName(t *testing.T, encoding string, testCases []EncodingTestCase, caseInsensitive bool) { enc, _ := NewNameEncoding(encoding) for _, test := range testCases { // Test when dirNameEncrypt=true c, _ := newCipher(NameEncryptionStandard, "", "", true, enc) actual, actualErr := c.DecryptFileName(test.in) assert.NoError(t, actualErr) assert.Equal(t, test.expected, actual) if caseInsensitive { c, _ := newCipher(NameEncryptionStandard, "", "", true, enc) actual, actualErr := c.DecryptFileName(strings.ToUpper(test.in)) assert.NoError(t, actualErr) assert.Equal(t, test.expected, actual) } // Add a character should raise ErrorNotAMultipleOfBlocksize actual, actualErr = c.DecryptFileName(enc.EncodeToString([]byte("1")) + test.in) assert.Equal(t, ErrorNotAMultipleOfBlocksize, actualErr) assert.Equal(t, "", actual) // Test when dirNameEncrypt=false noDirEncryptIn := test.in if strings.LastIndex(test.expected, "/") != -1 { noDirEncryptIn = test.expected[:strings.LastIndex(test.expected, "/")] + test.in[strings.LastIndex(test.in, "/"):] } c, _ = newCipher(NameEncryptionStandard, "", "", false, enc) actual, actualErr = c.DecryptFileName(noDirEncryptIn) assert.NoError(t, actualErr) assert.Equal(t, test.expected, actual) } } func TestStandardDecryptFileNameBase32(t *testing.T) { testStandardDecryptFileName(t, "base32", []EncodingTestCase{ {"p0e52nreeaj0a5ea7s64m4j72s", "1"}, {"p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng", "1/12"}, {"p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng/qgm4avr35m5loi1th53ato71v0", "1/12/123"}, }, true) } func TestStandardDecryptFileNameBase64(t *testing.T) { testStandardDecryptFileName(t, "base64", []EncodingTestCase{ {"yBxRX25ypgUVyj8MSxJnFw", "1"}, {"yBxRX25ypgUVyj8MSxJnFw/qQUDHOGN_jVdLIMQzYrhvA", "1/12"}, {"yBxRX25ypgUVyj8MSxJnFw/qQUDHOGN_jVdLIMQzYrhvA/1CxFf2Mti1xIPYlGruDh-A", "1/12/123"}, }, false) } func TestStandardDecryptFileNameBase32768(t *testing.T) { testStandardDecryptFileName(t, "base32768", []EncodingTestCase{ {"詮㪗鐮僀伎作㻖㢧⪟", "1"}, {"詮㪗鐮僀伎作㻖㢧⪟/竢朧䉱虃光塬䟛⣡蓟", "1/12"}, {"詮㪗鐮僀伎作㻖㢧⪟/竢朧䉱虃光塬䟛⣡蓟/遶㞟鋅缕袡鲅ⵝ蝁ꌟ", "1/12/123"}, }, false) } func TestNonStandardDecryptFileName(t *testing.T) { for _, encoding := range []string{"base32", "base64", "base32768"} { enc, _ := NewNameEncoding(encoding) for _, test := range []struct { mode NameEncryptionMode dirNameEncrypt bool in string expected string expectedErr error customSuffix string }{ {NameEncryptionOff, true, "1/12/123.bin", "1/12/123", nil, ""}, {NameEncryptionOff, true, "1/12/123.bix", "", ErrorNotAnEncryptedFile, ""}, {NameEncryptionOff, true, ".bin", "", ErrorNotAnEncryptedFile, ""}, {NameEncryptionOff, true, "1/12/123-v2001-02-03-040506-123.bin", "1/12/123-v2001-02-03-040506-123", nil, ""}, {NameEncryptionOff, true, "1/12/123-v1970-01-01-010101-123-v2001-02-03-040506-123.bin", "1/12/123-v1970-01-01-010101-123-v2001-02-03-040506-123", nil, ""}, {NameEncryptionOff, true, "1/12/123-v1970-01-01-010101-123-v2001-02-03-040506-123.txt.bin", "1/12/123-v1970-01-01-010101-123-v2001-02-03-040506-123.txt", nil, ""}, {NameEncryptionOff, true, "1/12/123.jpg", "1/12/123", nil, ".jpg"}, {NameEncryptionOff, true, "1/12/123", "1/12/123", nil, "none"}, {NameEncryptionObfuscated, true, "!.hello", "hello", nil, ""}, {NameEncryptionObfuscated, true, "hello", "", ErrorNotAnEncryptedFile, ""}, {NameEncryptionObfuscated, true, "161.\u00e4", "\u00a1", nil, ""}, {NameEncryptionObfuscated, true, "160.\u03c2", "\u03a0", nil, ""}, {NameEncryptionObfuscated, false, "1/12/123/53.!!lipps", "1/12/123/!hello", nil, ""}, {NameEncryptionObfuscated, false, "1/12/123/53-v2001-02-03-040506-123.!!lipps", "1/12/123/!hello-v2001-02-03-040506-123", nil, ""}, } { c, _ := newCipher(test.mode, "", "", test.dirNameEncrypt, enc) if test.customSuffix != "" { c.setEncryptedSuffix(test.customSuffix) } actual, actualErr := c.DecryptFileName(test.in) what := fmt.Sprintf("Testing %q (mode=%v)", test.in, test.mode) assert.Equal(t, test.expected, actual, what) assert.Equal(t, test.expectedErr, actualErr, what) } } } func TestEncDecMatches(t *testing.T) { for _, encoding := range []string{"base32", "base64", "base32768"} { enc, _ := NewNameEncoding(encoding) for _, test := range []struct { mode NameEncryptionMode in string }{ {NameEncryptionStandard, "1/2/3/4"}, {NameEncryptionOff, "1/2/3/4"}, {NameEncryptionObfuscated, "1/2/3/4/!hello\u03a0"}, {NameEncryptionObfuscated, "Avatar The Last Airbender"}, } { c, _ := newCipher(test.mode, "", "", true, enc) out, err := c.DecryptFileName(c.EncryptFileName(test.in)) what := fmt.Sprintf("Testing %q (mode=%v)", test.in, test.mode) assert.Equal(t, out, test.in, what) assert.Equal(t, err, nil, what) } } } func testStandardEncryptDirName(t *testing.T, encoding string, testCases []EncodingTestCase) { enc, _ := NewNameEncoding(encoding) c, _ := newCipher(NameEncryptionStandard, "", "", true, enc) // First standard mode for _, test := range testCases { assert.Equal(t, test.expected, c.EncryptDirName(test.in)) } } func TestStandardEncryptDirNameBase32(t *testing.T) { testStandardEncryptDirName(t, "base32", []EncodingTestCase{ {"1", "p0e52nreeaj0a5ea7s64m4j72s"}, {"1/12", "p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng"}, {"1/12/123", "p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng/qgm4avr35m5loi1th53ato71v0"}, }) } func TestStandardEncryptDirNameBase64(t *testing.T) { testStandardEncryptDirName(t, "base64", []EncodingTestCase{ {"1", "yBxRX25ypgUVyj8MSxJnFw"}, {"1/12", "yBxRX25ypgUVyj8MSxJnFw/qQUDHOGN_jVdLIMQzYrhvA"}, {"1/12/123", "yBxRX25ypgUVyj8MSxJnFw/qQUDHOGN_jVdLIMQzYrhvA/1CxFf2Mti1xIPYlGruDh-A"}, }) } func TestStandardEncryptDirNameBase32768(t *testing.T) { testStandardEncryptDirName(t, "base32768", []EncodingTestCase{ {"1", "詮㪗鐮僀伎作㻖㢧⪟"}, {"1/12", "詮㪗鐮僀伎作㻖㢧⪟/竢朧䉱虃光塬䟛⣡蓟"}, {"1/12/123", "詮㪗鐮僀伎作㻖㢧⪟/竢朧䉱虃光塬䟛⣡蓟/遶㞟鋅缕袡鲅ⵝ蝁ꌟ"}, }) } func TestNonStandardEncryptDirName(t *testing.T) { for _, encoding := range []string{"base32", "base64", "base32768"} { enc, _ := NewNameEncoding(encoding) c, _ := newCipher(NameEncryptionStandard, "", "", false, enc) assert.Equal(t, "1/12", c.EncryptDirName("1/12")) assert.Equal(t, "1/12/123", c.EncryptDirName("1/12/123")) // Now off mode c, _ = newCipher(NameEncryptionOff, "", "", true, enc) assert.Equal(t, "1/12/123", c.EncryptDirName("1/12/123")) } } func testStandardDecryptDirName(t *testing.T, encoding string, testCases []EncodingTestCase, caseInsensitive bool) { enc, _ := NewNameEncoding(encoding) for _, test := range testCases { // Test dirNameEncrypt=true c, _ := newCipher(NameEncryptionStandard, "", "", true, enc) actual, actualErr := c.DecryptDirName(test.in) assert.Equal(t, test.expected, actual) assert.NoError(t, actualErr) if caseInsensitive { actual, actualErr := c.DecryptDirName(strings.ToUpper(test.in)) assert.Equal(t, actual, test.expected) assert.NoError(t, actualErr) } actual, actualErr = c.DecryptDirName(enc.EncodeToString([]byte("1")) + test.in) assert.Equal(t, "", actual) assert.Equal(t, ErrorNotAMultipleOfBlocksize, actualErr) // Test dirNameEncrypt=false c, _ = newCipher(NameEncryptionStandard, "", "", false, enc) actual, actualErr = c.DecryptDirName(test.in) assert.Equal(t, test.in, actual) assert.NoError(t, actualErr) actual, actualErr = c.DecryptDirName(test.expected) assert.Equal(t, test.expected, actual) assert.NoError(t, actualErr) // Test dirNameEncrypt=false } } /* enc, _ := NewNameEncoding(encoding) for _, test := range []struct { mode NameEncryptionMode dirNameEncrypt bool in string expected string expectedErr error }{ {NameEncryptionStandard, true, "p0e52nreeaj0a5ea7s64m4j72s", "1", nil}, {NameEncryptionStandard, true, "p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng", "1/12", nil}, {NameEncryptionStandard, true, "p0e52nreeAJ0A5EA7S64M4J72S/L42G6771HNv3an9cgc8cr2n1ng", "1/12", nil}, {NameEncryptionStandard, true, "p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng/qgm4avr35m5loi1th53ato71v0", "1/12/123", nil}, {NameEncryptionStandard, true, "p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1/qgm4avr35m5loi1th53ato71v0", "", ErrorNotAMultipleOfBlocksize}, {NameEncryptionStandard, false, "p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng", "p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng", nil}, {NameEncryptionStandard, false, "1/12/123", "1/12/123", nil}, } { c, _ := newCipher(test.mode, "", "", test.dirNameEncrypt, enc) actual, actualErr := c.DecryptDirName(test.in) what := fmt.Sprintf("Testing %q (mode=%v)", test.in, test.mode) assert.Equal(t, test.expected, actual, what) assert.Equal(t, test.expectedErr, actualErr, what) } */ func TestStandardDecryptDirNameBase32(t *testing.T) { testStandardDecryptDirName(t, "base32", []EncodingTestCase{ {"p0e52nreeaj0a5ea7s64m4j72s", "1"}, {"p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng", "1/12"}, {"p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng/qgm4avr35m5loi1th53ato71v0", "1/12/123"}, }, true) } func TestStandardDecryptDirNameBase64(t *testing.T) { testStandardDecryptDirName(t, "base64", []EncodingTestCase{ {"yBxRX25ypgUVyj8MSxJnFw", "1"}, {"yBxRX25ypgUVyj8MSxJnFw/qQUDHOGN_jVdLIMQzYrhvA", "1/12"}, {"yBxRX25ypgUVyj8MSxJnFw/qQUDHOGN_jVdLIMQzYrhvA/1CxFf2Mti1xIPYlGruDh-A", "1/12/123"}, }, false) } func TestStandardDecryptDirNameBase32768(t *testing.T) { testStandardDecryptDirName(t, "base32768", []EncodingTestCase{ {"詮㪗鐮僀伎作㻖㢧⪟", "1"}, {"詮㪗鐮僀伎作㻖㢧⪟/竢朧䉱虃光塬䟛⣡蓟", "1/12"}, {"詮㪗鐮僀伎作㻖㢧⪟/竢朧䉱虃光塬䟛⣡蓟/遶㞟鋅缕袡鲅ⵝ蝁ꌟ", "1/12/123"}, }, false) } func TestNonStandardDecryptDirName(t *testing.T) { for _, test := range []struct { mode NameEncryptionMode dirNameEncrypt bool in string expected string expectedErr error }{ {NameEncryptionOff, true, "1/12/123.bin", "1/12/123.bin", nil}, {NameEncryptionOff, true, "1/12/123", "1/12/123", nil}, {NameEncryptionOff, true, ".bin", ".bin", nil}, } { c, _ := newCipher(test.mode, "", "", test.dirNameEncrypt, nil) actual, actualErr := c.DecryptDirName(test.in) what := fmt.Sprintf("Testing %q (mode=%v)", test.in, test.mode) assert.Equal(t, test.expected, actual, what) assert.Equal(t, test.expectedErr, actualErr, what) } } func TestEncryptedSize(t *testing.T) { c, _ := newCipher(NameEncryptionStandard, "", "", true, nil) for _, test := range []struct { in int64 expected int64 }{ {0, 32}, {1, 32 + 16 + 1}, {65536, 32 + 16 + 65536}, {65537, 32 + 16 + 65536 + 16 + 1}, {1 << 20, 32 + 16*(16+65536)}, {(1 << 20) + 65535, 32 + 16*(16+65536) + 16 + 65535}, {1 << 30, 32 + 16384*(16+65536)}, {(1 << 40) + 1, 32 + 16777216*(16+65536) + 16 + 1}, } { actual := c.EncryptedSize(test.in) assert.Equal(t, test.expected, actual, fmt.Sprintf("Testing %d", test.in)) recovered, err := c.DecryptedSize(test.expected) assert.NoError(t, err, fmt.Sprintf("Testing reverse %d", test.expected)) assert.Equal(t, test.in, recovered, fmt.Sprintf("Testing reverse %d", test.expected)) } } func TestDecryptedSize(t *testing.T) { // Test the errors since we tested the reverse above c, _ := newCipher(NameEncryptionStandard, "", "", true, nil) for _, test := range []struct { in int64 expectedErr error }{ {0, ErrorEncryptedFileTooShort}, {0, ErrorEncryptedFileTooShort}, {1, ErrorEncryptedFileTooShort}, {7, ErrorEncryptedFileTooShort}, {32 + 1, ErrorEncryptedFileBadHeader}, {32 + 16, ErrorEncryptedFileBadHeader}, {32 + 16 + 65536 + 1, ErrorEncryptedFileBadHeader}, {32 + 16 + 65536 + 16, ErrorEncryptedFileBadHeader}, } { _, actualErr := c.DecryptedSize(test.in) assert.Equal(t, test.expectedErr, actualErr, fmt.Sprintf("Testing %d", test.in)) } } func TestNoncePointer(t *testing.T) { var x nonce assert.Equal(t, (*[24]byte)(&x), x.pointer()) } func TestNonceFromReader(t *testing.T) { var x nonce buf := bytes.NewBufferString("123456789abcdefghijklmno") err := x.fromReader(buf) assert.NoError(t, err) assert.Equal(t, nonce{'1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o'}, x) buf = bytes.NewBufferString("123456789abcdefghijklmn") err = x.fromReader(buf) assert.EqualError(t, err, "short read of nonce: EOF") } func TestNonceFromBuf(t *testing.T) { var x nonce buf := []byte("123456789abcdefghijklmnoXXXXXXXX") x.fromBuf(buf) assert.Equal(t, nonce{'1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o'}, x) buf = []byte("0123456789abcdefghijklmn") x.fromBuf(buf) assert.Equal(t, nonce{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n'}, x) buf = []byte("0123456789abcdefghijklm") assert.Panics(t, func() { x.fromBuf(buf) }) } func TestNonceIncrement(t *testing.T) { for _, test := range []struct { in nonce out nonce }{ { nonce{0x00}, nonce{0x01}, }, { nonce{0xFF}, nonce{0x00, 0x01}, }, { nonce{0xFF, 0xFF}, nonce{0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, }, } { x := test.in x.increment() assert.Equal(t, test.out, x) } } func TestNonceAdd(t *testing.T) { for _, test := range []struct { add uint64 in nonce out nonce }{ { 0x01, nonce{0x00}, nonce{0x01}, }, { 0xFF, nonce{0xFF}, nonce{0xFE, 0x01}, }, { 0xFFFF, nonce{0xFF, 0xFF}, nonce{0xFE, 0xFF, 0x01}, }, { 0xFFFFFF, nonce{0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0x01}, }, { 0xFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFe, 0xFF, 0xFF, 0xFF, 0x01}, }, { 0xFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0x01}, }, { 0xFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01}, }, { 0xFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, }, { 0xFFFFFFFFFFFFFFFF, nonce{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, nonce{0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, }, } { x := test.in x.add(test.add) assert.Equal(t, test.out, x) } } // randomSource can read or write a random sequence type randomSource struct { counter int64 size int64 } func newRandomSource(size int64) *randomSource { return &randomSource{ size: size, } } func (r *randomSource) next() byte { r.counter++ return byte(r.counter % 257) } func (r *randomSource) Read(p []byte) (n int, err error) { for i := range p { if r.counter >= r.size { err = io.EOF break } p[i] = r.next() n++ } return n, err } func (r *randomSource) Write(p []byte) (n int, err error) { for i := range p { if p[i] != r.next() { return 0, fmt.Errorf("Error in stream at %d", r.counter) } } return len(p), nil } func (r *randomSource) Close() error { return nil } // Check interfaces var ( _ io.ReadCloser = (*randomSource)(nil) _ io.WriteCloser = (*randomSource)(nil) ) // Test test infrastructure first! func TestRandomSource(t *testing.T) { source := newRandomSource(1e8) sink := newRandomSource(1e8) n, err := io.Copy(sink, source) assert.NoError(t, err) assert.Equal(t, int64(1e8), n) source = newRandomSource(1e8) buf := make([]byte, 16) _, _ = source.Read(buf) sink = newRandomSource(1e8) _, err = io.Copy(sink, source) assert.EqualError(t, err, "Error in stream at 1") } type zeroes struct{} func (z *zeroes) Read(p []byte) (n int, err error) { for i := range p { p[i] = 0 n++ } return n, nil } // Test encrypt decrypt with different buffer sizes func testEncryptDecrypt(t *testing.T, bufSize int, copySize int64) { c, err := newCipher(NameEncryptionStandard, "", "", true, nil) assert.NoError(t, err) c.cryptoRand = &zeroes{} // zero out the nonce buf := make([]byte, bufSize) source := newRandomSource(copySize) encrypted, err := c.newEncrypter(source, nil) assert.NoError(t, err) decrypted, err := c.newDecrypter(io.NopCloser(encrypted)) assert.NoError(t, err) sink := newRandomSource(copySize) n, err := io.CopyBuffer(sink, decrypted, buf) assert.NoError(t, err) assert.Equal(t, copySize, n) blocks := copySize / blockSize if (copySize % blockSize) != 0 { blocks++ } var expectedNonce = nonce{byte(blocks), byte(blocks >> 8), byte(blocks >> 16), byte(blocks >> 32)} assert.Equal(t, expectedNonce, encrypted.nonce) assert.Equal(t, expectedNonce, decrypted.nonce) } func TestEncryptDecrypt1(t *testing.T) { testEncryptDecrypt(t, 1, 1e7) } func TestEncryptDecrypt32(t *testing.T) { testEncryptDecrypt(t, 32, 1e8) } func TestEncryptDecrypt4096(t *testing.T) { testEncryptDecrypt(t, 4096, 1e8) } func TestEncryptDecrypt65536(t *testing.T) { testEncryptDecrypt(t, 65536, 1e8) } func TestEncryptDecrypt65537(t *testing.T) { testEncryptDecrypt(t, 65537, 1e8) } var ( file0 = []byte{ 0x52, 0x43, 0x4c, 0x4f, 0x4e, 0x45, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, } file1 = []byte{ 0x52, 0x43, 0x4c, 0x4f, 0x4e, 0x45, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x09, 0x5b, 0x44, 0x6c, 0xd6, 0x23, 0x7b, 0xbc, 0xb0, 0x8d, 0x09, 0xfb, 0x52, 0x4c, 0xe5, 0x65, 0xAA, } file16 = []byte{ 0x52, 0x43, 0x4c, 0x4f, 0x4e, 0x45, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0xb9, 0xc4, 0x55, 0x2a, 0x27, 0x10, 0x06, 0x29, 0x18, 0x96, 0x0a, 0x3e, 0x60, 0x8c, 0x29, 0xb9, 0xaa, 0x8a, 0x5e, 0x1e, 0x16, 0x5b, 0x6d, 0x07, 0x5d, 0xe4, 0xe9, 0xbb, 0x36, 0x7f, 0xd6, 0xd4, } ) func TestEncryptData(t *testing.T) { for _, test := range []struct { in []byte expected []byte }{ {[]byte{}, file0}, {[]byte{1}, file1}, {[]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, file16}, } { c, err := newCipher(NameEncryptionStandard, "", "", true, nil) assert.NoError(t, err) c.cryptoRand = newRandomSource(1e8) // nodge the crypto rand generator // Check encode works buf := bytes.NewBuffer(test.in) encrypted, err := c.EncryptData(buf) assert.NoError(t, err) out, err := io.ReadAll(encrypted) assert.NoError(t, err) assert.Equal(t, test.expected, out) // Check we can decode the data properly too... buf = bytes.NewBuffer(out) decrypted, err := c.DecryptData(io.NopCloser(buf)) assert.NoError(t, err) out, err = io.ReadAll(decrypted) assert.NoError(t, err) assert.Equal(t, test.in, out) } } func TestNewEncrypter(t *testing.T) { c, err := newCipher(NameEncryptionStandard, "", "", true, nil) assert.NoError(t, err) c.cryptoRand = newRandomSource(1e8) // nodge the crypto rand generator z := &zeroes{} fh, err := c.newEncrypter(z, nil) assert.NoError(t, err) assert.Equal(t, nonce{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18}, fh.nonce) assert.Equal(t, []byte{'R', 'C', 'L', 'O', 'N', 'E', 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18}, (*fh.buf)[:32]) // Test error path c.cryptoRand = bytes.NewBufferString("123456789abcdefghijklmn") fh, err = c.newEncrypter(z, nil) assert.Nil(t, fh) assert.EqualError(t, err, "short read of nonce: EOF") } // Test the stream returning 0, io.ErrUnexpectedEOF - this used to // cause a fatal loop func TestNewEncrypterErrUnexpectedEOF(t *testing.T) { c, err := newCipher(NameEncryptionStandard, "", "", true, nil) assert.NoError(t, err) in := &readers.ErrorReader{Err: io.ErrUnexpectedEOF} fh, err := c.newEncrypter(in, nil) assert.NoError(t, err) n, err := io.CopyN(io.Discard, fh, 1e6) assert.Equal(t, io.ErrUnexpectedEOF, err) assert.Equal(t, int64(32), n) } type closeDetector struct { io.Reader closed int } func newCloseDetector(in io.Reader) *closeDetector { return &closeDetector{ Reader: in, } } func (c *closeDetector) Close() error { c.closed++ return nil } func TestNewDecrypter(t *testing.T) { c, err := newCipher(NameEncryptionStandard, "", "", true, nil) assert.NoError(t, err) c.cryptoRand = newRandomSource(1e8) // nodge the crypto rand generator cd := newCloseDetector(bytes.NewBuffer(file0)) fh, err := c.newDecrypter(cd) assert.NoError(t, err) // check nonce is in place assert.Equal(t, file0[8:32], fh.nonce[:]) assert.Equal(t, 0, cd.closed) // Test error paths for i := range file0 { cd := newCloseDetector(bytes.NewBuffer(file0[:i])) fh, err = c.newDecrypter(cd) assert.Nil(t, fh) assert.EqualError(t, err, ErrorEncryptedFileTooShort.Error()) assert.Equal(t, 1, cd.closed) } er := &readers.ErrorReader{Err: errors.New("potato")} cd = newCloseDetector(er) fh, err = c.newDecrypter(cd) assert.Nil(t, fh) assert.EqualError(t, err, "potato") assert.Equal(t, 1, cd.closed) // bad magic file0copy := make([]byte, len(file0)) copy(file0copy, file0) for i := range fileMagic { file0copy[i] ^= 0x1 cd := newCloseDetector(bytes.NewBuffer(file0copy)) fh, err := c.newDecrypter(cd) assert.Nil(t, fh) assert.EqualError(t, err, ErrorEncryptedBadMagic.Error()) file0copy[i] ^= 0x1 assert.Equal(t, 1, cd.closed) } } // Test the stream returning 0, io.ErrUnexpectedEOF func TestNewDecrypterErrUnexpectedEOF(t *testing.T) { c, err := newCipher(NameEncryptionStandard, "", "", true, nil) assert.NoError(t, err) in2 := &readers.ErrorReader{Err: io.ErrUnexpectedEOF} in1 := bytes.NewBuffer(file16) in := io.NopCloser(io.MultiReader(in1, in2)) fh, err := c.newDecrypter(in) assert.NoError(t, err) n, err := io.CopyN(io.Discard, fh, 1e6) assert.Equal(t, io.ErrUnexpectedEOF, err) assert.Equal(t, int64(16), n) } func TestNewDecrypterSeekLimit(t *testing.T) { c, err := newCipher(NameEncryptionStandard, "", "", true, nil) assert.NoError(t, err) c.cryptoRand = &zeroes{} // nodge the crypto rand generator // Make random data const dataSize = 150000 plaintext, err := io.ReadAll(newRandomSource(dataSize)) assert.NoError(t, err) // Encrypt the data buf := bytes.NewBuffer(plaintext) encrypted, err := c.EncryptData(buf) assert.NoError(t, err) ciphertext, err := io.ReadAll(encrypted) assert.NoError(t, err) trials := []int{0, 1, 2, 3, 4, 5, 7, 8, 9, 15, 16, 17, 31, 32, 33, 63, 64, 65, 127, 128, 129, 255, 256, 257, 511, 512, 513, 1023, 1024, 1025, 2047, 2048, 2049, 4095, 4096, 4097, 8191, 8192, 8193, 16383, 16384, 16385, 32767, 32768, 32769, 65535, 65536, 65537, 131071, 131072, 131073, dataSize - 1, dataSize} limits := []int{-1, 0, 1, 65535, 65536, 65537, 131071, 131072, 131073} // Open stream with a seek of underlyingOffset var reader io.ReadCloser open := func(ctx context.Context, underlyingOffset, underlyingLimit int64) (io.ReadCloser, error) { end := len(ciphertext) if underlyingLimit >= 0 { end = min(int(underlyingOffset+underlyingLimit), len(ciphertext)) } reader = io.NopCloser(bytes.NewBuffer(ciphertext[int(underlyingOffset):end])) return reader, nil } inBlock := make([]byte, dataSize) // Check the seek worked by reading a block and checking it // against what it should be check := func(rc io.Reader, offset, limit int) { n, err := io.ReadFull(rc, inBlock) if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF { require.NoError(t, err) } seekedDecrypted := inBlock[:n] what := fmt.Sprintf("offset = %d, limit = %d", offset, limit) if limit >= 0 { assert.Equal(t, limit, n, what) } require.Equal(t, plaintext[offset:offset+n], seekedDecrypted, what) // We should have completely emptied the reader at this point n, err = reader.Read(inBlock) assert.Equal(t, io.EOF, err) assert.Equal(t, 0, n) } // Now try decoding it with an open/seek for _, offset := range trials { for _, limit := range limits { if offset+limit > len(plaintext) { continue } rc, err := c.DecryptDataSeek(context.Background(), open, int64(offset), int64(limit)) assert.NoError(t, err) check(rc, offset, limit) } } // Try decoding it with a single open and lots of seeks fh, err := c.DecryptDataSeek(context.Background(), open, 0, -1) assert.NoError(t, err) for _, offset := range trials { for _, limit := range limits { if offset+limit > len(plaintext) { continue } _, err := fh.RangeSeek(context.Background(), int64(offset), io.SeekStart, int64(limit)) assert.NoError(t, err) check(fh, offset, limit) } } // Do some checks on the open callback for _, test := range []struct { offset, limit int64 wantOffset, wantLimit int64 }{ // unlimited {0, -1, int64(fileHeaderSize), -1}, {1, -1, int64(fileHeaderSize), -1}, {blockDataSize - 1, -1, int64(fileHeaderSize), -1}, {blockDataSize, -1, int64(fileHeaderSize) + blockSize, -1}, {blockDataSize + 1, -1, int64(fileHeaderSize) + blockSize, -1}, // limit=1 {0, 1, int64(fileHeaderSize), blockSize}, {1, 1, int64(fileHeaderSize), blockSize}, {blockDataSize - 1, 1, int64(fileHeaderSize), blockSize}, {blockDataSize, 1, int64(fileHeaderSize) + blockSize, blockSize}, {blockDataSize + 1, 1, int64(fileHeaderSize) + blockSize, blockSize}, // limit=100 {0, 100, int64(fileHeaderSize), blockSize}, {1, 100, int64(fileHeaderSize), blockSize}, {blockDataSize - 1, 100, int64(fileHeaderSize), 2 * blockSize}, {blockDataSize, 100, int64(fileHeaderSize) + blockSize, blockSize}, {blockDataSize + 1, 100, int64(fileHeaderSize) + blockSize, blockSize}, // limit=blockDataSize-1 {0, blockDataSize - 1, int64(fileHeaderSize), blockSize}, {1, blockDataSize - 1, int64(fileHeaderSize), blockSize}, {blockDataSize - 1, blockDataSize - 1, int64(fileHeaderSize), 2 * blockSize}, {blockDataSize, blockDataSize - 1, int64(fileHeaderSize) + blockSize, blockSize}, {blockDataSize + 1, blockDataSize - 1, int64(fileHeaderSize) + blockSize, blockSize}, // limit=blockDataSize {0, blockDataSize, int64(fileHeaderSize), blockSize}, {1, blockDataSize, int64(fileHeaderSize), 2 * blockSize}, {blockDataSize - 1, blockDataSize, int64(fileHeaderSize), 2 * blockSize}, {blockDataSize, blockDataSize, int64(fileHeaderSize) + blockSize, blockSize}, {blockDataSize + 1, blockDataSize, int64(fileHeaderSize) + blockSize, 2 * blockSize}, // limit=blockDataSize+1 {0, blockDataSize + 1, int64(fileHeaderSize), 2 * blockSize}, {1, blockDataSize + 1, int64(fileHeaderSize), 2 * blockSize}, {blockDataSize - 1, blockDataSize + 1, int64(fileHeaderSize), 2 * blockSize}, {blockDataSize, blockDataSize + 1, int64(fileHeaderSize) + blockSize, 2 * blockSize}, {blockDataSize + 1, blockDataSize + 1, int64(fileHeaderSize) + blockSize, 2 * blockSize}, } { what := fmt.Sprintf("offset = %d, limit = %d", test.offset, test.limit) callCount := 0 testOpen := func(ctx context.Context, underlyingOffset, underlyingLimit int64) (io.ReadCloser, error) { switch callCount { case 0: assert.Equal(t, int64(0), underlyingOffset, what) assert.Equal(t, int64(-1), underlyingLimit, what) case 1: assert.Equal(t, test.wantOffset, underlyingOffset, what) assert.Equal(t, test.wantLimit, underlyingLimit, what) default: t.Errorf("Too many calls %d for %s", callCount+1, what) } callCount++ return open(ctx, underlyingOffset, underlyingLimit) } fh, err := c.DecryptDataSeek(context.Background(), testOpen, 0, -1) assert.NoError(t, err) gotOffset, err := fh.RangeSeek(context.Background(), test.offset, io.SeekStart, test.limit) assert.NoError(t, err) assert.Equal(t, gotOffset, test.offset) } } func TestDecrypterCalculateUnderlying(t *testing.T) { for _, test := range []struct { offset, limit int64 wantOffset, wantLimit int64 wantDiscard, wantBlocks int64 }{ // unlimited {0, -1, int64(fileHeaderSize), -1, 0, 0}, {1, -1, int64(fileHeaderSize), -1, 1, 0}, {blockDataSize - 1, -1, int64(fileHeaderSize), -1, blockDataSize - 1, 0}, {blockDataSize, -1, int64(fileHeaderSize) + blockSize, -1, 0, 1}, {blockDataSize + 1, -1, int64(fileHeaderSize) + blockSize, -1, 1, 1}, // limit=1 {0, 1, int64(fileHeaderSize), blockSize, 0, 0}, {1, 1, int64(fileHeaderSize), blockSize, 1, 0}, {blockDataSize - 1, 1, int64(fileHeaderSize), blockSize, blockDataSize - 1, 0}, {blockDataSize, 1, int64(fileHeaderSize) + blockSize, blockSize, 0, 1}, {blockDataSize + 1, 1, int64(fileHeaderSize) + blockSize, blockSize, 1, 1}, // limit=100 {0, 100, int64(fileHeaderSize), blockSize, 0, 0}, {1, 100, int64(fileHeaderSize), blockSize, 1, 0}, {blockDataSize - 1, 100, int64(fileHeaderSize), 2 * blockSize, blockDataSize - 1, 0}, {blockDataSize, 100, int64(fileHeaderSize) + blockSize, blockSize, 0, 1}, {blockDataSize + 1, 100, int64(fileHeaderSize) + blockSize, blockSize, 1, 1}, // limit=blockDataSize-1 {0, blockDataSize - 1, int64(fileHeaderSize), blockSize, 0, 0}, {1, blockDataSize - 1, int64(fileHeaderSize), blockSize, 1, 0}, {blockDataSize - 1, blockDataSize - 1, int64(fileHeaderSize), 2 * blockSize, blockDataSize - 1, 0}, {blockDataSize, blockDataSize - 1, int64(fileHeaderSize) + blockSize, blockSize, 0, 1}, {blockDataSize + 1, blockDataSize - 1, int64(fileHeaderSize) + blockSize, blockSize, 1, 1}, // limit=blockDataSize {0, blockDataSize, int64(fileHeaderSize), blockSize, 0, 0}, {1, blockDataSize, int64(fileHeaderSize), 2 * blockSize, 1, 0}, {blockDataSize - 1, blockDataSize, int64(fileHeaderSize), 2 * blockSize, blockDataSize - 1, 0}, {blockDataSize, blockDataSize, int64(fileHeaderSize) + blockSize, blockSize, 0, 1}, {blockDataSize + 1, blockDataSize, int64(fileHeaderSize) + blockSize, 2 * blockSize, 1, 1}, // limit=blockDataSize+1 {0, blockDataSize + 1, int64(fileHeaderSize), 2 * blockSize, 0, 0}, {1, blockDataSize + 1, int64(fileHeaderSize), 2 * blockSize, 1, 0}, {blockDataSize - 1, blockDataSize + 1, int64(fileHeaderSize), 2 * blockSize, blockDataSize - 1, 0}, {blockDataSize, blockDataSize + 1, int64(fileHeaderSize) + blockSize, 2 * blockSize, 0, 1}, {blockDataSize + 1, blockDataSize + 1, int64(fileHeaderSize) + blockSize, 2 * blockSize, 1, 1}, } { what := fmt.Sprintf("offset = %d, limit = %d", test.offset, test.limit) underlyingOffset, underlyingLimit, discard, blocks := calculateUnderlying(test.offset, test.limit) assert.Equal(t, test.wantOffset, underlyingOffset, what) assert.Equal(t, test.wantLimit, underlyingLimit, what) assert.Equal(t, test.wantDiscard, discard, what) assert.Equal(t, test.wantBlocks, blocks, what) } } func TestDecrypterRead(t *testing.T) { c, err := newCipher(NameEncryptionStandard, "", "", true, nil) assert.NoError(t, err) // Test truncating the file at each possible point for i := range len(file16) - 1 { what := fmt.Sprintf("truncating to %d/%d", i, len(file16)) cd := newCloseDetector(bytes.NewBuffer(file16[:i])) fh, err := c.newDecrypter(cd) if i < fileHeaderSize { assert.EqualError(t, err, ErrorEncryptedFileTooShort.Error(), what) continue } if err != nil { assert.NoError(t, err, what) continue } _, err = io.ReadAll(fh) var expectedErr error switch { case i == fileHeaderSize: // This would normally produce an error *except* on the first block expectedErr = nil case i <= fileHeaderSize+blockHeaderSize: expectedErr = ErrorEncryptedFileBadHeader default: expectedErr = ErrorEncryptedBadBlock } if expectedErr != nil { assert.EqualError(t, err, expectedErr.Error(), what) } else { assert.NoError(t, err, what) } assert.Equal(t, 0, cd.closed, what) } // Test producing an error on the file on Read the underlying file in1 := bytes.NewBuffer(file1) in2 := &readers.ErrorReader{Err: errors.New("potato")} in := io.MultiReader(in1, in2) cd := newCloseDetector(in) fh, err := c.newDecrypter(cd) assert.NoError(t, err) _, err = io.ReadAll(fh) assert.EqualError(t, err, "potato") assert.Equal(t, 0, cd.closed) // Test corrupting the input // shouldn't be able to corrupt any byte without some sort of error file16copy := make([]byte, len(file16)) copy(file16copy, file16) for i := range file16copy { file16copy[i] ^= 0xFF fh, err := c.newDecrypter(io.NopCloser(bytes.NewBuffer(file16copy))) if i < fileMagicSize { assert.EqualError(t, err, ErrorEncryptedBadMagic.Error()) assert.Nil(t, fh) } else { assert.NoError(t, err) _, err = io.ReadAll(fh) assert.EqualError(t, err, ErrorEncryptedBadBlock.Error()) } file16copy[i] ^= 0xFF } // Test that we can corrupt a byte and read zeroes if // passBadBlocks is set copy(file16copy, file16) file16copy[len(file16copy)-1] ^= 0xFF c.passBadBlocks = true fh, err = c.newDecrypter(io.NopCloser(bytes.NewBuffer(file16copy))) assert.NoError(t, err) buf, err := io.ReadAll(fh) assert.NoError(t, err) assert.Equal(t, make([]byte, 16), buf) } func TestDecrypterClose(t *testing.T) { c, err := newCipher(NameEncryptionStandard, "", "", true, nil) assert.NoError(t, err) cd := newCloseDetector(bytes.NewBuffer(file16)) fh, err := c.newDecrypter(cd) assert.NoError(t, err) assert.Equal(t, 0, cd.closed) // close before reading assert.Equal(t, nil, fh.err) err = fh.Close() assert.NoError(t, err) assert.Equal(t, ErrorFileClosed, fh.err) assert.Equal(t, 1, cd.closed) // double close err = fh.Close() assert.EqualError(t, err, ErrorFileClosed.Error()) assert.Equal(t, 1, cd.closed) // try again reading the file this time cd = newCloseDetector(bytes.NewBuffer(file1)) fh, err = c.newDecrypter(cd) assert.NoError(t, err) assert.Equal(t, 0, cd.closed) // close after reading out, err := io.ReadAll(fh) assert.NoError(t, err) assert.Equal(t, []byte{1}, out) assert.Equal(t, io.EOF, fh.err) err = fh.Close() assert.NoError(t, err) assert.Equal(t, ErrorFileClosed, fh.err) assert.Equal(t, 1, cd.closed) } func TestPutGetBlock(t *testing.T) { c, err := newCipher(NameEncryptionStandard, "", "", true, nil) assert.NoError(t, err) block := c.getBlock() c.putBlock(block) c.putBlock(block) } func TestKey(t *testing.T) { c, err := newCipher(NameEncryptionStandard, "", "", true, nil) assert.NoError(t, err) // Check zero keys OK assert.Equal(t, [32]byte{}, c.dataKey) assert.Equal(t, [32]byte{}, c.nameKey) assert.Equal(t, [16]byte{}, c.nameTweak) require.NoError(t, c.Key("potato", "")) assert.Equal(t, [32]byte{0x74, 0x55, 0xC7, 0x1A, 0xB1, 0x7C, 0x86, 0x5B, 0x84, 0x71, 0xF4, 0x7B, 0x79, 0xAC, 0xB0, 0x7E, 0xB3, 0x1D, 0x56, 0x78, 0xB8, 0x0C, 0x7E, 0x2E, 0xAF, 0x4F, 0xC8, 0x06, 0x6A, 0x9E, 0xE4, 0x68}, c.dataKey) assert.Equal(t, [32]byte{0x76, 0x5D, 0xA2, 0x7A, 0xB1, 0x5D, 0x77, 0xF9, 0x57, 0x96, 0x71, 0x1F, 0x7B, 0x93, 0xAD, 0x63, 0xBB, 0xB4, 0x84, 0x07, 0x2E, 0x71, 0x80, 0xA8, 0xD1, 0x7A, 0x9B, 0xBE, 0xC1, 0x42, 0x70, 0xD0}, c.nameKey) assert.Equal(t, [16]byte{0xC1, 0x8D, 0x59, 0x32, 0xF5, 0x5B, 0x28, 0x28, 0xC5, 0xE1, 0xE8, 0x72, 0x15, 0x52, 0x03, 0x10}, c.nameTweak) require.NoError(t, c.Key("Potato", "")) assert.Equal(t, [32]byte{0xAE, 0xEA, 0x6A, 0xD3, 0x47, 0xDF, 0x75, 0xB9, 0x63, 0xCE, 0x12, 0xF5, 0x76, 0x23, 0xE9, 0x46, 0xD4, 0x2E, 0xD8, 0xBF, 0x3E, 0x92, 0x8B, 0x39, 0x24, 0x37, 0x94, 0x13, 0x3E, 0x5E, 0xF7, 0x5E}, c.dataKey) assert.Equal(t, [32]byte{0x54, 0xF7, 0x02, 0x6E, 0x8A, 0xFC, 0x56, 0x0A, 0x86, 0x63, 0x6A, 0xAB, 0x2C, 0x9C, 0x51, 0x62, 0xE5, 0x1A, 0x12, 0x23, 0x51, 0x83, 0x6E, 0xAF, 0x50, 0x42, 0x0F, 0x98, 0x1C, 0x86, 0x0A, 0x19}, c.nameKey) assert.Equal(t, [16]byte{0xF8, 0xC1, 0xB6, 0x27, 0x2D, 0x52, 0x9B, 0x4A, 0x8F, 0xDA, 0xEB, 0x42, 0x4A, 0x28, 0xDD, 0xF3}, c.nameTweak) require.NoError(t, c.Key("potato", "sausage")) assert.Equal(t, [32]uint8{0x8e, 0x9b, 0x6b, 0x99, 0xf8, 0x69, 0x4, 0x67, 0xa0, 0x71, 0xf9, 0xcb, 0x92, 0xd0, 0xaa, 0x78, 0x7f, 0x8f, 0xf1, 0x78, 0xbe, 0xc9, 0x6f, 0x99, 0x9f, 0xd5, 0x20, 0x6e, 0x64, 0x4a, 0x1b, 0x50}, c.dataKey) assert.Equal(t, [32]uint8{0x3e, 0xa9, 0x5e, 0xf6, 0x81, 0x78, 0x2d, 0xc9, 0xd9, 0x95, 0x5d, 0x22, 0x5b, 0xfd, 0x44, 0x2c, 0x6f, 0x5d, 0x68, 0x97, 0xb0, 0x29, 0x1, 0x5c, 0x6f, 0x46, 0x2e, 0x2a, 0x9d, 0xae, 0x2c, 0xe3}, c.nameKey) assert.Equal(t, [16]uint8{0xf1, 0x7f, 0xd7, 0x14, 0x1d, 0x65, 0x27, 0x4f, 0x36, 0x3f, 0xc2, 0xa0, 0x4d, 0xd2, 0x14, 0x8a}, c.nameTweak) require.NoError(t, c.Key("potato", "Sausage")) assert.Equal(t, [32]uint8{0xda, 0x81, 0x8c, 0x67, 0xef, 0x11, 0xf, 0xc8, 0xd5, 0xc8, 0x62, 0x4b, 0x7f, 0xe2, 0x9e, 0x35, 0x35, 0xb0, 0x8d, 0x79, 0x84, 0x89, 0xac, 0xcb, 0xa0, 0xff, 0x2, 0x72, 0x3, 0x1a, 0x5e, 0x64}, c.dataKey) assert.Equal(t, [32]uint8{0x2, 0x81, 0x7e, 0x7b, 0xea, 0x99, 0x81, 0x5a, 0xd0, 0x2d, 0xb9, 0x64, 0x48, 0xb0, 0x28, 0x27, 0x7c, 0x20, 0xb4, 0xd4, 0xa4, 0x68, 0xad, 0x4e, 0x5c, 0x29, 0xf, 0x79, 0xef, 0xee, 0xdb, 0x3b}, c.nameKey) assert.Equal(t, [16]uint8{0x9a, 0xb5, 0xb, 0x3d, 0xcb, 0x60, 0x59, 0x55, 0xa5, 0x4d, 0xe6, 0xb6, 0x47, 0x3, 0x23, 0xe2}, c.nameTweak) require.NoError(t, c.Key("", "")) assert.Equal(t, [32]byte{}, c.dataKey) assert.Equal(t, [32]byte{}, c.nameKey) assert.Equal(t, [16]byte{}, c.nameTweak) } rclone-v1.71.0/backend/crypt/crypt.go000066400000000000000000001140251505210326400174710ustar00rootroot00000000000000// Package crypt provides wrappers for Fs and Object which implement encryption package crypt import ( "context" "errors" "fmt" "io" "path" "strings" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fspath" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/list" ) // Globals // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "crypt", Description: "Encrypt/Decrypt a remote", NewFs: NewFs, CommandHelp: commandHelp, MetadataInfo: &fs.MetadataInfo{ Help: `Any metadata supported by the underlying remote is read and written.`, }, Options: []fs.Option{{ Name: "remote", Help: "Remote to encrypt/decrypt.\n\nNormally should contain a ':' and a path, e.g. \"myremote:path/to/dir\",\n\"myremote:bucket\" or maybe \"myremote:\" (not recommended).", Required: true, }, { Name: "filename_encryption", Help: "How to encrypt the filenames.", Default: "standard", Examples: []fs.OptionExample{ { Value: "standard", Help: "Encrypt the filenames.\nSee the docs for the details.", }, { Value: "obfuscate", Help: "Very simple filename obfuscation.", }, { Value: "off", Help: "Don't encrypt the file names.\nAdds a \".bin\", or \"suffix\" extension only.", }, }, }, { Name: "directory_name_encryption", Help: `Option to either encrypt directory names or leave them intact. NB If filename_encryption is "off" then this option will do nothing.`, Default: true, Examples: []fs.OptionExample{ { Value: "true", Help: "Encrypt directory names.", }, { Value: "false", Help: "Don't encrypt directory names, leave them intact.", }, }, }, { Name: "password", Help: "Password or pass phrase for encryption.", IsPassword: true, Required: true, }, { Name: "password2", Help: "Password or pass phrase for salt.\n\nOptional but recommended.\nShould be different to the previous password.", IsPassword: true, }, { Name: "server_side_across_configs", Default: false, Help: `Deprecated: use --server-side-across-configs instead. Allow server-side operations (e.g. copy) to work across different crypt configs. Normally this option is not what you want, but if you have two crypts pointing to the same backend you can use it. This can be used, for example, to change file name encryption type without re-uploading all the data. Just make two crypt backends pointing to two different directories with the single changed parameter and use rclone move to move the files between the crypt remotes.`, Advanced: true, }, { Name: "show_mapping", Help: `For all files listed show how the names encrypt. If this flag is set then for each file that the remote is asked to list, it will log (at level INFO) a line stating the decrypted file name and the encrypted file name. This is so you can work out which encrypted names are which decrypted names just in case you need to do something with the encrypted file names, or for debugging purposes.`, Default: false, Hide: fs.OptionHideConfigurator, Advanced: true, }, { Name: "no_data_encryption", Help: "Option to either encrypt file data or leave it unencrypted.", Default: false, Advanced: true, Examples: []fs.OptionExample{ { Value: "true", Help: "Don't encrypt file data, leave it unencrypted.", }, { Value: "false", Help: "Encrypt file data.", }, }, }, { Name: "pass_bad_blocks", Help: `If set this will pass bad blocks through as all 0. This should not be set in normal operation, it should only be set if trying to recover an encrypted file with errors and it is desired to recover as much of the file as possible.`, Default: false, Advanced: true, }, { Name: "strict_names", Help: `If set, this will raise an error when crypt comes across a filename that can't be decrypted. (By default, rclone will just log a NOTICE and continue as normal.) This can happen if encrypted and unencrypted files are stored in the same directory (which is not recommended.) It may also indicate a more serious problem that should be investigated.`, Default: false, Advanced: true, }, { Name: "filename_encoding", Help: `How to encode the encrypted filename to text string. This option could help with shortening the encrypted filename. The suitable option would depend on the way your remote count the filename length and if it's case sensitive.`, Default: "base32", Examples: []fs.OptionExample{ { Value: "base32", Help: "Encode using base32. Suitable for all remote.", }, { Value: "base64", Help: "Encode using base64. Suitable for case sensitive remote.", }, { Value: "base32768", Help: "Encode using base32768. Suitable if your remote counts UTF-16 or\nUnicode codepoint instead of UTF-8 byte length. (Eg. Onedrive, Dropbox)", }, }, Advanced: true, }, { Name: "suffix", Help: `If this is set it will override the default suffix of ".bin". Setting suffix to "none" will result in an empty suffix. This may be useful when the path length is critical.`, Default: ".bin", Advanced: true, }}, }) } // newCipherForConfig constructs a Cipher for the given config name func newCipherForConfig(opt *Options) (*Cipher, error) { mode, err := NewNameEncryptionMode(opt.FilenameEncryption) if err != nil { return nil, err } if opt.Password == "" { return nil, errors.New("password not set in config file") } password, err := obscure.Reveal(opt.Password) if err != nil { return nil, fmt.Errorf("failed to decrypt password: %w", err) } var salt string if opt.Password2 != "" { salt, err = obscure.Reveal(opt.Password2) if err != nil { return nil, fmt.Errorf("failed to decrypt password2: %w", err) } } enc, err := NewNameEncoding(opt.FilenameEncoding) if err != nil { return nil, err } cipher, err := newCipher(mode, password, salt, opt.DirectoryNameEncryption, enc) if err != nil { return nil, fmt.Errorf("failed to make cipher: %w", err) } cipher.setEncryptedSuffix(opt.Suffix) cipher.setPassBadBlocks(opt.PassBadBlocks) return cipher, nil } // NewCipher constructs a Cipher for the given config func NewCipher(m configmap.Mapper) (*Cipher, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } return newCipherForConfig(opt) } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, rpath string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } cipher, err := newCipherForConfig(opt) if err != nil { return nil, err } remote := opt.Remote if strings.HasPrefix(remote, name+":") { return nil, errors.New("can't point crypt remote at itself - check the value of the remote setting") } // Make sure to remove trailing . referring to the current dir if path.Base(rpath) == "." { rpath = strings.TrimSuffix(rpath, ".") } // Look for a file first var wrappedFs fs.Fs if rpath == "" { wrappedFs, err = cache.Get(ctx, remote) } else { remotePath := fspath.JoinRootPath(remote, cipher.EncryptFileName(rpath)) wrappedFs, err = cache.Get(ctx, remotePath) // if that didn't produce a file, look for a directory if err != fs.ErrorIsFile { remotePath = fspath.JoinRootPath(remote, cipher.EncryptDirName(rpath)) wrappedFs, err = cache.Get(ctx, remotePath) } } if err != fs.ErrorIsFile && err != nil { return nil, fmt.Errorf("failed to make remote %q to wrap: %w", remote, err) } f := &Fs{ Fs: wrappedFs, name: name, root: rpath, opt: *opt, cipher: cipher, } cache.PinUntilFinalized(f.Fs, f) // Correct root if definitely pointing to a file if err == fs.ErrorIsFile { f.root = path.Dir(f.root) if f.root == "." || f.root == "/" { f.root = "" } } // the features here are ones we could support, and they are // ANDed with the ones from wrappedFs f.features = (&fs.Features{ CaseInsensitive: !cipher.dirNameEncrypt || cipher.NameEncryptionMode() == NameEncryptionOff, DuplicateFiles: true, ReadMimeType: false, // MimeTypes not supported with crypt WriteMimeType: false, BucketBased: true, CanHaveEmptyDirectories: true, SetTier: true, GetTier: true, ServerSideAcrossConfigs: opt.ServerSideAcrossConfigs, ReadMetadata: true, WriteMetadata: true, UserMetadata: true, ReadDirMetadata: true, WriteDirMetadata: true, WriteDirSetModTime: true, UserDirMetadata: true, DirModTimeUpdatesOnWrite: true, PartialUploads: true, }).Fill(ctx, f).Mask(ctx, wrappedFs).WrapsFs(f, wrappedFs) // Enable ListP always f.features.ListP = f.ListP return f, err } // Options defines the configuration for this backend type Options struct { Remote string `config:"remote"` FilenameEncryption string `config:"filename_encryption"` DirectoryNameEncryption bool `config:"directory_name_encryption"` NoDataEncryption bool `config:"no_data_encryption"` Password string `config:"password"` Password2 string `config:"password2"` ServerSideAcrossConfigs bool `config:"server_side_across_configs"` ShowMapping bool `config:"show_mapping"` PassBadBlocks bool `config:"pass_bad_blocks"` FilenameEncoding string `config:"filename_encoding"` Suffix string `config:"suffix"` StrictNames bool `config:"strict_names"` } // Fs represents a wrapped fs.Fs type Fs struct { fs.Fs wrapper fs.Fs name string root string opt Options features *fs.Features // optional features cipher *Cipher } // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // String returns a description of the FS func (f *Fs) String() string { return fmt.Sprintf("Encrypted drive '%s:%s'", f.name, f.root) } // Encrypt an object file name to entries. func (f *Fs) add(entries *fs.DirEntries, obj fs.Object) error { remote := obj.Remote() decryptedRemote, err := f.cipher.DecryptFileName(remote) if err != nil { if f.opt.StrictNames { return fmt.Errorf("%s: undecryptable file name detected: %v", remote, err) } fs.Logf(remote, "Skipping undecryptable file name: %v", err) return nil } if f.opt.ShowMapping { fs.Logf(decryptedRemote, "Encrypts to %q", remote) } *entries = append(*entries, f.newObject(obj)) return nil } // Encrypt a directory file name to entries. func (f *Fs) addDir(ctx context.Context, entries *fs.DirEntries, dir fs.Directory) error { remote := dir.Remote() decryptedRemote, err := f.cipher.DecryptDirName(remote) if err != nil { if f.opt.StrictNames { return fmt.Errorf("%s: undecryptable dir name detected: %v", remote, err) } fs.Logf(remote, "Skipping undecryptable dir name: %v", err) return nil } if f.opt.ShowMapping { fs.Logf(decryptedRemote, "Encrypts to %q", remote) } *entries = append(*entries, f.newDir(ctx, dir)) return nil } // Encrypt some directory entries. This alters entries returning it as newEntries. func (f *Fs) encryptEntries(ctx context.Context, entries fs.DirEntries) (newEntries fs.DirEntries, err error) { newEntries = entries[:0] // in place filter errors := 0 var firsterr error for _, entry := range entries { switch x := entry.(type) { case fs.Object: err = f.add(&newEntries, x) case fs.Directory: err = f.addDir(ctx, &newEntries, x) default: return nil, fmt.Errorf("unknown object type %T", entry) } if err != nil { errors++ if firsterr == nil { firsterr = err } } } if firsterr != nil { return nil, fmt.Errorf("there were %v undecryptable name errors. first error: %v", errors, firsterr) } return newEntries, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { return list.WithListP(ctx, dir, f) } // ListP lists the objects and directories of the Fs starting // from dir non recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. func (f *Fs) ListP(ctx context.Context, dir string, callback fs.ListRCallback) error { wrappedCallback := func(entries fs.DirEntries) error { entries, err := f.encryptEntries(ctx, entries) if err != nil { return err } return callback(entries) } listP := f.Fs.Features().ListP encryptedDir := f.cipher.EncryptDirName(dir) if listP == nil { entries, err := f.Fs.List(ctx, encryptedDir) if err != nil { return err } return wrappedCallback(entries) } return listP(ctx, encryptedDir, wrappedCallback) } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively that doing a directory traversal. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { return f.Fs.Features().ListR(ctx, f.cipher.EncryptDirName(dir), func(entries fs.DirEntries) error { newEntries, err := f.encryptEntries(ctx, entries) if err != nil { return err } return callback(newEntries) }) } // NewObject finds the Object at remote. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { o, err := f.Fs.NewObject(ctx, f.cipher.EncryptFileName(remote)) if err != nil { return nil, err } return f.newObject(o), nil } type putFn func(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) // put implements Put or PutStream func (f *Fs) put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options []fs.OpenOption, put putFn) (fs.Object, error) { ci := fs.GetConfig(ctx) if f.opt.NoDataEncryption { o, err := put(ctx, in, f.newObjectInfo(src, nonce{}), options...) if err == nil && o != nil { o = f.newObject(o) } return o, err } // Encrypt the data into wrappedIn wrappedIn, encrypter, err := f.cipher.encryptData(in) if err != nil { return nil, err } // Find a hash the destination supports to compute a hash of // the encrypted data ht := f.Fs.Hashes().GetOne() if ci.IgnoreChecksum { ht = hash.None } var hasher *hash.MultiHasher if ht != hash.None { hasher, err = hash.NewMultiHasherTypes(hash.NewHashSet(ht)) if err != nil { return nil, err } // unwrap the accounting var wrap accounting.WrapFn wrappedIn, wrap = accounting.UnWrap(wrappedIn) // add the hasher wrappedIn = io.TeeReader(wrappedIn, hasher) // wrap the accounting back on wrappedIn = wrap(wrappedIn) } // Transfer the data o, err := put(ctx, wrappedIn, f.newObjectInfo(src, encrypter.nonce), options...) if err != nil { return nil, err } // Check the hashes of the encrypted data if we were comparing them if ht != hash.None && hasher != nil { srcHash := hasher.Sums()[ht] var dstHash string dstHash, err = o.Hash(ctx, ht) if err != nil { return nil, fmt.Errorf("failed to read destination hash: %w", err) } if srcHash != "" && dstHash != "" { if srcHash != dstHash { // remove object err = o.Remove(ctx) if err != nil { fs.Errorf(o, "Failed to remove corrupted object: %v", err) } return nil, fmt.Errorf("corrupted on transfer: %v encrypted hashes differ src(%s) %q vs dst(%s) %q", ht, f.Fs, srcHash, o.Fs(), dstHash) } fs.Debugf(src, "%v = %s OK", ht, srcHash) } } return f.newObject(o), nil } // Put in to the remote path with the modTime given of the given size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.put(ctx, in, src, options, f.Fs.Put) } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.put(ctx, in, src, options, f.Fs.Features().PutStream) } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hash.None) } // Mkdir makes the directory (container, bucket) // // Shouldn't return an error if it already exists func (f *Fs) Mkdir(ctx context.Context, dir string) error { return f.Fs.Mkdir(ctx, f.cipher.EncryptDirName(dir)) } // MkdirMetadata makes the root directory of the Fs object func (f *Fs) MkdirMetadata(ctx context.Context, dir string, metadata fs.Metadata) (fs.Directory, error) { do := f.Fs.Features().MkdirMetadata if do == nil { return nil, fs.ErrorNotImplemented } newDir, err := do(ctx, f.cipher.EncryptDirName(dir), metadata) if err != nil { return nil, err } var entries = make(fs.DirEntries, 0, 1) err = f.addDir(ctx, &entries, newDir) if err != nil { return nil, err } newDir, ok := entries[0].(fs.Directory) if !ok { return nil, fmt.Errorf("internal error: expecting %T to be fs.Directory", entries[0]) } return newDir, nil } // DirSetModTime sets the directory modtime for dir func (f *Fs) DirSetModTime(ctx context.Context, dir string, modTime time.Time) error { do := f.Fs.Features().DirSetModTime if do == nil { return fs.ErrorNotImplemented } return do(ctx, f.cipher.EncryptDirName(dir), modTime) } // Rmdir removes the directory (container, bucket) if empty // // Return an error if it doesn't exist or isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { return f.Fs.Rmdir(ctx, f.cipher.EncryptDirName(dir)) } // Purge all files in the directory specified // // Implement this if you have a way of deleting all the files // quicker than just running Remove() on the result of List() // // Return an error if it doesn't exist func (f *Fs) Purge(ctx context.Context, dir string) error { do := f.Fs.Features().Purge if do == nil { return fs.ErrorCantPurge } return do(ctx, f.cipher.EncryptDirName(dir)) } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { do := f.Fs.Features().Copy if do == nil { return nil, fs.ErrorCantCopy } o, ok := src.(*Object) if !ok { return nil, fs.ErrorCantCopy } oResult, err := do(ctx, o.Object, f.cipher.EncryptFileName(remote)) if err != nil { return nil, err } return f.newObject(oResult), nil } // Move src to this remote using server-side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { do := f.Fs.Features().Move if do == nil { return nil, fs.ErrorCantMove } o, ok := src.(*Object) if !ok { return nil, fs.ErrorCantMove } oResult, err := do(ctx, o.Object, f.cipher.EncryptFileName(remote)) if err != nil { return nil, err } return f.newObject(oResult), nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { do := f.Fs.Features().DirMove if do == nil { return fs.ErrorCantDirMove } srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } return do(ctx, srcFs.Fs, f.cipher.EncryptDirName(srcRemote), f.cipher.EncryptDirName(dstRemote)) } // PutUnchecked uploads the object // // This will create a duplicate if we upload a new file without // checking to see if there is one already - use Put() for that. func (f *Fs) PutUnchecked(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { do := f.Fs.Features().PutUnchecked if do == nil { return nil, errors.New("can't PutUnchecked") } wrappedIn, encrypter, err := f.cipher.encryptData(in) if err != nil { return nil, err } o, err := do(ctx, wrappedIn, f.newObjectInfo(src, encrypter.nonce)) if err != nil { return nil, err } return f.newObject(o), nil } // CleanUp the trash in the Fs // // Implement this if you have a way of emptying the trash or // otherwise cleaning up old versions of files. func (f *Fs) CleanUp(ctx context.Context) error { do := f.Fs.Features().CleanUp if do == nil { return errors.New("not supported by underlying remote") } return do(ctx) } // About gets quota information from the Fs func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { do := f.Fs.Features().About if do == nil { return nil, errors.New("not supported by underlying remote") } return do(ctx) } // UnWrap returns the Fs that this Fs is wrapping func (f *Fs) UnWrap() fs.Fs { return f.Fs } // WrapFs returns the Fs that is wrapping this Fs func (f *Fs) WrapFs() fs.Fs { return f.wrapper } // SetWrapper sets the Fs that is wrapping this Fs func (f *Fs) SetWrapper(wrapper fs.Fs) { f.wrapper = wrapper } // EncryptFileName returns an encrypted file name func (f *Fs) EncryptFileName(fileName string) string { return f.cipher.EncryptFileName(fileName) } // DecryptFileName returns a decrypted file name func (f *Fs) DecryptFileName(encryptedFileName string) (string, error) { return f.cipher.DecryptFileName(encryptedFileName) } // computeHashWithNonce takes the nonce and encrypts the contents of // src with it, and calculates the hash given by HashType on the fly // // Note that we break lots of encapsulation in this function. func (f *Fs) computeHashWithNonce(ctx context.Context, nonce nonce, src fs.Object, hashType hash.Type) (hashStr string, err error) { // Open the src for input in, err := src.Open(ctx) if err != nil { return "", fmt.Errorf("failed to open src: %w", err) } defer fs.CheckClose(in, &err) // Now encrypt the src with the nonce out, err := f.cipher.newEncrypter(in, &nonce) if err != nil { return "", fmt.Errorf("failed to make encrypter: %w", err) } // pipe into hash m, err := hash.NewMultiHasherTypes(hash.NewHashSet(hashType)) if err != nil { return "", fmt.Errorf("failed to make hasher: %w", err) } _, err = io.Copy(m, out) if err != nil { return "", fmt.Errorf("failed to hash data: %w", err) } return m.Sums()[hashType], nil } // ComputeHash takes the nonce from o, and encrypts the contents of // src with it, and calculates the hash given by HashType on the fly // // Note that we break lots of encapsulation in this function. func (f *Fs) ComputeHash(ctx context.Context, o *Object, src fs.Object, hashType hash.Type) (hashStr string, err error) { if f.opt.NoDataEncryption { return src.Hash(ctx, hashType) } // Read the nonce - opening the file is sufficient to read the nonce in // use a limited read so we only read the header in, err := o.Object.Open(ctx, &fs.RangeOption{Start: 0, End: int64(fileHeaderSize) - 1}) if err != nil { return "", fmt.Errorf("failed to open object to read nonce: %w", err) } d, err := f.cipher.newDecrypter(in) if err != nil { _ = in.Close() return "", fmt.Errorf("failed to open object to read nonce: %w", err) } nonce := d.nonce // fs.Debugf(o, "Read nonce % 2x", nonce) // Check nonce isn't all zeros isZero := true for i := range nonce { if nonce[i] != 0 { isZero = false } } if isZero { fs.Errorf(o, "empty nonce read") } // Close d (and hence in) once we have read the nonce err = d.Close() if err != nil { return "", fmt.Errorf("failed to close nonce read: %w", err) } return f.computeHashWithNonce(ctx, nonce, src, hashType) } // MergeDirs merges the contents of all the directories passed // in into the first one and rmdirs the other directories. func (f *Fs) MergeDirs(ctx context.Context, dirs []fs.Directory) error { do := f.Fs.Features().MergeDirs if do == nil { return errors.New("MergeDirs not supported") } out := make([]fs.Directory, len(dirs)) for i, dir := range dirs { out[i] = fs.NewDirWrapper(f.cipher.EncryptDirName(dir.Remote()), dir) } return do(ctx, out) } // DirCacheFlush resets the directory cache - used in testing // as an optional interface func (f *Fs) DirCacheFlush() { do := f.Fs.Features().DirCacheFlush if do != nil { do() } } // PublicLink generates a public link to the remote path (usually readable by anyone) func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (string, error) { do := f.Fs.Features().PublicLink if do == nil { return "", errors.New("PublicLink not supported") } o, err := f.NewObject(ctx, remote) if err != nil { // assume it is a directory return do(ctx, f.cipher.EncryptDirName(remote), expire, unlink) } return do(ctx, o.(*Object).Object.Remote(), expire, unlink) } // ChangeNotify calls the passed function with a path // that has had changes. If the implementation // uses polling, it should adhere to the given interval. func (f *Fs) ChangeNotify(ctx context.Context, notifyFunc func(string, fs.EntryType), pollIntervalChan <-chan time.Duration) { do := f.Fs.Features().ChangeNotify if do == nil { return } wrappedNotifyFunc := func(path string, entryType fs.EntryType) { // fs.Debugf(f, "ChangeNotify: path %q entryType %d", path, entryType) var ( err error decrypted string ) switch entryType { case fs.EntryDirectory: decrypted, err = f.cipher.DecryptDirName(path) case fs.EntryObject: decrypted, err = f.cipher.DecryptFileName(path) default: fs.Errorf(path, "crypt ChangeNotify: ignoring unknown EntryType %d", entryType) return } if err != nil { fs.Logf(f, "ChangeNotify was unable to decrypt %q: %s", path, err) return } notifyFunc(decrypted, entryType) } do(ctx, wrappedNotifyFunc, pollIntervalChan) } var commandHelp = []fs.CommandHelp{ { Name: "encode", Short: "Encode the given filename(s)", Long: `This encodes the filenames given as arguments returning a list of strings of the encoded results. Usage Example: rclone backend encode crypt: file1 [file2...] rclone rc backend/command command=encode fs=crypt: file1 [file2...] `, }, { Name: "decode", Short: "Decode the given filename(s)", Long: `This decodes the filenames given as arguments returning a list of strings of the decoded results. It will return an error if any of the inputs are invalid. Usage Example: rclone backend decode crypt: encryptedfile1 [encryptedfile2...] rclone rc backend/command command=decode fs=crypt: encryptedfile1 [encryptedfile2...] `, }, } // Command the backend to run a named command // // The command run is name // args may be used to read arguments from // opts may be used to read optional arguments from // // The result should be capable of being JSON encoded // If it is a string or a []string it will be shown to the user // otherwise it will be JSON encoded and shown to the user like that func (f *Fs) Command(ctx context.Context, name string, arg []string, opt map[string]string) (out any, err error) { switch name { case "decode": out := make([]string, 0, len(arg)) for _, encryptedFileName := range arg { fileName, err := f.DecryptFileName(encryptedFileName) if err != nil { return out, fmt.Errorf("failed to decrypt: %s: %w", encryptedFileName, err) } out = append(out, fileName) } return out, nil case "encode": out := make([]string, 0, len(arg)) for _, fileName := range arg { encryptedFileName := f.EncryptFileName(fileName) out = append(out, encryptedFileName) } return out, nil default: return nil, fs.ErrorCommandNotFound } } // Object describes a wrapped for being read from the Fs // // This decrypts the remote name and decrypts the data type Object struct { fs.Object f *Fs } func (f *Fs) newObject(o fs.Object) *Object { return &Object{ Object: o, f: f, } } // Fs returns read only access to the Fs that this object is part of func (o *Object) Fs() fs.Info { return o.f } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.Remote() } // Remote returns the remote path func (o *Object) Remote() string { remote := o.Object.Remote() decryptedName, err := o.f.cipher.DecryptFileName(remote) if err != nil { fs.Debugf(remote, "Undecryptable file name: %v", err) return remote } return decryptedName } // Size returns the size of the file func (o *Object) Size() int64 { size := o.Object.Size() if !o.f.opt.NoDataEncryption { var err error size, err = o.f.cipher.DecryptedSize(size) if err != nil { fs.Debugf(o, "Bad size for decrypt: %v", err) } } return size } // Hash returns the selected checksum of the file // If no checksum is available it returns "" func (o *Object) Hash(ctx context.Context, ht hash.Type) (string, error) { return "", hash.ErrUnsupported } // UnWrap returns the wrapped Object func (o *Object) UnWrap() fs.Object { return o.Object } // Open opens the file for read. Call Close() on the returned io.ReadCloser func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (rc io.ReadCloser, err error) { if o.f.opt.NoDataEncryption { return o.Object.Open(ctx, options...) } var openOptions []fs.OpenOption var offset, limit int64 = 0, -1 for _, option := range options { switch x := option.(type) { case *fs.SeekOption: offset = x.Offset case *fs.RangeOption: offset, limit = x.Decode(o.Size()) default: // pass on Options to underlying open if appropriate openOptions = append(openOptions, option) } } rc, err = o.f.cipher.DecryptDataSeek(ctx, func(ctx context.Context, underlyingOffset, underlyingLimit int64) (io.ReadCloser, error) { if underlyingOffset == 0 && underlyingLimit < 0 { // Open with no seek return o.Object.Open(ctx, openOptions...) } // Open stream with a range of underlyingOffset, underlyingLimit end := int64(-1) if underlyingLimit >= 0 { end = underlyingOffset + underlyingLimit - 1 if end >= o.Object.Size() { end = -1 } } newOpenOptions := append(openOptions, &fs.RangeOption{Start: underlyingOffset, End: end}) return o.Object.Open(ctx, newOpenOptions...) }, offset, limit) if err != nil { return nil, err } return rc, nil } // Update in to the object with the modTime given of the given size func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { update := func(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return o.Object, o.Object.Update(ctx, in, src, options...) } _, err := o.f.put(ctx, in, src, options, update) return err } // newDir returns a dir with the Name decrypted func (f *Fs) newDir(ctx context.Context, dir fs.Directory) fs.Directory { remote := dir.Remote() decryptedRemote, err := f.cipher.DecryptDirName(remote) if err != nil { fs.Debugf(remote, "Undecryptable dir name: %v", err) } else { remote = decryptedRemote } newDir := fs.NewDirWrapper(remote, dir) return newDir } // UserInfo returns info about the connected user func (f *Fs) UserInfo(ctx context.Context) (map[string]string, error) { do := f.Fs.Features().UserInfo if do == nil { return nil, fs.ErrorNotImplemented } return do(ctx) } // Disconnect the current user func (f *Fs) Disconnect(ctx context.Context) error { do := f.Fs.Features().Disconnect if do == nil { return fs.ErrorNotImplemented } return do(ctx) } // Shutdown the backend, closing any background tasks and any // cached connections. func (f *Fs) Shutdown(ctx context.Context) error { do := f.Fs.Features().Shutdown if do == nil { return nil } return do(ctx) } // ObjectInfo describes a wrapped fs.ObjectInfo for being the source // // This encrypts the remote name and adjusts the size type ObjectInfo struct { fs.ObjectInfo f *Fs nonce nonce } func (f *Fs) newObjectInfo(src fs.ObjectInfo, nonce nonce) *ObjectInfo { return &ObjectInfo{ ObjectInfo: src, f: f, nonce: nonce, } } // Fs returns read only access to the Fs that this object is part of func (o *ObjectInfo) Fs() fs.Info { return o.f } // Remote returns the remote path func (o *ObjectInfo) Remote() string { return o.f.cipher.EncryptFileName(o.ObjectInfo.Remote()) } // Size returns the size of the file func (o *ObjectInfo) Size() int64 { size := o.ObjectInfo.Size() if size < 0 { return size } if o.f.opt.NoDataEncryption { return size } return o.f.cipher.EncryptedSize(size) } // Hash returns the selected checksum of the file // If no checksum is available it returns "" func (o *ObjectInfo) Hash(ctx context.Context, hash hash.Type) (string, error) { var srcObj fs.Object var ok bool // Get the underlying object if there is one if srcObj, ok = o.ObjectInfo.(fs.Object); ok { // Prefer direct interface assertion } else if do, ok := o.ObjectInfo.(*fs.OverrideRemote); ok { // Unwrap if it is an operations.OverrideRemote srcObj = do.UnWrap() } else { // Otherwise don't unwrap any further return "", nil } // if this is wrapping a local object then we work out the hash if srcObj.Fs().Features().IsLocal { // Read the data and encrypt it to calculate the hash fs.Debugf(o, "Computing %v hash of encrypted source", hash) return o.f.computeHashWithNonce(ctx, o.nonce, srcObj, hash) } return "", nil } // GetTier returns storage tier or class of the Object func (o *ObjectInfo) GetTier() string { do, ok := o.ObjectInfo.(fs.GetTierer) if !ok { return "" } return do.GetTier() } // ID returns the ID of the Object if known, or "" if not func (o *ObjectInfo) ID() string { do, ok := o.ObjectInfo.(fs.IDer) if !ok { return "" } return do.ID() } // Metadata returns metadata for an object // // It should return nil if there is no Metadata func (o *ObjectInfo) Metadata(ctx context.Context) (fs.Metadata, error) { do, ok := o.ObjectInfo.(fs.Metadataer) if !ok { return nil, nil } return do.Metadata(ctx) } // MimeType returns the content type of the Object if // known, or "" if not // // This is deliberately unsupported so we don't leak mime type info by // default. func (o *ObjectInfo) MimeType(ctx context.Context) string { return "" } // UnWrap returns the Object that this Object is wrapping or // nil if it isn't wrapping anything func (o *ObjectInfo) UnWrap() fs.Object { return fs.UnWrapObjectInfo(o.ObjectInfo) } // ID returns the ID of the Object if known, or "" if not func (o *Object) ID() string { do, ok := o.Object.(fs.IDer) if !ok { return "" } return do.ID() } // SetTier performs changing storage tier of the Object if // multiple storage classes supported func (o *Object) SetTier(tier string) error { do, ok := o.Object.(fs.SetTierer) if !ok { return errors.New("crypt: underlying remote does not support SetTier") } return do.SetTier(tier) } // GetTier returns storage tier or class of the Object func (o *Object) GetTier() string { do, ok := o.Object.(fs.GetTierer) if !ok { return "" } return do.GetTier() } // Metadata returns metadata for an object // // It should return nil if there is no Metadata func (o *Object) Metadata(ctx context.Context) (fs.Metadata, error) { do, ok := o.Object.(fs.Metadataer) if !ok { return nil, nil } return do.Metadata(ctx) } // SetMetadata sets metadata for an Object // // It should return fs.ErrorNotImplemented if it can't set metadata func (o *Object) SetMetadata(ctx context.Context, metadata fs.Metadata) error { do, ok := o.Object.(fs.SetMetadataer) if !ok { return fs.ErrorNotImplemented } return do.SetMetadata(ctx, metadata) } // MimeType returns the content type of the Object if // known, or "" if not // // This is deliberately unsupported so we don't leak mime type info by // default. func (o *Object) MimeType(ctx context.Context) string { return "" } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.Commander = (*Fs)(nil) _ fs.PutUncheckeder = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.CleanUpper = (*Fs)(nil) _ fs.UnWrapper = (*Fs)(nil) _ fs.ListRer = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.Wrapper = (*Fs)(nil) _ fs.MergeDirser = (*Fs)(nil) _ fs.DirSetModTimer = (*Fs)(nil) _ fs.MkdirMetadataer = (*Fs)(nil) _ fs.DirCacheFlusher = (*Fs)(nil) _ fs.ChangeNotifier = (*Fs)(nil) _ fs.PublicLinker = (*Fs)(nil) _ fs.UserInfoer = (*Fs)(nil) _ fs.Disconnecter = (*Fs)(nil) _ fs.Shutdowner = (*Fs)(nil) _ fs.FullObjectInfo = (*ObjectInfo)(nil) _ fs.FullObject = (*Object)(nil) ) rclone-v1.71.0/backend/crypt/crypt_internal_test.go000066400000000000000000000066131505210326400224270ustar00rootroot00000000000000package crypt import ( "bytes" "context" "crypto/md5" "fmt" "io" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/object" "github.com/rclone/rclone/lib/random" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Create a temporary local fs to upload things from func makeTempLocalFs(t *testing.T) (localFs fs.Fs) { localFs, err := fs.TemporaryLocalFs(context.Background()) require.NoError(t, err) t.Cleanup(func() { require.NoError(t, localFs.Rmdir(context.Background(), "")) }) return localFs } // Upload a file to a remote func uploadFile(t *testing.T, f fs.Fs, remote, contents string) (obj fs.Object) { inBuf := bytes.NewBufferString(contents) t1 := time.Date(2012, time.December, 17, 18, 32, 31, 0, time.UTC) upSrc := object.NewStaticObjectInfo(remote, t1, int64(len(contents)), true, nil, nil) obj, err := f.Put(context.Background(), inBuf, upSrc) require.NoError(t, err) t.Cleanup(func() { require.NoError(t, obj.Remove(context.Background())) }) return obj } // Test the ObjectInfo func testObjectInfo(t *testing.T, f *Fs, wrap bool) { var ( contents = random.String(100) path = "hash_test_object" ctx = context.Background() ) if wrap { path = "_wrap" } localFs := makeTempLocalFs(t) obj := uploadFile(t, localFs, path, contents) // encrypt the data inBuf := bytes.NewBufferString(contents) var outBuf bytes.Buffer enc, err := f.cipher.newEncrypter(inBuf, nil) require.NoError(t, err) nonce := enc.nonce // read the nonce at the start _, err = io.Copy(&outBuf, enc) require.NoError(t, err) var oi fs.ObjectInfo = obj if wrap { // wrap the object in an fs.ObjectUnwrapper if required oi = fs.NewOverrideRemote(oi, "new_remote") } // wrap the object in a crypt for upload using the nonce we // saved from the encrypter src := f.newObjectInfo(oi, nonce) // Test ObjectInfo methods if !f.opt.NoDataEncryption { assert.Equal(t, int64(outBuf.Len()), src.Size()) } assert.Equal(t, f, src.Fs()) assert.NotEqual(t, path, src.Remote()) // Test ObjectInfo.Hash wantHash := md5.Sum(outBuf.Bytes()) gotHash, err := src.Hash(ctx, hash.MD5) require.NoError(t, err) assert.Equal(t, fmt.Sprintf("%x", wantHash), gotHash) } func testComputeHash(t *testing.T, f *Fs) { var ( contents = random.String(100) path = "compute_hash_test" ctx = context.Background() hashType = f.Fs.Hashes().GetOne() ) if hashType == hash.None { t.Skipf("%v: does not support hashes", f.Fs) } localFs := makeTempLocalFs(t) // Upload a file to localFs as a test object localObj := uploadFile(t, localFs, path, contents) // Upload the same data to the remote Fs also remoteObj := uploadFile(t, f, path, contents) // Calculate the expected Hash of the remote object computedHash, err := f.ComputeHash(ctx, remoteObj.(*Object), localObj, hashType) require.NoError(t, err) // Test computed hash matches remote object hash remoteObjHash, err := remoteObj.(*Object).Object.Hash(ctx, hashType) require.NoError(t, err) assert.Equal(t, remoteObjHash, computedHash) } // InternalTest is called by fstests.Run to extra tests func (f *Fs) InternalTest(t *testing.T) { t.Run("ObjectInfo", func(t *testing.T) { testObjectInfo(t, f, false) }) t.Run("ObjectInfoWrap", func(t *testing.T) { testObjectInfo(t, f, true) }) t.Run("ComputeHash", func(t *testing.T) { testComputeHash(t, f) }) } rclone-v1.71.0/backend/crypt/crypt_test.go000066400000000000000000000137671505210326400205430ustar00rootroot00000000000000// Test Crypt filesystem interface package crypt_test import ( "os" "path/filepath" "runtime" "testing" "github.com/rclone/rclone/backend/crypt" _ "github.com/rclone/rclone/backend/drive" // for integration tests _ "github.com/rclone/rclone/backend/local" _ "github.com/rclone/rclone/backend/swift" // for integration tests "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { if *fstest.RemoteName == "" { t.Skip("Skipping as -remote not set") } fstests.Run(t, &fstests.Opt{ RemoteName: *fstest.RemoteName, NilObject: (*crypt.Object)(nil), UnimplementableFsMethods: []string{"OpenWriterAt", "OpenChunkWriter"}, UnimplementableObjectMethods: []string{"MimeType"}, }) } // TestStandard runs integration tests against the remote func TestStandardBase32(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("Skipping as -remote set") } tempdir := filepath.Join(os.TempDir(), "rclone-crypt-test-standard") name := "TestCrypt" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":", NilObject: (*crypt.Object)(nil), ExtraConfig: []fstests.ExtraConfigItem{ {Name: name, Key: "type", Value: "crypt"}, {Name: name, Key: "remote", Value: tempdir}, {Name: name, Key: "password", Value: obscure.MustObscure("potato")}, {Name: name, Key: "filename_encryption", Value: "standard"}, }, UnimplementableFsMethods: []string{"OpenWriterAt", "OpenChunkWriter"}, UnimplementableObjectMethods: []string{"MimeType"}, QuickTestOK: true, }) } func TestStandardBase64(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("Skipping as -remote set") } tempdir := filepath.Join(os.TempDir(), "rclone-crypt-test-standard") name := "TestCrypt" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":", NilObject: (*crypt.Object)(nil), ExtraConfig: []fstests.ExtraConfigItem{ {Name: name, Key: "type", Value: "crypt"}, {Name: name, Key: "remote", Value: tempdir}, {Name: name, Key: "password", Value: obscure.MustObscure("potato")}, {Name: name, Key: "filename_encryption", Value: "standard"}, {Name: name, Key: "filename_encoding", Value: "base64"}, }, UnimplementableFsMethods: []string{"OpenWriterAt", "OpenChunkWriter"}, UnimplementableObjectMethods: []string{"MimeType"}, QuickTestOK: true, }) } func TestStandardBase32768(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("Skipping as -remote set") } tempdir := filepath.Join(os.TempDir(), "rclone-crypt-test-standard") name := "TestCrypt" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":", NilObject: (*crypt.Object)(nil), ExtraConfig: []fstests.ExtraConfigItem{ {Name: name, Key: "type", Value: "crypt"}, {Name: name, Key: "remote", Value: tempdir}, {Name: name, Key: "password", Value: obscure.MustObscure("potato")}, {Name: name, Key: "filename_encryption", Value: "standard"}, {Name: name, Key: "filename_encoding", Value: "base32768"}, }, UnimplementableFsMethods: []string{"OpenWriterAt", "OpenChunkWriter"}, UnimplementableObjectMethods: []string{"MimeType"}, QuickTestOK: true, }) } // TestOff runs integration tests against the remote func TestOff(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("Skipping as -remote set") } tempdir := filepath.Join(os.TempDir(), "rclone-crypt-test-off") name := "TestCrypt2" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":", NilObject: (*crypt.Object)(nil), ExtraConfig: []fstests.ExtraConfigItem{ {Name: name, Key: "type", Value: "crypt"}, {Name: name, Key: "remote", Value: tempdir}, {Name: name, Key: "password", Value: obscure.MustObscure("potato2")}, {Name: name, Key: "filename_encryption", Value: "off"}, }, UnimplementableFsMethods: []string{"OpenWriterAt", "OpenChunkWriter"}, UnimplementableObjectMethods: []string{"MimeType"}, QuickTestOK: true, }) } // TestObfuscate runs integration tests against the remote func TestObfuscate(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("Skipping as -remote set") } if runtime.GOOS == "darwin" { t.Skip("Skipping on macOS as obfuscating control characters makes filenames macOS can't cope with") } tempdir := filepath.Join(os.TempDir(), "rclone-crypt-test-obfuscate") name := "TestCrypt3" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":", NilObject: (*crypt.Object)(nil), ExtraConfig: []fstests.ExtraConfigItem{ {Name: name, Key: "type", Value: "crypt"}, {Name: name, Key: "remote", Value: tempdir}, {Name: name, Key: "password", Value: obscure.MustObscure("potato2")}, {Name: name, Key: "filename_encryption", Value: "obfuscate"}, }, SkipBadWindowsCharacters: true, UnimplementableFsMethods: []string{"OpenWriterAt", "OpenChunkWriter"}, UnimplementableObjectMethods: []string{"MimeType"}, QuickTestOK: true, }) } // TestNoDataObfuscate runs integration tests against the remote func TestNoDataObfuscate(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("Skipping as -remote set") } if runtime.GOOS == "darwin" { t.Skip("Skipping on macOS as obfuscating control characters makes filenames macOS can't cope with") } tempdir := filepath.Join(os.TempDir(), "rclone-crypt-test-obfuscate") name := "TestCrypt4" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":", NilObject: (*crypt.Object)(nil), ExtraConfig: []fstests.ExtraConfigItem{ {Name: name, Key: "type", Value: "crypt"}, {Name: name, Key: "remote", Value: tempdir}, {Name: name, Key: "password", Value: obscure.MustObscure("potato2")}, {Name: name, Key: "filename_encryption", Value: "obfuscate"}, {Name: name, Key: "no_data_encryption", Value: "true"}, }, SkipBadWindowsCharacters: true, UnimplementableFsMethods: []string{"OpenWriterAt", "OpenChunkWriter"}, UnimplementableObjectMethods: []string{"MimeType"}, QuickTestOK: true, }) } rclone-v1.71.0/backend/crypt/pkcs7/000077500000000000000000000000001505210326400170255ustar00rootroot00000000000000rclone-v1.71.0/backend/crypt/pkcs7/pkcs7.go000066400000000000000000000032241505210326400204040ustar00rootroot00000000000000// Package pkcs7 implements PKCS#7 padding // // This is a standard way of encoding variable length buffers into // buffers which are a multiple of an underlying crypto block size. package pkcs7 import "errors" // Errors Unpad can return var ( ErrorPaddingNotFound = errors.New("bad PKCS#7 padding - not padded") ErrorPaddingNotAMultiple = errors.New("bad PKCS#7 padding - not a multiple of blocksize") ErrorPaddingTooLong = errors.New("bad PKCS#7 padding - too long") ErrorPaddingTooShort = errors.New("bad PKCS#7 padding - too short") ErrorPaddingNotAllTheSame = errors.New("bad PKCS#7 padding - not all the same") ) // Pad buf using PKCS#7 to a multiple of n. // // Appends the padding to buf - make a copy of it first if you don't // want it modified. func Pad(n int, buf []byte) []byte { if n <= 1 || n >= 256 { panic("bad multiple") } length := len(buf) padding := n - (length % n) for range padding { buf = append(buf, byte(padding)) } if (len(buf) % n) != 0 { panic("padding failed") } return buf } // Unpad buf using PKCS#7 from a multiple of n returning a slice of // buf or an error if malformed. func Unpad(n int, buf []byte) ([]byte, error) { if n <= 1 || n >= 256 { panic("bad multiple") } length := len(buf) if length == 0 { return nil, ErrorPaddingNotFound } if (length % n) != 0 { return nil, ErrorPaddingNotAMultiple } padding := int(buf[length-1]) if padding > n { return nil, ErrorPaddingTooLong } if padding == 0 { return nil, ErrorPaddingTooShort } for i := range padding { if buf[length-1-i] != byte(padding) { return nil, ErrorPaddingNotAllTheSame } } return buf[:length-padding], nil } rclone-v1.71.0/backend/crypt/pkcs7/pkcs7_test.go000066400000000000000000000052421505210326400214450ustar00rootroot00000000000000package pkcs7 import ( "fmt" "testing" "github.com/stretchr/testify/assert" ) func TestPad(t *testing.T) { for _, test := range []struct { n int in string expected string }{ {8, "", "\x08\x08\x08\x08\x08\x08\x08\x08"}, {8, "1", "1\x07\x07\x07\x07\x07\x07\x07"}, {8, "12", "12\x06\x06\x06\x06\x06\x06"}, {8, "123", "123\x05\x05\x05\x05\x05"}, {8, "1234", "1234\x04\x04\x04\x04"}, {8, "12345", "12345\x03\x03\x03"}, {8, "123456", "123456\x02\x02"}, {8, "1234567", "1234567\x01"}, {8, "abcdefgh", "abcdefgh\x08\x08\x08\x08\x08\x08\x08\x08"}, {8, "abcdefgh1", "abcdefgh1\x07\x07\x07\x07\x07\x07\x07"}, {8, "abcdefgh12", "abcdefgh12\x06\x06\x06\x06\x06\x06"}, {8, "abcdefgh123", "abcdefgh123\x05\x05\x05\x05\x05"}, {8, "abcdefgh1234", "abcdefgh1234\x04\x04\x04\x04"}, {8, "abcdefgh12345", "abcdefgh12345\x03\x03\x03"}, {8, "abcdefgh123456", "abcdefgh123456\x02\x02"}, {8, "abcdefgh1234567", "abcdefgh1234567\x01"}, {8, "abcdefgh12345678", "abcdefgh12345678\x08\x08\x08\x08\x08\x08\x08\x08"}, {16, "", "\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10"}, {16, "a", "a\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f\x0f"}, } { actual := Pad(test.n, []byte(test.in)) assert.Equal(t, test.expected, string(actual), fmt.Sprintf("Pad %d %q", test.n, test.in)) recovered, err := Unpad(test.n, actual) assert.NoError(t, err) assert.Equal(t, []byte(test.in), recovered, fmt.Sprintf("Unpad %d %q", test.n, test.in)) } assert.Panics(t, func() { Pad(1, []byte("")) }, "bad multiple") assert.Panics(t, func() { Pad(256, []byte("")) }, "bad multiple") } func TestUnpad(t *testing.T) { // We've tested the OK decoding in TestPad, now test the error cases for _, test := range []struct { n int in string err error }{ {8, "", ErrorPaddingNotFound}, {8, "1", ErrorPaddingNotAMultiple}, {8, "12", ErrorPaddingNotAMultiple}, {8, "123", ErrorPaddingNotAMultiple}, {8, "1234", ErrorPaddingNotAMultiple}, {8, "12345", ErrorPaddingNotAMultiple}, {8, "123456", ErrorPaddingNotAMultiple}, {8, "1234567", ErrorPaddingNotAMultiple}, {8, "1234567\xFF", ErrorPaddingTooLong}, {8, "1234567\x09", ErrorPaddingTooLong}, {8, "1234567\x00", ErrorPaddingTooShort}, {8, "123456\x01\x02", ErrorPaddingNotAllTheSame}, {8, "\x07\x08\x08\x08\x08\x08\x08\x08", ErrorPaddingNotAllTheSame}, } { result, actualErr := Unpad(test.n, []byte(test.in)) assert.Equal(t, test.err, actualErr, fmt.Sprintf("Unpad %d %q", test.n, test.in)) assert.Equal(t, result, []byte(nil)) } assert.Panics(t, func() { _, _ = Unpad(1, []byte("")) }, "bad multiple") assert.Panics(t, func() { _, _ = Unpad(256, []byte("")) }, "bad multiple") } rclone-v1.71.0/backend/doi/000077500000000000000000000000001505210326400154105ustar00rootroot00000000000000rclone-v1.71.0/backend/doi/api/000077500000000000000000000000001505210326400161615ustar00rootroot00000000000000rclone-v1.71.0/backend/doi/api/dataversetypes.go000066400000000000000000000024071505210326400215560ustar00rootroot00000000000000// Type definitions specific to Dataverse package api // DataverseDatasetResponse is returned by the Dataverse dataset API type DataverseDatasetResponse struct { Status string `json:"status"` Data DataverseDataset `json:"data"` } // DataverseDataset is the representation of a dataset type DataverseDataset struct { LatestVersion DataverseDatasetVersion `json:"latestVersion"` } // DataverseDatasetVersion is the representation of a dataset version type DataverseDatasetVersion struct { LastUpdateTime string `json:"lastUpdateTime"` Files []DataverseFile `json:"files"` } // DataverseFile is the representation of a file found in a dataset type DataverseFile struct { DirectoryLabel string `json:"directoryLabel"` DataFile DataverseDataFile `json:"dataFile"` } // DataverseDataFile represents file metadata details type DataverseDataFile struct { ID int64 `json:"id"` Filename string `json:"filename"` ContentType string `json:"contentType"` FileSize int64 `json:"filesize"` OriginalFileFormat string `json:"originalFileFormat"` OriginalFileSize int64 `json:"originalFileSize"` OriginalFileName string `json:"originalFileName"` MD5 string `json:"md5"` } rclone-v1.71.0/backend/doi/api/inveniotypes.go000066400000000000000000000021231505210326400212420ustar00rootroot00000000000000// Type definitions specific to InvenioRDM package api // InvenioRecordResponse is the representation of a record stored in InvenioRDM type InvenioRecordResponse struct { Links InvenioRecordResponseLinks `json:"links"` } // InvenioRecordResponseLinks represents a record's links type InvenioRecordResponseLinks struct { Self string `json:"self"` } // InvenioFilesResponse is the representation of a record's files type InvenioFilesResponse struct { Entries []InvenioFilesResponseEntry `json:"entries"` } // InvenioFilesResponseEntry is the representation of a file entry type InvenioFilesResponseEntry struct { Key string `json:"key"` Checksum string `json:"checksum"` Size int64 `json:"size"` Updated string `json:"updated"` MimeType string `json:"mimetype"` Links InvenioFilesResponseEntryLinks `json:"links"` } // InvenioFilesResponseEntryLinks represents file links details type InvenioFilesResponseEntryLinks struct { Content string `json:"content"` } rclone-v1.71.0/backend/doi/api/types.go000066400000000000000000000017361505210326400176630ustar00rootroot00000000000000// Package api has general type definitions for doi package api // DoiResolverResponse is returned by the DOI resolver API // // Reference: https://www.doi.org/the-identifier/resources/factsheets/doi-resolution-documentation type DoiResolverResponse struct { ResponseCode int `json:"responseCode"` Handle string `json:"handle"` Values []DoiResolverResponseValue `json:"values"` } // DoiResolverResponseValue is a single handle record value type DoiResolverResponseValue struct { Index int `json:"index"` Type string `json:"type"` Data DoiResolverResponseValueData `json:"data"` TTL int `json:"ttl"` Timestamp string `json:"timestamp"` } // DoiResolverResponseValueData is the data held in a handle value type DoiResolverResponseValueData struct { Format string `json:"format"` Value any `json:"value"` } rclone-v1.71.0/backend/doi/dataverse.go000066400000000000000000000065111505210326400177200ustar00rootroot00000000000000// Implementation for Dataverse package doi import ( "context" "fmt" "net/http" "net/url" "path" "strings" "time" "github.com/rclone/rclone/backend/doi/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/lib/rest" ) // Returns true if resolvedURL is likely a DOI hosted on a Dataverse intallation func activateDataverse(resolvedURL *url.URL) (isActive bool) { queryValues := resolvedURL.Query() persistentID := queryValues.Get("persistentId") return persistentID != "" } // Resolve the main API endpoint for a DOI hosted on a Dataverse installation func resolveDataverseEndpoint(resolvedURL *url.URL) (provider Provider, endpoint *url.URL, err error) { queryValues := resolvedURL.Query() persistentID := queryValues.Get("persistentId") query := url.Values{} query.Add("persistentId", persistentID) endpointURL := resolvedURL.ResolveReference(&url.URL{Path: "/api/datasets/:persistentId/", RawQuery: query.Encode()}) return Dataverse, endpointURL, nil } // dataverseProvider implements the doiProvider interface for Dataverse installations type dataverseProvider struct { f *Fs } // ListEntries returns the full list of entries found at the remote, regardless of root func (dp *dataverseProvider) ListEntries(ctx context.Context) (entries []*Object, err error) { // Use the cache if populated cachedEntries, found := dp.f.cache.GetMaybe("files") if found { parsedEntries, ok := cachedEntries.([]Object) if ok { for _, entry := range parsedEntries { newEntry := entry entries = append(entries, &newEntry) } return entries, nil } } filesURL := dp.f.endpoint var res *http.Response var result api.DataverseDatasetResponse opts := rest.Opts{ Method: "GET", Path: strings.TrimLeft(filesURL.EscapedPath(), "/"), Parameters: filesURL.Query(), } err = dp.f.pacer.Call(func() (bool, error) { res, err = dp.f.srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, res, err) }) if err != nil { return nil, fmt.Errorf("readDir failed: %w", err) } modTime, modTimeErr := time.Parse(time.RFC3339, result.Data.LatestVersion.LastUpdateTime) if modTimeErr != nil { fs.Logf(dp.f, "error: could not parse last update time %v", modTimeErr) modTime = timeUnset } for _, file := range result.Data.LatestVersion.Files { contentURLPath := fmt.Sprintf("/api/access/datafile/%d", file.DataFile.ID) query := url.Values{} query.Add("format", "original") contentURL := dp.f.endpoint.ResolveReference(&url.URL{Path: contentURLPath, RawQuery: query.Encode()}) entry := &Object{ fs: dp.f, remote: path.Join(file.DirectoryLabel, file.DataFile.Filename), contentURL: contentURL.String(), size: file.DataFile.FileSize, modTime: modTime, md5: file.DataFile.MD5, contentType: file.DataFile.ContentType, } if file.DataFile.OriginalFileName != "" { entry.remote = path.Join(file.DirectoryLabel, file.DataFile.OriginalFileName) entry.size = file.DataFile.OriginalFileSize entry.contentType = file.DataFile.OriginalFileFormat } entries = append(entries, entry) } // Populate the cache cacheEntries := []Object{} for _, entry := range entries { cacheEntries = append(cacheEntries, *entry) } dp.f.cache.Put("files", cacheEntries) return entries, nil } func newDataverseProvider(f *Fs) doiProvider { return &dataverseProvider{ f: f, } } rclone-v1.71.0/backend/doi/doi.go000066400000000000000000000443571505210326400165270ustar00rootroot00000000000000// Package doi provides a filesystem interface for digital objects identified by DOIs. // // See: https://www.doi.org/the-identifier/what-is-a-doi/ package doi import ( "context" "errors" "fmt" "io" "net/http" "net/url" "path" "strings" "time" "github.com/rclone/rclone/backend/doi/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/cache" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/rest" ) const ( // the URL of the DOI resolver // // Reference: https://www.doi.org/the-identifier/resources/factsheets/doi-resolution-documentation doiResolverAPIURL = "https://doi.org/api" minSleep = 10 * time.Millisecond maxSleep = 2 * time.Second decayConstant = 2 // bigger for slower decay, exponential ) var ( errorReadOnly = errors.New("doi remotes are read only") timeUnset = time.Unix(0, 0) ) func init() { fsi := &fs.RegInfo{ Name: "doi", Description: "DOI datasets", NewFs: NewFs, CommandHelp: commandHelp, Options: []fs.Option{{ Name: "doi", Help: "The DOI or the doi.org URL.", Required: true, }, { Name: fs.ConfigProvider, Help: `DOI provider. The DOI provider can be set when rclone does not automatically recognize a supported DOI provider.`, Examples: []fs.OptionExample{ { Value: "auto", Help: "Auto-detect provider", }, { Value: string(Zenodo), Help: "Zenodo", }, { Value: string(Dataverse), Help: "Dataverse", }, { Value: string(Invenio), Help: "Invenio", }}, Required: false, Advanced: true, }, { Name: "doi_resolver_api_url", Help: `The URL of the DOI resolver API to use. The DOI resolver can be set for testing or for cases when the the canonical DOI resolver API cannot be used. Defaults to "https://doi.org/api".`, Required: false, Advanced: true, }}, } fs.Register(fsi) } // Provider defines the type of provider hosting the DOI type Provider string const ( // Zenodo provider, see https://zenodo.org Zenodo Provider = "zenodo" // Dataverse provider, see https://dataverse.harvard.edu Dataverse Provider = "dataverse" // Invenio provider, see https://inveniordm.docs.cern.ch Invenio Provider = "invenio" ) // Options defines the configuration for this backend type Options struct { Doi string `config:"doi"` // The DOI, a digital identifier of an object, usually a dataset Provider string `config:"provider"` // The DOI provider DoiResolverAPIURL string `config:"doi_resolver_api_url"` // The URL of the DOI resolver API to use. } // Fs stores the interface to the remote HTTP files type Fs struct { name string // name of this remote root string // the path we are working on provider Provider // the DOI provider doiProvider doiProvider // the interface used to interact with the DOI provider features *fs.Features // optional features opt Options // options for this backend ci *fs.ConfigInfo // global config endpoint *url.URL // the main API endpoint for this remote endpointURL string // endpoint as a string srv *rest.Client // the connection to the server pacer *fs.Pacer // pacer for API calls cache *cache.Cache // a cache for the remote metadata } // Object is a remote object that has been stat'd (so it exists, but is not necessarily open for reading) type Object struct { fs *Fs // what this object is part of remote string // the remote path contentURL string // the URL where the contents of the file can be downloaded size int64 // size of the object modTime time.Time // modification time of the object contentType string // content type of the object md5 string // MD5 hash of the object content } // doiProvider is the interface used to list objects in a DOI type doiProvider interface { // ListEntries returns the full list of entries found at the remote, regardless of root ListEntries(ctx context.Context) (entries []*Object, err error) } // Parse the input string as a DOI // Examples: // 10.1000/182 -> 10.1000/182 // https://doi.org/10.1000/182 -> 10.1000/182 // doi:10.1000/182 -> 10.1000/182 func parseDoi(doi string) string { doiURL, err := url.Parse(doi) if err != nil { return doi } if doiURL.Scheme == "doi" { return strings.TrimLeft(strings.TrimPrefix(doi, "doi:"), "/") } if strings.HasSuffix(doiURL.Hostname(), "doi.org") { return strings.TrimLeft(doiURL.Path, "/") } return doi } // Resolve a DOI to a URL // Reference: https://www.doi.org/the-identifier/resources/factsheets/doi-resolution-documentation func resolveDoiURL(ctx context.Context, srv *rest.Client, pacer *fs.Pacer, opt *Options) (doiURL *url.URL, err error) { resolverURL := opt.DoiResolverAPIURL if resolverURL == "" { resolverURL = doiResolverAPIURL } var result api.DoiResolverResponse params := url.Values{} params.Add("index", "1") opts := rest.Opts{ Method: "GET", RootURL: resolverURL, Path: "/handles/" + opt.Doi, Parameters: params, } err = pacer.Call(func() (bool, error) { res, err := srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, res, err) }) if err != nil { return nil, err } if result.ResponseCode != 1 { return nil, fmt.Errorf("could not resolve DOI (error code %d)", result.ResponseCode) } resolvedURLStr := "" for _, value := range result.Values { if value.Type == "URL" && value.Data.Format == "string" { valueStr, ok := value.Data.Value.(string) if !ok { return nil, fmt.Errorf("could not resolve DOI (incorrect response format)") } resolvedURLStr = valueStr } } resolvedURL, err := url.Parse(resolvedURLStr) if err != nil { return nil, err } return resolvedURL, nil } // Resolve the passed configuration into a provider and enpoint func resolveEndpoint(ctx context.Context, srv *rest.Client, pacer *fs.Pacer, opt *Options) (provider Provider, endpoint *url.URL, err error) { resolvedURL, err := resolveDoiURL(ctx, srv, pacer, opt) if err != nil { return "", nil, err } switch opt.Provider { case string(Dataverse): return resolveDataverseEndpoint(resolvedURL) case string(Invenio): return resolveInvenioEndpoint(ctx, srv, pacer, resolvedURL) case string(Zenodo): return resolveZenodoEndpoint(ctx, srv, pacer, resolvedURL, opt.Doi) } hostname := strings.ToLower(resolvedURL.Hostname()) if hostname == "dataverse.harvard.edu" || activateDataverse(resolvedURL) { return resolveDataverseEndpoint(resolvedURL) } if hostname == "zenodo.org" || strings.HasSuffix(hostname, ".zenodo.org") { return resolveZenodoEndpoint(ctx, srv, pacer, resolvedURL, opt.Doi) } if activateInvenio(ctx, srv, pacer, resolvedURL) { return resolveInvenioEndpoint(ctx, srv, pacer, resolvedURL) } return "", nil, fmt.Errorf("provider '%s' is not supported", resolvedURL.Hostname()) } // Make the http connection from the passed options func (f *Fs) httpConnection(ctx context.Context, opt *Options) (isFile bool, err error) { provider, endpoint, err := resolveEndpoint(ctx, f.srv, f.pacer, opt) if err != nil { return false, err } // Update f with the new parameters f.srv.SetRoot(endpoint.ResolveReference(&url.URL{Path: "/"}).String()) f.endpoint = endpoint f.endpointURL = endpoint.String() f.provider = provider f.opt.Provider = string(provider) switch f.provider { case Dataverse: f.doiProvider = newDataverseProvider(f) case Invenio, Zenodo: f.doiProvider = newInvenioProvider(f) default: return false, fmt.Errorf("provider type '%s' not supported", f.provider) } // Determine if the root is a file entries, err := f.doiProvider.ListEntries(ctx) if err != nil { return false, err } for _, entry := range entries { if entry.remote == f.root { isFile = true break } } return isFile, nil } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 429, // Too Many Requests. 500, // Internal Server Error 502, // Bad Gateway 503, // Service Unavailable 504, // Gateway Timeout 509, // Bandwidth Limit Exceeded } // shouldRetry returns a boolean as to whether this res and err // deserve to be retried. It returns the err as a convenience. func shouldRetry(ctx context.Context, res *http.Response, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } return fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(res, retryErrorCodes), err } // NewFs creates a new Fs object from the name and root. It connects to // the host specified in the config file. func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { root = strings.Trim(root, "/") // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } opt.Doi = parseDoi(opt.Doi) client := fshttp.NewClient(ctx) ci := fs.GetConfig(ctx) f := &Fs{ name: name, root: root, opt: *opt, ci: ci, srv: rest.NewClient(client), pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), cache: cache.New(), } f.features = (&fs.Features{ CanHaveEmptyDirectories: true, }).Fill(ctx, f) isFile, err := f.httpConnection(ctx, opt) if err != nil { return nil, err } if isFile { // return an error with an fs which points to the parent newRoot := path.Dir(f.root) if newRoot == "." { newRoot = "" } f.root = newRoot return f, fs.ErrorIsFile } return f, nil } // Name returns the configured name of the file system func (f *Fs) Name() string { return f.name } // Root returns the root for the filesystem func (f *Fs) Root() string { return f.root } // String returns the URL for the filesystem func (f *Fs) String() string { return fmt.Sprintf("DOI %s", f.opt.Doi) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // Precision is the remote http file system's modtime precision, which we have no way of knowing. We estimate at 1s func (f *Fs) Precision() time.Duration { return time.Second } // Hashes returns hash.HashNone to indicate remote hashing is unavailable func (f *Fs) Hashes() hash.Set { return hash.Set(hash.MD5) // return hash.Set(hash.None) } // Mkdir makes the root directory of the Fs object func (f *Fs) Mkdir(ctx context.Context, dir string) error { return errorReadOnly } // Remove a remote http file object func (o *Object) Remove(ctx context.Context) error { return errorReadOnly } // Rmdir removes the root directory of the Fs object func (f *Fs) Rmdir(ctx context.Context, dir string) error { return errorReadOnly } // NewObject creates a new remote http file object func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { entries, err := f.doiProvider.ListEntries(ctx) if err != nil { return nil, err } remoteFullPath := remote if f.root != "" { remoteFullPath = path.Join(f.root, remote) } for _, entry := range entries { if entry.Remote() == remoteFullPath { return entry, nil } } return nil, fs.ErrorObjectNotFound } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { fileEntries, err := f.doiProvider.ListEntries(ctx) if err != nil { return nil, fmt.Errorf("error listing %q: %w", dir, err) } fullDir := path.Join(f.root, dir) if fullDir != "" { fullDir += "/" } dirPaths := map[string]bool{} for _, entry := range fileEntries { // First, filter out files not in `fullDir` if !strings.HasPrefix(entry.remote, fullDir) { continue } // Then, find entries in subfolers remotePath := entry.remote if fullDir != "" { remotePath = strings.TrimLeft(strings.TrimPrefix(remotePath, fullDir), "/") } parts := strings.SplitN(remotePath, "/", 2) if len(parts) == 1 { newEntry := *entry newEntry.remote = path.Join(dir, remotePath) entries = append(entries, &newEntry) } else { dirPaths[path.Join(dir, parts[0])] = true } } for dirPath := range dirPaths { entry := fs.NewDir(dirPath, time.Time{}) entries = append(entries, entry) } return entries, nil } // Put in to the remote path with the modTime given of the given size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return nil, errorReadOnly } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return nil, errorReadOnly } // Fs is the filesystem this remote http file object is located within func (o *Object) Fs() fs.Info { return o.fs } // String returns the URL to the remote HTTP file func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote the name of the remote HTTP file, relative to the fs root func (o *Object) Remote() string { return o.remote } // Hash returns "" since HTTP (in Go or OpenSSH) doesn't support remote calculation of hashes func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if t != hash.MD5 { return "", hash.ErrUnsupported } return o.md5, nil } // Size returns the size in bytes of the remote http file func (o *Object) Size() int64 { return o.size } // ModTime returns the modification time of the remote http file func (o *Object) ModTime(ctx context.Context) time.Time { return o.modTime } // SetModTime sets the modification and access time to the specified time // // it also updates the info field func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { return errorReadOnly } // Storable returns whether the remote http file is a regular file (not a directory, symbolic link, block device, character device, named pipe, etc.) func (o *Object) Storable() bool { return true } // Open a remote http file object for reading. Seek is supported func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { fs.FixRangeOption(options, o.size) opts := rest.Opts{ Method: "GET", RootURL: o.contentURL, Options: options, } var res *http.Response err = o.fs.pacer.Call(func() (bool, error) { res, err = o.fs.srv.Call(ctx, &opts) return shouldRetry(ctx, res, err) }) if err != nil { return nil, fmt.Errorf("Open failed: %w", err) } // Handle non-compliant redirects if res.Header.Get("Location") != "" { newURL, err := res.Location() if err == nil { opts.RootURL = newURL.String() err = o.fs.pacer.Call(func() (bool, error) { res, err = o.fs.srv.Call(ctx, &opts) return shouldRetry(ctx, res, err) }) if err != nil { return nil, fmt.Errorf("Open failed: %w", err) } } } return res.Body, nil } // Update in to the object with the modTime given of the given size func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { return errorReadOnly } // MimeType of an Object if known, "" otherwise func (o *Object) MimeType(ctx context.Context) string { return o.contentType } var commandHelp = []fs.CommandHelp{{ Name: "metadata", Short: "Show metadata about the DOI.", Long: `This command returns a JSON object with some information about the DOI. rclone backend medatadata doi: It returns a JSON object representing metadata about the DOI. `, }, { Name: "set", Short: "Set command for updating the config parameters.", Long: `This set command can be used to update the config parameters for a running doi backend. Usage Examples: rclone backend set doi: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=doi: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=doi: -o doi=NEW_DOI The option keys are named as they are in the config file. This rebuilds the connection to the doi backend when it is called with the new parameters. Only new parameters need be passed as the values will default to those currently in use. It doesn't return anything. `, }} // Command the backend to run a named command // // The command run is name // args may be used to read arguments from // opts may be used to read optional arguments from // // The result should be capable of being JSON encoded // If it is a string or a []string it will be shown to the user // otherwise it will be JSON encoded and shown to the user like that func (f *Fs) Command(ctx context.Context, name string, arg []string, opt map[string]string) (out interface{}, err error) { switch name { case "metadata": return f.ShowMetadata(ctx) case "set": newOpt := f.opt err := configstruct.Set(configmap.Simple(opt), &newOpt) if err != nil { return nil, fmt.Errorf("reading config: %w", err) } _, err = f.httpConnection(ctx, &newOpt) if err != nil { return nil, fmt.Errorf("updating session: %w", err) } f.opt = newOpt keys := []string{} for k := range opt { keys = append(keys, k) } fs.Logf(f, "Updated config values: %s", strings.Join(keys, ", ")) return nil, nil default: return nil, fs.ErrorCommandNotFound } } // ShowMetadata returns some metadata about the corresponding DOI func (f *Fs) ShowMetadata(ctx context.Context) (metadata interface{}, err error) { doiURL, err := url.Parse("https://doi.org/" + f.opt.Doi) if err != nil { return nil, err } info := map[string]any{} info["DOI"] = f.opt.Doi info["URL"] = doiURL.String() info["metadataURL"] = f.endpointURL info["provider"] = f.provider return info, nil } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.Commander = (*Fs)(nil) _ fs.Object = (*Object)(nil) _ fs.MimeTyper = (*Object)(nil) ) rclone-v1.71.0/backend/doi/doi_internal_test.go000066400000000000000000000162461505210326400214560ustar00rootroot00000000000000package doi import ( "context" "crypto/md5" "encoding/hex" "encoding/json" "io" "net/http" "net/http/httptest" "net/url" "sort" "strings" "testing" "time" "github.com/rclone/rclone/backend/doi/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/hash" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var remoteName = "TestDoi" func TestParseDoi(t *testing.T) { // 10.1000/182 -> 10.1000/182 doi := "10.1000/182" parsed := parseDoi(doi) assert.Equal(t, "10.1000/182", parsed) // https://doi.org/10.1000/182 -> 10.1000/182 doi = "https://doi.org/10.1000/182" parsed = parseDoi(doi) assert.Equal(t, "10.1000/182", parsed) // https://dx.doi.org/10.1000/182 -> 10.1000/182 doi = "https://dxdoi.org/10.1000/182" parsed = parseDoi(doi) assert.Equal(t, "10.1000/182", parsed) // doi:10.1000/182 -> 10.1000/182 doi = "doi:10.1000/182" parsed = parseDoi(doi) assert.Equal(t, "10.1000/182", parsed) // doi://10.1000/182 -> 10.1000/182 doi = "doi://10.1000/182" parsed = parseDoi(doi) assert.Equal(t, "10.1000/182", parsed) } // prepareMockDoiResolverServer prepares a test server to resolve DOIs func prepareMockDoiResolverServer(t *testing.T, resolvedURL string) (doiResolverAPIURL string) { mux := http.NewServeMux() // Handle requests for resolving DOIs mux.HandleFunc("GET /api/handles/{handle...}", func(w http.ResponseWriter, r *http.Request) { // Check that we are resolving a DOI handle := strings.TrimPrefix(r.URL.Path, "/api/handles/") assert.NotEmpty(t, handle) index := r.URL.Query().Get("index") assert.Equal(t, "1", index) // Return the most basic response result := api.DoiResolverResponse{ ResponseCode: 1, Handle: handle, Values: []api.DoiResolverResponseValue{ { Index: 1, Type: "URL", Data: api.DoiResolverResponseValueData{ Format: "string", Value: resolvedURL, }, }, }, } resultBytes, err := json.Marshal(result) require.NoError(t, err) w.Header().Add("Content-Type", "application/json") _, err = w.Write(resultBytes) require.NoError(t, err) }) // Make the test server ts := httptest.NewServer(mux) // Close the server at the end of the test t.Cleanup(ts.Close) return ts.URL + "/api" } func md5Sum(text string) string { hash := md5.Sum([]byte(text)) return hex.EncodeToString(hash[:]) } // prepareMockZenodoServer prepares a test server that mocks Zenodo.org func prepareMockZenodoServer(t *testing.T, files map[string]string) *httptest.Server { mux := http.NewServeMux() // Handle requests for a single record mux.HandleFunc("GET /api/records/{recordID...}", func(w http.ResponseWriter, r *http.Request) { // Check that we are returning data about a single record recordID := strings.TrimPrefix(r.URL.Path, "/api/records/") assert.NotEmpty(t, recordID) // Return the most basic response selfURL, err := url.Parse("http://" + r.Host) require.NoError(t, err) selfURL = selfURL.JoinPath(r.URL.String()) result := api.InvenioRecordResponse{ Links: api.InvenioRecordResponseLinks{ Self: selfURL.String(), }, } resultBytes, err := json.Marshal(result) require.NoError(t, err) w.Header().Add("Content-Type", "application/json") _, err = w.Write(resultBytes) require.NoError(t, err) }) // Handle requests for listing files in a record mux.HandleFunc("GET /api/records/{record}/files", func(w http.ResponseWriter, r *http.Request) { // Return the most basic response filesBaseURL, err := url.Parse("http://" + r.Host) require.NoError(t, err) filesBaseURL = filesBaseURL.JoinPath("/api/files/") entries := []api.InvenioFilesResponseEntry{} for filename, contents := range files { entries = append(entries, api.InvenioFilesResponseEntry{ Key: filename, Checksum: md5Sum(contents), Size: int64(len(contents)), Updated: time.Now().UTC().Format(time.RFC3339), MimeType: "text/plain; charset=utf-8", Links: api.InvenioFilesResponseEntryLinks{ Content: filesBaseURL.JoinPath(filename).String(), }, }, ) } result := api.InvenioFilesResponse{ Entries: entries, } resultBytes, err := json.Marshal(result) require.NoError(t, err) w.Header().Add("Content-Type", "application/json") _, err = w.Write(resultBytes) require.NoError(t, err) }) // Handle requests for file contents mux.HandleFunc("/api/files/{file}", func(w http.ResponseWriter, r *http.Request) { // Check that we are returning the contents of a file filename := strings.TrimPrefix(r.URL.Path, "/api/files/") assert.NotEmpty(t, filename) contents, found := files[filename] if !found { w.WriteHeader(404) return } // Return the most basic response _, err := w.Write([]byte(contents)) require.NoError(t, err) }) // Make the test server ts := httptest.NewServer(mux) // Close the server at the end of the test t.Cleanup(ts.Close) return ts } func TestZenodoRemote(t *testing.T) { recordID := "2600782" doi := "10.5281/zenodo.2600782" // The files in the dataset files := map[string]string{ "README.md": "This is a dataset.", "data.txt": "Some data", } ts := prepareMockZenodoServer(t, files) resolvedURL := ts.URL + "/record/" + recordID doiResolverAPIURL := prepareMockDoiResolverServer(t, resolvedURL) testConfig := configmap.Simple{ "type": "doi", "doi": doi, "provider": "zenodo", "doi_resolver_api_url": doiResolverAPIURL, } f, err := NewFs(context.Background(), remoteName, "", testConfig) require.NoError(t, err) // Test listing the DOI files entries, err := f.List(context.Background(), "") require.NoError(t, err) sort.Sort(entries) require.Equal(t, len(files), len(entries)) e := entries[0] assert.Equal(t, "README.md", e.Remote()) assert.Equal(t, int64(18), e.Size()) _, ok := e.(*Object) assert.True(t, ok) e = entries[1] assert.Equal(t, "data.txt", e.Remote()) assert.Equal(t, int64(9), e.Size()) _, ok = e.(*Object) assert.True(t, ok) // Test reading the DOI files o, err := f.NewObject(context.Background(), "README.md") require.NoError(t, err) assert.Equal(t, int64(18), o.Size()) md5Hash, err := o.Hash(context.Background(), hash.MD5) require.NoError(t, err) assert.Equal(t, "464352b1cab5240e44528a56fda33d9d", md5Hash) fd, err := o.Open(context.Background()) require.NoError(t, err) data, err := io.ReadAll(fd) require.NoError(t, err) require.NoError(t, fd.Close()) assert.Equal(t, []byte(files["README.md"]), data) do, ok := o.(fs.MimeTyper) require.True(t, ok) assert.Equal(t, "text/plain; charset=utf-8", do.MimeType(context.Background())) o, err = f.NewObject(context.Background(), "data.txt") require.NoError(t, err) assert.Equal(t, int64(9), o.Size()) md5Hash, err = o.Hash(context.Background(), hash.MD5) require.NoError(t, err) assert.Equal(t, "5b82f8bf4df2bfb0e66ccaa7306fd024", md5Hash) fd, err = o.Open(context.Background()) require.NoError(t, err) data, err = io.ReadAll(fd) require.NoError(t, err) require.NoError(t, fd.Close()) assert.Equal(t, []byte(files["data.txt"]), data) do, ok = o.(fs.MimeTyper) require.True(t, ok) assert.Equal(t, "text/plain; charset=utf-8", do.MimeType(context.Background())) } rclone-v1.71.0/backend/doi/doi_test.go000066400000000000000000000004571505210326400175570ustar00rootroot00000000000000// Test DOI filesystem interface package doi import ( "testing" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestDoi:", NilObject: (*Object)(nil), }) } rclone-v1.71.0/backend/doi/invenio.go000066400000000000000000000110311505210326400174020ustar00rootroot00000000000000// Implementation for InvenioRDM package doi import ( "context" "fmt" "net/http" "net/url" "regexp" "strings" "time" "github.com/rclone/rclone/backend/doi/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/lib/rest" ) var invenioRecordRegex = regexp.MustCompile(`\/records?\/(.+)`) // Returns true if resolvedURL is likely a DOI hosted on an InvenioRDM intallation func activateInvenio(ctx context.Context, srv *rest.Client, pacer *fs.Pacer, resolvedURL *url.URL) (isActive bool) { _, _, err := resolveInvenioEndpoint(ctx, srv, pacer, resolvedURL) return err == nil } // Resolve the main API endpoint for a DOI hosted on an InvenioRDM installation func resolveInvenioEndpoint(ctx context.Context, srv *rest.Client, pacer *fs.Pacer, resolvedURL *url.URL) (provider Provider, endpoint *url.URL, err error) { var res *http.Response opts := rest.Opts{ Method: "GET", RootURL: resolvedURL.String(), } err = pacer.Call(func() (bool, error) { res, err = srv.Call(ctx, &opts) return shouldRetry(ctx, res, err) }) if err != nil { return "", nil, err } // First, attempt to grab the API URL from the headers var linksetURL *url.URL links := parseLinkHeader(res.Header.Get("Link")) for _, link := range links { if link.Rel == "linkset" && link.Type == "application/linkset+json" { parsed, err := url.Parse(link.Href) if err == nil { linksetURL = parsed break } } } if linksetURL != nil { endpoint, err = checkInvenioAPIURL(ctx, srv, pacer, linksetURL) if err == nil { return Invenio, endpoint, nil } fs.Logf(nil, "using linkset URL failed: %s", err.Error()) } // If there is no linkset header, try to grab the record ID from the URL recordID := "" resURL := res.Request.URL match := invenioRecordRegex.FindStringSubmatch(resURL.EscapedPath()) if match != nil { recordID = match[1] guessedURL := res.Request.URL.ResolveReference(&url.URL{ Path: "/api/records/" + recordID, }) endpoint, err = checkInvenioAPIURL(ctx, srv, pacer, guessedURL) if err == nil { return Invenio, endpoint, nil } fs.Logf(nil, "guessing the URL failed: %s", err.Error()) } return "", nil, fmt.Errorf("could not resolve the Invenio API endpoint for '%s'", resolvedURL.String()) } func checkInvenioAPIURL(ctx context.Context, srv *rest.Client, pacer *fs.Pacer, resolvedURL *url.URL) (endpoint *url.URL, err error) { var result api.InvenioRecordResponse opts := rest.Opts{ Method: "GET", RootURL: resolvedURL.String(), } err = pacer.Call(func() (bool, error) { res, err := srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, res, err) }) if err != nil { return nil, err } if result.Links.Self == "" { return nil, fmt.Errorf("could not parse API response from '%s'", resolvedURL.String()) } return url.Parse(result.Links.Self) } // invenioProvider implements the doiProvider interface for InvenioRDM installations type invenioProvider struct { f *Fs } // ListEntries returns the full list of entries found at the remote, regardless of root func (ip *invenioProvider) ListEntries(ctx context.Context) (entries []*Object, err error) { // Use the cache if populated cachedEntries, found := ip.f.cache.GetMaybe("files") if found { parsedEntries, ok := cachedEntries.([]Object) if ok { for _, entry := range parsedEntries { newEntry := entry entries = append(entries, &newEntry) } return entries, nil } } filesURL := ip.f.endpoint.JoinPath("files") var result api.InvenioFilesResponse opts := rest.Opts{ Method: "GET", Path: strings.TrimLeft(filesURL.EscapedPath(), "/"), } err = ip.f.pacer.Call(func() (bool, error) { res, err := ip.f.srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, res, err) }) if err != nil { return nil, fmt.Errorf("readDir failed: %w", err) } for _, file := range result.Entries { modTime, modTimeErr := time.Parse(time.RFC3339, file.Updated) if modTimeErr != nil { fs.Logf(ip.f, "error: could not parse last update time %v", modTimeErr) modTime = timeUnset } entry := &Object{ fs: ip.f, remote: file.Key, contentURL: file.Links.Content, size: file.Size, modTime: modTime, contentType: file.MimeType, md5: strings.TrimPrefix(file.Checksum, "md5:"), } entries = append(entries, entry) } // Populate the cache cacheEntries := []Object{} for _, entry := range entries { cacheEntries = append(cacheEntries, *entry) } ip.f.cache.Put("files", cacheEntries) return entries, nil } func newInvenioProvider(f *Fs) doiProvider { return &invenioProvider{ f: f, } } rclone-v1.71.0/backend/doi/link_header.go000066400000000000000000000030431505210326400202040ustar00rootroot00000000000000package doi import ( "regexp" "strings" ) var linkRegex = regexp.MustCompile(`^<(.+)>$`) var valueRegex = regexp.MustCompile(`^"(.+)"$`) // headerLink represents a link as presented in HTTP headers // MDN Reference: https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Link type headerLink struct { Href string Rel string Type string Extras map[string]string } func parseLinkHeader(header string) (links []headerLink) { for _, link := range strings.Split(header, ",") { link = strings.TrimSpace(link) parsed := parseLink(link) if parsed != nil { links = append(links, *parsed) } } return links } func parseLink(link string) (parsedLink *headerLink) { var parts []string for _, part := range strings.Split(link, ";") { parts = append(parts, strings.TrimSpace(part)) } match := linkRegex.FindStringSubmatch(parts[0]) if match == nil { return nil } result := &headerLink{ Href: match[1], Extras: map[string]string{}, } for _, keyValue := range parts[1:] { parsed := parseKeyValue(keyValue) if parsed != nil { key, value := parsed[0], parsed[1] switch strings.ToLower(key) { case "rel": result.Rel = value case "type": result.Type = value default: result.Extras[key] = value } } } return result } func parseKeyValue(keyValue string) []string { parts := strings.SplitN(keyValue, "=", 2) if parts[0] == "" || len(parts) < 2 { return nil } match := valueRegex.FindStringSubmatch(parts[1]) if match != nil { parts[1] = match[1] return parts } return parts } rclone-v1.71.0/backend/doi/link_header_internal_test.go000066400000000000000000000024061505210326400231410ustar00rootroot00000000000000package doi import ( "testing" "github.com/stretchr/testify/assert" ) func TestParseLinkHeader(t *testing.T) { header := " ; rel=\"linkset\" ; type=\"application/linkset+json\"" links := parseLinkHeader(header) expected := headerLink{ Href: "https://zenodo.org/api/records/15063252", Rel: "linkset", Type: "application/linkset+json", Extras: map[string]string{}, } assert.Contains(t, links, expected) header = "; rel=\"prev\", ; rel=\"next\", ; rel=\"last\", ; rel=\"first\"" links = parseLinkHeader(header) expectedList := []headerLink{{ Href: "https://api.example.com/issues?page=2", Rel: "prev", Type: "", Extras: map[string]string{}, }, { Href: "https://api.example.com/issues?page=4", Rel: "next", Type: "", Extras: map[string]string{}, }, { Href: "https://api.example.com/issues?page=10", Rel: "last", Type: "", Extras: map[string]string{}, }, { Href: "https://api.example.com/issues?page=1", Rel: "first", Type: "", Extras: map[string]string{}, }} assert.Equal(t, links, expectedList) } rclone-v1.71.0/backend/doi/zenodo.go000066400000000000000000000022561505210326400172420ustar00rootroot00000000000000// Implementation for Zenodo package doi import ( "context" "fmt" "net/url" "regexp" "github.com/rclone/rclone/backend/doi/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/lib/rest" ) var zenodoRecordRegex = regexp.MustCompile(`zenodo[.](.+)`) // Resolve the main API endpoint for a DOI hosted on Zenodo func resolveZenodoEndpoint(ctx context.Context, srv *rest.Client, pacer *fs.Pacer, resolvedURL *url.URL, doi string) (provider Provider, endpoint *url.URL, err error) { match := zenodoRecordRegex.FindStringSubmatch(doi) if match == nil { return "", nil, fmt.Errorf("could not derive API endpoint URL from '%s'", resolvedURL.String()) } recordID := match[1] endpointURL := resolvedURL.ResolveReference(&url.URL{Path: "/api/records/" + recordID}) var result api.InvenioRecordResponse opts := rest.Opts{ Method: "GET", RootURL: endpointURL.String(), } err = pacer.Call(func() (bool, error) { res, err := srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, res, err) }) if err != nil { return "", nil, err } endpointURL, err = url.Parse(result.Links.Self) if err != nil { return "", nil, err } return Zenodo, endpointURL, nil } rclone-v1.71.0/backend/drive/000077500000000000000000000000001505210326400157465ustar00rootroot00000000000000rclone-v1.71.0/backend/drive/drive.go000066400000000000000000004324431505210326400174200ustar00rootroot00000000000000// Package drive interfaces with the Google Drive object storage system package drive // FIXME need to deal with some corner cases // * multiple files with the same name // * files can be in multiple directories // * can have directory loops // * files with / in name import ( "bytes" "context" "crypto/tls" "errors" "fmt" "io" "mime" "net/http" "os" "path" "slices" "sort" "strconv" "strings" "sync" "sync/atomic" "text/template" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/fspath" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/lib/dircache" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/env" "github.com/rclone/rclone/lib/oauthutil" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/readers" "golang.org/x/oauth2" "golang.org/x/oauth2/google" drive_v2 "google.golang.org/api/drive/v2" drive "google.golang.org/api/drive/v3" "google.golang.org/api/googleapi" "google.golang.org/api/option" ) // Constants const ( rcloneClientID = "202264815644.apps.googleusercontent.com" rcloneEncryptedClientSecret = "eX8GpZTVx3vxMWVkuuBdDWmAUE6rGhTwVrvG9GhllYccSdj2-mvHVg" driveFolderType = "application/vnd.google-apps.folder" shortcutMimeType = "application/vnd.google-apps.shortcut" shortcutMimeTypeDangling = "application/vnd.google-apps.shortcut.dangling" // synthetic mime type for internal use timeFormatIn = time.RFC3339 timeFormatOut = "2006-01-02T15:04:05.000000000Z07:00" defaultMinSleep = fs.Duration(100 * time.Millisecond) defaultBurst = 100 defaultExportExtensions = "docx,xlsx,pptx,svg" scopePrefix = "https://www.googleapis.com/auth/" defaultScope = "drive" // chunkSize is the size of the chunks created during a resumable upload and should be a power of two. // 1<<18 is the minimum size supported by the Google uploader, and there is no maximum. minChunkSize = fs.SizeSuffix(googleapi.MinUploadChunkSize) defaultChunkSize = 8 * fs.Mebi partialFields = "id,name,size,md5Checksum,sha1Checksum,sha256Checksum,trashed,explicitlyTrashed,modifiedTime,createdTime,mimeType,parents,webViewLink,shortcutDetails,exportLinks,resourceKey" listRGrouping = 50 // number of IDs to search at once when using ListR listRInputBuffer = 1000 // size of input buffer when using ListR defaultXDGIcon = "text-html" ) // Globals var ( // Description of how to auth for this app driveConfig = &oauthutil.Config{ Scopes: []string{scopePrefix + "drive"}, AuthURL: google.Endpoint.AuthURL, TokenURL: google.Endpoint.TokenURL, ClientID: rcloneClientID, ClientSecret: obscure.MustReveal(rcloneEncryptedClientSecret), RedirectURL: oauthutil.RedirectURL, } _mimeTypeToExtensionDuplicates = map[string]string{ "application/x-vnd.oasis.opendocument.presentation": ".odp", "application/x-vnd.oasis.opendocument.spreadsheet": ".ods", "application/x-vnd.oasis.opendocument.text": ".odt", "image/jpg": ".jpg", "image/x-bmp": ".bmp", "image/x-png": ".png", "text/rtf": ".rtf", } _mimeTypeToExtension = map[string]string{ "application/epub+zip": ".epub", "application/json": ".json", "application/msword": ".doc", "application/pdf": ".pdf", "application/rtf": ".rtf", "application/vnd.ms-excel": ".xls", "application/vnd.oasis.opendocument.presentation": ".odp", "application/vnd.oasis.opendocument.spreadsheet": ".ods", "application/vnd.oasis.opendocument.text": ".odt", "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx", "application/x-msmetafile": ".wmf", "application/zip": ".zip", "image/bmp": ".bmp", "image/jpeg": ".jpg", "image/pjpeg": ".pjpeg", "image/png": ".png", "image/svg+xml": ".svg", "text/csv": ".csv", "text/html": ".html", "text/plain": ".txt", "text/tab-separated-values": ".tsv", "text/markdown": ".md", } _mimeTypeToExtensionLinks = map[string]string{ "application/x-link-desktop": ".desktop", "application/x-link-html": ".link.html", "application/x-link-url": ".url", "application/x-link-webloc": ".webloc", } _mimeTypeCustomTransform = map[string]string{ "application/vnd.google-apps.script+json": "application/json", } _mimeTypeToXDGLinkIcons = map[string]string{ "application/vnd.google-apps.document": "x-office-document", "application/vnd.google-apps.drawing": "x-office-drawing", "application/vnd.google-apps.presentation": "x-office-presentation", "application/vnd.google-apps.spreadsheet": "x-office-spreadsheet", } fetchFormatsOnce sync.Once // make sure we fetch the export/import formats only once _exportFormats map[string][]string // allowed export MIME type conversions _importFormats map[string][]string // allowed import MIME type conversions templatesOnce sync.Once // parse link templates only once _linkTemplates map[string]*template.Template // available link types ) // rwChoices type for fs.Bits type rwChoices struct{} func (rwChoices) Choices() []fs.BitsChoicesInfo { return []fs.BitsChoicesInfo{ {Bit: uint64(rwOff), Name: "off"}, {Bit: uint64(rwRead), Name: "read"}, {Bit: uint64(rwWrite), Name: "write"}, {Bit: uint64(rwFailOK), Name: "failok"}, } } // rwChoice type alias type rwChoice = fs.Bits[rwChoices] const ( rwRead rwChoice = 1 << iota rwWrite rwFailOK rwOff rwChoice = 0 ) // Examples for the options var rwExamples = fs.OptionExamples{{ Value: rwOff.String(), Help: "Do not read or write the value", }, { Value: rwRead.String(), Help: "Read the value only", }, { Value: rwWrite.String(), Help: "Write the value only", }, { Value: rwFailOK.String(), Help: "If writing fails log errors only, don't fail the transfer", }, { Value: (rwRead | rwWrite).String(), Help: "Read and Write the value.", }} // Parse the scopes option returning a slice of scopes func driveScopes(scopesString string) (scopes []string) { if scopesString == "" { scopesString = defaultScope } for _, scope := range strings.Split(scopesString, ",") { scope = strings.TrimSpace(scope) scopes = append(scopes, scopePrefix+scope) } return scopes } // Returns true if one of the scopes was "drive.appfolder" func driveScopesContainsAppFolder(scopes []string) bool { return slices.Contains(scopes, scopePrefix+"drive.appfolder") } func driveOAuthOptions() []fs.Option { opts := []fs.Option{} for _, opt := range oauthutil.SharedOptions { if opt.Name == config.ConfigClientID { opt.Help = "Google Application Client Id\nSetting your own is recommended.\nSee https://rclone.org/drive/#making-your-own-client-id for how to create your own.\nIf you leave this blank, it will use an internal key which is low performance." } opts = append(opts, opt) } return opts } // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "drive", Description: "Google Drive", NewFs: NewFs, CommandHelp: commandHelp, Config: func(ctx context.Context, name string, m configmap.Mapper, config fs.ConfigIn) (*fs.ConfigOut, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, fmt.Errorf("couldn't parse config into struct: %w", err) } switch config.State { case "": // Fill in the scopes driveConfig.Scopes = driveScopes(opt.Scope) // Set the root_folder_id if using drive.appfolder if driveScopesContainsAppFolder(driveConfig.Scopes) { m.Set("root_folder_id", "appDataFolder") } if opt.ServiceAccountFile == "" && opt.ServiceAccountCredentials == "" && !opt.EnvAuth { return oauthutil.ConfigOut("teamdrive", &oauthutil.Options{ OAuth2Config: driveConfig, }) } return fs.ConfigGoto("teamdrive") case "teamdrive": if opt.TeamDriveID == "" { return fs.ConfigConfirm("teamdrive_ok", false, "config_change_team_drive", "Configure this as a Shared Drive (Team Drive)?\n") } return fs.ConfigConfirm("teamdrive_change", false, "config_change_team_drive", fmt.Sprintf("Change current Shared Drive (Team Drive) ID %q?\n", opt.TeamDriveID)) case "teamdrive_ok": if config.Result == "false" { m.Set("team_drive", "") return nil, nil } return fs.ConfigGoto("teamdrive_config") case "teamdrive_change": if config.Result == "false" { return nil, nil } return fs.ConfigGoto("teamdrive_config") case "teamdrive_config": f, err := newFs(ctx, name, "", m) if err != nil { return nil, fmt.Errorf("failed to make Fs to list Shared Drives: %w", err) } teamDrives, err := f.listTeamDrives(ctx) if err != nil { return nil, err } if len(teamDrives) == 0 { return fs.ConfigError("", "No Shared Drives found in your account") } return fs.ConfigChoose("teamdrive_final", "config_team_drive", "Shared Drive", len(teamDrives), func(i int) (string, string) { teamDrive := teamDrives[i] return teamDrive.Id, teamDrive.Name }) case "teamdrive_final": driveID := config.Result m.Set("team_drive", driveID) m.Set("root_folder_id", "") opt.TeamDriveID = driveID opt.RootFolderID = "" return nil, nil } return nil, fmt.Errorf("unknown state %q", config.State) }, MetadataInfo: &fs.MetadataInfo{ System: systemMetadataInfo, Help: `User metadata is stored in the properties field of the drive object. Metadata is supported on files and directories. `, }, Options: append(driveOAuthOptions(), []fs.Option{{ Name: "scope", Help: "Comma separated list of scopes that rclone should use when requesting access from drive.", Examples: []fs.OptionExample{{ Value: "drive", Help: "Full access all files, excluding Application Data Folder.", }, { Value: "drive.readonly", Help: "Read-only access to file metadata and file contents.", }, { Value: "drive.file", Help: "Access to files created by rclone only.\nThese are visible in the drive website.\nFile authorization is revoked when the user deauthorizes the app.", }, { Value: "drive.appfolder", Help: "Allows read and write access to the Application Data folder.\nThis is not visible in the drive website.", }, { Value: "drive.metadata.readonly", Help: "Allows read-only access to file metadata but\ndoes not allow any access to read or download file content.", }}, }, { Name: "root_folder_id", Help: `ID of the root folder. Leave blank normally. Fill in to access "Computers" folders (see docs), or for rclone to use a non root folder as its starting point. `, Advanced: true, Sensitive: true, }, { Name: "service_account_file", Help: "Service Account Credentials JSON file path.\n\nLeave blank normally.\nNeeded only if you want use SA instead of interactive login." + env.ShellExpandHelp, }, { Name: "service_account_credentials", Help: "Service Account Credentials JSON blob.\n\nLeave blank normally.\nNeeded only if you want use SA instead of interactive login.", Hide: fs.OptionHideConfigurator, Advanced: true, Sensitive: true, }, { Name: "team_drive", Help: "ID of the Shared Drive (Team Drive).", Hide: fs.OptionHideConfigurator, Advanced: true, Sensitive: true, }, { Name: "auth_owner_only", Default: false, Help: "Only consider files owned by the authenticated user.", Advanced: true, }, { Name: "use_trash", Default: true, Help: "Send files to the trash instead of deleting permanently.\n\nDefaults to true, namely sending files to the trash.\nUse `--drive-use-trash=false` to delete files permanently instead.", Advanced: true, }, { Name: "copy_shortcut_content", Default: false, Help: `Server side copy contents of shortcuts instead of the shortcut. When doing server side copies, normally rclone will copy shortcuts as shortcuts. If this flag is used then rclone will copy the contents of shortcuts rather than shortcuts themselves when doing server side copies.`, Advanced: true, }, { Name: "skip_gdocs", Default: false, Help: "Skip google documents in all listings.\n\nIf given, gdocs practically become invisible to rclone.", Advanced: true, }, { Name: "show_all_gdocs", Default: false, Help: `Show all Google Docs including non-exportable ones in listings. If you try a server side copy on a Google Form without this flag, you will get this error: No export formats found for "application/vnd.google-apps.form" However adding this flag will allow the form to be server side copied. Note that rclone doesn't add extensions to the Google Docs file names in this mode. Do **not** use this flag when trying to download Google Docs - rclone will fail to download them. `, Advanced: true, }, { Name: "skip_checksum_gphotos", Default: false, Help: `Skip checksums on Google photos and videos only. Use this if you get checksum errors when transferring Google photos or videos. Setting this flag will cause Google photos and videos to return a blank checksums. Google photos are identified by being in the "photos" space. Corrupted checksums are caused by Google modifying the image/video but not updating the checksum.`, Advanced: true, }, { Name: "shared_with_me", Default: false, Help: `Only show files that are shared with me. Instructs rclone to operate on your "Shared with me" folder (where Google Drive lets you access the files and folders others have shared with you). This works both with the "list" (lsd, lsl, etc.) and the "copy" commands (copy, sync, etc.), and with all other commands too.`, Advanced: true, }, { Name: "trashed_only", Default: false, Help: "Only show files that are in the trash.\n\nThis will show trashed files in their original directory structure.", Advanced: true, }, { Name: "starred_only", Default: false, Help: "Only show files that are starred.", Advanced: true, }, { Name: "formats", Default: "", Help: "Deprecated: See export_formats.", Advanced: true, Hide: fs.OptionHideConfigurator, }, { Name: "export_formats", Default: defaultExportExtensions, Help: "Comma separated list of preferred formats for downloading Google docs.", Advanced: true, }, { Name: "import_formats", Default: "", Help: "Comma separated list of preferred formats for uploading Google docs.", Advanced: true, }, { Name: "allow_import_name_change", Default: false, Help: "Allow the filetype to change when uploading Google docs.\n\nE.g. file.doc to file.docx. This will confuse sync and reupload every time.", Advanced: true, }, { Name: "use_created_date", Default: false, Help: `Use file created date instead of modified date. Useful when downloading data and you want the creation date used in place of the last modified date. **WARNING**: This flag may have some unexpected consequences. When uploading to your drive all files will be overwritten unless they haven't been modified since their creation. And the inverse will occur while downloading. This side effect can be avoided by using the "--checksum" flag. This feature was implemented to retain photos capture date as recorded by google photos. You will first need to check the "Create a Google Photos folder" option in your google drive settings. You can then copy or move the photos locally and use the date the image was taken (created) set as the modification date.`, Advanced: true, Hide: fs.OptionHideConfigurator, }, { Name: "use_shared_date", Default: false, Help: `Use date file was shared instead of modified date. Note that, as with "--drive-use-created-date", this flag may have unexpected consequences when uploading/downloading files. If both this flag and "--drive-use-created-date" are set, the created date is used.`, Advanced: true, Hide: fs.OptionHideConfigurator, }, { Name: "list_chunk", Default: 1000, Help: "Size of listing chunk 100-1000, 0 to disable.", Advanced: true, }, { Name: "impersonate", Default: "", Help: `Impersonate this user when using a service account.`, Advanced: true, Sensitive: true, }, { Name: "alternate_export", Default: false, Help: "Deprecated: No longer needed.", Hide: fs.OptionHideBoth, }, { Name: "upload_cutoff", Default: defaultChunkSize, Help: "Cutoff for switching to chunked upload.", Advanced: true, }, { Name: "chunk_size", Default: defaultChunkSize, Help: `Upload chunk size. Must a power of 2 >= 256k. Making this larger will improve performance, but note that each chunk is buffered in memory one per transfer. Reducing this will reduce memory usage but decrease performance.`, Advanced: true, }, { Name: "acknowledge_abuse", Default: false, Help: `Set to allow files which return cannotDownloadAbusiveFile to be downloaded. If downloading a file returns the error "This file has been identified as malware or spam and cannot be downloaded" with the error code "cannotDownloadAbusiveFile" then supply this flag to rclone to indicate you acknowledge the risks of downloading the file and rclone will download it anyway. Note that if you are using service account it will need Manager permission (not Content Manager) to for this flag to work. If the SA does not have the right permission, Google will just ignore the flag.`, Advanced: true, }, { Name: "keep_revision_forever", Default: false, Help: "Keep new head revision of each file forever.", Advanced: true, }, { Name: "size_as_quota", Default: false, Help: `Show sizes as storage quota usage, not actual size. Show the size of a file as the storage quota used. This is the current version plus any older versions that have been set to keep forever. **WARNING**: This flag may have some unexpected consequences. It is not recommended to set this flag in your config - the recommended usage is using the flag form --drive-size-as-quota when doing rclone ls/lsl/lsf/lsjson/etc only. If you do use this flag for syncing (not recommended) then you will need to use --ignore size also.`, Advanced: true, Hide: fs.OptionHideConfigurator, }, { Name: "v2_download_min_size", Default: fs.SizeSuffix(-1), Help: "If Object's are greater, use drive v2 API to download.", Advanced: true, }, { Name: "pacer_min_sleep", Default: defaultMinSleep, Help: "Minimum time to sleep between API calls.", Advanced: true, }, { Name: "pacer_burst", Default: defaultBurst, Help: "Number of API calls to allow without sleeping.", Advanced: true, }, { Name: "server_side_across_configs", Default: false, Help: `Deprecated: use --server-side-across-configs instead. Allow server-side operations (e.g. copy) to work across different drive configs. This can be useful if you wish to do a server-side copy between two different Google drives. Note that this isn't enabled by default because it isn't easy to tell if it will work between any two configurations.`, Advanced: true, }, { Name: "disable_http2", Default: true, Help: `Disable drive using http2. There is currently an unsolved issue with the google drive backend and HTTP/2. HTTP/2 is therefore disabled by default for the drive backend but can be re-enabled here. When the issue is solved this flag will be removed. See: https://github.com/rclone/rclone/issues/3631 `, Advanced: true, }, { Name: "stop_on_upload_limit", Default: false, Help: `Make upload limit errors be fatal. At the time of writing it is only possible to upload 750 GiB of data to Google Drive a day (this is an undocumented limit). When this limit is reached Google Drive produces a slightly different error message. When this flag is set it causes these errors to be fatal. These will stop the in-progress sync. Note that this detection is relying on error message strings which Google don't document so it may break in the future. See: https://github.com/rclone/rclone/issues/3857 `, Advanced: true, }, { Name: "stop_on_download_limit", Default: false, Help: `Make download limit errors be fatal. At the time of writing it is only possible to download 10 TiB of data from Google Drive a day (this is an undocumented limit). When this limit is reached Google Drive produces a slightly different error message. When this flag is set it causes these errors to be fatal. These will stop the in-progress sync. Note that this detection is relying on error message strings which Google don't document so it may break in the future. `, Advanced: true, }, { Name: "skip_shortcuts", Help: `If set skip shortcut files. Normally rclone dereferences shortcut files making them appear as if they are the original file (see [the shortcuts section](#shortcuts)). If this flag is set then rclone will ignore shortcut files completely. `, Advanced: true, Default: false, }, { Name: "skip_dangling_shortcuts", Help: `If set skip dangling shortcut files. If this is set then rclone will not show any dangling shortcuts in listings. `, Advanced: true, Default: false, }, { Name: "resource_key", Help: `Resource key for accessing a link-shared file. If you need to access files shared with a link like this https://drive.google.com/drive/folders/XXX?resourcekey=YYY&usp=sharing Then you will need to use the first part "XXX" as the "root_folder_id" and the second part "YYY" as the "resource_key" otherwise you will get 404 not found errors when trying to access the directory. See: https://developers.google.com/drive/api/guides/resource-keys This resource key requirement only applies to a subset of old files. Note also that opening the folder once in the web interface (with the user you've authenticated rclone with) seems to be enough so that the resource key is not needed. `, Advanced: true, Sensitive: true, }, { Name: "fast_list_bug_fix", Help: `Work around a bug in Google Drive listing. Normally rclone will work around a bug in Google Drive when using --fast-list (ListR) where the search "(A in parents) or (B in parents)" returns nothing sometimes. See #3114, #4289 and https://issuetracker.google.com/issues/149522397 Rclone detects this by finding no items in more than one directory when listing and retries them as lists of individual directories. This means that if you have a lot of empty directories rclone will end up listing them all individually and this can take many more API calls. This flag allows the work-around to be disabled. This is **not** recommended in normal use - only if you have a particular case you are having trouble with like many empty directories. `, Advanced: true, Default: true, }, { Name: "metadata_owner", Help: `Control whether owner should be read or written in metadata. Owner is a standard part of the file metadata so is easy to read. But it isn't always desirable to set the owner from the metadata. Note that you can't set the owner on Shared Drives, and that setting ownership will generate an email to the new owner (this can't be disabled), and you can't transfer ownership to someone outside your organization. `, Advanced: true, Default: rwRead, Examples: rwExamples, }, { Name: "metadata_permissions", Help: `Control whether permissions should be read or written in metadata. Reading permissions metadata from files can be done quickly, but it isn't always desirable to set the permissions from the metadata. Note that rclone drops any inherited permissions on Shared Drives and any owner permission on My Drives as these are duplicated in the owner metadata. `, Advanced: true, Default: rwOff, Examples: rwExamples, }, { Name: "metadata_labels", Help: `Control whether labels should be read or written in metadata. Reading labels metadata from files takes an extra API transaction and will slow down listings. It isn't always desirable to set the labels from the metadata. The format of labels is documented in the drive API documentation at https://developers.google.com/drive/api/reference/rest/v3/Label - rclone just provides a JSON dump of this format. When setting labels, the label and fields must already exist - rclone will not create them. This means that if you are transferring labels from two different accounts you will have to create the labels in advance and use the metadata mapper to translate the IDs between the two accounts. `, Advanced: true, Default: rwOff, Examples: rwExamples, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, // Encode invalid UTF-8 bytes as json doesn't handle them properly. // Don't encode / as it's a valid name character in drive. Default: encoder.EncodeInvalidUtf8, }, { Name: "env_auth", Help: "Get IAM credentials from runtime (environment variables or instance meta data if no env vars).\n\nOnly applies if service_account_file and service_account_credentials is blank.", Default: false, Advanced: true, Examples: []fs.OptionExample{{ Value: "false", Help: "Enter credentials in the next step.", }, { Value: "true", Help: "Get GCP IAM credentials from the environment (env vars or IAM).", }}, }}...), }) // register duplicate MIME types first // this allows them to be used with mime.ExtensionsByType() but // mime.TypeByExtension() will return the later registered MIME type for _, m := range []map[string]string{ _mimeTypeToExtensionDuplicates, _mimeTypeToExtension, _mimeTypeToExtensionLinks, } { for mimeType, extension := range m { if err := mime.AddExtensionType(extension, mimeType); err != nil { fs.Errorf("Failed to register MIME type %q: %v", mimeType, err) } } } } // Options defines the configuration for this backend type Options struct { Scope string `config:"scope"` RootFolderID string `config:"root_folder_id"` ServiceAccountFile string `config:"service_account_file"` ServiceAccountCredentials string `config:"service_account_credentials"` TeamDriveID string `config:"team_drive"` AuthOwnerOnly bool `config:"auth_owner_only"` UseTrash bool `config:"use_trash"` CopyShortcutContent bool `config:"copy_shortcut_content"` SkipGdocs bool `config:"skip_gdocs"` ShowAllGdocs bool `config:"show_all_gdocs"` SkipChecksumGphotos bool `config:"skip_checksum_gphotos"` SharedWithMe bool `config:"shared_with_me"` TrashedOnly bool `config:"trashed_only"` StarredOnly bool `config:"starred_only"` Extensions string `config:"formats"` ExportExtensions string `config:"export_formats"` ImportExtensions string `config:"import_formats"` AllowImportNameChange bool `config:"allow_import_name_change"` UseCreatedDate bool `config:"use_created_date"` UseSharedDate bool `config:"use_shared_date"` ListChunk int64 `config:"list_chunk"` Impersonate string `config:"impersonate"` UploadCutoff fs.SizeSuffix `config:"upload_cutoff"` ChunkSize fs.SizeSuffix `config:"chunk_size"` AcknowledgeAbuse bool `config:"acknowledge_abuse"` KeepRevisionForever bool `config:"keep_revision_forever"` SizeAsQuota bool `config:"size_as_quota"` V2DownloadMinSize fs.SizeSuffix `config:"v2_download_min_size"` PacerMinSleep fs.Duration `config:"pacer_min_sleep"` PacerBurst int `config:"pacer_burst"` ServerSideAcrossConfigs bool `config:"server_side_across_configs"` DisableHTTP2 bool `config:"disable_http2"` StopOnUploadLimit bool `config:"stop_on_upload_limit"` StopOnDownloadLimit bool `config:"stop_on_download_limit"` SkipShortcuts bool `config:"skip_shortcuts"` SkipDanglingShortcuts bool `config:"skip_dangling_shortcuts"` ResourceKey string `config:"resource_key"` FastListBugFix bool `config:"fast_list_bug_fix"` MetadataOwner rwChoice `config:"metadata_owner"` MetadataPermissions rwChoice `config:"metadata_permissions"` MetadataLabels rwChoice `config:"metadata_labels"` Enc encoder.MultiEncoder `config:"encoding"` EnvAuth bool `config:"env_auth"` } // Fs represents a remote drive server type Fs struct { name string // name of this remote root string // the path we are working on opt Options // parsed options ci *fs.ConfigInfo // global config features *fs.Features // optional features svc *drive.Service // the connection to the drive server v2Svc *drive_v2.Service // used to create download links for the v2 api client *http.Client // authorized client rootFolderID string // the id of the root folder dirCache *dircache.DirCache // Map of directory path to directory id lastQuery string // Last query string to check in unit tests pacer *fs.Pacer // To pace the API calls exportExtensions []string // preferred extensions to download docs importMimeTypes []string // MIME types to convert to docs isTeamDrive bool // true if this is a team drive m configmap.Mapper grouping int32 // number of IDs to search at once in ListR - read with atomic listRmu *sync.Mutex // protects listRempties listRempties map[string]struct{} // IDs of supposedly empty directories which triggered grouping disable dirResourceKeys *sync.Map // map directory ID to resource key permissionsMu *sync.Mutex // protect the below permissions map[string]*drive.Permission // map permission IDs to Permissions } type baseObject struct { fs *Fs // what this object is part of remote string // The remote path id string // Drive Id of this object modifiedDate string // RFC3339 time it was last modified mimeType string // The object MIME type bytes int64 // size of the object parents []string // IDs of the parent directories resourceKey *string // resourceKey is needed for link shared objects metadata *fs.Metadata // metadata if known } type documentObject struct { baseObject url string // Download URL of this object documentMimeType string // the original document MIME type extLen int // The length of the added export extension } type linkObject struct { baseObject content []byte // The file content generated by a link template extLen int // The length of the added export extension } // Object describes a drive object type Object struct { baseObject url string // Download URL of this object md5sum string // md5sum of the object sha1sum string // sha1sum of the object sha256sum string // sha256sum of the object v2Download bool // generate v2 download link ondemand } // Directory describes a drive directory type Directory struct { baseObject } // ------------------------------------------------------------ // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("Google drive root '%s'", f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // shouldRetry determines whether a given err rates being retried func (f *Fs) shouldRetry(ctx context.Context, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } if err == nil { return false, nil } if fserrors.ShouldRetry(err) { return true, err } switch gerr := err.(type) { case *googleapi.Error: if gerr.Code >= 500 && gerr.Code < 600 { // All 5xx errors should be retried return true, err } if len(gerr.Errors) > 0 { reason := gerr.Errors[0].Reason if reason == "rateLimitExceeded" || reason == "userRateLimitExceeded" { if f.opt.StopOnUploadLimit && gerr.Errors[0].Message == "User rate limit exceeded." { fs.Errorf(f, "Received upload limit error: %v", err) return false, fserrors.FatalError(err) } return true, err } else if f.opt.StopOnDownloadLimit && reason == "downloadQuotaExceeded" { fs.Errorf(f, "Received download limit error: %v", err) return false, fserrors.FatalError(err) } else if f.opt.StopOnUploadLimit && (reason == "quotaExceeded" || reason == "storageQuotaExceeded") { fs.Errorf(f, "Received upload limit error: %v", err) return false, fserrors.FatalError(err) } else if f.opt.StopOnUploadLimit && reason == "teamDriveFileLimitExceeded" { fs.Errorf(f, "Received Shared Drive file limit error: %v", err) return false, fserrors.FatalError(err) } } } return false, err } // parseParse parses a drive 'url' func parseDrivePath(path string) (root string, err error) { root = strings.Trim(path, "/") return } // User function to process a File item from list // // Should return true to finish processing type listFn func(*drive.File) bool func containsString(slice []string, s string) bool { return slices.Contains(slice, s) } // getFile returns drive.File for the ID passed and fields passed in func (f *Fs) getFile(ctx context.Context, ID string, fields googleapi.Field) (info *drive.File, err error) { err = f.pacer.Call(func() (bool, error) { info, err = f.svc.Files.Get(ID). Fields(fields). SupportsAllDrives(true). Context(ctx).Do() return f.shouldRetry(ctx, err) }) return info, err } // getRootID returns the canonical ID for the "root" ID func (f *Fs) getRootID(ctx context.Context) (string, error) { info, err := f.getFile(ctx, "root", "id") if err != nil { return "", fmt.Errorf("couldn't find root directory ID: %w", err) } return info.Id, nil } // Lists the directory required calling the user function on each item found // // If the user fn ever returns true then it early exits with found = true // // Search params: https://developers.google.com/drive/search-parameters func (f *Fs) list(ctx context.Context, dirIDs []string, title string, directoriesOnly, filesOnly, trashedOnly, includeAll bool, fn listFn) (found bool, err error) { var query []string if !includeAll { q := "trashed=" + strconv.FormatBool(trashedOnly) if f.opt.TrashedOnly { q = fmt.Sprintf("(mimeType='%s' or %s)", driveFolderType, q) } query = append(query, q) } // Search with sharedWithMe will always return things listed in "Shared With Me" (without any parents) // We must not filter with parent when we try list "ROOT" with drive-shared-with-me // If we need to list file inside those shared folders, we must search it without sharedWithMe parentsQuery := bytes.NewBufferString("(") var resourceKeys []string for _, dirID := range dirIDs { if dirID == "" { continue } if parentsQuery.Len() > 1 { _, _ = parentsQuery.WriteString(" or ") } if (f.opt.SharedWithMe || f.opt.StarredOnly) && dirID == f.rootFolderID { if f.opt.SharedWithMe { _, _ = parentsQuery.WriteString("sharedWithMe=true") } if f.opt.StarredOnly { if f.opt.SharedWithMe { _, _ = parentsQuery.WriteString(" and ") } _, _ = parentsQuery.WriteString("starred=true") } } else { _, _ = fmt.Fprintf(parentsQuery, "'%s' in parents", dirID) } resourceKey, hasResourceKey := f.dirResourceKeys.Load(dirID) if hasResourceKey { resourceKeys = append(resourceKeys, fmt.Sprintf("%s/%s", dirID, resourceKey)) } } resourceKeysHeader := strings.Join(resourceKeys, ",") if parentsQuery.Len() > 1 { _ = parentsQuery.WriteByte(')') query = append(query, parentsQuery.String()) } var stems []string if title != "" { searchTitle := f.opt.Enc.FromStandardName(title) // Escaping the backslash isn't documented but seems to work searchTitle = strings.ReplaceAll(searchTitle, `\`, `\\`) searchTitle = strings.ReplaceAll(searchTitle, `'`, `\'`) var titleQuery bytes.Buffer _, _ = fmt.Fprintf(&titleQuery, "(name='%s'", searchTitle) if !directoriesOnly && !f.opt.SkipGdocs { // If the search title has an extension that is in the export extensions add a search // for the filename without the extension. // Assume that export extensions don't contain escape sequences. for _, ext := range f.exportExtensions { if strings.HasSuffix(searchTitle, ext) { stems = append(stems, title[:len(title)-len(ext)]) _, _ = fmt.Fprintf(&titleQuery, " or name='%s'", searchTitle[:len(searchTitle)-len(ext)]) } } } _ = titleQuery.WriteByte(')') query = append(query, titleQuery.String()) } if directoriesOnly { query = append(query, fmt.Sprintf("(mimeType='%s' or mimeType='%s')", driveFolderType, shortcutMimeType)) } if filesOnly { query = append(query, fmt.Sprintf("mimeType!='%s'", driveFolderType)) } // Constrain query using filter if this remote is a sync/copy/walk source. if fi, use := filter.GetConfig(ctx), filter.GetUseFilter(ctx); fi != nil && use { queryByTime := func(op string, tm time.Time) { if tm.IsZero() { return } // https://developers.google.com/drive/api/v3/ref-search-terms#operators // Query times use RFC 3339 format, default timezone is UTC timeStr := tm.UTC().Format("2006-01-02T15:04:05") term := fmt.Sprintf("(modifiedTime %s '%s' or mimeType = '%s')", op, timeStr, driveFolderType) query = append(query, term) } queryByTime(">=", fi.ModTimeFrom) queryByTime("<=", fi.ModTimeTo) } list := f.svc.Files.List() queryString := strings.Join(query, " and ") if queryString != "" { list.Q(queryString) // fs.Debugf(f, "list query: %q", queryString) } f.lastQuery = queryString // for unit tests if f.opt.ListChunk > 0 { list.PageSize(f.opt.ListChunk) } list.SupportsAllDrives(true) list.IncludeItemsFromAllDrives(true) if f.isTeamDrive && !f.opt.SharedWithMe { list.DriveId(f.opt.TeamDriveID) list.Corpora("drive") } // If using appDataFolder then need to add Spaces if f.rootFolderID == "appDataFolder" { list.Spaces("appDataFolder") } // Add resource Keys if necessary if resourceKeysHeader != "" { list.Header().Add("X-Goog-Drive-Resource-Keys", resourceKeysHeader) } fields := fmt.Sprintf("files(%s),nextPageToken,incompleteSearch", f.getFileFields(ctx)) OUTER: for { var files *drive.FileList err = f.pacer.Call(func() (bool, error) { files, err = list.Fields(googleapi.Field(fields)).Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return false, fmt.Errorf("couldn't list directory: %w", err) } if files.IncompleteSearch { fs.Errorf(f, "search result INCOMPLETE") } for _, item := range files.Files { item.Name = f.opt.Enc.ToStandardName(item.Name) if isShortcut(item) { // ignore shortcuts if directed if f.opt.SkipShortcuts { continue } // skip file shortcuts if directory only if directoriesOnly && item.ShortcutDetails.TargetMimeType != driveFolderType { continue } // skip directory shortcuts if file only if filesOnly && item.ShortcutDetails.TargetMimeType == driveFolderType { continue } item, err = f.resolveShortcut(ctx, item) if err != nil { return false, fmt.Errorf("list: %w", err) } // leave the dangling shortcut out of the listings // we've already logged about the dangling shortcut in resolveShortcut if f.opt.SkipDanglingShortcuts && item.MimeType == shortcutMimeTypeDangling { continue } } // Check the case of items is correct since // the `=` operator is case insensitive. if title != "" && title != item.Name { found := slices.Contains(stems, item.Name) if !found { continue } _, exportName, _, _ := f.findExportFormat(ctx, item) if exportName == "" || exportName != title { continue } } if fn(item) { found = true break OUTER } } if files.NextPageToken == "" { break } list.PageToken(files.NextPageToken) } return } // Returns true of x is a power of 2 or zero func isPowerOfTwo(x int64) bool { switch { case x == 0: return true case x < 0: return false default: return (x & (x - 1)) == 0 } } // add a charset parameter to all text/* MIME types func fixMimeType(mimeTypeIn string) string { if mimeTypeIn == "" { return "" } mediaType, param, err := mime.ParseMediaType(mimeTypeIn) if err != nil { return mimeTypeIn } mimeTypeOut := mimeTypeIn if strings.HasPrefix(mediaType, "text/") && param["charset"] == "" { param["charset"] = "utf-8" mimeTypeOut = mime.FormatMediaType(mediaType, param) } if mimeTypeOut == "" { panic(fmt.Errorf("unable to fix MIME type %q", mimeTypeIn)) } return mimeTypeOut } func fixMimeTypeMap(in map[string][]string) (out map[string][]string) { out = make(map[string][]string, len(in)) for k, v := range in { for i, mt := range v { v[i] = fixMimeType(mt) } out[fixMimeType(k)] = v } return out } func isInternalMimeType(mimeType string) bool { return strings.HasPrefix(mimeType, "application/vnd.google-apps.") } func isLinkMimeType(mimeType string) bool { return strings.HasPrefix(mimeType, "application/x-link-") } // parseExtensions parses a list of comma separated extensions // into a list of unique extensions with leading "." and a list of associated MIME types func parseExtensions(extensionsIn ...string) (extensions, mimeTypes []string, err error) { for _, extensionText := range extensionsIn { for _, extension := range strings.Split(extensionText, ",") { extension = strings.ToLower(strings.TrimSpace(extension)) if extension == "" { continue } if len(extension) > 0 && extension[0] != '.' { extension = "." + extension } mt := mime.TypeByExtension(extension) if mt == "" { return extensions, mimeTypes, fmt.Errorf("couldn't find MIME type for extension %q", extension) } if !containsString(extensions, extension) { extensions = append(extensions, extension) mimeTypes = append(mimeTypes, mt) } } } return } // getClient makes an http client according to the options func getClient(ctx context.Context, opt *Options) *http.Client { t := fshttp.NewTransportCustom(ctx, func(t *http.Transport) { if opt.DisableHTTP2 { t.TLSNextProto = map[string]func(string, *tls.Conn) http.RoundTripper{} } }) return &http.Client{ Transport: t, } } func getServiceAccountClient(ctx context.Context, opt *Options, credentialsData []byte) (*http.Client, error) { scopes := driveScopes(opt.Scope) conf, err := google.JWTConfigFromJSON(credentialsData, scopes...) if err != nil { return nil, fmt.Errorf("error processing credentials: %w", err) } if opt.Impersonate != "" { conf.Subject = opt.Impersonate } ctxWithSpecialClient := oauthutil.Context(ctx, getClient(ctx, opt)) return oauth2.NewClient(ctxWithSpecialClient, conf.TokenSource(ctxWithSpecialClient)), nil } func createOAuthClient(ctx context.Context, opt *Options, name string, m configmap.Mapper) (*http.Client, error) { var oAuthClient *http.Client var err error // try loading service account credentials from env variable, then from a file if len(opt.ServiceAccountCredentials) == 0 && opt.ServiceAccountFile != "" { loadedCreds, err := os.ReadFile(env.ShellExpand(opt.ServiceAccountFile)) if err != nil { return nil, fmt.Errorf("error opening service account credentials file: %w", err) } opt.ServiceAccountCredentials = string(loadedCreds) } if opt.ServiceAccountCredentials != "" { oAuthClient, err = getServiceAccountClient(ctx, opt, []byte(opt.ServiceAccountCredentials)) if err != nil { return nil, fmt.Errorf("failed to create oauth client from service account: %w", err) } } else if opt.EnvAuth { scopes := driveScopes(opt.Scope) oAuthClient, err = google.DefaultClient(ctx, scopes...) if err != nil { return nil, fmt.Errorf("failed to create client from environment: %w", err) } } else { oAuthClient, _, err = oauthutil.NewClientWithBaseClient(ctx, name, m, driveConfig, getClient(ctx, opt)) if err != nil { return nil, fmt.Errorf("failed to create oauth client: %w", err) } } return oAuthClient, nil } func checkUploadChunkSize(cs fs.SizeSuffix) error { if !isPowerOfTwo(int64(cs)) { return fmt.Errorf("%v isn't a power of two", cs) } if cs < minChunkSize { return fmt.Errorf("%s is less than %s", cs, minChunkSize) } return nil } func (f *Fs) setUploadChunkSize(cs fs.SizeSuffix) (old fs.SizeSuffix, err error) { err = checkUploadChunkSize(cs) if err == nil { old, f.opt.ChunkSize = f.opt.ChunkSize, cs } return } func checkUploadCutoff(cs fs.SizeSuffix) error { return nil } func (f *Fs) setUploadCutoff(cs fs.SizeSuffix) (old fs.SizeSuffix, err error) { err = checkUploadCutoff(cs) if err == nil { old, f.opt.UploadCutoff = f.opt.UploadCutoff, cs } return } // newFs partially constructs Fs from the path // // It constructs a valid Fs but doesn't attempt to figure out whether // it is a file or a directory. func newFs(ctx context.Context, name, path string, m configmap.Mapper) (*Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } err = checkUploadCutoff(opt.UploadCutoff) if err != nil { return nil, fmt.Errorf("drive: upload cutoff: %w", err) } err = checkUploadChunkSize(opt.ChunkSize) if err != nil { return nil, fmt.Errorf("drive: chunk size: %w", err) } oAuthClient, err := createOAuthClient(ctx, opt, name, m) if err != nil { return nil, fmt.Errorf("drive: failed when making oauth client: %w", err) } root, err := parseDrivePath(path) if err != nil { return nil, err } ci := fs.GetConfig(ctx) f := &Fs{ name: name, root: root, opt: *opt, ci: ci, pacer: fs.NewPacer(ctx, pacer.NewGoogleDrive(pacer.MinSleep(opt.PacerMinSleep), pacer.Burst(opt.PacerBurst))), m: m, grouping: listRGrouping, listRmu: new(sync.Mutex), listRempties: make(map[string]struct{}), dirResourceKeys: new(sync.Map), permissionsMu: new(sync.Mutex), permissions: make(map[string]*drive.Permission), } f.isTeamDrive = opt.TeamDriveID != "" f.features = (&fs.Features{ DuplicateFiles: true, ReadMimeType: true, WriteMimeType: true, CanHaveEmptyDirectories: true, ServerSideAcrossConfigs: opt.ServerSideAcrossConfigs, FilterAware: true, ReadMetadata: true, WriteMetadata: true, UserMetadata: true, ReadDirMetadata: true, WriteDirMetadata: true, WriteDirSetModTime: true, UserDirMetadata: true, DirModTimeUpdatesOnWrite: false, // FIXME need to check! }).Fill(ctx, f) // Create a new authorized Drive client. f.client = oAuthClient f.svc, err = drive.NewService(context.Background(), option.WithHTTPClient(f.client)) if err != nil { return nil, fmt.Errorf("couldn't create Drive client: %w", err) } if f.opt.V2DownloadMinSize >= 0 { f.v2Svc, err = drive_v2.NewService(context.Background(), option.WithHTTPClient(f.client)) if err != nil { return nil, fmt.Errorf("couldn't create Drive v2 client: %w", err) } } return f, nil } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, path string, m configmap.Mapper) (fs.Fs, error) { f, err := newFs(ctx, name, path, m) if err != nil { return nil, err } // Set the root folder ID if f.opt.RootFolderID != "" { // use root_folder ID if set f.rootFolderID = f.opt.RootFolderID } else if f.isTeamDrive { // otherwise use team_drive if set f.rootFolderID = f.opt.TeamDriveID } else { // otherwise look up the actual root ID rootID, err := f.getRootID(ctx) if err != nil { var gerr *googleapi.Error if errors.As(err, &gerr) && gerr.Code == 404 { // 404 means that this scope does not have permission to get the // root so just use "root" rootID = "root" } else { return nil, err } } f.rootFolderID = rootID fs.Debugf(f, "'root_folder_id = %s' - save this in the config to speed up startup", rootID) } f.dirCache = dircache.New(f.root, f.rootFolderID, f) // If resource key is set then cache it for the root folder id if f.opt.ResourceKey != "" { f.dirResourceKeys.Store(f.rootFolderID, f.opt.ResourceKey) } // Parse extensions if f.opt.Extensions != "" { if f.opt.ExportExtensions != defaultExportExtensions { return nil, errors.New("only one of 'formats' and 'export_formats' can be specified") } f.opt.Extensions, f.opt.ExportExtensions = "", f.opt.Extensions } f.exportExtensions, _, err = parseExtensions(f.opt.ExportExtensions, defaultExportExtensions) if err != nil { return nil, err } _, f.importMimeTypes, err = parseExtensions(f.opt.ImportExtensions) if err != nil { return nil, err } // Find the current root err = f.dirCache.FindRoot(ctx, false) if err != nil { // Assume it is a file newRoot, remote := dircache.SplitPath(f.root) tempF := *f tempF.dirCache = dircache.New(newRoot, f.rootFolderID, &tempF) tempF.root = newRoot // Make new Fs which is the parent err = tempF.dirCache.FindRoot(ctx, false) if err != nil { // No root so return old f return f, nil } _, err := tempF.NewObject(ctx, remote) if err != nil { // unable to list folder so return old f return f, nil } // XXX: update the old f here instead of returning tempF, since // `features` were already filled with functions having *f as a receiver. // See https://github.com/rclone/rclone/issues/2182 f.dirCache = tempF.dirCache f.root = tempF.root return f, fs.ErrorIsFile } // fmt.Printf("Root id %s", f.dirCache.RootID()) return f, nil } func (f *Fs) newBaseObject(ctx context.Context, remote string, info *drive.File) (o baseObject, err error) { modifiedDate := info.ModifiedTime if f.opt.UseCreatedDate { modifiedDate = info.CreatedTime } else if f.opt.UseSharedDate && info.SharedWithMeTime != "" { modifiedDate = info.SharedWithMeTime } size := info.Size if f.opt.SizeAsQuota { size = info.QuotaBytesUsed } o = baseObject{ fs: f, remote: remote, id: info.Id, modifiedDate: modifiedDate, mimeType: info.MimeType, bytes: size, parents: info.Parents, } err = nil if fs.GetConfig(ctx).Metadata { err = o.parseMetadata(ctx, info) } return o, err } // getFileFields gets the fields for a normal file Get or List func (f *Fs) getFileFields(ctx context.Context) (fields googleapi.Field) { fields = partialFields if f.opt.AuthOwnerOnly { fields += ",owners" } if f.opt.UseSharedDate { fields += ",sharedWithMeTime" } if f.opt.SkipChecksumGphotos { fields += ",spaces" } if f.opt.SizeAsQuota { fields += ",quotaBytesUsed" } if fs.GetConfig(ctx).Metadata { fields += "," + metadataFields } return fields } // newRegularObject creates an fs.Object for a normal drive.File func (f *Fs) newRegularObject(ctx context.Context, remote string, info *drive.File) (obj fs.Object, err error) { // wipe checksum if SkipChecksumGphotos and file is type Photo or Video if f.opt.SkipChecksumGphotos { if slices.Contains(info.Spaces, "photos") { info.Md5Checksum = "" info.Sha1Checksum = "" info.Sha256Checksum = "" } } o := &Object{ url: fmt.Sprintf("%sfiles/%s?alt=media", f.svc.BasePath, actualID(info.Id)), md5sum: strings.ToLower(info.Md5Checksum), sha1sum: strings.ToLower(info.Sha1Checksum), sha256sum: strings.ToLower(info.Sha256Checksum), v2Download: f.opt.V2DownloadMinSize != -1 && info.Size >= int64(f.opt.V2DownloadMinSize), } o.baseObject, err = f.newBaseObject(ctx, remote, info) if err != nil { return nil, err } if info.ResourceKey != "" { o.resourceKey = &info.ResourceKey } return o, nil } // newDocumentObject creates an fs.Object for a google docs drive.File func (f *Fs) newDocumentObject(ctx context.Context, remote string, info *drive.File, extension, exportMimeType string) (fs.Object, error) { mediaType, _, err := mime.ParseMediaType(exportMimeType) if err != nil { return nil, err } url := info.ExportLinks[mediaType] baseObject, err := f.newBaseObject(ctx, remote+extension, info) if err != nil { return nil, err } baseObject.bytes = -1 baseObject.mimeType = exportMimeType return &documentObject{ baseObject: baseObject, url: url, documentMimeType: info.MimeType, extLen: len(extension), }, nil } // newLinkObject creates an fs.Object that represents a link a google docs drive.File func (f *Fs) newLinkObject(ctx context.Context, remote string, info *drive.File, extension, exportMimeType string) (fs.Object, error) { t := linkTemplate(exportMimeType) if t == nil { return nil, fmt.Errorf("unsupported link type %s", exportMimeType) } xdgIcon := _mimeTypeToXDGLinkIcons[info.MimeType] if xdgIcon == "" { xdgIcon = defaultXDGIcon } var buf bytes.Buffer err := t.Execute(&buf, struct { URL, Title, XDGIcon string }{ info.WebViewLink, info.Name, xdgIcon, }) if err != nil { return nil, fmt.Errorf("executing template failed: %w", err) } baseObject, err := f.newBaseObject(ctx, remote+extension, info) if err != nil { return nil, err } baseObject.bytes = int64(buf.Len()) baseObject.mimeType = exportMimeType return &linkObject{ baseObject: baseObject, content: buf.Bytes(), extLen: len(extension), }, nil } // newObjectWithInfo creates an fs.Object for any drive.File // // When the drive.File cannot be represented as an fs.Object it will return (nil, nil). func (f *Fs) newObjectWithInfo(ctx context.Context, remote string, info *drive.File) (fs.Object, error) { // If item has MD5 sum it is a file stored on drive if info.Md5Checksum != "" { return f.newRegularObject(ctx, remote, info) } extension, exportName, exportMimeType, isDocument := f.findExportFormat(ctx, info) return f.newObjectWithExportInfo(ctx, remote, info, extension, exportName, exportMimeType, isDocument) } // newObjectWithExportInfo creates an fs.Object for any drive.File and the result of findExportFormat // // When the drive.File cannot be represented as an fs.Object it will return (nil, nil). func (f *Fs) newObjectWithExportInfo( ctx context.Context, remote string, info *drive.File, extension, exportName, exportMimeType string, isDocument bool, ) (o fs.Object, err error) { // Note that resolveShortcut will have been called already if // we are being called from a listing. However the drive.Item // will have been resolved so this will do nothing. info, err = f.resolveShortcut(ctx, info) if err != nil { return nil, fmt.Errorf("new object: %w", err) } switch { case info.MimeType == driveFolderType: return nil, fs.ErrorIsDir case info.MimeType == shortcutMimeType: // We can only get here if f.opt.SkipShortcuts is set // and not from a listing. This is unlikely. fs.Debugf(remote, "Ignoring shortcut as skip shortcuts is set") return nil, fs.ErrorObjectNotFound case info.MimeType == shortcutMimeTypeDangling: // Pretend a dangling shortcut is a regular object // It will error if used, but appear in listings so it can be deleted return f.newRegularObject(ctx, remote, info) case info.Md5Checksum != "": // If item has MD5 sum it is a file stored on drive return f.newRegularObject(ctx, remote, info) case f.opt.SkipGdocs: fs.Debugf(remote, "Skipping google document type %q", info.MimeType) return nil, fs.ErrorObjectNotFound case f.opt.ShowAllGdocs: return f.newDocumentObject(ctx, remote, info, "", info.MimeType) default: // If item MimeType is in the ExportFormats then it is a google doc if !isDocument { fs.Debugf(remote, "Ignoring unknown document type %q", info.MimeType) return nil, fs.ErrorObjectNotFound } if extension == "" { fs.Debugf(remote, "No export formats found for %q", info.MimeType) return nil, fs.ErrorObjectNotFound } if isLinkMimeType(exportMimeType) { return f.newLinkObject(ctx, remote, info, extension, exportMimeType) } return f.newDocumentObject(ctx, remote, info, extension, exportMimeType) } } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { if strings.HasSuffix(remote, "/") { return nil, fs.ErrorIsDir } info, extension, exportName, exportMimeType, isDocument, err := f.getRemoteInfoWithExport(ctx, remote) if err != nil { return nil, err } remote = remote[:len(remote)-len(extension)] obj, err := f.newObjectWithExportInfo(ctx, remote, info, extension, exportName, exportMimeType, isDocument) switch { case err != nil: return nil, err case obj == nil: return nil, fs.ErrorObjectNotFound default: return obj, nil } } // FindLeaf finds a directory of name leaf in the folder with ID pathID func (f *Fs) FindLeaf(ctx context.Context, pathID, leaf string) (pathIDOut string, found bool, err error) { // Find the leaf in pathID pathID = actualID(pathID) found, err = f.list(ctx, []string{pathID}, leaf, true, false, f.opt.TrashedOnly, false, func(item *drive.File) bool { if !f.opt.SkipGdocs { _, exportName, _, isDocument := f.findExportFormat(ctx, item) if exportName == leaf { pathIDOut = item.Id return true } if isDocument { return false } } if item.Name == leaf { pathIDOut = item.Id return true } return false }) return pathIDOut, found, err } // createDir makes a directory with pathID as parent and name leaf with optional metadata func (f *Fs) createDir(ctx context.Context, pathID, leaf string, metadata fs.Metadata) (info *drive.File, err error) { leaf = f.opt.Enc.FromStandardName(leaf) pathID = actualID(pathID) createInfo := &drive.File{ Name: leaf, MimeType: driveFolderType, Parents: []string{pathID}, } var updateMetadata updateMetadataFn if len(metadata) > 0 { updateMetadata, err = f.updateMetadata(ctx, createInfo, metadata, true, true) if err != nil { return nil, fmt.Errorf("create dir: failed to update metadata: %w", err) } } err = f.pacer.Call(func() (bool, error) { info, err = f.svc.Files.Create(createInfo). Fields(f.getFileFields(ctx)). SupportsAllDrives(true). Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return nil, err } if updateMetadata != nil { err = updateMetadata(ctx, info) if err != nil { return nil, err } } return info, nil } // updateDir updates an existing a directory with the metadata passed in func (f *Fs) updateDir(ctx context.Context, dirID string, metadata fs.Metadata) (info *drive.File, err error) { if len(metadata) == 0 { return f.getFile(ctx, dirID, f.getFileFields(ctx)) } dirID = actualID(dirID) updateInfo := &drive.File{} updateMetadata, err := f.updateMetadata(ctx, updateInfo, metadata, true, true) if err != nil { return nil, fmt.Errorf("update dir: failed to update metadata from source object: %w", err) } err = f.pacer.Call(func() (bool, error) { info, err = f.svc.Files.Update(dirID, updateInfo). Fields(f.getFileFields(ctx)). SupportsAllDrives(true). Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return nil, err } err = updateMetadata(ctx, info) if err != nil { return nil, err } return info, nil } // CreateDir makes a directory with pathID as parent and name leaf func (f *Fs) CreateDir(ctx context.Context, pathID, leaf string) (newID string, err error) { info, err := f.createDir(ctx, pathID, leaf, nil) if err != nil { return "", err } return info.Id, nil } // isAuthOwned checks if any of the item owners is the authenticated owner func isAuthOwned(item *drive.File) bool { for _, owner := range item.Owners { if owner.Me { return true } } return false } // linkTemplate returns the Template for a MIME type or nil if the // MIME type does not represent a link func linkTemplate(mt string) *template.Template { templatesOnce.Do(func() { _linkTemplates = map[string]*template.Template{ "application/x-link-desktop": template.Must( template.New("application/x-link-desktop").Parse(desktopTemplate)), "application/x-link-html": template.Must( template.New("application/x-link-html").Parse(htmlTemplate)), "application/x-link-url": template.Must( template.New("application/x-link-url").Parse(urlTemplate)), "application/x-link-webloc": template.Must( template.New("application/x-link-webloc").Parse(weblocTemplate)), } }) return _linkTemplates[mt] } func (f *Fs) fetchFormats(ctx context.Context) { fetchFormatsOnce.Do(func() { var about *drive.About var err error err = f.pacer.Call(func() (bool, error) { about, err = f.svc.About.Get(). Fields("exportFormats,importFormats"). Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { fs.Errorf(f, "Failed to get Drive exportFormats and importFormats: %v", err) _exportFormats = map[string][]string{} _importFormats = map[string][]string{} return } _exportFormats = fixMimeTypeMap(about.ExportFormats) _importFormats = fixMimeTypeMap(about.ImportFormats) }) } // exportFormats returns the export formats from drive, fetching them // if necessary. // // if the fetch fails then it will not export any drive formats func (f *Fs) exportFormats(ctx context.Context) map[string][]string { f.fetchFormats(ctx) return _exportFormats } // importFormats returns the import formats from drive, fetching them // if necessary. // // if the fetch fails then it will not import any drive formats func (f *Fs) importFormats(ctx context.Context) map[string][]string { f.fetchFormats(ctx) return _importFormats } // findExportFormatByMimeType works out the optimum export settings // for the given MIME type. // // Look through the exportExtensions and find the first format that can be // converted. If none found then return ("", "", false) func (f *Fs) findExportFormatByMimeType(ctx context.Context, itemMimeType string) ( extension, mimeType string, isDocument bool, ) { exportMimeTypes, isDocument := f.exportFormats(ctx)[itemMimeType] if isDocument { for _, _extension := range f.exportExtensions { _mimeType := mime.TypeByExtension(_extension) if isLinkMimeType(_mimeType) { return _extension, _mimeType, true } for _, emt := range exportMimeTypes { if emt == _mimeType { return _extension, emt, true } if _mimeType == _mimeTypeCustomTransform[emt] { return _extension, emt, true } } } } // If using a link type export and a more specific export // hasn't been found all docs should be exported for _, _extension := range f.exportExtensions { _mimeType := mime.TypeByExtension(_extension) if isLinkMimeType(_mimeType) { return _extension, _mimeType, true } } // else return empty return "", "", isDocument } // findExportFormat works out the optimum export settings // for the given drive.File. // // Look through the exportExtensions and find the first format that can be // converted. If none found then return ("", "", "", false) func (f *Fs) findExportFormat(ctx context.Context, item *drive.File) (extension, filename, mimeType string, isDocument bool) { // If item has MD5 sum it is a file stored on drive if item.Md5Checksum != "" { return } // Folders can't be documents if item.MimeType == driveFolderType { return } extension, mimeType, isDocument = f.findExportFormatByMimeType(ctx, item.MimeType) if extension != "" { filename = item.Name + extension } return } // findImportFormat finds the matching upload MIME type for a file // If the given MIME type is in importMimeTypes, the matching upload // MIME type is returned // // When no match is found "" is returned. func (f *Fs) findImportFormat(ctx context.Context, mimeType string) string { mimeType = fixMimeType(mimeType) ifs := f.importFormats(ctx) for _, mt := range f.importMimeTypes { if mt == mimeType { importMimeTypes := ifs[mimeType] if l := len(importMimeTypes); l > 0 { if l > 1 { fs.Infof(f, "found %d import formats for %q: %q", l, mimeType, importMimeTypes) } return importMimeTypes[0] } } } return "" } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { directoryID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { return nil, err } directoryID = actualID(directoryID) var iErr error _, err = f.list(ctx, []string{directoryID}, "", false, false, f.opt.TrashedOnly, false, func(item *drive.File) bool { entry, err := f.itemToDirEntry(ctx, path.Join(dir, item.Name), item) if err != nil { iErr = err return true } if entry != nil { entries = append(entries, entry) } return false }) if err != nil { return nil, err } if iErr != nil { return nil, iErr } // If listing the root of a teamdrive and got no entries, // double check we have access if f.isTeamDrive && len(entries) == 0 && f.root == "" && dir == "" { err = f.teamDriveOK(ctx) if err != nil { return nil, err } } return entries, nil } // listREntry is a task to be executed by a litRRunner type listREntry struct { id, path string } // listRSlices is a helper struct to sort two slices at once type listRSlices struct { dirs []string paths []string } func (s listRSlices) Sort() { sort.Sort(s) } func (s listRSlices) Len() int { return len(s.dirs) } func (s listRSlices) Swap(i, j int) { s.dirs[i], s.dirs[j] = s.dirs[j], s.dirs[i] s.paths[i], s.paths[j] = s.paths[j], s.paths[i] } func (s listRSlices) Less(i, j int) bool { return s.dirs[i] < s.dirs[j] } // listRRunner will read dirIDs from the in channel, perform the file listing and call cb with each DirEntry. // // In each cycle it will read up to grouping entries from the in channel without blocking. // If an error occurs it will be send to the out channel and then return. Once the in channel is closed, // nil is send to the out channel and the function returns. func (f *Fs) listRRunner(ctx context.Context, wg *sync.WaitGroup, in chan listREntry, out chan<- error, cb func(fs.DirEntry) error, sendJob func(listREntry)) { var dirs []string var paths []string var grouping int32 for dir := range in { dirs = append(dirs[:0], dir.id) paths = append(paths[:0], dir.path) grouping = atomic.LoadInt32(&f.grouping) waitloop: for i := int32(1); i < grouping; i++ { select { case d, ok := <-in: if !ok { break waitloop } dirs = append(dirs, d.id) paths = append(paths, d.path) default: } } listRSlices{dirs, paths}.Sort() var iErr error foundItems := false _, err := f.list(ctx, dirs, "", false, false, f.opt.TrashedOnly, false, func(item *drive.File) bool { // shared with me items have no parents when at the root if f.opt.SharedWithMe && len(item.Parents) == 0 && len(paths) == 1 && paths[0] == "" { item.Parents = dirs } for _, parent := range item.Parents { var i int foundItems = true earlyExit := false // If only one item in paths then no need to search for the ID // assuming google drive is doing its job properly. // // Note that we at the root when len(paths) == 1 && paths[0] == "" if len(paths) == 1 { // don't check parents at root because // - shared with me items have no parents at the root // - if using a root alias, e.g. "root" or "appDataFolder" the ID won't match i = 0 // items at root can have more than one parent so we need to put // the item in just once. earlyExit = true } else { // only handle parents that are in the requested dirs list if not at root i = sort.SearchStrings(dirs, parent) if i == len(dirs) || dirs[i] != parent { continue } } remote := path.Join(paths[i], item.Name) entry, err := f.itemToDirEntry(ctx, remote, item) if err != nil { iErr = err return true } err = cb(entry) if err != nil { iErr = err return true } // If didn't check parents then insert only once if earlyExit { break } } return false }) // Found no items in more than one directory. Retry these as // individual directories This is to work around a bug in google // drive where (A in parents) or (B in parents) returns nothing // sometimes. See #3114, #4289 and // https://issuetracker.google.com/issues/149522397 if f.opt.FastListBugFix && len(dirs) > 1 && !foundItems { if atomic.SwapInt32(&f.grouping, 1) != 1 { fs.Debugf(f, "Disabling ListR to work around bug in drive as multi listing (%d) returned no entries", len(dirs)) } f.listRmu.Lock() for i := range dirs { // Requeue the jobs job := listREntry{id: dirs[i], path: paths[i]} sendJob(job) // Make a note of these dirs - if they all turn // out to be empty then we can re-enable grouping f.listRempties[dirs[i]] = struct{}{} } f.listRmu.Unlock() fs.Debugf(f, "Recycled %d entries", len(dirs)) } // If using a grouping of 1 and dir was empty then check to see if it // is part of the group that caused grouping to be disabled. if grouping == 1 && len(dirs) == 1 && !foundItems { f.listRmu.Lock() if _, found := f.listRempties[dirs[0]]; found { // Remove the ID delete(f.listRempties, dirs[0]) // If no empties left => all the directories that // triggered the grouping being set to 1 were actually // empty so must have made a mistake if len(f.listRempties) == 0 { if atomic.SwapInt32(&f.grouping, listRGrouping) != listRGrouping { fs.Debugf(f, "Re-enabling ListR as previous detection was in error") } } } f.listRmu.Unlock() } for range dirs { wg.Done() } if iErr != nil { out <- iErr return } if err != nil { out <- err return } } out <- nil } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively that doing a directory traversal. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { directoryID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { return err } directoryID = actualID(directoryID) mu := sync.Mutex{} // protects in and overflow wg := sync.WaitGroup{} in := make(chan listREntry, listRInputBuffer) out := make(chan error, f.ci.Checkers) list := list.NewHelper(callback) overflow := []listREntry{} listed := 0 // Send a job to the input channel if not closed. If the job // won't fit then queue it in the overflow slice. // // This will not block if the channel is full. sendJob := func(job listREntry) { mu.Lock() defer mu.Unlock() if in == nil { return } wg.Add(1) select { case in <- job: default: overflow = append(overflow, job) wg.Done() } } // Send the entry to the caller, queueing any directories as new jobs cb := func(entry fs.DirEntry) error { if d, isDir := entry.(fs.Directory); isDir { job := listREntry{actualID(d.ID()), d.Remote()} sendJob(job) } mu.Lock() defer mu.Unlock() listed++ return list.Add(entry) } wg.Add(1) in <- listREntry{directoryID, dir} for range f.ci.Checkers { go f.listRRunner(ctx, &wg, in, out, cb, sendJob) } go func() { // wait until the all directories are processed wg.Wait() // if the input channel overflowed add the collected entries to the channel now for len(overflow) > 0 { mu.Lock() // only fill half of the channel to prevent entries being put into overflow again l := min(len(overflow), listRInputBuffer/2) wg.Add(l) for _, d := range overflow[:l] { in <- d } overflow = overflow[l:] mu.Unlock() // wait again for the completion of all directories wg.Wait() } mu.Lock() if in != nil { // notify all workers to exit close(in) in = nil } mu.Unlock() }() // wait until the all workers to finish for range f.ci.Checkers { e := <-out mu.Lock() // if one worker returns an error early, close the input so all other workers exit if e != nil && in != nil { err = e close(in) in = nil } mu.Unlock() } close(out) if err != nil { return err } err = list.Flush() if err != nil { return err } // If listing the root of a teamdrive and got no entries, // double check we have access if f.isTeamDrive && listed == 0 && f.root == "" && dir == "" { err = f.teamDriveOK(ctx) if err != nil { return err } } return nil } const shortcutSeparator = '\t' // joinID adds an actual drive ID to the shortcut ID it came from // // directoryIDs in the dircache are these composite directory IDs so // we must always unpack them before use. func joinID(actual, shortcut string) string { return actual + string(shortcutSeparator) + shortcut } // splitID separates an actual ID and a shortcut ID from a composite // ID. If there was no shortcut ID then it will return "" for it. func splitID(compositeID string) (actualID, shortcutID string) { i := strings.IndexRune(compositeID, shortcutSeparator) if i < 0 { return compositeID, "" } return compositeID[:i], compositeID[i+1:] } // isShortcutID returns true if compositeID refers to a shortcut func isShortcutID(compositeID string) bool { return strings.ContainsRune(compositeID, shortcutSeparator) } // actualID returns an actual ID from a composite ID func actualID(compositeID string) (actualID string) { actualID, _ = splitID(compositeID) return actualID } // shortcutID returns a shortcut ID from a composite ID if available, // or the actual ID if not. func shortcutID(compositeID string) (shortcutID string) { actualID, shortcutID := splitID(compositeID) if shortcutID != "" { return shortcutID } return actualID } // isShortcut returns true of the item is a shortcut func isShortcut(item *drive.File) bool { return item.MimeType == shortcutMimeType && item.ShortcutDetails != nil } // Dereference shortcut if required. It returns the newItem (which may // be just item). // // If we return a new item then the ID will be adjusted to be a // composite of the actual ID and the shortcut ID. This is to make // sure that we have decided in all use places what we are doing with // the ID. // // Note that we assume shortcuts can't point to shortcuts. Google // drive web interface doesn't offer the option to create a shortcut // to a shortcut. The documentation is silent on the issue. func (f *Fs) resolveShortcut(ctx context.Context, item *drive.File) (newItem *drive.File, err error) { if f.opt.SkipShortcuts || item.MimeType != shortcutMimeType { return item, nil } if item.ShortcutDetails == nil { fs.Errorf(nil, "Expecting shortcutDetails in %v", item) return item, nil } newItem, err = f.getFile(ctx, item.ShortcutDetails.TargetId, f.getFileFields(ctx)) if err != nil { var gerr *googleapi.Error if errors.As(err, &gerr) && gerr.Code == 404 { // 404 means dangling shortcut, so just return the shortcut with the mime type mangled fs.Logf(nil, "Dangling shortcut %q detected", item.Name) item.MimeType = shortcutMimeTypeDangling return item, nil } return nil, fmt.Errorf("failed to resolve shortcut: %w", err) } // make sure we use the Name, Parents and Trashed from the original item newItem.Name = item.Name newItem.Parents = item.Parents newItem.Trashed = item.Trashed // the new ID is a composite ID newItem.Id = joinID(newItem.Id, item.Id) return newItem, nil } // itemToDirEntry converts a drive.File to an fs.DirEntry. // When the drive.File cannot be represented as an fs.DirEntry // (nil, nil) is returned. func (f *Fs) itemToDirEntry(ctx context.Context, remote string, item *drive.File) (entry fs.DirEntry, err error) { switch { case item.MimeType == driveFolderType: // cache the directory ID for later lookups f.dirCache.Put(remote, item.Id) // cache the resource key for later lookups if item.ResourceKey != "" { f.dirResourceKeys.Store(item.Id, item.ResourceKey) } baseObject, err := f.newBaseObject(ctx, remote, item) if err != nil { return nil, err } d := &Directory{baseObject: baseObject} return d, nil case f.opt.AuthOwnerOnly && !isAuthOwned(item): // ignore object default: entry, err = f.newObjectWithInfo(ctx, remote, item) if err == fs.ErrorObjectNotFound { return nil, nil } return entry, err } return nil, nil } // Creates a drive.File info from the parameters passed in. // // Used to create new objects func (f *Fs) createFileInfo(ctx context.Context, remote string, modTime time.Time) (*drive.File, error) { leaf, directoryID, err := f.dirCache.FindPath(ctx, remote, true) if err != nil { return nil, err } directoryID = actualID(directoryID) leaf = f.opt.Enc.FromStandardName(leaf) // Define the metadata for the file we are going to create. createInfo := &drive.File{ Name: leaf, Parents: []string{directoryID}, ModifiedTime: modTime.Format(timeFormatOut), } return createInfo, nil } // Put the object // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { existingObj, err := f.NewObject(ctx, src.Remote()) switch err { case nil: return existingObj, existingObj.Update(ctx, in, src, options...) case fs.ErrorObjectNotFound: // Not found so create it return f.PutUnchecked(ctx, in, src, options...) default: return nil, err } } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } // PutUnchecked uploads the object // // This will create a duplicate if we upload a new file without // checking to see if there is one already - use Put() for that. func (f *Fs) PutUnchecked(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { remote := src.Remote() size := src.Size() modTime := src.ModTime(ctx) srcMimeType := fs.MimeTypeFromName(remote) srcExt := path.Ext(remote) exportExt := "" importMimeType := "" if f.importMimeTypes != nil && !f.opt.SkipGdocs { importMimeType = f.findImportFormat(ctx, srcMimeType) if isInternalMimeType(importMimeType) { remote = remote[:len(remote)-len(srcExt)] exportExt, _, _ = f.findExportFormatByMimeType(ctx, importMimeType) if exportExt == "" { return nil, fmt.Errorf("no export format found for %q", importMimeType) } if exportExt != srcExt && !f.opt.AllowImportNameChange { return nil, fmt.Errorf("can't convert %q to a document with a different export filetype (%q)", srcExt, exportExt) } } } createInfo, err := f.createFileInfo(ctx, remote, modTime) if err != nil { return nil, err } if importMimeType != "" { createInfo.MimeType = importMimeType } else { createInfo.MimeType = fs.MimeTypeFromName(remote) } updateMetadata, err := f.fetchAndUpdateMetadata(ctx, src, options, createInfo, false) if err != nil { return nil, err } var info *drive.File if size >= 0 && size < int64(f.opt.UploadCutoff) { // Make the API request to upload metadata and file data. // Don't retry, return a retry error instead err = f.pacer.CallNoRetry(func() (bool, error) { info, err = f.svc.Files.Create(createInfo). Media(in, googleapi.ContentType(srcMimeType), googleapi.ChunkSize(0)). Fields(partialFields). SupportsAllDrives(true). KeepRevisionForever(f.opt.KeepRevisionForever). Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return nil, err } } else { // Upload the file in chunks info, err = f.Upload(ctx, in, size, srcMimeType, "", remote, createInfo) if err != nil { return nil, err } } err = updateMetadata(ctx, info) if err != nil { return nil, err } return f.newObjectWithInfo(ctx, remote, info) } // MergeDirs merges the contents of all the directories passed // in into the first one and rmdirs the other directories. func (f *Fs) MergeDirs(ctx context.Context, dirs []fs.Directory) error { if len(dirs) < 2 { return nil } newDirs := dirs[:0] for _, dir := range dirs { if isShortcutID(dir.ID()) { fs.Infof(dir, "skipping shortcut directory") continue } newDirs = append(newDirs, dir) } dirs = newDirs if len(dirs) < 2 { return nil } dstDir := dirs[0] for _, srcDir := range dirs[1:] { // list the objects infos := []*drive.File{} _, err := f.list(ctx, []string{srcDir.ID()}, "", false, false, f.opt.TrashedOnly, true, func(info *drive.File) bool { infos = append(infos, info) return false }) if err != nil { return fmt.Errorf("MergeDirs list failed on %v: %w", srcDir, err) } // move them into place for _, info := range infos { fs.Infof(srcDir, "merging %q", info.Name) // Move the file into the destination err = f.pacer.Call(func() (bool, error) { _, err = f.svc.Files.Update(info.Id, nil). RemoveParents(srcDir.ID()). AddParents(dstDir.ID()). Fields(""). SupportsAllDrives(true). Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("MergeDirs move failed on %q in %v: %w", info.Name, srcDir, err) } } // rmdir (into trash) the now empty source directory fs.Infof(srcDir, "removing empty directory") err = f.delete(ctx, srcDir.ID(), true) if err != nil { return fmt.Errorf("MergeDirs move failed to rmdir %q: %w", srcDir, err) } } return nil } // Mkdir creates the container if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) error { _, err := f.dirCache.FindDir(ctx, dir, true) return err } // MkdirMetadata makes the directory passed in as dir. // // It shouldn't return an error if it already exists. // // If the metadata is not nil it is set. // // It returns the directory that was created. func (f *Fs) MkdirMetadata(ctx context.Context, dir string, metadata fs.Metadata) (fs.Directory, error) { var info *drive.File dirID, err := f.dirCache.FindDir(ctx, dir, false) if err == fs.ErrorDirNotFound { // Directory does not exist so create it var leaf, parentID string leaf, parentID, err = f.dirCache.FindPath(ctx, dir, true) if err != nil { return nil, err } info, err = f.createDir(ctx, parentID, leaf, metadata) } else if err == nil { // Directory exists and needs updating info, err = f.updateDir(ctx, dirID, metadata) } if err != nil { return nil, err } // Convert the info into a directory entry entry, err := f.itemToDirEntry(ctx, dir, info) if err != nil { return nil, err } dirEntry, ok := entry.(fs.Directory) if !ok { return nil, fmt.Errorf("internal error: expecting %T to be an fs.Directory", entry) } return dirEntry, nil } // DirSetModTime sets the directory modtime for dir func (f *Fs) DirSetModTime(ctx context.Context, dir string, modTime time.Time) error { dirID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { return err } o := baseObject{ fs: f, remote: dir, id: dirID, } return o.SetModTime(ctx, modTime) } // delete a file or directory unconditionally by ID func (f *Fs) delete(ctx context.Context, id string, useTrash bool) error { return f.pacer.Call(func() (bool, error) { var err error if useTrash { info := drive.File{ Trashed: true, } _, err = f.svc.Files.Update(id, &info). Fields(""). SupportsAllDrives(true). Context(ctx).Do() } else { err = f.svc.Files.Delete(id). Fields(""). SupportsAllDrives(true). Context(ctx).Do() } return f.shouldRetry(ctx, err) }) } // purgeCheck removes the dir 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 { root := path.Join(f.root, dir) dc := f.dirCache directoryID, err := dc.FindDir(ctx, dir, false) if err != nil { return err } directoryID, shortcutID := splitID(directoryID) // if directory is a shortcut remove it regardless if shortcutID != "" { return f.delete(ctx, shortcutID, f.opt.UseTrash) } trashedFiles := false if check { found, err := f.list(ctx, []string{directoryID}, "", false, false, f.opt.TrashedOnly, true, func(item *drive.File) bool { if !item.Trashed { fs.Debugf(dir, "Rmdir: contains file: %q", item.Name) return true } fs.Debugf(dir, "Rmdir: contains trashed file: %q", item.Name) trashedFiles = true return false }) if err != nil { return err } if found { return fmt.Errorf("directory not empty") } } if root != "" { // trash the directory if it had trashed files // in or the user wants to trash, otherwise // delete it. err = f.delete(ctx, directoryID, trashedFiles || f.opt.UseTrash) if err != nil { return err } } else if check { return errors.New("can't purge root directory") } f.dirCache.FlushDir(dir) if err != nil { return err } return nil } // Rmdir deletes a directory // // Returns an error if it isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, true) } // Precision of the object storage system func (f *Fs) Precision() time.Duration { return time.Millisecond } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { var srcObj *baseObject ext := "" isDoc := false switch src := src.(type) { case *Object: srcObj = &src.baseObject case *documentObject: srcObj, ext = &src.baseObject, src.ext() isDoc = true case *linkObject: srcObj, ext = &src.baseObject, src.ext() default: fs.Debugf(src, "Can't copy - not same remote type") return nil, fs.ErrorCantCopy } // Look to see if there is an existing object before we remove // the extension from the remote existingObject, _ := f.NewObject(ctx, remote) // Adjust the remote name to be without the extension if we // are about to create a doc. if ext != "" { if !strings.HasSuffix(remote, ext) { fs.Debugf(src, "Can't copy - not same document type") return nil, fs.ErrorCantCopy } remote = remote[:len(remote)-len(ext)] } createInfo, err := f.createFileInfo(ctx, remote, src.ModTime(ctx)) if err != nil { return nil, err } if isDoc { // preserve the description on copy for docs info, err := f.getFile(ctx, actualID(srcObj.id), "description") if err != nil { fs.Errorf(srcObj, "Failed to read description for Google Doc: %v", err) } else { createInfo.Description = info.Description } } else { // don't overwrite the description on copy for files // this should work for docs but it doesn't - it is probably a bug in Google Drive createInfo.Description = "" } // Adjust metadata if required updateMetadata, err := f.fetchAndUpdateMetadata(ctx, src, fs.MetadataAsOpenOptions(ctx), createInfo, false) if err != nil { return nil, err } // get the ID of the thing to copy // copy the contents if CopyShortcutContent // else copy the shortcut only id := shortcutID(srcObj.id) if f.opt.CopyShortcutContent { id = actualID(srcObj.id) } var info *drive.File err = f.pacer.Call(func() (bool, error) { copy := f.svc.Files.Copy(id, createInfo). Fields(f.getFileFields(ctx)). SupportsAllDrives(true). KeepRevisionForever(f.opt.KeepRevisionForever) srcObj.addResourceKey(copy.Header()) info, err = copy.Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return nil, err } newObject, err := f.newObjectWithInfo(ctx, remote, info) if err != nil { return nil, err } // Google docs aren't preserving their mod time after copy, so set them explicitly // See: https://github.com/rclone/rclone/issues/4517 // // FIXME remove this when google fixes the problem! if isDoc { // A short sleep is needed here in order to make the // change effective, without it is ignored. This is // probably some eventual consistency nastiness. sleepTime := 2 * time.Second fs.Debugf(f, "Sleeping for %v before setting the modtime to work around drive bug - see #4517", sleepTime) time.Sleep(sleepTime) err = newObject.SetModTime(ctx, src.ModTime(ctx)) if err != nil { return nil, err } } if existingObject != nil { err = existingObject.Remove(ctx) if err != nil { fs.Errorf(existingObject, "Failed to remove existing object after copy: %v", err) } } // Finalise metadata err = updateMetadata(ctx, info) if err != nil { return nil, err } return newObject, nil } // Purge deletes all the files and the container // // Optional interface: Only implement this if you have a way of // deleting all the files quicker than just running Remove() on the // result of List() func (f *Fs) Purge(ctx context.Context, dir string) error { if f.opt.TrashedOnly { return errors.New("can't purge with --drive-trashed-only, use delete if you want to selectively delete files") } return f.purgeCheck(ctx, dir, false) } type cleanupResult struct { Errors int } func (r cleanupResult) Error() string { return fmt.Sprintf("%d errors during cleanup - see log", r.Errors) } func (f *Fs) cleanupTeamDrive(ctx context.Context, dir string, directoryID string) (r cleanupResult, err error) { _, err = f.list(ctx, []string{directoryID}, "", false, false, true, false, func(item *drive.File) bool { remote := path.Join(dir, item.Name) if item.ExplicitlyTrashed { // description is wrong - can also be set for folders - no need to recurse them err := f.delete(ctx, item.Id, false) if err != nil { r.Errors++ fs.Errorf(remote, "%v", err) } return false } if item.MimeType == driveFolderType { if !isShortcutID(item.Id) { rNew, _ := f.cleanupTeamDrive(ctx, remote, item.Id) r.Errors += rNew.Errors } return false } return false }) if err != nil { err = fmt.Errorf("failed to list directory: %w", err) r.Errors++ fs.Errorf(dir, "%v", err) } if r.Errors != 0 { return r, r } return r, nil } // CleanUp empties the trash func (f *Fs) CleanUp(ctx context.Context) error { if f.isTeamDrive { directoryID, err := f.dirCache.FindDir(ctx, "", false) if err != nil { return err } directoryID = actualID(directoryID) _, err = f.cleanupTeamDrive(ctx, "", directoryID) return err } err := f.pacer.Call(func() (bool, error) { err := f.svc.Files.EmptyTrash().Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return err } fs.Logf(f, "Note that emptying the trash happens in the background and can take some time.") return nil } // teamDriveOK checks to see if we can access the team drive func (f *Fs) teamDriveOK(ctx context.Context) (err error) { if !f.isTeamDrive { return nil } var td *drive.Drive err = f.pacer.Call(func() (bool, error) { td, err = f.svc.Drives.Get(f.opt.TeamDriveID).Fields("name,id,capabilities,createdTime,restrictions").Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("failed to get Shared Drive info: %w", err) } fs.Debugf(f, "read info from Shared Drive %q", td.Name) return err } // About gets quota information func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { if f.isTeamDrive { err := f.teamDriveOK(ctx) if err != nil { return nil, err } // Teamdrives don't appear to have a usage API so just return empty return &fs.Usage{}, nil } var about *drive.About var err error err = f.pacer.Call(func() (bool, error) { about, err = f.svc.About.Get().Fields("storageQuota").Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("failed to get Drive storageQuota: %w", err) } q := about.StorageQuota usage := &fs.Usage{ Used: fs.NewUsageValue(q.UsageInDrive), // bytes in use Trashed: fs.NewUsageValue(q.UsageInDriveTrash), // bytes in trash Other: fs.NewUsageValue(q.Usage - q.UsageInDrive), // other usage e.g. gmail in drive } if q.Limit > 0 { usage.Total = fs.NewUsageValue(q.Limit) // quota of bytes that can be used usage.Free = fs.NewUsageValue(q.Limit - q.Usage) // bytes which can be uploaded before reaching the quota } return usage, nil } // Move src to this remote using server-side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { var srcObj *baseObject ext := "" switch src := src.(type) { case *Object: srcObj = &src.baseObject case *documentObject: srcObj, ext = &src.baseObject, src.ext() case *linkObject: srcObj, ext = &src.baseObject, src.ext() default: fs.Debugf(src, "Can't move - not same remote type") return nil, fs.ErrorCantMove } if ext != "" { if !strings.HasSuffix(remote, ext) { fs.Debugf(src, "Can't move - not same document type") return nil, fs.ErrorCantMove } remote = remote[:len(remote)-len(ext)] } _, srcParentID, err := srcObj.fs.dirCache.FindPath(ctx, src.Remote(), false) if err != nil { return nil, err } srcParentID = actualID(srcParentID) // Temporary Object under construction dstInfo, err := f.createFileInfo(ctx, remote, src.ModTime(ctx)) if err != nil { return nil, err } dstParents := strings.Join(dstInfo.Parents, ",") dstInfo.Parents = nil // Adjust metadata if required updateMetadata, err := f.fetchAndUpdateMetadata(ctx, src, fs.MetadataAsOpenOptions(ctx), dstInfo, true) if err != nil { return nil, err } // Do the move var info *drive.File err = f.pacer.Call(func() (bool, error) { info, err = f.svc.Files.Update(shortcutID(srcObj.id), dstInfo). RemoveParents(srcParentID). AddParents(dstParents). Fields(f.getFileFields(ctx)). SupportsAllDrives(true). Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return nil, err } // Finalise metadata err = updateMetadata(ctx, info) if err != nil { return nil, err } return f.newObjectWithInfo(ctx, remote, info) } // PublicLink adds a "readable by anyone with link" permission on the given file or folder. func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (link string, err error) { id, err := f.dirCache.FindDir(ctx, remote, false) if err == nil { fs.Debugf(f, "attempting to share directory '%s'", remote) id = shortcutID(id) } else { fs.Debugf(f, "attempting to share single file '%s'", remote) o, err := f.NewObject(ctx, remote) if err != nil { return "", err } id = shortcutID(o.(fs.IDer).ID()) } permission := &drive.Permission{ AllowFileDiscovery: false, Role: "reader", Type: "anyone", } err = f.pacer.Call(func() (bool, error) { // TODO: On TeamDrives this might fail if lacking permissions to change ACLs. // Need to either check `canShare` attribute on the object or see if a sufficient permission is already present. _, err = f.svc.Permissions.Create(id, permission). Fields(""). SupportsAllDrives(true). Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return "", err } return fmt.Sprintf("https://drive.google.com/open?id=%s", id), nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } srcID, srcDirectoryID, srcLeaf, dstDirectoryID, dstLeaf, err := f.dirCache.DirMove(ctx, srcFs.dirCache, srcFs.root, srcRemote, f.root, dstRemote) if err != nil { return err } _ = srcLeaf dstDirectoryID = actualID(dstDirectoryID) srcDirectoryID = actualID(srcDirectoryID) // Do the move patch := drive.File{ Name: dstLeaf, } err = f.pacer.Call(func() (bool, error) { _, err = f.svc.Files.Update(shortcutID(srcID), &patch). RemoveParents(srcDirectoryID). AddParents(dstDirectoryID). Fields(""). SupportsAllDrives(true). Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return err } srcFs.dirCache.FlushDir(srcRemote) return nil } // ChangeNotify calls the passed function with a path that has had changes. // If the implementation uses polling, it should adhere to the given interval. // // Automatically restarts itself in case of unexpected behavior of the remote. // // Close the returned channel to stop being notified. func (f *Fs) ChangeNotify(ctx context.Context, notifyFunc func(string, fs.EntryType), pollIntervalChan <-chan time.Duration) { go func() { // get the StartPageToken early so all changes from now on get processed startPageToken, err := f.changeNotifyStartPageToken(ctx) if err != nil { fs.Infof(f, "Failed to get StartPageToken: %s", err) } var ticker *time.Ticker var tickerC <-chan time.Time for { select { case pollInterval, ok := <-pollIntervalChan: if !ok { if ticker != nil { ticker.Stop() } return } if ticker != nil { ticker.Stop() ticker, tickerC = nil, nil } if pollInterval != 0 { ticker = time.NewTicker(pollInterval) tickerC = ticker.C } case <-tickerC: if startPageToken == "" { startPageToken, err = f.changeNotifyStartPageToken(ctx) if err != nil { fs.Infof(f, "Failed to get StartPageToken: %s", err) continue } } fs.Debugf(f, "Checking for changes on remote") startPageToken, err = f.changeNotifyRunner(ctx, notifyFunc, startPageToken) if err != nil { fs.Infof(f, "Change notify listener failure: %s", err) } } } }() } func (f *Fs) changeNotifyStartPageToken(ctx context.Context) (pageToken string, err error) { var startPageToken *drive.StartPageToken err = f.pacer.Call(func() (bool, error) { changes := f.svc.Changes.GetStartPageToken().SupportsAllDrives(true) if f.isTeamDrive { changes.DriveId(f.opt.TeamDriveID) } startPageToken, err = changes.Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return } return startPageToken.StartPageToken, nil } func (f *Fs) changeNotifyRunner(ctx context.Context, notifyFunc func(string, fs.EntryType), startPageToken string) (newStartPageToken string, err error) { pageToken := startPageToken for { var changeList *drive.ChangeList err = f.pacer.Call(func() (bool, error) { changesCall := f.svc.Changes.List(pageToken). Fields("nextPageToken,newStartPageToken,changes(fileId,file(name,parents,mimeType))") if f.opt.ListChunk > 0 { changesCall.PageSize(f.opt.ListChunk) } changesCall.SupportsAllDrives(true) changesCall.IncludeItemsFromAllDrives(true) if f.isTeamDrive { changesCall.DriveId(f.opt.TeamDriveID) } // If using appDataFolder then need to add Spaces if f.rootFolderID == "appDataFolder" { changesCall.Spaces("appDataFolder") } changesCall.RestrictToMyDrive(!f.opt.SharedWithMe) changeList, err = changesCall.Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return } type entryType struct { path string entryType fs.EntryType } var pathsToClear []entryType for _, change := range changeList.Changes { // find the previous path if path, ok := f.dirCache.GetInv(change.FileId); ok { if change.File != nil && change.File.MimeType != driveFolderType { pathsToClear = append(pathsToClear, entryType{path: path, entryType: fs.EntryObject}) } else { pathsToClear = append(pathsToClear, entryType{path: path, entryType: fs.EntryDirectory}) } } // find the new path if change.File != nil { change.File.Name = f.opt.Enc.ToStandardName(change.File.Name) changeType := fs.EntryDirectory if change.File.MimeType != driveFolderType { changeType = fs.EntryObject } // translate the parent dir of this object if len(change.File.Parents) > 0 { for _, parent := range change.File.Parents { if parentPath, ok := f.dirCache.GetInv(parent); ok { // and append the drive file name to compute the full file name newPath := path.Join(parentPath, change.File.Name) // this will now clear the actual file too pathsToClear = append(pathsToClear, entryType{path: newPath, entryType: changeType}) } } } else { // a true root object that is changed pathsToClear = append(pathsToClear, entryType{path: change.File.Name, entryType: changeType}) } } } visitedPaths := make(map[string]struct{}) for _, entry := range pathsToClear { if _, ok := visitedPaths[entry.path]; ok { continue } visitedPaths[entry.path] = struct{}{} notifyFunc(entry.path, entry.entryType) } switch { case changeList.NewStartPageToken != "": return changeList.NewStartPageToken, nil case changeList.NextPageToken != "": pageToken = changeList.NextPageToken default: return } } } // DirCacheFlush resets the directory cache - used in testing as an // optional interface func (f *Fs) DirCacheFlush() { f.dirCache.ResetRoot() } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.NewHashSet(hash.MD5, hash.SHA1, hash.SHA256) } func (f *Fs) changeChunkSize(chunkSizeString string) (err error) { chunkSizeInt, err := strconv.ParseInt(chunkSizeString, 10, 64) if err != nil { return fmt.Errorf("couldn't convert chunk size to int: %w", err) } chunkSize := fs.SizeSuffix(chunkSizeInt) if chunkSize == f.opt.ChunkSize { return nil } err = checkUploadChunkSize(chunkSize) if err == nil { f.opt.ChunkSize = chunkSize } return err } func (f *Fs) changeServiceAccountFile(ctx context.Context, file string) (err error) { fs.Debugf(nil, "Changing Service Account File from %s to %s", f.opt.ServiceAccountFile, file) if file == f.opt.ServiceAccountFile { return nil } oldSvc := f.svc oldv2Svc := f.v2Svc oldOAuthClient := f.client oldFile := f.opt.ServiceAccountFile oldCredentials := f.opt.ServiceAccountCredentials defer func() { // Undo all the changes instead of doing selective undo's if err != nil { f.svc = oldSvc f.v2Svc = oldv2Svc f.client = oldOAuthClient f.opt.ServiceAccountFile = oldFile f.opt.ServiceAccountCredentials = oldCredentials } }() f.opt.ServiceAccountFile = file f.opt.ServiceAccountCredentials = "" oAuthClient, err := createOAuthClient(ctx, &f.opt, f.name, f.m) if err != nil { return fmt.Errorf("drive: failed when making oauth client: %w", err) } f.client = oAuthClient f.svc, err = drive.NewService(context.Background(), option.WithHTTPClient(f.client)) if err != nil { return fmt.Errorf("couldn't create Drive client: %w", err) } if f.opt.V2DownloadMinSize >= 0 { f.v2Svc, err = drive_v2.NewService(context.Background(), option.WithHTTPClient(f.client)) if err != nil { return fmt.Errorf("couldn't create Drive v2 client: %w", err) } } return nil } // Create a shortcut from (f, srcPath) to (dstFs, dstPath) // // Will not overwrite existing files func (f *Fs) makeShortcut(ctx context.Context, srcPath string, dstFs *Fs, dstPath string) (o fs.Object, err error) { srcFs := f srcPath = strings.Trim(srcPath, "/") dstPath = strings.Trim(dstPath, "/") if dstPath == "" { return nil, errors.New("shortcut destination can't be root directory") } // Find source var srcID string isDir := false if srcPath == "" { // source is root directory srcID, err = f.dirCache.RootID(ctx, false) if err != nil { return nil, err } isDir = true } else if srcObj, err := srcFs.NewObject(ctx, srcPath); err != nil { if err != fs.ErrorIsDir { return nil, fmt.Errorf("can't find source: %w", err) } // source was a directory srcID, err = srcFs.dirCache.FindDir(ctx, srcPath, false) if err != nil { return nil, fmt.Errorf("failed to find source dir: %w", err) } isDir = true } else { // source was a file srcID = srcObj.(*Object).id } srcID = actualID(srcID) // link to underlying object not to shortcut // Find destination _, err = dstFs.NewObject(ctx, dstPath) if err != fs.ErrorObjectNotFound { if err == nil { err = errors.New("existing file") } else if err == fs.ErrorIsDir { err = errors.New("existing directory") } return nil, fmt.Errorf("not overwriting shortcut target: %w", err) } // Create destination shortcut createInfo, err := dstFs.createFileInfo(ctx, dstPath, time.Now()) if err != nil { return nil, fmt.Errorf("shortcut destination failed: %w", err) } createInfo.MimeType = shortcutMimeType createInfo.ShortcutDetails = &drive.FileShortcutDetails{ TargetId: srcID, } var info *drive.File err = dstFs.pacer.Call(func() (bool, error) { info, err = dstFs.svc.Files.Create(createInfo). Fields(partialFields). SupportsAllDrives(true). KeepRevisionForever(dstFs.opt.KeepRevisionForever). Context(ctx).Do() return dstFs.shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("shortcut creation failed: %w", err) } if isDir { return nil, nil } return dstFs.newObjectWithInfo(ctx, dstPath, info) } // List all team drives func (f *Fs) listTeamDrives(ctx context.Context) (drives []*drive.Drive, err error) { drives = []*drive.Drive{} listTeamDrives := f.svc.Drives.List().PageSize(100) var defaultFs Fs // default Fs with default Options for { var teamDrives *drive.DriveList err = f.pacer.Call(func() (bool, error) { teamDrives, err = listTeamDrives.Context(ctx).Do() return defaultFs.shouldRetry(ctx, err) }) if err != nil { return drives, fmt.Errorf("listing Team Drives failed: %w", err) } drives = append(drives, teamDrives.Drives...) if teamDrives.NextPageToken == "" { break } listTeamDrives.PageToken(teamDrives.NextPageToken) } return drives, nil } type unTrashResult struct { Untrashed int Errors int } func (r unTrashResult) Error() string { return fmt.Sprintf("%d errors while untrashing - see log", r.Errors) } // Restore the trashed files from dir, directoryID recursing if needed func (f *Fs) unTrash(ctx context.Context, dir string, directoryID string, recurse bool) (r unTrashResult, err error) { directoryID = actualID(directoryID) fs.Debugf(dir, "finding trash to restore in directory %q", directoryID) _, err = f.list(ctx, []string{directoryID}, "", false, false, f.opt.TrashedOnly, true, func(item *drive.File) bool { remote := path.Join(dir, item.Name) if item.ExplicitlyTrashed { fs.Infof(remote, "restoring %q", item.Id) if operations.SkipDestructive(ctx, remote, "restore") { return false } update := drive.File{ ForceSendFields: []string{"Trashed"}, // necessary to set false value Trashed: false, } err := f.pacer.Call(func() (bool, error) { _, err := f.svc.Files.Update(item.Id, &update). SupportsAllDrives(true). Fields("trashed"). Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { err = fmt.Errorf("failed to restore: %w", err) r.Errors++ fs.Errorf(remote, "%v", err) } else { r.Untrashed++ } } if recurse && item.MimeType == "application/vnd.google-apps.folder" { if !isShortcutID(item.Id) { rNew, _ := f.unTrash(ctx, remote, item.Id, recurse) r.Untrashed += rNew.Untrashed r.Errors += rNew.Errors } } return false }) if err != nil { err = fmt.Errorf("failed to list directory: %w", err) r.Errors++ fs.Errorf(dir, "%v", err) } if r.Errors != 0 { return r, r } return r, nil } // Untrash dir func (f *Fs) unTrashDir(ctx context.Context, dir string, recurse bool) (r unTrashResult, err error) { directoryID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { r.Errors++ return r, err } return f.unTrash(ctx, dir, directoryID, true) } // copy or move file with id to dest func (f *Fs) copyOrMoveID(ctx context.Context, operation string, id, dest string) (err error) { info, err := f.getFile(ctx, id, f.getFileFields(ctx)) if err != nil { return fmt.Errorf("couldn't find id: %w", err) } if info.MimeType == driveFolderType { return fmt.Errorf("can't %s directory use: rclone %s --drive-root-folder-id %s %s %s", operation, operation, id, fs.ConfigString(f), dest) } info.Name = f.opt.Enc.ToStandardName(info.Name) o, err := f.newObjectWithInfo(ctx, info.Name, info) if err != nil { return err } destDir, destLeaf, err := fspath.Split(dest) if err != nil { return err } if destLeaf == "" { destLeaf = path.Base(o.Remote()) } if destDir == "" { destDir = "." } dstFs, err := cache.Get(ctx, destDir) if err != nil { return err } var opErr error if operation == "moveid" { _, opErr = operations.Move(ctx, dstFs, nil, destLeaf, o) } else { _, opErr = operations.Copy(ctx, dstFs, nil, destLeaf, o) } if opErr != nil { return fmt.Errorf("%s failed: %w", operation, opErr) } return nil } // Run the drive query calling fn on each entry found func (f *Fs) queryFn(ctx context.Context, query string, fn func(*drive.File)) (err error) { list := f.svc.Files.List() if query != "" { list.Q(query) } if f.opt.ListChunk > 0 { list.PageSize(f.opt.ListChunk) } list.SupportsAllDrives(true) list.IncludeItemsFromAllDrives(true) if f.isTeamDrive && !f.opt.SharedWithMe { list.DriveId(f.opt.TeamDriveID) list.Corpora("drive") } // If using appDataFolder then need to add Spaces if f.rootFolderID == "appDataFolder" { list.Spaces("appDataFolder") } fields := fmt.Sprintf("files(%s),nextPageToken,incompleteSearch", f.getFileFields(ctx)) for { var files *drive.FileList err = f.pacer.Call(func() (bool, error) { files, err = list.Fields(googleapi.Field(fields)).Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("failed to execute query: %w", err) } if files.IncompleteSearch { fs.Errorf(f, "search result INCOMPLETE") } for _, item := range files.Files { fn(item) } if files.NextPageToken == "" { break } list.PageToken(files.NextPageToken) } return nil } // Run the drive query returning the entries found func (f *Fs) query(ctx context.Context, query string) (entries []*drive.File, err error) { var results []*drive.File err = f.queryFn(ctx, query, func(item *drive.File) { results = append(results, item) }) if err != nil { return nil, err } return results, nil } // Rescue, list or delete orphaned files func (f *Fs) rescue(ctx context.Context, dirID string, delete bool) (err error) { return f.queryFn(ctx, "'me' in owners and trashed=false", func(item *drive.File) { if len(item.Parents) != 0 { return } // Have found an orphaned entry if delete { fs.Infof(item.Name, "Deleting orphan %q into trash", item.Id) err = f.delete(ctx, item.Id, true) if err != nil { fs.Errorf(item.Name, "Failed to delete orphan %q: %v", item.Id, err) } } else if dirID == "" { operations.SyncPrintf("%q, %q\n", item.Name, item.Id) } else { fs.Infof(item.Name, "Rescuing orphan %q", item.Id) err = f.pacer.Call(func() (bool, error) { _, err = f.svc.Files.Update(item.Id, nil). AddParents(dirID). Fields(f.getFileFields(ctx)). SupportsAllDrives(true). Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { fs.Errorf(item.Name, "Failed to rescue orphan %q: %v", item.Id, err) } } }) } var commandHelp = []fs.CommandHelp{{ Name: "get", Short: "Get command for fetching the drive config parameters", Long: `This is a get command which will be used to fetch the various drive config parameters Usage Examples: rclone backend get drive: [-o service_account_file] [-o chunk_size] rclone rc backend/command command=get fs=drive: [-o service_account_file] [-o chunk_size] `, Opts: map[string]string{ "chunk_size": "show the current upload chunk size", "service_account_file": "show the current service account file", }, }, { Name: "set", Short: "Set command for updating the drive config parameters", Long: `This is a set command which will be used to update the various drive config parameters Usage Examples: rclone backend set drive: [-o service_account_file=sa.json] [-o chunk_size=67108864] rclone rc backend/command command=set fs=drive: [-o service_account_file=sa.json] [-o chunk_size=67108864] `, Opts: map[string]string{ "chunk_size": "update the current upload chunk size", "service_account_file": "update the current service account file", }, }, { Name: "shortcut", Short: "Create shortcuts from files or directories", Long: `This command creates shortcuts from files or directories. Usage: rclone backend shortcut drive: source_item destination_shortcut rclone backend shortcut drive: source_item -o target=drive2: destination_shortcut In the first example this creates a shortcut from the "source_item" which can be a file or a directory to the "destination_shortcut". The "source_item" and the "destination_shortcut" should be relative paths from "drive:" In the second example this creates a shortcut from the "source_item" relative to "drive:" to the "destination_shortcut" relative to "drive2:". This may fail with a permission error if the user authenticated with "drive2:" can't read files from "drive:". `, Opts: map[string]string{ "target": "optional target remote for the shortcut destination", }, }, { Name: "drives", Short: "List the Shared Drives available to this account", Long: `This command lists the Shared Drives (Team Drives) available to this account. Usage: rclone backend [-o config] drives drive: This will return a JSON list of objects like this [ { "id": "0ABCDEF-01234567890", "kind": "drive#teamDrive", "name": "My Drive" }, { "id": "0ABCDEFabcdefghijkl", "kind": "drive#teamDrive", "name": "Test Drive" } ] With the -o config parameter it will output the list in a format suitable for adding to a config file to make aliases for all the drives found and a combined drive. [My Drive] type = alias remote = drive,team_drive=0ABCDEF-01234567890,root_folder_id=: [Test Drive] type = alias remote = drive,team_drive=0ABCDEFabcdefghijkl,root_folder_id=: [AllDrives] type = combine upstreams = "My Drive=My Drive:" "Test Drive=Test Drive:" Adding this to the rclone config file will cause those team drives to be accessible with the aliases shown. Any illegal characters will be substituted with "_" and duplicate names will have numbers suffixed. It will also add a remote called AllDrives which shows all the shared drives combined into one directory tree. `, }, { Name: "untrash", Short: "Untrash files and directories", Long: `This command untrashes all the files and directories in the directory passed in recursively. Usage: This takes an optional directory to trash which make this easier to use via the API. rclone backend untrash drive:directory rclone backend --interactive untrash drive:directory subdir Use the --interactive/-i or --dry-run flag to see what would be restored before restoring it. Result: { "Untrashed": 17, "Errors": 0 } `, }, { Name: "copyid", Short: "Copy files by ID", Long: `This command copies files by ID Usage: rclone backend copyid drive: ID path rclone backend copyid drive: ID1 path1 ID2 path2 It copies the drive file with ID given to the path (an rclone path which will be passed internally to rclone copyto). The ID and path pairs can be repeated. The path should end with a / to indicate copy the file as named to this directory. If it doesn't end with a / then the last path component will be used as the file name. If the destination is a drive backend then server-side copying will be attempted if possible. Use the --interactive/-i or --dry-run flag to see what would be copied before copying. `, }, { Name: "moveid", Short: "Move files by ID", Long: `This command moves files by ID Usage: rclone backend moveid drive: ID path rclone backend moveid drive: ID1 path1 ID2 path2 It moves the drive file with ID given to the path (an rclone path which will be passed internally to rclone moveto). The path should end with a / to indicate move the file as named to this directory. If it doesn't end with a / then the last path component will be used as the file name. If the destination is a drive backend then server-side moving will be attempted if possible. Use the --interactive/-i or --dry-run flag to see what would be moved beforehand. `, }, { Name: "exportformats", Short: "Dump the export formats for debug purposes", }, { Name: "importformats", Short: "Dump the import formats for debug purposes", }, { Name: "query", Short: "List files using Google Drive query language", Long: `This command lists files based on a query Usage: rclone backend query drive: query The query syntax is documented at [Google Drive Search query terms and operators](https://developers.google.com/drive/api/guides/ref-search-terms). For example: rclone backend query drive: "'0ABc9DEFGHIJKLMNop0QRatUVW3X' in parents and name contains 'foo'" If the query contains literal ' or \ characters, these need to be escaped with \ characters. "'" becomes "\'" and "\" becomes "\\\", for example to match a file named "foo ' \.txt": rclone backend query drive: "name = 'foo \' \\\.txt'" The result is a JSON array of matches, for example: [ { "createdTime": "2017-06-29T19:58:28.537Z", "id": "0AxBe_CDEF4zkGHI4d0FjYko2QkD", "md5Checksum": "68518d16be0c6fbfab918be61d658032", "mimeType": "text/plain", "modifiedTime": "2024-02-02T10:40:02.874Z", "name": "foo ' \\.txt", "parents": [ "0BxAe_BCDE4zkFGZpcWJGek0xbzC" ], "resourceKey": "0-ABCDEFGHIXJQpIGqBJq3MC", "sha1Checksum": "8f284fa768bfb4e45d076a579ab3905ab6bfa893", "size": "311", "webViewLink": "https://drive.google.com/file/d/0AxBe_CDEF4zkGHI4d0FjYko2QkD/view?usp=drivesdk\u0026resourcekey=0-ABCDEFGHIXJQpIGqBJq3MC" } ]`, }, { Name: "rescue", Short: "Rescue or delete any orphaned files", Long: `This command rescues or deletes any orphaned files or directories. Sometimes files can get orphaned in Google Drive. This means that they are no longer in any folder in Google Drive. This command finds those files and either rescues them to a directory you specify or deletes them. Usage: This can be used in 3 ways. First, list all orphaned files rclone backend rescue drive: Second rescue all orphaned files to the directory indicated rclone backend rescue drive: "relative/path/to/rescue/directory" e.g. To rescue all orphans to a directory called "Orphans" in the top level rclone backend rescue drive: Orphans Third delete all orphaned files to the trash rclone backend rescue drive: -o delete `, }} // Command the backend to run a named command // // The command run is name // args may be used to read arguments from // opts may be used to read optional arguments from // // The result should be capable of being JSON encoded // If it is a string or a []string it will be shown to the user // otherwise it will be JSON encoded and shown to the user like that func (f *Fs) Command(ctx context.Context, name string, arg []string, opt map[string]string) (out any, err error) { switch name { case "get": out := make(map[string]string) if _, ok := opt["service_account_file"]; ok { out["service_account_file"] = f.opt.ServiceAccountFile } if _, ok := opt["chunk_size"]; ok { out["chunk_size"] = f.opt.ChunkSize.String() } return out, nil case "set": out := make(map[string]map[string]string) if serviceAccountFile, ok := opt["service_account_file"]; ok { serviceAccountMap := make(map[string]string) serviceAccountMap["previous"] = f.opt.ServiceAccountFile if err = f.changeServiceAccountFile(ctx, serviceAccountFile); err != nil { return out, err } f.m.Set("service_account_file", serviceAccountFile) serviceAccountMap["current"] = f.opt.ServiceAccountFile out["service_account_file"] = serviceAccountMap } if chunkSize, ok := opt["chunk_size"]; ok { chunkSizeMap := make(map[string]string) chunkSizeMap["previous"] = f.opt.ChunkSize.String() if err = f.changeChunkSize(chunkSize); err != nil { return out, err } chunkSizeString := f.opt.ChunkSize.String() f.m.Set("chunk_size", chunkSizeString) chunkSizeMap["current"] = chunkSizeString out["chunk_size"] = chunkSizeMap } return out, nil case "shortcut": if len(arg) != 2 { return nil, errors.New("need exactly 2 arguments") } dstFs := f target, ok := opt["target"] if ok { targetFs, err := cache.Get(ctx, target) if err != nil { return nil, fmt.Errorf("couldn't find target: %w", err) } dstFs, ok = targetFs.(*Fs) if !ok { return nil, errors.New("target is not a drive backend") } } return f.makeShortcut(ctx, arg[0], dstFs, arg[1]) case "drives": drives, err := f.listTeamDrives(ctx) if err != nil { return nil, err } if _, ok := opt["config"]; ok { lines := []string{} upstreams := []string{} names := make(map[string]struct{}, len(drives)) for i, drive := range drives { name := fspath.MakeConfigName(drive.Name) for { if _, found := names[name]; !found { break } name += fmt.Sprintf("-%d", i) } names[name] = struct{}{} lines = append(lines, "") lines = append(lines, fmt.Sprintf("[%s]", name)) lines = append(lines, "type = alias") lines = append(lines, fmt.Sprintf("remote = %s,team_drive=%s,root_folder_id=:", f.name, drive.Id)) upstreams = append(upstreams, fmt.Sprintf(`"%s=%s:"`, name, name)) } lines = append(lines, "") lines = append(lines, "[AllDrives]") lines = append(lines, "type = combine") lines = append(lines, fmt.Sprintf("upstreams = %s", strings.Join(upstreams, " "))) return lines, nil } return drives, nil case "untrash": dir := "" if len(arg) > 0 { dir = arg[0] } return f.unTrashDir(ctx, dir, true) case "copyid", "moveid": if len(arg)%2 != 0 { return nil, errors.New("need an even number of arguments") } for len(arg) > 0 { id, dest := arg[0], arg[1] arg = arg[2:] err = f.copyOrMoveID(ctx, name, id, dest) if err != nil { return nil, fmt.Errorf("failed %s %q to %q: %w", name, id, dest, err) } } return nil, nil case "exportformats": return f.exportFormats(ctx), nil case "importformats": return f.importFormats(ctx), nil case "query": if len(arg) == 1 { query := arg[0] results, err := f.query(ctx, query) if err != nil { return nil, fmt.Errorf("failed to execute query: %q, error: %w", query, err) } return results, nil } return nil, errors.New("need a query argument") case "rescue": dirID := "" _, delete := opt["delete"] if len(arg) == 0 { // no arguments - list only } else if !delete && len(arg) == 1 { dir := arg[0] dirID, err = f.dirCache.FindDir(ctx, dir, true) if err != nil { return nil, fmt.Errorf("failed to find or create rescue directory %q: %w", dir, err) } fs.Infof(f, "Rescuing orphans into %q", dir) } else { return nil, errors.New("syntax error: need 0 or 1 args or -o delete") } return nil, f.rescue(ctx, dirID, delete) default: return nil, fs.ErrorCommandNotFound } } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *baseObject) Fs() fs.Info { return o.fs } // Return a string version func (o *baseObject) String() string { return o.remote } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *baseObject) Remote() string { return o.remote } // Hash returns the Md5sum of an object returning a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if t == hash.MD5 { return o.md5sum, nil } if t == hash.SHA1 { return o.sha1sum, nil } if t == hash.SHA256 { return o.sha256sum, nil } return "", hash.ErrUnsupported } func (o *baseObject) Hash(ctx context.Context, t hash.Type) (string, error) { if t != hash.MD5 && t != hash.SHA1 && t != hash.SHA256 { return "", hash.ErrUnsupported } return "", nil } // Size returns the size of an object in bytes func (o *baseObject) Size() int64 { return o.bytes } // getRemoteInfoWithExport returns a drive.File and the export settings for the remote func (f *Fs) getRemoteInfoWithExport(ctx context.Context, remote string) ( info *drive.File, extension, exportName, exportMimeType string, isDocument bool, err error, ) { leaf, directoryID, err := f.dirCache.FindPath(ctx, remote, false) if err != nil { if err == fs.ErrorDirNotFound { return nil, "", "", "", false, fs.ErrorObjectNotFound } return nil, "", "", "", false, err } directoryID = actualID(directoryID) found, err := f.list(ctx, []string{directoryID}, leaf, false, false, f.opt.TrashedOnly, false, func(item *drive.File) bool { if !f.opt.SkipGdocs { extension, exportName, exportMimeType, isDocument = f.findExportFormat(ctx, item) if exportName == leaf { info = item return true } if isDocument { return false } } if item.Name == leaf { info = item return true } return false }) if err != nil { return nil, "", "", "", false, err } if !found { return nil, "", "", "", false, fs.ErrorObjectNotFound } return } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers func (o *baseObject) ModTime(ctx context.Context) time.Time { modTime, err := time.Parse(timeFormatIn, o.modifiedDate) if err != nil { fs.Debugf(o, "Failed to read mtime from object: %v", err) return time.Now() } return modTime } // SetModTime sets the modification time of the drive fs object func (o *baseObject) SetModTime(ctx context.Context, modTime time.Time) error { // New metadata updateInfo := &drive.File{ ModifiedTime: modTime.Format(timeFormatOut), } // Set modified date var info *drive.File err := o.fs.pacer.Call(func() (bool, error) { var err error info, err = o.fs.svc.Files.Update(actualID(o.id), updateInfo). Fields(partialFields). SupportsAllDrives(true). Context(ctx).Do() return o.fs.shouldRetry(ctx, err) }) if err != nil { return err } // Update info from read data o.modifiedDate = info.ModifiedTime return nil } // Storable returns a boolean as to whether this object is storable func (o *baseObject) Storable() bool { return true } // addResourceKey adds a X-Goog-Drive-Resource-Keys header for this // object if required. func (o *baseObject) addResourceKey(header http.Header) { if o.resourceKey != nil { header.Add("X-Goog-Drive-Resource-Keys", fmt.Sprintf("%s/%s", o.id, *o.resourceKey)) } } // httpResponse gets an http.Response object for the object // using the url and method passed in func (o *baseObject) httpResponse(ctx context.Context, url, method string, options []fs.OpenOption) (req *http.Request, res *http.Response, err error) { if url == "" { return nil, nil, errors.New("forbidden to download - check sharing permission") } req, err = http.NewRequestWithContext(ctx, method, url, nil) if err != nil { return req, nil, err } fs.OpenOptionAddHTTPHeaders(req.Header, options) if o.bytes == 0 { // Don't supply range requests for 0 length objects as they always fail delete(req.Header, "Range") } o.addResourceKey(req.Header) err = o.fs.pacer.Call(func() (bool, error) { res, err = o.fs.client.Do(req) if err == nil { err = googleapi.CheckResponse(res) if err != nil { _ = res.Body.Close() // ignore error } } return o.fs.shouldRetry(ctx, err) }) if err != nil { return req, nil, err } return req, res, nil } // openDocumentFile represents a documentObject open for reading. // Updates the object size after read successfully. type openDocumentFile struct { o *documentObject // Object we are reading for in io.ReadCloser // reading from here bytes int64 // number of bytes read on this connection eof bool // whether we have read end of file errored bool // whether we have encountered an error during reading } // Read bytes from the object - see io.Reader func (file *openDocumentFile) Read(p []byte) (n int, err error) { n, err = file.in.Read(p) file.bytes += int64(n) if err != nil && err != io.EOF { file.errored = true } if err == io.EOF { file.eof = true } return } // Close the object and update bytes read func (file *openDocumentFile) Close() (err error) { // If end of file, update bytes read if file.eof && !file.errored { fs.Debugf(file.o, "Updating size of doc after download to %v", file.bytes) file.o.bytes = file.bytes } return file.in.Close() } // Check it satisfies the interfaces var _ io.ReadCloser = (*openDocumentFile)(nil) // Checks to see if err is a googleapi.Error with of type what func isGoogleError(err error, what string) bool { if gerr, ok := err.(*googleapi.Error); ok { for _, error := range gerr.Errors { if error.Reason == what { return true } } } return false } // open a url for reading func (o *baseObject) open(ctx context.Context, url string, options ...fs.OpenOption) (in io.ReadCloser, err error) { _, res, err := o.httpResponse(ctx, url, "GET", options) if err != nil { if isGoogleError(err, "cannotDownloadAbusiveFile") { if o.fs.opt.AcknowledgeAbuse { // Retry acknowledging abuse if strings.ContainsRune(url, '?') { url += "&" } else { url += "?" } url += "acknowledgeAbuse=true" _, res, err = o.httpResponse(ctx, url, "GET", options) } else { err = fmt.Errorf("use the --drive-acknowledge-abuse flag to download this file: %w", err) } } if err != nil { return nil, fmt.Errorf("open file failed: %w", err) } } return res.Body, nil } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { if o.mimeType == shortcutMimeTypeDangling { return nil, errors.New("can't read dangling shortcut") } if o.v2Download { var v2File *drive_v2.File err = o.fs.pacer.Call(func() (bool, error) { v2File, err = o.fs.v2Svc.Files.Get(actualID(o.id)). Fields("downloadUrl"). SupportsAllDrives(true). Context(ctx).Do() return o.fs.shouldRetry(ctx, err) }) if err == nil { fs.Debugf(o, "Using v2 download: %v", v2File.DownloadUrl) o.url = v2File.DownloadUrl o.v2Download = false } } return o.baseObject.open(ctx, o.url, options...) } func (o *documentObject) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { // Update the size with what we are reading as it can change from // the HEAD in the listing to this GET. This stops rclone marking // the transfer as corrupted. var offset, end int64 = 0, -1 newOptions := options[:0] for _, o := range options { // Note that Range requests don't work on Google docs: // https://developers.google.com/drive/v3/web/manage-downloads#partial_download // So do a subset of them manually switch x := o.(type) { case *fs.RangeOption: offset, end = x.Start, x.End case *fs.SeekOption: offset, end = x.Offset, -1 default: newOptions = append(newOptions, o) } } options = newOptions if offset != 0 { return nil, errors.New("partial downloads are not supported while exporting Google Documents") } in, err = o.baseObject.open(ctx, o.url, options...) if in != nil { in = &openDocumentFile{o: o, in: in} } if end >= 0 { in = readers.NewLimitedReadCloser(in, end-offset+1) } return } func (o *linkObject) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { var offset, limit int64 = 0, -1 data := o.content for _, option := range options { switch x := option.(type) { case *fs.SeekOption: offset = x.Offset case *fs.RangeOption: offset, limit = x.Decode(int64(len(data))) default: if option.Mandatory() { fs.Logf(o, "Unsupported mandatory option: %v", option) } } } if l := int64(len(data)); offset > l { offset = l } data = data[offset:] if limit != -1 && limit < int64(len(data)) { data = data[:limit] } return io.NopCloser(bytes.NewReader(data)), nil } func (o *baseObject) update(ctx context.Context, updateInfo *drive.File, uploadMimeType string, in io.Reader, src fs.ObjectInfo, ) (info *drive.File, err error) { // Make the API request to upload metadata and file data. size := src.Size() if size >= 0 && size < int64(o.fs.opt.UploadCutoff) { // Don't retry, return a retry error instead err = o.fs.pacer.CallNoRetry(func() (bool, error) { info, err = o.fs.svc.Files.Update(actualID(o.id), updateInfo). Media(in, googleapi.ContentType(uploadMimeType), googleapi.ChunkSize(0)). Fields(partialFields). SupportsAllDrives(true). KeepRevisionForever(o.fs.opt.KeepRevisionForever). Context(ctx).Do() return o.fs.shouldRetry(ctx, err) }) return } // Upload the file in chunks return o.fs.Upload(ctx, in, size, uploadMimeType, o.id, o.remote, updateInfo) } // Update the already existing object // // Copy the reader into the object updating modTime and size. // // The new object may have been created if an error is returned func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { // If o is a shortcut if isShortcutID(o.id) { // Delete it first err := o.fs.delete(ctx, shortcutID(o.id), o.fs.opt.UseTrash) if err != nil { return err } // Then put the file as a new file newObj, err := o.fs.PutUnchecked(ctx, in, src, options...) if err != nil { return err } // Update the object if newO, ok := newObj.(*Object); ok { *o = *newO } else { fs.Debugf(newObj, "Failed to update object %T from new object %T", o, newObj) } return nil } srcMimeType := fs.MimeType(ctx, src) updateInfo := &drive.File{ MimeType: srcMimeType, ModifiedTime: src.ModTime(ctx).Format(timeFormatOut), } updateMetadata, err := o.fs.fetchAndUpdateMetadata(ctx, src, options, updateInfo, true) if err != nil { return err } info, err := o.baseObject.update(ctx, updateInfo, srcMimeType, in, src) if err != nil { return err } err = updateMetadata(ctx, info) if err != nil { return err } newO, err := o.fs.newObjectWithInfo(ctx, o.remote, info) if err != nil { return err } switch newO := newO.(type) { case *Object: *o = *newO default: return errors.New("object type changed by update") } return nil } func (o *documentObject) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { srcMimeType := fs.MimeType(ctx, src) importMimeType := "" updateInfo := &drive.File{ MimeType: srcMimeType, ModifiedTime: src.ModTime(ctx).Format(timeFormatOut), } if o.fs.importMimeTypes == nil || o.fs.opt.SkipGdocs { return fmt.Errorf("can't update google document type without --drive-import-formats") } importMimeType = o.fs.findImportFormat(ctx, updateInfo.MimeType) if importMimeType == "" { return fmt.Errorf("no import format found for %q", srcMimeType) } if importMimeType != o.documentMimeType { return fmt.Errorf("can't change google document type (o: %q, src: %q, import: %q)", o.documentMimeType, srcMimeType, importMimeType) } updateInfo.MimeType = importMimeType info, err := o.baseObject.update(ctx, updateInfo, srcMimeType, in, src) if err != nil { return err } remote := src.Remote() remote = remote[:len(remote)-o.extLen] newO, err := o.fs.newObjectWithInfo(ctx, remote, info) if err != nil { return err } switch newO := newO.(type) { case *documentObject: *o = *newO default: return errors.New("object type changed by update") } return nil } func (o *linkObject) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { return errors.New("cannot update link files") } // Remove an object func (o *baseObject) Remove(ctx context.Context) error { if len(o.parents) > 1 { return errors.New("can't delete safely - has multiple parents") } return o.fs.delete(ctx, shortcutID(o.id), o.fs.opt.UseTrash) } // MimeType of an Object if known, "" otherwise func (o *baseObject) MimeType(ctx context.Context) string { return o.mimeType } // ID returns the ID of the Object if known, or "" if not func (o *baseObject) ID() string { return o.id } // ParentID returns the ID of the Object parent if known, or "" if not func (o *baseObject) ParentID() string { if len(o.parents) > 0 { return o.parents[0] } return "" } // Metadata returns metadata for an object // // It should return nil if there is no Metadata func (o *baseObject) Metadata(ctx context.Context) (metadata fs.Metadata, err error) { if o.metadata != nil { return *o.metadata, nil } fs.Debugf(o, "Fetching metadata") id := actualID(o.id) info, err := o.fs.getFile(ctx, id, o.fs.getFileFields(ctx)) if err != nil { return nil, err } err = o.parseMetadata(ctx, info) if err != nil { return nil, err } return *o.metadata, nil } func (o *documentObject) ext() string { return o.baseObject.remote[len(o.baseObject.remote)-o.extLen:] } func (o *linkObject) ext() string { return o.baseObject.remote[len(o.baseObject.remote)-o.extLen:] } // Items returns the count of items in this directory or this // directory and subdirectories if known, -1 for unknown func (d *Directory) Items() int64 { return -1 } // SetMetadata sets metadata for a Directory // // It should return fs.ErrorNotImplemented if it can't set metadata func (d *Directory) SetMetadata(ctx context.Context, metadata fs.Metadata) error { info, err := d.fs.updateDir(ctx, d.id, metadata) if err != nil { return fmt.Errorf("failed to update directory info: %w", err) } // Update directory from info returned baseObject, err := d.fs.newBaseObject(ctx, d.remote, info) if err != nil { return fmt.Errorf("failed to process directory info: %w", err) } d.baseObject = baseObject return err } // Hash does nothing on a directory // // This method is implemented with the incorrect type signature to // stop the Directory type asserting to fs.Object or fs.ObjectInfo func (d *Directory) Hash() { // Does nothing } // templates for document link files const ( urlTemplate = `[InternetShortcut]{{"\r"}} URL={{ .URL }}{{"\r"}} ` weblocTemplate = ` URL {{ .URL }} ` desktopTemplate = `[Desktop Entry] Encoding=UTF-8 Name={{ .Title }} URL={{ .URL }} Icon={{ .XDGIcon }} Type=Link ` htmlTemplate = ` {{ .Title }} Loading {{ .Title }} ` ) // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.CleanUpper = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.Commander = (*Fs)(nil) _ fs.DirCacheFlusher = (*Fs)(nil) _ fs.ChangeNotifier = (*Fs)(nil) _ fs.PutUncheckeder = (*Fs)(nil) _ fs.PublicLinker = (*Fs)(nil) _ fs.ListRer = (*Fs)(nil) _ fs.MergeDirser = (*Fs)(nil) _ fs.DirSetModTimer = (*Fs)(nil) _ fs.MkdirMetadataer = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.Object = (*Object)(nil) _ fs.MimeTyper = (*Object)(nil) _ fs.IDer = (*Object)(nil) _ fs.ParentIDer = (*Object)(nil) _ fs.Metadataer = (*Object)(nil) _ fs.Object = (*documentObject)(nil) _ fs.MimeTyper = (*documentObject)(nil) _ fs.IDer = (*documentObject)(nil) _ fs.ParentIDer = (*documentObject)(nil) _ fs.Object = (*linkObject)(nil) _ fs.MimeTyper = (*linkObject)(nil) _ fs.IDer = (*linkObject)(nil) _ fs.ParentIDer = (*linkObject)(nil) _ fs.Directory = (*Directory)(nil) _ fs.SetModTimer = (*Directory)(nil) _ fs.SetMetadataer = (*Directory)(nil) _ fs.ParentIDer = (*Directory)(nil) ) rclone-v1.71.0/backend/drive/drive_internal_test.go000066400000000000000000000516371505210326400223550ustar00rootroot00000000000000package drive import ( "bytes" "context" "encoding/json" "errors" "fmt" "io" "mime" "os" "path" "path/filepath" "strings" "testing" "time" _ "github.com/rclone/rclone/backend/local" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fs/sync" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" "github.com/rclone/rclone/lib/random" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "google.golang.org/api/drive/v3" "google.golang.org/api/googleapi" ) func TestDriveScopes(t *testing.T) { for _, test := range []struct { in string want []string wantFlag bool }{ {"", []string{ "https://www.googleapis.com/auth/drive", }, false}, {" drive.file , drive.readonly", []string{ "https://www.googleapis.com/auth/drive.file", "https://www.googleapis.com/auth/drive.readonly", }, false}, {" drive.file , drive.appfolder", []string{ "https://www.googleapis.com/auth/drive.file", "https://www.googleapis.com/auth/drive.appfolder", }, true}, } { got := driveScopes(test.in) assert.Equal(t, test.want, got, test.in) gotFlag := driveScopesContainsAppFolder(got) assert.Equal(t, test.wantFlag, gotFlag, test.in) } } /* var additionalMimeTypes = map[string]string{ "application/vnd.ms-excel.sheet.macroenabled.12": ".xlsm", "application/vnd.ms-excel.template.macroenabled.12": ".xltm", "application/vnd.ms-powerpoint.presentation.macroenabled.12": ".pptm", "application/vnd.ms-powerpoint.slideshow.macroenabled.12": ".ppsm", "application/vnd.ms-powerpoint.template.macroenabled.12": ".potm", "application/vnd.ms-powerpoint": ".ppt", "application/vnd.ms-word.document.macroenabled.12": ".docm", "application/vnd.ms-word.template.macroenabled.12": ".dotm", "application/vnd.openxmlformats-officedocument.presentationml.template": ".potx", "application/vnd.openxmlformats-officedocument.spreadsheetml.template": ".xltx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template": ".dotx", "application/vnd.sun.xml.writer": ".sxw", "text/richtext": ".rtf", } */ // Load the example export formats into exportFormats for testing func TestInternalLoadExampleFormats(t *testing.T) { fetchFormatsOnce.Do(func() {}) buf, err := os.ReadFile(filepath.FromSlash("test/about.json")) var about struct { ExportFormats map[string][]string `json:"exportFormats,omitempty"` ImportFormats map[string][]string `json:"importFormats,omitempty"` } require.NoError(t, err) require.NoError(t, json.Unmarshal(buf, &about)) _exportFormats = fixMimeTypeMap(about.ExportFormats) _importFormats = fixMimeTypeMap(about.ImportFormats) } func TestInternalParseExtensions(t *testing.T) { for _, test := range []struct { in string want []string wantErr error }{ {"doc", []string{".doc"}, nil}, {" docx ,XLSX, pptx,svg,md", []string{".docx", ".xlsx", ".pptx", ".svg", ".md"}, nil}, {"docx,svg,Docx", []string{".docx", ".svg"}, nil}, {"docx,potato,docx", []string{".docx"}, errors.New(`couldn't find MIME type for extension ".potato"`)}, } { extensions, _, gotErr := parseExtensions(test.in) if test.wantErr == nil { assert.NoError(t, gotErr) } else { assert.EqualError(t, gotErr, test.wantErr.Error()) } assert.Equal(t, test.want, extensions) } // Test it is appending extensions, _, gotErr := parseExtensions("docx,svg", "docx,svg,xlsx") assert.NoError(t, gotErr) assert.Equal(t, []string{".docx", ".svg", ".xlsx"}, extensions) } func TestInternalFindExportFormat(t *testing.T) { ctx := context.Background() item := &drive.File{ Name: "file", MimeType: "application/vnd.google-apps.document", } for _, test := range []struct { extensions []string wantExtension string wantMimeType string }{ {[]string{}, "", ""}, {[]string{".pdf"}, ".pdf", "application/pdf"}, {[]string{".pdf", ".rtf", ".xls"}, ".pdf", "application/pdf"}, {[]string{".xls", ".rtf", ".pdf"}, ".rtf", "application/rtf"}, {[]string{".xls", ".csv", ".svg"}, "", ""}, } { f := new(Fs) f.exportExtensions = test.extensions gotExtension, gotFilename, gotMimeType, gotIsDocument := f.findExportFormat(ctx, item) assert.Equal(t, test.wantExtension, gotExtension) if test.wantExtension != "" { assert.Equal(t, item.Name+gotExtension, gotFilename) } else { assert.Equal(t, "", gotFilename) } assert.Equal(t, test.wantMimeType, gotMimeType) assert.Equal(t, true, gotIsDocument) } } func TestMimeTypesToExtension(t *testing.T) { for mimeType, extension := range _mimeTypeToExtension { extensions, err := mime.ExtensionsByType(mimeType) assert.NoError(t, err) assert.Contains(t, extensions, extension) } } func TestExtensionToMimeType(t *testing.T) { for mimeType, extension := range _mimeTypeToExtension { gotMimeType := mime.TypeByExtension(extension) mediatype, _, err := mime.ParseMediaType(gotMimeType) assert.NoError(t, err) assert.Equal(t, mimeType, mediatype) } } func TestExtensionsForExportFormats(t *testing.T) { if _exportFormats == nil { t.Error("exportFormats == nil") } for fromMT, toMTs := range _exportFormats { for _, toMT := range toMTs { if !isInternalMimeType(toMT) { extensions, err := mime.ExtensionsByType(toMT) assert.NoError(t, err, "invalid MIME type %q", toMT) assert.NotEmpty(t, extensions, "No extension found for %q (from: %q)", fromMT, toMT) } } } } func TestExtensionsForImportFormats(t *testing.T) { t.Skip() if _importFormats == nil { t.Error("_importFormats == nil") } for fromMT := range _importFormats { if !isInternalMimeType(fromMT) { extensions, err := mime.ExtensionsByType(fromMT) assert.NoError(t, err, "invalid MIME type %q", fromMT) assert.NotEmpty(t, extensions, "No extension found for %q", fromMT) } } } func (f *Fs) InternalTestShouldRetry(t *testing.T) { ctx := context.Background() gatewayTimeout := googleapi.Error{ Code: 503, } timeoutRetry, timeoutError := f.shouldRetry(ctx, &gatewayTimeout) assert.True(t, timeoutRetry) assert.Equal(t, &gatewayTimeout, timeoutError) generic403 := googleapi.Error{ Code: 403, } rLEItem := googleapi.ErrorItem{ Reason: "rateLimitExceeded", Message: "User rate limit exceeded.", } generic403.Errors = append(generic403.Errors, rLEItem) oldStopUpload := f.opt.StopOnUploadLimit oldStopDownload := f.opt.StopOnDownloadLimit f.opt.StopOnUploadLimit = true f.opt.StopOnDownloadLimit = true defer func() { f.opt.StopOnUploadLimit = oldStopUpload f.opt.StopOnDownloadLimit = oldStopDownload }() expectedRLError := fserrors.FatalError(&generic403) rateLimitRetry, rateLimitErr := f.shouldRetry(ctx, &generic403) assert.False(t, rateLimitRetry) assert.Equal(t, rateLimitErr, expectedRLError) dQEItem := googleapi.ErrorItem{ Reason: "downloadQuotaExceeded", } generic403.Errors[0] = dQEItem expectedDQError := fserrors.FatalError(&generic403) downloadQuotaRetry, downloadQuotaError := f.shouldRetry(ctx, &generic403) assert.False(t, downloadQuotaRetry) assert.Equal(t, downloadQuotaError, expectedDQError) tDFLEItem := googleapi.ErrorItem{ Reason: "teamDriveFileLimitExceeded", } generic403.Errors[0] = tDFLEItem expectedTDFLError := fserrors.FatalError(&generic403) teamDriveFileLimitRetry, teamDriveFileLimitError := f.shouldRetry(ctx, &generic403) assert.False(t, teamDriveFileLimitRetry) assert.Equal(t, teamDriveFileLimitError, expectedTDFLError) qEItem := googleapi.ErrorItem{ Reason: "quotaExceeded", } generic403.Errors[0] = qEItem expectedQuotaError := fserrors.FatalError(&generic403) quotaExceededRetry, quotaExceededError := f.shouldRetry(ctx, &generic403) assert.False(t, quotaExceededRetry) assert.Equal(t, quotaExceededError, expectedQuotaError) sqEItem := googleapi.ErrorItem{ Reason: "storageQuotaExceeded", } generic403.Errors[0] = sqEItem expectedStorageQuotaError := fserrors.FatalError(&generic403) storageQuotaExceededRetry, storageQuotaExceededError := f.shouldRetry(ctx, &generic403) assert.False(t, storageQuotaExceededRetry) assert.Equal(t, storageQuotaExceededError, expectedStorageQuotaError) } func (f *Fs) InternalTestDocumentImport(t *testing.T) { oldAllow := f.opt.AllowImportNameChange f.opt.AllowImportNameChange = true defer func() { f.opt.AllowImportNameChange = oldAllow }() testFilesPath, err := filepath.Abs(filepath.FromSlash("test/files")) require.NoError(t, err) testFilesFs, err := fs.NewFs(context.Background(), testFilesPath) require.NoError(t, err) _, f.importMimeTypes, err = parseExtensions("odt,ods,doc") require.NoError(t, err) err = operations.CopyFile(context.Background(), f, testFilesFs, "example2.doc", "example2.doc") require.NoError(t, err) } func (f *Fs) InternalTestDocumentUpdate(t *testing.T) { testFilesPath, err := filepath.Abs(filepath.FromSlash("test/files")) require.NoError(t, err) testFilesFs, err := fs.NewFs(context.Background(), testFilesPath) require.NoError(t, err) _, f.importMimeTypes, err = parseExtensions("odt,ods,doc") require.NoError(t, err) err = operations.CopyFile(context.Background(), f, testFilesFs, "example2.xlsx", "example1.ods") require.NoError(t, err) } func (f *Fs) InternalTestDocumentExport(t *testing.T) { var buf bytes.Buffer var err error f.exportExtensions, _, err = parseExtensions("txt") require.NoError(t, err) obj, err := f.NewObject(context.Background(), "example2.txt") require.NoError(t, err) rc, err := obj.Open(context.Background()) require.NoError(t, err) defer func() { require.NoError(t, rc.Close()) }() _, err = io.Copy(&buf, rc) require.NoError(t, err) text := buf.String() for _, excerpt := range []string{ "Lorem ipsum dolor sit amet, consectetur", "porta at ultrices in, consectetur at augue.", } { require.Contains(t, text, excerpt) } } func (f *Fs) InternalTestDocumentLink(t *testing.T) { var buf bytes.Buffer var err error f.exportExtensions, _, err = parseExtensions("link.html") require.NoError(t, err) obj, err := f.NewObject(context.Background(), "example2.link.html") require.NoError(t, err) rc, err := obj.Open(context.Background()) require.NoError(t, err) defer func() { require.NoError(t, rc.Close()) }() _, err = io.Copy(&buf, rc) require.NoError(t, err) text := buf.String() require.True(t, strings.HasPrefix(text, "")) require.True(t, strings.HasSuffix(text, "\n")) for _, excerpt := range []string{ ` & ? + ≠/z.txt` existingSubDir = "êé" ) // TestIntegration/FsMkdir/FsPutFiles/Internal/Shortcuts func (f *Fs) InternalTestShortcuts(t *testing.T) { ctx := context.Background() srcObj, err := f.NewObject(ctx, existingFile) require.NoError(t, err) srcHash, err := srcObj.Hash(ctx, hash.MD5) require.NoError(t, err) assert.NotEqual(t, "", srcHash) t.Run("Errors", func(t *testing.T) { _, err := f.makeShortcut(ctx, "", f, "") assert.Error(t, err) assert.Contains(t, err.Error(), "can't be root") _, err = f.makeShortcut(ctx, "notfound", f, "dst") assert.Error(t, err) assert.Contains(t, err.Error(), "can't find source") _, err = f.makeShortcut(ctx, existingFile, f, existingFile) assert.Error(t, err) assert.Contains(t, err.Error(), "not overwriting") assert.Contains(t, err.Error(), "existing file") _, err = f.makeShortcut(ctx, existingFile, f, existingDir) assert.Error(t, err) assert.Contains(t, err.Error(), "not overwriting") assert.Contains(t, err.Error(), "existing directory") }) t.Run("File", func(t *testing.T) { dstObj, err := f.makeShortcut(ctx, existingFile, f, "shortcut.txt") require.NoError(t, err) require.NotNil(t, dstObj) assert.Equal(t, "shortcut.txt", dstObj.Remote()) dstHash, err := dstObj.Hash(ctx, hash.MD5) require.NoError(t, err) assert.Equal(t, srcHash, dstHash) require.NoError(t, dstObj.Remove(ctx)) }) t.Run("Dir", func(t *testing.T) { dstObj, err := f.makeShortcut(ctx, existingDir, f, "shortcutdir") require.NoError(t, err) require.Nil(t, dstObj) entries, err := f.List(ctx, "shortcutdir") require.NoError(t, err) require.Equal(t, 1, len(entries)) require.Equal(t, "shortcutdir/"+existingSubDir, entries[0].Remote()) require.NoError(t, f.Rmdir(ctx, "shortcutdir")) }) t.Run("Command", func(t *testing.T) { _, err := f.Command(ctx, "shortcut", []string{"one"}, nil) require.Error(t, err) require.Contains(t, err.Error(), "need exactly 2 arguments") _, err = f.Command(ctx, "shortcut", []string{"one", "two"}, map[string]string{ "target": "doesnotexistremote:", }) require.Error(t, err) require.Contains(t, err.Error(), "couldn't find target") _, err = f.Command(ctx, "shortcut", []string{"one", "two"}, map[string]string{ "target": ".", }) require.Error(t, err) require.Contains(t, err.Error(), "target is not a drive backend") dstObjI, err := f.Command(ctx, "shortcut", []string{existingFile, "shortcut2.txt"}, map[string]string{ "target": fs.ConfigString(f), }) require.NoError(t, err) dstObj := dstObjI.(*Object) assert.Equal(t, "shortcut2.txt", dstObj.Remote()) dstHash, err := dstObj.Hash(ctx, hash.MD5) require.NoError(t, err) assert.Equal(t, srcHash, dstHash) require.NoError(t, dstObj.Remove(ctx)) dstObjI, err = f.Command(ctx, "shortcut", []string{existingFile, "shortcut3.txt"}, nil) require.NoError(t, err) dstObj = dstObjI.(*Object) assert.Equal(t, "shortcut3.txt", dstObj.Remote()) dstHash, err = dstObj.Hash(ctx, hash.MD5) require.NoError(t, err) assert.Equal(t, srcHash, dstHash) require.NoError(t, dstObj.Remove(ctx)) }) } // TestIntegration/FsMkdir/FsPutFiles/Internal/UnTrash func (f *Fs) InternalTestUnTrash(t *testing.T) { ctx := context.Background() // Make some objects, one in a subdir contents := random.String(100) file1 := fstest.NewItem("trashDir/toBeTrashed", contents, time.Now()) obj1 := fstests.PutTestContents(ctx, t, f, &file1, contents, false) file2 := fstest.NewItem("trashDir/subdir/toBeTrashed", contents, time.Now()) _ = fstests.PutTestContents(ctx, t, f, &file2, contents, false) // Check objects checkObjects := func() { fstest.CheckListingWithRoot(t, f, "trashDir", []fstest.Item{ file1, file2, }, []string{ "trashDir/subdir", }, f.Precision()) } checkObjects() // Make sure we are using the trash require.Equal(t, true, f.opt.UseTrash) // Remove the object and the dir require.NoError(t, obj1.Remove(ctx)) require.NoError(t, f.Purge(ctx, "trashDir/subdir")) // Check objects gone fstest.CheckListingWithRoot(t, f, "trashDir", []fstest.Item{}, []string{}, f.Precision()) // Restore the object and directory r, err := f.unTrashDir(ctx, "trashDir", true) require.NoError(t, err) assert.Equal(t, unTrashResult{Errors: 0, Untrashed: 2}, r) // Check objects restored checkObjects() // Remove the test dir require.NoError(t, f.Purge(ctx, "trashDir")) } // TestIntegration/FsMkdir/FsPutFiles/Internal/CopyOrMoveID func (f *Fs) InternalTestCopyOrMoveID(t *testing.T) { ctx := context.Background() obj, err := f.NewObject(ctx, existingFile) require.NoError(t, err) o := obj.(*Object) dir := t.TempDir() checkFile := func(name string) { filePath := filepath.Join(dir, name) fi, err := os.Stat(filePath) require.NoError(t, err) assert.Equal(t, int64(100), fi.Size()) err = os.Remove(filePath) require.NoError(t, err) } t.Run("BadID", func(t *testing.T) { err = f.copyOrMoveID(ctx, "moveid", "ID-NOT-FOUND", dir+"/") require.Error(t, err) assert.Contains(t, err.Error(), "couldn't find id") }) t.Run("Directory", func(t *testing.T) { rootID, err := f.dirCache.RootID(ctx, false) require.NoError(t, err) err = f.copyOrMoveID(ctx, "moveid", rootID, dir+"/") require.Error(t, err) assert.Contains(t, err.Error(), "can't moveid directory") }) t.Run("MoveWithoutDestName", func(t *testing.T) { err = f.copyOrMoveID(ctx, "moveid", o.id, dir+"/") require.NoError(t, err) checkFile(path.Base(existingFile)) }) t.Run("CopyWithoutDestName", func(t *testing.T) { err = f.copyOrMoveID(ctx, "copyid", o.id, dir+"/") require.NoError(t, err) checkFile(path.Base(existingFile)) }) t.Run("MoveWithDestName", func(t *testing.T) { err = f.copyOrMoveID(ctx, "moveid", o.id, dir+"/potato.txt") require.NoError(t, err) checkFile("potato.txt") }) t.Run("CopyWithDestName", func(t *testing.T) { err = f.copyOrMoveID(ctx, "copyid", o.id, dir+"/potato.txt") require.NoError(t, err) checkFile("potato.txt") }) } // TestIntegration/FsMkdir/FsPutFiles/Internal/Query func (f *Fs) InternalTestQuery(t *testing.T) { ctx := context.Background() var err error t.Run("BadQuery", func(t *testing.T) { _, err = f.query(ctx, "this is a bad query") require.Error(t, err) assert.Contains(t, err.Error(), "failed to execute query") }) t.Run("NoMatch", func(t *testing.T) { results, err := f.query(ctx, fmt.Sprintf("name='%s' and name!='%s'", existingSubDir, existingSubDir)) require.NoError(t, err) assert.Len(t, results, 0) }) t.Run("GoodQuery", func(t *testing.T) { pathSegments := strings.Split(existingFile, "/") var parent string for _, item := range pathSegments { // the file name contains ' characters which must be escaped escapedItem := f.opt.Enc.FromStandardName(item) escapedItem = strings.ReplaceAll(escapedItem, `\`, `\\`) escapedItem = strings.ReplaceAll(escapedItem, `'`, `\'`) results, err := f.query(ctx, fmt.Sprintf("%strashed=false and name='%s'", parent, escapedItem)) require.NoError(t, err) require.True(t, len(results) > 0) for _, result := range results { assert.True(t, len(result.Id) > 0) assert.Equal(t, result.Name, item) } parent = fmt.Sprintf("'%s' in parents and ", results[0].Id) } }) } // TestIntegration/FsMkdir/FsPutFiles/Internal/AgeQuery func (f *Fs) InternalTestAgeQuery(t *testing.T) { // Check set up for filtering assert.True(t, f.Features().FilterAware) opt := &filter.Options{} err := opt.MaxAge.Set("1h") assert.NoError(t, err) flt, err := filter.NewFilter(opt) assert.NoError(t, err) defCtx := context.Background() fltCtx := filter.ReplaceConfig(defCtx, flt) testCtx1 := fltCtx testCtx2 := filter.SetUseFilter(testCtx1, true) testCtx3, testCancel := context.WithCancel(testCtx2) testCtx4 := filter.SetUseFilter(testCtx3, false) testCancel() assert.False(t, filter.GetUseFilter(testCtx1)) assert.True(t, filter.GetUseFilter(testCtx2)) assert.True(t, filter.GetUseFilter(testCtx3)) assert.False(t, filter.GetUseFilter(testCtx4)) subRemote := fmt.Sprintf("%s:%s/%s", f.Name(), f.Root(), "agequery-testdir") subFsResult, err := fs.NewFs(defCtx, subRemote) require.NoError(t, err) subFs, isDriveFs := subFsResult.(*Fs) require.True(t, isDriveFs) tempDir1 := t.TempDir() tempFs1, err := fs.NewFs(defCtx, tempDir1) require.NoError(t, err) tempDir2 := t.TempDir() tempFs2, err := fs.NewFs(defCtx, tempDir2) require.NoError(t, err) file1 := fstest.Item{ModTime: time.Now(), Path: "agequery.txt"} _ = fstests.PutTestContents(defCtx, t, tempFs1, &file1, "abcxyz", true) // validate sync/copy const timeQuery = "(modifiedTime >= '" assert.NoError(t, sync.CopyDir(defCtx, subFs, tempFs1, false)) assert.NotContains(t, subFs.lastQuery, timeQuery) assert.NoError(t, sync.CopyDir(fltCtx, subFs, tempFs1, false)) assert.Contains(t, subFs.lastQuery, timeQuery) assert.NoError(t, sync.CopyDir(fltCtx, tempFs2, subFs, false)) assert.Contains(t, subFs.lastQuery, timeQuery) assert.NoError(t, sync.CopyDir(defCtx, tempFs2, subFs, false)) assert.NotContains(t, subFs.lastQuery, timeQuery) // validate list/walk devNull, errOpen := os.OpenFile(os.DevNull, os.O_WRONLY, 0) require.NoError(t, errOpen) defer func() { _ = devNull.Close() }() assert.NoError(t, operations.List(defCtx, subFs, devNull)) assert.NotContains(t, subFs.lastQuery, timeQuery) assert.NoError(t, operations.List(fltCtx, subFs, devNull)) assert.Contains(t, subFs.lastQuery, timeQuery) } func (f *Fs) InternalTest(t *testing.T) { // These tests all depend on each other so run them as nested tests t.Run("DocumentImport", func(t *testing.T) { f.InternalTestDocumentImport(t) t.Run("DocumentUpdate", func(t *testing.T) { f.InternalTestDocumentUpdate(t) t.Run("DocumentExport", func(t *testing.T) { f.InternalTestDocumentExport(t) t.Run("DocumentLink", func(t *testing.T) { f.InternalTestDocumentLink(t) }) }) }) }) t.Run("Shortcuts", f.InternalTestShortcuts) t.Run("UnTrash", f.InternalTestUnTrash) t.Run("CopyOrMoveID", f.InternalTestCopyOrMoveID) t.Run("Query", f.InternalTestQuery) t.Run("AgeQuery", f.InternalTestAgeQuery) t.Run("ShouldRetry", f.InternalTestShouldRetry) } var _ fstests.InternalTester = (*Fs)(nil) rclone-v1.71.0/backend/drive/drive_test.go000066400000000000000000000014131505210326400204440ustar00rootroot00000000000000// Test Drive filesystem interface package drive import ( "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestDrive:", NilObject: (*Object)(nil), ChunkedUpload: fstests.ChunkedUploadConfig{ MinChunkSize: minChunkSize, CeilChunkSize: fstests.NextPowerOfTwo, }, }) } func (f *Fs) SetUploadChunkSize(cs fs.SizeSuffix) (fs.SizeSuffix, error) { return f.setUploadChunkSize(cs) } func (f *Fs) SetUploadCutoff(cs fs.SizeSuffix) (fs.SizeSuffix, error) { return f.setUploadCutoff(cs) } var ( _ fstests.SetUploadChunkSizer = (*Fs)(nil) _ fstests.SetUploadCutoffer = (*Fs)(nil) ) rclone-v1.71.0/backend/drive/metadata.go000066400000000000000000000475021505210326400200650ustar00rootroot00000000000000package drive import ( "context" "encoding/json" "fmt" "maps" "strconv" "strings" "sync" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/lib/errcount" "golang.org/x/sync/errgroup" drive "google.golang.org/api/drive/v3" "google.golang.org/api/googleapi" ) // system metadata keys which this backend owns var systemMetadataInfo = map[string]fs.MetadataHelp{ "content-type": { Help: "The MIME type of the file.", Type: "string", Example: "text/plain", }, "mtime": { Help: "Time of last modification with mS accuracy.", Type: "RFC 3339", Example: "2006-01-02T15:04:05.999Z07:00", }, "btime": { Help: "Time of file birth (creation) with mS accuracy. Note that this is only writable on fresh uploads - it can't be written for updates.", Type: "RFC 3339", Example: "2006-01-02T15:04:05.999Z07:00", }, "copy-requires-writer-permission": { Help: "Whether the options to copy, print, or download this file, should be disabled for readers and commenters.", Type: "boolean", Example: "true", }, "writers-can-share": { Help: "Whether users with only writer permission can modify the file's permissions. Not populated and ignored when setting for items in shared drives.", Type: "boolean", Example: "false", }, "viewed-by-me": { Help: "Whether the file has been viewed by this user.", Type: "boolean", Example: "true", ReadOnly: true, }, "owner": { Help: "The owner of the file. Usually an email address. Enable with --drive-metadata-owner.", Type: "string", Example: "user@example.com", }, "permissions": { Help: "Permissions in a JSON dump of Google drive format. On shared drives these will only be present if they aren't inherited. Enable with --drive-metadata-permissions.", Type: "JSON", Example: "{}", }, "folder-color-rgb": { Help: "The color for a folder or a shortcut to a folder as an RGB hex string.", Type: "string", Example: "881133", }, "description": { Help: "A short description of the file.", Type: "string", Example: "Contract for signing", }, "starred": { Help: "Whether the user has starred the file.", Type: "boolean", Example: "false", }, "labels": { Help: "Labels attached to this file in a JSON dump of Googled drive format. Enable with --drive-metadata-labels.", Type: "JSON", Example: "[]", }, } // Extra fields we need to fetch to implement the system metadata above var metadataFields = googleapi.Field(strings.Join([]string{ "copyRequiresWriterPermission", "description", "folderColorRgb", "hasAugmentedPermissions", "owners", "permissionIds", "permissions", "properties", "starred", "viewedByMe", "viewedByMeTime", "writersCanShare", }, ",")) // Fields we need to read from permissions var permissionsFields = googleapi.Field(strings.Join([]string{ "*", "permissionDetails/*", }, ",")) // getPermission returns permissions for the fileID and permissionID passed in func (f *Fs) getPermission(ctx context.Context, fileID, permissionID string, useCache bool) (perm *drive.Permission, inherited bool, err error) { f.permissionsMu.Lock() defer f.permissionsMu.Unlock() if useCache { perm = f.permissions[permissionID] if perm != nil { return perm, false, nil } } fs.Debugf(f, "Fetching permission %q", permissionID) err = f.pacer.Call(func() (bool, error) { perm, err = f.svc.Permissions.Get(fileID, permissionID). Fields(permissionsFields). SupportsAllDrives(true). Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return nil, false, err } inherited = len(perm.PermissionDetails) > 0 && perm.PermissionDetails[0].Inherited cleanPermission(perm) // cache the permission f.permissions[permissionID] = perm return perm, inherited, err } // Set the permissions on the info func (f *Fs) setPermissions(ctx context.Context, info *drive.File, permissions []*drive.Permission) (err error) { errs := errcount.New() for _, perm := range permissions { if perm.Role == "owner" { // ignore owner permissions - these are set with owner continue } cleanPermissionForWrite(perm) err := f.pacer.Call(func() (bool, error) { _, err := f.svc.Permissions.Create(info.Id, perm). SupportsAllDrives(true). SendNotificationEmail(false). Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { fs.Errorf(f, "Failed to set permission %s for %q: %v", perm.Role, perm.EmailAddress, err) errs.Add(err) } } err = errs.Err("failed to set permission") if err != nil { err = fserrors.NoRetryError(err) } return err } // Clean attributes from permissions which we can't write func cleanPermissionForWrite(perm *drive.Permission) { perm.Deleted = false perm.DisplayName = "" perm.Id = "" perm.Kind = "" perm.PermissionDetails = nil perm.TeamDrivePermissionDetails = nil } // Clean and cache the permission if not already cached func (f *Fs) cleanAndCachePermission(perm *drive.Permission) { f.permissionsMu.Lock() defer f.permissionsMu.Unlock() cleanPermission(perm) if _, found := f.permissions[perm.Id]; !found { f.permissions[perm.Id] = perm } } // Clean fields we don't need to keep from the permission func cleanPermission(perm *drive.Permission) { // DisplayName: Output only. The "pretty" name of the value of the // permission. The following is a list of examples for each type of // permission: * `user` - User's full name, as defined for their Google // account, such as "Joe Smith." * `group` - Name of the Google Group, // such as "The Company Administrators." * `domain` - String domain // name, such as "thecompany.com." * `anyone` - No `displayName` is // present. perm.DisplayName = "" // Kind: Output only. Identifies what kind of resource this is. Value: // the fixed string "drive#permission". perm.Kind = "" // PermissionDetails: Output only. Details of whether the permissions on // this shared drive item are inherited or directly on this item. This // is an output-only field which is present only for shared drive items. perm.PermissionDetails = nil // PhotoLink: Output only. A link to the user's profile photo, if // available. perm.PhotoLink = "" // TeamDrivePermissionDetails: Output only. Deprecated: Output only. Use // `permissionDetails` instead. perm.TeamDrivePermissionDetails = nil } // Fields we need to read from labels var labelsFields = googleapi.Field(strings.Join([]string{ "*", }, ",")) // getLabels returns labels for the fileID passed in func (f *Fs) getLabels(ctx context.Context, fileID string) (labels []*drive.Label, err error) { fs.Debugf(f, "Fetching labels for %q", fileID) listLabels := f.svc.Files.ListLabels(fileID). Fields(labelsFields). Context(ctx) for { var info *drive.LabelList err = f.pacer.Call(func() (bool, error) { info, err = listLabels.Do() return f.shouldRetry(ctx, err) }) if err != nil { return nil, err } labels = append(labels, info.Labels...) if info.NextPageToken == "" { break } listLabels.PageToken(info.NextPageToken) } for _, label := range labels { cleanLabel(label) } return labels, nil } // Set the labels on the info func (f *Fs) setLabels(ctx context.Context, info *drive.File, labels []*drive.Label) (err error) { if len(labels) == 0 { return nil } req := drive.ModifyLabelsRequest{} for _, label := range labels { req.LabelModifications = append(req.LabelModifications, &drive.LabelModification{ FieldModifications: labelFieldsToFieldModifications(label.Fields), LabelId: label.Id, }) } err = f.pacer.Call(func() (bool, error) { _, err = f.svc.Files.ModifyLabels(info.Id, &req). Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("failed to set labels: %w", err) } return nil } // Convert label fields into something which can set the fields func labelFieldsToFieldModifications(fields map[string]drive.LabelField) (out []*drive.LabelFieldModification) { for id, field := range fields { var emails []string for _, user := range field.User { emails = append(emails, user.EmailAddress) } out = append(out, &drive.LabelFieldModification{ // FieldId: The ID of the field to be modified. FieldId: id, // SetDateValues: Replaces the value of a dateString Field with these // new values. The string must be in the RFC 3339 full-date format: // YYYY-MM-DD. SetDateValues: field.DateString, // SetIntegerValues: Replaces the value of an `integer` field with these // new values. SetIntegerValues: field.Integer, // SetSelectionValues: Replaces a `selection` field with these new // values. SetSelectionValues: field.Selection, // SetTextValues: Sets the value of a `text` field. SetTextValues: field.Text, // SetUserValues: Replaces a `user` field with these new values. The // values must be valid email addresses. SetUserValues: emails, }) } return out } // Clean fields we don't need to keep from the label func cleanLabel(label *drive.Label) { // Kind: This is always drive#label label.Kind = "" for name, field := range label.Fields { // Kind: This is always drive#labelField. field.Kind = "" // Note the fields are copies so we need to write them // back to the map label.Fields[name] = field } } // Parse the metadata from drive item // // It should return nil if there is no Metadata func (o *baseObject) parseMetadata(ctx context.Context, info *drive.File) (err error) { metadata := make(fs.Metadata, 16) // Dump user metadata first as it overrides system metadata maps.Copy(metadata, info.Properties) // System metadata metadata["copy-requires-writer-permission"] = fmt.Sprint(info.CopyRequiresWriterPermission) metadata["writers-can-share"] = fmt.Sprint(info.WritersCanShare) metadata["viewed-by-me"] = fmt.Sprint(info.ViewedByMe) metadata["content-type"] = info.MimeType // Owners: Output only. The owner of this file. Only certain legacy // files may have more than one owner. This field isn't populated for // items in shared drives. if o.fs.opt.MetadataOwner.IsSet(rwRead) && len(info.Owners) > 0 { user := info.Owners[0] if len(info.Owners) > 1 { fs.Logf(o, "Ignoring more than 1 owner") } if user != nil { id := user.EmailAddress if id == "" { id = user.DisplayName } metadata["owner"] = id } } if o.fs.opt.MetadataPermissions.IsSet(rwRead) { // We only write permissions out if they are not inherited. // // On My Drives permissions seem to be attached to every item // so they will always be written out. // // On Shared Drives only non-inherited permissions will be // written out. // To read the inherited permissions flag will mean we need to // read the permissions for each object and the cache will be // useless. However shared drives don't return permissions // only permissionIds so will need to fetch them for each // object. We use HasAugmentedPermissions to see if there are // special permissions before fetching them to save transactions. // HasAugmentedPermissions: Output only. Whether there are permissions // directly on this file. This field is only populated for items in // shared drives. if o.fs.isTeamDrive && !info.HasAugmentedPermissions { // Don't process permissions if there aren't any specifically set fs.Debugf(o, "Ignoring %d permissions and %d permissionIds as is shared drive with hasAugmentedPermissions false", len(info.Permissions), len(info.PermissionIds)) info.Permissions = nil info.PermissionIds = nil } // PermissionIds: Output only. List of permission IDs for users with // access to this file. // // Only process these if we have no Permissions if len(info.PermissionIds) > 0 && len(info.Permissions) == 0 { info.Permissions = make([]*drive.Permission, 0, len(info.PermissionIds)) g, gCtx := errgroup.WithContext(ctx) g.SetLimit(o.fs.ci.Checkers) var mu sync.Mutex // protect the info.Permissions from concurrent writes for _, permissionID := range info.PermissionIds { permissionID := permissionID g.Go(func() error { // must fetch the team drive ones individually to check the inherited flag perm, inherited, err := o.fs.getPermission(gCtx, actualID(info.Id), permissionID, !o.fs.isTeamDrive) if err != nil { return fmt.Errorf("failed to read permission: %w", err) } // Don't write inherited permissions out if inherited { return nil } // Don't write owner role out - these are covered by the owner metadata if perm.Role == "owner" { return nil } mu.Lock() info.Permissions = append(info.Permissions, perm) mu.Unlock() return nil }) } err = g.Wait() if err != nil { return err } } else { // Clean the fetched permissions for _, perm := range info.Permissions { o.fs.cleanAndCachePermission(perm) } } // Permissions: Output only. The full list of permissions for the file. // This is only available if the requesting user can share the file. Not // populated for items in shared drives. if len(info.Permissions) > 0 { buf, err := json.Marshal(info.Permissions) if err != nil { return fmt.Errorf("failed to marshal permissions: %w", err) } metadata["permissions"] = string(buf) } // Permission propagation // https://developers.google.com/drive/api/guides/manage-sharing#permission-propagation // Leads me to believe that in non shared drives, permissions // are added to each item when you set permissions for a // folder whereas in shared drives they are inherited and // placed on the item directly. } if info.FolderColorRgb != "" { metadata["folder-color-rgb"] = info.FolderColorRgb } if info.Description != "" { metadata["description"] = info.Description } metadata["starred"] = fmt.Sprint(info.Starred) metadata["btime"] = info.CreatedTime metadata["mtime"] = info.ModifiedTime if o.fs.opt.MetadataLabels.IsSet(rwRead) { // FIXME would be really nice if we knew if files had labels // before listing but we need to know all possible label IDs // to get it in the listing. labels, err := o.fs.getLabels(ctx, actualID(info.Id)) if err != nil { return fmt.Errorf("failed to fetch labels: %w", err) } buf, err := json.Marshal(labels) if err != nil { return fmt.Errorf("failed to marshal labels: %w", err) } metadata["labels"] = string(buf) } o.metadata = &metadata return nil } // Set the owner on the info func (f *Fs) setOwner(ctx context.Context, info *drive.File, owner string) (err error) { perm := drive.Permission{ Role: "owner", EmailAddress: owner, // Type: The type of the grantee. Valid values are: * `user` * `group` * // `domain` * `anyone` When creating a permission, if `type` is `user` // or `group`, you must provide an `emailAddress` for the user or group. // When `type` is `domain`, you must provide a `domain`. There isn't // extra information required for an `anyone` type. Type: "user", } err = f.pacer.Call(func() (bool, error) { _, err = f.svc.Permissions.Create(info.Id, &perm). SupportsAllDrives(true). TransferOwnership(true). // SendNotificationEmail(false). - required apparently! Context(ctx).Do() return f.shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("failed to set owner: %w", err) } return nil } // Call back to set metadata that can't be set on the upload/update // // The *drive.File passed in holds the current state of the drive.File // and this should update it with any modifications. type updateMetadataFn func(context.Context, *drive.File) error // read the metadata from meta and write it into updateInfo // // update should be true if this is being used to create metadata for // an update/PATCH call as the rules on what can be updated are // slightly different there. // // It returns a callback which should be called to finish the updates // after the data is uploaded. func (f *Fs) updateMetadata(ctx context.Context, updateInfo *drive.File, meta fs.Metadata, update, isFolder bool) (callback updateMetadataFn, err error) { callbackFns := []updateMetadataFn{} callback = func(ctx context.Context, info *drive.File) error { for _, fn := range callbackFns { err := fn(ctx, info) if err != nil { return err } } return nil } // merge metadata into request and user metadata for k, v := range meta { k, v := k, v // parse a boolean from v and write into out parseBool := func(out *bool) error { b, err := strconv.ParseBool(v) if err != nil { return fmt.Errorf("can't parse metadata %q = %q: %w", k, v, err) } *out = b return nil } switch k { case "copy-requires-writer-permission": if isFolder { fs.Debugf(f, "Ignoring %s=%s as can't set on folders", k, v) } else if err := parseBool(&updateInfo.CopyRequiresWriterPermission); err != nil { return nil, err } case "writers-can-share": if !f.isTeamDrive { if err := parseBool(&updateInfo.WritersCanShare); err != nil { return nil, err } } else { fs.Debugf(f, "Ignoring %s=%s as can't set on shared drives", k, v) } case "viewed-by-me": // Can't write this case "content-type": updateInfo.MimeType = v case "owner": if !f.opt.MetadataOwner.IsSet(rwWrite) { continue } // Can't set Owner on upload so need to set afterwards callbackFns = append(callbackFns, func(ctx context.Context, info *drive.File) error { err := f.setOwner(ctx, info, v) if err != nil && f.opt.MetadataOwner.IsSet(rwFailOK) { fs.Errorf(f, "Ignoring error as failok is set: %v", err) return nil } return err }) case "permissions": if !f.opt.MetadataPermissions.IsSet(rwWrite) { continue } var perms []*drive.Permission err := json.Unmarshal([]byte(v), &perms) if err != nil { return nil, fmt.Errorf("failed to unmarshal permissions: %w", err) } // Can't set Permissions on upload so need to set afterwards callbackFns = append(callbackFns, func(ctx context.Context, info *drive.File) error { err := f.setPermissions(ctx, info, perms) if err != nil && f.opt.MetadataPermissions.IsSet(rwFailOK) { // We've already logged the permissions errors individually here fs.Debugf(f, "Ignoring error as failok is set: %v", err) return nil } return err }) case "labels": if !f.opt.MetadataLabels.IsSet(rwWrite) { continue } var labels []*drive.Label err := json.Unmarshal([]byte(v), &labels) if err != nil { return nil, fmt.Errorf("failed to unmarshal labels: %w", err) } // Can't set Labels on upload so need to set afterwards callbackFns = append(callbackFns, func(ctx context.Context, info *drive.File) error { err := f.setLabels(ctx, info, labels) if err != nil && f.opt.MetadataLabels.IsSet(rwFailOK) { fs.Errorf(f, "Ignoring error as failok is set: %v", err) return nil } return err }) case "folder-color-rgb": updateInfo.FolderColorRgb = v case "description": updateInfo.Description = v case "starred": if err := parseBool(&updateInfo.Starred); err != nil { return nil, err } case "btime": if update { fs.Debugf(f, "Skipping btime metadata as can't update it on an existing file: %v", v) } else { updateInfo.CreatedTime = v } case "mtime": updateInfo.ModifiedTime = v default: if updateInfo.Properties == nil { updateInfo.Properties = make(map[string]string, 1) } updateInfo.Properties[k] = v } } return callback, nil } // Fetch metadata and update updateInfo if --metadata is in use func (f *Fs) fetchAndUpdateMetadata(ctx context.Context, src fs.ObjectInfo, options []fs.OpenOption, updateInfo *drive.File, update bool) (callback updateMetadataFn, err error) { meta, err := fs.GetMetadataOptions(ctx, f, src, options) if err != nil { return nil, fmt.Errorf("failed to read metadata from source object: %w", err) } callback, err = f.updateMetadata(ctx, updateInfo, meta, update, false) if err != nil { return nil, fmt.Errorf("failed to update metadata from source object: %w", err) } return callback, nil } rclone-v1.71.0/backend/drive/test/000077500000000000000000000000001505210326400167255ustar00rootroot00000000000000rclone-v1.71.0/backend/drive/test/about.json000066400000000000000000000121651505210326400207370ustar00rootroot00000000000000{ "importFormats": { "text/tab-separated-values": [ "application/vnd.google-apps.spreadsheet" ], "application/x-vnd.oasis.opendocument.presentation": [ "application/vnd.google-apps.presentation" ], "image/jpeg": [ "application/vnd.google-apps.document" ], "image/bmp": [ "application/vnd.google-apps.document" ], "image/gif": [ "application/vnd.google-apps.document" ], "application/vnd.ms-excel.sheet.macroenabled.12": [ "application/vnd.google-apps.spreadsheet" ], "application/vnd.openxmlformats-officedocument.wordprocessingml.template": [ "application/vnd.google-apps.document" ], "application/vnd.ms-powerpoint.presentation.macroenabled.12": [ "application/vnd.google-apps.presentation" ], "application/vnd.ms-word.template.macroenabled.12": [ "application/vnd.google-apps.document" ], "application/vnd.openxmlformats-officedocument.wordprocessingml.document": [ "application/vnd.google-apps.document" ], "image/pjpeg": [ "application/vnd.google-apps.document" ], "application/vnd.google-apps.script+text/plain": [ "application/vnd.google-apps.script" ], "application/vnd.ms-excel": [ "application/vnd.google-apps.spreadsheet" ], "application/vnd.sun.xml.writer": [ "application/vnd.google-apps.document" ], "application/vnd.ms-word.document.macroenabled.12": [ "application/vnd.google-apps.document" ], "application/vnd.ms-powerpoint.slideshow.macroenabled.12": [ "application/vnd.google-apps.presentation" ], "text/rtf": [ "application/vnd.google-apps.document" ], "text/plain": [ "application/vnd.google-apps.document" ], "application/vnd.oasis.opendocument.spreadsheet": [ "application/vnd.google-apps.spreadsheet" ], "application/x-vnd.oasis.opendocument.spreadsheet": [ "application/vnd.google-apps.spreadsheet" ], "image/png": [ "application/vnd.google-apps.document" ], "application/x-vnd.oasis.opendocument.text": [ "application/vnd.google-apps.document" ], "application/msword": [ "application/vnd.google-apps.document" ], "application/pdf": [ "application/vnd.google-apps.document" ], "application/json": [ "application/vnd.google-apps.script" ], "application/x-msmetafile": [ "application/vnd.google-apps.drawing" ], "application/vnd.openxmlformats-officedocument.spreadsheetml.template": [ "application/vnd.google-apps.spreadsheet" ], "application/vnd.ms-powerpoint": [ "application/vnd.google-apps.presentation" ], "application/vnd.ms-excel.template.macroenabled.12": [ "application/vnd.google-apps.spreadsheet" ], "image/x-bmp": [ "application/vnd.google-apps.document" ], "application/rtf": [ "application/vnd.google-apps.document" ], "application/vnd.openxmlformats-officedocument.presentationml.template": [ "application/vnd.google-apps.presentation" ], "image/x-png": [ "application/vnd.google-apps.document" ], "text/html": [ "application/vnd.google-apps.document" ], "application/vnd.oasis.opendocument.text": [ "application/vnd.google-apps.document" ], "application/vnd.openxmlformats-officedocument.presentationml.presentation": [ "application/vnd.google-apps.presentation" ], "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": [ "application/vnd.google-apps.spreadsheet" ], "application/vnd.google-apps.script+json": [ "application/vnd.google-apps.script" ], "application/vnd.openxmlformats-officedocument.presentationml.slideshow": [ "application/vnd.google-apps.presentation" ], "application/vnd.ms-powerpoint.template.macroenabled.12": [ "application/vnd.google-apps.presentation" ], "text/csv": [ "application/vnd.google-apps.spreadsheet" ], "application/vnd.oasis.opendocument.presentation": [ "application/vnd.google-apps.presentation" ], "image/jpg": [ "application/vnd.google-apps.document" ], "text/richtext": [ "application/vnd.google-apps.document" ] }, "exportFormats": { "application/vnd.google-apps.document": [ "application/rtf", "application/vnd.oasis.opendocument.text", "text/html", "application/pdf", "application/epub+zip", "application/zip", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "text/plain" ], "application/vnd.google-apps.spreadsheet": [ "application/x-vnd.oasis.opendocument.spreadsheet", "text/tab-separated-values", "application/pdf", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "text/csv", "application/zip", "application/vnd.oasis.opendocument.spreadsheet" ], "application/vnd.google-apps.jam": [ "application/pdf" ], "application/vnd.google-apps.script": [ "application/vnd.google-apps.script+json" ], "application/vnd.google-apps.presentation": [ "application/vnd.oasis.opendocument.presentation", "application/pdf", "application/vnd.openxmlformats-officedocument.presentationml.presentation", "text/plain" ], "application/vnd.google-apps.form": [ "application/zip" ], "application/vnd.google-apps.drawing": [ "image/svg+xml", "image/png", "application/pdf", "image/jpeg" ] } } rclone-v1.71.0/backend/drive/test/files/000077500000000000000000000000001505210326400200275ustar00rootroot00000000000000rclone-v1.71.0/backend/drive/test/files/example1.ods000066400000000000000000000320201505210326400222470ustar00rootroot00000000000000PKqYLl9..mimetypeapplication/vnd.oasis.opendocument.spreadsheetPKqYL>ɢiThumbnails/thumbnail.pngPNG  IHDR'ePLTE.(&%,/3-270*)67:,@):N7JA:T@.VF9HFHHLUKQZSLHVPO\RLSQTSU[TY]ZTQ[VY]XU[Z\MWfN_pSV`SZdT]kZ]cX]iR_r[aiTbrTfyVi|Zfs\htYhyeVJd\Ws^Ja_`kbZxgXcccbeifidfhljealhelllemvep~npsks}rkermkzmc~mhwqlssssvyuxz{vr|xs{{{]n^p`obreugzkunxm{k~v}q{wz}n_q^odug{s}jymrz~r{t{z}ũƧѵĭԹʱԱ۵ڹѽԼ۸űĵĺɶ̹ɺƽѽ¸ȸκ6kIDATx}TSW^[aP tBglO `0@( $qն-BЊ(uZB!b?x4dʇcCgJp=;qq.ٛ_w^ܷdlbX_ W*NP?QK|!l#=^x?sCv"x֍o a*qu,q)8({s  N?PVV:;Zfwїh"&G{ma9Okwbg~INq"A,M6>k^ѩY&mُ#SY,i8+c`{7v+8v8}]$>DaTO.sK~)Մ%\Soƀ5bC\w`y ϟexm3<3sO9^Gu4qz@5Z< 3^KENxN *;DKOYP_֕~? NB1SeW'k!Zt=Ftiϒ |;kw /JG+yÀ9LaM^o*;Frww2޻dOmnU^ЧjM~|z,^CYu kPuby@*}8/%?6腈y&b|y1ZC\r5Xt!9qIAiRR)+x\j 'q/ :يf/swBڙK̟Oy.6`П(eJ1hy$*SՐJlEkG= #\EߣRQwOׯjv 趂'+u&Ͷ(|!7NY^;_?!QNg? Ymk; y0igLфf*wws_z}T3%G"X~CZk]9V;g}\F9X=QIAO,x8}WLe8ֲG&"\#o{?̺,YQ@x19H?!*p!KK;>il}hʽѕeR zHE fJbC#Ւ9\9{'{]fR;HF0?oqHd >~<]GuP$5e5b٧1IR<_ڼ^n:p}:kn`F)-[z'wd/d=)xPI^脊CŜ!]!957kMk2hOIHF}ǠQׁA21]G7I=G8zj;z֍^})zZl.?aޚC4rGjR\黏_"k{vcуۑ9">Xp`ݶhr7R1C8{~ 2ѕT1z9fS:VD||q9F߇aE´h-c! =_rX~EOeYbɎ&uMt'q&ԘT~Ke*9o4;zN^tK֫31.shra0f4$H5N,͕ [~=-tMƬ8}*ӆ Dk+yD,Pb9 ~-[ħrI;>fW[&z6P`[+DQi#s_=?krg|?Nkk`N8=uJh*i?9z~3? ]/[ &1 dW +C8Ώ2sDhn'Ez8R0KJJcS_zPoƞLNz' "@|S@/,ܼSAg1)%OI#N11uF /z &9[B7˲#*|ǣ:E{TΝ<>KLg6 쨶jU=< kܭ jdo`G1Z=k9)Bnrk=Npwp?zFd&t6xl 4ify3U=ӓuzyBW?H"K?qowLۃaNY{#^u pmߵ68IҏKsv:ܧ gE-jVjuXgIENDB`PKqYL settings.xmlYs8~;GRxB#\$M h"k=6q:\g oէow[6 $E>z']Ez_ZF]rI]=tCjKPJO-K;Z6I͉Vl}8NO򧡵V*;(NN⢓fS]Kj*}h $Y'mNo8dt7~?Mk8vmhiB=jVѺy.9V6v\Ye9ȋoa ZAOF] =ߜWo$hS-7)Y%vU<˹) F1z/49':"?s` z(8 Dq*}ŻrWٛzSrE0D;FqA(ByECz᫒g62YYZ9^R7џkF>QG{ݺ1 +55F D[#%By8 N+%VݕZ&K<h ͐#@bFޅJ72@7b$T  ?8wSv#N9ΈTgUR`Җ˘HMBҚ._a n,u!bR'otvZ[9Km'HPoo 1^rs#/5F-os3rV'?Hw^K>.&gCB5A𱤄߇U!)h}޵ֶ쿟lZKV4-]Ul1}p' }e0jQ|ЩP)JJ%m7F߫t\F58T8! ͔=9 "apvE9*=H"{:ъ ŗQҵUd%oPKPKqYL content.xml͝sTWd00|.)(t쨕,!q߿+֑l ї@=zt3se\,qO{f'A^|{ߜ|qfoA/c(?Yȧ2[L/‹M>-ifԴ]=֪U^G.kzg Ve-4=|`_3KqQp;/t꺫pldV{~S. |D\,wšp7)I&j9>٫n{z|ZrߋI|SӠNPᘋ$* zwS;~nb\섋3Yyvҁ4Ɋ13lqQݔγ (.#p;Yoں[{[4$n{i,A}a.S./Mfh%) [DyI7N$N }N[Y|= fgvyn)opcXz\ͳA}-f '0~fA{w j og\7q]$Z]w5uY|VE>\P/,sG{h{cj0ğqf̎@]zl+z߿",wܐ]4{"t;< ϭ~"1y8rw^_ x^dpo^lYާVo(oq뷇Ż޾DP_M[ᢊYk?8u@g{y;U~%F>ABȨr[@BPHH*p}~jP$2ڟ($43C\r $4 g$($Hh*p}~āĠAb@@b:؟2#1"H $$ȨYo 3C*-2h[@bBb̌Ĉ\p 1n#g$&($&HH|wHL$&$&ȨYo Ǚ>3*:=[[է>2-v D`@d,d<&Id dZ(8)e&fz}Bՙ3DΑSi |S2)2-v jS揸^Bb7FΑp |32)ȴP92pSpNA6?z Vu CdZ(8)} ϟq k<Ey2-v Ss\aŧO1FΑ~ | 2*&ȴP52$NJn*%/Yޝe8PGΑsہJ}+2*2-v 9$;׸^f!N{:%2-v $;_p @%ŁJL #@%d7,dX*)TjdZ(8*$;_q @%Ł2-v To^Bu@ ;G΁Jn*-oYȰTR!Ba9P@%ف,dX*)Tisdv@z @%ŁVPdL罍"v@2u@U ;G΁*nO\d!:PEqJ Ba9P@ف_,dX(TIdZ(ȏs;PEv O>ޮisdb;فz}Bu@FΑsہ*qYȰTQ Ba9P@ف^,dX(T isdv@ ׆ @Ł2-v UT  ց*UcdZ(8";PYȰTQ Ba8";s\9ցj}dZ(8&;됅 @5ŁjL #@5d,dX)TKdZ(8&;^`!:PMqZ!Ba@~'dzO7}jdZ(8ٿ@c\c2ȴP92pTs;PMv \,dX)Tisdv@\2GȴP92pTs;PMv)) ցjcdZ(8&;пq @5Ł 2-v΁&; 댃uihoټǘZVl@m6"j?{PK"w wPKqYLmeta.xmlO0|58!Ҭā"(*g+ٔoty7c~t:z+kv(E`ʜvC\Mm.:0>Q/G;48m۫{f4-E+s{愌 [w"IUUd>P)ypz aГ'dcjbo#Yk&| =K)ed蓓R  [/ Ʒ(ZǿYxmSDФ4)ciON \2Ӣ&w5Ix]嗵?ǯ]7_*/>Ѭ!v0>,-ZNWNYK@e]>;%9f8,Ӈ'e[Y  SEhGJ8]gS&.!PK^NPKqYL styles.xmlZo6P&>l/v hcH̕#)QQ Mww$%6- teySך4 !J[{n] Q I'06wPNٲKb$-y$LD/Tň26V]MmoXe邛3+R,SS="co#b$G /n1J qvt7;bpr8pYNB11Ǜz&IR'7pjF!qLZ}mյ{h63,_*Mw|Bχع$FU@Q6:mB*WB]u;ŵ wqH x0*IEy@p+K^ ŒP^9_;~ժVR ivB;3Gh{Im-(~ *x#1U z- "ymWo3HԖ5 f`rr1,V*N3 Q*dKCxW*>t̖X7yԷz猈5#@;fbū'ŵtreGbTO>TX44Ane 2~mAkR3-v ShCX^"Uΰk|-3ƥ;arOo)={ E}.S%ER^rN_5űP<,j˥Oj! ؙFH9'B$ 1Ry$ٓ"i,1HBB5eS7Vӄ-V{6[@a ђҠq6+vTJelPp%JeEq +e|\V4)1z!gz5QM dUR0&.$8Pp|\89;Uy#$r;77Ο>_]'a%w͵RNʟASDZa>zd_N U *պUJKCoX Ym , 9Xd iIo++^Hn?A᤼~OמkmXiyw-j+ cD~(ŀ~Z#MhqEHmڐ꤆!:Vܤđ[s kS뺥eQRVNwQݿX\rTPq֋PwPK\x"&PKqYLConfigurations2/accelerator/PKqYLConfigurations2/toolpanel/PKqYLConfigurations2/floater/PKqYLConfigurations2/menubar/PKqYLConfigurations2/images/Bitmaps/PKqYLConfigurations2/popupmenu/PKqYLConfigurations2/progressbar/PKqYLConfigurations2/toolbar/PKqYLConfigurations2/statusbar/PKqYL manifest.rdf͓n0ɢiTThumbnails/thumbnail.pngPKqYL settings.xmlPKqYL"w w content.xmlPKqYL^Nz"meta.xmlPKqYL\x"& L$styles.xmlPKqYL+Configurations2/accelerator/PKqYL@+Configurations2/toolpanel/PKqYLx+Configurations2/floater/PKqYL+Configurations2/menubar/PKqYL+Configurations2/images/Bitmaps/PKqYL!,Configurations2/popupmenu/PKqYLY,Configurations2/progressbar/PKqYL,Configurations2/toolbar/PKqYL,Configurations2/statusbar/PKqYLh -manifest.rdfPKqYLE/@.META-INF/manifest.xmlPKe/rclone-v1.71.0/backend/drive/test/files/example2.doc000066400000000000000000000360001505210326400222320ustar00rootroot00000000000000ࡱ;  Root Entry  "  FMicrosoft Word-Dokument MSWordDocWord.Document.89q [^^Normal 1$*$A$3B*OJQJCJmHsHKHPJnHtH^JaJ_H9NN berschrift x$OJQJCJPJ^JaJ6B6 Textkrperd "/"Liste^JJ""J Beschriftung xx $CJ6^JaJ]222 Verzeichnis $^J $  PGTimes New Roman5Symbol3&ArialiLiberation SerifTimes New Roman7Unifont9FreeSansS&Liberation SansArial9$FreeSansBhzbhG  ' 0 0Oh+'0|8 @ L X d p3@.@@2#s@`ńwV9՜.+,D՜.+,\M 0Caolan80 2$    )b Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus auctor volutpat arcu. Proin facilisis efficitur lacus id viverra. Praesent tempor egestas lectus, a consequat dolor tincidunt vitae. Donec ut velit eget sapien tincidunt volutpat vitae et urna. Curabitur odio eros, varius a feugiat hendrerit, hendrerit eget sem. Pellentesque consectetur commodo magna quis sagittis. Nunc nec vehicula nisi. Pellentesque ut dui mollis, ullamcorper magna in, auctor arcu. Cras bibendum malesuada eleifend. Suspendisse ac magna eu felis ullamcorper efficitur. Vestibulum porta mauris id purus blandit, vitae porttitor tellus sagittis. Etiam nec sapien quam. Curabitur euismod egestas odio, ac ultricies arcu fermentum ut. Donec vel nisi luctus, ullamcorper enim non, imperdiet velit. Nulla vestibulum commodo arcu eget rhoncus. Ut id commodo neque, quis mattis erat. Duis et tincidunt odio. In fermentum, erat tristique varius pretium, sapien odio elementum nulla, eu porta libero nunc at erat. Maecenas egestas porta erat eu eleifend. Aliquam suscipit hendrerit purus a aliquet. Aliquam libero mauris, sollicitudin eu semper quis, finibus imperdiet sapien. Pellentesque hendrerit quis justo et ullamcorper. Proin elementum arcu a hendrerit ultrices. Praesent sit amet iaculis dui. Nam posuere, quam eget molestie ornare, diam enim laoreet magna, at tincidunt velit felis vel erat. Vestibulum eu ante congue, maximus dui at, volutpat ligula. Suspendisse a mi eros. In diam leo, rhoncus in eleifend vitae, condimentum vitae quam. Sed ultricies facilisis magna ac tincidunt. In ultrices, mi sit amet placerat tempor, risus turpis consequat leo, non vestibulum lorem nunc quis sem. Aenean mattis, metus vel placerat mattis, eros velit elementum nisl, consequat congue eros tortor sit amet justo. Suspendisse potenti. Proin vehicula lorem bibendum neque pretium suscipit. In nec lorem tortor. Aenean scelerisque facilisis molestie. Donec pellentesque felis magna, a aliquam mi finibus ut. Aenean eros diam, viverra id dignissim et, pulvinar a eros. Mauris risus tortor, condimentum efficitur velit vitae, fringilla auctor nibh. Cras pretium orci sed auctor volutpat. Cras non diam mauris. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Quisque ornare sodales nibh, vitae placerat nibh porta et. Donec dictum fermentum sem quis porta. Suspendisse suscipit sem ut congue dapibus. Nullam sit amet rhoncus turpis, ut feugiat enim. Maecenas hendrerit metus tortor, finibus tincidunt libero ullamcorper eu. Donec sed arcu ullamcorper, bibendum lectus nec, consectetur mi. Aenean eget aliquet nunc. Pellentesque quis condimentum nisl. Donec consequat magna odio. Aenean in massa massa. Phasellus egestas at nunc finibus volutpat. Phasellus urna ante, tincidunt consectetur ornare nec, rhoncus a justo. Vestibulum id quam id diam maximus congue. Sed luctus odio vitae felis interdum scelerisque. Quisque non interdum sapien, in viverra nisi. In neque justo, porta at ultrices in, consectetur at augue.  " nr5\ *7 B*ph " pr 0. A!n"n#n$n2P1h0p3P(20Root Entry FCompObjjOle 1TableSummaryInformation(WordDocument2$DocumentSummaryInformation8!trclone-v1.71.0/backend/drive/test/files/example3.odt000066400000000000000000000527541505210326400222720ustar00rootroot00000000000000PKnM^2 ''mimetypeapplication/vnd.oasis.opendocument.textPKnMa11Thumbnails/thumbnail.pngPNG  IHDRPLTE7%"9158@KG5/PBOt2HpD"Q xd=:#d"0N$G@ &Rd*)~Gӣ ?8HO?'CwT Mdy=rnj*{$j&1D@"uϗKl,]/ӥ L..1Tڥsd I\[a30Rb x87sb5Up'RCˁ^7~ߏS:9e?à {7 p6|(] Ao~+Pӟ>4'ˆo #@P%ꏓ>D"JL.%'ңq $F'S?I|i#sda4HN'h`ȟ?> Vp9ȏ&C?:[LO~M }& L`mO}ӧ!b/_O*_aוCr SZr^\,_si2gJWUқƽZNU$.lie; ;:|p~%o;F>/#7;/Td}G3K!8<:J^|#@> #ONP+]KxG`-Y #);8`*/OJCãX-{ֆ@:082gN͌.J##@{dߘLO&R)(S|pmX9^h%I_d:N$.S$)tꃹT:4XbəDD>]N>y!u'ajӧ/ գPD`Gaޟ|O~7`|H8x~x?x0@_%F @/G?x@rӏ@jQC~)]\]YX 'KsJ_)].F.q EN xKKs|i:C0WC./Ν^&sб|2lEJRJsft0llUt~(NO]NO!x} ө|t*?7 ؟?S>_ 3>L>CM:5=K'Rt"=7ɦ3`SSSҩaH >ޟ3Ã!r` {?ԏ !7}!F8<8u|h(#Ë",@É b8o0sqt:=9.L$/X3S|ʛW*TEO:9ʂ99yrjjj'sSɃCS"ȥʉ ɩӧ/˩ܥt~dBrr{vKˏ+QG%o,pQ;]yiY]xM\) T*fsCKçR3\#T~:uT~f:ϦINc\NO_`Oa-Nq4;KC: _.M陙 3I:Bj03Y<@MχG'Ё~ߠ{ 8Jpp" $>RCF"o ʥ|ȩ_%?2xoŠ}d N ɩ47JͤRS vRivB>7RǧNXJ]HөORLjdi8Rzb`i̝ N%g S` p3_PVpniWaY+-x(XLzfn[1 T-q 1iu(5=UQPɰ 9] I-ts2oBx#~70:P=upp:D#\oreF١ё_=a@=z{_͌!/s_ (䷣fN%O)2DS-L$I6KN'FC#P? K$Rԥ:yy0DK[p ~̝NT_ekwkkoLGC|!W3WNb7IgCSne3গfAasY&L"6q/wV̡F#=[13N(3n:mnF=8vl5q][\a0lvpfw}یj&4`8rJ7]ħU#HL<30VܠĄԿ {jlAYz6V6܏hT#,%M1Cm}fs&dl}{Kúhg1C> FL:,Zb!S?- [>d⧹l2B6ǂxS(fzX};+.BghW6|k\3w,ѐ;.+.ܢg^Nw8ϖn=Yl1ΑdYCQdjQq{ >Ja=*,Sr;0H4 Qq ppv66Niy1l'f't8J3XMƨ9dh ƋȌ[`pELƳ agc ӅkbUwNߑBi]Rsٕ&3$L%APx=a4=\8"E!Y4 1\+E,9QTir,LDpS2qG' `h3pq"AzI$i 7D؀)\XjkZ!ӏ_*x\c"#|T8v ףc?A{@{|EPsoDPD Zo4uB% wP `(N4!aM}Lz`_9*31zΜ 1{lf+ xp<%:G(ÆX)+[?t6۵'H XbC"'%`4L<ӍW,/@/ (5=;2N{("{CLP"KP3h# E: ٱq"'BIҹ'L7ogYV|=_6Rq8F&jE/ @ިפ 1.a \JၯwPQhD{zuh=ܿZ <mxITdsـ9Q p~I W$uF>ap`Bt?ۍQ֑d#A@@V,9!N9c$0-} {]SֵmOq"v&jdd qDm09]Ϲ"q&N m'6s}p>$, ;$;@8;ѻrYwplIINqHZ2{-YbdV/LETa*x{yy{sW4ѴK}cҼ{03(̀AU:!VT`p:3=(f@QLk3(>H=(6C~֬D1#d\{(+8}Kf.fe>ڇ Dՠ~τ ~l41=}ۜ&qnL6ԺC/Y0ilGw :b6v`2k`e_8zPDSA^BqU-b~ۻi E31|b AzM;ЁأgXpL'CLn7 m$]f 6p7   `1V7Y}Bh9k{&kѪ Ww-^t W}|-ZȲc#weK o|<pu+^w q3w%Vd*]3BnY{][S}J1b  1;x atg"g{ǹ7 ,`㐹쬝 rYHqt0zohAhUX Lt\8J"Pesq0A3qJse:0e<\r:@; l0x Hgc8(h<s]<+AK0("fbgh<P9L#PC R)!=&4m(Iɔ2f"1ϝEr[]AoTmG6:50w!:}F)86X`~WQ"VtG\6,,k@|uVTҮ;"Hz/BP%=. RI=¹V7W V5=|٪]JQAqK^lQa25[Z:` u.-h:CtmQ@FT-zME]W8ߺmX|%]]]T_[֡us;(h.)wC :[Bo;éFW5Wh 2zڡp򭜪^\Aױ4,oaB5ѓV1X .ƶ-(J 9K!.I;kki(C bG)RB.mV3mEDԢ͏!ҀIAgI[DآkDRC$">q+q讫 L+d.BjW+jSHJZLծoWUGIlBVPw-r}Ҕn $ Zr!{v+-@"`KݮR(V)U Uՠ[y {ޘ|lvP9NuqH'jʺ;`NtaMUZR-=5KҶr5N\]JV_)oXŒ]mV\5j;`X+:8K\R=RouCK$Bo*omlA x3-mZe]tC> [ CĭS@[%Cg*dXQAxCt,)2n^jVIVE'[U*q!-`:TڢPI6kD*mf] T-tIrBQ$d0{ufC{WWբ2,_T7rY']k]_+9Cq٪ҩG<ý9P_ .@b 6оQ%6Ɇ6ȩomA8d⭏*7ud9Usw v 8mM.tM$lX%h]0\o%* +@lJ)ܦ Z}?۠k8TAo[2}k侍m* \"{Vn vnK.O 0G`4.t҂VZ" K:Z3['=u?=˶54TyS_;Q@Gީ.KerZy99wQ f˂/D hdNڥRB+}6IoDm'z'|O~󩧾߄x)OVpPPP߰M䘱 'r9e2L1 bar9! G$1l,Z.\6Ad@>0E gL逓L9g6AA|tA Qcm;(xzdGDoDxMja}iDf5oѦHSi*)ɝ?C&qժޭGV!U ٷacuٴ[k#7F7" l%9R&f93E:q7ܴA܆[1N ʺp37"8n&&< bsPk8>w0+9Ǟ?bN7 ؾnŜafaĄ }Q.WVE=D1쯄&cyL_ e8Ān -Yd B/}{𱉉B1B?Xù2"3 0b4@l.<#@vaB FcX0Jl^XW<_ .&!p!ap<-9JBkd*dٓ6f(P̍ˮvRet{|7u05&f@ŴjAl#",ֿ` ^3AgQڳ`t'Fk0({0^&|D)h3ϏY,m M`Yvl)H6OV7<-ѪQg¬XUgp}ڊg{=fVbkf6[\EM̺-{3b:LvQG=fư{w[6˶yԏaf̸pplM}nwEW=CaiVomhP>~3yuRf+oZ A^i=Kҁy/ m_Gxz7xA&޷E7F9C @2!̌3ƃ +noӳVސpwBߘ']g_` cf>e#SEa7"mn8pb,ʐg.qPm% HIsġ+>Svg=C`C9H;ANN"p4ʀ{(p.iR&w,,ZeE{;b3c} Ղ[{p,nay[Y[(Gk3D,rveG+u7Q^|VS3fXxǚ[,8>o:^ qf> Y㷷xFƃnŖ) [΁>7"v2 3iƌc/.;^p8pֱcώ o;w;'p9bsweu[kw8le}e-bN\WggF:a2Yjn rLS e\m}rwWmEGayBv$uiD>0m[רNItc(̹*Q(b'لɟ -~N%EI2C"#ɛЇڷpx脑UP[MvQز]BB%\:Ec V?8t>(*k1<|WIkG4l,x9M3@[/֘5DQJ۷ˇ,>7wm'Fqm&;b-ؽvV>;>r؟y_g 0D︑_`\A bl.0-KΣuĂ#+_n{;Yasb/ʎ1ۦ9<Q]榞C 㤰lôZp%7AturXX̓t Hg͕e>c役_b}23<{Ynkl~bCJǎ[CAY@CUU/qy %rE_ת>𼾢r!i4+ ?񯚛o_&RyȂ++78E):2HK_~6qJ,,r}xds%t`'=aϝt<!(` M#H(O~^׏r6|qb'/ڱ_>}«ZNB{RަȔY)t8m!v\ɏQJ^R(wڈՔcfcXvsV֊ C;i+Än~r+(Aow<֍-ð#} J%k 'Y.,}Y 7V&6]Nvx4H'J*;Xu+*LYIĠ ~lӵ Jyo$ >DfghE'C+jtY7-g؂#2>9toWڷ[08ʪG5Q ,I-8GbD+"Nɉ!hU~h0D 5`$j6M_@{e"qm_8 $S1(%%gi)`!F`ĵ}9۾hS(ҋ~#\^f#{m!K O<1$1KC?oQ`* F֔w4)c"%kj&tDC;ṉArIA=aJ?ܜTD|u^cY'4GCl#GE(A aHe}9B^n#?D7NXg>ḳCFd4ۆV1šSSJ!OuqP̡\blj48^D'}Y8p=آ; l;7aYNpPKr8 M PKnM styles.xmlZ[۶~?P&Kwk7>8$}.hP@Rwx(Y*ٴ(P'@q>gCү?tq\V=2JYFS뇟7zx)q%C!tW[ Xlee5\LV6%>ɹ揬~ s6I0gaI2DI)(Qt<}l6HK[W7jTFb5e9l%k&UM|65HUl8'I gw_u-,&1zBϻ/rX ۣ*夞=M3ZSUUECH=xz"r4% B|Pn\MzR}q͸l '(`gՆW!K:^J{eP0gAy}6i.穫8R6l`ImYS$`S9Q"DumOe}JWxz `"ҨRdB}d= ?qMsq;d`wQ Tym2[ۼ0ȧ'{T$X@ss' = JqG"D]-d)^n`F5 !j"SH}ĉ0y74 LV,$._bQ:KǏ׶Jٙ5NiQ]4pXsK}İcS%7W.X1Ii+yXm5g# Y-uU,T߶(PƎ!X+ OOA\<JCp(jBuOL ]=^ԤK(l(s^@GtZ)Hdz7GTxS#4=HCH"fh] 76c1Z}"UVbg36pV ZӶpe܅ɍ0J-z 5c\O OVmU)ú!GrpҀ%lG+=1C!P5jL'O}݊Npk刪4z-Lx0h+-pV/AlP:WxgOD7ns]JgHQjhCuSRvn3=nT6FJ@;o3 Rntq]%˰`͹fvksT::ǻt̺1պB)\<W jC d?b\,^Esg~1!-E ..̋Iu^ZT*V}hmcy̬r\8V{J]IN'+%2on""EGt%l%?死Z~V#>69T䝁Syn)˚2 mi4svj^8,|Kh2Ɛ LTI|B%ӿJR9#|{WHw0>}EOb8̔kKR~.0#J;NiS=t!g/JG:E.1L,n>3=O_ѣwգݣXO5Ҝ/ L-С`ZmAՔz@f[U]D"&atLb{hbp}nv Vn̡dfGIPztҩi$du#OFH!}Bo yu#OÍ>!7Bln H_T1UNj=I=Xb x@7ho~sfPJ!| qMH t#cLx3l'1vsieJh{xVW̠N0Nj{XmtTe'q-9L>k,8Z.V @ '7&v o#&n"͊Fn zr;K舗Ǜí8cm*<RmuKfX.&:C p(6/䱛{C4^a8\=AgrFI{5!Mdx1o.cf[`GS5^*2,Dюf/A^8{a>E?PKK<(,PKnMmeta.xmlˎ0} Dg 3`FꢫZ]ld̐}-e2Yts|x4u*mއ(a 57Bj8|P%.jcΣ}[M TG5kdGz-MYJއgZ 0 Vy ~%8:bVvlFv[s !Lҕ&7dEJ`qX;( 9OD,K QAar$Be ,G!8X"@]`T)NkK_"ލߺ^ˮLnEJjƖdiigg;`[k~I@ Wo9D;KvN`;2nDհhNc֭nHt,,k,Xji-*?{;iQq̴ᬜZ}-ICP[/PK=OPKnM settings.xmlZ[w8~_{JB\8 =6 L}IH6iJh_fˏω8x9ʫc.WoycKx,i5Cz]v~)FnKn)kOʳ0&m7;TE]?_BE|1NY褙n|eVzBAq $6el?qXX_N YtG7:Gͷ"v;!fUE/nW.p9b z &74L0A57pc(>cB,0a!1\Tt[Uj>8{:.ňEZh &hɄDmFEHPdu!.P.}T%k?h@Wt!R $YlTVv`P&=w2 UGėfPdmfv-;dwY8W͔/%=$g@J4}[Zhϊ Zt>LP΁+LB0fj[[J E ԸJS1֫wL=Q%L>Klisc Z&̹ &Kc0S}+a„'Y[{]+tle=Lʡ]CC_ 3Qvs-䔚Gf z\+M7|Y[xbډ5/ -z,#P^NO} -)IͪBX(``yеAhWدv̢4YC \Iya?ͨX 7z atVU2̌􀒪~P=L҉bϻG/K\i3 P#͍oi nI*'#E]> Tb%]y͝L+ցP:D 𴆡 Òd@)mȞ){*2LZGz &CrkEv=Oelcvmʂ7}ni](D`BÔ0ldsZ߿D|&-6z RڴN== rq({݉"aXǰi݀ iC(6U-CoA@s&G6cN3 P?đ#jGLx.ljl|JGV'k;0L(pCEֳ!f*^BZθ g@uwZ+zޘzj3(xM+NwPץeokM".o%S0}YBjrTq @\h鉼?>;:?xX}0ciSuEZŻ1oh0]|ʹ᳕ $Ɍ _@r -cmb ڄxK1b);@P*';٬R{^bٟvz6,hқ+E*\XJ)|f?B;PK_ 3NS*PKnMConfigurations2/toolbar/PKnMConfigurations2/progressbar/PKnMConfigurations2/floater/PKnMConfigurations2/menubar/PKnMConfigurations2/toolpanel/PKnMConfigurations2/accelerator/PKnMConfigurations2/statusbar/PKnMConfigurations2/popupmenu/PKnMConfigurations2/images/Bitmaps/PKnM manifest.rdf͓n0= 0 { req.Header.Set("X-Upload-Content-Length", fmt.Sprintf("%v", size)) } res, err = f.client.Do(req) if err == nil { defer googleapi.CloseBody(res) err = googleapi.CheckResponse(res) } return f.shouldRetry(ctx, err) }) if err != nil { return nil, err } loc := res.Header.Get("Location") rx := &resumableUpload{ f: f, remote: remote, URI: loc, Media: in, MediaType: contentType, ContentLength: size, } return rx.Upload(ctx) } // Make an http.Request for the range passed in func (rx *resumableUpload) makeRequest(ctx context.Context, start int64, body io.ReadSeeker, reqSize int64) *http.Request { req, _ := http.NewRequestWithContext(ctx, "POST", rx.URI, body) req.ContentLength = reqSize totalSize := "*" if rx.ContentLength >= 0 { totalSize = strconv.FormatInt(rx.ContentLength, 10) } if reqSize != 0 { req.Header.Set("Content-Range", fmt.Sprintf("bytes %v-%v/%v", start, start+reqSize-1, totalSize)) } else { req.Header.Set("Content-Range", fmt.Sprintf("bytes */%v", totalSize)) } req.Header.Set("Content-Type", rx.MediaType) return req } // Transfer a chunk - caller must call googleapi.CloseBody(res) if err == nil || res != nil func (rx *resumableUpload) transferChunk(ctx context.Context, start int64, chunk io.ReadSeeker, chunkSize int64) (int, error) { _, _ = chunk.Seek(0, io.SeekStart) req := rx.makeRequest(ctx, start, chunk, chunkSize) res, err := rx.f.client.Do(req) if err != nil { return 599, err } defer googleapi.CloseBody(res) if res.StatusCode == statusResumeIncomplete { return res.StatusCode, nil } err = googleapi.CheckResponse(res) if err != nil { return res.StatusCode, err } // When the entire file upload is complete, the server // responds with an HTTP 201 Created along with any metadata // associated with this resource. If this request had been // updating an existing entity rather than creating a new one, // the HTTP response code for a completed upload would have // been 200 OK. // // So parse the response out of the body. We aren't expecting // any other 2xx codes, so we parse it unconditionally on // StatusCode if err = json.NewDecoder(res.Body).Decode(&rx.ret); err != nil { return 598, err } return res.StatusCode, nil } // Upload uploads the chunks from the input // It retries each chunk using the pacer and --low-level-retries func (rx *resumableUpload) Upload(ctx context.Context) (*drive.File, error) { start := int64(0) var StatusCode int var err error buf := make([]byte, int(rx.f.opt.ChunkSize)) for finished := false; !finished; { var reqSize int64 var chunk io.ReadSeeker if rx.ContentLength >= 0 { // If size known use repeatable reader for smoother bwlimit if start >= rx.ContentLength { break } reqSize = min(rx.ContentLength-start, int64(rx.f.opt.ChunkSize)) chunk = readers.NewRepeatableLimitReaderBuffer(rx.Media, buf, reqSize) } else { // If size unknown read into buffer var n int n, err = readers.ReadFill(rx.Media, buf) if err == io.EOF { // Send the last chunk with the correct ContentLength // otherwise Google doesn't know we've finished rx.ContentLength = start + int64(n) finished = true } else if err != nil { return nil, err } reqSize = int64(n) chunk = bytes.NewReader(buf[:reqSize]) } // Transfer the chunk err = rx.f.pacer.Call(func() (bool, error) { fs.Debugf(rx.remote, "Sending chunk %d length %d", start, reqSize) StatusCode, err = rx.transferChunk(ctx, start, chunk, reqSize) again, err := rx.f.shouldRetry(ctx, err) if StatusCode == statusResumeIncomplete || StatusCode == http.StatusCreated || StatusCode == http.StatusOK { again = false err = nil } return again, err }) if err != nil { return nil, err } start += reqSize } // Resume or retry uploads that fail due to connection interruptions or // any 5xx errors, including: // // 500 Internal Server Error // 502 Bad Gateway // 503 Service Unavailable // 504 Gateway Timeout // // Use an exponential backoff strategy if any 5xx server error is // returned when resuming or retrying upload requests. These errors can // occur if a server is getting overloaded. Exponential backoff can help // alleviate these kinds of problems during periods of high volume of // requests or heavy network traffic. Other kinds of requests should not // be handled by exponential backoff but you can still retry a number of // them. When retrying these requests, limit the number of times you // retry them. For example your code could limit to ten retries or less // before reporting an error. // // Handle 404 Not Found errors when doing resumable uploads by starting // the entire upload over from the beginning. if rx.ret == nil { return nil, fserrors.RetryErrorf("Incomplete upload - retry, last error %d", StatusCode) } return rx.ret, nil } rclone-v1.71.0/backend/dropbox/000077500000000000000000000000001505210326400163125ustar00rootroot00000000000000rclone-v1.71.0/backend/dropbox/batcher.go000066400000000000000000000042561505210326400202600ustar00rootroot00000000000000// This file contains the implementation of the sync batcher for uploads // // Dropbox rules say you can start as many batches as you want, but // you may only have one batch being committed and must wait for the // batch to be finished before committing another. package dropbox import ( "context" "fmt" "github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox/files" ) // finishBatch commits the batch, returning a batch status to poll or maybe complete func (f *Fs) finishBatch(ctx context.Context, items []*files.UploadSessionFinishArg) (complete *files.UploadSessionFinishBatchResult, err error) { var arg = &files.UploadSessionFinishBatchArg{ Entries: items, } err = f.pacer.Call(func() (bool, error) { complete, err = f.srv.UploadSessionFinishBatchV2(arg) if retry, err := shouldRetryExclude(ctx, err); !retry { return retry, err } // after the first chunk is uploaded, we retry everything except the excluded errors return err != nil, err }) if err != nil { return nil, fmt.Errorf("batch commit failed: %w", err) } return complete, nil } // Called by the batcher to commit a batch func (f *Fs) commitBatch(ctx context.Context, items []*files.UploadSessionFinishArg, results []*files.FileMetadata, errors []error) (err error) { // finalise the batch getting either a result or a job id to poll complete, err := f.finishBatch(ctx, items) if err != nil { return err } // Check we got the right number of entries entries := complete.Entries if len(entries) != len(results) { return fmt.Errorf("expecting %d items in batch but got %d", len(results), len(entries)) } // Format results for return for i := range results { item := entries[i] if item.Tag == "success" { results[i] = item.Success } else { errorTag := item.Tag if item.Failure != nil { errorTag = item.Failure.Tag if item.Failure.LookupFailed != nil { errorTag += "/" + item.Failure.LookupFailed.Tag } if item.Failure.Path != nil { errorTag += "/" + item.Failure.Path.Tag } if item.Failure.PropertiesError != nil { errorTag += "/" + item.Failure.PropertiesError.Tag } } errors[i] = fmt.Errorf("upload failed: %s", errorTag) } } return nil } rclone-v1.71.0/backend/dropbox/dbhash/000077500000000000000000000000001505210326400175435ustar00rootroot00000000000000rclone-v1.71.0/backend/dropbox/dbhash/dbhash.go000066400000000000000000000060621505210326400213270ustar00rootroot00000000000000// Package dbhash implements the dropbox hash as described in // // https://www.dropbox.com/developers/reference/content-hash package dbhash import ( "crypto/sha256" "hash" ) const ( // BlockSize of the checksum in bytes. BlockSize = sha256.BlockSize // Size of the checksum in bytes. Size = sha256.BlockSize bytesPerBlock = 4 * 1024 * 1024 hashReturnedError = "hash function returned error" ) type digest struct { n int // bytes written into blockHash so far blockHash hash.Hash totalHash hash.Hash sumCalled bool writtenMore bool } // New returns a new hash.Hash computing the Dropbox checksum. func New() hash.Hash { d := &digest{} d.Reset() return d } // writeBlockHash writes the current block hash into the total hash func (d *digest) writeBlockHash() { blockHash := d.blockHash.Sum(nil) _, err := d.totalHash.Write(blockHash) if err != nil { panic(hashReturnedError) } // reset counters for blockhash d.n = 0 d.blockHash.Reset() } // Write writes len(p) bytes from p to the underlying data stream. It returns // the number of bytes written from p (0 <= n <= len(p)) and any error // encountered that caused the write to stop early. Write must return a non-nil // error if it returns n < len(p). Write must not modify the slice data, even // temporarily. // // Implementations must not retain p. func (d *digest) Write(p []byte) (n int, err error) { n = len(p) for len(p) > 0 { d.writtenMore = true toWrite := min(bytesPerBlock-d.n, len(p)) _, err = d.blockHash.Write(p[:toWrite]) if err != nil { panic(hashReturnedError) } d.n += toWrite p = p[toWrite:] // Accumulate the total hash if d.n == bytesPerBlock { d.writeBlockHash() } } return n, nil } // Sum appends the current hash to b and returns the resulting slice. // It does not change the underlying hash state. // // TODO(ncw) Sum() can only be called once for this type of hash. // If you call Sum(), then Write() then Sum() it will result in // a panic. Calling Write() then Sum(), then Sum() is OK. func (d *digest) Sum(b []byte) []byte { if d.sumCalled && d.writtenMore { panic("digest.Sum() called more than once") } d.sumCalled = true d.writtenMore = false if d.n != 0 { d.writeBlockHash() } return d.totalHash.Sum(b) } // Reset resets the Hash to its initial state. func (d *digest) Reset() { d.n = 0 d.totalHash = sha256.New() d.blockHash = sha256.New() d.sumCalled = false d.writtenMore = false } // Size returns the number of bytes Sum will return. func (d *digest) Size() int { return d.totalHash.Size() } // BlockSize returns the hash's underlying block size. // The Write method must be able to accept any amount // of data, but it may operate more efficiently if all writes // are a multiple of the block size. func (d *digest) BlockSize() int { return d.totalHash.BlockSize() } // Sum returns the Dropbox checksum of the data. func Sum(data []byte) [Size]byte { var d digest d.Reset() _, _ = d.Write(data) var out [Size]byte d.Sum(out[:0]) return out } // must implement this interface var _ hash.Hash = (*digest)(nil) rclone-v1.71.0/backend/dropbox/dbhash/dbhash_test.go000066400000000000000000000054411505210326400223660ustar00rootroot00000000000000package dbhash_test import ( "encoding/hex" "fmt" "testing" "github.com/rclone/rclone/backend/dropbox/dbhash" "github.com/stretchr/testify/assert" ) func testChunk(t *testing.T, chunk int) { data := make([]byte, chunk) for i := range chunk { data[i] = 'A' } for _, test := range []struct { n int want string }{ {0, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"}, {1, "1cd6ef71e6e0ff46ad2609d403dc3fee244417089aa4461245a4e4fe23a55e42"}, {2, "01e0655fb754d10418a73760f57515f4903b298e6d67dda6bf0987fa79c22c88"}, {4096, "8620913d33852befe09f16fff8fd75f77a83160d29f76f07e0276e9690903035"}, {4194303, "647c8627d70f7a7d13ce96b1e7710a771a55d41a62c3da490d92e56044d311fa"}, {4194304, "d4d63bac5b866c71620185392a8a6218ac1092454a2d16f820363b69852befa3"}, {4194305, "8f553da8d00d0bf509d8470e242888be33019c20c0544811f5b2b89e98360b92"}, {8388607, "83b30cf4fb5195b04a937727ae379cf3d06673bf8f77947f6a92858536e8369c"}, {8388608, "e08b3ba1f538804075c5f939accdeaa9efc7b5c01865c94a41e78ca6550a88e7"}, {8388609, "02c8a4aefc2bfc9036f89a7098001865885938ca580e5c9e5db672385edd303c"}, } { d := dbhash.New() var toWrite int for toWrite = test.n; toWrite >= chunk; toWrite -= chunk { n, err := d.Write(data) assert.Nil(t, err) assert.Equal(t, chunk, n) } n, err := d.Write(data[:toWrite]) assert.Nil(t, err) assert.Equal(t, toWrite, n) got := hex.EncodeToString(d.Sum(nil)) assert.Equal(t, test.want, got, fmt.Sprintf("when testing length %d", n)) } } func TestHashChunk16M(t *testing.T) { testChunk(t, 16*1024*1024) } func TestHashChunk8M(t *testing.T) { testChunk(t, 8*1024*1024) } func TestHashChunk4M(t *testing.T) { testChunk(t, 4*1024*1024) } func TestHashChunk2M(t *testing.T) { testChunk(t, 2*1024*1024) } func TestHashChunk1M(t *testing.T) { testChunk(t, 1*1024*1024) } func TestHashChunk64k(t *testing.T) { testChunk(t, 64*1024) } func TestHashChunk32k(t *testing.T) { testChunk(t, 32*1024) } func TestHashChunk2048(t *testing.T) { testChunk(t, 2048) } func TestHashChunk2047(t *testing.T) { testChunk(t, 2047) } func TestSumCalledTwice(t *testing.T) { d := dbhash.New() assert.NotPanics(t, func() { d.Sum(nil) }) d.Reset() assert.NotPanics(t, func() { d.Sum(nil) }) assert.NotPanics(t, func() { d.Sum(nil) }) _, _ = d.Write([]byte{1}) assert.Panics(t, func() { d.Sum(nil) }) } func TestSize(t *testing.T) { d := dbhash.New() assert.Equal(t, 32, d.Size()) } func TestBlockSize(t *testing.T) { d := dbhash.New() assert.Equal(t, 64, d.BlockSize()) } func TestSum(t *testing.T) { assert.Equal(t, [64]byte{ 0x1c, 0xd6, 0xef, 0x71, 0xe6, 0xe0, 0xff, 0x46, 0xad, 0x26, 0x09, 0xd4, 0x03, 0xdc, 0x3f, 0xee, 0x24, 0x44, 0x17, 0x08, 0x9a, 0xa4, 0x46, 0x12, 0x45, 0xa4, 0xe4, 0xfe, 0x23, 0xa5, 0x5e, 0x42, }, dbhash.Sum([]byte{'A'}), ) } rclone-v1.71.0/backend/dropbox/dropbox.go000066400000000000000000001715771505210326400203400ustar00rootroot00000000000000// Package dropbox provides an interface to Dropbox object storage package dropbox // FIXME dropbox for business would be quite easy to add /* The Case folding of PathDisplay problem From the docs: path_display String. The cased path to be used for display purposes only. In rare instances the casing will not correctly match the user's filesystem, but this behavior will match the path provided in the Core API v1, and at least the last path component will have the correct casing. Changes to only the casing of paths won't be returned by list_folder/continue. This field will be null if the file or folder is not mounted. This field is optional. We solve this by not implementing the ListR interface. The dropbox remote will recurse directory by directory only using the last element of path_display and all will be well. */ import ( "context" "errors" "fmt" "io" "path" "regexp" "strings" "time" "unicode/utf8" "github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox" "github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox/auth" "github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox/common" "github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox/files" "github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox/sharing" "github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox/team" "github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox/users" "github.com/rclone/rclone/backend/dropbox/dbhash" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/lib/batcher" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/oauthutil" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/readers" "golang.org/x/oauth2" ) // Constants const ( rcloneClientID = "5jcck7diasz0rqy" rcloneEncryptedClientSecret = "fRS5vVLr2v6FbyXYnIgjwBuUAt0osq_QZTXAEcmZ7g" defaultMinSleep = fs.Duration(10 * time.Millisecond) maxSleep = 2 * time.Second decayConstant = 2 // bigger for slower decay, exponential // Upload chunk size - setting too small makes uploads slow. // Chunks are buffered into memory for retries. // // Speed vs chunk size uploading a 1 GiB file on 2017-11-22 // // Chunk Size MiB, Speed MiB/s, % of max // 1 1.364 11% // 2 2.443 19% // 4 4.288 33% // 8 6.79 52% // 16 8.916 69% // 24 10.195 79% // 32 10.427 81% // 40 10.96 85% // 48 11.828 91% // 56 11.763 91% // 64 12.047 93% // 96 12.302 95% // 128 12.945 100% // // Choose 48 MiB which is 91% of Maximum speed. rclone by // default does 4 transfers so this should use 4*48 MiB = 192 MiB // by default. defaultChunkSize = 48 * fs.Mebi maxChunkSize = 150 * fs.Mebi // Max length of filename parts: https://help.dropbox.com/installs-integrations/sync-uploads/files-not-syncing maxFileNameLength = 255 ) type exportAPIFormat string type exportExtension string // dotless var ( // Description of how to auth for this app dropboxConfig = &oauthutil.Config{ Scopes: []string{ "files.metadata.write", "files.content.write", "files.content.read", "sharing.write", "account_info.read", // needed for About // "file_requests.write", // "members.read", // needed for impersonate - but causes app to need to be approved by Dropbox Team Admin during the flow // "team_data.member" }, // Endpoint: oauth2.Endpoint{ // AuthURL: "https://www.dropbox.com/1/oauth2/authorize", // TokenURL: "https://api.dropboxapi.com/1/oauth2/token", // }, AuthURL: dropbox.OAuthEndpoint("").AuthURL, TokenURL: dropbox.OAuthEndpoint("").TokenURL, ClientID: rcloneClientID, ClientSecret: obscure.MustReveal(rcloneEncryptedClientSecret), RedirectURL: oauthutil.RedirectLocalhostURL, } // A regexp matching path names for files Dropbox ignores // See https://www.dropbox.com/en/help/145 - Ignored files ignoredFiles = regexp.MustCompile(`(?i)(^|/)(desktop\.ini|thumbs\.db|\.ds_store|icon\r|\.dropbox|\.dropbox.attr)$`) // DbHashType is the hash.Type for Dropbox DbHashType hash.Type // Errors errNotSupportedInSharedMode = fserrors.NoRetryError(errors.New("not supported in shared files mode")) // Configure the batcher defaultBatcherOptions = batcher.Options{ MaxBatchSize: 1000, DefaultTimeoutSync: 500 * time.Millisecond, DefaultTimeoutAsync: 10 * time.Second, DefaultBatchSizeAsync: 100, } exportKnownAPIFormats = map[exportAPIFormat]exportExtension{ "markdown": "md", "html": "html", } // Populated based on exportKnownAPIFormats exportKnownExtensions = map[exportExtension]exportAPIFormat{} paperExtension = ".paper" paperTemplateExtension = ".papert" ) // Gets an oauth config with the right scopes func getOauthConfig(m configmap.Mapper) *oauthutil.Config { // If not impersonating, use standard scopes if impersonate, _ := m.Get("impersonate"); impersonate == "" { return dropboxConfig } // Make a copy of the config config := *dropboxConfig // Make a copy of the scopes with extra scopes requires appended config.Scopes = append(config.Scopes, "members.read", "team_data.member") return &config } // Register with Fs func init() { DbHashType = hash.RegisterHash("dropbox", "DropboxHash", 64, dbhash.New) fs.Register(&fs.RegInfo{ Name: "dropbox", Description: "Dropbox", NewFs: NewFs, Config: func(ctx context.Context, name string, m configmap.Mapper, config fs.ConfigIn) (*fs.ConfigOut, error) { return oauthutil.ConfigOut("", &oauthutil.Options{ OAuth2Config: getOauthConfig(m), NoOffline: true, OAuth2Opts: []oauth2.AuthCodeOption{ oauth2.SetAuthURLParam("token_access_type", "offline"), }, }) }, Options: append(append(oauthutil.SharedOptions, []fs.Option{{ Name: "chunk_size", Help: fmt.Sprintf(`Upload chunk size (< %v). Any files larger than this will be uploaded in chunks of this size. Note that chunks are buffered in memory (one at a time) so rclone can deal with retries. Setting this larger will increase the speed slightly (at most 10%% for 128 MiB in tests) at the cost of using more memory. It can be set smaller if you are tight on memory.`, maxChunkSize), Default: defaultChunkSize, Advanced: true, }, { Name: "impersonate", Help: `Impersonate this user when using a business account. Note that if you want to use impersonate, you should make sure this flag is set when running "rclone config" as this will cause rclone to request the "members.read" scope which it won't normally. This is needed to lookup a members email address into the internal ID that dropbox uses in the API. Using the "members.read" scope will require a Dropbox Team Admin to approve during the OAuth flow. You will have to use your own App (setting your own client_id and client_secret) to use this option as currently rclone's default set of permissions doesn't include "members.read". This can be added once v1.55 or later is in use everywhere. `, Default: "", Advanced: true, Sensitive: true, }, { Name: "shared_files", Help: `Instructs rclone to work on individual shared files. In this mode rclone's features are extremely limited - only list (ls, lsl, etc.) operations and read operations (e.g. downloading) are supported in this mode. All other operations will be disabled.`, Default: false, Advanced: true, }, { Name: "shared_folders", Help: `Instructs rclone to work on shared folders. When this flag is used with no path only the List operation is supported and all available shared folders will be listed. If you specify a path the first part will be interpreted as the name of shared folder. Rclone will then try to mount this shared to the root namespace. On success shared folder rclone proceeds normally. The shared folder is now pretty much a normal folder and all normal operations are supported. Note that we don't unmount the shared folder afterwards so the --dropbox-shared-folders can be omitted after the first use of a particular shared folder. See also --dropbox-root-namespace for an alternative way to work with shared folders.`, Default: false, Advanced: true, }, { Name: "pacer_min_sleep", Default: defaultMinSleep, Help: "Minimum time to sleep between API calls.", Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, // https://www.dropbox.com/help/syncing-uploads/files-not-syncing lists / and \ // as invalid characters. // Testing revealed names with trailing spaces and the DEL character don't work. // Also encode invalid UTF-8 bytes as json doesn't handle them properly. Default: encoder.Base | encoder.EncodeBackSlash | encoder.EncodeDel | encoder.EncodeRightSpace | encoder.EncodeInvalidUtf8, }, { Name: "root_namespace", Help: "Specify a different Dropbox namespace ID to use as the root for all paths.", Default: "", Advanced: true, }, { Name: "export_formats", Help: `Comma separated list of preferred formats for exporting files Certain Dropbox files can only be accessed by exporting them to another format. These include Dropbox Paper documents. For each such file, rclone will choose the first format on this list that Dropbox considers valid. If none is valid, it will choose Dropbox's default format. Known formats include: "html", "md" (markdown)`, Default: fs.CommaSepList{"html", "md"}, Advanced: true, }, { Name: "skip_exports", Help: "Skip exportable files in all listings.\n\nIf given, exportable files practically become invisible to rclone.", Default: false, Advanced: true, }, { Name: "show_all_exports", Default: false, Help: `Show all exportable files in listings. Adding this flag will allow all exportable files to be server side copied. Note that rclone doesn't add extensions to the exportable file names in this mode. Do **not** use this flag when trying to download exportable files - rclone will fail to download them. `, Advanced: true, }, }...), defaultBatcherOptions.FsOptions("For full info see [the main docs](https://rclone.org/dropbox/#batch-mode)\n\n")...), }) for apiFormat, ext := range exportKnownAPIFormats { exportKnownExtensions[ext] = apiFormat } } // Options defines the configuration for this backend type Options struct { ChunkSize fs.SizeSuffix `config:"chunk_size"` Impersonate string `config:"impersonate"` SharedFiles bool `config:"shared_files"` SharedFolders bool `config:"shared_folders"` BatchMode string `config:"batch_mode"` BatchSize int `config:"batch_size"` BatchTimeout fs.Duration `config:"batch_timeout"` AsyncBatch bool `config:"async_batch"` PacerMinSleep fs.Duration `config:"pacer_min_sleep"` Enc encoder.MultiEncoder `config:"encoding"` RootNsid string `config:"root_namespace"` ExportFormats fs.CommaSepList `config:"export_formats"` SkipExports bool `config:"skip_exports"` ShowAllExports bool `config:"show_all_exports"` } // Fs represents a remote dropbox server type Fs struct { name string // name of this remote root string // the path we are working on opt Options // parsed options ci *fs.ConfigInfo // global config features *fs.Features // optional features srv files.Client // the connection to the dropbox server svc files.Client // the connection to the dropbox server (unauthorized) sharing sharing.Client // as above, but for generating sharing links users users.Client // as above, but for accessing user information team team.Client // for the Teams API slashRoot string // root with "/" prefix, lowercase slashRootSlash string // root with "/" prefix and postfix, lowercase pacer *fs.Pacer // To pace the API calls ns string // The namespace we are using or "" for none batcher *batcher.Batcher[*files.UploadSessionFinishArg, *files.FileMetadata] exportExts []exportExtension } type exportType int const ( notExport exportType = iota // a regular file exportHide // should be hidden exportListOnly // listable, but can't export exportExportable // can export ) // Object describes a dropbox object // // Dropbox Objects always have full metadata type Object struct { fs *Fs // what this object is part of id string url string remote string // The remote path bytes int64 // size of the object modTime time.Time // time it was last modified hash string // content_hash of the object exportType exportType exportAPIFormat exportAPIFormat } // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("Dropbox root '%s'", f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // Some specific errors which should be excluded from retries func shouldRetryExclude(ctx context.Context, err error) (bool, error) { if err == nil { return false, err } if fserrors.ContextError(ctx, &err) { return false, err } // First check for specific errors // // These come back from the SDK in a whole host of different // error types, but there doesn't seem to be a consistent way // of reading the error cause, so here we just check using the // error string which isn't perfect but does the job. errString := err.Error() if strings.Contains(errString, "insufficient_space") { return false, fserrors.FatalError(err) } else if strings.Contains(errString, "malformed_path") { return false, fserrors.NoRetryError(err) } return true, err } // shouldRetry returns a boolean as to whether this err deserves to be // retried. It returns the err as a convenience func shouldRetry(ctx context.Context, err error) (bool, error) { if retry, err := shouldRetryExclude(ctx, err); !retry { return retry, err } // Then handle any official Retry-After header from Dropbox's SDK switch e := err.(type) { case auth.RateLimitAPIError: if e.RateLimitError.RetryAfter > 0 { fs.Logf(nil, "Error %v. Too many requests or write operations. Trying again in %d seconds.", err, e.RateLimitError.RetryAfter) err = pacer.RetryAfterError(err, time.Duration(e.RateLimitError.RetryAfter)*time.Second) } return true, err } // Keep old behavior for backward compatibility errString := err.Error() if strings.Contains(errString, "too_many_write_operations") || strings.Contains(errString, "too_many_requests") || errString == "" { return true, err } return fserrors.ShouldRetry(err), err } func checkUploadChunkSize(cs fs.SizeSuffix) error { const minChunkSize = fs.SizeSuffixBase if cs < minChunkSize { return fmt.Errorf("%s is less than %s", cs, minChunkSize) } if cs > maxChunkSize { return fmt.Errorf("%s is greater than %s", cs, maxChunkSize) } return nil } func (f *Fs) setUploadChunkSize(cs fs.SizeSuffix) (old fs.SizeSuffix, err error) { err = checkUploadChunkSize(cs) if err == nil { old, f.opt.ChunkSize = f.opt.ChunkSize, cs } return } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } err = checkUploadChunkSize(opt.ChunkSize) if err != nil { return nil, fmt.Errorf("dropbox: chunk size: %w", err) } // Convert the old token if it exists. The old token was just // just a string, the new one is a JSON blob oldToken, ok := m.Get(config.ConfigToken) oldToken = strings.TrimSpace(oldToken) if ok && oldToken != "" && oldToken[0] != '{' { fs.Infof(name, "Converting token to new format") newToken := fmt.Sprintf(`{"access_token":%q,"token_type":"bearer","expiry":"0001-01-01T00:00:00Z"}`, oldToken) err := config.SetValueAndSave(name, config.ConfigToken, newToken) if err != nil { return nil, fmt.Errorf("NewFS convert token: %w", err) } } oAuthClient, _, err := oauthutil.NewClient(ctx, name, m, getOauthConfig(m)) if err != nil { return nil, fmt.Errorf("failed to configure dropbox: %w", err) } ci := fs.GetConfig(ctx) f := &Fs{ name: name, opt: *opt, ci: ci, pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(opt.PacerMinSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), } batcherOptions := defaultBatcherOptions batcherOptions.Mode = f.opt.BatchMode batcherOptions.Size = f.opt.BatchSize batcherOptions.Timeout = time.Duration(f.opt.BatchTimeout) f.batcher, err = batcher.New(ctx, f, f.commitBatch, batcherOptions) if err != nil { return nil, err } cfg := dropbox.Config{ LogLevel: dropbox.LogOff, // logging in the SDK: LogOff, LogDebug, LogInfo Client: oAuthClient, // maybe??? HeaderGenerator: f.headerGenerator, } for _, e := range opt.ExportFormats { ext := exportExtension(e) if exportKnownExtensions[ext] == "" { return nil, fmt.Errorf("dropbox: unknown export format '%s'", e) } f.exportExts = append(f.exportExts, ext) } // unauthorized config for endpoints that fail with auth ucfg := dropbox.Config{ LogLevel: dropbox.LogOff, // logging in the SDK: LogOff, LogDebug, LogInfo } // NOTE: needs to be created pre-impersonation so we can look up the impersonated user f.team = team.New(cfg) if opt.Impersonate != "" { user := team.UserSelectorArg{ Email: opt.Impersonate, } user.Tag = "email" members := []*team.UserSelectorArg{&user} args := team.NewMembersGetInfoArgs(members) memberIDs, err := f.team.MembersGetInfo(args) if err != nil { return nil, fmt.Errorf("invalid dropbox team member: %q: %w", opt.Impersonate, err) } if len(memberIDs) == 0 || memberIDs[0].MemberInfo == nil || memberIDs[0].MemberInfo.Profile == nil { return nil, fmt.Errorf("dropbox team member not found: %q", opt.Impersonate) } cfg.AsMemberID = memberIDs[0].MemberInfo.Profile.MemberProfile.TeamMemberId } f.srv = files.New(cfg) f.svc = files.New(ucfg) f.sharing = sharing.New(cfg) f.users = users.New(cfg) f.features = (&fs.Features{ CaseInsensitive: true, ReadMimeType: false, CanHaveEmptyDirectories: true, }) // do not fill features yet if f.opt.SharedFiles { f.setRoot(root) if f.root == "" { return f, nil } _, err := f.findSharedFile(ctx, f.root) f.root = "" if err == nil { return f, fs.ErrorIsFile } return f, nil } if f.opt.SharedFolders { f.setRoot(root) if f.root == "" { return f, nil // our root it empty so we probably want to list shared folders } dir := path.Dir(f.root) if dir == "." { dir = f.root } // root is not empty so we have find the right shared folder if it exists id, err := f.findSharedFolder(ctx, dir) if err != nil { // if we didn't find the specified shared folder we have to bail out here return nil, err } // we found the specified shared folder so let's mount it // this will add it to the users normal root namespace and allows us // to actually perform operations on it using the normal api endpoints. err = f.mountSharedFolder(ctx, id) if err != nil { switch e := err.(type) { case sharing.MountFolderAPIError: if e.EndpointError == nil || (e.EndpointError != nil && e.EndpointError.Tag != sharing.MountFolderErrorAlreadyMounted) { return nil, err } default: return nil, err } // if the mount failed we have to abort here } // if the mount succeeded it's now a normal folder in the users root namespace // we disable shared folder mode and proceed normally f.opt.SharedFolders = false } f.features.Fill(ctx, f) if f.opt.RootNsid != "" { f.ns = f.opt.RootNsid fs.Debugf(f, "Overriding root namespace to %q", f.ns) } else if strings.HasPrefix(root, "/") { // If root starts with / then use the actual root var acc *users.FullAccount err = f.pacer.Call(func() (bool, error) { acc, err = f.users.GetCurrentAccount() return shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("get current account failed: %w", err) } switch x := acc.RootInfo.(type) { case *common.TeamRootInfo: f.ns = x.RootNamespaceId case *common.UserRootInfo: f.ns = x.RootNamespaceId default: return nil, fmt.Errorf("unknown RootInfo type %v %T", acc.RootInfo, acc.RootInfo) } fs.Debugf(f, "Using root namespace %q", f.ns) } f.setRoot(root) // See if the root is actually an object if f.root != "" { _, err = f.getFileMetadata(ctx, f.slashRoot) if err == nil { newRoot := path.Dir(f.root) if newRoot == "." { newRoot = "" } f.setRoot(newRoot) // return an error with an fs which points to the parent return f, fs.ErrorIsFile } } return f, nil } // headerGenerator for dropbox sdk func (f *Fs) headerGenerator(hostType string, namespace string, route string) map[string]string { if f.ns == "" { return map[string]string{} } return map[string]string{ "Dropbox-API-Path-Root": `{".tag": "namespace_id", "namespace_id": "` + f.ns + `"}`, } } // Sets root in f func (f *Fs) setRoot(root string) { f.root = strings.Trim(root, "/") f.slashRoot = "/" + f.root f.slashRootSlash = f.slashRoot if f.root != "" { f.slashRootSlash += "/" } } type getMetadataResult struct { entry files.IsMetadata notFound bool err error } // getMetadata gets the metadata for a file or directory func (f *Fs) getMetadata(ctx context.Context, objPath string) (res getMetadataResult) { res.err = f.pacer.Call(func() (bool, error) { res.entry, res.err = f.srv.GetMetadata(&files.GetMetadataArg{ Path: f.opt.Enc.FromStandardPath(objPath), }) return shouldRetry(ctx, res.err) }) if res.err != nil { switch e := res.err.(type) { case files.GetMetadataAPIError: if e.EndpointError != nil && e.EndpointError.Path != nil && e.EndpointError.Path.Tag == files.LookupErrorNotFound { res.notFound = true res.err = nil } } } return } // Get metadata such that the result would be exported with the given extension // Return a channel that will eventually receive the metadata func (f *Fs) getMetadataForExt(ctx context.Context, filePath string, wantExportExtension exportExtension) chan getMetadataResult { ch := make(chan getMetadataResult, 1) wantDownloadable := (wantExportExtension == "") go func() { defer close(ch) res := f.getMetadata(ctx, filePath) info, ok := res.entry.(*files.FileMetadata) if !ok { // Can't check anything about file, just return what we have ch <- res return } // Return notFound if downloadability or extension doesn't match if wantDownloadable != info.IsDownloadable { ch <- getMetadataResult{notFound: true} return } if !info.IsDownloadable { _, ext := f.chooseExportFormat(info) if ext != wantExportExtension { ch <- getMetadataResult{notFound: true} return } } // Return our real result or error ch <- res }() return ch } // For a given rclone-path, figure out what the Dropbox-path may be, in order of preference. // Multiple paths might be plausible, due to export path munging. func (f *Fs) possibleMetadatas(ctx context.Context, filePath string) (ret []<-chan getMetadataResult) { ret = []<-chan getMetadataResult{} // Prefer an exact match ret = append(ret, f.getMetadataForExt(ctx, filePath, "")) // Check if we're plausibly an export path, otherwise we're done if f.opt.SkipExports || f.opt.ShowAllExports { return } dotted := path.Ext(filePath) if dotted == "" { return } ext := exportExtension(dotted[1:]) if exportKnownExtensions[ext] == "" { return } // We might be an export path! Try all possibilities base := strings.TrimSuffix(filePath, dotted) // `foo.papert.md` will only come from `foo.papert`. Never check something like `foo.papert.paper` if strings.HasSuffix(base, paperTemplateExtension) { ret = append(ret, f.getMetadataForExt(ctx, base, ext)) return } // Otherwise, try both `foo.md` coming from `foo`, or from `foo.paper` ret = append(ret, f.getMetadataForExt(ctx, base, ext)) ret = append(ret, f.getMetadataForExt(ctx, base+paperExtension, ext)) return } // getFileMetadata gets the metadata for a file func (f *Fs) getFileMetadata(ctx context.Context, filePath string) (*files.FileMetadata, error) { var res getMetadataResult // Try all possible metadatas possibleMetadatas := f.possibleMetadatas(ctx, filePath) for _, ch := range possibleMetadatas { res = <-ch if res.err != nil { return nil, res.err } if !res.notFound { break } } if res.notFound { return nil, fs.ErrorObjectNotFound } fileInfo, ok := res.entry.(*files.FileMetadata) if !ok { if _, ok = res.entry.(*files.FolderMetadata); ok { return nil, fs.ErrorIsDir } return nil, fs.ErrorNotAFile } return fileInfo, nil } // getDirMetadata gets the metadata for a directory func (f *Fs) getDirMetadata(ctx context.Context, dirPath string) (*files.FolderMetadata, error) { res := f.getMetadata(ctx, dirPath) if res.err != nil { return nil, res.err } if res.notFound { return nil, fs.ErrorDirNotFound } dirInfo, ok := res.entry.(*files.FolderMetadata) if !ok { return nil, fs.ErrorIsFile } return dirInfo, nil } // Return an Object from a path // // If it can't be found it returns the error fs.ErrorObjectNotFound. func (f *Fs) newObjectWithInfo(ctx context.Context, remote string, info *files.FileMetadata) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } var err error if info != nil { err = o.setMetadataFromEntry(info) } else { err = o.readEntryAndSetMetadata(ctx) } if err != nil { return nil, err } return o, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { if f.opt.SharedFiles { return f.findSharedFile(ctx, remote) } return f.newObjectWithInfo(ctx, remote, nil) } // listSharedFolders lists all available shared folders mounted and not mounted // we'll need the id later so we have to return them in original format func (f *Fs) listSharedFolders(ctx context.Context) (entries fs.DirEntries, err error) { started := false var res *sharing.ListFoldersResult for { if !started { arg := sharing.ListFoldersArgs{ Limit: 100, } err := f.pacer.Call(func() (bool, error) { res, err = f.sharing.ListFolders(&arg) return shouldRetry(ctx, err) }) if err != nil { return nil, err } started = true } else { arg := sharing.ListFoldersContinueArg{ Cursor: res.Cursor, } err := f.pacer.Call(func() (bool, error) { res, err = f.sharing.ListFoldersContinue(&arg) return shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("list continue: %w", err) } } for _, entry := range res.Entries { leaf := f.opt.Enc.ToStandardName(entry.Name) d := fs.NewDir(leaf, time.Time{}).SetID(entry.SharedFolderId) entries = append(entries, d) if err != nil { return nil, err } } if res.Cursor == "" { break } } return entries, nil } // findSharedFolder find the id for a given shared folder name // somewhat annoyingly there is no endpoint to query a shared folder by it's name // so our only option is to iterate over all shared folders func (f *Fs) findSharedFolder(ctx context.Context, name string) (id string, err error) { entries, err := f.listSharedFolders(ctx) if err != nil { return "", err } for _, entry := range entries { if entry.(*fs.Dir).Remote() == name { return entry.(*fs.Dir).ID(), nil } } return "", fs.ErrorDirNotFound } // mountSharedFolder mount a shared folder to the root namespace func (f *Fs) mountSharedFolder(ctx context.Context, id string) error { arg := sharing.MountFolderArg{ SharedFolderId: id, } err := f.pacer.Call(func() (bool, error) { _, err := f.sharing.MountFolder(&arg) return shouldRetry(ctx, err) }) return err } // listReceivedFiles lists shared the user as access to (note this means individual // files not files contained in shared folders) func (f *Fs) listReceivedFiles(ctx context.Context) (entries fs.DirEntries, err error) { started := false var res *sharing.ListFilesResult for { if !started { arg := sharing.ListFilesArg{ Limit: 100, } err := f.pacer.Call(func() (bool, error) { res, err = f.sharing.ListReceivedFiles(&arg) return shouldRetry(ctx, err) }) if err != nil { return nil, err } started = true } else { arg := sharing.ListFilesContinueArg{ Cursor: res.Cursor, } err := f.pacer.Call(func() (bool, error) { res, err = f.sharing.ListReceivedFilesContinue(&arg) return shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("list continue: %w", err) } } for _, entry := range res.Entries { fmt.Printf("%+v\n", entry) entryPath := entry.Name o := &Object{ fs: f, url: entry.PreviewUrl, remote: entryPath, modTime: *entry.TimeInvited, } if err != nil { return nil, err } entries = append(entries, o) } if res.Cursor == "" { break } } return entries, nil } func (f *Fs) findSharedFile(ctx context.Context, name string) (o *Object, err error) { files, err := f.listReceivedFiles(ctx) if err != nil { return nil, err } for _, entry := range files { if entry.(*Object).remote == name { return entry.(*Object), nil } } return nil, fs.ErrorObjectNotFound } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { if f.opt.SharedFiles { return f.listReceivedFiles(ctx) } if f.opt.SharedFolders { return f.listSharedFolders(ctx) } root := f.slashRoot if dir != "" { root += "/" + dir } started := false var res *files.ListFolderResult for { if !started { arg := files.NewListFolderArg(f.opt.Enc.FromStandardPath(root)) arg.Recursive = false arg.Limit = 1000 if root == "/" { arg.Path = "" // Specify root folder as empty string } err = f.pacer.Call(func() (bool, error) { res, err = f.srv.ListFolder(arg) return shouldRetry(ctx, err) }) if err != nil { switch e := err.(type) { case files.ListFolderAPIError: if e.EndpointError != nil && e.EndpointError.Path != nil && e.EndpointError.Path.Tag == files.LookupErrorNotFound { err = fs.ErrorDirNotFound } } return nil, err } started = true } else { arg := files.ListFolderContinueArg{ Cursor: res.Cursor, } err = f.pacer.Call(func() (bool, error) { res, err = f.srv.ListFolderContinue(&arg) return shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("list continue: %w", err) } } for _, entry := range res.Entries { var fileInfo *files.FileMetadata var folderInfo *files.FolderMetadata var metadata *files.Metadata switch info := entry.(type) { case *files.FolderMetadata: folderInfo = info metadata = &info.Metadata case *files.FileMetadata: fileInfo = info metadata = &info.Metadata default: fs.Errorf(f, "Unknown type %T", entry) continue } // Only the last element is reliably cased in PathDisplay entryPath := metadata.PathDisplay leaf := f.opt.Enc.ToStandardName(path.Base(entryPath)) remote := path.Join(dir, leaf) if folderInfo != nil { d := fs.NewDir(remote, time.Time{}).SetID(folderInfo.Id) entries = append(entries, d) } else if fileInfo != nil { o, err := f.newObjectWithInfo(ctx, remote, fileInfo) if err != nil { return nil, err } if o.(*Object).exportType.listable() { entries = append(entries, o) } } } if !res.HasMore { break } } return entries, nil } // Put the object // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { if f.opt.SharedFiles || f.opt.SharedFolders { return nil, errNotSupportedInSharedMode } // Temporary Object under construction o := &Object{ fs: f, remote: src.Remote(), } return o, o.Update(ctx, in, src, options...) } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } // Mkdir creates the container if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) error { if f.opt.SharedFiles || f.opt.SharedFolders { return errNotSupportedInSharedMode } root := path.Join(f.slashRoot, dir) // can't create or run metadata on root if root == "/" { return nil } // check directory doesn't exist _, err := f.getDirMetadata(ctx, root) if err == nil { return nil // directory exists already } else if err != fs.ErrorDirNotFound { return err // some other error } // create it arg2 := files.CreateFolderArg{ Path: f.opt.Enc.FromStandardPath(root), } // Don't attempt to create filenames that are too long if cErr := checkPathLength(arg2.Path); cErr != nil { return cErr } err = f.pacer.Call(func() (bool, error) { _, err = f.srv.CreateFolderV2(&arg2) return shouldRetry(ctx, err) }) return err } // 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) (err error) { root := path.Join(f.slashRoot, dir) // can't remove root if root == "/" { return errors.New("can't remove root directory") } encRoot := f.opt.Enc.FromStandardPath(root) if check { // check directory exists _, err = f.getDirMetadata(ctx, root) if err != nil { return fmt.Errorf("Rmdir: %w", err) } // check directory empty arg := files.NewListFolderArg(encRoot) arg.Recursive = false if root == "/" { arg.Path = "" // Specify root folder as empty string } var res *files.ListFolderResult err = f.pacer.Call(func() (bool, error) { res, err = f.srv.ListFolder(arg) return shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("Rmdir: %w", err) } if len(res.Entries) != 0 { return errors.New("directory not empty") } } // remove it err = f.pacer.Call(func() (bool, error) { _, err = f.srv.DeleteV2(&files.DeleteArg{Path: encRoot}) return shouldRetry(ctx, err) }) return err } // Rmdir deletes the container // // Returns an error if it isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { if f.opt.SharedFiles || f.opt.SharedFolders { return errNotSupportedInSharedMode } return f.purgeCheck(ctx, dir, true) } // Precision returns the precision func (f *Fs) Precision() time.Duration { return time.Second } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't copy - not same remote type") return nil, fs.ErrorCantCopy } // Find and remove existing object cleanup, err := operations.RemoveExisting(ctx, f, remote, "server side copy") if err != nil { return nil, err } defer cleanup(&err) // Temporary Object under construction dstObj := &Object{ fs: f, remote: remote, } // Copy arg := files.RelocationArg{ RelocationPath: files.RelocationPath{ FromPath: f.opt.Enc.FromStandardPath(srcObj.remotePath()), ToPath: f.opt.Enc.FromStandardPath(dstObj.remotePath()), }, } var result *files.RelocationResult err = f.pacer.Call(func() (bool, error) { result, err = f.srv.CopyV2(&arg) return shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("copy failed: %w", err) } // Set the metadata fileInfo, ok := result.Metadata.(*files.FileMetadata) if !ok { return nil, fs.ErrorNotAFile } err = dstObj.setMetadataFromEntry(fileInfo) if err != nil { return nil, fmt.Errorf("copy failed: %w", err) } return dstObj, nil } // Purge deletes all the files and the container // // Optional interface: Only implement this if you have a way of // deleting all the files quicker than just running Remove() on the // result of List() func (f *Fs) Purge(ctx context.Context, dir string) (err error) { return f.purgeCheck(ctx, dir, false) } // Move src to this remote using server-side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't move - not same remote type") return nil, fs.ErrorCantMove } // Temporary Object under construction dstObj := &Object{ fs: f, remote: remote, } // Do the move arg := files.RelocationArg{ RelocationPath: files.RelocationPath{ FromPath: f.opt.Enc.FromStandardPath(srcObj.remotePath()), ToPath: f.opt.Enc.FromStandardPath(dstObj.remotePath()), }, } var err error var result *files.RelocationResult err = f.pacer.Call(func() (bool, error) { result, err = f.srv.MoveV2(&arg) return shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("move failed: %w", err) } // Set the metadata fileInfo, ok := result.Metadata.(*files.FileMetadata) if !ok { return nil, fs.ErrorNotAFile } err = dstObj.setMetadataFromEntry(fileInfo) if err != nil { return nil, fmt.Errorf("move failed: %w", err) } return dstObj, nil } // PublicLink adds a "readable by anyone with link" permission on the given file or folder. func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (link string, err error) { absPath := f.opt.Enc.FromStandardPath(path.Join(f.slashRoot, remote)) fs.Debugf(f, "attempting to share '%s' (absolute path: %s)", remote, absPath) createArg := sharing.CreateSharedLinkWithSettingsArg{ Path: absPath, Settings: &sharing.SharedLinkSettings{ RequestedVisibility: &sharing.RequestedVisibility{ Tagged: dropbox.Tagged{Tag: sharing.RequestedVisibilityPublic}, }, Audience: &sharing.LinkAudience{ Tagged: dropbox.Tagged{Tag: sharing.LinkAudiencePublic}, }, Access: &sharing.RequestedLinkAccessLevel{ Tagged: dropbox.Tagged{Tag: sharing.RequestedLinkAccessLevelViewer}, }, }, } if expire < fs.DurationOff { expiryTime := time.Now().Add(time.Duration(expire)).UTC().Round(time.Second) createArg.Settings.Expires = &expiryTime } var linkRes sharing.IsSharedLinkMetadata err = f.pacer.Call(func() (bool, error) { linkRes, err = f.sharing.CreateSharedLinkWithSettings(&createArg) return shouldRetry(ctx, err) }) if err != nil && createArg.Settings.Expires != nil && strings.Contains(err.Error(), sharing.SharedLinkSettingsErrorNotAuthorized) { // Some plans can't create links with expiry fs.Debugf(absPath, "can't create link with expiry, trying without") createArg.Settings.Expires = nil err = f.pacer.Call(func() (bool, error) { linkRes, err = f.sharing.CreateSharedLinkWithSettings(&createArg) return shouldRetry(ctx, err) }) } if err != nil && strings.Contains(err.Error(), sharing.CreateSharedLinkWithSettingsErrorSharedLinkAlreadyExists) { fs.Debugf(absPath, "has a public link already, attempting to retrieve it") listArg := sharing.ListSharedLinksArg{ Path: absPath, DirectOnly: true, } var listRes *sharing.ListSharedLinksResult err = f.pacer.Call(func() (bool, error) { listRes, err = f.sharing.ListSharedLinks(&listArg) return shouldRetry(ctx, err) }) if err != nil { return } if len(listRes.Links) == 0 { err = errors.New("sharing link already exists, but list came back empty") return } linkRes = listRes.Links[0] } if err == nil { switch res := linkRes.(type) { case *sharing.FileLinkMetadata: link = res.Url case *sharing.FolderLinkMetadata: link = res.Url default: err = fmt.Errorf("don't know how to extract link, response has unknown format: %T", res) } } return } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } srcPath := path.Join(srcFs.slashRoot, srcRemote) dstPath := path.Join(f.slashRoot, dstRemote) // Check if destination exists _, err := f.getDirMetadata(ctx, dstPath) if err == nil { return fs.ErrorDirExists } else if err != fs.ErrorDirNotFound { return err } // Make sure the parent directory exists // ...apparently not necessary // Do the move arg := files.RelocationArg{ RelocationPath: files.RelocationPath{ FromPath: f.opt.Enc.FromStandardPath(srcPath), ToPath: f.opt.Enc.FromStandardPath(dstPath), }, } err = f.pacer.Call(func() (bool, error) { _, err = f.srv.MoveV2(&arg) return shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("MoveDir failed: %w", err) } return nil } // About gets quota information func (f *Fs) About(ctx context.Context) (usage *fs.Usage, err error) { var q *users.SpaceUsage err = f.pacer.Call(func() (bool, error) { q, err = f.users.GetSpaceUsage() return shouldRetry(ctx, err) }) if err != nil { return nil, err } var total uint64 used := q.Used if q.Allocation != nil { if q.Allocation.Individual != nil { total += q.Allocation.Individual.Allocated } if q.Allocation.Team != nil { total += q.Allocation.Team.Allocated // Override used with Team.Used as this includes q.Used already used = q.Allocation.Team.Used } } 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 } return usage, nil } // ChangeNotify calls the passed function with a path that has had changes. // If the implementation uses polling, it should adhere to the given interval. // // Automatically restarts itself in case of unexpected behavior of the remote. // // Close the returned channel to stop being notified. func (f *Fs) ChangeNotify(ctx context.Context, notifyFunc func(string, fs.EntryType), pollIntervalChan <-chan time.Duration) { go func() { // get the StartCursor early so all changes from now on get processed startCursor, err := f.changeNotifyCursor(ctx) if err != nil { fs.Infof(f, "Failed to get StartCursor: %s", err) } var ticker *time.Ticker var tickerC <-chan time.Time for { select { case pollInterval, ok := <-pollIntervalChan: if !ok { if ticker != nil { ticker.Stop() } return } if ticker != nil { ticker.Stop() ticker, tickerC = nil, nil } if pollInterval != 0 { ticker = time.NewTicker(pollInterval) tickerC = ticker.C } case <-tickerC: if startCursor == "" { startCursor, err = f.changeNotifyCursor(ctx) if err != nil { fs.Infof(f, "Failed to get StartCursor: %s", err) continue } } fs.Debugf(f, "Checking for changes on remote") startCursor, err = f.changeNotifyRunner(ctx, notifyFunc, startCursor) if err != nil { fs.Infof(f, "Change notify listener failure: %s", err) } } } }() } func (f *Fs) changeNotifyCursor(ctx context.Context) (cursor string, err error) { var startCursor *files.ListFolderGetLatestCursorResult err = f.pacer.Call(func() (bool, error) { arg := files.NewListFolderArg(f.opt.Enc.FromStandardPath(f.slashRoot)) arg.Recursive = true if arg.Path == "/" { arg.Path = "" } startCursor, err = f.srv.ListFolderGetLatestCursor(arg) return shouldRetry(ctx, err) }) if err != nil { return } return startCursor.Cursor, nil } func (f *Fs) changeNotifyRunner(ctx context.Context, notifyFunc func(string, fs.EntryType), startCursor string) (newCursor string, err error) { cursor := startCursor var res *files.ListFolderLongpollResult // Dropbox sets a timeout range of 30 - 480 timeout := uint64(f.ci.TimeoutOrInfinite() / time.Second) if timeout < 30 { timeout = 30 fs.Debugf(f, "Increasing poll interval to minimum 30s") } if timeout > 480 { timeout = 480 fs.Debugf(f, "Decreasing poll interval to maximum 480s") } err = f.pacer.Call(func() (bool, error) { args := files.ListFolderLongpollArg{ Cursor: cursor, Timeout: timeout, } res, err = f.svc.ListFolderLongpoll(&args) return shouldRetry(ctx, err) }) if err != nil { return } if !res.Changes { return cursor, nil } if res.Backoff != 0 { fs.Debugf(f, "Waiting to poll for %d seconds", res.Backoff) time.Sleep(time.Duration(res.Backoff) * time.Second) } for { var changeList *files.ListFolderResult arg := files.ListFolderContinueArg{ Cursor: cursor, } err = f.pacer.Call(func() (bool, error) { changeList, err = f.srv.ListFolderContinue(&arg) return shouldRetry(ctx, err) }) if err != nil { return "", fmt.Errorf("list continue: %w", err) } cursor = changeList.Cursor var entryType fs.EntryType for _, entry := range changeList.Entries { entryPath := "" switch info := entry.(type) { case *files.FolderMetadata: entryType = fs.EntryDirectory entryPath = strings.TrimPrefix(info.PathDisplay, f.slashRootSlash) case *files.FileMetadata: entryType = fs.EntryObject entryPath = strings.TrimPrefix(info.PathDisplay, f.slashRootSlash) case *files.DeletedMetadata: entryType = fs.EntryObject entryPath = strings.TrimPrefix(info.PathDisplay, f.slashRootSlash) default: fs.Errorf(entry, "dropbox ChangeNotify: ignoring unknown EntryType %T", entry) continue } if entryPath != "" { notifyFunc(f.opt.Enc.ToStandardPath(entryPath), entryType) } } if !changeList.HasMore { break } } return cursor, nil } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(DbHashType) } // Shutdown the backend, closing any background tasks and any // cached connections. func (f *Fs) Shutdown(ctx context.Context) error { f.batcher.Shutdown() return nil } func (f *Fs) chooseExportFormat(info *files.FileMetadata) (exportAPIFormat, exportExtension) { // Find API export formats Dropbox supports for this file // Sometimes Dropbox lists a format in ExportAs but not ExportOptions, so check both ei := info.ExportInfo dropboxFormatStrings := append([]string{ei.ExportAs}, ei.ExportOptions...) // Find which extensions these correspond to exportExtensions := map[exportExtension]exportAPIFormat{} var dropboxPreferredAPIFormat exportAPIFormat var dropboxPreferredExtension exportExtension for _, format := range dropboxFormatStrings { apiFormat := exportAPIFormat(format) // Only consider formats we know about if ext, ok := exportKnownAPIFormats[apiFormat]; ok { if dropboxPreferredAPIFormat == "" { dropboxPreferredAPIFormat = apiFormat dropboxPreferredExtension = ext } exportExtensions[ext] = apiFormat } } // See if the user picked a valid extension for _, ext := range f.exportExts { if apiFormat, ok := exportExtensions[ext]; ok { return apiFormat, ext } } // If no matches, prefer the first valid format Dropbox lists return dropboxPreferredAPIFormat, dropboxPreferredExtension } // ------------------------------------------------------------ func (et exportType) listable() bool { return et != exportHide } // something we should _try_ to export func (et exportType) exportable() bool { return et == exportExportable || et == exportListOnly } // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // ID returns the object id func (o *Object) ID() string { return o.id } // Hash returns the dropbox special hash func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if o.fs.opt.SharedFiles || o.fs.opt.SharedFolders { return "", errNotSupportedInSharedMode } if t != DbHashType { return "", hash.ErrUnsupported } err := o.readMetaData(ctx) if err != nil { return "", fmt.Errorf("failed to read hash from metadata: %w", err) } return o.hash, nil } // Size returns the size of an object in bytes func (o *Object) Size() int64 { return o.bytes } func (o *Object) setMetadataForExport(info *files.FileMetadata) { o.bytes = -1 o.hash = "" if o.fs.opt.SkipExports { o.exportType = exportHide return } if o.fs.opt.ShowAllExports { o.exportType = exportListOnly return } var exportExt exportExtension o.exportAPIFormat, exportExt = o.fs.chooseExportFormat(info) if o.exportAPIFormat == "" { o.exportType = exportHide } else { o.exportType = exportExportable // get rid of any paper extension, if present o.remote = strings.TrimSuffix(o.remote, paperExtension) // add the export extension o.remote += "." + string(exportExt) } } // setMetadataFromEntry sets the fs data from a files.FileMetadata // // This isn't a complete set of metadata and has an inaccurate date func (o *Object) setMetadataFromEntry(info *files.FileMetadata) error { o.id = info.Id o.bytes = int64(info.Size) o.modTime = info.ClientModified o.hash = info.ContentHash if !info.IsDownloadable { o.setMetadataForExport(info) } return nil } // Reads the entry for a file from dropbox func (o *Object) readEntry(ctx context.Context) (*files.FileMetadata, error) { return o.fs.getFileMetadata(ctx, o.remotePath()) } // Read entry if not set and set metadata from it func (o *Object) readEntryAndSetMetadata(ctx context.Context) error { // Last resort set time from client if !o.modTime.IsZero() { return nil } entry, err := o.readEntry(ctx) if err != nil { return err } return o.setMetadataFromEntry(entry) } // Returns the remote path for the object func (o *Object) remotePath() string { return o.fs.slashRootSlash + o.remote } // readMetaData gets the info if it hasn't already been fetched func (o *Object) readMetaData(ctx context.Context) (err error) { if !o.modTime.IsZero() { return nil } // Last resort return o.readEntryAndSetMetadata(ctx) } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers func (o *Object) ModTime(ctx context.Context) time.Time { err := o.readMetaData(ctx) if err != nil { fs.Debugf(o, "Failed to read metadata: %v", err) return time.Now() } return o.modTime } // SetModTime sets the modification time of the local fs object // // Commits the datastore func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { // Dropbox doesn't have a way of doing this so returning this // error will cause the file to be deleted first then // re-uploaded to set the time. return fs.ErrorCantSetModTimeWithoutDelete } // Storable returns whether this object is storable func (o *Object) Storable() bool { return true } func (o *Object) export(ctx context.Context) (in io.ReadCloser, err error) { if o.exportType == exportListOnly || o.exportAPIFormat == "" { fs.Debugf(o.remote, "No export format found") return nil, fs.ErrorObjectNotFound } arg := files.ExportArg{Path: o.id, ExportFormat: string(o.exportAPIFormat)} var exportResult *files.ExportResult err = o.fs.pacer.Call(func() (bool, error) { exportResult, in, err = o.fs.srv.Export(&arg) return shouldRetry(ctx, err) }) if err != nil { return nil, err } o.bytes = int64(exportResult.ExportMetadata.Size) o.hash = exportResult.ExportMetadata.ExportHash return } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { if o.fs.opt.SharedFiles { if len(options) != 0 { return nil, errors.New("OpenOptions not supported for shared files") } arg := sharing.GetSharedLinkMetadataArg{ Url: o.url, } err = o.fs.pacer.Call(func() (bool, error) { _, in, err = o.fs.sharing.GetSharedLinkFile(&arg) return shouldRetry(ctx, err) }) if err != nil { return nil, err } return } if o.exportType.exportable() { return o.export(ctx) } fs.FixRangeOption(options, o.bytes) headers := fs.OpenOptionHeaders(options) arg := files.DownloadArg{ Path: o.id, ExtraHeaders: headers, } err = o.fs.pacer.Call(func() (bool, error) { _, in, err = o.fs.srv.Download(&arg) return shouldRetry(ctx, err) }) switch e := err.(type) { case files.DownloadAPIError: // Don't attempt to retry copyright violation errors if e.EndpointError != nil && e.EndpointError.Path != nil && e.EndpointError.Path.Tag == files.LookupErrorRestrictedContent { return nil, fserrors.NoRetryError(err) } } return } // uploadChunked uploads the object in parts // // Will introduce two additional network requests to start and finish the session. // If the size is unknown (i.e. -1) the method incurs one additional // request to the Dropbox API that does not carry a payload to close the append session. func (o *Object) uploadChunked(ctx context.Context, in0 io.Reader, commitInfo *files.CommitInfo, size int64) (entry *files.FileMetadata, err error) { // start upload var res *files.UploadSessionStartResult err = o.fs.pacer.Call(func() (bool, error) { res, err = o.fs.srv.UploadSessionStart(&files.UploadSessionStartArg{}, nil) return shouldRetry(ctx, err) }) if err != nil { return nil, err } chunkSize := int64(o.fs.opt.ChunkSize) chunks, remainder := size/chunkSize, size%chunkSize if remainder > 0 { chunks++ } // write chunks in := readers.NewCountingReader(in0) buf := make([]byte, int(chunkSize)) cursor := files.UploadSessionCursor{ SessionId: res.SessionId, Offset: 0, } appendArg := files.UploadSessionAppendArg{Cursor: &cursor} for currentChunk := 1; ; currentChunk++ { cursor.Offset = in.BytesRead() if chunks < 0 { fs.Debugf(o, "Streaming chunk %d/unknown", currentChunk) } else { fs.Debugf(o, "Uploading chunk %d/%d", currentChunk, chunks) } chunk := readers.NewRepeatableLimitReaderBuffer(in, buf, chunkSize) skip := int64(0) err = o.fs.pacer.Call(func() (bool, error) { // seek to the start in case this is a retry if _, err = chunk.Seek(skip, io.SeekStart); err != nil { return false, err } err = o.fs.srv.UploadSessionAppendV2(&appendArg, chunk) // after session is started, we retry everything if err != nil { // Check for incorrect offset error and retry with new offset if uErr, ok := err.(files.UploadSessionAppendV2APIError); ok { if uErr.EndpointError != nil && uErr.EndpointError.IncorrectOffset != nil { correctOffset := uErr.EndpointError.IncorrectOffset.CorrectOffset delta := int64(correctOffset) - int64(cursor.Offset) skip += delta what := fmt.Sprintf("incorrect offset error received: sent %d, need %d, skip %d", cursor.Offset, correctOffset, skip) if skip < 0 { return false, fmt.Errorf("can't seek backwards to correct offset: %s", what) } else if skip == chunkSize { fs.Debugf(o, "%s: chunk received OK - continuing", what) return false, nil } else if skip > chunkSize { // This error should never happen return false, fmt.Errorf("can't seek forwards by more than a chunk to correct offset: %s", what) } // Skip the sent data on next retry cursor.Offset = uint64(int64(cursor.Offset) + delta) fs.Debugf(o, "%s: skipping bytes on retry to fix offset", what) } } } return err != nil, err }) if err != nil { return nil, err } if appendArg.Close { break } if size > 0 { // if size is known, check if next chunk is final appendArg.Close = uint64(size)-in.BytesRead() <= uint64(chunkSize) if in.BytesRead() > uint64(size) { return nil, fmt.Errorf("expected %d bytes in input, but have read %d so far", size, in.BytesRead()) } } else { // if size is unknown, upload as long as we can read full chunks from the reader appendArg.Close = in.BytesRead()-cursor.Offset < uint64(chunkSize) } } // finish upload cursor.Offset = in.BytesRead() args := &files.UploadSessionFinishArg{ Cursor: &cursor, Commit: commitInfo, } // If we are batching then we should have written all the data now // store the commit info now for a batch commit if o.fs.batcher.Batching() { return o.fs.batcher.Commit(ctx, o.remote, args) } err = o.fs.pacer.Call(func() (bool, error) { entry, err = o.fs.srv.UploadSessionFinish(args, nil) if retry, err := shouldRetryExclude(ctx, err); !retry { return retry, err } // after the first chunk is uploaded, we retry everything except the excluded errors return err != nil, err }) if err != nil { return nil, err } return entry, nil } // checks all the parts of name to see they are below // maxFileNameLength runes. // // This checks the length as runes which isn't quite right as dropbox // seems to encode some symbols (eg ☺) as two "characters". This seems // like utf-16 except that ☺ doesn't need two characters in utf-16. // // Using runes instead of what dropbox is using will work for most // cases, and when it goes wrong we will upload something we should // have detected as too long which is the least damaging way to fail. func checkPathLength(name string) (err error) { for next := ""; len(name) > 0; name = next { if slash := strings.IndexRune(name, '/'); slash >= 0 { name, next = name[:slash], name[slash+1:] } else { next = "" } length := utf8.RuneCountInString(name) if length > maxFileNameLength { return fserrors.NoRetryError(fs.ErrorFileNameTooLong) } } return nil } // Update the already existing object // // Copy the reader into the object updating modTime and size. // // The new object may have been created if an error is returned func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { if o.fs.opt.SharedFiles || o.fs.opt.SharedFolders { return errNotSupportedInSharedMode } remote := o.remotePath() if ignoredFiles.MatchString(remote) { return fserrors.NoRetryError(fmt.Errorf("file name %q is disallowed - not uploading", path.Base(remote))) } commitInfo := files.NewCommitInfo(o.fs.opt.Enc.FromStandardPath(o.remotePath())) commitInfo.Mode.Tag = "overwrite" // The Dropbox API only accepts timestamps in UTC with second precision. clientModified := src.ModTime(ctx).UTC().Round(time.Second) commitInfo.ClientModified = &clientModified // Don't attempt to create filenames that are too long if cErr := checkPathLength(commitInfo.Path); cErr != nil { return cErr } size := src.Size() var err error var entry *files.FileMetadata if size > int64(o.fs.opt.ChunkSize) || size < 0 || o.fs.batcher.Batching() { entry, err = o.uploadChunked(ctx, in, commitInfo, size) } else { err = o.fs.pacer.CallNoRetry(func() (bool, error) { entry, err = o.fs.srv.Upload(&files.UploadArg{CommitInfo: *commitInfo}, in) return shouldRetry(ctx, err) }) } if err != nil { return fmt.Errorf("upload failed: %w", err) } // If we haven't received data back from batch upload then fake it // // This will only happen if we are uploading async batches if entry == nil { o.bytes = size o.modTime = *commitInfo.ClientModified o.hash = "" // we don't have this return nil } return o.setMetadataFromEntry(entry) } // Remove an object func (o *Object) Remove(ctx context.Context) (err error) { if o.fs.opt.SharedFiles || o.fs.opt.SharedFolders { return errNotSupportedInSharedMode } err = o.fs.pacer.Call(func() (bool, error) { _, err = o.fs.srv.DeleteV2(&files.DeleteArg{ Path: o.fs.opt.Enc.FromStandardPath(o.remotePath()), }) return shouldRetry(ctx, err) }) return err } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.PublicLinker = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.Shutdowner = &Fs{} _ fs.Object = (*Object)(nil) _ fs.IDer = (*Object)(nil) ) rclone-v1.71.0/backend/dropbox/dropbox_internal_test.go000066400000000000000000000054301505210326400232530ustar00rootroot00000000000000package dropbox import ( "context" "io" "strings" "testing" "github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox" "github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox/files" "github.com/rclone/rclone/fstest/fstests" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestInternalCheckPathLength(t *testing.T) { rep := func(n int, r rune) (out string) { rs := make([]rune, n) for i := range rs { rs[i] = r } return string(rs) } for _, test := range []struct { in string ok bool }{ {in: "", ok: true}, {in: rep(maxFileNameLength, 'a'), ok: true}, {in: rep(maxFileNameLength+1, 'a'), ok: false}, {in: rep(maxFileNameLength, '£'), ok: true}, {in: rep(maxFileNameLength+1, '£'), ok: false}, {in: rep(maxFileNameLength, '☺'), ok: true}, {in: rep(maxFileNameLength+1, '☺'), ok: false}, {in: rep(maxFileNameLength, '你'), ok: true}, {in: rep(maxFileNameLength+1, '你'), ok: false}, {in: "/ok/ok", ok: true}, {in: "/ok/" + rep(maxFileNameLength, 'a') + "/ok", ok: true}, {in: "/ok/" + rep(maxFileNameLength+1, 'a') + "/ok", ok: false}, {in: "/ok/" + rep(maxFileNameLength, '£') + "/ok", ok: true}, {in: "/ok/" + rep(maxFileNameLength+1, '£') + "/ok", ok: false}, {in: "/ok/" + rep(maxFileNameLength, '☺') + "/ok", ok: true}, {in: "/ok/" + rep(maxFileNameLength+1, '☺') + "/ok", ok: false}, {in: "/ok/" + rep(maxFileNameLength, '你') + "/ok", ok: true}, {in: "/ok/" + rep(maxFileNameLength+1, '你') + "/ok", ok: false}, } { err := checkPathLength(test.in) assert.Equal(t, test.ok, err == nil, test.in) } } func (f *Fs) importPaperForTest(t *testing.T) { content := `# test doc Lorem ipsum __dolor__ sit amet [link](http://google.com) ` arg := files.PaperCreateArg{ Path: f.slashRootSlash + "export.paper", ImportFormat: &files.ImportFormat{Tagged: dropbox.Tagged{Tag: files.ImportFormatMarkdown}}, } var err error err = f.pacer.Call(func() (bool, error) { reader := strings.NewReader(content) _, err = f.srv.PaperCreate(&arg, reader) return shouldRetry(context.Background(), err) }) require.NoError(t, err) } func (f *Fs) InternalTestPaperExport(t *testing.T) { ctx := context.Background() f.importPaperForTest(t) f.exportExts = []exportExtension{"html"} obj, err := f.NewObject(ctx, "export.html") require.NoError(t, err) rc, err := obj.Open(ctx) require.NoError(t, err) defer func() { require.NoError(t, rc.Close()) }() buf, err := io.ReadAll(rc) require.NoError(t, err) text := string(buf) for _, excerpt := range []string{ "Lorem ipsum", "dolor", `href="http://google.com"`, } { require.Contains(t, text, excerpt) } } func (f *Fs) InternalTest(t *testing.T) { t.Run("PaperExport", f.InternalTestPaperExport) } var _ fstests.InternalTester = (*Fs)(nil) rclone-v1.71.0/backend/dropbox/dropbox_test.go000066400000000000000000000011131505210326400213510ustar00rootroot00000000000000// Test Dropbox filesystem interface package dropbox import ( "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestDropbox:", NilObject: (*Object)(nil), ChunkedUpload: fstests.ChunkedUploadConfig{ MaxChunkSize: maxChunkSize, }, }) } func (f *Fs) SetUploadChunkSize(cs fs.SizeSuffix) (fs.SizeSuffix, error) { return f.setUploadChunkSize(cs) } var _ fstests.SetUploadChunkSizer = (*Fs)(nil) rclone-v1.71.0/backend/fichier/000077500000000000000000000000001505210326400162465ustar00rootroot00000000000000rclone-v1.71.0/backend/fichier/api.go000066400000000000000000000346371505210326400173630ustar00rootroot00000000000000package fichier import ( "context" "errors" "fmt" "io" "net/http" "net/url" "regexp" "strconv" "strings" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/lib/rest" ) // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 429, // Too Many Requests. 403, // Forbidden (may happen when request limit is exceeded) 500, // Internal Server Error 502, // Bad Gateway 503, // Service Unavailable 504, // Gateway Timeout 509, // Bandwidth Limit Exceeded } var errorRegex = regexp.MustCompile(`#(\d{1,3})`) func parseFichierError(err error) int { matches := errorRegex.FindStringSubmatch(err.Error()) if len(matches) == 0 { return 0 } code, err := strconv.Atoi(matches[1]) if err != nil { fs.Debugf(nil, "failed parsing fichier error: %v", err) return 0 } return code } // shouldRetry returns a boolean as to whether this resp and err // deserve to be retried. It returns the err as a convenience func shouldRetry(ctx context.Context, resp *http.Response, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } // 1Fichier uses HTTP error code 403 (Forbidden) for all kinds of errors with // responses looking like this: "{\"message\":\"Flood detected: IP Locked #374\",\"status\":\"KO\"}" // // We attempt to parse the actual 1Fichier error code from this body and handle it accordingly // Most importantly #374 (Flood detected: IP locked) which the integration tests provoke // The list below is far from complete and should be expanded if we see any more error codes. if err != nil { switch parseFichierError(err) { case 93: return false, err // No such user case 186: return false, err // IP blocked? case 374, 412: // Flood detected seems to be #412 now fs.Debugf(nil, "Sleeping for 30 seconds due to: %v", err) time.Sleep(30 * time.Second) default: } } return fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(resp, retryErrorCodes), err } var isAlphaNumeric = regexp.MustCompile(`^[a-zA-Z0-9]+$`).MatchString func (f *Fs) createObject(ctx context.Context, remote string) (o *Object, leaf string, directoryID string, err error) { // Create the directory for the object if it doesn't exist leaf, directoryID, err = f.dirCache.FindPath(ctx, remote, true) if err != nil { return } // Temporary Object under construction o = &Object{ fs: f, remote: remote, } return o, leaf, directoryID, nil } func (f *Fs) readFileInfo(ctx context.Context, url string) (*File, error) { request := FileInfoRequest{ URL: url, } opts := rest.Opts{ Method: "POST", Path: "/file/info.cgi", } var file File err := f.pacer.Call(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, &request, &file) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't read file info: %w", err) } return &file, err } // maybe do some actual validation later if necessary func validToken(token *GetTokenResponse) bool { return token.Status == "OK" } func (f *Fs) getDownloadToken(ctx context.Context, url string) (*GetTokenResponse, error) { request := DownloadRequest{ URL: url, Single: 1, Pass: f.opt.FilePassword, } if f.opt.CDN { request.CDN = 1 } opts := rest.Opts{ Method: "POST", Path: "/download/get_token.cgi", } var token GetTokenResponse err := f.pacer.Call(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, &request, &token) doretry, err := shouldRetry(ctx, resp, err) return doretry || !validToken(&token), err }) if err != nil { return nil, fmt.Errorf("couldn't list files: %w", err) } return &token, nil } func fileFromSharedFile(file *SharedFile) File { return File{ URL: file.Link, Filename: file.Filename, Size: file.Size, } } func (f *Fs) listSharedFiles(ctx context.Context, id string) (entries fs.DirEntries, err error) { opts := rest.Opts{ Method: "GET", RootURL: "https://1fichier.com/dir/", Path: id, Parameters: map[string][]string{"json": {"1"}}, ContentType: "application/x-www-form-urlencoded", } if f.opt.FolderPassword != "" { opts.Method = "POST" opts.Parameters = nil opts.Body = strings.NewReader("json=1&pass=" + url.QueryEscape(f.opt.FolderPassword)) } var sharedFiles SharedFolderResponse err = f.pacer.Call(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, nil, &sharedFiles) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't list files: %w", err) } entries = make([]fs.DirEntry, len(sharedFiles)) for i, sharedFile := range sharedFiles { entries[i] = f.newObjectFromFile(ctx, "", fileFromSharedFile(&sharedFile)) } return entries, nil } func (f *Fs) listFiles(ctx context.Context, directoryID int) (filesList *FilesList, err error) { // fs.Debugf(f, "Requesting files for dir `%s`", directoryID) request := ListFilesRequest{ FolderID: directoryID, } opts := rest.Opts{ Method: "POST", Path: "/file/ls.cgi", } filesList = &FilesList{} err = f.pacer.Call(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, &request, filesList) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't list files: %w", err) } for i := range filesList.Items { item := &filesList.Items[i] item.Filename = f.opt.Enc.ToStandardName(item.Filename) } return filesList, nil } func (f *Fs) listFolders(ctx context.Context, directoryID int) (foldersList *FoldersList, err error) { // fs.Debugf(f, "Requesting folders for id `%s`", directoryID) request := ListFolderRequest{ FolderID: directoryID, } opts := rest.Opts{ Method: "POST", Path: "/folder/ls.cgi", } foldersList = &FoldersList{} err = f.pacer.Call(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, &request, foldersList) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't list folders: %w", err) } foldersList.Name = f.opt.Enc.ToStandardName(foldersList.Name) for i := range foldersList.SubFolders { folder := &foldersList.SubFolders[i] folder.Name = f.opt.Enc.ToStandardName(folder.Name) } // fs.Debugf(f, "Got FoldersList for id `%s`", directoryID) return foldersList, err } func (f *Fs) listDir(ctx context.Context, dir string) (entries fs.DirEntries, err error) { directoryID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { return nil, err } folderID, err := strconv.Atoi(directoryID) if err != nil { return nil, err } files, err := f.listFiles(ctx, folderID) if err != nil { return nil, err } folders, err := f.listFolders(ctx, folderID) if err != nil { return nil, err } entries = make([]fs.DirEntry, len(files.Items)+len(folders.SubFolders)) for i, item := range files.Items { entries[i] = f.newObjectFromFile(ctx, dir, item) } for i, folder := range folders.SubFolders { createDate, err := time.Parse("2006-01-02 15:04:05", folder.CreateDate) if err != nil { return nil, err } fullPath := getRemote(dir, folder.Name) folderID := strconv.Itoa(folder.ID) entries[len(files.Items)+i] = fs.NewDir(fullPath, createDate).SetID(folderID) // fs.Debugf(f, "Put Path `%s` for id `%d` into dircache", fullPath, folder.ID) f.dirCache.Put(fullPath, folderID) } return entries, nil } func (f *Fs) newObjectFromFile(ctx context.Context, dir string, item File) *Object { return &Object{ fs: f, remote: getRemote(dir, item.Filename), file: item, } } func getRemote(dir, fileName string) string { if dir == "" { return fileName } return dir + "/" + fileName } func (f *Fs) makeFolder(ctx context.Context, leaf string, folderID int) (response *MakeFolderResponse, err error) { name := f.opt.Enc.FromStandardName(leaf) // fs.Debugf(f, "Creating folder `%s` in id `%s`", name, directoryID) request := MakeFolderRequest{ FolderID: folderID, Name: name, } opts := rest.Opts{ Method: "POST", Path: "/folder/mkdir.cgi", } response = &MakeFolderResponse{} err = f.pacer.Call(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, &request, response) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't create folder: %w", err) } // fs.Debugf(f, "Created Folder `%s` in id `%s`", name, directoryID) return response, err } func (f *Fs) removeFolder(ctx context.Context, name string, folderID int) (response *GenericOKResponse, err error) { // fs.Debugf(f, "Removing folder with id `%s`", directoryID) request := &RemoveFolderRequest{ FolderID: folderID, } opts := rest.Opts{ Method: "POST", Path: "/folder/rm.cgi", } response = &GenericOKResponse{} var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.rest.CallJSON(ctx, &opts, request, response) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't remove folder: %w", err) } if response.Status != "OK" { return nil, fmt.Errorf("can't remove folder: %s", response.Message) } // fs.Debugf(f, "Removed Folder with id `%s`", directoryID) return response, nil } func (f *Fs) deleteFile(ctx context.Context, url string) (response *GenericOKResponse, err error) { request := &RemoveFileRequest{ Files: []RmFile{ {url}, }, } opts := rest.Opts{ Method: "POST", Path: "/file/rm.cgi", } response = &GenericOKResponse{} err = f.pacer.Call(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, request, response) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't remove file: %w", err) } // fs.Debugf(f, "Removed file with url `%s`", url) return response, nil } func (f *Fs) moveFile(ctx context.Context, url string, folderID int, rename string) (response *MoveFileResponse, err error) { request := &MoveFileRequest{ URLs: []string{url}, FolderID: folderID, Rename: rename, } opts := rest.Opts{ Method: "POST", Path: "/file/mv.cgi", } response = &MoveFileResponse{} err = f.pacer.Call(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, request, response) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't copy file: %w", err) } return response, nil } func (f *Fs) moveDir(ctx context.Context, folderID int, newLeaf string, destinationFolderID int) (response *MoveDirResponse, err error) { request := &MoveDirRequest{ FolderID: folderID, DestinationFolderID: destinationFolderID, Rename: newLeaf, // DestinationUser: destinationUser, } opts := rest.Opts{ Method: "POST", Path: "/folder/mv.cgi", } response = &MoveDirResponse{} err = f.pacer.Call(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, request, response) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't move dir: %w", err) } return response, nil } func (f *Fs) copyFile(ctx context.Context, url string, folderID int, rename string) (response *CopyFileResponse, err error) { request := &CopyFileRequest{ URLs: []string{url}, FolderID: folderID, Rename: rename, } opts := rest.Opts{ Method: "POST", Path: "/file/cp.cgi", } response = &CopyFileResponse{} err = f.pacer.Call(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, request, response) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't copy file: %w", err) } return response, nil } func (f *Fs) renameFile(ctx context.Context, url string, newName string) (response *RenameFileResponse, err error) { request := &RenameFileRequest{ URLs: []RenameFileURL{ { URL: url, Filename: newName, }, }, } opts := rest.Opts{ Method: "POST", Path: "/file/rename.cgi", } response = &RenameFileResponse{} err = f.pacer.Call(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, request, response) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't rename file: %w", err) } return response, nil } func (f *Fs) getUploadNode(ctx context.Context) (response *GetUploadNodeResponse, err error) { // fs.Debugf(f, "Requesting Upload node") opts := rest.Opts{ Method: "GET", ContentType: "application/json", // 1Fichier API is bad Path: "/upload/get_upload_server.cgi", } response = &GetUploadNodeResponse{} err = f.pacer.Call(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, nil, response) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("didn't get an upload node: %w", err) } // fs.Debugf(f, "Got Upload node") return response, err } func (f *Fs) uploadFile(ctx context.Context, in io.Reader, size int64, fileName, folderID, uploadID, node string, options ...fs.OpenOption) (response *http.Response, err error) { // fs.Debugf(f, "Uploading File `%s`", fileName) fileName = f.opt.Enc.FromStandardName(fileName) if len(uploadID) > 10 || !isAlphaNumeric(uploadID) { return nil, errors.New("invalid UploadID") } opts := rest.Opts{ Method: "POST", Path: "/upload.cgi", Parameters: map[string][]string{ "id": {uploadID}, }, NoResponse: true, Body: in, ContentLength: &size, Options: options, MultipartContentName: "file[]", MultipartFileName: fileName, MultipartParams: map[string][]string{ "did": {folderID}, }, } if node != "" { opts.RootURL = "https://" + node } err = f.pacer.CallNoRetry(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, nil, nil) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't upload file: %w", err) } // fs.Debugf(f, "Uploaded File `%s`", fileName) return response, err } func (f *Fs) endUpload(ctx context.Context, uploadID string, nodeurl string) (response *EndFileUploadResponse, err error) { // fs.Debugf(f, "Ending File Upload `%s`", uploadID) if len(uploadID) > 10 || !isAlphaNumeric(uploadID) { return nil, errors.New("invalid UploadID") } opts := rest.Opts{ Method: "GET", Path: "/end.pl", RootURL: "https://" + nodeurl, Parameters: map[string][]string{ "xid": {uploadID}, }, ExtraHeaders: map[string]string{ "JSON": "1", }, } response = &EndFileUploadResponse{} err = f.pacer.Call(func() (bool, error) { resp, err := f.rest.CallJSON(ctx, &opts, nil, response) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't finish file upload: %w", err) } return response, err } rclone-v1.71.0/backend/fichier/fichier.go000066400000000000000000000421121505210326400202060ustar00rootroot00000000000000// Package fichier provides an interface to the 1Fichier storage system. package fichier import ( "context" "errors" "fmt" "io" "net/http" "strconv" "strings" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/dircache" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/rest" ) const ( rootID = "0" apiBaseURL = "https://api.1fichier.com/v1" minSleep = 400 * time.Millisecond // api is extremely rate limited now maxSleep = 5 * time.Second decayConstant = 2 // bigger for slower decay, exponential attackConstant = 0 // start with max sleep ) func init() { fs.Register(&fs.RegInfo{ Name: "fichier", Description: "1Fichier", NewFs: NewFs, Options: []fs.Option{{ Help: "Your API Key, get it from https://1fichier.com/console/params.pl.", Name: "api_key", Sensitive: true, }, { Help: "If you want to download a shared folder, add this parameter.", Name: "shared_folder", Advanced: true, }, { Help: "If you want to download a shared file that is password protected, add this parameter.", Name: "file_password", Advanced: true, IsPassword: true, }, { Help: "If you want to list the files in a shared folder that is password protected, add this parameter.", Name: "folder_password", Advanced: true, IsPassword: true, }, { Help: "Set if you wish to use CDN download links.", Name: "cdn", Default: false, Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, // Characters that need escaping // // '\\': '＼', // FULLWIDTH REVERSE SOLIDUS // '<': '＜', // FULLWIDTH LESS-THAN SIGN // '>': '＞', // FULLWIDTH GREATER-THAN SIGN // '"': '＂', // FULLWIDTH QUOTATION MARK - not on the list but seems to be reserved // '\'': '＇', // FULLWIDTH APOSTROPHE // '$': '＄', // FULLWIDTH DOLLAR SIGN // '`': '｀', // FULLWIDTH GRAVE ACCENT // // Leading space and trailing space Default: (encoder.Display | encoder.EncodeBackSlash | encoder.EncodeSingleQuote | encoder.EncodeBackQuote | encoder.EncodeDoubleQuote | encoder.EncodeLtGt | encoder.EncodeDollar | encoder.EncodeLeftSpace | encoder.EncodeRightSpace | encoder.EncodeInvalidUtf8), }}, }) } // Options defines the configuration for this backend type Options struct { APIKey string `config:"api_key"` SharedFolder string `config:"shared_folder"` FilePassword string `config:"file_password"` FolderPassword string `config:"folder_password"` CDN bool `config:"cdn"` Enc encoder.MultiEncoder `config:"encoding"` } // Fs is the interface a cloud storage system must provide type Fs struct { root string name string features *fs.Features opt Options dirCache *dircache.DirCache baseClient *http.Client pacer *fs.Pacer rest *rest.Client } // FindLeaf finds a directory of name leaf in the folder with ID pathID func (f *Fs) FindLeaf(ctx context.Context, pathID, leaf string) (pathIDOut string, found bool, err error) { folderID, err := strconv.Atoi(pathID) if err != nil { return "", false, err } folders, err := f.listFolders(ctx, folderID) if err != nil { return "", false, err } for _, folder := range folders.SubFolders { if folder.Name == leaf { pathIDOut := strconv.Itoa(folder.ID) return pathIDOut, true, nil } } return "", false, nil } // CreateDir makes a directory with pathID as parent and name leaf func (f *Fs) CreateDir(ctx context.Context, pathID, leaf string) (newID string, err error) { folderID, err := strconv.Atoi(pathID) if err != nil { return "", err } resp, err := f.makeFolder(ctx, leaf, folderID) if err != nil { return "", err } return strconv.Itoa(resp.FolderID), err } // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String returns a description of the FS func (f *Fs) String() string { return fmt.Sprintf("1Fichier root '%s'", f.root) } // Precision of the ModTimes in this Fs func (f *Fs) Precision() time.Duration { return fs.ModTimeNotSupported } // Hashes returns the supported hash types of the filesystem func (f *Fs) Hashes() hash.Set { return hash.Set(hash.Whirlpool) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // NewFs makes a new Fs object from the path // // The path is of the form remote:path // // Remotes are looked up in the config file. If the remote isn't // found then NotFoundInConfigFile will be returned. // // On Windows avoid single character remote names as they can be mixed // up with drive letters. func NewFs(ctx context.Context, name string, root string, config configmap.Mapper) (fs.Fs, error) { opt := new(Options) err := configstruct.Set(config, opt) if err != nil { return nil, err } // If using a Shared Folder override root if opt.SharedFolder != "" { root = "" } //workaround for wonky parser root = strings.Trim(root, "/") f := &Fs{ name: name, root: root, opt: *opt, pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant), pacer.AttackConstant(attackConstant))), baseClient: &http.Client{}, } f.features = (&fs.Features{ DuplicateFiles: true, CanHaveEmptyDirectories: true, ReadMimeType: true, }).Fill(ctx, f) client := fshttp.NewClient(ctx) f.rest = rest.NewClient(client).SetRoot(apiBaseURL) f.rest.SetHeader("Authorization", "Bearer "+f.opt.APIKey) f.dirCache = dircache.New(root, rootID, f) // Find the current root err = f.dirCache.FindRoot(ctx, false) if err != nil { // Assume it is a file newRoot, remote := dircache.SplitPath(root) tempF := *f tempF.dirCache = dircache.New(newRoot, rootID, &tempF) tempF.root = newRoot // Make new Fs which is the parent err = tempF.dirCache.FindRoot(ctx, false) if err != nil { // No root so return old f return f, nil } _, err := tempF.NewObject(ctx, remote) if err != nil { if err == fs.ErrorObjectNotFound { // File doesn't exist so return old f return f, nil } return nil, err } f.features.Fill(ctx, &tempF) // XXX: update the old f here instead of returning tempF, since // `features` were already filled with functions having *f as a receiver. // See https://github.com/rclone/rclone/issues/2182 f.dirCache = tempF.dirCache f.root = tempF.root // return an error with an fs which points to the parent return f, fs.ErrorIsFile } return f, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { if f.opt.SharedFolder != "" { return f.listSharedFiles(ctx, f.opt.SharedFolder) } dirContent, err := f.listDir(ctx, dir) if err != nil { return nil, err } return dirContent, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { leaf, directoryID, err := f.dirCache.FindPath(ctx, remote, false) if err != nil { if err == fs.ErrorDirNotFound { return nil, fs.ErrorObjectNotFound } return nil, err } folderID, err := strconv.Atoi(directoryID) if err != nil { return nil, err } files, err := f.listFiles(ctx, folderID) if err != nil { return nil, err } for _, file := range files.Items { if file.Filename == leaf { path, ok := f.dirCache.GetInv(directoryID) if !ok { return nil, errors.New("cannot find dir in dircache") } return f.newObjectFromFile(ctx, path, file), nil } } return nil, fs.ErrorObjectNotFound } // Put in to the remote path with the modTime given of the given size // // When called from outside an Fs by rclone, src.Size() will always be >= 0. // But for unknown-sized objects (indicated by src.Size() == -1), Put should either // return an error or upload it properly (rather than e.g. calling panic). // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { existingObj, err := f.NewObject(ctx, src.Remote()) switch err { case nil: return existingObj, existingObj.Update(ctx, in, src, options...) case fs.ErrorObjectNotFound: // Not found so create it return f.PutUnchecked(ctx, in, src, options...) default: return nil, err } } // putUnchecked uploads the object with the given name and size // // This will create a duplicate if we upload a new file without // checking to see if there is one already - use Put() for that. func (f *Fs) putUnchecked(ctx context.Context, in io.Reader, remote string, size int64, options ...fs.OpenOption) (fs.Object, error) { if size > int64(300e9) { return nil, errors.New("File too big, can't upload") } else if size == 0 { return nil, fs.ErrorCantUploadEmptyFiles } nodeResponse, err := f.getUploadNode(ctx) if err != nil { return nil, err } leaf, directoryID, err := f.dirCache.FindPath(ctx, remote, true) if err != nil { return nil, err } _, err = f.uploadFile(ctx, in, size, leaf, directoryID, nodeResponse.ID, nodeResponse.URL, options...) if err != nil { return nil, err } fileUploadResponse, err := f.endUpload(ctx, nodeResponse.ID, nodeResponse.URL) if err != nil { return nil, err } if len(fileUploadResponse.Links) == 0 { return nil, errors.New("upload response not found") } else if len(fileUploadResponse.Links) > 1 { fs.Debugf(remote, "Multiple upload responses found, using the first") } link := fileUploadResponse.Links[0] fileSize, err := strconv.ParseInt(link.Size, 10, 64) if err != nil { return nil, err } return &Object{ fs: f, remote: remote, file: File{ CDN: 0, Checksum: link.Whirlpool, ContentType: "", Date: time.Now().Format("2006-01-02 15:04:05"), Filename: link.Filename, Pass: 0, Size: fileSize, URL: link.Download, }, }, nil } // PutUnchecked uploads the object // // This will create a duplicate if we upload a new file without // checking to see if there is one already - use Put() for that. func (f *Fs) PutUnchecked(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.putUnchecked(ctx, in, src.Remote(), src.Size(), options...) } // Mkdir makes the directory (container, bucket) // // Shouldn't return an error if it already exists func (f *Fs) Mkdir(ctx context.Context, dir string) error { _, err := f.dirCache.FindDir(ctx, dir, true) return err } // Rmdir removes the directory (container, bucket) if empty // // Return an error if it doesn't exist or isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { directoryID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { return err } folderID, err := strconv.Atoi(directoryID) if err != nil { return err } _, err = f.removeFolder(ctx, dir, folderID) if err != nil { return err } f.dirCache.FlushDir(dir) return nil } // Move src to this remote using server side move operations. 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 } srcFs := srcObj.fs // Find current directory ID srcLeaf, srcDirectoryID, err := srcFs.dirCache.FindPath(ctx, srcObj.remote, false) if err != nil { return nil, err } // Create temporary object dstObj, dstLeaf, dstDirectoryID, err := f.createObject(ctx, remote) if err != nil { return nil, err } // If it is in the correct directory, just rename it var url string if srcDirectoryID == dstDirectoryID { // No rename needed if srcLeaf == dstLeaf { return src, nil } resp, err := f.renameFile(ctx, srcObj.file.URL, dstLeaf) if err != nil { return nil, fmt.Errorf("couldn't rename file: %w", err) } if resp.Status != "OK" { return nil, fmt.Errorf("couldn't rename file: %s", resp.Message) } url = resp.URLs[0].URL } else { dstFolderID, err := strconv.Atoi(dstDirectoryID) if err != nil { return nil, err } rename := dstLeaf // No rename needed if srcLeaf == dstLeaf { rename = "" } resp, err := f.moveFile(ctx, srcObj.file.URL, dstFolderID, rename) if err != nil { return nil, fmt.Errorf("couldn't move file: %w", err) } if resp.Status != "OK" { return nil, fmt.Errorf("couldn't move file: %s", resp.Message) } url = resp.URLs[0] } file, err := f.readFileInfo(ctx, url) if err != nil { return nil, errors.New("couldn't read file data") } dstObj.setMetaData(*file) return dstObj, nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove. // // If destination exists then return fs.ErrorDirExists. // // This is complicated by the fact that we can't use moveDir to move // to a different directory AND rename at the same time as it can // overwrite files in the source directory. func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } srcID, _, _, dstDirectoryID, dstLeaf, err := f.dirCache.DirMove(ctx, srcFs.dirCache, srcFs.root, srcRemote, f.root, dstRemote) if err != nil { return err } srcIDnumeric, err := strconv.Atoi(srcID) if err != nil { return err } dstDirectoryIDnumeric, err := strconv.Atoi(dstDirectoryID) if err != nil { return err } var resp *MoveDirResponse resp, err = f.moveDir(ctx, srcIDnumeric, dstLeaf, dstDirectoryIDnumeric) if err != nil { return fmt.Errorf("couldn't rename leaf: %w", err) } if resp.Status != "OK" { return fmt.Errorf("couldn't rename leaf: %s", resp.Message) } srcFs.dirCache.FlushDir(srcRemote) return nil } // Copy src to this remote using server side move operations. 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 move - not same remote type") return nil, fs.ErrorCantMove } // Create temporary object dstObj, leaf, directoryID, err := f.createObject(ctx, remote) if err != nil { return nil, err } folderID, err := strconv.Atoi(directoryID) if err != nil { return nil, err } resp, err := f.copyFile(ctx, srcObj.file.URL, folderID, leaf) if err != nil { return nil, fmt.Errorf("couldn't move file: %w", err) } if resp.Status != "OK" { return nil, fmt.Errorf("couldn't move file: %s", resp.Message) } file, err := f.readFileInfo(ctx, resp.URLs[0].ToURL) if err != nil { return nil, errors.New("couldn't read file data") } dstObj.setMetaData(*file) return dstObj, nil } // About gets quota information func (f *Fs) About(ctx context.Context) (usage *fs.Usage, err error) { opts := rest.Opts{ Method: "POST", Path: "/user/info.cgi", ContentType: "application/json", } var accountInfo AccountInfo var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.rest.CallJSON(ctx, &opts, nil, &accountInfo) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("failed to read user info: %w", err) } // FIXME max upload size would be useful to use in Update usage = &fs.Usage{ Used: fs.NewUsageValue(accountInfo.ColdStorage), // bytes in use Total: fs.NewUsageValue(accountInfo.AvailableColdStorage), // bytes total Free: fs.NewUsageValue(accountInfo.AvailableColdStorage - accountInfo.ColdStorage), // bytes free } return usage, nil } // PublicLink adds a "readable by anyone with link" permission on the given file or folder. func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (string, error) { o, err := f.NewObject(ctx, remote) if err != nil { return "", err } return o.(*Object).file.URL, nil } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.PublicLinker = (*Fs)(nil) _ fs.PutUncheckeder = (*Fs)(nil) _ dircache.DirCacher = (*Fs)(nil) ) rclone-v1.71.0/backend/fichier/fichier_test.go000066400000000000000000000004361505210326400212500ustar00rootroot00000000000000// Test 1Fichier filesystem interface package fichier import ( "testing" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestFichier:", }) } rclone-v1.71.0/backend/fichier/object.go000066400000000000000000000074131505210326400200500ustar00rootroot00000000000000package fichier import ( "context" "errors" "fmt" "io" "net/http" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/rest" ) // Object is a filesystem like object provided by an Fs type Object struct { fs *Fs remote string file File } // String returns a description of the Object func (o *Object) String() string { return o.file.Filename } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // ModTime returns the modification date of the file // It should return a best guess if one isn't available func (o *Object) ModTime(ctx context.Context) time.Time { modTime, err := time.Parse("2006-01-02 15:04:05", o.file.Date) if err != nil { return time.Now() } return modTime } // Size returns the size of the file func (o *Object) Size() int64 { return o.file.Size } // Fs returns read only access to the Fs that this object is part of func (o *Object) Fs() fs.Info { return o.fs } // Hash returns the selected checksum of the file // If no checksum is available it returns "" func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if t != hash.Whirlpool { return "", hash.ErrUnsupported } return o.file.Checksum, nil } // Storable says whether this object can be stored func (o *Object) Storable() bool { return true } // SetModTime sets the metadata on the object to set the modification date func (o *Object) SetModTime(context.Context, time.Time) error { return fs.ErrorCantSetModTime //return errors.New("setting modtime is not supported for 1fichier remotes") } func (o *Object) setMetaData(file File) { o.file = file } // Open opens the file for read. Call Close() on the returned io.ReadCloser func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { fs.FixRangeOption(options, o.file.Size) downloadToken, err := o.fs.getDownloadToken(ctx, o.file.URL) if err != nil { return nil, err } var resp *http.Response opts := rest.Opts{ Method: "GET", RootURL: downloadToken.URL, Options: options, } err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.rest.Call(ctx, &opts) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } return resp.Body, err } // Update in to the object with the modTime given of the given size // // When called from outside an Fs by rclone, src.Size() will always be >= 0. // But for unknown-sized objects (indicated by src.Size() == -1), Upload should either // return an error or update the object properly (rather than e.g. calling panic). func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { if src.Size() < 0 { return errors.New("refusing to update with unknown size") } // upload with new size but old name info, err := o.fs.putUnchecked(ctx, in, o.Remote(), src.Size(), options...) if err != nil { return err } // Delete duplicate after successful upload err = o.Remove(ctx) if err != nil { return fmt.Errorf("failed to remove old version: %w", err) } // Replace guts of old object with new one *o = *info.(*Object) return nil } // Remove removes this object func (o *Object) Remove(ctx context.Context) error { // fs.Debugf(f, "Removing file `%s` with url `%s`", o.file.Filename, o.file.URL) _, err := o.fs.deleteFile(ctx, o.file.URL) if err != nil { return err } return nil } // MimeType of an Object if known, "" otherwise func (o *Object) MimeType(ctx context.Context) string { return o.file.ContentType } // ID returns the ID of the Object if known, or "" if not func (o *Object) ID() string { return o.file.URL } // Check the interfaces are satisfied var ( _ fs.Object = (*Object)(nil) _ fs.MimeTyper = (*Object)(nil) _ fs.IDer = (*Object)(nil) ) rclone-v1.71.0/backend/fichier/structs.go000066400000000000000000000165361505210326400203170ustar00rootroot00000000000000package fichier // FileInfoRequest is the request structure of the corresponding request type FileInfoRequest struct { URL string `json:"url"` } // ListFolderRequest is the request structure of the corresponding request type ListFolderRequest struct { FolderID int `json:"folder_id"` } // ListFilesRequest is the request structure of the corresponding request type ListFilesRequest struct { FolderID int `json:"folder_id"` } // DownloadRequest is the request structure of the corresponding request type DownloadRequest struct { URL string `json:"url"` Single int `json:"single"` Pass string `json:"pass,omitempty"` CDN int `json:"cdn,omitempty"` } // RemoveFolderRequest is the request structure of the corresponding request type RemoveFolderRequest struct { FolderID int `json:"folder_id"` } // RemoveFileRequest is the request structure of the corresponding request type RemoveFileRequest struct { Files []RmFile `json:"files"` } // RmFile is the request structure of the corresponding request type RmFile struct { URL string `json:"url"` } // GenericOKResponse is the response structure of the corresponding request type GenericOKResponse struct { Status string `json:"status"` Message string `json:"message"` } // MakeFolderRequest is the request structure of the corresponding request type MakeFolderRequest struct { Name string `json:"name"` FolderID int `json:"folder_id"` } // MakeFolderResponse is the response structure of the corresponding request type MakeFolderResponse struct { Name string `json:"name"` FolderID int `json:"folder_id"` } // MoveFileRequest is the request structure of the corresponding request type MoveFileRequest struct { URLs []string `json:"urls"` FolderID int `json:"destination_folder_id"` Rename string `json:"rename,omitempty"` } // MoveFileResponse is the response structure of the corresponding request type MoveFileResponse struct { Status string `json:"status"` Message string `json:"message"` URLs []string `json:"urls"` } // MoveDirRequest is the request structure of the corresponding request type MoveDirRequest struct { FolderID int `json:"folder_id"` DestinationFolderID int `json:"destination_folder_id,omitempty"` DestinationUser string `json:"destination_user"` Rename string `json:"rename,omitempty"` } // MoveDirResponse is the response structure of the corresponding request type MoveDirResponse struct { Status string `json:"status"` Message string `json:"message"` OldName string `json:"old_name"` NewName string `json:"new_name"` } // CopyFileRequest is the request structure of the corresponding request type CopyFileRequest struct { URLs []string `json:"urls"` FolderID int `json:"folder_id"` Rename string `json:"rename,omitempty"` } // CopyFileResponse is the response structure of the corresponding request type CopyFileResponse struct { Status string `json:"status"` Message string `json:"message"` Copied int `json:"copied"` URLs []FileCopy `json:"urls"` } // FileCopy is used in the CopyFileResponse type FileCopy struct { FromURL string `json:"from_url"` ToURL string `json:"to_url"` } // RenameFileURL is the data structure to rename a single file type RenameFileURL struct { URL string `json:"url"` Filename string `json:"filename"` } // RenameFileRequest is the request structure of the corresponding request type RenameFileRequest struct { URLs []RenameFileURL `json:"urls"` Pretty int `json:"pretty"` } // RenameFileResponse is the response structure of the corresponding request type RenameFileResponse struct { Status string `json:"status"` Message string `json:"message"` Renamed int `json:"renamed"` URLs []struct { URL string `json:"url"` OldFilename string `json:"old_filename"` NewFilename string `json:"new_filename"` } `json:"urls"` } // GetUploadNodeResponse is the response structure of the corresponding request type GetUploadNodeResponse struct { ID string `json:"id"` URL string `json:"url"` } // GetTokenResponse is the response structure of the corresponding request type GetTokenResponse struct { URL string `json:"url"` Status string `json:"Status"` Message string `json:"Message"` } // SharedFolderResponse is the response structure of the corresponding request type SharedFolderResponse []SharedFile // SharedFile is the structure how 1Fichier returns a shared File type SharedFile struct { Filename string `json:"filename"` Link string `json:"link"` Size int64 `json:"size"` } // EndFileUploadResponse is the response structure of the corresponding request type EndFileUploadResponse struct { Incoming int `json:"incoming"` Links []struct { Download string `json:"download"` Filename string `json:"filename"` Remove string `json:"remove"` Size string `json:"size"` Whirlpool string `json:"whirlpool"` } `json:"links"` } // File is the structure how 1Fichier returns a File type File struct { CDN int `json:"cdn"` Checksum string `json:"checksum"` ContentType string `json:"content-type"` Date string `json:"date"` Filename string `json:"filename"` Pass int `json:"pass"` Size int64 `json:"size"` URL string `json:"url"` } // FilesList is the structure how 1Fichier returns a list of files type FilesList struct { Items []File `json:"items"` Status string `json:"Status"` } // Folder is the structure how 1Fichier returns a Folder type Folder struct { CreateDate string `json:"create_date"` ID int `json:"id"` Name string `json:"name"` Pass int `json:"pass"` } // FoldersList is the structure how 1Fichier returns a list of Folders type FoldersList struct { FolderID int `json:"folder_id"` Name string `json:"name"` Status string `json:"Status"` SubFolders []Folder `json:"sub_folders"` } // AccountInfo is the structure how 1Fichier returns user info type AccountInfo struct { StatsDate string `json:"stats_date"` MailRM string `json:"mail_rm"` DefaultQuota int64 `json:"default_quota"` UploadForbidden string `json:"upload_forbidden"` PageLimit int `json:"page_limit"` ColdStorage int64 `json:"cold_storage"` Status string `json:"status"` UseCDN string `json:"use_cdn"` AvailableColdStorage int64 `json:"available_cold_storage"` DefaultPort string `json:"default_port"` DefaultDomain int `json:"default_domain"` Email string `json:"email"` DownloadMenu string `json:"download_menu"` FTPDID int `json:"ftp_did"` DefaultPortFiles string `json:"default_port_files"` FTPReport string `json:"ftp_report"` OverQuota int64 `json:"overquota"` AvailableStorage int64 `json:"available_storage"` CDN string `json:"cdn"` Offer string `json:"offer"` SubscriptionEnd string `json:"subscription_end"` TFA string `json:"2fa"` AllowedColdStorage int64 `json:"allowed_cold_storage"` HotStorage int64 `json:"hot_storage"` DefaultColdStorageQuota int64 `json:"default_cold_storage_quota"` FTPMode string `json:"ftp_mode"` RUReport string `json:"ru_report"` } rclone-v1.71.0/backend/filefabric/000077500000000000000000000000001505210326400167235ustar00rootroot00000000000000rclone-v1.71.0/backend/filefabric/api/000077500000000000000000000000001505210326400174745ustar00rootroot00000000000000rclone-v1.71.0/backend/filefabric/api/types.go000066400000000000000000000317151505210326400211760ustar00rootroot00000000000000// Package api has type definitions for filefabric // // Converted from the API responses with help from https://mholt.github.io/json-to-go/ package api import ( "bytes" "encoding/json" "fmt" "reflect" "strings" "time" ) const ( // TimeFormat for parameters (UTC) timeFormatParameters = `2006-01-02 15:04:05` // "2020-08-11 10:10:04" for JSON parsing timeFormatJSON = `"` + timeFormatParameters + `"` ) // Time represents date and time information for the // filefabric API type Time time.Time // MarshalJSON turns a Time into JSON (in UTC) func (t *Time) MarshalJSON() (out []byte, err error) { timeString := (*time.Time)(t).UTC().Format(timeFormatJSON) return []byte(timeString), nil } var zeroTime = []byte(`"0000-00-00 00:00:00"`) // UnmarshalJSON turns JSON into a Time (in UTC) func (t *Time) UnmarshalJSON(data []byte) error { // Set a Zero time.Time if we receive a zero time input if bytes.Equal(data, zeroTime) { *t = Time(time.Time{}) return nil } newT, err := time.Parse(timeFormatJSON, string(data)) if err != nil { return err } *t = Time(newT) return nil } // String turns a Time into a string in UTC suitable for the API // parameters func (t Time) String() string { return time.Time(t).UTC().Format(timeFormatParameters) } // Int represents an integer which can be represented in JSON as a // quoted integer or an integer. type Int int // MarshalJSON turns a Int into JSON func (i *Int) MarshalJSON() (out []byte, err error) { return json.Marshal((*int)(i)) } // UnmarshalJSON turns JSON into a Int func (i *Int) UnmarshalJSON(data []byte) error { if len(data) >= 2 && data[0] == '"' && data[len(data)-1] == '"' { data = data[1 : len(data)-1] } return json.Unmarshal(data, (*int)(i)) } // String represents an string which can be represented in JSON as a // quoted string or an integer. type String string // MarshalJSON turns a String into JSON func (s *String) MarshalJSON() (out []byte, err error) { return json.Marshal((*string)(s)) } // UnmarshalJSON turns JSON into a String func (s *String) UnmarshalJSON(data []byte) error { err := json.Unmarshal(data, (*string)(s)) if err != nil { *s = String(data) } return nil } // Status return returned in all status responses type Status struct { Code string `json:"status"` Message string `json:"statusmessage"` TaskID String `json:"taskid"` // Warning string `json:"warning"` // obsolete } // Status satisfies the error interface func (e *Status) Error() string { return fmt.Sprintf("%s (%s)", e.Message, e.Code) } // OK returns true if the status is all good func (e *Status) OK() bool { return e.Code == "ok" } // GetCode returns the status code if any func (e *Status) GetCode() string { return e.Code } // OKError defines an interface for items which can be OK or be an error type OKError interface { error OK() bool GetCode() string } // Check Status satisfies the OKError interface var _ OKError = (*Status)(nil) // EmptyResponse is response which just returns the error condition type EmptyResponse struct { Status } // GetTokenByAuthTokenResponse is the response to getTokenByAuthToken type GetTokenByAuthTokenResponse struct { Status Token string `json:"token"` UserID string `json:"userid"` AllowLoginRemember string `json:"allowloginremember"` LastLogin Time `json:"lastlogin"` AutoLoginCode string `json:"autologincode"` } // ApplianceInfo is the response to getApplianceInfo type ApplianceInfo struct { Status Sitetitle string `json:"sitetitle"` OauthLoginSupport string `json:"oauthloginsupport"` IsAppliance string `json:"isappliance"` SoftwareVersion string `json:"softwareversion"` SoftwareVersionLabel string `json:"softwareversionlabel"` } // GetFolderContentsResponse is returned from getFolderContents type GetFolderContentsResponse struct { Status Total int `json:"total,string"` Items []Item `json:"filelist"` Folder Item `json:"folder"` From Int `json:"from"` //Count int `json:"count"` Pid string `json:"pid"` RefreshResult Status `json:"refreshresult"` // Curfolder Item `json:"curfolder"` - sometimes returned as "ROOT"? Parents []Item `json:"parents"` CustomPermissions CustomPermissions `json:"custompermissions"` } // ItemType determine whether it is a file or a folder type ItemType uint8 // Types of things in Item const ( ItemTypeFile ItemType = 0 ItemTypeFolder ItemType = 1 ) // Item ia a File or a Folder type Item struct { ID string `json:"fi_id"` PID string `json:"fi_pid"` // UID string `json:"fi_uid"` Name string `json:"fi_name"` // S3Name string `json:"fi_s3name"` // Extension string `json:"fi_extension"` // Description string `json:"fi_description"` Type ItemType `json:"fi_type,string"` // Created Time `json:"fi_created"` Size int64 `json:"fi_size,string"` ContentType string `json:"fi_contenttype"` // Tags string `json:"fi_tags"` // MainCode string `json:"fi_maincode"` // Public int `json:"fi_public,string"` // Provider string `json:"fi_provider"` // ProviderFolder string `json:"fi_providerfolder"` // folder // Encrypted int `json:"fi_encrypted,string"` // StructType string `json:"fi_structtype"` // Bname string `json:"fi_bname"` // folder // OrgID string `json:"fi_orgid"` // Favorite int `json:"fi_favorite,string"` // IspartOf string `json:"fi_ispartof"` // folder Modified Time `json:"fi_modified"` // LastAccessed Time `json:"fi_lastaccessed"` // Hits int64 `json:"fi_hits,string"` // IP string `json:"fi_ip"` // folder // BigDescription string `json:"fi_bigdescription"` LocalTime Time `json:"fi_localtime"` // OrgfolderID string `json:"fi_orgfolderid"` // StorageIP string `json:"fi_storageip"` // folder // RemoteTime Time `json:"fi_remotetime"` // ProviderOptions string `json:"fi_provideroptions"` // Access string `json:"fi_access"` // Hidden string `json:"fi_hidden"` // folder // VersionOf string `json:"fi_versionof"` Trash bool `json:"trash"` // Isbucket string `json:"isbucket"` // filelist SubFolders int64 `json:"subfolders"` // folder } // ItemFields is a | separated list of fields in Item var ItemFields = mustFields(Item{}) // fields returns the JSON fields in use by opt as a | separated // string. func fields(opt any) (pipeTags string, err error) { var tags []string def := reflect.ValueOf(opt) defType := def.Type() for i := range def.NumField() { field := defType.Field(i) tag, ok := field.Tag.Lookup("json") if !ok { continue } if comma := strings.IndexRune(tag, ','); comma >= 0 { tag = tag[:comma] } if tag == "" { continue } tags = append(tags, tag) } return strings.Join(tags, "|"), nil } // mustFields returns the JSON fields in use by opt as a | separated // string. It panics on failure. func mustFields(opt any) string { tags, err := fields(opt) if err != nil { panic(err) } return tags } // CustomPermissions is returned as part of GetFolderContentsResponse type CustomPermissions struct { Upload string `json:"upload"` CreateSubFolder string `json:"createsubfolder"` Rename string `json:"rename"` Delete string `json:"delete"` Move string `json:"move"` ManagePermissions string `json:"managepermissions"` ListOnly string `json:"listonly"` VisibleInTrash string `json:"visibleintrash"` } // DoCreateNewFolderResponse is response from foCreateNewFolder type DoCreateNewFolderResponse struct { Status Item Item `json:"file"` } // DoInitUploadResponse is response from doInitUpload type DoInitUploadResponse struct { Status ProviderID string `json:"providerid"` UploadCode string `json:"uploadcode"` FileType string `json:"filetype"` DirectUploadSupport string `json:"directuploadsupport"` ResumeAllowed string `json:"resumeallowed"` } // UploaderResponse is returned from /cgi-bin/uploader/uploader1.cgi // // Sometimes the response is returned as XML and sometimes as JSON type UploaderResponse struct { FileSize int64 `xml:"filesize" json:"filesize,string"` MD5 string `xml:"md5" json:"md5"` Success string `xml:"success" json:"success"` } // UploadStatus is returned from getUploadStatus type UploadStatus struct { Status UploadCode string `json:"uploadcode"` Metafile string `json:"metafile"` Percent int `json:"percent,string"` Uploaded int64 `json:"uploaded,string"` Size int64 `json:"size,string"` Filename string `json:"filename"` Nofile string `json:"nofile"` Completed string `json:"completed"` Completsuccess string `json:"completsuccess"` Completerror string `json:"completerror"` } // DoCompleteUploadResponse is the response to doCompleteUpload type DoCompleteUploadResponse struct { Status UploadedSize int64 `json:"uploadedsize,string"` StorageIP string `json:"storageip"` UploadedName string `json:"uploadedname"` // Versioned []interface{} `json:"versioned"` // VersionedID int `json:"versionedid"` // Comment interface{} `json:"comment"` File Item `json:"file"` // UsSize string `json:"us_size"` // PaSize string `json:"pa_size"` // SpaceInfo SpaceInfo `json:"spaceinfo"` } // Providers is returned as part of UploadResponse type Providers struct { Max string `json:"max"` Used string `json:"used"` ID string `json:"id"` Private string `json:"private"` Limit string `json:"limit"` Percent int `json:"percent"` } // Total is returned as part of UploadResponse type Total struct { Max string `json:"max"` Used string `json:"used"` ID string `json:"id"` Priused string `json:"priused"` Primax string `json:"primax"` Limit string `json:"limit"` Percent int `json:"percent"` Pripercent int `json:"pripercent"` } // UploadResponse is returned as part of SpaceInfo type UploadResponse struct { Providers []Providers `json:"providers"` Total Total `json:"total"` } // SpaceInfo is returned as part of DoCompleteUploadResponse type SpaceInfo struct { Response UploadResponse `json:"response"` Status string `json:"status"` } // DeleteResponse is returned from doDeleteFile type DeleteResponse struct { Status Deleted []string `json:"deleted"` Errors []any `json:"errors"` ID string `json:"fi_id"` BackgroundTask int `json:"backgroundtask"` UsSize string `json:"us_size"` PaSize string `json:"pa_size"` //SpaceInfo SpaceInfo `json:"spaceinfo"` } // FileResponse is returned from doRenameFile type FileResponse struct { Status Item Item `json:"file"` Exists string `json:"exists"` } // MoveFilesResponse is returned from doMoveFiles type MoveFilesResponse struct { Status Filesleft string `json:"filesleft"` Addedtobackground string `json:"addedtobackground"` Moved string `json:"moved"` Item Item `json:"file"` IDs []string `json:"fi_ids"` Length int `json:"length"` DirID string `json:"dir_id"` MovedObjects []Item `json:"movedobjects"` // FolderTasks []interface{} `json:"foldertasks"` } // TasksResponse is the response to getUserBackgroundTasks type TasksResponse struct { Status Tasks []Task `json:"tasks"` Total string `json:"total"` } // BtData is part of TasksResponse type BtData struct { Callback string `json:"callback"` } // Task describes a task returned in TasksResponse type Task struct { BtID string `json:"bt_id"` UsID string `json:"us_id"` BtType string `json:"bt_type"` BtData BtData `json:"bt_data"` BtStatustext string `json:"bt_statustext"` BtStatusdata string `json:"bt_statusdata"` BtMessage string `json:"bt_message"` BtProcent string `json:"bt_procent"` BtAdded string `json:"bt_added"` BtStatus string `json:"bt_status"` BtCompleted string `json:"bt_completed"` BtTitle string `json:"bt_title"` BtCredentials string `json:"bt_credentials"` BtHidden string `json:"bt_hidden"` BtAutoremove string `json:"bt_autoremove"` BtDevsite string `json:"bt_devsite"` BtPriority string `json:"bt_priority"` BtReport string `json:"bt_report"` BtSitemarker string `json:"bt_sitemarker"` BtExecuteafter string `json:"bt_executeafter"` BtCompletestatus string `json:"bt_completestatus"` BtSubtype string `json:"bt_subtype"` BtCanceled string `json:"bt_canceled"` Callback string `json:"callback"` CanBeCanceled bool `json:"canbecanceled"` CanBeRestarted bool `json:"canberestarted"` Type string `json:"type"` Status string `json:"status"` Settings string `json:"settings"` } rclone-v1.71.0/backend/filefabric/filefabric.go000066400000000000000000001101351505210326400213410ustar00rootroot00000000000000// Package filefabric provides an interface to Storage Made Easy's // Enterprise File Fabric storage system. package filefabric /* Docs: https://product-demo.smestorage.com/?p=apidoc Missing features: - M-Stream support - Oauth-like flow (soon being changed to oauth) // TestFileFabric maxFileLength = 14094 */ import ( "bytes" "context" "encoding/base64" "errors" "fmt" "io" "net/http" "net/url" "path" "strings" "sync" "sync/atomic" "time" "github.com/rclone/rclone/lib/atexit" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/random" "github.com/rclone/rclone/backend/filefabric/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/log" "github.com/rclone/rclone/lib/dircache" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/rest" ) const ( minSleep = 20 * time.Millisecond maxSleep = 10 * time.Second decayConstant = 2 // bigger for slower decay, exponential listChunks = 1000 // chunk size to read directory listings tokenLifeTime = 55 * time.Minute // 1 hour minus a bit of leeway defaultRootID = "" // default root ID emptyMimeType = "application/vnd.rclone.empty.file" ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "filefabric", Description: "Enterprise File Fabric", NewFs: NewFs, Options: []fs.Option{{ Name: "url", Help: "URL of the Enterprise File Fabric to connect to.", Required: true, Examples: []fs.OptionExample{{ Value: "https://storagemadeeasy.com", Help: "Storage Made Easy US", }, { Value: "https://eu.storagemadeeasy.com", Help: "Storage Made Easy EU", }, { Value: "https://yourfabric.smestorage.com", Help: "Connect to your Enterprise File Fabric", }}, }, { Name: "root_folder_id", Help: `ID of the root folder. Leave blank normally. Fill in to make rclone start with directory of a given ID. `, Sensitive: true, }, { Name: "permanent_token", Help: `Permanent Authentication Token. A Permanent Authentication Token can be created in the Enterprise File Fabric, on the users Dashboard under Security, there is an entry you'll see called "My Authentication Tokens". Click the Manage button to create one. These tokens are normally valid for several years. For more info see: https://docs.storagemadeeasy.com/organisationcloud/api-tokens `, Sensitive: true, }, { Name: "token", Help: `Session Token. This is a session token which rclone caches in the config file. It is usually valid for 1 hour. Don't set this value - rclone will set it automatically. `, Advanced: true, Sensitive: true, }, { Name: "token_expiry", Help: `Token expiry time. Don't set this value - rclone will set it automatically. `, Advanced: true, }, { Name: "version", Help: `Version read from the file fabric. Don't set this value - rclone will set it automatically. `, Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: (encoder.Display | encoder.EncodeInvalidUtf8), }}, }) } // Options defines the configuration for this backend type Options struct { URL string `config:"url"` RootFolderID string `config:"root_folder_id"` PermanentToken string `config:"permanent_token"` Token string `config:"token"` TokenExpiry string `config:"token_expiry"` Version string `config:"version"` Enc encoder.MultiEncoder `config:"encoding"` } // Fs represents a remote filefabric type Fs struct { name string // name of this remote root string // the path we are working on opt Options // parsed options features *fs.Features // optional features m configmap.Mapper // to save config srv *rest.Client // the connection to the server dirCache *dircache.DirCache // Map of directory path to directory id pacer *fs.Pacer // pacer for API calls tokenMu sync.Mutex // hold when reading the token token string // current access token tokenExpiry time.Time // time the current token expires tokenExpired atomic.Int32 canCopyWithName bool // set if detected that can use fi_name in copy precision time.Duration // precision reported } // Object describes a filefabric object // // Will definitely have info but maybe not meta type Object struct { fs *Fs // what this object is part of remote string // The remote path hasMetaData bool // whether info below has been set size int64 // size of the object modTime time.Time // modification time of the object id string // ID of the object contentType string // ContentType of object } // ------------------------------------------------------------ // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("filefabric root '%s'", f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // parsePath parses a filefabric 'url' func parsePath(path string) (root string) { root = strings.Trim(path, "/") return } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 429, // Too Many Requests. 500, // Internal Server Error 502, // Bad Gateway 503, // Service Unavailable 504, // Gateway Timeout 509, // Bandwidth Limit Exceeded } // Retry any of these var retryStatusCodes = []struct { code string sleep time.Duration }{ { // Can not create folder now. We are not able to complete the // requested operation with such name. We are processing // delete in that folder. Please try again later or use // another name. (error_background) code: "error_background", sleep: 1 * time.Second, }, } // shouldRetry returns a boolean as to whether this resp and err // deserve to be retried. It returns the err as a convenience // try should be the number of the tries so far, counting up from 1 func (f *Fs) shouldRetry(ctx context.Context, resp *http.Response, err error, status api.OKError, try int) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } if err != nil { return fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(resp, retryErrorCodes), err } if status != nil && !status.OK() { err = status // return the error from the RPC code := status.GetCode() if code == "login_token_expired" { f.tokenExpired.Add(1) } else { for _, retryCode := range retryStatusCodes { if code == retryCode.code { if retryCode.sleep > 0 { // make this thread only sleep exponentially increasing extra time sleepTime := retryCode.sleep << (try - 1) fs.Debugf(f, "Sleeping for %v to wait for %q error to clear", sleepTime, retryCode.code) time.Sleep(sleepTime) } return true, err } } } } return false, err } // readMetaDataForPath reads the metadata from the path func (f *Fs) readMetaDataForPath(ctx context.Context, rootID string, path string) (info *api.Item, err error) { var resp api.FileResponse _, err = f.rpc(ctx, "checkPathExists", params{ "path": f.opt.Enc.FromStandardPath(path), "pid": rootID, }, &resp, nil) if err != nil { return nil, fmt.Errorf("failed to check path exists: %w", err) } if resp.Exists != "y" { return nil, fs.ErrorObjectNotFound } return &resp.Item, nil /* // defer fs.Trace(f, "path=%q", path)("info=%+v, err=%v", &info, &err) leaf, directoryID, err := f.dirCache.FindPath(ctx, path, false) if err != nil { if err == fs.ErrorDirNotFound { return nil, fs.ErrorObjectNotFound } return nil, err } found, err := f.listAll(ctx, directoryID, false, true, func(item *api.Item) bool { if item.Name == leaf { info = item return true } return false }) if err != nil { return nil, err } if !found { return nil, fs.ErrorObjectNotFound } return info, nil */ } // Get the appliance info so we can set Version func (f *Fs) getApplianceInfo(ctx context.Context) error { var applianceInfo api.ApplianceInfo _, err := f.rpc(ctx, "getApplianceInfo", params{ "token": "*", }, &applianceInfo, nil) if err != nil { return fmt.Errorf("failed to read appliance version: %w", err) } f.opt.Version = applianceInfo.SoftwareVersionLabel f.m.Set("version", f.opt.Version) return nil } // Gets the token or gets a new one if necessary func (f *Fs) getToken(ctx context.Context) (token string, err error) { f.tokenMu.Lock() var refreshed = false defer func() { if refreshed { f.tokenExpired.Store(0) } f.tokenMu.Unlock() }() expired := f.tokenExpired.Load() != 0 if expired { fs.Debugf(f, "Token invalid - refreshing") } if f.token == "" { fs.Debugf(f, "Empty token - refreshing") expired = true } now := time.Now() if f.tokenExpiry.IsZero() || now.After(f.tokenExpiry) { fs.Debugf(f, "Token expired - refreshing") expired = true } if !expired { return f.token, nil } var info api.GetTokenByAuthTokenResponse _, err = f.rpc(ctx, "getTokenByAuthToken", params{ "token": "*", "authtoken": f.opt.PermanentToken, }, &info, nil) if err != nil { return "", fmt.Errorf("failed to get session token: %w", err) } refreshed = true now = now.Add(tokenLifeTime) f.token = info.Token f.tokenExpiry = now f.m.Set("token", f.token) f.m.Set("token_expiry", now.Format(time.RFC3339)) // Read appliance info when we update the token err = f.getApplianceInfo(ctx) if err != nil { return "", err } f.setCapabilities() return f.token, nil } // params for rpc type params map[string]any // rpc calls the rpc.php method of the SME file fabric // // This is an entry point to all the method calls. // // If result is nil then resp.Body will need closing func (f *Fs) rpc(ctx context.Context, function string, p params, result api.OKError, options []fs.OpenOption) (resp *http.Response, err error) { defer log.Trace(f, "%s(%+v) options=%+v", function, p, options)("result=%+v, err=%v", &result, &err) // Get the token from params if present otherwise call getToken var token string if tokenI, ok := p["token"]; !ok { token, err = f.getToken(ctx) if err != nil { return resp, err } } else { token = tokenI.(string) } var data = url.Values{ "function": {function}, "token": {token}, "apiformat": {"json"}, } for k, v := range p { data.Set(k, fmt.Sprint(v)) } opts := rest.Opts{ Method: "POST", Path: "/api/rpc.php", ContentType: "application/x-www-form-urlencoded", Options: options, } try := 0 err = f.pacer.Call(func() (bool, error) { try++ // Refresh the body each retry opts.Body = strings.NewReader(data.Encode()) resp, err = f.srv.CallJSON(ctx, &opts, nil, result) return f.shouldRetry(ctx, resp, err, result, try) }) if err != nil { return resp, err } return resp, nil } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } opt.URL = strings.TrimSuffix(opt.URL, "/") if opt.URL == "" { return nil, errors.New("url must be set") } root = parsePath(root) client := fshttp.NewClient(ctx) f := &Fs{ name: name, root: root, opt: *opt, m: m, srv: rest.NewClient(client).SetRoot(opt.URL), pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), token: opt.Token, } f.features = (&fs.Features{ CaseInsensitive: true, CanHaveEmptyDirectories: true, ReadMimeType: true, WriteMimeType: true, }).Fill(ctx, f) if f.opt.Version == "" { err = f.getApplianceInfo(ctx) if err != nil { return nil, err } } f.setCapabilities() if opt.TokenExpiry != "" { tokenExpiry, err := time.Parse(time.RFC3339, opt.TokenExpiry) if err != nil { fs.Errorf(nil, "Failed to parse token_expiry option: %v", err) } else { f.tokenExpiry = tokenExpiry } } if opt.RootFolderID == "" { opt.RootFolderID = defaultRootID } f.dirCache = dircache.New(f.root, opt.RootFolderID, f) // Find out whether the root is a file or a directory or doesn't exist var errReturn error if f.root != "" { info, err := f.readMetaDataForPath(ctx, f.opt.RootFolderID, f.root) if err == nil && info != nil { if info.Type == api.ItemTypeFile { // Root is a file // Point the root to the parent directory f.root, _ = dircache.SplitPath(root) f.dirCache = dircache.New(f.root, opt.RootFolderID, f) errReturn = fs.ErrorIsFile // Cache the ID of the parent of the file as the root ID f.dirCache.Put(f.root, info.PID) } else if info.Type == api.ItemTypeFolder { // Root is a dir - cache its ID f.dirCache.Put(f.root, info.ID) } //} else { // Root is not found so a directory } } return f, errReturn } // set the capabilities of this version of software func (f *Fs) setCapabilities() { version := f.opt.Version if version == "" { version = "0000.00" } if version >= "2006.02" { f.precision = time.Second f.canCopyWithName = true } else { // times can be altered this much on renames f.precision = 1 * time.Hour f.canCopyWithName = false } } // Return an Object from a path // // If it can't be found it returns the error fs.ErrorObjectNotFound. func (f *Fs) newObjectWithInfo(ctx context.Context, remote string, info *api.Item) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } var err error if info != nil { // Set info err = o.setMetaData(info) } else { err = o.readMetaData(ctx) // reads info and meta, returning an error } if err != nil { return nil, err } return o, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return f.newObjectWithInfo(ctx, remote, nil) } // FindLeaf finds a directory of name leaf in the folder with ID pathID func (f *Fs) FindLeaf(ctx context.Context, pathID, leaf string) (pathIDOut string, found bool, err error) { // Find the leaf in pathID found, err = f.listAll(ctx, pathID, true, false, func(item *api.Item) bool { if strings.EqualFold(item.Name, leaf) { pathIDOut = item.ID return true } return false }) return pathIDOut, found, err } // CreateDir makes a directory with pathID as parent and name leaf func (f *Fs) CreateDir(ctx context.Context, pathID, leaf string) (newID string, err error) { //fs.Debugf(f, "CreateDir(%q, %q)\n", pathID, leaf) var info api.DoCreateNewFolderResponse _, err = f.rpc(ctx, "doCreateNewFolder", params{ "fi_pid": pathID, "fi_name": f.opt.Enc.FromStandardName(leaf), }, &info, nil) if err != nil { return "", fmt.Errorf("failed to create directory: %w", err) } // fmt.Printf("...Id %q\n", *info.Id) return info.Item.ID, nil } // list the objects into the function supplied // // If directories is set it only sends directories // User function to process a File item from listAll // // Should return true to finish processing type listAllFn func(*api.Item) bool // Lists the directory required calling the user function on each item found // // If the user fn ever returns true then it early exits with found = true func (f *Fs) listAll(ctx context.Context, dirID string, directoriesOnly bool, filesOnly bool, fn listAllFn) (found bool, err error) { var ( p = params{ "fi_pid": dirID, "count": listChunks, "subfolders": "y", // Cut down the things that are returned "options": "filelist|" + api.ItemFields, } n = 0 ) OUTER: for { var info api.GetFolderContentsResponse _, err = f.rpc(ctx, "getFolderContents", p, &info, nil) if err != nil { return false, fmt.Errorf("failed to list directory: %w", err) } for i := range info.Items { item := &info.Items[i] if item.Type == api.ItemTypeFolder { if filesOnly { continue } } else if item.Type == api.ItemTypeFile { if directoriesOnly { continue } } else { fs.Debugf(f, "Ignoring %q - unknown type %q", item.Name, item.Type) continue } if item.Trash { continue } item.Name = f.opt.Enc.ToStandardName(item.Name) if fn(item) { found = true break OUTER } } // if didn't get any items then exit if len(info.Items) == 0 { break } n += len(info.Items) if n >= info.Total { break } p["from"] = n } return found, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { directoryID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { return nil, err } var iErr error _, err = f.listAll(ctx, directoryID, false, false, func(info *api.Item) bool { remote := path.Join(dir, info.Name) if info.Type == api.ItemTypeFolder { // cache the directory ID for later lookups f.dirCache.Put(remote, info.ID) d := fs.NewDir(remote, time.Time(info.Modified)).SetID(info.ID).SetItems(info.SubFolders) entries = append(entries, d) } else if info.Type == api.ItemTypeFile { o, err := f.newObjectWithInfo(ctx, remote, info) if err != nil { iErr = err return true } entries = append(entries, o) } return false }) if err != nil { return nil, err } if iErr != nil { return nil, iErr } return entries, nil } // Creates from the parameters passed in a half finished Object which // must have setMetaData called on it // // Returns the object, leaf, directoryID and error. // // Used to create new objects func (f *Fs) createObject(ctx context.Context, remote string, modTime time.Time, size int64) (o *Object, leaf string, directoryID string, err error) { // Create the directory for the object if it doesn't exist leaf, directoryID, err = f.dirCache.FindPath(ctx, remote, true) if err != nil { return } // Temporary Object under construction o = &Object{ fs: f, remote: remote, } return o, leaf, directoryID, nil } // Put the object // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { remote := src.Remote() size := src.Size() modTime := src.ModTime(ctx) o, _, _, err := f.createObject(ctx, remote, modTime, size) if err != nil { return nil, err } return o, o.Update(ctx, in, src, options...) } // Mkdir creates the container if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) error { _, err := f.dirCache.FindDir(ctx, dir, true) return err } // deleteObject removes an object by ID func (f *Fs) deleteObject(ctx context.Context, id string) (err error) { var info api.DeleteResponse _, err = f.rpc(ctx, "doDeleteFile", params{ "fi_id": id, "completedeletion": "n", }, &info, nil) if err != nil { return fmt.Errorf("failed to delete file: %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 { root := path.Join(f.root, dir) if root == "" { return errors.New("can't purge root directory") } dc := f.dirCache rootID, err := dc.FindDir(ctx, dir, false) if err != nil { return err } if check { found, err := f.listAll(ctx, rootID, false, false, func(item *api.Item) bool { fs.Debugf(dir, "Rmdir: contains file: %q", item.Name) return true }) if err != nil { return err } if found { return fs.ErrorDirectoryNotEmpty } } var info api.EmptyResponse _, err = f.rpc(ctx, "doDeleteFolder", params{ "fi_id": rootID, }, &info, nil) f.dirCache.FlushDir(dir) if err != nil { return fmt.Errorf("failed to remove directory: %w", err) } return nil } // Rmdir deletes the root folder // // Returns an error if it isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { //fs.Debugf(f, "CreateDir(%q, %q)\n", pathID, leaf) return f.purgeCheck(ctx, dir, true) } // Precision return the precision of this Fs func (f *Fs) Precision() time.Duration { return f.precision } // Copy src to this remote using server side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (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) if err != nil { return nil, err } // Create temporary object dstObj, leaf, directoryID, err := f.createObject(ctx, remote, srcObj.modTime, srcObj.size) if err != nil { return nil, err } if !f.canCopyWithName && leaf != path.Base(srcObj.remote) { fs.Debugf(src, "Can't copy - can't change the name of files") return nil, fs.ErrorCantCopy } // Copy the object var info api.FileResponse p := params{ "fi_id": srcObj.id, "fi_pid": directoryID, "force": "y", "options": "allownoextension", // without this the filefabric adds extensions to files without } if f.canCopyWithName { p["fi_name"] = f.opt.Enc.FromStandardName(leaf) } _, err = f.rpc(ctx, "doCopyFile", p, &info, nil) if err != nil { return nil, fmt.Errorf("failed to copy file: %w", err) } err = dstObj.setMetaData(&info.Item) if err != nil { return nil, err } return dstObj, nil } // Purge deletes all the files and the container // // Optional interface: Only implement this if you have a way of // deleting all the files quicker than just running Remove() on the // result of List() func (f *Fs) Purge(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, false) } // Wait for the background task to complete if necessary func (f *Fs) waitForBackgroundTask(ctx context.Context, taskID api.String) (err error) { if taskID == "" || taskID == "0" { // No task to wait for return nil } start := time.Now() sleepTime := time.Second for { var info api.TasksResponse _, err = f.rpc(ctx, "getUserBackgroundTasks", params{ "taskid": taskID, }, &info, nil) if err != nil { return fmt.Errorf("failed to wait for task %s to complete: %w", taskID, err) } if len(info.Tasks) == 0 { // task has finished break } if len(info.Tasks) > 1 { fs.Errorf(f, "Unexpected number of tasks returned %d", len(info.Tasks)) } task := info.Tasks[0] if task.BtStatus == "c" { // task completed break } dt := time.Since(start) fs.Debugf(f, "Waiting for task ID %s: %s: to completed for %v - waited %v already", task.BtID, task.BtTitle, sleepTime, dt) time.Sleep(sleepTime) } return nil } // Rename the leaf of a file or directory in a directory func (f *Fs) renameLeaf(ctx context.Context, isDir bool, id string, newLeaf string) (item *api.Item, err error) { var info api.FileResponse method := "doRenameFile" if isDir { method = "doRenameFolder" } _, err = f.rpc(ctx, method, params{ "fi_id": id, "fi_name": newLeaf, }, &info, nil) if err != nil { return nil, fmt.Errorf("failed to rename leaf: %w", err) } err = f.waitForBackgroundTask(ctx, info.Status.TaskID) if err != nil { return nil, err } return &info.Item, nil } // move a file or folder // // This is complicated by the fact that there is an API to move files // between directories and a separate one to rename them. We try to // call the minimum number of API calls. func (f *Fs) move(ctx context.Context, isDir bool, id, oldLeaf, newLeaf, oldDirectoryID, newDirectoryID string) (item *api.Item, err error) { newLeaf = f.opt.Enc.FromStandardName(newLeaf) oldLeaf = f.opt.Enc.FromStandardName(oldLeaf) doRenameLeaf := oldLeaf != newLeaf doMove := oldDirectoryID != newDirectoryID // Now rename the leaf to a temporary name if we are moving to // another directory to make sure we don't overwrite something // in the destination directory by accident if doRenameLeaf && doMove { tmpLeaf := newLeaf + "." + random.String(8) item, err = f.renameLeaf(ctx, isDir, id, tmpLeaf) if err != nil { return nil, err } } // Move the object to a new directory (with the existing name) // if required if doMove { var info api.MoveFilesResponse method := "doMoveFiles" if isDir { method = "doMoveFolders" } _, err = f.rpc(ctx, method, params{ "fi_ids": id, "dir_id": newDirectoryID, }, &info, nil) if err != nil { return nil, fmt.Errorf("failed to move file to new directory: %w", err) } item = &info.Item err = f.waitForBackgroundTask(ctx, info.Status.TaskID) if err != nil { return nil, err } } // Rename the leaf to its final name if required if doRenameLeaf { item, err = f.renameLeaf(ctx, isDir, id, newLeaf) if err != nil { return nil, err } } return item, nil } // Move src to this remote using server side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't move - not same remote type") return nil, fs.ErrorCantMove } // find the source directoryID srcLeaf, srcDirectoryID, err := srcObj.fs.dirCache.FindPath(ctx, srcObj.remote, false) if err != nil { return nil, err } // Create temporary object dstObj, dstLeaf, dstDirectoryID, err := f.createObject(ctx, remote, srcObj.modTime, srcObj.size) if err != nil { return nil, err } // Do the move item, err := f.move(ctx, false, srcObj.id, srcLeaf, dstLeaf, srcDirectoryID, dstDirectoryID) if err != nil { return nil, err } // Set the metadata from what was returned or read it fresh if item == nil { err = dstObj.readMetaData(ctx) if err != nil { return nil, err } } else { err = dstObj.setMetaData(item) if err != nil { return nil, err } } return dstObj, nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } srcID, srcDirectoryID, srcLeaf, dstDirectoryID, dstLeaf, err := f.dirCache.DirMove(ctx, srcFs.dirCache, srcFs.root, srcRemote, f.root, dstRemote) if err != nil { return err } // Do the move _, err = f.move(ctx, true, srcID, srcLeaf, dstLeaf, srcDirectoryID, dstDirectoryID) if err != nil { return err } srcFs.dirCache.FlushDir(srcRemote) return nil } // CleanUp empties the trash func (f *Fs) CleanUp(ctx context.Context) (err error) { var info api.EmptyResponse _, err = f.rpc(ctx, "emptyTrashInBackground", params{}, &info, nil) if err != nil { return fmt.Errorf("failed to empty trash: %w", err) } return nil } // DirCacheFlush resets the directory cache - used in testing as an // optional interface func (f *Fs) DirCacheFlush() { f.dirCache.ResetRoot() } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hash.None) } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Hash of the object in the requested format as a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { return "", hash.ErrUnsupported } // Size returns the size of an object in bytes func (o *Object) Size() int64 { err := o.readMetaData(context.TODO()) if err != nil { fs.Logf(o, "Failed to read metadata: %v", err) return 0 } if o.contentType == emptyMimeType { return 0 } return o.size } // setMetaData sets the metadata from info func (o *Object) setMetaData(info *api.Item) (err error) { if info.Type != api.ItemTypeFile { return fs.ErrorIsDir } o.hasMetaData = true o.size = info.Size o.modTime = time.Time(info.Modified) if !time.Time(info.LocalTime).IsZero() { o.modTime = time.Time(info.LocalTime) } o.id = info.ID o.contentType = info.ContentType return nil } // readMetaData gets the metadata if it hasn't already been fetched // // it also sets the info func (o *Object) readMetaData(ctx context.Context) (err error) { if o.hasMetaData { return nil } rootID, err := o.fs.dirCache.RootID(ctx, false) if err != nil { if err == fs.ErrorDirNotFound { err = fs.ErrorObjectNotFound } return err } info, err := o.fs.readMetaDataForPath(ctx, rootID, o.remote) if err != nil { if apiErr, ok := err.(*api.Status); ok { if apiErr.Code == "not_found" || apiErr.Code == "trashed" { return fs.ErrorObjectNotFound } } return err } return o.setMetaData(info) } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers func (o *Object) ModTime(ctx context.Context) time.Time { err := o.readMetaData(ctx) if err != nil { fs.Logf(o, "Failed to read metadata: %v", err) return time.Now() } return o.modTime } // modifyFile updates file metadata // // keyValues should be key, value pairs func (o *Object) modifyFile(ctx context.Context, keyValues [][2]string) error { var info api.FileResponse var data strings.Builder for _, keyValue := range keyValues { data.WriteString(keyValue[0]) data.WriteRune('=') data.WriteString(keyValue[1]) data.WriteRune('\n') } _, err := o.fs.rpc(ctx, "doModifyFile", params{ "fi_id": o.id, "data": data.String(), }, &info, nil) if err != nil { return fmt.Errorf("failed to update metadata: %w", err) } return o.setMetaData(&info.Item) } // SetModTime sets the modification time of the local fs object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { return o.modifyFile(ctx, [][2]string{ {"fi_localtime", api.Time(modTime).String()}, }) } // Storable returns a boolean showing whether this object storable func (o *Object) Storable() bool { return true } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { if o.id == "" { return nil, errors.New("can't download - no id") } if o.contentType == emptyMimeType { return io.NopCloser(bytes.NewReader([]byte{})), nil } fs.FixRangeOption(options, o.size) resp, err := o.fs.rpc(ctx, "getFile", params{ "fi_id": o.id, }, nil, options) if err != nil { return nil, err } return resp.Body, nil } // Update the object with the contents of the io.Reader, modTime and size // // If existing is set then it updates the object rather than creating a new one. // // The new object may have been created if an error is returned func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { modTime := src.ModTime(ctx) remote := o.remote size := src.Size() // Can't upload 0 length files - these upload as a single // space. // if size == 0 { // return fs.ErrorCantUploadEmptyFiles // } // Create the directory for the object if it doesn't exist leaf, directoryID, err := o.fs.dirCache.FindPath(ctx, remote, true) if err != nil { return err } // Initialise the upload var upload api.DoInitUploadResponse timestamp := api.Time(modTime).String() encodedLeaf := o.fs.opt.Enc.FromStandardName(leaf) base64EncodedLeaf := base64.StdEncoding.EncodeToString([]byte(encodedLeaf)) contentType := fs.MimeType(ctx, src) if size == 0 { contentType = emptyMimeType } p := params{ "fi_name": encodedLeaf, "fi_pid": directoryID, "fi_filename": encodedLeaf, "fi_localtime": timestamp, "fi_modified": timestamp, "fi_contenttype": contentType, "responsetype": "json", // make the upload.cgi return JSON "directuploadsupport": "n", // FIXME should we support this? // "chunkifbig": "n", // FIXME multipart? } // Set the size if known if size >= 0 { p["fi_size"] = size } _, err = o.fs.rpc(ctx, "doInitUpload", p, &upload, nil) if err != nil { return fmt.Errorf("failed to initialize upload: %w", err) } // Cancel the upload if aborted or it fails finalized := false defer atexit.OnError(&err, func() { if finalized { return } fs.Debugf(o, "Cancelling upload %s", upload.UploadCode) var cancel api.EmptyResponse _, fErr := o.fs.rpc(ctx, "doAbortUpload", params{ "uploadcode": upload.UploadCode, }, &cancel, nil) if fErr != nil { fs.Errorf(o, "failed to cancel upload: %v", fErr) } })() // Post the file with the upload code var uploader api.UploaderResponse opts := rest.Opts{ //Method: "POST", Method: "PUT", Path: "/cgi-bin/uploader/uploader1.cgi/" + base64EncodedLeaf + "?" + upload.UploadCode, Body: in, ContentType: contentType, // MultipartParams: url.Values{}, // MultipartContentName: "file", // MultipartFileName: "datafile", } // Set the size if known if size >= 0 { var contentLength = size opts.ContentLength = &contentLength // NB CallJSON scribbles on this which is naughty } try := 0 err = o.fs.pacer.CallNoRetry(func() (bool, error) { try++ resp, err := o.fs.srv.CallJSON(ctx, &opts, nil, &uploader) return o.fs.shouldRetry(ctx, resp, err, nil, try) }) if err != nil { return fmt.Errorf("failed to upload: %w", err) } if uploader.Success != "y" { return fmt.Errorf("upload failed") } if size > 0 && uploader.FileSize != size { return fmt.Errorf("upload failed: size mismatch: want %d got %d", size, uploader.FileSize) } // Now finalize the file var finalize api.DoCompleteUploadResponse p = params{ "uploadcode": upload.UploadCode, "remotetime": timestamp, "fi_size": uploader.FileSize, } _, err = o.fs.rpc(ctx, "doCompleteUpload", p, &finalize, nil) if err != nil { return fmt.Errorf("failed to finalize upload: %w", err) } finalized = true err = o.setMetaData(&finalize.File) if err != nil { return err } // Make sure content type is correct if o.contentType != contentType { fs.Debugf(o, "Correcting mime type from %q to %q", o.contentType, contentType) return o.modifyFile(ctx, [][2]string{ {"fi_contenttype", contentType}, }) } return nil } // Remove an object func (o *Object) Remove(ctx context.Context) error { return o.fs.deleteObject(ctx, o.id) } // ID returns the ID of the Object if known, or "" if not func (o *Object) ID() string { return o.id } // MimeType returns the content type of the Object if // known, or "" if not func (o *Object) MimeType(ctx context.Context) string { return o.contentType } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.DirCacheFlusher = (*Fs)(nil) _ fs.CleanUpper = (*Fs)(nil) _ fs.Object = (*Object)(nil) _ fs.IDer = (*Object)(nil) _ fs.MimeTyper = (*Object)(nil) ) rclone-v1.71.0/backend/filefabric/filefabric_test.go000066400000000000000000000006031505210326400223760ustar00rootroot00000000000000// Test filefabric filesystem interface package filefabric_test import ( "testing" "github.com/rclone/rclone/backend/filefabric" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestFileFabric:", NilObject: (*filefabric.Object)(nil), }) } rclone-v1.71.0/backend/filelu/000077500000000000000000000000001505210326400161155ustar00rootroot00000000000000rclone-v1.71.0/backend/filelu/api/000077500000000000000000000000001505210326400166665ustar00rootroot00000000000000rclone-v1.71.0/backend/filelu/api/types.go000066400000000000000000000051001505210326400203550ustar00rootroot00000000000000// Package api defines types for interacting with the FileLu API. package api import "encoding/json" // CreateFolderResponse represents the response for creating a folder. type CreateFolderResponse struct { Status int `json:"status"` Msg string `json:"msg"` Result struct { FldID interface{} `json:"fld_id"` } `json:"result"` } // DeleteFolderResponse represents the response for deleting a folder. type DeleteFolderResponse struct { Status int `json:"status"` Msg string `json:"msg"` } // FolderListResponse represents the response for listing folders. type FolderListResponse struct { Status int `json:"status"` Msg string `json:"msg"` Result struct { Files []struct { Name string `json:"name"` FldID json.Number `json:"fld_id"` Path string `json:"path"` FileCode string `json:"file_code"` Size int64 `json:"size"` } `json:"files"` Folders []struct { Name string `json:"name"` FldID json.Number `json:"fld_id"` Path string `json:"path"` } `json:"folders"` } `json:"result"` } // FileDirectLinkResponse represents the response for a direct link to a file. type FileDirectLinkResponse struct { Status int `json:"status"` Msg string `json:"msg"` Result struct { URL string `json:"url"` Size int64 `json:"size"` } `json:"result"` } // FileInfoResponse represents the response for file information. type FileInfoResponse struct { Status int `json:"status"` Msg string `json:"msg"` Result []struct { Size string `json:"size"` Name string `json:"name"` FileCode string `json:"filecode"` Hash string `json:"hash"` Status int `json:"status"` } `json:"result"` } // DeleteFileResponse represents the response for deleting a file. type DeleteFileResponse struct { Status int `json:"status"` Msg string `json:"msg"` } // AccountInfoResponse represents the response for account information. type AccountInfoResponse struct { Status int `json:"status"` // HTTP status code of the response. Msg string `json:"msg"` // Message describing the response. Result struct { PremiumExpire string `json:"premium_expire"` // Expiration date of premium access. Email string `json:"email"` // User's email address. UType string `json:"utype"` // User type (e.g., premium or free). Storage string `json:"storage"` // Total storage available to the user. StorageUsed string `json:"storage_used"` // Amount of storage used. } `json:"result"` // Nested result structure containing account details. } rclone-v1.71.0/backend/filelu/filelu.go000066400000000000000000000227301505210326400177300ustar00rootroot00000000000000// Package filelu provides an interface to the FileLu storage system. package filelu import ( "context" "fmt" "io" "net/http" "os" "path" "strings" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/rest" ) // Register the backend with Rclone func init() { fs.Register(&fs.RegInfo{ Name: "filelu", Description: "FileLu Cloud Storage", NewFs: NewFs, Options: []fs.Option{{ Name: "key", Help: "Your FileLu Rclone key from My Account", Required: true, Sensitive: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: (encoder.Base | // Slash,LtGt,DoubleQuote,Question,Asterisk,Pipe,Hash,Percent,BackSlash,Del,Ctl,RightSpace,InvalidUtf8,Dot encoder.EncodeSlash | encoder.EncodeLtGt | encoder.EncodeExclamation | encoder.EncodeDoubleQuote | encoder.EncodeSingleQuote | encoder.EncodeBackQuote | encoder.EncodeQuestion | encoder.EncodeDollar | encoder.EncodeColon | encoder.EncodeAsterisk | encoder.EncodePipe | encoder.EncodeHash | encoder.EncodePercent | encoder.EncodeBackSlash | encoder.EncodeCrLf | encoder.EncodeDel | encoder.EncodeCtl | encoder.EncodeLeftSpace | encoder.EncodeLeftPeriod | encoder.EncodeLeftTilde | encoder.EncodeLeftCrLfHtVt | encoder.EncodeRightPeriod | encoder.EncodeRightCrLfHtVt | encoder.EncodeSquareBracket | encoder.EncodeSemicolon | encoder.EncodeRightSpace | encoder.EncodeInvalidUtf8 | encoder.EncodeDot), }, }}) } // Options defines the configuration for the FileLu backend type Options struct { Key string `config:"key"` Enc encoder.MultiEncoder `config:"encoding"` } // Fs represents the FileLu file system type Fs struct { name string root string opt Options features *fs.Features endpoint string pacer *pacer.Pacer srv *rest.Client client *http.Client targetFile string } // NewFs creates a new Fs object for FileLu func NewFs(ctx context.Context, name string, root string, m configmap.Mapper) (fs.Fs, error) { opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, fmt.Errorf("failed to parse config: %w", err) } if opt.Key == "" { return nil, fmt.Errorf("FileLu Rclone Key is required") } client := fshttp.NewClient(ctx) if strings.TrimSpace(root) == "" { root = "" } root = strings.Trim(root, "/") filename := "" f := &Fs{ name: name, opt: *opt, endpoint: "https://filelu.com/rclone", client: client, srv: rest.NewClient(client).SetRoot("https://filelu.com/rclone"), pacer: pacer.New(), targetFile: filename, root: root, } f.features = (&fs.Features{ CanHaveEmptyDirectories: true, WriteMetadata: false, SlowHash: true, }).Fill(ctx, f) rootContainer, rootDirectory := rootSplit(f.root) if rootContainer != "" && rootDirectory != "" { // Check to see if the (container,directory) is actually an existing file oldRoot := f.root newRoot, leaf := path.Split(oldRoot) f.root = strings.Trim(newRoot, "/") _, err := f.NewObject(ctx, leaf) if err != nil { if err == fs.ErrorObjectNotFound || err == fs.ErrorNotAFile { // File doesn't exist or is a directory so return old f f.root = strings.Trim(oldRoot, "/") return f, nil } return nil, err } // return an error with an fs which points to the parent return f, fs.ErrorIsFile } return f, nil } // Mkdir to create directory on remote server. func (f *Fs) Mkdir(ctx context.Context, dir string) error { fullPath := path.Clean(f.root + "/" + dir) _, err := f.createFolder(ctx, fullPath) return err } // About provides usage statistics for the remote func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { accountInfo, err := f.getAccountInfo(ctx) if err != nil { return nil, err } totalStorage, err := parseStorageToBytes(accountInfo.Result.Storage) if err != nil { return nil, fmt.Errorf("failed to parse total storage: %w", err) } usedStorage, err := parseStorageToBytes(accountInfo.Result.StorageUsed) if err != nil { return nil, fmt.Errorf("failed to parse used storage: %w", err) } return &fs.Usage{ Total: fs.NewUsageValue(totalStorage), // Total bytes available Used: fs.NewUsageValue(usedStorage), // Total bytes used Free: fs.NewUsageValue(totalStorage - usedStorage), }, nil } // Purge deletes the directory and all its contents func (f *Fs) Purge(ctx context.Context, dir string) error { fullPath := path.Join(f.root, dir) if fullPath != "" { fullPath = "/" + strings.Trim(fullPath, "/") } return f.deleteFolder(ctx, fullPath) } // List returns a list of files and folders // List returns a list of files and folders for the given directory func (f *Fs) List(ctx context.Context, dir string) (fs.DirEntries, error) { // Compose full path for API call fullPath := path.Join(f.root, dir) fullPath = "/" + strings.Trim(fullPath, "/") if fullPath == "/" { fullPath = "" } var entries fs.DirEntries result, err := f.getFolderList(ctx, fullPath) if err != nil { return nil, err } fldMap := map[string]bool{} for _, folder := range result.Result.Folders { fldMap[folder.FldID.String()] = true if f.root == "" && dir == "" && strings.Contains(folder.Path, "/") { continue } paths := strings.Split(folder.Path, fullPath+"/") remote := paths[0] if len(paths) > 1 { remote = paths[1] } if strings.Contains(remote, "/") { continue } pathsWithoutRoot := strings.Split(folder.Path, "/"+f.root+"/") remotePathWithoutRoot := pathsWithoutRoot[0] if len(pathsWithoutRoot) > 1 { remotePathWithoutRoot = pathsWithoutRoot[1] } remotePathWithoutRoot = strings.TrimPrefix(remotePathWithoutRoot, "/") entries = append(entries, fs.NewDir(remotePathWithoutRoot, time.Now())) } for _, file := range result.Result.Files { if _, ok := fldMap[file.FldID.String()]; ok { continue } remote := path.Join(dir, file.Name) // trim leading slashes remote = strings.TrimPrefix(remote, "/") obj := &Object{ fs: f, remote: remote, size: file.Size, modTime: time.Now(), } entries = append(entries, obj) } return entries, nil } // Put uploads a file directly to the destination folder in the FileLu storage system. func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { if src.Size() == 0 { return nil, fs.ErrorCantUploadEmptyFiles } err := f.uploadFile(ctx, in, src.Remote()) if err != nil { return nil, err } newObject := &Object{ fs: f, remote: src.Remote(), size: src.Size(), modTime: src.ModTime(ctx), } fs.Infof(f, "Put: Successfully uploaded new file %q", src.Remote()) return newObject, nil } // Move moves the file to the specified location func (f *Fs) Move(ctx context.Context, src fs.Object, destinationPath string) (fs.Object, error) { if strings.HasPrefix(destinationPath, "/") || strings.Contains(destinationPath, ":\\") { dir := path.Dir(destinationPath) if err := os.MkdirAll(dir, 0755); err != nil { return nil, fmt.Errorf("failed to create destination directory: %w", err) } reader, err := src.Open(ctx) if err != nil { return nil, fmt.Errorf("failed to open source file: %w", err) } defer func() { if err := reader.Close(); err != nil { fs.Logf(nil, "Failed to close file body: %v", err) } }() dest, err := os.Create(destinationPath) if err != nil { return nil, fmt.Errorf("failed to create destination file: %w", err) } defer func() { if err := dest.Close(); err != nil { fs.Logf(nil, "Failed to close file body: %v", err) } }() if _, err := io.Copy(dest, reader); err != nil { return nil, fmt.Errorf("failed to copy file content: %w", err) } if err := src.Remove(ctx); err != nil { return nil, fmt.Errorf("failed to remove source file: %w", err) } return nil, nil } reader, err := src.Open(ctx) if err != nil { return nil, fmt.Errorf("failed to open source object: %w", err) } defer func() { if err := reader.Close(); err != nil { fs.Logf(nil, "Failed to close file body: %v", err) } }() err = f.uploadFile(ctx, reader, destinationPath) if err != nil { return nil, fmt.Errorf("failed to upload file to destination: %w", err) } if err := src.Remove(ctx); err != nil { return nil, fmt.Errorf("failed to delete source file: %w", err) } return &Object{ fs: f, remote: destinationPath, size: src.Size(), modTime: src.ModTime(ctx), }, nil } // Rmdir removes a directory func (f *Fs) Rmdir(ctx context.Context, dir string) error { fullPath := path.Join(f.root, dir) if fullPath != "" { fullPath = "/" + strings.Trim(fullPath, "/") } // Step 1: Check if folder is empty listResp, err := f.getFolderList(ctx, fullPath) if err != nil { return err } if len(listResp.Result.Files) > 0 || len(listResp.Result.Folders) > 0 { return fmt.Errorf("Rmdir: directory %q is not empty", fullPath) } // Step 2: Delete the folder return f.deleteFolder(ctx, fullPath) } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.Object = (*Object)(nil) ) rclone-v1.71.0/backend/filelu/filelu_client.go000066400000000000000000000210031505210326400212560ustar00rootroot00000000000000package filelu import ( "bytes" "context" "encoding/json" "fmt" "io" "net/http" "net/url" "strings" "github.com/rclone/rclone/backend/filelu/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/lib/rest" ) // createFolder creates a folder at the specified path. func (f *Fs) createFolder(ctx context.Context, dirPath string) (*api.CreateFolderResponse, error) { encodedDir := f.fromStandardPath(dirPath) apiURL := fmt.Sprintf("%s/folder/create?folder_path=%s&key=%s", f.endpoint, url.QueryEscape(encodedDir), url.QueryEscape(f.opt.Key), // assuming f.opt.Key is the correct field ) req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil) if err != nil { return nil, fmt.Errorf("failed to create request: %w", err) } var resp *http.Response result := api.CreateFolderResponse{} err = f.pacer.Call(func() (bool, error) { var innerErr error resp, innerErr = f.client.Do(req) return fserrors.ShouldRetry(innerErr), innerErr }) if err != nil { return nil, fmt.Errorf("request failed: %w", err) } defer func() { if err := resp.Body.Close(); err != nil { fs.Logf(nil, "Failed to close response body: %v", err) } }() err = json.NewDecoder(resp.Body).Decode(&result) if err != nil { return nil, fmt.Errorf("error decoding response: %w", err) } if result.Status != 200 { return nil, fmt.Errorf("error: %s", result.Msg) } fs.Infof(f, "Successfully created folder %q with ID %v", dirPath, result.Result.FldID) return &result, nil } // getFolderList List both files and folders in a directory. func (f *Fs) getFolderList(ctx context.Context, path string) (*api.FolderListResponse, error) { encodedDir := f.fromStandardPath(path) apiURL := fmt.Sprintf("%s/folder/list?folder_path=%s&key=%s", f.endpoint, url.QueryEscape(encodedDir), url.QueryEscape(f.opt.Key), ) var body []byte err := f.pacer.Call(func() (bool, error) { req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil) if err != nil { return false, fmt.Errorf("failed to create request: %w", err) } resp, err := f.client.Do(req) if err != nil { return shouldRetry(err), fmt.Errorf("failed to list directory: %w", err) } defer func() { if err := resp.Body.Close(); err != nil { fs.Logf(nil, "Failed to close response body: %v", err) } }() body, err = io.ReadAll(resp.Body) if err != nil { return false, fmt.Errorf("error reading response body: %w", err) } return shouldRetryHTTP(resp.StatusCode), nil }) if err != nil { return nil, err } var response api.FolderListResponse if err := json.NewDecoder(bytes.NewReader(body)).Decode(&response); err != nil { return nil, fmt.Errorf("error decoding response: %w", err) } if response.Status != 200 { if strings.Contains(response.Msg, "Folder not found") { return nil, fs.ErrorDirNotFound } return nil, fmt.Errorf("API error: %s", response.Msg) } for index := range response.Result.Folders { response.Result.Folders[index].Path = f.toStandardPath(response.Result.Folders[index].Path) } for index := range response.Result.Files { response.Result.Files[index].Name = f.toStandardPath(response.Result.Files[index].Name) } return &response, nil } // deleteFolder deletes a folder at the specified path. func (f *Fs) deleteFolder(ctx context.Context, fullPath string) error { fullPath = f.fromStandardPath(fullPath) deleteURL := fmt.Sprintf("%s/folder/delete?folder_path=%s&key=%s", f.endpoint, url.QueryEscape(fullPath), url.QueryEscape(f.opt.Key), ) delResp := api.DeleteFolderResponse{} err := f.pacer.Call(func() (bool, error) { req, err := http.NewRequestWithContext(ctx, "GET", deleteURL, nil) if err != nil { return false, err } resp, err := f.client.Do(req) if err != nil { return fserrors.ShouldRetry(err), err } defer func() { if err := resp.Body.Close(); err != nil { fs.Logf(nil, "Failed to close response body: %v", err) } }() body, err := io.ReadAll(resp.Body) if err != nil { return false, err } if err := json.Unmarshal(body, &delResp); err != nil { return false, fmt.Errorf("error decoding delete response: %w", err) } if delResp.Status != 200 { return false, fmt.Errorf("delete error: %s", delResp.Msg) } return false, nil }) if err != nil { return err } fs.Infof(f, "Rmdir: successfully deleted %q", fullPath) return nil } // getDirectLink of file from FileLu to download. func (f *Fs) getDirectLink(ctx context.Context, filePath string) (string, int64, error) { filePath = f.fromStandardPath(filePath) apiURL := fmt.Sprintf("%s/file/direct_link?file_path=%s&key=%s", f.endpoint, url.QueryEscape(filePath), url.QueryEscape(f.opt.Key), ) result := api.FileDirectLinkResponse{} err := f.pacer.Call(func() (bool, error) { req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil) if err != nil { return false, fmt.Errorf("failed to create request: %w", err) } resp, err := f.client.Do(req) if err != nil { return shouldRetry(err), fmt.Errorf("failed to fetch direct link: %w", err) } defer func() { if err := resp.Body.Close(); err != nil { fs.Logf(nil, "Failed to close response body: %v", err) } }() if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { return false, fmt.Errorf("error decoding response: %w", err) } if result.Status != 200 { return false, fmt.Errorf("API error: %s", result.Msg) } return shouldRetryHTTP(resp.StatusCode), nil }) if err != nil { return "", 0, err } return result.Result.URL, result.Result.Size, nil } // deleteFile deletes a file based on filePath func (f *Fs) deleteFile(ctx context.Context, filePath string) error { filePath = f.fromStandardPath(filePath) apiURL := fmt.Sprintf("%s/file/remove?file_path=%s&key=%s", f.endpoint, url.QueryEscape(filePath), url.QueryEscape(f.opt.Key), ) result := api.DeleteFileResponse{} err := f.pacer.Call(func() (bool, error) { req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil) if err != nil { return false, fmt.Errorf("failed to create request: %w", err) } resp, err := f.client.Do(req) if err != nil { return shouldRetry(err), fmt.Errorf("failed to fetch direct link: %w", err) } defer func() { if err := resp.Body.Close(); err != nil { fs.Logf(nil, "Failed to close response body: %v", err) } }() if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { return false, fmt.Errorf("error decoding response: %w", err) } if result.Status != 200 { return false, fmt.Errorf("API error: %s", result.Msg) } return shouldRetryHTTP(resp.StatusCode), nil }) return err } // getAccountInfo retrieves account information func (f *Fs) getAccountInfo(ctx context.Context) (*api.AccountInfoResponse, error) { opts := rest.Opts{ Method: "GET", Path: "/account/info", Parameters: url.Values{ "key": {f.opt.Key}, }, } var result api.AccountInfoResponse err := f.pacer.Call(func() (bool, error) { _, callErr := f.srv.CallJSON(ctx, &opts, nil, &result) return fserrors.ShouldRetry(callErr), callErr }) if err != nil { return nil, err } if result.Status != 200 { return nil, fmt.Errorf("error: %s", result.Msg) } return &result, nil } // getFileInfo retrieves file information based on file code func (f *Fs) getFileInfo(ctx context.Context, fileCode string) (*api.FileInfoResponse, error) { u, _ := url.Parse(f.endpoint + "/file/info2") q := u.Query() q.Set("file_code", fileCode) // raw path — Go handles escaping properly here q.Set("key", f.opt.Key) u.RawQuery = q.Encode() apiURL := f.endpoint + "/file/info2?" + u.RawQuery var body []byte err := f.pacer.Call(func() (bool, error) { req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil) if err != nil { return false, fmt.Errorf("failed to create request: %w", err) } resp, err := f.client.Do(req) if err != nil { return shouldRetry(err), fmt.Errorf("failed to fetch file info: %w", err) } defer func() { if err := resp.Body.Close(); err != nil { fs.Logf(nil, "Failed to close response body: %v", err) } }() body, err = io.ReadAll(resp.Body) if err != nil { return false, fmt.Errorf("error reading response body: %w", err) } return shouldRetryHTTP(resp.StatusCode), nil }) if err != nil { return nil, err } result := api.FileInfoResponse{} if err := json.NewDecoder(bytes.NewReader(body)).Decode(&result); err != nil { return nil, fmt.Errorf("error decoding response: %w", err) } if result.Status != 200 || len(result.Result) == 0 { return nil, fs.ErrorObjectNotFound } return &result, nil } rclone-v1.71.0/backend/filelu/filelu_file_uploader.go000066400000000000000000000124461505210326400226250ustar00rootroot00000000000000package filelu import ( "context" "encoding/json" "errors" "fmt" "io" "mime/multipart" "net/http" "net/url" "path" "strings" "github.com/rclone/rclone/fs" ) // uploadFile uploads a file to FileLu func (f *Fs) uploadFile(ctx context.Context, fileContent io.Reader, fileFullPath string) error { directory := path.Dir(fileFullPath) fileName := path.Base(fileFullPath) if directory == "." { directory = "" } destinationFolderPath := path.Join(f.root, directory) if destinationFolderPath != "" { destinationFolderPath = "/" + strings.Trim(destinationFolderPath, "/") } existingEntries, err := f.List(ctx, path.Dir(fileFullPath)) if err != nil { if errors.Is(err, fs.ErrorDirNotFound) { err = f.Mkdir(ctx, path.Dir(fileFullPath)) if err != nil { return fmt.Errorf("failed to create directory: %w", err) } } else { return fmt.Errorf("failed to list existing files: %w", err) } } for _, entry := range existingEntries { if entry.Remote() == fileFullPath { _, ok := entry.(fs.Object) if !ok { continue } // If the file exists but is different, remove it filePath := "/" + strings.Trim(destinationFolderPath+"/"+fileName, "/") err = f.deleteFile(ctx, filePath) if err != nil { return fmt.Errorf("failed to delete existing file: %w", err) } } } uploadURL, sessID, err := f.getUploadServer(ctx) if err != nil { return fmt.Errorf("failed to retrieve upload server: %w", err) } // Since the fileCode isn't used, just handle the error if _, err := f.uploadFileWithDestination(ctx, uploadURL, sessID, fileName, fileContent, destinationFolderPath); err != nil { return fmt.Errorf("failed to upload file: %w", err) } return nil } // getUploadServer gets the upload server URL with proper key authentication func (f *Fs) getUploadServer(ctx context.Context) (string, string, error) { apiURL := fmt.Sprintf("%s/upload/server?key=%s", f.endpoint, url.QueryEscape(f.opt.Key)) var result struct { Status int `json:"status"` SessID string `json:"sess_id"` Result string `json:"result"` Msg string `json:"msg"` } err := f.pacer.Call(func() (bool, error) { req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil) if err != nil { return false, fmt.Errorf("failed to create request: %w", err) } resp, err := f.client.Do(req) if err != nil { return shouldRetry(err), fmt.Errorf("failed to get upload server: %w", err) } defer func() { if err := resp.Body.Close(); err != nil { fs.Logf(nil, "Failed to close response body: %v", err) } }() if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { return false, fmt.Errorf("error decoding response: %w", err) } if result.Status != 200 { return false, fmt.Errorf("API error: %s", result.Msg) } return shouldRetryHTTP(resp.StatusCode), nil }) if err != nil { return "", "", err } return result.Result, result.SessID, nil } // uploadFileWithDestination uploads a file directly to a specified folder using file content reader. func (f *Fs) uploadFileWithDestination(ctx context.Context, uploadURL, sessID, fileName string, fileContent io.Reader, dirPath string) (string, error) { destinationPath := f.fromStandardPath(dirPath) encodedFileName := f.fromStandardPath(fileName) pr, pw := io.Pipe() writer := multipart.NewWriter(pw) isDeletionRequired := false go func() { defer func() { if err := pw.Close(); err != nil { fs.Logf(nil, "Failed to close: %v", err) } }() _ = writer.WriteField("sess_id", sessID) _ = writer.WriteField("utype", "prem") _ = writer.WriteField("fld_path", destinationPath) part, err := writer.CreateFormFile("file_0", encodedFileName) if err != nil { pw.CloseWithError(fmt.Errorf("failed to create form file: %w", err)) return } if _, err := io.Copy(part, fileContent); err != nil { isDeletionRequired = true pw.CloseWithError(fmt.Errorf("failed to copy file content: %w", err)) return } if err := writer.Close(); err != nil { pw.CloseWithError(fmt.Errorf("failed to close writer: %w", err)) } }() var fileCode string err := f.pacer.Call(func() (bool, error) { req, err := http.NewRequestWithContext(ctx, "POST", uploadURL, pr) if err != nil { return false, fmt.Errorf("failed to create upload request: %w", err) } req.Header.Set("Content-Type", writer.FormDataContentType()) resp, err := f.client.Do(req) if err != nil { return shouldRetry(err), fmt.Errorf("failed to send upload request: %w", err) } defer respBodyClose(resp.Body) var result []struct { FileCode string `json:"file_code"` FileStatus string `json:"file_status"` } if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { return false, fmt.Errorf("failed to parse upload response: %w", err) } if len(result) == 0 || result[0].FileStatus != "OK" { return false, fmt.Errorf("upload failed with status: %s", result[0].FileStatus) } fileCode = result[0].FileCode return shouldRetryHTTP(resp.StatusCode), nil }) if err != nil && isDeletionRequired { // Attempt to delete the file if upload fails _ = f.deleteFile(ctx, destinationPath+"/"+fileName) } return fileCode, err } // respBodyClose to check body response. func respBodyClose(responseBody io.Closer) { if cerr := responseBody.Close(); cerr != nil { fmt.Printf("Error closing response body: %v\n", cerr) } } rclone-v1.71.0/backend/filelu/filelu_helper.go000066400000000000000000000045201505210326400212640ustar00rootroot00000000000000package filelu import ( "context" "errors" "fmt" "path" "strings" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/hash" ) // errFileNotFound represent file not found error var errFileNotFound = errors.New("file not found") // getFileCode retrieves the file code for a given file path func (f *Fs) getFileCode(ctx context.Context, filePath string) (string, error) { // Prepare parent directory parentDir := path.Dir(filePath) // Call List to get all the files result, err := f.getFolderList(ctx, parentDir) if err != nil { return "", err } for _, file := range result.Result.Files { filePathFromServer := parentDir + "/" + file.Name if parentDir == "/" { filePathFromServer = "/" + file.Name } if filePath == filePathFromServer { return file.FileCode, nil } } return "", errFileNotFound } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } func (f *Fs) fromStandardPath(remote string) string { return f.opt.Enc.FromStandardPath(remote) } func (f *Fs) toStandardPath(remote string) string { return f.opt.Enc.ToStandardPath(remote) } // Hashes returns an empty hash set, indicating no hash support func (f *Fs) Hashes() hash.Set { return hash.NewHashSet() // Properly creates an empty hash set } // Name returns the remote name func (f *Fs) Name() string { return f.name } // Root returns the root path func (f *Fs) Root() string { return f.root } // Precision returns the precision of the remote func (f *Fs) Precision() time.Duration { return fs.ModTimeNotSupported } func (f *Fs) String() string { return fmt.Sprintf("FileLu root '%s'", f.root) } // isFileCode checks if a string looks like a file code func isFileCode(s string) bool { if len(s) != 12 { return false } for _, c := range s { if !((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9')) { return false } } return true } func shouldRetry(err error) bool { return fserrors.ShouldRetry(err) } func shouldRetryHTTP(code int) bool { return code == 429 || code >= 500 } func rootSplit(absPath string) (bucket, bucketPath string) { // No bucket if absPath == "" { return "", "" } slash := strings.IndexRune(absPath, '/') // Bucket but no path if slash < 0 { return absPath, "" } return absPath[:slash], absPath[slash+1:] } rclone-v1.71.0/backend/filelu/filelu_object.go000066400000000000000000000140751505210326400212610ustar00rootroot00000000000000package filelu import ( "bytes" "context" "encoding/json" "fmt" "io" "net/http" "net/url" "path" "regexp" "strconv" "strings" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" ) // Object describes a FileLu object type Object struct { fs *Fs remote string size int64 modTime time.Time } // NewObject creates a new Object for the given remote path func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { var filePath string filePath = path.Join(f.root, remote) filePath = "/" + strings.Trim(filePath, "/") // Get File code fileCode, err := f.getFileCode(ctx, filePath) if err != nil { return nil, fs.ErrorObjectNotFound } // Get File info fileInfos, err := f.getFileInfo(ctx, fileCode) if err != nil { return nil, fmt.Errorf("failed to get file info: %w", err) } fileInfo := fileInfos.Result[0] size, _ := strconv.ParseInt(fileInfo.Size, 10, 64) returnedRemote := remote return &Object{ fs: f, remote: returnedRemote, size: size, modTime: time.Now(), }, nil } // Open opens the object for reading func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { filePath := path.Join(o.fs.root, o.remote) // Get direct link directLink, size, err := o.fs.getDirectLink(ctx, filePath) if err != nil { return nil, fmt.Errorf("failed to get direct link: %w", err) } o.size = size // Offset and Count for range download var offset int64 var count int64 fs.FixRangeOption(options, o.size) for _, option := range options { switch x := option.(type) { case *fs.RangeOption: offset, count = x.Decode(o.size) if count < 0 { count = o.size - offset } case *fs.SeekOption: offset = x.Offset count = o.size default: if option.Mandatory() { fs.Logf(o, "Unsupported mandatory option: %v", option) } } } var reader io.ReadCloser err = o.fs.pacer.Call(func() (bool, error) { req, err := http.NewRequestWithContext(ctx, "GET", directLink, nil) if err != nil { return false, fmt.Errorf("failed to create download request: %w", err) } resp, err := o.fs.client.Do(req) if err != nil { return shouldRetry(err), fmt.Errorf("failed to download file: %w", err) } if resp.StatusCode != http.StatusOK { defer func() { if err := resp.Body.Close(); err != nil { fs.Logf(nil, "Failed to close response body: %v", err) } }() return false, fmt.Errorf("failed to download file: HTTP %d", resp.StatusCode) } // Wrap the response body to handle offset and count currentContents, err := io.ReadAll(resp.Body) if err != nil { return false, fmt.Errorf("failed to read response body: %w", err) } if offset > 0 { if offset > int64(len(currentContents)) { return false, fmt.Errorf("offset %d exceeds file size %d", offset, len(currentContents)) } currentContents = currentContents[offset:] } if count > 0 && count < int64(len(currentContents)) { currentContents = currentContents[:count] } reader = io.NopCloser(bytes.NewReader(currentContents)) return false, nil }) if err != nil { return nil, err } return reader, nil } // Update updates the object with new data func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { if src.Size() <= 0 { return fs.ErrorCantUploadEmptyFiles } err := o.fs.uploadFile(ctx, in, o.remote) if err != nil { return fmt.Errorf("failed to upload file: %w", err) } o.size = src.Size() return nil } // Remove deletes the object from FileLu func (o *Object) Remove(ctx context.Context) error { fullPath := "/" + strings.Trim(path.Join(o.fs.root, o.remote), "/") err := o.fs.deleteFile(ctx, fullPath) if err != nil { return err } fs.Infof(o.fs, "Successfully deleted file: %s", fullPath) return nil } // Hash returns the MD5 hash of an object func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if t != hash.MD5 { return "", hash.ErrUnsupported } var fileCode string if isFileCode(o.fs.root) { fileCode = o.fs.root } else { matches := regexp.MustCompile(`\((.*?)\)`).FindAllStringSubmatch(o.remote, -1) for _, match := range matches { if len(match) > 1 && len(match[1]) == 12 { fileCode = match[1] break } } } if fileCode == "" { return "", fmt.Errorf("no valid file code found in the remote path") } apiURL := fmt.Sprintf("%s/file/info?file_code=%s&key=%s", o.fs.endpoint, url.QueryEscape(fileCode), url.QueryEscape(o.fs.opt.Key)) var result struct { Status int `json:"status"` Msg string `json:"msg"` Result []struct { Hash string `json:"hash"` } `json:"result"` } err := o.fs.pacer.Call(func() (bool, error) { req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil) if err != nil { return false, err } resp, err := o.fs.client.Do(req) if err != nil { return shouldRetry(err), err } defer func() { if err := resp.Body.Close(); err != nil { fs.Logf(nil, "Failed to close response body: %v", err) } }() if err := json.NewDecoder(resp.Body).Decode(&result); err != nil { return false, err } return shouldRetryHTTP(resp.StatusCode), nil }) if err != nil { return "", err } if result.Status != 200 || len(result.Result) == 0 { return "", fmt.Errorf("error: unable to fetch hash: %s", result.Msg) } return result.Result[0].Hash, nil } // String returns a string representation of the object func (o *Object) String() string { return o.remote } // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Size returns the size of the object func (o *Object) Size() int64 { return o.size } // ModTime returns the modification time of the object func (o *Object) ModTime(ctx context.Context) time.Time { return o.modTime } // SetModTime sets the modification time of the object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { return fs.ErrorCantSetModTime } // Storable indicates whether the object is storable func (o *Object) Storable() bool { return true } rclone-v1.71.0/backend/filelu/filelu_test.go000066400000000000000000000004651505210326400207700ustar00rootroot00000000000000package filelu_test import ( "testing" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests for the FileLu backend func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestFileLu:", NilObject: nil, SkipInvalidUTF8: true, }) } rclone-v1.71.0/backend/filelu/utils.go000066400000000000000000000005331505210326400176050ustar00rootroot00000000000000package filelu import ( "fmt" ) // parseStorageToBytes converts a storage string (e.g., "10") to bytes func parseStorageToBytes(storage string) (int64, error) { var gb float64 _, err := fmt.Sscanf(storage, "%f", &gb) if err != nil { return 0, fmt.Errorf("failed to parse storage: %w", err) } return int64(gb * 1024 * 1024 * 1024), nil } rclone-v1.71.0/backend/filescom/000077500000000000000000000000001505210326400164365ustar00rootroot00000000000000rclone-v1.71.0/backend/filescom/filescom.go000066400000000000000000000561361505210326400206010ustar00rootroot00000000000000// Package filescom provides an interface to the Files.com // object storage system. package filescom import ( "context" "errors" "fmt" "io" "net/http" "net/url" "path" "slices" "strings" "time" files_sdk "github.com/Files-com/files-sdk-go/v3" "github.com/Files-com/files-sdk-go/v3/bundle" "github.com/Files-com/files-sdk-go/v3/file" file_migration "github.com/Files-com/files-sdk-go/v3/filemigration" "github.com/Files-com/files-sdk-go/v3/folder" "github.com/Files-com/files-sdk-go/v3/session" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/pacer" ) /* Run of rclone info stringNeedsEscaping = []rune{ '/', '\x00' } maxFileLength = 512 // for 1 byte unicode characters maxFileLength = 512 // for 2 byte unicode characters maxFileLength = 512 // for 3 byte unicode characters maxFileLength = 512 // for 4 byte unicode characters canWriteUnnormalized = true canReadUnnormalized = true canReadRenormalized = true canStream = true */ const ( minSleep = 10 * time.Millisecond maxSleep = 2 * time.Second decayConstant = 2 // bigger for slower decay, exponential folderNotEmpty = "processing-failure/folder-not-empty" ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "filescom", Description: "Files.com", NewFs: NewFs, Options: []fs.Option{ { Name: "site", Help: "Your site subdomain (e.g. mysite) or custom domain (e.g. myfiles.customdomain.com).", }, { Name: "username", Help: "The username used to authenticate with Files.com.", }, { Name: "password", Help: "The password used to authenticate with Files.com.", IsPassword: true, }, { Name: "api_key", Help: "The API key used to authenticate with Files.com.", Advanced: true, Sensitive: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: (encoder.Display | encoder.EncodeBackSlash | encoder.EncodeRightSpace | encoder.EncodeRightCrLfHtVt | encoder.EncodeInvalidUtf8), }}, }) } // Options defines the configuration for this backend type Options struct { Site string `config:"site"` Username string `config:"username"` Password string `config:"password"` APIKey string `config:"api_key"` Enc encoder.MultiEncoder `config:"encoding"` } // Fs represents a remote files.com server type Fs struct { name string // name of this remote root string // the path we are working on opt Options // parsed options features *fs.Features // optional features fileClient *file.Client // the connection to the file API folderClient *folder.Client // the connection to the folder API migrationClient *file_migration.Client // the connection to the file migration API bundleClient *bundle.Client // the connection to the bundle API pacer *fs.Pacer // pacer for API calls } // Object describes a files object // // Will definitely have info but maybe not meta type Object struct { fs *Fs // what this object is part of remote string // The remote path size int64 // size of the object crc32 string // CRC32 of the object content md5 string // MD5 of the object content mimeType string // Content-Type of the object modTime time.Time // modification time of the object } // ------------------------------------------------------------ // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("files root '%s'", f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // Encode remote and turn it into an absolute path in the share func (f *Fs) absPath(remote string) string { return f.opt.Enc.FromStandardPath(path.Join(f.root, remote)) } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 429, // Too Many Requests. 500, // Internal Server Error 502, // Bad Gateway 503, // Service Unavailable 504, // Gateway Timeout 509, // Bandwidth Limit Exceeded } // shouldRetry returns a boolean as to whether this err deserves to be // retried. It returns the err as a convenience func shouldRetry(ctx context.Context, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } if apiErr, ok := err.(files_sdk.ResponseError); ok { if slices.Contains(retryErrorCodes, apiErr.HttpCode) { fs.Debugf(nil, "Retrying API error %v", err) return true, err } } return fserrors.ShouldRetry(err), err } // readMetaDataForPath reads the metadata from the path func (f *Fs) readMetaDataForPath(ctx context.Context, path string) (info *files_sdk.File, err error) { params := files_sdk.FileFindParams{ Path: f.absPath(path), } var file files_sdk.File err = f.pacer.Call(func() (bool, error) { file, err = f.fileClient.Find(params, files_sdk.WithContext(ctx)) return shouldRetry(ctx, err) }) if err != nil { return nil, err } return &file, nil } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } root = strings.Trim(root, "/") config, err := newClientConfig(ctx, opt) if err != nil { return nil, err } f := &Fs{ name: name, root: root, opt: *opt, fileClient: &file.Client{Config: config}, folderClient: &folder.Client{Config: config}, migrationClient: &file_migration.Client{Config: config}, bundleClient: &bundle.Client{Config: config}, pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), } f.features = (&fs.Features{ CaseInsensitive: true, CanHaveEmptyDirectories: true, ReadMimeType: true, DirModTimeUpdatesOnWrite: true, }).Fill(ctx, f) if f.root != "" { info, err := f.readMetaDataForPath(ctx, "") if err == nil && !info.IsDir() { f.root = path.Dir(f.root) if f.root == "." { f.root = "" } return f, fs.ErrorIsFile } } return f, err } func newClientConfig(ctx context.Context, opt *Options) (config files_sdk.Config, err error) { if opt.Site != "" { if strings.Contains(opt.Site, ".") { config.EndpointOverride = opt.Site } else { config.Subdomain = opt.Site } _, err = url.ParseRequestURI(config.Endpoint()) if err != nil { err = fmt.Errorf("invalid domain or subdomain: %v", opt.Site) return } } config = config.Init().SetCustomClient(fshttp.NewClient(ctx)) if opt.APIKey != "" { config.APIKey = opt.APIKey return } if opt.Username == "" { err = errors.New("username not found") return } if opt.Password == "" { err = errors.New("password not found") return } opt.Password, err = obscure.Reveal(opt.Password) if err != nil { return } sessionClient := session.Client{Config: config} params := files_sdk.SessionCreateParams{ Username: opt.Username, Password: opt.Password, } thisSession, err := sessionClient.Create(params, files_sdk.WithContext(ctx)) if err != nil { err = fmt.Errorf("couldn't create session: %w", err) return } config.SessionId = thisSession.Id return } // Return an Object from a path // // If it can't be found it returns the error fs.ErrorObjectNotFound. func (f *Fs) newObjectWithInfo(ctx context.Context, remote string, file *files_sdk.File) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } var err error if file != nil { err = o.setMetaData(file) } else { err = o.readMetaData(ctx) // reads info and meta, returning an error } if err != nil { return nil, err } return o, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return f.newObjectWithInfo(ctx, remote, nil) } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { var it *folder.Iter params := files_sdk.FolderListForParams{ Path: f.absPath(dir), } err = f.pacer.Call(func() (bool, error) { it, err = f.folderClient.ListFor(params, files_sdk.WithContext(ctx)) return shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("couldn't list files: %w", err) } for it.Next() { item := ptr(it.File()) remote := f.opt.Enc.ToStandardPath(item.DisplayName) remote = path.Join(dir, remote) if remote == dir { continue } if item.IsDir() { d := fs.NewDir(remote, item.ModTime()) entries = append(entries, d) } else { o, err := f.newObjectWithInfo(ctx, remote, item) if err != nil { return nil, err } entries = append(entries, o) } } err = it.Err() if files_sdk.IsNotExist(err) { return nil, fs.ErrorDirNotFound } return } // Creates from the parameters passed in a half finished Object which // must have setMetaData called on it // // Returns the object and error. // // Used to create new objects func (f *Fs) createObject(ctx context.Context, remote string) (o *Object, err error) { // Create the directory for the object if it doesn't exist err = f.mkParentDir(ctx, remote) if err != nil { return } // Temporary Object under construction o = &Object{ fs: f, remote: remote, } return o, nil } // Put the object // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { // Temporary Object under construction fs := &Object{ fs: f, remote: src.Remote(), } return fs, fs.Update(ctx, in, src, options...) } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } func (f *Fs) mkdir(ctx context.Context, path string) error { if path == "" || path == "." { return nil } params := files_sdk.FolderCreateParams{ Path: path, MkdirParents: ptr(true), } err := f.pacer.Call(func() (bool, error) { _, err := f.folderClient.Create(params, files_sdk.WithContext(ctx)) return shouldRetry(ctx, err) }) if files_sdk.IsExist(err) { return nil } return err } // Make the parent directory of remote func (f *Fs) mkParentDir(ctx context.Context, remote string) error { return f.mkdir(ctx, path.Dir(f.absPath(remote))) } // Mkdir creates the container if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) error { return f.mkdir(ctx, f.absPath(dir)) } // DirSetModTime sets the directory modtime for dir func (f *Fs) DirSetModTime(ctx context.Context, dir string, modTime time.Time) error { o := Object{ fs: f, remote: dir, } return o.SetModTime(ctx, modTime) } // 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 { path := f.absPath(dir) if path == "" || path == "." { return errors.New("can't purge root directory") } params := files_sdk.FileDeleteParams{ Path: path, Recursive: ptr(!check), } err := f.pacer.Call(func() (bool, error) { err := f.fileClient.Delete(params, files_sdk.WithContext(ctx)) // Allow for eventual consistency deletion of child objects. if isFolderNotEmpty(err) { return true, err } return shouldRetry(ctx, err) }) if err != nil { if files_sdk.IsNotExist(err) { return fs.ErrorDirNotFound } else if isFolderNotEmpty(err) { return fs.ErrorDirectoryNotEmpty } return fmt.Errorf("rmdir failed: %w", err) } return nil } // Rmdir deletes the root folder // // Returns an error if it isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, true) } // Precision return the precision of this Fs func (f *Fs) Precision() time.Duration { return time.Second } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (dstObj fs.Object, err 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) if err != nil { return } srcPath := srcObj.fs.absPath(srcObj.remote) dstPath := f.absPath(remote) if strings.EqualFold(srcPath, dstPath) { return nil, fmt.Errorf("can't copy %q -> %q as are same name when lowercase", srcPath, dstPath) } // Create temporary object dstObj, err = f.createObject(ctx, remote) if err != nil { return } // Copy the object params := files_sdk.FileCopyParams{ Path: srcPath, Destination: dstPath, Overwrite: ptr(true), } var action files_sdk.FileAction err = f.pacer.Call(func() (bool, error) { action, err = f.fileClient.Copy(params, files_sdk.WithContext(ctx)) return shouldRetry(ctx, err) }) if err != nil { return } err = f.waitForAction(ctx, action, "copy") if err != nil { return } err = dstObj.SetModTime(ctx, srcObj.modTime) return } // Purge deletes all the files and the container // // Optional interface: Only implement this if you have a way of // deleting all the files quicker than just running Remove() on the // result of List() func (f *Fs) Purge(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, false) } // move a file or folder func (f *Fs) move(ctx context.Context, src *Fs, srcRemote string, dstRemote string) (info *files_sdk.File, err error) { // Move the object params := files_sdk.FileMoveParams{ Path: src.absPath(srcRemote), Destination: f.absPath(dstRemote), } var action files_sdk.FileAction err = f.pacer.Call(func() (bool, error) { action, err = f.fileClient.Move(params, files_sdk.WithContext(ctx)) return shouldRetry(ctx, err) }) if err != nil { return nil, err } err = f.waitForAction(ctx, action, "move") if err != nil { return nil, err } info, err = f.readMetaDataForPath(ctx, dstRemote) return } func (f *Fs) waitForAction(ctx context.Context, action files_sdk.FileAction, operation string) (err error) { var migration files_sdk.FileMigration err = f.pacer.Call(func() (bool, error) { migration, err = f.migrationClient.Wait(action, func(migration files_sdk.FileMigration) { // noop }, files_sdk.WithContext(ctx)) return shouldRetry(ctx, err) }) if err == nil && migration.Status != "completed" { return fmt.Errorf("%v did not complete successfully: %v", operation, migration.Status) } return } // Move src to this remote using server-side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't move - not same remote type") return nil, fs.ErrorCantMove } // Create temporary object dstObj, err := f.createObject(ctx, remote) if err != nil { return nil, err } // Do the move info, err := f.move(ctx, srcObj.fs, srcObj.remote, dstObj.remote) if err != nil { return nil, err } err = dstObj.setMetaData(info) if err != nil { return nil, err } return dstObj, nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) (err error) { srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } // Check if destination exists _, err = f.readMetaDataForPath(ctx, dstRemote) if err == nil { return fs.ErrorDirExists } // Create temporary object dstObj, err := f.createObject(ctx, dstRemote) if err != nil { return } // Do the move _, err = f.move(ctx, srcFs, srcRemote, dstObj.remote) return } // PublicLink adds a "readable by anyone with link" permission on the given file or folder. func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (url string, err error) { params := files_sdk.BundleCreateParams{ Paths: []string{f.absPath(remote)}, } if expire < fs.DurationOff { params.ExpiresAt = ptr(time.Now().Add(time.Duration(expire))) } var bundle files_sdk.Bundle err = f.pacer.Call(func() (bool, error) { bundle, err = f.bundleClient.Create(params, files_sdk.WithContext(ctx)) return shouldRetry(ctx, err) }) url = bundle.Url return } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.NewHashSet(hash.CRC32, hash.MD5) } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Hash returns the MD5 of an object returning a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { switch t { case hash.CRC32: if o.crc32 == "" { return "", nil } return fmt.Sprintf("%08s", o.crc32), nil case hash.MD5: return o.md5, nil } return "", hash.ErrUnsupported } // Size returns the size of an object in bytes func (o *Object) Size() int64 { return o.size } // setMetaData sets the metadata from info func (o *Object) setMetaData(file *files_sdk.File) error { o.modTime = file.ModTime() if !file.IsDir() { o.size = file.Size o.crc32 = file.Crc32 o.md5 = file.Md5 o.mimeType = file.MimeType } return nil } // readMetaData gets the metadata if it hasn't already been fetched // // it also sets the info func (o *Object) readMetaData(ctx context.Context) (err error) { file, err := o.fs.readMetaDataForPath(ctx, o.remote) if err != nil { if files_sdk.IsNotExist(err) { return fs.ErrorObjectNotFound } return err } if file.IsDir() { return fs.ErrorIsDir } return o.setMetaData(file) } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers func (o *Object) ModTime(ctx context.Context) time.Time { return o.modTime } // SetModTime sets the modification time of the local fs object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) (err error) { params := files_sdk.FileUpdateParams{ Path: o.fs.absPath(o.remote), ProvidedMtime: &modTime, } var file files_sdk.File err = o.fs.pacer.Call(func() (bool, error) { file, err = o.fs.fileClient.Update(params, files_sdk.WithContext(ctx)) return shouldRetry(ctx, err) }) if err != nil { return err } return o.setMetaData(&file) } // Storable returns a boolean showing whether this object storable func (o *Object) Storable() bool { return true } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { // Offset and Count for range download var offset, count int64 fs.FixRangeOption(options, o.size) for _, option := range options { switch x := option.(type) { case *fs.RangeOption: offset, count = x.Decode(o.size) if count < 0 { count = o.size - offset } case *fs.SeekOption: offset = x.Offset count = o.size - offset default: if option.Mandatory() { fs.Logf(o, "Unsupported mandatory option: %v", option) } } } params := files_sdk.FileDownloadParams{ Path: o.fs.absPath(o.remote), } headers := &http.Header{} headers.Set("Range", fmt.Sprintf("bytes=%v-%v", offset, offset+count-1)) err = o.fs.pacer.Call(func() (bool, error) { _, err = o.fs.fileClient.Download( params, files_sdk.WithContext(ctx), files_sdk.RequestHeadersOption(headers), files_sdk.ResponseBodyOption(func(closer io.ReadCloser) error { in = closer return err }), ) return shouldRetry(ctx, err) }) return } // Returns a pointer to t - useful for returning pointers to constants func ptr[T any](t T) *T { return &t } func isFolderNotEmpty(err error) bool { var re files_sdk.ResponseError ok := errors.As(err, &re) return ok && re.Type == folderNotEmpty } // Update the object with the contents of the io.Reader, modTime and size // // If existing is set then it updates the object rather than creating a new one. // // The new object may have been created if an error is returned. func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { uploadOpts := []file.UploadOption{ file.UploadWithContext(ctx), file.UploadWithReader(in), file.UploadWithDestinationPath(o.fs.absPath(o.remote)), file.UploadWithProvidedMtime(src.ModTime(ctx)), } err := o.fs.pacer.Call(func() (bool, error) { err := o.fs.fileClient.Upload(uploadOpts...) return shouldRetry(ctx, err) }) if err != nil { return err } return o.readMetaData(ctx) } // Remove an object func (o *Object) Remove(ctx context.Context) error { params := files_sdk.FileDeleteParams{ Path: o.fs.absPath(o.remote), } return o.fs.pacer.Call(func() (bool, error) { err := o.fs.fileClient.Delete(params, files_sdk.WithContext(ctx)) return shouldRetry(ctx, err) }) } // MimeType of an Object if known, "" otherwise func (o *Object) MimeType(ctx context.Context) string { return o.mimeType } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.PublicLinker = (*Fs)(nil) _ fs.Object = (*Object)(nil) _ fs.MimeTyper = (*Object)(nil) ) rclone-v1.71.0/backend/filescom/filescom_test.go000066400000000000000000000005661505210326400216340ustar00rootroot00000000000000// Test Files filesystem interface package filescom_test import ( "testing" "github.com/rclone/rclone/backend/filescom" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestFilesCom:", NilObject: (*filescom.Object)(nil), }) } rclone-v1.71.0/backend/ftp/000077500000000000000000000000001505210326400154265ustar00rootroot00000000000000rclone-v1.71.0/backend/ftp/ftp.go000066400000000000000000001174041505210326400165550ustar00rootroot00000000000000// Package ftp interfaces with FTP servers package ftp import ( "context" "crypto/tls" "errors" "fmt" "io" "net" "net/textproto" "net/url" "path" "runtime" "strings" "sync" "time" "github.com/jlaffaye/ftp" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/env" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/proxy" "github.com/rclone/rclone/lib/readers" ) var ( currentUser = env.CurrentUser() ) const ( minSleep = 10 * time.Millisecond maxSleep = 2 * time.Second decayConstant = 2 // bigger for slower decay, exponential ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "ftp", Description: "FTP", NewFs: NewFs, Options: []fs.Option{{ Name: "host", Help: "FTP host to connect to.\n\nE.g. \"ftp.example.com\".", Required: true, Sensitive: true, }, { Name: "user", Help: "FTP username.", Default: currentUser, Sensitive: true, }, { Name: "port", Help: "FTP port number.", Default: 21, }, { Name: "pass", Help: "FTP password.", IsPassword: true, }, { Name: "tls", Help: `Use Implicit FTPS (FTP over TLS). When using implicit FTP over TLS the client connects using TLS right from the start which breaks compatibility with non-TLS-aware servers. This is usually served over port 990 rather than port 21. Cannot be used in combination with explicit FTPS.`, Default: false, }, { Name: "explicit_tls", Help: `Use Explicit FTPS (FTP over TLS). When using explicit FTP over TLS the client explicitly requests security from the server in order to upgrade a plain text connection to an encrypted one. Cannot be used in combination with implicit FTPS.`, Default: false, }, { Name: "concurrency", Help: strings.ReplaceAll(`Maximum number of FTP simultaneous connections, 0 for unlimited. Note that setting this is very likely to cause deadlocks so it should be used with care. If you are doing a sync or copy then make sure concurrency is one more than the sum of |--transfers| and |--checkers|. If you use |--check-first| then it just needs to be one more than the maximum of |--checkers| and |--transfers|. So for |concurrency 3| you'd use |--checkers 2 --transfers 2 --check-first| or |--checkers 1 --transfers 1|. `, "|", "`"), Default: 0, Advanced: true, }, { Name: "no_check_certificate", Help: "Do not verify the TLS certificate of the server.", Default: false, Advanced: true, }, { Name: "disable_epsv", Help: "Disable using EPSV even if server advertises support.", Default: false, Advanced: true, }, { Name: "disable_mlsd", Help: "Disable using MLSD even if server advertises support.", Default: false, Advanced: true, }, { Name: "disable_utf8", Help: "Disable using UTF-8 even if server advertises support.", Default: false, Advanced: true, }, { Name: "writing_mdtm", Help: "Use MDTM to set modification time (VsFtpd quirk)", Default: false, Advanced: true, }, { Name: "force_list_hidden", Help: "Use LIST -a to force listing of hidden files and folders. This will disable the use of MLSD.", Default: false, Advanced: true, }, { Name: "idle_timeout", Default: fs.Duration(60 * time.Second), Help: `Max time before closing idle connections. If no connections have been returned to the connection pool in the time given, rclone will empty the connection pool. Set to 0 to keep connections indefinitely. `, Advanced: true, }, { Name: "close_timeout", Help: "Maximum time to wait for a response to close.", Default: fs.Duration(60 * time.Second), Advanced: true, }, { Name: "tls_cache_size", Help: `Size of TLS session cache for all control and data connections. TLS cache allows to resume TLS sessions and reuse PSK between connections. Increase if default size is not enough resulting in TLS resumption errors. Enabled by default. Use 0 to disable.`, Default: 32, Advanced: true, }, { Name: "disable_tls13", 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.", Default: fs.Duration(60 * time.Second), Advanced: true, }, { Name: "ask_password", Default: false, Help: `Allow asking for FTP password when needed. If this is set and no password is supplied then rclone will ask for a password `, Advanced: true, }, { Name: "socks_proxy", Default: "", Help: `Socks 5 proxy host. Supports the format user:pass@host:port, user@host:port, host:port. Example: myUser:myPass@localhost:9005 `, Advanced: true, }, { Name: "http_proxy", Default: "", Help: `URL for HTTP CONNECT proxy Set this to a URL for an HTTP proxy which supports the HTTP CONNECT verb. `, Advanced: true, }, { Name: "no_check_upload", Default: false, Help: `Don't check the upload is OK Normally rclone will try to check the upload exists after it has uploaded a file to make sure the size and modification time are as expected. This flag stops rclone doing these checks. This enables uploading to folders which are write only. You will likely need to use the --inplace flag also if uploading to a write only folder. `, Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, // The FTP protocol can't handle trailing spaces // (for instance, pureftpd turns them into '_') Default: (encoder.Display | encoder.EncodeRightSpace), Examples: []fs.OptionExample{{ Value: "Asterisk,Ctl,Dot,Slash", Help: "ProFTPd can't handle '*' in file names", }, { Value: "BackSlash,Ctl,Del,Dot,RightSpace,Slash,SquareBracket", Help: "PureFTPd can't handle '[]' or '*' in file names", }, { Value: "Ctl,LeftPeriod,Slash", Help: "VsFTPd can't handle file names starting with dot", }}, }}, }) } // 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"` } // Fs represents a remote FTP server type Fs struct { name string // name of this remote root string // the path we are working on if any opt Options // parsed options ci *fs.ConfigInfo // global config features *fs.Features // optional features url string user string pass string dialAddr string tlsConf *tls.Config // default TLS client config poolMu sync.Mutex pool []*ftp.ServerConn drain *time.Timer // used to drain the pool when we stop using the connections tokens *pacer.TokenDispenser proxyURL *url.URL // address of HTTP proxy read from environment pacer *fs.Pacer // pacer for FTP connections fGetTime bool // true if the ftp library accepts GetTime fSetTime bool // true if the ftp library accepts SetTime fLstTime bool // true if the List call returns precise time } // Object describes an FTP file type Object struct { fs *Fs remote string info *FileInfo } // FileInfo is the metadata known about an FTP file type FileInfo struct { Name string Size uint64 ModTime time.Time precise bool // true if the time is precise IsDir bool } // ------------------------------------------------------------ // Name of this fs func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String returns a description of the FS func (f *Fs) String() string { return f.url } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // Enable debugging output type debugLog struct { mu sync.Mutex auth bool } // Write writes len(p) bytes from p to the underlying data stream. It returns // the number of bytes written from p (0 <= n <= len(p)) and any error // encountered that caused the write to stop early. Write must return a non-nil // error if it returns n < len(p). Write must not modify the slice data, even // temporarily. // // Implementations must not retain p. // // This writes debug info to the log func (dl *debugLog) Write(p []byte) (n int, err error) { dl.mu.Lock() defer dl.mu.Unlock() _, file, _, ok := runtime.Caller(1) direction := "FTP Rx" if ok && strings.Contains(file, "multi") { direction = "FTP Tx" } lines := strings.Split(string(p), "\r\n") if lines[len(lines)-1] == "" { lines = lines[:len(lines)-1] } for _, line := range lines { if !dl.auth && strings.HasPrefix(line, "PASS") { fs.Debugf(direction, "PASS *****") continue } fs.Debugf(direction, "%q", line) } return len(p), nil } // Return a *textproto.Error if err contains one or nil otherwise func textprotoError(err error) (errX *textproto.Error) { if errors.As(err, &errX) { return errX } return nil } // returns true if this FTP error should be retried func isRetriableFtpError(err error) bool { if errX := textprotoError(err); errX != nil { switch errX.Code { case ftp.StatusNotAvailable, ftp.StatusTransfertAborted: return true } } return false } // shouldRetry returns a boolean as to whether this err deserve to be // retried. It returns the err as a convenience func shouldRetry(ctx context.Context, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } if isRetriableFtpError(err) { return true, err } return fserrors.ShouldRetry(err), err } // Get a TLS config with a unique session cache. // // We can't share session caches between connections. // // See: https://github.com/rclone/rclone/issues/7234 func (f *Fs) tlsConfig() *tls.Config { var tlsConfig *tls.Config if f.opt.TLS || f.opt.ExplicitTLS { if f.tlsConf != nil { tlsConfig = f.tlsConf.Clone() } else { tlsConfig = new(tls.Config) } tlsConfig.ServerName = f.opt.Host if f.opt.SkipVerifyTLSCert { tlsConfig.InsecureSkipVerify = true } if f.opt.TLSCacheSize > 0 { tlsConfig.ClientSessionCache = tls.NewLRUClientSessionCache(f.opt.TLSCacheSize) } 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 } // Open a new connection to the FTP server. func (f *Fs) ftpConnection(ctx context.Context) (c *ftp.ServerConn, err error) { fs.Debugf(f, "Connecting to FTP server") // tls.Config for this connection only. Will be used for data // and control connections. tlsConfig := f.tlsConfig() // Make ftp library dial with fshttp dialer optionally using TLS initialConnection := true dial := func(network, address string) (conn net.Conn, err error) { fs.Debugf(f, "dial(%q,%q)", network, address) defer func() { if err != nil { fs.Debugf(f, "> dial: conn=%v, err=%v", conn, err) } else { fs.Debugf(f, "> dial: conn=%s->%s, err=%v", conn.LocalAddr(), conn.RemoteAddr(), err) } }() baseDialer := fshttp.NewDialer(ctx) if f.opt.SocksProxy != "" { conn, err = proxy.SOCKS5Dial(network, address, f.opt.SocksProxy, baseDialer) } else if f.proxyURL != nil { // We need to make the onward connection to f.opt.Host. However the FTP // library sets the host to the proxy IP after using EPSV or PASV so we need // to correct that here. var dialPort string _, dialPort, err = net.SplitHostPort(address) if err != nil { return nil, err } dialAddress := net.JoinHostPort(f.opt.Host, dialPort) conn, err = proxy.HTTPConnectDial(network, dialAddress, f.proxyURL, baseDialer) } else { conn, err = baseDialer.Dial(network, address) } if err != nil { return nil, err } // Connect using cleartext only for non TLS if tlsConfig == nil { return conn, nil } // Initial connection only needs to be cleartext for explicit TLS if f.opt.ExplicitTLS && initialConnection { initialConnection = false return conn, nil } // Upgrade connection to TLS tlsConn := tls.Client(conn, tlsConfig) // Do the initial handshake - tls.Client doesn't do it for us // If we do this then connections to proftpd/pureftpd lock up // See: https://github.com/rclone/rclone/issues/6426 // See: https://github.com/jlaffaye/ftp/issues/282 if false { err = tlsConn.HandshakeContext(ctx) if err != nil { _ = conn.Close() return nil, err } } return tlsConn, nil } ftpConfig := []ftp.DialOption{ ftp.DialWithContext(ctx), ftp.DialWithDialFunc(dial), } if f.opt.TLS { // Our dialer takes care of TLS but ftp library also needs tlsConf // as a trigger for sending PSBZ and PROT options to server. ftpConfig = append(ftpConfig, ftp.DialWithTLS(tlsConfig)) } else if f.opt.ExplicitTLS { ftpConfig = append(ftpConfig, ftp.DialWithExplicitTLS(tlsConfig)) } if f.opt.DisableEPSV { ftpConfig = append(ftpConfig, ftp.DialWithDisabledEPSV(true)) } if f.opt.DisableMLSD { ftpConfig = append(ftpConfig, ftp.DialWithDisabledMLSD(true)) } if f.opt.DisableUTF8 { ftpConfig = append(ftpConfig, ftp.DialWithDisabledUTF8(true)) } if f.opt.ShutTimeout != 0 && f.opt.ShutTimeout != fs.DurationOff { ftpConfig = append(ftpConfig, ftp.DialWithShutTimeout(time.Duration(f.opt.ShutTimeout))) } if f.opt.WritingMDTM { ftpConfig = append(ftpConfig, ftp.DialWithWritingMDTM(true)) } if f.opt.ForceListHidden { ftpConfig = append(ftpConfig, ftp.DialWithForceListHidden(true)) } if f.ci.Dump&(fs.DumpHeaders|fs.DumpBodies|fs.DumpRequests|fs.DumpResponses) != 0 { ftpConfig = append(ftpConfig, ftp.DialWithDebugOutput(&debugLog{auth: f.ci.Dump&fs.DumpAuth != 0})) } err = f.pacer.Call(func() (bool, error) { c, err = ftp.Dial(f.dialAddr, ftpConfig...) if err != nil { return shouldRetry(ctx, err) } err = c.Login(f.user, f.pass) if err != nil { _ = c.Quit() return shouldRetry(ctx, err) } return false, nil }) if err != nil { err = fmt.Errorf("failed to make FTP connection to %q: %w", f.dialAddr, err) } return c, err } // Get an FTP connection from the pool, or open a new one func (f *Fs) getFtpConnection(ctx context.Context) (c *ftp.ServerConn, err error) { if f.opt.Concurrency > 0 { f.tokens.Get() } accounting.LimitTPS(ctx) f.poolMu.Lock() if len(f.pool) > 0 { c = f.pool[0] f.pool = f.pool[1:] } f.poolMu.Unlock() if c != nil { return c, nil } c, err = f.ftpConnection(ctx) if err != nil && f.opt.Concurrency > 0 { f.tokens.Put() } return c, err } // Return an FTP connection to the pool // // It nils the pointed to connection out so it can't be reused // // if err is not nil then it checks the connection is alive using a // NOOP request func (f *Fs) putFtpConnection(pc **ftp.ServerConn, err error) { if f.opt.Concurrency > 0 { defer f.tokens.Put() } if pc == nil { return } c := *pc if c == nil { return } *pc = nil if err != nil { // If not a regular FTP error code then check the connection if tpErr := textprotoError(err); tpErr != nil { nopErr := c.NoOp() if nopErr != nil { fs.Debugf(f, "Connection failed, closing: %v", nopErr) _ = c.Quit() return } } } f.poolMu.Lock() f.pool = append(f.pool, c) if f.opt.IdleTimeout > 0 { f.drain.Reset(time.Duration(f.opt.IdleTimeout)) // nudge on the pool emptying timer } f.poolMu.Unlock() } // Drain the pool of any connections func (f *Fs) drainPool(ctx context.Context) (err error) { f.poolMu.Lock() defer f.poolMu.Unlock() if f.opt.IdleTimeout > 0 { f.drain.Stop() } if len(f.pool) != 0 { fs.Debugf(f, "closing %d unused connections", len(f.pool)) } for i, c := range f.pool { if cErr := c.Quit(); cErr != nil { err = cErr } f.pool[i] = nil } f.pool = nil return err } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (ff fs.Fs, err error) { // defer fs.Trace(nil, "name=%q, root=%q", name, root)("fs=%v, err=%v", &ff, &err) // Parse config into Options struct opt := new(Options) err = configstruct.Set(m, opt) if err != nil { return nil, err } pass := "" if opt.AskPassword && opt.Pass == "" { pass = config.GetPassword("FTP server password") } else { pass, err = obscure.Reveal(opt.Pass) if err != nil { return nil, fmt.Errorf("NewFS decrypt password: %w", err) } } user := opt.User if user == "" { user = currentUser } port := opt.Port if port == "" { port = "21" } dialAddr := opt.Host + ":" + port protocol := "ftp://" if opt.TLS { protocol = "ftps://" } if opt.TLS && opt.ExplicitTLS { return nil, errors.New("implicit TLS and explicit TLS are mutually incompatible, please revise your config") } u := protocol + path.Join(dialAddr+"/", root) ci := fs.GetConfig(ctx) f := &Fs{ name: name, root: root, opt: *opt, ci: ci, url: u, user: user, pass: pass, dialAddr: dialAddr, tokens: pacer.NewTokenDispenser(opt.Concurrency), pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), tlsConf: fshttp.NewTransport(ctx).TLSClientConfig, } f.features = (&fs.Features{ CanHaveEmptyDirectories: true, PartialUploads: true, }).Fill(ctx, f) // get proxy URL if set if opt.HTTPProxy != "" { proxyURL, err := url.Parse(opt.HTTPProxy) if err != nil { return nil, fmt.Errorf("failed to parse HTTP Proxy URL: %w", err) } f.proxyURL = proxyURL } // set the pool drainer timer going if f.opt.IdleTimeout > 0 { f.drain = time.AfterFunc(time.Duration(opt.IdleTimeout), func() { _ = f.drainPool(ctx) }) } // Make a connection and pool it to return errors early c, err := f.getFtpConnection(ctx) if err != nil { return nil, fmt.Errorf("NewFs: %w", err) } f.fGetTime = c.IsGetTimeSupported() f.fSetTime = c.IsSetTimeSupported() f.fLstTime = c.IsTimePreciseInList() if !f.fLstTime && f.fGetTime { f.features.SlowModTime = true } f.putFtpConnection(&c, nil) if root != "" { // Check to see if the root actually an existing file remote := path.Base(root) f.root = path.Dir(root) if f.root == "." { f.root = "" } _, err := f.NewObject(ctx, remote) if err != nil { if err == fs.ErrorObjectNotFound || errors.Is(err, fs.ErrorNotAFile) { // File doesn't exist so return old f f.root = root return f, nil } return nil, err } // return an error with an fs which points to the parent return f, fs.ErrorIsFile } return f, err } // Shutdown the backend, closing any background tasks and any // cached connections. func (f *Fs) Shutdown(ctx context.Context) error { return f.drainPool(ctx) } // translateErrorFile turns FTP errors into rclone errors if possible for a file func translateErrorFile(err error) error { if errX := textprotoError(err); errX != nil { switch errX.Code { case ftp.StatusFileUnavailable, ftp.StatusFileActionIgnored: err = fs.ErrorObjectNotFound } } return err } // translateErrorDir turns FTP errors into rclone errors if possible for a directory func translateErrorDir(err error) error { if errX := textprotoError(err); errX != nil { switch errX.Code { case ftp.StatusFileUnavailable, ftp.StatusFileActionIgnored: err = fs.ErrorDirNotFound } } return err } // entryToStandard converts an incoming ftp.Entry to Standard encoding func (f *Fs) entryToStandard(entry *ftp.Entry) { // Skip . and .. as we don't want these encoded if entry.Name == "." || entry.Name == ".." { return } entry.Name = f.opt.Enc.ToStandardName(entry.Name) entry.Target = f.opt.Enc.ToStandardPath(entry.Target) } // dirFromStandardPath returns dir in encoded form. func (f *Fs) dirFromStandardPath(dir string) string { // Skip . and .. as we don't want these encoded if dir == "." || dir == ".." { return dir } return f.opt.Enc.FromStandardPath(dir) } // findItem finds a directory entry for the name in its parent directory func (f *Fs) findItem(ctx context.Context, remote string) (entry *ftp.Entry, err error) { // defer fs.Trace(remote, "")("o=%v, err=%v", &o, &err) if remote == "" || remote == "." || remote == "/" { // if root, assume exists and synthesize an entry return &ftp.Entry{ Name: "", Type: ftp.EntryTypeFolder, Time: time.Now(), }, nil } c, err := f.getFtpConnection(ctx) if err != nil { return nil, fmt.Errorf("findItem: %w", err) } // returns TRUE if MLST is supported which is required to call GetEntry if c.IsTimePreciseInList() { entry, err := c.GetEntry(f.opt.Enc.FromStandardPath(remote)) f.putFtpConnection(&c, err) if err != nil { err = translateErrorFile(err) if err == fs.ErrorObjectNotFound { return nil, nil } if errX := textprotoError(err); errX != nil { switch errX.Code { case ftp.StatusBadArguments: err = nil } } return nil, err } if entry != nil { f.entryToStandard(entry) } return entry, nil } dir := path.Dir(remote) base := path.Base(remote) files, err := c.List(f.dirFromStandardPath(dir)) f.putFtpConnection(&c, err) if err != nil { return nil, translateErrorFile(err) } for _, file := range files { f.entryToStandard(file) if file.Name == base { return file, nil } } return nil, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (o fs.Object, err error) { // defer fs.Trace(remote, "")("o=%v, err=%v", &o, &err) entry, err := f.findItem(ctx, path.Join(f.root, remote)) if err != nil { return nil, err } if entry != nil && entry.Type != ftp.EntryTypeFolder { o := &Object{ fs: f, remote: remote, } o.info = &FileInfo{ Name: remote, Size: entry.Size, ModTime: entry.Time, precise: f.fLstTime, } return o, nil } return nil, fs.ErrorObjectNotFound } // dirExists checks the directory pointed to by remote exists or not func (f *Fs) dirExists(ctx context.Context, remote string) (exists bool, err error) { entry, err := f.findItem(ctx, path.Join(f.root, remote)) if err != nil { return false, fmt.Errorf("dirExists: %w", err) } if entry != nil && entry.Type == ftp.EntryTypeFolder { return true, nil } return false, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { // defer log.Trace(dir, "dir=%q", dir)("entries=%v, err=%v", &entries, &err) c, err := f.getFtpConnection(ctx) if err != nil { return nil, fmt.Errorf("list: %w", err) } var listErr error var files []*ftp.Entry resultchan := make(chan []*ftp.Entry, 1) errchan := make(chan error, 1) go func() { result, err := c.List(f.dirFromStandardPath(path.Join(f.root, dir))) f.putFtpConnection(&c, err) if err != nil { errchan <- err return } resultchan <- result }() // Wait for List for up to Timeout seconds timer := time.NewTimer(f.ci.TimeoutOrInfinite()) select { case listErr = <-errchan: timer.Stop() return nil, translateErrorDir(listErr) case files = <-resultchan: timer.Stop() case <-timer.C: // if timer fired assume no error but connection dead fs.Errorf(f, "Timeout when waiting for List") return nil, errors.New("timeout when waiting for List") } // Annoyingly FTP returns success for a directory which // doesn't exist, so check it really doesn't exist if no // entries found. if len(files) == 0 { exists, err := f.dirExists(ctx, dir) if err != nil { return nil, fmt.Errorf("list: %w", err) } if !exists { return nil, fs.ErrorDirNotFound } } for i := range files { object := files[i] f.entryToStandard(object) newremote := path.Join(dir, object.Name) switch object.Type { case ftp.EntryTypeFolder: if object.Name == "." || object.Name == ".." { continue } d := fs.NewDir(newremote, object.Time) entries = append(entries, d) default: o := &Object{ fs: f, remote: newremote, } info := &FileInfo{ Name: newremote, Size: object.Size, ModTime: object.Time, precise: f.fLstTime, } o.info = info entries = append(entries, o) } } return entries, nil } // Hashes are not supported func (f *Fs) Hashes() hash.Set { return 0 } // Precision shows whether modified time is supported or not depending on the // FTP server capabilities, namely whether FTP server: // - accepts the MDTM command to get file time (fGetTime) // or supports MLSD returning precise file time in the list (fLstTime) // - accepts the MFMT command to set file time (fSetTime) // or non-standard form of the MDTM command (fSetTime, too) // used by VsFtpd for the same purpose (WritingMDTM) // // See "mdtm_write" in https://security.appspot.com/vsftpd/vsftpd_conf.html func (f *Fs) Precision() time.Duration { if (f.fGetTime || f.fLstTime) && f.fSetTime { return time.Second } return fs.ModTimeNotSupported } // Put in to the remote path with the modTime given of the given size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { // fs.Debugf(f, "Trying to put file %s", src.Remote()) err := f.mkParentDir(ctx, src.Remote()) if err != nil { return nil, fmt.Errorf("Put mkParentDir failed: %w", err) } o := &Object{ fs: f, remote: src.Remote(), } err = o.Update(ctx, in, src, options...) return o, err } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } // getInfo reads the FileInfo for a path func (f *Fs) getInfo(ctx context.Context, remote string) (fi *FileInfo, err error) { // defer fs.Trace(remote, "")("fi=%v, err=%v", &fi, &err) file, err := f.findItem(ctx, remote) if err != nil { return nil, err } else if file != nil { info := &FileInfo{ Name: remote, Size: file.Size, ModTime: file.Time, precise: f.fLstTime, IsDir: file.Type == ftp.EntryTypeFolder, } return info, nil } return nil, fs.ErrorObjectNotFound } // mkdir makes the directory and parents using unrooted paths func (f *Fs) mkdir(ctx context.Context, abspath string) error { abspath = path.Clean(abspath) if abspath == "." || abspath == "/" { return nil } fi, err := f.getInfo(ctx, abspath) if err == nil { if fi.IsDir { return nil } return fs.ErrorIsFile } else if err != fs.ErrorObjectNotFound { return fmt.Errorf("mkdir %q failed: %w", abspath, err) } parent := path.Dir(abspath) err = f.mkdir(ctx, parent) if err != nil { return err } c, connErr := f.getFtpConnection(ctx) if connErr != nil { return fmt.Errorf("mkdir: %w", connErr) } err = c.MakeDir(f.dirFromStandardPath(abspath)) f.putFtpConnection(&c, err) if errX := textprotoError(err); errX != nil { switch errX.Code { case ftp.StatusRequestedFileActionOK: // some ftp servers apparently return 250 instead of 257 err = nil // see: https://forum.rclone.org/t/rclone-pop-up-an-i-o-error-when-creating-a-folder-in-a-mounted-ftp-drive/44368/ case ftp.StatusFileUnavailable: // dir already exists: see issue #2181 err = nil case 521: // dir already exists: error number according to RFC 959: issue #2363 err = nil } } return err } // mkParentDir makes the parent of remote if necessary and any // directories above that func (f *Fs) mkParentDir(ctx context.Context, remote string) error { parent := path.Dir(remote) return f.mkdir(ctx, path.Join(f.root, parent)) } // Mkdir creates the directory if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) (err error) { // defer fs.Trace(dir, "")("err=%v", &err) root := path.Join(f.root, dir) return f.mkdir(ctx, root) } // Rmdir removes the directory (container, bucket) if empty // // Return an error if it doesn't exist or isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { c, err := f.getFtpConnection(ctx) if err != nil { return fmt.Errorf("Rmdir: %w", translateErrorFile(err)) } err = c.RemoveDir(f.dirFromStandardPath(path.Join(f.root, dir))) f.putFtpConnection(&c, err) return translateErrorDir(err) } // Move renames a remote file object 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 := f.mkParentDir(ctx, remote) if err != nil { return nil, fmt.Errorf("Move mkParentDir failed: %w", err) } c, err := f.getFtpConnection(ctx) if err != nil { return nil, fmt.Errorf("Move: %w", err) } err = c.Rename( f.opt.Enc.FromStandardPath(path.Join(srcObj.fs.root, srcObj.remote)), f.opt.Enc.FromStandardPath(path.Join(f.root, remote)), ) f.putFtpConnection(&c, err) if err != nil { return nil, fmt.Errorf("Move Rename failed: %w", err) } dstObj, err := f.NewObject(ctx, remote) if err != nil { return nil, fmt.Errorf("Move NewObject failed: %w", err) } return dstObj, nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } srcPath := path.Join(srcFs.root, srcRemote) dstPath := path.Join(f.root, dstRemote) // Check if destination exists fi, err := f.getInfo(ctx, dstPath) if err == nil { if fi.IsDir { return fs.ErrorDirExists } return fs.ErrorIsFile } else if err != fs.ErrorObjectNotFound { return fmt.Errorf("DirMove getInfo failed: %w", err) } // Make sure the parent directory exists err = f.mkdir(ctx, path.Dir(dstPath)) if err != nil { return fmt.Errorf("DirMove mkParentDir dst failed: %w", err) } // Do the move c, err := f.getFtpConnection(ctx) if err != nil { return fmt.Errorf("DirMove: %w", err) } err = c.Rename( f.dirFromStandardPath(srcPath), f.dirFromStandardPath(dstPath), ) f.putFtpConnection(&c, err) if err != nil { return fmt.Errorf("DirMove Rename(%q,%q) failed: %w", srcPath, dstPath, err) } return nil } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // String version of o func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Hash returns the hash of an object returning a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { return "", hash.ErrUnsupported } // Size returns the size of an object in bytes func (o *Object) Size() int64 { return int64(o.info.Size) } // ModTime returns the modification time of the object func (o *Object) ModTime(ctx context.Context) time.Time { if !o.info.precise && o.fs.fGetTime { c, err := o.fs.getFtpConnection(ctx) if err == nil { path := path.Join(o.fs.root, o.remote) path = o.fs.opt.Enc.FromStandardPath(path) modTime, err := c.GetTime(path) if err == nil && o.info != nil { o.info.ModTime = modTime o.info.precise = true } o.fs.putFtpConnection(&c, err) } } return o.info.ModTime } // SetModTime sets the modification time of the object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { if !o.fs.fSetTime { fs.Debugf(o.fs, "SetModTime is not supported") return nil } c, err := o.fs.getFtpConnection(ctx) if err != nil { return err } path := path.Join(o.fs.root, o.remote) path = o.fs.opt.Enc.FromStandardPath(path) err = c.SetTime(path, modTime.In(time.UTC)) if err == nil && o.info != nil { o.info.ModTime = modTime o.info.precise = true } o.fs.putFtpConnection(&c, err) return err } // Storable returns a boolean as to whether this object is storable func (o *Object) Storable() bool { return true } // ftpReadCloser implements io.ReadCloser for FTP objects. type ftpReadCloser struct { rc io.ReadCloser c *ftp.ServerConn f *Fs err error // errors found during read } // Read bytes into p func (f *ftpReadCloser) Read(p []byte) (n int, err error) { n, err = f.rc.Read(p) if err != nil && err != io.EOF { f.err = err // store any errors for Close to examine } return } // Close the FTP reader and return the connection to the pool func (f *ftpReadCloser) Close() error { var err error errchan := make(chan error, 1) go func() { errchan <- f.rc.Close() }() // Wait for Close for up to 60 seconds by default closeTimeout := f.f.opt.CloseTimeout if closeTimeout == 0 { closeTimeout = fs.DurationOff } timer := time.NewTimer(time.Duration(closeTimeout)) select { case err = <-errchan: timer.Stop() case <-timer.C: // if timer fired assume no error but connection dead fs.Errorf(f.f, "Timeout when waiting for connection Close") f.f.putFtpConnection(nil, nil) return nil } // if errors while reading or closing, dump the connection if err != nil || f.err != nil { _ = f.c.Quit() f.f.putFtpConnection(nil, nil) } else { f.f.putFtpConnection(&f.c, nil) } // mask the error if it was caused by a premature close // NB StatusAboutToSend is to work around a bug in pureftpd // See: https://github.com/rclone/rclone/issues/3445#issuecomment-521654257 if errX := textprotoError(err); errX != nil { switch errX.Code { case ftp.StatusTransfertAborted, ftp.StatusFileUnavailable, ftp.StatusAboutToSend: err = nil } } return err } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (rc io.ReadCloser, err error) { // defer fs.Trace(o, "")("rc=%v, err=%v", &rc, &err) path := path.Join(o.fs.root, o.remote) var offset, limit int64 = 0, -1 for _, option := range options { switch x := option.(type) { case *fs.SeekOption: offset = x.Offset case *fs.RangeOption: offset, limit = x.Decode(o.Size()) default: if option.Mandatory() { fs.Logf(o, "Unsupported mandatory option: %v", option) } } } var ( fd *ftp.Response c *ftp.ServerConn ) err = o.fs.pacer.Call(func() (bool, error) { c, err = o.fs.getFtpConnection(ctx) if err != nil { return false, err // getFtpConnection has retries already } fd, err = c.RetrFrom(o.fs.opt.Enc.FromStandardPath(path), uint64(offset)) if err != nil { o.fs.putFtpConnection(&c, err) } return shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("open: %w", err) } rc = &ftpReadCloser{rc: readers.NewLimitedReadCloser(fd, limit), c: c, f: o.fs} return rc, nil } // Update the already existing object // // Copy the reader into the object updating modTime and size. // // The new object may have been created if an error is returned func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { // defer fs.Trace(o, "src=%v", src)("err=%v", &err) path := path.Join(o.fs.root, o.remote) // remove the file if upload failed remove := func() { // Give the FTP server a chance to get its internal state in order after the error. // The error may have been local in which case we closed the connection. The server // may still be dealing with it for a moment. A sleep isn't ideal but I haven't been // able to think of a better method to find out if the server has finished - ncw time.Sleep(1 * time.Second) removeErr := o.Remove(ctx) if removeErr != nil { fs.Debugf(o, "Failed to remove: %v", removeErr) } else { fs.Debugf(o, "Removed after failed upload: %v", err) } } c, err := o.fs.getFtpConnection(ctx) if err != nil { return fmt.Errorf("Update: %w", err) } err = c.Stor(o.fs.opt.Enc.FromStandardPath(path), in) // Ignore error 250 here - send by some servers if errX := textprotoError(err); errX != nil { switch errX.Code { case ftp.StatusRequestedFileActionOK: err = nil } } if err != nil { _ = c.Quit() // toss this connection to avoid sync errors // recycle connection in advance to let remove() find free token o.fs.putFtpConnection(nil, err) remove() return fmt.Errorf("update stor: %w", err) } o.fs.putFtpConnection(&c, nil) if o.fs.opt.NoCheckUpload { o.info = &FileInfo{ Name: o.remote, Size: uint64(src.Size()), ModTime: src.ModTime(ctx), precise: true, IsDir: false, } return nil } if err = o.SetModTime(ctx, src.ModTime(ctx)); err != nil { return fmt.Errorf("SetModTime: %w", err) } o.info, err = o.fs.getInfo(ctx, path) if err != nil { return fmt.Errorf("update getinfo: %w", err) } return nil } // Remove an object func (o *Object) Remove(ctx context.Context) (err error) { // defer fs.Trace(o, "")("err=%v", &err) path := path.Join(o.fs.root, o.remote) // Check if it's a directory or a file info, err := o.fs.getInfo(ctx, path) if err != nil { return err } if info.IsDir { err = o.fs.Rmdir(ctx, o.remote) } else { c, err := o.fs.getFtpConnection(ctx) if err != nil { return fmt.Errorf("Remove: %w", err) } err = c.Delete(o.fs.opt.Enc.FromStandardPath(path)) o.fs.putFtpConnection(&c, err) } return err } // Check the interfaces are satisfied var ( _ fs.Fs = &Fs{} _ fs.Mover = &Fs{} _ fs.DirMover = &Fs{} _ fs.PutStreamer = &Fs{} _ fs.Shutdowner = &Fs{} _ fs.Object = &Object{} ) rclone-v1.71.0/backend/ftp/ftp_internal_test.go000066400000000000000000000062331505210326400215050ustar00rootroot00000000000000package ftp import ( "context" "fmt" "strings" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/object" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" "github.com/rclone/rclone/lib/readers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) type settings map[string]any func deriveFs(ctx context.Context, t *testing.T, f fs.Fs, opts settings) fs.Fs { fsName := strings.Split(f.Name(), "{")[0] // strip off hash configMap := configmap.Simple{} for key, val := range opts { configMap[key] = fmt.Sprintf("%v", val) } remote := fmt.Sprintf("%s,%s:%s", fsName, configMap.String(), f.Root()) fixFs, err := fs.NewFs(ctx, remote) require.NoError(t, err) return fixFs } // test that big file uploads do not cause network i/o timeout func (f *Fs) testUploadTimeout(t *testing.T) { const ( fileSize = 100000000 // 100 MiB idleTimeout = 1 * time.Second // small because test server is local maxTime = 10 * time.Second // prevent test hangup ) if testing.Short() { t.Skip("not running with -short") } ctx := context.Background() ci := fs.GetConfig(ctx) saveLowLevelRetries := ci.LowLevelRetries saveTimeout := ci.Timeout defer func() { ci.LowLevelRetries = saveLowLevelRetries ci.Timeout = saveTimeout }() ci.LowLevelRetries = 1 ci.Timeout = fs.Duration(idleTimeout) upload := func(concurrency int, shutTimeout time.Duration) (obj fs.Object, err error) { fixFs := deriveFs(ctx, t, f, settings{ "concurrency": concurrency, "shut_timeout": shutTimeout, }) // Make test object fileTime := fstest.Time("2020-03-08T09:30:00.000000000Z") meta := object.NewStaticObjectInfo("upload-timeout.test", fileTime, int64(fileSize), true, nil, nil) data := readers.NewPatternReader(int64(fileSize)) // Run upload and ensure maximum time done := make(chan bool) deadline := time.After(maxTime) go func() { obj, err = fixFs.Put(ctx, data, meta) done <- true }() select { case <-done: case <-deadline: t.Fatalf("Upload got stuck for %v !", maxTime) } return obj, err } // non-zero shut_timeout should fix i/o errors obj, err := upload(f.opt.Concurrency, time.Second) assert.NoError(t, err) assert.NotNil(t, obj) if obj != nil { _ = obj.Remove(ctx) } } // rclone must support precise time with ProFtpd and PureFtpd out of the box. // The VsFtpd server does not support the MFMT command to set file time like // other servers but by default supports the MDTM command in the non-standard // two-argument form for the same purpose. // See "mdtm_write" in https://security.appspot.com/vsftpd/vsftpd_conf.html func (f *Fs) testTimePrecision(t *testing.T) { name := f.Name() if pos := strings.Index(name, "{"); pos != -1 { name = name[:pos] } switch name { case "TestFTPProftpd", "TestFTPPureftpd", "TestFTPVsftpd": assert.LessOrEqual(t, f.Precision(), time.Second) } } // InternalTest dispatches all internal tests func (f *Fs) InternalTest(t *testing.T) { t.Run("UploadTimeout", f.testUploadTimeout) t.Run("TimePrecision", f.testTimePrecision) } var _ fstests.InternalTester = (*Fs)(nil) rclone-v1.71.0/backend/ftp/ftp_test.go000066400000000000000000000023521505210326400176070ustar00rootroot00000000000000// Test FTP filesystem interface package ftp_test import ( "testing" "github.com/rclone/rclone/backend/ftp" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against rclone FTP server func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestFTPRclone:", NilObject: (*ftp.Object)(nil), }) } // TestIntegrationProftpd runs integration tests against proFTPd func TestIntegrationProftpd(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("skipping as -remote is set") } fstests.Run(t, &fstests.Opt{ RemoteName: "TestFTPProftpd:", NilObject: (*ftp.Object)(nil), }) } // TestIntegrationPureftpd runs integration tests against pureFTPd func TestIntegrationPureftpd(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("skipping as -remote is set") } fstests.Run(t, &fstests.Opt{ RemoteName: "TestFTPPureftpd:", NilObject: (*ftp.Object)(nil), }) } // TestIntegrationVsftpd runs integration tests against vsFTPd func TestIntegrationVsftpd(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("skipping as -remote is set") } fstests.Run(t, &fstests.Opt{ RemoteName: "TestFTPVsftpd:", NilObject: (*ftp.Object)(nil), }) } rclone-v1.71.0/backend/gofile/000077500000000000000000000000001505210326400161025ustar00rootroot00000000000000rclone-v1.71.0/backend/gofile/api/000077500000000000000000000000001505210326400166535ustar00rootroot00000000000000rclone-v1.71.0/backend/gofile/api/types.go000066400000000000000000000205321505210326400203500ustar00rootroot00000000000000// Package api has type definitions for gofile // // Converted from the API docs with help from https://mholt.github.io/json-to-go/ package api import ( "fmt" "time" ) const ( // 2017-05-03T07:26:10-07:00 timeFormat = `"` + time.RFC3339 + `"` ) // Time represents date and time information for the // gofile API, by using RFC3339 type Time time.Time // MarshalJSON turns a Time into JSON (in UTC) func (t *Time) MarshalJSON() (out []byte, err error) { timeString := (*time.Time)(t).Format(timeFormat) return []byte(timeString), nil } // UnmarshalJSON turns JSON into a Time func (t *Time) UnmarshalJSON(data []byte) error { newT, err := time.Parse(timeFormat, string(data)) if err != nil { return err } *t = Time(newT) return nil } // Error is returned from gofile when things go wrong type Error struct { Status string `json:"status"` } // Error returns a string for the error and satisfies the error interface func (e Error) Error() string { out := fmt.Sprintf("Error %q", e.Status) return out } // IsError returns true if there is an error func (e Error) IsError() bool { return e.Status != "ok" } // Err returns err if not nil, or e if IsError or nil func (e Error) Err(err error) error { if err != nil { return err } if e.IsError() { return e } return nil } // Check Error satisfies the error interface var _ error = (*Error)(nil) // Types of things in Item const ( ItemTypeFolder = "folder" ItemTypeFile = "file" ) // Item describes a folder or a file as returned by /contents type Item struct { ID string `json:"id"` ParentFolder string `json:"parentFolder"` Type string `json:"type"` Name string `json:"name"` Size int64 `json:"size"` Code string `json:"code"` CreateTime int64 `json:"createTime"` ModTime int64 `json:"modTime"` Link string `json:"link"` MD5 string `json:"md5"` MimeType string `json:"mimetype"` ChildrenCount int `json:"childrenCount"` DirectLinks map[string]*DirectLink `json:"directLinks"` //Public bool `json:"public"` //ServerSelected string `json:"serverSelected"` //Thumbnail string `json:"thumbnail"` //DownloadCount int `json:"downloadCount"` //TotalDownloadCount int64 `json:"totalDownloadCount"` //TotalSize int64 `json:"totalSize"` //ChildrenIDs []string `json:"childrenIds"` Children map[string]*Item `json:"children"` } // ToNativeTime converts a go time to a native time func ToNativeTime(t time.Time) int64 { return t.Unix() } // FromNativeTime converts native time to a go time func FromNativeTime(t int64) time.Time { return time.Unix(t, 0) } // DirectLink describes a direct link to a file so it can be // downloaded by third parties. type DirectLink struct { ExpireTime int64 `json:"expireTime"` SourceIpsAllowed []any `json:"sourceIpsAllowed"` DomainsAllowed []any `json:"domainsAllowed"` Auth []any `json:"auth"` IsReqLink bool `json:"isReqLink"` DirectLink string `json:"directLink"` } // Contents is returned from the /contents call type Contents struct { Error Data struct { Item } `json:"data"` Metadata Metadata `json:"metadata"` } // Metadata is returned when paging is in use type Metadata struct { TotalCount int `json:"totalCount"` TotalPages int `json:"totalPages"` Page int `json:"page"` PageSize int `json:"pageSize"` HasNextPage bool `json:"hasNextPage"` } // AccountsGetID is the result of /accounts/getid type AccountsGetID struct { Error Data struct { ID string `json:"id"` } `json:"data"` } // Stats of storage and traffic type Stats struct { FolderCount int64 `json:"folderCount"` FileCount int64 `json:"fileCount"` Storage int64 `json:"storage"` TrafficDirectGenerated int64 `json:"trafficDirectGenerated"` TrafficReqDownloaded int64 `json:"trafficReqDownloaded"` TrafficWebDownloaded int64 `json:"trafficWebDownloaded"` } // AccountsGet is the result of /accounts/{id} type AccountsGet struct { Error Data struct { ID string `json:"id"` Email string `json:"email"` Tier string `json:"tier"` PremiumType string `json:"premiumType"` Token string `json:"token"` RootFolder string `json:"rootFolder"` SubscriptionProvider string `json:"subscriptionProvider"` SubscriptionEndDate int `json:"subscriptionEndDate"` SubscriptionLimitDirectTraffic int64 `json:"subscriptionLimitDirectTraffic"` SubscriptionLimitStorage int64 `json:"subscriptionLimitStorage"` StatsCurrent Stats `json:"statsCurrent"` // StatsHistory map[int]map[int]map[int]Stats `json:"statsHistory"` } `json:"data"` } // CreateFolderRequest is the input to /contents/createFolder type CreateFolderRequest struct { ParentFolderID string `json:"parentFolderId"` FolderName string `json:"folderName"` ModTime int64 `json:"modTime,omitempty"` } // CreateFolderResponse is the output from /contents/createFolder type CreateFolderResponse struct { Error Data Item `json:"data"` } // DeleteRequest is the input to DELETE /contents type DeleteRequest struct { ContentsID string `json:"contentsId"` // comma separated list of IDs } // DeleteResponse is the input to DELETE /contents type DeleteResponse struct { Error Data map[string]Error } // DirectUploadURL returns the direct upload URL for Gofile func DirectUploadURL() string { return "https://upload.gofile.io/uploadfile" } // UploadResponse is returned by POST /contents/uploadfile type UploadResponse struct { Error Data Item `json:"data"` } // DirectLinksRequest specifies the parameters for the direct link type DirectLinksRequest struct { ExpireTime int64 `json:"expireTime,omitempty"` SourceIpsAllowed []any `json:"sourceIpsAllowed,omitempty"` DomainsAllowed []any `json:"domainsAllowed,omitempty"` Auth []any `json:"auth,omitempty"` } // DirectLinksResult is returned from POST /contents/{id}/directlinks type DirectLinksResult struct { Error Data struct { ExpireTime int64 `json:"expireTime"` SourceIpsAllowed []any `json:"sourceIpsAllowed"` DomainsAllowed []any `json:"domainsAllowed"` Auth []any `json:"auth"` IsReqLink bool `json:"isReqLink"` ID string `json:"id"` DirectLink string `json:"directLink"` } `json:"data"` } // UpdateItemRequest describes the updates to be done to an item for PUT /contents/{id}/update // // The Value of the attribute to define : // For Attribute "name" : The name of the content (file or folder) // For Attribute "description" : The description displayed on the download page (folder only) // For Attribute "tags" : A comma-separated list of tags (folder only) // For Attribute "public" : either true or false (folder only) // For Attribute "expiry" : A unix timestamp of the expiration date (folder only) // For Attribute "password" : The password to set (folder only) type UpdateItemRequest struct { Attribute string `json:"attribute"` Value any `json:"attributeValue"` } // UpdateItemResponse is returned by PUT /contents/{id}/update type UpdateItemResponse struct { Error Data Item `json:"data"` } // MoveRequest is the input to /contents/move type MoveRequest struct { FolderID string `json:"folderId"` ContentsID string `json:"contentsId"` // comma separated list of IDs } // MoveResponse is returned by POST /contents/move type MoveResponse struct { Error Data map[string]struct { Error Item `json:"data"` } `json:"data"` } // CopyRequest is the input to /contents/copy type CopyRequest struct { FolderID string `json:"folderId"` ContentsID string `json:"contentsId"` // comma separated list of IDs } // CopyResponse is returned by POST /contents/copy type CopyResponse struct { Error Data map[string]struct { Error Item `json:"data"` } `json:"data"` } // UploadServerStatus is returned when fetching the root of an upload server type UploadServerStatus struct { Error Data struct { Server string `json:"server"` Test string `json:"test"` } `json:"data"` } rclone-v1.71.0/backend/gofile/gofile.go000066400000000000000000001256611505210326400177110ustar00rootroot00000000000000// Package gofile provides an interface to the Gofile // object storage system. package gofile import ( "context" "encoding/json" "errors" "fmt" "io" "net/http" "net/url" "path" "strconv" "strings" "time" "github.com/rclone/rclone/backend/gofile/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/lib/dircache" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/rest" ) const ( minSleep = 10 * time.Millisecond maxSleep = 20 * time.Second decayConstant = 1 // bigger for slower decay, exponential rootURL = "https://api.gofile.io" rateLimitSleep = 5 * time.Second // penalise a goroutine by this long for making a rate limit error maxDepth = 4 // in ListR recursive list this deep (maximum is 16) ) /* // TestGoFile{sb0-v} stringNeedsEscaping = []rune{ '!', '*', '.', '/', ':', '<', '>', '?', '\"', '\\', '\a', '\b', '\f', '\n', '\r', '\t', '\v', '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x0e', '\x0f', '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17', '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f', '\x7f', '\xbf', '\xfe', '|' } maxFileLength = 255 // for 1 byte unicode characters maxFileLength = 255 // for 2 byte unicode characters maxFileLength = 255 // for 3 byte unicode characters maxFileLength = 255 // for 4 byte unicode characters canWriteUnnormalized = true canReadUnnormalized = true canReadRenormalized = false canStream = true base32768isOK = false // make sure maxFileLength for 2 byte unicode chars is the same as for 1 byte characters */ // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "gofile", Description: "Gofile", NewFs: NewFs, Options: []fs.Option{{ Name: "access_token", Help: `API Access token You can get this from the web control panel.`, Sensitive: true, }, { Name: "root_folder_id", Help: `ID of the root folder Leave this blank normally, rclone will fill it in automatically. If you want rclone to be restricted to a particular folder you can fill it in - see the docs for more info. `, Default: "", Advanced: true, Sensitive: true, }, { Name: "account_id", Help: `Account ID Leave this blank normally, rclone will fill it in automatically. `, Default: "", Advanced: true, Sensitive: true, }, { Name: "list_chunk", Help: `Number of items to list in each call`, Default: 1000, Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: (encoder.Display | // Slash Control Delete Dot encoder.EncodeDoubleQuote | encoder.EncodeAsterisk | encoder.EncodeColon | encoder.EncodeLtGt | encoder.EncodeQuestion | encoder.EncodeBackSlash | encoder.EncodePipe | encoder.EncodeExclamation | encoder.EncodeLeftPeriod | encoder.EncodeRightPeriod | encoder.EncodeInvalidUtf8), }}, }) } // Options defines the configuration for this backend type Options struct { AccessToken string `config:"access_token"` RootFolderID string `config:"root_folder_id"` AccountID string `config:"account_id"` ListChunk int `config:"list_chunk"` Enc encoder.MultiEncoder `config:"encoding"` } // Fs represents a remote gofile type Fs struct { name string // name of this remote root string // the path we are working on opt Options // parsed options features *fs.Features // optional features srv *rest.Client // the connection to the server dirCache *dircache.DirCache // Map of directory path to directory id pacer *fs.Pacer // pacer for API calls } // Object describes a gofile object // // The full set of metadata will always be present type Object struct { fs *Fs // what this object is part of remote string // The remote path size int64 // size of the object modTime time.Time // modification time of the object id string // ID of the object dirID string // ID of the object's directory mimeType string // mime type of the object md5 string // MD5 of the object content url string // where to download this object } // Directory describes a gofile directory type Directory struct { Object items int64 // number of items in the directory } // ------------------------------------------------------------ // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("gofile root '%s'", f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // parsePath parses a gofile 'url' func parsePath(path string) (root string) { root = strings.Trim(path, "/") return } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 429, // Too Many Requests. 500, // Internal Server Error 502, // Bad Gateway 503, // Service Unavailable 504, // Gateway Timeout 509, // Bandwidth Limit Exceeded } // Return true if the api error has the status given func isAPIErr(err error, status string) bool { var apiErr api.Error if errors.As(err, &apiErr) { return apiErr.Status == status } return false } // shouldRetry returns a boolean as to whether this resp and err // deserve to be retried. It returns the err as a convenience func shouldRetry(ctx context.Context, resp *http.Response, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } if isAPIErr(err, "error-rateLimit") { // Give an immediate penalty to rate limits fs.Debugf(nil, "Rate limited, sleep for %v", rateLimitSleep) time.Sleep(rateLimitSleep) //return true, pacer.RetryAfterError(err, 2*time.Second) return true, err } return fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(resp, retryErrorCodes), err } // readMetaDataForPath reads the metadata from the path func (f *Fs) readMetaDataForPath(ctx context.Context, path string) (info *api.Item, err error) { // defer log.Trace(f, "path=%q", path)("info=%+v, err=%v", &info, &err) leaf, directoryID, err := f.dirCache.FindPath(ctx, path, false) if err != nil { if err == fs.ErrorDirNotFound { return nil, fs.ErrorObjectNotFound } return nil, err } found, err := f.listAll(ctx, directoryID, false, true, leaf, func(item *api.Item) bool { if item.Name == leaf { info = item return true } return false }) if err != nil { return nil, err } if !found { return nil, fs.ErrorObjectNotFound } return info, nil } // readMetaDataForID reads the metadata for the ID given func (f *Fs) readMetaDataForID(ctx context.Context, id string) (info *api.Item, err error) { opts := rest.Opts{ Method: "GET", Path: "/contents/" + id, Parameters: url.Values{ "page": {"1"}, "pageSize": {"1"}, // not interested in children so just ask for 1 }, } var result api.Contents err = f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, nil, &result) // Retry not found errors - when looking for an ID it should really exist if isAPIErr(err, "error-notFound") { return true, err } return shouldRetry(ctx, resp, err) }) if err = result.Err(err); err != nil { return nil, fmt.Errorf("failed to get item info: %w", err) } return &result.Data.Item, nil } // errorHandler parses a non 2xx error response into an error func errorHandler(resp *http.Response) error { body, err := rest.ReadBody(resp) if err != nil { fs.Debugf(nil, "Couldn't read error out of body: %v", err) body = nil } // Decode error response if there was one - they can be blank var errResponse api.Error if len(body) > 0 { err = json.Unmarshal(body, &errResponse) if err != nil { fs.Debugf(nil, "Couldn't decode error response: %v", err) } } if errResponse.Status == "" { errResponse.Status = fmt.Sprintf("%s (%d): %s", resp.Status, resp.StatusCode, string(body)) } return errResponse } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } root = parsePath(root) client := fshttp.NewClient(ctx) f := &Fs{ name: name, root: root, opt: *opt, srv: rest.NewClient(client).SetRoot(rootURL), pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), } f.features = (&fs.Features{ CaseInsensitive: false, CanHaveEmptyDirectories: true, DuplicateFiles: true, ReadMimeType: true, WriteMimeType: false, WriteDirSetModTime: true, DirModTimeUpdatesOnWrite: true, }).Fill(ctx, f) f.srv.SetErrorHandler(errorHandler) f.srv.SetHeader("Authorization", "Bearer "+f.opt.AccessToken) // Read account ID if not present err = f.readAccountID(ctx, m) if err != nil { return nil, err } // Read Root Folder ID if not present err = f.readRootFolderID(ctx, m) if err != nil { return nil, err } // Get rootFolderID rootID := f.opt.RootFolderID f.dirCache = dircache.New(root, rootID, f) // Find the current root err = f.dirCache.FindRoot(ctx, false) if err != nil { // Assume it is a file newRoot, remote := dircache.SplitPath(root) tempF := *f tempF.dirCache = dircache.New(newRoot, rootID, &tempF) tempF.root = newRoot // Make new Fs which is the parent err = tempF.dirCache.FindRoot(ctx, false) if err != nil { // No root so return old f return f, nil } _, err := tempF.newObjectWithInfo(ctx, remote, nil) if err != nil { if err == fs.ErrorObjectNotFound { // File doesn't exist so return old f return f, nil } return nil, err } f.features.Fill(ctx, &tempF) // XXX: update the old f here instead of returning tempF, since // `features` were already filled with functions having *f as a receiver. // See https://github.com/rclone/rclone/issues/2182 f.dirCache = tempF.dirCache f.root = tempF.root // return an error with an fs which points to the parent return f, fs.ErrorIsFile } return f, nil } // Read the AccountID into f.opt if not set and cache in the config file as account_id func (f *Fs) readAccountID(ctx context.Context, m configmap.Mapper) (err error) { if f.opt.AccountID != "" { return nil } opts := rest.Opts{ Method: "GET", Path: "/accounts/getid", } var result api.AccountsGetID var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, resp, err) }) if err = result.Err(err); err != nil { return fmt.Errorf("failed to read account ID: %w", err) } f.opt.AccountID = result.Data.ID m.Set("account_id", f.opt.AccountID) return nil } // Read the Accounts info func (f *Fs) getAccounts(ctx context.Context) (result *api.AccountsGet, err error) { opts := rest.Opts{ Method: "GET", Path: "/accounts/" + f.opt.AccountID, } result = new(api.AccountsGet) var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, resp, err) }) if err = result.Err(err); err != nil { return nil, fmt.Errorf("failed to read accountd info: %w", err) } return result, nil } // Read the RootFolderID into f.opt if not set and cache in the config file as root_folder_id func (f *Fs) readRootFolderID(ctx context.Context, m configmap.Mapper) (err error) { if f.opt.RootFolderID != "" { return nil } result, err := f.getAccounts(ctx) if err != nil { return err } f.opt.RootFolderID = result.Data.RootFolder m.Set("root_folder_id", f.opt.RootFolderID) return nil } // rootSlash returns root with a slash on if it is empty, otherwise empty string func (f *Fs) rootSlash() string { if f.root == "" { return f.root } return f.root + "/" } // Return an Object from a path // // If it can't be found it returns the error fs.ErrorObjectNotFound. func (f *Fs) newObjectWithInfo(ctx context.Context, remote string, info *api.Item) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } var err error if info != nil { // Set info err = o.setMetaData(info) } else { err = o.readMetaData(ctx) // reads info and meta, returning an error } if err != nil { return nil, err } return o, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return f.newObjectWithInfo(ctx, remote, nil) } // FindLeaf finds a directory of name leaf in the folder with ID pathID func (f *Fs) FindLeaf(ctx context.Context, pathID, leaf string) (pathIDOut string, found bool, err error) { // Find the leaf in pathID found, err = f.listAll(ctx, pathID, true, false, leaf, func(item *api.Item) bool { if item.Name == leaf { pathIDOut = item.ID return true } return false }) return pathIDOut, found, err } // createDir makes a directory with pathID as parent and name leaf and modTime func (f *Fs) createDir(ctx context.Context, pathID, leaf string, modTime time.Time) (item *api.Item, err error) { var resp *http.Response var result api.CreateFolderResponse opts := rest.Opts{ Method: "POST", Path: "/contents/createFolder", } mkdir := api.CreateFolderRequest{ FolderName: f.opt.Enc.FromStandardName(leaf), ParentFolderID: pathID, ModTime: api.ToNativeTime(modTime), } err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, &mkdir, &result) return shouldRetry(ctx, resp, err) }) if err = result.Err(err); err != nil { return nil, fmt.Errorf("failed to create folder: %w", err) } return &result.Data, nil } // CreateDir makes a directory with pathID as parent and name leaf func (f *Fs) CreateDir(ctx context.Context, pathID, leaf string) (newID string, err error) { // fs.Debugf(f, "CreateDir(%q, %q)\n", pathID, leaf) item, err := f.createDir(ctx, pathID, leaf, time.Now()) if err != nil { return "", err } return item.ID, nil } // list the objects into the function supplied // // If directories is set it only sends directories // User function to process a File item from listAll // // Should return true to finish processing type listAllFn func(*api.Item) bool // Lists the directory required calling the user function on each item found // // If name is set then the server will limit the returned items to those // with that name. // // If the user fn ever returns true then it early exits with found = true func (f *Fs) listAll(ctx context.Context, dirID string, directoriesOnly bool, filesOnly bool, name string, fn listAllFn) (found bool, err error) { opts := rest.Opts{ Method: "GET", Path: "/contents/" + dirID, Parameters: url.Values{}, } if name != "" { opts.Parameters.Add("contentname", f.opt.Enc.FromStandardName(name)) } page := 1 OUTER: for { opts.Parameters.Set("page", strconv.Itoa(page)) opts.Parameters.Set("pageSize", strconv.Itoa(f.opt.ListChunk)) var result api.Contents var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, resp, err) }) if err = result.Err(err); err != nil { if isAPIErr(err, "error-notFound") { return found, fs.ErrorDirNotFound } return found, fmt.Errorf("couldn't list files: %w", err) } for id, item := range result.Data.Children { _ = id if item.Type == api.ItemTypeFolder { if filesOnly { continue } } else if item.Type == api.ItemTypeFile { if directoriesOnly { continue } } else { fs.Debugf(f, "Ignoring %q - unknown type %q", item.Name, item.Type) continue } item.Name = f.opt.Enc.ToStandardName(item.Name) if fn(item) { found = true break OUTER } } if !result.Metadata.HasNextPage { break } page += 1 } return found, err } // Convert a list item into a DirEntry func (f *Fs) itemToDirEntry(ctx context.Context, remote string, info *api.Item) (entry fs.DirEntry, err error) { if info.Type == api.ItemTypeFolder { // cache the directory ID for later lookups f.dirCache.Put(remote, info.ID) d := &Directory{ Object: Object{ fs: f, remote: remote, }, items: int64(info.ChildrenCount), } d.setMetaDataAny(info) entry = d } else if info.Type == api.ItemTypeFile { entry, err = f.newObjectWithInfo(ctx, remote, info) if err != nil { return nil, err } } return entry, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { directoryID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { return nil, err } var iErr error _, err = f.listAll(ctx, directoryID, false, false, "", func(info *api.Item) bool { remote := path.Join(dir, info.Name) entry, err := f.itemToDirEntry(ctx, remote, info) if err != nil { iErr = err return true } entries = append(entries, entry) return false }) if err != nil { return nil, err } if iErr != nil { return nil, iErr } return entries, nil } // implementation of ListR func (f *Fs) listR(ctx context.Context, dir string, list *list.Helper) (err error) { directoryID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { return err } opts := rest.Opts{ Method: "GET", Path: "/contents/" + directoryID, Parameters: url.Values{"maxdepth": {strconv.Itoa(maxDepth)}}, } page := 1 for { opts.Parameters.Set("page", strconv.Itoa(page)) opts.Parameters.Set("pageSize", strconv.Itoa(f.opt.ListChunk)) var result api.Contents var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, resp, err) }) if err = result.Err(err); err != nil { if isAPIErr(err, "error-notFound") { return fs.ErrorDirNotFound } return fmt.Errorf("couldn't recursively list files: %w", err) } // Result.Data.Item now contains a recursive listing so we will have to decode recursively var decode func(string, *api.Item) error decode = func(dir string, dirItem *api.Item) error { // If we have ChildrenCount but no Children this means the recursion stopped here if dirItem.ChildrenCount > 0 && len(dirItem.Children) == 0 { return f.listR(ctx, dir, list) } for _, item := range dirItem.Children { if item.Type != api.ItemTypeFolder && item.Type != api.ItemTypeFile { fs.Debugf(f, "Ignoring %q - unknown type %q", item.Name, item.Type) continue } item.Name = f.opt.Enc.ToStandardName(item.Name) remote := path.Join(dir, item.Name) entry, err := f.itemToDirEntry(ctx, remote, item) if err != nil { return err } err = list.Add(entry) if err != nil { return err } if item.Type == api.ItemTypeFolder { err := decode(remote, item) if err != nil { return err } } } return nil } err = decode(dir, &result.Data.Item) if err != nil { return err } if !result.Metadata.HasNextPage { break } page += 1 } return err } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively than doing a directory traversal. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { list := list.NewHelper(callback) err = f.listR(ctx, dir, list) if err != nil { return err } return list.Flush() } // Creates from the parameters passed in a half finished Object which // must have setMetaData called on it // // Returns the object, leaf, directoryID and error. // // Used to create new objects func (f *Fs) createObject(ctx context.Context, remote string, modTime time.Time, size int64) (o *Object, leaf string, directoryID string, err error) { // Create the directory for the object if it doesn't exist leaf, directoryID, err = f.dirCache.FindPath(ctx, remote, true) if err != nil { return } // Temporary Object under construction o = &Object{ fs: f, remote: remote, } return o, leaf, directoryID, nil } // Put the object // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { existingObj, err := f.NewObject(ctx, src.Remote()) switch err { case nil: return existingObj, existingObj.Update(ctx, in, src, options...) case fs.ErrorObjectNotFound: // Not found so create it return f.PutUnchecked(ctx, in, src, options...) default: return nil, err } } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } // PutUnchecked the object into the container // // This will produce a duplicate if the object already exists. // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) PutUnchecked(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { remote := src.Remote() size := src.Size() modTime := src.ModTime(ctx) o, _, _, err := f.createObject(ctx, remote, modTime, size) if err != nil { return nil, err } return o, o.Update(ctx, in, src, options...) } // Mkdir creates the container if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) error { _, err := f.dirCache.FindDir(ctx, dir, true) return err } // DirSetModTime sets the directory modtime for dir func (f *Fs) DirSetModTime(ctx context.Context, dir string, modTime time.Time) error { dirID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { return err } _, err = f.setModTime(ctx, dirID, modTime) return err } // deleteObject removes an object by ID func (f *Fs) deleteObject(ctx context.Context, id string) error { opts := rest.Opts{ Method: "DELETE", Path: "/contents/", } request := api.DeleteRequest{ ContentsID: id, } var result api.DeleteResponse err := f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, &request, &result) return shouldRetry(ctx, resp, err) }) if err = result.Err(err); err != nil { return fmt.Errorf("failed to delete item: %w", err) } // Check the individual result codes also for _, err := range result.Data { if err.IsError() { return fmt.Errorf("failed to delete item: %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 { root := path.Join(f.root, dir) if root == "" { return errors.New("can't purge root directory") } dc := f.dirCache rootID, err := dc.FindDir(ctx, dir, false) if err != nil { return err } // Check to see if there is contents in the directory if check { found, err := f.listAll(ctx, rootID, false, false, "", func(item *api.Item) bool { return true }) if err != nil { return err } if found { return fs.ErrorDirectoryNotEmpty } } // Delete the directory err = f.deleteObject(ctx, rootID) if err != nil { return err } f.dirCache.FlushDir(dir) return nil } // Rmdir deletes the root folder // // Returns an error if it isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, true) } // Precision return the precision of this Fs func (f *Fs) Precision() time.Duration { return time.Second } // Purge deletes all the files and the container // // Optional interface: Only implement this if you have a way of // deleting all the files quicker than just running Remove() on the // result of List() func (f *Fs) Purge(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, false) } // About gets quota information func (f *Fs) About(ctx context.Context) (usage *fs.Usage, err error) { result, err := f.getAccounts(ctx) if err != nil { return nil, err } used := result.Data.StatsCurrent.Storage files := result.Data.StatsCurrent.FileCount total := result.Data.SubscriptionLimitStorage usage = &fs.Usage{ Used: fs.NewUsageValue(used), // bytes in use Total: fs.NewUsageValue(total), // bytes total Free: fs.NewUsageValue(total - used), // bytes free Objects: fs.NewUsageValue(files), // total objects } return usage, nil } // patch an attribute on an object to value func (f *Fs) patch(ctx context.Context, id, attribute string, value any) (item *api.Item, err error) { var resp *http.Response var request = api.UpdateItemRequest{ Attribute: attribute, Value: value, } var result api.UpdateItemResponse opts := rest.Opts{ Method: "PUT", Path: "/contents/" + id + "/update", } err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, &request, &result) return shouldRetry(ctx, resp, err) }) if err = result.Err(err); err != nil { return nil, fmt.Errorf("failed to patch item %q to %v: %w", attribute, value, err) } return &result.Data, nil } // rename a file or a folder func (f *Fs) rename(ctx context.Context, id, newLeaf string) (item *api.Item, err error) { return f.patch(ctx, id, "name", f.opt.Enc.FromStandardName(newLeaf)) } // setModTime sets the modification time of a file or folder func (f *Fs) setModTime(ctx context.Context, id string, modTime time.Time) (item *api.Item, err error) { return f.patch(ctx, id, "modTime", api.ToNativeTime(modTime)) } // move a file or a folder to a new directory func (f *Fs) move(ctx context.Context, id, newDirID string) (item *api.Item, err error) { var resp *http.Response var request = api.MoveRequest{ FolderID: newDirID, ContentsID: id, } var result api.MoveResponse opts := rest.Opts{ Method: "PUT", Path: "/contents/move", } err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, &request, &result) return shouldRetry(ctx, resp, err) }) if err = result.Err(err); err != nil { return nil, fmt.Errorf("failed to move item: %w", err) } itemResult, ok := result.Data[id] if !ok || itemResult.Item.ID == "" { return nil, errors.New("failed to read result of move") } return &itemResult.Item, nil } // move and rename a file or folder to directoryID with leaf func (f *Fs) moveTo(ctx context.Context, id, srcLeaf, dstLeaf, srcDirectoryID, dstDirectoryID string) (info *api.Item, err error) { // Can have duplicates so don't have to be careful here // Rename if required if srcLeaf != dstLeaf { info, err = f.rename(ctx, id, dstLeaf) if err != nil { return nil, err } } // Move if required if srcDirectoryID != dstDirectoryID { info, err = f.move(ctx, id, dstDirectoryID) if err != nil { return nil, err } } if info == nil { return f.readMetaDataForID(ctx, id) } return info, nil } // Move src to this remote using server-side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't move - not same remote type") return nil, fs.ErrorCantMove } // Find existing object srcLeaf, srcDirectoryID, err := srcObj.fs.dirCache.FindPath(ctx, srcObj.remote, false) if err != nil { return nil, err } // Create temporary object dstObj, dstLeaf, dstDirectoryID, err := f.createObject(ctx, remote, srcObj.modTime, srcObj.size) if err != nil { return nil, err } // Do the move info, err := f.moveTo(ctx, srcObj.id, srcLeaf, dstLeaf, srcDirectoryID, dstDirectoryID) if err != nil { return nil, err } err = dstObj.setMetaData(info) if err != nil { return nil, err } return dstObj, nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } srcID, srcDirectoryID, srcLeaf, dstDirectoryID, dstLeaf, err := f.dirCache.DirMove(ctx, srcFs.dirCache, srcFs.root, srcRemote, f.root, dstRemote) if err != nil { return err } // Do the move _, err = f.moveTo(ctx, srcID, srcLeaf, dstLeaf, srcDirectoryID, dstDirectoryID) if err != nil { return err } srcFs.dirCache.FlushDir(srcRemote) return nil } // copy a file or a folder to a new directory func (f *Fs) copy(ctx context.Context, id, newDirID string) (item *api.Item, err error) { var resp *http.Response var request = api.CopyRequest{ FolderID: newDirID, ContentsID: id, } var result api.CopyResponse opts := rest.Opts{ Method: "POST", Path: "/contents/copy", } err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, &request, &result) return shouldRetry(ctx, resp, err) }) if err = result.Err(err); err != nil { return nil, fmt.Errorf("failed to copy item: %w", err) } itemResult, ok := result.Data[id] if !ok || itemResult.Item.ID == "" { return nil, errors.New("failed to read result of copy") } return &itemResult.Item, nil } // copy and rename a file or folder to directoryID with leaf func (f *Fs) copyTo(ctx context.Context, srcID, srcLeaf, dstLeaf, dstDirectoryID string) (info *api.Item, err error) { // Can have duplicates so don't have to be careful here // Copy to dstDirectoryID first info, err = f.copy(ctx, srcID, dstDirectoryID) if err != nil { return nil, err } // Rename if required if srcLeaf != dstLeaf { info, err = f.rename(ctx, info.ID, dstLeaf) if err != nil { return nil, err } } return info, nil } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't copy - not same remote type") return nil, fs.ErrorCantCopy } srcLeaf := path.Base(srcObj.remote) srcPath := srcObj.fs.rootSlash() + srcObj.remote dstPath := f.rootSlash() + remote if srcPath == dstPath { return nil, fmt.Errorf("can't copy %q -> %q as are same name", srcPath, dstPath) } // Find existing object existingObj, err := f.NewObject(ctx, remote) if err == nil { defer func() { // Don't remove existing object if returning an error if err != nil { return } fs.Debugf(existingObj, "Server side copy: removing existing object after successful copy") err = existingObj.Remove(ctx) }() } // Create temporary object dstObj, dstLeaf, dstDirectoryID, err := f.createObject(ctx, remote, srcObj.modTime, srcObj.size) if err != nil { return nil, err } // Copy the object info, err := f.copyTo(ctx, srcObj.id, srcLeaf, dstLeaf, dstDirectoryID) if err != nil { return nil, err } err = dstObj.setMetaData(info) if err != nil { return nil, err } // Reset the modification time as copy does not preserve it err = dstObj.SetModTime(ctx, srcObj.modTime) if err != nil { return nil, err } return dstObj, nil } // unLink a file or directory func (f *Fs) unLink(ctx context.Context, remote string, id string, info *api.Item) (err error) { if info == nil { info, err = f.readMetaDataForID(ctx, id) if err != nil { return err } } for linkID, link := range info.DirectLinks { fs.Debugf(remote, "Removing direct link %s", link.DirectLink) opts := rest.Opts{ Method: "DELETE", Path: "/contents/" + id + "/directlinks/" + linkID, } var result api.Error err := f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, resp, err) }) if err = result.Err(err); err != nil { return fmt.Errorf("failed to unlink: %s", link.DirectLink) } } return nil } // PublicLink adds a "readable by anyone with link" permission on the given file or folder. func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (string, error) { id, err := f.dirCache.FindDir(ctx, remote, false) var info *api.Item if err == nil { fs.Debugf(f, "attempting to share directory '%s'", remote) } else { fs.Debugf(f, "attempting to share single file '%s'", remote) info, err = f.readMetaDataForPath(ctx, remote) if err != nil { return "", err } id = info.ID } if unlink { return "", f.unLink(ctx, remote, id, info) } var resp *http.Response var request api.DirectLinksRequest var result api.DirectLinksResult opts := rest.Opts{ Method: "POST", Path: "/contents/" + id + "/directlinks", } if expire != fs.DurationOff { when := time.Now().Add(time.Duration(expire)) fs.Debugf(f, "Link expires at %v (duration %v)", when, expire) request.ExpireTime = api.ToNativeTime(when) } err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, &request, &result) return shouldRetry(ctx, resp, err) }) if err = result.Err(err); err != nil { return "", fmt.Errorf("failed to create direct link: %w", err) } return result.Data.DirectLink, err } // DirCacheFlush resets the directory cache - used in testing as an // optional interface func (f *Fs) DirCacheFlush() { f.dirCache.ResetRoot() } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hash.MD5) } // MergeDirs merges the contents of all the directories passed // in into the first one and rmdirs the other directories. func (f *Fs) MergeDirs(ctx context.Context, dirs []fs.Directory) error { if len(dirs) < 2 { return nil } dstDir := dirs[0] for _, srcDir := range dirs[1:] { // list the objects infos := []*api.Item{} _, err := f.listAll(ctx, srcDir.ID(), false, false, "", func(info *api.Item) bool { infos = append(infos, info) return false }) if err != nil { return fmt.Errorf("MergeDirs list failed on %v: %w", srcDir, err) } // move them into place for _, info := range infos { fs.Infof(srcDir, "merging %q", info.Name) // Move the file into the destination _, err = f.move(ctx, info.ID, dstDir.ID()) if err != nil { return fmt.Errorf("MergeDirs move failed on %q in %v: %w", info.Name, srcDir, err) } } // rmdir the now empty source directory fs.Infof(srcDir, "removing empty directory") err = f.deleteObject(ctx, srcDir.ID()) if err != nil { return fmt.Errorf("MergeDirs move failed to rmdir %q: %w", srcDir, err) } } return nil } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Hash returns the SHA-1 of an object returning a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if t != hash.MD5 { return "", hash.ErrUnsupported } return o.md5, nil } // Size returns the size of an object in bytes func (o *Object) Size() int64 { return o.size } // setMetaDataAny sets the metadata from info but doesn't check the type func (o *Object) setMetaDataAny(info *api.Item) { o.size = info.Size o.modTime = api.FromNativeTime(info.ModTime) o.id = info.ID o.dirID = info.ParentFolder o.mimeType = info.MimeType o.md5 = info.MD5 o.url = info.Link } // setMetaData sets the metadata from info func (o *Object) setMetaData(info *api.Item) (err error) { if info.Type == api.ItemTypeFolder { return fs.ErrorIsDir } if info.Type != api.ItemTypeFile { return fmt.Errorf("%q is %q: %w", o.remote, info.Type, fs.ErrorNotAFile) } if info.ID == "" { return fmt.Errorf("ID not found in response") } o.setMetaDataAny(info) return nil } // readMetaData gets the metadata unconditionally as we expect Object // to always have the full set of metadata func (o *Object) readMetaData(ctx context.Context) (err error) { var info *api.Item if o.id != "" { info, err = o.fs.readMetaDataForID(ctx, o.id) } else { info, err = o.fs.readMetaDataForPath(ctx, o.remote) } if err != nil { if isAPIErr(err, "error-notFound") { return fs.ErrorObjectNotFound } return err } return o.setMetaData(info) } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers func (o *Object) ModTime(ctx context.Context) time.Time { return o.modTime } // SetModTime sets the modification time of the local fs object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { info, err := o.fs.setModTime(ctx, o.id, modTime) if err != nil { return err } return o.setMetaData(info) } // Storable returns a boolean showing whether this object storable func (o *Object) Storable() bool { return true } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { if o.id == "" { return nil, errors.New("can't download - no id") } if o.url == "" { // On upload an Object is returned with no url, so fetch it here if needed err = o.readMetaData(ctx) if err != nil { return nil, fmt.Errorf("read metadata: %w", err) } } fs.FixRangeOption(options, o.size) var resp *http.Response opts := rest.Opts{ Method: "GET", RootURL: o.url, Options: options, // Workaround for bug in content servers - no longer needed // ExtraHeaders: map[string]string{ // "Cookie": "accountToken=" + o.fs.opt.AccessToken, // }, } err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.Call(ctx, &opts) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } return resp.Body, err } // Update the object with the contents of the io.Reader, modTime and size // // If existing is set then it updates the object rather than creating a new one. // // The new object may have been created if an error is returned. func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { remote := o.Remote() modTime := src.ModTime(ctx) // Create the directory for the object if it doesn't exist leaf, directoryID, err := o.fs.dirCache.FindPath(ctx, remote, true) if err != nil { return err } // If the file exists, delete it after a successful upload if o.id != "" { id := o.id o.id = "" defer func() { if err != nil { return } fs.Debugf(o, "Removing old object on successful upload") deleteErr := o.fs.deleteObject(ctx, id) if deleteErr != nil { err = fmt.Errorf("failed to delete existing object: %w", deleteErr) } }() } // Do the upload var resp *http.Response var result api.UploadResponse opts := rest.Opts{ Method: "POST", Body: in, MultipartParams: url.Values{ "folderId": {directoryID}, "modTime": {strconv.FormatInt(modTime.Unix(), 10)}, }, MultipartContentName: "file", MultipartFileName: o.fs.opt.Enc.FromStandardName(leaf), RootURL: api.DirectUploadURL(), Options: options, } err = o.fs.pacer.CallNoRetry(func() (bool, error) { resp, err = o.fs.srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, resp, err) }) if err = result.Err(err); err != nil { return fmt.Errorf("failed to upload file: %w", err) } return o.setMetaData(&result.Data) } // Remove an object func (o *Object) Remove(ctx context.Context) error { return o.fs.deleteObject(ctx, o.id) } // ID returns the ID of the Object if known, or "" if not func (o *Object) ID() string { return o.id } // MimeType returns the content type of the Object if known, or "" if not func (o *Object) MimeType(ctx context.Context) string { return o.mimeType } // ParentID returns the ID of the Object parent if known, or "" if not func (o *Object) ParentID() string { return o.dirID } // setMetaData sets the metadata from info for a directory func (d *Directory) setMetaData(info *api.Item) (err error) { if info.Type == api.ItemTypeFile { return fs.ErrorIsFile } if info.Type != api.ItemTypeFolder { return fmt.Errorf("%q is not a directory (type %q)", d.remote, info.Type) } if info.ID == "" { return fmt.Errorf("ID not found in response") } d.setMetaDataAny(info) return nil } // SetModTime sets the modification time of the directory func (d *Directory) SetModTime(ctx context.Context, modTime time.Time) error { info, err := d.fs.setModTime(ctx, d.id, modTime) if err != nil { return err } return d.setMetaData(info) } // Items returns the count of items in this directory or this // directory and subdirectories if known, -1 for unknown func (d *Directory) Items() int64 { return d.items } // Hash does nothing on a directory // // This method is implemented with the incorrect type signature to // stop the Directory type asserting to fs.Object or fs.ObjectInfo func (d *Directory) Hash() { // Does nothing } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.DirCacheFlusher = (*Fs)(nil) _ fs.PublicLinker = (*Fs)(nil) _ fs.MergeDirser = (*Fs)(nil) _ fs.DirSetModTimer = (*Fs)(nil) _ fs.ListRer = (*Fs)(nil) _ fs.Object = (*Object)(nil) _ fs.IDer = (*Object)(nil) _ fs.MimeTyper = (*Object)(nil) _ fs.Directory = (*Directory)(nil) _ fs.SetModTimer = (*Directory)(nil) _ fs.ParentIDer = (*Directory)(nil) ) rclone-v1.71.0/backend/gofile/gofile_test.go000066400000000000000000000005571505210326400207440ustar00rootroot00000000000000// Test Gofile filesystem interface package gofile_test import ( "testing" "github.com/rclone/rclone/backend/gofile" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestGoFile:", NilObject: (*gofile.Object)(nil), }) } rclone-v1.71.0/backend/googlecloudstorage/000077500000000000000000000000001505210326400205255ustar00rootroot00000000000000rclone-v1.71.0/backend/googlecloudstorage/googlecloudstorage.go000066400000000000000000001250141505210326400247470ustar00rootroot00000000000000// Package googlecloudstorage provides an interface to Google Cloud Storage package googlecloudstorage /* Notes Can't set Updated but can set Metadata on object creation Patch needs full_control not just read_write FIXME Patch/Delete/Get isn't working with files with spaces in - giving 404 error - https://code.google.com/p/google-api-go-client/issues/detail?id=64 */ import ( "context" "encoding/base64" "encoding/hex" "errors" "fmt" "io" "net/http" "os" "path" "strconv" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/lib/bucket" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/env" "github.com/rclone/rclone/lib/oauthutil" "github.com/rclone/rclone/lib/pacer" "golang.org/x/oauth2" "golang.org/x/oauth2/google" "google.golang.org/api/googleapi" option "google.golang.org/api/option" // NOTE: This API is deprecated storage "google.golang.org/api/storage/v1" ) const ( rcloneClientID = "202264815644.apps.googleusercontent.com" rcloneEncryptedClientSecret = "Uj7C9jGfb9gmeaV70Lh058cNkWvepr-Es9sBm0zdgil7JaOWF1VySw" timeFormat = time.RFC3339Nano metaMtime = "mtime" // key to store mtime in metadata metaMtimeGsutil = "goog-reserved-file-mtime" // key used by GSUtil to store mtime in metadata listChunks = 1000 // chunk size to read directory listings minSleep = 10 * time.Millisecond ) var ( // Description of how to auth for this app storageConfig = &oauthutil.Config{ Scopes: []string{storage.DevstorageReadWriteScope}, AuthURL: google.Endpoint.AuthURL, TokenURL: google.Endpoint.TokenURL, ClientID: rcloneClientID, ClientSecret: obscure.MustReveal(rcloneEncryptedClientSecret), RedirectURL: oauthutil.RedirectURL, } ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "google cloud storage", Prefix: "gcs", Description: "Google Cloud Storage (this is not Google Drive)", NewFs: NewFs, Config: func(ctx context.Context, name string, m configmap.Mapper, config fs.ConfigIn) (*fs.ConfigOut, error) { saFile, _ := m.Get("service_account_file") saCreds, _ := m.Get("service_account_credentials") anonymous, _ := m.Get("anonymous") envAuth, _ := m.Get("env_auth") if saFile != "" || saCreds != "" || anonymous == "true" || envAuth == "true" { return nil, nil } return oauthutil.ConfigOut("", &oauthutil.Options{ OAuth2Config: storageConfig, }) }, Options: append(oauthutil.SharedOptions, []fs.Option{{ Name: "project_number", Help: "Project number.\n\nOptional - needed only for list/create/delete buckets - see your developer console.", Sensitive: true, }, { Name: "user_project", Help: "User project.\n\nOptional - needed only for requester pays.", Sensitive: true, }, { Name: "service_account_file", Help: "Service Account Credentials JSON file path.\n\nLeave blank normally.\nNeeded only if you want use SA instead of interactive login." + env.ShellExpandHelp, }, { Name: "service_account_credentials", Help: "Service Account Credentials JSON blob.\n\nLeave blank normally.\nNeeded only if you want use SA instead of interactive login.", Hide: fs.OptionHideBoth, Sensitive: true, }, { Name: "access_token", Help: "Short-lived access token.\n\nLeave blank normally.\nNeeded only if you want use short-lived access token instead of interactive login.", Hide: fs.OptionHideConfigurator, Sensitive: true, Advanced: true, }, { Name: "anonymous", Help: "Access public buckets and objects without credentials.\n\nSet to 'true' if you just want to download files and don't configure credentials.", Default: false, }, { Name: "object_acl", Help: "Access Control List for new objects.", Examples: []fs.OptionExample{{ Value: "authenticatedRead", Help: "Object owner gets OWNER access.\nAll Authenticated Users get READER access.", }, { Value: "bucketOwnerFullControl", Help: "Object owner gets OWNER access.\nProject team owners get OWNER access.", }, { Value: "bucketOwnerRead", Help: "Object owner gets OWNER access.\nProject team owners get READER access.", }, { Value: "private", Help: "Object owner gets OWNER access.\nDefault if left blank.", }, { Value: "projectPrivate", Help: "Object owner gets OWNER access.\nProject team members get access according to their roles.", }, { Value: "publicRead", Help: "Object owner gets OWNER access.\nAll Users get READER access.", }}, }, { Name: "bucket_acl", Help: "Access Control List for new buckets.", Examples: []fs.OptionExample{{ Value: "authenticatedRead", Help: "Project team owners get OWNER access.\nAll Authenticated Users get READER access.", }, { Value: "private", Help: "Project team owners get OWNER access.\nDefault if left blank.", }, { Value: "projectPrivate", Help: "Project team members get access according to their roles.", }, { Value: "publicRead", Help: "Project team owners get OWNER access.\nAll Users get READER access.", }, { Value: "publicReadWrite", Help: "Project team owners get OWNER access.\nAll Users get WRITER access.", }}, }, { Name: "bucket_policy_only", Help: `Access checks should use bucket-level IAM policies. If you want to upload objects to a bucket with Bucket Policy Only set then you will need to set this. When it is set, rclone: - ignores ACLs set on buckets - ignores ACLs set on objects - creates buckets with Bucket Policy Only set Docs: https://cloud.google.com/storage/docs/bucket-policy-only `, Default: false, }, { Name: "location", Help: "Location for the newly created buckets.", Examples: []fs.OptionExample{{ Value: "", Help: "Empty for default location (US)", }, { Value: "asia", Help: "Multi-regional location for Asia", }, { Value: "eu", Help: "Multi-regional location for Europe", }, { Value: "us", Help: "Multi-regional location for United States", }, { Value: "asia-east1", Help: "Taiwan", }, { Value: "asia-east2", Help: "Hong Kong", }, { Value: "asia-northeast1", Help: "Tokyo", }, { Value: "asia-northeast2", Help: "Osaka", }, { Value: "asia-northeast3", Help: "Seoul", }, { Value: "asia-south1", Help: "Mumbai", }, { Value: "asia-south2", Help: "Delhi", }, { Value: "asia-southeast1", Help: "Singapore", }, { Value: "asia-southeast2", Help: "Jakarta", }, { Value: "australia-southeast1", Help: "Sydney", }, { Value: "australia-southeast2", Help: "Melbourne", }, { Value: "europe-north1", Help: "Finland", }, { Value: "europe-west1", Help: "Belgium", }, { Value: "europe-west2", Help: "London", }, { Value: "europe-west3", Help: "Frankfurt", }, { Value: "europe-west4", Help: "Netherlands", }, { Value: "europe-west6", Help: "Zürich", }, { Value: "europe-central2", Help: "Warsaw", }, { Value: "us-central1", Help: "Iowa", }, { Value: "us-east1", Help: "South Carolina", }, { Value: "us-east4", Help: "Northern Virginia", }, { Value: "us-west1", Help: "Oregon", }, { Value: "us-west2", Help: "California", }, { Value: "us-west3", Help: "Salt Lake City", }, { Value: "us-west4", Help: "Las Vegas", }, { Value: "northamerica-northeast1", Help: "Montréal", }, { Value: "northamerica-northeast2", Help: "Toronto", }, { Value: "southamerica-east1", Help: "São Paulo", }, { Value: "southamerica-west1", Help: "Santiago", }, { Value: "asia1", Help: "Dual region: asia-northeast1 and asia-northeast2.", }, { Value: "eur4", Help: "Dual region: europe-north1 and europe-west4.", }, { Value: "nam4", Help: "Dual region: us-central1 and us-east1.", }}, }, { Name: "storage_class", Help: "The storage class to use when storing objects in Google Cloud Storage.", Examples: []fs.OptionExample{{ Value: "", Help: "Default", }, { Value: "MULTI_REGIONAL", Help: "Multi-regional storage class", }, { Value: "REGIONAL", Help: "Regional storage class", }, { Value: "NEARLINE", Help: "Nearline storage class", }, { Value: "COLDLINE", Help: "Coldline storage class", }, { Value: "ARCHIVE", Help: "Archive storage class", }, { Value: "DURABLE_REDUCED_AVAILABILITY", Help: "Durable reduced availability storage class", }}, }, { Name: "directory_markers", Default: false, Advanced: true, Help: `Upload an empty object with a trailing slash when a new directory is created Empty folders are unsupported for bucket based remotes, this option creates an empty object ending with "/", to persist the folder. `, }, { Name: "no_check_bucket", Help: `If set, don't attempt to check the bucket exists or create it. This can be useful when trying to minimise the number of transactions rclone does if you know the bucket exists already. `, Default: false, Advanced: true, }, { Name: "decompress", Help: `If set this will decompress gzip encoded objects. It is possible to upload objects to GCS with "Content-Encoding: gzip" set. Normally rclone will download these files as compressed objects. If this flag is set then rclone will decompress these files with "Content-Encoding: gzip" as they are received. This means that rclone can't check the size and hash but the file contents will be decompressed. `, Advanced: true, Default: false, }, { Name: "endpoint", Help: "Endpoint for the service.\n\nLeave blank normally.", Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: (encoder.Base | encoder.EncodeCrLf | encoder.EncodeInvalidUtf8), }, { Name: "env_auth", Help: "Get GCP IAM credentials from runtime (environment variables or instance meta data if no env vars).\n\nOnly applies if service_account_file and service_account_credentials is blank.", Default: false, Examples: []fs.OptionExample{{ Value: "false", Help: "Enter credentials in the next step.", }, { Value: "true", Help: "Get GCP IAM credentials from the environment (env vars or IAM).", }}, }}...), }) } // Options defines the configuration for this backend type Options struct { ProjectNumber string `config:"project_number"` UserProject string `config:"user_project"` ServiceAccountFile string `config:"service_account_file"` ServiceAccountCredentials string `config:"service_account_credentials"` Anonymous bool `config:"anonymous"` ObjectACL string `config:"object_acl"` BucketACL string `config:"bucket_acl"` BucketPolicyOnly bool `config:"bucket_policy_only"` Location string `config:"location"` StorageClass string `config:"storage_class"` NoCheckBucket bool `config:"no_check_bucket"` Decompress bool `config:"decompress"` Endpoint string `config:"endpoint"` Enc encoder.MultiEncoder `config:"encoding"` EnvAuth bool `config:"env_auth"` DirectoryMarkers bool `config:"directory_markers"` AccessToken string `config:"access_token"` } // Fs represents a remote storage server type Fs struct { name string // name of this remote root string // the path we are working on if any opt Options // parsed options features *fs.Features // optional features svc *storage.Service // the connection to the storage server client *http.Client // authorized client rootBucket string // bucket part of root (if any) rootDirectory string // directory part of root (if any) cache *bucket.Cache // cache of bucket status pacer *fs.Pacer // To pace the API calls warnCompressed sync.Once // warn once about compressed files } // Object describes a storage object // // Will definitely have info but maybe not meta type Object struct { fs *Fs // what this object is part of remote string // The remote path url string // download path md5sum string // The MD5Sum of the object bytes int64 // Bytes in the object modTime time.Time // Modified time of the object mimeType string gzipped bool // set if object has Content-Encoding: gzip } // ------------------------------------------------------------ // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { if f.rootBucket == "" { return "GCS root" } if f.rootDirectory == "" { return fmt.Sprintf("GCS bucket %s", f.rootBucket) } return fmt.Sprintf("GCS bucket %s path %s", f.rootBucket, f.rootDirectory) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // shouldRetry determines whether a given err rates being retried func shouldRetry(ctx context.Context, err error) (again bool, errOut error) { if fserrors.ContextError(ctx, &err) { return false, err } again = false if err != nil { if fserrors.ShouldRetry(err) { again = true } else { switch gerr := err.(type) { case *googleapi.Error: if gerr.Code >= 500 && gerr.Code < 600 { // All 5xx errors should be retried again = true } else if len(gerr.Errors) > 0 { reason := gerr.Errors[0].Reason if reason == "rateLimitExceeded" || reason == "userRateLimitExceeded" { again = true } } } } } return again, err } // parsePath parses a remote 'url' func parsePath(path string) (root string) { root = strings.Trim(path, "/") return } // split returns bucket and bucketPath from the rootRelativePath // relative to f.root func (f *Fs) split(rootRelativePath string) (bucketName, bucketPath string) { bucketName, bucketPath = bucket.Split(bucket.Join(f.root, rootRelativePath)) if f.opt.DirectoryMarkers && strings.HasSuffix(bucketPath, "//") { bucketPath = bucketPath[:len(bucketPath)-1] } return f.opt.Enc.FromStandardName(bucketName), f.opt.Enc.FromStandardPath(bucketPath) } // split returns bucket and bucketPath from the object func (o *Object) split() (bucket, bucketPath string) { return o.fs.split(o.remote) } func getServiceAccountClient(ctx context.Context, credentialsData []byte) (*http.Client, error) { conf, err := google.JWTConfigFromJSON(credentialsData, storageConfig.Scopes...) if err != nil { return nil, fmt.Errorf("error processing credentials: %w", err) } ctxWithSpecialClient := oauthutil.Context(ctx, fshttp.NewClient(ctx)) return oauth2.NewClient(ctxWithSpecialClient, conf.TokenSource(ctxWithSpecialClient)), nil } // setRoot changes the root of the Fs func (f *Fs) setRoot(root string) { f.root = parsePath(root) f.rootBucket, f.rootDirectory = bucket.Split(f.root) } // NewFs constructs an Fs from the path, bucket:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { var oAuthClient *http.Client // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } if opt.ObjectACL == "" { opt.ObjectACL = "private" } if opt.BucketACL == "" { opt.BucketACL = "private" } // try loading service account credentials from env variable, then from a file if opt.ServiceAccountCredentials == "" && opt.ServiceAccountFile != "" { loadedCreds, err := os.ReadFile(env.ShellExpand(opt.ServiceAccountFile)) if err != nil { return nil, fmt.Errorf("error opening service account credentials file: %w", err) } opt.ServiceAccountCredentials = string(loadedCreds) } if opt.Anonymous { oAuthClient = fshttp.NewClient(ctx) } else if opt.ServiceAccountCredentials != "" { oAuthClient, err = getServiceAccountClient(ctx, []byte(opt.ServiceAccountCredentials)) if err != nil { return nil, fmt.Errorf("failed configuring Google Cloud Storage Service Account: %w", err) } } else if opt.EnvAuth { oAuthClient, err = google.DefaultClient(ctx, storage.DevstorageFullControlScope) if err != nil { return nil, fmt.Errorf("failed to configure Google Cloud Storage: %w", err) } } else if opt.AccessToken != "" { ts := oauth2.Token{AccessToken: opt.AccessToken} oAuthClient = oauth2.NewClient(ctx, oauth2.StaticTokenSource(&ts)) } else { oAuthClient, _, err = oauthutil.NewClient(ctx, name, m, storageConfig) if err != nil { ctx := context.Background() oAuthClient, err = google.DefaultClient(ctx, storage.DevstorageFullControlScope) if err != nil { return nil, fmt.Errorf("failed to configure Google Cloud Storage: %w", err) } } } f := &Fs{ name: name, root: root, opt: *opt, pacer: fs.NewPacer(ctx, pacer.NewS3(pacer.MinSleep(minSleep))), cache: bucket.NewCache(), } f.setRoot(root) f.features = (&fs.Features{ ReadMimeType: true, WriteMimeType: true, BucketBased: true, BucketBasedRootOK: true, }).Fill(ctx, f) if opt.DirectoryMarkers { f.features.CanHaveEmptyDirectories = true } // Create a new authorized Drive client. f.client = oAuthClient gcsOpts := []option.ClientOption{option.WithHTTPClient(f.client)} if opt.Endpoint != "" { gcsOpts = append(gcsOpts, option.WithEndpoint(opt.Endpoint)) } f.svc, err = storage.NewService(context.Background(), gcsOpts...) if err != nil { return nil, fmt.Errorf("couldn't create Google Cloud Storage client: %w", err) } if f.rootBucket != "" && f.rootDirectory != "" { // Check to see if the object exists encodedDirectory := f.opt.Enc.FromStandardPath(f.rootDirectory) err = f.pacer.Call(func() (bool, error) { get := f.svc.Objects.Get(f.rootBucket, encodedDirectory).Context(ctx) if f.opt.UserProject != "" { get = get.UserProject(f.opt.UserProject) } _, err = get.Do() return shouldRetry(ctx, err) }) if err == nil { newRoot := path.Dir(f.root) if newRoot == "." { newRoot = "" } f.setRoot(newRoot) // return an error with an fs which points to the parent return f, fs.ErrorIsFile } } return f, nil } // Return an Object from a path // // If it can't be found it returns the error fs.ErrorObjectNotFound. func (f *Fs) newObjectWithInfo(ctx context.Context, remote string, info *storage.Object) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } if info != nil { o.setMetaData(info) } else { err := o.readMetaData(ctx) // reads info and meta, returning an error if err != nil { return nil, err } } return o, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return f.newObjectWithInfo(ctx, remote, nil) } // listFn is called from list to handle an object. type listFn func(remote string, object *storage.Object, isDirectory bool) error // list the objects into the function supplied // // dir is the starting directory, "" for root // // Set recurse to read sub directories. // // The remote has prefix removed from it and if addBucket is set // then it adds the bucket to the start. func (f *Fs) list(ctx context.Context, bucket, directory, prefix string, addBucket bool, recurse bool, fn listFn) (err error) { if prefix != "" { prefix += "/" } if directory != "" { directory += "/" } list := f.svc.Objects.List(bucket).Prefix(directory).MaxResults(listChunks) if f.opt.UserProject != "" { list = list.UserProject(f.opt.UserProject) } if !recurse { list = list.Delimiter("/") } foundItems := 0 for { var objects *storage.Objects err = f.pacer.Call(func() (bool, error) { objects, err = list.Context(ctx).Do() return shouldRetry(ctx, err) }) if err != nil { if gErr, ok := err.(*googleapi.Error); ok { if gErr.Code == http.StatusNotFound { err = fs.ErrorDirNotFound } } return err } if !recurse { foundItems += len(objects.Prefixes) var object storage.Object for _, remote := range objects.Prefixes { if !strings.HasSuffix(remote, "/") { continue } remote = f.opt.Enc.ToStandardPath(remote) if !strings.HasPrefix(remote, prefix) { fs.Logf(f, "Odd name received %q", remote) continue } remote = remote[len(prefix) : len(remote)-1] if addBucket { remote = path.Join(bucket, remote) } err = fn(remote, &object, true) if err != nil { return err } } } foundItems += len(objects.Items) for _, object := range objects.Items { remote := f.opt.Enc.ToStandardPath(object.Name) if !strings.HasPrefix(remote, prefix) { fs.Logf(f, "Odd name received %q", object.Name) continue } isDirectory := remote == "" || strings.HasSuffix(remote, "/") // is this a directory marker? if isDirectory { // Don't insert the root directory if remote == f.opt.Enc.ToStandardPath(directory) { continue } // process directory markers as directories remote, _ = strings.CutSuffix(remote, "/") } remote = remote[len(prefix):] if addBucket { remote = path.Join(bucket, remote) } err = fn(remote, object, isDirectory) if err != nil { return err } } if objects.NextPageToken == "" { break } list.PageToken(objects.NextPageToken) } if f.opt.DirectoryMarkers && foundItems == 0 && directory != "" { // Determine whether the directory exists or not by whether it has a marker _, err := f.readObjectInfo(ctx, bucket, directory) if err != nil { if err == fs.ErrorObjectNotFound { return fs.ErrorDirNotFound } return err } } return nil } // Convert a list item into a DirEntry func (f *Fs) itemToDirEntry(ctx context.Context, remote string, object *storage.Object, isDirectory bool) (fs.DirEntry, error) { if isDirectory { d := fs.NewDir(remote, time.Time{}).SetSize(int64(object.Size)) return d, nil } o, err := f.newObjectWithInfo(ctx, remote, object) if err != nil { return nil, err } return o, nil } // listDir lists a single directory func (f *Fs) listDir(ctx context.Context, bucket, directory, prefix string, addBucket bool) (entries fs.DirEntries, err error) { // List the objects err = f.list(ctx, bucket, directory, prefix, addBucket, false, func(remote string, object *storage.Object, isDirectory bool) error { entry, err := f.itemToDirEntry(ctx, remote, object, isDirectory) if err != nil { return err } if entry != nil { entries = append(entries, entry) } return nil }) if err != nil { return nil, err } // bucket must be present if listing succeeded f.cache.MarkOK(bucket) return entries, err } // listBuckets lists the buckets func (f *Fs) listBuckets(ctx context.Context) (entries fs.DirEntries, err error) { if f.opt.ProjectNumber == "" { return nil, errors.New("can't list buckets without project number") } listBuckets := f.svc.Buckets.List(f.opt.ProjectNumber).MaxResults(listChunks) if f.opt.UserProject != "" { listBuckets = listBuckets.UserProject(f.opt.UserProject) } for { var buckets *storage.Buckets err = f.pacer.Call(func() (bool, error) { buckets, err = listBuckets.Context(ctx).Do() return shouldRetry(ctx, err) }) if err != nil { return nil, err } for _, bucket := range buckets.Items { d := fs.NewDir(f.opt.Enc.ToStandardName(bucket.Name), time.Time{}) entries = append(entries, d) } if buckets.NextPageToken == "" { break } listBuckets.PageToken(buckets.NextPageToken) } return entries, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { bucket, directory := f.split(dir) if bucket == "" { if directory != "" { return nil, fs.ErrorListBucketRequired } return f.listBuckets(ctx) } return f.listDir(ctx, bucket, directory, f.rootDirectory, f.rootBucket == "") } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively that doing a directory traversal. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { bucket, directory := f.split(dir) list := list.NewHelper(callback) listR := func(bucket, directory, prefix string, addBucket bool) error { return f.list(ctx, bucket, directory, prefix, addBucket, true, func(remote string, object *storage.Object, isDirectory bool) error { entry, err := f.itemToDirEntry(ctx, remote, object, isDirectory) if err != nil { return err } return list.Add(entry) }) } if bucket == "" { entries, err := f.listBuckets(ctx) if err != nil { return err } for _, entry := range entries { err = list.Add(entry) if err != nil { return err } bucket := entry.Remote() err = listR(bucket, "", f.rootDirectory, true) if err != nil { return err } // bucket must be present if listing succeeded f.cache.MarkOK(bucket) } } else { err = listR(bucket, directory, f.rootDirectory, f.rootBucket == "") if err != nil { return err } // bucket must be present if listing succeeded f.cache.MarkOK(bucket) } return list.Flush() } // Put the object into the bucket // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { // Temporary Object under construction o := &Object{ fs: f, remote: src.Remote(), } return o, o.Update(ctx, in, src, options...) } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } // Create directory marker file and parents func (f *Fs) createDirectoryMarker(ctx context.Context, bucket, dir string) error { if !f.opt.DirectoryMarkers || bucket == "" { return nil } // Object to be uploaded o := &Object{ fs: f, modTime: time.Now(), } for { _, bucketPath := f.split(dir) // Don't create the directory marker if it is the bucket or at the very root if bucketPath == "" { break } o.remote = dir + "/" // Check to see if object already exists _, err := o.readObjectInfo(ctx) if err == nil { return nil } // Upload it if not fs.Debugf(o, "Creating directory marker") content := io.Reader(strings.NewReader("")) err = o.Update(ctx, content, o) if err != nil { return fmt.Errorf("creating directory marker failed: %w", err) } // Now check parent directory exists dir = path.Dir(dir) if dir == "/" || dir == "." { break } } return nil } // Mkdir creates the bucket if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) (err error) { bucket, _ := f.split(dir) e := f.checkBucket(ctx, bucket) if e != nil { return e } return f.createDirectoryMarker(ctx, bucket, dir) } // mkdirParent creates the parent bucket/directory if it doesn't exist func (f *Fs) mkdirParent(ctx context.Context, remote string) error { remote, _ = strings.CutSuffix(remote, "/") dir := path.Dir(remote) if dir == "/" || dir == "." { dir = "" } return f.Mkdir(ctx, dir) } // makeBucket creates the bucket if it doesn't exist func (f *Fs) makeBucket(ctx context.Context, bucket string) (err error) { return f.cache.Create(bucket, func() error { // List something from the bucket to see if it exists. Doing it like this enables the use of a // service account that only has the "Storage Object Admin" role. See #2193 for details. err = f.pacer.Call(func() (bool, error) { list := f.svc.Objects.List(bucket).MaxResults(1).Context(ctx) if f.opt.UserProject != "" { list = list.UserProject(f.opt.UserProject) } _, err = list.Do() return shouldRetry(ctx, err) }) if err == nil { // Bucket already exists return nil } else if gErr, ok := err.(*googleapi.Error); ok { if gErr.Code != http.StatusNotFound { return fmt.Errorf("failed to get bucket: %w", err) } } else { return fmt.Errorf("failed to get bucket: %w", err) } if f.opt.ProjectNumber == "" { return errors.New("can't make bucket without project number") } bucket := storage.Bucket{ Name: bucket, Location: f.opt.Location, StorageClass: f.opt.StorageClass, } if f.opt.BucketPolicyOnly { bucket.IamConfiguration = &storage.BucketIamConfiguration{ BucketPolicyOnly: &storage.BucketIamConfigurationBucketPolicyOnly{ Enabled: true, }, } } return f.pacer.Call(func() (bool, error) { insertBucket := f.svc.Buckets.Insert(f.opt.ProjectNumber, &bucket) if !f.opt.BucketPolicyOnly { insertBucket.PredefinedAcl(f.opt.BucketACL) } insertBucket = insertBucket.Context(ctx) if f.opt.UserProject != "" { insertBucket = insertBucket.UserProject(f.opt.UserProject) } _, err = insertBucket.Do() return shouldRetry(ctx, err) }) }, nil) } // checkBucket creates the bucket if it doesn't exist unless NoCheckBucket is true func (f *Fs) checkBucket(ctx context.Context, bucket string) error { if f.opt.NoCheckBucket { return nil } return f.makeBucket(ctx, bucket) } // Rmdir deletes the bucket if the fs is at the root // // Returns an error if it isn't empty: Error 409: The bucket you tried // to delete was not empty. func (f *Fs) Rmdir(ctx context.Context, dir string) (err error) { bucket, directory := f.split(dir) // Remove directory marker file if f.opt.DirectoryMarkers && bucket != "" && dir != "" { o := &Object{ fs: f, remote: dir + "/", } fs.Debugf(o, "Removing directory marker") err := o.Remove(ctx) if err != nil { return fmt.Errorf("removing directory marker failed: %w", err) } } if bucket == "" || directory != "" { return nil } return f.cache.Remove(bucket, func() error { return f.pacer.Call(func() (bool, error) { deleteBucket := f.svc.Buckets.Delete(bucket).Context(ctx) if f.opt.UserProject != "" { deleteBucket = deleteBucket.UserProject(f.opt.UserProject) } err = deleteBucket.Do() return shouldRetry(ctx, err) }) }) } // Precision returns the precision func (f *Fs) Precision() time.Duration { return time.Nanosecond } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { dstBucket, dstPath := f.split(remote) err := f.mkdirParent(ctx, remote) if err != nil { return nil, err } srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't copy - not same remote type") return nil, fs.ErrorCantCopy } srcBucket, srcPath := srcObj.split() // Temporary Object under construction dstObj := &Object{ fs: f, remote: remote, } rewriteRequest := f.svc.Objects.Rewrite(srcBucket, srcPath, dstBucket, dstPath, nil) if !f.opt.BucketPolicyOnly { rewriteRequest.DestinationPredefinedAcl(f.opt.ObjectACL) } var rewriteResponse *storage.RewriteResponse for { err = f.pacer.Call(func() (bool, error) { rewriteRequest = rewriteRequest.Context(ctx) if f.opt.UserProject != "" { rewriteRequest.UserProject(f.opt.UserProject) } rewriteResponse, err = rewriteRequest.Do() return shouldRetry(ctx, err) }) if err != nil { return nil, err } if rewriteResponse.Done { break } rewriteRequest.RewriteToken(rewriteResponse.RewriteToken) fs.Debugf(dstObj, "Continuing rewrite %d bytes done", rewriteResponse.TotalBytesRewritten) } // Set the metadata for the new object while we have it dstObj.setMetaData(rewriteResponse.Resource) return dstObj, nil } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hash.MD5) } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Hash returns the Md5sum of an object returning a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if t != hash.MD5 { return "", hash.ErrUnsupported } return o.md5sum, nil } // Size returns the size of an object in bytes func (o *Object) Size() int64 { return o.bytes } // setMetaData sets the fs data from a storage.Object func (o *Object) setMetaData(info *storage.Object) { o.url = info.MediaLink o.bytes = int64(info.Size) o.mimeType = info.ContentType o.gzipped = info.ContentEncoding == "gzip" // Read md5sum md5sumData, err := base64.StdEncoding.DecodeString(info.Md5Hash) if err != nil { fs.Logf(o, "Bad MD5 decode: %v", err) } else { o.md5sum = hex.EncodeToString(md5sumData) } // read mtime out of metadata if available mtimeString, ok := info.Metadata[metaMtime] if ok { modTime, err := time.Parse(timeFormat, mtimeString) if err == nil { o.modTime = modTime return } fs.Debugf(o, "Failed to read mtime from metadata: %s", err) } // Fallback to GSUtil mtime mtimeGsutilString, ok := info.Metadata[metaMtimeGsutil] if ok { unixTimeSec, err := strconv.ParseInt(mtimeGsutilString, 10, 64) if err == nil { o.modTime = time.Unix(unixTimeSec, 0) return } fs.Debugf(o, "Failed to read GSUtil mtime from metadata: %s", err) } // Fallback to the Updated time modTime, err := time.Parse(timeFormat, info.Updated) if err != nil { fs.Logf(o, "Bad time decode: %v", err) } else { o.modTime = modTime } // If gunzipping then size and md5sum are unknown if o.gzipped && o.fs.opt.Decompress { o.bytes = -1 o.md5sum = "" } } // readObjectInfo reads the definition for an object func (o *Object) readObjectInfo(ctx context.Context) (object *storage.Object, err error) { bucket, bucketPath := o.split() return o.fs.readObjectInfo(ctx, bucket, bucketPath) } // readObjectInfo reads the definition for an object func (f *Fs) readObjectInfo(ctx context.Context, bucket, bucketPath string) (object *storage.Object, err error) { err = f.pacer.Call(func() (bool, error) { get := f.svc.Objects.Get(bucket, bucketPath).Context(ctx) if f.opt.UserProject != "" { get = get.UserProject(f.opt.UserProject) } object, err = get.Do() return shouldRetry(ctx, err) }) if err != nil { if gErr, ok := err.(*googleapi.Error); ok { if gErr.Code == http.StatusNotFound { return nil, fs.ErrorObjectNotFound } } return nil, err } return object, nil } // readMetaData gets the metadata if it hasn't already been fetched // // it also sets the info func (o *Object) readMetaData(ctx context.Context) (err error) { if !o.modTime.IsZero() { return nil } object, err := o.readObjectInfo(ctx) if err != nil { return err } o.setMetaData(object) return nil } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers func (o *Object) ModTime(ctx context.Context) time.Time { err := o.readMetaData(ctx) if err != nil { // fs.Logf(o, "Failed to read metadata: %v", err) return time.Now() } return o.modTime } // Returns metadata for an object func metadataFromModTime(modTime time.Time) map[string]string { metadata := make(map[string]string, 1) metadata[metaMtime] = modTime.Format(timeFormat) metadata[metaMtimeGsutil] = strconv.FormatInt(modTime.Unix(), 10) return metadata } // SetModTime sets the modification time of the local fs object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) (err error) { // read the complete existing object first object, err := o.readObjectInfo(ctx) if err != nil { return err } // Add the mtime to the existing metadata if object.Metadata == nil { object.Metadata = make(map[string]string, 1) } object.Metadata[metaMtime] = modTime.Format(timeFormat) object.Metadata[metaMtimeGsutil] = strconv.FormatInt(modTime.Unix(), 10) // Copy the object to itself to update the metadata // Using PATCH requires too many permissions bucket, bucketPath := o.split() var newObject *storage.Object err = o.fs.pacer.Call(func() (bool, error) { copyObject := o.fs.svc.Objects.Copy(bucket, bucketPath, bucket, bucketPath, object) if !o.fs.opt.BucketPolicyOnly { copyObject.DestinationPredefinedAcl(o.fs.opt.ObjectACL) } copyObject = copyObject.Context(ctx) if o.fs.opt.UserProject != "" { copyObject = copyObject.UserProject(o.fs.opt.UserProject) } newObject, err = copyObject.Do() return shouldRetry(ctx, err) }) if err != nil { return err } o.setMetaData(newObject) return nil } // Storable returns a boolean as to whether this object is storable func (o *Object) Storable() bool { return true } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { url := o.url if o.fs.opt.UserProject != "" { url += "&userProject=" + o.fs.opt.UserProject } req, err := http.NewRequestWithContext(ctx, "GET", url, nil) if err != nil { return nil, err } fs.FixRangeOption(options, o.bytes) if o.gzipped && !o.fs.opt.Decompress { // Allow files which are stored on the cloud storage system // compressed to be downloaded without being decompressed. Note // that setting this here overrides the automatic decompression // in the Transport. // // See: https://cloud.google.com/storage/docs/transcoding req.Header.Set("Accept-Encoding", "gzip") o.fs.warnCompressed.Do(func() { fs.Logf(o, "Not decompressing 'Content-Encoding: gzip' compressed file. Use --gcs-decompress to override") }) } fs.OpenOptionAddHTTPHeaders(req.Header, options) var res *http.Response err = o.fs.pacer.Call(func() (bool, error) { res, err = o.fs.client.Do(req) if err == nil { err = googleapi.CheckResponse(res) if err != nil { _ = res.Body.Close() // ignore error } } return shouldRetry(ctx, err) }) if err != nil { return nil, err } _, isRanging := req.Header["Range"] if !(res.StatusCode == http.StatusOK || (isRanging && res.StatusCode == http.StatusPartialContent)) { _ = res.Body.Close() // ignore error return nil, fmt.Errorf("bad response: %d: %s", res.StatusCode, res.Status) } return res.Body, nil } // Update the object with the contents of the io.Reader, modTime and size // // The new object may have been created if an error is returned func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { bucket, bucketPath := o.split() // Create parent dir/bucket if not saving directory marker if !strings.HasSuffix(o.remote, "/") { err = o.fs.mkdirParent(ctx, o.remote) if err != nil { return err } } modTime := src.ModTime(ctx) object := storage.Object{ Bucket: bucket, Name: bucketPath, ContentType: fs.MimeType(ctx, src), Metadata: metadataFromModTime(modTime), } // Apply upload options for _, option := range options { key, value := option.Header() lowerKey := strings.ToLower(key) switch lowerKey { case "": // ignore case "cache-control": object.CacheControl = value case "content-disposition": object.ContentDisposition = value case "content-encoding": object.ContentEncoding = value case "content-language": object.ContentLanguage = value case "content-type": object.ContentType = value case "x-goog-storage-class": object.StorageClass = value default: const googMetaPrefix = "x-goog-meta-" if strings.HasPrefix(lowerKey, googMetaPrefix) { metaKey := lowerKey[len(googMetaPrefix):] object.Metadata[metaKey] = value } else { fs.Errorf(o, "Don't know how to set key %q on upload", key) } } } var newObject *storage.Object err = o.fs.pacer.CallNoRetry(func() (bool, error) { insertObject := o.fs.svc.Objects.Insert(bucket, &object).Media(in, googleapi.ContentType("")).Name(object.Name) if !o.fs.opt.BucketPolicyOnly { insertObject.PredefinedAcl(o.fs.opt.ObjectACL) } insertObject = insertObject.Context(ctx) if o.fs.opt.UserProject != "" { insertObject = insertObject.UserProject(o.fs.opt.UserProject) } newObject, err = insertObject.Do() return shouldRetry(ctx, err) }) if err != nil { return err } // Set the metadata for the new object while we have it o.setMetaData(newObject) return nil } // Remove an object func (o *Object) Remove(ctx context.Context) (err error) { bucket, bucketPath := o.split() err = o.fs.pacer.Call(func() (bool, error) { deleteBucket := o.fs.svc.Objects.Delete(bucket, bucketPath).Context(ctx) if o.fs.opt.UserProject != "" { deleteBucket = deleteBucket.UserProject(o.fs.opt.UserProject) } err = deleteBucket.Do() return shouldRetry(ctx, err) }) return err } // MimeType of an Object if known, "" otherwise func (o *Object) MimeType(ctx context.Context) string { return o.mimeType } // Check the interfaces are satisfied var ( _ fs.Fs = &Fs{} _ fs.Copier = &Fs{} _ fs.PutStreamer = &Fs{} _ fs.ListRer = &Fs{} _ fs.Object = &Object{} _ fs.MimeTyper = &Object{} ) rclone-v1.71.0/backend/googlecloudstorage/googlecloudstorage_test.go000066400000000000000000000014661505210326400260120ustar00rootroot00000000000000// Test GoogleCloudStorage filesystem interface package googlecloudstorage_test import ( "testing" "github.com/rclone/rclone/backend/googlecloudstorage" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestGoogleCloudStorage:", NilObject: (*googlecloudstorage.Object)(nil), }) } func TestIntegration2(t *testing.T) { if *fstest.RemoteName != "" { t.Skip("Skipping as -remote set") } name := "TestGoogleCloudStorage" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":", NilObject: (*googlecloudstorage.Object)(nil), ExtraConfig: []fstests.ExtraConfigItem{ {Name: name, Key: "directory_markers", Value: "true"}, }, }) } rclone-v1.71.0/backend/googlephotos/000077500000000000000000000000001505210326400173465ustar00rootroot00000000000000rclone-v1.71.0/backend/googlephotos/albums.go000066400000000000000000000062521505210326400211650ustar00rootroot00000000000000// This file contains the albums abstraction package googlephotos import ( "path" "slices" "strings" "sync" "github.com/rclone/rclone/backend/googlephotos/api" ) // All the albums type albums struct { mu sync.Mutex dupes map[string][]*api.Album // duplicated names byID map[string]*api.Album //..indexed by ID byTitle map[string]*api.Album //..indexed by Title path map[string][]string // partial album names to directory } // Create a new album func newAlbums() *albums { return &albums{ dupes: map[string][]*api.Album{}, byID: map[string]*api.Album{}, byTitle: map[string]*api.Album{}, path: map[string][]string{}, } } // add an album func (as *albums) add(album *api.Album) { // Munge the name of the album into a sensible path name album.Title = path.Clean(album.Title) if album.Title == "." || album.Title == "/" { album.Title = addID("", album.ID) } as.mu.Lock() as._add(album) as.mu.Unlock() } // _add an album - call with lock held func (as *albums) _add(album *api.Album) { // update dupes by title dupes := as.dupes[album.Title] dupes = append(dupes, album) as.dupes[album.Title] = dupes // Dedupe the album name if necessary if len(dupes) >= 2 { // If this is the first dupe, then need to adjust the first one if len(dupes) == 2 { firstAlbum := dupes[0] as._del(firstAlbum) as._add(firstAlbum) // undo add of firstAlbum to dupes as.dupes[album.Title] = dupes } album.Title = addID(album.Title, album.ID) } // Store the new album as.byID[album.ID] = album as.byTitle[album.Title] = album // Store the partial paths dir, leaf := album.Title, "" for dir != "" { i := strings.LastIndex(dir, "/") if i >= 0 { dir, leaf = dir[:i], dir[i+1:] } else { dir, leaf = "", dir } dirs := as.path[dir] found := false for _, dir := range dirs { if dir == leaf { found = true } } if !found { as.path[dir] = append(as.path[dir], leaf) } } } // del an album func (as *albums) del(album *api.Album) { as.mu.Lock() as._del(album) as.mu.Unlock() } // _del an album - call with lock held func (as *albums) _del(album *api.Album) { // We leave in dupes so it doesn't cause albums to get renamed // Remove from byID and byTitle delete(as.byID, album.ID) delete(as.byTitle, album.Title) // Remove from paths dir, leaf := album.Title, "" for dir != "" { // Can't delete if this dir exists anywhere in the path structure if _, found := as.path[dir]; found { break } i := strings.LastIndex(dir, "/") if i >= 0 { dir, leaf = dir[:i], dir[i+1:] } else { dir, leaf = "", dir } dirs := as.path[dir] for i, dir := range dirs { if dir == leaf { dirs = slices.Delete(dirs, i, i+1) break } } if len(dirs) == 0 { delete(as.path, dir) } else { as.path[dir] = dirs } } } // get an album by title func (as *albums) get(title string) (album *api.Album, ok bool) { as.mu.Lock() defer as.mu.Unlock() album, ok = as.byTitle[title] return album, ok } // getDirs gets directories below an album path func (as *albums) getDirs(albumPath string) (dirs []string, ok bool) { as.mu.Lock() defer as.mu.Unlock() dirs, ok = as.path[albumPath] return dirs, ok } rclone-v1.71.0/backend/googlephotos/albums_test.go000066400000000000000000000141431505210326400222220ustar00rootroot00000000000000package googlephotos import ( "testing" "github.com/rclone/rclone/backend/googlephotos/api" "github.com/stretchr/testify/assert" ) func TestNewAlbums(t *testing.T) { albums := newAlbums() assert.NotNil(t, albums.dupes) assert.NotNil(t, albums.byID) assert.NotNil(t, albums.byTitle) assert.NotNil(t, albums.path) } func TestAlbumsAdd(t *testing.T) { albums := newAlbums() assert.Equal(t, map[string][]*api.Album{}, albums.dupes) assert.Equal(t, map[string]*api.Album{}, albums.byID) assert.Equal(t, map[string]*api.Album{}, albums.byTitle) assert.Equal(t, map[string][]string{}, albums.path) a1 := &api.Album{ Title: "one", ID: "1", } albums.add(a1) assert.Equal(t, map[string][]*api.Album{ "one": {a1}, }, albums.dupes) assert.Equal(t, map[string]*api.Album{ "1": a1, }, albums.byID) assert.Equal(t, map[string]*api.Album{ "one": a1, }, albums.byTitle) assert.Equal(t, map[string][]string{ "": {"one"}, }, albums.path) a2 := &api.Album{ Title: "two", ID: "2", } albums.add(a2) assert.Equal(t, map[string][]*api.Album{ "one": {a1}, "two": {a2}, }, albums.dupes) assert.Equal(t, map[string]*api.Album{ "1": a1, "2": a2, }, albums.byID) assert.Equal(t, map[string]*api.Album{ "one": a1, "two": a2, }, albums.byTitle) assert.Equal(t, map[string][]string{ "": {"one", "two"}, }, albums.path) // Add a duplicate a2a := &api.Album{ Title: "two", ID: "2a", } albums.add(a2a) assert.Equal(t, map[string][]*api.Album{ "one": {a1}, "two": {a2, a2a}, }, albums.dupes) assert.Equal(t, map[string]*api.Album{ "1": a1, "2": a2, "2a": a2a, }, albums.byID) assert.Equal(t, map[string]*api.Album{ "one": a1, "two {2}": a2, "two {2a}": a2a, }, albums.byTitle) assert.Equal(t, map[string][]string{ "": {"one", "two {2}", "two {2a}"}, }, albums.path) // Add a sub directory a1sub := &api.Album{ Title: "one/sub", ID: "1sub", } albums.add(a1sub) assert.Equal(t, map[string][]*api.Album{ "one": {a1}, "two": {a2, a2a}, "one/sub": {a1sub}, }, albums.dupes) assert.Equal(t, map[string]*api.Album{ "1": a1, "2": a2, "2a": a2a, "1sub": a1sub, }, albums.byID) assert.Equal(t, map[string]*api.Album{ "one": a1, "one/sub": a1sub, "two {2}": a2, "two {2a}": a2a, }, albums.byTitle) assert.Equal(t, map[string][]string{ "": {"one", "two {2}", "two {2a}"}, "one": {"sub"}, }, albums.path) // Add a weird path a0 := &api.Album{ Title: "/../././..////.", ID: "0", } albums.add(a0) assert.Equal(t, map[string][]*api.Album{ "{0}": {a0}, "one": {a1}, "two": {a2, a2a}, "one/sub": {a1sub}, }, albums.dupes) assert.Equal(t, map[string]*api.Album{ "0": a0, "1": a1, "2": a2, "2a": a2a, "1sub": a1sub, }, albums.byID) assert.Equal(t, map[string]*api.Album{ "{0}": a0, "one": a1, "one/sub": a1sub, "two {2}": a2, "two {2a}": a2a, }, albums.byTitle) assert.Equal(t, map[string][]string{ "": {"one", "two {2}", "two {2a}", "{0}"}, "one": {"sub"}, }, albums.path) } func TestAlbumsDel(t *testing.T) { albums := newAlbums() a1 := &api.Album{ Title: "one", ID: "1", } albums.add(a1) a2 := &api.Album{ Title: "two", ID: "2", } albums.add(a2) // Add a duplicate a2a := &api.Album{ Title: "two", ID: "2a", } albums.add(a2a) // Add a sub directory a1sub := &api.Album{ Title: "one/sub", ID: "1sub", } albums.add(a1sub) assert.Equal(t, map[string][]*api.Album{ "one": {a1}, "two": {a2, a2a}, "one/sub": {a1sub}, }, albums.dupes) assert.Equal(t, map[string]*api.Album{ "1": a1, "2": a2, "2a": a2a, "1sub": a1sub, }, albums.byID) assert.Equal(t, map[string]*api.Album{ "one": a1, "one/sub": a1sub, "two {2}": a2, "two {2a}": a2a, }, albums.byTitle) assert.Equal(t, map[string][]string{ "": {"one", "two {2}", "two {2a}"}, "one": {"sub"}, }, albums.path) albums.del(a1) assert.Equal(t, map[string][]*api.Album{ "one": {a1}, "two": {a2, a2a}, "one/sub": {a1sub}, }, albums.dupes) assert.Equal(t, map[string]*api.Album{ "2": a2, "2a": a2a, "1sub": a1sub, }, albums.byID) assert.Equal(t, map[string]*api.Album{ "one/sub": a1sub, "two {2}": a2, "two {2a}": a2a, }, albums.byTitle) assert.Equal(t, map[string][]string{ "": {"one", "two {2}", "two {2a}"}, "one": {"sub"}, }, albums.path) albums.del(a2) assert.Equal(t, map[string][]*api.Album{ "one": {a1}, "two": {a2, a2a}, "one/sub": {a1sub}, }, albums.dupes) assert.Equal(t, map[string]*api.Album{ "2a": a2a, "1sub": a1sub, }, albums.byID) assert.Equal(t, map[string]*api.Album{ "one/sub": a1sub, "two {2a}": a2a, }, albums.byTitle) assert.Equal(t, map[string][]string{ "": {"one", "two {2a}"}, "one": {"sub"}, }, albums.path) albums.del(a2a) assert.Equal(t, map[string][]*api.Album{ "one": {a1}, "two": {a2, a2a}, "one/sub": {a1sub}, }, albums.dupes) assert.Equal(t, map[string]*api.Album{ "1sub": a1sub, }, albums.byID) assert.Equal(t, map[string]*api.Album{ "one/sub": a1sub, }, albums.byTitle) assert.Equal(t, map[string][]string{ "": {"one"}, "one": {"sub"}, }, albums.path) albums.del(a1sub) assert.Equal(t, map[string][]*api.Album{ "one": {a1}, "two": {a2, a2a}, "one/sub": {a1sub}, }, albums.dupes) assert.Equal(t, map[string]*api.Album{}, albums.byID) assert.Equal(t, map[string]*api.Album{}, albums.byTitle) assert.Equal(t, map[string][]string{}, albums.path) } func TestAlbumsGet(t *testing.T) { albums := newAlbums() a1 := &api.Album{ Title: "one", ID: "1", } albums.add(a1) album, ok := albums.get("one") assert.Equal(t, true, ok) assert.Equal(t, a1, album) album, ok = albums.get("notfound") assert.Equal(t, false, ok) assert.Nil(t, album) } func TestAlbumsGetDirs(t *testing.T) { albums := newAlbums() a1 := &api.Album{ Title: "one", ID: "1", } albums.add(a1) dirs, ok := albums.getDirs("") assert.Equal(t, true, ok) assert.Equal(t, []string{"one"}, dirs) dirs, ok = albums.getDirs("notfound") assert.Equal(t, false, ok) assert.Nil(t, dirs) } rclone-v1.71.0/backend/googlephotos/api/000077500000000000000000000000001505210326400201175ustar00rootroot00000000000000rclone-v1.71.0/backend/googlephotos/api/types.go000066400000000000000000000151471505210326400216220ustar00rootroot00000000000000// Package api provides types used by the Google Photos API. package api import ( "fmt" "time" ) // ErrorDetails in the internals of the Error type type ErrorDetails struct { Code int `json:"code"` Message string `json:"message"` Status string `json:"status"` } // Error is returned on errors type Error struct { Details ErrorDetails `json:"error"` } // Error satisfies error interface func (e *Error) Error() string { return fmt.Sprintf("%s (%d %s)", e.Details.Message, e.Details.Code, e.Details.Status) } // Album of photos type Album struct { ID string `json:"id,omitempty"` Title string `json:"title"` ProductURL string `json:"productUrl,omitempty"` MediaItemsCount string `json:"mediaItemsCount,omitempty"` CoverPhotoBaseURL string `json:"coverPhotoBaseUrl,omitempty"` CoverPhotoMediaItemID string `json:"coverPhotoMediaItemId,omitempty"` IsWriteable bool `json:"isWriteable,omitempty"` } // ListAlbums is returned from albums.list and sharedAlbums.list type ListAlbums struct { Albums []Album `json:"albums"` SharedAlbums []Album `json:"sharedAlbums"` NextPageToken string `json:"nextPageToken"` } // CreateAlbum creates an Album type CreateAlbum struct { Album *Album `json:"album"` } // MediaItem is a photo or video type MediaItem struct { ID string `json:"id"` ProductURL string `json:"productUrl"` BaseURL string `json:"baseUrl"` MimeType string `json:"mimeType"` MediaMetadata struct { CreationTime time.Time `json:"creationTime"` Width string `json:"width"` Height string `json:"height"` Photo struct{} `json:"photo"` } `json:"mediaMetadata"` Filename string `json:"filename"` } // MediaItems is returned from mediaitems.list, mediaitems.search type MediaItems struct { MediaItems []MediaItem `json:"mediaItems"` NextPageToken string `json:"nextPageToken"` } // Content categories // NONE Default content category. This category is ignored when any other category is used in the filter. // LANDSCAPES Media items containing landscapes. // RECEIPTS Media items containing receipts. // CITYSCAPES Media items containing cityscapes. // LANDMARKS Media items containing landmarks. // SELFIES Media items that are selfies. // PEOPLE Media items containing people. // PETS Media items containing pets. // WEDDINGS Media items from weddings. // BIRTHDAYS Media items from birthdays. // DOCUMENTS Media items containing documents. // TRAVEL Media items taken during travel. // ANIMALS Media items containing animals. // FOOD Media items containing food. // SPORT Media items from sporting events. // NIGHT Media items taken at night. // PERFORMANCES Media items from performances. // WHITEBOARDS Media items containing whiteboards. // SCREENSHOTS Media items that are screenshots. // UTILITY Media items that are considered to be utility. These include, but aren't limited to documents, screenshots, whiteboards etc. // ARTS Media items containing art. // CRAFTS Media items containing crafts. // FASHION Media items related to fashion. // HOUSES Media items containing houses. // GARDENS Media items containing gardens. // FLOWERS Media items containing flowers. // HOLIDAYS Media items taken of holidays. // MediaTypes // ALL_MEDIA Treated as if no filters are applied. All media types are included. // VIDEO All media items that are considered videos. This also includes movies the user has created using the Google Photos app. // PHOTO All media items that are considered photos. This includes .bmp, .gif, .ico, .jpg (and other spellings), .tiff, .webp and special photo types such as iOS live photos, Android motion photos, panoramas, photospheres. // Features // NONE Treated as if no filters are applied. All features are included. // FAVORITES Media items that the user has marked as favorites in the Google Photos app. // Date is used as part of SearchFilter type Date struct { Year int `json:"year,omitempty"` Month int `json:"month,omitempty"` Day int `json:"day,omitempty"` } // DateFilter is uses to add date ranges to media item queries type DateFilter struct { Dates []Date `json:"dates,omitempty"` Ranges []struct { StartDate Date `json:"startDate,omitempty"` EndDate Date `json:"endDate,omitempty"` } `json:"ranges,omitempty"` } // ContentFilter is uses to add content categories to media item queries type ContentFilter struct { IncludedContentCategories []string `json:"includedContentCategories,omitempty"` ExcludedContentCategories []string `json:"excludedContentCategories,omitempty"` } // MediaTypeFilter is uses to add media types to media item queries type MediaTypeFilter struct { MediaTypes []string `json:"mediaTypes,omitempty"` } // FeatureFilter is uses to add features to media item queries type FeatureFilter struct { IncludedFeatures []string `json:"includedFeatures,omitempty"` } // Filters combines all the filter types for media item queries type Filters struct { DateFilter *DateFilter `json:"dateFilter,omitempty"` ContentFilter *ContentFilter `json:"contentFilter,omitempty"` MediaTypeFilter *MediaTypeFilter `json:"mediaTypeFilter,omitempty"` FeatureFilter *FeatureFilter `json:"featureFilter,omitempty"` IncludeArchivedMedia *bool `json:"includeArchivedMedia,omitempty"` ExcludeNonAppCreatedData *bool `json:"excludeNonAppCreatedData,omitempty"` } // SearchFilter is uses with mediaItems.search type SearchFilter struct { AlbumID string `json:"albumId,omitempty"` PageSize int `json:"pageSize"` PageToken string `json:"pageToken,omitempty"` Filters *Filters `json:"filters,omitempty"` } // SimpleMediaItem is part of NewMediaItem type SimpleMediaItem struct { UploadToken string `json:"uploadToken"` } // NewMediaItem is a single media item for upload type NewMediaItem struct { Description string `json:"description"` SimpleMediaItem SimpleMediaItem `json:"simpleMediaItem"` } // BatchCreateRequest creates media items from upload tokens type BatchCreateRequest struct { AlbumID string `json:"albumId,omitempty"` NewMediaItems []NewMediaItem `json:"newMediaItems"` } // BatchCreateResponse is returned from BatchCreateRequest type BatchCreateResponse struct { NewMediaItemResults []struct { UploadToken string `json:"uploadToken"` Status struct { Message string `json:"message"` Code int `json:"code"` } `json:"status"` MediaItem MediaItem `json:"mediaItem"` } `json:"newMediaItemResults"` } // BatchRemoveItems is for removing items from an album type BatchRemoveItems struct { MediaItemIDs []string `json:"mediaItemIds"` } rclone-v1.71.0/backend/googlephotos/googlephotos.go000066400000000000000000001042501505210326400224100ustar00rootroot00000000000000// Package googlephotos provides an interface to Google Photos package googlephotos // FIXME Resumable uploads not implemented - rclone can't resume uploads in general import ( "context" "encoding/json" "errors" "fmt" "io" "net/http" "net/url" "path" "regexp" "strconv" "strings" "sync" "time" "github.com/rclone/rclone/backend/googlephotos/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/dirtree" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/batcher" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/oauthutil" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/rest" "golang.org/x/oauth2/google" ) var ( errCantUpload = errors.New("can't upload files here") errCantMkdir = errors.New("can't make directories here") errCantRmdir = errors.New("can't remove this directory") errAlbumDelete = errors.New("google photos API does not implement deleting albums") errRemove = errors.New("google photos API only implements removing files from albums") errOwnAlbums = errors.New("google photos API only allows uploading to albums rclone created") errReadOnly = errors.New("can't upload files in read only mode") ) const ( rcloneClientID = "202264815644-rt1o1c9evjaotbpbab10m83i8cnjk077.apps.googleusercontent.com" rcloneEncryptedClientSecret = "kLJLretPefBgrDHosdml_nlF64HZ9mUcO85X5rdjYBPP8ChA-jr3Ow" rootURL = "https://photoslibrary.googleapis.com/v1" listChunks = 100 // chunk size to read directory listings albumChunks = 50 // chunk size to read album listings minSleep = 10 * time.Millisecond scopeAppendOnly = "https://www.googleapis.com/auth/photoslibrary.appendonly" scopeReadOnly = "https://www.googleapis.com/auth/photoslibrary.readonly.appcreateddata" scopeReadWrite = "https://www.googleapis.com/auth/photoslibrary.edit.appcreateddata" ) var ( // scopes needed for read write access scopesReadWrite = []string{ "openid", "profile", scopeAppendOnly, scopeReadOnly, scopeReadWrite, } // scopes needed for read only access scopesReadOnly = []string{ "openid", "profile", scopeReadOnly, } // Description of how to auth for this app oauthConfig = &oauthutil.Config{ Scopes: scopesReadWrite, AuthURL: google.Endpoint.AuthURL, TokenURL: google.Endpoint.TokenURL, ClientID: rcloneClientID, ClientSecret: obscure.MustReveal(rcloneEncryptedClientSecret), RedirectURL: oauthutil.RedirectURL, } // Configure the batcher defaultBatcherOptions = batcher.Options{ MaxBatchSize: 50, DefaultTimeoutSync: 1000 * time.Millisecond, DefaultTimeoutAsync: 10 * time.Second, DefaultBatchSizeAsync: 50, } ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "google photos", Prefix: "gphotos", Description: "Google Photos", NewFs: NewFs, Config: func(ctx context.Context, name string, m configmap.Mapper, config fs.ConfigIn) (*fs.ConfigOut, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, fmt.Errorf("couldn't parse config into struct: %w", err) } switch config.State { case "": // Fill in the scopes if opt.ReadOnly { oauthConfig.Scopes = scopesReadOnly } else { oauthConfig.Scopes = scopesReadWrite } return oauthutil.ConfigOut("warning1", &oauthutil.Options{ OAuth2Config: oauthConfig, }) case "warning1": // Warn the user as required by google photos integration return fs.ConfigConfirm("warning2", true, "config_warning", `Warning IMPORTANT: All media items uploaded to Google Photos with rclone are stored in full resolution at original quality. These uploads will count towards storage in your Google Account.`) case "warning2": // Warn the user that rclone can no longer download photos it didnt upload from google photos return fs.ConfigConfirm("warning_done", true, "config_warning", `Warning IMPORTANT: Due to Google policy changes rclone can now only download photos it uploaded.`) case "warning_done": return nil, nil } return nil, fmt.Errorf("unknown state %q", config.State) }, Options: append(append(oauthutil.SharedOptions, []fs.Option{{ Name: "read_only", Default: false, Help: `Set to make the Google Photos backend read only. If you choose read only then rclone will only request read only access to your photos, otherwise rclone will request full access.`, }, { Name: "read_size", Default: false, Help: `Set to read the size of media items. Normally rclone does not read the size of media items since this takes another transaction. This isn't necessary for syncing. However rclone mount needs to know the size of files in advance of reading them, so setting this flag when using rclone mount is recommended if you want to read the media.`, Advanced: true, }, { Name: "start_year", Default: 2000, Help: `Year limits the photos to be downloaded to those which are uploaded after the given year.`, Advanced: true, }, { Name: "include_archived", Default: false, Help: `Also view and download archived media. By default, rclone does not request archived media. Thus, when syncing, archived media is not visible in directory listings or transferred. Note that media in albums is always visible and synced, no matter their archive status. With this flag, archived media are always visible in directory listings and transferred. Without this flag, archived media will not be visible in directory listings and won't be transferred.`, Advanced: true, }, { Name: "proxy", Default: "", Help: strings.ReplaceAll(`Use the gphotosdl proxy for downloading the full resolution images The Google API will deliver images and video which aren't full resolution, and/or have EXIF data missing. However if you use the gphotosdl proxy then you can download original, unchanged images. This runs a headless browser in the background. Download the software from [gphotosdl](https://github.com/rclone/gphotosdl) First run with gphotosdl -login Then once you have logged into google photos close the browser window and run gphotosdl Then supply the parameter |--gphotos-proxy "http://localhost:8282"| to make rclone use the proxy. `, "|", "`"), Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: (encoder.Base | encoder.EncodeCrLf | encoder.EncodeInvalidUtf8), }}...), defaultBatcherOptions.FsOptions("")...), }) } // Options defines the configuration for this backend type Options struct { ReadOnly bool `config:"read_only"` ReadSize bool `config:"read_size"` StartYear int `config:"start_year"` IncludeArchived bool `config:"include_archived"` Enc encoder.MultiEncoder `config:"encoding"` BatchMode string `config:"batch_mode"` BatchSize int `config:"batch_size"` BatchTimeout fs.Duration `config:"batch_timeout"` Proxy string `config:"proxy"` } // Fs represents a remote storage server type Fs struct { name string // name of this remote root string // the path we are working on if any opt Options // parsed options features *fs.Features // optional features unAuth *rest.Client // unauthenticated http client srv *rest.Client // the connection to the server ts *oauthutil.TokenSource // token source for oauth2 pacer *fs.Pacer // To pace the API calls startTime time.Time // time Fs was started - used for datestamps albumsMu sync.Mutex // protect albums (but not contents) albums map[bool]*albums // albums, shared or not uploadedMu sync.Mutex // to protect the below uploaded dirtree.DirTree // record of uploaded items createMu sync.Mutex // held when creating albums to prevent dupes batcher *batcher.Batcher[uploadedItem, *api.MediaItem] } // Object describes a storage object // // Will definitely have info but maybe not meta type Object struct { fs *Fs // what this object is part of remote string // The remote path url string // download path id string // ID of this object bytes int64 // Bytes in the object modTime time.Time // Modified time of the object mimeType string } // ------------------------------------------------------------ // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("Google Photos path %q", f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // dirTime returns the time to set a directory to func (f *Fs) dirTime() time.Time { return f.startTime } // startYear returns the start year func (f *Fs) startYear() int { return f.opt.StartYear } func (f *Fs) includeArchived() bool { return f.opt.IncludeArchived } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 429, // Too Many Requests. 500, // Internal Server Error 502, // Bad Gateway 503, // Service Unavailable 504, // Gateway Timeout 509, // Bandwidth Limit Exceeded } // shouldRetry returns a boolean as to whether this resp and err // deserve to be retried. It returns the err as a convenience func shouldRetry(ctx context.Context, resp *http.Response, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } return fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(resp, retryErrorCodes), err } // errorHandler parses a non 2xx error response into an error func errorHandler(resp *http.Response) error { body, err := rest.ReadBody(resp) if err != nil { body = nil } // Google sends 404 messages as images so be prepared for that if strings.HasPrefix(resp.Header.Get("Content-Type"), "image/") { body = []byte("Image not found or broken") } e := api.Error{ Details: api.ErrorDetails{ Code: resp.StatusCode, Message: string(body), Status: resp.Status, }, } if body != nil { _ = json.Unmarshal(body, &e) } return &e } // NewFs constructs an Fs from the path, bucket:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } baseClient := fshttp.NewClient(ctx) oAuthClient, ts, err := oauthutil.NewClientWithBaseClient(ctx, name, m, oauthConfig, baseClient) if err != nil { return nil, fmt.Errorf("failed to configure google photos: %w", err) } root = strings.Trim(path.Clean(root), "/") if root == "." || root == "/" { root = "" } f := &Fs{ name: name, root: root, opt: *opt, unAuth: rest.NewClient(baseClient), srv: rest.NewClient(oAuthClient).SetRoot(rootURL), ts: ts, pacer: fs.NewPacer(ctx, pacer.NewGoogleDrive(pacer.MinSleep(minSleep))), startTime: time.Now(), albums: map[bool]*albums{}, uploaded: dirtree.New(), } batcherOptions := defaultBatcherOptions batcherOptions.Mode = f.opt.BatchMode batcherOptions.Size = f.opt.BatchSize batcherOptions.Timeout = time.Duration(f.opt.BatchTimeout) f.batcher, err = batcher.New(ctx, f, f.commitBatch, batcherOptions) if err != nil { return nil, err } f.features = (&fs.Features{ ReadMimeType: true, }).Fill(ctx, f) f.srv.SetErrorHandler(errorHandler) _, _, pattern := patterns.match(f.root, "", true) if pattern != nil && pattern.isFile { oldRoot := f.root var leaf string f.root, leaf = path.Split(f.root) f.root = strings.TrimRight(f.root, "/") _, err := f.NewObject(ctx, leaf) if err == nil { return f, fs.ErrorIsFile } f.root = oldRoot } return f, nil } // fetchEndpoint gets the openid endpoint named from the Google config func (f *Fs) fetchEndpoint(ctx context.Context, name string) (endpoint string, err error) { // Get openID config without auth opts := rest.Opts{ Method: "GET", RootURL: "https://accounts.google.com/.well-known/openid-configuration", } var openIDconfig map[string]any err = f.pacer.Call(func() (bool, error) { resp, err := f.unAuth.CallJSON(ctx, &opts, nil, &openIDconfig) return shouldRetry(ctx, resp, err) }) if err != nil { return "", fmt.Errorf("couldn't read openID config: %w", err) } // Find userinfo endpoint endpoint, ok := openIDconfig[name].(string) if !ok { return "", fmt.Errorf("couldn't find %q from openID config", name) } return endpoint, nil } // UserInfo fetches info about the current user with oauth2 func (f *Fs) UserInfo(ctx context.Context) (userInfo map[string]string, err error) { endpoint, err := f.fetchEndpoint(ctx, "userinfo_endpoint") if err != nil { return nil, err } // Fetch the user info with auth opts := rest.Opts{ Method: "GET", RootURL: endpoint, } err = f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, nil, &userInfo) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't read user info: %w", err) } return userInfo, nil } // Disconnect kills the token and refresh token func (f *Fs) Disconnect(ctx context.Context) (err error) { endpoint, err := f.fetchEndpoint(ctx, "revocation_endpoint") if err != nil { return err } token, err := f.ts.Token() if err != nil { return err } // Revoke the token and the refresh token opts := rest.Opts{ Method: "POST", RootURL: endpoint, MultipartParams: url.Values{ "token": []string{token.AccessToken}, "token_type_hint": []string{"access_token"}, }, } var res any err = f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, &opts, nil, &res) return shouldRetry(ctx, resp, err) }) if err != nil { return fmt.Errorf("couldn't revoke token: %w", err) } fs.Infof(f, "res = %+v", res) return nil } // Return an Object from a path // // If it can't be found it returns the error fs.ErrorObjectNotFound. func (f *Fs) newObjectWithInfo(ctx context.Context, remote string, info *api.MediaItem) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } if info != nil { o.setMetaData(info) } else { err := o.readMetaData(ctx) // reads info and meta, returning an error if err != nil { return nil, err } } return o, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { // defer log.Trace(f, "remote=%q", remote)("") return f.newObjectWithInfo(ctx, remote, nil) } // addID adds the ID to name func addID(name string, ID string) string { idStr := "{" + ID + "}" if name == "" { return idStr } return name + " " + idStr } // addFileID adds the ID to the fileName passed in func addFileID(fileName string, ID string) string { ext := path.Ext(fileName) base := fileName[:len(fileName)-len(ext)] return addID(base, ID) + ext } var idRe = regexp.MustCompile(`\{([A-Za-z0-9_-]{55,})\}`) // findID finds an ID in string if one is there or "" func findID(name string) string { match := idRe.FindStringSubmatch(name) if match == nil { return "" } return match[1] } // list the albums into an internal cache // FIXME cache invalidation func (f *Fs) listAlbums(ctx context.Context, shared bool) (all *albums, err error) { f.albumsMu.Lock() defer f.albumsMu.Unlock() all, ok := f.albums[shared] if ok && all != nil { return all, nil } opts := rest.Opts{ Method: "GET", Path: "/albums", Parameters: url.Values{}, } if shared { opts.Path = "/sharedAlbums" } all = newAlbums() opts.Parameters.Set("pageSize", strconv.Itoa(albumChunks)) lastID := "" for { var result api.ListAlbums var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't list albums: %w", err) } newAlbums := result.Albums if shared { newAlbums = result.SharedAlbums } if len(newAlbums) > 0 && newAlbums[0].ID == lastID { // skip first if ID duplicated from last page newAlbums = newAlbums[1:] } if len(newAlbums) > 0 { lastID = newAlbums[len(newAlbums)-1].ID } for i := range newAlbums { anAlbum := newAlbums[i] anAlbum.Title = f.opt.Enc.FromStandardPath(anAlbum.Title) all.add(&anAlbum) } if result.NextPageToken == "" { break } opts.Parameters.Set("pageToken", result.NextPageToken) } f.albums[shared] = all return all, nil } // listFn is called from list to handle an object. type listFn func(remote string, object *api.MediaItem, isDirectory bool) error // list the objects into the function supplied // // dir is the starting directory, "" for root // // Set recurse to read sub directories func (f *Fs) list(ctx context.Context, filter api.SearchFilter, fn listFn) (err error) { opts := rest.Opts{ Method: "POST", Path: "/mediaItems:search", } filter.PageSize = listChunks filter.PageToken = "" if filter.AlbumID == "" { // album ID and filters cannot be set together, else error 400 INVALID_ARGUMENT if filter.Filters == nil { filter.Filters = &api.Filters{} } filter.Filters.IncludeArchivedMedia = &f.opt.IncludeArchived } lastID := "" for { var result api.MediaItems var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, &filter, &result) return shouldRetry(ctx, resp, err) }) if err != nil { return fmt.Errorf("couldn't list files: %w", err) } items := result.MediaItems if len(items) > 0 && items[0].ID == lastID { // skip first if ID duplicated from last page items = items[1:] } if len(items) > 0 { lastID = items[len(items)-1].ID } for i := range items { item := &result.MediaItems[i] remote := item.Filename remote = strings.ReplaceAll(remote, "/", "／") err = fn(remote, item, false) if err != nil { return err } } if result.NextPageToken == "" { break } filter.PageToken = result.NextPageToken } return nil } // Convert a list item into a DirEntry func (f *Fs) itemToDirEntry(ctx context.Context, remote string, item *api.MediaItem, isDirectory bool) (fs.DirEntry, error) { if isDirectory { d := fs.NewDir(remote, f.dirTime()) return d, nil } o := &Object{ fs: f, remote: remote, } o.setMetaData(item) return o, nil } // listDir lists a single directory func (f *Fs) listDir(ctx context.Context, prefix string, filter api.SearchFilter) (entries fs.DirEntries, err error) { // List the objects err = f.list(ctx, filter, func(remote string, item *api.MediaItem, isDirectory bool) error { entry, err := f.itemToDirEntry(ctx, prefix+remote, item, isDirectory) if err != nil { return err } entries = append(entries, entry) return nil }) if err != nil { return nil, err } // Dedupe the file names dupes := map[string]int{} for _, entry := range entries { o, ok := entry.(*Object) if ok { dupes[o.remote]++ } } for _, entry := range entries { o, ok := entry.(*Object) if ok { duplicated := dupes[o.remote] > 1 if duplicated || o.remote == "" { o.remote = addFileID(o.remote, o.id) } } } return entries, err } // listUploads lists a single directory from the uploads func (f *Fs) listUploads(ctx context.Context, dir string) (entries fs.DirEntries, err error) { f.uploadedMu.Lock() entries, ok := f.uploaded[dir] f.uploadedMu.Unlock() if !ok && dir != "" { return nil, fs.ErrorDirNotFound } return entries, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { // defer log.Trace(f, "dir=%q", dir)("err=%v", &err) match, prefix, pattern := patterns.match(f.root, dir, false) if pattern == nil || pattern.isFile { return nil, fs.ErrorDirNotFound } if pattern.toEntries != nil { return pattern.toEntries(ctx, f, prefix, match) } return nil, fs.ErrorDirNotFound } // Put the object into the bucket // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { // defer log.Trace(f, "src=%+v", src)("") // Temporary Object under construction o := &Object{ fs: f, remote: src.Remote(), } return o, o.Update(ctx, in, src, options...) } // createAlbum creates the album func (f *Fs) createAlbum(ctx context.Context, albumTitle string) (album *api.Album, err error) { opts := rest.Opts{ Method: "POST", Path: "/albums", Parameters: url.Values{}, } request := api.CreateAlbum{ Album: &api.Album{ Title: albumTitle, }, } var result api.Album var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, request, &result) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, fmt.Errorf("couldn't create album: %w", err) } f.albums[false].add(&result) return &result, nil } // getOrCreateAlbum gets an existing album or creates a new one // // It does the creation with the lock held to avoid duplicates func (f *Fs) getOrCreateAlbum(ctx context.Context, albumTitle string) (album *api.Album, err error) { f.createMu.Lock() defer f.createMu.Unlock() albums, err := f.listAlbums(ctx, false) if err != nil { return nil, err } album, ok := albums.get(albumTitle) if ok { return album, nil } return f.createAlbum(ctx, albumTitle) } // Mkdir creates the album if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) (err error) { // defer log.Trace(f, "dir=%q", dir)("err=%v", &err) match, prefix, pattern := patterns.match(f.root, dir, false) if pattern == nil { return fs.ErrorDirNotFound } if !pattern.canMkdir { return errCantMkdir } if pattern.isUpload { f.uploadedMu.Lock() d := fs.NewDir(strings.Trim(prefix, "/"), f.dirTime()) f.uploaded.AddEntry(d) f.uploadedMu.Unlock() return nil } albumTitle := match[1] _, err = f.getOrCreateAlbum(ctx, albumTitle) return err } // Rmdir deletes the bucket if the fs is at the root // // Returns an error if it isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) (err error) { // defer log.Trace(f, "dir=%q")("err=%v", &err) match, _, pattern := patterns.match(f.root, dir, false) if pattern == nil { return fs.ErrorDirNotFound } if !pattern.canMkdir { return errCantRmdir } if pattern.isUpload { f.uploadedMu.Lock() err = f.uploaded.Prune(map[string]bool{ dir: true, }) f.uploadedMu.Unlock() return err } albumTitle := match[1] allAlbums, err := f.listAlbums(ctx, false) if err != nil { return err } album, ok := allAlbums.get(albumTitle) if !ok { return fs.ErrorDirNotFound } _ = album return errAlbumDelete } // Precision returns the precision func (f *Fs) Precision() time.Duration { return fs.ModTimeNotSupported } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hash.None) } // Shutdown the backend, closing any background tasks and any // cached connections. func (f *Fs) Shutdown(ctx context.Context) error { f.batcher.Shutdown() return nil } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Hash returns the Md5sum of an object returning a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { return "", hash.ErrUnsupported } // Size returns the size of an object in bytes func (o *Object) Size() int64 { // defer log.Trace(o, "")("") if !o.fs.opt.ReadSize || o.bytes >= 0 { return o.bytes } ctx := context.TODO() err := o.readMetaData(ctx) if err != nil { fs.Debugf(o, "Size: Failed to read metadata: %v", err) return -1 } var resp *http.Response opts := rest.Opts{ Method: "HEAD", RootURL: o.downloadURL(), } err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.Call(ctx, &opts) return shouldRetry(ctx, resp, err) }) if err != nil { fs.Debugf(o, "Reading size failed: %v", err) } else { lengthStr := resp.Header.Get("Content-Length") length, err := strconv.ParseInt(lengthStr, 10, 64) if err != nil { fs.Debugf(o, "Reading size failed to parse Content_length %q: %v", lengthStr, err) } else { o.bytes = length } } return o.bytes } // setMetaData sets the fs data from a storage.Object func (o *Object) setMetaData(info *api.MediaItem) { o.url = info.BaseURL o.id = info.ID o.bytes = -1 // FIXME o.mimeType = info.MimeType o.modTime = info.MediaMetadata.CreationTime } // readMetaData gets the metadata if it hasn't already been fetched // // it also sets the info func (o *Object) readMetaData(ctx context.Context) (err error) { if !o.modTime.IsZero() && o.url != "" { return nil } dir, fileName := path.Split(o.remote) dir = strings.Trim(dir, "/") _, _, pattern := patterns.match(o.fs.root, o.remote, true) if pattern == nil { return fs.ErrorObjectNotFound } if !pattern.isFile { return fs.ErrorNotAFile } // If have ID fetch it directly if id := findID(fileName); id != "" { opts := rest.Opts{ Method: "GET", Path: "/mediaItems/" + id, } var item api.MediaItem var resp *http.Response err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.CallJSON(ctx, &opts, nil, &item) return shouldRetry(ctx, resp, err) }) if err != nil { return fmt.Errorf("couldn't get media item: %w", err) } o.setMetaData(&item) return nil } // Otherwise list the directory the file is in entries, err := o.fs.List(ctx, dir) if err != nil { if err == fs.ErrorDirNotFound { return fs.ErrorObjectNotFound } return err } // and find the file in the directory for _, entry := range entries { if entry.Remote() == o.remote { if newO, ok := entry.(*Object); ok { *o = *newO return nil } } } return fs.ErrorObjectNotFound } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers func (o *Object) ModTime(ctx context.Context) time.Time { // defer log.Trace(o, "")("") err := o.readMetaData(ctx) if err != nil { fs.Debugf(o, "ModTime: Failed to read metadata: %v", err) return time.Now() } return o.modTime } // SetModTime sets the modification time of the local fs object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) (err error) { return fs.ErrorCantSetModTime } // Storable returns a boolean as to whether this object is storable func (o *Object) Storable() bool { return true } // downloadURL returns the URL for a full bytes download for the object func (o *Object) downloadURL() string { url := o.url + "=d" if strings.HasPrefix(o.mimeType, "video/") { url += "v" } return url } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { // defer log.Trace(o, "")("") err = o.readMetaData(ctx) if err != nil { fs.Debugf(o, "Open: Failed to read metadata: %v", err) return nil, err } url := o.downloadURL() if o.fs.opt.Proxy != "" { url = strings.TrimRight(o.fs.opt.Proxy, "/") + "/id/" + o.id } var resp *http.Response opts := rest.Opts{ Method: "GET", RootURL: url, Options: options, } err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.Call(ctx, &opts) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } return resp.Body, err } // input to the batcher type uploadedItem struct { AlbumID string // desired album UploadToken string // upload ID } // Commit a batch of items to albumID returning the errors in errors func (f *Fs) commitBatchAlbumID(ctx context.Context, items []uploadedItem, results []*api.MediaItem, errors []error, albumID string) { // Create the media item from an UploadToken, optionally adding to an album opts := rest.Opts{ Method: "POST", Path: "/mediaItems:batchCreate", } request := api.BatchCreateRequest{ AlbumID: albumID, } itemsInBatch := 0 for i := range items { if items[i].AlbumID == albumID { request.NewMediaItems = append(request.NewMediaItems, api.NewMediaItem{ SimpleMediaItem: api.SimpleMediaItem{ UploadToken: items[i].UploadToken, }, }) itemsInBatch++ } } var result api.BatchCreateResponse var resp *http.Response var err error err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, request, &result) return shouldRetry(ctx, resp, err) }) if err != nil { err = fmt.Errorf("failed to create media item: %w", err) } if err == nil && len(result.NewMediaItemResults) != itemsInBatch { err = fmt.Errorf("bad response to BatchCreate expecting %d items but got %d", itemsInBatch, len(result.NewMediaItemResults)) } j := 0 for i := range items { if items[i].AlbumID == albumID { if err == nil { media := &result.NewMediaItemResults[j] if media.Status.Code != 0 { errors[i] = fmt.Errorf("upload failed: %s (%d)", media.Status.Message, media.Status.Code) } else { results[i] = &media.MediaItem } } else { errors[i] = err } j++ } } } // Called by the batcher to commit a batch func (f *Fs) commitBatch(ctx context.Context, items []uploadedItem, results []*api.MediaItem, errors []error) (err error) { // Discover all the AlbumIDs as we have to upload these separately // // Should maybe have one batcher per AlbumID albumIDs := map[string]struct{}{} for i := range items { albumIDs[items[i].AlbumID] = struct{}{} } // batch the albums for albumID := range albumIDs { // errors returned in errors f.commitBatchAlbumID(ctx, items, results, errors, albumID) } return nil } // Update the object with the contents of the io.Reader, modTime and size // // The new object may have been created if an error is returned func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { // defer log.Trace(o, "src=%+v", src)("err=%v", &err) match, _, pattern := patterns.match(o.fs.root, o.remote, true) if pattern == nil || !pattern.isFile || !pattern.canUpload { return errCantUpload } var ( albumID string fileName string ) if pattern.isUpload { fileName = match[1] } else { var albumTitle string albumTitle, fileName = match[1], match[2] album, err := o.fs.getOrCreateAlbum(ctx, albumTitle) if err != nil { return err } if !album.IsWriteable { if o.fs.opt.ReadOnly { return errReadOnly } return errOwnAlbums } albumID = album.ID } // Upload the media item in exchange for an UploadToken opts := rest.Opts{ Method: "POST", Path: "/uploads", Options: options, ExtraHeaders: map[string]string{ "X-Goog-Upload-File-Name": fileName, "X-Goog-Upload-Protocol": "raw", }, Body: in, } var token []byte var resp *http.Response err = o.fs.pacer.CallNoRetry(func() (bool, error) { resp, err = o.fs.srv.Call(ctx, &opts) if err != nil { return shouldRetry(ctx, resp, err) } token, err = rest.ReadBody(resp) return shouldRetry(ctx, resp, err) }) if err != nil { return fmt.Errorf("couldn't upload file: %w", err) } uploadToken := strings.TrimSpace(string(token)) if uploadToken == "" { return errors.New("empty upload token") } uploaded := uploadedItem{ AlbumID: albumID, UploadToken: uploadToken, } // Save the upload into an album var info *api.MediaItem if o.fs.batcher.Batching() { info, err = o.fs.batcher.Commit(ctx, o.remote, uploaded) } else { errors := make([]error, 1) results := make([]*api.MediaItem, 1) err = o.fs.commitBatch(ctx, []uploadedItem{uploaded}, results, errors) if err == nil { err = errors[0] info = results[0] } } if err != nil { return fmt.Errorf("failed to commit batch: %w", err) } o.setMetaData(info) // Add upload to internal storage if pattern.isUpload { o.fs.uploadedMu.Lock() o.fs.uploaded.AddEntry(o) o.fs.uploadedMu.Unlock() } return nil } // Remove an object func (o *Object) Remove(ctx context.Context) (err error) { match, _, pattern := patterns.match(o.fs.root, o.remote, true) if pattern == nil || !pattern.isFile || !pattern.canUpload || pattern.isUpload { return errRemove } albumTitle, fileName := match[1], match[2] album, ok := o.fs.albums[false].get(albumTitle) if !ok { return fmt.Errorf("couldn't file %q in album %q for delete", fileName, albumTitle) } opts := rest.Opts{ Method: "POST", Path: "/albums/" + album.ID + ":batchRemoveMediaItems", NoResponse: true, } request := api.BatchRemoveItems{ MediaItemIDs: []string{o.id}, } var resp *http.Response err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.CallJSON(ctx, &opts, &request, nil) return shouldRetry(ctx, resp, err) }) if err != nil { return fmt.Errorf("couldn't delete item from album: %w", err) } return nil } // MimeType of an Object if known, "" otherwise func (o *Object) MimeType(ctx context.Context) string { return o.mimeType } // ID of an Object if known, "" otherwise func (o *Object) ID() string { return o.id } // Check the interfaces are satisfied var ( _ fs.Fs = &Fs{} _ fs.UserInfoer = &Fs{} _ fs.Disconnecter = &Fs{} _ fs.Object = &Object{} _ fs.MimeTyper = &Object{} _ fs.IDer = &Object{} ) rclone-v1.71.0/backend/googlephotos/googlephotos_test.go000066400000000000000000000202501505210326400234440ustar00rootroot00000000000000package googlephotos import ( "context" "errors" "fmt" "io" "net/http" "path" "testing" "time" _ "github.com/rclone/rclone/backend/local" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/lib/random" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) const ( // We have two different files here as Google Photos will uniq // them otherwise which confuses the tests as the filename is // unexpected. fileNameAlbum = "rclone-test-image1.jpg" fileNameUpload = "rclone-test-image2.jpg" ) func TestIntegration(t *testing.T) { ctx := context.Background() fstest.Initialise() // Create Fs if *fstest.RemoteName == "" { *fstest.RemoteName = "TestGooglePhotos:" } f, err := fs.NewFs(ctx, *fstest.RemoteName) if errors.Is(err, fs.ErrorNotFoundInConfigFile) { t.Skipf("Couldn't create google photos backend - skipping tests: %v", err) } require.NoError(t, err) // Create local Fs pointing at testfiles localFs, err := fs.NewFs(ctx, "testfiles") require.NoError(t, err) t.Run("CreateAlbum", func(t *testing.T) { albumName := "album/rclone-test-" + random.String(24) err = f.Mkdir(ctx, albumName) require.NoError(t, err) remote := albumName + "/" + fileNameAlbum t.Run("PutFile", func(t *testing.T) { srcObj, err := localFs.NewObject(ctx, fileNameAlbum) require.NoError(t, err) in, err := srcObj.Open(ctx) require.NoError(t, err) dstObj, err := f.Put(ctx, in, fs.NewOverrideRemote(srcObj, remote)) require.NoError(t, err) assert.Equal(t, remote, dstObj.Remote()) _ = in.Close() remoteWithID := addFileID(remote, dstObj.(*Object).id) t.Run("ObjectFs", func(t *testing.T) { assert.Equal(t, f, dstObj.Fs()) }) t.Run("ObjectString", func(t *testing.T) { assert.Equal(t, remote, dstObj.String()) assert.Equal(t, "", (*Object)(nil).String()) }) t.Run("ObjectHash", func(t *testing.T) { h, err := dstObj.Hash(ctx, hash.MD5) assert.Equal(t, "", h) assert.Equal(t, hash.ErrUnsupported, err) }) t.Run("ObjectSize", func(t *testing.T) { assert.Equal(t, int64(-1), dstObj.Size()) f.(*Fs).opt.ReadSize = true defer func() { f.(*Fs).opt.ReadSize = false }() size := dstObj.Size() assert.True(t, size > 1000, fmt.Sprintf("Size too small %d", size)) }) t.Run("ObjectSetModTime", func(t *testing.T) { err := dstObj.SetModTime(ctx, time.Now()) assert.Equal(t, fs.ErrorCantSetModTime, err) }) t.Run("ObjectStorable", func(t *testing.T) { assert.True(t, dstObj.Storable()) }) t.Run("ObjectOpen", func(t *testing.T) { in, err := dstObj.Open(ctx) require.NoError(t, err) buf, err := io.ReadAll(in) require.NoError(t, err) require.NoError(t, in.Close()) assert.True(t, len(buf) > 1000) contentType := http.DetectContentType(buf[:512]) assert.Equal(t, "image/jpeg", contentType) }) t.Run("CheckFileInAlbum", func(t *testing.T) { entries, err := f.List(ctx, albumName) require.NoError(t, err) assert.Equal(t, 1, len(entries)) assert.Equal(t, remote, entries[0].Remote()) assert.Equal(t, "2013-07-26 08:57:21 +0000 UTC", entries[0].ModTime(ctx).String()) }) // Check it is there in the date/month/year hierarchy // 2013-07-13 is the creation date of the folder checkPresent := func(t *testing.T, objPath string) { entries, err := f.List(ctx, objPath) require.NoError(t, err) found := false for _, entry := range entries { leaf := path.Base(entry.Remote()) if leaf == fileNameAlbum || leaf == remoteWithID { found = true } } assert.True(t, found, fmt.Sprintf("didn't find %q in %q", fileNameAlbum, objPath)) } t.Run("CheckInByYear", func(t *testing.T) { checkPresent(t, "media/by-year/2013") }) t.Run("CheckInByMonth", func(t *testing.T) { checkPresent(t, "media/by-month/2013/2013-07") }) t.Run("CheckInByDay", func(t *testing.T) { checkPresent(t, "media/by-day/2013/2013-07-26") }) t.Run("NewObject", func(t *testing.T) { o, err := f.NewObject(ctx, remote) require.NoError(t, err) require.Equal(t, remote, o.Remote()) }) t.Run("NewObjectWithID", func(t *testing.T) { o, err := f.NewObject(ctx, remoteWithID) require.NoError(t, err) require.Equal(t, remoteWithID, o.Remote()) }) t.Run("NewFsIsFile", func(t *testing.T) { fNew, err := fs.NewFs(ctx, *fstest.RemoteName+remote) assert.Equal(t, fs.ErrorIsFile, err) leaf := path.Base(remote) o, err := fNew.NewObject(ctx, leaf) require.NoError(t, err) require.Equal(t, leaf, o.Remote()) }) t.Run("RemoveFileFromAlbum", func(t *testing.T) { err = dstObj.Remove(ctx) require.NoError(t, err) time.Sleep(time.Second) // Check album empty entries, err := f.List(ctx, albumName) require.NoError(t, err) assert.Equal(t, 0, len(entries)) }) }) // remove the album err = f.Rmdir(ctx, albumName) require.Error(t, err) // FIXME doesn't work yet }) t.Run("UploadMkdir", func(t *testing.T) { assert.NoError(t, f.Mkdir(ctx, "upload/dir")) assert.NoError(t, f.Mkdir(ctx, "upload/dir/subdir")) t.Run("List", func(t *testing.T) { entries, err := f.List(ctx, "upload") require.NoError(t, err) assert.Equal(t, 1, len(entries)) assert.Equal(t, "upload/dir", entries[0].Remote()) entries, err = f.List(ctx, "upload/dir") require.NoError(t, err) assert.Equal(t, 1, len(entries)) assert.Equal(t, "upload/dir/subdir", entries[0].Remote()) }) t.Run("Rmdir", func(t *testing.T) { assert.NoError(t, f.Rmdir(ctx, "upload/dir/subdir")) assert.NoError(t, f.Rmdir(ctx, "upload/dir")) }) t.Run("ListEmpty", func(t *testing.T) { entries, err := f.List(ctx, "upload") require.NoError(t, err) assert.Equal(t, 0, len(entries)) _, err = f.List(ctx, "upload/dir") assert.Equal(t, fs.ErrorDirNotFound, err) }) }) t.Run("Upload", func(t *testing.T) { uploadDir := "upload/dir/subdir" remote := path.Join(uploadDir, fileNameUpload) srcObj, err := localFs.NewObject(ctx, fileNameUpload) require.NoError(t, err) in, err := srcObj.Open(ctx) require.NoError(t, err) dstObj, err := f.Put(ctx, in, fs.NewOverrideRemote(srcObj, remote)) require.NoError(t, err) assert.Equal(t, remote, dstObj.Remote()) _ = in.Close() remoteWithID := addFileID(remote, dstObj.(*Object).id) t.Run("List", func(t *testing.T) { entries, err := f.List(ctx, uploadDir) require.NoError(t, err) require.Equal(t, 1, len(entries)) assert.Equal(t, remote, entries[0].Remote()) assert.Equal(t, "2013-07-26 08:57:21 +0000 UTC", entries[0].ModTime(ctx).String()) }) t.Run("NewObject", func(t *testing.T) { o, err := f.NewObject(ctx, remote) require.NoError(t, err) require.Equal(t, remote, o.Remote()) }) t.Run("NewObjectWithID", func(t *testing.T) { o, err := f.NewObject(ctx, remoteWithID) require.NoError(t, err) require.Equal(t, remoteWithID, o.Remote()) }) }) t.Run("Name", func(t *testing.T) { assert.Equal(t, (*fstest.RemoteName)[:len(*fstest.RemoteName)-1], f.Name()) }) t.Run("Root", func(t *testing.T) { assert.Equal(t, "", f.Root()) }) t.Run("String", func(t *testing.T) { assert.Equal(t, `Google Photos path ""`, f.String()) }) t.Run("Features", func(t *testing.T) { features := f.Features() assert.False(t, features.CaseInsensitive) assert.True(t, features.ReadMimeType) }) t.Run("Precision", func(t *testing.T) { assert.Equal(t, fs.ModTimeNotSupported, f.Precision()) }) t.Run("Hashes", func(t *testing.T) { assert.Equal(t, hash.Set(hash.None), f.Hashes()) }) } func TestAddID(t *testing.T) { assert.Equal(t, "potato {123}", addID("potato", "123")) assert.Equal(t, "{123}", addID("", "123")) } func TestFileAddID(t *testing.T) { assert.Equal(t, "potato {123}.txt", addFileID("potato.txt", "123")) assert.Equal(t, "potato {123}", addFileID("potato", "123")) assert.Equal(t, "{123}", addFileID("", "123")) } func TestFindID(t *testing.T) { assert.Equal(t, "", findID("potato")) ID := "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" assert.Equal(t, ID, findID("potato {"+ID+"}.txt")) ID = ID[1:] assert.Equal(t, "", findID("potato {"+ID+"}.txt")) } rclone-v1.71.0/backend/googlephotos/pattern.go000066400000000000000000000245101505210326400213540ustar00rootroot00000000000000// Store the parsing of file patterns package googlephotos import ( "context" "fmt" "path" "regexp" "strconv" "strings" "time" "github.com/rclone/rclone/backend/googlephotos/api" "github.com/rclone/rclone/fs" ) // lister describes the subset of the interfaces on Fs needed for the // file pattern parsing type lister interface { listDir(ctx context.Context, prefix string, filter api.SearchFilter) (entries fs.DirEntries, err error) listAlbums(ctx context.Context, shared bool) (all *albums, err error) listUploads(ctx context.Context, dir string) (entries fs.DirEntries, err error) dirTime() time.Time startYear() int includeArchived() bool } // dirPattern describes a single directory pattern type dirPattern struct { re string // match for the path match *regexp.Regexp // compiled match canUpload bool // true if can upload here canMkdir bool // true if can make a directory here isFile bool // true if this is a file isUpload bool // true if this is the upload directory // function to turn a match into DirEntries toEntries func(ctx context.Context, f lister, prefix string, match []string) (fs.DirEntries, error) } // dirPatterns is a slice of all the directory patterns type dirPatterns []dirPattern // patterns describes the layout of the google photos backend file system. // // NB no trailing / on paths var patterns = dirPatterns{ { re: `^$`, toEntries: func(ctx context.Context, f lister, prefix string, match []string) (fs.DirEntries, error) { return fs.DirEntries{ fs.NewDir(prefix+"media", f.dirTime()), fs.NewDir(prefix+"album", f.dirTime()), fs.NewDir(prefix+"shared-album", f.dirTime()), fs.NewDir(prefix+"upload", f.dirTime()), fs.NewDir(prefix+"feature", f.dirTime()), }, nil }, }, { re: `^upload(?:/(.*))?$`, toEntries: func(ctx context.Context, f lister, prefix string, match []string) (fs.DirEntries, error) { return f.listUploads(ctx, match[0]) }, canUpload: true, canMkdir: true, isUpload: true, }, { re: `^upload/(.*)$`, isFile: true, canUpload: true, isUpload: true, }, { re: `^media$`, toEntries: func(ctx context.Context, f lister, prefix string, match []string) (fs.DirEntries, error) { return fs.DirEntries{ fs.NewDir(prefix+"all", f.dirTime()), fs.NewDir(prefix+"by-year", f.dirTime()), fs.NewDir(prefix+"by-month", f.dirTime()), fs.NewDir(prefix+"by-day", f.dirTime()), }, nil }, }, { re: `^media/all$`, toEntries: func(ctx context.Context, f lister, prefix string, match []string) (fs.DirEntries, error) { return f.listDir(ctx, prefix, api.SearchFilter{}) }, }, { re: `^media/all/([^/]+)$`, isFile: true, }, { re: `^media/by-year$`, toEntries: years, }, { re: `^media/by-year/(\d{4})$`, toEntries: func(ctx context.Context, f lister, prefix string, match []string) (fs.DirEntries, error) { filter, err := yearMonthDayFilter(ctx, f, match) if err != nil { return nil, err } return f.listDir(ctx, prefix, filter) }, }, { re: `^media/by-year/(\d{4})/([^/]+)$`, isFile: true, }, { re: `^media/by-month$`, toEntries: years, }, { re: `^media/by-month/(\d{4})$`, toEntries: months, }, { re: `^media/by-month/\d{4}/(\d{4})-(\d{2})$`, toEntries: func(ctx context.Context, f lister, prefix string, match []string) (fs.DirEntries, error) { filter, err := yearMonthDayFilter(ctx, f, match) if err != nil { return nil, err } return f.listDir(ctx, prefix, filter) }, }, { re: `^media/by-month/\d{4}/(\d{4})-(\d{2})/([^/]+)$`, isFile: true, }, { re: `^media/by-day$`, toEntries: years, }, { re: `^media/by-day/(\d{4})$`, toEntries: days, }, { re: `^media/by-day/\d{4}/(\d{4})-(\d{2})-(\d{2})$`, toEntries: func(ctx context.Context, f lister, prefix string, match []string) (fs.DirEntries, error) { filter, err := yearMonthDayFilter(ctx, f, match) if err != nil { return nil, err } return f.listDir(ctx, prefix, filter) }, }, { re: `^media/by-day/\d{4}/(\d{4})-(\d{2})-(\d{2})/([^/]+)$`, isFile: true, }, { re: `^album$`, toEntries: func(ctx context.Context, f lister, prefix string, match []string) (entries fs.DirEntries, err error) { return albumsToEntries(ctx, f, false, prefix, "") }, }, { re: `^album/(.+)$`, canMkdir: true, toEntries: func(ctx context.Context, f lister, prefix string, match []string) (entries fs.DirEntries, err error) { return albumsToEntries(ctx, f, false, prefix, match[1]) }, }, { re: `^album/(.+?)/([^/]+)$`, canUpload: true, isFile: true, }, { re: `^shared-album$`, toEntries: func(ctx context.Context, f lister, prefix string, match []string) (entries fs.DirEntries, err error) { return albumsToEntries(ctx, f, true, prefix, "") }, }, { re: `^shared-album/(.+)$`, toEntries: func(ctx context.Context, f lister, prefix string, match []string) (entries fs.DirEntries, err error) { return albumsToEntries(ctx, f, true, prefix, match[1]) }, }, { re: `^shared-album/(.+?)/([^/]+)$`, isFile: true, }, { re: `^feature$`, toEntries: func(ctx context.Context, f lister, prefix string, match []string) (entries fs.DirEntries, err error) { return fs.DirEntries{ fs.NewDir(prefix+"favorites", f.dirTime()), }, nil }, }, { re: `^feature/favorites$`, toEntries: func(ctx context.Context, f lister, prefix string, match []string) (entries fs.DirEntries, err error) { filter := featureFilter(ctx, f, match) if err != nil { return nil, err } return f.listDir(ctx, prefix, filter) }, }, { re: `^feature/favorites/([^/]+)$`, isFile: true, }, }.mustCompile() // mustCompile compiles the regexps in the dirPatterns func (ds dirPatterns) mustCompile() dirPatterns { for i := range ds { pattern := &ds[i] pattern.match = regexp.MustCompile(pattern.re) } return ds } // match finds the path passed in the matching structure and // returns the parameters and a pointer to the match, or nil. func (ds dirPatterns) match(root string, itemPath string, isFile bool) (match []string, prefix string, pattern *dirPattern) { itemPath = strings.Trim(itemPath, "/") absPath := path.Join(root, itemPath) prefix = strings.Trim(absPath[len(root):], "/") if prefix != "" { prefix += "/" } for i := range ds { pattern = &ds[i] if pattern.isFile != isFile { continue } match = pattern.match.FindStringSubmatch(absPath) if match != nil { return } } return nil, "", nil } // Return the years from startYear to today func years(ctx context.Context, f lister, prefix string, match []string) (entries fs.DirEntries, err error) { currentYear := f.dirTime().Year() for year := f.startYear(); year <= currentYear; year++ { entries = append(entries, fs.NewDir(prefix+fmt.Sprint(year), f.dirTime())) } return entries, nil } // Return the months in a given year func months(ctx context.Context, f lister, prefix string, match []string) (entries fs.DirEntries, err error) { year := match[1] for month := 1; month <= 12; month++ { entries = append(entries, fs.NewDir(fmt.Sprintf("%s%s-%02d", prefix, year, month), f.dirTime())) } return entries, nil } // Return the days in a given year func days(ctx context.Context, f lister, prefix string, match []string) (entries fs.DirEntries, err error) { year := match[1] current, err := time.Parse("2006", year) if err != nil { return nil, fmt.Errorf("bad year %q", match[1]) } currentYear := current.Year() for current.Year() == currentYear { entries = append(entries, fs.NewDir(prefix+current.Format("2006-01-02"), f.dirTime())) current = current.AddDate(0, 0, 1) } return entries, nil } // This creates a search filter on year/month/day as provided func yearMonthDayFilter(ctx context.Context, f lister, match []string) (sf api.SearchFilter, err error) { year, err := strconv.Atoi(match[1]) if err != nil || year < 1000 || year > 3000 { return sf, fmt.Errorf("bad year %q", match[1]) } sf = api.SearchFilter{ Filters: &api.Filters{ DateFilter: &api.DateFilter{ Dates: []api.Date{ { Year: year, }, }, }, }, } if len(match) >= 3 { month, err := strconv.Atoi(match[2]) if err != nil || month < 1 || month > 12 { return sf, fmt.Errorf("bad month %q", match[2]) } sf.Filters.DateFilter.Dates[0].Month = month } if len(match) >= 4 { day, err := strconv.Atoi(match[3]) if err != nil || day < 1 || day > 31 { return sf, fmt.Errorf("bad day %q", match[3]) } sf.Filters.DateFilter.Dates[0].Day = day } return sf, nil } // featureFilter creates a filter for the Feature enum // // The API only supports one feature, FAVORITES, so hardcode that feature. // // https://developers.google.com/photos/library/reference/rest/v1/mediaItems/search#FeatureFilter func featureFilter(ctx context.Context, f lister, match []string) (sf api.SearchFilter) { sf = api.SearchFilter{ Filters: &api.Filters{ FeatureFilter: &api.FeatureFilter{ IncludedFeatures: []string{ "FAVORITES", }, }, }, } return sf } // Turns an albumPath into entries // // These can either be synthetic directory entries if the album path // is a prefix of another album, or actual files, or a combination of // the two. func albumsToEntries(ctx context.Context, f lister, shared bool, prefix string, albumPath string) (entries fs.DirEntries, err error) { albums, err := f.listAlbums(ctx, shared) if err != nil { return nil, err } // Put in the directories dirs, foundAlbumPath := albums.getDirs(albumPath) if foundAlbumPath { for _, dir := range dirs { d := fs.NewDir(prefix+dir, f.dirTime()) dirPath := path.Join(albumPath, dir) // if this dir is an album add more special stuff album, ok := albums.get(dirPath) if ok { count, err := strconv.ParseInt(album.MediaItemsCount, 10, 64) if err != nil { fs.Debugf(f, "Error reading media count: %v", err) } d.SetID(album.ID).SetItems(count) } entries = append(entries, d) } } // if this is an album then return a filter to list it album, foundAlbum := albums.get(albumPath) if foundAlbum { filter := api.SearchFilter{AlbumID: album.ID} newEntries, err := f.listDir(ctx, prefix, filter) if err != nil { return nil, err } entries = append(entries, newEntries...) } if !foundAlbumPath && !foundAlbum && albumPath != "" { return nil, fs.ErrorDirNotFound } return entries, nil } rclone-v1.71.0/backend/googlephotos/pattern_test.go000066400000000000000000000317511505210326400224200ustar00rootroot00000000000000package googlephotos import ( "context" "fmt" "testing" "time" "github.com/rclone/rclone/backend/googlephotos/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/dirtree" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/mockobject" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // time for directories var startTime = fstest.Time("2019-06-24T15:53:05.999999999Z") // mock Fs for testing patterns type testLister struct { t *testing.T albums *albums names []string uploaded dirtree.DirTree } // newTestLister makes a mock for testing func newTestLister(t *testing.T) *testLister { return &testLister{ t: t, albums: newAlbums(), uploaded: dirtree.New(), } } // mock listDir for testing func (f *testLister) listDir(ctx context.Context, prefix string, filter api.SearchFilter) (entries fs.DirEntries, err error) { for _, name := range f.names { entries = append(entries, mockobject.New(prefix+name)) } return entries, nil } // mock listAlbums for testing func (f *testLister) listAlbums(ctx context.Context, shared bool) (all *albums, err error) { return f.albums, nil } // mock listUploads for testing func (f *testLister) listUploads(ctx context.Context, dir string) (entries fs.DirEntries, err error) { entries = f.uploaded[dir] return entries, nil } // mock dirTime for testing func (f *testLister) dirTime() time.Time { return startTime } // mock startYear for testing func (f *testLister) startYear() int { return 2000 } // mock includeArchived for testing func (f *testLister) includeArchived() bool { return false } func TestPatternMatch(t *testing.T) { for testNumber, test := range []struct { // input root string itemPath string isFile bool // expected output wantMatch []string wantPrefix string wantPattern *dirPattern }{ { root: "", itemPath: "", isFile: false, wantMatch: []string{""}, wantPrefix: "", wantPattern: &patterns[0], }, { root: "", itemPath: "", isFile: true, wantMatch: nil, wantPrefix: "", wantPattern: nil, }, { root: "upload", itemPath: "", isFile: false, wantMatch: []string{"upload", ""}, wantPrefix: "", wantPattern: &patterns[1], }, { root: "upload/dir", itemPath: "", isFile: false, wantMatch: []string{"upload/dir", "dir"}, wantPrefix: "", wantPattern: &patterns[1], }, { root: "upload/file.jpg", itemPath: "", isFile: true, wantMatch: []string{"upload/file.jpg", "file.jpg"}, wantPrefix: "", wantPattern: &patterns[2], }, { root: "media", itemPath: "", isFile: false, wantMatch: []string{"media"}, wantPrefix: "", wantPattern: &patterns[3], }, { root: "", itemPath: "media", isFile: false, wantMatch: []string{"media"}, wantPrefix: "media/", wantPattern: &patterns[3], }, { root: "media/all", itemPath: "", isFile: false, wantMatch: []string{"media/all"}, wantPrefix: "", wantPattern: &patterns[4], }, { root: "media", itemPath: "all", isFile: false, wantMatch: []string{"media/all"}, wantPrefix: "all/", wantPattern: &patterns[4], }, { root: "media/all", itemPath: "file.jpg", isFile: true, wantMatch: []string{"media/all/file.jpg", "file.jpg"}, wantPrefix: "file.jpg/", wantPattern: &patterns[5], }, { root: "", itemPath: "feature", isFile: false, wantMatch: []string{"feature"}, wantPrefix: "feature/", wantPattern: &patterns[23], }, { root: "feature/favorites", itemPath: "", isFile: false, wantMatch: []string{"feature/favorites"}, wantPrefix: "", wantPattern: &patterns[24], }, { root: "feature", itemPath: "favorites", isFile: false, wantMatch: []string{"feature/favorites"}, wantPrefix: "favorites/", wantPattern: &patterns[24], }, { root: "feature/favorites", itemPath: "file.jpg", isFile: true, wantMatch: []string{"feature/favorites/file.jpg", "file.jpg"}, wantPrefix: "file.jpg/", wantPattern: &patterns[25], }, } { t.Run(fmt.Sprintf("#%d,root=%q,itemPath=%q,isFile=%v", testNumber, test.root, test.itemPath, test.isFile), func(t *testing.T) { gotMatch, gotPrefix, gotPattern := patterns.match(test.root, test.itemPath, test.isFile) assert.Equal(t, test.wantMatch, gotMatch) assert.Equal(t, test.wantPrefix, gotPrefix) assert.Equal(t, test.wantPattern, gotPattern) }) } } func TestPatternMatchToEntries(t *testing.T) { ctx := context.Background() f := newTestLister(t) f.names = []string{"file.jpg"} f.albums.add(&api.Album{ ID: "1", Title: "sub/one", }) f.albums.add(&api.Album{ ID: "2", Title: "sub", }) f.uploaded.AddEntry(mockobject.New("upload/file1.jpg")) f.uploaded.AddEntry(mockobject.New("upload/dir/file2.jpg")) for testNumber, test := range []struct { // input root string itemPath string // expected output wantMatch []string wantPrefix string remotes []string }{ { root: "", itemPath: "", wantMatch: []string{""}, wantPrefix: "", remotes: []string{"media/", "album/", "shared-album/", "upload/"}, }, { root: "upload", itemPath: "", wantMatch: []string{"upload", ""}, wantPrefix: "", remotes: []string{"upload/file1.jpg", "upload/dir/"}, }, { root: "upload", itemPath: "dir", wantMatch: []string{"upload/dir", "dir"}, wantPrefix: "dir/", remotes: []string{"upload/dir/file2.jpg"}, }, { root: "media", itemPath: "", wantMatch: []string{"media"}, wantPrefix: "", remotes: []string{"all/", "by-year/", "by-month/", "by-day/"}, }, { root: "media/all", itemPath: "", wantMatch: []string{"media/all"}, wantPrefix: "", remotes: []string{"file.jpg"}, }, { root: "media", itemPath: "all", wantMatch: []string{"media/all"}, wantPrefix: "all/", remotes: []string{"all/file.jpg"}, }, { root: "media/by-year", itemPath: "", wantMatch: []string{"media/by-year"}, wantPrefix: "", remotes: []string{"2000/", "2001/", "2002/", "2003/"}, }, { root: "media/by-year/2000", itemPath: "", wantMatch: []string{"media/by-year/2000", "2000"}, wantPrefix: "", remotes: []string{"file.jpg"}, }, { root: "media/by-month", itemPath: "", wantMatch: []string{"media/by-month"}, wantPrefix: "", remotes: []string{"2000/", "2001/", "2002/", "2003/"}, }, { root: "media/by-month/2001", itemPath: "", wantMatch: []string{"media/by-month/2001", "2001"}, wantPrefix: "", remotes: []string{"2001-01/", "2001-02/", "2001-03/", "2001-04/"}, }, { root: "media/by-month/2001/2001-01", itemPath: "", wantMatch: []string{"media/by-month/2001/2001-01", "2001", "01"}, wantPrefix: "", remotes: []string{"file.jpg"}, }, { root: "media/by-day", itemPath: "", wantMatch: []string{"media/by-day"}, wantPrefix: "", remotes: []string{"2000/", "2001/", "2002/", "2003/"}, }, { root: "media/by-day/2001", itemPath: "", wantMatch: []string{"media/by-day/2001", "2001"}, wantPrefix: "", remotes: []string{"2001-01-01/", "2001-01-02/", "2001-01-03/", "2001-01-04/"}, }, { root: "media/by-day/2001/2001-01-02", itemPath: "", wantMatch: []string{"media/by-day/2001/2001-01-02", "2001", "01", "02"}, wantPrefix: "", remotes: []string{"file.jpg"}, }, { root: "album", itemPath: "", wantMatch: []string{"album"}, wantPrefix: "", remotes: []string{"sub/"}, }, { root: "album/sub", itemPath: "", wantMatch: []string{"album/sub", "sub"}, wantPrefix: "", remotes: []string{"one/", "file.jpg"}, }, { root: "album/sub/one", itemPath: "", wantMatch: []string{"album/sub/one", "sub/one"}, wantPrefix: "", remotes: []string{"file.jpg"}, }, { root: "shared-album", itemPath: "", wantMatch: []string{"shared-album"}, wantPrefix: "", remotes: []string{"sub/"}, }, { root: "shared-album/sub", itemPath: "", wantMatch: []string{"shared-album/sub", "sub"}, wantPrefix: "", remotes: []string{"one/", "file.jpg"}, }, { root: "shared-album/sub/one", itemPath: "", wantMatch: []string{"shared-album/sub/one", "sub/one"}, wantPrefix: "", remotes: []string{"file.jpg"}, }, } { t.Run(fmt.Sprintf("#%d,root=%q,itemPath=%q", testNumber, test.root, test.itemPath), func(t *testing.T) { match, prefix, pattern := patterns.match(test.root, test.itemPath, false) assert.Equal(t, test.wantMatch, match) assert.Equal(t, test.wantPrefix, prefix) assert.NotNil(t, pattern) assert.NotNil(t, pattern.toEntries) entries, err := pattern.toEntries(ctx, f, prefix, match) assert.NoError(t, err) var remotes = []string{} for _, entry := range entries { remote := entry.Remote() if _, isDir := entry.(fs.Directory); isDir { remote += "/" } remotes = append(remotes, remote) if len(remotes) >= 4 { break // only test first 4 entries } } assert.Equal(t, test.remotes, remotes) }) } } func TestPatternYears(t *testing.T) { f := newTestLister(t) entries, err := years(context.Background(), f, "potato/", nil) require.NoError(t, err) year := 2000 for _, entry := range entries { assert.Equal(t, "potato/"+fmt.Sprint(year), entry.Remote()) year++ } } func TestPatternMonths(t *testing.T) { f := newTestLister(t) entries, err := months(context.Background(), f, "potato/", []string{"", "2020"}) require.NoError(t, err) assert.Equal(t, 12, len(entries)) for i, entry := range entries { assert.Equal(t, fmt.Sprintf("potato/2020-%02d", i+1), entry.Remote()) } } func TestPatternDays(t *testing.T) { f := newTestLister(t) entries, err := days(context.Background(), f, "potato/", []string{"", "2020"}) require.NoError(t, err) assert.Equal(t, 366, len(entries)) assert.Equal(t, "potato/2020-01-01", entries[0].Remote()) assert.Equal(t, "potato/2020-12-31", entries[len(entries)-1].Remote()) } func TestPatternYearMonthDayFilter(t *testing.T) { ctx := context.Background() f := newTestLister(t) // Years sf, err := yearMonthDayFilter(ctx, f, []string{"", "2000"}) require.NoError(t, err) assert.Equal(t, api.SearchFilter{ Filters: &api.Filters{ DateFilter: &api.DateFilter{ Dates: []api.Date{ { Year: 2000, }, }, }, }, }, sf) _, err = yearMonthDayFilter(ctx, f, []string{"", "potato"}) require.Error(t, err) _, err = yearMonthDayFilter(ctx, f, []string{"", "999"}) require.Error(t, err) _, err = yearMonthDayFilter(ctx, f, []string{"", "4000"}) require.Error(t, err) // Months sf, err = yearMonthDayFilter(ctx, f, []string{"", "2000", "01"}) require.NoError(t, err) assert.Equal(t, api.SearchFilter{ Filters: &api.Filters{ DateFilter: &api.DateFilter{ Dates: []api.Date{ { Month: 1, Year: 2000, }, }, }, }, }, sf) _, err = yearMonthDayFilter(ctx, f, []string{"", "2000", "potato"}) require.Error(t, err) _, err = yearMonthDayFilter(ctx, f, []string{"", "2000", "0"}) require.Error(t, err) _, err = yearMonthDayFilter(ctx, f, []string{"", "2000", "13"}) require.Error(t, err) // Days sf, err = yearMonthDayFilter(ctx, f, []string{"", "2000", "01", "02"}) require.NoError(t, err) assert.Equal(t, api.SearchFilter{ Filters: &api.Filters{ DateFilter: &api.DateFilter{ Dates: []api.Date{ { Day: 2, Month: 1, Year: 2000, }, }, }, }, }, sf) _, err = yearMonthDayFilter(ctx, f, []string{"", "2000", "01", "potato"}) require.Error(t, err) _, err = yearMonthDayFilter(ctx, f, []string{"", "2000", "01", "0"}) require.Error(t, err) _, err = yearMonthDayFilter(ctx, f, []string{"", "2000", "01", "32"}) require.Error(t, err) } func TestPatternAlbumsToEntries(t *testing.T) { f := newTestLister(t) ctx := context.Background() _, err := albumsToEntries(ctx, f, false, "potato/", "sub") assert.Equal(t, fs.ErrorDirNotFound, err) f.albums.add(&api.Album{ ID: "1", Title: "sub/one", }) entries, err := albumsToEntries(ctx, f, false, "potato/", "sub") assert.NoError(t, err) assert.Equal(t, 1, len(entries)) assert.Equal(t, "potato/one", entries[0].Remote()) _, ok := entries[0].(fs.Directory) assert.Equal(t, true, ok) f.albums.add(&api.Album{ ID: "1", Title: "sub", }) f.names = []string{"file.jpg"} entries, err = albumsToEntries(ctx, f, false, "potato/", "sub") assert.NoError(t, err) assert.Equal(t, 2, len(entries)) assert.Equal(t, "potato/one", entries[0].Remote()) _, ok = entries[0].(fs.Directory) assert.Equal(t, true, ok) assert.Equal(t, "potato/file.jpg", entries[1].Remote()) _, ok = entries[1].(fs.Object) assert.Equal(t, true, ok) } rclone-v1.71.0/backend/googlephotos/testfiles/000077500000000000000000000000001505210326400213505ustar00rootroot00000000000000rclone-v1.71.0/backend/googlephotos/testfiles/rclone-test-image1.jpg000066400000000000000000000402501505210326400254530ustar00rootroot00000000000000JFIF'ExifII* z (1 2iCanonCanon EOS 7DGIMP 2.10.82019:06:28 12:11:52Nick Craig-Wood 2 ("'0D X` hp  x5150000CanonCanon EOS 7D2014:03:16 17:26:02Nick Craig-Wood33 2013:07:26 08:57:212013:07:26 08:57:21`<#$JFIFC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?<]e BF0PqDo3W2c,5 : ksJt\8b_k Q] !bjqy/h-[1dSqWdzT%0k(;yH)UXegzwSw(El"|5iF4:}ޕ2~ZA[lU3[zWw6:W:?4,yTfʅ?Ά W;s9K`dj("vsV7qX6@P>(\NV7JnCnT%WQw9h4'Ҙ-W ;̢RzշT^J̲5|V=U,_^[4Y% ׷)ӭV\u^Xt*[D.qUnM^, 2uMVg ͓JSyySE $IFZ#H_[a)!#i^ƪC-[}u hU]8<=kO[EwH|n"n,V\c c_Ht]ZYZ.ǭaY;ʆuv;jopKs<4jSiTtG-J(H(1H>0'Exjǩ,|84X~TzGxBs1S) < }̐~aНQRYZ9W ڶfc qx#<JRt7cGەcϽOj8YHW#Z6Z\Y];q nJfgs=krM?j?*HA9yCrEhєrMWR1Wk6[`p*m8-̒0 'rE*7U]Ѭ28wkxLqɮ )UqΔs}jʮCji U V, C<;j1ta< .y# .[+ 5c? Q8h_2p?:H{~uE qN֌#U&e;UqFX%Q/,;63^JMà铏δ,BXNVj^^S0Qoj9ܫF*dqνift H:U;jxA*ީ<=kCAe*GQըJKuSO.Dːkߙ1~s\ύ1Ƭq<0>aȅ zW#DYެ.:O^rQ[۫Ɂrmun%IREl ZzNGV`HTSuc)SW؄^! [Ijk2\GsZH09z3\ḖeIN; o&.# /q=Fky6w=;c^}y}|{RG6]nj[]~K܉F`A${եJqT_@-imȖ!z{Ƥ:ˇP *i#X#X''ϯz-Κ+xdPRmQ[jq\8 }Ÿ#5= rs[V7"[uOjƪmm!x4OQ=xc<8z+jII >dGjZ]Dlnͺ#RnJg;Mw Wnygw.T('&hj9 Iyٞ8H8+˹bsk˖r^y0rGZkrUkR$doy+F8U^\Iun 񬴔@}kH;(`#>y?r*.HUӳ˕=.d%\:s\#;+o _'zu;Nz`񀼟jŝ4H~lwU;4g!q6mS9>Wu:p<`j~hKL҉5;o*3O>.uq#κ}(Deg΋:qp'{TQW6V#mVZ >nwv_YfKY8<~V;]gPH¾F1]()=θ4s`B:׽mn"JIҶLPFTq{{ix4;;3H{,S]X Nx-*ޞ,q}}m#d k{&cZvź] N9la'AmL. ڶnS21a~TW0jӪnp9;VܕWFfizM iMrN{qZེ51㕕]c+IWn0GӵnEeeF1&;zw5 o̦cQYT.Uvt®9TzҒs|V/mln3LּjͷǗVnOR!8jrd= ͻ`X`4;?{\)^ڦ|R?= |`9jfrjÜdf*ri!t,h J :^sZjyW'KgyPڽ 3jdqjeQ ggsq)t G]³")Y2ݛVdx̯o'$`ZV$Ixk5䩺9({r -yl)_, "]]‘= X -PR~7V4e/  $hB3N;Wqw>Ffw,Ó [d}%èl ҷ a \cݱQN${Rq\mFo'p #kuHۓU[-8%!H&5:K4ǚ[';}kfz>DPwNpc;#cQϝ)7r쓪FMf&.xnwB[Ұ[dwdA]dҹ\[فBs5Dܪuo "QF=;=e.ыMqJƭskF!֝@5(G۱װ>{T[`V SgB&avlG<+0tv(k3Z2u3zo4g8\ =[3lq3뭻JByۿJEỺ>[mzzV.q3Qz&+"NN͋lYc(A~ժtwLS{gelL&vHYBv9(jE? O\%u( <{7??)7;b2qޕz0 TjZӴbIw \ַ܀d{d ${kV`ⱵfSnI=M 2^G\֮KM2\p7>>gSjߏLH8GhbǞkJPnNS_&ZO WSxPԙ7.GCX_Sv ]_ntHsf9 kJ<5-]}vw~O;?θȠ oL@Ae#kѤc\t&1+NOHHu=*F⥒A\S)YFO5Ly ޳>Yq![Z`'͚ty.y[pWsk*-Un+J.2=SMj[ k֎ ?+D2{ɼ# m$r6ancGmןҩbxsV~LAz(U4M*I^N"We8-X6flՙSWBF15lUCА v18e46Ap:}+|-uѥ[GЗM4lai]N;fIf[ec0I&(=SxhYK /;>f۽٭$ݢnO_ֺM>_XqeQf+_CܷSOjFʸs [ᡆ***?ZV[ZFiqVKS'WO|$\aWbE F{T#1V]jѼ鸔 :KGsdZp+Wf535fU1yyçd<35kDڬ( tVV$ scUƏi x|Or{W W̞ a>m8{x"IؤԞRksp`(lGKgb^"j.tnWM`fUg<sRogF >0#H3Fǚ图2{T2#zԿ6ٽE68ʷQҒW0Tq%AJiqtcץ;91̘՛-P"ϥ}}xr )ێzUn*2i7+RrVaG=&S:snMNM) Tf_:S̀Ĥp33 zT9~B=tݝM+d5NHGbU*jG9sA3DqbFBǐCq>,~}+ BzrΔS^̎1圶*CeyL%I^ߕAq,F$"9sfa˖1k,&jvJIB1WtucC6ۃQ]9>ޭ lp^:N,ʯ p 浧Rq/+GC=qr&f\Qs( NkkX՘Pn2@,&9ͫ$9j$2nxք N=j9-7U>-s[S4І_TVшU$mU;*n>h$:H?.ٶ+,Ljgִ /J0G{LcQ|YnLW_b yus:G=ȈjFqQ21+ȜLj7)pm2ӳ#[DS n"lzз9!DS@*OZl=S9tᬌ!dTEvJ;Լև1ӭMاBbFE@w*M\p] 'ԥ B+(-c"'_X۴nu?aTWJ ޺KSo ]r@FFQ[J@pÚQ)4KYaUgk#IJHm ZO8]$)09M-FԨRX:vKSb"s~+K;VfyA;nc]6mXPfڪŪ8PcҵϠ=s2S* SRlDخ{gUSmg t9Z_x}*}¹W2[ cnqP1 WY?zz!ɒD+ MTg8Z۶ o_k/{cL;+mj{<7ںmǷߏ]Mubi*^)ZӍ0:TtkA+Ȧa QZn: CdiW")E;es?\~On6Vs*ڪODUޫ- U http://ns.adobe.com/xap/1.0/ Nick Craig-Wood \Photoshop 3.08BIM@Z%GtNick Craig-Wood720190628< 121152-1211C 2!=,.$2I@LKG@FEPZsbPUmVEFdemw{N`}s~|C;!!;|SFS||||||||||||||||||||||||||||||||||||||||||||||||||Another image!Cd 1v]4OB]lu=In*"V %vFBMM['ZoiNU6̵ JY8NMY8ĝ*(OJVIYM&͹JVF5b4IBUdegS) lrcDO [Ҝ%l !1 2A"T)ni;1C\HM;mteÍ6JhjHrjzjGBmLVޣ|$=8R6ek!v>sv$$Qܽ(z>?% 0!1?9B )*+T,᫱w hzY"҉pu#DȺ$e(4=3et{Bҋ&!ı ac::!1AQq?`ٹmBsmlFL,IvHLe3oxJwm).:wo\KI0dU{nXf7I`&?|u' Sس Gy ۆGf ʘaB,RJ6mSoϓ!!1AQaq?؎.vq캩mEUG8'] z(aIKk>M,LT|@.E* 0 u\`MQ^XM s@Q, |Z'D+񍂢FZܸJ[@g"PY|02OJ9#+?B[B?{Sѣi3~Fۺilx USGc$.O[5.ckVݨڎC,VAGbG&`,-rP>v!f쩞VL_ydM&_IVuMxw#}(JHZ.qV1Z["P1?_\y4_Z@ K#G C8CJS_.2M)Dp W!p(zwq38B f.{PԸ?"?rclone-v1.71.0/backend/googlephotos/testfiles/rclone-test-image2.jpg000066400000000000000000000405751505210326400254660ustar00rootroot00000000000000JFIF'ExifII* z (1 2iCanonCanon EOS 7DGIMP 2.10.82019:06:28 12:10:48Nick Craig-Wood 2 ("'0D X` hp  x5150000CanonCanon EOS 7D2014:03:16 17:26:02Nick Craig-Wood33 2013:07:26 08:57:212013:07:26 08:57:21`<#$JFIFC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?<]e BF0PqDo3W2c,5 : ksJt\8b_k Q] !bjqy/h-[1dSqWdzT%0k(;yH)UXegzwSw(El"|5iF4:}ޕ2~ZA[lU3[zWw6:W:?4,yTfʅ?Ά W;s9K`dj("vsV7qX6@P>(\NV7JnCnT%WQw9h4'Ҙ-W ;̢RzշT^J̲5|V=U,_^[4Y% ׷)ӭV\u^Xt*[D.qUnM^, 2uMVg ͓JSyySE $IFZ#H_[a)!#i^ƪC-[}u hU]8<=kO[EwH|n"n,V\c c_Ht]ZYZ.ǭaY;ʆuv;jopKs<4jSiTtG-J(H(1H>0'Exjǩ,|84X~TzGxBs1S) < }̐~aНQRYZ9W ڶfc qx#<JRt7cGەcϽOj8YHW#Z6Z\Y];q nJfgs=krM?j?*HA9yCrEhєrMWR1Wk6[`p*m8-̒0 'rE*7U]Ѭ28wkxLqɮ )UqΔs}jʮCji U V, C<;j1ta< .y# .[+ 5c? Q8h_2p?:H{~uE qN֌#U&e;UqFX%Q/,;63^JMà铏δ,BXNVj^^S0Qoj9ܫF*dqνift H:U;jxA*ީ<=kCAe*GQըJKuSO.Dːkߙ1~s\ύ1Ƭq<0>aȅ zW#DYެ.:O^rQ[۫Ɂrmun%IREl ZzNGV`HTSuc)SW؄^! [Ijk2\GsZH09z3\ḖeIN; o&.# /q=Fky6w=;c^}y}|{RG6]nj[]~K܉F`A${եJqT_@-imȖ!z{Ƥ:ˇP *i#X#X''ϯz-Κ+xdPRmQ[jq\8 }Ÿ#5= rs[V7"[uOjƪmm!x4OQ=xc<8z+jII >dGjZ]Dlnͺ#RnJg;Mw Wnygw.T('&hj9 Iyٞ8H8+˹bsk˖r^y0rGZkrUkR$doy+F8U^\Iun 񬴔@}kH;(`#>y?r*.HUӳ˕=.d%\:s\#;+o _'zu;Nz`񀼟jŝ4H~lwU;4g!q6mS9>Wu:p<`j~hKL҉5;o*3O>.uq#κ}(Deg΋:qp'{TQW6V#mVZ >nwv_YfKY8<~V;]gPH¾F1]()=θ4s`B:׽mn"JIҶLPFTq{{ix4;;3H{,S]X Nx-*ޞ,q}}m#d k{&cZvź] N9la'AmL. ڶnS21a~TW0jӪnp9;VܕWFfizM iMrN{qZེ51㕕]c+IWn0GӵnEeeF1&;zw5 o̦cQYT.Uvt®9TzҒs|V/mln3LּjͷǗVnOR!8jrd= ͻ`X`4;?{\)^ڦ|R?= |`9jfrjÜdf*ri!t,h J :^sZjyW'KgyPڽ 3jdqjeQ ggsq)t G]³")Y2ݛVdx̯o'$`ZV$Ixk5䩺9({r -yl)_, "]]‘= X -PR~7V4e/  $hB3N;Wqw>Ffw,Ó [d}%èl ҷ a \cݱQN${Rq\mFo'p #kuHۓU[-8%!H&5:K4ǚ[';}kfz>DPwNpc;#cQϝ)7r쓪FMf&.xnwB[Ұ[dwdA]dҹ\[فBs5Dܪuo "QF=;=e.ыMqJƭskF!֝@5(G۱װ>{T[`V SgB&avlG<+0tv(k3Z2u3zo4g8\ =[3lq3뭻JByۿJEỺ>[mzzV.q3Qz&+"NN͋lYc(A~ժtwLS{gelL&vHYBv9(jE? O\%u( <{7??)7;b2qޕz0 TjZӴbIw \ַ܀d{d ${kV`ⱵfSnI=M 2^G\֮KM2\p7>>gSjߏLH8GhbǞkJPnNS_&ZO WSxPԙ7.GCX_Sv ]_ntHsf9 kJ<5-]}vw~O;?θȠ oL@Ae#kѤc\t&1+NOHHu=*F⥒A\S)YFO5Ly ޳>Yq![Z`'͚ty.y[pWsk*-Un+J.2=SMj[ k֎ ?+D2{ɼ# m$r6ancGmןҩbxsV~LAz(U4M*I^N"We8-X6flՙSWBF15lUCА v18e46Ap:}+|-uѥ[GЗM4lai]N;fIf[ec0I&(=SxhYK /;>f۽٭$ݢnO_ֺM>_XqeQf+_CܷSOjFʸs [ᡆ***?ZV[ZFiqVKS'WO|$\aWbE F{T#1V]jѼ鸔 :KGsdZp+Wf535fU1yyçd<35kDڬ( tVV$ scUƏi x|Or{W W̞ a>m8{x"IؤԞRksp`(lGKgb^"j.tnWM`fUg<sRogF >0#H3Fǚ图2{T2#zԿ6ٽE68ʷQҒW0Tq%AJiqtcץ;91̘՛-P"ϥ}}xr )ێzUn*2i7+RrVaG=&S:snMNM) Tf_:S̀Ĥp33 zT9~B=tݝM+d5NHGbU*jG9sA3DqbFBǐCq>,~}+ BzrΔS^̎1圶*CeyL%I^ߕAq,F$"9sfa˖1k,&jvJIB1WtucC6ۃQ]9>ޭ lp^:N,ʯ p 浧Rq/+GC=qr&f\Qs( NkkX՘Pn2@,&9ͫ$9j$2nxք N=j9-7U>-s[S4І_TVшU$mU;*n>h$:H?.ٶ+,Ljgִ /J0G{LcQ|YnLW_b yus:G=ȈjFqQ21+ȜLj7)pm2ӳ#[DS n"lzз9!DS@*OZl=S9tᬌ!dTEvJ;Լև1ӭMاBbFE@w*M\p] 'ԥ B+(-c"'_X۴nu?aTWJ ޺KSo ]r@FFQ[J@pÚQ)4KYaUgk#IJHm ZO8]$)09M-FԨRX:vKSb"s~+K;VfyA;nc]6mXPfڪŪ8PcҵϠ=s2S* SRlDخ{gUSmg t9Z_x}*}¹W2[ cnqP1 WY?zz!ɒD+ MTg8Z۶ o_k/{cL;+mj{<7ںmǷߏ]Mubi*^)ZӍ0:TtkA+Ȧa QZn: CdiW")E;es?\~On6Vs*ڪODUޫ- U http://ns.adobe.com/xap/1.0/ Nick Craig-Wood \Photoshop 3.08BIM@Z%GtNick Craig-Wood720190628< 121048-1210C   (1#%(:3=<9387@H\N@DWE78PmQW_bghg>Mqypdx\egcC//cB8BccccccccccccccccccccccccccccccccccccccccccccccccccCd 1Xcg.|'n[a4X%= &IMϪ815. 1M-)M}; #Uq<ӯn6ΚA+oV\Po%X[[mt Gdapb㚤*&m4l0;!Y i@:t`w!!1 A"2&54v`js_& STM@@%T֑ ^\j.HZ2ˢU'"C,/&o(710fXi 3 7ciPv gjLnrOjcb &1U T>Ox?  !1A0Q?%KH2DŖ6.f Cl蹣4v(x"Wш',JNO !A 1Qa?Q⇬B"1id YŌ,qg QH[ױ[Yl6Dz</Fl5А=.BB,彚这 vsx!CV%^fS<-茸W&!$! 1"02QAa?xXge-"tm%HT#Y<ĭBiyڢ$Cxȝ?_e8u="!1AQqa?!m(sʰ7hgl[CoplJ w+.axpWwZ}1`UKЙ4K1%T?%R#$xy*-G˞dN 3ܹ44Ԯ e H!$u16-Xt"yoppîF%cpXZKs`ʦ27,і~ g%Z aJTHRdc?Q!aP du+FK5QֻQAo%y#YpjČs!1AQ ?_>٤2 [&Rn aXGY3{z-=y$y &\位޶cWK9qr35o?DJ夌}K5~`po9#ˤaYcGkjgk3C='SGmI$lRrm%wkoɎWꏤE6@Mi D &;jBr&]r髎gpmpB=n68}wẸ\}N'$!1AQaq?^ceD%XM0rM#?(jm-xߨ8W)Ir7$B>P \ÅHWŅo|2'J3d*XplTvhLe#۽ȗbJwVQjpΟ `4jW;ix>bSn^yv*F+CKᑵ.Ah>cjeR["ouQ>" +>bhR \ڰWkkk9U˯Raq VƐ 5+k3+udmiM nA_lPV^/t# A5Vֹp,ȹJ ט sL W؏%koErclone-v1.71.0/backend/hasher/000077500000000000000000000000001505210326400161075ustar00rootroot00000000000000rclone-v1.71.0/backend/hasher/commands.go000066400000000000000000000115231505210326400202410ustar00rootroot00000000000000package hasher import ( "context" "errors" "fmt" "path" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/fspath" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/lib/kv" ) // Command the backend to run a named command // // The command run is name // args may be used to read arguments from // opts may be used to read optional arguments from // // The result should be capable of being JSON encoded // If it is a string or a []string it will be shown to the user // otherwise it will be JSON encoded and shown to the user like that func (f *Fs) Command(ctx context.Context, name string, arg []string, opt map[string]string) (out any, err error) { switch name { case "drop": return nil, f.db.Stop(true) case "dump", "fulldump": return nil, f.dbDump(ctx, name == "fulldump", "") case "import", "stickyimport": sticky := name == "stickyimport" if len(arg) != 2 { return nil, errors.New("please provide checksum type and path to sum file") } return nil, f.dbImport(ctx, arg[0], arg[1], sticky) default: return nil, fs.ErrorCommandNotFound } } var commandHelp = []fs.CommandHelp{{ Name: "drop", Short: "Drop cache", Long: `Completely drop checksum cache. Usage Example: rclone backend drop hasher: `, }, { Name: "dump", Short: "Dump the database", Long: "Dump cache records covered by the current remote", }, { Name: "fulldump", Short: "Full dump of the database", Long: "Dump all cache records in the database", }, { Name: "import", Short: "Import a SUM file", Long: `Amend hash cache from a SUM file and bind checksums to files by size/time. Usage Example: rclone backend import hasher:subdir md5 /path/to/sum.md5 `, }, { Name: "stickyimport", Short: "Perform fast import of a SUM file", Long: `Fill hash cache from a SUM file without verifying file fingerprints. Usage Example: rclone backend stickyimport hasher:subdir md5 remote:path/to/sum.md5 `, }} func (f *Fs) dbDump(ctx context.Context, full bool, root string) error { if root == "" { remoteFs, err := cache.Get(ctx, f.opt.Remote) if err != nil { return err } root = fspath.JoinRootPath(remoteFs.Root(), f.Root()) } if f.db == nil { if f.opt.MaxAge == 0 { fs.Errorf(f, "db not found. (disabled with max_age = 0)") } else { fs.Errorf(f, "db not found.") } return kv.ErrInactive } op := &kvDump{ full: full, root: root, path: f.db.Path(), fs: f, } err := f.db.Do(false, op) if err == kv.ErrEmpty { fs.Infof(op.path, "empty") err = nil } return err } func (f *Fs) dbImport(ctx context.Context, hashName, sumRemote string, sticky bool) error { var hashType hash.Type if err := hashType.Set(hashName); err != nil { return err } if hashType == hash.None { return errors.New("please provide a valid hash type") } if !f.suppHashes.Contains(hashType) { return errors.New("unsupported hash type") } if !f.keepHashes.Contains(hashType) { fs.Infof(nil, "Need not import hashes of this type") return nil } _, sumPath, err := fspath.SplitFs(sumRemote) if err != nil { return err } sumFs, err := cache.Get(ctx, sumRemote) switch err { case fs.ErrorIsFile: // ok case nil: return fmt.Errorf("not a file: %s", sumRemote) default: return err } sumObj, err := sumFs.NewObject(ctx, path.Base(sumPath)) if err != nil { return fmt.Errorf("cannot open sum file: %w", err) } hashes, err := operations.ParseSumFile(ctx, sumObj) if err != nil { return fmt.Errorf("failed to parse sum file: %w", err) } if sticky { rootPath := f.Fs.Root() for remote, hashVal := range hashes { key := path.Join(rootPath, remote) hashSums := operations.HashSums{hashName: hashVal} if err := f.putRawHashes(ctx, key, anyFingerprint, hashSums); err != nil { fs.Errorf(nil, "%s: failed to import: %v", remote, err) } } fs.Infof(nil, "Summary: %d checksum(s) imported", len(hashes)) return nil } const longImportThreshold = 100 if len(hashes) > longImportThreshold { fs.Infof(nil, "Importing %d checksums. Please wait...", len(hashes)) } doneCount := 0 err = operations.ListFn(ctx, f, func(obj fs.Object) { remote := obj.Remote() hash := hashes[remote] hashes[remote] = "" // mark as handled o, ok := obj.(*Object) if ok && hash != "" { if err := o.putHashes(ctx, hashMap{hashType: hash}); err != nil { fs.Errorf(nil, "%s: failed to import: %v", remote, err) } accounting.Stats(ctx).NewCheckingTransfer(obj, "importing").Done(ctx, err) doneCount++ } }) if err != nil { fs.Errorf(nil, "Import failed: %v", err) } skipCount := 0 for remote, emptyOrDone := range hashes { if emptyOrDone != "" { fs.Infof(nil, "Skip vanished object: %s", remote) skipCount++ } } fs.Infof(nil, "Summary: %d imported, %d skipped", doneCount, skipCount) return err } rclone-v1.71.0/backend/hasher/hasher.go000066400000000000000000000410331505210326400177110ustar00rootroot00000000000000// Package hasher implements a checksum handling overlay backend package hasher import ( "context" "encoding/gob" "errors" "fmt" "io" "path" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fspath" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/lib/kv" ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "hasher", Description: "Better checksums for other remotes", NewFs: NewFs, MetadataInfo: &fs.MetadataInfo{ Help: `Any metadata supported by the underlying remote is read and written.`, }, CommandHelp: commandHelp, Options: []fs.Option{{ Name: "remote", Required: true, Help: "Remote to cache checksums for (e.g. myRemote:path).", }, { Name: "hashes", Default: fs.CommaSepList{"md5", "sha1"}, Advanced: false, Help: "Comma separated list of supported checksum types.", }, { Name: "max_age", Advanced: false, Default: fs.DurationOff, Help: "Maximum time to keep checksums in cache (0 = no cache, off = cache forever).", }, { Name: "auto_size", Advanced: true, Default: fs.SizeSuffix(0), Help: "Auto-update checksum for files smaller than this size (disabled by default).", }}, }) } // Options defines the configuration for this backend type Options struct { Remote string `config:"remote"` Hashes fs.CommaSepList `config:"hashes"` AutoSize fs.SizeSuffix `config:"auto_size"` MaxAge fs.Duration `config:"max_age"` } // Fs represents a wrapped fs.Fs type Fs struct { fs.Fs name string root string wrapper fs.Fs features *fs.Features opt *Options db *kv.DB // fingerprinting fpTime bool // true if using time in fingerprints fpHash hash.Type // hash type to use in fingerprints or None // hash types triaged by groups suppHashes hash.Set // all supported checksum types passHashes hash.Set // passed directly to the base without caching slowHashes hash.Set // passed to the base and then cached autoHashes hash.Set // calculated in-house and cached keepHashes hash.Set // checksums to keep in cache (slow + auto) } var warnExperimental sync.Once // NewFs constructs an Fs from the remote:path string func NewFs(ctx context.Context, fsname, rpath string, cmap configmap.Mapper) (fs.Fs, error) { if !kv.Supported() { return nil, errors.New("hasher is not supported on this OS") } warnExperimental.Do(func() { fs.Infof(nil, "Hasher is EXPERIMENTAL!") }) opt := &Options{} err := configstruct.Set(cmap, opt) if err != nil { return nil, err } if strings.HasPrefix(opt.Remote, fsname+":") { return nil, errors.New("can't point remote at itself") } remotePath := fspath.JoinRootPath(opt.Remote, rpath) baseFs, err := cache.Get(ctx, remotePath) if err != nil && err != fs.ErrorIsFile { return nil, fmt.Errorf("failed to derive base remote %q: %w", opt.Remote, err) } f := &Fs{ Fs: baseFs, name: fsname, root: rpath, opt: opt, } // Correct root if definitely pointing to a file if err == fs.ErrorIsFile { f.root = path.Dir(f.root) if f.root == "." || f.root == "/" { f.root = "" } } baseFeatures := baseFs.Features() f.fpTime = baseFs.Precision() != fs.ModTimeNotSupported if baseFeatures.SlowHash { f.slowHashes = f.Fs.Hashes() } else { f.passHashes = f.Fs.Hashes() f.fpHash = f.passHashes.GetOne() } f.suppHashes = f.passHashes f.suppHashes.Add(f.slowHashes.Array()...) for _, hashName := range opt.Hashes { var ht hash.Type if err := ht.Set(hashName); err != nil { return nil, fmt.Errorf("invalid token %q in hash string %q", hashName, opt.Hashes.String()) } if !f.slowHashes.Contains(ht) { f.autoHashes.Add(ht) } f.keepHashes.Add(ht) f.suppHashes.Add(ht) } fs.Debugf(f, "Groups by usage: cached %s, passed %s, auto %s, slow %s, supported %s", f.keepHashes, f.passHashes, f.autoHashes, f.slowHashes, f.suppHashes) var nilSet hash.Set if f.keepHashes == nilSet { return nil, errors.New("configured hash_names have nothing to keep in cache") } if f.opt.MaxAge > 0 { gob.Register(hashRecord{}) db, err := kv.Start(ctx, "hasher", f.Fs) if err != nil { return nil, err } f.db = db } stubFeatures := &fs.Features{ CanHaveEmptyDirectories: true, IsLocal: true, ReadMimeType: true, WriteMimeType: true, SetTier: true, GetTier: true, ReadMetadata: true, WriteMetadata: true, UserMetadata: true, ReadDirMetadata: true, WriteDirMetadata: true, WriteDirSetModTime: true, UserDirMetadata: true, DirModTimeUpdatesOnWrite: true, PartialUploads: true, } f.features = stubFeatures.Fill(ctx, f).Mask(ctx, f.Fs).WrapsFs(f, f.Fs) // Enable ListP always f.features.ListP = f.ListP cache.PinUntilFinalized(f.Fs, f) return f, err } // // Filesystem // // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return f.suppHashes } // String returns a description of the FS // The "hasher::" prefix is a distinctive feature. func (f *Fs) String() string { return fmt.Sprintf("hasher::%s:%s", f.name, f.root) } // UnWrap returns the Fs that this Fs is wrapping func (f *Fs) UnWrap() fs.Fs { return f.Fs } // WrapFs returns the Fs that is wrapping this Fs func (f *Fs) WrapFs() fs.Fs { return f.wrapper } // SetWrapper sets the Fs that is wrapping this Fs func (f *Fs) SetWrapper(wrapper fs.Fs) { f.wrapper = wrapper } // Wrap base entries into hasher entries. func (f *Fs) wrapEntries(baseEntries fs.DirEntries) (hashEntries fs.DirEntries, err error) { hashEntries = baseEntries[:0] // work inplace for _, entry := range baseEntries { switch x := entry.(type) { case fs.Object: obj, err := f.wrapObject(x, nil) if err != nil { return nil, err } hashEntries = append(hashEntries, obj) default: hashEntries = append(hashEntries, entry) // trash in - trash out } } return hashEntries, nil } // List the objects and directories in dir into entries. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { return list.WithListP(ctx, dir, f) } // ListP lists the objects and directories of the Fs starting // from dir non recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. func (f *Fs) ListP(ctx context.Context, dir string, callback fs.ListRCallback) error { wrappedCallback := func(entries fs.DirEntries) error { entries, err := f.wrapEntries(entries) if err != nil { return err } return callback(entries) } listP := f.Fs.Features().ListP if listP == nil { entries, err := f.Fs.List(ctx, dir) if err != nil { return err } return wrappedCallback(entries) } return listP(ctx, dir, wrappedCallback) } // ListR lists the objects and directories recursively into out. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { return f.Fs.Features().ListR(ctx, dir, func(baseEntries fs.DirEntries) error { hashEntries, err := f.wrapEntries(baseEntries) if err != nil { return err } return callback(hashEntries) }) } // Purge a directory func (f *Fs) Purge(ctx context.Context, dir string) error { if do := f.Fs.Features().Purge; do != nil { if err := do(ctx, dir); err != nil { return err } err := f.db.Do(true, &kvPurge{ dir: path.Join(f.Fs.Root(), dir), }) if err != nil { fs.Errorf(f, "Failed to purge some hashes: %v", err) } return nil } return fs.ErrorCantPurge } // PutStream uploads to the remote path with undeterminate size. func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { if do := f.Fs.Features().PutStream; do != nil { _ = f.pruneHash(src.Remote()) oResult, err := do(ctx, in, src, options...) return f.wrapObject(oResult, err) } return nil, errors.New("PutStream not supported") } // PutUnchecked uploads the object, allowing duplicates. func (f *Fs) PutUnchecked(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { if do := f.Fs.Features().PutUnchecked; do != nil { _ = f.pruneHash(src.Remote()) oResult, err := do(ctx, in, src, options...) return f.wrapObject(oResult, err) } return nil, errors.New("PutUnchecked not supported") } // pruneHash deletes hash for a path func (f *Fs) pruneHash(remote string) error { return f.db.Do(true, &kvPrune{ key: path.Join(f.Fs.Root(), remote), }) } // CleanUp the trash in the Fs func (f *Fs) CleanUp(ctx context.Context) error { if do := f.Fs.Features().CleanUp; do != nil { return do(ctx) } return errors.New("not supported by underlying remote") } // About gets quota information from the Fs func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { if do := f.Fs.Features().About; do != nil { return do(ctx) } return nil, errors.New("not supported by underlying remote") } // ChangeNotify calls the passed function with a path that has had changes. func (f *Fs) ChangeNotify(ctx context.Context, notifyFunc func(string, fs.EntryType), pollIntervalChan <-chan time.Duration) { if do := f.Fs.Features().ChangeNotify; do != nil { do(ctx, notifyFunc, pollIntervalChan) } } // UserInfo returns info about the connected user func (f *Fs) UserInfo(ctx context.Context) (map[string]string, error) { if do := f.Fs.Features().UserInfo; do != nil { return do(ctx) } return nil, fs.ErrorNotImplemented } // Disconnect the current user func (f *Fs) Disconnect(ctx context.Context) error { if do := f.Fs.Features().Disconnect; do != nil { return do(ctx) } return fs.ErrorNotImplemented } // MergeDirs merges the contents of all the directories passed // in into the first one and rmdirs the other directories. func (f *Fs) MergeDirs(ctx context.Context, dirs []fs.Directory) error { if do := f.Fs.Features().MergeDirs; do != nil { return do(ctx, dirs) } return errors.New("MergeDirs not supported") } // DirSetModTime sets the directory modtime for dir func (f *Fs) DirSetModTime(ctx context.Context, dir string, modTime time.Time) error { if do := f.Fs.Features().DirSetModTime; do != nil { return do(ctx, dir, modTime) } return fs.ErrorNotImplemented } // MkdirMetadata makes the root directory of the Fs object func (f *Fs) MkdirMetadata(ctx context.Context, dir string, metadata fs.Metadata) (fs.Directory, error) { if do := f.Fs.Features().MkdirMetadata; do != nil { return do(ctx, dir, metadata) } return nil, fs.ErrorNotImplemented } // DirCacheFlush resets the directory cache - used in testing // as an optional interface func (f *Fs) DirCacheFlush() { if do := f.Fs.Features().DirCacheFlush; do != nil { do() } } // PublicLink generates a public link to the remote path (usually readable by anyone) func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (string, error) { if do := f.Fs.Features().PublicLink; do != nil { return do(ctx, remote, expire, unlink) } return "", errors.New("PublicLink not supported") } // Copy src to this remote using server-side copy operations. func (f *Fs) Copy(ctx context.Context, src fs.Object, remote string) (fs.Object, error) { do := f.Fs.Features().Copy if do == nil { return nil, fs.ErrorCantCopy } o, ok := src.(*Object) if !ok { return nil, fs.ErrorCantCopy } oResult, err := do(ctx, o.Object, remote) return f.wrapObject(oResult, err) } // Move src to this remote using server-side move operations. func (f *Fs) Move(ctx context.Context, src fs.Object, remote string) (fs.Object, error) { do := f.Fs.Features().Move if do == nil { return nil, fs.ErrorCantMove } o, ok := src.(*Object) if !ok { return nil, fs.ErrorCantMove } oResult, err := do(ctx, o.Object, remote) if err != nil { return nil, err } _ = f.db.Do(true, &kvMove{ src: path.Join(f.Fs.Root(), src.Remote()), dst: path.Join(f.Fs.Root(), remote), dir: false, fs: f, }) return f.wrapObject(oResult, nil) } // DirMove moves src, srcRemote to this remote at dstRemote using server-side move operations. func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { do := f.Fs.Features().DirMove if do == nil { return fs.ErrorCantDirMove } srcFs, ok := src.(*Fs) if !ok { return fs.ErrorCantDirMove } err := do(ctx, srcFs.Fs, srcRemote, dstRemote) if err == nil { _ = f.db.Do(true, &kvMove{ src: path.Join(srcFs.Fs.Root(), srcRemote), dst: path.Join(f.Fs.Root(), dstRemote), dir: true, fs: f, }) } return err } // Shutdown the backend, closing any background tasks and any cached connections. func (f *Fs) Shutdown(ctx context.Context) (err error) { if f.db != nil && !f.db.IsStopped() { err = f.db.Stop(false) } if do := f.Fs.Features().Shutdown; do != nil { if err2 := do(ctx); err2 != nil { err = err2 } } return } // NewObject finds the Object at remote. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { o, err := f.Fs.NewObject(ctx, remote) return f.wrapObject(o, err) } // // Object // // Object represents a composite file wrapping one or more data chunks type Object struct { fs.Object f *Fs } // Wrap base object into hasher object func (f *Fs) wrapObject(o fs.Object, err error) (obj fs.Object, outErr error) { // log.Trace(o, "err=%v", err)("obj=%#v, outErr=%v", &obj, &outErr) if err != nil { return nil, err } if o == nil { return nil, fs.ErrorObjectNotFound } return &Object{Object: o, f: f}, nil } // Fs returns read only access to the Fs that this object is part of func (o *Object) Fs() fs.Info { return o.f } // UnWrap returns the wrapped Object func (o *Object) UnWrap() fs.Object { return o.Object } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.Object.String() } // ID returns the ID of the Object if possible func (o *Object) ID() string { if doer, ok := o.Object.(fs.IDer); ok { return doer.ID() } return "" } // GetTier returns the Tier of the Object if possible func (o *Object) GetTier() string { if doer, ok := o.Object.(fs.GetTierer); ok { return doer.GetTier() } return "" } // SetTier set the Tier of the Object if possible func (o *Object) SetTier(tier string) error { if doer, ok := o.Object.(fs.SetTierer); ok { return doer.SetTier(tier) } return errors.New("SetTier not supported") } // MimeType of an Object if known, "" otherwise func (o *Object) MimeType(ctx context.Context) string { if doer, ok := o.Object.(fs.MimeTyper); ok { return doer.MimeType(ctx) } return "" } // Metadata returns metadata for an object // // It should return nil if there is no Metadata func (o *Object) Metadata(ctx context.Context) (fs.Metadata, error) { do, ok := o.Object.(fs.Metadataer) if !ok { return nil, nil } return do.Metadata(ctx) } // SetMetadata sets metadata for an Object // // It should return fs.ErrorNotImplemented if it can't set metadata func (o *Object) SetMetadata(ctx context.Context, metadata fs.Metadata) error { do, ok := o.Object.(fs.SetMetadataer) if !ok { return fs.ErrorNotImplemented } return do.SetMetadata(ctx, metadata) } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.Commander = (*Fs)(nil) _ fs.PutUncheckeder = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.CleanUpper = (*Fs)(nil) _ fs.UnWrapper = (*Fs)(nil) _ fs.ListRer = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.Wrapper = (*Fs)(nil) _ fs.MergeDirser = (*Fs)(nil) _ fs.DirSetModTimer = (*Fs)(nil) _ fs.MkdirMetadataer = (*Fs)(nil) _ fs.DirCacheFlusher = (*Fs)(nil) _ fs.ChangeNotifier = (*Fs)(nil) _ fs.PublicLinker = (*Fs)(nil) _ fs.UserInfoer = (*Fs)(nil) _ fs.Disconnecter = (*Fs)(nil) _ fs.Shutdowner = (*Fs)(nil) _ fs.FullObject = (*Object)(nil) ) rclone-v1.71.0/backend/hasher/hasher_internal_test.go000066400000000000000000000042611505210326400226460ustar00rootroot00000000000000package hasher import ( "context" "fmt" "os" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" "github.com/rclone/rclone/lib/kv" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func putFile(ctx context.Context, t *testing.T, f fs.Fs, name, data string) fs.Object { mtime1 := fstest.Time("2001-02-03T04:05:06.499999999Z") item := fstest.Item{Path: name, ModTime: mtime1} o := fstests.PutTestContents(ctx, t, f, &item, data, true) require.NotNil(t, o) return o } func (f *Fs) testUploadFromCrypt(t *testing.T) { // make a temporary local remote tempRoot, err := fstest.LocalRemote() require.NoError(t, err) defer func() { _ = os.RemoveAll(tempRoot) }() // make a temporary crypt remote ctx := context.Background() pass := obscure.MustObscure("crypt") remote := fmt.Sprintf(`:crypt,remote="%s",password="%s":`, tempRoot, pass) cryptFs, err := fs.NewFs(ctx, remote) require.NoError(t, err) // make a test file on the crypt remote const dirName = "from_crypt_1" const fileName = dirName + "/file_from_crypt_1" const longTime = fs.ModTimeNotSupported src := putFile(ctx, t, cryptFs, fileName, "doggy froggy") // ensure that hash does not exist yet _ = f.pruneHash(fileName) hashType := f.keepHashes.GetOne() hash, err := f.getRawHash(ctx, hashType, fileName, anyFingerprint, longTime) assert.Error(t, err) assert.Empty(t, hash) // upload file to hasher in, err := src.Open(ctx) require.NoError(t, err) dst, err := f.Put(ctx, in, src) require.NoError(t, err) assert.NotNil(t, dst) // check that hash was created if f.opt.MaxAge > 0 { hash, err = f.getRawHash(ctx, hashType, fileName, anyFingerprint, longTime) assert.NoError(t, err) assert.NotEmpty(t, hash) } //t.Logf("hash is %q", hash) _ = operations.Purge(ctx, f, dirName) } // InternalTest dispatches all internal tests func (f *Fs) InternalTest(t *testing.T) { if !kv.Supported() { t.Skip("hasher is not supported on this OS") } t.Run("UploadFromCrypt", f.testUploadFromCrypt) } var _ fstests.InternalTester = (*Fs)(nil) rclone-v1.71.0/backend/hasher/hasher_test.go000066400000000000000000000023171505210326400207520ustar00rootroot00000000000000package hasher_test import ( "os" "path/filepath" "testing" "github.com/rclone/rclone/backend/hasher" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" "github.com/rclone/rclone/lib/kv" _ "github.com/rclone/rclone/backend/all" // for integration tests ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { if !kv.Supported() { t.Skip("hasher is not supported on this OS") } opt := fstests.Opt{ RemoteName: *fstest.RemoteName, NilObject: (*hasher.Object)(nil), UnimplementableFsMethods: []string{ "OpenWriterAt", "OpenChunkWriter", }, UnimplementableObjectMethods: []string{}, } if *fstest.RemoteName == "" { tempDir := filepath.Join(os.TempDir(), "rclone-hasher-test") opt.ExtraConfig = []fstests.ExtraConfigItem{ {Name: "TestHasher", Key: "type", Value: "hasher"}, {Name: "TestHasher", Key: "remote", Value: tempDir}, } opt.RemoteName = "TestHasher:" opt.QuickTestOK = true } fstests.Run(t, &opt) // test again with MaxAge = 0 if *fstest.RemoteName == "" { opt.ExtraConfig = append(opt.ExtraConfig, fstests.ExtraConfigItem{Name: "TestHasher", Key: "max_age", Value: "0"}) fstests.Run(t, &opt) } } rclone-v1.71.0/backend/hasher/kv.go000066400000000000000000000152521505210326400170630ustar00rootroot00000000000000package hasher import ( "bytes" "context" "encoding/gob" "errors" "fmt" "maps" "strings" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/lib/kv" ) const ( timeFormat = "2006-01-02T15:04:05.000000000-0700" anyFingerprint = "*" ) type hashMap map[hash.Type]string type hashRecord struct { Fp string // fingerprint Hashes operations.HashSums Created time.Time } func (r *hashRecord) encode(key string) ([]byte, error) { var buf bytes.Buffer if err := gob.NewEncoder(&buf).Encode(r); err != nil { fs.Debugf(key, "hasher encoding %v: %v", r, err) return nil, err } return buf.Bytes(), nil } func (r *hashRecord) decode(key string, data []byte) error { if err := gob.NewDecoder(bytes.NewBuffer(data)).Decode(r); err != nil { fs.Debugf(key, "hasher decoding %q failed: %v", data, err) return err } return nil } // kvPrune: prune a single hash type kvPrune struct { key string } func (op *kvPrune) Do(ctx context.Context, b kv.Bucket) error { return b.Delete([]byte(op.key)) } // kvPurge: delete a subtree type kvPurge struct { dir string } func (op *kvPurge) Do(ctx context.Context, b kv.Bucket) error { dir := op.dir if !strings.HasSuffix(dir, "/") { dir += "/" } var items []string cur := b.Cursor() bkey, _ := cur.Seek([]byte(dir)) for bkey != nil { key := string(bkey) if !strings.HasPrefix(key, dir) { break } items = append(items, key[len(dir):]) bkey, _ = cur.Next() } nerr := 0 for _, sub := range items { if err := b.Delete([]byte(dir + sub)); err != nil { nerr++ } } fs.Debugf(dir, "%d hashes purged, %d failed", len(items)-nerr, nerr) return nil } // kvMove: assign hashes to new path type kvMove struct { src string dst string dir bool fs *Fs } func (op *kvMove) Do(ctx context.Context, b kv.Bucket) error { src, dst := op.src, op.dst if !op.dir { err := moveHash(b, src, dst) fs.Debugf(op.fs, "moving cached hash %s to %s (err: %v)", src, dst, err) return err } if !strings.HasSuffix(src, "/") { src += "/" } if !strings.HasSuffix(dst, "/") { dst += "/" } var items []string cur := b.Cursor() bkey, _ := cur.Seek([]byte(src)) for bkey != nil { key := string(bkey) if !strings.HasPrefix(key, src) { break } items = append(items, key[len(src):]) bkey, _ = cur.Next() } nerr := 0 for _, suffix := range items { srcKey, dstKey := src+suffix, dst+suffix err := moveHash(b, srcKey, dstKey) fs.Debugf(op.fs, "Rename cache record %s -> %s (err: %v)", srcKey, dstKey, err) if err != nil { nerr++ } } fs.Debugf(op.fs, "%d hashes moved, %d failed", len(items)-nerr, nerr) return nil } func moveHash(b kv.Bucket, src, dst string) error { data := b.Get([]byte(src)) err := b.Delete([]byte(src)) if err != nil || len(data) == 0 { return err } return b.Put([]byte(dst), data) } // kvGet: get single hash from database type kvGet struct { key string fp string hash string val string age time.Duration } func (op *kvGet) Do(ctx context.Context, b kv.Bucket) error { data := b.Get([]byte(op.key)) if len(data) == 0 { return errors.New("no record") } var r hashRecord if err := r.decode(op.key, data); err != nil { return errors.New("invalid record") } if !(r.Fp == anyFingerprint || op.fp == anyFingerprint || r.Fp == op.fp) { return errors.New("fingerprint changed") } if time.Since(r.Created) > op.age { return errors.New("record timed out") } if r.Hashes != nil { op.val = r.Hashes[op.hash] } return nil } // kvPut: set hashes for an object by key type kvPut struct { key string fp string hashes operations.HashSums age time.Duration } func (op *kvPut) Do(ctx context.Context, b kv.Bucket) (err error) { data := b.Get([]byte(op.key)) var r hashRecord if len(data) > 0 { err = r.decode(op.key, data) if err != nil || r.Fp != op.fp || time.Since(r.Created) > op.age { r.Hashes = nil } } if len(r.Hashes) == 0 { r.Created = time.Now() r.Hashes = operations.HashSums{} r.Fp = op.fp } maps.Copy(r.Hashes, op.hashes) if data, err = r.encode(op.key); err != nil { return fmt.Errorf("marshal failed: %w", err) } if err = b.Put([]byte(op.key), data); err != nil { return fmt.Errorf("put failed: %w", err) } return err } // kvDump: dump the database. // Note: long dump can cause concurrent operations to fail. type kvDump struct { full bool root string path string fs *Fs num int total int } func (op *kvDump) Do(ctx context.Context, b kv.Bucket) error { f, baseRoot, dbPath := op.fs, op.root, op.path if op.full { total := 0 num := 0 _ = b.ForEach(func(bkey, data []byte) error { total++ key := string(bkey) include := (baseRoot == "" || key == baseRoot || strings.HasPrefix(key, baseRoot+"/")) var r hashRecord if err := r.decode(key, data); err != nil { fs.Errorf(nil, "%s: invalid record: %v", key, err) return nil } fmt.Println(f.dumpLine(&r, key, include, nil)) if include { num++ } return nil }) fs.Infof(dbPath, "%d records out of %d", num, total) op.num, op.total = num, total // for unit tests return nil } num := 0 cur := b.Cursor() var bkey, data []byte if baseRoot != "" { bkey, data = cur.Seek([]byte(baseRoot)) } else { bkey, data = cur.First() } for bkey != nil { key := string(bkey) if !(baseRoot == "" || key == baseRoot || strings.HasPrefix(key, baseRoot+"/")) { break } var r hashRecord if err := r.decode(key, data); err != nil { fs.Errorf(nil, "%s: invalid record: %v", key, err) continue } if key = strings.TrimPrefix(key[len(baseRoot):], "/"); key == "" { key = "/" } fmt.Println(f.dumpLine(&r, key, true, nil)) num++ bkey, data = cur.Next() } fs.Infof(dbPath, "%d records", num) op.num = num // for unit tests return nil } func (f *Fs) dumpLine(r *hashRecord, path string, include bool, err error) string { var status string switch { case !include: status = "ext" case err != nil: status = "bad" case r.Fp == anyFingerprint: status = "stk" default: status = "ok " } var hashes []string for _, hashType := range f.keepHashes.Array() { hashName := hashType.String() hashVal := r.Hashes[hashName] if hashVal == "" || err != nil { hashVal = "-" } hashVal = fmt.Sprintf("%-*s", hash.Width(hashType, false), hashVal) hashes = append(hashes, hashName+":"+hashVal) } hashesStr := strings.Join(hashes, " ") age := time.Since(r.Created).Round(time.Second) if age > 24*time.Hour { age = age.Round(time.Hour) } if err != nil { age = 0 } ageStr := age.String() if strings.HasSuffix(ageStr, "h0m0s") { ageStr = strings.TrimSuffix(ageStr, "0m0s") } return fmt.Sprintf("%s %s %9s %s", status, hashesStr, ageStr, path) } rclone-v1.71.0/backend/hasher/object.go000066400000000000000000000176351505210326400177200ustar00rootroot00000000000000package hasher import ( "context" "errors" "fmt" "io" "path" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/operations" ) // obtain hash for an object func (o *Object) getHash(ctx context.Context, hashType hash.Type) (string, error) { maxAge := time.Duration(o.f.opt.MaxAge) if maxAge <= 0 { return "", nil } fp := o.fingerprint(ctx) if fp == "" { return "", errors.New("fingerprint failed") } return o.f.getRawHash(ctx, hashType, o.Remote(), fp, maxAge) } // obtain hash for a path func (f *Fs) getRawHash(ctx context.Context, hashType hash.Type, remote, fp string, age time.Duration) (string, error) { key := path.Join(f.Fs.Root(), remote) op := &kvGet{ key: key, fp: fp, hash: hashType.String(), age: age, } err := f.db.Do(false, op) return op.val, err } // put new hashes for an object func (o *Object) putHashes(ctx context.Context, rawHashes hashMap) error { if o.f.opt.MaxAge <= 0 { return nil } fp := o.fingerprint(ctx) if fp == "" { return nil } key := path.Join(o.f.Fs.Root(), o.Remote()) hashes := operations.HashSums{} for hashType, hashVal := range rawHashes { hashes[hashType.String()] = hashVal } return o.f.putRawHashes(ctx, key, fp, hashes) } // set hashes for a path without any validation func (f *Fs) putRawHashes(ctx context.Context, key, fp string, hashes operations.HashSums) error { return f.db.Do(true, &kvPut{ key: key, fp: fp, hashes: hashes, age: time.Duration(f.opt.MaxAge), }) } // Hash returns the selected checksum of the file or "" if unavailable. func (o *Object) Hash(ctx context.Context, hashType hash.Type) (hashVal string, err error) { f := o.f if f.passHashes.Contains(hashType) { fs.Debugf(o, "pass %s", hashType) hashVal, err = o.Object.Hash(ctx, hashType) if hashVal != "" { return hashVal, err } if err != nil { fs.Debugf(o, "error passing %s: %v", hashType, err) } fs.Debugf(o, "passed %s is blank -- trying other methods", hashType) } if !f.suppHashes.Contains(hashType) { fs.Debugf(o, "unsupp %s", hashType) return "", hash.ErrUnsupported } if hashVal, err = o.getHash(ctx, hashType); err != nil { fs.Debugf(o, "getHash: %v", err) err = nil hashVal = "" } if hashVal != "" { fs.Debugf(o, "cached %s = %q", hashType, hashVal) return hashVal, nil } if f.slowHashes.Contains(hashType) { fs.Debugf(o, "slow %s", hashType) hashVal, err = o.Object.Hash(ctx, hashType) if err == nil && hashVal != "" && f.keepHashes.Contains(hashType) { if err = o.putHashes(ctx, hashMap{hashType: hashVal}); err != nil { fs.Debugf(o, "putHashes: %v", err) err = nil } } return hashVal, err } if f.autoHashes.Contains(hashType) && o.Size() < int64(f.opt.AutoSize) { _ = o.updateHashes(ctx) if hashVal, err = o.getHash(ctx, hashType); err != nil { fs.Debugf(o, "auto %s = %q (%v)", hashType, hashVal, err) err = nil } } return hashVal, err } // updateHashes performs implicit "rclone hashsum --download" and updates cache. func (o *Object) updateHashes(ctx context.Context) error { r, err := o.Open(ctx) if err != nil { fs.Infof(o, "update failed (open): %v", err) return err } defer func() { _ = r.Close() }() if _, err = io.Copy(io.Discard, r); err != nil { fs.Infof(o, "update failed (copy): %v", err) return err } return nil } // Update the object with the given data, time and size. func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { _ = o.f.pruneHash(src.Remote()) return o.Object.Update(ctx, in, src, options...) } // Remove an object. func (o *Object) Remove(ctx context.Context) error { _ = o.f.pruneHash(o.Remote()) return o.Object.Remove(ctx) } // SetModTime sets the modification time of the file. // Also prunes the cache entry when modtime changes so that // touching a file will trigger checksum recalculation even // on backends that don't provide modTime with fingerprint. func (o *Object) SetModTime(ctx context.Context, mtime time.Time) error { if mtime != o.Object.ModTime(ctx) { _ = o.f.pruneHash(o.Remote()) } return o.Object.SetModTime(ctx, mtime) } // Open opens the file for read. // Full reads will also update object hashes. func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (r io.ReadCloser, err error) { size := o.Size() var offset, limit int64 = 0, -1 for _, option := range options { switch opt := option.(type) { case *fs.SeekOption: offset = opt.Offset case *fs.RangeOption: offset, limit = opt.Decode(size) } } if offset < 0 { return nil, errors.New("invalid offset") } if limit < 0 { limit = size - offset } if r, err = o.Object.Open(ctx, options...); err != nil { return nil, err } if offset != 0 || limit < size { // It's a partial read return r, err } return o.f.newHashingReader(ctx, r, func(sums hashMap) { if err := o.putHashes(ctx, sums); err != nil { fs.Infof(o, "auto hashing error: %v", err) } }) } // Put data into the remote path with given modTime and size func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { var ( o fs.Object common hash.Set rehash bool hashes hashMap ) if fsrc := src.Fs(); fsrc != nil { common = fsrc.Hashes().Overlap(f.keepHashes) // Rehash if source does not have all required hashes or hashing is slow rehash = fsrc.Features().SlowHash || common != f.keepHashes } wrapIn := in if rehash { r, err := f.newHashingReader(ctx, in, func(sums hashMap) { hashes = sums }) fs.Debugf(src, "Rehash in-fly due to incomplete or slow source set %v (err: %v)", common, err) if err == nil { wrapIn = r } else { rehash = false } } _ = f.pruneHash(src.Remote()) oResult, err := f.Fs.Put(ctx, wrapIn, src, options...) o, err = f.wrapObject(oResult, err) if err != nil { return nil, err } if !rehash { hashes = hashMap{} for _, ht := range common.Array() { if h, e := src.Hash(ctx, ht); e == nil && h != "" { hashes[ht] = h } } } if len(hashes) > 0 { err := o.(*Object).putHashes(ctx, hashes) fs.Debugf(o, "Applied %d source hashes, err: %v", len(hashes), err) } return o, err } type hashingReader struct { rd io.Reader hasher *hash.MultiHasher fun func(hashMap) } func (f *Fs) newHashingReader(ctx context.Context, rd io.Reader, fun func(hashMap)) (*hashingReader, error) { hasher, err := hash.NewMultiHasherTypes(f.keepHashes) if err != nil { return nil, err } hr := &hashingReader{ rd: rd, hasher: hasher, fun: fun, } return hr, nil } func (r *hashingReader) Read(p []byte) (n int, err error) { n, err = r.rd.Read(p) if err != nil && err != io.EOF { r.hasher = nil } if r.hasher != nil { if _, errHash := r.hasher.Write(p[:n]); errHash != nil { r.hasher = nil err = errHash } } if err == io.EOF && r.hasher != nil { r.fun(r.hasher.Sums()) r.hasher = nil } return } func (r *hashingReader) Close() error { if rc, ok := r.rd.(io.ReadCloser); ok { return rc.Close() } return nil } // Return object fingerprint or empty string in case of errors // // Note that we can't use the generic `fs.Fingerprint` here because // this fingerprint is used to pick _derived hashes_ that are slow // to calculate or completely unsupported by the base remote. // // The hasher fingerprint must be based on `fsHash`, the first _fast_ // hash supported _by the underlying remote_ (if there is one), // while `fs.Fingerprint` would select a hash _produced by hasher_ // creating unresolvable fingerprint loop. func (o *Object) fingerprint(ctx context.Context) string { size := o.Object.Size() timeStr := "-" if o.f.fpTime { timeStr = o.Object.ModTime(ctx).UTC().Format(timeFormat) if timeStr == "" { return "" } } hashStr := "-" if o.f.fpHash != hash.None { var err error hashStr, err = o.Object.Hash(ctx, o.f.fpHash) if hashStr == "" || err != nil { return "" } } return fmt.Sprintf("%d,%s,%s", size, timeStr, hashStr) } rclone-v1.71.0/backend/hdfs/000077500000000000000000000000001505210326400155615ustar00rootroot00000000000000rclone-v1.71.0/backend/hdfs/fs.go000066400000000000000000000234661505210326400165330ustar00rootroot00000000000000//go:build !plan9 package hdfs import ( "context" "fmt" "io" "os" "os/user" "path" "strings" "time" "github.com/colinmarc/hdfs/v2" krb "github.com/jcmturner/gokrb5/v8/client" "github.com/jcmturner/gokrb5/v8/config" "github.com/jcmturner/gokrb5/v8/credentials" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/pacer" ) // Fs represents a HDFS server type Fs struct { name string root string features *fs.Features // optional features opt Options // options for this backend ci *fs.ConfigInfo // global config client *hdfs.Client pacer *fs.Pacer // pacer for API calls } const ( minSleep = 20 * time.Millisecond maxSleep = 10 * time.Second decayConstant = 2 // bigger for slower decay, exponential ) // copy-paste from https://github.com/colinmarc/hdfs/blob/master/cmd/hdfs/kerberos.go func getKerberosClient() (*krb.Client, error) { configPath := os.Getenv("KRB5_CONFIG") if configPath == "" { configPath = "/etc/krb5.conf" } cfg, err := config.Load(configPath) if err != nil { return nil, err } // Determine the ccache location from the environment, falling back to the // default location. ccachePath := os.Getenv("KRB5CCNAME") if strings.Contains(ccachePath, ":") { if strings.HasPrefix(ccachePath, "FILE:") { ccachePath = strings.SplitN(ccachePath, ":", 2)[1] } else { return nil, fmt.Errorf("unusable ccache: %s", ccachePath) } } else if ccachePath == "" { u, err := user.Current() if err != nil { return nil, err } ccachePath = fmt.Sprintf("/tmp/krb5cc_%s", u.Uid) } ccache, err := credentials.LoadCCache(ccachePath) if err != nil { return nil, err } client, err := krb.NewFromCCache(ccache, cfg) if err != nil { return nil, err } return client, nil } // NewFs constructs an Fs from the path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } options := hdfs.ClientOptions{ Addresses: opt.Namenode, UseDatanodeHostname: false, } if opt.ServicePrincipalName != "" { options.KerberosClient, err = getKerberosClient() if err != nil { return nil, fmt.Errorf("problem with kerberos authentication: %w", err) } options.KerberosServicePrincipleName = opt.ServicePrincipalName if opt.DataTransferProtection != "" { options.DataTransferProtection = opt.DataTransferProtection } } else { options.User = opt.Username } client, err := hdfs.NewClient(options) if err != nil { return nil, err } f := &Fs{ name: name, root: root, opt: *opt, ci: fs.GetConfig(ctx), client: client, pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), } f.features = (&fs.Features{ CanHaveEmptyDirectories: true, }).Fill(ctx, f) info, err := f.client.Stat(f.realpath("")) if err == nil && !info.IsDir() { f.root = path.Dir(f.root) return f, fs.ErrorIsFile } return f, nil } // Name of this fs func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String returns a description of the FS func (f *Fs) String() string { return fmt.Sprintf("hdfs://%s/%s", f.opt.Namenode, f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // Precision return the precision of this Fs func (f *Fs) Precision() time.Duration { return time.Second } // Hashes are not supported func (f *Fs) Hashes() hash.Set { return hash.Set(hash.None) } // NewObject finds file at remote or return fs.ErrorObjectNotFound func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { realpath := f.realpath(remote) fs.Debugf(f, "new [%s]", realpath) info, err := f.ensureFile(realpath) if err != nil { return nil, err } return &Object{ fs: f, remote: remote, size: info.Size(), modTime: info.ModTime(), }, nil } // List the objects and directories in dir into entries. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { realpath := f.realpath(dir) fs.Debugf(f, "list [%s]", realpath) err = f.ensureDirectory(realpath) if err != nil { return nil, err } list, err := f.client.ReadDir(realpath) if err != nil { return nil, err } for _, x := range list { stdName := f.opt.Enc.ToStandardName(x.Name()) remote := path.Join(dir, stdName) if x.IsDir() { entries = append(entries, fs.NewDir(remote, x.ModTime())) } else { entries = append(entries, &Object{ fs: f, remote: remote, size: x.Size(), modTime: x.ModTime(), }) } } return entries, nil } // Put the object func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { o := &Object{ fs: f, remote: src.Remote(), } err := o.Update(ctx, in, src, options...) return o, err } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } // Mkdir makes a directory func (f *Fs) Mkdir(ctx context.Context, dir string) error { fs.Debugf(f, "mkdir [%s]", f.realpath(dir)) return f.client.MkdirAll(f.realpath(dir), 0755) } // Rmdir deletes the directory func (f *Fs) Rmdir(ctx context.Context, dir string) error { realpath := f.realpath(dir) fs.Debugf(f, "rmdir [%s]", realpath) err := f.ensureDirectory(realpath) if err != nil { return err } // do not remove empty directory list, err := f.client.ReadDir(realpath) if err != nil { return err } if len(list) > 0 { return fs.ErrorDirectoryNotEmpty } return f.client.Remove(realpath) } // Purge deletes all the files in the directory func (f *Fs) Purge(ctx context.Context, dir string) error { realpath := f.realpath(dir) fs.Debugf(f, "purge [%s]", realpath) err := f.ensureDirectory(realpath) if err != nil { return err } return f.client.RemoveAll(realpath) } // Move src to this remote using server-side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't move - not same remote type") return nil, fs.ErrorCantMove } // Get the real paths from the remote specs: sourcePath := srcObj.fs.realpath(srcObj.remote) targetPath := f.realpath(remote) fs.Debugf(f, "rename [%s] to [%s]", sourcePath, targetPath) // Make sure the target folder exists: dirname := path.Dir(targetPath) err := f.client.MkdirAll(dirname, 0755) if err != nil { return nil, err } // Do the move // Note that the underlying HDFS library hard-codes Overwrite=True, but this is expected rclone behaviour. err = f.client.Rename(sourcePath, targetPath) if err != nil { return nil, err } // Look up the resulting object info, err := f.client.Stat(targetPath) if err != nil { return nil, err } // And return it: return &Object{ fs: f, remote: remote, size: info.Size(), modTime: info.ModTime(), }, nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) (err error) { srcFs, ok := src.(*Fs) if !ok { return fs.ErrorCantDirMove } // Get the real paths from the remote specs: sourcePath := srcFs.realpath(srcRemote) targetPath := f.realpath(dstRemote) fs.Debugf(f, "rename [%s] to [%s]", sourcePath, targetPath) // Check if the destination exists: info, err := f.client.Stat(targetPath) if err == nil { fs.Debugf(f, "target directory already exits, IsDir = [%t]", info.IsDir()) return fs.ErrorDirExists } // Make sure the targets parent folder exists: dirname := path.Dir(targetPath) err = f.client.MkdirAll(dirname, 0755) if err != nil { return err } // Do the move err = f.client.Rename(sourcePath, targetPath) if err != nil { return err } return nil } // About gets quota information from the Fs func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { info, err := f.client.StatFs() if err != nil { return nil, err } return &fs.Usage{ Total: fs.NewUsageValue(info.Capacity), Used: fs.NewUsageValue(info.Used), Free: fs.NewUsageValue(info.Remaining), }, nil } func (f *Fs) ensureDirectory(realpath string) error { info, err := f.client.Stat(realpath) if e, ok := err.(*os.PathError); ok && e.Err == os.ErrNotExist { return fs.ErrorDirNotFound } if err != nil { return err } if !info.IsDir() { return fs.ErrorDirNotFound } return nil } func (f *Fs) ensureFile(realpath string) (os.FileInfo, error) { info, err := f.client.Stat(realpath) if e, ok := err.(*os.PathError); ok && e.Err == os.ErrNotExist { return nil, fs.ErrorObjectNotFound } if err != nil { return nil, err } if info.IsDir() { return nil, fs.ErrorObjectNotFound } return info, nil } func (f *Fs) realpath(dir string) string { return f.opt.Enc.FromStandardPath(xPath(f.Root(), dir)) } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) ) rclone-v1.71.0/backend/hdfs/hdfs.go000066400000000000000000000047021505210326400170370ustar00rootroot00000000000000//go:build !plan9 // Package hdfs provides an interface to the HDFS storage system. package hdfs import ( "path" "strings" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/lib/encoder" ) func init() { fsi := &fs.RegInfo{ Name: "hdfs", Description: "Hadoop distributed file system", NewFs: NewFs, Options: []fs.Option{{ Name: "namenode", Help: "Hadoop name nodes and ports.\n\nE.g. \"namenode-1:8020,namenode-2:8020,...\" to connect to host namenodes at port 8020.", Required: true, Sensitive: true, Default: fs.CommaSepList{}, }, { Name: "username", Help: "Hadoop user name.", Examples: []fs.OptionExample{{ Value: "root", Help: "Connect to hdfs as root.", }}, Sensitive: true, }, { Name: "service_principal_name", Help: `Kerberos service principal name for the namenode. Enables KERBEROS authentication. Specifies the Service Principal Name (SERVICE/FQDN) for the namenode. E.g. \"hdfs/namenode.hadoop.docker\" for namenode running as service 'hdfs' with FQDN 'namenode.hadoop.docker'.`, Advanced: true, Sensitive: true, }, { Name: "data_transfer_protection", Help: `Kerberos data transfer protection: authentication|integrity|privacy. Specifies whether or not authentication, data signature integrity checks, and wire encryption are required when communicating with the datanodes. Possible values are 'authentication', 'integrity' and 'privacy'. Used only with KERBEROS enabled.`, Examples: []fs.OptionExample{{ Value: "privacy", Help: "Ensure authentication, integrity and encryption enabled.", }}, Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: (encoder.Display | encoder.EncodeInvalidUtf8 | encoder.EncodeColon), }}, } fs.Register(fsi) } // Options for this backend type Options struct { Namenode fs.CommaSepList `config:"namenode"` Username string `config:"username"` ServicePrincipalName string `config:"service_principal_name"` DataTransferProtection string `config:"data_transfer_protection"` Enc encoder.MultiEncoder `config:"encoding"` } // xPath make correct file path with leading '/' func xPath(root string, tail string) string { if !strings.HasPrefix(root, "/") { root = "/" + root } return path.Join(root, tail) } rclone-v1.71.0/backend/hdfs/hdfs_test.go000066400000000000000000000005711505210326400200760ustar00rootroot00000000000000// Test HDFS filesystem interface //go:build !plan9 package hdfs_test import ( "testing" "github.com/rclone/rclone/backend/hdfs" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestHdfs:", NilObject: (*hdfs.Object)(nil), }) } rclone-v1.71.0/backend/hdfs/hdfs_unsupported.go000066400000000000000000000003161505210326400215040ustar00rootroot00000000000000// Build for hdfs for unsupported platforms to stop go complaining // about "no buildable Go source files " //go:build plan9 // Package hdfs provides an interface to the HDFS storage system. package hdfs rclone-v1.71.0/backend/hdfs/object.go000066400000000000000000000100201505210326400173470ustar00rootroot00000000000000//go:build !plan9 package hdfs import ( "context" "errors" "io" "path" "time" "github.com/colinmarc/hdfs/v2" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/readers" ) // Object describes an HDFS file type Object struct { fs *Fs remote string size int64 modTime time.Time } // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Size returns the size of an object in bytes func (o *Object) Size() int64 { return o.size } // ModTime returns the modification time of the object func (o *Object) ModTime(ctx context.Context) time.Time { return o.modTime } // SetModTime sets the modification time of the local fs object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { realpath := o.fs.realpath(o.Remote()) err := o.fs.client.Chtimes(realpath, modTime, modTime) if err != nil { return err } o.modTime = modTime return nil } // Storable returns whether this object is storable func (o *Object) Storable() bool { return true } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.Remote() } // Hash is not supported func (o *Object) Hash(ctx context.Context, r hash.Type) (string, error) { return "", hash.ErrUnsupported } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { realpath := o.realpath() fs.Debugf(o.fs, "open [%s]", realpath) f, err := o.fs.client.Open(realpath) if err != nil { return nil, err } var offset, limit int64 = 0, -1 for _, option := range options { switch x := option.(type) { case *fs.SeekOption: offset = x.Offset case *fs.RangeOption: offset, limit = x.Decode(o.Size()) } } _, err = f.Seek(offset, io.SeekStart) if err != nil { return nil, err } if limit != -1 { in = readers.NewLimitedReadCloser(f, limit) } else { in = f } return in, err } // Update object func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { realpath := o.fs.realpath(o.remote) dirname := path.Dir(realpath) fs.Debugf(o.fs, "update [%s]", realpath) err := o.fs.client.MkdirAll(dirname, 0755) if err != nil { return err } _, err = o.fs.client.Stat(realpath) if err == nil { err = o.fs.client.Remove(realpath) if err != nil { return err } } out, err := o.fs.client.Create(realpath) if err != nil { return err } cleanup := func() { rerr := o.fs.client.Remove(realpath) if rerr != nil { fs.Errorf(o.fs, "failed to remove [%v]: %v", realpath, rerr) } } _, err = io.Copy(out, in) if err != nil { cleanup() return err } // If the datanodes have acknowledged all writes but not yet // to the namenode, FileWriter.Close can return ErrReplicating // (wrapped in an os.PathError). This indicates that all data // has been written, but the lease is still open for the file. // // It is safe in this case to either ignore the error (and let // the lease expire on its own) or to call Close multiple // times until it completes without an error. The Java client, // for context, always chooses to retry, with exponential // backoff. err = o.fs.pacer.Call(func() (bool, error) { err := out.Close() if err == nil { return false, nil } return errors.Is(err, hdfs.ErrReplicating), err }) if err != nil { cleanup() return err } info, err := o.fs.client.Stat(realpath) if err != nil { return err } err = o.SetModTime(ctx, src.ModTime(ctx)) if err != nil { return err } o.size = info.Size() return nil } // Remove an object func (o *Object) Remove(ctx context.Context) error { realpath := o.fs.realpath(o.remote) fs.Debugf(o.fs, "remove [%s]", realpath) return o.fs.client.Remove(realpath) } func (o *Object) realpath() string { return o.fs.opt.Enc.FromStandardPath(xPath(o.Fs().Root(), o.remote)) } // Check the interfaces are satisfied var ( _ fs.Object = (*Object)(nil) ) rclone-v1.71.0/backend/hidrive/000077500000000000000000000000001505210326400162675ustar00rootroot00000000000000rclone-v1.71.0/backend/hidrive/api/000077500000000000000000000000001505210326400170405ustar00rootroot00000000000000rclone-v1.71.0/backend/hidrive/api/queries.go000066400000000000000000000053011505210326400210430ustar00rootroot00000000000000package api import ( "encoding/json" "net/url" "path" "strings" "time" ) // Some presets for different amounts of information that can be requested for fields; // it is recommended to only request the information that is actually needed. var ( HiDriveObjectNoMetadataFields = []string{"name", "type"} HiDriveObjectWithMetadataFields = append(HiDriveObjectNoMetadataFields, "id", "size", "mtime", "chash") HiDriveObjectWithDirectoryMetadataFields = append(HiDriveObjectWithMetadataFields, "nmembers") DirectoryContentFields = []string{"nmembers"} ) // QueryParameters represents the parameters passed to an API-call. type QueryParameters struct { url.Values } // NewQueryParameters initializes an instance of QueryParameters and // returns a pointer to it. func NewQueryParameters() *QueryParameters { return &QueryParameters{url.Values{}} } // SetFileInDirectory sets the appropriate parameters // to specify a path to a file in a directory. // This is used by requests that work with paths for files that do not exist yet. // (For example when creating a file). // Most requests use the format produced by SetPath(...). func (p *QueryParameters) SetFileInDirectory(filePath string) { directory, file := path.Split(path.Clean(filePath)) p.Set("dir", path.Clean(directory)) p.Set("name", file) // NOTE: It would be possible to switch to pid-based requests // by modifying this function. } // SetPath sets the appropriate parameters to access the given path. func (p *QueryParameters) SetPath(objectPath string) { p.Set("path", path.Clean(objectPath)) // NOTE: It would be possible to switch to pid-based requests // by modifying this function. } // SetTime sets the key to the time-value. It replaces any existing values. func (p *QueryParameters) SetTime(key string, value time.Time) error { valueAPI := Time(value) valueBytes, err := json.Marshal(&valueAPI) if err != nil { return err } p.Set(key, string(valueBytes)) return nil } // AddList adds the given values as a list // with each value separated by the separator. // It appends to any existing values associated with key. func (p *QueryParameters) AddList(key string, separator string, values ...string) { original := p.Get(key) p.Set(key, strings.Join(values, separator)) if original != "" { p.Set(key, original+separator+p.Get(key)) } } // AddFields sets the appropriate parameter to access the given fields. // The given fields will be appended to any other existing fields. func (p *QueryParameters) AddFields(prefix string, fields ...string) { modifiedFields := make([]string, len(fields)) for i, field := range fields { modifiedFields[i] = prefix + field } p.AddList("fields", ",", modifiedFields...) } rclone-v1.71.0/backend/hidrive/api/types.go000066400000000000000000000066661505210326400205510ustar00rootroot00000000000000// Package api has type definitions and code related to API-calls for the HiDrive-API. package api import ( "encoding/json" "fmt" "net/url" "strconv" "time" ) // Time represents date and time information for the API. type Time time.Time // MarshalJSON turns Time into JSON (in Unix-time/UTC). func (t *Time) MarshalJSON() ([]byte, error) { secs := time.Time(*t).Unix() return []byte(strconv.FormatInt(secs, 10)), nil } // UnmarshalJSON turns JSON into Time. func (t *Time) UnmarshalJSON(data []byte) error { secs, err := strconv.ParseInt(string(data), 10, 64) if err != nil { return err } *t = Time(time.Unix(secs, 0)) return nil } // Error is returned from the API when things go wrong. type Error struct { Code json.Number `json:"code"` ContextInfo json.RawMessage Message string `json:"msg"` } // Error returns a string for the error and satisfies the error interface. func (e *Error) Error() string { out := fmt.Sprintf("Error %q", e.Code.String()) if e.Message != "" { out += ": " + e.Message } if e.ContextInfo != nil { out += fmt.Sprintf(" (%+v)", e.ContextInfo) } return out } // Check Error satisfies the error interface. var _ error = (*Error)(nil) // possible types for HiDriveObject const ( HiDriveObjectTypeDirectory = "dir" HiDriveObjectTypeFile = "file" HiDriveObjectTypeSymlink = "symlink" ) // HiDriveObject describes a folder, a symlink or a file. // Depending on the type and content, not all fields are present. type HiDriveObject struct { Type string `json:"type"` ID string `json:"id"` ParentID string `json:"parent_id"` Name string `json:"name"` Path string `json:"path"` Size int64 `json:"size"` MemberCount int64 `json:"nmembers"` ModifiedAt Time `json:"mtime"` ChangedAt Time `json:"ctime"` MetaHash string `json:"mhash"` MetaOnlyHash string `json:"mohash"` NameHash string `json:"nhash"` ContentHash string `json:"chash"` IsTeamfolder bool `json:"teamfolder"` Readable bool `json:"readable"` Writable bool `json:"writable"` Shareable bool `json:"shareable"` MIMEType string `json:"mime_type"` } // ModTime returns the modification time of the HiDriveObject. func (i *HiDriveObject) ModTime() time.Time { t := time.Time(i.ModifiedAt) if t.IsZero() { t = time.Time(i.ChangedAt) } return t } // UnmarshalJSON turns JSON into HiDriveObject and // introduces specific default-values where necessary. func (i *HiDriveObject) UnmarshalJSON(data []byte) error { type objectAlias HiDriveObject defaultObject := objectAlias{ Size: -1, MemberCount: -1, } err := json.Unmarshal(data, &defaultObject) if err != nil { return err } name, err := url.PathUnescape(defaultObject.Name) if err == nil { defaultObject.Name = name } *i = HiDriveObject(defaultObject) return nil } // DirectoryContent describes the content of a directory. type DirectoryContent struct { TotalCount int64 `json:"nmembers"` Entries []HiDriveObject `json:"members"` } // UnmarshalJSON turns JSON into DirectoryContent and // introduces specific default-values where necessary. func (d *DirectoryContent) UnmarshalJSON(data []byte) error { type directoryContentAlias DirectoryContent defaultDirectoryContent := directoryContentAlias{ TotalCount: -1, } err := json.Unmarshal(data, &defaultDirectoryContent) if err != nil { return err } *d = DirectoryContent(defaultDirectoryContent) return nil } rclone-v1.71.0/backend/hidrive/helpers.go000066400000000000000000000713001505210326400202610ustar00rootroot00000000000000package hidrive // This file is for helper-functions which may provide more general and // specialized functionality than the generic interfaces. // There are two sections: // 1. methods bound to Fs // 2. other functions independent from Fs used throughout the package // NOTE: Functions accessing paths expect any relative paths // to be resolved prior to execution with resolvePath(...). import ( "bytes" "context" "errors" "io" "net/http" "path" "strconv" "sync" "time" "github.com/rclone/rclone/backend/hidrive/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/lib/ranges" "github.com/rclone/rclone/lib/readers" "github.com/rclone/rclone/lib/rest" "golang.org/x/sync/errgroup" "golang.org/x/sync/semaphore" ) const ( // MaximumUploadBytes represents the maximum amount of bytes // a single upload-operation will support. MaximumUploadBytes = 2147483647 // = 2GiB - 1 // iterationChunkSize represents the chunk size used to iterate directory contents. iterationChunkSize = 5000 ) var ( // retryErrorCodes is a slice of error codes that we will always retry. retryErrorCodes = []int{ 429, // Too Many Requests 500, // Internal Server Error 502, // Bad Gateway 503, // Service Unavailable 504, // Gateway Timeout 509, // Bandwidth Limit Exceeded } // ErrorFileExists is returned when a query tries to create a file // that already exists. ErrorFileExists = errors.New("destination file already exists") ) // MemberType represents the possible types of entries a directory can contain. type MemberType string // possible values for MemberType const ( AllMembers MemberType = "all" NoMembers MemberType = "none" DirectoryMembers MemberType = api.HiDriveObjectTypeDirectory FileMembers MemberType = api.HiDriveObjectTypeFile SymlinkMembers MemberType = api.HiDriveObjectTypeSymlink ) // SortByField represents possible fields to sort entries of a directory by. type SortByField string // possible values for SortByField const ( descendingSort string = "-" SortByName SortByField = "name" SortByModTime SortByField = "mtime" SortByObjectType SortByField = "type" SortBySize SortByField = "size" SortByNameDescending SortByField = SortByField(descendingSort) + SortByName SortByModTimeDescending SortByField = SortByField(descendingSort) + SortByModTime SortByObjectTypeDescending SortByField = SortByField(descendingSort) + SortByObjectType SortBySizeDescending SortByField = SortByField(descendingSort) + SortBySize ) var ( // Unsorted disables sorting and can therefore not be combined with other values. Unsorted = []SortByField{"none"} // DefaultSorted does not specify how to sort and // therefore implies the default sort order. DefaultSorted = []SortByField{} ) // CopyOrMoveOperationType represents the possible types of copy- and move-operations. type CopyOrMoveOperationType int // possible values for CopyOrMoveOperationType const ( MoveOriginal CopyOrMoveOperationType = iota CopyOriginal CopyOriginalPreserveModTime ) // OnExistAction represents possible actions the API should take, // when a request tries to create a path that already exists. type OnExistAction string // possible values for OnExistAction const ( // IgnoreOnExist instructs the API not to execute // the request in case of a conflict, but to return an error. IgnoreOnExist OnExistAction = "ignore" // AutoNameOnExist instructs the API to automatically rename // any conflicting request-objects. AutoNameOnExist OnExistAction = "autoname" // OverwriteOnExist instructs the API to overwrite any conflicting files. // This can only be used, if the request operates on files directly. // (For example when moving/copying a file.) // For most requests this action will simply be ignored. OverwriteOnExist OnExistAction = "overwrite" ) // shouldRetry returns a boolean as to whether this resp and err deserve to be retried. // It tries to expire/invalidate the token, if necessary. // It returns the err as a convenience. func (f *Fs) shouldRetry(ctx context.Context, resp *http.Response, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } if resp != nil && (resp.StatusCode == 401 || isHTTPError(err, 401)) && len(resp.Header["Www-Authenticate"]) > 0 { fs.Debugf(f, "Token might be invalid: %v", err) if f.tokenRenewer != nil { iErr := f.tokenRenewer.Expire() if iErr == nil { return true, err } } } return fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(resp, retryErrorCodes), err } // resolvePath resolves the given (relative) path and // returns a path suitable for API-calls. // This will consider the root-path of the fs and any needed prefixes. // // Any relative paths passed to functions that access these paths should // be resolved with this first! func (f *Fs) resolvePath(objectPath string) string { resolved := path.Join(f.opt.RootPrefix, f.root, f.opt.Enc.FromStandardPath(objectPath)) return resolved } // iterateOverDirectory calls the given function callback // on each item found in a given directory. // // If callback ever returns true then this exits early with found = true. func (f *Fs) iterateOverDirectory(ctx context.Context, directory string, searchOnly MemberType, callback func(*api.HiDriveObject) bool, fields []string, sortBy []SortByField) (found bool, err error) { parameters := api.NewQueryParameters() parameters.SetPath(directory) parameters.AddFields("members.", fields...) parameters.AddFields("", api.DirectoryContentFields...) parameters.Set("members", string(searchOnly)) for _, v := range sortBy { // The explicit conversion is necessary for each element. parameters.AddList("sort", ",", string(v)) } opts := rest.Opts{ Method: "GET", Path: "/dir", Parameters: parameters.Values, } iterateContent := func(result *api.DirectoryContent, err error) (bool, error) { if err != nil { return false, err } for _, item := range result.Entries { item.Name = f.opt.Enc.ToStandardName(item.Name) if callback(&item) { return true, nil } } return false, nil } return f.paginateDirectoryAccess(ctx, &opts, iterationChunkSize, 0, iterateContent) } // paginateDirectoryAccess executes requests specified via ctx and opts // which should produce api.DirectoryContent. // This will paginate the requests using limit starting at the given offset. // // The given function callback is called on each api.DirectoryContent found // along with any errors that occurred. // If callback ever returns true then this exits early with found = true. // If callback ever returns an error then this exits early with that error. func (f *Fs) paginateDirectoryAccess(ctx context.Context, opts *rest.Opts, limit int64, offset int64, callback func(*api.DirectoryContent, error) (bool, error)) (found bool, err error) { for { opts.Parameters.Set("limit", strconv.FormatInt(offset, 10)+","+strconv.FormatInt(limit, 10)) var result api.DirectoryContent var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, opts, nil, &result) return f.shouldRetry(ctx, resp, err) }) found, err = callback(&result, err) if found || err != nil { return found, err } offset += int64(len(result.Entries)) if offset >= result.TotalCount || limit > int64(len(result.Entries)) { break } } return false, nil } // fetchMetadataForPath reads the metadata from the path. func (f *Fs) fetchMetadataForPath(ctx context.Context, path string, fields []string) (*api.HiDriveObject, error) { parameters := api.NewQueryParameters() parameters.SetPath(path) parameters.AddFields("", fields...) opts := rest.Opts{ Method: "GET", Path: "/meta", Parameters: parameters.Values, } var result api.HiDriveObject var resp *http.Response var err error err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return f.shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } return &result, nil } // copyOrMove copies or moves a directory or file // from the source-path to the destination-path. // // The operation will only be successful // if the parent-directory of the destination-path exists. // // NOTE: Use the explicit methods instead of directly invoking this method. // (Those are: copyDirectory, moveDirectory, copyFile, moveFile.) func (f *Fs) copyOrMove(ctx context.Context, isDirectory bool, operationType CopyOrMoveOperationType, source string, destination string, onExist OnExistAction) (*api.HiDriveObject, error) { parameters := api.NewQueryParameters() parameters.Set("src", source) parameters.Set("dst", destination) if onExist == AutoNameOnExist || (onExist == OverwriteOnExist && !isDirectory) { parameters.Set("on_exist", string(onExist)) } endpoint := "/" if isDirectory { endpoint += "dir" } else { endpoint += "file" } switch operationType { case MoveOriginal: endpoint += "/move" case CopyOriginalPreserveModTime: parameters.Set("preserve_mtime", strconv.FormatBool(true)) fallthrough case CopyOriginal: endpoint += "/copy" } opts := rest.Opts{ Method: "POST", Path: endpoint, Parameters: parameters.Values, } var result api.HiDriveObject var resp *http.Response var err error err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return f.shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } return &result, nil } // moveDirectory moves the directory at the source-path to the destination-path and // returns the resulting api-object if successful. // // The operation will only be successful // if the parent-directory of the destination-path exists. func (f *Fs) moveDirectory(ctx context.Context, source string, destination string, onExist OnExistAction) (*api.HiDriveObject, error) { return f.copyOrMove(ctx, true, MoveOriginal, source, destination, onExist) } // copyFile copies the file at the source-path to the destination-path and // returns the resulting api-object if successful. // // The operation will only be successful // if the parent-directory of the destination-path exists. // // NOTE: This operation will expand sparse areas in the content of the source-file // to blocks of 0-bytes in the destination-file. func (f *Fs) copyFile(ctx context.Context, source string, destination string, onExist OnExistAction) (*api.HiDriveObject, error) { return f.copyOrMove(ctx, false, CopyOriginalPreserveModTime, source, destination, onExist) } // moveFile moves the file at the source-path to the destination-path and // returns the resulting api-object if successful. // // The operation will only be successful // if the parent-directory of the destination-path exists. // // NOTE: This operation may expand sparse areas in the content of the source-file // to blocks of 0-bytes in the destination-file. func (f *Fs) moveFile(ctx context.Context, source string, destination string, onExist OnExistAction) (*api.HiDriveObject, error) { return f.copyOrMove(ctx, false, MoveOriginal, source, destination, onExist) } // createDirectory creates the directory at the given path and // returns the resulting api-object if successful. // // The directory will only be created if its parent-directory exists. // This returns fs.ErrorDirNotFound if the parent-directory is not found. // This returns fs.ErrorDirExists if the directory already exists. func (f *Fs) createDirectory(ctx context.Context, directory string, onExist OnExistAction) (*api.HiDriveObject, error) { parameters := api.NewQueryParameters() parameters.SetPath(directory) if onExist == AutoNameOnExist { parameters.Set("on_exist", string(onExist)) } opts := rest.Opts{ Method: "POST", Path: "/dir", Parameters: parameters.Values, } var result api.HiDriveObject var resp *http.Response var err error err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return f.shouldRetry(ctx, resp, err) }) switch { case err == nil: return &result, nil case isHTTPError(err, 404): return nil, fs.ErrorDirNotFound case isHTTPError(err, 409): return nil, fs.ErrorDirExists } return nil, err } // createDirectories creates the directory at the given path // along with any missing parent directories and // returns the resulting api-object (of the created directory) if successful. // // This returns fs.ErrorDirExists if the directory already exists. // // If an error occurs while the parent directories are being created, // any directories already created will NOT be deleted again. func (f *Fs) createDirectories(ctx context.Context, directory string, onExist OnExistAction) (*api.HiDriveObject, error) { result, err := f.createDirectory(ctx, directory, onExist) if err == nil { return result, nil } if err != fs.ErrorDirNotFound { return nil, err } parentDirectory := path.Dir(directory) _, err = f.createDirectories(ctx, parentDirectory, onExist) if err != nil && err != fs.ErrorDirExists { return nil, err } // NOTE: Ignoring fs.ErrorDirExists does no harm, // since it does not mean the child directory cannot be created. return f.createDirectory(ctx, directory, onExist) } // deleteDirectory deletes the directory at the given path. // // If recursive is false, the directory will only be deleted if it is empty. // If recursive is true, the directory will be deleted regardless of its content. // This returns fs.ErrorDirNotFound if the directory is not found. // This returns fs.ErrorDirectoryNotEmpty if the directory is not empty and // recursive is false. func (f *Fs) deleteDirectory(ctx context.Context, directory string, recursive bool) error { parameters := api.NewQueryParameters() parameters.SetPath(directory) parameters.Set("recursive", strconv.FormatBool(recursive)) opts := rest.Opts{ Method: "DELETE", Path: "/dir", Parameters: parameters.Values, NoResponse: true, } var resp *http.Response var err error err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.Call(ctx, &opts) return f.shouldRetry(ctx, resp, err) }) switch { case isHTTPError(err, 404): return fs.ErrorDirNotFound case isHTTPError(err, 409): return fs.ErrorDirectoryNotEmpty } return err } // deleteObject deletes the object/file at the given path. // // This returns fs.ErrorObjectNotFound if the object is not found. func (f *Fs) deleteObject(ctx context.Context, path string) error { parameters := api.NewQueryParameters() parameters.SetPath(path) opts := rest.Opts{ Method: "DELETE", Path: "/file", Parameters: parameters.Values, NoResponse: true, } var resp *http.Response var err error err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.Call(ctx, &opts) return f.shouldRetry(ctx, resp, err) }) if isHTTPError(err, 404) { return fs.ErrorObjectNotFound } return err } // createFile creates a file at the given path // with the content of the io.ReadSeeker. // This guarantees that existing files will not be overwritten. // The maximum size of the content is limited by MaximumUploadBytes. // The io.ReadSeeker should be resettable by seeking to its start. // If modTime is not the zero time instant, // it will be set as the file's modification time after the operation. // // This returns fs.ErrorDirNotFound // if the parent directory of the file is not found. // This returns ErrorFileExists if a file already exists at the specified path. func (f *Fs) createFile(ctx context.Context, path string, content io.ReadSeeker, modTime time.Time, onExist OnExistAction) (*api.HiDriveObject, error) { parameters := api.NewQueryParameters() parameters.SetFileInDirectory(path) if onExist == AutoNameOnExist { parameters.Set("on_exist", string(onExist)) } var err error if !modTime.IsZero() { err = parameters.SetTime("mtime", modTime) if err != nil { return nil, err } } opts := rest.Opts{ Method: "POST", Path: "/file", Body: content, ContentType: "application/octet-stream", Parameters: parameters.Values, } var result api.HiDriveObject var resp *http.Response err = f.pacer.Call(func() (bool, error) { // Reset the reading index (in case this is a retry). if _, err = content.Seek(0, io.SeekStart); err != nil { return false, err } resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return f.shouldRetry(ctx, resp, err) }) switch { case err == nil: return &result, nil case isHTTPError(err, 404): return nil, fs.ErrorDirNotFound case isHTTPError(err, 409): return nil, ErrorFileExists } return nil, err } // overwriteFile updates the content of the file at the given path // with the content of the io.ReadSeeker. // If the file does not exist it will be created. // The maximum size of the content is limited by MaximumUploadBytes. // The io.ReadSeeker should be resettable by seeking to its start. // If modTime is not the zero time instant, // it will be set as the file's modification time after the operation. // // This returns fs.ErrorDirNotFound // if the parent directory of the file is not found. func (f *Fs) overwriteFile(ctx context.Context, path string, content io.ReadSeeker, modTime time.Time) (*api.HiDriveObject, error) { parameters := api.NewQueryParameters() parameters.SetFileInDirectory(path) var err error if !modTime.IsZero() { err = parameters.SetTime("mtime", modTime) if err != nil { return nil, err } } opts := rest.Opts{ Method: "PUT", Path: "/file", Body: content, ContentType: "application/octet-stream", Parameters: parameters.Values, } var result api.HiDriveObject var resp *http.Response err = f.pacer.Call(func() (bool, error) { // Reset the reading index (in case this is a retry). if _, err = content.Seek(0, io.SeekStart); err != nil { return false, err } resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return f.shouldRetry(ctx, resp, err) }) switch { case err == nil: return &result, nil case isHTTPError(err, 404): return nil, fs.ErrorDirNotFound } return nil, err } // uploadFileChunked updates the content of the existing file at the given path // with the content of the io.Reader. // Returns the position of the last successfully written byte, stopping before the first failed write. // If nothing was written this will be 0. // Returns the resulting api-object if successful. // // Replaces the file contents by uploading multiple chunks of the given size in parallel. // Therefore this can and be used to upload files of any size efficiently. // The number of parallel transfers is limited by transferLimit which should larger than 0. // If modTime is not the zero time instant, // it will be set as the file's modification time after the operation. // // NOTE: This method uses updateFileChunked and may create sparse files, // if the upload of a chunk fails unexpectedly. // See note about sparse files in patchFile. // If any of the uploads fail, the process will be aborted and // the first error that occurred will be returned. // This is not an atomic operation, // therefore if the upload fails the file may be partially modified. // // This returns fs.ErrorObjectNotFound if the object is not found. func (f *Fs) uploadFileChunked(ctx context.Context, path string, content io.Reader, modTime time.Time, chunkSize int, transferLimit int64) (okSize uint64, info *api.HiDriveObject, err error) { okSize, err = f.updateFileChunked(ctx, path, content, 0, chunkSize, transferLimit) if err == nil { info, err = f.resizeFile(ctx, path, okSize, modTime) } return okSize, info, err } // updateFileChunked updates the content of the existing file at the given path // starting at the given offset. // Returns the position of the last successfully written byte, stopping before the first failed write. // If nothing was written this will be 0. // // Replaces the file contents starting from the given byte offset // with the content of the io.Reader. // If the offset is beyond the file end, the file is extended up to the offset. // // The upload is done multiple chunks of the given size in parallel. // Therefore this can and be used to upload files of any size efficiently. // The number of parallel transfers is limited by transferLimit which should larger than 0. // // NOTE: Because it is inefficient to set the modification time with every chunk, // setting it to a specific value must be done in a separate request // after this operation finishes. // // NOTE: This method uses patchFile and may create sparse files, // especially if the upload of a chunk fails unexpectedly. // See note about sparse files in patchFile. // If any of the uploads fail, the process will be aborted and // the first error that occurred will be returned. // This is not an atomic operation, // therefore if the upload fails the file may be partially modified. // // This returns fs.ErrorObjectNotFound if the object is not found. func (f *Fs) updateFileChunked(ctx context.Context, path string, content io.Reader, offset uint64, chunkSize int, transferLimit int64) (okSize uint64, err error) { var ( okChunksMu sync.Mutex // protects the variables below okChunks []ranges.Range ) g, gCtx := errgroup.WithContext(ctx) transferSemaphore := semaphore.NewWeighted(transferLimit) var readErr error startMoreTransfers := true zeroTime := time.Time{} for chunk := uint64(0); startMoreTransfers; chunk++ { // Acquire semaphore to limit number of transfers in parallel. readErr = transferSemaphore.Acquire(gCtx, 1) if readErr != nil { break } // Read a chunk of data. chunkReader, bytesRead, readErr := readerForChunk(content, chunkSize) if bytesRead < chunkSize { startMoreTransfers = false } if readErr != nil || bytesRead <= 0 { break } // Transfer the chunk. chunkOffset := uint64(chunkSize)*chunk + offset g.Go(func() error { // After this upload is done, // signal that another transfer can be started. defer transferSemaphore.Release(1) uploadErr := f.patchFile(gCtx, path, cachedReader(chunkReader), chunkOffset, zeroTime) if uploadErr == nil { // Remember successfully written chunks. okChunksMu.Lock() okChunks = append(okChunks, ranges.Range{Pos: int64(chunkOffset), Size: int64(bytesRead)}) okChunksMu.Unlock() fs.Debugf(f, "Done uploading chunk of size %v at offset %v.", bytesRead, chunkOffset) } else { fs.Infof(f, "Error while uploading chunk at offset %v. Error is %v.", chunkOffset, uploadErr) } return uploadErr }) } if readErr != nil { // Log the error in case it is later ignored because of an upload-error. fs.Infof(f, "Error while reading/preparing to upload a chunk. Error is %v.", readErr) } err = g.Wait() // Compute the first continuous range of the file content, // which does not contain any failed chunks. // Do not forget to add the file content up to the starting offset, // which is presumed to be already correct. rs := ranges.Ranges{} rs.Insert(ranges.Range{Pos: 0, Size: int64(offset)}) for _, chunkRange := range okChunks { rs.Insert(chunkRange) } if len(rs) > 0 && rs[0].Pos == 0 { okSize = uint64(rs[0].Size) } if err != nil { return okSize, err } if readErr != nil { return okSize, readErr } return okSize, nil } // patchFile updates the content of the existing file at the given path // starting at the given offset. // // Replaces the file contents starting from the given byte offset // with the content of the io.ReadSeeker. // If the offset is beyond the file end, the file is extended up to the offset. // The maximum size of the update is limited by MaximumUploadBytes. // The io.ReadSeeker should be resettable by seeking to its start. // If modTime is not the zero time instant, // it will be set as the file's modification time after the operation. // // NOTE: By extending the file up to the offset this may create sparse files, // which allocate less space on the file system than their apparent size indicates, // since holes between data chunks are "real" holes // and not regions made up of consecutive 0-bytes. // Subsequent operations (such as copying data) // usually expand the holes into regions of 0-bytes. // // This returns fs.ErrorObjectNotFound if the object is not found. func (f *Fs) patchFile(ctx context.Context, path string, content io.ReadSeeker, offset uint64, modTime time.Time) error { parameters := api.NewQueryParameters() parameters.SetPath(path) parameters.Set("offset", strconv.FormatUint(offset, 10)) if !modTime.IsZero() { err := parameters.SetTime("mtime", modTime) if err != nil { return err } } opts := rest.Opts{ Method: "PATCH", Path: "/file", Body: content, ContentType: "application/octet-stream", Parameters: parameters.Values, NoResponse: true, } var resp *http.Response var err error err = f.pacer.Call(func() (bool, error) { // Reset the reading index (in case this is a retry). _, err = content.Seek(0, io.SeekStart) if err != nil { return false, err } resp, err = f.srv.Call(ctx, &opts) if isHTTPError(err, 423) { return true, err } return f.shouldRetry(ctx, resp, err) }) if isHTTPError(err, 404) { return fs.ErrorObjectNotFound } return err } // resizeFile updates the existing file at the given path to be of the given size // and returns the resulting api-object if successful. // // If the given size is smaller than the current filesize, // the file is cut/truncated at that position. // If the given size is larger, the file is extended up to that position. // If modTime is not the zero time instant, // it will be set as the file's modification time after the operation. // // NOTE: By extending the file this may create sparse files, // which allocate less space on the file system than their apparent size indicates, // since holes between data chunks are "real" holes // and not regions made up of consecutive 0-bytes. // Subsequent operations (such as copying data) // usually expand the holes into regions of 0-bytes. // // This returns fs.ErrorObjectNotFound if the object is not found. func (f *Fs) resizeFile(ctx context.Context, path string, size uint64, modTime time.Time) (*api.HiDriveObject, error) { parameters := api.NewQueryParameters() parameters.SetPath(path) parameters.Set("size", strconv.FormatUint(size, 10)) if !modTime.IsZero() { err := parameters.SetTime("mtime", modTime) if err != nil { return nil, err } } opts := rest.Opts{ Method: "POST", Path: "/file/truncate", Parameters: parameters.Values, } var result api.HiDriveObject var resp *http.Response var err error err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.CallJSON(ctx, &opts, nil, &result) return f.shouldRetry(ctx, resp, err) }) switch { case err == nil: return &result, nil case isHTTPError(err, 404): return nil, fs.ErrorObjectNotFound } return nil, err } // ------------------------------------------------------------ // isHTTPError compares the numerical status code // of an api.Error to the given HTTP status. // // If the given error is not an api.Error or // a numerical status code could not be determined, this returns false. // Otherwise this returns whether the status code of the error is equal to the given status. func isHTTPError(err error, status int64) bool { if apiErr, ok := err.(*api.Error); ok { errStatus, decodeErr := apiErr.Code.Int64() if decodeErr == nil && errStatus == status { return true } } return false } // createHiDriveScopes creates oauth-scopes // from the given user-role and access-permissions. // // If the arguments are empty, they will not be included in the result. func createHiDriveScopes(role string, access string) []string { switch { case role != "" && access != "": return []string{access + "," + role} case role != "": return []string{role} case access != "": return []string{access} } return []string{} } // cachedReader returns a version of the reader that caches its contents and // can therefore be reset using Seek. func cachedReader(reader io.Reader) io.ReadSeeker { bytesReader, ok := reader.(*bytes.Reader) if ok { return bytesReader } repeatableReader, ok := reader.(*readers.RepeatableReader) if ok { return repeatableReader } return readers.NewRepeatableReader(reader) } // readerForChunk reads a chunk of bytes from reader (after handling any accounting). // Returns a new io.Reader (chunkReader) for that chunk // and the number of bytes that have been read from reader. func readerForChunk(reader io.Reader, length int) (chunkReader io.Reader, bytesRead int, err error) { // Unwrap any accounting from the input if present. reader, wrap := accounting.UnWrap(reader) // Read a chunk of data. buffer := make([]byte, length) bytesRead, err = io.ReadFull(reader, buffer) if err == io.EOF || err == io.ErrUnexpectedEOF { err = nil } if err != nil { return nil, bytesRead, err } // Truncate unused capacity. buffer = buffer[:bytesRead] // Use wrap to put any accounting back for chunkReader. return wrap(bytes.NewReader(buffer)), bytesRead, nil } rclone-v1.71.0/backend/hidrive/hidrive.go000066400000000000000000001004771505210326400202610ustar00rootroot00000000000000// Package hidrive provides an interface to the HiDrive object storage system. package hidrive // FIXME HiDrive only supports file or folder names of 255 characters or less. // Operations that create files or folders with longer names will throw an HTTP error: // - 422 Unprocessable Entity // A more graceful way for rclone to handle this may be desirable. import ( "context" "encoding/json" "errors" "fmt" "io" "net/http" "path" "strconv" "time" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/backend/hidrive/api" "github.com/rclone/rclone/backend/hidrive/hidrivehash" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/oauthutil" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/rest" ) const ( rcloneClientID = "6b0258fdda630d34db68a3ce3cbf19ae" rcloneEncryptedClientSecret = "GC7UDZ3Ra4jLcmfQSagKCDJ1JEy-mU6pBBhFrS3tDEHILrK7j3TQHUrglkO5SgZ_" minSleep = 10 * time.Millisecond maxSleep = 2 * time.Second decayConstant = 2 // bigger for slower decay, exponential defaultUploadChunkSize = 48 * fs.Mebi defaultUploadCutoff = 2 * defaultUploadChunkSize defaultUploadConcurrency = 4 ) // Globals var ( // Description of how to auth for this app. oauthConfig = &oauthutil.Config{ AuthURL: "https://my.hidrive.com/client/authorize", TokenURL: "https://my.hidrive.com/oauth2/token", ClientID: rcloneClientID, ClientSecret: obscure.MustReveal(rcloneEncryptedClientSecret), RedirectURL: oauthutil.TitleBarRedirectURL, } // hidrivehashType is the hash.Type for HiDrive hashes. hidrivehashType hash.Type ) // Register the backend with Fs. func init() { hidrivehashType = hash.RegisterHash("hidrive", "HiDriveHash", 40, hidrivehash.New) fs.Register(&fs.RegInfo{ Name: "hidrive", Description: "HiDrive", NewFs: NewFs, Config: func(ctx context.Context, name string, m configmap.Mapper, config fs.ConfigIn) (*fs.ConfigOut, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, fmt.Errorf("couldn't parse config into struct: %w", err) } //fs.Debugf(nil, "hidrive: configuring oauth-token.") oauthConfig.Scopes = createHiDriveScopes(opt.ScopeRole, opt.ScopeAccess) return oauthutil.ConfigOut("", &oauthutil.Options{ OAuth2Config: oauthConfig, }) }, Options: append(oauthutil.SharedOptions, []fs.Option{{ Name: "scope_access", Help: "Access permissions that rclone should use when requesting access from HiDrive.", Default: "rw", Examples: []fs.OptionExample{{ Value: "rw", Help: "Read and write access to resources.", }, { Value: "ro", Help: "Read-only access to resources.", }}, }, { Name: "scope_role", Help: "User-level that rclone should use when requesting access from HiDrive.", Default: "user", Examples: []fs.OptionExample{{ Value: "user", Help: `User-level access to management permissions. This will be sufficient in most cases.`, }, { Value: "admin", Help: "Extensive access to management permissions.", }, { Value: "owner", Help: "Full access to management permissions.", }}, Advanced: true, }, { Name: "root_prefix", Help: `The root/parent folder for all paths. Fill in to use the specified folder as the parent for all paths given to the remote. This way rclone can use any folder as its starting point.`, Default: "/", Examples: []fs.OptionExample{{ Value: "/", Help: `The topmost directory accessible by rclone. This will be equivalent with "root" if rclone uses a regular HiDrive user account.`, }, { Value: "root", Help: `The topmost directory of the HiDrive user account`, }, { Value: "", Help: `This specifies that there is no root-prefix for your paths. When using this you will always need to specify paths to this remote with a valid parent e.g. "remote:/path/to/dir" or "remote:root/path/to/dir".`, }}, Advanced: true, }, { Name: "endpoint", Help: `Endpoint for the service. This is the URL that API-calls will be made to.`, Default: "https://api.hidrive.strato.com/2.1", Advanced: true, }, { Name: "disable_fetching_member_count", Help: `Do not fetch number of objects in directories unless it is absolutely necessary. Requests may be faster if the number of objects in subdirectories is not fetched.`, Default: false, Advanced: true, }, { Name: "chunk_size", Help: fmt.Sprintf(`Chunksize for chunked uploads. Any files larger than the configured cutoff (or files of unknown size) will be uploaded in chunks of this size. The upper limit for this is %v bytes (about %v). That is the maximum amount of bytes a single upload-operation will support. Setting this above the upper limit or to a negative value will cause uploads to fail. Setting this to larger values may increase the upload speed at the cost of using more memory. It can be set to smaller values smaller to save on memory.`, MaximumUploadBytes, fs.SizeSuffix(MaximumUploadBytes)), Default: defaultUploadChunkSize, Advanced: true, }, { Name: "upload_cutoff", Help: fmt.Sprintf(`Cutoff/Threshold for chunked uploads. Any files larger than this will be uploaded in chunks of the configured chunksize. The upper limit for this is %v bytes (about %v). That is the maximum amount of bytes a single upload-operation will support. Setting this above the upper limit will cause uploads to fail.`, MaximumUploadBytes, fs.SizeSuffix(MaximumUploadBytes)), Default: defaultUploadCutoff, Advanced: true, }, { Name: "upload_concurrency", Help: `Concurrency for chunked uploads. This is the upper limit for how many transfers for the same file are running concurrently. Setting this above to a value smaller than 1 will cause uploads to deadlock. If you are uploading small numbers of large files over high-speed links and these uploads do not fully utilize your bandwidth, then increasing this may help to speed up the transfers.`, Default: defaultUploadConcurrency, Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, // HiDrive only supports file or folder names of 255 characters or less. // Names containing "/" are not supported. // The special names "." and ".." are not supported. Default: (encoder.EncodeZero | encoder.EncodeSlash | encoder.EncodeDot), }}...), }) } // Options defines the configuration for this backend. type Options struct { EndpointAPI string `config:"endpoint"` OptionalMemberCountDisabled bool `config:"disable_fetching_member_count"` UploadChunkSize fs.SizeSuffix `config:"chunk_size"` UploadCutoff fs.SizeSuffix `config:"upload_cutoff"` UploadConcurrency int64 `config:"upload_concurrency"` Enc encoder.MultiEncoder `config:"encoding"` RootPrefix string `config:"root_prefix"` ScopeAccess string `config:"scope_access"` ScopeRole string `config:"scope_role"` } // Fs represents a remote hidrive. type Fs struct { name string // name of this remote root string // the path we are working on opt Options // parsed options features *fs.Features // optional features srv *rest.Client // the connection to the server pacer *fs.Pacer // pacer for API calls // retryOnce is NOT intended as a pacer for API calls. // The intended use case is to repeat an action that failed because // some preconditions were not previously fulfilled. // Code using this should then establish these preconditions // and let the pacer retry the operation. retryOnce *pacer.Pacer // pacer with no delays to retry certain operations once tokenRenewer *oauthutil.Renew // renew the token on expiry } // Object describes a hidrive object. // // Will definitely have the remote-path but may lack meta-information. type Object struct { fs *Fs // what this object is part of remote string // The remote path hasMetadata bool // whether info below has been set size int64 // size of the object modTime time.Time // modification time of the object id string // ID of the object hash string // content-hash of the object } // ------------------------------------------------------------ // Name returns the name of the remote (as passed into NewFs). func (f *Fs) Name() string { return f.name } // Root returns the name of the remote (as passed into NewFs). func (f *Fs) Root() string { return f.root } // String returns a string-representation of this Fs. func (f *Fs) String() string { return fmt.Sprintf("HiDrive root '%s'", f.root) } // Precision returns the precision of this Fs. func (f *Fs) Precision() time.Duration { return time.Second } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hidrivehashType) } // Features returns the optional features of this Fs. func (f *Fs) Features() *fs.Features { return f.features } // errorHandler parses a non 2xx error response into an error. func errorHandler(resp *http.Response) error { // Decode error response. errResponse := new(api.Error) err := rest.DecodeJSON(resp, &errResponse) if err != nil { fs.Debugf(nil, "Couldn't decode error response: %v", err) } _, err = errResponse.Code.Int64() if err != nil { errResponse.Code = json.Number(strconv.Itoa(resp.StatusCode)) } return errResponse } // NewFs creates a new file system from the path. func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { //fs.Debugf(nil, "hidrive: creating new Fs.") // Parse config into Options struct. opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } // Clean root-prefix and root-path. // NOTE: With the default-encoding "." and ".." will be encoded, // but with custom encodings without encoder.EncodeDot // "." and ".." will be interpreted as paths. if opt.RootPrefix != "" { opt.RootPrefix = path.Clean(opt.Enc.FromStandardPath(opt.RootPrefix)) } root = path.Clean(opt.Enc.FromStandardPath(root)) client, ts, err := oauthutil.NewClient(ctx, name, m, oauthConfig) if err != nil { return nil, fmt.Errorf("failed to configure HiDrive: %w", err) } f := &Fs{ name: name, root: root, opt: *opt, srv: rest.NewClient(client).SetRoot(opt.EndpointAPI), pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), retryOnce: pacer.New(pacer.RetriesOption(2), pacer.MaxConnectionsOption(-1), pacer.CalculatorOption(&pacer.ZeroDelayCalculator{})), } f.features = (&fs.Features{ CanHaveEmptyDirectories: true, }).Fill(ctx, f) f.srv.SetErrorHandler(errorHandler) if ts != nil { transaction := func() error { resolvedRoot := f.resolvePath("") _, err := f.fetchMetadataForPath(ctx, resolvedRoot, api.HiDriveObjectNoMetadataFields) return err } f.tokenRenewer = oauthutil.NewRenew(f.String(), ts, transaction) } // Do not allow the root-prefix to be nonexistent nor a directory, // but it can be empty. if f.opt.RootPrefix != "" { item, err := f.fetchMetadataForPath(ctx, f.opt.RootPrefix, api.HiDriveObjectNoMetadataFields) if err != nil { return nil, fmt.Errorf("could not access root-prefix: %w", err) } if item.Type != api.HiDriveObjectTypeDirectory { return nil, errors.New("the root-prefix needs to point to a valid directory or be empty") } } resolvedRoot := f.resolvePath("") item, err := f.fetchMetadataForPath(ctx, resolvedRoot, api.HiDriveObjectNoMetadataFields) if err != nil { if isHTTPError(err, 404) { // NOTE: NewFs needs to work with paths that do not exist, // in case they will be created later (see mkdir). return f, nil } return nil, fmt.Errorf("could not access root-path: %w", err) } if item.Type != api.HiDriveObjectTypeDirectory { fs.Debugf(f, "The root is not a directory. Setting its parent-directory as the new root.") // NOTE: There is no need to check // if the parent-directory is inside the root-prefix: // If the parent-directory was outside, // then the resolved path would be the root-prefix, // therefore the root-prefix would point to a file, // which has already been checked for. // In case the root-prefix is empty, this needs not be checked, // because top-level files cannot exist. f.root = path.Dir(f.root) return f, fs.ErrorIsFile } return f, nil } // newObject constructs an Object by calling the given function metaFiller // on an Object with no metadata. // // metaFiller should set the metadata of the object or // return an appropriate error. func (f *Fs) newObject(remote string, metaFiller func(*Object) error) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } var err error if metaFiller != nil { err = metaFiller(o) } if err != nil { return nil, err } return o, nil } // newObjectFromHiDriveObject constructs an Object from the given api.HiDriveObject. func (f *Fs) newObjectFromHiDriveObject(remote string, info *api.HiDriveObject) (fs.Object, error) { metaFiller := func(o *Object) error { return o.setMetadata(info) } return f.newObject(remote, metaFiller) } // NewObject finds the Object at remote. // // If remote points to a directory then it returns fs.ErrorIsDir. // If it can not be found it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { //fs.Debugf(f, "executing NewObject(%s).", remote) metaFiller := func(o *Object) error { return o.readMetadata(ctx) } return f.newObject(remote, metaFiller) } // List the objects and directories in dir into entries. // The entries can be returned in any order, // but should be for a complete directory. // // dir should be "" to list the root, and should not have trailing slashes. // // This returns fs.ErrorDirNotFound if the directory is not found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { //fs.Debugf(f, "executing List(%s).", dir) var iErr error addEntry := func(info *api.HiDriveObject) bool { fs.Debugf(f, "found directory-element with name %s", info.Name) remote := path.Join(dir, info.Name) if info.Type == api.HiDriveObjectTypeDirectory { d := fs.NewDir(remote, info.ModTime()) d.SetID(info.ID) d.SetSize(info.Size) d.SetItems(info.MemberCount) entries = append(entries, d) } else if info.Type == api.HiDriveObjectTypeFile { o, err := f.newObjectFromHiDriveObject(remote, info) if err != nil { iErr = err return true } entries = append(entries, o) } return false } var fields []string if f.opt.OptionalMemberCountDisabled { fields = api.HiDriveObjectWithMetadataFields } else { fields = api.HiDriveObjectWithDirectoryMetadataFields } resolvedDir := f.resolvePath(dir) _, err = f.iterateOverDirectory(ctx, resolvedDir, AllMembers, addEntry, fields, Unsorted) if err != nil { if isHTTPError(err, 404) { return nil, fs.ErrorDirNotFound } return nil, err } if iErr != nil { return nil, iErr } return entries, nil } // Put the contents of the io.Reader into the remote path // with the modTime given of the given size. // The existing or new object is returned. // // A new object may have been created or // an existing one accessed even if an error is returned, // in which case both the object and the error will be returned. func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { remote := src.Remote() //fs.Debugf(f, "executing Put(%s, %v).", remote, options) existingObj, err := f.NewObject(ctx, remote) switch err { case nil: return existingObj, existingObj.Update(ctx, in, src, options...) case fs.ErrorObjectNotFound: // Object was not found, so create a new one. return f.PutUnchecked(ctx, in, src, options...) } return nil, err } // PutStream uploads the contents of the io.Reader to the remote path // with the modTime given of indeterminate size. // The existing or new object is returned. // // A new object may have been created or // an existing one accessed even if an error is returned, // in which case both the object and the error will be returned. func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { //fs.Debugf(f, "executing PutStream(%s, %v).", src.Remote(), options) return f.Put(ctx, in, src, options...) } // PutUnchecked the contents of the io.Reader into the remote path // with the modTime given of the given size. // This guarantees that existing objects will not be overwritten. // The new object is returned. // // This will produce an error if an object already exists at that path. // // In case the upload fails and an object has been created, // this will try to delete the object at that path. // In case the failed upload could not be deleted, // both the object and the (upload-)error will be returned. func (f *Fs) PutUnchecked(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { remote := src.Remote() modTime := src.ModTime(ctx) //fs.Debugf(f, "executing PutUnchecked(%s, %v).", remote, options) resolvedPath := f.resolvePath(remote) // NOTE: The file creation operation is a single atomic operation. // Thus uploading as much content as is reasonable // (i.e. everything up to the cutoff) in the first request, // avoids files being created on upload failure for small files. // (As opposed to creating an empty file and then uploading the content.) tmpReader, bytesRead, err := readerForChunk(in, int(f.opt.UploadCutoff)) cutoffReader := cachedReader(tmpReader) if err != nil { return nil, err } var info *api.HiDriveObject err = f.retryOnce.Call(func() (bool, error) { var createErr error // Reset the reading index (in case this is a retry). if _, createErr = cutoffReader.Seek(0, io.SeekStart); createErr != nil { return false, createErr } info, createErr = f.createFile(ctx, resolvedPath, cutoffReader, modTime, IgnoreOnExist) if createErr == fs.ErrorDirNotFound { // Create the parent-directory for the object and repeat request. _, parentErr := f.createDirectories(ctx, path.Dir(resolvedPath), IgnoreOnExist) if parentErr != nil && parentErr != fs.ErrorDirExists { fs.Errorf(f, "Tried to create parent-directory for '%s', but failed.", resolvedPath) return false, parentErr } return true, createErr } return false, createErr }) if err != nil { return nil, err } o, err := f.newObjectFromHiDriveObject(remote, info) if err != nil { return nil, err } if fs.SizeSuffix(bytesRead) < f.opt.UploadCutoff { return o, nil } // If there is more left to write, o.Update needs to skip ahead. // Use a fs.SeekOption with the current offset to do this. options = append(options, &fs.SeekOption{Offset: int64(bytesRead)}) err = o.Update(ctx, in, src, options...) if err == nil { return o, nil } // Try to remove object at path after the its content could not be uploaded. deleteErr := f.pacer.Call(func() (bool, error) { deleteErr := o.Remove(ctx) return deleteErr == fs.ErrorObjectNotFound, deleteErr }) if deleteErr == nil { return nil, err } fs.Errorf(f, "Tried to delete failed upload at path '%s', but failed: %v", resolvedPath, deleteErr) return o, err } // Mkdir creates the directory if it does not exist. // // This will create any missing parent directories. // // NOTE: If an error occurs while the parent directories are being created, // any directories already created will NOT be deleted again. func (f *Fs) Mkdir(ctx context.Context, dir string) error { //fs.Debugf(f, "executing Mkdir(%s).", dir) resolvedDir := f.resolvePath(dir) _, err := f.createDirectories(ctx, resolvedDir, IgnoreOnExist) if err == fs.ErrorDirExists { // NOTE: The conflict is caused by the directory already existing, // which should be ignored here. return nil } return err } // Rmdir removes the directory if empty. // // This returns fs.ErrorDirNotFound if the directory is not found. // This returns fs.ErrorDirectoryNotEmpty if the directory is not empty. func (f *Fs) Rmdir(ctx context.Context, dir string) error { //fs.Debugf(f, "executing Rmdir(%s).", dir) resolvedDir := f.resolvePath(dir) return f.deleteDirectory(ctx, resolvedDir, false) } // Purge removes the directory and all of its contents. // // This returns fs.ErrorDirectoryNotEmpty if the directory is not empty. func (f *Fs) Purge(ctx context.Context, dir string) error { //fs.Debugf(f, "executing Purge(%s).", dir) resolvedDir := f.resolvePath(dir) return f.deleteDirectory(ctx, resolvedDir, true) } // shouldRetryAndCreateParents returns a boolean as to whether the operation // should be retried after the parent-directories of the destination have been created. // If so, it will create the parent-directories. // // If any errors arise while finding the source or // creating the parent-directory those will be returned. // Otherwise returns the originalError. func (f *Fs) shouldRetryAndCreateParents(ctx context.Context, destinationPath string, sourcePath string, originalError error) (bool, error) { if fserrors.ContextError(ctx, &originalError) { return false, originalError } if isHTTPError(originalError, 404) { // Check if source is missing. _, srcErr := f.fetchMetadataForPath(ctx, sourcePath, api.HiDriveObjectNoMetadataFields) if srcErr != nil { return false, srcErr } // Source exists, so the parent of the destination must have been missing. // Create the parent-directory and repeat request. _, parentErr := f.createDirectories(ctx, path.Dir(destinationPath), IgnoreOnExist) if parentErr != nil && parentErr != fs.ErrorDirExists { fs.Errorf(f, "Tried to create parent-directory for '%s', but failed.", destinationPath) return false, parentErr } return true, originalError } return false, originalError } // Copy src to this remote using server-side copy operations. // // It returns the destination Object and a possible error. // // This returns fs.ErrorCantCopy if the operation cannot be performed. // // NOTE: If an error occurs when copying the Object, // any parent-directories already created will NOT be deleted again. // // NOTE: This operation will expand sparse areas in the content of the source-Object // to blocks of 0-bytes in the destination-Object. 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 } // Get the absolute path to the source. srcPath := srcObj.fs.resolvePath(srcObj.Remote()) //fs.Debugf(f, "executing Copy(%s, %s).", srcPath, remote) dstPath := f.resolvePath(remote) var info *api.HiDriveObject err := f.retryOnce.Call(func() (bool, error) { var copyErr error info, copyErr = f.copyFile(ctx, srcPath, dstPath, OverwriteOnExist) return f.shouldRetryAndCreateParents(ctx, dstPath, srcPath, copyErr) }) if err != nil { return nil, err } dstObj, err := f.newObjectFromHiDriveObject(remote, info) if err != nil { return nil, err } return dstObj, nil } // Move src to this remote using server-side move operations. // // It returns the destination Object and a possible error. // // This returns fs.ErrorCantMove if the operation cannot be performed. // // NOTE: If an error occurs when moving the Object, // any parent-directories already created will NOT be deleted again. // // NOTE: This operation will expand sparse areas in the content of the source-Object // to blocks of 0-bytes in the destination-Object. 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 } // Get the absolute path to the source. srcPath := srcObj.fs.resolvePath(srcObj.Remote()) //fs.Debugf(f, "executing Move(%s, %s).", srcPath, remote) dstPath := f.resolvePath(remote) var info *api.HiDriveObject err := f.retryOnce.Call(func() (bool, error) { var moveErr error info, moveErr = f.moveFile(ctx, srcPath, dstPath, OverwriteOnExist) return f.shouldRetryAndCreateParents(ctx, dstPath, srcPath, moveErr) }) if err != nil { return nil, err } dstObj, err := f.newObjectFromHiDriveObject(remote, info) if err != nil { return nil, err } return dstObj, nil } // DirMove moves from src at srcRemote to this remote at dstRemote // using server-side move operations. // // This returns fs.ErrorCantCopy if the operation cannot be performed. // This returns fs.ErrorDirExists if the destination already exists. // // NOTE: If an error occurs when moving the directory, // any parent-directories already created will NOT be deleted again. func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } // Get the absolute path to the source. srcPath := srcFs.resolvePath(srcRemote) //fs.Debugf(f, "executing DirMove(%s, %s).", srcPath, dstRemote) dstPath := f.resolvePath(dstRemote) err := f.retryOnce.Call(func() (bool, error) { var moveErr error _, moveErr = f.moveDirectory(ctx, srcPath, dstPath, IgnoreOnExist) return f.shouldRetryAndCreateParents(ctx, dstPath, srcPath, moveErr) }) if err != nil { if isHTTPError(err, 409) { return fs.ErrorDirExists } return err } return nil } // Shutdown shutdown the fs func (f *Fs) Shutdown(ctx context.Context) error { f.tokenRenewer.Shutdown() return nil } // ------------------------------------------------------------ // Fs returns the parent Fs. func (o *Object) Fs() fs.Info { return o.fs } // String returns a string-representation of this Object. func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path. func (o *Object) Remote() string { return o.remote } // ID returns the ID of the Object if known, or "" if not. func (o *Object) ID() string { err := o.readMetadata(context.TODO()) if err != nil { fs.Logf(o, "Failed to read metadata: %v", err) return "" } return o.id } // Hash returns the selected checksum of the file. // If no checksum is available it returns "". func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { err := o.readMetadata(ctx) if err != nil { return "", fmt.Errorf("failed to read hash from metadata: %w", err) } switch t { case hidrivehashType: return o.hash, nil default: return "", hash.ErrUnsupported } } // Size returns the size of an object in bytes. func (o *Object) Size() int64 { err := o.readMetadata(context.TODO()) if err != nil { fs.Logf(o, "Failed to read metadata: %v", err) return -1 } return o.size } // setMetadata sets the metadata from info. func (o *Object) setMetadata(info *api.HiDriveObject) error { if info.Type == api.HiDriveObjectTypeDirectory { return fs.ErrorIsDir } if info.Type != api.HiDriveObjectTypeFile { return fmt.Errorf("%q is %q: %w", o.remote, info.Type, fs.ErrorNotAFile) } o.hasMetadata = true o.size = info.Size o.modTime = info.ModTime() o.id = info.ID o.hash = info.ContentHash return nil } // readMetadata fetches the metadata if it has not already been fetched. func (o *Object) readMetadata(ctx context.Context) error { if o.hasMetadata { return nil } resolvedPath := o.fs.resolvePath(o.remote) info, err := o.fs.fetchMetadataForPath(ctx, resolvedPath, api.HiDriveObjectWithMetadataFields) if err != nil { if isHTTPError(err, 404) { return fs.ErrorObjectNotFound } return err } return o.setMetadata(info) } // ModTime returns the modification time of the object. func (o *Object) ModTime(ctx context.Context) time.Time { err := o.readMetadata(ctx) if err != nil { fs.Logf(o, "Failed to read metadata: %v", err) return time.Now() } return o.modTime } // SetModTime sets the metadata on the object to set the modification date. func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { parameters := api.NewQueryParameters() resolvedPath := o.fs.resolvePath(o.remote) parameters.SetPath(resolvedPath) err := parameters.SetTime("mtime", modTime) if err != nil { return err } opts := rest.Opts{ Method: "PATCH", Path: "/meta", Parameters: parameters.Values, NoResponse: true, } var resp *http.Response err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.Call(ctx, &opts) return o.fs.shouldRetry(ctx, resp, err) }) if err != nil { return err } o.modTime = modTime return nil } // Storable says whether this object can be stored. func (o *Object) Storable() bool { return true } // Open an object for reading. func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { parameters := api.NewQueryParameters() resolvedPath := o.fs.resolvePath(o.remote) parameters.SetPath(resolvedPath) fs.FixRangeOption(options, o.Size()) opts := rest.Opts{ Method: "GET", Path: "/file", Parameters: parameters.Values, Options: options, } var resp *http.Response var err error err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.Call(ctx, &opts) return o.fs.shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } return resp.Body, err } // Update the existing object // with the contents of the io.Reader, modTime and size. // // For unknown-sized contents (indicated by src.Size() == -1) // this will try to properly upload it in multiple chunks. func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { //fs.Debugf(o.fs, "executing Update(%s, %v).", o.remote, options) modTime := src.ModTime(ctx) resolvedPath := o.fs.resolvePath(o.remote) if o.fs.tokenRenewer != nil { o.fs.tokenRenewer.Start() defer o.fs.tokenRenewer.Stop() } // PutUnchecked can pass a valid SeekOption to skip ahead. var offset uint64 for _, option := range options { if seekoption, ok := option.(*fs.SeekOption); ok { offset = uint64(seekoption.Offset) break } } var info *api.HiDriveObject var err, metaErr error if offset > 0 || src.Size() == -1 || src.Size() >= int64(o.fs.opt.UploadCutoff) { fs.Debugf(o.fs, "Uploading with chunks of size %v and %v transfers in parallel at path '%s'.", int(o.fs.opt.UploadChunkSize), o.fs.opt.UploadConcurrency, resolvedPath) // NOTE: o.fs.opt.UploadChunkSize should always // be between 0 and MaximumUploadBytes, // so the conversion to an int does not cause problems for valid inputs. if offset > 0 { // NOTE: The offset is only set // when the file was newly created, // therefore the file does not need truncating. _, err = o.fs.updateFileChunked(ctx, resolvedPath, in, offset, int(o.fs.opt.UploadChunkSize), o.fs.opt.UploadConcurrency) if err == nil { err = o.SetModTime(ctx, modTime) } } else { _, _, err = o.fs.uploadFileChunked(ctx, resolvedPath, in, modTime, int(o.fs.opt.UploadChunkSize), o.fs.opt.UploadConcurrency) } // Try to check if object was updated, either way. // Metadata should be updated even if the upload fails. info, metaErr = o.fs.fetchMetadataForPath(ctx, resolvedPath, api.HiDriveObjectWithMetadataFields) } else { info, err = o.fs.overwriteFile(ctx, resolvedPath, cachedReader(in), modTime) metaErr = err } // Update metadata of this object, // if there was no error with getting the metadata. if metaErr == nil { metaErr = o.setMetadata(info) } // Errors with the upload-process are more relevant, return those first. if err != nil { return err } return metaErr } // Remove an object. func (o *Object) Remove(ctx context.Context) error { resolvedPath := o.fs.resolvePath(o.remote) return o.fs.deleteObject(ctx, resolvedPath) } // Check the interfaces are satisfied. var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.PutStreamer = (*Fs)(nil) _ fs.PutUncheckeder = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.Shutdowner = (*Fs)(nil) _ fs.Object = (*Object)(nil) _ fs.IDer = (*Object)(nil) ) rclone-v1.71.0/backend/hidrive/hidrive_test.go000066400000000000000000000022551505210326400213130ustar00rootroot00000000000000// Test HiDrive filesystem interface package hidrive import ( "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote. func TestIntegration(t *testing.T) { name := "TestHiDrive" fstests.Run(t, &fstests.Opt{ RemoteName: name + ":", NilObject: (*Object)(nil), ChunkedUpload: fstests.ChunkedUploadConfig{ MinChunkSize: 1, MaxChunkSize: MaximumUploadBytes, CeilChunkSize: nil, NeedMultipleChunks: false, }, }) } // Change the configured UploadChunkSize. // Will only be called while no transfer is in progress. func (f *Fs) SetUploadChunkSize(chunksize fs.SizeSuffix) (fs.SizeSuffix, error) { var old fs.SizeSuffix old, f.opt.UploadChunkSize = f.opt.UploadChunkSize, chunksize return old, nil } // Change the configured UploadCutoff. // Will only be called while no transfer is in progress. func (f *Fs) SetUploadCutoff(cutoff fs.SizeSuffix) (fs.SizeSuffix, error) { var old fs.SizeSuffix old, f.opt.UploadCutoff = f.opt.UploadCutoff, cutoff return old, nil } var ( _ fstests.SetUploadChunkSizer = (*Fs)(nil) _ fstests.SetUploadCutoffer = (*Fs)(nil) ) rclone-v1.71.0/backend/hidrive/hidrivehash/000077500000000000000000000000001505210326400205655ustar00rootroot00000000000000rclone-v1.71.0/backend/hidrive/hidrivehash/hidrivehash.go000066400000000000000000000305171505210326400234200ustar00rootroot00000000000000// Package hidrivehash implements the HiDrive hashing algorithm which combines SHA-1 hashes hierarchically to a single top-level hash. // // Note: This implementation does not grant access to any partial hashes generated. // // See: https://developer.hidrive.com/wp-content/uploads/2021/07/HiDrive_Synchronization-v3.3-rev28.pdf // (link to newest version: https://static.hidrive.com/dev/0001) package hidrivehash import ( "bytes" "crypto/sha1" "encoding" "encoding/binary" "errors" "fmt" "hash" "io" "github.com/rclone/rclone/backend/hidrive/hidrivehash/internal" ) const ( // BlockSize of the checksum in bytes. BlockSize = 4096 // Size of the checksum in bytes. Size = sha1.Size // sumsPerLevel is the number of checksums sumsPerLevel = 256 ) var ( // zeroSum is a special hash consisting of 20 null-bytes. // This will be the hash of any empty file (or ones containing only null-bytes). zeroSum = [Size]byte{} // ErrorInvalidEncoding is returned when a hash should be decoded from a binary form that is invalid. ErrorInvalidEncoding = errors.New("encoded binary form is invalid for this hash") // ErrorHashFull is returned when a hash reached its capacity and cannot accept any more input. ErrorHashFull = errors.New("hash reached its capacity") ) // writeByBlock writes len(p) bytes from p to the io.Writer in blocks of size blockSize. // It returns the number of bytes written from p (0 <= n <= len(p)) // and any error encountered that caused the write to stop early. // // A pointer bytesInBlock to a counter needs to be supplied, // that is used to keep track how many bytes have been written to the writer already. // A pointer onlyNullBytesInBlock to a boolean needs to be supplied, // that is used to keep track whether the block so far only consists of null-bytes. // The callback onBlockWritten is called whenever a full block has been written to the writer // and is given as input the number of bytes that still need to be written. func writeByBlock(p []byte, writer io.Writer, blockSize uint32, bytesInBlock *uint32, onlyNullBytesInBlock *bool, onBlockWritten func(remaining int) error) (n int, err error) { total := len(p) nullBytes := make([]byte, blockSize) for len(p) > 0 { toWrite := min(int(blockSize-*bytesInBlock), len(p)) c, err := writer.Write(p[:toWrite]) *bytesInBlock += uint32(c) *onlyNullBytesInBlock = *onlyNullBytesInBlock && bytes.Equal(nullBytes[:toWrite], p[:toWrite]) // Discard data written through a reslice p = p[c:] if err != nil { return total - len(p), err } if *bytesInBlock == blockSize { err = onBlockWritten(len(p)) if err != nil { return total - len(p), err } *bytesInBlock = 0 *onlyNullBytesInBlock = true } } return total, nil } // level is a hash.Hash that is used to aggregate the checksums produced by the level hierarchically beneath it. // It is used to represent any level-n hash, except for level-0. type level struct { checksum [Size]byte // aggregated checksum of this level sumCount uint32 // number of sums contained in this level so far bytesInHasher uint32 // number of bytes written into hasher so far onlyNullBytesInHasher bool // whether the hasher only contains null-bytes so far hasher hash.Hash } // NewLevel returns a new hash.Hash computing any level-n hash, except level-0. func NewLevel() hash.Hash { l := &level{} l.Reset() return l } // Add takes a position-embedded SHA-1 checksum and adds it to the level. func (l *level) Add(sha1sum []byte) { var tmp uint var carry bool for i := Size - 1; i >= 0; i-- { tmp = uint(sha1sum[i]) + uint(l.checksum[i]) if carry { tmp++ } carry = tmp > 255 l.checksum[i] = byte(tmp) } } // IsFull returns whether the number of checksums added to this level reached its capacity. func (l *level) IsFull() bool { return l.sumCount >= sumsPerLevel } // Write (via the embedded io.Writer interface) adds more data to the running hash. // Contrary to the specification from hash.Hash, this DOES return an error, // specifically ErrorHashFull if and only if IsFull() returns true. func (l *level) Write(p []byte) (n int, err error) { if l.IsFull() { return 0, ErrorHashFull } onBlockWritten := func(remaining int) error { if !l.onlyNullBytesInHasher { c, err := l.hasher.Write([]byte{byte(l.sumCount)}) l.bytesInHasher += uint32(c) if err != nil { return err } l.Add(l.hasher.Sum(nil)) } l.sumCount++ l.hasher.Reset() if remaining > 0 && l.IsFull() { return ErrorHashFull } return nil } return writeByBlock(p, l.hasher, uint32(l.BlockSize()), &l.bytesInHasher, &l.onlyNullBytesInHasher, onBlockWritten) } // Sum appends the current hash to b and returns the resulting slice. // It does not change the underlying hash state. func (l *level) Sum(b []byte) []byte { return append(b, l.checksum[:]...) } // Reset resets the Hash to its initial state. func (l *level) Reset() { l.checksum = zeroSum // clear the current checksum l.sumCount = 0 l.bytesInHasher = 0 l.onlyNullBytesInHasher = true l.hasher = sha1.New() } // Size returns the number of bytes Sum will return. func (l *level) Size() int { return Size } // BlockSize returns the hash's underlying block size. // The Write method must be able to accept any amount // of data, but it may operate more efficiently if all writes // are a multiple of the block size. func (l *level) BlockSize() int { return Size } // MarshalBinary encodes the hash into a binary form and returns the result. func (l *level) MarshalBinary() ([]byte, error) { b := make([]byte, Size+4+4+1) copy(b, l.checksum[:]) binary.BigEndian.PutUint32(b[Size:], l.sumCount) binary.BigEndian.PutUint32(b[Size+4:], l.bytesInHasher) if l.onlyNullBytesInHasher { b[Size+4+4] = 1 } encodedHasher, err := l.hasher.(encoding.BinaryMarshaler).MarshalBinary() if err != nil { return nil, err } b = append(b, encodedHasher...) return b, nil } // UnmarshalBinary decodes the binary form generated by MarshalBinary. // The hash will replace its internal state accordingly. func (l *level) UnmarshalBinary(b []byte) error { if len(b) < Size+4+4+1 { return ErrorInvalidEncoding } copy(l.checksum[:], b) l.sumCount = binary.BigEndian.Uint32(b[Size:]) l.bytesInHasher = binary.BigEndian.Uint32(b[Size+4:]) switch b[Size+4+4] { case 0: l.onlyNullBytesInHasher = false case 1: l.onlyNullBytesInHasher = true default: return ErrorInvalidEncoding } err := l.hasher.(encoding.BinaryUnmarshaler).UnmarshalBinary(b[Size+4+4+1:]) return err } // hidriveHash is the hash computing the actual checksum used by HiDrive by combining multiple level-hashes. type hidriveHash struct { levels []*level // collection of level-hashes, one for each level starting at level-1 lastSumWritten [Size]byte // the last checksum written to any of the levels bytesInBlock uint32 // bytes written into blockHash so far onlyNullBytesInBlock bool // whether the hasher only contains null-bytes so far blockHash hash.Hash } // New returns a new hash.Hash computing the HiDrive checksum. func New() hash.Hash { h := &hidriveHash{} h.Reset() return h } // aggregateToLevel writes the checksum to the level at the given index // and if necessary propagates any changes to levels above. func (h *hidriveHash) aggregateToLevel(index int, sum []byte) { for i := index; ; i++ { if i >= len(h.levels) { h.levels = append(h.levels, NewLevel().(*level)) } _, err := h.levels[i].Write(sum) copy(h.lastSumWritten[:], sum) if err != nil { panic(fmt.Errorf("level-hash should not have produced an error: %w", err)) } if !h.levels[i].IsFull() { break } sum = h.levels[i].Sum(nil) h.levels[i].Reset() } } // Write (via the embedded io.Writer interface) adds more data to the running hash. // It never returns an error. func (h *hidriveHash) Write(p []byte) (n int, err error) { onBlockWritten := func(remaining int) error { var sum []byte if h.onlyNullBytesInBlock { sum = zeroSum[:] } else { sum = h.blockHash.Sum(nil) } h.blockHash.Reset() h.aggregateToLevel(0, sum) return nil } return writeByBlock(p, h.blockHash, uint32(BlockSize), &h.bytesInBlock, &h.onlyNullBytesInBlock, onBlockWritten) } // Sum appends the current hash to b and returns the resulting slice. // It does not change the underlying hash state. func (h *hidriveHash) Sum(b []byte) []byte { // Save internal state. state, err := h.MarshalBinary() if err != nil { panic(fmt.Errorf("saving the internal state should not have produced an error: %w", err)) } if h.bytesInBlock > 0 { // Fill remainder of block with null-bytes. filler := make([]byte, h.BlockSize()-int(h.bytesInBlock)) _, err = h.Write(filler) if err != nil { panic(fmt.Errorf("filling with null-bytes should not have an error: %w", err)) } } checksum := zeroSum for i := range h.levels { level := h.levels[i] if i < len(h.levels)-1 { // Aggregate non-empty non-final levels. if level.sumCount >= 1 { h.aggregateToLevel(i+1, level.Sum(nil)) level.Reset() } } else { // Determine sum of final level. if level.sumCount > 1 { copy(checksum[:], level.Sum(nil)) } else { // This is needed, otherwise there is no way to return // the non-position-embedded checksum. checksum = h.lastSumWritten } } } // Restore internal state. err = h.UnmarshalBinary(state) if err != nil { panic(fmt.Errorf("restoring the internal state should not have produced an error: %w", err)) } return append(b, checksum[:]...) } // Reset resets the Hash to its initial state. func (h *hidriveHash) Reset() { h.levels = nil h.lastSumWritten = zeroSum // clear the last written checksum h.bytesInBlock = 0 h.onlyNullBytesInBlock = true h.blockHash = sha1.New() } // Size returns the number of bytes Sum will return. func (h *hidriveHash) Size() int { return Size } // BlockSize returns the hash's underlying block size. // The Write method must be able to accept any amount // of data, but it may operate more efficiently if all writes // are a multiple of the block size. func (h *hidriveHash) BlockSize() int { return BlockSize } // MarshalBinary encodes the hash into a binary form and returns the result. func (h *hidriveHash) MarshalBinary() ([]byte, error) { b := make([]byte, Size+4+1+8) copy(b, h.lastSumWritten[:]) binary.BigEndian.PutUint32(b[Size:], h.bytesInBlock) if h.onlyNullBytesInBlock { b[Size+4] = 1 } binary.BigEndian.PutUint64(b[Size+4+1:], uint64(len(h.levels))) for _, level := range h.levels { encodedLevel, err := level.MarshalBinary() if err != nil { return nil, err } encodedLength := make([]byte, 8) binary.BigEndian.PutUint64(encodedLength, uint64(len(encodedLevel))) b = append(b, encodedLength...) b = append(b, encodedLevel...) } encodedBlockHash, err := h.blockHash.(encoding.BinaryMarshaler).MarshalBinary() if err != nil { return nil, err } b = append(b, encodedBlockHash...) return b, nil } // UnmarshalBinary decodes the binary form generated by MarshalBinary. // The hash will replace its internal state accordingly. func (h *hidriveHash) UnmarshalBinary(b []byte) error { if len(b) < Size+4+1+8 { return ErrorInvalidEncoding } copy(h.lastSumWritten[:], b) h.bytesInBlock = binary.BigEndian.Uint32(b[Size:]) switch b[Size+4] { case 0: h.onlyNullBytesInBlock = false case 1: h.onlyNullBytesInBlock = true default: return ErrorInvalidEncoding } amount := binary.BigEndian.Uint64(b[Size+4+1:]) h.levels = make([]*level, int(amount)) offset := Size + 4 + 1 + 8 for i := range h.levels { length := int(binary.BigEndian.Uint64(b[offset:])) offset += 8 h.levels[i] = NewLevel().(*level) err := h.levels[i].UnmarshalBinary(b[offset : offset+length]) if err != nil { return err } offset += length } err := h.blockHash.(encoding.BinaryUnmarshaler).UnmarshalBinary(b[offset:]) return err } // Sum returns the HiDrive checksum of the data. func Sum(data []byte) [Size]byte { h := New().(*hidriveHash) _, _ = h.Write(data) var result [Size]byte copy(result[:], h.Sum(nil)) return result } // Check the interfaces are satisfied. var ( _ hash.Hash = (*level)(nil) _ encoding.BinaryMarshaler = (*level)(nil) _ encoding.BinaryUnmarshaler = (*level)(nil) _ internal.LevelHash = (*level)(nil) _ hash.Hash = (*hidriveHash)(nil) _ encoding.BinaryMarshaler = (*hidriveHash)(nil) _ encoding.BinaryUnmarshaler = (*hidriveHash)(nil) ) rclone-v1.71.0/backend/hidrive/hidrivehash/hidrivehash_test.go000066400000000000000000000300351505210326400244520ustar00rootroot00000000000000package hidrivehash_test import ( "crypto/sha1" "encoding" "encoding/hex" "fmt" "io" "testing" "github.com/rclone/rclone/backend/hidrive/hidrivehash" "github.com/rclone/rclone/backend/hidrive/hidrivehash/internal" "github.com/stretchr/testify/assert" ) // helper functions to set up test-tables func sha1ArrayAsSlice(sum [sha1.Size]byte) []byte { return sum[:] } func mustDecode(hexstring string) []byte { result, err := hex.DecodeString(hexstring) if err != nil { panic(err) } return result } // ------------------------------------------------------------ var testTableLevelPositionEmbedded = []struct { ins [][]byte outs [][]byte name string }{ { [][]byte{ sha1ArrayAsSlice([20]byte{245, 202, 195, 223, 121, 198, 189, 112, 138, 202, 222, 2, 146, 156, 127, 16, 208, 233, 98, 88}), sha1ArrayAsSlice([20]byte{78, 188, 156, 219, 173, 54, 81, 55, 47, 220, 222, 207, 201, 21, 57, 252, 255, 239, 251, 186}), }, [][]byte{ sha1ArrayAsSlice([20]byte{245, 202, 195, 223, 121, 198, 189, 112, 138, 202, 222, 2, 146, 156, 127, 16, 208, 233, 98, 88}), sha1ArrayAsSlice([20]byte{68, 135, 96, 187, 38, 253, 14, 167, 186, 167, 188, 210, 91, 177, 185, 13, 208, 217, 94, 18}), }, "documentation-v3.2rev27-example L0 (position-embedded)", }, { [][]byte{ sha1ArrayAsSlice([20]byte{68, 254, 92, 166, 52, 37, 104, 180, 22, 123, 249, 144, 182, 78, 64, 74, 57, 117, 225, 195}), sha1ArrayAsSlice([20]byte{75, 211, 153, 190, 125, 179, 67, 49, 60, 149, 98, 246, 142, 20, 11, 254, 159, 162, 129, 237}), sha1ArrayAsSlice([20]byte{150, 2, 9, 153, 97, 153, 189, 104, 147, 14, 77, 203, 244, 243, 25, 212, 67, 48, 111, 107}), }, [][]byte{ sha1ArrayAsSlice([20]byte{68, 254, 92, 166, 52, 37, 104, 180, 22, 123, 249, 144, 182, 78, 64, 74, 57, 117, 225, 195}), sha1ArrayAsSlice([20]byte{144, 209, 246, 100, 177, 216, 171, 229, 83, 17, 92, 135, 68, 98, 76, 72, 217, 24, 99, 176}), sha1ArrayAsSlice([20]byte{38, 211, 255, 254, 19, 114, 105, 77, 230, 31, 170, 83, 57, 85, 102, 29, 28, 72, 211, 27}), }, "documentation-example L0 (position-embedded)", }, { [][]byte{ sha1ArrayAsSlice([20]byte{173, 123, 132, 245, 176, 172, 43, 183, 121, 40, 66, 252, 101, 249, 188, 193, 160, 189, 2, 116}), sha1ArrayAsSlice([20]byte{40, 34, 8, 238, 37, 5, 237, 184, 79, 105, 10, 167, 171, 254, 13, 229, 132, 112, 254, 8}), sha1ArrayAsSlice([20]byte{39, 112, 26, 86, 190, 35, 100, 101, 28, 131, 122, 191, 254, 144, 239, 107, 253, 124, 104, 203}), }, [][]byte{ sha1ArrayAsSlice([20]byte{173, 123, 132, 245, 176, 172, 43, 183, 121, 40, 66, 252, 101, 249, 188, 193, 160, 189, 2, 116}), sha1ArrayAsSlice([20]byte{213, 157, 141, 227, 213, 178, 25, 111, 200, 145, 77, 164, 17, 247, 202, 167, 37, 46, 0, 124}), sha1ArrayAsSlice([20]byte{253, 13, 168, 58, 147, 213, 125, 212, 229, 20, 200, 100, 16, 136, 186, 19, 34, 170, 105, 71}), }, "documentation-example L1 (position-embedded)", }, } var testTableLevel = []struct { ins [][]byte outs [][]byte name string }{ { [][]byte{ mustDecode("09f077820a8a41f34a639f2172f1133b1eafe4e6"), mustDecode("09f077820a8a41f34a639f2172f1133b1eafe4e6"), mustDecode("09f077820a8a41f34a639f2172f1133b1eafe4e6"), }, [][]byte{ mustDecode("44fe5ca6342568b4167bf990b64e404a3975e1c3"), mustDecode("90d1f664b1d8abe553115c8744624c48d91863b0"), mustDecode("26d3fffe1372694de61faa533955661d1c48d31b"), }, "documentation-example L0", }, { [][]byte{ mustDecode("75a9f88fb219ef1dd31adf41c93e2efaac8d0245"), mustDecode("daedc425199501b1e86b5eaba5649cbde205e6ae"), mustDecode("286ac5283f99c4e0f11683900a3e39661c375dd6"), }, [][]byte{ mustDecode("ad7b84f5b0ac2bb7792842fc65f9bcc1a0bd0274"), mustDecode("d59d8de3d5b2196fc8914da411f7caa7252e007c"), mustDecode("fd0da83a93d57dd4e514c8641088ba1322aa6947"), }, "documentation-example L1", }, { [][]byte{ mustDecode("0000000000000000000000000000000000000000"), mustDecode("0000000000000000000000000000000000000000"), mustDecode("75a9f88fb219ef1dd31adf41c93e2efaac8d0245"), mustDecode("0000000000000000000000000000000000000000"), mustDecode("daedc425199501b1e86b5eaba5649cbde205e6ae"), mustDecode("0000000000000000000000000000000000000000"), mustDecode("0000000000000000000000000000000000000000"), mustDecode("0000000000000000000000000000000000000000"), mustDecode("286ac5283f99c4e0f11683900a3e39661c375dd6"), mustDecode("0000000000000000000000000000000000000000"), }, [][]byte{ mustDecode("0000000000000000000000000000000000000000"), mustDecode("0000000000000000000000000000000000000000"), mustDecode("a197464ec19f2b2b2bc6b21f6c939c7e57772843"), mustDecode("a197464ec19f2b2b2bc6b21f6c939c7e57772843"), mustDecode("b04769357aa4eb4b52cd5bec6935bc8f977fa3a1"), mustDecode("b04769357aa4eb4b52cd5bec6935bc8f977fa3a1"), mustDecode("b04769357aa4eb4b52cd5bec6935bc8f977fa3a1"), mustDecode("b04769357aa4eb4b52cd5bec6935bc8f977fa3a1"), mustDecode("8f56351897b4e1d100646fa122c924347721b2f5"), mustDecode("8f56351897b4e1d100646fa122c924347721b2f5"), }, "mixed-with-empties", }, } var testTable = []struct { data []byte // pattern describes how to use data to construct the hash-input. // For every entry n at even indices this repeats the data n times. // For every entry m at odd indices this repeats a null-byte m times. // The input-data is constructed by concatenating the results in order. pattern []int64 out []byte name string }{ { []byte("#ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz\n"), []int64{64}, mustDecode("09f077820a8a41f34a639f2172f1133b1eafe4e6"), "documentation-example L0", }, { []byte("#ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz\n"), []int64{64 * 256}, mustDecode("75a9f88fb219ef1dd31adf41c93e2efaac8d0245"), "documentation-example L1", }, { []byte("#ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz\n"), []int64{64 * 256, 0, 64 * 128, 4096 * 128, 64*2 + 32}, mustDecode("fd0da83a93d57dd4e514c8641088ba1322aa6947"), "documentation-example L2", }, { []byte("hello rclone\n"), []int64{316}, mustDecode("72370f9c18a2c20b31d71f3f4cee7a3cd2703737"), "not-block-aligned", }, { []byte("hello rclone\n"), []int64{13, 4096 * 3, 4}, mustDecode("a6990b81791f0d2db750b38f046df321c975aa60"), "not-block-aligned-with-null-bytes", }, { []byte{}, []int64{}, mustDecode("0000000000000000000000000000000000000000"), "empty", }, { []byte{}, []int64{0, 4096 * 256 * 256}, mustDecode("0000000000000000000000000000000000000000"), "null-bytes", }, } // ------------------------------------------------------------ func TestLevelAdd(t *testing.T) { for _, test := range testTableLevelPositionEmbedded { l := hidrivehash.NewLevel().(internal.LevelHash) t.Run(test.name, func(t *testing.T) { for i := range test.ins { l.Add(test.ins[i]) assert.Equal(t, test.outs[i], l.Sum(nil)) } }) } } func TestLevelWrite(t *testing.T) { for _, test := range testTableLevel { l := hidrivehash.NewLevel() t.Run(test.name, func(t *testing.T) { for i := range test.ins { l.Write(test.ins[i]) assert.Equal(t, test.outs[i], l.Sum(nil)) } }) } } func TestLevelIsFull(t *testing.T) { content := [hidrivehash.Size]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19} l := hidrivehash.NewLevel() for range 256 { assert.False(t, l.(internal.LevelHash).IsFull()) written, err := l.Write(content[:]) assert.Equal(t, len(content), written) if !assert.NoError(t, err) { t.FailNow() } } assert.True(t, l.(internal.LevelHash).IsFull()) written, err := l.Write(content[:]) assert.True(t, l.(internal.LevelHash).IsFull()) assert.Equal(t, 0, written) assert.ErrorIs(t, err, hidrivehash.ErrorHashFull) } func TestLevelReset(t *testing.T) { l := hidrivehash.NewLevel() zeroHash := l.Sum(nil) _, err := l.Write([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}) if assert.NoError(t, err) { assert.NotEqual(t, zeroHash, l.Sum(nil)) l.Reset() assert.Equal(t, zeroHash, l.Sum(nil)) } } func TestLevelSize(t *testing.T) { l := hidrivehash.NewLevel() assert.Equal(t, 20, l.Size()) } func TestLevelBlockSize(t *testing.T) { l := hidrivehash.NewLevel() assert.Equal(t, 20, l.BlockSize()) } func TestLevelBinaryMarshaler(t *testing.T) { content := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19} l := hidrivehash.NewLevel().(internal.LevelHash) l.Write(content[:10]) encoded, err := l.MarshalBinary() if assert.NoError(t, err) { d := hidrivehash.NewLevel().(internal.LevelHash) err = d.UnmarshalBinary(encoded) if assert.NoError(t, err) { assert.Equal(t, l.Sum(nil), d.Sum(nil)) l.Write(content[10:]) d.Write(content[10:]) assert.Equal(t, l.Sum(nil), d.Sum(nil)) } } } func TestLevelInvalidEncoding(t *testing.T) { l := hidrivehash.NewLevel().(internal.LevelHash) err := l.UnmarshalBinary([]byte{}) assert.ErrorIs(t, err, hidrivehash.ErrorInvalidEncoding) } // ------------------------------------------------------------ type infiniteReader struct { source []byte offset int } func (m *infiniteReader) Read(b []byte) (int, error) { count := copy(b, m.source[m.offset:]) m.offset += count m.offset %= len(m.source) return count, nil } func writeInChunks(writer io.Writer, chunkSize int64, data []byte, pattern []int64) error { readers := make([]io.Reader, len(pattern)) nullBytes := [4096]byte{} for i, n := range pattern { if i%2 == 0 { readers[i] = io.LimitReader(&infiniteReader{data, 0}, n*int64(len(data))) } else { readers[i] = io.LimitReader(&infiniteReader{nullBytes[:], 0}, n) } } reader := io.MultiReader(readers...) for { _, err := io.CopyN(writer, reader, chunkSize) if err != nil { if err == io.EOF { err = nil } return err } } } func TestWrite(t *testing.T) { for _, test := range testTable { t.Run(test.name, func(t *testing.T) { h := hidrivehash.New() err := writeInChunks(h, int64(h.BlockSize()), test.data, test.pattern) if assert.NoError(t, err) { normalSum := h.Sum(nil) assert.Equal(t, test.out, normalSum) // Test if different block-sizes produce differing results. for _, blockSize := range []int64{397, 512, 4091, 8192, 10000} { t.Run(fmt.Sprintf("block-size %v", blockSize), func(t *testing.T) { h := hidrivehash.New() err := writeInChunks(h, blockSize, test.data, test.pattern) if assert.NoError(t, err) { assert.Equal(t, normalSum, h.Sum(nil)) } }) } } }) } } func TestReset(t *testing.T) { h := hidrivehash.New() zeroHash := h.Sum(nil) _, err := h.Write([]byte{1}) if assert.NoError(t, err) { assert.NotEqual(t, zeroHash, h.Sum(nil)) h.Reset() assert.Equal(t, zeroHash, h.Sum(nil)) } } func TestSize(t *testing.T) { h := hidrivehash.New() assert.Equal(t, 20, h.Size()) } func TestBlockSize(t *testing.T) { h := hidrivehash.New() assert.Equal(t, 4096, h.BlockSize()) } func TestBinaryMarshaler(t *testing.T) { for _, test := range testTable { h := hidrivehash.New() d := hidrivehash.New() half := len(test.pattern) / 2 t.Run(test.name, func(t *testing.T) { err := writeInChunks(h, int64(h.BlockSize()), test.data, test.pattern[:half]) assert.NoError(t, err) encoded, err := h.(encoding.BinaryMarshaler).MarshalBinary() if assert.NoError(t, err) { err = d.(encoding.BinaryUnmarshaler).UnmarshalBinary(encoded) if assert.NoError(t, err) { assert.Equal(t, h.Sum(nil), d.Sum(nil)) err = writeInChunks(h, int64(h.BlockSize()), test.data, test.pattern[half:]) assert.NoError(t, err) err = writeInChunks(d, int64(d.BlockSize()), test.data, test.pattern[half:]) assert.NoError(t, err) assert.Equal(t, h.Sum(nil), d.Sum(nil)) } } }) } } func TestInvalidEncoding(t *testing.T) { h := hidrivehash.New() err := h.(encoding.BinaryUnmarshaler).UnmarshalBinary([]byte{}) assert.ErrorIs(t, err, hidrivehash.ErrorInvalidEncoding) } func TestSum(t *testing.T) { assert.Equal(t, [hidrivehash.Size]byte{}, hidrivehash.Sum([]byte{})) content := []byte{1} h := hidrivehash.New() h.Write(content) sum := hidrivehash.Sum(content) assert.Equal(t, h.Sum(nil), sum[:]) } rclone-v1.71.0/backend/hidrive/hidrivehash/internal/000077500000000000000000000000001505210326400224015ustar00rootroot00000000000000rclone-v1.71.0/backend/hidrive/hidrivehash/internal/internal.go000066400000000000000000000006761505210326400245550ustar00rootroot00000000000000// Package internal provides utilities for HiDrive. package internal import ( "encoding" "hash" ) // LevelHash is an internal interface for level-hashes. type LevelHash interface { encoding.BinaryMarshaler encoding.BinaryUnmarshaler hash.Hash // Add takes a position-embedded checksum and adds it to the level. Add(sum []byte) // IsFull returns whether the number of checksums added to this level reached its capacity. IsFull() bool } rclone-v1.71.0/backend/http/000077500000000000000000000000001505210326400156145ustar00rootroot00000000000000rclone-v1.71.0/backend/http/http.go000066400000000000000000000535011505210326400171260ustar00rootroot00000000000000// Package http provides a filesystem interface using golang.org/net/http // // It treats HTML pages served from the endpoint as directory // listings, and includes any links found as files. package http import ( "context" "errors" "fmt" "io" "mime" "net/http" "net/url" "path" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/rest" "golang.org/x/net/html" ) var ( errorReadOnly = errors.New("http remotes are read only") timeUnset = time.Unix(0, 0) ) func init() { fsi := &fs.RegInfo{ Name: "http", Description: "HTTP", NewFs: NewFs, CommandHelp: commandHelp, Options: []fs.Option{{ Name: "url", Help: "URL of HTTP host to connect to.\n\nE.g. \"https://example.com\", or \"https://user:pass@example.com\" to use a username and password.", Required: true, }, { Name: "headers", Help: `Set HTTP headers for all transactions. Use this to set additional HTTP headers for all transactions. The input format is comma separated list of key,value pairs. Standard [CSV encoding](https://godoc.org/encoding/csv) may be used. For example, to set a Cookie use 'Cookie,name=value', or '"Cookie","name=value"'. You can set multiple headers, e.g. '"Cookie","name=value","Authorization","xxx"'.`, Default: fs.CommaSepList{}, Advanced: true, }, { Name: "no_slash", Help: `Set this if the site doesn't end directories with /. Use this if your target website does not use / on the end of directories. A / on the end of a path is how rclone normally tells the difference between files and directories. If this flag is set, then rclone will treat all files with Content-Type: text/html as directories and read URLs from them rather than downloading them. Note that this may cause rclone to confuse genuine HTML files with directories.`, Default: false, Advanced: true, }, { Name: "no_head", Help: `Don't use HEAD requests. HEAD requests are mainly used to find file sizes in dir listing. If your site is being very slow to load then you can try this option. Normally rclone does a HEAD request for each potential file in a directory listing to: - find its size - check it really exists - check to see if it is a directory If you set this option, rclone will not do the HEAD request. This will mean that directory listings are much quicker, but rclone won't have the times or sizes of any files, and some files that don't exist may be in the listing.`, Default: false, Advanced: true, }, { Name: "no_escape", Help: "Do not escape URL metacharacters in path names.", Default: false, }}, } fs.Register(fsi) } // Options defines the configuration for this backend type Options struct { Endpoint string `config:"url"` NoSlash bool `config:"no_slash"` NoHead bool `config:"no_head"` Headers fs.CommaSepList `config:"headers"` NoEscape bool `config:"no_escape"` } // Fs stores the interface to the remote HTTP files type Fs struct { name string root string features *fs.Features // optional features opt Options // options for this backend ci *fs.ConfigInfo // global config endpoint *url.URL endpointURL string // endpoint as a string httpClient *http.Client } // Object is a remote object that has been stat'd (so it exists, but is not necessarily open for reading) type Object struct { fs *Fs remote string size int64 modTime time.Time contentType string } // statusError returns an error if the res contained an error func statusError(res *http.Response, err error) error { if err != nil { return err } if res.StatusCode < 200 || res.StatusCode > 299 { _ = res.Body.Close() return fmt.Errorf("HTTP Error: %s", res.Status) } return nil } // getFsEndpoint decides if url is to be considered a file or directory, // and returns a proper endpoint url to use for the fs. func getFsEndpoint(ctx context.Context, client *http.Client, url string, opt *Options) (string, bool) { // If url ends with '/' it is already a proper url always assumed to be a directory. if url[len(url)-1] == '/' { return url, false } // If url does not end with '/' we send a HEAD request to decide // if it is directory or file, and if directory appends the missing // '/', or if file returns the directory url to parent instead. createFileResult := func() (string, bool) { fs.Debugf(nil, "If path is a directory you must add a trailing '/'") parent, _ := path.Split(url) return parent, true } createDirResult := func() (string, bool) { fs.Debugf(nil, "To avoid the initial HEAD request add a trailing '/' to the path") return url + "/", false } // If HEAD requests are not allowed we just have to assume it is a file. if opt.NoHead { fs.Debugf(nil, "Assuming path is a file as --http-no-head is set") return createFileResult() } // Use a client which doesn't follow redirects so the server // doesn't redirect http://host/dir to http://host/dir/ noRedir := *client noRedir.CheckRedirect = func(req *http.Request, via []*http.Request) error { return http.ErrUseLastResponse } req, err := http.NewRequestWithContext(ctx, "HEAD", url, nil) if err != nil { fs.Debugf(nil, "Assuming path is a file as HEAD request could not be created: %v", err) return createFileResult() } addHeaders(req, opt) res, err := noRedir.Do(req) if err != nil { fs.Debugf(nil, "Assuming path is a file as HEAD request could not be sent: %v", err) return createFileResult() } if res.StatusCode == http.StatusNotFound { fs.Debugf(nil, "Assuming path is a directory as HEAD response is it does not exist as a file (%s)", res.Status) return createDirResult() } if res.StatusCode == http.StatusMovedPermanently || res.StatusCode == http.StatusFound || res.StatusCode == http.StatusSeeOther || res.StatusCode == http.StatusTemporaryRedirect || res.StatusCode == http.StatusPermanentRedirect { redir := res.Header.Get("Location") if redir != "" { if redir[len(redir)-1] == '/' { fs.Debugf(nil, "Assuming path is a directory as HEAD response is redirect (%s) to a path that ends with '/': %s", res.Status, redir) return createDirResult() } fs.Debugf(nil, "Assuming path is a file as HEAD response is redirect (%s) to a path that does not end with '/': %s", res.Status, redir) return createFileResult() } fs.Debugf(nil, "Assuming path is a file as HEAD response is redirect (%s) but no location header", res.Status) return createFileResult() } if res.StatusCode < 200 || res.StatusCode > 299 { // Example is 403 (http.StatusForbidden) for servers not allowing HEAD requests. fs.Debugf(nil, "Assuming path is a file as HEAD response is an error (%s)", res.Status) return createFileResult() } fs.Debugf(nil, "Assuming path is a file as HEAD response is success (%s)", res.Status) return createFileResult() } // Make the http connection with opt func (f *Fs) httpConnection(ctx context.Context, opt *Options) (isFile bool, err error) { if len(opt.Headers)%2 != 0 { return false, errors.New("odd number of headers supplied") } if !strings.HasSuffix(opt.Endpoint, "/") { opt.Endpoint += "/" } // Parse the endpoint and stick the root onto it base, err := url.Parse(opt.Endpoint) if err != nil { return false, err } u, err := rest.URLJoin(base, rest.URLPathEscape(f.root)) if err != nil { return false, err } client := fshttp.NewClient(ctx) endpoint, isFile := getFsEndpoint(ctx, client, u.String(), opt) fs.Debugf(nil, "Root: %s", endpoint) u, err = url.Parse(endpoint) if err != nil { return false, err } // Update f with the new parameters f.httpClient = client f.endpoint = u f.endpointURL = u.String() if isFile { // Correct root if definitely pointing to a file f.root = path.Dir(f.root) if f.root == "." || f.root == "/" { f.root = "" } } return isFile, nil } // NewFs creates a new Fs object from the name and root. It connects to // the host specified in the config file. func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } ci := fs.GetConfig(ctx) f := &Fs{ name: name, root: root, opt: *opt, ci: ci, } f.features = (&fs.Features{ CanHaveEmptyDirectories: true, }).Fill(ctx, f) // Make the http connection isFile, err := f.httpConnection(ctx, opt) if err != nil { return nil, err } if isFile { // return an error with an fs which points to the parent return f, fs.ErrorIsFile } if !strings.HasSuffix(f.endpointURL, "/") { return nil, errors.New("internal error: url doesn't end with /") } return f, nil } // Name returns the configured name of the file system func (f *Fs) Name() string { return f.name } // Root returns the root for the filesystem func (f *Fs) Root() string { return f.root } // String returns the URL for the filesystem func (f *Fs) String() string { return f.endpointURL } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // Precision is the remote http file system's modtime precision, which we have no way of knowing. We estimate at 1s func (f *Fs) Precision() time.Duration { return time.Second } // NewObject creates a new remote http file object func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } err := o.head(ctx) if err != nil { return nil, err } return o, nil } // Join's the remote onto the base URL func (f *Fs) url(remote string) string { trimmedRemote := strings.TrimLeft(remote, "/") // remove leading "/" since we always have it in f.endpointURL if f.opt.NoEscape { // Directly concatenate without escaping, no_escape behavior return f.endpointURL + trimmedRemote } // Default behavior return f.endpointURL + rest.URLPathEscape(trimmedRemote) } // Errors returned by parseName var ( errURLJoinFailed = errors.New("URLJoin failed") errFoundQuestionMark = errors.New("found ? in URL") errHostMismatch = errors.New("host mismatch") errSchemeMismatch = errors.New("scheme mismatch") errNotUnderRoot = errors.New("not under root") errNameIsEmpty = errors.New("name is empty") errNameContainsSlash = errors.New("name contains /") ) // parseName turns a name as found in the page into a remote path or returns an error func parseName(base *url.URL, name string) (string, error) { // make URL absolute u, err := rest.URLJoin(base, name) if err != nil { return "", errURLJoinFailed } // check it doesn't have URL parameters uStr := u.String() if strings.Contains(uStr, "?") { return "", errFoundQuestionMark } // check that this is going back to the same host and scheme if base.Host != u.Host { return "", errHostMismatch } if base.Scheme != u.Scheme { return "", errSchemeMismatch } // check has path prefix if !strings.HasPrefix(u.Path, base.Path) { return "", errNotUnderRoot } // calculate the name relative to the base name = u.Path[len(base.Path):] // mustn't be empty if name == "" { return "", errNameIsEmpty } // mustn't contain a / - we are looking for a single level directory slash := strings.Index(name, "/") if slash >= 0 && slash != len(name)-1 { return "", errNameContainsSlash } return name, nil } // Parse turns HTML for a directory into names // base should be the base URL to resolve any relative names from func parse(base *url.URL, in io.Reader) (names []string, err error) { doc, err := html.Parse(in) if err != nil { return nil, err } var ( walk func(*html.Node) seen = make(map[string]struct{}) ) walk = func(n *html.Node) { if n.Type == html.ElementNode && n.Data == "a" { for _, a := range n.Attr { if a.Key == "href" { name, err := parseName(base, a.Val) if err == nil { if _, found := seen[name]; !found { names = append(names, name) seen[name] = struct{}{} } } break } } } for c := n.FirstChild; c != nil; c = c.NextSibling { walk(c) } } walk(doc) return names, nil } // Adds the configured headers to the request if any func addHeaders(req *http.Request, opt *Options) { for i := 0; i < len(opt.Headers); i += 2 { key := opt.Headers[i] value := opt.Headers[i+1] req.Header.Add(key, value) } } // Adds the configured headers to the request if any func (f *Fs) addHeaders(req *http.Request) { addHeaders(req, &f.opt) } // Read the directory passed in func (f *Fs) readDir(ctx context.Context, dir string) (names []string, err error) { URL := f.url(dir) u, err := url.Parse(URL) if err != nil { return nil, fmt.Errorf("failed to readDir: %w", err) } if !strings.HasSuffix(URL, "/") { return nil, fmt.Errorf("internal error: readDir URL %q didn't end in /", URL) } // Do the request req, err := http.NewRequestWithContext(ctx, "GET", URL, nil) if err != nil { return nil, fmt.Errorf("readDir failed: %w", err) } f.addHeaders(req) res, err := f.httpClient.Do(req) if err == nil { defer fs.CheckClose(res.Body, &err) if res.StatusCode == http.StatusNotFound { return nil, fs.ErrorDirNotFound } } err = statusError(res, err) if err != nil { return nil, fmt.Errorf("failed to readDir: %w", err) } contentType := strings.SplitN(res.Header.Get("Content-Type"), ";", 2)[0] switch contentType { case "text/html": names, err = parse(u, res.Body) if err != nil { return nil, fmt.Errorf("readDir: %w", err) } default: return nil, fmt.Errorf("can't parse content type %q", contentType) } return names, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { if !strings.HasSuffix(dir, "/") && dir != "" { dir += "/" } names, err := f.readDir(ctx, dir) if err != nil { return nil, fmt.Errorf("error listing %q: %w", dir, err) } var ( entriesMu sync.Mutex // to protect entries wg sync.WaitGroup checkers = f.ci.Checkers in = make(chan string, checkers) ) add := func(entry fs.DirEntry) { entriesMu.Lock() entries = append(entries, entry) entriesMu.Unlock() } for range checkers { wg.Add(1) go func() { defer wg.Done() for remote := range in { file := &Object{ fs: f, remote: remote, } switch err := file.head(ctx); err { case nil: add(file) case fs.ErrorNotAFile: // ...found a directory not a file add(fs.NewDir(remote, time.Time{})) default: fs.Debugf(remote, "skipping because of error: %v", err) } } }() } for _, name := range names { isDir := name[len(name)-1] == '/' name = strings.TrimRight(name, "/") remote := path.Join(dir, name) if isDir { add(fs.NewDir(remote, time.Time{})) } else { in <- remote } } close(in) wg.Wait() return entries, nil } // Put in to the remote path with the modTime given of the given size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return nil, errorReadOnly } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return nil, errorReadOnly } // Fs is the filesystem this remote http file object is located within func (o *Object) Fs() fs.Info { return o.fs } // String returns the URL to the remote HTTP file func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote the name of the remote HTTP file, relative to the fs root func (o *Object) Remote() string { return o.remote } // Hash returns "" since HTTP (in Go or OpenSSH) doesn't support remote calculation of hashes func (o *Object) Hash(ctx context.Context, r hash.Type) (string, error) { return "", hash.ErrUnsupported } // Size returns the size in bytes of the remote http file func (o *Object) Size() int64 { return o.size } // ModTime returns the modification time of the remote http file func (o *Object) ModTime(ctx context.Context) time.Time { return o.modTime } // url returns the native url of the object func (o *Object) url() string { return o.fs.url(o.remote) } // head sends a HEAD request to update info fields in the Object func (o *Object) head(ctx context.Context) error { if o.fs.opt.NoHead { o.size = -1 o.modTime = timeUnset o.contentType = fs.MimeType(ctx, o) return nil } url := o.url() req, err := http.NewRequestWithContext(ctx, "HEAD", url, nil) if err != nil { return fmt.Errorf("stat failed: %w", err) } o.fs.addHeaders(req) res, err := o.fs.httpClient.Do(req) if err == nil && res.StatusCode == http.StatusNotFound { return fs.ErrorObjectNotFound } err = statusError(res, err) if err != nil { return fmt.Errorf("failed to stat: %w", err) } return o.decodeMetadata(ctx, res) } // decodeMetadata updates info fields in the Object according to HTTP response headers func (o *Object) decodeMetadata(ctx context.Context, res *http.Response) error { t, err := http.ParseTime(res.Header.Get("Last-Modified")) if err != nil { t = timeUnset } o.modTime = t o.contentType = res.Header.Get("Content-Type") o.size = rest.ParseSizeFromHeaders(res.Header) // If NoSlash is set then check ContentType to see if it is a directory if o.fs.opt.NoSlash { mediaType, _, err := mime.ParseMediaType(o.contentType) if err != nil { return fmt.Errorf("failed to parse Content-Type: %q: %w", o.contentType, err) } if mediaType == "text/html" { return fs.ErrorNotAFile } } return nil } // SetModTime sets the modification and access time to the specified time // // it also updates the info field func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { return errorReadOnly } // Storable returns whether the remote http file is a regular file (not a directory, symbolic link, block device, character device, named pipe, etc.) func (o *Object) Storable() bool { return true } // Open a remote http file object for reading. Seek is supported func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { url := o.url() req, err := http.NewRequestWithContext(ctx, "GET", url, nil) if err != nil { return nil, fmt.Errorf("Open failed: %w", err) } // Add optional headers for k, v := range fs.OpenOptionHeaders(options) { req.Header.Add(k, v) } o.fs.addHeaders(req) // Do the request res, err := o.fs.httpClient.Do(req) err = statusError(res, err) if err != nil { return nil, fmt.Errorf("Open failed: %w", err) } if err = o.decodeMetadata(ctx, res); err != nil { return nil, fmt.Errorf("decodeMetadata failed: %w", err) } return res.Body, nil } // Hashes returns hash.HashNone to indicate remote hashing is unavailable func (f *Fs) Hashes() hash.Set { return hash.Set(hash.None) } // Mkdir makes the root directory of the Fs object func (f *Fs) Mkdir(ctx context.Context, dir string) error { return errorReadOnly } // Remove a remote http file object func (o *Object) Remove(ctx context.Context) error { return errorReadOnly } // Rmdir removes the root directory of the Fs object func (f *Fs) Rmdir(ctx context.Context, dir string) error { return errorReadOnly } // Update in to the object with the modTime given of the given size func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { return errorReadOnly } // MimeType of an Object if known, "" otherwise func (o *Object) MimeType(ctx context.Context) string { return o.contentType } var commandHelp = []fs.CommandHelp{{ Name: "set", Short: "Set command for updating the config parameters.", Long: `This set command can be used to update the config parameters for a running http backend. Usage Examples: rclone backend set remote: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=remote: [-o opt_name=opt_value] [-o opt_name2=opt_value2] rclone rc backend/command command=set fs=remote: -o url=https://example.com The option keys are named as they are in the config file. This rebuilds the connection to the http backend when it is called with the new parameters. Only new parameters need be passed as the values will default to those currently in use. It doesn't return anything. `, }} // Command the backend to run a named command // // The command run is name // args may be used to read arguments from // opts may be used to read optional arguments from // // The result should be capable of being JSON encoded // If it is a string or a []string it will be shown to the user // otherwise it will be JSON encoded and shown to the user like that func (f *Fs) Command(ctx context.Context, name string, arg []string, opt map[string]string) (out any, err error) { switch name { case "set": newOpt := f.opt err := configstruct.Set(configmap.Simple(opt), &newOpt) if err != nil { return nil, fmt.Errorf("reading config: %w", err) } _, err = f.httpConnection(ctx, &newOpt) if err != nil { return nil, fmt.Errorf("updating session: %w", err) } f.opt = newOpt keys := []string{} for k := range opt { keys = append(keys, k) } fs.Logf(f, "Updated config values: %s", strings.Join(keys, ", ")) return nil, nil default: return nil, fs.ErrorCommandNotFound } } // Check the interfaces are satisfied var ( _ fs.Fs = &Fs{} _ fs.PutStreamer = &Fs{} _ fs.Object = &Object{} _ fs.MimeTyper = &Object{} _ fs.Commander = &Fs{} ) rclone-v1.71.0/backend/http/http_internal_test.go000066400000000000000000000352251505210326400220640ustar00rootroot00000000000000package http import ( "context" "fmt" "io" "net/http" "net/http/httptest" "net/url" "os" "path" "path/filepath" "sort" "strconv" "strings" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configfile" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/lib/rest" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var ( remoteName = "TestHTTP" testPath = "test" filesPath = filepath.Join(testPath, "files") headers = []string{"X-Potato", "sausage", "X-Rhubarb", "cucumber"} lineEndSize = 1 ) // prepareServer prepares the test server and shuts it down automatically // when the test completes. func prepareServer(t *testing.T) configmap.Simple { // file server for test/files fileServer := http.FileServer(http.Dir(filesPath)) // verify the file path is correct, and also check which line endings // are used to get sizes right ("\n" except on Windows, but even there // we may have "\n" or "\r\n" depending on git crlf setting) fileList, err := os.ReadDir(filesPath) require.NoError(t, err) require.Greater(t, len(fileList), 0) for _, file := range fileList { if !file.IsDir() { data, _ := os.ReadFile(filepath.Join(filesPath, file.Name())) if strings.HasSuffix(string(data), "\r\n") { lineEndSize = 2 } break } } // test the headers are there then pass on to fileServer handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { what := fmt.Sprintf("%s %s: Header ", r.Method, r.URL.Path) assert.Equal(t, headers[1], r.Header.Get(headers[0]), what+headers[0]) assert.Equal(t, headers[3], r.Header.Get(headers[2]), what+headers[2]) fileServer.ServeHTTP(w, r) }) // Make the test server ts := httptest.NewServer(handler) // Configure the remote configfile.Install() // fs.Config.LogLevel = fs.LogLevelDebug // fs.Config.DumpHeaders = true // fs.Config.DumpBodies = true // config.FileSet(remoteName, "type", "http") // config.FileSet(remoteName, "url", ts.URL) m := configmap.Simple{ "type": "http", "url": ts.URL, "headers": strings.Join(headers, ","), } t.Cleanup(ts.Close) return m } // prepare prepares the test server and shuts it down automatically // when the test completes. func prepare(t *testing.T) fs.Fs { m := prepareServer(t) // Instantiate it f, err := NewFs(context.Background(), remoteName, "", m) require.NoError(t, err) return f } func testListRoot(t *testing.T, f fs.Fs, noSlash bool) { entries, err := f.List(context.Background(), "") require.NoError(t, err) sort.Sort(entries) require.Equal(t, 4, len(entries)) e := entries[0] assert.Equal(t, "four", e.Remote()) assert.Equal(t, int64(-1), e.Size()) _, ok := e.(fs.Directory) assert.True(t, ok) e = entries[1] assert.Equal(t, "one%.txt", e.Remote()) assert.Equal(t, int64(5+lineEndSize), e.Size()) _, ok = e.(*Object) assert.True(t, ok) e = entries[2] assert.Equal(t, "three", e.Remote()) assert.Equal(t, int64(-1), e.Size()) _, ok = e.(fs.Directory) assert.True(t, ok) e = entries[3] assert.Equal(t, "two.html", e.Remote()) if noSlash { assert.Equal(t, int64(-1), e.Size()) _, ok = e.(fs.Directory) assert.True(t, ok) } else { assert.Equal(t, int64(40+lineEndSize), e.Size()) _, ok = e.(*Object) assert.True(t, ok) } } func TestListRoot(t *testing.T) { f := prepare(t) testListRoot(t, f, false) } func TestListRootNoSlash(t *testing.T) { f := prepare(t) f.(*Fs).opt.NoSlash = true testListRoot(t, f, true) } func TestListSubDir(t *testing.T) { f := prepare(t) entries, err := f.List(context.Background(), "three") require.NoError(t, err) sort.Sort(entries) assert.Equal(t, 1, len(entries)) e := entries[0] assert.Equal(t, "three/underthree.txt", e.Remote()) assert.Equal(t, int64(8+lineEndSize), e.Size()) _, ok := e.(*Object) assert.True(t, ok) } func TestNewObject(t *testing.T) { f := prepare(t) o, err := f.NewObject(context.Background(), "four/under four.txt") require.NoError(t, err) assert.Equal(t, "four/under four.txt", o.Remote()) assert.Equal(t, int64(8+lineEndSize), o.Size()) _, ok := o.(*Object) assert.True(t, ok) // Test the time is correct on the object tObj := o.ModTime(context.Background()) fi, err := os.Stat(filepath.Join(filesPath, "four", "under four.txt")) require.NoError(t, err) tFile := fi.ModTime() fstest.AssertTimeEqualWithPrecision(t, o.Remote(), tFile, tObj, time.Second) // check object not found o, err = f.NewObject(context.Background(), "not found.txt") assert.Nil(t, o) assert.Equal(t, fs.ErrorObjectNotFound, err) } func TestNewObjectWithLeadingSlash(t *testing.T) { f := prepare(t) o, err := f.NewObject(context.Background(), "/four/under four.txt") require.NoError(t, err) assert.Equal(t, "/four/under four.txt", o.Remote()) assert.Equal(t, int64(8+lineEndSize), o.Size()) _, ok := o.(*Object) assert.True(t, ok) // Test the time is correct on the object tObj := o.ModTime(context.Background()) fi, err := os.Stat(filepath.Join(filesPath, "four", "under four.txt")) require.NoError(t, err) tFile := fi.ModTime() fstest.AssertTimeEqualWithPrecision(t, o.Remote(), tFile, tObj, time.Second) // check object not found o, err = f.NewObject(context.Background(), "/not found.txt") assert.Nil(t, o) assert.Equal(t, fs.ErrorObjectNotFound, err) } func TestOpen(t *testing.T) { m := prepareServer(t) for _, head := range []bool{false, true} { if !head { m.Set("no_head", "true") } f, err := NewFs(context.Background(), remoteName, "", m) require.NoError(t, err) for _, rangeRead := range []bool{false, true} { o, err := f.NewObject(context.Background(), "four/under four.txt") require.NoError(t, err) if !head { // Test mod time is still indeterminate tObj := o.ModTime(context.Background()) assert.Equal(t, time.Duration(0), time.Unix(0, 0).Sub(tObj)) // Test file size is still indeterminate assert.Equal(t, int64(-1), o.Size()) } var data []byte if !rangeRead { // Test normal read fd, err := o.Open(context.Background()) require.NoError(t, err) data, err = io.ReadAll(fd) require.NoError(t, err) require.NoError(t, fd.Close()) if lineEndSize == 2 { assert.Equal(t, "beetroot\r\n", string(data)) } else { assert.Equal(t, "beetroot\n", string(data)) } } else { // Test with range request fd, err := o.Open(context.Background(), &fs.RangeOption{Start: 1, End: 5}) require.NoError(t, err) data, err = io.ReadAll(fd) require.NoError(t, err) require.NoError(t, fd.Close()) assert.Equal(t, "eetro", string(data)) } fi, err := os.Stat(filepath.Join(filesPath, "four", "under four.txt")) require.NoError(t, err) tFile := fi.ModTime() // Test the time is always correct on the object after file open tObj := o.ModTime(context.Background()) fstest.AssertTimeEqualWithPrecision(t, o.Remote(), tFile, tObj, time.Second) if !rangeRead { // Test the file size assert.Equal(t, int64(len(data)), o.Size()) } } } } func TestMimeType(t *testing.T) { f := prepare(t) o, err := f.NewObject(context.Background(), "four/under four.txt") require.NoError(t, err) do, ok := o.(fs.MimeTyper) require.True(t, ok) assert.Equal(t, "text/plain; charset=utf-8", do.MimeType(context.Background())) } func TestIsAFileRoot(t *testing.T) { m := prepareServer(t) f, err := NewFs(context.Background(), remoteName, "one%.txt", m) assert.Equal(t, err, fs.ErrorIsFile) testListRoot(t, f, false) } func TestIsAFileSubDir(t *testing.T) { m := prepareServer(t) f, err := NewFs(context.Background(), remoteName, "three/underthree.txt", m) assert.Equal(t, err, fs.ErrorIsFile) entries, err := f.List(context.Background(), "") require.NoError(t, err) sort.Sort(entries) assert.Equal(t, 1, len(entries)) e := entries[0] assert.Equal(t, "underthree.txt", e.Remote()) assert.Equal(t, int64(8+lineEndSize), e.Size()) _, ok := e.(*Object) assert.True(t, ok) } func TestParseName(t *testing.T) { for i, test := range []struct { base string val string wantErr error want string }{ {"http://example.com/", "potato", nil, "potato"}, {"http://example.com/dir/", "potato", nil, "potato"}, {"http://example.com/dir/", "potato?download=true", errFoundQuestionMark, ""}, {"http://example.com/dir/", "../dir/potato", nil, "potato"}, {"http://example.com/dir/", "..", errNotUnderRoot, ""}, {"http://example.com/dir/", "http://example.com/", errNotUnderRoot, ""}, {"http://example.com/dir/", "http://example.com/dir/", errNameIsEmpty, ""}, {"http://example.com/dir/", "http://example.com/dir/potato", nil, "potato"}, {"http://example.com/dir/", "https://example.com/dir/potato", errSchemeMismatch, ""}, {"http://example.com/dir/", "http://notexample.com/dir/potato", errHostMismatch, ""}, {"http://example.com/dir/", "/dir/", errNameIsEmpty, ""}, {"http://example.com/dir/", "/dir/potato", nil, "potato"}, {"http://example.com/dir/", "subdir/potato", errNameContainsSlash, ""}, {"http://example.com/dir/", "With percent %25.txt", nil, "With percent %.txt"}, {"http://example.com/dir/", "With colon :", errURLJoinFailed, ""}, {"http://example.com/dir/", rest.URLPathEscape("With colon :"), nil, "With colon :"}, {"http://example.com/Dungeons%20%26%20Dragons/", "/Dungeons%20&%20Dragons/D%26D%20Basic%20%28Holmes%2C%20B%2C%20X%2C%20BECMI%29/", nil, "D&D Basic (Holmes, B, X, BECMI)/"}, } { u, err := url.Parse(test.base) require.NoError(t, err) got, gotErr := parseName(u, test.val) what := fmt.Sprintf("test %d base=%q, val=%q", i, test.base, test.val) assert.Equal(t, test.wantErr, gotErr, what) assert.Equal(t, test.want, got, what) } } // Load HTML from the file given and parse it, checking it against the entries passed in func parseHTML(t *testing.T, name string, base string, want []string) { in, err := os.Open(filepath.Join(testPath, "index_files", name)) require.NoError(t, err) defer func() { require.NoError(t, in.Close()) }() if base == "" { base = "http://example.com/" } u, err := url.Parse(base) require.NoError(t, err) entries, err := parse(u, in) require.NoError(t, err) assert.Equal(t, want, entries) } func TestParseEmpty(t *testing.T) { parseHTML(t, "empty.html", "", []string(nil)) } func TestParseApache(t *testing.T) { parseHTML(t, "apache.html", "http://example.com/nick/pub/", []string{ "SWIG-embed.tar.gz", "avi2dvd.pl", "cambert.exe", "cambert.gz", "fedora_demo.gz", "gchq-challenge/", "mandelterm/", "pgp-key.txt", "pymath/", "rclone", "readdir.exe", "rush_hour_solver_cut_down.py", "snake-puzzle/", "stressdisk/", "timer-test", "words-to-regexp.pl", "Now 100% better.mp3", "Now better.mp3", }) } func TestParseMemstore(t *testing.T) { parseHTML(t, "memstore.html", "", []string{ "test/", "v1.35/", "v1.36-01-g503cd84/", "rclone-beta-latest-freebsd-386.zip", "rclone-beta-latest-freebsd-amd64.zip", "rclone-beta-latest-windows-amd64.zip", }) } func TestParseNginx(t *testing.T) { parseHTML(t, "nginx.html", "", []string{ "deltas/", "objects/", "refs/", "state/", "config", "summary", }) } func TestParseCaddy(t *testing.T) { parseHTML(t, "caddy.html", "", []string{ "mimetype.zip", "rclone-delete-empty-dirs.py", "rclone-show-empty-dirs.py", "stat-windows-386.zip", "v1.36-155-gcf29ee8b-team-driveβ/", "v1.36-156-gca76b3fb-team-driveβ/", "v1.36-156-ge1f0e0f5-team-driveβ/", "v1.36-22-g06ea13a-ssh-agentβ/", }) } func TestFsNoSlashRoots(t *testing.T) { // Test Fs with roots that does not end with '/', the logic that // decides if url is to be considered a file or directory, based // on result from a HEAD request. // Handler for faking HEAD responses with different status codes headCount := 0 handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.Method == "HEAD" { headCount++ responseCode, err := strconv.Atoi(path.Base(r.URL.String())) require.NoError(t, err) if strings.HasPrefix(r.URL.String(), "/redirect/") { var redir string if strings.HasPrefix(r.URL.String(), "/redirect/file/") { redir = "/redirected" } else if strings.HasPrefix(r.URL.String(), "/redirect/dir/") { redir = "/redirected/" } else { require.Fail(t, "Redirect test requests must start with '/redirect/file/' or '/redirect/dir/'") } http.Redirect(w, r, redir, responseCode) } else { http.Error(w, http.StatusText(responseCode), responseCode) } } }) // Make the test server ts := httptest.NewServer(handler) defer ts.Close() // Configure the remote configfile.Install() m := configmap.Simple{ "type": "http", "url": ts.URL, } // Test for i, test := range []struct { root string isFile bool }{ // 2xx success {"parent/200", true}, {"parent/204", true}, // 3xx redirection Redirect status 301, 302, 303, 307, 308 {"redirect/file/301", true}, // Request is redirected to "/redirected" {"redirect/dir/301", false}, // Request is redirected to "/redirected/" {"redirect/file/302", true}, // Request is redirected to "/redirected" {"redirect/dir/302", false}, // Request is redirected to "/redirected/" {"redirect/file/303", true}, // Request is redirected to "/redirected" {"redirect/dir/303", false}, // Request is redirected to "/redirected/" {"redirect/file/304", true}, // Not really a redirect, handled like 4xx errors (below) {"redirect/file/305", true}, // Not really a redirect, handled like 4xx errors (below) {"redirect/file/306", true}, // Not really a redirect, handled like 4xx errors (below) {"redirect/file/307", true}, // Request is redirected to "/redirected" {"redirect/dir/307", false}, // Request is redirected to "/redirected/" {"redirect/file/308", true}, // Request is redirected to "/redirected" {"redirect/dir/308", false}, // Request is redirected to "/redirected/" // 4xx client errors {"parent/403", true}, // Forbidden status (head request blocked) {"parent/404", false}, // Not found status } { for _, noHead := range []bool{false, true} { var isFile bool if noHead { m.Set("no_head", "true") isFile = true } else { m.Set("no_head", "false") isFile = test.isFile } headCount = 0 f, err := NewFs(context.Background(), remoteName, test.root, m) if noHead { assert.Equal(t, 0, headCount) } else { assert.Equal(t, 1, headCount) } if isFile { assert.ErrorIs(t, err, fs.ErrorIsFile) } else { assert.NoError(t, err) } var endpoint string if isFile { parent, _ := path.Split(test.root) endpoint = "/" + parent } else { endpoint = "/" + test.root + "/" } what := fmt.Sprintf("i=%d, root=%q, isFile=%v, noHead=%v", i, test.root, isFile, noHead) assert.Equal(t, ts.URL+endpoint, f.String(), what) } } } rclone-v1.71.0/backend/http/test/000077500000000000000000000000001505210326400165735ustar00rootroot00000000000000rclone-v1.71.0/backend/http/test/files/000077500000000000000000000000001505210326400176755ustar00rootroot00000000000000rclone-v1.71.0/backend/http/test/files/four/000077500000000000000000000000001505210326400206505ustar00rootroot00000000000000rclone-v1.71.0/backend/http/test/files/four/under four.txt000066400000000000000000000000111505210326400234520ustar00rootroot00000000000000beetroot rclone-v1.71.0/backend/http/test/files/one%.txt000066400000000000000000000000061505210326400212600ustar00rootroot00000000000000hello rclone-v1.71.0/backend/http/test/files/three/000077500000000000000000000000001505210326400210045ustar00rootroot00000000000000rclone-v1.71.0/backend/http/test/files/three/underthree.txt000066400000000000000000000000111505210326400237020ustar00rootroot00000000000000rutabaga rclone-v1.71.0/backend/http/test/files/two.html000066400000000000000000000000511505210326400213700ustar00rootroot00000000000000file.txt rclone-v1.71.0/backend/http/test/index_files/000077500000000000000000000000001505210326400210645ustar00rootroot00000000000000rclone-v1.71.0/backend/http/test/index_files/apache.html000066400000000000000000000105471505210326400232020ustar00rootroot00000000000000 Index of /nick/pub

Index of /nick/pub

[ICO]NameLast modifiedSizeDescription
[DIR]Parent Directory  -  
[ ]SWIG-embed.tar.gz29-Nov-2005 16:27 2.3K 
[TXT]avi2dvd.pl14-Apr-2010 23:07 17K 
[ ]cambert.exe15-Dec-2006 18:07 54K 
[ ]cambert.gz14-Apr-2010 23:07 18K 
[ ]fedora_demo.gz08-Jun-2007 11:01 1.0M 
[DIR]gchq-challenge/24-Dec-2016 15:24 -  
[DIR]mandelterm/13-Jul-2013 22:22 -  
[TXT]pgp-key.txt14-Apr-2010 23:07 400  
[DIR]pymath/24-Dec-2016 15:24 -  
[ ]rclone09-May-2017 17:15 22M 
[ ]readdir.exe21-Oct-2016 14:47 1.6M 
[TXT]rush_hour_solver_cut_down.py23-Jul-2009 11:44 14K 
[DIR]snake-puzzle/25-Sep-2016 20:56 -  
[DIR]stressdisk/08-Nov-2016 14:25 -  
[ ]timer-test09-May-2017 17:05 1.5M 
[TXT]words-to-regexp.pl01-Mar-2005 20:43 6.0K 
[SND]Now 100% better.mp32017-08-01 11:41 0  
[SND]Now better.mp32017-08-01 11:41 0  
rclone-v1.71.0/backend/http/test/index_files/caddy.html000066400000000000000000000264651505210326400230530ustar00rootroot00000000000000 /

/

4 directories 4 files
Name Size Modified
mimetype.zip 765 KiB
rclone-delete-empty-dirs.py 1.2 KiB
rclone-show-empty-dirs.py 868 B
stat-windows-386.zip 688 KiB
v1.36-155-gcf29ee8b-team-driveβ —
v1.36-156-gca76b3fb-team-driveβ —
v1.36-156-ge1f0e0f5-team-driveβ —
v1.36-22-g06ea13a-ssh-agentβ —
rclone-v1.71.0/backend/http/test/index_files/empty.html000066400000000000000000000000001505210326400230760ustar00rootroot00000000000000rclone-v1.71.0/backend/http/test/index_files/memstore.html000066400000000000000000000040721505210326400236100ustar00rootroot00000000000000 Index of /

Index of /

Name Type Size Last modified MD5
test/ application/directory 0 bytes - -
v1.35/ application/directory 0 bytes - -
v1.36-01-g503cd84/ application/directory 0 bytes - -
rclone-beta-latest-freebsd-386.zip application/zip 4.6 MB 2017-06-19 14:04:52 e747003c69c81e675f206a715264bfa8
rclone-beta-latest-freebsd-amd64.zip application/zip 5.0 MB 2017-06-19 14:04:53 ff30b5e9bf2863a2373069142e6f2b7f
rclone-beta-latest-windows-amd64.zip application/x-zip-compressed 4.9 MB 2017-06-19 13:56:02 851a5547a0495cbbd94cbc90a80ed6f5

Memset Ltd.

rclone-v1.71.0/backend/http/test/index_files/nginx.html000066400000000000000000000015041505210326400230750ustar00rootroot00000000000000 Index of /atomic/fedora/

Index of /atomic/fedora/

../
deltas/                                            04-May-2017 21:37                   -
objects/                                           04-May-2017 20:44                   -
refs/                                              04-May-2017 20:42                   -
state/                                             04-May-2017 21:36                   -
config                                             04-May-2017 20:42                 118
summary                                            04-May-2017 21:36                 806
rclone-v1.71.0/backend/iclouddrive/000077500000000000000000000000001505210326400171465ustar00rootroot00000000000000rclone-v1.71.0/backend/iclouddrive/api/000077500000000000000000000000001505210326400177175ustar00rootroot00000000000000rclone-v1.71.0/backend/iclouddrive/api/client.go000066400000000000000000000115341505210326400215300ustar00rootroot00000000000000// Package api provides functionality for interacting with the iCloud API. package api import ( "bytes" "context" "encoding/json" "errors" "fmt" "net/http" "strings" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/lib/rest" ) const ( baseEndpoint = "https://www.icloud.com" homeEndpoint = "https://www.icloud.com" setupEndpoint = "https://setup.icloud.com/setup/ws/1" authEndpoint = "https://idmsa.apple.com/appleauth/auth" ) type sessionSave func(*Session) // Client defines the client configuration type Client struct { appleID string password string srv *rest.Client Session *Session sessionSaveCallback sessionSave drive *DriveService } // New creates a new Client instance with the provided Apple ID, password, trust token, cookies, and session save callback. // // Parameters: // - appleID: the Apple ID of the user. // - password: the password of the user. // - trustToken: the trust token for the session. // - clientID: the client id for the session. // - cookies: the cookies for the session. // - sessionSaveCallback: the callback function to save the session. func New(appleID, password, trustToken string, clientID string, cookies []*http.Cookie, sessionSaveCallback sessionSave) (*Client, error) { icloud := &Client{ appleID: appleID, password: password, srv: rest.NewClient(fshttp.NewClient(context.Background())), Session: NewSession(), sessionSaveCallback: sessionSaveCallback, } icloud.Session.TrustToken = trustToken icloud.Session.Cookies = cookies icloud.Session.ClientID = clientID return icloud, nil } // DriveService returns the DriveService instance associated with the Client. func (c *Client) DriveService() (*DriveService, error) { var err error if c.drive == nil { c.drive, err = NewDriveService(c) if err != nil { return nil, err } } return c.drive, nil } // Request makes a request and retries it if the session is invalid. // // This function is the main entry point for making requests to the iCloud // API. If the initial request returns a 401 (Unauthorized), it will try to // reauthenticate and retry the request. func (c *Client) Request(ctx context.Context, opts rest.Opts, request any, response any) (resp *http.Response, err error) { resp, err = c.Session.Request(ctx, opts, request, response) if err != nil && resp != nil { // try to reauth if resp.StatusCode == 401 || resp.StatusCode == 421 { err = c.Authenticate(ctx) if err != nil { return nil, err } if c.Session.Requires2FA() { return nil, errors.New("trust token expired, please reauth") } return c.RequestNoReAuth(ctx, opts, request, response) } } return resp, err } // RequestNoReAuth makes a request without re-authenticating. // // This function is useful when you have a session that is already // authenticated, but you need to make a request without triggering // a re-authentication. func (c *Client) RequestNoReAuth(ctx context.Context, opts rest.Opts, request any, response any) (resp *http.Response, err error) { // Make the request without re-authenticating resp, err = c.Session.Request(ctx, opts, request, response) return resp, err } // Authenticate authenticates the client with the iCloud API. func (c *Client) Authenticate(ctx context.Context) error { if c.Session.Cookies != nil { if err := c.Session.ValidateSession(ctx); err == nil { fs.Debugf("icloud", "Valid session, no need to reauth") return nil } c.Session.Cookies = nil } fs.Debugf("icloud", "Authenticating as %s\n", c.appleID) err := c.Session.SignIn(ctx, c.appleID, c.password) if err == nil { err = c.Session.AuthWithToken(ctx) if err == nil && c.sessionSaveCallback != nil { c.sessionSaveCallback(c.Session) } } return err } // SignIn signs in the client using the provided context and credentials. func (c *Client) SignIn(ctx context.Context) error { return c.Session.SignIn(ctx, c.appleID, c.password) } // IntoReader marshals the provided values into a JSON encoded reader func IntoReader(values any) (*bytes.Reader, error) { m, err := json.Marshal(values) if err != nil { return nil, err } return bytes.NewReader(m), nil } // RequestError holds info on a result state, icloud can return a 200 but the result is unknown type RequestError struct { Status string Text string } // Error satisfy the error interface. func (e *RequestError) Error() string { return fmt.Sprintf("%s: %s", e.Text, e.Status) } func newRequestError(Status string, Text string) *RequestError { return &RequestError{ Status: strings.ToLower(Status), Text: Text, } } // newErr orf makes a new error from sprintf parameters. func newRequestErrorf(Status string, Text string, Parameters ...any) *RequestError { return newRequestError(strings.ToLower(Status), fmt.Sprintf(Text, Parameters...)) } rclone-v1.71.0/backend/iclouddrive/api/drive.go000066400000000000000000000660541505210326400213720ustar00rootroot00000000000000package api import ( "bytes" "context" "io" "mime" "net/http" "net/url" "path/filepath" "strconv" "strings" "time" "github.com/google/uuid" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/lib/rest" ) const ( defaultZone = "com.apple.CloudDocs" statusOk = "OK" statusEtagConflict = "ETAG_CONFLICT" ) // DriveService represents an iCloud Drive service. type DriveService struct { icloud *Client RootID string endpoint string docsEndpoint string } // NewDriveService creates a new DriveService instance. func NewDriveService(icloud *Client) (*DriveService, error) { return &DriveService{icloud: icloud, RootID: "FOLDER::com.apple.CloudDocs::root", endpoint: icloud.Session.AccountInfo.Webservices["drivews"].URL, docsEndpoint: icloud.Session.AccountInfo.Webservices["docws"].URL}, nil } // GetItemByDriveID retrieves a DriveItem by its Drive ID. func (d *DriveService) GetItemByDriveID(ctx context.Context, id string, includeChildren bool) (*DriveItem, *http.Response, error) { items, resp, err := d.GetItemsByDriveID(ctx, []string{id}, includeChildren) if err != nil { return nil, resp, err } return items[0], resp, err } // GetItemsByDriveID retrieves DriveItems by their Drive IDs. func (d *DriveService) GetItemsByDriveID(ctx context.Context, ids []string, includeChildren bool) ([]*DriveItem, *http.Response, error) { var err error _items := []map[string]any{} for _, id := range ids { _items = append(_items, map[string]any{ "drivewsid": id, "partialData": false, "includeHierarchy": false, }) } var body *bytes.Reader var path string if !includeChildren { values := []map[string]any{{ "items": _items, }} body, err = IntoReader(values) if err != nil { return nil, nil, err } path = "/retrieveItemDetails" } else { values := _items body, err = IntoReader(values) if err != nil { return nil, nil, err } path = "/retrieveItemDetailsInFolders" } opts := rest.Opts{ Method: "POST", Path: path, ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.endpoint, Body: body, } var items []*DriveItem resp, err := d.icloud.Request(ctx, opts, nil, &items) if err != nil { return nil, resp, err } return items, resp, err } // GetDocByPath retrieves a document by its path. func (d *DriveService) GetDocByPath(ctx context.Context, path string) (*Document, *http.Response, error) { values := url.Values{} values.Set("unified_format", "false") body, err := IntoReader(path) if err != nil { return nil, nil, err } opts := rest.Opts{ Method: "POST", Path: "/ws/" + defaultZone + "/list/lookup_by_path", ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.docsEndpoint, Parameters: values, Body: body, } var item []*Document resp, err := d.icloud.Request(ctx, opts, nil, &item) if err != nil { return nil, resp, err } return item[0], resp, err } // GetItemByPath retrieves a DriveItem by its path. func (d *DriveService) GetItemByPath(ctx context.Context, path string) (*DriveItem, *http.Response, error) { values := url.Values{} values.Set("unified_format", "true") body, err := IntoReader(path) if err != nil { return nil, nil, err } opts := rest.Opts{ Method: "POST", Path: "/ws/" + defaultZone + "/list/lookup_by_path", ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.docsEndpoint, Parameters: values, Body: body, } var item []*DriveItem resp, err := d.icloud.Request(ctx, opts, nil, &item) if err != nil { return nil, resp, err } return item[0], resp, err } // GetDocByItemID retrieves a document by its item ID. func (d *DriveService) GetDocByItemID(ctx context.Context, id string) (*Document, *http.Response, error) { values := url.Values{} values.Set("document_id", id) values.Set("unified_format", "false") // important opts := rest.Opts{ Method: "GET", Path: "/ws/" + defaultZone + "/list/lookup_by_id", ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.docsEndpoint, Parameters: values, } var item *Document resp, err := d.icloud.Request(ctx, opts, nil, &item) if err != nil { return nil, resp, err } return item, resp, err } // GetItemRawByItemID retrieves a DriveItemRaw by its item ID. func (d *DriveService) GetItemRawByItemID(ctx context.Context, id string) (*DriveItemRaw, *http.Response, error) { opts := rest.Opts{ Method: "GET", Path: "/v1/item/" + id, ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.docsEndpoint, } var item *DriveItemRaw resp, err := d.icloud.Request(ctx, opts, nil, &item) if err != nil { return nil, resp, err } return item, resp, err } // GetItemsInFolder retrieves a list of DriveItemRaw objects in a folder with the given ID. func (d *DriveService) GetItemsInFolder(ctx context.Context, id string, limit int64) ([]*DriveItemRaw, *http.Response, error) { values := url.Values{} values.Set("limit", strconv.FormatInt(limit, 10)) opts := rest.Opts{ Method: "GET", Path: "/v1/enumerate/" + id, ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.docsEndpoint, Parameters: values, } items := struct { Items []*DriveItemRaw `json:"drive_item"` }{} resp, err := d.icloud.Request(ctx, opts, nil, &items) if err != nil { return nil, resp, err } return items.Items, resp, err } // GetDownloadURLByDriveID retrieves the download URL for a file in the DriveService. func (d *DriveService) GetDownloadURLByDriveID(ctx context.Context, id string) (string, *http.Response, error) { _, zone, docid := DeconstructDriveID(id) values := url.Values{} values.Set("document_id", docid) if zone == "" { zone = defaultZone } opts := rest.Opts{ Method: "GET", Path: "/ws/" + zone + "/download/by_id", Parameters: values, ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.docsEndpoint, } var filer *FileRequest resp, err := d.icloud.Request(ctx, opts, nil, &filer) if err != nil { return "", resp, err } var url string if filer.DataToken != nil { url = filer.DataToken.URL } else { url = filer.PackageToken.URL } return url, resp, err } // DownloadFile downloads a file from the given URL using the provided options. func (d *DriveService) DownloadFile(ctx context.Context, url string, opt []fs.OpenOption) (*http.Response, error) { opts := &rest.Opts{ Method: "GET", ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: url, Options: opt, } resp, err := d.icloud.srv.Call(ctx, opts) // icloud has some weird http codes if err != nil && resp != nil && resp.StatusCode == 330 { loc, err := resp.Location() if err == nil { return d.DownloadFile(ctx, loc.String(), opt) } } return resp, err } // MoveItemToTrashByItemID moves an item to the trash based on the item ID. func (d *DriveService) MoveItemToTrashByItemID(ctx context.Context, id, etag string, force bool) (*DriveItem, *http.Response, error) { doc, resp, err := d.GetDocByItemID(ctx, id) if err != nil { return nil, resp, err } return d.MoveItemToTrashByID(ctx, doc.DriveID(), etag, force) } // MoveItemToTrashByID moves an item to the trash based on the item ID. func (d *DriveService) MoveItemToTrashByID(ctx context.Context, drivewsid, etag string, force bool) (*DriveItem, *http.Response, error) { values := map[string]any{ "items": []map[string]any{{ "drivewsid": drivewsid, "etag": etag, "clientId": drivewsid, }}} body, err := IntoReader(values) if err != nil { return nil, nil, err } opts := rest.Opts{ Method: "POST", Path: "/moveItemsToTrash", ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.endpoint, Body: body, } item := struct { Items []*DriveItem `json:"items"` }{} resp, err := d.icloud.Request(ctx, opts, nil, &item) if err != nil { return nil, resp, err } if item.Items[0].Status != statusOk { // rerun with latest etag if force && item.Items[0].Status == "ETAG_CONFLICT" { return d.MoveItemToTrashByID(ctx, drivewsid, item.Items[0].Etag, false) } err = newRequestError(item.Items[0].Status, "unknown request status") } return item.Items[0], resp, err } // CreateNewFolderByItemID creates a new folder by item ID. func (d *DriveService) CreateNewFolderByItemID(ctx context.Context, id, name string) (*DriveItem, *http.Response, error) { doc, resp, err := d.GetDocByItemID(ctx, id) if err != nil { return nil, resp, err } return d.CreateNewFolderByDriveID(ctx, doc.DriveID(), name) } // CreateNewFolderByDriveID creates a new folder by its Drive ID. func (d *DriveService) CreateNewFolderByDriveID(ctx context.Context, drivewsid, name string) (*DriveItem, *http.Response, error) { values := map[string]any{ "destinationDrivewsId": drivewsid, "folders": []map[string]any{{ "clientId": "FOLDER::UNKNOWN_ZONE::TempId-" + uuid.New().String(), "name": name, }}, } body, err := IntoReader(values) if err != nil { return nil, nil, err } opts := rest.Opts{ Method: "POST", Path: "/createFolders", ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.endpoint, Body: body, } var fResp *CreateFoldersResponse resp, err := d.icloud.Request(ctx, opts, nil, &fResp) if err != nil { return nil, resp, err } status := fResp.Folders[0].Status if status != statusOk { err = newRequestError(status, "unknown request status") } return fResp.Folders[0], resp, err } // RenameItemByItemID renames a DriveItem by its item ID. func (d *DriveService) RenameItemByItemID(ctx context.Context, id, etag, name string, force bool) (*DriveItem, *http.Response, error) { doc, resp, err := d.GetDocByItemID(ctx, id) if err != nil { return nil, resp, err } return d.RenameItemByDriveID(ctx, doc.DriveID(), doc.Etag, name, force) } // RenameItemByDriveID renames a DriveItem by its drive ID. func (d *DriveService) RenameItemByDriveID(ctx context.Context, id, etag, name string, force bool) (*DriveItem, *http.Response, error) { values := map[string]any{ "items": []map[string]any{{ "drivewsid": id, "name": name, "etag": etag, // "extension": split[1], }}, } body, err := IntoReader(values) if err != nil { return nil, nil, err } opts := rest.Opts{ Method: "POST", Path: "/renameItems", ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.endpoint, Body: body, } var items *DriveItem resp, err := d.icloud.Request(ctx, opts, nil, &items) if err != nil { return nil, resp, err } status := items.Items[0].Status if status != statusOk { // rerun with latest etag if force && status == "ETAG_CONFLICT" { return d.RenameItemByDriveID(ctx, id, items.Items[0].Etag, name, false) } err = newRequestErrorf(status, "unknown inner status for: %s %s", opts.Method, resp.Request.URL) } return items.Items[0], resp, err } // MoveItemByItemID moves an item by its item ID to a destination item ID. func (d *DriveService) MoveItemByItemID(ctx context.Context, id, etag, dstID string, force bool) (*DriveItem, *http.Response, error) { docSrc, resp, err := d.GetDocByItemID(ctx, id) if err != nil { return nil, resp, err } docDst, resp, err := d.GetDocByItemID(ctx, dstID) if err != nil { return nil, resp, err } return d.MoveItemByDriveID(ctx, docSrc.DriveID(), docSrc.Etag, docDst.DriveID(), force) } // MoveItemByDocID moves an item by its doc ID. // func (d *DriveService) MoveItemByDocID(ctx context.Context, srcDocID, srcEtag, dstDocID string, force bool) (*DriveItem, *http.Response, error) { // return d.MoveItemByDriveID(ctx, srcDocID, srcEtag, docDst.DriveID(), force) // } // MoveItemByDriveID moves an item by its drive ID. func (d *DriveService) MoveItemByDriveID(ctx context.Context, id, etag, dstID string, force bool) (*DriveItem, *http.Response, error) { values := map[string]any{ "destinationDrivewsId": dstID, "items": []map[string]any{{ "drivewsid": id, "etag": etag, "clientId": id, }}, } body, err := IntoReader(values) if err != nil { return nil, nil, err } opts := rest.Opts{ Method: "POST", Path: "/moveItems", ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.endpoint, Body: body, } var items *DriveItem resp, err := d.icloud.Request(ctx, opts, nil, &items) if err != nil { return nil, resp, err } status := items.Items[0].Status if status != statusOk { // rerun with latest etag if force && status == "ETAG_CONFLICT" { return d.MoveItemByDriveID(ctx, id, items.Items[0].Etag, dstID, false) } err = newRequestErrorf(status, "unknown inner status for: %s %s", opts.Method, resp.Request.URL) } return items.Items[0], resp, err } // CopyDocByItemID copies a document by its item ID. func (d *DriveService) CopyDocByItemID(ctx context.Context, itemID string) (*DriveItemRaw, *http.Response, error) { // putting name in info doesn't work. extension does work so assume this is a bug in the endpoint values := map[string]any{ "info_to_update": map[string]any{}, } body, err := IntoReader(values) if err != nil { return nil, nil, err } opts := rest.Opts{ Method: "POST", Path: "/v1/item/copy/" + itemID, ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.docsEndpoint, Body: body, } var info *DriveItemRaw resp, err := d.icloud.Request(ctx, opts, nil, &info) if err != nil { return nil, resp, err } return info, resp, err } // CreateUpload creates an url for an upload. func (d *DriveService) CreateUpload(ctx context.Context, size int64, name string) (*UploadResponse, *http.Response, error) { // first we need to request an upload url values := map[string]any{ "filename": name, "type": "FILE", "size": strconv.FormatInt(size, 10), "content_type": GetContentTypeForFile(name), } body, err := IntoReader(values) if err != nil { return nil, nil, err } opts := rest.Opts{ Method: "POST", Path: "/ws/" + defaultZone + "/upload/web", ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.docsEndpoint, Body: body, } var responseInfo []*UploadResponse resp, err := d.icloud.Request(ctx, opts, nil, &responseInfo) if err != nil { return nil, resp, err } return responseInfo[0], resp, err } // Upload uploads a file to the given url func (d *DriveService) Upload(ctx context.Context, in io.Reader, size int64, name, uploadURL string) (*SingleFileResponse, *http.Response, error) { // TODO: implement multipart upload opts := rest.Opts{ Method: "POST", ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: uploadURL, Body: in, ContentLength: &size, ContentType: GetContentTypeForFile(name), // MultipartContentName: "files", MultipartFileName: name, } var singleFileResponse *SingleFileResponse resp, err := d.icloud.Request(ctx, opts, nil, &singleFileResponse) if err != nil { return nil, resp, err } return singleFileResponse, resp, err } // UpdateFile updates a file in the DriveService. // // ctx: the context.Context object for the request. // r: a pointer to the UpdateFileInfo struct containing the information for the file update. // Returns a pointer to the DriveItem struct representing the updated file, the http.Response object, and an error if any. func (d *DriveService) UpdateFile(ctx context.Context, r *UpdateFileInfo) (*DriveItem, *http.Response, error) { body, err := IntoReader(r) if err != nil { return nil, nil, err } opts := rest.Opts{ Method: "POST", Path: "/ws/" + defaultZone + "/update/documents", ExtraHeaders: d.icloud.Session.GetHeaders(map[string]string{}), RootURL: d.docsEndpoint, Body: body, } var responseInfo *DocumentUpdateResponse resp, err := d.icloud.Request(ctx, opts, nil, &responseInfo) if err != nil { return nil, resp, err } doc := responseInfo.Results[0].Document item := DriveItem{ Drivewsid: "FILE::com.apple.CloudDocs::" + doc.DocumentID, Docwsid: doc.DocumentID, Itemid: doc.ItemID, Etag: doc.Etag, ParentID: doc.ParentID, DateModified: time.Unix(r.Mtime, 0), DateCreated: time.Unix(r.Mtime, 0), Type: doc.Type, Name: doc.Name, Size: doc.Size, } return &item, resp, err } // UpdateFileInfo represents the information for an update to a file in the DriveService. type UpdateFileInfo struct { AllowConflict bool `json:"allow_conflict"` Btime int64 `json:"btime"` Command string `json:"command"` CreateShortGUID bool `json:"create_short_guid"` Data struct { Receipt string `json:"receipt,omitempty"` ReferenceSignature string `json:"reference_signature,omitempty"` Signature string `json:"signature,omitempty"` Size int64 `json:"size,omitempty"` WrappingKey string `json:"wrapping_key,omitempty"` } `json:"data,omitempty"` DocumentID string `json:"document_id"` FileFlags FileFlags `json:"file_flags"` Mtime int64 `json:"mtime"` Path struct { Path string `json:"path"` StartingDocumentID string `json:"starting_document_id"` } `json:"path"` } // FileFlags defines the file flags for a document. type FileFlags struct { IsExecutable bool `json:"is_executable"` IsHidden bool `json:"is_hidden"` IsWritable bool `json:"is_writable"` } // NewUpdateFileInfo creates a new UpdateFileInfo object with default values. // // Returns an UpdateFileInfo object. func NewUpdateFileInfo() UpdateFileInfo { return UpdateFileInfo{ Command: "add_file", CreateShortGUID: true, AllowConflict: true, FileFlags: FileFlags{ IsExecutable: true, IsHidden: false, IsWritable: true, }, } } // DriveItemRaw is a raw drive item. // not suure what to call this but there seems to be a "unified" and non "unified" drive item response. This is the non unified. type DriveItemRaw struct { ItemID string `json:"item_id"` ItemInfo *DriveItemRawInfo `json:"item_info"` } // SplitName splits the name of a DriveItemRaw into its name and extension. // // It returns the name and extension as separate strings. If the name ends with a dot, // it means there is no extension, so an empty string is returned for the extension. // If the name does not contain a dot, it means func (d *DriveItemRaw) SplitName() (string, string) { name := d.ItemInfo.Name // ends with a dot, no extension if strings.HasSuffix(name, ".") { return name, "" } lastInd := strings.LastIndex(name, ".") if lastInd == -1 { return name, "" } return name[:lastInd], name[lastInd+1:] } // ModTime returns the modification time of the DriveItemRaw. // // It parses the ModifiedAt field of the ItemInfo struct and converts it to a time.Time value. // If the parsing fails, it returns the zero value of time.Time. // The returned time.Time value represents the modification time of the DriveItemRaw. func (d *DriveItemRaw) ModTime() time.Time { i, err := strconv.ParseInt(d.ItemInfo.ModifiedAt, 10, 64) if err != nil { return time.Time{} } return time.UnixMilli(i) } // CreatedTime returns the creation time of the DriveItemRaw. // // It parses the CreatedAt field of the ItemInfo struct and converts it to a time.Time value. // If the parsing fails, it returns the zero value of time.Time. // The returned time.Time func (d *DriveItemRaw) CreatedTime() time.Time { i, err := strconv.ParseInt(d.ItemInfo.CreatedAt, 10, 64) if err != nil { return time.Time{} } return time.UnixMilli(i) } // DriveItemRawInfo is the raw information about a drive item. type DriveItemRawInfo struct { Name string `json:"name"` // Extension is absolutely borked on endpoints so dont use it. Extension string `json:"extension"` Size int64 `json:"size,string"` Type string `json:"type"` Version string `json:"version"` ModifiedAt string `json:"modified_at"` CreatedAt string `json:"created_at"` Urls struct { URLDownload string `json:"url_download"` } `json:"urls"` } // IntoDriveItem converts a DriveItemRaw into a DriveItem. // // It takes no parameters. // It returns a pointer to a DriveItem. func (d *DriveItemRaw) IntoDriveItem() *DriveItem { name, extension := d.SplitName() return &DriveItem{ Itemid: d.ItemID, Name: name, Extension: extension, Type: d.ItemInfo.Type, Etag: d.ItemInfo.Version, DateModified: d.ModTime(), DateCreated: d.CreatedTime(), Size: d.ItemInfo.Size, Urls: d.ItemInfo.Urls, } } // DocumentUpdateResponse is the response of a document update request. type DocumentUpdateResponse struct { Status struct { StatusCode int `json:"status_code"` ErrorMessage string `json:"error_message"` } `json:"status"` Results []struct { Status struct { StatusCode int `json:"status_code"` ErrorMessage string `json:"error_message"` } `json:"status"` OperationID any `json:"operation_id"` Document *Document `json:"document"` } `json:"results"` } // Document represents a document on iCloud. type Document struct { Status struct { StatusCode int `json:"status_code"` ErrorMessage string `json:"error_message"` } `json:"status"` DocumentID string `json:"document_id"` ItemID string `json:"item_id"` Urls struct { URLDownload string `json:"url_download"` } `json:"urls"` Etag string `json:"etag"` ParentID string `json:"parent_id"` Name string `json:"name"` Type string `json:"type"` Deleted bool `json:"deleted"` Mtime int64 `json:"mtime"` LastEditorName string `json:"last_editor_name"` Data DocumentData `json:"data"` Size int64 `json:"size"` Btime int64 `json:"btime"` Zone string `json:"zone"` FileFlags struct { IsExecutable bool `json:"is_executable"` IsWritable bool `json:"is_writable"` IsHidden bool `json:"is_hidden"` } `json:"file_flags"` LastOpenedTime int64 `json:"lastOpenedTime"` RestorePath any `json:"restorePath"` HasChainedParent bool `json:"hasChainedParent"` } // DriveID returns the drive ID of the Document. func (d *Document) DriveID() string { if d.Zone == "" { d.Zone = defaultZone } return d.Type + "::" + d.Zone + "::" + d.DocumentID } // DocumentData represents the data of a document. type DocumentData struct { Signature string `json:"signature"` Owner string `json:"owner"` Size int64 `json:"size"` ReferenceSignature string `json:"reference_signature"` WrappingKey string `json:"wrapping_key"` PcsInfo string `json:"pcsInfo"` } // SingleFileResponse is the response of a single file request. type SingleFileResponse struct { SingleFile *SingleFileInfo `json:"singleFile"` } // SingleFileInfo represents the information of a single file. type SingleFileInfo struct { ReferenceSignature string `json:"referenceChecksum"` Size int64 `json:"size"` Signature string `json:"fileChecksum"` WrappingKey string `json:"wrappingKey"` Receipt string `json:"receipt"` } // UploadResponse is the response of an upload request. type UploadResponse struct { URL string `json:"url"` DocumentID string `json:"document_id"` } // FileRequestToken represents the token of a file request. type FileRequestToken struct { URL string `json:"url"` Token string `json:"token"` Signature string `json:"signature"` WrappingKey string `json:"wrapping_key"` ReferenceSignature string `json:"reference_signature"` } // FileRequest represents the request of a file. type FileRequest struct { DocumentID string `json:"document_id"` ItemID string `json:"item_id"` OwnerDsid int64 `json:"owner_dsid"` DataToken *FileRequestToken `json:"data_token,omitempty"` PackageToken *FileRequestToken `json:"package_token,omitempty"` DoubleEtag string `json:"double_etag"` } // CreateFoldersResponse is the response of a create folders request. type CreateFoldersResponse struct { Folders []*DriveItem `json:"folders"` } // DriveItem represents an item on iCloud. type DriveItem struct { DateCreated time.Time `json:"dateCreated"` Drivewsid string `json:"drivewsid"` Docwsid string `json:"docwsid"` Itemid string `json:"item_id"` Zone string `json:"zone"` Name string `json:"name"` ParentID string `json:"parentId"` Hierarchy []DriveItem `json:"hierarchy"` Etag string `json:"etag"` Type string `json:"type"` AssetQuota int64 `json:"assetQuota"` FileCount int64 `json:"fileCount"` ShareCount int64 `json:"shareCount"` ShareAliasCount int64 `json:"shareAliasCount"` DirectChildrenCount int64 `json:"directChildrenCount"` Items []*DriveItem `json:"items"` NumberOfItems int64 `json:"numberOfItems"` Status string `json:"status"` Extension string `json:"extension,omitempty"` DateModified time.Time `json:"dateModified,omitempty"` DateChanged time.Time `json:"dateChanged,omitempty"` Size int64 `json:"size,omitempty"` LastOpenTime time.Time `json:"lastOpenTime,omitempty"` Urls struct { URLDownload string `json:"url_download"` } `json:"urls"` } // IsFolder returns true if the item is a folder. func (d *DriveItem) IsFolder() bool { return d.Type == "FOLDER" || d.Type == "APP_CONTAINER" || d.Type == "APP_LIBRARY" } // DownloadURL returns the download URL of the item. func (d *DriveItem) DownloadURL() string { return d.Urls.URLDownload } // FullName returns the full name of the item. // name + extension func (d *DriveItem) FullName() string { if d.Extension != "" { return d.Name + "." + d.Extension } return d.Name } // GetDocIDFromDriveID returns the DocumentID from the drive ID. func GetDocIDFromDriveID(id string) string { split := strings.Split(id, "::") return split[len(split)-1] } // DeconstructDriveID returns the document type, zone, and document ID from the drive ID. func DeconstructDriveID(id string) (docType, zone, docid string) { split := strings.Split(id, "::") if len(split) < 3 { return "", "", id } return split[0], split[1], split[2] } // ConstructDriveID constructs a drive ID from the given components. func ConstructDriveID(id string, zone string, t string) string { return strings.Join([]string{t, zone, id}, "::") } // GetContentTypeForFile detects content type for given file name. func GetContentTypeForFile(name string) string { // detect MIME type by looking at the filename only mimeType := mime.TypeByExtension(filepath.Ext(name)) if mimeType == "" { // api requires a mime type passed in mimeType = "text/plain" } return strings.Split(mimeType, ";")[0] } rclone-v1.71.0/backend/iclouddrive/api/session.go000066400000000000000000000336011505210326400217340ustar00rootroot00000000000000package api import ( "context" "fmt" "maps" "net/http" "net/url" "slices" "strings" "github.com/oracle/oci-go-sdk/v65/common" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/lib/rest" ) // Session represents an iCloud session type Session struct { SessionToken string `json:"session_token"` Scnt string `json:"scnt"` SessionID string `json:"session_id"` AccountCountry string `json:"account_country"` TrustToken string `json:"trust_token"` ClientID string `json:"client_id"` Cookies []*http.Cookie `json:"cookies"` AccountInfo AccountInfo `json:"account_info"` srv *rest.Client `json:"-"` } // String returns the session as a string // func (s *Session) String() string { // jsession, _ := json.Marshal(s) // return string(jsession) // } // Request makes a request func (s *Session) Request(ctx context.Context, opts rest.Opts, request any, response any) (*http.Response, error) { resp, err := s.srv.CallJSON(ctx, &opts, &request, &response) if err != nil { return resp, err } if val := resp.Header.Get("X-Apple-ID-Account-Country"); val != "" { s.AccountCountry = val } if val := resp.Header.Get("X-Apple-ID-Session-Id"); val != "" { s.SessionID = val } if val := resp.Header.Get("X-Apple-Session-Token"); val != "" { s.SessionToken = val } if val := resp.Header.Get("X-Apple-TwoSV-Trust-Token"); val != "" { s.TrustToken = val } if val := resp.Header.Get("scnt"); val != "" { s.Scnt = val } return resp, nil } // Requires2FA returns true if the session requires 2FA func (s *Session) Requires2FA() bool { return s.AccountInfo.DsInfo.HsaVersion == 2 && s.AccountInfo.HsaChallengeRequired } // SignIn signs in the session func (s *Session) SignIn(ctx context.Context, appleID, password string) error { trustTokens := []string{} if s.TrustToken != "" { trustTokens = []string{s.TrustToken} } values := map[string]any{ "accountName": appleID, "password": password, "rememberMe": true, "trustTokens": trustTokens, } body, err := IntoReader(values) if err != nil { return err } opts := rest.Opts{ Method: "POST", Path: "/signin", Parameters: url.Values{}, ExtraHeaders: s.GetAuthHeaders(map[string]string{}), RootURL: authEndpoint, IgnoreStatus: true, // need to handle 409 for hsa2 NoResponse: true, Body: body, } opts.Parameters.Set("isRememberMeEnabled", "true") _, err = s.Request(ctx, opts, nil, nil) return err } // AuthWithToken authenticates the session func (s *Session) AuthWithToken(ctx context.Context) error { values := map[string]any{ "accountCountryCode": s.AccountCountry, "dsWebAuthToken": s.SessionToken, "extended_login": true, "trustToken": s.TrustToken, } body, err := IntoReader(values) if err != nil { return err } opts := rest.Opts{ Method: "POST", Path: "/accountLogin", ExtraHeaders: GetCommonHeaders(map[string]string{}), RootURL: setupEndpoint, Body: body, } resp, err := s.Request(ctx, opts, nil, &s.AccountInfo) if err == nil { s.Cookies = resp.Cookies() } return err } // Validate2FACode validates the 2FA code func (s *Session) Validate2FACode(ctx context.Context, code string) error { values := map[string]any{"securityCode": map[string]string{"code": code}} body, err := IntoReader(values) if err != nil { return err } headers := s.GetAuthHeaders(map[string]string{}) headers["scnt"] = s.Scnt headers["X-Apple-ID-Session-Id"] = s.SessionID opts := rest.Opts{ Method: "POST", Path: "/verify/trusteddevice/securitycode", ExtraHeaders: headers, RootURL: authEndpoint, Body: body, NoResponse: true, } _, err = s.Request(ctx, opts, nil, nil) if err == nil { if err := s.TrustSession(ctx); err != nil { return err } return nil } return fmt.Errorf("validate2FACode failed: %w", err) } // TrustSession trusts the session func (s *Session) TrustSession(ctx context.Context) error { headers := s.GetAuthHeaders(map[string]string{}) headers["scnt"] = s.Scnt headers["X-Apple-ID-Session-Id"] = s.SessionID opts := rest.Opts{ Method: "GET", Path: "/2sv/trust", ExtraHeaders: headers, RootURL: authEndpoint, NoResponse: true, ContentLength: common.Int64(0), } _, err := s.Request(ctx, opts, nil, nil) if err != nil { return fmt.Errorf("trustSession failed: %w", err) } return s.AuthWithToken(ctx) } // ValidateSession validates the session func (s *Session) ValidateSession(ctx context.Context) error { opts := rest.Opts{ Method: "POST", Path: "/validate", ExtraHeaders: s.GetHeaders(map[string]string{}), RootURL: setupEndpoint, ContentLength: common.Int64(0), } _, err := s.Request(ctx, opts, nil, &s.AccountInfo) if err != nil { return fmt.Errorf("validateSession failed: %w", err) } return nil } // GetAuthHeaders returns the authentication headers for the session. // // It takes an `overwrite` map[string]string parameter which allows // overwriting the default headers. It returns a map[string]string. func (s *Session) GetAuthHeaders(overwrite map[string]string) map[string]string { headers := map[string]string{ "Accept": "application/json", "Content-Type": "application/json", "X-Apple-OAuth-Client-Id": s.ClientID, "X-Apple-OAuth-Client-Type": "firstPartyAuth", "X-Apple-OAuth-Redirect-URI": "https://www.icloud.com", "X-Apple-OAuth-Require-Grant-Code": "true", "X-Apple-OAuth-Response-Mode": "web_message", "X-Apple-OAuth-Response-Type": "code", "X-Apple-OAuth-State": s.ClientID, "X-Apple-Widget-Key": s.ClientID, "Origin": homeEndpoint, "Referer": fmt.Sprintf("%s/", homeEndpoint), "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:103.0) Gecko/20100101 Firefox/103.0", } maps.Copy(headers, overwrite) return headers } // GetHeaders Gets the authentication headers required for a request func (s *Session) GetHeaders(overwrite map[string]string) map[string]string { headers := GetCommonHeaders(map[string]string{}) headers["Cookie"] = s.GetCookieString() maps.Copy(headers, overwrite) return headers } // GetCookieString returns the cookie header string for the session. func (s *Session) GetCookieString() string { cookieHeader := "" // we only care about name and value. for _, cookie := range s.Cookies { cookieHeader = cookieHeader + cookie.Name + "=" + cookie.Value + ";" } return cookieHeader } // GetCommonHeaders generates common HTTP headers with optional overwrite. func GetCommonHeaders(overwrite map[string]string) map[string]string { headers := map[string]string{ "Content-Type": "application/json", "Origin": baseEndpoint, "Referer": fmt.Sprintf("%s/", baseEndpoint), "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:103.0) Gecko/20100101 Firefox/103.0", } maps.Copy(headers, overwrite) return headers } // MergeCookies merges two slices of http.Cookies, ensuring no duplicates are added. func MergeCookies(left []*http.Cookie, right []*http.Cookie) ([]*http.Cookie, error) { var hashes []string for _, cookie := range right { hashes = append(hashes, cookie.Raw) } for _, cookie := range left { if !slices.Contains(hashes, cookie.Raw) { right = append(right, cookie) } } return right, nil } // GetCookiesForDomain filters the provided cookies based on the domain of the given URL. func GetCookiesForDomain(url *url.URL, cookies []*http.Cookie) ([]*http.Cookie, error) { var domainCookies []*http.Cookie for _, cookie := range cookies { if strings.HasSuffix(url.Host, cookie.Domain) { domainCookies = append(domainCookies, cookie) } } return domainCookies, nil } // NewSession creates a new Session instance with default values. func NewSession() *Session { session := &Session{} session.srv = rest.NewClient(fshttp.NewClient(context.Background())).SetRoot(baseEndpoint) //session.ClientID = "auth-" + uuid.New().String() return session } // AccountInfo represents an account info type AccountInfo struct { DsInfo *ValidateDataDsInfo `json:"dsInfo"` HasMinimumDeviceForPhotosWeb bool `json:"hasMinimumDeviceForPhotosWeb"` ICDPEnabled bool `json:"iCDPEnabled"` Webservices map[string]*webService `json:"webservices"` PcsEnabled bool `json:"pcsEnabled"` TermsUpdateNeeded bool `json:"termsUpdateNeeded"` ConfigBag struct { Urls struct { AccountCreateUI string `json:"accountCreateUI"` AccountLoginUI string `json:"accountLoginUI"` AccountLogin string `json:"accountLogin"` AccountRepairUI string `json:"accountRepairUI"` DownloadICloudTerms string `json:"downloadICloudTerms"` RepairDone string `json:"repairDone"` AccountAuthorizeUI string `json:"accountAuthorizeUI"` VettingURLForEmail string `json:"vettingUrlForEmail"` AccountCreate string `json:"accountCreate"` GetICloudTerms string `json:"getICloudTerms"` VettingURLForPhone string `json:"vettingUrlForPhone"` } `json:"urls"` AccountCreateEnabled bool `json:"accountCreateEnabled"` } `json:"configBag"` HsaTrustedBrowser bool `json:"hsaTrustedBrowser"` AppsOrder []string `json:"appsOrder"` Version int `json:"version"` IsExtendedLogin bool `json:"isExtendedLogin"` PcsServiceIdentitiesIncluded bool `json:"pcsServiceIdentitiesIncluded"` IsRepairNeeded bool `json:"isRepairNeeded"` HsaChallengeRequired bool `json:"hsaChallengeRequired"` RequestInfo struct { Country string `json:"country"` TimeZone string `json:"timeZone"` Region string `json:"region"` } `json:"requestInfo"` PcsDeleted bool `json:"pcsDeleted"` ICloudInfo struct { SafariBookmarksHasMigratedToCloudKit bool `json:"SafariBookmarksHasMigratedToCloudKit"` } `json:"iCloudInfo"` Apps map[string]*ValidateDataApp `json:"apps"` } // ValidateDataDsInfo represents an validation info type ValidateDataDsInfo struct { HsaVersion int `json:"hsaVersion"` LastName string `json:"lastName"` ICDPEnabled bool `json:"iCDPEnabled"` TantorMigrated bool `json:"tantorMigrated"` Dsid string `json:"dsid"` HsaEnabled bool `json:"hsaEnabled"` IsHideMyEmailSubscriptionActive bool `json:"isHideMyEmailSubscriptionActive"` IroncadeMigrated bool `json:"ironcadeMigrated"` Locale string `json:"locale"` BrZoneConsolidated bool `json:"brZoneConsolidated"` ICDRSCapableDeviceList string `json:"ICDRSCapableDeviceList"` IsManagedAppleID bool `json:"isManagedAppleID"` IsCustomDomainsFeatureAvailable bool `json:"isCustomDomainsFeatureAvailable"` IsHideMyEmailFeatureAvailable bool `json:"isHideMyEmailFeatureAvailable"` ContinueOnDeviceEligibleDeviceInfo []string `json:"ContinueOnDeviceEligibleDeviceInfo"` Gilligvited bool `json:"gilligvited"` AppleIDAliases []any `json:"appleIdAliases"` UbiquityEOLEnabled bool `json:"ubiquityEOLEnabled"` IsPaidDeveloper bool `json:"isPaidDeveloper"` CountryCode string `json:"countryCode"` NotificationID string `json:"notificationId"` PrimaryEmailVerified bool `json:"primaryEmailVerified"` ADsID string `json:"aDsID"` Locked bool `json:"locked"` ICDRSCapableDeviceCount int `json:"ICDRSCapableDeviceCount"` HasICloudQualifyingDevice bool `json:"hasICloudQualifyingDevice"` PrimaryEmail string `json:"primaryEmail"` AppleIDEntries []struct { IsPrimary bool `json:"isPrimary"` Type string `json:"type"` Value string `json:"value"` } `json:"appleIdEntries"` GilliganEnabled bool `json:"gilligan-enabled"` IsWebAccessAllowed bool `json:"isWebAccessAllowed"` FullName string `json:"fullName"` MailFlags struct { IsThreadingAvailable bool `json:"isThreadingAvailable"` IsSearchV2Provisioned bool `json:"isSearchV2Provisioned"` SCKMail bool `json:"sCKMail"` IsMppSupportedInCurrentCountry bool `json:"isMppSupportedInCurrentCountry"` } `json:"mailFlags"` LanguageCode string `json:"languageCode"` AppleID string `json:"appleId"` HasUnreleasedOS bool `json:"hasUnreleasedOS"` AnalyticsOptInStatus bool `json:"analyticsOptInStatus"` FirstName string `json:"firstName"` ICloudAppleIDAlias string `json:"iCloudAppleIdAlias"` NotesMigrated bool `json:"notesMigrated"` BeneficiaryInfo struct { IsBeneficiary bool `json:"isBeneficiary"` } `json:"beneficiaryInfo"` HasPaymentInfo bool `json:"hasPaymentInfo"` PcsDelet bool `json:"pcsDelet"` AppleIDAlias string `json:"appleIdAlias"` BrMigrated bool `json:"brMigrated"` StatusCode int `json:"statusCode"` FamilyEligible bool `json:"familyEligible"` } // ValidateDataApp represents an app type ValidateDataApp struct { CanLaunchWithOneFactor bool `json:"canLaunchWithOneFactor"` IsQualifiedForBeta bool `json:"isQualifiedForBeta"` } // WebService represents a web service type webService struct { PcsRequired bool `json:"pcsRequired"` URL string `json:"url"` UploadURL string `json:"uploadUrl"` Status string `json:"status"` } rclone-v1.71.0/backend/iclouddrive/iclouddrive.go000066400000000000000000000735101505210326400220140ustar00rootroot00000000000000//go:build !plan9 && !solaris // Package iclouddrive implements the iCloud Drive backend package iclouddrive import ( "bytes" "context" "path" "errors" "fmt" "io" "net/http" "strings" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/backend/iclouddrive/api" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/dircache" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/pacer" ) /* - dirCache operates on relative path to root - path sanitization - rule of thumb: sanitize before use, but store things as-is - the paths cached in dirCache are after sanitizing - the remote/dir passed in aren't, and are stored as-is */ const ( configAppleID = "apple_id" configPassword = "password" configClientID = "client_id" configCookies = "cookies" configTrustToken = "trust_token" minSleep = 10 * time.Millisecond maxSleep = 2 * time.Second decayConstant = 2 ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "iclouddrive", Description: "iCloud Drive", Config: Config, NewFs: NewFs, Options: []fs.Option{{ Name: configAppleID, Help: "Apple ID.", Required: true, Sensitive: true, }, { Name: configPassword, Help: "Password.", Required: true, IsPassword: true, Sensitive: true, }, { Name: configTrustToken, Help: "Trust token (internal use)", IsPassword: false, Required: false, Sensitive: true, Hide: fs.OptionHideBoth, }, { Name: configCookies, Help: "cookies (internal use only)", Required: false, Advanced: false, Sensitive: true, Hide: fs.OptionHideBoth, }, { Name: configClientID, Help: "Client id", Required: false, Advanced: true, Default: "d39ba9916b7251055b22c7f910e2ea796ee65e98b2ddecea8f5dde8d9d1a815d", }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: (encoder.Display | //encoder.EncodeDot | encoder.EncodeBackSlash | encoder.EncodeInvalidUtf8), }}, }) } // Options defines the configuration for this backend type Options struct { AppleID string `config:"apple_id"` Password string `config:"password"` Photos bool `config:"photos"` TrustToken string `config:"trust_token"` Cookies string `config:"cookies"` ClientID string `config:"client_id"` Enc encoder.MultiEncoder `config:"encoding"` } // Fs represents a remote icloud drive type Fs struct { name string // name of this remote root string // the path we are working on. rootID string opt Options // parsed config options features *fs.Features // optional features dirCache *dircache.DirCache // Map of directory path to directory id icloud *api.Client service *api.DriveService pacer *fs.Pacer // pacer for API calls } // Object describes an icloud drive object type Object struct { fs *Fs // what this object is part of remote string // The remote path (relative to the fs.root) size int64 // size of the object (on server, after encryption) modTime time.Time // modification time of the object createdTime time.Time // creation time of the object driveID string // item ID of the object docID string // document ID of the object itemID string // item ID of the object etag string downloadURL string } // Config configures the iCloud remote. func Config(ctx context.Context, name string, m configmap.Mapper, config fs.ConfigIn) (*fs.ConfigOut, error) { var err error appleid, _ := m.Get(configAppleID) if appleid == "" { return nil, errors.New("a apple ID is required") } password, _ := m.Get(configPassword) if password != "" { password, err = obscure.Reveal(password) if err != nil { return nil, err } } trustToken, _ := m.Get(configTrustToken) cookieRaw, _ := m.Get(configCookies) clientID, _ := m.Get(configClientID) cookies := ReadCookies(cookieRaw) switch config.State { case "": icloud, err := api.New(appleid, password, trustToken, clientID, cookies, nil) if err != nil { return nil, err } if err := icloud.Authenticate(ctx); err != nil { return nil, err } m.Set(configCookies, icloud.Session.GetCookieString()) if icloud.Session.Requires2FA() { return fs.ConfigInput("2fa_do", "config_2fa", "Two-factor authentication: please enter your 2FA code") } return nil, nil case "2fa_do": code := config.Result if code == "" { return fs.ConfigError("authenticate", "2FA codes can't be blank") } icloud, err := api.New(appleid, password, trustToken, clientID, cookies, nil) if err != nil { return nil, err } if err := icloud.SignIn(ctx); err != nil { return nil, err } if err := icloud.Session.Validate2FACode(ctx, code); err != nil { return nil, err } m.Set(configTrustToken, icloud.Session.TrustToken) m.Set(configCookies, icloud.Session.GetCookieString()) return nil, nil case "2fa_error": if config.Result == "true" { return fs.ConfigGoto("2fa") } return nil, errors.New("2fa authentication failed") } return nil, fmt.Errorf("unknown state %q", config.State) } // find item by path. Will not return any children for the item func (f *Fs) findItem(ctx context.Context, dir string) (item *api.DriveItem, found bool, err error) { var resp *http.Response if err = f.pacer.Call(func() (bool, error) { item, resp, err = f.service.GetItemByPath(ctx, path.Join(f.root, dir)) return shouldRetry(ctx, resp, err) }); err != nil { if item == nil && resp.StatusCode == 404 { return nil, false, nil } return nil, false, err } return item, true, nil } func (f *Fs) findLeafItem(ctx context.Context, pathID string, leaf string) (item *api.DriveItem, found bool, err error) { items, err := f.listAll(ctx, pathID) if err != nil { return nil, false, err } for _, item := range items { if strings.EqualFold(item.FullName(), leaf) { return item, true, nil } } return nil, false, nil } // FindLeaf finds a directory of name leaf in the folder with ID pathID func (f *Fs) FindLeaf(ctx context.Context, pathID string, leaf string) (pathIDOut string, found bool, err error) { item, found, err := f.findLeafItem(ctx, pathID, leaf) if err != nil { return "", found, err } if !found { return "", false, err } if !item.IsFolder() { return "", false, fs.ErrorIsFile } return f.IDJoin(item.Drivewsid, item.Etag), true, nil } // Features implements fs.Fs. func (f *Fs) Features() *fs.Features { return f.features } // Hashes are not exposed anywhere func (f *Fs) Hashes() hash.Set { return hash.Set(hash.None) } func (f *Fs) purgeCheck(ctx context.Context, dir string, check bool) error { root := path.Join(f.root, dir) if root == "" { return errors.New("can't purge root directory") } directoryID, etag, err := f.FindDir(ctx, dir, false) if err != nil { return err } if check { item, found, err := f.findItem(ctx, dir) if err != nil { return err } if found && item.DirectChildrenCount > 0 { return fs.ErrorDirectoryNotEmpty } } var _ *api.DriveItem var resp *http.Response if err = f.pacer.Call(func() (bool, error) { _, resp, err = f.service.MoveItemToTrashByID(ctx, directoryID, etag, true) return retryResultUnknown(ctx, resp, err) }); err != nil { return err } // flush everything from the left of the dir f.dirCache.FlushDir(dir) return nil } // Purge all files in the directory specified // // Implement this if you have a way of deleting all the files // quicker than just running Remove() on the result of List() // // Return an error if it doesn't exist func (f *Fs) Purge(ctx context.Context, dir string) error { if dir == "" { return fs.ErrorCantPurge } return f.purgeCheck(ctx, dir, false) } func (f *Fs) listAll(ctx context.Context, dirID string) (items []*api.DriveItem, err error) { var item *api.DriveItem var resp *http.Response if err = f.pacer.Call(func() (bool, error) { id, _ := f.parseNormalizedID(dirID) item, resp, err = f.service.GetItemByDriveID(ctx, id, true) return shouldRetry(ctx, resp, err) }); err != nil { return nil, err } items = item.Items for i, item := range items { item.Name = f.opt.Enc.ToStandardName(item.Name) item.Extension = f.opt.Enc.ToStandardName(item.Extension) items[i] = item } return items, nil } // List implements fs.Fs. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { dirRemoteID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { return nil, err } entries = make(fs.DirEntries, 0) items, err := f.listAll(ctx, dirRemoteID) if err != nil { return nil, err } for _, item := range items { id := item.Drivewsid name := item.FullName() remote := path.Join(dir, name) if item.IsFolder() { jid := f.putFolderCache(id, item.Etag, remote) d := fs.NewDir(remote, item.DateModified).SetID(jid).SetSize(item.AssetQuota) entries = append(entries, d) } else { o, err := f.NewObjectFromDriveItem(ctx, remote, item) if err != nil { return nil, err } entries = append(entries, o) } } return entries, nil } // Mkdir implements fs.Fs. func (f *Fs) Mkdir(ctx context.Context, dir string) error { _, _, err := f.FindDir(ctx, dir, true) return err } // Name implements fs.Fs. func (f *Fs) Name() string { return f.name } // Precision implements fs.Fs. func (f *Fs) Precision() time.Duration { return time.Second } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantCopy // //nolint:all func (f *Fs) Copy(ctx context.Context, src fs.Object, remote string) (fs.Object, error) { // ICloud cooy endpoint is broken. Once they fixed it this can be re-enabled. return nil, fs.ErrorCantCopy // note: so many calls its only just faster then a reupload for big files. srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't copy - not same remote type") return nil, fs.ErrorCantCopy } file, pathID, _, err := f.FindPath(ctx, remote, true) if err != nil { return nil, err } var resp *http.Response var info *api.DriveItemRaw // make a copy if err = f.pacer.Call(func() (bool, error) { info, resp, err = f.service.CopyDocByItemID(ctx, srcObj.itemID) return retryResultUnknown(ctx, resp, err) }); err != nil { return nil, err } // renaming in CopyDocByID endpoint does not work :/ so do it the hard way // get new document var doc *api.Document if err = f.pacer.Call(func() (bool, error) { doc, resp, err = f.service.GetDocByItemID(ctx, info.ItemID) return shouldRetry(ctx, resp, err) }); err != nil { return nil, err } // get parentdrive id var dirDoc *api.Document if err = f.pacer.Call(func() (bool, error) { dirDoc, resp, err = f.service.GetDocByItemID(ctx, pathID) return shouldRetry(ctx, resp, err) }); err != nil { return nil, err } // build request // can't use normal rename as file needs to be "activated" first r := api.NewUpdateFileInfo() r.DocumentID = doc.DocumentID r.Path.Path = file r.Path.StartingDocumentID = dirDoc.DocumentID r.Data.Signature = doc.Data.Signature r.Data.ReferenceSignature = doc.Data.ReferenceSignature r.Data.WrappingKey = doc.Data.WrappingKey r.Data.Size = doc.Data.Size r.Mtime = srcObj.modTime.UnixMilli() r.Btime = srcObj.modTime.UnixMilli() var item *api.DriveItem if err = f.pacer.Call(func() (bool, error) { item, resp, err = f.service.UpdateFile(ctx, &r) return retryResultUnknown(ctx, resp, err) }); err != nil { return nil, err } o, err := f.NewObjectFromDriveItem(ctx, remote, item) if err != nil { return nil, err } obj := o.(*Object) // cheat unit tests obj.modTime = srcObj.modTime obj.createdTime = srcObj.createdTime return obj, nil } // Put in to the remote path with the modTime given of the given size // // When called from outside an Fs by rclone, src.Size() will always be >= 0. // But for unknown-sized objects (indicated by src.Size() == -1), Put should either // return an error or upload it properly (rather than e.g. calling panic). // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { size := src.Size() if size < 0 { return nil, errors.New("file size unknown") } existingObj, err := f.NewObject(ctx, src.Remote()) switch err { case nil: // object is found return existingObj, existingObj.Update(ctx, in, src, options...) case fs.ErrorObjectNotFound: // object not found, so we need to create it remote := src.Remote() size := src.Size() modTime := src.ModTime(ctx) obj, err := f.createObject(ctx, remote, modTime, size) if err != nil { return nil, err } return obj, obj.Update(ctx, in, src, options...) default: // real error caught return nil, err } } // DirCacheFlush resets the directory cache - used in testing as an // optional interface func (f *Fs) DirCacheFlush() { f.dirCache.ResetRoot() } // parseNormalizedID parses a normalized ID (may be in the form `driveID#itemID` or just `itemID`) // and returns itemID, driveID, rootURL. // Such a normalized ID can come from (*Item).GetID() // // Parameters: // - rid: the normalized ID to be parsed // // Returns: // - id: the itemID extracted from the normalized ID // - etag: the driveID extracted from the normalized ID, or an empty string if not present func (f *Fs) parseNormalizedID(rid string) (id string, etag string) { split := strings.Split(rid, "#") if len(split) == 1 { return split[0], "" } return split[0], split[1] } // FindPath finds the leaf and directoryID from a normalized path func (f *Fs) FindPath(ctx context.Context, remote string, create bool) (leaf, directoryID, etag string, err error) { leaf, jDirectoryID, err := f.dirCache.FindPath(ctx, remote, create) if err != nil { return "", "", "", err } directoryID, etag = f.parseNormalizedID(jDirectoryID) return leaf, directoryID, etag, nil } // FindDir finds the directory passed in returning the directory ID // starting from pathID func (f *Fs) FindDir(ctx context.Context, path string, create bool) (pathID string, etag string, err error) { jDirectoryID, err := f.dirCache.FindDir(ctx, path, create) if err != nil { return "", "", err } directoryID, etag := f.parseNormalizedID(jDirectoryID) return directoryID, etag, nil } // IDJoin joins the given ID and ETag into a single string with a "#" delimiter. func (f *Fs) IDJoin(id string, etag string) string { if strings.Contains(id, "#") { // already contains an etag, replace id, _ = f.parseNormalizedID(id) } return strings.Join([]string{id, etag}, "#") } func (f *Fs) putFolderCache(id, etag, remote string) string { jid := f.IDJoin(id, etag) f.dirCache.Put(remote, f.IDJoin(id, etag)) return jid } // Rmdir implements fs.Fs. func (f *Fs) Rmdir(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, true) } // Root implements fs.Fs. func (f *Fs) Root() string { return f.opt.Enc.ToStandardPath(f.root) } // String implements fs.Fs. func (f *Fs) String() string { return f.root } // CreateDir makes a directory with pathID as parent and name leaf // // This should be implemented by the backend and will be called by the // dircache package when appropriate. func (f *Fs) CreateDir(ctx context.Context, pathID, leaf string) (string, error) { var item *api.DriveItem var err error var found bool var resp *http.Response if err = f.pacer.Call(func() (bool, error) { id, _ := f.parseNormalizedID(pathID) item, resp, err = f.service.CreateNewFolderByDriveID(ctx, id, f.opt.Enc.FromStandardName(leaf)) // check if it went oke if requestError, ok := err.(*api.RequestError); ok { if requestError.Status == "unknown" { fs.Debugf(requestError, " checking if dir is created with separate call.") time.Sleep(1 * time.Second) // sleep to give icloud time to clear up its mind item, found, err = f.findLeafItem(ctx, pathID, leaf) if err != nil { return false, err } if !found { // lets assume it failed and retry return true, err } // success, clear err err = nil } } return ignoreResultUnknown(ctx, resp, err) }); err != nil { return "", err } return f.IDJoin(item.Drivewsid, item.Etag), err } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } srcID, jsrcDirectoryID, srcLeaf, jdstDirectoryID, dstLeaf, err := f.dirCache.DirMove(ctx, srcFs.dirCache, srcFs.root, srcRemote, f.root, dstRemote) if err != nil { return err } srcDirectoryID, srcEtag := f.parseNormalizedID(jsrcDirectoryID) dstDirectoryID, _ := f.parseNormalizedID(jdstDirectoryID) _, err = f.move(ctx, srcID, srcDirectoryID, srcLeaf, srcEtag, dstDirectoryID, dstLeaf) if err != nil { return err } srcFs.dirCache.FlushDir(srcRemote) return nil } func (f *Fs) move(ctx context.Context, ID, srcDirectoryID, srcLeaf, srcEtag, dstDirectoryID, dstLeaf string) (*api.DriveItem, error) { var resp *http.Response var item *api.DriveItem var err error // move if srcDirectoryID != dstDirectoryID { if err = f.pacer.Call(func() (bool, error) { id, _ := f.parseNormalizedID(ID) item, resp, err = f.service.MoveItemByDriveID(ctx, id, srcEtag, dstDirectoryID, true) return ignoreResultUnknown(ctx, resp, err) }); err != nil { return nil, err } ID = item.Drivewsid srcEtag = item.Etag } // rename if srcLeaf != dstLeaf { if err = f.pacer.Call(func() (bool, error) { id, _ := f.parseNormalizedID(ID) item, resp, err = f.service.RenameItemByDriveID(ctx, id, srcEtag, dstLeaf, true) return ignoreResultUnknown(ctx, resp, err) }); err != nil { return item, err } } return item, err } // Move moves the src object to the specified remote. 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 } srcLeaf, srcDirectoryID, _, err := srcObj.fs.FindPath(ctx, srcObj.remote, true) if err != nil { return nil, err } dstLeaf, dstDirectoryID, _, err := f.FindPath(ctx, remote, true) if err != nil { return nil, err } item, err := f.move(ctx, srcObj.driveID, srcDirectoryID, srcLeaf, srcObj.etag, dstDirectoryID, dstLeaf) if err != nil { return src, err } return f.NewObjectFromDriveItem(ctx, remote, item) } // Creates from the parameters passed in a half finished Object which // must have setMetaData called on it // // Returns the object, leaf, directoryID and error. // // Used to create new objects func (f *Fs) createObject(ctx context.Context, remote string, modTime time.Time, size int64) (o *Object, err error) { // Create the directory for the object if it doesn't exist _, _, _, err = f.FindPath(ctx, remote, true) if err != nil { return } // Temporary Object under construction o = &Object{ fs: f, remote: remote, modTime: modTime, size: size, } return o, nil } // ReadCookies parses the raw cookie string and returns an array of http.Cookie objects. func ReadCookies(raw string) []*http.Cookie { header := http.Header{} header.Add("Cookie", raw) request := http.Request{Header: header} return request.Cookies() } var retryErrorCodes = []int{ 400, // icloud is a mess, sometimes returns 400 on a perfectly fine request. So just retry 408, // Request Timeout 409, // Conflict, retry could fix it. 429, // Rate exceeded. 500, // Get occasional 500 Internal Server Error 502, // Server overload 503, // Service Unavailable 504, // Gateway Time-out } func shouldRetry(ctx context.Context, resp *http.Response, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } return fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(resp, retryErrorCodes), err } func ignoreResultUnknown(ctx context.Context, resp *http.Response, err error) (bool, error) { if requestError, ok := err.(*api.RequestError); ok { if requestError.Status == "unknown" { fs.Debugf(requestError, " ignoring.") return false, nil } } return shouldRetry(ctx, resp, err) } func retryResultUnknown(ctx context.Context, resp *http.Response, err error) (bool, error) { if requestError, ok := err.(*api.RequestError); ok { if requestError.Status == "unknown" { fs.Debugf(requestError, " retrying.") return true, err } } return shouldRetry(ctx, resp, err) } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } if opt.Password != "" { var err error opt.Password, err = obscure.Reveal(opt.Password) if err != nil { return nil, fmt.Errorf("couldn't decrypt user password: %w", err) } } if opt.TrustToken == "" { return nil, fmt.Errorf("missing icloud trust token: try refreshing it with \"rclone config reconnect %s:\"", name) } cookies := ReadCookies(opt.Cookies) callback := func(session *api.Session) { m.Set(configCookies, session.GetCookieString()) } icloud, err := api.New( opt.AppleID, opt.Password, opt.TrustToken, opt.ClientID, cookies, callback, ) if err != nil { return nil, err } if err := icloud.Authenticate(ctx); err != nil { return nil, err } if icloud.Session.Requires2FA() { return nil, errors.New("trust token expired, please reauth") } root = strings.Trim(root, "/") f := &Fs{ name: name, root: root, icloud: icloud, rootID: "FOLDER::com.apple.CloudDocs::root", opt: *opt, pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), } f.features = (&fs.Features{ CanHaveEmptyDirectories: true, PartialUploads: false, }).Fill(ctx, f) rootID := f.rootID f.service, err = icloud.DriveService() if err != nil { return nil, err } f.dirCache = dircache.New( root, rootID, f, ) err = f.dirCache.FindRoot(ctx, false) if err != nil { // Assume it is a file newRoot, remote := dircache.SplitPath(root) tempF := *f tempF.dirCache = dircache.New(newRoot, rootID, &tempF) tempF.root = newRoot // Make new Fs which is the parent err = tempF.dirCache.FindRoot(ctx, false) if err != nil { // No root so return old f return f, nil } _, err := tempF.NewObject(ctx, remote) if err != nil { if err == fs.ErrorObjectNotFound { // File doesn't exist so return old f return f, nil } return nil, err } f.dirCache = tempF.dirCache f.root = tempF.root // return an error with an fs which points to the parent return f, fs.ErrorIsFile } return f, nil } // NewObject creates a new fs.Object from a given remote string. // // ctx: The context.Context for the function. // remote: The remote string representing the object's location. // Returns an fs.Object and an error. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return f.NewObjectFromDriveItem(ctx, remote, nil) } // NewObjectFromDriveItem creates a new fs.Object from a given remote string and DriveItem. // // ctx: The context.Context for the function. // remote: The remote string representing the object's location. // item: The optional DriveItem to use for initializing the Object. If nil, the function will read the metadata from the remote location. // Returns an fs.Object and an error. func (f *Fs) NewObjectFromDriveItem(ctx context.Context, remote string, item *api.DriveItem) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } if item != nil { err := o.setMetaData(item) if err != nil { return nil, err } } else { item, err := f.readMetaData(ctx, remote) if err != nil { return nil, err } err = o.setMetaData(item) if err != nil { return nil, err } } return o, nil } func (f *Fs) readMetaData(ctx context.Context, path string) (item *api.DriveItem, err error) { leaf, ID, _, err := f.FindPath(ctx, path, false) if err != nil { if err == fs.ErrorDirNotFound { return nil, fs.ErrorObjectNotFound } return nil, err } item, found, err := f.findLeafItem(ctx, ID, leaf) if err != nil { return nil, err } if !found { return nil, fs.ErrorObjectNotFound } return item, nil } func (o *Object) setMetaData(item *api.DriveItem) (err error) { if item.IsFolder() { return fs.ErrorIsDir } o.size = item.Size o.modTime = item.DateModified o.createdTime = item.DateCreated o.driveID = item.Drivewsid o.docID = item.Docwsid o.itemID = item.Itemid o.etag = item.Etag o.downloadURL = item.DownloadURL() return nil } // ID returns the ID of the Object if known, or "" if not func (o *Object) ID() string { return o.driveID } // Fs implements fs.Object. func (o *Object) Fs() fs.Info { return o.fs } // Hash implements fs.Object. func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { return "", hash.ErrUnsupported } // ModTime implements fs.Object. func (o *Object) ModTime(context.Context) time.Time { return o.modTime } // Open implements fs.Object. func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { fs.FixRangeOption(options, o.size) // Drive does not support empty files, so we cheat if o.size == 0 { return io.NopCloser(bytes.NewBufferString("")), nil } var resp *http.Response var err error if err = o.fs.pacer.Call(func() (bool, error) { var url string //var doc *api.Document //if o.docID == "" { //doc, resp, err = o.fs.service.GetDocByItemID(ctx, o.itemID) //} // Can not get the download url on a item to work, so do it the hard way. url, _, err = o.fs.service.GetDownloadURLByDriveID(ctx, o.driveID) resp, err = o.fs.service.DownloadFile(ctx, url, options) return shouldRetry(ctx, resp, err) }); err != nil { return nil, err } return resp.Body, err } // Remote implements fs.Object. func (o *Object) Remote() string { return o.remote } // Remove implements fs.Object. func (o *Object) Remove(ctx context.Context) error { if o.itemID == "" { return nil } var resp *http.Response var err error if err = o.fs.pacer.Call(func() (bool, error) { _, resp, err = o.fs.service.MoveItemToTrashByID(ctx, o.driveID, o.etag, true) return retryResultUnknown(ctx, resp, err) }); err != nil { return err } return nil } // SetModTime implements fs.Object. func (o *Object) SetModTime(ctx context.Context, t time.Time) error { return fs.ErrorCantSetModTime } // Size implements fs.Object. func (o *Object) Size() int64 { return o.size } // Storable implements fs.Object. func (o *Object) Storable() bool { return true } // String implements fs.Object. func (o *Object) String() string { if o == nil { return "" } return o.remote } // Update implements fs.Object. func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { size := src.Size() if size < 0 { return errors.New("file size unknown") } remote := o.Remote() modTime := src.ModTime(ctx) leaf, dirID, _, err := o.fs.FindPath(ctx, path.Clean(remote), true) if err != nil { return err } // Move current file to trash if o.driveID != "" { err = o.Remove(ctx) if err != nil { return err } } name := o.fs.opt.Enc.FromStandardName(leaf) var resp *http.Response // Create document var uploadInfo *api.UploadResponse if err = o.fs.pacer.Call(func() (bool, error) { uploadInfo, resp, err = o.fs.service.CreateUpload(ctx, size, name) return ignoreResultUnknown(ctx, resp, err) }); err != nil { return err } // Upload content var upload *api.SingleFileResponse if err = o.fs.pacer.Call(func() (bool, error) { upload, resp, err = o.fs.service.Upload(ctx, in, size, name, uploadInfo.URL) return ignoreResultUnknown(ctx, resp, err) }); err != nil { return err } //var doc *api.Document //if err = o.fs.pacer.Call(func() (bool, error) { // doc, resp, err = o.fs.service.GetDocByItemID(ctx, dirID) // return ignoreResultUnknown(ctx, resp, err) //}); err != nil { // return err //} r := api.NewUpdateFileInfo() r.DocumentID = uploadInfo.DocumentID r.Path.Path = name r.Path.StartingDocumentID = api.GetDocIDFromDriveID(dirID) //r.Path.StartingDocumentID = doc.DocumentID r.Data.Receipt = upload.SingleFile.Receipt r.Data.Signature = upload.SingleFile.Signature r.Data.ReferenceSignature = upload.SingleFile.ReferenceSignature r.Data.WrappingKey = upload.SingleFile.WrappingKey r.Data.Size = upload.SingleFile.Size r.Mtime = modTime.Unix() * 1000 r.Btime = modTime.Unix() * 1000 // Update metadata var item *api.DriveItem if err = o.fs.pacer.Call(func() (bool, error) { item, resp, err = o.fs.service.UpdateFile(ctx, &r) return ignoreResultUnknown(ctx, resp, err) }); err != nil { return err } err = o.setMetaData(item) if err != nil { return err } o.modTime = modTime o.size = src.Size() return nil } // Check interfaces are satisfied var ( _ fs.Fs = &Fs{} _ fs.Mover = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.DirCacheFlusher = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Object = &Object{} _ fs.IDer = (*Object)(nil) ) rclone-v1.71.0/backend/iclouddrive/iclouddrive_test.go000066400000000000000000000005761505210326400230550ustar00rootroot00000000000000//go:build !plan9 && !solaris package iclouddrive_test import ( "testing" "github.com/rclone/rclone/backend/iclouddrive" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestICloudDrive:", NilObject: (*iclouddrive.Object)(nil), }) } rclone-v1.71.0/backend/iclouddrive/iclouddrive_unsupported.go000066400000000000000000000003371505210326400244610ustar00rootroot00000000000000// Build for iclouddrive for unsupported platforms to stop go complaining // about "no buildable Go source files " //go:build plan9 || solaris // Package iclouddrive implements the iCloud Drive backend package iclouddriverclone-v1.71.0/backend/imagekit/000077500000000000000000000000001505210326400164275ustar00rootroot00000000000000rclone-v1.71.0/backend/imagekit/client/000077500000000000000000000000001505210326400177055ustar00rootroot00000000000000rclone-v1.71.0/backend/imagekit/client/client.go000066400000000000000000000031361505210326400215150ustar00rootroot00000000000000// Package client provides a client for interacting with the ImageKit API. package client import ( "context" "fmt" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/lib/rest" ) // ImageKit main struct type ImageKit struct { Prefix string UploadPrefix string Timeout int64 UploadTimeout int64 PrivateKey string PublicKey string URLEndpoint string HTTPClient *rest.Client } // NewParams is a struct to define parameters to imagekit type NewParams struct { PrivateKey string PublicKey string URLEndpoint string } // New returns ImageKit object from environment variables func New(ctx context.Context, params NewParams) (*ImageKit, error) { privateKey := params.PrivateKey publicKey := params.PublicKey endpointURL := params.URLEndpoint switch { case privateKey == "": return nil, fmt.Errorf("ImageKit.io URL endpoint is required") case publicKey == "": return nil, fmt.Errorf("ImageKit.io public key is required") case endpointURL == "": return nil, fmt.Errorf("ImageKit.io private key is required") } cliCtx, cliCfg := fs.AddConfig(ctx) cliCfg.UserAgent = "rclone/imagekit" client := rest.NewClient(fshttp.NewClient(cliCtx)) client.SetUserPass(privateKey, "") client.SetHeader("Accept", "application/json") return &ImageKit{ Prefix: "https://api.imagekit.io/v2", UploadPrefix: "https://upload.imagekit.io/api/v2", Timeout: 60, UploadTimeout: 3600, PrivateKey: params.PrivateKey, PublicKey: params.PublicKey, URLEndpoint: params.URLEndpoint, HTTPClient: client, }, nil } rclone-v1.71.0/backend/imagekit/client/media.go000066400000000000000000000161761505210326400213260ustar00rootroot00000000000000package client import ( "context" "errors" "fmt" "net/http" "net/url" "time" "github.com/rclone/rclone/lib/rest" "gopkg.in/validator.v2" ) // FilesOrFolderParam struct is a parameter type to ListFiles() function to search / list media library files. type FilesOrFolderParam struct { Path string `json:"path,omitempty"` Limit int `json:"limit,omitempty"` Skip int `json:"skip,omitempty"` SearchQuery string `json:"searchQuery,omitempty"` } // AITag represents an AI tag for a media library file. type AITag struct { Name string `json:"name"` Confidence float32 `json:"confidence"` Source string `json:"source"` } // File represents media library File details. type File struct { FileID string `json:"fileId"` Name string `json:"name"` FilePath string `json:"filePath"` Type string `json:"type"` VersionInfo map[string]string `json:"versionInfo"` IsPrivateFile *bool `json:"isPrivateFile"` CustomCoordinates *string `json:"customCoordinates"` URL string `json:"url"` Thumbnail string `json:"thumbnail"` FileType string `json:"fileType"` Mime string `json:"mime"` Height int `json:"height"` Width int `json:"Width"` Size uint64 `json:"size"` HasAlpha bool `json:"hasAlpha"` CustomMetadata map[string]any `json:"customMetadata,omitempty"` EmbeddedMetadata map[string]any `json:"embeddedMetadata"` CreatedAt time.Time `json:"createdAt"` UpdatedAt time.Time `json:"updatedAt"` Tags []string `json:"tags"` AITags []AITag `json:"AITags"` } // Folder represents media library Folder details. type Folder struct { *File FolderPath string `json:"folderPath"` } // CreateFolderParam represents parameter to create folder api type CreateFolderParam struct { FolderName string `validate:"nonzero" json:"folderName"` ParentFolderPath string `validate:"nonzero" json:"parentFolderPath"` } // DeleteFolderParam represents parameter to delete folder api type DeleteFolderParam struct { FolderPath string `validate:"nonzero" json:"folderPath"` } // MoveFolderParam represents parameter to move folder api type MoveFolderParam struct { SourceFolderPath string `validate:"nonzero" json:"sourceFolderPath"` DestinationPath string `validate:"nonzero" json:"destinationPath"` } // JobIDResponse represents response struct with JobID for folder operations type JobIDResponse struct { JobID string `json:"jobId"` } // JobStatus represents response Data to job status api type JobStatus struct { JobID string `json:"jobId"` Type string `json:"type"` Status string `json:"status"` } // File represents media library File details. func (ik *ImageKit) File(ctx context.Context, fileID string) (*http.Response, *File, error) { data := &File{} response, err := ik.HTTPClient.CallJSON(ctx, &rest.Opts{ Method: "GET", Path: fmt.Sprintf("/files/%s/details", fileID), RootURL: ik.Prefix, IgnoreStatus: true, }, nil, data) return response, data, err } // Files retrieves media library files. Filter options can be supplied as FilesOrFolderParam. func (ik *ImageKit) Files(ctx context.Context, params FilesOrFolderParam, includeVersion bool) (*http.Response, *[]File, error) { var SearchQuery = `type = "file"` if includeVersion { SearchQuery = `type IN ["file", "file-version"]` } if params.SearchQuery != "" { SearchQuery = params.SearchQuery } parameters := url.Values{} parameters.Set("skip", fmt.Sprintf("%d", params.Skip)) parameters.Set("limit", fmt.Sprintf("%d", params.Limit)) parameters.Set("path", params.Path) parameters.Set("searchQuery", SearchQuery) data := &[]File{} response, err := ik.HTTPClient.CallJSON(ctx, &rest.Opts{ Method: "GET", Path: "/files", RootURL: ik.Prefix, Parameters: parameters, }, nil, data) return response, data, err } // DeleteFile removes file by FileID from media library func (ik *ImageKit) DeleteFile(ctx context.Context, fileID string) (*http.Response, error) { var err error if fileID == "" { return nil, errors.New("fileID can not be empty") } response, err := ik.HTTPClient.CallJSON(ctx, &rest.Opts{ Method: "DELETE", Path: fmt.Sprintf("/files/%s", fileID), RootURL: ik.Prefix, NoResponse: true, }, nil, nil) return response, err } // Folders retrieves media library files. Filter options can be supplied as FilesOrFolderParam. func (ik *ImageKit) Folders(ctx context.Context, params FilesOrFolderParam) (*http.Response, *[]Folder, error) { var SearchQuery = `type = "folder"` if params.SearchQuery != "" { SearchQuery = params.SearchQuery } parameters := url.Values{} parameters.Set("skip", fmt.Sprintf("%d", params.Skip)) parameters.Set("limit", fmt.Sprintf("%d", params.Limit)) parameters.Set("path", params.Path) parameters.Set("searchQuery", SearchQuery) data := &[]Folder{} resp, err := ik.HTTPClient.CallJSON(ctx, &rest.Opts{ Method: "GET", Path: "/files", RootURL: ik.Prefix, Parameters: parameters, }, nil, data) if err != nil { return resp, data, err } return resp, data, err } // CreateFolder creates a new folder in media library func (ik *ImageKit) CreateFolder(ctx context.Context, param CreateFolderParam) (*http.Response, error) { var err error if err = validator.Validate(¶m); err != nil { return nil, err } response, err := ik.HTTPClient.CallJSON(ctx, &rest.Opts{ Method: "POST", Path: "/folder", RootURL: ik.Prefix, NoResponse: true, }, param, nil) return response, err } // DeleteFolder removes the folder from media library func (ik *ImageKit) DeleteFolder(ctx context.Context, param DeleteFolderParam) (*http.Response, error) { var err error if err = validator.Validate(¶m); err != nil { return nil, err } response, err := ik.HTTPClient.CallJSON(ctx, &rest.Opts{ Method: "DELETE", Path: "/folder", RootURL: ik.Prefix, NoResponse: true, }, param, nil) return response, err } // MoveFolder moves given folder to new path in media library func (ik *ImageKit) MoveFolder(ctx context.Context, param MoveFolderParam) (*http.Response, *JobIDResponse, error) { var err error var response = &JobIDResponse{} if err = validator.Validate(¶m); err != nil { return nil, nil, err } resp, err := ik.HTTPClient.CallJSON(ctx, &rest.Opts{ Method: "PUT", Path: "bulkJobs/moveFolder", RootURL: ik.Prefix, }, param, response) return resp, response, err } // BulkJobStatus retrieves the status of a bulk job by job ID. func (ik *ImageKit) BulkJobStatus(ctx context.Context, jobID string) (*http.Response, *JobStatus, error) { var err error var response = &JobStatus{} if jobID == "" { return nil, nil, errors.New("jobId can not be blank") } resp, err := ik.HTTPClient.CallJSON(ctx, &rest.Opts{ Method: "GET", Path: "bulkJobs/" + jobID, RootURL: ik.Prefix, }, nil, response) return resp, response, err } rclone-v1.71.0/backend/imagekit/client/upload.go000066400000000000000000000050251505210326400215220ustar00rootroot00000000000000package client import ( "context" "errors" "fmt" "io" "net/http" "net/url" "github.com/rclone/rclone/lib/rest" ) // UploadParam defines upload parameters type UploadParam struct { FileName string `json:"fileName"` Folder string `json:"folder,omitempty"` // default value: / Tags string `json:"tags,omitempty"` IsPrivateFile *bool `json:"isPrivateFile,omitempty"` // default: false } // UploadResult defines the response structure for the upload API type UploadResult struct { FileID string `json:"fileId"` Name string `json:"name"` URL string `json:"url"` ThumbnailURL string `json:"thumbnailUrl"` Height int `json:"height"` Width int `json:"Width"` Size uint64 `json:"size"` FilePath string `json:"filePath"` AITags []map[string]any `json:"AITags"` VersionInfo map[string]string `json:"versionInfo"` } // Upload uploads an asset to a imagekit account. // // The asset can be: // - the actual data (io.Reader) // - the Data URI (Base64 encoded), max ~60 MB (62,910,000 chars) // - the remote FTP, HTTP or HTTPS URL address of an existing file // // https://docs.imagekit.io/api-reference/upload-file-api/server-side-file-upload func (ik *ImageKit) Upload(ctx context.Context, file io.Reader, param UploadParam) (*http.Response, *UploadResult, error) { var err error if param.FileName == "" { return nil, nil, errors.New("Upload: Filename is required") } // Initialize URL values formParams := url.Values{} formParams.Add("useUniqueFileName", fmt.Sprint(false)) // Add individual fields to URL values if param.FileName != "" { formParams.Add("fileName", param.FileName) } if param.Tags != "" { formParams.Add("tags", param.Tags) } if param.Folder != "" { formParams.Add("folder", param.Folder) } if param.IsPrivateFile != nil { formParams.Add("isPrivateFile", fmt.Sprintf("%v", *param.IsPrivateFile)) } response := &UploadResult{} formReader, contentType, _, err := rest.MultipartUpload(ctx, file, formParams, "file", param.FileName) if err != nil { return nil, nil, fmt.Errorf("failed to make multipart upload: %w", err) } opts := rest.Opts{ Method: "POST", Path: "/files/upload", RootURL: ik.UploadPrefix, Body: formReader, ContentType: contentType, } resp, err := ik.HTTPClient.CallJSON(ctx, &opts, nil, response) if err != nil { return resp, response, err } return resp, response, err } rclone-v1.71.0/backend/imagekit/client/url.go000066400000000000000000000027731505210326400210470ustar00rootroot00000000000000package client import ( "crypto/hmac" "crypto/sha1" "encoding/hex" "fmt" neturl "net/url" "strconv" "strings" "time" ) // URLParam represents parameters for generating url type URLParam struct { Path string Src string URLEndpoint string Signed bool ExpireSeconds int64 QueryParameters map[string]string } // URL generates url from URLParam func (ik *ImageKit) URL(params URLParam) (string, error) { var resultURL string var url *neturl.URL var err error var endpoint = params.URLEndpoint if endpoint == "" { endpoint = ik.URLEndpoint } endpoint = strings.TrimRight(endpoint, "/") + "/" if params.QueryParameters == nil { params.QueryParameters = make(map[string]string) } if url, err = neturl.Parse(params.Src); err != nil { return "", err } query := url.Query() for k, v := range params.QueryParameters { query.Set(k, v) } url.RawQuery = query.Encode() resultURL = url.String() if params.Signed { now := time.Now().Unix() var expires = strconv.FormatInt(now+params.ExpireSeconds, 10) var path = strings.Replace(resultURL, endpoint, "", 1) path += expires mac := hmac.New(sha1.New, []byte(ik.PrivateKey)) mac.Write([]byte(path)) signature := hex.EncodeToString(mac.Sum(nil)) if strings.Contains(resultURL, "?") { resultURL = resultURL + "&" + fmt.Sprintf("ik-t=%s&ik-s=%s", expires, signature) } else { resultURL = resultURL + "?" + fmt.Sprintf("ik-t=%s&ik-s=%s", expires, signature) } } return resultURL, nil } rclone-v1.71.0/backend/imagekit/imagekit.go000066400000000000000000000503251505210326400205550ustar00rootroot00000000000000// Package imagekit provides an interface to the ImageKit.io media library. package imagekit import ( "context" "errors" "fmt" "io" "math" "net/http" "path" "strconv" "strings" "time" "github.com/rclone/rclone/backend/imagekit/client" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/readers" "github.com/rclone/rclone/lib/version" ) const ( minSleep = 1 * time.Millisecond maxSleep = 100 * time.Millisecond decayConstant = 2 ) var systemMetadataInfo = map[string]fs.MetadataHelp{ "btime": { Help: "Time of file birth (creation) read from Last-Modified header", Type: "RFC 3339", Example: "2006-01-02T15:04:05.999999999Z07:00", ReadOnly: true, }, "size": { Help: "Size of the object in bytes", Type: "int64", ReadOnly: true, }, "file-type": { Help: "Type of the file", Type: "string", Example: "image", ReadOnly: true, }, "height": { Help: "Height of the image or video in pixels", Type: "int", ReadOnly: true, }, "width": { Help: "Width of the image or video in pixels", Type: "int", ReadOnly: true, }, "has-alpha": { Help: "Whether the image has alpha channel or not", Type: "bool", ReadOnly: true, }, "tags": { Help: "Tags associated with the file", Type: "string", Example: "tag1,tag2", ReadOnly: true, }, "google-tags": { Help: "AI generated tags by Google Cloud Vision associated with the image", Type: "string", Example: "tag1,tag2", ReadOnly: true, }, "aws-tags": { Help: "AI generated tags by AWS Rekognition associated with the image", Type: "string", Example: "tag1,tag2", ReadOnly: true, }, "is-private-file": { Help: "Whether the file is private or not", Type: "bool", ReadOnly: true, }, "custom-coordinates": { Help: "Custom coordinates of the file", Type: "string", Example: "0,0,100,100", ReadOnly: true, }, } // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "imagekit", Description: "ImageKit.io", NewFs: NewFs, MetadataInfo: &fs.MetadataInfo{ System: systemMetadataInfo, Help: `Any metadata supported by the underlying remote is read and written.`, }, Options: []fs.Option{ { Name: "endpoint", Help: "You can find your ImageKit.io URL endpoint in your [dashboard](https://imagekit.io/dashboard/developer/api-keys)", Required: true, }, { Name: "public_key", Help: "You can find your ImageKit.io public key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys)", Required: true, Sensitive: true, }, { Name: "private_key", Help: "You can find your ImageKit.io private key in your [dashboard](https://imagekit.io/dashboard/developer/api-keys)", Required: true, Sensitive: true, }, { Name: "only_signed", Help: "If you have configured `Restrict unsigned image URLs` in your dashboard settings, set this to true.", Default: false, Advanced: true, }, { Name: "versions", Help: "Include old versions in directory listings.", Default: false, Advanced: true, }, { Name: "upload_tags", Help: "Tags to add to the uploaded files, e.g. \"tag1,tag2\".", Default: "", Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: (encoder.EncodeZero | encoder.EncodeSlash | encoder.EncodeQuestion | encoder.EncodeHashPercent | encoder.EncodeCtl | encoder.EncodeDel | encoder.EncodeDot | encoder.EncodeDoubleQuote | encoder.EncodePercent | encoder.EncodeBackSlash | encoder.EncodeDollar | encoder.EncodeLtGt | encoder.EncodeSquareBracket | encoder.EncodeInvalidUtf8), }, }, }) } // Options defines the configuration for this backend type Options struct { Endpoint string `config:"endpoint"` PublicKey string `config:"public_key"` PrivateKey string `config:"private_key"` OnlySigned bool `config:"only_signed"` Versions bool `config:"versions"` Enc encoder.MultiEncoder `config:"encoding"` } // Fs represents a remote to ImageKit type Fs struct { name string // name of remote root string // root path opt Options // parsed options features *fs.Features // optional features ik *client.ImageKit // ImageKit client pacer *fs.Pacer // pacer for API calls } // Object describes a ImageKit file type Object struct { fs *Fs // The Fs this object is part of remote string // The remote path filePath string // The path to the file contentType string // The content type of the object if known - may be "" timestamp time.Time // The timestamp of the object if known - may be zero file client.File // The media file if known - may be nil versionID string // If present this points to an object version } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name string, root string, m configmap.Mapper) (fs.Fs, error) { opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } ik, err := client.New(ctx, client.NewParams{ URLEndpoint: opt.Endpoint, PublicKey: opt.PublicKey, PrivateKey: opt.PrivateKey, }) if err != nil { return nil, err } f := &Fs{ name: name, opt: *opt, ik: ik, pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), } f.root = path.Join("/", root) f.features = (&fs.Features{ CaseInsensitive: false, DuplicateFiles: false, ReadMimeType: true, WriteMimeType: false, CanHaveEmptyDirectories: true, BucketBased: false, ServerSideAcrossConfigs: false, IsLocal: false, SlowHash: true, ReadMetadata: true, WriteMetadata: false, UserMetadata: false, FilterAware: true, PartialUploads: false, NoMultiThreading: false, }).Fill(ctx, f) if f.root != "/" { r := f.root folderPath := f.EncodePath(r[:strings.LastIndex(r, "/")+1]) fileName := f.EncodeFileName(r[strings.LastIndex(r, "/")+1:]) file := f.getFileByName(ctx, folderPath, fileName) if file != nil { newRoot := path.Dir(f.root) f.root = newRoot return f, fs.ErrorIsFile } } return f, nil } // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return strings.TrimLeft(f.root, "/") } // String returns a description of the FS func (f *Fs) String() string { return fmt.Sprintf("FS imagekit: %s", f.root) } // Precision of the ModTimes in this Fs func (f *Fs) Precision() time.Duration { return fs.ModTimeNotSupported } // Hashes returns the supported hash types of the filesystem. func (f *Fs) Hashes() hash.Set { return hash.NewHashSet() } // Features returns the optional features of this Fs. func (f *Fs) Features() *fs.Features { return f.features } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { remote := path.Join(f.root, dir) remote = f.EncodePath(remote) if remote != "/" { parentFolderPath, folderName := path.Split(remote) folderExists, err := f.getFolderByName(ctx, parentFolderPath, folderName) if err != nil { return make(fs.DirEntries, 0), err } if folderExists == nil { return make(fs.DirEntries, 0), fs.ErrorDirNotFound } } folders, folderError := f.getFolders(ctx, remote) if folderError != nil { return make(fs.DirEntries, 0), folderError } files, fileError := f.getFiles(ctx, remote, f.opt.Versions) if fileError != nil { return make(fs.DirEntries, 0), fileError } res := make([]fs.DirEntry, 0, len(folders)+len(files)) for _, folder := range folders { folderPath := f.DecodePath(strings.TrimLeft(strings.Replace(folder.FolderPath, f.EncodePath(f.root), "", 1), "/")) res = append(res, fs.NewDir(folderPath, folder.UpdatedAt)) } for _, file := range files { res = append(res, f.newObject(ctx, remote, file)) } return res, nil } func (f *Fs) newObject(ctx context.Context, remote string, file client.File) *Object { remoteFile := strings.TrimLeft(strings.Replace(file.FilePath, f.EncodePath(f.root), "", 1), "/") folderPath, fileName := path.Split(remoteFile) folderPath = f.DecodePath(folderPath) fileName = f.DecodeFileName(fileName) remoteFile = path.Join(folderPath, fileName) if file.Type == "file-version" { remoteFile = version.Add(remoteFile, file.UpdatedAt) return &Object{ fs: f, remote: remoteFile, filePath: file.FilePath, contentType: file.Mime, timestamp: file.UpdatedAt, file: file, versionID: file.VersionInfo["id"], } } return &Object{ fs: f, remote: remoteFile, filePath: file.FilePath, contentType: file.Mime, timestamp: file.UpdatedAt, file: file, } } // NewObject finds the Object at remote. If it can't be found // it returns the error ErrorObjectNotFound. // // If remote points to a directory then it should return // ErrorIsDir if possible without doing any extra work, // otherwise ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { r := path.Join(f.root, remote) folderPath, fileName := path.Split(r) folderPath = f.EncodePath(folderPath) fileName = f.EncodeFileName(fileName) isFolder, err := f.getFolderByName(ctx, folderPath, fileName) if err != nil { return nil, err } if isFolder != nil { return nil, fs.ErrorIsDir } file := f.getFileByName(ctx, folderPath, fileName) if file == nil { return nil, fs.ErrorObjectNotFound } return f.newObject(ctx, r, *file), nil } // Put in to the remote path with the modTime given of the given size // // When called from outside an Fs by rclone, src.Size() will always be >= 0. // But for unknown-sized objects (indicated by src.Size() == -1), Put should either // return an error or upload it properly (rather than e.g. calling panic). // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { if src.Size() == 0 { return nil, fs.ErrorCantUploadEmptyFiles } return uploadFile(ctx, f, in, src.Remote(), options...) } // Mkdir makes the directory (container, bucket) // // Shouldn't return an error if it already exists func (f *Fs) Mkdir(ctx context.Context, dir string) (err error) { remote := path.Join(f.root, dir) parentFolderPath, folderName := path.Split(remote) parentFolderPath = f.EncodePath(parentFolderPath) folderName = f.EncodeFileName(folderName) err = f.pacer.Call(func() (bool, error) { var res *http.Response res, err = f.ik.CreateFolder(ctx, client.CreateFolderParam{ ParentFolderPath: parentFolderPath, FolderName: folderName, }) return f.shouldRetry(ctx, res, err) }) return err } // Rmdir removes the directory (container, bucket) if empty // // Return an error if it doesn't exist or isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) (err error) { entries, err := f.List(ctx, dir) if err != nil { return err } if len(entries) > 0 { return errors.New("directory is not empty") } err = f.pacer.Call(func() (bool, error) { var res *http.Response res, err = f.ik.DeleteFolder(ctx, client.DeleteFolderParam{ FolderPath: f.EncodePath(path.Join(f.root, dir)), }) if res.StatusCode == http.StatusNotFound { return false, fs.ErrorDirNotFound } return f.shouldRetry(ctx, res, err) }) return err } // Purge deletes all the files and the container // // Optional interface: Only implement this if you have a way of // deleting all the files quicker than just running Remove() on the // result of List() func (f *Fs) Purge(ctx context.Context, dir string) (err error) { remote := path.Join(f.root, dir) err = f.pacer.Call(func() (bool, error) { var res *http.Response res, err = f.ik.DeleteFolder(ctx, client.DeleteFolderParam{ FolderPath: f.EncodePath(remote), }) if res.StatusCode == http.StatusNotFound { return false, fs.ErrorDirNotFound } return f.shouldRetry(ctx, res, err) }) return err } // PublicLink generates a public link to the remote path (usually readable by anyone) func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (string, error) { duration := time.Duration(math.Abs(float64(expire))) expireSeconds := duration.Seconds() fileRemote := path.Join(f.root, remote) folderPath, fileName := path.Split(fileRemote) folderPath = f.EncodePath(folderPath) fileName = f.EncodeFileName(fileName) file := f.getFileByName(ctx, folderPath, fileName) if file == nil { return "", fs.ErrorObjectNotFound } // Pacer not needed as this doesn't use the API url, err := f.ik.URL(client.URLParam{ Src: file.URL, Signed: *file.IsPrivateFile || f.opt.OnlySigned, ExpireSeconds: int64(expireSeconds), QueryParameters: map[string]string{ "updatedAt": file.UpdatedAt.String(), }, }) if err != nil { return "", err } return url, nil } // Fs returns read only access to the Fs that this object is part of func (o *Object) Fs() fs.Info { return o.fs } // Hash returns the selected checksum of the file // If no checksum is available it returns "" func (o *Object) Hash(ctx context.Context, ty hash.Type) (string, error) { return "", hash.ErrUnsupported } // Storable says whether this object can be stored func (o *Object) Storable() bool { return true } // String returns a description of the Object func (o *Object) String() string { if o == nil { return "" } return o.file.Name } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // ModTime returns the modification date of the file // It should return a best guess if one isn't available func (o *Object) ModTime(context.Context) time.Time { return o.file.UpdatedAt } // Size returns the size of the file func (o *Object) Size() int64 { return int64(o.file.Size) } // MimeType returns the MIME type of the file func (o *Object) MimeType(context.Context) string { return o.contentType } // Open opens the file for read. Call Close() on the returned io.ReadCloser func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { // Offset and Count for range download var offset int64 var count int64 fs.FixRangeOption(options, -1) partialContent := false for _, option := range options { switch x := option.(type) { case *fs.RangeOption: offset, count = x.Decode(-1) partialContent = true case *fs.SeekOption: offset = x.Offset partialContent = true default: if option.Mandatory() { fs.Logf(o, "Unsupported mandatory option: %v", option) } } } // Pacer not needed as this doesn't use the API url, err := o.fs.ik.URL(client.URLParam{ Src: o.file.URL, Signed: *o.file.IsPrivateFile || o.fs.opt.OnlySigned, QueryParameters: map[string]string{ "tr": "orig-true", "updatedAt": o.file.UpdatedAt.String(), }, }) if err != nil { return nil, err } client := &http.Client{} req, _ := http.NewRequest("GET", url, nil) req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", offset, offset+count-1)) resp, err := client.Do(req) if err != nil { return nil, err } end := resp.ContentLength if partialContent && resp.StatusCode == http.StatusOK { skip := offset if offset < 0 { skip = end + offset + 1 } _, err = io.CopyN(io.Discard, resp.Body, skip) if err != nil { if resp != nil { _ = resp.Body.Close() } return nil, err } return readers.NewLimitedReadCloser(resp.Body, end-skip), nil } return resp.Body, nil } // Update in to the object with the modTime given of the given size // // When called from outside an Fs by rclone, src.Size() will always be >= 0. // But for unknown-sized objects (indicated by src.Size() == -1), Upload should either // return an error or update the object properly (rather than e.g. calling panic). func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { if src.Size() == 0 { return fs.ErrorCantUploadEmptyFiles } srcRemote := o.Remote() remote := path.Join(o.fs.root, srcRemote) folderPath, fileName := path.Split(remote) UseUniqueFileName := new(bool) *UseUniqueFileName = false var resp *client.UploadResult err = o.fs.pacer.CallNoRetry(func() (bool, error) { var res *http.Response res, resp, err = o.fs.ik.Upload(ctx, in, client.UploadParam{ FileName: fileName, Folder: folderPath, IsPrivateFile: o.file.IsPrivateFile, }) return o.fs.shouldRetry(ctx, res, err) }) if err != nil { return err } fileID := resp.FileID _, file, err := o.fs.ik.File(ctx, fileID) if err != nil { return err } o.file = *file return nil } // Remove this object func (o *Object) Remove(ctx context.Context) (err error) { err = o.fs.pacer.Call(func() (bool, error) { var res *http.Response res, err = o.fs.ik.DeleteFile(ctx, o.file.FileID) return o.fs.shouldRetry(ctx, res, err) }) return err } // SetModTime sets the metadata on the object to set the modification date func (o *Object) SetModTime(ctx context.Context, t time.Time) error { return fs.ErrorCantSetModTime } func uploadFile(ctx context.Context, f *Fs, in io.Reader, srcRemote string, options ...fs.OpenOption) (fs.Object, error) { remote := path.Join(f.root, srcRemote) folderPath, fileName := path.Split(remote) folderPath = f.EncodePath(folderPath) fileName = f.EncodeFileName(fileName) UseUniqueFileName := new(bool) *UseUniqueFileName = false err := f.pacer.CallNoRetry(func() (bool, error) { var res *http.Response var err error res, _, err = f.ik.Upload(ctx, in, client.UploadParam{ FileName: fileName, Folder: folderPath, IsPrivateFile: &f.opt.OnlySigned, }) return f.shouldRetry(ctx, res, err) }) if err != nil { return nil, err } return f.NewObject(ctx, srcRemote) } // Metadata returns the metadata for the object func (o *Object) Metadata(ctx context.Context) (metadata fs.Metadata, err error) { metadata.Set("btime", o.file.CreatedAt.Format(time.RFC3339)) metadata.Set("size", strconv.FormatUint(o.file.Size, 10)) metadata.Set("file-type", o.file.FileType) metadata.Set("height", strconv.Itoa(o.file.Height)) metadata.Set("width", strconv.Itoa(o.file.Width)) metadata.Set("has-alpha", strconv.FormatBool(o.file.HasAlpha)) for k, v := range o.file.EmbeddedMetadata { metadata.Set(k, fmt.Sprint(v)) } if o.file.Tags != nil { metadata.Set("tags", strings.Join(o.file.Tags, ",")) } if o.file.CustomCoordinates != nil { metadata.Set("custom-coordinates", *o.file.CustomCoordinates) } if o.file.IsPrivateFile != nil { metadata.Set("is-private-file", strconv.FormatBool(*o.file.IsPrivateFile)) } if o.file.AITags != nil { googleTags := []string{} awsTags := []string{} for _, tag := range o.file.AITags { if tag.Source == "google-auto-tagging" { googleTags = append(googleTags, tag.Name) } else if tag.Source == "aws-auto-tagging" { awsTags = append(awsTags, tag.Name) } } if len(googleTags) > 0 { metadata.Set("google-tags", strings.Join(googleTags, ",")) } if len(awsTags) > 0 { metadata.Set("aws-tags", strings.Join(awsTags, ",")) } } return metadata, nil } // Check the interfaces are satisfied. var ( _ fs.Fs = &Fs{} _ fs.Purger = &Fs{} _ fs.PublicLinker = &Fs{} _ fs.Object = &Object{} ) rclone-v1.71.0/backend/imagekit/imagekit_test.go000066400000000000000000000005111505210326400216040ustar00rootroot00000000000000package imagekit import ( "testing" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" ) func TestIntegration(t *testing.T) { debug := true fstest.Verbose = &debug fstests.Run(t, &fstests.Opt{ RemoteName: "TestImageKit:", NilObject: (*Object)(nil), SkipFsCheckWrap: true, }) } rclone-v1.71.0/backend/imagekit/util.go000066400000000000000000000104431505210326400177350ustar00rootroot00000000000000package imagekit import ( "context" "fmt" "net/http" "slices" "strconv" "time" "github.com/rclone/rclone/backend/imagekit/client" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/lib/pacer" ) func (f *Fs) getFiles(ctx context.Context, path string, includeVersions bool) (files []client.File, err error) { files = make([]client.File, 0) var hasMore = true for hasMore { err = f.pacer.Call(func() (bool, error) { var data *[]client.File var res *http.Response res, data, err = f.ik.Files(ctx, client.FilesOrFolderParam{ Skip: len(files), Limit: 100, Path: path, }, includeVersions) hasMore = !(len(*data) == 0 || len(*data) < 100) if len(*data) > 0 { files = append(files, *data...) } return f.shouldRetry(ctx, res, err) }) } if err != nil { return make([]client.File, 0), err } return files, nil } func (f *Fs) getFolders(ctx context.Context, path string) (folders []client.Folder, err error) { folders = make([]client.Folder, 0) var hasMore = true for hasMore { err = f.pacer.Call(func() (bool, error) { var data *[]client.Folder var res *http.Response res, data, err = f.ik.Folders(ctx, client.FilesOrFolderParam{ Skip: len(folders), Limit: 100, Path: path, }) hasMore = !(len(*data) == 0 || len(*data) < 100) if len(*data) > 0 { folders = append(folders, *data...) } return f.shouldRetry(ctx, res, err) }) } if err != nil { return make([]client.Folder, 0), err } return folders, nil } func (f *Fs) getFileByName(ctx context.Context, path string, name string) (file *client.File) { err := f.pacer.Call(func() (bool, error) { res, data, err := f.ik.Files(ctx, client.FilesOrFolderParam{ Limit: 1, Path: path, SearchQuery: fmt.Sprintf(`type = "file" AND name = %s`, strconv.Quote(name)), }, false) if len(*data) == 0 { file = nil } else { file = &(*data)[0] } return f.shouldRetry(ctx, res, err) }) if err != nil { return nil } return file } func (f *Fs) getFolderByName(ctx context.Context, path string, name string) (folder *client.Folder, err error) { err = f.pacer.Call(func() (bool, error) { res, data, err := f.ik.Folders(ctx, client.FilesOrFolderParam{ Limit: 1, Path: path, SearchQuery: fmt.Sprintf(`type = "folder" AND name = %s`, strconv.Quote(name)), }) if len(*data) == 0 { folder = nil } else { folder = &(*data)[0] } return f.shouldRetry(ctx, res, err) }) if err != nil { return nil, err } return folder, nil } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 401, // Unauthorized (e.g. "Token has expired") 408, // Request Timeout 429, // Rate exceeded. 500, // Get occasional 500 Internal Server Error 503, // Service Unavailable 504, // Gateway Time-out } func shouldRetryHTTP(resp *http.Response, retryErrorCodes []int) bool { if resp == nil { return false } return slices.Contains(retryErrorCodes, resp.StatusCode) } func (f *Fs) shouldRetry(ctx context.Context, resp *http.Response, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } if resp != nil && (resp.StatusCode == 429 || resp.StatusCode == 503) { var retryAfter = 1 retryAfterString := resp.Header.Get("X-RateLimit-Reset") if retryAfterString != "" { var err error retryAfter, err = strconv.Atoi(retryAfterString) if err != nil { fs.Errorf(f, "Malformed %s header %q: %v", "X-RateLimit-Reset", retryAfterString, err) } } return true, pacer.RetryAfterError(err, time.Duration(retryAfter)*time.Millisecond) } return fserrors.ShouldRetry(err) || shouldRetryHTTP(resp, retryErrorCodes), err } // EncodePath encapsulates the logic for encoding a path func (f *Fs) EncodePath(str string) string { return f.opt.Enc.FromStandardPath(str) } // DecodePath encapsulates the logic for decoding a path func (f *Fs) DecodePath(str string) string { return f.opt.Enc.ToStandardPath(str) } // EncodeFileName encapsulates the logic for encoding a file name func (f *Fs) EncodeFileName(str string) string { return f.opt.Enc.FromStandardName(str) } // DecodeFileName encapsulates the logic for decoding a file name func (f *Fs) DecodeFileName(str string) string { return f.opt.Enc.ToStandardName(str) } rclone-v1.71.0/backend/internetarchive/000077500000000000000000000000001505210326400200275ustar00rootroot00000000000000rclone-v1.71.0/backend/internetarchive/internetarchive.go000066400000000000000000001121151505210326400235510ustar00rootroot00000000000000// Package internetarchive provides an interface to Internet Archive's Item // via their native API than using S3-compatible endpoints. package internetarchive import ( "bytes" "context" "encoding/json" "errors" "fmt" "io" "net/http" "net/url" "path" "regexp" "slices" "strconv" "strings" "time" "github.com/ncw/swift/v2" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/bucket" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/random" "github.com/rclone/rclone/lib/rest" ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "internetarchive", Description: "Internet Archive", NewFs: NewFs, MetadataInfo: &fs.MetadataInfo{ System: map[string]fs.MetadataHelp{ "name": { Help: "Full file path, without the bucket part", Type: "filename", Example: "backend/internetarchive/internetarchive.go", ReadOnly: true, }, "source": { Help: "The source of the file", Type: "string", Example: "original", ReadOnly: true, }, "mtime": { Help: "Time of last modification, managed by Rclone", Type: "RFC 3339", Example: "2006-01-02T15:04:05.999999999Z", ReadOnly: true, }, "size": { Help: "File size in bytes", Type: "decimal number", Example: "123456", ReadOnly: true, }, "md5": { Help: "MD5 hash calculated by Internet Archive", Type: "string", Example: "01234567012345670123456701234567", ReadOnly: true, }, "crc32": { Help: "CRC32 calculated by Internet Archive", Type: "string", Example: "01234567", ReadOnly: true, }, "sha1": { Help: "SHA1 hash calculated by Internet Archive", Type: "string", Example: "0123456701234567012345670123456701234567", ReadOnly: true, }, "format": { Help: "Name of format identified by Internet Archive", Type: "string", Example: "Comma-Separated Values", ReadOnly: true, }, "old_version": { Help: "Whether the file was replaced and moved by keep-old-version flag", Type: "boolean", Example: "true", ReadOnly: true, }, "viruscheck": { Help: "The last time viruscheck process was run for the file (?)", Type: "unixtime", Example: "1654191352", ReadOnly: true, }, "summation": { Help: "Check https://forum.rclone.org/t/31922 for how it is used", Type: "string", Example: "md5", ReadOnly: true, }, "rclone-ia-mtime": { Help: "Time of last modification, managed by Internet Archive", Type: "RFC 3339", Example: "2006-01-02T15:04:05.999999999Z", }, "rclone-mtime": { Help: "Time of last modification, managed by Rclone", Type: "RFC 3339", Example: "2006-01-02T15:04:05.999999999Z", }, "rclone-update-track": { Help: "Random value used by Rclone for tracking changes inside Internet Archive", Type: "string", Example: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", }, }, Help: `Metadata fields provided by Internet Archive. If there are multiple values for a key, only the first one is returned. This is a limitation of Rclone, that supports one value per one key. Owner is able to add custom keys. Metadata feature grabs all the keys including them. `, }, Options: []fs.Option{{ Name: "access_key_id", Help: "IAS3 Access Key.\n\nLeave blank for anonymous access.\nYou can find one here: https://archive.org/account/s3.php", Sensitive: true, }, { Name: "secret_access_key", Help: "IAS3 Secret Key (password).\n\nLeave blank for anonymous access.", Sensitive: true, }, { // their official client (https://github.com/jjjake/internetarchive) hardcodes following the two Name: "endpoint", Help: "IAS3 Endpoint.\n\nLeave blank for default value.", Default: "https://s3.us.archive.org", Advanced: true, }, { Name: "front_endpoint", Help: "Host of InternetArchive Frontend.\n\nLeave blank for default value.", Default: "https://archive.org", Advanced: true, }, { Name: "item_metadata", Help: `Metadata to be set on the IA item, this is different from file-level metadata that can be set using --metadata-set. Format is key=value and the 'x-archive-meta-' prefix is automatically added.`, Default: []string{}, Hide: fs.OptionHideConfigurator, Advanced: true, }, { Name: "item_derive", Help: `Whether to trigger derive on the IA item or not. If set to false, the item will not be derived by IA upon upload. The derive process produces a number of secondary files from an upload to make an upload more usable on the web. Setting this to false is useful for uploading files that are already in a format that IA can display or reduce burden on IA's infrastructure.`, Default: true, }, { Name: "disable_checksum", Help: `Don't ask the server to test against MD5 checksum calculated by rclone. Normally rclone will calculate the MD5 checksum of the input before uploading it so it can ask the server to check the object against checksum. This is great for data integrity checking but can cause long delays for large files to start uploading.`, Default: true, Advanced: true, }, { Name: "wait_archive", Help: `Timeout for waiting the server's processing tasks (specifically archive and book_op) to finish. Only enable if you need to be guaranteed to be reflected after write operations. 0 to disable waiting. No errors to be thrown in case of timeout.`, Default: fs.Duration(0), Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: encoder.EncodeZero | encoder.EncodeSlash | encoder.EncodeLtGt | encoder.EncodeCrLf | encoder.EncodeDel | encoder.EncodeCtl | encoder.EncodeInvalidUtf8 | encoder.EncodeDot, }, }}) } // maximum size of an item. this is constant across all items const iaItemMaxSize int64 = 1099511627776 // metadata keys that are not writeable var roMetadataKey = map[string]any{ // do not add mtime here, it's a documented exception "name": nil, "source": nil, "size": nil, "md5": nil, "crc32": nil, "sha1": nil, "format": nil, "old_version": nil, "viruscheck": nil, "summation": nil, } // Options defines the configuration for this backend type Options struct { AccessKeyID string `config:"access_key_id"` SecretAccessKey string `config:"secret_access_key"` Endpoint string `config:"endpoint"` FrontEndpoint string `config:"front_endpoint"` DisableChecksum bool `config:"disable_checksum"` ItemMetadata []string `config:"item_metadata"` ItemDerive bool `config:"item_derive"` WaitArchive fs.Duration `config:"wait_archive"` Enc encoder.MultiEncoder `config:"encoding"` } // Fs represents an IAS3 remote type Fs struct { name string // name of this remote root string // the path we are working on if any opt Options // parsed config options features *fs.Features // optional features srv *rest.Client // the connection to IAS3 front *rest.Client // the connection to frontend pacer *fs.Pacer // pacer for API calls ctx context.Context } // Object describes a file at IA type Object struct { fs *Fs // reference to Fs remote string // the remote path modTime time.Time // last modified time size int64 // size of the file in bytes md5 string // md5 hash of the file presented by the server sha1 string // sha1 hash of the file presented by the server crc32 string // crc32 of the file presented by the server rawData json.RawMessage } // IAFile represents a subset of object in MetadataResponse.Files type IAFile struct { Name string `json:"name"` // Source string `json:"source"` Mtime string `json:"mtime"` RcloneMtime json.RawMessage `json:"rclone-mtime"` UpdateTrack json.RawMessage `json:"rclone-update-track"` Size string `json:"size"` Md5 string `json:"md5"` Crc32 string `json:"crc32"` Sha1 string `json:"sha1"` Summation string `json:"summation"` rawData json.RawMessage } // MetadataResponse represents subset of the JSON object returned by (frontend)/metadata/ type MetadataResponse struct { Files []IAFile `json:"files"` ItemSize int64 `json:"item_size"` } // MetadataResponseRaw is the form of MetadataResponse to deal with metadata type MetadataResponseRaw struct { Files []json.RawMessage `json:"files"` ItemSize int64 `json:"item_size"` } // ModMetadataResponse represents response for amending metadata type ModMetadataResponse struct { // https://archive.org/services/docs/api/md-write.html#example Success bool `json:"success"` Error string `json:"error"` } // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { bucket, file := f.split("") if bucket == "" { return "Internet Archive root" } if file == "" { return fmt.Sprintf("Internet Archive item %s", bucket) } return fmt.Sprintf("Internet Archive item %s path %s", bucket, file) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // Hashes returns type of hashes supported by IA func (f *Fs) Hashes() hash.Set { return hash.NewHashSet(hash.MD5, hash.SHA1, hash.CRC32) } // Precision returns the precision of mtime that the server responds func (f *Fs) Precision() time.Duration { if f.opt.WaitArchive == 0 { return fs.ModTimeNotSupported } return time.Nanosecond } // retryErrorCodes is a slice of error codes that we will retry // See: https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html var retryErrorCodes = []int{ 429, // Too Many Requests 500, // Internal Server Error - "We encountered an internal error. Please try again." 503, // Service Unavailable/Slow Down - "Reduce your request rate" } // NewFs constructs an Fs from the path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } // Parse the endpoints ep, err := url.Parse(opt.Endpoint) if err != nil { return nil, err } fe, err := url.Parse(opt.FrontEndpoint) if err != nil { return nil, err } root = strings.Trim(root, "/") f := &Fs{ name: name, opt: *opt, ctx: ctx, } f.setRoot(root) f.features = (&fs.Features{ BucketBased: true, ReadMetadata: true, WriteMetadata: true, UserMetadata: true, }).Fill(ctx, f) f.srv = rest.NewClient(fshttp.NewClient(ctx)) f.srv.SetRoot(ep.String()) f.front = rest.NewClient(fshttp.NewClient(ctx)) f.front.SetRoot(fe.String()) if opt.AccessKeyID != "" && opt.SecretAccessKey != "" { auth := fmt.Sprintf("LOW %s:%s", opt.AccessKeyID, opt.SecretAccessKey) f.srv.SetHeader("Authorization", auth) f.front.SetHeader("Authorization", auth) } f.pacer = fs.NewPacer(ctx, pacer.NewS3(pacer.MinSleep(10*time.Millisecond))) // test if the root exists as a file _, err = f.NewObject(ctx, "/") if err == nil { f.setRoot(betterPathDir(root)) return f, fs.ErrorIsFile } return f, nil } // setRoot changes the root of the Fs func (f *Fs) setRoot(root string) { f.root = strings.Trim(root, "/") } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // ModTime is the last modified time (read-only) func (o *Object) ModTime(ctx context.Context) time.Time { return o.modTime } // Size is the file length func (o *Object) Size() int64 { return o.size } // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Hash returns the hash value presented by IA func (o *Object) Hash(ctx context.Context, ty hash.Type) (string, error) { if ty == hash.MD5 { return o.md5, nil } if ty == hash.SHA1 { return o.sha1, nil } if ty == hash.CRC32 { return o.crc32, nil } return "", hash.ErrUnsupported } // Storable returns if this object is storable func (o *Object) Storable() bool { return true } // SetModTime sets modTime on a particular file func (o *Object) SetModTime(ctx context.Context, t time.Time) (err error) { bucket, reqDir := o.split() if bucket == "" { return fs.ErrorCantSetModTime } if reqDir == "" { return fs.ErrorCantSetModTime } // https://archive.org/services/docs/api/md-write.html // the following code might be useful for modifying metadata of an uploaded file patch := []map[string]string{ // we should drop it first to clear all rclone-provided mtimes { "op": "remove", "path": "/rclone-mtime", }, { "op": "add", "path": "/rclone-mtime", "value": t.Format(time.RFC3339Nano), }} res, err := json.Marshal(patch) if err != nil { return err } params := url.Values{} params.Add("-target", fmt.Sprintf("files/%s", reqDir)) params.Add("-patch", string(res)) body := []byte(params.Encode()) bodyLen := int64(len(body)) var resp *http.Response var result ModMetadataResponse // make a POST request to (frontend)/metadata/:item/ opts := rest.Opts{ Method: "POST", Path: path.Join("/metadata/", bucket), Body: bytes.NewReader(body), ContentLength: &bodyLen, ContentType: "application/x-www-form-urlencoded", } err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.front.CallJSON(ctx, &opts, nil, &result) return o.fs.shouldRetry(resp, err) }) if err != nil { return err } if result.Success { o.modTime = t return nil } return errors.New(result.Error) } // List files and directories in a directory func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { bucket, reqDir := f.split(dir) if bucket == "" { if reqDir != "" { return nil, fs.ErrorListBucketRequired } return entries, nil } grandparent := f.opt.Enc.ToStandardPath(strings.Trim(path.Join(bucket, reqDir), "/") + "/") allEntries, err := f.listAllUnconstrained(ctx, bucket) if err != nil { return entries, err } for _, ent := range allEntries { obj, ok := ent.(*Object) if ok && strings.HasPrefix(obj.remote, grandparent) { path := trimPathPrefix(obj.remote, grandparent, f.opt.Enc) if !strings.Contains(path, "/") { obj.remote = trimPathPrefix(obj.remote, f.root, f.opt.Enc) entries = append(entries, obj) } } dire, ok := ent.(*fs.Dir) if ok && strings.HasPrefix(dire.Remote(), grandparent) { path := trimPathPrefix(dire.Remote(), grandparent, f.opt.Enc) if !strings.Contains(path, "/") { dire.SetRemote(trimPathPrefix(dire.Remote(), f.root, f.opt.Enc)) entries = append(entries, dire) } } } return entries, nil } // Mkdir can't be performed on IA like git repositories func (f *Fs) Mkdir(ctx context.Context, dir string) (err error) { return nil } // Rmdir as well, unless we're asked for recursive deletion func (f *Fs) Rmdir(ctx context.Context, dir string) error { return nil } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (ret fs.Object, err error) { bucket, filepath := f.split(remote) filepath = strings.Trim(filepath, "/") if bucket == "" { if filepath != "" { return nil, fs.ErrorListBucketRequired } return nil, fs.ErrorIsDir } grandparent := f.opt.Enc.ToStandardPath(strings.Trim(path.Join(bucket, filepath), "/")) allEntries, err := f.listAllUnconstrained(ctx, bucket) if err != nil { return nil, err } for _, ent := range allEntries { obj, ok := ent.(*Object) if ok && obj.remote == grandparent { obj.remote = trimPathPrefix(obj.remote, f.root, f.opt.Enc) return obj, nil } } return nil, fs.ErrorObjectNotFound } // Put uploads a file func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { o := &Object{ fs: f, remote: src.Remote(), modTime: src.ModTime(ctx), size: src.Size(), } err := o.Update(ctx, in, src, options...) if err == nil { return o, nil } return nil, err } // PublicLink generates a public link to the remote path (usually readable by anyone) func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (link string, err error) { if strings.HasSuffix(remote, "/") { return "", fs.ErrorCantShareDirectories } if _, err := f.NewObject(ctx, remote); err != nil { return "", err } bucket, bucketPath := f.split(remote) return path.Join(f.opt.FrontEndpoint, "/download/", bucket, quotePath(bucketPath)), nil } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (_ fs.Object, err error) { dstBucket, dstPath := f.split(remote) srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't copy - not same remote type") return nil, fs.ErrorCantCopy } srcBucket, srcPath := srcObj.split() if dstBucket == srcBucket && dstPath == srcPath { // https://github.com/jjjake/internetarchive/blob/2456376533251df9d05e0a14d796ec1ced4959f5/internetarchive/cli/ia_copy.py#L68 fs.Debugf(src, "Can't copy - the source and destination files cannot be the same!") return nil, fs.ErrorCantCopy } updateTracker := random.String(32) headers := map[string]string{ "x-archive-auto-make-bucket": "1", "x-archive-queue-derive": "0", "x-archive-keep-old-version": "0", "x-amz-copy-source": quotePath(path.Join("/", srcBucket, srcPath)), "x-amz-metadata-directive": "COPY", "x-archive-filemeta-sha1": srcObj.sha1, "x-archive-filemeta-md5": srcObj.md5, "x-archive-filemeta-crc32": srcObj.crc32, "x-archive-filemeta-size": fmt.Sprint(srcObj.size), // add this too for sure "x-archive-filemeta-rclone-mtime": srcObj.modTime.Format(time.RFC3339Nano), "x-archive-filemeta-rclone-update-track": updateTracker, } // make a PUT request at (IAS3)/:item/:path without body var resp *http.Response opts := rest.Opts{ Method: "PUT", Path: "/" + url.PathEscape(path.Join(dstBucket, dstPath)), ExtraHeaders: headers, } err = f.pacer.Call(func() (bool, error) { resp, err = f.srv.Call(ctx, &opts) return f.shouldRetry(resp, err) }) if err != nil { return nil, err } // we can't update/find metadata here as IA will also // queue server-side copy as well as upload/delete. return f.waitFileUpload(ctx, trimPathPrefix(path.Join(dstBucket, dstPath), f.root, f.opt.Enc), updateTracker, srcObj.size) } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively than doing a directory traversal. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { var allEntries, entries fs.DirEntries bucket, reqDir := f.split(dir) if bucket == "" { if reqDir != "" { return fs.ErrorListBucketRequired } return callback(entries) } grandparent := f.opt.Enc.ToStandardPath(strings.Trim(path.Join(bucket, reqDir), "/") + "/") allEntries, err = f.listAllUnconstrained(ctx, bucket) if err != nil { return err } for _, ent := range allEntries { obj, ok := ent.(*Object) if ok && strings.HasPrefix(obj.remote, grandparent) { obj.remote = trimPathPrefix(obj.remote, f.root, f.opt.Enc) entries = append(entries, obj) } dire, ok := ent.(*fs.Dir) if ok && strings.HasPrefix(dire.Remote(), grandparent) { dire.SetRemote(trimPathPrefix(dire.Remote(), f.root, f.opt.Enc)) entries = append(entries, dire) } } return callback(entries) } // CleanUp removes all files inside history/ func (f *Fs) CleanUp(ctx context.Context) (err error) { bucket, _ := f.split("/") if bucket == "" { return fs.ErrorListBucketRequired } entries, err := f.listAllUnconstrained(ctx, bucket) if err != nil { return err } for _, ent := range entries { obj, ok := ent.(*Object) if ok && strings.HasPrefix(obj.remote, bucket+"/history/") { err = obj.Remove(ctx) if err != nil { return err } } // we can fully ignore directories, as they're just virtual entries to // comply with rclone's requirement } return nil } // About returns things about remaining and used spaces func (f *Fs) About(ctx context.Context) (_ *fs.Usage, err error) { bucket, _ := f.split("/") if bucket == "" { return nil, fs.ErrorListBucketRequired } result, err := f.requestMetadata(ctx, bucket) if err != nil { return nil, err } // perform low-level operation here since it's ridiculous to make 2 same requests var historySize int64 for _, ent := range result.Files { if strings.HasPrefix(ent.Name, "history/") { size := parseSize(ent.Size) if size < 0 { // parse error can be ignored since it's not fatal continue } historySize += size } } usage := &fs.Usage{ Total: fs.NewUsageValue(iaItemMaxSize), Free: fs.NewUsageValue(iaItemMaxSize - result.ItemSize), Used: fs.NewUsageValue(result.ItemSize), Trashed: fs.NewUsageValue(historySize), // bytes in trash } return usage, nil } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { var optionsFixed []fs.OpenOption for _, opt := range options { if optRange, ok := opt.(*fs.RangeOption); ok { // Ignore range option if file is empty if o.Size() == 0 && optRange.Start == 0 && optRange.End > 0 { continue } } optionsFixed = append(optionsFixed, opt) } var resp *http.Response // make a GET request to (frontend)/download/:item/:path opts := rest.Opts{ Method: "GET", Path: path.Join("/download/", o.fs.root, quotePath(o.fs.opt.Enc.FromStandardPath(o.remote))), Options: optionsFixed, } err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.front.Call(ctx, &opts) return o.fs.shouldRetry(resp, err) }) if err != nil { return nil, err } return resp.Body, nil } // Update the Object from in with modTime and size func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { bucket, bucketPath := o.split() modTime := src.ModTime(ctx) size := src.Size() updateTracker := random.String(32) // Set the mtime in the metadata // internetarchive backend builds at header level as IAS3 has extension outside X-Amz- headers := map[string]string{ // https://github.com/jjjake/internetarchive/blob/2456376533251df9d05e0a14d796ec1ced4959f5/internetarchive/iarequest.py#L158 "x-amz-filemeta-rclone-mtime": modTime.Format(time.RFC3339Nano), "x-amz-filemeta-rclone-update-track": updateTracker, // we add some more headers for intuitive actions "x-amz-auto-make-bucket": "1", // create an item if does not exist, do nothing if already "x-archive-auto-make-bucket": "1", // same as above in IAS3 original way "x-archive-keep-old-version": "0", // do not keep old versions (a.k.a. trashes in other clouds) "x-archive-cascade-delete": "1", // enable "cascate delete" (delete all derived files in addition to the file itself) } if size >= 0 { headers["Content-Length"] = fmt.Sprintf("%d", size) headers["x-archive-size-hint"] = fmt.Sprintf("%d", size) } // This is IA's ITEM metadata, not file metadata headers, err = o.appendItemMetadataHeaders(headers, o.fs.opt) if err != nil { return err } var mdata fs.Metadata mdata, err = fs.GetMetadataOptions(ctx, o.fs, src, options) if err == nil && mdata != nil { for mk, mv := range mdata { mk = strings.ToLower(mk) if strings.HasPrefix(mk, "rclone-") { fs.LogPrintf(fs.LogLevelWarning, o, "reserved metadata key %s is about to set", mk) } else if _, ok := roMetadataKey[mk]; ok { fs.LogPrintf(fs.LogLevelWarning, o, "setting or modifying read-only key %s is requested, skipping", mk) continue } else if mk == "mtime" { // redirect to make it work mk = "rclone-mtime" } headers[fmt.Sprintf("x-amz-filemeta-%s", mk)] = mv } } // read the md5sum if available var md5sumHex string if !o.fs.opt.DisableChecksum { md5sumHex, err = src.Hash(ctx, hash.MD5) if err == nil && matchMd5.MatchString(md5sumHex) { // Set the md5sum in header on the object if // the user wants it // https://github.com/jjjake/internetarchive/blob/245637653/internetarchive/item.py#L969 headers["Content-MD5"] = md5sumHex } } // make a PUT request at (IAS3)/encoded(:item/:path) var resp *http.Response opts := rest.Opts{ Method: "PUT", Path: "/" + url.PathEscape(path.Join(bucket, bucketPath)), Body: in, ContentLength: &size, ExtraHeaders: headers, } err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.Call(ctx, &opts) return o.fs.shouldRetry(resp, err) }) // we can't update/find metadata here as IA will "ingest" uploaded file(s) // upon uploads. (you can find its progress at https://archive.org/history/ItemNameHere ) // or we have to wait for finish? (needs polling (frontend)/metadata/:item or scraping (frontend)/history/:item) var newObj *Object if err == nil { newObj, err = o.fs.waitFileUpload(ctx, o.remote, updateTracker, size) } else { newObj = &Object{} } o.crc32 = newObj.crc32 o.md5 = newObj.md5 o.sha1 = newObj.sha1 o.modTime = newObj.modTime o.size = newObj.size return err } func (o *Object) appendItemMetadataHeaders(headers map[string]string, options Options) (newHeaders map[string]string, err error) { metadataCounter := make(map[string]int) metadataValues := make(map[string][]string) // First pass: count occurrences and collect values for _, v := range options.ItemMetadata { parts := strings.SplitN(v, "=", 2) if len(parts) != 2 { return newHeaders, errors.New("item metadata key=value should be in the form key=value") } key, value := parts[0], parts[1] metadataCounter[key]++ metadataValues[key] = append(metadataValues[key], value) } // Second pass: add headers with appropriate prefixes for key, count := range metadataCounter { if count == 1 { // Only one occurrence, use x-archive-meta- headers[fmt.Sprintf("x-archive-meta-%s", key)] = metadataValues[key][0] } else { // Multiple occurrences, use x-archive-meta01-, x-archive-meta02-, etc. for i, value := range metadataValues[key] { headers[fmt.Sprintf("x-archive-meta%02d-%s", i+1, key)] = value } } } if o.fs.opt.ItemDerive { headers["x-archive-queue-derive"] = "1" } else { headers["x-archive-queue-derive"] = "0" } fs.Debugf(o, "Setting IA item derive: %t", o.fs.opt.ItemDerive) for k, v := range headers { if strings.HasPrefix(k, "x-archive-meta") { fs.Debugf(o, "Setting IA item metadata: %s=%s", k, v) } } return headers, nil } // Remove an object func (o *Object) Remove(ctx context.Context) (err error) { bucket, bucketPath := o.split() // make a DELETE request at (IAS3)/:item/:path var resp *http.Response opts := rest.Opts{ Method: "DELETE", Path: "/" + url.PathEscape(path.Join(bucket, bucketPath)), } err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.srv.Call(ctx, &opts) return o.fs.shouldRetry(resp, err) }) // deleting files can take bit longer as // it'll be processed on same queue as uploads if err == nil { err = o.fs.waitDelete(ctx, bucket, bucketPath) } return err } // String converts this Fs to a string func (o *Object) String() string { if o == nil { return "" } return o.remote } // Metadata returns all file metadata provided by Internet Archive func (o *Object) Metadata(ctx context.Context) (m fs.Metadata, err error) { if o.rawData == nil { return nil, nil } raw := make(map[string]json.RawMessage) err = json.Unmarshal(o.rawData, &raw) if err != nil { // fatal: json parsing failed return } for k, v := range raw { items, err := listOrString(v) if len(items) == 0 || err != nil { // skip: an entry failed to parse continue } m.Set(k, items[0]) } // move the old mtime to an another key if v, ok := m["mtime"]; ok { m["rclone-ia-mtime"] = v } // overwrite with a correct mtime m["mtime"] = o.modTime.Format(time.RFC3339Nano) return } func (f *Fs) shouldRetry(resp *http.Response, err error) (bool, error) { if resp != nil { if slices.Contains(retryErrorCodes, resp.StatusCode) { return true, err } } // Ok, not an awserr, check for generic failure conditions return fserrors.ShouldRetry(err), err } var matchMd5 = regexp.MustCompile(`^[0-9a-f]{32}$`) // split returns bucket and bucketPath from the rootRelativePath // relative to f.root func (f *Fs) split(rootRelativePath string) (bucketName, bucketPath string) { bucketName, bucketPath = bucket.Split(path.Join(f.root, rootRelativePath)) return f.opt.Enc.FromStandardName(bucketName), f.opt.Enc.FromStandardPath(bucketPath) } // split returns bucket and bucketPath from the object func (o *Object) split() (bucket, bucketPath string) { return o.fs.split(o.remote) } func (f *Fs) requestMetadata(ctx context.Context, bucket string) (result *MetadataResponse, err error) { var resp *http.Response // make a GET request to (frontend)/metadata/:item/ opts := rest.Opts{ Method: "GET", Path: path.Join("/metadata/", bucket), } var temp MetadataResponseRaw err = f.pacer.Call(func() (bool, error) { resp, err = f.front.CallJSON(ctx, &opts, nil, &temp) return f.shouldRetry(resp, err) }) if err != nil { return } return temp.unraw() } // list up all files/directories without any filters func (f *Fs) listAllUnconstrained(ctx context.Context, bucket string) (entries fs.DirEntries, err error) { result, err := f.requestMetadata(ctx, bucket) if err != nil { return nil, err } knownDirs := map[string]time.Time{ "": time.Unix(0, 0), } for _, file := range result.Files { dir := strings.Trim(betterPathDir(file.Name), "/") nameWithBucket := path.Join(bucket, file.Name) mtimeTime := file.parseMtime() // populate children directories child := dir for { if _, ok := knownDirs[child]; ok { break } // directory d := fs.NewDir(f.opt.Enc.ToStandardPath(path.Join(bucket, child)), mtimeTime) entries = append(entries, d) knownDirs[child] = mtimeTime child = strings.Trim(betterPathDir(child), "/") } if _, ok := knownDirs[betterPathDir(file.Name)]; !ok { continue } size := parseSize(file.Size) o := makeValidObject(f, f.opt.Enc.ToStandardPath(nameWithBucket), file, mtimeTime, size) entries = append(entries, o) } return entries, nil } func (f *Fs) waitFileUpload(ctx context.Context, reqPath, tracker string, newSize int64) (ret *Object, err error) { bucket, bucketPath := f.split(reqPath) ret = &Object{ fs: f, remote: trimPathPrefix(path.Join(bucket, bucketPath), f.root, f.opt.Enc), modTime: time.Unix(0, 0), size: -1, } if f.opt.WaitArchive == 0 { // user doesn't want to poll, let's not ret2, err := f.NewObject(ctx, reqPath) if err == nil { ret2, ok := ret2.(*Object) if ok { ret = ret2 ret.crc32 = "" ret.md5 = "" ret.sha1 = "" ret.size = -1 } } return ret, nil } retC := make(chan struct { *Object error }, 1) go func() { isFirstTime := true existed := false for { if !isFirstTime { // depending on the queue, it takes time time.Sleep(10 * time.Second) } metadata, err := f.requestMetadata(ctx, bucket) if err != nil { retC <- struct { *Object error }{ret, err} return } var iaFile *IAFile for _, f := range metadata.Files { if f.Name == bucketPath { iaFile = &f break } } if isFirstTime { isFirstTime = false existed = iaFile != nil } if iaFile == nil { continue } if !existed && !isFirstTime { // fast path: file wasn't exited before retC <- struct { *Object error }{makeValidObject2(f, *iaFile, bucket), nil} return } fileTrackers, _ := listOrString(iaFile.UpdateTrack) trackerMatch := slices.Contains(fileTrackers, tracker) if !trackerMatch { continue } if !compareSize(parseSize(iaFile.Size), newSize) { continue } // voila! retC <- struct { *Object error }{makeValidObject2(f, *iaFile, bucket), nil} return } }() select { case res := <-retC: return res.Object, res.error case <-time.After(time.Duration(f.opt.WaitArchive)): return ret, nil } } func (f *Fs) waitDelete(ctx context.Context, bucket, bucketPath string) (err error) { if f.opt.WaitArchive == 0 { // user doesn't want to poll, let's not return nil } retC := make(chan error, 1) go func() { for { metadata, err := f.requestMetadata(ctx, bucket) if err != nil { retC <- err return } found := false for _, f := range metadata.Files { if f.Name == bucketPath { found = true break } } if !found { retC <- nil return } // depending on the queue, it takes time time.Sleep(10 * time.Second) } }() select { case res := <-retC: return res case <-time.After(time.Duration(f.opt.WaitArchive)): return nil } } func makeValidObject(f *Fs, remote string, file IAFile, mtime time.Time, size int64) *Object { ret := &Object{ fs: f, remote: remote, modTime: mtime, size: size, rawData: file.rawData, } // hashes from _files.xml (where summation != "") is different from one in other files // https://forum.rclone.org/t/internet-archive-md5-tag-in-id-files-xml-interpreted-incorrectly/31922 if file.Summation == "" { ret.md5 = file.Md5 ret.crc32 = file.Crc32 ret.sha1 = file.Sha1 } return ret } func makeValidObject2(f *Fs, file IAFile, bucket string) *Object { mtimeTime := file.parseMtime() size := parseSize(file.Size) return makeValidObject(f, trimPathPrefix(path.Join(bucket, file.Name), f.root, f.opt.Enc), file, mtimeTime, size) } func listOrString(jm json.RawMessage) (rmArray []string, err error) { // rclone-metadata can be an array or string // try to deserialize it as array first err = json.Unmarshal(jm, &rmArray) if err != nil { // if not, it's a string dst := new(string) err = json.Unmarshal(jm, dst) if err == nil { rmArray = []string{*dst} } } return } func (file IAFile) parseMtime() (mtime time.Time) { // method 1: use metadata added by rclone rmArray, err := listOrString(file.RcloneMtime) // let's take the first value we can deserialize for _, value := range rmArray { mtime, err = time.Parse(time.RFC3339Nano, value) if err == nil { break } } if err != nil { // method 2: use metadata added by IAS3 mtime, err = swift.FloatStringToTime(file.Mtime) } if err != nil { // metadata files don't have some of the fields mtime = time.Unix(0, 0) } return mtime } func (mrr *MetadataResponseRaw) unraw() (_ *MetadataResponse, err error) { var files []IAFile for _, raw := range mrr.Files { var parsed IAFile err = json.Unmarshal(raw, &parsed) if err != nil { return nil, err } parsed.rawData = raw files = append(files, parsed) } return &MetadataResponse{ Files: files, ItemSize: mrr.ItemSize, }, nil } func compareSize(a, b int64) bool { if a < 0 || b < 0 { // we won't compare if any of them is not known return true } return a == b } func parseSize(str string) int64 { size, err := strconv.ParseInt(str, 10, 64) if err != nil { size = -1 } return size } func betterPathDir(p string) string { d := path.Dir(p) if d == "." { return "" } return d } func betterPathClean(p string) string { d := path.Clean(p) if d == "." { return "" } return d } func trimPathPrefix(s, prefix string, enc encoder.MultiEncoder) string { // we need to clean the paths to make tests pass! s = betterPathClean(s) prefix = betterPathClean(prefix) if s == prefix || s == prefix+"/" { return "" } prefix = enc.ToStandardPath(strings.TrimRight(prefix, "/")) return enc.ToStandardPath(strings.TrimPrefix(s, prefix+"/")) } // mimics urllib.parse.quote() on Python; exclude / from url.PathEscape func quotePath(s string) string { seg := strings.Split(s, "/") newValues := []string{} for _, v := range seg { newValues = append(newValues, url.QueryEscape(v)) } return strings.Join(newValues, "/") } var ( _ fs.Fs = &Fs{} _ fs.Copier = &Fs{} _ fs.ListRer = &Fs{} _ fs.CleanUpper = &Fs{} _ fs.PublicLinker = &Fs{} _ fs.Abouter = &Fs{} _ fs.Object = &Object{} _ fs.Metadataer = &Object{} ) rclone-v1.71.0/backend/internetarchive/internetarchive_test.go000066400000000000000000000006411505210326400246100ustar00rootroot00000000000000// Test internetarchive filesystem interface package internetarchive_test import ( "testing" "github.com/rclone/rclone/backend/internetarchive" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestIA:lesmi-rclone-test/", NilObject: (*internetarchive.Object)(nil), }) } rclone-v1.71.0/backend/jottacloud/000077500000000000000000000000001505210326400170055ustar00rootroot00000000000000rclone-v1.71.0/backend/jottacloud/api/000077500000000000000000000000001505210326400175565ustar00rootroot00000000000000rclone-v1.71.0/backend/jottacloud/api/types.go000066400000000000000000000353201505210326400212540ustar00rootroot00000000000000// Package api provides types used by the Jottacloud API. package api import ( "encoding/xml" "errors" "fmt" "time" ) const ( // default time format historically used for all request and responses. // Similar to time.RFC3339, but with an extra '-' in front of 'T', // and no ':' separator in timezone offset. Some newer endpoints have // moved to proper time.RFC3339 conformant format instead. jottaTimeFormat = "2006-01-02-T15:04:05Z0700" ) // unmarshalXML turns XML into a Time func unmarshalXMLTime(d *xml.Decoder, start xml.StartElement, timeFormat string) (time.Time, error) { var v string if err := d.DecodeElement(&v, &start); err != nil { return time.Time{}, err } if v == "" { return time.Time{}, nil } newTime, err := time.Parse(timeFormat, v) if err == nil { return newTime, nil } return time.Time{}, err } // JottaTime represents time values in the classic API using a custom RFC3339 like format type JottaTime time.Time // String returns JottaTime string in Jottacloud classic format func (t JottaTime) String() string { return time.Time(t).Format(jottaTimeFormat) } // UnmarshalXML turns XML into a JottaTime func (t *JottaTime) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { tm, err := unmarshalXMLTime(d, start, jottaTimeFormat) *t = JottaTime(tm) return err } // MarshalXML turns a JottaTime into XML func (t *JottaTime) MarshalXML(e *xml.Encoder, start xml.StartElement) error { return e.EncodeElement(t.String(), start) } // Rfc3339Time represents time values in the newer APIs using standard RFC3339 format type Rfc3339Time time.Time // String returns Rfc3339Time string in Jottacloud RFC3339 format func (t Rfc3339Time) String() string { return time.Time(t).Format(time.RFC3339) } // UnmarshalXML turns XML into a Rfc3339Time func (t *Rfc3339Time) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { tm, err := unmarshalXMLTime(d, start, time.RFC3339) *t = Rfc3339Time(tm) return err } // MarshalXML turns a Rfc3339Time into XML func (t *Rfc3339Time) MarshalXML(e *xml.Encoder, start xml.StartElement) error { return e.EncodeElement(t.String(), start) } // MarshalJSON turns a Rfc3339Time into JSON func (t *Rfc3339Time) MarshalJSON() ([]byte, error) { return fmt.Appendf(nil, "\"%s\"", t.String()), nil } // LoginToken is struct representing the login token generated in the WebUI type LoginToken struct { Username string `json:"username"` Realm string `json:"realm"` WellKnownLink string `json:"well_known_link"` AuthToken string `json:"auth_token"` } // WellKnown contains some configuration parameters for setting up endpoints type WellKnown struct { Issuer string `json:"issuer"` AuthorizationEndpoint string `json:"authorization_endpoint"` TokenEndpoint string `json:"token_endpoint"` TokenIntrospectionEndpoint string `json:"token_introspection_endpoint"` UserinfoEndpoint string `json:"userinfo_endpoint"` EndSessionEndpoint string `json:"end_session_endpoint"` JwksURI string `json:"jwks_uri"` CheckSessionIframe string `json:"check_session_iframe"` GrantTypesSupported []string `json:"grant_types_supported"` ResponseTypesSupported []string `json:"response_types_supported"` SubjectTypesSupported []string `json:"subject_types_supported"` IDTokenSigningAlgValuesSupported []string `json:"id_token_signing_alg_values_supported"` UserinfoSigningAlgValuesSupported []string `json:"userinfo_signing_alg_values_supported"` RequestObjectSigningAlgValuesSupported []string `json:"request_object_signing_alg_values_supported"` ResponseNodesSupported []string `json:"response_modes_supported"` RegistrationEndpoint string `json:"registration_endpoint"` TokenEndpointAuthMethodsSupported []string `json:"token_endpoint_auth_methods_supported"` TokenEndpointAuthSigningAlgValuesSupported []string `json:"token_endpoint_auth_signing_alg_values_supported"` ClaimsSupported []string `json:"claims_supported"` ClaimTypesSupported []string `json:"claim_types_supported"` ClaimsParameterSupported bool `json:"claims_parameter_supported"` ScopesSupported []string `json:"scopes_supported"` RequestParameterSupported bool `json:"request_parameter_supported"` RequestURIParameterSupported bool `json:"request_uri_parameter_supported"` CodeChallengeMethodsSupported []string `json:"code_challenge_methods_supported"` TLSClientCertificateBoundAccessTokens bool `json:"tls_client_certificate_bound_access_tokens"` IntrospectionEndpoint string `json:"introspection_endpoint"` } // TokenJSON is the struct representing the HTTP response from OAuth2 // providers returning a token in JSON form. type TokenJSON struct { AccessToken string `json:"access_token"` ExpiresIn int32 `json:"expires_in"` // at least PayPal returns string, while most return number RefreshExpiresIn int32 `json:"refresh_expires_in"` RefreshToken string `json:"refresh_token"` TokenType string `json:"token_type"` IDToken string `json:"id_token"` NotBeforePolicy int32 `json:"not-before-policy"` SessionState string `json:"session_state"` Scope string `json:"scope"` } // JSON structures returned by new API // AllocateFileRequest to prepare an upload to Jottacloud type AllocateFileRequest struct { Bytes int64 `json:"bytes"` Created string `json:"created"` Md5 string `json:"md5"` Modified string `json:"modified"` Path string `json:"path"` } // AllocateFileResponse for upload requests type AllocateFileResponse struct { Name string `json:"name"` Path string `json:"path"` State string `json:"state"` UploadID string `json:"upload_id"` UploadURL string `json:"upload_url"` Bytes int64 `json:"bytes"` ResumePos int64 `json:"resume_pos"` } // UploadResponse after an upload type UploadResponse struct { Path string `json:"path"` ContentID string `json:"content_id"` Bytes int64 `json:"bytes"` Md5 string `json:"md5"` Modified int64 `json:"modified"` } // DeviceRegistrationResponse is the response to registering a device type DeviceRegistrationResponse struct { ClientID string `json:"client_id"` ClientSecret string `json:"client_secret"` } // CustomerInfo provides general information about the account. Required for finding the correct internal username. type CustomerInfo struct { Username string `json:"username"` Email string `json:"email"` Name string `json:"name"` CountryCode string `json:"country_code"` LanguageCode string `json:"language_code"` CustomerGroupCode string `json:"customer_group_code"` BrandCode string `json:"brand_code"` AccountType string `json:"account_type"` SubscriptionType string `json:"subscription_type"` Usage int64 `json:"usage"` Quota int64 `json:"quota"` BusinessUsage int64 `json:"business_usage"` BusinessQuota int64 `json:"business_quota"` WriteLocked bool `json:"write_locked"` ReadLocked bool `json:"read_locked"` LockedCause any `json:"locked_cause"` WebHash string `json:"web_hash"` AndroidHash string `json:"android_hash"` IOSHash string `json:"ios_hash"` } // TrashResponse is returned when emptying the Trash type TrashResponse struct { Folders int64 `json:"folders"` Files int64 `json:"files"` } // XML structures returned by the old API // Flag is a hacky type for checking if an attribute is present type Flag bool // UnmarshalXMLAttr sets Flag to true if the attribute is present func (f *Flag) UnmarshalXMLAttr(attr xml.Attr) error { *f = true return nil } // MarshalXMLAttr : Do not use func (f *Flag) MarshalXMLAttr(name xml.Name) (xml.Attr, error) { attr := xml.Attr{ Name: name, Value: "false", } return attr, errors.New("unimplemented") } /* GET http://www.jottacloud.com/JFS/ 12qh1wsht8cssxdtwl15rqh9 free false 5368709120 -1 -1 0 false false false true true Jotta Jotta JOTTA 5c458d01-9eaf-4f23-8d3c-2486fd9704d8 0 2018-07-15-T22:04:59Z */ // DriveInfo represents a Jottacloud account type DriveInfo struct { Username string `xml:"username"` AccountType string `xml:"account-type"` Locked bool `xml:"locked"` Capacity int64 `xml:"capacity"` MaxDevices int `xml:"max-devices"` MaxMobileDevices int `xml:"max-mobile-devices"` Usage int64 `xml:"usage"` ReadLocked bool `xml:"read-locked"` WriteLocked bool `xml:"write-locked"` QuotaWriteLocked bool `xml:"quota-write-locked"` EnableSync bool `xml:"enable-sync"` EnableFolderShare bool `xml:"enable-foldershare"` Devices []JottaDevice `xml:"devices>device"` } /* GET http://www.jottacloud.com/JFS// Jotta Jotta JOTTA 5c458d01-9eaf-4f23-8d3c-2486fd9704d8 0 2018-07-15-T22:04:59Z 12qh1wsht8cssxdtwl15rqh9 Archive 0 2018-07-15-T22:04:59Z Shared 0 Sync 0 */ // JottaDevice represents a Jottacloud Device type JottaDevice struct { Name string `xml:"name"` DisplayName string `xml:"display_name"` Type string `xml:"type"` Sid string `xml:"sid"` Size int64 `xml:"size"` User string `xml:"user"` MountPoints []JottaMountPoint `xml:"mountPoints>mountPoint"` } /* GET http://www.jottacloud.com/JFS/// Sync /12qh1wsht8cssxdtwl15rqh9/Jotta /12qh1wsht8cssxdtwl15rqh9/Jotta 0 Jotta 12qh1wsht8cssxdtwl15rqh9 */ // JottaMountPoint represents a Jottacloud mountpoint type JottaMountPoint struct { Name string `xml:"name"` Size int64 `xml:"size"` Device string `xml:"device"` Folders []JottaFolder `xml:"folders>folder"` Files []JottaFile `xml:"files>file"` } /* GET http://www.jottacloud.com/JFS//// /12qh1wsht8cssxdtwl15rqh9/Jotta/Sync /12qh1wsht8cssxdtwl15rqh9/Jotta/Sync c 1 COMPLETED 2018-07-05-T15:08:02Z 2018-07-05-T15:08:02Z application/octet-stream 30827730 1e8a7b728ab678048df00075c9507158 2018-07-24-T20:41:10Z */ // JottaFolder represents a JottacloudFolder type JottaFolder struct { XMLName xml.Name Name string `xml:"name,attr"` Deleted Flag `xml:"deleted,attr"` Path string `xml:"path"` CreatedAt JottaTime `xml:"created"` ModifiedAt JottaTime `xml:"modified"` Updated JottaTime `xml:"updated"` Folders []JottaFolder `xml:"folders>folder"` Files []JottaFile `xml:"files>file"` } /* GET http://www.jottacloud.com/JFS////.../ 1 COMPLETED 2018-07-05-T15:08:02Z 2018-07-05-T15:08:02Z application/octet-stream 30827730 1e8a7b728ab678048df00075c9507158 2018-07-24-T20:41:10Z */ // JottaFile represents a Jottacloud file type JottaFile struct { XMLName xml.Name Name string `xml:"name,attr"` Deleted Flag `xml:"deleted,attr"` PublicURI string `xml:"publicURI"` PublicSharePath string `xml:"publicSharePath"` State string `xml:"currentRevision>state"` CreatedAt JottaTime `xml:"currentRevision>created"` ModifiedAt JottaTime `xml:"currentRevision>modified"` UpdatedAt JottaTime `xml:"currentRevision>updated"` Size int64 `xml:"currentRevision>size"` MimeType string `xml:"currentRevision>mime"` MD5 string `xml:"currentRevision>md5"` } // Error is a custom Error for wrapping Jottacloud error responses type Error struct { StatusCode int `xml:"code"` Message string `xml:"message"` Reason string `xml:"reason"` Cause string `xml:"cause"` } // Error returns a string for the error and satisfies the error interface func (e *Error) Error() string { out := fmt.Sprintf("error %d", e.StatusCode) if e.Message != "" { out += ": " + e.Message } if e.Reason != "" { out += fmt.Sprintf(" (%+v)", e.Reason) } return out } rclone-v1.71.0/backend/jottacloud/api/types_test.go000066400000000000000000000012651505210326400223140ustar00rootroot00000000000000package api import ( "encoding/xml" "testing" "time" ) func TestMountpointEmptyModificationTime(t *testing.T) { mountpoint := ` Sync /foo/Jotta /foo/Jotta 0 Jotta foo ` var jf JottaFolder if err := xml.Unmarshal([]byte(mountpoint), &jf); err != nil { t.Fatal(err) } if !time.Time(jf.ModifiedAt).IsZero() { t.Errorf("got non-zero time, want zero") } } rclone-v1.71.0/backend/jottacloud/jottacloud.go000066400000000000000000002020161505210326400215050ustar00rootroot00000000000000// Package jottacloud provides an interface to the Jottacloud storage system. package jottacloud import ( "bytes" "context" "crypto/md5" "encoding/base64" "encoding/hex" "encoding/json" "encoding/xml" "errors" "fmt" "io" "math/rand" "net/http" "net/url" "os" "path" "strconv" "strings" "time" "github.com/rclone/rclone/backend/jottacloud/api" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/oauthutil" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/rest" "golang.org/x/oauth2" ) // Globals const ( minSleep = 10 * time.Millisecond maxSleep = 2 * time.Second decayConstant = 2 // bigger for slower decay, exponential defaultDevice = "Jotta" defaultMountpoint = "Archive" jfsURL = "https://jfs.jottacloud.com/jfs/" apiURL = "https://api.jottacloud.com/" wwwURL = "https://www.jottacloud.com/" cachePrefix = "rclone-jcmd5-" configDevice = "device" configMountpoint = "mountpoint" configTokenURL = "tokenURL" configClientID = "client_id" configClientSecret = "client_secret" configUsername = "username" configVersion = 1 defaultTokenURL = "https://id.jottacloud.com/auth/realms/jottacloud/protocol/openid-connect/token" defaultClientID = "jottacli" legacyTokenURL = "https://api.jottacloud.com/auth/v1/token" legacyRegisterURL = "https://api.jottacloud.com/auth/v1/register" legacyClientID = "nibfk8biu12ju7hpqomr8b1e40" legacyEncryptedClientSecret = "Vp8eAv7eVElMnQwN-kgU9cbhgApNDaMqWdlDi5qFydlQoji4JBxrGMF2" legacyConfigVersion = 0 teliaseCloudTokenURL = "https://cloud-auth.telia.se/auth/realms/telia_se/protocol/openid-connect/token" teliaseCloudAuthURL = "https://cloud-auth.telia.se/auth/realms/telia_se/protocol/openid-connect/auth" teliaseCloudClientID = "desktop" telianoCloudTokenURL = "https://sky-auth.telia.no/auth/realms/get/protocol/openid-connect/token" telianoCloudAuthURL = "https://sky-auth.telia.no/auth/realms/get/protocol/openid-connect/auth" telianoCloudClientID = "desktop" tele2CloudTokenURL = "https://mittcloud-auth.tele2.se/auth/realms/comhem/protocol/openid-connect/token" tele2CloudAuthURL = "https://mittcloud-auth.tele2.se/auth/realms/comhem/protocol/openid-connect/auth" tele2CloudClientID = "desktop" onlimeCloudTokenURL = "https://cloud-auth.onlime.dk/auth/realms/onlime_wl/protocol/openid-connect/token" onlimeCloudAuthURL = "https://cloud-auth.onlime.dk/auth/realms/onlime_wl/protocol/openid-connect/auth" onlimeCloudClientID = "desktop" ) // Register with Fs func init() { // needs to be done early so we can use oauth during config fs.Register(&fs.RegInfo{ Name: "jottacloud", Description: "Jottacloud", NewFs: NewFs, Config: Config, MetadataInfo: &fs.MetadataInfo{ Help: `Jottacloud has limited support for metadata, currently an extended set of timestamps.`, System: map[string]fs.MetadataHelp{ "btime": { Help: "Time of file birth (creation), read from rclone metadata", Type: "RFC 3339", Example: "2006-01-02T15:04:05.999999999Z07:00", }, "mtime": { Help: "Time of last modification, read from rclone metadata", Type: "RFC 3339", Example: "2006-01-02T15:04:05.999999999Z07:00", }, "utime": { Help: "Time of last upload, when current revision was created, generated by backend", Type: "RFC 3339", Example: "2006-01-02T15:04:05.999999999Z07:00", ReadOnly: true, }, "content-type": { Help: "MIME type, also known as media type", Type: "string", Example: "text/plain", ReadOnly: true, }, }, }, Options: append(oauthutil.SharedOptions, []fs.Option{{ Name: "md5_memory_limit", Help: "Files bigger than this will be cached on disk to calculate the MD5 if required.", Default: fs.SizeSuffix(10 * 1024 * 1024), Advanced: true, }, { Name: "trashed_only", Help: "Only show files that are in the trash.\n\nThis will show trashed files in their original directory structure.", Default: false, Advanced: true, }, { Name: "hard_delete", Help: "Delete files permanently rather than putting them into the trash.", Default: false, Advanced: true, }, { Name: "upload_resume_limit", Help: "Files bigger than this can be resumed if the upload fail's.", Default: fs.SizeSuffix(10 * 1024 * 1024), Advanced: true, }, { Name: "no_versions", Help: "Avoid server side versioning by deleting files and recreating files instead of overwriting them.", Default: false, Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, // Encode invalid UTF-8 bytes as xml doesn't handle them properly. // // Also: '*', '/', ':', '<', '>', '?', '\"', '\x00', '|' Default: (encoder.Display | encoder.EncodeWin | // :?"*<>| encoder.EncodeInvalidUtf8), }}...), }) } // Config runs the backend configuration protocol func Config(ctx context.Context, name string, m configmap.Mapper, config fs.ConfigIn) (*fs.ConfigOut, error) { switch config.State { case "": return fs.ConfigChooseExclusiveFixed("auth_type_done", "config_type", `Select authentication type.`, []fs.OptionExample{{ Value: "standard", Help: "Standard authentication.\nUse this if you're a normal Jottacloud user.", }, { Value: "legacy", Help: "Legacy authentication.\nThis is only required for certain whitelabel versions of Jottacloud and not recommended for normal users.", }, { Value: "telia_se", Help: "Telia Cloud authentication.\nUse this if you are using Telia Cloud (Sweden).", }, { Value: "telia_no", Help: "Telia Sky authentication.\nUse this if you are using Telia Sky (Norway).", }, { Value: "tele2", Help: "Tele2 Cloud authentication.\nUse this if you are using Tele2 Cloud.", }, { Value: "onlime", Help: "Onlime Cloud authentication.\nUse this if you are using Onlime Cloud.", }}) case "auth_type_done": // Jump to next state according to config chosen return fs.ConfigGoto(config.Result) case "standard": // configure a jottacloud backend using the modern JottaCli token based authentication m.Set("configVersion", fmt.Sprint(configVersion)) return fs.ConfigInput("standard_token", "config_login_token", "Personal login token.\nGenerate here: https://www.jottacloud.com/web/secure") case "standard_token": loginToken := config.Result m.Set(configClientID, defaultClientID) m.Set(configClientSecret, "") srv := rest.NewClient(fshttp.NewClient(ctx)) token, tokenEndpoint, err := doTokenAuth(ctx, srv, loginToken) if err != nil { return nil, fmt.Errorf("failed to get oauth token: %w", err) } m.Set(configTokenURL, tokenEndpoint) err = oauthutil.PutToken(name, m, &token, true) if err != nil { return nil, fmt.Errorf("error while saving token: %w", err) } return fs.ConfigGoto("choose_device") case "legacy": // configure a jottacloud backend using legacy authentication m.Set("configVersion", fmt.Sprint(legacyConfigVersion)) return fs.ConfigConfirm("legacy_api", false, "config_machine_specific", `Do you want to create a machine specific API key? Rclone has it's own Jottacloud API KEY which works fine as long as one only uses rclone on a single machine. When you want to use rclone with this account on more than one machine it's recommended to create a machine specific API key. These keys can NOT be shared between machines.`) case "legacy_api": srv := rest.NewClient(fshttp.NewClient(ctx)) if config.Result == "true" { deviceRegistration, err := registerDevice(ctx, srv) if err != nil { return nil, fmt.Errorf("failed to register device: %w", err) } m.Set(configClientID, deviceRegistration.ClientID) m.Set(configClientSecret, obscure.MustObscure(deviceRegistration.ClientSecret)) fs.Debugf(nil, "Got clientID %q and clientSecret %q", deviceRegistration.ClientID, deviceRegistration.ClientSecret) } return fs.ConfigInput("legacy_username", "config_username", "Username (e-mail address)") case "legacy_username": m.Set(configUsername, config.Result) return fs.ConfigPassword("legacy_password", "config_password", "Password (only used in setup, will not be stored)") case "legacy_password": m.Set("password", config.Result) m.Set("auth_code", "") return fs.ConfigGoto("legacy_do_auth") case "legacy_auth_code": authCode := strings.ReplaceAll(config.Result, "-", "") // remove any "-" contained in the code so we have a 6 digit number m.Set("auth_code", authCode) return fs.ConfigGoto("legacy_do_auth") case "legacy_do_auth": username, _ := m.Get(configUsername) password, _ := m.Get("password") password = obscure.MustReveal(password) authCode, _ := m.Get("auth_code") srv := rest.NewClient(fshttp.NewClient(ctx)) clientID, ok := m.Get(configClientID) if !ok { clientID = legacyClientID } clientSecret, ok := m.Get(configClientSecret) if !ok { clientSecret = legacyEncryptedClientSecret } oauthConfig := &oauth2.Config{ Endpoint: oauth2.Endpoint{ AuthURL: legacyTokenURL, }, ClientID: clientID, ClientSecret: obscure.MustReveal(clientSecret), } token, err := doLegacyAuth(ctx, srv, oauthConfig, username, password, authCode) if err == errAuthCodeRequired { return fs.ConfigInput("legacy_auth_code", "config_auth_code", "Verification Code\nThis account uses 2 factor authentication you will receive a verification code via SMS.") } m.Set("password", "") m.Set("auth_code", "") if err != nil { return nil, fmt.Errorf("failed to get oauth token: %w", err) } err = oauthutil.PutToken(name, m, &token, true) if err != nil { return nil, fmt.Errorf("error while saving token: %w", err) } return fs.ConfigGoto("choose_device") case "telia_se": // telia_se cloud config m.Set("configVersion", fmt.Sprint(configVersion)) m.Set(configClientID, teliaseCloudClientID) m.Set(configTokenURL, teliaseCloudTokenURL) return oauthutil.ConfigOut("choose_device", &oauthutil.Options{ OAuth2Config: &oauthutil.Config{ AuthURL: teliaseCloudAuthURL, TokenURL: teliaseCloudTokenURL, ClientID: teliaseCloudClientID, Scopes: []string{"openid", "jotta-default", "offline_access"}, RedirectURL: oauthutil.RedirectLocalhostURL, }, }) case "telia_no": // telia_no cloud config m.Set("configVersion", fmt.Sprint(configVersion)) m.Set(configClientID, telianoCloudClientID) m.Set(configTokenURL, telianoCloudTokenURL) return oauthutil.ConfigOut("choose_device", &oauthutil.Options{ OAuth2Config: &oauthutil.Config{ AuthURL: telianoCloudAuthURL, TokenURL: telianoCloudTokenURL, ClientID: telianoCloudClientID, Scopes: []string{"openid", "jotta-default", "offline_access"}, RedirectURL: oauthutil.RedirectLocalhostURL, }, }) case "tele2": // tele2 cloud config m.Set("configVersion", fmt.Sprint(configVersion)) m.Set(configClientID, tele2CloudClientID) m.Set(configTokenURL, tele2CloudTokenURL) return oauthutil.ConfigOut("choose_device", &oauthutil.Options{ OAuth2Config: &oauthutil.Config{ AuthURL: tele2CloudAuthURL, TokenURL: tele2CloudTokenURL, ClientID: tele2CloudClientID, Scopes: []string{"openid", "jotta-default", "offline_access"}, RedirectURL: oauthutil.RedirectLocalhostURL, }, }) case "onlime": // onlime cloud config m.Set("configVersion", fmt.Sprint(configVersion)) m.Set(configClientID, onlimeCloudClientID) m.Set(configTokenURL, onlimeCloudTokenURL) return oauthutil.ConfigOut("choose_device", &oauthutil.Options{ OAuth2Config: &oauthutil.Config{ AuthURL: onlimeCloudAuthURL, TokenURL: onlimeCloudTokenURL, ClientID: onlimeCloudClientID, Scopes: []string{"openid", "jotta-default", "offline_access"}, RedirectURL: oauthutil.RedirectLocalhostURL, }, }) case "choose_device": return fs.ConfigConfirm("choose_device_query", false, "config_non_standard", `Use a non-standard device/mountpoint? Choosing no, the default, will let you access the storage used for the archive section of the official Jottacloud client. If you instead want to access the sync or the backup section, for example, you must choose yes.`) case "choose_device_query": if config.Result != "true" { m.Set(configDevice, "") m.Set(configMountpoint, "") return fs.ConfigGoto("end") } oAuthClient, _, err := getOAuthClient(ctx, name, m) if err != nil { return nil, err } jfsSrv := rest.NewClient(oAuthClient).SetRoot(jfsURL) apiSrv := rest.NewClient(oAuthClient).SetRoot(apiURL) cust, err := getCustomerInfo(ctx, apiSrv) if err != nil { return nil, err } acc, err := getDriveInfo(ctx, jfsSrv, cust.Username) if err != nil { return nil, err } deviceNames := make([]string, len(acc.Devices)) for i, dev := range acc.Devices { if i > 0 && dev.Name == defaultDevice { // Insert the special Jotta device as first entry, making it the default choice. copy(deviceNames[1:i+1], deviceNames[0:i]) deviceNames[0] = dev.Name } else { deviceNames[i] = dev.Name } } help := fmt.Sprintf(`The device to use. In standard setup the built-in %s device is used, which contains predefined mountpoints for archive, sync etc. All other devices are treated as backup devices by the official Jottacloud client. You may create a new by entering a unique name.`, defaultDevice) return fs.ConfigChoose("choose_device_result", "config_device", help, len(deviceNames), func(i int) (string, string) { return deviceNames[i], "" }) case "choose_device_result": device := config.Result oAuthClient, _, err := getOAuthClient(ctx, name, m) if err != nil { return nil, err } jfsSrv := rest.NewClient(oAuthClient).SetRoot(jfsURL) apiSrv := rest.NewClient(oAuthClient).SetRoot(apiURL) cust, err := getCustomerInfo(ctx, apiSrv) if err != nil { return nil, err } acc, err := getDriveInfo(ctx, jfsSrv, cust.Username) if err != nil { return nil, err } isNew := true for _, dev := range acc.Devices { if strings.EqualFold(dev.Name, device) { // If device name exists with different casing we prefer the existing (not sure if and how the api handles the opposite) device = dev.Name // Prefer same casing as existing, e.g. if user entered "jotta" we use the standard casing "Jotta" instead isNew = false break } } var dev *api.JottaDevice if isNew { fs.Debugf(nil, "Creating new device: %s", device) dev, err = createDevice(ctx, jfsSrv, path.Join(cust.Username, device)) if err != nil { return nil, err } } m.Set(configDevice, device) if !isNew { dev, err = getDeviceInfo(ctx, jfsSrv, path.Join(cust.Username, device)) if err != nil { return nil, err } } var help string if device == defaultDevice { // With built-in Jotta device the mountpoint choice is exclusive, // we do not want to risk any problems by creating new mountpoints on it. help = fmt.Sprintf(`The mountpoint to use on the built-in device %s. The standard setup is to use the %s mountpoint. Most other mountpoints have very limited support in rclone and should generally be avoided.`, defaultDevice, defaultMountpoint) return fs.ConfigChooseExclusive("choose_device_mountpoint", "config_mountpoint", help, len(dev.MountPoints), func(i int) (string, string) { return dev.MountPoints[i].Name, "" }) } help = fmt.Sprintf(`The mountpoint to use on the non-standard device %s. You may create a new by entering a unique name.`, device) return fs.ConfigChoose("choose_device_mountpoint", "config_mountpoint", help, len(dev.MountPoints), func(i int) (string, string) { return dev.MountPoints[i].Name, "" }) case "choose_device_mountpoint": mountpoint := config.Result oAuthClient, _, err := getOAuthClient(ctx, name, m) if err != nil { return nil, err } jfsSrv := rest.NewClient(oAuthClient).SetRoot(jfsURL) apiSrv := rest.NewClient(oAuthClient).SetRoot(apiURL) cust, err := getCustomerInfo(ctx, apiSrv) if err != nil { return nil, err } device, _ := m.Get(configDevice) dev, err := getDeviceInfo(ctx, jfsSrv, path.Join(cust.Username, device)) if err != nil { return nil, err } isNew := true for _, mnt := range dev.MountPoints { if strings.EqualFold(mnt.Name, mountpoint) { mountpoint = mnt.Name isNew = false break } } if isNew { if device == defaultDevice { return nil, fmt.Errorf("custom mountpoints not supported on built-in %s device: %w", defaultDevice, err) } fs.Debugf(nil, "Creating new mountpoint: %s", mountpoint) _, err := createMountPoint(ctx, jfsSrv, path.Join(cust.Username, device, mountpoint)) if err != nil { return nil, err } } m.Set(configMountpoint, mountpoint) return fs.ConfigGoto("end") case "end": // All the config flows end up here in case we need to carry on with something return nil, nil } return nil, fmt.Errorf("unknown state %q", config.State) } // Options defines the configuration for this backend type Options struct { Device string `config:"device"` Mountpoint string `config:"mountpoint"` MD5MemoryThreshold fs.SizeSuffix `config:"md5_memory_limit"` TrashedOnly bool `config:"trashed_only"` HardDelete bool `config:"hard_delete"` NoVersions bool `config:"no_versions"` UploadThreshold fs.SizeSuffix `config:"upload_resume_limit"` Enc encoder.MultiEncoder `config:"encoding"` } // Fs represents a remote jottacloud type Fs struct { name string root string user string opt Options features *fs.Features fileEndpoint string allocateEndpoint string jfsSrv *rest.Client apiSrv *rest.Client pacer *fs.Pacer tokenRenewer *oauthutil.Renew // renew the token on expiry } // Object describes a jottacloud object // // Will definitely have info but maybe not meta type Object struct { fs *Fs remote string hasMetaData bool size int64 createTime time.Time modTime time.Time updateTime time.Time md5 string mimeType string } // ------------------------------------------------------------ // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("jottacloud root '%s'", f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // joinPath joins two path/url elements // // Does not perform clean on the result like path.Join does, // which breaks urls by changing prefix "https://" into "https:/". func joinPath(base string, rel string) string { if rel == "" { return base } if strings.HasSuffix(base, "/") { return base + strings.TrimPrefix(rel, "/") } if strings.HasPrefix(rel, "/") { return strings.TrimSuffix(base, "/") + rel } return base + "/" + rel } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 429, // Too Many Requests. 500, // Internal Server Error 502, // Bad Gateway 503, // Service Unavailable 504, // Gateway Timeout 509, // Bandwidth Limit Exceeded } // shouldRetry returns a boolean as to whether this resp and err // deserve to be retried. It returns the err as a convenience func shouldRetry(ctx context.Context, resp *http.Response, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } return fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(resp, retryErrorCodes), err } // registerDevice register a new device for use with the jottacloud API func registerDevice(ctx context.Context, srv *rest.Client) (reg *api.DeviceRegistrationResponse, err error) { // random generator to generate random device names seededRand := rand.New(rand.NewSource(time.Now().UnixNano())) randonDeviceNamePartLength := 21 randomDeviceNamePart := make([]byte, randonDeviceNamePartLength) charset := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" for i := range randomDeviceNamePart { randomDeviceNamePart[i] = charset[seededRand.Intn(len(charset))] } randomDeviceName := "rclone-" + string(randomDeviceNamePart) fs.Debugf(nil, "Trying to register device '%s'", randomDeviceName) values := url.Values{} values.Set("device_id", randomDeviceName) opts := rest.Opts{ Method: "POST", RootURL: legacyRegisterURL, ContentType: "application/x-www-form-urlencoded", ExtraHeaders: map[string]string{"Authorization": "Bearer c2xrZmpoYWRsZmFramhkc2xma2phaHNkbGZramhhc2xkZmtqaGFzZGxrZmpobGtq"}, Parameters: values, } var deviceRegistration *api.DeviceRegistrationResponse _, err = srv.CallJSON(ctx, &opts, nil, &deviceRegistration) return deviceRegistration, err } var errAuthCodeRequired = errors.New("auth code required") // doLegacyAuth runs the actual token request for V1 authentication // // Call this first with blank authCode. If errAuthCodeRequired is // returned then call it again with an authCode func doLegacyAuth(ctx context.Context, srv *rest.Client, oauthConfig *oauth2.Config, username, password, authCode string) (token oauth2.Token, err error) { // prepare out token request with username and password values := url.Values{} values.Set("grant_type", "PASSWORD") values.Set("password", password) values.Set("username", username) values.Set("client_id", oauthConfig.ClientID) values.Set("client_secret", oauthConfig.ClientSecret) opts := rest.Opts{ Method: "POST", RootURL: oauthConfig.Endpoint.AuthURL, ContentType: "application/x-www-form-urlencoded", Parameters: values, } if authCode != "" { opts.ExtraHeaders = make(map[string]string) opts.ExtraHeaders["X-Jottacloud-Otp"] = authCode } // do the first request var jsonToken api.TokenJSON resp, err := srv.CallJSON(ctx, &opts, nil, &jsonToken) if err != nil && authCode == "" { // if 2fa is enabled the first request is expected to fail. We will do another request with the 2fa code as an additional http header if resp != nil { if resp.Header.Get("X-JottaCloud-OTP") == "required; SMS" { return token, errAuthCodeRequired } } } token.AccessToken = jsonToken.AccessToken token.RefreshToken = jsonToken.RefreshToken token.TokenType = jsonToken.TokenType token.Expiry = time.Now().Add(time.Duration(jsonToken.ExpiresIn) * time.Second) return token, err } // doTokenAuth runs the actual token request for V2 authentication func doTokenAuth(ctx context.Context, apiSrv *rest.Client, loginTokenBase64 string) (token oauth2.Token, tokenEndpoint string, err error) { loginTokenBytes, err := base64.RawURLEncoding.DecodeString(loginTokenBase64) if err != nil { return token, "", err } // decode login token var loginToken api.LoginToken decoder := json.NewDecoder(bytes.NewReader(loginTokenBytes)) err = decoder.Decode(&loginToken) if err != nil { return token, "", err } // retrieve endpoint urls opts := rest.Opts{ Method: "GET", RootURL: loginToken.WellKnownLink, } var wellKnown api.WellKnown _, err = apiSrv.CallJSON(ctx, &opts, nil, &wellKnown) if err != nil { return token, "", err } // prepare out token request with username and password values := url.Values{} values.Set("client_id", defaultClientID) values.Set("grant_type", "password") values.Set("password", loginToken.AuthToken) values.Set("scope", "openid offline_access") values.Set("username", loginToken.Username) values.Encode() opts = rest.Opts{ Method: "POST", RootURL: wellKnown.TokenEndpoint, ContentType: "application/x-www-form-urlencoded", Body: strings.NewReader(values.Encode()), } // do the first request var jsonToken api.TokenJSON _, err = apiSrv.CallJSON(ctx, &opts, nil, &jsonToken) if err != nil { return token, "", err } token.AccessToken = jsonToken.AccessToken token.RefreshToken = jsonToken.RefreshToken token.TokenType = jsonToken.TokenType token.Expiry = time.Now().Add(time.Duration(jsonToken.ExpiresIn) * time.Second) return token, wellKnown.TokenEndpoint, err } // getCustomerInfo queries general information about the account func getCustomerInfo(ctx context.Context, apiSrv *rest.Client) (info *api.CustomerInfo, err error) { opts := rest.Opts{ Method: "GET", Path: "account/v1/customer", } _, err = apiSrv.CallJSON(ctx, &opts, nil, &info) if err != nil { return nil, fmt.Errorf("couldn't get customer info: %w", err) } return info, nil } // getDriveInfo queries general information about the account and the available devices and mountpoints. func getDriveInfo(ctx context.Context, srv *rest.Client, username string) (info *api.DriveInfo, err error) { opts := rest.Opts{ Method: "GET", Path: username, } _, err = srv.CallXML(ctx, &opts, nil, &info) if err != nil { return nil, fmt.Errorf("couldn't get drive info: %w", err) } return info, nil } // getDeviceInfo queries Information about a jottacloud device func getDeviceInfo(ctx context.Context, srv *rest.Client, path string) (info *api.JottaDevice, err error) { opts := rest.Opts{ Method: "GET", Path: urlPathEscape(path), } _, err = srv.CallXML(ctx, &opts, nil, &info) if err != nil { return nil, fmt.Errorf("couldn't get device info: %w", err) } return info, nil } // createDevice makes a device func createDevice(ctx context.Context, srv *rest.Client, path string) (info *api.JottaDevice, err error) { opts := rest.Opts{ Method: "POST", Path: urlPathEscape(path), Parameters: url.Values{}, } opts.Parameters.Set("type", "WORKSTATION") _, err = srv.CallXML(ctx, &opts, nil, &info) if err != nil { return nil, fmt.Errorf("couldn't create device: %w", err) } return info, nil } // createMountPoint makes a mount point func createMountPoint(ctx context.Context, srv *rest.Client, path string) (info *api.JottaMountPoint, err error) { opts := rest.Opts{ Method: "POST", Path: urlPathEscape(path), } _, err = srv.CallXML(ctx, &opts, nil, &info) if err != nil { return nil, fmt.Errorf("couldn't create mountpoint: %w", err) } return info, nil } // setEndpoints generates the API endpoints func (f *Fs) setEndpoints() { if f.opt.Device == "" { f.opt.Device = defaultDevice } if f.opt.Mountpoint == "" { f.opt.Mountpoint = defaultMountpoint } f.fileEndpoint = path.Join(f.user, f.opt.Device, f.opt.Mountpoint) f.allocateEndpoint = path.Join("/jfs", f.opt.Device, f.opt.Mountpoint) } // readMetaDataForPath reads the metadata from the path func (f *Fs) readMetaDataForPath(ctx context.Context, path string) (info *api.JottaFile, err error) { opts := rest.Opts{ Method: "GET", Path: f.filePath(path), } var result api.JottaFile var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.jfsSrv.CallXML(ctx, &opts, nil, &result) return shouldRetry(ctx, resp, err) }) if apiErr, ok := err.(*api.Error); ok { // does not exist if apiErr.StatusCode == http.StatusNotFound { return nil, fs.ErrorObjectNotFound } } if err != nil { return nil, fmt.Errorf("read metadata failed: %w", err) } if result.XMLName.Local == "folder" { return nil, fs.ErrorIsDir } else if result.XMLName.Local != "file" { return nil, fs.ErrorNotAFile } return &result, nil } // errorHandler parses a non 2xx error response into an error func errorHandler(resp *http.Response) error { // Decode error response errResponse := new(api.Error) err := rest.DecodeXML(resp, &errResponse) if err != nil { fs.Debugf(nil, "Couldn't decode error response: %v", err) } if errResponse.Message == "" { errResponse.Message = resp.Status } if errResponse.StatusCode == 0 { errResponse.StatusCode = resp.StatusCode } return errResponse } // Jottacloud wants '+' to be URL encoded even though the RFC states it's not reserved func urlPathEscape(in string) string { return strings.ReplaceAll(rest.URLPathEscape(in), "+", "%2B") } // filePathRaw returns an unescaped file path (f.root, file) // Optionally made absolute by prefixing with "/", typically required when used // as request parameter instead of the path (which is relative to some root url). func (f *Fs) filePathRaw(file string, absolute bool) string { prefix := "" if absolute { prefix = "/" } return path.Join(prefix, f.fileEndpoint, f.opt.Enc.FromStandardPath(path.Join(f.root, file))) } // filePath returns an escaped file path (f.root, file) func (f *Fs) filePath(file string) string { return urlPathEscape(f.filePathRaw(file, false)) } // allocatePathRaw returns an unescaped allocate file path (f.root, file) // Optionally made absolute by prefixing with "/", typically required when used // as request parameter instead of the path (which is relative to some root url). func (f *Fs) allocatePathRaw(file string, absolute bool) string { prefix := "" if absolute { prefix = "/" } return path.Join(prefix, f.allocateEndpoint, f.opt.Enc.FromStandardPath(path.Join(f.root, file))) } // Jottacloud requires the grant_type 'refresh_token' string // to be uppercase and throws a 400 Bad Request if we use the // lower case used by the oauth2 module // // This filter catches all refresh requests, reads the body, // changes the case and then sends it on func grantTypeFilter(req *http.Request) { if legacyTokenURL == req.URL.String() { // read the entire body refreshBody, err := io.ReadAll(req.Body) if err != nil { return } _ = req.Body.Close() // make the refresh token upper case refreshBody = []byte(strings.Replace(string(refreshBody), "grant_type=refresh_token", "grant_type=REFRESH_TOKEN", 1)) // set the new ReadCloser (with a dummy Close()) req.Body = io.NopCloser(bytes.NewReader(refreshBody)) } } func getOAuthClient(ctx context.Context, name string, m configmap.Mapper) (oAuthClient *http.Client, ts *oauthutil.TokenSource, err error) { // Check config version var ver int version, ok := m.Get("configVersion") if ok { ver, err = strconv.Atoi(version) if err != nil { return nil, nil, errors.New("failed to parse config version") } ok = (ver == configVersion) || (ver == legacyConfigVersion) } if !ok { return nil, nil, errors.New("outdated config - please reconfigure this backend") } baseClient := fshttp.NewClient(ctx) oauthConfig := &oauthutil.Config{ AuthURL: defaultTokenURL, TokenURL: defaultTokenURL, } if ver == configVersion { oauthConfig.ClientID = defaultClientID // if custom endpoints are set use them else stick with defaults if tokenURL, ok := m.Get(configTokenURL); ok { oauthConfig.TokenURL = tokenURL // jottacloud is weird. we need to use the tokenURL as authURL oauthConfig.AuthURL = tokenURL } } else if ver == legacyConfigVersion { clientID, ok := m.Get(configClientID) if !ok { clientID = legacyClientID } clientSecret, ok := m.Get(configClientSecret) if !ok { clientSecret = legacyEncryptedClientSecret } oauthConfig.ClientID = clientID oauthConfig.ClientSecret = obscure.MustReveal(clientSecret) oauthConfig.TokenURL = legacyTokenURL oauthConfig.AuthURL = legacyTokenURL // add the request filter to fix token refresh if do, ok := baseClient.Transport.(interface { SetRequestFilter(f func(req *http.Request)) }); ok { do.SetRequestFilter(grantTypeFilter) } else { fs.Debugf(name+":", "Couldn't add request filter - uploads will fail") } } // Create OAuth Client oAuthClient, ts, err = oauthutil.NewClientWithBaseClient(ctx, name, m, oauthConfig, baseClient) if err != nil { return nil, nil, fmt.Errorf("failed to configure Jottacloud oauth client: %w", err) } return oAuthClient, ts, nil } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } oAuthClient, ts, err := getOAuthClient(ctx, name, m) if err != nil { return nil, err } rootIsDir := strings.HasSuffix(root, "/") root = strings.Trim(root, "/") f := &Fs{ name: name, root: root, opt: *opt, jfsSrv: rest.NewClient(oAuthClient).SetRoot(jfsURL), apiSrv: rest.NewClient(oAuthClient).SetRoot(apiURL), pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), } f.features = (&fs.Features{ CaseInsensitive: true, CanHaveEmptyDirectories: true, ReadMimeType: true, WriteMimeType: false, ReadMetadata: true, WriteMetadata: true, UserMetadata: false, }).Fill(ctx, f) f.jfsSrv.SetErrorHandler(errorHandler) if opt.TrashedOnly { // we cannot support showing Trashed Files when using ListR right now f.features.ListR = nil } // Renew the token in the background f.tokenRenewer = oauthutil.NewRenew(f.String(), ts, func() error { _, err := f.readMetaDataForPath(ctx, "") if err == fs.ErrorNotAFile || err == fs.ErrorIsDir { err = nil } return err }) cust, err := getCustomerInfo(ctx, f.apiSrv) if err != nil { return nil, err } f.user = cust.Username f.setEndpoints() if root != "" && !rootIsDir { // Check to see if the root actually an existing file remote := path.Base(root) f.root = path.Dir(root) if f.root == "." { f.root = "" } _, err := f.NewObject(context.TODO(), remote) if err != nil { if errors.Is(err, fs.ErrorObjectNotFound) || errors.Is(err, fs.ErrorNotAFile) || errors.Is(err, fs.ErrorIsDir) { // File doesn't exist so return old f f.root = root return f, nil } return nil, err } // return an error with an fs which points to the parent return f, fs.ErrorIsFile } return f, nil } // Return an Object from a path // // If it can't be found it returns the error fs.ErrorObjectNotFound. func (f *Fs) newObjectWithInfo(ctx context.Context, remote string, info *api.JottaFile) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } var err error if info != nil { if !f.validFile(info) { return nil, fs.ErrorObjectNotFound } err = o.setMetaData(info) // sets the info } else { err = o.readMetaData(ctx, false) // reads info and meta, returning an error } if err != nil { return nil, err } return o, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return f.newObjectWithInfo(ctx, remote, nil) } // CreateDir makes a directory func (f *Fs) CreateDir(ctx context.Context, path string) (jf *api.JottaFolder, err error) { // fs.Debugf(f, "CreateDir(%q, %q)\n", pathID, leaf) var resp *http.Response opts := rest.Opts{ Method: "POST", Path: f.filePath(path), Parameters: url.Values{}, } opts.Parameters.Set("mkDir", "true") err = f.pacer.Call(func() (bool, error) { resp, err = f.jfsSrv.CallXML(ctx, &opts, nil, &jf) return shouldRetry(ctx, resp, err) }) if err != nil { //fmt.Printf("...Error %v\n", err) return nil, err } // fmt.Printf("...Id %q\n", *info.Id) return jf, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { opts := rest.Opts{ Method: "GET", Path: f.filePath(dir), } var resp *http.Response var result api.JottaFolder err = f.pacer.Call(func() (bool, error) { resp, err = f.jfsSrv.CallXML(ctx, &opts, nil, &result) return shouldRetry(ctx, resp, err) }) if err != nil { if apiErr, ok := err.(*api.Error); ok { // does not exist if apiErr.StatusCode == http.StatusNotFound { return nil, fs.ErrorDirNotFound } } return nil, fmt.Errorf("couldn't list files: %w", err) } if !f.validFolder(&result) { return nil, fs.ErrorDirNotFound } for i := range result.Folders { item := &result.Folders[i] if f.validFolder(item) { remote := path.Join(dir, f.opt.Enc.ToStandardName(item.Name)) d := fs.NewDir(remote, time.Time(item.ModifiedAt)) entries = append(entries, d) } } for i := range result.Files { item := &result.Files[i] if f.validFile(item) { remote := path.Join(dir, f.opt.Enc.ToStandardName(item.Name)) if o, err := f.newObjectWithInfo(ctx, remote, item); err == nil { entries = append(entries, o) } } } return entries, nil } func parseListRStream(ctx context.Context, r io.Reader, filesystem *Fs, callback func(fs.DirEntry) error) error { type stats struct { Folders int `xml:"folders"` Files int `xml:"files"` } var expected, actual stats type xmlFile struct { Path string `xml:"path"` Name string `xml:"filename"` Checksum string `xml:"md5"` Size int64 `xml:"size"` Modified api.Rfc3339Time `xml:"modified"` // Note: Liststream response includes 3 decimal milliseconds, but we ignore them since there is second precision everywhere else Created api.Rfc3339Time `xml:"created"` } type xmlFolder struct { Path string `xml:"path"` } addFolder := func(path string) error { return callback(fs.NewDir(filesystem.opt.Enc.ToStandardPath(path), time.Time{})) } addFile := func(f *xmlFile) error { return callback(&Object{ hasMetaData: true, fs: filesystem, remote: filesystem.opt.Enc.ToStandardPath(path.Join(f.Path, f.Name)), size: f.Size, md5: f.Checksum, createTime: time.Time(f.Created), modTime: time.Time(f.Modified), }) } // liststream paths are /mountpoint/root/path // so the returned paths should have /mountpoint/root/ trimmed // as the caller is expecting path. pathPrefix := filesystem.opt.Enc.FromStandardPath(path.Join("/", filesystem.opt.Mountpoint, filesystem.root)) trimPathPrefix := func(p string) string { p = strings.TrimPrefix(p, pathPrefix) p = strings.TrimPrefix(p, "/") return p } uniqueFolders := map[string]bool{} decoder := xml.NewDecoder(r) for { t, err := decoder.Token() if err != nil { if err != io.EOF { return err } break } switch se := t.(type) { case xml.StartElement: switch se.Name.Local { case "file": var f xmlFile if err := decoder.DecodeElement(&f, &se); err != nil { return err } f.Path = trimPathPrefix(f.Path) actual.Files++ if !uniqueFolders[f.Path] { uniqueFolders[f.Path] = true actual.Folders++ if err := addFolder(f.Path); err != nil { return err } } if err := addFile(&f); err != nil { return err } case "folder": var f xmlFolder if err := decoder.DecodeElement(&f, &se); err != nil { return err } f.Path = trimPathPrefix(f.Path) uniqueFolders[f.Path] = true actual.Folders++ if err := addFolder(f.Path); err != nil { return err } case "stats": if err := decoder.DecodeElement(&expected, &se); err != nil { return err } } } } if expected.Folders != actual.Folders || expected.Files != actual.Files { return fmt.Errorf("invalid result from listStream: expected[%#v] != actual[%#v]", expected, actual) } return nil } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { opts := rest.Opts{ Method: "GET", Path: f.filePath(dir), Parameters: url.Values{}, } opts.Parameters.Set("mode", "liststream") list := list.NewHelper(callback) var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.jfsSrv.Call(ctx, &opts) if err != nil { return shouldRetry(ctx, resp, err) } err = parseListRStream(ctx, resp.Body, f, func(d fs.DirEntry) error { if d.Remote() == dir { return nil } return list.Add(d) }) _ = resp.Body.Close() return shouldRetry(ctx, resp, err) }) if err != nil { if apiErr, ok := err.(*api.Error); ok { // does not exist if apiErr.StatusCode == http.StatusNotFound { return fs.ErrorDirNotFound } } return fmt.Errorf("couldn't list files: %w", err) } if err != nil { return err } return list.Flush() } // Creates from the parameters passed in a half finished Object which // must have setMetaData called on it // // Used to create new objects func (f *Fs) createObject(remote string, modTime time.Time, size int64) (o *Object) { // Temporary Object under construction o = &Object{ fs: f, remote: remote, size: size, modTime: modTime, } return o } // Put the object // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { o := f.createObject(src.Remote(), src.ModTime(ctx), src.Size()) return o, o.Update(ctx, in, src, options...) } // mkParentDir makes the parent of the native path dirPath if // necessary and any directories above that func (f *Fs) mkParentDir(ctx context.Context, dirPath string) error { // defer log.Trace(dirPath, "")("") // chop off trailing / if it exists parent := path.Dir(strings.TrimSuffix(dirPath, "/")) if parent == "." { parent = "" } return f.Mkdir(ctx, parent) } // Mkdir creates the container if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) error { _, err := f.CreateDir(ctx, dir) return err } // 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) (err error) { root := path.Join(f.root, dir) if root == "" { return errors.New("can't purge root directory") } // check that the directory exists entries, err := f.List(ctx, dir) if err != nil { return err } if check { if len(entries) != 0 { return fs.ErrorDirectoryNotEmpty } } opts := rest.Opts{ Method: "POST", Path: f.filePath(dir), Parameters: url.Values{}, NoResponse: true, } if f.opt.HardDelete { opts.Parameters.Set("rmDir", "true") } else { opts.Parameters.Set("dlDir", "true") } var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.jfsSrv.Call(ctx, &opts) return shouldRetry(ctx, resp, err) }) if err != nil { return fmt.Errorf("couldn't purge directory: %w", err) } return nil } // Rmdir deletes the root folder // // Returns an error if it isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, true) } // Precision return the precision of this Fs func (f *Fs) Precision() time.Duration { return time.Second } // Purge deletes all the files and the container func (f *Fs) Purge(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, false) } // createOrUpdate tries to make remote file match without uploading. // If the remote file exists, and has matching size and md5, only // timestamps are updated. If the file does not exist or does does // not match size and md5, but matching content can be constructed // from deduplication, the file will be updated/created. If the file // is currently in trash, but can be made to match, it will be // restored. Returns ErrorObjectNotFound if upload will be necessary // to get a matching remote file. func (f *Fs) createOrUpdate(ctx context.Context, file string, createTime time.Time, modTime time.Time, size int64, md5 string) (info *api.JottaFile, err error) { opts := rest.Opts{ Method: "POST", Path: f.filePath(file), Parameters: url.Values{}, ExtraHeaders: make(map[string]string), } opts.Parameters.Set("cphash", "true") opts.ExtraHeaders["JSize"] = strconv.FormatInt(size, 10) opts.ExtraHeaders["JMd5"] = md5 opts.ExtraHeaders["JCreated"] = api.JottaTime(createTime).String() opts.ExtraHeaders["JModified"] = api.JottaTime(modTime).String() var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.jfsSrv.CallXML(ctx, &opts, nil, &info) return shouldRetry(ctx, resp, err) }) if apiErr, ok := err.(*api.Error); ok { // does not exist, i.e. not matching size and md5, and not possible to make it by deduplication if apiErr.StatusCode == http.StatusNotFound { return nil, fs.ErrorObjectNotFound } } return info, nil } // copyOrMoves copies or moves directories or files depending on the method parameter func (f *Fs) copyOrMove(ctx context.Context, method, src, dest string) (info *api.JottaFile, err error) { opts := rest.Opts{ Method: "POST", Path: src, Parameters: url.Values{}, } opts.Parameters.Set(method, f.filePathRaw(dest, true)) var resp *http.Response err = f.pacer.Call(func() (bool, error) { resp, err = f.jfsSrv.CallXML(ctx, &opts, nil, &info) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } return info, nil } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't copy - not same remote type") return nil, fs.ErrorCantMove } meta, err := fs.GetMetadataOptions(ctx, f, src, fs.MetadataAsOpenOptions(ctx)) if err != nil { return nil, err } if err := f.mkParentDir(ctx, remote); err != nil { return nil, err } info, err := f.copyOrMove(ctx, "cp", srcObj.filePath(), remote) if err == nil { var createTime time.Time var createTimeMeta bool var modTime time.Time var modTimeMeta bool if meta != nil { createTime, createTimeMeta = srcObj.parseFsMetadataTime(meta, "btime") if !createTimeMeta { createTime = srcObj.createTime } modTime, modTimeMeta = srcObj.parseFsMetadataTime(meta, "mtime") if !modTimeMeta { modTime = srcObj.modTime } } if bool(info.Deleted) && !f.opt.TrashedOnly && info.State == "COMPLETED" { // Workaround necessary when destination was a trashed file, to avoid the copied file also being in trash (bug in api?) fs.Debugf(src, "Server-side copied to trashed destination, restoring") info, err = f.createOrUpdate(ctx, remote, createTime, modTime, info.Size, info.MD5) } else if createTimeMeta || modTimeMeta { info, err = f.createOrUpdate(ctx, remote, createTime, modTime, info.Size, info.MD5) } } if err != nil { return nil, fmt.Errorf("couldn't copy file: %w", err) } return f.newObjectWithInfo(ctx, remote, info) //return f.newObjectWithInfo(remote, &result) } // Move src to this remote using server-side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't move - not same remote type") return nil, fs.ErrorCantMove } meta, err := fs.GetMetadataOptions(ctx, f, src, fs.MetadataAsOpenOptions(ctx)) if err != nil { return nil, err } if err := f.mkParentDir(ctx, remote); err != nil { return nil, err } info, err := f.copyOrMove(ctx, "mv", srcObj.filePath(), remote) if err == nil && meta != nil { createTime, createTimeMeta := srcObj.parseFsMetadataTime(meta, "btime") if !createTimeMeta { createTime = srcObj.createTime } modTime, modTimeMeta := srcObj.parseFsMetadataTime(meta, "mtime") if !modTimeMeta { modTime = srcObj.modTime } if createTimeMeta || modTimeMeta { info, err = f.createOrUpdate(ctx, remote, createTime, modTime, info.Size, info.MD5) } } if err != nil { return nil, fmt.Errorf("couldn't move file: %w", err) } return f.newObjectWithInfo(ctx, remote, info) //return f.newObjectWithInfo(remote, result) } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } srcPath := path.Join(srcFs.root, srcRemote) dstPath := path.Join(f.root, dstRemote) // Refuse to move to or from the root if srcPath == "" || dstPath == "" { fs.Debugf(src, "DirMove error: Can't move root") return errors.New("can't move root directory") } //fmt.Printf("Move src: %s (FullPath %s), dst: %s (FullPath: %s)\n", srcRemote, srcPath, dstRemote, dstPath) var err error _, err = f.List(ctx, dstRemote) if err == fs.ErrorDirNotFound { // OK } else if err != nil { return err } else { return fs.ErrorDirExists } _, err = f.copyOrMove(ctx, "mvDir", path.Join(f.fileEndpoint, f.opt.Enc.FromStandardPath(srcPath))+"/", dstRemote) if err != nil { return fmt.Errorf("couldn't move directory: %w", err) } return nil } // PublicLink generates a public link to the remote path (usually readable by anyone) func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (link string, err error) { opts := rest.Opts{ Method: "GET", Path: f.filePath(remote), Parameters: url.Values{}, } if unlink { opts.Parameters.Set("mode", "disableShare") } else { opts.Parameters.Set("mode", "enableShare") } var resp *http.Response var result api.JottaFile err = f.pacer.Call(func() (bool, error) { resp, err = f.jfsSrv.CallXML(ctx, &opts, nil, &result) return shouldRetry(ctx, resp, err) }) if apiErr, ok := err.(*api.Error); ok { // does not exist if apiErr.StatusCode == http.StatusNotFound { return "", fs.ErrorObjectNotFound } } if err != nil { if unlink { return "", fmt.Errorf("couldn't remove public link: %w", err) } return "", fmt.Errorf("couldn't create public link: %w", err) } if unlink { if result.PublicURI != "" { return "", fmt.Errorf("couldn't remove public link - %q", result.PublicURI) } return "", nil } if result.PublicURI == "" { return "", errors.New("couldn't create public link - no uri received") } if result.PublicSharePath != "" { webLink := joinPath(wwwURL, result.PublicSharePath) fs.Debugf(nil, "Web link: %s", webLink) } else { fs.Debugf(nil, "No web link received") } directLink := joinPath(wwwURL, fmt.Sprintf("opin/io/downloadPublic/%s/%s", f.user, result.PublicURI)) fs.Debugf(nil, "Direct link: %s", directLink) return directLink, nil } // About gets quota information func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { info, err := getDriveInfo(ctx, f.jfsSrv, f.user) if err != nil { return nil, err } usage := &fs.Usage{ Used: fs.NewUsageValue(info.Usage), } if info.Capacity > 0 { usage.Total = fs.NewUsageValue(info.Capacity) usage.Free = fs.NewUsageValue(info.Capacity - info.Usage) } return usage, nil } // UserInfo fetches info about the current user func (f *Fs) UserInfo(ctx context.Context) (userInfo map[string]string, err error) { cust, err := getCustomerInfo(ctx, f.apiSrv) if err != nil { return nil, err } return map[string]string{ "Username": cust.Username, "Email": cust.Email, "Name": cust.Name, "AccountType": cust.AccountType, "SubscriptionType": cust.SubscriptionType, }, nil } // CleanUp empties the trash func (f *Fs) CleanUp(ctx context.Context) error { opts := rest.Opts{ Method: "POST", Path: "files/v1/purge_trash", } var info api.TrashResponse _, err := f.apiSrv.CallJSON(ctx, &opts, nil, &info) if err != nil { return fmt.Errorf("couldn't empty trash: %w", err) } return nil } // Shutdown shutdown the fs func (f *Fs) Shutdown(ctx context.Context) error { f.tokenRenewer.Shutdown() return nil } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hash.MD5) } // --------------------------------------------- // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // filePath returns an escaped file path (f.root, remote) func (o *Object) filePath() string { return o.fs.filePath(o.remote) } // Hash returns the MD5 of an object returning a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if t != hash.MD5 { return "", hash.ErrUnsupported } return o.md5, nil } // Size returns the size of an object in bytes func (o *Object) Size() int64 { ctx := context.TODO() err := o.readMetaData(ctx, false) if err != nil { fs.Logf(o, "Failed to read metadata: %v", err) return 0 } return o.size } // MimeType of an Object if known, "" otherwise func (o *Object) MimeType(ctx context.Context) string { return o.mimeType } // validFile checks if info indicates file is valid func (f *Fs) validFile(info *api.JottaFile) bool { if info.State != "COMPLETED" { return false // File is incomplete or corrupt } if !info.Deleted { return !f.opt.TrashedOnly // Regular file; return false if TrashedOnly, else true } return f.opt.TrashedOnly // Deleted file; return true if TrashedOnly, else false } // validFolder checks if info indicates folder is valid func (f *Fs) validFolder(info *api.JottaFolder) bool { // Returns true if folder is not deleted. // If TrashedOnly option then always returns true, because a folder not // in trash must be traversed to get to files/subfolders that are. return !bool(info.Deleted) || f.opt.TrashedOnly } // setMetaData sets the metadata from info func (o *Object) setMetaData(info *api.JottaFile) (err error) { o.hasMetaData = true o.size = info.Size o.md5 = info.MD5 o.mimeType = info.MimeType o.createTime = time.Time(info.CreatedAt) o.modTime = time.Time(info.ModifiedAt) o.updateTime = time.Time(info.UpdatedAt) return nil } // readMetaData reads and updates the metadata for an object func (o *Object) readMetaData(ctx context.Context, force bool) (err error) { if o.hasMetaData && !force { return nil } info, err := o.fs.readMetaDataForPath(ctx, o.remote) if err != nil { return err } if !o.fs.validFile(info) { return fs.ErrorObjectNotFound } return o.setMetaData(info) } // parseFsMetadataTime parses a time string from fs.Metadata with key func (o *Object) parseFsMetadataTime(m fs.Metadata, key string) (t time.Time, ok bool) { value, ok := m[key] if ok { var err error t, err = time.Parse(time.RFC3339Nano, value) // metadata stores RFC3339Nano timestamps if err != nil { fs.Debugf(o, "failed to parse metadata %s: %q: %v", key, value, err) ok = false } } return t, ok } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers func (o *Object) ModTime(ctx context.Context) time.Time { err := o.readMetaData(ctx, false) if err != nil { fs.Logf(o, "Failed to read metadata: %v", err) return time.Now() } return o.modTime } // SetModTime sets the modification time of the local fs object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { // make sure metadata is available, we need its current size and md5 err := o.readMetaData(ctx, false) if err != nil { fs.Logf(o, "Failed to read metadata: %v", err) return err } // request check/update with existing metadata and new modtime // (note that if size/md5 does not match, the file content will // also be modified if deduplication is possible, i.e. it is // important to use correct/latest values) _, err = o.fs.createOrUpdate(ctx, o.remote, o.createTime, modTime, o.size, o.md5) if err != nil { if err == fs.ErrorObjectNotFound { // file was modified (size/md5 changed) between readMetaData and createOrUpdate? return errors.New("metadata did not match") } return err } // update local metadata o.modTime = modTime return nil } // Storable returns a boolean showing whether this object storable func (o *Object) Storable() bool { return true } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { fs.FixRangeOption(options, o.size) var resp *http.Response opts := rest.Opts{ Method: "GET", Path: o.filePath(), Parameters: url.Values{}, Options: options, } opts.Parameters.Set("mode", "bin") err = o.fs.pacer.Call(func() (bool, error) { resp, err = o.fs.jfsSrv.Call(ctx, &opts) return shouldRetry(ctx, resp, err) }) if err != nil { return nil, err } return resp.Body, err } // Read the md5 of in returning a reader which will read the same contents // // The cleanup function should be called when out is finished with // regardless of whether this function returned an error or not. func readMD5(in io.Reader, size, threshold int64) (md5sum string, out io.Reader, cleanup func(), err error) { // we need an MD5 md5Hasher := md5.New() // use the teeReader to write to the local file AND calculate the MD5 while doing so teeReader := io.TeeReader(in, md5Hasher) // nothing to clean up by default cleanup = func() {} // don't cache small files on disk to reduce wear of the disk if size > threshold { var tempFile *os.File // create the cache file tempFile, err = os.CreateTemp("", cachePrefix) if err != nil { return } _ = os.Remove(tempFile.Name()) // Delete the file - may not work on Windows // clean up the file after we are done downloading cleanup = func() { // the file should normally already be close, but just to make sure _ = tempFile.Close() _ = os.Remove(tempFile.Name()) // delete the cache file after we are done - may be deleted already } // copy the ENTIRE file to disc and calculate the MD5 in the process if _, err = io.Copy(tempFile, teeReader); err != nil { return } // jump to the start of the local file so we can pass it along if _, err = tempFile.Seek(0, 0); err != nil { return } // replace the already read source with a reader of our cached file out = tempFile } else { // that's a small file, just read it into memory var inData []byte inData, err = io.ReadAll(teeReader) if err != nil { return } // set the reader to our read memory block out = bytes.NewReader(inData) } return hex.EncodeToString(md5Hasher.Sum(nil)), out, cleanup, nil } // Update the object with the contents of the io.Reader, modTime and size // // If existing is set then it updates the object rather than creating a new one. // // The new object may have been created if an error is returned func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { if o.fs.opt.NoVersions { err := o.readMetaData(ctx, false) if err == nil { // if the object exists delete it err = o.remove(ctx, true) if err != nil && err != fs.ErrorObjectNotFound { // if delete failed then report that, unless it was because the file did not exist after all return fmt.Errorf("failed to remove old object: %w", err) } } else if err != fs.ErrorObjectNotFound { // if the object does not exist we can just continue but if the error is something different we should report that return err } } o.fs.tokenRenewer.Start() defer o.fs.tokenRenewer.Stop() size := src.Size() md5String, err := src.Hash(ctx, hash.MD5) if err != nil || md5String == "" { // unwrap the accounting from the input, we use wrap to put it // back on after the buffering var wrap accounting.WrapFn in, wrap = accounting.UnWrap(in) var cleanup func() md5String, in, cleanup, err = readMD5(in, size, int64(o.fs.opt.MD5MemoryThreshold)) defer cleanup() if err != nil { return fmt.Errorf("failed to calculate MD5: %w", err) } // Wrap the accounting back onto the stream in = wrap(in) } // Fetch metadata if --metadata is in use meta, err := fs.GetMetadataOptions(ctx, o.fs, src, options) if err != nil { return fmt.Errorf("failed to read metadata from source object: %w", err) } var createdTime string var modTime string if meta != nil { if t, ok := o.parseFsMetadataTime(meta, "btime"); ok { createdTime = api.Rfc3339Time(t).String() // jottacloud api wants RFC3339 timestamps } if t, ok := o.parseFsMetadataTime(meta, "mtime"); ok { modTime = api.Rfc3339Time(t).String() } } if modTime == "" { // prefer mtime in meta as Modified time, fallback to source ModTime modTime = api.Rfc3339Time(src.ModTime(ctx)).String() } if createdTime == "" { // if no Created time set same as Modified createdTime = modTime } // use the api to allocate the file first and get resume / deduplication info var resp *http.Response opts := rest.Opts{ Method: "POST", Path: "files/v1/allocate", Options: options, ExtraHeaders: make(map[string]string), } // the allocate request var request = api.AllocateFileRequest{ Bytes: size, Created: createdTime, Modified: modTime, Md5: md5String, Path: o.fs.allocatePathRaw(o.remote, true), } // send it var response api.AllocateFileResponse err = o.fs.pacer.CallNoRetry(func() (bool, error) { resp, err = o.fs.apiSrv.CallJSON(ctx, &opts, &request, &response) return shouldRetry(ctx, resp, err) }) if err != nil { return err } // If the file state is INCOMPLETE and CORRUPT, we must upload it. // Else, if the file state is COMPLETE, we don't need to upload it because // the content is already there, possibly it was created with deduplication, // and also any metadata changes are already performed by the allocate request. if response.State != "COMPLETED" { // how much do we still have to upload? remainingBytes := size - response.ResumePos opts = rest.Opts{ Method: "POST", RootURL: response.UploadURL, ContentLength: &remainingBytes, ContentType: "application/octet-stream", Body: in, ExtraHeaders: make(map[string]string), } if response.ResumePos != 0 { opts.ExtraHeaders["Range"] = "bytes=" + strconv.FormatInt(response.ResumePos, 10) + "-" + strconv.FormatInt(size-1, 10) } // copy the already uploaded bytes into the trash :) var result api.UploadResponse _, err = io.CopyN(io.Discard, in, response.ResumePos) if err != nil { return err } // send the remaining bytes _, err = o.fs.apiSrv.CallJSON(ctx, &opts, nil, &result) if err != nil { return err } // Upload response contains main metadata properties (size, md5 and modTime) // which could be set back to the object, but it does not contain the // necessary information to set the createTime and updateTime properties, // so must therefore perform a read instead. } // in any case we must update the object meta data return o.readMetaData(ctx, true) } func (o *Object) remove(ctx context.Context, hard bool) error { opts := rest.Opts{ Method: "POST", Path: o.filePath(), Parameters: url.Values{}, NoResponse: true, } if hard { opts.Parameters.Set("rm", "true") } else { opts.Parameters.Set("dl", "true") } err := o.fs.pacer.Call(func() (bool, error) { resp, err := o.fs.jfsSrv.CallXML(ctx, &opts, nil, nil) return shouldRetry(ctx, resp, err) }) if apiErr, ok := err.(*api.Error); ok { // attempting to hard delete will fail if path does not exist, but standard delete will succeed if apiErr.StatusCode == http.StatusNotFound { return fs.ErrorObjectNotFound } } return err } // Remove an object func (o *Object) Remove(ctx context.Context) error { return o.remove(ctx, o.fs.opt.HardDelete) } // 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, false) if err != nil { fs.Logf(o, "Failed to read metadata: %v", err) return nil, err } metadata.Set("btime", o.createTime.Format(time.RFC3339Nano)) // metadata timestamps should be RFC3339Nano metadata.Set("mtime", o.modTime.Format(time.RFC3339Nano)) metadata.Set("utime", o.updateTime.Format(time.RFC3339Nano)) metadata.Set("content-type", o.mimeType) return metadata, nil } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.ListRer = (*Fs)(nil) _ fs.PublicLinker = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.UserInfoer = (*Fs)(nil) _ fs.CleanUpper = (*Fs)(nil) _ fs.Shutdowner = (*Fs)(nil) _ fs.Object = (*Object)(nil) _ fs.MimeTyper = (*Object)(nil) _ fs.Metadataer = (*Object)(nil) ) rclone-v1.71.0/backend/jottacloud/jottacloud_internal_test.go000066400000000000000000000055031505210326400244420ustar00rootroot00000000000000package jottacloud import ( "context" "crypto/md5" "fmt" "io" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" "github.com/rclone/rclone/lib/random" "github.com/rclone/rclone/lib/readers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestReadMD5(t *testing.T) { // Check readMD5 for different size and threshold for _, size := range []int64{0, 1024, 10 * 1024, 100 * 1024} { t.Run(fmt.Sprintf("%d", size), func(t *testing.T) { hasher := md5.New() n, err := io.Copy(hasher, readers.NewPatternReader(size)) require.NoError(t, err) assert.Equal(t, n, size) wantMD5 := fmt.Sprintf("%x", hasher.Sum(nil)) for _, threshold := range []int64{512, 1024, 10 * 1024, 20 * 1024} { t.Run(fmt.Sprintf("%d", threshold), func(t *testing.T) { in := readers.NewPatternReader(size) gotMD5, out, cleanup, err := readMD5(in, size, threshold) defer cleanup() require.NoError(t, err) assert.Equal(t, wantMD5, gotMD5) // check md5hash of out hasher := md5.New() n, err := io.Copy(hasher, out) require.NoError(t, err) assert.Equal(t, n, size) outMD5 := fmt.Sprintf("%x", hasher.Sum(nil)) assert.Equal(t, wantMD5, outMD5) }) } }) } } func (f *Fs) InternalTestMetadata(t *testing.T) { ctx := context.Background() contents := random.String(1000) item := fstest.NewItem("test-metadata", contents, fstest.Time("2001-05-06T04:05:06.499999999Z")) utime := time.Now() metadata := fs.Metadata{ "btime": "2009-05-06T04:05:06.499999999Z", "mtime": "2010-06-07T08:09:07.599999999Z", //"utime" - read-only //"content-type" - read-only } obj := fstests.PutTestContentsMetadata(ctx, t, f, &item, false, contents, true, "text/html", metadata) defer func() { assert.NoError(t, obj.Remove(ctx)) }() o := obj.(*Object) gotMetadata, err := o.Metadata(ctx) require.NoError(t, err) for k, v := range metadata { got := gotMetadata[k] switch k { case "btime": assert.True(t, fstest.Time(v).Truncate(f.Precision()).Equal(fstest.Time(got)), fmt.Sprintf("btime not equal want %v got %v", v, got)) case "mtime": assert.True(t, fstest.Time(v).Truncate(f.Precision()).Equal(fstest.Time(got)), fmt.Sprintf("btime not equal want %v got %v", v, got)) case "utime": gotUtime := fstest.Time(got) dt := gotUtime.Sub(utime) assert.True(t, dt < time.Minute && dt > -time.Minute, fmt.Sprintf("utime more than 1 minute out want %v got %v delta %v", utime, gotUtime, dt)) assert.True(t, fstest.Time(v).Equal(fstest.Time(got))) case "content-type": assert.True(t, o.MimeType(ctx) == got) default: assert.Equal(t, v, got, k) } } } func (f *Fs) InternalTest(t *testing.T) { t.Run("Metadata", f.InternalTestMetadata) } var _ fstests.InternalTester = (*Fs)(nil) rclone-v1.71.0/backend/jottacloud/jottacloud_test.go000066400000000000000000000005741505210326400225510ustar00rootroot00000000000000// Test Box filesystem interface package jottacloud_test import ( "testing" "github.com/rclone/rclone/backend/jottacloud" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestJottacloud:", NilObject: (*jottacloud.Object)(nil), }) } rclone-v1.71.0/backend/koofr/000077500000000000000000000000001505210326400157555ustar00rootroot00000000000000rclone-v1.71.0/backend/koofr/koofr.go000066400000000000000000000450231505210326400174300ustar00rootroot00000000000000// Package koofr provides an interface to the Koofr storage system. package koofr import ( "context" "encoding/base64" "errors" "fmt" "io" "net/http" "path" "strings" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/encoder" httpclient "github.com/koofr/go-httpclient" koofrclient "github.com/koofr/go-koofrclient" ) // Register Fs with rclone func init() { fs.Register(&fs.RegInfo{ Name: "koofr", Description: "Koofr, Digi Storage and other Koofr-compatible storage providers", NewFs: NewFs, Options: []fs.Option{{ Name: fs.ConfigProvider, Help: "Choose your storage provider.", // NOTE if you add a new provider here, then add it in the // setProviderDefaults() function and update options accordingly Examples: []fs.OptionExample{{ Value: "koofr", Help: "Koofr, https://app.koofr.net/", }, { Value: "digistorage", Help: "Digi Storage, https://storage.rcs-rds.ro/", }, { Value: "other", Help: "Any other Koofr API compatible storage service", }}, }, { Name: "endpoint", Help: "The Koofr API endpoint to use.", Provider: "other", Required: true, }, { Name: "mountid", Help: "Mount ID of the mount to use.\n\nIf omitted, the primary mount is used.", Advanced: true, }, { Name: "setmtime", Help: "Does the backend support setting modification time.\n\nSet this to false if you use a mount ID that points to a Dropbox or Amazon Drive backend.", Default: true, Advanced: true, }, { Name: "user", Help: "Your user name.", Required: true, Sensitive: true, }, { Name: "password", Help: "Your password for rclone generate one at https://app.koofr.net/app/admin/preferences/password.", Provider: "koofr", IsPassword: true, Required: true, }, { Name: "password", Help: "Your password for rclone generate one at https://storage.rcs-rds.ro/app/admin/preferences/password.", Provider: "digistorage", IsPassword: true, Required: true, }, { Name: "password", Help: "Your password for rclone (generate one at your service's settings page).", Provider: "other", IsPassword: true, Required: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, // Encode invalid UTF-8 bytes as json doesn't handle them properly. Default: (encoder.Display | encoder.EncodeBackSlash | encoder.EncodeInvalidUtf8), }}, }) } // Options represent the configuration of the Koofr backend type Options struct { Provider string `config:"provider"` Endpoint string `config:"endpoint"` MountID string `config:"mountid"` User string `config:"user"` Password string `config:"password"` SetMTime bool `config:"setmtime"` Enc encoder.MultiEncoder `config:"encoding"` } // An Fs is a representation of a remote Koofr Fs type Fs struct { name string mountID string root string opt Options features *fs.Features client *koofrclient.KoofrClient } // An Object on the remote Koofr Fs type Object struct { fs *Fs remote string info koofrclient.FileInfo } func base(pth string) string { rv := path.Base(pth) if rv == "" || rv == "." { rv = "/" } return rv } func dir(pth string) string { rv := path.Dir(pth) if rv == "" || rv == "." { rv = "/" } return rv } // String returns a string representation of the remote Object func (o *Object) String() string { return o.remote } // Remote returns the remote path of the Object, relative to Fs root func (o *Object) Remote() string { return o.remote } // ModTime returns the modification time of the Object func (o *Object) ModTime(ctx context.Context) time.Time { return time.Unix(o.info.Modified/1000, (o.info.Modified%1000)*1000*1000) } // Size return the size of the Object in bytes func (o *Object) Size() int64 { return o.info.Size } // Fs returns a reference to the Koofr Fs containing the Object func (o *Object) Fs() fs.Info { return o.fs } // Hash returns an MD5 hash of the Object func (o *Object) Hash(ctx context.Context, typ hash.Type) (string, error) { if typ == hash.MD5 { return o.info.Hash, nil } return "", nil } // fullPath returns full path of the remote Object (including Fs root) func (o *Object) fullPath() string { return o.fs.fullPath(o.remote) } // Storable returns true if the Object is storable func (o *Object) Storable() bool { return true } // SetModTime is not supported func (o *Object) SetModTime(ctx context.Context, mtime time.Time) error { return fs.ErrorCantSetModTimeWithoutDelete } // Open opens the Object for reading func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { var sOff, eOff int64 = 0, -1 fs.FixRangeOption(options, o.Size()) for _, option := range options { switch x := option.(type) { case *fs.SeekOption: sOff = x.Offset case *fs.RangeOption: sOff = x.Start eOff = x.End default: if option.Mandatory() { fs.Logf(o, "Unsupported mandatory option: %v", option) } } } if sOff == 0 && eOff < 0 { return o.fs.client.FilesGet(o.fs.mountID, o.fullPath()) } span := &koofrclient.FileSpan{ Start: sOff, End: eOff, } return o.fs.client.FilesGetRange(o.fs.mountID, o.fullPath(), span) } // Update updates the Object contents func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { mtime := src.ModTime(ctx).UnixNano() / 1000 / 1000 putopts := &koofrclient.PutOptions{ ForceOverwrite: true, NoRename: true, OverwriteIgnoreNonExisting: true, SetModified: &mtime, } fullPath := o.fullPath() dirPath := dir(fullPath) name := base(fullPath) err := o.fs.mkdir(dirPath) if err != nil { return err } info, err := o.fs.client.FilesPutWithOptions(o.fs.mountID, dirPath, name, in, putopts) if err != nil { return err } o.info = *info return nil } // Remove deletes the remote Object func (o *Object) Remove(ctx context.Context) error { return o.fs.client.FilesDelete(o.fs.mountID, o.fullPath()) } // Name returns the name of the Fs func (f *Fs) Name() string { return f.name } // Root returns the root path of the Fs func (f *Fs) Root() string { return f.root } // String returns a string representation of the Fs func (f *Fs) String() string { return "koofr:" + f.mountID + ":" + f.root } // Features returns the optional features supported by this Fs func (f *Fs) Features() *fs.Features { return f.features } // Precision denotes that setting modification times is not supported func (f *Fs) Precision() time.Duration { if !f.opt.SetMTime { return fs.ModTimeNotSupported } return time.Millisecond } // Hashes returns a set of hashes are Provided by the Fs func (f *Fs) Hashes() hash.Set { return hash.Set(hash.MD5) } // fullPath constructs a full, absolute path from an Fs root relative path, func (f *Fs) fullPath(part string) string { return f.opt.Enc.FromStandardPath(path.Join("/", f.root, part)) } func setProviderDefaults(opt *Options) { // handle old, provider-less configs if opt.Provider == "" { if opt.Endpoint == "" || strings.HasPrefix(opt.Endpoint, "https://app.koofr.net") { opt.Provider = "koofr" } else if strings.HasPrefix(opt.Endpoint, "https://storage.rcs-rds.ro") { opt.Provider = "digistorage" } else { opt.Provider = "other" } } // now assign an endpoint if opt.Provider == "koofr" { opt.Endpoint = "https://app.koofr.net" } else if opt.Provider == "digistorage" { opt.Endpoint = "https://storage.rcs-rds.ro" } } // NewFs constructs a new filesystem given a root path and rclone configuration options func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (ff fs.Fs, err error) { opt := new(Options) err = configstruct.Set(m, opt) if err != nil { return nil, err } setProviderDefaults(opt) return NewFsFromOptions(ctx, name, root, opt) } // NewFsFromOptions constructs a new filesystem given a root path and internal configuration options func NewFsFromOptions(ctx context.Context, name, root string, opt *Options) (ff fs.Fs, err error) { pass, err := obscure.Reveal(opt.Password) if err != nil { return nil, err } httpClient := httpclient.New() httpClient.Client = fshttp.NewClient(ctx) client := koofrclient.NewKoofrClientWithHTTPClient(opt.Endpoint, httpClient) basicAuth := fmt.Sprintf("Basic %s", base64.StdEncoding.EncodeToString([]byte(opt.User+":"+pass))) client.HTTPClient.Headers.Set("Authorization", basicAuth) mounts, err := client.Mounts() if err != nil { return nil, err } f := &Fs{ name: name, root: root, opt: *opt, client: client, } f.features = (&fs.Features{ CaseInsensitive: true, DuplicateFiles: false, BucketBased: false, CanHaveEmptyDirectories: true, }).Fill(ctx, f) for _, m := range mounts { if opt.MountID != "" { if m.Id == opt.MountID { f.mountID = m.Id break } } else if m.IsPrimary { f.mountID = m.Id break } } if f.mountID == "" { if opt.MountID == "" { return nil, errors.New("failed to find primary mount") } return nil, errors.New("failed to find mount " + opt.MountID) } rootFile, err := f.client.FilesInfo(f.mountID, f.opt.Enc.FromStandardPath("/"+f.root)) if err == nil && rootFile.Type != "dir" { f.root = dir(f.root) err = fs.ErrorIsFile } else { err = nil } return f, err } // List returns a list of items in a directory func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { files, err := f.client.FilesList(f.mountID, f.fullPath(dir)) if err != nil { return nil, translateErrorsDir(err) } entries = make([]fs.DirEntry, len(files)) for i, file := range files { remote := path.Join(dir, f.opt.Enc.ToStandardName(file.Name)) if file.Type == "dir" { entries[i] = fs.NewDir(remote, time.Time{}) } else { entries[i] = &Object{ fs: f, info: file, remote: remote, } } } return entries, nil } // NewObject creates a new remote Object for a given remote path func (f *Fs) NewObject(ctx context.Context, remote string) (obj fs.Object, err error) { info, err := f.client.FilesInfo(f.mountID, f.fullPath(remote)) if err != nil { return nil, translateErrorsObject(err) } if info.Type == "dir" { return nil, fs.ErrorIsDir } return &Object{ fs: f, info: info, remote: remote, }, nil } // Put updates a remote Object func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (obj fs.Object, err error) { mtime := src.ModTime(ctx).UnixNano() / 1000 / 1000 putopts := &koofrclient.PutOptions{ ForceOverwrite: true, NoRename: true, OverwriteIgnoreNonExisting: true, SetModified: &mtime, } fullPath := f.fullPath(src.Remote()) dirPath := dir(fullPath) name := base(fullPath) err = f.mkdir(dirPath) if err != nil { return nil, err } info, err := f.client.FilesPutWithOptions(f.mountID, dirPath, name, in, putopts) if err != nil { return nil, translateErrorsObject(err) } return &Object{ fs: f, info: *info, remote: src.Remote(), }, nil } // PutStream updates a remote Object with a stream of unknown size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } // isBadRequest is a predicate which holds true iff the error returned was // HTTP status 400 func isBadRequest(err error) bool { switch err := err.(type) { case httpclient.InvalidStatusError: if err.Got == http.StatusBadRequest { return true } } return false } // translateErrorsDir translates koofr errors to rclone errors (for a dir // operation) func translateErrorsDir(err error) error { switch err := err.(type) { case httpclient.InvalidStatusError: if err.Got == http.StatusNotFound { return fs.ErrorDirNotFound } } return err } // translateErrorsObject translates Koofr errors to rclone errors (for an object operation) func translateErrorsObject(err error) error { switch err := err.(type) { case httpclient.InvalidStatusError: if err.Got == http.StatusNotFound { return fs.ErrorObjectNotFound } } return err } // mkdir creates a directory at the given remote path. Creates ancestors if // necessary func (f *Fs) mkdir(fullPath string) error { if fullPath == "/" { return nil } info, err := f.client.FilesInfo(f.mountID, fullPath) if err == nil && info.Type == "dir" { return nil } err = translateErrorsDir(err) if err != nil && err != fs.ErrorDirNotFound { return err } dirs := strings.Split(fullPath, "/") parent := "/" for _, part := range dirs { if part == "" { continue } info, err = f.client.FilesInfo(f.mountID, path.Join(parent, part)) if err != nil || info.Type != "dir" { err = translateErrorsDir(err) if err != nil && err != fs.ErrorDirNotFound { return err } err = f.client.FilesNewFolder(f.mountID, parent, part) if err != nil && !isBadRequest(err) { return err } } parent = path.Join(parent, part) } return nil } // Mkdir creates a directory at the given remote path. Creates ancestors if // necessary func (f *Fs) Mkdir(ctx context.Context, dir string) error { fullPath := f.fullPath(dir) return f.mkdir(fullPath) } // Rmdir removes an (empty) directory at the given remote path func (f *Fs) Rmdir(ctx context.Context, dir string) error { files, err := f.client.FilesList(f.mountID, f.fullPath(dir)) if err != nil { return translateErrorsDir(err) } if len(files) > 0 { return fs.ErrorDirectoryNotEmpty } err = f.client.FilesDelete(f.mountID, f.fullPath(dir)) if err != nil { return translateErrorsDir(err) } return nil } // Copy copies a remote Object to the given path func (f *Fs) Copy(ctx context.Context, src fs.Object, remote string) (fs.Object, error) { dstFullPath := f.fullPath(remote) dstDir := dir(dstFullPath) err := f.mkdir(dstDir) if err != nil { return nil, fs.ErrorCantCopy } mtime := src.ModTime(ctx).UnixNano() / 1000 / 1000 err = f.client.FilesCopy((src.(*Object)).fs.mountID, (src.(*Object)).fs.fullPath((src.(*Object)).remote), f.mountID, dstFullPath, koofrclient.CopyOptions{SetModified: &mtime}) if err != nil { return nil, fs.ErrorCantCopy } return f.NewObject(ctx, remote) } // Move moves a remote Object to the given path func (f *Fs) Move(ctx context.Context, src fs.Object, remote string) (fs.Object, error) { srcObj := src.(*Object) dstFullPath := f.fullPath(remote) dstDir := dir(dstFullPath) err := f.mkdir(dstDir) if err != nil { return nil, fs.ErrorCantMove } err = f.client.FilesMove(srcObj.fs.mountID, srcObj.fs.fullPath(srcObj.remote), f.mountID, dstFullPath) if err != nil { return nil, fs.ErrorCantMove } return f.NewObject(ctx, remote) } // DirMove moves a remote directory to the given path func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { srcFs := src.(*Fs) srcFullPath := srcFs.fullPath(srcRemote) dstFullPath := f.fullPath(dstRemote) if srcFs.mountID == f.mountID && srcFullPath == dstFullPath { return fs.ErrorDirExists } dstDir := dir(dstFullPath) err := f.mkdir(dstDir) if err != nil { return fs.ErrorCantDirMove } err = f.client.FilesMove(srcFs.mountID, srcFullPath, f.mountID, dstFullPath) if err != nil { return fs.ErrorCantDirMove } return nil } // About reports space usage (with a MiB precision) func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { mount, err := f.client.MountsDetails(f.mountID) if err != nil { return nil, err } return &fs.Usage{ Total: fs.NewUsageValue(mount.SpaceTotal * 1024 * 1024), Used: fs.NewUsageValue(mount.SpaceUsed * 1024 * 1024), Trashed: nil, Other: nil, Free: fs.NewUsageValue((mount.SpaceTotal - mount.SpaceUsed) * 1024 * 1024), Objects: nil, }, nil } // Purge purges the complete Fs func (f *Fs) Purge(ctx context.Context) error { err := translateErrorsDir(f.client.FilesDelete(f.mountID, f.fullPath(""))) return err } // linkCreate is a Koofr API request for creating a public link type linkCreate struct { Path string `json:"path"` } // link is a Koofr API response to creating a public link type link struct { ID string `json:"id"` Name string `json:"name"` Path string `json:"path"` Counter int64 `json:"counter"` URL string `json:"url"` ShortURL string `json:"shortUrl"` Hash string `json:"hash"` Host string `json:"host"` HasPassword bool `json:"hasPassword"` Password string `json:"password"` ValidFrom int64 `json:"validFrom"` ValidTo int64 `json:"validTo"` PasswordRequired bool `json:"passwordRequired"` } // createLink makes a Koofr API call to create a public link func createLink(c *koofrclient.KoofrClient, mountID string, path string) (*link, error) { linkCreate := linkCreate{ Path: path, } linkData := link{} request := httpclient.RequestData{ Method: "POST", Path: "/api/v2/mounts/" + mountID + "/links", ExpectedStatus: []int{http.StatusOK, http.StatusCreated}, ReqEncoding: httpclient.EncodingJSON, ReqValue: linkCreate, RespEncoding: httpclient.EncodingJSON, RespValue: &linkData, } _, err := c.Request(&request) if err != nil { return nil, err } return &linkData, nil } // PublicLink creates a public link to the remote path func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (string, error) { linkData, err := createLink(f.client, f.mountID, f.fullPath(remote)) if err != nil { return "", translateErrorsDir(err) } // URL returned by API looks like following: // // https://app.koofr.net/links/35d9fb92-74a3-4930-b4ed-57f123bfb1a6 // // Direct url looks like following: // // https://app.koofr.net/content/links/39a6cc01-3b23-477a-8059-c0fb3b0f15de/files/get?path=%2F // // I am not sure about meaning of "path" parameter; in my experiments // it is always "%2F", and omitting it or putting any other value // results in 404. // // There is one more quirk: direct link to file in / returns that file, // direct link to file somewhere else in hierarchy returns zip archive // with one member. link := linkData.URL link = strings.ReplaceAll(link, "/links", "/content/links") link += "/files/get?path=%2F" return link, nil } rclone-v1.71.0/backend/koofr/koofr_test.go000066400000000000000000000003711505210326400204640ustar00rootroot00000000000000package koofr_test import ( "testing" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestKoofr:", }) } rclone-v1.71.0/backend/linkbox/000077500000000000000000000000001505210326400163035ustar00rootroot00000000000000rclone-v1.71.0/backend/linkbox/linkbox.go000066400000000000000000000573241505210326400203130ustar00rootroot00000000000000// Package linkbox provides an interface to the linkbox.to Cloud storage system. // // API docs: https://www.linkbox.to/api-docs package linkbox /* Extras - PublicLink - NO - sharing doesn't share the actual file, only a page with it on - Move - YES - have Move and Rename file APIs so is possible - MoveDir - NO - probably not possible - have Move but no Rename */ import ( "bytes" "context" "crypto/md5" "fmt" "io" "net/http" "net/url" "path" "regexp" "strconv" "strings" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/dircache" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/rest" ) const ( maxEntitiesPerPage = 1000 minSleep = 200 * time.Millisecond maxSleep = 2 * time.Second pacerBurst = 1 linkboxAPIURL = "https://www.linkbox.to/api/open/" rootID = "0" // ID of root directory ) func init() { fsi := &fs.RegInfo{ Name: "linkbox", Description: "Linkbox", NewFs: NewFs, Options: []fs.Option{{ Name: "token", Help: "Token from https://www.linkbox.to/admin/account", Sensitive: true, Required: true, }}, } fs.Register(fsi) } // Options defines the configuration for this backend type Options struct { Token string `config:"token"` } // Fs stores the interface to the remote Linkbox files type Fs struct { name string root string opt Options // options for this backend features *fs.Features // optional features ci *fs.ConfigInfo // global config srv *rest.Client // the connection to the server dirCache *dircache.DirCache // Map of directory path to directory id pacer *fs.Pacer } // Object is a remote object that has been stat'd (so it exists, but is not necessarily open for reading) type Object struct { fs *Fs remote string size int64 modTime time.Time contentType string fullURL string dirID int64 itemID string // and these IDs are for files id int64 // these IDs appear to apply to directories isDir bool } // NewFs creates a new Fs object from the name and root. It connects to // the host specified in the config file. func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { root = strings.Trim(root, "/") // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } ci := fs.GetConfig(ctx) f := &Fs{ name: name, opt: *opt, root: root, ci: ci, srv: rest.NewClient(fshttp.NewClient(ctx)), pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep))), } f.dirCache = dircache.New(root, rootID, f) f.features = (&fs.Features{ CanHaveEmptyDirectories: true, CaseInsensitive: true, }).Fill(ctx, f) // Find the current root err = f.dirCache.FindRoot(ctx, false) if err != nil { // Assume it is a file newRoot, remote := dircache.SplitPath(root) tempF := *f tempF.dirCache = dircache.New(newRoot, rootID, &tempF) tempF.root = newRoot // Make new Fs which is the parent err = tempF.dirCache.FindRoot(ctx, false) if err != nil { // No root so return old f return f, nil } _, err := tempF.NewObject(ctx, remote) if err != nil { if err == fs.ErrorObjectNotFound { // File doesn't exist so return old f return f, nil } return nil, err } f.features.Fill(ctx, &tempF) // XXX: update the old f here instead of returning tempF, since // `features` were already filled with functions having *f as a receiver. // See https://github.com/rclone/rclone/issues/2182 f.dirCache = tempF.dirCache f.root = tempF.root // return an error with an fs which points to the parent return f, fs.ErrorIsFile } return f, nil } type entity struct { Type string `json:"type"` Name string `json:"name"` URL string `json:"url"` Ctime int64 `json:"ctime"` Size int64 `json:"size"` ID int64 `json:"id"` Pid int64 `json:"pid"` ItemID string `json:"item_id"` } // Return true if the entity is a directory func (e *entity) isDir() bool { return e.Type == "dir" || e.Type == "sdir" } type data struct { Entities []entity `json:"list"` } type fileSearchRes struct { response SearchData data `json:"data"` } // Set an object info from an entity func (o *Object) set(e *entity) { o.modTime = time.Unix(e.Ctime, 0) o.contentType = e.Type o.size = e.Size o.fullURL = e.URL o.isDir = e.isDir() o.id = e.ID o.itemID = e.ItemID o.dirID = e.Pid } // Call linkbox with the query in opts and return result // // This will be checked for error and an error will be returned if Status != 1 func getUnmarshaledResponse(ctx context.Context, f *Fs, opts *rest.Opts, result any) error { err := f.pacer.Call(func() (bool, error) { resp, err := f.srv.CallJSON(ctx, opts, nil, &result) return f.shouldRetry(ctx, resp, err) }) if err != nil { return err } responser := result.(responser) if responser.IsError() { return responser } return nil } // list the objects into the function supplied // // If directories is set it only sends directories // User function to process a File item from listAll // // Should return true to finish processing type listAllFn func(*entity) bool // Search is a bit fussy about which characters match // // If the name doesn't match this then do an dir list instead // N.B.: Linkbox doesn't support search by name that is longer than 50 chars var searchOK = regexp.MustCompile(`^[a-zA-Z0-9_ -.]{1,50}$`) // Lists the directory required calling the user function on each item found // // If the user fn ever returns true then it early exits with found = true // // If you set name then search ignores dirID. name is a substring // search also so name="dir" matches "sub dir" also. This filters it // down so it only returns items in dirID func (f *Fs) listAll(ctx context.Context, dirID string, name string, fn listAllFn) (found bool, err error) { var ( pageNumber = 0 numberOfEntities = maxEntitiesPerPage ) name = strings.TrimSpace(name) // search doesn't like spaces if !searchOK.MatchString(name) { // If name isn't good then do an unbounded search name = "" } OUTER: for numberOfEntities == maxEntitiesPerPage { pageNumber++ opts := &rest.Opts{ Method: "GET", RootURL: linkboxAPIURL, Path: "file_search", Parameters: url.Values{ "token": {f.opt.Token}, "name": {name}, "pid": {dirID}, "pageNo": {itoa(pageNumber)}, "pageSize": {itoa64(maxEntitiesPerPage)}, }, } var responseResult fileSearchRes err = getUnmarshaledResponse(ctx, f, opts, &responseResult) if err != nil { return false, fmt.Errorf("getting files failed: %w", err) } numberOfEntities = len(responseResult.SearchData.Entities) for _, entity := range responseResult.SearchData.Entities { if itoa64(entity.Pid) != dirID { // when name != "" this returns from all directories, so ignore not this one continue } if fn(&entity) { found = true break OUTER } } if pageNumber > 100000 { return false, fmt.Errorf("too many results") } } return found, nil } // Turn 64 bit int to string func itoa64(i int64) string { return strconv.FormatInt(i, 10) } // Turn int to string func itoa(i int) string { return itoa64(int64(i)) } func splitDirAndName(remote string) (dir string, name string) { lastSlashPosition := strings.LastIndex(remote, "/") if lastSlashPosition == -1 { dir = "" name = remote } else { dir = remote[:lastSlashPosition] name = remote[lastSlashPosition+1:] } // fs.Debugf(nil, "splitDirAndName remote = {%s}, dir = {%s}, name = {%s}", remote, dir, name) return dir, name } // FindLeaf finds a directory of name leaf in the folder with ID directoryID func (f *Fs) FindLeaf(ctx context.Context, directoryID, leaf string) (directoryIDOut string, found bool, err error) { // Find the leaf in directoryID found, err = f.listAll(ctx, directoryID, leaf, func(entity *entity) bool { if entity.isDir() && strings.EqualFold(entity.Name, leaf) { directoryIDOut = itoa64(entity.ID) return true } return false }) return directoryIDOut, found, err } // Returned from "folder_create" type folderCreateRes struct { response Data struct { DirID int64 `json:"dirId"` } `json:"data"` } // CreateDir makes a directory with dirID as parent and name leaf func (f *Fs) CreateDir(ctx context.Context, dirID, leaf string) (newID string, err error) { // fs.Debugf(f, "CreateDir(%q, %q)\n", dirID, leaf) opts := &rest.Opts{ Method: "GET", RootURL: linkboxAPIURL, Path: "folder_create", Parameters: url.Values{ "token": {f.opt.Token}, "name": {leaf}, "pid": {dirID}, "isShare": {"0"}, "canInvite": {"1"}, "canShare": {"1"}, "withBodyImg": {"1"}, "desc": {""}, }, } response := folderCreateRes{} err = getUnmarshaledResponse(ctx, f, opts, &response) if err != nil { // response status 1501 means that directory already exists if response.Status == 1501 { return newID, fmt.Errorf("couldn't find already created directory: %w", fs.ErrorDirNotFound) } return newID, fmt.Errorf("CreateDir failed: %w", err) } if response.Data.DirID == 0 { return newID, fmt.Errorf("API returned 0 for ID of newly created directory") } return itoa64(response.Data.DirID), nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { // fs.Debugf(f, "List method dir = {%s}", dir) directoryID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { return nil, err } _, err = f.listAll(ctx, directoryID, "", func(entity *entity) bool { remote := path.Join(dir, entity.Name) if entity.isDir() { id := itoa64(entity.ID) modTime := time.Unix(entity.Ctime, 0) d := fs.NewDir(remote, modTime).SetID(id).SetParentID(itoa64(entity.Pid)) entries = append(entries, d) // cache the directory ID for later lookups f.dirCache.Put(remote, id) } else { o := &Object{ fs: f, remote: remote, } o.set(entity) entries = append(entries, o) } return false }) if err != nil { return nil, err } return entries, nil } // get an entity with leaf from dirID func getEntity(ctx context.Context, f *Fs, leaf string, directoryID string, token string) (*entity, error) { var result *entity var resultErr = fs.ErrorObjectNotFound _, err := f.listAll(ctx, directoryID, leaf, func(entity *entity) bool { if strings.EqualFold(entity.Name, leaf) { // fs.Debugf(f, "getObject found entity.Name {%s} name {%s}", entity.Name, name) if entity.isDir() { result = nil resultErr = fs.ErrorIsDir } else { result = entity resultErr = nil } return true } return false }) if err != nil { return nil, err } return result, resultErr } // NewObject finds the Object at remote. If it can't be found // it returns the error ErrorObjectNotFound. // // If remote points to a directory then it should return // ErrorIsDir if possible without doing any extra work, // otherwise ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { leaf, dirID, err := f.dirCache.FindPath(ctx, remote, false) if err != nil { if err == fs.ErrorDirNotFound { return nil, fs.ErrorObjectNotFound } return nil, err } entity, err := getEntity(ctx, f, leaf, dirID, f.opt.Token) if err != nil { return nil, err } o := &Object{ fs: f, remote: remote, } o.set(entity) return o, nil } // Mkdir makes the directory (container, bucket) // // Shouldn't return an error if it already exists func (f *Fs) Mkdir(ctx context.Context, dir string) error { _, err := f.dirCache.FindDir(ctx, dir, true) return err } func (f *Fs) purgeCheck(ctx context.Context, dir string, check bool) error { if check { entries, err := f.List(ctx, dir) if err != nil { return err } if len(entries) != 0 { return fs.ErrorDirectoryNotEmpty } } directoryID, err := f.dirCache.FindDir(ctx, dir, false) if err != nil { return err } opts := &rest.Opts{ Method: "GET", RootURL: linkboxAPIURL, Path: "folder_del", Parameters: url.Values{ "token": {f.opt.Token}, "dirIds": {directoryID}, }, } response := response{} err = getUnmarshaledResponse(ctx, f, opts, &response) if err != nil { // Linkbox has some odd error returns here if response.Status == 403 || response.Status == 500 { return fs.ErrorDirNotFound } return fmt.Errorf("purge error: %w", err) } f.dirCache.FlushDir(dir) if err != nil { return err } return nil } // Rmdir removes the directory (container, bucket) if empty // // Return an error if it doesn't exist or isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, true) } // SetModTime sets modTime on a particular file func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { return fs.ErrorCantSetModTime } // Open opens the file for read. Call Close() on the returned io.ReadCloser func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { var res *http.Response downloadURL := o.fullURL if downloadURL == "" { _, name := splitDirAndName(o.Remote()) newObject, err := getEntity(ctx, o.fs, name, itoa64(o.dirID), o.fs.opt.Token) if err != nil { return nil, err } if newObject == nil { // fs.Debugf(o.fs, "Open entity is empty: name = {%s}", name) return nil, fs.ErrorObjectNotFound } downloadURL = newObject.URL } opts := &rest.Opts{ Method: "GET", RootURL: downloadURL, Options: options, } err := o.fs.pacer.Call(func() (bool, error) { var err error res, err = o.fs.srv.Call(ctx, opts) return o.fs.shouldRetry(ctx, res, err) }) if err != nil { return nil, fmt.Errorf("Open failed: %w", err) } return res.Body, nil } // Update in to the object with the modTime given of the given size // // When called from outside an Fs by rclone, src.Size() will always be >= 0. // But for unknown-sized objects (indicated by src.Size() == -1), Upload should either // return an error or update the object properly (rather than e.g. calling panic). func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { size := src.Size() if size == 0 { return fs.ErrorCantUploadEmptyFiles } else if size < 0 { return fmt.Errorf("can't upload files of unknown length") } remote := o.Remote() // remove the file if it exists if o.itemID != "" { fs.Debugf(o, "Update: removing old file") err = o.Remove(ctx) if err != nil { fs.Errorf(o, "Update: failed to remove existing file: %v", err) } o.itemID = "" } else { tmpObject, err := o.fs.NewObject(ctx, remote) if err == nil { fs.Debugf(o, "Update: removing old file") err = tmpObject.Remove(ctx) if err != nil { fs.Errorf(o, "Update: failed to remove existing file: %v", err) } } } first10m := io.LimitReader(in, 10_485_760) first10mBytes, err := io.ReadAll(first10m) if err != nil { return fmt.Errorf("Update err in reading file: %w", err) } // get upload authorization (step 1) opts := &rest.Opts{ Method: "GET", RootURL: linkboxAPIURL, Path: "get_upload_url", Options: options, Parameters: url.Values{ "token": {o.fs.opt.Token}, "fileMd5ofPre10m": {fmt.Sprintf("%x", md5.Sum(first10mBytes))}, "fileSize": {itoa64(size)}, }, } getFirstStepResult := getUploadURLResponse{} err = getUnmarshaledResponse(ctx, o.fs, opts, &getFirstStepResult) if err != nil { if getFirstStepResult.Status != 600 { return fmt.Errorf("Update err in unmarshaling response: %w", err) } } switch getFirstStepResult.Status { case 1: // upload file using link from first step var res *http.Response var location string // Check to see if we are being redirected opts := &rest.Opts{ Method: "HEAD", RootURL: getFirstStepResult.Data.SignURL, Options: options, NoRedirect: true, } err = o.fs.pacer.CallNoRetry(func() (bool, error) { res, err = o.fs.srv.Call(ctx, opts) return o.fs.shouldRetry(ctx, res, err) }) if res != nil { location = res.Header.Get("Location") if location != "" { // set the URL to the new Location opts.RootURL = location err = nil } } if err != nil { return fmt.Errorf("head upload URL: %w", err) } file := io.MultiReader(bytes.NewReader(first10mBytes), in) opts.Method = "PUT" opts.Body = file opts.ContentLength = &size err = o.fs.pacer.CallNoRetry(func() (bool, error) { res, err = o.fs.srv.Call(ctx, opts) return o.fs.shouldRetry(ctx, res, err) }) if err != nil { return fmt.Errorf("update err in uploading file: %w", err) } _, err = io.ReadAll(res.Body) if err != nil { return fmt.Errorf("update err in reading response: %w", err) } case 600: // Status means that we don't need to upload file // We need only to make second step default: return fmt.Errorf("got unexpected message from Linkbox: %s", getFirstStepResult.Message) } leaf, dirID, err := o.fs.dirCache.FindPath(ctx, remote, false) if err != nil { return err } // create file item at Linkbox (second step) opts = &rest.Opts{ Method: "GET", RootURL: linkboxAPIURL, Path: "folder_upload_file", Options: options, Parameters: url.Values{ "token": {o.fs.opt.Token}, "fileMd5ofPre10m": {fmt.Sprintf("%x", md5.Sum(first10mBytes))}, "fileSize": {itoa64(size)}, "pid": {dirID}, "diyName": {leaf}, }, } getSecondStepResult := getUploadURLResponse{} err = getUnmarshaledResponse(ctx, o.fs, opts, &getSecondStepResult) if err != nil { return fmt.Errorf("Update second step failed: %w", err) } // Try a few times to read the object after upload for eventual consistency const maxTries = 10 var sleepTime = 100 * time.Millisecond var entity *entity for try := 1; try <= maxTries; try++ { entity, err = getEntity(ctx, o.fs, leaf, dirID, o.fs.opt.Token) if err == nil { break } if err != fs.ErrorObjectNotFound { return fmt.Errorf("Update failed to read object: %w", err) } fs.Debugf(o, "Trying to read object after upload: try again in %v (%d/%d)", sleepTime, try, maxTries) time.Sleep(sleepTime) sleepTime *= 2 } if err != nil { return err } o.set(entity) return nil } // Remove this object func (o *Object) Remove(ctx context.Context) error { opts := &rest.Opts{ Method: "GET", RootURL: linkboxAPIURL, Path: "file_del", Parameters: url.Values{ "token": {o.fs.opt.Token}, "itemIds": {o.itemID}, }, } requestResult := getUploadURLResponse{} err := getUnmarshaledResponse(ctx, o.fs, opts, &requestResult) if err != nil { return fmt.Errorf("could not Remove: %w", err) } return nil } // ModTime returns the modification time of the remote http file func (o *Object) ModTime(ctx context.Context) time.Time { return o.modTime } // Remote the name of the remote HTTP file, relative to the fs root func (o *Object) Remote() string { return o.remote } // Size returns the size in bytes of the remote http file func (o *Object) Size() int64 { return o.size } // String returns the URL to the remote HTTP file func (o *Object) String() string { if o == nil { return "" } return o.remote } // Fs is the filesystem this remote http file object is located within func (o *Object) Fs() fs.Info { return o.fs } // Hash returns "" since HTTP (in Go or OpenSSH) doesn't support remote calculation of hashes func (o *Object) Hash(ctx context.Context, r hash.Type) (string, error) { return "", hash.ErrUnsupported } // Storable returns whether the remote http file is a regular file // (not a directory, symbolic link, block device, character device, named pipe, etc.) func (o *Object) Storable() bool { return true } // Features returns the optional features of this Fs // Info provides a read only interface to information about a filesystem. func (f *Fs) Features() *fs.Features { return f.features } // Name of the remote (as passed into NewFs) // Name returns the configured name of the file system func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String returns a description of the FS func (f *Fs) String() string { return fmt.Sprintf("Linkbox root '%s'", f.root) } // Precision of the ModTimes in this Fs func (f *Fs) Precision() time.Duration { return fs.ModTimeNotSupported } // Hashes returns hash.HashNone to indicate remote hashing is unavailable // Returns the supported hash types of the filesystem func (f *Fs) Hashes() hash.Set { return hash.Set(hash.None) } /* { "data": { "signUrl": "http://xx -- Then CURL PUT your file with sign url " }, "msg": "please use this url to upload (PUT method)", "status": 1 } */ // All messages have these items type response struct { Message string `json:"msg"` Status int `json:"status"` } // IsError returns whether response represents an error func (r *response) IsError() bool { return r.Status != 1 } // Error returns the error state of this response func (r *response) Error() string { return fmt.Sprintf("Linkbox error %d: %s", r.Status, r.Message) } // responser is interface covering the response so we can use it when it is embedded. type responser interface { IsError() bool Error() string } type getUploadURLData struct { SignURL string `json:"signUrl"` } type getUploadURLResponse struct { response Data getUploadURLData `json:"data"` } // Put in to the remote path with the modTime given of the given size // // When called from outside an Fs by rclone, src.Size() will always be >= 0. // But for unknown-sized objects (indicated by src.Size() == -1), Put should either // return an error or upload it properly (rather than e.g. calling panic). // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { o := &Object{ fs: f, remote: src.Remote(), size: src.Size(), } dir, _ := splitDirAndName(src.Remote()) err := f.Mkdir(ctx, dir) if err != nil { return nil, err } err = o.Update(ctx, in, src, options...) return o, err } // Purge all files in the directory specified // // Implement this if you have a way of deleting all the files // quicker than just running Remove() on the result of List() // // Return an error if it doesn't exist func (f *Fs) Purge(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, false) } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 429, // Too Many Requests. 500, // Internal Server Error 502, // Bad Gateway 503, // Service Unavailable 504, // Gateway Timeout 509, // Bandwidth Limit Exceeded } // shouldRetry determines whether a given err rates being retried func (f *Fs) shouldRetry(ctx context.Context, resp *http.Response, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } return fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(resp, retryErrorCodes), err } // DirCacheFlush resets the directory cache - used in testing as an // optional interface func (f *Fs) DirCacheFlush() { f.dirCache.ResetRoot() } // Check the interfaces are satisfied var ( _ fs.Fs = &Fs{} _ fs.Purger = &Fs{} _ fs.DirCacheFlusher = &Fs{} _ fs.Object = &Object{} ) rclone-v1.71.0/backend/linkbox/linkbox_test.go000066400000000000000000000007001505210326400213340ustar00rootroot00000000000000// Test Linkbox filesystem interface package linkbox_test import ( "testing" "github.com/rclone/rclone/backend/linkbox" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestLinkbox:", NilObject: (*linkbox.Object)(nil), // Linkbox doesn't support leading dots for files SkipLeadingDot: true, }) } rclone-v1.71.0/backend/local/000077500000000000000000000000001505210326400157275ustar00rootroot00000000000000rclone-v1.71.0/backend/local/about_unix.go000066400000000000000000000016261505210326400204400ustar00rootroot00000000000000//go:build darwin || dragonfly || freebsd || linux package local import ( "context" "fmt" "os" "syscall" "github.com/rclone/rclone/fs" ) // About gets quota information func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { var s syscall.Statfs_t err := syscall.Statfs(f.root, &s) if err != nil { if os.IsNotExist(err) { return nil, fs.ErrorDirNotFound } return nil, fmt.Errorf("failed to read disk usage: %w", err) } bs := int64(s.Bsize) // nolint: unconvert usage := &fs.Usage{ Total: fs.NewUsageValue(bs * int64(s.Blocks)), //nolint: unconvert // quota of bytes that can be used Used: fs.NewUsageValue(bs * int64(s.Blocks-s.Bfree)), //nolint: unconvert // bytes in use Free: fs.NewUsageValue(bs * int64(s.Bavail)), //nolint: unconvert // bytes which can be uploaded before reaching the quota } return usage, nil } // check interface var _ fs.Abouter = &Fs{} rclone-v1.71.0/backend/local/about_windows.go000066400000000000000000000022341505210326400211430ustar00rootroot00000000000000//go:build windows package local import ( "context" "fmt" "unsafe" "github.com/rclone/rclone/fs" "golang.org/x/sys/windows" ) var getFreeDiskSpace = windows.NewLazySystemDLL("kernel32.dll").NewProc("GetDiskFreeSpaceExW") // About gets quota information func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { var available, total, free int64 root, e := windows.UTF16PtrFromString(f.root) if e != nil { return nil, fmt.Errorf("failed to read disk usage: %w", e) } _, _, e1 := getFreeDiskSpace.Call( uintptr(unsafe.Pointer(root)), uintptr(unsafe.Pointer(&available)), // lpFreeBytesAvailable - for this user uintptr(unsafe.Pointer(&total)), // lpTotalNumberOfBytes uintptr(unsafe.Pointer(&free)), // lpTotalNumberOfFreeBytes ) if e1 != windows.Errno(0) { return nil, fmt.Errorf("failed to read disk usage: %w", e1) } usage := &fs.Usage{ Total: fs.NewUsageValue(total), // quota of bytes that can be used Used: fs.NewUsageValue(total - free), // bytes in use Free: fs.NewUsageValue(available), // bytes which can be uploaded before reaching the quota } return usage, nil } // check interface var _ fs.Abouter = &Fs{} rclone-v1.71.0/backend/local/clone_darwin.go000066400000000000000000000047221505210326400207270ustar00rootroot00000000000000//go:build darwin && cgo // Package local provides a filesystem interface package local import ( "context" "fmt" "path/filepath" "runtime" "github.com/go-darwin/apfs" "github.com/rclone/rclone/fs" ) // Copy src to this remote using server-side copy operations. // // # This is stored with the remote path given // // # It returns the destination Object and a possible error // // 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) (fs.Object, error) { if runtime.GOOS != "darwin" || f.opt.NoClone { return nil, fs.ErrorCantCopy } srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't clone - not same remote type") return nil, fs.ErrorCantCopy } if f.opt.TranslateSymlinks && srcObj.translatedLink { // in --links mode, use cloning only for regular files return nil, fs.ErrorCantCopy } // Fetch metadata if --metadata is in use meta, err := fs.GetMetadataOptions(ctx, f, src, fs.MetadataAsOpenOptions(ctx)) if err != nil { return nil, fmt.Errorf("copy: failed to read metadata: %w", err) } // Create destination dstObj := f.newObject(remote) err = dstObj.mkdirAll() if err != nil { return nil, err } srcPath := srcObj.path if f.opt.FollowSymlinks { // in --copy-links mode, find the real file being pointed to and pass that in instead srcPath, err = filepath.EvalSymlinks(srcPath) if err != nil { return nil, err } } err = Clone(srcPath, f.localPath(remote)) if err != nil { return nil, err } // Set metadata if --metadata is in use if meta != nil { err = dstObj.writeMetadata(meta) if err != nil { return nil, fmt.Errorf("copy: failed to set metadata: %w", err) } } return f.NewObject(ctx, remote) } // Clone uses APFS cloning if possible, otherwise falls back to copying (with full metadata preservation) // note that this is closely related to unix.Clonefile(src, dst, unix.CLONE_NOFOLLOW) but not 100% identical // https://opensource.apple.com/source/copyfile/copyfile-173.40.2/copyfile.c.auto.html func Clone(src, dst string) error { state := apfs.CopyFileStateAlloc() defer func() { if err := apfs.CopyFileStateFree(state); err != nil { fs.Errorf(dst, "free state error: %v", err) } }() cloned, err := apfs.CopyFile(src, dst, state, apfs.COPYFILE_CLONE) fs.Debugf(dst, "isCloned: %v, error: %v", cloned, err) return err } // Check the interfaces are satisfied var ( _ fs.Copier = &Fs{} ) rclone-v1.71.0/backend/local/fadvise_other.go000066400000000000000000000002341505210326400210770ustar00rootroot00000000000000//go:build !linux package local import ( "io" "os" ) func newFadviseReadCloser(o *Object, f *os.File, offset, limit int64) io.ReadCloser { return f } rclone-v1.71.0/backend/local/fadvise_unix.go000066400000000000000000000103751505210326400207500ustar00rootroot00000000000000//go:build linux package local import ( "io" "os" "github.com/rclone/rclone/fs" "golang.org/x/sys/unix" ) // fadvise provides means to automate freeing pages in kernel page cache for // a given file descriptor as the file is sequentially processed (read or // written). // // When copying a file to a remote backend all the file content is read by // kernel and put to page cache to make future reads faster. // This causes memory pressure visible in both memory usage and CPU consumption // and can even cause OOM errors in applications consuming large amounts memory. // // In case of an upload to a remote backend, there is no benefits from caching. // // fadvise would orchestrate calling POSIX_FADV_DONTNEED // // POSIX_FADV_DONTNEED attempts to free cached pages associated // with the specified region. This is useful, for example, while // streaming large files. A program may periodically request the // kernel to free cached data that has already been used, so that // more useful cached pages are not discarded instead. // // Requests to discard partial pages are ignored. It is // preferable to preserve needed data than discard unneeded data. // If the application requires that data be considered for // discarding, then offset and len must be page-aligned. // // The implementation may attempt to write back dirty pages in // the specified region, but this is not guaranteed. Any // unwritten dirty pages will not be freed. If the application // wishes to ensure that dirty pages will be released, it should // call fsync(2) or fdatasync(2) first. type fadvise struct { o *Object fd int lastPos int64 curPos int64 windowSize int64 freePagesCh chan offsetLength doneCh chan struct{} } type offsetLength struct { offset int64 length int64 } const ( defaultAllowPages = 32 defaultWorkerQueueSize = 64 ) func newFadvise(o *Object, fd int, offset int64) *fadvise { f := &fadvise{ o: o, fd: fd, lastPos: offset, curPos: offset, windowSize: int64(os.Getpagesize()) * defaultAllowPages, freePagesCh: make(chan offsetLength, defaultWorkerQueueSize), doneCh: make(chan struct{}), } go f.worker() return f } // sequential configures readahead strategy in Linux kernel. // // Under Linux, POSIX_FADV_NORMAL sets the readahead window to the // default size for the backing device; POSIX_FADV_SEQUENTIAL doubles // this size, and POSIX_FADV_RANDOM disables file readahead entirely. func (f *fadvise) sequential(limit int64) bool { l := int64(0) if limit > 0 { l = limit } if err := unix.Fadvise(f.fd, f.curPos, l, unix.FADV_SEQUENTIAL); err != nil { fs.Debugf(f.o, "fadvise sequential failed on file descriptor %d: %s", f.fd, err) return false } return true } func (f *fadvise) next(n int) { f.curPos += int64(n) f.freePagesIfNeeded() } func (f *fadvise) freePagesIfNeeded() { if f.curPos >= f.lastPos+f.windowSize { f.freePages() } } func (f *fadvise) freePages() { f.freePagesCh <- offsetLength{f.lastPos, f.curPos - f.lastPos} f.lastPos = f.curPos } func (f *fadvise) worker() { for p := range f.freePagesCh { if err := unix.Fadvise(f.fd, p.offset, p.length, unix.FADV_DONTNEED); err != nil { fs.Debugf(f.o, "fadvise dontneed failed on file descriptor %d: %s", f.fd, err) } } close(f.doneCh) } func (f *fadvise) wait() { close(f.freePagesCh) <-f.doneCh } type fadviseReadCloser struct { *fadvise inner io.ReadCloser } // newFadviseReadCloser wraps os.File so that reading from that file would // remove already consumed pages from kernel page cache. // In addition to that it instructs kernel to double the readahead window to // make sequential reads faster. // See also fadvise. func newFadviseReadCloser(o *Object, f *os.File, offset, limit int64) io.ReadCloser { r := fadviseReadCloser{ fadvise: newFadvise(o, int(f.Fd()), offset), inner: f, } // If syscall failed it's likely that the subsequent syscalls to that // file descriptor would also fail. In that case return the provided os.File // pointer. if !r.sequential(limit) { r.wait() return f } return r } func (f fadviseReadCloser) Read(p []byte) (n int, err error) { n, err = f.inner.Read(p) f.next(n) return } func (f fadviseReadCloser) Close() error { f.freePages() f.wait() return f.inner.Close() } rclone-v1.71.0/backend/local/lchmod.go000066400000000000000000000006661505210326400175340ustar00rootroot00000000000000//go:build windows || plan9 || js || linux package local import "os" const haveLChmod = false // lChmod changes the mode of the named file to mode. If the file is a symbolic // link, it changes the link, not the target. If there is an error, // it will be of type *PathError. func lChmod(name string, mode os.FileMode) error { // Can't do this safely on this OS - chmoding a symlink always // changes the destination. return nil } rclone-v1.71.0/backend/local/lchmod_unix.go000066400000000000000000000020741505210326400205720ustar00rootroot00000000000000//go:build !windows && !plan9 && !js && !linux package local import ( "os" "syscall" "golang.org/x/sys/unix" ) const haveLChmod = true // syscallMode returns the syscall-specific mode bits from Go's portable mode bits. // // Borrowed from the syscall source since it isn't public. func syscallMode(i os.FileMode) (o uint32) { o |= uint32(i.Perm()) if i&os.ModeSetuid != 0 { o |= syscall.S_ISUID } if i&os.ModeSetgid != 0 { o |= syscall.S_ISGID } if i&os.ModeSticky != 0 { o |= syscall.S_ISVTX } return o } // lChmod changes the mode of the named file to mode. If the file is a symbolic // link, it changes the link, not the target. If there is an error, // it will be of type *PathError. func lChmod(name string, mode os.FileMode) error { // NB linux does not support AT_SYMLINK_NOFOLLOW as a parameter to fchmodat // and returns ENOTSUP if you try, so we don't support this on linux if e := unix.Fchmodat(unix.AT_FDCWD, name, syscallMode(mode), unix.AT_SYMLINK_NOFOLLOW); e != nil { return &os.PathError{Op: "lChmod", Path: name, Err: e} } return nil } rclone-v1.71.0/backend/local/lchtimes.go000066400000000000000000000007231505210326400200700ustar00rootroot00000000000000//go:build plan9 || js package local import ( "time" ) const haveLChtimes = false // lChtimes changes the access and modification times of the named // link, similar to the Unix utime() or utimes() functions. // // The underlying filesystem may truncate or round the values to a // less precise time unit. // If there is an error, it will be of type *PathError. func lChtimes(name string, atime time.Time, mtime time.Time) error { // Does nothing return nil } rclone-v1.71.0/backend/local/lchtimes_unix.go000066400000000000000000000014221505210326400211300ustar00rootroot00000000000000//go:build !windows && !plan9 && !js package local import ( "os" "time" "golang.org/x/sys/unix" ) const haveLChtimes = true // lChtimes changes the access and modification times of the named // link, similar to the Unix utime() or utimes() functions. // // The underlying filesystem may truncate or round the values to a // less precise time unit. // If there is an error, it will be of type *PathError. func lChtimes(name string, atime time.Time, mtime time.Time) error { var utimes [2]unix.Timespec utimes[0] = unix.NsecToTimespec(atime.UnixNano()) utimes[1] = unix.NsecToTimespec(mtime.UnixNano()) if e := unix.UtimesNanoAt(unix.AT_FDCWD, name, utimes[0:], unix.AT_SYMLINK_NOFOLLOW); e != nil { return &os.PathError{Op: "lchtimes", Path: name, Err: e} } return nil } rclone-v1.71.0/backend/local/lchtimes_windows.go000066400000000000000000000007511505210326400216430ustar00rootroot00000000000000//go:build windows package local import ( "time" ) const haveLChtimes = true // lChtimes changes the access and modification times of the named // link, similar to the Unix utime() or utimes() functions. // // The underlying filesystem may truncate or round the values to a // less precise time unit. // If there is an error, it will be of type *PathError. func lChtimes(name string, atime time.Time, mtime time.Time) error { return setTimes(name, atime, mtime, time.Time{}, true) } rclone-v1.71.0/backend/local/local.go000066400000000000000000001411701505210326400173540ustar00rootroot00000000000000// Package local provides a filesystem interface package local import ( "bytes" "context" "errors" "fmt" "io" "os" "path" "path/filepath" "runtime" "strings" "sync" "sync/atomic" "time" "unicode/utf8" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/file" "github.com/rclone/rclone/lib/readers" "golang.org/x/text/unicode/norm" ) // Constants const ( devUnset = 0xdeadbeefcafebabe // a device id meaning it is unset useReadDir = (runtime.GOOS == "windows" || runtime.GOOS == "plan9") // these OSes read FileInfos directly ) // timeType allows the user to choose what exactly ModTime() returns type timeType = fs.Enum[timeTypeChoices] const ( mTime timeType = iota aTime bTime cTime ) type timeTypeChoices struct{} func (timeTypeChoices) Choices() []string { return []string{ mTime: "mtime", aTime: "atime", bTime: "btime", cTime: "ctime", } } // Register with Fs func init() { fsi := &fs.RegInfo{ Name: "local", Description: "Local Disk", NewFs: NewFs, CommandHelp: commandHelp, MetadataInfo: &fs.MetadataInfo{ System: systemMetadataInfo, Help: `Depending on which OS is in use the local backend may return only some of the system metadata. Setting system metadata is supported on all OSes but setting user metadata is only supported on linux, freebsd, netbsd, macOS and Solaris. It is **not** supported on Windows yet ([see pkg/attrs#47](https://github.com/pkg/xattr/issues/47)). User metadata is stored as extended attributes (which may not be supported by all file systems) under the "user.*" prefix. Metadata is supported on files and directories. `, }, Options: []fs.Option{ { Name: "nounc", Help: "Disable UNC (long path names) conversion on Windows.", Default: false, Advanced: runtime.GOOS != "windows", Examples: []fs.OptionExample{{ Value: "true", Help: "Disables long file names.", }}, }, { Name: "copy_links", Help: "Follow symlinks and copy the pointed to item.", Default: false, NoPrefix: true, ShortOpt: "L", Advanced: true, }, { Name: "links", Help: "Translate symlinks to/from regular files with a '" + fs.LinkSuffix + "' extension for the local backend.", Default: false, Advanced: true, }, { Name: "skip_links", Help: `Don't warn about skipped symlinks. This flag disables warning messages on skipped symlinks or junction points, as you explicitly acknowledge that they should be skipped.`, Default: false, NoPrefix: true, Advanced: true, }, { Name: "zero_size_links", Help: `Assume the Stat size of links is zero (and read them instead) (deprecated). Rclone used to use the Stat size of links as the link size, but this fails in quite a few places: - Windows - On some virtual filesystems (such ash LucidLink) - Android So rclone now always reads the link. `, Default: false, Advanced: true, }, { Name: "unicode_normalization", Help: `Apply unicode NFC normalization to paths and filenames. This flag can be used to normalize file names into unicode NFC form that are read from the local filesystem. Rclone does not normally touch the encoding of file names it reads from the file system. This can be useful when using macOS as it normally provides decomposed (NFD) unicode which in some language (eg Korean) doesn't display properly on some OSes. Note that rclone compares filenames with unicode normalization in the sync routine so this flag shouldn't normally be used.`, Default: false, Advanced: true, }, { Name: "no_check_updated", Help: `Don't check to see if the files change during upload. Normally rclone checks the size and modification time of files as they are being uploaded and aborts with a message which starts "can't copy - source file is being updated" if the file changes during upload. However on some file systems this modification time check may fail (e.g. [Glusterfs #2206](https://github.com/rclone/rclone/issues/2206)) so this check can be disabled with this flag. If this flag is set, rclone will use its best efforts to transfer a file which is being updated. If the file is only having things appended to it (e.g. a log) then rclone will transfer the log file with the size it had the first time rclone saw it. If the file is being modified throughout (not just appended to) then the transfer may fail with a hash check failure. In detail, once the file has had stat() called on it for the first time we: - Only transfer the size that stat gave - Only checksum the size that stat gave - Don't update the stat info for the file **NB** do not use this flag on a Windows Volume Shadow (VSS). For some unknown reason, files in a VSS sometimes show different sizes from the directory listing (where the initial stat value comes from on Windows) and when stat is called on them directly. Other copy tools always use the direct stat value and setting this flag will disable that. `, Default: false, Advanced: true, }, { Name: "one_file_system", Help: "Don't cross filesystem boundaries (unix/macOS only).", Default: false, NoPrefix: true, ShortOpt: "x", Advanced: true, }, { Name: "case_sensitive", Help: `Force the filesystem to report itself as case sensitive. Normally the local backend declares itself as case insensitive on Windows/macOS and case sensitive for everything else. Use this flag to override the default choice.`, Default: false, Advanced: true, }, { Name: "case_insensitive", Help: `Force the filesystem to report itself as case insensitive. Normally the local backend declares itself as case insensitive on Windows/macOS and case sensitive for everything else. Use this flag to override the default choice.`, Default: false, Advanced: true, }, { Name: "no_clone", Help: `Disable reflink cloning for server-side copies. Normally, for local-to-local transfers, rclone will "clone" the file when possible, and fall back to "copying" only when cloning is not supported. Cloning creates a shallow copy (or "reflink") which initially shares blocks with the original file. Unlike a "hardlink", the two files are independent and neither will affect the other if subsequently modified. Cloning is usually preferable to copying, as it is much faster and is deduplicated by default (i.e. having two identical files does not consume more storage than having just one.) However, for use cases where data redundancy is preferable, --local-no-clone can be used to disable cloning and force "deep" copies. Currently, cloning is only supported when using APFS on macOS (support for other platforms may be added in the future.)`, Default: false, Advanced: true, }, { Name: "no_preallocate", Help: `Disable preallocation of disk space for transferred files. Preallocation of disk space helps prevent filesystem fragmentation. However, some virtual filesystem layers (such as Google Drive File Stream) may incorrectly set the actual file size equal to the preallocated space, causing checksum and file size checks to fail. Use this flag to disable preallocation.`, Default: false, Advanced: true, }, { Name: "no_sparse", Help: `Disable sparse files for multi-thread downloads. On Windows platforms rclone will make sparse files when doing multi-thread downloads. This avoids long pauses on large files where the OS zeros the file. However sparse files may be undesirable as they cause disk fragmentation and can be slow to work with.`, Default: false, Advanced: true, }, { Name: "no_set_modtime", Help: `Disable setting modtime. Normally rclone updates modification time of files after they are done uploading. This can cause permissions issues on Linux platforms when the user rclone is running as does not own the file uploaded, such as when copying to a CIFS mount owned by another user. If this option is enabled, rclone will no longer update the modtime after copying a file.`, Default: false, Advanced: true, }, { Name: "time_type", Help: `Set what kind of time is returned. Normally rclone does all operations on the mtime or Modification time. If you set this flag then rclone will return the Modified time as whatever you set here. So if you use "rclone lsl --local-time-type ctime" then you will see ctimes in the listing. If the OS doesn't support returning the time_type specified then rclone will silently replace it with the modification time which all OSes support. - mtime is supported by all OSes - atime is supported on all OSes except: plan9, js - btime is only supported on: Windows, macOS, freebsd, netbsd - ctime is supported on all Oses except: Windows, plan9, js Note that setting the time will still set the modified time so this is only useful for reading. `, Default: mTime, Advanced: true, Examples: []fs.OptionExample{{ Value: mTime.String(), Help: "The last modification time.", }, { Value: aTime.String(), Help: "The last access time.", }, { Value: bTime.String(), Help: "The creation time.", }, { Value: cTime.String(), Help: "The last status change time.", }}, }, { Name: "hashes", Help: `Comma separated list of supported checksum types.`, Default: fs.CommaSepList{}, Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, Default: encoder.OS, }, }, } fs.Register(fsi) } // Options defines the configuration for this backend type Options struct { FollowSymlinks bool `config:"copy_links"` TranslateSymlinks bool `config:"links"` SkipSymlinks bool `config:"skip_links"` UTFNorm bool `config:"unicode_normalization"` NoCheckUpdated bool `config:"no_check_updated"` NoUNC bool `config:"nounc"` OneFileSystem bool `config:"one_file_system"` CaseSensitive bool `config:"case_sensitive"` CaseInsensitive bool `config:"case_insensitive"` NoPreAllocate bool `config:"no_preallocate"` NoSparse bool `config:"no_sparse"` NoSetModTime bool `config:"no_set_modtime"` TimeType timeType `config:"time_type"` Hashes fs.CommaSepList `config:"hashes"` Enc encoder.MultiEncoder `config:"encoding"` NoClone bool `config:"no_clone"` } // Fs represents a local filesystem rooted at root type Fs struct { name string // the name of the remote root string // The root directory (OS path) opt Options // parsed config options features *fs.Features // optional features dev uint64 // device number of root node precisionOk sync.Once // Whether we need to read the precision precision time.Duration // precision of local filesystem warnedMu sync.Mutex // used for locking access to 'warned'. warned map[string]struct{} // whether we have warned about this string xattrSupported atomic.Int32 // whether xattrs are supported // do os.Lstat or os.Stat lstat func(name string) (os.FileInfo, error) objectMetaMu sync.RWMutex // global lock for Object metadata } // Object represents a local filesystem object type Object struct { fs *Fs // The Fs this object is part of remote string // The remote path (encoded path) path string // The local path (OS path) // When using these items the fs.objectMetaMu must be held size int64 // file metadata - always present mode os.FileMode modTime time.Time hashes map[hash.Type]string // Hashes // these are read only and don't need the mutex held translatedLink bool // Is this object a translated link } // Directory represents a local filesystem directory type Directory struct { Object } // ------------------------------------------------------------ var ( errLinksAndCopyLinks = errors.New("can't use -l/--links with -L/--copy-links") errLinksNeedsSuffix = errors.New("need \"" + fs.LinkSuffix + "\" suffix to refer to symlink when using -l/--links") ) // NewFs constructs an Fs from the path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { ci := fs.GetConfig(ctx) // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } // Override --local-links with --links if set if ci.Links { opt.TranslateSymlinks = true } if opt.TranslateSymlinks && opt.FollowSymlinks { return nil, errLinksAndCopyLinks } f := &Fs{ name: name, opt: *opt, warned: make(map[string]struct{}), dev: devUnset, lstat: os.Lstat, } if xattrSupported { f.xattrSupported.Store(1) } f.root = cleanRootPath(root, f.opt.NoUNC, f.opt.Enc) f.features = (&fs.Features{ CaseInsensitive: f.caseInsensitive(), CanHaveEmptyDirectories: true, IsLocal: true, SlowHash: true, ReadMetadata: true, WriteMetadata: true, ReadDirMetadata: true, WriteDirMetadata: true, WriteDirSetModTime: true, UserDirMetadata: xattrSupported, // can only R/W general purpose metadata if xattrs are supported DirModTimeUpdatesOnWrite: true, UserMetadata: xattrSupported, // can only R/W general purpose metadata if xattrs are supported FilterAware: true, PartialUploads: true, }).Fill(ctx, f) if opt.FollowSymlinks { f.lstat = os.Stat } if opt.NoClone { // Disable server-side copy when --local-no-clone is set f.features.Copy = nil } // Check to see if this points to a file fi, err := f.lstat(f.root) if err == nil { f.dev = readDevice(fi, f.opt.OneFileSystem) } // Check to see if this is a .rclonelink if not found hasLinkSuffix := strings.HasSuffix(f.root, fs.LinkSuffix) if hasLinkSuffix && opt.TranslateSymlinks && os.IsNotExist(err) { fi, err = f.lstat(strings.TrimSuffix(f.root, fs.LinkSuffix)) } if err == nil && f.isRegular(fi.Mode()) { // Handle the odd case, that a symlink was specified by name without the link suffix if !hasLinkSuffix && opt.TranslateSymlinks && fi.Mode()&os.ModeSymlink != 0 { return nil, errLinksNeedsSuffix } // It is a file, so use the parent as the root f.root = filepath.Dir(f.root) // return an error with an fs which points to the parent return f, fs.ErrorIsFile } return f, nil } // Determine whether a file is a 'regular' file, // Symlinks are regular files, only if the TranslateSymlink // option is in-effect func (f *Fs) isRegular(mode os.FileMode) bool { if !f.opt.TranslateSymlinks { return mode.IsRegular() } // fi.Mode().IsRegular() tests that all mode bits are zero // Since symlinks are accepted, test that all other bits are zero, // except the symlink bit return mode&os.ModeType&^os.ModeSymlink == 0 } // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.opt.Enc.ToStandardPath(filepath.ToSlash(f.root)) } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("Local file system at %s", f.Root()) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // caseInsensitive returns whether the remote is case insensitive or not func (f *Fs) caseInsensitive() bool { if f.opt.CaseSensitive { return false } if f.opt.CaseInsensitive { return true } // FIXME not entirely accurate since you can have case // sensitive Fses on darwin and case insensitive Fses on linux. // Should probably check but that would involve creating a // file in the remote to be most accurate which probably isn't // desirable. return runtime.GOOS == "windows" || runtime.GOOS == "darwin" } // translateLink checks whether the remote is a translated link // and returns a new path, removing the suffix as needed, // It also returns whether this is a translated link at all // // for regular files, localPath is returned unchanged func translateLink(remote, localPath string) (newLocalPath string, isTranslatedLink bool) { isTranslatedLink = strings.HasSuffix(remote, fs.LinkSuffix) newLocalPath = strings.TrimSuffix(localPath, fs.LinkSuffix) return newLocalPath, isTranslatedLink } // newObject makes a half completed Object func (f *Fs) newObject(remote string) *Object { translatedLink := false localPath := f.localPath(remote) if f.opt.TranslateSymlinks { // Possibly receive a new name for localPath localPath, translatedLink = translateLink(remote, localPath) } return &Object{ fs: f, remote: remote, path: localPath, translatedLink: translatedLink, } } // Return an Object from a path // // May return nil if an error occurred func (f *Fs) newObjectWithInfo(remote string, info os.FileInfo) (fs.Object, error) { o := f.newObject(remote) if info != nil { o.setMetadata(info) } else { err := o.lstat() if err != nil { if os.IsNotExist(err) { return nil, fs.ErrorObjectNotFound } if os.IsPermission(err) { return nil, fs.ErrorPermissionDenied } return nil, err } // Handle the odd case, that a symlink was specified by name without the link suffix if o.fs.opt.TranslateSymlinks && o.mode&os.ModeSymlink != 0 && !o.translatedLink { return nil, fs.ErrorObjectNotFound } } if o.mode.IsDir() { return nil, fs.ErrorIsDir } return o, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return f.newObjectWithInfo(remote, nil) } // Create new directory object from the info passed in func (f *Fs) newDirectory(dir string, fi os.FileInfo) *Directory { o := f.newObject(dir) o.setMetadata(fi) return &Directory{ Object: *o, } } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { filter, useFilter := filter.GetConfig(ctx), filter.GetUseFilter(ctx) fsDirPath := f.localPath(dir) _, err = os.Stat(fsDirPath) if err != nil { return nil, fs.ErrorDirNotFound } fd, err := os.Open(fsDirPath) if err != nil { isPerm := os.IsPermission(err) err = fmt.Errorf("failed to open directory %q: %w", dir, err) fs.Errorf(dir, "%v", err) if isPerm { _ = accounting.Stats(ctx).Error(fserrors.NoRetryError(err)) err = nil // ignore error but fail sync } return nil, err } defer func() { cerr := fd.Close() if cerr != nil && err == nil { err = fmt.Errorf("failed to close directory %q:: %w", dir, cerr) } }() for { var fis []os.FileInfo if useReadDir { // Windows and Plan9 read the directory entries with the stat information in which // shouldn't fail because of unreadable entries. fis, err = fd.Readdir(1024) if err == io.EOF && len(fis) == 0 { break } } else { // For other OSes we read the names only (which shouldn't fail) then stat the // individual ourselves so we can log errors but not fail the directory read. var names []string names, err = fd.Readdirnames(1024) if err == io.EOF && len(names) == 0 { break } if err == nil { for _, name := range names { namepath := filepath.Join(fsDirPath, name) fi, fierr := os.Lstat(namepath) if os.IsNotExist(fierr) { // skip entry removed by a concurrent goroutine continue } if fierr != nil { // Don't report errors on any file names that are excluded if useFilter { newRemote := f.cleanRemote(dir, name) if !filter.IncludeRemote(newRemote) { continue } } fierr = fmt.Errorf("failed to get info about directory entry %q: %w", namepath, fierr) fs.Errorf(dir, "%v", fierr) _ = accounting.Stats(ctx).Error(fserrors.NoRetryError(fierr)) // fail the sync continue } fis = append(fis, fi) } } } if err != nil { return nil, fmt.Errorf("failed to read directory entry: %w", err) } for _, fi := range fis { 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 { localPath := filepath.Join(fsDirPath, name) fi, err = os.Stat(localPath) // Quietly skip errors on excluded files and directories if err != nil && useFilter && !filter.IncludeRemote(newRemote) { continue } if os.IsNotExist(err) || isCircularSymlinkError(err) { // Skip bad symlinks and circular symlinks err = fserrors.NoRetryError(fmt.Errorf("symlink: %w", err)) fs.Errorf(newRemote, "Listing error: %v", err) err = accounting.Stats(ctx).Error(err) continue } if err != nil { return nil, err } mode = fi.Mode() } 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) { 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 { newRemote += fs.LinkSuffix } // Don't include non directory if not included // we leave directory filtering to the layer above if useFilter && !filter.IncludeRemote(newRemote) { continue } fso, err := f.newObjectWithInfo(newRemote, fi) if err != nil { return nil, err } if fso.Storable() { entries = append(entries, fso) } } } } return entries, nil } func (f *Fs) cleanRemote(dir, filename string) (remote string) { if f.opt.UTFNorm { filename = norm.NFC.String(filename) } remote = path.Join(dir, f.opt.Enc.ToStandardName(filename)) if !utf8.ValidString(filename) { f.warnedMu.Lock() if _, ok := f.warned[remote]; !ok { fs.Logf(f, "Replacing invalid UTF-8 characters in %q", remote) f.warned[remote] = struct{}{} } f.warnedMu.Unlock() } return } func (f *Fs) localPath(name string) string { return filepath.Join(f.root, filepath.FromSlash(f.opt.Enc.FromStandardPath(name))) } // Put the Object to the local filesystem func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { // Temporary Object under construction - info filled in by Update() o := f.newObject(src.Remote()) err := o.Update(ctx, in, src, options...) if err != nil { return nil, err } return o, nil } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } // Mkdir creates the directory if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) error { localPath := f.localPath(dir) err := file.MkdirAll(localPath, 0777) if err != nil { return err } if dir == "" { fi, err := f.lstat(localPath) if err != nil { return err } f.dev = readDevice(fi, f.opt.OneFileSystem) } return nil } // DirSetModTime sets the directory modtime for dir func (f *Fs) DirSetModTime(ctx context.Context, dir string, modTime time.Time) error { o := Object{ fs: f, remote: dir, path: f.localPath(dir), } return o.SetModTime(ctx, modTime) } // MkdirMetadata makes the directory passed in as dir. // // It shouldn't return an error if it already exists. // // If the metadata is not nil it is set. // // It returns the directory that was created. func (f *Fs) MkdirMetadata(ctx context.Context, dir string, metadata fs.Metadata) (fs.Directory, error) { // Find and or create the directory localPath := f.localPath(dir) fi, err := f.lstat(localPath) if errors.Is(err, os.ErrNotExist) { err := f.Mkdir(ctx, dir) if err != nil { return nil, fmt.Errorf("mkdir metadata: failed make directory: %w", err) } fi, err = f.lstat(localPath) if err != nil { return nil, fmt.Errorf("mkdir metadata: failed to read info: %w", err) } } else if err != nil { return nil, err } // Create directory object d := f.newDirectory(dir, fi) // Set metadata on the directory object if provided if metadata != nil { err = d.writeMetadata(metadata) if err != nil { return nil, fmt.Errorf("failed to set metadata on directory: %w", err) } // Re-read info now we have finished setting stuff err = d.lstat() if err != nil { return nil, fmt.Errorf("mkdir metadata: failed to re-read info: %w", err) } } return d, nil } // Rmdir removes the directory // // If it isn't empty it will return an error func (f *Fs) Rmdir(ctx context.Context, dir string) error { localPath := f.localPath(dir) if fi, err := os.Stat(localPath); err != nil { return err } else if !fi.IsDir() { return fs.ErrorIsFile } return os.Remove(localPath) } // Precision of the file system func (f *Fs) Precision() (precision time.Duration) { if f.opt.NoSetModTime { return fs.ModTimeNotSupported } f.precisionOk.Do(func() { f.precision = f.readPrecision() }) return f.precision } // Read the precision func (f *Fs) readPrecision() (precision time.Duration) { // Default precision of 1s precision = time.Second // Create temporary file and test it fd, err := os.CreateTemp("", "rclone") if err != nil { // If failed return 1s // fmt.Println("Failed to create temp file", err) return time.Second } path := fd.Name() // fmt.Println("Created temp file", path) err = fd.Close() if err != nil { return time.Second } // Delete it on return defer func() { // fmt.Println("Remove temp file") _ = os.Remove(path) // ignore error }() // Find the minimum duration we can detect for duration := time.Duration(1); duration < time.Second; duration *= 10 { // Current time with delta t := time.Unix(time.Now().Unix(), int64(duration)) err := os.Chtimes(path, t, t) if err != nil { // fmt.Println("Failed to Chtimes", err) break } // Read the actual time back fi, err := os.Stat(path) if err != nil { // fmt.Println("Failed to Stat", err) break } // If it matches - have found the precision // fmt.Println("compare", fi.ModTime(ctx), t) if fi.ModTime().Equal(t) { // fmt.Println("Precision detected as", duration) return duration } } return } // Move src to this remote using server-side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't move - not same remote type") return nil, fs.ErrorCantMove } // Temporary Object under construction dstObj := f.newObject(remote) dstObj.fs.objectMetaMu.RLock() dstObjMode := dstObj.mode dstObj.fs.objectMetaMu.RUnlock() // Check it is a file if it exists err := dstObj.lstat() if os.IsNotExist(err) { // OK } else if err != nil { return nil, err } else if !dstObj.fs.isRegular(dstObjMode) { // It isn't a file return nil, errors.New("can't move file onto non-file") } // Create destination err = dstObj.mkdirAll() if err != nil { return nil, err } // Fetch metadata if --metadata is in use meta, err := fs.GetMetadataOptions(ctx, f, src, fs.MetadataAsOpenOptions(ctx)) if err != nil { return nil, fmt.Errorf("move: failed to read metadata: %w", err) } // Do the move err = os.Rename(srcObj.path, dstObj.path) if os.IsNotExist(err) { // race condition, source was deleted in the meantime return nil, err } else if os.IsPermission(err) { // not enough rights to write to dst return nil, err } else if err != nil { // not quite clear, but probably trying to move a file across file system // boundaries. Copying might still work. fs.Debugf(src, "Can't move: %v: trying copy", err) return nil, fs.ErrorCantMove } // Set metadata if --metadata is in use err = dstObj.writeMetadata(meta) if err != nil { return nil, fmt.Errorf("move: failed to set metadata: %w", err) } // Update the info err = dstObj.lstat() if err != nil { return nil, err } return dstObj, nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } srcPath := srcFs.localPath(srcRemote) dstPath := f.localPath(dstRemote) // Check if destination exists _, err := os.Lstat(dstPath) if !os.IsNotExist(err) { return fs.ErrorDirExists } // Create parent of destination dstParentPath := filepath.Dir(dstPath) err = file.MkdirAll(dstParentPath, 0777) if err != nil { return err } // Do the move err = os.Rename(srcPath, dstPath) if os.IsNotExist(err) { // race condition, source was deleted in the meantime return err } else if os.IsPermission(err) { // not enough rights to write to dst return err } else if err != nil { // not quite clear, but probably trying to move directory across file system // boundaries. Copying might still work. fs.Debugf(src, "Can't move dir: %v: trying copy", err) return fs.ErrorCantDirMove } return nil } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { if len(f.opt.Hashes) > 0 { // Return only configured hashes. // Note: Could have used hash.SupportOnly to limit supported hashes for all hash related features. var supported hash.Set for _, hashName := range f.opt.Hashes { var ht hash.Type if err := ht.Set(hashName); err != nil { fs.Infof(nil, "Invalid token %q in hash string %q", hashName, f.opt.Hashes.String()) } supported.Add(ht) } return supported } return hash.Supported() } var commandHelp = []fs.CommandHelp{ { Name: "noop", Short: "A null operation for testing backend commands", Long: `This is a test command which has some options you can try to change the output.`, Opts: map[string]string{ "echo": "echo the input arguments", "error": "return an error based on option value", }, }, } // Command the backend to run a named command // // The command run is name // args may be used to read arguments from // opts may be used to read optional arguments from // // The result should be capable of being JSON encoded // If it is a string or a []string it will be shown to the user // otherwise it will be JSON encoded and shown to the user like that func (f *Fs) Command(ctx context.Context, name string, arg []string, opt map[string]string) (any, error) { switch name { case "noop": if txt, ok := opt["error"]; ok { if txt == "" { txt = "unspecified error" } return nil, errors.New(txt) } if _, ok := opt["echo"]; ok { out := map[string]any{} out["name"] = name out["arg"] = arg out["opt"] = opt return out, nil } return nil, nil default: return nil, fs.ErrorCommandNotFound } } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Hash returns the requested hash of a file as a lowercase hex string func (o *Object) Hash(ctx context.Context, r hash.Type) (string, error) { if r == hash.None { return "", nil } // Check that the underlying file hasn't changed o.fs.objectMetaMu.RLock() oldtime := o.modTime oldsize := o.size o.fs.objectMetaMu.RUnlock() err := o.lstat() var changed bool if err != nil { if errors.Is(err, os.ErrNotExist) { // If file not found then we assume any accumulated // hashes are OK - this will error on Open changed = true } else { return "", fmt.Errorf("hash: failed to stat: %w", err) } } else { o.fs.objectMetaMu.RLock() changed = !o.modTime.Equal(oldtime) || oldsize != o.size o.fs.objectMetaMu.RUnlock() } o.fs.objectMetaMu.RLock() hashValue, hashFound := o.hashes[r] o.fs.objectMetaMu.RUnlock() if changed || !hashFound { var in io.ReadCloser if !o.translatedLink { var fd *os.File fd, err = file.Open(o.path) if fd != nil { in = newFadviseReadCloser(o, fd, 0, 0) } } else { in, err = o.openTranslatedLink(0, -1) } // If not checking for updates, only read size given if o.fs.opt.NoCheckUpdated { in = readers.NewLimitedReadCloser(in, o.size) } if err != nil { return "", fmt.Errorf("hash: failed to open: %w", err) } var hashes map[hash.Type]string hashes, err = hash.StreamTypes(readers.NewContextReader(ctx, in), hash.NewHashSet(r)) closeErr := in.Close() if err != nil { return "", fmt.Errorf("hash: failed to read: %w", err) } if closeErr != nil { return "", fmt.Errorf("hash: failed to close: %w", closeErr) } hashValue = hashes[r] o.fs.objectMetaMu.Lock() if o.hashes == nil { o.hashes = hashes } else { o.hashes[r] = hashValue } o.fs.objectMetaMu.Unlock() } return hashValue, nil } // Size returns the size of an object in bytes func (o *Object) Size() int64 { o.fs.objectMetaMu.RLock() defer o.fs.objectMetaMu.RUnlock() return o.size } // ModTime returns the modification time of the object func (o *Object) ModTime(ctx context.Context) time.Time { o.fs.objectMetaMu.RLock() defer o.fs.objectMetaMu.RUnlock() return o.modTime } // Set the atime and ltime of the object func (o *Object) setTimes(atime, mtime time.Time) (err error) { if o.translatedLink { err = lChtimes(o.path, atime, mtime) } else { err = os.Chtimes(o.path, atime, mtime) } return err } // SetModTime sets the modification time of the local fs object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { if o.fs.opt.NoSetModTime { return nil } err := o.setTimes(modTime, modTime) if err != nil { return err } // Re-read metadata return o.lstat() } // Storable returns a boolean showing if this object is storable func (o *Object) Storable() bool { o.fs.objectMetaMu.RLock() mode := o.mode o.fs.objectMetaMu.RUnlock() // On Windows items with os.ModeIrregular are likely Junction // points so we treat them as symlinks for the purpose of ignoring them. // https://github.com/golang/go/issues/73827 symlinkFlag := os.ModeSymlink if runtime.GOOS == "windows" { symlinkFlag |= os.ModeIrregular } if mode&symlinkFlag != 0 && !o.fs.opt.TranslateSymlinks { if !o.fs.opt.SkipSymlinks { fs.Logf(o, "Can't follow symlink without -L/--copy-links") } return false } else if mode&(os.ModeNamedPipe|os.ModeSocket|os.ModeDevice) != 0 { fs.Logf(o, "Can't transfer non file/directory") return false } else if mode&os.ModeDir != 0 { // fs.Debugf(o, "Skipping directory") return false } return true } // localOpenFile wraps an io.ReadCloser and updates the md5sum of the // object that is read type localOpenFile struct { o *Object // object that is open in io.ReadCloser // handle we are wrapping hash *hash.MultiHasher // currently accumulating hashes fd *os.File // file object reference } // Read bytes from the object - see io.Reader func (file *localOpenFile) Read(p []byte) (n int, err error) { if !file.o.fs.opt.NoCheckUpdated { // Check if file has the same size and modTime fi, err := file.fd.Stat() if err != nil { return 0, fmt.Errorf("can't read status of source file while transferring: %w", err) } file.o.fs.objectMetaMu.RLock() oldtime := file.o.modTime oldsize := file.o.size file.o.fs.objectMetaMu.RUnlock() if oldsize != fi.Size() { return 0, fserrors.NoLowLevelRetryError(fmt.Errorf("can't copy - source file is being updated (size changed from %d to %d)", oldsize, fi.Size())) } if !oldtime.Equal(readTime(file.o.fs.opt.TimeType, fi)) { return 0, fserrors.NoLowLevelRetryError(fmt.Errorf("can't copy - source file is being updated (mod time changed from %v to %v)", oldtime, fi.ModTime())) } } n, err = file.in.Read(p) if n > 0 { // Hash routines never return an error _, _ = file.hash.Write(p[:n]) } return } // Close the object and update the hashes func (file *localOpenFile) Close() (err error) { err = file.in.Close() if err == nil { if file.hash.Size() == file.o.Size() { file.o.fs.objectMetaMu.Lock() file.o.hashes = file.hash.Sums() file.o.fs.objectMetaMu.Unlock() } } return err } // Returns a ReadCloser() object that contains the contents of a symbolic link func (o *Object) openTranslatedLink(offset, limit int64) (lrc io.ReadCloser, err error) { // Read the link and return the destination it as the contents of the object linkdst, err := os.Readlink(o.path) if err != nil { return nil, err } return readers.NewLimitedReadCloser(io.NopCloser(strings.NewReader(linkdst[offset:])), limit), nil } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { var offset, limit int64 = 0, -1 var hasher *hash.MultiHasher for _, option := range options { switch x := option.(type) { case *fs.SeekOption: offset = x.Offset case *fs.RangeOption: offset, limit = x.Decode(o.Size()) case *fs.HashesOption: if x.Hashes.Count() > 0 { hasher, err = hash.NewMultiHasherTypes(x.Hashes) if err != nil { return nil, err } } default: if option.Mandatory() { fs.Logf(o, "Unsupported mandatory option: %v", option) } } } // Update the file info before we start reading err = o.lstat() if err != nil { return nil, err } // If not checking updated then limit to current size. This means if // file is being extended, readers will read a o.Size() bytes rather // than the new size making for a consistent upload. if limit < 0 && o.fs.opt.NoCheckUpdated { limit = o.size } // Handle a translated link if o.translatedLink { return o.openTranslatedLink(offset, limit) } fd, err := file.Open(o.path) if err != nil { return } wrappedFd := readers.NewLimitedReadCloser(newFadviseReadCloser(o, fd, offset, limit), limit) if offset != 0 { // seek the object _, err = fd.Seek(offset, io.SeekStart) // don't attempt to make checksums return wrappedFd, err } if hasher == nil { // no need to wrap since we don't need checksums return wrappedFd, nil } // Update the hashes as we go along in = &localOpenFile{ o: o, in: wrappedFd, hash: hasher, fd: fd, } return in, nil } // mkdirAll makes all the directories needed to store the object func (o *Object) mkdirAll() error { dir := filepath.Dir(o.path) return file.MkdirAll(dir, 0777) } type nopWriterCloser struct { *bytes.Buffer } func (nwc nopWriterCloser) Close() error { // noop return nil } // Update the object from in with modTime and size func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { var out io.WriteCloser var hasher *hash.MultiHasher for _, option := range options { switch x := option.(type) { case *fs.HashesOption: if x.Hashes.Count() > 0 { hasher, err = hash.NewMultiHasherTypes(x.Hashes) if err != nil { return err } } } } err = o.mkdirAll() if err != nil { return err } // Wipe hashes before update o.clearHashCache() var symlinkData bytes.Buffer // If the object is a regular file, create it. // If it is a translated link, just read in the contents, and // then create a symlink if !o.translatedLink { f, err := file.OpenFile(o.path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666) if err != nil { if runtime.GOOS == "windows" && os.IsPermission(err) { // If permission denied on Windows might be trying to update a // hidden file, in which case try opening without CREATE // See: https://stackoverflow.com/questions/13215716/ioerror-errno-13-permission-denied-when-trying-to-open-hidden-file-in-w-mod f, err = file.OpenFile(o.path, os.O_WRONLY|os.O_TRUNC, 0666) if err != nil { return err } } else { return err } } if !o.fs.opt.NoPreAllocate { // Pre-allocate the file for performance reasons err = file.PreAllocate(src.Size(), f) if err != nil { fs.Debugf(o, "Failed to pre-allocate: %v", err) if err == file.ErrDiskFull { _ = f.Close() return err } } } out = f } else { out = nopWriterCloser{&symlinkData} } // Calculate the hash of the object we are reading as we go along if hasher != nil { in = io.TeeReader(in, hasher) } _, err = io.Copy(out, in) closeErr := out.Close() if err == nil { err = closeErr } if o.translatedLink { if err == nil { // Remove any current symlink or file, if one exists if _, err := os.Lstat(o.path); err == nil { if removeErr := os.Remove(o.path); removeErr != nil { fs.Errorf(o, "Failed to remove previous file: %v", removeErr) return removeErr } } // Use the contents for the copied object to create a symlink err = os.Symlink(symlinkData.String(), o.path) } // only continue if symlink creation succeeded if err != nil { return err } } if err != nil { fs.Logf(o, "Removing partially written file on error: %v", err) if removeErr := os.Remove(o.path); removeErr != nil { fs.Errorf(o, "Failed to remove partially written file: %v", removeErr) } return err } // All successful so update the hashes if hasher != nil { o.fs.objectMetaMu.Lock() o.hashes = hasher.Sums() o.fs.objectMetaMu.Unlock() } // Set the mtime err = o.SetModTime(ctx, src.ModTime(ctx)) if err != nil { return err } // Fetch and set metadata if --metadata is in use meta, err := fs.GetMetadataOptions(ctx, o.fs, src, options) if err != nil { return fmt.Errorf("failed to read metadata from source object: %w", err) } err = o.writeMetadata(meta) if err != nil { return fmt.Errorf("failed to set metadata: %w", err) } // ReRead info now that we have finished return o.lstat() } var sparseWarning sync.Once // 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) { // Temporary Object under construction o := f.newObject(remote) err := o.mkdirAll() if err != nil { return nil, err } if o.translatedLink { return nil, errors.New("can't open a symlink for random writing") } out, err := file.OpenFile(o.path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666) if err != nil { return nil, err } // Pre-allocate the file for performance reasons if !f.opt.NoPreAllocate { err = file.PreAllocate(size, out) if err != nil { fs.Debugf(o, "Failed to pre-allocate: %v", err) } } if !f.opt.NoSparse && file.SetSparseImplemented { sparseWarning.Do(func() { fs.Infof(nil, "Writing sparse files: use --local-no-sparse or --multi-thread-streams 0 to disable") }) // Set the file to be a sparse file (important on Windows) err = file.SetSparse(out) if err != nil { fs.Errorf(o, "Failed to set sparse: %v", err) } } return out, nil } // setMetadata sets the file info from the os.FileInfo passed in func (o *Object) setMetadata(info os.FileInfo) { // if not checking updated then don't update the stat if o.fs.opt.NoCheckUpdated && !o.modTime.IsZero() { return } o.fs.objectMetaMu.Lock() o.size = info.Size() o.modTime = readTime(o.fs.opt.TimeType, info) o.mode = info.Mode() o.fs.objectMetaMu.Unlock() // Read the size of the link. // // The value in info.Size() is not always correct // - Windows links read as 0 size // - Some virtual filesystems (such ash LucidLink) links read as 0 size // - Android - some versions the links are larger than readlink suggests if o.translatedLink { linkdst, err := os.Readlink(o.path) if err != nil { fs.Errorf(o, "Failed to read link size: %v", err) } else { o.size = int64(len(linkdst)) } } } // clearHashCache wipes any cached hashes for the object func (o *Object) clearHashCache() { o.fs.objectMetaMu.Lock() o.hashes = nil o.fs.objectMetaMu.Unlock() } // Stat an Object into info func (o *Object) lstat() error { info, err := o.fs.lstat(o.path) if err == nil { o.setMetadata(info) } return err } // Remove an object func (o *Object) Remove(ctx context.Context) error { o.clearHashCache() return remove(o.path) } // 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) { metadata, err = o.getXattr() if err != nil { return nil, err } err = o.readMetadataFromFile(&metadata) if err != nil { return nil, err } return metadata, nil } // Write the metadata on the object func (o *Object) writeMetadata(metadata fs.Metadata) (err error) { err = o.setXattr(metadata) if err != nil { return err } err = o.writeMetadataToFile(metadata) if err != nil { return err } return err } // SetMetadata sets metadata for an Object // // It should return fs.ErrorNotImplemented if it can't set metadata func (o *Object) SetMetadata(ctx context.Context, metadata fs.Metadata) error { err := o.writeMetadata(metadata) if err != nil { return fmt.Errorf("SetMetadata failed on Object: %w", err) } // Re-read info now we have finished setting stuff return o.lstat() } func cleanRootPath(s string, noUNC bool, enc encoder.MultiEncoder) string { var vol string if runtime.GOOS == "windows" { vol = filepath.VolumeName(s) if vol == `\\?` && len(s) >= 6 { // `\\?\C:` vol = s[:6] } s = s[len(vol):] } // Don't use FromStandardPath. Make sure Dot (`.`, `..`) as name will not be reencoded // Take care of the case Standard: ./．/‛． (the first dot means current directory) if enc != encoder.Standard { s = filepath.ToSlash(s) parts := strings.Split(s, "/") encoded := make([]string, len(parts)) changed := false for i, p := range parts { if (p == ".") || (p == "..") { encoded[i] = p continue } part := enc.FromStandardName(p) changed = changed || part != p encoded[i] = part } if changed { s = strings.Join(encoded, "/") } s = filepath.FromSlash(s) } if runtime.GOOS == "windows" { s = vol + s } s2, err := filepath.Abs(s) if err == nil { s = s2 } if !noUNC { // Convert to UNC. It does nothing on non windows platforms. s = file.UNCPath(s) } return s } // Items returns the count of items in this directory or this // directory and subdirectories if known, -1 for unknown func (d *Directory) Items() int64 { return -1 } // ID returns the internal ID of this directory if known, or // "" otherwise func (d *Directory) ID() string { return "" } // SetMetadata sets metadata for a Directory // // It should return fs.ErrorNotImplemented if it can't set metadata func (d *Directory) SetMetadata(ctx context.Context, metadata fs.Metadata) error { err := d.writeMetadata(metadata) if err != nil { return fmt.Errorf("SetMetadata failed on Directory: %w", err) } // Re-read info now we have finished setting stuff return d.lstat() } // Hash does nothing on a directory // // This method is implemented with the incorrect type signature to // stop the Directory type asserting to fs.Object or fs.ObjectInfo func (d *Directory) Hash() { // Does nothing } // Check the interfaces are satisfied var ( _ fs.Fs = &Fs{} _ fs.PutStreamer = &Fs{} _ fs.Mover = &Fs{} _ fs.DirMover = &Fs{} _ fs.Commander = &Fs{} _ fs.OpenWriterAter = &Fs{} _ fs.DirSetModTimer = &Fs{} _ fs.MkdirMetadataer = &Fs{} _ fs.Object = &Object{} _ fs.Metadataer = &Object{} _ fs.SetMetadataer = &Object{} _ fs.Directory = &Directory{} _ fs.SetModTimer = &Directory{} _ fs.SetMetadataer = &Directory{} ) rclone-v1.71.0/backend/local/local_internal_test.go000066400000000000000000000465031505210326400223130ustar00rootroot00000000000000package local import ( "bytes" "context" "fmt" "io" "os" "path" "path/filepath" "runtime" "sort" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/object" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/lib/file" "github.com/rclone/rclone/lib/readers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // TestMain drives the tests func TestMain(m *testing.M) { fstest.TestMain(m) } // Test copy with source file that's updating func TestUpdatingCheck(t *testing.T) { r := fstest.NewRun(t) filePath := "sub dir/local test" r.WriteFile(filePath, "content", time.Now()) fd, err := file.Open(path.Join(r.LocalName, filePath)) if err != nil { t.Fatalf("failed opening file %q: %v", filePath, err) } defer func() { require.NoError(t, fd.Close()) }() fi, err := fd.Stat() require.NoError(t, err) o := &Object{size: fi.Size(), modTime: fi.ModTime(), fs: &Fs{}} wrappedFd := readers.NewLimitedReadCloser(fd, -1) hash, err := hash.NewMultiHasherTypes(hash.Supported()) require.NoError(t, err) in := localOpenFile{ o: o, in: wrappedFd, hash: hash, fd: fd, } buf := make([]byte, 1) _, err = in.Read(buf) require.NoError(t, err) r.WriteFile(filePath, "content updated", time.Now()) _, err = in.Read(buf) require.Errorf(t, err, "can't copy - source file is being updated") // turn the checking off and try again in.o.fs.opt.NoCheckUpdated = true r.WriteFile(filePath, "content updated", time.Now()) _, err = in.Read(buf) require.NoError(t, err) } // Test corrupted on transfer // should error due to size/hash mismatch func TestVerifyCopy(t *testing.T) { t.Skip("FIXME this test is unreliable") r := fstest.NewRun(t) filePath := "sub dir/local test" r.WriteFile(filePath, "some content", time.Now()) src, err := r.Flocal.NewObject(context.Background(), filePath) require.NoError(t, err) src.(*Object).fs.opt.NoCheckUpdated = true for i := range 100 { go r.WriteFile(src.Remote(), fmt.Sprintf("some new content %d", i), src.ModTime(context.Background())) } _, err = operations.Copy(context.Background(), r.Fremote, nil, filePath+"2", src) assert.Error(t, err) } func TestSymlink(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) f := r.Flocal.(*Fs) dir := f.root // Write a file modTime1 := fstest.Time("2001-02-03T04:05:10.123123123Z") file1 := r.WriteFile("file.txt", "hello", modTime1) // Write a symlink modTime2 := fstest.Time("2002-02-03T04:05:10.123123123Z") symlinkPath := filepath.Join(dir, "symlink.txt") require.NoError(t, os.Symlink("file.txt", symlinkPath)) require.NoError(t, lChtimes(symlinkPath, modTime2, modTime2)) // Object viewed as symlink file2 := fstest.NewItem("symlink.txt"+fs.LinkSuffix, "file.txt", modTime2) // Object viewed as destination file2d := fstest.NewItem("symlink.txt", "hello", modTime1) // Check with no symlink flags r.CheckLocalItems(t, file1) r.CheckRemoteItems(t) // Set fs into "-L" mode f.opt.FollowSymlinks = true f.opt.TranslateSymlinks = false f.lstat = os.Stat r.CheckLocalItems(t, file1, file2d) r.CheckRemoteItems(t) // Set fs into "-l" mode f.opt.FollowSymlinks = false f.opt.TranslateSymlinks = true f.lstat = os.Lstat fstest.CheckListingWithPrecision(t, r.Flocal, []fstest.Item{file1, file2}, nil, fs.ModTimeNotSupported) if haveLChtimes { r.CheckLocalItems(t, file1, file2) } // Create a symlink modTime3 := fstest.Time("2002-03-03T04:05:10.123123123Z") file3 := r.WriteObjectTo(ctx, r.Flocal, "symlink2.txt"+fs.LinkSuffix, "file.txt", modTime3, false) fstest.CheckListingWithPrecision(t, r.Flocal, []fstest.Item{file1, file2, file3}, nil, fs.ModTimeNotSupported) if haveLChtimes { r.CheckLocalItems(t, file1, file2, file3) } // Check it got the correct contents symlinkPath = filepath.Join(dir, "symlink2.txt") fi, err := os.Lstat(symlinkPath) require.NoError(t, err) assert.False(t, fi.Mode().IsRegular()) linkText, err := os.Readlink(symlinkPath) require.NoError(t, err) assert.Equal(t, "file.txt", linkText) // Check that NewObject gets the correct object o, err := r.Flocal.NewObject(ctx, "symlink2.txt"+fs.LinkSuffix) require.NoError(t, err) assert.Equal(t, "symlink2.txt"+fs.LinkSuffix, o.Remote()) assert.Equal(t, int64(8), o.Size()) // Check that NewObject doesn't see the non suffixed version _, err = r.Flocal.NewObject(ctx, "symlink2.txt") require.Equal(t, fs.ErrorObjectNotFound, err) // Check that NewFs works with the suffixed version and --links f2, err := NewFs(ctx, "local", filepath.Join(dir, "symlink2.txt"+fs.LinkSuffix), configmap.Simple{ "links": "true", }) require.Equal(t, fs.ErrorIsFile, err) require.Equal(t, dir, f2.(*Fs).root) // Check that NewFs doesn't see the non suffixed version with --links f2, err = NewFs(ctx, "local", filepath.Join(dir, "symlink2.txt"), configmap.Simple{ "links": "true", }) require.Equal(t, errLinksNeedsSuffix, err) require.Nil(t, f2) // Check reading the object in, err := o.Open(ctx) require.NoError(t, err) contents, err := io.ReadAll(in) require.NoError(t, err) require.Equal(t, "file.txt", string(contents)) require.NoError(t, in.Close()) // Check reading the object with range in, err = o.Open(ctx, &fs.RangeOption{Start: 2, End: 5}) require.NoError(t, err) contents, err = io.ReadAll(in) require.NoError(t, err) require.Equal(t, "file.txt"[2:5+1], string(contents)) require.NoError(t, in.Close()) } func TestSymlinkError(t *testing.T) { m := configmap.Simple{ "links": "true", "copy_links": "true", } _, err := NewFs(context.Background(), "local", "/", m) assert.Equal(t, errLinksAndCopyLinks, err) } func TestHashWithTypeNone(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) const filePath = "file.txt" r.WriteFile(filePath, "content", time.Now()) f := r.Flocal.(*Fs) // Get the object o, err := f.NewObject(ctx, filePath) require.NoError(t, err) // Test the hash is as we expect h, err := o.Hash(ctx, hash.None) require.Empty(t, h) require.NoError(t, err) } // Test hashes on updating an object func TestHashOnUpdate(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) const filePath = "file.txt" when := time.Now() r.WriteFile(filePath, "content", when) f := r.Flocal.(*Fs) // Get the object o, err := f.NewObject(ctx, filePath) require.NoError(t, err) // Test the hash is as we expect md5, err := o.Hash(ctx, hash.MD5) require.NoError(t, err) assert.Equal(t, "9a0364b9e99bb480dd25e1f0284c8555", md5) // Reupload it with different contents but same size and timestamp b := bytes.NewBufferString("CONTENT") src := object.NewStaticObjectInfo(filePath, when, int64(b.Len()), true, nil, f) err = o.Update(ctx, b, src) require.NoError(t, err) // Check the hash is as expected md5, err = o.Hash(ctx, hash.MD5) require.NoError(t, err) assert.Equal(t, "45685e95985e20822fb2538a522a5ccf", md5) } // Test hashes on deleting an object func TestHashOnDelete(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) const filePath = "file.txt" when := time.Now() r.WriteFile(filePath, "content", when) f := r.Flocal.(*Fs) // Get the object o, err := f.NewObject(ctx, filePath) require.NoError(t, err) // Test the hash is as we expect md5, err := o.Hash(ctx, hash.MD5) require.NoError(t, err) assert.Equal(t, "9a0364b9e99bb480dd25e1f0284c8555", md5) // Delete the object require.NoError(t, o.Remove(ctx)) // Test the hash cache is empty require.Nil(t, o.(*Object).hashes) // Test the hash returns an error _, err = o.Hash(ctx, hash.MD5) require.Error(t, err) } func TestMetadata(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) const filePath = "metafile.txt" when := time.Now() r.WriteFile(filePath, "metadata file contents", when) f := r.Flocal.(*Fs) // Set fs into "-l" / "--links" mode f.opt.TranslateSymlinks = true // Write a symlink to the file symlinkPath := "metafile-link.txt" osSymlinkPath := filepath.Join(f.root, symlinkPath) symlinkPath += fs.LinkSuffix require.NoError(t, os.Symlink(filePath, osSymlinkPath)) symlinkModTime := fstest.Time("2002-02-03T04:05:10.123123123Z") require.NoError(t, lChtimes(osSymlinkPath, symlinkModTime, symlinkModTime)) // Get the object obj, err := f.NewObject(ctx, filePath) require.NoError(t, err) o := obj.(*Object) // Get the symlink object symlinkObj, err := f.NewObject(ctx, symlinkPath) require.NoError(t, err) symlinkO := symlinkObj.(*Object) // Record metadata for o oMeta, err := o.Metadata(ctx) require.NoError(t, err) // Test symlink first to check it doesn't mess up file t.Run("Symlink", func(t *testing.T) { testMetadata(t, r, symlinkO, symlinkModTime) }) // Read it again oMetaNew, err := o.Metadata(ctx) require.NoError(t, err) // Check that operating on the symlink didn't change the file it was pointing to // See: https://github.com/rclone/rclone/security/advisories/GHSA-hrxh-9w67-g4cv assert.Equal(t, oMeta, oMetaNew, "metadata setting on symlink messed up file") // Now run the same tests on the file t.Run("File", func(t *testing.T) { testMetadata(t, r, o, when) }) } func testMetadata(t *testing.T, r *fstest.Run, o *Object, when time.Time) { ctx := context.Background() whenRFC := when.Format(time.RFC3339Nano) const dayLength = len("2001-01-01") f := r.Flocal.(*Fs) features := f.Features() var hasXID, hasAtime, hasBtime, canSetXattrOnLinks bool switch runtime.GOOS { case "darwin", "freebsd", "netbsd", "linux": hasXID, hasAtime, hasBtime = true, true, true canSetXattrOnLinks = runtime.GOOS != "linux" case "openbsd", "solaris": hasXID, hasAtime = true, true case "windows": hasAtime, hasBtime = true, true case "plan9", "js": // nada default: t.Errorf("No test cases for OS %q", runtime.GOOS) } assert.True(t, features.ReadMetadata) assert.True(t, features.WriteMetadata) assert.Equal(t, xattrSupported, features.UserMetadata) t.Run("Xattr", func(t *testing.T) { if !xattrSupported { t.Skip() } m, err := o.getXattr() require.NoError(t, err) assert.Nil(t, m) if !canSetXattrOnLinks && o.translatedLink { t.Skip("Skip remainder of test as can't set xattr on symlinks on this OS") } inM := fs.Metadata{ "potato": "chips", "cabbage": "soup", } err = o.setXattr(inM) require.NoError(t, err) m, err = o.getXattr() require.NoError(t, err) assert.NotNil(t, m) assert.Equal(t, inM, m) }) checkTime := func(m fs.Metadata, key string, when time.Time) { t.Helper() mt, ok := o.parseMetadataTime(m, key) assert.True(t, ok) dt := mt.Sub(when) precision := time.Second assert.True(t, dt >= -precision && dt <= precision, fmt.Sprintf("%s: dt %v outside +/- precision %v want %v got %v", key, dt, precision, mt, when)) } checkInt := func(m fs.Metadata, key string, base int) int { t.Helper() value, ok := o.parseMetadataInt(m, key, base) assert.True(t, ok) return value } t.Run("Read", func(t *testing.T) { m, err := o.Metadata(ctx) require.NoError(t, err) assert.NotNil(t, m) // All OSes have these checkInt(m, "mode", 8) checkTime(m, "mtime", when) assert.Equal(t, whenRFC[:dayLength], m["mtime"][:dayLength]) if hasAtime && !o.translatedLink { // symlinks generally don't record atime checkTime(m, "atime", when) } if hasBtime && !o.translatedLink { // symlinks generally don't record btime checkTime(m, "btime", when) } if hasXID { checkInt(m, "uid", 10) checkInt(m, "gid", 10) } }) t.Run("Write", func(t *testing.T) { newAtimeString := "2011-12-13T14:15:16.999999999Z" newAtime := fstest.Time(newAtimeString) newMtimeString := "2011-12-12T14:15:16.999999999Z" newMtime := fstest.Time(newMtimeString) newBtimeString := "2011-12-11T14:15:16.999999999Z" newBtime := fstest.Time(newBtimeString) newM := fs.Metadata{ "mtime": newMtimeString, "atime": newAtimeString, "btime": newBtimeString, // Can't test uid, gid without being root "mode": "0767", "potato": "wedges", } if !canSetXattrOnLinks && o.translatedLink { // Don't change xattr if not supported on symlinks delete(newM, "potato") } err := o.writeMetadata(newM) require.NoError(t, err) m, err := o.Metadata(ctx) require.NoError(t, err) assert.NotNil(t, m) mode := checkInt(m, "mode", 8) if runtime.GOOS != "windows" { expectedMode := 0767 if o.translatedLink && runtime.GOOS == "linux" { expectedMode = 0777 // perms of symlinks always read as 0777 on linux } assert.Equal(t, expectedMode, mode&0777, fmt.Sprintf("mode wrong - expecting 0%o got 0%o", expectedMode, mode&0777)) } checkTime(m, "mtime", newMtime) if hasAtime { checkTime(m, "atime", newAtime) } if haveSetBTime { checkTime(m, "btime", newBtime) } if xattrSupported && (canSetXattrOnLinks || !o.translatedLink) { assert.Equal(t, "wedges", m["potato"]) } }) } func TestFilter(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) when := time.Now() r.WriteFile("included", "included file", when) r.WriteFile("excluded", "excluded file", when) f := r.Flocal.(*Fs) // Check set up for filtering assert.True(t, f.Features().FilterAware) // Add a filter ctx, fi := filter.AddConfig(ctx) require.NoError(t, fi.AddRule("+ included")) require.NoError(t, fi.AddRule("- *")) // Check listing without use filter flag entries, err := f.List(ctx, "") require.NoError(t, err) sort.Sort(entries) require.Equal(t, "[excluded included]", fmt.Sprint(entries)) // Add user filter flag ctx = filter.SetUseFilter(ctx, true) // Check listing with use filter flag entries, err = f.List(ctx, "") require.NoError(t, err) sort.Sort(entries) require.Equal(t, "[included]", fmt.Sprint(entries)) } func testFilterSymlink(t *testing.T, copyLinks bool) { ctx := context.Background() r := fstest.NewRun(t) defer r.Finalise() when := time.Now() f := r.Flocal.(*Fs) // Create a file, a directory, a symlink to a file, a symlink to a directory and a dangling symlink r.WriteFile("included.file", "included file", when) r.WriteFile("included.dir/included.sub.file", "included sub file", when) require.NoError(t, os.Symlink("included.file", filepath.Join(r.LocalName, "included.file.link"))) require.NoError(t, os.Symlink("included.dir", filepath.Join(r.LocalName, "included.dir.link"))) require.NoError(t, os.Symlink("dangling", filepath.Join(r.LocalName, "dangling.link"))) defer func() { // Reset -L/-l mode f.opt.FollowSymlinks = false f.opt.TranslateSymlinks = false f.lstat = os.Lstat }() if copyLinks { // Set fs into "-L" mode f.opt.FollowSymlinks = true f.opt.TranslateSymlinks = false f.lstat = os.Stat } else { // Set fs into "-l" mode f.opt.FollowSymlinks = false f.opt.TranslateSymlinks = true f.lstat = os.Lstat } // Check set up for filtering assert.True(t, f.Features().FilterAware) // Reset global error count accounting.Stats(ctx).ResetErrors() assert.Equal(t, int64(0), accounting.Stats(ctx).GetErrors(), "global errors found") // Add a filter ctx, fi := filter.AddConfig(ctx) require.NoError(t, fi.AddRule("+ included.file")) require.NoError(t, fi.AddRule("+ included.dir/**")) if copyLinks { require.NoError(t, fi.AddRule("+ included.file.link")) require.NoError(t, fi.AddRule("+ included.dir.link/**")) } else { require.NoError(t, fi.AddRule("+ included.file.link.rclonelink")) require.NoError(t, fi.AddRule("+ included.dir.link.rclonelink")) } require.NoError(t, fi.AddRule("- *")) // Check listing without use filter flag entries, err := f.List(ctx, "") require.NoError(t, err) if copyLinks { // Check 1 global errors one for each dangling symlink assert.Equal(t, int64(1), accounting.Stats(ctx).GetErrors(), "global errors found") } else { // Check 0 global errors as dangling symlink copied properly assert.Equal(t, int64(0), accounting.Stats(ctx).GetErrors(), "global errors found") } accounting.Stats(ctx).ResetErrors() sort.Sort(entries) if copyLinks { require.Equal(t, "[included.dir included.dir.link included.file included.file.link]", fmt.Sprint(entries)) } else { require.Equal(t, "[dangling.link.rclonelink included.dir included.dir.link.rclonelink included.file included.file.link.rclonelink]", fmt.Sprint(entries)) } // Add user filter flag ctx = filter.SetUseFilter(ctx, true) // Check listing with use filter flag entries, err = f.List(ctx, "") require.NoError(t, err) assert.Equal(t, int64(0), accounting.Stats(ctx).GetErrors(), "global errors found") sort.Sort(entries) if copyLinks { require.Equal(t, "[included.dir included.dir.link included.file included.file.link]", fmt.Sprint(entries)) } else { require.Equal(t, "[included.dir included.dir.link.rclonelink included.file included.file.link.rclonelink]", fmt.Sprint(entries)) } // Check listing through a symlink still works entries, err = f.List(ctx, "included.dir") require.NoError(t, err) assert.Equal(t, int64(0), accounting.Stats(ctx).GetErrors(), "global errors found") sort.Sort(entries) require.Equal(t, "[included.dir/included.sub.file]", fmt.Sprint(entries)) } func TestFilterSymlinkCopyLinks(t *testing.T) { testFilterSymlink(t, true) } func TestFilterSymlinkLinks(t *testing.T) { testFilterSymlink(t, false) } func TestCopySymlink(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) defer r.Finalise() when := time.Now() f := r.Flocal.(*Fs) // Create a file and a symlink to it r.WriteFile("src/file.txt", "hello world", when) require.NoError(t, os.Symlink("file.txt", filepath.Join(r.LocalName, "src", "link.txt"))) defer func() { // Reset -L/-l mode f.opt.FollowSymlinks = false f.opt.TranslateSymlinks = false f.lstat = os.Lstat }() // Set fs into "-l/--links" mode f.opt.FollowSymlinks = false f.opt.TranslateSymlinks = true f.lstat = os.Lstat // Create dst require.NoError(t, f.Mkdir(ctx, "dst")) // Do copy from src into dst src, err := f.NewObject(ctx, "src/link.txt.rclonelink") require.NoError(t, err) require.NotNil(t, src) dst, err := operations.Copy(ctx, f, nil, "dst/link.txt.rclonelink", src) require.NoError(t, err) require.NotNil(t, dst) // Test that we made a symlink and it has the right contents dstPath := filepath.Join(r.LocalName, "dst", "link.txt") linkContents, err := os.Readlink(dstPath) require.NoError(t, err) assert.Equal(t, "file.txt", linkContents) // Set fs into "-L/--copy-links" mode f.opt.FollowSymlinks = true f.opt.TranslateSymlinks = false f.lstat = os.Stat // Create dst require.NoError(t, f.Mkdir(ctx, "dst2")) // Do copy from src into dst src, err = f.NewObject(ctx, "src/link.txt") require.NoError(t, err) require.NotNil(t, src) dst, err = operations.Copy(ctx, f, nil, "dst2/link.txt", src) require.NoError(t, err) require.NotNil(t, dst) // Test that we made a NON-symlink and it has the right contents dstPath = filepath.Join(r.LocalName, "dst2", "link.txt") fi, err := os.Lstat(dstPath) require.NoError(t, err) assert.True(t, fi.Mode()&os.ModeSymlink == 0) want := fstest.NewItem("dst2/link.txt", "hello world", when) fstest.CompareItems(t, []fs.DirEntry{dst}, []fstest.Item{want}, nil, f.precision, "") // Test that copying a normal file also works dst, err = operations.Copy(ctx, f, nil, "dst2/file.txt", dst) require.NoError(t, err) require.NotNil(t, dst) want = fstest.NewItem("dst2/file.txt", "hello world", when) fstest.CompareItems(t, []fs.DirEntry{dst}, []fstest.Item{want}, nil, f.precision, "") } rclone-v1.71.0/backend/local/local_test.go000066400000000000000000000005671505210326400204170ustar00rootroot00000000000000// Test Local filesystem interface package local_test import ( "testing" "github.com/rclone/rclone/backend/local" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "", NilObject: (*local.Object)(nil), QuickTestOK: true, }) } rclone-v1.71.0/backend/local/metadata.go000066400000000000000000000073471505210326400200510ustar00rootroot00000000000000package local import ( "fmt" "math" "os" "runtime" "strconv" "time" "github.com/rclone/rclone/fs" ) const metadataTimeFormat = time.RFC3339Nano // system metadata keys which this backend owns // // not all values supported on all OSes var systemMetadataInfo = map[string]fs.MetadataHelp{ "mode": { Help: "File type and mode", Type: "octal, unix style", Example: "0100664", }, "uid": { Help: "User ID of owner", Type: "decimal number", Example: "500", }, "gid": { Help: "Group ID of owner", Type: "decimal number", Example: "500", }, "rdev": { Help: "Device ID (if special file)", Type: "hexadecimal", Example: "1abc", }, "atime": { Help: "Time of last access", Type: "RFC 3339", Example: "2006-01-02T15:04:05.999999999Z07:00", }, "mtime": { Help: "Time of last modification", Type: "RFC 3339", Example: "2006-01-02T15:04:05.999999999Z07:00", }, "btime": { Help: "Time of file birth (creation)", Type: "RFC 3339", Example: "2006-01-02T15:04:05.999999999Z07:00", }, } // parse a time string from metadata with key func (o *Object) parseMetadataTime(m fs.Metadata, key string) (t time.Time, ok bool) { value, ok := m[key] if ok { var err error t, err = time.Parse(metadataTimeFormat, value) if err != nil { fs.Debugf(o, "failed to parse metadata %s: %q: %v", key, value, err) ok = false } } return t, ok } // parse am int from metadata with key and base func (o *Object) parseMetadataInt(m fs.Metadata, key string, base int) (result int, ok bool) { value, ok := m[key] if ok { var err error parsed, err := strconv.ParseInt(value, base, 0) if err != nil { fs.Debugf(o, "failed to parse metadata %s: %q: %v", key, value, err) ok = false } result = int(parsed) } return result, ok } // Write the metadata into the file // // It isn't possible to set the ctime and btime under Unix func (o *Object) writeMetadataToFile(m fs.Metadata) (outErr error) { var err error atime, atimeOK := o.parseMetadataTime(m, "atime") mtime, mtimeOK := o.parseMetadataTime(m, "mtime") btime, btimeOK := o.parseMetadataTime(m, "btime") if atimeOK || mtimeOK { if atimeOK && !mtimeOK { mtime = atime } if !atimeOK && mtimeOK { atime = mtime } err = o.setTimes(atime, mtime) if err != nil { outErr = fmt.Errorf("failed to set times: %w", err) } } if haveSetBTime { if btimeOK { if o.translatedLink { err = lsetBTime(o.path, btime) } else { err = setBTime(o.path, btime) } if err != nil { outErr = fmt.Errorf("failed to set birth (creation) time: %w", err) } } } uid, hasUID := o.parseMetadataInt(m, "uid", 10) gid, hasGID := o.parseMetadataInt(m, "gid", 10) if hasUID { // FIXME should read UID and GID of current user and only attempt to set it if different if !hasGID { gid = uid } if runtime.GOOS == "windows" || runtime.GOOS == "plan9" { fs.Debugf(o, "Ignoring request to set ownership %o.%o on this OS", gid, uid) } else { if o.translatedLink { err = os.Lchown(o.path, uid, gid) } else { err = os.Chown(o.path, uid, gid) } if err != nil { outErr = fmt.Errorf("failed to change ownership: %w", err) } } } mode, hasMode := o.parseMetadataInt(m, "mode", 8) if hasMode { if mode >= 0 { umode := uint(mode) if umode <= math.MaxUint32 { if o.translatedLink { if haveLChmod { err = lChmod(o.path, os.FileMode(umode)) } else { fs.Debugf(o, "Unable to set mode %v on a symlink on this OS", os.FileMode(umode)) err = nil } } else { err = os.Chmod(o.path, os.FileMode(umode)) } if err != nil { outErr = fmt.Errorf("failed to change permissions: %w", err) } } } } // FIXME not parsing rdev yet return outErr } rclone-v1.71.0/backend/local/metadata_bsd.go000066400000000000000000000024531505210326400206720ustar00rootroot00000000000000//go:build darwin || freebsd || netbsd package local import ( "fmt" "os" "syscall" "time" "github.com/rclone/rclone/fs" ) // Read the time specified from the os.FileInfo func readTime(t timeType, fi os.FileInfo) time.Time { stat, ok := fi.Sys().(*syscall.Stat_t) if !ok { fs.Debugf(nil, "didn't return Stat_t as expected") return fi.ModTime() } switch t { case aTime: return time.Unix(stat.Atimespec.Unix()) case bTime: return time.Unix(stat.Birthtimespec.Unix()) case cTime: return time.Unix(stat.Ctimespec.Unix()) } return fi.ModTime() } // Read the metadata from the file into metadata where possible func (o *Object) readMetadataFromFile(m *fs.Metadata) (err error) { info, err := o.fs.lstat(o.path) if err != nil { return err } stat, ok := info.Sys().(*syscall.Stat_t) if !ok { fs.Debugf(o, "didn't return Stat_t as expected") return nil } m.Set("mode", fmt.Sprintf("%0o", stat.Mode)) m.Set("uid", fmt.Sprintf("%d", stat.Uid)) m.Set("gid", fmt.Sprintf("%d", stat.Gid)) if stat.Rdev != 0 { m.Set("rdev", fmt.Sprintf("%x", stat.Rdev)) } setTime := func(key string, t syscall.Timespec) { m.Set(key, time.Unix(t.Unix()).Format(metadataTimeFormat)) } setTime("atime", stat.Atimespec) setTime("mtime", stat.Mtimespec) setTime("btime", stat.Birthtimespec) return nil } rclone-v1.71.0/backend/local/metadata_linux.go000066400000000000000000000067251505210326400212670ustar00rootroot00000000000000//go:build linux package local import ( "fmt" "os" "runtime" "sync" "syscall" "time" "github.com/rclone/rclone/fs" "golang.org/x/sys/unix" ) var ( statxCheckOnce sync.Once readMetadataFromFileFn func(o *Object, m *fs.Metadata) (err error) ) // Read the time specified from the os.FileInfo func readTime(t timeType, fi os.FileInfo) time.Time { stat, ok := fi.Sys().(*syscall.Stat_t) if !ok { fs.Debugf(nil, "didn't return Stat_t as expected") return fi.ModTime() } switch t { case aTime: return time.Unix(stat.Atim.Unix()) case cTime: return time.Unix(stat.Ctim.Unix()) } return fi.ModTime() } // Read the metadata from the file into metadata where possible func (o *Object) readMetadataFromFile(m *fs.Metadata) (err error) { statxCheckOnce.Do(func() { // Check statx() is available as it was only introduced in kernel 4.11 // If not, fall back to fstatat() which was introduced in 2.6.16 which is guaranteed for all Go versions var stat unix.Statx_t if runtime.GOOS != "android" && unix.Statx(unix.AT_FDCWD, ".", 0, unix.STATX_ALL, &stat) != unix.ENOSYS { readMetadataFromFileFn = readMetadataFromFileStatx } else { readMetadataFromFileFn = readMetadataFromFileFstatat } }) return readMetadataFromFileFn(o, m) } // Read the metadata from the file into metadata where possible func readMetadataFromFileStatx(o *Object, m *fs.Metadata) (err error) { flags := unix.AT_SYMLINK_NOFOLLOW if o.fs.opt.FollowSymlinks { flags = 0 } var stat unix.Statx_t // statx() was added to Linux in kernel 4.11 err = unix.Statx(unix.AT_FDCWD, o.path, flags, (0 | unix.STATX_TYPE | // Want stx_mode & S_IFMT unix.STATX_MODE | // Want stx_mode & ~S_IFMT unix.STATX_UID | // Want stx_uid unix.STATX_GID | // Want stx_gid unix.STATX_ATIME | // Want stx_atime unix.STATX_MTIME | // Want stx_mtime unix.STATX_CTIME | // Want stx_ctime unix.STATX_BTIME), // Want stx_btime &stat) if err != nil { return err } m.Set("mode", fmt.Sprintf("%0o", stat.Mode)) m.Set("uid", fmt.Sprintf("%d", stat.Uid)) m.Set("gid", fmt.Sprintf("%d", stat.Gid)) if stat.Rdev_major != 0 || stat.Rdev_minor != 0 { m.Set("rdev", fmt.Sprintf("%x", uint64(stat.Rdev_major)<<32|uint64(stat.Rdev_minor))) } setTime := func(key string, t unix.StatxTimestamp) { m.Set(key, time.Unix(t.Sec, int64(t.Nsec)).Format(metadataTimeFormat)) } setTime("atime", stat.Atime) setTime("mtime", stat.Mtime) setTime("btime", stat.Btime) return nil } // Read the metadata from the file into metadata where possible func readMetadataFromFileFstatat(o *Object, m *fs.Metadata) (err error) { flags := unix.AT_SYMLINK_NOFOLLOW if o.fs.opt.FollowSymlinks { flags = 0 } var stat unix.Stat_t // fstatat() was added to Linux in kernel 2.6.16 // Go only supports 2.6.32 or later err = unix.Fstatat(unix.AT_FDCWD, o.path, &stat, flags) if err != nil { return err } m.Set("mode", fmt.Sprintf("%0o", stat.Mode)) m.Set("uid", fmt.Sprintf("%d", stat.Uid)) m.Set("gid", fmt.Sprintf("%d", stat.Gid)) if stat.Rdev != 0 { m.Set("rdev", fmt.Sprintf("%x", stat.Rdev)) } setTime := func(key string, t unix.Timespec) { // The types of t.Sec and t.Nsec vary from int32 to int64 on // different Linux architectures so we need to cast them to // int64 here and hence need to quiet the linter about // unnecessary casts. // // nolint: unconvert m.Set(key, time.Unix(int64(t.Sec), int64(t.Nsec)).Format(metadataTimeFormat)) } setTime("atime", stat.Atim) setTime("mtime", stat.Mtim) return nil } rclone-v1.71.0/backend/local/metadata_other.go000066400000000000000000000010621505210326400212360ustar00rootroot00000000000000//go:build dragonfly || plan9 || js package local import ( "fmt" "os" "time" "github.com/rclone/rclone/fs" ) // Read the time specified from the os.FileInfo func readTime(t timeType, fi os.FileInfo) time.Time { return fi.ModTime() } // Read the metadata from the file into metadata where possible func (o *Object) readMetadataFromFile(m *fs.Metadata) (err error) { info, err := o.fs.lstat(o.path) if err != nil { return err } m.Set("mode", fmt.Sprintf("%0o", info.Mode())) m.Set("mtime", info.ModTime().Format(metadataTimeFormat)) return nil } rclone-v1.71.0/backend/local/metadata_unix.go000066400000000000000000000022551505210326400211050ustar00rootroot00000000000000//go:build openbsd || solaris package local import ( "fmt" "os" "syscall" "time" "github.com/rclone/rclone/fs" ) // Read the time specified from the os.FileInfo func readTime(t timeType, fi os.FileInfo) time.Time { stat, ok := fi.Sys().(*syscall.Stat_t) if !ok { fs.Debugf(nil, "didn't return Stat_t as expected") return fi.ModTime() } switch t { case aTime: return time.Unix(stat.Atim.Unix()) case cTime: return time.Unix(stat.Ctim.Unix()) } return fi.ModTime() } // Read the metadata from the file into metadata where possible func (o *Object) readMetadataFromFile(m *fs.Metadata) (err error) { info, err := o.fs.lstat(o.path) if err != nil { return err } stat, ok := info.Sys().(*syscall.Stat_t) if !ok { fs.Debugf(o, "didn't return Stat_t as expected") return nil } m.Set("mode", fmt.Sprintf("%0o", stat.Mode)) m.Set("uid", fmt.Sprintf("%d", stat.Uid)) m.Set("gid", fmt.Sprintf("%d", stat.Gid)) if stat.Rdev != 0 { m.Set("rdev", fmt.Sprintf("%x", stat.Rdev)) } setTime := func(key string, t syscall.Timespec) { m.Set(key, time.Unix(t.Unix()).Format(metadataTimeFormat)) } setTime("atime", stat.Atim) setTime("mtime", stat.Mtim) return nil } rclone-v1.71.0/backend/local/metadata_windows.go000066400000000000000000000023421505210326400216110ustar00rootroot00000000000000//go:build windows package local import ( "fmt" "os" "syscall" "time" "github.com/rclone/rclone/fs" ) // Read the time specified from the os.FileInfo func readTime(t timeType, fi os.FileInfo) time.Time { stat, ok := fi.Sys().(*syscall.Win32FileAttributeData) if !ok { fs.Debugf(nil, "didn't return Win32FileAttributeData as expected") return fi.ModTime() } switch t { case aTime: return time.Unix(0, stat.LastAccessTime.Nanoseconds()) case bTime: return time.Unix(0, stat.CreationTime.Nanoseconds()) } return fi.ModTime() } // Read the metadata from the file into metadata where possible func (o *Object) readMetadataFromFile(m *fs.Metadata) (err error) { info, err := o.fs.lstat(o.path) if err != nil { return err } stat, ok := info.Sys().(*syscall.Win32FileAttributeData) if !ok { fs.Debugf(o, "didn't return Win32FileAttributeData as expected") return nil } // FIXME do something with stat.FileAttributes ? m.Set("mode", fmt.Sprintf("%0o", info.Mode())) setTime := func(key string, t syscall.Filetime) { m.Set(key, time.Unix(0, t.Nanoseconds()).Format(metadataTimeFormat)) } setTime("atime", stat.LastAccessTime) setTime("mtime", stat.LastWriteTime) setTime("btime", stat.CreationTime) return nil } rclone-v1.71.0/backend/local/read_device_other.go000066400000000000000000000005051505210326400217110ustar00rootroot00000000000000// Device reading functions //go:build !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris package local import "os" // readDevice turns a valid os.FileInfo into a device number, // returning devUnset if it fails. func readDevice(fi os.FileInfo, oneFileSystem bool) uint64 { return devUnset } rclone-v1.71.0/backend/local/read_device_unix.go000066400000000000000000000011351505210326400215530ustar00rootroot00000000000000// Device reading functions //go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris package local import ( "os" "syscall" "github.com/rclone/rclone/fs" ) // readDevice turns a valid os.FileInfo into a device number, // returning devUnset if it fails. func readDevice(fi os.FileInfo, oneFileSystem bool) uint64 { if !oneFileSystem { return devUnset } statT, ok := fi.Sys().(*syscall.Stat_t) if !ok { fs.Debugf(fi.Name(), "Type assertion fi.Sys().(*syscall.Stat_t) failed from: %#v", fi.Sys()) return devUnset } return uint64(statT.Dev) // nolint: unconvert } rclone-v1.71.0/backend/local/remove_other.go000066400000000000000000000002351505210326400207540ustar00rootroot00000000000000//go:build !windows package local import "os" // Removes name, retrying on a sharing violation func remove(name string) error { return os.Remove(name) } rclone-v1.71.0/backend/local/remove_test.go000066400000000000000000000016051505210326400206140ustar00rootroot00000000000000package local import ( "os" "sync" "testing" "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Check we can remove an open file func TestRemove(t *testing.T) { fd, err := os.CreateTemp("", "rclone-remove-test") require.NoError(t, err) name := fd.Name() defer func() { _ = os.Remove(name) }() exists := func() bool { _, err := os.Stat(name) if err == nil { return true } else if os.IsNotExist(err) { return false } require.NoError(t, err) return false } assert.True(t, exists()) // close the file in the background var wg sync.WaitGroup wg.Add(1) go func() { defer wg.Done() time.Sleep(250 * time.Millisecond) require.NoError(t, fd.Close()) }() // delete the open file err = remove(name) require.NoError(t, err) // check it no longer exists assert.False(t, exists()) // wait for background close wg.Wait() } rclone-v1.71.0/backend/local/remove_windows.go000066400000000000000000000012101505210326400213170ustar00rootroot00000000000000//go:build windows package local import ( "os" "time" "github.com/rclone/rclone/fs" "golang.org/x/sys/windows" ) // Removes name, retrying on a sharing violation func remove(name string) (err error) { const maxTries = 10 var sleepTime = 1 * time.Millisecond for i := 0; i < maxTries; i++ { err = os.Remove(name) if err == nil { break } pathErr, ok := err.(*os.PathError) if !ok { break } if pathErr.Err != windows.ERROR_SHARING_VIOLATION { break } fs.Logf(name, "Remove detected sharing violation - retry %d/%d sleeping %v", i+1, maxTries, sleepTime) time.Sleep(sleepTime) sleepTime <<= 1 } return err } rclone-v1.71.0/backend/local/setbtime.go000066400000000000000000000005571505210326400201010ustar00rootroot00000000000000//go:build !windows package local import ( "time" ) const haveSetBTime = false // setBTime changes the birth time of the file passed in func setBTime(name string, btime time.Time) error { // Does nothing return nil } // lsetBTime changes the birth time of the link passed in func lsetBTime(name string, btime time.Time) error { // Does nothing return nil } rclone-v1.71.0/backend/local/setbtime_windows.go000066400000000000000000000026661505210326400216560ustar00rootroot00000000000000//go:build windows package local import ( "syscall" "time" ) const haveSetBTime = true // setTimes sets any of atime, mtime or btime // if link is set it sets a link rather than the target func setTimes(name string, atime, mtime, btime time.Time, link bool) (err error) { pathp, err := syscall.UTF16PtrFromString(name) if err != nil { return err } fileFlag := uint32(syscall.FILE_FLAG_BACKUP_SEMANTICS) if link { fileFlag |= syscall.FILE_FLAG_OPEN_REPARSE_POINT } h, err := syscall.CreateFile(pathp, syscall.FILE_WRITE_ATTRIBUTES, syscall.FILE_SHARE_WRITE, nil, syscall.OPEN_EXISTING, fileFlag, 0) if err != nil { return err } defer func() { closeErr := syscall.Close(h) if err == nil { err = closeErr } }() var patime, pmtime, pbtime *syscall.Filetime if !atime.IsZero() { t := syscall.NsecToFiletime(atime.UnixNano()) patime = &t } if !mtime.IsZero() { t := syscall.NsecToFiletime(mtime.UnixNano()) pmtime = &t } if !btime.IsZero() { t := syscall.NsecToFiletime(btime.UnixNano()) pbtime = &t } return syscall.SetFileTime(h, pbtime, patime, pmtime) } // setBTime sets the birth time of the file passed in func setBTime(name string, btime time.Time) (err error) { return setTimes(name, time.Time{}, time.Time{}, btime, false) } // lsetBTime changes the birth time of the link passed in func lsetBTime(name string, btime time.Time) error { return setTimes(name, time.Time{}, time.Time{}, btime, true) } rclone-v1.71.0/backend/local/symlink.go000066400000000000000000000006451505210326400177510ustar00rootroot00000000000000//go:build !windows && !plan9 && !js package local import ( "os" "syscall" ) // isCircularSymlinkError checks if the current error code is because of a circular symlink func isCircularSymlinkError(err error) bool { if err != nil { if newerr, ok := err.(*os.PathError); ok { if errcode, ok := newerr.Err.(syscall.Errno); ok { if errcode == syscall.ELOOP { return true } } } } return false } rclone-v1.71.0/backend/local/symlink_other.go000066400000000000000000000005501505210326400211450ustar00rootroot00000000000000//go:build windows || plan9 || js package local import ( "strings" ) // isCircularSymlinkError checks if the current error code is because of a circular symlink func isCircularSymlinkError(err error) bool { if err != nil { if strings.Contains(err.Error(), "The name of the file cannot be resolved by the system") { return true } } return false } rclone-v1.71.0/backend/local/tests_test.go000066400000000000000000000015311505210326400204570ustar00rootroot00000000000000package local import ( "runtime" "testing" "github.com/rclone/rclone/lib/encoder" ) // Test Windows character replacements var testsWindows = [][2]string{ {`c:\temp`, `c:\temp`}, {`\\?\UNC\theserver\dir\file.txt`, `\\?\UNC\theserver\dir\file.txt`}, {`//?/UNC/theserver/dir\file.txt`, `\\?\UNC\theserver\dir\file.txt`}, {`c:/temp`, `c:\temp`}, {`C:/temp/file.txt`, `C:\temp\file.txt`}, {`c:\!\"#¤%&/()=;:*^?+-`, `c:\!\＂#¤%&\()=;：＊^？+-`}, {`c:\<>"|?*:&\<>"|?*:&\<>"|?*:&`, `c:\＜＞＂｜？＊：&\＜＞＂｜？＊：&\＜＞＂｜？＊：&`}, } func TestCleanWindows(t *testing.T) { if runtime.GOOS != "windows" { t.Skipf("windows only") } for _, test := range testsWindows { got := cleanRootPath(test[0], true, encoder.OS) expect := test[1] if got != expect { t.Fatalf("got %q, expected %q", got, expect) } } } rclone-v1.71.0/backend/local/xattr.go000066400000000000000000000051761505210326400174310ustar00rootroot00000000000000//go:build !openbsd && !plan9 package local import ( "fmt" "strings" "syscall" "github.com/pkg/xattr" "github.com/rclone/rclone/fs" ) const ( xattrPrefix = "user." // FIXME is this correct for all unixes? xattrSupported = xattr.XATTR_SUPPORTED ) // Check to see if the error supplied is a not supported error, and if // so, disable xattrs func (f *Fs) xattrIsNotSupported(err error) bool { xattrErr, ok := err.(*xattr.Error) if !ok { return false } // Xattrs not supported can be ENOTSUP or ENOATTR or EINVAL (on Solaris) if xattrErr.Err == syscall.EINVAL || xattrErr.Err == syscall.ENOTSUP || xattrErr.Err == xattr.ENOATTR { // Show xattrs not supported if f.xattrSupported.CompareAndSwap(1, 0) { fs.Errorf(f, "xattrs not supported - disabling: %v", err) } return true } return false } // getXattr returns the extended attributes for an object // // It doesn't return any attributes owned by this backend in // metadataKeys func (o *Object) getXattr() (metadata fs.Metadata, err error) { if !xattrSupported || o.fs.xattrSupported.Load() == 0 { return nil, nil } var list []string if o.fs.opt.FollowSymlinks { list, err = xattr.List(o.path) } else { list, err = xattr.LList(o.path) } if err != nil { if o.fs.xattrIsNotSupported(err) { return nil, nil } return nil, fmt.Errorf("failed to read xattr: %w", err) } if len(list) == 0 { return nil, nil } metadata = make(fs.Metadata, len(list)) for _, k := range list { var v []byte if o.fs.opt.FollowSymlinks { v, err = xattr.Get(o.path, k) } else { v, err = xattr.LGet(o.path, k) } if err != nil { if o.fs.xattrIsNotSupported(err) { return nil, nil } return nil, fmt.Errorf("failed to read xattr key %q: %w", k, err) } k = strings.ToLower(k) if !strings.HasPrefix(k, xattrPrefix) { continue } k = k[len(xattrPrefix):] if _, found := systemMetadataInfo[k]; found { continue } metadata[k] = string(v) } return metadata, nil } // setXattr sets the metadata on the file Xattrs // // It doesn't set any attributes owned by this backend in metadataKeys func (o *Object) setXattr(metadata fs.Metadata) (err error) { if !xattrSupported || o.fs.xattrSupported.Load() == 0 { return nil } for k, value := range metadata { k = strings.ToLower(k) if _, found := systemMetadataInfo[k]; found { continue } k = xattrPrefix + k v := []byte(value) if o.fs.opt.FollowSymlinks { err = xattr.Set(o.path, k, v) } else { err = xattr.LSet(o.path, k, v) } if err != nil { if o.fs.xattrIsNotSupported(err) { return nil } return fmt.Errorf("failed to set xattr key %q: %w", k, err) } } return nil } rclone-v1.71.0/backend/local/xattr_unsupported.go000066400000000000000000000006761505210326400221010ustar00rootroot00000000000000// The pkg/xattr module doesn't compile for openbsd or plan9 //go:build openbsd || plan9 package local import "github.com/rclone/rclone/fs" const ( xattrSupported = false ) // getXattr returns the extended attributes for an object func (o *Object) getXattr() (metadata fs.Metadata, err error) { return nil, nil } // setXattr sets the metadata on the file Xattrs func (o *Object) setXattr(metadata fs.Metadata) (err error) { return nil } rclone-v1.71.0/backend/mailru/000077500000000000000000000000001505210326400161265ustar00rootroot00000000000000rclone-v1.71.0/backend/mailru/api/000077500000000000000000000000001505210326400166775ustar00rootroot00000000000000rclone-v1.71.0/backend/mailru/api/bin.go000066400000000000000000000047701505210326400200060ustar00rootroot00000000000000package api // BIN protocol constants const ( BinContentType = "application/x-www-form-urlencoded" TreeIDLength = 12 DunnoNodeIDLength = 16 ) // Operations in binary protocol const ( OperationAddFile = 103 // 0x67 OperationRename = 105 // 0x69 OperationCreateFolder = 106 // 0x6A OperationFolderList = 117 // 0x75 OperationSharedFoldersList = 121 // 0x79 // TODO investigate opcodes below Operation154MaybeItemInfo = 154 // 0x9A Operation102MaybeAbout = 102 // 0x66 Operation104MaybeDelete = 104 // 0x68 ) // CreateDir protocol constants const ( MkdirResultOK = 0 MkdirResultSourceNotExists = 1 MkdirResultAlreadyExists = 4 MkdirResultExistsDifferentCase = 9 MkdirResultInvalidName = 10 MkdirResultFailed254 = 254 ) // Move result codes const ( MoveResultOK = 0 MoveResultSourceNotExists = 1 MoveResultFailed002 = 2 MoveResultAlreadyExists = 4 MoveResultFailed005 = 5 MoveResultFailed254 = 254 ) // AddFile result codes const ( AddResultOK = 0 AddResultError01 = 1 AddResultDunno04 = 4 AddResultWrongPath = 5 AddResultNoFreeSpace = 7 AddResultDunno09 = 9 AddResultInvalidName = 10 AddResultNotModified = 12 AddResultFailedA = 253 AddResultFailedB = 254 ) // List request options const ( ListOptTotalSpace = 1 ListOptDelete = 2 ListOptFingerprint = 4 ListOptUnknown8 = 8 ListOptUnknown16 = 16 ListOptFolderSize = 32 ListOptUsedSpace = 64 ListOptUnknown128 = 128 ListOptUnknown256 = 256 ) // ListOptDefaults ... const ListOptDefaults = ListOptUnknown128 | ListOptUnknown256 | ListOptFolderSize | ListOptTotalSpace | ListOptUsedSpace // List parse flags const ( ListParseDone = 0 ListParseReadItem = 1 ListParsePin = 2 ListParsePinUpper = 3 ListParseUnknown15 = 15 ) // List operation results const ( ListResultOK = 0 ListResultNotExists = 1 ListResultDunno02 = 2 ListResultDunno03 = 3 ListResultAlreadyExists04 = 4 ListResultDunno05 = 5 ListResultDunno06 = 6 ListResultDunno07 = 7 ListResultDunno08 = 8 ListResultAlreadyExists09 = 9 ListResultDunno10 = 10 ListResultDunno11 = 11 ListResultDunno12 = 12 ListResultFailedB = 253 ListResultFailedA = 254 ) // Directory item types const ( ListItemMountPoint = 0 ListItemFile = 1 ListItemFolder = 2 ListItemSharedFolder = 3 ) rclone-v1.71.0/backend/mailru/api/helpers.go000066400000000000000000000120561505210326400206740ustar00rootroot00000000000000package api // BIN protocol helpers import ( "bufio" "bytes" "encoding/binary" "errors" "fmt" "io" "time" "github.com/rclone/rclone/lib/readers" ) // protocol errors var ( ErrorPrematureEOF = errors.New("premature EOF") ErrorInvalidLength = errors.New("invalid length") ErrorZeroTerminate = errors.New("string must end with zero") ) // BinWriter is a binary protocol writer type BinWriter struct { b *bytes.Buffer // growing byte buffer a []byte // temporary buffer for next varint } // NewBinWriter creates a binary protocol helper func NewBinWriter() *BinWriter { return &BinWriter{ b: new(bytes.Buffer), a: make([]byte, binary.MaxVarintLen64), } } // Bytes returns binary data func (w *BinWriter) Bytes() []byte { return w.b.Bytes() } // Reader returns io.Reader with binary data func (w *BinWriter) Reader() io.Reader { return bytes.NewReader(w.b.Bytes()) } // WritePu16 writes a short as unsigned varint func (w *BinWriter) WritePu16(val int) { if val < 0 || val > 65535 { panic(fmt.Sprintf("Invalid UInt16 %v", val)) } w.WritePu64(int64(val)) } // WritePu32 writes a signed long as unsigned varint func (w *BinWriter) WritePu32(val int64) { if val < 0 || val > 4294967295 { panic(fmt.Sprintf("Invalid UInt32 %v", val)) } w.WritePu64(val) } // WritePu64 writes an unsigned (actually, signed) long as unsigned varint func (w *BinWriter) WritePu64(val int64) { if val < 0 { panic(fmt.Sprintf("Invalid UInt64 %v", val)) } w.b.Write(w.a[:binary.PutUvarint(w.a, uint64(val))]) } // WriteP64 writes an signed long as unsigned varint func (w *BinWriter) WriteP64(val int64) { w.b.Write(w.a[:binary.PutUvarint(w.a, uint64(val))]) } // WriteString writes a zero-terminated string func (w *BinWriter) WriteString(str string) { buf := []byte(str) w.WritePu64(int64(len(buf) + 1)) w.b.Write(buf) w.b.WriteByte(0) } // Write writes a byte buffer func (w *BinWriter) Write(buf []byte) { w.b.Write(buf) } // WriteWithLength writes a byte buffer prepended with its length as varint func (w *BinWriter) WriteWithLength(buf []byte) { w.WritePu64(int64(len(buf))) w.b.Write(buf) } // BinReader is a binary protocol reader helper type BinReader struct { b *bufio.Reader count *readers.CountingReader err error // keeps the first error encountered } // NewBinReader creates a binary protocol reader helper func NewBinReader(reader io.Reader) *BinReader { r := &BinReader{} r.count = readers.NewCountingReader(reader) r.b = bufio.NewReader(r.count) return r } // Count returns number of bytes read func (r *BinReader) Count() uint64 { return r.count.BytesRead() } // Error returns first encountered error or nil func (r *BinReader) Error() error { return r.err } // check() keeps the first error encountered in a stream func (r *BinReader) check(err error) bool { if err == nil { return true } if r.err == nil { // keep the first error r.err = err } if err != io.EOF { panic(fmt.Sprintf("Error parsing response: %v", err)) } return false } // ReadByteAsInt reads a single byte as uint32, returns -1 for EOF or errors func (r *BinReader) ReadByteAsInt() int { if octet, err := r.b.ReadByte(); r.check(err) { return int(octet) } return -1 } // ReadByteAsShort reads a single byte as uint16, returns -1 for EOF or errors func (r *BinReader) ReadByteAsShort() int16 { if octet, err := r.b.ReadByte(); r.check(err) { return int16(octet) } return -1 } // ReadIntSpl reads two bytes as little-endian uint16, returns -1 for EOF or errors func (r *BinReader) ReadIntSpl() int { var val uint16 if r.check(binary.Read(r.b, binary.LittleEndian, &val)) { return int(val) } return -1 } // ReadULong returns uint64 equivalent of -1 for EOF or errors func (r *BinReader) ReadULong() uint64 { if val, err := binary.ReadUvarint(r.b); r.check(err) { return val } return 0xffffffffffffffff } // ReadPu32 returns -1 for EOF or errors func (r *BinReader) ReadPu32() int64 { if val, err := binary.ReadUvarint(r.b); r.check(err) { return int64(val) } return -1 } // ReadNBytes reads given number of bytes, returns invalid data for EOF or errors func (r *BinReader) ReadNBytes(len int) []byte { buf := make([]byte, len) n, err := r.b.Read(buf) if r.check(err) { return buf } if n != len { r.check(ErrorPrematureEOF) } return buf } // ReadBytesByLength reads buffer length and its bytes func (r *BinReader) ReadBytesByLength() []byte { len := r.ReadPu32() if len < 0 { r.check(ErrorInvalidLength) return []byte{} } return r.ReadNBytes(int(len)) } // ReadString reads a zero-terminated string with length func (r *BinReader) ReadString() string { len := int(r.ReadPu32()) if len < 1 { r.check(ErrorInvalidLength) return "" } buf := make([]byte, len-1) n, err := r.b.Read(buf) if !r.check(err) { return "" } if n != len-1 { r.check(ErrorPrematureEOF) return "" } zeroByte, err := r.b.ReadByte() if !r.check(err) { return "" } if zeroByte != 0 { r.check(ErrorZeroTerminate) return "" } return string(buf) } // ReadDate reads a Unix encoded time func (r *BinReader) ReadDate() time.Time { return time.Unix(r.ReadPu32(), 0) } rclone-v1.71.0/backend/mailru/api/m1.go000066400000000000000000000117741505210326400175550ustar00rootroot00000000000000// Package api provides types used by the Mail.ru API. package api import ( "fmt" ) // M1 protocol constants and structures const ( APIServerURL = "https://cloud.mail.ru" PublicLinkURL = "https://cloud.mail.ru/public/" DispatchServerURL = "https://dispatcher.cloud.mail.ru" OAuthURL = "https://o2.mail.ru/token" OAuthClientID = "cloud-win" ) // ServerErrorResponse represents erroneous API response. type ServerErrorResponse struct { Message string `json:"body"` Time int64 `json:"time"` Status int `json:"status"` } func (e *ServerErrorResponse) Error() string { return fmt.Sprintf("server error %d (%s)", e.Status, e.Message) } // FileErrorResponse represents erroneous API response for a file type FileErrorResponse struct { Body struct { Home struct { Value string `json:"value"` Error string `json:"error"` } `json:"home"` } `json:"body"` Status int `json:"status"` Account string `json:"email,omitempty"` Time int64 `json:"time,omitempty"` Message string // non-json, calculated field } func (e *FileErrorResponse) Error() string { return fmt.Sprintf("file error %d (%s)", e.Status, e.Body.Home.Error) } // UserInfoResponse contains account metadata type UserInfoResponse struct { Body struct { AccountType string `json:"account_type"` AccountVerified bool `json:"account_verified"` Cloud struct { Beta struct { Allowed bool `json:"allowed"` Asked bool `json:"asked"` } `json:"beta"` Billing struct { ActiveCostID string `json:"active_cost_id"` ActiveRateID string `json:"active_rate_id"` AutoProlong bool `json:"auto_prolong"` Basequota int64 `json:"basequota"` Enabled bool `json:"enabled"` Expires int64 `json:"expires"` Prolong bool `json:"prolong"` Promocodes struct { } `json:"promocodes"` Subscription []any `json:"subscription"` Version string `json:"version"` } `json:"billing"` Bonuses struct { CameraUpload bool `json:"camera_upload"` Complete bool `json:"complete"` Desktop bool `json:"desktop"` Feedback bool `json:"feedback"` Links bool `json:"links"` Mobile bool `json:"mobile"` Registration bool `json:"registration"` } `json:"bonuses"` Enable struct { Sharing bool `json:"sharing"` } `json:"enable"` FileSizeLimit int64 `json:"file_size_limit"` Space struct { BytesTotal int64 `json:"bytes_total"` BytesUsed int64 `json:"bytes_used"` Overquota bool `json:"overquota"` } `json:"space"` } `json:"cloud"` Cloudflags struct { Exists bool `json:"exists"` } `json:"cloudflags"` Domain string `json:"domain"` Login string `json:"login"` Newbie bool `json:"newbie"` UI struct { ExpandLoader bool `json:"expand_loader"` Kind string `json:"kind"` Sidebar bool `json:"sidebar"` Sort struct { Order string `json:"order"` Type string `json:"type"` } `json:"sort"` Thumbs bool `json:"thumbs"` } `json:"ui"` } `json:"body"` Email string `json:"email"` Status int `json:"status"` Time int64 `json:"time"` } // ListItem ... type ListItem struct { Count struct { Folders int `json:"folders"` Files int `json:"files"` } `json:"count,omitempty"` Kind string `json:"kind"` Type string `json:"type"` Name string `json:"name"` Home string `json:"home"` Size int64 `json:"size"` Mtime uint64 `json:"mtime,omitempty"` Hash string `json:"hash,omitempty"` VirusScan string `json:"virus_scan,omitempty"` Tree string `json:"tree,omitempty"` Grev int `json:"grev,omitempty"` Rev int `json:"rev,omitempty"` } // ItemInfoResponse ... type ItemInfoResponse struct { Email string `json:"email"` Body ListItem `json:"body"` Time int64 `json:"time"` Status int `json:"status"` } // FolderInfoResponse ... type FolderInfoResponse struct { Body struct { Count struct { Folders int `json:"folders"` Files int `json:"files"` } `json:"count"` Tree string `json:"tree"` Name string `json:"name"` Grev int `json:"grev"` Size int64 `json:"size"` Sort struct { Order string `json:"order"` Type string `json:"type"` } `json:"sort"` Kind string `json:"kind"` Rev int `json:"rev"` Type string `json:"type"` Home string `json:"home"` List []ListItem `json:"list"` } `json:"body,omitempty"` Time int64 `json:"time"` Status int `json:"status"` Email string `json:"email"` } // CleanupResponse ... type CleanupResponse struct { Email string `json:"email"` Time int64 `json:"time"` StatusStr string `json:"status"` } // GenericResponse ... type GenericResponse struct { Email string `json:"email"` Time int64 `json:"time"` Status int `json:"status"` // ignore other fields } // GenericBodyResponse ... type GenericBodyResponse struct { Email string `json:"email"` Body string `json:"body"` Time int64 `json:"time"` Status int `json:"status"` } rclone-v1.71.0/backend/mailru/mailru.go000066400000000000000000001776631505210326400177720ustar00rootroot00000000000000// Package mailru provides an interface to the Mail.ru Cloud storage system. package mailru import ( "bytes" "context" "errors" "fmt" gohash "hash" "io" "path" "path/filepath" "sort" "strconv" "strings" "sync" "time" "encoding/hex" "encoding/json" "net/http" "net/url" "github.com/rclone/rclone/backend/mailru/api" "github.com/rclone/rclone/backend/mailru/mrhash" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/object" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/oauthutil" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/readers" "github.com/rclone/rclone/lib/rest" "golang.org/x/oauth2" ) // Global constants const ( minSleepPacer = 100 * time.Millisecond maxSleepPacer = 5 * time.Second decayConstPacer = 2 // bigger for slower decay, exponential metaExpirySec = 20 * 60 // meta server expiration time serverExpirySec = 3 * 60 // download server expiration time shardExpirySec = 30 * 60 // upload server expiration time maxServerLocks = 4 // maximum number of locks per single download server maxInt32 = 2147483647 // used as limit in directory list request speedupMinSize = 512 // speedup is not optimal if data is smaller than average packet ) // Global errors var ( ErrorDirAlreadyExists = errors.New("directory already exists") ErrorDirSourceNotExists = errors.New("directory source does not exist") ErrorInvalidName = errors.New("invalid characters in object name") // MrHashType is the hash.Type for Mailru MrHashType hash.Type ) // Description of how to authorize var oauthConfig = &oauthutil.Config{ ClientID: api.OAuthClientID, ClientSecret: "", AuthURL: api.OAuthURL, TokenURL: api.OAuthURL, AuthStyle: oauth2.AuthStyleInParams, } // Register with Fs func init() { MrHashType = hash.RegisterHash("mailru", "MailruHash", 40, mrhash.New) fs.Register(&fs.RegInfo{ Name: "mailru", Description: "Mail.ru Cloud", NewFs: NewFs, Options: append(oauthutil.SharedOptions, []fs.Option{{ Name: "user", Help: "User name (usually email).", Required: true, Sensitive: true, }, { Name: "pass", Help: `Password. This must be an app password - rclone will not work with your normal password. See the Configuration section in the docs for how to make an app password. `, Required: true, IsPassword: true, }, { Name: "speedup_enable", Default: true, Advanced: false, Help: `Skip full upload if there is another file with same data hash. This feature is called "speedup" or "put by hash". It is especially efficient in case of generally available files like popular books, video or audio clips, because files are searched by hash in all accounts of all mailru users. It is meaningless and ineffective if source file is unique or encrypted. Please note that rclone may need local memory and disk space to calculate content hash in advance and decide whether full upload is required. Also, if rclone does not know file size in advance (e.g. in case of streaming or partial uploads), it will not even try this optimization.`, Examples: []fs.OptionExample{{ Value: "true", Help: "Enable", }, { Value: "false", Help: "Disable", }}, }, { Name: "speedup_file_patterns", Default: "*.mkv,*.avi,*.mp4,*.mp3,*.zip,*.gz,*.rar,*.pdf", Advanced: true, Help: `Comma separated list of file name patterns eligible for speedup (put by hash). Patterns are case insensitive and can contain '*' or '?' meta characters.`, Examples: []fs.OptionExample{{ Value: "", Help: "Empty list completely disables speedup (put by hash).", }, { Value: "*", Help: "All files will be attempted for speedup.", }, { Value: "*.mkv,*.avi,*.mp4,*.mp3", Help: "Only common audio/video files will be tried for put by hash.", }, { Value: "*.zip,*.gz,*.rar,*.pdf", Help: "Only common archives or PDF books will be tried for speedup.", }}, }, { Name: "speedup_max_disk", Default: fs.SizeSuffix(3 * 1024 * 1024 * 1024), Advanced: true, Help: `This option allows you to disable speedup (put by hash) for large files. Reason is that preliminary hashing can exhaust your RAM or disk space.`, Examples: []fs.OptionExample{{ Value: "0", Help: "Completely disable speedup (put by hash).", }, { Value: "1G", Help: "Files larger than 1Gb will be uploaded directly.", }, { Value: "3G", Help: "Choose this option if you have less than 3Gb free on local disk.", }}, }, { Name: "speedup_max_memory", Default: fs.SizeSuffix(32 * 1024 * 1024), Advanced: true, Help: `Files larger than the size given below will always be hashed on disk.`, Examples: []fs.OptionExample{{ Value: "0", Help: "Preliminary hashing will always be done in a temporary disk location.", }, { Value: "32M", Help: "Do not dedicate more than 32Mb RAM for preliminary hashing.", }, { Value: "256M", Help: "You have at most 256Mb RAM free for hash calculations.", }}, }, { Name: "check_hash", Default: true, Advanced: true, Help: "What should copy do if file checksum is mismatched or invalid.", Examples: []fs.OptionExample{{ Value: "true", Help: "Fail with error.", }, { Value: "false", Help: "Ignore and continue.", }}, }, { Name: "user_agent", Default: "", Advanced: true, Hide: fs.OptionHideBoth, Help: `HTTP user agent used internally by client. Defaults to "rclone/VERSION" or "--user-agent" provided on command line.`, }, { Name: "quirks", Default: "", Advanced: true, Hide: fs.OptionHideBoth, Help: `Comma separated list of internal maintenance flags. This option must not be used by an ordinary user. It is intended only to facilitate remote troubleshooting of backend issues. Strict meaning of flags is not documented and not guaranteed to persist between releases. Quirks will be removed when the backend grows stable. Supported quirks: atomicmkdir binlist unknowndirs`, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, // Encode invalid UTF-8 bytes as json doesn't handle them properly. Default: (encoder.Display | encoder.EncodeWin | // :?"*<>| encoder.EncodeBackSlash | encoder.EncodeInvalidUtf8), }}...), }) } // Options defines the configuration for this backend type Options struct { Username string `config:"user"` Password string `config:"pass"` UserAgent string `config:"user_agent"` CheckHash bool `config:"check_hash"` SpeedupEnable bool `config:"speedup_enable"` SpeedupPatterns string `config:"speedup_file_patterns"` SpeedupMaxDisk fs.SizeSuffix `config:"speedup_max_disk"` SpeedupMaxMem fs.SizeSuffix `config:"speedup_max_memory"` Quirks string `config:"quirks"` Enc encoder.MultiEncoder `config:"encoding"` } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 429, // Too Many Requests. 500, // Internal Server Error 502, // Bad Gateway 503, // Service Unavailable 504, // Gateway Timeout 509, // Bandwidth Limit Exceeded } // shouldRetry returns a boolean as to whether this response and err // deserve to be retried. It returns the err as a convenience. // Retries password authorization (once) in a special case of access denied. func shouldRetry(ctx context.Context, res *http.Response, err error, f *Fs, opts *rest.Opts) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } if res != nil && res.StatusCode == 403 && f.opt.Password != "" && !f.passFailed { reAuthErr := f.reAuthorize(opts, err) return reAuthErr == nil, err // return an original error } return fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(res, retryErrorCodes), err } // errorHandler parses a non 2xx error response into an error func errorHandler(res *http.Response) (err error) { data, err := rest.ReadBody(res) if err != nil { return err } fileError := &api.FileErrorResponse{} err = json.NewDecoder(bytes.NewReader(data)).Decode(fileError) if err == nil { fileError.Message = fileError.Body.Home.Error return fileError } serverError := &api.ServerErrorResponse{} err = json.NewDecoder(bytes.NewReader(data)).Decode(serverError) if err == nil { return serverError } serverError.Message = string(data) if serverError.Message == "" || strings.HasPrefix(serverError.Message, "{") { // Replace empty or JSON response with a human-readable text. serverError.Message = res.Status } serverError.Status = res.StatusCode return serverError } // Fs represents a remote mail.ru type Fs struct { name string root string // root path opt Options // parsed options ci *fs.ConfigInfo // global config speedupGlobs []string // list of file name patterns eligible for speedup speedupAny bool // true if all file names are eligible for speedup features *fs.Features // optional features srv *rest.Client // REST API client cli *http.Client // underlying HTTP client (for authorize) m configmap.Mapper // config reader (for authorize) source oauth2.TokenSource // OAuth token refresher pacer *fs.Pacer // pacer for API calls metaMu sync.Mutex // lock for meta server switcher metaURL string // URL of meta server metaExpiry time.Time // time to refresh meta server shardMu sync.Mutex // lock for upload shard switcher shardURL string // URL of upload shard shardExpiry time.Time // time to refresh upload shard fileServers serverPool // file server dispatcher authMu sync.Mutex // mutex for authorize() passFailed bool // true if authorize() failed after 403 quirks quirks // internal maintenance flags } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // fs.Debugf(nil, ">>> NewFs %q %q", name, root) // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } if opt.Password != "" { opt.Password = obscure.MustReveal(opt.Password) } // Trailing slash signals us to optimize out one file check rootIsDir := strings.HasSuffix(root, "/") // However the f.root string should not have leading or trailing slashes root = strings.Trim(root, "/") ci := fs.GetConfig(ctx) f := &Fs{ name: name, root: root, opt: *opt, ci: ci, m: m, } if err := f.parseSpeedupPatterns(opt.SpeedupPatterns); err != nil { return nil, err } f.quirks.parseQuirks(opt.Quirks) f.pacer = fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleepPacer), pacer.MaxSleep(maxSleepPacer), pacer.DecayConstant(decayConstPacer))) f.features = (&fs.Features{ CaseInsensitive: true, CanHaveEmptyDirectories: true, // Can copy/move across mailru configs (almost, thus true here), but // only when they share common account (this is checked in Copy/Move). ServerSideAcrossConfigs: true, }).Fill(ctx, f) // Override few config settings and create a client newCtx, clientConfig := fs.AddConfig(ctx) if opt.UserAgent != "" { clientConfig.UserAgent = opt.UserAgent } clientConfig.NoGzip = true // Mimic official client, skip sending "Accept-Encoding: gzip" f.cli = fshttp.NewClient(newCtx) f.srv = rest.NewClient(f.cli) f.srv.SetRoot(api.APIServerURL) f.srv.SetHeader("Accept", "*/*") // Send "Accept: */*" with every request like official client f.srv.SetErrorHandler(errorHandler) if err = f.authorize(ctx, false); err != nil { return nil, err } f.fileServers = serverPool{ pool: make(pendingServerMap), fs: f, path: "/d", expirySec: serverExpirySec, } if !rootIsDir { _, dirSize, err := f.readItemMetaData(ctx, f.root) rootIsDir = (dirSize >= 0) // Ignore non-existing item and other errors if err == nil && !rootIsDir { root = path.Dir(f.root) if root == "." { root = "" } f.root = root // Return fs that points to the parent and signal rclone to do filtering return f, fs.ErrorIsFile } } return f, nil } // Internal maintenance flags (to be removed when the backend matures). // Primarily intended to facilitate remote support and troubleshooting. type quirks struct { binlist bool atomicmkdir bool unknowndirs bool } func (q *quirks) parseQuirks(option string) { for _, flag := range strings.Split(option, ",") { switch strings.ToLower(strings.TrimSpace(flag)) { case "binlist": // The official client sometimes uses a so called "bin" protocol, // implemented in the listBin file system method below. This method // is generally faster than non-recursive listM1 but results in // sporadic deserialization failures if total size of tree data // approaches 8Kb (?). The recursive method is normally disabled. // This quirk can be used to enable it for further investigation. // Remove this quirk when the "bin" protocol support is complete. q.binlist = true case "atomicmkdir": // At the moment rclone requires Mkdir to return success if the // directory already exists. However, such programs as borgbackup // use mkdir as a locking primitive and depend on its atomicity. // Remove this quirk when the above issue is investigated. q.atomicmkdir = true case "unknowndirs": // Accepts unknown resource types as folders. q.unknowndirs = true default: // Ignore unknown flags } } } // Note: authorize() is not safe for concurrent access as it updates token source func (f *Fs) authorize(ctx context.Context, force bool) (err error) { var t *oauth2.Token if !force { t, err = oauthutil.GetToken(f.name, f.m) } if err != nil || !tokenIsValid(t) { fs.Infof(f, "Valid token not found, authorizing.") ctx := oauthutil.Context(ctx, f.cli) oauth2Conf := oauthConfig.MakeOauth2Config() t, err = oauth2Conf.PasswordCredentialsToken(ctx, f.opt.Username, f.opt.Password) } if err == nil && !tokenIsValid(t) { err = errors.New("invalid token") } if err != nil { return fmt.Errorf("failed to authorize: %w", err) } if err = oauthutil.PutToken(f.name, f.m, t, false); err != nil { return err } // Mailru API server expects access token not in the request header but // in the URL query string, so we must use a bare token source rather than // client provided by oauthutil. // // WARNING: direct use of the returned token source triggers a bug in the // `(*token != *ts.token)` comparison in oauthutil.TokenSource.Token() // crashing with panic `comparing uncomparable type map[string]interface{}` // As a workaround, mimic oauth2.NewClient() wrapping token source in // oauth2.ReuseTokenSource _, ts, err := oauthutil.NewClientWithBaseClient(ctx, f.name, f.m, oauthConfig, f.cli) if err == nil { f.source = oauth2.ReuseTokenSource(nil, ts) } return err } func tokenIsValid(t *oauth2.Token) bool { return t.Valid() && t.RefreshToken != "" && t.Type() == "Bearer" } // reAuthorize is called after getting 403 (access denied) from the server. // It handles the case when user has changed password since a previous // rclone invocation and obtains a new access token, if needed. func (f *Fs) reAuthorize(opts *rest.Opts, origErr error) error { // lock and recheck the flag to ensure authorize() is attempted only once f.authMu.Lock() defer f.authMu.Unlock() if f.passFailed { return origErr } ctx := context.Background() // Note: reAuthorize is called by ShouldRetry, no context! fs.Debugf(f, "re-authorize with new password") if err := f.authorize(ctx, true); err != nil { f.passFailed = true return err } // obtain new token, if needed tokenParameter := "" if opts != nil && opts.Parameters.Get("token") != "" { tokenParameter = "token" } if opts != nil && opts.Parameters.Get("access_token") != "" { tokenParameter = "access_token" } if tokenParameter != "" { token, err := f.accessToken() if err != nil { f.passFailed = true return err } opts.Parameters.Set(tokenParameter, token) } return nil } // accessToken() returns OAuth token and possibly refreshes it func (f *Fs) accessToken() (string, error) { token, err := f.source.Token() if err != nil { return "", fmt.Errorf("cannot refresh access token: %w", err) } return token.AccessToken, nil } // absPath converts root-relative remote to absolute home path func (f *Fs) absPath(remote string) string { return path.Join("/", f.root, remote) } // relPath converts absolute home path to root-relative remote // Note that f.root can not have leading and trailing slashes func (f *Fs) relPath(absPath string) (string, error) { target := strings.Trim(absPath, "/") if f.root == "" { return target, nil } if target == f.root { return "", nil } if strings.HasPrefix(target+"/", f.root+"/") { return target[len(f.root)+1:], nil } return "", fmt.Errorf("path %q should be under %q", absPath, f.root) } // metaServer returns URL of current meta server func (f *Fs) metaServer(ctx context.Context) (string, error) { f.metaMu.Lock() defer f.metaMu.Unlock() if f.metaURL != "" && time.Now().Before(f.metaExpiry) { return f.metaURL, nil } opts := rest.Opts{ RootURL: api.DispatchServerURL, Method: "GET", Path: "/m", } var ( res *http.Response url string err error ) err = f.pacer.Call(func() (bool, error) { res, err = f.srv.Call(ctx, &opts) if err == nil { url, err = readBodyWord(res) } return fserrors.ShouldRetry(err), err }) if err != nil { closeBody(res) return "", err } f.metaURL = url f.metaExpiry = time.Now().Add(metaExpirySec * time.Second) fs.Debugf(f, "new meta server: %s", f.metaURL) return f.metaURL, nil } // readBodyWord reads the single line response to completion // and extracts the first word from the first line. func readBodyWord(res *http.Response) (word string, err error) { var body []byte body, err = rest.ReadBody(res) if err == nil { line := strings.Trim(string(body), " \r\n") word = strings.Split(line, " ")[0] } if word == "" { return "", errors.New("empty reply from dispatcher") } return word, nil } // readItemMetaData returns a file/directory info at given full path // If it can't be found it fails with fs.ErrorObjectNotFound // For the return value `dirSize` please see Fs.itemToEntry() func (f *Fs) readItemMetaData(ctx context.Context, path string) (entry fs.DirEntry, dirSize int, err error) { token, err := f.accessToken() if err != nil { return nil, -1, err } opts := rest.Opts{ Method: "GET", Path: "/api/m1/file", Parameters: url.Values{ "access_token": {token}, "home": {f.opt.Enc.FromStandardPath(path)}, "offset": {"0"}, "limit": {strconv.Itoa(maxInt32)}, }, } var info api.ItemInfoResponse err = f.pacer.Call(func() (bool, error) { res, err := f.srv.CallJSON(ctx, &opts, nil, &info) return shouldRetry(ctx, res, err, f, &opts) }) if err != nil { if apiErr, ok := err.(*api.FileErrorResponse); ok { switch apiErr.Status { case 404: err = fs.ErrorObjectNotFound case 400: fs.Debugf(f, "object %q status %d (%s)", path, apiErr.Status, apiErr.Message) err = fs.ErrorObjectNotFound } } return } entry, dirSize, err = f.itemToDirEntry(ctx, &info.Body) return } // itemToDirEntry converts API item to rclone directory entry // The dirSize return value is: // // <0 - for a file or in case of error // =0 - for an empty directory // >0 - for a non-empty directory func (f *Fs) itemToDirEntry(ctx context.Context, item *api.ListItem) (entry fs.DirEntry, dirSize int, err error) { remote, err := f.relPath(f.opt.Enc.ToStandardPath(item.Home)) if err != nil { return nil, -1, err } modTime := time.Unix(int64(item.Mtime), 0) isDir, err := f.isDir(item.Kind, remote) if err != nil { return nil, -1, err } if isDir { dir := fs.NewDir(remote, modTime).SetSize(item.Size) return dir, item.Count.Files + item.Count.Folders, nil } binHash, err := mrhash.DecodeString(item.Hash) if err != nil { return nil, -1, err } file := &Object{ fs: f, remote: remote, hasMetaData: true, size: item.Size, mrHash: binHash, modTime: modTime, } return file, -1, nil } // isDir returns true for directories, false for files func (f *Fs) isDir(kind, path string) (bool, error) { switch kind { case "": return false, errors.New("empty resource type") case "file": return false, nil case "folder": // fall thru case "camera-upload", "mounted", "shared": fs.Debugf(f, "[%s]: folder has type %q", path, kind) default: if !f.quirks.unknowndirs { return false, fmt.Errorf("unknown resource type %q", kind) } fs.Errorf(f, "[%s]: folder has unknown type %q", path, kind) } return true, nil } // List the objects and directories in dir into entries. // The entries can be returned in any order but should be for a complete directory. // dir should be "" to list the root, and should not have trailing slashes. // This should return ErrDirNotFound if the directory isn't found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { // fs.Debugf(f, ">>> List: %q", dir) if f.quirks.binlist { entries, err = f.listBin(ctx, f.absPath(dir), 1) } else { entries, err = f.listM1(ctx, f.absPath(dir), 0, maxInt32) } if err == nil && f.ci.LogLevel >= fs.LogLevelDebug { names := []string{} for _, entry := range entries { names = append(names, entry.Remote()) } sort.Strings(names) // fs.Debugf(f, "List(%q): %v", dir, names) } return } // list using protocol "m1" func (f *Fs) listM1(ctx context.Context, dirPath string, offset int, limit int) (entries fs.DirEntries, err error) { token, err := f.accessToken() if err != nil { return nil, err } params := url.Values{} params.Set("access_token", token) params.Set("offset", strconv.Itoa(offset)) params.Set("limit", strconv.Itoa(limit)) data := url.Values{} data.Set("home", f.opt.Enc.FromStandardPath(dirPath)) opts := rest.Opts{ Method: "POST", Path: "/api/m1/folder", Parameters: params, Body: strings.NewReader(data.Encode()), ContentType: api.BinContentType, } var ( info api.FolderInfoResponse res *http.Response ) err = f.pacer.Call(func() (bool, error) { res, err = f.srv.CallJSON(ctx, &opts, nil, &info) return shouldRetry(ctx, res, err, f, &opts) }) if err != nil { apiErr, ok := err.(*api.FileErrorResponse) if ok && apiErr.Status == 404 { return nil, fs.ErrorDirNotFound } return nil, err } isDir, err := f.isDir(info.Body.Kind, dirPath) if err != nil { return nil, err } if !isDir { return nil, fs.ErrorIsFile } for _, item := range info.Body.List { entry, _, err := f.itemToDirEntry(ctx, &item) if err == nil { entries = append(entries, entry) } else { fs.Debugf(f, "Excluding path %q from list: %v", item.Home, err) } } return entries, nil } // list using protocol "bin" func (f *Fs) listBin(ctx context.Context, dirPath string, depth int) (entries fs.DirEntries, err error) { options := api.ListOptDefaults req := api.NewBinWriter() req.WritePu16(api.OperationFolderList) req.WriteString(f.opt.Enc.FromStandardPath(dirPath)) req.WritePu32(int64(depth)) req.WritePu32(int64(options)) req.WritePu32(0) token, err := f.accessToken() if err != nil { return nil, err } metaURL, err := f.metaServer(ctx) if err != nil { return nil, err } opts := rest.Opts{ Method: "POST", RootURL: metaURL, Parameters: url.Values{ "client_id": {api.OAuthClientID}, "token": {token}, }, ContentType: api.BinContentType, Body: req.Reader(), } var res *http.Response err = f.pacer.Call(func() (bool, error) { res, err = f.srv.Call(ctx, &opts) return shouldRetry(ctx, res, err, f, &opts) }) if err != nil { closeBody(res) return nil, err } r := api.NewBinReader(res.Body) defer closeBody(res) // read status switch status := r.ReadByteAsInt(); status { case api.ListResultOK: // go on... case api.ListResultNotExists: return nil, fs.ErrorDirNotFound default: return nil, fmt.Errorf("directory list error %d", status) } t := &treeState{ f: f, r: r, options: options, rootDir: parentDir(dirPath), lastDir: "", level: 0, } t.currDir = t.rootDir // read revision if err := t.revision.Read(r); err != nil { return nil, err } // read space if (options & api.ListOptTotalSpace) != 0 { t.totalSpace = int64(r.ReadULong()) } if (options & api.ListOptUsedSpace) != 0 { t.usedSpace = int64(r.ReadULong()) } t.fingerprint = r.ReadBytesByLength() // deserialize for { entry, err := t.NextRecord() if err != nil { break } if entry != nil { entries = append(entries, entry) } } if err != nil && err != fs.ErrorListAborted { fs.Debugf(f, "listBin failed at offset %d: %v", r.Count(), err) return nil, err } return entries, nil } func (t *treeState) NextRecord() (fs.DirEntry, error) { r := t.r parseOp := r.ReadByteAsShort() if r.Error() != nil { return nil, r.Error() } switch parseOp { case api.ListParseDone: return nil, fs.ErrorListAborted case api.ListParsePin: if t.lastDir == "" { return nil, errors.New("last folder is null") } t.currDir = t.lastDir t.level++ return nil, nil case api.ListParsePinUpper: if t.currDir == t.rootDir { return nil, nil } if t.level <= 0 { return nil, errors.New("no parent folder") } t.currDir = parentDir(t.currDir) t.level-- return nil, nil case api.ListParseUnknown15: skip := int(r.ReadPu32()) for range skip { r.ReadPu32() r.ReadPu32() } return nil, nil case api.ListParseReadItem: // get item (see below) default: return nil, fmt.Errorf("unknown parse operation %d", parseOp) } // get item head := r.ReadIntSpl() itemType := head & 3 if (head & 4096) != 0 { t.dunnoNodeID = r.ReadNBytes(api.DunnoNodeIDLength) } name := t.f.opt.Enc.FromStandardPath(string(r.ReadBytesByLength())) t.dunno1 = int(r.ReadULong()) t.dunno2 = 0 t.dunno3 = 0 if r.Error() != nil { return nil, r.Error() } var ( modTime time.Time size int64 binHash []byte dirSize int64 isDir = true ) switch itemType { case api.ListItemMountPoint: t.treeID = r.ReadNBytes(api.TreeIDLength) t.dunno2 = int(r.ReadULong()) t.dunno3 = int(r.ReadULong()) case api.ListItemFolder: t.dunno2 = int(r.ReadULong()) case api.ListItemSharedFolder: t.dunno2 = int(r.ReadULong()) t.treeID = r.ReadNBytes(api.TreeIDLength) case api.ListItemFile: isDir = false modTime = r.ReadDate() size = int64(r.ReadULong()) binHash = r.ReadNBytes(mrhash.Size) default: return nil, fmt.Errorf("unknown item type %d", itemType) } if isDir { t.lastDir = path.Join(t.currDir, name) if (t.options & api.ListOptDelete) != 0 { t.dunnoDel1 = int(r.ReadPu32()) t.dunnoDel2 = int(r.ReadPu32()) } if (t.options & api.ListOptFolderSize) != 0 { dirSize = int64(r.ReadULong()) } } if r.Error() != nil { return nil, r.Error() } if t.f.ci.LogLevel >= fs.LogLevelDebug { ctime, _ := modTime.MarshalJSON() fs.Debugf(t.f, "binDir %d.%d %q %q (%d) %s", t.level, itemType, t.currDir, name, size, ctime) } if t.level != 1 { // TODO: implement recursion and ListR // Note: recursion is broken because maximum buffer size is 8K return nil, nil } remote, err := t.f.relPath(path.Join(t.currDir, name)) if err != nil { return nil, err } if isDir { return fs.NewDir(remote, modTime).SetSize(dirSize), nil } obj := &Object{ fs: t.f, remote: remote, hasMetaData: true, size: size, mrHash: binHash, modTime: modTime, } return obj, nil } type treeState struct { f *Fs r *api.BinReader options int rootDir string currDir string lastDir string level int revision treeRevision totalSpace int64 usedSpace int64 fingerprint []byte dunno1 int dunno2 int dunno3 int dunnoDel1 int dunnoDel2 int dunnoNodeID []byte treeID []byte } type treeRevision struct { ver int16 treeID []byte treeIDNew []byte bgn uint64 bgnNew uint64 } func (rev *treeRevision) Read(data *api.BinReader) error { rev.ver = data.ReadByteAsShort() switch rev.ver { case 0: // Revision() case 1, 2: rev.treeID = data.ReadNBytes(api.TreeIDLength) rev.bgn = data.ReadULong() case 3, 4: rev.treeID = data.ReadNBytes(api.TreeIDLength) rev.bgn = data.ReadULong() rev.treeIDNew = data.ReadNBytes(api.TreeIDLength) rev.bgnNew = data.ReadULong() case 5: rev.treeID = data.ReadNBytes(api.TreeIDLength) rev.bgn = data.ReadULong() rev.treeIDNew = data.ReadNBytes(api.TreeIDLength) default: return fmt.Errorf("unknown directory revision %d", rev.ver) } return data.Error() } // CreateDir makes a directory (parent must exist) func (f *Fs) CreateDir(ctx context.Context, path string) error { // fs.Debugf(f, ">>> CreateDir %q", path) req := api.NewBinWriter() req.WritePu16(api.OperationCreateFolder) req.WritePu16(0) // revision req.WriteString(f.opt.Enc.FromStandardPath(path)) req.WritePu32(0) token, err := f.accessToken() if err != nil { return err } metaURL, err := f.metaServer(ctx) if err != nil { return err } opts := rest.Opts{ Method: "POST", RootURL: metaURL, Parameters: url.Values{ "client_id": {api.OAuthClientID}, "token": {token}, }, ContentType: api.BinContentType, Body: req.Reader(), } var res *http.Response err = f.pacer.Call(func() (bool, error) { res, err = f.srv.Call(ctx, &opts) return shouldRetry(ctx, res, err, f, &opts) }) if err != nil { closeBody(res) return err } reply := api.NewBinReader(res.Body) defer closeBody(res) switch status := reply.ReadByteAsInt(); status { case api.MkdirResultOK: return nil case api.MkdirResultAlreadyExists, api.MkdirResultExistsDifferentCase: return ErrorDirAlreadyExists case api.MkdirResultSourceNotExists: return ErrorDirSourceNotExists case api.MkdirResultInvalidName: return ErrorInvalidName default: return fmt.Errorf("mkdir error %d", status) } } // Mkdir creates the container (and its parents) if it doesn't exist. // Normally it ignores the ErrorDirAlreadyExist, as required by rclone tests. // Nevertheless, such programs as borgbackup or restic use mkdir as a locking // primitive and depend on its atomicity, i.e. mkdir should fail if directory // already exists. As a workaround, users can add string "atomicmkdir" in the // hidden `quirks` parameter or in the `--mailru-quirks` command-line option. func (f *Fs) Mkdir(ctx context.Context, dir string) error { // fs.Debugf(f, ">>> Mkdir %q", dir) err := f.mkDirs(ctx, f.absPath(dir)) if err == ErrorDirAlreadyExists && !f.quirks.atomicmkdir { return nil } return err } // mkDirs creates container and its parents by absolute path, // fails with ErrorDirAlreadyExists if it already exists. func (f *Fs) mkDirs(ctx context.Context, path string) error { if path == "/" || path == "" { return nil } switch err := f.CreateDir(ctx, path); err { case nil: return nil case ErrorDirSourceNotExists: fs.Debugf(f, "mkDirs by part %q", path) // fall thru... default: return err } parts := strings.Split(strings.Trim(path, "/"), "/") path = "" for _, part := range parts { if part == "" { continue } path += "/" + part switch err := f.CreateDir(ctx, path); err { case nil, ErrorDirAlreadyExists: continue default: return err } } return nil } func parentDir(absPath string) string { parent := path.Dir(strings.TrimRight(absPath, "/")) if parent == "." { parent = "" } return parent } // mkParentDirs creates parent containers by absolute path, // ignores the ErrorDirAlreadyExists func (f *Fs) mkParentDirs(ctx context.Context, path string) error { err := f.mkDirs(ctx, parentDir(path)) if err == ErrorDirAlreadyExists { return nil } return err } // Rmdir deletes a directory. // Returns an error if it isn't empty. func (f *Fs) Rmdir(ctx context.Context, dir string) error { // fs.Debugf(f, ">>> Rmdir %q", dir) return f.purgeWithCheck(ctx, dir, true, "rmdir") } // Purge deletes all the files in the directory // Optional interface: Only implement this if you have a way of deleting // all the files quicker than just running Remove() on the result of List() func (f *Fs) Purge(ctx context.Context, dir string) error { // fs.Debugf(f, ">>> Purge") return f.purgeWithCheck(ctx, dir, false, "purge") } // purgeWithCheck() removes the root directory. // Refuses if `check` is set and directory has anything in. func (f *Fs) purgeWithCheck(ctx context.Context, dir string, check bool, opName string) error { path := f.absPath(dir) if path == "/" || path == "" { // Mailru will not allow to purge root space returning status 400 return fs.ErrorNotDeletingDirs } _, dirSize, err := f.readItemMetaData(ctx, path) if err != nil { return fmt.Errorf("%s failed: %w", opName, err) } if check && dirSize > 0 { return fs.ErrorDirectoryNotEmpty } return f.delete(ctx, path, false) } func (f *Fs) delete(ctx context.Context, path string, hardDelete bool) error { token, err := f.accessToken() if err != nil { return err } data := url.Values{"home": {f.opt.Enc.FromStandardPath(path)}} opts := rest.Opts{ Method: "POST", Path: "/api/m1/file/remove", Parameters: url.Values{ "access_token": {token}, }, Body: strings.NewReader(data.Encode()), ContentType: api.BinContentType, } var response api.GenericResponse err = f.pacer.Call(func() (bool, error) { res, err := f.srv.CallJSON(ctx, &opts, nil, &response) return shouldRetry(ctx, res, err, f, &opts) }) switch { case err != nil: return err case response.Status == 200: return nil default: return fmt.Errorf("delete failed with code %d", response.Status) } } // Copy src to this remote using server-side copy operations. // This is stored with the remote path given. // It returns the destination Object and a possible error. // 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) (fs.Object, error) { // fs.Debugf(f, ">>> Copy %q %q", src.Remote(), remote) srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't copy - not same remote type") return nil, fs.ErrorCantCopy } if srcObj.fs.opt.Username != f.opt.Username { // Can copy across mailru configs only if they share common account fs.Debugf(src, "Can't copy - not same account") return nil, fs.ErrorCantCopy } srcPath := srcObj.absPath() dstPath := f.absPath(remote) overwrite := false // fs.Debugf(f, "copy %q -> %q\n", srcPath, dstPath) err := f.mkParentDirs(ctx, dstPath) if err != nil { return nil, err } data := url.Values{} data.Set("home", f.opt.Enc.FromStandardPath(srcPath)) data.Set("folder", f.opt.Enc.FromStandardPath(parentDir(dstPath))) data.Set("email", f.opt.Username) data.Set("x-email", f.opt.Username) if overwrite { data.Set("conflict", "rewrite") } else { data.Set("conflict", "rename") } token, err := f.accessToken() if err != nil { return nil, err } opts := rest.Opts{ Method: "POST", Path: "/api/m1/file/copy", Parameters: url.Values{ "access_token": {token}, }, Body: strings.NewReader(data.Encode()), ContentType: api.BinContentType, } var response api.GenericBodyResponse err = f.pacer.Call(func() (bool, error) { res, err := f.srv.CallJSON(ctx, &opts, nil, &response) return shouldRetry(ctx, res, err, f, &opts) }) if err != nil { return nil, fmt.Errorf("couldn't copy file: %w", err) } if response.Status != 200 { return nil, fmt.Errorf("copy failed with code %d", response.Status) } tmpPath := f.opt.Enc.ToStandardPath(response.Body) if tmpPath != dstPath { // fs.Debugf(f, "rename temporary file %q -> %q\n", tmpPath, dstPath) err = f.moveItemBin(ctx, tmpPath, dstPath, "rename temporary file") if err != nil { _ = f.delete(ctx, tmpPath, false) // ignore error return nil, err } } // fix modification time at destination dstObj := &Object{ fs: f, remote: remote, } err = dstObj.readMetaData(ctx, true) if err == nil && dstObj.modTime != srcObj.modTime { dstObj.modTime = srcObj.modTime err = dstObj.addFileMetaData(ctx, true) } if err != nil { dstObj = nil } return dstObj, err } // Move src to this remote using server-side move operations. // This is stored with the remote path given. // It returns the destination Object and a possible error. // 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) (fs.Object, error) { // fs.Debugf(f, ">>> Move %q %q", src.Remote(), remote) srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't move - not same remote type") return nil, fs.ErrorCantMove } if srcObj.fs.opt.Username != f.opt.Username { // Can move across mailru configs only if they share common account fs.Debugf(src, "Can't move - not same account") return nil, fs.ErrorCantMove } srcPath := srcObj.absPath() dstPath := f.absPath(remote) err := f.mkParentDirs(ctx, dstPath) if err != nil { return nil, err } err = f.moveItemBin(ctx, srcPath, dstPath, "move file") if err != nil { return nil, err } return f.NewObject(ctx, remote) } // move/rename an object using BIN protocol func (f *Fs) moveItemBin(ctx context.Context, srcPath, dstPath, opName string) error { token, err := f.accessToken() if err != nil { return err } metaURL, err := f.metaServer(ctx) if err != nil { return err } req := api.NewBinWriter() req.WritePu16(api.OperationRename) req.WritePu32(0) // old revision req.WriteString(f.opt.Enc.FromStandardPath(srcPath)) req.WritePu32(0) // new revision req.WriteString(f.opt.Enc.FromStandardPath(dstPath)) req.WritePu32(0) // dunno opts := rest.Opts{ Method: "POST", RootURL: metaURL, Parameters: url.Values{ "client_id": {api.OAuthClientID}, "token": {token}, }, ContentType: api.BinContentType, Body: req.Reader(), } var res *http.Response err = f.pacer.Call(func() (bool, error) { res, err = f.srv.Call(ctx, &opts) return shouldRetry(ctx, res, err, f, &opts) }) if err != nil { closeBody(res) return err } reply := api.NewBinReader(res.Body) defer closeBody(res) switch status := reply.ReadByteAsInt(); status { case api.MoveResultOK: return nil default: return fmt.Errorf("%s failed with error %d", opName, status) } } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // Will only be called if src.Fs().Name() == f.Name() // If it isn't possible then return fs.ErrorCantDirMove // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { // fs.Debugf(f, ">>> DirMove %q %q", srcRemote, dstRemote) srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } if srcFs.opt.Username != f.opt.Username { // Can move across mailru configs only if they share common account fs.Debugf(src, "Can't move - not same account") return fs.ErrorCantDirMove } srcPath := srcFs.absPath(srcRemote) dstPath := f.absPath(dstRemote) // fs.Debugf(srcFs, "DirMove [%s]%q --> [%s]%q\n", srcRemote, srcPath, dstRemote, dstPath) // Refuse to move to or from the root if len(srcPath) <= len(srcFs.root) || len(dstPath) <= len(f.root) { fs.Debugf(src, "DirMove error: Can't move root") return errors.New("can't move root directory") } err := f.mkParentDirs(ctx, dstPath) if err != nil { return err } _, _, err = f.readItemMetaData(ctx, dstPath) switch err { case fs.ErrorObjectNotFound: // OK! case nil: return fs.ErrorDirExists default: return err } return f.moveItemBin(ctx, srcPath, dstPath, "directory move") } // PublicLink generates a public link to the remote path (usually readable by anyone) func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (link string, err error) { // fs.Debugf(f, ">>> PublicLink %q", remote) token, err := f.accessToken() if err != nil { return "", err } data := url.Values{} data.Set("home", f.opt.Enc.FromStandardPath(f.absPath(remote))) data.Set("email", f.opt.Username) data.Set("x-email", f.opt.Username) opts := rest.Opts{ Method: "POST", Path: "/api/m1/file/publish", Parameters: url.Values{ "access_token": {token}, }, Body: strings.NewReader(data.Encode()), ContentType: api.BinContentType, } var response api.GenericBodyResponse err = f.pacer.Call(func() (bool, error) { res, err := f.srv.CallJSON(ctx, &opts, nil, &response) return shouldRetry(ctx, res, err, f, &opts) }) if err == nil && response.Body != "" { return api.PublicLinkURL + response.Body, nil } if err == nil { return "", errors.New("server returned empty link") } if apiErr, ok := err.(*api.FileErrorResponse); ok && apiErr.Status == 404 { return "", fs.ErrorObjectNotFound } return "", err } // CleanUp permanently deletes all trashed files/folders func (f *Fs) CleanUp(ctx context.Context) error { // fs.Debugf(f, ">>> CleanUp") token, err := f.accessToken() if err != nil { return err } data := url.Values{ "email": {f.opt.Username}, "x-email": {f.opt.Username}, } opts := rest.Opts{ Method: "POST", Path: "/api/m1/trashbin/empty", Parameters: url.Values{ "access_token": {token}, }, Body: strings.NewReader(data.Encode()), ContentType: api.BinContentType, } var response api.CleanupResponse err = f.pacer.Call(func() (bool, error) { res, err := f.srv.CallJSON(ctx, &opts, nil, &response) return shouldRetry(ctx, res, err, f, &opts) }) if err != nil { return err } switch response.StatusStr { case "200": return nil default: return fmt.Errorf("cleanup failed (%s)", response.StatusStr) } } // About gets quota information func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { // fs.Debugf(f, ">>> About") token, err := f.accessToken() if err != nil { return nil, err } opts := rest.Opts{ Method: "GET", Path: "/api/m1/user", Parameters: url.Values{ "access_token": {token}, }, } var info api.UserInfoResponse err = f.pacer.Call(func() (bool, error) { res, err := f.srv.CallJSON(ctx, &opts, nil, &info) return shouldRetry(ctx, res, err, f, &opts) }) if err != nil { return nil, err } total := info.Body.Cloud.Space.BytesTotal used := info.Body.Cloud.Space.BytesUsed usage := &fs.Usage{ Total: fs.NewUsageValue(total), Used: fs.NewUsageValue(used), Free: fs.NewUsageValue(total - used), } return usage, nil } // Put the object // Copy the reader in to the new object which is returned // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { o := &Object{ fs: f, remote: src.Remote(), size: src.Size(), modTime: src.ModTime(ctx), } // fs.Debugf(f, ">>> Put: %q %d '%v'", o.remote, o.size, o.modTime) return o, o.Update(ctx, in, src, options...) } // Update an existing object // Copy the reader into the object updating modTime and size // The new object may have been created if an error is returned func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { wrapIn := in size := src.Size() if size < 0 { return errors.New("mailru does not support streaming uploads") } err := o.fs.mkParentDirs(ctx, o.absPath()) if err != nil { return err } var ( fileBuf []byte fileHash []byte newHash []byte slowHash bool localSrc bool ) if srcObj := fs.UnWrapObjectInfo(src); srcObj != nil { srcFeatures := srcObj.Fs().Features() slowHash = srcFeatures.SlowHash localSrc = srcFeatures.IsLocal } // Try speedup if it's globally enabled but skip extra post // request if file is small and fits in the metadata request trySpeedup := o.fs.opt.SpeedupEnable && size > mrhash.Size // Try to get the hash if it's instant if trySpeedup && !slowHash { if srcHash, err := src.Hash(ctx, MrHashType); err == nil && srcHash != "" { fileHash, _ = mrhash.DecodeString(srcHash) } if fileHash != nil { if o.putByHash(ctx, fileHash, src, "source") { return nil } trySpeedup = false // speedup failed, force upload } } // Need to calculate hash, check whether file is still eligible for speedup trySpeedup = trySpeedup && o.fs.eligibleForSpeedup(o.Remote(), size, options...) // Attempt to put by hash if file is local and eligible if trySpeedup && localSrc { if srcHash, err := src.Hash(ctx, MrHashType); err == nil && srcHash != "" { fileHash, _ = mrhash.DecodeString(srcHash) } if fileHash != nil && o.putByHash(ctx, fileHash, src, "localfs") { return nil } // If local file hashing has failed, it's pointless to try anymore trySpeedup = false } // Attempt to put by calculating hash in memory if trySpeedup && size <= int64(o.fs.opt.SpeedupMaxMem) { fileBuf, err = io.ReadAll(in) if err != nil { return err } fileHash = mrhash.Sum(fileBuf) if o.putByHash(ctx, fileHash, src, "memory") { return nil } wrapIn = bytes.NewReader(fileBuf) trySpeedup = false // speedup failed, force upload } // Attempt to put by hash using a spool file if trySpeedup { tmpFs, err := fs.TemporaryLocalFs(ctx) if err != nil { fs.Infof(tmpFs, "Failed to create spool FS: %v", err) } else { defer func() { if err := operations.Purge(ctx, tmpFs, ""); err != nil { fs.Infof(tmpFs, "Failed to cleanup spool FS: %v", err) } }() spoolFile, mrHash, err := makeTempFile(ctx, tmpFs, wrapIn, src) if err != nil { return fmt.Errorf("failed to create spool file: %w", err) } if o.putByHash(ctx, mrHash, src, "spool") { // If put by hash is successful, ignore transitive error return nil } if wrapIn, err = spoolFile.Open(ctx); err != nil { return err } fileHash = mrHash } } // Upload object data if size <= mrhash.Size { // Optimize upload: skip extra request if data fits in the hash buffer. if fileBuf == nil { fileBuf, err = io.ReadAll(wrapIn) } if fileHash == nil && err == nil { fileHash = mrhash.Sum(fileBuf) } newHash = fileHash } else { var hasher gohash.Hash if fileHash == nil { // Calculate hash in transit hasher = mrhash.New() wrapIn = io.TeeReader(wrapIn, hasher) } newHash, err = o.upload(ctx, wrapIn, size, options...) if fileHash == nil && err == nil { fileHash = hasher.Sum(nil) } } if err != nil { return err } if !bytes.Equal(fileHash, newHash) { if o.fs.opt.CheckHash { return mrhash.ErrorInvalidHash } fs.Infof(o, "hash mismatch on upload: expected %x received %x", fileHash, newHash) } o.mrHash = newHash o.size = size o.modTime = src.ModTime(ctx) return o.addFileMetaData(ctx, true) } // eligibleForSpeedup checks whether file is eligible for speedup method (put by hash) func (f *Fs) eligibleForSpeedup(remote string, size int64, options ...fs.OpenOption) bool { if !f.opt.SpeedupEnable { return false } if size <= mrhash.Size || size < speedupMinSize || size >= int64(f.opt.SpeedupMaxDisk) { return false } _, _, partial := getTransferRange(size, options...) if partial { return false } if f.speedupAny { return true } if f.speedupGlobs == nil { return false } nameLower := strings.ToLower(strings.TrimSpace(path.Base(remote))) for _, pattern := range f.speedupGlobs { if matches, _ := filepath.Match(pattern, nameLower); matches { return true } } return false } // parseSpeedupPatterns converts pattern string into list of unique glob patterns func (f *Fs) parseSpeedupPatterns(patternString string) (err error) { f.speedupGlobs = nil f.speedupAny = false uniqueValidPatterns := make(map[string]any) for _, pattern := range strings.Split(patternString, ",") { pattern = strings.ToLower(strings.TrimSpace(pattern)) if pattern == "" { continue } if pattern == "*" { f.speedupAny = true } if _, err := filepath.Match(pattern, ""); err != nil { return fmt.Errorf("invalid file name pattern %q", pattern) } uniqueValidPatterns[pattern] = nil } for pattern := range uniqueValidPatterns { f.speedupGlobs = append(f.speedupGlobs, pattern) } return nil } // putByHash is a thin wrapper around addFileMetaData func (o *Object) putByHash(ctx context.Context, mrHash []byte, info fs.ObjectInfo, method string) bool { oNew := new(Object) *oNew = *o oNew.mrHash = mrHash oNew.size = info.Size() oNew.modTime = info.ModTime(ctx) if err := oNew.addFileMetaData(ctx, true); err != nil { fs.Debugf(o, "Cannot put by hash from %s, performing upload", method) return false } *o = *oNew fs.Debugf(o, "File has been put by hash from %s", method) return true } func makeTempFile(ctx context.Context, tmpFs fs.Fs, wrapIn io.Reader, src fs.ObjectInfo) (spoolFile fs.Object, mrHash []byte, err error) { // Local temporary file system must support SHA1 hashType := hash.SHA1 // Calculate Mailru and spool verification hashes in transit hashSet := hash.NewHashSet(MrHashType, hashType) hasher, err := hash.NewMultiHasherTypes(hashSet) if err != nil { return nil, nil, err } wrapIn = io.TeeReader(wrapIn, hasher) // Copy stream into spool file tmpInfo := object.NewStaticObjectInfo(src.Remote(), src.ModTime(ctx), src.Size(), false, nil, nil) hashOption := &fs.HashesOption{Hashes: hashSet} if spoolFile, err = tmpFs.Put(ctx, wrapIn, tmpInfo, hashOption); err != nil { return nil, nil, err } // Validate spool file sums := hasher.Sums() checkSum := sums[hashType] fileSum, err := spoolFile.Hash(ctx, hashType) if spoolFile.Size() != src.Size() || err != nil || checkSum == "" || fileSum != checkSum { return nil, nil, mrhash.ErrorInvalidHash } mrHash, err = mrhash.DecodeString(sums[MrHashType]) return } func (o *Object) upload(ctx context.Context, in io.Reader, size int64, options ...fs.OpenOption) ([]byte, error) { token, err := o.fs.accessToken() if err != nil { return nil, err } shardURL, err := o.fs.uploadShard(ctx) if err != nil { return nil, err } opts := rest.Opts{ Method: "PUT", RootURL: shardURL, Body: in, Options: options, ContentLength: &size, Parameters: url.Values{ "client_id": {api.OAuthClientID}, "token": {token}, }, ExtraHeaders: map[string]string{ "Accept": "*/*", }, } var ( res *http.Response strHash string ) err = o.fs.pacer.Call(func() (bool, error) { res, err = o.fs.srv.Call(ctx, &opts) if err == nil { strHash, err = readBodyWord(res) } return fserrors.ShouldRetry(err), err }) if err != nil { closeBody(res) return nil, err } switch res.StatusCode { case 200, 201: return mrhash.DecodeString(strHash) default: return nil, fmt.Errorf("upload failed with code %s (%d)", res.Status, res.StatusCode) } } func (f *Fs) uploadShard(ctx context.Context) (string, error) { f.shardMu.Lock() defer f.shardMu.Unlock() if f.shardURL != "" && time.Now().Before(f.shardExpiry) { return f.shardURL, nil } opts := rest.Opts{ RootURL: api.DispatchServerURL, Method: "GET", Path: "/u", } var ( res *http.Response url string err error ) err = f.pacer.Call(func() (bool, error) { res, err = f.srv.Call(ctx, &opts) if err == nil { url, err = readBodyWord(res) } return fserrors.ShouldRetry(err), err }) if err != nil { closeBody(res) return "", err } f.shardURL = url f.shardExpiry = time.Now().Add(shardExpirySec * time.Second) fs.Debugf(f, "new upload shard: %s", f.shardURL) return f.shardURL, nil } // Object describes a mailru object type Object struct { fs *Fs // what this object is part of remote string // The remote path hasMetaData bool // whether info below has been set size int64 // Bytes in the object modTime time.Time // Modified time of the object mrHash []byte // Mail.ru flavored SHA1 hash of the object } // NewObject finds an Object at the remote. // If object can't be found it fails with fs.ErrorObjectNotFound func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { // fs.Debugf(f, ">>> NewObject %q", remote) o := &Object{ fs: f, remote: remote, } err := o.readMetaData(ctx, true) if err != nil { return nil, err } return o, nil } // absPath converts root-relative remote to absolute home path func (o *Object) absPath() string { return o.fs.absPath(o.remote) } // Object.readMetaData reads and fills a file info // If object can't be found it fails with fs.ErrorObjectNotFound func (o *Object) readMetaData(ctx context.Context, force bool) error { if o.hasMetaData && !force { return nil } entry, dirSize, err := o.fs.readItemMetaData(ctx, o.absPath()) if err != nil { return err } newObj, ok := entry.(*Object) if !ok || dirSize >= 0 { return fs.ErrorIsDir } if newObj.remote != o.remote { return fmt.Errorf("file %q path has changed to %q", o.remote, newObj.remote) } o.hasMetaData = true o.size = newObj.size o.modTime = newObj.modTime o.mrHash = newObj.mrHash return nil } // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } //return fmt.Sprintf("[%s]%q", o.fs.root, o.remote) return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // ModTime returns the modification time of the object // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers func (o *Object) ModTime(ctx context.Context) time.Time { err := o.readMetaData(ctx, false) if err != nil { fs.Errorf(o, "%v", err) } return o.modTime } // Size returns the size of an object in bytes func (o *Object) Size() int64 { ctx := context.Background() // Note: Object.Size does not pass context! err := o.readMetaData(ctx, false) if err != nil { fs.Errorf(o, "%v", err) } return o.size } // Hash returns the MD5 or SHA1 sum of an object // returning a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if t == MrHashType { return hex.EncodeToString(o.mrHash), nil } return "", hash.ErrUnsupported } // Storable returns whether this object is storable func (o *Object) Storable() bool { return true } // SetModTime sets the modification time of the local fs object // // Commits the datastore func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { // fs.Debugf(o, ">>> SetModTime [%v]", modTime) o.modTime = modTime return o.addFileMetaData(ctx, true) } func (o *Object) addFileMetaData(ctx context.Context, overwrite bool) error { if len(o.mrHash) != mrhash.Size { return mrhash.ErrorInvalidHash } token, err := o.fs.accessToken() if err != nil { return err } metaURL, err := o.fs.metaServer(ctx) if err != nil { return err } req := api.NewBinWriter() req.WritePu16(api.OperationAddFile) req.WritePu16(0) // revision req.WriteString(o.fs.opt.Enc.FromStandardPath(o.absPath())) req.WritePu64(o.size) req.WriteP64(o.modTime.Unix()) req.WritePu32(0) req.Write(o.mrHash) if overwrite { // overwrite req.WritePu32(1) } else { // don't add if not changed, add with rename if changed req.WritePu32(55) req.Write(o.mrHash) req.WritePu64(o.size) } opts := rest.Opts{ Method: "POST", RootURL: metaURL, Parameters: url.Values{ "client_id": {api.OAuthClientID}, "token": {token}, }, ContentType: api.BinContentType, Body: req.Reader(), } var res *http.Response err = o.fs.pacer.Call(func() (bool, error) { res, err = o.fs.srv.Call(ctx, &opts) return shouldRetry(ctx, res, err, o.fs, &opts) }) if err != nil { closeBody(res) return err } reply := api.NewBinReader(res.Body) defer closeBody(res) switch status := reply.ReadByteAsInt(); status { case api.AddResultOK, api.AddResultNotModified, api.AddResultDunno04, api.AddResultDunno09: return nil case api.AddResultInvalidName: return ErrorInvalidName default: return fmt.Errorf("add file error %d", status) } } // Remove an object func (o *Object) Remove(ctx context.Context) error { // fs.Debugf(o, ">>> Remove") return o.fs.delete(ctx, o.absPath(), false) } // getTransferRange detects partial transfers and calculates start/end offsets into file func getTransferRange(size int64, options ...fs.OpenOption) (start int64, end int64, partial bool) { var offset, limit int64 = 0, -1 for _, option := range options { switch opt := option.(type) { case *fs.SeekOption: offset = opt.Offset case *fs.RangeOption: offset, limit = opt.Decode(size) default: if option.Mandatory() { fs.Errorf(nil, "Unsupported mandatory option: %v", option) } } } if limit < 0 { limit = size - offset } end = min(offset+limit, size) partial = !(offset == 0 && end == size) return offset, end, partial } // Open an object for read and download its content func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { // fs.Debugf(o, ">>> Open") token, err := o.fs.accessToken() if err != nil { return nil, err } start, end, partialRequest := getTransferRange(o.size, options...) headers := map[string]string{ "Accept": "*/*", "Content-Type": "application/octet-stream", } if partialRequest { rangeStr := fmt.Sprintf("bytes=%d-%d", start, end-1) headers["Range"] = rangeStr // headers["Content-Range"] = rangeStr headers["Accept-Ranges"] = "bytes" } // TODO: set custom timeouts opts := rest.Opts{ Method: "GET", Options: options, Path: url.PathEscape(strings.TrimLeft(o.fs.opt.Enc.FromStandardPath(o.absPath()), "/")), Parameters: url.Values{ "client_id": {api.OAuthClientID}, "token": {token}, }, ExtraHeaders: headers, } var res *http.Response server := "" err = o.fs.pacer.Call(func() (bool, error) { server, err = o.fs.fileServers.Dispatch(ctx, server) if err != nil { return false, err } opts.RootURL = server res, err = o.fs.srv.Call(ctx, &opts) return shouldRetry(ctx, res, err, o.fs, &opts) }) if err != nil { if res != nil && res.Body != nil { closeBody(res) } return nil, err } // Server should respond with Status 206 and Content-Range header to a range // request. Status 200 (and no Content-Range) means a full-content response. partialResponse := res.StatusCode == 206 var ( hasher gohash.Hash wrapStream io.ReadCloser ) if !partialResponse { // Cannot check hash of partial download hasher = mrhash.New() } wrapStream = &endHandler{ ctx: ctx, stream: res.Body, hasher: hasher, o: o, server: server, } if partialRequest && !partialResponse { fs.Debugf(o, "Server returned full content instead of range") if start > 0 { // Discard the beginning of the data _, err = io.CopyN(io.Discard, wrapStream, start) if err != nil { closeBody(res) return nil, err } } wrapStream = readers.NewLimitedReadCloser(wrapStream, end-start) } return wrapStream, nil } type endHandler struct { ctx context.Context stream io.ReadCloser hasher gohash.Hash o *Object server string done bool } func (e *endHandler) Read(p []byte) (n int, err error) { n, err = e.stream.Read(p) if e.hasher != nil { // hasher will not return an error, just panic _, _ = e.hasher.Write(p[:n]) } if err != nil { // io.Error or EOF err = e.handle(err) } return } func (e *endHandler) Close() error { _ = e.handle(nil) // ignore returned error return e.stream.Close() } func (e *endHandler) handle(err error) error { if e.done { return err } e.done = true o := e.o o.fs.fileServers.Free(e.server) if err != io.EOF || e.hasher == nil { return err } newHash := e.hasher.Sum(nil) if bytes.Equal(o.mrHash, newHash) { return io.EOF } if o.fs.opt.CheckHash { return mrhash.ErrorInvalidHash } fs.Infof(o, "hash mismatch on download: expected %x received %x", o.mrHash, newHash) return io.EOF } // serverPool backs server dispatcher type serverPool struct { pool pendingServerMap mu sync.Mutex path string expirySec int fs *Fs } type pendingServerMap map[string]*pendingServer type pendingServer struct { locks int expiry time.Time } // Dispatch dispatches next download server. // It prefers switching and tries to avoid current server // in use by caller because it may be overloaded or slow. func (p *serverPool) Dispatch(ctx context.Context, current string) (string, error) { now := time.Now() url := p.getServer(current, now) if url != "" { return url, nil } // Server not found - ask Mailru dispatcher. opts := rest.Opts{ Method: "GET", RootURL: api.DispatchServerURL, Path: p.path, } var ( res *http.Response err error ) err = p.fs.pacer.Call(func() (bool, error) { res, err = p.fs.srv.Call(ctx, &opts) if err != nil { return fserrors.ShouldRetry(err), err } url, err = readBodyWord(res) return fserrors.ShouldRetry(err), err }) if err != nil || url == "" { closeBody(res) return "", fmt.Errorf("failed to request file server: %w", err) } p.addServer(url, now) return url, nil } func (p *serverPool) Free(url string) { if url == "" { return } p.mu.Lock() defer p.mu.Unlock() srv := p.pool[url] if srv == nil { return } if srv.locks <= 0 { // Getting here indicates possible race fs.Infof(p.fs, "Purge file server: locks -, url %s", url) delete(p.pool, url) return } srv.locks-- if srv.locks == 0 && time.Now().After(srv.expiry) { delete(p.pool, url) fs.Debugf(p.fs, "Free file server: locks 0, url %s", url) return } fs.Debugf(p.fs, "Unlock file server: locks %d, url %s", srv.locks, url) } // Find an underlocked server func (p *serverPool) getServer(current string, now time.Time) string { p.mu.Lock() defer p.mu.Unlock() for url, srv := range p.pool { if url == "" || srv.locks < 0 { continue // Purged server slot } if url == current { continue // Current server - prefer another } if srv.locks >= maxServerLocks { continue // Overlocked server } if now.After(srv.expiry) { continue // Expired server } srv.locks++ fs.Debugf(p.fs, "Lock file server: locks %d, url %s", srv.locks, url) return url } return "" } func (p *serverPool) addServer(url string, now time.Time) { p.mu.Lock() defer p.mu.Unlock() expiry := now.Add(time.Duration(p.expirySec) * time.Second) expiryStr := []byte("-") if p.fs.ci.LogLevel >= fs.LogLevelInfo { expiryStr, _ = expiry.MarshalJSON() } // Attach to a server proposed by dispatcher srv := p.pool[url] if srv != nil { srv.locks++ srv.expiry = expiry fs.Debugf(p.fs, "Reuse file server: locks %d, url %s, expiry %s", srv.locks, url, expiryStr) return } // Add new server p.pool[url] = &pendingServer{locks: 1, expiry: expiry} fs.Debugf(p.fs, "Switch file server: locks 1, url %s, expiry %s", url, expiryStr) } // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("[%s]", f.root) } // Precision return the precision of this Fs func (f *Fs) Precision() time.Duration { return time.Second } // Hashes returns the supported hash sets func (f *Fs) Hashes() hash.Set { return hash.Set(MrHashType) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // close response body ignoring errors func closeBody(res *http.Response) { if res != nil { _ = res.Body.Close() } } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.Copier = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.PublicLinker = (*Fs)(nil) _ fs.CleanUpper = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.Object = (*Object)(nil) ) rclone-v1.71.0/backend/mailru/mailru_test.go000066400000000000000000000006551505210326400210130ustar00rootroot00000000000000// Test Mailru filesystem interface package mailru_test import ( "testing" "github.com/rclone/rclone/backend/mailru" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestMailru:", NilObject: (*mailru.Object)(nil), SkipBadWindowsCharacters: true, }) } rclone-v1.71.0/backend/mailru/mrhash/000077500000000000000000000000001505210326400174105ustar00rootroot00000000000000rclone-v1.71.0/backend/mailru/mrhash/mrhash.go000066400000000000000000000064051505210326400212260ustar00rootroot00000000000000// Package mrhash implements the mailru hash, which is a modified SHA1. // If file size is less than or equal to the SHA1 block size (20 bytes), // its hash is simply its data right-padded with zero bytes. // Hash sum of a larger file is computed as a SHA1 sum of the file data // bytes concatenated with a decimal representation of the data length. package mrhash import ( "crypto/sha1" "encoding" "encoding/hex" "errors" "hash" "strconv" ) const ( // BlockSize of the checksum in bytes. BlockSize = sha1.BlockSize // Size of the checksum in bytes. Size = sha1.Size startString = "mrCloud" hashError = "hash function returned error" ) // Global errors var ( ErrorInvalidHash = errors.New("invalid hash") ) type digest struct { total int // bytes written into hash so far sha hash.Hash // underlying SHA1 small []byte // small content } // New returns a new hash.Hash computing the Mailru checksum. func New() hash.Hash { d := &digest{} d.Reset() return d } // Write writes len(p) bytes from p to the underlying data stream. It returns // the number of bytes written from p (0 <= n <= len(p)) and any error // encountered that caused the write to stop early. Write must return a non-nil // error if it returns n < len(p). Write must not modify the slice data, even // temporarily. // // Implementations must not retain p. func (d *digest) Write(p []byte) (n int, err error) { n, err = d.sha.Write(p) if err != nil { panic(hashError) } d.total += n if d.total <= Size { d.small = append(d.small, p...) } return n, nil } // Sum appends the current hash to b and returns the resulting slice. // It does not change the underlying hash state. func (d *digest) Sum(b []byte) []byte { // If content is small, return it padded to Size if d.total <= Size { padded := make([]byte, Size) copy(padded, d.small) return append(b, padded...) } endString := strconv.Itoa(d.total) copy, err := cloneSHA1(d.sha) if err == nil { _, err = copy.Write([]byte(endString)) } if err != nil { panic(hashError) } return copy.Sum(b) } // cloneSHA1 clones state of SHA1 hash func cloneSHA1(orig hash.Hash) (clone hash.Hash, err error) { state, err := orig.(encoding.BinaryMarshaler).MarshalBinary() if err != nil { return nil, err } clone = sha1.New() err = clone.(encoding.BinaryUnmarshaler).UnmarshalBinary(state) return } // Reset resets the Hash to its initial state. func (d *digest) Reset() { d.sha = sha1.New() _, _ = d.sha.Write([]byte(startString)) d.total = 0 } // Size returns the number of bytes Sum will return. func (d *digest) Size() int { return Size } // BlockSize returns the hash's underlying block size. // The Write method must be able to accept any amount // of data, but it may operate more efficiently if all writes // are a multiple of the block size. func (d *digest) BlockSize() int { return BlockSize } // Sum returns the Mailru checksum of the data. func Sum(data []byte) []byte { var d digest d.Reset() _, _ = d.Write(data) return d.Sum(nil) } // DecodeString converts a string to the Mailru hash func DecodeString(s string) ([]byte, error) { b, err := hex.DecodeString(s) if err != nil || len(b) != Size { return nil, ErrorInvalidHash } return b, nil } // must implement this interface var ( _ hash.Hash = (*digest)(nil) ) rclone-v1.71.0/backend/mailru/mrhash/mrhash_test.go000066400000000000000000000051301505210326400222570ustar00rootroot00000000000000package mrhash_test import ( "encoding/hex" "fmt" "testing" "github.com/rclone/rclone/backend/mailru/mrhash" "github.com/stretchr/testify/assert" ) func testChunk(t *testing.T, chunk int) { data := make([]byte, chunk) for i := range chunk { data[i] = 'A' } for _, test := range []struct { n int want string }{ {0, "0000000000000000000000000000000000000000"}, {1, "4100000000000000000000000000000000000000"}, {2, "4141000000000000000000000000000000000000"}, {19, "4141414141414141414141414141414141414100"}, {20, "4141414141414141414141414141414141414141"}, {21, "eb1d05e78a18691a5aa196a6c2b60cd40b5faafb"}, {22, "037e6d960601118a0639afbeff30fe716c66ed2d"}, {4096, "45a16aa192502b010280fb5b44274c601a91fd9f"}, {4194303, "fa019d5bd26498cf6abe35e0d61801bf19bf704b"}, {4194304, "5ed0e07aa6ea5c1beb9402b4d807258f27d40773"}, {4194305, "67bd0b9247db92e0e7d7e29a0947a50fedcb5452"}, {8388607, "41a8e2eb044c2e242971b5445d7be2a13fc0dd84"}, {8388608, "267a970917c624c11fe624276ec60233a66dc2c0"}, {8388609, "37b60b308d553d2732aefb62b3ea88f74acfa13f"}, } { d := mrhash.New() var toWrite int for toWrite = test.n; toWrite >= chunk; toWrite -= chunk { n, err := d.Write(data) assert.Nil(t, err) assert.Equal(t, chunk, n) } n, err := d.Write(data[:toWrite]) assert.Nil(t, err) assert.Equal(t, toWrite, n) got1 := hex.EncodeToString(d.Sum(nil)) assert.Equal(t, test.want, got1, fmt.Sprintf("when testing length %d", n)) got2 := hex.EncodeToString(d.Sum(nil)) assert.Equal(t, test.want, got2, fmt.Sprintf("when testing length %d (2nd sum)", n)) } } func TestHashChunk16M(t *testing.T) { testChunk(t, 16*1024*1024) } func TestHashChunk8M(t *testing.T) { testChunk(t, 8*1024*1024) } func TestHashChunk4M(t *testing.T) { testChunk(t, 4*1024*1024) } func TestHashChunk2M(t *testing.T) { testChunk(t, 2*1024*1024) } func TestHashChunk1M(t *testing.T) { testChunk(t, 1*1024*1024) } func TestHashChunk64k(t *testing.T) { testChunk(t, 64*1024) } func TestHashChunk32k(t *testing.T) { testChunk(t, 32*1024) } func TestHashChunk2048(t *testing.T) { testChunk(t, 2048) } func TestHashChunk2047(t *testing.T) { testChunk(t, 2047) } func TestSumCalledTwice(t *testing.T) { d := mrhash.New() assert.NotPanics(t, func() { d.Sum(nil) }) d.Reset() assert.NotPanics(t, func() { d.Sum(nil) }) assert.NotPanics(t, func() { d.Sum(nil) }) _, _ = d.Write([]byte{1}) assert.NotPanics(t, func() { d.Sum(nil) }) } func TestSize(t *testing.T) { d := mrhash.New() assert.Equal(t, 20, d.Size()) } func TestBlockSize(t *testing.T) { d := mrhash.New() assert.Equal(t, 64, d.BlockSize()) } rclone-v1.71.0/backend/mega/000077500000000000000000000000001505210326400155465ustar00rootroot00000000000000rclone-v1.71.0/backend/mega/mega.go000066400000000000000000001033671505210326400170200ustar00rootroot00000000000000// Package mega provides an interface to the Mega // object storage system. package mega /* Open questions * Does mega support a content hash - what exactly are the mega hashes? * Can mega support setting modification times? Improvements: * Uploads could be done in parallel * Downloads would be more efficient done in one go * Uploads would be more efficient with bigger chunks * Looks like mega can support server-side copy, but it isn't implemented in go-mega * Upload can set modtime... - set as int64_t - can set ctime and mtime? */ import ( "context" "crypto/tls" "errors" "fmt" "io" "net/http" "path" "slices" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/readers" mega "github.com/t3rm1n4l/go-mega" ) const ( minSleep = 10 * time.Millisecond maxSleep = 2 * time.Second eventWaitTime = 500 * time.Millisecond decayConstant = 2 // bigger for slower decay, exponential ) var ( megaCacheMu sync.Mutex // mutex for the below megaCache = map[string]*mega.Mega{} // cache logged in Mega's by user ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "mega", Description: "Mega", NewFs: NewFs, Options: []fs.Option{{ Name: "user", Help: "User name.", Required: true, Sensitive: true, }, { Name: "pass", Help: "Password.", Required: true, IsPassword: true, }, { Name: "debug", Help: `Output more debug from Mega. If this flag is set (along with -vv) it will print further debugging information from the mega backend.`, Default: false, Advanced: true, }, { Name: "hard_delete", Help: `Delete files permanently rather than putting them into the trash. Normally the mega backend will put all deletions into the trash rather than permanently deleting them. If you specify this then rclone will permanently delete objects instead.`, Default: false, Advanced: true, }, { Name: "use_https", Help: `Use HTTPS for transfers. MEGA uses plain text HTTP connections by default. Some ISPs throttle HTTP connections, this causes transfers to become very slow. Enabling this will force MEGA to use HTTPS for all transfers. HTTPS is normally not necessary since all data is already encrypted anyway. Enabling it will increase CPU usage and add network overhead.`, Default: false, Advanced: true, }, { Name: config.ConfigEncoding, Help: config.ConfigEncodingHelp, Advanced: true, // Encode invalid UTF-8 bytes as json doesn't handle them properly. Default: (encoder.Base | encoder.EncodeInvalidUtf8), }}, }) } // Options defines the configuration for this backend type Options struct { User string `config:"user"` Pass string `config:"pass"` Debug bool `config:"debug"` HardDelete bool `config:"hard_delete"` UseHTTPS bool `config:"use_https"` Enc encoder.MultiEncoder `config:"encoding"` } // Fs represents a remote mega type Fs struct { name string // name of this remote root string // the path we are working on opt Options // parsed config options features *fs.Features // optional features srv *mega.Mega // the connection to the server pacer *fs.Pacer // pacer for API calls rootNodeMu sync.Mutex // mutex for _rootNode _rootNode *mega.Node // root node - call findRoot to use this mkdirMu sync.Mutex // used to serialize calls to mkdir / rmdir } // Object describes a mega object // // Will definitely have info but maybe not meta. // // Normally rclone would just store an ID here but go-mega and mega.nz // expect you to build an entire tree of all the objects in memory. // In this case we just store a pointer to the object. type Object struct { fs *Fs // what this object is part of remote string // The remote path info *mega.Node // pointer to the mega node } // ------------------------------------------------------------ // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("mega root '%s'", f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // parsePath parses a mega 'url' func parsePath(path string) (root string) { root = strings.Trim(path, "/") return } // shouldRetry returns a boolean as to whether this err deserves to be // retried. It returns the err as a convenience func shouldRetry(ctx context.Context, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } // Let the mega library handle the low level retries return false, err } // readMetaDataForPath reads the metadata from the path func (f *Fs) readMetaDataForPath(ctx context.Context, remote string) (info *mega.Node, err error) { rootNode, err := f.findRoot(ctx, false) if err != nil { return nil, err } return f.findObject(rootNode, remote) } // NewFs constructs an Fs from the path, container:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } if opt.Pass != "" { var err error opt.Pass, err = obscure.Reveal(opt.Pass) if err != nil { return nil, fmt.Errorf("couldn't decrypt password: %w", err) } } ci := fs.GetConfig(ctx) // cache *mega.Mega on username so we can reuse and share // them between remotes. They are expensive to make as they // contain all the objects and sharing the objects makes the // move code easier as we don't have to worry about mixing // them up between different remotes. megaCacheMu.Lock() defer megaCacheMu.Unlock() srv := megaCache[opt.User] if srv == nil { // srv = mega.New().SetClient(fshttp.NewClient(ctx)) // Workaround for Mega's use of insecure cipher suites which are no longer supported by default since Go 1.22. // Relevant issues: // https://github.com/rclone/rclone/issues/8565 // https://github.com/meganz/webclient/issues/103 clt := fshttp.NewClient(ctx) clt.Transport = fshttp.NewTransportCustom(ctx, func(t *http.Transport) { var ids []uint16 // Read default ciphers for _, cs := range tls.CipherSuites() { ids = append(ids, cs.ID) } // Insecure but Mega uses TLS_RSA_WITH_AES_128_GCM_SHA256 for storage endpoints // (e.g. https://gfs302n114.userstorage.mega.co.nz) as of June 18, 2025. t.TLSClientConfig.CipherSuites = append(ids, tls.TLS_RSA_WITH_AES_128_GCM_SHA256) }) srv = mega.New().SetClient(clt) srv.SetRetries(ci.LowLevelRetries) // let mega do the low level retries srv.SetHTTPS(opt.UseHTTPS) srv.SetLogger(func(format string, v ...any) { fs.Infof("*go-mega*", format, v...) }) if opt.Debug { srv.SetDebugger(func(format string, v ...any) { fs.Debugf("*go-mega*", format, v...) }) } err := srv.Login(opt.User, opt.Pass) if err != nil { return nil, fmt.Errorf("couldn't login: %w", err) } megaCache[opt.User] = srv } root = parsePath(root) f := &Fs{ name: name, root: root, opt: *opt, srv: srv, pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), } f.features = (&fs.Features{ DuplicateFiles: true, CanHaveEmptyDirectories: true, }).Fill(ctx, f) // Find the root node and check if it is a file or not _, err = f.findRoot(ctx, false) switch err { case nil: // root node found and is a directory case fs.ErrorDirNotFound: // root node not found, so can't be a file case fs.ErrorIsFile: // root node is a file so point to parent directory root = path.Dir(root) if root == "." { root = "" } f.root = root return f, err } return f, nil } // splitNodePath splits nodePath into / separated parts, returning nil if it // should refer to the root. // It also encodes the parts into backend-specific encoding func (f *Fs) splitNodePath(nodePath string) (parts []string) { nodePath = path.Clean(nodePath) if nodePath == "." || nodePath == "/" { return nil } nodePath = f.opt.Enc.FromStandardPath(nodePath) return strings.Split(nodePath, "/") } // findNode looks up the node for the path of the name given from the root given // // It returns mega.ENOENT if it wasn't found func (f *Fs) findNode(rootNode *mega.Node, nodePath string) (*mega.Node, error) { parts := f.splitNodePath(nodePath) if parts == nil { return rootNode, nil } nodes, err := f.srv.FS.PathLookup(rootNode, parts) if err != nil { return nil, err } return nodes[len(nodes)-1], nil } // findDir finds the directory rooted from the node passed in func (f *Fs) findDir(rootNode *mega.Node, dir string) (node *mega.Node, err error) { node, err = f.findNode(rootNode, dir) if err == mega.ENOENT { return nil, fs.ErrorDirNotFound } else if err == nil && node.GetType() == mega.FILE { return nil, fs.ErrorIsFile } return node, err } // findObject looks up the node for the object of the name given func (f *Fs) findObject(rootNode *mega.Node, file string) (node *mega.Node, err error) { node, err = f.findNode(rootNode, file) if err == mega.ENOENT { return nil, fs.ErrorObjectNotFound } else if err == nil && node.GetType() != mega.FILE { return nil, fs.ErrorIsDir // all other node types are directories } return node, err } // lookupDir looks up the node for the directory of the name given // // if create is true it tries to create the root directory if not found func (f *Fs) lookupDir(ctx context.Context, dir string) (*mega.Node, error) { rootNode, err := f.findRoot(ctx, false) if err != nil { return nil, err } return f.findDir(rootNode, dir) } // lookupParentDir finds the parent node for the remote passed in func (f *Fs) lookupParentDir(ctx context.Context, remote string) (dirNode *mega.Node, leaf string, err error) { parent, leaf := path.Split(remote) dirNode, err = f.lookupDir(ctx, parent) return dirNode, leaf, err } // mkdir makes the directory and any parent directories for the // directory of the name given func (f *Fs) mkdir(ctx context.Context, rootNode *mega.Node, dir string) (node *mega.Node, err error) { f.mkdirMu.Lock() defer f.mkdirMu.Unlock() parts := f.splitNodePath(dir) if parts == nil { return rootNode, nil } var i int // look up until we find a directory which exists for i = 0; i <= len(parts); i++ { var nodes []*mega.Node nodes, err = f.srv.FS.PathLookup(rootNode, parts[:len(parts)-i]) if err == nil { if len(nodes) == 0 { node = rootNode } else { node = nodes[len(nodes)-1] } break } if err != mega.ENOENT { return nil, fmt.Errorf("mkdir lookup failed: %w", err) } } if err != nil { return nil, fmt.Errorf("internal error: mkdir called with nonexistent root node: %w", err) } // i is number of directories to create (may be 0) // node is directory to create them from for _, name := range parts[len(parts)-i:] { // create directory called name in node err = f.pacer.Call(func() (bool, error) { node, err = f.srv.CreateDir(name, node) return shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("mkdir create node failed: %w", err) } } return node, nil } // mkdirParent creates the parent directory of remote func (f *Fs) mkdirParent(ctx context.Context, remote string) (dirNode *mega.Node, leaf string, err error) { rootNode, err := f.findRoot(ctx, true) if err != nil { return nil, "", err } parent, leaf := path.Split(remote) dirNode, err = f.mkdir(ctx, rootNode, parent) return dirNode, leaf, err } // findRoot looks up the root directory node and returns it. // // if create is true it tries to create the root directory if not found func (f *Fs) findRoot(ctx context.Context, create bool) (*mega.Node, error) { f.rootNodeMu.Lock() defer f.rootNodeMu.Unlock() // Check if we haven't found it already if f._rootNode != nil { return f._rootNode, nil } // Check for preexisting root absRoot := f.srv.FS.GetRoot() node, err := f.findDir(absRoot, f.root) //log.Printf("findRoot findDir %p %v", node, err) if err == nil { f._rootNode = node return node, nil } if !create || err != fs.ErrorDirNotFound { return nil, err } //..not found so create the root directory f._rootNode, err = f.mkdir(ctx, absRoot, f.root) return f._rootNode, err } // clearRoot unsets the root directory func (f *Fs) clearRoot() { f.rootNodeMu.Lock() f._rootNode = nil f.rootNodeMu.Unlock() //log.Printf("cleared root directory") } // CleanUp deletes all files currently in trash func (f *Fs) CleanUp(ctx context.Context) (err error) { trash := f.srv.FS.GetTrash() items := []*mega.Node{} _, err = f.list(ctx, trash, func(item *mega.Node) bool { items = append(items, item) return false }) if err != nil { return fmt.Errorf("CleanUp failed to list items in trash: %w", err) } fs.Infof(f, "Deleting %d items from the trash", len(items)) errors := 0 // similar to f.deleteNode(trash) but with HardDelete as true for _, item := range items { fs.Debugf(f, "Deleting trash %q", f.opt.Enc.ToStandardName(item.GetName())) deleteErr := f.pacer.Call(func() (bool, error) { err := f.srv.Delete(item, true) return shouldRetry(ctx, err) }) if deleteErr != nil { err = deleteErr errors++ } } fs.Infof(f, "Deleted %d items from the trash with %d errors", len(items), errors) return err } // Return an Object from a path // // If it can't be found it returns the error fs.ErrorObjectNotFound. func (f *Fs) newObjectWithInfo(ctx context.Context, remote string, info *mega.Node) (fs.Object, error) { o := &Object{ fs: f, remote: remote, } var err error if info != nil { // Set info err = o.setMetaData(info) } else { err = o.readMetaData(ctx) // reads info and meta, returning an error } if err != nil { return nil, err } return o, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return f.newObjectWithInfo(ctx, remote, nil) } // list the objects into the function supplied // // If directories is set it only sends directories // User function to process a File item from listAll // // Should return true to finish processing type listFn func(*mega.Node) bool // Lists the directory required calling the user function on each item found // // If the user fn ever returns true then it early exits with found = true func (f *Fs) list(ctx context.Context, dir *mega.Node, fn listFn) (found bool, err error) { nodes, err := f.srv.FS.GetChildren(dir) if err != nil { return false, fmt.Errorf("list failed: %w", err) } if slices.ContainsFunc(nodes, fn) { found = true } return } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { dirNode, err := f.lookupDir(ctx, dir) if err != nil { return nil, err } var iErr error _, err = f.list(ctx, dirNode, func(info *mega.Node) bool { remote := path.Join(dir, f.opt.Enc.ToStandardName(info.GetName())) switch info.GetType() { case mega.FOLDER, mega.ROOT, mega.INBOX, mega.TRASH: d := fs.NewDir(remote, info.GetTimeStamp()).SetID(info.GetHash()) entries = append(entries, d) case mega.FILE: o, err := f.newObjectWithInfo(ctx, remote, info) if err != nil { iErr = err return true } entries = append(entries, o) } return false }) if err != nil { return nil, err } if iErr != nil { return nil, iErr } return entries, nil } // Creates from the parameters passed in a half finished Object which // must have setMetaData called on it // // Returns the dirNode, object, leaf and error. // // Used to create new objects func (f *Fs) createObject(ctx context.Context, remote string, modTime time.Time, size int64) (o *Object, dirNode *mega.Node, leaf string, err error) { dirNode, leaf, err = f.mkdirParent(ctx, remote) if err != nil { return nil, nil, leaf, err } // Temporary Object under construction o = &Object{ fs: f, remote: remote, } return o, dirNode, leaf, nil } // Put the object // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned // PutUnchecked uploads the object // // This will create a duplicate if we upload a new file without // checking to see if there is one already - use Put() for that. func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { existingObj, err := f.newObjectWithInfo(ctx, src.Remote(), nil) switch err { case nil: return existingObj, existingObj.Update(ctx, in, src, options...) case fs.ErrorObjectNotFound: // Not found so create it return f.PutUnchecked(ctx, in, src) default: return nil, err } } // PutUnchecked the object // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned // PutUnchecked uploads the object // // This will create a duplicate if we upload a new file without // checking to see if there is one already - use Put() for that. func (f *Fs) PutUnchecked(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { remote := src.Remote() size := src.Size() modTime := src.ModTime(ctx) o, _, _, err := f.createObject(ctx, remote, modTime, size) if err != nil { return nil, err } return o, o.Update(ctx, in, src, options...) } // Mkdir creates the directory if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) error { rootNode, err := f.findRoot(ctx, true) if err != nil { return err } _, err = f.mkdir(ctx, rootNode, dir) if err != nil { return fmt.Errorf("Mkdir failed: %w", err) } return nil } // deleteNode removes a file or directory, observing useTrash func (f *Fs) deleteNode(ctx context.Context, node *mega.Node) (err error) { err = f.pacer.Call(func() (bool, error) { err = f.srv.Delete(node, f.opt.HardDelete) return shouldRetry(ctx, err) }) return err } // purgeCheck removes the directory dir, 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 { f.mkdirMu.Lock() defer f.mkdirMu.Unlock() rootNode, err := f.findRoot(ctx, false) if err != nil { return err } dirNode, err := f.findDir(rootNode, dir) if err != nil { return err } if check { children, err := f.srv.FS.GetChildren(dirNode) if err != nil { return fmt.Errorf("purgeCheck GetChildren failed: %w", err) } if len(children) > 0 { return fs.ErrorDirectoryNotEmpty } } waitEvent := f.srv.WaitEventsStart() err = f.deleteNode(ctx, dirNode) if err != nil { return fmt.Errorf("delete directory node failed: %w", err) } // Remove the root node if we just deleted it if dirNode == rootNode { f.clearRoot() } f.srv.WaitEvents(waitEvent, eventWaitTime) return nil } // Rmdir deletes the root folder // // Returns an error if it isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, true) } // Precision return the precision of this Fs func (f *Fs) Precision() time.Duration { return fs.ModTimeNotSupported } // Purge deletes all the files in the directory // // Optional interface: Only implement this if you have a way of // deleting all the files quicker than just running Remove() on the // result of List() func (f *Fs) Purge(ctx context.Context, dir string) error { return f.purgeCheck(ctx, dir, false) } // move a file or folder (srcFs, srcRemote, info) to (f, dstRemote) // // info will be updates func (f *Fs) move(ctx context.Context, dstRemote string, srcFs *Fs, srcRemote string, info *mega.Node) (err error) { var ( dstFs = f srcDirNode, dstDirNode *mega.Node srcParent, dstParent string srcLeaf, dstLeaf string ) if dstRemote != "" { // lookup or create the destination parent directory dstDirNode, dstLeaf, err = dstFs.mkdirParent(ctx, dstRemote) } else { // find or create the parent of the root directory absRoot := dstFs.srv.FS.GetRoot() dstParent, dstLeaf = path.Split(dstFs.root) dstDirNode, err = dstFs.mkdir(ctx, absRoot, dstParent) } if err != nil { return fmt.Errorf("server-side move failed to make dst parent dir: %w", err) } if srcRemote != "" { // lookup the existing parent directory srcDirNode, srcLeaf, err = srcFs.lookupParentDir(ctx, srcRemote) } else { // lookup the existing root parent absRoot := srcFs.srv.FS.GetRoot() srcParent, srcLeaf = path.Split(srcFs.root) srcDirNode, err = f.findDir(absRoot, srcParent) } if err != nil { return fmt.Errorf("server-side move failed to lookup src parent dir: %w", err) } // move the object into its new directory if required if srcDirNode != dstDirNode && srcDirNode.GetHash() != dstDirNode.GetHash() { //log.Printf("move src %p %q dst %p %q", srcDirNode, srcDirNode.GetName(), dstDirNode, dstDirNode.GetName()) err = f.pacer.Call(func() (bool, error) { err = f.srv.Move(info, dstDirNode) return shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("server-side move failed: %w", err) } } waitEvent := f.srv.WaitEventsStart() // rename the object if required if srcLeaf != dstLeaf { //log.Printf("rename %q to %q", srcLeaf, dstLeaf) err = f.pacer.Call(func() (bool, error) { err = f.srv.Rename(info, f.opt.Enc.FromStandardName(dstLeaf)) return shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("server-side rename failed: %w", err) } } f.srv.WaitEvents(waitEvent, eventWaitTime) return nil } // Move src to this remote using server-side move operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { dstFs := f //log.Printf("Move %q -> %q", src.Remote(), remote) srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't move - not same remote type") return nil, fs.ErrorCantMove } // Do the move err := f.move(ctx, remote, srcObj.fs, srcObj.remote, srcObj.info) if err != nil { return nil, err } // Create a destination object dstObj := &Object{ fs: dstFs, remote: remote, info: srcObj.info, } return dstObj, nil } // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists func (f *Fs) DirMove(ctx context.Context, src fs.Fs, srcRemote, dstRemote string) error { dstFs := f srcFs, ok := src.(*Fs) if !ok { fs.Debugf(srcFs, "Can't move directory - not same remote type") return fs.ErrorCantDirMove } // find the source info, err := srcFs.lookupDir(ctx, srcRemote) if err != nil { return err } // check the destination doesn't exist _, err = dstFs.lookupDir(ctx, dstRemote) if err == nil { return fs.ErrorDirExists } else if err != fs.ErrorDirNotFound { return fmt.Errorf("DirMove error while checking dest directory: %w", err) } // Do the move err = f.move(ctx, dstRemote, srcFs, srcRemote, info) if err != nil { return err } // Clear src if it was the root if srcRemote == "" { srcFs.clearRoot() } return nil } // DirCacheFlush an optional interface to flush internal directory cache func (f *Fs) DirCacheFlush() { // f.dirCache.ResetRoot() // FIXME Flush the mega somehow? } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hash.None) } // PublicLink generates a public link to the remote path (usually readable by anyone) func (f *Fs) PublicLink(ctx context.Context, remote string, expire fs.Duration, unlink bool) (link string, err error) { root, err := f.findRoot(ctx, false) if err != nil { return "", fmt.Errorf("PublicLink failed to find root node: %w", err) } node, err := f.findNode(root, remote) if err != nil { return "", fmt.Errorf("PublicLink failed to find path: %w", err) } link, err = f.srv.Link(node, true) if err != nil { return "", fmt.Errorf("PublicLink failed to create link: %w", err) } return link, nil } // MergeDirs merges the contents of all the directories passed // in into the first one and rmdirs the other directories. func (f *Fs) MergeDirs(ctx context.Context, dirs []fs.Directory) error { if len(dirs) < 2 { return nil } // find dst directory dstDir := dirs[0] dstDirNode := f.srv.FS.HashLookup(dstDir.ID()) if dstDirNode == nil { return fmt.Errorf("MergeDirs failed to find node for: %v", dstDir) } for _, srcDir := range dirs[1:] { // find src directory srcDirNode := f.srv.FS.HashLookup(srcDir.ID()) if srcDirNode == nil { return fmt.Errorf("MergeDirs failed to find node for: %v", srcDir) } // list the objects infos := []*mega.Node{} _, err := f.list(ctx, srcDirNode, func(info *mega.Node) bool { infos = append(infos, info) return false }) if err != nil { return fmt.Errorf("MergeDirs list failed on %v: %w", srcDir, err) } // move them into place for _, info := range infos { fs.Infof(srcDir, "merging %q", f.opt.Enc.ToStandardName(info.GetName())) err = f.pacer.Call(func() (bool, error) { err = f.srv.Move(info, dstDirNode) return shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("MergeDirs move failed on %q in %v: %w", f.opt.Enc.ToStandardName(info.GetName()), srcDir, err) } } // rmdir (into trash) the now empty source directory fs.Infof(srcDir, "removing empty directory") err = f.deleteNode(ctx, srcDirNode) if err != nil { return fmt.Errorf("MergeDirs move failed to rmdir %q: %w", srcDir, err) } } return nil } // About gets quota information func (f *Fs) About(ctx context.Context) (*fs.Usage, error) { var q mega.QuotaResp var err error err = f.pacer.Call(func() (bool, error) { q, err = f.srv.GetQuota() return shouldRetry(ctx, err) }) if err != nil { 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 } return usage, nil } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Hash returns the hashes of an object func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { return "", hash.ErrUnsupported } // Size returns the size of an object in bytes func (o *Object) Size() int64 { return o.info.GetSize() } // setMetaData sets the metadata from info func (o *Object) setMetaData(info *mega.Node) (err error) { if info.GetType() != mega.FILE { return fs.ErrorIsDir // all other node types are directories } o.info = info return nil } // readMetaData gets the metadata if it hasn't already been fetched // // it also sets the info func (o *Object) readMetaData(ctx context.Context) (err error) { if o.info != nil { return nil } info, err := o.fs.readMetaDataForPath(ctx, o.remote) if err != nil { if err == fs.ErrorDirNotFound { err = fs.ErrorObjectNotFound } return err } return o.setMetaData(info) } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers func (o *Object) ModTime(ctx context.Context) time.Time { return o.info.GetTimeStamp() } // SetModTime sets the modification time of the local fs object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { return fs.ErrorCantSetModTime } // Storable returns a boolean showing whether this object storable func (o *Object) Storable() bool { return true } // openObject represents a download in progress type openObject struct { ctx context.Context mu sync.Mutex o *Object d *mega.Download id int skip int64 chunk []byte closed bool } // get the next chunk func (oo *openObject) getChunk(ctx context.Context) (err error) { if oo.id >= oo.d.Chunks() { return io.EOF } var chunk []byte err = oo.o.fs.pacer.Call(func() (bool, error) { chunk, err = oo.d.DownloadChunk(oo.id) return shouldRetry(ctx, err) }) if err != nil { return err } oo.id++ oo.chunk = chunk return nil } // Read reads up to len(p) bytes into p. func (oo *openObject) Read(p []byte) (n int, err error) { oo.mu.Lock() defer oo.mu.Unlock() if oo.closed { return 0, errors.New("read on closed file") } // Skip data at the start if requested for oo.skip > 0 { _, size, err := oo.d.ChunkLocation(oo.id) if err != nil { return 0, err } if oo.skip < int64(size) { break } oo.id++ oo.skip -= int64(size) } if len(oo.chunk) == 0 { err = oo.getChunk(oo.ctx) if err != nil { return 0, err } if oo.skip > 0 { oo.chunk = oo.chunk[oo.skip:] oo.skip = 0 } } n = copy(p, oo.chunk) oo.chunk = oo.chunk[n:] return n, nil } // Close closed the file - MAC errors are reported here func (oo *openObject) Close() (err error) { oo.mu.Lock() defer oo.mu.Unlock() if oo.closed { return nil } err = oo.o.fs.pacer.Call(func() (bool, error) { err = oo.d.Finish() return shouldRetry(oo.ctx, err) }) if err != nil { return fmt.Errorf("failed to finish download: %w", err) } oo.closed = true return nil } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { var offset, limit int64 = 0, -1 for _, option := range options { switch x := option.(type) { case *fs.SeekOption: offset = x.Offset case *fs.RangeOption: offset, limit = x.Decode(o.Size()) default: if option.Mandatory() { fs.Logf(o, "Unsupported mandatory option: %v", option) } } } var d *mega.Download err = o.fs.pacer.Call(func() (bool, error) { d, err = o.fs.srv.NewDownload(o.info) return shouldRetry(ctx, err) }) if err != nil { return nil, fmt.Errorf("open download file failed: %w", err) } oo := &openObject{ ctx: ctx, o: o, d: d, skip: offset, } return readers.NewLimitedReadCloser(oo, limit), nil } // Update the object with the contents of the io.Reader, modTime and size // // If existing is set then it updates the object rather than creating a new one. // // The new object may have been created if an error is returned func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { size := src.Size() if size < 0 { return errors.New("mega backend can't upload a file of unknown length") } //modTime := src.ModTime(ctx) remote := o.Remote() // Create the parent directory dirNode, leaf, err := o.fs.mkdirParent(ctx, remote) if err != nil { return fmt.Errorf("update make parent dir failed: %w", err) } var u *mega.Upload err = o.fs.pacer.Call(func() (bool, error) { u, err = o.fs.srv.NewUpload(dirNode, o.fs.opt.Enc.FromStandardName(leaf), size) return shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("upload file failed to create session: %w", err) } // Upload the chunks // FIXME do this in parallel for id := range u.Chunks() { _, chunkSize, err := u.ChunkLocation(id) if err != nil { return fmt.Errorf("upload failed to read chunk location: %w", err) } chunk := make([]byte, chunkSize) _, err = io.ReadFull(in, chunk) if err != nil { return fmt.Errorf("upload failed to read data: %w", err) } err = o.fs.pacer.Call(func() (bool, error) { err = u.UploadChunk(id, chunk) return shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("upload file failed to upload chunk: %w", err) } } // Finish the upload var info *mega.Node err = o.fs.pacer.Call(func() (bool, error) { info, err = u.Finish() return shouldRetry(ctx, err) }) if err != nil { return fmt.Errorf("failed to finish upload: %w", err) } // If the upload succeeded and the original object existed, then delete it if o.info != nil { err = o.fs.deleteNode(ctx, o.info) if err != nil { return fmt.Errorf("upload failed to remove old version: %w", err) } o.info = nil } return o.setMetaData(info) } // Remove an object func (o *Object) Remove(ctx context.Context) error { err := o.fs.deleteNode(ctx, o.info) if err != nil { return fmt.Errorf("Remove object failed: %w", err) } return nil } // ID returns the ID of the Object if known, or "" if not func (o *Object) ID() string { return o.info.GetHash() } // Check the interfaces are satisfied var ( _ fs.Fs = (*Fs)(nil) _ fs.Purger = (*Fs)(nil) _ fs.Mover = (*Fs)(nil) _ fs.PutUncheckeder = (*Fs)(nil) _ fs.DirMover = (*Fs)(nil) _ fs.DirCacheFlusher = (*Fs)(nil) _ fs.PublicLinker = (*Fs)(nil) _ fs.MergeDirser = (*Fs)(nil) _ fs.Abouter = (*Fs)(nil) _ fs.Object = (*Object)(nil) _ fs.IDer = (*Object)(nil) ) rclone-v1.71.0/backend/mega/mega_test.go000066400000000000000000000005451505210326400200510ustar00rootroot00000000000000// Test Mega filesystem interface package mega_test import ( "testing" "github.com/rclone/rclone/backend/mega" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestMega:", NilObject: (*mega.Object)(nil), }) } rclone-v1.71.0/backend/memory/000077500000000000000000000000001505210326400161455ustar00rootroot00000000000000rclone-v1.71.0/backend/memory/memory.go000066400000000000000000000401361505210326400200100ustar00rootroot00000000000000// Package memory provides an interface to an in memory object storage system package memory import ( "bytes" "context" "crypto/md5" "encoding/hex" "fmt" "io" "path" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/lib/bucket" ) var ( hashType = hash.MD5 // the object storage is persistent buckets = newBucketsInfo() ) // Register with Fs func init() { fs.Register(&fs.RegInfo{ Name: "memory", Description: "In memory object storage system.", NewFs: NewFs, Options: []fs.Option{}, }) } // Options defines the configuration for this backend type Options struct{} // Fs represents a remote memory server type Fs struct { name string // name of this remote root string // the path we are working on if any opt Options // parsed config options rootBucket string // bucket part of root (if any) rootDirectory string // directory part of root (if any) features *fs.Features // optional features } // bucketsInfo holds info about all the buckets type bucketsInfo struct { mu sync.RWMutex buckets map[string]*bucketInfo } func newBucketsInfo() *bucketsInfo { return &bucketsInfo{ buckets: make(map[string]*bucketInfo, 16), } } // getBucket gets a names bucket or nil func (bi *bucketsInfo) getBucket(name string) (b *bucketInfo) { bi.mu.RLock() b = bi.buckets[name] bi.mu.RUnlock() return b } // makeBucket returns the bucket or makes it func (bi *bucketsInfo) makeBucket(name string) (b *bucketInfo) { bi.mu.Lock() defer bi.mu.Unlock() b = bi.buckets[name] if b != nil { return b } b = newBucketInfo() bi.buckets[name] = b return b } // deleteBucket deleted the bucket or returns an error func (bi *bucketsInfo) deleteBucket(name string) error { bi.mu.Lock() defer bi.mu.Unlock() b := bi.buckets[name] if b == nil { return fs.ErrorDirNotFound } if !b.isEmpty() { return fs.ErrorDirectoryNotEmpty } delete(bi.buckets, name) return nil } // getObjectData gets an object from (bucketName, bucketPath) or nil func (bi *bucketsInfo) getObjectData(bucketName, bucketPath string) (od *objectData) { b := bi.getBucket(bucketName) if b == nil { return nil } return b.getObjectData(bucketPath) } // updateObjectData updates an object from (bucketName, bucketPath) func (bi *bucketsInfo) updateObjectData(bucketName, bucketPath string, od *objectData) { b := bi.makeBucket(bucketName) b.mu.Lock() b.objects[bucketPath] = od b.mu.Unlock() } // removeObjectData removes an object from (bucketName, bucketPath) returning true if removed func (bi *bucketsInfo) removeObjectData(bucketName, bucketPath string) (removed bool) { b := bi.getBucket(bucketName) if b != nil { b.mu.Lock() od := b.objects[bucketPath] if od != nil { delete(b.objects, bucketPath) removed = true } b.mu.Unlock() } return removed } // bucketInfo holds info about a single bucket type bucketInfo struct { mu sync.RWMutex objects map[string]*objectData } func newBucketInfo() *bucketInfo { return &bucketInfo{ objects: make(map[string]*objectData, 16), } } // getBucket gets a names bucket or nil func (bi *bucketInfo) getObjectData(name string) (od *objectData) { bi.mu.RLock() od = bi.objects[name] bi.mu.RUnlock() return od } // getBucket gets a names bucket or nil func (bi *bucketInfo) isEmpty() (empty bool) { bi.mu.RLock() empty = len(bi.objects) == 0 bi.mu.RUnlock() return empty } // the object data and metadata type objectData struct { modTime time.Time hash string mimeType string data []byte } // Object describes a memory object type Object struct { fs *Fs // what this object is part of remote string // The remote path od *objectData // the object data } // ------------------------------------------------------------ // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String converts this Fs to a string func (f *Fs) String() string { return fmt.Sprintf("Memory root '%s'", f.root) } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // parsePath parses a remote 'url' func parsePath(path string) (root string) { root = strings.Trim(path, "/") return } // split returns bucket and bucketPath from the rootRelativePath // relative to f.root func (f *Fs) split(rootRelativePath string) (bucketName, bucketPath string) { return bucket.Split(path.Join(f.root, rootRelativePath)) } // split returns bucket and bucketPath from the object func (o *Object) split() (bucket, bucketPath string) { return o.fs.split(o.remote) } // setRoot changes the root of the Fs func (f *Fs) setRoot(root string) { f.root = parsePath(root) f.rootBucket, f.rootDirectory = bucket.Split(f.root) } // NewFs constructs an Fs from the path, bucket:path func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } root = strings.Trim(root, "/") f := &Fs{ name: name, root: root, opt: *opt, } f.setRoot(root) f.features = (&fs.Features{ ReadMimeType: true, WriteMimeType: true, BucketBased: true, BucketBasedRootOK: true, }).Fill(ctx, f) if f.rootBucket != "" && f.rootDirectory != "" { od := buckets.getObjectData(f.rootBucket, f.rootDirectory) if od != nil { newRoot := path.Dir(f.root) if newRoot == "." { newRoot = "" } f.setRoot(newRoot) // return an error with an fs which points to the parent err = fs.ErrorIsFile } } return f, err } // newObject makes an object from a remote and an objectData func (f *Fs) newObject(remote string, od *objectData) *Object { return &Object{fs: f, remote: remote, od: od} } // NewObject finds the Object at remote. If it can't be found // it returns the error fs.ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { bucket, bucketPath := f.split(remote) od := buckets.getObjectData(bucket, bucketPath) if od == nil { return nil, fs.ErrorObjectNotFound } return f.newObject(remote, od), nil } // listFn is called from list to handle an object. type listFn func(remote string, entry fs.DirEntry, isDirectory bool) error // list the buckets to fn func (f *Fs) list(ctx context.Context, bucket, directory, prefix string, addBucket bool, recurse bool, fn listFn) (err error) { if prefix != "" { prefix += "/" } if directory != "" { directory += "/" } b := buckets.getBucket(bucket) if b == nil { return fs.ErrorDirNotFound } b.mu.RLock() defer b.mu.RUnlock() dirs := make(map[string]struct{}) for absPath, od := range b.objects { if strings.HasPrefix(absPath, directory) { remote := absPath[len(prefix):] if !recurse { localPath := absPath[len(directory):] slash := strings.IndexRune(localPath, '/') if slash >= 0 { // send a directory if have a slash dir := strings.TrimPrefix(directory, f.rootDirectory+"/") + localPath[:slash] if addBucket { dir = path.Join(bucket, dir) } _, found := dirs[dir] if !found { err = fn(dir, fs.NewDir(dir, time.Time{}), true) if err != nil { return err } dirs[dir] = struct{}{} } continue // don't send this file if not recursing } } // send an object if addBucket { remote = path.Join(bucket, remote) } err = fn(remote, f.newObject(remote, od), false) if err != nil { return err } } } return nil } // listDir lists the bucket to the entries func (f *Fs) listDir(ctx context.Context, bucket, directory, prefix string, addBucket bool) (entries fs.DirEntries, err error) { // List the objects and directories err = f.list(ctx, bucket, directory, prefix, addBucket, false, func(remote string, entry fs.DirEntry, isDirectory bool) error { entries = append(entries, entry) return nil }) return entries, err } // listBuckets lists the buckets to entries func (f *Fs) listBuckets(ctx context.Context) (entries fs.DirEntries, err error) { buckets.mu.RLock() defer buckets.mu.RUnlock() for name := range buckets.buckets { entries = append(entries, fs.NewDir(name, time.Time{})) } return entries, nil } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { // defer fslog.Trace(dir, "")("entries = %q, err = %v", &entries, &err) bucket, directory := f.split(dir) if bucket == "" { if directory != "" { return nil, fs.ErrorListBucketRequired } return f.listBuckets(ctx) } return f.listDir(ctx, bucket, directory, f.rootDirectory, f.rootBucket == "") } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively that doing a directory traversal. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { bucket, directory := f.split(dir) list := list.NewHelper(callback) entries := fs.DirEntries{} listR := func(bucket, directory, prefix string, addBucket bool) error { err = f.list(ctx, bucket, directory, prefix, addBucket, true, func(remote string, entry fs.DirEntry, isDirectory bool) error { entries = append(entries, entry) // can't list.Add here -- could deadlock return nil }) if err != nil { return err } for _, entry := range entries { err = list.Add(entry) if err != nil { return err } } return nil } if bucket == "" { entries, err := f.listBuckets(ctx) if err != nil { return err } for _, entry := range entries { err = list.Add(entry) if err != nil { return err } bucket := entry.Remote() err = listR(bucket, "", f.rootDirectory, true) if err != nil { return err } } } else { err = listR(bucket, directory, f.rootDirectory, f.rootBucket == "") if err != nil { return err } } return list.Flush() } // Put the object into the bucket // // Copy the reader in to the new object which is returned. // // The new object may have been created if an error is returned func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { // Temporary Object under construction fs := &Object{ fs: f, remote: src.Remote(), od: &objectData{ modTime: src.ModTime(ctx), }, } return fs, fs.Update(ctx, in, src, options...) } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return f.Put(ctx, in, src, options...) } // Mkdir creates the bucket if it doesn't exist func (f *Fs) Mkdir(ctx context.Context, dir string) error { bucket, _ := f.split(dir) buckets.makeBucket(bucket) return nil } // Rmdir deletes the bucket if the fs is at the root // // Returns an error if it isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { bucket, directory := f.split(dir) if bucket == "" || directory != "" { return nil } return buckets.deleteBucket(bucket) } // Precision of the remote func (f *Fs) Precision() time.Duration { return time.Nanosecond } // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given. // // It returns the destination Object and a possible error. // // 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) (fs.Object, error) { dstBucket, dstPath := f.split(remote) _ = buckets.makeBucket(dstBucket) srcObj, ok := src.(*Object) if !ok { fs.Debugf(src, "Can't copy - not same remote type") return nil, fs.ErrorCantCopy } srcBucket, srcPath := srcObj.split() od := buckets.getObjectData(srcBucket, srcPath) if od == nil { return nil, fs.ErrorObjectNotFound } odCopy := *od buckets.updateObjectData(dstBucket, dstPath, &odCopy) return f.NewObject(ctx, remote) } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hashType) } // ------------------------------------------------------------ // Fs returns the parent Fs func (o *Object) Fs() fs.Info { return o.fs } // Return a string version func (o *Object) String() string { if o == nil { return "" } return o.Remote() } // Remote returns the remote path func (o *Object) Remote() string { return o.remote } // Hash returns the hash of an object returning a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if t != hashType { return "", hash.ErrUnsupported } if o.od.hash == "" { sum := md5.Sum(o.od.data) o.od.hash = hex.EncodeToString(sum[:]) } return o.od.hash, nil } // Size returns the size of an object in bytes func (o *Object) Size() int64 { return int64(len(o.od.data)) } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers // // SHA-1 will also be updated once the request has completed. func (o *Object) ModTime(ctx context.Context) (result time.Time) { return o.od.modTime } // SetModTime sets the modification time of the local fs object func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { o.od.modTime = modTime return nil } // Storable returns if this object is storable func (o *Object) Storable() bool { return true } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { var offset, limit int64 = 0, -1 for _, option := range options { switch x := option.(type) { case *fs.RangeOption: offset, limit = x.Decode(int64(len(o.od.data))) case *fs.SeekOption: offset = x.Offset default: if option.Mandatory() { fs.Logf(o, "Unsupported mandatory option: %v", option) } } } if offset > int64(len(o.od.data)) { offset = int64(len(o.od.data)) } data := o.od.data[offset:] if limit >= 0 { if limit > int64(len(data)) { limit = int64(len(data)) } data = data[:limit] } return io.NopCloser(bytes.NewBuffer(data)), nil } // Update the object with the contents of the io.Reader, modTime and size // // The new object may have been created if an error is returned func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { bucket, bucketPath := o.split() data, err := io.ReadAll(in) if err != nil { return fmt.Errorf("failed to update memory object: %w", err) } o.od = &objectData{ data: data, hash: "", modTime: src.ModTime(ctx), mimeType: fs.MimeType(ctx, src), } buckets.updateObjectData(bucket, bucketPath, o.od) return nil } // Remove an object func (o *Object) Remove(ctx context.Context) error { bucket, bucketPath := o.split() removed := buckets.removeObjectData(bucket, bucketPath) if !removed { return fs.ErrorObjectNotFound } return nil } // MimeType of an Object if known, "" otherwise func (o *Object) MimeType(ctx context.Context) string { return o.od.mimeType } // Check the interfaces are satisfied var ( _ fs.Fs = &Fs{} _ fs.Copier = &Fs{} _ fs.PutStreamer = &Fs{} _ fs.ListRer = &Fs{} _ fs.Object = &Object{} _ fs.MimeTyper = &Object{} ) rclone-v1.71.0/backend/memory/memory_internal_test.go000066400000000000000000000020331505210326400227350ustar00rootroot00000000000000package memory import ( "context" "fmt" "testing" _ "github.com/rclone/rclone/backend/local" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" "github.com/stretchr/testify/require" ) var t1 = fstest.Time("2001-02-03T04:05:06.499999999Z") // InternalTest dispatches all internal tests func (f *Fs) InternalTest(t *testing.T) { t.Run("PurgeListDeadlock", func(t *testing.T) { testPurgeListDeadlock(t) }) } // test that Purge fallback does not result in deadlock from concurrently listing and removing func testPurgeListDeadlock(t *testing.T) { ctx := context.Background() r := fstest.NewRunIndividual(t) r.Mkdir(ctx, r.Fremote) r.Fremote.Features().Disable("Purge") // force fallback-purge // make a lot of files to prevent it from finishing too quickly for i := range 100 { dst := "file" + fmt.Sprint(i) + ".txt" r.WriteObject(ctx, dst, "hello", t1) } require.NoError(t, operations.Purge(ctx, r.Fremote, "")) } var _ fstests.InternalTester = (*Fs)(nil) rclone-v1.71.0/backend/memory/memory_test.go000066400000000000000000000005141505210326400210430ustar00rootroot00000000000000// Test memory filesystem interface package memory import ( "testing" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: ":memory:", NilObject: (*Object)(nil), QuickTestOK: true, }) } rclone-v1.71.0/backend/netstorage/000077500000000000000000000000001505210326400170105ustar00rootroot00000000000000rclone-v1.71.0/backend/netstorage/netstorage.go000077500000000000000000001172671505210326400215330ustar00rootroot00000000000000// Package netstorage provides an interface to Akamai NetStorage API package netstorage import ( "context" "crypto/hmac" "crypto/sha256" "encoding/base64" "encoding/hex" "encoding/xml" "errors" "fmt" gohash "hash" "io" "math/rand" "net/http" "net/url" "path" "strconv" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/rest" ) // Constants const ( minSleep = 10 * time.Millisecond maxSleep = 2 * time.Second decayConstant = 2 // bigger for slower decay, exponential ) func init() { fsi := &fs.RegInfo{ Name: "netstorage", Description: "Akamai NetStorage", NewFs: NewFs, CommandHelp: commandHelp, Options: []fs.Option{{ Name: "protocol", Help: `Select between HTTP or HTTPS protocol. Most users should choose HTTPS, which is the default. HTTP is provided primarily for debugging purposes.`, Examples: []fs.OptionExample{{ Value: "http", Help: "HTTP protocol", }, { Value: "https", Help: "HTTPS protocol", }}, Default: "https", Advanced: true, }, { Name: "host", Help: `Domain+path of NetStorage host to connect to. Format should be ` + "`/`", Required: true, Sensitive: true, }, { Name: "account", Help: "Set the NetStorage account name", Required: true, Sensitive: true, }, { Name: "secret", Help: `Set the NetStorage account secret/G2O key for authentication. Please choose the 'y' option to set your own password then enter your secret.`, IsPassword: true, Required: true, }}, } fs.Register(fsi) } var commandHelp = []fs.CommandHelp{{ Name: "du", Short: "Return disk usage information for a specified directory", Long: `The usage information returned, includes the targeted directory as well as all files stored in any sub-directories that may exist.`, }, { Name: "symlink", Short: "You can create a symbolic link in ObjectStore with the symlink action.", Long: `The desired path location (including applicable sub-directories) ending in the object that will be the target of the symlink (for example, /links/mylink). Include the file extension for the object, if applicable. ` + "`rclone backend symlink `", }, } // Options defines the configuration for this backend type Options struct { Endpoint string `config:"host"` Account string `config:"account"` Secret string `config:"secret"` Protocol string `config:"protocol"` } // Fs stores the interface to the remote HTTP files type Fs struct { name string root string features *fs.Features // optional features opt Options // options for this backend endpointURL string // endpoint as a string srv *rest.Client // the connection to the Netstorage server pacer *fs.Pacer // to pace the API calls filetype string // dir, file or symlink dirscreated map[string]bool // if implicit dir has been created already dirscreatedMutex sync.Mutex // mutex to protect dirscreated statcache map[string][]File // cache successful stat requests statcacheMutex sync.RWMutex // RWMutex to protect statcache } // Object is a remote object that has been stat'd (so it exists, but is not necessarily open for reading) type Object struct { fs *Fs filetype string // dir, file or symlink remote string // remote path size int64 // size of the object in bytes modTime int64 // modification time of the object md5sum string // md5sum of the object fullURL string // full path URL target string // symlink target when filetype is symlink } //------------------------------------------------------------------------------ // Stat is an object which holds the information of the stat element of the response xml type Stat struct { XMLName xml.Name `xml:"stat"` Files []File `xml:"file"` Directory string `xml:"directory,attr"` } // File is an object which holds the information of the file element of the response xml type File struct { XMLName xml.Name `xml:"file"` Type string `xml:"type,attr"` Name string `xml:"name,attr"` NameBase64 string `xml:"name_base64,attr"` Size int64 `xml:"size,attr"` Md5 string `xml:"md5,attr"` Mtime int64 `xml:"mtime,attr"` Bytes int64 `xml:"bytes,attr"` Files int64 `xml:"files,attr"` Target string `xml:"target,attr"` } // List is an object which holds the information of the list element of the response xml type List struct { XMLName xml.Name `xml:"list"` Files []File `xml:"file"` Resume ListResume `xml:"resume"` } // ListResume represents the resume xml element of the list type ListResume struct { XMLName xml.Name `xml:"resume"` Start string `xml:"start,attr"` } // Du represents the du xml element of the response type Du struct { XMLName xml.Name `xml:"du"` Directory string `xml:"directory,attr"` Duinfo DuInfo `xml:"du-info"` } // DuInfo represents the du-info xml element of the response type DuInfo struct { XMLName xml.Name `xml:"du-info"` Files int64 `xml:"files,attr"` Bytes int64 `xml:"bytes,attr"` } // GetName returns a normalized name of the Stat item func (s Stat) GetName() xml.Name { return s.XMLName } // GetName returns a normalized name of the List item func (l List) GetName() xml.Name { return l.XMLName } // GetName returns a normalized name of the Du item func (d Du) GetName() xml.Name { return d.XMLName } //------------------------------------------------------------------------------ // NewFs creates a new Fs object from the name and root. It connects to // the host specified in the config file. // // If root refers to an existing object, then it should return an Fs which // points to the parent of that object and ErrorIsFile. func NewFs(ctx context.Context, name, root string, m configmap.Mapper) (fs.Fs, error) { // Parse config into Options struct opt := new(Options) err := configstruct.Set(m, opt) if err != nil { return nil, err } // The base URL (endPoint is protocol + :// + domain/internal folder opt.Endpoint = opt.Protocol + "://" + opt.Endpoint fs.Debugf(nil, "NetStorage NewFS endpoint %q", opt.Endpoint) if !strings.HasSuffix(opt.Endpoint, "/") { opt.Endpoint += "/" } // Decrypt credentials, even though it is hard to eyedrop the hex string, it adds an extra piece of mind opt.Secret = obscure.MustReveal(opt.Secret) // Parse the endpoint and stick the root onto it base, err := url.Parse(opt.Endpoint) if err != nil { return nil, fmt.Errorf("couldn't parse URL %q: %w", opt.Endpoint, err) } u, err := rest.URLJoin(base, rest.URLPathEscape(root)) if err != nil { return nil, fmt.Errorf("couldn't join URL %q and %q: %w", base.String(), root, err) } client := fshttp.NewClient(ctx) f := &Fs{ name: name, root: root, opt: *opt, endpointURL: u.String(), pacer: fs.NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(minSleep), pacer.MaxSleep(maxSleep), pacer.DecayConstant(decayConstant))), dirscreated: make(map[string]bool), statcache: make(map[string][]File), } f.srv = rest.NewClient(client) f.srv.SetSigner(f.getAuth) f.features = (&fs.Features{ CanHaveEmptyDirectories: true, }).Fill(ctx, f) err = f.initFs(ctx, "") switch err { case nil: // Object is the directory return f, nil case fs.ErrorObjectNotFound: return f, nil case fs.ErrorIsFile: // Correct root if definitely pointing to a file f.root = path.Dir(f.root) if f.root == "." || f.root == "/" { f.root = "" } // Fs points to the parent directory return f, err default: return nil, err } } // Command the backend to run a named commands: du and symlink func (f *Fs) Command(ctx context.Context, name string, arg []string, opt map[string]string) (out any, err error) { switch name { case "du": // No arg parsing needed, the path is passed in the fs return f.netStorageDuRequest(ctx) case "symlink": dst := "" if len(arg) > 0 { dst = arg[0] } else { return nil, errors.New("NetStorage symlink command: need argument for target") } // Strip off the leading slash added by NewFs on object not found URL := strings.TrimSuffix(f.url(""), "/") return f.netStorageSymlinkRequest(ctx, URL, dst, nil) default: return nil, fs.ErrorCommandNotFound } } // Name returns the configured name of the file system func (f *Fs) Name() string { return f.name } // Root returns the root for the filesystem func (f *Fs) Root() string { return f.root } // String returns the URL for the filesystem func (f *Fs) String() string { return f.endpointURL } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // Precision return the precision of this Fs func (f *Fs) Precision() time.Duration { return time.Second } // NewObject creates a new remote http file object // NewObject finds the Object at remote // If it can't be found returns fs.ErrorObjectNotFound // If it isn't a file, then it returns fs.ErrorIsDir func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { URL := f.url(remote) files, err := f.netStorageStatRequest(ctx, URL, false) if err != nil { return nil, err } if files == nil { fs.Errorf(nil, "Stat for %q has empty files", URL) return nil, fs.ErrorObjectNotFound } file := files[0] switch file.Type { case "file", "symlink": return f.newObjectWithInfo(remote, &file) case "dir": return nil, fs.ErrorIsDir default: return nil, fmt.Errorf("object of an unsupported type %s for %q: %w", file.Type, URL, err) } } // initFs initializes Fs based on the stat reply func (f *Fs) initFs(ctx context.Context, dir string) error { // Path must end with the slash, so the join later will work correctly defer func() { if !strings.HasSuffix(f.endpointURL, "/") { f.endpointURL += "/" } }() URL := f.url(dir) files, err := f.netStorageStatRequest(ctx, URL, true) if err == fs.ErrorObjectNotFound || files == nil { return fs.ErrorObjectNotFound } if err != nil { return err } f.filetype = files[0].Type switch f.filetype { case "dir": // This directory is known to exist, adding to explicit directories f.setDirscreated(URL) return nil case "file", "symlink": // Fs should point to the parent of that object and return ErrorIsFile lastindex := strings.LastIndex(f.endpointURL, "/") if lastindex != -1 { f.endpointURL = f.endpointURL[0 : lastindex+1] } else { fs.Errorf(nil, "Remote URL %q unexpectedly does not include the slash", f.endpointURL) } return fs.ErrorIsFile default: err = fmt.Errorf("unsupported object type %s for %q: %w", f.filetype, URL, err) f.filetype = "" return err } } // url joins the remote onto the endpoint URL func (f *Fs) url(remote string) string { if remote == "" { return f.endpointURL } pathescapeURL := rest.URLPathEscape(remote) // Strip off initial "./" from the path, which can be added by path escape function following the RFC 3986 4.2 // (a segment must be preceded by a dot-segment (e.g., "./this:that") to make a relative-path reference). pathescapeURL = strings.TrimPrefix(pathescapeURL, "./") // Cannot use rest.URLJoin() here because NetStorage is an object storage and allows to have a "." // directory name, which will be eliminated by the join function. return f.endpointURL + pathescapeURL } // getFileName returns the file name if present, otherwise decoded name_base64 // if present, otherwise an empty string func (f *Fs) getFileName(file *File) string { if file.Name != "" { return file.Name } if file.NameBase64 != "" { decoded, err := base64.StdEncoding.DecodeString(file.NameBase64) if err == nil { return string(decoded) } fs.Errorf(nil, "Failed to base64 decode object %s: %v", file.NameBase64, err) } return "" } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { if f.filetype == "" { // This happens in two scenarios. // 1. NewFs is done on a nonexistent object, then later rclone attempts to List/ListR this NewFs. // 2. List/ListR is called from the context of test_all and not the regular rclone binary. err := f.initFs(ctx, dir) if err != nil { if err == fs.ErrorObjectNotFound { return nil, fs.ErrorDirNotFound } return nil, err } } URL := f.url(dir) files, err := f.netStorageDirRequest(ctx, URL) if err != nil { return nil, err } if dir != "" && !strings.HasSuffix(dir, "/") { dir += "/" } for _, item := range files { name := dir + f.getFileName(&item) switch item.Type { case "dir": when := time.Unix(item.Mtime, 0) entry := fs.NewDir(name, when).SetSize(item.Bytes).SetItems(item.Files) entries = append(entries, entry) case "file": if entry, _ := f.newObjectWithInfo(name, &item); entry != nil { entries = append(entries, entry) } case "symlink": var entry fs.Object // Add .rclonelink suffix to allow local backend code to convert to a symlink. // In case both .rclonelink file AND symlink file exists, the first will be used. if entry, _ = f.newObjectWithInfo(name+".rclonelink", &item); entry != nil { fs.Infof(nil, "Converting a symlink to the rclonelink %s target %s", entry.Remote(), item.Target) entries = append(entries, entry) } default: fs.Logf(nil, "Ignoring unsupported object type %s for %q path", item.Type, name) } } return entries, nil } // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively that doing a directory traversal. func (f *Fs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { if f.filetype == "" { // This happens in two scenarios. // 1. NewFs is done on a nonexistent object, then later rclone attempts to List/ListR this NewFs. // 2. List/ListR is called from the context of test_all and not the regular rclone binary. err := f.initFs(ctx, dir) if err != nil { if err == fs.ErrorObjectNotFound { return fs.ErrorDirNotFound } return err } } if !strings.HasSuffix(dir, "/") && dir != "" { dir += "/" } URL := f.url(dir) u, err := url.Parse(URL) if err != nil { fs.Errorf(nil, "Unable to parse URL %q: %v", URL, err) return fs.ErrorDirNotFound } list := list.NewHelper(callback) for resumeStart := u.Path; resumeStart != ""; { var files []File files, resumeStart, err = f.netStorageListRequest(ctx, URL, u.Path) if err != nil { if err == fs.ErrorObjectNotFound { return fs.ErrorDirNotFound } return err } for _, item := range files { name := f.getFileName(&item) // List output includes full paths starting from [CP Code]/ path := strings.TrimPrefix("/"+name, u.Path) if path == "" { // Skip the starting directory itself continue } switch item.Type { case "dir": when := time.Unix(item.Mtime, 0) entry := fs.NewDir(dir+strings.TrimSuffix(path, "/"), when) if err := list.Add(entry); err != nil { return err } case "file": if entry, _ := f.newObjectWithInfo(dir+path, &item); entry != nil { if err := list.Add(entry); err != nil { return err } } case "symlink": // Add .rclonelink suffix to allow local backend code to convert to a symlink. // In case both .rclonelink file AND symlink file exists, the first will be used. if entry, _ := f.newObjectWithInfo(dir+path+".rclonelink", &item); entry != nil { fs.Infof(nil, "Converting a symlink to the rclonelink %s for target %s", entry.Remote(), item.Target) if err := list.Add(entry); err != nil { return err } } default: fs.Logf(nil, "Ignoring unsupported object type %s for %s path", item.Type, name) } } if resumeStart != "" { // Perform subsequent list action call, construct the // URL where the previous request finished u, err := url.Parse(f.endpointURL) if err != nil { fs.Errorf(nil, "Unable to parse URL %q: %v", f.endpointURL, err) return fs.ErrorDirNotFound } resumeURL, err := rest.URLJoin(u, rest.URLPathEscape(resumeStart)) if err != nil { fs.Errorf(nil, "Unable to join URL %q for resumeStart %s: %v", f.endpointURL, resumeStart, err) return fs.ErrorDirNotFound } URL = resumeURL.String() } } return list.Flush() } // Put in to the remote path with the modTime given of the given size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { err := f.implicitCheck(ctx, src.Remote(), true) if err != nil { return nil, err } // Barebones object will get filled in Update o := &Object{ fs: f, remote: src.Remote(), fullURL: f.url(src.Remote()), } // We pass through the Update's error err = o.Update(ctx, in, src, options...) if err != nil { return nil, err } return o, nil } // implicitCheck prevents implicit dir creation by doing mkdir from base up to current dir, // does NOT check if these dirs created conflict with existing dirs/files so can result in dupe func (f *Fs) implicitCheck(ctx context.Context, remote string, isfile bool) error { // Find base (URL including the CPCODE path) and root (what follows after that) URL := f.url(remote) u, err := url.Parse(URL) if err != nil { fs.Errorf(nil, "Unable to parse URL %q while implicit checking directory: %v", URL, err) return err } startPos := 0 if strings.HasPrefix(u.Path, "/") { startPos = 1 } pos := strings.Index(u.Path[startPos:], "/") if pos == -1 { fs.Errorf(nil, "URL %q unexpectedly does not include the slash in the CPCODE path", URL) return nil } root := rest.URLPathEscape(u.Path[startPos+pos+1:]) u.Path = u.Path[:startPos+pos] base := u.String() if !strings.HasSuffix(base, "/") { base += "/" } if isfile { // Get the base name of root lastindex := strings.LastIndex(root, "/") if lastindex == -1 { // We are at the level of CPCODE path return nil } root = root[0 : lastindex+1] } // We make sure root always has "/" at the end if !strings.HasSuffix(root, "/") { root += "/" } for root != "" { frontindex := strings.Index(root, "/") if frontindex == -1 { return nil } frontdir := root[0 : frontindex+1] root = root[frontindex+1:] base += frontdir if !f.testAndSetDirscreated(base) { fs.Infof(nil, "Implicitly create directory %s", base) err := f.netStorageMkdirRequest(ctx, base) if err != nil { fs.Errorf("Mkdir request in implicit check failed for base %s: %v", base, err) return err } } } return nil } // Purge all files in the directory specified. // NetStorage quick-delete is disabled by default AND not instantaneous. // Returns fs.ErrorCantPurge when quick-delete fails. func (f *Fs) Purge(ctx context.Context, dir string) error { URL := f.url(dir) const actionHeader = "version=1&action=quick-delete&quick-delete=imreallyreallysure" if _, err := f.callBackend(ctx, URL, "POST", actionHeader, true, nil, nil); err != nil { fs.Logf(nil, "Purge using quick-delete failed, fallback on recursive delete: %v", err) return fs.ErrorCantPurge } fs.Logf(nil, "Purge using quick-delete has been queued, you may not see immediate changes") return nil } // PutStream uploads to the remote path with the modTime given of indeterminate size func (f *Fs) PutStream(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { // Pass through error from Put return f.Put(ctx, in, src, options...) } // Fs is the filesystem this remote http file object is located within func (o *Object) Fs() fs.Info { return o.fs } // String returns the URL to the remote HTTP file func (o *Object) String() string { if o == nil { return "" } return o.remote } // Remote the name of the remote HTTP file, relative to the fs root func (o *Object) Remote() string { return o.remote } // Hash returns the Md5sum of an object returning a lowercase hex string func (o *Object) Hash(ctx context.Context, t hash.Type) (string, error) { if t != hash.MD5 { return "", hash.ErrUnsupported } return o.md5sum, nil } // Size returns the size in bytes of the remote http file func (o *Object) Size() int64 { return o.size } // Md5Sum returns the md5 of the object func (o *Object) Md5Sum() string { return o.md5sum } // ModTime returns the modification time of the object // // It attempts to read the objects mtime and if that isn't present the // LastModified returned in the http headers func (o *Object) ModTime(ctx context.Context) time.Time { return time.Unix(o.modTime, 0) } // SetModTime sets the modification and access time to the specified time func (o *Object) SetModTime(ctx context.Context, modTime time.Time) error { URL := o.fullURL when := strconv.FormatInt(modTime.Unix(), 10) actionHeader := "version=1&action=mtime&mtime=" + when if _, err := o.fs.callBackend(ctx, URL, "POST", actionHeader, true, nil, nil); err != nil { fs.Debugf(nil, "NetStorage action mtime failed for %q: %v", URL, err) return err } o.fs.deleteStatCache(URL) o.modTime = modTime.Unix() return nil } // Storable returns whether this object is storable func (o *Object) Storable() bool { return true } // Open an object for read func (o *Object) Open(ctx context.Context, options ...fs.OpenOption) (in io.ReadCloser, err error) { return o.netStorageDownloadRequest(ctx, options) } // Hashes returns the supported hash sets. func (f *Fs) Hashes() hash.Set { return hash.Set(hash.MD5) } // Mkdir makes the root directory of the Fs object // Shouldn't return an error if it already exists func (f *Fs) Mkdir(ctx context.Context, dir string) error { // ImplicitCheck will mkdir from base up to dir, if not already in dirscreated return f.implicitCheck(ctx, dir, false) } // Remove an object func (o *Object) Remove(ctx context.Context) error { return o.netStorageDeleteRequest(ctx) } // Rmdir removes the root directory of the Fs object // Return an error if it doesn't exist or isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { return f.netStorageRmdirRequest(ctx, dir) } // Update netstorage with the object func (o *Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { o.size = src.Size() o.modTime = src.ModTime(ctx).Unix() // Don't do md5 check because that's done by server o.md5sum = "" err := o.netStorageUploadRequest(ctx, in, src) // We return an object updated with source stats, // we don't refetch the obj after upload if err != nil { return err } return nil } // newObjectWithInfo creates an fs.Object for any netstorage.File or symlink. // If it can't be found it returns the error fs.ErrorObjectNotFound. // It returns fs.ErrorIsDir error for directory objects, but still fills the // fs.Object structure (for directory operations). func (f *Fs) newObjectWithInfo(remote string, info *File) (fs.Object, error) { if info == nil { return nil, fs.ErrorObjectNotFound } URL := f.url(remote) size := info.Size if info.Type == "symlink" { // File size for symlinks is absent but for .rclonelink to work // the size should be the length of the target name size = int64(len(info.Target)) } o := &Object{ fs: f, filetype: info.Type, remote: remote, size: size, modTime: info.Mtime, md5sum: info.Md5, fullURL: URL, target: info.Target, } if info.Type == "dir" { return o, fs.ErrorIsDir } return o, nil } // getAuth is the signing hook to get the NetStorage auth func (f *Fs) getAuth(req *http.Request) error { // Set Authorization header dataHeader := generateDataHeader(f) path := req.URL.RequestURI() //lint:ignore SA1008 false positive when running staticcheck, the header name is according to docs even if not canonical //nolint:staticcheck // Don't include staticcheck when running golangci-lint to avoid SA1008 actionHeader := req.Header["X-Akamai-ACS-Action"][0] fs.Debugf(nil, "NetStorage API %s call %s for path %q", req.Method, actionHeader, path) req.Header.Set("X-Akamai-ACS-Auth-Data", dataHeader) req.Header.Set("X-Akamai-ACS-Auth-Sign", generateSignHeader(f, dataHeader, path, actionHeader)) return nil } // retryErrorCodes is a slice of error codes that we will retry var retryErrorCodes = []int{ 423, // Locked 429, // Too Many Requests 500, // Internal Server Error 502, // Bad Gateway 503, // Service Unavailable 504, // Gateway Timeout 509, // Bandwidth Limit Exceeded } // shouldRetry returns a boolean as to whether this resp and err // deserve to be retried. It returns the err as a convenience func shouldRetry(ctx context.Context, resp *http.Response, err error) (bool, error) { if fserrors.ContextError(ctx, &err) { return false, err } return fserrors.ShouldRetry(err) || fserrors.ShouldRetryHTTP(resp, retryErrorCodes), err } // callBackend calls NetStorage API using either rest.Call or rest.CallXML function, // depending on whether the response is required func (f *Fs) callBackend(ctx context.Context, URL, method, actionHeader string, noResponse bool, response any, options []fs.OpenOption) (io.ReadCloser, error) { opts := rest.Opts{ Method: method, RootURL: URL, NoResponse: noResponse, ExtraHeaders: map[string]string{ "*X-Akamai-ACS-Action": actionHeader, }, } if options != nil { opts.Options = options } var resp *http.Response err := f.pacer.Call(func() (bool, error) { var err error if response != nil { resp, err = f.srv.CallXML(ctx, &opts, nil, response) } else { resp, err = f.srv.Call(ctx, &opts) } return shouldRetry(ctx, resp, err) }) if err != nil { if resp != nil && resp.StatusCode == http.StatusNotFound { // 404 HTTP code translates into Object not found return nil, fs.ErrorObjectNotFound } return nil, fmt.Errorf("failed to call NetStorage API: %w", err) } if noResponse { return nil, nil } return resp.Body, nil } // netStorageStatRequest performs a NetStorage stat request func (f *Fs) netStorageStatRequest(ctx context.Context, URL string, directory bool) ([]File, error) { if strings.HasSuffix(URL, ".rclonelink") { fs.Infof(nil, "Converting rclonelink to a symlink on the stat request %q", URL) URL = strings.TrimSuffix(URL, ".rclonelink") } URL = strings.TrimSuffix(URL, "/") files := f.getStatCache(URL) if files == nil { const actionHeader = "version=1&action=stat&implicit=yes&format=xml&encoding=utf-8&slash=both" statResp := &Stat{} if _, err := f.callBackend(ctx, URL, "GET", actionHeader, false, statResp, nil); err != nil { fs.Debugf(nil, "NetStorage action stat failed for %q: %v", URL, err) return nil, err } files = statResp.Files f.setStatCache(URL, files) } // Multiple objects can be returned with the "slash=both" option, // when file/symlink/directory has the same name for i := range files { if files[i].Type == "symlink" { // Add .rclonelink suffix to allow local backend code to convert to a symlink. files[i].Name += ".rclonelink" fs.Infof(nil, "Converting a symlink to the rclonelink on the stat request %s", files[i].Name) } entrywanted := (directory && files[i].Type == "dir") || (!directory && files[i].Type != "dir") if entrywanted { files[0], files[i] = files[i], files[0] } } return files, nil } // netStorageDirRequest performs a NetStorage dir request func (f *Fs) netStorageDirRequest(ctx context.Context, URL string) ([]File, error) { const actionHeader = "version=1&action=dir&format=xml&encoding=utf-8" statResp := &Stat{} if _, err := f.callBackend(ctx, URL, "GET", actionHeader, false, statResp, nil); err != nil { if err == fs.ErrorObjectNotFound { return nil, fs.ErrorDirNotFound } fs.Debugf(nil, "NetStorage action dir failed for %q: %v", URL, err) return nil, err } return statResp.Files, nil } // netStorageListRequest performs a NetStorage list request // Second returning parameter is resumeStart string, if not empty the function should be restarted with the adjusted URL to continue the listing. func (f *Fs) netStorageListRequest(ctx context.Context, URL, endPath string) ([]File, string, error) { actionHeader := "version=1&action=list&mtime_all=yes&format=xml&encoding=utf-8" if !pathIsOneLevelDeep(endPath) { // Add end= to limit the depth to endPath escapeEndPath := url.QueryEscape(strings.TrimSuffix(endPath, "/")) // The "0" character exists in place of the trailing slash to // accommodate ObjectStore directory logic end := "&end=" + strings.TrimSuffix(escapeEndPath, "/") + "0" actionHeader += end } listResp := &List{} if _, err := f.callBackend(ctx, URL, "GET", actionHeader, false, listResp, nil); err != nil { if err == fs.ErrorObjectNotFound { // List action is known to return 404 for a valid [CP Code] path with no objects inside. // Call stat to find out whether it is an empty directory or path does not exist. fs.Debugf(nil, "NetStorage action list returned 404, call stat for %q", URL) files, err := f.netStorageStatRequest(ctx, URL, true) if err == nil && len(files) > 0 && files[0].Type == "dir" { return []File{}, "", nil } } fs.Debugf(nil, "NetStorage action list failed for %q: %v", URL, err) return nil, "", err } return listResp.Files, listResp.Resume.Start, nil } // netStorageUploadRequest performs a NetStorage upload request func (o *Object) netStorageUploadRequest(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { URL := o.fullURL if URL == "" { URL = o.fs.url(src.Remote()) } if strings.HasSuffix(URL, ".rclonelink") { bits, err := io.ReadAll(in) if err != nil { return err } targ := string(bits) symlinkloc := strings.TrimSuffix(URL, ".rclonelink") fs.Infof(nil, "Converting rclonelink to a symlink on upload %s target %s", symlinkloc, targ) _, err = o.fs.netStorageSymlinkRequest(ctx, symlinkloc, targ, &o.modTime) return err } u, err := url.Parse(URL) if err != nil { return fmt.Errorf("unable to parse URL %q while uploading: %w", URL, err) } path := u.RequestURI() const actionHeader = "version=1&action=upload&sha256=atend&mtime=atend" trailers := &http.Header{} hr := newHashReader(in, sha256.New()) reader := customReader( func(p []byte) (n int, err error) { if n, err = hr.Read(p); err != nil && err == io.EOF { // Send the "chunked trailer" after upload of the object digest := hex.EncodeToString(hr.Sum(nil)) actionHeader := "version=1&action=upload&sha256=" + digest + "&mtime=" + strconv.FormatInt(src.ModTime(ctx).Unix(), 10) trailers.Add("X-Akamai-ACS-Action", actionHeader) dataHeader := generateDataHeader(o.fs) trailers.Add("X-Akamai-ACS-Auth-Data", dataHeader) signHeader := generateSignHeader(o.fs, dataHeader, path, actionHeader) trailers.Add("X-Akamai-ACS-Auth-Sign", signHeader) } return }, ) var resp *http.Response opts := rest.Opts{ Method: "PUT", RootURL: URL, NoResponse: true, Options: options, Body: reader, Trailer: trailers, ExtraHeaders: map[string]string{ "*X-Akamai-ACS-Action": actionHeader, }, } err = o.fs.pacer.CallNoRetry(func() (bool, error) { resp, err = o.fs.srv.Call(ctx, &opts) return shouldRetry(ctx, resp, err) }) if err != nil { if resp != nil && resp.StatusCode == http.StatusNotFound { // 404 HTTP code translates into Object not found return fs.ErrorObjectNotFound } fs.Debugf(nil, "NetStorage action upload failed for %q: %v", URL, err) // Remove failed upload _ = o.Remove(ctx) return fmt.Errorf("failed to call NetStorage API upload: %w", err) } // Invalidate stat cache o.fs.deleteStatCache(URL) if o.size == -1 { files, err := o.fs.netStorageStatRequest(ctx, URL, false) if err != nil { return nil } if files != nil { o.size = files[0].Size } } return nil } // netStorageDownloadRequest performs a NetStorage download request func (o *Object) netStorageDownloadRequest(ctx context.Context, options []fs.OpenOption) (in io.ReadCloser, err error) { URL := o.fullURL // If requested file ends with .rclonelink and target has value // then serve the content of target (the symlink target) if strings.HasSuffix(URL, ".rclonelink") && o.target != "" { fs.Infof(nil, "Converting a symlink to the rclonelink file on download %q", URL) reader := strings.NewReader(o.target) readcloser := io.NopCloser(reader) return readcloser, nil } const actionHeader = "version=1&action=download" fs.FixRangeOption(options, o.size) body, err := o.fs.callBackend(ctx, URL, "GET", actionHeader, false, nil, options) if err != nil { fs.Debugf(nil, "NetStorage action download failed for %q: %v", URL, err) return nil, err } return body, nil } // netStorageDuRequest performs a NetStorage du request func (f *Fs) netStorageDuRequest(ctx context.Context) (any, error) { URL := f.url("") const actionHeader = "version=1&action=du&format=xml&encoding=utf-8" duResp := &Du{} if _, err := f.callBackend(ctx, URL, "GET", actionHeader, false, duResp, nil); err != nil { if err == fs.ErrorObjectNotFound { return nil, errors.New("NetStorage du command: target is not a directory or does not exist") } fs.Debugf(nil, "NetStorage action du failed for %q: %v", URL, err) return nil, err } //passing the output format expected from return of Command to be displayed by rclone code out := map[string]int64{ "Number of files": duResp.Duinfo.Files, "Total bytes": duResp.Duinfo.Bytes, } return out, nil } // netStorageDuRequest performs a NetStorage symlink request func (f *Fs) netStorageSymlinkRequest(ctx context.Context, URL string, dst string, modTime *int64) (any, error) { target := url.QueryEscape(strings.TrimSuffix(dst, "/")) actionHeader := "version=1&action=symlink&target=" + target if modTime != nil { when := strconv.FormatInt(*modTime, 10) actionHeader += "&mtime=" + when } if _, err := f.callBackend(ctx, URL, "POST", actionHeader, true, nil, nil); err != nil { fs.Debugf(nil, "NetStorage action symlink failed for %q: %v", URL, err) return nil, fmt.Errorf("symlink creation failed: %w", err) } f.deleteStatCache(URL) out := map[string]string{ "Symlink successfully created": dst, } return out, nil } // netStorageMkdirRequest performs a NetStorage mkdir request func (f *Fs) netStorageMkdirRequest(ctx context.Context, URL string) error { const actionHeader = "version=1&action=mkdir" if _, err := f.callBackend(ctx, URL, "POST", actionHeader, true, nil, nil); err != nil { fs.Debugf(nil, "NetStorage action mkdir failed for %q: %v", URL, err) return err } f.deleteStatCache(URL) return nil } // netStorageDeleteRequest performs a NetStorage delete request func (o *Object) netStorageDeleteRequest(ctx context.Context) error { URL := o.fullURL // We shouldn't be creating .rclonelink files on remote // but delete corresponding symlink if it exists if strings.HasSuffix(URL, ".rclonelink") { fs.Infof(nil, "Converting rclonelink to a symlink on delete %q", URL) URL = strings.TrimSuffix(URL, ".rclonelink") } const actionHeader = "version=1&action=delete" if _, err := o.fs.callBackend(ctx, URL, "POST", actionHeader, true, nil, nil); err != nil { fs.Debugf(nil, "NetStorage action delete failed for %q: %v", URL, err) return err } o.fs.deleteStatCache(URL) return nil } // netStorageRmdirRequest performs a NetStorage rmdir request func (f *Fs) netStorageRmdirRequest(ctx context.Context, dir string) error { URL := f.url(dir) const actionHeader = "version=1&action=rmdir" if _, err := f.callBackend(ctx, URL, "POST", actionHeader, true, nil, nil); err != nil { if err == fs.ErrorObjectNotFound { return fs.ErrorDirNotFound } fs.Debugf(nil, "NetStorage action rmdir failed for %q: %v", URL, err) return err } f.deleteStatCache(URL) f.deleteDirscreated(URL) return nil } // deleteDirscreated deletes URL from dirscreated map thread-safely func (f *Fs) deleteDirscreated(URL string) { URL = strings.TrimSuffix(URL, "/") f.dirscreatedMutex.Lock() delete(f.dirscreated, URL) f.dirscreatedMutex.Unlock() } // setDirscreated sets to true URL in dirscreated map thread-safely func (f *Fs) setDirscreated(URL string) { URL = strings.TrimSuffix(URL, "/") f.dirscreatedMutex.Lock() f.dirscreated[URL] = true f.dirscreatedMutex.Unlock() } // testAndSetDirscreated atomic test-and-set to true URL in dirscreated map, // returns the previous value func (f *Fs) testAndSetDirscreated(URL string) bool { URL = strings.TrimSuffix(URL, "/") f.dirscreatedMutex.Lock() oldValue := f.dirscreated[URL] f.dirscreated[URL] = true f.dirscreatedMutex.Unlock() return oldValue } // deleteStatCache deletes URL from stat cache thread-safely func (f *Fs) deleteStatCache(URL string) { URL = strings.TrimSuffix(URL, "/") f.statcacheMutex.Lock() delete(f.statcache, URL) f.statcacheMutex.Unlock() } // getStatCache gets value from statcache map thread-safely func (f *Fs) getStatCache(URL string) (files []File) { URL = strings.TrimSuffix(URL, "/") f.statcacheMutex.RLock() files = f.statcache[URL] f.statcacheMutex.RUnlock() if files != nil { fs.Debugf(nil, "NetStorage stat cache hit for %q", URL) } return } // setStatCache sets value to statcache map thread-safely func (f *Fs) setStatCache(URL string, files []File) { URL = strings.TrimSuffix(URL, "/") f.statcacheMutex.Lock() f.statcache[URL] = files f.statcacheMutex.Unlock() } type hashReader struct { io.Reader gohash.Hash } func newHashReader(r io.Reader, h gohash.Hash) hashReader { return hashReader{io.TeeReader(r, h), h} } type customReader func([]byte) (int, error) func (c customReader) Read(p []byte) (n int, err error) { return c(p) } // generateRequestID generates the unique requestID func generateRequestID() int64 { s1 := rand.NewSource(time.Now().UnixNano()) r1 := rand.New(s1) return r1.Int63() } // computeHmac256 calculates the hash for the sign header func computeHmac256(message string, secret string) string { key := []byte(secret) h := hmac.New(sha256.New, key) h.Write([]byte(message)) return base64.StdEncoding.EncodeToString(h.Sum(nil)) } // getEpochTimeInSeconds returns current epoch time in seconds func getEpochTimeInSeconds() int64 { now := time.Now() secs := now.Unix() return secs } // generateDataHeader generates data header needed for making the request func generateDataHeader(f *Fs) string { return "5, 0.0.0.0, 0.0.0.0, " + strconv.FormatInt(getEpochTimeInSeconds(), 10) + ", " + strconv.FormatInt(generateRequestID(), 10) + "," + f.opt.Account } // generateSignHeader generates sign header needed for making the request func generateSignHeader(f *Fs, dataHeader string, path string, actionHeader string) string { var message = dataHeader + path + "\nx-akamai-acs-action:" + actionHeader + "\n" return computeHmac256(message, f.opt.Secret) } // pathIsOneLevelDeep returns true if a given path does not go deeper than one level func pathIsOneLevelDeep(path string) bool { return !strings.Contains(strings.TrimSuffix(strings.TrimPrefix(path, "/"), "/"), "/") } // Check the interfaces are satisfied var ( _ fs.Fs = &Fs{} _ fs.Purger = &Fs{} _ fs.PutStreamer = &Fs{} _ fs.ListRer = &Fs{} _ fs.Object = &Object{} ) rclone-v1.71.0/backend/netstorage/netstorage_test.go000066400000000000000000000005311505210326400225500ustar00rootroot00000000000000package netstorage_test import ( "testing" "github.com/rclone/rclone/backend/netstorage" "github.com/rclone/rclone/fstest/fstests" ) // TestIntegration runs integration tests against the remote func TestIntegration(t *testing.T) { fstests.Run(t, &fstests.Opt{ RemoteName: "TestnStorage:", NilObject: (*netstorage.Object)(nil), }) } rclone-v1.71.0/backend/onedrive/000077500000000000000000000000001505210326400164505ustar00rootroot00000000000000rclone-v1.71.0/backend/onedrive/api/000077500000000000000000000000001505210326400172215ustar00rootroot00000000000000rclone-v1.71.0/backend/onedrive/api/types.go000066400000000000000000000777631505210326400207400ustar00rootroot00000000000000// Package api provides types used by the OneDrive API. package api import ( "strings" "time" ) const ( timeFormat = `"` + "2006-01-02T15:04:05.999Z" + `"` // PackageTypeOneNote is the package type value for OneNote files PackageTypeOneNote = "oneNote" ) // Error is returned from OneDrive when things go wrong type Error struct { ErrorInfo struct { Code string `json:"code"` Message string `json:"message"` InnerError struct { Code string `json:"code"` } `json:"innererror"` } `json:"error"` } // Error returns a string for the error and satisfies the error interface func (e *Error) Error() string { out := e.ErrorInfo.Code if e.ErrorInfo.InnerError.Code != "" { out += ": " + e.ErrorInfo.InnerError.Code } out += ": " + e.ErrorInfo.Message return out } // Check Error satisfies the error interface var _ error = (*Error)(nil) // Identity represents an identity of an actor. For example, and actor // can be a user, device, or application. type Identity struct { DisplayName string `json:"displayName,omitempty"` ID string `json:"id,omitempty"` Email string `json:"email,omitempty"` // not officially documented, but seems to sometimes exist LoginName string `json:"loginName,omitempty"` // SharePoint only } // IdentitySet is a keyed collection of Identity objects. It is used // to represent a set of identities associated with various events for // an item, such as created by or last modified by. type IdentitySet struct { User Identity `json:"user,omitempty"` Application Identity `json:"application,omitempty"` Device Identity `json:"device,omitempty"` Group Identity `json:"group,omitempty"` SiteGroup Identity `json:"siteGroup,omitempty"` // The SharePoint group associated with this action. Optional. SiteUser Identity `json:"siteUser,omitempty"` // The SharePoint user associated with this action. Optional. } // Quota groups storage space quota-related information on OneDrive into a single structure. type Quota struct { Total int64 `json:"total"` Used int64 `json:"used"` Remaining int64 `json:"remaining"` Deleted int64 `json:"deleted"` State string `json:"state"` // normal | nearing | critical | exceeded } // Drive is a representation of a drive resource type Drive struct { ID string `json:"id"` DriveType string `json:"driveType"` Owner IdentitySet `json:"owner"` Quota Quota `json:"quota"` } // Timestamp represents date and time information for the // OneDrive API, by using ISO 8601 and is always in UTC time. type Timestamp time.Time // MarshalJSON turns a Timestamp into JSON (in UTC) func (t *Timestamp) MarshalJSON() (out []byte, err error) { timeString := (*time.Time)(t).UTC().Format(timeFormat) return []byte(timeString), nil } // UnmarshalJSON turns JSON into a Timestamp func (t *Timestamp) UnmarshalJSON(data []byte) error { newT, err := time.Parse(timeFormat, string(data)) if err != nil { return err } *t = Timestamp(newT) return nil } // ItemReference groups data needed to reference a OneDrive item // across the service into a single structure. type ItemReference struct { DriveID string `json:"driveId"` // Unique identifier for the Drive that contains the item. Read-only. ID string `json:"id"` // Unique identifier for the item. Read/Write. Path string `json:"path"` // Path that used to navigate to the item. Read/Write. DriveType string `json:"driveType"` // Type of the drive, Read-Only } // GetID returns a normalized ID of the item // If DriveID is known it will be prefixed to the ID with # separator // Can be parsed using onedrive.parseNormalizedID(normalizedID) func (i *ItemReference) GetID() string { if !strings.Contains(i.ID, "#") { return i.DriveID + "#" + i.ID } return i.ID } // RemoteItemFacet groups data needed to reference a OneDrive remote item type RemoteItemFacet struct { ID string `json:"id"` // The unique identifier of the item within the remote Drive. Read-only. Name string `json:"name"` // The name of the item (filename and extension). Read-write. CreatedBy IdentitySet `json:"createdBy"` // Identity of the user, device, and application which created the item. Read-only. LastModifiedBy IdentitySet `json:"lastModifiedBy"` // Identity of the user, device, and application which last modified the item. Read-only. CreatedDateTime Timestamp `json:"createdDateTime"` // Date and time of item creation. Read-only. LastModifiedDateTime Timestamp `json:"lastModifiedDateTime"` // Date and time the item was last modified. Read-only. Folder *FolderFacet `json:"folder"` // Folder metadata, if the item is a folder. Read-only. File *FileFacet `json:"file"` // File metadata, if the item is a file. Read-only. Package *PackageFacet `json:"package"` // If present, indicates that this item is a package instead of a folder or file. Packages are treated like files in some contexts and folders in others. Read-only. FileSystemInfo *FileSystemInfoFacet `json:"fileSystemInfo"` // File system information on client. Read-write. ParentReference *ItemReference `json:"parentReference"` // Parent information, if the item has a parent. Read-write. Size int64 `json:"size"` // Size of the item in bytes. Read-only. WebURL string `json:"webUrl"` // URL that displays the resource in the browser. Read-only. } // FolderFacet groups folder-related data on OneDrive into a single structure type FolderFacet struct { ChildCount int64 `json:"childCount"` // Number of children contained immediately within this container. } // HashesType groups different types of hashes into a single structure, for an item on OneDrive. type HashesType struct { Sha1Hash string `json:"sha1Hash"` // hex encoded SHA1 hash for the contents of the file (if available) Crc32Hash string `json:"crc32Hash"` // hex encoded CRC32 value of the file (if available) QuickXorHash string `json:"quickXorHash"` // base64 encoded QuickXorHash value of the file (if available) Sha256Hash string `json:"sha256Hash"` // hex encoded SHA256 value of the file (if available) } // FileFacet groups file-related data on OneDrive into a single structure. type FileFacet struct { MimeType string `json:"mimeType"` // The MIME type for the file. This is determined by logic on the server and might not be the value provided when the file was uploaded. Hashes HashesType `json:"hashes"` // Hashes of the file's binary content, if available. } // FileSystemInfoFacet contains properties that are reported by the // device's local file system for the local version of an item. This // facet can be used to specify the last modified date or created date // of the item as it was on the local device. type FileSystemInfoFacet struct { CreatedDateTime Timestamp `json:"createdDateTime,omitempty"` // The UTC date and time the file was created on a client. LastModifiedDateTime Timestamp `json:"lastModifiedDateTime,omitempty"` // The UTC date and time the file was last modified on a client. } // DeletedFacet indicates that the item on OneDrive has been // deleted. In this version of the API, the presence (non-null) of the // facet value indicates that the file was deleted. A null (or // missing) value indicates that the file is not deleted. type DeletedFacet struct{} // PackageFacet indicates that a DriveItem is the top level item // in a "package" or a collection of items that should be treated as a collection instead of individual items. // `oneNote` is the only currently defined value. type PackageFacet struct { Type string `json:"type"` } // SharedType indicates a DriveItem has been shared with others. The resource includes information about how the item is shared. // If a Driveitem has a non-null shared facet, the item has been shared. type SharedType struct { Owner IdentitySet `json:"owner,omitempty"` // The identity of the owner of the shared item. Read-only. Scope string `json:"scope,omitempty"` // Indicates the scope of how the item is shared: anonymous, organization, or users. Read-only. SharedBy IdentitySet `json:"sharedBy,omitempty"` // The identity of the user who shared the item. Read-only. SharedDateTime Timestamp `json:"sharedDateTime,omitempty"` // The UTC date and time when the item was shared. Read-only. } // SharingInvitationType groups invitation-related data items into a single structure. type SharingInvitationType struct { Email string `json:"email,omitempty"` // The email address provided for the recipient of the sharing invitation. Read-only. InvitedBy *IdentitySet `json:"invitedBy,omitempty"` // Provides information about who sent the invitation that created this permission, if that information is available. Read-only. SignInRequired bool `json:"signInRequired,omitempty"` // If true the recipient of the invitation needs to sign in in order to access the shared item. Read-only. } // SharingLinkType groups link-related data items into a single structure. // If a Permission resource has a non-null sharingLink facet, the permission represents a sharing link (as opposed to permissions granted to a person or group). type SharingLinkType struct { Application *Identity `json:"application,omitempty"` // The app the link is associated with. Type LinkType `json:"type,omitempty"` // The type of the link created. Scope LinkScope `json:"scope,omitempty"` // The scope of the link represented by this permission. Value anonymous indicates the link is usable by anyone, organization indicates the link is only usable for users signed into the same tenant. WebHTML string `json:"webHtml,omitempty"` // For embed links, this property contains the HTML code for an
Links
Rclone forum
GitHub project
Rclone Wiki
Sponsor
@njcw
rclone-v1.71.0/docs/layouts/chrome/navbar.html000066400000000000000000000256701505210326400213240ustar00rootroot00000000000000 rclone-v1.71.0/docs/layouts/index.html000066400000000000000000000000551505210326400176730ustar00rootroot00000000000000{{ define "main" }} {{ .Content }} {{ end }} rclone-v1.71.0/docs/layouts/partials/000077500000000000000000000000001505210326400175155ustar00rootroot00000000000000rclone-v1.71.0/docs/layouts/partials/version.html000066400000000000000000000000071505210326400220650ustar00rootroot00000000000000v1.71.0rclone-v1.71.0/docs/layouts/rss.xml000066400000000000000000000013621505210326400172310ustar00rootroot00000000000000 {{ .Title }} on {{ .Site.Title }} {{ .Permalink }} en-US Nick Craig-Wood Copyright (c) 2017, Nick Craig-Wood; all rights reserved. {{ .Date.Format "Mon, 02 Jan 2006 15:04:05 MST" }} {{ range first 15 .Data.Pages }} {{ .Title }} {{ .Permalink }} {{ .Date.Format "Mon, 02 Jan 2006 15:04:05 MST" }} Nick Craig-Wood {{ .Permalink }} {{ .Content | html }} {{ end }} rclone-v1.71.0/docs/layouts/section/000077500000000000000000000000001505210326400173425ustar00rootroot00000000000000rclone-v1.71.0/docs/layouts/section/commands.html000066400000000000000000000007631505210326400220370ustar00rootroot00000000000000{{ define "main" }}

Rclone Commands

This is an index of all commands in rclone. Run rclone command --help to see the help for that command.

{{ range .Data.Pages }} {{ end }}
Command Description
{{ .Title | markdownify }} {{ .Description | markdownify }}
{{ end }} rclone-v1.71.0/docs/layouts/shortcodes/000077500000000000000000000000001505210326400200535ustar00rootroot00000000000000rclone-v1.71.0/docs/layouts/shortcodes/asciinema.html000066400000000000000000000002111505210326400226640ustar00rootroot00000000000000 rclone-v1.71.0/docs/layouts/shortcodes/bizbutton.html000066400000000000000000000002501505210326400227560ustar00rootroot00000000000000 For Business rclone-v1.71.0/docs/layouts/shortcodes/cdownload.html000066400000000000000000000004361505210326400227160ustar00rootroot00000000000000 rclone-v1.71.0/docs/layouts/shortcodes/color.html000066400000000000000000000000661505210326400220610ustar00rootroot00000000000000{{ .Inner }} rclone-v1.71.0/docs/layouts/shortcodes/download.html000066400000000000000000000005241505210326400225510ustar00rootroot00000000000000 rclone-v1.71.0/docs/layouts/shortcodes/icon.html000066400000000000000000000000601505210326400216650ustar00rootroot00000000000000 rclone-v1.71.0/docs/layouts/shortcodes/img.html000066400000000000000000000001641505210326400215160ustar00rootroot00000000000000{{ .Get rclone-v1.71.0/docs/layouts/shortcodes/monthly_donations.html000066400000000000000000000030111505210326400245040ustar00rootroot00000000000000 rclone-v1.71.0/docs/layouts/shortcodes/nick.html000066400000000000000000000001311505210326400216600ustar00rootroot00000000000000

Nick
Nick Craig-Wood

rclone-v1.71.0/docs/layouts/shortcodes/one_off_donations.html000066400000000000000000000041361505210326400244360ustar00rootroot00000000000000
Sponsor in $ USD Sponsor in £ GBP Sponsor in € EUR
PayPal.Me
Bitcoin: scan or click the image or copy the address bitcoin:19j3oLUsqBcTRvZ2LSq2phVjsAAJ86xSnk
rclone-v1.71.0/docs/layouts/shortcodes/provider.html000066400000000000000000000010441505210326400225720ustar00rootroot00000000000000
  • {{ .Get "name" }}{{ if .Get "note"}} (See note){{end}} Home Config
    • rclone-v1.71.0/docs/layouts/shortcodes/provider_list.html000066400000000000000000000000531505210326400236240ustar00rootroot00000000000000
      {{ .Inner }}
    rclone-v1.71.0/docs/layouts/shortcodes/rem.html000066400000000000000000000000001505210326400215120ustar00rootroot00000000000000rclone-v1.71.0/docs/layouts/shortcodes/sponsor.html000066400000000000000000000004111505210326400224400ustar00rootroot00000000000000 rclone-v1.71.0/docs/layouts/shortcodes/version.html000066400000000000000000000000361505210326400224250ustar00rootroot00000000000000{{ partial "version.html" . }}rclone-v1.71.0/docs/layouts/sitemap.xml000066400000000000000000000006301505210326400200610ustar00rootroot00000000000000 {{ range .Data.Pages }} {{ .Permalink }} {{ safeHTML ( .Date.Format "2006-01-02T15:04:05-07:00" ) }}{{ with .Sitemap.ChangeFreq }} {{ . }}{{ end }}{{ if ge .Sitemap.Priority 0.0 }} {{ .Sitemap.Priority }}{{ end }} {{ end }} rclone-v1.71.0/docs/static/000077500000000000000000000000001505210326400154655ustar00rootroot00000000000000rclone-v1.71.0/docs/static/css/000077500000000000000000000000001505210326400162555ustar00rootroot00000000000000rclone-v1.71.0/docs/static/css/bootstrap.min.4.4.1.css000066400000000000000000004674331505210326400222520ustar00rootroot00000000000000/*! * Bootstrap v4.4.1 (https://getbootstrap.com/) * Copyright 2011-2019 The Bootstrap Authors * Copyright 2011-2019 Twitter, Inc. * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) */:root{--blue:#007bff;--indigo:#6610f2;--purple:#6f42c1;--pink:#e83e8c;--red:#dc3545;--orange:#fd7e14;--yellow:#ffc107;--green:#28a745;--teal:#20c997;--cyan:#17a2b8;--white:#fff;--gray:#6c757d;--gray-dark:#343a40;--primary:#007bff;--secondary:#6c757d;--success:#28a745;--info:#17a2b8;--warning:#ffc107;--danger:#dc3545;--light:#f8f9fa;--dark:#343a40;--breakpoint-xs:0;--breakpoint-sm:576px;--breakpoint-md:768px;--breakpoint-lg:992px;--breakpoint-xl:1200px;--font-family-sans-serif:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";--font-family-monospace:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace}*,::after,::before{box-sizing:border-box}html{font-family:sans-serif;line-height:1.15;-webkit-text-size-adjust:100%;-webkit-tap-highlight-color:transparent}article,aside,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}body{margin:0;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";font-size:1rem;font-weight:400;line-height:1.5;color:#212529;text-align:left;background-color:#fff}[tabindex="-1"]:focus:not(:focus-visible){outline:0!important}hr{box-sizing:content-box;height:0;overflow:visible}h1,h2,h3,h4,h5,h6{margin-top:0;margin-bottom:.5rem}p{margin-top:0;margin-bottom:1rem}abbr[data-original-title],abbr[title]{text-decoration:underline;-webkit-text-decoration:underline dotted;text-decoration:underline dotted;cursor:help;border-bottom:0;-webkit-text-decoration-skip-ink:none;text-decoration-skip-ink:none}address{margin-bottom:1rem;font-style:normal;line-height:inherit}dl,ol,ul{margin-top:0;margin-bottom:1rem}ol ol,ol ul,ul ol,ul ul{margin-bottom:0}dt{font-weight:700}dd{margin-bottom:.5rem;margin-left:0}blockquote{margin:0 0 1rem}b,strong{font-weight:bolder}small{font-size:80%}sub,sup{position:relative;font-size:75%;line-height:0;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}a{color:#007bff;text-decoration:none;background-color:transparent}a:hover{color:#0056b3;text-decoration:underline}a:not([href]){color:inherit;text-decoration:none}a:not([href]):hover{color:inherit;text-decoration:none}code,kbd,pre,samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;font-size:1em}pre{margin-top:0;margin-bottom:1rem;overflow:auto}figure{margin:0 0 1rem}img{vertical-align:middle;border-style:none}svg{overflow:hidden;vertical-align:middle}table{border-collapse:collapse}caption{padding-top:.75rem;padding-bottom:.75rem;color:#6c757d;text-align:left;caption-side:bottom}th{text-align:inherit}label{display:inline-block;margin-bottom:.5rem}button{border-radius:0}button:focus{outline:1px dotted;outline:5px auto -webkit-focus-ring-color}button,input,optgroup,select,textarea{margin:0;font-family:inherit;font-size:inherit;line-height:inherit}button,input{overflow:visible}button,select{text-transform:none}select{word-wrap:normal}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]:not(:disabled),[type=reset]:not(:disabled),[type=submit]:not(:disabled),button:not(:disabled){cursor:pointer}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{padding:0;border-style:none}input[type=checkbox],input[type=radio]{box-sizing:border-box;padding:0}input[type=date],input[type=datetime-local],input[type=month],input[type=time]{-webkit-appearance:listbox}textarea{overflow:auto;resize:vertical}fieldset{min-width:0;padding:0;margin:0;border:0}legend{display:block;width:100%;max-width:100%;padding:0;margin-bottom:.5rem;font-size:1.5rem;line-height:inherit;color:inherit;white-space:normal}progress{vertical-align:baseline}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{outline-offset:-2px;-webkit-appearance:none}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{font:inherit;-webkit-appearance:button}output{display:inline-block}summary{display:list-item;cursor:pointer}template{display:none}[hidden]{display:none!important}.h1,.h2,.h3,.h4,.h5,.h6,h1,h2,h3,h4,h5,h6{margin-bottom:.5rem;font-weight:500;line-height:1.2}.h1,h1{font-size:2.5rem}.h2,h2{font-size:2rem}.h3,h3{font-size:1.75rem}.h4,h4{font-size:1.5rem}.h5,h5{font-size:1.25rem}.h6,h6{font-size:1rem}.lead{font-size:1.25rem;font-weight:300}.display-1{font-size:6rem;font-weight:300;line-height:1.2}.display-2{font-size:5.5rem;font-weight:300;line-height:1.2}.display-3{font-size:4.5rem;font-weight:300;line-height:1.2}.display-4{font-size:3.5rem;font-weight:300;line-height:1.2}hr{margin-top:1rem;margin-bottom:1rem;border:0;border-top:1px solid rgba(0,0,0,.1)}.small,small{font-size:80%;font-weight:400}.mark,mark{padding:.2em;background-color:#fcf8e3}.list-unstyled{padding-left:0;list-style:none}.list-inline{padding-left:0;list-style:none}.list-inline-item{display:inline-block}.list-inline-item:not(:last-child){margin-right:.5rem}.initialism{font-size:90%;text-transform:uppercase}.blockquote{margin-bottom:1rem;font-size:1.25rem}.blockquote-footer{display:block;font-size:80%;color:#6c757d}.blockquote-footer::before{content:"\2014\00A0"}.img-fluid{max-width:100%;height:auto}.img-thumbnail{padding:.25rem;background-color:#fff;border:1px solid #dee2e6;border-radius:.25rem;max-width:100%;height:auto}.figure{display:inline-block}.figure-img{margin-bottom:.5rem;line-height:1}.figure-caption{font-size:90%;color:#6c757d}code{font-size:87.5%;color:#e83e8c;word-wrap:break-word}a>code{color:inherit}kbd{padding:.2rem .4rem;font-size:87.5%;color:#fff;background-color:#212529;border-radius:.2rem}kbd kbd{padding:0;font-size:100%;font-weight:700}pre{display:block;font-size:87.5%;color:#212529}pre code{font-size:inherit;color:inherit;word-break:normal}.pre-scrollable{max-height:340px;overflow-y:scroll}.container{width:100%;padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}@media (min-width:576px){.container{max-width:540px}}@media (min-width:768px){.container{max-width:720px}}@media (min-width:992px){.container{max-width:960px}}@media (min-width:1200px){.container{max-width:1140px}}.container-fluid,.container-lg,.container-md,.container-sm,.container-xl{width:100%;padding-right:15px;padding-left:15px;margin-right:auto;margin-left:auto}@media (min-width:576px){.container,.container-sm{max-width:540px}}@media (min-width:768px){.container,.container-md,.container-sm{max-width:720px}}@media (min-width:992px){.container,.container-lg,.container-md,.container-sm{max-width:960px}}@media (min-width:1200px){.container,.container-lg,.container-md,.container-sm,.container-xl{max-width:1140px}}.row{display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;margin-right:-15px;margin-left:-15px}.no-gutters{margin-right:0;margin-left:0}.no-gutters>.col,.no-gutters>[class*=col-]{padding-right:0;padding-left:0}.col,.col-1,.col-10,.col-11,.col-12,.col-2,.col-3,.col-4,.col-5,.col-6,.col-7,.col-8,.col-9,.col-auto,.col-lg,.col-lg-1,.col-lg-10,.col-lg-11,.col-lg-12,.col-lg-2,.col-lg-3,.col-lg-4,.col-lg-5,.col-lg-6,.col-lg-7,.col-lg-8,.col-lg-9,.col-lg-auto,.col-md,.col-md-1,.col-md-10,.col-md-11,.col-md-12,.col-md-2,.col-md-3,.col-md-4,.col-md-5,.col-md-6,.col-md-7,.col-md-8,.col-md-9,.col-md-auto,.col-sm,.col-sm-1,.col-sm-10,.col-sm-11,.col-sm-12,.col-sm-2,.col-sm-3,.col-sm-4,.col-sm-5,.col-sm-6,.col-sm-7,.col-sm-8,.col-sm-9,.col-sm-auto,.col-xl,.col-xl-1,.col-xl-10,.col-xl-11,.col-xl-12,.col-xl-2,.col-xl-3,.col-xl-4,.col-xl-5,.col-xl-6,.col-xl-7,.col-xl-8,.col-xl-9,.col-xl-auto{position:relative;width:100%;padding-right:15px;padding-left:15px}.col{-ms-flex-preferred-size:0;flex-basis:0;-ms-flex-positive:1;flex-grow:1;max-width:100%}.row-cols-1>*{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.row-cols-2>*{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.row-cols-3>*{-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.row-cols-4>*{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.row-cols-5>*{-ms-flex:0 0 20%;flex:0 0 20%;max-width:20%}.row-cols-6>*{-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto;max-width:100%}.col-1{-ms-flex:0 0 8.333333%;flex:0 0 8.333333%;max-width:8.333333%}.col-2{-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-3{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-4{-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.col-5{-ms-flex:0 0 41.666667%;flex:0 0 41.666667%;max-width:41.666667%}.col-6{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-7{-ms-flex:0 0 58.333333%;flex:0 0 58.333333%;max-width:58.333333%}.col-8{-ms-flex:0 0 66.666667%;flex:0 0 66.666667%;max-width:66.666667%}.col-9{-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-10{-ms-flex:0 0 83.333333%;flex:0 0 83.333333%;max-width:83.333333%}.col-11{-ms-flex:0 0 91.666667%;flex:0 0 91.666667%;max-width:91.666667%}.col-12{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.order-first{-ms-flex-order:-1;order:-1}.order-last{-ms-flex-order:13;order:13}.order-0{-ms-flex-order:0;order:0}.order-1{-ms-flex-order:1;order:1}.order-2{-ms-flex-order:2;order:2}.order-3{-ms-flex-order:3;order:3}.order-4{-ms-flex-order:4;order:4}.order-5{-ms-flex-order:5;order:5}.order-6{-ms-flex-order:6;order:6}.order-7{-ms-flex-order:7;order:7}.order-8{-ms-flex-order:8;order:8}.order-9{-ms-flex-order:9;order:9}.order-10{-ms-flex-order:10;order:10}.order-11{-ms-flex-order:11;order:11}.order-12{-ms-flex-order:12;order:12}.offset-1{margin-left:8.333333%}.offset-2{margin-left:16.666667%}.offset-3{margin-left:25%}.offset-4{margin-left:33.333333%}.offset-5{margin-left:41.666667%}.offset-6{margin-left:50%}.offset-7{margin-left:58.333333%}.offset-8{margin-left:66.666667%}.offset-9{margin-left:75%}.offset-10{margin-left:83.333333%}.offset-11{margin-left:91.666667%}@media (min-width:576px){.col-sm{-ms-flex-preferred-size:0;flex-basis:0;-ms-flex-positive:1;flex-grow:1;max-width:100%}.row-cols-sm-1>*{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.row-cols-sm-2>*{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.row-cols-sm-3>*{-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.row-cols-sm-4>*{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.row-cols-sm-5>*{-ms-flex:0 0 20%;flex:0 0 20%;max-width:20%}.row-cols-sm-6>*{-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-sm-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto;max-width:100%}.col-sm-1{-ms-flex:0 0 8.333333%;flex:0 0 8.333333%;max-width:8.333333%}.col-sm-2{-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-sm-3{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-sm-4{-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.col-sm-5{-ms-flex:0 0 41.666667%;flex:0 0 41.666667%;max-width:41.666667%}.col-sm-6{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-sm-7{-ms-flex:0 0 58.333333%;flex:0 0 58.333333%;max-width:58.333333%}.col-sm-8{-ms-flex:0 0 66.666667%;flex:0 0 66.666667%;max-width:66.666667%}.col-sm-9{-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-sm-10{-ms-flex:0 0 83.333333%;flex:0 0 83.333333%;max-width:83.333333%}.col-sm-11{-ms-flex:0 0 91.666667%;flex:0 0 91.666667%;max-width:91.666667%}.col-sm-12{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.order-sm-first{-ms-flex-order:-1;order:-1}.order-sm-last{-ms-flex-order:13;order:13}.order-sm-0{-ms-flex-order:0;order:0}.order-sm-1{-ms-flex-order:1;order:1}.order-sm-2{-ms-flex-order:2;order:2}.order-sm-3{-ms-flex-order:3;order:3}.order-sm-4{-ms-flex-order:4;order:4}.order-sm-5{-ms-flex-order:5;order:5}.order-sm-6{-ms-flex-order:6;order:6}.order-sm-7{-ms-flex-order:7;order:7}.order-sm-8{-ms-flex-order:8;order:8}.order-sm-9{-ms-flex-order:9;order:9}.order-sm-10{-ms-flex-order:10;order:10}.order-sm-11{-ms-flex-order:11;order:11}.order-sm-12{-ms-flex-order:12;order:12}.offset-sm-0{margin-left:0}.offset-sm-1{margin-left:8.333333%}.offset-sm-2{margin-left:16.666667%}.offset-sm-3{margin-left:25%}.offset-sm-4{margin-left:33.333333%}.offset-sm-5{margin-left:41.666667%}.offset-sm-6{margin-left:50%}.offset-sm-7{margin-left:58.333333%}.offset-sm-8{margin-left:66.666667%}.offset-sm-9{margin-left:75%}.offset-sm-10{margin-left:83.333333%}.offset-sm-11{margin-left:91.666667%}}@media (min-width:768px){.col-md{-ms-flex-preferred-size:0;flex-basis:0;-ms-flex-positive:1;flex-grow:1;max-width:100%}.row-cols-md-1>*{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.row-cols-md-2>*{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.row-cols-md-3>*{-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.row-cols-md-4>*{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.row-cols-md-5>*{-ms-flex:0 0 20%;flex:0 0 20%;max-width:20%}.row-cols-md-6>*{-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-md-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto;max-width:100%}.col-md-1{-ms-flex:0 0 8.333333%;flex:0 0 8.333333%;max-width:8.333333%}.col-md-2{-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-md-3{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-md-4{-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.col-md-5{-ms-flex:0 0 41.666667%;flex:0 0 41.666667%;max-width:41.666667%}.col-md-6{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-md-7{-ms-flex:0 0 58.333333%;flex:0 0 58.333333%;max-width:58.333333%}.col-md-8{-ms-flex:0 0 66.666667%;flex:0 0 66.666667%;max-width:66.666667%}.col-md-9{-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-md-10{-ms-flex:0 0 83.333333%;flex:0 0 83.333333%;max-width:83.333333%}.col-md-11{-ms-flex:0 0 91.666667%;flex:0 0 91.666667%;max-width:91.666667%}.col-md-12{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.order-md-first{-ms-flex-order:-1;order:-1}.order-md-last{-ms-flex-order:13;order:13}.order-md-0{-ms-flex-order:0;order:0}.order-md-1{-ms-flex-order:1;order:1}.order-md-2{-ms-flex-order:2;order:2}.order-md-3{-ms-flex-order:3;order:3}.order-md-4{-ms-flex-order:4;order:4}.order-md-5{-ms-flex-order:5;order:5}.order-md-6{-ms-flex-order:6;order:6}.order-md-7{-ms-flex-order:7;order:7}.order-md-8{-ms-flex-order:8;order:8}.order-md-9{-ms-flex-order:9;order:9}.order-md-10{-ms-flex-order:10;order:10}.order-md-11{-ms-flex-order:11;order:11}.order-md-12{-ms-flex-order:12;order:12}.offset-md-0{margin-left:0}.offset-md-1{margin-left:8.333333%}.offset-md-2{margin-left:16.666667%}.offset-md-3{margin-left:25%}.offset-md-4{margin-left:33.333333%}.offset-md-5{margin-left:41.666667%}.offset-md-6{margin-left:50%}.offset-md-7{margin-left:58.333333%}.offset-md-8{margin-left:66.666667%}.offset-md-9{margin-left:75%}.offset-md-10{margin-left:83.333333%}.offset-md-11{margin-left:91.666667%}}@media (min-width:992px){.col-lg{-ms-flex-preferred-size:0;flex-basis:0;-ms-flex-positive:1;flex-grow:1;max-width:100%}.row-cols-lg-1>*{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.row-cols-lg-2>*{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.row-cols-lg-3>*{-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.row-cols-lg-4>*{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.row-cols-lg-5>*{-ms-flex:0 0 20%;flex:0 0 20%;max-width:20%}.row-cols-lg-6>*{-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-lg-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto;max-width:100%}.col-lg-1{-ms-flex:0 0 8.333333%;flex:0 0 8.333333%;max-width:8.333333%}.col-lg-2{-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-lg-3{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-lg-4{-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.col-lg-5{-ms-flex:0 0 41.666667%;flex:0 0 41.666667%;max-width:41.666667%}.col-lg-6{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-lg-7{-ms-flex:0 0 58.333333%;flex:0 0 58.333333%;max-width:58.333333%}.col-lg-8{-ms-flex:0 0 66.666667%;flex:0 0 66.666667%;max-width:66.666667%}.col-lg-9{-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-lg-10{-ms-flex:0 0 83.333333%;flex:0 0 83.333333%;max-width:83.333333%}.col-lg-11{-ms-flex:0 0 91.666667%;flex:0 0 91.666667%;max-width:91.666667%}.col-lg-12{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.order-lg-first{-ms-flex-order:-1;order:-1}.order-lg-last{-ms-flex-order:13;order:13}.order-lg-0{-ms-flex-order:0;order:0}.order-lg-1{-ms-flex-order:1;order:1}.order-lg-2{-ms-flex-order:2;order:2}.order-lg-3{-ms-flex-order:3;order:3}.order-lg-4{-ms-flex-order:4;order:4}.order-lg-5{-ms-flex-order:5;order:5}.order-lg-6{-ms-flex-order:6;order:6}.order-lg-7{-ms-flex-order:7;order:7}.order-lg-8{-ms-flex-order:8;order:8}.order-lg-9{-ms-flex-order:9;order:9}.order-lg-10{-ms-flex-order:10;order:10}.order-lg-11{-ms-flex-order:11;order:11}.order-lg-12{-ms-flex-order:12;order:12}.offset-lg-0{margin-left:0}.offset-lg-1{margin-left:8.333333%}.offset-lg-2{margin-left:16.666667%}.offset-lg-3{margin-left:25%}.offset-lg-4{margin-left:33.333333%}.offset-lg-5{margin-left:41.666667%}.offset-lg-6{margin-left:50%}.offset-lg-7{margin-left:58.333333%}.offset-lg-8{margin-left:66.666667%}.offset-lg-9{margin-left:75%}.offset-lg-10{margin-left:83.333333%}.offset-lg-11{margin-left:91.666667%}}@media (min-width:1200px){.col-xl{-ms-flex-preferred-size:0;flex-basis:0;-ms-flex-positive:1;flex-grow:1;max-width:100%}.row-cols-xl-1>*{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.row-cols-xl-2>*{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.row-cols-xl-3>*{-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.row-cols-xl-4>*{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.row-cols-xl-5>*{-ms-flex:0 0 20%;flex:0 0 20%;max-width:20%}.row-cols-xl-6>*{-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-xl-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto;max-width:100%}.col-xl-1{-ms-flex:0 0 8.333333%;flex:0 0 8.333333%;max-width:8.333333%}.col-xl-2{-ms-flex:0 0 16.666667%;flex:0 0 16.666667%;max-width:16.666667%}.col-xl-3{-ms-flex:0 0 25%;flex:0 0 25%;max-width:25%}.col-xl-4{-ms-flex:0 0 33.333333%;flex:0 0 33.333333%;max-width:33.333333%}.col-xl-5{-ms-flex:0 0 41.666667%;flex:0 0 41.666667%;max-width:41.666667%}.col-xl-6{-ms-flex:0 0 50%;flex:0 0 50%;max-width:50%}.col-xl-7{-ms-flex:0 0 58.333333%;flex:0 0 58.333333%;max-width:58.333333%}.col-xl-8{-ms-flex:0 0 66.666667%;flex:0 0 66.666667%;max-width:66.666667%}.col-xl-9{-ms-flex:0 0 75%;flex:0 0 75%;max-width:75%}.col-xl-10{-ms-flex:0 0 83.333333%;flex:0 0 83.333333%;max-width:83.333333%}.col-xl-11{-ms-flex:0 0 91.666667%;flex:0 0 91.666667%;max-width:91.666667%}.col-xl-12{-ms-flex:0 0 100%;flex:0 0 100%;max-width:100%}.order-xl-first{-ms-flex-order:-1;order:-1}.order-xl-last{-ms-flex-order:13;order:13}.order-xl-0{-ms-flex-order:0;order:0}.order-xl-1{-ms-flex-order:1;order:1}.order-xl-2{-ms-flex-order:2;order:2}.order-xl-3{-ms-flex-order:3;order:3}.order-xl-4{-ms-flex-order:4;order:4}.order-xl-5{-ms-flex-order:5;order:5}.order-xl-6{-ms-flex-order:6;order:6}.order-xl-7{-ms-flex-order:7;order:7}.order-xl-8{-ms-flex-order:8;order:8}.order-xl-9{-ms-flex-order:9;order:9}.order-xl-10{-ms-flex-order:10;order:10}.order-xl-11{-ms-flex-order:11;order:11}.order-xl-12{-ms-flex-order:12;order:12}.offset-xl-0{margin-left:0}.offset-xl-1{margin-left:8.333333%}.offset-xl-2{margin-left:16.666667%}.offset-xl-3{margin-left:25%}.offset-xl-4{margin-left:33.333333%}.offset-xl-5{margin-left:41.666667%}.offset-xl-6{margin-left:50%}.offset-xl-7{margin-left:58.333333%}.offset-xl-8{margin-left:66.666667%}.offset-xl-9{margin-left:75%}.offset-xl-10{margin-left:83.333333%}.offset-xl-11{margin-left:91.666667%}}.table{width:100%;margin-bottom:1rem;color:#212529}.table td,.table th{padding:.75rem;vertical-align:top;border-top:1px solid #dee2e6}.table thead th{vertical-align:bottom;border-bottom:2px solid #dee2e6}.table tbody+tbody{border-top:2px solid #dee2e6}.table-sm td,.table-sm th{padding:.3rem}.table-bordered{border:1px solid #dee2e6}.table-bordered td,.table-bordered th{border:1px solid #dee2e6}.table-bordered thead td,.table-bordered thead th{border-bottom-width:2px}.table-borderless tbody+tbody,.table-borderless td,.table-borderless th,.table-borderless thead th{border:0}.table-striped tbody tr:nth-of-type(odd){background-color:rgba(0,0,0,.05)}.table-hover tbody tr:hover{color:#212529;background-color:rgba(0,0,0,.075)}.table-primary,.table-primary>td,.table-primary>th{background-color:#b8daff}.table-primary tbody+tbody,.table-primary td,.table-primary th,.table-primary thead th{border-color:#7abaff}.table-hover .table-primary:hover{background-color:#9fcdff}.table-hover .table-primary:hover>td,.table-hover .table-primary:hover>th{background-color:#9fcdff}.table-secondary,.table-secondary>td,.table-secondary>th{background-color:#d6d8db}.table-secondary tbody+tbody,.table-secondary td,.table-secondary th,.table-secondary thead th{border-color:#b3b7bb}.table-hover .table-secondary:hover{background-color:#c8cbcf}.table-hover .table-secondary:hover>td,.table-hover .table-secondary:hover>th{background-color:#c8cbcf}.table-success,.table-success>td,.table-success>th{background-color:#c3e6cb}.table-success tbody+tbody,.table-success td,.table-success th,.table-success thead th{border-color:#8fd19e}.table-hover .table-success:hover{background-color:#b1dfbb}.table-hover .table-success:hover>td,.table-hover .table-success:hover>th{background-color:#b1dfbb}.table-info,.table-info>td,.table-info>th{background-color:#bee5eb}.table-info tbody+tbody,.table-info td,.table-info th,.table-info thead th{border-color:#86cfda}.table-hover .table-info:hover{background-color:#abdde5}.table-hover .table-info:hover>td,.table-hover .table-info:hover>th{background-color:#abdde5}.table-warning,.table-warning>td,.table-warning>th{background-color:#ffeeba}.table-warning tbody+tbody,.table-warning td,.table-warning th,.table-warning thead th{border-color:#ffdf7e}.table-hover .table-warning:hover{background-color:#ffe8a1}.table-hover .table-warning:hover>td,.table-hover .table-warning:hover>th{background-color:#ffe8a1}.table-danger,.table-danger>td,.table-danger>th{background-color:#f5c6cb}.table-danger tbody+tbody,.table-danger td,.table-danger th,.table-danger thead th{border-color:#ed969e}.table-hover .table-danger:hover{background-color:#f1b0b7}.table-hover .table-danger:hover>td,.table-hover .table-danger:hover>th{background-color:#f1b0b7}.table-light,.table-light>td,.table-light>th{background-color:#fdfdfe}.table-light tbody+tbody,.table-light td,.table-light th,.table-light thead th{border-color:#fbfcfc}.table-hover .table-light:hover{background-color:#ececf6}.table-hover .table-light:hover>td,.table-hover .table-light:hover>th{background-color:#ececf6}.table-dark,.table-dark>td,.table-dark>th{background-color:#c6c8ca}.table-dark tbody+tbody,.table-dark td,.table-dark th,.table-dark thead th{border-color:#95999c}.table-hover .table-dark:hover{background-color:#b9bbbe}.table-hover .table-dark:hover>td,.table-hover .table-dark:hover>th{background-color:#b9bbbe}.table-active,.table-active>td,.table-active>th{background-color:rgba(0,0,0,.075)}.table-hover .table-active:hover{background-color:rgba(0,0,0,.075)}.table-hover .table-active:hover>td,.table-hover .table-active:hover>th{background-color:rgba(0,0,0,.075)}.table .thead-dark th{color:#fff;background-color:#343a40;border-color:#454d55}.table .thead-light th{color:#495057;background-color:#e9ecef;border-color:#dee2e6}.table-dark{color:#fff;background-color:#343a40}.table-dark td,.table-dark th,.table-dark thead th{border-color:#454d55}.table-dark.table-bordered{border:0}.table-dark.table-striped tbody tr:nth-of-type(odd){background-color:rgba(255,255,255,.05)}.table-dark.table-hover tbody tr:hover{color:#fff;background-color:rgba(255,255,255,.075)}@media (max-width:575.98px){.table-responsive-sm{display:block;width:100%;overflow-x:auto;-webkit-overflow-scrolling:touch}.table-responsive-sm>.table-bordered{border:0}}@media (max-width:767.98px){.table-responsive-md{display:block;width:100%;overflow-x:auto;-webkit-overflow-scrolling:touch}.table-responsive-md>.table-bordered{border:0}}@media (max-width:991.98px){.table-responsive-lg{display:block;width:100%;overflow-x:auto;-webkit-overflow-scrolling:touch}.table-responsive-lg>.table-bordered{border:0}}@media (max-width:1199.98px){.table-responsive-xl{display:block;width:100%;overflow-x:auto;-webkit-overflow-scrolling:touch}.table-responsive-xl>.table-bordered{border:0}}.table-responsive{display:block;width:100%;overflow-x:auto;-webkit-overflow-scrolling:touch}.table-responsive>.table-bordered{border:0}.form-control{display:block;width:100%;height:calc(1.5em + .75rem + 2px);padding:.375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;color:#495057;background-color:#fff;background-clip:padding-box;border:1px solid #ced4da;border-radius:.25rem;transition:border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.form-control{transition:none}}.form-control::-ms-expand{background-color:transparent;border:0}.form-control:-moz-focusring{color:transparent;text-shadow:0 0 0 #495057}.form-control:focus{color:#495057;background-color:#fff;border-color:#80bdff;outline:0;box-shadow:0 0 0 .2rem rgba(0,123,255,.25)}.form-control::-webkit-input-placeholder{color:#6c757d;opacity:1}.form-control::-moz-placeholder{color:#6c757d;opacity:1}.form-control:-ms-input-placeholder{color:#6c757d;opacity:1}.form-control::-ms-input-placeholder{color:#6c757d;opacity:1}.form-control::placeholder{color:#6c757d;opacity:1}.form-control:disabled,.form-control[readonly]{background-color:#e9ecef;opacity:1}select.form-control:focus::-ms-value{color:#495057;background-color:#fff}.form-control-file,.form-control-range{display:block;width:100%}.col-form-label{padding-top:calc(.375rem + 1px);padding-bottom:calc(.375rem + 1px);margin-bottom:0;font-size:inherit;line-height:1.5}.col-form-label-lg{padding-top:calc(.5rem + 1px);padding-bottom:calc(.5rem + 1px);font-size:1.25rem;line-height:1.5}.col-form-label-sm{padding-top:calc(.25rem + 1px);padding-bottom:calc(.25rem + 1px);font-size:.875rem;line-height:1.5}.form-control-plaintext{display:block;width:100%;padding:.375rem 0;margin-bottom:0;font-size:1rem;line-height:1.5;color:#212529;background-color:transparent;border:solid transparent;border-width:1px 0}.form-control-plaintext.form-control-lg,.form-control-plaintext.form-control-sm{padding-right:0;padding-left:0}.form-control-sm{height:calc(1.5em + .5rem + 2px);padding:.25rem .5rem;font-size:.875rem;line-height:1.5;border-radius:.2rem}.form-control-lg{height:calc(1.5em + 1rem + 2px);padding:.5rem 1rem;font-size:1.25rem;line-height:1.5;border-radius:.3rem}select.form-control[multiple],select.form-control[size]{height:auto}textarea.form-control{height:auto}.form-group{margin-bottom:1rem}.form-text{display:block;margin-top:.25rem}.form-row{display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;margin-right:-5px;margin-left:-5px}.form-row>.col,.form-row>[class*=col-]{padding-right:5px;padding-left:5px}.form-check{position:relative;display:block;padding-left:1.25rem}.form-check-input{position:absolute;margin-top:.3rem;margin-left:-1.25rem}.form-check-input:disabled~.form-check-label,.form-check-input[disabled]~.form-check-label{color:#6c757d}.form-check-label{margin-bottom:0}.form-check-inline{display:-ms-inline-flexbox;display:inline-flex;-ms-flex-align:center;align-items:center;padding-left:0;margin-right:.75rem}.form-check-inline .form-check-input{position:static;margin-top:0;margin-right:.3125rem;margin-left:0}.valid-feedback{display:none;width:100%;margin-top:.25rem;font-size:80%;color:#28a745}.valid-tooltip{position:absolute;top:100%;z-index:5;display:none;max-width:100%;padding:.25rem .5rem;margin-top:.1rem;font-size:.875rem;line-height:1.5;color:#fff;background-color:rgba(40,167,69,.9);border-radius:.25rem}.is-valid~.valid-feedback,.is-valid~.valid-tooltip,.was-validated :valid~.valid-feedback,.was-validated :valid~.valid-tooltip{display:block}.form-control.is-valid,.was-validated .form-control:valid{border-color:#28a745;padding-right:calc(1.5em + .75rem);background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='8' height='8' viewBox='0 0 8 8'%3e%3cpath fill='%2328a745' d='M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3e%3c/svg%3e");background-repeat:no-repeat;background-position:right calc(.375em + .1875rem) center;background-size:calc(.75em + .375rem) calc(.75em + .375rem)}.form-control.is-valid:focus,.was-validated .form-control:valid:focus{border-color:#28a745;box-shadow:0 0 0 .2rem rgba(40,167,69,.25)}.was-validated textarea.form-control:valid,textarea.form-control.is-valid{padding-right:calc(1.5em + .75rem);background-position:top calc(.375em + .1875rem) right calc(.375em + .1875rem)}.custom-select.is-valid,.was-validated .custom-select:valid{border-color:#28a745;padding-right:calc(.75em + 2.3125rem);background:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='4' height='5' viewBox='0 0 4 5'%3e%3cpath fill='%23343a40' d='M2 0L0 2h4zm0 5L0 3h4z'/%3e%3c/svg%3e") no-repeat right .75rem center/8px 10px,url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='8' height='8' viewBox='0 0 8 8'%3e%3cpath fill='%2328a745' d='M2.3 6.73L.6 4.53c-.4-1.04.46-1.4 1.1-.8l1.1 1.4 3.4-3.8c.6-.63 1.6-.27 1.2.7l-4 4.6c-.43.5-.8.4-1.1.1z'/%3e%3c/svg%3e") #fff no-repeat center right 1.75rem/calc(.75em + .375rem) calc(.75em + .375rem)}.custom-select.is-valid:focus,.was-validated .custom-select:valid:focus{border-color:#28a745;box-shadow:0 0 0 .2rem rgba(40,167,69,.25)}.form-check-input.is-valid~.form-check-label,.was-validated .form-check-input:valid~.form-check-label{color:#28a745}.form-check-input.is-valid~.valid-feedback,.form-check-input.is-valid~.valid-tooltip,.was-validated .form-check-input:valid~.valid-feedback,.was-validated .form-check-input:valid~.valid-tooltip{display:block}.custom-control-input.is-valid~.custom-control-label,.was-validated .custom-control-input:valid~.custom-control-label{color:#28a745}.custom-control-input.is-valid~.custom-control-label::before,.was-validated .custom-control-input:valid~.custom-control-label::before{border-color:#28a745}.custom-control-input.is-valid:checked~.custom-control-label::before,.was-validated .custom-control-input:valid:checked~.custom-control-label::before{border-color:#34ce57;background-color:#34ce57}.custom-control-input.is-valid:focus~.custom-control-label::before,.was-validated .custom-control-input:valid:focus~.custom-control-label::before{box-shadow:0 0 0 .2rem rgba(40,167,69,.25)}.custom-control-input.is-valid:focus:not(:checked)~.custom-control-label::before,.was-validated .custom-control-input:valid:focus:not(:checked)~.custom-control-label::before{border-color:#28a745}.custom-file-input.is-valid~.custom-file-label,.was-validated .custom-file-input:valid~.custom-file-label{border-color:#28a745}.custom-file-input.is-valid:focus~.custom-file-label,.was-validated .custom-file-input:valid:focus~.custom-file-label{border-color:#28a745;box-shadow:0 0 0 .2rem rgba(40,167,69,.25)}.invalid-feedback{display:none;width:100%;margin-top:.25rem;font-size:80%;color:#dc3545}.invalid-tooltip{position:absolute;top:100%;z-index:5;display:none;max-width:100%;padding:.25rem .5rem;margin-top:.1rem;font-size:.875rem;line-height:1.5;color:#fff;background-color:rgba(220,53,69,.9);border-radius:.25rem}.is-invalid~.invalid-feedback,.is-invalid~.invalid-tooltip,.was-validated :invalid~.invalid-feedback,.was-validated :invalid~.invalid-tooltip{display:block}.form-control.is-invalid,.was-validated .form-control:invalid{border-color:#dc3545;padding-right:calc(1.5em + .75rem);background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='none' stroke='%23dc3545' viewBox='0 0 12 12'%3e%3ccircle cx='6' cy='6' r='4.5'/%3e%3cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3e%3ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3e%3c/svg%3e");background-repeat:no-repeat;background-position:right calc(.375em + .1875rem) center;background-size:calc(.75em + .375rem) calc(.75em + .375rem)}.form-control.is-invalid:focus,.was-validated .form-control:invalid:focus{border-color:#dc3545;box-shadow:0 0 0 .2rem rgba(220,53,69,.25)}.was-validated textarea.form-control:invalid,textarea.form-control.is-invalid{padding-right:calc(1.5em + .75rem);background-position:top calc(.375em + .1875rem) right calc(.375em + .1875rem)}.custom-select.is-invalid,.was-validated .custom-select:invalid{border-color:#dc3545;padding-right:calc(.75em + 2.3125rem);background:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='4' height='5' viewBox='0 0 4 5'%3e%3cpath fill='%23343a40' d='M2 0L0 2h4zm0 5L0 3h4z'/%3e%3c/svg%3e") no-repeat right .75rem center/8px 10px,url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' fill='none' stroke='%23dc3545' viewBox='0 0 12 12'%3e%3ccircle cx='6' cy='6' r='4.5'/%3e%3cpath stroke-linejoin='round' d='M5.8 3.6h.4L6 6.5z'/%3e%3ccircle cx='6' cy='8.2' r='.6' fill='%23dc3545' stroke='none'/%3e%3c/svg%3e") #fff no-repeat center right 1.75rem/calc(.75em + .375rem) calc(.75em + .375rem)}.custom-select.is-invalid:focus,.was-validated .custom-select:invalid:focus{border-color:#dc3545;box-shadow:0 0 0 .2rem rgba(220,53,69,.25)}.form-check-input.is-invalid~.form-check-label,.was-validated .form-check-input:invalid~.form-check-label{color:#dc3545}.form-check-input.is-invalid~.invalid-feedback,.form-check-input.is-invalid~.invalid-tooltip,.was-validated .form-check-input:invalid~.invalid-feedback,.was-validated .form-check-input:invalid~.invalid-tooltip{display:block}.custom-control-input.is-invalid~.custom-control-label,.was-validated .custom-control-input:invalid~.custom-control-label{color:#dc3545}.custom-control-input.is-invalid~.custom-control-label::before,.was-validated .custom-control-input:invalid~.custom-control-label::before{border-color:#dc3545}.custom-control-input.is-invalid:checked~.custom-control-label::before,.was-validated .custom-control-input:invalid:checked~.custom-control-label::before{border-color:#e4606d;background-color:#e4606d}.custom-control-input.is-invalid:focus~.custom-control-label::before,.was-validated .custom-control-input:invalid:focus~.custom-control-label::before{box-shadow:0 0 0 .2rem rgba(220,53,69,.25)}.custom-control-input.is-invalid:focus:not(:checked)~.custom-control-label::before,.was-validated .custom-control-input:invalid:focus:not(:checked)~.custom-control-label::before{border-color:#dc3545}.custom-file-input.is-invalid~.custom-file-label,.was-validated .custom-file-input:invalid~.custom-file-label{border-color:#dc3545}.custom-file-input.is-invalid:focus~.custom-file-label,.was-validated .custom-file-input:invalid:focus~.custom-file-label{border-color:#dc3545;box-shadow:0 0 0 .2rem rgba(220,53,69,.25)}.form-inline{display:-ms-flexbox;display:flex;-ms-flex-flow:row wrap;flex-flow:row wrap;-ms-flex-align:center;align-items:center}.form-inline .form-check{width:100%}@media (min-width:576px){.form-inline label{display:-ms-flexbox;display:flex;-ms-flex-align:center;align-items:center;-ms-flex-pack:center;justify-content:center;margin-bottom:0}.form-inline .form-group{display:-ms-flexbox;display:flex;-ms-flex:0 0 auto;flex:0 0 auto;-ms-flex-flow:row wrap;flex-flow:row wrap;-ms-flex-align:center;align-items:center;margin-bottom:0}.form-inline .form-control{display:inline-block;width:auto;vertical-align:middle}.form-inline .form-control-plaintext{display:inline-block}.form-inline .custom-select,.form-inline .input-group{width:auto}.form-inline .form-check{display:-ms-flexbox;display:flex;-ms-flex-align:center;align-items:center;-ms-flex-pack:center;justify-content:center;width:auto;padding-left:0}.form-inline .form-check-input{position:relative;-ms-flex-negative:0;flex-shrink:0;margin-top:0;margin-right:.25rem;margin-left:0}.form-inline .custom-control{-ms-flex-align:center;align-items:center;-ms-flex-pack:center;justify-content:center}.form-inline .custom-control-label{margin-bottom:0}}.btn{display:inline-block;font-weight:400;color:#212529;text-align:center;vertical-align:middle;cursor:pointer;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;background-color:transparent;border:1px solid transparent;padding:.375rem .75rem;font-size:1rem;line-height:1.5;border-radius:.25rem;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.btn{transition:none}}.btn:hover{color:#212529;text-decoration:none}.btn.focus,.btn:focus{outline:0;box-shadow:0 0 0 .2rem rgba(0,123,255,.25)}.btn.disabled,.btn:disabled{opacity:.65}a.btn.disabled,fieldset:disabled a.btn{pointer-events:none}.btn-primary{color:#fff;background-color:#007bff;border-color:#007bff}.btn-primary:hover{color:#fff;background-color:#0069d9;border-color:#0062cc}.btn-primary.focus,.btn-primary:focus{color:#fff;background-color:#0069d9;border-color:#0062cc;box-shadow:0 0 0 .2rem rgba(38,143,255,.5)}.btn-primary.disabled,.btn-primary:disabled{color:#fff;background-color:#007bff;border-color:#007bff}.btn-primary:not(:disabled):not(.disabled).active,.btn-primary:not(:disabled):not(.disabled):active,.show>.btn-primary.dropdown-toggle{color:#fff;background-color:#0062cc;border-color:#005cbf}.btn-primary:not(:disabled):not(.disabled).active:focus,.btn-primary:not(:disabled):not(.disabled):active:focus,.show>.btn-primary.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(38,143,255,.5)}.btn-secondary{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-secondary:hover{color:#fff;background-color:#5a6268;border-color:#545b62}.btn-secondary.focus,.btn-secondary:focus{color:#fff;background-color:#5a6268;border-color:#545b62;box-shadow:0 0 0 .2rem rgba(130,138,145,.5)}.btn-secondary.disabled,.btn-secondary:disabled{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-secondary:not(:disabled):not(.disabled).active,.btn-secondary:not(:disabled):not(.disabled):active,.show>.btn-secondary.dropdown-toggle{color:#fff;background-color:#545b62;border-color:#4e555b}.btn-secondary:not(:disabled):not(.disabled).active:focus,.btn-secondary:not(:disabled):not(.disabled):active:focus,.show>.btn-secondary.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(130,138,145,.5)}.btn-success{color:#fff;background-color:#28a745;border-color:#28a745}.btn-success:hover{color:#fff;background-color:#218838;border-color:#1e7e34}.btn-success.focus,.btn-success:focus{color:#fff;background-color:#218838;border-color:#1e7e34;box-shadow:0 0 0 .2rem rgba(72,180,97,.5)}.btn-success.disabled,.btn-success:disabled{color:#fff;background-color:#28a745;border-color:#28a745}.btn-success:not(:disabled):not(.disabled).active,.btn-success:not(:disabled):not(.disabled):active,.show>.btn-success.dropdown-toggle{color:#fff;background-color:#1e7e34;border-color:#1c7430}.btn-success:not(:disabled):not(.disabled).active:focus,.btn-success:not(:disabled):not(.disabled):active:focus,.show>.btn-success.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(72,180,97,.5)}.btn-info{color:#fff;background-color:#17a2b8;border-color:#17a2b8}.btn-info:hover{color:#fff;background-color:#138496;border-color:#117a8b}.btn-info.focus,.btn-info:focus{color:#fff;background-color:#138496;border-color:#117a8b;box-shadow:0 0 0 .2rem rgba(58,176,195,.5)}.btn-info.disabled,.btn-info:disabled{color:#fff;background-color:#17a2b8;border-color:#17a2b8}.btn-info:not(:disabled):not(.disabled).active,.btn-info:not(:disabled):not(.disabled):active,.show>.btn-info.dropdown-toggle{color:#fff;background-color:#117a8b;border-color:#10707f}.btn-info:not(:disabled):not(.disabled).active:focus,.btn-info:not(:disabled):not(.disabled):active:focus,.show>.btn-info.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(58,176,195,.5)}.btn-warning{color:#212529;background-color:#ffc107;border-color:#ffc107}.btn-warning:hover{color:#212529;background-color:#e0a800;border-color:#d39e00}.btn-warning.focus,.btn-warning:focus{color:#212529;background-color:#e0a800;border-color:#d39e00;box-shadow:0 0 0 .2rem rgba(222,170,12,.5)}.btn-warning.disabled,.btn-warning:disabled{color:#212529;background-color:#ffc107;border-color:#ffc107}.btn-warning:not(:disabled):not(.disabled).active,.btn-warning:not(:disabled):not(.disabled):active,.show>.btn-warning.dropdown-toggle{color:#212529;background-color:#d39e00;border-color:#c69500}.btn-warning:not(:disabled):not(.disabled).active:focus,.btn-warning:not(:disabled):not(.disabled):active:focus,.show>.btn-warning.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(222,170,12,.5)}.btn-danger{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-danger:hover{color:#fff;background-color:#c82333;border-color:#bd2130}.btn-danger.focus,.btn-danger:focus{color:#fff;background-color:#c82333;border-color:#bd2130;box-shadow:0 0 0 .2rem rgba(225,83,97,.5)}.btn-danger.disabled,.btn-danger:disabled{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-danger:not(:disabled):not(.disabled).active,.btn-danger:not(:disabled):not(.disabled):active,.show>.btn-danger.dropdown-toggle{color:#fff;background-color:#bd2130;border-color:#b21f2d}.btn-danger:not(:disabled):not(.disabled).active:focus,.btn-danger:not(:disabled):not(.disabled):active:focus,.show>.btn-danger.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(225,83,97,.5)}.btn-light{color:#212529;background-color:#f8f9fa;border-color:#f8f9fa}.btn-light:hover{color:#212529;background-color:#e2e6ea;border-color:#dae0e5}.btn-light.focus,.btn-light:focus{color:#212529;background-color:#e2e6ea;border-color:#dae0e5;box-shadow:0 0 0 .2rem rgba(216,217,219,.5)}.btn-light.disabled,.btn-light:disabled{color:#212529;background-color:#f8f9fa;border-color:#f8f9fa}.btn-light:not(:disabled):not(.disabled).active,.btn-light:not(:disabled):not(.disabled):active,.show>.btn-light.dropdown-toggle{color:#212529;background-color:#dae0e5;border-color:#d3d9df}.btn-light:not(:disabled):not(.disabled).active:focus,.btn-light:not(:disabled):not(.disabled):active:focus,.show>.btn-light.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(216,217,219,.5)}.btn-dark{color:#fff;background-color:#343a40;border-color:#343a40}.btn-dark:hover{color:#fff;background-color:#23272b;border-color:#1d2124}.btn-dark.focus,.btn-dark:focus{color:#fff;background-color:#23272b;border-color:#1d2124;box-shadow:0 0 0 .2rem rgba(82,88,93,.5)}.btn-dark.disabled,.btn-dark:disabled{color:#fff;background-color:#343a40;border-color:#343a40}.btn-dark:not(:disabled):not(.disabled).active,.btn-dark:not(:disabled):not(.disabled):active,.show>.btn-dark.dropdown-toggle{color:#fff;background-color:#1d2124;border-color:#171a1d}.btn-dark:not(:disabled):not(.disabled).active:focus,.btn-dark:not(:disabled):not(.disabled):active:focus,.show>.btn-dark.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(82,88,93,.5)}.btn-outline-primary{color:#007bff;border-color:#007bff}.btn-outline-primary:hover{color:#fff;background-color:#007bff;border-color:#007bff}.btn-outline-primary.focus,.btn-outline-primary:focus{box-shadow:0 0 0 .2rem rgba(0,123,255,.5)}.btn-outline-primary.disabled,.btn-outline-primary:disabled{color:#007bff;background-color:transparent}.btn-outline-primary:not(:disabled):not(.disabled).active,.btn-outline-primary:not(:disabled):not(.disabled):active,.show>.btn-outline-primary.dropdown-toggle{color:#fff;background-color:#007bff;border-color:#007bff}.btn-outline-primary:not(:disabled):not(.disabled).active:focus,.btn-outline-primary:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-primary.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(0,123,255,.5)}.btn-outline-secondary{color:#6c757d;border-color:#6c757d}.btn-outline-secondary:hover{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-outline-secondary.focus,.btn-outline-secondary:focus{box-shadow:0 0 0 .2rem rgba(108,117,125,.5)}.btn-outline-secondary.disabled,.btn-outline-secondary:disabled{color:#6c757d;background-color:transparent}.btn-outline-secondary:not(:disabled):not(.disabled).active,.btn-outline-secondary:not(:disabled):not(.disabled):active,.show>.btn-outline-secondary.dropdown-toggle{color:#fff;background-color:#6c757d;border-color:#6c757d}.btn-outline-secondary:not(:disabled):not(.disabled).active:focus,.btn-outline-secondary:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-secondary.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(108,117,125,.5)}.btn-outline-success{color:#28a745;border-color:#28a745}.btn-outline-success:hover{color:#fff;background-color:#28a745;border-color:#28a745}.btn-outline-success.focus,.btn-outline-success:focus{box-shadow:0 0 0 .2rem rgba(40,167,69,.5)}.btn-outline-success.disabled,.btn-outline-success:disabled{color:#28a745;background-color:transparent}.btn-outline-success:not(:disabled):not(.disabled).active,.btn-outline-success:not(:disabled):not(.disabled):active,.show>.btn-outline-success.dropdown-toggle{color:#fff;background-color:#28a745;border-color:#28a745}.btn-outline-success:not(:disabled):not(.disabled).active:focus,.btn-outline-success:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-success.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(40,167,69,.5)}.btn-outline-info{color:#17a2b8;border-color:#17a2b8}.btn-outline-info:hover{color:#fff;background-color:#17a2b8;border-color:#17a2b8}.btn-outline-info.focus,.btn-outline-info:focus{box-shadow:0 0 0 .2rem rgba(23,162,184,.5)}.btn-outline-info.disabled,.btn-outline-info:disabled{color:#17a2b8;background-color:transparent}.btn-outline-info:not(:disabled):not(.disabled).active,.btn-outline-info:not(:disabled):not(.disabled):active,.show>.btn-outline-info.dropdown-toggle{color:#fff;background-color:#17a2b8;border-color:#17a2b8}.btn-outline-info:not(:disabled):not(.disabled).active:focus,.btn-outline-info:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-info.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(23,162,184,.5)}.btn-outline-warning{color:#ffc107;border-color:#ffc107}.btn-outline-warning:hover{color:#212529;background-color:#ffc107;border-color:#ffc107}.btn-outline-warning.focus,.btn-outline-warning:focus{box-shadow:0 0 0 .2rem rgba(255,193,7,.5)}.btn-outline-warning.disabled,.btn-outline-warning:disabled{color:#ffc107;background-color:transparent}.btn-outline-warning:not(:disabled):not(.disabled).active,.btn-outline-warning:not(:disabled):not(.disabled):active,.show>.btn-outline-warning.dropdown-toggle{color:#212529;background-color:#ffc107;border-color:#ffc107}.btn-outline-warning:not(:disabled):not(.disabled).active:focus,.btn-outline-warning:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-warning.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(255,193,7,.5)}.btn-outline-danger{color:#dc3545;border-color:#dc3545}.btn-outline-danger:hover{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-outline-danger.focus,.btn-outline-danger:focus{box-shadow:0 0 0 .2rem rgba(220,53,69,.5)}.btn-outline-danger.disabled,.btn-outline-danger:disabled{color:#dc3545;background-color:transparent}.btn-outline-danger:not(:disabled):not(.disabled).active,.btn-outline-danger:not(:disabled):not(.disabled):active,.show>.btn-outline-danger.dropdown-toggle{color:#fff;background-color:#dc3545;border-color:#dc3545}.btn-outline-danger:not(:disabled):not(.disabled).active:focus,.btn-outline-danger:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-danger.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(220,53,69,.5)}.btn-outline-light{color:#f8f9fa;border-color:#f8f9fa}.btn-outline-light:hover{color:#212529;background-color:#f8f9fa;border-color:#f8f9fa}.btn-outline-light.focus,.btn-outline-light:focus{box-shadow:0 0 0 .2rem rgba(248,249,250,.5)}.btn-outline-light.disabled,.btn-outline-light:disabled{color:#f8f9fa;background-color:transparent}.btn-outline-light:not(:disabled):not(.disabled).active,.btn-outline-light:not(:disabled):not(.disabled):active,.show>.btn-outline-light.dropdown-toggle{color:#212529;background-color:#f8f9fa;border-color:#f8f9fa}.btn-outline-light:not(:disabled):not(.disabled).active:focus,.btn-outline-light:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-light.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(248,249,250,.5)}.btn-outline-dark{color:#343a40;border-color:#343a40}.btn-outline-dark:hover{color:#fff;background-color:#343a40;border-color:#343a40}.btn-outline-dark.focus,.btn-outline-dark:focus{box-shadow:0 0 0 .2rem rgba(52,58,64,.5)}.btn-outline-dark.disabled,.btn-outline-dark:disabled{color:#343a40;background-color:transparent}.btn-outline-dark:not(:disabled):not(.disabled).active,.btn-outline-dark:not(:disabled):not(.disabled):active,.show>.btn-outline-dark.dropdown-toggle{color:#fff;background-color:#343a40;border-color:#343a40}.btn-outline-dark:not(:disabled):not(.disabled).active:focus,.btn-outline-dark:not(:disabled):not(.disabled):active:focus,.show>.btn-outline-dark.dropdown-toggle:focus{box-shadow:0 0 0 .2rem rgba(52,58,64,.5)}.btn-link{font-weight:400;color:#007bff;text-decoration:none}.btn-link:hover{color:#0056b3;text-decoration:underline}.btn-link.focus,.btn-link:focus{text-decoration:underline;box-shadow:none}.btn-link.disabled,.btn-link:disabled{color:#6c757d;pointer-events:none}.btn-group-lg>.btn,.btn-lg{padding:.5rem 1rem;font-size:1.25rem;line-height:1.5;border-radius:.3rem}.btn-group-sm>.btn,.btn-sm{padding:.25rem .5rem;font-size:.875rem;line-height:1.5;border-radius:.2rem}.btn-block{display:block;width:100%}.btn-block+.btn-block{margin-top:.5rem}input[type=button].btn-block,input[type=reset].btn-block,input[type=submit].btn-block{width:100%}.fade{transition:opacity .15s linear}@media (prefers-reduced-motion:reduce){.fade{transition:none}}.fade:not(.show){opacity:0}.collapse:not(.show){display:none}.collapsing{position:relative;height:0;overflow:hidden;transition:height .35s ease}@media (prefers-reduced-motion:reduce){.collapsing{transition:none}}.dropdown,.dropleft,.dropright,.dropup{position:relative}.dropdown-toggle{white-space:nowrap}.dropdown-toggle::after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:"";border-top:.3em solid;border-right:.3em solid transparent;border-bottom:0;border-left:.3em solid transparent}.dropdown-toggle:empty::after{margin-left:0}.dropdown-menu{position:absolute;top:100%;left:0;z-index:1000;display:none;float:left;min-width:10rem;padding:.5rem 0;margin:.125rem 0 0;font-size:1rem;color:#212529;text-align:left;list-style:none;background-color:#fff;background-clip:padding-box;border:1px solid rgba(0,0,0,.15);border-radius:.25rem}.dropdown-menu-left{right:auto;left:0}.dropdown-menu-right{right:0;left:auto}@media (min-width:576px){.dropdown-menu-sm-left{right:auto;left:0}.dropdown-menu-sm-right{right:0;left:auto}}@media (min-width:768px){.dropdown-menu-md-left{right:auto;left:0}.dropdown-menu-md-right{right:0;left:auto}}@media (min-width:992px){.dropdown-menu-lg-left{right:auto;left:0}.dropdown-menu-lg-right{right:0;left:auto}}@media (min-width:1200px){.dropdown-menu-xl-left{right:auto;left:0}.dropdown-menu-xl-right{right:0;left:auto}}.dropup .dropdown-menu{top:auto;bottom:100%;margin-top:0;margin-bottom:.125rem}.dropup .dropdown-toggle::after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:"";border-top:0;border-right:.3em solid transparent;border-bottom:.3em solid;border-left:.3em solid transparent}.dropup .dropdown-toggle:empty::after{margin-left:0}.dropright .dropdown-menu{top:0;right:auto;left:100%;margin-top:0;margin-left:.125rem}.dropright .dropdown-toggle::after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:"";border-top:.3em solid transparent;border-right:0;border-bottom:.3em solid transparent;border-left:.3em solid}.dropright .dropdown-toggle:empty::after{margin-left:0}.dropright .dropdown-toggle::after{vertical-align:0}.dropleft .dropdown-menu{top:0;right:100%;left:auto;margin-top:0;margin-right:.125rem}.dropleft .dropdown-toggle::after{display:inline-block;margin-left:.255em;vertical-align:.255em;content:""}.dropleft .dropdown-toggle::after{display:none}.dropleft .dropdown-toggle::before{display:inline-block;margin-right:.255em;vertical-align:.255em;content:"";border-top:.3em solid transparent;border-right:.3em solid;border-bottom:.3em solid transparent}.dropleft .dropdown-toggle:empty::after{margin-left:0}.dropleft .dropdown-toggle::before{vertical-align:0}.dropdown-menu[x-placement^=bottom],.dropdown-menu[x-placement^=left],.dropdown-menu[x-placement^=right],.dropdown-menu[x-placement^=top]{right:auto;bottom:auto}.dropdown-divider{height:0;margin:.5rem 0;overflow:hidden;border-top:1px solid #e9ecef}.dropdown-item{display:block;width:100%;padding:.25rem 1.5rem;clear:both;font-weight:400;color:#212529;text-align:inherit;white-space:nowrap;background-color:transparent;border:0}.dropdown-item:focus,.dropdown-item:hover{color:#16181b;text-decoration:none;background-color:#f8f9fa}.dropdown-item.active,.dropdown-item:active{color:#fff;text-decoration:none;background-color:#007bff}.dropdown-item.disabled,.dropdown-item:disabled{color:#6c757d;pointer-events:none;background-color:transparent}.dropdown-menu.show{display:block}.dropdown-header{display:block;padding:.5rem 1.5rem;margin-bottom:0;font-size:.875rem;color:#6c757d;white-space:nowrap}.dropdown-item-text{display:block;padding:.25rem 1.5rem;color:#212529}.btn-group,.btn-group-vertical{position:relative;display:-ms-inline-flexbox;display:inline-flex;vertical-align:middle}.btn-group-vertical>.btn,.btn-group>.btn{position:relative;-ms-flex:1 1 auto;flex:1 1 auto}.btn-group-vertical>.btn:hover,.btn-group>.btn:hover{z-index:1}.btn-group-vertical>.btn.active,.btn-group-vertical>.btn:active,.btn-group-vertical>.btn:focus,.btn-group>.btn.active,.btn-group>.btn:active,.btn-group>.btn:focus{z-index:1}.btn-toolbar{display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;-ms-flex-pack:start;justify-content:flex-start}.btn-toolbar .input-group{width:auto}.btn-group>.btn-group:not(:first-child),.btn-group>.btn:not(:first-child){margin-left:-1px}.btn-group>.btn-group:not(:last-child)>.btn,.btn-group>.btn:not(:last-child):not(.dropdown-toggle){border-top-right-radius:0;border-bottom-right-radius:0}.btn-group>.btn-group:not(:first-child)>.btn,.btn-group>.btn:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.dropdown-toggle-split{padding-right:.5625rem;padding-left:.5625rem}.dropdown-toggle-split::after,.dropright .dropdown-toggle-split::after,.dropup .dropdown-toggle-split::after{margin-left:0}.dropleft .dropdown-toggle-split::before{margin-right:0}.btn-group-sm>.btn+.dropdown-toggle-split,.btn-sm+.dropdown-toggle-split{padding-right:.375rem;padding-left:.375rem}.btn-group-lg>.btn+.dropdown-toggle-split,.btn-lg+.dropdown-toggle-split{padding-right:.75rem;padding-left:.75rem}.btn-group-vertical{-ms-flex-direction:column;flex-direction:column;-ms-flex-align:start;align-items:flex-start;-ms-flex-pack:center;justify-content:center}.btn-group-vertical>.btn,.btn-group-vertical>.btn-group{width:100%}.btn-group-vertical>.btn-group:not(:first-child),.btn-group-vertical>.btn:not(:first-child){margin-top:-1px}.btn-group-vertical>.btn-group:not(:last-child)>.btn,.btn-group-vertical>.btn:not(:last-child):not(.dropdown-toggle){border-bottom-right-radius:0;border-bottom-left-radius:0}.btn-group-vertical>.btn-group:not(:first-child)>.btn,.btn-group-vertical>.btn:not(:first-child){border-top-left-radius:0;border-top-right-radius:0}.btn-group-toggle>.btn,.btn-group-toggle>.btn-group>.btn{margin-bottom:0}.btn-group-toggle>.btn input[type=checkbox],.btn-group-toggle>.btn input[type=radio],.btn-group-toggle>.btn-group>.btn input[type=checkbox],.btn-group-toggle>.btn-group>.btn input[type=radio]{position:absolute;clip:rect(0,0,0,0);pointer-events:none}.input-group{position:relative;display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;-ms-flex-align:stretch;align-items:stretch;width:100%}.input-group>.custom-file,.input-group>.custom-select,.input-group>.form-control,.input-group>.form-control-plaintext{position:relative;-ms-flex:1 1 0%;flex:1 1 0%;min-width:0;margin-bottom:0}.input-group>.custom-file+.custom-file,.input-group>.custom-file+.custom-select,.input-group>.custom-file+.form-control,.input-group>.custom-select+.custom-file,.input-group>.custom-select+.custom-select,.input-group>.custom-select+.form-control,.input-group>.form-control+.custom-file,.input-group>.form-control+.custom-select,.input-group>.form-control+.form-control,.input-group>.form-control-plaintext+.custom-file,.input-group>.form-control-plaintext+.custom-select,.input-group>.form-control-plaintext+.form-control{margin-left:-1px}.input-group>.custom-file .custom-file-input:focus~.custom-file-label,.input-group>.custom-select:focus,.input-group>.form-control:focus{z-index:3}.input-group>.custom-file .custom-file-input:focus{z-index:4}.input-group>.custom-select:not(:last-child),.input-group>.form-control:not(:last-child){border-top-right-radius:0;border-bottom-right-radius:0}.input-group>.custom-select:not(:first-child),.input-group>.form-control:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.input-group>.custom-file{display:-ms-flexbox;display:flex;-ms-flex-align:center;align-items:center}.input-group>.custom-file:not(:last-child) .custom-file-label,.input-group>.custom-file:not(:last-child) .custom-file-label::after{border-top-right-radius:0;border-bottom-right-radius:0}.input-group>.custom-file:not(:first-child) .custom-file-label{border-top-left-radius:0;border-bottom-left-radius:0}.input-group-append,.input-group-prepend{display:-ms-flexbox;display:flex}.input-group-append .btn,.input-group-prepend .btn{position:relative;z-index:2}.input-group-append .btn:focus,.input-group-prepend .btn:focus{z-index:3}.input-group-append .btn+.btn,.input-group-append .btn+.input-group-text,.input-group-append .input-group-text+.btn,.input-group-append .input-group-text+.input-group-text,.input-group-prepend .btn+.btn,.input-group-prepend .btn+.input-group-text,.input-group-prepend .input-group-text+.btn,.input-group-prepend .input-group-text+.input-group-text{margin-left:-1px}.input-group-prepend{margin-right:-1px}.input-group-append{margin-left:-1px}.input-group-text{display:-ms-flexbox;display:flex;-ms-flex-align:center;align-items:center;padding:.375rem .75rem;margin-bottom:0;font-size:1rem;font-weight:400;line-height:1.5;color:#495057;text-align:center;white-space:nowrap;background-color:#e9ecef;border:1px solid #ced4da;border-radius:.25rem}.input-group-text input[type=checkbox],.input-group-text input[type=radio]{margin-top:0}.input-group-lg>.custom-select,.input-group-lg>.form-control:not(textarea){height:calc(1.5em + 1rem + 2px)}.input-group-lg>.custom-select,.input-group-lg>.form-control,.input-group-lg>.input-group-append>.btn,.input-group-lg>.input-group-append>.input-group-text,.input-group-lg>.input-group-prepend>.btn,.input-group-lg>.input-group-prepend>.input-group-text{padding:.5rem 1rem;font-size:1.25rem;line-height:1.5;border-radius:.3rem}.input-group-sm>.custom-select,.input-group-sm>.form-control:not(textarea){height:calc(1.5em + .5rem + 2px)}.input-group-sm>.custom-select,.input-group-sm>.form-control,.input-group-sm>.input-group-append>.btn,.input-group-sm>.input-group-append>.input-group-text,.input-group-sm>.input-group-prepend>.btn,.input-group-sm>.input-group-prepend>.input-group-text{padding:.25rem .5rem;font-size:.875rem;line-height:1.5;border-radius:.2rem}.input-group-lg>.custom-select,.input-group-sm>.custom-select{padding-right:1.75rem}.input-group>.input-group-append:last-child>.btn:not(:last-child):not(.dropdown-toggle),.input-group>.input-group-append:last-child>.input-group-text:not(:last-child),.input-group>.input-group-append:not(:last-child)>.btn,.input-group>.input-group-append:not(:last-child)>.input-group-text,.input-group>.input-group-prepend>.btn,.input-group>.input-group-prepend>.input-group-text{border-top-right-radius:0;border-bottom-right-radius:0}.input-group>.input-group-append>.btn,.input-group>.input-group-append>.input-group-text,.input-group>.input-group-prepend:first-child>.btn:not(:first-child),.input-group>.input-group-prepend:first-child>.input-group-text:not(:first-child),.input-group>.input-group-prepend:not(:first-child)>.btn,.input-group>.input-group-prepend:not(:first-child)>.input-group-text{border-top-left-radius:0;border-bottom-left-radius:0}.custom-control{position:relative;display:block;min-height:1.5rem;padding-left:1.5rem}.custom-control-inline{display:-ms-inline-flexbox;display:inline-flex;margin-right:1rem}.custom-control-input{position:absolute;left:0;z-index:-1;width:1rem;height:1.25rem;opacity:0}.custom-control-input:checked~.custom-control-label::before{color:#fff;border-color:#007bff;background-color:#007bff}.custom-control-input:focus~.custom-control-label::before{box-shadow:0 0 0 .2rem rgba(0,123,255,.25)}.custom-control-input:focus:not(:checked)~.custom-control-label::before{border-color:#80bdff}.custom-control-input:not(:disabled):active~.custom-control-label::before{color:#fff;background-color:#b3d7ff;border-color:#b3d7ff}.custom-control-input:disabled~.custom-control-label,.custom-control-input[disabled]~.custom-control-label{color:#6c757d}.custom-control-input:disabled~.custom-control-label::before,.custom-control-input[disabled]~.custom-control-label::before{background-color:#e9ecef}.custom-control-label{position:relative;margin-bottom:0;vertical-align:top}.custom-control-label::before{position:absolute;top:.25rem;left:-1.5rem;display:block;width:1rem;height:1rem;pointer-events:none;content:"";background-color:#fff;border:#adb5bd solid 1px}.custom-control-label::after{position:absolute;top:.25rem;left:-1.5rem;display:block;width:1rem;height:1rem;content:"";background:no-repeat 50%/50% 50%}.custom-checkbox .custom-control-label::before{border-radius:.25rem}.custom-checkbox .custom-control-input:checked~.custom-control-label::after{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='8' height='8' viewBox='0 0 8 8'%3e%3cpath fill='%23fff' d='M6.564.75l-3.59 3.612-1.538-1.55L0 4.26l2.974 2.99L8 2.193z'/%3e%3c/svg%3e")}.custom-checkbox .custom-control-input:indeterminate~.custom-control-label::before{border-color:#007bff;background-color:#007bff}.custom-checkbox .custom-control-input:indeterminate~.custom-control-label::after{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='4' height='4' viewBox='0 0 4 4'%3e%3cpath stroke='%23fff' d='M0 2h4'/%3e%3c/svg%3e")}.custom-checkbox .custom-control-input:disabled:checked~.custom-control-label::before{background-color:rgba(0,123,255,.5)}.custom-checkbox .custom-control-input:disabled:indeterminate~.custom-control-label::before{background-color:rgba(0,123,255,.5)}.custom-radio .custom-control-label::before{border-radius:50%}.custom-radio .custom-control-input:checked~.custom-control-label::after{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='-4 -4 8 8'%3e%3ccircle r='3' fill='%23fff'/%3e%3c/svg%3e")}.custom-radio .custom-control-input:disabled:checked~.custom-control-label::before{background-color:rgba(0,123,255,.5)}.custom-switch{padding-left:2.25rem}.custom-switch .custom-control-label::before{left:-2.25rem;width:1.75rem;pointer-events:all;border-radius:.5rem}.custom-switch .custom-control-label::after{top:calc(.25rem + 2px);left:calc(-2.25rem + 2px);width:calc(1rem - 4px);height:calc(1rem - 4px);background-color:#adb5bd;border-radius:.5rem;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out,-webkit-transform .15s ease-in-out;transition:transform .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:transform .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out,-webkit-transform .15s ease-in-out}@media (prefers-reduced-motion:reduce){.custom-switch .custom-control-label::after{transition:none}}.custom-switch .custom-control-input:checked~.custom-control-label::after{background-color:#fff;-webkit-transform:translateX(.75rem);transform:translateX(.75rem)}.custom-switch .custom-control-input:disabled:checked~.custom-control-label::before{background-color:rgba(0,123,255,.5)}.custom-select{display:inline-block;width:100%;height:calc(1.5em + .75rem + 2px);padding:.375rem 1.75rem .375rem .75rem;font-size:1rem;font-weight:400;line-height:1.5;color:#495057;vertical-align:middle;background:#fff url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='4' height='5' viewBox='0 0 4 5'%3e%3cpath fill='%23343a40' d='M2 0L0 2h4zm0 5L0 3h4z'/%3e%3c/svg%3e") no-repeat right .75rem center/8px 10px;border:1px solid #ced4da;border-radius:.25rem;-webkit-appearance:none;-moz-appearance:none;appearance:none}.custom-select:focus{border-color:#80bdff;outline:0;box-shadow:0 0 0 .2rem rgba(0,123,255,.25)}.custom-select:focus::-ms-value{color:#495057;background-color:#fff}.custom-select[multiple],.custom-select[size]:not([size="1"]){height:auto;padding-right:.75rem;background-image:none}.custom-select:disabled{color:#6c757d;background-color:#e9ecef}.custom-select::-ms-expand{display:none}.custom-select:-moz-focusring{color:transparent;text-shadow:0 0 0 #495057}.custom-select-sm{height:calc(1.5em + .5rem + 2px);padding-top:.25rem;padding-bottom:.25rem;padding-left:.5rem;font-size:.875rem}.custom-select-lg{height:calc(1.5em + 1rem + 2px);padding-top:.5rem;padding-bottom:.5rem;padding-left:1rem;font-size:1.25rem}.custom-file{position:relative;display:inline-block;width:100%;height:calc(1.5em + .75rem + 2px);margin-bottom:0}.custom-file-input{position:relative;z-index:2;width:100%;height:calc(1.5em + .75rem + 2px);margin:0;opacity:0}.custom-file-input:focus~.custom-file-label{border-color:#80bdff;box-shadow:0 0 0 .2rem rgba(0,123,255,.25)}.custom-file-input:disabled~.custom-file-label,.custom-file-input[disabled]~.custom-file-label{background-color:#e9ecef}.custom-file-input:lang(en)~.custom-file-label::after{content:"Browse"}.custom-file-input~.custom-file-label[data-browse]::after{content:attr(data-browse)}.custom-file-label{position:absolute;top:0;right:0;left:0;z-index:1;height:calc(1.5em + .75rem + 2px);padding:.375rem .75rem;font-weight:400;line-height:1.5;color:#495057;background-color:#fff;border:1px solid #ced4da;border-radius:.25rem}.custom-file-label::after{position:absolute;top:0;right:0;bottom:0;z-index:3;display:block;height:calc(1.5em + .75rem);padding:.375rem .75rem;line-height:1.5;color:#495057;content:"Browse";background-color:#e9ecef;border-left:inherit;border-radius:0 .25rem .25rem 0}.custom-range{width:100%;height:1.4rem;padding:0;background-color:transparent;-webkit-appearance:none;-moz-appearance:none;appearance:none}.custom-range:focus{outline:0}.custom-range:focus::-webkit-slider-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .2rem rgba(0,123,255,.25)}.custom-range:focus::-moz-range-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .2rem rgba(0,123,255,.25)}.custom-range:focus::-ms-thumb{box-shadow:0 0 0 1px #fff,0 0 0 .2rem rgba(0,123,255,.25)}.custom-range::-moz-focus-outer{border:0}.custom-range::-webkit-slider-thumb{width:1rem;height:1rem;margin-top:-.25rem;background-color:#007bff;border:0;border-radius:1rem;-webkit-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;-webkit-appearance:none;appearance:none}@media (prefers-reduced-motion:reduce){.custom-range::-webkit-slider-thumb{-webkit-transition:none;transition:none}}.custom-range::-webkit-slider-thumb:active{background-color:#b3d7ff}.custom-range::-webkit-slider-runnable-track{width:100%;height:.5rem;color:transparent;cursor:pointer;background-color:#dee2e6;border-color:transparent;border-radius:1rem}.custom-range::-moz-range-thumb{width:1rem;height:1rem;background-color:#007bff;border:0;border-radius:1rem;-moz-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;-moz-appearance:none;appearance:none}@media (prefers-reduced-motion:reduce){.custom-range::-moz-range-thumb{-moz-transition:none;transition:none}}.custom-range::-moz-range-thumb:active{background-color:#b3d7ff}.custom-range::-moz-range-track{width:100%;height:.5rem;color:transparent;cursor:pointer;background-color:#dee2e6;border-color:transparent;border-radius:1rem}.custom-range::-ms-thumb{width:1rem;height:1rem;margin-top:0;margin-right:.2rem;margin-left:.2rem;background-color:#007bff;border:0;border-radius:1rem;-ms-transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;appearance:none}@media (prefers-reduced-motion:reduce){.custom-range::-ms-thumb{-ms-transition:none;transition:none}}.custom-range::-ms-thumb:active{background-color:#b3d7ff}.custom-range::-ms-track{width:100%;height:.5rem;color:transparent;cursor:pointer;background-color:transparent;border-color:transparent;border-width:.5rem}.custom-range::-ms-fill-lower{background-color:#dee2e6;border-radius:1rem}.custom-range::-ms-fill-upper{margin-right:15px;background-color:#dee2e6;border-radius:1rem}.custom-range:disabled::-webkit-slider-thumb{background-color:#adb5bd}.custom-range:disabled::-webkit-slider-runnable-track{cursor:default}.custom-range:disabled::-moz-range-thumb{background-color:#adb5bd}.custom-range:disabled::-moz-range-track{cursor:default}.custom-range:disabled::-ms-thumb{background-color:#adb5bd}.custom-control-label::before,.custom-file-label,.custom-select{transition:background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.custom-control-label::before,.custom-file-label,.custom-select{transition:none}}.nav{display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;padding-left:0;margin-bottom:0;list-style:none}.nav-link{display:block;padding:.5rem 1rem}.nav-link:focus,.nav-link:hover{text-decoration:none}.nav-link.disabled{color:#6c757d;pointer-events:none;cursor:default}.nav-tabs{border-bottom:1px solid #dee2e6}.nav-tabs .nav-item{margin-bottom:-1px}.nav-tabs .nav-link{border:1px solid transparent;border-top-left-radius:.25rem;border-top-right-radius:.25rem}.nav-tabs .nav-link:focus,.nav-tabs .nav-link:hover{border-color:#e9ecef #e9ecef #dee2e6}.nav-tabs .nav-link.disabled{color:#6c757d;background-color:transparent;border-color:transparent}.nav-tabs .nav-item.show .nav-link,.nav-tabs .nav-link.active{color:#495057;background-color:#fff;border-color:#dee2e6 #dee2e6 #fff}.nav-tabs .dropdown-menu{margin-top:-1px;border-top-left-radius:0;border-top-right-radius:0}.nav-pills .nav-link{border-radius:.25rem}.nav-pills .nav-link.active,.nav-pills .show>.nav-link{color:#fff;background-color:#007bff}.nav-fill .nav-item{-ms-flex:1 1 auto;flex:1 1 auto;text-align:center}.nav-justified .nav-item{-ms-flex-preferred-size:0;flex-basis:0;-ms-flex-positive:1;flex-grow:1;text-align:center}.tab-content>.tab-pane{display:none}.tab-content>.active{display:block}.navbar{position:relative;display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;-ms-flex-align:center;align-items:center;-ms-flex-pack:justify;justify-content:space-between;padding:.5rem 1rem}.navbar .container,.navbar .container-fluid,.navbar .container-lg,.navbar .container-md,.navbar .container-sm,.navbar .container-xl{display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;-ms-flex-align:center;align-items:center;-ms-flex-pack:justify;justify-content:space-between}.navbar-brand{display:inline-block;padding-top:.3125rem;padding-bottom:.3125rem;margin-right:1rem;font-size:1.25rem;line-height:inherit;white-space:nowrap}.navbar-brand:focus,.navbar-brand:hover{text-decoration:none}.navbar-nav{display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;padding-left:0;margin-bottom:0;list-style:none}.navbar-nav .nav-link{padding-right:0;padding-left:0}.navbar-nav .dropdown-menu{position:static;float:none}.navbar-text{display:inline-block;padding-top:.5rem;padding-bottom:.5rem}.navbar-collapse{-ms-flex-preferred-size:100%;flex-basis:100%;-ms-flex-positive:1;flex-grow:1;-ms-flex-align:center;align-items:center}.navbar-toggler{padding:.25rem .75rem;font-size:1.25rem;line-height:1;background-color:transparent;border:1px solid transparent;border-radius:.25rem}.navbar-toggler:focus,.navbar-toggler:hover{text-decoration:none}.navbar-toggler-icon{display:inline-block;width:1.5em;height:1.5em;vertical-align:middle;content:"";background:no-repeat center center;background-size:100% 100%}@media (max-width:575.98px){.navbar-expand-sm>.container,.navbar-expand-sm>.container-fluid,.navbar-expand-sm>.container-lg,.navbar-expand-sm>.container-md,.navbar-expand-sm>.container-sm,.navbar-expand-sm>.container-xl{padding-right:0;padding-left:0}}@media (min-width:576px){.navbar-expand-sm{-ms-flex-flow:row nowrap;flex-flow:row nowrap;-ms-flex-pack:start;justify-content:flex-start}.navbar-expand-sm .navbar-nav{-ms-flex-direction:row;flex-direction:row}.navbar-expand-sm .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-sm .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand-sm>.container,.navbar-expand-sm>.container-fluid,.navbar-expand-sm>.container-lg,.navbar-expand-sm>.container-md,.navbar-expand-sm>.container-sm,.navbar-expand-sm>.container-xl{-ms-flex-wrap:nowrap;flex-wrap:nowrap}.navbar-expand-sm .navbar-collapse{display:-ms-flexbox!important;display:flex!important;-ms-flex-preferred-size:auto;flex-basis:auto}.navbar-expand-sm .navbar-toggler{display:none}}@media (max-width:767.98px){.navbar-expand-md>.container,.navbar-expand-md>.container-fluid,.navbar-expand-md>.container-lg,.navbar-expand-md>.container-md,.navbar-expand-md>.container-sm,.navbar-expand-md>.container-xl{padding-right:0;padding-left:0}}@media (min-width:768px){.navbar-expand-md{-ms-flex-flow:row nowrap;flex-flow:row nowrap;-ms-flex-pack:start;justify-content:flex-start}.navbar-expand-md .navbar-nav{-ms-flex-direction:row;flex-direction:row}.navbar-expand-md .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-md .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand-md>.container,.navbar-expand-md>.container-fluid,.navbar-expand-md>.container-lg,.navbar-expand-md>.container-md,.navbar-expand-md>.container-sm,.navbar-expand-md>.container-xl{-ms-flex-wrap:nowrap;flex-wrap:nowrap}.navbar-expand-md .navbar-collapse{display:-ms-flexbox!important;display:flex!important;-ms-flex-preferred-size:auto;flex-basis:auto}.navbar-expand-md .navbar-toggler{display:none}}@media (max-width:991.98px){.navbar-expand-lg>.container,.navbar-expand-lg>.container-fluid,.navbar-expand-lg>.container-lg,.navbar-expand-lg>.container-md,.navbar-expand-lg>.container-sm,.navbar-expand-lg>.container-xl{padding-right:0;padding-left:0}}@media (min-width:992px){.navbar-expand-lg{-ms-flex-flow:row nowrap;flex-flow:row nowrap;-ms-flex-pack:start;justify-content:flex-start}.navbar-expand-lg .navbar-nav{-ms-flex-direction:row;flex-direction:row}.navbar-expand-lg .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-lg .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand-lg>.container,.navbar-expand-lg>.container-fluid,.navbar-expand-lg>.container-lg,.navbar-expand-lg>.container-md,.navbar-expand-lg>.container-sm,.navbar-expand-lg>.container-xl{-ms-flex-wrap:nowrap;flex-wrap:nowrap}.navbar-expand-lg .navbar-collapse{display:-ms-flexbox!important;display:flex!important;-ms-flex-preferred-size:auto;flex-basis:auto}.navbar-expand-lg .navbar-toggler{display:none}}@media (max-width:1199.98px){.navbar-expand-xl>.container,.navbar-expand-xl>.container-fluid,.navbar-expand-xl>.container-lg,.navbar-expand-xl>.container-md,.navbar-expand-xl>.container-sm,.navbar-expand-xl>.container-xl{padding-right:0;padding-left:0}}@media (min-width:1200px){.navbar-expand-xl{-ms-flex-flow:row nowrap;flex-flow:row nowrap;-ms-flex-pack:start;justify-content:flex-start}.navbar-expand-xl .navbar-nav{-ms-flex-direction:row;flex-direction:row}.navbar-expand-xl .navbar-nav .dropdown-menu{position:absolute}.navbar-expand-xl .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand-xl>.container,.navbar-expand-xl>.container-fluid,.navbar-expand-xl>.container-lg,.navbar-expand-xl>.container-md,.navbar-expand-xl>.container-sm,.navbar-expand-xl>.container-xl{-ms-flex-wrap:nowrap;flex-wrap:nowrap}.navbar-expand-xl .navbar-collapse{display:-ms-flexbox!important;display:flex!important;-ms-flex-preferred-size:auto;flex-basis:auto}.navbar-expand-xl .navbar-toggler{display:none}}.navbar-expand{-ms-flex-flow:row nowrap;flex-flow:row nowrap;-ms-flex-pack:start;justify-content:flex-start}.navbar-expand>.container,.navbar-expand>.container-fluid,.navbar-expand>.container-lg,.navbar-expand>.container-md,.navbar-expand>.container-sm,.navbar-expand>.container-xl{padding-right:0;padding-left:0}.navbar-expand .navbar-nav{-ms-flex-direction:row;flex-direction:row}.navbar-expand .navbar-nav .dropdown-menu{position:absolute}.navbar-expand .navbar-nav .nav-link{padding-right:.5rem;padding-left:.5rem}.navbar-expand>.container,.navbar-expand>.container-fluid,.navbar-expand>.container-lg,.navbar-expand>.container-md,.navbar-expand>.container-sm,.navbar-expand>.container-xl{-ms-flex-wrap:nowrap;flex-wrap:nowrap}.navbar-expand .navbar-collapse{display:-ms-flexbox!important;display:flex!important;-ms-flex-preferred-size:auto;flex-basis:auto}.navbar-expand .navbar-toggler{display:none}.navbar-light .navbar-brand{color:rgba(0,0,0,.9)}.navbar-light .navbar-brand:focus,.navbar-light .navbar-brand:hover{color:rgba(0,0,0,.9)}.navbar-light .navbar-nav .nav-link{color:rgba(0,0,0,.5)}.navbar-light .navbar-nav .nav-link:focus,.navbar-light .navbar-nav .nav-link:hover{color:rgba(0,0,0,.7)}.navbar-light .navbar-nav .nav-link.disabled{color:rgba(0,0,0,.3)}.navbar-light .navbar-nav .active>.nav-link,.navbar-light .navbar-nav .nav-link.active,.navbar-light .navbar-nav .nav-link.show,.navbar-light .navbar-nav .show>.nav-link{color:rgba(0,0,0,.9)}.navbar-light .navbar-toggler{color:rgba(0,0,0,.5);border-color:rgba(0,0,0,.1)}.navbar-light .navbar-toggler-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='30' height='30' viewBox='0 0 30 30'%3e%3cpath stroke='rgba(0, 0, 0, 0.5)' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3e%3c/svg%3e")}.navbar-light .navbar-text{color:rgba(0,0,0,.5)}.navbar-light .navbar-text a{color:rgba(0,0,0,.9)}.navbar-light .navbar-text a:focus,.navbar-light .navbar-text a:hover{color:rgba(0,0,0,.9)}.navbar-dark .navbar-brand{color:#fff}.navbar-dark .navbar-brand:focus,.navbar-dark .navbar-brand:hover{color:#fff}.navbar-dark .navbar-nav .nav-link{color:rgba(255,255,255,.5)}.navbar-dark .navbar-nav .nav-link:focus,.navbar-dark .navbar-nav .nav-link:hover{color:rgba(255,255,255,.75)}.navbar-dark .navbar-nav .nav-link.disabled{color:rgba(255,255,255,.25)}.navbar-dark .navbar-nav .active>.nav-link,.navbar-dark .navbar-nav .nav-link.active,.navbar-dark .navbar-nav .nav-link.show,.navbar-dark .navbar-nav .show>.nav-link{color:#fff}.navbar-dark .navbar-toggler{color:rgba(255,255,255,.5);border-color:rgba(255,255,255,.1)}.navbar-dark .navbar-toggler-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' width='30' height='30' viewBox='0 0 30 30'%3e%3cpath stroke='rgba(255, 255, 255, 0.5)' stroke-linecap='round' stroke-miterlimit='10' stroke-width='2' d='M4 7h22M4 15h22M4 23h22'/%3e%3c/svg%3e")}.navbar-dark .navbar-text{color:rgba(255,255,255,.5)}.navbar-dark .navbar-text a{color:#fff}.navbar-dark .navbar-text a:focus,.navbar-dark .navbar-text a:hover{color:#fff}.card{position:relative;display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;min-width:0;word-wrap:break-word;background-color:#fff;background-clip:border-box;border:1px solid rgba(0,0,0,.125);border-radius:.25rem}.card>hr{margin-right:0;margin-left:0}.card>.list-group:first-child .list-group-item:first-child{border-top-left-radius:.25rem;border-top-right-radius:.25rem}.card>.list-group:last-child .list-group-item:last-child{border-bottom-right-radius:.25rem;border-bottom-left-radius:.25rem}.card-body{-ms-flex:1 1 auto;flex:1 1 auto;min-height:1px;padding:1.25rem}.card-title{margin-bottom:.75rem}.card-subtitle{margin-top:-.375rem;margin-bottom:0}.card-text:last-child{margin-bottom:0}.card-link:hover{text-decoration:none}.card-link+.card-link{margin-left:1.25rem}.card-header{padding:.75rem 1.25rem;margin-bottom:0;background-color:rgba(0,0,0,.03);border-bottom:1px solid rgba(0,0,0,.125)}.card-header:first-child{border-radius:calc(.25rem - 1px) calc(.25rem - 1px) 0 0}.card-header+.list-group .list-group-item:first-child{border-top:0}.card-footer{padding:.75rem 1.25rem;background-color:rgba(0,0,0,.03);border-top:1px solid rgba(0,0,0,.125)}.card-footer:last-child{border-radius:0 0 calc(.25rem - 1px) calc(.25rem - 1px)}.card-header-tabs{margin-right:-.625rem;margin-bottom:-.75rem;margin-left:-.625rem;border-bottom:0}.card-header-pills{margin-right:-.625rem;margin-left:-.625rem}.card-img-overlay{position:absolute;top:0;right:0;bottom:0;left:0;padding:1.25rem}.card-img,.card-img-bottom,.card-img-top{-ms-flex-negative:0;flex-shrink:0;width:100%}.card-img,.card-img-top{border-top-left-radius:calc(.25rem - 1px);border-top-right-radius:calc(.25rem - 1px)}.card-img,.card-img-bottom{border-bottom-right-radius:calc(.25rem - 1px);border-bottom-left-radius:calc(.25rem - 1px)}.card-deck .card{margin-bottom:15px}@media (min-width:576px){.card-deck{display:-ms-flexbox;display:flex;-ms-flex-flow:row wrap;flex-flow:row wrap;margin-right:-15px;margin-left:-15px}.card-deck .card{-ms-flex:1 0 0%;flex:1 0 0%;margin-right:15px;margin-bottom:0;margin-left:15px}}.card-group>.card{margin-bottom:15px}@media (min-width:576px){.card-group{display:-ms-flexbox;display:flex;-ms-flex-flow:row wrap;flex-flow:row wrap}.card-group>.card{-ms-flex:1 0 0%;flex:1 0 0%;margin-bottom:0}.card-group>.card+.card{margin-left:0;border-left:0}.card-group>.card:not(:last-child){border-top-right-radius:0;border-bottom-right-radius:0}.card-group>.card:not(:last-child) .card-header,.card-group>.card:not(:last-child) .card-img-top{border-top-right-radius:0}.card-group>.card:not(:last-child) .card-footer,.card-group>.card:not(:last-child) .card-img-bottom{border-bottom-right-radius:0}.card-group>.card:not(:first-child){border-top-left-radius:0;border-bottom-left-radius:0}.card-group>.card:not(:first-child) .card-header,.card-group>.card:not(:first-child) .card-img-top{border-top-left-radius:0}.card-group>.card:not(:first-child) .card-footer,.card-group>.card:not(:first-child) .card-img-bottom{border-bottom-left-radius:0}}.card-columns .card{margin-bottom:.75rem}@media (min-width:576px){.card-columns{-webkit-column-count:3;-moz-column-count:3;column-count:3;-webkit-column-gap:1.25rem;-moz-column-gap:1.25rem;column-gap:1.25rem;orphans:1;widows:1}.card-columns .card{display:inline-block;width:100%}}.accordion>.card{overflow:hidden}.accordion>.card:not(:last-of-type){border-bottom:0;border-bottom-right-radius:0;border-bottom-left-radius:0}.accordion>.card:not(:first-of-type){border-top-left-radius:0;border-top-right-radius:0}.accordion>.card>.card-header{border-radius:0;margin-bottom:-1px}.breadcrumb{display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;padding:.75rem 1rem;margin-bottom:1rem;list-style:none;background-color:#e9ecef;border-radius:.25rem}.breadcrumb-item+.breadcrumb-item{padding-left:.5rem}.breadcrumb-item+.breadcrumb-item::before{display:inline-block;padding-right:.5rem;color:#6c757d;content:"/"}.breadcrumb-item+.breadcrumb-item:hover::before{text-decoration:underline}.breadcrumb-item+.breadcrumb-item:hover::before{text-decoration:none}.breadcrumb-item.active{color:#6c757d}.pagination{display:-ms-flexbox;display:flex;padding-left:0;list-style:none;border-radius:.25rem}.page-link{position:relative;display:block;padding:.5rem .75rem;margin-left:-1px;line-height:1.25;color:#007bff;background-color:#fff;border:1px solid #dee2e6}.page-link:hover{z-index:2;color:#0056b3;text-decoration:none;background-color:#e9ecef;border-color:#dee2e6}.page-link:focus{z-index:3;outline:0;box-shadow:0 0 0 .2rem rgba(0,123,255,.25)}.page-item:first-child .page-link{margin-left:0;border-top-left-radius:.25rem;border-bottom-left-radius:.25rem}.page-item:last-child .page-link{border-top-right-radius:.25rem;border-bottom-right-radius:.25rem}.page-item.active .page-link{z-index:3;color:#fff;background-color:#007bff;border-color:#007bff}.page-item.disabled .page-link{color:#6c757d;pointer-events:none;cursor:auto;background-color:#fff;border-color:#dee2e6}.pagination-lg .page-link{padding:.75rem 1.5rem;font-size:1.25rem;line-height:1.5}.pagination-lg .page-item:first-child .page-link{border-top-left-radius:.3rem;border-bottom-left-radius:.3rem}.pagination-lg .page-item:last-child .page-link{border-top-right-radius:.3rem;border-bottom-right-radius:.3rem}.pagination-sm .page-link{padding:.25rem .5rem;font-size:.875rem;line-height:1.5}.pagination-sm .page-item:first-child .page-link{border-top-left-radius:.2rem;border-bottom-left-radius:.2rem}.pagination-sm .page-item:last-child .page-link{border-top-right-radius:.2rem;border-bottom-right-radius:.2rem}.badge{display:inline-block;padding:.25em .4em;font-size:75%;font-weight:700;line-height:1;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25rem;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out}@media (prefers-reduced-motion:reduce){.badge{transition:none}}a.badge:focus,a.badge:hover{text-decoration:none}.badge:empty{display:none}.btn .badge{position:relative;top:-1px}.badge-pill{padding-right:.6em;padding-left:.6em;border-radius:10rem}.badge-primary{color:#fff;background-color:#007bff}a.badge-primary:focus,a.badge-primary:hover{color:#fff;background-color:#0062cc}a.badge-primary.focus,a.badge-primary:focus{outline:0;box-shadow:0 0 0 .2rem rgba(0,123,255,.5)}.badge-secondary{color:#fff;background-color:#6c757d}a.badge-secondary:focus,a.badge-secondary:hover{color:#fff;background-color:#545b62}a.badge-secondary.focus,a.badge-secondary:focus{outline:0;box-shadow:0 0 0 .2rem rgba(108,117,125,.5)}.badge-success{color:#fff;background-color:#28a745}a.badge-success:focus,a.badge-success:hover{color:#fff;background-color:#1e7e34}a.badge-success.focus,a.badge-success:focus{outline:0;box-shadow:0 0 0 .2rem rgba(40,167,69,.5)}.badge-info{color:#fff;background-color:#17a2b8}a.badge-info:focus,a.badge-info:hover{color:#fff;background-color:#117a8b}a.badge-info.focus,a.badge-info:focus{outline:0;box-shadow:0 0 0 .2rem rgba(23,162,184,.5)}.badge-warning{color:#212529;background-color:#ffc107}a.badge-warning:focus,a.badge-warning:hover{color:#212529;background-color:#d39e00}a.badge-warning.focus,a.badge-warning:focus{outline:0;box-shadow:0 0 0 .2rem rgba(255,193,7,.5)}.badge-danger{color:#fff;background-color:#dc3545}a.badge-danger:focus,a.badge-danger:hover{color:#fff;background-color:#bd2130}a.badge-danger.focus,a.badge-danger:focus{outline:0;box-shadow:0 0 0 .2rem rgba(220,53,69,.5)}.badge-light{color:#212529;background-color:#f8f9fa}a.badge-light:focus,a.badge-light:hover{color:#212529;background-color:#dae0e5}a.badge-light.focus,a.badge-light:focus{outline:0;box-shadow:0 0 0 .2rem rgba(248,249,250,.5)}.badge-dark{color:#fff;background-color:#343a40}a.badge-dark:focus,a.badge-dark:hover{color:#fff;background-color:#1d2124}a.badge-dark.focus,a.badge-dark:focus{outline:0;box-shadow:0 0 0 .2rem rgba(52,58,64,.5)}.jumbotron{padding:2rem 1rem;margin-bottom:2rem;background-color:#e9ecef;border-radius:.3rem}@media (min-width:576px){.jumbotron{padding:4rem 2rem}}.jumbotron-fluid{padding-right:0;padding-left:0;border-radius:0}.alert{position:relative;padding:.75rem 1.25rem;margin-bottom:1rem;border:1px solid transparent;border-radius:.25rem}.alert-heading{color:inherit}.alert-link{font-weight:700}.alert-dismissible{padding-right:4rem}.alert-dismissible .close{position:absolute;top:0;right:0;padding:.75rem 1.25rem;color:inherit}.alert-primary{color:#004085;background-color:#cce5ff;border-color:#b8daff}.alert-primary hr{border-top-color:#9fcdff}.alert-primary .alert-link{color:#002752}.alert-secondary{color:#383d41;background-color:#e2e3e5;border-color:#d6d8db}.alert-secondary hr{border-top-color:#c8cbcf}.alert-secondary .alert-link{color:#202326}.alert-success{color:#155724;background-color:#d4edda;border-color:#c3e6cb}.alert-success hr{border-top-color:#b1dfbb}.alert-success .alert-link{color:#0b2e13}.alert-info{color:#0c5460;background-color:#d1ecf1;border-color:#bee5eb}.alert-info hr{border-top-color:#abdde5}.alert-info .alert-link{color:#062c33}.alert-warning{color:#856404;background-color:#fff3cd;border-color:#ffeeba}.alert-warning hr{border-top-color:#ffe8a1}.alert-warning .alert-link{color:#533f03}.alert-danger{color:#721c24;background-color:#f8d7da;border-color:#f5c6cb}.alert-danger hr{border-top-color:#f1b0b7}.alert-danger .alert-link{color:#491217}.alert-light{color:#818182;background-color:#fefefe;border-color:#fdfdfe}.alert-light hr{border-top-color:#ececf6}.alert-light .alert-link{color:#686868}.alert-dark{color:#1b1e21;background-color:#d6d8d9;border-color:#c6c8ca}.alert-dark hr{border-top-color:#b9bbbe}.alert-dark .alert-link{color:#040505}@-webkit-keyframes progress-bar-stripes{from{background-position:1rem 0}to{background-position:0 0}}@keyframes progress-bar-stripes{from{background-position:1rem 0}to{background-position:0 0}}.progress{display:-ms-flexbox;display:flex;height:1rem;overflow:hidden;font-size:.75rem;background-color:#e9ecef;border-radius:.25rem}.progress-bar{display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;-ms-flex-pack:center;justify-content:center;overflow:hidden;color:#fff;text-align:center;white-space:nowrap;background-color:#007bff;transition:width .6s ease}@media (prefers-reduced-motion:reduce){.progress-bar{transition:none}}.progress-bar-striped{background-image:linear-gradient(45deg,rgba(255,255,255,.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,.15) 50%,rgba(255,255,255,.15) 75%,transparent 75%,transparent);background-size:1rem 1rem}.progress-bar-animated{-webkit-animation:progress-bar-stripes 1s linear infinite;animation:progress-bar-stripes 1s linear infinite}@media (prefers-reduced-motion:reduce){.progress-bar-animated{-webkit-animation:none;animation:none}}.media{display:-ms-flexbox;display:flex;-ms-flex-align:start;align-items:flex-start}.media-body{-ms-flex:1;flex:1}.list-group{display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;padding-left:0;margin-bottom:0}.list-group-item-action{width:100%;color:#495057;text-align:inherit}.list-group-item-action:focus,.list-group-item-action:hover{z-index:1;color:#495057;text-decoration:none;background-color:#f8f9fa}.list-group-item-action:active{color:#212529;background-color:#e9ecef}.list-group-item{position:relative;display:block;padding:.75rem 1.25rem;background-color:#fff;border:1px solid rgba(0,0,0,.125)}.list-group-item:first-child{border-top-left-radius:.25rem;border-top-right-radius:.25rem}.list-group-item:last-child{border-bottom-right-radius:.25rem;border-bottom-left-radius:.25rem}.list-group-item.disabled,.list-group-item:disabled{color:#6c757d;pointer-events:none;background-color:#fff}.list-group-item.active{z-index:2;color:#fff;background-color:#007bff;border-color:#007bff}.list-group-item+.list-group-item{border-top-width:0}.list-group-item+.list-group-item.active{margin-top:-1px;border-top-width:1px}.list-group-horizontal{-ms-flex-direction:row;flex-direction:row}.list-group-horizontal .list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal .list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal .list-group-item.active{margin-top:0}.list-group-horizontal .list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal .list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}@media (min-width:576px){.list-group-horizontal-sm{-ms-flex-direction:row;flex-direction:row}.list-group-horizontal-sm .list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal-sm .list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-sm .list-group-item.active{margin-top:0}.list-group-horizontal-sm .list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-sm .list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}}@media (min-width:768px){.list-group-horizontal-md{-ms-flex-direction:row;flex-direction:row}.list-group-horizontal-md .list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal-md .list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-md .list-group-item.active{margin-top:0}.list-group-horizontal-md .list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-md .list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}}@media (min-width:992px){.list-group-horizontal-lg{-ms-flex-direction:row;flex-direction:row}.list-group-horizontal-lg .list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal-lg .list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-lg .list-group-item.active{margin-top:0}.list-group-horizontal-lg .list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-lg .list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}}@media (min-width:1200px){.list-group-horizontal-xl{-ms-flex-direction:row;flex-direction:row}.list-group-horizontal-xl .list-group-item:first-child{border-bottom-left-radius:.25rem;border-top-right-radius:0}.list-group-horizontal-xl .list-group-item:last-child{border-top-right-radius:.25rem;border-bottom-left-radius:0}.list-group-horizontal-xl .list-group-item.active{margin-top:0}.list-group-horizontal-xl .list-group-item+.list-group-item{border-top-width:1px;border-left-width:0}.list-group-horizontal-xl .list-group-item+.list-group-item.active{margin-left:-1px;border-left-width:1px}}.list-group-flush .list-group-item{border-right-width:0;border-left-width:0;border-radius:0}.list-group-flush .list-group-item:first-child{border-top-width:0}.list-group-flush:last-child .list-group-item:last-child{border-bottom-width:0}.list-group-item-primary{color:#004085;background-color:#b8daff}.list-group-item-primary.list-group-item-action:focus,.list-group-item-primary.list-group-item-action:hover{color:#004085;background-color:#9fcdff}.list-group-item-primary.list-group-item-action.active{color:#fff;background-color:#004085;border-color:#004085}.list-group-item-secondary{color:#383d41;background-color:#d6d8db}.list-group-item-secondary.list-group-item-action:focus,.list-group-item-secondary.list-group-item-action:hover{color:#383d41;background-color:#c8cbcf}.list-group-item-secondary.list-group-item-action.active{color:#fff;background-color:#383d41;border-color:#383d41}.list-group-item-success{color:#155724;background-color:#c3e6cb}.list-group-item-success.list-group-item-action:focus,.list-group-item-success.list-group-item-action:hover{color:#155724;background-color:#b1dfbb}.list-group-item-success.list-group-item-action.active{color:#fff;background-color:#155724;border-color:#155724}.list-group-item-info{color:#0c5460;background-color:#bee5eb}.list-group-item-info.list-group-item-action:focus,.list-group-item-info.list-group-item-action:hover{color:#0c5460;background-color:#abdde5}.list-group-item-info.list-group-item-action.active{color:#fff;background-color:#0c5460;border-color:#0c5460}.list-group-item-warning{color:#856404;background-color:#ffeeba}.list-group-item-warning.list-group-item-action:focus,.list-group-item-warning.list-group-item-action:hover{color:#856404;background-color:#ffe8a1}.list-group-item-warning.list-group-item-action.active{color:#fff;background-color:#856404;border-color:#856404}.list-group-item-danger{color:#721c24;background-color:#f5c6cb}.list-group-item-danger.list-group-item-action:focus,.list-group-item-danger.list-group-item-action:hover{color:#721c24;background-color:#f1b0b7}.list-group-item-danger.list-group-item-action.active{color:#fff;background-color:#721c24;border-color:#721c24}.list-group-item-light{color:#818182;background-color:#fdfdfe}.list-group-item-light.list-group-item-action:focus,.list-group-item-light.list-group-item-action:hover{color:#818182;background-color:#ececf6}.list-group-item-light.list-group-item-action.active{color:#fff;background-color:#818182;border-color:#818182}.list-group-item-dark{color:#1b1e21;background-color:#c6c8ca}.list-group-item-dark.list-group-item-action:focus,.list-group-item-dark.list-group-item-action:hover{color:#1b1e21;background-color:#b9bbbe}.list-group-item-dark.list-group-item-action.active{color:#fff;background-color:#1b1e21;border-color:#1b1e21}.close{float:right;font-size:1.5rem;font-weight:700;line-height:1;color:#000;text-shadow:0 1px 0 #fff;opacity:.5}.close:hover{color:#000;text-decoration:none}.close:not(:disabled):not(.disabled):focus,.close:not(:disabled):not(.disabled):hover{opacity:.75}button.close{padding:0;background-color:transparent;border:0;-webkit-appearance:none;-moz-appearance:none;appearance:none}a.close.disabled{pointer-events:none}.toast{max-width:350px;overflow:hidden;font-size:.875rem;background-color:rgba(255,255,255,.85);background-clip:padding-box;border:1px solid rgba(0,0,0,.1);box-shadow:0 .25rem .75rem rgba(0,0,0,.1);-webkit-backdrop-filter:blur(10px);backdrop-filter:blur(10px);opacity:0;border-radius:.25rem}.toast:not(:last-child){margin-bottom:.75rem}.toast.showing{opacity:1}.toast.show{display:block;opacity:1}.toast.hide{display:none}.toast-header{display:-ms-flexbox;display:flex;-ms-flex-align:center;align-items:center;padding:.25rem .75rem;color:#6c757d;background-color:rgba(255,255,255,.85);background-clip:padding-box;border-bottom:1px solid rgba(0,0,0,.05)}.toast-body{padding:.75rem}.modal-open{overflow:hidden}.modal-open .modal{overflow-x:hidden;overflow-y:auto}.modal{position:fixed;top:0;left:0;z-index:1050;display:none;width:100%;height:100%;overflow:hidden;outline:0}.modal-dialog{position:relative;width:auto;margin:.5rem;pointer-events:none}.modal.fade .modal-dialog{transition:-webkit-transform .3s ease-out;transition:transform .3s ease-out;transition:transform .3s ease-out,-webkit-transform .3s ease-out;-webkit-transform:translate(0,-50px);transform:translate(0,-50px)}@media (prefers-reduced-motion:reduce){.modal.fade .modal-dialog{transition:none}}.modal.show .modal-dialog{-webkit-transform:none;transform:none}.modal.modal-static .modal-dialog{-webkit-transform:scale(1.02);transform:scale(1.02)}.modal-dialog-scrollable{display:-ms-flexbox;display:flex;max-height:calc(100% - 1rem)}.modal-dialog-scrollable .modal-content{max-height:calc(100vh - 1rem);overflow:hidden}.modal-dialog-scrollable .modal-footer,.modal-dialog-scrollable .modal-header{-ms-flex-negative:0;flex-shrink:0}.modal-dialog-scrollable .modal-body{overflow-y:auto}.modal-dialog-centered{display:-ms-flexbox;display:flex;-ms-flex-align:center;align-items:center;min-height:calc(100% - 1rem)}.modal-dialog-centered::before{display:block;height:calc(100vh - 1rem);content:""}.modal-dialog-centered.modal-dialog-scrollable{-ms-flex-direction:column;flex-direction:column;-ms-flex-pack:center;justify-content:center;height:100%}.modal-dialog-centered.modal-dialog-scrollable .modal-content{max-height:none}.modal-dialog-centered.modal-dialog-scrollable::before{content:none}.modal-content{position:relative;display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;width:100%;pointer-events:auto;background-color:#fff;background-clip:padding-box;border:1px solid rgba(0,0,0,.2);border-radius:.3rem;outline:0}.modal-backdrop{position:fixed;top:0;left:0;z-index:1040;width:100vw;height:100vh;background-color:#000}.modal-backdrop.fade{opacity:0}.modal-backdrop.show{opacity:.5}.modal-header{display:-ms-flexbox;display:flex;-ms-flex-align:start;align-items:flex-start;-ms-flex-pack:justify;justify-content:space-between;padding:1rem 1rem;border-bottom:1px solid #dee2e6;border-top-left-radius:calc(.3rem - 1px);border-top-right-radius:calc(.3rem - 1px)}.modal-header .close{padding:1rem 1rem;margin:-1rem -1rem -1rem auto}.modal-title{margin-bottom:0;line-height:1.5}.modal-body{position:relative;-ms-flex:1 1 auto;flex:1 1 auto;padding:1rem}.modal-footer{display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;-ms-flex-align:center;align-items:center;-ms-flex-pack:end;justify-content:flex-end;padding:.75rem;border-top:1px solid #dee2e6;border-bottom-right-radius:calc(.3rem - 1px);border-bottom-left-radius:calc(.3rem - 1px)}.modal-footer>*{margin:.25rem}.modal-scrollbar-measure{position:absolute;top:-9999px;width:50px;height:50px;overflow:scroll}@media (min-width:576px){.modal-dialog{max-width:500px;margin:1.75rem auto}.modal-dialog-scrollable{max-height:calc(100% - 3.5rem)}.modal-dialog-scrollable .modal-content{max-height:calc(100vh - 3.5rem)}.modal-dialog-centered{min-height:calc(100% - 3.5rem)}.modal-dialog-centered::before{height:calc(100vh - 3.5rem)}.modal-sm{max-width:300px}}@media (min-width:992px){.modal-lg,.modal-xl{max-width:800px}}@media (min-width:1200px){.modal-xl{max-width:1140px}}.tooltip{position:absolute;z-index:1070;display:block;margin:0;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";font-style:normal;font-weight:400;line-height:1.5;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;white-space:normal;line-break:auto;font-size:.875rem;word-wrap:break-word;opacity:0}.tooltip.show{opacity:.9}.tooltip .arrow{position:absolute;display:block;width:.8rem;height:.4rem}.tooltip .arrow::before{position:absolute;content:"";border-color:transparent;border-style:solid}.bs-tooltip-auto[x-placement^=top],.bs-tooltip-top{padding:.4rem 0}.bs-tooltip-auto[x-placement^=top] .arrow,.bs-tooltip-top .arrow{bottom:0}.bs-tooltip-auto[x-placement^=top] .arrow::before,.bs-tooltip-top .arrow::before{top:0;border-width:.4rem .4rem 0;border-top-color:#000}.bs-tooltip-auto[x-placement^=right],.bs-tooltip-right{padding:0 .4rem}.bs-tooltip-auto[x-placement^=right] .arrow,.bs-tooltip-right .arrow{left:0;width:.4rem;height:.8rem}.bs-tooltip-auto[x-placement^=right] .arrow::before,.bs-tooltip-right .arrow::before{right:0;border-width:.4rem .4rem .4rem 0;border-right-color:#000}.bs-tooltip-auto[x-placement^=bottom],.bs-tooltip-bottom{padding:.4rem 0}.bs-tooltip-auto[x-placement^=bottom] .arrow,.bs-tooltip-bottom .arrow{top:0}.bs-tooltip-auto[x-placement^=bottom] .arrow::before,.bs-tooltip-bottom .arrow::before{bottom:0;border-width:0 .4rem .4rem;border-bottom-color:#000}.bs-tooltip-auto[x-placement^=left],.bs-tooltip-left{padding:0 .4rem}.bs-tooltip-auto[x-placement^=left] .arrow,.bs-tooltip-left .arrow{right:0;width:.4rem;height:.8rem}.bs-tooltip-auto[x-placement^=left] .arrow::before,.bs-tooltip-left .arrow::before{left:0;border-width:.4rem 0 .4rem .4rem;border-left-color:#000}.tooltip-inner{max-width:200px;padding:.25rem .5rem;color:#fff;text-align:center;background-color:#000;border-radius:.25rem}.popover{position:absolute;top:0;left:0;z-index:1060;display:block;max-width:276px;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Arial,"Noto Sans",sans-serif,"Apple Color Emoji","Segoe UI Emoji","Segoe UI Symbol","Noto Color Emoji";font-style:normal;font-weight:400;line-height:1.5;text-align:left;text-align:start;text-decoration:none;text-shadow:none;text-transform:none;letter-spacing:normal;word-break:normal;word-spacing:normal;white-space:normal;line-break:auto;font-size:.875rem;word-wrap:break-word;background-color:#fff;background-clip:padding-box;border:1px solid rgba(0,0,0,.2);border-radius:.3rem}.popover .arrow{position:absolute;display:block;width:1rem;height:.5rem;margin:0 .3rem}.popover .arrow::after,.popover .arrow::before{position:absolute;display:block;content:"";border-color:transparent;border-style:solid}.bs-popover-auto[x-placement^=top],.bs-popover-top{margin-bottom:.5rem}.bs-popover-auto[x-placement^=top]>.arrow,.bs-popover-top>.arrow{bottom:calc(-.5rem - 1px)}.bs-popover-auto[x-placement^=top]>.arrow::before,.bs-popover-top>.arrow::before{bottom:0;border-width:.5rem .5rem 0;border-top-color:rgba(0,0,0,.25)}.bs-popover-auto[x-placement^=top]>.arrow::after,.bs-popover-top>.arrow::after{bottom:1px;border-width:.5rem .5rem 0;border-top-color:#fff}.bs-popover-auto[x-placement^=right],.bs-popover-right{margin-left:.5rem}.bs-popover-auto[x-placement^=right]>.arrow,.bs-popover-right>.arrow{left:calc(-.5rem - 1px);width:.5rem;height:1rem;margin:.3rem 0}.bs-popover-auto[x-placement^=right]>.arrow::before,.bs-popover-right>.arrow::before{left:0;border-width:.5rem .5rem .5rem 0;border-right-color:rgba(0,0,0,.25)}.bs-popover-auto[x-placement^=right]>.arrow::after,.bs-popover-right>.arrow::after{left:1px;border-width:.5rem .5rem .5rem 0;border-right-color:#fff}.bs-popover-auto[x-placement^=bottom],.bs-popover-bottom{margin-top:.5rem}.bs-popover-auto[x-placement^=bottom]>.arrow,.bs-popover-bottom>.arrow{top:calc(-.5rem - 1px)}.bs-popover-auto[x-placement^=bottom]>.arrow::before,.bs-popover-bottom>.arrow::before{top:0;border-width:0 .5rem .5rem .5rem;border-bottom-color:rgba(0,0,0,.25)}.bs-popover-auto[x-placement^=bottom]>.arrow::after,.bs-popover-bottom>.arrow::after{top:1px;border-width:0 .5rem .5rem .5rem;border-bottom-color:#fff}.bs-popover-auto[x-placement^=bottom] .popover-header::before,.bs-popover-bottom .popover-header::before{position:absolute;top:0;left:50%;display:block;width:1rem;margin-left:-.5rem;content:"";border-bottom:1px solid #f7f7f7}.bs-popover-auto[x-placement^=left],.bs-popover-left{margin-right:.5rem}.bs-popover-auto[x-placement^=left]>.arrow,.bs-popover-left>.arrow{right:calc(-.5rem - 1px);width:.5rem;height:1rem;margin:.3rem 0}.bs-popover-auto[x-placement^=left]>.arrow::before,.bs-popover-left>.arrow::before{right:0;border-width:.5rem 0 .5rem .5rem;border-left-color:rgba(0,0,0,.25)}.bs-popover-auto[x-placement^=left]>.arrow::after,.bs-popover-left>.arrow::after{right:1px;border-width:.5rem 0 .5rem .5rem;border-left-color:#fff}.popover-header{padding:.5rem .75rem;margin-bottom:0;font-size:1rem;background-color:#f7f7f7;border-bottom:1px solid #ebebeb;border-top-left-radius:calc(.3rem - 1px);border-top-right-radius:calc(.3rem - 1px)}.popover-header:empty{display:none}.popover-body{padding:.5rem .75rem;color:#212529}.carousel{position:relative}.carousel.pointer-event{-ms-touch-action:pan-y;touch-action:pan-y}.carousel-inner{position:relative;width:100%;overflow:hidden}.carousel-inner::after{display:block;clear:both;content:""}.carousel-item{position:relative;display:none;float:left;width:100%;margin-right:-100%;-webkit-backface-visibility:hidden;backface-visibility:hidden;transition:-webkit-transform .6s ease-in-out;transition:transform .6s ease-in-out;transition:transform .6s ease-in-out,-webkit-transform .6s ease-in-out}@media (prefers-reduced-motion:reduce){.carousel-item{transition:none}}.carousel-item-next,.carousel-item-prev,.carousel-item.active{display:block}.active.carousel-item-right,.carousel-item-next:not(.carousel-item-left){-webkit-transform:translateX(100%);transform:translateX(100%)}.active.carousel-item-left,.carousel-item-prev:not(.carousel-item-right){-webkit-transform:translateX(-100%);transform:translateX(-100%)}.carousel-fade .carousel-item{opacity:0;transition-property:opacity;-webkit-transform:none;transform:none}.carousel-fade .carousel-item-next.carousel-item-left,.carousel-fade .carousel-item-prev.carousel-item-right,.carousel-fade .carousel-item.active{z-index:1;opacity:1}.carousel-fade .active.carousel-item-left,.carousel-fade .active.carousel-item-right{z-index:0;opacity:0;transition:opacity 0s .6s}@media (prefers-reduced-motion:reduce){.carousel-fade .active.carousel-item-left,.carousel-fade .active.carousel-item-right{transition:none}}.carousel-control-next,.carousel-control-prev{position:absolute;top:0;bottom:0;z-index:1;display:-ms-flexbox;display:flex;-ms-flex-align:center;align-items:center;-ms-flex-pack:center;justify-content:center;width:15%;color:#fff;text-align:center;opacity:.5;transition:opacity .15s ease}@media (prefers-reduced-motion:reduce){.carousel-control-next,.carousel-control-prev{transition:none}}.carousel-control-next:focus,.carousel-control-next:hover,.carousel-control-prev:focus,.carousel-control-prev:hover{color:#fff;text-decoration:none;outline:0;opacity:.9}.carousel-control-prev{left:0}.carousel-control-next{right:0}.carousel-control-next-icon,.carousel-control-prev-icon{display:inline-block;width:20px;height:20px;background:no-repeat 50%/100% 100%}.carousel-control-prev-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' fill='%23fff' width='8' height='8' viewBox='0 0 8 8'%3e%3cpath d='M5.25 0l-4 4 4 4 1.5-1.5L4.25 4l2.5-2.5L5.25 0z'/%3e%3c/svg%3e")}.carousel-control-next-icon{background-image:url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' fill='%23fff' width='8' height='8' viewBox='0 0 8 8'%3e%3cpath d='M2.75 0l-1.5 1.5L3.75 4l-2.5 2.5L2.75 8l4-4-4-4z'/%3e%3c/svg%3e")}.carousel-indicators{position:absolute;right:0;bottom:0;left:0;z-index:15;display:-ms-flexbox;display:flex;-ms-flex-pack:center;justify-content:center;padding-left:0;margin-right:15%;margin-left:15%;list-style:none}.carousel-indicators li{box-sizing:content-box;-ms-flex:0 1 auto;flex:0 1 auto;width:30px;height:3px;margin-right:3px;margin-left:3px;text-indent:-999px;cursor:pointer;background-color:#fff;background-clip:padding-box;border-top:10px solid transparent;border-bottom:10px solid transparent;opacity:.5;transition:opacity .6s ease}@media (prefers-reduced-motion:reduce){.carousel-indicators li{transition:none}}.carousel-indicators .active{opacity:1}.carousel-caption{position:absolute;right:15%;bottom:20px;left:15%;z-index:10;padding-top:20px;padding-bottom:20px;color:#fff;text-align:center}@-webkit-keyframes spinner-border{to{-webkit-transform:rotate(360deg);transform:rotate(360deg)}}@keyframes spinner-border{to{-webkit-transform:rotate(360deg);transform:rotate(360deg)}}.spinner-border{display:inline-block;width:2rem;height:2rem;vertical-align:text-bottom;border:.25em solid currentColor;border-right-color:transparent;border-radius:50%;-webkit-animation:spinner-border .75s linear infinite;animation:spinner-border .75s linear infinite}.spinner-border-sm{width:1rem;height:1rem;border-width:.2em}@-webkit-keyframes spinner-grow{0%{-webkit-transform:scale(0);transform:scale(0)}50%{opacity:1}}@keyframes spinner-grow{0%{-webkit-transform:scale(0);transform:scale(0)}50%{opacity:1}}.spinner-grow{display:inline-block;width:2rem;height:2rem;vertical-align:text-bottom;background-color:currentColor;border-radius:50%;opacity:0;-webkit-animation:spinner-grow .75s linear infinite;animation:spinner-grow .75s linear infinite}.spinner-grow-sm{width:1rem;height:1rem}.align-baseline{vertical-align:baseline!important}.align-top{vertical-align:top!important}.align-middle{vertical-align:middle!important}.align-bottom{vertical-align:bottom!important}.align-text-bottom{vertical-align:text-bottom!important}.align-text-top{vertical-align:text-top!important}.bg-primary{background-color:#007bff!important}a.bg-primary:focus,a.bg-primary:hover,button.bg-primary:focus,button.bg-primary:hover{background-color:#0062cc!important}.bg-secondary{background-color:#6c757d!important}a.bg-secondary:focus,a.bg-secondary:hover,button.bg-secondary:focus,button.bg-secondary:hover{background-color:#545b62!important}.bg-success{background-color:#28a745!important}a.bg-success:focus,a.bg-success:hover,button.bg-success:focus,button.bg-success:hover{background-color:#1e7e34!important}.bg-info{background-color:#17a2b8!important}a.bg-info:focus,a.bg-info:hover,button.bg-info:focus,button.bg-info:hover{background-color:#117a8b!important}.bg-warning{background-color:#ffc107!important}a.bg-warning:focus,a.bg-warning:hover,button.bg-warning:focus,button.bg-warning:hover{background-color:#d39e00!important}.bg-danger{background-color:#dc3545!important}a.bg-danger:focus,a.bg-danger:hover,button.bg-danger:focus,button.bg-danger:hover{background-color:#bd2130!important}.bg-light{background-color:#f8f9fa!important}a.bg-light:focus,a.bg-light:hover,button.bg-light:focus,button.bg-light:hover{background-color:#dae0e5!important}.bg-dark{background-color:#343a40!important}a.bg-dark:focus,a.bg-dark:hover,button.bg-dark:focus,button.bg-dark:hover{background-color:#1d2124!important}.bg-white{background-color:#fff!important}.bg-transparent{background-color:transparent!important}.border{border:1px solid #dee2e6!important}.border-top{border-top:1px solid #dee2e6!important}.border-right{border-right:1px solid #dee2e6!important}.border-bottom{border-bottom:1px solid #dee2e6!important}.border-left{border-left:1px solid #dee2e6!important}.border-0{border:0!important}.border-top-0{border-top:0!important}.border-right-0{border-right:0!important}.border-bottom-0{border-bottom:0!important}.border-left-0{border-left:0!important}.border-primary{border-color:#007bff!important}.border-secondary{border-color:#6c757d!important}.border-success{border-color:#28a745!important}.border-info{border-color:#17a2b8!important}.border-warning{border-color:#ffc107!important}.border-danger{border-color:#dc3545!important}.border-light{border-color:#f8f9fa!important}.border-dark{border-color:#343a40!important}.border-white{border-color:#fff!important}.rounded-sm{border-radius:.2rem!important}.rounded{border-radius:.25rem!important}.rounded-top{border-top-left-radius:.25rem!important;border-top-right-radius:.25rem!important}.rounded-right{border-top-right-radius:.25rem!important;border-bottom-right-radius:.25rem!important}.rounded-bottom{border-bottom-right-radius:.25rem!important;border-bottom-left-radius:.25rem!important}.rounded-left{border-top-left-radius:.25rem!important;border-bottom-left-radius:.25rem!important}.rounded-lg{border-radius:.3rem!important}.rounded-circle{border-radius:50%!important}.rounded-pill{border-radius:50rem!important}.rounded-0{border-radius:0!important}.clearfix::after{display:block;clear:both;content:""}.d-none{display:none!important}.d-inline{display:inline!important}.d-inline-block{display:inline-block!important}.d-block{display:block!important}.d-table{display:table!important}.d-table-row{display:table-row!important}.d-table-cell{display:table-cell!important}.d-flex{display:-ms-flexbox!important;display:flex!important}.d-inline-flex{display:-ms-inline-flexbox!important;display:inline-flex!important}@media (min-width:576px){.d-sm-none{display:none!important}.d-sm-inline{display:inline!important}.d-sm-inline-block{display:inline-block!important}.d-sm-block{display:block!important}.d-sm-table{display:table!important}.d-sm-table-row{display:table-row!important}.d-sm-table-cell{display:table-cell!important}.d-sm-flex{display:-ms-flexbox!important;display:flex!important}.d-sm-inline-flex{display:-ms-inline-flexbox!important;display:inline-flex!important}}@media (min-width:768px){.d-md-none{display:none!important}.d-md-inline{display:inline!important}.d-md-inline-block{display:inline-block!important}.d-md-block{display:block!important}.d-md-table{display:table!important}.d-md-table-row{display:table-row!important}.d-md-table-cell{display:table-cell!important}.d-md-flex{display:-ms-flexbox!important;display:flex!important}.d-md-inline-flex{display:-ms-inline-flexbox!important;display:inline-flex!important}}@media (min-width:992px){.d-lg-none{display:none!important}.d-lg-inline{display:inline!important}.d-lg-inline-block{display:inline-block!important}.d-lg-block{display:block!important}.d-lg-table{display:table!important}.d-lg-table-row{display:table-row!important}.d-lg-table-cell{display:table-cell!important}.d-lg-flex{display:-ms-flexbox!important;display:flex!important}.d-lg-inline-flex{display:-ms-inline-flexbox!important;display:inline-flex!important}}@media (min-width:1200px){.d-xl-none{display:none!important}.d-xl-inline{display:inline!important}.d-xl-inline-block{display:inline-block!important}.d-xl-block{display:block!important}.d-xl-table{display:table!important}.d-xl-table-row{display:table-row!important}.d-xl-table-cell{display:table-cell!important}.d-xl-flex{display:-ms-flexbox!important;display:flex!important}.d-xl-inline-flex{display:-ms-inline-flexbox!important;display:inline-flex!important}}@media print{.d-print-none{display:none!important}.d-print-inline{display:inline!important}.d-print-inline-block{display:inline-block!important}.d-print-block{display:block!important}.d-print-table{display:table!important}.d-print-table-row{display:table-row!important}.d-print-table-cell{display:table-cell!important}.d-print-flex{display:-ms-flexbox!important;display:flex!important}.d-print-inline-flex{display:-ms-inline-flexbox!important;display:inline-flex!important}}.embed-responsive{position:relative;display:block;width:100%;padding:0;overflow:hidden}.embed-responsive::before{display:block;content:""}.embed-responsive .embed-responsive-item,.embed-responsive embed,.embed-responsive iframe,.embed-responsive object,.embed-responsive video{position:absolute;top:0;bottom:0;left:0;width:100%;height:100%;border:0}.embed-responsive-21by9::before{padding-top:42.857143%}.embed-responsive-16by9::before{padding-top:56.25%}.embed-responsive-4by3::before{padding-top:75%}.embed-responsive-1by1::before{padding-top:100%}.flex-row{-ms-flex-direction:row!important;flex-direction:row!important}.flex-column{-ms-flex-direction:column!important;flex-direction:column!important}.flex-row-reverse{-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-column-reverse{-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-wrap{-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-nowrap{-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-wrap-reverse{-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.flex-fill{-ms-flex:1 1 auto!important;flex:1 1 auto!important}.flex-grow-0{-ms-flex-positive:0!important;flex-grow:0!important}.flex-grow-1{-ms-flex-positive:1!important;flex-grow:1!important}.flex-shrink-0{-ms-flex-negative:0!important;flex-shrink:0!important}.flex-shrink-1{-ms-flex-negative:1!important;flex-shrink:1!important}.justify-content-start{-ms-flex-pack:start!important;justify-content:flex-start!important}.justify-content-end{-ms-flex-pack:end!important;justify-content:flex-end!important}.justify-content-center{-ms-flex-pack:center!important;justify-content:center!important}.justify-content-between{-ms-flex-pack:justify!important;justify-content:space-between!important}.justify-content-around{-ms-flex-pack:distribute!important;justify-content:space-around!important}.align-items-start{-ms-flex-align:start!important;align-items:flex-start!important}.align-items-end{-ms-flex-align:end!important;align-items:flex-end!important}.align-items-center{-ms-flex-align:center!important;align-items:center!important}.align-items-baseline{-ms-flex-align:baseline!important;align-items:baseline!important}.align-items-stretch{-ms-flex-align:stretch!important;align-items:stretch!important}.align-content-start{-ms-flex-line-pack:start!important;align-content:flex-start!important}.align-content-end{-ms-flex-line-pack:end!important;align-content:flex-end!important}.align-content-center{-ms-flex-line-pack:center!important;align-content:center!important}.align-content-between{-ms-flex-line-pack:justify!important;align-content:space-between!important}.align-content-around{-ms-flex-line-pack:distribute!important;align-content:space-around!important}.align-content-stretch{-ms-flex-line-pack:stretch!important;align-content:stretch!important}.align-self-auto{-ms-flex-item-align:auto!important;align-self:auto!important}.align-self-start{-ms-flex-item-align:start!important;align-self:flex-start!important}.align-self-end{-ms-flex-item-align:end!important;align-self:flex-end!important}.align-self-center{-ms-flex-item-align:center!important;align-self:center!important}.align-self-baseline{-ms-flex-item-align:baseline!important;align-self:baseline!important}.align-self-stretch{-ms-flex-item-align:stretch!important;align-self:stretch!important}@media (min-width:576px){.flex-sm-row{-ms-flex-direction:row!important;flex-direction:row!important}.flex-sm-column{-ms-flex-direction:column!important;flex-direction:column!important}.flex-sm-row-reverse{-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-sm-column-reverse{-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-sm-wrap{-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-sm-nowrap{-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-sm-wrap-reverse{-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.flex-sm-fill{-ms-flex:1 1 auto!important;flex:1 1 auto!important}.flex-sm-grow-0{-ms-flex-positive:0!important;flex-grow:0!important}.flex-sm-grow-1{-ms-flex-positive:1!important;flex-grow:1!important}.flex-sm-shrink-0{-ms-flex-negative:0!important;flex-shrink:0!important}.flex-sm-shrink-1{-ms-flex-negative:1!important;flex-shrink:1!important}.justify-content-sm-start{-ms-flex-pack:start!important;justify-content:flex-start!important}.justify-content-sm-end{-ms-flex-pack:end!important;justify-content:flex-end!important}.justify-content-sm-center{-ms-flex-pack:center!important;justify-content:center!important}.justify-content-sm-between{-ms-flex-pack:justify!important;justify-content:space-between!important}.justify-content-sm-around{-ms-flex-pack:distribute!important;justify-content:space-around!important}.align-items-sm-start{-ms-flex-align:start!important;align-items:flex-start!important}.align-items-sm-end{-ms-flex-align:end!important;align-items:flex-end!important}.align-items-sm-center{-ms-flex-align:center!important;align-items:center!important}.align-items-sm-baseline{-ms-flex-align:baseline!important;align-items:baseline!important}.align-items-sm-stretch{-ms-flex-align:stretch!important;align-items:stretch!important}.align-content-sm-start{-ms-flex-line-pack:start!important;align-content:flex-start!important}.align-content-sm-end{-ms-flex-line-pack:end!important;align-content:flex-end!important}.align-content-sm-center{-ms-flex-line-pack:center!important;align-content:center!important}.align-content-sm-between{-ms-flex-line-pack:justify!important;align-content:space-between!important}.align-content-sm-around{-ms-flex-line-pack:distribute!important;align-content:space-around!important}.align-content-sm-stretch{-ms-flex-line-pack:stretch!important;align-content:stretch!important}.align-self-sm-auto{-ms-flex-item-align:auto!important;align-self:auto!important}.align-self-sm-start{-ms-flex-item-align:start!important;align-self:flex-start!important}.align-self-sm-end{-ms-flex-item-align:end!important;align-self:flex-end!important}.align-self-sm-center{-ms-flex-item-align:center!important;align-self:center!important}.align-self-sm-baseline{-ms-flex-item-align:baseline!important;align-self:baseline!important}.align-self-sm-stretch{-ms-flex-item-align:stretch!important;align-self:stretch!important}}@media (min-width:768px){.flex-md-row{-ms-flex-direction:row!important;flex-direction:row!important}.flex-md-column{-ms-flex-direction:column!important;flex-direction:column!important}.flex-md-row-reverse{-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-md-column-reverse{-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-md-wrap{-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-md-nowrap{-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-md-wrap-reverse{-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.flex-md-fill{-ms-flex:1 1 auto!important;flex:1 1 auto!important}.flex-md-grow-0{-ms-flex-positive:0!important;flex-grow:0!important}.flex-md-grow-1{-ms-flex-positive:1!important;flex-grow:1!important}.flex-md-shrink-0{-ms-flex-negative:0!important;flex-shrink:0!important}.flex-md-shrink-1{-ms-flex-negative:1!important;flex-shrink:1!important}.justify-content-md-start{-ms-flex-pack:start!important;justify-content:flex-start!important}.justify-content-md-end{-ms-flex-pack:end!important;justify-content:flex-end!important}.justify-content-md-center{-ms-flex-pack:center!important;justify-content:center!important}.justify-content-md-between{-ms-flex-pack:justify!important;justify-content:space-between!important}.justify-content-md-around{-ms-flex-pack:distribute!important;justify-content:space-around!important}.align-items-md-start{-ms-flex-align:start!important;align-items:flex-start!important}.align-items-md-end{-ms-flex-align:end!important;align-items:flex-end!important}.align-items-md-center{-ms-flex-align:center!important;align-items:center!important}.align-items-md-baseline{-ms-flex-align:baseline!important;align-items:baseline!important}.align-items-md-stretch{-ms-flex-align:stretch!important;align-items:stretch!important}.align-content-md-start{-ms-flex-line-pack:start!important;align-content:flex-start!important}.align-content-md-end{-ms-flex-line-pack:end!important;align-content:flex-end!important}.align-content-md-center{-ms-flex-line-pack:center!important;align-content:center!important}.align-content-md-between{-ms-flex-line-pack:justify!important;align-content:space-between!important}.align-content-md-around{-ms-flex-line-pack:distribute!important;align-content:space-around!important}.align-content-md-stretch{-ms-flex-line-pack:stretch!important;align-content:stretch!important}.align-self-md-auto{-ms-flex-item-align:auto!important;align-self:auto!important}.align-self-md-start{-ms-flex-item-align:start!important;align-self:flex-start!important}.align-self-md-end{-ms-flex-item-align:end!important;align-self:flex-end!important}.align-self-md-center{-ms-flex-item-align:center!important;align-self:center!important}.align-self-md-baseline{-ms-flex-item-align:baseline!important;align-self:baseline!important}.align-self-md-stretch{-ms-flex-item-align:stretch!important;align-self:stretch!important}}@media (min-width:992px){.flex-lg-row{-ms-flex-direction:row!important;flex-direction:row!important}.flex-lg-column{-ms-flex-direction:column!important;flex-direction:column!important}.flex-lg-row-reverse{-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-lg-column-reverse{-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-lg-wrap{-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-lg-nowrap{-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-lg-wrap-reverse{-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.flex-lg-fill{-ms-flex:1 1 auto!important;flex:1 1 auto!important}.flex-lg-grow-0{-ms-flex-positive:0!important;flex-grow:0!important}.flex-lg-grow-1{-ms-flex-positive:1!important;flex-grow:1!important}.flex-lg-shrink-0{-ms-flex-negative:0!important;flex-shrink:0!important}.flex-lg-shrink-1{-ms-flex-negative:1!important;flex-shrink:1!important}.justify-content-lg-start{-ms-flex-pack:start!important;justify-content:flex-start!important}.justify-content-lg-end{-ms-flex-pack:end!important;justify-content:flex-end!important}.justify-content-lg-center{-ms-flex-pack:center!important;justify-content:center!important}.justify-content-lg-between{-ms-flex-pack:justify!important;justify-content:space-between!important}.justify-content-lg-around{-ms-flex-pack:distribute!important;justify-content:space-around!important}.align-items-lg-start{-ms-flex-align:start!important;align-items:flex-start!important}.align-items-lg-end{-ms-flex-align:end!important;align-items:flex-end!important}.align-items-lg-center{-ms-flex-align:center!important;align-items:center!important}.align-items-lg-baseline{-ms-flex-align:baseline!important;align-items:baseline!important}.align-items-lg-stretch{-ms-flex-align:stretch!important;align-items:stretch!important}.align-content-lg-start{-ms-flex-line-pack:start!important;align-content:flex-start!important}.align-content-lg-end{-ms-flex-line-pack:end!important;align-content:flex-end!important}.align-content-lg-center{-ms-flex-line-pack:center!important;align-content:center!important}.align-content-lg-between{-ms-flex-line-pack:justify!important;align-content:space-between!important}.align-content-lg-around{-ms-flex-line-pack:distribute!important;align-content:space-around!important}.align-content-lg-stretch{-ms-flex-line-pack:stretch!important;align-content:stretch!important}.align-self-lg-auto{-ms-flex-item-align:auto!important;align-self:auto!important}.align-self-lg-start{-ms-flex-item-align:start!important;align-self:flex-start!important}.align-self-lg-end{-ms-flex-item-align:end!important;align-self:flex-end!important}.align-self-lg-center{-ms-flex-item-align:center!important;align-self:center!important}.align-self-lg-baseline{-ms-flex-item-align:baseline!important;align-self:baseline!important}.align-self-lg-stretch{-ms-flex-item-align:stretch!important;align-self:stretch!important}}@media (min-width:1200px){.flex-xl-row{-ms-flex-direction:row!important;flex-direction:row!important}.flex-xl-column{-ms-flex-direction:column!important;flex-direction:column!important}.flex-xl-row-reverse{-ms-flex-direction:row-reverse!important;flex-direction:row-reverse!important}.flex-xl-column-reverse{-ms-flex-direction:column-reverse!important;flex-direction:column-reverse!important}.flex-xl-wrap{-ms-flex-wrap:wrap!important;flex-wrap:wrap!important}.flex-xl-nowrap{-ms-flex-wrap:nowrap!important;flex-wrap:nowrap!important}.flex-xl-wrap-reverse{-ms-flex-wrap:wrap-reverse!important;flex-wrap:wrap-reverse!important}.flex-xl-fill{-ms-flex:1 1 auto!important;flex:1 1 auto!important}.flex-xl-grow-0{-ms-flex-positive:0!important;flex-grow:0!important}.flex-xl-grow-1{-ms-flex-positive:1!important;flex-grow:1!important}.flex-xl-shrink-0{-ms-flex-negative:0!important;flex-shrink:0!important}.flex-xl-shrink-1{-ms-flex-negative:1!important;flex-shrink:1!important}.justify-content-xl-start{-ms-flex-pack:start!important;justify-content:flex-start!important}.justify-content-xl-end{-ms-flex-pack:end!important;justify-content:flex-end!important}.justify-content-xl-center{-ms-flex-pack:center!important;justify-content:center!important}.justify-content-xl-between{-ms-flex-pack:justify!important;justify-content:space-between!important}.justify-content-xl-around{-ms-flex-pack:distribute!important;justify-content:space-around!important}.align-items-xl-start{-ms-flex-align:start!important;align-items:flex-start!important}.align-items-xl-end{-ms-flex-align:end!important;align-items:flex-end!important}.align-items-xl-center{-ms-flex-align:center!important;align-items:center!important}.align-items-xl-baseline{-ms-flex-align:baseline!important;align-items:baseline!important}.align-items-xl-stretch{-ms-flex-align:stretch!important;align-items:stretch!important}.align-content-xl-start{-ms-flex-line-pack:start!important;align-content:flex-start!important}.align-content-xl-end{-ms-flex-line-pack:end!important;align-content:flex-end!important}.align-content-xl-center{-ms-flex-line-pack:center!important;align-content:center!important}.align-content-xl-between{-ms-flex-line-pack:justify!important;align-content:space-between!important}.align-content-xl-around{-ms-flex-line-pack:distribute!important;align-content:space-around!important}.align-content-xl-stretch{-ms-flex-line-pack:stretch!important;align-content:stretch!important}.align-self-xl-auto{-ms-flex-item-align:auto!important;align-self:auto!important}.align-self-xl-start{-ms-flex-item-align:start!important;align-self:flex-start!important}.align-self-xl-end{-ms-flex-item-align:end!important;align-self:flex-end!important}.align-self-xl-center{-ms-flex-item-align:center!important;align-self:center!important}.align-self-xl-baseline{-ms-flex-item-align:baseline!important;align-self:baseline!important}.align-self-xl-stretch{-ms-flex-item-align:stretch!important;align-self:stretch!important}}.float-left{float:left!important}.float-right{float:right!important}.float-none{float:none!important}@media (min-width:576px){.float-sm-left{float:left!important}.float-sm-right{float:right!important}.float-sm-none{float:none!important}}@media (min-width:768px){.float-md-left{float:left!important}.float-md-right{float:right!important}.float-md-none{float:none!important}}@media (min-width:992px){.float-lg-left{float:left!important}.float-lg-right{float:right!important}.float-lg-none{float:none!important}}@media (min-width:1200px){.float-xl-left{float:left!important}.float-xl-right{float:right!important}.float-xl-none{float:none!important}}.overflow-auto{overflow:auto!important}.overflow-hidden{overflow:hidden!important}.position-static{position:static!important}.position-relative{position:relative!important}.position-absolute{position:absolute!important}.position-fixed{position:fixed!important}.position-sticky{position:-webkit-sticky!important;position:sticky!important}.fixed-top{position:fixed;top:0;right:0;left:0;z-index:1030}.fixed-bottom{position:fixed;right:0;bottom:0;left:0;z-index:1030}@supports ((position:-webkit-sticky) or (position:sticky)){.sticky-top{position:-webkit-sticky;position:sticky;top:0;z-index:1020}}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;overflow:visible;clip:auto;white-space:normal}.shadow-sm{box-shadow:0 .125rem .25rem rgba(0,0,0,.075)!important}.shadow{box-shadow:0 .5rem 1rem rgba(0,0,0,.15)!important}.shadow-lg{box-shadow:0 1rem 3rem rgba(0,0,0,.175)!important}.shadow-none{box-shadow:none!important}.w-25{width:25%!important}.w-50{width:50%!important}.w-75{width:75%!important}.w-100{width:100%!important}.w-auto{width:auto!important}.h-25{height:25%!important}.h-50{height:50%!important}.h-75{height:75%!important}.h-100{height:100%!important}.h-auto{height:auto!important}.mw-100{max-width:100%!important}.mh-100{max-height:100%!important}.min-vw-100{min-width:100vw!important}.min-vh-100{min-height:100vh!important}.vw-100{width:100vw!important}.vh-100{height:100vh!important}.stretched-link::after{position:absolute;top:0;right:0;bottom:0;left:0;z-index:1;pointer-events:auto;content:"";background-color:rgba(0,0,0,0)}.m-0{margin:0!important}.mt-0,.my-0{margin-top:0!important}.mr-0,.mx-0{margin-right:0!important}.mb-0,.my-0{margin-bottom:0!important}.ml-0,.mx-0{margin-left:0!important}.m-1{margin:.25rem!important}.mt-1,.my-1{margin-top:.25rem!important}.mr-1,.mx-1{margin-right:.25rem!important}.mb-1,.my-1{margin-bottom:.25rem!important}.ml-1,.mx-1{margin-left:.25rem!important}.m-2{margin:.5rem!important}.mt-2,.my-2{margin-top:.5rem!important}.mr-2,.mx-2{margin-right:.5rem!important}.mb-2,.my-2{margin-bottom:.5rem!important}.ml-2,.mx-2{margin-left:.5rem!important}.m-3{margin:1rem!important}.mt-3,.my-3{margin-top:1rem!important}.mr-3,.mx-3{margin-right:1rem!important}.mb-3,.my-3{margin-bottom:1rem!important}.ml-3,.mx-3{margin-left:1rem!important}.m-4{margin:1.5rem!important}.mt-4,.my-4{margin-top:1.5rem!important}.mr-4,.mx-4{margin-right:1.5rem!important}.mb-4,.my-4{margin-bottom:1.5rem!important}.ml-4,.mx-4{margin-left:1.5rem!important}.m-5{margin:3rem!important}.mt-5,.my-5{margin-top:3rem!important}.mr-5,.mx-5{margin-right:3rem!important}.mb-5,.my-5{margin-bottom:3rem!important}.ml-5,.mx-5{margin-left:3rem!important}.p-0{padding:0!important}.pt-0,.py-0{padding-top:0!important}.pr-0,.px-0{padding-right:0!important}.pb-0,.py-0{padding-bottom:0!important}.pl-0,.px-0{padding-left:0!important}.p-1{padding:.25rem!important}.pt-1,.py-1{padding-top:.25rem!important}.pr-1,.px-1{padding-right:.25rem!important}.pb-1,.py-1{padding-bottom:.25rem!important}.pl-1,.px-1{padding-left:.25rem!important}.p-2{padding:.5rem!important}.pt-2,.py-2{padding-top:.5rem!important}.pr-2,.px-2{padding-right:.5rem!important}.pb-2,.py-2{padding-bottom:.5rem!important}.pl-2,.px-2{padding-left:.5rem!important}.p-3{padding:1rem!important}.pt-3,.py-3{padding-top:1rem!important}.pr-3,.px-3{padding-right:1rem!important}.pb-3,.py-3{padding-bottom:1rem!important}.pl-3,.px-3{padding-left:1rem!important}.p-4{padding:1.5rem!important}.pt-4,.py-4{padding-top:1.5rem!important}.pr-4,.px-4{padding-right:1.5rem!important}.pb-4,.py-4{padding-bottom:1.5rem!important}.pl-4,.px-4{padding-left:1.5rem!important}.p-5{padding:3rem!important}.pt-5,.py-5{padding-top:3rem!important}.pr-5,.px-5{padding-right:3rem!important}.pb-5,.py-5{padding-bottom:3rem!important}.pl-5,.px-5{padding-left:3rem!important}.m-n1{margin:-.25rem!important}.mt-n1,.my-n1{margin-top:-.25rem!important}.mr-n1,.mx-n1{margin-right:-.25rem!important}.mb-n1,.my-n1{margin-bottom:-.25rem!important}.ml-n1,.mx-n1{margin-left:-.25rem!important}.m-n2{margin:-.5rem!important}.mt-n2,.my-n2{margin-top:-.5rem!important}.mr-n2,.mx-n2{margin-right:-.5rem!important}.mb-n2,.my-n2{margin-bottom:-.5rem!important}.ml-n2,.mx-n2{margin-left:-.5rem!important}.m-n3{margin:-1rem!important}.mt-n3,.my-n3{margin-top:-1rem!important}.mr-n3,.mx-n3{margin-right:-1rem!important}.mb-n3,.my-n3{margin-bottom:-1rem!important}.ml-n3,.mx-n3{margin-left:-1rem!important}.m-n4{margin:-1.5rem!important}.mt-n4,.my-n4{margin-top:-1.5rem!important}.mr-n4,.mx-n4{margin-right:-1.5rem!important}.mb-n4,.my-n4{margin-bottom:-1.5rem!important}.ml-n4,.mx-n4{margin-left:-1.5rem!important}.m-n5{margin:-3rem!important}.mt-n5,.my-n5{margin-top:-3rem!important}.mr-n5,.mx-n5{margin-right:-3rem!important}.mb-n5,.my-n5{margin-bottom:-3rem!important}.ml-n5,.mx-n5{margin-left:-3rem!important}.m-auto{margin:auto!important}.mt-auto,.my-auto{margin-top:auto!important}.mr-auto,.mx-auto{margin-right:auto!important}.mb-auto,.my-auto{margin-bottom:auto!important}.ml-auto,.mx-auto{margin-left:auto!important}@media (min-width:576px){.m-sm-0{margin:0!important}.mt-sm-0,.my-sm-0{margin-top:0!important}.mr-sm-0,.mx-sm-0{margin-right:0!important}.mb-sm-0,.my-sm-0{margin-bottom:0!important}.ml-sm-0,.mx-sm-0{margin-left:0!important}.m-sm-1{margin:.25rem!important}.mt-sm-1,.my-sm-1{margin-top:.25rem!important}.mr-sm-1,.mx-sm-1{margin-right:.25rem!important}.mb-sm-1,.my-sm-1{margin-bottom:.25rem!important}.ml-sm-1,.mx-sm-1{margin-left:.25rem!important}.m-sm-2{margin:.5rem!important}.mt-sm-2,.my-sm-2{margin-top:.5rem!important}.mr-sm-2,.mx-sm-2{margin-right:.5rem!important}.mb-sm-2,.my-sm-2{margin-bottom:.5rem!important}.ml-sm-2,.mx-sm-2{margin-left:.5rem!important}.m-sm-3{margin:1rem!important}.mt-sm-3,.my-sm-3{margin-top:1rem!important}.mr-sm-3,.mx-sm-3{margin-right:1rem!important}.mb-sm-3,.my-sm-3{margin-bottom:1rem!important}.ml-sm-3,.mx-sm-3{margin-left:1rem!important}.m-sm-4{margin:1.5rem!important}.mt-sm-4,.my-sm-4{margin-top:1.5rem!important}.mr-sm-4,.mx-sm-4{margin-right:1.5rem!important}.mb-sm-4,.my-sm-4{margin-bottom:1.5rem!important}.ml-sm-4,.mx-sm-4{margin-left:1.5rem!important}.m-sm-5{margin:3rem!important}.mt-sm-5,.my-sm-5{margin-top:3rem!important}.mr-sm-5,.mx-sm-5{margin-right:3rem!important}.mb-sm-5,.my-sm-5{margin-bottom:3rem!important}.ml-sm-5,.mx-sm-5{margin-left:3rem!important}.p-sm-0{padding:0!important}.pt-sm-0,.py-sm-0{padding-top:0!important}.pr-sm-0,.px-sm-0{padding-right:0!important}.pb-sm-0,.py-sm-0{padding-bottom:0!important}.pl-sm-0,.px-sm-0{padding-left:0!important}.p-sm-1{padding:.25rem!important}.pt-sm-1,.py-sm-1{padding-top:.25rem!important}.pr-sm-1,.px-sm-1{padding-right:.25rem!important}.pb-sm-1,.py-sm-1{padding-bottom:.25rem!important}.pl-sm-1,.px-sm-1{padding-left:.25rem!important}.p-sm-2{padding:.5rem!important}.pt-sm-2,.py-sm-2{padding-top:.5rem!important}.pr-sm-2,.px-sm-2{padding-right:.5rem!important}.pb-sm-2,.py-sm-2{padding-bottom:.5rem!important}.pl-sm-2,.px-sm-2{padding-left:.5rem!important}.p-sm-3{padding:1rem!important}.pt-sm-3,.py-sm-3{padding-top:1rem!important}.pr-sm-3,.px-sm-3{padding-right:1rem!important}.pb-sm-3,.py-sm-3{padding-bottom:1rem!important}.pl-sm-3,.px-sm-3{padding-left:1rem!important}.p-sm-4{padding:1.5rem!important}.pt-sm-4,.py-sm-4{padding-top:1.5rem!important}.pr-sm-4,.px-sm-4{padding-right:1.5rem!important}.pb-sm-4,.py-sm-4{padding-bottom:1.5rem!important}.pl-sm-4,.px-sm-4{padding-left:1.5rem!important}.p-sm-5{padding:3rem!important}.pt-sm-5,.py-sm-5{padding-top:3rem!important}.pr-sm-5,.px-sm-5{padding-right:3rem!important}.pb-sm-5,.py-sm-5{padding-bottom:3rem!important}.pl-sm-5,.px-sm-5{padding-left:3rem!important}.m-sm-n1{margin:-.25rem!important}.mt-sm-n1,.my-sm-n1{margin-top:-.25rem!important}.mr-sm-n1,.mx-sm-n1{margin-right:-.25rem!important}.mb-sm-n1,.my-sm-n1{margin-bottom:-.25rem!important}.ml-sm-n1,.mx-sm-n1{margin-left:-.25rem!important}.m-sm-n2{margin:-.5rem!important}.mt-sm-n2,.my-sm-n2{margin-top:-.5rem!important}.mr-sm-n2,.mx-sm-n2{margin-right:-.5rem!important}.mb-sm-n2,.my-sm-n2{margin-bottom:-.5rem!important}.ml-sm-n2,.mx-sm-n2{margin-left:-.5rem!important}.m-sm-n3{margin:-1rem!important}.mt-sm-n3,.my-sm-n3{margin-top:-1rem!important}.mr-sm-n3,.mx-sm-n3{margin-right:-1rem!important}.mb-sm-n3,.my-sm-n3{margin-bottom:-1rem!important}.ml-sm-n3,.mx-sm-n3{margin-left:-1rem!important}.m-sm-n4{margin:-1.5rem!important}.mt-sm-n4,.my-sm-n4{margin-top:-1.5rem!important}.mr-sm-n4,.mx-sm-n4{margin-right:-1.5rem!important}.mb-sm-n4,.my-sm-n4{margin-bottom:-1.5rem!important}.ml-sm-n4,.mx-sm-n4{margin-left:-1.5rem!important}.m-sm-n5{margin:-3rem!important}.mt-sm-n5,.my-sm-n5{margin-top:-3rem!important}.mr-sm-n5,.mx-sm-n5{margin-right:-3rem!important}.mb-sm-n5,.my-sm-n5{margin-bottom:-3rem!important}.ml-sm-n5,.mx-sm-n5{margin-left:-3rem!important}.m-sm-auto{margin:auto!important}.mt-sm-auto,.my-sm-auto{margin-top:auto!important}.mr-sm-auto,.mx-sm-auto{margin-right:auto!important}.mb-sm-auto,.my-sm-auto{margin-bottom:auto!important}.ml-sm-auto,.mx-sm-auto{margin-left:auto!important}}@media (min-width:768px){.m-md-0{margin:0!important}.mt-md-0,.my-md-0{margin-top:0!important}.mr-md-0,.mx-md-0{margin-right:0!important}.mb-md-0,.my-md-0{margin-bottom:0!important}.ml-md-0,.mx-md-0{margin-left:0!important}.m-md-1{margin:.25rem!important}.mt-md-1,.my-md-1{margin-top:.25rem!important}.mr-md-1,.mx-md-1{margin-right:.25rem!important}.mb-md-1,.my-md-1{margin-bottom:.25rem!important}.ml-md-1,.mx-md-1{margin-left:.25rem!important}.m-md-2{margin:.5rem!important}.mt-md-2,.my-md-2{margin-top:.5rem!important}.mr-md-2,.mx-md-2{margin-right:.5rem!important}.mb-md-2,.my-md-2{margin-bottom:.5rem!important}.ml-md-2,.mx-md-2{margin-left:.5rem!important}.m-md-3{margin:1rem!important}.mt-md-3,.my-md-3{margin-top:1rem!important}.mr-md-3,.mx-md-3{margin-right:1rem!important}.mb-md-3,.my-md-3{margin-bottom:1rem!important}.ml-md-3,.mx-md-3{margin-left:1rem!important}.m-md-4{margin:1.5rem!important}.mt-md-4,.my-md-4{margin-top:1.5rem!important}.mr-md-4,.mx-md-4{margin-right:1.5rem!important}.mb-md-4,.my-md-4{margin-bottom:1.5rem!important}.ml-md-4,.mx-md-4{margin-left:1.5rem!important}.m-md-5{margin:3rem!important}.mt-md-5,.my-md-5{margin-top:3rem!important}.mr-md-5,.mx-md-5{margin-right:3rem!important}.mb-md-5,.my-md-5{margin-bottom:3rem!important}.ml-md-5,.mx-md-5{margin-left:3rem!important}.p-md-0{padding:0!important}.pt-md-0,.py-md-0{padding-top:0!important}.pr-md-0,.px-md-0{padding-right:0!important}.pb-md-0,.py-md-0{padding-bottom:0!important}.pl-md-0,.px-md-0{padding-left:0!important}.p-md-1{padding:.25rem!important}.pt-md-1,.py-md-1{padding-top:.25rem!important}.pr-md-1,.px-md-1{padding-right:.25rem!important}.pb-md-1,.py-md-1{padding-bottom:.25rem!important}.pl-md-1,.px-md-1{padding-left:.25rem!important}.p-md-2{padding:.5rem!important}.pt-md-2,.py-md-2{padding-top:.5rem!important}.pr-md-2,.px-md-2{padding-right:.5rem!important}.pb-md-2,.py-md-2{padding-bottom:.5rem!important}.pl-md-2,.px-md-2{padding-left:.5rem!important}.p-md-3{padding:1rem!important}.pt-md-3,.py-md-3{padding-top:1rem!important}.pr-md-3,.px-md-3{padding-right:1rem!important}.pb-md-3,.py-md-3{padding-bottom:1rem!important}.pl-md-3,.px-md-3{padding-left:1rem!important}.p-md-4{padding:1.5rem!important}.pt-md-4,.py-md-4{padding-top:1.5rem!important}.pr-md-4,.px-md-4{padding-right:1.5rem!important}.pb-md-4,.py-md-4{padding-bottom:1.5rem!important}.pl-md-4,.px-md-4{padding-left:1.5rem!important}.p-md-5{padding:3rem!important}.pt-md-5,.py-md-5{padding-top:3rem!important}.pr-md-5,.px-md-5{padding-right:3rem!important}.pb-md-5,.py-md-5{padding-bottom:3rem!important}.pl-md-5,.px-md-5{padding-left:3rem!important}.m-md-n1{margin:-.25rem!important}.mt-md-n1,.my-md-n1{margin-top:-.25rem!important}.mr-md-n1,.mx-md-n1{margin-right:-.25rem!important}.mb-md-n1,.my-md-n1{margin-bottom:-.25rem!important}.ml-md-n1,.mx-md-n1{margin-left:-.25rem!important}.m-md-n2{margin:-.5rem!important}.mt-md-n2,.my-md-n2{margin-top:-.5rem!important}.mr-md-n2,.mx-md-n2{margin-right:-.5rem!important}.mb-md-n2,.my-md-n2{margin-bottom:-.5rem!important}.ml-md-n2,.mx-md-n2{margin-left:-.5rem!important}.m-md-n3{margin:-1rem!important}.mt-md-n3,.my-md-n3{margin-top:-1rem!important}.mr-md-n3,.mx-md-n3{margin-right:-1rem!important}.mb-md-n3,.my-md-n3{margin-bottom:-1rem!important}.ml-md-n3,.mx-md-n3{margin-left:-1rem!important}.m-md-n4{margin:-1.5rem!important}.mt-md-n4,.my-md-n4{margin-top:-1.5rem!important}.mr-md-n4,.mx-md-n4{margin-right:-1.5rem!important}.mb-md-n4,.my-md-n4{margin-bottom:-1.5rem!important}.ml-md-n4,.mx-md-n4{margin-left:-1.5rem!important}.m-md-n5{margin:-3rem!important}.mt-md-n5,.my-md-n5{margin-top:-3rem!important}.mr-md-n5,.mx-md-n5{margin-right:-3rem!important}.mb-md-n5,.my-md-n5{margin-bottom:-3rem!important}.ml-md-n5,.mx-md-n5{margin-left:-3rem!important}.m-md-auto{margin:auto!important}.mt-md-auto,.my-md-auto{margin-top:auto!important}.mr-md-auto,.mx-md-auto{margin-right:auto!important}.mb-md-auto,.my-md-auto{margin-bottom:auto!important}.ml-md-auto,.mx-md-auto{margin-left:auto!important}}@media (min-width:992px){.m-lg-0{margin:0!important}.mt-lg-0,.my-lg-0{margin-top:0!important}.mr-lg-0,.mx-lg-0{margin-right:0!important}.mb-lg-0,.my-lg-0{margin-bottom:0!important}.ml-lg-0,.mx-lg-0{margin-left:0!important}.m-lg-1{margin:.25rem!important}.mt-lg-1,.my-lg-1{margin-top:.25rem!important}.mr-lg-1,.mx-lg-1{margin-right:.25rem!important}.mb-lg-1,.my-lg-1{margin-bottom:.25rem!important}.ml-lg-1,.mx-lg-1{margin-left:.25rem!important}.m-lg-2{margin:.5rem!important}.mt-lg-2,.my-lg-2{margin-top:.5rem!important}.mr-lg-2,.mx-lg-2{margin-right:.5rem!important}.mb-lg-2,.my-lg-2{margin-bottom:.5rem!important}.ml-lg-2,.mx-lg-2{margin-left:.5rem!important}.m-lg-3{margin:1rem!important}.mt-lg-3,.my-lg-3{margin-top:1rem!important}.mr-lg-3,.mx-lg-3{margin-right:1rem!important}.mb-lg-3,.my-lg-3{margin-bottom:1rem!important}.ml-lg-3,.mx-lg-3{margin-left:1rem!important}.m-lg-4{margin:1.5rem!important}.mt-lg-4,.my-lg-4{margin-top:1.5rem!important}.mr-lg-4,.mx-lg-4{margin-right:1.5rem!important}.mb-lg-4,.my-lg-4{margin-bottom:1.5rem!important}.ml-lg-4,.mx-lg-4{margin-left:1.5rem!important}.m-lg-5{margin:3rem!important}.mt-lg-5,.my-lg-5{margin-top:3rem!important}.mr-lg-5,.mx-lg-5{margin-right:3rem!important}.mb-lg-5,.my-lg-5{margin-bottom:3rem!important}.ml-lg-5,.mx-lg-5{margin-left:3rem!important}.p-lg-0{padding:0!important}.pt-lg-0,.py-lg-0{padding-top:0!important}.pr-lg-0,.px-lg-0{padding-right:0!important}.pb-lg-0,.py-lg-0{padding-bottom:0!important}.pl-lg-0,.px-lg-0{padding-left:0!important}.p-lg-1{padding:.25rem!important}.pt-lg-1,.py-lg-1{padding-top:.25rem!important}.pr-lg-1,.px-lg-1{padding-right:.25rem!important}.pb-lg-1,.py-lg-1{padding-bottom:.25rem!important}.pl-lg-1,.px-lg-1{padding-left:.25rem!important}.p-lg-2{padding:.5rem!important}.pt-lg-2,.py-lg-2{padding-top:.5rem!important}.pr-lg-2,.px-lg-2{padding-right:.5rem!important}.pb-lg-2,.py-lg-2{padding-bottom:.5rem!important}.pl-lg-2,.px-lg-2{padding-left:.5rem!important}.p-lg-3{padding:1rem!important}.pt-lg-3,.py-lg-3{padding-top:1rem!important}.pr-lg-3,.px-lg-3{padding-right:1rem!important}.pb-lg-3,.py-lg-3{padding-bottom:1rem!important}.pl-lg-3,.px-lg-3{padding-left:1rem!important}.p-lg-4{padding:1.5rem!important}.pt-lg-4,.py-lg-4{padding-top:1.5rem!important}.pr-lg-4,.px-lg-4{padding-right:1.5rem!important}.pb-lg-4,.py-lg-4{padding-bottom:1.5rem!important}.pl-lg-4,.px-lg-4{padding-left:1.5rem!important}.p-lg-5{padding:3rem!important}.pt-lg-5,.py-lg-5{padding-top:3rem!important}.pr-lg-5,.px-lg-5{padding-right:3rem!important}.pb-lg-5,.py-lg-5{padding-bottom:3rem!important}.pl-lg-5,.px-lg-5{padding-left:3rem!important}.m-lg-n1{margin:-.25rem!important}.mt-lg-n1,.my-lg-n1{margin-top:-.25rem!important}.mr-lg-n1,.mx-lg-n1{margin-right:-.25rem!important}.mb-lg-n1,.my-lg-n1{margin-bottom:-.25rem!important}.ml-lg-n1,.mx-lg-n1{margin-left:-.25rem!important}.m-lg-n2{margin:-.5rem!important}.mt-lg-n2,.my-lg-n2{margin-top:-.5rem!important}.mr-lg-n2,.mx-lg-n2{margin-right:-.5rem!important}.mb-lg-n2,.my-lg-n2{margin-bottom:-.5rem!important}.ml-lg-n2,.mx-lg-n2{margin-left:-.5rem!important}.m-lg-n3{margin:-1rem!important}.mt-lg-n3,.my-lg-n3{margin-top:-1rem!important}.mr-lg-n3,.mx-lg-n3{margin-right:-1rem!important}.mb-lg-n3,.my-lg-n3{margin-bottom:-1rem!important}.ml-lg-n3,.mx-lg-n3{margin-left:-1rem!important}.m-lg-n4{margin:-1.5rem!important}.mt-lg-n4,.my-lg-n4{margin-top:-1.5rem!important}.mr-lg-n4,.mx-lg-n4{margin-right:-1.5rem!important}.mb-lg-n4,.my-lg-n4{margin-bottom:-1.5rem!important}.ml-lg-n4,.mx-lg-n4{margin-left:-1.5rem!important}.m-lg-n5{margin:-3rem!important}.mt-lg-n5,.my-lg-n5{margin-top:-3rem!important}.mr-lg-n5,.mx-lg-n5{margin-right:-3rem!important}.mb-lg-n5,.my-lg-n5{margin-bottom:-3rem!important}.ml-lg-n5,.mx-lg-n5{margin-left:-3rem!important}.m-lg-auto{margin:auto!important}.mt-lg-auto,.my-lg-auto{margin-top:auto!important}.mr-lg-auto,.mx-lg-auto{margin-right:auto!important}.mb-lg-auto,.my-lg-auto{margin-bottom:auto!important}.ml-lg-auto,.mx-lg-auto{margin-left:auto!important}}@media (min-width:1200px){.m-xl-0{margin:0!important}.mt-xl-0,.my-xl-0{margin-top:0!important}.mr-xl-0,.mx-xl-0{margin-right:0!important}.mb-xl-0,.my-xl-0{margin-bottom:0!important}.ml-xl-0,.mx-xl-0{margin-left:0!important}.m-xl-1{margin:.25rem!important}.mt-xl-1,.my-xl-1{margin-top:.25rem!important}.mr-xl-1,.mx-xl-1{margin-right:.25rem!important}.mb-xl-1,.my-xl-1{margin-bottom:.25rem!important}.ml-xl-1,.mx-xl-1{margin-left:.25rem!important}.m-xl-2{margin:.5rem!important}.mt-xl-2,.my-xl-2{margin-top:.5rem!important}.mr-xl-2,.mx-xl-2{margin-right:.5rem!important}.mb-xl-2,.my-xl-2{margin-bottom:.5rem!important}.ml-xl-2,.mx-xl-2{margin-left:.5rem!important}.m-xl-3{margin:1rem!important}.mt-xl-3,.my-xl-3{margin-top:1rem!important}.mr-xl-3,.mx-xl-3{margin-right:1rem!important}.mb-xl-3,.my-xl-3{margin-bottom:1rem!important}.ml-xl-3,.mx-xl-3{margin-left:1rem!important}.m-xl-4{margin:1.5rem!important}.mt-xl-4,.my-xl-4{margin-top:1.5rem!important}.mr-xl-4,.mx-xl-4{margin-right:1.5rem!important}.mb-xl-4,.my-xl-4{margin-bottom:1.5rem!important}.ml-xl-4,.mx-xl-4{margin-left:1.5rem!important}.m-xl-5{margin:3rem!important}.mt-xl-5,.my-xl-5{margin-top:3rem!important}.mr-xl-5,.mx-xl-5{margin-right:3rem!important}.mb-xl-5,.my-xl-5{margin-bottom:3rem!important}.ml-xl-5,.mx-xl-5{margin-left:3rem!important}.p-xl-0{padding:0!important}.pt-xl-0,.py-xl-0{padding-top:0!important}.pr-xl-0,.px-xl-0{padding-right:0!important}.pb-xl-0,.py-xl-0{padding-bottom:0!important}.pl-xl-0,.px-xl-0{padding-left:0!important}.p-xl-1{padding:.25rem!important}.pt-xl-1,.py-xl-1{padding-top:.25rem!important}.pr-xl-1,.px-xl-1{padding-right:.25rem!important}.pb-xl-1,.py-xl-1{padding-bottom:.25rem!important}.pl-xl-1,.px-xl-1{padding-left:.25rem!important}.p-xl-2{padding:.5rem!important}.pt-xl-2,.py-xl-2{padding-top:.5rem!important}.pr-xl-2,.px-xl-2{padding-right:.5rem!important}.pb-xl-2,.py-xl-2{padding-bottom:.5rem!important}.pl-xl-2,.px-xl-2{padding-left:.5rem!important}.p-xl-3{padding:1rem!important}.pt-xl-3,.py-xl-3{padding-top:1rem!important}.pr-xl-3,.px-xl-3{padding-right:1rem!important}.pb-xl-3,.py-xl-3{padding-bottom:1rem!important}.pl-xl-3,.px-xl-3{padding-left:1rem!important}.p-xl-4{padding:1.5rem!important}.pt-xl-4,.py-xl-4{padding-top:1.5rem!important}.pr-xl-4,.px-xl-4{padding-right:1.5rem!important}.pb-xl-4,.py-xl-4{padding-bottom:1.5rem!important}.pl-xl-4,.px-xl-4{padding-left:1.5rem!important}.p-xl-5{padding:3rem!important}.pt-xl-5,.py-xl-5{padding-top:3rem!important}.pr-xl-5,.px-xl-5{padding-right:3rem!important}.pb-xl-5,.py-xl-5{padding-bottom:3rem!important}.pl-xl-5,.px-xl-5{padding-left:3rem!important}.m-xl-n1{margin:-.25rem!important}.mt-xl-n1,.my-xl-n1{margin-top:-.25rem!important}.mr-xl-n1,.mx-xl-n1{margin-right:-.25rem!important}.mb-xl-n1,.my-xl-n1{margin-bottom:-.25rem!important}.ml-xl-n1,.mx-xl-n1{margin-left:-.25rem!important}.m-xl-n2{margin:-.5rem!important}.mt-xl-n2,.my-xl-n2{margin-top:-.5rem!important}.mr-xl-n2,.mx-xl-n2{margin-right:-.5rem!important}.mb-xl-n2,.my-xl-n2{margin-bottom:-.5rem!important}.ml-xl-n2,.mx-xl-n2{margin-left:-.5rem!important}.m-xl-n3{margin:-1rem!important}.mt-xl-n3,.my-xl-n3{margin-top:-1rem!important}.mr-xl-n3,.mx-xl-n3{margin-right:-1rem!important}.mb-xl-n3,.my-xl-n3{margin-bottom:-1rem!important}.ml-xl-n3,.mx-xl-n3{margin-left:-1rem!important}.m-xl-n4{margin:-1.5rem!important}.mt-xl-n4,.my-xl-n4{margin-top:-1.5rem!important}.mr-xl-n4,.mx-xl-n4{margin-right:-1.5rem!important}.mb-xl-n4,.my-xl-n4{margin-bottom:-1.5rem!important}.ml-xl-n4,.mx-xl-n4{margin-left:-1.5rem!important}.m-xl-n5{margin:-3rem!important}.mt-xl-n5,.my-xl-n5{margin-top:-3rem!important}.mr-xl-n5,.mx-xl-n5{margin-right:-3rem!important}.mb-xl-n5,.my-xl-n5{margin-bottom:-3rem!important}.ml-xl-n5,.mx-xl-n5{margin-left:-3rem!important}.m-xl-auto{margin:auto!important}.mt-xl-auto,.my-xl-auto{margin-top:auto!important}.mr-xl-auto,.mx-xl-auto{margin-right:auto!important}.mb-xl-auto,.my-xl-auto{margin-bottom:auto!important}.ml-xl-auto,.mx-xl-auto{margin-left:auto!important}}.text-monospace{font-family:SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace!important}.text-justify{text-align:justify!important}.text-wrap{white-space:normal!important}.text-nowrap{white-space:nowrap!important}.text-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.text-left{text-align:left!important}.text-right{text-align:right!important}.text-center{text-align:center!important}@media (min-width:576px){.text-sm-left{text-align:left!important}.text-sm-right{text-align:right!important}.text-sm-center{text-align:center!important}}@media (min-width:768px){.text-md-left{text-align:left!important}.text-md-right{text-align:right!important}.text-md-center{text-align:center!important}}@media (min-width:992px){.text-lg-left{text-align:left!important}.text-lg-right{text-align:right!important}.text-lg-center{text-align:center!important}}@media (min-width:1200px){.text-xl-left{text-align:left!important}.text-xl-right{text-align:right!important}.text-xl-center{text-align:center!important}}.text-lowercase{text-transform:lowercase!important}.text-uppercase{text-transform:uppercase!important}.text-capitalize{text-transform:capitalize!important}.font-weight-light{font-weight:300!important}.font-weight-lighter{font-weight:lighter!important}.font-weight-normal{font-weight:400!important}.font-weight-bold{font-weight:700!important}.font-weight-bolder{font-weight:bolder!important}.font-italic{font-style:italic!important}.text-white{color:#fff!important}.text-primary{color:#007bff!important}a.text-primary:focus,a.text-primary:hover{color:#0056b3!important}.text-secondary{color:#6c757d!important}a.text-secondary:focus,a.text-secondary:hover{color:#494f54!important}.text-success{color:#28a745!important}a.text-success:focus,a.text-success:hover{color:#19692c!important}.text-info{color:#17a2b8!important}a.text-info:focus,a.text-info:hover{color:#0f6674!important}.text-warning{color:#ffc107!important}a.text-warning:focus,a.text-warning:hover{color:#ba8b00!important}.text-danger{color:#dc3545!important}a.text-danger:focus,a.text-danger:hover{color:#a71d2a!important}.text-light{color:#f8f9fa!important}a.text-light:focus,a.text-light:hover{color:#cbd3da!important}.text-dark{color:#343a40!important}a.text-dark:focus,a.text-dark:hover{color:#121416!important}.text-body{color:#212529!important}.text-muted{color:#6c757d!important}.text-black-50{color:rgba(0,0,0,.5)!important}.text-white-50{color:rgba(255,255,255,.5)!important}.text-hide{font:0/0 a;color:transparent;text-shadow:none;background-color:transparent;border:0}.text-decoration-none{text-decoration:none!important}.text-break{word-break:break-word!important;overflow-wrap:break-word!important}.text-reset{color:inherit!important}.visible{visibility:visible!important}.invisible{visibility:hidden!important}@media print{*,::after,::before{text-shadow:none!important;box-shadow:none!important}a:not(.btn){text-decoration:underline}abbr[title]::after{content:" (" attr(title) ")"}pre{white-space:pre-wrap!important}blockquote,pre{border:1px solid #adb5bd;page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}h2,h3,p{orphans:3;widows:3}h2,h3{page-break-after:avoid}@page{size:a3}body{min-width:992px!important}.container{min-width:992px!important}.navbar{display:none}.badge{border:1px solid #000}.table{border-collapse:collapse!important}.table td,.table th{background-color:#fff!important}.table-bordered td,.table-bordered th{border:1px solid #dee2e6!important}.table-dark{color:inherit}.table-dark tbody+tbody,.table-dark td,.table-dark th,.table-dark thead th{border-color:#dee2e6}.table .thead-dark th{color:inherit;border-color:#dee2e6}} /*# sourceMappingURL=bootstrap.min.css.map */rclone-v1.71.0/docs/static/css/custom.css000066400000000000000000000073411505210326400203060ustar00rootroot00000000000000body { font-family: "Open Sans","Helvetica Neue",Helvetica,Arial,sans-serif; } btn-group.a { color: #000000; } a { color: #3f79ad; text-decoration: none; } a:hover { color: #70caf2; } table { background-color:#f0f0f0; } tbody td, th { border: 1px solid #c0c0c0; padding: 3px 7px 2px 7px; } thead td, th { padding: 3px 7px 2px 7px; font-weight: bold; background-color:#e0e0e0; } tbody tr:nth-child(even) { background-color:#e8e8e8; } /* Preserve whitespace. Wrap text only at line breaks. */ /* Avoids auto-wrapping the code lines. */ pre code { white-space: pre } /* Hover over links on headers */ .header-link { position: absolute; left: -0.5em; opacity: 0; transition: opacity 0.2s ease-in-out 0.1s; } h2:hover .header-link, h3:hover .header-link, h4:hover .header-link, h5:hover .header-link, h6:hover .header-link { opacity: 1; } /* more space before headings */ h1, h2, h3, h4, h5, h6 { margin-top: 12px; padding: 15px 0px; } /* Fix spacing of info boxes */ .card { margin-top: 0.5rem; } /* less padding on titles */ .card-header { padding: 5px 15px; } /* less padding around info box items */ .card-body { padding: 0px; } /* more padding around info box items */ .card-body-padded { padding: 10px 10px 10px 10px; } /* make menus longer */ .pre-scrollable { max-height: 30rem; } /* Fix spacing between menu items */ /* .navbar-default .dropdown-menu>li>a { */ /* padding-top: 6px; */ /* padding-bottom: 6px; */ /* } */ /* custom logo in navbar */ .rclone-logo { height: 36px; margin-top: -10px; margin-bottom: -10px; } .heart { color: #e31b23; } blockquote { display: block; background-color: #EEE; padding: 0.25rem; border: 1px solid black; } pre { padding: 10px; margin: 0 0 10.5px; font-size: 14px; line-height: 1.42857143; word-break: break-all; word-wrap: break-word; color: #333333; background-color: #f5f5f5; border: 1px solid #cccccc; border-radius: 0.25rem; } code { font-size: 87.5%; color: #e83e8c; word-wrap: break-word; } /* reduce h12345 sizes */ h1 { font-size: 160%; } h2 { font-size: 130%; } h3 { font-size: 110%; font-weight: bold; } h4 { font-size: 100%; font-weight: bold; } h5 { font-size: 90%; font-weight: bold; } .menu { font-size: 95%; } .container-fluid { padding-left: 2.2rem !important; padding-right: 2.2rem !important; } /* Make primary buttons rclone colours. Should learn sass and do this the proper way! */ .btn-primary { background-color: #3f79ad; border-color: #3f79ad; } .btn-primary:hover { background-color: #70caf2; border-color: #70caf2; } .btn-primary:not(:disabled):not(.disabled).active, .btn-primary:not(:disabled):not(.disabled):active, .show>.btn-primary.dropdown-toggle { background-color: #70caf2; border-color: #70caf2; } .btn-primary.focus, .btn-primary:focus { background-color: #3f79ad; border-color: #3f79ad; box-shadow: 0 0 0 0.2rem rgba(63,121,173,.5); } .badge-primary { background-color: #3f79ad; border-color: #3f79ad; } a.badge-primary:focus, a.badge-primary:hover { background-color: #70caf2; } a.badge-primary.focus, a.badge-primary:focus { outline: 0; box-shadow: 0 0 0 0.2rem rgba(112,202,242,.5); } .bizbutton { background-color:#fb7a20; border-radius: 15px; padding: 5px; } .bizbutton:hover { /* background-color:#f29870; */ /* border-color:#f29870; */ background-color: #70caf2; border-color: #70caf2; } nav#TableOfContents ul { list-style-type: none; padding: 0.0rem; margin: 0rem 0.5rem 0rem 0.5rem; font-size: 90%; white-space: nowrap; overflow: hidden; } nav#TableOfContents ul:hover { overflow: visible; } rclone-v1.71.0/docs/static/fontawesome/000077500000000000000000000000001505210326400200145ustar00rootroot00000000000000rclone-v1.71.0/docs/static/fontawesome/css/000077500000000000000000000000001505210326400206045ustar00rootroot00000000000000rclone-v1.71.0/docs/static/fontawesome/css/brands.min.css000066400000000000000000000343561505210326400233640ustar00rootroot00000000000000/*! * Font Awesome Free 6.7.1 by @fontawesome - https://fontawesome.com * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) * Copyright 2024 Fonticons, Inc. */ :host,:root{--fa-style-family-brands:"Font Awesome 6 Brands";--fa-font-brands:normal 400 1em/1 "Font Awesome 6 Brands"}@font-face{font-family:"Font Awesome 6 Brands";font-style:normal;font-weight:400;font-display:block;src:url(../webfonts/fa-brands-400.woff2) format("woff2"),url(../webfonts/fa-brands-400.ttf) format("truetype")}.fa-brands,.fab{font-weight:400}.fa-monero{--fa:"\f3d0"}.fa-hooli{--fa:"\f427"}.fa-yelp{--fa:"\f1e9"}.fa-cc-visa{--fa:"\f1f0"}.fa-lastfm{--fa:"\f202"}.fa-shopware{--fa:"\f5b5"}.fa-creative-commons-nc{--fa:"\f4e8"}.fa-aws{--fa:"\f375"}.fa-redhat{--fa:"\f7bc"}.fa-yoast{--fa:"\f2b1"}.fa-cloudflare{--fa:"\e07d"}.fa-ups{--fa:"\f7e0"}.fa-pixiv{--fa:"\e640"}.fa-wpexplorer{--fa:"\f2de"}.fa-dyalog{--fa:"\f399"}.fa-bity{--fa:"\f37a"}.fa-stackpath{--fa:"\f842"}.fa-buysellads{--fa:"\f20d"}.fa-first-order{--fa:"\f2b0"}.fa-modx{--fa:"\f285"}.fa-guilded{--fa:"\e07e"}.fa-vnv{--fa:"\f40b"}.fa-js-square,.fa-square-js{--fa:"\f3b9"}.fa-microsoft{--fa:"\f3ca"}.fa-qq{--fa:"\f1d6"}.fa-orcid{--fa:"\f8d2"}.fa-java{--fa:"\f4e4"}.fa-invision{--fa:"\f7b0"}.fa-creative-commons-pd-alt{--fa:"\f4ed"}.fa-centercode{--fa:"\f380"}.fa-glide-g{--fa:"\f2a6"}.fa-drupal{--fa:"\f1a9"}.fa-jxl{--fa:"\e67b"}.fa-dart-lang{--fa:"\e693"}.fa-hire-a-helper{--fa:"\f3b0"}.fa-creative-commons-by{--fa:"\f4e7"}.fa-unity{--fa:"\e049"}.fa-whmcs{--fa:"\f40d"}.fa-rocketchat{--fa:"\f3e8"}.fa-vk{--fa:"\f189"}.fa-untappd{--fa:"\f405"}.fa-mailchimp{--fa:"\f59e"}.fa-css3-alt{--fa:"\f38b"}.fa-reddit-square,.fa-square-reddit{--fa:"\f1a2"}.fa-vimeo-v{--fa:"\f27d"}.fa-contao{--fa:"\f26d"}.fa-square-font-awesome{--fa:"\e5ad"}.fa-deskpro{--fa:"\f38f"}.fa-brave{--fa:"\e63c"}.fa-sistrix{--fa:"\f3ee"}.fa-instagram-square,.fa-square-instagram{--fa:"\e055"}.fa-battle-net{--fa:"\f835"}.fa-the-red-yeti{--fa:"\f69d"}.fa-hacker-news-square,.fa-square-hacker-news{--fa:"\f3af"}.fa-edge{--fa:"\f282"}.fa-threads{--fa:"\e618"}.fa-napster{--fa:"\f3d2"}.fa-snapchat-square,.fa-square-snapchat{--fa:"\f2ad"}.fa-google-plus-g{--fa:"\f0d5"}.fa-artstation{--fa:"\f77a"}.fa-markdown{--fa:"\f60f"}.fa-sourcetree{--fa:"\f7d3"}.fa-google-plus{--fa:"\f2b3"}.fa-diaspora{--fa:"\f791"}.fa-foursquare{--fa:"\f180"}.fa-stack-overflow{--fa:"\f16c"}.fa-github-alt{--fa:"\f113"}.fa-phoenix-squadron{--fa:"\f511"}.fa-pagelines{--fa:"\f18c"}.fa-algolia{--fa:"\f36c"}.fa-red-river{--fa:"\f3e3"}.fa-creative-commons-sa{--fa:"\f4ef"}.fa-safari{--fa:"\f267"}.fa-google{--fa:"\f1a0"}.fa-font-awesome-alt,.fa-square-font-awesome-stroke{--fa:"\f35c"}.fa-atlassian{--fa:"\f77b"}.fa-linkedin-in{--fa:"\f0e1"}.fa-digital-ocean{--fa:"\f391"}.fa-nimblr{--fa:"\f5a8"}.fa-chromecast{--fa:"\f838"}.fa-evernote{--fa:"\f839"}.fa-hacker-news{--fa:"\f1d4"}.fa-creative-commons-sampling{--fa:"\f4f0"}.fa-adversal{--fa:"\f36a"}.fa-creative-commons{--fa:"\f25e"}.fa-watchman-monitoring{--fa:"\e087"}.fa-fonticons{--fa:"\f280"}.fa-weixin{--fa:"\f1d7"}.fa-shirtsinbulk{--fa:"\f214"}.fa-codepen{--fa:"\f1cb"}.fa-git-alt{--fa:"\f841"}.fa-lyft{--fa:"\f3c3"}.fa-rev{--fa:"\f5b2"}.fa-windows{--fa:"\f17a"}.fa-wizards-of-the-coast{--fa:"\f730"}.fa-square-viadeo,.fa-viadeo-square{--fa:"\f2aa"}.fa-meetup{--fa:"\f2e0"}.fa-centos{--fa:"\f789"}.fa-adn{--fa:"\f170"}.fa-cloudsmith{--fa:"\f384"}.fa-opensuse{--fa:"\e62b"}.fa-pied-piper-alt{--fa:"\f1a8"}.fa-dribbble-square,.fa-square-dribbble{--fa:"\f397"}.fa-codiepie{--fa:"\f284"}.fa-node{--fa:"\f419"}.fa-mix{--fa:"\f3cb"}.fa-steam{--fa:"\f1b6"}.fa-cc-apple-pay{--fa:"\f416"}.fa-scribd{--fa:"\f28a"}.fa-debian{--fa:"\e60b"}.fa-openid{--fa:"\f19b"}.fa-instalod{--fa:"\e081"}.fa-files-pinwheel{--fa:"\e69f"}.fa-expeditedssl{--fa:"\f23e"}.fa-sellcast{--fa:"\f2da"}.fa-square-twitter,.fa-twitter-square{--fa:"\f081"}.fa-r-project{--fa:"\f4f7"}.fa-delicious{--fa:"\f1a5"}.fa-freebsd{--fa:"\f3a4"}.fa-vuejs{--fa:"\f41f"}.fa-accusoft{--fa:"\f369"}.fa-ioxhost{--fa:"\f208"}.fa-fonticons-fi{--fa:"\f3a2"}.fa-app-store{--fa:"\f36f"}.fa-cc-mastercard{--fa:"\f1f1"}.fa-itunes-note{--fa:"\f3b5"}.fa-golang{--fa:"\e40f"}.fa-kickstarter,.fa-square-kickstarter{--fa:"\f3bb"}.fa-grav{--fa:"\f2d6"}.fa-weibo{--fa:"\f18a"}.fa-uncharted{--fa:"\e084"}.fa-firstdraft{--fa:"\f3a1"}.fa-square-youtube,.fa-youtube-square{--fa:"\f431"}.fa-wikipedia-w{--fa:"\f266"}.fa-rendact,.fa-wpressr{--fa:"\f3e4"}.fa-angellist{--fa:"\f209"}.fa-galactic-republic{--fa:"\f50c"}.fa-nfc-directional{--fa:"\e530"}.fa-skype{--fa:"\f17e"}.fa-joget{--fa:"\f3b7"}.fa-fedora{--fa:"\f798"}.fa-stripe-s{--fa:"\f42a"}.fa-meta{--fa:"\e49b"}.fa-laravel{--fa:"\f3bd"}.fa-hotjar{--fa:"\f3b1"}.fa-bluetooth-b{--fa:"\f294"}.fa-square-letterboxd{--fa:"\e62e"}.fa-sticker-mule{--fa:"\f3f7"}.fa-creative-commons-zero{--fa:"\f4f3"}.fa-hips{--fa:"\f452"}.fa-css{--fa:"\e6a2"}.fa-behance{--fa:"\f1b4"}.fa-reddit{--fa:"\f1a1"}.fa-discord{--fa:"\f392"}.fa-chrome{--fa:"\f268"}.fa-app-store-ios{--fa:"\f370"}.fa-cc-discover{--fa:"\f1f2"}.fa-wpbeginner{--fa:"\f297"}.fa-confluence{--fa:"\f78d"}.fa-shoelace{--fa:"\e60c"}.fa-mdb{--fa:"\f8ca"}.fa-dochub{--fa:"\f394"}.fa-accessible-icon{--fa:"\f368"}.fa-ebay{--fa:"\f4f4"}.fa-amazon{--fa:"\f270"}.fa-unsplash{--fa:"\e07c"}.fa-yarn{--fa:"\f7e3"}.fa-square-steam,.fa-steam-square{--fa:"\f1b7"}.fa-500px{--fa:"\f26e"}.fa-square-vimeo,.fa-vimeo-square{--fa:"\f194"}.fa-asymmetrik{--fa:"\f372"}.fa-font-awesome,.fa-font-awesome-flag,.fa-font-awesome-logo-full{--fa:"\f2b4"}.fa-gratipay{--fa:"\f184"}.fa-apple{--fa:"\f179"}.fa-hive{--fa:"\e07f"}.fa-gitkraken{--fa:"\f3a6"}.fa-keybase{--fa:"\f4f5"}.fa-apple-pay{--fa:"\f415"}.fa-padlet{--fa:"\e4a0"}.fa-amazon-pay{--fa:"\f42c"}.fa-github-square,.fa-square-github{--fa:"\f092"}.fa-stumbleupon{--fa:"\f1a4"}.fa-fedex{--fa:"\f797"}.fa-phoenix-framework{--fa:"\f3dc"}.fa-shopify{--fa:"\e057"}.fa-neos{--fa:"\f612"}.fa-square-threads{--fa:"\e619"}.fa-hackerrank{--fa:"\f5f7"}.fa-researchgate{--fa:"\f4f8"}.fa-swift{--fa:"\f8e1"}.fa-angular{--fa:"\f420"}.fa-speakap{--fa:"\f3f3"}.fa-angrycreative{--fa:"\f36e"}.fa-y-combinator{--fa:"\f23b"}.fa-empire{--fa:"\f1d1"}.fa-envira{--fa:"\f299"}.fa-google-scholar{--fa:"\e63b"}.fa-gitlab-square,.fa-square-gitlab{--fa:"\e5ae"}.fa-studiovinari{--fa:"\f3f8"}.fa-pied-piper{--fa:"\f2ae"}.fa-wordpress{--fa:"\f19a"}.fa-product-hunt{--fa:"\f288"}.fa-firefox{--fa:"\f269"}.fa-linode{--fa:"\f2b8"}.fa-goodreads{--fa:"\f3a8"}.fa-odnoklassniki-square,.fa-square-odnoklassniki{--fa:"\f264"}.fa-jsfiddle{--fa:"\f1cc"}.fa-sith{--fa:"\f512"}.fa-themeisle{--fa:"\f2b2"}.fa-page4{--fa:"\f3d7"}.fa-hashnode{--fa:"\e499"}.fa-react{--fa:"\f41b"}.fa-cc-paypal{--fa:"\f1f4"}.fa-squarespace{--fa:"\f5be"}.fa-cc-stripe{--fa:"\f1f5"}.fa-creative-commons-share{--fa:"\f4f2"}.fa-bitcoin{--fa:"\f379"}.fa-keycdn{--fa:"\f3ba"}.fa-opera{--fa:"\f26a"}.fa-itch-io{--fa:"\f83a"}.fa-umbraco{--fa:"\f8e8"}.fa-galactic-senate{--fa:"\f50d"}.fa-ubuntu{--fa:"\f7df"}.fa-draft2digital{--fa:"\f396"}.fa-stripe{--fa:"\f429"}.fa-houzz{--fa:"\f27c"}.fa-gg{--fa:"\f260"}.fa-dhl{--fa:"\f790"}.fa-pinterest-square,.fa-square-pinterest{--fa:"\f0d3"}.fa-xing{--fa:"\f168"}.fa-blackberry{--fa:"\f37b"}.fa-creative-commons-pd{--fa:"\f4ec"}.fa-playstation{--fa:"\f3df"}.fa-quinscape{--fa:"\f459"}.fa-less{--fa:"\f41d"}.fa-blogger-b{--fa:"\f37d"}.fa-opencart{--fa:"\f23d"}.fa-vine{--fa:"\f1ca"}.fa-signal-messenger{--fa:"\e663"}.fa-paypal{--fa:"\f1ed"}.fa-gitlab{--fa:"\f296"}.fa-typo3{--fa:"\f42b"}.fa-reddit-alien{--fa:"\f281"}.fa-yahoo{--fa:"\f19e"}.fa-dailymotion{--fa:"\e052"}.fa-affiliatetheme{--fa:"\f36b"}.fa-pied-piper-pp{--fa:"\f1a7"}.fa-bootstrap{--fa:"\f836"}.fa-odnoklassniki{--fa:"\f263"}.fa-nfc-symbol{--fa:"\e531"}.fa-mintbit{--fa:"\e62f"}.fa-ethereum{--fa:"\f42e"}.fa-speaker-deck{--fa:"\f83c"}.fa-creative-commons-nc-eu{--fa:"\f4e9"}.fa-patreon{--fa:"\f3d9"}.fa-avianex{--fa:"\f374"}.fa-ello{--fa:"\f5f1"}.fa-gofore{--fa:"\f3a7"}.fa-bimobject{--fa:"\f378"}.fa-brave-reverse{--fa:"\e63d"}.fa-facebook-f{--fa:"\f39e"}.fa-google-plus-square,.fa-square-google-plus{--fa:"\f0d4"}.fa-web-awesome{--fa:"\e682"}.fa-mandalorian{--fa:"\f50f"}.fa-first-order-alt{--fa:"\f50a"}.fa-osi{--fa:"\f41a"}.fa-google-wallet{--fa:"\f1ee"}.fa-d-and-d-beyond{--fa:"\f6ca"}.fa-periscope{--fa:"\f3da"}.fa-fulcrum{--fa:"\f50b"}.fa-cloudscale{--fa:"\f383"}.fa-forumbee{--fa:"\f211"}.fa-mizuni{--fa:"\f3cc"}.fa-schlix{--fa:"\f3ea"}.fa-square-xing,.fa-xing-square{--fa:"\f169"}.fa-bandcamp{--fa:"\f2d5"}.fa-wpforms{--fa:"\f298"}.fa-cloudversify{--fa:"\f385"}.fa-usps{--fa:"\f7e1"}.fa-megaport{--fa:"\f5a3"}.fa-magento{--fa:"\f3c4"}.fa-spotify{--fa:"\f1bc"}.fa-optin-monster{--fa:"\f23c"}.fa-fly{--fa:"\f417"}.fa-square-bluesky{--fa:"\e6a3"}.fa-aviato{--fa:"\f421"}.fa-itunes{--fa:"\f3b4"}.fa-cuttlefish{--fa:"\f38c"}.fa-blogger{--fa:"\f37c"}.fa-flickr{--fa:"\f16e"}.fa-viber{--fa:"\f409"}.fa-soundcloud{--fa:"\f1be"}.fa-digg{--fa:"\f1a6"}.fa-tencent-weibo{--fa:"\f1d5"}.fa-letterboxd{--fa:"\e62d"}.fa-symfony{--fa:"\f83d"}.fa-maxcdn{--fa:"\f136"}.fa-etsy{--fa:"\f2d7"}.fa-facebook-messenger{--fa:"\f39f"}.fa-audible{--fa:"\f373"}.fa-think-peaks{--fa:"\f731"}.fa-bilibili{--fa:"\e3d9"}.fa-erlang{--fa:"\f39d"}.fa-x-twitter{--fa:"\e61b"}.fa-cotton-bureau{--fa:"\f89e"}.fa-dashcube{--fa:"\f210"}.fa-42-group,.fa-innosoft{--fa:"\e080"}.fa-stack-exchange{--fa:"\f18d"}.fa-elementor{--fa:"\f430"}.fa-pied-piper-square,.fa-square-pied-piper{--fa:"\e01e"}.fa-creative-commons-nd{--fa:"\f4eb"}.fa-palfed{--fa:"\f3d8"}.fa-superpowers{--fa:"\f2dd"}.fa-resolving{--fa:"\f3e7"}.fa-xbox{--fa:"\f412"}.fa-square-web-awesome-stroke{--fa:"\e684"}.fa-searchengin{--fa:"\f3eb"}.fa-tiktok{--fa:"\e07b"}.fa-facebook-square,.fa-square-facebook{--fa:"\f082"}.fa-renren{--fa:"\f18b"}.fa-linux{--fa:"\f17c"}.fa-glide{--fa:"\f2a5"}.fa-linkedin{--fa:"\f08c"}.fa-hubspot{--fa:"\f3b2"}.fa-deploydog{--fa:"\f38e"}.fa-twitch{--fa:"\f1e8"}.fa-flutter{--fa:"\e694"}.fa-ravelry{--fa:"\f2d9"}.fa-mixer{--fa:"\e056"}.fa-lastfm-square,.fa-square-lastfm{--fa:"\f203"}.fa-vimeo{--fa:"\f40a"}.fa-mendeley{--fa:"\f7b3"}.fa-uniregistry{--fa:"\f404"}.fa-figma{--fa:"\f799"}.fa-creative-commons-remix{--fa:"\f4ee"}.fa-cc-amazon-pay{--fa:"\f42d"}.fa-dropbox{--fa:"\f16b"}.fa-instagram{--fa:"\f16d"}.fa-cmplid{--fa:"\e360"}.fa-upwork{--fa:"\e641"}.fa-facebook{--fa:"\f09a"}.fa-gripfire{--fa:"\f3ac"}.fa-jedi-order{--fa:"\f50e"}.fa-uikit{--fa:"\f403"}.fa-fort-awesome-alt{--fa:"\f3a3"}.fa-phabricator{--fa:"\f3db"}.fa-ussunnah{--fa:"\f407"}.fa-earlybirds{--fa:"\f39a"}.fa-trade-federation{--fa:"\f513"}.fa-autoprefixer{--fa:"\f41c"}.fa-whatsapp{--fa:"\f232"}.fa-square-upwork{--fa:"\e67c"}.fa-slideshare{--fa:"\f1e7"}.fa-google-play{--fa:"\f3ab"}.fa-viadeo{--fa:"\f2a9"}.fa-line{--fa:"\f3c0"}.fa-google-drive{--fa:"\f3aa"}.fa-servicestack{--fa:"\f3ec"}.fa-simplybuilt{--fa:"\f215"}.fa-bitbucket{--fa:"\f171"}.fa-imdb{--fa:"\f2d8"}.fa-deezer{--fa:"\e077"}.fa-raspberry-pi{--fa:"\f7bb"}.fa-jira{--fa:"\f7b1"}.fa-docker{--fa:"\f395"}.fa-screenpal{--fa:"\e570"}.fa-bluetooth{--fa:"\f293"}.fa-gitter{--fa:"\f426"}.fa-d-and-d{--fa:"\f38d"}.fa-microblog{--fa:"\e01a"}.fa-cc-diners-club{--fa:"\f24c"}.fa-gg-circle{--fa:"\f261"}.fa-pied-piper-hat{--fa:"\f4e5"}.fa-kickstarter-k{--fa:"\f3bc"}.fa-yandex{--fa:"\f413"}.fa-readme{--fa:"\f4d5"}.fa-html5{--fa:"\f13b"}.fa-sellsy{--fa:"\f213"}.fa-square-web-awesome{--fa:"\e683"}.fa-sass{--fa:"\f41e"}.fa-wirsindhandwerk,.fa-wsh{--fa:"\e2d0"}.fa-buromobelexperte{--fa:"\f37f"}.fa-salesforce{--fa:"\f83b"}.fa-octopus-deploy{--fa:"\e082"}.fa-medapps{--fa:"\f3c6"}.fa-ns8{--fa:"\f3d5"}.fa-pinterest-p{--fa:"\f231"}.fa-apper{--fa:"\f371"}.fa-fort-awesome{--fa:"\f286"}.fa-waze{--fa:"\f83f"}.fa-bluesky{--fa:"\e671"}.fa-cc-jcb{--fa:"\f24b"}.fa-snapchat,.fa-snapchat-ghost{--fa:"\f2ab"}.fa-fantasy-flight-games{--fa:"\f6dc"}.fa-rust{--fa:"\e07a"}.fa-wix{--fa:"\f5cf"}.fa-behance-square,.fa-square-behance{--fa:"\f1b5"}.fa-supple{--fa:"\f3f9"}.fa-webflow{--fa:"\e65c"}.fa-rebel{--fa:"\f1d0"}.fa-css3{--fa:"\f13c"}.fa-staylinked{--fa:"\f3f5"}.fa-kaggle{--fa:"\f5fa"}.fa-space-awesome{--fa:"\e5ac"}.fa-deviantart{--fa:"\f1bd"}.fa-cpanel{--fa:"\f388"}.fa-goodreads-g{--fa:"\f3a9"}.fa-git-square,.fa-square-git{--fa:"\f1d2"}.fa-square-tumblr,.fa-tumblr-square{--fa:"\f174"}.fa-trello{--fa:"\f181"}.fa-creative-commons-nc-jp{--fa:"\f4ea"}.fa-get-pocket{--fa:"\f265"}.fa-perbyte{--fa:"\e083"}.fa-grunt{--fa:"\f3ad"}.fa-weebly{--fa:"\f5cc"}.fa-connectdevelop{--fa:"\f20e"}.fa-leanpub{--fa:"\f212"}.fa-black-tie{--fa:"\f27e"}.fa-themeco{--fa:"\f5c6"}.fa-python{--fa:"\f3e2"}.fa-android{--fa:"\f17b"}.fa-bots{--fa:"\e340"}.fa-free-code-camp{--fa:"\f2c5"}.fa-hornbill{--fa:"\f592"}.fa-js{--fa:"\f3b8"}.fa-ideal{--fa:"\e013"}.fa-git{--fa:"\f1d3"}.fa-dev{--fa:"\f6cc"}.fa-sketch{--fa:"\f7c6"}.fa-yandex-international{--fa:"\f414"}.fa-cc-amex{--fa:"\f1f3"}.fa-uber{--fa:"\f402"}.fa-github{--fa:"\f09b"}.fa-php{--fa:"\f457"}.fa-alipay{--fa:"\f642"}.fa-youtube{--fa:"\f167"}.fa-skyatlas{--fa:"\f216"}.fa-firefox-browser{--fa:"\e007"}.fa-replyd{--fa:"\f3e6"}.fa-suse{--fa:"\f7d6"}.fa-jenkins{--fa:"\f3b6"}.fa-twitter{--fa:"\f099"}.fa-rockrms{--fa:"\f3e9"}.fa-pinterest{--fa:"\f0d2"}.fa-buffer{--fa:"\f837"}.fa-npm{--fa:"\f3d4"}.fa-yammer{--fa:"\f840"}.fa-btc{--fa:"\f15a"}.fa-dribbble{--fa:"\f17d"}.fa-stumbleupon-circle{--fa:"\f1a3"}.fa-internet-explorer{--fa:"\f26b"}.fa-stubber{--fa:"\e5c7"}.fa-telegram,.fa-telegram-plane{--fa:"\f2c6"}.fa-old-republic{--fa:"\f510"}.fa-odysee{--fa:"\e5c6"}.fa-square-whatsapp,.fa-whatsapp-square{--fa:"\f40c"}.fa-node-js{--fa:"\f3d3"}.fa-edge-legacy{--fa:"\e078"}.fa-slack,.fa-slack-hash{--fa:"\f198"}.fa-medrt{--fa:"\f3c8"}.fa-usb{--fa:"\f287"}.fa-tumblr{--fa:"\f173"}.fa-vaadin{--fa:"\f408"}.fa-quora{--fa:"\f2c4"}.fa-square-x-twitter{--fa:"\e61a"}.fa-reacteurope{--fa:"\f75d"}.fa-medium,.fa-medium-m{--fa:"\f23a"}.fa-amilia{--fa:"\f36d"}.fa-mixcloud{--fa:"\f289"}.fa-flipboard{--fa:"\f44d"}.fa-viacoin{--fa:"\f237"}.fa-critical-role{--fa:"\f6c9"}.fa-sitrox{--fa:"\e44a"}.fa-discourse{--fa:"\f393"}.fa-joomla{--fa:"\f1aa"}.fa-mastodon{--fa:"\f4f6"}.fa-airbnb{--fa:"\f834"}.fa-wolf-pack-battalion{--fa:"\f514"}.fa-buy-n-large{--fa:"\f8a6"}.fa-gulp{--fa:"\f3ae"}.fa-creative-commons-sampling-plus{--fa:"\f4f1"}.fa-strava{--fa:"\f428"}.fa-ember{--fa:"\f423"}.fa-canadian-maple-leaf{--fa:"\f785"}.fa-teamspeak{--fa:"\f4f9"}.fa-pushed{--fa:"\f3e1"}.fa-wordpress-simple{--fa:"\f411"}.fa-nutritionix{--fa:"\f3d6"}.fa-wodu{--fa:"\e088"}.fa-google-pay{--fa:"\e079"}.fa-intercom{--fa:"\f7af"}.fa-zhihu{--fa:"\f63f"}.fa-korvue{--fa:"\f42f"}.fa-pix{--fa:"\e43a"}.fa-steam-symbol{--fa:"\f3f6"}rclone-v1.71.0/docs/static/fontawesome/css/fontawesome.min.css000066400000000000000000002525351505210326400244430ustar00rootroot00000000000000/*! * Font Awesome Free 6.7.1 by @fontawesome - https://fontawesome.com * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) * Copyright 2024 Fonticons, Inc. */ .fa{font-family:var(--fa-style-family,"Font Awesome 6 Free");font-weight:var(--fa-style,900)}.fa,.fa-brands,.fa-regular,.fa-solid,.fab,.far,.fas{-moz-osx-font-smoothing:grayscale;-webkit-font-smoothing:antialiased;display:var(--fa-display,inline-block);font-style:normal;font-variant:normal;line-height:1;text-rendering:auto}.fa-brands:before,.fa-regular:before,.fa-solid:before,.fa:before,.fab:before,.far:before,.fas:before{content:var(--fa)}.fa-classic,.fa-regular,.fa-solid,.far,.fas{font-family:"Font Awesome 6 Free"}.fa-brands,.fab{font-family:"Font Awesome 6 Brands"}.fa-1x{font-size:1em}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-6x{font-size:6em}.fa-7x{font-size:7em}.fa-8x{font-size:8em}.fa-9x{font-size:9em}.fa-10x{font-size:10em}.fa-2xs{font-size:.625em;line-height:.1em;vertical-align:.225em}.fa-xs{font-size:.75em;line-height:.08333em;vertical-align:.125em}.fa-sm{font-size:.875em;line-height:.07143em;vertical-align:.05357em}.fa-lg{font-size:1.25em;line-height:.05em;vertical-align:-.075em}.fa-xl{font-size:1.5em;line-height:.04167em;vertical-align:-.125em}.fa-2xl{font-size:2em;line-height:.03125em;vertical-align:-.1875em}.fa-fw{text-align:center;width:1.25em}.fa-ul{list-style-type:none;margin-left:var(--fa-li-margin,2.5em);padding-left:0}.fa-ul>li{position:relative}.fa-li{left:calc(var(--fa-li-width, 2em)*-1);position:absolute;text-align:center;width:var(--fa-li-width,2em);line-height:inherit}.fa-border{border-radius:var(--fa-border-radius,.1em);border:var(--fa-border-width,.08em) var(--fa-border-style,solid) var(--fa-border-color,#eee);padding:var(--fa-border-padding,.2em .25em .15em)}.fa-pull-left{float:left;margin-right:var(--fa-pull-margin,.3em)}.fa-pull-right{float:right;margin-left:var(--fa-pull-margin,.3em)}.fa-beat{animation-name:fa-beat;animation-delay:var(--fa-animation-delay,0s);animation-direction:var(--fa-animation-direction,normal);animation-duration:var(--fa-animation-duration,1s);animation-iteration-count:var(--fa-animation-iteration-count,infinite);animation-timing-function:var(--fa-animation-timing,ease-in-out)}.fa-bounce{animation-name:fa-bounce;animation-delay:var(--fa-animation-delay,0s);animation-direction:var(--fa-animation-direction,normal);animation-duration:var(--fa-animation-duration,1s);animation-iteration-count:var(--fa-animation-iteration-count,infinite);animation-timing-function:var(--fa-animation-timing,cubic-bezier(.28,.84,.42,1))}.fa-fade{animation-name:fa-fade;animation-iteration-count:var(--fa-animation-iteration-count,infinite);animation-timing-function:var(--fa-animation-timing,cubic-bezier(.4,0,.6,1))}.fa-beat-fade,.fa-fade{animation-delay:var(--fa-animation-delay,0s);animation-direction:var(--fa-animation-direction,normal);animation-duration:var(--fa-animation-duration,1s)}.fa-beat-fade{animation-name:fa-beat-fade;animation-iteration-count:var(--fa-animation-iteration-count,infinite);animation-timing-function:var(--fa-animation-timing,cubic-bezier(.4,0,.6,1))}.fa-flip{animation-name:fa-flip;animation-delay:var(--fa-animation-delay,0s);animation-direction:var(--fa-animation-direction,normal);animation-duration:var(--fa-animation-duration,1s);animation-iteration-count:var(--fa-animation-iteration-count,infinite);animation-timing-function:var(--fa-animation-timing,ease-in-out)}.fa-shake{animation-name:fa-shake;animation-duration:var(--fa-animation-duration,1s);animation-iteration-count:var(--fa-animation-iteration-count,infinite);animation-timing-function:var(--fa-animation-timing,linear)}.fa-shake,.fa-spin{animation-delay:var(--fa-animation-delay,0s);animation-direction:var(--fa-animation-direction,normal)}.fa-spin{animation-name:fa-spin;animation-duration:var(--fa-animation-duration,2s);animation-iteration-count:var(--fa-animation-iteration-count,infinite);animation-timing-function:var(--fa-animation-timing,linear)}.fa-spin-reverse{--fa-animation-direction:reverse}.fa-pulse,.fa-spin-pulse{animation-name:fa-spin;animation-direction:var(--fa-animation-direction,normal);animation-duration:var(--fa-animation-duration,1s);animation-iteration-count:var(--fa-animation-iteration-count,infinite);animation-timing-function:var(--fa-animation-timing,steps(8))}@media (prefers-reduced-motion:reduce){.fa-beat,.fa-beat-fade,.fa-bounce,.fa-fade,.fa-flip,.fa-pulse,.fa-shake,.fa-spin,.fa-spin-pulse{animation-delay:-1ms;animation-duration:1ms;animation-iteration-count:1;transition-delay:0s;transition-duration:0s}}@keyframes fa-beat{0%,90%{transform:scale(1)}45%{transform:scale(var(--fa-beat-scale,1.25))}}@keyframes fa-bounce{0%{transform:scale(1) translateY(0)}10%{transform:scale(var(--fa-bounce-start-scale-x,1.1),var(--fa-bounce-start-scale-y,.9)) translateY(0)}30%{transform:scale(var(--fa-bounce-jump-scale-x,.9),var(--fa-bounce-jump-scale-y,1.1)) translateY(var(--fa-bounce-height,-.5em))}50%{transform:scale(var(--fa-bounce-land-scale-x,1.05),var(--fa-bounce-land-scale-y,.95)) translateY(0)}57%{transform:scale(1) translateY(var(--fa-bounce-rebound,-.125em))}64%{transform:scale(1) translateY(0)}to{transform:scale(1) translateY(0)}}@keyframes fa-fade{50%{opacity:var(--fa-fade-opacity,.4)}}@keyframes fa-beat-fade{0%,to{opacity:var(--fa-beat-fade-opacity,.4);transform:scale(1)}50%{opacity:1;transform:scale(var(--fa-beat-fade-scale,1.125))}}@keyframes fa-flip{50%{transform:rotate3d(var(--fa-flip-x,0),var(--fa-flip-y,1),var(--fa-flip-z,0),var(--fa-flip-angle,-180deg))}}@keyframes fa-shake{0%{transform:rotate(-15deg)}4%{transform:rotate(15deg)}8%,24%{transform:rotate(-18deg)}12%,28%{transform:rotate(18deg)}16%{transform:rotate(-22deg)}20%{transform:rotate(22deg)}32%{transform:rotate(-12deg)}36%{transform:rotate(12deg)}40%,to{transform:rotate(0deg)}}@keyframes fa-spin{0%{transform:rotate(0deg)}to{transform:rotate(1turn)}}.fa-rotate-90{transform:rotate(90deg)}.fa-rotate-180{transform:rotate(180deg)}.fa-rotate-270{transform:rotate(270deg)}.fa-flip-horizontal{transform:scaleX(-1)}.fa-flip-vertical{transform:scaleY(-1)}.fa-flip-both,.fa-flip-horizontal.fa-flip-vertical{transform:scale(-1)}.fa-rotate-by{transform:rotate(var(--fa-rotate-angle,0))}.fa-stack{display:inline-block;height:2em;line-height:2em;position:relative;vertical-align:middle;width:2.5em}.fa-stack-1x,.fa-stack-2x{left:0;position:absolute;text-align:center;width:100%;z-index:var(--fa-stack-z-index,auto)}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:var(--fa-inverse,#fff)} .fa-0{--fa:"\30";--fa--fa:"\30\30"}.fa-1{--fa:"\31";--fa--fa:"\31\31"}.fa-2{--fa:"\32";--fa--fa:"\32\32"}.fa-3{--fa:"\33";--fa--fa:"\33\33"}.fa-4{--fa:"\34";--fa--fa:"\34\34"}.fa-5{--fa:"\35";--fa--fa:"\35\35"}.fa-6{--fa:"\36";--fa--fa:"\36\36"}.fa-7{--fa:"\37";--fa--fa:"\37\37"}.fa-8{--fa:"\38";--fa--fa:"\38\38"}.fa-9{--fa:"\39";--fa--fa:"\39\39"}.fa-fill-drip{--fa:"\f576";--fa--fa:"\f576\f576"}.fa-arrows-to-circle{--fa:"\e4bd";--fa--fa:"\e4bd\e4bd"}.fa-chevron-circle-right,.fa-circle-chevron-right{--fa:"\f138";--fa--fa:"\f138\f138"}.fa-at{--fa:"\40";--fa--fa:"\40\40"}.fa-trash-alt,.fa-trash-can{--fa:"\f2ed";--fa--fa:"\f2ed\f2ed"}.fa-text-height{--fa:"\f034";--fa--fa:"\f034\f034"}.fa-user-times,.fa-user-xmark{--fa:"\f235";--fa--fa:"\f235\f235"}.fa-stethoscope{--fa:"\f0f1";--fa--fa:"\f0f1\f0f1"}.fa-comment-alt,.fa-message{--fa:"\f27a";--fa--fa:"\f27a\f27a"}.fa-info{--fa:"\f129";--fa--fa:"\f129\f129"}.fa-compress-alt,.fa-down-left-and-up-right-to-center{--fa:"\f422";--fa--fa:"\f422\f422"}.fa-explosion{--fa:"\e4e9";--fa--fa:"\e4e9\e4e9"}.fa-file-alt,.fa-file-lines,.fa-file-text{--fa:"\f15c";--fa--fa:"\f15c\f15c"}.fa-wave-square{--fa:"\f83e";--fa--fa:"\f83e\f83e"}.fa-ring{--fa:"\f70b";--fa--fa:"\f70b\f70b"}.fa-building-un{--fa:"\e4d9";--fa--fa:"\e4d9\e4d9"}.fa-dice-three{--fa:"\f527";--fa--fa:"\f527\f527"}.fa-calendar-alt,.fa-calendar-days{--fa:"\f073";--fa--fa:"\f073\f073"}.fa-anchor-circle-check{--fa:"\e4aa";--fa--fa:"\e4aa\e4aa"}.fa-building-circle-arrow-right{--fa:"\e4d1";--fa--fa:"\e4d1\e4d1"}.fa-volleyball,.fa-volleyball-ball{--fa:"\f45f";--fa--fa:"\f45f\f45f"}.fa-arrows-up-to-line{--fa:"\e4c2";--fa--fa:"\e4c2\e4c2"}.fa-sort-desc,.fa-sort-down{--fa:"\f0dd";--fa--fa:"\f0dd\f0dd"}.fa-circle-minus,.fa-minus-circle{--fa:"\f056";--fa--fa:"\f056\f056"}.fa-door-open{--fa:"\f52b";--fa--fa:"\f52b\f52b"}.fa-right-from-bracket,.fa-sign-out-alt{--fa:"\f2f5";--fa--fa:"\f2f5\f2f5"}.fa-atom{--fa:"\f5d2";--fa--fa:"\f5d2\f5d2"}.fa-soap{--fa:"\e06e";--fa--fa:"\e06e\e06e"}.fa-heart-music-camera-bolt,.fa-icons{--fa:"\f86d";--fa--fa:"\f86d\f86d"}.fa-microphone-alt-slash,.fa-microphone-lines-slash{--fa:"\f539";--fa--fa:"\f539\f539"}.fa-bridge-circle-check{--fa:"\e4c9";--fa--fa:"\e4c9\e4c9"}.fa-pump-medical{--fa:"\e06a";--fa--fa:"\e06a\e06a"}.fa-fingerprint{--fa:"\f577";--fa--fa:"\f577\f577"}.fa-hand-point-right{--fa:"\f0a4";--fa--fa:"\f0a4\f0a4"}.fa-magnifying-glass-location,.fa-search-location{--fa:"\f689";--fa--fa:"\f689\f689"}.fa-forward-step,.fa-step-forward{--fa:"\f051";--fa--fa:"\f051\f051"}.fa-face-smile-beam,.fa-smile-beam{--fa:"\f5b8";--fa--fa:"\f5b8\f5b8"}.fa-flag-checkered{--fa:"\f11e";--fa--fa:"\f11e\f11e"}.fa-football,.fa-football-ball{--fa:"\f44e";--fa--fa:"\f44e\f44e"}.fa-school-circle-exclamation{--fa:"\e56c";--fa--fa:"\e56c\e56c"}.fa-crop{--fa:"\f125";--fa--fa:"\f125\f125"}.fa-angle-double-down,.fa-angles-down{--fa:"\f103";--fa--fa:"\f103\f103"}.fa-users-rectangle{--fa:"\e594";--fa--fa:"\e594\e594"}.fa-people-roof{--fa:"\e537";--fa--fa:"\e537\e537"}.fa-people-line{--fa:"\e534";--fa--fa:"\e534\e534"}.fa-beer,.fa-beer-mug-empty{--fa:"\f0fc";--fa--fa:"\f0fc\f0fc"}.fa-diagram-predecessor{--fa:"\e477";--fa--fa:"\e477\e477"}.fa-arrow-up-long,.fa-long-arrow-up{--fa:"\f176";--fa--fa:"\f176\f176"}.fa-burn,.fa-fire-flame-simple{--fa:"\f46a";--fa--fa:"\f46a\f46a"}.fa-male,.fa-person{--fa:"\f183";--fa--fa:"\f183\f183"}.fa-laptop{--fa:"\f109";--fa--fa:"\f109\f109"}.fa-file-csv{--fa:"\f6dd";--fa--fa:"\f6dd\f6dd"}.fa-menorah{--fa:"\f676";--fa--fa:"\f676\f676"}.fa-truck-plane{--fa:"\e58f";--fa--fa:"\e58f\e58f"}.fa-record-vinyl{--fa:"\f8d9";--fa--fa:"\f8d9\f8d9"}.fa-face-grin-stars,.fa-grin-stars{--fa:"\f587";--fa--fa:"\f587\f587"}.fa-bong{--fa:"\f55c";--fa--fa:"\f55c\f55c"}.fa-pastafarianism,.fa-spaghetti-monster-flying{--fa:"\f67b";--fa--fa:"\f67b\f67b"}.fa-arrow-down-up-across-line{--fa:"\e4af";--fa--fa:"\e4af\e4af"}.fa-spoon,.fa-utensil-spoon{--fa:"\f2e5";--fa--fa:"\f2e5\f2e5"}.fa-jar-wheat{--fa:"\e517";--fa--fa:"\e517\e517"}.fa-envelopes-bulk,.fa-mail-bulk{--fa:"\f674";--fa--fa:"\f674\f674"}.fa-file-circle-exclamation{--fa:"\e4eb";--fa--fa:"\e4eb\e4eb"}.fa-circle-h,.fa-hospital-symbol{--fa:"\f47e";--fa--fa:"\f47e\f47e"}.fa-pager{--fa:"\f815";--fa--fa:"\f815\f815"}.fa-address-book,.fa-contact-book{--fa:"\f2b9";--fa--fa:"\f2b9\f2b9"}.fa-strikethrough{--fa:"\f0cc";--fa--fa:"\f0cc\f0cc"}.fa-k{--fa:"\4b";--fa--fa:"\4b\4b"}.fa-landmark-flag{--fa:"\e51c";--fa--fa:"\e51c\e51c"}.fa-pencil,.fa-pencil-alt{--fa:"\f303";--fa--fa:"\f303\f303"}.fa-backward{--fa:"\f04a";--fa--fa:"\f04a\f04a"}.fa-caret-right{--fa:"\f0da";--fa--fa:"\f0da\f0da"}.fa-comments{--fa:"\f086";--fa--fa:"\f086\f086"}.fa-file-clipboard,.fa-paste{--fa:"\f0ea";--fa--fa:"\f0ea\f0ea"}.fa-code-pull-request{--fa:"\e13c";--fa--fa:"\e13c\e13c"}.fa-clipboard-list{--fa:"\f46d";--fa--fa:"\f46d\f46d"}.fa-truck-loading,.fa-truck-ramp-box{--fa:"\f4de";--fa--fa:"\f4de\f4de"}.fa-user-check{--fa:"\f4fc";--fa--fa:"\f4fc\f4fc"}.fa-vial-virus{--fa:"\e597";--fa--fa:"\e597\e597"}.fa-sheet-plastic{--fa:"\e571";--fa--fa:"\e571\e571"}.fa-blog{--fa:"\f781";--fa--fa:"\f781\f781"}.fa-user-ninja{--fa:"\f504";--fa--fa:"\f504\f504"}.fa-person-arrow-up-from-line{--fa:"\e539";--fa--fa:"\e539\e539"}.fa-scroll-torah,.fa-torah{--fa:"\f6a0";--fa--fa:"\f6a0\f6a0"}.fa-broom-ball,.fa-quidditch,.fa-quidditch-broom-ball{--fa:"\f458";--fa--fa:"\f458\f458"}.fa-toggle-off{--fa:"\f204";--fa--fa:"\f204\f204"}.fa-archive,.fa-box-archive{--fa:"\f187";--fa--fa:"\f187\f187"}.fa-person-drowning{--fa:"\e545";--fa--fa:"\e545\e545"}.fa-arrow-down-9-1,.fa-sort-numeric-desc,.fa-sort-numeric-down-alt{--fa:"\f886";--fa--fa:"\f886\f886"}.fa-face-grin-tongue-squint,.fa-grin-tongue-squint{--fa:"\f58a";--fa--fa:"\f58a\f58a"}.fa-spray-can{--fa:"\f5bd";--fa--fa:"\f5bd\f5bd"}.fa-truck-monster{--fa:"\f63b";--fa--fa:"\f63b\f63b"}.fa-w{--fa:"\57";--fa--fa:"\57\57"}.fa-earth-africa,.fa-globe-africa{--fa:"\f57c";--fa--fa:"\f57c\f57c"}.fa-rainbow{--fa:"\f75b";--fa--fa:"\f75b\f75b"}.fa-circle-notch{--fa:"\f1ce";--fa--fa:"\f1ce\f1ce"}.fa-tablet-alt,.fa-tablet-screen-button{--fa:"\f3fa";--fa--fa:"\f3fa\f3fa"}.fa-paw{--fa:"\f1b0";--fa--fa:"\f1b0\f1b0"}.fa-cloud{--fa:"\f0c2";--fa--fa:"\f0c2\f0c2"}.fa-trowel-bricks{--fa:"\e58a";--fa--fa:"\e58a\e58a"}.fa-face-flushed,.fa-flushed{--fa:"\f579";--fa--fa:"\f579\f579"}.fa-hospital-user{--fa:"\f80d";--fa--fa:"\f80d\f80d"}.fa-tent-arrow-left-right{--fa:"\e57f";--fa--fa:"\e57f\e57f"}.fa-gavel,.fa-legal{--fa:"\f0e3";--fa--fa:"\f0e3\f0e3"}.fa-binoculars{--fa:"\f1e5";--fa--fa:"\f1e5\f1e5"}.fa-microphone-slash{--fa:"\f131";--fa--fa:"\f131\f131"}.fa-box-tissue{--fa:"\e05b";--fa--fa:"\e05b\e05b"}.fa-motorcycle{--fa:"\f21c";--fa--fa:"\f21c\f21c"}.fa-bell-concierge,.fa-concierge-bell{--fa:"\f562";--fa--fa:"\f562\f562"}.fa-pen-ruler,.fa-pencil-ruler{--fa:"\f5ae";--fa--fa:"\f5ae\f5ae"}.fa-people-arrows,.fa-people-arrows-left-right{--fa:"\e068";--fa--fa:"\e068\e068"}.fa-mars-and-venus-burst{--fa:"\e523";--fa--fa:"\e523\e523"}.fa-caret-square-right,.fa-square-caret-right{--fa:"\f152";--fa--fa:"\f152\f152"}.fa-cut,.fa-scissors{--fa:"\f0c4";--fa--fa:"\f0c4\f0c4"}.fa-sun-plant-wilt{--fa:"\e57a";--fa--fa:"\e57a\e57a"}.fa-toilets-portable{--fa:"\e584";--fa--fa:"\e584\e584"}.fa-hockey-puck{--fa:"\f453";--fa--fa:"\f453\f453"}.fa-table{--fa:"\f0ce";--fa--fa:"\f0ce\f0ce"}.fa-magnifying-glass-arrow-right{--fa:"\e521";--fa--fa:"\e521\e521"}.fa-digital-tachograph,.fa-tachograph-digital{--fa:"\f566";--fa--fa:"\f566\f566"}.fa-users-slash{--fa:"\e073";--fa--fa:"\e073\e073"}.fa-clover{--fa:"\e139";--fa--fa:"\e139\e139"}.fa-mail-reply,.fa-reply{--fa:"\f3e5";--fa--fa:"\f3e5\f3e5"}.fa-star-and-crescent{--fa:"\f699";--fa--fa:"\f699\f699"}.fa-house-fire{--fa:"\e50c";--fa--fa:"\e50c\e50c"}.fa-minus-square,.fa-square-minus{--fa:"\f146";--fa--fa:"\f146\f146"}.fa-helicopter{--fa:"\f533";--fa--fa:"\f533\f533"}.fa-compass{--fa:"\f14e";--fa--fa:"\f14e\f14e"}.fa-caret-square-down,.fa-square-caret-down{--fa:"\f150";--fa--fa:"\f150\f150"}.fa-file-circle-question{--fa:"\e4ef";--fa--fa:"\e4ef\e4ef"}.fa-laptop-code{--fa:"\f5fc";--fa--fa:"\f5fc\f5fc"}.fa-swatchbook{--fa:"\f5c3";--fa--fa:"\f5c3\f5c3"}.fa-prescription-bottle{--fa:"\f485";--fa--fa:"\f485\f485"}.fa-bars,.fa-navicon{--fa:"\f0c9";--fa--fa:"\f0c9\f0c9"}.fa-people-group{--fa:"\e533";--fa--fa:"\e533\e533"}.fa-hourglass-3,.fa-hourglass-end{--fa:"\f253";--fa--fa:"\f253\f253"}.fa-heart-broken,.fa-heart-crack{--fa:"\f7a9";--fa--fa:"\f7a9\f7a9"}.fa-external-link-square-alt,.fa-square-up-right{--fa:"\f360";--fa--fa:"\f360\f360"}.fa-face-kiss-beam,.fa-kiss-beam{--fa:"\f597";--fa--fa:"\f597\f597"}.fa-film{--fa:"\f008";--fa--fa:"\f008\f008"}.fa-ruler-horizontal{--fa:"\f547";--fa--fa:"\f547\f547"}.fa-people-robbery{--fa:"\e536";--fa--fa:"\e536\e536"}.fa-lightbulb{--fa:"\f0eb";--fa--fa:"\f0eb\f0eb"}.fa-caret-left{--fa:"\f0d9";--fa--fa:"\f0d9\f0d9"}.fa-circle-exclamation,.fa-exclamation-circle{--fa:"\f06a";--fa--fa:"\f06a\f06a"}.fa-school-circle-xmark{--fa:"\e56d";--fa--fa:"\e56d\e56d"}.fa-arrow-right-from-bracket,.fa-sign-out{--fa:"\f08b";--fa--fa:"\f08b\f08b"}.fa-chevron-circle-down,.fa-circle-chevron-down{--fa:"\f13a";--fa--fa:"\f13a\f13a"}.fa-unlock-alt,.fa-unlock-keyhole{--fa:"\f13e";--fa--fa:"\f13e\f13e"}.fa-cloud-showers-heavy{--fa:"\f740";--fa--fa:"\f740\f740"}.fa-headphones-alt,.fa-headphones-simple{--fa:"\f58f";--fa--fa:"\f58f\f58f"}.fa-sitemap{--fa:"\f0e8";--fa--fa:"\f0e8\f0e8"}.fa-circle-dollar-to-slot,.fa-donate{--fa:"\f4b9";--fa--fa:"\f4b9\f4b9"}.fa-memory{--fa:"\f538";--fa--fa:"\f538\f538"}.fa-road-spikes{--fa:"\e568";--fa--fa:"\e568\e568"}.fa-fire-burner{--fa:"\e4f1";--fa--fa:"\e4f1\e4f1"}.fa-flag{--fa:"\f024";--fa--fa:"\f024\f024"}.fa-hanukiah{--fa:"\f6e6";--fa--fa:"\f6e6\f6e6"}.fa-feather{--fa:"\f52d";--fa--fa:"\f52d\f52d"}.fa-volume-down,.fa-volume-low{--fa:"\f027";--fa--fa:"\f027\f027"}.fa-comment-slash{--fa:"\f4b3";--fa--fa:"\f4b3\f4b3"}.fa-cloud-sun-rain{--fa:"\f743";--fa--fa:"\f743\f743"}.fa-compress{--fa:"\f066";--fa--fa:"\f066\f066"}.fa-wheat-alt,.fa-wheat-awn{--fa:"\e2cd";--fa--fa:"\e2cd\e2cd"}.fa-ankh{--fa:"\f644";--fa--fa:"\f644\f644"}.fa-hands-holding-child{--fa:"\e4fa";--fa--fa:"\e4fa\e4fa"}.fa-asterisk{--fa:"\2a";--fa--fa:"\2a\2a"}.fa-check-square,.fa-square-check{--fa:"\f14a";--fa--fa:"\f14a\f14a"}.fa-peseta-sign{--fa:"\e221";--fa--fa:"\e221\e221"}.fa-header,.fa-heading{--fa:"\f1dc";--fa--fa:"\f1dc\f1dc"}.fa-ghost{--fa:"\f6e2";--fa--fa:"\f6e2\f6e2"}.fa-list,.fa-list-squares{--fa:"\f03a";--fa--fa:"\f03a\f03a"}.fa-phone-square-alt,.fa-square-phone-flip{--fa:"\f87b";--fa--fa:"\f87b\f87b"}.fa-cart-plus{--fa:"\f217";--fa--fa:"\f217\f217"}.fa-gamepad{--fa:"\f11b";--fa--fa:"\f11b\f11b"}.fa-circle-dot,.fa-dot-circle{--fa:"\f192";--fa--fa:"\f192\f192"}.fa-dizzy,.fa-face-dizzy{--fa:"\f567";--fa--fa:"\f567\f567"}.fa-egg{--fa:"\f7fb";--fa--fa:"\f7fb\f7fb"}.fa-house-medical-circle-xmark{--fa:"\e513";--fa--fa:"\e513\e513"}.fa-campground{--fa:"\f6bb";--fa--fa:"\f6bb\f6bb"}.fa-folder-plus{--fa:"\f65e";--fa--fa:"\f65e\f65e"}.fa-futbol,.fa-futbol-ball,.fa-soccer-ball{--fa:"\f1e3";--fa--fa:"\f1e3\f1e3"}.fa-paint-brush,.fa-paintbrush{--fa:"\f1fc";--fa--fa:"\f1fc\f1fc"}.fa-lock{--fa:"\f023";--fa--fa:"\f023\f023"}.fa-gas-pump{--fa:"\f52f";--fa--fa:"\f52f\f52f"}.fa-hot-tub,.fa-hot-tub-person{--fa:"\f593";--fa--fa:"\f593\f593"}.fa-map-location,.fa-map-marked{--fa:"\f59f";--fa--fa:"\f59f\f59f"}.fa-house-flood-water{--fa:"\e50e";--fa--fa:"\e50e\e50e"}.fa-tree{--fa:"\f1bb";--fa--fa:"\f1bb\f1bb"}.fa-bridge-lock{--fa:"\e4cc";--fa--fa:"\e4cc\e4cc"}.fa-sack-dollar{--fa:"\f81d";--fa--fa:"\f81d\f81d"}.fa-edit,.fa-pen-to-square{--fa:"\f044";--fa--fa:"\f044\f044"}.fa-car-side{--fa:"\f5e4";--fa--fa:"\f5e4\f5e4"}.fa-share-alt,.fa-share-nodes{--fa:"\f1e0";--fa--fa:"\f1e0\f1e0"}.fa-heart-circle-minus{--fa:"\e4ff";--fa--fa:"\e4ff\e4ff"}.fa-hourglass-2,.fa-hourglass-half{--fa:"\f252";--fa--fa:"\f252\f252"}.fa-microscope{--fa:"\f610";--fa--fa:"\f610\f610"}.fa-sink{--fa:"\e06d";--fa--fa:"\e06d\e06d"}.fa-bag-shopping,.fa-shopping-bag{--fa:"\f290";--fa--fa:"\f290\f290"}.fa-arrow-down-z-a,.fa-sort-alpha-desc,.fa-sort-alpha-down-alt{--fa:"\f881";--fa--fa:"\f881\f881"}.fa-mitten{--fa:"\f7b5";--fa--fa:"\f7b5\f7b5"}.fa-person-rays{--fa:"\e54d";--fa--fa:"\e54d\e54d"}.fa-users{--fa:"\f0c0";--fa--fa:"\f0c0\f0c0"}.fa-eye-slash{--fa:"\f070";--fa--fa:"\f070\f070"}.fa-flask-vial{--fa:"\e4f3";--fa--fa:"\e4f3\e4f3"}.fa-hand,.fa-hand-paper{--fa:"\f256";--fa--fa:"\f256\f256"}.fa-om{--fa:"\f679";--fa--fa:"\f679\f679"}.fa-worm{--fa:"\e599";--fa--fa:"\e599\e599"}.fa-house-circle-xmark{--fa:"\e50b";--fa--fa:"\e50b\e50b"}.fa-plug{--fa:"\f1e6";--fa--fa:"\f1e6\f1e6"}.fa-chevron-up{--fa:"\f077";--fa--fa:"\f077\f077"}.fa-hand-spock{--fa:"\f259";--fa--fa:"\f259\f259"}.fa-stopwatch{--fa:"\f2f2";--fa--fa:"\f2f2\f2f2"}.fa-face-kiss,.fa-kiss{--fa:"\f596";--fa--fa:"\f596\f596"}.fa-bridge-circle-xmark{--fa:"\e4cb";--fa--fa:"\e4cb\e4cb"}.fa-face-grin-tongue,.fa-grin-tongue{--fa:"\f589";--fa--fa:"\f589\f589"}.fa-chess-bishop{--fa:"\f43a";--fa--fa:"\f43a\f43a"}.fa-face-grin-wink,.fa-grin-wink{--fa:"\f58c";--fa--fa:"\f58c\f58c"}.fa-deaf,.fa-deafness,.fa-ear-deaf,.fa-hard-of-hearing{--fa:"\f2a4";--fa--fa:"\f2a4\f2a4"}.fa-road-circle-check{--fa:"\e564";--fa--fa:"\e564\e564"}.fa-dice-five{--fa:"\f523";--fa--fa:"\f523\f523"}.fa-rss-square,.fa-square-rss{--fa:"\f143";--fa--fa:"\f143\f143"}.fa-land-mine-on{--fa:"\e51b";--fa--fa:"\e51b\e51b"}.fa-i-cursor{--fa:"\f246";--fa--fa:"\f246\f246"}.fa-stamp{--fa:"\f5bf";--fa--fa:"\f5bf\f5bf"}.fa-stairs{--fa:"\e289";--fa--fa:"\e289\e289"}.fa-i{--fa:"\49";--fa--fa:"\49\49"}.fa-hryvnia,.fa-hryvnia-sign{--fa:"\f6f2";--fa--fa:"\f6f2\f6f2"}.fa-pills{--fa:"\f484";--fa--fa:"\f484\f484"}.fa-face-grin-wide,.fa-grin-alt{--fa:"\f581";--fa--fa:"\f581\f581"}.fa-tooth{--fa:"\f5c9";--fa--fa:"\f5c9\f5c9"}.fa-v{--fa:"\56";--fa--fa:"\56\56"}.fa-bangladeshi-taka-sign{--fa:"\e2e6";--fa--fa:"\e2e6\e2e6"}.fa-bicycle{--fa:"\f206";--fa--fa:"\f206\f206"}.fa-rod-asclepius,.fa-rod-snake,.fa-staff-aesculapius,.fa-staff-snake{--fa:"\e579";--fa--fa:"\e579\e579"}.fa-head-side-cough-slash{--fa:"\e062";--fa--fa:"\e062\e062"}.fa-ambulance,.fa-truck-medical{--fa:"\f0f9";--fa--fa:"\f0f9\f0f9"}.fa-wheat-awn-circle-exclamation{--fa:"\e598";--fa--fa:"\e598\e598"}.fa-snowman{--fa:"\f7d0";--fa--fa:"\f7d0\f7d0"}.fa-mortar-pestle{--fa:"\f5a7";--fa--fa:"\f5a7\f5a7"}.fa-road-barrier{--fa:"\e562";--fa--fa:"\e562\e562"}.fa-school{--fa:"\f549";--fa--fa:"\f549\f549"}.fa-igloo{--fa:"\f7ae";--fa--fa:"\f7ae\f7ae"}.fa-joint{--fa:"\f595";--fa--fa:"\f595\f595"}.fa-angle-right{--fa:"\f105";--fa--fa:"\f105\f105"}.fa-horse{--fa:"\f6f0";--fa--fa:"\f6f0\f6f0"}.fa-q{--fa:"\51";--fa--fa:"\51\51"}.fa-g{--fa:"\47";--fa--fa:"\47\47"}.fa-notes-medical{--fa:"\f481";--fa--fa:"\f481\f481"}.fa-temperature-2,.fa-temperature-half,.fa-thermometer-2,.fa-thermometer-half{--fa:"\f2c9";--fa--fa:"\f2c9\f2c9"}.fa-dong-sign{--fa:"\e169";--fa--fa:"\e169\e169"}.fa-capsules{--fa:"\f46b";--fa--fa:"\f46b\f46b"}.fa-poo-bolt,.fa-poo-storm{--fa:"\f75a";--fa--fa:"\f75a\f75a"}.fa-face-frown-open,.fa-frown-open{--fa:"\f57a";--fa--fa:"\f57a\f57a"}.fa-hand-point-up{--fa:"\f0a6";--fa--fa:"\f0a6\f0a6"}.fa-money-bill{--fa:"\f0d6";--fa--fa:"\f0d6\f0d6"}.fa-bookmark{--fa:"\f02e";--fa--fa:"\f02e\f02e"}.fa-align-justify{--fa:"\f039";--fa--fa:"\f039\f039"}.fa-umbrella-beach{--fa:"\f5ca";--fa--fa:"\f5ca\f5ca"}.fa-helmet-un{--fa:"\e503";--fa--fa:"\e503\e503"}.fa-bullseye{--fa:"\f140";--fa--fa:"\f140\f140"}.fa-bacon{--fa:"\f7e5";--fa--fa:"\f7e5\f7e5"}.fa-hand-point-down{--fa:"\f0a7";--fa--fa:"\f0a7\f0a7"}.fa-arrow-up-from-bracket{--fa:"\e09a";--fa--fa:"\e09a\e09a"}.fa-folder,.fa-folder-blank{--fa:"\f07b";--fa--fa:"\f07b\f07b"}.fa-file-medical-alt,.fa-file-waveform{--fa:"\f478";--fa--fa:"\f478\f478"}.fa-radiation{--fa:"\f7b9";--fa--fa:"\f7b9\f7b9"}.fa-chart-simple{--fa:"\e473";--fa--fa:"\e473\e473"}.fa-mars-stroke{--fa:"\f229";--fa--fa:"\f229\f229"}.fa-vial{--fa:"\f492";--fa--fa:"\f492\f492"}.fa-dashboard,.fa-gauge,.fa-gauge-med,.fa-tachometer-alt-average{--fa:"\f624";--fa--fa:"\f624\f624"}.fa-magic-wand-sparkles,.fa-wand-magic-sparkles{--fa:"\e2ca";--fa--fa:"\e2ca\e2ca"}.fa-e{--fa:"\45";--fa--fa:"\45\45"}.fa-pen-alt,.fa-pen-clip{--fa:"\f305";--fa--fa:"\f305\f305"}.fa-bridge-circle-exclamation{--fa:"\e4ca";--fa--fa:"\e4ca\e4ca"}.fa-user{--fa:"\f007";--fa--fa:"\f007\f007"}.fa-school-circle-check{--fa:"\e56b";--fa--fa:"\e56b\e56b"}.fa-dumpster{--fa:"\f793";--fa--fa:"\f793\f793"}.fa-shuttle-van,.fa-van-shuttle{--fa:"\f5b6";--fa--fa:"\f5b6\f5b6"}.fa-building-user{--fa:"\e4da";--fa--fa:"\e4da\e4da"}.fa-caret-square-left,.fa-square-caret-left{--fa:"\f191";--fa--fa:"\f191\f191"}.fa-highlighter{--fa:"\f591";--fa--fa:"\f591\f591"}.fa-key{--fa:"\f084";--fa--fa:"\f084\f084"}.fa-bullhorn{--fa:"\f0a1";--fa--fa:"\f0a1\f0a1"}.fa-globe{--fa:"\f0ac";--fa--fa:"\f0ac\f0ac"}.fa-synagogue{--fa:"\f69b";--fa--fa:"\f69b\f69b"}.fa-person-half-dress{--fa:"\e548";--fa--fa:"\e548\e548"}.fa-road-bridge{--fa:"\e563";--fa--fa:"\e563\e563"}.fa-location-arrow{--fa:"\f124";--fa--fa:"\f124\f124"}.fa-c{--fa:"\43";--fa--fa:"\43\43"}.fa-tablet-button{--fa:"\f10a";--fa--fa:"\f10a\f10a"}.fa-building-lock{--fa:"\e4d6";--fa--fa:"\e4d6\e4d6"}.fa-pizza-slice{--fa:"\f818";--fa--fa:"\f818\f818"}.fa-money-bill-wave{--fa:"\f53a";--fa--fa:"\f53a\f53a"}.fa-area-chart,.fa-chart-area{--fa:"\f1fe";--fa--fa:"\f1fe\f1fe"}.fa-house-flag{--fa:"\e50d";--fa--fa:"\e50d\e50d"}.fa-person-circle-minus{--fa:"\e540";--fa--fa:"\e540\e540"}.fa-ban,.fa-cancel{--fa:"\f05e";--fa--fa:"\f05e\f05e"}.fa-camera-rotate{--fa:"\e0d8";--fa--fa:"\e0d8\e0d8"}.fa-air-freshener,.fa-spray-can-sparkles{--fa:"\f5d0";--fa--fa:"\f5d0\f5d0"}.fa-star{--fa:"\f005";--fa--fa:"\f005\f005"}.fa-repeat{--fa:"\f363";--fa--fa:"\f363\f363"}.fa-cross{--fa:"\f654";--fa--fa:"\f654\f654"}.fa-box{--fa:"\f466";--fa--fa:"\f466\f466"}.fa-venus-mars{--fa:"\f228";--fa--fa:"\f228\f228"}.fa-arrow-pointer,.fa-mouse-pointer{--fa:"\f245";--fa--fa:"\f245\f245"}.fa-expand-arrows-alt,.fa-maximize{--fa:"\f31e";--fa--fa:"\f31e\f31e"}.fa-charging-station{--fa:"\f5e7";--fa--fa:"\f5e7\f5e7"}.fa-shapes,.fa-triangle-circle-square{--fa:"\f61f";--fa--fa:"\f61f\f61f"}.fa-random,.fa-shuffle{--fa:"\f074";--fa--fa:"\f074\f074"}.fa-person-running,.fa-running{--fa:"\f70c";--fa--fa:"\f70c\f70c"}.fa-mobile-retro{--fa:"\e527";--fa--fa:"\e527\e527"}.fa-grip-lines-vertical{--fa:"\f7a5";--fa--fa:"\f7a5\f7a5"}.fa-spider{--fa:"\f717";--fa--fa:"\f717\f717"}.fa-hands-bound{--fa:"\e4f9";--fa--fa:"\e4f9\e4f9"}.fa-file-invoice-dollar{--fa:"\f571";--fa--fa:"\f571\f571"}.fa-plane-circle-exclamation{--fa:"\e556";--fa--fa:"\e556\e556"}.fa-x-ray{--fa:"\f497";--fa--fa:"\f497\f497"}.fa-spell-check{--fa:"\f891";--fa--fa:"\f891\f891"}.fa-slash{--fa:"\f715";--fa--fa:"\f715\f715"}.fa-computer-mouse,.fa-mouse{--fa:"\f8cc";--fa--fa:"\f8cc\f8cc"}.fa-arrow-right-to-bracket,.fa-sign-in{--fa:"\f090";--fa--fa:"\f090\f090"}.fa-shop-slash,.fa-store-alt-slash{--fa:"\e070";--fa--fa:"\e070\e070"}.fa-server{--fa:"\f233";--fa--fa:"\f233\f233"}.fa-virus-covid-slash{--fa:"\e4a9";--fa--fa:"\e4a9\e4a9"}.fa-shop-lock{--fa:"\e4a5";--fa--fa:"\e4a5\e4a5"}.fa-hourglass-1,.fa-hourglass-start{--fa:"\f251";--fa--fa:"\f251\f251"}.fa-blender-phone{--fa:"\f6b6";--fa--fa:"\f6b6\f6b6"}.fa-building-wheat{--fa:"\e4db";--fa--fa:"\e4db\e4db"}.fa-person-breastfeeding{--fa:"\e53a";--fa--fa:"\e53a\e53a"}.fa-right-to-bracket,.fa-sign-in-alt{--fa:"\f2f6";--fa--fa:"\f2f6\f2f6"}.fa-venus{--fa:"\f221";--fa--fa:"\f221\f221"}.fa-passport{--fa:"\f5ab";--fa--fa:"\f5ab\f5ab"}.fa-thumb-tack-slash,.fa-thumbtack-slash{--fa:"\e68f";--fa--fa:"\e68f\e68f"}.fa-heart-pulse,.fa-heartbeat{--fa:"\f21e";--fa--fa:"\f21e\f21e"}.fa-people-carry,.fa-people-carry-box{--fa:"\f4ce";--fa--fa:"\f4ce\f4ce"}.fa-temperature-high{--fa:"\f769";--fa--fa:"\f769\f769"}.fa-microchip{--fa:"\f2db";--fa--fa:"\f2db\f2db"}.fa-crown{--fa:"\f521";--fa--fa:"\f521\f521"}.fa-weight-hanging{--fa:"\f5cd";--fa--fa:"\f5cd\f5cd"}.fa-xmarks-lines{--fa:"\e59a";--fa--fa:"\e59a\e59a"}.fa-file-prescription{--fa:"\f572";--fa--fa:"\f572\f572"}.fa-weight,.fa-weight-scale{--fa:"\f496";--fa--fa:"\f496\f496"}.fa-user-friends,.fa-user-group{--fa:"\f500";--fa--fa:"\f500\f500"}.fa-arrow-up-a-z,.fa-sort-alpha-up{--fa:"\f15e";--fa--fa:"\f15e\f15e"}.fa-chess-knight{--fa:"\f441";--fa--fa:"\f441\f441"}.fa-face-laugh-squint,.fa-laugh-squint{--fa:"\f59b";--fa--fa:"\f59b\f59b"}.fa-wheelchair{--fa:"\f193";--fa--fa:"\f193\f193"}.fa-arrow-circle-up,.fa-circle-arrow-up{--fa:"\f0aa";--fa--fa:"\f0aa\f0aa"}.fa-toggle-on{--fa:"\f205";--fa--fa:"\f205\f205"}.fa-person-walking,.fa-walking{--fa:"\f554";--fa--fa:"\f554\f554"}.fa-l{--fa:"\4c";--fa--fa:"\4c\4c"}.fa-fire{--fa:"\f06d";--fa--fa:"\f06d\f06d"}.fa-bed-pulse,.fa-procedures{--fa:"\f487";--fa--fa:"\f487\f487"}.fa-shuttle-space,.fa-space-shuttle{--fa:"\f197";--fa--fa:"\f197\f197"}.fa-face-laugh,.fa-laugh{--fa:"\f599";--fa--fa:"\f599\f599"}.fa-folder-open{--fa:"\f07c";--fa--fa:"\f07c\f07c"}.fa-heart-circle-plus{--fa:"\e500";--fa--fa:"\e500\e500"}.fa-code-fork{--fa:"\e13b";--fa--fa:"\e13b\e13b"}.fa-city{--fa:"\f64f";--fa--fa:"\f64f\f64f"}.fa-microphone-alt,.fa-microphone-lines{--fa:"\f3c9";--fa--fa:"\f3c9\f3c9"}.fa-pepper-hot{--fa:"\f816";--fa--fa:"\f816\f816"}.fa-unlock{--fa:"\f09c";--fa--fa:"\f09c\f09c"}.fa-colon-sign{--fa:"\e140";--fa--fa:"\e140\e140"}.fa-headset{--fa:"\f590";--fa--fa:"\f590\f590"}.fa-store-slash{--fa:"\e071";--fa--fa:"\e071\e071"}.fa-road-circle-xmark{--fa:"\e566";--fa--fa:"\e566\e566"}.fa-user-minus{--fa:"\f503";--fa--fa:"\f503\f503"}.fa-mars-stroke-up,.fa-mars-stroke-v{--fa:"\f22a";--fa--fa:"\f22a\f22a"}.fa-champagne-glasses,.fa-glass-cheers{--fa:"\f79f";--fa--fa:"\f79f\f79f"}.fa-clipboard{--fa:"\f328";--fa--fa:"\f328\f328"}.fa-house-circle-exclamation{--fa:"\e50a";--fa--fa:"\e50a\e50a"}.fa-file-arrow-up,.fa-file-upload{--fa:"\f574";--fa--fa:"\f574\f574"}.fa-wifi,.fa-wifi-3,.fa-wifi-strong{--fa:"\f1eb";--fa--fa:"\f1eb\f1eb"}.fa-bath,.fa-bathtub{--fa:"\f2cd";--fa--fa:"\f2cd\f2cd"}.fa-underline{--fa:"\f0cd";--fa--fa:"\f0cd\f0cd"}.fa-user-edit,.fa-user-pen{--fa:"\f4ff";--fa--fa:"\f4ff\f4ff"}.fa-signature{--fa:"\f5b7";--fa--fa:"\f5b7\f5b7"}.fa-stroopwafel{--fa:"\f551";--fa--fa:"\f551\f551"}.fa-bold{--fa:"\f032";--fa--fa:"\f032\f032"}.fa-anchor-lock{--fa:"\e4ad";--fa--fa:"\e4ad\e4ad"}.fa-building-ngo{--fa:"\e4d7";--fa--fa:"\e4d7\e4d7"}.fa-manat-sign{--fa:"\e1d5";--fa--fa:"\e1d5\e1d5"}.fa-not-equal{--fa:"\f53e";--fa--fa:"\f53e\f53e"}.fa-border-style,.fa-border-top-left{--fa:"\f853";--fa--fa:"\f853\f853"}.fa-map-location-dot,.fa-map-marked-alt{--fa:"\f5a0";--fa--fa:"\f5a0\f5a0"}.fa-jedi{--fa:"\f669";--fa--fa:"\f669\f669"}.fa-poll,.fa-square-poll-vertical{--fa:"\f681";--fa--fa:"\f681\f681"}.fa-mug-hot{--fa:"\f7b6";--fa--fa:"\f7b6\f7b6"}.fa-battery-car,.fa-car-battery{--fa:"\f5df";--fa--fa:"\f5df\f5df"}.fa-gift{--fa:"\f06b";--fa--fa:"\f06b\f06b"}.fa-dice-two{--fa:"\f528";--fa--fa:"\f528\f528"}.fa-chess-queen{--fa:"\f445";--fa--fa:"\f445\f445"}.fa-glasses{--fa:"\f530";--fa--fa:"\f530\f530"}.fa-chess-board{--fa:"\f43c";--fa--fa:"\f43c\f43c"}.fa-building-circle-check{--fa:"\e4d2";--fa--fa:"\e4d2\e4d2"}.fa-person-chalkboard{--fa:"\e53d";--fa--fa:"\e53d\e53d"}.fa-mars-stroke-h,.fa-mars-stroke-right{--fa:"\f22b";--fa--fa:"\f22b\f22b"}.fa-hand-back-fist,.fa-hand-rock{--fa:"\f255";--fa--fa:"\f255\f255"}.fa-caret-square-up,.fa-square-caret-up{--fa:"\f151";--fa--fa:"\f151\f151"}.fa-cloud-showers-water{--fa:"\e4e4";--fa--fa:"\e4e4\e4e4"}.fa-bar-chart,.fa-chart-bar{--fa:"\f080";--fa--fa:"\f080\f080"}.fa-hands-bubbles,.fa-hands-wash{--fa:"\e05e";--fa--fa:"\e05e\e05e"}.fa-less-than-equal{--fa:"\f537";--fa--fa:"\f537\f537"}.fa-train{--fa:"\f238";--fa--fa:"\f238\f238"}.fa-eye-low-vision,.fa-low-vision{--fa:"\f2a8";--fa--fa:"\f2a8\f2a8"}.fa-crow{--fa:"\f520";--fa--fa:"\f520\f520"}.fa-sailboat{--fa:"\e445";--fa--fa:"\e445\e445"}.fa-window-restore{--fa:"\f2d2";--fa--fa:"\f2d2\f2d2"}.fa-plus-square,.fa-square-plus{--fa:"\f0fe";--fa--fa:"\f0fe\f0fe"}.fa-torii-gate{--fa:"\f6a1";--fa--fa:"\f6a1\f6a1"}.fa-frog{--fa:"\f52e";--fa--fa:"\f52e\f52e"}.fa-bucket{--fa:"\e4cf";--fa--fa:"\e4cf\e4cf"}.fa-image{--fa:"\f03e";--fa--fa:"\f03e\f03e"}.fa-microphone{--fa:"\f130";--fa--fa:"\f130\f130"}.fa-cow{--fa:"\f6c8";--fa--fa:"\f6c8\f6c8"}.fa-caret-up{--fa:"\f0d8";--fa--fa:"\f0d8\f0d8"}.fa-screwdriver{--fa:"\f54a";--fa--fa:"\f54a\f54a"}.fa-folder-closed{--fa:"\e185";--fa--fa:"\e185\e185"}.fa-house-tsunami{--fa:"\e515";--fa--fa:"\e515\e515"}.fa-square-nfi{--fa:"\e576";--fa--fa:"\e576\e576"}.fa-arrow-up-from-ground-water{--fa:"\e4b5";--fa--fa:"\e4b5\e4b5"}.fa-glass-martini-alt,.fa-martini-glass{--fa:"\f57b";--fa--fa:"\f57b\f57b"}.fa-square-binary{--fa:"\e69b";--fa--fa:"\e69b\e69b"}.fa-rotate-back,.fa-rotate-backward,.fa-rotate-left,.fa-undo-alt{--fa:"\f2ea";--fa--fa:"\f2ea\f2ea"}.fa-columns,.fa-table-columns{--fa:"\f0db";--fa--fa:"\f0db\f0db"}.fa-lemon{--fa:"\f094";--fa--fa:"\f094\f094"}.fa-head-side-mask{--fa:"\e063";--fa--fa:"\e063\e063"}.fa-handshake{--fa:"\f2b5";--fa--fa:"\f2b5\f2b5"}.fa-gem{--fa:"\f3a5";--fa--fa:"\f3a5\f3a5"}.fa-dolly,.fa-dolly-box{--fa:"\f472";--fa--fa:"\f472\f472"}.fa-smoking{--fa:"\f48d";--fa--fa:"\f48d\f48d"}.fa-compress-arrows-alt,.fa-minimize{--fa:"\f78c";--fa--fa:"\f78c\f78c"}.fa-monument{--fa:"\f5a6";--fa--fa:"\f5a6\f5a6"}.fa-snowplow{--fa:"\f7d2";--fa--fa:"\f7d2\f7d2"}.fa-angle-double-right,.fa-angles-right{--fa:"\f101";--fa--fa:"\f101\f101"}.fa-cannabis{--fa:"\f55f";--fa--fa:"\f55f\f55f"}.fa-circle-play,.fa-play-circle{--fa:"\f144";--fa--fa:"\f144\f144"}.fa-tablets{--fa:"\f490";--fa--fa:"\f490\f490"}.fa-ethernet{--fa:"\f796";--fa--fa:"\f796\f796"}.fa-eur,.fa-euro,.fa-euro-sign{--fa:"\f153";--fa--fa:"\f153\f153"}.fa-chair{--fa:"\f6c0";--fa--fa:"\f6c0\f6c0"}.fa-check-circle,.fa-circle-check{--fa:"\f058";--fa--fa:"\f058\f058"}.fa-circle-stop,.fa-stop-circle{--fa:"\f28d";--fa--fa:"\f28d\f28d"}.fa-compass-drafting,.fa-drafting-compass{--fa:"\f568";--fa--fa:"\f568\f568"}.fa-plate-wheat{--fa:"\e55a";--fa--fa:"\e55a\e55a"}.fa-icicles{--fa:"\f7ad";--fa--fa:"\f7ad\f7ad"}.fa-person-shelter{--fa:"\e54f";--fa--fa:"\e54f\e54f"}.fa-neuter{--fa:"\f22c";--fa--fa:"\f22c\f22c"}.fa-id-badge{--fa:"\f2c1";--fa--fa:"\f2c1\f2c1"}.fa-marker{--fa:"\f5a1";--fa--fa:"\f5a1\f5a1"}.fa-face-laugh-beam,.fa-laugh-beam{--fa:"\f59a";--fa--fa:"\f59a\f59a"}.fa-helicopter-symbol{--fa:"\e502";--fa--fa:"\e502\e502"}.fa-universal-access{--fa:"\f29a";--fa--fa:"\f29a\f29a"}.fa-chevron-circle-up,.fa-circle-chevron-up{--fa:"\f139";--fa--fa:"\f139\f139"}.fa-lari-sign{--fa:"\e1c8";--fa--fa:"\e1c8\e1c8"}.fa-volcano{--fa:"\f770";--fa--fa:"\f770\f770"}.fa-person-walking-dashed-line-arrow-right{--fa:"\e553";--fa--fa:"\e553\e553"}.fa-gbp,.fa-pound-sign,.fa-sterling-sign{--fa:"\f154";--fa--fa:"\f154\f154"}.fa-viruses{--fa:"\e076";--fa--fa:"\e076\e076"}.fa-square-person-confined{--fa:"\e577";--fa--fa:"\e577\e577"}.fa-user-tie{--fa:"\f508";--fa--fa:"\f508\f508"}.fa-arrow-down-long,.fa-long-arrow-down{--fa:"\f175";--fa--fa:"\f175\f175"}.fa-tent-arrow-down-to-line{--fa:"\e57e";--fa--fa:"\e57e\e57e"}.fa-certificate{--fa:"\f0a3";--fa--fa:"\f0a3\f0a3"}.fa-mail-reply-all,.fa-reply-all{--fa:"\f122";--fa--fa:"\f122\f122"}.fa-suitcase{--fa:"\f0f2";--fa--fa:"\f0f2\f0f2"}.fa-person-skating,.fa-skating{--fa:"\f7c5";--fa--fa:"\f7c5\f7c5"}.fa-filter-circle-dollar,.fa-funnel-dollar{--fa:"\f662";--fa--fa:"\f662\f662"}.fa-camera-retro{--fa:"\f083";--fa--fa:"\f083\f083"}.fa-arrow-circle-down,.fa-circle-arrow-down{--fa:"\f0ab";--fa--fa:"\f0ab\f0ab"}.fa-arrow-right-to-file,.fa-file-import{--fa:"\f56f";--fa--fa:"\f56f\f56f"}.fa-external-link-square,.fa-square-arrow-up-right{--fa:"\f14c";--fa--fa:"\f14c\f14c"}.fa-box-open{--fa:"\f49e";--fa--fa:"\f49e\f49e"}.fa-scroll{--fa:"\f70e";--fa--fa:"\f70e\f70e"}.fa-spa{--fa:"\f5bb";--fa--fa:"\f5bb\f5bb"}.fa-location-pin-lock{--fa:"\e51f";--fa--fa:"\e51f\e51f"}.fa-pause{--fa:"\f04c";--fa--fa:"\f04c\f04c"}.fa-hill-avalanche{--fa:"\e507";--fa--fa:"\e507\e507"}.fa-temperature-0,.fa-temperature-empty,.fa-thermometer-0,.fa-thermometer-empty{--fa:"\f2cb";--fa--fa:"\f2cb\f2cb"}.fa-bomb{--fa:"\f1e2";--fa--fa:"\f1e2\f1e2"}.fa-registered{--fa:"\f25d";--fa--fa:"\f25d\f25d"}.fa-address-card,.fa-contact-card,.fa-vcard{--fa:"\f2bb";--fa--fa:"\f2bb\f2bb"}.fa-balance-scale-right,.fa-scale-unbalanced-flip{--fa:"\f516";--fa--fa:"\f516\f516"}.fa-subscript{--fa:"\f12c";--fa--fa:"\f12c\f12c"}.fa-diamond-turn-right,.fa-directions{--fa:"\f5eb";--fa--fa:"\f5eb\f5eb"}.fa-burst{--fa:"\e4dc";--fa--fa:"\e4dc\e4dc"}.fa-house-laptop,.fa-laptop-house{--fa:"\e066";--fa--fa:"\e066\e066"}.fa-face-tired,.fa-tired{--fa:"\f5c8";--fa--fa:"\f5c8\f5c8"}.fa-money-bills{--fa:"\e1f3";--fa--fa:"\e1f3\e1f3"}.fa-smog{--fa:"\f75f";--fa--fa:"\f75f\f75f"}.fa-crutch{--fa:"\f7f7";--fa--fa:"\f7f7\f7f7"}.fa-cloud-arrow-up,.fa-cloud-upload,.fa-cloud-upload-alt{--fa:"\f0ee";--fa--fa:"\f0ee\f0ee"}.fa-palette{--fa:"\f53f";--fa--fa:"\f53f\f53f"}.fa-arrows-turn-right{--fa:"\e4c0";--fa--fa:"\e4c0\e4c0"}.fa-vest{--fa:"\e085";--fa--fa:"\e085\e085"}.fa-ferry{--fa:"\e4ea";--fa--fa:"\e4ea\e4ea"}.fa-arrows-down-to-people{--fa:"\e4b9";--fa--fa:"\e4b9\e4b9"}.fa-seedling,.fa-sprout{--fa:"\f4d8";--fa--fa:"\f4d8\f4d8"}.fa-arrows-alt-h,.fa-left-right{--fa:"\f337";--fa--fa:"\f337\f337"}.fa-boxes-packing{--fa:"\e4c7";--fa--fa:"\e4c7\e4c7"}.fa-arrow-circle-left,.fa-circle-arrow-left{--fa:"\f0a8";--fa--fa:"\f0a8\f0a8"}.fa-group-arrows-rotate{--fa:"\e4f6";--fa--fa:"\e4f6\e4f6"}.fa-bowl-food{--fa:"\e4c6";--fa--fa:"\e4c6\e4c6"}.fa-candy-cane{--fa:"\f786";--fa--fa:"\f786\f786"}.fa-arrow-down-wide-short,.fa-sort-amount-asc,.fa-sort-amount-down{--fa:"\f160";--fa--fa:"\f160\f160"}.fa-cloud-bolt,.fa-thunderstorm{--fa:"\f76c";--fa--fa:"\f76c\f76c"}.fa-remove-format,.fa-text-slash{--fa:"\f87d";--fa--fa:"\f87d\f87d"}.fa-face-smile-wink,.fa-smile-wink{--fa:"\f4da";--fa--fa:"\f4da\f4da"}.fa-file-word{--fa:"\f1c2";--fa--fa:"\f1c2\f1c2"}.fa-file-powerpoint{--fa:"\f1c4";--fa--fa:"\f1c4\f1c4"}.fa-arrows-h,.fa-arrows-left-right{--fa:"\f07e";--fa--fa:"\f07e\f07e"}.fa-house-lock{--fa:"\e510";--fa--fa:"\e510\e510"}.fa-cloud-arrow-down,.fa-cloud-download,.fa-cloud-download-alt{--fa:"\f0ed";--fa--fa:"\f0ed\f0ed"}.fa-children{--fa:"\e4e1";--fa--fa:"\e4e1\e4e1"}.fa-blackboard,.fa-chalkboard{--fa:"\f51b";--fa--fa:"\f51b\f51b"}.fa-user-alt-slash,.fa-user-large-slash{--fa:"\f4fa";--fa--fa:"\f4fa\f4fa"}.fa-envelope-open{--fa:"\f2b6";--fa--fa:"\f2b6\f2b6"}.fa-handshake-alt-slash,.fa-handshake-simple-slash{--fa:"\e05f";--fa--fa:"\e05f\e05f"}.fa-mattress-pillow{--fa:"\e525";--fa--fa:"\e525\e525"}.fa-guarani-sign{--fa:"\e19a";--fa--fa:"\e19a\e19a"}.fa-arrows-rotate,.fa-refresh,.fa-sync{--fa:"\f021";--fa--fa:"\f021\f021"}.fa-fire-extinguisher{--fa:"\f134";--fa--fa:"\f134\f134"}.fa-cruzeiro-sign{--fa:"\e152";--fa--fa:"\e152\e152"}.fa-greater-than-equal{--fa:"\f532";--fa--fa:"\f532\f532"}.fa-shield-alt,.fa-shield-halved{--fa:"\f3ed";--fa--fa:"\f3ed\f3ed"}.fa-atlas,.fa-book-atlas{--fa:"\f558";--fa--fa:"\f558\f558"}.fa-virus{--fa:"\e074";--fa--fa:"\e074\e074"}.fa-envelope-circle-check{--fa:"\e4e8";--fa--fa:"\e4e8\e4e8"}.fa-layer-group{--fa:"\f5fd";--fa--fa:"\f5fd\f5fd"}.fa-arrows-to-dot{--fa:"\e4be";--fa--fa:"\e4be\e4be"}.fa-archway{--fa:"\f557";--fa--fa:"\f557\f557"}.fa-heart-circle-check{--fa:"\e4fd";--fa--fa:"\e4fd\e4fd"}.fa-house-chimney-crack,.fa-house-damage{--fa:"\f6f1";--fa--fa:"\f6f1\f6f1"}.fa-file-archive,.fa-file-zipper{--fa:"\f1c6";--fa--fa:"\f1c6\f1c6"}.fa-square{--fa:"\f0c8";--fa--fa:"\f0c8\f0c8"}.fa-glass-martini,.fa-martini-glass-empty{--fa:"\f000";--fa--fa:"\f000\f000"}.fa-couch{--fa:"\f4b8";--fa--fa:"\f4b8\f4b8"}.fa-cedi-sign{--fa:"\e0df";--fa--fa:"\e0df\e0df"}.fa-italic{--fa:"\f033";--fa--fa:"\f033\f033"}.fa-table-cells-column-lock{--fa:"\e678";--fa--fa:"\e678\e678"}.fa-church{--fa:"\f51d";--fa--fa:"\f51d\f51d"}.fa-comments-dollar{--fa:"\f653";--fa--fa:"\f653\f653"}.fa-democrat{--fa:"\f747";--fa--fa:"\f747\f747"}.fa-z{--fa:"\5a";--fa--fa:"\5a\5a"}.fa-person-skiing,.fa-skiing{--fa:"\f7c9";--fa--fa:"\f7c9\f7c9"}.fa-road-lock{--fa:"\e567";--fa--fa:"\e567\e567"}.fa-a{--fa:"\41";--fa--fa:"\41\41"}.fa-temperature-arrow-down,.fa-temperature-down{--fa:"\e03f";--fa--fa:"\e03f\e03f"}.fa-feather-alt,.fa-feather-pointed{--fa:"\f56b";--fa--fa:"\f56b\f56b"}.fa-p{--fa:"\50";--fa--fa:"\50\50"}.fa-snowflake{--fa:"\f2dc";--fa--fa:"\f2dc\f2dc"}.fa-newspaper{--fa:"\f1ea";--fa--fa:"\f1ea\f1ea"}.fa-ad,.fa-rectangle-ad{--fa:"\f641";--fa--fa:"\f641\f641"}.fa-arrow-circle-right,.fa-circle-arrow-right{--fa:"\f0a9";--fa--fa:"\f0a9\f0a9"}.fa-filter-circle-xmark{--fa:"\e17b";--fa--fa:"\e17b\e17b"}.fa-locust{--fa:"\e520";--fa--fa:"\e520\e520"}.fa-sort,.fa-unsorted{--fa:"\f0dc";--fa--fa:"\f0dc\f0dc"}.fa-list-1-2,.fa-list-numeric,.fa-list-ol{--fa:"\f0cb";--fa--fa:"\f0cb\f0cb"}.fa-person-dress-burst{--fa:"\e544";--fa--fa:"\e544\e544"}.fa-money-check-alt,.fa-money-check-dollar{--fa:"\f53d";--fa--fa:"\f53d\f53d"}.fa-vector-square{--fa:"\f5cb";--fa--fa:"\f5cb\f5cb"}.fa-bread-slice{--fa:"\f7ec";--fa--fa:"\f7ec\f7ec"}.fa-language{--fa:"\f1ab";--fa--fa:"\f1ab\f1ab"}.fa-face-kiss-wink-heart,.fa-kiss-wink-heart{--fa:"\f598";--fa--fa:"\f598\f598"}.fa-filter{--fa:"\f0b0";--fa--fa:"\f0b0\f0b0"}.fa-question{--fa:"\3f";--fa--fa:"\3f\3f"}.fa-file-signature{--fa:"\f573";--fa--fa:"\f573\f573"}.fa-arrows-alt,.fa-up-down-left-right{--fa:"\f0b2";--fa--fa:"\f0b2\f0b2"}.fa-house-chimney-user{--fa:"\e065";--fa--fa:"\e065\e065"}.fa-hand-holding-heart{--fa:"\f4be";--fa--fa:"\f4be\f4be"}.fa-puzzle-piece{--fa:"\f12e";--fa--fa:"\f12e\f12e"}.fa-money-check{--fa:"\f53c";--fa--fa:"\f53c\f53c"}.fa-star-half-alt,.fa-star-half-stroke{--fa:"\f5c0";--fa--fa:"\f5c0\f5c0"}.fa-code{--fa:"\f121";--fa--fa:"\f121\f121"}.fa-glass-whiskey,.fa-whiskey-glass{--fa:"\f7a0";--fa--fa:"\f7a0\f7a0"}.fa-building-circle-exclamation{--fa:"\e4d3";--fa--fa:"\e4d3\e4d3"}.fa-magnifying-glass-chart{--fa:"\e522";--fa--fa:"\e522\e522"}.fa-arrow-up-right-from-square,.fa-external-link{--fa:"\f08e";--fa--fa:"\f08e\f08e"}.fa-cubes-stacked{--fa:"\e4e6";--fa--fa:"\e4e6\e4e6"}.fa-krw,.fa-won,.fa-won-sign{--fa:"\f159";--fa--fa:"\f159\f159"}.fa-virus-covid{--fa:"\e4a8";--fa--fa:"\e4a8\e4a8"}.fa-austral-sign{--fa:"\e0a9";--fa--fa:"\e0a9\e0a9"}.fa-f{--fa:"\46";--fa--fa:"\46\46"}.fa-leaf{--fa:"\f06c";--fa--fa:"\f06c\f06c"}.fa-road{--fa:"\f018";--fa--fa:"\f018\f018"}.fa-cab,.fa-taxi{--fa:"\f1ba";--fa--fa:"\f1ba\f1ba"}.fa-person-circle-plus{--fa:"\e541";--fa--fa:"\e541\e541"}.fa-chart-pie,.fa-pie-chart{--fa:"\f200";--fa--fa:"\f200\f200"}.fa-bolt-lightning{--fa:"\e0b7";--fa--fa:"\e0b7\e0b7"}.fa-sack-xmark{--fa:"\e56a";--fa--fa:"\e56a\e56a"}.fa-file-excel{--fa:"\f1c3";--fa--fa:"\f1c3\f1c3"}.fa-file-contract{--fa:"\f56c";--fa--fa:"\f56c\f56c"}.fa-fish-fins{--fa:"\e4f2";--fa--fa:"\e4f2\e4f2"}.fa-building-flag{--fa:"\e4d5";--fa--fa:"\e4d5\e4d5"}.fa-face-grin-beam,.fa-grin-beam{--fa:"\f582";--fa--fa:"\f582\f582"}.fa-object-ungroup{--fa:"\f248";--fa--fa:"\f248\f248"}.fa-poop{--fa:"\f619";--fa--fa:"\f619\f619"}.fa-location-pin,.fa-map-marker{--fa:"\f041";--fa--fa:"\f041\f041"}.fa-kaaba{--fa:"\f66b";--fa--fa:"\f66b\f66b"}.fa-toilet-paper{--fa:"\f71e";--fa--fa:"\f71e\f71e"}.fa-hard-hat,.fa-hat-hard,.fa-helmet-safety{--fa:"\f807";--fa--fa:"\f807\f807"}.fa-eject{--fa:"\f052";--fa--fa:"\f052\f052"}.fa-arrow-alt-circle-right,.fa-circle-right{--fa:"\f35a";--fa--fa:"\f35a\f35a"}.fa-plane-circle-check{--fa:"\e555";--fa--fa:"\e555\e555"}.fa-face-rolling-eyes,.fa-meh-rolling-eyes{--fa:"\f5a5";--fa--fa:"\f5a5\f5a5"}.fa-object-group{--fa:"\f247";--fa--fa:"\f247\f247"}.fa-chart-line,.fa-line-chart{--fa:"\f201";--fa--fa:"\f201\f201"}.fa-mask-ventilator{--fa:"\e524";--fa--fa:"\e524\e524"}.fa-arrow-right{--fa:"\f061";--fa--fa:"\f061\f061"}.fa-map-signs,.fa-signs-post{--fa:"\f277";--fa--fa:"\f277\f277"}.fa-cash-register{--fa:"\f788";--fa--fa:"\f788\f788"}.fa-person-circle-question{--fa:"\e542";--fa--fa:"\e542\e542"}.fa-h{--fa:"\48";--fa--fa:"\48\48"}.fa-tarp{--fa:"\e57b";--fa--fa:"\e57b\e57b"}.fa-screwdriver-wrench,.fa-tools{--fa:"\f7d9";--fa--fa:"\f7d9\f7d9"}.fa-arrows-to-eye{--fa:"\e4bf";--fa--fa:"\e4bf\e4bf"}.fa-plug-circle-bolt{--fa:"\e55b";--fa--fa:"\e55b\e55b"}.fa-heart{--fa:"\f004";--fa--fa:"\f004\f004"}.fa-mars-and-venus{--fa:"\f224";--fa--fa:"\f224\f224"}.fa-home-user,.fa-house-user{--fa:"\e1b0";--fa--fa:"\e1b0\e1b0"}.fa-dumpster-fire{--fa:"\f794";--fa--fa:"\f794\f794"}.fa-house-crack{--fa:"\e3b1";--fa--fa:"\e3b1\e3b1"}.fa-cocktail,.fa-martini-glass-citrus{--fa:"\f561";--fa--fa:"\f561\f561"}.fa-face-surprise,.fa-surprise{--fa:"\f5c2";--fa--fa:"\f5c2\f5c2"}.fa-bottle-water{--fa:"\e4c5";--fa--fa:"\e4c5\e4c5"}.fa-circle-pause,.fa-pause-circle{--fa:"\f28b";--fa--fa:"\f28b\f28b"}.fa-toilet-paper-slash{--fa:"\e072";--fa--fa:"\e072\e072"}.fa-apple-alt,.fa-apple-whole{--fa:"\f5d1";--fa--fa:"\f5d1\f5d1"}.fa-kitchen-set{--fa:"\e51a";--fa--fa:"\e51a\e51a"}.fa-r{--fa:"\52";--fa--fa:"\52\52"}.fa-temperature-1,.fa-temperature-quarter,.fa-thermometer-1,.fa-thermometer-quarter{--fa:"\f2ca";--fa--fa:"\f2ca\f2ca"}.fa-cube{--fa:"\f1b2";--fa--fa:"\f1b2\f1b2"}.fa-bitcoin-sign{--fa:"\e0b4";--fa--fa:"\e0b4\e0b4"}.fa-shield-dog{--fa:"\e573";--fa--fa:"\e573\e573"}.fa-solar-panel{--fa:"\f5ba";--fa--fa:"\f5ba\f5ba"}.fa-lock-open{--fa:"\f3c1";--fa--fa:"\f3c1\f3c1"}.fa-elevator{--fa:"\e16d";--fa--fa:"\e16d\e16d"}.fa-money-bill-transfer{--fa:"\e528";--fa--fa:"\e528\e528"}.fa-money-bill-trend-up{--fa:"\e529";--fa--fa:"\e529\e529"}.fa-house-flood-water-circle-arrow-right{--fa:"\e50f";--fa--fa:"\e50f\e50f"}.fa-poll-h,.fa-square-poll-horizontal{--fa:"\f682";--fa--fa:"\f682\f682"}.fa-circle{--fa:"\f111";--fa--fa:"\f111\f111"}.fa-backward-fast,.fa-fast-backward{--fa:"\f049";--fa--fa:"\f049\f049"}.fa-recycle{--fa:"\f1b8";--fa--fa:"\f1b8\f1b8"}.fa-user-astronaut{--fa:"\f4fb";--fa--fa:"\f4fb\f4fb"}.fa-plane-slash{--fa:"\e069";--fa--fa:"\e069\e069"}.fa-trademark{--fa:"\f25c";--fa--fa:"\f25c\f25c"}.fa-basketball,.fa-basketball-ball{--fa:"\f434";--fa--fa:"\f434\f434"}.fa-satellite-dish{--fa:"\f7c0";--fa--fa:"\f7c0\f7c0"}.fa-arrow-alt-circle-up,.fa-circle-up{--fa:"\f35b";--fa--fa:"\f35b\f35b"}.fa-mobile-alt,.fa-mobile-screen-button{--fa:"\f3cd";--fa--fa:"\f3cd\f3cd"}.fa-volume-high,.fa-volume-up{--fa:"\f028";--fa--fa:"\f028\f028"}.fa-users-rays{--fa:"\e593";--fa--fa:"\e593\e593"}.fa-wallet{--fa:"\f555";--fa--fa:"\f555\f555"}.fa-clipboard-check{--fa:"\f46c";--fa--fa:"\f46c\f46c"}.fa-file-audio{--fa:"\f1c7";--fa--fa:"\f1c7\f1c7"}.fa-burger,.fa-hamburger{--fa:"\f805";--fa--fa:"\f805\f805"}.fa-wrench{--fa:"\f0ad";--fa--fa:"\f0ad\f0ad"}.fa-bugs{--fa:"\e4d0";--fa--fa:"\e4d0\e4d0"}.fa-rupee,.fa-rupee-sign{--fa:"\f156";--fa--fa:"\f156\f156"}.fa-file-image{--fa:"\f1c5";--fa--fa:"\f1c5\f1c5"}.fa-circle-question,.fa-question-circle{--fa:"\f059";--fa--fa:"\f059\f059"}.fa-plane-departure{--fa:"\f5b0";--fa--fa:"\f5b0\f5b0"}.fa-handshake-slash{--fa:"\e060";--fa--fa:"\e060\e060"}.fa-book-bookmark{--fa:"\e0bb";--fa--fa:"\e0bb\e0bb"}.fa-code-branch{--fa:"\f126";--fa--fa:"\f126\f126"}.fa-hat-cowboy{--fa:"\f8c0";--fa--fa:"\f8c0\f8c0"}.fa-bridge{--fa:"\e4c8";--fa--fa:"\e4c8\e4c8"}.fa-phone-alt,.fa-phone-flip{--fa:"\f879";--fa--fa:"\f879\f879"}.fa-truck-front{--fa:"\e2b7";--fa--fa:"\e2b7\e2b7"}.fa-cat{--fa:"\f6be";--fa--fa:"\f6be\f6be"}.fa-anchor-circle-exclamation{--fa:"\e4ab";--fa--fa:"\e4ab\e4ab"}.fa-truck-field{--fa:"\e58d";--fa--fa:"\e58d\e58d"}.fa-route{--fa:"\f4d7";--fa--fa:"\f4d7\f4d7"}.fa-clipboard-question{--fa:"\e4e3";--fa--fa:"\e4e3\e4e3"}.fa-panorama{--fa:"\e209";--fa--fa:"\e209\e209"}.fa-comment-medical{--fa:"\f7f5";--fa--fa:"\f7f5\f7f5"}.fa-teeth-open{--fa:"\f62f";--fa--fa:"\f62f\f62f"}.fa-file-circle-minus{--fa:"\e4ed";--fa--fa:"\e4ed\e4ed"}.fa-tags{--fa:"\f02c";--fa--fa:"\f02c\f02c"}.fa-wine-glass{--fa:"\f4e3";--fa--fa:"\f4e3\f4e3"}.fa-fast-forward,.fa-forward-fast{--fa:"\f050";--fa--fa:"\f050\f050"}.fa-face-meh-blank,.fa-meh-blank{--fa:"\f5a4";--fa--fa:"\f5a4\f5a4"}.fa-parking,.fa-square-parking{--fa:"\f540";--fa--fa:"\f540\f540"}.fa-house-signal{--fa:"\e012";--fa--fa:"\e012\e012"}.fa-bars-progress,.fa-tasks-alt{--fa:"\f828";--fa--fa:"\f828\f828"}.fa-faucet-drip{--fa:"\e006";--fa--fa:"\e006\e006"}.fa-cart-flatbed,.fa-dolly-flatbed{--fa:"\f474";--fa--fa:"\f474\f474"}.fa-ban-smoking,.fa-smoking-ban{--fa:"\f54d";--fa--fa:"\f54d\f54d"}.fa-terminal{--fa:"\f120";--fa--fa:"\f120\f120"}.fa-mobile-button{--fa:"\f10b";--fa--fa:"\f10b\f10b"}.fa-house-medical-flag{--fa:"\e514";--fa--fa:"\e514\e514"}.fa-basket-shopping,.fa-shopping-basket{--fa:"\f291";--fa--fa:"\f291\f291"}.fa-tape{--fa:"\f4db";--fa--fa:"\f4db\f4db"}.fa-bus-alt,.fa-bus-simple{--fa:"\f55e";--fa--fa:"\f55e\f55e"}.fa-eye{--fa:"\f06e";--fa--fa:"\f06e\f06e"}.fa-face-sad-cry,.fa-sad-cry{--fa:"\f5b3";--fa--fa:"\f5b3\f5b3"}.fa-audio-description{--fa:"\f29e";--fa--fa:"\f29e\f29e"}.fa-person-military-to-person{--fa:"\e54c";--fa--fa:"\e54c\e54c"}.fa-file-shield{--fa:"\e4f0";--fa--fa:"\e4f0\e4f0"}.fa-user-slash{--fa:"\f506";--fa--fa:"\f506\f506"}.fa-pen{--fa:"\f304";--fa--fa:"\f304\f304"}.fa-tower-observation{--fa:"\e586";--fa--fa:"\e586\e586"}.fa-file-code{--fa:"\f1c9";--fa--fa:"\f1c9\f1c9"}.fa-signal,.fa-signal-5,.fa-signal-perfect{--fa:"\f012";--fa--fa:"\f012\f012"}.fa-bus{--fa:"\f207";--fa--fa:"\f207\f207"}.fa-heart-circle-xmark{--fa:"\e501";--fa--fa:"\e501\e501"}.fa-home-lg,.fa-house-chimney{--fa:"\e3af";--fa--fa:"\e3af\e3af"}.fa-window-maximize{--fa:"\f2d0";--fa--fa:"\f2d0\f2d0"}.fa-face-frown,.fa-frown{--fa:"\f119";--fa--fa:"\f119\f119"}.fa-prescription{--fa:"\f5b1";--fa--fa:"\f5b1\f5b1"}.fa-shop,.fa-store-alt{--fa:"\f54f";--fa--fa:"\f54f\f54f"}.fa-floppy-disk,.fa-save{--fa:"\f0c7";--fa--fa:"\f0c7\f0c7"}.fa-vihara{--fa:"\f6a7";--fa--fa:"\f6a7\f6a7"}.fa-balance-scale-left,.fa-scale-unbalanced{--fa:"\f515";--fa--fa:"\f515\f515"}.fa-sort-asc,.fa-sort-up{--fa:"\f0de";--fa--fa:"\f0de\f0de"}.fa-comment-dots,.fa-commenting{--fa:"\f4ad";--fa--fa:"\f4ad\f4ad"}.fa-plant-wilt{--fa:"\e5aa";--fa--fa:"\e5aa\e5aa"}.fa-diamond{--fa:"\f219";--fa--fa:"\f219\f219"}.fa-face-grin-squint,.fa-grin-squint{--fa:"\f585";--fa--fa:"\f585\f585"}.fa-hand-holding-dollar,.fa-hand-holding-usd{--fa:"\f4c0";--fa--fa:"\f4c0\f4c0"}.fa-chart-diagram{--fa:"\e695";--fa--fa:"\e695\e695"}.fa-bacterium{--fa:"\e05a";--fa--fa:"\e05a\e05a"}.fa-hand-pointer{--fa:"\f25a";--fa--fa:"\f25a\f25a"}.fa-drum-steelpan{--fa:"\f56a";--fa--fa:"\f56a\f56a"}.fa-hand-scissors{--fa:"\f257";--fa--fa:"\f257\f257"}.fa-hands-praying,.fa-praying-hands{--fa:"\f684";--fa--fa:"\f684\f684"}.fa-arrow-right-rotate,.fa-arrow-rotate-forward,.fa-arrow-rotate-right,.fa-redo{--fa:"\f01e";--fa--fa:"\f01e\f01e"}.fa-biohazard{--fa:"\f780";--fa--fa:"\f780\f780"}.fa-location,.fa-location-crosshairs{--fa:"\f601";--fa--fa:"\f601\f601"}.fa-mars-double{--fa:"\f227";--fa--fa:"\f227\f227"}.fa-child-dress{--fa:"\e59c";--fa--fa:"\e59c\e59c"}.fa-users-between-lines{--fa:"\e591";--fa--fa:"\e591\e591"}.fa-lungs-virus{--fa:"\e067";--fa--fa:"\e067\e067"}.fa-face-grin-tears,.fa-grin-tears{--fa:"\f588";--fa--fa:"\f588\f588"}.fa-phone{--fa:"\f095";--fa--fa:"\f095\f095"}.fa-calendar-times,.fa-calendar-xmark{--fa:"\f273";--fa--fa:"\f273\f273"}.fa-child-reaching{--fa:"\e59d";--fa--fa:"\e59d\e59d"}.fa-head-side-virus{--fa:"\e064";--fa--fa:"\e064\e064"}.fa-user-cog,.fa-user-gear{--fa:"\f4fe";--fa--fa:"\f4fe\f4fe"}.fa-arrow-up-1-9,.fa-sort-numeric-up{--fa:"\f163";--fa--fa:"\f163\f163"}.fa-door-closed{--fa:"\f52a";--fa--fa:"\f52a\f52a"}.fa-shield-virus{--fa:"\e06c";--fa--fa:"\e06c\e06c"}.fa-dice-six{--fa:"\f526";--fa--fa:"\f526\f526"}.fa-mosquito-net{--fa:"\e52c";--fa--fa:"\e52c\e52c"}.fa-file-fragment{--fa:"\e697";--fa--fa:"\e697\e697"}.fa-bridge-water{--fa:"\e4ce";--fa--fa:"\e4ce\e4ce"}.fa-person-booth{--fa:"\f756";--fa--fa:"\f756\f756"}.fa-text-width{--fa:"\f035";--fa--fa:"\f035\f035"}.fa-hat-wizard{--fa:"\f6e8";--fa--fa:"\f6e8\f6e8"}.fa-pen-fancy{--fa:"\f5ac";--fa--fa:"\f5ac\f5ac"}.fa-digging,.fa-person-digging{--fa:"\f85e";--fa--fa:"\f85e\f85e"}.fa-trash{--fa:"\f1f8";--fa--fa:"\f1f8\f1f8"}.fa-gauge-simple,.fa-gauge-simple-med,.fa-tachometer-average{--fa:"\f629";--fa--fa:"\f629\f629"}.fa-book-medical{--fa:"\f7e6";--fa--fa:"\f7e6\f7e6"}.fa-poo{--fa:"\f2fe";--fa--fa:"\f2fe\f2fe"}.fa-quote-right,.fa-quote-right-alt{--fa:"\f10e";--fa--fa:"\f10e\f10e"}.fa-shirt,.fa-t-shirt,.fa-tshirt{--fa:"\f553";--fa--fa:"\f553\f553"}.fa-cubes{--fa:"\f1b3";--fa--fa:"\f1b3\f1b3"}.fa-divide{--fa:"\f529";--fa--fa:"\f529\f529"}.fa-tenge,.fa-tenge-sign{--fa:"\f7d7";--fa--fa:"\f7d7\f7d7"}.fa-headphones{--fa:"\f025";--fa--fa:"\f025\f025"}.fa-hands-holding{--fa:"\f4c2";--fa--fa:"\f4c2\f4c2"}.fa-hands-clapping{--fa:"\e1a8";--fa--fa:"\e1a8\e1a8"}.fa-republican{--fa:"\f75e";--fa--fa:"\f75e\f75e"}.fa-arrow-left{--fa:"\f060";--fa--fa:"\f060\f060"}.fa-person-circle-xmark{--fa:"\e543";--fa--fa:"\e543\e543"}.fa-ruler{--fa:"\f545";--fa--fa:"\f545\f545"}.fa-align-left{--fa:"\f036";--fa--fa:"\f036\f036"}.fa-dice-d6{--fa:"\f6d1";--fa--fa:"\f6d1\f6d1"}.fa-restroom{--fa:"\f7bd";--fa--fa:"\f7bd\f7bd"}.fa-j{--fa:"\4a";--fa--fa:"\4a\4a"}.fa-users-viewfinder{--fa:"\e595";--fa--fa:"\e595\e595"}.fa-file-video{--fa:"\f1c8";--fa--fa:"\f1c8\f1c8"}.fa-external-link-alt,.fa-up-right-from-square{--fa:"\f35d";--fa--fa:"\f35d\f35d"}.fa-table-cells,.fa-th{--fa:"\f00a";--fa--fa:"\f00a\f00a"}.fa-file-pdf{--fa:"\f1c1";--fa--fa:"\f1c1\f1c1"}.fa-bible,.fa-book-bible{--fa:"\f647";--fa--fa:"\f647\f647"}.fa-o{--fa:"\4f";--fa--fa:"\4f\4f"}.fa-medkit,.fa-suitcase-medical{--fa:"\f0fa";--fa--fa:"\f0fa\f0fa"}.fa-user-secret{--fa:"\f21b";--fa--fa:"\f21b\f21b"}.fa-otter{--fa:"\f700";--fa--fa:"\f700\f700"}.fa-female,.fa-person-dress{--fa:"\f182";--fa--fa:"\f182\f182"}.fa-comment-dollar{--fa:"\f651";--fa--fa:"\f651\f651"}.fa-briefcase-clock,.fa-business-time{--fa:"\f64a";--fa--fa:"\f64a\f64a"}.fa-table-cells-large,.fa-th-large{--fa:"\f009";--fa--fa:"\f009\f009"}.fa-book-tanakh,.fa-tanakh{--fa:"\f827";--fa--fa:"\f827\f827"}.fa-phone-volume,.fa-volume-control-phone{--fa:"\f2a0";--fa--fa:"\f2a0\f2a0"}.fa-hat-cowboy-side{--fa:"\f8c1";--fa--fa:"\f8c1\f8c1"}.fa-clipboard-user{--fa:"\f7f3";--fa--fa:"\f7f3\f7f3"}.fa-child{--fa:"\f1ae";--fa--fa:"\f1ae\f1ae"}.fa-lira-sign{--fa:"\f195";--fa--fa:"\f195\f195"}.fa-satellite{--fa:"\f7bf";--fa--fa:"\f7bf\f7bf"}.fa-plane-lock{--fa:"\e558";--fa--fa:"\e558\e558"}.fa-tag{--fa:"\f02b";--fa--fa:"\f02b\f02b"}.fa-comment{--fa:"\f075";--fa--fa:"\f075\f075"}.fa-birthday-cake,.fa-cake,.fa-cake-candles{--fa:"\f1fd";--fa--fa:"\f1fd\f1fd"}.fa-envelope{--fa:"\f0e0";--fa--fa:"\f0e0\f0e0"}.fa-angle-double-up,.fa-angles-up{--fa:"\f102";--fa--fa:"\f102\f102"}.fa-paperclip{--fa:"\f0c6";--fa--fa:"\f0c6\f0c6"}.fa-arrow-right-to-city{--fa:"\e4b3";--fa--fa:"\e4b3\e4b3"}.fa-ribbon{--fa:"\f4d6";--fa--fa:"\f4d6\f4d6"}.fa-lungs{--fa:"\f604";--fa--fa:"\f604\f604"}.fa-arrow-up-9-1,.fa-sort-numeric-up-alt{--fa:"\f887";--fa--fa:"\f887\f887"}.fa-litecoin-sign{--fa:"\e1d3";--fa--fa:"\e1d3\e1d3"}.fa-border-none{--fa:"\f850";--fa--fa:"\f850\f850"}.fa-circle-nodes{--fa:"\e4e2";--fa--fa:"\e4e2\e4e2"}.fa-parachute-box{--fa:"\f4cd";--fa--fa:"\f4cd\f4cd"}.fa-indent{--fa:"\f03c";--fa--fa:"\f03c\f03c"}.fa-truck-field-un{--fa:"\e58e";--fa--fa:"\e58e\e58e"}.fa-hourglass,.fa-hourglass-empty{--fa:"\f254";--fa--fa:"\f254\f254"}.fa-mountain{--fa:"\f6fc";--fa--fa:"\f6fc\f6fc"}.fa-user-doctor,.fa-user-md{--fa:"\f0f0";--fa--fa:"\f0f0\f0f0"}.fa-circle-info,.fa-info-circle{--fa:"\f05a";--fa--fa:"\f05a\f05a"}.fa-cloud-meatball{--fa:"\f73b";--fa--fa:"\f73b\f73b"}.fa-camera,.fa-camera-alt{--fa:"\f030";--fa--fa:"\f030\f030"}.fa-square-virus{--fa:"\e578";--fa--fa:"\e578\e578"}.fa-meteor{--fa:"\f753";--fa--fa:"\f753\f753"}.fa-car-on{--fa:"\e4dd";--fa--fa:"\e4dd\e4dd"}.fa-sleigh{--fa:"\f7cc";--fa--fa:"\f7cc\f7cc"}.fa-arrow-down-1-9,.fa-sort-numeric-asc,.fa-sort-numeric-down{--fa:"\f162";--fa--fa:"\f162\f162"}.fa-hand-holding-droplet,.fa-hand-holding-water{--fa:"\f4c1";--fa--fa:"\f4c1\f4c1"}.fa-water{--fa:"\f773";--fa--fa:"\f773\f773"}.fa-calendar-check{--fa:"\f274";--fa--fa:"\f274\f274"}.fa-braille{--fa:"\f2a1";--fa--fa:"\f2a1\f2a1"}.fa-prescription-bottle-alt,.fa-prescription-bottle-medical{--fa:"\f486";--fa--fa:"\f486\f486"}.fa-landmark{--fa:"\f66f";--fa--fa:"\f66f\f66f"}.fa-truck{--fa:"\f0d1";--fa--fa:"\f0d1\f0d1"}.fa-crosshairs{--fa:"\f05b";--fa--fa:"\f05b\f05b"}.fa-person-cane{--fa:"\e53c";--fa--fa:"\e53c\e53c"}.fa-tent{--fa:"\e57d";--fa--fa:"\e57d\e57d"}.fa-vest-patches{--fa:"\e086";--fa--fa:"\e086\e086"}.fa-check-double{--fa:"\f560";--fa--fa:"\f560\f560"}.fa-arrow-down-a-z,.fa-sort-alpha-asc,.fa-sort-alpha-down{--fa:"\f15d";--fa--fa:"\f15d\f15d"}.fa-money-bill-wheat{--fa:"\e52a";--fa--fa:"\e52a\e52a"}.fa-cookie{--fa:"\f563";--fa--fa:"\f563\f563"}.fa-arrow-left-rotate,.fa-arrow-rotate-back,.fa-arrow-rotate-backward,.fa-arrow-rotate-left,.fa-undo{--fa:"\f0e2";--fa--fa:"\f0e2\f0e2"}.fa-hard-drive,.fa-hdd{--fa:"\f0a0";--fa--fa:"\f0a0\f0a0"}.fa-face-grin-squint-tears,.fa-grin-squint-tears{--fa:"\f586";--fa--fa:"\f586\f586"}.fa-dumbbell{--fa:"\f44b";--fa--fa:"\f44b\f44b"}.fa-list-alt,.fa-rectangle-list{--fa:"\f022";--fa--fa:"\f022\f022"}.fa-tarp-droplet{--fa:"\e57c";--fa--fa:"\e57c\e57c"}.fa-house-medical-circle-check{--fa:"\e511";--fa--fa:"\e511\e511"}.fa-person-skiing-nordic,.fa-skiing-nordic{--fa:"\f7ca";--fa--fa:"\f7ca\f7ca"}.fa-calendar-plus{--fa:"\f271";--fa--fa:"\f271\f271"}.fa-plane-arrival{--fa:"\f5af";--fa--fa:"\f5af\f5af"}.fa-arrow-alt-circle-left,.fa-circle-left{--fa:"\f359";--fa--fa:"\f359\f359"}.fa-subway,.fa-train-subway{--fa:"\f239";--fa--fa:"\f239\f239"}.fa-chart-gantt{--fa:"\e0e4";--fa--fa:"\e0e4\e0e4"}.fa-indian-rupee,.fa-indian-rupee-sign,.fa-inr{--fa:"\e1bc";--fa--fa:"\e1bc\e1bc"}.fa-crop-alt,.fa-crop-simple{--fa:"\f565";--fa--fa:"\f565\f565"}.fa-money-bill-1,.fa-money-bill-alt{--fa:"\f3d1";--fa--fa:"\f3d1\f3d1"}.fa-left-long,.fa-long-arrow-alt-left{--fa:"\f30a";--fa--fa:"\f30a\f30a"}.fa-dna{--fa:"\f471";--fa--fa:"\f471\f471"}.fa-virus-slash{--fa:"\e075";--fa--fa:"\e075\e075"}.fa-minus,.fa-subtract{--fa:"\f068";--fa--fa:"\f068\f068"}.fa-chess{--fa:"\f439";--fa--fa:"\f439\f439"}.fa-arrow-left-long,.fa-long-arrow-left{--fa:"\f177";--fa--fa:"\f177\f177"}.fa-plug-circle-check{--fa:"\e55c";--fa--fa:"\e55c\e55c"}.fa-street-view{--fa:"\f21d";--fa--fa:"\f21d\f21d"}.fa-franc-sign{--fa:"\e18f";--fa--fa:"\e18f\e18f"}.fa-volume-off{--fa:"\f026";--fa--fa:"\f026\f026"}.fa-american-sign-language-interpreting,.fa-asl-interpreting,.fa-hands-american-sign-language-interpreting,.fa-hands-asl-interpreting{--fa:"\f2a3";--fa--fa:"\f2a3\f2a3"}.fa-cog,.fa-gear{--fa:"\f013";--fa--fa:"\f013\f013"}.fa-droplet-slash,.fa-tint-slash{--fa:"\f5c7";--fa--fa:"\f5c7\f5c7"}.fa-mosque{--fa:"\f678";--fa--fa:"\f678\f678"}.fa-mosquito{--fa:"\e52b";--fa--fa:"\e52b\e52b"}.fa-star-of-david{--fa:"\f69a";--fa--fa:"\f69a\f69a"}.fa-person-military-rifle{--fa:"\e54b";--fa--fa:"\e54b\e54b"}.fa-cart-shopping,.fa-shopping-cart{--fa:"\f07a";--fa--fa:"\f07a\f07a"}.fa-vials{--fa:"\f493";--fa--fa:"\f493\f493"}.fa-plug-circle-plus{--fa:"\e55f";--fa--fa:"\e55f\e55f"}.fa-place-of-worship{--fa:"\f67f";--fa--fa:"\f67f\f67f"}.fa-grip-vertical{--fa:"\f58e";--fa--fa:"\f58e\f58e"}.fa-hexagon-nodes{--fa:"\e699";--fa--fa:"\e699\e699"}.fa-arrow-turn-up,.fa-level-up{--fa:"\f148";--fa--fa:"\f148\f148"}.fa-u{--fa:"\55";--fa--fa:"\55\55"}.fa-square-root-alt,.fa-square-root-variable{--fa:"\f698";--fa--fa:"\f698\f698"}.fa-clock,.fa-clock-four{--fa:"\f017";--fa--fa:"\f017\f017"}.fa-backward-step,.fa-step-backward{--fa:"\f048";--fa--fa:"\f048\f048"}.fa-pallet{--fa:"\f482";--fa--fa:"\f482\f482"}.fa-faucet{--fa:"\e005";--fa--fa:"\e005\e005"}.fa-baseball-bat-ball{--fa:"\f432";--fa--fa:"\f432\f432"}.fa-s{--fa:"\53";--fa--fa:"\53\53"}.fa-timeline{--fa:"\e29c";--fa--fa:"\e29c\e29c"}.fa-keyboard{--fa:"\f11c";--fa--fa:"\f11c\f11c"}.fa-caret-down{--fa:"\f0d7";--fa--fa:"\f0d7\f0d7"}.fa-clinic-medical,.fa-house-chimney-medical{--fa:"\f7f2";--fa--fa:"\f7f2\f7f2"}.fa-temperature-3,.fa-temperature-three-quarters,.fa-thermometer-3,.fa-thermometer-three-quarters{--fa:"\f2c8";--fa--fa:"\f2c8\f2c8"}.fa-mobile-android-alt,.fa-mobile-screen{--fa:"\f3cf";--fa--fa:"\f3cf\f3cf"}.fa-plane-up{--fa:"\e22d";--fa--fa:"\e22d\e22d"}.fa-piggy-bank{--fa:"\f4d3";--fa--fa:"\f4d3\f4d3"}.fa-battery-3,.fa-battery-half{--fa:"\f242";--fa--fa:"\f242\f242"}.fa-mountain-city{--fa:"\e52e";--fa--fa:"\e52e\e52e"}.fa-coins{--fa:"\f51e";--fa--fa:"\f51e\f51e"}.fa-khanda{--fa:"\f66d";--fa--fa:"\f66d\f66d"}.fa-sliders,.fa-sliders-h{--fa:"\f1de";--fa--fa:"\f1de\f1de"}.fa-folder-tree{--fa:"\f802";--fa--fa:"\f802\f802"}.fa-network-wired{--fa:"\f6ff";--fa--fa:"\f6ff\f6ff"}.fa-map-pin{--fa:"\f276";--fa--fa:"\f276\f276"}.fa-hamsa{--fa:"\f665";--fa--fa:"\f665\f665"}.fa-cent-sign{--fa:"\e3f5";--fa--fa:"\e3f5\e3f5"}.fa-flask{--fa:"\f0c3";--fa--fa:"\f0c3\f0c3"}.fa-person-pregnant{--fa:"\e31e";--fa--fa:"\e31e\e31e"}.fa-wand-sparkles{--fa:"\f72b";--fa--fa:"\f72b\f72b"}.fa-ellipsis-v,.fa-ellipsis-vertical{--fa:"\f142";--fa--fa:"\f142\f142"}.fa-ticket{--fa:"\f145";--fa--fa:"\f145\f145"}.fa-power-off{--fa:"\f011";--fa--fa:"\f011\f011"}.fa-long-arrow-alt-right,.fa-right-long{--fa:"\f30b";--fa--fa:"\f30b\f30b"}.fa-flag-usa{--fa:"\f74d";--fa--fa:"\f74d\f74d"}.fa-laptop-file{--fa:"\e51d";--fa--fa:"\e51d\e51d"}.fa-teletype,.fa-tty{--fa:"\f1e4";--fa--fa:"\f1e4\f1e4"}.fa-diagram-next{--fa:"\e476";--fa--fa:"\e476\e476"}.fa-person-rifle{--fa:"\e54e";--fa--fa:"\e54e\e54e"}.fa-house-medical-circle-exclamation{--fa:"\e512";--fa--fa:"\e512\e512"}.fa-closed-captioning{--fa:"\f20a";--fa--fa:"\f20a\f20a"}.fa-hiking,.fa-person-hiking{--fa:"\f6ec";--fa--fa:"\f6ec\f6ec"}.fa-venus-double{--fa:"\f226";--fa--fa:"\f226\f226"}.fa-images{--fa:"\f302";--fa--fa:"\f302\f302"}.fa-calculator{--fa:"\f1ec";--fa--fa:"\f1ec\f1ec"}.fa-people-pulling{--fa:"\e535";--fa--fa:"\e535\e535"}.fa-n{--fa:"\4e";--fa--fa:"\4e\4e"}.fa-cable-car,.fa-tram{--fa:"\f7da";--fa--fa:"\f7da\f7da"}.fa-cloud-rain{--fa:"\f73d";--fa--fa:"\f73d\f73d"}.fa-building-circle-xmark{--fa:"\e4d4";--fa--fa:"\e4d4\e4d4"}.fa-ship{--fa:"\f21a";--fa--fa:"\f21a\f21a"}.fa-arrows-down-to-line{--fa:"\e4b8";--fa--fa:"\e4b8\e4b8"}.fa-download{--fa:"\f019";--fa--fa:"\f019\f019"}.fa-face-grin,.fa-grin{--fa:"\f580";--fa--fa:"\f580\f580"}.fa-backspace,.fa-delete-left{--fa:"\f55a";--fa--fa:"\f55a\f55a"}.fa-eye-dropper,.fa-eye-dropper-empty,.fa-eyedropper{--fa:"\f1fb";--fa--fa:"\f1fb\f1fb"}.fa-file-circle-check{--fa:"\e5a0";--fa--fa:"\e5a0\e5a0"}.fa-forward{--fa:"\f04e";--fa--fa:"\f04e\f04e"}.fa-mobile,.fa-mobile-android,.fa-mobile-phone{--fa:"\f3ce";--fa--fa:"\f3ce\f3ce"}.fa-face-meh,.fa-meh{--fa:"\f11a";--fa--fa:"\f11a\f11a"}.fa-align-center{--fa:"\f037";--fa--fa:"\f037\f037"}.fa-book-dead,.fa-book-skull{--fa:"\f6b7";--fa--fa:"\f6b7\f6b7"}.fa-drivers-license,.fa-id-card{--fa:"\f2c2";--fa--fa:"\f2c2\f2c2"}.fa-dedent,.fa-outdent{--fa:"\f03b";--fa--fa:"\f03b\f03b"}.fa-heart-circle-exclamation{--fa:"\e4fe";--fa--fa:"\e4fe\e4fe"}.fa-home,.fa-home-alt,.fa-home-lg-alt,.fa-house{--fa:"\f015";--fa--fa:"\f015\f015"}.fa-calendar-week{--fa:"\f784";--fa--fa:"\f784\f784"}.fa-laptop-medical{--fa:"\f812";--fa--fa:"\f812\f812"}.fa-b{--fa:"\42";--fa--fa:"\42\42"}.fa-file-medical{--fa:"\f477";--fa--fa:"\f477\f477"}.fa-dice-one{--fa:"\f525";--fa--fa:"\f525\f525"}.fa-kiwi-bird{--fa:"\f535";--fa--fa:"\f535\f535"}.fa-arrow-right-arrow-left,.fa-exchange{--fa:"\f0ec";--fa--fa:"\f0ec\f0ec"}.fa-redo-alt,.fa-rotate-forward,.fa-rotate-right{--fa:"\f2f9";--fa--fa:"\f2f9\f2f9"}.fa-cutlery,.fa-utensils{--fa:"\f2e7";--fa--fa:"\f2e7\f2e7"}.fa-arrow-up-wide-short,.fa-sort-amount-up{--fa:"\f161";--fa--fa:"\f161\f161"}.fa-mill-sign{--fa:"\e1ed";--fa--fa:"\e1ed\e1ed"}.fa-bowl-rice{--fa:"\e2eb";--fa--fa:"\e2eb\e2eb"}.fa-skull{--fa:"\f54c";--fa--fa:"\f54c\f54c"}.fa-broadcast-tower,.fa-tower-broadcast{--fa:"\f519";--fa--fa:"\f519\f519"}.fa-truck-pickup{--fa:"\f63c";--fa--fa:"\f63c\f63c"}.fa-long-arrow-alt-up,.fa-up-long{--fa:"\f30c";--fa--fa:"\f30c\f30c"}.fa-stop{--fa:"\f04d";--fa--fa:"\f04d\f04d"}.fa-code-merge{--fa:"\f387";--fa--fa:"\f387\f387"}.fa-upload{--fa:"\f093";--fa--fa:"\f093\f093"}.fa-hurricane{--fa:"\f751";--fa--fa:"\f751\f751"}.fa-mound{--fa:"\e52d";--fa--fa:"\e52d\e52d"}.fa-toilet-portable{--fa:"\e583";--fa--fa:"\e583\e583"}.fa-compact-disc{--fa:"\f51f";--fa--fa:"\f51f\f51f"}.fa-file-arrow-down,.fa-file-download{--fa:"\f56d";--fa--fa:"\f56d\f56d"}.fa-caravan{--fa:"\f8ff";--fa--fa:"\f8ff\f8ff"}.fa-shield-cat{--fa:"\e572";--fa--fa:"\e572\e572"}.fa-bolt,.fa-zap{--fa:"\f0e7";--fa--fa:"\f0e7\f0e7"}.fa-glass-water{--fa:"\e4f4";--fa--fa:"\e4f4\e4f4"}.fa-oil-well{--fa:"\e532";--fa--fa:"\e532\e532"}.fa-vault{--fa:"\e2c5";--fa--fa:"\e2c5\e2c5"}.fa-mars{--fa:"\f222";--fa--fa:"\f222\f222"}.fa-toilet{--fa:"\f7d8";--fa--fa:"\f7d8\f7d8"}.fa-plane-circle-xmark{--fa:"\e557";--fa--fa:"\e557\e557"}.fa-cny,.fa-jpy,.fa-rmb,.fa-yen,.fa-yen-sign{--fa:"\f157";--fa--fa:"\f157\f157"}.fa-rouble,.fa-rub,.fa-ruble,.fa-ruble-sign{--fa:"\f158";--fa--fa:"\f158\f158"}.fa-sun{--fa:"\f185";--fa--fa:"\f185\f185"}.fa-guitar{--fa:"\f7a6";--fa--fa:"\f7a6\f7a6"}.fa-face-laugh-wink,.fa-laugh-wink{--fa:"\f59c";--fa--fa:"\f59c\f59c"}.fa-horse-head{--fa:"\f7ab";--fa--fa:"\f7ab\f7ab"}.fa-bore-hole{--fa:"\e4c3";--fa--fa:"\e4c3\e4c3"}.fa-industry{--fa:"\f275";--fa--fa:"\f275\f275"}.fa-arrow-alt-circle-down,.fa-circle-down{--fa:"\f358";--fa--fa:"\f358\f358"}.fa-arrows-turn-to-dots{--fa:"\e4c1";--fa--fa:"\e4c1\e4c1"}.fa-florin-sign{--fa:"\e184";--fa--fa:"\e184\e184"}.fa-arrow-down-short-wide,.fa-sort-amount-desc,.fa-sort-amount-down-alt{--fa:"\f884";--fa--fa:"\f884\f884"}.fa-less-than{--fa:"\3c";--fa--fa:"\3c\3c"}.fa-angle-down{--fa:"\f107";--fa--fa:"\f107\f107"}.fa-car-tunnel{--fa:"\e4de";--fa--fa:"\e4de\e4de"}.fa-head-side-cough{--fa:"\e061";--fa--fa:"\e061\e061"}.fa-grip-lines{--fa:"\f7a4";--fa--fa:"\f7a4\f7a4"}.fa-thumbs-down{--fa:"\f165";--fa--fa:"\f165\f165"}.fa-user-lock{--fa:"\f502";--fa--fa:"\f502\f502"}.fa-arrow-right-long,.fa-long-arrow-right{--fa:"\f178";--fa--fa:"\f178\f178"}.fa-anchor-circle-xmark{--fa:"\e4ac";--fa--fa:"\e4ac\e4ac"}.fa-ellipsis,.fa-ellipsis-h{--fa:"\f141";--fa--fa:"\f141\f141"}.fa-chess-pawn{--fa:"\f443";--fa--fa:"\f443\f443"}.fa-first-aid,.fa-kit-medical{--fa:"\f479";--fa--fa:"\f479\f479"}.fa-person-through-window{--fa:"\e5a9";--fa--fa:"\e5a9\e5a9"}.fa-toolbox{--fa:"\f552";--fa--fa:"\f552\f552"}.fa-hands-holding-circle{--fa:"\e4fb";--fa--fa:"\e4fb\e4fb"}.fa-bug{--fa:"\f188";--fa--fa:"\f188\f188"}.fa-credit-card,.fa-credit-card-alt{--fa:"\f09d";--fa--fa:"\f09d\f09d"}.fa-automobile,.fa-car{--fa:"\f1b9";--fa--fa:"\f1b9\f1b9"}.fa-hand-holding-hand{--fa:"\e4f7";--fa--fa:"\e4f7\e4f7"}.fa-book-open-reader,.fa-book-reader{--fa:"\f5da";--fa--fa:"\f5da\f5da"}.fa-mountain-sun{--fa:"\e52f";--fa--fa:"\e52f\e52f"}.fa-arrows-left-right-to-line{--fa:"\e4ba";--fa--fa:"\e4ba\e4ba"}.fa-dice-d20{--fa:"\f6cf";--fa--fa:"\f6cf\f6cf"}.fa-truck-droplet{--fa:"\e58c";--fa--fa:"\e58c\e58c"}.fa-file-circle-xmark{--fa:"\e5a1";--fa--fa:"\e5a1\e5a1"}.fa-temperature-arrow-up,.fa-temperature-up{--fa:"\e040";--fa--fa:"\e040\e040"}.fa-medal{--fa:"\f5a2";--fa--fa:"\f5a2\f5a2"}.fa-bed{--fa:"\f236";--fa--fa:"\f236\f236"}.fa-h-square,.fa-square-h{--fa:"\f0fd";--fa--fa:"\f0fd\f0fd"}.fa-podcast{--fa:"\f2ce";--fa--fa:"\f2ce\f2ce"}.fa-temperature-4,.fa-temperature-full,.fa-thermometer-4,.fa-thermometer-full{--fa:"\f2c7";--fa--fa:"\f2c7\f2c7"}.fa-bell{--fa:"\f0f3";--fa--fa:"\f0f3\f0f3"}.fa-superscript{--fa:"\f12b";--fa--fa:"\f12b\f12b"}.fa-plug-circle-xmark{--fa:"\e560";--fa--fa:"\e560\e560"}.fa-star-of-life{--fa:"\f621";--fa--fa:"\f621\f621"}.fa-phone-slash{--fa:"\f3dd";--fa--fa:"\f3dd\f3dd"}.fa-paint-roller{--fa:"\f5aa";--fa--fa:"\f5aa\f5aa"}.fa-hands-helping,.fa-handshake-angle{--fa:"\f4c4";--fa--fa:"\f4c4\f4c4"}.fa-location-dot,.fa-map-marker-alt{--fa:"\f3c5";--fa--fa:"\f3c5\f3c5"}.fa-file{--fa:"\f15b";--fa--fa:"\f15b\f15b"}.fa-greater-than{--fa:"\3e";--fa--fa:"\3e\3e"}.fa-person-swimming,.fa-swimmer{--fa:"\f5c4";--fa--fa:"\f5c4\f5c4"}.fa-arrow-down{--fa:"\f063";--fa--fa:"\f063\f063"}.fa-droplet,.fa-tint{--fa:"\f043";--fa--fa:"\f043\f043"}.fa-eraser{--fa:"\f12d";--fa--fa:"\f12d\f12d"}.fa-earth,.fa-earth-america,.fa-earth-americas,.fa-globe-americas{--fa:"\f57d";--fa--fa:"\f57d\f57d"}.fa-person-burst{--fa:"\e53b";--fa--fa:"\e53b\e53b"}.fa-dove{--fa:"\f4ba";--fa--fa:"\f4ba\f4ba"}.fa-battery-0,.fa-battery-empty{--fa:"\f244";--fa--fa:"\f244\f244"}.fa-socks{--fa:"\f696";--fa--fa:"\f696\f696"}.fa-inbox{--fa:"\f01c";--fa--fa:"\f01c\f01c"}.fa-section{--fa:"\e447";--fa--fa:"\e447\e447"}.fa-gauge-high,.fa-tachometer-alt,.fa-tachometer-alt-fast{--fa:"\f625";--fa--fa:"\f625\f625"}.fa-envelope-open-text{--fa:"\f658";--fa--fa:"\f658\f658"}.fa-hospital,.fa-hospital-alt,.fa-hospital-wide{--fa:"\f0f8";--fa--fa:"\f0f8\f0f8"}.fa-wine-bottle{--fa:"\f72f";--fa--fa:"\f72f\f72f"}.fa-chess-rook{--fa:"\f447";--fa--fa:"\f447\f447"}.fa-bars-staggered,.fa-reorder,.fa-stream{--fa:"\f550";--fa--fa:"\f550\f550"}.fa-dharmachakra{--fa:"\f655";--fa--fa:"\f655\f655"}.fa-hotdog{--fa:"\f80f";--fa--fa:"\f80f\f80f"}.fa-blind,.fa-person-walking-with-cane{--fa:"\f29d";--fa--fa:"\f29d\f29d"}.fa-drum{--fa:"\f569";--fa--fa:"\f569\f569"}.fa-ice-cream{--fa:"\f810";--fa--fa:"\f810\f810"}.fa-heart-circle-bolt{--fa:"\e4fc";--fa--fa:"\e4fc\e4fc"}.fa-fax{--fa:"\f1ac";--fa--fa:"\f1ac\f1ac"}.fa-paragraph{--fa:"\f1dd";--fa--fa:"\f1dd\f1dd"}.fa-check-to-slot,.fa-vote-yea{--fa:"\f772";--fa--fa:"\f772\f772"}.fa-star-half{--fa:"\f089";--fa--fa:"\f089\f089"}.fa-boxes,.fa-boxes-alt,.fa-boxes-stacked{--fa:"\f468";--fa--fa:"\f468\f468"}.fa-chain,.fa-link{--fa:"\f0c1";--fa--fa:"\f0c1\f0c1"}.fa-assistive-listening-systems,.fa-ear-listen{--fa:"\f2a2";--fa--fa:"\f2a2\f2a2"}.fa-tree-city{--fa:"\e587";--fa--fa:"\e587\e587"}.fa-play{--fa:"\f04b";--fa--fa:"\f04b\f04b"}.fa-font{--fa:"\f031";--fa--fa:"\f031\f031"}.fa-table-cells-row-lock{--fa:"\e67a";--fa--fa:"\e67a\e67a"}.fa-rupiah-sign{--fa:"\e23d";--fa--fa:"\e23d\e23d"}.fa-magnifying-glass,.fa-search{--fa:"\f002";--fa--fa:"\f002\f002"}.fa-ping-pong-paddle-ball,.fa-table-tennis,.fa-table-tennis-paddle-ball{--fa:"\f45d";--fa--fa:"\f45d\f45d"}.fa-diagnoses,.fa-person-dots-from-line{--fa:"\f470";--fa--fa:"\f470\f470"}.fa-trash-can-arrow-up,.fa-trash-restore-alt{--fa:"\f82a";--fa--fa:"\f82a\f82a"}.fa-naira-sign{--fa:"\e1f6";--fa--fa:"\e1f6\e1f6"}.fa-cart-arrow-down{--fa:"\f218";--fa--fa:"\f218\f218"}.fa-walkie-talkie{--fa:"\f8ef";--fa--fa:"\f8ef\f8ef"}.fa-file-edit,.fa-file-pen{--fa:"\f31c";--fa--fa:"\f31c\f31c"}.fa-receipt{--fa:"\f543";--fa--fa:"\f543\f543"}.fa-pen-square,.fa-pencil-square,.fa-square-pen{--fa:"\f14b";--fa--fa:"\f14b\f14b"}.fa-suitcase-rolling{--fa:"\f5c1";--fa--fa:"\f5c1\f5c1"}.fa-person-circle-exclamation{--fa:"\e53f";--fa--fa:"\e53f\e53f"}.fa-chevron-down{--fa:"\f078";--fa--fa:"\f078\f078"}.fa-battery,.fa-battery-5,.fa-battery-full{--fa:"\f240";--fa--fa:"\f240\f240"}.fa-skull-crossbones{--fa:"\f714";--fa--fa:"\f714\f714"}.fa-code-compare{--fa:"\e13a";--fa--fa:"\e13a\e13a"}.fa-list-dots,.fa-list-ul{--fa:"\f0ca";--fa--fa:"\f0ca\f0ca"}.fa-school-lock{--fa:"\e56f";--fa--fa:"\e56f\e56f"}.fa-tower-cell{--fa:"\e585";--fa--fa:"\e585\e585"}.fa-down-long,.fa-long-arrow-alt-down{--fa:"\f309";--fa--fa:"\f309\f309"}.fa-ranking-star{--fa:"\e561";--fa--fa:"\e561\e561"}.fa-chess-king{--fa:"\f43f";--fa--fa:"\f43f\f43f"}.fa-person-harassing{--fa:"\e549";--fa--fa:"\e549\e549"}.fa-brazilian-real-sign{--fa:"\e46c";--fa--fa:"\e46c\e46c"}.fa-landmark-alt,.fa-landmark-dome{--fa:"\f752";--fa--fa:"\f752\f752"}.fa-arrow-up{--fa:"\f062";--fa--fa:"\f062\f062"}.fa-television,.fa-tv,.fa-tv-alt{--fa:"\f26c";--fa--fa:"\f26c\f26c"}.fa-shrimp{--fa:"\e448";--fa--fa:"\e448\e448"}.fa-list-check,.fa-tasks{--fa:"\f0ae";--fa--fa:"\f0ae\f0ae"}.fa-jug-detergent{--fa:"\e519";--fa--fa:"\e519\e519"}.fa-circle-user,.fa-user-circle{--fa:"\f2bd";--fa--fa:"\f2bd\f2bd"}.fa-user-shield{--fa:"\f505";--fa--fa:"\f505\f505"}.fa-wind{--fa:"\f72e";--fa--fa:"\f72e\f72e"}.fa-car-burst,.fa-car-crash{--fa:"\f5e1";--fa--fa:"\f5e1\f5e1"}.fa-y{--fa:"\59";--fa--fa:"\59\59"}.fa-person-snowboarding,.fa-snowboarding{--fa:"\f7ce";--fa--fa:"\f7ce\f7ce"}.fa-shipping-fast,.fa-truck-fast{--fa:"\f48b";--fa--fa:"\f48b\f48b"}.fa-fish{--fa:"\f578";--fa--fa:"\f578\f578"}.fa-user-graduate{--fa:"\f501";--fa--fa:"\f501\f501"}.fa-adjust,.fa-circle-half-stroke{--fa:"\f042";--fa--fa:"\f042\f042"}.fa-clapperboard{--fa:"\e131";--fa--fa:"\e131\e131"}.fa-circle-radiation,.fa-radiation-alt{--fa:"\f7ba";--fa--fa:"\f7ba\f7ba"}.fa-baseball,.fa-baseball-ball{--fa:"\f433";--fa--fa:"\f433\f433"}.fa-jet-fighter-up{--fa:"\e518";--fa--fa:"\e518\e518"}.fa-diagram-project,.fa-project-diagram{--fa:"\f542";--fa--fa:"\f542\f542"}.fa-copy{--fa:"\f0c5";--fa--fa:"\f0c5\f0c5"}.fa-volume-mute,.fa-volume-times,.fa-volume-xmark{--fa:"\f6a9";--fa--fa:"\f6a9\f6a9"}.fa-hand-sparkles{--fa:"\e05d";--fa--fa:"\e05d\e05d"}.fa-grip,.fa-grip-horizontal{--fa:"\f58d";--fa--fa:"\f58d\f58d"}.fa-share-from-square,.fa-share-square{--fa:"\f14d";--fa--fa:"\f14d\f14d"}.fa-child-combatant,.fa-child-rifle{--fa:"\e4e0";--fa--fa:"\e4e0\e4e0"}.fa-gun{--fa:"\e19b";--fa--fa:"\e19b\e19b"}.fa-phone-square,.fa-square-phone{--fa:"\f098";--fa--fa:"\f098\f098"}.fa-add,.fa-plus{--fa:"\2b";--fa--fa:"\2b\2b"}.fa-expand{--fa:"\f065";--fa--fa:"\f065\f065"}.fa-computer{--fa:"\e4e5";--fa--fa:"\e4e5\e4e5"}.fa-close,.fa-multiply,.fa-remove,.fa-times,.fa-xmark{--fa:"\f00d";--fa--fa:"\f00d\f00d"}.fa-arrows,.fa-arrows-up-down-left-right{--fa:"\f047";--fa--fa:"\f047\f047"}.fa-chalkboard-teacher,.fa-chalkboard-user{--fa:"\f51c";--fa--fa:"\f51c\f51c"}.fa-peso-sign{--fa:"\e222";--fa--fa:"\e222\e222"}.fa-building-shield{--fa:"\e4d8";--fa--fa:"\e4d8\e4d8"}.fa-baby{--fa:"\f77c";--fa--fa:"\f77c\f77c"}.fa-users-line{--fa:"\e592";--fa--fa:"\e592\e592"}.fa-quote-left,.fa-quote-left-alt{--fa:"\f10d";--fa--fa:"\f10d\f10d"}.fa-tractor{--fa:"\f722";--fa--fa:"\f722\f722"}.fa-trash-arrow-up,.fa-trash-restore{--fa:"\f829";--fa--fa:"\f829\f829"}.fa-arrow-down-up-lock{--fa:"\e4b0";--fa--fa:"\e4b0\e4b0"}.fa-lines-leaning{--fa:"\e51e";--fa--fa:"\e51e\e51e"}.fa-ruler-combined{--fa:"\f546";--fa--fa:"\f546\f546"}.fa-copyright{--fa:"\f1f9";--fa--fa:"\f1f9\f1f9"}.fa-equals{--fa:"\3d";--fa--fa:"\3d\3d"}.fa-blender{--fa:"\f517";--fa--fa:"\f517\f517"}.fa-teeth{--fa:"\f62e";--fa--fa:"\f62e\f62e"}.fa-ils,.fa-shekel,.fa-shekel-sign,.fa-sheqel,.fa-sheqel-sign{--fa:"\f20b";--fa--fa:"\f20b\f20b"}.fa-map{--fa:"\f279";--fa--fa:"\f279\f279"}.fa-rocket{--fa:"\f135";--fa--fa:"\f135\f135"}.fa-photo-film,.fa-photo-video{--fa:"\f87c";--fa--fa:"\f87c\f87c"}.fa-folder-minus{--fa:"\f65d";--fa--fa:"\f65d\f65d"}.fa-hexagon-nodes-bolt{--fa:"\e69a";--fa--fa:"\e69a\e69a"}.fa-store{--fa:"\f54e";--fa--fa:"\f54e\f54e"}.fa-arrow-trend-up{--fa:"\e098";--fa--fa:"\e098\e098"}.fa-plug-circle-minus{--fa:"\e55e";--fa--fa:"\e55e\e55e"}.fa-sign,.fa-sign-hanging{--fa:"\f4d9";--fa--fa:"\f4d9\f4d9"}.fa-bezier-curve{--fa:"\f55b";--fa--fa:"\f55b\f55b"}.fa-bell-slash{--fa:"\f1f6";--fa--fa:"\f1f6\f1f6"}.fa-tablet,.fa-tablet-android{--fa:"\f3fb";--fa--fa:"\f3fb\f3fb"}.fa-school-flag{--fa:"\e56e";--fa--fa:"\e56e\e56e"}.fa-fill{--fa:"\f575";--fa--fa:"\f575\f575"}.fa-angle-up{--fa:"\f106";--fa--fa:"\f106\f106"}.fa-drumstick-bite{--fa:"\f6d7";--fa--fa:"\f6d7\f6d7"}.fa-holly-berry{--fa:"\f7aa";--fa--fa:"\f7aa\f7aa"}.fa-chevron-left{--fa:"\f053";--fa--fa:"\f053\f053"}.fa-bacteria{--fa:"\e059";--fa--fa:"\e059\e059"}.fa-hand-lizard{--fa:"\f258";--fa--fa:"\f258\f258"}.fa-notdef{--fa:"\e1fe";--fa--fa:"\e1fe\e1fe"}.fa-disease{--fa:"\f7fa";--fa--fa:"\f7fa\f7fa"}.fa-briefcase-medical{--fa:"\f469";--fa--fa:"\f469\f469"}.fa-genderless{--fa:"\f22d";--fa--fa:"\f22d\f22d"}.fa-chevron-right{--fa:"\f054";--fa--fa:"\f054\f054"}.fa-retweet{--fa:"\f079";--fa--fa:"\f079\f079"}.fa-car-alt,.fa-car-rear{--fa:"\f5de";--fa--fa:"\f5de\f5de"}.fa-pump-soap{--fa:"\e06b";--fa--fa:"\e06b\e06b"}.fa-video-slash{--fa:"\f4e2";--fa--fa:"\f4e2\f4e2"}.fa-battery-2,.fa-battery-quarter{--fa:"\f243";--fa--fa:"\f243\f243"}.fa-radio{--fa:"\f8d7";--fa--fa:"\f8d7\f8d7"}.fa-baby-carriage,.fa-carriage-baby{--fa:"\f77d";--fa--fa:"\f77d\f77d"}.fa-traffic-light{--fa:"\f637";--fa--fa:"\f637\f637"}.fa-thermometer{--fa:"\f491";--fa--fa:"\f491\f491"}.fa-vr-cardboard{--fa:"\f729";--fa--fa:"\f729\f729"}.fa-hand-middle-finger{--fa:"\f806";--fa--fa:"\f806\f806"}.fa-percent,.fa-percentage{--fa:"\25";--fa--fa:"\25\25"}.fa-truck-moving{--fa:"\f4df";--fa--fa:"\f4df\f4df"}.fa-glass-water-droplet{--fa:"\e4f5";--fa--fa:"\e4f5\e4f5"}.fa-display{--fa:"\e163";--fa--fa:"\e163\e163"}.fa-face-smile,.fa-smile{--fa:"\f118";--fa--fa:"\f118\f118"}.fa-thumb-tack,.fa-thumbtack{--fa:"\f08d";--fa--fa:"\f08d\f08d"}.fa-trophy{--fa:"\f091";--fa--fa:"\f091\f091"}.fa-person-praying,.fa-pray{--fa:"\f683";--fa--fa:"\f683\f683"}.fa-hammer{--fa:"\f6e3";--fa--fa:"\f6e3\f6e3"}.fa-hand-peace{--fa:"\f25b";--fa--fa:"\f25b\f25b"}.fa-rotate,.fa-sync-alt{--fa:"\f2f1";--fa--fa:"\f2f1\f2f1"}.fa-spinner{--fa:"\f110";--fa--fa:"\f110\f110"}.fa-robot{--fa:"\f544";--fa--fa:"\f544\f544"}.fa-peace{--fa:"\f67c";--fa--fa:"\f67c\f67c"}.fa-cogs,.fa-gears{--fa:"\f085";--fa--fa:"\f085\f085"}.fa-warehouse{--fa:"\f494";--fa--fa:"\f494\f494"}.fa-arrow-up-right-dots{--fa:"\e4b7";--fa--fa:"\e4b7\e4b7"}.fa-splotch{--fa:"\f5bc";--fa--fa:"\f5bc\f5bc"}.fa-face-grin-hearts,.fa-grin-hearts{--fa:"\f584";--fa--fa:"\f584\f584"}.fa-dice-four{--fa:"\f524";--fa--fa:"\f524\f524"}.fa-sim-card{--fa:"\f7c4";--fa--fa:"\f7c4\f7c4"}.fa-transgender,.fa-transgender-alt{--fa:"\f225";--fa--fa:"\f225\f225"}.fa-mercury{--fa:"\f223";--fa--fa:"\f223\f223"}.fa-arrow-turn-down,.fa-level-down{--fa:"\f149";--fa--fa:"\f149\f149"}.fa-person-falling-burst{--fa:"\e547";--fa--fa:"\e547\e547"}.fa-award{--fa:"\f559";--fa--fa:"\f559\f559"}.fa-ticket-alt,.fa-ticket-simple{--fa:"\f3ff";--fa--fa:"\f3ff\f3ff"}.fa-building{--fa:"\f1ad";--fa--fa:"\f1ad\f1ad"}.fa-angle-double-left,.fa-angles-left{--fa:"\f100";--fa--fa:"\f100\f100"}.fa-qrcode{--fa:"\f029";--fa--fa:"\f029\f029"}.fa-clock-rotate-left,.fa-history{--fa:"\f1da";--fa--fa:"\f1da\f1da"}.fa-face-grin-beam-sweat,.fa-grin-beam-sweat{--fa:"\f583";--fa--fa:"\f583\f583"}.fa-arrow-right-from-file,.fa-file-export{--fa:"\f56e";--fa--fa:"\f56e\f56e"}.fa-shield,.fa-shield-blank{--fa:"\f132";--fa--fa:"\f132\f132"}.fa-arrow-up-short-wide,.fa-sort-amount-up-alt{--fa:"\f885";--fa--fa:"\f885\f885"}.fa-comment-nodes{--fa:"\e696";--fa--fa:"\e696\e696"}.fa-house-medical{--fa:"\e3b2";--fa--fa:"\e3b2\e3b2"}.fa-golf-ball,.fa-golf-ball-tee{--fa:"\f450";--fa--fa:"\f450\f450"}.fa-chevron-circle-left,.fa-circle-chevron-left{--fa:"\f137";--fa--fa:"\f137\f137"}.fa-house-chimney-window{--fa:"\e00d";--fa--fa:"\e00d\e00d"}.fa-pen-nib{--fa:"\f5ad";--fa--fa:"\f5ad\f5ad"}.fa-tent-arrow-turn-left{--fa:"\e580";--fa--fa:"\e580\e580"}.fa-tents{--fa:"\e582";--fa--fa:"\e582\e582"}.fa-magic,.fa-wand-magic{--fa:"\f0d0";--fa--fa:"\f0d0\f0d0"}.fa-dog{--fa:"\f6d3";--fa--fa:"\f6d3\f6d3"}.fa-carrot{--fa:"\f787";--fa--fa:"\f787\f787"}.fa-moon{--fa:"\f186";--fa--fa:"\f186\f186"}.fa-wine-glass-alt,.fa-wine-glass-empty{--fa:"\f5ce";--fa--fa:"\f5ce\f5ce"}.fa-cheese{--fa:"\f7ef";--fa--fa:"\f7ef\f7ef"}.fa-yin-yang{--fa:"\f6ad";--fa--fa:"\f6ad\f6ad"}.fa-music{--fa:"\f001";--fa--fa:"\f001\f001"}.fa-code-commit{--fa:"\f386";--fa--fa:"\f386\f386"}.fa-temperature-low{--fa:"\f76b";--fa--fa:"\f76b\f76b"}.fa-biking,.fa-person-biking{--fa:"\f84a";--fa--fa:"\f84a\f84a"}.fa-broom{--fa:"\f51a";--fa--fa:"\f51a\f51a"}.fa-shield-heart{--fa:"\e574";--fa--fa:"\e574\e574"}.fa-gopuram{--fa:"\f664";--fa--fa:"\f664\f664"}.fa-earth-oceania,.fa-globe-oceania{--fa:"\e47b";--fa--fa:"\e47b\e47b"}.fa-square-xmark,.fa-times-square,.fa-xmark-square{--fa:"\f2d3";--fa--fa:"\f2d3\f2d3"}.fa-hashtag{--fa:"\23";--fa--fa:"\23\23"}.fa-expand-alt,.fa-up-right-and-down-left-from-center{--fa:"\f424";--fa--fa:"\f424\f424"}.fa-oil-can{--fa:"\f613";--fa--fa:"\f613\f613"}.fa-t{--fa:"\54";--fa--fa:"\54\54"}.fa-hippo{--fa:"\f6ed";--fa--fa:"\f6ed\f6ed"}.fa-chart-column{--fa:"\e0e3";--fa--fa:"\e0e3\e0e3"}.fa-infinity{--fa:"\f534";--fa--fa:"\f534\f534"}.fa-vial-circle-check{--fa:"\e596";--fa--fa:"\e596\e596"}.fa-person-arrow-down-to-line{--fa:"\e538";--fa--fa:"\e538\e538"}.fa-voicemail{--fa:"\f897";--fa--fa:"\f897\f897"}.fa-fan{--fa:"\f863";--fa--fa:"\f863\f863"}.fa-person-walking-luggage{--fa:"\e554";--fa--fa:"\e554\e554"}.fa-arrows-alt-v,.fa-up-down{--fa:"\f338";--fa--fa:"\f338\f338"}.fa-cloud-moon-rain{--fa:"\f73c";--fa--fa:"\f73c\f73c"}.fa-calendar{--fa:"\f133";--fa--fa:"\f133\f133"}.fa-trailer{--fa:"\e041";--fa--fa:"\e041\e041"}.fa-bahai,.fa-haykal{--fa:"\f666";--fa--fa:"\f666\f666"}.fa-sd-card{--fa:"\f7c2";--fa--fa:"\f7c2\f7c2"}.fa-dragon{--fa:"\f6d5";--fa--fa:"\f6d5\f6d5"}.fa-shoe-prints{--fa:"\f54b";--fa--fa:"\f54b\f54b"}.fa-circle-plus,.fa-plus-circle{--fa:"\f055";--fa--fa:"\f055\f055"}.fa-face-grin-tongue-wink,.fa-grin-tongue-wink{--fa:"\f58b";--fa--fa:"\f58b\f58b"}.fa-hand-holding{--fa:"\f4bd";--fa--fa:"\f4bd\f4bd"}.fa-plug-circle-exclamation{--fa:"\e55d";--fa--fa:"\e55d\e55d"}.fa-chain-broken,.fa-chain-slash,.fa-link-slash,.fa-unlink{--fa:"\f127";--fa--fa:"\f127\f127"}.fa-clone{--fa:"\f24d";--fa--fa:"\f24d\f24d"}.fa-person-walking-arrow-loop-left{--fa:"\e551";--fa--fa:"\e551\e551"}.fa-arrow-up-z-a,.fa-sort-alpha-up-alt{--fa:"\f882";--fa--fa:"\f882\f882"}.fa-fire-alt,.fa-fire-flame-curved{--fa:"\f7e4";--fa--fa:"\f7e4\f7e4"}.fa-tornado{--fa:"\f76f";--fa--fa:"\f76f\f76f"}.fa-file-circle-plus{--fa:"\e494";--fa--fa:"\e494\e494"}.fa-book-quran,.fa-quran{--fa:"\f687";--fa--fa:"\f687\f687"}.fa-anchor{--fa:"\f13d";--fa--fa:"\f13d\f13d"}.fa-border-all{--fa:"\f84c";--fa--fa:"\f84c\f84c"}.fa-angry,.fa-face-angry{--fa:"\f556";--fa--fa:"\f556\f556"}.fa-cookie-bite{--fa:"\f564";--fa--fa:"\f564\f564"}.fa-arrow-trend-down{--fa:"\e097";--fa--fa:"\e097\e097"}.fa-feed,.fa-rss{--fa:"\f09e";--fa--fa:"\f09e\f09e"}.fa-draw-polygon{--fa:"\f5ee";--fa--fa:"\f5ee\f5ee"}.fa-balance-scale,.fa-scale-balanced{--fa:"\f24e";--fa--fa:"\f24e\f24e"}.fa-gauge-simple-high,.fa-tachometer,.fa-tachometer-fast{--fa:"\f62a";--fa--fa:"\f62a\f62a"}.fa-shower{--fa:"\f2cc";--fa--fa:"\f2cc\f2cc"}.fa-desktop,.fa-desktop-alt{--fa:"\f390";--fa--fa:"\f390\f390"}.fa-m{--fa:"\4d";--fa--fa:"\4d\4d"}.fa-table-list,.fa-th-list{--fa:"\f00b";--fa--fa:"\f00b\f00b"}.fa-comment-sms,.fa-sms{--fa:"\f7cd";--fa--fa:"\f7cd\f7cd"}.fa-book{--fa:"\f02d";--fa--fa:"\f02d\f02d"}.fa-user-plus{--fa:"\f234";--fa--fa:"\f234\f234"}.fa-check{--fa:"\f00c";--fa--fa:"\f00c\f00c"}.fa-battery-4,.fa-battery-three-quarters{--fa:"\f241";--fa--fa:"\f241\f241"}.fa-house-circle-check{--fa:"\e509";--fa--fa:"\e509\e509"}.fa-angle-left{--fa:"\f104";--fa--fa:"\f104\f104"}.fa-diagram-successor{--fa:"\e47a";--fa--fa:"\e47a\e47a"}.fa-truck-arrow-right{--fa:"\e58b";--fa--fa:"\e58b\e58b"}.fa-arrows-split-up-and-left{--fa:"\e4bc";--fa--fa:"\e4bc\e4bc"}.fa-fist-raised,.fa-hand-fist{--fa:"\f6de";--fa--fa:"\f6de\f6de"}.fa-cloud-moon{--fa:"\f6c3";--fa--fa:"\f6c3\f6c3"}.fa-briefcase{--fa:"\f0b1";--fa--fa:"\f0b1\f0b1"}.fa-person-falling{--fa:"\e546";--fa--fa:"\e546\e546"}.fa-image-portrait,.fa-portrait{--fa:"\f3e0";--fa--fa:"\f3e0\f3e0"}.fa-user-tag{--fa:"\f507";--fa--fa:"\f507\f507"}.fa-rug{--fa:"\e569";--fa--fa:"\e569\e569"}.fa-earth-europe,.fa-globe-europe{--fa:"\f7a2";--fa--fa:"\f7a2\f7a2"}.fa-cart-flatbed-suitcase,.fa-luggage-cart{--fa:"\f59d";--fa--fa:"\f59d\f59d"}.fa-rectangle-times,.fa-rectangle-xmark,.fa-times-rectangle,.fa-window-close{--fa:"\f410";--fa--fa:"\f410\f410"}.fa-baht-sign{--fa:"\e0ac";--fa--fa:"\e0ac\e0ac"}.fa-book-open{--fa:"\f518";--fa--fa:"\f518\f518"}.fa-book-journal-whills,.fa-journal-whills{--fa:"\f66a";--fa--fa:"\f66a\f66a"}.fa-handcuffs{--fa:"\e4f8";--fa--fa:"\e4f8\e4f8"}.fa-exclamation-triangle,.fa-triangle-exclamation,.fa-warning{--fa:"\f071";--fa--fa:"\f071\f071"}.fa-database{--fa:"\f1c0";--fa--fa:"\f1c0\f1c0"}.fa-mail-forward,.fa-share{--fa:"\f064";--fa--fa:"\f064\f064"}.fa-bottle-droplet{--fa:"\e4c4";--fa--fa:"\e4c4\e4c4"}.fa-mask-face{--fa:"\e1d7";--fa--fa:"\e1d7\e1d7"}.fa-hill-rockslide{--fa:"\e508";--fa--fa:"\e508\e508"}.fa-exchange-alt,.fa-right-left{--fa:"\f362";--fa--fa:"\f362\f362"}.fa-paper-plane{--fa:"\f1d8";--fa--fa:"\f1d8\f1d8"}.fa-road-circle-exclamation{--fa:"\e565";--fa--fa:"\e565\e565"}.fa-dungeon{--fa:"\f6d9";--fa--fa:"\f6d9\f6d9"}.fa-align-right{--fa:"\f038";--fa--fa:"\f038\f038"}.fa-money-bill-1-wave,.fa-money-bill-wave-alt{--fa:"\f53b";--fa--fa:"\f53b\f53b"}.fa-life-ring{--fa:"\f1cd";--fa--fa:"\f1cd\f1cd"}.fa-hands,.fa-sign-language,.fa-signing{--fa:"\f2a7";--fa--fa:"\f2a7\f2a7"}.fa-calendar-day{--fa:"\f783";--fa--fa:"\f783\f783"}.fa-ladder-water,.fa-swimming-pool,.fa-water-ladder{--fa:"\f5c5";--fa--fa:"\f5c5\f5c5"}.fa-arrows-up-down,.fa-arrows-v{--fa:"\f07d";--fa--fa:"\f07d\f07d"}.fa-face-grimace,.fa-grimace{--fa:"\f57f";--fa--fa:"\f57f\f57f"}.fa-wheelchair-alt,.fa-wheelchair-move{--fa:"\e2ce";--fa--fa:"\e2ce\e2ce"}.fa-level-down-alt,.fa-turn-down{--fa:"\f3be";--fa--fa:"\f3be\f3be"}.fa-person-walking-arrow-right{--fa:"\e552";--fa--fa:"\e552\e552"}.fa-envelope-square,.fa-square-envelope{--fa:"\f199";--fa--fa:"\f199\f199"}.fa-dice{--fa:"\f522";--fa--fa:"\f522\f522"}.fa-bowling-ball{--fa:"\f436";--fa--fa:"\f436\f436"}.fa-brain{--fa:"\f5dc";--fa--fa:"\f5dc\f5dc"}.fa-band-aid,.fa-bandage{--fa:"\f462";--fa--fa:"\f462\f462"}.fa-calendar-minus{--fa:"\f272";--fa--fa:"\f272\f272"}.fa-circle-xmark,.fa-times-circle,.fa-xmark-circle{--fa:"\f057";--fa--fa:"\f057\f057"}.fa-gifts{--fa:"\f79c";--fa--fa:"\f79c\f79c"}.fa-hotel{--fa:"\f594";--fa--fa:"\f594\f594"}.fa-earth-asia,.fa-globe-asia{--fa:"\f57e";--fa--fa:"\f57e\f57e"}.fa-id-card-alt,.fa-id-card-clip{--fa:"\f47f";--fa--fa:"\f47f\f47f"}.fa-magnifying-glass-plus,.fa-search-plus{--fa:"\f00e";--fa--fa:"\f00e\f00e"}.fa-thumbs-up{--fa:"\f164";--fa--fa:"\f164\f164"}.fa-user-clock{--fa:"\f4fd";--fa--fa:"\f4fd\f4fd"}.fa-allergies,.fa-hand-dots{--fa:"\f461";--fa--fa:"\f461\f461"}.fa-file-invoice{--fa:"\f570";--fa--fa:"\f570\f570"}.fa-window-minimize{--fa:"\f2d1";--fa--fa:"\f2d1\f2d1"}.fa-coffee,.fa-mug-saucer{--fa:"\f0f4";--fa--fa:"\f0f4\f0f4"}.fa-brush{--fa:"\f55d";--fa--fa:"\f55d\f55d"}.fa-file-half-dashed{--fa:"\e698";--fa--fa:"\e698\e698"}.fa-mask{--fa:"\f6fa";--fa--fa:"\f6fa\f6fa"}.fa-magnifying-glass-minus,.fa-search-minus{--fa:"\f010";--fa--fa:"\f010\f010"}.fa-ruler-vertical{--fa:"\f548";--fa--fa:"\f548\f548"}.fa-user-alt,.fa-user-large{--fa:"\f406";--fa--fa:"\f406\f406"}.fa-train-tram{--fa:"\e5b4";--fa--fa:"\e5b4\e5b4"}.fa-user-nurse{--fa:"\f82f";--fa--fa:"\f82f\f82f"}.fa-syringe{--fa:"\f48e";--fa--fa:"\f48e\f48e"}.fa-cloud-sun{--fa:"\f6c4";--fa--fa:"\f6c4\f6c4"}.fa-stopwatch-20{--fa:"\e06f";--fa--fa:"\e06f\e06f"}.fa-square-full{--fa:"\f45c";--fa--fa:"\f45c\f45c"}.fa-magnet{--fa:"\f076";--fa--fa:"\f076\f076"}.fa-jar{--fa:"\e516";--fa--fa:"\e516\e516"}.fa-note-sticky,.fa-sticky-note{--fa:"\f249";--fa--fa:"\f249\f249"}.fa-bug-slash{--fa:"\e490";--fa--fa:"\e490\e490"}.fa-arrow-up-from-water-pump{--fa:"\e4b6";--fa--fa:"\e4b6\e4b6"}.fa-bone{--fa:"\f5d7";--fa--fa:"\f5d7\f5d7"}.fa-table-cells-row-unlock{--fa:"\e691";--fa--fa:"\e691\e691"}.fa-user-injured{--fa:"\f728";--fa--fa:"\f728\f728"}.fa-face-sad-tear,.fa-sad-tear{--fa:"\f5b4";--fa--fa:"\f5b4\f5b4"}.fa-plane{--fa:"\f072";--fa--fa:"\f072\f072"}.fa-tent-arrows-down{--fa:"\e581";--fa--fa:"\e581\e581"}.fa-exclamation{--fa:"\21";--fa--fa:"\21\21"}.fa-arrows-spin{--fa:"\e4bb";--fa--fa:"\e4bb\e4bb"}.fa-print{--fa:"\f02f";--fa--fa:"\f02f\f02f"}.fa-try,.fa-turkish-lira,.fa-turkish-lira-sign{--fa:"\e2bb";--fa--fa:"\e2bb\e2bb"}.fa-dollar,.fa-dollar-sign,.fa-usd{--fa:"\24";--fa--fa:"\24\24"}.fa-x{--fa:"\58";--fa--fa:"\58\58"}.fa-magnifying-glass-dollar,.fa-search-dollar{--fa:"\f688";--fa--fa:"\f688\f688"}.fa-users-cog,.fa-users-gear{--fa:"\f509";--fa--fa:"\f509\f509"}.fa-person-military-pointing{--fa:"\e54a";--fa--fa:"\e54a\e54a"}.fa-bank,.fa-building-columns,.fa-institution,.fa-museum,.fa-university{--fa:"\f19c";--fa--fa:"\f19c\f19c"}.fa-umbrella{--fa:"\f0e9";--fa--fa:"\f0e9\f0e9"}.fa-trowel{--fa:"\e589";--fa--fa:"\e589\e589"}.fa-d{--fa:"\44";--fa--fa:"\44\44"}.fa-stapler{--fa:"\e5af";--fa--fa:"\e5af\e5af"}.fa-masks-theater,.fa-theater-masks{--fa:"\f630";--fa--fa:"\f630\f630"}.fa-kip-sign{--fa:"\e1c4";--fa--fa:"\e1c4\e1c4"}.fa-hand-point-left{--fa:"\f0a5";--fa--fa:"\f0a5\f0a5"}.fa-handshake-alt,.fa-handshake-simple{--fa:"\f4c6";--fa--fa:"\f4c6\f4c6"}.fa-fighter-jet,.fa-jet-fighter{--fa:"\f0fb";--fa--fa:"\f0fb\f0fb"}.fa-share-alt-square,.fa-square-share-nodes{--fa:"\f1e1";--fa--fa:"\f1e1\f1e1"}.fa-barcode{--fa:"\f02a";--fa--fa:"\f02a\f02a"}.fa-plus-minus{--fa:"\e43c";--fa--fa:"\e43c\e43c"}.fa-video,.fa-video-camera{--fa:"\f03d";--fa--fa:"\f03d\f03d"}.fa-graduation-cap,.fa-mortar-board{--fa:"\f19d";--fa--fa:"\f19d\f19d"}.fa-hand-holding-medical{--fa:"\e05c";--fa--fa:"\e05c\e05c"}.fa-person-circle-check{--fa:"\e53e";--fa--fa:"\e53e\e53e"}.fa-level-up-alt,.fa-turn-up{--fa:"\f3bf";--fa--fa:"\f3bf\f3bf"} .fa-sr-only,.fa-sr-only-focusable:not(:focus),.sr-only,.sr-only-focusable:not(:focus){position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border-width:0}rclone-v1.71.0/docs/static/fontawesome/css/solid.min.css000066400000000000000000000010741505210326400232140ustar00rootroot00000000000000/*! * Font Awesome Free 6.7.1 by @fontawesome - https://fontawesome.com * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) * Copyright 2024 Fonticons, Inc. */ :host,:root{--fa-style-family-classic:"Font Awesome 6 Free";--fa-font-solid:normal 900 1em/1 "Font Awesome 6 Free"}@font-face{font-family:"Font Awesome 6 Free";font-style:normal;font-weight:900;font-display:block;src:url(../webfonts/fa-solid-900.woff2) format("woff2"),url(../webfonts/fa-solid-900.ttf) format("truetype")}.fa-solid,.fas{font-weight:900}rclone-v1.71.0/docs/static/fontawesome/webfonts/000077500000000000000000000000001505210326400216435ustar00rootroot00000000000000rclone-v1.71.0/docs/static/fontawesome/webfonts/fa-brands-400.ttf000066400000000000000000006334601505210326400245340ustar00rootroot00000000000000  OS/2_x^w(`cmapJ; vglyfQ&head+p6hheaTG$hmtxDlocaPmaxpIQ nameC?post#P.X_< bb  O'LfGLfAWSM!JB @ @@@@@@@@@@@@@@@@ @@@@ @ @  3@$   @@@ p@@@@ @ @@@@@@,@@@@@ @  @      @ @h@@P    @ @@@@@ @@ @@ @ E@@@@@ @@@ @@$$ !%+9Zabcdefghijklmnopqrstuvwxyz'1'S'T'U'W'IRW@`:J1p +/=A\cq|gi(*6L^aknp~\u} !#%1MRWY,16A?B1]{=B!#*0<abcdefghijklmnopqrstuvwxyz'1'S'T'U'W'IRUw@`:J0p +-;@\cq{gi(*6;UZfgjkprsy 017:K^`cmp|\hx#%&MRWY ,16A?B0]z4? )   Kz t?$QF76+) qOK."!   yxwonca`_\QCA@ j f b a J ? ; 7 . , $    P % $  { r o l j e P O H ? 3 1 ) ( | u R K = 7VRL86vr@."rrld !"#$%&'()*+,-./} " \!!#%*+09<Zaabbccddeeffgghhiijjkk ll!mm"nn#oo$pp%qq&rr'ss(tt)uu*vv+ww,xx-yy.zz/'1'1'S'S'T'T'U'U'W'W''0123II4RR5UW6w9GIJ@@K``LMN::OJJPQRS01TppVWZ \^++b-/c;=f@Ai\\kcclqqm{|npsuvggiixz{|((**66;<UUZZffgijjknpqrrsty~ 00}1277:>KL^^`ackmnpp|~"    \\!hu"x}068;<AHJMQ^hiklmpq|} !##%%&1MMRRWWYY ,,1166AA??BB01]]z{ 4= ?B8(llH  X HD(888 !x""$%'0'(*/h/081H123H34578:$:; =|?$@`B BCdCDEIJtL8LMNQR\X[ \P]^T^`abcldhTmnoor<s(su uvwx<x{ |}~|dp 0 l,h4DD@H8`T,dl`X\l8 HÄp\DŽ͠Ҕ 4(Xl,PPTT8D`8    ,H(8Lp ""#T$<$%`&&'(*+X,|-034t669:;X<<>T?d?BCEFHDHJMMOPSSTUXZ[$]\^8__bce4fxgiXjklmn@p4r<rsLyz{|t}~L~D,Dd` 0t\4@,d,4t``ɴ(̤ դנ|Pݐ0hd||(@PXXH88 (  <d t!!%)p)*L*+,4./014P5\6<7|89:;=>D?XAPC4D<EPFHJK<LNPQPSLVW]hlijmqswwxypz@{||}X0(xDPhLx¸Đ˴̤l\xPהHT tp t0<8\< 5777'13#3'17'17#3#17%671167!11!1&'&'@ZZZZ'ZYYYYY3YZ     ::   `  m"4'11&#"132765676'&'`       `js11131716761312##11312##11'&'&771#11'&'&771#1"'&547633171#1"'&54763317167673171# _   : E: E   _   : E: E  __ ;E ;   E ;E ;   E 42111230111''1&1211#"'&5510#01#10101&'&'&'&76767676'&'&''10101"'&'&'&'&7676767514763 0  /0 1     1 1   $       ! #       # "/65114'&#"1327&'&767&'&767w @    I @ $$$$$$$$J211171611''11#"'&5511'&'&76771'1&'&76761514763 p  rs  p  o  rr  p  C DE C B EE C 14'11&#"1#1"331132765513127654'&##15      p      @,6711671&'&'57111676751&'&'--DD----DD--))))D----DD----D`)))))&'&17711#1"33327654'&##1`  .@ `` @ @    `@0"1#"'&54771671312#!1&'&77167&'&'" +<>())  "` *)(><+  ""@D47116331131#1"'&''1&76761316767&'&'#1&'&771#1"'&5  :&''&:O   Oh   x'&::&'  x 96'11&'&1331132765513127654'&##1514'&#"1#17       kr  P P   @?67312##1131#1"'&''1&76761316767&'&'#1"'&77! r:&''&:S   S !  p'&::&'   @!<6'11&'&1116767&'&'711#"'&'&54767632  %--DD--*+@?   k  +9D----DB,-K  D471163!11'&'&71#1"'&5       P @"Dc&'11&'#13167674'&'673#3#1&'&'67673101013101015011101#10101&'&'6767310$%6 6%$#$%6@6%$#@   6%$$%65$ 6%$$%6 $5@@81132767654'&'&#"&'11&'67671'&'&77@   XA+*--DD--$ @  -,BD----D7*  K1111'%1&'67%16}   @ n     @@+"113!127654'&#!"113!127654'&#!0 `  ` @     11117%167&'%1&   @ n     0<I6711673111132765514771676551&'&'#132765676'&'P +'  *$%6 6%$  P   "0  "6%$$%6 P]112#&'&'&'6767671&'&'&'6767632113276551&'&'&'&767R6666R H9:"""":9HH9:"")-$36%$$%6+    66R@  66RR66  "":9HH9:"""":9H )!!$%66%$ P   R66$$$$!(&'11767713117676''1#3#71 x(  (x+HH`  LL  ` @/>11113167674'&'67&'&'##3#51313#3#15@6%$$%6`````````$%6#"06%$@, "327632#"'&'&767632#"'I1<<1//1<<1 DVVD,,DVVD 1//1@@1// AA-9999,BB +67116731#1&'&'3#3#1316767&'&'`?2332?`````D----D`32??23@--DD--@511113127654'&##1513127654'&##1513127654'&##@       @-111132765513127654'&##1513127654'&##@        :116767#1"'&54763312&'&'&'676767'&'D----D;++ }  >>Z?2332?X=  ,?`--DD--$#8  X9:32??237  (2%53276551514'&#"1!1514'&#"13276551!@         @1"113311#1"3!127654'&##113127654'&##  ``  ``     @  @*2111&'&'51476321676714763  --DD--  ))  D----D   )) B565114'&#"11514'&#"1132765517117676''177 .   A j / x kC  ˍ @2111312##1"'&514763@       ,617161#"'&511#"''11#"'&5167      $611476321'11#"'&5167    ( = 5"1132767654'&'&#11#"'&'&'6767632+%%%%++%%%%+45;;5445;;54`%&**&%%&**&%=3333==3333=@.67116731#11#"'&55153#36767&'&'#1`D----D`  @```))``--DD--` ))@71167'1&7676167&'&'&'&'&'6767671'&''@--D,#H G--DD--5D?2332??2350 .D--V  U*7D----D"32??2332?V=9  8B+;111132765513117676''16767&'&'##3#5131@  _g T(()=pppppp""   x$#.=)(""Dj013'110101&'&'&'&#&'&767627676'&'&'01&#&'&'&'&71'1676'&'&'711&c 8 :7E    9  8  :7E    9 W   $@     $@  #"1133113276513127654'&##        `  *2111676751476321&'&'514763  $%66%$  66RR66  6%$$%6 R6666R 611116761&'1&767     9   B.6111167116761#&'11"'1&767 nUUn  QQ   $&   16'11&'&1'1&'&117677117676''17y  k     %&'11&113276551716'&'&1':      ז   &471163!11312#!1&'&71#1"'&5 @         L  ~011&'11&'0&'&'&'&74#1133233167&'&'&'&'&76767674'&'&'&'&'&'&711&'&7067676'&'41`    #/ ,=-3    &   !77D\CB @-* #"""  --&%     &D77 !98X5## ( $H_n767&'&'3#351#7&'11&#113127675531131&'&'&##1131#11316765##3#51311#11311#113''#11#17131'!!!1!127676'&'&'#3#1312#731'~  (OOOO"++-_((_k-,9997 "J   z@@67kk==;:pT G..[[[E>!! S+---K[  [[@:9n+43&%U21ge34 F%67&'&'276274'&767'71''11'&771'1&7637171632112.?>__>??>_)&2F:::;;:HHV5IV::::VW::& ,,,E))E,DD:7716767!1"1111!1676745454545 "!3GGCC13%$%%$,+   (I3!"<<<H2"",-9;22;%&2 ""210A@10B'1''1&77151117151611''11171'11'51477161151'1PPP_`PN_PNNP_Nd...88.\w.]8p/.ww./p8].w\6%&#"327654'&'%!1#3#51#1#"'&'&54767632517+    I555(  8   @@   N  [h776'&'&7&'&'&"#"#"#&0172323237676767676'4545456'&'11&''&76767&'&767676#11"'7&'11&'!11!16767##"#"'"'&5&545474763632322    C%)*(%)*(@[''''  E    -././Z@'''++'4&'&11767716'''716'&'&117676's   \\  \\\\      t {} }}}{  =JW4'"#&#&'&'171&'&'&'&''&'&#"#0'0'&11"#0116767'267671111"'&5017136765&'&'&'&767610'&76' ~ c &- /8     /%   2  _ X O66HH67"  /##  ,+88**4@ '   $ ,   %9   @y ")07>E%3#351#553153#351#3#351#3#351#3#351#3#351#'3#351#3#351#53#351#}}}}}}}}}}=}}}}}}}}}}}}}}}}}}}}}}}}}}}}IeHHHHIIIIIIIIIIII77111016'&'&#67676#1676776751'&'!1534@i;: 78M  9 !!5BDD&+??21:B97@@Y0$%4./E70/ i?4?A-Rax7531#"'&'&7116763671&#167674'%&#"16321&#"32731131514'#'&547632'&##113151312725676'&'##15131277#1'1#111317j9)+""      ^?' ''  $$$%4O)))  002      OY    L? A \\\\x@ _ "%''&5716'&''1414'716'&#'1"1&'716'&#1&'716'&1&'714'&1&''14'&1&#'1&'&1"''1&#"1#'1&1"##'1&11'1&10'1&1#1&10#1"101111111312113711771177101771223177120113277163176771236317657143671765'167176''1671276''1674371276''16571676''14771654'&1#"''1&'&1&'3125514#17131231&'6711#&'6731'77676''1311#1&7'476311&'77312#"'&'&'0'6767&'&'&'&##16713277111#1"1'6731&'"'&76311         %)(& -0  O  X 5   ?     +>)!! #            ## 6#    x#%$ $$$ T    / %(   2%"'1'&'&'&76761&7676513111D70100#!,-3X +$'4)) ''21.-Z] 3%5!1513113155#3#13@}}}@n9f%''"'&763716767714545&'&&#&3!1010127716'&'7"#112#1130101312765&'&'<>A@( j  23 $$5"C"A  (  c  6#$+!!!7676767!131&'&'&'&501!16'JJ !))U8 %YQN88 @## G&&,8 '*+,(DZ%''&#"11327716'73312745'1&##1"''&##1"11331277145#3#"133127716'&#'CoBCCCBBBmBm `+276767654'&'&'&#'71'1!31@     B/.`@    @./B 3#371%''#1'71t-vvvuuutg 9]' b%&511476'&'&'&767676776767676767676545&767676'&'&'74'&'&'! ,HAA   ""          c%,,,!"F$& &   !   9P`%#3#13127654'&#'#3#13127654'!!!1!167671&'&'#!1"'&514763!12#3#13127654'&#1:::: :::: !!!!?}:::: b  b  a!!!!b  *S\eny72767654''171654''1&111327655113"151&'&1'1&#11327716751&'67&'767&'67&''674'&'67&'367&'3767&'67&' uKdtJJ ee %@?? @ >  E+ :s UC++ ::, T  T $ RH2Yq1111676767&'&'&'&'11&5477111777276'&'&'01&311'167632''71654545'1511C66  66CC66  66C( g N   I//80+* "!!! <=[ 66CC66  66CC66 c--5! N +$% \=>h1D]p7#3#'1111#1'1311117131131713211#"'&547632711654'&'3111'&'&5476721151311#'11327654'&'#3#51#1#"'&7513113'5133#31#%%%&-&#$/   "   "" &&&&luuttvv,h    >f   fLF$AW% 5777'13#3'17'17#3#17%671167!11!1&'&'@ZZZZ'ZYYYYY3YZ     ::   `  3 3#3513#351'5'1151#117113SSSSIRRRR|yT p/AA/PII{{iLj"-8Zmx7"51&'#11331276551327654'&#&'51677674'K56'&'1327676'&'&'11#"'&'6763267&'11%"111&5632701716'&#"&'&1132765&'&'"5&##&551312751&'#1514'&##1"111#1"11133113276'V .   # "! #V''''2  #` + > $"l +  !;Z---  -""  ""k       =3@) t0BIb~74'&##1"'&771673167716'0#01#112331677145054'e#1133#371#%#1"10013167141#3#1"3013167716'&'01#3#10010131671417761#1101013013127  "   Q)3i4443,)[)\))) ) 7)))\)\ * )< f)!h)3Qz^))4^))))5Mcy1!1&'&'51676731'1&547632131716321311&'&#!1"1!1676751#"'&55147632131#"'&551676321((( IXK ('  @         X'(+'  EE  F   + ! ! ! ! LHZjz%11#1'&'&76711116705#1"76767673167676#01#01"'&''&'&7676"771633121#'"771633121##3127514##1"%451145&'&7674145   !< e 70)%-,+! 8.&""6,& pq/KD?, %&   + ->+  -+4(,     - (+[761311#"''1312777''1&##1716321#1"'216771633111#1"''1&#"1#1'1&547713 Mab L L baML  M%;;%M  L :: MabLJMaaMLM  M::M L:: ,111311!16767111#111&'&'3671167!11311--77-,7-,7--6$$$$6$$6$$6,11132771654''1&#"#11"'&547632###%00%##%00%""""%00%##%00%##""""3K]%11#'&''1&'&'01'"'&5676767267671%&'11&767476716'&'&'"1715-"", 1##&7))5%##& '2))0'0#"5/0&*E'(K5 V''CI??''0'&%>>L~.005J>/H`@?N>E&9DO\111111111''11'&''1'1511671'1717111111'%7731171'7'''17'1&761* + ED +   ^^^J +)))/)  *   4 '''{z'@c)))ma*MMMBooo U`S;_'&'&76767221231716763221#"'&''1&5476321511##'&'&54767632323214711651167654'&'0'&5&'&7416743436362"#"'&#&5"5&'05&7671#"'&'&541&5511"#"'&547716321#"#&''1167676'&'"'&'01&7&7476767231#&''1&747632167&'&'&76761"'&'676210#"''11_98 HJa,,W@>3$#*)$$  ##W8. >?J,,W@> 34U)0F? '011F? ')NPaaB@e//Y<=WWG" k!!&& "&'++'&!"%&!"&'++&'zD:IICC('c//W<>VWGF1#E>!%#0V#10#F?!$$ 'O6'&''1&'676321674'&'&'&7671'&'&5476761#"''11 ?"!!"?    S2  ?!!!!?   S2  -88=?88- EW.,+$ @-88?=88- EU0,,# 8AJ`~67&'11#"'&5476326731#"'&'&'&'3167%&'6767&''&'&'6767651'6776767676'&'&'671!&'&7677'1O"x""**//*+!"x"#..#ny##  !! !Z! !![..*)  )*..."    "  "" ""   )JS73#31#151315131513155#1131131131133#31#151#11#113151315131131#3#1315`  @ @@@@ `   @@@<111!167671&'&'!3111#11#1515151&567@@Z  @z EE   e!167671&'&'!1'11111001#&''1'1#111&'&771716763601320130131716767632@R,,, E67C -{`@@ ttt3))3t\\ 8AJu~ #&'&'76767'"#&7676765&560127'&563''6"'47674'&'#10101011101301'76'&771'1'171711'1111111'01"#0#'&'&"1&5676767&76'%6'&7356#"3471166'&'3#3256'&'"'&'&5&7620#00101AVU@@%      `\:!   ==   8  $%$' "":9HN> U   Y 0/.L%     _ME`3,-#%!  =  //*+&  H9:""(}(    )B7'6763271!171'171'171'171'1!11#"'&'&'&#&1:::   /********P/   #"  >0 88888888 /3 ? ELeq%6516'&7#1&'&'&'&6711216'011101701116#0111"711611101011111111111111111#13116"'1011111&1111111111717131'111030103&11�'&'&'&7&76'7167115132767614767716767716716767031167763160131727316'1127316001031116'"10105"1&#'111&'&''1111&51101411111110110&'&1&7011163&'4'11050111&510654#1'116'0111"7'4'&'&76711115111116767672&'&43011101010111016571671111016767670711110343670711116'11&77165654161#'111111&'11&'&'0151&'7'7111&'672'4'011101"54701111117716717&'&311011&'0151&'71171'1&'17677%0311016"101111654511&7011|       1)*              :C  $$&e  ##O8  \     #        '&55;%            ,)   /     x   "  *x )  %677167677163271631161001""##&'&55167676321&'&''1&'&'51476321#"'1'&731477145&7654'&#"67'3076744#"""331657410121076577145&''#3#117&'&''1&'&##13276767 ! .-5I-5,6$ *'"0$ " '+<o t "%1&&B4$$u %' %>*&% $%  2 1 &  ! )$. xP "+/Ym%211##1&'&'11116767311&'&'27676'&''&'&7676&'&##1"'16731#1172767&#"1L, #3[i7117ij8 ) ,VV+''+VJ' /$-    #:` (''%5E>ll>EE"0 &662]]26) (!%% ,iE - m111!167671&'&'!#11&'&'111167631121&'&'27676'&''&'&7676&'&'#1&'167311271167&#"#7#@@ "=G$  %FG%:991  &@H    @#.)HH)/. ##">>!$    FD  2;111!167671&'&'!71#1'11#171'1311713''#113@@)hhhz_KV/oubCO/&@TwwwbbZZ!3#311#1'11#171'131173#31#1GGGoGet(((*𑑼䅅N|c11&'&'01&"76'&'&#32767&'&"##"'&'11676'&'&7631&76731&767667676765254##01&'&'01'&'7670567&'&'&'&'�1'&7676'&276'&#&511471 '(0'67K 2E      9.%"1 1@   %   Y  , / '9    !'!!3  )# K      S@A^11"'&'67&'115167673#211111#1"'&'654'117167673#211111#1&'&'6767 3!""!3    3!""!3@"!32!"########"!23!"0I^111!1&'&'16767!116771'1&547&'3116771'1&547&'3116767&'&'@' 'w' '' 'w' '@ )2;D55!15131513151#11#11#11#11373#31#1573#31#1555311#73#31#15I%IIۓIIIIIIIIIJJJJJIIIIIII@IIIIIIIIIIIJJJJIII0%01&'&'47116767677&'11&''1%11*+??+* +G3' *+55+*__#?****?# 3 --MMJ3#3167630111"11111&'&'&'&'&'&'&'&'&'71'12767671116701070367676'&'&'&'&'ї"0110115111672111716'0145&'&'0'45&'&701410567676311636362123231111"011111#0"176'&''1&767011163716765110367&'&'&'01"#&'0111"'&'&1111&1101"'&#1131221111013676767674'&'#&'&'&'&767672165&'&'01"#&#&'#1&'&'&723236763310011111111031NN,           -N              +      +            3  ,**.-  -.**,  3h        ..      {21616110"1#"'&'"'&#)&'&'&'&'&'&'&'01&'&5&14771'1&7436567676767602171633#3#1'0#01"'01&110332767676701676767676767676543'1&771&'&'&'&"01"1''211#&'"'&'&'&76767676356676701'&'&'&'&'6767676767674'4'&'&567672767676'"#&#&#0"#&'"#&7474767656'&1&'&'&'&""#223'&767456'4'&'&'&'&'&'6767670167676013*&        &'         'E                                  , &  <  =  & ,- '! 3    L! ' -                DU111!167671&'&'!11#&'&'1#1&767511'14767676767&'&'"1@@>'')(;!;()6.13@T"#66! 4!+, O%&'11&'676511&'#11&'&551#11367675113171236767&'&'& ###>##  q""A%'<<%$#C "(>))))> G)) +-7''?**((B_'')Ǎ ))AA))*#171#15176767#151311317131131713V5PQp##FIqqE+*  &0;EMU]eow''1673771&'167'47'171&5''167716'1''167'17'7167'71&'67'1771&''671&771'11771'''71&'1717171&'"171767676'&'&'&#" !&{" !&  l "%!d ##&&1 ##&&222  19p""" !w910U*10..!!  ,,1  t!&" && &&=" !&[D1 "%!aG 22 @"! 521990U$$/000''N116767676''&'&'1145&#"11'&'&767'&'&'&'&5476p-((((-)).M*)  )*M.))$55&&55$ &  ! 0%%-((-%%0 ! & '5C!!!"13!1276514'&#11#167633511#167673511#167673x x !  x rr,o!!!1!1&'&'16767671162#&'&''&'##1#"'&551#1132765511317111030301216767&'&'8PP    !  $"! % ##"P'   *N  NN#$5oO $$:171&567671#1&''1&'&56767171&'6767tjh   q((q   hj!]    $$    ]!E111!167671&'&'!'71&5671#1&''1&'67171&'67@@55548 f 845@... }} .3_"1113!1276514'&#!671167!11!1&'&''71&5671#1&''1&'67171&'67@ @ @@55548 f 845  @ @R... }} . ,9"#!171632!!!611111#1'111&'&7'1&'677{  > kO Cb >HqH> jEMb  > %71#1'1'1713'11#;OOOԊ;OOO ?]y7''&5&547477167221'"'755&76563633121#"#&'&5"'&'&747716363221##''&5&767633121##&'%3#321"#"#&5'1&'474763"##1"'&'&7477167237'201"'"'&551476723'4763631##1"'&55tttt)TT[____rmm(SSSStttt#TT___`jllSSSSJ!!!13!1276514'&#&'31327654'&''1&'&547632#14'&#"1#"''&'31327654'&''1&'&547632#14'&#"1#"'&551476321#1514'&'&#"13276551311#"'xx0,         e         i  !!  0q             K  B  n111!167671&'&'!671167676''&'&'0101015101&#"01011010101'&767'&'&'&'&56@@  1 "  " 1  @!"#        #"!S111!167671&'&'!111&'2327"'&'7&'&551&'&567&767676701@@)*<9,/" #") @-*+  #  =1113151#1513151&21&#"1311#113167671&'&'!@b55~   TEN"G N@"5X!!!"13!1276514'&##3#5131'"'11&547632##3#516'&'1#151311316763  BBBC"   BBBC@1    hj ,u t}&'11&'!11!167674545&'6767&'676'&01&#"&'&#"'&'&#337#&'&'6767"7'432"'"'672#'&563''&76''&76''&76''&563'@        2--GF//3 [  `@  .    .    *+8F----F8+*7  :1101&'367&'&'327&'&'51&'67&567676767#"CBaZG K8$  %,'87B,/$ !(GDD--.,' 90 , % ;%&'11&'11&'51#1513151&21&#"1311#1167671"":9HH9:""56U55~   TEa??H9:"""":9H\CCN"G NFFd7#"5632'76'&7365&#11'4545"'&'4'&'&'&7632767&'&'4767&'&76016324767676767&'&'&'76'&'76'&76'&'76'&,BkDD..M    ,!!  !    L.-!"89F ! 3DDjU@@    F    0 #%  @@UF77 #p%1111"'676767670136767&'&'767676'&'&54767&'&767676'"01&'&'676767!!88E&# 9##++BP*) 5.!    G++!!88EE88!!E88!!   ,+B?'(,+=   + -3    >=PE88!!!!88Em!!!131'1&5476701674'&567636767&'&''&'&54767&'&'3167671&'&'@I   ".5 *)OB**##9%" # 2-+   =++'(>A++   @B[&'11&'!11!167676711671&'36767#15131&'&'5#151#1513151311311#@+)  9^,+#`@+  " ,+ s'@%&'&'67671&'&#6767#151355#11#1131131513151#12TR6666RN24 3!""!38m877888T3466RR6602 ""44""C88888888:7#3#13'&'11&'676#3#516'&'1#11311316767d]]]].]]]"# ]Z "D+)+)'(>Ch{711&'&54767%'"#"#'&'&'&747&5476726326763&'11&'#"'&#&'73176767'1167654'&'    &#$*)&&++%%)",-)'!(@$#""$0$"#S  w32-%%-2@1   2@3""++7 {"%#3#716'&##11#11#11#11'1!1aaa410 1'17131117171!171!171!171!@@@RtM pPP_),,aR5RH`t%6'&'&'51#11"51#11#"#&#12361'"#1232#1315123011315167676'&''271161111'"#555236'"#6- /11     @11=&%#>*OMNO4 :DCCD8.l  `jjj  1:A&'&'&'"#"#23012367676767674545&'&'551& %22++++22%  %22++++22% D%  %%  %֣QR3711##1&7712#'1&731277111#1"''167676331 A E,A -ܐ[ A ]!] B +1  zL  M  ;  /J&'11&'!11!16767&77101'1&73121##71111#1"''16767676331@ 1 . 0.B /B= / g`@ W6  7U !w  xj  *711'171'1717711'777'1711111'LUUUTTUTTTTUUUUTTpTTTTTTUTTU} "1%''17''1''1717#3#13!!!51#11!151##; w b'(g()))')~ UUU%T ((x%2[116767&'&'&'11&'67677&'476324'&#&#"#""7236776565454'#"#"#"'&'&'&'&54545476767676232321 !! 11 !! 1    L%'6%$$%6(%%'7%$$%6'%0 ""  "!  !"  "" 3! 11 !! 11 !    7'%%'6%$$$7'%%'7$$$%  !"  ""  ""  "",?!!!1!167671&'&'&'11&'67673&'11&'6767`  `     ` #2'#171111&'&'&'676767''131713113AAAA!!88EE88!!!!88EE88!!d""bbbcYE88!!!!88EE88!!!!88ES44"1!16716'"#!#3#'131DF D-hhhd ֓::11&'&'&551#1"'5147676763311311#117616 $; /  .G S  T!  ! D "!! s R  AR&'11&'!11!16767&'11&751#1"'5147676763311311#11761#@7  ,44 `@Z+  H4S(|.A%&7&'&&'&'6767676767&'&701'67116'11017?38  ,"#- 9 '7( !!C'*   *##771#15'51#1'51#153151b"""Բ|"@@9%&'67!&'67%776'&#"111&#"'1&#"111!1&'&'0001;@@;10?&'@'&?SSSUUS#;:KK:;# )s311327&'01&"32327110721256#&013&'1141&'&'&'6'&'&'0'&'&5456'&'&'#767676723117676767676'63112&'07676'&#&&'&7'2116'&#16&76767116743676#"'&'&'&'&711'&#&'&7116'45&7676767676761'&'76'&'&'&76767667676767767676726'&'&3"#0#6'&1'%11'&7676767672176723603116701676'"&'&'01&5&'    &+          )                         E  *% !     =      =          $                      )8GVet1111676767&'&'&'&'&&'6767'11&'&'6'11'676745767&'671167'&'&'11&'6E88!!!!88EE88!!!!88E.++7 :8322'L77 -z ??R :005R++A 4980 3%%$!!88EE88!!!!88EE88!!r8L0#" #!""02&'((-:T#%%;++% )):,%$ a%65&'&'"&'276767&'"'11&'476367&'&'"'&'&'&'67632#&'&'&#&#::W'0 ::W'/ 2#" )  +!"(+!!  ( !!"+W:: 0'W:: /'[   +,   &,})W!!!1367676760162131676725716'7#11312#1"6516731C  ?S 0:  k[I :NI ! @J<<<    FS5O!!!014!167671&'&'#1"'&'516763312711##1"'&'51676731PPS  S  Q  Q HGP  p   61111676767&'&'&'7'1&'&76727676E88!!!!88EE88!!!!88Esqqqq  !!88EE88!!!!88EE88!!♙      *T111731767676'516'&'&'&#1&3#351311676731#1&'&'1#1&'&'++KK++++KK++-333005M)*++KK++++KK++i@JC11X7Jat6'11&'&76'&7"'11&'11&'676763272167&'11&7676'117676'&'&11'&'&7676'&117676'7&76' ' 611J3-- >## C=>g..BA()/.AA)( %  *)4O!   V    !   &+DK20 3 33+,*!!+*!!+ $3++           )11&'6767&'67677&'11&'51()B899Z)A5+  ,5BB)(Z998TAB!C]^CC'(00('W!BATCC^]C\%11'11&'11&'&5476767'&'667#&'&'66765&'&'&7&7676'"'676760/; 1()6$$ ""$#;"!  < .""!! ''-2 >$# 3 6$+;%%.&& A)%"(:7!!!1##1151#1"'&555!!!51!15!!!51!1%!!!1!1514'&'dWdddd[tZZUUnUUF&'11&'!11!16767#"'&'05&'&'"'1676341676767676'&6@B-   %  B2?`@T33 7`- N?.R'9Oaw711#"'&'67673134711671&'&557"'11&547671#211#1&'&'676334711632#15#11&'&'516767211&'&'5135"'11&'676731##^   /    /   /  v  v   /    /   /  v  v   /  v  v   /    /   /  v  v   /     P[h&'&'67&'&'&'47632321&'232763012171'1&'&56323276301217167677327&''716767&'1111&'&'&'676767#&'11&'11&'676767>eee6 !R ;U8./M/!  L @@@%"AA0=!!88EE88!!!!88EE88!!  65BB56  65BB56 32@/(L& 6,[G& y -00<8.fE88!!!!88EE88!!!!88EB56  65BB56  65B)%7&'&'676711717''71&'5171DDDY8955T7""&%;D%(F2#  ((96(' + %'T!+ a"7'1#111317674'73179998`j'^ & ##B]]]h]3ZS"# &.%11&'&'&'6767671&676767#15131@AmE88!!!!88EeAC/::,++,A1lBB!!88EE88!!?A*)*FC,,V"_p76711671167#1&'&771&'&5%6711654'&'11&'676767&'&'&'114767113211'"'&5676311#'&763211&'&'&7632"":9HH9:"""":9H 1#^  9*!00GH00 +9       0H9:"""":9HH9:"" 1#./5f    &6####6&   ^  & 9  Ran{!!!1!1&'&'167672711654'&#11&'6767674'&'&'11476711211''6767''47632&'&7632@@@ 2$)*??*)%2    *('@   !//!  Q  " 1##Gf1111676767&'&'&'1&'&'513116751676711'151&'11&'&'5117116751315E88!!!!88EE88!!!!88E :" ":!!88EE88!!!!88EE88!!k  ..m { / /0!K%5&'&'5117116765513''7151&'&'1&'51#1167675147632 /0 "4 V###3 // V /0  FFF/  /FG H:$/.EF/  /  4F&511&5&'&'&'&'01&'&'&#&#!113!1276514'#151#151673113  `|  ` ` &/@IR[#3#13151#1#3#5131%5311#113151##3#51313#31#113151#173#31#15'3#31#153#31#15RRRR3)RRRRRRR3{44444444L]])]]))]]u33L9Pi11"'51632"136767&'!1&'&'16767!1671167&'&'"#11715134'11&'"#1715136765  5      `   -4  4   D CD  `  `  !" 3! 3"9KR 7&#""1117&'&'&'1101674'&'676767671#151"'&'6367715&'11�1&'&'&"13"'&'&'517165&'"#&'"#1276767327676763676551&'&'&'01&'25276767&'&'&'571'''71''27676745&555 '  f-  19 ;##8  !  5       !"    % %! N G -  ^"  -##                 %$/".===3 "H[&'11&'0101276745&'&'01#1"'&10111&''1&7671167671111&'&76767#7111#1&'11&''1'1&'&5&'51&767110*##65SR88##*  +-P*  ~; &T(11CS8866RC11(  ,2%( "j= $+%.*X471167261&#11&'&'&'&'&'&7&'&5'0167676763216'67654'&'"&6'11&'&'&'&'&'11"'1767674'&''''#"'&5&7'12767767676767672., d,&  ,,,  ,-  --d ,T,,,'   ,,  %d +-  d,& u,,, -14 -,d  , 5---'  -/4  $ @v!/8U[765&'&#113127674''3#36##15#3#51316#%#3#51314'11&'27#1#&'3165'67#0 !/2$%AIII OSSSSU6g8 =;$###=\>>54s546Ee  Sb5 ##:('&&;=$%W @55 9BUx77&#113'#3#13127&'&#3#3&'7!!!1!167671&'&'#3#5131##151312711000#1276731#&'&'6767.-(((+ ???i@@"NNNN#][v!d" "2! 4- K@; '  ' " /! 8Rex%1111&'&'132765712767&'&'11&'16767''7676'&'&1'7"'11&'67632#5671167&'&'!!88EWA@_T)'(; EDeE88!!        E88!!12O'<)((V 7b@@!!88E        Ubo711''17676'&'&%&'11&'!111671516767#1&'&''11!16767767&'&3476'&5 u8%%&OY@    0 Q%%&8%a@d!!!!  3Pi1111676767&'&'&'"'&'&"#&56767"'11&#&'&"#&'47676327"'&'&"##&'67632E88!!!!88EE88!!!!88Ee/556 >=<6  0?@?dM 9POA5A765+ !!88EE88!!!!88EE88!!  B - L  @,71311#1111#15171'1#151317171676131@bbb[ ,]]V+bc T]  T]@_$EZs%##1"'&551476747672636%45&'&#&#"327676'&'&'&#"327676''4'&#"327656'&'4'&#"327656'4'&'32767676''4'&"327656'4'&#"32765676'$("  ,  --  -,-# ;99;;99;gffg54467336`__`0$##%%##$%##&&#"&5%5#'&'&'&'3167&'&54767'"'67&#"7&& !"K&+!&18 %%6444;++ $$MNuFF-,?&'12 !!+*.2< "+2;DMT''&11177165514'''1'15#51'17'15''7117''711557117''71 ବM_,_M7777M_NNNNNN_M7777   asss3?gggg?3s%%%%Jsss3?g444444ggg?3s%%%%J@0]%&54'&'&'&'&&'&'&323232767676'&''"##"'"#"'&7676'&76327676'11&'&'&'&'&767676'&'&'6767676'&'&'&76()120).'' %#" ""\\( ",<='('(C ""&(244%$ + X  "# &   3 3)0!!$#'%!!#< (( ''? **&P   # -  p&'11&'11&7676741272767016'&'&'&'«014'&'711016767011017676501676'&'&#&32G78 7.   ,,  & ($$BCl8"#99F<44$$$232  32  %% $&'"#.-YoDD '9Ma~31&'1&'777&'47'167'171&'&'1&'151"'7'67'16351167''1#16767'171111&'&'&'676767#&'11&'11&'676767'711167&'67167'167&'71&'1&'71&#"1'11171167' ;00 (>  >( 00;x(>;00 6(>;00 ]!!88EE88!!!!88EE88!!  55BB55  55BB55 '  3 @@ 3  4 @@ 4  0  .  1::1 p .  /9- 0  . /  E88!!!!88EE88!!!!88EB55  55BB55  55Bk  /;:1, ,CC, ,CC9Bp7 "'7674'&'01711654'7!!!1!167671&'&'"'632#3#311#'1032&747&7470311&'676'1#151632'516'01&#&'7131137'751454#"#51673170301311#110117y@@^111 *EB y I  5j,  $&p  v@   -   &lKi  *B(= ,?Pmv#3#&"13676'&'&'7176767&'711'11&'67'&'11&7116755636765514'&'&'7131131'&'632"'&551416#&516767317311#1107OOO! 7mC  %? % 3      T?$$$$%$ &9= "(.   H' &   d w! $##$#j$! )a  -!11!1110101015#151'13167676731@P%  #Q@@6eeeg8   7gG11'&767&767'111176'&76767'&76767&'&'H 6  2x@++   #$3:'&&')8..//G0bPP7"5IHY%%877 /.-'':.!"   )(4G//L%"'11&'11&51101'&''&'&767&'&5#"5&7676767&767#  $$$$   '&VU''     4 Z=>==[ 4 3)8Sbq2&'&'17127&56767'"'&'6763"'11&54763&'11&'67631'16767'"'11&547633"'11&54763 76IS77LD ..Gh    00CH....H6k<&&..GQ3;"B+,5 0 <'(('<<((0!%g"1167654'"116767&'&#751&'&'!11&'&'&76745454537676'676'&11'11"#"&'&"#'&'51476!16   P!  !O 0('"'&/ =,&Z %#H*+ $  $ *+G$$  / -#3#13'#3#13'713117131717#1151#11!&&&&j''''aaataM'MMMMDW5Ynnn[[[[[III@@&:M`7'1'&'&767676771&'&17'7676'&''1&7&'&1771676'%1767514'&+dddk  ,$+   J;;; " i ! > k  h  :6111 ,)  o R n^^^' " ( [    (U71111##1&5167272"#&7&'"#"73167410767676237676'&'oK ;+=, $$3  "#%&  @  6&&   t &&./4 g#"  ?= *;&'&'6'45#3#31&'&'1131&'&'#7&'#16765&'7  0]]] >h !05''r &&9m YI AYI30(%%#%'I Ri401,XQ]^dh]]ND  FL.445of@+BKt%11#1676707677!1&'&'16767!177#11'1'1&#1113377#11374'&'472171&'"#"''116767''#1&131476731013!j     Y???+'@$+^(("      <*4% `  `  jH 2 !  #2  @!Vt&8Jat %&'67%67&'731&#67&'011120#0011"15015"101&14141430141030303012010031101410501"1#11315111131'!1&'&'16767!11127&747&'65114'&'&&#"51#113145&3231&5&363157#3#1&#271315 "'63271&32#"'1767''#"'513151#151#11#113113773#3&7'1'&'7&51#11315147674711671&7'1'&57#3#1&713153 "51#11315147677#3#1&713157531513151#113450'01"50#01"10##101033230303052141417#3#1'1#1111511317113157&'11&'36767    v k  jK     (';)#76#);'(5555   -(    $   ;    B  "(  (':*#$ %#*:'(&        Y`  `  :('0CD/'';l,@@--@@,M%%      % %%4K|}P;''*+**'(: @ $<S`s%4##1131257!!!1!167671&'&'23116111#1'1#11#'3#31#11311#11311#''71311#1''211#"'&547635&71'&'67627116'&76761&'713#3#513123#3#513!1676767%&##113127654'      ,8----E$#'  1a     f  Do`YX>?*     ` #!!RR7777TT     B   R  R"! `6 @7fm711!1676751#1'11#151#17131151311713151&'&'!1%77131'171#11'1#11151#1513151#1513151#1137'51'7713151#11'1#11'1#113171311315113'771#  > BRNbK   +++*3DD3*)3CCSQQSza''''%%%%'< =@3>+ B R%"'  ##@@00  ....HH//IG! !H***S)\ddddYYdd=.... @(B]{7"'672'#3#"13176'&!#3#"1317&'&7!1&'&'16767!14'11&##11331677162367#3#01&6733167714'77454'#1"1'1&'#1"316774'11&##11331277162367#3#01&67"33167714'74'#1113316771167&#i      @ ( -U    (@@@  ( -U   /Z0 `  `  f-    @b\\\'&  kf-    @!he4 @+Le{%&31&167&'7!!!1!167671&'&''5127&'&'&'6721&#&7#3#13271#"'&'517113&11"1#1513116761#3#51357517&'1151311672#7#3#7271#"'&'67632$u        j/  .  E  #J$ ,$$$$$$$$J#FFF 5   ` ' "  '"  82 r!U} }}) !3  1QQ7''"'&56762767&'&'&'&763671&&'&'&'&'&'&'"676501#* "#J7!! '$(*; [*F <, NA!"~1Q333*63 +,1$M0; ! @&&'&F r&'11&'!11!16767&'11&501&'&#&367671&'6737&'&'01&#&#&7676361&"3#&'&'@     NR1  % ,9%"/`@ "   UY)   % 0  )P^#3#&'&'#1316767674'3167&'11&'&'!167&'!1&56767!1!1%3#3#1&'67hCCC<=NE88!!5C<=NE88!!5`98U9..98U9..* D)*!!88ED)*!!88E`U89/U89/,@Tm%6711671167&'&'&'&'&'&'&'67676'&''671167'17'47116111&#&4#&'&'&'1111&'&'&54767#"'&'&767"'&'&'676'232367414'&'67676767&'"#'&'&'&7636'112&'&'[      5--JY32 ##  "! "    ,A-"!             b  !" '' -,"89-,98X! k  ^< -e  1*!       %% ~  /'#177!1&'&'16767!1#11317113+++V+   ` A____[p[)G`  `  **[[2SZe| &-7K%''65&''165&'"#1&#"#1&#1021112731327313674'71674'7167&'''315#3#&50171570'"''1650145712715''650501715771'1'171'#17'''7117711#1'111'17'7'1713#67311'1377631157711'15'157711#15&''151311#3&'#171311#77'131777317#3#71177'171101'333 8jj86  7 4jk4 7  s,,,,,,,-333843...,,,,,F#@b  SSSPSPOOOD|q:bSu qqq9{K3ht36<<<]EE#rQQ""RRs<0/!.'56 hLL##A@V>23$EF^#RQrsSS"&-!11<86#NMi VBB#9/I'#1&&#"167267"'&'"&###116766'&#&&"167632632 8//8!-/=*(;%!48<++<84 %*>G9119G>*+"""14;,,;41"#&8//8&#Q +*))]""-''  z$4DTd%65&'&'&'!16767&'&'#1&'5167313#1&'5167313#1&'5167313#1&'516731/0G;,-$!"#4~4#"*  YZ  W  G0/##9# $4####4+!!  oo      ' ")07>ELSZahov} ")07>ELW^7'71''71'7'71''71'''71''71''71'7'71'#3#13'#3#13'#3#137#3#137#3#137#3#13'#3#137#3#13#3#137#3#13#3#351#113671167&'&''671161#1&'&#"36''7111327674'&#'&5'#3#133#351#%#3#131717'11!1!!!51!1#3#13#3#137#3#133#351#53#351#'#3#133#351#3#351#'#3#137#3#133#351#113'#3#13d#|FX!!!!/""""/""""!!!!_""""/""""_!!!!"""" F""""F" ''''0       y V 5zz u!!!! !!!! !!!!0""""S !$""""&    - * 0   & P " "''''o     U""+!Qjjbb}VVVV+;;! ! ! !W B!" " !4G#3#"1#1514'&##11!1671&'&'11&'67673&'11&54767jjj  j (( L|h%11&'&'&'&'2767676701&'&'6767676'&'#&'6767&'&'&'67676363!!2>**$#*)<79!!!   )(*@,,*+BI10'!$$01.  !2  ='&/ w3 &%10%% )*    ('AB))))4, "!"" 2    &%= /T"11367654'&'&'6767"'&56767&'&376767673676765&'&#P<=''=4!  "      5""54I0/T5  >%&5#$ !))*+#*- --/L,,5|&'1713116767674'&'&''1171'1&'676727&'11&'&'&'&'&7676'&'&'&'&"1"#&03767676'&'&#}B[>22v19>23 3+F54NL6755Ne  ' _@22><3s22>-(( D-5N4566LN54        .5#3#1#1'1#11#11311#11311713151#1713151#17''31@@@Q^Q@00E RgYYgRD006p0 00 0p@@@@ v':116767&'&'11676711&'&'1167654'&'M3333ML3333L ''&&  v34MM4334MM43 00II0000II00,+AA+,,+AA+,!11!77#11'1'1#111315@NNN!. -#M@@[ [^\F +@M  1DU%6&'6&'4#"&4527676'&'&'"""'ʤ512767676'&'&'&'&'&'&636'&54'&'&2""&&#31&&#&&&277367674''656&'116'&'6711#&'2301&711676&'6767&'"'&717143677211&'&'676311'&'232'11#"'&'&71123#11"'&747632311'67'&'&7671125772377637767201&'&'6'11#&'&'476'&71167676'&70367&''15111677677&'673111"'&'67676&'11&11611767676'�&'&'117676'&%"11767&'&'&117674'&'=       6BB;($    !   J     Z    0    t 6  I   j$    #''2/&&!      *882R5<=7 5;9/ j   F8                  $+    !!     !       !     ! !! 6  3      $#  B- @! ! -  {$$;      C   * %H%11#"'&547632'"11327654'&#"'11&'11&'7667676'&#     $WV22' JIy&&#%*%G"#~  .   * "#)&:%$6FXo116767&'&'6711671#1&'51&'&1#1&'5#1&'516731'5##1"55147311##1"'51&5476321111676767&'&'&'"'11&'11&54767632#Z<<<{  #`  `  p%1 $&''Z @*D\116767&'&'&'11&'6767355!!!1!167671&'&'#3#&'&'676731K2112KJ2222J(  P      [[[Q7777Q[Q:;.-5p12KJ2222JK21 $$ $$ H   ` `66PX4554X5++A^q77&'&#"271'&'676237&'&#"27101'&'6762'1111276767&'&'&'&'11&'6767!!! ! .!!! !  .H88 !"88DB88"# 88GV:988ZW99;Qd%1111'&'011'&'&7676771&'&'&'&767667656'671167&'&'31132767&'&#"L .L  ,, $%77%$$%77%$Br L .L         7%%%%77$%%$7 &3t"3276'!!!1!167671&'&'&'&76761111'&'01111'&767676771&'&'&'&7676676501  @@....;   / 0    7i@@')(((()'    / 0     B!!!"1676767514'&##11"'&'&'&767636676762o 32??23  $(      '# ?2332? #&     %#z5#1'1'"#&'&'&'&'4545311676767&'&'&'&'&5131167676#6545232323111&'&5111) $$R #$%#         4"%;z  &%@SSG#$><RQSS  !865#-    !  { !!7K]n.%''1111676767&'&'&'776111'11&7'776111'11&'&7'111111&'516761'&''1&71116111''1&7111673111#1&'7'&'11&767716117111''1&711617'&77167611&'516711111'&''1&711617111''1&71161'7717111''1&71167617#3#&'11673111&&&GZE88!!!!88EE88!!!!88Eb:K@  9(^BC@  mt#&&&mR!!88EE88!!!!88EE88!!Y"*  I *  mttttC 3F76713271&'&'65&'3177#3#'167671671167&'&'!n%L`=>m)"":9Hmq0"" M$44>H::"%%%%G:FFcB$;%-3G::""--"#:%%%%%&5115111&'0''1010145&50105&5050#4'514#45&145&14101&54'0101&'114#4'0501&50'050'4'05"54'&5&141&10'41&101&5&5'14'0'4#050''1"501&'4'&'&'&'&'&'01&'"# "#"1&##1""0111111110101110167710103272301216'&'476767&&'&767&672767670145    41//% /.&   (+*)-CC^E88!!      #&)() "" ?./"9"2:BZ9:!"88E&?1111327"#&'&'&'67676731&#'11&'67654'&'676:V343&%-7,DaB65!!88EaC,7f "#++ "# 55<'./7/+&#"2222%# =((+-*(FH](!--5,* $%*3-S%1111#11#151311&'&'&'6767671''&'&'676771&'&#"6767 &1 9:ME88!!!!88EI87"&===*P@****@J+;..8=2112=<00 ,aE)(!!88EE88!!$%@mb E**?@**>"012==214#%'1'177#3#117%%11773171d%%%`TSY(.YYY}T&`:L9%#3#"1#151&##1"1#1514##1"1#151&"#516323767514#"#"'&#"5165&#"1"#&1#1514##1"1#1514##1"1#151&##1"1315167613151&#%##1"551433123##1"55143312$%%   $$$   &<  p   `$ $`@@@@p%1#"'&'51#1315167311#1&'51#1&'&'&'&'#1#"'&'67632237676762367#&'#1"!1514761Y YY e  %%  7Y5$Y ,< "!#6-B%11##1513121111&'&'&'676767'&'11&'#113151316767F FF !!88EE88!!!!88EE88!!%x2F% J %E88!!!!88EE88!!!!88E%%J%e$AJ7#3#5171#11#1'1#111#151311317131%75171'151131711111'1#'#3#5131!!! &=& !B$ $BKVVVIIV VIIV re?>>>&44&>>&44&> !!$M7&567631'171&#"76'&'&#&76&'71'1113767676'&'*0/GF,,2&8C(#"#"">&#^P@!#=(115' ! 3L&'H'$%  ?/'G# %$#"  (A7'177'171111''&'&'476766#77'11'1111171171'%+++,,,,,+*)99--,-9V22OOO}J]]JS+++V+++++Vf7777fe9987XXXI]]IY&&777'11'1111171171'7751'15]]]VllVb)222222222gggV ll Vƕgg222d22222dE%'''1&'&#&1#1'1&'&'&"1131111101670171717131676'F//F "j5  5j" (*)O((P)*( (1?H%1111"'&'"#"##&'&'&7&76767%3#351#155'&'17'3#351#11 0&=GNW`gp#!1"'&514763!12&'#11'11'1#11!167%5#15135#1513777#15#15135#1513'77#15#1513  j % o==n jIIII 666v@T@@@v6Tccuj j jjK22K%%%%J&&&&,,,,I%%%%J&&&&,,,,%%%%$I111111111#1'1'&'&'&'&'&111132'&'&'&'&'&'&'QRQF "33:0 P $$1# ;&'9888$RG+'33L5F. !/11 '&#-((.s'"#&'&54767637!1&'&'16767!1&'11&'&''16767&236'676761&'&#36767676367227     ` @ C6T   %  + ** E`  `  A''+S;  !  Ri%&''167674'&#3236'&'676765&'&#67676767676763227&'&'&'''"#&'&74767632 59'&%$B    (:('    !  ,-6 -.+C##? (,-5!   TCC %&'  >a111&'716'4'&'&'6767267&767676'1111676767654',!! &&=n 02%%<  R006#/0/0#)m  $!! ()OH+,(y<('H97/9:01 &%5:))  54IH=% %/67-     " #$00'Z}&'11&'!11!16767&7116711672&#67676'1145&'1#127674'67#"'767116767&5676743016767&'@!4&  E& "/0"     `@&-. ! %! $$ 2-"$R.%""##    %&'&#&'&'&'&'&7676767676'&'""4'&'&'&'&#""'&#726767016763217676767676767516'11#&&'&'&'&"'&54'&'&'&767676'216'&'&'&76322354'&7676767671723676763203 "   "**"   !  "     7   ))   7 Q           $      !!!"13!1276514'&#111'01"01#"'&'&'&#'&'&'4'&'&'&'&7676767676'&'&'"'&'&'&7632234767676322363232'&'11&701&767676'&#"#"17056'&'&'&'#&1"'&'"#"013267676327654767676'&'@@               $        $     @    &   &             ,=&#6767&'"'6767676767676'&&'11&567672+H/6X;;;;XX;;: ,22K/) H22K(%2//0 :;;XX;;;;XT= 2CK22 U+*2##'K22.GGi r70111010117"1'11'11'11'1711711711711327'1167'1167'1167'11654'171&'171&'171&'171&#1'1171''111715''11'1517116767&'&' - 3= @DD@ =3 - - 2= @CD@ =2 - ʼG////GG////GۄD@ >3 - - 3= @DEA =3 - - 3= @D uuuuvvennnnnn3/0GG0//0GG0/@R3#31#111#1&'&'51676773#3516765414'&'&'311#167311&'71[, &'CCC+% !-$)>2f 0>t%&8pKb11 3 ,,g*0; u 4711632&511#11#&'&'&'"'&5&'67&'7&'&'&74767672676767676767672632#63%116767&'&#"4767654#"'&5&'16753&'16753&'16753&'1675711&'&'4767676767676774'11&'2766765 0 %%     " "!   ##(  /       2)!0)112M*)4I++#    ! ,/ 1  h''      %% ,@    i)**  2        -34G4<.**&'+d*"5))%I`1111676767&'&'&'"'11&'&547676321&#2767#1513175#151#151315131131E88!!!!88EE88!!!!88EG!!0#!!!Fu 7$##$#!!88EE88!!!!88EE88!!!! !!!+ 6!!j####$##$ %67&'&'1113151!1674''17165&'!\@v>>`@@ L71'11'1'171'11'171'1111111111&'&71676#011151717111717n;;;'al(K\}* BN !.:%%%%( Ah>&1,'!e NF6 7 M"$J,%@%#3#&'6765&'&'767676''&'11&'163#&7&7!;:ON:;%%89<%(#/  nnp= "''1Z5556YC10 :?%=%j654'&#"327654'&'47135517&71167114'11&'2&'&7676767227210167676''7&#"32767674'&'a   CA]+ &#     (  AC  `"&&23''!$ ?f\>##$74&& / %$  *)8 >\f? $!''32&&"[1111676767&'&'&'1111'"'&'&'&'&767676767676'&'"'&'&#&5676767632E88!!!!88EE88!!!!88Es    e  m$2!!88EE88!!!!88EE88!!"!""   E  /#1111676767&'&'&'#3#713E88!!!!88EE88!!!!88E0U!!88EE88!!!!88EE88!!!6A^%1''1&7716'6'&776'&7&'11&76'7&1176'1111&'&'&'6767674'11&'&'&67236'6'&1"1676'&'&&'&'&767&'&676016'&#"41017674'6762765016'#014'&'7676767677-    H  0 !!88EE88!!!!88EE88!!B   $                     ,tE88!!!!88EE88!!!!88E+             #$ m%1111&#&5167676567454'4'&'&'51237670#1&'&'&'#1"16727676731#1&'&'&'2'"'13312767673WVVn  (@@DD6  W2-Y)d &<<>=)    ( '+ '@Sz7#3#5131777311#1511#1'11#15131553121##752765516'&'"#"#155311676321'"'&'1#765514'&#"13271111001!101&&'167!100111!16714'&'!Z$$$$B / .D  +#:" -8  || ||IAAA]][[ #I0rYYY5 r,&   #  $   |  l%4'11&'&'&'&'&'&'&'&'"#41"1"#"##0122333123636767676767676767676745070151&5'"'11&#"1#1513116         II 3         % ^ &Fy!!!1!167671&'&'11''&7716'&7676'&'&0'"'&76'&71111'&'&23'&'&'&7676716a(())2''&        %        % ''&  ((((%     ('%      '(%%   0111676767676'&'711'&'&7676>??>F/.W>?>?F/.WP+,==&',+=='&  11G*&'W  11G*&'W=&&*+==&&+*=9BYbk%1111&'&'&'676767#&'11&'11&'676767%'1'17'#1'11#171'17111'''1'17'1'17""::GG::""""::GG::"" 32?>3223>>32WWW%W%n///213D EEEDP7777G::""""::GG::""""::G>3223>>3223>%%%W%W^^^ddk uDE+77 #,5>GP}7'&7676'&6'&7&76'%6'&76'&776'&7&76''76'&11''#'&'&'&'&767&7676766 &'11&'&767676'&'&#"1"1'&'&'&'01&'&'&776767676767676767636576'&c     V   z        u   '  P      !!"!)10-5((F                "   H         :    8   J    "$$# %##37 K     %%       \  3V"1113!1276514'&#!671167!11!1&'&'3111#11#1515151&567@ @ @@    @ @: EE   ATm%7'&5711'16'&'&'"'16771'11'&'&77161712'671167&'&'&'11&'11&7'17'1#  ))(-''"/L+3D"!"!  :j A)( ))9:4'z&?+'!'&( V. = B $$"'(7C))'(1b%55'103670167676701010145&5477167676731176767676'&'&'&'&'&'&'&#"#"##0#&&'11&'"'&''1&'&'""2176767676'B3 !!+2&' ] (( !",/%$  9"##$,-<;-.  B ! +1&&  "x  $%00%$  ++9;//  J  Tu!!!"13!1276514'&#&11'0#&'&767676'&'&'&'&'&'&7676767676'11'11&#!1"'&54762323236"'&'&'&7676765101&76232361#11&'&7676"#11"'11&'6767676#;;    >? ../ % u  *,+ (4  z    )   0   T#  D31 G#23 #+711'&767676%11'&'36767674'()* '()* '_:KJ:% +*6&56>L=>$$70/76//79^)(21#"-%$>>M Y1111276''1&'&'&'6767311'1&'&'&'&767176'&'&'&2717651&'#G99#""!::HB9 '-X:::;Wv6$+'&%8?,+)(=2& !"99FH::##<;YV::h'$,&8%%((?=** FW"11767672167671232323236'16'&'&'&745&7676767/01(  *),) -22)( 6%+*  /.d2 /& !!"  "&  ##  )=%%    1N$-4;%7117111171117111'171171777711''1171'&767672717167171111711117117171171171711111'111'7&7677177612767777''17'''1117171171711717114167676371716'1711717111171'111'11171'11'11%67676'&7676717171711&'&#77'1###"@ /  ]    ' A$$%%7 K :(~,   8 ( 9 & ' +"% (&9m  "?  qsvPSxx$$$&  uoV\F  G<<<!-&&&(Kzfh?B)    +.O,-+#'%'  *(?BR#     &' ,Hex776131#1&'673171'1&767'&771673#3#11'&'&'&7671111676767&'&'&'11&'&'6767 W?4B O 555   $ZE88!!!!88EE88!!!!88E==\[>===\[>=G  s$ """ >" ." ? !!88EE88!!!!88EE88!![>===\[>===\#Ea!!!1!167671&'&''&77167#3#&'673171'1&7617161313#3#1'&'&'&76731`  `   3A  V>b    4   `  "6r#   " &%!7 W&/Pc721111516#&#147661#171#1'7&'6&773#313167632''#11#154'11&&3276573#311167632''#11#154'11&&327657476321#1017'311''&77456&1373#313162#145016"1#15*&&.'++N&&&  'Q  :&&&  'Q  5 ! L& $' L&7'''# '   L'%0  _     F==     F=$   ) .   Dw@@N%654'&'&67676'11&'&76767131717131'167131'167''1'711:+,Rcml[O\8984sH2+ /!d=*D"e"#!-fI!#"fO=72$$ 3*ABP))." =+(63"%5 GnQ)))5|  -F%51%1511%77&'&#"316766371&'&#'6711611171&'&'67@@///--67,-GQR9 5!.="yCMNHH31)ABOOAA*6666H+*8 G. /4  E>%$$$?J!!!1!1676716'&'7'111'1'171167'1'17171116760118989: s)4:E g  _4n @ =0dq  w9N7111#01'&'#'&5&766516'&0#&'0#&567676766711676'45&#&7"''1&5&70103231714763316171476331604#1"'&501'1101'#"'11&'&'5163676743676'&'&'&'"'&'476721#&'&'&01'"111#'&'&766767&1111"1&76761676'  & % ' V    2 $!!%  !!    !    )6EECXRQB~s   !$$      "   E     $$S       i'<S0!  ##  ?Y!!!"13!1276514'&#11#1"'&'#11#15131131676312'5##1'&551476312  @C @@C@. .   & #K %#  o%1111&'&'&'676767'6'11&'71'11&'71'11&'11'1123130#"'1'"'&'11117111717676'&'67'11&'11G37'11&'11&'713!!88EE88!!!!88EE88!!   %     #   # > E88!!!!88EE88!!!!88E# -+,-  3H -,-- #W< X6 +>Lq6711611'&#"'&77116'&'&76'&767116'&7'55&'1671111#"'&747&#1776751&'"N1==>=2 BTTA cU)) ,+A].. ((P>  G @? $#--#$},/ >: ] JIV@==..!QQ`SFG OHHH H   A<G44G s 0@P`p11#171317#3#131676'6'&'#3#13167654'&'3#3#13167654'&'7#3#131676'6'&'#3#131676'4'&'#3#13167654'&')GD ~DDDF' DDDF) DDDG' DDDF' DDDF) DDDF* KY (Y Y Y 6Y Y 6Y 3l763116323"#"'&'&7&1122371716'01&'&##"#"#"'"'&'&'&'&5&545454747672723233'&'&'"'"'&74'&'&#"'"336367676565&5>'  0   ', $$PM$$   (22AA22 U     *   _ ,   $$QP$$ '  $$RV)(- $.4Mi%&'&#&'&'&7&'&'&'"'"2327676765654'%67116323##"'&'&771'&'&'&76763016 (%  2C " 0011 /#  #    + M2  ?@  2) I;I &$% #"!!@   #,5>GPYbkt}53151##3#5131753151##3#5131753151##3#513153151##3#5131753151##3#5131753151##3#513153151##3#5131753151##3#5131753151#xpppp(xpppp(xppppHxpppp(xpppp(xppppHxpppp(xpppp(xppxxppxxpp(xppxxppxxpp(xppxxppx-@%11'&'&7676&'11&'11&767676'76'11&'11&'767IVJ78 %%8SPP56##<>HA22%>>[J;;!! #17$%'%   LT  >3223>>3223>D----DD----D& %&7 +  Xp  23>>3223>>32--DD----DD--+%51#1'1517131271167654'&'&&389%  %%  %9998 $$  $$ o5r711732767676'&'&'&'&"11#1"'51#1"1311'&'&7&'&'&'&7676&'&'676676'1'&''#3#&'5167311'&'5167311#75567311#1&'5#1&'516731'(<(56'4#" 8!"%%+ / 16$% )* %%$   ((((v    p    4!&+0,,, + ( "      $$ !!" "& (h(((    ]     &Bt7&'11&##1131677131##1131676'3#32771#1"31714##1&5477#3#131111#1&543316771#13167716'&'%#3#"12767716'111#113127713113127716'&'&771633121##113127716'&##1131677% #     (%  NNN: # 09 L$ 0   b! 5 / C    `   )# 4 " c#b@ (!J   (   71711!71113111'1'131117171'11111'17171#1'13####9so bc156p{tt44P///2J&=.//*%11#&'&'6767267&'&#2767&'X,,C"//7E88!!!!88E7//"C,,O'&!!88EE88!!&'N*<a&76767676&'&'&''&76'&'&"201"01&'&7&'&"7676727#10#0#767476725010'012410767672323#00#05716760767676510#0'&'11&'11&'010#"'&7676767&4747656'670101&7767676'7&'"'67676'&'&'"'#&'&'&'&'&#"#"'&'45&'&#"#&'01232&7677676767'6017676'&'%&'6&7&5&5&'&5&76741671&'&'&5&76767056'&'&#"#676'&2767633763'67'1676'&'&67&'&'"'67&247676'&'&01"#67676'7&'S " 9       ( , %    $% %))          !   z               #  ] )  :#    $ {  . + )" !$1 $  &/         %!                        +DWq3#31#151'&'47676511327654'&''3#31#151'&'47676511327654'&'%2111#!1"'&514763!5!!!1!167671&'&'~4444) @   3333* A   D  84 h  4 h    )eo7727676'4'&'&'31#"#7271167#113'5#11#1&'&'&7&#1'&'&7514763310363274'31'6'&  O& w+J!   [R T6 @@@  @&&&  % ੩7     + ! 8 8C3#351#'5315%&'11&'&31676761111167676'55#11311WJJJJ>>)*8VJJ..`//7 ''4S>?__"J=====8)*?>S4'' 6//`..JJV____sH[n&1&'"&&'&#02767054#&'&543676332720"3367456'&'11&547673&'11&'6767 :>CC>:8CP IKLH ODfz   UTSR1 !! 1"711110131676767&'&'&'"'171&56767>33>2222>Q$%66%$$%622="",,!!33=>23 K"6%$$%66%$##3#515##1131251&##11312551#^r__` dQT~ #,T]fox%#3#51315#3#1315#3#1315'#3#13153#3#1315&'11&&''11!1327677676747'%#3#13153#3#13153#3#1315'#3#1315^BBBBBBBBNBBBBBBBBNBBBB $ #M 8nwTT) BBBBNBBBBNBBBBNBBBB;;==;;H<<<CLi%''1#167676'&'&'&'&67654'&'67676!17'&'67671167676'&'2[ $$4,   8*+P"////3,+* "   2RRRA())0)) " ?.-@m012! !!## ,?JYs11767&'&'7116767&'&&'11&'7'11'6767&'67&'&'611&'7!!!1!167671&'&'"'11&'&54767632#$#2$ !U) $%!15)("&H0 ! "#%v@@+%%%%++%%%%+;     &6& !;&w1$ @%&**&%%&**&%"5315131#1131676765&'&'#@kV//-,\Q67=Erwww7/0><01@ !239[?E#,5!671162&'"561171165&'&"67&'#67&''11&'01323721&5676676632'"11''1#"''&571"#&5473&''&7676767&5&'7676363676367&7676676222'%4'11&&767676'&'11&'&327677&'11э"1&76767676'9      >h00    D0    ,_   5  =#  " 4       j h        _    $    *      :T     3#3#131&'671131&'&'711111!16767131WWWWdL@#$1!!J3&%` QkQtL %% @bU67*0.#2$7531513171#1514763251&'&#&1#113PtWi' BBb"&Y+a$F1176767676767&'&'7''1&1'&77167617716lEF%  NIH//EEkIII  : OI  : OBCj6-.!  ;;XjCBttt  ,< t  ,; -:K#3#1#11#15131513151315#11#1131513151##3#13151315315131513151!@@@ZZZZ@&Z@;Xw73#31#11311#151712'51&#15131516614'&#"13#3#51712551&''1713111'1'11'171'1713171311311r]]]M; &i%E   ! n *+ & &3"# 3c-  "  ("[---  -% &&!#7#3#1316751&'3#3#1316551&'7&'&'&'&'"'&'&#"00111011111100120101000321111312010201010110000111011010101212322123032320321232303212230303232323012323232321212321230363230323212363032303216321230367670121474707014707412547250503474341056701016565070147416141654371470525710741470565674701054165654345054345414705414741456501417105056501054145654501450505505250545454545&'51&'&1&'&'&'5147311315147311315147311315162351&'63216323276321#"'&#"12361315167311315167311315163312v*44),))12))- ((    4444}   ?Q'  )Q? L L GZ 1%F671167116'&'&'&7'&'11&67'&'&'&7667&'67674'0   0)   -6\====\[==`    1j  =<\\<==<\:0 H&516716767&'&'&5167&'67676751&'&'&'"#11&'&'67676'&511&'&'476'&51716767674'&'67&'676 @Ac Q43""9  3'&>  >&'3  9""34Q cA@ $%>?M M?>%$J  ,1hHH|h@@XE88  32?G77\  %  &&  &&  %  \76G@23  88FW@@h{HHg2,  06N@?''''?@N60/)9%#3#1#&'&'6767271&'2767&'&''#3#13151&'&#D &48&%%&86(>A[>2221?0+,$ ( jjjv4%##&&99&&'?A23>>32*qY)10w11"'&'&767627!1&'&'16767!1511451145#11"'01&'&'76747010301'&'401#176765,  #Pv' 3- !!%$$% -#gPP/0Z($;+  "  'cCZ73#3230127676'654''1'&'&7676735131501'&'&'&11727676'&'&#+ 3)(3 $FN-. ('<. ,8787 )""*# 6-3 1!"A,-Y$"6 =HH<+, .n !E.)) **,6 !%311#7!171!11'SQQQ6Q0QS%%''1%11''1171654'%%'1E<;;;AA<<ݡ< F """@A#  < @6o747116711671167&'&'6'4'&'&'&'&'&57&'11&'11&'1327676701270367674'q/        $  $%-$# '!    ""' ~,7fsJ_n9LSho1111121677476567'&'&117'&'&7111101&'&767767650765&'1167&'&501711'&'67#3#"327676'&5&5476767276767&'&'0101&#&'&547676'&'ǂ#&747676371'14'&'"&'&76701&&'&7&'&545#1&'&'&#011201""&'"11676767676'&#63"#"&'&'6767&'6763%&'672&'&##&'&54'&'2&'110'&'&'67716727676'&'&'&'&76763011'101&'&'6763201171016767672453&'1110101"#&'&'&'&##1"6767"'676'&'&7114731"'&'&'11&'&76731767677#6'&5&'2767'111676501#"'#3#"367676'&'=       >                        %++&  +       ,       **      u    %.  o,v,Q L%       >      -      - f                       $+  +$        (                          + 2  E   @S771#"'&''1'1327''67676#&'01&36767716701"'&56767"'1676771#'"5676767&'&547676760#'41"5'"7'&70567621276767676727670147676326767610161474767632676760##36707676571'&'711#11"'11&'67672717161114'1#"'413167"21!       &%        0000#"--#" !1 =9 F  9PO }}}        O^          .   1@<)!B&'11&'!11!167670101011#3#51'1310167016767311@UP%  #Q`@g8   7e!!!1!167671&'&'"#11 "'11"#"#&547676507676'&5&'#11"'&#"##""#&7472767676551&'&'&76723322327630#31676'654545&'&'"1&76722232363272313st%   p        n    rk     =f    e> :1111101#16767676767367116531#1676767j )b !*b<*b *b A)(4A()54A()5A)(K^%1&#"327674'7136767&'&'5167&'&'1&'&'&'65&'&'67&'11&'6767 '2  2!.7%%0  ' Z%9-!2  2%$82##>    = s]w116767&'&''&76723670125454#'&'&7676327674'4747636767612#3#131676751&'&'&'11&'6767I0110IH1001HO    ( *,,,,yR7667RQ7667Qp01IH1001HI10   8(%  % B#/  ,,,,d67QR7667RQ76^%'&'&5&767676367016765&56#1'&'&76767276767654'454767636767612~ +  ,+++ !   N/B<)  "!N R/2  )((" {DG`{*9OXbG`m|%&'11&'&'&'&'4767676'4'&'&'&'&!16767656"'"#"676767&'&45&767&'676'""'&76767674'&5676'67676&6'&'&'&'&&'&'&'&'671123&4'&567676&'6'47''61257674'11&76''&'11&732&'672#11101417271167#711#&'&5&'&'05&76#3#4'#1&'67677623476#7"1#167&'&'654'&676767116&&747631127&'&503'&'11&7'&7711767676'&'&'&'&'&56'&'&7'&'11&'"&'&7&611&76767117'&''&'&'&'&'&3723 !01(   i" %    %$             h  .8      5   $S      `      , \     4:;*       ]         +))      }  ! :&     %    I  @     F               / 3Z&#"767676'&'11"'&'&'&'&767676323'&'11&767676'&&767601"'&'&'7&11'&301676767676'&##71716'&'z>D?88$$;;AA:9%$;4016 M( * $@%%*2SSN9 --11    .%9;AA:9%$;;AA:9%2    V "  MHL.$99?7  I!11!11#&'&'7175131&'71674'&''1&'&'676761&1#@"*c:"   (!  @@! @(  #  0\&'11&'!11!16767&'11&'71751311#777674'&''1&'&'676761&1#&'@"*V"""   (!  :`@ !+  #  (!A`7777'&'"'&5676%6#"'&7&'&'01674'7%11&767'1'&56762%11"'1&'&'1671&547672'&'&76767131'167&'&'@<<<.Q.( 1;B4   c-    @ . '-  i   ?2M.(1;B4)<## --<<##('8; J ';;;A  *   08E4    6F,&h 0,;,&18E4  -  ?9h0((0((]BB!!88EE88!!BB]d*/C .1MME>@A+ +$)*',87/1(p((0((0#3#31#1533#31#153#31#1533#31#15,76751676176751676176751!@]   t   *:H1111676767&'&'&'1476327&#"5147632&'5147632E88!!!!88EE88!!!!88EP0  x  x 0  !!88EE88!!!!88EE88!!    :  1%3#3&'&'3151171%5517113165&'&'&'3`lll!78DD87!lhhK !!88EE88!! K@7  7ii0П&*E88!!!!88E*&)K`y%&'37671#"'&'51632'63112&#"&''53276751654'51&'&&'23116367676545"'&'111122301&'&"#&'&01327014'*d,'01@@11',33+3@@2 -11- Y,, ;;JJ;: ,,*8887+33'%J  R))))R :.-FFF01\--.-Z01E..  )7 ) {  T"''1&76767676177165514''1&1117675147311"'&''1&55147716111#74'11&'&'&7&76723312765&'"'&'&##1"67 >  /2 5 0 +)   WR&, 9$ ;Z<%kjj  8  k k  k  A:   >@@ *7P%#3#5131%5!11#151#151!#3#131513113153#3#131513153#3#131513113151311315  @`@ @@@ @@ `` ```` >B9k73#351#35551&'&11311167#1&'&'#111331276551#767#1#"'&'51#151676131514'&'&#"13%217151&'011&''111675151&'&'&'&'51633#351#&'6771'1&'1111675'6321#"'#"'51632''#11311113151#h5 O&%!#01"" !  !!   (%   )&  `  #" $%I/;;;?   %%0#""#0%% %$ -     qD    4  :  ZZZ)^2K^q /B6111147676'476767&4'&'&'2'&'&'#"'&'&74767674'11&#"3276554'11&#"3276554'11&#"67654'11&#"3276554'11&#"3276554'11&#"67654'11&#"3276554'11&#"3276554'11&#"67654'11&#"3276554'11&#"3276554'11&#"67657&511&'&'67X  *#!%8! ,,00,, ! @``@       H      H      H       =SS= B^^B8   * ,>J: :J%!"/0"!%h   B   B     B   B     B   B     B   B   (  %,7B[j{&'11&'11&'676767213155513567#7715131516'7#11'3#351#11#151#11#151#1#3#516'1315571151'151715'#3#1315131&'&7'1676'E88!!!!88EΕ`F)o9  sD)*EEE EEEEEE$$$   8!!88EE88!!p ]]]? 6  480M<=Np0!!0 g E  9G%&'11&6767031167"'&567674766'11'&'&54765'11311!176771317676'&'#1&'&'#1514'&'#1&1#1"#1&  , 8&'  ! A V  " <<)H  ##  5("!<( 2211 U #"&'11&'&67676767676767 .9BA7?5)  7 !&2%$ ;;D'>>21%  ('97T&'676767676767&'&'11&'11&'676711&'&'&7116767&'6rf ) 01I!!!1!167671&'&'5#516731#1"#3#"1#516731a)))) 8 888  ))))888  H 8 1111676767&'&'&'#"#"#"#"#"'&'&'&767676767632370176763232327676767632323676#"#"#"76767632323232E88!!!!88EE88!!!!88E  DE          ; !!88EE88!!!!88EE88!!34   #" .. 1     3Wbs#3#&'&'516767311'&#"#1'1#113151676327#"'&'3165654'&'&'&#"32767''#167632327654'&#"327654'&#"@6$%%$66$%%$6  $  t S " 3 P     %$66$%%$66$% Z"h  %"G   d  BH%67116''1&'&117117167611111%116767674'&'&'''" & ZAB4 $ ] 08GE88!!!!88E&&&% ' 6b944T@ .%)! " %P"!!88EE88!!I;>%8m%"11327654'&##"11327654'"11327674'&'&'&#"&'&7673276767654'"'165676'&'6767   n     )(327$$2))33))2$$732()-,3ABccBAABc       8$ 4BB4 $)..)  8,(8@****@@+*A1111676767&'&'&'#3#'1&76731'11#1716321#"##"1E88!!!!88EE88!!!!88EZZZp KTUZ  e!!88EE88!!!!88EE88!!\cc ww#,5>GPYbkt}''711'7711'7711'''711'7711'''7117711'771177'17177'1717'1717'1'17'''1717711'7711'77711'_777JNa..."7A %  " <& )))#.'UFFF7(T***3)===5P"3CCCBY,"...',)$#$X####TJ " !- & %; / 1@ )*r@ D9996_ l--_W OVB? $_h75117117'711&'&'6767'&'&'&'&'&'&'&''1717167654'&'511'&'67DDD66DT%;&%'&;8  &,$,@**   >t`5 #(6 ,+>>,+ A  1 &*4,,B3'  #71111!167676'731&'&'&'X+AA98x3%&/ 0+11'(`FEPP623A&%3418N"#22@mST22)''67&'&'6717%&'11&'6767//FG////G<-7$$$$76$$$$6+8H/00/HH/0%v$%77%%%%77%$Z7&711676'&'777&'&'&'01'&'17767676'&'&'&'&56766@;CEVV?;C *@?@A0''' )  (  8FUV?<BEVV?2))) '  *(   -_%''1&11711611''1&1107716'7''&'&11177111716''1&11''1&771617716':DT^- +29_\-,ARJ"}*'7\H$5Tg11&'&5476323111&'&''15116716767&'11&#"#"1'&'&'67677&'11&#"67674 1m!:aG 01   &!  !0 O!k'f0  1  !!  @%"3'&'11&'11&'&'&'&567676'"#&'&76'"'&'&'&'&03207676567276'4'&'&'&'&'&5&'&7676767676767633632765672327&'&'&'&'&7676767676747676767676767676301667676545&'&'2 6          N          )                   j'1111111167676722371111171711717171171'171'11'11'11'11'1'11'1171'17171111111'8P  C]8Y8}Rsf|1.+l &  ,ND% '$J .3E6 {l&Jc&Tz8a %   E`)Wl $%11"'236767&'%6711672&#&'1167&'&'&'672131514'&##&'&50175#"'51#116751#3#3513167&'#113175531#3#3513167&'#113175531#3312551#11##1"5514##1131233312551#11##1"5513151#15131131514##11317531513151#1137531511317113151#11'1#DEg&" gEE2.EEg "%gED-2<      y "'  9'  9 & ?'4;1! $$6-!#6$$!!2!-(     J777777VH++H+" >=    @LB!!!"13!1276514'&#'11&'311316751&'#11#16767| | :**^DD^&%66%&""9  | ""9D6""""69**!1'1511117151'171'''117XeWeUUUYVX@-uKK:5:O1117/5(/6=DKRYcjqx67#1'55#113145#3#31&''#3#31&''#3#135#3#135#3#13#3#13#3#135#3#13#3#133#367#173#351#3#351#53#351#553153#367!13#351#3#351#!!!67!173#36767#1731014551#53#351#Ee  s  %  R xFo11111111'&'&'&771677167676767456703655143610"'11"27676'&'45&'"'"'076'&303''&'&'&'&'&'&'&1767676'   1      > !!  1    ; 5P%11#"'&'&'6767632!11327676'6'&'&#""'&5516'2713221##1&'&###654'&54771'17117113311654''1&547416167133351&'71131'1&'71131'1&'71133276765514'271#'&511123'7&'&547#&'&547&'&547 99?@89  99?@98 734::4334::43  Q        WB77! "77AA77" "77A<2332<<2332**   $$5  0,('H&%  *&,/#"39&%    !    8e"..((4   8`=>.   !%&T/  65QQ!+ !%=! %$Bb 9        @!!!"13!1276514'&##"'&'&'&#"'167676767676'&6f f @B.  %  C2  f /RV45 8a. N@`3g7&'11&7'1&'&7311067610171676731011#!&'11&71101'1&'&73110676#716767311#'1111011#1&'&''10'&'1011#1&767017147673i 8! $ $ !8 # 8! $ % !7 # 8! % % 8 $` p KK p  p KK p  p KK p m711711116767&'&#'11&'&'&'&10141&'&'67670563230101601767676212217&'11&'!11!16767771&56767"'\ 2$8&&''68%%    @TTT--CA/.-.C)#& 0 %%87&'%&8K      @R%+C-,..BC-,`s55'1'171'11'171'11'1'1#111'1111'1111111111711117111317171171'171171'1717"'11&'67632#'11111'1111'111#1'1'11'171'11'171'1'1517171'171171'17117171311'1'1111111111127673371713111717171'1'        wH///7'6'' * $%7&66'5%$ *  $-&           -( #&4(66'2#&)'$4'4. '-$ %0t1111676767&'&'&'471&'&'"'711#6765&'"#"'11'1676'4'"#"#6767&1"#1'776'4'E88!!!!88EE88!!!!88Ek9""!CD#'    "0R  10;Y> PQDDD3!!88EE88!!!!88EE88!!1*55C » G_.9 ))J/! 0;>32"Gj%11'&'&'&547676763'&'11&'11&'&'&7676767&'11&'"767676767654'%211113276762&'&7r!;3*    27 "$$ , 1>=>!)   !  %%. !!! & 33>?<#")881!     '77#171&'&56763311#151##3#&7315WWW@`"+*?R7..#%""9P)( ?=.55131113111#o7R^4y3@*<C=P[~#4767"11&'&'3676736767676501&'&'676703&'531513167654'&'#3#3#156731131514'&#"316721137&'67711#7116771#11#1'1#111'"'123u            d*I###))#&5 " f 5#$3!      %B&%Ma  &  J ss @ /8k%#15131675117!1&'&'16767!127650111&'11&'476721&'&#"&'&'6763236765017&'11&##113151312767&'"3167211671113157#3#1#1'1#111'"#12377.0     @  <       3 Z& %  f$ %7?  `  `  v  K 6 /  DQQc"hfCQd71100&'&7676741672&'&#33125276767676'&'&'11&'&7676771167676'&' !  &)$)#"!! #$! B     i$""5)++&'%%()#(44-,/.!(55.$%%/.,Ly Ph"''1&3676177125514''1&111551433121#''1&'5167716111#74'&'&5&763312165&#3#"54##1"3277&'67#&'67#3#&54##11#151316#01201'4#11312'%4''1&##1"11771655147716321117655%51''1&55147716175161&1'1"#1"131771055365514''1&1117716''1&551477161177"131217125514#'10#554''1&1117716745'11131#''13<::9 :::/ 7    >=$%P===%-===%>$M    ==>=KM !B!!B  BB B!!B!B  2      $$_,  ,_h$$G$ ^   $$G##  ,GGG##G##|4g76711676'&'&7676'&'&'&'&'&'&'457117676'&7676767676'&'&'&<NxN())))Tj 2   QQ/9 / 84L8g%4711656#113161'1#1131'4'&5&76751&'&7&'11&'43271&'""'136765&'&''51#1&173151#1745654'51654'45&31167'1'017&'11&'43271&'""'136765&'&''11327'1#'3105674'&'63#e**j$     K*)  $      "!_!9 0 "" 0        ;0  0 "" ";      E'' $ !B?Xq%77"&'&'4'&767616'&'"&'&5&767654'&'110501111&7676765016'&"654'0#&14#&'&'&54767676'&'&01727676'&'&#767674'05016767677676761"67671076111676767101017676765&'45676765012767674'6767676'&'11'&76767676761630771111#&'&767676'47012767670017&767.      :K44 $#3 *0 89E)'($              ')  ,S  o V  EW           #*)++ "      $         .!\  5  #3#1'1#111#3#3171311eMMM80[555sr6YY !73#3'1771171#3#'1#11#1LLL&&& N111n0[[JJJbbBB$ X("+<aHU7''#11#1711#'731'''3117131755311#75#151#151311##"'&'&'&5476767276323#4'&'&'&#"3276767675571165657114101&''131131'113171311""01'11'11167&'51113274'5111#1131513113151#151111#1131513113151#1512767711#1131513113151#15171127&'5171167&''771#1'11#k4>>-'q>>>-->Q)d)          _YAA >? @@Y   P   &&   P   ****c++++g``ttttt 3       a  ))               X++++((~t8I`u% "1101#&54701454'&##1456'&#'&5276765&'&001676'4'&676'&'&101"&56567656'&011'167674'"01'1676'&#&1"""'&10127676'&&"#'&1376771767676013137676767013176767677676101765"767713176701076567116"101%471167116676701#11&'05476201270511476012#01                   +       T        %%!       #    #      :  |     p#7#3#1317#3#1313#3#1313#3#1315B2222e3333e3333d2222}CLL M)%,Yj7'&'517'%671165&#"3#351#3#351&'11&&3012767676'45456'&'11#"'&55166'&'11&&&'01511&&13151&'&'5115147671514'&'5132767676'45456'&'%5&'&7611#"'&55166&&&98'-  ::::J::::    'k9-) *: "       "*`  s  xnn1     H)    *  'J 1 ^ 6    1???()  x 31711317'1#117Y>>Y,,,-Dqo$ttXXXX <D.5Zw716751#"'513151#''#11315163651&77174251&#"#&'17767&'&'&'4'11&'36751#'&'3165'6711632''1#1171712767&'&#&''16323#351#+++   ""Y&,  \,,,,S !  VX  ',   ,,,,/  "?& g ) H % D  *   (    "#"( !  A 3 *'{B  ! u26251&#&'&'132767&'&'&'&'&'/!&%"GGX44 !$*)%KQZ76"!!%! **L/   &'M4 "94711676767'01&'&'&'7&11676765&'&622 )(& ! {  ()7r (8877%%'&=32>>%.#..##*)+ q0l%j76767676"##1"#&'&'&'&'4'7"5414'&##1&102367454151767656'&'&#&#"#01&762'&'&5454545457"111""#76367600#01&'&767433232745514'&'&'"#&#"#'&'&76762&'&'&32367276767676765655'&'&'&'&#"#"#&#"#&376767656#"#"#"101&5 =B /0TO /5%&)'QA  "  /       #       $#"{ !  :  I* *  j     {65HI  YZd@5O%\745114551436'&'&576725454545454#&#&'&%!1&'&'16767!1#&#"#&37676767674#"#"#"014501&'&'&'&#"#"767433232545514'&'&'"#&##10#0#76367621010#&'&'532327450151203767656'&'"'"##10#"41014'45&##1&&'&'&'&'&'&1323212131030367676701676'7&'&'&323716201367436767670145}  (                   BG((83 6D # ,' 2  $     `  `  &'?> T f  Y  c<  0    8%7'11''1718]]]]z\\\\(7!!!1!167671&'&'3#3171311#15''1#151311#GG```>oQBBB`XvGWttrrrr%.7@71111676767&'&'&'75#151333#31#155#15133#31#15""9:GH9:"""":9HG:9""++*G:9""""9:GG99""""99Gj++U++++U++ U%''177!!!1!167671&'&'11"#"#&'&'&'&'&50147676767672323____f@@!""!!""!666l6@!11!#3#1#11#11!1@fYYYZY @@ZY Yw=t4##1"133125'&#"514#1"13312551"1&7670113125514'&''1&76767514#&#"011#&'&13270327676'%&1111131255136767&'&'"'&56767'"11327654'&#))_$))"" : '  5!%)!//   " Q  {#n  -  "  )Y/.  h9La21111&'&'&'6767635"11113276767&'&'&#11'11"#712363#371232767676'&##173#31232#167676'&"#1#1711'11"#712363#371232767676'&##1@WDD(''(DDWWDD(''(DDWYHI*++*IHYYHI*++*IHYf y%%%  G!%%%  %%! y%%%  G!W"#((#""#((#"&&//&&&&//&&Gl,,& `jGl, 13J#3#&'&'&547676765&'&'&'27&'&'117"11767654'&#:+$%%$+I-- !77DE77!  !77E##N )%&)*&%33H-4E77!  !77ED77!   )@/?O_o#3#"&'&##1"133127676331276751&'&###1"551433125#1&551433125#1&55143312##1"55147315##1"551433125#1&55143312% %  ZK  KZ  $$  &&  ==z==$Afy%6711651101#"'&7676301&767'&'11&'11&7676'70111"11111127676'&'&'&767676'&67611'&'&7676&7676''11117&''&767#11"'01767672'11'&7677&'$"! "%%>=3V -2  %s   4>    ./;;9:    #gRQ''%005 =?@-*066'' 3+,)76?   &)*! $   >   )  a     \1111&6'01676762121'&&'&74376767626766767676767013  G559 ,144X5 =56051717335 !&#   $ `   h,+  %$*/"?R%5#11#151#1514763312'432#"571111&'&'&'676767116767&'&';Mff#""##G88 #"88BD88"! 88HZ889:VQ<;99Wfffxxf?##""{!!78FJ87! 88FC88""-;;RU:976]W99It1111&'&'&'67676767676701'11#151"'71374'"'&'&'&'7&1116763513111&1654'&#F88! #"88BD88"! 88H :9V=''])"" -,`/0-_" " ;;U !78GJ87!!88EC88""$U:9) &&" +=+ ''!  9V:<SZ1111676767&'&'&'&'11&'471#1131#1131367'1#"'&'3111'#3#31173#351#1'167671&''16767621'I87 !!88EB88#" !78GV9: A ##,*  ['&;MG '<$Q $# W99""88CE88!!78JF88! =9:U# 2. 8  / ) %.99W<KTu1111676767&'&'&'&'11&'471#113111#1131131513151117#3#5171755#171#11'1'1#11'16767'I87 !!88EB88#" 88GV9: :@@=AQ&&9X:::7&?B+(BR+*DW99e""88CE88!!78JF88! =9:U 8' '88$$3t` V3$#99W -/8A1111&'&'&'676767116767&'&'5#15135#1513G88 #"88BD88"! 88HZ889:VQ<;99W^!!78FJ87! 88FC88""-;;RU:976]W99++++P****Kk1111676767&'&'&'&'11&'11&7132767'1&'&517''67671&'&#'16767"101E88!!!!88EE88!!!!88EG23O$  K,4..:(GK,,5V98!!88EE88!!!!88EE88!!>''==B#1 ,! /ddd*1!*89V/?Oam1111676767&'&'&'&'11&'6767#3#131767&'&#3#5131036'#3#1315131676'4##3#5131H88 !"88DB88"# 88GV:988ZW99;4 221!!78FJ87! 88FC88""-;;RU:976]W99)2((9./(,11/1111&'&'&'676767116767&'&'61117167147147217163311#11#&''11'41'&'1'05'&'1"''15'0145'11'&''1"#151317161716701617147632171014767G88 #"88BD88"! 88HZ889:VQ<;99W   :3       4- !!78FJ87! 88FC88""-;;RU:976]W995l<   :@ a , ]  7H  ?_  W  Y9 Lb  E\Pb/1111&'&'&'676767116767&'&'1'1&#"1'1&"1'1&#"1'1&#"1'1&#"1'1&'&1#11312713277113277113277113277113277117713151##3#1&551#1&'633151471312G88 #"88BD88"! 88HZ889:VQ<;99Wk      +3      3;N!!78FJ87! 88FC88""-;;RU:976]W99 ] 3E  -^ TC P9 Z I +N FI QH :@ S,/KZc1111&'&'&'676767116767&'&'1#1&'51#1&'516731133#351673151#17#3#1315G88 #"88BD88"! 88HZ889:VQ<;99We  6  6))) 7lllll!!78FJ87! 88FC88""-;;RU:976]W99  6  6se (X/BO[1111&'&'&'676767116767&'&'11676'6'&'21&5&767"'&77G88 #"88BD88"! 88HZ889:VQ<;99W<<<< 6) =!!78FJ87! 88FC88""-;;RU:976]W99<,,44,,,,44,,6d. j@@Nal7'1#11&"316761"#"65&'&#&51#11316536767731&5514'11317&'11&547677&'&56633#3514'&#2767#1'&'7#3#676^7777% ,"(A !  %'=$ct  3-d#*+!____mmmm "# 'P   B t6|/. '$     i%67&'7&'11&'&'6'&'&&767'11&#&#&#"#511011717676'&'7116767674707765&'%''11'1"'&771676011''11''1&771'11'&'&771&'&'&5676167&'p$      -   .-AA= #  #"Rh  $011+!  >^];:D 8""  7,++,7I45 >= Kr#$)8&% EK *+ (&777IHw!11!'11&'&'"'1231"#"#"#"#51272765514'&'"'5176327"'11&5514763114'&'"167#15131#"'516301@           t  $&@@..m  %   -E""36_01016767&'&'67636''17676'&'&'&27676'&'11111'7676''1716'&'&767676''1&'&'05&'&7654'&'&12111111#'1..'08:\23 KK_=;&$=JMRSNJ=7$  $7=J NSRM!!88EE88!!!!88EE88!! 66CC66  66CC66 12==2112==21P;7$ $7>JMRRMJ>6# '+7'177711151'177'71''117171'1'`$$$##T33))P###$$T****33,,,,+y::--/,,,,+Z----:: 9CM&'11&'11&'676767"111132767654'&'&#571&'#1116755'111#113111711315167171'1673151#1&'71'11&'51#731&'!3167'71&'#!167#751&'3167'11E88!!!!88EE88!!!!88EA4444AA4444A.%,989,$/  ;;RR;;  ;;RR;; ""*"",9/$$/9,8!!88EE88!!!!88EE88!!44AA4444AA44" !3RRR;;   ;;RR;;  ;;R%.9,,9/$9,$//$,9z"""9P 5675147676321&'&'51#''2676767363&''&7&''&7&'111"#&167670101327010167676751&'&"#&'&'5111&'11&'&'6767"11327654'&#11#"'&54767"016316751676726501&#01"10101#"'010101"1&'&'         $@$        #(** *# #* **(#         s   ::RR::   )&""&)    !    !`         C    %67116'11&#6'&'&'&###015&''171'1711&'&'&5511511'11111715"'&'&'&7"'&'&767&'&'&7"'&'316767676'101- &# ????" #& .--LM--J>55 !+''@32##!!<++ 20 7./HG8999GG0.7 0$2 ++< !##23@&'+! 55>-$$$$- #>&51145656767454'454'4'&745&5476767676'01'&5&'&7674'&'&111"'&747676567674751'1&'&''1714545'1'105&'&54'4'"'&'&'41&771'1&'&'&5&76767676676'4'45&5&#&'&'&'&'"1&'&'&''151'1716763216767&#&'&76163276367633771312727711#&376767676767674767676111111111111#74'4'4'4'&'&5&76#'&'&'4'4'&'&54'&547611#41117'&'&7677116'"'&'671'               GW A 4 "! =,+@         <                          '-      &    5) 345(! # \S>231123222333"####"'"'"#"'"#&'&'&'&'4#&'&'&'&'&'01&545&545&547454745474747676747676767676723632363236323"032323727272367236767676767676767676'4'45&'&'&'&'&'"#&#&6710"#&'&'&'&'&5&'4'&'&'4'4'&7676767711230#"'454545654545454545454545676767676765&'&'&'&'"'&'672330213676745054545454545456545454545454545454545450103747416767676323013236767676767'&'&'&#&'301"1"#"#"'&'&'&'&#&'676767'&'&'&'&'01&'&'2232323232721636016567456767654745656745454545454545&5&'&'&'&'"#0'4741676767011161110#&5&'454'"#0#"#"#"#"#014163252767036345&#"1&'&#&#�270125476772723323001""#001220001"#"#"#"#"1"#0#4505514545651167222#"'&'&'&'&'&'05&'&'45&545&54765476767%11310#&'"'�'&' ( +    4  +   +   (!  '/  i             e      "          l      '  2#  ,A  &   -<  #  1                ; 7778               &&-           v671162&6727676767676'450#&'7676767677676'4'45676''&'&'&'5167676767#`#+*-,*$%B.5"*/'+"2 )L,15/.!Q:K\''1117117117171'11'11'16'711711711&#"'11'2#"'&54763"327654'&#FFF;FF;Fw [[ wF;FF;Fw [ [ w2&$$&22&$$&2####www [[ wF;FF;Fw [[ wF;FF;Fd$&22&$$&22&$$#### 9Vq+>1111676767&'&'&'&'11&'11&'67676755#11#1131131513151#15135#11#151#1'13151311#1'''1111711'17'771'11111717'11111711'77'11111711''1111676767&'&'&'5#11#151#1'13151311#1'11#11#16767&'11&'47131131513151#1513151'''1111711'17E88!!!!88EE88!!!!88EB54  45BB54  45B›%v0TTIS|O  4   t  ?4334??4334?_T4u(ƒ .''Ǟ76H[<< ,s@TS0<<[E  !!88EE88!!!!88EE88!! 55AB5555BA55 I///R./#-P8E       Y  33@?3333?@333332R3RA()U<<[ 8?39P[<<  !&/<'7111676767674767&71'11'11'11711711656'&'16'4'1&'&'&'&56767676'1171111'11111'171'1'11'1'1711'1'1&'&'676'7171711711711'11'11&7'167675171171177''677&'6705&'7&#&'65'116767&'77&''67&'0547'6367&5711&'&'67  4      :l,! ,k:        4   O           $$%#- "&"!#  $%/"#>']<&1xx1&<]'>##/%$  #!"&" -#%$$  _  2  J$.  2  J$.&S7'&76&76767323231"'&'6'&'&731450567676767624'&'&67116'&'&&'&#123632767676'7671165#1'"'&'77676'&'&#L $ #$-J..l  ( "**81  --F,"# s) "++9   N 8++" *G   ./K,#"!"  ) "#$+,,C-## %    ,7BiQx%66'&011176'&767201760156'6'11&7711674'0111'&76'&#"276767674'2#%4'11&511&'676'&'&'"'&74'&'67&'&10'&'&#&1376767654'&#&'11&'&76'&'&'&76767601""11"'6367676'&'&'&767654'&'&'&767631227256763"'4#&7676'&'&'7676''672100156767201003&0'05K 6   6  ,  !- ,,)* AB@A  &-- A  )##  '#   $$!  5$$    O    ! ..-. CA  0  r4   4Qe                '\7517151'51111676767&'&'&'7'151'1111'151'1111'151715171517111111!!!E88!!!!88EE88!!!!88E!"!";<<;BBB!!B"!!88EE88!!!!88EE88!!bA!!AA!!AW;X;LL;X;Wr(;7&'6767&'7"11'116767&'&'&'11&'6767O'(-22LK2323K9%%%%98%&&%8$L1221LK12%&78&%%&78&%E%11'&'&'&767677111&'&'1&'&'6767171'1111315" "."-,CC,,)(=mmR6589Uҭ -('#")C,,,,C?+,(??&99SV9:&E#&'&'&'676767#&#"74'&'&#0101017276'BRE88!!!!88E_Gc=<((,4#c&#"&(! .0-1!!88EE88!!?'(L6"!  6;!<d|777163213271171654'&#"7&1#"'11&1111327716'776'&1#"'11&5471171&#"111327'7716321176'&#"11w('('w('X('iw''hWw''5+DNXiz6111''1&'5167"#11"#1315131676'&'''676'&'"#"#131513113'11#15'11#1571111676'&'1111&'&767k     *C " ## #l  mm  \fe###f""T!&6j"11&'&&&'&#767767676767654'&'7&''1#11&''1&5476313171671317167 & <= 'AAA $# (' "$ A ,- -,$~*  *! 4&;, 55 ,A(3 %s#!uu!# " C>Nj111101476767217'1&#"1'1&'&123276767676767632371&10327676'5111577&#"01'&'&'&'&#"011172767676760137'  s### (& #B    Bs  SSS  SS S<  #m00m  %'      U|||      |{      {71111676767&'&'&'11&'&'&7667676E88!!!!88EE88!!!!88E''44''  **  !!88EE88!!!!88EE88!!22  ((  6&'11&'11&'11&'6767676767654'&'&'11&56345474'45#1'"#"#745656'51"'4767#131454'&32322'&!! ! '''' ! !!&'P P@  $$--$$  $$--$$ 2/.X CG&' 2+''716'&##1"114##1"13312551711331270E33nC62m2?!!!1!1676514'&'#3#511'11#1513117131''31513113R$  $  >>>=>>>=>=\\\=>=   . xMMxMMlllii+8EN#3#'111#1171311517131715113171#17751'1113311#11'11___lVb(m{WaCHU4N4PPPOIH(66SPߌHHHH@\?q?2335';;;er5FF=fff5{/Qp5311713151##3#1'1#15131'#3#653145&'#167"032767656731#101317677671476'05&'&'167316'&'1%671167&'&'&11110171&'&'1"11"#11"#11"1512767676'&#763631#1311'"'"'1365513167651*1za Iv4443X  4 B@  6 =      = +*67$  &l  -z,^)! ,  K2$A     ;  Ge d G ,I Uf!!!1!16767&'&'&'&'&7676765#1513151#1513151311311#113151&'&'116767&'z44#--/&&04>7H \nn3mmX &'$$ +'E(2"33#   *]v%'&'&'71676'&'&'&&5&545&11&'&'&'1&'&'6767&71'1041&'&'&#&#1111711107136767610767171&'&''5721'171'6767671&5271216&"171&'1#1&'716'&'6'311#1&'7767711711167671&'23012351'116767676711163151'1&"#&#112331311713167513216762111&''&'"#111012&'&'&'1&'&'&'71&71'1"4'1'16711#111&'1&'&'&'1'1'&'&'"17'11&'101&'&'767037271'17&'&'371'16367277#3#100'111'11#1'11'111&5&'&'1'"5&'71'11'&''11676767&'&'&'6767667415'31676367171116'171&'&5&711675171167677151'131171'117111312111"'&'"#'7'17167276767&'&17&76'&'7511&7017101&'&476"''7116511&7&#"7#3#12&'&#1111'1676'714'&&#1012767&'&'767676"''1'145671111101'&771'1&0167017#1&7631'11    !#   5-  !  .B\^?? Z     (      '         -       -  ;,, (@       s!  !/.,-##      5/    )          -(  D      *            ,   &  !)*/<9:^              % $          &%)          ,'         T     g $ /  23       8     8ycE~111111#1&'&'&'&545454545476767676711101011'0'&'&'1676767623270131551014#"#'&'&"#&303"#"#&54323274565456&#"#&72360125514720331&'21"701651"'4'43676767&'&'111&5&'&'&''"#6727201'&'6'&'"3'&'&7672'6567654#"#"'&567433232'6545456#&5676432327'6113"741&'&767674721'&'&767#3#"'63545456'"763207254105456#&73160#01"30013"#"#'&'&7%11#&#"30#"#&76'&'4#"#172#1&7276767676343270325415454#"#"7010323"3'6&72323236'6&#"17012370160'454'"#&7765656"#"301&76156'&01'1'4'&7674560101#"'&547601"1&03765476'01#1&703274545&&#&72323'71121"#&721545&#"#&70323230#"014767676767012#"#"#"010'&'&'&7476#1'32376'&'&#&711'&'4745765&'01'11654'376'&'&'' *+  "!(()32%% %*"! aa      !    ()  XX W   ++4           P    h        &  % &  '&Z !!) [ j    P }~""./'' 87      0   FG   32&% "JK           W     A  %n   j   :! .     hZ%0;r$)Cn}'L%67&'&'&'&701&47456'11007201&5437&110127&#'6''&'&'&#"#&54'&#"#&'&77'7'112632016&'#16701#47016311167654'&#556'%&747&7654'"311667"362767"#&7017"#66654#4'&'&'&'&'&'2#"'''&#"11'27251#67116'1101&'&##111#111123276765416'&''231161'"#55236131'"#7'5171#15131'111#11113171#71111676'&'&'11&71167'77#11111'171#111131''1"317&7"&701&6763&'&"#"#&'012311611'"#'111&'&'#111131'1511131517'"#11"#11&'010676"010351236'0111676'6'&':  4    '  !"-  '  8    )   e%4IQ<& &' %[,,,*-,*#    '         4N  L666!  m    ' NLN   BBB&&B '    - *  M0  U `     *<Yk7&##11312765514'%!!!"13!127671&'&#11#151317#3#1311#11311#1&'516731'11&''13117131xh  h   /0 e555 5>?h  & !&h F  h GX&&}srr9v7171'2511071167676&'&'&&'&'11'&'&'&'676776'&'&'41&7676761216767117711'ߨ:              C:      <       e}1@%|NW($3@N71176'&01117676'&'&111676'3276565'111131676701767&'6763&'01167&'6776'0161&'&'&''11&'&760177711'1711'#3#6'&'&51671101&13167673110#&1171"7"11516'&'4'11"#1'1116767613111&#1701701111151&''11311#116'4'&'&'&'11276711111672731'1&'51236711301751171&'&'4'3167121#161131630731111"#&11112767317#01"'&'&76767676'&'1712160171&#"#&5&'&1171111'&767610755214767611&011&'&'716'014767&#&76'"'11"#5171454&1114#�3010'63112716'"1711&'&'7101#&'&7&#&'01073176'&761"511&'1111'171716711&1𜥷117''05654'&"'&'01711'&'&'&72017&'11&'11&'"7111'1676716571171'11171'1276'&'&'&1711&5&'&'171'111&'&'&"101'167671'171171'171171171'1711714'&'171'116767121'1161117116762'%27101&'&1117'1113101676717654'&'&'6'"3767&1176#231134547 Q/)11110/), 2fJK**09:!*==I=""    ))??Kc       7  -       %         *       #)(A( !U[! =    "*$ )!  ( _ ;  "  %6;<h    ,  -[DC&&!"GGq =f L &+    !"$%  12[6$%    7-, Gu     ,       X  s   Y   O     ,       P+% & D 3X +^%  ;   * $  +  =A= !!Jr '&| !!327 ,54'&  + )%77#111113#371131XXX 8 ̕ v!'_bi`D%S}'9Diw 'D9L7771'171#1'11#1771'171#1'11#1#3#"'551463312'45&11&17117456##3#513125514##1513125514##1"133125514#'6751&#1"133125513113312'''#15131274'&#1&13312765713113312''77553125514##1"13311331257#3#51312525514#4##151312165114'0##1"#1"23312161514'0#'#3#"133125514#'5514665514##1"#1023312161513113312''#3#513121#7#3#0#1021310361513125514###151312''1#111711'177&'6'&'&67601&'&'&767&''&'0#&'&7367676'&'676'%6711636&67&'05&'&54711#'&'7676767017&'"'167&'01'&'&'#&'670#'#&7670167&'01676767667&'011167670#'#3#&11'55105&#1&1133125510'&''1#111711'17''1111711'17'#3#513127055141&##1513123455105"##1"111003312161514'0#'7#111711'171#=]Q  * O  P] .   V   $$(( *+7/0    6 ! 2##0( B600    r]++1//+* 1++2//$  $$ 88  $$vj  <  89 < 2!"s  &9 $ ( < ;& ; 6666??((4  $   ?  !?   F;(('&  !"= K"" $$& } -&  !"=K!" #$,%A" JA">  ,%(%#01 %&" &r2  244U@d7'!1'7&'#117105676''''+++;X) ssstGKKKg##@G-57&131276'&'7111111331276'&'&'&'&'&'&#" } 2\4$  #"$# >KK8ULLEFA//FFGG12%6711671167'1&547676767'&'&'01'&7476765'&'&'&''&'&''&'&'&'01'&'&'121276767601314'&'&563010'&'&76763         `            -4ETcls'15'51#73#311715131'''#151115131773#351'''1#1113117%7713151'171#!#3#111317155113'3#3'17'1#111135#3#17''13'77#1#3#51'111#1'7751#11'113"LvMMM- ,,, -8 88 Ollla888 8!!!Z[ P=NNNZ[M -mmmL!=[ZNlllM=LLL-LLLm--- ,7o[[[Z!P^MlMMMl 8 -87, -a888- ,7PZ[[ZlllL L [Z M =LLLl=MMM-g 7aZZZ[ O&M7170167670501716'&'&'&6''1&1'&'&'&010117676767 j +*Q2 tHI)* j **P3 tII)*$ B 4(  r6 ,-'8 A 4 (  r 6 ,,( -6?\es|73#371#1'53171#7"51147110167676##11316767#%77#113#3#1317711013107676'&'#113123#371#1!3#371#10133#351#1773151#3#351#1'7#171#113171#33171#;;;;RW3)dD=(((>(>u___[o -vpIIINC;;;; ___ZMI VVVQ:(':!^ 7 5555 9 N55<t7111111#&'&'&'47676767&'&'&'4767672254565456563232367676767"&'&'&'&'  !!!!  !  ]   !"   \Zbs%77#11'1#1513151#11#1&&'&51#1513151#11315131767#1'&'31673113171131'%6311#&'11&71167#3#51311#11311#1131'5531511151#7#171'1311713111#1'J555>w8  7''!!!!!!!!V:999WB55f  f55B----d%6'&7&76'&'010132101312367&'&'&'&767676232727676"#'"'&'&7636323237454'&'&'&'&'&&'&'&'&'&7676'&'&'"7674'&'&7632'&'&76703316'&'&#&'&72323236Q  /p    -.64+((!  "33      !!$  2                  %"'    %$ $  (5BU&'&767&'&7677&'&'&'&''&'&767'676'%67676767&232%%&%%%&%%%&%%&%%a@AM (!! #%%&%%&%% 3-''-IA@$ u++++++++iH++$ %Z++++T#@QRD!,11+ % "#?{->P`7#11"'51#1176751#'567676751&'&11&'&55167653151767&'&556#&'0171111"'17674'&'&'67251&g ! !c21UT11;EEAA0f)*WX*)NZZS    O  hg$ iJ&%!!&%J >!"$$"!>D lE70veee- W      %` ?c%6'11&#101632763276711676#'131&'&"#1676767'1111210!1    pE !)43GGp&*40&`34$B2w10  ))<<<<((D  ]0     @f%11&'&763&'&'"'&76701#'&'&7&767&'&7601676760167647676771111&'&'&'676767&'04'&'676'&'&'&&'&'0101&#"117276767676767676')       #  f!!88EE88!!!!88EE88!!O            g        $   YE88!!!!88EE88!!!!88EK!%       ?l7&'&76'11&'676'&#'&76767676767676327&'11&'11&1767701676'4'&'&5&% 2"* ,0%'   !! /? !42', 2K/$,,$/I A-,),85' && 07DC1 <;  i455&% (- %&5 \enw%6711676'&'676'&'&'&' &'11&014767'7767501&'&'677676'&'6'67'&77&'67#&'6767'6767012'&'&'014767037&'&56&'&2&'&'1&&6766&#7676311#&'547  "  %9  ;"A   '0" ""Y ,N!,3    .' '## 3E0   8;;*+(-A   !# 4! ' 6( * " 1)- j8$ 8  &. - ,?5OJ 9--    $,9'   9 -9 =Wc%&'#1131677&'11&76'&'!11!16765&7676751&'#3#513121#'#3#13167&'N*3+2 '' H '' bbbb! ' 222446!G$ 0000mO'&3E%7''1&77161771615''&1''1&117716'%'7716''1&1//////hCaaaaCCCCbbr[[[[[[!.<L!!!"13151!11#113127671&'&#1111314'531&'&'3#3&'&'&'1 +  U@.+**@+++ 45BR66 @@+ * @U***-?+*A55 +66R11#11"1"#"#"1710&7116732765116'&'"#&'&''&'"'&'&'&'67232767676545&7601212'01"'&'776'&'&y   mO        #"# "  ! A   Q <o         %   "=66""8 @k111676767671167656765676751&'&'&'"#"#11"''767676'&''&'#"'"'611667601'&'&5''&767676711711327237511&'&'H  1**3788   +JJJI*    ") ,, "   **)  "]    :988  98:9 6##/ -  - /##0   $3^ C%07#3#4763670#11&117216765&'&0101751&#"%11'''&''&767&7676767264'11&'1101&'&'632707674'&013#"'01&11016571013076720&#&767016551016'&'705"1#10#1112131030570111&'&2765'14#"#&'&7413125054'4'67&'&'"1&#&'4720767654'&013"'4#1130174##1476762125716#01&"#1"1331"1'4767676767312501114'11&'01676'7&11"510'01#10#1101131070151&760125676'''&#''&5&76327416741&010127657&'11&#72765'14#"#&'&7413125056''"1131&   10B#$/+,*+=##2 /<&!0 0,,        /  8 %$     B   6.   /  6   % D(( 01 %$33!)('0" $$2  + "O25  :   86  '  `9Z7#3#"'&'&547676331#1312##1&'&76731654'67312765514'&##1654'311rrr  r   T* Av""    x3x""1111676767&'&'&'&'4767&'&#76'&56''&'67633674167676703&'&'&1'&'&7676'&'&767667676016E88!!!!88EE88!!!!88E   '  '      $   !!88EE88!!!!88EE88!! +  *%&!  /J     4 .U`k%11"'&'"#"'#&'&7&'&76727676767676711676'&'&'622323676'63112#"'363112#"'&711611367676&'&' >  9+ =43%%=$1G       8=co&'&1111151&'&1#113117216767111111227676''111171#1&'514''1&76331217167271151&'#11111'131675117111'1'15171717171> gg , n5554  %% n7s&Rs T3x'!XDgg0<aa[[[..\ FF  =PC4+RB4"H TTC%''&#"11616'&7'11#"'&76751&'&7'11132771654' (32  /  2 )42.z  {  3  BW^e711#151317!16'&747334'&'"'01&7#1132774'11&##11315131676777#17#3#13  @1   0~ 4!11100*@@      &8 / ] BO`iz%11516727654'&'&'&31&'&56763231&'&'6767'"'67676'&511&71167'2&'671111&'&547&'67#67&'34QI/.$$#$./Je779:kV77>=auAAAAua=>?I+)R $ $+*++H$ # I? 5*4  vF&&1J/.# !./J1:9hk::&'HS--AAuuAA--SDI  b##3IC&'    86I`p1111676767&'&'&'71312&#"73#31#1'11#17131#3#7136767&'&'713113%#3#13127676'#3#13167676'&"# N?@%%%%@?NN?@%%%%@?NUM/ ![ $ % ! \5h     32??2332??23#" :Z##Z%= R$9c0  _9!,:Q_o7317113171131'1#11'3#3#13176767&'&'&#556'0176'&'&#1131276767&'&'41101#157751116' ,-. -)*0000 4.3  PPMMvv0.fff !" J !   m,3<L#3#131676'6'&''1111676767&'&'&'#3#513'&'67#3#5131'.../2+'E88!!!!88EE88!!!!88EQQQQQ94 !!88EE88!!!!88EE88!! '*J454'&'&'&'&#"##1"#"#132331232767676765455145 ""#1#'&'367&'&'&'&'&53676'&''      F&%)B'+((+## #)))@/. : $     = !''$   ,&&?!"%''"$999%m1111676767&'&'&''#1'&'&'&74767456763111013312767654'&''1414771312E88!!!!88EE88!!!!87F 77      !!87FE88!!!!87FE88!!)  )  )) v#S29 ,  4 :  F : d 4w XO . *% RegularVersion 775.01171875 (Font Awesome version: 6.7.1)FontAwesome6Brands-RegularFont Awesome 6 Brands Regular-6.7.1Copyright (c) Font AwesomeFont Awesome 6 BrandsThe web's most popular icon set and toolkit.Font Awesome 6 Brands Regularhttps://fontawesome.comRegularVersion 775.01171875 (Font Awesome version: 6.7.1)FontAwesome6Brands-RegularFont Awesome 6 Brands Regular-6.7.1Copyright (c) Font AwesomeFont Awesome 6 BrandsThe web's most popular icon set and toolkit.Font Awesome 6 Brands Regularhttps://fontawesome.com       "# !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      exclamationhashtag dollar-sign0123456789 less-thanequals greater-thanabcdefghijklmnopqrstuvwxyzfirefox-browserideal microblogsquare-pied-piperunity dailymotionsquare-instagrammixershopifydeezer edge-legacy google-payrusttiktokunsplash cloudflareguildedhive42-groupinstalodoctopus-deployperbyte unchartedwatchman-monitoringwodunotdefwirsindhandwerkbotscmplidbilibiligolangpixsitroxhashnodemetapadletnfc-directional nfc-symbol screenpal space-awesomesquare-font-awesome square-gitlabodyseestubberdebianshoelacethreadssquare-threadssquare-x-twitter x-twitteropensuse letterboxdsquare-letterboxdmintbitgoogle-scholarbrave brave-reversepixivupworkwebflowsignal-messengerblueskyjxl square-upwork web-awesomesquare-web-awesomesquare-web-awesome-stroke dart-langflutterfiles-pinwheelcsssquare-blueskysquare-twittersquare-facebooklinkedin square-githubtwitterfacebookgithub pinterestsquare-pinterestsquare-google-plus google-plus-g linkedin-in github-altmaxcdnhtml5css3btcyoutubexing square-xingdropboxstack-overflow instagramflickradn bitbuckettumblr square-tumblrapplewindowsandroidlinuxdribbbleskype foursquaretrellogratipayvkweiborenren pagelinesstack-exchange square-vimeoslack wordpressopenidyahoogooglereddit square-redditstumbleupon-circle stumbleupon deliciousdigg pied-piper-pppied-piper-altdrupaljoomlabehancesquare-behancesteam square-steamspotify deviantart soundcloudvinecodepenjsfiddlerebelempire square-gitgit hacker-news tencent-weiboqqweixin slidesharetwitchyelppaypal google-walletcc-visa cc-mastercard cc-discovercc-amex cc-paypal cc-stripelastfm square-lastfmioxhost angellist buyselladsconnectdevelopdashcubeforumbeeleanpubsellsy shirtsinbulk simplybuiltskyatlas pinterest-pwhatsappviacoinmedium y-combinator optin-monsteropencart expeditedsslcc-jcbcc-diners-clubcreative-commonsgg gg-circle odnoklassnikisquare-odnoklassniki get-pocket wikipedia-wsafarichromefirefoxoperainternet-explorercontao500pxamazonhouzzvimeo-v black-tie fonticons reddit-alienedgecodiepiemodx fort-awesomeusb product-huntmixcloudscribd bluetooth bluetooth-bgitlab wpbeginnerwpformsenviraglideglide-gviadeo square-viadeosnapchatsquare-snapchat pied-piper first-orderyoast themeisle google-plus font-awesomelinodequorafree-code-camptelegrambandcampgravetsyimdbravelrysellcast superpowers wpexplorermeetupsquare-font-awesome-strokeaccessible-iconaccusoftadversalaffiliatethemealgoliaamilia angrycreative app-store app-store-iosapper asymmetrikaudibleavianexaws bimobjectbitcoinbity blackberryblogger blogger-bburomobelexperte centercode cloudscale cloudsmith cloudversifycpanelcss3-alt cuttlefishd-and-d deploydogdeskpro digital-oceandiscord discoursedochubdocker draft2digitalsquare-dribbbledyalog earlybirdserlang facebook-ffacebook-messenger firstdraft fonticons-fifort-awesome-altfreebsd gitkrakengofore goodreads goodreads-g google-drive google-playgripfiregruntgulpsquare-hacker-news hire-a-helperhotjarhubspotitunes itunes-notejenkinsjogetjs square-jskeycdn kickstarter kickstarter-klaravellinelyftmagentomedappsmedrt microsoftmixmizunimoneronapsternode-jsnpmns8 nutritionixpage4palfedpatreon periscope phabricatorphoenix-framework playstationpushedpython red-riverwpressrreplyd resolving rocketchatrockrmsschlix searchengin servicestacksistrixspeakap staylinked steam-symbol sticker-mule studiovinarisuppleuberuikit uniregistryuntappdussunnahvaadinvibervimeovnvsquare-whatsappwhmcswordpress-simplexboxyandexyandex-international apple-pay cc-apple-payflynodeosireact autoprefixerlesssassvuejsangularaviatoembergitterhoolistravastripestripe-stypo3 amazon-pay cc-amazon-payethereumkorvue elementorsquare-youtube flipboardhipsphp quinscapereadmejavapied-piper-hatcreative-commons-bycreative-commons-nccreative-commons-nc-eucreative-commons-nc-jpcreative-commons-ndcreative-commons-pdcreative-commons-pd-altcreative-commons-remixcreative-commons-sacreative-commons-samplingcreative-commons-sampling-pluscreative-commons-sharecreative-commons-zeroebaykeybasemastodon r-project researchgate teamspeakfirst-order-altfulcrumgalactic-republicgalactic-senate jedi-order mandalorian old-republicphoenix-squadronsithtrade-federationwolf-pack-battalionhornbill mailchimpmegaportnimblrrevshopware squarespacethemecoweeblywixello hackerrankkagglemarkdownneoszhihualipay the-red-yeti critical-roled-and-d-beyonddevfantasy-flight-gameswizards-of-the-coast think-peaks reacteurope artstation atlassiancanadian-maple-leafcentos confluencedhldiasporafedexfedorafigmaintercominvisionjiramendeley raspberry-piredhatsketch sourcetreesuseubuntuupsuspsyarnairbnb battle-net bootstrapbuffer chromecastevernoteitch-io salesforce speaker-decksymfonywazeyammergit-alt stackpath cotton-bureau buy-n-largemdborcidswiftumbracorclone-v1.71.0/docs/static/fontawesome/webfonts/fa-brands-400.woff2000066400000000000000000003477041505210326400247650ustar00rootroot00000000000000wOF2 my6$ `vʋ\ˑ %6qEuIׄU;~/cw@,q=_.cY9+ y*S~G"q/ᖁ7(杈y1;ɷ` @*J?/\:K3> Ж 3i,l+IɄڤ)@ 戻9wf~_j= I5Y"BG\.5Y|m-1]K?B !ձ-i4] L!ö+oV\k=I˟o?@bS>Ss6=˚Jp^>/]cM0r!/P#? iXRZfhE Ң AїhTK >KptL"h^g(F%uƉr6͚-D71)k Yκ-}IlAXj Mj}N&vwp%g,ҠIas"fǤLWx?y<_4k䌬WAXYFK"u|ZEhP11Qf|+ؚ*e;%o2s;e+iЏyC# JKgi#S #XkR]II ̠s#.ȯ{461vq@RN,PUd O`0Â]WFooR'exr!))B]/4U҃ t>kPStMJZ%2cW0|n~3s7gאkjCV'G53x1\A'<.>؟DZx݇t(/t!FG^DEUt#] *b+ҧG=tje|{%^#8 !q1!,⎧`ІI;g53{Z^EwD9o5F,(%Ki7BuQJ#w4[o3 ٹ.h[ vޏ2tx>۶^g'^]Gd.p[c?5 3S소Ý3#O1b .HkwAXC>ٴv8"$]q]:N5W1`[?Xh;Rl'vWQ3?D@8@4Z',;Aã6 ܐr@>(m3t C 7`0 0  `4U$W\r5223LifFliN5g&w?<8pNyW\ǻ?7Q %R*LEUzԁ:S_@hMٴ2ZEkh;IN=܎x6xWʇ_|oM-`/!dZEf9dY_6-ekLTV~UҪl-[[au޺nݵXh)w@ T T  UET{5VMS:H'*=wdr;ţx"O<*^Ǜx;| ɷ!?ĂOf(\:d6Cz^)G+[ j̟uZ#ߖ,!3!&" ~8dΘ9]ԙfdJt9Ōu3[a+O>yyyę]}XK<8:a:;hJ}<>m6 ZA-+E eҜRiZEr;_/ķ2xW#^ώg37RⒸ8.S84 /gDx,<po; n 7 p]pepA8?gª,,ͧ ?.?8?;)!"0_'_+[1E{sSr-s-r5/dnnnȮˮNNΎvvͶͶ|4s 33-3>30[}i'?YOOMnLOnFY449/"9dם/6|RݻdNz}WF6_{f Vh2* j:ꪧj&jZj6j:ꤳq|IY<])S4Gˇ&}yCU,²õjvi=>:'m/A۟v΢F;Ў1\D;v2.Es\A;o W.]hЧ`.݀kiwh p?5ڻx-{ƤS3dĔ'g4'f63QQ{4FGLCJKIM,B݈8u"u*u:u.,u>uu1u)u9u2u u:u0 $= ;R)3QoPS s+`'pQq%UCxjzvb hĩ1g'OA\@>q9}7g#&N2͉{k̉ΉωoҿMbdN|p9)s3 ̉/_24'bxuN|7 ̉oOo\*o\o\:5 pwpi?lL`r? `j)s`OL.LOL0y> 0,8\1!0kC ?!& `/ `e#qwOpx 4KsH #sHyC8,~ODI40fcL@EATy2TBSXJESE22I*I}w/^]wuWvŻ~ `#ppA O#W 7W 7vwRES"zZ^iԔ0溌1溌5$m.%m.q2Ƙ;1\  Qa8ïH*Q2Ue$|eԌcE@i&EJNgB^R҂.hs4.L?^NXM0 υpَ8v֥";VuEzp8Ywp R( v"%U$#jR3MUBͨdj7? 5ijƭ4vVbT o2*&IjyU;E\ƈ[ZDslwskq58sJHMӫT}aWk!7t°UB4ͮ* 12Wɘc6ZcRbQ%ä%eqVo,miM1Xse8aҒhXwkƼۖ0Z yW4[2ʶ IPF2*4捵/gžO%|;ګl!lƦk~ΙvӀ\Pq_D7*NȋBRn )4;fZ\8/yE\( s;C5;[{g)4̣o=z돦g?z4z11@(~ C5|$Samٽ2]ݝ4cE@k w^7KjKrZ]iHoI¤J44Illml?h^GWXX Z0IЪ|O}%8wF c5pl-JN:;Eይfmڂ5I[sv /|*l`n).de츈dՒ}S(gǛJTvH$dªsbU٧ ?-=1Mz74j1ts) 7,b,s.c8yXzIt95tUK`ӳ`S—AS&'D2;ơy6HpnΧ?(J7ls#w~ |н yxViV?ȡ[SeK6#Mܟ#/j'XK[ЄT4Peb>IA~\˟Xg2Q h;7tH~(kSsBDZWvg ."]sz}ø۵HbGTwq{{3Ҟ:>"۲,94/rJt5ͤsY\`/a$&v$ Yhr?ɋl[tR B׋Oوq\_<A.yi'{gSMO}9qCQ9ucd=2tv'P>~ZvD-v+V8NGi1qhejOqXF-qPNi/O ]HOGc/tʳ?Uĩ8"2G;\~TnqguTd[o&Ag[|m tV2?ҺT9c-٘FYr$#̇Rp:<ؙ C y$MR̵ps7WZ-V{|;Gh$y~s2$y~ymml>AZ7[ޜdLX @f}&MXf:sL)zyQL@axf 6$2q@EzK? Q7y7P:X@xt0 -+hM‚;mC!u=->uLb6ֹٓǗSRǏMu`w{%-~m3!lTWmem>msa l#ǝ1Xp^gB5ԞSF`-OT؟[Xxn pͥMfF;(mWB^q6[7Zi"¶2 qV6S^ED<:gO+LC[fB˭*a}b嵠Po#΃b[m`FxzhK41lռYL\`'1SOWз/Uz"? f\:R=bq8D~q@ѵGO{z>3v4bY\8kphѯyvVt`2<6 (/`ذR-)s;n"nJH^(Glϳ)%1ÊauF;VepT^ϗyW°<ǂ4}b|Y%.W2Kxb?28c.v{4]aX0 IECoJu:QF?ŝcݝ|_3NO~nft"˖CI}E#X#8AҕYvBI-^m@a‘)KO|NWfR4T!}_i!:슥L<ݽ?2nw`sja[~b޽e-[ch30fd]RpF[sHWN`%#H(yWxȉer0HZ2B#_%}񖊲T ͥ$MbB.<&-̢T_ư%iJ.ꚡs\50t82n>hF\PSGA`n٬"evE\(%w0 hhRXG0Rr4#ߜi:YZJǘd rC "(GZJUO[0gZnqy,~`zpnɃDs~WL^S&MRm$^sn>9XZ#C7 1nGq97%mtMuP8xmmkY~EtEn߫#h? 0$!7CP8l~zr}M):_iS#أ2!l:> n(r|A'?.ܱ?I5{?5T^Az9wHُ}E4salXߊC "GO޵f Gx `kOq,痧 =/ᵆX/qR0~ o;'Ed ,ʶO43^rYٝK7iqx4c֤;A0@^ٯJYqsmj].U֩5_?QkX.evq\!ںYVR$k(Q͢ػ.EQP#aB !$,[NI%tlMZA['dqѯ9aAj5)Jt(M$GƱ1; 8>J8σ!\zqhYuU\v+d7f)YډJ^P!52i%OͦG&V8Ofm1c u ׉A oގI]l kkeeܳ7?[4[Wh7ӟ }J%/=L&>qXZUX' 2rܥuqo\:эґ{f[~76GRDyi,mm? j5dv#:yW9})-J3zQY gR* ߟ$N;w!N[I }a['#z5]?vL5 {94t2wNP{!wzE=:[!++hubdOnFC Es***͝7F@l533gTiwpD:9b˞WUxUlV p_7_/NI9 *i=3cv'gij #,2iҬlewiL3)>ST&;G;>| ;noCB<*mKwvv8?F1w.?;Kzy晝]3 !C?`MtɊ61vQ$㱉Ť엦'IRё~zY/ |KO2?s]{?kk}!ۼOůG"$_L>@~RE^E]=K%mA>f^>k*)5]8=+ɫHefO,fE^U^rX.EW{ó4QXo-7t2tײ G 葧.(8B 1ƙ@?طd⡵*zZo0yjwn$ytn]5eBH9@s(09}pқZ# WY0 #*]銭쐚C:O˗] B˗ĿzI"Jo-/4e}ɕ+W-/4n74ZqH$ď\On"#"*/ʢ*6)7@dy1fSf&/fJE:͎潳jVҪ\ϫr93LCVjYʜUZ?ėpF r\“LDk^b9AJv) yYr:Rʱ%*MwY!pN\aSu)y8DxV,p![.\X5'F#44*pXt *- Өk͔ zl=|bUםpGͱ[YmyG#`<^9wQjTa*S}I+yi))U:OneA;@թ:"'*߱a&zNx~;MC<\Cg3]]?-_Z=?k p*eE?yK ʲ}v|i_|{?FC<(1~:49!JWR*0LnPRw,l!Y3ej2LpI؞*~64LO6+߻1e$JMSw@M>2D65w$Y_ݹם&McV6vk^l̢^5|;T1_\K帪Fr',*jRV/fA|ҿjt6S)MhVQJ7.JzX*D.g d0y:u:y$S>>e w8RޣT1ޥqͨŌs03asA挃.g Ү:p1/Nt eH(>P/grN[҂rdYal381j)vV  G3G* |>c< ,ed 8mqL)CA_9 `,fe)r_ޗ.p[D^Kk!mQoR|R[d v芡%رl( PΌCiA0!El1ِEwccsG;[mϗe^ѓ#١;Zʺ]?}Ǿ2Ϋ穌:EhiԆ?׬lVtNAꬣ~n7tڎ=fg[gAe$购,jxuPB퀤S{IJ?oooO~򓟼r嗯ꇐ=zMnMcjڌzHӾw%,_)撹2VN+M-e#`ұۯf–ӚS:mm*cR 4no'(Ź>F) a`q*6@8mMҴuӄs);6+ ^Ynt;nn 9|\#)9BΑ T*8C}~'3g Ov?S En dD1&kdq e* +;bkx<`}tm‹/zfwx`{({ч=)ju"t"uQ7FL`FaO._駟~?>‡v'KchdaGQMʽ%" AŲ܊ b Vq`u52s9Y>}Nc[EA((s8pM"ϕV;MǶ]җ\^ȏgxr),b M@0,'>O).۽|IcWҫd@ 9G&KKm7FRkMr[󬀿auYp3f mC:opmTӲΪu]ԩ)~`2ePcmcw@8[R)J;~>DJ cj4!=AGneY駿멧^V<ĭq338# (6z}JTe!;Gyc<Ƥƛ1Uv#u:qq5QEB`KS{kx}um+E[U.UUyDBdۑ6AngI0ƩdF16cR/QJkѐ1 b|292Fy~-Mt4!H pq6M<$IGoBQ?P[ND)6VÌt{k6  '%u[Dg8<[ߙFxafIꅡ{KNh}b>۾5YDvMuk֏gέp9꺷8;'#{dA8@n0DŪfÙ&:ʶnžg9mvpuAƊnl«~-x=}dj*je"WJt&(fX~v M0Eot1Uf0!?V-ǡ(,jE7ʥ~fRr}feĹЫk<)y0EQ6!:t9)?Ung!,M*n krw$M|uKU{YUxTU4U.PNN;q  fMYzGNC !D "쓒'2!0dmI2HSLe0]Q+r0SM,+9eS5d*]i*gLQO~ d?;d_"/be}K<#7}` .w[h.؇{a8baȔ> ?SUPuw{r:g=~[oS}>s>m[ v1"p*쓻_BQBte\\gu(@RgWWxrKk@Xat xvO'*)Z]XMr[U2N]xॳ\r,a:;WE^E̗e5C~a*R\<xVV#o˾)wj1ZlDe0=ydzTZ )nN?nz JUփn2ʰz)u;iQl :[x0.F$XnO)(@5ғ"mӂRFwlǶGn%ѥ-%:{I[֋K~GTK39 Oqg `R9Eu mw)yZ#)p!JUTc=ސ;qٳG;(}Gl]&堽KN{ߍ7$Ձ*|4;Ϲ`'k V &8czu&8TvBj|D\ІE_~`TL;.ҳOq~r\Gm|ֻJ>9ֶ|oS5cǮ?uض=϶o>9FNc#ļ&Zp!1y*+3-r ܛm(2QSR 9Lqukp{w:q顓gYGwwnvžyS҄!M)>&)iB_/~OfOf1,۱meqʨV[c<8[R(qڭb134I)MGQ\xhst:qFӣ;;0$H:ͼ#Z+\9ELONBÁ yöjDZ^qn ݄4uQdž93.߱"Z :v5> m_htu4h4mpo4?$Fc׮]F\A{{{Ω8>6׎TtȦdIaӓɴv0OP/u *x?ϘX~N9iq\D4~t,k2tRʌZ[MmAϵ.\ ܵ[Y89R6a-E1FƲ5z ~/:{xg˗H>rB߮(ifwɟ%w:s7ҏw{Y.δ]DբTHlbbY13ՉW%,S28F3eLb~Rjfb6 vr fFڽLRe'cm٨Ζ"Ok?yUe뢞/WՁ^%V*KR~fjV :}諒5{E QyvY$ EDzcqQpmƱf`q͹IC@\.DŽ̓=d,loL6*|@N( <>8eSxQeGlʶ0 ʨp808 ݹQk⨖,<u{kRZVi meAgq< n=X]LƑ^Nס}RJew;Txw%cRJ7h8pDG)2v2A)gctp==|o BYSF1{O8籲c&8(wlS&--%-\.L9M ʱmX\#FcHDžS.`b&D, aOPPp&ٔ81Tgݐ}q8;u7͇~=t]^@ Ed> hTc)M{fe\ɕTU+[xgVY\Imp (V㼨«Ux5d[޻Y7U,'ڐq7cއ(NV,R#ߧ =VU%Ο|kO3쯀+L^;tǔDk-!ثηlA-@=? &b|m_49Zf(NҔs ̅y3pmt~#`4I`~里Jr?v)E+-H'%c~$xfـ5Zwڽ^…^֢Vv?(ۉB .hmR-!*ܷB3ړ87 z|y߹=pc=<7\F{w:C{~d#XǎkEP8in; Riq$ *AZ k"σ7oެn Bg̥R03H@Dv*%Y4E@#u,7Ps1ѐ3!c)3BP) LSs][%%J&/$R!TJSZں $i@5@) MfTYW#ZNuRPOIxFHa <1*kp]Rpmk+zJ DcD)"cL~m? =?N R&^q^ {}"ԛZk K79ai2a Ō b ܉xT34}8P1!5VN wrF}}r2_(G3 q \m^)`8I!z ճ1L mJ;s96P]5)s@9n;`?1,8#r0rO:8ֿgfUh/ˁNqZ IQWV\u\<|' puؠQˎy:c[@YYt&ua9 %"eB0&Isnot F8/| nO+UCUDSq~`O@[dS7sChԍ, ʓe30ruogrW\]E\]=~LbB <ק(_ߜ?S5 Q=̩5XY9xQU?V)ӫ.'whLzˑ96rd6/1^c|4eyO;/-sk3|3<4 Mb"#2&9r/Bד/&Oo!?AHW9L) ׳y%wU-y=*<-x(.>r₵v!/m=S4J\P;ȑy.-m2CFrS (?.%,Fr aVg6WVxee3k6[׀Ruu8^[tlɍMNgu-Z]CD~7+ ޸4FR#8$͆ h& 򲧂`l~_uH+L !j]8L[Kopi?|1zCKRw}x0g<{s;jTe kOˉHN[Kx2LtuB ,>c[sĺMRe-+GDZc I$Z+d@ ha =8jѽ/s=,_zY~ @/-e9@uM2tz^ky,,wTO-k~+^x.xnD+͸*W]!f@(u0)9#ܿ.y]IiF'&z V̙I??_Ϥ_g"!i"o% $_O\CR;i6MG%f:ęC 0X#(}B&,*VDT3;&`HKia^},ֽ)eQ\Dif Pp:*{ =[ޑFJ)RD 8@(Pgts\}PFR*<{UW2\d ,j$>QԤK(uq)\܅yoFꎊQ )`IQQ@Ɛ+Dހ[yX\J(DB޽i'$LLu m4Ӂ`oܨTZ3*O%k[ȋ7Rngid 61c6eCutnq04YƬR~pZX?i-(ΨznmN.AI4 ZvNIOx`ߠ,`_+ݗ:^ݕn첝Q\b7!<)Iq-EqpƌinoM;.$&@3kkey$}}T)-̃ M!8:,}Of غlZzeԶ[JY'}tC}20"J?1OԖq?Һk'\\v{}2fQxaFsC@eg.Qo-h!#e}h5XK~\''d 28Çɧ鴬)xj%BsGvv8n^^A_=ٛ~ߋ.Ov#p8Ƚ5OAr$2$oew\_^"?իWrhZMիWQai \},3$  z;j4nX_=Z9 CcN"rUkt( #rimuDrªLjh41KY&DY^qKap)Z8Z(B0 ] O˛;uJH4ɰ(P+ (P, @,[CGE\5܏$յk }pkvxC};xt]˻wxyh33Ύ%Ft&o:]Ka;kWOEl da?+^J؆1(HsHg5ja Kp˥K=s]pb^}{xv"58]et,P@Ez<;0u?ˊ__~~x4=Z=+|t:oz}ҥ=:εη9kAȡM-"2' SX]Ɍ76朂^TeQy`"sVD׫&kҞEI. 3O_Q IE3yG):L8XK-幖-jL66&Ց (ŤjړI&$yf+etS y#}}3?l.]RrךjH|jI}uɓgnS: :C=4<p \ӉPҐõ?4z?ʃO L:aOt:iEZO3MO x^:O<ē,GXJ㓾T@'$mm6*/AmT&8cs(1x+_. @^!q"}Wʼn" fjVj;:kjy*novm;Exm'n4|96s8= O[B 9]-;35G}{ G*}i8 wGJYGWJ\7! MJjE5?0aZ\Um>P؏,7t*En'Nܶmzm[~VlGPx|:k (,4믵ÁnҶ8( B'A{Y ݨVĺͧz}KF$x~ε<_̑=/ݏRdA8:H&[bBHml[R6 fLJfۻ0)eSe螪So T(rw !ĥ~B]\wO\W؇?y]ߢ/{s;l̔*Oz^'׎5s3_R͌LDSvvЛbH<,UGLA.)ΚkհU*$)*>UR8 *#ZHJgtIKƬ*34XnTVLx覵5zʌ?L^̊U੉BQBETFce :]r*U$E-J? ,28R4ԋ,;6r3GgAM9Th`ŽFcCzzfJZǕj U%pr(26>\zE;`3" e ɪTD%L$8RPSc\SJrWqK8H)cHR|)p)G2q8gc(12^iePD1j }8$@N0ù7.V⯤WDZ~fHNZҘVf6VKN9Qi|UYW6bLZ (`( R: 1J!qpOP"PZL#J ր# XiDoɸXi48iaa ~W,"C\D)ZPaR~E\+׳WI""ks4D":iOx*#K56('nY^X"Ag(Y2dH#,~7l\_+hM lZy.&;;՟ H凎rLRjn#N=,U3߮:Qj ag`}#|:\).Ph#M~k03zj[9D>A&Eנ0D LL™?@1 玣NBp88Xk ~4&c пB`EAoqG[? Z}!vcB,EhK 8)[ɸu̯ujttV^Kw1MᭋOW~P6.%2T?}pbA+Up1. xX| Rf+kh澧uMfZfZr.ڱ8YY]\ eSӥ%k.iRdz!U#ݖ̋Ob ͱ.۫FU/gď7' fi1ΓDE6I2M57{..NFkE;u oP7]1r<]+7i;dyDxdN=&~=Sve2IB(πXO,p+g|4z+}(4‘Gok.rNdYF̞ɗ]lm^Y|{41crzhmu~qN\yqMcIZ0SŮKh5G>_ ]?{NXaõdAߵV4 q2QA MYLuh\WF2F2ʜ̺(5J3Bdt\s8'+| ^B&!9~~ocz+#G |`pg^|:je<^xg<|LMM'\!ClņF箛=씀 <M$+Y^K荷Y[NfKKY}IåR<0ό7np0҅9N.At& gq-$ɱ4I-B-/oQh$|t.(rHowmY!G N(et4NGu:;ݫ>x |8?юI-?]GkY'N^$d+r ;Y։c1w  0w&C.~3:lǂw4@\~PPI > ./$9B'/&_M> u%Ww>S L@{Lw\LlыڼJ <.zZz[tuLi=6A |su\7.&N\o;qF?=߲M,? yy :'-:5ىӝ*ɒq=R="OvCh˹u9gڲ\'h28x/}?"Bt](E1*P4w{P(4(ޓ~<8}q 8޹s{7ͦY6w nNvW%y3 ׹x!@|F[Oc{?mLh7zJ6牗%" K y0܈:ٳ/;8^cg?7ir~A++Gf+YwZVpyLN#cB9E<"CBb9U]y-IBT'FĘ?wȑG_U=n]իW_q&o{_/Koan{瞋ԟ!ZFR;.,ӯ/=}fэun3>'5FWΟ@ESݐp{]noZK[-5 [mq%bɂv""~b-U5R}GzAp hvn}}X[޲l쮌꧵7\ʉ0}0b' "-FHBAO]n["iV!* B,O;C%dD>\$:MNt-f"ugTɼ: ;ӆ/^Iŋoy^9zrw]W?^WW7^䞏 s{a5x>i0 [7K*!P.(&yɶ z23/h)a\ͮrzd>JQkisf])qegY B|]{aEg<΄C"3xnI r7H#Є y^S'3HHlM´TYK˴L$9r~$2(8qsOR)oCbd (1ɇtgRzT9djh*97'S@ʑ 4/4ۯȐS!xԍTSNJ3R)cPKq05 <Ñ:""SB52/vqh`(<AA{+1 C-({QP,E~[$ȼ00ôJ@pR)aT .DlͲ?/=K -0f4E`j R0yC퀔*`Rjۡ繮О+@) ;#/aKQ[V=q7Rď: Hކ/A"o9@?bbk\ɰOG&j_Ⱥ,w!2qu(JU0N,S*ke饋{{ rlo-EPc:~Ӹ%6N_ FYt, "(#Q%r[J]dۣ͔)˵?0.b$=WmQ2n\ 5$aLSa X߄Q6;IursTF^P~4OqGOP vX24 3 L!Q' Dd6?/<lg+}#[eDp?\$ƭ-fYƍ v{~kA@Fk12ۏ}J {[[[k3g5[[^,Y^OTi!x^nnG&eTp?i44Wlmm,2n}\ yĭs)^LjXlo=rBLp< r{{p-'B.\7\Ċ3ƃ`T_׮x9}gsncFa'ᰂSEQ̇U\h[Wᤘ%,g_LxW]uUp-r !{zǏ0uax>}7"\((Y˵e?sd@LP*<ࢻD\:¹d\sjǩR%ɤfN .ɈuJB-Via2,5/#U66[[[۬e漻xIj}\hIҼzB(|d"`֏#8 -Xq;w Ũ-ڞ{YVSf=a`TB{8CM|=fQkAUfJН7]QVh1yuQe Rz3&sS,$nbـ;J{:tUQJI$q c6skzn6 E-Ҵ{X_kp[=|p`1%km$i$JJsFEQF̞~fnsv^Rs&Re-e[e^t)ӭe\hTƞA2;-M/&Ozs^[FqK)eGh =zQqܪZv 4\}v8Rq)!N] ƈzxRuC8#ߏ0~ݵ֭*ߟ36I.`7KGH01Y]Qv>Ǐ4MA'N"Ra# x)3@yZ-7-DW~m2jz_zQ֥  d[\K{BFiJkk<̠N.zO(ЊR0oO)<➏[}?ms~~J_R"~Z}ANr8#sV:b&l1Wq>Wd*l\9Ť)Z@٪XXf9afJ<$p7GP2'MI}z_Y߄7ʼnL%$KAA">\j:I~Dxd?IfRD/mxbnnu׿ooL&E9͍BwfǚMϟ} d,(\8P%'2#KBM04)NT {Y˴%"_K~?_#?}[\/VUU}?]?9}CR~!)?$̇,'|?9Cx|aiu<c^/Z'De aƚ~yalJ%E5iu 27U5p앯?g:e9)rRU(g)\p)&ê}:ŻUv:eG: ph]oC..T{.`S2vݢ"@!Ack-R0~Ժ.!I$?u}("FNy -#:FkӞy|1FFCOy>q'E Fb0L3 ^r,:q|-u99| /k6~RW7T(At k%nm]xprlH1Fo4F˗9|xR[[CОvƹc xspw \ nO]-*D"Oq< a\l(P@". ԰ ~NnQ6=If~s?quGx$ f;f&gvkEAHdBi*Y[&aP?F w7&}^\ƦvD3y ZͦB66/FVp)G%/ՍEgv2\y8ێwWlJ iņCQ)k6}xd2<(=Г]cu]w;` w/=spv+o/93q89\Or4UG^ϔYhChQ1b!̷WŸ]Vت ]ֻ#x <mj%٫|ѣGrSJԚJ/Д/)Bs꙲,\okJ$p_pfnQ 4PcXk uo-fJ˟(Bc&܆ djfCkjEQC^du1-%H)HGi9^[Rh4&\ǃxLC89MPeoVCddg7K)Ch.QPh<ܓ>!f8CvY,eQdEA]~Udtm<( [L-qMs@Y,/ysYK #ɢ"("&ITʚ~Z7Ph~Dgo]'O,ǼEZ} DSfk(6fB4d?A ,q;R2S|~z[>~pj\+I$C y?AJQ$Dx^;;O:r>|uOjx㢛tR򴊋y9Z"?&iɗrZNE(s7n/T0Uh%{Y' #6xX͆Crg"Id9er&C.|VټFIDpo3fs%^!gU5M*8W,T=avi+C$faKOnc]U3i1-Kr:LL{/'ᗳ7G+Z\MYǀ< _ =ka`l|E4S֊ V<\.Op8XQnK) BI]3"@N10"0QRJzfS41VJ1p!6E৥B-ydH(ŵy/P#åda`)%rc81YpH;x7ۀ ]IgwY+ 9nlol]H42r2"lܰry( ĭD>%3QIǩ@ILpB=AQIS"_\cZ<7P(x(F7bchgsnqtpY|l0?#ݹ|:ٹxqw }qcc{yG}]~[G9뮙tjΚsڹyq7w4MLzW0OM  $Cyk. ~b(A1*HT& m[=ɟA]eZ+X=~R0y1TH1 -2A`\9s 1J 61S^l-`Ƿ@B` e#P!?hJ~Я_! !!/&'O&D73g QM׍; {/RLB m>R0~\T^;ht:Mw9O;wDKQPv"O`:9Wr2dk%Ϫ.=D@HyGJ B] R*i2eT0j4q5JRG2fS{d7J 1;QFBk k6`4Q5 WS)ŨBi5:.$|J>zy'_o5P_rn"X-RJ "Txocj\v7oxC$h.>ae[Aq܉5aS797yҢ-u." Iű"K(m(_q&nC6#WW>`W0>"A{6:]JViJNS~[Y4^Xe9smqU!G.uhz4R&=$s0@19DCF~םcAZV;pRࠩ#ɳl|dX&סּ?lQ߈8mDgmYwG"Zc#Jجd֬ 4 >^ ZA$߷E S.$3`k`JsHԘNX&kkx >;72X·].<`Zżu,&Edy_,%U=sLu5[f+xni@!f?~r/ja>3d ήo(=zYӾ)mo,ü-pge8:/rr~31[VRL'J-5bR%WeE ŭr2V`XI  6Q0)W996NЊm*f=ue6i'rߏf x%u|}]6!15fU2Ìi $J~ (E/֩A?JyºQJ-'d%11rFY߷5i @ [Fn> eF a턉A Bu.E%iPGO2]@eRULɮ[ٍ :Άeg8mOYU·c(r.*r$erZ)a'EQEiZ`jU\ۊpVyPKgZb1=O3!$ ,Tx P}` ؞ J;;;8뺜_0dnop g×!oyz^I:9{ 9رcnXFB9){'>ՔRB(p$ tUUpwA"H4>D5K"W"yXK~kVjxn\.\k_<doΛ7| ;_ykt Ym&;o~> GϦ !g/mU{ !5 D(/  Tѝ $Z#`SO=]"*Zpgdk$O0vЈR!|ׁ-;A2g_l &2QaZ0({kcY(;Iohys5߷dgo2 CNaa52[[ _߰,) <^^\ BB!</D:% I%ZikAlOW04 Q! O(/REu:#qݙkLYfsvԯԠ1u*7Vk놣Ngn{}Y(2DBeM™>`?s0u"ǿQ8\8!Į GUGtB᠈Ʊ8oƍFm.8wM.Ѹ:j+[5Lxr=?6Bgщ.Y&M_Cr9#N8UV$ьTk~뺴K;ie>8:50Ciڥ<vmAo1 >Xh0n4nU8f'I:cn*^RV5!Cl޶sQJna-jzí(h1,aR60mXV)} 2q|Rq8#B-ks@ Vt!'7a|p4 d^0߂0|az3;Ga]fYEs}ey_d,Q00ɽA)kx_{Rd0NZP* JAղAReH.[̂Uo4]'meU8(ΎV !([%PuA.}}#6b,X8LQ' 2"~!2 `QN3 cI┡^O'=5WyOIht k0`BF. *4a2<1ò0, qS4#KVDNipNq퇿nOLTƟ"n"}J! !l,-3 p>ÈZ|.Kp ƘP_t PHK3Kl7*3 fiʑ#+MmC޿ve}n{9E<^?S/+9` cgqsPUB8$ͧ_{;=.nwivZ -3ȍĎ$:pPPGwMVl;j߰cd{Yg ֿSz 80 ^ ×I=<\1ބ"T00> I`K0CcۀIJ1O|Q8p1 ؗQ0|ⓐ|O:KBi{\H~ EDcAKzݘуHH$zeIlND#= QA>%{Kq >ҧ⸠H@"NC;aMmuغ/YHn]ȅQ2^$Cٹ@$i"楆?ᘘwWyV¬Y#_eJDJȳ!eB_J݊)Sᡵ/1Ε)gZVVcu HTHђ %3b9?.֙"Bz\jBH\pkA~ieTjƙEվJfQd }~󷚒 #k £4}@KiM4,dwYJ0Ե<6J1P|2o@Pۛn1MWzytPH >>_R&?Ov;w^"(*c(vyR?p! ς' g k`z@ѲSaDiTm ¨2y+!6)bUZ"iQ$F~(@fGJ%Xd%1uJ]Qr,vyILD{ca40$<'Azq0 MWVr40T.٣MTlȨ8g/8L}h9^EM9W"obw]oy_|tvz. @ƮK,X,f}K^~ @wu8yg|c?HڄB77 Ts$AP]wԋŽ4!Y}^ F!Șg  MtOhD1>_fD3Dd @o~SSSYT.z$^lr)1.*pp*ߢ+ %XeugʜR X`c9pd@1lV:Z5V9sIT3qݔ>{}`vvڋKw2f/ۓ8پ-I0Nm0ە={>u}رc{4{l .&r#'1F*j$>Rj$8Jp`?.$ʮ30uH*]-yKZ N:m&V5ݞ\u'jVʕ .!\6|jD["cAa:fENj=!QIW3N\Vy6"#& rAng^1I'D<e\ ,Һhn^hGRp||u i%d|p-48pMܒ9ˆ J^[-k^7Yn6\K)x.pzK{6yvQh8$Nߩb(;v>|9$` qfEWI^ d;)rRs ɤ*"QtklW`!*,p0$:ZUTzf;4 U<ఝZhtv565M ݙs|V@i`VO& wg4|':6!a!9pMA\C7G(r8lE -CHA8-p8wOEgp}֢Ep c8اyŻ|wR @}A6(3f8mⱷ8\n},~Fள_O~oeAęcRq̝^= 'ZI;:Ҙ5>dY_4'^9E/79 u#G X22|/vH|sNwFG G _V{; ȥ5P-_oρ$#wlRL"\Ƌd9-rŲ\ Iy+d ct9-'i1]NE1] Y9)Xr,rQLpE9C&f ~ZDp~PƎj+1@șPr:U,D@*BƭL]sMK !?0OҬ]&b d0ANqܺ4۳DZɳEu(wwǾ͢Τ9g\Be!<ϓ5 3$7"Km\zvi_Npp sZUQ]h^WjP>($NOz`0Q9-ѩih3!mQYXC!ÀV$#m@Cӡ$R^W k\]\WpVzQܦmvANUݻo9L^n,?j_rΆ nNǠ7,&8k ZlP)B\D^-E+ $ϑ+  .Zm@(0Mnۺ)p2)jRRȢ{ȞթS)dZfT,ZM+JZAh#1.nUJ` Hqˆ"N9"RiĩjAnh5vۣpݵNe^^Z HA"Q?3J8Xln]}fmMT}}Onu 1Z7Ʈ4⨖jY4FĉbG`̵8WN8c97d3.+r}pyov&lMru~1'],ZBDN{F3^$&-,09W]ծ_, HJSd׾:US_HNj́f<2%8~}{pكSxd7ywu]:N)^5gZp14| *X4ᖁtDEhH5*Qo{wog7e-0TY)D'TF[ Zo~n /C$@2N/" zrG$Nߗa(5j鼚1|<<;5;Z ݬ csIAw2cV$B 8u˪YZRl+U=~pq7zi $ر:vBYz^ Z  0aQ 9$m6THh?4eQlm!nmQQ>rY O릉RX$u<7-!qhȲb ֭a:: ׿Ont8X.)De%1SކY7vrj/T` ]S=q8,V걙ia45'Je] OvN »BO$D!0971ffa|1Qֶ~exmRsZ-tiB!t\. xFj1b \d[{5e$ 5Lũ ɦ,/c 0LN¸25S`<ͥQ߻5,4¶;99Kb\vdnu yu[7'ZGUk 'iem \:SDk>1` 1HKcjs7޹I?9ȑ#wM|;?{OwuƔީqk^ށ>ɘB#0-[~Cq 'VmR0t66z|G(t^y|[0B軏ci[۶im35Dp`h!8Q@1d24LhmY6 OM7m3MIThRaqHxv6 ap,\مƦ9UQ9gY1 "b.B/ ^>a&,eYtgyAq/0O lCHFFٮ[TWMxf|B 6cn-b?y%0l ;da-@=cB8 X媋}yyyii;/|{᳟-|~?=O/GiTE;/U!PI7 #&Rfa%ٴ˹•O[pÄngVKpڣOa;5}拡σ6Y{`NATϳLގ0c8݌|=oZc-9b0t"{h*|ѪU_G!U_F,ڀDARF1I$YDKk 4f$I]m95M05V>fv*Ul޻{۶gio!4/JSOg^tTj/}'W Yk2xV7!M=]qrgqٽRwzyd0S+++rK+_{J$$N$ŒM(&O(S#$ya:؂ᝊƝ`Li6N-YQV$;>y_z1>-O40iڜcFO~4bt&UXx7Q=7:@KaԬ{V}F)i4߳qbǶ,DZYv0vf˩ӍFd4&[?я~_-$Ӕ$ժqbT-n?=l*Eh!?sG[.tVЕg|Gr0*"j[ڭ|O)$ c櫊3&(UQ]17w90ppx_Wr`aaχoj(jGq'v`oeaj&*j?P!~)abzwNifSvq^|~d&o)$Ѩ0v%OQ$o(l;!oek.b2D^[ksHNg*S6N";0E]]U`VU D*"C׉_Vϩ9)c휄T8j6ɭ'%=>Eͮq$=/k5K!0].)YV/K{/8e9ٍ T[8_H%i$ 9t|w{& 4: W´9 RDkBkIx'H3![(LU@G0}$ Jʼi<}cf1*BUP P 1Xg)B2hF*B)0 +nrG{QSJ_A:Q'm`nuQdKjLF TRQk' 8fOA A2AzD eR 9R0 ( N˅HGG53럁оW AyBnp'iqm cza0i|hW * g%cUY$guo)n (4\*y5MfrZwm6 1-'`Z4kvېO]ӈ8nxF)SN1RcDžtm[W ikRŨfBR[UaEKʩ",%*YHah Sz@]ͦw'8% "3";"H(!FJx'ed!qi9/F""E,6G(H1F0\&D.Ɵ k$GKE6j(I(4`׻ 2sJtSC3t^(0E1 ň} e0YR'˺O1$j9= )ʞBh$f؎BBNO"F 33`I plBAYlYEw8,N'i{)㙙$%ٸ=I( /9f#aX/(A=I:un$c%FGF@F( 0SuR=o^ֿ$"׿~D׿ \.G(,t27 +lXY>7HI,>qjv^*zWڎAVɲO( "/tө?~?eʁɅ~aj~mGn#IW ՟vnaCYWfp4*e[I˰C #@W+k'N Ylq3^n3W.K@T}Ҭh(bRE4]Me/>z(t x5}CsvD"wXGqR_N=DcrxK^~zX)ZA4 rAG\y>O;cq 0thV DNI%9t: dNiGpc~qx*G/&/%q5Q%ruיr$~#d28(|>oq<7&ylj_7؜g|.R..K(v3$ KTYEk ^dXsE1) (an |pfggԻ>pPv/G nwQLk[]qzza躈|c}p%~A{;JJ_d2pt+vs<).F`*d HA^&):ŎiMSZ5!8/%}ԷEH F(f? AKQR!%!(8b@^k!vG`,&o슰'o3br5iSokNyU4yV1k@5et}kkŅpnOWŪ'͡Pl&tڋ n1%C,D"*|vZ3T%:1rBKi8RSY ws!(`*gBi=I](!-:Cϫ@e 9H@ւR2:R &"V Dc`|k}Ѭu#$#B+97 c1gRLA@D-!zOUiӣEJ22\xZluTapQLQ5j¬V܍^>$.cf Ah^ G ,I]Kܫ+p WK"2#w' A6/yEL'Ŭy񗠘ouPHΞ] h#k; i ̠@O gwAXh6m#Pɱc'GSuD'O9O*Ֆ׬ 5)rcEmj.E#Y~Z=O;_|h?T0 )D0)& fY#pX˴Gܪ]ז/dKSeV耫K8t+0&U[vOg2Ӳ_NITLQS2>"&=FR]/u;@6RyO 9h2Pƅ`Jl(RpF -!{VI)-6G8T׿moԩSo{yT\ zFSɓi$8/뮻xKEmo{E p@TJP!AF r/*`ƴO5(^r4KJpW8/t8d< rPr%D Y>UC}XN22J#΀)@NNN A((H$2ύ6m(7~7:I!DR y裠J*3Mƴ^Ø${ I-( ӤH @*+qVkH`wux/&(=I`kPe3.&o}ŤmN*5-IRpy6] ӱ!:<<<\l pH볬(&DM̵EtbX4c#,%/RbtbɗP\{Xk6+cm1q3PX,]@p֊3$`ħƾt6kPDHۙqnϭq"n6<'Nt;dž/q;/g7Ysuζo*7Ͽ<C#@{Om+q{߮|CNҝyq4OUORdqȪO5BBX-YE2*'r\qQLoT02EW014n`Z+Ր|FW"\ͥ]1ym tuAl(3B @mZ ot]i| ktlny#Zi9^aWyZ$@6!zr@cDzPnlkTKdרȹƸk,0nh/hJPBZ-j]Ɓ:]+k凨kV@w=h0:NVzSr]ӭl_Ae(S`@J†q.Iz 4}"+^C!KZ$w=xdѽ^7Cʳ/s{Ynr֙>С@Yo/z8+)r6*dRPJĆ#KDYG%*!LpC=O&llb{<}FaO,Asp*f~j`<[Y gR&f/&4zڎ㮆$NbJ{2{Z}4kՙu.Oeܢ쪱*2L1 leaiNd]ILoӬ){&URho&2 i6[M>BlZQJI.d(FC'bxDO|jQJzCpJtkFq]M:N 8MP~oL R)J8|UdB a΂ҞORdRKCp @[ԸУ*n䝕Mh`,I 5Ȳ gV"I3GG᫇GC9Gda|j:q1O a2BlήD8q]DWV)_ R q_s :Vk ( a;~^j~ؾeF.Fz"=H+%ÌSaax @#ZߓFi+W/vryΏuXQJRU)JQq~#[*+QjH(ڢؔ츪  (~IVBHV啨ŢU;Qڨ!Jq2ߡj_DRQL;B=jC[?!C!ȁպnﾯZ-KǴEō n%8*社\Cj]߶l6U+ D&1Rb9I)0tMk]ݜ6nZ@̣=7n6 pǴE6|Z}H}.(ȋ+rqaAPV[ 6˞W⍷DW㫃h45$!ZI.c~0&$}vlK| yDҀ!tdZ ǎe{25a_=OuOZ=B\;xno1lf TJB=TiR9I8k-"8Fny +*V`AU& V)qHKgI$+˷xۺ sCQrp\k3u A9&htM oٟ1:*:DԳjJ"BGN}| u)Uܘ$VOj0jמg>p!"t'IA2ԨϾOx83^p5gjFVUڌr^.ܺ9/z=7ܻxպ盽vgfa~U z?%29u?woR /ח~u+;meq,Y9&d8\U({p\7zɍp^U[m M7[wz}|3]Soԩ jV_vYis!q.iTw:'#d3:WʳHUk99^8+xU R@hYSתOHW{_5 {x=Yxqz.V.Ϡ8< q9wt$<ž=pOnui0rGUW\Mξs_Bw>I1) ~'B2*\,H@4aM\K]nyYQDwOs:4弁TQbOn*Vq/Berb>Fxv1(u7|sp(A99^ܧ~TmdiK x.&[5H #gQ"1DbLl$ Hd! HppD7<\@hEE}G%Z*xl$(Ν;s7fo{BS&۪وhR- d)F(*J6Z;h"q Vqs=ZYPU r)Sw;|RB-.` 8dt=5F%h2ִ0JZ J#Θ7I1J)`J} @@%RM!jԵ=Go;a47ҨLLRn@Ї,DJ{;89$g@ف4s_W&YDÿ& l o R-VEnm T䀶M1Kܛ(VsbrU,^ǭ<(`W0(jFc׍jR$~Rfc}nqlG&e#)Ӵh|_TK$$tC膆,]ҟ@9ڊҔR6$0 v̀Fvש=+hE$w-cy<&vkZ @Գ,2zt_\gvtr>T,C|eJqU>?[b>> ABO||^f$]k >ylUL E@!u" DGQGe^JPV's_  i$.CΔ1Z>E|mqoX)L_O08BQ!dHEq(õqKM3m jD}0OHfY%ݶTObc@ )!@琤y8$A@^H P.# _P~#j`ΐv#5:y}v*''LQij ̕r|cO}9$$}xܸ;v]/t=.օ\=ZP9k4:ϯ4^rf[ ]5߇N{k߯PLҬyMtR\p'܀_r9q 'TIEɯ\r(nG')grR|r /(Ϫa9N K-bZR4}|6WOtH[[xiYP.N"@\L ^8 T1ь674frQMDAHq+,,XB[I,(ʈqxRǃZrUX h.M 9,2Y>9cv 2=syV%@QaD Z@I寢^j*}{ET<h |r=aG(4,P{B?mE$تmu3L@Ԯxy||V,> "gy2_R"$E{&N.9 ř3B8{I,̍ `E5^  c~_|~{9Ӏnfy@>|h8nXc7r0 )seηV8 %v)I,⍘ \mYk| `])9+x8 }|~AƉO`j<̜+=]i228yp;»w~xD~/ƃ{;zozӛVrҷ9>{?ouss^o sEwwΉk LM1$@_Tx`"q?=8ӧOԯ%Hm$liqcZ{/~խGfLIidq{xرcHD2li/kk 9(Ei:cdegZɳ/_ bX4Kc% 5jf:cg x=y=^V"'q2-uoׂu3TRvk9IRgtoc3DCy\vdQzv7jOsd7H A@Zw:c'w#5&ȣi9[yKgFixN+]<+aTp Z#.R$H[ Ii2 ad{w(n$|4EOQbBx뭖r&pv;/N .06[ c_yx"L^'u,eY |I)SZVkz?jҩ75?I)^E rD0z_=%^Ο< O_ `l1t^p.lo#?rӪj79 JN# D\fYtjLyL(u"8ν}W]u R7Hg><'B՜Q"&yv?s?O-Ώ1շsq)(G74~o /8{-.pdY˟tw'/_j4K.^ҥƥKɥK.5.} UrҥTþQNULQ}{B\~I8(pwy'.>:GDgpqQw z1cv$u <;|¼-c.zxW Etloo,c=x}ǡa w'x^KJ"% $*:+ y,M2)|&iR&e6fsf~N$̀'4!TSC nٰ&e^frf?f2'vZfyRNi'eVNӬRv^>gl>i~:r,eͮ]Mgj x1\TjZME5lfr:_T9 M:-^-l(W\-\TlYj1=l\UjZN b9:؇_, ʪ.Xwt9]&rj zXxOX4NxnjU>/K`.4֛Uqi]X4x&2J3@^eŌyP?QEѨ- ARRz=JsC^w>3lpX6`@?5^]S Z7hFB AZ 9PP΅@2ooYhFqLs^)FOބe+F}C:9̷{ah9_j4avta0טu𦓇Pk;Jkݾ.xءF?p]Iz@JwAˤlA+v1Kũ@hpU1c&Mijv#]"/&(/(ˉ/6L-.ɶ*bQ4 A7@4w1kF)$Inqd@y.*?}z>Ev~OVF;j cvGz:L+9,IB|ߏ~GDBIA&I;Aa]ljr .;[N<<fnk|./w''Nʲ8S Ws yiХ]"Ϊ+ M]=%~y.bˋtW%Yڢ^xE#RLBuTp| :~*?.Lv.Ӱ$ =\~5'9gA'C>3S8ӫ:-HL£e^oDxeQVhRIwL"f,-?PW2G K* ⒪,Cv۹/V ]'^emWNDaS_-DZ29pyv&<&`+ӬvcF[ @Q>y@? lJ\^JOin;D3U` ̷.RZ BڀfƮ(# OidnahC֦ւ`x+3*k}J e@bP=AN67VTdF͌) FXe1*iŐPB"p%eG(tj)ҩp7#)^F/2c7ьx<$0<Њ3B0&J! sTe@ňq#5zVQIʌpFx&X 42EA}XK幮>t8A@ø`\"ADrfX -eRJ-DjTB@)Vk)30.%Ed]@`[-$ ?G=J ZAr -J%`g#RA5A ܵeZ[i!Rpp@ZS@! J ʬg-P* j-qpi}?@D߷0E"=aM,Z @&I6eNS&3:`PX>Kɔ !#&)'~RO8 r!%pbȜӰY.hf:Z5*H6{8bu97 <$2k\;1k]gqH Rg1gr'BǩrE|gYU%Dgyk VU#Ii|M$n&.-ЯR5Ţ,y1)4U>+Մ9R\/4.LfP%[r%C|N燛2@^~EsƠ,wQWK,E9SUyBB`V.J0B.GSB2&%DtROPeXM)(fYҤpPLSP9AA( @ȥRvJ#Gc( r!MB:M BMig8lo~q"Ny`ex".eox 9h)>"}䶅M]C"hXI 9 aTP8G(tTEP䮐\3 Q(%H(WZ9%@P/hƩ"plP)*{JY9[)mt;>DGxhU|Ԗ肺 5!2B8tydXr&YQӄ$=oŀ89᥯Q)W3V "@o?)9*| "SH{f~;i[IIVѱ%5rJ}xk}iER )^bʹR\)hb:Jqd$ȘrN .EVJ@`vw8jY_ <PdtpFm4L#F'\vcR!s-r&: )CEv[ ez/e9 OU(K pku&Cz]XaȲ^Q6jy;zݩT|j}V!Z_K\3S͠B֯ .K4`U媵RkLXkYngs$48.ZN{yema{|ߌ346q>kx7 ,81^;ɲHxxǝ}j'2W9omz8ɳ$:ŒL;ęn|PK{0+;rH1ukP&gqZ^6d%Ͳ4ErxH^3c8$kU[hkbknV~9&x)N˃5&(Vk$#ԗXRS@g4Vg)!JDuz@礼xGpUt\q{ r\>)FBR5(8oQ& k"XHlmnn2tC^}%S5J\w.4c M(}@A*)wgikZAV+_yBAF%r ^wBq|?/;:sA6`n;ax7| > ^Ez:Y P\RIu1KToeU.I$+!n>Ȳ:qB#FT<Bx#nÔ:2Ud0t!GO|(T_>i] Ҡp&bA9tKP\Fs[$⎁wO?UN 'xjM\Z3e#q]$fJyR[`OM!GX4`$AA}HTi$ PDR}:m.(JK΀w y4!0Fy@pNEag$ĺƄqRJ*e굼=!!PtDڤl8YichEF A$L*#@q`9{ drg/0[MBAV/2ܘd[KrZz< Vlt ЪL >i%G溞f\jLT956cn2"M%ZIF f[M#&%\,F-0qY Ժ^oQ\*]JCqFFF5j*MZ N(BA}P QB83~(b^4-@#Q1<9A(hY CU%(56+$q 8CfXGq&-Nf]6{zʗJ$ y6 7qj%pJI\:eaB $iIq!!6 `θz@B<fF!0$ oB`OT$+n8K%4\m(T9gj#B\ͅQR0yRMRFQq(J %# E)5R"SJ*"4(mr*du%[mߺ`%1X R!ѮKK $[W~7g*4^ Wl{Hެ`M"̣"*(מ}N[L x퉳'F#NS쏧 \i-+L"LU+.u# ^Qat0G!6fr~l}6aF[Rwi.eiVhX<;sW ʣJ+A9m `4F*m$v-@~Ut 4knFR*x^"4캝Yf?qG{q/=B - /J(yY+bmϯ7=s kkkk7}ݷvry8lcY]72Y4~ŵ.o4jZ?e/{1/{*bɅ)OEӀ8A]FQlˢL?87z'x$0SQ.^E8+NU} le\v;8w9O5E( S<)&F;ٮt¹s1'3(m9zf"e|qJ#)5 s:\.H"[୵ 3T)JtA@,|׆hZF`mh]C<:eJHi妉Q[hȹinϚ:<LdY6&  r'8k8߶4)E+pw/˾)98Ew( wPS89Irhg \ei0'^_TrQFnlu 2-|k󃃙e][[ѫ>zj6Z0NPr6RBq2Kb fFFNNy}}}Fsdg<,?|gZvپӲ{Ďdu%t]֥"5qiq8 UJEm^g Ǩٯ {\%H1࠱)PE::zV(]B>䳄|Yj .R4?ǟ)$\in˺X 7cM@B}:-:#>o(!_gQL̼@7SmkcL+)AȘ"SG:*R1e48@ϑNp*F%:v\3X dΎJJG֝18sE᳗ƃ/]t=}ҥg/_|zO\|rww/=ݻt|9Ýt~c)<_K3NYqfeJ=Ii9gK(2a z.O$9uyJr3eI-J=>y8Ygw},m4%IA h@8r0h|z~Ƅ1n߅YZ X ƞLR r'LBlh( xw!(<;zhqFрjc3 `qh`8m4qcFsQ2j4jiZi.`S1 T]h.@X2mi_vW:uP\6֞G &w}o6՚+W| sfޛe?yœЂ]8U,3,JNwr PE[مh@K\7nWŖr魪,t{*6!_Z/e1∤}{[[Vք>x{RZ+ؿ.x j[n9)? Bl!2yט| (7N~#9brqEsu3ȷ޿ES+^#Qt:.+(jnՔl9;Nn,Ƙd{e~)GϹP^+ltBR~[c({R$-jE-N ɼh_R5WNr>x7hf Z[Z)E&)hA0LYQ>HayKS-JAihaj6!(ǎg<`H5Io8Jj(Z q, (fLln0 IL@g- ufPOSCO^ _Dbyx0௰?}:٨r=|7H^LfR=z8qbVRǽa֊}1t դqU X}o/?v]G'i̍c8d\|r8om/^og2ƱkG.<~b<+C]ʞ2fFM\恐4һA9('C9{ @Qn"+B\>h(69ִ쑳J}Q#KAI pb=X Bj` SW_~|1ᐦ5-M/V(rg! K8(Obl>ME6,>dPNf*E8%0؏ɤײ.ck5یhF;Z )'õ ~_#~0]PA)j%i8(sŀFQkm6rК㱧 .^w0q>Dֺ@aI&&3^1hg60qdu Њ} 8 bL>YJS*F^(2קP#X1ӯ7Q*ѫ, m9D~ ILf]^#*Sb@"t 4FZoB"Ju͔<"F%`D$nXF)˹!HSԌ)@O2K.HC(J" +~,_G9eY1KXa4l<1t-An .oU~_#1A=2YJMFz :|f D!~CsH {B\svW+JG2v$}W 1] ,,8rx1팝msqȋ\J.x$_N+6u=󂔺ɴtPg{=wwVp<zזE? }^-N _/(ܨڐ-?DkAw?OpWU/_W;Pǹ5TKWJi4 h%p˩IӼ2ڹUUi /'=:ȦG <[#W/V{o {8R2-!Fb/5߇i+N RA]7[|{{ suZ[i+]QzsK*ǚAb>k&/K Vi X~ 3z)ftO 񙽽=-ĂG OCGR@^[(%mH?!x*QDOkgKSʽ|FdD?T$њ3g1bB~7#g&i$RFKJ .%iD\JjGB+S|!Ef, AYΨV%UR%q\ߚ C.sDU:F';w_zqXP#/TEc,!EնMg˗WEɾ] #%Z($SFR-Ul/u/ `x9Y~#Zp.wvpf-#J ,FpBh<FE~ATu,9Ӛ?9W3Ƶf*JBtf(&5bUl:5`CN],@ fOݧNlQƎ[[J7Grss!N?|| =F͆ԯ!*"[E D!{^9ZY;uZ;=+88vjKgJu$^aݐueۡ+]?|wU2^\rhoߙ>F1>9?꺟^so2q0tcD>,6s Ҵe3z^8R Z"MӔdL$cvlvYSki?^ݺњǏ_89s][0)GVk,Zyp [(E uQԮ)\]6^9?g߱?>^,˶8p{>݈G<`98eLEl4@bg`1 ElX BBkYqw G'cbrb2/NS5`V.Ŗ/|/`<"uCb8nAJ6õV[[04o,<7(u5v؂om:}HLb/c:SQIG"gSb`qUTɛ'֤sԩ7˲Xϟ_Ng6?&p6;x-fR_eκ"/L|:Rp{{vl;^FQVosq{[}ej`~ Y|Q>EvF~MjWUxj"p<㪂Ho9G);sO Wʵ_/BDqoD`4Mus5}o-Ͳy"0id]=kvc>w'R0N"I2?B+4-Ts!|3JÍD`7+֬1!2Bu %gy Q>m,i ί Vb &gH43*`.rO/\B|?ۂc9ӿ뿎%9 !+G_cՌ}/c.>_>2Vp+u;8:O'Gҹy?[eBtg«G,sn+6(S<)ͮZ%O*xQaԨG!,+_DZCyzӲ׃0jPBI#R(JP*4, z4QF5~Dq;AǦzBIaFFQK)!,3>+ٕ+30[kDls $' 1QqB֬id-[H"N:]LR8_q֢yN-/ڋXQDžj5SodiJׄg P]!D.NHd$ *Qv;|dI~b2`rz&"(9gtGʴx(-)%Ryf13d"G u=%(@ڄ^2ED/\RØ1.RQP-" ymɞvR"C3Rm(uQã\!<YMKXPTGJ <!8S# ~:IȒ0IXœH H.mTh1ΖsH8rMtJεnʥcd jHqbS` rսT /S/\v8Py`e%EDvḎ_:wUJYXػ1X9yp澽L"k7wGΗ7_hS:i[!]ZguKNhZx5swjJ.zO~${pl[prYqMuη;os>|-P00ϩ+ xu[ӣ)B h%݈+SHmP&TL  64Ü^ V5TΓu~*Br++yx=d`!v s[3?~,Fs{ǤZR(jY{CW0{=A F!ĺh}Pcg,GvPmL#~g9xO8 iV]A臬76D\6B|o+RF{?;㭏[nnL$F_ۯ;+0jlY(G)EiPUFĨFzkZOw>3 ITRxW;ξ ?Guo:| =&-ʶl$B#u8gzuV Cɇmm /qe~&y^yiEY.e'|iD{)>2(bHl&].$ޖጻ?yOX'z]8՚/Ỷ$/M{c,:s6 %71<DJ2 ""^@& ˑg\] OFPScdc~tU{AU:UUolt:ٱoCOr> J;2V7&ђ~P7rܔ &dir;~m~PF$lk e^zQRB9cĝ0q5V(Ht1k"D”(ZreX!BYT9]$F8H94!LszJE6~AW&y>4:SΟ8Lo\6V2^p]V[a9xʽPpAkzj0,ã|p@q"SLi,ZL݋t]Y[g<yG;9 Q@ZJIHzK=ODqX|4Z0MJkE 'c2Fq$8p[Y8 tZH= 3)>PF.E=:Y[5%kʂ N=xDjJ!  X x&ݺR{*_-oI>dg@1=|<:o,q}PtA'9-?pQ2v?ޛwƺ(V{1:nF!S1;  2ʉn RQEEMKA?zkS;;gև_%xWM OADƱ@k}WJ $c8k&ZKҷ`3+'5̲-g0utPK0(83ħZD9AUiβq@Or:F+zi( ȭOtiM~| #>EYIt[85"6NlZ$!\4mRlFfTXnEdEn6^LjŋtQn7lΩ!,q9@=i+axQ@7MSeDʖIiAST2NLM"!6%6ImK$b; Z=B|8 EW+^dN2oO,/v88rWZvy>Ky83WL;SIMyln͇qˇK.5h0fAkв% |!%/誢T^ ^=)ڭVlԏ!F^,KkugI$ь<8ZE.%HtfPFNhB(rv:@m,0" *?nq :*t:,*֝rS)p7 ,^g i1WpykmS%YGpŴ_a높JƤ6mRŅk#RkGRG:0 Up>xǃV7~MVkd :BkuXZaԝ38!"N;H $ԄB,V=J_OC[Q ZPj]kj$66Wj*u5]OK5|N:{ K8sq">OL\Q4{;3Ӝ):R_vlHw0`t~m~z(լHl$rgU;Z=j'JJ1"$ F2JQqƤLxRMi;Ih $Lc^4C=!ք ']D"ix$Fk@4A.k@"Ub[wMkݎmBlM7=ÚW.c%D]Ut5g#"IT G6\JHtA 6u($0FY?$̛338;r"pq#JĂjnr/k}@d/S)=NViH蘐1bFX#zrN<iA{PT8UTOHi: G@""QP̞t@R#@NMq0B@tPȶ(<'~'r?u:\~2DL_LDR1޺ppMaoS}lt?,LϔKT(v "c:s{itBc>Za]l0;4J:,eԚ&5kAR)~8,Gnf-akjr8s7푟}iW=W_3skz`ibw~o6JP!iEv(%^NYjңGwtQw+s\eۜq>|:#09LU5I1n-ڃnKX^T@W!*3AlZz\և$<J`:{.|"V k|cդ{JKd$.f1+Ӥ NMRaQ'i'vfW(@ƶMzc-ZZJ%@?)es-D'I)Mmy5nVegT"I !E-t|I ȓAAjk>4J}_?YFK(Gzѷy<}A#ʴi)Fi. Gvom)cl)!^yJmv:hӦkYz[BzYZĿf$:ZdYau]7Oϥq#q&iI]7qk]u ӗ1@Z7[DJ9Mb#,^8sH*e NrjDp t}p8vKsr)I%! y9d:i^Vc N|?֟J~pO}J$ϐ~ӛn jS^k=q9rg\tn)eX dWܸ*H :Z(\5ځBo8ǪW9IĒ0 8Tz< YXN4ع\ G?Pe$iuR ⣀j5yG>|BS0GM6Q1"IH4A\78|kp=1BƞV5_qAIQQFZ8M {;YY64(°y 76֍uA2uku2 .TmEYl  ®ip Ts^,ik[\aHk`_MD؅kuJ)5^r! (RSܿhxPS/ x-BZ lf0:Gy;(GBPv7ϭkݑ6T6[@{=Ji{R-w '"> =.&V;}Vcb3O9=N`Ck%ZЕb2pKzA`lД ɩ8869O'մ~gNq<NȪr_4}V%l-<#T{RL}E[TS5RPR7NKRFA'G g蹁6r0hYgTJ2D #`%Ňtb*d"ʀq$"X+lGGa@(IF Jڡ5pi ĵfVyQ) AB~ Qk dqDr([b$|I0F<е(<|N< @0Ǹf>mSأHB trȑ.A8H@$RogDn* Ek5]Kt\lśc)mnW_n""ƺZڋ$k'[}$H7T>XSWn&UedHWA$yMɓkq~A%/\WҖ h$']}u][[[g_|0:';ujΎtv^\rܚ]jr΄K-$[EKTAc96;q4x_2xw /ZQ)xlt:\!tb/nnn6w] "L֌Y: ?˲y~J 5~{AxKzQ$^5\vP1HCa2cTT>[!ٳcW)6 ɉ׀^TJY fC^iŘ5kk5Ӄ!d|'` 8 }!ڧ1S"I_&L^_ap͔+.\ڑcd(ZP 4wjznW}lhL5zcX{N+QUC<gby''"np7pTI<>@zNe`CCnL]NB1fnRH:5;.dA1OzF(3xl 5M(iliC9xH.`Z5`?$WQ'j}QG+kj9>0d2k.P$qV\4a($B08i]C 3"E5LJU `^);AO-}( }@^ #V\ JkZGl X)-Bx%7}cO~򝯄 l~n&ppǓO>߾/߬.\/7r=q񄻳 BaL \^8?͍K7S|ǵ뛛mn)NNϹ )YV [Kkd1G%-pķ4x#[=u\ԃFl.yk/V\ZCHS"9'zKH;Z׋utlea/S 뮻 O}ػ1_7ë9<| '^: WB[% K[kYb ArF{2xIoe^w>GDa>-pUQXG_HPXdu@}|0!h|S׏Xky6[EB! )S ~^OA(<ϰVc Xvn# 0Z);u҅!J/F&xU[:[ɋsSxHQyK `jHKTCDqLF-)URJJi-KZUldmzݬB Ұϑ:բ!6oQG~\6xdE'pH>4[m"no=x;~@Qz,%Z};?z6,ޅEs{{Lwtۑ}ZVgM׃ɤ3Ƞd'wa̍. AE)cjѼ1f[pzl^ǿ82a7ټtOeI 菽j8R![ Db?do]W>s齽AsyS[eq,DUyQJ/Kű7FvK ZLq}O>vY%z-U<P`]NP G~l5ޓKpLge#µVe^YKH.M/IUXGP}{?88~&$L` ;f} iKPצܽ磼aα}dw1|1}(g@_ӫuasdRlB!Α3+~/2J#e52Z!4J@)9dOy^1 iFx*GPi3?g@oo̭gq_뻭͜_Ɯʘ.s[r r>Y;?5}s3I^+qOTbHٻK)uܷXX,~a}}Lϼ/|a!S EpWORJT=sc1ݕcTu d()/ӏbko=nԣzKp} 띇:osc1*NAd)NMN6 CU+$"羙J,=UWJ^`;!? UUUclӔhw EVA6nű9tosdzgyٯ<K.ep#Mde/4<˲,%/zы^4Az 0C(ƍ?JkE z=^W{ LQ I: hSӦҪ8̱W~~+{g4DZR'Na&evp,$U( R>+SMvAB͍%'I^Pw՚g<%r!Oe1t1"FJߍ=9w V@\/Ud[k̙֚ aԶO:ȳ6 X>3B|MPC^)"e!HDsQ1{mv]COF`sQ{^:-~;\z5}cCyimKӣw@ Z#%l,4IYi3t^sA+$"J+g /]|9ڱn\`?1J,]E@`B-Z^ްJEkxkO@?IYhp8vfww`ew/bkn7VgeT#{OcƔ P oxy]*'OVn I̯҄׫%yz<<߉#%J~ `5zk%ExXE?/ /&=)xS7|:X[jƣêbP,O,Z kqYeWR &7F !Lk[J"ABҨYU |0&BƑׁ0՟t# ?Ipv|JAJO(F`Mx.h d@gj m80o|eg<|oIۋ8xxPH q36f̈Pu2QpY6z$ɘ i't6%tȽqZ?TLFǏ]p]=]=8) O;ꭉcE U1W!PheRFJ˨P"#W`vvmqK"7x3(!'B/{&FEGR"=%)%$b2$%2CRIx^! L$zۓMⶡB(ۈ:swnwZ¹xa%_=PNg|o-Ye|i" ۟I >6dĆ]SΎ}(!G}y]}v|Ot2['t뱟P_qAf&uo~{S';Q r7 }~CB66^[a^SZjpұX#dn!ccCOi%_0ݩfQjonNoA b[.O@n٣i&ѣ]nKɮ\hq'''_*LeZ"]Ub8=-ŗd)q?+ige[ʦuq8qzqk:bPA sV"el ӵ-ՂZw%`}W+'ش nHRJ@ʔ0ӹs12-[b,wOreD,1MePV\5]^W qVIIj[nyrRR / 3 21E2\";Q3֊;4)ntmePE_}t3>%J2cʔOE?"|Uј|))mAT*Q B bJ ɑ(СHc!rjܵ)Fe9G<ʴD0]` b)u%/DzyNS\ $TEqPBGn9Cy?>'Ζyn|RS&;G}F-ho& c&@9B.e"30)\H I(EDLƔ>'H$"8AlڌcH:Q^ꇔZMqH) H@"1DB)I3F8 `#J$$`K:`.A)qIXYyX0Fq-r`A<zH7^g#AOr4A*LN)H8b 9 OI4bL3!W.J(cBF7̦2JH|Dl8c0ʄ@\kɹR&^"hR@;_,4kqɺ~/1ogO['LgRn,݃VA`22 v`4+SpI.*p#\|#bq~ZLxC c!ErW*?=e s /Ep!g׳jUU3ݐ%2}?jFR0|-anli&`X^*\Lt]B`Ÿ=;gi*H8'E:̓[ MgqnM5Ť9 `mu-!䶶jشsBk[#O1] X9_u6)=zzjƁI'R7u5I(u-k#mX&bZB}^RC$$t RB)%gB+DX^`.3*T^5n >RXIZB(~h-:AwP'@8ibB?y眹V no\j뺜P!Ρ9/ XK0<ϫYU1q.sτLx,=x/wk,)r&X\P$\t# >]paRWuS Áe$stWe\!(l<$Ak%5zRwR&ᅅ$ܺRJim]aQ džg?ZpuE/Qέ+v~0s)-y K̇[\OXgN)ֳI3]#"B<0czڸgn"B L=93DDq')fӎ c/=3F3BQ`qJEL=cMaSΥqWGl֦) acBahV|%bյJ3.(  (5iHjo="+<@QJ8{T_vgzMm>uy[JiVC%+gJybS].32KB!( "6Ae%N#7gwbk ehxBķ]c`; )sJvҍy!椀0@ܾ$vZJٞUk%:rIK(2R~iEYĖ;z+H) db*pG =Z[ˍ~/W:ΚAڋb2tΟ?v:|'W:y}?aSkpx;vOկ7s~9Mġ8i] grxP>L`9ˋ*2-WժZU`ҁDY!-g*R\"*TurY|򐨹)$}*J2):)DlJIeB *cXJi%1$q>ZWL%Dau"g+7^ ɏQDE1eVBJ2A-Z ;Gqۓ$,NAI20ZA$T*N!V ,z>XJY4cdo#4Kt& Eޞ C &JEZ.HR1˜$)huc*Ir?2U 7"NFڤRIsO^\-ˢ,|? Z"q=/)KpXnE7~/Zg~pXV Re_fANj|Bj9~*S(&܂P*m!IՄ~xAd)߱ ahٽS},<Ȟf-GWo77iA#^7}H;׻p\2^}ugy_N/;篝+:~/Mx_K. ݨdv=; iG1VwݹZw'?wX_mAxOOfEjYazՉ}Xtn;R:Pa֘#vajkѿ Ӓ9ym8?3^eY at,3,իGGSx1-u+ߐlj6Bae7/e}y|P{|v_:}.]Zss׋_bv͎#Uk[pyAp\ԫ)^zЃ+ [A4>Bwppb>[$``:9,<jp L>k7Ev@)xLPf<8ڝ?syZh[g5VBQ[KpmvuTqvz]t!U5iQGQ(ϣW z&_gy&Q4:G_'_9õ_ƾ7M 0Qq]/z& `mv恖<\su^<۪fS7)JwJ'U"Qѫ#TPS4P~OL ;yx9xs^v'L*QPg'E]5Q^ljv@lm頟_u/~VUN:wewonP=dp'}#=oL0IQSQ-GUX_x77 Wb S`{?f\7tA^4}^iBdqRW.;-"fAݙrƻoVn(AnF TSk[K+2-e[= 5}|>؃;(ή󬫕VI !rʳ+Y!T%_>4FJ !\k4cKi)cbeZEƚ(K鱸g5U'w,#KHc~'˸,9ͪZ#5$$Y|ZkOǿ4.kה=u\c=D)=x0פ!#`QK_H෾z@x\B[}vWjDP.:&Zݭ;8I՛/ԋjU^hT/SߟNz4Rz2tud"_* (RZYPLI"eS< I, 'čnw߸2/\ooxowɟP *zݨ vl-DkLB "O| *孋:IF |^o?F;Z.CM4l@ +\ujG?~JݬYR]}w~HN9~`ӠDCŹyC7>-I1{adAdp \|Sԋ7\;'3YW^}ݯבuk{i:f0.3t-R6&A$mkyfp!nĤ᪪M/z3q}78ͣG~v'?cnsO?}K.u'kz'?WGN?勵ߞ܂={Qn_}f< bΧ`?\=_wh\ͮ=< j]d nxJl]՞~#R8;\QBM*mS_0T>>HOM >j%,ESh2k5 ҿ͆0פkÇDC`cY\7Ahގ(hiby4|k #d4&23?-b̆] >}k8rm;H*$_N;?_O?5"/cV#!B&^`zs%Xh$e/rx.(Rf)%3a!σ@ BH2%ҭ%X_\rnǣ+n[|L[>4# x Uxass,Gf9g;rSEqC{[>]5^0 Kul*V( `Ogv6AZNƒYx1kUelζ4(8&zY ΍ԑ@ORϷi("< CA{S~sz<Š䓅\Q`` a4QǝQOM~hWO?ј, !RƘ@!zxRYGO$[ؐGAtr³`YzA2>q6bvva{%$18DI,D+?Rಎ+/3Y6lmRuWL'鶒~˳zSb55_滶Z5q&Ȅ]+6SJ6 S\|. Rzݱa + Z뉭*r=k7ڊfrݴțzޭ7o3eQ4 gpqY/F-o|Yl\@gsl=n$rmwdk]WM6[gzV(e+tZ*t*T~kQYK-| +*/T*ۈF}˦NQol2Xm09]Y^zyK ff,W^tՔzSLr+с]Uye.V뼐 2 z-:b]8ki6M~UEljY楐DbLOh29<=v6=8 $Z؎zؚ6#J6)B<$RpvfktBi5u=tqabtA24]7}v{R{nW^OE?b> JNEn.VJL8UB p:: LָoLҡ4M A ɠ(KI[>*˲<1,3ҙR} R ɱ낽kf){vjCh=RPv#"Xi8ߣUTA\=һDR5-C<:%dj؍!@st\&M ٵnd0)!{ԔhՐ @!cBeL@j%Dۙ,&Cԋ'ˑkN5NOaH & q`o~̭%J CN7@ oPYVUIĝ(Dٙu3$;yuo$/x2 VA8 Y)"QeBbI өa < #J+[iRZא4q-WJ} Lx(fwVz A{h8d4t-kRB3A gCWH&,!@ša'*hP@8ORDDy*tBxiL@J2#'i`) J΄O,@HJ+jPDTDFTVXcI?l$(Ѓb]T =aX>a1B~*()̈8[ziS,Y71DeJNS%RRzt0Ȳ~X&DicH_ ( h{JHH%T8N8Γ});ʓ~)\Ńx>oTRMw;,5mI 8^Tn w)}zW(9>)H2eUuv$5ŲUZ͕Li5 wk@ZuaE#Hmq.zіՆ,^h[X qUy]滋.׾Vһ9QlTӻ8á'R yYUl~@|)k+նQ^2O &vSWMc5_Ŷ+8Sl:Ti!3o%^4wF%Uzi|*پ]3 v^ԋ웫y5j~Z !Ȕ!ʕiM[V]5f:BE}Ѻ\\{ YRZ0^s.|Ep3{S(kj0~9VU&1dD45&01 ;+=p'2 %R5: ozL'u@*&6c]^ F\jC'Sd$?rRv"m]c.UUo۵~tx7A`VZJO9:::Ty&0A̩RFHϵ:XZ4W(Q'@}f (mQ]%; B%RA&"c [!X*Rȷ2Z^!#0^ t#ӹf# ( k۩i6pC`:$cX+ pZJVFV &+-\d!4a@@VIiф_T]]UZB.ETG.t:}€nqʕ+zW2k>պF나8@L8I,mTt q %_v;I}ӆm6>iZ<%\T-'DZ yLJW,+LbUJBroZBM)TO30 N*BwdwBtr&?P7pH%`]iު}i^V ԔTe Ӥ؜U@CE1L^ӿ?O>>xɗNᇿnO:'oښ~^3hkįջ$vU.h^&b&$tm AfFrxߌv-9 dz @4f4\ ј4$N^R&a 4h"i!aT$qy0v&X ]zK <}py46"eQLa Kг ~G?O~2 NOTbJY^<P %.xꀀWn*O]@$p:cr rF8 ҂j"^Қr|4fp&Gu"ra^7HoC!30^L1ТJ|먹D4M2T aIJZ@2]& BeL C74nnLC7MH { rկ:08 霩UE q_ȁHC j.z2:E$K=(Y8ζIyEW e!vLT{󎡹?1wg'u+^ct)\%δ 2^_8ݨԧEn3v^E,72~s>d2ɮSΧمqar̲llÓdmmΗ{cs+,Np8Q2sήmΗ{G,,dP {yV `0O{WF#s\;_"|5B7WIZN9\pl1 ](aLz&axrtѬj5i ( axԪRGTj5g=v-K[L5Kg+nR }Mek-I!]$隱k-Ju+ûVv=^ފ>~`hS-ޜaAd,_ǹm Gl G4v[V lO"פEd3ELp?{3Ulp]`jmf^ycvDY 6 eԻϽp;M+Ovc]GZe͵P 9LSƧUhB 猕eY2Jc1lBUJSiҔZJife)B‹?=|6UzICjwH#V\(^րYQh[VEe[q 0@<$ir`^EG %4'O膭+ `&+/?mM0t G1ײ;0(0XV l\e BLDF DaD!`#?O!C "F)T`4sacQ)GP0KsXa+:Es>#mݰXI@zgk5B:3/7"f7`_Z-讧T 0zCe&M3Tve'&Rˤ}W^yCDQ8xEA`>2sQ^*WhsCI7- Bm2l5 7 8Ţ2 \ X^]=iie(,u=঍_ax\ݭg)N<|m$6,uBC?S[) iz( OπQ"bE|TMM qrM,K<&kCLFqk渚 ~๵l8ok$f "D'-wsٹN^4hMF}RlB ڒe)V>-s t,F*|Y/\x] q xaC/FIJ;TjA mp'3k^z$كPMIM{88C>$ݫl'mg;(! F6m'\x0>ei3cKścDz(!n8 \V ǖјՓ iM)_K(\Xh)˲,sU2 ۴qO 'lRxa< qEYVXR~:!j2u}Lx^(Pː^t^]dMqʶIa ڄ^^asU6v@*1}_|sD&UU˒9e!Ca1IΩ #KE & G5D~'1)l~BM9ڪokMΛ7ƌgf#Ψ mB+v23\vFζM1t\USZ?wǎZ;Nbz~b \SkڛsG_w[h`cN=Zjo;w:/G1VK3=Xpܲс$jG2DE.9G,\˒vOHU7\h/{Uh)zX3cϯ&FÍxm=cQLj@  ;.Bp ?c6^Х}p#C3:ϓVsT @ \Zq if~I ]+?_v|yA ~~  a\YbO1UѳEEF)aD~`\ "B.yn' 25tG @&-Q"ѰY Lf\LWU2"*>OS.jPՊ|:3¸lq/V[ `vqjx6!i1Y d|UdtULܡphH8OȠ-E*jUb|9r\YJG:@KA I龔GЁ ރlէi')eTJ2,zhi(H80(x]!P!eIN8͵jXennk e$ϓD fgG0J$jJ(8VstPN *81 KR Lflդq =?{CDWm͈G@*a!ra52.G0 @O|Tˠ8Oiv?%L "<*CQA1)@RR2Tz{^okdXDY$)F[Xa# xt'@nbcjfKs;a3JBGg&wq5#ȹ-g9|c''c8g2CSeZvRsJN88h6:u0xf$f'zQ$|MhU>#Ozk>@2])D0 'l~_?'|!>(clg4\!@^f ^;P8i:=ÃN9rYR:J77][3B4"A0ڎNϠu1B2:a) x[#Lֵ[P ;h$R Pz %D{K`V0Ǘ +I 06AԃDM G>姘1|_Jb1^ uJl0kݭtߟ[A`L>a{ FpX".@љ7}s& эkۭS4U50K1xf@)u$Z#"~@wV),[Cg)lZԶ[hkm\=4&OKIlɎv N.qGa톫Aoo7cd lIC `fm YyHE}? A8CqY܇wp8I1,r^cŦKC W"˒sH.djzؘoB_;+̸p"~.ߧyDZqгlXK.F5)kߓA3|$(z PL!wQ-l}G$5["/Vf^1΋yEO_⫝̸J!".绻C8s3=Qr~W+y }=܃x!+:uRǁsh[[hnɫB1Za,ҵn> bZ؄K{_$$i"Ť< 4݆szKBU25RQݖR ^p Q>-mT칠U&V`kb9>w]v i$lrD=FEc!/tۍGjc٩+s׋uIкjPuvpj8Ȅє8IWRP2yS2Bx}f3I?g&cjrg=|(sԩWmp$Da:I)n*]7j#P򝓈tN1^\-tdQ!^yx^^y>xnD,*76^T& 䂿yW_FȄn:֭5֖g!S7y/a͍0GT i4E7lrB7iڰ}~F/󔾳ݎ'XBgJA{*=J]n5 jqͶuwCbP@$W6^匜s~痝o368<c:N5jʫ,', d6aO_-NpmȆVadįQ+V,1D.$l`Ț I&B$MYZV\$4l>ij>|5e iWTaReG=^VK̪ղ(Aꆐ.QtRDYSb ń:$Oվi[|Yᴄ!4\붐>ϖIeFD20D@,˩;~П<-3W̫\A2b`Ѕ_Y_d 7xUzt^NĿ6 B"1F6&$-8rzvͭpdhFßnm"Meޱ#zxmš@@0׻\Vu HZBp׺XO8XXK!lpǠ~8g AiH|,$fT .T:D)uf {DV!n?;T:_m`ZŗJ '8V-1gFVc kQ|B%!ٵ5یdaXh>ﯯtAЈ;zFR2^{_H`*1(=&%7 /'ƣv 41WFh4.uuK!Zgۨ/8{q9K7#1v`q@#Y,4 !*.MtNJ+\E,ϧIY R,- 'd5r F$-<=6>r a8wca]<~w>9 n?jVQ}F <[ɝg|q) .@>w=CNcϟ7`7bLؼӝz٭:8W3=hx ;8-Uư*):UWeZgM 4U1y%4)H9,W"{^:iEyCu;5+R~YY?Vi~\n/˳Cǫ`x> Ͽw +jwuE RD<:Ajfٶ^2#ƝggD'=5_SVVh'"q::: |5a$n6@Zp(4L K IBe].!bϛ*?{oq^M"2eq{Mh_>IdnI֊f흉#ͱ&njMSiaIeMnFMtY_vko<)Cf(y2C86gں͵aIRI/em88~m_.ҥ;8~ O3+mM;v`|뮗aH{g):5]cH&Adc1M닧 0:V+o,TOL}&O%\2X,I)5-B B{.Ga=ny!JSf(S 8c:PHS ELl LEQKN!ꊝ뮚g)lۿ>_M0JoZ* H$- "ON%!B=T-(JU+\,Z놋sX*ضrUaBW jPMξURaEaGhC*mmm51ERV\.(Kj^6-Js +^-7 bo(|)烇E }làl!C@"Fv0U= +UV ϸhDɯ1~&1BJq񊌪N[HD7 ]BPPՂ~U RDtPԙQ7agR5NĜ憆\s ʍNc&3M`j0$->}h k*!k*_L@DNb+Z3\C-2XRE*Re2>1Y{fzEiMڕSdɟdi Lm.'p\ oUbY|֗R PcY'WU5ّx;N&۲1oD(lD]׶D4ů+8vܧ뾸8q+ ZucnfNW qPAߡ[c BЄ e`fu`=  #DM^ 5qbQ= cwi^p.D?$5H>o㐾2yIȝ uPP@?P ԝ *T B&Ct#5]B,] c0X c0NI0yOj?`ھ0 fcan? /w`ׅ2}[} s( - 841q&8B8J8q?\_|e?BZ-o: kºQX @ND>@| F?b K"$z2H{q6!~$u#z"ލHzلH$$R)iHiRԮBxX9* RQ|l}Tn0*U:nFaQD.ńPl} G (>JR(1QLN˅ѻw''Q×QbIc4 5{5Z^F6amn5Pu:Qըi5 uC=PӨWm4 8 :FC6he4"ʆƦѸrhhr4a;vXfYhvi.FKJh}7Z?mv4F;Ю$B{[}P9tSt4 eCǾD{!t9:<:]؍.BW+|ut2ݽ-Grѣz=UB(x}}<}2}}}}S }D$].nS\z6 yDGGWGNJeGBR[q9g㼳qpָf\7. >ǥһqڸ/l JqpX7q8r01qc0lG~||z:>sF}Ӌ}<܉<:<ݎ<ۋ@DEFN[\]^fghin~ "#'()*.5:>FGNTUY^ex -69IJNP]lwxz{ (28[]`c"$%46:JLPS^cmy}!#*0<abcdefghijklmnopqrstuvwxyz    9 : !"!!!!!!!!!!""####(#)#*#+############$%%%%%%&&&&&&&& &"&#&%&*&,&.&/&8&9&?&@&B&Z&[&\&]&^&_&e&f&r&z&{&~&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''' ' ' ' '''''''''!'1'D'F'L'N'S'T'U'W'd''')4)5+ +++$+P ?Y19@Rcim{ !-=JLPS^cmy{ + % !~2+(v_UFpWON+%#!   ~}|zxwvutronml_^ZYXUTQPONMGFEDCBA@>=<;:98) }{zyvrqjba_]ZXVROL=<3%}ztkZYLKIHFEDCB?=<:6321.-+*($#"~}{xuolhfdb^]\ZVSRPONJIHGEDB651,+(      z x v u t s p o n m i ` [ Y W V U S M K F E D B A = 4 0 "       {HJh \B,0L" $jD~zX.zz^zlb|~~v6::.00D6:6.*.v8.HTRF06 $8" >VVT@>Dx8:4  jr4@<jj2dRzHrz|xvBDfdb`t\|`fHpnf\4 !"#$%&'()*+,-./ !#'/9:<ABCGIOPQTUVW[\^`c{  !#$134568DFGHJLR\]^_`achjku{lm 029>@C 0L!!#%*+09<Zaabbccddeeffgghhiijjkk ll!mm"nn#oo$pp%qq&rr'ss(tt)uu*vv+ww,xx-yy.zz/PQ    [  \ 9 9T : :U       @ !"!"!!!!!!!!!!\!!]!!c!!:!!!!A""""##V##W###(#(c#)#)#*#*#+#+##############L##########$$%%'%%%%^%%%%'%%'&&&&!&&>&& &&&&0&&& & &"&"2&#&#&%&%&*&*&,&,&.&.&/&/&8&8&9&9`&?&?&@&@&B&B&Z&Z&[&[&\&\&]&]&^&^&_&_&e&e&f&f&r&r&z&z&{&{&~&~&&&&&&&&&&&&&&{&& &&&&&&&&<&&&&&&&&&&&&&&&&&&^&&^&&&&&&&&>&&&&&&/&&&&&&9&&&&''#''#''#''' ' 9' ' ' ' ' ' ''R''m''l'''''''''''!'!'1'1'D'DF'F'FF'L'L'N'ND'S'S'T'T'U'U'W'W'd'd'''''')4)4k)5)5j+ + ]+++++$+$^+P+P0 23?A4Yv7UWYZ[\]^C_`a11c9<d@@hRRiccjiikmml{{mnpqstuvwxyz{|}~ !"--==<<EEGHllssvwz{%'/2OQX9ZoAqtWv[mt~xxzz9J^a!>@@RADEEFFGNP[\\]]^^`fgghhiijnp~'  G.09:<DHIPh X ^ []u_d "e##$'h(())l**+.m05q7:w=>{@F}GGHNPTUUVY[^`eux`_OG^ !-3689@IJJ MN PPQ] llqwxx!yz!{{ ##$$%'(*/13445566789A{EGHIJKMOPQ UYZ(([2278\X[^]]b``cbcdBCfhijlmnorstuvwyz{""|$$}%%124~669:<<??AACCEEGGKKNNPPSSXX\]__abffhmprttwy}}I~1 +,,-01125667@AABWbfjrtw{!!$%)*.077;<AADDGGJJOOQQSUXX]^bbdfikmmoottvvxy{| ""()++./;=@@CCGGMMQSVV Z[ ^_ iikloprs|} "#$&'*-/134679;>?@DGHIKLMOP   STVWYZ'*[//_>>`JJaLLbPPcSSd^^eccfmmgyyh{}ilnrstvwxyz     ABC!!;&&''))**--T112266XKKNNOOhhUjj(ttHwwxx@nd=eIX  =AAMMNNQQUUddee{{i*@PZ X&tt[% Y W5pweK         G %%''((,,44^55^GGIIJJKKLLMMNNSSkknnqquuww{{ }}h9SlQh&vBA!E^MFGHJ    v  IaZ\[NPO  ""s&&?++,,D--r..~33>66fBB_DDgtJ/C1aA>?'spo4^^^^^   ##K))LAA.BB$CC%DDGNNSSEUUZZNwwpuFLyyzzE8(llH  X HD(888L !0"#%H)++,.1 2(356h7x99:=??@ACD0EFGHIJLhMP(QxS,STTU4V4W@XhXYZ[\]^x`aXbce(ffgi4j,jkXllmoLppqrsTtuTvPwtx<xyz{|X}p~X``<hXH$LL`\Hl<,hPHxhŒÈD d֠ؔ|LߴD lX4@T||`x     0l(X "#\$%&L(()*+P,X-.D/79 9;(<>D@ADDFhFGIKM\NPRSdTUVXYDZ[]^`abceXfLghj(km4nLoTq rtv\whx|yz|~ L XP,Xtp xD(Xt<Xd,\”lPǰȐɄʘl8Ҽ@֔@ tHܬ0lXPL |08l@$(lP8TP,t,0@, 4P|   <  <    XX,,\,D,,Ptd4 !!"D#$%&D&&'())*D*+,-d/01123x4X56p7H78p99:;<`=d>@ApBChDDEDF|G0HtHIJKM MNDOTOPQ|QRSUVPW<WXHY`Z`ZZ[$[d[\`\\]h^,__l`abcdd<eeg hHi ijhkm<n\oPpHpqr8rst$txtu(u|uv|wwxzzl{x|}d~P(dx$p<(lT,l|ld \t<LP,pH`<$x\PLphPH,ĜhƼLt0͜ЈT0\|L$\ ؄hdܴdPLh$ X dH`tlHP|\0@P8      (P@ 8x@ !d""#$& &'(`)T*++,l-$-.t./081 23 4 5 6@9;4<>h@A ACCDEFxGPH|IxJtKpLlMTO0P$QR RdSLSUtWXWXYtZh[h\$]]^_`abdc ccdDde|fdg(ghhipjjklLmmnop@pq`qrsttu$uvwx`xy|zz{ {|X|}~T|\p4(XH<|XDL<,(0dd|\˜Ĵtƀ`Xɴhˌ4ѴҸӌԐHPDظ٘ܐ @,Td,<|`HP|D X d    P hxtDpH4 !"#$%\&&'()l*,-<.8/P0,1`22346H7T89\:;<=>?@DABDFGH IKLNOQPSTVTWXZ[\|]^X`acpeXgj,k lmnp qr$rstuv8vwy yz`{x|}H~(Hhp$\ T8D$\0 tLPT( dxd$Ü` $ɰdlά0 t|4`݀`HxD(Dd L`0|   $@|<\$X$4  "("`$%X'@(L)*+,.01X2p4<6t8 89:<=? A$B4CEF FGHJxKLN(ODPPR RTVVXYl[\(\^^_t`@`bcddefgijklmnoqrxsxu<vx8yzt{|~$~ p`XL(ptdxxP(\,Hp< `4P    D` 5777'13#3'17'17#3#17%671167!11!1&'&'@ZZZZ'ZYYYYY3YZ     ::   `  m"4'11&#"132765676'&'`       `js11131716761312##11312##11'&'&771#11'&'&771#1"'&547633171#1"'&54763317167673171# _   : E: E   _   : E: E  __ ;E ;   E ;E ;   E 42111230111''1&1211#"'&5510#01#10101&'&'&'&76767676'&'&''10101"'&'&'&'&7676767514763 0  /0 1     1 1   $       ! #       # "/65114'&#"1327&'&767&'&767w @    I @ $$$$$$$$J211171611''11#"'&5511'&'&76771'1&'&76761514763 p  rs  p  o  rr  p  C DE C B EE C 14'11&#"1#1"331132765513127654'&##15      p      @,6711671&'&'57111676751&'&'--DD----DD--))))D----DD----D`)))))&'&17711#1"33327654'&##1`  .@ `` @ @    `@0"1#"'&54771671312#!1&'&77167&'&'" +<>())  "` *)(><+  ""@D47116331131#1"'&''1&76761316767&'&'#1&'&771#1"'&5  :&''&:O   Oh   x'&::&'  x 96'11&'&1331132765513127654'&##1514'&#"1#17       kr  P P   @?67312##1131#1"'&''1&76761316767&'&'#1"'&77! r:&''&:S   S !  p'&::&'   @!<6'11&'&1116767&'&'711#"'&'&54767632  %--DD--*+@?   k  +9D----DB,-K  D471163!11'&'&71#1"'&5       P @"Dc&'11&'#13167674'&'673#3#1&'&'67673101013101015011101#10101&'&'6767310$%6 6%$#$%6@6%$#@   6%$$%65$ 6%$$%6 $5@@81132767654'&'&#"&'11&'67671'&'&77@   XA+*--DD--$ @  -,BD----D7*  K1111'%1&'67%16}   @ n     @@+"113!127654'&#!"113!127654'&#!0 `  ` @     11117%167&'%1&   @ n     0<I6711673111132765514771676551&'&'#132765676'&'P +'  *$%6 6%$  P   "0  "6%$$%6 P]112#&'&'&'6767671&'&'&'6767632113276551&'&'&'&767R6666R H9:"""":9HH9:"")-$36%$$%6+    66R@  66RR66  "":9HH9:"""":9H )!!$%66%$ P   R66$$$$!(&'11767713117676''1#3#71 x(  (x+HH`  LL  ` @/>11113167674'&'67&'&'##3#51313#3#15@6%$$%6`````````$%6#"06%$@, "327632#"'&'&767632#"'I1<<1//1<<1 DVVD,,DVVD 1//1@@1// AA-9999,BB +67116731#1&'&'3#3#1316767&'&'`?2332?`````D----D`32??23@--DD--@511113127654'&##1513127654'&##1513127654'&##@       @-111132765513127654'&##1513127654'&##@        :116767#1"'&54763312&'&'&'676767'&'D----D;++ }  >>Z?2332?X=  ,?`--DD--$#8  X9:32??237  (2%53276551514'&#"1!1514'&#"13276551!@         @1"113311#1"3!127654'&##113127654'&##  ``  ``     @  @*2111&'&'51476321676714763  --DD--  ))  D----D   )) B565114'&#"11514'&#"1132765517117676''177 .   A j / x kC  ˍ @2111312##1"'&514763@       ,617161#"'&511#"''11#"'&5167      $611476321'11#"'&5167    ( = 5"1132767654'&'&#11#"'&'&'6767632+%%%%++%%%%+45;;5445;;54`%&**&%%&**&%=3333==3333=@.67116731#11#"'&55153#36767&'&'#1`D----D`  @```))``--DD--` ))@71167'1&7676167&'&'&'&'&'6767671'&''@--D,#H G--DD--5D?2332??2350 .D--V  U*7D----D"32??2332?V=9  8B+;111132765513117676''16767&'&'##3#5131@  _g T(()=pppppp""   x$#.=)(""Dj013'110101&'&'&'&#&'&767627676'&'&'01&#&'&'&'&71'1676'&'&'711&c 8 :7E    9  8  :7E    9 W   $@     $@  #"1133113276513127654'&##        `  *2111676751476321&'&'514763  $%66%$  66RR66  6%$$%6 R6666R 611116761&'1&767     9   B.6111167116761#&'11"'1&767 nUUn  QQ   $&   16'11&'&1'1&'&117677117676''17y  k     %&'11&113276551716'&'&1':      ז   &471163!11312#!1&'&71#1"'&5 @         L +i5'1"37171331127654'&#1514'&#""111331673123312765&'&'#1'1&##151'111#1"1#` `` `   d!;;!$ @ --D    ``      @ ..  D-- ,, ,j2111712#'1'1##11"'&54763151476347116331716331517111312131##1"'&54'&##1&'#1"'&5563211#"'&551477 ` `` `  `    D-- @ $!;;!d           ,, --D  .. @+ +A8H%11#11!1&'&'51#1&'&547%162151476331211%1316751&'#@    k   5 PP   ^% y. ?PPE-@Sd "13167675131676''67311#1&'567&'&'&'2711654'&#"3'67&'&'f B/0   F@@N4444A   %'&: 00B p@@044NA44   %:&' %D[}6711671&'&'4767571110016767&'&'010151&'&'671167&'51&'1%#3#14'&#"1#11327716'&'   "" 00 ()==)( 0  P   @ @P  ""p 0%3=)(()=3%0 ` ! 33 ! @  @ @ %D[|6711671&'&'4767571110016767&'&'010151&'&'671167&'51&'13#3676''1&#"131132765   "" 00 ()==)( 0  0  @ @   P  ""p 0%3=)(()=3%0 ` !  ! @ @  )4AMZhu1113167673327654'&##151&'&'!15167"51671&#55671&'71&'51675&'5167676'&'5211#"'&547630  ++x @ @ `Ppp----    **   @ qq '((''(('p   dp&1&'1&1'1&1'1&1'1&10111111111"3201'1177117712327176''167176''167176''16767176''16'716'&1&'716'''01012337211#"'&54763767&'771767176''167176''167176''16767176''101656745614541515111112#"'01145716'&1&'716'&1"#"'1&1'1&1'1&1'1&117717011101&#&#11#"'&5476321            000   @             0                P   0               6'&1&'1&1'1&1'1&1'1&10101111111"301'1177117717176''167516751176''167176''16767176''16'716'&1&'70111011'7676'&'7&'67 !     '  %     #     44                 $  +  #HY3#331211!1'1'1&54763'#13!67&'#171311!15167673!!!1!1&'&'5]sss  U $/ 00   O `  [@@ @@@@ pp 0  0B)]i5#11311316751316751&'#151&'#167116'&'&1#1&'673327654'&###"1#1"1333277%3#30101"101880880P  wy@ @^-#-% ,$88808808   X  $ @ ^^~21116751476321675147632111#1&''1&54763214545147632167514763&#"11113277171654''1'''11#"''1'1&5477171632'11#"''1'1&5477171632@      /@]Cq  <   000000000000  p   &?k  :  00000000  %2p2711654'&#"32711654'&#"3&'&767545015147677167716'&1'&7716'&1010101011514'&#"%70716'&733010131716'&&'11&113167&'#1&'673167&'#1&'673167&'#1&'673167&'#101010101#171676'  `  .< .  N >  D+  ,   /   @ <''3\  ||    |].        0III'#"7..%O   k uK1 G***2 @/// (  %('.      Aa&176''1&''11'17161131676751&'&'##'1'1&#"1'171&#"1'5311767671767671' P  M  *  LH!YR#~' l\   0 j {<   /IBc S % 7Jbk|&176''1&''11'17161151#1'1'1&#"1'171&#"1'''#1133127655%%131176767176767%&'67%5331276551#67&'' P  M  H!YR#~9777)   >\    `  0 j {< /IBc,,, S f H[dmv76711671167311##101011111#11#10101#1"'&551&'&'!2711654'&#"367&'7&'6767&''&'67767&'&'6732?I77 * mk P( .`  p(((>32--E5    I=M   xx8ajs|%'112121#1'1&76167311##10101%671111#11#10101#1"'&551&'&'&'67'&'67767&',,, +'  39MI77 * @;>+ "P( .h@(z""" "  (,--E5  f:1" I=M0  ,Zm74711#1"'&551&'&'''6767311#13#30101311#1311#1311##15167016372711654'&#"3  .56DI77 * !8   0  ! I=MG:##--E5  @   P   6w76711671167311##11#11##1"'&551&'&'7'&766767676'&76767&'&'&76'&'&'&'&'6767&'32?I77 * @  .        (>32--E5  @  I=M        `PA7DW%6711676''1514'&##1"1'1&#&1311!16765513%&'&76767116731#1&'  5   j  @ $$$$p"@"  /y %^    ""-6X631121#151&'#11311#1&'&'51#1&'&7753151#'471163312131##&'&'67315 @@   І0   0   &@ pِ   _2111&#"514763&'11&51676721"''1&'7'11654'&5456301636767&'&'"'"'4547654''&&'&'&'&76'&'&'67676'&7676767767#&'&'514567676767671&01#"227767&'&'67@  } # & H            HHH & #  qH | |  '&,,,&           E&,,,&'    l 4Ag676'&'67116731111#1&'&'51&'&77%676'&'&'673111#1&'&'5171654''5315167611'&'51#11''1&7716@  & ,+@0      *,     0@` @@ ` @@ $$$$ @/I  t2$$$$ 2t  I/@(  @@   @@ %G11#11'1&761'1&73113%%1#1&771#11##1&'4771'1&567I  (8 et(AAB 81g+*    ?r: nn !%?a531513121327654''1&##14'&##1"11131676''1&'&'#531#11&'51#1&'67315167<" "!< @ c    ``` " " x    !%?V531513121327654''1&##14'&##1"11131676''1&'&'#11#"'&'6767632<" "!< @   ``` " " ^gp&#"1767676'4'&''76'&&'&'&'&76'&'&'67676'&767676767&'&'67  /.VV./          HP3EEAB+ +BAEE3Pm         [m471163232765&'&'1#151&'&'#1311#1"33327654'&##151673167&'#11#1555!11!16767   ))@00P  P88@@))`  ))    )) ,]s676'&'676'&'74'11&#"32765#1&'&'676731&'#11!1676751&'&'11316767&'&'#  p$$$$`   )))X))@)) `    + )))&))))`7N\"1133116767&'71654'&#"1&'513127654'&##111&'&'51676756751&''"1'&771671131#1&'5147716551&' L11;;XX;;  +9 `p   t  %' ,@'   "88PX;;;;X@1 # "  ``4```  `  ",  + /=X&176''151#11'151#11'1!127654''1&'!11'3#3'113#3#51#11131676751'1' P 7@@+F Lt#UUUe @  @ 0 +ʘd4"  r O  P  A3$5@[&176''1515101#"'1'1676727676''1&#!1"1'327'155#"'11&'11!127'1#' P W  ())*:8Ij!0@ 0 Dd %%%[ $,S@ v'?R&176''16767&'&''165&767!1'%%31276767711&'&54767' P n&)); "&9H,        0 V55MR6666RK5.&,243'0-L55  A1EUb&176''13167&'&'#1"'167&'&''167&'&''11310101&''1#11!167'1#7676'&'' P .*)0)"+'D. I8&&J@---- 0 . ."#)$  "".+9&&8'((''(('4'11&#"1''1&#"1#1"3311327716132765516761327654''1&7673127654'&##1&'&771654'&#"1'&'5676'&'&'67     &   &        '   '   p  &        &   &        &   8IS&176''1&7673127654'&##1&'&771654'&#"1'&'514'&#"1''1&#"'63'%%#1"3311327716132765516767' P    '       `  E   &      0 y     &   &  K 7      '   `i|17716131#11''1&1&'51&'&1'&7716'&'#1&'6731676''1&761767516767&''4'11&#"327651176'&&'&'&'&76'&'&'67676'&76767674'11&#"32765              00   @                         @  P        p  jx7''6711316767514''1&5515151&'&'#10101"101&'&'&'01"10101#1111113127&551477'''1&767761'&7888//F  0  0   000 0 000 0 ӧ   H J  J H   "x000 0 0000 0 kx'11##1&'&'5147716551515167673101010301676767012101033111111#1&'&'514771&'676'&''11771176''1716'&1'1&513367&'#151&'888   0  0  F//7        z"   H J  J H   ~      @`9%"113312765514'&#"1'1&#"1'1&#"1327711#   i iS`   S j j @`9"'11&547633121#"'&5511#"''11#"'&54771632171#   i iS   S j j)W "132771132765511327654''4'11&#"1!16767514'&#"1#!1"'&55 I  I  ))    J J  @))@ @ @U\e&'1#1"3311#1"3311767713117676''13127654'&##1'13127654'&##1'#3#713#31#17 H[ @ 3    3 @ [G@@@ [vvv    4  LL  4   MM@ @>GS\k"111#1"1111331132765513167674'&'67&'&'514'&#5#1513555#15135531# J F  0  0  00@  @00@      z*v    0%0   ````````  @````````  @Yhy4711632131514763211#"'&551#11#"'&551#1"'&55151515147633153#36767&'&'#1#3#1316767&'&'#0   # 0     ppp  ppppp        '%0      v*z   `@`  +7776731213121##1"'&54771#1"'&5 .   /  {    5F6711673117711767513321#12##!&'&'113!151!1")` 66     )@  `) ++  @  )@ @ @@%Gi7#11!167671&'&'#1'1&'#1#1&'4771&#"1'&771677163673113277161&'1#&'5 KK "z" M #21$ M #21$  "" M@ "" M a;G4'11&#"11327655167676'&'&517676'&'&'55&'&'6767  F,--,F  /$    $/@** # 34II43 # #  #d "!..!"  7Mdz2111!12#!1&'&'147632111#"'&551476375#"'&551476322111#"'&551476375#"'&55147632   p"      @        "P @ @ @   ` ` `   7Mc2111!12#!1&'&'14763471163312##1"'&53#32##1"'&547633#32##1"'&54763   p" ` ` ` `  @@@ @    "P `  @   `   %5F#3#11317171"#554'13'#3#1131717#111317171#!!!1!167675VVV\@hv\\\\F@@@h@&#11#''1&##111312771621127716136767514''1&747636133167654''1&771654'&'#1"1'"'&5&7716551&'&'"1''          3<py''1&547716131676751&'&567671#1&'67%67611'&'51#11&'&'476751676731567&'@  PP   "" $%6  PP   "" $%6( H H ( "" 6%$(8 H H ( "" 6%$(h]fo67&'7111331276551&'&567671#11&'&'476751#1&'&'51&'&5676767&'&'67PP    "" )0 "" 0) ""xX ' ' "" ')G "" G)' ""4=clu1311&'&'476751&'&'#11''1&547716&'675&'&'476751&'&56767&'6767&'2 6%$ ""   PP  ""  "" H($%6 "" ( H H NI "" ""  bU_i6'11&'&117677117677167676'&'&71676'&'0#&'716'&'&1&'77&'4767771&'   B)*      2'  6     \... ===>   -33F,%&G  4  *   <  0g(% R76711677676'&'&'67676'&'&515167217676'&''1&#"&#"111&'&'`--D?,  =X?2332?X=  ,?    +D--(  732??237  (`   7 S&'2@5>111311#1"3!127654'&##1'13167671&'&'!!11!@ E  E @@    @  6CY"11#1"3311&#272765515127654''&#676'&'"113!127654'&#!    #6%$$%6%     ` @    1$%66%$ `   $$$$   +8Rly731276''1&111!167671&'&'!&'&767671167311##1"'&553671167311##1"'&557676'&'77716'&'#1"@@@ @ E`  P @  `  @  ` 5 @ @@@@  @ {`         @  @@7W67!11&''1&551'1&7211#"'&'&54767636'&1'1&11771176''17  k=''@  '!!!!''!!!!'; %% $$ %% $$ //A)$0 O""&&""""&&""k $$ %% $$ %%E"111#1"3311#1"3312767713127654'&##171673127654'&##; 7k P- % % 7k P- % %  l    l  )!!!&'&'51!11!!!516767311331@   @@ @I"1111#1"331132765513127654'&##1513127654'&##1513127654'&##P    P P   `  @ @  @  `  :FP"1111327655167674'&##151327654'&'514'&#5&'&'67675531 F,--,F  F,- " *<  **@\ " # 34II43 # # 34I \  ) # "!..!" \\\" @AM[&'1!1"13311331677131276771312771312765514'&##15#3#71311#'!!!!1&'67@   ( `i C \\\i p   h K  P @; `{5&'5167'''1&766176751476321'&''1&76176''1&76176''1&76176''1&767655167514763211'&7716Pc   f|   %166)d5 ]] uu ]*%)%  %   @@@@000  0  `| ' +%$'d5 ]] uu ]**0b( +%$ 0  0 A(5G%11#11!1&'&'51#1&'&547%1621'&'&767113167&'&'#@       `""@     $$$$`""@P471163332##1312##11''1&767312767#1"'&5476331&'&###"'&5 @ 8# # !!.  P   @     ,g     I67116'&'&1514'&#"1#1"3311327655117676'&''13127654'&##17U        h  z    z   j211163251476321'&'&'1#"'&551&#"1#"'&551312###"'&5476331&'6767514763   *   #    .$%6  /2  !! 1#$. -D __ D%?6%$   5K;..1 94'11&#"1177113!127654'&##15171676'&'&15  )      w     ' "B"111132765516767132765113276551&'&'514'&# F,-  *  *  -,F  # 34I .!"   "!. I43 # ,>P]kx"1###116771676751&'&'##"''1&#''&'&55167311%76751311%6731#1&'3#3#1&'676731#1&'@*"% X)l5DD5l)H&"*(##(U* #" *UU0E55E0U0P]6'11&'&1&'"&'"113276551676711767712765517163213276551&'&'7. "  0     N  $   +  _!  P   +  < d -5#-7ANf5!1676751&'&'!111#157115135#16767'3#31&'&'676'&''&'1!167&'!1&'&'5``@@@@`@@@@@'((''(('""3p`@@@@@@p----X3""CJQ&1#1"33113276551311767513127654'&##1514'&#"1#1'3#31''#3#51{    da    9w::::      @VV 5777'13#3'17'17#3#17%671167!11!1&'&'@ZZZZ'ZYYYYY3YZ     ::   `  .A^"1113276767327671&'&#"&'&'&#4711632#"'&5!21'&''&77163217163.  EFllFE    EFllFE 2    | FccF  E W    d         W ! 5AL"111"31132765513167673127654'&##1&'&'##3#51313#3#15@    `;++   ++;ۻ`   ` `  ` `$#8  8#$@@@OYdl"111"31"31132765513167673127654'&##1654'3127654'&##1&'&'##3#51313#3#15#1513@     P4))  ))4pP//P @   @` @+    +` @ ` A671167111''1111"#'11"#&'514771511'&55147715: nn :bBw 99P+*   *+P99 vB+:Zj471163311'&''1#11#"'&55153#36767&'&'#1%3#3#11#"'&551514763671167&'&'#113 P=)('4 8*  @000""0PPP0  00  P  00 ()=-#"   ""` 00 `    `@E471163312##11##11##11##1"'&547633151476331514763315  ` ` `  ` ` `  ` ` `  ` ` ``ir&'67671165&'&'1#1"3!1167674'&'51!127654'&##1516765&'&'1!15%67&'&'67  "" @  ""  @ "" Hxa "" 7  7 "" 7  7 "" 77I1?Re671167!111##1"'&551!11##1"'&551&'7!1'1&'#14'11&#"327652711654'&#"3"`"            p"")0   0) HHHHH     b211171611716113167675167631#1"'&5511'&'&76771511'&'&76771514763` w  w  @4$$  66N`   )  )  #" '" '""5  N33     6 @)6Qg111311317131131713167671&'&'!676'&'5211#"'&'&54767635&'51&'6767@@@@----+%%%%++%%%%+   `'((''(('%&**&%%&**&%ssss !  !   :Cc7113277171654''1'1&#"1113271654''1&#"7'171113277171654''1'1&#"1113277171654''1'1&#"1&&&&&&#}#iiii#8998`8998&&&&#}#8iiii"99889988 6'&177'&111&''1&111&''1&111327711327716''1&'711327716''1&'711327716''1&'716'&1&6'716'&1&''XX      E E '& ", &' ", &' .;  :. XX '& *! &' *! &' D E  !  !  .< !!:.  Lg676'&'&1'&'&76771611311'&'&771#1&'&'6767271'271167654'&'&#"3@s )  )&,Z&b  F --DD----D7*-    I + + z"D----DD--6   _&1111#1"331131676751&'&'#1"33121#1"'&5513127654'&##151&'&''$     ) R66)  $%6    %    )66R )   6%$   &  (GTao|6731#1&'3#3#1&'673#3#1&'67471163!121#1&''1&'&'76731#1&'#6731#1&''3#3#1&'676731#1&''3#3#1&'676731#1&''3#3#1&'67'3#3#1&'678  00`x`0Hk  6))))6S`````H` P&'&767&'511'&'&7716763332311###1#"'&551##1#"'&55  H :-" (    7  a'!$  ` `` aAk%6711676''1514'&##1"1'1&#&1311011331232323332767515147633121133323233127675145513  5   j     @      /y %^  Ep @ @ A=%6711676''1&#&131131'1&771'1&76111316767'13   f U< v Q&{     4 GS ] C@A'O%6711676''1&#&1311!16765513%67311311#11#1&'51#1&'5167315   @  00 00    P0 00 0 aB2111'&'6761#"'&551&'&'6767514763 /$  !,6%$$%6,!  $/  F,--,F  # $%66%$ # # 34II43 # 1H4'11&#"1#1"331132765513127654'&##15113!127654'&#!1"  p p  p p @   p  p p  p@  = 46761##1&'1#1"'&7716&7!11!1&'&''  ,    "!,,!"    @Q  **~6767676'&'&'&'&"300101011'&'&'0101&'&#&2330101317676'&'676'&'&'&'#1&'&'&7''#1&'&'&76761A(  6,/  " ))   5,/   ) M) ( # `   6 *     4 &      %6>JZc11313151##"'&54763!167&'!3151'1&167'17674'1#3#131271&'&'67&'@//E8 pH@ 7)Vy&}[ ++8D--  XH "#F@/@W$ ]0@`21111''1&##1111#"'&551&''1&'&767613676751&''1&'&56767514763471163311'&''1#11#"'&55153#36767&'&'#1   !4"#     4"$ p P=)('4 8*  @000""0  #%'     #%(  @ ()=-#"   ""3M671167311#1&'&'671167311#1&'&'5%3#31#1&'&'16767            p      p    `         1l11#11311''1&7673151#1&'&'516767!155#131676'311!1&'&'5167673131#11311327713. FF .@S GG S @ FF @@@@@@@@@"V%55!11!!!!&'&'516767!1111#1&'&'516767331311''1&7673151&'#1"& FF &P @@@@@@@@@" FF @"V%55&'&'!11!1676755331#355311#117716'&'#151&'&'##1316767@P& FF &" @@@@@@@@@@@ FF "@Vly671167654'&'&''''&1'&''1&767716771671771632111#"''1&'7'#1"''1&7677166731#1&'7'''1&767'&7716F::$""$::FF::$""$::F/'''  #       A  +  '  @!"<=CC=<"!!"<=CC=<"!         P 3Lrx&176''1653127654'&##1&'6771654'&#"1&##1"'%111331276551&'&'#3#"33113277151'167'1' P @ @ @ @p ) )@@@ @@ ?%58'_ 0 x  @ @ )  )  % @ ?!m&Jv@#*Ee6711673113311#!1&'&'#3#51211#"'&'&5476763&'1#131167513167&'#15 8$#"0'!!!!''!!!!'0000 '.->-%%@`""&&""""&&""P0000<Mq!!!6767654''1&'!113#3#1#151#111316767515152111#15147635"13312765514'3&'&'%c// LtL [@@@@   @ P  ""  rr  P  P  00 000   0""6731#1171'1&761''113151671&'51#117161'&771'1131#1&'673151&'11''1&76171&'#11&'516713167'11'&7716116751#1&'&'&76767&'P/# 8 "" 8 $.P/# 8 "" 8 $.0@" 8 $.P/# 8 "" 8 #/P/# 8 "  hU&176''1673116751&'1#1&'71176''1&11&'513167&'#1311'1716'&1'#151&'16751311'1&176''1711#13167&'#15167'' P "" 8 #/P/# !_n"" 8 $.P 0 |#P/# 8 "" !K P/# 8 ""d11#"'&54763267&'&'#1"3311#1&'&'51176''1&177113327&'#151513127654'&##4'11&'&#"3276765'1''1&761716@   ))))   0)88--DPP "   +""&&""""&&""M H ( = `  P4))4  )88D--%P  '!!!!''!!!!'+ H ( < d11#"'&54763267&'&'#1"3311#1&'&'51176''1&177113327&'#151513127654'&##271167654'&'&#"35&'6751&'5167@   ))))   0)88--DPP "   '!!!!''!!!!'`  P4))4  )88D--%P  ""&&""""&&""`PPd11#"'&54763267&'&'#1"3311#1&'&'51176''1&177113327&'#151513127654'&##271167654'&'&#"3771''11'&771'1&761716@   ))))   0)88--DPP "   '!!!!''!!!!';$$$$ %% $$ %% `  P4))4  )88D--%P  ""&&""""&&""%%%% $$ %% $$ fw11#"'&54763267&'&'#1"3311#1&'&'51176''1&177113327&551##1513127654'&##2111#15147635"13312765514'3&'&'@   ))))   0)88--DPP 0    @ P  ""`  P4))4  )88D-- !  @ 00 000   0""@Yhw3112771654'&#"151!127654'&##1511327654''1&#"1327711##"3311'1&#"3#3514'&#"#3#1327655 ` )` `) ` ` ) `) ` @@@  @@@@  7 ` *s  s* ` ` *s  s* `7  Uds77654'&#"151!15147#1511327654''1&#"1327711##"3311'1&#"1327554'&#"1353276551#72111#15147635"13312765514'3&'&'``` ) K) ` ` ) @) `  @  @ @ P  ""7``` *ss* ` ` *s  s* ` 7  P 00 000   0""+=M_o6711673113151671311##&'&'5316751&'#11316751&'#5316751&'#171316751&'#5316751&'#1%'1#"'&54771#1"'&5476331'1&547632  ` (  ` @          PPP P s s   HH     P  p    p  PPP P    B*cx%271165511327654''1&#"13277113&'01&7676767677676'&'&'&0101&'&'#3#1676763635&'11&'#11010167625   P P  #+*#  &,21  12-&  #**#N    `  P P  F          0   Ba111#116767636367632327626551&'&'#1511327654''1&#"1327711#151&'&'#&&'01&7676767677676'&'&'&0101&'p  ! 0 P P  #+*#  &,21  12-&  #**#  `       `  P P  Z        F)6CP]jw"11331132771132765514'&##&'&767&'&767676'&'&'&7673&'&767%676'&'&'&767676'&'%&'&767'676'&' 3  0  0  0  0    3  P    P    PP  0  P@?j%!!!"3!127654'򺲺'&#"1514'&#"1'1&#"13277% "1514'&#"1'1&#"132771654'    )  ) ` ` )  ) ` `   * * ` `. * * ` `  v'4A1'1&17716'&151&'&'&767&'&767676'&''76''167711331276551117711331276551176''1&'&##1"'1&'&##1"1&##1"1771133127655'7716'&151&'1'1&@@8    $ 0 $   0   & "  " &   0 @@@@v@@v  `  (j111 D16 61D 1& &1 G ? ? G 1& &!@@@@vvUk2111#"'&51476311131'1&54763211#"'&54771#11#"''1&54771632%#"'&5147632    ** ` ` ** ` `      @ I )) ` ` )) ` ` )@ @  :Xu13167514'&1&'"163'76751&'#1"131&567#3#'1&131276''1674'&'716'&'#117712751#;*  p "=V|!!! p "5A#ZAAA#! p "5;*  p "=V`#! p "5A;  p "=V;*E;*  p "=V#! p "5A[#11"'&547716321#"''11312##1&'&'&'&'#11#"''1&54771632131251 ` ` )@ @6%$s* ` ` *s#)) ` ` *  $%6) ` ` )*0=p6311215147632111##1"'&5476331'1&547676'&'#3#"'&54763310101112111#"'&5511#"'&547747116321716321312##1"'11&'&51101015'#"''11#"'&5510101114767631101312## i  ` j    `   i j-  i j ` mjjj i   `  j `  i $$$$`  ` j i j i  `iii j `  "Df2111311#"''1&76731514763776321#11#"'&551#1&'&7'3#35167611'&'51#1"'&54763&511477161312##11'''211#"'&54763  @ @ W@@@ @     @ @  ) @   @I    @ @  w@@@ @     @ @  7 @    @7   ;Hb}6151671#1&'6731'1&76711671167&'&'&'&7676'&'6131#1&'516717&771#1&'67311&'511'!''1&'516731#11'?`&?w %%11%%  %%11%% $$$$?&`??&`?@???`&??&`?  L  1?`&??`&????&`?6m6311211#"'&54771#11#"'&551676731'1&5476311211#"'&54771#1"1#"'&551676731'1&547) ` ` *  $%6* ` ` ` *  )*  ` ` )   6%$) ` ` )    )) 5kx631121311#"'&5514'&##11#"''1&5477'1#"'&54771#1"1#"'&551676731'1&547632676'&'%&'&767 )   P PPPP P   ) y  $$$$ )     P PPPP P     ) g$$$$  @?j!!!27654'&#!1"31132771132765511327654''1&#"3112771132765511327654''1&#"1    )  ) ` `@ )  ) ` ` `   * * ` `. * * ` ` J"1116767&'14'&#111!167671&'&'#1"1&'&'514'&##      P )) P %%        ))   ?T11316767514'&'&'516767&'#101010101#101010101#"'11&'67676#`p@   A !! A        >KW3#31#151676771633121#1&'&'67&'67&'67&'3167&'#13167&'#xPPPXL@````((  Hp,K67116703036767267632632121!1&5471163!121#1&''1&'&'      00   [  6))))6#>N_k671167!11#165516751&'&'#156''1&17711675117%67!11!1&'55#!1"'&551!3167&'#     p; @ @ %% ``  @``  `  !  P @ @ $yy$   P @@OXaj"113311#11133127655167671331276551676751#1513127654'&#!5#1513#5#1513#5#1513  (H)   ))   )H( PPPPPP  @)@ @))@ @)@  @@@@@@@@@@@@@ AJS\w"113311#11133127655167672676751#1513127654'&#!5#1513#5#1513#5#15134'11&'&#"3276765'1''1&761716@ (H)   ) ))5A/H( PPPPPP""&&""""&&""M H ( =   @)@ @),'H@  @@@@@@@@@@@@@'!!!!''!!!!'+ H ( <  AJS\w"113311#11133127655167672676751#1513127654'&#!5#1513#5#1513#5#1513271167654'&'&#"35&'6751&'5167@ (H)   ) ))5A/H( PPPPPP'!!!!''!!!!'  @)@ @),'H@  @@@@@@@@@@@@@`""&&""""&&""`PP AJS\w"113311#11133127655167672676751#1513127654'&#!5#1513#5#1513#5#1513271167654'&'&#"3771''11'&771'1&761716@ (H)   ) ))5A/H( PPPPPP'!!!!''!!!!';$$$$ %% $$ %%   @)@ @),'H@  @@@@@@@@@@@@@`""&&""""&&""%%%% $$ %% $$  BKT]n471163!12##11#11&'1##1"'&551&'&'513151#1"'&553151#55#113'53151#"11131514'&#671167121##1"'&55147635  (0  ,)   )H( xPP0PPPPx @ P""    @ 0 )@ @)@  @@@@@@@@@@@@@@ 00 ""0   0B?x471163!121#1"01015151&'&'11&'3&'&'"'&5567016'&'&'&'&''&'&7676760101676   )) 3#**#  &-21  12,&  #*+#` $ } )) } $       !H5#1516767311#151&'&'#1471163!12##11##1"'&''1#1"'&5`0+*A0A*+0,0,`     (A*++*A,,H    CU776'&1'1&1#1'1&13111177171671176''1&''1513167716'&1#1&'776'&1714'"1'1716'&111'1&177117117716''17117716'&1'16'!!!  " &&&& LBBB 4  % #  "     UIII :: I ( 8((8 ( /// %?P  '   - $ & 5    +;M]o671167!11#151&'&'1#1&'&'1316751&'#5316751&'#171316751&'#'5316751&'#171316751&'#5316751&'#1471167632#"'&'&571#13117716''1&   3`  ` P  P  p    p  P  `""&&""""&&"" YY 8 8   ##)L2P  P       p      '!!!!''!!!!'C  8 8 +;M]o1113151676713167&'476751&'&'!67311#1&'573#31#1&'516767311#1&'5'3#31#1&'516767311#1&'573#31#1&'51674'11&'&#"3276765'1''1&7617160  `  `3   p  P    P  p  p""&&""""&&""M H ( =  ` P  P2L)##             '!!!!''!!!!'+ H ( < +;M]o1113151676713167&'476751&'&'!67311#1&'573#31#1&'516767311#1&'5'3#31#1&'516767311#1&'573#31#1&'5167271167654'&'&#"35&'6751&'51670  `  `3   p  P    P  p  '!!!!''!!!!' ` P  P2L)##             `""&&""""&&""`PP +;M]o1113151676713167&'476751&'&'!67311#1&'573#31#1&'516767311#1&'5'3#31#1&'516767311#1&'573#31#1&'5167271167654'&'&#"3771''11'&771'1&7617160  `  `3   p  P    P  p  '!!!!''!!!!';$$$$ %% $$ %%  ` P  P2L)##             `""&&""""&&""%%%% $$ %% $$ '7IYk{1113151676713167671&'&'!67311#1&'573#31#1&'516767311#1&'5'3#31#1&'516767311#1&'573#31#1&'51677"111311316751&'#14'�  `  `    p  P    P  p   @  ` P  P              `  @ @-=O_q11131516767131&55167516751&'&'!67311#1&'573#31#1&'516767311#1&'5'3#31#1&'516767311#1&'573#31#1&'51672111#15147635"13312765514'3&'&'0  `  Y    p  P    P  p   @ P  "" ` P  P%/              00 000   0""'7IYy1113151676713167671&'&'!67311#1&'573#31#1&'516767311#1&'5'3#3#113151671#1&'516716751&'6711671&'&'5''51671''11&'516760  `  `    p  P  X000  0    ### #  ` P  P        @X         )444+`  4+`  A9I[m}671167!111##1110##151&'&'1#1&'&'1316751&'#5316751&'#1'5316751&'#171316751&'#5316751&'#161'&'&'&7677''16767   *& 7 `  ` P  P  `  p  P   x 6 6 xh___2   -88,P  P           r0!))&&&&))!0V&&&**''7IYw1113151676713167671&'&'!67311#1&'573#31#1&'516767311#1&'5''51671''11&'5167656751671&'&'51670  `  `    p  P  ### # }   ` P  P        444+`  4+`  @@@@@  @ +;M]o11131516767131&547675151&'&'!67311#1&'573#31#1&'516767311#1&'5'3#31#1&'516767311#1&'573#31#1&'5167&'&767113312765&'&'#10  `  Z    p  P    P  p  0'((''(('  'f' ` P  P$`             ---- '''7IYk{671167!11#151&'&'1#1&'&'1316751&'#5316751&'#171316751&'#'5316751&'#171316751&'#5316751&'#15#1516767311#15167673111#1516767315#1&'&'51315#3#&'&'513155#1&'&'513171&'51675&'5167'1&'5167    `  ` P  P  p    p  P  """"""""""""`  ` P  P       p      P""""p""@""`""""hh@    ?&111177116771176''17167&''1716'&1'1&'1'& pcg5 e!!e 5gj G"   !e 5gg5 e!"G jcp S\er&'16753#31#17167'7111331276551!113312765515151&''1&'&##1"&'6767&'176''1&!77716'&^  K        000000PP 55  OOO%(@     @(%OI000000:FT]f1111131&551677167633121131676751&'&'&'&551#113'731'1&##1"67&'7&'67H9:""+ t +"":9Hk ֬t"":9H p!@ @!p H9:"" (( ****  F676'&'55311327655117676''1&'#1176771132765#3#11"13311316''1316751&'#151716751&'#11151&'51&'$$$$   44 44     <,05 @     R,,R   d   `\ T8m tr Ta&'&76755#1"'&7711'&'&771671'&''11##11#"'&551#11#"'&5&'&7675#"'&5511'&'&77167311'&''11#"'&551#$$$$H :%::%;     $$$$   44 44      PPP]%  N..N  %]P PP   ```   R,,R   `+7671167&'&'1&'2716767&'765711'"!"""""!%% ""!J"" ""+J J$7at11#11!167671&'&'#1&'&'211#"'&54763671163311&'51477165&'#1"1'&754711632#"'&5  &%    V:  ,: 6   @@    $     B$2?MZ2116731!1&'&'676767677'&7716%1'&77167'&771671'&771667016'&'&'&'&''&'&7676760101676 ")S000  0  G 0  0 000  0  g 0  0 1#**#  &-21  12,&  #*+#)PPP P ! P P !PPP P ! P P        >Xfs5!151!%111311#1"3!127654'&##1'131676751&'&'!!1113167671&'&'#3#3#1&'676731#1&'211#"'&54763@u K  K u  @  @       `@      ` @P   3Mg53312765514'&##1"111771676''1&'&7"1113312765514'&##"1113312765514'&##53312765514'&##1"'"1113312765514'&## @ @ m   7   7 @ @@ @ @ @ @  @ @@@@ @  7   7   @ @ @ @ @@@ @  @ @ 1L_11177167677167&'&'!#11"''11!1&'47%4'11&'&#"3276765'1''1&7617160 :'&3 `('Z""&&""""&&""M H ( =   +.   /A '!!!!''!!!!'+ H ( < @;]j617161#1&'&#"#1'1&76167'1&761632371671011101!10101312#!1"'&5476331&'5167 a WG   PL a?f  L     7W4 h XK   00BKT3#32311!1'1&767314763!!!211#1&'&#"#1&'&'01'1&55147635!151!67016'&'&'&'&''&'&7676760101676 K  K  33  @#**#  &-21  12,&  #*+#    |H H| @````       @#*EN[6711673113311#!1&'&'#3#51211#"'&'&547676367&'516751&' 8$#"0'!!!!''!!!!' '.->-%%@`""&&""""&&""PP@#*ER6711673113311#!1&'&'#3#51471167632#"'&'&53&'#13167 8$#"`""&&""""&&"" '.->-%%@'!!!!''!!!!'@#*ENz6711673113311#!1&'&'#3#51211#"'&'&547676367&''56751673111675171674'&'#1 8$#"0'!!!!''!!!!'@ (   (  '.->-%%@`""&&""""&&""      A#*BL67116731133111#!1&'&'#3#5161'&'&'&7677''16767 ]!7 ' x 6 6 xh___2 /%%-::/@b0!))&&&&))!0V&&&**'$9w77632&'&'6767630101&'11&'&32767471163312#1!151"'&54763312121#!1"'&551476352711654'&#"374'11&#"327652711654'&#"3Z --DE-,"!&  &                  **.D----D9/0   0  @@  ` @ @ `        D9L&1'1&117711771676767676'&'&'&'&''4711632#"'&5 ] .. ] N)#"  "#)Nm    17 PP 71 ;;  (Sd7#&'&'1"'&54763332#153151#%3#32#11!1&'&'477151"'&5476335131'1&551#) @ 1O@@ v  v  01@;)   PF````@    @ OO ("131676716'&#!''3111'&''  !! )!! l   ]]]]  (="131676716'&#!''3111'&''7&'11&'&6767  !! 3   l   f *U67116'&'&&#7676723676745677&11237676'&'65&'&#"&'&'11&277676'&'&'45&'&'"#&'6'11&'&"#767367674'67%47176751&'#1"176'&'7'1&131276''167&'&'&  !              !          <  !]! =  x   !   =    !   !          !H=  -! ';'=  -! B4Av7&7116771633321##11###"'&547633367&'#11'&'%01110131010#111###"'&5514763317163332###31716011101#10103  $- %-#-NP @yw v  $- %-#-NP @yw  ] @ $  X  0 ^ @ $  X  0%Pk4711632#"'&5211#"'&54763211311&'&'6767&55167314763271167654'&'&#"374'67&551673147632311&'&'6534'11&'&#"3276765211#"'&54763211#"'&54763   0    +--DD--,   5  +--D/%&     P       P ''2D----D2''   `'"3 ''2D--'"'  `   0    `u4'11&#"111111#13!67&'#1716551515151514'&#"111'&7716'&'&111#151514''1&'&1''15155315131131513167&'#!3`  V `V  E   /@/   E@@    @;$cc$;@ @1\  #   4&> >&4   #  \1@@  3z&'&767'"''1#11'&7711'&7716321''%21111117676''1'1&54763211010111#1"''1&'5151514763!2111111##1&'&'5167710101717163211771655151514763@  -   &&  3     Cd 0 dC    3 YYY##Y  d (P(3   !.O d'f@8 8@f'd O.!   3(P( a211#"'&'&547676321111117676''1'1&54763211010111#1"''1&'5151514763!2111111##1&'&'5167710101717163211771655151514763@#### 3     Cd 0 dC    3 """"@ (P(3   !.O d'f@8 8@f'd O.!   3(P( @-He7'32771&'676726551&'&'&1'1&'&1271167654'&'&#"3713121'&771#1"'&77160  21K+$!!4#!   !#4!!/'!!!!''!!!!'0$`$` +8K12 6&'     '&6A,""&&""""&&"" 6H6H@-H[7'32771&'676726551&'&'&1'1&'&14'11&'&#"3276765'1''1&7617160  21K+$!!4#!   !#4!!/""&&""""&&""M H ( = +8K12 6&'     '&6A,D'!!!!''!!!!'+ H ( < @-HQ^7'32771&'676726551&'&'&1'1&'&1271167654'&'&#"35&'6751&'51670  21K+$!!4#!   !#4!!/'!!!!''!!!!' +8K12 6&'     '&6A,""&&""""&&""`PP@-HU7'32771&'676726551&'&'&1'1&'&14'11&'&#"3276765##1&'67310  21K+$!!4#!   !#4!!/""&&""""&&""@ +8K12 6&'     '&6A,D'!!!!''!!!!'@-Hj7'32771&'676726551&'&'&1'1&'&1271167654'&'&#"37531#11&'51#1&'673151670  21K+$!!4#!   !#4!!/'!!!!''!!!!'0000 +8K12 6&'     '&6A,""&&""""&&""000000@-Hj7'32771&'676726551&'&'&1'1&'&1271167654'&'&#"3771''11'&771'1&7617160  21K+$!!4#!   !#4!!/'!!!!''!!!!';$$$$ %% $$ %% +8K12 6&'     '&6A,""&&""""&&""%%%% $$ %% $$  )7i%3#3&'&'1#3#16767!1151&'&'#53#367675174'11&#"1327655131132765514'&#"1#15AAA = l '';M]m111163311#1131676751&'&'#151&'1#151&'&'#3#31#1&'516767311#1&'567311#1&'53#31#1&'5167%'#11'177&'1!1676'P G Iz  ( `        <<<=0J  {  \w z""  HH @  p  `  P  ccc@)z,: ,676'&'!!!67674''1&#"1'1&'10----E   0~   '((''((' OBYb&'11&111'1&'1151&'1#1"3!127654'&##1'111#17111#151%11771676''77311# ! l  C>BK5)Q !* p   ['#'   NKX^  !}  1Q^fsz676'&'571##1"'&551&'&56767315567&'67311##1"'&5676'&'5654'%&'&7675175654'111##1"'&551&'&5676731H. @  0 %.% 0  @ x$$$$P@ @  0 0 h   T2*B4' "0 '4B* 0" H   TTT  T*TTT*"+ +"0  0 /<&'&767676'&'"113!127654'&#!%676'&''76''167711331276551117711331276551176''1&'&##1"'1&'&##1"1&##1"1771133127655h  p @     $ 0 $   0   & "  " &   0 x     j111 D16 61D 1& &1 G ? ? G 1& &C 676'&'11132717676''13117676'11230176767410171677103271117676''1&''171117676'&''1'1&'&#"1'1&##%676'&'71327716771'1&'P      9t  G 2   "#&5  r< =(`   {  6 @!NX  \ 6A  %"< >>>; > $-2?LY11&'&''1&'&11327655131132765167716'&'&676'&'!676'&'1111132765513113276551133127654'&##1'1&'#     ;    ;    X        0 &+!#  #D  2 C#  #% `    ;$(5B%'%11'&'&767%16&'&767&'&767676'&'''1##1"'&5511'&77167633127167633121633121''11##1"'&5511'&771&''11##1"'&55111'P    !    8 0   & "  " &   0   $ 0 $    `(  111& &1 G ? ? G 1& &1 D16 61D  R|676'&'55311###3#"33!27654'&#!15117676''1&'&##1"1767715'1&#"132771654'&#"1514'&#"  @XXX x  :  : X P P   `````   /  a a  / P P   R|676'&'55311###3#"33!27654'&#!15117676''1&'&##1"176771''&#"132771132765511327654'  @XXX x  :  : PPP P    `````   /  a a  /GPPP P    Vc&'&7677'&'&7#1&'514'&#"11''1"'01&'&'&7477167633121'&'&767----??? <(  f  C $L#3 u'((''(('OOO  -% 02  P eG  3   J676'&'55311327655117676''1&'&##1"176771132765&#"1'1&1111771176''17171'1716'&1'     :  :    L (B  N ;; 28( L` /  a a  /  J E-  P 66 O)&E J Gc&'&767'7676''1&'#1"176771132765513113276556716751&'&'1675/// J-$ :     X  999  Y" a  0  pp l676'&'553113276513327654'&##151311#151#1131676751&'&'#11##"176771132765    8P @    MB :   `   @ 0    P a  0 @ E`s676'&'5#"'&5511'&'&77167633121&''11#"'&551#471167632#"'&'&57&1'1&17716'p(   :  -   ""&&""""&&"" = ( H   Ѐ 0  a J#/ '!!!!''!!!!'+ < ( H @ E`iv676'&'5#"'&5511'&'&77167633121&''11#"'&551#%211#"'&'&547676367&'516751&'p(   :  -   '!!!!''!!!!'  Ѐ 0  a J#/ ""&&""""&&""PP@ E`m676'&'5#"'&5511'&'&77167633121&''11#"'&551#471167632#"'&'&53&'#13167p(   :  -   ""&&""""&&""  Ѐ 0  a J#/ '!!!!''!!!!'@ E`676'&'5#"'&5511'&'&77167633121&''11#"'&551#%211#"'&'&5476763&'1#131167513167&'#15p(   :  -   '!!!!''!!!!'0000  Ѐ 0  a J#/ ""&&""""&&""P0000@ E`i676'&'5#"'&5511'&'&77167633121&''11#"'&551#%211#"'&'&547676367&''56751673111675171674'&'#1p(   :  -   '!!!!''!!!!'@ (   (   Ѐ 0  a J#/ ""&&""""&&""      @ E`676'&'5#"'&5511'&'&77167633121&''11#"'&551#%211#"'&'&54767636'&1'1&11771176''17p(   :  -   '!!!!''!!!!'; %% $$ %% $$  Ѐ 0  a J#/ ""&&""""&&""k $$ %% $$ %% Z&'&7673#313276551311327655131276''117676''1&'&##1"17677113&#"1'1&1111771176''17171'1716'&1'    &" 5 5 "& L (B  N ;; 27' L  ` `` `s8  YY  8sn J E-  P 66 O)&E JB3@y4'11&#"1167632716771676'&'&1'&'&'5676'&'&&'01&7676767677676'&'&'&0101&'   !i  i?=&$$$$ #+*#  &,21  12-&  #**#  )$# a   (          :JW211111311'&''1##1'&''11#"'&55167676765514763&'&767  !9W, &`\   .     )##P:  3  J J1((   }IV4'11&#"1132765514717676''13317676''1&'#1'11167655&'&767'76''171676''1716'&1'1&#"1'1&110113121117  .   \P& ,G9!p;;; O A' L L (B $'   ('2J J  3  :P##) 0  666 O  -F J J E- 1$B 2^&'&767553121'&''11#"'&5510101'671167101011#"'&551#1"'&7711'&'&77   ;   n  &" 5 a  0 ` `s9  Z@ HU}676'&'7713276551311327655117676''1&'#1"1767%&'&7675'1&17677113676751&'&'3167&'#1&176''      / J-$ : ) 0 788  0 0`000  9  Y" a  A  h;;;* `  87f(2   # 2HY316751&'1167674'#1"11331171&##7315117676''1&'5331276551#"" i6 M   b""p  Y.Z    Rnw67711#1&'3#3&'&'47''101'16331271&76111111'&'#3#"'&5511'&'&771671#'67&'""6662_  8 $L  V 6  L 9""ZZZn  ` @ 4 nZ  -;Hb~316751&##3#67674'533123'16551&'&'#1"7676'&'111331276551&'&'#654''1&1#13117771767513167&'#151&'&1Goow{{{ @$$$$   @@  XX  @H@  XX  @ A   o+ j       8    8 8    8  IVbo}676'&'5#"'&5511'&'&77167633121'&''11#"'&551#61''1&7!61'&77&77161'!''&761'(   :  ;   PPPP0PPPPPP  Ѐ /  a a  / YPPPPPPPPPP  &l21#1511'&'&77167633'676'&'%1171516731111311#11#1&'51#1"'&5514763516751&'673 ' 6  L%2i'((''(('  50,< ԮZ  p----Pt m8U \`   d%2`&113276517111327651&''676'&'553116751176''1&'&##1"1771167       &  &    -nn @ XXXX1 G G 1 Vn676'&'4311271117676''1&''171117676'&''1'1&'&#"117677167771327716771'1&'31127654''1316767&'&'#1"331#171654'&#"1  TG 2   "#3  < =([ D----D )) P P`i@!MX  \ 6A  %5   >>>; > $-w --DD--  )) P P Vn676'&'4311271117676''1&''171117676'&''1'1&'&#"117677167771327716771'1&'% "1#1"331132771654''  TG 2   "#3  < =(   P P`i@!MX  \ 6A  %5   >>>; > $-    P P Vn676'&'4311271117676''1&''171117676'&''1'1&'&#"117677167771327716771'1&'% "1#1"331132771654'''16751&'&'167516751&'&'1675  TG 2   "#3  < =(   P P`i@!MX  \ 6A  %5   >>>; > $-    P P00x00"# Vn676'&'4311271117676''1&''171117676'&''1'1&'&#"117677167771327716771'1&''&1'1&117677167716'  TG 1   "#3  < =(> 6 @ 7 @, `i@!MX  \ 6A  %5   >>>; > $-> 7 o   oL 6Qd11111771111237112367&'&54767'151&'&'4'11&'&#"3276765'1''1&761716: nn #M""&&""""&&""M H ( = Ti B1G+*  "#).&%,T'!!!!''!!!!'+ H ( < 6QZg11111771111237112367&'&54767'151&'&'271167654'&'&#"35&'6751&'5167: nn #M'!!!!''!!!!'Ti B1G+*  "#).&%,T""&&""""&&""`PP6Qs11111771111237112367&'&54767'151&'&'271167654'&'&#"3771''11'&771'1&761716: nn #M'!!!!''!!!!';$$$$ %% $$ %% Ti B1G+*  "#).&%,T""&&""""&&""%%%% $$ %% $$ ?Pt671167111'11111"#'11"#&'514771511'5147715"11131514'&#671167121##1"'&55147635f@: nn :P @ P""  bT:"G+   *+G1B iT 00 ""0   0  .;K^p111&'&'51673#3#1&'673#3#1&'676731#1&'7671&'&'57111&'&'51675&'516767'1&'5167675&'516767&71163!121#!1"'&551&'&'""x0000 pppp00""""P""""`""  %  %"" H`""""""""""  & &@!Mh"11131514'"11131514'&#"11311327655167&56767654'&#!271167654'&'&#"3713121'&771#1"'&7716` @  @  $#8  ##8 '!!!!''!!!!'0$`$` `` ``  ;++ C C=.- ""&&""""&&"" 6H6H@!Mh{"11131514'"11131514'&#"11311327655167&56767654'&#!4'11&'&#"3276765'1''1&761716` @  @  $#8  ##8  ""&&""""&&""M H ( =  `` ``  ;++ C C=.- '!!!!''!!!!'+ H ( < @!Mhq~"11131514'"11131514'&#"11311327655167&56767654'&#!271167654'&'&#"35&'6751&'5167` @  @  $#8  ##8 '!!!!''!!!!' `` ``  ;++ C C=.- ""&&""""&&""`PP@!Mhu"11131514'"11131514'&#"11311327655167&56767654'&#!4'11&'&#"3276765##1&'6731` @  @  $#8  ##8  ""&&""""&&""@ `` ``  ;++ C C=.- '!!!!''!!!!'@!Mh"11131514'"11131514'&#"11311327655167&56767654'&#!271167654'&'&#"37531#11&'51#1&'67315167` @  @  $#8  ##8 '!!!!''!!!!'0000 `` ``  ;++ C C=.- ""&&""""&&""000000@!Mh"11131514'"11131514'&#"11311327655167&56767654'&#!271167654'&'&#"3771''11'&771'1&761716` @  @  $#8  ##8 '!!!!''!!!!';$$$$ %% $$ %%  `` ``  ;++ C C=.- ""&&""""&&""%%%% $$ %% $$ (B\v''&#"11117711765'1716'&''"1113312765514'&##"1113312765514'&##53312765514'&##1"b4& // &4b       0000%54%   @   `@@@ @ )6C^"111327655171#1514'&##3#11317173#37171#11'71317171#3#313276514'&#"1   UU uJJJ[JZ*JJJ[J[ZJZJ UUU   U    @   6&2?s|!!!21#!1"'&51476316751&'&'167516751&'!!!1#113111##1"'&551&'&'513151#1"'&54763#3#1315`  @(()   )H( PPPP @  @@@@X@@8@@`)@ @)`@  @@@ Idw3#3132765513121&#"514'&#"1327#1"1#1&'&'4716763471167632#"'&'&57&1'1&17716'KKK  K+-%&   v""&&""""&&"" = ( H @ @ x#+ @  @ L '!!!!''!!!!'+ < ( H  Idmz3#3132765513121&#"514'&#"1327#1"1#1&'&'4716763211#"'&'&547676367&'516751&'KKK  K+-%&   v'!!!!''!!!!'@ @ x#+ @  @ L ""&&""""&&""PP Id3#3132765513121&#"514'&#"1327#1"1#1&'&'4716763211#"'&'&5476763776'&1'1&11771176''KKK  K+-%&   v'!!!!''!!!!'$$$ %% $$ %% $@ @ x#+ @  @ L ""&&""""&&""%%% $$ %% $$ % <Rc#3#"13151476321315167516767'1&'&##11#"'&555#"'&551476322111#15147635"13312765514'3&'&' KKKv  ,K  @    @ P  ""  @ @%-V @ @@@@ @  00 000   0""^'=671161516761516761516761#!5!!!2#!1"'&54763@ c c c  D@ @@  K        =F3#3111111##&'673151#1&'673151#1&'673151#1&'673151#1&'673!!!1!1#1131#1131#1131#1131##51515151515133 8 X``  XPPX(  ((  (XPPX<]3#3716'&'#1#3#0101010101!16767&'&'&'01&'&''''11'&771'1&761716/ /*) )@) )*//////////`G  G "#78R))R87#"//////////CUgz&1#11!10101#1516767113167#&'&'676767251&'&'#1'3#31#1&'51673#31#1&'5167713167&'#151&'4'11&'&#"3276765'61''1&7617Rv  @$%%%,;-%& v     @""&&""""&&""c H ( = [  `:) %%% #{ [@@@@ '!!!!''!!!!'+ H ( <CUgz&1#11!10101#1516767113167#&'&'676767251&'&'#1'3#31#1&'51673#31#1&'5167713167&'#151&'271167654'&'&#"35&'6751&'5167Rv  @$%%%,;-%& v     '!!!!''!!!!' [  `:) %%% #{ [@@@@ ""&&""""&&""`PPCUgz&1#11!10101#1516767113167#&'&'676767251&'&'#1'3#31#1&'51673#31#1&'5167713167&'#151&'271167654'&'&#"37'''11'&771'1&761716Rv  @$%%%,;-%& v     '!!!!''!!!!'$$$ %% $$ %% $ [  `:) %%% #{ [@@@@ ""&&""""&&""%%% $$ %% $$ %@=JZl|3#31#11311#151&'&'1#1&'&'5167673171514763&'&767%1316751&'#5316751&'#11316751&'#!1316751&'# pppOYf  fZ 0  p      @@p  p@@   @@@@@@p@@@@7I[h|61311&'&'1#1111310101!1&'&'167673175316751&'#15316751&'#17676'&'7531#1&'5167"11131514'&#671167121##1"'&55147635.v  00 @@  v    2222  @ P""   [ 0  0%` @ [@@@@@@@@H*,,**,,*x ` 00 ""0   0+9@71131514763311&'&'!17'&77167'&7716#3#17 ``` ` ` u  u``` ` 뀀?HQ&#"1767676'4'&''673121331277163111&'&'567&'7&'67  /.VV./ m (0( ))8`P3EEAB+ +BAEE3P 66 v))vEYb&#"1767676'4'&''3676751311311#11"''1&5477'3#311#"'&55167&'67  /.VV./ l, @"0 c ((0  P3EEAB+ +BAEE3P@ "3 * ~  00:&#"1767676'4'&''6711672171631''1&'  /.VV./ }S SP3EEAB+ +BAEE3PR R6Vb671167!11!1&'&'16751176751&'1'1&5167513167&'#1513167&'#13&'1675@L B B 000@`@A fn  fn @@@`P &N111!167671&'&'!676'&'6711671"''11'&'&77167615@@`P7 1 )@p  hf78  ` *;Zmv111!167671&'&'!76'&&'&'&'&76'&'&'67676'&76767672711654'&#"3&'67@@   X@>   531#1513167&'##131#1513167&'#1111&'51'1#1"'&5476331'1#1&'&'6767131'1###1&'&'676733'1514105676321167&'A))(((())+' $)# #b ))P))Pd+  )$_     E@M`"1'1&1111771132771176''17167&''1716'&1'1&#&'&7674'11&#"327654711632176765&'51&'&'1&#176765&'514763211!1"3!127654'&##151515 9 7 7 9 9 7  7 9 $$$$   8     """     X @ h 7 9 9 7 7 9 9 7 `  @   5 !   ! 5""" !   !     `@$7&'11&'!11!151476331577#1211#"'&54763@@`   @ @   @<CV&'11&'67676'3#36767311#1"1!1&'&'1676755312711654'&#"3               A'611###&''1&#1###"'&71677    P d          @K1''1&7615167171661112#!1"'&547633151716773#3'1&# PP (({    PPP= PH H $zz$      z v@+S&1!1716'&1176''1!11771654''&11333276551672133276''1&'' "m! PP !! PP    D <    H H  H H  v   @'O6'&1176''1!116751&'&'!17&11333276551672133276''1&''x PP !q""3!    D <   H H ((3""}  v   ?5]&151&'1'1&17716'!&151&'1'1&17716'&11333276551672133276''1&''(( PP `(( PP     D <  P $zz$ H H $zz$ H H7  v   A71131276''1&''1&&11333276551672133276''1&''       D <  zzz )     v   @,:5!1514'&#!1"#3#11675131167151#5&'5167@  (  @p@@@@@*7Ibo3#321!15147633#!11&'51#11&'1516751&'73#321!15147633#!11&'51#11&'1516751&'        `p@@   `p@@@5[dk|&117676'&5476'&'!11767654'&'&65&'&'1767713117676'#3#7131''#17'6'&76'&547%&7654'?         Q&&&L&}   &    2::2  '--'  '--'  2::2   --  . SSSS #''#   #''#GNY`gs61#1##11312##1"10##1"10##1"'&547633171#1"'&551"'&7677''13'7171'1#771'''1'3167&'#    E __ E    I;;;:uu??t .#n--- "vP P   P PC111155SCCC&&&&C+=M_o6711673113151671311##&'&'5316751&'#11316751&'#5316751&'#171316751&'#5316751&'#1%#11#"'&551#1&'&'67&56767  ` (  ` @           "  #))  HH     P  p    p   )# #) ))-%711'&71676171&547716321#"'XcccB  P Ac _`  cccA P  Bc  `_ (B\v1316731#1&'#11''1&'677164711633121##1"'&553#321##1"'&55147633!!!21#!1"'&5514763YX  XY/   ``` `    H  H `  `  @ @ @ @ @ @ ?JWd~671167!1131211112##1&'&'#1&'&'#1&'&'3#351'1#1676'&'%&'&767&1#13117716'' @ 3M  )))) M3  p''PP  0M @  )))) @M`0  A''PP?JWdy671167!1131211112##1&'&'#1&'&'#1&'&'3#351'1#1676'&'%&'&767%671167&'&'& @ 3M  )))) M3  p   0M @  )))) @M`0  !! !!MVcp671167313113112##1&'&'#1&'&'#1"'&5476351"'&551476353#3'1#1676'&'%&'&767 %4)5  ))))   `VVV++  p`$w  ))))  ` ``0  OXer111"131"33167673167673127654'3&'&'#1&505'1&'#1&'#3#31#15676'&'%&'&767''51671''11&'5167656751671&'&'5167`   ))))  5)4% ++++Vp  ### # }   `  ))))  w$```  0444+`  4+`  @@@@@  @>ht}111117711117711&551&'1151515151010151&'&'513167513113167516751&'&'!167311#17&'6767&'{2[ZX  PkQ @%R( !"Ra! +((+ !  O11a &;Ohu67!1!1&'67!1!1&'676'&'671167312#1"'&5&'11&'6331##'##1"'&54767633127676'&''&'&767PPS  3`V ` Rg3  0 ` ,  q--..0H$$$$     >0 /$$$$@'((''((' !5N[h~&'&767113316767&##13#32765&'&'#1"'&##1"3312767&'&'7&'&767676'&'"113!127654'&#!   V`RRR `g ` 0  3  --.. @ `$$$$    >/ 0$$$$`'((''(('    &2?Xew&176''!77716'&7716'&1!76''1&%676'&'31674'&'&'&##1""'676'&'11316767&##67&'&'#1"3'676'&')HH.HHHHHHPHH$$$$l&P($  8 FpF 85  HHHHHHHHHH  P  # %p  P p3@Qcx111!167671&'&'!471163!121#!1"'&5&'&767316767&##13#367&'&'#1"'&##1"31674'&'7&'&767676'&'`))))@  @ 8 Fm888F YP))$$$$)))@)`  @P    / &  & q  P   !3CXer3#367&'#1"1675676'&'11316767&##67&'&'#1"3#&'&##1"31674'7676'&''&'&76773#3167514'&##155&'133167&'#!31276551&'1#0XXXh   8 FpF 8Y)P)$  P  xXXX h8 hXh X hX  P &  &  p $$$$Xh `XXXh  hX"+FY471163332#1&'&'1"'&553151#471167632#"'&'&57&1'1&17716' @ 3) `@@""&&""""&&"" = ( H   ,9&!')  ````'!!!!''!!!!'+ < ( H 1:}"1131674741&'&'676705&547675127654'&##55311#11766767676'&76767&'&'&76'&'&'&''&7211#"'&5476367&'  ), @@@@xh  (  )r  ````X   ` 6'&177'&111&''1&111&''1&111327711327716''1&'7117414567&'71167&'716'&1&6'716'&1&''271167654'&'&#"35&'6751&'5167XX      E E '& ", $. +F.;  :. '!!!!''!!!!'XX '& *! &' *! &' D E  ! "2(  5 .< !!:. ""&&""""&&""`PP JS67116731111&'&'514'&#"1&'&'51676713276551#1&'&'7&'67)&&'&::&'    '&::&'  )`)&V:&''&:P   :&''&:P )+Ll"113!127654'&#!"113!127654'&#!'11771176''1716'&1'1&!&11771176''1716'&1'311771176''1716'&1'1&  @  @ 777777777777777777777777     777777777777777777777777A S&'&76753276551311327655131276''117676''1&'176771133       ;%::%: $$$$PPP PP P]%  N..N  %]r O&'&767&''1&'&11327655131132765167716'&'&1#"'"1"'  g% +   , $$$$i   ) `` +  @#*EX6711673113311#!1&'&'#3#51471167632#"'&'&57&1'1&17716' 8$#"`""&&""""&&"" = ( H  '.->-%%@'!!!!''!!!!'+ < ( H @#*Ee6711673113311#!1&'&'#3#51211#"'&'&54767636'&1'1&11771176''17 8$#"0'!!!!''!!!!'; %% $$ %% $$ '.->-%%@`""&&""""&&""k $$ %% $$ %%/^kx3#3110101#1!3#31#1'1'1&##1'14#67655#3#13167671&'&'!11!117676''131##3#01015147&'&767@.@ DLG)"I...+    ! TJ(JJJEJ  ('2J@[?##) @ `   2  ~0Jg  [67116713276765&'51&'&'1&#13276765&'516767113276551515 ..""33""3""..  H 66 3""""3""3 66    5>%51#!"'&54763!151!1"'&551'1&'&5477167632155%11! P@   $$$*)%F@   0 u  /! 9IOi|"1'&77167!11''1&##113111#1"''1#11##1&'&771&'5167673151#"1113312765514'&##4'11&#"327652711654'&#"3W  **  q()#B( 77 (B#)(qI     `      0)/B 77 B/)0p          +4=FO`671167!11#11311#11311!1&'&'353151#3#3#131553151#53151#%"11131514'&#671167121##1"'&55147635 C8XXXXXXXXXX@ @ P""  `A@ %@@@@@@@@@@@@@@@@@p 00 ""0   0+4=FO`671167!11#11311#11311!1&'&'53151#3#3#1315#3#1315353151#%"11131514'&#671167121##1"'&55147635 C8@XXXXXXXXXX8XX@ @ P""  `A@ %@@@@@@@@@@@@@@@p 00 ""0   0:171&567671#1&''1&'&56767171&'6767tjh   q((q   hj!]    $$    ]!/<K&176''1676''1&''13127654'&#!1"3311'''13353276551#' P  9     %  @ 0 u @   Pttt+ ``` `+4=FO671167!11#11311#11311!1&'&'53151#3#3#1315#3#1315353151#%53321##1"'&5514763516767#14'&#" C8@XXXXXXXXXX8XX P  ""0  `A@ %@@@@@@@@@@@@@@@P000   0"" 113111#11#1"13312765514'&##15147633111#1"13312765514'&##151713121#1"13312765514'&##151&'&'#1'151316767&'&'!P  08% @  80 @ 08  @ %80    (0%0 @ @ 0 0( @ @ (0 0 @ @ 0%0(  <}%27476771&567672&'&'101"110101010136767371176767317676'&'&'11#1&'7136767&'&'1& /) DD^H9:""/ ,&#08I J J! " *)H-.//:E4%    9= !(B6711673113311#151&'&'#1#3#513#321##1"'&5514763 ``` `  @ ` ` %.7@IR111!151#1"'&551#3531'3#351#1#3#1315##3#1315##3#5!56767#755#113@ @@@@ PPPPpPPPPp@@@@@@@ `@@ @@@@@@@@ @@@@67&'&'1'16'&176'71&'1&'5167116767&'516717676'&'&'5167676'&'&1711'145&'5P  23PP  23PU##b.!  Z  !Z.#b##b.!  Z  !Z.#b@]t67&'&'1'16'&176'71&'1&'5167116767&'&'5167167'145&'5&'11&171263236'271167654'&'&#"3713121'&771#1"'&7716P  23P    23!& '!!!!''!!!!'0$`$`U##b.!  Z  !Z.#b#b#c ! ""&&""""&&"" 6H6H3CSd~671167!11!1&'&'"1113312765514'&##433121##1"55716751&'#16751&'#153312765514'&##1"73#321##1"55143@      `     ,  `@ 0 0 ,00,L`L`000 0 00'.11#1"33327654'&##151716'&'!''!1  @ `` @ @&ֳ   ӓ211&'&'676725111&'&'67672515167%16 ))))))@  H"""M"""H` 7%1#"''1&'&'6767271167654'&'&#"3' ~5FX;;;;XX;;'!!!!''!!!!'F5~ ';;XX;;;;X""&&""""&&""%7'327716751&'&'&1'1&'&10  /!!4#!   !#4!!/ ,A6&'     '&6A,,'&'1111771176''1716'&''1'=  @hh @g DD g07271167654'&'&#"3113!12765&'&'#####.K32    23K\""""023K   K32 +;M]o671167!11!1&'&'5316751&'#1%1316751&'#%5316751&'#1%1316751&'#%5316751&'#1%1316751&'#53312765514'&##1""1113312765514'&##0  p    p    p      `@    p    p     @@@ @  @ @ #=5#15135#1513'#3#51313#31#15111!167671&'&'!ࠠ`@@@ "+4=FOXaj111!167671&'&'!5#151333#31#1535#15133#31#1535#151333#31#155#151333#31#1535#1513@XXX8XXXXXXXXXXXX@XXXXXX8XXXXXX@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"+4=FO671167!11!1&'&'353151#!!!!1!1553151#!!!!1!1553151#!!!!1!15@@@@@@@`@@@@@@@@@@@@@@@@@@@ `111#"''1&547632171632 i W j  ``165114'&#"1'1&#"11327711327654''17W ii jj ii jj) jj ii jj ii<%1#"''1&'&'676767513167&'#151&'1#131' ~5FX;;;;XX;;@@@@F5~ ';;XX;;;;XX@@@@(%1#"''1&'&'6767%3167&'#' ~5FX;;;;XX;;F5~ ';;XX;;;;XL4'11&#"132765567116'&'&6767674'&'&&'&'4767    ) 66CC66 (  21KK21  Y "/08C66  66C80/" ##)K1221K)## `-CZp2111#"'&5147632111#"'&514763#"'&51476322111#"'&55147635#"'&55147632@    `     `    @  `  `   @   @@@ @  `m111''11#"'&''1&'1'&''1&'&771&547'1&76771676167716763217161676'&' ,,   8  8   ,,   8  8  ---- ( (   ::   ' (   99  '((''(('AZ%11#111##1"#"###"'&551514'&##1"11###"#"#"##1"'&5514551#1&'&547%1621@  ! @        @ @ pE   .11&'&'&54767675176''151&'F::$""$::FF::$""$::F ` U!"<=CC=<"!!"<=CC=<"!x @ 9{@8N#3#"131514763213167674'1&'&##11#"'&555#"'&55147632KKKv  vK  @     @ @ L @ @@@@ @ )MV4'11&#"1'1&#"132771654'&#"15111!1676751&'&'#11#"''1#&'67  I Ie.-fp J J  --8!:"1111!16767514''1&'&#!!!!1#11#1&''1&'#17y9903  x  30 \\ @F#3#"3312765514'&#"1'1&'&767654'&#"#"'&547632222   ,9999,,,,9999, 1@@1//1@@1   3,,,9999,,, //1@@1//<7676321#1"3310101112765514'&#"1'1&'&76713276551101767676'&'&#"'11'13127654'&##1"##i 1@@1" p  ,9999,% B  ,9999,%  1@@1" p"//  p #,,%.  Vp #,,%.  !//  @,?R^jv671167!11!1&'&'2711654'&#"374'11&#"327652711654'&#"373167&'#3167&'#3167&'#@       ``@        ``653151&'&'5567671311!1&'&'5167673""@()==)(00000""0000=)(()=054'11&#"11132765517167716751&'&1#"'&15@   @@;EI"  $&E  p "  B11631&'&'515151676767111&'&'5167672&'&'Q99   """:9HH9:"""   99Qp32O  "00H9:"""":9H00"  O23@&'&1#11311767@DD  x@x  -1''1#1&'&'51676731716'&767&'&76-DDp!!     x@x //  1B_11'&767654'&'&7611'&767&'&76'&767&'&76'1''1#1&'&'5167673171611 )) =!! 33 C66  h`"!7 ./9K0:$$''BAQA7 ;6676&'&'&'676727676'&1'&'&'&3)% 32??32++GC%      1 &.  @55  55@%1111"'"'&70101010101010101510107676767&'676767"":9H80#&, /"":9HH9:"":// %4E:////: 1B567676751#11&'&'51#53#3514'&##1"!3#3514'&##1"32??23)) @ @ @  ```?2332?``))` @ @@ @ ``631121#"''11#"'&5477 W   73112771654'&#"1'1&#" ) E-[%2711654'&##1"'&55131676''1&#"13113"1133121#11327716'&'#151&'&'# p  @ @ )p  p  @ @  )p  @ @)@  @ @)>,9F6731!11#!11!1!1"'&'1&##1&'676'&'%&'&767." ) 4.P  H  0!!!!67671&'&'#1"''1&'#11@    D1771676731213311!167!11!1&'&77YYYYvu$  p p p   = "1327711'1&#"132771654'&#"111327654'' ` )) ` ` )) ` ` ** ` ` *&* `@@=%77654''1&#"1!171654'&#"11327654''1!11327``` ` ** ` ` *&* I``` ` )) ` ` ))  7Mc2111!12#!1&'&'14763471163312##1"'&53#32##1"'&54763!!!2#!1"'&54763   p" `          "P `  @   `   ?L77311#1&'#1513127!167671&'&'#1"1#151&'#11676'&'222s!,,!s 3 @*,,**,,*G`@ @2222,9%671167&'&'113167513167513127713&'&767PK1221KK12P(( !(  `21KK1221K P((!xan6'&''1&'&1&''1&' "1'1&11117711327677167176771676''1654'7676'&'76771676''1677167654'&''1&'716'&''1&'&1&#"'1&111111771327'&'&7675                        )  9              )            (Y7671167&'&'1#10101676771167676'010101011105"1&'&'&'67&'&'X;;;;XX;;'  " /:=>Z66I:/ "   '66S`21KK1221K;,   V88 9#$   ,;G11111177123#  @hg D)W%65114''1&#"1#1"33113277%2711654'&##113127654'&##1"'&5147633 J J  @))@ @ @ I  I  ))   .=471163!12##111#!1"'&7716771#1"'&53#31#"'&55   9  9  @@@    @ @ ` `)]"11331132771132765514'&##111!16767514'&#"1!1&'1673127654'&##@ S  ""@"  p p  S  """p p@  -W3#321##1"33167671&'&'#1"365114''1&#"1#1"33113277`@@@ @ @))@  J J `   ))  I  I @M[h#3##1##1"33127654'&##1"'&5476767676767&'#1654'&'3#3&'&'&'676731 j#!%%    %%""j TTT&##&T E21!       !12E pC//!##1!//C1##(LU5#"'&5511#"'&547716321#"''3#36767311!1&'&'51676767&'  I IpS J J  h2E&'11&'"'&27676767676'&7676511'&767676 998,+ 998,+*  %%2 `+,899 +,899   * 2%%'&'11&167716'&''1&1&'&'716'' X< ?  //  ? > -- > ?  ..  ? > --  ? > -- > ?  ..  ? > -- > ?  //%<R211##1513211##1"'&547633711##1"'&54763312211##1"'&547633'3#3#1&'&'51677167311#"'&551&'1 Р @ @@ 0 0 ` @ @X  D--. %5  `  @   @     `--D>B/ %X 88%<R"1133151#"1133127654'&##'1133127654'&##1""1133127654'&##7#3#31676751&''1&'#113276551671  Р @ @@ 0 0 ` @ @X  D--. &5  `  @   @     `--D>B/ %X 88%<R47116321#1547116321#"'&55'2111#"'&551476347116321#"'&55553273271#1&''1&'516767312##1316767  @   @     `--D>B/ %X 88 Р @ @@ 0 0 ` @ @X  D--. &5  %<R113276551#171132765514'&#"271165514'&#"1371132765514'&#"'56326763251&'&'#1113127654'&##1&'6731  @   @     `--D>B/ %X 88  Р @ @@ 0 0 ` @ @X  D--. %5  4%&'11&'&#"3276767%6131#11''1&77!"<=CC=<"!!"<=CC=<"!GGppF::$""$::FF::$""$::FGGpp47113276767&'&'&#"'&771#1&'6731'1&761!"<=CC=<"!!"<=CC=<"!)GGppF::$""$::FF::$""$::FGGpp4671167654'&'&'''11&'511'&7716F::$""$::FF::$""$::FGGpp@!"<=CC=<"!!"<=CC=<"!)GGpp4116767654'&'&'&761516717161''F::$""$::FF::$""$::FGGpp!"<=CC=<"!!"<=CC=<"!GGpp  $4>L[cm%#1&5473173#3#1654'7#3#&'##3#676766##3#67673#3#1&547&'31''&''&'&'3!11673`{{{{pttt(<-,   ttt,-<({{{{  <(<-,tf,-;'u!!!!@!!!! b6'(87(##(78('6b !!!!(77(##_b6'(88('6b4=%6711674'&'&1##1&'5147716'&'&#127713&'67`D--M9MD-- --DL9M--D X)@Wn{1#"''1&7617161#"''1&7617167471163312##1"'&5471163312##1"'&5471163!12#!1"'&5'&'&767 H (7 H (7H     @    p  P(= P(= f      067!111''1&551'1&7  @    0 O /P3#31#151675#113!51&'&'#151&'&'#1#3#1##1"'&551#11!1676758@@@ @ (((((``(   a "1311#151&'&1176751311#11327716'&'#151311771654''1&1#15131676'' @  `@ @`  @ @  `@ @`  @ @` @ @  `@ @`  @ @  `@ 0Fat&'&767!&'&7676711673120101#1&'011101674'6331#'471167632#"'&'&567116731!1&'----p----.*))*.ֵ   `&&8v8&&'((''((''((''(('. ;%%; .`  8&&&&8n={%65114'&'&177161#"'&'&7716'&'&13277%11771676'&'&1'&'&547716321767716'&'&#"D**'43,  q  &-9:-p**'43-  p  &-9:,q-:9-%  !q  ,43'**p-:9-%  !q  ,43'**p(711!16767&'&'65&'&'"&'&'01()=p6%$,)$$-D--+p=)($%6/"# )$--D$$0.@#3#"311!167674''1&55127654'&##553111#17165   m 6 l   `@#"    Ņ$88$0=JW''65&'&'2711&#67674'16'&#"'3276''1'676'&'&'&767''' 00  0''0  00  vvv @0  '''0  00 '( 00  0 vvv @  =3#3211#1&'&'167673#31#113151311#1&'&'16767|||D   PPP@@   D    @ 0    N&11"1327716321#"'&547716321#"'&547716321771654'l !++! 3AA300%//%##  l!++!  003AA3##%//% 5B111!16767514''1&##4711633121##1"'&55&'&767@@M   $$$$M` @ @  671167!11!1&'&'@`@-D471163!12#!1"'&5471163!12#!1"'&511#!1"'&54763!12        `        "8N[h676'&'7"113!127654'&#!"113!127654'&#!"113!127654'&#!676'&'7&'&767@             00P       P  AWm6731131#1&'673151#1&'&1'&771676131#1&'&7716'!!!2#!1"'&54763!!!2#!1"'&54763!!!2#!1"'&54763 P?  #!X H      x`  &  N        @y6767676'&'&'&'&01#1"3!127654'&##111#1&'&'&7'&'&'"1&'&'&2010101010101117676'#1!8    E7: ]  7 !8  E7:L 0   @#        @ F]471163312##11676751#1"'&54763312##11&'&'51#1"'&5471163!12#!1"'&5 ` )) ` --DD--      ))   D----D   #=755311#3#31#1555311#7#3#5131%111!167671&'&'!@ࠠ````@`````````@"&51147163211#"''77'11}##Niiii}##iiii?JWd1113167673167673127654'�''1&##151&'&'!3#311#15676'&'%&'&7670  ))))  M3 p333Mp    ))))  @ M0 M`  0@#-7A\111!167671&'&'!#3#51'55316711671#7&'11&'31'211#"'&'&5476763@@@@@@@@@@@  @@@@@@   @E731127716'&'!1   I E@ "1!1676''   7 e7&511477161''    @e765114''1&177    "+671167!11!1&'&'311#!#3#131@`@@E'631121!1&'&77''&767!11#"'       R E#11"''1&767!1    E "1!1676''    ,11177167&'&'!5!16767511#"''0  `0   pУ F3#32##1"'&55147632171676'&'&547632327654'&#"~222   ,9999,,,,9999, 1@@1//1@@1   3,,,9999,,, //1@@1//9[ "113277111132771654''1&#"1'171654'' "1132771654''171'11'? x  j  x  j  p 0 p ;-; x  j  x  j  p 0 p ;-;6'&13117%16'&'#17]  pM oL  @671167311#11311311#1&'&'5167673151&'#11311#1&'&'5167673151#11311#1&'&'516767315167673151#1&'&'5 @    @    @    @   p  @ (  @  @  ( @  @ (  @  @  ( @>>_2111'&'&#&'&'&'&'&'&'"'&5676751476321"'&''1&767613675163  eEF  FEe  "      @@`    `@@  s"    s "@I#1131167673151&'&'#1&'1111316767514''1&##'&'67%9  "0 9%p   DL  "    DXp#4E%67114101016767&'&'10101367116751#11&'6767 21KK12 P""P 0"@.' +9K1221K9+ '/""P0 ")S65114''1&#"1!1"3!11327731127654''1!127654'&#!171654'&#"1 ` * 3* ` *3 * ` `) ` )  ) ` )  ) ` `%A&'11&'676745676763!7'7716'&151&'1'1&=)(+--D-$$),$%6OPPPP'' ()=0$$D--$) #"/6%$PPPP''%?&'11&'676745676763!777116751176''1&=)(+--D-$$),$%6O''PP ()=0$$D--$) #"/6%$''PPt}7271167654'&'&#"3113!12765&'&'11#1&'67514'&#"1#1&'51476751&##1"1&'&'4767567&'####`9##    ##9     \   """"7.->   >-.3( (9A; 0^q1111676751'1&'&767611676751&'&567671&'&'&'&'5147677162711654'&#"3 ))   #$7,0  "" 21KG119#$  R    y))y  y;+* + 0G "" GK12-.F ++;y    &8J53151&'#155676731111!115#3#31#1&'&'16767#3#13110@  ((((((((( ` ,7"11111!1676''1&'51&'&'514'&#65##327 8#$/    0$#8 -@@  ++;H7  6I;++  ,B471163!3#1#1&'&'53#36767&'&'#1!!!2#!1"'&54763` @@6%$$%6 ))  @   $%66%$))   Ek671167311#151&'&'1#13#31#1&'&'513167&'#1513167&'#1516767!111#1311#1311#113%1#11311316751316751&'#151&'#  P  Ppppp PPPP   PPPP pp  0P  P0` @0  0@  ?JWd671167!1131211112##1&'&'#1&'&'#1&'&'3#351'1#1676'&'%&'&7675#11311316751316751&'#151&'#1 @ 3M  )))) M3  p00 00   0M @  )))) @M`0  P000 00 0 '8Iq3#31#15167511!115151&'&'#1#3#1313#367671&'&'#167311311#11#1&'51#1&'51673158  @   00 00((((( ` ((0 00 0Xd6731#1131211##1131#1&'673151#11##1"'&551"'&5476351476331213151#1&'3167&'#pht ff thp 7     7 P@@&&7 @  @ 7 )6BNZ471163!12131111#1&'&'776551&'#1'&'16753&'16753&'1675   3! R`888 3@@  !f %"`f =111!167671&'&'!51&'51#11&'51671315167@@@xhhhhPPPP;111!167671&'&'!55#1&'67315167131#11&'@@@@@@@@@@@@@ ;7111327654''171654'&#"%71327654''171654'&#") ` @;%65114''1&#"11327777654''1&#"11327  ; "1327711327654''''&#"1327711327654'   ;#11"''1&5476321716327#"''1&547632171632  `  7111327654''171654'&#") @ %111#"'&54771'1&547632  `@631121#"''11#"'&5477 7  @ 73112771654'&#"1'1&#" I )111311!11311&'&'!!16767&'!@@m!!!!,111!167671&'&'!211#"'&54763@@  p   p,1113167671&'&'#211#"'&54763Pp  p    `/_7671167312##11311#1&'&'51515!671167312##11311#1&'&'51515""3 @@""3 @@3""  @ H3""  @ H `/_%11#1"'&5476331676751#1&'&'5167673111!11#1"'&5476331676751#1&'&'5167673111""3 @@""3 @@3""  @ H3""  @ H &3@MZ&'&767&'&767%676'&'%&'&7676'&'&76'&'&77676'&0    `  0  &671167654'&'&'F::$""$::FF::$""$::F@!"<=CC=<"!!"<=CC=<"!5H[671167654'&'&''1167676&'&'&76'6711632#"'&'7211#"'&'6763F::$""$::FF::$""$::F\!! ))       @!"<=CC=<"!!"<=CC=<"!    v     3FY671167654'&'&'''&76767'&'&''6711632#"'&'7211#"'&'6763F::$""$::FF::$""$::Fa  ""..""   ##       @!"<=CC=<"!!"<=CC=<"!{ ((      -@N671167654'&'&'211#"'&'67636711632#"'&'3#3#1&'67F::$""$::FF::$""$::FP      @!"<=CC=<"!!"<=CC=<"!P     "/O11!16767&'&'!&'&767676'&''67131#11&'51#1&'67315R6666RR6666R0  h    66RR6666RR66h  h    @+;M]o111!167671&'&'!3#31#1&'516767311#1&'53#31#1&'5167767311#1&'53#31#1&'516767311#1&'573#31#1&'516767311#1&'573#31#1&'516767311#1&'573#31#1&'516767311#1&'53#31#1&'5167@@      P    p    p    p      @  p  P    P  p    p  p  p  p  p  P  8y211171632771611'&11#"'&551511514763771117167517165111'1&'151151&''151&'&'1&1511771511'755#177  E;7#&&$  "IE;@@   @@@@1' * ! ) @@!   "` PB  BA @ @C G F@ > HKI HNFFF E@3&5114763211#"'&54771'!!!2#!1"'&54763     i   5T&11176716'&'111132771654''1&#"! "11327654''171654'   P ZZ p p p p ZZ  @   x YY p p p p YY @D&1176''1716'&'&11767513127676767&'&'#15  )  21K0    @)  %%8K12@ 6'&13117 d `T77654'&#"1#1131114'&#"1#1"33113151#171132765513127654'&##1777 6        S666 7@3   @   Ybk67&'71116331676751&'&567671#11&'&'47675151&'&567673&'6767&'PP #` "" $%6` ""  ""X X "" 6%$ ""  ""7AKn&176''171654'&'&177161'16'&'&'&'611'''7%7771676'&'&1'&'&54771'' P [**'43,  `  )55,s-&&&999**'43-  =2 0 oZ-:9-%  !`)+,!'!s !*Z>0 888-:9-%  !>( 9676'&'4711633121312##1"'&547633151#1"'&500 @     p      !k4'&131"33327654'"1133111#1"3312771133127654'&##1'1713127654'&##1"1'1&##     @ ZZ   VV   ZZ   VV    P     zz   zzIk"1133111#1"3312771133127654'&##1'1713127654'&##1"1'1&##4'&131"33327654'  ZZ   VV   ZZ   VV          zz   zz  P   ' #.7133327654'&##171654''1&#"#3#'1711#Pi | rP|DP  P}Cp&'&'67673116767&'&'1#1&'6767&'&'#1&'&'51676767&'&'&'5167673167  9      9  y      yW     9  y      y  9 pH111676751&'&'&'11#13367&'#151676751&'1&'&'5))))+*B0HH0B*+$%66%$))))(D00 "" 00D((6%$$%6('O&176''16751&'1'151&'&'1'67'1#&'&'51'111#13367&'#15' P ))1+6%$/+*B0HH0 0 |(1(( ))6W"$%6 %(D00 ""21'&'&'&747677163 /.VV./ P3EEAB+ +BAEE3P->5#11!151&'&'#1514'&#"1#1514'&#"!!!1!16767`0  0   `@@ `   00       @QZ1''1&'#111#151476751'&76767514763312131677165#1&'&'51367&' A8 ! *   A `p `  #""5 &    g  @5B7''&767#1"'&7716731676767611'&551'7676'&' j5)R*2211%<"Y    ? Y"<%1122*R)5k ,%&'11&'&#"3276767'611''1&77!"<=CC=<"!!"<=CC=<"!WWhhF::$""$::FF::$""$::FyWWhh,7113276767&'&'&#"'&771'1&761!"<=CC=<"!!"<=CC=<"!WWhhF::$""$::FF::$""$::FyWWhh,671167654'&'&'7''11'&7716F::$""$::FF::$""$::FyWWhh@!"<=CC=<"!!"<=CC=<"!WWhh,116767654'&'&'&7617161''F::$""$::FF::$""$::FyWWhh!"<=CC=<"!!"<=CC=<"!WWhhG|11#"'&54763267&'&'#1"3311#1&'&'51176''1&1771133676751176''1&17711#151312767&'&##@   ))))   0)88--DPPD--88)0  `  P4))4  )88D----D88)  8N111311!1&'&'51676731516767'&'&'&#2711654'&##1"33"()=,""    @ @"00=)(%     5B]p%4'11&'&#"3276765!671167632#"'&'&'676'&'5211#"'&'&54767634711632#"'&5--33----33--@!"<=CC=<"!!"<=CC=<"!----'!!!!''!!!!'   4,,,,44,,,,4F::$""$::FF::$""$::FP'((''(('""&&""""&&""   &7676'&'3676'&'7&'&767       8 &7676'&'5676'&'7&'&767@     8Xh   ,=P111!167671&'&'!67&'&'&'&'67&'&'&'&'4711632#"'&5@@ E88!!98UA*+,   @h!!88EU89`+*A,x  -7671167632#"'&'&'71771654''1&!"<=CC=<"!!"<=CC=<"! F::$""$::FF::$""$::FmX X@-?Y1111!1676751&'&'676751&'&'!5!16751&'!1'471163!121#!1"'&55@@@  @  @ "" @@ "" @p  '111!167671&'&'!3#3#1&'67@@X@`57"11331676711327654''1&#"1327711##  `)I I `  )3J J `5"'11&54763311716321#"''1&547632114'&##  `)I I `  )J J3 -111!167671&'&'!7''1&761716@@@/o@@/o+?111!167671&'&'!'1'17163277111'&77167@@ G  iiiGi < @l  G iiiGi < 3111!1&'&'16767!31177116751&'#@^@pf06h%#3##1"'&'&'&'676731514763211##1"'&55%1!16751476321!1&'&'16767312##`...#  ()=P   @  """0 0#  /=)(= |  } @0 0""@"  0C671167654'&'&'77'&771677161'4'11&#"32765F::$""$::FF::$""$::F3 8  8    @!"<=CC=<"!!"<=CC=<"!888  8  E  ,6711671&'&'!11!'"''1&767311#@ h  h @p    p,111!167671&'&'!21#1&'&77163@@ h  h @p    p,&'11&'!11!167671'&'516761@p    p`@ h  h @g711011#1"3313127654'&##1&'&'3127654'&##14551453127654'&##167673127654'&##1#1"330 66H ,##~  ~##, H66   @'(  $    $  ('@  BQ671167217676'&''1&#1#1"33111!127654'&##15165513127654'&##15p Q  Q6$%    p p  %$6@  -2  &,-  @+:471163311'&''1#11#"'&55153#36767&'&'#131'110101&'&'e&#&'&'&7676010107676'&'&''1&'&'&7676'&'&'& P=)('4 8*  @000""0   $"'     ##'      ()=-#"   ""   +    + BY&'11&1#1"3311#1"331132765513127654'&##1513127654'&##1716'&'&1'; _4 PP P  P PP 4_ ee    @ @    GW"111#1"3311#1"331132765513127654'&##151316767&'&'##3#5131`       p=)(()=pppp""       ()==)(""OV]d&'11&1#1"33113677131127713127654'&##1716'&'&1#1'1&'1#1'3#31'7771#3#31'> 2 )9*.*9) 2 9@**@9N m`       ..@@..$6711673113311!1&'&'#3#51  @$2@N111!167671#1"'&551#3531'3#3#1&'673#3#1&'673#3#1&'67@  @@''Nqx#"''1&767611476321716767471163311312##1&'&771#1"'&511'&''1#11'&'&77171673#3'1  X    X  J3  J3 ` @ X @ ((( `  $. $  ` I  I      ((''Nqx&#"176771132765117676''1133113127654'&##1716'&'#1"11767713117676''1'1&'771#  X    X 3J  3J  ` @ X @ ( `  $ .$  ` I  I      ((((@'=Si#"''1&76761147632171676"'11&54763312##5"'11&54763312##5"'11&54763312##5"'11&54763312##  X    X     ` `     `  $. $  `         @'=Si&#"176771132765117676''3#327654'&##1"353#327654'&##1"353#327654'&##1"353#327654'&##1"3  X    X    ``` `      `  $ .$  `J         '*Sf&17711#1"33327654'&##1514'27716'&'&114'&#"1'1&'&13%611'&'&76777677165&'&'0   00   X    X     1%%  4   ` F `  $. $  `   q  B$%% '*Sf1312###"'&5476331511'&'&767716%21'&''11#"'&511'&'&7716367116'&'&7&'11&567671'&'&77  00   0 X    X    )%%1  `   4   `  $ .$  `   7 %%$B  <V11131#1"''1&'515151677167716763#321##1"'&55147639    a&*#) @@@ @  (#   "  3&0.!3     <V67116''1&'316767&'674'&'65&'65&'&'#1"1111117%3#32765514'&##1"139    a&*#) @@@ @  (#   "  3&0.!3  _    `)3112771654'&#"114'&#"1'1&#" I  I 7 Js J  `) "13277113276511327654'' I  I  J sJ  `)7111327654''1!127654'&#!171654'&#" Js J I  I  `)%65114''1&#"1!1"3!113277 J sJ I  I B Y&'&767#3#"'&7711'&'&77167633121'&''11##11#"'&551#11#"'&55  H&" 5 5 "&    s9  ZZ  9s` `` `B I676'&'5#"'&5511'&'&77167633121'&''11#"'&551#p(   :  ;     Ѐ 0  a a  0 @[v111111''11'&''1'1&'&771'1&76771716761716471167632#"'&'&534'11&'&#"3276765jl>>lZZl>>lZZ   """"lZZl>>lZZl>>  ####&1111676'&#&'&'47676'&'&#?2332?]> J21(  32??23= 21K2(( *7!!!21#!1"'&5514763!!!1!1&'&'3167&'#1 @ @ @     P111##1"'&551676763112106331247716321312##11#"''151&'1&'1#"'&5477167&5#1"'&547633167&''1&547) ) @p@ @ @ @@ ?%55%? @@ @ @ )  )i @ @ @  % @ ?!!? @ %  @ ,711!167671&'&'!17477161''1&5@p    p @ h  h 5671167654'&'&'211#"'&'&5476763F::$""$::FF::$""$::F  @!"<=CC=<"!!"<=CC=<"!`    -n676'&'6'&67676'&#&'&'67677''&'&#131233121771676'&'&1'1&'&##1'13127654'&##  G /--D.%%  !0 !  ^ $ 0   E ? L` ((4D--'  0$ G  t a  D0  Bi671167217676'&''1&#1#1"3311#1"3311!127654'&##151673127654'&##1513127654'&##15p Q  Q6$%      q pp p  %$6   2  "    Qc2771#113''&##113!55#1131"1113#1131513167!127676'&'&#!1&'#5#"55147>5kkkk5>   ) 5.." "..5)  @``@@@ ```` 0  0 `,,t W )A111!167671&'&'!''67!11#&'771#!1"'&5511327@@  @ddddYYY~ ~YL_71!16751676''1&#3#1#1!1676''1"1"551#11#151#11#151#11#157211#"'&54763 s@@@00@(@0@(  ```  `     @V"11117676'&'51676771611327%167&'%1&#116767'11#"''1@ : @     66RR66e'1,%B*.$ > =:ee33"8?6711673!1!!&'&'!!11!&'177131176'''#17%133#111''1&'1'&77167'1&761167##&'67315167@@ @ J @& ,     #H4@0    9++++E$      7M`s53151311131514''1&##1331276514'&##1"!!!13!1276514'&#211#"'&547634711632#"'&5211#"'&547634711632#"'&5@@     ` @   `        ````CC`@ @    @     `     '7IYk{1113151676713167671&'&'!67311#1&'573#31#1&'516767311#1&'5'3#31#1&'516767311#1&'573#31#1&'51670  `  `    p  P    P  p   ` P  P              B G676'&'5#"'&5511'&'&771676321'&''11#"'&551#`  0   ($$(   $$$$``` !  ??  ! `%Pcv11'&'&767611'&'&767667116711661#"''1&1#"'&55147%&'11&7676''&'11&7676'   $#"!!"#$ XX ap  c! !! !j  F'&&'F  v   ] !! !!(16111''1&'&551476777171'77511   DDDD<>>>>>>9999@ =FR[eq'1'17165"11177117716751&''1—&''1&175171'1'1716557117611'17751711#NNNQQN`"!`qr` "`"``"RRRRNNNQQNRRNQQNfMMMR ,ppp$&w#* 11 *$w&$p&$$&vY Z(ddd `$"""d [)Z6717161''1&'&771'1&'1'&'&776111#11''1&771613127654''1&767%''&7677161''113312##1&'&'47744' W &    )` @@ `   W 3    )2,,> X <   ()  @@   ' W R   )P GZm7!1'1&'#1776763312111##1"'&551!11##1"'&5515147674'11&#"327652711654'&#"3&_###  #     X      KKKKKPeeee0 00 0[     IWj}"11111111331276551!11331276551514'&''1&'&'11514'&##3#31!17167211#"'&547634711632#"'&5  #   @   #  E       e0 00 0e  KK     A7311311311327655131674''131674''131674''1&#"ӕI!K  K!I I Z     Z I *>5&'&'516767671&'&'516767671&'&'5@?__?@@?__?@7 @?__?@ FccFw FccF @?__?@p000""0"" f""f   V""V!(BLbn6711673113311#11#1&'&'#3#513#3#11&'51516767&'#11373#31#1&'51676751&'#11376731#1131#11&'515 0  `     P0   @ 0PP0P @ @`p 0@@$J111!167671#1"'&551#3531''716717161"''11&''1&76@ 0!!0 YYYZZY__$F111!167671#1"'&551#3531''71611''11'&771'1&76@ d$$$$ // $$ //  4444 BB 44 BB $>N111!167671#1"'&551#3531'3#3#11&'5151672711654'&##113@ xDDD  ,D  ,,   8hh 8$7R111!167671#1"'&551#3531'4711632#"'&521###"'&77163217163@   X X 0  0     PF$1>Kam111!167671#1"'&551#3531'6731#1&'6731#1&'6731#1&'67311&'&'4773167&'#@          0@@HXXX$?Xi111!167671#1"'&551#3531'11'&767654'&'&761''1#1&'5167317166'&7654'&7@      \ $!!$ 3    ##   #0##   $>P111!167671#1"'&551#3531'4711633121##1"'&55''5171631"'@ ` ` ----    ` `n@ h $8L111!167671#1"'&551#3531'71''1&77167'1'&771'1&76@ g00p0000 00"0000 ,:HVc%&'71327367&'6'&&'&76776''''654'717&#"'1677&'6717676'&'o0??0::[44 B[[B 44B[[B .::::#".::::0??0:::##:2#"": :B[[B 44B[[B 44.::::0??0 ::::##:::0??0:5  6116767&'&'&'&7676&'&'&'67676 <&&66RR66&%=  Q22"":9HH9:""22Q  12BR6666RB21 BAYH9:"""":9HYAB &1''11'&'5147716'&1'1&'4716@ xD X `1J T ,   9L''&131676''167&'&676767&'&'&'"1176''151&'K""" n 6RR6666R>0  ?SH9:"""":9H5/.#HAu""" n 666RR66! -"":9HH9:""#5h HA^n471163332##113151#1"'&54763332##111312###"'&547633151#11312###"'&54763315151#1"'&5 00  00  00  00    pp        13#32##11#"'&51#11#"'&551#1&'&'6767@@    D----D   ` `--DD--*=P{711331327673127654'&##1&'&#"#1"34711632#"'&574711632#"'&57"11#1"331327673127654'&##1&'&#'"'11&547632#7&'11&#"#1"331327673127654'&## 7     7         7 7   I  W W              P       0   @      :%671167&'&'1&'6716767&'&''1654'71`)))^())(^)))(^^()))/))/)))//P111!167671&'&'!11"'1163&'&'45'1&'&'676771456767@@@UUQQ@./-- @Z''&#"111167717167&'' "1&#67674'71654''111&'51676731#.... "%X;;;;XX;;  P,'&:------5  ;;XX;;;;X%! PW,:&'5Pd%''"1#"''1&'&#1&'71676''16713277111671167654'&'&'&113167716''GGGG= 0770 =F::$""$::FF::$""$::F0 < 0XFF)5&B'..'B'4)!"<=CC=<"!!"<=CC=<"!F # 88 # #3CUew7''&767671''1&'51&11'67311#1&'567311#1&'573#31#1&'516767311#1&'573#31#1&'516767311#1&'53#31#1&'516767311#1&'5&=%/%5567#671167211&'&'&'''130?23:9Z 6%$$%66%$;;; <@1 0eeeeSS  Xj{111121#1#1##1"'&551#11##1"'&551"'&551"'&55147630101510101516767533151#1"3#32765514'&##12711654'&#"3!2711654'&#"3&'#13167 f<=         =,9Fg6731!11#!11!1!1"'&'1&##1&'676'&'%&'&76731167513167&'#151&'1#1." ) 4.P  ,,,,H  0,,,,>CP]31213!167&'!1&''1!12767716'&'#117161''1&76151#1&'#676'&'%&'&767.4  ) @@#.  Pf@@f0   "1132771654''      B;H471163312131111#"'&#""''1&76771516767315776151!167016'&'&'&'&''&'&7676760101676  0 , e!e , 0 llll#**#  &-21  12,&  #*+#   \ \  $$$$[[       Ljs|&'"1&'#113!127654'&'7165&'#1654'674'&'&'&'01"1#3#&'&#"#1"'&5513271#'1'177'1717  $> < '!    !' < >$  8     +55+ X 0@000 @#  a%%,   ,%%a  #  ` Qk3111'1&##1"13131&5476716767&'&'"'1312765514'&##1"1'1&'#'76''123&'&'4711#&'&'6767231&'&'6767#2711654'&#"3:b-e `D--F-$%66%$$%67>  / ?  C ""06%$$%60"" C;  R-  --D(!!%>6%$$%66%$f   (444 5A  -$%66%$-    2k&'&767111331131677131276551&'&'#6'&67676767&'&'&'&&'&'&76767@  `  &  @\2   "EeeE"    2- =``> -$$$$`0 dd 0            !Y''&'316771127711311#"'%#3#"''1&'1'1&#1##1"&551676761716761䴴W$ 1*"h  )3 k !!4#!   !#4!! n  U /  SrL6&'     '&6pT471167632#"'&'&5671167&'&'1#1"331132765513127654'&##15P?((21KK12((?       0/BK1221KB/0 #     #&5P67311''11&'&'676771'1&701110101010101271167654'&'&#"3"p !521KK1221K8,4! np !4,8K1221KK125! !pFa61167676131#11&'51#1&'673151&'&'4767&'&7671132767654'&'&#"H //  #+*B    B*+$   ##   &&.D00  00D.&&  `BQl67311''11131#11&'51#1&'673151&'&'676771'1&7011101010101014'11&'&#"3276765Rp '&&;;&&--D=+' n`   p '%0=,+    +,=D--%' !  k211716116771'1&767311''11131#11&'51#1&'673151&'&'67'11'&771'11'&'516734'11&'&#"3276765p )66)E ` E&&;;&& `    E ` E)6=,+  +,=6) `  pU7271167654'&'&#"37111312##11#"'&551#1"'&547633151&'&'6767676767&'&'&'671312##11#"'&551#1"'&547633151&'((?      ?((21KK12'0  0'-;K12((?      ( pB/0 #     # 0/BK1221K 00 !21KB/0 #     #%4O11&'6767&'71176751&'#01110101010101471167632#"'&'&5671167&'71176751&'#111111110#0"'38 !4,8K1221KK125! pX0K125! p!(!$ 0" !521KK1221K8,4! p021K8,4! p !)$ 30  U7271167654'&'&#"37111312##11#"'&551#1"'&547633151&'&'6767676767&'&'"&'6371'1&767311''11&'((?      ?((21KK12P-0  0 8,! p !21KN2pB/0 #     # 0/BK1221K 00  ! p !,8K125 9Hc11'1&11&'6767&'71176''171176751&'#01110101010101471167632#"'&'&5x !,8K1221KK12! pX !21KK1221K8,! p0@?Z61#1131#11&'&'6767414151#1&'673151#1"'&774'11&'&#"3276765 @ (  ;&&--DD--&&;  ( @k    @  +,=D----D=,+  @   wpV7271167654'&'&#"3711&'&'67673151671315167611'&'51#11&'51# 00DK1221KD00 "  PP  "PXB*+21KK12+*B888 PP 888p8471167632#"'&'&5671167&'&'1327655P?((21KK12((?   0/BK1221KB/0  pp5211#"'&'&5476763271167654'&'&#"30((((00((((00)*..*))*..*)"+ENW111!1676751&'&'!&'6767&'111!1676751&'&'!&'6767&'@08@@H@@H1S471167632#"'&'&567116731#!1"'&5%55#1&'67315167131#11&'`""""`23K\K32  |  @@@@@####K3223K   @@@@@@1R471167632#"'&'&567116731#!1"'&56171611''11'&771'1&7`""""`23K\K32  |  ////////@####K3223K   S////////4A211131514763311#"'&551#!1#"'&514763&'&767  )   ----  )    `'((''(('1KX1111312771311331676''167671&'&'!471163!121#!1"'&55&'&767`)#.( 77 (.#)     )%. 77 .%)` ` `1Kex1111312771311331676''167671&'&'!4711633121##1"'&5573#321##1"'&55147634711632#"'&5%211#"'&54763`)#.( 77 (.#) P P PPP P       )%. 77 .%) ` ` ` `       @`5>1!1&'5167!%111!16767512765514'3&'&'!!!!1!15""" "p`` @""" @ "` @`5>1!1&'5167!%111!16767512765514'3&'&'!!!!1!15""" " @""" @ "` @`5>1!1&'5167!%111!16767512765514'3&'&'!#3#1315""" " @""" @ "` @`5>1!1&'5167!%111!16767512765514'3&'&'!#3#1315""" "p```` @""" @ "` @`51!16751&'!671167!1121#1!1&'&'5PP"" "" "" @ ""@!277117676''131674'%1&# R: 8v s_t  r j1111#1"3311#17716717676'&'#1&'&'513127654'&##151676771676'&'&1&''1&        4!!4         4!!4  `  `  &&   `  `   &&  @'9Sp&'6767!1671&'!1&'&'67%!!!1!1671&'4711633121##1"'&553#36767513121##1"'&55 %R%%%RR   @  I%%%%@ ` ` `  '7k&'676731671&'#1&'&'67571316751&'#&'&'6751311316751&'#1&'5131671&'# %%%%W%@. I%%I%%r%%rrr%))q %q%,111315167673151&'&'!#3#1171717@ p--p @ p C- @  :%#3#513151#1131676751#1'3#3676751&'&'#11 @@@@@@@`;BY`u3#32##11312###"'&54763311&'#1"'&5476331673#3'1&'11&'&771631%731'&771631&'&' r %  % r ))8IHH0#"  __  "#0IIIH~ __  #"00#"   (   '(  ||`" "|||| ""=M"1131111"33!27654'3&''171675127654'&##5#15167711  .DD.    .DD.  DD  B/DD/B   B/DD/B  K (DD'=KU"1131111"33!27654'3&''171675127654'&##55311#1&567711#  .DD.    .DD.  DD  B/DD/B   B/DD/B  K DD=M"1131111"33!27654'3&''171675127654'&##553111'1&'  .DD.    .DD.  DD  B/DD/B   B/DD/B  K (DD(>M\4711633!2#11112##!"'&54763516771'1&'51"'&551716751#3#351&''11    .DD.   .DD. `DDDD  B/DD/B   B/DD/B  (DD' (DD'  J11111&'5111113312765516767515151&'&'"&'&#"&'&#"&'&#  -2  $        03&;'*` i )P     S4'11&#"1&'514'&#"1'1&#"1316767514'&#"1&'514'&#"1&'5    <  qC]K12      :  k?21K p A7"1133133676751&'&'#11''10101'1&1#(     @6%$+$2." K C     $%6q?,# @B<671167331111##1"'&551'1##&'&'6767336767&'&'##&'&' p9#q ` N"  0P  Pp P /# 0 2      "Y&'11&1&''1&'&1''1&#"1330101676716'&'&1#&7716'&'&1&'' 5 + ?7  qC] -!" R % $  &9    5  k?+     ?KXd471163216367263111##11#1"'&'&''1&76761&'1675716751&'&'1675  !    $%6@*$$H   8p0P     006%$"`  KC``````'=M2111#15147632111#"'&551476347116321#"'&55%'#1'1&767655332##1316767513273271#1&''1&'516767 @ `  @   SSSFG F 88--D>A0 %  @ @ @ @ @      D--. &5 d+P&132765511327711327651&'&1'11331132765513127654'&##1"Z  V  V  vv @  @  S s s     8G671167654'&'&'67311''1#11&'5153#327654'&##1F::$""$::FF::$""$::F`X""" %=0@@@ @@!"<=CC=<"!!"<=CC=<"!h",K RH`pX  @"8!11!#671167!11!1&'&'!!!2#!1"'&54763@@       ->_5#11!151&'&'#1514'&#"1#1514'&#"!!!1!16767131#11&'51#1&'67315167`0  0   `@@ ` 8888  00       88888.?K21113151476321311!151676731514763!!!1!1&'&'67&'#13  0 @ 0 @  8     00     .?_21113151476321311!151676731514763!!!1!1&'&'6'&1'1&11771176''17  0 @ 0 @  1////////     00     q////////.?Q21113151476321311!151676731514763!!!1!1&'&'6'&1'1&177  0 @ 0 @  I_/@p     00     q_/@p  /"11111!167675151&'&151&'&1514'&##@     @ 0P  T?T 0+=471167632#"'&'&5767&'676767553271#"'&5""&&""""&&"")   0'!!!!''!!!!'@)p #EU#3#"13!127716''1&##14'&#"4'11&##151#11#1"113!12765555#1132765ࠠ y0 0   @0 0y @   @ 0 0  0 0 @```` @'''11771617711'&'167  o 7777}2 :|:::}3 O#1113117713167671&'&'!@` {P ] 0F671167654'&'&'5#"'&5514763235#"'&55147632F::$""$::FF::$""$::F     @!"<=CC=<"!!"<=CC=<"!@    4671167654'&'&'3#321##1"'&5514763F::$""$::FF::$""$::F@  @!"<=CC=<"!!"<=CC=<"!`   6?H6711671#15#3#1!1676751&'&'#151&'&'&'6767&'0@@@ )) @ 00 P000 )) 00  000@3AN\6'&1#1"313!127677127654'&##1'1&1#175&'516771&'51675&'5167  ]V 44 V]  QQ=`        ``````````N[7671167632#"'&'&'7&111771632176''1&55167716'&1#"''7676'&'!"<=CC=<"!!"<=CC=<"!       (++( _  F::$""$::FF::$""$::FV  3V II V3    FUa676'&'"1117677111132765514''15117676''1&'#776771'76''1   / #M  2F M/(  5C vv` ]  F+MS Y2^^  g%}}}  X5  @18JY111!167671&'&'!'''1#11'&771672''1376731#1&'55316767&'&'#@@HHH R H*[8))80    @    k****`))```  ):b1111&'&'&'&'67211#"'&54763'67&'&'&'&''6111171611&'&'&'677A4444N   :&'% ( 1)*5(` }ee<<X44AN44   H'&:%w`(5*)1 ( X<  D+     .   ? <'+*A\  ||    |].  III'#"7..%O   k uK1 G***2 @/// (  %('.A*+    9CV&176''167676'&'&'&'&''67116'16'&'&''167%112301%1' P i  #$00=3+*!p&11+. '   Zk Se $#00= 0 R  ##!"X"!442"  F ##!"  %67&'&'1113151!1674''17165&'!\@v>>`@@!Rdm777161151#1'1'1&#"7'&'&76771&#"11311767671767677676'&''%1331276551#&'67%5331276551&'#67&'C```  c  H!444TH\     P    P kOOO   N /}(((C0S  {R  +777111#"''157"11!1676751&''1&#@0u u0     +8DQ]111!167671&'&'!3#3#1&'6767'676'&'%&'167516751&'&'1675` p@@@""   P""`$$$$p@@p@@@@@+8FTb111!167671&'&'!3#3#1&'6767'676'&'%3#3#1&'673#3#1&'673#3#1&'67@@P@@@""   @""`$$$$ @@/<%&'11&##1"32767%671167632#"'&'&'676'&'$@$$%++%$q!"<=CC=<"!!"<=CC=<"!))))@F::$""$::FF::$""$::F#$$##$$#+8F111!167671&'&'!3#3#1&'6767'676'&'73#3#1&'67@`@@@""   ````""`$$$$@ 1>KXe!!!&'&'!1!167671!67116731#1&'7&'&7676731#1&'6731#1&'6731#1&'@@@@v p$$$$`       @@0D[11167674'&'51&'&'6711671001&'&'67670101511&'&'6751671 ""  p 00 ()==)(   "" 00  0%3=)(()=3%  !  !0D[11167674'&'51&'&'6711671001&'&'67670101511&'&'6751671 ""  p 00 ()==)(   "" 00  0%3=)(()=3%  !  !0D[11167674'&'51&'&'6711671001&'&'67670101511&'&'6751671 ""  p 00 ()==)(   "" 00  0%3=)(()=3%  ! ss !0D[11167674'&'51&'&'6711671001&'&'67670101511&'&'6751671 ""  p 00 ()==)(   "" 00  0%3=)(()=3%  ! 33 !0DQ6711671&'&'4767571110016767&'&'010151&'&'676'&'p   "" 00 ()==)( 0  P  ""p 0%3=)(()=3%0 `3FYl4711632117716'&1&'&'1&'1327652711654'&#"34'11&#"3276552711654'&#"34'11&#"3276552711654'&#"34'11&#"3276572711654'&#"3@   !)+    @     @     @     <  !+ <   @     @     @     7\67217716'&&'"'1&#1"3!127654'&#!15513276551!1132765516751!`  h  !  @    @s  h !   ,(  (,.Ojw%671165&'&'1&'&'6767675167'&'&'67&'&'&'6767'611#"'&'&'&'67635&'&767?%21KK12%=%%32??23%%= )) 1()==)(1]     L&'/K1221K/'&67F?2332?F76& ,)), *D=)(()=D* )))) /111!167671&'&'!!!!2#!1"'&54763@ @@  @@    7"113!127654'&#!   @   'AX#3#1#1516767311#151316751&'671167!11!1&'&'1133127654'&##1"@"""P@   """@   :111!167671&'&'!6171611''11'&771'1&7@@O////////@////////&'1#1311#1311#131167513116751311675167673167&'#1513167&'#1513167&'#1&'&'51&'1#151&'1#153#321##1"'&5514763#3#1315((((((88((((((88  (88((((((88(((((h   21117161171716171611''11171611''11''1'111''11#"'&5511'&7715111'&7711'&'&76771'1&76171'11'&771'1&'&76761'1&761151'1&761514763 1=  D<=D  =1  1F#C #$ C#F1 1F$B ## C#F1 7&5676767"'1#"'&5477,+1)$$)" !)$$)1+, &^g&11111311327655151514'&#&'"11327655167674''1&#1&''1&'1&'51111151    "  "     0&'Gp p   # #   :7#3#&'516761676'&'&547632327654'&#"1#1  *,9989,,,,9999, 1@@1//1?@1) w *,,,9999,,, //1@@1/.) 0=JW67311312#!1"'&54763317!!!1!1&'&'16751&'316751&'316751&' x `  `g```   n@@.^'&'&7676767161#10101#1&'&771&#"67311131132767676'&'1'&'51115  %,9899,* x )1@?1x )1@?1  %,9899,* 1!  .%,,*  )./ )./!  .%,,* x7E"1133116767&'71654'&#"1&'513127654'&##5&'5167 L11;;XX;;  +9 0  "88PX;;;;X@1 # "  'U'1#"'&551#1"'&5514763315147632'#3#"13312##1&'&'16767312#z{{{ {     @@@ @ @))@ V{{{  { > @ >   ))  'U'1#"'&551#1"'&55147633151476323#3276514'&##1"'&54763311#1"'&54763{{{ {     @@@ @ @))@ V{{{  { > @ >   ))  :%3#36751&'&1&'&767654'&#"#"'&54763213 *,9989,,,,9999, 1@@1//1?@1) x *,,,9999,,, //1@@1/.) BUh{&#1#1!16767&'&'67&'&'#167&'&'#165&'&'211#"'&547634711632#"'&5&'&'&56731 "p$M  `   @))  "$$%     l    @5H`111!1676751&'&'!'###&'&771632171632'4711632#"'&5'&'1!167&'!1&'&'5```` @ 8    '&:@%k  P T   :&'%1O]%77'1'1'11111771677177171677113711111717171654''1&#"7'&7716 ">" # x O  ">" (0 ">" y $N } ">" ' $7171654''1&#"717716771'k1111(G# x1111(Gx #K'10101'10101'1'1'171632&1'&77163211111111'&7716771'(((4`4ff `Jf I (((4`4`ff `I fI D"71327716'&'#114'&##1"1#1   H @ Hq    c"7''1&5477161!121#!11      "   H @ Hc"%771654''1&1!1"13!11O    "   H @ HC"6''1&#"1311331276513167>   H @ H      @!(:N671167311331111#1&'&'#3#51'1'17163277111'&77167 W G  G <  ~WK @l  G G <  Y#3#177111'1&131676''17111316751&'&1'171176751&'#111'1716'&'Ȑ (OO(  (OO(  (OO(  (OO(  (OO(  (OO(  (OO(  (OO( $7E11#11!167671&'&'#1&'&'211#"'&547633#3#1&'67  &%    P@@   <D+%654''1&1#151&'&117675131177p    pp    p h 88 h h 88 h+&#"1311#11327716'&'#15131676'' h 88 h h 88 hp    pp    p<116767654'&'&'''&7673151476331213121'F::$""$::FF::$""$::F ppp @   @ p !"<=CC=<"!!"<=CC=<"!uppp ` ` p <%&'11&'&#"3276767%77613121##11''1&7!"<=CC=<"!!"<=CC=<"!uppp ` ` p F::$""$::FF::$""$::F ppp @   @ p <7113276767&'&'&#"7'&'51#1"'&551476331514761!"<=CC=<"!!"<=CC=<"!ppp ` ` p F::$""$::FF::$""$::F ppp @   @ p <671167654'&'&''#11##1"'&551#1"'&7716F::$""$::FF::$""$::F ppp @   @ p @!"<=CC=<"!!"<=CC=<"!ppp ` ` p S11327711767514'&##111!16767514'&#"1!1&'1673127654'&##` * ) ""@"  p p) *  """p p@  9111!1&'&'16767!"11132771176551&'#@ (G$G( @ (G$G( !C!!!5167611'&'51!1"'&54763211#!11''1&5477161! @@` `  ` `@`@ ` `@   @ ` `@*U711327656767311771654''1&1#14'11&#"#151&'&1176751316767  )@ @D--  )@ @D-- )  @ @ --D@ )  @ @ --D ` 6%676'&'711&'&'#1"'&54763316767312##@---- ++;;++   ++;;++  p'((''(('08#$$#8  8#$$#8  IR[&'67671165&'&'167674'&'513136767&'&'"#1&'&'&'67%67&'P  ""  "" )7W "" W& a "" "" W "" &@5>111311#1"3!127654'&##1'13167671&'&'!5!151!@ E  E @@    @:6331211#"'1&7711121037167&''1716'&1'1&u p   p&:9ZZ (`  `aac.%1#"''1&76731514'&##1"'&551476331131^   X P P6%$Xq     $%6c.6''1&#"1311##1"13316767513167^   X P P6%$X      $%6 @;67116713276551&'&'1#11!1676751&'&'#15`""  ()==)(@ 0""0 0=)(()=00)6711671167&'&'327&'&767''66RR66''  $$$$3!87;;-R6666R-;;78! s  p/d56767#1&'673151#1&'673151#1&'6731&'&'5&'&'51&'11#13367&'#151676751&'`))PPPPPP))$%66%$+*B0HH0B*+`))  ))6%$$%6((D00 "" 00D(p,5671167311#1&'&'4'11&#"32765#3#131   P  @p'1113167671&'&'#3#3#1&'67PP@@@@Pp&/671167311#1&'&'3167&'#1#3#131@@@@#-7A\w111!167671&'&'!#3#51'55316711671#7&'11&'31471167632#"'&'&571#13367&'#151&'#1@@@@@@@@@@@L@@@@@@@00D#;&'11&11716'&1&'716''7367716'&''1&1&' X0 P 1 (a\\\:FGO `( QHH:z  '(`HHH-X ( 1 &=&'11&'!11!16767676'&'67116731##1"'&5  0W $$$$  0131#&'676767&'&'#11''1&547716pK12  )`  @21K8%%  )@   .21'&'&'&747677163676765'10101 /.VV./ D'&P3EEAB+ +BAEE3PCz#669:.J,5671167!11!1&'&'4'11&#"32765!!!1!1@   @@  @'111!167671&'&'!3#3#1&'67@@p````P@-671167!111!1&'&'516767&'&'5@@@ "" @@ "" @0%271167654'&'&#"3113!12765&'&'#'!!!!''!!!!'_D.-  -.D""&&""""&&"" -.D D.-:111!167671&'&'!6171611''11'&771'1&7@o////////@////////96111#1&'51676173#31''11''1&771'1&767 W'  'W 'W W'  W'  'W 'W W' ;3#31''11''1&771'1&767#3#&'516761716111X 'W W'  'W W'  'W W'  'W W'  -:"11117167716771654''1&#&'&767%176''1& I %3&t)X'((''(('@@t%3% I )P----!@@P]j7#"'676727654'2323&#"3632&547&'""#"#&'&'&'4532765&'77676'&&7676'?::UH9:"" ::UH9:"" : E! ;E! ; U:: "":9HU:: "":9H !E ;K !E ; +8AIW'674'367'7"171&'"'71'165&'11672&#16767''''127&567WUUU#B1,;*U ,=Fc>=4H>=4H;*U,#B1U===Ed ,UUU*;,1B#UWH4=> cF=,& cF=, #U1B5*;,U===>H4-@S671167654'&'&'211#"'&547634711632#"'&5'211#"'&54763F::$""$::FF::$""$::F     @  @!"<=CC=<"!!"<=CC=<"!     @   ARc&'1#1311#11#131131'13167&'#17165&'#1513167&'#15731674''1#!731674''1#'51131'1716551&'#11#151&'#11#151&'#1671#154!!4`++++ ++++ ~P  TT p::::::::444 HH 4` @->"11131516767&'1'&771&'674'&##7!1674''1# $&&d j&$ @P)))) !:;J#  #80c j:! P)))  )bkt}111!167671&'&'!531513113151311#11311#11311#151#11#151#11#1513151#1513151#15133#351#155#1133#3#131513#351#1@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@R2111312##113121!1'1&547633151#1"'&547633151476377!11!1&'47   MM   ))) )   0  0   '))))  09I711771677161!1716551&'&'#167&'!1674''1!1`  2 @66R ar))   % W R66  D  ))0'77671165&'&'#1"131'1674'&##31674''1#1 ,,     )),, pp   )) 7FW&'&76767676732761#!'1&76763276701110101010101!!!1!1&'477   z,,  kk  z  ))%%   P)  )9M_5567311316751673113167516731111!171'1&53#367514'&#"177!11!1&'47 @ @ @ 33   )))@)(((( && `0 0))))  7ox471163312111##1"'&551#1"'&551"'&54763514763315!531212#1##11##1"'&551515147633125#1513`                   @ @ @  @ @@@@ @  @ @ @ @@@@ !.;H1676767'6'&'&''761''1&761''1&761''1&7b- b- WD߽WD7 @ @ 0 @ @ 0 @ @ 'N-2'N-2WEݽWEK @ @ 0 @ @ 0 @ @ '8Kt11#1&'&'676711#327674'&'327654'&#711#327654'&471163332##11#"'&551&'#1"'&5''66RR66     4    q     @@    3)**)3R6666RA    2            '%&'11&'6767671&'&'5167mHHHHmmHHHHm&HHmmHH&OqqO))))))@ >K1111#1'151672171632'#1&'47716'&1'67716&'&7677 "l " vvv/+<3 "1C---- " l" vvvC1* q 1#/u'((''(('!!!1!1Fa%"11'13171676&'%'"##1&''1&#1"''1&56771674''1&'5147211#"'&'&5476763&<,9999,3 !,5& :   C  $o   <,,3CC? #$  C   : &5"    *7DQ%6'&''&'677'&'11&'6323&''&56767&'6767&'677#()6Q32 KRSH$:=@A>.(.E$%B=I//%&>F:&&$..P0M= AKKH#--4PGF4BBY#0)$27$ 7E;;-.KJW ##;;I K<;!Z;E$55>+SED&w')%- !S\enw4'11&#"1&'514'&#"1'1&#"1316767514'&#"1&'514'&#"1&'567&'&'67767&'&'6767&''&'67    <  qC]K12    0P0p0  :  k?21K p P0 `+4=FO%3#3676751&'&'#1!!!1!1!111311#67&'7&'6767&'7&'67```` ``xxx @@@px '73151#13#3'1&'#1!!!1!1676753333r3r@@@eeeee @$Jp#3#131676751&'&'#11#1&'511131676751&'&'#11#1&'51#3#3676751&'&'#11#1&'51#1"13(((  (0(0( (0( pp PPPPPP 7_3#31#151675#11!167671&'&'#151&'&'#167311311#11#1&'51#1&'51673158@@` 00 00((((((0 00 09%''&''1&#"1167674'&'&'477167716321u4oo4 76QQ67 [)))  *gg"P6666P"1((6)  )6F;KV6711671#15#567675117676''1&'&51&'&'&71167611'#110171"@  `@ 00 ,,'',,(* 00 )  CPA0  pp0  0'--('!20  0@ b8_$7K11#11!167671&'&'#1&'&'211#"'&547637''1&761716  &%    q@/o@@   р@/o$7@NWd11#11!167671&'&'#1&'&'211#"'&5476367&'73#3#1&'6767&'36731#1&'  &%    xhhX@@   pB GS\enw676'&'671167131517676'&'&'&'&'47&'00"'7!167&'!767&'&'67'&'6767&' 2222 $$  # ;G[E    7hp*,,**,,*  mm      [8`blv|2111010101010101131&'71716767#"'&5!1#"'&5676767&'&'&'47632!14763#3#!1&'3#367!167# ,6 v&   ,66,  @ M   8 v -$$)$  $$-  -$$)$$)$$-  0B.P47116331217161&'&'671#1"'&5&7116771171'171611'&'' I\.  ()#\I  .=. 1  1 #C D()0 g == 1 Eq"1133113167674'3167654'3127654'&#!1&'1&'&'#5!1676751&'&'#11''11'&551#1  "   C 0" @  ` '' `   "       "P      $L111!167671#1"'&551#3531'67311311#11#1&'51#1&'5167315@ ` 00 00 0 00 0 CJ111312171632131#1"''11#"''1#11!167671#1"'&551#3531'`p 2 FP 2 f  #c 7 #c 7 @,T111311#3!11!6711671&'&'#11367311311#11#1&'51#1&'5167315@ @@  00 00@@@@@00 00 0>671167654'&'&'51&'51#11&'51671315167F::$""$::FF::$""$::Fp@!"<=CC=<"!!"<=CC=<"!hhhhhPPPP@CTa3#321##1"'&55147633#3131676751311!1&'&'1676731674'&'#17676'&'@@@ @  ` @p up$$$$ @ @ @0  0@  U  C[76767!111##1&'&'71#11311316751316751&'#151&'##1&'&'516713`:00 00 :&'%`:0 00 0'&:%1:C7"113311#1"33!27654'&##1513127654'&##3#31#1533#31#15    @   @`ࠠ  @   @  @@@@@@&;N1113151&'&'6711671&'&'5#11''1&74767&'&'676361p ` p 00  00 +  #,D--<#,D--  ` pp 00  00  0  --D,#<--D,#  H471163!121#!1"'&55!!!1#1&'&'513167&'#1513167&'#1513167&'#15 @  @@pppppp    ` @@@*T471163!121#!1"'&55!!!1#1&'&'5#11311316751316751&'#151&'#1 @  @@00 00     `@p000 00 0)gt'31#1"''11"''1#1&'673121716763#3176771311#"'&551#!1#"'&5147632131514763#&'&767)))\h / ){ .    R)    ----666 d  = $a  )     '((''(('aly111#133##33##33#1167673167673127654'�''1&##151&'&'!5#15131&'&767676'&'p 0000))))  M3 3M   0))))  @ M0 `M0  %Ken511#"'&5514''1&'514763255&''1&'5147632111#"'&5671167!121#!1&'&'5353151#%2111#"'&551476332111#"'&5514763)   <  )   <  ` ࠠ   `   ;+!.   =V   ;+!.   =V   `  @ ` ` ` ` %\'1''111''1'1&76171'1&7677210111121##11'&771514771176''171176'' &7HH7&===88Y99+9 9*9 9 &7HH7&===8899Y,9 9*9 9+;%''1&767&'&'6761&'&'&7!5!!!&76767f &1D--/&1D--  +*;;*+  +*;;*+  --D1&/--D1& J7####7 8####8:7554771176''171176''171176''171671##11'&77`9 9*9 9*9 9.+,YYYBYYY9 9*9 9*9 9.,+YY+4 "111316711327654''1'1'7711#W )' ` 3`f () ` 3` )JS471163332#1&'&'1"'&5#3#13157471163332#1&'&'1"'&5#3#1315 8h "" 0000 8h "" 0000  ""0    ""0  -;DM4767%1611#1&'14'&#!1"1#1&'!!!&'51!11%55!11!555!11!    0  0P(==kk 88p@@@@`PPPP>U471167632#"'&'&5%&'11&#"#11!167671&'&'#4'716'&132765""""##))##88` " !  ####p@ O N  *}471163!12#12#!1"'&547631"'&51#1311#1311'1&##1"1316771654'&##1"1513167&'#1513167&'#151&'&'6767&'   @  PPpp3 x 3ppPP0P    @   0G    G0  uD63171211''11''1&'&77'77111''1&'&5511767713; *SS*777    7  T .. TV[[[$ 33 $[>Qdw%6711671167&'&'&'#0110101010101010101367673'211#"'&547633211#"'&547634711632#"'&5H9:"""":9HH9:""/ ,&#08    `   //::////:E4%        G&176''167&'&'&''#011010101010101010136767327' P v="":9HhGjU/ ,&#0880 0 \9P://6SW  %*E4% Q671167!111!151&'&'567631##1"'&5!1##1"'&55167672113!515@$%66%$    @      6%$$%6"00"p!      !0 0}%#"'51&'&'6767"11'&'010101010101"'"'&1675167676'&'&'01#1&'&505476376'&'51&'3#3#113351#167311!1&'&'516767G"%%".!8;;XX;;8 ,G         *HH+  `  , ":VX;;;;XV:!8      ' ' @  @ T]51&'&'&50101101011&'&'&'&'"12771316767517165&'#17&'67)%#  ,-((  )(>LJD-- d"P_.A@/ ""8 ""0:*) &=--D- "B3B%67116'&'&1#1&'673327654'&###"1#1"1333277%0111030101"1010  wy@ @^-#-% ,$8   X  $ @ ^BR_&511476321716321#"''111###"'&5514763317163332###31716011101#10103e f  $- %-#-NP @yw 7g g ^ @ $  X  0B_5'&#""101013101011&'51&'"#&#&#&763276565116'&''1&'&'67675167111###"'&5514763317163332###31716011101#101038          $- %-#-NP @yw   "    #   ^ @ $  X  0BLY63211&'&'51477111###"'&5514763317163332###31716011101#10103B))C$  $- %-#-NP @yw `))` ^ @ $  X  0E4'11&#"1111331676751&''10101'1'1&#"11''1&551515!5111'&'&77171654'&#"11010111312771655151514'&#"P  dC    33    Cd  X 8@f'd O.!   3(P((((P(3   !.O d'f@8  v:%571654''1&#"1&##1111327655101015133010131'5&'&'511113277123033127674'3127674'676511&'&'0101# FN(p  "JN%    xEN)x H"8888w9IN& +f777161131676751&'&'##'1'1&#"7'&'&76771&#"1#11311767671767677676'&''C```  c  *  LH!444THP  l\  kOOO   N   /}(((C0  S  {U45&'&'311#1"'131&547673111316767514'71316'&'&'311&##1513&&22&&o xD#$  `  $#Dx pN2//2N0))--) `  ` )--))0 w676'&'511'&''1'1&5516767115147633121717167111'&'&77167715111##1"#"'&''1&''7711'&'&7&'&767''&''17P@3  O&/  0&O  3 <; 0001%   N000 %1  AAA3 [ VOXGL LGXOV [ 3A  www1^  www  ^1@s|5&##1"4545676723673113121##11##1"'&551#11##1"'&551&'#1&'&'676731#1316767633&'67))-         6  -@`)) !7 ` @   @)G-!! GV%011101'10101'16767117165514''1&'#111101011011771676''''1177M58U(*L(&8S\6 XSSS_ 7L}:  =]%<#!5$@`i  `X```h  RHfy1111'#1"331!167673127654'&##1&'&'676731&'&'6767111'&'&'&'676774'11&#"32765%2711654'&#"3] `))   `))( ))u ))       `  ))   ))))w ))     511&'67673124711633111#"'&551&'&'&'66T 633@   ?23  ?23W== Q:4 @ 32?  32?2L2111!12#!11#"'&51#1"'&5476331514763!!!21#!1"'&5514763` `     `      `     5HY671167654'&'&''1167676&'&'&76'6711632#"'&''&7632'&#"F::$""$::FF::$""$::F\!! ))     $$ @!"<=CC=<"!!"<=CC=<"!    v      @#>K%671165&'&'&'!127654'&##211#"'&'&5476763&'&767}32??2332?@   @   ))/?2332??23     `$$$$+Q&'&'1'&'&767%1167673&'&767%&711677117716''171611'&'' 0/   @@ .. )  *pp0 .d W"p    M M  * CNat111116767674'3367674'3127655151514''1&'#151&'&'!#3#51312211#"'&547634711632#"'&5'211#"'&54763@"))"""" ;1 iii129     `  P"""" @  G0@=p        -=&176''117671&'&11111'151&'&'#1'1!167' P W` Kpw% 0 D   @ ;d''11:67116331211312###"'&547633151&'&773#3'1#1  40 PP 048  7)* d   d *)7c@@*&176''16767&'&''#3#'1#13!' P %()=5'& ;D.-  0 "",=)( 2n-.D &@a&'11&'167676765514'&'5#1&'&'51676731''&#"11113277171654''113315147633121312765&'&'&'13151&'67&'s''22''   ''22''  #) )  L3  b  b  30??0? ``++ @ ++ @ 0))  ,,9  @ @  9,,""00 1E471167632#"'&'&567116731#!1"'&57''1&761716`""""`23K\K32  |  q@/o@####K3223K   1@/o0K^211#"'&'&54767633#32!1"'&56767471167632#"'&'&5713167&'#151&'####.\\\ #  23K""&&""""&&""0 """" -%&  K32@'!!!!''!!!!'P@0r<211#"'&'&54767633#3271!1"'&56767%67632171611''11#"'&'51&'1'&'&'&771&547'1&76767616754'&765####.\\\     23K                 \""""   K32V             2DV7271167654'&'&#"3113!1&7716771&'#% "1171654''17716771'1####.K32  % )2J\  G  < G""""023K  < (0D G   < G1K\471167632#"'&'&567116731#!1"'&5#3#65514'&'032331#&'674'67`""""`23K\K32  |  a!>D.- 0&0  0@####K3223K   .''-.D  )6)! 00 /L6111&'&'51'111##1"'&77151&'677617716#!1"'&56767M$%66%$0 k G G 2 ~ 2(96%$$%69 AOOG( L L ))7 7))0Ae7271167654'&'&#"3113!1&55145&'#%2111#15147635"13312765514'3&'&'####.K32  k 0B\^ @ P  """"""023K  )@ 00 000   0""1?471167632#"'&'&567116731#!1"'&53#3#1&'67`""""`23K\K32  |  ؐ@####K3223K   .MY7&'11&'&5676767&'&'&'436763671167617716#!1"'&53167&'#, !      &6%$$%6%$; > > ;$%  |  '      $%66%$?./S S/.?   0JT7271167654'&'&#"3113!123&'&'&##%7767676'&''1&1151####.K32  9\5xxx 6 6 x h2_""""023K  ,78.N000!))&&&&))!0V()*&)&176'%16767&'&''113!127%' P *$%66$$H//   0  !"-6%$$#5x21I  y2NW7271167654'&'&#"3113!167'1&551&##7"111132771654''1&##67&'####.K32   d\ kIkS""""023K   d!!P SkIkPT1132767654'&'&#"'1'1&331010333"301312765&'&'&1'1716'&'##`""""_!$ 6!" v "!6 $!  @####| *+9 9+* | .Cu 676'&'!676'&'310101&'47&##167676765&'&'&'#1!1&551&'1'&'&'5111'11111&'&767714545'7#3#"1675147676321716&'&'6'&''1&'&1'&'51&'&#"1''1&1111771613276751676176771676''1&5477676'&'----p----)*.@%)))Ah8&&,   ***     ,\           '((''((''((''(('%; .)))< &&8       ,                      9@W^u67116'&'&1&'1771133127654'&##11677771#6711676''1&#1%'#171167676''1&#1  q."{    ! ~RHHHHH0#"  __  "#0IIIH~ #"00#"  `_  %%") -  '"*||||`" #\||||"" 9@W^u&'11&76761671''11##1"'&54763311&''''13&'11&'&771631%731'11&'&'&771631v  q."z    ! ~RHHHHI0#"  __  "#0IIIH~ #"00#"  __  %%") -  '"*||||`" "\||||"" 7@Zm6711673!1#1311#1311#1311!1'1#1&'&'5''#113!!!1!1&'&'5167672711654'&#"3@V |jb W FR         @@@`      `   @"E7116514'&'&'"176763367116727651&'&'&#17 ,&!!  !L!  !!&,  y     r  @1Jc|'&'&547676%'&'&7654'&76761#"'&51&'6767''&'&547676%'&'&7654'&7676P         %   '--'  2::2  2::2  '--'  l% )%3  $))$  $))$    @=65114'&#"1'1&#1131674''17''&17716131676'7 " l"vvvC1" 3=+/ "l "vvv/#1 q *1C@?111311!11311&'&'!5#1"3!127654'&##1514'&##1"`@@          1L^671167!11#1&'315147633121311!11211#"'&'&54767633#3!1&'6767`#d @ @#  6668&&&&8'    1 @   &&88&&7EU&'1#131111315167671311&''1513167&'#151315167116751&''113X  q``q   Pg7 gP.D``D.\ 8 \8GX|&'&'"'1&'67676320101010101010101101#&'&'&'676767&'676710145""'&'&'5167676767431135551676714567671&'&'51%.M=W %66RR66/'(&('0\8%##9+!+ %8\0'(%=WW=  7W=66RR66=Wp""Q  O! # ` #   # p #""# -H]7671167632#"'&'&'"'11&547632#'1132767654'&'&#"'676767&'"67!"<=CC=<"!!"<=CC=<"!  `   @+,7" F::$""$::FF::$""$::F     7,+ "~@I111177131176''1312303176''167675151716'&'&##1&'&'67%  J/ ')/ *>&'Q 2*% 9q _q f22C@ @@M674'&#"1''1654'&#"3012113!1276771030127654'&#"1'&''5  9 Y  --  Y 9V   s  G      G  s "+4=Fbk "1132771654''67&''&'67&'677&'67'&'671131676751&'&'#117&'67Kh`rtPt"x,?Rex111!167671&'&'!211#"'&547634711632#"'&57211#"'&5476374711632#"'&5211#"'&54763@@@       @     @`        @     ,?Re671167!11!1&'&'4'11&#"327652711654'&#"374'11&#"327652711654'&#"3@          `@@          ,111!167671&'&'!211#"'&54763@@  @   ,?Rex671167!11!1&'&'4'11&#"327652711654'&#"34'11&#"3276572711654'&#"34'11&#"327652711654'&#"3@               `@@     @     @     ,?R111!167671&'&'!211#"'&547634711632#"'&5211#"'&54763@@@  @     @`     @   ,?671167!11!1&'&'4'11&#"32765'2711654'&#"3@`     `@      /&'&767&'&76772711654'&#!1"3!  ``       @%8671167!11312##!"'&54763312711654'&#"3`@ pp @         @.M4'&11#1"3335111#"'&54763273#3133127654'&##11&'&'#1@   @@  ```` @  ` -       @@ A%%77131676'&'&'477167716'&'#1&'47716765&''1&'117169DL? Q p,-@@-h$ 9( " %@-,,h$//37 @^g11111312##1"''16'&'&#"177111116761312#!1&'&'676767676767&'p U \3 @ n !)) J J%Z &&AAR "S\  oF G%  TEE,,hYk6711673113116751&'&551'1&7611111&'&'514'&'#112#!1"'&547635316751&'#1 %  M   @% @  M       ````@1671011311101010101011010171316710101&'&10101010101011131070307676767'1&'"1'&7716321111#1&'&''1#11#1&'&'515151474771676321''1&#531276771&'&'0155&'&'0#1316767w& /2!  (   2/ &  , 0,.& .,0 ,  7 , $%%$ , p         )0 .. 0)   +++  .  *+++  .  3&'11&767611'&'&76771'211#!1"'&54763!4  @  l  b    bb   @Ml471163!12##11311###&''1&''1&''1&731213151#1"'&53#351&'&'#1111!1"'&54763!12771632   D-- @ H &Р ) &5    @--D@ _7\ 3@  )i $    `%8K7671167171671&''11&'&'5''&'16773'3676751&'&')(><+HH+<>())(><+HH+<>()HHH""""HZHHH""""H>()*HH*)(>>())II))(>HHH""HHHH""H@<E%6711673127176751&'&'#1&'&'&'1675132716751677&'67#8U $%68,7R66,< z  6%$ 66R6+,B.)3 367116'&'&117676'&''17"113!127654'&#!  @    b    bb   @%^t1111!151&'&'676751&'&'!!!!1331516713151671315167131516713127655%5#"'&5514763235#"'&5514763235#"'&55147632@  @  @@ 0```0         GG  @     @@@@ @ @@@ @ @@@ @ Eo&176''16751&'11'151#1'1633151#1&'673151#1&'6731&'&'1'''#&'&'51'111#13367&'#15167' P 9#PPPPP))j+++6%$/+*B0HH0 0 |(1( -  ))6i"""$%6 %(D00 ""@!4>HR\7676767671&'&'&&'11&'6767#11#157115135#16767'3#31&'&'ABAA<<<;AABA<<<; """"@@@@@@@@O5   5   ))))@@@@@@@!+5?I\w7676767671&'&'&#3#51'55316711671#7&'11&'3111&'&'6767'1#13367&'#151&'#1ABAA<<<;AABA<<<;@@@@@@@@))))O5   5   @@@@@@`0  00  000D@'4F111!167671&'&'!3#3#1&'6767!1!1&'%3#31#1&'5167@@0`PPPPp00@'4111!167671&'&'!3#3#1&'676731#1&''5'&'"11211&'51&'01010101&'&76327656'&''101&'&'67675167@@\        p    N111312##11312##11'&'&771#1"'&547633171#1"'&547633171676r *? i@ A *? j@ A  >  `  b  >  `  b 0CVi|%111##1"#&'&'&'6767674'11&#"3276552711654'&#"374'11&#"327652711654'&#"3b  H9:"""":9HH9:""        `   "":9HH9:"""":9H   `   `  `   (H111!167671&'&'!3#327654'&##1#3#1#"'&55151476331@@000 00000  H))@  @@  @x ))@Q67116731131516767311#1&'&'51#111311#1&'&'5145'1#1&'&'5 `  `  ` P`  ` P` p    `  k `  `k `4@MY61716171617161''11''11''11'&'1673167&'#3167&'#173167&'# ((((((    ((((((   R "" "" "" 0 "" "" "" p(4@LYfx2111311!1&'&'16767315147633167&'#33167&'#33167&'#'&'&767676'&'%3#31#1&'&'516767!111#1513@ xx p  `  `          @@   (H `  ` A#11"''1&54771176''171176''171176''171176''1716321\30 0*0 0*0 0*0 03\.\30 0*0 0*0 0*0 03\`1133!676751&'&'#11&'51#11&'51#11&'51#1&'673151#1&'673151#1&'673151&'&'#11101 `@  0@@PPPPPP `   ` PPPPPP@@0  `@@K711!1676751&'&'#11&'51#11&'51#11&'51#11&'51#11&'51#1    @@@@@@ p   PPPPPPPPPP A671167311#1311#1311#1311#1311#1&'&'  PPPPPPPP    0@@@0  -?Oaq~&1#113151676713167671&'&'#1'3#31#1&'516767311#1&'53#31#1&'516767311#1&'5%676'&'713167&'#151&'Rv    v    p    *,,**,,*X  [  `` @ [@@@@p@@@@22220 1&111713127716''7132771654'&#"h V V6 P (ppp @ p P 6V  V h(ppp @ p 1Rc111113276767&'&'&#113151#12711671167&'&'&##1%113151#1!%%##))$#341 143#$))##%%!  ((``(( `@MZ%671167&'&'&'011131516713151671316767510501%676'&'%&'&767,"":9HH9:"", 0@0   $$$$1--6?2332?5.-@ 0000 @$$$$@  /Jcp'11&'&'67''311#3#36751&'#1'167'671167654'&'&'3167&'&'#1&'&'''#113dOOO`\0?R66# S3 ###|0?R66"0mF::$""$::FF::$""$::F    *```v/OOO`]"66R?0 @|#66R?0/!"<=CC=<"!!"<=CC=<"!  ```@9#P''&#!1"1367676727676'011101#"'1!151#"'11&'11!167675151$::::*))((()*0 @X[[[ [%%%%%%@@6E!!!27654''1&'!113513167675151#11#151#!327651#%66 LtL   @@  @  rr  P  P -D471163!12#!1"'&5471163!12#!1"'&511#!1"'&54763!12   @      `      7671167632#"'&'&'%&1'1&11'1&11'1&117711177111771176''171176''171176''1716'&1'1716'&1'1716'7711'7711'77711'77'171!"<=CC=<"!!"<=CC=<"!9 "" !-8 9." "" ".9 8-! "" "-9 8-" "" "-8 9-" ------D------D------------F::$""$::FF::$""$::F "" ".9 8-" "" "-9 8-" "" "-8 9-" "" !-8 9." ------D------D------D------ Nt53151&'#155676731131211#1514'&#"1#1514'&#"1#15147716335531327653132765311!1&'&'04   4   h(((((((((4\     \4@@@  @=67676731211''11#1&'&'511'&''1&76771633  !!  "  8 43 8  ~"   i  @ ++ @  iB Vm676'&'#11"11'&'&771677163211''1&''1111'&''1'1&7777111#"'&5477!  3#"   2  G9(= <     5%  A6 \  XN!@>>>-$ > ;)<111!1676751&'&'!1&'67!127654'&#!211#"'&54763@p `      3Pk7671167632#"'&'&'6'&'&'7676327'27116545176''1&1374'716'&177132767!"<=CC=<"!!"<=CC=<"!S    `   `   F::$""$::FF::$""$::F     |          ="113!127654'&#!"1133351676713327654'&#1!1   @ @@))@@ @    ))   #4CJQlt|671167!321#12##!&'&'113!151!1"7''&'&'31767315#1&'4'11&'&#"32767653#3&'7#3#67766#16767)    )@   ? *  $$  N"""" $  $ 9 ? `)  @  )@ @  ##  &++&R####&+ +&L ## _l61371211111111#'1"1''1&#1"''1&''1&5714''1&77165'147716771631277&'&7677721371011''11'&7''67714112771431''11#&'              b'((''(('+++ )% !8 %%%) + 8!                ----ggg$ Y 1=YY=> ! ':M`&1111177167716''1&''1&''211#"'&547634711632#"'&57211#"'&54763"J$<"S"J$<"S'  @     (L"R"; (L!S":      @    ,?Re&'&1111177167716'&'&'&'&'&'&'211#"'&547634711632#"'&57211#"'&54763 "J$<"S"J$'  *1  @      (L"R"; (L! & )t     @   %K4'11&#"1#1"33113151#11132765513127654'&##11&'&'#1131           @`@   @ 3@MV_hqz111!167671&'&'!3#321##1"'&551476367!1!1&'!6731#1&'%&'6767&'7&'6767&'7&'67@    @0P0P@ @ @ P'Hi671167654'&'&'5&'&767'6171611''11'&771'1&736171611''11'&771'1&7F::$""$::FF::$""$::F$$$$ %% $$ %% $$ %% $$ %% $$ @!"<=CC=<"!!"<=CC=<"!   $$ %% $$ %% $$ %% $$ %% N`s1'101010101132767676"'11'&5514771&'&767671&567676711''1&''2711654'&#"3` 5$44D $6-- (::E508 8< F ))1(,8 (u  `['Yv '  2b  7 h  x))!L 7  F   3W6'&1&#"1516715167167516716751&'77771&'&'&7&767632 i4>mHHE2>>2ELD@@@ o =ee= >?/:  K !  845& .==<* $2@t111!167671#1"'&551#3531'3#3#1&'673#3#1&'67#1&'6731677167163131#1"''1&#"1#&''1@ @@@@@@@@6 #   6@      @@  2'     8!$@111!167671#1"'&551#3531'57161''1&7615167@ (HH fffHHfG'@G6711673113311#1311!1&'&'5531'1&7611'&771#5#3#51 n'PP'n p000'PP'Ѐ5@G6711673113311!1&'&'513117716''1&1#155#1&'673%#3#51 'PP'hh p'PP'000$2@Zcq111!167671#1"'&551#3531'3#3#1&'673#3#1&'673#321##1"'&551476353151#3#3#1&'67@ @@@@@@@@  @@@@ @@` @ @ @@@@$1>111!167671#1"'&551#3531'6731#1&'6731#1&'1'&#"1101010101011&'51&'010101&'&7601010101010101227654'&''10101&'&'67675167@ @@@@        P@H      $^h111!167671#1"'&551#3531'3#3171611''11'&771'1&'01#11&'51516767&'#113@ HHH +" "" !AH44 (  <,@PP(@_fx111!16767511"##1"''1&#"1#&''11#1&'6731677167163131&771677151#1"'&551#3531' "1171654''17716771'1@<@     #     _ &  G  < G   8!  2'  < ^,  G   < G$>111!167671#1"'&551#3531'&'511'&77161''1@ (HH hfHHf'D "11132771654''1&#"1''327654''171611!1677W R\u&&5QQ111 25*\ Q\&&u5R222 15*\@(F]6311217163211#"''1&54771'1&547''1!1716''1&11#"'&'11&'6767632) Q5&&u\R 111\?*52 ' R5u&&\Q 222\*51   0Ql7671167276'&'&#1675%&167514''"76313676551&'&'&'11"13676551676'1113676551676713676551&'&'&'117716550;;X0() #22;H9:""  6%$ 12Ki $   i)    )  $X;;" )"":9H((5(({  $%6&% )*K12E.>$$ ++)  )64 ;=66 :<)`[T ]cDp0C671167&'&'&'1'&771'1&761674'11&#"32765''00''  ''00''Z .. Z   25 PP 5r  '4AJS7671167632#"'&'&'3167&'#1'676'&'%&'&767!67&'367&'!"<=CC=<"!!"<=CC=<"!))))#$$##$$#F::$""$::FF::$""$::FX#$$##$$#H))))-@W671167654'&'&'211#"'&'67636711632#"'&''11&767632'&#"F::$""$::FF::$""$::FP      z     "(("@!"<=CC=<"!!"<=CC=<"!P       '011#1"33327654'&##151716'&'!''!11#  @ `` @ @@@@&@ֳ   @@@@a|'17716132771611''1&#"113113277165514771674''1&761761&'&'"671167632#"'&'&'     $  '     !   66I*$!"<=CC=<"!!"<=CC=<"! )      0 "  ! C**F::$""$::FF::$""$::FK\w7'11176771677167514''1&##1"''1&'&7716176''1&7716''1"#&'11165!671167632#"'&'&': : +"  G55 0!"<=CC=<"!!"<=CC=<"! ('      ((@?8-  2F::$""$::FF::$""$::F5^y7'77161676''1&7633167716''1&767716771&#&11"1''1&#"1117716167%671167632#"'&'&'176''1&77716'&7&17716'4         !$X;;   $95!"<=CC=<"!!"<=CC=<"!  \j         ) ;;X    .I,F::$""$::FF::$""$::F\     &2;DMVal671167654'&'&'7#3#5131#7#3#51312##3#5131#3#5131'5#15135#1513'#3#676331#3#"'&'31'6711632#"'&'7211#"'&'6763F::$""$::FF::$""$::F`7 /777 G@@@@@@@@P@@@@P777  7      @!"<=CC=<"!!"<=CC=<"!p( 8( ((8((`((((8(((( (8 (     1DW671167654'&'&'7611&'&'&7667'6711632#"'&'7211#"'&'6763F::$""$::FF::$""$::F ((43(( =GH<      @!"<=CC=<"!!"<=CC=<"! -- i     1DW671167654'&'&'7611&'&'&7667'11&'&54767&'11&54767F::$""$::FF::$""$::F ((43(( =GH<     @!"<=CC=<"!!"<=CC=<"! -- y@1x671167654'&'&'7611&'&'&7667'0111010101#14101&'&'&'010#1010101010101'&56767'010101013011101#14101&'&'&'010#1010101010101'&56767'010101010101F::$""$::FF::$""$::F ((43(( =GH<@!"<=CC=<"!!"<=CC=<"! -- T    ;P#"'&'47450367676'27&'&'&'676767#"'&67676'&'0111010101765&'&'70101010101013141016767670103101010101301110101010101765&'&'70101013141016767670103101    N=! "":9HH9:"""":9H;EE; ''22'' B    ~( "/6H9:"""":9HH9:"" ++ Y    1Nj671167654'&'&'7611&'&'&7667'111''1&'&7676171676'7161''1&7676F::$""$::FF::$""$::F ((43(( =GH<A   A @!"<=CC=<"!!"<=CC=<"! --  A  A 1Kd671167654'&'&'7611&'&'&7667''1'&54771'1&547611''1&547716F::$""$::FF::$""$::F ((43(( =GHASTK ) >ASTK   m 026 ,..$# 9 b a8   KTSA> ) KTSA> )    621  #$..,L8a aaa 81Z7671167632#"'&'&'6'11&&'&6767'"11117711765'1716'&''1'1"11117711765'1716'&''1'1&#!"<=CC=<"!!"<=CC=<"! Xr111&'516767671#1#1&'&'67673131276551&'&'3#321##1&'&'5167673111#1"'&55147633X;;"":9HH9:""%n    n ;;Xp  ;;X((H9:"""":9H%   X;; p 00 p  2D%77'110111015167%163211#11#"''1&54777711##1&'5147;V  7 H 2 y???G EVH 6   2 ???G >LYgt&'1116751&''1&'551!1676751&'&'#1"''1&#5&'516771&'51675&'516771&'51671116751&''1&'51&'676'&'''U )PpP(''$$$$5$  5$ p @)@````````````@5$  5$   8JZl|471163!12#12##151&'&'1#1"'&547631"'&55316751&'#171316751&'#5316751&'#11316751&'#5316751&'#171316751&'#27116'&'&'33       `    p    p    (  ""     0  0   P      P        %Kt4'11&#"1113276551&''1&'5113276551&''1&5514'&#"11&"##131023316''1&'3#36''1&'##"#"11''6765514'&##1  <   )  <   ):1)  )(/0-Cf Ff%0g%ggg#   V=   .!+;   V=   .!+; h   {{{{{{ P 671167654'&'&'7"'&7010101010101010111030521676767654'&'&'&'0#41"111010101010101&5470101010101010101010111315121676767654'&'&'&'0'11#111010101010101&7632'6711632#"'&'7211#"'&'6763F::$""$::FF::$""$::F1          @!"<=CC=<"!!"<=CC=<"!    i     I671167654'&'&'7"'&7010101010101010111030521676767654'&'&'&'0#41"111010101010101&5470101010101010101010111315121676767654'&'&'&'0'11#111010101010101&7632'0111010101#14101&'&'&'010#1010101010101'&56767'010101013011101#14101&'&'&'010#1010101010101'&56767'010101010101F::$""$::FF::$""$::F1    W@!"<=CC=<"!!"<=CC=<"!    T    $%65&'&'&'27&''1&76766'"'&7010101010101010111030521676767654'&'&'&'0#51#111010101&547010101010111034121676767654'&'&'&'0'01"111010101&7632'211#"'&'6763 "'&7632'&'11&1771676'&'&1'"":9HH9:"""":9H5/     x    $$ ? U l(,H9:"""":9HH9:"" Y         :    v Y /BU671167654'&'&''&71163!12&'&'76711632#"'&'7211#"'&'6763F::$""$::FF::$""$::F  ++::++/      @!"<=CC=<"!!"<=CC=<"!  4!  !4z     /v671167654'&'&''&71163!12&'&'70111010101#14101&'&'&'010#1010101010101'&56767'01010101301#14101&'&'&'010#1010101'&56767'010101F::$""$::FF::$""$::F  ++::++y@!"<=CC=<"!!"<=CC=<"!  4!  !4e    /Ib671167654'&'&''&71163!12&'&'7'1'&54771'1&547611''1&547716F::$""$::FF::$""$::F  ++::++%YYYY$$$$ZZ@!"<=CC=<"!!"<=CC=<"!  4!  !4000 0++ ++0 //BS671167654'&'&''&71163!12&'&'76711632#"'&''&7632'&#"F::$""$::FF::$""$::F  ++::++/    $$ @!"<=CC=<"!!"<=CC=<"!  4!  !4z      FShy471163311!12##1&'&'47#1&'&547#1&'&'1&'#1"'&555&'#113#5567673111#1555311#%3#31#1&'&'516767 " C   " P`P     "      "  @((((((((    @1CQ%6711671167&'&'32777671&'&1177151&'&'#"'&'115/""33"" q to {q!!"#%%3""""3%%#"::: . <3 1D117@0BQ^1111#"'&'&'&'676767456571611%11'&'1677671'151327'676'&' ""33""t  {!!(  H%%#""#%%3""""3P . :/> 31171$7 "1'1&#"1771611171654'''11771677%% VV t@J fJ@ VV t%%ÂAIf IA 8b&567311'!7&'716731471167632#"'&'&57&1111771617'1&7716''1&''m EJ2ffff2JE mT)*..*))*..*)2 $ --  $ 2r 44 r0((((00((((0_ . #11# .-@7671167632#"'&'&'74'11&#"327652711654'&#"3!"<=CC=<"!!"<=CC=<"!       F::$""$::FF::$""$::F0     (C^671167654'&'&''3#3#1&'67711&'&'67327654'&'11&'67327654'F::$""$::FF::$""$::F@ $  $$  $@!"<=CC=<"!!"<=CC=<"!)   )@)   )1611!116773167&'#!!!2#!1"'&54763 P((PPPx@@   PBP   :&'11&13171674'"113331276'&'676527654'&#! ёj(  =  =  @ i  >.. ..>  Q671167!11!1&'&'547116351676731276551511#1121##1"'&55  " ) @ @@ "  Z  )    07=MTo{671167!11!1&'&'&'3111111&'&'31767317&'#'11111#16767#1674'11&'&#"32767653167&'#@, ' ) 0 ) ' , , '8 / ) ' ,""""1-  ++  -1g-1P ++  -1W####8671'1'1'17'111171327654'&#"171677v$" @ @ `  _2S"$ @ @ S2_  `<7171654''1&#"71171&56767"'17%1677171'p777}8.P  X      ,888}7.M,      X  %Hk'1'17163277111'&7716777'1&5477163210#017712105'"101771214111#"''179r9Xr h  ̒WN@ @----@ @NW9r9r  h WN@ @----@ @NW+ATg556111'1&731111'%1&''1&5!!!2#!1"'&5476374711632#"'&57211#"'&54763#)( mk#@A R @@  `     ccc0&  M T   P     ,C''&111'1&1133127%1676'&'#1"113!127654'&#!1"}.c: ! I G 9h @  MIII  _2 U %K5  GW"111132765513111327711327654''171654'&#"1'16767&'&'##3#5131   3j ii jj iV& 0pppp   ` @i jj ii jV (0 `  '8Ka#"'51&'1&'&'67676751&'76'&#"763236311276'&#"75676751&'&'`-33-:#""":9HH9:"""#: $$ z $$ m    -"::HH9:"""":9HH::"        f      '<Ob7113276767&'&'&#"67'&'&'"'11&'67676#711#"'&547632'211#"'&54763!"<=CC=<"!!"<=CC=<"!E/ '5P          F::$""$::FF::$""$::FP3 *P        MZg53151#1''#113#55#113#3#&'&'#1&'&'#1&'&'5167673!11#&'&767676'&'@`XQQQQ``)))) xo @  XXXX`X````````)))) l   0Scoy471163211167716771133127654'&##1716'&16551&'&'1327655771#&'5167314551#67&'!1!  T) )^   T {))  111((P L@ )) !H#GO&  6 %))   3/H?(05|671167654'&'&''1167676&'&'&7670111010101#14101&'&'&'010#1010101010101'&56767'01010101301#14101&'&'&'010#1010101'&56767'010101F::$""$::FF::$""$::F\!! )) 6@!"<=CC=<"!!"<=CC=<"!    a    }5>GPYbo"111311#1"33127654'&##15131676'1&'&#!3#31#17#3#71313#31#1733#31#1733#31#1'7#3#'131711z4@  @3tvvv ;ddd[ niii t iiit `eee [@   @@hhhhh0hhhhhh0hh@"5767676731##&'&'&'6731711&'67676323# #3DU $#=?^@ @)!  #**#  &-21  12,&  #*+#www ]=>  $$$$       BS6711671'&''1&'"1315167671'&''1&'"1"#010151#11"'&'567016'&'&'&'&''&'&7676760101676)%   )%   #**#  &-21  12,&  #*+#@)%   ``)%   ``        *=67%1765&'&'&'&##1"'1&176''%11&'&'67@R666R!!''   P ~"0 @79+R66/??77 !!* 0 b#" 0?Yr671167654'&'&''6711632''1&##1"1'&56767''1'&54771'1&547611''1&547716F::$""$::FF::$""$::F[ )++) YYYY$$$$ZZ@!"<=CC=<"!!"<=CC=<"! 000 0++ ++0 0 ;&#1116771671677167716551&'&'"11''1' ) $$ +%  %)/zz/* @0La%''1#1"3!127654'&#!173717676'&'1'&'11&'&#"1&111716'511171677167Z<<00P""<10 01>>>b  7DQ`m|%7767&'711'#"'&''&767&'&76676326276765&''674'&'&'&'11&&6767"67113&'&'7&'&767'211#"'&54763  "R R""R R"B  S     '((''(('P  1"!!5 (( 5!!""!!5 (( 5!!"C    0Y  t  1----    @`F1133127676763"'&'&'&##1"#&'&'67654'&'67672  "(("   "((" /  "00"   "00" 0E471167632#"'&'&5'1&''1&'514763316731211   P0 #` bP Pb `# 0`    77  0a111"'&'#&'&'47&'&54767&54767&5476767633211"'#&'&'16767    p       K]jx3#31!17167#711331276551!1133127655167514'&''1&'&##1"3#31#1&'51676731#1&'%3#3#1&'67Z###        #  ````  h  `KKeeeP%9 00 9%Pe  1Q^471163312314763312311!1&'&'5167673&'1#131167513167&'#153167&'#1P @ ` @ 0    ```  `    0e0>x"1'1&11117717171677167&5&1'1&#'1'1716'71111767711117677171716''1&'&''1&'&76676'&7 L (B  N $ ,) M   F000#          J E-  P !#'.< J $$$ 96/ EEE#&>  B  >'$T$ S  N[h3#31#17167553121#''&'#1"11331676731676731276551&'&'676'&7%&'&767555qeQ Cddd. ) !$$$%! 1]     ``L```` T}}}#hp #### 02## @i111"3!127654'조1676751676551&'#151&'1#151&'1#111&'51&'&'#151&'&'#13121'&771#1&'&7716`     %y : p : p     | 0000 | %S K ` K `=6311211#"''1&5477&1#116751673117716''   W @@ P P   ؉ 8008 P P-i5310101'1'10101"#&'&'6763230101717111#111&'#1&'&'6751&'6767316711111`   %%%%  )88 %%8  8*>R671167!11#11!11#167!1!1&'&'%71''1&77167'1'&771'1&76@@@@Z!!00p0000`!!00"0000  ,F611''1&'677'1''1&'67711777711''1&'677117     555    5%%5    5%% ee eee eFFFFFe eFB]j2111312##11#"'&551&'&'#1"'&547633167675147631132767654'&'&#"7&'&767 =+* # # *+=  =+* # # *+= """"---- # *+=  =+* # # *+=  =+* # ####P'((''(('x2111151676721"''1&'&'51176''111'1&'1110177111#&'&'5145676767676317167514763@  # & H![  l, ,_  [!H & #   .'&,,,& "I: E < :I" &,,,&'. *R`47116331221###1"'&5"'&5514763!!!6767&'&'51312##!"'&5476373#3#1&'67          6%$$%6R66/  P      `$%66%$@66RK5   @ ?H2711654'&##1"3311##111!127716'&1'1&##15135'1513@   P` C 2Q 00@    A  $ PVVVAB63131!1&'&'6767&'676731&'67673167674'&7 $"%$$" +F&'131676''53312765514'&##1"271167654'&'&#"3;  `    `   ####ؐ  """"U47116331217161111''11##1"'&5511'&''1&76771'1&'&77167615   z  zz  z   z  zz  z G  FF  G G  FF  G5H[n7671167632#"'&'&'4'11&'51&'16767'2711654'&#"34'11&#"327652711654'&#"3'4'11&#"32765!"<=CC=<"!!"<=CC=<"!@             F::$""$::FF::$""$::F`   P       -J]p7671167632#"'&'&'%4'11&#"32765671167&'716'&1"1"14'11&#"327652711654'&#"3%4'11&#"32765!"<=CC=<"!!"<=CC=<"!   @ @P   P  `   F::$""$::FF::$""$::F          57671167632#"'&'&'4'11&'51&'16767!"<=CC=<"!!"<=CC=<"!@  F::$""$::FF::$""$::F`37671167632#"'&'&'&'716'&1"#6767!"<=CC=<"!!"<=CC=<"!@L  MF::$""$::FF::$""$::F`  @-BVk671167!11!1&'&'5316751&'&'7111316751&'&'5316751&'&'67116751&'#11711676751&'#167116751&'#1175316751&'&'67116751&'#11))))0   0 0  0 0 P  0 0 P0  0 0 @))))08888  0 88 P    0  0       @.BWk111!1676751&'&'!111#1&'5167676711671#1&'5'111#1&'5167676711671#1&'5!!!676751&'&'!115&'11&'516731175567311&'&'&'11&'516731175567311&'&'`)) 0 P  0 0 P  0)@) 0 P0   0 P0  )@@)@ 88 0  88  0  )  )@  0  0  0  2Kj711767&'&7'&76767637167676701&'&'&17600'&'01&167671176767716'&'&'&17&'&'050167611''&'&'05056761011'&'&'47676K -,-    ',,SS'' *W     d$#,-,- * &'SS,,            &&%23,K6<   :'   %%% ':   :2      c"& @$1>11167671&'&'#&'&7677'&'676'&'&767@--DD--`  00  D----D `  PH531'1#7'31212#&'&#"#1&'&#""'&5476351476331516767313#36111'#1&'&'''1&7&'&'516767&77166767676'&'%67316111'#1&'&'''1&7&'&'516767&771667&'&767 0PMMMP  !!((!!@!!((!!   `                    P@@@@&fff @    @ P                 k  Tan'#1513'5#1"1"33167674'3167674'3127654'Ȃ'&##1'1&'#1'&'676!'&'676qLLLQ  ! 00 B 00 !  0ma  `````ppp @  0  00  0  @      @18A]111!167671&'&'!'''1#11'&771632731'67&'7556711"'#&'&'67672@@HHH Z H*  @    A****,`0@M671167&'&'&5711#1"331132765513127654'&##16767&'&'`    @6%$ / `  ` / $%6@  $%6' !     ! '6%$#3[111!327654'񽋽14'&##!!!1!1"'&5476367311311#11#1&'51#1&'5167315`))     p 00 00))  @ @ @  00 pp 0 5Ni|3#31#151675#11336763251&'&'#151&'&'#1#3#"'&551#11!1&'47#4'11&'&#"3276765'131#1&'51678@##)@``` ('@""&&""""&&"" 0(((((`!(  /A'!!!!''!!!!'P0@ ?Qcs&'11&'#11#151&'1#151&'1#111!!676751&'&'#155#1&'516731#3#&'5167311'#1&'516731%1#1&'51673%5#1&'516731'1#1&'51673#1&'516731#3#&'5167311%5#1&'516731'1#1&'516735#1&'516731 ` @@     p`    p            0        0HHHH `     0      P        0    p  >%6711671167&'&'&'#01101010101010101013676735'&'"11211&'51&'0101&'&763010127656'&''101&'&'67675167H9:"""":9HH9:""/ ,&#08        //::////:E4% 8    .]11&'&'&701010101110521676767&'67676711674'13101010101#&'&'&'&'&'11#&'&'&01010101167516767&'&'#1&'&7&763276'&'5;;X:/ "  ';;XX;;Z>=S66'  " /:I66        K12   ,;K1221K 88V11G;,   $#97    9111#113113167675131676751&'&'#151&'&'# P  P   P  P   P        P   y%771&'&'51656'&#"#1&'514'&#"1#1&#&1#1"331132771132765516731376'4''1673127654'&##%671'671'&'71&'717'1677'167'7&'71211#"'&54763R000A "  -;  ;- "   "  -;  ;-  "  $ +A0AA0h%+ w% +A1@A+++ %]  +++$ ;- "   "  -;  ;- "   "  -;  cA0g%+ x$ +A0AA0g%+ 000Ab   8Xft#3#1111'16771516767317163213111151515151#5513277110101!1&'&'01013#3#1&'673#3#1&'67GGw` M21M ` l` '(YF, % % ,FY(' Ρ  @!-!!!&'&'167673113311%3167&'#   @ !A%11!1&'&'16767311331%67513167&'#151&'1#131  @@@@ @ (@@@@@767!11&''1&551'1&7471167632#"'&'&576763276'&'51&'131#&'&'&21301010101167516767&'&'11&'&30147  k=''@  ""&&""""&&""y        //A)$0 O'!!!!''!!!!'!       131516713151671315167111212121##151#151#151#11311311#151&'&'1#15131513151#11#11#11#1"'&551476351476351476351515167"11131514'&#'531514'&#"x(0(   @ P  P @    @  @   @ @ ` ` ``0  0`` ` ` @ @  00 P  Mh{73#36751476321675147632167514763213121#"'&''1&547633116767654'&'&'211#"'&54763#---      - V )*..*) V            _""_         'H17161111''11''11'&7711'&771'1&76771'1&76171677''11111716171671'1&761'1&76771'1&'&7711'&'' L '\TB Z55Z AT\' L       Y5 T 'A\ LL \A' T 5Y        07''&7617167177161111''1&16767&'&767654'&76131201131&'&'&7316''1&5&54563316''1&76767671&1'&7716''1&547716'  &&.'  )  . #@@QQ@@# .  )  '.&&   > "#09% # ))2/D))))D . 2)) # %90#" = #4671167!321#12##!&'&'113!151!1"7''001#"''167671#"'&5477141414'1'&771&'&'113276''171654''1716' "#1'14#"1'1&111101327711&'&76'&741')    )@  Z% )) %           `)  @  )@ @  && $#  po!$@$NZfz'71'17611010111'%1515167%%%1177111'%1&'51176''15117'&176''6'&177&17716'&1''< 5 + + 5 @ @` @ @ '&''HGGGGGGvPYYPUUU.  PP  .U           W`i610101010101010101111100111110101010111717167654''1&761676010101011133330111#11101010101'11''11163&''11#"'&567511&'67271'11'7170101010111#1'105"'&'&'&'&'676767672721713111010101011'1611151'1&701010101010111116747674705&'&547674'&'&'1111010101010101&7767&'67&' 0  *$)    K!-(  (- L    *"*  0  H  (   $""'0(   (("" +     + #"((  (0'""$   (w##j##P61111!1&'&771517173#313151311315131131513113011!1&'&771212550@0@@@(@0@(@0@0b  b   `7Iax"1113151676731514'&#!"111311312765514'&#!3#31#1&'5167"11116771514'&#!7&''113!127655 `  `   P      `    @    ss  Ueeee  /Ia{0EZ63211#"'&551477363211#"'&5514777763211#"'&55147763211#"'&5514777763211#"'&55147763211#"'&5514777763211#"'&5514721113315147632131276551476321#11312###"'&547633151#1&'&'514763321111#151514763321111#151514763321111#151514763321111#151514763  `  N  r  N  r  N       )  ) ` @ ` @  @ ` @ + ++ ++++++ ++ ++++++ ++ ++++++ N     )@   @) ` ` ` ` ` ` ` ` .i}2010101!1&'676767010101010167676355&'1#1"'&5514763!121##151&'1#151&''111#611#151476773#311##1&'&'15!!)--)!!p0  0@@ F @ "7,+7"HHHH   HH::    %   g"&117716''"#"01112676767630151113101010101654'&#"00#&'&'0#&'&1"1163#1133&'&'&'&'45"5114'&'&'"#"010110267674'316771633121#&'&'&'4141#14'&' 010100103676751&'&'#11##165&'&'7{    b /   !    "  & 56%$'  &  ())( 1  0&      >      g       $%6# `   )`) 0   &'673163271&'6767"#011172767516767"1&'3276763#0#"'&'&'7&'&'&'#"'&'6776767&'1#&'0101&'&'&'672327676767476747&'&'&'51&'&#&'671376771676767'1"#&'&'67673&'670%%       #  &  &  #!                           %@7551'7751''167765&'&'1%671167632#"'&'&'^(6F,-%^^^6()-,FY!"<=CC=<"!!"<=CC=<"!yyyM# ^nnn 34I5*2MMMy #2*5I43 n_F::$""$::FF::$""$::F+9I5113151676713151&''1514''1&11315167116751&''113)``) L L  Pg7 gPSmmm``m L L \ 8 \80F]111!167671&'&'!2111#"'&5514763747116321#"'&552111#"'&5514763@@@  @     @ ` ` @       0F]&'11&'!11!1676711##1"'&54763312211##1"'&54763311##1"'&54763312@ ` ` @       `@@  @       C&'&767'771676'&'&1'1&'"11#1"331676''17`  w  X   8* 06W  t-$$$$  H   -$! ]'  VZ:u6761111''1&'&'5147632167514''1&'&767#1167514763211'&551677167514771676_ x  O +  W > W  + O  x  I ` - "!-v PU    UP v-!" - ` I #3Sv111!#"'&5476351"'&5147633!!!1!127654'&#'711177115'1716''1'1&11276'&#&'&'6767276'&'`))      N      $%6' )) '6%$))  @ @ @     *6%$(($%6l%1#"''1&'&'6767'&'11#&'&'&01010101167516767&'&'#1&'&7&763276'&'5' ~5FX;;;;XX;;        F5~ ';;XX;;;;Xh    1D%1#"''1&'&'6767'&'11&'76767#4711632#"'&5' ~5FX;;;;XX;;"" p   F5~ ';;XX;;;;X ""&'( ('&  ,CT&567716551#1112773#35147&##15127716751#755&'&'#1132@ @%) / ` @%) s2 ` !?'0  0/)  0/)W'?   @+^671163312##11''1#1"'&547633116311217163211#"''11#"'&54771'1&547 i f. .$AUn )) ** )) ** r    p" ** )) ** )) (\767116711672#&#232#&'&'&'%631121111''1&1'&7714''1&76771677"":9H2,  X;;;;X  ,2H9:""wG3 ?? 3GH9:"" ;;XX;; "":9Hw@ 2F!!F2 @LSZaho%731''''#1113173'##11&''1#1"'&54771'1&547633171671312''71#'''13#3#17731''71#*!666z66z6B555 n8  8n 55 n8  8n 56*d6****y6""""6XXXXXXWWW  \\  WW  [[  WX####8,,,,8##""""Z,,,,!6Ko6111##514'&#"1##51516777163211##1&'&'5147716327&1#111311771316''1716'#1'6 yp  py@ @@ @    e%r` `r%e  G  G y     5fmz&'&#"132767!!!1!17"111327671&'&#4771'1&567317163213111#11#"''1#1&'77#1''3171'1#1731'7#3#17'731''71#''13`    P    t9 99 9|*AFF!!!!`*`!!! @ @ @ @  106 6016 66$$$$p444444L<$$$$<h9j1131131513113151311315131676751&'"1#!1"''1&#53276551!1132765513127654'&#!1"33 @`@`@  11 @     @  p @@@@@@ C   C     7767632112##11111"##11#11#"'&551#11#"'&551#11#"'&551#1&'676751#1"#&'&'&'45676767716771715151#1"'&'&'&767637167#3#133553351##0101#3= '' -(    (- '& =3``Hx$ 8 B#         #B 0 $j@@@@@@G>1''1#1&'&'51676731716'71611''11'&771'1&76-DD|7777777777   x@x 77777777775H[11&'&'6767671167654'&'&'4'11&#"327654711632#"'&5))))R6666RF::$""$::FF::$""$::F   @   ))))66RR66@!"<=CC=<"!!"<=CC=<"!`    9.H[{7&767!11#1311#1311#1311!!!!1!1&'&'5167672711654'&#"31''171611'&'&7676! |jb        !!, 11 ,`,, @@@       `    :AA:  6EEEE6 #4MV_671167!321#12##!&'&'113!151!1"&'11&'131675167'&'6767&'&11771176''1716'&1')    )@  ""@p0z MM jj MM jj`)  @  )@ @ 0   !a !! .. !! ..@/86'11&'&1'1&'&111336767514'17#3#711#y '' 0    0Ywwwwxx  11  <  % 5P#-66R0")#) " !")?)) 4#-Q76P")%) " HU|111"#"51&'&'271'&''1'1&'&771'1&76771716761716676'&'11!1&'&'6767516767263&U&#))) U22UGG  ")#) "U7)))  TGGU22$$$$")%) " v75133127655116751327167516713312765511112767716''151&'1'1&'&###1167675151516767&'%&567311&''`      *  5#3"" w"00"  X  X  2 ? fRJ""36  (&@p  !! #5GYj~'7716'"157716''1&%'771654''1&#&'11&11767571237165&#6751&''1"123''276''1&#"1%''&#"171676'776'&##117'3#3276''1&##1"131555N !< .&NNN 5 - <1    VO NNNV OOO OZ P  P B  b .{{{\    b  \{4@ ^4 @xxxx     )=611''1&'677'1''1&'51476!611'&551477 ` hh ```` W  W `@S\7767213121311##1'5##1"'&551#"'1##1"'&551&''1&76761337&'676 48" %pj   $,,$   -  p0! "@a ss 1  @LXb~''&'&771'1&763331#1"''1#111#!"'&'&5476763%1674''1&'515701110101011''676711611#1&'&7711'&77`444  ), p0/9   !j /"0,.///  E ~C    %M   'B/$-/B-95 %  W2+ < oC71#'&#67674'&74771633127676'&56767276'&'&'      Y   0  /0BK12     0  ?()21KY 2K^r011771676'&'&1'6'11&'&#"1763277111743676''1&'&3167&'&'&1%&113167676''#3#1316751&'!1316751&'#1316751&'#!1316751&'#'&'167&'16753&'1675QD       C :P E PE2PPPP0PPPPPP@# -  L x  LL0 .  L )$ . L $) .00000000 !(^6711673113311#11#1&'&'#3#513#321&'51&'#11316751671##1"'&551476333#3#11##1&'6731674''1&'47633165516711#"''1&55167 0   #### % ++ % c @ P P        ##  5,,5   6L2111#151476347116321#15347116321#"'&5547116321#"'&555532732711##1"'&551&''1&'516767312##1316767 @   @   `   `   %X 88 pp @ PP ` `@ @ @X  (!!` N  &5  5H[7#&'167671"''1&1#"''1&#"1#"''1&'&4'11&#"327652711654'&#"3( 66RR66    x   `   R6666R  # #      G/C%''1&551'1&5677163311171611''1&771'7711&'&'67-#'P /9*-$ X}& $ !& ,  &*%1X&  $%6IZm~T1167&'&'&#"1167&'&'&#"67&'&'&#"71167&'&'&#"67&'&'&#"71167&'&'&#"67&'&'&#"71167&'&'&#"67&'&'&#"11315151&'311315151&'311315151&'311315151&'311315151&'311315151&''4'11&#"1#1"'&5514'&#"1311#1"33327654'&##151316767514'&#"1##15:>R..R>( @ @  @ @     )  )  055555558````````````  ` `)@   @)` ` 6Vl777677163111#1717167&''1'1&'1111#&#"11113277171654''1'!!!2#!1"'&54763@iii1<] (  ( (  ( @ @  5^# (  ( #    M_w676'&'711#"'&551'1&77167613151671010101011&'51#1&''7711'&'&77''1&'&771676331232  J'$$$* 8$$$0    LLL2Y SJ#T +8񊊊*d  Z [ 612331271611#1&'51#11#1&'51&'&'&'&'13311##1"'&551#"'1##1"'&5511'&7716567671133267'1&7&'6767&''&'6767&'    @   @ "" @  66R9 IXX0  )  %"  @ L L w) 1R88 p@dm%5531176751&'3167&'####16751671131676''1&77165451133127655167010157&'67  P 6%$`K0!  "  T   0NNN#L$%6'"88 *,24 ?   .AN%11#11#1'1716''1&111#1&'&'51#1&'&547%162151476331211@ {&Q u 23"@" 8  Mp  2   0%   0d%  33F?2332>'  & v;7676'4'&'&'67&'%671167671&'&'&'5@GhhG 7YY7 G43HH34G"HeeH""HeeH" %%    ((%##%`%##%` Vm&'&7676323111767716'&''171133127654'&##1&''1&''1&#13277#3#"3316771'1&'@W 9   900" #;;; F    ^ 5Y  e$R   6!   )@/C533351&'&'7167675167673151&'&'!671167&'#113 0  p)`0 )p000 P  0)@ 0) 3Fy111##1"'&551&'&567672711654'&#"374'11&#"3276567116171611''11'&'&76771'1&'&7p ` ()==)(         @" "6%$$%60      YY CC YY CC  61'1&7P   0 6'&11'1&''1&111177167711176''1&7716767117716''11176''1&''17167716'&11716''1&11514'&'&1&'514'&1'1&77 ! 9P  <<  P9 !   ((   ! 9P  =<  P9 !  0  0  U"99 8  8 99"U T (( T U"99 8  8 99"U T0    0T `2ENW`i11##1&'&76767656767!&'11&'676756711654'&'%&'673&'6767&'7&'67"     )D))))  @0P&442vFE  55LR6666RR6666RR6606711673121315147716761131211&##1##111#"''11##1"'&551&'1#"''1&54771&'#1"'&55147633167'1&547716515153#3#133'676'&'67&'&'11&'676323`j0j  8 +=#P          jjj q'Z----`%#"% x"%"  " - .            ```'((''(('@%.#%!+ETc3#3&'7&#3176711674'#1131'1'7'31312765&'&'#1"1133151%&'11&'#116765ggg C&) R[66%$$%6d >:!///D"R  23K\  "@ 09 p2D $D$%66%$8h`OOO"  K32  #$) _ '4A!!!13167716713167671&'&'676'&'%&'&767@x'  &y   $$$$"@@"$$$$@  +Ln6111#1"1#"''1&547716551673127%21111#"''1'1&547717163%'111#"''1'1&5477171632721111#"''1'1&547717163 V  * p# 33443344x ` *  c4334444334F*U113312#!1"3!16767&'&'#1"113316767&'&'!1"3!12##1"3#36767&'&'#1"3312##1"3    @))  @  ))    ))       ))  ))   ))    6H631121#'111#"''1&5477167677171&547'7716''1&1 @ 1  X1  BBB b B b  @  1X 1 BBB b B b <7113167632367232316767&'&'0#0#65&'&'&'&#4'11&#"&'&#"01"#"321230"3276701327654503327654'&'012327654'&#"1"#0365654'&#"0145676'&'!676'&')--))"&!0               )  ))" 0  `          C$JWdq~113676'&#&'&'47676'&'"#671167&'&'65&'&'"&'&#1!&17716'3&17716'3&17716'3&17716'1###6$ &   q"" )#)  `  `  `  /  ## &  " " )$)$ 0 0 0 0 0 0 0 0)AYs7&'11&'6767&567672672121!63211&'&'51477363211&'&'514777763211&'&'5147`) 0!&"))# ## #}#### )  0 "))4A    AA    AAAAAA    )6CQ^7&'11&'6767&567672672121!1'&771631'&77167'&7716'1'&7716`) 0!&"))0 0 y0 0 000 0 0 0 )  0 "))" p p p pppp p  p p6ER_ly1&#1'&''1'1&'&771'1&767717167617162&'67671'&771631'&771631'&771631'&7716711!1&'&'6767516767263& #) 8U22UGGV E  `  `  `  K")#) "?!) 1"'UGGU22  0 0 0 0 0 0 0 0 t")%) " Dk6763217163213331'&''1&'1!1'1&1##1&'&'4771&'&'3#311##1"'&551#11##1"'&551513'&#"11"117711765'1716'&#'1'7"11"117711765'1716'&#'1'1&#&#"11"117711765'1716'&#'1'@.. L ?'  ( * L```     `  k  u   ,,  H 2   W^ ^ @@ @@ @@   211171632771611''1&'1177111''1&11716177111''1&11716177111'&11#"'&55151515151515151514763&'67367&'&'67367&'  E;7#&&$  -BA!LO"-BA>C?F85LO"-BA>C?F85LO""IE;@@  P     $  ! > ! ! > ! ! " "P @F!@ @ 9  `09L767116761"'51&'&'&'4'11&'&#"3276765'211#"'&5476301LM1101LM11   `  O98 ? 98PP88@  98P0     )^3#31312#!1"'&5476331676751673#313151311315131131513113011!1&'&77121255=+*    *+=@@@(@0@(@0@0 *+=   =+*   'BU^7714'&12767716'&#17165&'"211#"'&'&54767634'11&#"3276567&' /9:V7./f K ####   KKK f/.7V:9/  """"`  `@%6`m4'11&#"1315!4'11&#"13276527116551#113"1176771327653276514'&##&'&76755133127654'&##1'1&#11132765511132765514''  @@    @ `      I C)   &  @    ڛ     P  HHH  *7 `+5 ; 4Fc&##1&771632131316767&'&'65&'&'#165&'&'&13117716'&'#1716' %  !  % $-  F4  F4  !! :%! % i  i 4_11111#"'&5516767671#"'&551&'&'&'111#"'&55167671#"'&551&'&'5#"'&5516767671#"'&551&'&'@H9:""  +*IHYYHI*+  "":9H  $%66%$    32??23  --DD--`"":9H` `YHI*++*IHY` `H9:""` `6%$$%6` `@``` `?2332?` `D----D:b671167311!15%"1111771176''1716'&''1'1&#&#"1111771176''1716'&''1''"1111771176''1716'&''1'1&#3#!116751476321&'&'51#111##1"'&551#11##1"'&551513--DD--        "" @ @ D----D@@@    P0 0""0 @ @@ @`$2@N[113167316767&'&'"&'&#&'!!!!167&'#3#3167&'#!!!!167&''&'#13167 ()={#22#0  0%2#&5=)(HPP@ppppPPhh0=)( 00 ()=`H-Kr211#"'&54763271167654'&'&#"3%6711671&'&'4767571110016767&'&'010151&'&'671167&'51&'1       ""00 ()==)( 0       P  ""p 0%3=)(()=3%0 ` !  ! -Lr4'11&#"32765#471167632#"'&'&5'11167674'&'51&'&'6711671001&'&'67670101511&'&'6751671      ""  p 00 ()==)(  `      "" 00  0%3=)(()=3%  ! 33 !8U71131716321336767&'&'0#0#65&'&'&'&#&13117716'&'#1716')/ @))"&!0 J  F4  F4 )u :))" 0   i  i !1A5!1677165&'!1"!!!!1'1&''31654'!113277167#a& `R(T/ uuu  N  &  `6*?EEE #v!$$ N&AY&'11&'676726763"'1#"''1#77632132771'1&##1"17767311#!1&'&'477$$  000  ;*<+*+ h 0 0 0  BC`@$F671167!11!1&1'1&17716'671167311!151311!1&'&'5`   9o/@g     p  0/o/@  `  `B8q667016'&'&'&'&''&'&76767601016767016'&'&'&'&''&'&767676010167656701016'&'&'&'&''&'&7676760101676#**#  &-21  12,&  #*+#%#**#  &-21  12,&  #*+##**#  &-21  12,&  #*+#z                      5Lc676'&'67116132771611#151&''1&'&7'11#"''1&'&777711#"'&54771'#$$##$$#p $)33)$  %$ Z<<<  0 2===2 0  h))))9     $$  555&  0  H5555H  0  % 4AN!!!676767671167312##11#"'&'&'&5335&'&767676'&', u    ))-,*)   8..   @&$##$&@0  ALYhy"7627677676'&'&763676'&'&'65&'&#&'&'&76'676'&'6'&'&#&67"6326767&#6767&"."4*89&!786587!&98+5".  11  C:   " j,%  &+   " /G(!4&:=00  00=:&4!(G/ $&&&&$   ( +$$ b    ( $$+ 9e11332765&'&'&'"11332765&'&'"&'11&'16767&'&'#1131&'&'5 ?23  &'AAP 6%$  66R `  ()==)(()=    32? PAA'& ` $%6 R66   =)(()==)(`   .?O21113151476321311!151676731514763!!!1!1&'&'1316751&'#  0 @ 0 @  P``     00     @``.?O21113151476321311!151676731514763!!!1!1&'&'1!16751&'!  0 @ 0 @  P      00     @@@+5?IR[d63117%1676551&'&'"177'6711'771&'''167'1'17'1'17'1'17] T#*+@+%3  Y... .===> V<<<=l====g====< "#)@+*Q =>5/// .;R&&&&C&&&&A%%%%,S110136767654'&'&'1765&'&'&#"1''1111771'1&761716765&'&'[      f?'< 7| 4 =d#%&7      .= 7 ?4 <. '7&% AO\enw"1113311#1"11!16767514''1&'&##151312765514'&##3#3#1&'6767!1!1&'7&'677&'67&'677&'67&'677&'67&'67@ P9P   `0xHHH @ FF @ 0hhhhh!Aa%#3#&'51676171632111111#"''11'&'51673!1''11#"''1&54771'1&7673'&'&771'1&5477163217161#Ȑ (I$I(  (I$I(  (I$I(  (I$I(  (I$I( @ (I%I(  (I$I( @ (I$I( @ .c13171#55#11333#3'1#133#3674''1&'#1'#1"331132765!132765713127654'&##171!2^[c| }}}c^^^ZS    @    TT      %:a3#31#1&'477167#3#7131355311#7&'&''1311&#"11#1#"'&5'1#1"'&5476331'1!1777632&'&'67676301&'11&'&327672[[[^|||c c:  Z 0    2 --DE-,"!&  & TH @T KL6   # **.D----D9/0   a7533151671315167131516713151671312765514'&##1514'&##1514'&##1"1#1"1#1" @@@@@       pppppppp      ;Gv6'&1'1&1'1&1#1131&551476767&'#1716'&17'#1&'672#1131513113151&'&'#165&'&'1'1&'113151#13#3676751#1#17163       $ 1 \   ##0  `1      0 &&&   P``P  (( P0 P8& W`i617161171611'&'&76771'1'&''11'11''1'1&'&7676171&'&777171'37171'}}O %)  GG  ).$%  $%.)  GG  )% O,Z KLLLY..+,+V  V.AA.V  V+,+7555 :: 5 "131676716'&#!''!11!  22 @8v W m7127716331111136771632136''1&771676731#1"131211133165&'&'&#"''1&#"''1&##1"1113316767%671167632#"'&'&'7&17716' !!!  *           87U    6++J!"<=CC=<"!!"<=CC=<"!             "V::  ! -dF::$""$::FF::$""$::F ` +7"113!127654'&#!5"113!127654'&#!          +4'11&#"13276534'11&#"132765@         5B&111&#"767676767654'717167716''&'&7670M#$$ '"*+33# M)0(  0)M #33,)"' $$#M0(2611176''1716''1611#"''1&'516767w$!2Lp>L 7--BBB`@@@@@   B`~~~;""~yyy . F: P  P :F :%!!!'1&56767311716331471163!121#!1"'&55` ;'(;2&& O    @;('1~V@    :If167&'&''1&'&5&'"111316767316767&'&'#3#3#15'&'167&'&''1&'&5X    8 ))0  00              )) 00 @  `      &:G#1"'&767676271#"'&'&77137#3#&'71676#'&'&767& ( H(H .55. H&H (   / 5,, } }  } P/} ,,5 05E[m211#"'&'&5476763671167654'&'&'67'1&'&337327676''1#"'73#3276'&'&12711654'&#"34,,,,44,,,,4F::$""$::FF::$""$::F8$ '  H$$$  $  THHH  ' $8  --33----33--@!"<=CC=<"!!"<=CC=<"! ? #5 1>>>  >1 5# >!    AN[676'&'5#"'&551'&'&77167633121'1#"'&551#1&'167676'&'55#1"'&771"'&'&771676321#1##11#"'&551#11#"'&5P(             ""         Ѐ  dd  `00  P``` _  _ ` `` IR[&111&#"11&#"327654'7117654'7117716''171654''1&#"1'''711'''711`Z%,0( l  l Y`Y7 0 7YHHH>H>HHH>H>`Y l  l (0,%Y`Y7 0 7YHHH>H>HHH>H>Hc471163#"'&5&'&'&'"'&5'71&547632#"'11#&'&'47676711#"'&5&'&'"'&54763 PAA'&  32? hhh  h #)X;; R66  $%6  &'AAP ?23 hhh  h ;;X)# }66R 6%$  )7E#3#"11!167671&'&'5&'516735&'516735&'5167@MPPMX000000000000)2@IW`n3#3211!1&'&'16767"1113151#3#!51##%4'11&##11315'53151#27116551#113'53151#1133151#1@M  @ PPP  @@@ @ @@`  @M  @@@ @ @@@@  @@@@@@  @  9Kbz676'&'47116331111#"'&551'1&76771#1"'&57711#"'&5471##1&'6731675167'&''1&7617716` " J<  NK /WWW R CYY; <     P F<I CM VVV S `  < ;   3q676'&'6171'1&7111177161'%1&77'716116771611''1&''111'1'11'&771'1&76} .Km(  2 ,, t  7T 4  :       fEK4' JC    ! 3   I   @ -v676'&'23111#171'1&'1#11677163011121#131210331210331676751&'1#171674'&##1&''1&''1&#17#1716'&''171133P  mWX) ; 6j8+E  900" 3,9 `@^ 5RX ~'  6! YL$R Ee"113113151311315167675127654'&###"1"'&''1&'&'&##4'11&#"1!1"3!167675  )@@)   911#") I   %  ) )`  )1#   %>i%6711671167&'&'&'#0110101010101010101367673'47116331#1"1##1&'6731254''1&'%3#3#1"1##1&'6731254''1&'4763'7161&'511#"''11&'51676H9:"""":9HH9:""/ ,&#08    ####  //::////:E4%     %    //// `00` Zkx611111''11111331#1"'%1&''1&7611&5&76771516771'1&''1&767'&7716''11&'&767 *~  HG! W J". G5 T%   2b 8 K! 5'2 === K ," ^R[dmv715167171611##1"'&'676'&''1'1&761516711676'&56767'67&'&'6767&'&'6767&'51327716551&'U 0 8I0..0I8 1  )) u00  3 (    -GE--EG-    ( ))-P0 ^t}'#1'1513''&'#11#1"1!167674'3111327654''15151716'&'&11#1514'4'11!1&'&'6767!&'6767&''&'6767&'+EEEp@kWWW){    00  +6 79 9@M    8h@`% p k"0  037 6SUG  G5m    0;471163!12#!1"'&5471163332##11#"'&551#1"'&5 @            /SZh31113!1276''16767&'&'513167&'!#"'&'&7110101&7676320101155113#3#1&'67$  $ph/PP//PP/8  #F+< <+F#  @+;hq&113311132771654''1&'&'1514''2771&7'1%4'&'&1##1&'5147716'&'&#1161676767&'O( P 6m p @ pm h;v >@9@=)(U%8 (h mp @ p m6 Pyv !> ?9@()=U#",%Uew211#"'&547634711632#"'&567116731511'&77171611311!1&'&'531316751&'#5316751&'#171316751&'#      Ո@@@p@@@@   8  B*00,L@@@@@@@@9776311#1&'&'5167716316767514''1&'47 U$11JR665 &% Q#/.3J1166RL6Y&&5+"C&Q6111"11'1&767676701716767776767017167670101317111''/U--/.Y# V--/0X_11''N+ L#%23b+ 0**1/11/ ,0//1--6 14410%%  ""01663 ,#4^671167!321#12##!&'&'113!151!1"5#11311316751316751&'#151&'#1)    )@  00 00 `)  @  )@ @ 0000 00 0&&11111!16767516767&'&'&#<<11   11<<###?  ?## %5!16771635!1&'&'51! X;;  ;;X0A8`%11#11!1&'&'51#1&'&547%162151476331211%1#11311316751316751&'#151&'#@    k   5 00 00   ^% y. ?0 00 0$7DW11#11!167671&'&'#1&'&'211#"'&54763676'&'67116731#1&'  &%    @  0"@"@@   $$$$"">f%6711671167&'&'&'#011010101010101010136767367311311#11#1&'51#1&'5167315H9:"""":9HH9:""/ ,&#08  00 00//::////:E4%  0 00 0ET111327654''1&#"7113277167716771010171'11'171'1'1171677) `"""c c l#J-4C4-KCCC  M  ###l b c#K-4C4-JDCCC M  I\ex7''1&117716331213676751476771674'&''1&'&''1&'&#211#"'&5476367&'211#"'&54763 < > *!%# "L          '   P   -&'11&'11&'4767676'&6747676++*+@@+*++6% #0//6:>?+,,+?>:6//j #21,&-,@!Ce4'11&#"113151#1513151#15113312765514'&##1"''1&##1"113312765514'&##1"''1&##1"@    c  C  c  C  `@@@      $-6Ma7"'11&547676767#!7&'6767&''&'67671167!1!1&'&'67!11!1&'&'5=  0/XX/0  zSp       %%""""%%   `0    ` D"111&#11&'51"1113167675151&'&'"&'&#"514'&#  -,:v6%$       I8&;'$$%6@     @-?"1111"''11!151&'&'1#&'51514'&##676765&'!  08""!"80  @DDDD d T55C@BC44T d @1[h11131#1131#1131&547675151&'&'#3#31311#11#1&'51#1&'5167315167&'&767113312765&'&'#10    hh'((''(('  'f' @P $` @---- ''}111#"'&5471632&10#0101010111101#176771036767676771676771676767677167673167676'11#"'''&5477163211' ` .                   `F               ~   !,65&'&'#1336767&'&'#'6771!o()==)(  6  iiii =)(()=      *R671167!11#11!11#167!1!1&'&'%67311311#11#1&'51#1&'5167315@@@@Z!!  00 00`!!0 00 03?K671167!11!1&'&'53!12765514'&#!1"3167&'#33167&'#@ @  8800@ @@@ @ ,N61'"''1&'#1&'51&'#1&'&76326''1&777311311#1"'&547677167  *   I%+# ]]]( L=Z[k; 2:  ,A   P  P 0R./   5"6I\o&11121210071676'&'&'&'45&'&'&'"#0117%'211#"'&547634711632#"'&54711632#"'&5  YHI*+, ./JK\&'AAPe |  @      ,+*IHY  \KJ/.gPAA'& e     0  <#3#'1&767313#301!1&'&'67676701010101016767&'11#&'&'&01010101167516767&'&'010111&'&7&763276'&'5@/ /*) )) )*T        `G  G "#78R))R87#"X     #3:kx111!#"'&5476351"'&5147633!!!1!127654'&#''#17'733113277131276''1716'&##1'1&#"1#1"3773111#1'57'137771#3#31''#177'13`))       7 8  7 8 88*E 7))  @ @ @  000 00 00 00 00000000H0"+E#3#5131%111!1676751&'&'!5!151!%111!1676751&'&'!p    `p    ` ` @  @  @ @  @ !2O3#31312#!1"'&54763317167!!!1##1"'&'"177116751176''1&#xxx `  `    P''P     S@P''P!2O3#31312#!1"'&54763317167!!!1!1&'&'"177116751176''1&#xxx `  `  P''P    @@P''P"2Oy556771611111&'&'5145111676751#1617716#!1"'&567675#11311316751316751&'#151&'#1`` `$%66$%0""  G G 2 ~ 2`@::: $$ :(6%$$%6(0"" L L ))7 7))E471163312131514763312##11##1"'&51#11##1"'&54763315  `  `  `  `    `   =Jer676'&'''&#"11132765514''171133127654'&##676'&'34'11&'&#"32767653676'&'34'11&'&#"3276765  >>> S<  +<) @ 5#$$##$$#""""#$$##$$#""""`@111 @&o  1!  ))))####))))#####=5#15135#1513'#3#51313#31#15111!167671&'&'!@`@@@%8K^q /BUh{"'11&547632#7211#"'&54763211#"'&54763"'11&547632#211#"'&54763"'11&547632#211#"'&54763"'11&547632#211#"'&54763"'11&547632#211#"'&54763211#"'&54763"'11&547632#211#"'&54763"'11&547632#211#"'&54763"'11&547632#%211#"'&54763%"'11&547632#%211#"'&54763"'11&547632#   `            `                               @          @                 @     @     @   @     @   @   2EXk~71132765167!127654'&#!134'11&#"3276534'11&#"32765#4'11&#"3276534'11&#"32765'2711654'&#"3"11327654'�'&#"3  P "     `            P  "               D ;^676'&'6171671171631!1"'&771673171%1&7'1#"'&551'11'&'&77171 2' #O"  `     Sppp  =% 0   &+%g".   \000` Ko  !@S"'1#1"76711323676'&'131276545&'&71514'&#211#"'&54763B""  r  56C  A""  r  56C    56C  A""  r  56C  B""  r    *O\z1&'&'67675111&'&'6767516771677633121311#1&'&'5167673&'&767%73121'&771#1"'&7716%''1&7676171676 ` W >     u'''8  '8   a `    9v   `   p  p h  ZZZ p Z p ; d d'671161&''1&76771616767'1&77[ X<+i''Nqx#"''1&76761147632171676471163311312##1&'&771#1"'&511'&''1#11'&'&77171673#3'1  X    X  J3  J3 ` @ X @ ((( `  $. $  ` I  I     ((''Nqx&#"176771132765117676''1133113127654'&##1716'&'#1"11767713117676''1'1&'771#  X    X 3J  3J  ` @ X @ ( `  $ .$  ` I  I     ((((@'=Si#"''1&767611476321716763#32##1"'&547633#32##1"'&547633#32##1"'&547633#32##1"'&54763  X    X    ``` `      `  $. $  `         @'=Si&#"176771132765117676''7"1133127654'&##"1133127654'&##"1133127654'&##"1133127654'&##  X    X     ` `     `  $ .$  `         '(Sf27716'&'&114'&#"1'1&'&13%&17711#1"33327654'&##1514''611'&'&76777677165&'&' X    X #0   00  !    1%% `  $. $  `  4   `   q  B$%% '(Sf21'&''11#"'&511'&'&771631312###"'&5476331511'&'&767716'67116'&'&7&'11&567671'&'&77 X    X #  00   0   )%%1  `  $ .$  ` `   4    7 %%$B  @")GS^|11767713117676''1'1&'#3#717513316767&'65&'&'#1"#3#51313#3#1565114'&#"1'1&#"13277pC  Z B &&&} P" "@ `  00 I `    --```` "$" @ @ J ` @` ,97&'&767367&'&'!16767&'&'#7&'&767----x()==)(()=`=)(()==)(p----'((''(('#-=)(()==)(()==)(()=-#'((''(('&I6711016763#"'&'676767201116767676&'&'&'&76@    *+55+*    $44EE45#& +%>>\\>>$, & ((34% %43((  :+'',9 %=763312116765&'&'&''1&'&##1"111!1%1&##1"1 <2$ &)3 .&&8999#& 4 ')  *3#351#1531676751#755&'&'#113D----D@D----D--D D----D D--#0=JW6'&1111!167671&'&'#1%&'&7676731#1&'6731#1&'6731#1&'S ----````~ !lQ'((''(('@@5Pc7671167632#"'&'&'%211#"'&'&5476763271167654'&'&#"352711654'&#"3!"<=CC=<"!!"<=CC=<"!  ####  F::$""$::FF::$""$::F`   """"`   ESao&'1#11113167675147716551&'&'#14'&#"#14'&#"#153#3#1&'673#3#1&'673#3#1&'67p       0H \  \   H@@)D^k671167!11312##!&'&'#1&'&'53#351#1&'6731514'&##1"'"1113312765514'&##676'&'"PD--   ))"@  @   `  P"--D  ))"`@  @ @ `[`22 ,y H[ 4} 2   >? 2 d ,Y X . &  Version 775.01171875 (Font Awesome version: 6.7.1)FontAwesome6Free-SolidFont Awesome 6 FreeSolidFont Awesome 6 Free SolidThe web's most popular icon set and toolkit.Font Awesome 6 Free Solid-6.7.1Copyright (c) Font Awesomehttps://fontawesome.comVersion 775.01171875 (Font Awesome version: 6.7.1)FontAwesome6Free-SolidFont Awesome 6 FreeSolidFont Awesome 6 Free SolidThe web's most popular icon set and toolkit.Font Awesome 6 Free Solid-6.7.1Copyright (c) Font Awesomehttps://fontawesome.com{      "# !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv exclamationhashtag dollar-sign0123456789 less-thanequals greater-thanabcdefghijklmnopqrstuvwxyzfaucet faucet-driphouse-chimney-window house-signaltemperature-arrow-downtemperature-arrow-uptrailerbacteria bacterium box-tissuehand-holding-medical hand-sparkles hands-bubbleshandshake-simple-slashhandshake-slashhead-side-coughhead-side-cough-slashhead-side-maskhead-side-virushouse-chimney-user house-laptop lungs-virus people-arrows plane-slash pump-medical pump-soap shield-virussinksoap stopwatch-20 shop-slash store-slashtoilet-paper-slash users-slashvirus virus-slashvirusesvest vest-patchesarrow-trend-downarrow-trend-uparrow-up-from-bracket austral-sign baht-sign bitcoin-signbolt-lightning book-bookmark camera-rotate cedi-sign chart-column chart-gantt clapperboardclover code-compare code-forkcode-pull-request colon-sign cruzeiro-signdisplay dong-signelevatorfilter-circle-xmark florin-sign folder-closed franc-sign guarani-signgunhands-clapping house-userindian-rupee-signkip-sign lari-sign litecoin-sign manat-sign mask-face mill-sign money-bills naira-signnotdefpanorama peseta-sign peso-signplane-up rupiah-signstairstimeline truck-frontturkish-lira-signvaultwand-magic-sparkles wheat-awnwheelchair-movebangladeshi-taka-sign bowl-riceperson-pregnant house-chimney house-crack house-medical cent-sign plus-minussailboatsectionshrimpbrazilian-real-sign chart-simple diagram-nextdiagram-predecessordiagram-successor earth-oceania bug-slashfile-circle-plus shop-lock virus-covidvirus-covid-slashanchor-circle-checkanchor-circle-exclamationanchor-circle-xmark anchor-lockarrow-down-up-across-linearrow-down-up-lockarrow-right-to-cityarrow-up-from-ground-waterarrow-up-from-water-pumparrow-up-right-dotsarrows-down-to-linearrows-down-to-peoplearrows-left-right-to-line arrows-spinarrows-split-up-and-leftarrows-to-circle arrows-to-dot arrows-to-eyearrows-turn-rightarrows-turn-to-dotsarrows-up-to-line bore-holebottle-droplet bottle-water bowl-food boxes-packingbridgebridge-circle-checkbridge-circle-exclamationbridge-circle-xmark bridge-lock bridge-waterbucketbugsbuilding-circle-arrow-rightbuilding-circle-checkbuilding-circle-exclamationbuilding-circle-xmark building-flag building-lock building-ngobuilding-shield building-un building-userbuilding-wheatburstcar-on car-tunnelchild-combatantchildren circle-nodesclipboard-questioncloud-showers-watercomputer cubes-stackedenvelope-circle-check explosionferryfile-circle-exclamationfile-circle-minusfile-circle-question file-shield fire-burner fish-fins flask-vial glass-waterglass-water-dropletgroup-arrows-rotatehand-holding-hand handcuffs hands-boundhands-holding-childhands-holding-circleheart-circle-boltheart-circle-checkheart-circle-exclamationheart-circle-minusheart-circle-plusheart-circle-xmarkhelicopter-symbol helmet-unhill-avalanchehill-rockslidehouse-circle-checkhouse-circle-exclamationhouse-circle-xmark house-fire house-flaghouse-flood-water$house-flood-water-circle-arrow-right house-lockhouse-medical-circle-check house-medical-circle-exclamationhouse-medical-circle-xmarkhouse-medical-flag house-tsunamijar jar-wheatjet-fighter-up jug-detergent kitchen-set land-mine-on landmark-flag laptop-file lines-leaninglocation-pin-locklocustmagnifying-glass-arrow-rightmagnifying-glass-chartmars-and-venus-burstmask-ventilatormattress-pillow mobile-retromoney-bill-transfermoney-bill-trend-upmoney-bill-wheatmosquito mosquito-netmound mountain-city mountain-sunoil-well people-group people-linepeople-pullingpeople-robbery people-roofperson-arrow-down-to-lineperson-arrow-up-from-lineperson-breastfeeding person-burst person-caneperson-chalkboardperson-circle-checkperson-circle-exclamationperson-circle-minusperson-circle-plusperson-circle-questionperson-circle-xmarkperson-dress-burstperson-drowningperson-fallingperson-falling-burstperson-half-dressperson-harassingperson-military-pointingperson-military-rifleperson-military-to-person person-rays person-rifleperson-shelterperson-walking-arrow-loop-leftperson-walking-arrow-right&person-walking-dashed-line-arrow-rightperson-walking-luggageplane-circle-checkplane-circle-exclamationplane-circle-xmark plane-lock plate-wheatplug-circle-boltplug-circle-checkplug-circle-exclamationplug-circle-minusplug-circle-plusplug-circle-xmark ranking-star road-barrier road-bridgeroad-circle-checkroad-circle-exclamationroad-circle-xmark road-lock road-spikesrug sack-xmarkschool-circle-checkschool-circle-exclamationschool-circle-xmark school-flag school-lock sheet-plastic shield-cat shield-dog shield-heart square-nfisquare-person-confined square-virus staff-snakesun-plant-wilttarp tarp-droplettenttent-arrow-down-to-linetent-arrow-left-righttent-arrow-turn-lefttent-arrows-downtentstoilet-portabletoilets-portable tower-celltower-observation tree-citytrowel trowel-brickstruck-arrow-right truck-droplet truck-fieldtruck-field-un truck-planeusers-between-lines users-line users-raysusers-rectangleusers-viewfindervial-circle-check vial-viruswheat-awn-circle-exclamationworm xmarks-lines child-dresschild-reachingfile-circle-checkfile-circle-xmarkperson-through-window plant-wiltstapler train-tramtable-cells-column-locktable-cells-row-lock web-awesomethumbtack-slashtable-cells-row-unlock chart-diagram comment-nodes file-fragmentfile-half-dashed hexagon-nodeshexagon-nodes-bolt square-binarymartini-glass-emptymusicmagnifying-glassheartstaruserfilmtable-cells-large table-cells table-listcheckxmarkmagnifying-glass-plusmagnifying-glass-minus power-offsignalgearhouseclockroaddownloadinboxarrow-rotate-right arrows-rotaterectangle-listlockflag headphones volume-off volume-low volume-highqrcodebarcodetagtagsbookbookmarkprintcamerafontbolditalic text-height text-width align-left align-center align-right align-justifylistoutdentindentvideoimage location-pincircle-half-strokedroplet pen-to-squarearrows-up-down-left-right backward-step backward-fastbackwardplaypausestopforward forward-fast forward-stepeject chevron-left chevron-right circle-plus circle-minus circle-xmark circle-checkcircle-question circle-info crosshairsban arrow-left arrow-rightarrow-up arrow-downshareexpandcompressminuscircle-exclamationgiftleaffireeye eye-slashtriangle-exclamationplane calendar-daysshufflecommentmagnet chevron-up chevron-downretweet cart-shoppingfolder folder-openarrows-up-downarrows-left-right chart-bar camera-retrokeygearscomments star-halfarrow-right-from-bracket thumbtackarrow-up-right-from-squarearrow-right-to-brackettrophyuploadlemonphone square-phoneunlock credit-cardrss hard-drivebullhorn certificatehand-point-righthand-point-left hand-point-uphand-point-downcircle-arrow-leftcircle-arrow-rightcircle-arrow-upcircle-arrow-downglobewrench list-checkfilter briefcaseup-down-left-rightuserslinkcloudflaskscissorscopy paperclip floppy-disksquarebarslist-ullist-ol strikethrough underlinetable wand-magictruck money-bill caret-downcaret-up caret-left caret-right table-columnssort sort-downsort-upenvelopearrow-rotate-leftgavelboltsitemapumbrellapaste lightbulbarrow-right-arrow-leftcloud-arrow-downcloud-arrow-up user-doctor stethoscopesuitcasebell mug-saucerhospital truck-medicalsuitcase-medical jet-fighterbeer-mug-emptysquare-h square-plus angles-left angles-right angles-up angles-down angle-left angle-rightangle-up angle-downlaptop tablet-button mobile-button quote-left quote-rightspinnercircle face-smile face-frownface-mehgamepadkeyboardflag-checkeredterminalcode reply-alllocation-arrowcrop code-branch link-slashinfo superscript subscripteraser puzzle-piece microphonemicrophone-slashshieldcalendarfire-extinguisherrocketcircle-chevron-leftcircle-chevron-rightcircle-chevron-upcircle-chevron-downanchorunlock-keyholebullseyeellipsisellipsis-vertical square-rss circle-playticket square-minus arrow-turn-uparrow-turn-down square-check square-pensquare-arrow-up-rightshare-from-squarecompasssquare-caret-downsquare-caret-upsquare-caret-right euro-sign sterling-sign rupee-signyen-sign ruble-signwon-signfile file-linesarrow-down-a-z arrow-up-a-zarrow-down-wide-shortarrow-up-wide-shortarrow-down-1-9 arrow-up-1-9 thumbs-up thumbs-downarrow-down-long arrow-up-longarrow-left-longarrow-right-long person-dresspersonsunmoon box-archivebugsquare-caret-left circle-dot wheelchair lira-sign shuttle-spacesquare-envelopebuilding-columnsgraduation-caplanguagefaxbuildingchildpawcubecubesrecyclecartaxitreedatabasefile-pdf file-word file-excelfile-powerpoint file-image file-zipper file-audio file-video file-code life-ring circle-notch paper-planeclock-rotate-leftheading paragraphsliders share-nodessquare-share-nodesbombfutboltty binocularsplug newspaperwifi calculator bell-slashtrash copyright eye-dropper paintbrush cake-candles chart-area chart-pie chart-line toggle-off toggle-onbicyclebusclosed-captioning shekel-sign cart-pluscart-arrow-downdiamondship user-secret motorcycle street-view heart-pulsevenusmarsmercurymars-and-venus transgender venus-double mars-double venus-mars mars-strokemars-stroke-upmars-stroke-rightneuter genderlessserver user-plus user-xmarkbedtrain train-subway battery-fullbattery-three-quarters battery-halfbattery-quarter battery-empty arrow-pointeri-cursor object-groupobject-ungroup note-stickyclonescale-balancedhourglass-starthourglass-half hourglass-end hourglasshand-back-fisthand hand-scissors hand-lizard hand-spock hand-pointer hand-peace trademark registeredtv calendar-pluscalendar-minuscalendar-xmarkcalendar-checkindustrymap-pin signs-postmapmessage circle-pause circle-stop bag-shoppingbasket-shoppinguniversal-accessperson-walking-with-caneaudio-description phone-volumebraille ear-listenhands-asl-interpretingear-deafhandseye-low-vision font-awesome handshake envelope-open address-book address-card circle-userid-badgeid-cardtemperature-fulltemperature-three-quarterstemperature-halftemperature-quartertemperature-emptyshowerbathpodcastwindow-maximizewindow-minimizewindow-restore square-xmark microchip snowflakespoonutensils rotate-left trash-canrotate stopwatchright-from-bracketright-to-bracket rotate-rightpooimagespencilpenpen-clip down-long left-long right-longup-longfile-penmaximize clipboard left-rightup-down circle-down circle-left circle-right circle-upup-right-from-squaresquare-up-right right-leftrepeat code-commit code-mergedesktopgem turn-downturn-up lock-open location-dotmicrophone-linesmobile-screen-buttonmobile mobile-screen money-bill-1 phone-slashimage-portraitreply shield-halvedtablet-screen-buttontablet ticket-simple user-largerectangle-xmark down-left-and-up-right-to-center"up-right-and-down-left-from-centerbaseball-bat-ballbaseball basketball bowling-ballchess chess-bishop chess-board chess-king chess-knight chess-pawn chess-queen chess-rookdumbbellfootball golf-ball-tee hockey-puck broom-ball square-fulltable-tennis-paddle-ball volleyball hand-dotsbandagebox boxes-stackedbriefcase-medicalfire-flame-simplecapsulesclipboard-checkclipboard-listperson-dots-from-linednadolly cart-flatbed file-medical file-waveform kit-medicalcircle-h id-card-clip notes-medicalpalletpillsprescription-bottleprescription-bottle-medical bed-pulse truck-fastsmokingsyringetablets thermometervialvials warehouse weight-scalex-raybox-open comment-dots comment-slashcouchcircle-dollar-to-slotdove hand-holdinghand-holding-hearthand-holding-dollarhand-holding-droplet hands-holdinghandshake-anglehandshake-simple parachute-boxpeople-carry-box piggy-bankribbonrouteseedling sign-hangingface-smile-winktapetruck-ramp-box truck-moving video-slash wine-glassuser-large-slashuser-astronaut user-check user-clock user-gearuser-pen user-group user-graduate user-lock user-minus user-ninja user-shield user-slashuser-taguser-tie users-gearscale-unbalancedscale-unbalanced-flipblender book-opentower-broadcastbroom chalkboardchalkboard-userchurchcoins compact-disccrowcrowndice dice-five dice-fourdice-onedice-six dice-threedice-twodivide door-closed door-openfeatherfroggas-pumpglassesgreater-than-equal helicopterinfinity kiwi-birdless-than-equalmemorymicrophone-lines-slashmoney-bill-wavemoney-bill-1-wave money-checkmoney-check-dollar not-equalpalettesquare-parkingdiagram-projectreceiptrobotrulerruler-combinedruler-horizontalruler-verticalschool screwdriver shoe-printsskull ban-smokingstoreshopbars-staggered stroopwafeltoolboxshirtperson-walkingwallet face-angryarchway book-atlasaward delete-left bezier-curvebongbrush bus-simplecannabis check-doublemartini-glass-citrusbell-conciergecookie cookie-bite crop-simpletachograph-digital face-dizzycompass-draftingdrum drum-steelpanfeather-pointed file-contractfile-arrow-down file-export file-import file-invoicefile-invoice-dollarfile-prescriptionfile-signature file-arrow-upfill fill-drip fingerprintfish face-flushedface-frown-open martini-glass earth-africaearth-americas earth-asia face-grimace face-grinface-grin-wideface-grin-beamface-grin-beam-sweatface-grin-heartsface-grin-squintface-grin-squint-tearsface-grin-starsface-grin-tearsface-grin-tongueface-grin-tongue-squintface-grin-tongue-winkface-grin-winkgrip grip-verticalheadphones-simpleheadset highlighterhot-tub-personhoteljoint face-kissface-kiss-beamface-kiss-wink-heart face-laughface-laugh-beamface-laugh-squintface-laugh-winkcart-flatbed-suitcase map-locationmap-location-dotmarkermedalface-meh-blankface-rolling-eyesmonument mortar-pestle paint-rollerpassport pen-fancypen-nib pen-ruler plane-arrivalplane-departure prescription face-sad-cry face-sad-tear van-shuttle signatureface-smile-beam solar-panelspasplotch spray-canstampstar-half-strokesuitcase-rolling face-surprise swatchbookperson-swimming water-ladder droplet-slash face-tiredtoothumbrella-beach vector-squareweight-hangingwine-glass-emptyspray-can-sparkles apple-wholeatombonebook-open-readerbraincar-rear car-battery car-burstcar-sidecharging-stationdiamond-turn-right draw-polygon laptop-code layer-grouplocation-crosshairslungs microscopeoil-canpoopshapes star-of-lifegauge gauge-high gauge-simplegauge-simple-highteeth teeth-open masks-theater traffic-light truck-monster truck-pickup rectangle-adankh book-bible business-timecitycomment-dollarcomments-dollarcross dharmachakraenvelope-open-text folder-minus folder-plusfilter-circle-dollargopuramhamsabahaijedibook-journal-whillskaabakhandalandmarkenvelopes-bulkmenorahmosqueomspaghetti-monster-flyingpeaceplace-of-worshipsquare-poll-verticalsquare-poll-horizontalperson-praying hands-praying book-quranmagnifying-glass-dollarmagnifying-glass-locationsockssquare-root-variablestar-and-crescent star-of-david synagogue scroll-torah torii-gatevihara volume-xmarkyin-yang blender-phone book-skull campgroundcatchair cloud-moon cloud-suncowdice-d20dice-d6dogdragondrumstick-bitedungeonfile-csv hand-fistghosthammerhanukiah hat-wizard person-hikinghippohorsehouse-chimney-crack hryvnia-signmaskmountain network-wiredotterringperson-runningscrollskull-crossbonesslashspider toilet-papertractor user-injured vr-cardboard wand-sparkleswind wine-bottlecloud-meatballcloud-moon-rain cloud-raincloud-showers-heavycloud-sun-raindemocratflag-usa hurricane landmark-domemeteor person-booth poo-stormrainbow republicansmogtemperature-hightemperature-low cloud-bolttornadovolcano check-to-slotwaterbaby baby-carriage biohazardblog calendar-day calendar-week candy-canecarrot cash-registerminimizedumpster dumpster-fireethernetgiftschampagne-glasses whiskey-glass earth-europe grip-linesgrip-lines-verticalguitar heart-crack holly-berry horse-headiciclesigloomittenmug-hot radiationcircle-radiationrestroom satellitesatellite-dishsd-cardsim-cardperson-skating person-skiingperson-skiing-nordicsleigh comment-smsperson-snowboardingsnowmansnowplow tenge-signtoiletscrewdriver-wrench cable-carfire-flame-curvedbacon book-medical bread-slicecheesehouse-chimney-medicalclipboard-usercomment-medicalcrutchdiseaseegg folder-treeburgerhand-middle-finger helmet-safety hospital-userhotdog ice-creamlaptop-medicalpager pepper-hot pizza-slice sack-dollar book-tanakh bars-progresstrash-arrow-uptrash-can-arrow-up user-nurse wave-square person-biking border-all border-noneborder-top-leftperson-diggingfanicons phone-flipsquare-phone-flip photo-film text-slasharrow-down-z-a arrow-up-z-aarrow-down-short-widearrow-up-short-widearrow-down-9-1 arrow-up-9-1 spell-check voicemail hat-cowboyhat-cowboy-sidecomputer-mouseradio record-vinyl walkie-talkiecaravanrclone-v1.71.0/docs/static/fontawesome/webfonts/fa-solid-900.woff2000066400000000000000000004650201505210326400246230ustar00rootroot00000000000000wOF2j 2i6$ `lzʖ`˫pm %V'۞)=<|@UUUUUk^U?~O´lx}~~=3 Cs +@`TȔZ~[lQ>ɾ$t~ )L[̶=~BJg9OX4ُxWyfw6B1Q Jwew{'*Y:U];o!"濗]fޙ@tb 3!cs?bfY. DCpQT2yGzGYBk*B* %`2_%?OV{n[֭:LwWwMw䮩ٝ]mmMFqP+ "BDH3 0 a{Ԅgڐｿ60xT}4/p{8wG H'Rl $2Ul\,P%e;g+rƭ­3Ns]9v}U@Ւ,dK!;8JYo8d0kDv>Ϭ8C8˃w6ٝ]#[J@!]4q)Gaȅxky/˱g˲{\܊uܛ#$hH$#ђ(֭EJ*9VC5h6VqJ+^{rf앿`w^}u%5T<5v叅jݘJ0\)$:JOM Q J`4Բ}釗pvܻL!X摔om/@G gI) j&f3Ǐ\MeB5ktE4Y;qxr%+yFNzeKgFMqƣ5l>u G-j䢒&aJ:>~](g泫c+GYgy3Z=klfw|#'k2D2R~R_t{wKzj7@>z9k\5]joY Y;5l=z/$Rfza7'8SryM.hKμ_wWikNŽvf{ג7tQ$=VBqVְ:n a'ʙDǁq5Ax>}qD^>@͕fߗqjerUnOע{5ќx8(g,'w^6:D~Yt<3{K$[GϛޱXvj{kϧD,͗~O6;#ާCX'}濜rx{Mu*[ M9Yy :-oOw=A^K}UjQFz7,sNIroM`<2df? rHua% /E!Wi9:߫_Ky|"g !'U(cE:TKSUU_ܞgwxQW|q 1|#-'4J{^dn2=/p0{{S9;IJ/\Ƨqv]yxOٕ*M=ktmeQ;)LіlwYՆ-UqNXF أlzxjJ99A(Tgfפ_a3g"g|:u0#00c0000S00嘁٘888kaM5MsĜ0')s\17]Fn[V޲hR4ywٮ긺npkνwr@p-=Ld*sic:lVl͎,`p q0p(Gs 9 K˹+;xxGxx'xxxO/O Z|H*դK$IHIXi,%R&^[(*d{f׭Q7nN621L|T6# ʬ1>s̜4g-ؼ2N K9$M2VBY+䐜rYy$|6bv]gOڳjoо2#7WUw\?7ԍtc"mw!w]w/]޻oa~_~cpL8%\." ":b "#R# "#*:jڢڣz'z7`&afbfcbc9V`%Va6c n^ GOoϘŸL$LL,ʜ,2llQY\E\\\Kp57 W \/0C 3L&3%L9t6LO30s2\5ms<5g1k"M8 s`.̍ VJXcMu!6fag=8 d3p..% ܎$^+xo|/#~E?~T Q1*N U괜6KtzAo}}9C9sn.Ÿ,W\rn͹5.܃@Cy<,kx#o罼YW{K~o=a?#8JI$I$,CKA)*ԔXZJ(] a2R&t%d5I#刜 rY -<A/FHD"mk؄6Ml6Mg3bFmi؞vo'v]n}k[dwr:bN%rZ^!iYW]0{{uG'Oݸn^wǸ&w_/Z9*D8*JijuUn>@ SLX-S+&MP;1uM=SoGw^jGu"X'S/˦s\.ʺfn;nzgkrf%Os~Ay #@'w䢜SrRr}M6d! 2 )2Y&0@2Cdf[hچ֡ehF^jDo2h!j|a?~7F_}/ETi|wfkxuUW ^yi/%z.=g1 yjO)='2>72 8gY3ΘqS8s`?-lb=kYb2)g#қthG+Z҂f4>CmjQT2@9 Q ;YHCJ$$":QD鏾>酞n.N뤎kvijVkVhhifj&k&hjiizj**ʪ ())*"!o( g¡#l¢0i#######_Jm4TŵB=U/UTES9DTITRӃJk8:/i66"_=7qpWpgp'*p'7?kwq$?7qr/hhhih6SLꨎ**1+/񈚩ꨆ**pb!!n>cG.kP%`qWRIgvfe`fU~.gc~ď!~Oe\8;{Go |75\'^,+yh/+9=w}I-36| ]X|ͳE٭-7l o  s۾}B{hwgkul̓cS>f z|=۸Su{cH3㞪u0,5ݎbJ`J'] $"LRԠ&MRH)"y"҈4)hN .ܮ+:n[V'I{޲>>/Kƾ'~_On2QeTP uRguU/V HXxMMtm:Ugl] u.%Tr]un׽zDOMoSkvhvihi蠗^{Eս3o୼v;z_|>ڧ43|9_[D?O3L? r??߷|#~XsMpOx(< ‡y*|~DIɤF2itJ'=>h9B@ y@@c -N@q+0vՀٮ:0溚倥."`ˀU.]Xk]#`k wM )56ZBCwC_B#5'wgQݐ ru) M\'h,:C wt/.Х rA@1{ IO=]i:~b/^KaBz|*çAz%|@!}vAO(?C! jAY#5} Y] {aC7}O!{]큗 #>&ȎCC@&'}yh:?#2O~Z4" IwII3 VEb]2~EHZC̐ԀGbc 6ExbsW!@bG!vfBboh;!Nq*lB? .8jIşoAx|;ē  TOtB[ ^/ j-E8MoB Vh۠ovBNhĻ@^q#@!>}_rw@"?B- @<_A>PJ}.>[pp% U7S߁7Rߧn~~7TI%.{x ?ɺ7)%@ Mf.yi"LNƄEh6ً >469$f4МE؃K \NsHi!Ms ͭcip<4Nw0 ';ޡKX΢wz;p* ]F8 RA\ԏԟpiiHHc WM(V%G4II'M&[&G i HS"CIӒ$BZZX iyKx iE≤Hkڤu|Bg-GH[vWi'`igI|BI$|Cڛt$Gz_q N夓 HJ H:t& M:؟t@҅B.Bxt'CH$%]M8t~q%u;Hw%NAz&qjۤws>$}ITjD\%T~ג&|H'I{(^ҟȋ"/A^/%/M^xyb<2yMO#oyC&cf-y L|,8'|bkVso&_ /"/z+wo#I,,V"Kacc i+o$@/?1)_&fe7$B.=?#+#%Ɠ!Om ~Aۏv +!C}i"61| ]vKӮN`5hפB"nA1vwEC{dkbZCϟĝ2<^br#=)ȓSS)L1\CFCgsbC>MDKBN,J؟|XRK_K,C~',cXLby+Jbe򿊱 m@NJ6&mIKHb=4f+67msp[uh$mbsf]{ۡ`1a%iGюS؆veIlK{.o"IiFNi/;^n%v}"K=i?F^h{ ľQcIOM&q5āԔ1+55q5"Pj^j>0jIA-,q$QGSKJC--q,qJSH@.q"NIDm@m8~kc"TjSj34j+U3m3]݈=Q{SSd,uu9 u(uquu4qu<=S3ۨ$qum_z#wRG]=}ԃC׆#cH19|Ex>>}z# D>#}gUq$ϥc/BK_TVʰ/d1l3: ێ~;F~џ ?E8E(Wcow%N'?DDD?8i$NgKIdHC,q.9y8I\@NøKq%99?q$!\J:rYɕ$n W5ȵbAnNnIInCnGC ɝ$ wxܳbOK%W$>"_|C-Ow^|F~@~H|N~J~F|Iߐߓ?ߒ?ߓI'-gK1j8jx7jDJSSc\_k,$&4"!njNS #m ֨" jj5`jMUlèuhQRFi#S;Q;FvvNO@::R::6.u$u4m|x"Di鴉3%mR6uu1mrRmJrJT5uii3PwPwfB=60mvQE9ǩ'hsQP^RS/^Fڂԫ%m!-k]s=o NOH _#,q6TMBA/ q>JR"(u$J]T(,.OD\ !FAiJs(- JWCi@ ĵPJF($n2Gf($ne-, m,q[(0n@(CP q(KP΍{By $]By_~Pʯ?CIR-TĦ('a2J HRCHpQ"j:?$zPMbc$.Ci0Ϡ4PA*W $B q9J; ҾĿ~$LBpQ:Q:[Q:P:]P<.%%H(L(A(Mt&JJJO8'I(=M(=C\ #D^ 0^&^#t$4"7!h'f>$a>#/w$BGnBJt'ʁQE(&sI $Gy2O('"w1ʋ$By+sQޚP>oP>(OM(B(Eb': p!.Ӆ˱ =/B&F6נ||'qP~U(?D\{!ʏʏ?<QA ?Q~P~P~ /BZ_"Σ2Q~(JB"wH0?&~5ʟWOI\gݎ$G  gqo;\!*ѿ(M Y ~.ZD"Ctăqo OtD!kBt#E֌ȚD kI\'dYw$ ^$|  FdÝ0nC6Ǒ!~dsIx<C6א- ;dKB_f`#!loG/ فVV2;Cvqg5 ~)I I}l#;fȮ !~;d݋zFvn}E\dmfC$1dZ}q^|6OA񓑽Gt=.F=~/*0UDTq$GO T $DH,TATÈ#k"XdU6BJ=Ց ngd3 l6G6-%n d lqG!!n dKwe[ٲl9NEG$ ٺ "k`D  ]N]C]KȮ#sn n"n;H{$كD_"{"{vdrdOkdOȞ!n&Ii-dpudII0]2dF}M}Kt7_;o/RG6F}h+k+q'|Džt{Hx)G<.3/ b.UE"asI8|'q $q"q!6)u!)u#. 7@~s6ۑ\뤴9Ǒ#/#\=S]ĝ;$.{Ip8Q#MN  q)y'ȏ'l$q $H}Fo$>C)԰N0e$fRdy[ٗ"ҶRtuy=X`0-/WʕyO֓YٓO>Y:}hhh'OjhAWjL~Uh4h 7 57$J8=R5Nt@@Wۘ"sQ<-OZ_o18YOVZ{qEQGт9MSGQSQE]I!u$IY/49yR",Z2imzR)wvrd=Eke=Š{8HD{^F|굚j:'ӝy޵޵0TM_; (~z=9Qpp8Eяna9A,O|"9ser"/q5VtN%K?V9Sn щMK" ~Pp}dٲna_8Œ$Q[g&"Ƃu"9N (0O"h* љiH21HxVGU:R P1Ȓ kmJ214IQ/)Q!"Cx y^7IVV ȞrLzOdP0SGT]W)?CNv:4mۓ-x=<ϳF)@IP. ~sBC39E)oO-wF`Z@QtjiX _0@< $id-Վ-?7 ZVuA{S^GmQ_B*LR<Ӿ`ܓ1/ 29,Izi=Lyq??H^UQҲȈR~ޣxĭ'R(2zdu\v:p>g<qkV YcDE&gY8!-G^$sI{%keIΘ<$T씆VMCEmpΘ,"7 oGAauTk4rqU.t/.yP) X}Fx5f}oAFuj$Idzx▭g럆[-ˁ/(錾{ bz6Mg}_[~bPn7XUERcLddA&:cз, t݀+DLtMc%nŽQR^$IRO n^s *p^kNimyc\^w.{Ktw]^U˶ G%6L5{Y]lj~s8wn:~Ca T~$-ﳌ#b6 Rkl ^o Db^9 L%- r;c c4RGIȸD&,CsQ0F=-I;1dԗC=:;,̛3GB)p*4Q!4pAEdS< 2#s{ :0B^4֑/LxPkT/gcGCxKk#צ9 .ROqj @U{`&LG{'΃S;vbM gTUAV-# N[-AG:Q:@X^":R}}nlOskדBvYIB5!}ch"5+:GDSj=$nl'I6T?>iSIB^,KUUxGtMÂ֧@TGK_˼ɯPmǚڟ&4vJlĭ R&;&XvoAaU;^58韤>ǸVO>_ږmο=d"-hy!$NMpug9z3&iС Ø u?eɁL"~5`k=o6ZǾJwmRà7[kNZZKݗQ۫P -7B e Ҵ="1Zxy> >P$9c2|%[#ՉzCkD&R\$HBgsp`>ZW4U ^o/xiNm;vPWWWq}͡5)-"|d..Tف X],n~#;|-X64u8neԕ;I9ъ[WɕNlcAW] e8KH"7TEA*b.APt%^h:;mK0;3Ȃi꺪$rRU R >B04]% +q$A@|{:Aq#LHB\5egcgkNMR.ݻ)n;B$m;$LȤ 2?.1tIG$J:$J[CDIbMCƘT#=N{i!I=]cҝ*A\zܒ$nR? xtS$>(J>L䯡K(1M =A0{05&qukReV9VTSWDu]=P?U#&v-h uOG?ތxz=|53z%4{SS߮ TtoU+؏v}Ϗ ꗾޕZ 򿃟1Mcg+Fs+㦜8BpPM޶%c QT;_dVMZL[7NEAr`]u2 tBpg*:W0:c3>W=Jx꺚sEC3+u͚6 u73m3&uj!LsRHY:1-p347d.~%|S0ll" CYIxE}$I;A_P͠@W^d4Jt:%M=+MzYИ][LZc^׻ 噕vEZ| @Q0@Q``Xa09Pƒg Fsw\R\|yqʞ1`1׀3> ؀1s<.dv;xx7)Ed{~=|}}}}n x!h„!>#sӝDdzrzn%^$IHN'gg,t9 ?ҽw.ѱh!4IS?ͪ"{2i΁{ww^t{Jw%&݋y FId{2OEH҈r| (3VDjpc߃Ĕ%k$=I5tEvMkiVeTDU CMSD0e p ;HLa4,˶Nt]U)d(_t:fyՏxIdқ?nq|S4 ^ A I15)ԲʸFE2EUADI6 A4ӔP:qJl`ڒ!ȦAR1z%qM.QG*M0&T/jmCYEEUgeƯr!qw_| }=>^F]kc#utX{IJ;P/_#HI@X2xVt}E4 ےU%RLcJLC8U=UvHd*_BQwSY]0TMVOadjSӸ7)RT}&C^+8OˍJøyA]ZGǩ Y$>ΰ1qAАGi_Ysn\Sz{*Wra3M}׊I0! )_t:Ep(ߜ l-eL)?ggkLP{ɯ)ns3Mi;1Np&8SOΏ t3Z C Q- 4DB.BiRVdY-sGO/Kd:$U }7!|"0:%5DÇʦ3"qa0cp22/./RcJP5/ jR\QÀ.ˉخqٲYcj @{Z @}EM$209o_9r$EAPjS']o1j{,W,qòT;_ZZJթh@v: hƚ6=^!:A]oB{u9-"+nqB8H,hPdP8Js2h7;3q1&)(`ycKza^tT bй{Նp*Xp3VKvUW͏a`p|10fpX,k:Gע'd$J>80HO+56}6cI,r[- Y̞\0;NnJx^i Gy$ᗅ9<(TM;ome99O5Ѝtz=ށPkrIft'$^T CGX!V7uBz 2"`%J/@dج3ǽ:wo8`.!~g\C[om].W ] !l:(>)OX;څ:{x$~- 45$Jn kV9GL '+ e1-`NU}[vFZ>d;.*L}`z~4DO鸣Nc&iY~ZSz= O^,;* An {R>Cm=E(1< :$)ųm6xHS]}@c 8jM10^{+(Cs1Ip8iE-"q.A\M\x'Dxnf[UM&*<"=e諶 FΛ0dsK94_InGs1CKxj 8}{HK==Ķ՞Ֆ}&#Ky; Дe-\d3 MYRs5Y61߬&:p@/_'- /)5%na߳(i+^0jPUd2yEj C_uϤ {'/}Y9Ij5 S6}m=2@>S;Xs oacD{+5\h>"Fߤ ~VЛIOw1xQ ݔVm`Ǯ|b;]| *]JF 4K[pV40܆f/Dr[FZ|$Ec K e^/ÿ[D7 iqYԋWVgYf.dvOILeK/+.[\mT˺˲җO Mܻo}{L] ;FFsGz9,P\լA  w.f?p.1r^.Nn TwYbFhL$SoԸP0 )1)-% POaB0cPͣkX2 BP:f=FΛ96 Ƥ9Nac( NeɑSD!?6ɖh ,l\Y+jrJ-:;}Ddn,Q.DW vArpCqfIV`@/&af!S2#`%lѿy h=Tb["Mcm^, |ujmyR #μd`0QDbn55mc sYP,t%[}ӊV\#1!W-a׉о$N"ˇ2UM>K{J\^*CTm\K8gn\ M55z ಩OT3Um<MtZ7!*{׾opVTٰ=z]9jDǞ{r'\j[֔b{PYv*e*ZVc9"aw;\3 VBfyO k'xBM}o*F{E ut}q붲^VOdCSjʞKCg,NB=;[… :oLU!TQk'$g.ScJ /8)4R+1`e$% ]ߣ8"x|{2q`E8Nԓ^'Q6ƻ5rKr0TCwԌksj=b\y!v3X;*pL x:Fn^juSs;Fj1wYŧCE\/ȝ)^.qxk,9B4Ma*yATAg/`x֪JR\ꬥERUg*5aư:SU~-j(yj-6|}"Vw0N-޳|axߪ7>:.FOu^ dcA/׮K)54]gFN3vSuOM&ۆ_e;ny0|c`'eйKLTa`L!݂^^FhFc`h0MtTU3O~t4MU>kbl~(gH֙a]`"Ȅ/P>jsΌx#ggtx` t}Or8Vu'WɈzvDt4NDPhTd,}8!C]mi n;Wq\1@JwCR܊PQ CQj %4 iP<c+8= mQ^/=co0h(J$[ŏ!hB͸JHr-Y& R]Su]).>=*{bUdg]qJo}Gqi ݘ"'Jc>a&; ̠r7{2+OY38H?:YRu]|t2ְ:|`QNܟSyJgW= ~s: pD~29OFRt5zU d,+%Ff rxO3 XiH( (&ǶQ㫩zxay^u}:DeӦO|ĉ< @90]n3ux24H[&0$ ^L/7=79GMMc>t :QpSN'gN' 5|hֿfn8NX4Zw OzР t=*|7Z/]AE`G`Y J#g0WӖ6cf<@mÎ +h_,Jܜ2wo}g25-X {ajc41:#BP+޺J"/T5+U`iS:VM6,3W& _uǣ#]t(&Y7I Zy`kKI7 "TQhGk2ٲ "*ܜ,ȣRtBʷp#_Ԭ[rH&ső!rU`dh;ܷ(Kzx,KH0i$}^38@*7 P'T ^깖Ź-'ARa-6xVm̮_j^6TI(x˹e FAD 1\c i_{YL@7a٣uQ/Mke3JkKlP*^7{DzrJGe_$Lui+l3ZV_kbןo #e=][>ub tO[^gn9 *Y39hD6,.`-_ b,D=#?]pJHAA01pX@x~V}7@NQZJKTO.n EZ8S͔ 9%i%Y҈kNCka<:~A7W{JQSfTM;SHx84u_ UiN-̔oϝGԳYx++rWه\Y_A`!þVnt݋ȉ@a$ÖID_l׽B+Use^s?ngwϥD TUgasцf?,6\{#{^&@ _Rtl`&fBJ<9ާV܉¸yO[qFHFe$x[ 5Ûm£:d]5tʹ{Jk`|Ջ.8v޽:lGĥ_xZYZ F9O 0B0of9̲<1ʏE bHg^Q[ݧ8<=" eRtT*6PU]qPXcLWdJyF/v[ s^g %Ke+6j a;]>dx%$/Bi>1lA8قGzh?!;zU/1 )כb}9{%nEzkך+-fU8GKd7˯bLBNXz¨2&Bd| d9.Bjui^!7N6\=C\|rti(\yED'<'UI )LlݷT\zt\Xc7w5EbD$WՇMc?RjG>@X _H22+'DR(bu'% ZL> ږ̞n>"-jq8[yCO8n?5UմfSTuz{#ޙi <qFj4O};rF|zy,Y1_kBZb@˦adeV̶hG ,4TtFIZ5uI1'CN+8\i40E[MuI3b)^=e-sJ-N_rn6Q[viFq\d;h':ǜɒ"Ggs(rاD&cJrh~Pi<]ОҖ_M <,[+G8WUU3Z)}9eɯF@ -ڋNJ(pn6~{V݌.a'(~@efƯ]5)@J؜嚮[`^}-! PQt|: N)h:പZh@)sJ_kYpE먌a$B@T$&yJf?oLBRv'ȁ0 so*^/I7s#4Jܲ4Jܲ-?f3Mx6E#!?lG 5 ttJ|1?ל*7Z]J5J5^۞Ӈlz0۷_RO)W0 D|F3LI`K1 oUOAXw]>6A!H1x%ɰQ>w| ,5&[w0e$oBr`03_FF@84y9> hM|F| {v)Zu=!4טlo>asTg @PEC*4t*jw >#V܊L[[QmBVqolX)UE9NMQt]S-:>g9=t[Ke:@}7^5U kxӁ枤)xtB a ,F\ϱR۳6gtYD遚RzjM{4Qc.9s3 Uپ̃y|6nGs9sJe6r (Ӥ)0k&`JkGUNͣ P]K ȄGb ` ZHXrX%~$!\zԔH)~,lYS(gn8н}X0zRh5fTT RD&(NcˀcE`` xE plQp҂iY &D!S@`B;@.-:y'&3헊z Ռ<KҊ-s81 PJ EIf:Ӥ%aZVqJ=ՎS:-ˊpN)LUxδdSJj\ϱ.(sM/ԪrW?EBtS, EF]G _j+!4iI|-]b(Rk,Z8SJxaO ->ol5)lJ{[[ yBTt>U7͋OFafuken$q=Z@SJU%. x>Cx]ux 0߹sNx-)ADI~~eX?B|`E+\FZ+4jĭnݢG bz颫 Wi`SmAWO+Ѝ3YszJ|sItKtL4S ffV6^?_}_x‰J%-G:\j(J8Ae{y:E>2iDqBFyyMÎc'NA")>y}Sk"xG?PCgiRdzQ^d'Rj׻@(H 4L"՞Rg;Q4yx2t:~)upߊ$ܞٽ54Y$+ol5TFka1tRv4I#K=M 2{cGYĦ&`5R!EJ+Ku k Zq( 1YOM#+0ҨЍ&H %1;왽,IeU6ٲzvd?; WIlZՙa+;[HՍT0j#u޶mmRx@ (8;FLLf$AN0z(BN0PMh?7HD^ړ(,y V^:ޯ3MdYٍ+"T{ `̻Ҥn!Ȳ3M+oht*@U\R~ӧUߣ}Ax'W}j:8]?[cחKv>DTuL37ZTekOqNꞻwT CI^ټwmwsSN`ǡh?=8.^H3Xފd$N$v$ֹkZX0Ǘ9ȗk<[ &zBv?* ݜE$5cD#=MEYѧ#YB[HCoBd`{mDTRzK Edc-8 ;ތ C15& "`nKVHZg (~ۢDh2"2uMAj{= :; P)LS.K"7((I@d]ט$YvV*E_ZR"3Ȓ$2N$,F!9N.@GѕL&]8ɭC x#MȐk8d[J]·{~6 }6F_=UrE$)4m=ͭr#Mqeۆ r}Nx=\O F$|)%Pk: l͙V< b('oH /uGI2RטcSqe4q`P_i' zW 7\&1V&aJ)ƕ FIG֍kj'9ݮTuֹVDWy@w}Q ,]Ӵ MUѣ6Q;2U#s|e>Hn' 2 Mat.s'gyBFn8=|}uWdbJRY$Y;dY4Y\Q$tKI,pӒ4{7M(sòEm 2r4e).Cɺ8R`n PZܳP:*")9Ъ@ ~yPY5Msbb^tnzIFj̖.`9NMs7Nl46!hdAd @BU 5W ~7w#$&$/Bq&4g19? j1А$CVI~=Oڹsј޹г)KquDH$8$H:HlJZQODAR2b(a[kE9A;ˡص{ݻux[(ɒ.XX `IIfpfXA(Ț*ј pO . z"ar.@k4#.eUMdMDRȑ4qan_<+ 'ysK}32( {) 3a lq{ݧ$|v57ągҽqJsMEQ8S.Cfw.n:z͢>$A% ?Q7gpRl %J2M(Bޯ0W#p݆$>p8v6`hJ'aS ,4ki0Dr?m:^SI,ZMD0*&ݨywA_[ZI&7ԖjU7ť^]z1熓M<&ƶdd:ʹ8evmz:B/WMSFz6ѝL'[M~K]vT]. Ҥ(xQZkJp,ń n~(&K#|<6BKxzXbcgF`F( VQ4F j-)/WUz,C&*$01݈Fo@g 2UӟnUzzĵ5IGY{`P{ H;Vr…yǽF`_fɯmBVչU{oLe9@עWq R)"]ސI Yrǖͼ2 / Hm]?e fR*׹60BsG>hlߧTKw7VR7\ul0 w 6}4f~~(*M'/pe݀@D i:,&0R p7m-G9x^])5I'Lѽ˺ *Эs)A4/'5J% nK SEc_QyNՊyQe@)~w9 afn T)h P4T]4؜0? Kʡ?oe`Zu.ʩ,9to$kSв7 LHzr]RȲ1(;x(AktFa`]]n=tgtr%cMx">#/u+}=96JqfH =|tޚ;_/y~wH;-+(tPCuV=ɹK/`K}7e'>S/Wh80{=Vz]kt ݫyA5YI_,hEG~ߌ/\S*z_8sYkWZaqQKu1χ;I>{ Avvep?iB E^ 9ψPLm9eǁeq[Vιe {lfX H鿠O2s:qRᔖ1\ܢxO\\pGǶؿ/ ,΃|c) >=oMġ= w%">2$BZm<1]1]g]g; dž'>*ws^I̓4Y U  I`eꉣ QmC?bᬞm?D?ͳw8!ɷQ ET 6EiҼNI MYTT-RU[xj9^.DW;nbAdrnWtxosHR՟[oxI)wۜH_eTҙHazX[oHs,ӝ":nBOF82]$z?m7 $$=g\ju\1;58IidCw}CJy߾֎0(Xfʰ^tdI2bx~SsS+P2GeTBkh]AQ2X1hZ鿠9Ĝ\N0츚A4ܥYH"8ݤ[aY{lep~?+$i6KE]LإOò8xƥhY8߳òkXU}c%`R=uyFt/Ǯ)HP>{M¦lK%?+?fA`Դ} hdd\FvV^/嗬iOT~kV}}a?K7z,Z')togyIJ/Gp:i]Kʣ',#RI8@IQ}=L?|4N{evH v9Z#ͫhݏ\flgv;%ϙ`fwrV ([ ~x\+O΃Kz=#%2VpWVi@ tROjC_+]1AwKwrvct .=$rjѮ`Qw(-h4%iI9[Q ̥vvC N-N͏~? I`LL*89NQ1áw0o{Jm9C'c@& "Oc!JVHX*U*pc=0d= VX<[z) 8VEͪV,hv ؼ79َmM3Eǩ<@?\푊〢fckF0Fu21*{RzsDZJqnĭfvTj"Hο:.ڊ({g0ݫ(U&DW7CJ91@f$SVȁԬ-!BBgA/ t!{VDI+Ȓc63{@ā(j{vW_uxZyi -CP%ٶ[-ۑ$E0Z#)e"&߷oqgE|Qq HOuɜbMSE;lԸ!;K+[zY7l9rӈsC4f{ mU4W} Tø&}UST۾,x}fiip,>קۚj"[MͬIӞe-O]Sk_nj(znky&Am-X]|T1Mч:A|t돭ZNy஖z~[l2`cG>j,Hq9VUuUFB1f/[Wɿ&=MM(w Qs1FQvs᠛DQp< 9J;J("R:D`ce=&F#hWhwlel嵘mgT c 3 ľSR`ZڣWh ?pk]==VI 8|[ߪ9GԎU*CtgN[zkuU/N>yegNùe7G?mP]'Ov+q ?[#'p<_?|X_©A v ]K{K8Ll[CQ7sA$#M2@AnҶs==e 8Eu۴Op?ȱt7g}Va|4iu3UMSܬo Dv۠:;;;+˯?JiTq BxjK/= iQ'5S5%cW%SMSXy@O(]':c [Ac>ۄiVGƘ]` Uk훌L߯Ӯ&Da]40cvƍ7R'orJ`j,(["0V;zc|WZKl}Q2L6y7^?|\U9>wV'-R~ѺH"M1YΝ5]TjX;9ɜN4Av$DViboՙv"ӝTL7Qd1gwp?Q~ځ.ƙV $!A_8ӊ3e8NbHٲ<7NQJr-ޜ$7)y'4U ~T`I#Aj8cQU;*IC,;x4uh@P%?)ePpt;L{޷uڂԌDS+kC/9wvm Fl^SƪʽCd G&'9>f*Vyڱ}}H9Hؕ_| =\Zhi>͌66H %ݝY/8&6p:Qw,hT=O 3w:ݵՎtK;s7։FǼiPK@kCeu߷)wnuwC/}kQn B7=f KC>T0$[` <%)b6vL7LggVʿ|8Upό[K ibXO݌Cx6(j>,{-BfRd'{{#[|ߣ` ,wXǜRN,g48G CEeoWbdtol[e^P[z-^M뺞╌4g8;>-ϳ~VO~8APu`TK=z3eY&g=Uct R Bl ZA*!e|2tD!M녂!_Z-A3E°nu #!d}9$a+l=ڨ;D˴Rz_fd{^$+>.ꑨES)fuq#MF0-]}@Y^4/aF:нȟ ۶+ߓeyLtE$z{J]hӏ,ڇ!^Ne:tk5񔖺 N\jͅ;XQ!2XҦ2\u|M7dY`AҦL1Ł-@b|R'O#[4i#&,C0MAeP/ q?ObF~.T]x7Cg ZX6|ޓ /1M O(rlxsR@]V=E A9ʞ(̵a{Ea:T4t<<<.\tVs-6U˓=j&=x.VZ :7L8q3Kخ UA)o.Q,IeTtg`wV"ǗZo%Qz>5tY=9Orc{^$tL;*ߟy_Ja94x-[{ H ˒0>5먣 PVޝL+JY?ҏq:i^^֋@ТY]h"teK8`uvxp #Q LlZz0U-FcZL]Ts)nca@)׵@=;:%.j|Y87r1*B'񁵇E#þ\;Oڪ$QbQs7kR-o-(]R6&ct}>t{\wnpsCHMz_,*K|\}i/AUk?9|ۂqZ6 :t59ؐk9Uf(:O%|#|s fFE>C[f{ 1?c>>~c2{oa}oFPi m_[UƯ/2?;X[ւs邤1oM.KJЯ1v6ȓZo8QCW!BTü?pFe,#\R4 Pśc; *ߣbfn#]:i`m ԌyS8FG4F̃"ܒJ^d2duE9WW/;r2EiW"(4{qh; rfi댭O>!kI|Y{}\ [`ޔ %vL1^##KsPAW sd𫽎EZe##HcdҊI#I;:Ym`EW4MijՎ]ݕ&4* =G4Myy\Ag.AEI83+ $>eI{p\;1CRUi^ laimPi>73%:,RDLz0J9||^t9 s1 )֝݋S@(%"Xt75! GJxS $*_<`tWZ6c} ퟣFtz'^R4%5Qu {^!V&Ds(3F 0z^QlμVv/VsY}Ṽ x<|@5yN,S?'O3gϞ1ol}maR-–Z-( (v*c(8d_oc=7jPrM|P D4"C)q#˄:M1N<KN )BgrQ(:ӖӦ}kiЬpfss`B|y@)8u:werut:BxX1j[yRtMQE?U rR`d9Yvx"L.`{{6ID$Ra?xH"%镾_ wLWZ+Ї֕Wb.H:A)DQpkS؟-2Zk$+j0j1qZibFdbAP*kk2ש@ldߔ {jT8 ;yN^,4*憏l_z4J.UŬI"d\[eh]!G&n̟ʃˌTB" ("ArLv(Ӆ*ȵfn.=c>h{:vN+7݈Jо F!r<+!;KLVjZ4S:.jD ;lǨ/Q(1e:Z+-G;zTĢ'I*!DFK%Ð@WN@a_}2;a+ͺY ]{^ )Dll$|(ݙ rI^4+|V:4$nh0+/pCtQ_h ݋EGX(ݑl ii90%bh=7;$#lj^ˢ~i%{/'>ߛ@2pÿWvM3SJg-Ur̜*q{e|r6SC}C7 Geۆaw-(R Pz66nzz#E rChc.l S=bvl,IP<11 a+.uo2c+ uߺctT7TAS3 (^Y4_BO~hXހ>@W4Ϳ\wu 94FԳE ?M`qP-JshzJ.N>62t ~c7ʈɎϡԩ"L?o5UO6$ Y䶃=N]6sgkYk*휷"$ڸj0t=h.UtP3ǖMt)i?˒~PhbBX1ipgOTr k3%himt/c/  y_Jh>yqJcriIF.fps6u f/ d ;HzΚ]Kl2ԍUBWk{-J=UJV Ⱥѯ( (@ ]n oJĴ 9@SEW$* Z[ewH|5nVx:մEdѽԗT C-Qy=ȵ^/9]Jk0(8nm(:'yb,0,.(ɨ/8/ECd)!.7@:02.rT}6Mt:\wqWpSY䊤܌S9RZ-Yu*-H%Qj8xTEyn:z(-l[Fols<TF!nSA= ZV+Rř\(zʭU/,{z}Q/ ߃0"@G>dX EʊXi0,s_ܮ]vwG+/TsaGKƉC#sklӅ:FUe,'v;5YnL7>.f)c)RR]%aMYMIgCF4 tjnD8 =1 >ұ $0M7ꦩNiچFx<4ME5M JIL~]9/sЩWDDxX5*j/d7y[~$.yCNe7 ̼:{, JKe"_hoo`*y;U5E#:*} (7|/Wt]΅JVґA%XCumO/[TNՊ#<}OuC0ckt$6B32'{xt\ 'cz:*Gw>@jJGf" *o(J#9F*=mwme*ei yee; i+0u֣rK|i4tM7`02RUk^*`{}n]eɓ'M3LC]WxYmǖeIVTeaIRUKO:cz7GJK^~KQR^ J% 1Íd|[/Ag, -WےL2:oJ[7${S#TfZ)Uਟ`D ^K .)KɓcHu!`Ieiiif,L*gӍSx) OR5u?(wءC+t#ilϷ"̉a(p[uꑉ\.azYR3TUs-@ OKHws2U 1A4X5zqKoh͐6oYu`j%g LE듶!@YKt]#A4./[}zljdpI쉸!ީL (ߊ$caeaJw_Yˡf0z>oV"KLw#kX9|u3!=BX7!zyDz .̎ P'gG#dk=spo"D}E-aȑq:_NiY qomjbUEq4ZXouXm{_JnY{uLqE(^kanE&pg7vo#| )\6} d2W_hYa;SeV<ա9e` ]=[)iasQpf:*Sh.]łja;\˨&C/E#hPGsAQe@GB{9nש︼CźLkW3MgH*ʋSI)gX}1\"`Q25)D8Z_ãIhμl1:./S@*kde2$ǣ$NPKܟgIw%v'_ ̘:K5ͩH$k jh;v{6֮9'U6L ’-UAAsrzo_3,h.ӆ~E3*zl&phDڅr챾܇h畷NIbrK}q(q:_5A!%dĝfxש4V֍1G[[[cŋ ?^Q]hwGJ:ߋѥfSC=Œd-Jd;f!(6$h"t>J Qr>|sҙ$Z29)9F,^@WdÉwNGQGaoVszmmmVÂ1X%3uԣeY R@Ϙ#x騊=OBKD1% [ C^%(Z`C8xx3eG]O=arCVFWçD/` ЯoXኢ(L,]=WHa*֟#$Tˈ*݉/L{{di$1ɠr>!!D'#=c`0`NWzޟ LV8L^Ś(ihA/JRg%DE}?;ɻ;1!ՙ( ac4(EcR~gJ>P0'úMd< ZW_w-= z"!ٮlgY Ә;)`!R2,FMEw6eK.4e驏肘5-P.O*Jθa=_)9׷^MOcnRjРSr֫ʜ$} B beB421 jo9B5kbSW7;>qKl,bs;P yv-b8gYνyNҲ- 7 3'q9 ǭ3TD(˒ Z q+TfeNq`#H|BA ]H>@p\ǩ֚˷ڄS͛Xs?4 2u5:wHXRMg͹` tLLF`_GM˱#Kdn#gʌ2$ M!ڌ "f< |VVfr8ړ1_Rj3~^^&8u56X8\НByq#e&I0M!ծ4R nDKs~cWD%c&UZ-U "0-ٻ O]剕-siGA~e]{w*~^!3f1In8dRCf@[xOXQ՟#~gҊ0ihlmZwCe ӋcH>$=3˂2tc٥_ & {5cDWqݟG?ߨU&94S^h);k^PƭbY*>1$icO]rV9<')[DQK `O6- B1JCOG] ]]@bz Ӝ0M|H$?iWoLo3B@.[bQ8̣'M :z8~@zX`3V7>6dT&^rOְDut XKӍ9< tҊ!Quٙ̚gi\i-XD*Z,gNa0'.õ9 _bZ,QNrJsg7M,}DZhJ`LT&yZAiian, h᧳SKӤ @(\ 8U'6lϥяpv[Cm⣹_-ޔé]]AxB<H|PDœ9Qsl?ykǎQ溝ci9ZhV1Dt_ io4u#+yrP)`JḫҠFWi}M%e! RLLgY? O|u HЬ)]"t?SPC'hd$,נdYLcNJ0Bz{ S1M<LÈi3 *}MPK rQl0gJ3A"L*6E=Z ݊ A 7n*U<ƀx1AT[eoL<$MvCeA*ίDU{zn%ĒۣU IS?(j!\[_`4h2B!1 S>qx+)L0,D5i0(QV Xg Ĉ:[$ =!p$uUp8Iuv& #\ZS8 gfX疵dY߿1  =݈ՋV+vj5l>xpڏ.E7лѳQ`%2eXTa\uWk\Q UςE?>qE}֋0!@Av ,h6E0לWG}Oc~`8rIZ^ 6˶ ;g(S^=rzvûf̄!ZU"98x%R/];4>O̘2ɮR?>ʪ ܱX޽ Op;z-z0 _ĥ-zGNl҈Fd=+?ꯗKіIGշ5!@;yM8^kpwQav&MFFI76_圙5f_lr:Bk'yf:$L$'{J^"{[ģoo qXLL MRqO':f_. OPInx!(I6vpMh7&tBV v& ,J0M\V90,~J[ ;$`S5L?E9b0D;a.%:5 CP?h44U6W2{j?S8TUvNm8U@h5E(p@dҚg?8D׫$-)Ej vYG6HW^ bO{"rsg{P'fm A *=O<1Ur;Q'65R &4l@ i|$do`&/e6Yp:&Wr,Z7Os|Gཫ3n_i[{6m+:EN~.X}|g]:) Em>{2 P!e(Rx;\9#֓{nѹ+,MwXd#1NU0<7.F3D#_X.DCx1rγA_o}X_lgdSVJil1^26š%7M968jۆBc! 3n93C& G*dkt:DL7"'14U{?txf/Q@&SbL5܋;LCFG`XҔnFf= |68$C؍7,q jx̉ӥրͪHP1p/[{N&tYaW]?X]9MʎFR| ^>`ѥLS>`ݤ;RT5BI/̙w-`7M55T52z1FX\f_P>ioF+"дnW҈)ɷއ~aIBsblșTqRWwB! W)bH`%h _ئn4&w ݴҷMݨ;E&V* */mVmߣ[jh> h1bp?DwH Rkד,ǒvm555k4/`{ޚ5ȟvh@[czEI]r>syeʵ n{ W{Ύ:cMTD{93N;N"WAo?3HiP I9?{|ᡇ,\zTG v ͷY { c kwf`)[%BOmyaYw6 ӳ4,}EF$ǤQK,9PӷZIBsjA>WKPNF`T\.Ka]քbeW\rQ{FM{07V=j\z:!)7|@Tuu7ߑ;g%n\A *$^ש0̱`Mc =z`@:f/R{UPM);orttE#᩠Qݐ,i>)v=\4 ^ʔ䜰iCRPEFD(~EPzɿ[+ qBqN8%'CB?5;;9'WusˊXF}t|2YpC%gzcbpۙu_zݟrl:'l K{fp1YtOrxn (ݜڒ;JvMטk WXX,x^aIO:}PUJyX M\Ncfx>X~"Bn%2l 9PuЧ<;oDfKLc_G|.lDffYUS1[wwE*?:}R~q)TN|.cw+ܬjulReudXPqucZ+ -qJ~Ӏ Sx6-`/|AXv<$NWewuLDID|6Q9%9ѵEebf9uR̈́el:X]tI0[ܗe6.s]岡FlYE"qhYj=_؄WPy ƾqmfU /r}Yu҄EtE 'TIOży'F r,AfZm4  `ᜏpiWڌqv3o=N(xj`GyL m--kпaxuQh+yA,|dEhk(d7^3?QڒQLaQ}ݐ'K-uS})0fNZoG/y)RduȖSNɔZLRM_CshC2) U9GYh2̟oTy:(dz/>?U)BJy8 L_,sHND0$N7 Ek#lje ?nDRxI ryf~Uc4Eh.<WgllƗ7picpħ$}H1zj K:'԰b/,8ӊ3mXԃ_Q[H/ɏ(=$+]e>%[f[pNӋP(BFCDKWDUu  _r[BFIWNʉ9hAoc(R/ADBpZ;3ZBz*IJs/L+Z/4=^RP9(gO8&[M8C<:nͺwtMHQ|L{:E=i;yqnYYfY~9{xiTݲ**NYПy8_;=ťP6l ZTYTkYkܩD:269Ouw:ŷp׾HC`<͐ain־4FL77}M>S "k3ŶJŚc4-zXŊm2M~Qd`lLK˴S\]SkH(J` gSz,GoY~%x9 ?ݐU'!=~&2Х2ۥr--W"%ΤpЂ*X4Jֆi8Yh* izgIEiDeܱBȷh8@q,..}&;Hb=%G:zthN&iB>WY{L4 |i 5PQpvaup՝yzw͙n҅0gݸm&+\lF6PxKYufϯU+T-wϡH9Mht׷4ϾdQ=S5BK)hzf%u8G?T *ٙ&*r>!$IC9:W4Rݱ?dAPLqa5߂1:ɿ~{@/Q)AGl qCƋXvӼ?MdzyٲL`Ch$`lQ`A گA}E|xGe0MffL蠭,M hHQey}ȶJC?}iW5BshEOD:MԬ 'M6U#~l9^6Q@R} 8!;uSXNV>%:xhYŜMG @ ;V|W$?u&_6O:ujO0W=jgqV tw,Mx[O+lsy^~sމ)S-N0u~Zesi >  ;몭$%GcNxq=.zy$![Ӕ䪽=&;qP}׻rj~v 9g7t:o|{ '2px88ҠlIs\>WX` ȼEYNG+|* ĔyJqvBe cLgY,B+1)LV;MuV-bs󌛅 iwXlv8.ci>zviִ"tLMTlMЖ,NLH# yE&nI_xYsGBPEgmddU7hfkdzi"P.p8˖$K!"H|+r:Gtb p^("e;Ud er ofeYj v 婥W%ND @T[ab2 DQ"P,؊"leJQe.nA-!¤:6xT8@cN$)f}+"q ;<|r9ք +;CSQrt5:P;-m DQVfC: 4xKҼv(Nh<nDqm ^jRƟY w=Eͷudz~__ vSQMG"6L{eB.g3?708@5f؂q3XBDf4r([u+oc2ocWm61t(#~=#Y=yS&ݾ2ҳ\@ hTr$/Il#q9, {CNt\87rډa,TBY5)k^mGO)J%d Ghk5 `8uφ4r{򍲹`mKl6jY4TMwrěk/Ʃ_::uԹRǟ^gMg<WO`:4= HINC2 Qǯvj)\dTq"5 \Rc~~L O-M63zMLesUĴX0eVO_PۦAWAsp[z'^,~#zfϭ*Iz׃M_d7[1}vT^jYx99vl9Uq@E]ArY˚^,5fl!f%/'f *}+[Y jH6𭳌j3xR\;0tr9=( Q6[N1=nqw.I>S:CюöU +YŇ8a0-FQ{U뮴>Z#GyQx^ TUD}rU%S~bS)9`f*-446N.wR5T,PcuP],}D;周ժWyTB:*%>BB:46Q4pEoU~,EfVtg#QVo mh邂6pf_1Wy'I񰯷 xB%C@ ׻f)wX8zF0G<55嵄n<(Skʂ7O<<_rp&'?6a\m///gx1Et193D7QOE1L竨1VIV3F\b)N;#clEL~cl9 Zm:#8J:aZS`;),ʆrl>!CzffIHn)udtEg_BhW$ªȑ\M'KTT2X$IrI웧!>?7X5 Ϡ96} d[F,*L6`?H% =s(7Py1!uJE})m4 u7:{>W#x{CQd8HJ"+NZݘDb8eqQ,9ɳs=%am9l>n czܲ^Scy{zlΜgelANR^) cZM٥zeZBBoaͦN 8Byqb:K<*, ƞϛ GLܦ2i1¾""ݴ|:0Yx"ᅻс΄d]SqeP5H(+$Qqy2uz d =[R*/JT\a .>4:$E֚N,9`PٿT( <7Mq/T'QDyJ}#YYUU ZP4?x~Wl4to Y`B=>YLt6G6JO666VW-.;y:ܹ10 a{upӌre⪊@({H܊#D)l+LYaLT4L_L7{UD ֣P03(i?9Pnm]qH84&A߶5^^X}+1T4r4!8/63D4[ P>nLyd^Xb>AH>HT{5sxJg={6]z΄n/_=Kھ_Q6) KB2@Eϕ_ x Bv{T+\'Hɖe ke] :_ 3[x2推|+w:I~bC~e=Eݟ6tm?Oc-kQͯ,;Jɗyw9$#s :{b)LW :#R|R27q1Iׄ( Fgdī^Ӻ~RE탪$'e{(S Y )ixM=<9WEXLJ.ܲAsMpU  T!wTd9|`Z:* LQg9j -5J}rtvTK!@=\{_Fp>80\^R4Ml@"nӴGkg5i?}x ]ܡPaVծۼjw>fgm6q3B!OmY@ORsRNxz{^?5=hN@+5%e#D XL:'rO||c\ߗW?뾷3&c7B8SYh6/ 6$PtH'>?ll8gg~`00S CxY qvP( C,~=[>h,/Ϫ,S@ҥ]Ƴ;S&zzHfx,S=uĄ싫u]3~m1ṟȯQ&vw%ALP7m|47 , ܯ~Jx[yGHBa`*ەbǛll3<SKs<~dT{{[@`dؘ`$7Rݡ} Pų, gQe[SJDž^/+CX}P BMp"5s>E=(]'fH֍W\ Te]sLSG. X n_h:PKZ}kyA{Ĉ V)<%+P8Ւe]ۏ~ E>C5_3&ܴW&+M, CoZz5k:.lҌHY e^෌'VWyQ;W1xW /} 3C段 ݱ3~ Cv[n_ 5L7wD{F; ks݈ JH \(DBH˝R>8ISRY|KvI)VNB5=x_ѻ}puL m6QVYO὇4;uz6cSaCZ8ƙQ(H !aXs Um ^c4mDu/'VMב05p=mT7UM]*h ]aMpad].ק% b7RXr]Nn3,Тt%$8{%8*7֩ SR l649@^1΢-#D e׉>%Ȣ䚐 jاUX2CwnxhY167Fq`KD]&3)+5u\%ʄ /\p|Q[X%ˍF֙Yf:{j"Y&N˅B9Ŧg+`KcSOmm|^[[&:ͯ1o7Kck.0Ytjď`չ=t63I=QT ⮃!Q殅;Ma\/q}TTs+׫aYR)< hԳ8tDk99= bo&Iel1cddf21pq>4=KoB.ٓ.W+o5ت^ԙnۜ! xQceXJ%Ȼ0n7ߵ~dU^jNsVј W*H؞lo0B-&ɬ8+@q؍E`>1G/jS#n-ݝt$iAMw:C$ ]֨VcǡPQ,Q)Ʀxo^SUz]sUɊ,>QMͣg=8h4+Yl>7j WLf/wic+֕m+S ~OƋLG rg^T ki3w4c?ӪU}&;t^ݪztq:\)+-,nDgN˼pV,[(`?%<3ٴ/ÆS"/?&bf! >1t)lGS*sbvsb?єmPɟ`5w c`ԣ'NN ,eBD8&&Iy|4aܠw ?Rn8"(JOhI#'O.\Si6_1cbrJFl/Z"fw*_էghE߿z&U.@ZΓY&mcZįK.HEuζkեvV]zhLu`t*SES͐k>+&M۝m}Kt[csmnNE\MS`$5Z6dV֏a@0ྩb!'jͫ@VՒXmΥ2ܲ,^j\Qz݅K $…݇\#%/gqPdžá~ȧOB^EY P8qoCc$#"قt}n3?.>C>l*V0&1HL$ɄxEo7>P.l?Rsq`vDS`o^s+2=RXwņ 2M!SlI!ŝnWZyxoT a8+pb,d]Uyu#pia塵1#SupKھM/HdČ$\#lT&0+ }%䔽wiڰiړݷy(mC-[N>=> ϺYBJ|'tv3ס91{Av#ԌwXLT4E&uPv1~^@ס;_d)Da~`@~J%n"S7uP= ^v Q՜MUUF94' u)U230n}COId"Upc@Y b2BV~qPQkuqXkN%AOb=r&Ȍ4&cڼ|ΠM }b:yk QY.Fb ɥ`Dn0H3:0& /=HrG1:m( s!ߥYn w9 #gL Idht{[} ՛͚ifr[2%S4ͪ5o%{1KV+*ؖZѲoEڶ"105Ch3I,t}-޿T5A%W7KK( TGt3Y (F,Qr([sXʘt1O.ߥj1}jIb'QXStz$idUZ$&mCI*"U'J|G,2n Բkǎ9(¢+lX%\`TAD;c[T}\k.H|4%Z%c(Fcb#&]TA[)iun*cصUzY6eݝ)&mó, ȫ^k)rzIqfv?H*8H q_!3|ǶCQz]U&q%XywDc87 UW*KyHj"#@L~L~X \IRt7FGΘ(v1/ 9y3Ø}s! 5x:t'[$R_`v~7,87¨Gp8e^dc>-];*< 4I<"j$Y[,Wfċ,-_)<`^߻7nEŸς앯YҺri masA+޻W#–5%]*y%6UAD6 U/u5A.Ԛ [%0hwp @XsБo5yX{pLKTxizlsťTKs(;Te(ݕe 0(Ӯ/eyc7;tyN.bgZN<㏷={_*VļKݩך}im}}UyW`E.-QAUuuaAչh 7/ϾmB6pTO 'vЛiQwaIq tV UD0R>Ӵ,%X~HcF^;w.F}+T2v).k.fWSE$0a@5kʖ/,`ߒ̪)9#Zs]H_VhF U1c$:E%8}&9G$"l;&*io$7^!u& `]6D5"~iuDzʼn\7+k2.;{gz^ i<#Jl<'-ҝKo6{]IR CBGn23 eQ5B|P##!ZYǖ?:̹emp1&u>>,u-kcd{XZF\axd>!? +"rK( `#a'a~"i'[|\ b@60zy1 !B2[/c_i.@Utx452!oFi%QF Z8Tʄ<ױFЊ59f@HzY ዂE+Âq=] Ϟ=KmӲ4ͲL=/j>Â𰢼hբ]n bq`j=k^߳j֎4Dl[õ6m5k7j޵[AQ#&K86:,S'ϼ X"` ,,`s.8Ne\29Ӹ!^X8x ""xa@Yw>KO0m.A9Sjg3u ERs3NT9,?Л|\Έovқ7BږŹGnM@NWX*!?_q4/ߩσeduuTEfo7[cR ^jHtUbtR!/lnnYm֛q8Z`M=c8ٹqcrli (vԡd/!Np7 35J׈DX;BjYۓ€t@󼇤([MKt7IaT|+.'hd2R!ҩv/0e9 {9=W]?[YhV|M&?֚kP:_8kV F@@ vqXO@˂uC?JI##l-&Vh#bȝїi+<\Ab=- Ae 5Ql-ع_oZ hK+l gvXhJb ᰠW _*bm ^_IٍfPgDz(nJ'׸|na*23^8J%ؠi^8-5"j٦%Ӿ9hNOw>L[[k`o2ʬA+&CtLzJz;p; ǵ 8D7x'ki&qGqZ#q>T+˙.6A^'ŠAq;8v9D+_>90n}fkV>w}Qn^;]! , ),R (ȃkp}p+G= kۆ6 5P:| >.N>?J|yvXt^\iTQIM;KK(:T*m.7U;`P3B5>{/DQsiyJ%&cz)?)KʨK3:q/LL+[Cl h puN8_R9[vD,9'?JnD`K`G] k[ԃ$0,-(-MFf]*/a~aso%.橐z?I~mu߸_Y.ΏOrtGD 뛴y|k{!ՀZyKt93"oS|G4ñ4T* fT />9^?95fZE vlϛnhx)'?˰Lmˑ83EbNS3c,$lSU1YPxnG ?T'2љi\D&{.I%IUX:]xXEXpf;WEt`QL)w&J *\M3lUUPs`3%@"0 mrMyGJHqk A(r&5B2%}"j  b@;N3ǫpaRˌȧNqXxі;2^{SR@C$?}<ҠћZGUQ his)¸(lizb82`g#s{QmK=٫.\+YԌzI|FxaЩA$7Y0Ә;Cbʠ6#s[Ap!̙rBծ!wƹs.>E?,wHկ$Q*У'2Ϳ5yAwDNs؁zBX[g^u>@**N_ׅ>O&-J7T]W;쟸|ҋ} MxOdp uOnl :mm> EX樸>{ ",[VWO9#%z 91<#%"CePquVb#`6DO7wo=J4b&56t[71p.,,کlZA[c[Tx2{en8s:מ*jؗʭ|RJijAXtTw8IPN#K{$fgszJ.cMgR6ߩ@;$hsKq|/G)m8+2fTqWz8(/`a[{3- iZhcJ/)ͅTiI7Ah8үώlzz[]4K>nml/ܖ.l7&3~F~&ޔF-ي`w s]}]J[s3@1h67NdsPYTм\ٴd)Jvz=$[al~Neã+Pܖ6q&q`D:n? r# 0Wk)ͤM rcG[q4v[^o:}Ļ :wqpcc  PIǚI'x 8G4 ԙl(1}ҀB8iokV᥮I56QoPCȼkfL HG1ZEGdiTig6$+K4JaX)bu>BX ťS|H+7E S0aU2O(G) K"\lf`7#1j<}n&s70N ʠ?X}"AZ63*jS&Rר`?m>t!&70"d|i<^Mm|{tP/*ҭ#,'{<~SjAbQTnb̙.٥#܏.=dqBGN0+vXiq/O6XM^[n FOe*&eB_AkR]ۚ$#3Bj`4-d\Wzj3(m@39Bu]Z9;*NF琖z$79ru~0NΉc[0JKJ^ҵoHUBO*v]dϐ7Ciޝȴ<@}"kYr$wn>Pa=}ݎp(]#VT/"ъx* 9;r S[2Gl>"d\|/Z:O/|*z=2X1/"~56.M.k &6԰E9Lt/FaT{(*),qh1@1'h26'9}l1NRD-Ns]aT55;F&584Bӫ7ju!J:KKHz- qRI!3qG`gˊίN~8wUf9dgSp裁3B7E·4TTRQOӈ[{jnjzsԪTff*j:2N`xq\6UCM}251{qFҰ#Jmq'V b7 ]FCtCRK(*T۬uAyjWF=^l"\.A*|!rs|Tfпʨe')*BGُygdъ{`6B⮾zw~l/yc@ /tnoܰK{}6}sJcWу Nց :օJgO O5<:zJF !+eD,>GF$/F9rJeQ5M-#(„(1=0iZzLqm]wbTT^{Ox}K-*T'^jL&al1MvB{t }.A(ݧKpH2 }]Dx9b~+dS|<`"Dh:SvJoe*xc3?] "gTő"FW/uе,U (>GtP#yC5ί:;sD1B6&"Uϝk9r@&}a]CvPA (; :lo47ږo|o҅Uq cvdYdZ|>pfA1 E#kK`|\Y'فfX/{Ώ퇉1sa=A/R(@CُJ4Ռ7XK$LrQ며97xQ<ES_ Y'R$ʼI'VdSӕD*/}F%2yo~Vs^CHtK\Y[.X6Ĭa_LkF $ 'g[\7#h$)D1p5?)R؁T1ǻѣFiu ov [iE{op¼:s3eOVlt8gVgUFYncsl6gYf;l'(D]g|R(Dd{ GvY?Ey\;- ;/{28ΚE=e=K|~x'?zk Z}D=bRB eLt0| !,AAh1#Ёx5u> 6 .|f[}s/> >$& wڔqatİa25ռɩehMXm{\m(Sf&B8VKߊk%]I Q|gCE)u H˹)k0xp"=(/}oZYT)]^S|o~A뒞ePL :ڀ(Q眭ԶccťE89 sрe.1q)Ԁx8 OE-*lbp GP]Cfw,"Ub*-K *X DLR?t]S-..tUJ4coS*3޲*핀OTn,rF5E0krj2I|ZjF?1?Hj̭!rԤ>eG?`ϔev`v YOӺC$r; 9]}1\. Gx%;s9Ybĩ$hJb%y>ʡip쌀eQggaۗ42 agضl:rr俭&+,lBNI2rLVvnhHh4h=O"!uTDV/Iu|-oOf/c#335y7I5ex\缇G$՛IEWAjC'+ժC}R>nnoT}0x:_7d.c+/B\^;6$YGˀs1ׁQ.;3ndsSM$*U)vF ӹ\.7=0zDZuR`[ h<'Zv3cWiݨw跔WaqLO!9<Й~G컏חʢi2N2FJ/Aa3SrtPSSQSl%YZ<5 *S@4쟁튗 R$xgjrOq0]*ZbS<3ޢ[1=6C+i]7 MЍg_e(; C9KOf^I)%ǒ+;Sd6jN*|#6Y(a\m`#o؊5d VjD\f'g DE m U,|?z $5i|D ԃ={Y ceI>߄5 O3G5(mlb#b_w]m/棞ـ03IүЩ2\?2 zj,Of<"eIcR޸@2T!0-;~))&{e!_ߺYncܶԷ8rmn$7D7>.m?Aqr:-.P{rTd;(5fU;2Qy'Bj 8 At%-:kjkuu\[[TOPa%Ro~ 0feJs+ b*P,!ء,T>-gv٧BZ 3'pDG~'|TUyc٦>(A[J=l.差U1# m%2ɨzIQ[ֹrCe]3 ֕cXPlw MI?3JBquo="Z3>f $ĺB ۲O=;:SL]t^UB]eAc;J/יXv30Yd9k֓ ƆjQ*Qm_CpqƆf6Ǖ +3f5+/58`T;gn'Es/N$Bk<[ ݚo"WTWCwrt]ʻlNA=d&1 P`۾\}9K;9n3v4!!nԄsǩ) g+  $Z%AQc|&Y-a(R&Xbb"]7$4T rSQ$%L?,9 4K;&fqeT2Sd2"2to,r jNY6 {tA>ȁ${=uk~n )CG{ɎUoZ8=Ց:vڒх؀x/WFԉ`bAh?tY&:4wGxNe8j=5j7͙^gccP5\!`Aot5ǎö04_/Ճ2hGdN0ߕҤWQ4:KJIR޼^Re2ltu>׬2ƘyKrGo/{}ؾew B?; %{QMJvj ǔdrp9GBŨYOm^՟<-:6GF31twF:mJ $j9t5T щ*lt^^T 8"wIWBA\BnzBg9tCף'8C3qAΌ-̅nUכ@Un`e 6CkU&A0`]!t ih눖LveSI. 1R`.4 累gFyM~{?fiS#✉ DStݎ^KsEdO'(#bo2/u 3z@< QAngIGGJMmn~$N3ftU"[%xM6g>ͯCuN|P8骭ӳI~sʏ@0[MCktܖ1l; TOcCr%wpbɜbOu`9yk(9皡Ś hO)y3yҩhV8&M 9_.)FB[Z'ZHZI_+|l8fճYSwY+ ޡZƬ {4SzW:WHolVܫ %%/} #x k2*e_"CvJ#Òi2V/ڠi6eyq߄72I55,[7g7-'b0W"t CDU'd`9biy&Ka6_zsĊh?&Un'C  D!NzJ|`g7cY;ˠ>߃xI |rڰᕇU!aF \įYa2Lփ |%YS{βsGR0 4F t$eyUq+S#^cY2*qYa"{K0Wg^9G.W>\&*nږ=Лyoq'Mz'8+[(e^6 w#w"Kd."]fru S_a*ߐuZ}ZےS2 Ga5qɘ~d`lo߶v)ºj>ř섊% C*X OOLTW1K6QiQ6-ġ$(CGJaE_1;hѻ@r(H_;]9n[~!RDϪTMHtIC]1XkMVpxгuwJQǍA>[AAaywQ1L:ݫIDe{^]V@g31$0K4SѢai$ؔkB,O='E]AF6>mFbO-8-w\m9xr0v06rS,QˑmN-s]ׅ0]-^u0v1ְu S,퍥ؑ`R+he*Ltes,S]]e`}5F?At{BKѫG8&Q*Ǚmۈ, 6'G.8] o tak6/v2Dv`k b敥4~ikRbsa;z0=]FϘd %)_Řh⤼m,\N^݇"^Y?йC&RV+ Ũ+ K͏GhwW,J.zz c.[=)SڍF=8W 0 6$L6})$Z J50<>gm3] 3\Knf=rMdz&[+g]mUfB]Uy۫Iô,4- !0<{0rU|/+f bu"Yg) "J|]<-XX&q{LO`j`׭6777ᓊ_,=fe?-|RmMKKK^t)܇/!G t>5ԟ%bල'i#p 6va=I{v ;~g"DCG6\"W_}5\-IxPP/ A:W7b@'N8-#=qWt5\}۱cNxSX":ƽ5ifކYYSٸ\.(Jr [.\o<_^Ciarg w8mw= V4@ui̋bqkap<_I^*SPm[9ۚn#X;+8'&Ibhd Puo,@2Ì:}\9>g0o&Ѯ~:VsJ)jkw #[>07ݴEEat[}9`S&&ל,2Gi-i0BpG-EB--Bi&}Ft_H,v"dz!-")DzgwuSxGZyJ+Qi`Q6[h`eٚ$^zCnE[h'֚ kiC;]'& ~?_/WQχi$=8N۝m{]1pd>/3˦xrZ6TeӖ NVxms]gםd%ش& ;XO\j5ӵԹ9vF{aaaLw^bu=fed\wZ_9M˚֛$?7~tK((]UzTzϔ'pmnExLEmi%}YnΉ"YMԱs|l(\Q5E2T.}Ӟ]FsJba2qá4\ԭ,Y3ٰL}Ȱ i ?ґwNM,Y ³K&Y!zd7:;:N+x4! dH{>ةE&Rࡸ`۶]08&M@rzUUYbSۺfrEjTF^Mu~ 皎KoʘI1WlQ+u^mt02f:L¤9x.KV2̌$k, tJRA5n;hLLa\=+g^P.'S$f=rpZBv54,?5j$ *u:PE((4@I5aztҐHF$ IXJzfQW/nZ /=~oY žwe!co{w돗cxYy+T cywz ]pRן&w\'X@J<0 FJ$4+Aq<2GK7 Mt~s;rvsc,y={2v0/F~ w~BWɚ/wfdq~sA~Ugm`XIL*qZ*LӸi* ]^`BJ`4~ (Sa3Ve=ba֑jGh֋lBrB]-_vHI37$c:״jQb( ^NU\Q`: =/1>i^˦\_%'( -b qjJ9h n\$zyYN|0S{TQ*1F!T t6ӻe1LX2'D(hwi׻fHJ e}./}]q.zsY㿺WJ{Tl=En=&V̺Q5 #|޲z%8ؽeY //%[&pY6apc~Ҧɺ7'F\n˳rs6h(LJ T!mvL]n;;E濯Yv9jɌEO3;\V)wL֧Q1;gnzeiƅ$?[DIC_w'&&a-`\ja~§y%@SO ] kQُ˺makmj V&{YkzK]oc 6v&$m|4D2 >QH?(#~څ ヨ5ewtf≝9s;'ΎRɂl(Eaj޿hrYmِhs.5c|wB@'6QS_L.% mC{Xr_~9(_AYJ0ţ&NJyL0H'.ǃ݂lXV)P0)F+JMN/*986cq=?N`{FdzF#;W:^W_j*WW?zfE AMZiD7r&Nb0U0JUv$nV]~b‚]sh=ކCF߭"iu dva[. [}P?pK# .#̫$+*>^a{`2CKqG1?So~t0ǿ)HqwR~󽵧ſ/YM):q.\/| pO1]q=+:س,MRT\!ܙ8cE]<`ܻ㐍cCt}"lEa.x9B$^K(]/-e(k[B$D>n'BV6a_jw8x;m (4G,V![z(k~ޓl&ݍ>Im݆x~1ۊDia^`bo~}3óv<&mr8A29Ԙ|}i>,ydv0q ZlC IWЁSwX҅m?Kݗe(A.*Gp iۺQqRo,[ lYnakti? [?`È#xno^X2YiڊyEu>I'"NZk"!mZq$nYәLxz4#S*W/Q|6ym`JXo*2 m'ۺ+ 1@.oXOeB8,r A2aIU n $n?T&FT_w 7MGDPVl,YdKz\%ϝN6QҹdBMV"%Eĩ1NB&FFD GLz=0T_Q5BhO k-~S (svm"oDHY (_/6ц}Ylp<^^Ϩ㦂+?㾌 { _ѵ)Jsyzwx G{h5%UKhEO$}w,3*3˲Z4zXE{FãWbQx5J>J@P*oZq?Y ;͐Q,8fy|Lqkyנv{>za~ψM~42FNeHQ9k1A{97FGNa΍η[} ؖ5T<3M|PN3\(tV8Oٳnkp2Ŭu]N)&Mđ).RZ&`;\{;?R+~ִ>BסuŋÓ'EG2H;z}*98=,1K0 {'0 LKYHo񃴈67ݶsHzMXy&u;=Ki[4k9`7vc՚ >90æRqǺnDvo_/g9[/\wBx.k,yS׾oD¥_ Fa~t0K W ^]*^4,܍(6uC.O+Ɍzy@cūTGQVraoBD@p+ )a kk0θ\x<$ O/ Jic%E}D=P~EUYؙƎ#V gg=@;OQH'ĭxX#MD-q,ݕ0K긴}OKf),'s (뺬)kIGgxih-Gk/%^pȼ5M-κ=`(e%N#-@A,H¨w4UG^ڵ'L/Oi^a8Q?6:#K\T=Urً$;LFGwuݵ MIC Mfzum1ӂ_Oj5j3_FhGؓ`F;N eZӘ޴.(9,Tl_RK"e2FFF!/3I{ioS`в՚KwV}']T (_u=bB3lMtt>kYV[Vd2C>3UAi.]7gi|X!Q*]UYV\,!Y5[P*lMDQ4Eh4FQzxkНI;vܺǢ#J0iëA,xD)ibehQ,[̸s/T:(vɬGV{.|N syaHgg̲2vgYlZ ev`#xY:1bf33mӴ'*X4n6`ㅅ^ƻe= iL,9 t4r#$tg,WNS0NG @hN.u!LcyaK ޲>`>t@ZX=pj)Эh>8ɰ~mJ+A,gf )q[ss[fx1] ighűPcLWl[`v􂷣 :PVH#!8oCGu sO,@~6Ux~?ș$x=&Ll3Ӣ&wLQE0^MGyNOD8J s lˡk%xF}@D[bӷf\˙'&@n=^KK3[s{ezs-=~%֘xl t*8>` G [ IYMT?$B蕎4wӝ^hE[FI8X(* Ӌ?=7(u*/v7yi% &JNAfku{JB:؅\!h_; .b߇ɽ_ǽS5SW1 O( V1rfjFcvQGAsjhf/fEC%y(=^}$-f-Β\In|SAԌ]l2=$N*r []T. ؏ҙfqUR+|nZDbeYpf62:ݧ||k75%Wf1Tl*+{a@6%ҁ\F%V>LOG.yFq;Jizo$Q ϒ=y#?aY%+mAgtC/C¹=my<%W2(r~3@? IQ3;2ǚ6[Ǐ1,,@PT {߬ڪt<0ŲNڢXې-nI^0ri*\?,,y&mXflfQ*P(nT2*MfAES9fxji;w /kŰ|X%0ߔxRر.%]n'EշjMR>_Fc3OB%YԘOEc( y8Tt+:E*^Q,|/]ww爜j dVnuj?ׄXӅ:Gj_ɩ,omZa]E 5n-U>0vL+t`tGTք2&&ZKBpnk 0TBvc}ϛ'4(yVd{^MU~BׄauMтrwNG&2޾z QZrm?~P8Zк qpoicx>y?'r3r/l[e8 䫱'1&x. T@EA:JT6W:CBHX"bK7l3T6TYdA E)O$*@V)`ψ @X[a^I H xHЅ8  7oVR4; dus9:KY85Ks1\ҝt^OA}uǝ&[7A:ٚeJ*ʶMp~8߾j C!BjlkȴcT&n"[ ;3kvJځ+f薎 C/ >7Um a6@4>AXݤc,~Cch`?aʒ?˔ƿjWF#w>}g9 4ܹ>DEv"U{X;fIn%"e'eKI{"IJio.a6} ^:~M/ _=;~ A>A %h#tr,;7ȑQbDȇ3-}eb(9ʨ')sU( ʂ"TϾb;NV9H" JBXRQ@SM3ݷs:) lR=Xc5SvR0 FJKu (,=<7@1MN(HvP5$^_j'4(yjn9QY~踝jvɎg l{T VóbцԳI.Kl M%>>gr77C+uݽb\qʋBP(i: Ff 2w4pff݄q&)щ]mG`£7J-vC|OhE a n{ˬk?G(d[q4lC+_aJ^[yiGSq.UEAK;蛛_ $+Jzzv'NύA>2.u[3l6'|j+rII,&Uո5~Ç\}3jW9 {KX7 w Po=j 05j|ÿ "ClK0OTOb uTFN9 pFĒh"ms{N]MӴd̟ENq~(}Hq0M|T_F֦e?#F.Udo*l~8ObA]Y:e&HvcWpTYBnVT줱CܨAXV3]i22s482{ Ytq$<&ͣWs2Ԙ]yx'O s̙6U͗K3= ]9hb\CVw2di2npp6p.T bG/<*#/sOJ6Xas_N!y vw%' 1Z #P SB4fK}ь+)I@ ٠h,)bUoNj~q Zi;n=K;yg^:%TXa{xPiY~ח ~|/x,?7AW[G\ C%/uM>3Bm׻٪m<9O^;{{+lyM&c<'`8jnMVRNg֊55MM369 kw?ҿ) ZJ $ހuQl1Ahu!)n9{.-{ֳ>+Ic@;-˦f.νІq*6u qU&d%^p?#-[G۟ GHROhUGc8`/> )(D B$ ; Sg6Mxҽb`M;Ԝ(zUO>WUG cL .//jˌpdm=پW Baހs[SS!t*?(h>h*ԽL,Xca"cA^h~,X-n2ϟ% JL'r ^mCt3>l(S8:@ct G-׮4w)l 1nA(g,% jGn|+Q&xwq_wJ1PF9]Or{-P Z6kf7˯5+m';hMo8OrW|C7~r=fIz,+ sBqYB3.P| Ŝ9bN!!< =4l}טg H|g$p)BNwSSM4i*H'aJ)mLMTeT46)\8jCjp $Ǣ:EͰ yJ! 9Gb7Ax.9VLe,Ѡ{d(GZf"!7sT=fy<1q:uz(L>mqLаh]ۅJnЙF)0ŌCbT]*p_VWWk ʄ}<omn1 [ _g뺊o`99999+ldW559ieq-+b;(lw$,H{;m^2{$NլhW ǰѴ04XB9/ѼfROzj!i,zJ5B.ڇԋQ[u-}ch=4*tU-^}ފU;>rVl[`I3{+V9A; 6K?~ @1]进ԗ/g_{{kohL#aas5^FJҪ.zނ7h,Zų2D Do]$1LQb{#2J@nXD Q2uvmlDrɴ'(UH`a/hk#g`&-<,\" ςe&^$XfZri0;UP]m,\/ | r^z~C ڑ?2a@SHw`g&8(GYOy zvȈ5F)Lg0Y%#]#9`vⒻW3^_-F>.S,}U,!J;g$3q>`QxbLs}&}U7eޭ׀cdL]k>=eFc&]yjv|~a^W֝?R~ک]#>z*5)R; fxDP@y! ^VD 2HZxqtRC5aB҈Wx4/M0x+=pOiR.T s aZ9WP(LXUSnjy&mmͺvӐr2?z:)4lj&!^NAH@[4zfh׍k(4ņeXeTp?6ipdS9f>345,yXh;,ߔzGF-A'h-n[6Ѽ$MҔ3UvmD5n_,ۭXz).HөY]z wjp_&%UY*V6s(J?b|G12 Hq_"ml=6m\F }']gƯYbLi %{kk6U Ík% Foz=D ΑJ֜4N&·ʻ3H#^7 ZPBXpmY ubfur=\I|fע p`Eu;?a`IZt7Ą#˙L>S4{ؕqcaxʼnE1ùUPbX+Jգ%De uϺ$mh4muŻF=iX>7񍭗k[W7<oh)keiiC,`Oך:_ A7!YAXjNW[+T!qxd;)3UfBX!8xhB 6W&mzlMI:t*h COd.gQR"M:N{=g !R b'fڙ+v d~XT-<5}󛏢>nuͶ b u;jHojFIa͸nG T⑪Fp+,D,lW:;|S#eh]@r`=A 뷤|fy "&?EM3P?K[* !cQʎ<Du6SA)3a-^1EJ'r<~Op,.l}*axEh]V椇t8ҦʼnvI`\χrKB%]F ÊlDáp dgpwax( Ƒ *'o<{Y?QkΫhd+ЃvG~zz3]qXMzQ?iG\]4--Ӧ}M5Mն{J*5 7Pe>+O_iV) Ζ/a˶Ks)2;?P17F{39;SigH*z\*ɪSa2x`I+ЩlRp]K 3(YF]W!VŽa܇ U L! !+:>4eYDDaڪLQ!R F=Ia2GY[NQRVlzPzAPd^?wP1y'8ř;r @u4u]fNNN󙣙F2Gdɗ lo`R䉅+&sƷod*͌ LD8]hȁBi!sOkt j#GRU3u߄q-P| _0=QLƀj3禁ڐwoX_n¨~9 Iv9#`!&]+>"^fʸsu2 @;㔲$S$H-@8Ԗܴm!G}dty7gOR;wY]zȾ8+ ph/ǿTvX.ynhz0IJ * Q]YT <ɉk \ 7P$o_|0m!ҹ=ޟ5?wүe㝒\EJ ~@0=W°VkV?Y/TZ¹,J y~>hrnCiR]UrUńAȸ<0Bj0CƯe>Cȥ'{]§sNpfrziiQ!v(km}w?mjZn`hQMN =7ԅnf0m !'5J!ʣٹ疲l^O/M?i:,%{T !XGghEܲ# w4*p8i h@RX$2P! |:E$2ͣQA#\xxBBUϒ QWӯx+4^]BUUsזIMK}<\vթ:zuҌ.P@ u0,FTy:^ WE?r;}/:.WXPƄ<{]Ns$NuFC9"GFEDT Y3-6dzӲsugaX;vbƥ=tLlA{9`LE'_r5^.y%~y>3z.OwF%Kecl[$֊"AhQAL#hi[ZJ5j}5|oW3#!!D /}纶vsF5.SLM|$mG[\zs'?'TUGH-et !G\MFܐ}N.Lz{_/OLL8X{e?l[ۂb10\u[; xġvuB&m/sndo;NCdm) muUT]GRSUFY5B`lZwl2f"Fp`K}(@rRASP % }U~_ p@%Ee;!O'y4#ؗNYQ4<հ];q:g~UAhYrz yp!ֹ"1eIH^- 5`ldO#Dv];隌BoM!ŽV>OaډGSO;#2Et6׊H[oU⯁uAtw2ہ);XӖ#ﱯwCқXD&ZDrx mVj?TWtq-uV)HIF7ff{ &c+Q39D=M1 n|]ߤa48o|!^CI|БlK@@P->;T"C֨C W\CTQhCL Wv0/J C5QvF\;xSJ@<|\p>H2ŏƣ-C}3a (U_^|`z$:%|9󓽦Qv4U3#|i盛4қ,,o$ kIDQ|o#:>QWj"h-ЀHf3gȹ>5c7ºŋt& ++VPΣOaE 2DS7[dkX߽E^aޙxwϑg<yA7/~R!‡L\V| 0$Zl.;ommm3y/)O*a:~&zHwMz9ӟٺi7 @G# @Z%]G(>mm(L:0>Lnȴ\Ľđr#T?Kngw׶)a OQab0xfbJBa׳ˊ8P!`,_NeLl(3/IinLr@(pd΄oG-EG.iK\P( ^қ5&&gޛPF"n||1ea*zK Jb9uT toN /1yjiW;xLxs+ ݅$ i{/\p*\YYyo O:5#t:afua]yi|ne_ӈB|* \ְ $ƊR04[]Aq:Bq6Br}];]B{J\5K]bY4qeI<\@230S w6CpIk055EL0MgjBx725<~\T>j@e6ᗷEؑk?Be#F϶4W+ :/ tzD4Gc J+\<k+8[bplѐg; w4jm;`l2cȻ,*|sߋ[ݱ\9esc&‹籀܂DL X_?/P8UEy_a;\#Yob6}:O_XF/kw;])Y9&s ZexYF0UbjQW$[ZЭ|5i[ӥccO?s'&DM|`--]O0tm I:8-ݎ,M'"qzq}z Cj|*) -J4i (,@(n%>fw*R19=DmkmѩjfnWڞdFw>z?A|w/~ʾKӥ"F8ol9̹P>ϰo>fQsKaa:w_! "OI^p_o/gZ:ꡃv8#jyqƕZa}&,ĖJr m}f<ś/Ce0*ar5~N%U m>!=4a_f#`1[)TS˗5U c׮\dd-yZy]uګn i C~D"K5޲F¢y'ۿ ذ2X Kmll4TksØJdJz~Es?Ϝ9&#j!?i_ZX4=9^{' KV!|).klh jCV/CO0yU.Tw %\UV[bewɕsC/Ed.7lsGp3E%>Tąiew׆ڟ ;Aw񘺆腫cFnձ>>WPբ^ rTlxţxGZ*M Noʰ_ UMN{=0{$aa*_vqQqU18{g_: Sݒ,ᬬ2G^޴VT0ƃ1I"ps_Eic?=( X#!Gme4H8I O3d1l6J%G`Gh[/Mda\5SAUk`Ë%6яw"Po,<_B"Tuk~uB:!G^r=& y)W_=V^˲\l׮xP GW_ٽc>aZ69ިF[tP/ E܈TiKGo-JU'pv'ApѪ$6Z8?/Xfk[lV߶aӉEq0nbЅZ>lr9ё{k)+n0N ,[f˪ _ Mu7 S.xMWZ&'R.U$:ٺ݅Q@Ђ`iL+؟ܪې,%x!դѩW.${jJ(I%mh `#@J( t\FslX1;ހ,˖ydm42&-Lr9"#G)k*N%\UTQʨvL˿L󽫸;Tc/U6qRdغ*;ʅVmGx-yo;R!1^'h~'wa01"a2Pj0ig~06;#M V:i' f$d4[[^]5)cNB,3xyhKa.zmVou*J؜"'o&ʣ}1ɠ!P灬 `HE[%a] x_Aw}%8p9s̐+l40!J]Wо˴ȼ ۶l<9VGeUM|4dA;nV֮d&~5TF3~ 3-@;4g(tNB4LX.lUGB0!R2)ʧPi&uoqTUO3P_]\o}ԋƱxO)J K*)\Txf:ɠ#|Ar((A~ղh])|;>#:oC=& qoQ`Ta1`DםOP;n24"V1@B<`l6Be!뾵0Xf Cy0 ύ"S;ĊŴ cG.Ft ZfrbÑ*4a4KFy[PaX}/2H *8n,I9I@y­I+MO* ._5BW0`ZuGIKiz뺬XɋoD(! \mOvNc=Cתɔ6\e?u4}Q5g6ЮֱM*x0Xljcʯ̒y_9fS\V3p7+CC<8F] IN"c哵 yv FUhW- ODQ af/zyە^#v^?hܒm dO-i.M>NHn~7o嗄s54p !9.*HDv቞n~AuJRаTkHzvn,0&w옜ұ ?B~6bu]fr,m} [8㞅#l..6 QD6;MOuIwB2wp45],9s΅V!M9ilX*mY焰s=ef(IE 01j$@8W?lѤ!9kz6Y|ɝjz9 _m`kOg4UdmC@vo "XV]ӈsjA ΟhZm<'$F@u ځcm/5ݺ?]z.!(8B ðHutG|-%8R/ra9=NYr'!w*卿0/__^ZEڠT/2`i6 wL6YkTOBŖ&/䐡5؅]x.D/VA1 jt.(jyD(aܿ:k ;+{_r;XQڵu,ES^VUH/'cj DGǻVCCF~9 gOt=tBg0ND0C!LmXGo;IJl(N&th]/xZ6oY:=Wax/0,q_:מ>(amYnˆa~*{!$5g@5zhvE(̋[>'8siߥ: Mx9Y>§.!WzHq˭n#foZWQ>V3 |[Y|_K:+hҤKk.0F}iS$_I舡2!ݞOٴ J+Z2}41)ʨ_ /LP&DvfwT\A0drN@9 !Fd'>y"ʢRV"DӇYIi}.0L ;LAv(<|.sʌlceYhuhy?oɴ]]>P`;Kjec T"0"Sc`I-PtB)"͛o,;ules"Fq C F@Gȉ2LCqwf{p@0UFnЬ2uMLL81˿n y﵊$ќEWퟙ% څ15uSJJ?W.!–Y.:jkyi (dgfojRHciE6ڛ2k>Jteڎ4^/_i+-CQ\P}վ>DD{N{Y7m$;AJㄥRU[b >2ray² W5$386'^*D )4j܈LڗL8+⡋MEUe؆H q7#ᬪĊ3015u&ŎJRoIW4X˄`o15#kƁ&<012! zD!vF$DGC)~k4/\鴜ɊB}\1{f'dK계Kc$*"RImJKr* ]2cPBP#+Kfq Qۀ-7j?bŽ8?'kb"ji|w7u8ZFo PSbpe8R)HR`cݢkz0 nGtkqtвvP:){E9yS6oz$aie$I p&cKʪS ̽8Na+n!(Bx!̹G4nCsb*i1N!lpxeqL 'l,G2t)`OF$Qu4">'PʤClHrN//aFË#Wk*XsYk: Ez~`njEʏ)J,ff~4}\[͙\l)cnl{{㄀spL~Ƿņt+9A`B6uN: َZy0BPtꉓ`pB] zgm [I8egKmm{\lb2m,ҫ0Xw}cJT #WZ-y^SOgjF:eNwsgP>DW9J,;{6?Us ϛZ{OA#%1v%{MoI4S {F9zR;~KBǤ6/ߜnj+R>dv.ψH-|Pa6,1a0Xd|ӴǻX4.Qe\qaTvPT;4PsDV u?|\qL /,K* ٓq2,^ Po*7I"?zp{S5<:m8œaW`~nlusa #0-T4)}2/l3?Ӝtmy<_NeY_ݰmMF rR>g:ڣl6xOd̸f}0F| ̸8C\0 ǧ P)%7p{-H~̻s3++5 2T+DuT6_! 秽TRRU眨0X:>$irwfr=T6 7ir?NԉE pʦ Z׮-,uhx6W cb ogTCeZ-TCre1,)Q**SrH(DlI7pd_p;j.j%gCeaKI`/z͹{}}&~%4Al-9?W5j,#} B[s7 4f`_xeƬODY`Vhܔ(3!4MDd<{:3`؆I19nj= M&>tu{N}h\҆GcdV2Od$|*UG 6ðɤ, sӝlb~2_%E&=X a &t]?,y:K+)}JD?glL}blUX!}}lՆ78_5p5x[P?~rnx 4H $"rA*˹]0h9LpA87괐ʥHDkTy5gu(\ל/d}{VBwgʢI ?NC܎!q_$$ ?R0J(ј(יٴ7P݌^:BUmC}I( I-Z6(25lI/,kT +QRIOR7I} %+To(S/m[ Cnjz`*3zzsX9ٲ,ZK} ?1wxKBk>Wi P}4tarQ*MIU!SJLYt`<| "~ ᗧHn>C+ZH4!e,aĬT/Qs"c2&AZTdn^_}=/?{o;<_Qszq=D854[&~ Dô0au3mS/]l]ŜPQd7"w䌎4:BIm J U5[PƏ$ eۖ U"Y*k\ͪV߆d5Eha6lxC*),qL0W&KbE7MK& Y+T(K,%? R&5S!W,ð SpOg§*]:GI|=?H5w镠N$&>/K{=nņ6&Zx?ӱ3,K1)>}8]\hjϷsHs4%s׼5T@v~KU.Sh q%(IR(Q۬ I_#Q_865M@,ɟ}JUۻ9(n#?e *9_!ݞ/scJs(ss]RgRʎ+O?Az V#{^iǏt:t:c\kfqupYϽ^7ʱV.P~Y g(IMlUb(]k"X/\-Cjs{yYs CWs :m_Y.MUJ$ޚ*45h\ӸF4 &Rշ^.Z9) M00tS !\3Rv]FWݳsVNI[skGjHZpѺ ]kpus_~4lIRB6w=t/?_~09NgխV_LOO4'n`a磤ކ(߫? j:7w4;(_ ;ĝFÆwʆ{ 'Ɍ.cqO# V'[B]{a!ts'gOkBX5ɜ{M5tn:''B^z#`z nJ[vnqm&{a7)nrR#FR΍G9T+]*,yȤrOXLN-Ö&6z(џTzȰY= d~q1Gfcn!8:]4crbЩ|&4:% RUFějQ,@ti**F;\ػf,"q&ޮJ:2^P}SB>؄? Я$"|s%_fZX2LScSRj`dǪ,Isu]1ɒT*M_ʒ U4l&),˒* !D0!& `B*K$<M-y=ԇ"eJ6N: EƆAVUKeЮӪyyd麄[/b~i"+SP8dcu\ʩ"+0m-3l㟐1YQtE@lgaB%gЍsu r΃#=N@hYK|ae[ձjVpb_agMOPEfE{ՍU {X4*`: i }8m\Asط9&yH8x\,^I ZVq:]73(ND'p 8bڋ;Ni  C4ɣX X£CDF#G_V#fM7*lT)JE_,J(˙vP4$)Ld34 r7rB0g ( 8&KȆfl8I!>|ePBF#wa#\Lc#8dq FE0k3J:!j DI6kўwmPөeQ]/;<% .ކw՝ TQd)8N SfO#ېsu_Vn+HzO 7oקЊ߮K2W1ejݷ}jS%Nu9%Yt,3+Bamov =&BVQwt,m̑ 3a$y9ތq!v1BQco~m=F> E`zB?,Mݮkd,Fc Ĺ%٣zDͩl{.^/䶀Ceʃ ?m`Z dL\{e Ibr~O:G켹/BgуYU$1^Nm8HK=TG $u l ϢxBQ4\S?k!ðnϠ2σgrFqݐ>8~i%`%u$xɲq0Uɺ0"c x}+ͮ9k\ Q1̺fuf%7r~J8 ~{v pEJ=LC{"DŽj%_cX}(WL?/PB@(rTU2!WK:'} @IϛOnFf(ϹRS=ۢr&krRrԛi|fQb)Jy=.}|fXlIev6.vY_g0~FC7TcI65&zq/,1տ+!' u?k8V ԡշF+@bX 1oA-r!s pu͆b;!c79Ce N %B,T]?3 @f *K|;!d|?1l6r[VJg*_A_IsE}BqVxKJm~{~voJ( *xUS(UgBbǣ/rAT&fЬ4cBE.Cȥu }-N`aaFn,v2=b8:H փVh_ KSnWiDw;GԼZ' &`i3ݾH2<+Mk%hnbqJ9 7enGsQ2)*ʆy.(y:=[.)*ϊC4M]/'TL ,k,HZ^@ax} yX'~aE!p20hvUXf]iZ.(g`X"/ZiC]B*ɩqu#$=]W#D`'@RDf}+ ώt;B/kk 0[ !2[nmn#>|JQnlXIqT9:^γ#p Ta7']%kL9NR# _q.7:rɻVq;}]MLQz~FHҕn;]e9^t* NJwLBGfk]02_]]\5SமΜaXfVWw䤛ץUͪ:[aVWWW3@'DM~ A:y)A"}&2)= L6_d씧)|6ybjF!-w6W@RFE.'v?@@ƲIysa[lIlqEQ1~Dq=XY$?&S15etrLM~+ʋ<@$gjY{Pŧr*: );%=h6_\SL2C!ٻgΝ;w8 ۳gqWSB`^IXj4䉣 7Kz(SV uKn\u"zt|ߒb˖8}4;:h7:,Ig?EP#שWNeOg*x?< +?N C w;EP/"G PBD]WZ6l9~|d𾓒4ݮ}r< Ej#q[?Nڎ%U8D䨆|U:Jٕ ("ނ5Ֆc 3=p@¡c.I}Pc2 ر gԭ2KԱ%L0T cG9L@"1YdU-E:6IexO( ٲ6F`>=n/Ѱ& Y?$'6w; T ]UI{JL&A>gyiz>P!WHpJ C"yvZ4Tɺݎ^0@ŦPB:3PΫ`>mO\;%BxAq0EN 6اiMŁrM!Ѱe.Ě]-b26JvM ֤a$p~8qI܁WBђdfןM}fIWBҜmG,}=C9K3Ҙ->1aY^JZ`jxf|ժ"0s2*e&\1q0͝IG^@x ݇^/'KO1tY}JH45u1)] $m>__>:Qp`.ppEim ˺`p+'|-ʞnqoa\09|Ջ ]§啎H;[p5k^/Di&nioKB\oٞ]'x'A]OWN*iؾR4>;"m[Z4ǣd!Ğ=ygzf)AYYY"a0)ΏP\eFɸ՟ 8Ql7nnCRI<(x2Aqt3=kahkL\NK91umο)3AHG:Ƿʕ@).JVcr{ (%br_"aRrg3ĥf\P x ށtf)d=/!+.0Ea0P2&&ii?kPv|% GZ¤t!wGt.KjMqqMśe{3M 65U?d5 rkn^KҮYTjBb]i[M*I%SLgw2:)e<$l9NLdgyZ whb'\8ztN>RoLd|ณ,Va# ,$"b{0xKc*F|ָ ܝjl?,T4t%ѧ.sFćĨ|p'Ƀ+jϡסg?U77M]D\B ~^l.G0wk'ړ,ZA/llEEbJ_Cr`Wڒ3[ښ,xbAyxAbAx9 nK^ܚ L<~g"35+ KիWu7/J2P^-&`.g _TV+nSrKڎJ8y-m;rK{ڲ!yBG-XB_Xj#HΥyŦCW?r]KvEpc Ȋ"iYzgIDMbL}Q8~^7nlXT1˝LwZb22#t^Cnxȳخ 2<}ĬMp''>nu?KƊˢm8] G25ꎶL%7CȀ;n@Q@3YW!c0dL=u!y<%peȆ^fE9YbTҎ"ml-]7]Wj0bt>-C9`flig[mZ*%JwKia*.1R13&'{uL0}G3v "E!\A)>-D! siL5 Ay3Y[1q)/VSL$b-A!= F@7:îIJo<4wS}b!G1f Lj8'LtgaƖM SMF LDk/֦ A -qGS wf ȉS)-mt:|!6<5BkǑPf3{%SE N6cbO(%Fʽt>ERJFÐlB j_ܳmm/zm@R25tӧ.meXڅIJ |$:ka}Msh5Sc0mߴnjy+.3Sݹݝ>\ǩ7ڷ{w*)\{grBg ؘF˜+@HdZ sDy$#w&׆6ꅝdOGMrpPvG(Pt(l~wԨW* =c.pζ*9Ƶ,/0}Ot诚4kHU.(䗧Ug+ry6# #MYVa 'y1Jzk?Jkyuzϊgڪ6ƪ&eEGaH'i+w,}^?۬nBܮTjp:[:BMw@Wr2^Yol ^uѣ-ao .N @8" v!&ز-,.l|E~JU7y*KG?h&w{vJI sCگ gM8 SҨ:K0S.PCe3JСq +>1(\wQ1Jt=Ʒ\SW&|S4}GxLe}9oOJf Bؼ-A(9/mܰfB_HZRn*Bk"/f#-Ɏ'9eus*lkv:͏ .ȥΆ tc 6}y2t{;Ǻ^N 1׃iFpWqz s 07I$:B8Õr.|NȆA,D{99#LDk Z{vw>E)^p3'.RpDD)b5 =Өo;-&a 6}*cka](R-LPO|4,;HIFH~T x=A061< ݪC6_HTi;.,;E S7xq1_瓦6XblJ V6_,yOřӁ3=X;((2jh+{&fb2iML(8k͓' uDB}coI,y-Hʥ#?fj<~ckKo e~EwP(~1W4x샳/J~}G?gAw]rw;_{= >߲,M>?$ rcm J kwvuN8m/t PA1.l)XmakdIa{ރ zGL%@0bo06!\) !#+v \aL2J7| 0`0 *9mI]oOug.?`dy( ң\[d};uTA+g;[s'"`X @qޙXڧ]lx_\2_>+;,5_)P]!; ( L-/GCM1$7} @-((xZ\?ؚgڄ]'!. zYyPm%n3@wD[_$6u$aVCJ)BleR8ix+Zw(2x02&m7̩k+:KApʈҾsBˌO%& I ?}o:=?9i\`Jkkcu{CH--*0 FIC0fl,T}в{)kQ)S=ZvU ^)buqD]tju=0'g?Tk6c~- Rp9 23$P!FD{S‰GǷ6D.f;#EzDyJ(3\G<tO\9r<׷`Se`_gvHOjIh0Ü8 muWFEaWs@1DV 1׸3p_7Kt\L%gq@%ⵎcǜcXz!BV|ϘXۚW5޾/ )$*"a\(07ѕ^on|Qlwt~9Ùqe|eVZcK6/}ty}3\ړߵL X6 Q3R`0uVQb e)'?&:e,fw!iF?w<yG[Gh!VtNezB+Tk$(Œc'OWry̘ڠ~p '8!y,1DQN*ϕox-]i+ ÿnDSCx^q2cXᑈ32amv}'I2&ϛDxnz@2(2M8 k1Bq`2oqA]kֶg=ke v촜|v*gU$聒|Θp_nj6rO䖤P(; a_hFy<))D3.㎚K =\im\Pێ!ҴkfVagbS0|y' <ŘV<߶{aDF1K?1ŮWQ1OGeZxꆫn<\- ̜0cbkbk"!3&?njǶM}ڜ0'6qL=xGgh؜l#Ju{m4R}bmœjױ<}9exe3a!_e2/s"%1ƜuL9Xc4b,vsW?ղNZg7[b}eI*S,VLdqlxXNiFeds#GBނWG1oj4tʊv]QƮ" qG-.V=q]7#6N9_c$\ o Rf> 67WRˏarbn!9~lbCdmC>d\7\96vE+0G<*/,cQj1 *%ln""IP3FR5̾8~0{FY/>JҀ\&J&tQF/˳3s1Ft4 "HBHGu}Dx2οV-DFwh> @AS Gb֦uZ+GS |Nbs@dbˊ"φ k **L}\wT8yyzhٹ喝.g6=Ҟw p穫bFlƗ7 71/2~4H"p'5A|n,nPuW|A c 9б1BƉæq[zG){z=SM-/w .)JF,z[ ?Lwe_(D"J \Ty~;0j8 my^b #(XJLTE-;8ĉz8\_K7T2v^Ս*@Puch῍oo&f n' ¿pFk`"}-)^_'Dayd?y ]q,&g|˴ZqP[ߋu&$z/L@՚j"?8*Wpf}ڷKyX`탭?`<\m慨I~zg doP3u?o/=Gǵ N ;8gl8|袯N:Zd=E:d>33&dJ&`5!VGmnoCqAyɜDY$޾ISż*U{V7+۵:nDh!f#77T=]Iz M7}mTsFS*A({/޷. /Khr4=qEJڋ P q:USnjVLK>{> !Ni_2S1~+JUqmOo~zb~I8s'0*5碄*n9-:֮[KLK'@q';@K7x W?5#H|d^ [Y5ɖaqT.wdA=Vܤx ]y˝80}d܆$[_Q1-lsmT,l펄),\ѐBUV"db]l_֘ő*Ѓ"N?s\WFjv^*"O%u4u =ՙ:\u1Q4 2'o)E!f$(ٺbK+n$hވAe9<푨N&;`R1*uT&`'6KOމWahZ旸Rܮr~cA+rimkE3M$3ٍ׷z4Z | D]?ػ ?w@ޞmk_p)rjٸ MaMQt¼mYYQՊ -80DŶPflÄ`6!tX=V;GsBi.B1!i`QMs &2 C3XTVߙndw審{;W|$.Vpe4Ѩǭ~wy=[mvނ'ufWg~'/|2uy%FIY%؅Ȩ&?LU8i5+t)}Be|sҟ)yS$ݾ&GZ hA'HZM ǩ!.뗲ўpV_JJ]78mP^$GX|Z~e*#Ѡweߠ̙H3G%lͅzI;":(p~wTL1`a'=miG3(Yh+F.g=~p0me}ub^J᝹LrfeRAInBͭTgOMi9+s 19]\L*22|NӸ%lE^SnGVy!/p"^epp{o*3jȤM;.(++?`s?KǪհ Z qy7A?MLr%&&]=nrq:84.bJ5 cbðZ.]dt.7-} .nꧩv!3{Ic0bѣn(M? d%ha8rIn]3GRq1*H?߃d 5 msQԘ2)GZs,90Bbkw|T"/L?kws3rL=N67wiT` \1#YZgV?6~L+Ҥ $]4R6 ckb(E%^,`0YUI2ձrlrҗ#Jpm*]r%i_;b8ӪLr=R|ʈ^%ThJV5!C*"TxI0{՜+Z yCgI5RƒcQ&v Y|D-Rj﬋Oyx-n-˷H^ whbyeQcpýWLj~-77pGae2#kHYm҃FtE) \vV[QjFa`*2MKGC>|X59i>G45#i茟z%Mr=O\ )7{$ ٽk?^acF&{z&w𞲥ND@@;i!} ElJ|\. qS8'v{LV xLߋHs^xN{c0`um./6r&mm -+T\~GXxh:4(ΈϷt`㪮%Ӻe STyh>uKϹ`j5d5N*#;Lh"EX1Ґ|s/^eHhG5D[8S.pteS1- fvew5\ @x]+}޲gJSKΞ={vPCz Hٙvmu< sNj_rC Bއ|잦a̦P7Zu*fgՒCNj SҮ# ^.+U(#4sj5r")n&SD`ia}Exu6*nn%Ő=QڅS/RE܊]J&K) n&&Û1֎,^{LW$}#/)e5;@/ˮCı^w=v\p;oW_-oy>˷~2upE|H6*re@)XZn&^ϾzZ.h!ǒ0cX\OZٹ;<1r( (5-LIʸ[`ޜ]IoOh^`+=xrBBackô|b\iUE/GJ`+aʭjhpi&_َ(Hi*!8Gq_nRCZ#WIO4uZȤq\RT H\$jP(L )=jN8r;bHd$S5-ֵ>| VBR cvb.DN7T &Mi$ N.pΝ;W?zYyݿ_Bׁ$"l֑y{RA?"Iek;; A|˜ a6u>)s#?Fn$ǯU¼, t݅^^q8qkS4\#NL=X|{ Qe;@Ĝ("p~{ 8aF gQ4EGQk#pS(*M#'O6KqKU<8QCkN_,t6tJfh JtÞaE)=@UV:Bd_%Zq/fd9') 1u4M{0Hչ׽uL6){[x8mz>z`洫Eqg9Es*Ƽ2)t2}ӻW==pպ/(zh jIBS}LԲ?^ Cޱ:09vh&GGto"ϤC{; anފU&'Bϰn|%7HWJq$N $>Ҩqg7AbnWNcƸ֜1;vwQ A,˒VDZHAl8T> 4oD|I8Onm iFf"EHkmFߑ c%?xʹۻ#t;z.o5BGٌ [9@ @bCdT(_Ju~V`L4MFjv{s&%k;D 6 zzMsasFFNJb–`o֋6Z9l <#Pa/PG)bV-4bl$/j!pVR*;q Oc$=i'Y tjV0$I*.b.t,^韭#)M^g\HgZ[~s+Ze#%s_'4\xv2-#@پ @ͻUV-JOHe1x.v+ER8vlIqbzsqcb1nJ$9]/ 8׫,x.@}QTcWaXETUxUsQ'@/~/7[HhԷ-Q"b)Nm;Spr6ޏ9m~{H;&;yyTiJ GcZ 㴚ͤ=g`enŋ̲|=2usA*.!{_0_U و@8)(`C*)UEU#RXþlԂb.k+g>m4O F?]&o_څCw.WE5:!v먅bvd,g{\Sp5e  &.O4zET㚘n9`걢q 7"lZY\b0ʯ244M斪04mOR .|?2|\*u$}+q2+vf E RQ$m;ǥҁhU64MeFCJj9e5ƕQI!˪fn+`(;~BKX4(|e!&/#,ՏUґLL wkMAӹ1}t…GKPoQ j\=rZ=ch8[\Nok[㟫~sQ@zl+IL]p>XA|r|?Q r¹ރ}#j};3On3VaF{A0VBYM%\b;f߼KeMuN 9@2kv$*x8^I7 ɨ3{@ϗ6qY{*ŝ"߶q4 .hS8/#M .DgxeǟMYO}_Ngs<]?O?d^d.~v&~u+."^^AEwE-\;xqH0;˓$'W&Qa\Z-IWq0"Qxrlh "Ef}DŽ-kI8hxx@=MMƀ= q $2JثR?VÆySism&Cg8WYմF6 #~V<@;sy,g٢^]óe@q ;974|rGf"^q \2NH] ! g<Þȭ{4*mȎubx5r-\u^n8 [۝%8p:G: dEh'j?V+sq[% 0Z (k,FA LmsX)/~s12¼&jkBVDwtMõ,N>1x=Ԣt'UW7@HzxANM(|B6|Vª֞h|K*$3jΛC/Z]#\Q*|5{nؚ݂-nZ?76fF/`b3JBOW&D8P\|@ fQIx@$j1CXA6}ӽd;x^dzÿ~dX/\t$M ̞$ O=-2Jk5)#a>W@qbw2,};8|cf~[tUdt@oK}1a˸av]z»HIS9`{8FvO8yZ .Zas?Uǣr'}o.> fn=v˸ <Ǐ63Qz1IzԌrIyӹԚ8pY4N*^J!@s3ga72O ⲛ끠V^B+RA C:嫹++ܿeghOr Nj-..:F&Il{U/(⫤j.o)Ϣ z"vuiT6svMVHDҞĦ 4.7^^_c+AYpeh'LF7WJ`dljSf"Z?:ԻzwCdžH nqmӽWxYMki#4;УVg;DFEԨX c`0uÖ[i#f4MFuQҰk$H[04zdtLk`ӡB [o#LM($qܜ,{1r@LO<$\2.am00j~!33Ѥ<9=-47)8Ha[\ )OȊnn[*ǚEF6K!4%2>Rfd,9vw'se ӜX*0c,'E0$r8&V~V׹5u; w*X"r,K! ʱd6U!4kPHad eNHqjC,$.0i!YJ5ItH @LxKY5cBPĢ*-즠UZ#Țc&aY_ck1IF8jHt,u-+׶ 7wƖWh}OG;Vg_T*JП@Ym;O˲s͓5QE23ɸrZ/J7_\=2Ԗ\"R]QNPi'Byz oשOzA HtwPiϻVAV$ח͋hn~zI]Ǔ*vI0iha왜tӅB)33ku_co?Ahmwi w H]Gv{p͸axs/㱢ύ9{Cʹ\yz7*)Nõ?VPg~%z?D3`sOgY&rVt9!Píc "ǭ44bmdj8n*!dz*s{Qŧ⼩(QyG[D?FC) iIߛL9sjH3N;n9Α $v/$Y+j~y};eZ%_q:~cc> I)![_ }+ty7mZ{wέѠW_ ZBܲ1m>OWLܧ:dھBsk7m6AhѠ6`R/s[5 Bv;E%zA/Mo㲞 oշtl U"MB\Fc0|(eK4ԝu&nH:w8vHpۍ)n׍ .g@rea-I 0nۡR\%OR"Rz~勋FPLR@4K{^fz2B$E"Ȗ\QIW !v6@ø9HD 丗䞙qF ͆yU@"KrZGkГ9!(7 Ns=r+S[,04wD/-EuOVv[C{^¯jh|n> hZ>#)UMCaf…ʎWV r+nSA?T#1-ESxںT/M|oN,}jRE-R/ E¯a655UKwHLyѭ_P/N&iKKзni?`$CY2ߗ=DW088龨BIXuOb(w}ldeCoα9 <^ xGJǙKO":fnn^T#P0)fmG+|]*iigffeDI*0SU;/:UR6g/Dkl1g=`Y`<6&5MUuMa*v* Ս'pb āPjB(=XP4,B.t( Rxɏ d ûbeX<>^S51BC\K$s}m;aBl´& F`;^h]?5K @zzf/KഢAʙ-\VTh'2]I+=;KAxJA %Z8n+Mc{>ZRwp`}ز,RIpRmI)&Tm?4󙒭\e6x@ir%VX P8Ƅ&d!cC_#6M@5XpڨۀTPI+PŢ+&j60ƪ ׭i!h67#Lj |Maq[&u01^^??2WS-m1n(Uu @rjRdj jيl{p$1|Lo4~z&2lgi<.hˏ9q%e1-460V"pxN#ny>a+$e?ٰrg^=d qL1(Ci$UAc4fҚRJu Jdq ~P#$@.UNA$I<C(EhT\ cƸ1j>&I-B.z7 6dyWj)g~NYjߎ IKX+MX@g!ȠiJ63M .g xZ#;q6{V")7YggIUζ Pe_X*bX ˿B0s0u!j)uՊaݥؙA`' ¥YYSw`fW Nfܡddpɓ'O|+{<c/{7}:T!'otRnJv\aǥQHaǥ66ule?YxBRq~wh![[Z$t(-Ah``2S9_oQQL&$4 w%ardE3Pym3@1$Ƈó,+ YԬ~ M!NJ9TGKA|:Qk~9/e>}!l?/ V?J*~3Ps=ϭF@j'jq9P QzFn+qP1/;aPF%w΁p7 =snε~ZoYy~zh}j>#HABs0jS(F`H{,5 <(lF^V5z1! MgQhdRάNNpS{QFme߸PY6*soJyG3V= 8nP+XIo*w{#+E('?r.]ڜ:sS dkZ1"`-*/w۾n%x.?6?˴9I]S,¥mpyÖ{FEY7|7h 6!jeq2]bEy3#ݏ>(~U}W:vCֻc(0C׃Aœxe9YFFe]OKqr0U{Bc2f!gO1Įo^@cK {^%gg-̧~V)j~1.;.|r ~帾Mb/)#A8*=_N씢Yp~ڴ#O>zuO֢sy߼Q4v=00C>|1yO l 4`V . ZvW !d| n(bNWHs$j?Rʫq /_n!l_ժu1njǖ֩.RwaQ%8[GዌQAlD csAY˵CO+"Ul=(7A8:8~M<g첥\"r_a=>a+mZOK1dTod$G+z(<ѳ1SRU!ŴߐlqtQa@a*f޳]Z{* }),v!8q8\wFb: պ5G \cgV9B$Ve H͊LRyz~3VOF]5JQ`Βtr:jԥShasOOZ{0L1Z3LM a=r^A*;UŨ`v|kU MJrv.z#Ps] JIx^=%:Lj 8& ` KH"P+_B }C7.@r+f6ZÔ9/s[lj$ѻw/Ltm(p.l)Oc@D5'ٰ{ ) YB9wFɳJ-@Cu۳7Dԉ}IXL#z4,3Ȣs, ZNd,bТp (W ]`K4`Yz242nR؇)L]*Èa;fu$ & 6V+0JXV "z}4וC΢!y+% xaN/П]lk{[8?\7lA]P$̗Og񾉏.^Z 2QU0%Z'lxp:‰,+/S- U*2fNXw-:Te42uwap.Cu1 C9nssSMM^:#$_̨XNZ\3ׂg ^hc9$D⥫ȫHOqEwA"»ȝ? D[{A4̆(qe6ߞK![نI.]fHFi K>i1Ő6=ϧWT*crےDey7%2R[@\C s;y>%rʒT"I2=Hy#oZEGIt]B/ΘJ;5(W۩b|0[0Η,:B(Nx<^ {vvt:T-"S\ް |>}[2jZJΜ93R].{?sk/lbZV>7/ #6OjV9\w&hbf lnf+$$/# v8%v8M2$F0F:i=,`-z0F _e̊4ٲd-§b32h-"p+q̷l8q~E)`PPqa<ȓV umyazzz⊂lL3-PrRIy*zO EI۶{ĩע6{0;0 sv munڢ57~T(bTXy¸8:ЇS*JOZUJbكcv`۶UXeW BE!Tޭj޲LP(-vjBPT( <2[j :Ɂ@j#K/W:htW%qbIoj&qM7"҂htO<}ߕo۸?}t}.еgs3]~ʗJoqzJܣҎ:`b|)l`1KzAdM'YiwDbIl6qfpJHcqFi9)bI[e$qlYܼyg&J$LeY,c؈S&P`)\i?>VFO|Lg6ye,1a*D3*Tm{c8o/āCx/Hwyd*7r2QZD"21jwi' ǴkUa4dH$G`0mL ڱ,J%ȱ֭޴KZ)` 4ZA*M@oHW'Ybiۿ%2uW ԓ\)x8{XZGmIJC+.T_aTl1z2?e@+_qX@iHm˲SÞOa7M#xe={$}<NJ>h ` ¯2R;x)6` Q`,.cFeӵ2r$d1Cf;;C/5F Aff„!Ns9L25M0X;Z*RjezipN=I– %}%D6d~x VLeoίc}ϸQA= c#Z_'E*f^ /l"N@>+N^ȉ6j@+'^D$}ruq$k$LLL&8Hp)"ɺVC:~zخVe}~Tj(*Om@ZCKW#~_SIę^nK]bz'0'M$ڨVLi5D.$&l}(H<!3b%JlXyR4"9qu߾}!F|Sw5b/V|߮=;E6yd[[[ZϢm#6Z&9 ox%[< &GUU<)߯`&g?;U—r;'lt+G*xE7">rL/sQcsg<Ac3{T}O> )¡i/ϩS`ys7 l_w |B(~dwwWDu("|׉|!Kv.߷Ltv4DDl?3M/rB5كf z4*o7t\FF Mb6L ^QFptŷ\wh.,4'+R|GdFwo)0=YJeшFy3G\v4&16;x'bMb&C8czj#ttZ]ñzKbJVXRr 7*B'K666B7 ,Odz4b0™p) 9"G K*+84+<9>N rbfdttjyf#̱VMZ\>jB P*S|ɵy9d/7 c{8=8_6fU7tF }z Q>EtN F@nzTB塝pYQՙ`% ݄EOݩw{4fLЦDdt}bwg˜;bIj0xV@lC;xd&@. "(Rr3wNl:Otk l\FVjne4^vTqէ6i;>D9fxΰ{N'XglG5EZ%`f (ZO (5Tx[٣mz jLC/i$Bh2*.6:@.ON8tJt(7l}*o`Mڣ`Jj"Q4Z*s0Rzi[qJVm~q=hAN̊G`? IOn .3rݿ]1ɖqWr&Nh }?=hfURDjVyB2O_>~ʰkw2lr+Ծ8sXZr/ջ8!LK0_sIߟ_Ecu~Q2~$s)>/Z`PηPÍG;=&aEu(-9,NYFp}`TfgrӾET&z)efn>0ޱ#E.`Ih<ŇC9cTB:iJ턞wb&J aCLy MXȨDՄ#zQ# yGsab ¬oZvwM$z?җiJYbWp[$k[PQcGX4MY DiAt]ˢ>3"CYGVqBrr*i`.P2 ndM?_mwЯ v.=F}@e;G|\߷/d9fq0 ,|>wc>n9}i?AXܰo)Ƶ n Á鋒J7j>7U}ȧR%ndf6,;*lXu4_P j"Z<4372 q5NQyТQKÄ Smn.Rpu>WlKiL/TSN nD٦mbJXtA`:~i.م(fyJĀy' X@f d|ES'UaVX6?`aaz1=$:m9s=\~ S=$.dJoI Gܳi"fxsJ~kUܟ.4uKkΝp>D2Ҥ1M6!pd@,d# =J 5t]AW2qsY;[.=3U>޽{5oŐz!7 OM\.gg\{OFQle{r~}SlcO2B;s<7^h̷ \3Ҟoz+̉걿M(ᛐO-VgBm2:1ոvj0'oS"D}3̲ǒF<:$~k ͟&XtEڮ4g09FP*lԮT4xN5 RSM՟X.WkPS+4)&ڃΡZ>o%Ikg9m.=Vh(:tZ@¨ܪr"lpZeL$<;% ѣhw%!\EoNpsR80MЏDCki)|~cIjF%% 62ꝋ1^~MK#xztM^0 M4׼5y$V ɒ$YR`I${K3SGz5zz:FKS*T"8b7K3u_,NwrADvT9o{r%cڷbgN8k&(%X7kKkVI]vX`yCTL=d1V֬+-{aqK[3>Ƃ/>J(BDsPBqeA%lv3[Q8xzCC~/>|ikŵEa XZ\k Ty#5\#\`W*)-Iͮ=RmJ >> l&b*{ W&5--D QPxN?G)|NQ bOUmEQW uއ!N;>,Ap {qz;w$OQ$w+!CzxIsTQY~d{-y/[km14u!@$4 qhFfdG%+IVms~bVWWf'|`;,} # bljb`8EJ b?nT$w@LX+fPnݻo߯7yyCpSXa+:REZ UT$Y;@䭇0FŴqI3J9 74Ͳe\,fLcFf k Ct. }SV#[ S{ IJQ'JNw$UMΨO~05yxܹÓSs]1nHzհ` H }<N\QՕB@V#8'H$=˖Dˁ1 _7QI;uFSJ%һ1`5I6oŐ$(>tPn!<3_I[)c(a<"Ir6+K_,t,X=[46a~/eedc]X$K g%IZ#fD:VVkA]BfSHRФ7فAcL ^yLTǍoPJbƥ5rO/u P|cZ.;. , ^*iˮ` :^⇲ƴ n--6J -K˝sJhsd:SU*\g}<繊&~!<Fж;C}oѳB)) E9e$OE%kN9$~UA5x,#y[)kC{~'@W:yy"{cȌ B˔G}Tw*æ y5j!z,$ 1.Ӌ`f,Rjg߽/K3RDU՞l !Y7N68p RqnVkɡEQ(UVjɲ{ڦêvRR((by΢1 1xRƳXPB!M E10e47 KT !S0sl,SDJ xypa>6*l&Ʈ'SW0Ǚ៛5Y,HlǧwYZ)ߵRZ)/vا&33Ʉ? q&qh5\^377&ye:h4܆mO^w>&:2Nj>72դG^:ITD/1ysT׶bhۜR+ Bܶ;٩{jjʅ'mE۶]U(0? \]S]4Uiݽis֎ר@u:QCf҅3w8b %֦Q|r1 evUΫ04Ԩqr|RƱe"qҜP_r}؊dc)D6'ZxV޹_fmeLIOfv\٫6ތ2j/fWt3z86t<=UvZkWH $Js3H;AiskmLΑև=MNSZi{o;Ɵf5tp{Si P͖q/;4Km;Du(8+q}I6;TZi/4ؽ1won>=C[] 9j_e骺wb%8 c`]+I.6 t("m`"}_'et3zf0XƀQᶍONr d( u*\w"$s\L!Ά1 `cn}쳧 ~dtP~枥N痰q6mֵ~$[6Wc0'$oT|Bb/n Ih.MLx/)Opؘ_fd5 x$D~+twC|Cځ{cI[q&k 2i881%'. ^_Phr;~ |ύ|x</B Ao[nVyX,ɬTec:*(8(¸{ rhk#z JR#_:rcD!$hT1vI$~J$Tϓ (_)nV 3Z|e'~+OR &iY^4ԢZUbi"Npzaa Nx ծ>"ItIezQ)+K$R29(~, [%w-Gj,jqPS0c[(ϕ~$ } Pp%pYfLwlhIDDdJپes-H+th-P8+MhVtbȸ[enrM ҿ 盜|BqaCF/q@ᨱjR=M<&dlЇ٫ JX4R'\TNL rEAU6 񭴞z꩓{vRێ^L6d C&p3)MNΏ=P#Κۯ#GCdӔWiBQ6MX I)1R5fp80/چ yyu–:^V.88fcT>@KBn42M'Iҿ91]sEj%#g If52kWWW±hj9 >ƶ2Dpdֱyk.]׉]w1r.:%}U\>@7:9OM2j \~~,W5?_ݠ{-f{֎ SrIf#%fղDA^V69 o9NdRrj.$JuBxfmk|IJ: bs{6 U@4ݸ)r=ύnF {-͉e PJΔBU QQ2'N\&Ô%oǶ=:>ݚ] ;ֹjzȰKܻVWWw b`,W]ʲ}jL ;{ގJq*r7Hht+Gbkidʱ%9km:HӳtR\G񒆱gw ?ۃU]g}ҥK.B0w8یCCΫv{L΅>^#-k{qЇ>sكSv+|mb cnn)S8\iɵTmtd3nKF"&`Yj^Ű6܂L ]o~+Ưֽ N~`:s.8\1 06ɨeoeDjCӋ։(J:ĝ@s=׶Ȉ&}0CbZ^L3%զ,qa8g͊9ߦ|Ɋ*͌iB>eKL $ɑl]fU) _:H vm{w`x5?bH5< %*aD`dRV/>ĦZ `,MABu"%wT8ci`E!.PjL(䧖z]ݝK}PKܜ"V+Gi@%E_˹# t]""r,[fNLA:$L93UFh(&k0z_d~e{d)JM52C1ّ3T|Aƛ2%JUPUJfȲ~]zm:] :rgf^-nDGLZE"m:4$s.g;bZuwee#*vznȸ1J`_VtEJ aO˽:汄줊ߟr6. ` repJ56ܽ2o0Ș0,-e81qjSk/Q˭57X0뷵)-?EnS站H:0#́C3"hT)LN!3gX(/B:T?$ȶ$2@C0B=C"$ݽN:zI+!=ՅDLw{p d!׍֟Z)&j0uo>s|4$j#ЦnY[>oIuF.Mׇ iWnnnַUys뼖S?CN)˒,in[\QĻA.5i:$)RTu1 a*BO]`/^h 6#h0},9Rֹ/Dg6 {2R;:cI;H;i*us$e0ԂGjTN\PJRa ̭*]ފʙ;E4sScWoA)3 Fe d*!0$Ȧ ͻv_AShmH_5;cOG`Zk0"IWpKRV_H8o0\B̄En>ح9aujXs87 ^/H/=-3Ib dSZiNS|a4c´/ٌkKI^k ͚SIh)rx"it1/8s*[fjՌNm%+rە$tus& `8No ?Q@%Ϟht9\@w%SNb?lߪַ`u2e0 ܝ ohAA9"Zաz,j.6O<UNLV:RqWϫ5ꐃϱzxn}Ub힐v%s2LUaT?QnMSYޑOLydkԵ$1GN̔0fE K陙Tk?foJ2.'022.Ϸo)d*ͥ]-KnILn5 #]XHV1BñiXmssI_mтoooY$sr Ü9|q@oE )qE6 \wFLK x4bHwt6A8ݝ:Gwqj8n&W$}QԉVvڰb:x}],+r~;ζ>I<:")_]*VEGj7c[ ̈kT0ĆZ4}kfd*LmT|hiP6k(%1tMιMs{xV6e/2=AKnёA|%S#a2_`@5 SH aAZh[EzR~WދYط0s$ܷo13=Y94w|#c/g. u#}~g9?#} w Pdp \ˁ4 ŭ)^_Y6M|ql{mǰ t]-?k[`l=Ɔ yϣ:v$(׽ǏdsSSݺ5=Ŵ5UhA47]޵{jݻss"Εx>T4fmqFz8CWHzE<8wEy,F'}7|n&o]Owa;P"k{ MG54fH ^Ś՚Y{8 pٳs->~d>`@G!EcՂ|TE[\%ɨ׫Uzݐ$]lxsUR&h~N.p$+GirJIx) F[ ;n0C5.0J[k6tyo*pb"51;"ĬFQyngUokV @^|lF0qFRJj0•bK|$9_->I@ ȵNg_ﾅµumňf%)Yt-9.!2|r!GgNUi7yϸDET~HUhB0ձKlK;5\XWLVbf˾=X#ZЕx?.Od );"YՅ4x3EL(jaP ] "s~BU]7_l;v&c[8x˂Qoa60Ãj Wua]LȜ_Ƅ M[>~2;6OT[  Fl`䂁f:i$11/&d# naoY}A(^WQZoc}0 ꬶA15(]CWrhGj%PVwۆ9ʜa픙 ،x.~ېC/ɩF`{ރu*N ( a"܎6A=M DYP4;YPSMZ!yO'4ffmYT 7ܐhfwp Cr>+s{ Yr^O~Z\ubv ñt]DgП}N[/`e=FƓF7JӍpͻՕN3D%1tuRU`sW'(۰=Jɜ9PUk.tGe&W?)q_ܷ[J, .2653zc2ZVv,j@Uoo8P5V.2Cpj,R2˫mnI-Ԡxz5zz z'51_14jAjuQm;ޤtL#Si`j­Glڶ RzS&(Q(dYV{9/r"˅yU|~1_ !D~R!  -r&dZgm:Ooz^L#^+bؿ|'zM`F*vȺ!c*f1onqAʰ(`1u2ioEQݘwG$”9ŐJEJ;HaH$R(LO}; =ᘏfmTfKc'5aNTQ@g=u%&̃^[}9Lߖn{_rg~ݘ Ot qB'Ufx vygh@FVoȤMd";@Ɲ:}^eyf,5Բ&O, \#2B]bC(er7y40%ͦV^D? ~|헬_;r"(O xy4+Z aw~׮]e!p^;GLlr4@u>N ABnxj! 5[Mbx:v&RP߸0wqf}y4F0orPݖ(͟AWߣ_^8Fj`Ҧ姛=;ΫLk5"}УBɏHgw E>QLV1Z?Wpk1L&ь˳_]vs=b3y/jc#;N A;+xWkiAg~F@X,BFI~]"-v8ɴ:|L| 1Be~(\E%LmT jҒ p.KCf*|R.f[|F6;NRwΖ~cJcjvxAu7Qz_jK5FB|)zs[֔鹹ȵS &tߺ|^Wb.{P\W&h{8۪sr7Dwpbcg?*O@Z\/ϑv 4'=IKqA[Ds 3YmͿ.!Ɉ2"L{G~#5IeggZ=}QMPqBa $^e7 #:jy`|js=33nl\iJ$nn7I'7\CnZ= p |8q&;y UurؼfJ9ˤ+Ǻ]Fi%D'p11(yZbl!/o,eF.0Ro~bXJf3=0d̘I\bc?ȌUm7533)*EŒe=ڑ9aa~9:Z,YeWqaK ^&1s=)ɹ#hpu8!iF.6rr4֜Cvtu1JF6 b8l~ɻSsd20evǽG(鳉ٝ%ou:L;Lf{f70N䁭ccUvRF/ɲee~TY*Tf|k/),U4.OMp&87s~Tk>b5YGZCfd|!i:jdqWҹz~j:*ZtŬ{ZڥL[sW+{Φ Yv _O6 )H:BB$%G6B8t4 ^搁Lo=#H5ɩA H HE3 _Z_m!j!zb:! bs;`1 x0n 5BZ `/pIHj\.`L?-0Za|o .I6 e:!2` M=!30*(be=pŃp ^qo:œA0w7\U0=0zaa-y$B X wÊMaXY-V u0y T:r5;A .;J.wpw'{* <UH+Drx x*尳~= OA<vBsjZ0/ /2xڀ:h7!x{<*+^x(>{~=/ >lBw>p VD>뇾!<Mz8RGN@+Sn83p6p ΃Rf| P;o -C=X? ?uH%\jDBL:$ mFmH\ bٍa۪߬F$1ػyBۇ7!<2)$IB2r3LE4 ~@rBT2ͅ"nr)9!MUAׇ̩B #"s ȼ AE" K@,̇,o@Vt!7ِH %AV"krdRA6xˑMndK'RۇYlBꑻڑa a #fn7C-#GNIdT?>dgyƋ<ۂ4]9yiA^D^t!ZeiiC^!zߛ6Ҷy-^ې? o#o6mNl@]ׁًߌ@DȇMHw5W?@#rAP3rFV|ҋOOO#Fqg)yE)o ESiGNGv#Ǫcx9>ҏ|U zȉvt9]FΖ"g{s- ȅd& ֏|ۆ|W -B},Ȱ(c-e<22TEŅ !Fh?AcBh,hl=jqF jt0߀GPkFG͋DhB;X&@^ه&.E]-/:֏EuWE'P M)mhM;MhlA3Ѭ~ӎNv[)>ti4< 9iatz:Ä@g>֡y4?Ԡeha7ZTnVFb5:+ЫjЫT>kEg9ѲZ: .^ߍsZ|荋P7:ߋ.x]؎.Kt4P.DWCtE:b5bD+BhzSҋlCoF+[[[U%5uZU7m*t t)CkM"t Z֡V:Yn6Et{5zwZDY.<8|=#78z2cD'pbNRqrN~S8u8NU8#gǙqVg9qns 88. .:pu\re"Wp\WѸ< qe-5ƭq[}vquU>"sv}qv<Cex8cx|>h'"<ϼs\</Nji<T\VEx3ox{8iwx;>hQ>nOY4>;/g| >ojh|{5vϗKczwg{5CS;;% 2 k+9,m?acEX&ecX bBt+gJVU XLb=X3&6vk,IcXw&a!6&iUf| -~ǖkmJcخ4Ob$v]c \c$b2<788C658l_#8>&ql q58)38y NYS8Ǚqv!I$ν~. 38/:.xE \ ..%qi/pe|+p"\]T59\[ނ~an(čܔM;ps7߂f??-xq/9ނ=gix ]1ZW59=^߃7<[r5;s~}ep ,Gxl8ol7ۂxSM[Z-x[u3w{3x4>>> >>'|"|z>ggrq||||=o\oƷF{;q?鍟.ϛGMmߞ1?ǟ/YKe%*oo?gxb,Sxz4f q3(MIEDob_%DD߉R9h;DD D5D{YR D/j[O5V5=D-D݋zDӈ D%DwANLMnNE-O}hO84| eѵ2ѭ<ѽqDDkwKCn!_# 1f41bĤSSibz1#E*O~0EXԜX$䈥O!V$UU \K=@La):-ACKGu(VuOzD=A'Pߖ_O?AgAuѐ GG#(\ Q9hLO46^@㗠 uѤh2h4 Ma4s3Y@ڢcЂ#h /Z\-A*kЊh ZO?AcЖ9hkG ھ SAtp:6EǖѩLbt-]̊.՞ts3 {Ѓ#IG(z=^F/WMЛz+ zF&O5eDccO`?^?-G hq8f^.qjAw '̊7pҔ8i#?jqʲ8U|/Ns/L5q8k^-Ιsoao. YqX|\<%}q鎸L˧⊑qrWտa\)mq f=qȸPw on7닛-.Vq뎸MG./n?w̉;].Cq{w?{,=^ܫ%}jeqK<<ڃCaM7xΉ.s_}p5[RAhb+gtf&T$L>s5Ϸz_&&d[K%jX2m7D;j4ҲlH  @ @@@@@'@@@'@@> AGf~ #>ILV^acxzAGe} #>HLV^`cuz}{zq`_\?:-& , R `*2<Bbb  T " , t * Z n8 '.5!!!"13!1276514'&#'17''3171'#17`@ @  ZZZZZZ&ZZZZ&ZZZZ @  z L: :)6711671167&'&'327&'&767''66RR66''  $$$$3!87;;-R6666R-;;78! s  a "1311#151&'&1176751311#11327716'&'#151311771654''1&1#15131676'' @  `@ @`  @ @  `@ @`  @ @` @ @  `@ @`  @ @  `@;3#31''11''1&771'1&767#3#&'516761716111X 'W W'  'W W'  'W W'  'W W' 96111#1&'51676173#31''11''1&771'1&767 W'  'W 'W W'  W'  'W 'W W' +&#"1311#11327716'&'#15131676'' h 88 h h 88 hp    pp    p<D+%654''1&1#151&'&117675131177p    pp    p h 88 h h 88 h 7Mdz2111!12#!1&'&'147632111#"'&551476375#"'&551476322111#"'&551476375#"'&55147632   p"      @        "P @ @ @   ` ` `  'U'1#"'&551#1"'&5514763315147632'#3#"13312##1&'&'16767312#z{{{ {     @@@ @ @))@ V{{{  { > @ >   ))  S11327711767514'&##111!16767514'&#"1!1&'1673127654'&##` * ) ""@"  p p) *  """p p@  'U'1#"'&551#1"'&55147633151476323#3276514'&##1"'&54763311#1"'&54763{{{ {     @@@ @ @))@ V{{{  { > @ >   ))  2$7531513171#1514763251&'&#&1#113PtWi' BBb"&Y+aK\w7'11176771677167514''1&##1"''1&'&7716176''1&7716''1"#&'11165!671167632#"'&'&': : +"  G55 0!"<=CC=<"!!"<=CC=<"! ('      ((@?8-  2F::$""$::FF::$""$::F"+E#3#5131%111!1676751&'&'!5!151!%111!1676751&'&'!p    `p    ` ` @  @  @ @  @  Y#3#177111'1&131676''17111316751&'&1'171176751&'#111'1716'&'Ȑ (OO(  (OO(  (OO(  (OO(  (OO(  (OO(  (OO(  (OO(   :Cc7113277171654''1'1&#"1113271654''1&#"7'171113277171654''1'1&#"1113277171654''1'1&#"1&&&&&&#}#iiii#8998`8998&&&&#}#8iiii"99889988@#-7A\w111!167671&'&'!#3#51'55316711671#7&'11&'31471167632#"'&'&571#13367&'#151&'#1@@@@@@@@@@@L@@@@@@@00D-J]p7671167632#"'&'&'%4'11&#"32765671167&'716'&1"1"14'11&#"327652711654'&#"3%4'11&#"32765!"<=CC=<"!!"<=CC=<"!   @ @P   P  `   F::$""$::FF::$""$::F          !C!!!5167611'&'51!1"'&54763211#!11''1&5477161! @@` `  ` `@`@ ` `@   @ ` `@,5671167!11!1&'&'4'11&#"32765!!!1!1@   @@  @p,5671167311#1&'&'4'11&#"32765#3#131   P  @+';&'1111771176''1716'&''1'1111'1&#6D o o D5 vVi   n II n 22l U x8767116727676'&'&'1#11!1676751&'&'#15"  "",=)(@0"   %()=00c.6''1&#"1311##1"13316767513167^   X P P6%$X      $%6 c.%1#"''1&76731514'&##1"'&551476331131^   X P P6%$Xq     $%69111!1&'&'16767!"11132771176551&'#@ (G$G( @ (G$G( @P471163332##1312##11''1&767312767#1"'&5476331&'&###"'&5 @ 8# # !!.  P   @     ,g     ''Nqx#"''1&76761147632171676471163311312##1&'&771#1"'&511'&''1#11'&'&77171673#3'1  X    X  J3  J3 ` @ X @ ((( `  $. $  ` I  I     ((@'=Si#"''1&767611476321716763#32##1"'&547633#32##1"'&547633#32##1"'&547633#32##1"'&54763  X    X    ``` `      `  $. $  `         @'=Si#"''1&76761147632171676"'11&54763312##5"'11&54763312##5"'11&54763312##5"'11&54763312##  X    X     ` `     `  $. $  `         '(Sf27716'&'&114'&#"1'1&'&13%&17711#1"33327654'&##1514''611'&'&76777677165&'&' X    X #0   00  !    1%% `  $. $  `  4   `   q  B$%% D"71327716'&'#114'&##1"1#1   H @ Hq    C"6''1&#"1311331276513167>   H @ H      c"7''1&5477161!121#!11      "   H @ Hc"%771654''1&1!1"13!11O    "   H @ Hb211171611716113167675167631#1"'&5511'&'&76771511'&'&76771514763` w  w  @4$$  66N`   )  )  #" '" '""5  N33     6 0=JW67311312#!1"'&54763317!!!1!1&'&'16751&'316751&'316751&' x `  `g```   n@@ 3'71#731'#3!17%3#3'1#"'1&771633121WWWXHHH92I8  p p x]]]]MMMM}0MM( >Qdw%6711671167&'&'&'#0110101010101010101367673'211#"'&547633211#"'&547634711632#"'&5H9:"""":9HH9:""/ ,&#08    `   //::////:E4%        %M+"%2T" , M 4k J  Vi J d D% X . :1 FontAwesomev4Compatibility-RegularFont Awesome v4 Compatibility Regular-6.7.1RegularVersion 775.01171875 (Font Awesome version: 6.7.1)Font Awesome v4 CompatibilityCopyright (c) Font Awesomehttps://fontawesome.comFont Awesome v4 Compatibility RegularThe web's most popular icon set and toolkit.FontAwesomev4Compatibility-RegularFont Awesome v4 Compatibility Regular-6.7.1RegularVersion 775.01171875 (Font Awesome version: 6.7.1)Font Awesome v4 CompatibilityCopyright (c) Font Awesomehttps://fontawesome.comFont Awesome v4 Compatibility RegularThe web's most popular icon set and toolkit.'      !"#$%&' location-dotup-down-left-right"up-right-and-down-left-from-center down-left-and-up-right-to-centerup-down left-right chart-columnright-from-bracketup-right-from-squareright-to-bracket facebook-fearth-americas bars-progressmaximizewand-magic-sparkles money-bill-1 gauge-high right-lefttablet-screen-buttonmobile-screen-buttonstar-half-strokeunlockturn-up turn-downsquare-up-rightindian-rupee-signarrow-down-z-aarrow-down-short-widearrow-down-wide-shortarrow-down-9-1 down-longup-long left-long right-longturkish-lira-sign trash-cangem comment-dotsrclone-v1.71.0/docs/static/fontawesome/webfonts/fa-v4compatibility.woff2000066400000000000000000000112641505210326400263230ustar00rootroot00000000000000wOF2 'j6$ `ʿP} Up~?=hdyD&$+$Rt=\(s-o .@.q *H%%\SY9LKi}IAhJwԶ*ZrJ?aw2Po^KvL%XHRQaT;0;͛I9[Mb$ י ;߰4R@^˸~R@}#~"Rԏԏ(E]?H%e@(~{Pnoq*^7Rxw$ @Qxh#{~Z1<*AkX5T #e}6[)9T ERP wE8uXue?l)PW]7@u8!4axi|5׏Gw?2S㟏;?xo\ԍk7x[7wsu 0>2^8~Qvoo< IDgBlݢ(YvY([ 53&=?i߿*,bbd [n.$GxSXe"Bw8A}F4eD"by e_B&D#5*23!Q0Bpg )a?_t]>;?c34NKhBH"5!dR$FƉ,88!ˀhOF@ALqqBNٟFㄌX*ִ8X8V#[r-!"3A`Xv-?hTowRdXv/WN'&0[ Xь[-%5<3+-VhUcBr#5!K8s)ߑ<H&"\ȳehqO$~LrνyBF)Z8NrH) +Y06{"(e',LdX[[l0! ÀQ:X__ 9[W ljOtXTp:S斉,VVVZ1`Ǣ_JY1"vsi𚕕mV `10 JY E2J۝Cvb+\ e%}"1gA$qjDJ82=H$GS>%lۇ(5msMxS%S BYZh99<\\5q_vxgy.K})€WvB&"u%dyLً55D*8Y? ?<_H>Ji{r_WABJI]!:Gd#jiF3̲lf4Tum89ej֜Jށǎ<Ћށǎ<Ћmnuu&:UI&;Mbӆ$͖ٲt8;[^iV{iꌝot7oy7Mw4q!Ѓp4԰&"}?}/Z6bup-Yj@w pm)Yj= ð%TX:/NNphO\52(鮄ȓ (W< D"Γ^v٬ɔٖc׊h5툔Ka h$@BIH`|);0AI#$' )ZɔH4$IT5a*,竌ŬYKKzĭU~C^B'O QդZ<ϊX^ŌU/6Up 8Ia'pDiYNB^Ek>JWkЋ0 r8}(eX; ؑtl"~NwΗ~e; D&B8Jƹ1#ERSi_i*SwMz񠯶}[U ?Fl+wQJ.PsX#x]:~w|b,#>0?y-q̽[6_dҴʼn9w&;9s P%\r4B01!PU-lHfɉx7e+pnNMa[e&%'i*GƄr2ICkM)K}kY؁,!033SRm6/6hzr2\o("LF~&>cETC9:Hx:7ٔ)iSA;pWG>i/~&)9L;K{" v}7((ɆmƂ5ߢ/ɐC'uMUe`ӜϏSl!G1f(eق{4sfO̙Dla lõ*,5U)o5T)ιPk̙=R. w#ZI! {?8p[t薚Y:Q^8 o}D+;k:[݈H5a&mՈsRc[h#Ϟ=A9 h C-̅tk&q͝8hjkd-E?5J#u=Ky/tݾ!BwJ&wlnùKc؅s~KtLm[XjwR:=d n:fW8wb:kޑݗMYYX=[%TFW ɢX xѳT0?:qagX++*147'lj I÷@/VRO)!_kJ)с^e>7w^0X{LϤb~T%R={}kמ^2+O^7L̲د`_E:tM6m6@h0y<! Gp9 tQBZt(֑wz^n/ T̻(}CKJ4Q:]Z6sZ`1XL3fvC0͞˕JܜtgUgTL-%sp}ߎ{IP^gؓjB=SҖko#LeomƈWN~'L7[Dd/7;up )r@`=2 f11,*a0:1R{Lsq&@z a=1 İ^Ω G+{e-dcG&¾$ڷ"l\4Qd\#j3O$V Da5a$1HFzl.@M8*1`R.q> <*Pj8"\Yj1"@^8m PЄIh6G8aagV&T+$"qnT1&je'@!d< ND rclone-v1.71.0/docs/static/img/logo_on_light__horizontal_color.svg000066400000000000000000000127601505210326400254210ustar00rootroot00000000000000 rclone-v1.71.0/docs/static/img/ncw-bitcoin-address.png000066400000000000000000000021141505210326400226040ustar00rootroot00000000000000PNG  IHDRg3 pHYs  tIME !K?IDATxaj0 Qe`]pٙ5_ }=uyVv^ b-wDŽ3ϒ1V=0 b{/͛aw̻;>4ީ}bX@, {g~2vpbX@,ow}ZY@,X@,  ̰=:2BȷYV b='80Y}`ŔbX@,p{/xGr.界 b)(=|z K;|Z}}v@[Y@,  DbbS{8ȣgea  (Lخӣǵջr;=hbX@, NE4:_xʨzYΝgeX@,  ܣ|ʔwNşpsZYmb=N#ت䨾N)gG[Ymb=_ĔC)Np1 X@,  ">K߯z'Jϲ9,6 bX,C3i49;=o3v@[Ymb=ݮFc)'wbX@,p]ǝf8 jl1 X@,X/RA{տr&uVpbX@,p'"=6:=}twbX@, Gc/љ3N8:,6 bX ;SW#ʔeʮq+ X@,  "]puu'<ίwUu n@,  w'w?Kl]Sv,6 bXisNm+ bX F+`Ly]XZ(bX@, qe|YY@,  X]aʘO+ X@, DIENDB`rclone-v1.71.0/docs/static/img/nick.svg000066400000000000000000000223741505210326400177160ustar00rootroot00000000000000 image/svg+xml rclone-v1.71.0/docs/static/img/rclone-1200x630.png000066400000000000000000001072271505210326400212430ustar00rootroot00000000000000PNG  IHDRvO@{\bKGD pHYs.#.#x?vtIME 3/zUF IDATxyw}OUO7Zmy1Ƙ06u !BB!M&;ssL<$/C 1WMlknާ^C2%zթyd;UO߲ ʦ0F`hX0F`hX0F`hX0F`hX0F`hX0F`hX0F`h1JJ*RTt|He?H^-,K-m)nYYRc)i GJ:R1KEfbAPEA e@@rp>_"Rv,-'lG"#(((,-NP5[阥渥Ƥ-n-!Xj@_@#@y:=%$,%m$ @#Uj0kҍ2DZ$ô@!H@`%5i3e0 T MHcœU =IIKӎklº!aQp||Hfűe)[+Ҷ$Y \т@):5X)h[Z]gkiʑCB  #_Y|YyuK;JŘERe}D-%-MZW>A \`@_GhZ,(@::Д'^(h&[Ҫ:[k%,x3)GU(,i]Uuȱb  fhϸˏ0J9679L,(,0<_:8H [QMv,0)9vjXFG9" חN:2S*% "snkǘU$8QWn,0?धCň-1,0'r@;]HK1B09̟2ȜvdCl)s @)O2jOZ%ƖBpY)y' XJR[cjHbGf-S ̨<{Qǒ.mX,`Y+zvU٧ 60 X X>U *2]t툨oCU'P߁'_Ubh@K̀`P%]PUb* lmɱNu/_*Aɗz;jYsQW>n5n!i)e[YJ:ʻRk(S4*9Λ#O 2C}ҲZ[- K [XXJ:RSS@Rhkk8wJtjm  f2^-@`"S@yW먱uIK7r^- X3f!D@0ړ.m%zU 6b`!ˆ 0=|31K#mt68J{b]+Bp,֘fN˒taKL- :bpa@H.m.N0=K5z 5 %  t:GlXұtQ^2ToDKc5V[Uu,$K2a*.*_I.lvxYS ~,]a[jN|9[-me+$66r,oq3[˘,B !0Va{c#˜X( ^a2Õ@9/ 1KK3@wIS r 4XC64:=>;r"^ Cv]R;Ws.XZv]'  V.5uh祣F1,B MExtܖET%,cPC-((KRc)H)R9/nIX^>;fIuB\%5,-K#%lK4ؿ DsHԔT8VQL]"ԇYM)R[RsRSV] W" v}M 0әFAmiIV{VKRM -]|X3blXjL̬œ+F_&ɶ,clujL5!X40kJ8h\{L5ThXI,LGe --5JeWBYBIbY'U,]<sJ&bl .iL`xXDd&ɜƧxN}#dAٲ_O&uy38Q#yIo!y) d74C'q dˑ7~QoWp}iCz@`PE򅒎OwhR{C/z攧eK{m 0  Ă ЉiҶu9/ݽKmXt*I1N.=4X!S*:p?^<2ElY>_~+ŐR_.V] 0  \WQm{\?zG#y=rXod:"_y_Wu} 0ر1=G?yWcBRzN{,i)f` X&W(iס=rd̓;wCڲnitrbt%l) ,B C f3mG_CX4xUs `Ӄ-ORPV?D};g:Aic+‚ EԿ=W KW>]>> @Xtٶ X,X,ýú=z(0X՝Շo$2wf٦Z_a֡IW?-ꦥ ]ԞC бaCW&ݺUl*aWYOc@+CecyBZh`#dV_W#2Ao7GU,qȄ/ ,ITOԿܿ_E/ {nׯK6uU9vOHRKMeS Mը%߅OXuHھW_kM)H|ҺN%չD+JRKi$=Cɞxڹ;,K:` t_Y«?OsiߤEW ˼~ʁ; n,zbG>tێ$ľt>Oed<*IjOڪtYR=_ߗ]y\j \"O돞d˖}:p{%Ϋ|ijXb0G8ӧn~X:Q?:gwI{&N^sNw}}vwN %,fWաňE =MپrmοʹesH+꧇*2Y#9="l"<cw}iW/WTl`Ml՗d50Xɬ>_ۿ>J1"tP=jemK}7ۮt`P), o<'z&)FD@߿Ps;CzjXe/}9Cїz'\*@iҟ}]A?{qHBs&=_R{RMSōtǑ<.gD գ_kȜ^a$k@j]Nş9.jTfE^ͭ,18m;>F?LZ̒Tqw OٟS70#,N @=Sg/dR;)C+km9z']{>!A$oء/=tbFu0J^fϜX7־rX >X2\}}`^e ]Xya_iK7ylG3t:[vW#9O; iO?;RPD RF>K!PtO';`$l+]yՓCP-pDщ[)6TUFہIO4_l]#UnQ74vPY/!DB._g2ZjqLut6;J8w_=W[~xI+D*wjv(f>ol5^&I]Ҋʻ==6VsI?.%T!,@W9B!0k~57;.חN"Ȯ*tO_o;Z7`B; )<"fQc-URvhY";J:e+!`) YM*yl5f1)2,I+:X群PE74O!0kׯo ˍ=ukm+O,D)Zi]#l%T,@*3go*2iumXwM|= '%\XP{dP8H!0kf:?NǚvjQ|+z#6zM Xr=_߸{'k6x;km&j[JWO{z|,oqDYy ZOs YwlVC]Mhג)붥Q;>@g T(P%i]}wCttnRZj*?#%w?M sG?]OspΔZ(%mU IDAT^|=@ a/Pڻthڥ=c t_vErEy=R@h`BW`+NܶӞ&zLvLLS38%oZxf«[Zѕsv5M1i]X׳gn5@8m^f_[ֶ ~V- 68 c3cI6lJ-ᆔkgܙliG0ٳ(iܴCUW$[ fCcC=,ݴFו8ނG!#oT}\BoTM򴣦u,~W.MV%eq{h(#k>oZrZ-MYd>nř<=qӱ}^ *sr ˶%5%m-OkKZX㼰-?ZEj'Jsl# ` dro]ע29t^lY67{Q{BXLW;40wXEx7t5?J&bYZWoVUi[I޸,7r/`F0{() G+kQ6-kXp͒U5ڔf)9_O![`\Q^z Ys,iSy]X%9Xٖ~o]J^җa\Ns0E8oZ68k6{X@[[ K0'mPscX@Ӆ՝% `c>椣7]Xc.|~0(DO~|ku>/ r `Lbd?uekE! "ޅu ` ,1Ǧ#}z5"{cG1-㢦ʑ< ,a3 Sټ~4;ڸ`0\2*}Ӿ8!!.`,&3ȞڸP tGcK0"1! `Rs?oi 7zxQDn'K\H:6Es0X# ZuՊFksd4'̾~>Xxbh.'Jܣ`0scy7t_K"` `L.۪s WۧPz\.ZDs a# `XKZs;zגry|`,2hjkJss'J \_/3tIRS_E`P.9ʕq&X#|U

    nEy!$X#^$;#:'_ 5E3C0%7zoL8rlV NJ #/^LV j!V{] s::thE5 `*gUֵt{oنV:nGAF0i:nӃ% x1@(G0B"ɒ'5_)k:;4]0KIAFHƣ6KX1[UҲ}} t7M)[;6 X3h~%.O{zdk*N_- b<) x,=5]W(zQ{ $ )iIс0HD_ݣe훎F7kCM/*E0Lu,F`B0Bcm"=46ů@ t{fCGb˔9.pf!.VH_m% =9X/|4W`Pfu$uL| 箁&r1e9P 0B:֓&es&UNr =9f@0X#&#y~ qFϔmnk1Wa@BX' `Ȟnt1$鎞|/n# `tJvD7 0K~yy_;GjOD1c,|386#yz'5>&x~ioIy63c <&7k"{; 2/j@OgKBz,It` 7ґ=> pJ t2'e[,KZrxJ&1:"{ۏg78M )X=N!f b~GG.`Xrg/7)o^T[f#.0F{K];Q&Kw$b޳l7IcIYq{Q2}KXRs X`ay'vF8eUcLW5( HB̡xڴ-s`%5}q3Ixуe e= 1@y/ݏk0(]͑dpJS0}&{ b3Z<[2W`D0JmMB/|~O8e iÚgJx.rn辒$-# `7A$}*&II{~:5Q{l}q6IKuqf `+[)Ƀ/RSƵLJtт`fohYOBҖ^0@q֮h|n=BH,Pؑfc=%>08޼]'2B:G׶%r:?+D(n=הGߚ$YVҁ0HWo=}O+_,S I+$+s< fK9Xq5_n[菉'Uv^ nӘr("ES.hb lX#u-itB̽{;3"s${*b~_`8s *>ۧ? DܶIn35*bΑ]ҙVKlXc]q9EW99^;6ĵ3yqӭ W.JUq0XZUϬm=mOTV&y~;2n9W΍nt}ovNcc #ql2m;s{\|15H;z[^iO_ڝp.Z/|龞wMp` F|cR"[k'ЇzK>7CHosʼn2 l XjՅK G7J>?S1K^VJ}ˇ z(ׯ{?۝i:65,_T]B?Ot޲vIGBS,k*H@I7i0[]O H_Q/2^QS 7<P.ܥJ/ܯǞ;,/o) 2ے޵" 0 =_7_n)W+ sy+re;Wp>|2LLĕhŨ@=C:|dP5>s860/Y5lkgklg=鼩T iOѲZRe_+%crqK=/%6 + @8:O|,%7ʥ-Ȕ~~}^I֔+lx++YY_kIl0T%=4\,wiBvѵ,@(Az?C1һt}oި5+ڌ;cs_޹Y7qcYt o;km]ۙb==srYŞ[mM14@x`B]=[SsUx25.q %ׯѶ~>_z57TvE7gwf5NqΚE]wpI{:W״צ( TQv=}Pdbے޹ehv1=\Q~ݵsP +'﹢ᒾ}d.Iٺ%M1:˕˸:8jۘ<՜/kՙv( Tw`K{޼SWkY{ksξ}O502Fzgk=YȑżV-K;jM~prh].nlw:XP?BE^76lK^/kЊ:եJ&$J&GAz*sEML42WȴT51 ,@}}"> Wo?ףc.tr8eQ @@ujKAE7߽KB_")^$ XB6П"Mu>a]KwAUl |Z-M)DA f*$$A m rFT2OݰBDP+eܱI ȺъzF/YKS =T׷uaCW; P9>~"r r=Z޹ֈu^Kx ?,@m^TI!"hഞ];Ҏn`nޱt_ >xDtX߲<8 JŸՁ zm ?޶BDЉ\Y?loşO,{#֦l]Ճ Pnx]QGhojbX]#+@}zO A~ r.AP-I]I[oZƽ >XޢMm"x% ]PG %wW'g `J&+K DA>}KX J31 J,UgV7RI[\v+޼{PUoܨk4S?!+ V3]+-ޚb*9+RC05գQWeC+ja/,MZmuBDgܥLşO:>FqX2׶ƴ=A!U Pն[aw>'o[ >"kSn:B" Pnf޽e Gf3t$tm+NaƘ?8?C Uϱm}}kK{-ň޵KCwJ:XQ#s· ҵI?x:q!yg r?ץ$Ag InS-XhUJ/vgqK>4۳`u< RtR 1<ի{zg3)GquKL׭`h; X"-+7m>Y̚x5޳FM"Dۯިtz !esYܖ>"Ih֤l}h]Jq ]Xz[S׮w$<ߟ]љ1w +icRJF,˲oGZI1"'G޴V83x9)e]턑1Vpw}BSY}GU'Q V:JoRD@Az Q(EU:JQET`EDz1.-t!u*j$sfz>x:w~93s?9ZSxouf`GB.hʶJ[2G)}3՗)LNB ǡM>DI)$#Y_o+o/t{#:Y?~V!w E³) Xƺú0dJѫ#; ދOժqO+񇸤NAz6Ѓdwߛkb5kadר."V\E\fy8KJxT7@P i)9tdիkeq”T_$ pVp)OB2H# Xá/OT;ru+cwF&iݥGJ:>1Ţ]WidCrwRϒ^ A2pM򣢓Xۑza IDATiz*V8_$?QwU"pA2[Ct]4om,R 0!U.?ɇ<]>7'u-]IV@ +HMMՑW4r@N+ JņH:s'Q&2AzʋYWX ,vF \|ת [}-ucm,GQImxl^7Q,B\u#&ةBnixn&Ijn%^:I v\u@V@ykJH֞x:6yZޞrTBn%JH%ZT>/g@@M{~n õ(W@>3#6ɢ73LVA<.@6@69w6+T߅'WFE.G?$*QpT,]*nĤhekyܜ|!wU p3+,l bõ_tZ fVprZ.H..]ta'C Y-I n, Q,®ɉ$$5+_-)eݎMѡۉ:,zZAju `s0͈ױp*Z,5J(C\ÄTNwwM_]T+]\Ą+A %D5m;|I'£IHnK٧!1)ŢuNΰNV8~~WU pWO[`" Xb{m D '^g+DP~|L0ƥTdE&^?]T%JHHL+:zCNTtŬpsvRjT**$w7Tt=:Y?K֑{z#禧)E+,̣$ u7>9Y-*Գ BBNxTZtG%dE$漟}.NRe_#JσGGc))~~7{U}U|!=]2@ 32n\ IQ ,]UE\L+,HL\߾t*_Tg'֓UD~-_E#?/؊S-k1)0EgbRj򄇓|\eKJNѭ;uC]s7`ZnΪ[e h!)[ÝV)";)k1):hrTY%|Es9@.y1 G bAtE^T>qv7FawbtAY"ys)0 Υ|[ysř3MaB$^B>JUdEhuqR;)y8+r{8Iȉ(`jQB=JR|B%)1)E||pvr\]*wWy)ryŅzlQ|E-JJ(9UzbQq],8IΒrQG Fϡ0,F FQ(`h`4 X0,F FQ(`h`4 X0,F FQ(`h`4 X0,F FQ(`h`4 X0,F FQ(`h`4 X0,F FQ(`h`4 X0,F FQ(`h`4 X0,F FQ(`h`4 X0,F FQ(`h`4 X0,F FQ(`h`4 X0+)XEEE)**JъULL>|GI└$I}W>>>|'???y{{`FNIIbÇ%INNN$O>>>Q\;wnG...$d) XC=x@y._3?'e˗W:uT\9(QBA +`A"IJJҭ[t-]vM.\Љ~g7gY\J,… +00P bXHx/_VN"rvv\\\&777nBbQxxΟ?Pmߺ՘||}ܷjԨҥKxʟ?O2fsX]xQϟǵef] y\e˗WTre)SFŋ ׃rRI *%cEH獹+F"'?X"#"HMJ**VxB P޼yyɉ$&>>^N8>L{ʮo߹Zj+TRvuW_^FEOjj\3ghwivw0@kO?… ;v݋/f9,QBNAAA4gyF'CBlr_%JXb4۷Ix@۳Gy߸??TxqLJ@||Μ9N Wv{-~>n\r@0MՎvw 9morǎjߡWERfW4׵L X2m޽ڿw>EV:bEaaao5\ uFIJ)QcS%Cw=5khۖ-ummۺ\wW׮]UfMɓ&>HOW1cY 03)V/_m۪D"ѣnݪv<D շO+UJw]|XIII$&>|m۶YӦz~}_6իլQ#5oL;vÇ [ڿ*hʛoDGk˜1P G*99Αźu0P,Xke˖ھ}IJEGGkmjܨ:mOR~ulڲebccI FRR߯v/& hu$EʥKUfMuY類"#"񊉉!cQ`Q6mTfMmٲE$O$$$hǎW:m'N?q9uQ7oݻw3FKNN楗ԤAڹ<[դAuM!!!JMM%)Ys_(`ֱڷk_bԩSޭڽBO&)itAj\={ԩS$駟4p@5i@{g73hرp S'MҮ]HHaW_I9bn޼^{M5*W[ Fzt}{Mj+իIH,;WK%KX. tIgϞ%㸒 zb&Ullu-]|YޭlXj%믵t2=srvYudٳG pvm-[^zloF#sH2D7nԌ3UV}Ub5z(mܴI$` XTVM:tpkLMMU\\tm+,,LCB飏zaaj٬&Fy~w}W,ZĠ'CBԤAMy] 2D~~~$6gΘ%  +;zխzK#FPڴI9gLn]+ÇY&_WJ2RSSw^ի[U{wdغ?N2d)ھ};sOJ d*UN;ky玾ܳGCF{kZ~']||̙k,loխYS۷mc-dM>]?lpAծQCVTbb" 4 A ϟ_M4ܹsv>XZ%˔ U:utSDDF cilQ`Vm5c őX͵kԯo_M~ aט1ctaÆUdd$,Y*((H{V?/PŪU3>1j\<y UVv :=qF .СC[>ۼdmM fLd) XZloӆ͛iݢN:e7Ft2$auVgv@X,}jX;UL?{6l@"6E @Ut4$DCGJ1޵۷mSڵAg07v}v:w@$%%i…$01ziS}gX,$$꥓'OP` ҬY// ]Ǟ 1ck7kXC۶4Nsĉ$i3gj$`۵Ӻuش!۷oMP`3jѢ8gIױ۷nՊ+/E7nT.]ht;~4lcG[qqqz뭷47Iл>X2}tUTiP;4|h 4H|Ejɒ%1u*p_ x&Nx:`@-^$]l޼٘]^|fh߹&<<QHyE ;vDduj*P`(`0ҳ>Kgģ QQQf轢k׮ĉڲy9b9[ZZjEg-^ƍ'''' P&MHD:oP`훦$}sgbccڄ v/}bŊ*RUf( @P5kQG+,,LN?oקlk_rZ {nUo *WUD 5h@Ç׍?D׭ۜWQƫrj֬j֪ 6VXWZ5X1M}otݿ?[[vڱîr/ @3fVȏ?j˧_TbŲ+WN;wֆu6,LKWԓ%J$M`f ౮^>z]7G6)5-YDM4Q…Vz=YoBkٰ֬0XVUpfcdD&MxA衋/Q`=zҥK ڵs͛ XBU2}M .o߾];>ܱܽN ctssS mwߩ~V?G`BɓAǺy^88}|}fz}'jРQO!k_hvfΘdE/Ij(` ջw^}V=|0K נh&C=Sv׶۵xr͛UhQbh?:o 8}ZݺuۯΜ=.=z˵o>F&w_~DQr46222Kcp:DGHH:u,lo_BCվsL;vB $?93g`+Vn\LXRc|S֛.&:ZCֽ{H (`i~,Aq9kidf)[!ڽ\rZf>ڴI>z>fD{dwߩ[nz!!i~<9m۶1@2}9s&c2ó$Ţe˖sٳZ<==թsg:vL 6Mױϟ3[}yܱۿ_wW^]_ޭmcuI&̝5KQ`7ҳ$_~E52?ϟaÆaSO=O?T~;M>z(gg5s #ck߹/Y… ;l-+W.VdD[ǎ:ud 4?B%1[ܼ????7еzm] g޽:`b=ђKnF͛W .T1ca`!{.d,vI*VLkcuY͝5˸^@C ūpqqKmɓ*[{݆ 5w\fp,qqqzg4տܹ͛s瘶׬3;v0`2XQ IDAT<]k!:t萎9bTL7;３# ~~~1skbMy,{<='`"mܸDҍ]й{f6KEzkҤ\PP֬YCJlݪҥK3XRRRr bzD XR ȱ;wn͛?_86_3p`@:~8 ,v% Z{·~,ՕQ%˔E; ; o<9sg!!HӧOএ?Vs|)RDk֮5.ysWn"4s^cs&%%i%Faz'%W\^:@}7dE|5j0R6V`ZZkV&4nĦcgAkڵk19([Fcm뫩Ӧˋ777M0AAA4u$EFF8V2bAAA;oYi^kڵk XWKy5#}VYt EFDUCط9U8mߺq)T\و8_f#dѢZjָQquze?uJ+VہhܾDJK\90҇~]G!777۔AJ(AGFQdIJx UZq\0dDkjب,]j\\ÆUdd$r( Xs! I4Nݻ[m)7AA*\0pq/ qmE...j6S^z)o_b:1},H XrY#]L8Q{"Ν;6CnNh\-Ê0k]Lٳa:?@ҥKԱc+V詧jnݲy.*UDl\W1d&Gb#vjʕտW/Pu͒t64VhĸΝ;7ʕ+gb|3-^l\\ӑ#GP{nխSG I/Wnݲ,x#Igh\a 0Poǵ;8X7n`0 [X,jjռyv O>rvκ$lYz@Nc¸~B999Y+W.X6رL`TLϝĉ# kp K3f*WV|z,,֞,Z8ظd,cŒդoWWW?^76*iժUX, p R +ȑ#Z|mْէ۶q6P6F@@pq/~"QJNQ9ϓ',\*aOA p@`5qqq ѬYT\9дiWGx%I6c. \^^4D1 XT|y}uqq]/_f`b KLLԵkt9hՊ ~*ִi2dHe5;Lь,c#c9'u6m):i11_k͚5fo)66Vy._Пֶm2_)_,\zӄ޽Kl\ߋ! wر5b W;v׶-[Tzu7Prwѓ$E+::-矷h:w颼y,YH|Z\rA8ظy& ElCN-`IfϙSLt1qꫪR6m A -7jƍ$"!CTRJ:T#fq}2$qE=zdrrKJ* |^xzvdɒ p`3c&LPȏ?jΜ9F$ݝ2x2Cq5lOo͛kF#F(**l ܥK>}*Ud^Əmh,pJd/76|wlT\vԼy؍R ; :T_٣ghذa*Vqz͚6޽{tJ\]]UF BY3gl\ri 2*w~[_~% v,3jxk]yS .T&Mo|eʖy wܡVSO<ʒ·GShQYθu/BcwVӣOկ__˗WٲegaboݢCNewǙԨQ#?ƎaLL12x>ݺզ2t R֭UR%-ZTEU"E/A\7lpݗԦCm۲Ŧq,^PÆ G`jӮ֯]k8͝_]Q2Fa>7#Gt2$Ę>XHժUS^h$+ΕKO>$`U V>s=}ژ5*TH )8ڵɠx͝3LjXJ.M^}Uoܘd҅?(Z}an>OOO׈X֭]+BpܽG#by{$EEE(pĐ+V"'O_D҅jب.[c>XHWvԭWψ8֯]s)+xg#u8pIT]ƈXzՕ 3B $f`0 ] 4HdqS|͛7!+xꩧe+..FISNi!W^ɤ6mh›o@P<==5eTUQ#]C׮]/R6lhD,S'Mٳg@&{^Fr`>ܹFId͛;׈X||}UB%\\\4vXhݚd,{hts5,LƎUlllL</Vjj*Ȥ/lL,cG֝;wh4ؿ1F# %D ߪQ֬_c>ۼYK,˳>kL,.ԩS@&UZ՘X¯_ƍiiSs=GXQҥ~&KIN4f„t3qx޽ۮTR^1L:UtH  .lc4nHc:oRJ4=ߢ.) XUǏWæMu\׎nM6&Mȴ.]ϘѣE<ƙ3g4woc;~|y7%6|wL2 *O}-}iқo*&&;7oԒŋ@25W8X,Z|vScTL's׬[G"@ @jJoN;k>nݻ[{mQ0+={V۵ȡC5sL%&&-[S6mO?8}&cTL\\\h,֨Q#?> X#Fu\ߞ=u 5k$M2~u5kDǏ$M{-X[eʔQA)&:Z{ҍ7rtۜ8qBڶ5**5jVZ lG>$CIYҽNŀu-^OOO9Ҹ>CŢ;v~Z ~I{)))?I6.'NhԨQ~l0uƍ'///N6~N:Ue˗'IdBѢE}c6qD>sF-/lGy݋/k&f>E,Ua3}$iۖ-2x"##sT{\xQ]:wհ0*Y6kƀfO<-_N"(`ȤFiҥ:իzjm+εCLtZ4mc9#Fѣ^]f͢rssQӏ?ր#ԱNiπ:uhɊ$@ @KO1w}gwK/׸b|Ӧ:|SNuVZoy=VZjc#kշO]v͡zU+6p+Y ٳ^6D@G @yzzj*_bҩ {L(P@12h5][n٢Tg Z~jTǏ)b\]]5: leΝj֤I#IMMՎ;TR%]]lߺUsQJJ\gܹ\ 뿽=qbw3~/11Q[lQʕ飏ƌѢE(b9;k+g޽5n8]ݮܹs0`&ct^{M CT^=ݿ3{;{;o/v찫lּhat׮Uʕyf%&&U~-~C:vTg5JK,)^ҥǹx<ըVM[nU+We Wp@ Uio~:C۶:}\Lb|1ީ^8PgΜ/^ƩVl,;#tRXzN㌌Pշo_XHUVU޽ϯKIv6Nw'OVæM+v*TP;99Y.\бcǴx" y>F ,ggg_Hpqq_Y#GoуV-[U˖%4zh5jXKkKHHпoڵKsgVdD_ϖ|!ڶmWxC3d64 sve5l0pvc6>}T\9լY.^z.ԙbߞ=ڷg$Mjݺ*U%K*HJJ۷~A[6o#GŰW^cERŊg/CjaqΓ'͟Zvհ0:Tez5jlٲ JONNuY=zT[v>A;qS6qt7oԗ;w xeK Xfϙ!! OǶｃod5:99iڷoo {mm1^jN5yF%JPPP)OOOyxx GXEGG+""B7nPhh|ܿԻwo̩VXv_97&LK)?*H"*TvrrRjjDDG+-]rE?ve6w"ձqe IDAT~>X;6Z H w[ +VLk֭=c.;chV rέEfz֭ھuk믃,vXȼ`jܹsMϝ7si;>}렝*ڻנO(iC;EPPzBe `EtJ۸񆫋QTb$1tƀ`KxgQQ$*j1h!f n*c(*SeRImf&i9 ^}>}>^T\R(L[ 0@]cPyi֮]|:m wG7rrr bp"9N-\H(bѴi4ů3k*M<өKթSex|~Mf&($DE7+880~RYY9v,a>wҸqGҥKyײXpff ի]̡|EFFСe3x( ,ne۵a|sfkSW4|(VU:0€$Xs3Qot]6o&@Xܮ_\]sA-^X3|I*(`' aô Lh co|@a(z-ƬXDe&+nW͊aM ?f* ZWXsAfX+(-=0P`hz''GSR\6nΝ;gyv]JJŢժ*+)'iiiZq#ă"MNOj|}}/x ,fiUAM&3""B{/e +?K*.)! ZZ_~Y^^m+~i}7~EZSTTv4ٳ3gܹcykcOD;ƕWpbQqڹgaފ 3+ڠD@ >\,piLM*ڴTѣ˹;%&s9FA!!a0]uVN0ڰ'j&Gz%ƽ*sL*,,Tk0z8ܵK={$ , :^SÝG&:ׂ<U~0y#0ժ+V޵KƍFS5fe˴`v\m(,TΝ DxxJoWzFa̙3U{745k \׿jVvSO[Q!w EE͕?azꩧ=wZh"~ 66VE&EPe+W4foYVXjENS'NJ 11դIԮ];cѾ}{M6MGSdTI\bjNVFF|||TeΜI`BX b(##C/OҸ橢”sv8*߽[xϘ>RMqU7!sj}% Ce:0! ,뫼|EEG4nԯzSιcǎ5{9ժZ|BKܬSNמ-,@:zTS`` 'l*X d(nCl9[,l3f ]v:tN*7/@Pe^0@^^k +..N\lDuϟwv6M:~"-,L;wֺuԣG!+''G5OkQuNf+,/99&ARbh۶mbQ~s.k.xtVGP ;cccDe߾%&Rׯ lO<񄲳L y{{+''eL'O~r:MNW[oBCL 0s۠Atm/+syϿ$!9Y**tR x:v/0(^``VZI'/ &O uuZ[XHL1Cg.\eԻwoXV9R?Dw+6>P:p8#<zҿmh (2\|Y̙;wxL:u/]Ҷ;nn^iʕzgeX8P`Z1b>UUS6ŔuJ{)CU…F4F.)).֚5kQYl6=ZGՑcJffx DhvMr8W(>>>JHHPaaի-,u7ڵkտN4#+K#ǎ% 0s50ӛ7xC/Ҹ9:|Gfdk֭8xGjUE=sFhĉ>}_ t{]U֪IM2Eh5:t%Kdڕ0XV:{挾taQT{""#=6gyFǏWjju),-{M7hMNOW||风;G>NJJRRR~mթ1mܸQ&())IC:t`a(}QWciЮ;Sݺ_\љ3g'nV 2M}Ң&]jhЩSTVVsOIK?Ȉ isohhٳg9P ((0PCNݻwuUUcKž?2[nEoŋ[wo߾,{SGm?޳:w +cfSPP8cCݻ{}ڷoO0hiiѷ~aSu`X04Q`(`hX04 ,  FCQ`(`hX04 ,  FCQ`(`hX04 ,  FCQ`(`hX0'! vIENDB`rclone-v1.71.0/docs/static/img/rclone-32x32.png000066400000000000000000000021221505210326400210050ustar00rootroot00000000000000PNG  IHDR szz pHYs.#.#x?vIDATX]hU]Rj&NA6M")m2"XF¿bEꅠh+iEjҋ0ZLh6XMF/$NΙļs|87i%&Bk` pu; ]uA%xXVzhgf O4Mpxҵ?h+s0cA%6}\:-];"4չK% w'lW (@Pہ$Xk)"pk?tҎr=tm(4T"YH.f %YoV%dD)_7pҵqUkJ0J_O"o{#Ѐ7g_Sݖ 0]GRV!vFϔFEs8t=b/ 4Q81,B;U #x kP`WٳGq xUAC5;a4[> 3U-b ء?z; g~0|K~lƪϖ=d51/";5w(=$&!K0ڏ #׀9ajeAL8atp MJIFC, EpIehƜ0 ъ<\u3āӅ(v`C3titJè9a4dW*%^beF@$t*bi4;8Q8<p1'jڻF?g~3b_#!Ĉy0p#p'o#:$g~/~rG1s˺ DQx;Plxĥ?|91 Έ!īk׋NS|;П0]=:cTC@OWyh3EPsj&k. ܄H!Ͳg|9ax@o #^GkP4 1)W_#f 0ʚ'_bIENDB`rclone-v1.71.0/docs/static/js/000077500000000000000000000000001505210326400161015ustar00rootroot00000000000000rclone-v1.71.0/docs/static/js/bootstrap.min.4.4.1.js000066400000000000000000001651521505210326400217130ustar00rootroot00000000000000/*! * Bootstrap v4.4.1 (https://getbootstrap.com/) * Copyright 2011-2019 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) */ !function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports,require("jquery"),require("popper.js")):"function"==typeof define&&define.amd?define(["exports","jquery","popper.js"],e):e((t=t||self).bootstrap={},t.jQuery,t.Popper)}(this,function(t,g,u){"use strict";function i(t,e){for(var n=0;nthis._items.length-1||t<0))if(this._isSliding)g(this._element).one(Y.SLID,function(){return e.to(t)});else{if(n===t)return this.pause(),void this.cycle();var i=ndocument.documentElement.clientHeight;!this._isBodyOverflowing&&t&&(this._element.style.paddingLeft=this._scrollbarWidth+"px"),this._isBodyOverflowing&&!t&&(this._element.style.paddingRight=this._scrollbarWidth+"px")},t._resetAdjustments=function(){this._element.style.paddingLeft="",this._element.style.paddingRight=""},t._checkScrollbar=function(){var t=document.body.getBoundingClientRect();this._isBodyOverflowing=t.left+t.right

    ',trigger:"hover focus",title:"",delay:0,html:!1,selector:!1,placement:"top",offset:0,container:!1,fallbackPlacement:"flip",boundary:"scrollParent",sanitize:!0,sanitizeFn:null,whiteList:Se,popperConfig:null},Fe="show",Ue="out",We={HIDE:"hide"+Oe,HIDDEN:"hidden"+Oe,SHOW:"show"+Oe,SHOWN:"shown"+Oe,INSERTED:"inserted"+Oe,CLICK:"click"+Oe,FOCUSIN:"focusin"+Oe,FOCUSOUT:"focusout"+Oe,MOUSEENTER:"mouseenter"+Oe,MOUSELEAVE:"mouseleave"+Oe},qe="fade",Me="show",Ke=".tooltip-inner",Qe=".arrow",Be="hover",Ve="focus",Ye="click",ze="manual",Xe=function(){function i(t,e){if("undefined"==typeof u)throw new TypeError("Bootstrap's tooltips require Popper.js (https://popper.js.org/)");this._isEnabled=!0,this._timeout=0,this._hoverState="",this._activeTrigger={},this._popper=null,this.element=t,this.config=this._getConfig(e),this.tip=null,this._setListeners()}var t=i.prototype;return t.enable=function(){this._isEnabled=!0},t.disable=function(){this._isEnabled=!1},t.toggleEnabled=function(){this._isEnabled=!this._isEnabled},t.toggle=function(t){if(this._isEnabled)if(t){var e=this.constructor.DATA_KEY,n=g(t.currentTarget).data(e);n||(n=new this.constructor(t.currentTarget,this._getDelegateConfig()),g(t.currentTarget).data(e,n)),n._activeTrigger.click=!n._activeTrigger.click,n._isWithActiveTrigger()?n._enter(null,n):n._leave(null,n)}else{if(g(this.getTipElement()).hasClass(Me))return void this._leave(null,this);this._enter(null,this)}},t.dispose=function(){clearTimeout(this._timeout),g.removeData(this.element,this.constructor.DATA_KEY),g(this.element).off(this.constructor.EVENT_KEY),g(this.element).closest(".modal").off("hide.bs.modal",this._hideModalHandler),this.tip&&g(this.tip).remove(),this._isEnabled=null,this._timeout=null,this._hoverState=null,this._activeTrigger=null,this._popper&&this._popper.destroy(),this._popper=null,this.element=null,this.config=null,this.tip=null},t.show=function(){var e=this;if("none"===g(this.element).css("display"))throw new Error("Please use show on visible elements");var t=g.Event(this.constructor.Event.SHOW);if(this.isWithContent()&&this._isEnabled){g(this.element).trigger(t);var n=_.findShadowRoot(this.element),i=g.contains(null!==n?n:this.element.ownerDocument.documentElement,this.element);if(t.isDefaultPrevented()||!i)return;var o=this.getTipElement(),r=_.getUID(this.constructor.NAME);o.setAttribute("id",r),this.element.setAttribute("aria-describedby",r),this.setContent(),this.config.animation&&g(o).addClass(qe);var s="function"==typeof this.config.placement?this.config.placement.call(this,o,this.element):this.config.placement,a=this._getAttachment(s);this.addAttachmentClass(a);var l=this._getContainer();g(o).data(this.constructor.DATA_KEY,this),g.contains(this.element.ownerDocument.documentElement,this.tip)||g(o).appendTo(l),g(this.element).trigger(this.constructor.Event.INSERTED),this._popper=new u(this.element,o,this._getPopperConfig(a)),g(o).addClass(Me),"ontouchstart"in document.documentElement&&g(document.body).children().on("mouseover",null,g.noop);var c=function(){e.config.animation&&e._fixTransition();var t=e._hoverState;e._hoverState=null,g(e.element).trigger(e.constructor.Event.SHOWN),t===Ue&&e._leave(null,e)};if(g(this.tip).hasClass(qe)){var h=_.getTransitionDurationFromElement(this.tip);g(this.tip).one(_.TRANSITION_END,c).emulateTransitionEnd(h)}else c()}},t.hide=function(t){function e(){n._hoverState!==Fe&&i.parentNode&&i.parentNode.removeChild(i),n._cleanTipClass(),n.element.removeAttribute("aria-describedby"),g(n.element).trigger(n.constructor.Event.HIDDEN),null!==n._popper&&n._popper.destroy(),t&&t()}var n=this,i=this.getTipElement(),o=g.Event(this.constructor.Event.HIDE);if(g(this.element).trigger(o),!o.isDefaultPrevented()){if(g(i).removeClass(Me),"ontouchstart"in document.documentElement&&g(document.body).children().off("mouseover",null,g.noop),this._activeTrigger[Ye]=!1,this._activeTrigger[Ve]=!1,this._activeTrigger[Be]=!1,g(this.tip).hasClass(qe)){var r=_.getTransitionDurationFromElement(i);g(i).one(_.TRANSITION_END,e).emulateTransitionEnd(r)}else e();this._hoverState=""}},t.update=function(){null!==this._popper&&this._popper.scheduleUpdate()},t.isWithContent=function(){return Boolean(this.getTitle())},t.addAttachmentClass=function(t){g(this.getTipElement()).addClass(Pe+"-"+t)},t.getTipElement=function(){return this.tip=this.tip||g(this.config.template)[0],this.tip},t.setContent=function(){var t=this.getTipElement();this.setElementContent(g(t.querySelectorAll(Ke)),this.getTitle()),g(t).removeClass(qe+" "+Me)},t.setElementContent=function(t,e){"object"!=typeof e||!e.nodeType&&!e.jquery?this.config.html?(this.config.sanitize&&(e=we(e,this.config.whiteList,this.config.sanitizeFn)),t.html(e)):t.text(e):this.config.html?g(e).parent().is(t)||t.empty().append(e):t.text(g(e).text())},t.getTitle=function(){var t=this.element.getAttribute("data-original-title");return t=t||("function"==typeof this.config.title?this.config.title.call(this.element):this.config.title)},t._getPopperConfig=function(t){var e=this;return l({},{placement:t,modifiers:{offset:this._getOffset(),flip:{behavior:this.config.fallbackPlacement},arrow:{element:Qe},preventOverflow:{boundariesElement:this.config.boundary}},onCreate:function(t){t.originalPlacement!==t.placement&&e._handlePopperPlacementChange(t)},onUpdate:function(t){return e._handlePopperPlacementChange(t)}},{},this.config.popperConfig)},t._getOffset=function(){var e=this,t={};return"function"==typeof this.config.offset?t.fn=function(t){return t.offsets=l({},t.offsets,{},e.config.offset(t.offsets,e.element)||{}),t}:t.offset=this.config.offset,t},t._getContainer=function(){return!1===this.config.container?document.body:_.isElement(this.config.container)?g(this.config.container):g(document).find(this.config.container)},t._getAttachment=function(t){return Re[t.toUpperCase()]},t._setListeners=function(){var i=this;this.config.trigger.split(" ").forEach(function(t){if("click"===t)g(i.element).on(i.constructor.Event.CLICK,i.config.selector,function(t){return i.toggle(t)});else if(t!==ze){var e=t===Be?i.constructor.Event.MOUSEENTER:i.constructor.Event.FOCUSIN,n=t===Be?i.constructor.Event.MOUSELEAVE:i.constructor.Event.FOCUSOUT;g(i.element).on(e,i.config.selector,function(t){return i._enter(t)}).on(n,i.config.selector,function(t){return i._leave(t)})}}),this._hideModalHandler=function(){i.element&&i.hide()},g(this.element).closest(".modal").on("hide.bs.modal",this._hideModalHandler),this.config.selector?this.config=l({},this.config,{trigger:"manual",selector:""}):this._fixTitle()},t._fixTitle=function(){var t=typeof this.element.getAttribute("data-original-title");!this.element.getAttribute("title")&&"string"==t||(this.element.setAttribute("data-original-title",this.element.getAttribute("title")||""),this.element.setAttribute("title",""))},t._enter=function(t,e){var n=this.constructor.DATA_KEY;(e=e||g(t.currentTarget).data(n))||(e=new this.constructor(t.currentTarget,this._getDelegateConfig()),g(t.currentTarget).data(n,e)),t&&(e._activeTrigger["focusin"===t.type?Ve:Be]=!0),g(e.getTipElement()).hasClass(Me)||e._hoverState===Fe?e._hoverState=Fe:(clearTimeout(e._timeout),e._hoverState=Fe,e.config.delay&&e.config.delay.show?e._timeout=setTimeout(function(){e._hoverState===Fe&&e.show()},e.config.delay.show):e.show())},t._leave=function(t,e){var n=this.constructor.DATA_KEY;(e=e||g(t.currentTarget).data(n))||(e=new this.constructor(t.currentTarget,this._getDelegateConfig()),g(t.currentTarget).data(n,e)),t&&(e._activeTrigger["focusout"===t.type?Ve:Be]=!1),e._isWithActiveTrigger()||(clearTimeout(e._timeout),e._hoverState=Ue,e.config.delay&&e.config.delay.hide?e._timeout=setTimeout(function(){e._hoverState===Ue&&e.hide()},e.config.delay.hide):e.hide())},t._isWithActiveTrigger=function(){for(var t in this._activeTrigger)if(this._activeTrigger[t])return!0;return!1},t._getConfig=function(t){var e=g(this.element).data();return Object.keys(e).forEach(function(t){-1!==je.indexOf(t)&&delete e[t]}),"number"==typeof(t=l({},this.constructor.Default,{},e,{},"object"==typeof t&&t?t:{})).delay&&(t.delay={show:t.delay,hide:t.delay}),"number"==typeof t.title&&(t.title=t.title.toString()),"number"==typeof t.content&&(t.content=t.content.toString()),_.typeCheckConfig(Ae,t,this.constructor.DefaultType),t.sanitize&&(t.template=we(t.template,t.whiteList,t.sanitizeFn)),t},t._getDelegateConfig=function(){var t={};if(this.config)for(var e in this.config)this.constructor.Default[e]!==this.config[e]&&(t[e]=this.config[e]);return t},t._cleanTipClass=function(){var t=g(this.getTipElement()),e=t.attr("class").match(Le);null!==e&&e.length&&t.removeClass(e.join(""))},t._handlePopperPlacementChange=function(t){var e=t.instance;this.tip=e.popper,this._cleanTipClass(),this.addAttachmentClass(this._getAttachment(t.placement))},t._fixTransition=function(){var t=this.getTipElement(),e=this.config.animation;null===t.getAttribute("x-placement")&&(g(t).removeClass(qe),this.config.animation=!1,this.hide(),this.show(),this.config.animation=e)},i._jQueryInterface=function(n){return this.each(function(){var t=g(this).data(Ne),e="object"==typeof n&&n;if((t||!/dispose|hide/.test(n))&&(t||(t=new i(this,e),g(this).data(Ne,t)),"string"==typeof n)){if("undefined"==typeof t[n])throw new TypeError('No method named "'+n+'"');t[n]()}})},s(i,null,[{key:"VERSION",get:function(){return"4.4.1"}},{key:"Default",get:function(){return xe}},{key:"NAME",get:function(){return Ae}},{key:"DATA_KEY",get:function(){return Ne}},{key:"Event",get:function(){return We}},{key:"EVENT_KEY",get:function(){return Oe}},{key:"DefaultType",get:function(){return He}}]),i}();g.fn[Ae]=Xe._jQueryInterface,g.fn[Ae].Constructor=Xe,g.fn[Ae].noConflict=function(){return g.fn[Ae]=ke,Xe._jQueryInterface};var $e="popover",Ge="bs.popover",Je="."+Ge,Ze=g.fn[$e],tn="bs-popover",en=new RegExp("(^|\\s)"+tn+"\\S+","g"),nn=l({},Xe.Default,{placement:"right",trigger:"click",content:"",template:''}),on=l({},Xe.DefaultType,{content:"(string|element|function)"}),rn="fade",sn="show",an=".popover-header",ln=".popover-body",cn={HIDE:"hide"+Je,HIDDEN:"hidden"+Je,SHOW:"show"+Je,SHOWN:"shown"+Je,INSERTED:"inserted"+Je,CLICK:"click"+Je,FOCUSIN:"focusin"+Je,FOCUSOUT:"focusout"+Je,MOUSEENTER:"mouseenter"+Je,MOUSELEAVE:"mouseleave"+Je},hn=function(t){function i(){return t.apply(this,arguments)||this}!function(t,e){t.prototype=Object.create(e.prototype),(t.prototype.constructor=t).__proto__=e}(i,t);var e=i.prototype;return e.isWithContent=function(){return this.getTitle()||this._getContent()},e.addAttachmentClass=function(t){g(this.getTipElement()).addClass(tn+"-"+t)},e.getTipElement=function(){return this.tip=this.tip||g(this.config.template)[0],this.tip},e.setContent=function(){var t=g(this.getTipElement());this.setElementContent(t.find(an),this.getTitle());var e=this._getContent();"function"==typeof e&&(e=e.call(this.element)),this.setElementContent(t.find(ln),e),t.removeClass(rn+" "+sn)},e._getContent=function(){return this.element.getAttribute("data-content")||this.config.content},e._cleanTipClass=function(){var t=g(this.getTipElement()),e=t.attr("class").match(en);null!==e&&0=this._offsets[o]&&("undefined"==typeof this._offsets[o+1]||t").addClass("header-link").attr("href", "#" + id).html(icon)); } }); // Wire up copy to clipboard buttons $(".copy-to-clipboard").click(function() { var copyText = $(this).prev(); copyText.select(); document.execCommand("copy"); $(this).attr("title", "Copied!"); }); }); rclone-v1.71.0/docs/static/js/jquery.min.3.5.1.js000066400000000000000000002566041505210326400212200ustar00rootroot00000000000000/*! jQuery v3.5.1 | (c) JS Foundation and other contributors | jquery.org/license */ !function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.5.1",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e.namespaceURI,n=(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},D=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function D(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||j,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,j=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="",y.option=!!ce.lastChild;var ge={thead:[1,"","
    "],col:[2,"","
    "],tr:[2,"","
    "],td:[3,"","
    "],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n",""]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d\s*$/g;function qe(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function Le(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function He(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Oe(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var Ut,Xt=[],Vt=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Xt.pop()||S.expando+"_"+Ct.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Vt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Vt.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Vt,"$1"+r):!1!==e.jsonp&&(e.url+=(Et.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,Xt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((Ut=E.implementation.createHTMLDocument("").body).innerHTML="
    ",2===Ut.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):("number"==typeof f.top&&(f.top+="px"),"number"==typeof f.left&&(f.left+="px"),c.css(f))}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=$e(y.pixelPosition,function(e,t){if(t)return t=Be(e,n),Me.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0=o.clientWidth&&n>=o.clientHeight}),l=0a[e]&&!t.escapeWithReference&&(n=Q(f[o],a[e]-('right'===e?f.width:f.height))),ae({},o,n)}};return l.forEach(function(e){var t=-1===['left','top'].indexOf(e)?'secondary':'primary';f=le({},f,m[t](e))}),e.offsets.popper=f,e},priority:['left','right','top','bottom'],padding:5,boundariesElement:'scrollParent'},keepTogether:{order:400,enabled:!0,fn:function(e){var t=e.offsets,o=t.popper,n=t.reference,i=e.placement.split('-')[0],r=Z,p=-1!==['top','bottom'].indexOf(i),s=p?'right':'bottom',d=p?'left':'top',a=p?'width':'height';return o[s]r(n[s])&&(e.offsets.popper[d]=r(n[s])),e}},arrow:{order:500,enabled:!0,fn:function(e,o){var n;if(!K(e.instance.modifiers,'arrow','keepTogether'))return e;var i=o.element;if('string'==typeof i){if(i=e.instance.popper.querySelector(i),!i)return e;}else if(!e.instance.popper.contains(i))return console.warn('WARNING: `arrow.element` must be child of its popper element!'),e;var r=e.placement.split('-')[0],p=e.offsets,s=p.popper,d=p.reference,a=-1!==['left','right'].indexOf(r),l=a?'height':'width',f=a?'Top':'Left',m=f.toLowerCase(),h=a?'left':'top',c=a?'bottom':'right',u=S(i)[l];d[c]-us[c]&&(e.offsets.popper[m]+=d[m]+u-s[c]),e.offsets.popper=g(e.offsets.popper);var b=d[m]+d[l]/2-u/2,w=t(e.instance.popper),y=parseFloat(w['margin'+f],10),E=parseFloat(w['border'+f+'Width'],10),v=b-e.offsets.popper[m]-y-E;return v=ee(Q(s[l]-u,v),0),e.arrowElement=i,e.offsets.arrow=(n={},ae(n,m,$(v)),ae(n,h,''),n),e},element:'[x-arrow]'},flip:{order:600,enabled:!0,fn:function(e,t){if(W(e.instance.modifiers,'inner'))return e;if(e.flipped&&e.placement===e.originalPlacement)return e;var o=v(e.instance.popper,e.instance.reference,t.padding,t.boundariesElement,e.positionFixed),n=e.placement.split('-')[0],i=T(n),r=e.placement.split('-')[1]||'',p=[];switch(t.behavior){case ce.FLIP:p=[n,i];break;case ce.CLOCKWISE:p=G(n);break;case ce.COUNTERCLOCKWISE:p=G(n,!0);break;default:p=t.behavior;}return p.forEach(function(s,d){if(n!==s||p.length===d+1)return e;n=e.placement.split('-')[0],i=T(n);var a=e.offsets.popper,l=e.offsets.reference,f=Z,m='left'===n&&f(a.right)>f(l.left)||'right'===n&&f(a.left)f(l.top)||'bottom'===n&&f(a.top)f(o.right),g=f(a.top)f(o.bottom),b='left'===n&&h||'right'===n&&c||'top'===n&&g||'bottom'===n&&u,w=-1!==['top','bottom'].indexOf(n),y=!!t.flipVariations&&(w&&'start'===r&&h||w&&'end'===r&&c||!w&&'start'===r&&g||!w&&'end'===r&&u),E=!!t.flipVariationsByContent&&(w&&'start'===r&&c||w&&'end'===r&&h||!w&&'start'===r&&u||!w&&'end'===r&&g),v=y||E;(m||b||v)&&(e.flipped=!0,(m||b)&&(n=p[d+1]),v&&(r=z(r)),e.placement=n+(r?'-'+r:''),e.offsets.popper=le({},e.offsets.popper,C(e.instance.popper,e.offsets.reference,e.placement)),e=P(e.instance.modifiers,e,'flip'))}),e},behavior:'flip',padding:5,boundariesElement:'viewport',flipVariations:!1,flipVariationsByContent:!1},inner:{order:700,enabled:!1,fn:function(e){var t=e.placement,o=t.split('-')[0],n=e.offsets,i=n.popper,r=n.reference,p=-1!==['left','right'].indexOf(o),s=-1===['top','left'].indexOf(o);return i[p?'left':'top']=r[o]-(s?i[p?'width':'height']:0),e.placement=T(t),e.offsets.popper=g(i),e}},hide:{order:800,enabled:!0,fn:function(e){if(!K(e.instance.modifiers,'hide','preventOverflow'))return e;var t=e.offsets.reference,o=D(e.instance.modifiers,function(e){return'preventOverflow'===e.name}).boundaries;if(t.bottomo.right||t.top>o.bottom||t.rightwindow.devicePixelRatio||!fe),c='bottom'===o?'top':'bottom',g='right'===n?'left':'right',b=B('transform');if(d='bottom'==c?'HTML'===l.nodeName?-l.clientHeight+h.bottom:-f.height+h.bottom:h.top,s='right'==g?'HTML'===l.nodeName?-l.clientWidth+h.right:-f.width+h.right:h.left,a&&b)m[b]='translate3d('+s+'px, '+d+'px, 0)',m[c]=0,m[g]=0,m.willChange='transform';else{var w='bottom'==c?-1:1,y='right'==g?-1:1;m[c]=d*w,m[g]=s*y,m.willChange=c+', '+g}var E={"x-placement":e.placement};return e.attributes=le({},E,e.attributes),e.styles=le({},m,e.styles),e.arrowStyles=le({},e.offsets.arrow,e.arrowStyles),e},gpuAcceleration:!0,x:'bottom',y:'right'},applyStyle:{order:900,enabled:!0,fn:function(e){return V(e.instance.popper,e.styles),j(e.instance.popper,e.attributes),e.arrowElement&&Object.keys(e.arrowStyles).length&&V(e.arrowElement,e.arrowStyles),e},onLoad:function(e,t,o,n,i){var r=L(i,t,e,o.positionFixed),p=O(o.placement,r,t,e,o.modifiers.flip.boundariesElement,o.modifiers.flip.padding);return t.setAttribute('x-placement',p),V(t,{position:o.positionFixed?'fixed':'absolute'}),o},gpuAcceleration:void 0}}},ge}); //# sourceMappingURL=popper.min.js.map rclone-v1.71.0/docs/static/js/search.js000066400000000000000000000002071505210326400177030ustar00rootroot00000000000000function on_search() { document.search_form.q.value = document.search_form.words.value + " -site:forum.rclone.org"; return true; } rclone-v1.71.0/fs/000077500000000000000000000000001505210326400136565ustar00rootroot00000000000000rclone-v1.71.0/fs/accounting/000077500000000000000000000000001505210326400160105ustar00rootroot00000000000000rclone-v1.71.0/fs/accounting/accounting.go000066400000000000000000000422271505210326400205000ustar00rootroot00000000000000// Package accounting providers an accounting and limiting reader package accounting import ( "context" "errors" "fmt" "io" "sync" "time" "unicode/utf8" "github.com/rclone/rclone/fs/rc" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/asyncreader" "github.com/rclone/rclone/fs/fserrors" ) // ErrorMaxTransferLimitReached defines error when transfer limit is reached. // Used for checking on exit and matching to correct exit code. var ErrorMaxTransferLimitReached = errors.New("max transfer limit reached as set by --max-transfer") // ErrorMaxTransferLimitReachedFatal is returned from Read when the max // transfer limit is reached. var ErrorMaxTransferLimitReachedFatal = fserrors.FatalError(ErrorMaxTransferLimitReached) // ErrorMaxTransferLimitReachedGraceful is returned from operations.Copy when the max // transfer limit is reached and a graceful stop is required. var ErrorMaxTransferLimitReachedGraceful = fserrors.NoRetryError(ErrorMaxTransferLimitReached) // Start sets up the accounting, in particular the bandwidth limiting func Start(ctx context.Context) { // Start the token bucket limiter TokenBucket.StartTokenBucket(ctx) // Start the bandwidth update ticker TokenBucket.StartTokenTicker(ctx) // Start the transactions per second limiter StartLimitTPS(ctx) // Set the error count function pointer up in fs // // We can't do this in an init() method as it uses fs.Config // and that isn't set up then. fs.CountError = func(ctx context.Context, err error) error { return Stats(ctx).Error(err) } } // Account limits and accounts for one transfer type Account struct { stats *StatsInfo // The mutex is to make sure Read() and Close() aren't called // concurrently. Unfortunately the persistent connection loop // in http transport calls Read() after Do() returns on // CancelRequest so this race can happen when it apparently // shouldn't. mu sync.Mutex // mutex protects these values in io.Reader ctx context.Context // current context for transfer - may change ci *fs.ConfigInfo origIn io.ReadCloser close io.Closer size int64 name string closed bool // set if the file is closed exit chan struct{} // channel that will be closed when transfer is finished withBuf bool // is using a buffered in checking bool // set if attached transfer is checking tokenBucket buckets // per file bandwidth limiter (may be nil) values accountValues } // accountValues holds statistics for this Account type accountValues struct { mu sync.Mutex // Mutex for stat values. bytes int64 // Total number of bytes read max int64 // if >=0 the max number of bytes to transfer start time.Time // Start time of first read lpTime time.Time // Time of last average measurement lpBytes int // Number of bytes read since last measurement avg float64 // Moving average of last few measurements in Byte/s } const averagePeriod = 16 // period to do exponentially weighted averages over // newAccountSizeName makes an Account reader for an io.ReadCloser of // the given size and name func newAccountSizeName(ctx context.Context, stats *StatsInfo, in io.ReadCloser, size int64, name string) *Account { acc := &Account{ stats: stats, in: in, ctx: ctx, ci: fs.GetConfig(ctx), close: in, origIn: in, size: size, name: name, exit: make(chan struct{}), values: accountValues{ avg: 0, lpTime: time.Now(), max: -1, }, } if acc.ci.CutoffMode == fs.CutoffModeHard { acc.values.max = int64((acc.ci.MaxTransfer)) } currLimit := acc.ci.BwLimitFile.LimitAt(time.Now()) if currLimit.Bandwidth.IsSet() { fs.Debugf(acc.name, "Limiting file transfer to %v", currLimit.Bandwidth) acc.tokenBucket = newTokenBucket(currLimit.Bandwidth) } go acc.averageLoop() stats.inProgress.set(acc.name, acc) return acc } // WithBuffer - If the file is above a certain size it adds an Async reader func (acc *Account) WithBuffer() *Account { // if already have a buffer then just return if acc.withBuf { return acc } acc.withBuf = true var buffers int if acc.size >= int64(acc.ci.BufferSize) || acc.size == -1 { buffers = int(int64(acc.ci.BufferSize) / asyncreader.BufferSize) } else { buffers = int(acc.size / asyncreader.BufferSize) } // On big files add a buffer if buffers > 0 { rc, err := asyncreader.New(acc.ctx, acc.origIn, buffers) if err != nil { fs.Errorf(acc.name, "Failed to make buffer: %v", err) } else { acc.in = rc acc.close = rc } } return acc } // HasBuffer - returns true if this Account has an AsyncReader with a buffer func (acc *Account) HasBuffer() bool { acc.mu.Lock() defer acc.mu.Unlock() _, ok := acc.in.(*asyncreader.AsyncReader) return ok } // GetReader returns the underlying io.ReadCloser under any Buffer func (acc *Account) GetReader() io.ReadCloser { acc.mu.Lock() defer acc.mu.Unlock() return acc.origIn } // GetAsyncReader returns the current AsyncReader or nil if Account is unbuffered func (acc *Account) GetAsyncReader() *asyncreader.AsyncReader { acc.mu.Lock() defer acc.mu.Unlock() if asyncIn, ok := acc.in.(*asyncreader.AsyncReader); ok { return asyncIn } return nil } // StopBuffering stops the async buffer doing any more buffering func (acc *Account) StopBuffering() { if asyncIn, ok := acc.in.(*asyncreader.AsyncReader); ok { asyncIn.StopBuffering() } } // Abandon stops the async buffer doing any more buffering func (acc *Account) Abandon() { if asyncIn, ok := acc.in.(*asyncreader.AsyncReader); ok { asyncIn.Abandon() } } // UpdateReader updates the underlying io.ReadCloser stopping the // async buffer (if any) and re-adding it func (acc *Account) UpdateReader(ctx context.Context, in io.ReadCloser) { acc.mu.Lock() withBuf := acc.withBuf if withBuf { acc.Abandon() acc.withBuf = false } acc.in = in acc.ctx = ctx acc.close = in acc.origIn = in acc.closed = false if withBuf { acc.WithBuffer() } acc.mu.Unlock() // Reset counter to stop percentage going over 100% acc.values.mu.Lock() acc.values.lpBytes = 0 acc.values.bytes = 0 acc.values.mu.Unlock() } // averageLoop calculates averages for the stats in the background func (acc *Account) averageLoop() { tick := time.NewTicker(time.Second) var period float64 defer tick.Stop() for { select { case now := <-tick.C: acc.values.mu.Lock() // Add average of last second. elapsed := now.Sub(acc.values.lpTime).Seconds() avg := 0.0 if elapsed > 0 { avg = float64(acc.values.lpBytes) / elapsed } // Soft start the moving average if period < averagePeriod { period++ } acc.values.avg = (avg + (period-1)*acc.values.avg) / period acc.values.lpBytes = 0 acc.values.lpTime = now // Unlock stats acc.values.mu.Unlock() case <-acc.exit: return } } } // Check the read before it has happened is valid returning the number // of bytes remaining to read. func (acc *Account) checkReadBefore() (bytesUntilLimit int64, err error) { // Check to see if context is cancelled if err = acc.ctx.Err(); err != nil { return 0, err } acc.values.mu.Lock() if acc.values.max >= 0 { bytesUntilLimit = acc.values.max - acc.stats.GetBytes() if bytesUntilLimit < 0 { acc.values.mu.Unlock() return bytesUntilLimit, ErrorMaxTransferLimitReachedFatal } } else { bytesUntilLimit = 1 << 62 } // Set start time. if acc.values.start.IsZero() { acc.values.start = time.Now() } acc.values.mu.Unlock() return bytesUntilLimit, nil } // Check the read call after the read has happened func (acc *Account) checkReadAfter(bytesUntilLimit int64, n int, err error) (outN int, outErr error) { bytesUntilLimit -= int64(n) if bytesUntilLimit < 0 { // chop the overage off n += int(bytesUntilLimit) if n < 0 { n = 0 } err = ErrorMaxTransferLimitReachedFatal } return n, err } // ServerSideTransferStart should be called at the start of a server-side transfer // // This pretends a transfer has started func (acc *Account) ServerSideTransferStart() { acc.values.mu.Lock() // Set start time. if acc.values.start.IsZero() { acc.values.start = time.Now() } acc.values.mu.Unlock() } // ServerSideTransferEnd accounts for a read of n bytes in a sever // side transfer to be treated as a normal transfer. func (acc *Account) ServerSideTransferEnd(n int64) { // Update Stats acc.values.mu.Lock() acc.values.bytes += n acc.values.mu.Unlock() acc.stats.Bytes(n) } // serverSideEnd accounts for non specific server-side data func (acc *Account) serverSideEnd(n int64) { // Account for bytes unless we are checking if !acc.checking { acc.stats.BytesNoNetwork(n) } } // ServerSideCopyEnd accounts for a read of n bytes in a server-side copy func (acc *Account) ServerSideCopyEnd(n int64) { acc.stats.AddServerSideCopy(n) acc.serverSideEnd(n) } // ServerSideMoveEnd accounts for a read of n bytes in a server-side move func (acc *Account) ServerSideMoveEnd(n int64) { acc.stats.AddServerSideMove(n) acc.serverSideEnd(n) } // DryRun accounts for statistics without running the operation func (acc *Account) DryRun(n int64) { acc.ServerSideTransferStart() acc.ServerSideTransferEnd(n) } // Account for n bytes from the current file bandwidth limit (if any) func (acc *Account) limitPerFileBandwidth(n int) { acc.values.mu.Lock() tokenBucket := acc.tokenBucket[TokenBucketSlotAccounting] acc.values.mu.Unlock() if tokenBucket != nil { err := tokenBucket.WaitN(context.Background(), n) if err != nil { fs.Errorf(nil, "Token bucket error: %v", err) } } } // Account the read and limit bandwidth func (acc *Account) accountRead(n int) { // Update Stats acc.values.mu.Lock() acc.values.lpBytes += n acc.values.bytes += int64(n) acc.values.mu.Unlock() acc.stats.Bytes(int64(n)) TokenBucket.LimitBandwidth(TokenBucketSlotAccounting, n) acc.limitPerFileBandwidth(n) } // read bytes from the io.Reader passed in and account them func (acc *Account) read(in io.Reader, p []byte) (n int, err error) { bytesUntilLimit, err := acc.checkReadBefore() if err == nil { n, err = in.Read(p) acc.accountRead(n) n, err = acc.checkReadAfter(bytesUntilLimit, n, err) } return n, err } // Read bytes from the object - see io.Reader func (acc *Account) Read(p []byte) (n int, err error) { acc.mu.Lock() defer acc.mu.Unlock() return acc.read(acc.in, p) } // Thin wrapper for w type accountWriteTo struct { w io.Writer acc *Account } // Write writes len(p) bytes from p to the underlying data stream. It // returns the number of bytes written from p (0 <= n <= len(p)) and // any error encountered that caused the write to stop early. Write // must return a non-nil error if it returns n < len(p). Write must // not modify the slice data, even temporarily. // // Implementations must not retain p. func (awt *accountWriteTo) Write(p []byte) (n int, err error) { bytesUntilLimit, err := awt.acc.checkReadBefore() if err == nil { n, err = awt.w.Write(p) n, err = awt.acc.checkReadAfter(bytesUntilLimit, n, err) awt.acc.accountRead(n) } return n, err } // WriteTo writes data to w until there's no more data to write or // when an error occurs. The return value n is the number of bytes // written. Any error encountered during the write is also returned. func (acc *Account) WriteTo(w io.Writer) (n int64, err error) { acc.mu.Lock() in := acc.in acc.mu.Unlock() wrappedWriter := accountWriteTo{w: w, acc: acc} if do, ok := in.(io.WriterTo); ok { n, err = do.WriteTo(&wrappedWriter) } else { n, err = io.Copy(&wrappedWriter, in) } return } // AccountRead account having read n bytes func (acc *Account) AccountRead(n int) (err error) { acc.mu.Lock() defer acc.mu.Unlock() bytesUntilLimit, err := acc.checkReadBefore() if err == nil { n, err = acc.checkReadAfter(bytesUntilLimit, n, err) acc.accountRead(n) } return err } // Close the object func (acc *Account) Close() error { acc.mu.Lock() defer acc.mu.Unlock() if acc.closed { return nil } acc.closed = true if acc.close == nil { return nil } return acc.close.Close() } // Done with accounting - must be called to free accounting goroutine func (acc *Account) Done() { acc.mu.Lock() defer acc.mu.Unlock() close(acc.exit) acc.stats.inProgress.clear(acc.name) } // progress returns bytes read as well as the size. // Size can be <= 0 if the size is unknown. func (acc *Account) progress() (bytes, size int64) { if acc == nil { return 0, 0 } acc.values.mu.Lock() bytes, size = acc.values.bytes, acc.size acc.values.mu.Unlock() return bytes, size } // speed returns the speed of the current file transfer // in bytes per second, as well an exponentially weighted moving average // If no read has completed yet, 0 is returned for both values. func (acc *Account) speed() (bps, current float64) { if acc == nil { return 0, 0 } acc.values.mu.Lock() defer acc.values.mu.Unlock() if acc.values.bytes == 0 { return 0, 0 } // Calculate speed from first read. total := float64(time.Since(acc.values.start)) / float64(time.Second) if total > 0 { bps = float64(acc.values.bytes) / total } else { bps = 0.0 } current = acc.values.avg return } // eta returns the ETA of the current operation, // rounded to full seconds. // If the ETA cannot be determined 'ok' returns false. func (acc *Account) eta() (etaDuration time.Duration, ok bool) { if acc == nil { return 0, false } acc.values.mu.Lock() defer acc.values.mu.Unlock() return eta(acc.values.bytes, acc.size, acc.values.avg) } // shortenName shortens in to size runes long // If size <= 0 then in is left untouched func shortenName(in string, size int) string { if size <= 0 { return in } if utf8.RuneCountInString(in) <= size { return in } name := []rune(in) size-- // don't count ellipsis rune suffixLength := size / 2 prefixLength := size - suffixLength suffixStart := len(name) - suffixLength name = append(append(name[:prefixLength], '…'), name[suffixStart:]...) return string(name) } // String produces stats for this file func (acc *Account) String() string { a, b := acc.progress() _, cur := acc.speed() eta, etaok := acc.eta() etas := "-" if etaok { if eta > 0 { etas = fmt.Sprintf("%v", eta) } else { etas = "0s" } } if acc.ci.DataRateUnit == "bits" { cur *= 8 } percentageDone := 0 if b > 0 { percentageDone = int(100 * float64(a) / float64(b)) } return fmt.Sprintf("%*s:%3d%% /%s, %s/s, %s", acc.ci.StatsFileNameLength, shortenName(acc.name, acc.ci.StatsFileNameLength), percentageDone, fs.SizeSuffix(b), fs.SizeSuffix(cur), etas, ) } // rcStats adds remote control stats for this file func (acc *Account) rcStats(out rc.Params) { a, b := acc.progress() out["bytes"] = a out["size"] = b spd, cur := acc.speed() out["speed"] = spd out["speedAvg"] = cur eta, etaOK := acc.eta() if etaOK { out["eta"] = eta.Seconds() } else { out["eta"] = nil } out["name"] = acc.name percentageDone := 0 if b > 0 { percentageDone = int(100 * float64(a) / float64(b)) } out["percentage"] = percentageDone out["group"] = acc.stats.group } // OldStream returns the top io.Reader func (acc *Account) OldStream() io.Reader { acc.mu.Lock() defer acc.mu.Unlock() return acc.in } // SetStream updates the top io.Reader func (acc *Account) SetStream(in io.Reader) { acc.mu.Lock() acc.in = in acc.mu.Unlock() } // WrapStream wraps an io Reader so it will be accounted in the same // way as account func (acc *Account) WrapStream(in io.Reader) io.Reader { return &accountStream{ acc: acc, in: in, } } // accountStream accounts a single io.Reader into a parent *Account type accountStream struct { acc *Account in io.Reader } // OldStream return the underlying stream func (a *accountStream) OldStream() io.Reader { return a.in } // SetStream set the underlying stream func (a *accountStream) SetStream(in io.Reader) { a.in = in } // WrapStream wrap in an accounter func (a *accountStream) WrapStream(in io.Reader) io.Reader { return a.acc.WrapStream(in) } // Read bytes from the object - see io.Reader func (a *accountStream) Read(p []byte) (n int, err error) { return a.acc.read(a.in, p) } // Accounter accounts a stream allowing the accounting to be removed and re-added type Accounter interface { io.Reader OldStream() io.Reader SetStream(io.Reader) WrapStream(io.Reader) io.Reader } // WrapFn wraps an io.Reader (for accounting purposes usually) type WrapFn func(io.Reader) io.Reader // UnWrap unwraps a reader returning unwrapped and wrap, a function to // wrap it back up again. If `in` is an Accounter then this function // will take the accounting unwrapped and wrap will put it back on // again the new Reader passed in. // // This allows functions which wrap io.Readers to move the accounting // to the end of the wrapped chain of readers. This is very important // if buffering is being introduced and if the Reader might be wrapped // again. func UnWrap(in io.Reader) (unwrapped io.Reader, wrap WrapFn) { acc, ok := in.(Accounter) if !ok { return in, func(r io.Reader) io.Reader { return r } } return acc.OldStream(), acc.WrapStream } // UnWrapAccounting unwraps a reader returning unwrapped and acc a // pointer to the accounting. // // The caller is expected to manage the accounting at this point. func UnWrapAccounting(in io.Reader) (unwrapped io.Reader, acc *Account) { a, ok := in.(*accountStream) if !ok { return in, nil } return a.in, a.acc } rclone-v1.71.0/fs/accounting/accounting_other.go000066400000000000000000000004701505210326400216730ustar00rootroot00000000000000// Accounting and limiting reader // Non-unix specific functions. //go:build !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris package accounting // startSignalHandler() is Unix specific and does nothing under non-Unix // platforms. func (tb *tokenBucket) startSignalHandler() {} rclone-v1.71.0/fs/accounting/accounting_test.go000066400000000000000000000232321505210326400215320ustar00rootroot00000000000000package accounting import ( "bytes" "context" "fmt" "io" "strings" "testing" "unicode/utf8" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/asyncreader" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/lib/readers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Check it satisfies the interfaces var ( _ io.ReadCloser = &Account{} _ io.WriterTo = &Account{} _ io.Reader = &accountStream{} _ Accounter = &Account{} _ Accounter = &accountStream{} ) func TestNewAccountSizeName(t *testing.T) { ctx := context.Background() in := io.NopCloser(bytes.NewBuffer([]byte{1})) stats := NewStats(ctx) acc := newAccountSizeName(context.Background(), stats, in, 1, "test") assert.Equal(t, in, acc.in) assert.Equal(t, acc, stats.inProgress.get("test")) err := acc.Close() assert.NoError(t, err) assert.Equal(t, acc, stats.inProgress.get("test")) acc.Done() assert.Nil(t, stats.inProgress.get("test")) assert.False(t, acc.HasBuffer()) } func TestAccountWithBuffer(t *testing.T) { ctx := context.Background() in := io.NopCloser(bytes.NewBuffer([]byte{1})) stats := NewStats(ctx) acc := newAccountSizeName(ctx, stats, in, -1, "test") assert.False(t, acc.HasBuffer()) acc.WithBuffer() assert.True(t, acc.HasBuffer()) // should have a buffer for an unknown size _, ok := acc.in.(*asyncreader.AsyncReader) require.True(t, ok) assert.NoError(t, acc.Close()) acc = newAccountSizeName(ctx, stats, in, 1, "test") acc.WithBuffer() // should not have a buffer for a small size _, ok = acc.in.(*asyncreader.AsyncReader) require.False(t, ok) assert.NoError(t, acc.Close()) } func TestAccountGetUpdateReader(t *testing.T) { ctx := context.Background() test := func(doClose bool) func(t *testing.T) { return func(t *testing.T) { in := io.NopCloser(bytes.NewBuffer([]byte{1})) stats := NewStats(ctx) acc := newAccountSizeName(ctx, stats, in, 1, "test") assert.Equal(t, in, acc.GetReader()) assert.Equal(t, acc, stats.inProgress.get("test")) if doClose { // close the account before swapping it out require.NoError(t, acc.Close()) } in2 := io.NopCloser(bytes.NewBuffer([]byte{1})) acc.UpdateReader(ctx, in2) assert.Equal(t, in2, acc.GetReader()) assert.Equal(t, acc, stats.inProgress.get("test")) assert.NoError(t, acc.Close()) } } t.Run("NoClose", test(false)) t.Run("Close", test(true)) } func TestAccountRead(t *testing.T) { ctx := context.Background() in := io.NopCloser(bytes.NewBuffer([]byte{1, 2, 3})) stats := NewStats(ctx) acc := newAccountSizeName(ctx, stats, in, 1, "test") assert.True(t, acc.values.start.IsZero()) acc.values.mu.Lock() assert.Equal(t, 0, acc.values.lpBytes) assert.Equal(t, int64(0), acc.values.bytes) acc.values.mu.Unlock() assert.Equal(t, int64(0), stats.bytes) var buf = make([]byte, 2) n, err := acc.Read(buf) assert.NoError(t, err) assert.Equal(t, 2, n) assert.Equal(t, []byte{1, 2}, buf[:n]) assert.False(t, acc.values.start.IsZero()) acc.values.mu.Lock() assert.Equal(t, 2, acc.values.lpBytes) assert.Equal(t, int64(2), acc.values.bytes) acc.values.mu.Unlock() assert.Equal(t, int64(2), stats.bytes) n, err = acc.Read(buf) assert.NoError(t, err) assert.Equal(t, 1, n) assert.Equal(t, []byte{3}, buf[:n]) n, err = acc.Read(buf) assert.Equal(t, io.EOF, err) assert.Equal(t, 0, n) assert.NoError(t, acc.Close()) } func testAccountWriteTo(t *testing.T, withBuffer bool) { ctx := context.Background() buf := make([]byte, 2*asyncreader.BufferSize+1) for i := range buf { buf[i] = byte(i % 251) } in := io.NopCloser(bytes.NewBuffer(buf)) stats := NewStats(ctx) acc := newAccountSizeName(ctx, stats, in, int64(len(buf)), "test") if withBuffer { acc = acc.WithBuffer() } assert.True(t, acc.values.start.IsZero()) acc.values.mu.Lock() assert.Equal(t, 0, acc.values.lpBytes) assert.Equal(t, int64(0), acc.values.bytes) acc.values.mu.Unlock() assert.Equal(t, int64(0), stats.bytes) var out bytes.Buffer n, err := acc.WriteTo(&out) assert.NoError(t, err) assert.Equal(t, int64(len(buf)), n) assert.Equal(t, buf, out.Bytes()) assert.False(t, acc.values.start.IsZero()) acc.values.mu.Lock() assert.Equal(t, len(buf), acc.values.lpBytes) assert.Equal(t, int64(len(buf)), acc.values.bytes) acc.values.mu.Unlock() assert.Equal(t, int64(len(buf)), stats.bytes) assert.NoError(t, acc.Close()) } func TestAccountWriteTo(t *testing.T) { testAccountWriteTo(t, false) } func TestAccountWriteToWithBuffer(t *testing.T) { testAccountWriteTo(t, true) } func TestAccountString(t *testing.T) { ctx := context.Background() in := io.NopCloser(bytes.NewBuffer([]byte{1, 2, 3})) stats := NewStats(ctx) acc := newAccountSizeName(ctx, stats, in, 3, "test") // FIXME not an exhaustive test! assert.Equal(t, "test: 0% /3, 0/s, -", strings.TrimSpace(acc.String())) var buf = make([]byte, 2) n, err := acc.Read(buf) assert.NoError(t, err) assert.Equal(t, 2, n) assert.Equal(t, "test: 66% /3, 0/s, -", strings.TrimSpace(acc.String())) assert.NoError(t, acc.Close()) } // Test the Accounter interface methods on Account and accountStream func TestAccountAccounter(t *testing.T) { ctx := context.Background() in := io.NopCloser(bytes.NewBuffer([]byte{1, 2, 3})) stats := NewStats(ctx) acc := newAccountSizeName(ctx, stats, in, 3, "test") assert.True(t, in == acc.OldStream()) in2 := io.NopCloser(bytes.NewBuffer([]byte{2, 3, 4})) acc.SetStream(in2) assert.True(t, in2 == acc.OldStream()) r := acc.WrapStream(in) as, ok := r.(Accounter) require.True(t, ok) assert.True(t, in == as.OldStream()) assert.True(t, in2 == acc.OldStream()) accs, ok := r.(*accountStream) require.True(t, ok) assert.Equal(t, acc, accs.acc) assert.True(t, in == accs.in) // Check Read on the accountStream var buf = make([]byte, 2) n, err := r.Read(buf) assert.NoError(t, err) assert.Equal(t, 2, n) assert.Equal(t, []byte{1, 2}, buf[:n]) // Test that we can get another accountstream out in3 := io.NopCloser(bytes.NewBuffer([]byte{3, 1, 2})) r2 := as.WrapStream(in3) as2, ok := r2.(Accounter) require.True(t, ok) assert.True(t, in3 == as2.OldStream()) assert.True(t, in2 == acc.OldStream()) accs2, ok := r2.(*accountStream) require.True(t, ok) assert.Equal(t, acc, accs2.acc) assert.True(t, in3 == accs2.in) // Test we can set this new accountStream as2.SetStream(in) assert.True(t, in == as2.OldStream()) // Test UnWrap on accountStream unwrapped, wrap := UnWrap(r2) assert.True(t, unwrapped == in) r3 := wrap(in2) assert.True(t, in2 == r3.(Accounter).OldStream()) // TestUnWrap on a normal io.Reader unwrapped, wrap = UnWrap(in2) assert.True(t, unwrapped == in2) assert.True(t, wrap(in3) == in3) } func TestAccountMaxTransfer(t *testing.T) { ctx := context.Background() ci := fs.GetConfig(ctx) old := ci.MaxTransfer oldMode := ci.CutoffMode ci.MaxTransfer = 15 defer func() { ci.MaxTransfer = old ci.CutoffMode = oldMode }() in := io.NopCloser(bytes.NewBuffer(make([]byte, 100))) stats := NewStats(ctx) acc := newAccountSizeName(ctx, stats, in, 1, "test") var b = make([]byte, 10) n, err := acc.Read(b) assert.Equal(t, 10, n) assert.NoError(t, err) n, err = acc.Read(b) assert.Equal(t, 5, n) assert.Equal(t, ErrorMaxTransferLimitReachedFatal, err) n, err = acc.Read(b) assert.Equal(t, 0, n) assert.Equal(t, ErrorMaxTransferLimitReachedFatal, err) assert.True(t, fserrors.IsFatalError(err)) ci.CutoffMode = fs.CutoffModeSoft stats = NewStats(ctx) acc = newAccountSizeName(ctx, stats, in, 1, "test") n, err = acc.Read(b) assert.Equal(t, 10, n) assert.NoError(t, err) n, err = acc.Read(b) assert.Equal(t, 10, n) assert.NoError(t, err) n, err = acc.Read(b) assert.Equal(t, 10, n) assert.NoError(t, err) } func TestAccountMaxTransferWriteTo(t *testing.T) { ctx := context.Background() ci := fs.GetConfig(ctx) old := ci.MaxTransfer oldMode := ci.CutoffMode ci.MaxTransfer = 15 defer func() { ci.MaxTransfer = old ci.CutoffMode = oldMode }() in := io.NopCloser(readers.NewPatternReader(1024)) stats := NewStats(ctx) acc := newAccountSizeName(ctx, stats, in, 1, "test") var b bytes.Buffer n, err := acc.WriteTo(&b) assert.Equal(t, int64(15), n) assert.Equal(t, ErrorMaxTransferLimitReachedFatal, err) } func TestAccountReadCtx(t *testing.T) { ctx := context.Background() ctx, cancel := context.WithCancel(ctx) in := io.NopCloser(bytes.NewBuffer(make([]byte, 100))) stats := NewStats(ctx) acc := newAccountSizeName(ctx, stats, in, 1, "test") var b = make([]byte, 10) n, err := acc.Read(b) assert.Equal(t, 10, n) assert.NoError(t, err) cancel() n, err = acc.Read(b) assert.Equal(t, 0, n) assert.Equal(t, context.Canceled, err) } func TestShortenName(t *testing.T) { for _, test := range []struct { in string size int want string }{ {"", 0, ""}, {"abcde", 10, "abcde"}, {"abcde", 0, "abcde"}, {"abcde", -1, "abcde"}, {"abcde", 5, "abcde"}, {"abcde", 4, "ab…e"}, {"abcde", 3, "a…e"}, {"abcde", 2, "a…"}, {"abcde", 1, "…"}, {"abcdef", 6, "abcdef"}, {"abcdef", 5, "ab…ef"}, {"abcdef", 4, "ab…f"}, {"abcdef", 3, "a…f"}, {"abcdef", 2, "a…"}, {"áßcdèf", 1, "…"}, {"áßcdè", 5, "áßcdè"}, {"áßcdè", 4, "áß…è"}, {"áßcdè", 3, "á…è"}, {"áßcdè", 2, "á…"}, {"áßcdè", 1, "…"}, {"áßcdèł", 6, "áßcdèł"}, {"áßcdèł", 5, "áß…èł"}, {"áßcdèł", 4, "áß…ł"}, {"áßcdèł", 3, "á…ł"}, {"áßcdèł", 2, "á…"}, {"áßcdèł", 1, "…"}, } { t.Run(fmt.Sprintf("in=%q, size=%d", test.in, test.size), func(t *testing.T) { got := shortenName(test.in, test.size) assert.Equal(t, test.want, got) if test.size > 0 { assert.True(t, utf8.RuneCountInString(got) <= test.size, "too big") } }) } } rclone-v1.71.0/fs/accounting/accounting_unix.go000066400000000000000000000021331505210326400215330ustar00rootroot00000000000000// Accounting and limiting reader // Unix specific functions. //go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris package accounting import ( "os" "os/signal" "syscall" "github.com/rclone/rclone/fs" ) // startSignalHandler() sets a signal handler to catch SIGUSR2 and toggle throttling. func (tb *tokenBucket) startSignalHandler() { signals := make(chan os.Signal, 1) signal.Notify(signals, syscall.SIGUSR2) go func() { // This runs forever, but blocks until the signal is received. for { <-signals func() { tb.mu.Lock() defer tb.mu.Unlock() // if there's no bandwidth limit configured now, do nothing if !tb.currLimit.Bandwidth.IsSet() { fs.Debugf(nil, "SIGUSR2 received but no bandwidth limit configured right now, ignoring") return } tb.toggledOff = !tb.toggledOff tb.curr, tb.prev = tb.prev, tb.curr s, limit := "disabled", "off" if !tb.curr._isOff() { s = "enabled" limit = tb.currLimit.Bandwidth.String() } fs.Logf(nil, "Bandwidth limit %s by user (now %s)", s, limit) }() } }() } rclone-v1.71.0/fs/accounting/inprogress.go000066400000000000000000000020521505210326400205310ustar00rootroot00000000000000package accounting import ( "context" "maps" "sync" "github.com/rclone/rclone/fs" ) // inProgress holds a synchronized map of in progress transfers type inProgress struct { mu sync.Mutex m map[string]*Account } // newInProgress makes a new inProgress object func newInProgress(ctx context.Context) *inProgress { ci := fs.GetConfig(ctx) return &inProgress{ m: make(map[string]*Account, ci.Transfers), } } // set marks the name as in progress func (ip *inProgress) set(name string, acc *Account) { ip.mu.Lock() defer ip.mu.Unlock() ip.m[name] = acc } // clear marks the name as no longer in progress func (ip *inProgress) clear(name string) { ip.mu.Lock() defer ip.mu.Unlock() delete(ip.m, name) } // get gets the account for name, of nil if not found func (ip *inProgress) get(name string) *Account { ip.mu.Lock() defer ip.mu.Unlock() return ip.m[name] } // merge adds items from another inProgress func (ip *inProgress) merge(m *inProgress) { ip.mu.Lock() defer ip.mu.Unlock() m.mu.Lock() defer m.mu.Unlock() maps.Copy(ip.m, m.m) } rclone-v1.71.0/fs/accounting/prometheus.go000066400000000000000000000100001505210326400205210ustar00rootroot00000000000000package accounting import ( "context" "github.com/prometheus/client_golang/prometheus" ) var namespace = "rclone_" // RcloneCollector is a Prometheus collector for Rclone type RcloneCollector struct { ctx context.Context bytesTransferred *prometheus.Desc transferSpeed *prometheus.Desc numOfErrors *prometheus.Desc numOfCheckFiles *prometheus.Desc transferredFiles *prometheus.Desc deletes *prometheus.Desc deletedDirs *prometheus.Desc renames *prometheus.Desc listed *prometheus.Desc fatalError *prometheus.Desc retryError *prometheus.Desc } // NewRcloneCollector make a new RcloneCollector func NewRcloneCollector(ctx context.Context) *RcloneCollector { return &RcloneCollector{ ctx: ctx, bytesTransferred: prometheus.NewDesc(namespace+"bytes_transferred_total", "Total transferred bytes since the start of the Rclone process", nil, nil, ), transferSpeed: prometheus.NewDesc(namespace+"speed", "Average speed in bytes per second since the start of the Rclone process", nil, nil, ), numOfErrors: prometheus.NewDesc(namespace+"errors_total", "Number of errors thrown", nil, nil, ), numOfCheckFiles: prometheus.NewDesc(namespace+"checked_files_total", "Number of checked files", nil, nil, ), transferredFiles: prometheus.NewDesc(namespace+"files_transferred_total", "Number of transferred files", nil, nil, ), deletes: prometheus.NewDesc(namespace+"files_deleted_total", "Total number of files deleted", nil, nil, ), deletedDirs: prometheus.NewDesc(namespace+"dirs_deleted_total", "Total number of directories deleted", nil, nil, ), renames: prometheus.NewDesc(namespace+"files_renamed_total", "Total number of files renamed", nil, nil, ), listed: prometheus.NewDesc(namespace+"entries_listed_total", "Total number of entries listed", nil, nil, ), fatalError: prometheus.NewDesc(namespace+"fatal_error", "Whether a fatal error has occurred", nil, nil, ), retryError: prometheus.NewDesc(namespace+"retry_error", "Whether there has been an error that will be retried", nil, nil, ), } } // Describe is part of the Collector interface: https://godoc.org/github.com/prometheus/client_golang/prometheus#Collector func (c *RcloneCollector) Describe(ch chan<- *prometheus.Desc) { ch <- c.bytesTransferred ch <- c.transferSpeed ch <- c.numOfErrors ch <- c.numOfCheckFiles ch <- c.transferredFiles ch <- c.deletes ch <- c.deletedDirs ch <- c.renames ch <- c.listed ch <- c.fatalError ch <- c.retryError } // Collect is part of the Collector interface: https://godoc.org/github.com/prometheus/client_golang/prometheus#Collector func (c *RcloneCollector) Collect(ch chan<- prometheus.Metric) { s := groups.sum(c.ctx) s.mu.RLock() ch <- prometheus.MustNewConstMetric(c.bytesTransferred, prometheus.CounterValue, float64(s.bytes)) ch <- prometheus.MustNewConstMetric(c.transferSpeed, prometheus.GaugeValue, s._speed()) ch <- prometheus.MustNewConstMetric(c.numOfErrors, prometheus.CounterValue, float64(s.errors)) ch <- prometheus.MustNewConstMetric(c.numOfCheckFiles, prometheus.CounterValue, float64(s.checks)) ch <- prometheus.MustNewConstMetric(c.transferredFiles, prometheus.CounterValue, float64(s.transfers)) ch <- prometheus.MustNewConstMetric(c.deletes, prometheus.CounterValue, float64(s.deletes)) ch <- prometheus.MustNewConstMetric(c.deletedDirs, prometheus.CounterValue, float64(s.deletedDirs)) ch <- prometheus.MustNewConstMetric(c.renames, prometheus.CounterValue, float64(s.renames)) ch <- prometheus.MustNewConstMetric(c.listed, prometheus.CounterValue, float64(s.listed)) ch <- prometheus.MustNewConstMetric(c.fatalError, prometheus.GaugeValue, bool2Float(s.fatalError)) ch <- prometheus.MustNewConstMetric(c.retryError, prometheus.GaugeValue, bool2Float(s.retryError)) s.mu.RUnlock() } // bool2Float is a small function to convert a boolean into a float64 value that can be used for Prometheus func bool2Float(e bool) float64 { if e { return 1 } return 0 } rclone-v1.71.0/fs/accounting/stats.go000066400000000000000000000575641505210326400175160ustar00rootroot00000000000000package accounting import ( "bytes" "context" "errors" "fmt" "slices" "sort" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/rc" "github.com/rclone/rclone/lib/terminal" ) const ( averagePeriodLength = time.Second averageStopAfter = time.Minute ) // MaxCompletedTransfers specifies maximum number of completed transfers in startedTransfers list var MaxCompletedTransfers = 100 // StatsInfo accounts all transfers // N.B.: if this struct is modified, please remember to also update sum() function in stats_groups // to correctly count the updated fields type StatsInfo struct { mu sync.RWMutex ctx context.Context ci *fs.ConfigInfo bytes int64 errors int64 lastError error fatalError bool retryError bool retryAfter time.Time checks int64 checking *transferMap checkQueue int checkQueueSize int64 transfers int64 transferring *transferMap transferQueue int transferQueueSize int64 listed int64 renames int64 renameQueue int renameQueueSize int64 deletes int64 deletesSize int64 deletedDirs int64 inProgress *inProgress startedTransfers []*Transfer // currently active transfers oldTimeRanges timeRanges // a merged list of time ranges for the transfers oldDuration time.Duration // duration of transfers we have culled group string startTime time.Time // the moment these stats were initialized or reset average averageValues serverSideCopies int64 serverSideCopyBytes int64 serverSideMoves int64 serverSideMoveBytes int64 } type averageValues struct { mu sync.Mutex period float64 lpBytes int64 lpTime time.Time speed float64 cancel context.CancelFunc stopped sync.WaitGroup started bool } // NewStats creates an initialised StatsInfo func NewStats(ctx context.Context) *StatsInfo { ci := fs.GetConfig(ctx) s := &StatsInfo{ ctx: ctx, ci: ci, checking: newTransferMap(ci.Checkers, "checking"), transferring: newTransferMap(ci.Transfers, "transferring"), inProgress: newInProgress(ctx), startTime: time.Now(), average: averageValues{}, } return s } // RemoteStats returns stats for rc // // If short is true then the transfers and checkers won't be added. func (s *StatsInfo) RemoteStats(short bool) (out rc.Params, err error) { // NB if adding values here - make sure you update the docs in // stats_groups.go out = make(rc.Params) ts := s.calculateTransferStats() out["totalChecks"] = ts.totalChecks out["totalTransfers"] = ts.totalTransfers out["totalBytes"] = ts.totalBytes out["transferTime"] = ts.transferTime out["speed"] = ts.speed s.mu.RLock() out["bytes"] = s.bytes out["errors"] = s.errors out["fatalError"] = s.fatalError out["retryError"] = s.retryError out["checks"] = s.checks out["transfers"] = s.transfers out["deletes"] = s.deletes out["deletedDirs"] = s.deletedDirs out["renames"] = s.renames out["listed"] = s.listed out["elapsedTime"] = time.Since(s.startTime).Seconds() out["serverSideCopies"] = s.serverSideCopies out["serverSideCopyBytes"] = s.serverSideCopyBytes out["serverSideMoves"] = s.serverSideMoves out["serverSideMoveBytes"] = s.serverSideMoveBytes eta, etaOK := eta(s.bytes, ts.totalBytes, ts.speed) if etaOK { out["eta"] = eta.Seconds() } else { out["eta"] = nil } s.mu.RUnlock() if !short && !s.checking.empty() { out["checking"] = s.checking.remotes() } if !short && !s.transferring.empty() { out["transferring"] = s.transferring.rcStats(s.inProgress) } if s.errors > 0 { out["lastError"] = s.lastError.Error() } return out, nil } // _speed returns the average speed of the transfer in bytes/second // // Call with lock held func (s *StatsInfo) _speed() float64 { return s.average.speed } // timeRange is a start and end time of a transfer type timeRange struct { start time.Time end time.Time } // timeRanges is a list of non-overlapping start and end times for // transfers type timeRanges []timeRange // merge all the overlapping time ranges func (trs *timeRanges) merge() { Trs := *trs // Sort by the starting time. sort.Slice(Trs, func(i, j int) bool { return Trs[i].start.Before(Trs[j].start) }) // Merge overlaps and add distinctive ranges together var ( newTrs = Trs[:0] i, j = 0, 1 ) for i < len(Trs) { if j < len(Trs) { if !Trs[i].end.Before(Trs[j].start) { if Trs[i].end.Before(Trs[j].end) { Trs[i].end = Trs[j].end } j++ continue } } newTrs = append(newTrs, Trs[i]) i = j j++ } *trs = newTrs } // cull remove any ranges whose start and end are before cutoff // returning their duration sum func (trs *timeRanges) cull(cutoff time.Time) (d time.Duration) { var newTrs = (*trs)[:0] for _, tr := range *trs { if cutoff.Before(tr.start) || cutoff.Before(tr.end) { newTrs = append(newTrs, tr) } else { d += tr.end.Sub(tr.start) } } *trs = newTrs return d } // total the time out of the time ranges func (trs timeRanges) total() (total time.Duration) { for _, tr := range trs { total += tr.end.Sub(tr.start) } return total } // Total duration is union of durations of all transfers belonging to this // object. // // Needs to be protected by mutex. func (s *StatsInfo) _totalDuration() time.Duration { // copy of s.oldTimeRanges with extra room for the current transfers timeRanges := make(timeRanges, len(s.oldTimeRanges), len(s.oldTimeRanges)+len(s.startedTransfers)) copy(timeRanges, s.oldTimeRanges) // Extract time ranges of all transfers. now := time.Now() for i := range s.startedTransfers { start, end := s.startedTransfers[i].TimeRange() if end.IsZero() { end = now } timeRanges = append(timeRanges, timeRange{start, end}) } timeRanges.merge() return s.oldDuration + timeRanges.total() } const ( etaMaxSeconds = (1<<63 - 1) / int64(time.Second) // Largest possible ETA as number of seconds etaMax = time.Duration(etaMaxSeconds) * time.Second // Largest possible ETA, which is in second precision, representing "292y24w3d23h47m16s" ) // eta returns the ETA of the current operation, // rounded to full seconds. // If the ETA cannot be determined 'ok' returns false. func eta(size, total int64, rate float64) (eta time.Duration, ok bool) { if total <= 0 || size < 0 || rate <= 0 { return 0, false } remaining := total - size if remaining < 0 { return 0, false } seconds := int64(float64(remaining) / rate) if seconds < 0 { // Got Int64 overflow eta = etaMax } else if seconds >= etaMaxSeconds { // Would get Int64 overflow if converting from seconds to Duration (nanoseconds) eta = etaMax } else { eta = time.Duration(seconds) * time.Second } return eta, true } // etaString returns the ETA of the current operation, // rounded to full seconds. // If the ETA cannot be determined it returns "-" func etaString(done, total int64, rate float64) string { d, ok := eta(done, total, rate) if !ok { return "-" } if d == etaMax { return "-" } return fs.Duration(d).ShortReadableString() } // percent returns a/b as a percentage rounded to the nearest integer // as a string // // if the percentage is invalid it returns "-" func percent(a int64, b int64) string { if a < 0 || b <= 0 { return "-" } return fmt.Sprintf("%d%%", int(float64(a)*100/float64(b)+0.5)) } // returned from calculateTransferStats type transferStats struct { totalChecks int64 totalTransfers int64 totalBytes int64 transferTime float64 speed float64 } // calculateTransferStats calculates some additional transfer stats not // stored directly in StatsInfo func (s *StatsInfo) calculateTransferStats() (ts transferStats) { // checking and transferring have their own locking so read // here before lock to prevent deadlock on GetBytes transferring, checking := s.transferring.count(), s.checking.count() transferringBytesDone, transferringBytesTotal := s.transferring.progress(s) s.mu.RLock() defer s.mu.RUnlock() ts.totalChecks = int64(s.checkQueue) + s.checks + int64(checking) ts.totalTransfers = int64(s.transferQueue) + s.transfers + int64(transferring) // note that s.bytes already includes transferringBytesDone so // we take it off here to avoid double counting ts.totalBytes = s.transferQueueSize + s.bytes + transferringBytesTotal - transferringBytesDone s.average.mu.Lock() ts.speed = s.average.speed s.average.mu.Unlock() dt := s._totalDuration() ts.transferTime = dt.Seconds() return ts } func (s *StatsInfo) averageLoop(ctx context.Context) { ticker := time.NewTicker(averagePeriodLength) defer ticker.Stop() a := &s.average defer a.stopped.Done() for { select { case now := <-ticker.C: a.mu.Lock() avg := 0.0 elapsed := now.Sub(a.lpTime).Seconds() if elapsed > 0 { avg = float64(a.lpBytes) / elapsed } if a.period < averagePeriod { a.period++ } a.speed = (avg + a.speed*(a.period-1)) / a.period a.lpBytes = 0 a.lpTime = now a.mu.Unlock() case <-ctx.Done(): // Stop the loop return } } } // Start the average loop // // Call with the mutex held func (s *StatsInfo) _startAverageLoop() { if !s.average.started { ctx, cancel := context.WithCancel(context.Background()) s.average.cancel = cancel s.average.started = true s.average.stopped.Add(1) s.average.lpTime = time.Now() go s.averageLoop(ctx) } } // Start the average loop func (s *StatsInfo) startAverageLoop() { s.mu.Lock() defer s.mu.Unlock() s._startAverageLoop() } // Stop the average loop // // Call with the mutex held func (s *StatsInfo) _stopAverageLoop() { if s.average.started { s.average.cancel() s.average.stopped.Wait() s.average.started = false } } // String convert the StatsInfo to a string for printing func (s *StatsInfo) String() string { // NB if adding more stats in here, remember to add them into // RemoteStats() too. ts := s.calculateTransferStats() s.mu.RLock() var ( buf = &bytes.Buffer{} xfrchkString = "" dateString = "" elapsedTime = time.Since(s.startTime) elapsedTimeSecondsOnly = elapsedTime.Truncate(time.Second/10) % time.Minute displaySpeedString string ) if s.ci.DataRateUnit == "bits" { displaySpeedString = fs.SizeSuffix(ts.speed * 8).BitRateUnit() } else { displaySpeedString = fs.SizeSuffix(ts.speed).ByteRateUnit() } if !s.ci.StatsOneLine { _, _ = fmt.Fprintf(buf, "\nTransferred: ") } else { xfrchk := []string{} if ts.totalTransfers > 0 && s.transferQueue > 0 { xfrchk = append(xfrchk, fmt.Sprintf("xfr#%d/%d", s.transfers, ts.totalTransfers)) } if ts.totalChecks > 0 && s.checkQueue > 0 { xfrchk = append(xfrchk, fmt.Sprintf("chk#%d/%d", s.checks, ts.totalChecks)) } if len(xfrchk) > 0 { xfrchkString = fmt.Sprintf(" (%s)", strings.Join(xfrchk, ", ")) } if s.ci.StatsOneLineDate { t := time.Now() dateString = t.Format(s.ci.StatsOneLineDateFormat) // Including the separator so people can customize it } } _, _ = fmt.Fprintf(buf, "%s%13s / %s, %s, %s, ETA %s%s", dateString, fs.SizeSuffix(s.bytes).ByteUnit(), fs.SizeSuffix(ts.totalBytes).ByteUnit(), percent(s.bytes, ts.totalBytes), displaySpeedString, etaString(s.bytes, ts.totalBytes, ts.speed), xfrchkString, ) if s.ci.ProgressTerminalTitle { // Writes ETA to the terminal title terminal.WriteTerminalTitle("ETA: " + etaString(s.bytes, ts.totalBytes, ts.speed)) } if !s.ci.StatsOneLine { _, _ = buf.WriteRune('\n') errorDetails := "" switch { case s.fatalError: errorDetails = " (fatal error encountered)" case s.retryError: errorDetails = " (retrying may help)" case s.errors != 0: errorDetails = " (no need to retry)" } // Add only non zero stats if s.errors != 0 { _, _ = fmt.Fprintf(buf, "Errors: %10d%s\n", s.errors, errorDetails) } if s.checks != 0 || ts.totalChecks != 0 || s.listed != 0 { _, _ = fmt.Fprintf(buf, "Checks: %10d / %d, %s, Listed %d\n", s.checks, ts.totalChecks, percent(s.checks, ts.totalChecks), s.listed) } if s.deletes != 0 || s.deletedDirs != 0 { _, _ = fmt.Fprintf(buf, "Deleted: %10d (files), %d (dirs), %s (freed)\n", s.deletes, s.deletedDirs, fs.SizeSuffix(s.deletesSize).ByteUnit()) } if s.renames != 0 { _, _ = fmt.Fprintf(buf, "Renamed: %10d\n", s.renames) } if s.transfers != 0 || ts.totalTransfers != 0 { _, _ = fmt.Fprintf(buf, "Transferred: %10d / %d, %s\n", s.transfers, ts.totalTransfers, percent(s.transfers, ts.totalTransfers)) } if s.serverSideCopies != 0 || s.serverSideCopyBytes != 0 { _, _ = fmt.Fprintf(buf, "Server Side Copies:%6d @ %s\n", s.serverSideCopies, fs.SizeSuffix(s.serverSideCopyBytes).ByteUnit(), ) } if s.serverSideMoves != 0 || s.serverSideMoveBytes != 0 { _, _ = fmt.Fprintf(buf, "Server Side Moves:%7d @ %s\n", s.serverSideMoves, fs.SizeSuffix(s.serverSideMoveBytes).ByteUnit(), ) } _, _ = fmt.Fprintf(buf, "Elapsed time: %10ss\n", strings.TrimRight(fs.Duration(elapsedTime.Truncate(time.Minute)).ReadableString(), "0s")+fmt.Sprintf("%.1f", elapsedTimeSecondsOnly.Seconds())) } // checking and transferring have their own locking so unlock // here to prevent deadlock on GetBytes s.mu.RUnlock() // Add per transfer stats if required if !s.ci.StatsOneLine { if !s.checking.empty() { _, _ = fmt.Fprintf(buf, "Checking:\n%s\n", s.checking.String(s.ctx, s.inProgress, s.transferring)) } if !s.transferring.empty() { _, _ = fmt.Fprintf(buf, "Transferring:\n%s\n", s.transferring.String(s.ctx, s.inProgress, nil)) } } return buf.String() } // Transferred returns list of all completed transfers including checked and // failed ones. func (s *StatsInfo) Transferred() []TransferSnapshot { s.mu.RLock() defer s.mu.RUnlock() ts := make([]TransferSnapshot, 0, len(s.startedTransfers)) for _, tr := range s.startedTransfers { if tr.IsDone() { ts = append(ts, tr.Snapshot()) } } return ts } // Log outputs the StatsInfo to the log func (s *StatsInfo) Log() { if s.ci.UseJSONLog { out, _ := s.RemoteStats(false) fs.LogLevelPrintf(s.ci.StatsLogLevel, nil, "%v%v\n", s, fs.LogValueHide("stats", out)) } else { fs.LogLevelPrintf(s.ci.StatsLogLevel, nil, "%v\n", s) } } // Bytes updates the stats for bytes bytes func (s *StatsInfo) Bytes(bytes int64) { s.average.mu.Lock() s.average.lpBytes += bytes s.average.mu.Unlock() s.mu.Lock() defer s.mu.Unlock() s.bytes += bytes } // BytesNoNetwork updates the stats for bytes bytes but doesn't include the transfer stats func (s *StatsInfo) BytesNoNetwork(bytes int64) { s.mu.Lock() defer s.mu.Unlock() s.bytes += bytes } // GetBytes returns the number of bytes transferred so far func (s *StatsInfo) GetBytes() int64 { s.mu.RLock() defer s.mu.RUnlock() return s.bytes } // GetBytesWithPending returns the number of bytes transferred and remaining transfers func (s *StatsInfo) GetBytesWithPending() int64 { s.mu.RLock() defer s.mu.RUnlock() pending := int64(0) for _, tr := range s.startedTransfers { if tr.acc != nil { bytesRead, size := tr.acc.progress() if bytesRead < size { pending += size - bytesRead } } } return s.bytes + pending } // Errors updates the stats for errors func (s *StatsInfo) Errors(errors int64) { s.mu.Lock() defer s.mu.Unlock() s.errors += errors } // GetErrors reads the number of errors func (s *StatsInfo) GetErrors() int64 { s.mu.RLock() defer s.mu.RUnlock() return s.errors } // GetLastError returns the lastError func (s *StatsInfo) GetLastError() error { s.mu.RLock() defer s.mu.RUnlock() return s.lastError } // GetChecks returns the number of checks func (s *StatsInfo) GetChecks() int64 { s.mu.RLock() defer s.mu.RUnlock() return s.checks } // FatalError sets the fatalError flag func (s *StatsInfo) FatalError() { s.mu.Lock() defer s.mu.Unlock() s.fatalError = true } // HadFatalError returns whether there has been at least one FatalError func (s *StatsInfo) HadFatalError() bool { s.mu.RLock() defer s.mu.RUnlock() return s.fatalError } // RetryError sets the retryError flag func (s *StatsInfo) RetryError() { s.mu.Lock() defer s.mu.Unlock() s.retryError = true } // HadRetryError returns whether there has been at least one non-NoRetryError func (s *StatsInfo) HadRetryError() bool { s.mu.RLock() defer s.mu.RUnlock() return s.retryError } var ( errMaxDelete = fserrors.FatalError(errors.New("--max-delete threshold reached")) errMaxDeleteSize = fserrors.FatalError(errors.New("--max-delete-size threshold reached")) ) // DeleteFile updates the stats for deleting a file // // It may return fatal errors if the threshold for --max-delete or // --max-delete-size have been reached. func (s *StatsInfo) DeleteFile(ctx context.Context, size int64) error { ci := fs.GetConfig(ctx) s.mu.Lock() defer s.mu.Unlock() if size < 0 { size = 0 } if ci.MaxDelete >= 0 && s.deletes+1 > ci.MaxDelete { return errMaxDelete } if ci.MaxDeleteSize >= 0 && s.deletesSize+size > int64(ci.MaxDeleteSize) { return errMaxDeleteSize } s.deletes++ s.deletesSize += size return nil } // GetDeletes returns the number of deletes func (s *StatsInfo) GetDeletes() int64 { s.mu.Lock() defer s.mu.Unlock() return s.deletes } // DeletedDirs updates the stats for deletedDirs func (s *StatsInfo) DeletedDirs(deletedDirs int64) int64 { s.mu.Lock() defer s.mu.Unlock() s.deletedDirs += deletedDirs return s.deletedDirs } // Renames updates the stats for renames func (s *StatsInfo) Renames(renames int64) int64 { s.mu.Lock() defer s.mu.Unlock() s.renames += renames return s.renames } // Listed updates the stats for listed objects func (s *StatsInfo) Listed(listed int64) int64 { s.mu.Lock() defer s.mu.Unlock() s.listed += listed return s.listed } // ResetCounters sets the counters (bytes, checks, errors, transfers, deletes, renames, listed) to 0 and resets lastError, fatalError and retryError func (s *StatsInfo) ResetCounters() { s.mu.Lock() defer s.mu.Unlock() s.bytes = 0 s.errors = 0 s.lastError = nil s.fatalError = false s.retryError = false s.retryAfter = time.Time{} s.checks = 0 s.transfers = 0 s.deletes = 0 s.deletesSize = 0 s.deletedDirs = 0 s.renames = 0 s.listed = 0 s.startedTransfers = nil s.oldDuration = 0 s._stopAverageLoop() s.average = averageValues{} s._startAverageLoop() } // ResetErrors sets the errors count to 0 and resets lastError, fatalError and retryError func (s *StatsInfo) ResetErrors() { s.mu.Lock() defer s.mu.Unlock() s.errors = 0 s.lastError = nil s.fatalError = false s.retryError = false s.retryAfter = time.Time{} } // Errored returns whether there have been any errors func (s *StatsInfo) Errored() bool { s.mu.RLock() defer s.mu.RUnlock() return s.errors != 0 } // Error adds a single error into the stats, assigns lastError and eventually sets fatalError or retryError func (s *StatsInfo) Error(err error) error { if err == nil || fserrors.IsCounted(err) { return err } s.mu.Lock() defer s.mu.Unlock() s.errors++ s.lastError = err err = fserrors.FsError(err) fserrors.Count(err) switch { case fserrors.IsFatalError(err): s.fatalError = true case fserrors.IsRetryAfterError(err): retryAfter := fserrors.RetryAfterErrorTime(err) if s.retryAfter.IsZero() || retryAfter.Sub(s.retryAfter) > 0 { s.retryAfter = retryAfter } s.retryError = true case !fserrors.IsNoRetryError(err): s.retryError = true } return err } // RetryAfter returns the time to retry after if it is set. It will // be Zero if it isn't set. func (s *StatsInfo) RetryAfter() time.Time { s.mu.Lock() defer s.mu.Unlock() return s.retryAfter } // NewCheckingTransfer adds a checking transfer to the stats, from the object. func (s *StatsInfo) NewCheckingTransfer(obj fs.DirEntry, what string) *Transfer { tr := newCheckingTransfer(s, obj, what) s.checking.add(tr) return tr } // DoneChecking removes a check from the stats func (s *StatsInfo) DoneChecking(remote string) { s.checking.del(remote) s.mu.Lock() s.checks++ s.mu.Unlock() } // GetTransfers reads the number of transfers func (s *StatsInfo) GetTransfers() int64 { s.mu.RLock() defer s.mu.RUnlock() return s.transfers } // NewTransfer adds a transfer to the stats from the object. // // The obj is uses as the srcFs, the dstFs must be supplied func (s *StatsInfo) NewTransfer(obj fs.DirEntry, dstFs fs.Fs) *Transfer { var srcFs fs.Fs if oi, ok := obj.(fs.ObjectInfo); ok { if f, ok := oi.Fs().(fs.Fs); ok { srcFs = f } } tr := newTransfer(s, obj, srcFs, dstFs) s.transferring.add(tr) s.startAverageLoop() return tr } // NewTransferRemoteSize adds a transfer to the stats based on remote and size. func (s *StatsInfo) NewTransferRemoteSize(remote string, size int64, srcFs, dstFs fs.Fs) *Transfer { tr := newTransferRemoteSize(s, remote, size, false, "", srcFs, dstFs) s.transferring.add(tr) s.startAverageLoop() return tr } // DoneTransferring removes a transfer from the stats // // if ok is true and it was in the transfermap (to avoid incrementing in case of nested calls, #6213) then it increments the transfers count func (s *StatsInfo) DoneTransferring(remote string, ok bool) { existed := s.transferring.del(remote) if ok && existed { s.mu.Lock() s.transfers++ s.mu.Unlock() } if s.transferring.empty() && s.checking.empty() { s.mu.Lock() s._stopAverageLoop() s.mu.Unlock() } } // SetCheckQueue sets the number of queued checks func (s *StatsInfo) SetCheckQueue(n int, size int64) { s.mu.Lock() s.checkQueue = n s.checkQueueSize = size s.mu.Unlock() } // SetTransferQueue sets the number of queued transfers func (s *StatsInfo) SetTransferQueue(n int, size int64) { s.mu.Lock() s.transferQueue = n s.transferQueueSize = size s.mu.Unlock() } // SetRenameQueue sets the number of queued transfers func (s *StatsInfo) SetRenameQueue(n int, size int64) { s.mu.Lock() s.renameQueue = n s.renameQueueSize = size s.mu.Unlock() } // AddTransfer adds reference to the started transfer. func (s *StatsInfo) AddTransfer(transfer *Transfer) { s.mu.Lock() s.startedTransfers = append(s.startedTransfers, transfer) s.mu.Unlock() } // _removeTransfer removes a reference to the started transfer in // position i. // // Must be called with the lock held func (s *StatsInfo) _removeTransfer(transfer *Transfer, i int) { now := time.Now() // add finished transfer onto old time ranges start, end := transfer.TimeRange() if end.IsZero() { end = now } s.oldTimeRanges = append(s.oldTimeRanges, timeRange{start, end}) s.oldTimeRanges.merge() // remove the found entry s.startedTransfers = slices.Delete(s.startedTransfers, i, i+1) // Find youngest active transfer oldestStart := now for i := range s.startedTransfers { start, _ := s.startedTransfers[i].TimeRange() if start.Before(oldestStart) { oldestStart = start } } // remove old entries older than that s.oldDuration += s.oldTimeRanges.cull(oldestStart) } // RemoveTransfer removes a reference to the started transfer. func (s *StatsInfo) RemoveTransfer(transfer *Transfer) { s.mu.Lock() for i, tr := range s.startedTransfers { if tr == transfer { s._removeTransfer(tr, i) break } } s.mu.Unlock() } // PruneTransfers makes sure there aren't too many old transfers by removing // single finished transfer. func (s *StatsInfo) PruneTransfers() { if MaxCompletedTransfers < 0 { return } s.mu.Lock() // remove a transfer from the start if we are over quota if len(s.startedTransfers) > MaxCompletedTransfers+s.ci.Transfers { for i, tr := range s.startedTransfers { if tr.IsDone() { s._removeTransfer(tr, i) break } } } s.mu.Unlock() } // AddServerSideMove counts a server side move func (s *StatsInfo) AddServerSideMove(n int64) { s.mu.Lock() s.serverSideMoves += 1 s.serverSideMoveBytes += n s.mu.Unlock() } // AddServerSideCopy counts a server side copy func (s *StatsInfo) AddServerSideCopy(n int64) { s.mu.Lock() s.serverSideCopies += 1 s.serverSideCopyBytes += n s.mu.Unlock() } rclone-v1.71.0/fs/accounting/stats_groups.go000066400000000000000000000256071505210326400211060ustar00rootroot00000000000000package accounting import ( "context" "fmt" "sync" "github.com/rclone/rclone/fs/rc" "github.com/rclone/rclone/fs" ) const globalStats = "global_stats" var groups *statsGroups func init() { // Init stats container groups = newStatsGroups() } func rcListStats(ctx context.Context, in rc.Params) (rc.Params, error) { out := make(rc.Params) out["groups"] = groups.names() return out, nil } func init() { rc.Add(rc.Call{ Path: "core/group-list", Fn: rcListStats, Title: "Returns list of stats.", Help: ` This returns list of stats groups currently in memory. Returns the following values: ` + "```" + ` { "groups": an array of group names: [ "group1", "group2", ... ] } ` + "```" + ` `, }) } func rcRemoteStats(ctx context.Context, in rc.Params) (rc.Params, error) { // Check to see if we should filter by group. group, err := in.GetString("group") if rc.NotErrParamNotFound(err) { return rc.Params{}, err } short, _ := in.GetBool("short") if group != "" { return StatsGroup(ctx, group).RemoteStats(short) } return groups.sum(ctx).RemoteStats(short) } func init() { rc.Add(rc.Call{ Path: "core/stats", Fn: rcRemoteStats, Title: "Returns stats about current transfers.", Help: ` This returns all available stats: rclone rc core/stats If group is not provided then summed up stats for all groups will be returned. Parameters - group - name of the stats group (string, optional) - short - if true will not return the transferring and checking arrays (boolean, optional) Returns the following values: ` + "```" + ` { "bytes": total transferred bytes since the start of the group, "checks": number of files checked, "deletes" : number of files deleted, "elapsedTime": time in floating point seconds since rclone was started, "errors": number of errors, "eta": estimated time in seconds until the group completes, "fatalError": boolean whether there has been at least one fatal error, "lastError": last error string, "renames" : number of files renamed, "listed" : number of directory entries listed, "retryError": boolean showing whether there has been at least one non-NoRetryError, "serverSideCopies": number of server side copies done, "serverSideCopyBytes": number bytes server side copied, "serverSideMoves": number of server side moves done, "serverSideMoveBytes": number bytes server side moved, "speed": average speed in bytes per second since start of the group, "totalBytes": total number of bytes in the group, "totalChecks": total number of checks in the group, "totalTransfers": total number of transfers in the group, "transferTime" : total time spent on running jobs, "transfers": number of transferred files, "transferring": an array of currently active file transfers: [ { "bytes": total transferred bytes for this file, "eta": estimated time in seconds until file transfer completion "name": name of the file, "percentage": progress of the file transfer in percent, "speed": average speed over the whole transfer in bytes per second, "speedAvg": current speed in bytes per second as an exponentially weighted moving average, "size": size of the file in bytes } ], "checking": an array of names of currently active file checks [] } ` + "```" + ` Values for "transferring", "checking" and "lastError" are only assigned if data is available. The value for "eta" is null if an eta cannot be determined. `, }) } func rcTransferredStats(ctx context.Context, in rc.Params) (rc.Params, error) { // Check to see if we should filter by group. group, err := in.GetString("group") if rc.NotErrParamNotFound(err) { return rc.Params{}, err } out := make(rc.Params) if group != "" { out["transferred"] = StatsGroup(ctx, group).Transferred() } else { out["transferred"] = groups.sum(ctx).Transferred() } return out, nil } func init() { rc.Add(rc.Call{ Path: "core/transferred", Fn: rcTransferredStats, Title: "Returns stats about completed transfers.", Help: ` This returns stats about completed transfers: rclone rc core/transferred If group is not provided then completed transfers for all groups will be returned. Note only the last 100 completed transfers are returned. Parameters - group - name of the stats group (string) Returns the following values: ` + "```" + ` { "transferred": an array of completed transfers (including failed ones): [ { "name": name of the file, "size": size of the file in bytes, "bytes": total transferred bytes for this file, "checked": if the transfer is only checked (skipped, deleted), "what": the purpose of the transfer (transferring, deleting, checking, importing, hashing, merging, listing, moving, renaming), "timestamp": integer representing millisecond unix epoch, "error": string description of the error (empty if successful), "jobid": id of the job that this transfer belongs to } ] } ` + "```" + ` `, }) } func rcResetStats(ctx context.Context, in rc.Params) (rc.Params, error) { // Check to see if we should filter by group. group, err := in.GetString("group") if rc.NotErrParamNotFound(err) { return rc.Params{}, err } if group != "" { stats := groups.get(group) if stats == nil { return rc.Params{}, fmt.Errorf("group %q not found", group) } stats.ResetErrors() stats.ResetCounters() } else { groups.reset() } return rc.Params{}, nil } func init() { rc.Add(rc.Call{ Path: "core/stats-reset", Fn: rcResetStats, Title: "Reset stats.", Help: ` This clears counters, errors and finished transfers for all stats or specific stats group if group is provided. Parameters - group - name of the stats group (string) `, }) } func rcDeleteStats(ctx context.Context, in rc.Params) (rc.Params, error) { // Group name required because we only do single group. group, err := in.GetString("group") if rc.NotErrParamNotFound(err) { return rc.Params{}, err } if group != "" { groups.delete(group) } return rc.Params{}, nil } func init() { rc.Add(rc.Call{ Path: "core/stats-delete", Fn: rcDeleteStats, Title: "Delete stats group.", Help: ` This deletes entire stats group. Parameters - group - name of the stats group (string) `, }) } type statsGroupCtx int64 const statsGroupKey statsGroupCtx = 1 // WithStatsGroup returns copy of the parent context with assigned group. func WithStatsGroup(parent context.Context, group string) context.Context { return context.WithValue(parent, statsGroupKey, group) } // StatsGroupFromContext returns group from the context if it's available. // Returns false if group is empty. func StatsGroupFromContext(ctx context.Context) (string, bool) { statsGroup, ok := ctx.Value(statsGroupKey).(string) if statsGroup == "" { ok = false } return statsGroup, ok } // Stats gets stats by extracting group from context. func Stats(ctx context.Context) *StatsInfo { group, ok := StatsGroupFromContext(ctx) if !ok { return GlobalStats() } return StatsGroup(ctx, group) } // StatsGroup gets stats by group name. func StatsGroup(ctx context.Context, group string) *StatsInfo { stats := groups.get(group) if stats == nil { return NewStatsGroup(ctx, group) } return stats } // GlobalStats returns special stats used for global accounting. func GlobalStats() *StatsInfo { return StatsGroup(context.Background(), globalStats) } // NewStatsGroup creates new stats under named group. func NewStatsGroup(ctx context.Context, group string) *StatsInfo { stats := NewStats(ctx) stats.startAverageLoop() stats.group = group groups.set(ctx, group, stats) return stats } // statsGroups holds a synchronized map of stats type statsGroups struct { mu sync.Mutex m map[string]*StatsInfo order []string } // newStatsGroups makes a new statsGroups object func newStatsGroups() *statsGroups { return &statsGroups{ m: make(map[string]*StatsInfo), } } // set marks the stats as belonging to a group func (sg *statsGroups) set(ctx context.Context, group string, stats *StatsInfo) { sg.mu.Lock() defer sg.mu.Unlock() ci := fs.GetConfig(ctx) // Limit number of groups kept in memory. if len(sg.order) >= ci.MaxStatsGroups { group := sg.order[0] fs.Debugf(nil, "Max number of stats groups reached removing %s", group) delete(sg.m, group) r := (len(sg.order) - ci.MaxStatsGroups) + 1 sg.order = sg.order[r:] } // Exclude global stats from listing if group != globalStats { sg.order = append(sg.order, group) } sg.m[group] = stats } // get gets the stats for group, or nil if not found func (sg *statsGroups) get(group string) *StatsInfo { sg.mu.Lock() defer sg.mu.Unlock() stats, ok := sg.m[group] if !ok { return nil } return stats } func (sg *statsGroups) names() []string { sg.mu.Lock() defer sg.mu.Unlock() return sg.order } // sum returns aggregate stats that contains summation of all groups. func (sg *statsGroups) sum(ctx context.Context) *StatsInfo { startTime := GlobalStats().startTime sg.mu.Lock() defer sg.mu.Unlock() sum := NewStats(ctx) for _, stats := range sg.m { stats.mu.RLock() { sum.bytes += stats.bytes sum.errors += stats.errors if sum.lastError == nil && stats.lastError != nil { sum.lastError = stats.lastError } sum.fatalError = sum.fatalError || stats.fatalError sum.retryError = sum.retryError || stats.retryError if stats.retryAfter.After(sum.retryAfter) { // Update the retryAfter field only if it is a later date than the current one in the sum sum.retryAfter = stats.retryAfter } sum.checks += stats.checks sum.checking.merge(stats.checking) sum.checkQueue += stats.checkQueue sum.checkQueueSize += stats.checkQueueSize sum.transfers += stats.transfers sum.transferring.merge(stats.transferring) sum.transferQueueSize += stats.transferQueueSize sum.listed += stats.listed sum.renames += stats.renames sum.renameQueue += stats.renameQueue sum.renameQueueSize += stats.renameQueueSize sum.deletes += stats.deletes sum.deletedDirs += stats.deletedDirs sum.inProgress.merge(stats.inProgress) sum.startedTransfers = append(sum.startedTransfers, stats.startedTransfers...) sum.oldTimeRanges = append(sum.oldTimeRanges, stats.oldTimeRanges...) sum.oldDuration += stats.oldDuration stats.average.mu.Lock() sum.average.speed += stats.average.speed stats.average.mu.Unlock() } stats.mu.RUnlock() } sum.startTime = startTime return sum } func (sg *statsGroups) reset() { sg.mu.Lock() defer sg.mu.Unlock() for _, stats := range sg.m { stats.ResetErrors() stats.ResetCounters() } sg.m = make(map[string]*StatsInfo) sg.order = nil } // delete removes all references to the group. func (sg *statsGroups) delete(group string) { sg.mu.Lock() defer sg.mu.Unlock() stats := sg.m[group] if stats == nil { return } stats.ResetErrors() stats.ResetCounters() delete(sg.m, group) // Remove group reference from the ordering slice. tmp := sg.order[:0] for _, g := range sg.order { if g != group { tmp = append(tmp, g) } } sg.order = tmp } rclone-v1.71.0/fs/accounting/stats_groups_test.go000066400000000000000000000171041505210326400221360ustar00rootroot00000000000000package accounting import ( "context" "encoding/json" "fmt" "runtime" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/rc" "github.com/rclone/rclone/fstest/mockobject" "github.com/rclone/rclone/fstest/testy" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestStatsGroupOperations(t *testing.T) { ctx := context.Background() t.Run("empty group returns nil", func(t *testing.T) { t.Parallel() sg := newStatsGroups() sg.get("invalid-group") }) t.Run("set assigns stats to group", func(t *testing.T) { t.Parallel() stats := NewStats(ctx) sg := newStatsGroups() sg.set(ctx, "test", stats) sg.set(ctx, "test1", stats) if len(sg.m) != len(sg.names()) || len(sg.m) != 2 { t.Fatalf("Expected two stats got %d, %d", len(sg.m), len(sg.order)) } }) t.Run("get returns correct group", func(t *testing.T) { t.Parallel() stats := NewStats(ctx) sg := newStatsGroups() sg.set(ctx, "test", stats) sg.set(ctx, "test1", stats) got := sg.get("test") if got != stats { t.Fatal("get returns incorrect stats") } }) t.Run("sum returns correct values", func(t *testing.T) { t.Parallel() stats1 := NewStats(ctx) stats1.bytes = 5 stats1.transferQueueSize = 10 stats1.errors = 6 stats1.oldDuration = time.Second stats1.oldTimeRanges = []timeRange{{time.Now(), time.Now().Add(time.Second)}} stats2 := NewStats(ctx) stats2.bytes = 10 stats2.errors = 12 stats1.transferQueueSize = 20 stats2.oldDuration = 2 * time.Second stats2.oldTimeRanges = []timeRange{{time.Now(), time.Now().Add(2 * time.Second)}} sg := newStatsGroups() sg.set(ctx, "test1", stats1) sg.set(ctx, "test2", stats2) sum := sg.sum(ctx) assert.Equal(t, stats1.bytes+stats2.bytes, sum.bytes) assert.Equal(t, stats1.transferQueueSize+stats2.transferQueueSize, sum.transferQueueSize) assert.Equal(t, stats1.errors+stats2.errors, sum.errors) assert.Equal(t, stats1.oldDuration+stats2.oldDuration, sum.oldDuration) assert.Equal(t, stats1.average.speed+stats2.average.speed, sum.average.speed) // dict can iterate in either order a := timeRanges{stats1.oldTimeRanges[0], stats2.oldTimeRanges[0]} b := timeRanges{stats2.oldTimeRanges[0], stats1.oldTimeRanges[0]} if !assert.ObjectsAreEqual(a, sum.oldTimeRanges) { assert.Equal(t, b, sum.oldTimeRanges) } }) t.Run("delete removes stats", func(t *testing.T) { t.Parallel() stats := NewStats(ctx) sg := newStatsGroups() sg.set(ctx, "test", stats) sg.set(ctx, "test1", stats) sg.delete("test1") if sg.get("test1") != nil { t.Fatal("stats not deleted") } if len(sg.m) != len(sg.names()) || len(sg.m) != 1 { t.Fatalf("Expected two stats got %d, %d", len(sg.m), len(sg.order)) } }) t.Run("memory is reclaimed", func(t *testing.T) { testy.SkipUnreliable(t) var ( count = 1000 start, end runtime.MemStats sg = newStatsGroups() ) runtime.GC() runtime.ReadMemStats(&start) for i := range count { sg.set(ctx, fmt.Sprintf("test-%d", i), NewStats(ctx)) } for i := range count { sg.delete(fmt.Sprintf("test-%d", i)) } runtime.GC() runtime.ReadMemStats(&end) t.Logf("%+v\n%+v", start, end) diff := percentDiff(start.HeapObjects, end.HeapObjects) if diff > 1 { t.Errorf("HeapObjects = %d, expected %d", end.HeapObjects, start.HeapObjects) } }) testGroupStatsInfo := NewStatsGroup(ctx, "test-group") require.NoError(t, testGroupStatsInfo.DeleteFile(ctx, 0)) for range 41 { require.NoError(t, GlobalStats().DeleteFile(ctx, 0)) } t.Run("core/group-list", func(t *testing.T) { call := rc.Calls.Get("core/group-list") require.NotNil(t, call) got, err := call.Fn(ctx, rc.Params{}) require.NoError(t, err) require.Equal(t, rc.Params{ "groups": []string{ "test-group", }, }, got) }) t.Run("core/stats", func(t *testing.T) { tr := Stats(ctx).NewCheckingTransfer(mockobject.New("core-check"), "deleting") // defer tr.Done(ctx, nil) _ = tr // don't finish the transfer so we don't mess up the other tests tr2 := Stats(ctx).NewTransfer(mockobject.New("core-transfer"), nil) //defer tr2.Done(ctx, nil) _ = tr2 // don't finish the transfer so we don't mess up the other tests call := rc.Calls.Get("core/stats") require.NotNil(t, call) got, err := call.Fn(ctx, rc.Params{}) require.NoError(t, err) assert.Equal(t, int64(42), got["deletes"]) data, err := json.Marshal(got["transferring"]) require.NoError(t, err) assert.Contains(t, string(data), "core-transfer") data, err = json.Marshal(got["checking"]) require.NoError(t, err) assert.Contains(t, string(data), "core-check") got, err = call.Fn(ctx, rc.Params{"short": true}) require.NoError(t, err) assert.Equal(t, int64(42), got["deletes"]) assert.Nil(t, got["transferring"]) assert.Nil(t, got["checking"]) got, err = call.Fn(ctx, rc.Params{"group": "test-group"}) require.NoError(t, err) assert.Equal(t, int64(1), got["deletes"]) }) t.Run("core/transferred", func(t *testing.T) { call := rc.Calls.Get("core/transferred") require.NotNil(t, call) gotNoGroup, err := call.Fn(ctx, rc.Params{}) require.NoError(t, err) gotGroup, err := call.Fn(ctx, rc.Params{"group": "test-group"}) require.NoError(t, err) assert.Equal(t, rc.Params{ "transferred": []TransferSnapshot{}, }, gotNoGroup) assert.Equal(t, rc.Params{ "transferred": []TransferSnapshot{}, }, gotGroup) }) t.Run("core/stats-reset", func(t *testing.T) { call := rc.Calls.Get("core/stats-reset") require.NotNil(t, call) assert.Equal(t, int64(41), GlobalStats().deletes) assert.Equal(t, int64(1), testGroupStatsInfo.deletes) _, err := call.Fn(ctx, rc.Params{"group": "test-group"}) require.NoError(t, err) assert.Equal(t, int64(41), GlobalStats().deletes) assert.Equal(t, int64(0), testGroupStatsInfo.deletes) _, err = call.Fn(ctx, rc.Params{}) require.NoError(t, err) assert.Equal(t, int64(0), GlobalStats().deletes) assert.Equal(t, int64(0), testGroupStatsInfo.deletes) _, err = call.Fn(ctx, rc.Params{"group": "not-found"}) require.ErrorContains(t, err, `group "not-found" not found`) }) testGroupStatsInfo = NewStatsGroup(ctx, "test-group") t.Run("core/stats-delete", func(t *testing.T) { call := rc.Calls.Get("core/stats-delete") require.NotNil(t, call) assert.Equal(t, []string{"test-group"}, groups.names()) _, err := call.Fn(ctx, rc.Params{"group": "test-group"}) require.NoError(t, err) assert.Equal(t, []string{}, groups.names()) _, err = call.Fn(ctx, rc.Params{"group": "not-found"}) require.NoError(t, err) }) } func TestCountError(t *testing.T) { ctx := context.Background() Start(ctx) defer func() { groups = newStatsGroups() }() t.Run("global stats", func(t *testing.T) { GlobalStats().ResetCounters() err := fs.CountError(ctx, fmt.Errorf("global err")) assert.Equal(t, int64(1), GlobalStats().errors) assert.True(t, fserrors.IsCounted(err)) }) t.Run("group stats", func(t *testing.T) { statGroupName := fmt.Sprintf("%s-error_group", t.Name()) GlobalStats().ResetCounters() stCtx := WithStatsGroup(ctx, statGroupName) st := StatsGroup(stCtx, statGroupName) err := fs.CountError(stCtx, fmt.Errorf("group err")) assert.Equal(t, int64(0), GlobalStats().errors) assert.Equal(t, int64(1), st.errors) assert.True(t, fserrors.IsCounted(err)) }) } func percentDiff(start, end uint64) uint64 { if start == 0 { return 0 // Handle zero start value to avoid division by zero } var diff uint64 if end > start { diff = end - start // Handle case where end is larger than start } else { diff = start - end } return (diff * 100) / start } rclone-v1.71.0/fs/accounting/stats_test.go000066400000000000000000000333131505210326400205370ustar00rootroot00000000000000package accounting import ( "context" "fmt" "io" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fserrors" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestETA(t *testing.T) { for _, test := range []struct { size, total int64 rate float64 wantETA time.Duration wantOK bool wantString string }{ // Custom String Cases {size: 0, total: 365 * 86400, rate: 1.0, wantETA: 365 * 86400 * time.Second, wantOK: true, wantString: "1y"}, {size: 0, total: 7 * 86400, rate: 1.0, wantETA: 7 * 86400 * time.Second, wantOK: true, wantString: "1w"}, {size: 0, total: 1 * 86400, rate: 1.0, wantETA: 1 * 86400 * time.Second, wantOK: true, wantString: "1d"}, {size: 0, total: 1110 * 86400, rate: 1.0, wantETA: 1110 * 86400 * time.Second, wantOK: true, wantString: "3y2w1d"}, {size: 0, total: 15 * 86400, rate: 1.0, wantETA: 15 * 86400 * time.Second, wantOK: true, wantString: "2w1d"}, // Composite Custom String Cases {size: 0, total: 1.5 * 86400, rate: 1.0, wantETA: 1.5 * 86400 * time.Second, wantOK: true, wantString: "1d12h"}, {size: 0, total: 95000, rate: 1.0, wantETA: 95000 * time.Second, wantOK: true, wantString: "1d2h23m"}, // Short format, if full it would be "1d2h23m20s" // Standard Duration String Cases {size: 0, total: 1, rate: 2.0, wantETA: 0, wantOK: true, wantString: "0s"}, {size: 0, total: 1, rate: 1.0, wantETA: time.Second, wantOK: true, wantString: "1s"}, {size: 0, total: 1, rate: 0.5, wantETA: 2 * time.Second, wantOK: true, wantString: "2s"}, {size: 0, total: 100, rate: 1.0, wantETA: 100 * time.Second, wantOK: true, wantString: "1m40s"}, {size: 50, total: 100, rate: 1.0, wantETA: 50 * time.Second, wantOK: true, wantString: "50s"}, {size: 100, total: 100, rate: 1.0, wantETA: 0 * time.Second, wantOK: true, wantString: "0s"}, // No String Cases {size: -1, total: 100, rate: 1.0, wantETA: 0, wantOK: false, wantString: "-"}, {size: 200, total: 100, rate: 1.0, wantETA: 0, wantOK: false, wantString: "-"}, {size: 10, total: -1, rate: 1.0, wantETA: 0, wantOK: false, wantString: "-"}, {size: 10, total: 20, rate: 0.0, wantETA: 0, wantOK: false, wantString: "-"}, {size: 10, total: 20, rate: -1.0, wantETA: 0, wantOK: false, wantString: "-"}, {size: 0, total: 0, rate: 1.0, wantETA: 0, wantOK: false, wantString: "-"}, // Extreme Cases {size: 0, total: (1 << 63) - 1, rate: 1.0, wantETA: (time.Duration((1<<63)-1) / time.Second) * time.Second, wantOK: true, wantString: "-"}, {size: 0, total: ((1 << 63) - 1) / int64(time.Second), rate: 1.0, wantETA: (time.Duration((1<<63)-1) / time.Second) * time.Second, wantOK: true, wantString: "-"}, {size: 0, total: ((1<<63)-1)/int64(time.Second) - 1, rate: 1.0, wantETA: (time.Duration((1<<63)-1)/time.Second - 1) * time.Second, wantOK: true, wantString: "292y24w3d"}, // Short format, if full it would be "292y24w3d23h47m15s" {size: 0, total: ((1<<63)-1)/int64(time.Second) - 1, rate: 0.1, wantETA: (time.Duration((1<<63)-1) / time.Second) * time.Second, wantOK: true, wantString: "-"}, } { t.Run(fmt.Sprintf("size=%d/total=%d/rate=%f", test.size, test.total, test.rate), func(t *testing.T) { gotETA, gotOK := eta(test.size, test.total, test.rate) assert.Equal(t, int64(test.wantETA), int64(gotETA)) assert.Equal(t, test.wantOK, gotOK) gotString := etaString(test.size, test.total, test.rate) assert.Equal(t, test.wantString, gotString) }) } } func TestPercentage(t *testing.T) { assert.Equal(t, percent(0, 1000), "0%") assert.Equal(t, percent(1, 1000), "0%") assert.Equal(t, percent(9, 1000), "1%") assert.Equal(t, percent(500, 1000), "50%") assert.Equal(t, percent(1000, 1000), "100%") assert.Equal(t, percent(1e8, 1e9), "10%") assert.Equal(t, percent(1e8, 1e9), "10%") assert.Equal(t, percent(0, 0), "-") assert.Equal(t, percent(100, -100), "-") assert.Equal(t, percent(-100, 100), "-") assert.Equal(t, percent(-100, -100), "-") } func TestStatsError(t *testing.T) { ctx := context.Background() s := NewStats(ctx) assert.Equal(t, int64(0), s.GetErrors()) assert.False(t, s.HadFatalError()) assert.False(t, s.HadRetryError()) assert.Equal(t, time.Time{}, s.RetryAfter()) assert.Equal(t, nil, s.GetLastError()) assert.False(t, s.Errored()) t0 := time.Now() t1 := t0.Add(time.Second) _ = s.Error(nil) assert.Equal(t, int64(0), s.GetErrors()) assert.False(t, s.HadFatalError()) assert.False(t, s.HadRetryError()) assert.Equal(t, time.Time{}, s.RetryAfter()) assert.Equal(t, nil, s.GetLastError()) assert.False(t, s.Errored()) _ = s.Error(io.EOF) assert.Equal(t, int64(1), s.GetErrors()) assert.False(t, s.HadFatalError()) assert.True(t, s.HadRetryError()) assert.Equal(t, time.Time{}, s.RetryAfter()) assert.Equal(t, io.EOF, s.GetLastError()) assert.True(t, s.Errored()) e := fserrors.ErrorRetryAfter(t0) _ = s.Error(e) assert.Equal(t, int64(2), s.GetErrors()) assert.False(t, s.HadFatalError()) assert.True(t, s.HadRetryError()) assert.Equal(t, t0, s.RetryAfter()) assert.Equal(t, e, s.GetLastError()) err := fmt.Errorf("potato: %w", fserrors.ErrorRetryAfter(t1)) err = s.Error(err) assert.Equal(t, int64(3), s.GetErrors()) assert.False(t, s.HadFatalError()) assert.True(t, s.HadRetryError()) assert.Equal(t, t1, s.RetryAfter()) assert.Equal(t, t1, fserrors.RetryAfterErrorTime(err)) _ = s.Error(fserrors.FatalError(io.EOF)) assert.Equal(t, int64(4), s.GetErrors()) assert.True(t, s.HadFatalError()) assert.True(t, s.HadRetryError()) assert.Equal(t, t1, s.RetryAfter()) s.ResetErrors() assert.Equal(t, int64(0), s.GetErrors()) assert.False(t, s.HadFatalError()) assert.False(t, s.HadRetryError()) assert.Equal(t, time.Time{}, s.RetryAfter()) assert.Equal(t, nil, s.GetLastError()) assert.False(t, s.Errored()) _ = s.Error(fserrors.NoRetryError(io.EOF)) assert.Equal(t, int64(1), s.GetErrors()) assert.False(t, s.HadFatalError()) assert.False(t, s.HadRetryError()) assert.Equal(t, time.Time{}, s.RetryAfter()) } func TestStatsTotalDuration(t *testing.T) { ctx := context.Background() startTime := time.Now() time1 := startTime.Add(-40 * time.Second) time2 := time1.Add(10 * time.Second) time3 := time2.Add(10 * time.Second) time4 := time3.Add(10 * time.Second) t.Run("Single completed transfer", func(t *testing.T) { s := NewStats(ctx) tr1 := &Transfer{ startedAt: time1, completedAt: time2, } s.AddTransfer(tr1) s.mu.Lock() total := s._totalDuration() s.mu.Unlock() assert.Equal(t, 1, len(s.startedTransfers)) assert.Equal(t, 10*time.Second, total) s.RemoveTransfer(tr1) assert.Equal(t, 10*time.Second, total) assert.Equal(t, 0, len(s.startedTransfers)) }) t.Run("Single uncompleted transfer", func(t *testing.T) { s := NewStats(ctx) tr1 := &Transfer{ startedAt: time1, } s.AddTransfer(tr1) s.mu.Lock() total := s._totalDuration() s.mu.Unlock() assert.Equal(t, time.Since(time1)/time.Second, total/time.Second) s.RemoveTransfer(tr1) assert.Equal(t, time.Since(time1)/time.Second, total/time.Second) }) t.Run("Overlapping without ending", func(t *testing.T) { s := NewStats(ctx) tr1 := &Transfer{ startedAt: time2, completedAt: time3, } s.AddTransfer(tr1) tr2 := &Transfer{ startedAt: time2, completedAt: time2.Add(time.Second), } s.AddTransfer(tr2) tr3 := &Transfer{ startedAt: time1, completedAt: time3, } s.AddTransfer(tr3) tr4 := &Transfer{ startedAt: time3, completedAt: time4, } s.AddTransfer(tr4) tr5 := &Transfer{ startedAt: time.Now(), } s.AddTransfer(tr5) time.Sleep(time.Millisecond) s.mu.Lock() total := s._totalDuration() s.mu.Unlock() assert.Equal(t, time.Duration(30), total/time.Second) s.RemoveTransfer(tr1) assert.Equal(t, time.Duration(30), total/time.Second) s.RemoveTransfer(tr2) assert.Equal(t, time.Duration(30), total/time.Second) s.RemoveTransfer(tr3) assert.Equal(t, time.Duration(30), total/time.Second) s.RemoveTransfer(tr4) assert.Equal(t, time.Duration(30), total/time.Second) }) t.Run("Mixed completed and uncompleted transfers", func(t *testing.T) { s := NewStats(ctx) s.AddTransfer(&Transfer{ startedAt: time1, completedAt: time2, }) s.AddTransfer(&Transfer{ startedAt: time2, }) s.AddTransfer(&Transfer{ startedAt: time3, }) s.AddTransfer(&Transfer{ startedAt: time3, }) s.mu.Lock() total := s._totalDuration() s.mu.Unlock() assert.Equal(t, startTime.Sub(time1)/time.Second, total/time.Second) }) } func TestRemoteStats(t *testing.T) { ctx := context.Background() startTime := time.Now() time1 := startTime.Add(-40 * time.Second) time2 := time1.Add(10 * time.Second) t.Run("Single completed transfer", func(t *testing.T) { s := NewStats(ctx) tr1 := &Transfer{ startedAt: time1, completedAt: time2, } s.AddTransfer(tr1) time.Sleep(time.Millisecond) rs, err := s.RemoteStats(false) require.NoError(t, err) assert.Equal(t, float64(10), rs["transferTime"]) assert.Greater(t, rs["elapsedTime"], float64(0)) }) } // make time ranges from string description for testing func makeTimeRanges(t *testing.T, in []string) timeRanges { trs := make(timeRanges, len(in)) for i, Range := range in { var start, end int64 n, err := fmt.Sscanf(Range, "%d-%d", &start, &end) require.NoError(t, err) require.Equal(t, 2, n) trs[i] = timeRange{time.Unix(start, 0), time.Unix(end, 0)} } return trs } func (trs timeRanges) toStrings() (out []string) { out = []string{} for _, tr := range trs { out = append(out, fmt.Sprintf("%d-%d", tr.start.Unix(), tr.end.Unix())) } return out } func TestTimeRangeMerge(t *testing.T) { for _, test := range []struct { in []string want []string }{{ in: []string{}, want: []string{}, }, { in: []string{"1-2"}, want: []string{"1-2"}, }, { in: []string{"1-4", "2-3"}, want: []string{"1-4"}, }, { in: []string{"2-3", "1-4"}, want: []string{"1-4"}, }, { in: []string{"1-3", "2-4"}, want: []string{"1-4"}, }, { in: []string{"2-4", "1-3"}, want: []string{"1-4"}, }, { in: []string{"1-2", "2-3"}, want: []string{"1-3"}, }, { in: []string{"2-3", "1-2"}, want: []string{"1-3"}, }, { in: []string{"1-2", "3-4"}, want: []string{"1-2", "3-4"}, }, { in: []string{"1-3", "7-8", "4-6", "2-5", "7-8", "7-8"}, want: []string{"1-6", "7-8"}, }} { in := makeTimeRanges(t, test.in) in.merge() got := in.toStrings() assert.Equal(t, test.want, got) } } func TestTimeRangeCull(t *testing.T) { for _, test := range []struct { in []string cutoff int64 want []string wantDuration time.Duration }{{ in: []string{}, cutoff: 1, want: []string{}, wantDuration: 0 * time.Second, }, { in: []string{"1-2"}, cutoff: 1, want: []string{"1-2"}, wantDuration: 0 * time.Second, }, { in: []string{"2-5", "7-9"}, cutoff: 1, want: []string{"2-5", "7-9"}, wantDuration: 0 * time.Second, }, { in: []string{"2-5", "7-9"}, cutoff: 4, want: []string{"2-5", "7-9"}, wantDuration: 0 * time.Second, }, { in: []string{"2-5", "7-9"}, cutoff: 5, want: []string{"7-9"}, wantDuration: 3 * time.Second, }, { in: []string{"2-5", "7-9", "2-5", "2-5"}, cutoff: 6, want: []string{"7-9"}, wantDuration: 9 * time.Second, }, { in: []string{"7-9", "3-3", "2-5"}, cutoff: 7, want: []string{"7-9"}, wantDuration: 3 * time.Second, }, { in: []string{"2-5", "7-9"}, cutoff: 8, want: []string{"7-9"}, wantDuration: 3 * time.Second, }, { in: []string{"2-5", "7-9"}, cutoff: 9, want: []string{}, wantDuration: 5 * time.Second, }, { in: []string{"2-5", "7-9"}, cutoff: 10, want: []string{}, wantDuration: 5 * time.Second, }} { in := makeTimeRanges(t, test.in) cutoff := time.Unix(test.cutoff, 0) gotDuration := in.cull(cutoff) what := fmt.Sprintf("in=%q, cutoff=%d", test.in, test.cutoff) got := in.toStrings() assert.Equal(t, test.want, got, what) assert.Equal(t, test.wantDuration, gotDuration, what) } } func TestTimeRangeDuration(t *testing.T) { assert.Equal(t, 0*time.Second, timeRanges{}.total()) assert.Equal(t, 1*time.Second, makeTimeRanges(t, []string{"1-2"}).total()) assert.Equal(t, 91*time.Second, makeTimeRanges(t, []string{"1-2", "10-100"}).total()) } func TestPruneTransfers(t *testing.T) { ctx := context.Background() ci := fs.GetConfig(ctx) for _, test := range []struct { Name string Transfers int Limit int ExpectedStartedTransfers int }{ { Name: "Limited number of StartedTransfers", Limit: 100, Transfers: 200, ExpectedStartedTransfers: 100 + ci.Transfers, }, { Name: "Unlimited number of StartedTransfers", Limit: -1, Transfers: 200, ExpectedStartedTransfers: 200, }, } { t.Run(test.Name, func(t *testing.T) { prevLimit := MaxCompletedTransfers MaxCompletedTransfers = test.Limit defer func() { MaxCompletedTransfers = prevLimit }() s := NewStats(ctx) for i := int64(1); i <= int64(test.Transfers); i++ { s.AddTransfer(&Transfer{ startedAt: time.Unix(i, 0), completedAt: time.Unix(i+1, 0), }) } s.mu.Lock() assert.Equal(t, time.Duration(test.Transfers)*time.Second, s._totalDuration()) assert.Equal(t, test.Transfers, len(s.startedTransfers)) s.mu.Unlock() for range test.Transfers { s.PruneTransfers() } s.mu.Lock() assert.Equal(t, time.Duration(test.Transfers)*time.Second, s._totalDuration()) assert.Equal(t, test.ExpectedStartedTransfers, len(s.startedTransfers)) s.mu.Unlock() }) } } rclone-v1.71.0/fs/accounting/token_bucket.go000066400000000000000000000172321505210326400210210ustar00rootroot00000000000000package accounting import ( "context" "errors" "fmt" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/rc" "golang.org/x/time/rate" ) // TokenBucket holds the global token bucket limiter var TokenBucket tokenBucket // TokenBucketSlot is the type to select which token bucket to use type TokenBucketSlot int // Slots for the token bucket const ( TokenBucketSlotAccounting TokenBucketSlot = iota TokenBucketSlotTransportRx TokenBucketSlotTransportTx TokenBucketSlots ) type buckets [TokenBucketSlots]*rate.Limiter // tokenBucket holds info about the rate limiters in use type tokenBucket struct { mu sync.RWMutex // protects the token bucket variables curr buckets prev buckets toggledOff bool currLimit fs.BwTimeSlot } // Return true if limit is disabled // // Call with lock held func (bs *buckets) _isOff() bool { //nolint:unused // Don't include unused when running golangci-lint in case its on windows where this is not called for i := range bs { if bs[i] != nil { return false } } return true } // Disable the limits // // Call with lock held func (bs *buckets) _setOff() { for i := range bs { bs[i] = nil } } const defaultMaxBurstSize = 4 * 1024 * 1024 // must be bigger than the biggest request // make a new empty token bucket with the bandwidth given func newEmptyTokenBucket(bandwidth fs.SizeSuffix) *rate.Limiter { // Relate maxBurstSize to bandwidth limit // 4M gives 2.5 Gb/s on Windows // Use defaultMaxBurstSize up to 2GBit/s (256MiB/s) then scale maxBurstSize := max((bandwidth*defaultMaxBurstSize)/(256*1024*1024), defaultMaxBurstSize) // fs.Debugf(nil, "bandwidth=%v maxBurstSize=%v", bandwidth, maxBurstSize) tb := rate.NewLimiter(rate.Limit(bandwidth), int(maxBurstSize)) if tb != nil { // empty the bucket err := tb.WaitN(context.Background(), int(maxBurstSize)) if err != nil { fs.Errorf(nil, "Failed to empty token bucket: %v", err) } } return tb } // make a new empty token bucket with the bandwidth(s) given func newTokenBucket(bandwidth fs.BwPair) (tbs buckets) { bandwidthAccounting := fs.SizeSuffix(-1) if bandwidth.Tx > 0 { tbs[TokenBucketSlotTransportTx] = newEmptyTokenBucket(bandwidth.Tx) bandwidthAccounting = bandwidth.Tx } if bandwidth.Rx > 0 { tbs[TokenBucketSlotTransportRx] = newEmptyTokenBucket(bandwidth.Rx) if bandwidth.Rx > bandwidthAccounting { bandwidthAccounting = bandwidth.Rx } } // Limit core bandwidth to max of Rx and Tx if both are limited if bandwidth.Tx > 0 && bandwidth.Rx > 0 { tbs[TokenBucketSlotAccounting] = newEmptyTokenBucket(bandwidthAccounting) } return tbs } // StartTokenBucket starts the token bucket if necessary func (tb *tokenBucket) StartTokenBucket(ctx context.Context) { tb.mu.Lock() defer tb.mu.Unlock() ci := fs.GetConfig(ctx) tb.currLimit = ci.BwLimit.LimitAt(time.Now()) if tb.currLimit.Bandwidth.IsSet() { tb.curr = newTokenBucket(tb.currLimit.Bandwidth) fs.Infof(nil, "Starting bandwidth limiter at %v Byte/s", &tb.currLimit.Bandwidth) } // Start the SIGUSR2 signal handler to toggle bandwidth. // This function does nothing in windows systems. tb.startSignalHandler() } // StartTokenTicker creates a ticker to update the bandwidth limiter every minute. func (tb *tokenBucket) StartTokenTicker(ctx context.Context) { ci := fs.GetConfig(ctx) // If the timetable has a single entry or was not specified, we don't need // a ticker to update the bandwidth. if len(ci.BwLimit) <= 1 { return } ticker := time.NewTicker(time.Minute) go func() { for range ticker.C { limitNow := ci.BwLimit.LimitAt(time.Now()) tb.mu.Lock() if tb.currLimit.Bandwidth != limitNow.Bandwidth { // If bwlimit is toggled off, the change should only // become active on the next toggle, which causes // an exchange of tb.curr <-> tb.prev var targetBucket *buckets if tb.toggledOff { targetBucket = &tb.prev } else { targetBucket = &tb.curr } // Set new bandwidth. If unlimited, set tokenbucket to nil. if limitNow.Bandwidth.IsSet() { *targetBucket = newTokenBucket(limitNow.Bandwidth) if tb.toggledOff { fs.Logf(nil, "Scheduled bandwidth change. "+ "Limit will be set to %v Byte/s when toggled on again.", &limitNow.Bandwidth) } else { fs.Logf(nil, "Scheduled bandwidth change. Limit set to %v Byte/s", &limitNow.Bandwidth) } } else { targetBucket._setOff() fs.Logf(nil, "Scheduled bandwidth change. Bandwidth limits disabled") } tb.currLimit = limitNow } tb.mu.Unlock() } }() } // LimitBandwidth sleeps for the correct amount of time for the passage // of n bytes according to the current bandwidth limit func (tb *tokenBucket) LimitBandwidth(i TokenBucketSlot, n int) { tb.mu.RLock() // Limit the transfer speed if required if tb.curr[i] != nil { err := tb.curr[i].WaitN(context.Background(), n) if err != nil { fs.Errorf(nil, "Token bucket error: %v", err) } } tb.mu.RUnlock() } // SetBwLimit sets the current bandwidth limit func (tb *tokenBucket) SetBwLimit(bandwidth fs.BwPair) { tb.mu.Lock() defer tb.mu.Unlock() if bandwidth.IsSet() { tb.curr = newTokenBucket(bandwidth) fs.Logf(nil, "Bandwidth limit set to %v", bandwidth) } else { tb.curr._setOff() fs.Logf(nil, "Bandwidth limit reset to unlimited") } } // read and set the bandwidth limits func (tb *tokenBucket) rcBwlimit(ctx context.Context, in rc.Params) (out rc.Params, err error) { if in["rate"] != nil { bwlimit, err := in.GetString("rate") if err != nil { return out, err } var bws fs.BwTimetable err = bws.Set(bwlimit) if err != nil { return out, fmt.Errorf("bad bwlimit: %w", err) } if len(bws) != 1 { return out, errors.New("need exactly 1 bandwidth setting") } bw := bws[0] tb.SetBwLimit(bw.Bandwidth) } tb.mu.RLock() bytesPerSecond := int64(-1) if tb.curr[TokenBucketSlotAccounting] != nil { bytesPerSecond = int64(tb.curr[TokenBucketSlotAccounting].Limit()) } var bp = fs.BwPair{Tx: -1, Rx: -1} if tb.curr[TokenBucketSlotTransportTx] != nil { bp.Tx = fs.SizeSuffix(tb.curr[TokenBucketSlotTransportTx].Limit()) } if tb.curr[TokenBucketSlotTransportRx] != nil { bp.Rx = fs.SizeSuffix(tb.curr[TokenBucketSlotTransportRx].Limit()) } tb.mu.RUnlock() out = rc.Params{ "rate": bp.String(), "bytesPerSecond": bytesPerSecond, "bytesPerSecondTx": int64(bp.Tx), "bytesPerSecondRx": int64(bp.Rx), } return out, nil } // Remote control for the token bucket func init() { rc.Add(rc.Call{ Path: "core/bwlimit", Fn: TokenBucket.rcBwlimit, Title: "Set the bandwidth limit.", Help: ` This sets the bandwidth limit to the string passed in. This should be a single bandwidth limit entry or a pair of upload:download bandwidth. Eg rclone rc core/bwlimit rate=off { "bytesPerSecond": -1, "bytesPerSecondTx": -1, "bytesPerSecondRx": -1, "rate": "off" } rclone rc core/bwlimit rate=1M { "bytesPerSecond": 1048576, "bytesPerSecondTx": 1048576, "bytesPerSecondRx": 1048576, "rate": "1M" } rclone rc core/bwlimit rate=1M:100k { "bytesPerSecond": 1048576, "bytesPerSecondTx": 1048576, "bytesPerSecondRx": 131072, "rate": "1M" } If the rate parameter is not supplied then the bandwidth is queried rclone rc core/bwlimit { "bytesPerSecond": 1048576, "bytesPerSecondTx": 1048576, "bytesPerSecondRx": 1048576, "rate": "1M" } The format of the parameter is exactly the same as passed to --bwlimit except only one bandwidth may be specified. In either case "rate" is returned as a human-readable string, and "bytesPerSecond" is returned as a number. `, }) } rclone-v1.71.0/fs/accounting/token_bucket_test.go000066400000000000000000000042101505210326400220500ustar00rootroot00000000000000package accounting import ( "context" "testing" "github.com/rclone/rclone/fs/rc" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "golang.org/x/time/rate" ) func TestRcBwLimit(t *testing.T) { call := rc.Calls.Get("core/bwlimit") assert.NotNil(t, call) // Set in := rc.Params{ "rate": "1M", } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params{ "bytesPerSecond": int64(1048576), "bytesPerSecondTx": int64(1048576), "bytesPerSecondRx": int64(1048576), "rate": "1Mi", }, out) assert.Equal(t, rate.Limit(1048576), TokenBucket.curr[0].Limit()) // Query in = rc.Params{} out, err = call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params{ "bytesPerSecond": int64(1048576), "bytesPerSecondTx": int64(1048576), "bytesPerSecondRx": int64(1048576), "rate": "1Mi", }, out) // Set in = rc.Params{ "rate": "10M:1M", } out, err = call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params{ "bytesPerSecond": int64(10485760), "bytesPerSecondTx": int64(10485760), "bytesPerSecondRx": int64(1048576), "rate": "10Mi:1Mi", }, out) assert.Equal(t, rate.Limit(10485760), TokenBucket.curr[0].Limit()) // Query in = rc.Params{} out, err = call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params{ "bytesPerSecond": int64(10485760), "bytesPerSecondTx": int64(10485760), "bytesPerSecondRx": int64(1048576), "rate": "10Mi:1Mi", }, out) // Reset in = rc.Params{ "rate": "off", } out, err = call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params{ "bytesPerSecond": int64(-1), "bytesPerSecondTx": int64(-1), "bytesPerSecondRx": int64(-1), "rate": "off", }, out) assert.Nil(t, TokenBucket.curr[0]) // Query in = rc.Params{} out, err = call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params{ "bytesPerSecond": int64(-1), "bytesPerSecondTx": int64(-1), "bytesPerSecondRx": int64(-1), "rate": "off", }, out) } rclone-v1.71.0/fs/accounting/tpslimit.go000066400000000000000000000016161505210326400202100ustar00rootroot00000000000000package accounting import ( "context" "github.com/rclone/rclone/fs" "golang.org/x/time/rate" ) var ( tpsBucket *rate.Limiter // for limiting number of http transactions per second ) // StartLimitTPS starts the token bucket for transactions per second // limiting if necessary func StartLimitTPS(ctx context.Context) { ci := fs.GetConfig(ctx) if ci.TPSLimit > 0 { tpsBurst := max(ci.TPSLimitBurst, 1) tpsBucket = rate.NewLimiter(rate.Limit(ci.TPSLimit), tpsBurst) fs.Infof(nil, "Starting transaction limiter: max %g transactions/s with burst %d", ci.TPSLimit, tpsBurst) } } // LimitTPS limits the number of transactions per second if enabled. // It should be called once per transaction. func LimitTPS(ctx context.Context) { if tpsBucket != nil { tbErr := tpsBucket.Wait(ctx) if tbErr != nil && tbErr != context.Canceled { fs.Errorf(nil, "HTTP token bucket error: %v", tbErr) } } } rclone-v1.71.0/fs/accounting/tpslimit_test.go000066400000000000000000000015631505210326400212500ustar00rootroot00000000000000package accounting import ( "context" "testing" "time" "github.com/rclone/rclone/fs" "github.com/stretchr/testify/assert" ) func TestLimitTPS(t *testing.T) { timeTransactions := func(n int, minTime, maxTime time.Duration) { start := time.Now() for range n { LimitTPS(context.Background()) } dt := time.Since(start) assert.True(t, dt >= minTime && dt <= maxTime, "Expecting time between %v and %v, got %v", minTime, maxTime, dt) } t.Run("Off", func(t *testing.T) { assert.Nil(t, tpsBucket) timeTransactions(100, 0*time.Millisecond, 100*time.Millisecond) }) t.Run("On", func(t *testing.T) { ctx, ci := fs.AddConfig(context.Background()) ci.TPSLimit = 100.0 ci.TPSLimitBurst = 0 StartLimitTPS(ctx) assert.NotNil(t, tpsBucket) defer func() { tpsBucket = nil }() timeTransactions(100, 900*time.Millisecond, 5000*time.Millisecond) }) } rclone-v1.71.0/fs/accounting/transfer.go000066400000000000000000000127641505210326400201750ustar00rootroot00000000000000package accounting import ( "context" "encoding/json" "io" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/rc" ) // TransferSnapshot represents state of an account at point in time. type TransferSnapshot struct { Name string `json:"name"` Size int64 `json:"size"` Bytes int64 `json:"bytes"` Checked bool `json:"checked"` What string `json:"what"` StartedAt time.Time `json:"started_at"` CompletedAt time.Time `json:"completed_at,omitempty"` Error error `json:"-"` Group string `json:"group"` SrcFs string `json:"srcFs,omitempty"` DstFs string `json:"dstFs,omitempty"` } // MarshalJSON implements json.Marshaler interface. func (as TransferSnapshot) MarshalJSON() ([]byte, error) { err := "" if as.Error != nil { err = as.Error.Error() } type Alias TransferSnapshot return json.Marshal(&struct { Error string `json:"error"` Alias }{ Error: err, Alias: (Alias)(as), }) } // Transfer keeps track of initiated transfers and provides access to // accounting functions. // Transfer needs to be closed on completion. type Transfer struct { // these are initialised at creation and may be accessed without locking stats *StatsInfo remote string size int64 startedAt time.Time checking bool what string // what kind of transfer this is srcFs fs.Fs // source Fs - may be nil dstFs fs.Fs // destination Fs - may be nil // Protects all below // // NB to avoid deadlocks we must release this lock before // calling any methods on Transfer.stats. This is because // StatsInfo calls back into Transfer. mu sync.RWMutex acc *Account err error completedAt time.Time } // newCheckingTransfer instantiates new checking of the object. func newCheckingTransfer(stats *StatsInfo, obj fs.DirEntry, what string) *Transfer { return newTransferRemoteSize(stats, obj.Remote(), obj.Size(), true, what, nil, nil) } // newTransfer instantiates new transfer. func newTransfer(stats *StatsInfo, obj fs.DirEntry, srcFs, dstFs fs.Fs) *Transfer { return newTransferRemoteSize(stats, obj.Remote(), obj.Size(), false, "", srcFs, dstFs) } func newTransferRemoteSize(stats *StatsInfo, remote string, size int64, checking bool, what string, srcFs, dstFs fs.Fs) *Transfer { tr := &Transfer{ stats: stats, remote: remote, size: size, startedAt: time.Now(), checking: checking, what: what, srcFs: srcFs, dstFs: dstFs, } stats.AddTransfer(tr) return tr } // Done ends the transfer. // Must be called after transfer is finished to run proper cleanups. func (tr *Transfer) Done(ctx context.Context, err error) { if err != nil { err = tr.stats.Error(err) tr.mu.Lock() tr.err = err tr.mu.Unlock() } tr.mu.RLock() acc := tr.acc tr.mu.RUnlock() ci := fs.GetConfig(ctx) if acc != nil { // Close the file if it is still open if err := acc.Close(); err != nil { fs.LogLevelPrintf(ci.StatsLogLevel, nil, "can't close account: %+v\n", err) } // Signal done with accounting acc.Done() // free the account since we may keep the transfer acc = nil } tr.mu.Lock() tr.completedAt = time.Now() tr.mu.Unlock() if tr.checking { tr.stats.DoneChecking(tr.remote) } else { tr.stats.DoneTransferring(tr.remote, err == nil) } tr.stats.PruneTransfers() } // Reset allows to switch the Account to another transfer method. func (tr *Transfer) Reset(ctx context.Context) { tr.mu.RLock() acc := tr.acc tr.acc = nil tr.mu.RUnlock() ci := fs.GetConfig(ctx) if acc != nil { acc.Done() if err := acc.Close(); err != nil { fs.LogLevelPrintf(ci.StatsLogLevel, nil, "can't close account: %+v\n", err) } } } // Account returns reader that knows how to keep track of transfer progress. func (tr *Transfer) Account(ctx context.Context, in io.ReadCloser) *Account { tr.mu.Lock() if tr.acc == nil { tr.acc = newAccountSizeName(ctx, tr.stats, in, tr.size, tr.remote) } else { tr.acc.UpdateReader(ctx, in) } tr.acc.checking = tr.checking tr.mu.Unlock() return tr.acc } // TimeRange returns the time transfer started and ended at. If not completed // it will return zero time for end time. func (tr *Transfer) TimeRange() (time.Time, time.Time) { tr.mu.RLock() defer tr.mu.RUnlock() return tr.startedAt, tr.completedAt } // IsDone returns true if transfer is completed. func (tr *Transfer) IsDone() bool { tr.mu.RLock() defer tr.mu.RUnlock() return !tr.completedAt.IsZero() } // Snapshot produces stats for this account at point in time. func (tr *Transfer) Snapshot() TransferSnapshot { tr.mu.RLock() defer tr.mu.RUnlock() var s, b int64 = tr.size, 0 if tr.acc != nil { b, s = tr.acc.progress() } what := tr.what if what == "" { what = "transferring" } snapshot := TransferSnapshot{ Name: tr.remote, Size: s, Bytes: b, Checked: tr.checking, What: what, StartedAt: tr.startedAt, CompletedAt: tr.completedAt, Error: tr.err, Group: tr.stats.group, } if tr.srcFs != nil { snapshot.SrcFs = fs.ConfigString(tr.srcFs) } if tr.dstFs != nil { snapshot.DstFs = fs.ConfigString(tr.dstFs) } return snapshot } // rcStats returns stats for the transfer suitable for the rc func (tr *Transfer) rcStats() rc.Params { out := rc.Params{ "name": tr.remote, // no locking needed to access this "size": tr.size, } if tr.srcFs != nil { out["srcFs"] = fs.ConfigString(tr.srcFs) } if tr.dstFs != nil { out["dstFs"] = fs.ConfigString(tr.dstFs) } return out } rclone-v1.71.0/fs/accounting/transfer_test.go000066400000000000000000000046251505210326400212310ustar00rootroot00000000000000package accounting import ( "context" "errors" "io" "testing" "github.com/rclone/rclone/fs/rc" "github.com/rclone/rclone/fstest/mockfs" "github.com/rclone/rclone/fstest/mockobject" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestTransfer(t *testing.T) { ctx := context.Background() s := NewStats(ctx) o := mockobject.Object("obj") srcFs, err := mockfs.NewFs(ctx, "srcFs", "srcFs", nil) require.NoError(t, err) dstFs, err := mockfs.NewFs(ctx, "dstFs", "dstFs", nil) require.NoError(t, err) tr := newTransfer(s, o, srcFs, dstFs) t.Run("Snapshot", func(t *testing.T) { snap := tr.Snapshot() assert.Equal(t, "obj", snap.Name) assert.Equal(t, int64(0), snap.Size) assert.Equal(t, int64(0), snap.Bytes) assert.Equal(t, false, snap.Checked) assert.Equal(t, "transferring", snap.What) assert.Equal(t, false, snap.StartedAt.IsZero()) assert.Equal(t, true, snap.CompletedAt.IsZero()) assert.Equal(t, nil, snap.Error) assert.Equal(t, "", snap.Group) assert.Equal(t, "srcFs:srcFs", snap.SrcFs) assert.Equal(t, "dstFs:dstFs", snap.DstFs) }) t.Run("Done", func(t *testing.T) { tr.Done(ctx, io.EOF) snap := tr.Snapshot() assert.Equal(t, "obj", snap.Name) assert.Equal(t, int64(0), snap.Size) assert.Equal(t, int64(0), snap.Bytes) assert.Equal(t, false, snap.Checked) assert.Equal(t, "transferring", snap.What) assert.Equal(t, false, snap.StartedAt.IsZero()) assert.Equal(t, false, snap.CompletedAt.IsZero()) assert.Equal(t, true, errors.Is(snap.Error, io.EOF)) assert.Equal(t, "", snap.Group) assert.Equal(t, "srcFs:srcFs", snap.SrcFs) assert.Equal(t, "dstFs:dstFs", snap.DstFs) }) t.Run("rcStats", func(t *testing.T) { out := tr.rcStats() assert.Equal(t, rc.Params{ "name": "obj", "size": int64(0), "srcFs": "srcFs:srcFs", "dstFs": "dstFs:dstFs", }, out) }) t.Run("Snapshot checking transfer", func(t *testing.T) { ctr := newCheckingTransfer(s, o, "checking") snap := ctr.Snapshot() assert.Equal(t, "obj", snap.Name) assert.Equal(t, int64(0), snap.Size) assert.Equal(t, int64(0), snap.Bytes) assert.Equal(t, true, snap.Checked) assert.Equal(t, "checking", snap.What) assert.Equal(t, false, snap.StartedAt.IsZero()) assert.Equal(t, true, snap.CompletedAt.IsZero()) assert.Equal(t, nil, snap.Error) assert.Equal(t, "", snap.Group) assert.Equal(t, "", snap.SrcFs) assert.Equal(t, "", snap.DstFs) }) } rclone-v1.71.0/fs/accounting/transfermap.go000066400000000000000000000074461505210326400206740ustar00rootroot00000000000000package accounting import ( "context" "fmt" "maps" "sort" "strings" "sync" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/rc" ) // transferMap holds name to transfer map type transferMap struct { mu sync.RWMutex items map[string]*Transfer name string } // newTransferMap creates a new empty transfer map of capacity size func newTransferMap(size int, name string) *transferMap { return &transferMap{ items: make(map[string]*Transfer, size), name: name, } } // add adds a new transfer to the map func (tm *transferMap) add(tr *Transfer) { tm.mu.Lock() tm.items[tr.remote] = tr tm.mu.Unlock() } // del removes a transfer from the map by name func (tm *transferMap) del(remote string) bool { tm.mu.Lock() _, exists := tm.items[remote] delete(tm.items, remote) tm.mu.Unlock() return exists } // merge adds items from another map func (tm *transferMap) merge(m *transferMap) { tm.mu.Lock() m.mu.Lock() maps.Copy(tm.items, m.items) m.mu.Unlock() tm.mu.Unlock() } // empty returns whether the map has any items func (tm *transferMap) empty() bool { tm.mu.RLock() defer tm.mu.RUnlock() return len(tm.items) == 0 } // count returns the number of items in the map func (tm *transferMap) count() int { tm.mu.RLock() defer tm.mu.RUnlock() return len(tm.items) } // _sortedSlice returns all transfers sorted by start time // // Call with mu.Rlock held func (tm *transferMap) _sortedSlice() []*Transfer { s := make([]*Transfer, 0, len(tm.items)) for _, tr := range tm.items { s = append(s, tr) } // sort by time first and if equal by name. Note that the relatively // low time resolution on Windows can cause equal times. sort.Slice(s, func(i, j int) bool { a, b := s[i], s[j] if a.startedAt.Before(b.startedAt) { return true } else if !a.startedAt.Equal(b.startedAt) { return false } return a.remote < b.remote }) return s } // String returns string representation of map items excluding any in // exclude (if set). func (tm *transferMap) String(ctx context.Context, progress *inProgress, exclude *transferMap) string { tm.mu.RLock() defer tm.mu.RUnlock() ci := fs.GetConfig(ctx) stringList := make([]string, 0, len(tm.items)) for _, tr := range tm._sortedSlice() { var what = tr.what if exclude != nil { exclude.mu.RLock() _, found := exclude.items[tr.remote] exclude.mu.RUnlock() if found { continue } } var out string if acc := progress.get(tr.remote); acc != nil { out = acc.String() if what != "" { out += ", " + what } } else { if what == "" { what = tm.name } out = fmt.Sprintf("%*s: %s", ci.StatsFileNameLength, shortenName(tr.remote, ci.StatsFileNameLength), what, ) } stringList = append(stringList, " * "+out) } return strings.Join(stringList, "\n") } // progress returns total bytes read as well as the size. func (tm *transferMap) progress(stats *StatsInfo) (totalBytes, totalSize int64) { tm.mu.RLock() defer tm.mu.RUnlock() for name := range tm.items { if acc := stats.inProgress.get(name); acc != nil { bytes, size := acc.progress() if size >= 0 && bytes >= 0 { totalBytes += bytes totalSize += size } } } return totalBytes, totalSize } // remotes returns a []string of the remote names for the transferMap func (tm *transferMap) remotes() (c []string) { tm.mu.RLock() defer tm.mu.RUnlock() for _, tr := range tm._sortedSlice() { c = append(c, tr.remote) } return c } // rcStats returns a []rc.Params of the stats for the transferMap func (tm *transferMap) rcStats(progress *inProgress) (t []rc.Params) { tm.mu.RLock() defer tm.mu.RUnlock() for _, tr := range tm._sortedSlice() { out := tr.rcStats() // basic stats if acc := progress.get(tr.remote); acc != nil { acc.rcStats(out) // add extended stats if have acc } t = append(t, out) } return t } rclone-v1.71.0/fs/asyncreader/000077500000000000000000000000001505210326400161565ustar00rootroot00000000000000rclone-v1.71.0/fs/asyncreader/asyncreader.go000066400000000000000000000177341505210326400210210ustar00rootroot00000000000000// Package asyncreader provides an asynchronous reader which reads // independently of write package asyncreader import ( "context" "errors" "io" "sync" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/lib/pool" "github.com/rclone/rclone/lib/readers" ) const ( // BufferSize is the default size of the async buffer BufferSize = pool.BufferSize softStartInitial = 4 * 1024 ) // ErrorStreamAbandoned is returned when the input is closed before the end of the stream var ErrorStreamAbandoned = errors.New("stream abandoned") // AsyncReader will do async read-ahead from the input reader // and make the data available as an io.Reader. // This should be fully transparent, except that once an error // has been returned from the Reader, it will not recover. type AsyncReader struct { in io.ReadCloser // Input reader ready chan *buffer // Buffers ready to be handed to the reader token chan struct{} // Tokens which allow a buffer to be taken exit chan struct{} // Closes when finished buffers int // Number of buffers err error // If an error has occurred it is here cur *buffer // Current buffer being served exited chan struct{} // Channel is closed been the async reader shuts down size int // size of buffer to use closed bool // whether we have closed the underlying stream mu sync.Mutex // lock for Read/WriteTo/Abandon/Close ci *fs.ConfigInfo // for reading config pool *pool.Pool // pool to get memory from } // New returns a reader that will asynchronously read from // the supplied Reader into a number of buffers each of size BufferSize // It will start reading from the input at once, maybe even before this // function has returned. // The input can be read from the returned reader. // When done use Close to release the buffers and close the supplied input. func New(ctx context.Context, rd io.ReadCloser, buffers int) (*AsyncReader, error) { if buffers <= 0 { return nil, errors.New("number of buffers too small") } if rd == nil { return nil, errors.New("nil reader supplied") } a := &AsyncReader{ ci: fs.GetConfig(ctx), pool: pool.Global(), } a.init(rd, buffers) return a, nil } func (a *AsyncReader) init(rd io.ReadCloser, buffers int) { a.in = rd a.ready = make(chan *buffer, buffers) a.token = make(chan struct{}, buffers) a.exit = make(chan struct{}) a.exited = make(chan struct{}) a.buffers = buffers a.cur = nil a.size = softStartInitial // Create tokens for range buffers { a.token <- struct{}{} } // Start async reader go func() { // Ensure that when we exit this is signalled. defer close(a.exited) defer close(a.ready) for { select { case <-a.token: b := a.getBuffer() if a.size < BufferSize { b.buf = b.buf[:a.size] a.size <<= 1 } err := b.read(a.in) a.ready <- b if err != nil { return } case <-a.exit: return } } }() } // return the buffer to the pool (clearing it) func (a *AsyncReader) putBuffer(b *buffer) { a.pool.Put(b.buf) b.buf = nil } // get a buffer from the pool func (a *AsyncReader) getBuffer() *buffer { return &buffer{ buf: a.pool.Get(), } } // Read will return the next available data. func (a *AsyncReader) fill() (err error) { if a.cur.isEmpty() { if a.cur != nil { a.putBuffer(a.cur) a.token <- struct{}{} a.cur = nil } b, ok := <-a.ready if !ok { // Return an error to show fill failed if a.err == nil { return ErrorStreamAbandoned } return a.err } a.cur = b } return nil } // Read will return the next available data. func (a *AsyncReader) Read(p []byte) (n int, err error) { a.mu.Lock() defer a.mu.Unlock() // Swap buffer and maybe return error err = a.fill() if err != nil { return 0, err } // Copy what we can n = copy(p, a.cur.buffer()) a.cur.increment(n) // If at end of buffer, return any error, if present if a.cur.isEmpty() { a.err = a.cur.err return n, a.err } return n, nil } // WriteTo writes data to w until there's no more data to write or when an error occurs. // The return value n is the number of bytes written. // Any error encountered during the write is also returned. func (a *AsyncReader) WriteTo(w io.Writer) (n int64, err error) { a.mu.Lock() defer a.mu.Unlock() n = 0 for { err = a.fill() if err == io.EOF { return n, nil } if err != nil { return n, err } n2, err := w.Write(a.cur.buffer()) a.cur.increment(n2) n += int64(n2) if err != nil { return n, err } if a.cur.err == io.EOF { a.err = a.cur.err return n, err } if a.cur.err != nil { a.err = a.cur.err return n, a.cur.err } } } // SkipBytes will try to seek 'skip' bytes relative to the current position. // On success it returns true. If 'skip' is outside the current buffer data or // an error occurs, Abandon is called and false is returned. func (a *AsyncReader) SkipBytes(skip int) (ok bool) { a.mu.Lock() defer func() { a.mu.Unlock() if !ok { a.Abandon() } }() if a.err != nil { return false } if skip < 0 { // seek backwards if skip is inside current buffer if a.cur != nil && a.cur.offset+skip >= 0 { a.cur.offset += skip return true } return false } // early return if skip is past the maximum buffer capacity if skip >= (len(a.ready)+1)*BufferSize { return false } refillTokens := 0 for { if a.cur.isEmpty() { if a.cur != nil { a.putBuffer(a.cur) refillTokens++ a.cur = nil } select { case b, ok := <-a.ready: if !ok { return false } a.cur = b default: return false } } n := min(len(a.cur.buffer()), skip) a.cur.increment(n) skip -= n if skip == 0 { for ; refillTokens > 0; refillTokens-- { a.token <- struct{}{} } // If at end of buffer, store any error, if present if a.cur.isEmpty() && a.cur.err != nil { a.err = a.cur.err } return true } if a.cur.err != nil { a.err = a.cur.err return false } } } // StopBuffering will ensure that the underlying async reader is shut // down so no more is read from the input. // // This does not free the memory so Abandon() or Close() need to be // called on the input. // // This does not wait for Read/WriteTo to complete so can be called // concurrently to those. func (a *AsyncReader) StopBuffering() { select { case <-a.exit: // Do nothing if reader routine already exited return default: } // Close and wait for go routine close(a.exit) <-a.exited } // Abandon will ensure that the underlying async reader is shut down // and memory is returned. It does everything but close the input. // // It will NOT close the input supplied on New. func (a *AsyncReader) Abandon() { a.StopBuffering() // take the lock to wait for Read/WriteTo to complete a.mu.Lock() defer a.mu.Unlock() // Return any outstanding buffers to the Pool if a.cur != nil { a.putBuffer(a.cur) a.cur = nil } for b := range a.ready { a.putBuffer(b) } } // Close will ensure that the underlying async reader is shut down. // It will also close the input supplied on New. func (a *AsyncReader) Close() (err error) { a.Abandon() if a.closed { return nil } a.closed = true return a.in.Close() } // Internal buffer // If an error is present, it must be returned // once all buffer content has been served. type buffer struct { buf []byte err error offset int } // isEmpty returns true is offset is at end of // buffer, or func (b *buffer) isEmpty() bool { if b == nil { return true } if len(b.buf)-b.offset <= 0 { return true } return false } // read into start of the buffer from the supplied reader, // resets the offset and updates the size of the buffer. // Any error encountered during the read is returned. func (b *buffer) read(rd io.Reader) error { var n int n, b.err = readers.ReadFill(rd, b.buf) b.buf = b.buf[0:n] b.offset = 0 return b.err } // Return the buffer at current offset func (b *buffer) buffer() []byte { return b.buf[b.offset:] } // increment the offset func (b *buffer) increment(n int) { b.offset += n } rclone-v1.71.0/fs/asyncreader/asyncreader_test.go000066400000000000000000000220771505210326400220540ustar00rootroot00000000000000package asyncreader import ( "bufio" "bytes" "context" "fmt" "io" "math/rand" "strings" "sync" "testing" "testing/iotest" "time" "github.com/rclone/rclone/lib/israce" "github.com/rclone/rclone/lib/readers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestAsyncReader(t *testing.T) { ctx := context.Background() buf := io.NopCloser(bytes.NewBufferString("Testbuffer")) ar, err := New(ctx, buf, 4) require.NoError(t, err) var dst = make([]byte, 100) n, err := ar.Read(dst) assert.Equal(t, io.EOF, err) assert.Equal(t, 10, n) n, err = ar.Read(dst) assert.Equal(t, io.EOF, err) assert.Equal(t, 0, n) // Test read after error n, err = ar.Read(dst) assert.Equal(t, io.EOF, err) assert.Equal(t, 0, n) err = ar.Close() require.NoError(t, err) // Test double close err = ar.Close() require.NoError(t, err) // Test Close without reading everything buf = io.NopCloser(bytes.NewBuffer(make([]byte, 50000))) ar, err = New(ctx, buf, 4) require.NoError(t, err) err = ar.Close() require.NoError(t, err) } func TestAsyncWriteTo(t *testing.T) { ctx := context.Background() buf := io.NopCloser(bytes.NewBufferString("Testbuffer")) ar, err := New(ctx, buf, 4) require.NoError(t, err) var dst = &bytes.Buffer{} n, err := io.Copy(dst, ar) require.NoError(t, err) assert.Equal(t, int64(10), n) // Should still not return any errors n, err = io.Copy(dst, ar) require.NoError(t, err) assert.Equal(t, int64(0), n) err = ar.Close() require.NoError(t, err) } func TestAsyncReaderErrors(t *testing.T) { ctx := context.Background() // test nil reader _, err := New(ctx, nil, 4) require.Error(t, err) // invalid buffer number buf := io.NopCloser(bytes.NewBufferString("Testbuffer")) _, err = New(ctx, buf, 0) require.Error(t, err) _, err = New(ctx, buf, -1) require.Error(t, err) } // Complex read tests, leveraged from "bufio". type readMaker struct { name string fn func(io.Reader) io.Reader } var readMakers = []readMaker{ {"full", func(r io.Reader) io.Reader { return r }}, {"byte", iotest.OneByteReader}, {"half", iotest.HalfReader}, {"data+err", iotest.DataErrReader}, {"timeout", iotest.TimeoutReader}, } // Call Read to accumulate the text of a file func reads(buf io.Reader, m int) string { var b [1000]byte nb := 0 for { n, err := buf.Read(b[nb : nb+m]) nb += n if err == io.EOF { break } else if err != nil && err != iotest.ErrTimeout { panic("Data: " + err.Error()) } else if err != nil { break } } return string(b[0:nb]) } type bufReader struct { name string fn func(io.Reader) string } var bufreaders = []bufReader{ {"1", func(b io.Reader) string { return reads(b, 1) }}, {"2", func(b io.Reader) string { return reads(b, 2) }}, {"3", func(b io.Reader) string { return reads(b, 3) }}, {"4", func(b io.Reader) string { return reads(b, 4) }}, {"5", func(b io.Reader) string { return reads(b, 5) }}, {"7", func(b io.Reader) string { return reads(b, 7) }}, } const minReadBufferSize = 16 var bufsizes = []int{ 0, minReadBufferSize, 23, 32, 46, 64, 93, 128, 1024, 4096, } // Test various input buffer sizes, number of buffers and read sizes. func TestAsyncReaderSizes(t *testing.T) { ctx := context.Background() var texts [31]string str := "" all := "" for i := range len(texts) - 1 { texts[i] = str + "\n" all += texts[i] str += string(rune(i)%26 + 'a') } texts[len(texts)-1] = all for h := range len(texts) { text := texts[h] for i := range readMakers { for j := range bufreaders { for k := range bufsizes { for l := 1; l < 10; l++ { readmaker := readMakers[i] bufreader := bufreaders[j] bufsize := bufsizes[k] read := readmaker.fn(strings.NewReader(text)) buf := bufio.NewReaderSize(read, bufsize) ar, _ := New(ctx, io.NopCloser(buf), l) s := bufreader.fn(ar) // "timeout" expects the Reader to recover, AsyncReader does not. if s != text && readmaker.name != "timeout" { t.Errorf("reader=%s fn=%s bufsize=%d want=%q got=%q", readmaker.name, bufreader.name, bufsize, text, s) } err := ar.Close() require.NoError(t, err) } } } } } } // Test various input buffer sizes, number of buffers and read sizes. func TestAsyncReaderWriteTo(t *testing.T) { ctx := context.Background() var texts [31]string str := "" all := "" for i := range len(texts) - 1 { texts[i] = str + "\n" all += texts[i] str += string(rune(i)%26 + 'a') } texts[len(texts)-1] = all for h := range len(texts) { text := texts[h] for i := range readMakers { for j := range bufreaders { for k := range bufsizes { for l := 1; l < 10; l++ { readmaker := readMakers[i] bufreader := bufreaders[j] bufsize := bufsizes[k] read := readmaker.fn(strings.NewReader(text)) buf := bufio.NewReaderSize(read, bufsize) ar, _ := New(ctx, io.NopCloser(buf), l) dst := &bytes.Buffer{} _, err := ar.WriteTo(dst) if err != nil && err != io.EOF && err != iotest.ErrTimeout { t.Fatal("Copy:", err) } s := dst.String() // "timeout" expects the Reader to recover, AsyncReader does not. if s != text && readmaker.name != "timeout" { t.Errorf("reader=%s fn=%s bufsize=%d want=%q got=%q", readmaker.name, bufreader.name, bufsize, text, s) } err = ar.Close() require.NoError(t, err) } } } } } } // Read an infinite number of zeros type zeroReader struct { closed bool } func (z *zeroReader) Read(p []byte) (n int, err error) { if z.closed { return 0, io.EOF } for i := range p { p[i] = 0 } return len(p), nil } func (z *zeroReader) Close() error { if z.closed { panic("double close on zeroReader") } z.closed = true return nil } // Test closing and abandoning func testAsyncReaderClose(t *testing.T, writeto bool) { ctx := context.Background() zr := &zeroReader{} a, err := New(ctx, zr, 16) require.NoError(t, err) var copyN int64 var copyErr error var wg sync.WaitGroup started := make(chan struct{}) wg.Add(1) go func() { defer wg.Done() close(started) if writeto { // exercise the WriteTo path copyN, copyErr = a.WriteTo(io.Discard) } else { // exercise the Read path buf := make([]byte, 64*1024) for { var n int n, copyErr = a.Read(buf) copyN += int64(n) if copyErr != nil { break } } } }() // Do some copying <-started time.Sleep(100 * time.Millisecond) // Abandon the copy a.Abandon() wg.Wait() assert.Equal(t, ErrorStreamAbandoned, copyErr) // t.Logf("Copied %d bytes, err %v", copyN, copyErr) assert.True(t, copyN > 0) } func TestAsyncReaderCloseRead(t *testing.T) { testAsyncReaderClose(t, false) } func TestAsyncReaderCloseWriteTo(t *testing.T) { testAsyncReaderClose(t, true) } func TestAsyncReaderSkipBytes(t *testing.T) { ctx := context.Background() t.Parallel() data := make([]byte, 15000) buf := make([]byte, len(data)) r := rand.New(rand.NewSource(42)) n, err := r.Read(data) require.NoError(t, err) require.Equal(t, len(data), n) initialReads := []int{0, 1, 100, 2048, softStartInitial - 1, softStartInitial, softStartInitial + 1, 8000, len(data)} skips := []int{-1000, -101, -100, -99, 0, 1, 2048, softStartInitial - 1, softStartInitial, softStartInitial + 1, 8000, len(data), BufferSize, 2 * BufferSize} for buffers := 1; buffers <= 5; buffers++ { if israce.Enabled && buffers > 1 { t.Skip("FIXME Skipping further tests with race detector until https://github.com/golang/go/issues/27070 is fixed.") } t.Run(fmt.Sprintf("%d", buffers), func(t *testing.T) { for _, initialRead := range initialReads { t.Run(fmt.Sprintf("%d", initialRead), func(t *testing.T) { for _, skip := range skips { t.Run(fmt.Sprintf("%d", skip), func(t *testing.T) { ar, err := New(ctx, io.NopCloser(bytes.NewReader(data)), buffers) require.NoError(t, err) wantSkipFalse := false buf = buf[:initialRead] n, err := readers.ReadFill(ar, buf) if initialRead >= len(data) { wantSkipFalse = true if initialRead > len(data) { assert.Equal(t, err, io.EOF) } else { assert.True(t, err == nil || err == io.EOF) } assert.Equal(t, len(data), n) assert.Equal(t, data, buf[:len(data)]) } else { assert.NoError(t, err) assert.Equal(t, initialRead, n) assert.Equal(t, data[:initialRead], buf) } skipped := ar.SkipBytes(skip) buf = buf[:1024] n, err = readers.ReadFill(ar, buf) offset := initialRead + skip if skipped { assert.False(t, wantSkipFalse) l := len(buf) if offset >= len(data) { assert.Equal(t, err, io.EOF) } else { if offset+1024 >= len(data) { l = len(data) - offset } assert.Equal(t, l, n) assert.Equal(t, data[offset:offset+l], buf[:l]) } } else { if initialRead >= len(data) { assert.Equal(t, err, io.EOF) } else { assert.True(t, err == ErrorStreamAbandoned || err == io.EOF) } } }) } }) } }) } } rclone-v1.71.0/fs/backend_config.go000066400000000000000000000430721505210326400171270ustar00rootroot00000000000000// Structures and utilities for backend config // // package fs import ( "context" "errors" "fmt" "slices" "strconv" "strings" "github.com/rclone/rclone/fs/config/configmap" ) const ( // ConfigToken is the key used to store the token under ConfigToken = "token" // ConfigKeyEphemeralPrefix marks config keys which shouldn't be stored in the config file ConfigKeyEphemeralPrefix = "config_" ) // ConfigOAuth should be called to do the OAuth // // set in lib/oauthutil to avoid a circular import var ConfigOAuth func(ctx context.Context, name string, m configmap.Mapper, ri *RegInfo, in ConfigIn) (*ConfigOut, error) // ConfigIn is passed to the Config function for an Fs // // The interactive config system for backends is state based. This is // so that different frontends to the config can be attached, eg over // the API or web page. // // Each call to the config system supplies ConfigIn which tells the // system what to do. Each will return a ConfigOut which gives a // question to ask the user and a state to return to. There is one // special question which allows the backends to do OAuth. // // The ConfigIn contains a State which the backend should act upon and // a Result from the previous question to the user. // // If ConfigOut is nil or ConfigOut.State == "" then the process is // deemed to have finished. If there is no Option in ConfigOut then // the next state will be called immediately. This is wrapped in // ConfigGoto and ConfigResult. // // Backends should keep no state in memory - if they need to persist // things between calls it should be persisted in the config file. // Things can also be persisted in the state using the StatePush and // StatePop utilities here. // // The utilities here are convenience methods for different kinds of // questions and responses. // // Where the questions ask for a name then this should start with // "config_" to show it is an ephemeral config input rather than the // actual value stored in the config file. Names beginning with // "config_fs_" are reserved for internal use. // // State names starting with "*" are reserved for internal use. // // Note that in the bin directory there is a python program called // "config.py" which shows how this interface should be used. type ConfigIn struct { State string // State to run Result string // Result from previous Option } // ConfigOut is returned from Config function for an Fs // // State is the state for the next call to Config // OAuth is a special value set by oauthutil.ConfigOAuth // Error is displayed to the user before asking a question // Result is passed to the next call to Config if Option/OAuth isn't set type ConfigOut struct { State string // State to jump to after this Option *Option // Option to query user about OAuth any `json:"-"` // Do OAuth if set Error string // error to be displayed to the user Result string // if Option/OAuth not set then this is passed to the next state } // ConfigInputOptional asks the user for a string which may be empty // // state should be the next state required // name is the config name for this item // help should be the help shown to the user func ConfigInputOptional(state string, name string, help string) (*ConfigOut, error) { return &ConfigOut{ State: state, Option: &Option{ Name: name, Help: help, Default: "", }, }, nil } // ConfigInput asks the user for a non-empty string // // state should be the next state required // name is the config name for this item // help should be the help shown to the user func ConfigInput(state string, name string, help string) (*ConfigOut, error) { out, _ := ConfigInputOptional(state, name, help) out.Option.Required = true return out, nil } // ConfigPassword asks the user for a password // // state should be the next state required // name is the config name for this item // help should be the help shown to the user func ConfigPassword(state string, name string, help string) (*ConfigOut, error) { out, _ := ConfigInputOptional(state, name, help) out.Option.IsPassword = true return out, nil } // ConfigGoto goes to the next state with empty Result // // state should be the next state required func ConfigGoto(state string) (*ConfigOut, error) { return &ConfigOut{ State: state, }, nil } // ConfigResult goes to the next state with result given // // state should be the next state required // result should be the result for the next state func ConfigResult(state, result string) (*ConfigOut, error) { return &ConfigOut{ State: state, Result: result, }, nil } // ConfigError shows the error to the user and goes to the state passed in // // state should be the next state required // Error should be the error shown to the user func ConfigError(state string, Error string) (*ConfigOut, error) { return &ConfigOut{ State: state, Error: Error, }, nil } // ConfigConfirm returns a ConfigOut structure which asks a Yes/No question // // state should be the next state required // Default should be the default state // name is the config name for this item // help should be the help shown to the user func ConfigConfirm(state string, Default bool, name string, help string) (*ConfigOut, error) { return &ConfigOut{ State: state, Option: &Option{ Name: name, Help: help, Default: Default, Examples: []OptionExample{{ Value: "true", Help: "Yes", }, { Value: "false", Help: "No", }}, Exclusive: true, }, }, nil } // ConfigChooseExclusiveFixed returns a ConfigOut structure which has a list of // items to choose from. // // Possible items must be supplied as a fixed list. // // User is required to supply a value, and is restricted to the specified list, // i.e. free text input is not allowed. // // state should be the next state required // name is the config name for this item // help should be the help shown to the user // items should be the items in the list // // It chooses the first item to be the default. // If there are no items then it will return an error. // If there is only one item it will short cut to the next state. func ConfigChooseExclusiveFixed(state string, name string, help string, items []OptionExample) (*ConfigOut, error) { if len(items) == 0 { return nil, fmt.Errorf("no items found in: %s", help) } choose := &ConfigOut{ State: state, Option: &Option{ Name: name, Help: help, Examples: items, Exclusive: true, }, } choose.Option.Default = choose.Option.Examples[0].Value if len(items) == 1 { // short circuit asking the question if only one entry choose.Result = choose.Option.Examples[0].Value choose.Option = nil } return choose, nil } // ConfigChooseExclusive returns a ConfigOut structure which has a list of // items to choose from. // // Possible items are retrieved from a supplied function. // // User is required to supply a value, and is restricted to the specified list, // i.e. free text input is not allowed. // // state should be the next state required // name is the config name for this item // help should be the help shown to the user // n should be the number of items in the list // getItem should return the items (value, help) // // It chooses the first item to be the default. // If there are no items then it will return an error. // If there is only one item it will short cut to the next state. func ConfigChooseExclusive(state string, name string, help string, n int, getItem func(i int) (itemValue string, itemHelp string)) (*ConfigOut, error) { items := make(OptionExamples, n) for i := range items { items[i].Value, items[i].Help = getItem(i) } return ConfigChooseExclusiveFixed(state, name, help, items) } // ConfigChooseFixed returns a ConfigOut structure which has a list of // suggested items. // // Suggested items must be supplied as a fixed list. // // User is required to supply a value, but is not restricted to the specified // list, i.e. free text input is accepted. // // state should be the next state required // name is the config name for this item // help should be the help shown to the user // items should be the items in the list // // It chooses the first item to be the default. func ConfigChooseFixed(state string, name string, help string, items []OptionExample) (*ConfigOut, error) { choose := &ConfigOut{ State: state, Option: &Option{ Name: name, Help: help, Examples: items, Required: true, }, } if len(choose.Option.Examples) > 0 { choose.Option.Default = choose.Option.Examples[0].Value } return choose, nil } // ConfigChoose returns a ConfigOut structure which has a list of suggested // items. // // Suggested items are retrieved from a supplied function. // // User is required to supply a value, but is not restricted to the specified // list, i.e. free text input is accepted. // // state should be the next state required // name is the config name for this item // help should be the help shown to the user // n should be the number of items in the list // getItem should return the items (value, help) // // It chooses the first item to be the default. func ConfigChoose(state string, name string, help string, n int, getItem func(i int) (itemValue string, itemHelp string)) (*ConfigOut, error) { items := make(OptionExamples, n) for i := range items { items[i].Value, items[i].Help = getItem(i) } return ConfigChooseFixed(state, name, help, items) } // StatePush pushes a new values onto the front of the config string func StatePush(state string, values ...string) string { for i := range values { values[i] = strings.ReplaceAll(values[i], ",", "，") // replace comma with unicode wide version } if state != "" { values = append(values[:len(values):len(values)], state) } return strings.Join(values, ",") } type configOAuthKeyType struct{} // OAuth key for config var configOAuthKey = configOAuthKeyType{} // ConfigOAuthOnly marks the ctx so that the Config will stop after // finding an OAuth func ConfigOAuthOnly(ctx context.Context) context.Context { return context.WithValue(ctx, configOAuthKey, struct{}{}) } // Return true if ctx is marked as ConfigOAuthOnly func isConfigOAuthOnly(ctx context.Context) bool { return ctx.Value(configOAuthKey) != nil } // StatePop pops a state from the front of the config string // It returns the new state and the value popped func StatePop(state string) (newState string, value string) { comma := strings.IndexRune(state, ',') if comma < 0 { return "", state } value, newState = state[:comma], state[comma+1:] value = strings.ReplaceAll(value, "，", ",") // replace unicode wide comma with comma return newState, value } // BackendConfig calls the config for the backend in ri // // It wraps any OAuth transactions as necessary so only straight // forward config questions are emitted func BackendConfig(ctx context.Context, name string, m configmap.Mapper, ri *RegInfo, choices configmap.Getter, in ConfigIn) (out *ConfigOut, err error) { for { out, err = backendConfigStep(ctx, name, m, ri, choices, in) if err != nil { break } if out == nil || out.State == "" { // finished break } if out.Option != nil { // question to ask user break } if out.Error != "" { // error to show user break } // non terminal state, but no question to ask or error to show - loop here in = ConfigIn{ State: out.State, Result: out.Result, } } return out, err } // ConfigAll should be passed in as the initial state to run the // entire config const ConfigAll = "*all" // Run the config state machine for the normal config func configAll(ctx context.Context, name string, m configmap.Mapper, ri *RegInfo, in ConfigIn) (out *ConfigOut, err error) { if len(ri.Options) == 0 { return ConfigGoto("*postconfig") } // States are encoded // // *all-ACTION,NUMBER,ADVANCED // // Where NUMBER is the current state, ADVANCED is a flag true or false // to say whether we are asking about advanced config and // ACTION is what the state should be doing next. stateParams, state := StatePop(in.State) stateParams, stateNumber := StatePop(stateParams) _, stateAdvanced := StatePop(stateParams) optionNumber := 0 advanced := stateAdvanced == "true" if stateNumber != "" { optionNumber, err = strconv.Atoi(stateNumber) if err != nil { return nil, fmt.Errorf("internal error: bad state number: %w", err) } } // Detect if reached the end of the questions if optionNumber == len(ri.Options) { if ri.Options.HasAdvanced() { return ConfigConfirm("*all-advanced", false, "config_fs_advanced", "Edit advanced config?") } return ConfigGoto("*postconfig") } else if optionNumber < 0 || optionNumber > len(ri.Options) { return nil, errors.New("internal error: option out of range") } // Make the next state newState := func(state string, i int, advanced bool) string { return StatePush("", state, fmt.Sprint(i), fmt.Sprint(advanced)) } // Find the current option option := &ri.Options[optionNumber] switch state { case "*all": // If option is hidden or doesn't match advanced setting then skip it if option.Hide&OptionHideConfigurator != 0 || option.Advanced != advanced { return ConfigGoto(newState("*all", optionNumber+1, advanced)) } // Skip this question if it isn't the correct provider provider, _ := m.Get(ConfigProvider) if !MatchProvider(option.Provider, provider) { return ConfigGoto(newState("*all", optionNumber+1, advanced)) } out = &ConfigOut{ State: newState("*all-set", optionNumber, advanced), Option: option, } // Filter examples by provider if necessary if provider != "" && len(option.Examples) > 0 { optionCopy := option.Copy() optionCopy.Examples = OptionExamples{} for _, example := range option.Examples { if MatchProvider(example.Provider, provider) { optionCopy.Examples = append(optionCopy.Examples, example) } } out.Option = optionCopy } return out, nil case "*all-set": // Set the value if not different to current // Note this won't set blank values in the config file // if the default is blank currentValue, _ := m.Get(option.Name) if currentValue != in.Result { m.Set(option.Name, in.Result) } // Find the next question return ConfigGoto(newState("*all", optionNumber+1, advanced)) case "*all-advanced": // Reply to edit advanced question if in.Result == "true" { return ConfigGoto(newState("*all", 0, true)) } return ConfigGoto("*postconfig") } return nil, fmt.Errorf("internal error: bad state %q", state) } func backendConfigStep(ctx context.Context, name string, m configmap.Mapper, ri *RegInfo, choices configmap.Getter, in ConfigIn) (out *ConfigOut, err error) { ci := GetConfig(ctx) Debugf(name, "config in: state=%q, result=%q", in.State, in.Result) defer func() { Debugf(name, "config out: out=%+v, err=%v", out, err) }() switch { case strings.HasPrefix(in.State, ConfigAll): // Do all config out, err = configAll(ctx, name, m, ri, in) case strings.HasPrefix(in.State, "*oauth"): // Do internal oauth states out, err = ConfigOAuth(ctx, name, m, ri, in) case strings.HasPrefix(in.State, "*postconfig"): // Do the post config starting from state "" in.State = "" return backendConfigStep(ctx, name, m, ri, choices, in) case strings.HasPrefix(in.State, "*"): err = fmt.Errorf("unknown internal state %q", in.State) default: // Otherwise pass to backend if ri.Config == nil { return nil, nil } out, err = ri.Config(ctx, name, m, in) } if err != nil { return nil, err } switch { case out == nil: case out.OAuth != nil: // If this is an OAuth state the deal with it here returnState := out.State // If rclone authorize, stop after doing oauth if isConfigOAuthOnly(ctx) { Debugf(nil, "OAuth only is set - overriding return state") returnState = "" } // Run internal state, saving the input so we can recall the state return ConfigGoto(StatePush("", "*oauth", returnState, in.State, in.Result)) case out.Option != nil: if out.Option.Name == "" { return nil, errors.New("internal error: no name set in Option") } // If override value is set in the choices then use that if result, ok := choices.Get(out.Option.Name); ok { Debugf(nil, "Override value found, choosing value %q for state %q", result, out.State) return ConfigResult(out.State, result) } // If AutoConfirm is set, choose the default value if ci.AutoConfirm { result := fmt.Sprint(out.Option.Default) Debugf(nil, "Auto confirm is set, choosing default %q for state %q, override by setting config parameter %q", result, out.State, out.Option.Name) return ConfigResult(out.State, result) } // If fs.ConfigEdit is set then make the default value // in the config the current value. if result, ok := choices.Get(ConfigEdit); ok && result == "true" { if value, ok := m.Get(out.Option.Name); ok { newOption := out.Option.Copy() oldValue := newOption.Value err = newOption.Set(value) if err != nil { Errorf(nil, "Failed to set %q from %q - using default: %v", out.Option.Name, value, err) } else { newOption.Default = newOption.Value newOption.Value = oldValue out.Option = newOption } } } } return out, nil } // MatchProvider returns true if provider matches the providerConfig string. // // The providerConfig string can either be a list of providers to // match, or if it starts with "!" it will be a list of providers not // to match. // // If either providerConfig or provider is blank then it will return true func MatchProvider(providerConfig, provider string) bool { if providerConfig == "" || provider == "" { return true } negate := false if strings.HasPrefix(providerConfig, "!") { providerConfig = providerConfig[1:] negate = true } providers := strings.Split(providerConfig, ",") matched := slices.Contains(providers, provider) if negate { return !matched } return matched } rclone-v1.71.0/fs/backend_config_test.go000066400000000000000000000027001505210326400201570ustar00rootroot00000000000000package fs import ( "fmt" "testing" "github.com/stretchr/testify/assert" ) func TestStatePush(t *testing.T) { assert.Equal(t, "", StatePush("")) assert.Equal(t, "", StatePush("", "")) assert.Equal(t, "a", StatePush("", "a")) assert.Equal(t, "a,1，2，3", StatePush("", "a", "1,2,3")) assert.Equal(t, "potato", StatePush("potato")) assert.Equal(t, ",potato", StatePush("potato", "")) assert.Equal(t, "a,potato", StatePush("potato", "a")) assert.Equal(t, "a,1，2，3,potato", StatePush("potato", "a", "1,2,3")) } func TestStatePop(t *testing.T) { state, value := StatePop("") assert.Equal(t, "", value) assert.Equal(t, "", state) state, value = StatePop("a") assert.Equal(t, "a", value) assert.Equal(t, "", state) state, value = StatePop("a,1，2，3") assert.Equal(t, "a", value) assert.Equal(t, "1，2，3", state) state, value = StatePop("1，2，3,a") assert.Equal(t, "1,2,3", value) assert.Equal(t, "a", state) } func TestMatchProvider(t *testing.T) { for _, test := range []struct { config string provider string want bool }{ {"", "", true}, {"one", "one", true}, {"one,two", "two", true}, {"one,two,three", "two", true}, {"one", "on", false}, {"one,two,three", "tw", false}, {"!one,two,three", "two", false}, {"!one,two,three", "four", true}, } { what := fmt.Sprintf("%q,%q", test.config, test.provider) got := MatchProvider(test.config, test.provider) assert.Equal(t, test.want, got, what) } } rclone-v1.71.0/fs/bits.go000066400000000000000000000064341505210326400151550ustar00rootroot00000000000000package fs import ( "encoding/json" "fmt" "strings" ) // Bits is an option which can be any combination of the Choices. // // Suggested implementation is something like this: // // type bits = Bits[bitsChoices] // // const ( // bitA bits = 1 << iota // bitB // bitC // ) // // type bitsChoices struct{} // // func (bitsChoices) Choices() []BitsChoicesInfo { // return []BitsChoicesInfo{ // {Bit: uint64(0), Name: "OFF"}, // Optional Off value - "" if not defined // {Bit: uint64(bitA), Name: "A"}, // {Bit: uint64(bitB), Name: "B"}, // {Bit: uint64(bitC), Name: "C"}, // } // } type Bits[C BitsChoices] uint64 // BitsChoicesInfo should be returned from the Choices method type BitsChoicesInfo struct { Bit uint64 Name string } // BitsChoices returns the valid choices for this type. // // It must work on the zero value. // // Note that when using this in an Option the ExampleBitsChoices will be // filled in automatically. type BitsChoices interface { // Choices returns the valid choices for each bit of this type Choices() []BitsChoicesInfo } // String turns a Bits into a string func (b Bits[C]) String() string { var out []string choices := b.Choices() // Return an off value if set if b == 0 { for _, info := range choices { if info.Bit == 0 { return info.Name } } } for _, info := range choices { if info.Bit == 0 { continue } if b&Bits[C](info.Bit) != 0 { out = append(out, info.Name) b &^= Bits[C](info.Bit) } } if b != 0 { out = append(out, fmt.Sprintf("Unknown-0x%X", int(b))) } return strings.Join(out, ",") } // Help returns a comma separated list of all possible bits. func (b Bits[C]) Help() string { var out []string for _, info := range b.Choices() { out = append(out, info.Name) } return strings.Join(out, ", ") } // Choices returns the possible values of the Bits. func (b Bits[C]) Choices() []BitsChoicesInfo { var c C return c.Choices() } // Set a Bits as a comma separated list of flags func (b *Bits[C]) Set(s string) error { var flags Bits[C] parts := strings.Split(s, ",") choices := b.Choices() for _, part := range parts { found := false part = strings.TrimSpace(part) if part == "" { continue } for _, info := range choices { if strings.EqualFold(info.Name, part) { found = true flags |= Bits[C](info.Bit) } } if !found { return fmt.Errorf("invalid choice %q from: %s", part, b.Help()) } } *b = flags return nil } // IsSet returns true all the bits in mask are set in b. func (b Bits[C]) IsSet(mask Bits[C]) bool { return (b & mask) == mask } // Type of the value. // // If C has a Type() string method then it will be used instead. func (b Bits[C]) Type() string { var c C if do, ok := any(c).(typer); ok { return do.Type() } return "Bits" } // Scan implements the fmt.Scanner interface func (b *Bits[C]) Scan(s fmt.ScanState, ch rune) error { token, err := s.Token(true, nil) if err != nil { return err } return b.Set(string(token)) } // UnmarshalJSON makes sure the value can be parsed as a string or integer in JSON func (b *Bits[C]) UnmarshalJSON(in []byte) error { return UnmarshalJSONFlag(in, b, func(i int64) error { *b = (Bits[C])(i) return nil }) } // MarshalJSON encodes it as string func (b *Bits[C]) MarshalJSON() ([]byte, error) { return json.Marshal(b.String()) } rclone-v1.71.0/fs/bits_test.go000066400000000000000000000064211505210326400162100ustar00rootroot00000000000000package fs import ( "encoding/json" "fmt" "strconv" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) type bits = Bits[bitsChoices] const ( bitA bits = 1 << iota bitB bitC ) type bitsChoices struct{} func (bitsChoices) Choices() []BitsChoicesInfo { return []BitsChoicesInfo{ {uint64(0), "OFF"}, {uint64(bitA), "A"}, {uint64(bitB), "B"}, {uint64(bitC), "C"}, } } // Check it satisfies the interfaces var ( _ Flagger = (*bits)(nil) _ FlaggerNP = bits(0) ) func TestBitsString(t *testing.T) { assert.Equal(t, "OFF", bits(0).String()) assert.Equal(t, "A", (bitA).String()) assert.Equal(t, "A,B", (bitA | bitB).String()) assert.Equal(t, "A,B,C", (bitA | bitB | bitC).String()) assert.Equal(t, "A,Unknown-0x8000", (bitA | bits(0x8000)).String()) } func TestBitsHelp(t *testing.T) { assert.Equal(t, "OFF, A, B, C", bits(0).Help()) } func TestBitsSet(t *testing.T) { for _, test := range []struct { in string want bits wantErr string }{ {"", bits(0), ""}, {"B", bitB, ""}, {"B,A", bitB | bitA, ""}, {"a,b,C", bitA | bitB | bitC, ""}, {"A,B,unknown,E", 0, `invalid choice "unknown" from: OFF, A, B, C`}, } { f := bits(0xffffffffffffffff) initial := f err := f.Set(test.in) if err != nil { if test.wantErr == "" { t.Errorf("Got an error when not expecting one on %q: %v", test.in, err) } else { assert.Contains(t, err.Error(), test.wantErr) } assert.Equal(t, initial, f, test.want) } else { if test.wantErr != "" { t.Errorf("Got no error when expecting one on %q", test.in) } else { assert.Equal(t, test.want, f) } } } } func TestBitsIsSet(t *testing.T) { b := bitA | bitB assert.True(t, b.IsSet(bitA)) assert.True(t, b.IsSet(bitB)) assert.True(t, b.IsSet(bitA|bitB)) assert.False(t, b.IsSet(bitC)) assert.False(t, b.IsSet(bitA|bitC)) } func TestBitsType(t *testing.T) { f := bits(0) assert.Equal(t, "Bits", f.Type()) } func TestBitsScan(t *testing.T) { var v bits n, err := fmt.Sscan(" C,B ", &v) require.NoError(t, err) assert.Equal(t, 1, n) assert.Equal(t, bitC|bitB, v) } func TestBitsUnmarshallJSON(t *testing.T) { for _, test := range []struct { in string want bits wantErr string }{ {`""`, bits(0), ""}, {`"B"`, bitB, ""}, {`"B,A"`, bitB | bitA, ""}, {`"A,B,C"`, bitA | bitB | bitC, ""}, {`"A,B,unknown,E"`, 0, `invalid choice "unknown" from: OFF, A, B, C`}, {`0`, bits(0), ""}, {strconv.Itoa(int(bitB)), bitB, ""}, {strconv.Itoa(int(bitB | bitA)), bitB | bitA, ""}, } { f := bits(0xffffffffffffffff) initial := f err := json.Unmarshal([]byte(test.in), &f) if err != nil { if test.wantErr == "" { t.Errorf("Got an error when not expecting one on %q: %v", test.in, err) } else { assert.Contains(t, err.Error(), test.wantErr) } assert.Equal(t, initial, f, test.want) } else { if test.wantErr != "" { t.Errorf("Got no error when expecting one on %q", test.in) } else { assert.Equal(t, test.want, f) } } } } func TestBitsMarshalJSON(t *testing.T) { for _, test := range []struct { in bits want string }{ {bitA | bitC, `"A,C"`}, {0, `"OFF"`}, } { got, err := json.Marshal(&test.in) require.NoError(t, err) assert.Equal(t, test.want, string(got), fmt.Sprintf("%#v", test.in)) } } rclone-v1.71.0/fs/bwtimetable.go000066400000000000000000000157021505210326400165110ustar00rootroot00000000000000package fs import ( "encoding/json" "errors" "fmt" "strconv" "strings" "time" ) // BwPair represents an upload and a download bandwidth type BwPair struct { Tx SizeSuffix // upload bandwidth Rx SizeSuffix // download bandwidth } // String returns a printable representation of a BwPair func (bp *BwPair) String() string { var out strings.Builder out.WriteString(bp.Tx.String()) if bp.Rx != bp.Tx { out.WriteRune(':') out.WriteString(bp.Rx.String()) } return out.String() } // Set the bandwidth from a string which is either // SizeSuffix or SizeSuffix:SizeSuffix (for tx:rx bandwidth) func (bp *BwPair) Set(s string) (err error) { colon := strings.Index(s, ":") stx, srx := s, "" if colon >= 0 { stx, srx = s[:colon], s[colon+1:] } err = bp.Tx.Set(stx) if err != nil { return err } if colon < 0 { bp.Rx = bp.Tx } else { err = bp.Rx.Set(srx) if err != nil { return err } } return nil } // IsSet returns true if either of the bandwidth limits are set func (bp *BwPair) IsSet() bool { return bp.Tx > 0 || bp.Rx > 0 } // BwTimeSlot represents a bandwidth configuration at a point in time. type BwTimeSlot struct { DayOfTheWeek int HHMM int Bandwidth BwPair } // BwTimetable contains all configured time slots. type BwTimetable []BwTimeSlot // String returns a printable representation of BwTimetable. func (x BwTimetable) String() string { var out strings.Builder bwOnly := len(x) == 1 && x[0].DayOfTheWeek == 0 && x[0].HHMM == 0 for _, ts := range x { if out.Len() != 0 { out.WriteRune(' ') } if !bwOnly { _, _ = fmt.Fprintf(&out, "%s-%02d:%02d,", time.Weekday(ts.DayOfTheWeek).String()[:3], ts.HHMM/100, ts.HHMM%100) } out.WriteString(ts.Bandwidth.String()) } return out.String() } // Basic hour format checking func validateHour(HHMM string) error { if len(HHMM) != 5 { return fmt.Errorf("invalid time specification (hh:mm): %q", HHMM) } hh, err := strconv.Atoi(HHMM[0:2]) if err != nil { return fmt.Errorf("invalid hour in time specification %q: %v", HHMM, err) } if hh < 0 || hh > 23 { return fmt.Errorf("invalid hour (must be between 00 and 23): %q", hh) } mm, err := strconv.Atoi(HHMM[3:]) if err != nil { return fmt.Errorf("invalid minute in time specification: %q: %v", HHMM, err) } if mm < 0 || mm > 59 { return fmt.Errorf("invalid minute (must be between 00 and 59): %q", hh) } return nil } // Basic weekday format checking func parseWeekday(dayOfWeek string) (int, error) { dayOfWeek = strings.ToLower(dayOfWeek) if dayOfWeek == "sun" || dayOfWeek == "sunday" { return 0, nil } if dayOfWeek == "mon" || dayOfWeek == "monday" { return 1, nil } if dayOfWeek == "tue" || dayOfWeek == "tuesday" { return 2, nil } if dayOfWeek == "wed" || dayOfWeek == "wednesday" { return 3, nil } if dayOfWeek == "thu" || dayOfWeek == "thursday" { return 4, nil } if dayOfWeek == "fri" || dayOfWeek == "friday" { return 5, nil } if dayOfWeek == "sat" || dayOfWeek == "saturday" { return 6, nil } return 0, fmt.Errorf("invalid weekday: %q", dayOfWeek) } // Set the bandwidth timetable. func (x *BwTimetable) Set(s string) error { // The timetable is formatted as: // "dayOfWeek-hh:mm,bandwidth dayOfWeek-hh:mm,bandwidth..." ex: "Mon-10:00,10G Mon-11:30,1G Tue-18:00,off" // If only a single bandwidth identifier is provided, we assume constant bandwidth. if len(s) == 0 { return errors.New("empty string") } // Single value without time specification. if !strings.Contains(s, " ") && !strings.Contains(s, ",") { ts := BwTimeSlot{} if err := ts.Bandwidth.Set(s); err != nil { return err } ts.DayOfTheWeek = 0 ts.HHMM = 0 *x = BwTimetable{ts} return nil } // Split the timetable string by both spaces and semicolons for _, tok := range strings.FieldsFunc(s, func(r rune) bool { return r == ' ' || r == ';' }) { tv := strings.Split(tok, ",") // Format must be dayOfWeek-HH:MM,BW if len(tv) != 2 { return fmt.Errorf("invalid time/bandwidth specification: %q", tok) } weekday := 0 HHMM := "" if !strings.Contains(tv[0], "-") { HHMM = tv[0] if err := validateHour(HHMM); err != nil { return err } for i := range 7 { hh, _ := strconv.Atoi(HHMM[0:2]) mm, _ := strconv.Atoi(HHMM[3:]) ts := BwTimeSlot{ DayOfTheWeek: i, HHMM: (hh * 100) + mm, } if err := ts.Bandwidth.Set(tv[1]); err != nil { return err } *x = append(*x, ts) } } else { timespec := strings.Split(tv[0], "-") if len(timespec) != 2 { return fmt.Errorf("invalid time specification: %q", tv[0]) } var err error weekday, err = parseWeekday(timespec[0]) if err != nil { return err } HHMM = timespec[1] if err := validateHour(HHMM); err != nil { return err } hh, _ := strconv.Atoi(HHMM[0:2]) mm, _ := strconv.Atoi(HHMM[3:]) ts := BwTimeSlot{ DayOfTheWeek: weekday, HHMM: (hh * 100) + mm, } // Bandwidth limit for this time slot. if err := ts.Bandwidth.Set(tv[1]); err != nil { return err } *x = append(*x, ts) } } return nil } // Difference in minutes between lateDayOfWeekHHMM and earlyDayOfWeekHHMM func timeDiff(lateDayOfWeekHHMM int, earlyDayOfWeekHHMM int) int { lateTimeMinutes := (lateDayOfWeekHHMM / 10000) * 24 * 60 lateTimeMinutes += ((lateDayOfWeekHHMM / 100) % 100) * 60 lateTimeMinutes += lateDayOfWeekHHMM % 100 earlyTimeMinutes := (earlyDayOfWeekHHMM / 10000) * 24 * 60 earlyTimeMinutes += ((earlyDayOfWeekHHMM / 100) % 100) * 60 earlyTimeMinutes += earlyDayOfWeekHHMM % 100 return lateTimeMinutes - earlyTimeMinutes } // LimitAt returns a BwTimeSlot for the time requested. func (x BwTimetable) LimitAt(tt time.Time) BwTimeSlot { // If the timetable is empty, we return an unlimited BwTimeSlot starting at Sunday midnight. if len(x) == 0 { return BwTimeSlot{Bandwidth: BwPair{-1, -1}} } dayOfWeekHHMM := int(tt.Weekday())*10000 + tt.Hour()*100 + tt.Minute() // By default, we return the last element in the timetable. This // satisfies two conditions: 1) If there's only one element it // will always be selected, and 2) The last element of the table // will "wrap around" until overridden by an earlier time slot. // there's only one time slot in the timetable. ret := x[len(x)-1] mindif := 0 first := true // Look for most recent time slot. for _, ts := range x { // Ignore the past if dayOfWeekHHMM < (ts.DayOfTheWeek*10000)+ts.HHMM { continue } dif := timeDiff(dayOfWeekHHMM, (ts.DayOfTheWeek*10000)+ts.HHMM) if first { mindif = dif first = false } if dif <= mindif { mindif = dif ret = ts } } return ret } // Type of the value func (x BwTimetable) Type() string { return "BwTimetable" } // UnmarshalJSON unmarshals a string value func (x *BwTimetable) UnmarshalJSON(in []byte) error { var s string err := json.Unmarshal(in, &s) if err != nil { return err } return x.Set(s) } // MarshalJSON marshals as a string value func (x BwTimetable) MarshalJSON() ([]byte, error) { s := x.String() return json.Marshal(s) } rclone-v1.71.0/fs/bwtimetable_test.go000066400000000000000000001135451505210326400175540ustar00rootroot00000000000000package fs import ( "encoding/json" "testing" "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Check it satisfies the interfaces var ( _ Flagger = (*BwTimetable)(nil) _ FlaggerNP = BwTimetable{} ) func TestBwTimetableSet(t *testing.T) { for _, test := range []struct { in string want BwTimetable err bool out string }{ {"", BwTimetable{}, true, ""}, {"bad,bad", BwTimetable{}, true, ""}, {"bad bad", BwTimetable{}, true, ""}, {"bad", BwTimetable{}, true, ""}, {"1000X", BwTimetable{}, true, ""}, {"2401,666", BwTimetable{}, true, ""}, {"1061,666", BwTimetable{}, true, ""}, {"bad-10:20,666", BwTimetable{}, true, ""}, {"Mon-bad,666", BwTimetable{}, true, ""}, {"Mon-10:20,bad", BwTimetable{}, true, ""}, { "0", BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 0, Bandwidth: BwPair{Tx: 0, Rx: 0}}, }, false, "0", }, { "666", BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 0, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, }, false, "666Ki", }, { "666:333", BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 0, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 333 * 1024}}, }, false, "666Ki:333Ki", }, { "10:20,666", BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, }, false, "Sun-10:20,666Ki Mon-10:20,666Ki Tue-10:20,666Ki Wed-10:20,666Ki Thu-10:20,666Ki Fri-10:20,666Ki Sat-10:20,666Ki", }, { "10:20,666:333", BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 333 * 1024}}, }, false, "Sun-10:20,666Ki:333Ki Mon-10:20,666Ki:333Ki Tue-10:20,666Ki:333Ki Wed-10:20,666Ki:333Ki Thu-10:20,666Ki:333Ki Fri-10:20,666Ki:333Ki Sat-10:20,666Ki:333Ki", }, { "11:00,333 13:40,666 23:50,10M 23:59,off", BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, }, false, "Sun-11:00,333Ki Mon-11:00,333Ki Tue-11:00,333Ki Wed-11:00,333Ki Thu-11:00,333Ki Fri-11:00,333Ki Sat-11:00,333Ki Sun-13:40,666Ki Mon-13:40,666Ki Tue-13:40,666Ki Wed-13:40,666Ki Thu-13:40,666Ki Fri-13:40,666Ki Sat-13:40,666Ki Sun-23:50,10Mi Mon-23:50,10Mi Tue-23:50,10Mi Wed-23:50,10Mi Thu-23:50,10Mi Fri-23:50,10Mi Sat-23:50,10Mi Sun-23:59,off Mon-23:59,off Tue-23:59,off Wed-23:59,off Thu-23:59,off Fri-23:59,off Sat-23:59,off", }, { "11:00,333:666 13:40,666:off 23:50,10M:1M 23:59,off:10M", BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 1 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 1 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 1 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 1 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 1 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 1 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 1 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: 10 * 1024 * 1024}}, }, false, "Sun-11:00,333Ki:666Ki Mon-11:00,333Ki:666Ki Tue-11:00,333Ki:666Ki Wed-11:00,333Ki:666Ki Thu-11:00,333Ki:666Ki Fri-11:00,333Ki:666Ki Sat-11:00,333Ki:666Ki Sun-13:40,666Ki:off Mon-13:40,666Ki:off Tue-13:40,666Ki:off Wed-13:40,666Ki:off Thu-13:40,666Ki:off Fri-13:40,666Ki:off Sat-13:40,666Ki:off Sun-23:50,10Mi:1Mi Mon-23:50,10Mi:1Mi Tue-23:50,10Mi:1Mi Wed-23:50,10Mi:1Mi Thu-23:50,10Mi:1Mi Fri-23:50,10Mi:1Mi Sat-23:50,10Mi:1Mi Sun-23:59,off:10Mi Mon-23:59,off:10Mi Tue-23:59,off:10Mi Wed-23:59,off:10Mi Thu-23:59,off:10Mi Fri-23:59,off:10Mi Sat-23:59,off:10Mi", }, { "Mon-11:00,333 Tue-13:40,666:333 Fri-00:00,10M Sat-10:00,off Sun-23:00,666", BwTimetable{ BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 0000, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1000, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, }, false, "Mon-11:00,333Ki Tue-13:40,666Ki:333Ki Fri-00:00,10Mi Sat-10:00,off Sun-23:00,666Ki", }, { "Mon-11:00,333 Tue-13:40,666 Fri-00:00,10M 00:01,off Sun-23:00,666:off", BwTimetable{ BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 0000, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 1, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: -1}}, }, false, "Mon-11:00,333Ki Tue-13:40,666Ki Fri-00:00,10Mi Sun-00:01,off Mon-00:01,off Tue-00:01,off Wed-00:01,off Thu-00:01,off Fri-00:01,off Sat-00:01,off Sun-23:00,666Ki:off", }, { // from the docs "08:00,512 12:00,10M 13:00,512 18:00,30M 23:00,off", BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 800, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 800, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 800, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 800, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 800, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 800, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 800, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 1200, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1200, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1200, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1200, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1200, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1200, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1200, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 1300, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1300, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1300, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1300, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1300, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1300, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1300, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 1800, Bandwidth: BwPair{Tx: 30 * 1024 * 1024, Rx: 30 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1800, Bandwidth: BwPair{Tx: 30 * 1024 * 1024, Rx: 30 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1800, Bandwidth: BwPair{Tx: 30 * 1024 * 1024, Rx: 30 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1800, Bandwidth: BwPair{Tx: 30 * 1024 * 1024, Rx: 30 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1800, Bandwidth: BwPair{Tx: 30 * 1024 * 1024, Rx: 30 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1800, Bandwidth: BwPair{Tx: 30 * 1024 * 1024, Rx: 30 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1800, Bandwidth: BwPair{Tx: 30 * 1024 * 1024, Rx: 30 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2300, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2300, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2300, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2300, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2300, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2300, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2300, Bandwidth: BwPair{Tx: -1, Rx: -1}}, }, false, "Sun-08:00,512Ki Mon-08:00,512Ki Tue-08:00,512Ki Wed-08:00,512Ki Thu-08:00,512Ki Fri-08:00,512Ki Sat-08:00,512Ki Sun-12:00,10Mi Mon-12:00,10Mi Tue-12:00,10Mi Wed-12:00,10Mi Thu-12:00,10Mi Fri-12:00,10Mi Sat-12:00,10Mi Sun-13:00,512Ki Mon-13:00,512Ki Tue-13:00,512Ki Wed-13:00,512Ki Thu-13:00,512Ki Fri-13:00,512Ki Sat-13:00,512Ki Sun-18:00,30Mi Mon-18:00,30Mi Tue-18:00,30Mi Wed-18:00,30Mi Thu-18:00,30Mi Fri-18:00,30Mi Sat-18:00,30Mi Sun-23:00,off Mon-23:00,off Tue-23:00,off Wed-23:00,off Thu-23:00,off Fri-23:00,off Sat-23:00,off", }, { // from the docs "Mon-00:00,512 Fri-23:59,10M Sat-10:00,1M Sun-20:00,off", BwTimetable{ BwTimeSlot{DayOfTheWeek: 1, HHMM: 0, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2359, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1000, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2000, Bandwidth: BwPair{Tx: -1, Rx: -1}}, }, false, "Mon-00:00,512Ki Fri-23:59,10Mi Sat-10:00,1Mi Sun-20:00,off", }, { // from the docs "Mon-00:00,512 12:00,1M Sun-20:00,off", BwTimetable{ BwTimeSlot{DayOfTheWeek: 1, HHMM: 0, Bandwidth: BwPair{Tx: 512 * 1024, Rx: 512 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 1200, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1200, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1200, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1200, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1200, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1200, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1200, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2000, Bandwidth: BwPair{Tx: -1, Rx: -1}}, }, false, "Mon-00:00,512Ki Sun-12:00,1Mi Mon-12:00,1Mi Tue-12:00,1Mi Wed-12:00,1Mi Thu-12:00,1Mi Fri-12:00,1Mi Sat-12:00,1Mi Sun-20:00,off", }, { "11:00,333;13:40,666;23:50,10M;23:59,off", BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2350, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2359, Bandwidth: BwPair{Tx: -1, Rx: -1}}, }, false, "Sun-11:00,333Ki Mon-11:00,333Ki Tue-11:00,333Ki Wed-11:00,333Ki Thu-11:00,333Ki Fri-11:00,333Ki Sat-11:00,333Ki Sun-13:40,666Ki Mon-13:40,666Ki Tue-13:40,666Ki Wed-13:40,666Ki Thu-13:40,666Ki Fri-13:40,666Ki Sat-13:40,666Ki Sun-23:50,10Mi Mon-23:50,10Mi Tue-23:50,10Mi Wed-23:50,10Mi Thu-23:50,10Mi Fri-23:50,10Mi Sat-23:50,10Mi Sun-23:59,off Mon-23:59,off Tue-23:59,off Wed-23:59,off Thu-23:59,off Fri-23:59,off Sat-23:59,off", }, { "Mon-11:00,333;Tue-13:40,666:333;Fri-00:00,10M;Sat-10:00,off;Sun-23:00,666", BwTimetable{ BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 0000, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 10 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1000, Bandwidth: BwPair{Tx: -1, Rx: -1}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, }, false, "Mon-11:00,333Ki Tue-13:40,666Ki:333Ki Fri-00:00,10Mi Sat-10:00,off Sun-23:00,666Ki", }, } { tt := BwTimetable{} err := tt.Set(test.in) if test.err { require.Error(t, err) } else { require.NoError(t, err) } assert.Equal(t, test.want, tt) assert.Equal(t, test.out, tt.String()) } } func TestBwTimetableLimitAt(t *testing.T) { for _, test := range []struct { tt BwTimetable now time.Time want BwTimeSlot }{ { BwTimetable{}, time.Date(2017, time.April, 20, 15, 0, 0, 0, time.UTC), BwTimeSlot{DayOfTheWeek: 0, HHMM: 0, Bandwidth: BwPair{Tx: -1, Rx: -1}}, }, { BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 333 * 1024}}, }, time.Date(2017, time.April, 20, 15, 0, 0, 0, time.UTC), BwTimeSlot{DayOfTheWeek: 4, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 666 * 1024}}, }, { BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, }, time.Date(2017, time.April, 20, 10, 15, 0, 0, time.UTC), BwTimeSlot{DayOfTheWeek: 3, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, }, { BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, }, time.Date(2017, time.April, 20, 11, 0, 0, 0, time.UTC), BwTimeSlot{DayOfTheWeek: 4, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, }, { BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, }, time.Date(2017, time.April, 20, 13, 1, 0, 0, time.UTC), BwTimeSlot{DayOfTheWeek: 4, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, }, { BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2301, Bandwidth: BwPair{Tx: 1024 * 1024, Rx: 102 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, }, time.Date(2017, time.April, 20, 23, 59, 0, 0, time.UTC), BwTimeSlot{DayOfTheWeek: 4, HHMM: 2350, Bandwidth: BwPair{Tx: -1, Rx: 1024 * 1024}}, }, { BwTimetable{ BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 0000, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 1 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1000, Bandwidth: BwPair{Tx: -1, Rx: 100 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, }, time.Date(2017, time.April, 20, 23, 59, 0, 0, time.UTC), BwTimeSlot{DayOfTheWeek: 2, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, }, { BwTimetable{ BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 0000, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 1 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1000, Bandwidth: BwPair{Tx: -1, Rx: 100 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, }, time.Date(2017, time.April, 21, 23, 59, 0, 0, time.UTC), BwTimeSlot{DayOfTheWeek: 5, HHMM: 0000, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 1 * 1024 * 1024}}, }, { BwTimetable{ BwTimeSlot{DayOfTheWeek: 1, HHMM: 1100, Bandwidth: BwPair{Tx: 333 * 1024, Rx: 33 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1340, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 0000, Bandwidth: BwPair{Tx: 10 * 1024 * 1024, Rx: 1 * 1024 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1000, Bandwidth: BwPair{Tx: -1, Rx: 100 * 1024}}, BwTimeSlot{DayOfTheWeek: 0, HHMM: 2300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, }, time.Date(2017, time.April, 17, 10, 59, 0, 0, time.UTC), BwTimeSlot{DayOfTheWeek: 0, HHMM: 2300, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 66 * 1024}}, }, } { slot := test.tt.LimitAt(test.now) assert.Equal(t, test.want, slot) } } func TestBwTimetableUnmarshalJSON(t *testing.T) { for _, test := range []struct { in string want BwTimetable err bool }{ { `"Mon-10:20,bad"`, BwTimetable(nil), true, }, { `"0"`, BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 0, Bandwidth: BwPair{Tx: 0, Rx: 0}}, }, false, }, { `"666"`, BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 0, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, }, false, }, { `"666:333"`, BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 0, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 333 * 1024}}, }, false, }, { `"10:20,666"`, BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, }, false, }, } { var bwt BwTimetable err := json.Unmarshal([]byte(test.in), &bwt) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, bwt) } } func TestBwTimetableMarshalJSON(t *testing.T) { for _, test := range []struct { in BwTimetable want string }{ { BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 0, Bandwidth: BwPair{Tx: 0, Rx: 0}}, }, `"0"`, }, { BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 0, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, }, `"666Ki"`, }, { BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 0, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 333 * 1024}}, }, `"666Ki:333Ki"`, }, { BwTimetable{ BwTimeSlot{DayOfTheWeek: 0, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 1, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 2, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 3, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 4, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 5, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, BwTimeSlot{DayOfTheWeek: 6, HHMM: 1020, Bandwidth: BwPair{Tx: 666 * 1024, Rx: 666 * 1024}}, }, `"Sun-10:20,666Ki Mon-10:20,666Ki Tue-10:20,666Ki Wed-10:20,666Ki Thu-10:20,666Ki Fri-10:20,666Ki Sat-10:20,666Ki"`, }, } { got, err := json.Marshal(test.in) require.NoError(t, err, test.want) assert.Equal(t, test.want, string(got)) } } rclone-v1.71.0/fs/cache/000077500000000000000000000000001505210326400147215ustar00rootroot00000000000000rclone-v1.71.0/fs/cache/cache.go000066400000000000000000000205401505210326400163140ustar00rootroot00000000000000// Package cache implements the Fs cache package cache import ( "context" "runtime" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/lib/cache" ) var ( once sync.Once // creation c *cache.Cache mu sync.Mutex // mutex to protect remap remap = map[string]string{} // map user supplied names to canonical names - [fsString]canonicalName childParentMap = map[string]string{} // tracks a one-to-many relationship between parent dirs and their direct children files - [child]parent ) // Create the cache just once func createOnFirstUse() { once.Do(func() { ci := fs.GetConfig(context.Background()) c = cache.New() c.SetExpireDuration(time.Duration(ci.FsCacheExpireDuration)) c.SetExpireInterval(time.Duration(ci.FsCacheExpireInterval)) c.SetFinalizer(func(value any) { if s, ok := value.(fs.Shutdowner); ok { _ = fs.CountError(context.Background(), s.Shutdown(context.Background())) } }) }) } // Canonicalize looks up fsString in the mapping from user supplied // names to canonical names and return the canonical form func Canonicalize(fsString string) string { createOnFirstUse() mu.Lock() canonicalName, ok := remap[fsString] mu.Unlock() if !ok { return fsString } fs.Debugf(nil, "fs cache: switching user supplied name %q for canonical name %q", fsString, canonicalName) return canonicalName } // Put in a mapping from fsString => canonicalName if they are different func addMapping(fsString, canonicalName string) { if canonicalName == fsString { return } mu.Lock() remap[fsString] = canonicalName mu.Unlock() } // addChild tracks known file (child) to directory (parent) relationships. // Note that the canonicalName of a child will always equal that of its parent, // but not everything with an equal canonicalName is a child. // It could be an alias or overridden version of a directory. func addChild(child, parent string) { if child == parent { return } mu.Lock() childParentMap[child] = parent mu.Unlock() } // returns true if name is definitely known to be a child (i.e. a file, not a dir). // returns false if name is a dir or if we don't know. func isChild(child string) bool { mu.Lock() _, found := childParentMap[child] mu.Unlock() return found } // ensures that we return fs.ErrorIsFile when necessary func getError(fsString string, err error) error { if err != nil && err != fs.ErrorIsFile { return err } if isChild(fsString) { return fs.ErrorIsFile } return nil } // GetFn gets an fs.Fs named fsString either from the cache or creates // it afresh with the create function func GetFn(ctx context.Context, fsString string, create func(ctx context.Context, fsString string) (fs.Fs, error)) (f fs.Fs, err error) { createOnFirstUse() canonicalFsString := Canonicalize(fsString) created := false value, err := c.Get(canonicalFsString, func(canonicalFsString string) (f any, ok bool, err error) { f, err = create(ctx, fsString) // always create the backend with the original non-canonicalised string ok = err == nil || err == fs.ErrorIsFile created = ok return f, ok, err }) f, ok := value.(fs.Fs) if err != nil && err != fs.ErrorIsFile { if ok { return f, err // for possible future uses of PutErr } return nil, err } // Check we stored the Fs at the canonical name if created { canonicalName := fs.ConfigString(f) if canonicalName != canonicalFsString { if err == nil { // it's a dir fs.Debugf(nil, "fs cache: renaming cache item %q to be canonical %q", canonicalFsString, canonicalName) value, found := c.Rename(canonicalFsString, canonicalName) if found { f = value.(fs.Fs) } addMapping(canonicalFsString, canonicalName) } else { // it's a file // the fs we cache is always the file's parent, never the file, // but we use the childParentMap to return the correct error status based on the fsString passed in. fs.Debugf(nil, "fs cache: renaming child cache item %q to be canonical for parent %q", canonicalFsString, canonicalName) value, found := c.Rename(canonicalFsString, canonicalName) // rename the file entry to parent if found { f = value.(fs.Fs) // if parent already exists, use it } Put(canonicalName, f) // force err == nil for the cache addMapping(canonicalFsString, canonicalName) // note the fsString-canonicalName connection for future lookups addChild(fsString, canonicalName) // note the file-directory connection for future lookups } } } return f, getError(fsString, err) // ensure fs.ErrorIsFile is returned when necessary } // Pin f into the cache until Unpin is called func Pin(f fs.Fs) { createOnFirstUse() c.Pin(fs.ConfigString(f)) } // PinUntilFinalized pins f into the cache until x is garbage collected // // This calls runtime.SetFinalizer on x so it shouldn't have a // finalizer already. func PinUntilFinalized(f fs.Fs, x any) { Pin(f) runtime.SetFinalizer(x, func(_ any) { Unpin(f) }) } // Unpin f from the cache func Unpin(f fs.Fs) { createOnFirstUse() c.Unpin(fs.ConfigString(f)) } // To avoid circular dependencies these are filled in by fs/rc/jobs/job.go var ( // JobGetJobID for internal use only JobGetJobID func(context.Context) (int64, bool) // JobOnFinish for internal use only JobOnFinish func(int64, func()) (func(), error) ) // Get gets an fs.Fs named fsString either from the cache or creates it afresh func Get(ctx context.Context, fsString string) (f fs.Fs, err error) { // If we are making a long lived backend which lives longer // than this request, we want to disconnect it from the // current context and in particular any WithCancel contexts, // but we want to preserve the config embedded in the context. newCtx := context.Background() newCtx = fs.CopyConfig(newCtx, ctx) newCtx = filter.CopyConfig(newCtx, ctx) f, err = GetFn(newCtx, fsString, fs.NewFs) if f == nil || (err != nil && err != fs.ErrorIsFile) { return f, err } // If this is part of an rc job then pin the backend until it finishes if JobOnFinish != nil && JobGetJobID != nil { if jobID, ok := JobGetJobID(ctx); ok { // fs.Debugf(f, "Pin for job %d", jobID) Pin(f) _, _ = JobOnFinish(jobID, func() { // fs.Debugf(f, "Unpin for job %d", jobID) Unpin(f) }) } } return f, err } // GetArr gets []fs.Fs from []fsStrings either from the cache or creates it afresh func GetArr(ctx context.Context, fsStrings []string) (f []fs.Fs, err error) { var fArr []fs.Fs for _, fsString := range fsStrings { f1, err1 := GetFn(ctx, fsString, fs.NewFs) if err1 != nil { return fArr, err1 } fArr = append(fArr, f1) } return fArr, nil } // PutErr puts an fs.Fs named fsString into the cache with err func PutErr(fsString string, f fs.Fs, err error) { createOnFirstUse() canonicalName := fs.ConfigString(f) c.PutErr(canonicalName, f, err) addMapping(fsString, canonicalName) if err == fs.ErrorIsFile { addChild(fsString, canonicalName) } } // Put puts an fs.Fs named fsString into the cache func Put(fsString string, f fs.Fs) { PutErr(fsString, f, nil) } // ClearConfig deletes all entries which were based on the config name passed in // // Returns number of entries deleted func ClearConfig(name string) (deleted int) { createOnFirstUse() ClearMappingsPrefix(name) return c.DeletePrefix(name + ":") } // Clear removes everything from the cache func Clear() { createOnFirstUse() c.Clear() ClearMappings() } // Entries returns the number of entries in the cache func Entries() int { createOnFirstUse() return c.Entries() } // ClearMappings removes everything from remap and childParentMap func ClearMappings() { mu.Lock() defer mu.Unlock() remap = map[string]string{} childParentMap = map[string]string{} } // ClearMappingsPrefix deletes all mappings to parents with given prefix // // Returns number of entries deleted func ClearMappingsPrefix(prefix string) (deleted int) { mu.Lock() do := func(mapping map[string]string) { for key, val := range mapping { if !strings.HasPrefix(val, prefix) { continue } delete(mapping, key) deleted++ } } do(remap) do(childParentMap) mu.Unlock() return deleted } // EntriesWithPinCount returns the number of pinned and unpinned entries in the cache // // Each entry is counted only once, regardless of entry.pinCount func EntriesWithPinCount() (pinned, unpinned int) { createOnFirstUse() return c.EntriesWithPinCount() } rclone-v1.71.0/fs/cache/cache_test.go000066400000000000000000000157151505210326400173630ustar00rootroot00000000000000package cache import ( "context" "errors" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest/mockfs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var ( called = 0 errSentinel = errors.New("an error") ) func mockNewFs(t *testing.T) func(ctx context.Context, path string) (fs.Fs, error) { called = 0 create := func(ctx context.Context, path string) (f fs.Fs, err error) { assert.Equal(t, 0, called) called++ switch path { case "mock:/": return mockfs.NewFs(ctx, "mock", "/", nil) case "mock:/file.txt", "mock:file.txt", "mock:/file2.txt", "mock:file2.txt": fMock, err := mockfs.NewFs(ctx, "mock", "/", nil) require.NoError(t, err) return fMock, fs.ErrorIsFile case "mock:/error": return nil, errSentinel } t.Fatalf("Unknown path %q", path) panic("unreachable") } t.Cleanup(Clear) return create } func TestGet(t *testing.T) { create := mockNewFs(t) assert.Equal(t, 0, Entries()) f, err := GetFn(context.Background(), "mock:/", create) require.NoError(t, err) assert.Equal(t, 1, Entries()) f2, err := GetFn(context.Background(), "mock:/", create) require.NoError(t, err) assert.Equal(t, f, f2) } func TestGetFile(t *testing.T) { defer ClearMappings() create := mockNewFs(t) assert.Equal(t, 0, Entries()) f, err := GetFn(context.Background(), "mock:/file.txt", create) require.Equal(t, fs.ErrorIsFile, err) require.NotNil(t, f) assert.Equal(t, 1, Entries()) f2, err := GetFn(context.Background(), "mock:/file.txt", create) require.Equal(t, fs.ErrorIsFile, err) require.NotNil(t, f2) assert.Equal(t, f, f2) // check it is also found when referred to by parent name f2, err = GetFn(context.Background(), "mock:/", create) require.Nil(t, err) require.NotNil(t, f2) assert.Equal(t, f, f2) } func TestGetFile2(t *testing.T) { defer ClearMappings() create := mockNewFs(t) assert.Equal(t, 0, Entries()) f, err := GetFn(context.Background(), "mock:file.txt", create) require.Equal(t, fs.ErrorIsFile, err) require.NotNil(t, f) assert.Equal(t, 1, Entries()) f2, err := GetFn(context.Background(), "mock:file.txt", create) require.Equal(t, fs.ErrorIsFile, err) require.NotNil(t, f2) assert.Equal(t, f, f2) // check it is also found when referred to by parent name f2, err = GetFn(context.Background(), "mock:/", create) require.Nil(t, err) require.NotNil(t, f2) assert.Equal(t, f, f2) } func TestGetError(t *testing.T) { create := mockNewFs(t) assert.Equal(t, 0, Entries()) f, err := GetFn(context.Background(), "mock:/error", create) require.Equal(t, errSentinel, err) require.Equal(t, nil, f) assert.Equal(t, 0, Entries()) } func TestPutErr(t *testing.T) { create := mockNewFs(t) f, err := mockfs.NewFs(context.Background(), "mock", "", nil) require.NoError(t, err) assert.Equal(t, 0, Entries()) PutErr("mock:/", f, fs.ErrorNotFoundInConfigFile) assert.Equal(t, 1, Entries()) fNew, err := GetFn(context.Background(), "mock:/", create) require.True(t, errors.Is(err, fs.ErrorNotFoundInConfigFile)) require.Equal(t, f, fNew) assert.Equal(t, 1, Entries()) // Check canonicalisation PutErr("mock:/file.txt", f, fs.ErrorNotFoundInConfigFile) fNew, err = GetFn(context.Background(), "mock:/file.txt", create) require.True(t, errors.Is(err, fs.ErrorNotFoundInConfigFile)) require.Equal(t, f, fNew) assert.Equal(t, 1, Entries()) } func TestPut(t *testing.T) { create := mockNewFs(t) f, err := mockfs.NewFs(context.Background(), "mock", "/alien", nil) require.NoError(t, err) assert.Equal(t, 0, Entries()) Put("mock:/alien", f) assert.Equal(t, 1, Entries()) fNew, err := GetFn(context.Background(), "mock:/alien", create) require.NoError(t, err) require.Equal(t, f, fNew) assert.Equal(t, 1, Entries()) // Check canonicalisation Put("mock:/alien/", f) fNew, err = GetFn(context.Background(), "mock:/alien/", create) require.NoError(t, err) require.Equal(t, f, fNew) assert.Equal(t, 1, Entries()) } func TestPin(t *testing.T) { create := mockNewFs(t) // Test pinning and unpinning nonexistent f, err := mockfs.NewFs(context.Background(), "mock", "/alien", nil) require.NoError(t, err) Pin(f) Unpin(f) // Now test pinning an existing f2, err := GetFn(context.Background(), "mock:/", create) require.NoError(t, err) Pin(f2) Unpin(f2) } func TestPinFile(t *testing.T) { defer ClearMappings() create := mockNewFs(t) // Test pinning and unpinning nonexistent f, err := mockfs.NewFs(context.Background(), "mock", "/file.txt", nil) require.NoError(t, err) Pin(f) Unpin(f) // Now test pinning an existing f2, err := GetFn(context.Background(), "mock:/file.txt", create) require.Equal(t, fs.ErrorIsFile, err) assert.Equal(t, 1, len(childParentMap)) Pin(f2) assert.Equal(t, 1, Entries()) pinned, unpinned := EntriesWithPinCount() assert.Equal(t, 1, pinned) assert.Equal(t, 0, unpinned) Unpin(f2) assert.Equal(t, 1, Entries()) pinned, unpinned = EntriesWithPinCount() assert.Equal(t, 0, pinned) assert.Equal(t, 1, unpinned) // try a different child of the same parent, and parent // should not add additional cache items called = 0 // this one does create() because we haven't seen it before and don't yet know it's a file f3, err := GetFn(context.Background(), "mock:/file2.txt", create) assert.Equal(t, fs.ErrorIsFile, err) assert.Equal(t, 1, Entries()) assert.Equal(t, 2, len(childParentMap)) parent, err := GetFn(context.Background(), "mock:/", create) assert.NoError(t, err) assert.Equal(t, 1, Entries()) assert.Equal(t, 2, len(childParentMap)) Pin(f3) assert.Equal(t, 1, Entries()) pinned, unpinned = EntriesWithPinCount() assert.Equal(t, 1, pinned) assert.Equal(t, 0, unpinned) Unpin(f3) assert.Equal(t, 1, Entries()) pinned, unpinned = EntriesWithPinCount() assert.Equal(t, 0, pinned) assert.Equal(t, 1, unpinned) Pin(parent) assert.Equal(t, 1, Entries()) pinned, unpinned = EntriesWithPinCount() assert.Equal(t, 1, pinned) assert.Equal(t, 0, unpinned) Unpin(parent) assert.Equal(t, 1, Entries()) pinned, unpinned = EntriesWithPinCount() assert.Equal(t, 0, pinned) assert.Equal(t, 1, unpinned) // all 3 should have equal configstrings assert.Equal(t, fs.ConfigString(f2), fs.ConfigString(f3)) assert.Equal(t, fs.ConfigString(f2), fs.ConfigString(parent)) } func TestClearConfig(t *testing.T) { create := mockNewFs(t) assert.Equal(t, 0, Entries()) _, err := GetFn(context.Background(), "mock:/file.txt", create) require.Equal(t, fs.ErrorIsFile, err) assert.Equal(t, 1, Entries()) assert.Equal(t, 1, ClearConfig("mock")) assert.Equal(t, 0, Entries()) } func TestClear(t *testing.T) { create := mockNewFs(t) // Create something _, err := GetFn(context.Background(), "mock:/", create) require.NoError(t, err) assert.Equal(t, 1, Entries()) Clear() assert.Equal(t, 0, Entries()) } func TestEntries(t *testing.T) { create := mockNewFs(t) assert.Equal(t, 0, Entries()) // Create something _, err := GetFn(context.Background(), "mock:/", create) require.NoError(t, err) assert.Equal(t, 1, Entries()) } rclone-v1.71.0/fs/chunkedreader/000077500000000000000000000000001505210326400164625ustar00rootroot00000000000000rclone-v1.71.0/fs/chunkedreader/chunkedreader.go000066400000000000000000000024171505210326400216210ustar00rootroot00000000000000// Package chunkedreader provides functionality for reading a stream in chunks. package chunkedreader import ( "context" "errors" "io" "github.com/rclone/rclone/fs" ) // io related errors returned by ChunkedReader var ( ErrorFileClosed = errors.New("file already closed") ErrorInvalidSeek = errors.New("invalid seek position") ) // ChunkedReader describes what a chunked reader can do. type ChunkedReader interface { io.Reader io.Seeker io.Closer fs.RangeSeeker Open() (ChunkedReader, error) } // New returns a ChunkedReader for the Object. // // An initialChunkSize of <= 0 will disable chunked reading. // If maxChunkSize is greater than initialChunkSize, the chunk size will be // doubled after each chunk read with a maximum of maxChunkSize. // A Seek or RangeSeek will reset the chunk size to it's initial value func New(ctx context.Context, o fs.Object, initialChunkSize int64, maxChunkSize int64, streams int) ChunkedReader { if initialChunkSize <= 0 { initialChunkSize = -1 } if maxChunkSize != -1 && maxChunkSize < initialChunkSize { maxChunkSize = initialChunkSize } if streams < 0 { streams = 0 } if streams <= 1 || o.Size() < 0 { return newSequential(ctx, o, initialChunkSize, maxChunkSize) } return newParallel(ctx, o, initialChunkSize, streams) } rclone-v1.71.0/fs/chunkedreader/chunkedreader_test.go000066400000000000000000000071001505210326400226520ustar00rootroot00000000000000package chunkedreader import ( "context" "fmt" "io" "math/rand" "testing" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/mockobject" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // TestMain drives the tests func TestMain(m *testing.M) { fstest.TestMain(m) } func TestChunkedReader(t *testing.T) { ctx := context.Background() o := mockobject.New("test.bin").WithContent([]byte("hello"), mockobject.SeekModeRegular) const MB = 1024 * 1024 for _, test := range []struct { initialChunkSize int64 maxChunkSize int64 streams int crType any unknownSize bool }{ {-1, MB, 0, new(sequential), false}, {MB, 10 * MB, 0, new(sequential), false}, {MB, 10 * MB, 1, new(sequential), false}, {MB, 10 * MB, 1, new(sequential), true}, {MB, 10 * MB, 2, new(parallel), false}, {MB, 10 * MB, 2, new(sequential), true}, } { what := fmt.Sprintf("%+v", test) o.SetUnknownSize(test.unknownSize) cr := New(ctx, o, test.initialChunkSize, test.maxChunkSize, test.streams) assert.IsType(t, test.crType, cr, what) require.NoError(t, cr.Close(), what) } } func testRead(content []byte, mode mockobject.SeekMode, streams int) func(*testing.T) { return func(t *testing.T) { ctx := context.Background() chunkSizes := []int64{-1, 0, 1, 15, 16, 17, 1023, 1024, 1025, 2000} offsets := []int64{0, 1, 2, 3, 4, 5, 7, 8, 9, 15, 16, 17, 31, 32, 33, 63, 64, 65, 511, 512, 513, 1023, 1024, 1025} limits := []int64{-1, 0, 1, 31, 32, 33, 1023, 1024, 1025} cl := int64(len(content)) bl := 32 buf := make([]byte, bl) o := mockobject.New("test.bin").WithContent(content, mode) for ics, cs := range chunkSizes { for icsMax, csMax := range chunkSizes { // skip tests where chunkSize is much bigger than maxChunkSize if ics > icsMax+1 { continue } t.Run(fmt.Sprintf("Chunksize_%d_%d", cs, csMax), func(t *testing.T) { cr := New(ctx, o, cs, csMax, streams) for _, offset := range offsets { for _, limit := range limits { what := fmt.Sprintf("offset %d, limit %d", offset, limit) p, err := cr.RangeSeek(ctx, offset, io.SeekStart, limit) if offset >= cl { require.Error(t, err, what) return } require.NoError(t, err, what) require.Equal(t, offset, p, what) n, err := cr.Read(buf) end := min(offset+int64(bl), cl) l := int(end - offset) if l < bl { require.Equal(t, io.EOF, err, what) } else { require.NoError(t, err, what) } require.Equal(t, l, n, what) require.Equal(t, content[offset:end], buf[:n], what) } } }) } } } } func testErrorAfterClose(t *testing.T, streams int) { ctx := context.Background() content := makeContent(t, 1024) o := mockobject.New("test.bin").WithContent(content, mockobject.SeekModeNone) // Close cr := New(ctx, o, 0, 0, streams) require.NoError(t, cr.Close()) require.Error(t, cr.Close()) // Read cr = New(ctx, o, 0, 0, streams) require.NoError(t, cr.Close()) var buf [1]byte _, err := cr.Read(buf[:]) require.Error(t, err) // Seek cr = New(ctx, o, 0, 0, streams) require.NoError(t, cr.Close()) _, err = cr.Seek(1, io.SeekCurrent) require.Error(t, err) // RangeSeek cr = New(ctx, o, 0, 0, streams) require.NoError(t, cr.Close()) _, err = cr.RangeSeek(ctx, 1, io.SeekCurrent, 0) require.Error(t, err) } func makeContent(t *testing.T, size int) []byte { content := make([]byte, size) r := rand.New(rand.NewSource(42)) _, err := io.ReadFull(r, content) assert.NoError(t, err) return content } rclone-v1.71.0/fs/chunkedreader/parallel.go000066400000000000000000000233551505210326400206150ustar00rootroot00000000000000package chunkedreader import ( "context" "fmt" "io" "sync" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/log" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/lib/multipart" "github.com/rclone/rclone/lib/pool" ) // parallel reads Object in chunks of a given size in parallel. type parallel struct { ctx context.Context o fs.Object // source to read from mu sync.Mutex // protects following fields endStream int64 // offset we have started streams for offset int64 // offset the read file pointer is at chunkSize int64 // length of the chunks to read nstreams int // number of streams to use streams []*stream // the opened streams in offset order - the current one is first closed bool // has Close been called? } // stream holds the info about a single download type stream struct { cr *parallel // parent reader ctx context.Context // ctx to cancel if needed cancel func() // cancel the stream rc io.ReadCloser // reader that it is reading from, may be nil offset int64 // where the stream is reading from size int64 // and the size it is reading readBytes int64 // bytes read from the stream rw *pool.RW // buffer for read err chan error // error returned from the read name string // name of this stream for debugging } // Start a stream reading (offset, offset+size) func (cr *parallel) newStream(ctx context.Context, offset, size int64) (s *stream, err error) { ctx, cancel := context.WithCancel(ctx) // Create the stream rw := multipart.NewRW() s = &stream{ cr: cr, ctx: ctx, cancel: cancel, offset: offset, size: size, rw: rw, err: make(chan error, 1), } s.name = fmt.Sprintf("stream(%d,%d,%p)", s.offset, s.size, s) // Start the background read into the buffer go s.readFrom(ctx) // Return the stream to the caller return s, nil } // read the file into the buffer func (s *stream) readFrom(ctx context.Context) { // Open the object at the correct range fs.Debugf(s.cr.o, "%s: open", s.name) rc, err := operations.Open(ctx, s.cr.o, &fs.HashesOption{Hashes: hash.Set(hash.None)}, &fs.RangeOption{Start: s.offset, End: s.offset + s.size - 1}) if err != nil { s.err <- fmt.Errorf("parallel chunked reader: failed to open stream at %d size %d: %w", s.offset, s.size, err) return } s.rc = rc fs.Debugf(s.cr.o, "%s: readfrom started", s.name) _, err = s.rw.ReadFrom(s.rc) fs.Debugf(s.cr.o, "%s: readfrom finished (%d bytes): %v", s.name, s.rw.Size(), err) s.err <- err } // eof is true when we've read all the data we are expecting func (s *stream) eof() bool { return s.readBytes >= s.size } // read reads up to len(p) bytes into p. It returns the number of // bytes read (0 <= n <= len(p)) and any error encountered. If some // data is available but not len(p) bytes, read returns what is // available instead of waiting for more. func (s *stream) read(p []byte) (n int, err error) { defer log.Trace(s.cr.o, "%s: Read len(p)=%d", s.name, len(p))("n=%d, err=%v", &n, &err) if len(p) == 0 { return n, nil } for { var nn int nn, err = s.rw.Read(p[n:]) fs.Debugf(s.cr.o, "%s: rw.Read nn=%d, err=%v", s.name, nn, err) s.readBytes += int64(nn) n += nn if err != nil && err != io.EOF { return n, err } if s.eof() { return n, io.EOF } // Received a faux io.EOF because we haven't read all the data yet if n >= len(p) { break } // Wait for a write to happen to read more s.rw.WaitWrite(s.ctx) } return n, nil } // Sets *perr to newErr if err is nil func orErr(perr *error, newErr error) { if *perr == nil { *perr = newErr } } // Close a stream func (s *stream) close() (err error) { defer log.Trace(s.cr.o, "%s: close", s.name)("err=%v", &err) s.cancel() err = <-s.err // wait for readFrom to stop and return error orErr(&err, s.rw.Close()) if s.rc != nil { orErr(&err, s.rc.Close()) } if err != nil && err != io.EOF { return fmt.Errorf("parallel chunked reader: failed to read stream at %d size %d: %w", s.offset, s.size, err) } return nil } // Make a new parallel chunked reader // // Mustn't be called for an unknown size object func newParallel(ctx context.Context, o fs.Object, chunkSize int64, streams int) ChunkedReader { // Make sure chunkSize is a multiple of multipart.BufferSize if chunkSize < 0 { chunkSize = multipart.BufferSize } newChunkSize := multipart.BufferSize * (chunkSize / multipart.BufferSize) if newChunkSize < chunkSize { newChunkSize += multipart.BufferSize } fs.Debugf(o, "newParallel chunkSize=%d, streams=%d", chunkSize, streams) return ¶llel{ ctx: ctx, o: o, offset: 0, chunkSize: newChunkSize, nstreams: streams, } } // _open starts the file transferring at offset // // Call with the lock held func (cr *parallel) _open() (err error) { size := cr.o.Size() if size < 0 { return fmt.Errorf("parallel chunked reader: can't use multiple threads for unknown sized object %q", cr.o) } // Launched enough streams already if cr.endStream >= size { return nil } // Make sure cr.nstreams are running for i := len(cr.streams); i < cr.nstreams; i++ { // clip to length of file chunkSize := cr.chunkSize newEndStream := cr.endStream + chunkSize if newEndStream > size { chunkSize = size - cr.endStream newEndStream = cr.endStream + chunkSize } s, err := cr.newStream(cr.ctx, cr.endStream, chunkSize) if err != nil { return err } cr.streams = append(cr.streams, s) cr.endStream = newEndStream if cr.endStream >= size { break } } return nil } // Finished reading the current stream so pop it off and destroy it // // Call with lock held func (cr *parallel) _popStream() (err error) { defer log.Trace(cr.o, "streams=%+v", cr.streams)("streams=%+v, err=%v", &cr.streams, &err) if len(cr.streams) == 0 { return nil } stream := cr.streams[0] err = stream.close() cr.streams[0] = nil cr.streams = cr.streams[1:] return err } // Get rid of all the streams // // Call with lock held func (cr *parallel) _popStreams() (err error) { defer log.Trace(cr.o, "streams=%+v", cr.streams)("streams=%+v, err=%v", &cr.streams, &err) for len(cr.streams) > 0 { orErr(&err, cr._popStream()) } cr.streams = nil return err } // Read from the file - for details see io.Reader func (cr *parallel) Read(p []byte) (n int, err error) { defer log.Trace(cr.o, "Read len(p)=%d", len(p))("n=%d, err=%v", &n, &err) cr.mu.Lock() defer cr.mu.Unlock() if cr.closed { return 0, ErrorFileClosed } for n < len(p) { // Make sure we have the correct number of streams open err = cr._open() if err != nil { return n, err } // No streams left means EOF if len(cr.streams) == 0 { return n, io.EOF } // Read from the stream stream := cr.streams[0] nn, err := stream.read(p[n:]) n += nn cr.offset += int64(nn) if err == io.EOF { err = cr._popStream() if err != nil { break } } else if err != nil { break } } return n, err } // Close the file - for details see io.Closer // // All methods on ChunkedReader will return ErrorFileClosed afterwards func (cr *parallel) Close() error { cr.mu.Lock() defer cr.mu.Unlock() if cr.closed { return ErrorFileClosed } cr.closed = true // Close all the streams return cr._popStreams() } // Seek the file - for details see io.Seeker func (cr *parallel) Seek(offset int64, whence int) (int64, error) { cr.mu.Lock() defer cr.mu.Unlock() fs.Debugf(cr.o, "parallel chunked reader: seek from %d to %d whence %d", cr.offset, offset, whence) if cr.closed { return 0, ErrorFileClosed } size := cr.o.Size() currentOffset := cr.offset switch whence { case io.SeekStart: currentOffset = 0 case io.SeekEnd: currentOffset = size } // set the new chunk start newOffset := currentOffset + offset if newOffset < 0 || newOffset >= size { return 0, ErrorInvalidSeek } // If seek pointer didn't move, return now if newOffset == cr.offset { fs.Debugf(cr.o, "parallel chunked reader: seek pointer didn't move") return cr.offset, nil } cr.offset = newOffset // Ditch out of range streams for len(cr.streams) > 0 { stream := cr.streams[0] if newOffset >= stream.offset+stream.size { _ = cr._popStream() } else { break } } // If no streams remain we can just restart if len(cr.streams) == 0 { fs.Debugf(cr.o, "parallel chunked reader: no streams remain") cr.endStream = cr.offset return cr.offset, nil } // Current stream stream := cr.streams[0] // If new offset is before current stream then ditch all the streams if newOffset < stream.offset { _ = cr._popStreams() fs.Debugf(cr.o, "parallel chunked reader: new offset is before current stream - ditch all") cr.endStream = cr.offset return cr.offset, nil } // Seek the current stream streamOffset := newOffset - stream.offset stream.readBytes = streamOffset // correct read value fs.Debugf(cr.o, "parallel chunked reader: seek the current stream to %d", streamOffset) // Wait for the read to the correct part of the data for stream.rw.Size() < streamOffset { stream.rw.WaitWrite(cr.ctx) } _, err := stream.rw.Seek(streamOffset, io.SeekStart) if err != nil { return cr.offset, fmt.Errorf("parallel chunked reader: failed to seek stream: %w", err) } return cr.offset, nil } // RangeSeek the file - for details see RangeSeeker // // In the parallel chunked reader this just acts like Seek func (cr *parallel) RangeSeek(ctx context.Context, offset int64, whence int, length int64) (int64, error) { return cr.Seek(offset, whence) } // Open forces the connection to be opened func (cr *parallel) Open() (ChunkedReader, error) { cr.mu.Lock() defer cr.mu.Unlock() return cr, cr._open() } var ( _ ChunkedReader = (*parallel)(nil) ) rclone-v1.71.0/fs/chunkedreader/parallel_test.go000066400000000000000000000045771505210326400216610ustar00rootroot00000000000000package chunkedreader import ( "context" "io" "math/rand" "testing" "github.com/rclone/rclone/fstest/mockobject" "github.com/rclone/rclone/lib/multipart" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestParallel(t *testing.T) { content := makeContent(t, 1024) for _, mode := range mockobject.SeekModes { t.Run(mode.String(), testRead(content, mode, 3)) } } func TestParallelErrorAfterClose(t *testing.T) { testErrorAfterClose(t, 3) } func TestParallelLarge(t *testing.T) { ctx := context.Background() const streams = 3 const chunkSize = multipart.BufferSize const size = (2*streams+1)*chunkSize + 255 content := makeContent(t, size) o := mockobject.New("test.bin").WithContent(content, mockobject.SeekModeNone) cr := New(ctx, o, chunkSize, 0, streams) for _, test := range []struct { name string offset int64 seekMode int }{ {name: "Straight", offset: 0, seekMode: -1}, {name: "Rewind", offset: 0, seekMode: io.SeekStart}, {name: "NearStart", offset: 1, seekMode: io.SeekStart}, {name: "NearEnd", offset: size - 2*chunkSize - 127, seekMode: io.SeekEnd}, } { t.Run(test.name, func(t *testing.T) { if test.seekMode >= 0 { var n int64 var err error if test.seekMode == io.SeekEnd { n, err = cr.Seek(test.offset-size, test.seekMode) } else { n, err = cr.Seek(test.offset, test.seekMode) } require.NoError(t, err) assert.Equal(t, test.offset, n) } got, err := io.ReadAll(cr) require.NoError(t, err) require.Equal(t, len(content[test.offset:]), len(got)) assert.Equal(t, content[test.offset:], got) }) } require.NoError(t, cr.Close()) t.Run("Seeky", func(t *testing.T) { cr := New(ctx, o, chunkSize, 0, streams) offset := 0 buf := make([]byte, 1024) for { // Read and check a random read readSize := rand.Intn(1024) readBuf := buf[:readSize] n, err := cr.Read(readBuf) require.Equal(t, content[offset:offset+n], readBuf[:n]) offset += n if err == io.EOF { assert.Equal(t, size, offset) break } require.NoError(t, err) // Now do a smaller random seek backwards seekSize := rand.Intn(512) if offset-seekSize < 0 { seekSize = offset } nn, err := cr.Seek(-int64(seekSize), io.SeekCurrent) offset -= seekSize require.NoError(t, err) assert.Equal(t, nn, int64(offset)) } require.NoError(t, cr.Close()) }) } rclone-v1.71.0/fs/chunkedreader/sequential.go000066400000000000000000000147431505210326400211740ustar00rootroot00000000000000package chunkedreader import ( "context" "io" "sync" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" ) // sequential is a reader for an Object with the possibility // of reading the source in chunks of given size // // An initialChunkSize of <= 0 will disable chunked reading. type sequential struct { ctx context.Context mu sync.Mutex // protects following fields o fs.Object // source to read from rc io.ReadCloser // reader for the current open chunk offset int64 // offset the next Read will start. -1 forces a reopen of o chunkOffset int64 // beginning of the current or next chunk chunkSize int64 // length of the current or next chunk. -1 will open o from chunkOffset to the end initialChunkSize int64 // default chunkSize after the chunk specified by RangeSeek is complete maxChunkSize int64 // consecutive read chunks will double in size until reached. -1 means no limit customChunkSize bool // is the current chunkSize set by RangeSeek? closed bool // has Close been called? } // Make a new sequential chunked reader func newSequential(ctx context.Context, o fs.Object, initialChunkSize int64, maxChunkSize int64) ChunkedReader { return &sequential{ ctx: ctx, o: o, offset: -1, chunkSize: initialChunkSize, initialChunkSize: initialChunkSize, maxChunkSize: maxChunkSize, } } // Read from the file - for details see io.Reader func (cr *sequential) Read(p []byte) (n int, err error) { cr.mu.Lock() defer cr.mu.Unlock() if cr.closed { return 0, ErrorFileClosed } for reqSize := int64(len(p)); reqSize > 0; reqSize = int64(len(p)) { // the current chunk boundary. valid only when chunkSize > 0 chunkEnd := cr.chunkOffset + cr.chunkSize fs.Debugf(cr.o, "ChunkedReader.Read at %d length %d chunkOffset %d chunkSize %d", cr.offset, reqSize, cr.chunkOffset, cr.chunkSize) switch { case cr.chunkSize > 0 && cr.offset == chunkEnd: // last chunk read completely cr.chunkOffset = cr.offset if cr.customChunkSize { // last chunkSize was set by RangeSeek cr.customChunkSize = false cr.chunkSize = cr.initialChunkSize } else { cr.chunkSize *= 2 if cr.chunkSize > cr.maxChunkSize && cr.maxChunkSize != -1 { cr.chunkSize = cr.maxChunkSize } } // recalculate the chunk boundary. valid only when chunkSize > 0 chunkEnd = cr.chunkOffset + cr.chunkSize fallthrough case cr.offset == -1: // first Read or Read after RangeSeek err = cr.openRange() if err != nil { return } } var buf []byte chunkRest := chunkEnd - cr.offset // limit read to chunk boundaries if chunkSize > 0 if reqSize > chunkRest && cr.chunkSize > 0 { buf, p = p[0:chunkRest], p[chunkRest:] } else { buf, p = p, nil } var rn int rn, err = io.ReadFull(cr.rc, buf) n += rn cr.offset += int64(rn) if err != nil { if err == io.ErrUnexpectedEOF { err = io.EOF } return } } return n, nil } // Close the file - for details see io.Closer // // All methods on ChunkedReader will return ErrorFileClosed afterwards func (cr *sequential) Close() error { cr.mu.Lock() defer cr.mu.Unlock() if cr.closed { return ErrorFileClosed } cr.closed = true return cr.resetReader(nil, 0) } // Seek the file - for details see io.Seeker func (cr *sequential) Seek(offset int64, whence int) (int64, error) { return cr.RangeSeek(context.TODO(), offset, whence, -1) } // RangeSeek the file - for details see RangeSeeker // // The specified length will only apply to the next chunk opened. // RangeSeek will not reopen the source until Read is called. func (cr *sequential) RangeSeek(ctx context.Context, offset int64, whence int, length int64) (int64, error) { cr.mu.Lock() defer cr.mu.Unlock() fs.Debugf(cr.o, "ChunkedReader.RangeSeek from %d to %d length %d", cr.offset, offset, length) if cr.closed { return 0, ErrorFileClosed } size := cr.o.Size() switch whence { case io.SeekStart: cr.offset = 0 case io.SeekEnd: if size < 0 { return 0, ErrorInvalidSeek // Can't seek from end for unknown size } cr.offset = size } // set the new chunk start cr.chunkOffset = cr.offset + offset // force reopen on next Read cr.offset = -1 if length > 0 { cr.customChunkSize = true cr.chunkSize = length } else { cr.chunkSize = cr.initialChunkSize } if cr.chunkOffset < 0 || cr.chunkOffset >= size { cr.chunkOffset = 0 return 0, ErrorInvalidSeek } return cr.chunkOffset, nil } // Open forces the connection to be opened func (cr *sequential) Open() (ChunkedReader, error) { cr.mu.Lock() defer cr.mu.Unlock() if cr.rc != nil && cr.offset != -1 { return cr, nil } return cr, cr.openRange() } // openRange will open the source Object with the current chunk range // // If the current open reader implements RangeSeeker, it is tried first. // When RangeSeek fails, o.Open with a RangeOption is used. // // A length <= 0 will request till the end of the file func (cr *sequential) openRange() error { offset, length := cr.chunkOffset, cr.chunkSize fs.Debugf(cr.o, "ChunkedReader.openRange at %d length %d", offset, length) if cr.closed { return ErrorFileClosed } if rs, ok := cr.rc.(fs.RangeSeeker); ok { n, err := rs.RangeSeek(cr.ctx, offset, io.SeekStart, length) if err == nil && n == offset { cr.offset = offset return nil } if err != nil { fs.Debugf(cr.o, "ChunkedReader.openRange seek failed (%s). Trying Open", err) } else { fs.Debugf(cr.o, "ChunkedReader.openRange seeked to wrong offset. Wanted %d, got %d. Trying Open", offset, n) } } var rc io.ReadCloser var err error if length <= 0 { if offset == 0 { rc, err = cr.o.Open(cr.ctx, &fs.HashesOption{Hashes: hash.Set(hash.None)}) } else { rc, err = cr.o.Open(cr.ctx, &fs.HashesOption{Hashes: hash.Set(hash.None)}, &fs.RangeOption{Start: offset, End: -1}) } } else { rc, err = cr.o.Open(cr.ctx, &fs.HashesOption{Hashes: hash.Set(hash.None)}, &fs.RangeOption{Start: offset, End: offset + length - 1}) } if err != nil { return err } return cr.resetReader(rc, offset) } // resetReader switches the current reader to the given reader. // The old reader will be Close'd before setting the new reader. func (cr *sequential) resetReader(rc io.ReadCloser, offset int64) error { if cr.rc != nil { if err := cr.rc.Close(); err != nil { return err } } cr.rc = rc cr.offset = offset return nil } var ( _ ChunkedReader = (*sequential)(nil) ) rclone-v1.71.0/fs/chunkedreader/sequential_test.go000066400000000000000000000006051505210326400222230ustar00rootroot00000000000000package chunkedreader import ( "testing" _ "github.com/rclone/rclone/backend/local" "github.com/rclone/rclone/fstest/mockobject" ) func TestSequential(t *testing.T) { content := makeContent(t, 1024) for _, mode := range mockobject.SeekModes { t.Run(mode.String(), testRead(content, mode, 0)) } } func TestSequentialErrorAfterClose(t *testing.T) { testErrorAfterClose(t, 0) } rclone-v1.71.0/fs/chunksize/000077500000000000000000000000001505210326400156615ustar00rootroot00000000000000rclone-v1.71.0/fs/chunksize/chunksize.go000066400000000000000000000035711505210326400202210ustar00rootroot00000000000000// Package chunksize calculates a suitable chunk size for large uploads package chunksize import ( "github.com/rclone/rclone/fs" ) // Calculator calculates the minimum chunk size needed to fit within // the maximum number of parts, rounded up to the nearest fs.Mebi. // // For most backends, (chunk_size) * (concurrent_upload_routines) // memory will be required so we want to use the smallest possible // chunk size that's going to allow the upload to proceed. Rounding up // to the nearest fs.Mebi on the assumption that some backends may // only allow integer type parameters when specifying the chunk size. // // Returns the default chunk size if it is sufficiently large enough // to support the given file size otherwise returns the smallest chunk // size necessary to allow the upload to proceed. func Calculator(o any, size int64, maxParts int, defaultChunkSize fs.SizeSuffix) fs.SizeSuffix { // If streaming then use default chunk size if size < 0 { fs.Debugf(o, "Streaming upload with chunk_size %s allows uploads of up to %s and will fail only when that limit is reached.", defaultChunkSize, fs.SizeSuffix(maxParts)*defaultChunkSize) return defaultChunkSize } fileSize := fs.SizeSuffix(size) requiredChunks := fileSize / defaultChunkSize if requiredChunks < fs.SizeSuffix(maxParts) || (requiredChunks == fs.SizeSuffix(maxParts) && fileSize%defaultChunkSize == 0) { return defaultChunkSize } minChunk := fileSize / fs.SizeSuffix(maxParts) remainder := minChunk % fs.Mebi if remainder != 0 { minChunk += fs.Mebi - remainder } if fileSize/minChunk == fs.SizeSuffix(maxParts) && fileSize%fs.SizeSuffix(maxParts) != 0 { // when right on the boundary, we need to add a MiB minChunk += fs.Mebi } fs.Debugf(o, "size: %v, parts: %v, default: %v, new: %v; default chunk size insufficient, returned new chunk size", fileSize, maxParts, defaultChunkSize, minChunk) return minChunk } rclone-v1.71.0/fs/chunksize/chunksize_test.go000066400000000000000000000063541505210326400212620ustar00rootroot00000000000000package chunksize import ( "testing" "github.com/rclone/rclone/fs" ) func TestComputeChunkSize(t *testing.T) { for _, test := range []struct { name string size fs.SizeSuffix maxParts int defaultChunkSize fs.SizeSuffix want fs.SizeSuffix }{ { name: "streaming file", size: -1, maxParts: 10000, defaultChunkSize: toSizeSuffixMiB(10), want: toSizeSuffixMiB(10), }, { name: "default size returned when file size is small enough", size: 1000, maxParts: 10000, defaultChunkSize: toSizeSuffixMiB(10), want: toSizeSuffixMiB(10), }, { name: "default size returned when file size is just 1 byte small enough", size: toSizeSuffixMiB(100000) - 1, maxParts: 10000, defaultChunkSize: toSizeSuffixMiB(10), want: toSizeSuffixMiB(10), }, { name: "no rounding up when everything divides evenly", size: toSizeSuffixMiB(1000000), maxParts: 10000, defaultChunkSize: toSizeSuffixMiB(100), want: toSizeSuffixMiB(100), }, { name: "rounding up to nearest MiB when not quite enough parts", size: toSizeSuffixMiB(1000000), maxParts: 9999, defaultChunkSize: toSizeSuffixMiB(100), want: toSizeSuffixMiB(101), }, { name: "rounding up to nearest MiB when one extra byte", size: toSizeSuffixMiB(1000000) + 1, maxParts: 10000, defaultChunkSize: toSizeSuffixMiB(100), want: toSizeSuffixMiB(101), }, { name: "expected MiB value when rounding sets to absolute minimum", size: toSizeSuffixMiB(1) - 1, maxParts: 1, defaultChunkSize: toSizeSuffixMiB(1), want: toSizeSuffixMiB(1), }, { name: "expected MiB value when rounding to absolute min with extra", size: toSizeSuffixMiB(1) + 1, maxParts: 1, defaultChunkSize: toSizeSuffixMiB(1), want: toSizeSuffixMiB(2), }, { name: "issue from forum #1", size: 120864818840, maxParts: 10000, defaultChunkSize: 5 * 1024 * 1024, want: toSizeSuffixMiB(12), }, } { t.Run(test.name, func(t *testing.T) { got := Calculator(test.name, int64(test.size), test.maxParts, test.defaultChunkSize) if got != test.want { t.Fatalf("expected: %v, got: %v", test.want, got) } if test.size < 0 { return } parts := func(result fs.SizeSuffix) int { n := test.size / result r := test.size % result if r != 0 { n++ } return int(n) } // Check this gives the parts in range if parts(got) > test.maxParts { t.Fatalf("too many parts %d", parts(got)) } // Check that setting chunk size smaller gave too many parts if got > test.defaultChunkSize { if parts(got-toSizeSuffixMiB(1)) <= test.maxParts { t.Fatalf("chunk size %v too big as %v only gives %d parts", got, got-toSizeSuffixMiB(1), parts(got-toSizeSuffixMiB(1))) } } }) } } func toSizeSuffixMiB(size int64) fs.SizeSuffix { return fs.SizeSuffix(size * int64(fs.Mebi)) } rclone-v1.71.0/fs/config.go000066400000000000000000000712031505210326400154550ustar00rootroot00000000000000package fs import ( "context" "errors" "fmt" "net" "os" "strconv" "strings" "time" ) // Global var ( // globalConfig for rclone globalConfig = new(ConfigInfo) // Read a value from the config file // // This is a function pointer to decouple the config // implementation from the fs ConfigFileGet = func(section, key string) (string, bool) { return "", false } // Set a value into the config file and persist it // // This is a function pointer to decouple the config // implementation from the fs ConfigFileSet = func(section, key, value string) (err error) { return errors.New("no config file set handler") } // Check if the config file has the named section // // This is a function pointer to decouple the config // implementation from the fs ConfigFileHasSection = func(section string) bool { return false } // CountError counts an error. If any errors have been // counted then rclone will exit with a non zero error code. // // This is a function pointer to decouple the config // implementation from the fs CountError = func(ctx context.Context, err error) error { return err } // ConfigProvider is the config key used for provider options ConfigProvider = "provider" // ConfigEdit is the config key used to show we wish to edit existing entries ConfigEdit = "config_fs_edit" ) // ConfigOptionsInfo describes the Options in use var ConfigOptionsInfo = Options{{ Name: "modify_window", Default: time.Nanosecond, Help: "Max time diff to be considered the same", Groups: "Copy", }, { Name: "checkers", Default: 8, Help: "Number of checkers to run in parallel", Groups: "Performance", }, { Name: "transfers", Default: 4, Help: "Number of file transfers to run in parallel", Groups: "Performance", }, { Name: "checksum", ShortOpt: "c", Default: false, Help: "Check for changes with size & checksum (if available, or fallback to size only)", Groups: "Copy", }, { Name: "size_only", Default: false, Help: "Skip based on size only, not modtime or checksum", Groups: "Copy", }, { Name: "ignore_times", ShortOpt: "I", Default: false, Help: "Don't skip items that match size and time - transfer all unconditionally", Groups: "Copy", }, { Name: "ignore_existing", Default: false, Help: "Skip all files that exist on destination", Groups: "Copy", }, { Name: "ignore_errors", Default: false, Help: "Delete even if there are I/O errors", Groups: "Sync", }, { Name: "dry_run", ShortOpt: "n", Default: false, Help: "Do a trial run with no permanent changes", Groups: "Config,Important", }, { Name: "interactive", ShortOpt: "i", Default: false, Help: "Enable interactive mode", Groups: "Config,Important", }, { Name: "links", Help: "Translate symlinks to/from regular files with a '" + LinkSuffix + "' extension.", Default: false, ShortOpt: "l", Groups: "Copy", }, { Name: "contimeout", Default: 60 * time.Second, Help: "Connect timeout", Groups: "Networking", }, { Name: "timeout", Default: 5 * 60 * time.Second, Help: "IO idle timeout", Groups: "Networking", }, { Name: "expect_continue_timeout", Default: 1 * time.Second, Help: "Timeout when using expect / 100-continue in HTTP", Groups: "Networking", }, { Name: "no_check_certificate", Default: false, Help: "Do not verify the server SSL certificate (insecure)", Groups: "Networking", }, { Name: "ask_password", Default: true, Help: "Allow prompt for password for encrypted configuration", Groups: "Config", }, { Name: "password_command", Default: SpaceSepList{}, Help: "Command for supplying password for encrypted configuration", Groups: "Config", }, { Name: "max_delete", Default: int64(-1), Help: "When synchronizing, limit the number of deletes", Groups: "Sync", }, { Name: "max_delete_size", Default: SizeSuffix(-1), Help: "When synchronizing, limit the total size of deletes", Groups: "Sync", }, { Name: "track_renames", Default: false, Help: "When synchronizing, track file renames and do a server-side move if possible", Groups: "Sync", }, { Name: "track_renames_strategy", Default: "hash", Help: "Strategies to use when synchronizing using track-renames hash|modtime|leaf", Groups: "Sync", }, { Name: "retries", Default: 3, Help: "Retry operations this many times if they fail", Groups: "Config", }, { Name: "retries_sleep", Default: time.Duration(0), Help: "Interval between retrying operations if they fail, e.g. 500ms, 60s, 5m (0 to disable)", Groups: "Config", }, { Name: "low_level_retries", Default: 10, Help: "Number of low level retries to do", Groups: "Config", }, { Name: "update", ShortOpt: "u", Default: false, Help: "Skip files that are newer on the destination", Groups: "Copy", }, { Name: "use_server_modtime", Default: false, Help: "Use server modified time instead of object metadata", Groups: "Config", }, { Name: "no_gzip_encoding", Default: false, Help: "Don't set Accept-Encoding: gzip", Groups: "Networking", }, { Name: "max_depth", Default: -1, Help: "If set limits the recursion depth to this", Groups: "Filter", }, { Name: "ignore_size", Default: false, Help: "Ignore size when skipping use modtime or checksum", Groups: "Copy", }, { Name: "ignore_checksum", Default: false, Help: "Skip post copy check of checksums", Groups: "Copy", }, { Name: "ignore_case_sync", Default: false, Help: "Ignore case when synchronizing", Groups: "Copy", }, { Name: "fix_case", Default: false, Help: "Force rename of case insensitive dest to match source", Groups: "Sync", }, { Name: "no_traverse", Default: false, Help: "Don't traverse destination file system on copy", Groups: "Copy", }, { Name: "check_first", Default: false, Help: "Do all the checks before starting transfers", Groups: "Copy", }, { Name: "no_check_dest", Default: false, Help: "Don't check the destination, copy regardless", Groups: "Copy", }, { Name: "no_unicode_normalization", Default: false, Help: "Don't normalize unicode characters in filenames", Groups: "Config", }, { Name: "no_update_modtime", Default: false, Help: "Don't update destination modtime if files identical", Groups: "Copy", }, { Name: "no_update_dir_modtime", Default: false, Help: "Don't update directory modification times", Groups: "Copy", }, { Name: "compare_dest", Default: []string{}, Help: "Include additional server-side paths during comparison", Groups: "Copy", }, { Name: "copy_dest", Default: []string{}, Help: "Implies --compare-dest but also copies files from paths into destination", Groups: "Copy", }, { Name: "backup_dir", Default: "", Help: "Make backups into hierarchy based in DIR", Groups: "Sync", }, { Name: "suffix", Default: "", Help: "Suffix to add to changed files", Groups: "Sync", }, { Name: "suffix_keep_extension", Default: false, Help: "Preserve the extension when using --suffix", Groups: "Sync", }, { Name: "fast_list", Default: false, Help: "Use recursive list if available; uses more memory but fewer transactions", Groups: "Listing", }, { Name: "list_cutoff", Default: 1_000_000, Help: "To save memory, sort directory listings on disk above this threshold", Groups: "Sync", }, { Name: "tpslimit", Default: 0.0, Help: "Limit HTTP transactions per second to this", Groups: "Networking", }, { Name: "tpslimit_burst", Default: 1, Help: "Max burst of transactions for --tpslimit", Groups: "Networking", }, { Name: "user_agent", Default: "rclone/" + Version, Help: "Set the user-agent to a specified string", Groups: "Networking", }, { Name: "immutable", Default: false, Help: "Do not modify files, fail if existing files have been modified", Groups: "Copy", }, { Name: "auto_confirm", Default: false, Help: "If enabled, do not request console confirmation", Groups: "Config", }, { Name: "stats_unit", Default: "bytes", Help: "Show data rate in stats as either 'bits' or 'bytes' per second", Groups: "Logging", }, { Name: "stats_file_name_length", Default: 45, Help: "Max file name length in stats (0 for no limit)", Groups: "Logging", }, { Name: "log_level", Default: LogLevelNotice, Help: "Log level DEBUG|INFO|NOTICE|ERROR", Groups: "Logging", }, { Name: "stats_log_level", Default: LogLevelInfo, Help: "Log level to show --stats output DEBUG|INFO|NOTICE|ERROR", Groups: "Logging", }, { Name: "bwlimit", Default: BwTimetable{}, Help: "Bandwidth limit in KiB/s, or use suffix B|K|M|G|T|P or a full timetable", Groups: "Networking", }, { Name: "bwlimit_file", Default: BwTimetable{}, Help: "Bandwidth limit per file in KiB/s, or use suffix B|K|M|G|T|P or a full timetable", Groups: "Networking", }, { Name: "buffer_size", Default: SizeSuffix(16 << 20), Help: "In memory buffer size when reading files for each --transfer", Groups: "Performance", }, { Name: "streaming_upload_cutoff", Default: SizeSuffix(100 * 1024), Help: "Cutoff for switching to chunked upload if file size is unknown, upload starts after reaching cutoff or when file ends", Groups: "Copy", }, { Name: "dump", Default: DumpFlags(0), Help: "List of items to dump from: " + DumpFlagsList, Groups: "Debugging", }, { Name: "max_transfer", Default: SizeSuffix(-1), Help: "Maximum size of data to transfer", Groups: "Copy", }, { Name: "max_duration", Default: time.Duration(0), Help: "Maximum duration rclone will transfer data for", Groups: "Copy", }, { Name: "cutoff_mode", Default: CutoffMode(0), Help: "Mode to stop transfers when reaching the max transfer limit HARD|SOFT|CAUTIOUS", Groups: "Copy", }, { Name: "max_backlog", Default: 10000, Help: "Maximum number of objects in sync or check backlog", Groups: "Copy,Check", }, { Name: "max_stats_groups", Default: 1000, Help: "Maximum number of stats groups to keep in memory, on max oldest is discarded", Groups: "Logging", }, { Name: "stats_one_line", Default: false, Help: "Make the stats fit on one line", Groups: "Logging", }, { Name: "stats_one_line_date", Default: false, Help: "Enable --stats-one-line and add current date/time prefix", Groups: "Logging", }, { Name: "stats_one_line_date_format", Default: "", Help: "Enable --stats-one-line-date and use custom formatted date: Enclose date string in double quotes (\"), see https://golang.org/pkg/time/#Time.Format", Groups: "Logging", }, { Name: "error_on_no_transfer", Default: false, Help: "Sets exit code 9 if no files are transferred, useful in scripts", Groups: "Config", }, { Name: "progress", ShortOpt: "P", Default: false, Help: "Show progress during transfer", Groups: "Logging", }, { Name: "progress_terminal_title", Default: false, Help: "Show progress on the terminal title (requires -P/--progress)", Groups: "Logging", }, { Name: "use_cookies", Default: false, Help: "Enable session cookiejar", Groups: "Networking", }, { Name: "use_mmap", Default: false, Help: "Use mmap allocator (see docs)", Groups: "Config", }, { Name: "max_buffer_memory", Default: SizeSuffix(-1), Help: "If set, don't allocate more than this amount of memory as buffers", Groups: "Config", }, { Name: "ca_cert", Default: []string{}, Help: "CA certificate used to verify servers", Groups: "Networking", }, { Name: "client_cert", Default: "", Help: "Client SSL certificate (PEM) for mutual TLS auth", Groups: "Networking", }, { Name: "client_key", Default: "", Help: "Client SSL private key (PEM) for mutual TLS auth", Groups: "Networking", }, { Name: "client_pass", Default: "", Help: "Password for client SSL private key (PEM) for mutual TLS auth (obscured)", Groups: "Networking", IsPassword: true, }, { Name: "multi_thread_cutoff", Default: SizeSuffix(256 * 1024 * 1024), Help: "Use multi-thread downloads for files above this size", Groups: "Copy", }, { Name: "multi_thread_streams", Default: 4, Help: "Number of streams to use for multi-thread downloads", Groups: "Copy", }, { Name: "multi_thread_write_buffer_size", Default: SizeSuffix(128 * 1024), Help: "In memory buffer size for writing when in multi-thread mode", Groups: "Copy", }, { Name: "multi_thread_chunk_size", Default: SizeSuffix(64 * 1024 * 1024), Help: "Chunk size for multi-thread downloads / uploads, if not set by filesystem", Groups: "Copy", }, { Name: "use_json_log", Default: false, Help: "Use json log format", Groups: "Logging", }, { Name: "order_by", Default: "", Help: "Instructions on how to order the transfers, e.g. 'size,descending'", Groups: "Copy", }, { Name: "refresh_times", Default: false, Help: "Refresh the modtime of remote files", Groups: "Copy", }, { Name: "no_console", Default: false, Help: "Hide console window (supported on Windows only)", Groups: "Config", }, { Name: "fs_cache_expire_duration", Default: 300 * time.Second, Help: "Cache remotes for this long (0 to disable caching)", Groups: "Config", }, { Name: "fs_cache_expire_interval", Default: 60 * time.Second, Help: "Interval to check for expired remotes", Groups: "Config", }, { Name: "disable_http2", Default: false, Help: "Disable HTTP/2 in the global transport", Groups: "Networking", }, { Name: "human_readable", Default: false, Help: "Print numbers in a human-readable format, sizes with suffix Ki|Mi|Gi|Ti|Pi", Groups: "Config", }, { Name: "kv_lock_time", Default: 1 * time.Second, Help: "Maximum time to keep key-value database locked by process", Groups: "Config", }, { Name: "disable_http_keep_alives", Default: false, Help: "Disable HTTP keep-alives and use each connection once.", Groups: "Networking", }, { Name: "metadata", ShortOpt: "M", Default: false, Help: "If set, preserve metadata when copying objects", Groups: "Metadata,Copy", }, { Name: "server_side_across_configs", Default: false, Help: "Allow server-side operations (e.g. copy) to work across different configs", Groups: "Copy", }, { Name: "color", Default: TerminalColorMode(0), Help: "When to show colors (and other ANSI codes) AUTO|NEVER|ALWAYS", Groups: "Config", }, { Name: "default_time", Default: Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)), Help: "Time to show if modtime is unknown for files and directories", Groups: "Config,Listing", }, { Name: "inplace", Default: false, Help: "Download directly to destination file instead of atomic download to temp/rename", Groups: "Copy", }, { Name: "metadata_mapper", Default: SpaceSepList{}, Help: "Program to run to transforming metadata before upload", Groups: "Metadata", }, { Name: "partial_suffix", Default: ".partial", Help: "Add partial-suffix to temporary file name when --inplace is not used", Groups: "Copy", }, { Name: "max_connections", Help: "Maximum number of simultaneous backend API connections, 0 for unlimited.", Default: 0, Advanced: true, Groups: "Networking", }, { Name: "name_transform", Default: []string{}, Help: "Transform paths during the copy process.", Groups: "Copy", }, { Name: "http_proxy", Default: "", Help: "HTTP proxy URL.", Groups: "Networking", }} // ConfigInfo is filesystem config options type ConfigInfo struct { LogLevel LogLevel `config:"log_level"` StatsLogLevel LogLevel `config:"stats_log_level"` UseJSONLog bool `config:"use_json_log"` DryRun bool `config:"dry_run"` Interactive bool `config:"interactive"` Links bool `config:"links"` CheckSum bool `config:"checksum"` SizeOnly bool `config:"size_only"` IgnoreTimes bool `config:"ignore_times"` IgnoreExisting bool `config:"ignore_existing"` IgnoreErrors bool `config:"ignore_errors"` ModifyWindow Duration `config:"modify_window"` Checkers int `config:"checkers"` Transfers int `config:"transfers"` ConnectTimeout Duration `config:"contimeout"` // Connect timeout Timeout Duration `config:"timeout"` // Data channel timeout ExpectContinueTimeout Duration `config:"expect_continue_timeout"` Dump DumpFlags `config:"dump"` InsecureSkipVerify bool `config:"no_check_certificate"` // Skip server certificate verification DeleteMode DeleteMode `config:"delete_mode"` MaxDelete int64 `config:"max_delete"` MaxDeleteSize SizeSuffix `config:"max_delete_size"` TrackRenames bool `config:"track_renames"` // Track file renames. TrackRenamesStrategy string `config:"track_renames_strategy"` // Comma separated list of strategies used to track renames Retries int `config:"retries"` // High-level retries RetriesInterval Duration `config:"retries_sleep"` LowLevelRetries int `config:"low_level_retries"` UpdateOlder bool `config:"update"` // Skip files that are newer on the destination NoGzip bool `config:"no_gzip_encoding"` // Disable compression MaxDepth int `config:"max_depth"` IgnoreSize bool `config:"ignore_size"` IgnoreChecksum bool `config:"ignore_checksum"` IgnoreCaseSync bool `config:"ignore_case_sync"` FixCase bool `config:"fix_case"` NoTraverse bool `config:"no_traverse"` CheckFirst bool `config:"check_first"` NoCheckDest bool `config:"no_check_dest"` NoUnicodeNormalization bool `config:"no_unicode_normalization"` NoUpdateModTime bool `config:"no_update_modtime"` NoUpdateDirModTime bool `config:"no_update_dir_modtime"` DataRateUnit string `config:"stats_unit"` CompareDest []string `config:"compare_dest"` CopyDest []string `config:"copy_dest"` BackupDir string `config:"backup_dir"` Suffix string `config:"suffix"` SuffixKeepExtension bool `config:"suffix_keep_extension"` UseListR bool `config:"fast_list"` ListCutoff int `config:"list_cutoff"` BufferSize SizeSuffix `config:"buffer_size"` BwLimit BwTimetable `config:"bwlimit"` BwLimitFile BwTimetable `config:"bwlimit_file"` TPSLimit float64 `config:"tpslimit"` TPSLimitBurst int `config:"tpslimit_burst"` BindAddr net.IP `config:"bind_addr"` DisableFeatures []string `config:"disable"` UserAgent string `config:"user_agent"` Immutable bool `config:"immutable"` AutoConfirm bool `config:"auto_confirm"` StreamingUploadCutoff SizeSuffix `config:"streaming_upload_cutoff"` StatsFileNameLength int `config:"stats_file_name_length"` AskPassword bool `config:"ask_password"` PasswordCommand SpaceSepList `config:"password_command"` UseServerModTime bool `config:"use_server_modtime"` MaxTransfer SizeSuffix `config:"max_transfer"` MaxDuration Duration `config:"max_duration"` CutoffMode CutoffMode `config:"cutoff_mode"` MaxBacklog int `config:"max_backlog"` MaxStatsGroups int `config:"max_stats_groups"` StatsOneLine bool `config:"stats_one_line"` StatsOneLineDate bool `config:"stats_one_line_date"` // If we want a date prefix at all StatsOneLineDateFormat string `config:"stats_one_line_date_format"` // If we want to customize the prefix ErrorOnNoTransfer bool `config:"error_on_no_transfer"` // Set appropriate exit code if no files transferred Progress bool `config:"progress"` ProgressTerminalTitle bool `config:"progress_terminal_title"` Cookie bool `config:"use_cookies"` UseMmap bool `config:"use_mmap"` MaxBufferMemory SizeSuffix `config:"max_buffer_memory"` CaCert []string `config:"ca_cert"` // Client Side CA ClientCert string `config:"client_cert"` // Client Side Cert ClientKey string `config:"client_key"` // Client Side Key ClientPass string `config:"client_pass"` // Client Side Key Password (obscured) MultiThreadCutoff SizeSuffix `config:"multi_thread_cutoff"` MultiThreadStreams int `config:"multi_thread_streams"` MultiThreadSet bool `config:"multi_thread_set"` // whether MultiThreadStreams was set (set in fs/config/configflags) MultiThreadChunkSize SizeSuffix `config:"multi_thread_chunk_size"` // Chunk size for multi-thread downloads / uploads, if not set by filesystem MultiThreadWriteBufferSize SizeSuffix `config:"multi_thread_write_buffer_size"` OrderBy string `config:"order_by"` // instructions on how to order the transfer UploadHeaders []*HTTPOption `config:"upload_headers"` DownloadHeaders []*HTTPOption `config:"download_headers"` Headers []*HTTPOption `config:"headers"` MetadataSet Metadata `config:"metadata_set"` // extra metadata to write when uploading RefreshTimes bool `config:"refresh_times"` NoConsole bool `config:"no_console"` TrafficClass uint8 `config:"traffic_class"` FsCacheExpireDuration Duration `config:"fs_cache_expire_duration"` FsCacheExpireInterval Duration `config:"fs_cache_expire_interval"` DisableHTTP2 bool `config:"disable_http2"` HumanReadable bool `config:"human_readable"` KvLockTime Duration `config:"kv_lock_time"` // maximum time to keep key-value database locked by process DisableHTTPKeepAlives bool `config:"disable_http_keep_alives"` Metadata bool `config:"metadata"` ServerSideAcrossConfigs bool `config:"server_side_across_configs"` TerminalColorMode TerminalColorMode `config:"color"` DefaultTime Time `config:"default_time"` // time that directories with no time should display Inplace bool `config:"inplace"` // Download directly to destination file instead of atomic download to temp/rename PartialSuffix string `config:"partial_suffix"` MetadataMapper SpaceSepList `config:"metadata_mapper"` MaxConnections int `config:"max_connections"` NameTransform []string `config:"name_transform"` HTTPProxy string `config:"http_proxy"` } func init() { // Set any values which aren't the zero for the type globalConfig.DeleteMode = DeleteModeDefault // Register the config and fill globalConfig with the defaults RegisterGlobalOptions(OptionsInfo{Name: "main", Opt: globalConfig, Options: ConfigOptionsInfo, Reload: globalConfig.Reload}) // initial guess at log level from the flags globalConfig.LogLevel = InitialLogLevel() } // LogReload is written by fs/log to set variables which should really // be there but we can't move due to them being visible here in the rc. var LogReload = func(*ConfigInfo) error { return nil } // Reload assumes the config has been edited and does what is necessary to make it live func (ci *ConfigInfo) Reload(ctx context.Context) error { // Set -vv if --dump is in use if ci.Dump != 0 && ci.LogLevel != LogLevelDebug { Logf(nil, "Automatically setting -vv as --dump is enabled") ci.LogLevel = LogLevelDebug } // If --dry-run or -i then use NOTICE as minimum log level if (ci.DryRun || ci.Interactive) && ci.StatsLogLevel > LogLevelNotice { ci.StatsLogLevel = LogLevelNotice } // Check --compare-dest and --copy-dest if len(ci.CompareDest) > 0 && len(ci.CopyDest) > 0 { return fmt.Errorf("can't use --compare-dest with --copy-dest") } // Check --stats-one-line and dependent flags switch { case len(ci.StatsOneLineDateFormat) > 0: ci.StatsOneLineDate = true ci.StatsOneLine = true case ci.StatsOneLineDate: ci.StatsOneLineDateFormat = "2006/01/02 15:04:05 - " ci.StatsOneLine = true } // Check --partial-suffix if len(ci.PartialSuffix) > 16 { return fmt.Errorf("--partial-suffix: Expecting suffix length not greater than %d but got %d", 16, len(ci.PartialSuffix)) } // Make sure some values are > 0 nonZero := func(pi *int) { if *pi <= 0 { *pi = 1 } } // Check --stats-unit if ci.DataRateUnit != "bits" && ci.DataRateUnit != "bytes" { Errorf(nil, "Unknown unit %q passed to --stats-unit. Defaulting to bytes.", ci.DataRateUnit) ci.DataRateUnit = "bytes" } // Check these are all > 0 nonZero(&ci.Retries) nonZero(&ci.LowLevelRetries) nonZero(&ci.Transfers) nonZero(&ci.Checkers) return LogReload(ci) } // InitialLogLevel performs a simple check for debug flags to enable // debug logging during the flag initialization. func InitialLogLevel() LogLevel { logLevel := LogLevelNotice for argIndex, arg := range os.Args { if strings.HasPrefix(arg, "-vv") && strings.TrimRight(arg, "v") == "-" { logLevel = LogLevelDebug } if arg == "--log-level=DEBUG" || (arg == "--log-level" && len(os.Args) > argIndex+1 && os.Args[argIndex+1] == "DEBUG") { logLevel = LogLevelDebug } if strings.HasPrefix(arg, "--verbose=") { if level, err := strconv.Atoi(arg[10:]); err == nil && level >= 2 { logLevel = LogLevelDebug } } } envValue, found := os.LookupEnv("RCLONE_LOG_LEVEL") if found && envValue == "DEBUG" { logLevel = LogLevelDebug } return logLevel } // TimeoutOrInfinite returns ci.Timeout if > 0 or infinite otherwise func (ci *ConfigInfo) TimeoutOrInfinite() time.Duration { if ci.Timeout > 0 { return time.Duration(ci.Timeout) } return ModTimeNotSupported } type configContextKeyType struct{} // Context key for config var configContextKey = configContextKeyType{} // GetConfig returns the global or context sensitive context func GetConfig(ctx context.Context) *ConfigInfo { if ctx == nil { return globalConfig } c := ctx.Value(configContextKey) if c == nil { return globalConfig } return c.(*ConfigInfo) } // CopyConfig copies the global config (if any) from srcCtx into // dstCtx returning the new context. func CopyConfig(dstCtx, srcCtx context.Context) context.Context { if srcCtx == nil { return dstCtx } c := srcCtx.Value(configContextKey) if c == nil { return dstCtx } return context.WithValue(dstCtx, configContextKey, c) } // AddConfig returns a mutable config structure based on a shallow // copy of that found in ctx and returns a new context with that added // to it. func AddConfig(ctx context.Context) (context.Context, *ConfigInfo) { c := GetConfig(ctx) cCopy := new(ConfigInfo) *cCopy = *c newCtx := context.WithValue(ctx, configContextKey, cCopy) return newCtx, cCopy } // ConfigToEnv converts a config section and name, e.g. ("my-remote", // "ignore-size") into an environment name // "RCLONE_CONFIG_MY-REMOTE_IGNORE_SIZE" func ConfigToEnv(section, name string) string { return "RCLONE_CONFIG_" + strings.ToUpper(section+"_"+strings.ReplaceAll(name, "-", "_")) } // OptionToEnv converts an option name, e.g. "ignore-size" into an // environment name "RCLONE_IGNORE_SIZE" func OptionToEnv(name string) string { return "RCLONE_" + strings.ToUpper(strings.ReplaceAll(name, "-", "_")) } rclone-v1.71.0/fs/config/000077500000000000000000000000001505210326400151235ustar00rootroot00000000000000rclone-v1.71.0/fs/config/authorize.go000066400000000000000000000036741505210326400174760ustar00rootroot00000000000000package config import ( "context" "fmt" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configmap" ) // Authorize is for remote authorization of headless machines. // // It expects 1, 2 or 3 arguments // // rclone authorize "fs name" // rclone authorize "fs name" "base64 encoded JSON blob" // rclone authorize "fs name" "client id" "client secret" func Authorize(ctx context.Context, args []string, noAutoBrowser bool, templateFile string) error { ctx = suppressConfirm(ctx) ctx = fs.ConfigOAuthOnly(ctx) switch len(args) { case 1, 2, 3: default: return fmt.Errorf("invalid number of arguments: %d", len(args)) } Type := args[0] // FIXME could read this from input ri, err := fs.Find(Type) if err != nil { return err } if ri.Config == nil { return fmt.Errorf("can't authorize fs %q", Type) } // Config map for remote inM := configmap.Simple{} // Indicate that we are running rclone authorize inM[ConfigAuthorize] = "true" if noAutoBrowser { inM[ConfigAuthNoBrowser] = "true" } // Indicate if we specified a custom template via a file if templateFile != "" { inM[ConfigTemplateFile] = templateFile } // Add extra parameters if supplied if len(args) == 2 { err := inM.Decode(args[1]) if err != nil { return err } } else if len(args) == 3 { inM[ConfigClientID] = args[1] inM[ConfigClientSecret] = args[2] } // Name used for temporary remote name := "**temp-fs**" m := fs.ConfigMap(ri.Prefix, ri.Options, name, inM) outM := configmap.Simple{} m.ClearSetters() m.AddSetter(outM) m.AddGetter(outM, configmap.PriorityNormal) err = PostConfig(ctx, name, m, ri) if err != nil { return err } // Print the code for the user to paste out := outM["token"] // If received a config blob, then return one if len(args) == 2 { out, err = outM.Encode() if err != nil { return err } } fmt.Printf("Paste the following into your remote machine --->\n%s\n<---End paste\n", out) return nil } rclone-v1.71.0/fs/config/config.go000066400000000000000000000576101505210326400167300ustar00rootroot00000000000000// Package config reads, writes and edits the config file and deals with command line flags package config import ( "context" "encoding/json" "errors" "fmt" mathrand "math/rand" "os" "path/filepath" "regexp" "runtime" "strings" "time" "github.com/mitchellh/go-homedir" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/fspath" "github.com/rclone/rclone/fs/rc" "github.com/rclone/rclone/lib/file" "github.com/rclone/rclone/lib/random" ) const ( configFileName = "rclone.conf" hiddenConfigFileName = "." + configFileName noConfigFile = "notfound" // ConfigToken is the key used to store the token under ConfigToken = "token" // ConfigClientID is the config key used to store the client id ConfigClientID = "client_id" // ConfigClientSecret is the config key used to store the client secret ConfigClientSecret = "client_secret" // ConfigAuthURL is the config key used to store the auth server endpoint ConfigAuthURL = "auth_url" // ConfigTokenURL is the config key used to store the token server endpoint ConfigTokenURL = "token_url" // ConfigClientCredentials - use OAUTH2 client credentials ConfigClientCredentials = "client_credentials" // ConfigEncoding is the config key to change the encoding for a backend ConfigEncoding = "encoding" // ConfigEncodingHelp is the help for ConfigEncoding ConfigEncodingHelp = "The encoding for the backend.\n\nSee the [encoding section in the overview](/overview/#encoding) for more info." // ConfigAuthorize indicates that we just want "rclone authorize" ConfigAuthorize = "config_authorize" // ConfigAuthNoBrowser indicates that we do not want to open browser ConfigAuthNoBrowser = "config_auth_no_browser" // ConfigTemplate is the template content to be used in the authorization webserver ConfigTemplate = "config_template" // ConfigTemplateFile is the path to a template file to read into the value of `ConfigTemplate` above ConfigTemplateFile = "config_template_file" ) // Storage defines an interface for loading and saving config to // persistent storage. Rclone provides a default implementation to // load and save to a config file when this is imported // // import "github.com/rclone/rclone/fs/config/configfile" // configfile.Install() type Storage interface { // GetSectionList returns a slice of strings with names for all the // sections GetSectionList() []string // HasSection returns true if section exists in the config file HasSection(section string) bool // DeleteSection removes the named section and all config from the // config file DeleteSection(section string) // GetKeyList returns the keys in this section GetKeyList(section string) []string // GetValue returns the key in section with a found flag GetValue(section string, key string) (value string, found bool) // SetValue sets the value under key in section SetValue(section string, key string, value string) // DeleteKey removes the key under section DeleteKey(section string, key string) bool // Load the config from permanent storage Load() error // Save the config to permanent storage Save() error // Serialize the config into a string Serialize() (string, error) } // Global var ( // Password can be used to configure the random password generator Password = random.Password ) var ( configPath string cacheDir string data Storage dataLoaded bool ) func init() { // Set the function pointers up in fs fs.ConfigFileGet = FileGetValue fs.ConfigFileSet = SetValueAndSave fs.ConfigFileHasSection = func(section string) bool { return LoadedData().HasSection(section) } configPath = makeConfigPath() cacheDir = makeCacheDir() // Has fallback to tempDir, so set that first data = newDefaultStorage() } // Join directory with filename, and check if exists func findFile(dir string, name string) string { path := filepath.Join(dir, name) if _, err := os.Stat(path); err != nil { return "" } return path } // Find current user's home directory func findHomeDir() (string, error) { path, err := homedir.Dir() if err != nil { fs.Debugf(nil, "Home directory lookup failed and cannot be used as configuration location: %v", err) } else if path == "" { // On Unix homedir return success but empty string for user with empty home configured in passwd file fs.Debugf(nil, "Home directory not defined and cannot be used as configuration location") } return path, err } // Find rclone executable directory and look for existing rclone.conf there // (/rclone.conf) func findLocalConfig() (configDir string, configFile string) { if exePath, err := os.Executable(); err == nil { configDir = filepath.Dir(exePath) configFile = findFile(configDir, configFileName) } return } // Get path to Windows AppData config subdirectory for rclone and look for existing rclone.conf there // ($AppData/rclone/rclone.conf) func findAppDataConfig() (configDir string, configFile string) { if appDataDir := os.Getenv("APPDATA"); appDataDir != "" { configDir = filepath.Join(appDataDir, "rclone") configFile = findFile(configDir, configFileName) } else { fs.Debugf(nil, "Environment variable APPDATA is not defined and cannot be used as configuration location") } return } // Get path to XDG config subdirectory for rclone and look for existing rclone.conf there // (see XDG Base Directory specification: https://specifications.freedesktop.org/basedir-spec/latest/). // ($XDG_CONFIG_HOME\rclone\rclone.conf) func findXDGConfig() (configDir string, configFile string) { if xdgConfigDir := os.Getenv("XDG_CONFIG_HOME"); xdgConfigDir != "" { configDir = filepath.Join(xdgConfigDir, "rclone") configFile = findFile(configDir, configFileName) } return } // Get path to .config subdirectory for rclone and look for existing rclone.conf there // (~/.config/rclone/rclone.conf) func findDotConfigConfig(home string) (configDir string, configFile string) { if home != "" { configDir = filepath.Join(home, ".config", "rclone") configFile = findFile(configDir, configFileName) } return } // Look for existing .rclone.conf (legacy hidden filename) in root of user's home directory // (~/.rclone.conf) func findOldHomeConfig(home string) (configDir string, configFile string) { if home != "" { configDir = home configFile = findFile(home, hiddenConfigFileName) } return } // Return the path to the configuration file func makeConfigPath() string { // Look for existing rclone.conf in prioritized list of known locations // Also get configuration directory to use for new config file when no existing is found. var ( configFile string configDir string primaryConfigDir string fallbackConfigDir string ) // /rclone.conf if _, configFile = findLocalConfig(); configFile != "" { return configFile } // Windows: $AppData/rclone/rclone.conf // This is also the default location for new config when no existing is found if runtime.GOOS == "windows" { if primaryConfigDir, configFile = findAppDataConfig(); configFile != "" { return configFile } } // $XDG_CONFIG_HOME/rclone/rclone.conf // Also looking for this on Windows, for backwards compatibility reasons. if configDir, configFile = findXDGConfig(); configFile != "" { return configFile } if runtime.GOOS != "windows" { // On Unix this is also the default location for new config when no existing is found primaryConfigDir = configDir } // ~/.config/rclone/rclone.conf // This is also the fallback location for new config // (when $AppData on Windows and $XDG_CONFIG_HOME on Unix is not defined) homeDir, homeDirErr := findHomeDir() if fallbackConfigDir, configFile = findDotConfigConfig(homeDir); configFile != "" { return configFile } // ~/.rclone.conf if _, configFile = findOldHomeConfig(homeDir); configFile != "" { return configFile } // No existing config file found, prepare proper default for a new one. // But first check if user supplied a --config variable or environment // variable, since then we skip actually trying to create the default // and report any errors related to it (we can't use pflag for this because // it isn't initialised yet so we search the command line manually). _, configSupplied := os.LookupEnv("RCLONE_CONFIG") if !configSupplied { for _, item := range os.Args { if item == "--config" || strings.HasPrefix(item, "--config=") { configSupplied = true break } } } // If we found a configuration directory to be used for new config during search // above, then create it to be ready for rclone.conf file to be written into it // later, and also as a test of permissions to use fallback if not even able to // create the directory. if primaryConfigDir != "" { configDir = primaryConfigDir } else if fallbackConfigDir != "" { configDir = fallbackConfigDir } else { configDir = "" } if configDir != "" { configFile = filepath.Join(configDir, configFileName) if configSupplied { // User supplied custom config option, just return the default path // as is without creating any directories, since it will not be used // anyway and we don't want to unnecessarily create empty directory. return configFile } var mkdirErr error if mkdirErr = file.MkdirAll(configDir, os.ModePerm); mkdirErr == nil { return configFile } // Problem: Try a fallback location. If we did find a home directory then // just assume file .rclone.conf (legacy hidden filename) can be written in // its root (~/.rclone.conf). if homeDir != "" { fs.Debugf(nil, "Configuration directory could not be created and will not be used: %v", mkdirErr) return filepath.Join(homeDir, hiddenConfigFileName) } if !configSupplied { fs.Errorf(nil, "Couldn't find home directory nor create configuration directory: %v", mkdirErr) } } else if !configSupplied { if homeDirErr != nil { fs.Errorf(nil, "Couldn't find configuration directory nor home directory: %v", homeDirErr) } else { fs.Errorf(nil, "Couldn't find configuration directory nor home directory") } } // No known location that can be used: Did possibly find a configDir // (XDG_CONFIG_HOME or APPDATA) which couldn't be created, but in any case // did not find a home directory! // Report it as an error, and return as last resort the path relative to current // working directory, of .rclone.conf (legacy hidden filename). if !configSupplied { fs.Errorf(nil, "Defaulting to storing config in current directory.") fs.Errorf(nil, "Use --config flag to workaround.") } return hiddenConfigFileName } // GetConfigPath returns the current config file path func GetConfigPath() string { return configPath } // SetConfigPath sets new config file path // // Checks for empty string, os null device, or special path, all of which indicates in-memory config. func SetConfigPath(path string) (err error) { var cfgPath string if path == "" || path == os.DevNull { cfgPath = "" } else if filepath.Base(path) == noConfigFile { cfgPath = "" } else if err = file.IsReserved(path); err != nil { return err } else if cfgPath, err = filepath.Abs(path); err != nil { return err } configPath = cfgPath return nil } // SetData sets new config file storage func SetData(newData Storage) { // If no config file, use in-memory config (which is the default) if configPath == "" { return } data = newData dataLoaded = false } // Data returns current config file storage func Data() Storage { return data } // ErrorConfigFileNotFound is returned when the config file is not found var ErrorConfigFileNotFound = errors.New("config file not found") // LoadedData ensures the config file storage is loaded and returns it func LoadedData() Storage { if !dataLoaded { // Set RCLONE_CONFIG_DIR for backend config and subprocesses // If empty configPath (in-memory only) the value will be "." _ = os.Setenv("RCLONE_CONFIG_DIR", filepath.Dir(configPath)) // Load configuration from file (or initialize sensible default if no file or error) if err := data.Load(); err == nil { fs.Debugf(nil, "Using config file from %q", configPath) dataLoaded = true } else if err == ErrorConfigFileNotFound { if configPath == "" { fs.Debugf(nil, "Config is memory-only - using defaults") } else { fs.Logf(nil, "Config file %q not found - using defaults", configPath) } dataLoaded = true } else { fs.Fatalf(nil, "Failed to load config file %q: %v", configPath, err) } } return data } // SaveConfig calling function which saves configuration file. // if SaveConfig returns error trying again after sleep. func SaveConfig() { ctx := context.Background() ci := fs.GetConfig(ctx) var err error for range ci.LowLevelRetries + 1 { if err = LoadedData().Save(); err == nil { return } waitingTimeMs := mathrand.Intn(1000) time.Sleep(time.Duration(waitingTimeMs) * time.Millisecond) } fs.Errorf(nil, "Failed to save config after %d tries: %v", ci.LowLevelRetries, err) } // FileSections returns the sections in the config file func FileSections() []string { return LoadedData().GetSectionList() } // FileGetValue gets the config key under section returning the // the value and true if found and or ("", false) otherwise func FileGetValue(section, key string) (string, bool) { return LoadedData().GetValue(section, key) } // FileSetValue sets the key in section to value. // It doesn't save the config file. func FileSetValue(section, key, value string) { LoadedData().SetValue(section, key, value) } // FileDeleteKey deletes the config key in the config file. // It returns true if the key was deleted, // or returns false if the section or key didn't exist. func FileDeleteKey(section, key string) bool { return LoadedData().DeleteKey(section, key) } // GetValue gets the value for a config key from environment // or config file under section returning the default if not set. // // Emulates the preference documented and normally used by rclone via // configmap, which means environment variables before config file. func GetValue(remote, key string) string { envKey := fs.ConfigToEnv(remote, key) value, found := os.LookupEnv(envKey) if found { return value } value, _ = LoadedData().GetValue(remote, key) return value } // SetValueAndSave sets the key to the value and saves just that // value in the config file. It loads the old config file in from // disk first and overwrites the given value only. func SetValueAndSave(remote, key, value string) error { // Set the value in config in case we fail to reload it FileSetValue(remote, key, value) // Save it again SaveConfig() return nil } // Remote defines a remote with a name, type, source and description type Remote struct { Name string `json:"name"` Type string `json:"type"` Source string `json:"source"` Description string `json:"description"` } var remoteEnvRe = regexp.MustCompile(`^RCLONE_CONFIG_(.+?)_TYPE=(.+)$`) // GetRemotes returns the list of remotes defined in environment and config file. // // Emulates the preference documented and normally used by rclone via // configmap, which means environment variables before config file. func GetRemotes() []Remote { var remotes []Remote for _, item := range os.Environ() { matches := remoteEnvRe.FindStringSubmatch(item) if len(matches) == 3 { remotes = append(remotes, Remote{ Name: strings.ToLower(matches[1]), Type: strings.ToLower(matches[2]), Source: "environment", }) } } remoteExists := func(name string) bool { for _, remote := range remotes { if name == remote.Name { return true } } return false } sections := LoadedData().GetSectionList() for _, section := range sections { if !remoteExists(section) { typeValue, found := LoadedData().GetValue(section, "type") if found { description, _ := LoadedData().GetValue(section, "description") remotes = append(remotes, Remote{ Name: section, Type: typeValue, Source: "file", Description: description, }) } } } return remotes } // GetRemoteNames returns the names of remotes defined in environment and config file. func GetRemoteNames() []string { remotes := GetRemotes() var remoteNames []string for _, remote := range remotes { remoteNames = append(remoteNames, remote.Name) } return remoteNames } // UpdateRemoteOpt configures the remote update type UpdateRemoteOpt struct { // Treat all passwords as plain that need obscuring Obscure bool `json:"obscure"` // Treat all passwords as obscured NoObscure bool `json:"noObscure"` // Don't provide any output NoOutput bool `json:"noOutput"` // Don't interact with the user - return questions NonInteractive bool `json:"nonInteractive"` // If set then supply state and result parameters to continue the process Continue bool `json:"continue"` // If set then ask all the questions, not just the post config questions All bool `json:"all"` // State to restart with - used with Continue State string `json:"state"` // Result to return - used with Continue Result string `json:"result"` // If set then edit existing values Edit bool `json:"edit"` } func updateRemote(ctx context.Context, name string, keyValues rc.Params, opt UpdateRemoteOpt) (out *fs.ConfigOut, err error) { if opt.Obscure && opt.NoObscure { return nil, errors.New("can't use --obscure and --no-obscure together") } err = fspath.CheckConfigName(name) if err != nil { return nil, err } interactive := !(opt.NonInteractive || opt.Continue) if interactive && !opt.All { ctx = suppressConfirm(ctx) } fsType := GetValue(name, "type") if fsType == "" { return nil, errors.New("couldn't find type field in config") } ri, err := fs.Find(fsType) if err != nil { return nil, fmt.Errorf("couldn't find backend for type %q", fsType) } // Work out which options need to be obscured needsObscure := map[string]struct{}{} if !opt.NoObscure { for _, option := range ri.Options { if option.IsPassword { needsObscure[option.Name] = struct{}{} } } } choices := configmap.Simple{} m := fs.ConfigMap(ri.Prefix, ri.Options, name, nil) // Set the config for k, v := range keyValues { vStr := fmt.Sprint(v) if strings.ContainsAny(k, "\n\r") || strings.ContainsAny(vStr, "\n\r") { return nil, fmt.Errorf("update remote: invalid key or value contains \\n or \\r") } // Obscure parameter if necessary if _, ok := needsObscure[k]; ok { _, err := obscure.Reveal(vStr) if err != nil || opt.Obscure { // If error => not already obscured, so obscure it // or we are forced to obscure vStr, err = obscure.Obscure(vStr) if err != nil { return nil, fmt.Errorf("update remote: obscure failed: %w", err) } } } choices.Set(k, vStr) if !strings.HasPrefix(k, fs.ConfigKeyEphemeralPrefix) { m.Set(k, vStr) } } if opt.Edit { choices[fs.ConfigEdit] = "true" } if interactive { var state = "" if opt.All { state = fs.ConfigAll } err = backendConfig(ctx, name, m, ri, choices, state) } else { // Start the config state machine in := fs.ConfigIn{ State: opt.State, Result: opt.Result, } if in.State == "" && opt.All { in.State = fs.ConfigAll } out, err = fs.BackendConfig(ctx, name, m, ri, choices, in) } if err != nil { return nil, err } SaveConfig() cache.ClearConfig(name) // remove any remotes based on this config from the cache return out, nil } // UpdateRemote adds the keyValues passed in to the remote of name. // keyValues should be key, value pairs. func UpdateRemote(ctx context.Context, name string, keyValues rc.Params, opt UpdateRemoteOpt) (out *fs.ConfigOut, err error) { opt.Edit = true return updateRemote(ctx, name, keyValues, opt) } // CreateRemote creates a new remote with name, type and a list of // parameters which are key, value pairs. If update is set then it // adds the new keys rather than replacing all of them. func CreateRemote(ctx context.Context, name string, Type string, keyValues rc.Params, opts UpdateRemoteOpt) (out *fs.ConfigOut, err error) { err = fspath.CheckConfigName(name) if err != nil { return nil, err } if !opts.Continue { // Delete the old config if it exists LoadedData().DeleteSection(name) // Set the type LoadedData().SetValue(name, "type", Type) } // Set the remaining values return UpdateRemote(ctx, name, keyValues, opts) } // PasswordRemote adds the keyValues passed in to the remote of name. // keyValues should be key, value pairs. func PasswordRemote(ctx context.Context, name string, keyValues rc.Params) error { ctx = suppressConfirm(ctx) err := fspath.CheckConfigName(name) if err != nil { return err } for k, v := range keyValues { keyValues[k] = obscure.MustObscure(fmt.Sprint(v)) } _, err = UpdateRemote(ctx, name, keyValues, UpdateRemoteOpt{ NoObscure: true, }) return err } // JSONListProviders prints all the providers and options in JSON format func JSONListProviders() error { b, err := json.MarshalIndent(fs.Registry, "", " ") if err != nil { return fmt.Errorf("failed to marshal examples: %w", err) } _, err = os.Stdout.Write(b) if err != nil { return fmt.Errorf("failed to write providers list: %w", err) } return nil } // fsOption returns an Option describing the possible remotes func fsOption() *fs.Option { o := &fs.Option{ Name: "Storage", Help: "Type of storage to configure.", Default: "", Required: true, } for _, item := range fs.Registry { if item.Hide { continue } example := fs.OptionExample{ Value: item.Name, Help: item.Description, } o.Examples = append(o.Examples, example) } o.Examples.Sort() return o } // DumpRcRemote dumps the config for a single remote func DumpRcRemote(name string) (dump rc.Params) { params := rc.Params{} for _, key := range LoadedData().GetKeyList(name) { params[key] = GetValue(name, key) } return params } // DumpRcBlob dumps all the config as an unstructured blob suitable // for the rc func DumpRcBlob() (dump rc.Params) { dump = rc.Params{} for _, name := range LoadedData().GetSectionList() { dump[name] = DumpRcRemote(name) } return dump } // Dump dumps all the config as a JSON file func Dump() error { dump := DumpRcBlob() b, err := json.MarshalIndent(dump, "", " ") if err != nil { return fmt.Errorf("failed to marshal config dump: %w", err) } _, err = os.Stdout.Write(b) if err != nil { return fmt.Errorf("failed to write config dump: %w", err) } return nil } // makeCacheDir returns a directory to use for caching. func makeCacheDir() (dir string) { dir, err := os.UserCacheDir() if err != nil || dir == "" { fs.Debugf(nil, "Failed to find user cache dir, using temporary directory: %v", err) // if no dir found then use TempDir - we will have a cachedir! dir = os.TempDir() } return filepath.Join(dir, "rclone") } // GetCacheDir returns the default directory for cache // // The directory is neither guaranteed to exist nor have accessible permissions. // Users of this should make a subdirectory and use MkdirAll() to create it // and any parents. func GetCacheDir() string { return cacheDir } // SetCacheDir sets new default directory for cache func SetCacheDir(path string) (err error) { cacheDir, err = filepath.Abs(path) return } // SetTempDir sets new default directory to use for temporary files. // // Assuming golang's os.TempDir is used to get the directory: // "On Unix systems, it returns $TMPDIR if non-empty, else /tmp. On Windows, // it uses GetTempPath, returning the first non-empty value from %TMP%, %TEMP%, // %USERPROFILE%, or the Windows directory." // // To override the default we therefore set environment variable TMPDIR // on Unix systems, and both TMP and TEMP on Windows (they are almost exclusively // aliases for the same path, and programs may refer to to either of them). // This should make all libraries and forked processes use the same. func SetTempDir(path string) (err error) { var tempDir string if tempDir, err = filepath.Abs(path); err != nil { return err } if runtime.GOOS == "windows" { if err = os.Setenv("TMP", tempDir); err != nil { return err } if err = os.Setenv("TEMP", tempDir); err != nil { return err } } else { return os.Setenv("TMPDIR", tempDir) } return nil } rclone-v1.71.0/fs/config/config_read_password.go000066400000000000000000000011461505210326400216360ustar00rootroot00000000000000// ReadPassword for OSes which are supported by golang.org/x/term // See https://github.com/golang/go/issues/14441 - plan9 //go:build !plan9 package config import ( "fmt" "os" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/lib/terminal" ) // ReadPassword reads a password without echoing it to the terminal. func ReadPassword() string { stdin := int(os.Stdin.Fd()) if !terminal.IsTerminal(stdin) { return ReadLine("") } line, err := terminal.ReadPassword(stdin) _, _ = fmt.Fprintln(os.Stderr) if err != nil { fs.Fatalf(nil, "Failed to read password: %v", err) } return string(line) } rclone-v1.71.0/fs/config/config_read_password_unsupported.go000066400000000000000000000004301505210326400243010ustar00rootroot00000000000000// ReadPassword for OSes which are not supported by golang.org/x/term // See https://github.com/golang/go/issues/14441 - plan9 //go:build plan9 package config // ReadPassword reads a password with echoing it to the terminal. func ReadPassword() string { return ReadLine("") } rclone-v1.71.0/fs/config/config_test.go000066400000000000000000000014221505210326400177550ustar00rootroot00000000000000// These are in an external package because we need to import configfile package config_test import ( "testing" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configfile" "github.com/stretchr/testify/assert" ) func init() { configfile.Install() } func TestConfigLoad(t *testing.T) { oldConfigPath := config.GetConfigPath() assert.NoError(t, config.SetConfigPath("./testdata/plain.conf")) defer func() { assert.NoError(t, config.SetConfigPath(oldConfigPath)) }() config.ClearConfigPassword() sections := config.Data().GetSectionList() var expect = []string{"RCLONE_ENCRYPT_V0", "nounc", "unc"} assert.Equal(t, expect, sections) keys := config.Data().GetKeyList("nounc") expect = []string{"type", "nounc"} assert.Equal(t, expect, keys) } rclone-v1.71.0/fs/config/configfile/000077500000000000000000000000001505210326400172305ustar00rootroot00000000000000rclone-v1.71.0/fs/config/configfile/configfile.go000066400000000000000000000167501505210326400216750ustar00rootroot00000000000000// Package configfile implements a config file loader and saver package configfile import ( "bytes" "fmt" "os" "path/filepath" "strings" "sync" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/lib/file" "github.com/unknwon/goconfig" //nolint:misspell // Don't include misspell when running golangci-lint ) // Install installs the config file handler func Install() { config.SetData(&Storage{}) } // Storage implements config.Storage for saving and loading config // data in a simple INI based file. type Storage struct { mu sync.Mutex // to protect the following variables gc *goconfig.ConfigFile // config file loaded - not thread safe fi os.FileInfo // stat of the file when last loaded } // Check to see if we need to reload the config // // mu must be held when calling this func (s *Storage) _check() { if configPath := config.GetConfigPath(); configPath != "" { // Check to see if config file has changed since it was last loaded fi, err := os.Stat(configPath) if err == nil { // check to see if config file has changed and if it has, reload it if s.fi == nil || !fi.ModTime().Equal(s.fi.ModTime()) || fi.Size() != s.fi.Size() { fs.Debugf(nil, "Config file has changed externally - reloading") err := s._load() if err != nil { fs.Errorf(nil, "Failed to read config file - using previous config: %v", err) } } } } } // _load the config from permanent storage, decrypting if necessary // // mu must be held when calling this func (s *Storage) _load() (err error) { // Make sure we have a sensible default even when we error defer func() { if s.gc == nil { s.gc, _ = goconfig.LoadFromReader(bytes.NewReader([]byte{})) } }() configPath := config.GetConfigPath() if configPath == "" { return config.ErrorConfigFileNotFound } fd, err := os.Open(configPath) if err != nil { if os.IsNotExist(err) { return config.ErrorConfigFileNotFound } return err } defer fs.CheckClose(fd, &err) // Update s.fi with the current file info s.fi, _ = os.Stat(configPath) cryptReader, err := config.Decrypt(fd) if err != nil { return err } gc, err := goconfig.LoadFromReader(cryptReader) if err != nil { return err } s.gc = gc return nil } // Load the config from permanent storage, decrypting if necessary func (s *Storage) Load() (err error) { s.mu.Lock() defer s.mu.Unlock() return s._load() } // Save the config to permanent storage, encrypting if necessary func (s *Storage) Save() error { s.mu.Lock() defer s.mu.Unlock() configPath := config.GetConfigPath() if configPath == "" { return fmt.Errorf("failed to save config file, path is empty") } configDir, configName := filepath.Split(configPath) info, err := os.Lstat(configPath) if err != nil { if !os.IsNotExist(err) { return fmt.Errorf("failed to resolve config file path: %w", err) } } else { if info.Mode()&os.ModeSymlink != 0 { configPath, err = os.Readlink(configPath) if err != nil { return fmt.Errorf("failed to resolve config file symbolic link: %w", err) } if !filepath.IsAbs(configPath) { configPath = filepath.Join(configDir, configPath) } configDir = filepath.Dir(configPath) } } err = file.MkdirAll(configDir, os.ModePerm) if err != nil { return fmt.Errorf("failed to create config directory: %w", err) } f, err := os.CreateTemp(configDir, configName) if err != nil { return fmt.Errorf("failed to create temp file for new config: %w", err) } defer func() { _ = f.Close() if err := os.Remove(f.Name()); err != nil && !os.IsNotExist(err) { fs.Errorf(nil, "Failed to remove temp file for new config: %v", err) } }() var buf bytes.Buffer if err := goconfig.SaveConfigData(s.gc, &buf); err != nil { return fmt.Errorf("failed to save config file: %w", err) } if err := config.Encrypt(&buf, f); err != nil { return err } _ = f.Sync() err = f.Close() if err != nil { return fmt.Errorf("failed to close config file: %w", err) } var fileMode os.FileMode = 0600 info, err = os.Stat(configPath) if err != nil { fs.Debugf(nil, "Using default permissions for config file: %v", fileMode) } else if info.Mode() != fileMode { fs.Debugf(nil, "Keeping previous permissions for config file: %v", info.Mode()) fileMode = info.Mode() } attemptCopyGroup(configPath, f.Name()) err = os.Chmod(f.Name(), fileMode) if err != nil { fs.Errorf(nil, "Failed to set permissions on config file: %v", err) } fbackup, err := os.CreateTemp(configDir, configName+".old") if err != nil { return fmt.Errorf("failed to create temp file for old config backup: %w", err) } err = fbackup.Close() if err != nil { return fmt.Errorf("failed to close temp file for old config backup: %w", err) } keepBackup := true defer func() { if !keepBackup { if err := os.Remove(fbackup.Name()); err != nil && !os.IsNotExist(err) { fs.Errorf(nil, "Failed to remove temp file for old config backup: %v", err) } } }() if err = os.Rename(configPath, fbackup.Name()); err != nil { if !os.IsNotExist(err) { return fmt.Errorf("failed to move previous config to backup location: %w", err) } keepBackup = false // no existing file, no need to keep backup even if writing of new file fails } if err = os.Rename(f.Name(), configPath); err != nil { return fmt.Errorf("failed to move newly written config from %s to final location: %v", f.Name(), err) } keepBackup = false // new file was written, no need to keep backup // Update s.fi with the newly written file s.fi, _ = os.Stat(configPath) return nil } // Serialize the config into a string func (s *Storage) Serialize() (string, error) { s.mu.Lock() defer s.mu.Unlock() s._check() var buf bytes.Buffer if err := goconfig.SaveConfigData(s.gc, &buf); err != nil { return "", fmt.Errorf("failed to save config file: %w", err) } return buf.String(), nil } // HasSection returns true if section exists in the config file func (s *Storage) HasSection(section string) bool { s.mu.Lock() defer s.mu.Unlock() s._check() _, err := s.gc.GetSection(section) return err == nil } // DeleteSection removes the named section and all config from the // config file func (s *Storage) DeleteSection(section string) { s.mu.Lock() defer s.mu.Unlock() s._check() s.gc.DeleteSection(section) } // GetSectionList returns a slice of strings with names for all the // sections func (s *Storage) GetSectionList() []string { s.mu.Lock() defer s.mu.Unlock() s._check() return s.gc.GetSectionList() } // GetKeyList returns the keys in this section func (s *Storage) GetKeyList(section string) []string { s.mu.Lock() defer s.mu.Unlock() s._check() return s.gc.GetKeyList(section) } // GetValue returns the key in section with a found flag func (s *Storage) GetValue(section string, key string) (value string, found bool) { s.mu.Lock() defer s.mu.Unlock() s._check() value, err := s.gc.GetValue(section, key) if err != nil { return "", false } return value, true } // SetValue sets the value under key in section func (s *Storage) SetValue(section string, key string, value string) { s.mu.Lock() defer s.mu.Unlock() s._check() if strings.HasPrefix(section, ":") { fs.Logf(nil, "Can't save config %q for on the fly backend %q", key, section) return } s.gc.SetValue(section, key, value) } // DeleteKey removes the key under section func (s *Storage) DeleteKey(section string, key string) bool { s.mu.Lock() defer s.mu.Unlock() s._check() return s.gc.DeleteKey(section, key) } // Check the interface is satisfied var _ config.Storage = (*Storage)(nil) rclone-v1.71.0/fs/config/configfile/configfile_other.go000066400000000000000000000005551505210326400230720ustar00rootroot00000000000000// Read, write and edit the config file // Non-unix specific functions. //go:build !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris package configfile // attemptCopyGroup tries to keep the group the same, which only makes sense // for system with user-group-world permission model. func attemptCopyGroup(fromPath, toPath string) {} rclone-v1.71.0/fs/config/configfile/configfile_test.go000066400000000000000000000220411505210326400227220ustar00rootroot00000000000000package configfile import ( "fmt" "os" "path/filepath" "runtime" "strings" "testing" "github.com/rclone/rclone/fs/config" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var configData = `[one] type = number1 fruit = potato [two] type = number2 fruit = apple topping = nuts [three] type = number3 fruit = banana ` // Fill up a temporary config file with the testdata filename passed in func setConfigFile(t *testing.T, data string) func() { out, err := os.CreateTemp("", "rclone-configfile-test") require.NoError(t, err) filePath := out.Name() _, err = out.Write([]byte(data)) require.NoError(t, err) require.NoError(t, out.Close()) old := config.GetConfigPath() assert.NoError(t, config.SetConfigPath(filePath)) return func() { assert.NoError(t, config.SetConfigPath(old)) _ = os.Remove(filePath) } } // toUnix converts \r\n to \n in buf func toUnix(buf string) string { if runtime.GOOS == "windows" { return strings.ReplaceAll(buf, "\r\n", "\n") } return buf } func TestConfigFile(t *testing.T) { defer setConfigFile(t, configData)() data := &Storage{} require.NoError(t, data.Load()) t.Run("Read", func(t *testing.T) { t.Run("Serialize", func(t *testing.T) { buf, err := data.Serialize() require.NoError(t, err) assert.Equal(t, configData, toUnix(buf)) }) t.Run("HasSection", func(t *testing.T) { assert.True(t, data.HasSection("one")) assert.False(t, data.HasSection("missing")) }) t.Run("GetSectionList", func(t *testing.T) { assert.Equal(t, []string{ "one", "two", "three", }, data.GetSectionList()) }) t.Run("GetKeyList", func(t *testing.T) { assert.Equal(t, []string{ "type", "fruit", "topping", }, data.GetKeyList("two")) assert.Equal(t, []string(nil), data.GetKeyList("unicorn")) }) t.Run("GetValue", func(t *testing.T) { value, ok := data.GetValue("one", "type") assert.True(t, ok) assert.Equal(t, "number1", value) value, ok = data.GetValue("three", "fruit") assert.True(t, ok) assert.Equal(t, "banana", value) value, ok = data.GetValue("one", "typeX") assert.False(t, ok) assert.Equal(t, "", value) value, ok = data.GetValue("threeX", "fruit") assert.False(t, ok) assert.Equal(t, "", value) }) }) //defer setConfigFile(configData)() t.Run("Write", func(t *testing.T) { t.Run("SetValue", func(t *testing.T) { data.SetValue("one", "extra", "42") data.SetValue("two", "fruit", "acorn") buf, err := data.Serialize() require.NoError(t, err) assert.Equal(t, `[one] type = number1 fruit = potato extra = 42 [two] type = number2 fruit = acorn topping = nuts [three] type = number3 fruit = banana `, toUnix(buf)) t.Run("DeleteKey", func(t *testing.T) { data.DeleteKey("one", "type") data.DeleteKey("two", "missing") data.DeleteKey("three", "fruit") buf, err := data.Serialize() require.NoError(t, err) assert.Equal(t, `[one] fruit = potato extra = 42 [two] type = number2 fruit = acorn topping = nuts [three] type = number3 `, toUnix(buf)) t.Run("DeleteSection", func(t *testing.T) { data.DeleteSection("two") data.DeleteSection("missing") buf, err := data.Serialize() require.NoError(t, err) assert.Equal(t, `[one] fruit = potato extra = 42 [three] type = number3 `, toUnix(buf)) t.Run("Save", func(t *testing.T) { require.NoError(t, data.Save()) buf, err := os.ReadFile(config.GetConfigPath()) require.NoError(t, err) assert.Equal(t, `[one] fruit = potato extra = 42 [three] type = number3 `, toUnix(string(buf))) }) }) }) }) }) } func TestConfigFileReload(t *testing.T) { defer setConfigFile(t, configData)() data := &Storage{} require.NoError(t, data.Load()) value, ok := data.GetValue("three", "appended") assert.False(t, ok) assert.Equal(t, "", value) // Now write a new value on the end out, err := os.OpenFile(config.GetConfigPath(), os.O_APPEND|os.O_WRONLY, 0777) require.NoError(t, err) _, err = fmt.Fprintln(out, "appended = what magic") require.NoError(t, err) require.NoError(t, out.Close()) // And check we magically reloaded it value, ok = data.GetValue("three", "appended") assert.True(t, ok) assert.Equal(t, "what magic", value) } func TestConfigFileDoesNotExist(t *testing.T) { defer setConfigFile(t, configData)() data := &Storage{} require.NoError(t, os.Remove(config.GetConfigPath())) err := data.Load() require.Equal(t, config.ErrorConfigFileNotFound, err) // check that using data doesn't crash value, ok := data.GetValue("three", "appended") assert.False(t, ok) assert.Equal(t, "", value) } func testConfigFileNoConfig(t *testing.T, configPath string) { assert.NoError(t, config.SetConfigPath(configPath)) data := &Storage{} err := data.Load() require.Equal(t, config.ErrorConfigFileNotFound, err) data.SetValue("one", "extra", "42") value, ok := data.GetValue("one", "extra") assert.True(t, ok) assert.Equal(t, "42", value) err = data.Save() require.Error(t, err) } func TestConfigFileNoConfig(t *testing.T) { old := config.GetConfigPath() defer func() { assert.NoError(t, config.SetConfigPath(old)) }() t.Run("Empty", func(t *testing.T) { testConfigFileNoConfig(t, "") }) t.Run("NotFound", func(t *testing.T) { testConfigFileNoConfig(t, "/notfound") }) } func TestConfigFileSave(t *testing.T) { testDir := t.TempDir() configPath := filepath.Join(testDir, "a", "b", "c", "configfile") assert.NoError(t, config.SetConfigPath(configPath)) data := &Storage{} require.Error(t, data.Load(), config.ErrorConfigFileNotFound) t.Run("CreatesDirsAndFile", func(t *testing.T) { err := data.Save() require.NoError(t, err) info, err := os.Stat(configPath) require.NoError(t, err) assert.False(t, info.IsDir()) }) t.Run("KeepsFileMode", func(t *testing.T) { if runtime.GOOS != "linux" { t.Skip("this is a Linux only test") } assert.NoError(t, os.Chmod(configPath, 0400)) // -r-------- defer func() { _ = os.Chmod(configPath, 0644) // -rw-r--r-- }() err := data.Save() require.NoError(t, err) info, err := os.Stat(configPath) require.NoError(t, err) assert.Equal(t, os.FileMode(0400), info.Mode().Perm()) }) t.Run("SucceedsEvenIfReadOnlyFile", func(t *testing.T) { // Save succeeds even if file is read-only since it does not write directly to the file. assert.NoError(t, os.Chmod(configPath, 0400)) // -r-------- defer func() { _ = os.Chmod(configPath, 0644) // -rw-r--r-- }() err := data.Save() assert.NoError(t, err) }) t.Run("FailsIfNotAccessToDir", func(t *testing.T) { // Save fails if no access to the directory. if runtime.GOOS != "linux" { // On Windows the os.Chmod only affects the read-only attribute of files) t.Skip("this is a Linux only test") } configDir := filepath.Dir(configPath) assert.NoError(t, os.Chmod(configDir, 0400)) // -r-------- defer func() { _ = os.Chmod(configDir, 0755) // -rwxr-xr-x }() err := data.Save() require.Error(t, err) assert.True(t, strings.HasPrefix(err.Error(), "failed to resolve config file path")) }) t.Run("FailsIfNotAllowedToCreateNewFiles", func(t *testing.T) { // Save fails if read-only access to the directory, since it needs to create temporary files in there. if runtime.GOOS != "linux" { // On Windows the os.Chmod only affects the read-only attribute of files) t.Skip("this is a Linux only test") } configDir := filepath.Dir(configPath) assert.NoError(t, os.Chmod(configDir, 0544)) // -r-xr--r-- defer func() { _ = os.Chmod(configDir, 0755) // -rwxr-xr-x }() err := data.Save() require.Error(t, err) assert.True(t, strings.HasPrefix(err.Error(), "failed to create temp file for new config")) }) } func TestConfigFileSaveSymlinkAbsolute(t *testing.T) { if runtime.GOOS != "linux" { // Symlinks may require admin privileges on Windows and os.Symlink will then // fail with "A required privilege is not held by the client." t.Skip("this is a Linux only test") } testDir := t.TempDir() linkDir := filepath.Join(testDir, "a") err := os.Mkdir(linkDir, os.ModePerm) require.NoError(t, err) testSymlink := func(t *testing.T, link string, target string, resolvedTarget string) { err = os.Symlink(target, link) require.NoError(t, err) defer func() { _ = os.Remove(link) }() assert.NoError(t, config.SetConfigPath(link)) data := &Storage{} require.Error(t, data.Load(), config.ErrorConfigFileNotFound) err = data.Save() require.NoError(t, err) info, err := os.Lstat(link) require.NoError(t, err) assert.True(t, info.Mode()&os.ModeSymlink != 0) assert.False(t, info.IsDir()) info, err = os.Lstat(resolvedTarget) require.NoError(t, err) assert.False(t, info.IsDir()) } t.Run("Absolute", func(t *testing.T) { link := filepath.Join(linkDir, "configfilelink") target := filepath.Join(testDir, "b", "configfiletarget") testSymlink(t, link, target, target) }) t.Run("Relative", func(t *testing.T) { link := filepath.Join(linkDir, "configfilelink") target := filepath.Join("b", "c", "configfiletarget") resolvedTarget := filepath.Join(filepath.Dir(link), target) testSymlink(t, link, target, resolvedTarget) }) } rclone-v1.71.0/fs/config/configfile/configfile_unix.go000066400000000000000000000016641505210326400227360ustar00rootroot00000000000000// Read, write and edit the config file // Unix specific functions. //go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris package configfile import ( "os" "os/user" "strconv" "syscall" "github.com/rclone/rclone/fs" ) // attemptCopyGroup tries to keep the group the same. User will be the one // who is currently running this process. func attemptCopyGroup(fromPath, toPath string) { info, err := os.Stat(fromPath) if err != nil || info.Sys() == nil { return } if stat, ok := info.Sys().(*syscall.Stat_t); ok { uid := int(stat.Uid) // prefer self over previous owner of file, because it has a higher chance // of success if user, err := user.Current(); err == nil { if tmpUID, err := strconv.Atoi(user.Uid); err == nil { uid = tmpUID } } if err = os.Chown(toPath, uid, int(stat.Gid)); err != nil { fs.Debugf(nil, "Failed to keep previous owner of config file: %v", err) } } } rclone-v1.71.0/fs/config/configflags/000077500000000000000000000000001505210326400174055ustar00rootroot00000000000000rclone-v1.71.0/fs/config/configflags/configflags.go000066400000000000000000000207201505210326400222170ustar00rootroot00000000000000// Package configflags defines the flags used by rclone. It is // decoupled into a separate package so it can be replaced. package configflags // Options set by command line flags import ( "context" "net" "os" "strconv" "strings" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/flags" "github.com/spf13/pflag" ) var ( // these will get interpreted into fs.Config via SetFlags() below verbose int quiet bool configPath string cacheDir string tempDir string dumpHeaders bool dumpBodies bool deleteBefore bool deleteDuring bool deleteAfter bool bindAddr string disableFeatures string dscp string uploadHeaders []string downloadHeaders []string headers []string metadataSet []string ) // AddFlags adds the non filing system specific flags to the command func AddFlags(ci *fs.ConfigInfo, flagSet *pflag.FlagSet) { flags.AddFlagsFromOptions(flagSet, "", fs.ConfigOptionsInfo) // Add flags we haven't converted into options yet flags.CountVarP(flagSet, &verbose, "verbose", "v", "Print lots more stuff (repeat for more)", "Logging,Important") flags.BoolVarP(flagSet, &quiet, "quiet", "q", false, "Print as little stuff as possible", "Logging") flags.StringVarP(flagSet, &configPath, "config", "", config.GetConfigPath(), "Config file", "Config") flags.StringVarP(flagSet, &cacheDir, "cache-dir", "", config.GetCacheDir(), "Directory rclone will use for caching", "Config") flags.StringVarP(flagSet, &tempDir, "temp-dir", "", os.TempDir(), "Directory rclone will use for temporary files", "Config") flags.BoolVarP(flagSet, &dumpHeaders, "dump-headers", "", false, "Dump HTTP headers - may contain sensitive info", "Debugging") flags.BoolVarP(flagSet, &dumpBodies, "dump-bodies", "", false, "Dump HTTP headers and bodies - may contain sensitive info", "Debugging") flags.BoolVarP(flagSet, &deleteBefore, "delete-before", "", false, "When synchronizing, delete files on destination before transferring", "Sync") flags.BoolVarP(flagSet, &deleteDuring, "delete-during", "", false, "When synchronizing, delete files during transfer", "Sync") flags.BoolVarP(flagSet, &deleteAfter, "delete-after", "", false, "When synchronizing, delete files on destination after transferring (default)", "Sync") flags.StringVarP(flagSet, &bindAddr, "bind", "", "", "Local address to bind to for outgoing connections, IPv4, IPv6 or name", "Networking") flags.StringVarP(flagSet, &disableFeatures, "disable", "", "", "Disable a comma separated list of features (use --disable help to see a list)", "Config") flags.StringArrayVarP(flagSet, &uploadHeaders, "header-upload", "", nil, "Set HTTP header for upload transactions", "Networking") flags.StringArrayVarP(flagSet, &downloadHeaders, "header-download", "", nil, "Set HTTP header for download transactions", "Networking") flags.StringArrayVarP(flagSet, &headers, "header", "", nil, "Set HTTP header for all transactions", "Networking") flags.StringArrayVarP(flagSet, &metadataSet, "metadata-set", "", nil, "Add metadata key=value when uploading", "Metadata") flags.StringVarP(flagSet, &dscp, "dscp", "", "", "Set DSCP value to connections, value or name, e.g. CS1, LE, DF, AF21", "Networking") } // ParseHeaders converts the strings passed in via the header flags into HTTPOptions func ParseHeaders(headers []string) []*fs.HTTPOption { opts := []*fs.HTTPOption{} for _, header := range headers { parts := strings.SplitN(header, ":", 2) if len(parts) == 1 { fs.Fatalf(nil, "Failed to parse '%s' as an HTTP header. Expecting a string like: 'Content-Encoding: gzip'", header) } option := &fs.HTTPOption{ Key: strings.TrimSpace(parts[0]), Value: strings.TrimSpace(parts[1]), } opts = append(opts, option) } return opts } // SetFlags sets flags which aren't part of the config system func SetFlags(ci *fs.ConfigInfo) { // Process obsolete --dump-headers and --dump-bodies flags if dumpHeaders { ci.Dump |= fs.DumpHeaders fs.Logf(nil, "--dump-headers is obsolete - please use --dump headers instead") } if dumpBodies { ci.Dump |= fs.DumpBodies fs.Logf(nil, "--dump-bodies is obsolete - please use --dump bodies instead") } // Process -v flag if verbose >= 2 { ci.LogLevel = fs.LogLevelDebug } else if verbose >= 1 { ci.LogLevel = fs.LogLevelInfo } // Process -q flag if quiet { if verbose > 0 { fs.Fatalf(nil, "Can't set -v and -q") } ci.LogLevel = fs.LogLevelError } // Can't set log level, -v, -q logLevelFlag := pflag.Lookup("log-level") if logLevelFlag != nil && logLevelFlag.Changed { if verbose > 0 { fs.Fatalf(nil, "Can't set -v and --log-level") } if quiet { fs.Fatalf(nil, "Can't set -q and --log-level") } } // Process --delete-before, --delete-during and --delete-after switch { case deleteBefore && (deleteDuring || deleteAfter), deleteDuring && deleteAfter: fs.Fatalf(nil, `Only one of --delete-before, --delete-during or --delete-after can be used.`) case deleteBefore: ci.DeleteMode = fs.DeleteModeBefore case deleteDuring: ci.DeleteMode = fs.DeleteModeDuring case deleteAfter: ci.DeleteMode = fs.DeleteModeAfter default: ci.DeleteMode = fs.DeleteModeDefault } // Process --bind into IP address if bindAddr != "" { addrs, err := net.LookupIP(bindAddr) if err != nil { fs.Fatalf(nil, "--bind: Failed to parse %q as IP address: %v", bindAddr, err) } if len(addrs) != 1 { fs.Fatalf(nil, "--bind: Expecting 1 IP address for %q but got %d", bindAddr, len(addrs)) } ci.BindAddr = addrs[0] } // Process --disable if disableFeatures != "" { if disableFeatures == "help" { fs.Fatalf(nil, "Possible backend features are: %s\n", strings.Join(new(fs.Features).List(), ", ")) } ci.DisableFeatures = strings.Split(disableFeatures, ",") } // Process --headers-upload, --headers-download, --headers if len(uploadHeaders) != 0 { ci.UploadHeaders = ParseHeaders(uploadHeaders) } if len(downloadHeaders) != 0 { ci.DownloadHeaders = ParseHeaders(downloadHeaders) } if len(headers) != 0 { ci.Headers = ParseHeaders(headers) } // Process --metadata-set if len(metadataSet) != 0 { ci.MetadataSet = make(fs.Metadata, len(metadataSet)) for _, kv := range metadataSet { equal := strings.IndexRune(kv, '=') if equal < 0 { fs.Fatalf(nil, "Failed to parse '%s' as metadata key=value.", kv) } ci.MetadataSet[strings.ToLower(kv[:equal])] = kv[equal+1:] } fs.Debugf(nil, "MetadataUpload %v", ci.MetadataSet) } // Process --dscp if len(dscp) != 0 { if value, ok := parseDSCP(dscp); ok { ci.TrafficClass = value << 2 } else { fs.Fatalf(nil, "--dscp: Invalid DSCP name: %v", dscp) } } // Process --config path if err := config.SetConfigPath(configPath); err != nil { fs.Fatalf(nil, "--config: Failed to set %q as config path: %v", configPath, err) } // Process --cache-dir path if err := config.SetCacheDir(cacheDir); err != nil { fs.Fatalf(nil, "--cache-dir: Failed to set %q as cache dir: %v", cacheDir, err) } // Process --temp-dir path if err := config.SetTempDir(tempDir); err != nil { fs.Fatalf(nil, "--temp-dir: Failed to set %q as temp dir: %v", tempDir, err) } // Process --multi-thread-streams - set whether multi-thread-streams was set multiThreadStreamsFlag := pflag.Lookup("multi-thread-streams") ci.MultiThreadSet = multiThreadStreamsFlag != nil && multiThreadStreamsFlag.Changed // Reload any changes if err := ci.Reload(context.Background()); err != nil { fs.Fatalf(nil, "Failed to reload config changes: %v", err) } } // parseDSCP converts DSCP names to value func parseDSCP(dscp string) (uint8, bool) { if s, err := strconv.ParseUint(dscp, 10, 6); err == nil { return uint8(s), true } dscp = strings.ToUpper(dscp) switch dscp { case "BE": fallthrough case "DF": fallthrough case "CS0": return 0x00, true case "CS1": return 0x08, true case "AF11": return 0x0A, true case "AF12": return 0x0C, true case "AF13": return 0x0E, true case "CS2": return 0x10, true case "AF21": return 0x12, true case "AF22": return 0x14, true case "AF23": return 0x16, true case "CS3": return 0x18, true case "AF31": return 0x1A, true case "AF32": return 0x1C, true case "AF33": return 0x1E, true case "CS4": return 0x20, true case "AF41": return 0x22, true case "AF42": return 0x24, true case "AF43": return 0x26, true case "CS5": return 0x28, true case "EF": return 0x2E, true case "CS6": return 0x30, true case "LE": return 0x01, true default: return 0, false } } rclone-v1.71.0/fs/config/configmap/000077500000000000000000000000001505210326400170665ustar00rootroot00000000000000rclone-v1.71.0/fs/config/configmap/configmap.go000066400000000000000000000110131505210326400213540ustar00rootroot00000000000000// Package configmap provides an abstraction for reading and writing config package configmap import ( "encoding/base64" "encoding/json" "fmt" "sort" "strings" "unicode" ) // Priority of getters type Priority int8 // Priority levels for AddGetter const ( PriorityNormal Priority = iota PriorityConfig // use for reading from the config PriorityDefault // use for default values PriorityMax ) // Getter provides an interface to get config items type Getter interface { // Get should get an item with the key passed in and return // the value. If the item is found then it should return true, // otherwise false. Get(key string) (value string, ok bool) } // Setter provides an interface to set config items type Setter interface { // Set should set an item into persistent config store. Set(key, value string) } // Mapper provides an interface to read and write config type Mapper interface { Getter Setter } // Map provides a wrapper around multiple Setter and // Getter interfaces. type Map struct { setters []Setter getters []getprio } type getprio struct { getter Getter priority Priority } // New returns an empty Map func New() *Map { return &Map{} } // AddGetter appends a getter onto the end of the getters in priority order func (c *Map) AddGetter(getter Getter, priority Priority) *Map { c.getters = append(c.getters, getprio{getter, priority}) sort.SliceStable(c.getters, func(i, j int) bool { return c.getters[i].priority < c.getters[j].priority }) return c } // AddSetter appends a setter onto the end of the setters func (c *Map) AddSetter(setter Setter) *Map { c.setters = append(c.setters, setter) return c } // ClearSetters removes all the setters set so far func (c *Map) ClearSetters() *Map { c.setters = nil return c } // ClearGetters removes all the getters with the priority given func (c *Map) ClearGetters(priority Priority) *Map { getters := c.getters[:0] for _, item := range c.getters { if item.priority != priority { getters = append(getters, item) } } c.getters = getters return c } // GetPriority gets an item with the key passed in and return the // value from the first getter to return a result with priority <= // maxPriority. If the item is found then it returns true, otherwise // false. func (c *Map) GetPriority(key string, maxPriority Priority) (value string, ok bool) { for _, item := range c.getters { if item.priority > maxPriority { break } value, ok = item.getter.Get(key) if ok { return value, ok } } return "", false } // Get gets an item with the key passed in and return the value from // the first getter. If the item is found then it returns true, // otherwise false. func (c *Map) Get(key string) (value string, ok bool) { return c.GetPriority(key, PriorityMax) } // Set sets an item into all the stored setters. func (c *Map) Set(key, value string) { for _, do := range c.setters { do.Set(key, value) } } // Simple is a simple Mapper for testing type Simple map[string]string // Get the value func (c Simple) Get(key string) (value string, ok bool) { value, ok = c[key] return value, ok } // Set the value func (c Simple) Set(key, value string) { c[key] = value } // String the map value the same way the config parser does, but with // sorted keys for reproducibility. func (c Simple) String() string { var ks = make([]string, 0, len(c)) for k := range c { ks = append(ks, k) } sort.Strings(ks) var out strings.Builder for _, k := range ks { if out.Len() > 0 { out.WriteRune(',') } out.WriteString(k) out.WriteRune('=') out.WriteRune('\'') for _, ch := range c[k] { out.WriteRune(ch) // Escape ' as '' if ch == '\'' { out.WriteRune(ch) } } out.WriteRune('\'') } return out.String() } // Encode from c into a string suitable for putting on the command line func (c Simple) Encode() (string, error) { if len(c) == 0 { return "", nil } buf, err := json.Marshal(c) if err != nil { return "", fmt.Errorf("encode simple map: %w", err) } return base64.RawStdEncoding.EncodeToString(buf), nil } // Decode an Encode~d string in into c func (c Simple) Decode(in string) error { // Remove all whitespace from the input string in = strings.Map(func(r rune) rune { if unicode.IsSpace(r) { return -1 } return r }, in) if len(in) == 0 { return nil } decodedM, err := base64.RawStdEncoding.DecodeString(in) if err != nil { return fmt.Errorf("decode simple map: %w", err) } err = json.Unmarshal(decodedM, &c) if err != nil { return fmt.Errorf("parse simple map: %w", err) } return nil } rclone-v1.71.0/fs/config/configmap/configmap_test.go000066400000000000000000000165471505210326400224340ustar00rootroot00000000000000package configmap import ( "encoding/base64" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var ( _ Mapper = Simple(nil) _ Getter = Simple(nil) _ Setter = Simple(nil) ) func TestConfigMapGet(t *testing.T) { m := New() value, found := m.Get("config1") assert.Equal(t, "", value) assert.Equal(t, false, found) value, found = m.Get("config2") assert.Equal(t, "", value) assert.Equal(t, false, found) m1 := Simple{ "config1": "one", } m.AddGetter(m1, PriorityNormal) value, found = m.Get("config1") assert.Equal(t, "one", value) assert.Equal(t, true, found) value, found = m.Get("config2") assert.Equal(t, "", value) assert.Equal(t, false, found) m2 := Simple{ "config1": "one2", "config2": "two2", } m.AddGetter(m2, PriorityNormal) value, found = m.Get("config1") assert.Equal(t, "one", value) assert.Equal(t, true, found) value, found = m.Get("config2") assert.Equal(t, "two2", value) assert.Equal(t, true, found) } func TestConfigMapSet(t *testing.T) { m := New() m1 := Simple{ "config1": "one", } m2 := Simple{ "config1": "one2", "config2": "two2", } m.AddSetter(m1).AddSetter(m2) m.Set("config2", "potato") assert.Equal(t, Simple{ "config1": "one", "config2": "potato", }, m1) assert.Equal(t, Simple{ "config1": "one2", "config2": "potato", }, m2) m.Set("config1", "beetroot") assert.Equal(t, Simple{ "config1": "beetroot", "config2": "potato", }, m1) assert.Equal(t, Simple{ "config1": "beetroot", "config2": "potato", }, m2) m.ClearSetters() // Check that nothing gets set m.Set("config1", "BEETROOT") assert.Equal(t, Simple{ "config1": "beetroot", "config2": "potato", }, m1) assert.Equal(t, Simple{ "config1": "beetroot", "config2": "potato", }, m2) } func TestConfigMapGetPriority(t *testing.T) { m := New() value, found := m.GetPriority("config1", PriorityMax) assert.Equal(t, "", value) assert.Equal(t, false, found) value, found = m.GetPriority("config2", PriorityMax) assert.Equal(t, "", value) assert.Equal(t, false, found) m1 := Simple{ "config1": "one", "config3": "three", } m.AddGetter(m1, PriorityConfig) value, found = m.GetPriority("config1", PriorityNormal) assert.Equal(t, "", value) assert.Equal(t, false, found) value, found = m.GetPriority("config2", PriorityNormal) assert.Equal(t, "", value) assert.Equal(t, false, found) value, found = m.GetPriority("config3", PriorityNormal) assert.Equal(t, "", value) assert.Equal(t, false, found) value, found = m.GetPriority("config1", PriorityConfig) assert.Equal(t, "one", value) assert.Equal(t, true, found) value, found = m.GetPriority("config2", PriorityConfig) assert.Equal(t, "", value) assert.Equal(t, false, found) value, found = m.GetPriority("config3", PriorityConfig) assert.Equal(t, "three", value) assert.Equal(t, true, found) value, found = m.GetPriority("config1", PriorityMax) assert.Equal(t, "one", value) assert.Equal(t, true, found) value, found = m.GetPriority("config2", PriorityMax) assert.Equal(t, "", value) assert.Equal(t, false, found) value, found = m.GetPriority("config3", PriorityMax) assert.Equal(t, "three", value) assert.Equal(t, true, found) m2 := Simple{ "config1": "one2", "config2": "two2", } m.AddGetter(m2, PriorityNormal) value, found = m.GetPriority("config1", PriorityNormal) assert.Equal(t, "one2", value) assert.Equal(t, true, found) value, found = m.GetPriority("config2", PriorityNormal) assert.Equal(t, "two2", value) assert.Equal(t, true, found) value, found = m.GetPriority("config3", PriorityNormal) assert.Equal(t, "", value) assert.Equal(t, false, found) value, found = m.GetPriority("config1", PriorityConfig) assert.Equal(t, "one2", value) assert.Equal(t, true, found) value, found = m.GetPriority("config2", PriorityConfig) assert.Equal(t, "two2", value) assert.Equal(t, true, found) value, found = m.GetPriority("config3", PriorityConfig) assert.Equal(t, "three", value) assert.Equal(t, true, found) value, found = m.GetPriority("config1", PriorityMax) assert.Equal(t, "one2", value) assert.Equal(t, true, found) value, found = m.GetPriority("config2", PriorityMax) assert.Equal(t, "two2", value) assert.Equal(t, true, found) value, found = m.GetPriority("config3", PriorityMax) assert.Equal(t, "three", value) assert.Equal(t, true, found) } func TestConfigMapClearGetters(t *testing.T) { m := New() m1 := Simple{} m2 := Simple{} m3 := Simple{} m.AddGetter(m1, PriorityNormal) m.AddGetter(m2, PriorityDefault) m.AddGetter(m3, PriorityConfig) assert.Equal(t, []getprio{ {m1, PriorityNormal}, {m3, PriorityConfig}, {m2, PriorityDefault}, }, m.getters) m.ClearGetters(PriorityConfig) assert.Equal(t, []getprio{ {m1, PriorityNormal}, {m2, PriorityDefault}, }, m.getters) m.ClearGetters(PriorityNormal) assert.Equal(t, []getprio{ {m2, PriorityDefault}, }, m.getters) m.ClearGetters(PriorityDefault) assert.Equal(t, []getprio{}, m.getters) m.ClearGetters(PriorityDefault) assert.Equal(t, []getprio{}, m.getters) } func TestConfigMapClearSetters(t *testing.T) { m := New() m1 := Simple{} m2 := Simple{} m3 := Simple{} m.AddSetter(m1) m.AddSetter(m2) m.AddSetter(m3) assert.Equal(t, []Setter{m1, m2, m3}, m.setters) m.ClearSetters() assert.Equal(t, []Setter(nil), m.setters) } func TestSimpleString(t *testing.T) { // Basic assert.Equal(t, "", Simple(nil).String()) assert.Equal(t, "", Simple{}.String()) assert.Equal(t, "config1='one'", Simple{ "config1": "one", }.String()) // Check ordering assert.Equal(t, "config1='one',config2='two',config3='three',config4='four',config5='five'", Simple{ "config5": "five", "config4": "four", "config3": "three", "config2": "two", "config1": "one", }.String()) // Check escaping assert.Equal(t, "apple='',config1='o''n''e'", Simple{ "config1": "o'n'e", "apple": "", }.String()) } func TestSimpleEncode(t *testing.T) { for _, test := range []struct { in Simple want string }{ { in: Simple{}, want: "", }, { in: Simple{ "one": "potato", }, want: "eyJvbmUiOiJwb3RhdG8ifQ", }, { in: Simple{ "one": "potato", "two": "", }, want: "eyJvbmUiOiJwb3RhdG8iLCJ0d28iOiIifQ", }, } { got, err := test.in.Encode() require.NoError(t, err) assert.Equal(t, test.want, got) gotM := Simple{} err = gotM.Decode(got) require.NoError(t, err) assert.Equal(t, test.in, gotM) } } func TestSimpleDecode(t *testing.T) { for _, test := range []struct { in string want Simple wantErr string }{ { in: "", want: Simple{}, }, { in: "eyJvbmUiOiJwb3RhdG8ifQ", want: Simple{ "one": "potato", }, }, { in: " e yJvbm UiOiJwb\r\n 3Rhd\tG8ifQ\n\n ", want: Simple{ "one": "potato", }, }, { in: "eyJvbmUiOiJwb3RhdG8iLCJ0d28iOiIifQ", want: Simple{ "one": "potato", "two": "", }, }, { in: "!!!!!", want: Simple{}, wantErr: "decode simple map", }, { in: base64.RawStdEncoding.EncodeToString([]byte(`null`)), want: Simple{}, }, { in: base64.RawStdEncoding.EncodeToString([]byte(`rubbish`)), want: Simple{}, wantErr: "parse simple map", }, } { got := Simple{} err := got.Decode(test.in) assert.Equal(t, test.want, got, test.in) if test.wantErr == "" { require.NoError(t, err, test.in) } else { assert.Contains(t, err.Error(), test.wantErr, test.in) } } } rclone-v1.71.0/fs/config/configstruct/000077500000000000000000000000001505210326400176355ustar00rootroot00000000000000rclone-v1.71.0/fs/config/configstruct/configstruct.go000066400000000000000000000224641505210326400227060ustar00rootroot00000000000000// Package configstruct parses unstructured maps into structures package configstruct import ( "encoding/csv" "errors" "fmt" "reflect" "regexp" "strconv" "strings" "time" "github.com/rclone/rclone/fs/config/configmap" ) var matchUpper = regexp.MustCompile("([A-Z]+)") // camelToSnake converts CamelCase to snake_case func camelToSnake(in string) string { out := matchUpper.ReplaceAllString(in, "_$1") out = strings.ToLower(out) out = strings.Trim(out, "_") return out } // StringToInterface turns in into an interface{} the same type as def // // This supports a subset of builtin types, string, integer types, // bool, time.Duration and []string. // // Builtin types are expected to be encoding as their natural // stringificatons as produced by fmt.Sprint except for []string which // is expected to be encoded a a CSV with empty array encoded as "". // // Any other types are expected to be encoded by their String() // methods and decoded by their `Set(s string) error` methods. func StringToInterface(def any, in string) (newValue any, err error) { typ := reflect.TypeOf(def) o := reflect.New(typ) switch def.(type) { case string: // return strings unmodified newValue = in case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr, float32, float64: // As per Rob Pike's advice in https://github.com/golang/go/issues/43306 // we only use Sscan for numbers var n int n, err = fmt.Sscanln(in, o.Interface()) if err == nil && n != 1 { err = errors.New("no items parsed") } newValue = o.Elem().Interface() case bool: newValue, err = strconv.ParseBool(in) case time.Duration: newValue, err = time.ParseDuration(in) case []string: // CSV decode arrays of strings - ideally we would use // fs.CommaSepList here but we can't as it would cause // a circular import. if len(in) == 0 { newValue = []string{} } else { r := csv.NewReader(strings.NewReader(in)) newValue, err = r.Read() switch _err := err.(type) { case *csv.ParseError: err = _err.Err // remove line numbers from the error message } } default: // Try using a Set method if do, ok := o.Interface().(interface{ Set(s string) error }); ok { err = do.Set(in) } else { err = errors.New("don't know how to parse this type") } newValue = o.Elem().Interface() } if err != nil { return nil, fmt.Errorf("parsing %q as %T failed: %w", in, def, err) } return newValue, nil } // InterfaceToString turns in into a string // // This supports a subset of builtin types, string, integer types, // bool, time.Duration and []string. // // Builtin types are expected to be encoding as their natural // stringificatons as produced by fmt.Sprint except for []string which // is expected to be encoded a a CSV with empty array encoded as "". // // Any other types are expected to be encoded by their String() // methods and decoded by their `Set(s string) error` methods. func InterfaceToString(in any) (strValue string, err error) { switch x := in.(type) { case string: // return strings unmodified strValue = x case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr, float32, float64: strValue = fmt.Sprint(in) case bool: strValue = fmt.Sprint(in) case time.Duration: strValue = fmt.Sprint(in) case []string: // CSV encode arrays of strings - ideally we would use // fs.CommaSepList here but we can't as it would cause // a circular import. if len(x) == 0 { strValue = "" } else if len(x) == 1 && len(x[0]) == 0 { strValue = `""` } else { var buf strings.Builder w := csv.NewWriter(&buf) err := w.Write(x) if err != nil { return "", err } w.Flush() strValue = strings.TrimSpace(buf.String()) } default: // Try using a String method if do, ok := in.(fmt.Stringer); ok { strValue = do.String() } else { err = errors.New("don't know how to convert this") } } if err != nil { return "", fmt.Errorf("interpreting %T as string failed: %w", in, err) } return strValue, nil } // Item describes a single entry in the options structure type Item struct { Name string // snake_case Field string // CamelCase Set func(any) // set this field Value any } // Items parses the opt struct and returns a slice of Item objects. // // opt must be a pointer to a struct. The struct should have entirely // public fields. // // The config_name is looked up in a struct tag called "config" or if // not found is the field name converted from CamelCase to snake_case. // // Nested structs are looked up too. If the parent struct has a struct // tag, this will be used as a prefix for the values in the sub // struct, otherwise they will be embedded as they are. func Items(opt any) (items []Item, err error) { def := reflect.ValueOf(opt) if def.Kind() != reflect.Ptr { return nil, errors.New("argument must be a pointer") } def = def.Elem() // indirect the pointer if def.Kind() != reflect.Struct { return nil, errors.New("argument must be a pointer to a struct") } defType := def.Type() for i := range def.NumField() { field := def.Field(i) fieldType := defType.Field(i) fieldName := fieldType.Name configName, hasTag := fieldType.Tag.Lookup("config") if hasTag && configName == "-" { // Skip items with config:"-" continue } if !hasTag { configName = camelToSnake(fieldName) } valuePtr := field.Addr().Interface() // pointer to the value as an interface _, canSet := valuePtr.(interface{ Set(string) error }) // can we set this with the Option Set protocol // If we have a nested struct that isn't a config item then recurse if fieldType.Type.Kind() == reflect.Struct && !canSet { newItems, err := Items(valuePtr) if err != nil { return nil, fmt.Errorf("error parsing field %q: %w", fieldName, err) } for _, newItem := range newItems { if hasTag { newItem.Name = configName + "_" + newItem.Name } newItem.Field = fieldName + "." + newItem.Field items = append(items, newItem) } } else { defaultItem := Item{ Name: configName, Field: fieldName, Set: func(newValue any) { field.Set(reflect.ValueOf(newValue)) }, Value: field.Interface(), } items = append(items, defaultItem) } } return items, nil } // setValue sets newValue to configValue returning an updated newValue func setValue(newValue any, configValue string) (any, error) { newNewValue, err := StringToInterface(newValue, configValue) if err != nil { // Mask errors if setting an empty string as // it isn't valid for all types. This makes // empty string be the equivalent of unset. if configValue != "" { return nil, err } } else { newValue = newNewValue } return newValue, nil } // Set interprets the field names in defaults and looks up config // values in the config passed in. Any values found in config will be // set in the opt structure. // // opt must be a pointer to a struct. The struct should have entirely // public fields. The field names are converted from CamelCase to // snake_case and looked up in the config supplied or a // `config:"field_name"` is looked up. // // If items are found then they are converted from string to native // types and set in opt. // // All the field types in the struct must implement fmt.Scanner. func Set(config configmap.Getter, opt any) (err error) { defaultItems, err := Items(opt) if err != nil { return err } for _, defaultItem := range defaultItems { newValue := defaultItem.Value if configValue, ok := config.Get(defaultItem.Name); ok { newValue, err = setValue(newValue, configValue) if err != nil { return fmt.Errorf("couldn't parse config item %q = %q as %T: %w", defaultItem.Name, configValue, defaultItem.Value, err) } } defaultItem.Set(newValue) } return nil } // setIfSameType set aPtr with b if they are the same type or returns false. func setIfSameType(aPtr interface{}, b interface{}) bool { aVal := reflect.ValueOf(aPtr).Elem() bVal := reflect.ValueOf(b) if aVal.Type() != bVal.Type() { return false } aVal.Set(bVal) return true } // SetAny interprets the field names in defaults and looks up config // values in the config passed in. Any values found in config will be // set in the opt structure. // // opt must be a pointer to a struct. The struct should have entirely // public fields. The field names are converted from CamelCase to // snake_case and looked up in the config supplied or a // `config:"field_name"` is looked up. // // If items are found then they are set directly if the correct type, // otherwise they are converted to string and then converted from // string to native types and set in opt. // // All the field types in the struct must implement fmt.Scanner. func SetAny(config map[string]any, opt any) (err error) { defaultItems, err := Items(opt) if err != nil { return err } for _, defaultItem := range defaultItems { newValue := defaultItem.Value if configValue, ok := config[defaultItem.Name]; ok { if !setIfSameType(&newValue, configValue) { // Convert the config value to be a string stringConfigValue, err := InterfaceToString(configValue) if err != nil { return err } newValue, err = setValue(newValue, stringConfigValue) if err != nil { return fmt.Errorf("couldn't parse config item %q = %q as %T: %w", defaultItem.Name, stringConfigValue, defaultItem.Value, err) } } } defaultItem.Set(newValue) } return nil } rclone-v1.71.0/fs/config/configstruct/configstruct_test.go000066400000000000000000000224031505210326400237360ustar00rootroot00000000000000package configstruct_test import ( "fmt" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configstruct" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) type Conf struct { A string B string } type Conf2 struct { PotatoPie string `config:"spud_pie"` BeanStew bool RaisinRoll int SausageOnStick int64 ForbiddenFruit uint CookingTime fs.Duration TotalWeight fs.SizeSuffix } type ConfNested struct { Conf // embedded struct with no tag Sub1 Conf `config:"sub"` // member struct with tag Sub2 Conf2 // member struct without tag C string // normal item D fs.Tristate // an embedded struct which we don't want to recurse } func TestItemsError(t *testing.T) { _, err := configstruct.Items(nil) assert.EqualError(t, err, "argument must be a pointer") _, err = configstruct.Items(new(int)) assert.EqualError(t, err, "argument must be a pointer to a struct") } // Check each item has a Set function pointer then clear it for the assert.Equal func cleanItems(t *testing.T, items []configstruct.Item) []configstruct.Item { for i := range items { item := &items[i] assert.NotNil(t, item.Set) item.Set = nil } return items } func TestItems(t *testing.T) { in := &Conf2{ PotatoPie: "yum", BeanStew: true, RaisinRoll: 42, SausageOnStick: 101, ForbiddenFruit: 6, CookingTime: fs.Duration(42 * time.Second), TotalWeight: fs.SizeSuffix(17 << 20), } got, err := configstruct.Items(in) require.NoError(t, err) want := []configstruct.Item{ {Name: "spud_pie", Field: "PotatoPie", Value: string("yum")}, {Name: "bean_stew", Field: "BeanStew", Value: true}, {Name: "raisin_roll", Field: "RaisinRoll", Value: int(42)}, {Name: "sausage_on_stick", Field: "SausageOnStick", Value: int64(101)}, {Name: "forbidden_fruit", Field: "ForbiddenFruit", Value: uint(6)}, {Name: "cooking_time", Field: "CookingTime", Value: fs.Duration(42 * time.Second)}, {Name: "total_weight", Field: "TotalWeight", Value: fs.SizeSuffix(17 << 20)}, } assert.Equal(t, want, cleanItems(t, got)) } func TestItemsNested(t *testing.T) { in := ConfNested{ Conf: Conf{ A: "1", B: "2", }, Sub1: Conf{ A: "3", B: "4", }, Sub2: Conf2{ PotatoPie: "yum", BeanStew: true, RaisinRoll: 42, SausageOnStick: 101, ForbiddenFruit: 6, CookingTime: fs.Duration(42 * time.Second), TotalWeight: fs.SizeSuffix(17 << 20), }, C: "normal", D: fs.Tristate{Value: true, Valid: true}, } got, err := configstruct.Items(&in) require.NoError(t, err) want := []configstruct.Item{ {Name: "a", Field: "Conf.A", Value: string("1")}, {Name: "b", Field: "Conf.B", Value: string("2")}, {Name: "sub_a", Field: "Sub1.A", Value: string("3")}, {Name: "sub_b", Field: "Sub1.B", Value: string("4")}, {Name: "spud_pie", Field: "Sub2.PotatoPie", Value: string("yum")}, {Name: "bean_stew", Field: "Sub2.BeanStew", Value: true}, {Name: "raisin_roll", Field: "Sub2.RaisinRoll", Value: int(42)}, {Name: "sausage_on_stick", Field: "Sub2.SausageOnStick", Value: int64(101)}, {Name: "forbidden_fruit", Field: "Sub2.ForbiddenFruit", Value: uint(6)}, {Name: "cooking_time", Field: "Sub2.CookingTime", Value: fs.Duration(42 * time.Second)}, {Name: "total_weight", Field: "Sub2.TotalWeight", Value: fs.SizeSuffix(17 << 20)}, {Name: "c", Field: "C", Value: string("normal")}, {Name: "d", Field: "D", Value: fs.Tristate{Value: true, Valid: true}}, } assert.Equal(t, want, cleanItems(t, got)) } func TestSetBasics(t *testing.T) { c := &Conf{A: "one", B: "two"} err := configstruct.Set(configMap{}, c) require.NoError(t, err) assert.Equal(t, &Conf{A: "one", B: "two"}, c) } // a simple configmap.Getter for testing type configMap map[string]string // Get the value func (c configMap) Get(key string) (value string, ok bool) { value, ok = c[key] return value, ok } func TestSetMore(t *testing.T) { c := &Conf{A: "one", B: "two"} m := configMap{ "a": "ONE", } err := configstruct.Set(m, c) require.NoError(t, err) assert.Equal(t, &Conf{A: "ONE", B: "two"}, c) } func TestSetFull(t *testing.T) { in := &Conf2{ PotatoPie: "yum", BeanStew: true, RaisinRoll: 42, SausageOnStick: 101, ForbiddenFruit: 6, CookingTime: fs.Duration(42 * time.Second), TotalWeight: fs.SizeSuffix(17 << 20), } m := configMap{ "spud_pie": "YUM", "bean_stew": "FALSE", "raisin_roll": "43 ", "sausage_on_stick": " 102 ", "forbidden_fruit": "0x7", "cooking_time": "43s", "total_weight": "18M", } want := &Conf2{ PotatoPie: "YUM", BeanStew: false, RaisinRoll: 43, SausageOnStick: 102, ForbiddenFruit: 7, CookingTime: fs.Duration(43 * time.Second), TotalWeight: fs.SizeSuffix(18 << 20), } err := configstruct.Set(m, in) require.NoError(t, err) assert.Equal(t, want, in) } func TestSetAnyFull(t *testing.T) { in := &Conf2{ PotatoPie: "yum", BeanStew: true, RaisinRoll: 42, SausageOnStick: 101, ForbiddenFruit: 6, CookingTime: fs.Duration(42 * time.Second), TotalWeight: fs.SizeSuffix(17 << 20), } m := map[string]any{ "spud_pie": "YUM", "bean_stew": false, "raisin_roll": "43 ", "sausage_on_stick": " 102 ", "forbidden_fruit": "0x7", "cooking_time": 43 * time.Second, "total_weight": "18M", } want := &Conf2{ PotatoPie: "YUM", BeanStew: false, RaisinRoll: 43, SausageOnStick: 102, ForbiddenFruit: 7, CookingTime: fs.Duration(43 * time.Second), TotalWeight: fs.SizeSuffix(18 << 20), } err := configstruct.SetAny(m, in) require.NoError(t, err) assert.Equal(t, want, in) } func TestStringToInterface(t *testing.T) { item := struct{ A int }{2} for _, test := range []struct { in string def any want any err string }{ {"", string(""), "", ""}, {" string ", string(""), " string ", ""}, {"123", int(0), int(123), ""}, {"0x123", int(0), int(0x123), ""}, {" 0x123 ", int(0), int(0x123), ""}, {"-123", int(0), int(-123), ""}, {"0", false, false, ""}, {"1", false, true, ""}, {"7", false, true, `parsing "7" as bool failed: strconv.ParseBool: parsing "7": invalid syntax`}, {"FALSE", false, false, ""}, {"true", false, true, ""}, {"123", uint(0), uint(123), ""}, {"123", int64(0), int64(123), ""}, {"123x", int64(0), nil, "parsing \"123x\" as int64 failed: expected newline"}, {"truth", false, nil, "parsing \"truth\" as bool failed: strconv.ParseBool: parsing \"truth\": invalid syntax"}, {"struct", item, nil, "parsing \"struct\" as struct { A int } failed: don't know how to parse this type"}, {"1s", fs.Duration(0), fs.Duration(time.Second), ""}, {"1m1s", fs.Duration(0), fs.Duration(61 * time.Second), ""}, {"1potato", fs.Duration(0), nil, `parsing "1potato" as fs.Duration failed: parsing time "1potato" as "2006-01-02": cannot parse "1potato" as "2006"`}, {``, []string{}, []string{}, ""}, {`""`, []string(nil), []string{""}, ""}, {`hello`, []string{}, []string{"hello"}, ""}, {`"hello"`, []string{}, []string{"hello"}, ""}, {`hello,world!`, []string(nil), []string{"hello", "world!"}, ""}, {`"hello","world!"`, []string(nil), []string{"hello", "world!"}, ""}, {"1s", time.Duration(0), time.Second, ""}, {"1m1s", time.Duration(0), 61 * time.Second, ""}, {"1potato", time.Duration(0), nil, `parsing "1potato" as time.Duration failed: time: unknown unit "potato" in duration "1potato"`}, {"1M", fs.SizeSuffix(0), fs.Mebi, ""}, {"1G", fs.SizeSuffix(0), fs.Gibi, ""}, {"1potato", fs.SizeSuffix(0), nil, `parsing "1potato" as fs.SizeSuffix failed: bad suffix 'o'`}, } { what := fmt.Sprintf("parse %q as %T", test.in, test.def) got, err := configstruct.StringToInterface(test.def, test.in) if test.err == "" { require.NoError(t, err, what) assert.Equal(t, test.want, got, what) } else { assert.Nil(t, got, what) assert.EqualError(t, err, test.err, what) } } } func TestInterfaceToString(t *testing.T) { item := struct{ A int }{2} for _, test := range []struct { in any want string err string }{ {nil, "", "interpreting as string failed: don't know how to convert this"}, {"", "", ""}, {" string ", " string ", ""}, {int(123), "123", ""}, {int(0x123), "291", ""}, {int(-123), "-123", ""}, {false, "false", ""}, {true, "true", ""}, {uint(123), "123", ""}, {int64(123), "123", ""}, {item, "", "interpreting struct { A int } as string failed: don't know how to convert this"}, {fs.Duration(time.Second), "1s", ""}, {fs.Duration(61 * time.Second), "1m1s", ""}, {[]string{}, ``, ""}, {[]string{""}, `""`, ""}, {[]string{"", ""}, `,`, ""}, {[]string{"hello"}, `hello`, ""}, {[]string{"hello", "world"}, `hello,world`, ""}, {[]string{"hello", "", "world"}, `hello,,world`, ""}, {[]string{`hello, world`, `goodbye, world!`}, `"hello, world","goodbye, world!"`, ""}, {time.Second, "1s", ""}, {61 * time.Second, "1m1s", ""}, {fs.Mebi, "1Mi", ""}, {fs.Gibi, "1Gi", ""}, } { what := fmt.Sprintf("interpret %#v as string", test.in) got, err := configstruct.InterfaceToString(test.in) if test.err == "" { require.NoError(t, err, what) assert.Equal(t, test.want, got, what) } else { assert.Equal(t, "", got) assert.EqualError(t, err, test.err, what) } } } rclone-v1.71.0/fs/config/configstruct/internal_test.go000066400000000000000000000005661505210326400230460ustar00rootroot00000000000000package configstruct import ( "testing" "github.com/stretchr/testify/assert" ) func TestCamelToSnake(t *testing.T) { for _, test := range []struct { in string want string }{ {"", ""}, {"Type", "type"}, {"AuthVersion", "auth_version"}, {"AccessKeyID", "access_key_id"}, } { got := camelToSnake(test.in) assert.Equal(t, test.want, got, test.in) } } rclone-v1.71.0/fs/config/crypt.go000066400000000000000000000242731505210326400166230ustar00rootroot00000000000000package config import ( "bufio" "bytes" "context" "crypto/rand" "crypto/sha256" "encoding/base64" "errors" "fmt" "io" "os" "os/exec" "strings" "golang.org/x/crypto/nacl/secretbox" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/obscure" ) var ( // Key to use for password en/decryption. // When nil, no encryption will be used for saving. configKey []byte // PasswordPromptOutput is output of prompt for password PasswordPromptOutput = os.Stderr // PassConfigKeyForDaemonization if set to true, the configKey // is obscured with obscure.Obscure and saved to a temp file // when it is calculated from the password. The path of that // temp file is then written to the environment variable // `_RCLONE_CONFIG_KEY_FILE`. If `_RCLONE_CONFIG_KEY_FILE` is // present, password prompt is skipped and // `RCLONE_CONFIG_PASS` ignored. For security reasons, the // temp file is deleted once the configKey is successfully // loaded. This can be used to pass the configKey to a child // process. PassConfigKeyForDaemonization = false ) // IsEncrypted returns true if the config file is encrypted func IsEncrypted() bool { return len(configKey) > 0 } // Decrypt will automatically decrypt a reader func Decrypt(b io.ReadSeeker) (io.Reader, error) { ctx := context.Background() ci := fs.GetConfig(ctx) var usingPasswordCommand bool var usingEnvPassword bool // Find first non-empty line r := bufio.NewReader(b) for { line, _, err := r.ReadLine() if err != nil { if err == io.EOF { if _, err := b.Seek(0, io.SeekStart); err != nil { return nil, err } return b, nil } return nil, err } l := strings.TrimSpace(string(line)) if len(l) == 0 || strings.HasPrefix(l, ";") || strings.HasPrefix(l, "#") { continue } // First non-empty or non-comment must be ENCRYPT_V0 if l == "RCLONE_ENCRYPT_V0:" { break } if strings.HasPrefix(l, "RCLONE_ENCRYPT_V") { return nil, errors.New("unsupported configuration encryption - update rclone for support") } if _, err := b.Seek(0, io.SeekStart); err != nil { return nil, err } return b, nil } if len(configKey) == 0 { pass, err := GetPasswordCommand(ctx) if err != nil { return nil, err } if pass != "" { usingPasswordCommand = true err = SetConfigPassword(pass) if err != nil { return nil, fmt.Errorf("incorrect password: %w", err) } if len(configKey) == 0 { return nil, errors.New("unable to decrypt configuration: incorrect password") } } else { usingPasswordCommand = false envPassword := os.Getenv("RCLONE_CONFIG_PASS") if envPassword != "" { usingEnvPassword = true err := SetConfigPassword(envPassword) if err != nil { fs.Errorf(nil, "Using RCLONE_CONFIG_PASS returned: %v", err) } else { fs.Debugf(nil, "Using RCLONE_CONFIG_PASS password.") } } else { usingEnvPassword = false } } } // Encrypted content is base64 encoded. dec := base64.NewDecoder(base64.StdEncoding, r) box, err := io.ReadAll(dec) if err != nil { return nil, fmt.Errorf("failed to load base64 encoded data: %w", err) } if len(box) < 24+secretbox.Overhead { return nil, errors.New("configuration data too short") } var out []byte for { if envKeyFile := os.Getenv("_RCLONE_CONFIG_KEY_FILE"); len(envKeyFile) > 0 { fs.Debugf(nil, "attempting to obtain configKey from temp file %s", envKeyFile) obscuredKey, err := os.ReadFile(envKeyFile) if err != nil { errRemove := os.Remove(envKeyFile) if errRemove != nil { return nil, fmt.Errorf("unable to read obscured config key and unable to delete the temp file: %w", err) } return nil, fmt.Errorf("unable to read obscured config key: %w", err) } errRemove := os.Remove(envKeyFile) if errRemove != nil { return nil, fmt.Errorf("unable to delete temp file with configKey: %w", errRemove) } configKey = []byte(obscure.MustReveal(string(obscuredKey))) fs.Debugf(nil, "using _RCLONE_CONFIG_KEY_FILE for configKey") } else if len(configKey) == 0 { if usingPasswordCommand { return nil, errors.New("using --password-command derived password, unable to decrypt configuration") } if usingEnvPassword { return nil, errors.New("using RCLONE_CONFIG_PASS env password, unable to decrypt configuration") } if !ci.AskPassword { return nil, errors.New("unable to decrypt configuration and not allowed to ask for password - set RCLONE_CONFIG_PASS to your configuration password") } getConfigPassword("Enter configuration password:") } // Nonce is first 24 bytes of the ciphertext var nonce [24]byte copy(nonce[:], box[:24]) var key [32]byte copy(key[:], configKey[:32]) // Attempt to decrypt var ok bool out, ok = secretbox.Open(nil, box[24:], &nonce, &key) if ok { break } // Retry fs.Errorf(nil, "Couldn't decrypt configuration, most likely wrong password.") configKey = nil } return bytes.NewReader(out), nil } // GetPasswordCommand gets the password using the --password-command setting // // If the the --password-command flag was not in use it returns "", nil func GetPasswordCommand(ctx context.Context) (pass string, err error) { ci := fs.GetConfig(ctx) if len(ci.PasswordCommand) == 0 { return "", nil } var stdout bytes.Buffer var stderr bytes.Buffer cmd := exec.Command(ci.PasswordCommand[0], ci.PasswordCommand[1:]...) cmd.Stdout = &stdout cmd.Stderr = &stderr cmd.Stdin = os.Stdin err = cmd.Run() if err != nil { // One does not always get the stderr returned in the wrapped error. fs.Errorf(nil, "Using --password-command returned: %v", err) if ers := strings.TrimSpace(stderr.String()); ers != "" { fs.Errorf(nil, "--password-command stderr: %s", ers) } return pass, fmt.Errorf("password command failed: %w", err) } pass = strings.Trim(stdout.String(), "\r\n") if pass == "" { return pass, errors.New("--password-command returned empty string") } return pass, nil } // Encrypt the config file func Encrypt(src io.Reader, dst io.Writer) error { if len(configKey) == 0 { _, err := io.Copy(dst, src) return err } _, _ = fmt.Fprintln(dst, "# Encrypted rclone configuration File") _, _ = fmt.Fprintln(dst, "") _, _ = fmt.Fprintln(dst, "RCLONE_ENCRYPT_V0:") // Generate new nonce and write it to the start of the ciphertext var nonce [24]byte n, _ := rand.Read(nonce[:]) if n != 24 { return fmt.Errorf("nonce short read: %d", n) } enc := base64.NewEncoder(base64.StdEncoding, dst) _, err := enc.Write(nonce[:]) if err != nil { return fmt.Errorf("failed to write config file: %w", err) } var key [32]byte copy(key[:], configKey[:32]) data, err := io.ReadAll(src) if err != nil { return err } b := secretbox.Seal(nil, data, &nonce, &key) _, err = enc.Write(b) if err != nil { return fmt.Errorf("failed to write config file: %w", err) } return enc.Close() } // getConfigPassword will query the user for a password the // first time it is required. func getConfigPassword(q string) { if len(configKey) != 0 { return } for { password := GetPassword(q) err := SetConfigPassword(password) if err == nil { return } _, _ = fmt.Fprintln(os.Stderr, "Error:", err) } } // SetConfigPassword will set the configKey to the hash of // the password. If the length of the password is // zero after trimming+normalization, an error is returned. func SetConfigPassword(password string) error { password, err := checkPassword(password) if err != nil { return err } // Create SHA256 has of the password sha := sha256.New() _, err = sha.Write([]byte("[" + password + "][rclone-config]")) if err != nil { return err } configKey = sha.Sum(nil) if PassConfigKeyForDaemonization { tempFile, err := os.CreateTemp("", "rclone") if err != nil { return fmt.Errorf("cannot create temp file to store configKey: %w", err) } _, err = tempFile.WriteString(obscure.MustObscure(string(configKey))) if err != nil { errRemove := os.Remove(tempFile.Name()) if errRemove != nil { return fmt.Errorf("error writing configKey to temp file and also error deleting it: %w", err) } return fmt.Errorf("error writing configKey to temp file: %w", err) } err = tempFile.Close() if err != nil { errRemove := os.Remove(tempFile.Name()) if errRemove != nil { return fmt.Errorf("error closing temp file with configKey and also error deleting it: %w", err) } return fmt.Errorf("error closing temp file with configKey: %w", err) } fs.Debugf(nil, "saving configKey to temp file") err = os.Setenv("_RCLONE_CONFIG_KEY_FILE", tempFile.Name()) if err != nil { errRemove := os.Remove(tempFile.Name()) if errRemove != nil { return fmt.Errorf("unable to set environment variable _RCLONE_CONFIG_KEY_FILE and unable to delete the temp file: %w", err) } return fmt.Errorf("unable to set environment variable _RCLONE_CONFIG_KEY_FILE: %w", err) } } return nil } // ClearConfigPassword sets the current the password to empty func ClearConfigPassword() { configKey = nil } // changeConfigPassword will query the user twice // for a password. If the same password is entered // twice the key is updated. // // This will use --password-command if configured to read the password. func changeConfigPassword() { // Set RCLONE_PASSWORD_CHANGE to "1" when calling the --password-command tool _ = os.Setenv("RCLONE_PASSWORD_CHANGE", "1") defer func() { _ = os.Unsetenv("RCLONE_PASSWORD_CHANGE") }() pass, err := GetPasswordCommand(context.Background()) if err != nil { fmt.Printf("Failed to read new password with --password-command: %v\n", err) return } if pass == "" { pass = ChangePassword("NEW configuration") } else { fmt.Printf("Read password using --password-command\n") } err = SetConfigPassword(pass) if err != nil { fmt.Printf("Failed to set config password: %v\n", err) return } } // ChangeConfigPasswordAndSave will query the user twice // for a password. If the same password is entered // twice the key is updated. // // This will use --password-command if configured to read the password. // // It will then save the config func ChangeConfigPasswordAndSave() { changeConfigPassword() SaveConfig() } // RemoveConfigPasswordAndSave will clear the config password and save // the unencrypted config file. func RemoveConfigPasswordAndSave() { configKey = nil SaveConfig() } rclone-v1.71.0/fs/config/crypt_internal_test.go000066400000000000000000000044311505210326400215500ustar00rootroot00000000000000package config import ( "context" "os" "path/filepath" "testing" "github.com/rclone/rclone/fs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func hashedKeyCompare(t *testing.T, a, b string, shouldMatch bool) { err := SetConfigPassword(a) require.NoError(t, err) k1 := configKey err = SetConfigPassword(b) require.NoError(t, err) k2 := configKey if shouldMatch { assert.Equal(t, k1, k2) } else { assert.NotEqual(t, k1, k2) } } func TestPassword(t *testing.T) { defer func() { configKey = nil // reset password }() var err error // Empty password should give error err = SetConfigPassword(" \t ") require.Error(t, err) // Test invalid utf8 sequence err = SetConfigPassword(string([]byte{0xff, 0xfe, 0xfd}) + "abc") require.Error(t, err) // Simple check of wrong passwords hashedKeyCompare(t, "mis", "match", false) // Check that passwords match after unicode normalization hashedKeyCompare(t, "ff\u0041\u030A", "ffÅ", true) // Check that passwords preserves case hashedKeyCompare(t, "abcdef", "ABCDEF", false) } func TestChangeConfigPassword(t *testing.T) { ci := fs.GetConfig(context.Background()) var err error oldConfigPath := GetConfigPath() assert.NoError(t, SetConfigPath("./testdata/encrypted.conf")) defer func() { assert.NoError(t, SetConfigPath(oldConfigPath)) ClearConfigPassword() ci.PasswordCommand = nil }() // Get rid of any config password ClearConfigPassword() // Return the password, checking the state of the environment variable checkCode := ` package main import ( "fmt" "os" "log" ) func main() { v := os.Getenv("RCLONE_PASSWORD_CHANGE") if v == "" { log.Fatal("Env var not found") } else if v != "1" { log.Fatal("Env var wrong value") } else { fmt.Println("asdf") } } ` dir := t.TempDir() code := filepath.Join(dir, "file.go") require.NoError(t, os.WriteFile(code, []byte(checkCode), 0777)) // Set correct password using --password-command ci.PasswordCommand = fs.SpaceSepList{"go", "run", code} changeConfigPassword() err = Data().Load() require.NoError(t, err) sections := Data().GetSectionList() var expect = []string{"nounc", "unc"} assert.Equal(t, expect, sections) keys := Data().GetKeyList("nounc") expect = []string{"type", "nounc"} assert.Equal(t, expect, keys) } rclone-v1.71.0/fs/config/crypt_test.go000066400000000000000000000114311505210326400176520ustar00rootroot00000000000000// These are in an external package because we need to import configfile // // Internal tests are in crypt_internal_test.go package config_test import ( "context" "os" "path/filepath" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestConfigLoadEncrypted(t *testing.T) { var err error oldConfigPath := config.GetConfigPath() assert.NoError(t, config.SetConfigPath("./testdata/encrypted.conf")) defer func() { assert.NoError(t, config.SetConfigPath(oldConfigPath)) config.ClearConfigPassword() }() // Set correct password assert.False(t, config.IsEncrypted()) err = config.SetConfigPassword("asdf") require.NoError(t, err) assert.True(t, config.IsEncrypted()) err = config.Data().Load() require.NoError(t, err) sections := config.Data().GetSectionList() var expect = []string{"nounc", "unc"} assert.Equal(t, expect, sections) keys := config.Data().GetKeyList("nounc") expect = []string{"type", "nounc"} assert.Equal(t, expect, keys) } func TestConfigLoadEncryptedWithValidPassCommand(t *testing.T) { ctx := context.Background() ci := fs.GetConfig(ctx) oldConfigPath := config.GetConfigPath() oldConfig := *ci assert.NoError(t, config.SetConfigPath("./testdata/encrypted.conf")) // using ci.PasswordCommand, correct password ci.PasswordCommand = fs.SpaceSepList{"echo", "asdf"} defer func() { assert.NoError(t, config.SetConfigPath(oldConfigPath)) config.ClearConfigPassword() *ci = oldConfig ci.PasswordCommand = nil }() config.ClearConfigPassword() err := config.Data().Load() require.NoError(t, err) sections := config.Data().GetSectionList() var expect = []string{"nounc", "unc"} assert.Equal(t, expect, sections) keys := config.Data().GetKeyList("nounc") expect = []string{"type", "nounc"} assert.Equal(t, expect, keys) } func TestConfigLoadEncryptedWithInvalidPassCommand(t *testing.T) { ctx := context.Background() ci := fs.GetConfig(ctx) oldConfigPath := config.GetConfigPath() oldConfig := *ci assert.NoError(t, config.SetConfigPath("./testdata/encrypted.conf")) // using ci.PasswordCommand, incorrect password ci.PasswordCommand = fs.SpaceSepList{"echo", "asdf-blurfl"} defer func() { assert.NoError(t, config.SetConfigPath(oldConfigPath)) config.ClearConfigPassword() *ci = oldConfig ci.PasswordCommand = nil }() config.ClearConfigPassword() err := config.Data().Load() require.Error(t, err) assert.Contains(t, err.Error(), "using --password-command derived password") } func TestConfigLoadEncryptedFailures(t *testing.T) { var err error // This file should be too short to be decoded. oldConfigPath := config.GetConfigPath() assert.NoError(t, config.SetConfigPath("./testdata/enc-short.conf")) defer func() { assert.NoError(t, config.SetConfigPath(oldConfigPath)) }() err = config.Data().Load() require.Error(t, err) // This file contains invalid base64 characters. assert.NoError(t, config.SetConfigPath("./testdata/enc-invalid.conf")) err = config.Data().Load() require.Error(t, err) // This file contains invalid base64 characters. assert.NoError(t, config.SetConfigPath("./testdata/enc-too-new.conf")) err = config.Data().Load() require.Error(t, err) // This file does not exist. assert.NoError(t, config.SetConfigPath("./testdata/filenotfound.conf")) err = config.Data().Load() assert.Equal(t, config.ErrorConfigFileNotFound, err) } func TestGetPasswordCommand(t *testing.T) { ctx, ci := fs.AddConfig(context.Background()) // Not configured ci.PasswordCommand = fs.SpaceSepList{} pass, err := config.GetPasswordCommand(ctx) require.NoError(t, err) assert.Equal(t, "", pass) // With password - happy path ci.PasswordCommand = fs.SpaceSepList{"echo", "asdf"} pass, err = config.GetPasswordCommand(ctx) require.NoError(t, err) assert.Equal(t, "asdf", pass) // Empty password returned ci.PasswordCommand = fs.SpaceSepList{"echo", ""} _, err = config.GetPasswordCommand(ctx) assert.ErrorContains(t, err, "returned empty string") // Error when running command ci.PasswordCommand = fs.SpaceSepList{"XXX non-existent command XXX", ""} _, err = config.GetPasswordCommand(ctx) assert.ErrorContains(t, err, "not found") // Check the state of the environment variable in --password-command checkCode := ` package main import ( "fmt" "os" ) func main() { if _, found := os.LookupEnv("RCLONE_PASSWORD_CHANGE"); found { fmt.Println("Env var set") } else { fmt.Println("OK") } } ` dir := t.TempDir() code := filepath.Join(dir, "file.go") require.NoError(t, os.WriteFile(code, []byte(checkCode), 0777)) // Check the environment variable unset when called directly ci.PasswordCommand = fs.SpaceSepList{"go", "run", code} pass, err = config.GetPasswordCommand(ctx) require.NoError(t, err) assert.Equal(t, "OK", pass) } rclone-v1.71.0/fs/config/default_storage.go000066400000000000000000000051411505210326400206230ustar00rootroot00000000000000package config import ( "encoding/json" "sync" ) // defaultStorage implements config.Storage, providing in-memory config. // Indexed by section, then key. type defaultStorage struct { mu sync.RWMutex sections map[string]map[string]string } func newDefaultStorage() *defaultStorage { return &defaultStorage{ sections: map[string]map[string]string{}, } } // GetSectionList returns a slice of strings with names for all the sections. func (s *defaultStorage) GetSectionList() []string { s.mu.RLock() defer s.mu.RUnlock() sections := make([]string, 0, len(s.sections)) for section := range s.sections { sections = append(sections, section) } return sections } // HasSection returns true if section exists in the config. func (s *defaultStorage) HasSection(section string) bool { s.mu.RLock() defer s.mu.RUnlock() _, hasSection := s.sections[section] return hasSection } // DeleteSection deletes the specified section. func (s *defaultStorage) DeleteSection(section string) { s.mu.Lock() defer s.mu.Unlock() delete(s.sections, section) } // GetKeyList returns the keys in this section. func (s *defaultStorage) GetKeyList(section string) []string { s.mu.RLock() defer s.mu.RUnlock() theSection := s.sections[section] keys := make([]string, 0, len(theSection)) for key := range theSection { keys = append(keys, key) } return keys } // GetValue returns the key in section with a found flag. func (s *defaultStorage) GetValue(section string, key string) (value string, found bool) { s.mu.RLock() defer s.mu.RUnlock() theSection, hasSection := s.sections[section] if !hasSection { return "", false } value, hasValue := theSection[key] return value, hasValue } func (s *defaultStorage) SetValue(section string, key string, value string) { s.mu.Lock() defer s.mu.Unlock() theSection, hasSection := s.sections[section] if !hasSection { theSection = map[string]string{} s.sections[section] = theSection } theSection[key] = value } func (s *defaultStorage) DeleteKey(section string, key string) bool { s.mu.Lock() defer s.mu.Unlock() theSection, hasSection := s.sections[section] if !hasSection { return false } _, hasKey := theSection[key] if !hasKey { return false } delete(s.sections[section], key) return true } func (s *defaultStorage) Load() error { return nil } func (s *defaultStorage) Save() error { return nil } // Serialize the config into a string func (s *defaultStorage) Serialize() (string, error) { s.mu.RLock() defer s.mu.RUnlock() j, err := json.Marshal(s.sections) return string(j), err } // Check the interface is satisfied var _ Storage = newDefaultStorage() rclone-v1.71.0/fs/config/default_storage_test.go000066400000000000000000000015121505210326400216600ustar00rootroot00000000000000package config import ( "testing" "github.com/stretchr/testify/assert" ) func TestDefaultStorage(t *testing.T) { a := assert.New(t) ds := newDefaultStorage() section := "test" key := "key" val := "something" ds.SetValue(section, key, val) ds.SetValue("some other section", key, val) v, hasVal := ds.GetValue(section, key) a.True(hasVal) a.Equal(val, v) a.ElementsMatch([]string{section, "some other section"}, ds.GetSectionList()) a.True(ds.HasSection(section)) a.False(ds.HasSection("nope")) a.Equal([]string{key}, ds.GetKeyList(section)) _, err := ds.Serialize() a.NoError(err) a.True(ds.DeleteKey(section, key)) a.False(ds.DeleteKey(section, key)) a.False(ds.DeleteKey("not there", key)) _, hasVal = ds.GetValue(section, key) a.False(hasVal) ds.DeleteSection(section) a.False(ds.HasSection(section)) } rclone-v1.71.0/fs/config/flags/000077500000000000000000000000001505210326400162175ustar00rootroot00000000000000rclone-v1.71.0/fs/config/flags/flags.go000066400000000000000000000315531505210326400176510ustar00rootroot00000000000000// Package flags contains enhanced versions of spf13/pflag flag // routines which will read from the environment also. package flags import ( "os" "regexp" "strings" "time" "github.com/rclone/rclone/fs" "github.com/spf13/pflag" ) // Groups of Flags type Groups struct { // Groups of flags Groups []*Group // GroupsMaps maps a group name to a Group ByName map[string]*Group } // Group related flags together for documentation purposes type Group struct { Groups *Groups Name string Help string Flags *pflag.FlagSet } // NewGroups constructs a collection of Groups func NewGroups() *Groups { return &Groups{ ByName: make(map[string]*Group), } } // NewGroup to create Group func (gs *Groups) NewGroup(name, help string) *Group { group := &Group{ Name: name, Help: help, Flags: pflag.NewFlagSet(name, pflag.ExitOnError), } gs.ByName[group.Name] = group gs.Groups = append(gs.Groups, group) return group } // Filter makes a copy of groups filtered by flagsRe func (gs *Groups) Filter(group string, filterRe *regexp.Regexp, filterNamesOnly bool) *Groups { newGs := NewGroups() for _, g := range gs.Groups { if group == "" || strings.EqualFold(g.Name, group) { newG := newGs.NewGroup(g.Name, g.Help) g.Flags.VisitAll(func(f *pflag.Flag) { if filterRe == nil || filterRe.MatchString(f.Name) || (!filterNamesOnly && filterRe.MatchString(f.Usage)) { newG.Flags.AddFlag(f) } }) } } return newGs } // Include makes a copy of groups only including the ones in the filter string func (gs *Groups) Include(groupsString string) *Groups { if groupsString == "" { return gs } want := map[string]bool{} for _, groupName := range strings.Split(groupsString, ",") { _, ok := All.ByName[groupName] if !ok { fs.Fatalf(nil, "Couldn't find group %q in command annotation", groupName) } want[groupName] = true } newGs := NewGroups() for _, g := range gs.Groups { if !want[g.Name] { continue } newG := newGs.NewGroup(g.Name, g.Help) newG.Flags = g.Flags } return newGs } // Add a new flag to the Group func (g *Group) Add(flag *pflag.Flag) { g.Flags.AddFlag(flag) } // AllRegistered returns all flags in a group func (gs *Groups) AllRegistered() map[*pflag.Flag]struct{} { out := make(map[*pflag.Flag]struct{}) for _, g := range gs.Groups { g.Flags.VisitAll(func(f *pflag.Flag) { out[f] = struct{}{} }) } return out } // All is the global stats Groups var All *Groups // Groups of flags for documentation purposes func init() { All = NewGroups() All.NewGroup("Copy", "Flags for anything which can copy a file") All.NewGroup("Sync", "Flags used for sync commands") All.NewGroup("Important", "Important flags useful for most commands") All.NewGroup("Check", "Flags used for check commands") All.NewGroup("Networking", "Flags for general networking and HTTP stuff") All.NewGroup("Performance", "Flags helpful for increasing performance") All.NewGroup("Config", "Flags for general configuration of rclone") All.NewGroup("Debugging", "Flags for developers") All.NewGroup("Filter", "Flags for filtering directory listings") All.NewGroup("Listing", "Flags for listing directories") All.NewGroup("Logging", "Flags for logging and statistics") All.NewGroup("Metadata", "Flags to control metadata") All.NewGroup("RC", "Flags to control the Remote Control API") All.NewGroup("Metrics", "Flags to control the Metrics HTTP endpoint.") } // installFlag constructs a name from the flag passed in and // sets the value and default from the environment if possible // the value may be overridden when the command line is parsed // // Used to create non-backend flags like --stats. // // It also adds the flag to the groups passed in. func installFlag(flags *pflag.FlagSet, name string, groupsString string) { // Find flag flag := flags.Lookup(name) if flag == nil { fs.Fatalf(nil, "Couldn't find flag --%q", name) } // Read default from environment if possible envKey := fs.OptionToEnv(name) if envValue, envFound := os.LookupEnv(envKey); envFound { isStringArray := false opt, isOption := flag.Value.(*fs.Option) if isOption { _, isStringArray = opt.Default.([]string) } if isStringArray { // Treat stringArray differently, treating the environment variable as a CSV array var list fs.CommaSepList err := list.Set(envValue) if err != nil { fs.Fatalf(nil, "Invalid value when setting stringArray --%s from environment variable %s=%q: %v", name, envKey, envValue, err) } // Set both the Value (so items on the command line get added) and DefValue so the help is correct opt.Value = ([]string)(list) flag.DefValue = list.String() for _, v := range list { fs.Debugf(nil, "Setting --%s %q from environment variable %s=%q", name, v, envKey, envValue) } } else { err := flags.Set(name, envValue) if err != nil { fs.Fatalf(nil, "Invalid value when setting --%s from environment variable %s=%q: %v", name, envKey, envValue, err) } fs.Debugf(nil, "Setting --%s %q from environment variable %s=%q", name, flag.Value, envKey, envValue) flag.DefValue = envValue } } // Add flag to Group if it is a global flag if groupsString != "" && flags == pflag.CommandLine { for _, groupName := range strings.Split(groupsString, ",") { if groupName == "rc-" { groupName = "RC" } group, ok := All.ByName[groupName] if !ok { fs.Fatalf(nil, "Couldn't find group %q for flag --%s", groupName, name) } group.Add(flag) } } } // StringP defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.StringP func StringP(name, shorthand string, value string, usage string, groups string) (out *string) { out = pflag.StringP(name, shorthand, value, usage) installFlag(pflag.CommandLine, name, groups) return out } // StringVarP defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.StringVarP func StringVarP(flags *pflag.FlagSet, p *string, name, shorthand string, value string, usage string, groups string) { flags.StringVarP(p, name, shorthand, value, usage) installFlag(flags, name, groups) } // BoolP defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.BoolP func BoolP(name, shorthand string, value bool, usage string, groups string) (out *bool) { out = pflag.BoolP(name, shorthand, value, usage) installFlag(pflag.CommandLine, name, groups) return out } // BoolVarP defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.BoolVarP func BoolVarP(flags *pflag.FlagSet, p *bool, name, shorthand string, value bool, usage string, groups string) { flags.BoolVarP(p, name, shorthand, value, usage) installFlag(flags, name, groups) } // IntP defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.IntP func IntP(name, shorthand string, value int, usage string, groups string) (out *int) { out = pflag.IntP(name, shorthand, value, usage) installFlag(pflag.CommandLine, name, groups) return out } // Int64P defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.IntP func Int64P(name, shorthand string, value int64, usage string, groups string) (out *int64) { out = pflag.Int64P(name, shorthand, value, usage) installFlag(pflag.CommandLine, name, groups) return out } // Int64VarP defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.Int64VarP func Int64VarP(flags *pflag.FlagSet, p *int64, name, shorthand string, value int64, usage string, groups string) { flags.Int64VarP(p, name, shorthand, value, usage) installFlag(flags, name, groups) } // IntVarP defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.IntVarP func IntVarP(flags *pflag.FlagSet, p *int, name, shorthand string, value int, usage string, groups string) { flags.IntVarP(p, name, shorthand, value, usage) installFlag(flags, name, groups) } // Uint32VarP defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.Uint32VarP func Uint32VarP(flags *pflag.FlagSet, p *uint32, name, shorthand string, value uint32, usage string, groups string) { flags.Uint32VarP(p, name, shorthand, value, usage) installFlag(flags, name, groups) } // Float64P defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.Float64P func Float64P(name, shorthand string, value float64, usage string, groups string) (out *float64) { out = pflag.Float64P(name, shorthand, value, usage) installFlag(pflag.CommandLine, name, groups) return out } // Float64VarP defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.Float64VarP func Float64VarP(flags *pflag.FlagSet, p *float64, name, shorthand string, value float64, usage string, groups string) { flags.Float64VarP(p, name, shorthand, value, usage) installFlag(flags, name, groups) } // DurationP defines a flag which can be set by an environment variable // // It wraps the duration in an fs.Duration for extra suffixes and // passes it to pflag.VarP func DurationP(name, shorthand string, value time.Duration, usage string, groups string) (out *time.Duration) { out = new(time.Duration) *out = value pflag.VarP((*fs.Duration)(out), name, shorthand, usage) installFlag(pflag.CommandLine, name, groups) return out } // DurationVarP defines a flag which can be set by an environment variable // // It wraps the duration in an fs.Duration for extra suffixes and // passes it to pflag.VarP func DurationVarP(flags *pflag.FlagSet, p *time.Duration, name, shorthand string, value time.Duration, usage string, groups string) { flags.VarP((*fs.Duration)(p), name, shorthand, usage) installFlag(flags, name, groups) } // VarP defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.VarP func VarP(value pflag.Value, name, shorthand, usage string, groups string) { pflag.VarP(value, name, shorthand, usage) installFlag(pflag.CommandLine, name, groups) } // FVarP defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.VarP func FVarP(flags *pflag.FlagSet, value pflag.Value, name, shorthand, usage string, groups string) { flags.VarP(value, name, shorthand, usage) installFlag(flags, name, groups) } // StringArrayP defines a flag which can be set by an environment variable // // It sets one value only - command line flags can be used to set more. // // It is a thin wrapper around pflag.StringArrayP func StringArrayP(name, shorthand string, value []string, usage string, groups string) (out *[]string) { out = pflag.StringArrayP(name, shorthand, value, usage) installFlag(pflag.CommandLine, name, groups) return out } // StringArrayVarP defines a flag which can be set by an environment variable // // It sets one value only - command line flags can be used to set more. // // It is a thin wrapper around pflag.StringArrayVarP func StringArrayVarP(flags *pflag.FlagSet, p *[]string, name, shorthand string, value []string, usage string, groups string) { flags.StringArrayVarP(p, name, shorthand, value, usage) installFlag(flags, name, groups) } // CountP defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.CountP func CountP(name, shorthand string, usage string, groups string) (out *int) { out = pflag.CountP(name, shorthand, usage) installFlag(pflag.CommandLine, name, groups) return out } // CountVarP defines a flag which can be set by an environment variable // // It is a thin wrapper around pflag.CountVarP func CountVarP(flags *pflag.FlagSet, p *int, name, shorthand string, usage string, groups string) { flags.CountVarP(p, name, shorthand, usage) installFlag(flags, name, groups) } // AddFlagsFromOptions takes a slice of fs.Option and adds flags for all of them func AddFlagsFromOptions(flags *pflag.FlagSet, prefix string, options fs.Options) { done := map[string]struct{}{} for i := range options { opt := &options[i] // Skip if done already (e.g. with Provider options) if _, doneAlready := done[opt.Name]; doneAlready { continue } done[opt.Name] = struct{}{} // Make a flag from each option if prefix == "" { opt.NoPrefix = true } name := opt.FlagName(prefix) found := flags.Lookup(name) != nil if !found { // Take first line of help only help := strings.TrimSpace(opt.Help) if nl := strings.IndexRune(help, '\n'); nl >= 0 { help = help[:nl] } help = strings.TrimRight(strings.TrimSpace(help), ".!?") if opt.IsPassword { help += " (obscured)" } flag := flags.VarPF(opt, name, opt.ShortOpt, help) installFlag(flags, name, opt.Groups) if _, isBool := opt.Default.(bool); isBool { flag.NoOptDefVal = "true" } // Hide on the command line if requested if opt.Hide&fs.OptionHideCommandLine != 0 { flag.Hidden = true } } else { fs.Errorf(nil, "Not adding duplicate flag --%s", name) } // flag.Hidden = true } } rclone-v1.71.0/fs/config/obscure/000077500000000000000000000000001505210326400165655ustar00rootroot00000000000000rclone-v1.71.0/fs/config/obscure/obscure.go000066400000000000000000000050271505210326400205620ustar00rootroot00000000000000// Package obscure contains the Obscure and Reveal commands package obscure import ( "crypto/aes" "crypto/cipher" "crypto/rand" "encoding/base64" "errors" "fmt" "io" "math" "github.com/rclone/rclone/fs" ) // crypt internals var ( cryptKey = []byte{ 0x9c, 0x93, 0x5b, 0x48, 0x73, 0x0a, 0x55, 0x4d, 0x6b, 0xfd, 0x7c, 0x63, 0xc8, 0x86, 0xa9, 0x2b, 0xd3, 0x90, 0x19, 0x8e, 0xb8, 0x12, 0x8a, 0xfb, 0xf4, 0xde, 0x16, 0x2b, 0x8b, 0x95, 0xf6, 0x38, } cryptBlock cipher.Block cryptRand = rand.Reader ) // crypt transforms in to out using iv under AES-CTR. // // in and out may be the same buffer. // // Note encryption and decryption are the same operation func crypt(out, in, iv []byte) error { if cryptBlock == nil { var err error cryptBlock, err = aes.NewCipher(cryptKey) if err != nil { return err } } stream := cipher.NewCTR(cryptBlock, iv) stream.XORKeyStream(out, in) return nil } // Obscure a value // // This is done by encrypting with AES-CTR func Obscure(x string) (string, error) { plaintext := []byte(x) if math.MaxInt32-aes.BlockSize < len(plaintext) { return "", fmt.Errorf("value too large") } ciphertext := make([]byte, aes.BlockSize+len(plaintext)) iv := ciphertext[:aes.BlockSize] if _, err := io.ReadFull(cryptRand, iv); err != nil { return "", fmt.Errorf("failed to read iv: %w", err) } if err := crypt(ciphertext[aes.BlockSize:], plaintext, iv); err != nil { return "", fmt.Errorf("encrypt failed: %w", err) } return base64.RawURLEncoding.EncodeToString(ciphertext), nil } // MustObscure obscures a value, exiting with a fatal error if it failed func MustObscure(x string) string { out, err := Obscure(x) if err != nil { fs.Fatalf(nil, "Obscure failed: %v", err) } return out } // Reveal an obscured value func Reveal(x string) (string, error) { ciphertext, err := base64.RawURLEncoding.DecodeString(x) if err != nil { return "", fmt.Errorf("base64 decode failed when revealing password - is it obscured?: %w", err) } if len(ciphertext) < aes.BlockSize { return "", errors.New("input too short when revealing password - is it obscured?") } buf := ciphertext[aes.BlockSize:] iv := ciphertext[:aes.BlockSize] if err := crypt(buf, buf, iv); err != nil { return "", fmt.Errorf("decrypt failed when revealing password - is it obscured?: %w", err) } return string(buf), nil } // MustReveal reveals an obscured value, exiting with a fatal error if it failed func MustReveal(x string) string { out, err := Reveal(x) if err != nil { fs.Fatalf(nil, "Reveal failed: %v", err) } return out } rclone-v1.71.0/fs/config/obscure/obscure_test.go000066400000000000000000000040441505210326400216170ustar00rootroot00000000000000package obscure import ( "bytes" "crypto/rand" "testing" "github.com/stretchr/testify/assert" ) func TestObscure(t *testing.T) { for _, test := range []struct { in string want string iv string }{ {"", "YWFhYWFhYWFhYWFhYWFhYQ", "aaaaaaaaaaaaaaaa"}, {"potato", "YWFhYWFhYWFhYWFhYWFhYXMaGgIlEQ", "aaaaaaaaaaaaaaaa"}, {"potato", "YmJiYmJiYmJiYmJiYmJiYp3gcEWbAw", "bbbbbbbbbbbbbbbb"}, } { cryptRand = bytes.NewBufferString(test.iv) got, err := Obscure(test.in) cryptRand = rand.Reader assert.NoError(t, err) assert.Equal(t, test.want, got) recoveredIn, err := Reveal(got) assert.NoError(t, err) assert.Equal(t, test.in, recoveredIn, "not bidirectional") // Now the Must variants cryptRand = bytes.NewBufferString(test.iv) got = MustObscure(test.in) cryptRand = rand.Reader assert.Equal(t, test.want, got) recoveredIn = MustReveal(got) assert.Equal(t, test.in, recoveredIn, "not bidirectional") } } func TestReveal(t *testing.T) { for _, test := range []struct { in string want string iv string }{ {"YWFhYWFhYWFhYWFhYWFhYQ", "", "aaaaaaaaaaaaaaaa"}, {"YWFhYWFhYWFhYWFhYWFhYXMaGgIlEQ", "potato", "aaaaaaaaaaaaaaaa"}, {"YmJiYmJiYmJiYmJiYmJiYp3gcEWbAw", "potato", "bbbbbbbbbbbbbbbb"}, } { cryptRand = bytes.NewBufferString(test.iv) got, err := Reveal(test.in) assert.NoError(t, err) assert.Equal(t, test.want, got) // Now the Must variants cryptRand = bytes.NewBufferString(test.iv) got = MustReveal(test.in) assert.Equal(t, test.want, got) } } // Test some error cases func TestRevealErrors(t *testing.T) { for _, test := range []struct { in string wantErr string }{ {"YmJiYmJiYmJiYmJiYmJiYp*gcEWbAw", "base64 decode failed when revealing password - is it obscured?: illegal base64 data at input byte 22"}, {"aGVsbG8", "input too short when revealing password - is it obscured?"}, {"", "input too short when revealing password - is it obscured?"}, } { gotString, gotErr := Reveal(test.in) assert.Equal(t, "", gotString) assert.Equal(t, test.wantErr, gotErr.Error()) } } rclone-v1.71.0/fs/config/rc.go000066400000000000000000000171361505210326400160660ustar00rootroot00000000000000package config import ( "context" "errors" "os" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/rc" ) func init() { rc.Add(rc.Call{ Path: "config/unlock", Fn: rcConfigPassword, Title: "Unlock the config file.", AuthRequired: true, Help: ` Unlocks the config file if it is locked. Parameters: - 'config_password' - password to unlock the config file A good idea is to disable AskPassword before making this call `, }) } // Unlock the config file // A good idea is to disable AskPassword before making this call func rcConfigPassword(ctx context.Context, in rc.Params) (out rc.Params, err error) { configPass, err := in.GetString("config_password") if err != nil { return nil, err } if SetConfigPassword(configPass) != nil { return nil, errors.New("failed to set config password") } return nil, nil } func init() { rc.Add(rc.Call{ Path: "config/dump", Fn: rcDump, Title: "Dumps the config file.", AuthRequired: true, Help: ` Returns a JSON object: - key: value Where keys are remote names and values are the config parameters. See the [config dump](/commands/rclone_config_dump/) command for more information on the above. `, }) } // Return the config file dump func rcDump(ctx context.Context, in rc.Params) (out rc.Params, err error) { return DumpRcBlob(), nil } func init() { rc.Add(rc.Call{ Path: "config/get", Fn: rcGet, Title: "Get a remote in the config file.", AuthRequired: true, Help: ` Parameters: - name - name of remote to get See the [config dump](/commands/rclone_config_dump/) command for more information on the above. `, }) } // Return the config file get func rcGet(ctx context.Context, in rc.Params) (out rc.Params, err error) { name, err := in.GetString("name") if err != nil { return nil, err } return DumpRcRemote(name), nil } func init() { rc.Add(rc.Call{ Path: "config/listremotes", Fn: rcListRemotes, Title: "Lists the remotes in the config file and defined in environment variables.", AuthRequired: true, Help: ` Returns - remotes - array of remote names See the [listremotes](/commands/rclone_listremotes/) command for more information on the above. `, }) } // Return the a list of remotes in the config file // including any defined by environment variables. func rcListRemotes(ctx context.Context, in rc.Params) (out rc.Params, err error) { remoteNames := GetRemoteNames() if remoteNames == nil { remoteNames = []string{} } out = rc.Params{ "remotes": remoteNames, } return out, nil } func init() { rc.Add(rc.Call{ Path: "config/providers", Fn: rcProviders, Title: "Shows how providers are configured in the config file.", AuthRequired: true, Help: ` Returns a JSON object: - providers - array of objects See the [config providers](/commands/rclone_config_providers/) command for more information on the above. Note that the Options blocks are in the same format as returned by "options/info". They are described in the [option blocks](#option-blocks) section. `, }) } // Return the config file providers func rcProviders(ctx context.Context, in rc.Params) (out rc.Params, err error) { out = rc.Params{ "providers": fs.Registry, } return out, nil } func init() { for _, name := range []string{"create", "update", "password"} { name := name extraHelp := "" if name == "create" { extraHelp = "- type - type of the new remote\n" } if name == "create" || name == "update" { extraHelp += `- opt - a dictionary of options to control the configuration - obscure - declare passwords are plain and need obscuring - noObscure - declare passwords are already obscured and don't need obscuring - noOutput - don't print anything to stdout - nonInteractive - don't interact with a user, return questions - continue - continue the config process with an answer - all - ask all the config questions not just the post config ones - state - state to restart with - used with continue - result - result to restart with - used with continue ` } rc.Add(rc.Call{ Path: "config/" + name, AuthRequired: true, Fn: func(ctx context.Context, in rc.Params) (rc.Params, error) { return rcConfig(ctx, in, name) }, Title: name + " the config for a remote.", Help: `This takes the following parameters: - name - name of remote - parameters - a map of \{ "key": "value" \} pairs ` + extraHelp + ` See the [config ` + name + `](/commands/rclone_config_` + name + `/) command for more information on the above.`, }) } } // Manipulate the config file func rcConfig(ctx context.Context, in rc.Params, what string) (out rc.Params, err error) { name, err := in.GetString("name") if err != nil { return nil, err } parameters := rc.Params{} err = in.GetStruct("parameters", ¶meters) if err != nil { return nil, err } var opt UpdateRemoteOpt err = in.GetStruct("opt", &opt) if err != nil && !rc.IsErrParamNotFound(err) { return nil, err } // Backwards compatibility if value, err := in.GetBool("obscure"); err == nil { opt.Obscure = value } if value, err := in.GetBool("noObscure"); err == nil { opt.NoObscure = value } var configOut *fs.ConfigOut switch what { case "create": remoteType, typeErr := in.GetString("type") if typeErr != nil { return nil, typeErr } configOut, err = CreateRemote(ctx, name, remoteType, parameters, opt) case "update": configOut, err = UpdateRemote(ctx, name, parameters, opt) case "password": err = PasswordRemote(ctx, name, parameters) default: err = errors.New("unknown rcConfig type") } if err != nil { return nil, err } if !opt.NonInteractive { return nil, nil } if configOut == nil { configOut = &fs.ConfigOut{} } err = rc.Reshape(&out, configOut) if err != nil { return nil, err } return out, nil } func init() { rc.Add(rc.Call{ Path: "config/delete", Fn: rcDelete, Title: "Delete a remote in the config file.", AuthRequired: true, Help: ` Parameters: - name - name of remote to delete See the [config delete](/commands/rclone_config_delete/) command for more information on the above. `, }) } // Return the config file delete func rcDelete(ctx context.Context, in rc.Params) (out rc.Params, err error) { name, err := in.GetString("name") if err != nil { return nil, err } DeleteRemote(name) return nil, nil } func init() { rc.Add(rc.Call{ Path: "config/setpath", Fn: rcSetPath, Title: "Set the path of the config file", AuthRequired: true, Help: ` Parameters: - path - path to the config file to use `, }) } // Set the config file path func rcSetPath(ctx context.Context, in rc.Params) (out rc.Params, err error) { path, err := in.GetString("path") if err != nil { return nil, err } err = SetConfigPath(path) return nil, err } func init() { rc.Add(rc.Call{ Path: "config/paths", Fn: rcPaths, Title: "Reads the config file path and other important paths.", AuthRequired: true, Help: ` Returns a JSON object with the following keys: - config: path to config file - cache: path to root of cache directory - temp: path to root of temporary directory Eg { "cache": "/home/USER/.cache/rclone", "config": "/home/USER/.rclone.conf", "temp": "/tmp" } See the [config paths](/commands/rclone_config_paths/) command for more information on the above. `, }) } // Set the config file path func rcPaths(ctx context.Context, in rc.Params) (out rc.Params, err error) { return rc.Params{ "config": GetConfigPath(), "cache": GetCacheDir(), "temp": os.TempDir(), }, nil } rclone-v1.71.0/fs/config/rc_test.go000066400000000000000000000136561505210326400171300ustar00rootroot00000000000000package config_test import ( "context" "os" "path/filepath" "testing" _ "github.com/rclone/rclone/backend/local" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configfile" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/rc" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) const testName = "configTestNameForRc" func TestRc(t *testing.T) { ctx := context.Background() oldConfigFile := config.GetConfigPath() defer func() { require.NoError(t, config.SetConfigPath(oldConfigFile)) }() // Set a temporary config file require.NoError(t, config.SetConfigPath(filepath.Join(t.TempDir(), "rclone.conf"))) configfile.Install() // Create the test remote call := rc.Calls.Get("config/create") assert.NotNil(t, call) in := rc.Params{ "name": testName, "type": "local", "parameters": rc.Params{ "test_key": "sausage", }, } out, err := call.Fn(ctx, in) require.NoError(t, err) require.Nil(t, out) assert.Equal(t, "local", config.GetValue(testName, "type")) assert.Equal(t, "sausage", config.GetValue(testName, "test_key")) // The sub tests rely on the remote created above but they can // all be run independently t.Run("Dump", func(t *testing.T) { call := rc.Calls.Get("config/dump") assert.NotNil(t, call) in := rc.Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) require.NotNil(t, out[testName]) config := out[testName].(rc.Params) assert.Equal(t, "local", config["type"]) assert.Equal(t, "sausage", config["test_key"]) }) t.Run("Get", func(t *testing.T) { call := rc.Calls.Get("config/get") assert.NotNil(t, call) in := rc.Params{ "name": testName, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, "local", out["type"]) assert.Equal(t, "sausage", out["test_key"]) }) t.Run("ListRemotes", func(t *testing.T) { assert.NoError(t, os.Setenv("RCLONE_CONFIG_MY-LOCAL_TYPE", "local")) defer func() { assert.NoError(t, os.Unsetenv("RCLONE_CONFIG_MY-LOCAL_TYPE")) }() call := rc.Calls.Get("config/listremotes") assert.NotNil(t, call) in := rc.Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) var remotes []string err = out.GetStruct("remotes", &remotes) require.NoError(t, err) assert.Contains(t, remotes, testName) assert.Contains(t, remotes, "my-local") }) t.Run("Update", func(t *testing.T) { call := rc.Calls.Get("config/update") assert.NotNil(t, call) in := rc.Params{ "name": testName, "parameters": rc.Params{ "test_key": "rutabaga", "test_key2": "cabbage", }, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Nil(t, out) assert.Equal(t, "local", config.GetValue(testName, "type")) assert.Equal(t, "rutabaga", config.GetValue(testName, "test_key")) assert.Equal(t, "cabbage", config.GetValue(testName, "test_key2")) }) t.Run("Password", func(t *testing.T) { call := rc.Calls.Get("config/password") assert.NotNil(t, call) pw2 := obscure.MustObscure("password") in := rc.Params{ "name": testName, "parameters": rc.Params{ "test_key": "rutabaga", "test_key2": pw2, // check we encode an already encoded password }, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Nil(t, out) assert.Equal(t, "local", config.GetValue(testName, "type")) assert.Equal(t, "rutabaga", obscure.MustReveal(config.GetValue(testName, "test_key"))) assert.Equal(t, pw2, obscure.MustReveal(config.GetValue(testName, "test_key2"))) }) // Delete the test remote call = rc.Calls.Get("config/delete") assert.NotNil(t, call) in = rc.Params{ "name": testName, } out, err = call.Fn(context.Background(), in) require.NoError(t, err) assert.Nil(t, out) assert.Equal(t, "", config.GetValue(testName, "type")) assert.Equal(t, "", config.GetValue(testName, "test_key")) t.Run("ListRemotes empty not nil", func(t *testing.T) { call := rc.Calls.Get("config/listremotes") assert.NotNil(t, call) in := rc.Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) var remotes []string err = out.GetStruct("remotes", &remotes) require.NoError(t, err) assert.NotNil(t, remotes) assert.Empty(t, remotes) }) } func TestRcProviders(t *testing.T) { call := rc.Calls.Get("config/providers") assert.NotNil(t, call) in := rc.Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) var registry []*fs.RegInfo err = out.GetStruct("providers", ®istry) require.NoError(t, err) foundLocal := false for _, provider := range registry { if provider.Name == "local" { foundLocal = true break } } assert.True(t, foundLocal, "didn't find local provider") } func TestRcSetPath(t *testing.T) { oldPath := config.GetConfigPath() newPath := oldPath + ".newPath" call := rc.Calls.Get("config/setpath") assert.NotNil(t, call) in := rc.Params{ "path": newPath, } _, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, newPath, config.GetConfigPath()) in["path"] = oldPath _, err = call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, oldPath, config.GetConfigPath()) } func TestRcPaths(t *testing.T) { call := rc.Calls.Get("config/paths") assert.NotNil(t, call) out, err := call.Fn(context.Background(), nil) require.NoError(t, err) assert.Equal(t, config.GetConfigPath(), out["config"]) assert.Equal(t, config.GetCacheDir(), out["cache"]) assert.Equal(t, os.TempDir(), out["temp"]) } func TestRcConfigUnlock(t *testing.T) { call := rc.Calls.Get("config/unlock") assert.NotNil(t, call) in := rc.Params{ "config_password": "test", } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Nil(t, err) assert.Nil(t, out) } rclone-v1.71.0/fs/config/testdata/000077500000000000000000000000001505210326400167345ustar00rootroot00000000000000rclone-v1.71.0/fs/config/testdata/enc-invalid.conf000066400000000000000000000003341505210326400217740ustar00rootroot00000000000000# Encrypted rclone configuration File RCLONE_ENCRYPT_V0: b5Uk6mE3cUn5Wb8xiWYnVBAxXUirAaEG1PO/GIDiO9274AOæøå+Yj790BwJA4d2y7lNkmHt4nJwIsoueFvUYmm7RDyzER8IA3XOCrjzl3OUcczZqcplk5JfBdhxMZpt1aGYWUdle1IgO/kAFne6sLD6IuxPySEbrclone-v1.71.0/fs/config/testdata/enc-short.conf000066400000000000000000000001131505210326400215000ustar00rootroot00000000000000# Encrypted rclone configuration File RCLONE_ENCRYPT_V0: b5Uk6mE3cUn5Wb8xirclone-v1.71.0/fs/config/testdata/enc-too-new.conf000066400000000000000000000003261505210326400217370ustar00rootroot00000000000000# Encrypted rclone configuration File RCLONE_ENCRYPT_V1: b5Uk6mE3cUn5Wb8xiWYnVBAxXUirAaEG1PO/GIDiO9274AO+Yj790BwJA4d2y7lNkmHt4nJwIsoueFvUYmm7RDyzER8IA3XOCrjzl3OUcczZqcplk5JfBdhxMZpt1aGYWUdle1IgO/kAFne6sLD6IuxPySEbrclone-v1.71.0/fs/config/testdata/encrypted.conf000066400000000000000000000003261505210326400216010ustar00rootroot00000000000000# Encrypted rclone configuration File RCLONE_ENCRYPT_V0: b5Uk6mE3cUn5Wb8xiWYnVBAxXUirAaEG1PO/GIDiO9274AO+Yj790BwJA4d2y7lNkmHt4nJwIsoueFvUYmm7RDyzER8IA3XOCrjzl3OUcczZqcplk5JfBdhxMZpt1aGYWUdle1IgO/kAFne6sLD6IuxPySEbrclone-v1.71.0/fs/config/testdata/plain.conf000066400000000000000000000001641505210326400207070ustar00rootroot00000000000000[RCLONE_ENCRYPT_V0] type = local nounc = true [nounc] type = local nounc = true [unc] type = local nounc = false rclone-v1.71.0/fs/config/ui.go000066400000000000000000000537261505210326400161040ustar00rootroot00000000000000// Textual user interface parts of the config system package config import ( "context" "errors" "fmt" "io" "os" "slices" "sort" "strconv" "strings" "unicode/utf8" "github.com/peterh/liner" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/driveletter" "github.com/rclone/rclone/fs/fspath" "github.com/rclone/rclone/lib/terminal" "golang.org/x/text/unicode/norm" ) // ReadLine reads an unlimited length line from stdin with a prompt. var ReadLine = func(prompt string) string { l := liner.NewLiner() defer func() { _ = l.Close() }() l.SetMultiLineMode(true) l.SetCtrlCAborts(true) line, err := l.Prompt(prompt) if err == io.EOF { return "" } if err != nil { _ = l.Close() fs.Fatalf(nil, "Failed to read: %v", err) } return strings.TrimSpace(line) } // ReadNonEmptyLine prints prompt and calls Readline until non empty func ReadNonEmptyLine(prompt string) string { result := "" for result == "" { result = strings.TrimSpace(ReadLine(prompt)) } return result } // CommandDefault - choose one. If return is pressed then it will // chose the defaultIndex if it is >= 0 // // Must not call fs.Log anything from here to avoid deadlock in // --interactive --progress func CommandDefault(commands []string, defaultIndex int) byte { opts := []string{} for i, text := range commands { def := "" if i == defaultIndex { def = " (default)" } fmt.Printf("%c) %s%s\n", text[0], text[1:], def) opts = append(opts, text[:1]) } optString := strings.Join(opts, "") optHelp := strings.Join(opts, "/") for { result := strings.ToLower(ReadLine(fmt.Sprintf("%s> ", optHelp))) if len(result) == 0 { if defaultIndex >= 0 { return optString[defaultIndex] } fmt.Printf("This value is required and it has no default.\n") } else if len(result) == 1 { i := strings.Index(optString, string(result[0])) if i >= 0 { return result[0] } fmt.Printf("This value must be one of the following characters: %s.\n", strings.Join(opts, ", ")) } else { fmt.Printf("This value must be a single character, one of the following: %s.\n", strings.Join(opts, ", ")) } } } // Command - choose one func Command(commands []string) byte { return CommandDefault(commands, -1) } // Confirm asks the user for Yes or No and returns true or false // // If the user presses enter then the Default will be used func Confirm(Default bool) bool { defaultIndex := 0 if !Default { defaultIndex = 1 } return CommandDefault([]string{"yYes", "nNo"}, defaultIndex) == 'y' } // Choose one of the choices, or default, or type a new string if newOk is set func Choose(what string, kind string, choices, help []string, defaultValue string, required bool, newOk bool) string { valueDescription := "an existing" if newOk { valueDescription = "your own" } fmt.Printf("Choose a number from below, or type in %s %s.\n", valueDescription, kind) // Empty input is allowed if not required is set, or if // required is set but there is a default value to use. if defaultValue != "" { fmt.Printf("Press Enter for the default (%s).\n", defaultValue) } else if !required { fmt.Printf("Press Enter to leave empty.\n") } attributes := []string{terminal.HiRedFg, terminal.HiGreenFg} for i, text := range choices { var lines []string if help != nil && help[i] != "" { parts := strings.Split(help[i], "\n") lines = append(lines, parts...) lines = append(lines, fmt.Sprintf("(%s)", text)) } pos := i + 1 terminal.WriteString(attributes[i%len(attributes)]) if len(lines) == 0 { fmt.Printf("%2d > %s\n", pos, text) } else { mid := (len(lines) - 1) / 2 for i, line := range lines { var sep rune switch i { case 0: sep = '/' case len(lines) - 1: sep = '\\' default: sep = '|' } number := " " if i == mid { number = fmt.Sprintf("%2d", pos) } fmt.Printf("%s %c %s\n", number, sep, line) } } terminal.WriteString(terminal.Reset) } for { result := ReadLine(fmt.Sprintf("%s> ", what)) i, err := strconv.Atoi(result) if err != nil { if slices.Contains(choices, result) { return result } if result == "" { // If empty string is in the predefined list of choices it has already been returned above. // If parameter required is not set, then empty string is always a valid value. if !required { return result } // If parameter required is set, but there is a default, then empty input means default. if defaultValue != "" { return defaultValue } // If parameter required is set, and there is no default, then an input value is required. fmt.Printf("This value is required and it has no default.\n") } else if newOk { // If legal input is not restricted to defined choices, then any nonzero input string is accepted. return result } else { // A nonzero input string was specified but it did not match any of the strictly defined choices. fmt.Printf("This value must match %s value.\n", valueDescription) } } else { if i >= 1 && i <= len(choices) { return choices[i-1] } fmt.Printf("No choices with this number.\n") } } } // Enter prompts for an input value of a specified type func Enter(what string, kind string, defaultValue string, required bool) string { // Empty input is allowed if not required is set, or if // required is set but there is a default value to use. fmt.Printf("Enter a %s.", kind) if defaultValue != "" { fmt.Printf(" Press Enter for the default (%s).\n", defaultValue) } else if !required { fmt.Println(" Press Enter to leave empty.") } else { fmt.Println() } for { result := ReadLine(fmt.Sprintf("%s> ", what)) if !required || result != "" { return result } if defaultValue != "" { return defaultValue } fmt.Printf("This value is required and it has no default.\n") } } // ChoosePassword asks the user for a password func ChoosePassword(defaultValue string, required bool) string { fmt.Printf("Choose an alternative below.") actions := []string{"yYes, type in my own password", "gGenerate random password"} defaultAction := -1 if defaultValue != "" { defaultAction = len(actions) actions = append(actions, "nNo, keep existing") fmt.Printf(" Press Enter for the default (%s).", string(actions[defaultAction][0])) } else if !required { defaultAction = len(actions) actions = append(actions, "nNo, leave this optional password blank") fmt.Printf(" Press Enter for the default (%s).", string(actions[defaultAction][0])) } fmt.Println() var password string var err error switch i := CommandDefault(actions, defaultAction); i { case 'y': password = ChangePassword("the") case 'g': for { fmt.Printf("Password strength in bits.\n64 is just about memorable\n128 is secure\n1024 is the maximum\n") bits := ChooseNumber("Bits", 64, 1024) password, err = Password(bits) if err != nil { fs.Fatalf(nil, "Failed to make password: %v", err) } fmt.Printf("Your password is: %s\n", password) fmt.Printf("Use this password? Please note that an obscured version of this \npassword (and not the " + "password itself) will be stored under your \nconfiguration file, so keep this generated password " + "in a safe place.\n") if Confirm(true) { break } } case 'n': return defaultValue default: fs.Errorf(nil, "Bad choice %c", i) } return obscure.MustObscure(password) } // ChooseNumber asks the user to enter a number between min and max // inclusive prompting them with what. func ChooseNumber(what string, min, max int) int { for { result := ReadLine(fmt.Sprintf("%s> ", what)) i, err := strconv.Atoi(result) if err != nil { fmt.Printf("Bad number: %v\n", err) continue } if i < min || i > max { fmt.Printf("Out of range - %d to %d inclusive\n", min, max) continue } return i } } // ShowRemotes shows an overview of the config file func ShowRemotes() { remotes := LoadedData().GetSectionList() if len(remotes) == 0 { return } sort.Strings(remotes) fmt.Printf("%-20s %s\n", "Name", "Type") fmt.Printf("%-20s %s\n", "====", "====") for _, remote := range remotes { fmt.Printf("%-20s %s\n", remote, GetValue(remote, "type")) } } // ChooseRemote chooses a remote name func ChooseRemote() string { remotes := LoadedData().GetSectionList() sort.Strings(remotes) fmt.Println("Select remote.") return Choose("remote", "value", remotes, nil, "", true, false) } // mustFindByName finds the RegInfo for the remote name passed in or // exits with a fatal error. func mustFindByName(name string) *fs.RegInfo { fsType := GetValue(name, "type") if fsType == "" { fs.Fatalf(nil, "Couldn't find type of fs for %q", name) } return fs.MustFind(fsType) } // findByName finds the RegInfo for the remote name passed in or // returns an error func findByName(name string) (*fs.RegInfo, error) { fsType := GetValue(name, "type") if fsType == "" { return nil, fmt.Errorf("couldn't find type of fs for %q", name) } return fs.Find(fsType) } // printRemoteOptions prints the options of the remote func printRemoteOptions(name string, prefix string, sep string, redacted bool) { fsInfo, err := findByName(name) if err != nil { fmt.Printf("# %v\n", err) fsInfo = nil } for _, key := range LoadedData().GetKeyList(name) { isPassword := false isSensitive := false if fsInfo != nil { for _, option := range fsInfo.Options { if option.Name == key { if option.IsPassword { isPassword = true } else if option.Sensitive { isSensitive = true } } } } value := GetValue(name, key) if redacted && (isSensitive || isPassword) && value != "" { fmt.Printf("%s%s%sXXX\n", prefix, key, sep) } else if isPassword && value != "" { fmt.Printf("%s%s%s*** ENCRYPTED ***\n", prefix, key, sep) } else { fmt.Printf("%s%s%s%s\n", prefix, key, sep, value) } } } // listRemoteOptions lists the options of the remote func listRemoteOptions(name string) { printRemoteOptions(name, "- ", ": ", false) } // ShowRemote shows the contents of the remote in config file format func ShowRemote(name string) { fmt.Printf("[%s]\n", name) printRemoteOptions(name, "", " = ", false) } // ShowRedactedRemote shows the contents of the remote in config file format func ShowRedactedRemote(name string) { fmt.Printf("[%s]\n", name) printRemoteOptions(name, "", " = ", true) } // OkRemote prints the contents of the remote and ask if it is OK func OkRemote(name string) bool { fmt.Println("Configuration complete.") fmt.Println("Options:") listRemoteOptions(name) fmt.Printf("Keep this %q remote?\n", name) switch i := CommandDefault([]string{"yYes this is OK", "eEdit this remote", "dDelete this remote"}, 0); i { case 'y': return true case 'e': return false case 'd': LoadedData().DeleteSection(name) return true default: fs.Errorf(nil, "Bad choice %c", i) } return false } // newSection prints an empty line to separate sections func newSection() { fmt.Println() } // backendConfig configures the backend starting from the state passed in // // The is the user interface loop that drives the post configuration backend config. func backendConfig(ctx context.Context, name string, m configmap.Mapper, ri *fs.RegInfo, choices configmap.Getter, startState string) error { in := fs.ConfigIn{ State: startState, } for { out, err := fs.BackendConfig(ctx, name, m, ri, choices, in) if err != nil { return err } if out == nil { break } if out.Error != "" { fmt.Println(out.Error) } in.State = out.State in.Result = out.Result if out.Option != nil { fs.Debugf(name, "config: reading config parameter %q", out.Option.Name) if out.Option.Default == nil { out.Option.Default = "" } if Default, isBool := out.Option.Default.(bool); isBool && len(out.Option.Examples) == 2 && out.Option.Examples[0].Help == "Yes" && out.Option.Examples[0].Value == "true" && out.Option.Examples[1].Help == "No" && out.Option.Examples[1].Value == "false" && out.Option.Exclusive { // Use Confirm for Yes/No questions as it has a nicer interface= fmt.Println(out.Option.Help) in.Result = fmt.Sprint(Confirm(Default)) } else { value := ChooseOption(out.Option, name) if value != "" { err := out.Option.Set(value) if err != nil { return fmt.Errorf("failed to set option: %w", err) } } in.Result = out.Option.String() } } if out.State == "" { break } newSection() } return nil } // PostConfig configures the backend after the main config has been done // // The is the user interface loop that drives the post configuration backend config. func PostConfig(ctx context.Context, name string, m configmap.Mapper, ri *fs.RegInfo) error { if ri.Config == nil { return errors.New("backend doesn't support reconnect or authorize") } return backendConfig(ctx, name, m, ri, configmap.Simple{}, "") } // RemoteConfig runs the config helper for the remote if needed func RemoteConfig(ctx context.Context, name string) error { fmt.Printf("Remote config\n") ri := mustFindByName(name) m := fs.ConfigMap(ri.Prefix, ri.Options, name, nil) if ri.Config == nil { return nil } return PostConfig(ctx, name, m, ri) } // ChooseOption asks the user to choose an option func ChooseOption(o *fs.Option, name string) string { fmt.Printf("Option %s.\n", o.Name) if o.Help != "" { // Show help string without empty lines. help := strings.ReplaceAll(strings.TrimSpace(o.Help), "\n\n", "\n") fmt.Println(help) } var defaultValue string if o.Default == nil { defaultValue = "" } else { defaultValue = fmt.Sprint(o.Default) } if o.IsPassword { return ChoosePassword(defaultValue, o.Required) } what := "value" if o.Default != "" { switch o.Default.(type) { case bool: what = "boolean value (true or false)" case fs.SizeSuffix: what = "size with suffix K,M,G,T" case fs.Duration: what = "duration s,m,h,d,w,M,y" case int, int8, int16, int32, int64: what = "signed integer" case uint, byte, uint16, uint32, uint64: what = "unsigned integer" default: what = fmt.Sprintf("value of type %s", o.Type()) } } var in string for { if len(o.Examples) > 0 { var values []string var help []string for _, example := range o.Examples { values = append(values, example.Value) help = append(help, example.Help) } in = Choose(o.Name, what, values, help, defaultValue, o.Required, !o.Exclusive) } else { in = Enter(o.Name, what, defaultValue, o.Required) } if in != "" { newIn, err := configstruct.StringToInterface(o.Default, in) if err != nil { fmt.Printf("Failed to parse %q: %v\n", in, err) continue } in = fmt.Sprint(newIn) // canonicalise } return in } } // NewRemoteName asks the user for a name for a new remote func NewRemoteName() (name string) { for { fmt.Println("Enter name for new remote.") name = ReadLine("name> ") if LoadedData().HasSection(name) { fmt.Printf("Remote %q already exists.\n", name) continue } err := fspath.CheckConfigName(name) switch { case name == "": fmt.Printf("Can't use empty name.\n") case driveletter.IsDriveLetter(name): fmt.Printf("Can't use %q as it can be confused with a drive letter.\n", name) case err != nil: fmt.Printf("Can't use %q as %v.\n", name, err) default: return name } } } // NewRemote make a new remote from its name func NewRemote(ctx context.Context, name string) error { var ( newType string ri *fs.RegInfo err error ) // Set the type first for { newType = ChooseOption(fsOption(), name) ri, err = fs.Find(newType) if err != nil { fmt.Printf("Bad remote %q: %v\n", newType, err) continue } break } LoadedData().SetValue(name, "type", newType) newSection() _, err = CreateRemote(ctx, name, newType, nil, UpdateRemoteOpt{ All: true, }) if err != nil { return err } if OkRemote(name) { SaveConfig() return nil } newSection() return EditRemote(ctx, ri, name) } // EditRemote gets the user to edit a remote func EditRemote(ctx context.Context, ri *fs.RegInfo, name string) error { fmt.Printf("Editing existing %q remote with options:\n", name) listRemoteOptions(name) newSection() for { _, err := UpdateRemote(ctx, name, nil, UpdateRemoteOpt{ All: true, }) if err != nil { return err } if OkRemote(name) { break } } SaveConfig() return nil } // DeleteRemote gets the user to delete a remote func DeleteRemote(name string) { LoadedData().DeleteSection(name) SaveConfig() } // copyRemote asks the user for a new remote name and copies name into // it. Returns the new name. func copyRemote(name string) string { newName := NewRemoteName() // Copy the keys for _, key := range LoadedData().GetKeyList(name) { value, _ := FileGetValue(name, key) LoadedData().SetValue(newName, key, value) } return newName } // RenameRemote renames a config section func RenameRemote(name string) { fmt.Printf("Enter new name for %q remote.\n", name) newName := copyRemote(name) if name != newName { LoadedData().DeleteSection(name) SaveConfig() } } // CopyRemote copies a config section func CopyRemote(name string) { fmt.Printf("Enter name for copy of %q remote.\n", name) copyRemote(name) SaveConfig() } // ShowConfigLocation prints the location of the config file in use func ShowConfigLocation() { if configPath := GetConfigPath(); configPath == "" { fmt.Println("Configuration is in memory only") } else { if _, err := os.Stat(configPath); os.IsNotExist(err) { fmt.Println("Configuration file doesn't exist, but rclone will use this path:") } else { fmt.Println("Configuration file is stored at:") } fmt.Printf("%s\n", configPath) } } // ShowConfig prints the (unencrypted) config options func ShowConfig() { str, err := LoadedData().Serialize() if err != nil { fs.Fatalf(nil, "Failed to serialize config: %v", err) } if str == "" { str = "; empty config\n" } fmt.Printf("%s", str) } // ShowRedactedConfig prints the redacted (unencrypted) config options func ShowRedactedConfig() { remotes := LoadedData().GetSectionList() if len(remotes) == 0 { fmt.Println("; empty config") return } sort.Strings(remotes) for i, remote := range remotes { if i != 0 { fmt.Println() } ShowRedactedRemote(remote) } } // EditConfig edits the config file interactively func EditConfig(ctx context.Context) (err error) { for { haveRemotes := len(LoadedData().GetSectionList()) != 0 what := []string{"eEdit existing remote", "nNew remote", "dDelete remote", "rRename remote", "cCopy remote", "sSet configuration password", "qQuit config"} if haveRemotes { fmt.Printf("Current remotes:\n\n") ShowRemotes() fmt.Printf("\n") } else { fmt.Printf("No remotes found, make a new one?\n") // take 2nd item and last 2 items of menu list what = append(what[1:2], what[len(what)-2:]...) } switch i := Command(what); i { case 'e': newSection() name := ChooseRemote() newSection() fs := mustFindByName(name) err = EditRemote(ctx, fs, name) if err != nil { return err } case 'n': newSection() name := NewRemoteName() newSection() err = NewRemote(ctx, name) if err != nil { return err } case 'd': newSection() name := ChooseRemote() newSection() DeleteRemote(name) case 'r': newSection() name := ChooseRemote() newSection() RenameRemote(name) case 'c': newSection() name := ChooseRemote() newSection() CopyRemote(name) case 's': newSection() SetPassword() case 'q': return nil } newSection() } } // Suppress the confirm prompts by altering the context config func suppressConfirm(ctx context.Context) context.Context { newCtx, ci := fs.AddConfig(ctx) ci.AutoConfirm = true return newCtx } // checkPassword normalises and validates the password func checkPassword(password string) (string, error) { if !utf8.ValidString(password) { return "", errors.New("password contains invalid utf8 characters") } // Check for leading/trailing whitespace trimmedPassword := strings.TrimSpace(password) // Warn user if password has leading+trailing whitespace if len(password) != len(trimmedPassword) { _, _ = fmt.Fprintln(os.Stderr, "Your password contains leading/trailing whitespace - in previous versions of rclone this was stripped") } // Normalize to reduce weird variations. password = norm.NFKC.String(password) if len(password) == 0 || len(trimmedPassword) == 0 { return "", errors.New("no characters in password") } return password, nil } // GetPassword asks the user for a password with the prompt given. func GetPassword(prompt string) string { _, _ = fmt.Fprintln(PasswordPromptOutput, prompt) for { _, _ = fmt.Fprint(PasswordPromptOutput, "password:") password := ReadPassword() password, err := checkPassword(password) if err == nil { return password } _, _ = fmt.Fprintf(os.Stderr, "Bad password: %v\n", err) } } // ChangePassword will query the user twice for the named password. If // the same password is entered it is returned. func ChangePassword(name string) string { for { a := GetPassword(fmt.Sprintf("Enter %s password:", name)) b := GetPassword(fmt.Sprintf("Confirm %s password:", name)) if a == b { return a } fmt.Println("Passwords do not match!") } } // SetPassword will allow the user to modify the current // configuration encryption settings. func SetPassword() { for { if len(configKey) > 0 { fmt.Println("Your configuration is encrypted.") what := []string{"cChange Password", "uUnencrypt configuration", "qQuit to main menu"} switch i := Command(what); i { case 'c': ChangeConfigPasswordAndSave() fmt.Println("Password changed") continue case 'u': RemoveConfigPasswordAndSave() continue case 'q': return } } else { fmt.Println("Your configuration is not encrypted.") fmt.Println("If you add a password, you will protect your login information to cloud services.") what := []string{"aAdd Password", "qQuit to main menu"} switch i := Command(what); i { case 'a': ChangeConfigPasswordAndSave() fmt.Println("Password set") continue case 'q': return } } } } rclone-v1.71.0/fs/config/ui_test.go000066400000000000000000000432721505210326400171360ustar00rootroot00000000000000// These are in an external package because we need to import configfile // // Internal tests are in ui_internal_test.go package config_test import ( "context" "fmt" "os" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configfile" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/fs/rc" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var simpleOptions = []fs.Option{{ Name: "bool", Default: false, IsPassword: false, }, { Name: "pass", Default: "", IsPassword: true, }} func testConfigFile(t *testing.T, options []fs.Option, configFileName string) func() { ctx := context.Background() ci := fs.GetConfig(ctx) config.ClearConfigPassword() _ = os.Unsetenv("_RCLONE_CONFIG_KEY_FILE") _ = os.Unsetenv("RCLONE_CONFIG_PASS") // create temp config file tempFile, err := os.CreateTemp("", configFileName) assert.NoError(t, err) path := tempFile.Name() assert.NoError(t, tempFile.Close()) // temporarily adapt configuration oldOsStdout := os.Stdout oldConfigPath := config.GetConfigPath() oldConfig := *ci oldConfigFile := config.Data() oldReadLine := config.ReadLine oldPassword := config.Password os.Stdout = nil assert.NoError(t, config.SetConfigPath(path)) ci = &fs.ConfigInfo{} configfile.Install() assert.Equal(t, []string{}, config.Data().GetSectionList()) // Fake a filesystem/backend backendName := "config_test_remote" if regInfo, _ := fs.Find(backendName); regInfo != nil { regInfo.Options = options } else { fs.Register(&fs.RegInfo{ Name: backendName, Options: options, }) } // Undo the above (except registered backend, unfortunately) return func() { err := os.Remove(path) assert.NoError(t, err) os.Stdout = oldOsStdout assert.NoError(t, config.SetConfigPath(oldConfigPath)) config.ReadLine = oldReadLine config.Password = oldPassword *ci = oldConfig config.SetData(oldConfigFile) _ = os.Unsetenv("_RCLONE_CONFIG_KEY_FILE") _ = os.Unsetenv("RCLONE_CONFIG_PASS") } } // makeReadLine makes a simple readLine which returns a fixed list of // strings func makeReadLine(answers []string) func(string) string { i := 0 return func(string) string { i++ return answers[i-1] } } func TestCRUD(t *testing.T) { defer testConfigFile(t, simpleOptions, "crud.conf")() ctx := context.Background() // script for creating remote config.ReadLine = makeReadLine([]string{ "config_test_remote", // type "true", // bool value "y", // type my own password "secret", // password "secret", // repeat "n", // don't edit advanced config "y", // looks good, save }) require.NoError(t, config.NewRemote(ctx, "test")) assert.Equal(t, []string{"test"}, config.Data().GetSectionList()) assert.Equal(t, "config_test_remote", config.GetValue("test", "type")) assert.Equal(t, "true", config.GetValue("test", "bool")) assert.Equal(t, "secret", obscure.MustReveal(config.GetValue("test", "pass"))) // normal rename, test → asdf config.ReadLine = makeReadLine([]string{ "asdf", "asdf", "asdf", }) config.RenameRemote("test") assert.Equal(t, []string{"asdf"}, config.Data().GetSectionList()) assert.Equal(t, "config_test_remote", config.GetValue("asdf", "type")) assert.Equal(t, "true", config.GetValue("asdf", "bool")) assert.Equal(t, "secret", obscure.MustReveal(config.GetValue("asdf", "pass"))) // delete remote config.DeleteRemote("asdf") assert.Equal(t, []string{}, config.Data().GetSectionList()) } func TestChooseOption(t *testing.T) { defer testConfigFile(t, simpleOptions, "crud.conf")() ctx := context.Background() // script for creating remote config.ReadLine = makeReadLine([]string{ "config_test_remote", // type "false", // bool value "x", // bad choice "g", // generate password "1024", // very big "y", // password OK "y", // looks good, save }) config.Password = func(bits int) (string, error) { assert.Equal(t, 1024, bits) return "not very random password", nil } require.NoError(t, config.NewRemote(ctx, "test")) assert.Equal(t, "", config.GetValue("test", "bool")) // this is the default now assert.Equal(t, "not very random password", obscure.MustReveal(config.GetValue("test", "pass"))) // script for creating remote config.ReadLine = makeReadLine([]string{ "config_test_remote", // type "true", // bool value "n", // not required "y", // looks good, save }) require.NoError(t, config.NewRemote(ctx, "test")) assert.Equal(t, "true", config.GetValue("test", "bool")) assert.Equal(t, "", config.GetValue("test", "pass")) } func TestNewRemoteName(t *testing.T) { defer testConfigFile(t, simpleOptions, "crud.conf")() ctx := context.Background() // script for creating remote config.ReadLine = makeReadLine([]string{ "config_test_remote", // type "true", // bool value "n", // not required "y", // looks good, save }) require.NoError(t, config.NewRemote(ctx, "test")) config.ReadLine = makeReadLine([]string{ "test", // already exists "", // empty string not allowed "bad^characters", // bad characters "newname", // OK }) assert.Equal(t, "newname", config.NewRemoteName()) } func TestCreateUpdatePasswordRemote(t *testing.T) { ctx := context.Background() defer testConfigFile(t, simpleOptions, "update.conf")() for _, doObscure := range []bool{false, true} { for _, noObscure := range []bool{false, true} { if doObscure && noObscure { break } t.Run(fmt.Sprintf("doObscure=%v,noObscure=%v", doObscure, noObscure), func(t *testing.T) { opt := config.UpdateRemoteOpt{ Obscure: doObscure, NoObscure: noObscure, } _, err := config.CreateRemote(ctx, "test2", "config_test_remote", rc.Params{ "bool": true, "pass": "potato", }, opt) require.NoError(t, err) assert.Equal(t, []string{"test2"}, config.Data().GetSectionList()) assert.Equal(t, "config_test_remote", config.GetValue("test2", "type")) assert.Equal(t, "true", config.GetValue("test2", "bool")) gotPw := config.GetValue("test2", "pass") if !noObscure { gotPw = obscure.MustReveal(gotPw) } assert.Equal(t, "potato", gotPw) wantPw := obscure.MustObscure("potato2") _, err = config.UpdateRemote(ctx, "test2", rc.Params{ "bool": false, "pass": wantPw, "spare": "spare", }, opt) require.NoError(t, err) assert.Equal(t, []string{"test2"}, config.Data().GetSectionList()) assert.Equal(t, "config_test_remote", config.GetValue("test2", "type")) assert.Equal(t, "false", config.GetValue("test2", "bool")) gotPw = config.GetValue("test2", "pass") if doObscure { gotPw = obscure.MustReveal(gotPw) } assert.Equal(t, wantPw, gotPw) require.NoError(t, config.PasswordRemote(ctx, "test2", rc.Params{ "pass": "potato3", })) assert.Equal(t, []string{"test2"}, config.Data().GetSectionList()) assert.Equal(t, "config_test_remote", config.GetValue("test2", "type")) assert.Equal(t, "false", config.GetValue("test2", "bool")) assert.Equal(t, "potato3", obscure.MustReveal(config.GetValue("test2", "pass"))) }) } } } func TestDefaultRequired(t *testing.T) { // By default options are optional (sic), regardless if a default value is defined. // Setting Required=true means empty string is no longer allowed, except when // a default value is set: Default value means empty string is always allowed! options := []fs.Option{{ Name: "string_required", Required: true, }, { Name: "string_default", Default: "AAA", }, { Name: "string_required_default", Default: "BBB", Required: true, }} defer testConfigFile(t, options, "crud.conf")() ctx := context.Background() // script for creating remote config.ReadLine = makeReadLine([]string{ "config_test_remote", // type "111", // string_required "222", // string_default "333", // string_required_default "y", // looks good, save }) require.NoError(t, config.NewRemote(ctx, "test")) assert.Equal(t, []string{"test"}, config.Data().GetSectionList()) assert.Equal(t, "config_test_remote", config.GetValue("test", "type")) assert.Equal(t, "111", config.GetValue("test", "string_required")) assert.Equal(t, "222", config.GetValue("test", "string_default")) assert.Equal(t, "333", config.GetValue("test", "string_required_default")) // delete remote config.DeleteRemote("test") assert.Equal(t, []string{}, config.Data().GetSectionList()) // script for creating remote config.ReadLine = makeReadLine([]string{ "config_test_remote", // type "", // string_required - invalid (empty string not allowed) "111", // string_required - valid "", // string_default (empty string allowed, means use default) "", // string_required_default (empty string allowed, means use default) "y", // looks good, save }) require.NoError(t, config.NewRemote(ctx, "test")) assert.Equal(t, []string{"test"}, config.Data().GetSectionList()) assert.Equal(t, "config_test_remote", config.GetValue("test", "type")) assert.Equal(t, "111", config.GetValue("test", "string_required")) assert.Equal(t, "", config.GetValue("test", "string_default")) assert.Equal(t, "", config.GetValue("test", "string_required_default")) } func TestMultipleChoice(t *testing.T) { // Multiple-choice options can be set to the number of a predefined choice, or // its text. Unless Exclusive=true, tested later, any free text input is accepted. // // By default options are optional, regardless if a default value is defined. // Setting Required=true means empty string is no longer allowed, except when // a default value is set: Default value means empty string is always allowed! options := []fs.Option{{ Name: "multiple_choice", Examples: []fs.OptionExample{{ Value: "AAA", Help: "This is value AAA", }, { Value: "BBB", Help: "This is value BBB", }, { Value: "CCC", Help: "This is value CCC", }}, }, { Name: "multiple_choice_required", Required: true, Examples: []fs.OptionExample{{ Value: "AAA", Help: "This is value AAA", }, { Value: "BBB", Help: "This is value BBB", }, { Value: "CCC", Help: "This is value CCC", }}, }, { Name: "multiple_choice_default", Default: "BBB", Examples: []fs.OptionExample{{ Value: "AAA", Help: "This is value AAA", }, { Value: "BBB", Help: "This is value BBB", }, { Value: "CCC", Help: "This is value CCC", }}, }, { Name: "multiple_choice_required_default", Required: true, Default: "BBB", Examples: []fs.OptionExample{{ Value: "AAA", Help: "This is value AAA", }, { Value: "BBB", Help: "This is value BBB", }, { Value: "CCC", Help: "This is value CCC", }}, }} defer testConfigFile(t, options, "crud.conf")() ctx := context.Background() // script for creating remote config.ReadLine = makeReadLine([]string{ "config_test_remote", // type "3", // multiple_choice "3", // multiple_choice_required "3", // multiple_choice_default "3", // multiple_choice_required_default "y", // looks good, save }) require.NoError(t, config.NewRemote(ctx, "test")) assert.Equal(t, []string{"test"}, config.Data().GetSectionList()) assert.Equal(t, "config_test_remote", config.GetValue("test", "type")) assert.Equal(t, "CCC", config.GetValue("test", "multiple_choice")) assert.Equal(t, "CCC", config.GetValue("test", "multiple_choice_required")) assert.Equal(t, "CCC", config.GetValue("test", "multiple_choice_default")) assert.Equal(t, "CCC", config.GetValue("test", "multiple_choice_required_default")) // delete remote config.DeleteRemote("test") assert.Equal(t, []string{}, config.Data().GetSectionList()) // script for creating remote config.ReadLine = makeReadLine([]string{ "config_test_remote", // type "XXX", // multiple_choice "XXX", // multiple_choice_required "XXX", // multiple_choice_default "XXX", // multiple_choice_required_default "y", // looks good, save }) require.NoError(t, config.NewRemote(ctx, "test")) assert.Equal(t, []string{"test"}, config.Data().GetSectionList()) assert.Equal(t, "config_test_remote", config.GetValue("test", "type")) assert.Equal(t, "XXX", config.GetValue("test", "multiple_choice")) assert.Equal(t, "XXX", config.GetValue("test", "multiple_choice_required")) assert.Equal(t, "XXX", config.GetValue("test", "multiple_choice_default")) assert.Equal(t, "XXX", config.GetValue("test", "multiple_choice_required_default")) // delete remote config.DeleteRemote("test") assert.Equal(t, []string{}, config.Data().GetSectionList()) // script for creating remote config.ReadLine = makeReadLine([]string{ "config_test_remote", // type "", // multiple_choice (empty string allowed) "", // multiple_choice_required - invalid (empty string not allowed) "XXX", // multiple_choice_required - valid (value not restricted to examples) "", // multiple_choice_default (empty string allowed) "", // multiple_choice_required_default (required does nothing when default is set) "y", // looks good, save }) require.NoError(t, config.NewRemote(ctx, "test")) assert.Equal(t, []string{"test"}, config.Data().GetSectionList()) assert.Equal(t, "config_test_remote", config.GetValue("test", "type")) assert.Equal(t, "", config.GetValue("test", "multiple_choice")) assert.Equal(t, "XXX", config.GetValue("test", "multiple_choice_required")) assert.Equal(t, "", config.GetValue("test", "multiple_choice_default")) assert.Equal(t, "", config.GetValue("test", "multiple_choice_required_default")) } func TestMultipleChoiceExclusive(t *testing.T) { // Setting Exclusive=true on multiple-choice option means any input // value must be from the predefined list, but empty string is allowed. // Setting a default value makes no difference. options := []fs.Option{{ Name: "multiple_choice_exclusive", Exclusive: true, Examples: []fs.OptionExample{{ Value: "AAA", Help: "This is value AAA", }, { Value: "BBB", Help: "This is value BBB", }, { Value: "CCC", Help: "This is value CCC", }}, }, { Name: "multiple_choice_exclusive_default", Exclusive: true, Default: "CCC", Examples: []fs.OptionExample{{ Value: "AAA", Help: "This is value AAA", }, { Value: "BBB", Help: "This is value BBB", }, { Value: "CCC", Help: "This is value CCC", }}, }} defer testConfigFile(t, options, "crud.conf")() ctx := context.Background() // script for creating remote config.ReadLine = makeReadLine([]string{ "config_test_remote", // type "XXX", // multiple_choice_exclusive - invalid (not a value from examples) "", // multiple_choice_exclusive - valid (empty string allowed) "YYY", // multiple_choice_exclusive_default - invalid (not a value from examples) "", // multiple_choice_exclusive_default - valid (empty string allowed) "y", // looks good, save }) require.NoError(t, config.NewRemote(ctx, "test")) assert.Equal(t, []string{"test"}, config.Data().GetSectionList()) assert.Equal(t, "config_test_remote", config.GetValue("test", "type")) assert.Equal(t, "", config.GetValue("test", "multiple_choice_exclusive")) assert.Equal(t, "", config.GetValue("test", "multiple_choice_exclusive_default")) } func TestMultipleChoiceExclusiveRequired(t *testing.T) { // Setting Required=true together with Exclusive=true on multiple-choice option // means empty string is no longer allowed, except when a default value is set // (default value means empty string is always allowed). options := []fs.Option{{ Name: "multiple_choice_exclusive_required", Exclusive: true, Required: true, Examples: []fs.OptionExample{{ Value: "AAA", Help: "This is value AAA", }, { Value: "BBB", Help: "This is value BBB", }, { Value: "CCC", Help: "This is value CCC", }}, }, { Name: "multiple_choice_exclusive_required_default", Exclusive: true, Required: true, Default: "CCC", Examples: []fs.OptionExample{{ Value: "AAA", Help: "This is value AAA", }, { Value: "BBB", Help: "This is value BBB", }, { Value: "CCC", Help: "This is value CCC", }}, }} defer testConfigFile(t, options, "crud.conf")() ctx := context.Background() // script for creating remote config.ReadLine = makeReadLine([]string{ "config_test_remote", // type "XXX", // multiple_choice_exclusive_required - invalid (not a value from examples) "", // multiple_choice_exclusive_required - invalid (empty string not allowed) "CCC", // multiple_choice_exclusive_required - valid "XXX", // multiple_choice_exclusive_required_default - invalid (not a value from examples) "", // multiple_choice_exclusive_required_default - valid (empty string allowed) "y", // looks good, save }) require.NoError(t, config.NewRemote(ctx, "test")) assert.Equal(t, []string{"test"}, config.Data().GetSectionList()) assert.Equal(t, "config_test_remote", config.GetValue("test", "type")) assert.Equal(t, "CCC", config.GetValue("test", "multiple_choice_exclusive_required")) assert.Equal(t, "", config.GetValue("test", "multiple_choice_exclusive_required_default")) } rclone-v1.71.0/fs/config_list.go000066400000000000000000000037711505210326400165150ustar00rootroot00000000000000package fs import ( "bytes" "encoding/csv" "fmt" ) // CommaSepList is a comma separated config value // It uses the encoding/csv rules for quoting and escaping type CommaSepList []string // SpaceSepList is a space separated config value // It uses the encoding/csv rules for quoting and escaping type SpaceSepList []string type genericList []string func (l CommaSepList) String() string { return genericList(l).string(',') } // Set the List entries func (l *CommaSepList) Set(s string) error { return (*genericList)(l).set(',', []byte(s)) } // Type of the value func (CommaSepList) Type() string { return "CommaSepList" } // Scan implements the fmt.Scanner interface func (l *CommaSepList) Scan(s fmt.ScanState, ch rune) error { return (*genericList)(l).scan(',', s, ch) } func (l SpaceSepList) String() string { return genericList(l).string(' ') } // Set the List entries func (l *SpaceSepList) Set(s string) error { return (*genericList)(l).set(' ', []byte(s)) } // Type of the value func (SpaceSepList) Type() string { return "SpaceSepList" } // Scan implements the fmt.Scanner interface func (l *SpaceSepList) Scan(s fmt.ScanState, ch rune) error { return (*genericList)(l).scan(' ', s, ch) } func (gl genericList) string(sep rune) string { var buf bytes.Buffer w := csv.NewWriter(&buf) w.Comma = sep err := w.Write(gl) if err != nil { // can only happen if w.Comma is invalid panic(err) } w.Flush() return string(bytes.TrimSpace(buf.Bytes())) } func (gl *genericList) set(sep rune, b []byte) error { if len(b) == 0 { *gl = nil return nil } r := csv.NewReader(bytes.NewReader(b)) r.Comma = sep record, err := r.Read() switch _err := err.(type) { case nil: *gl = record case *csv.ParseError: err = _err.Err // remove line numbers from the error message } return err } func (gl *genericList) scan(sep rune, s fmt.ScanState, ch rune) error { token, err := s.Token(true, func(rune) bool { return true }) if err != nil { return err } return gl.set(sep, bytes.TrimSpace(token)) } rclone-v1.71.0/fs/config_list_test.go000066400000000000000000000045101505210326400175440ustar00rootroot00000000000000package fs import ( "fmt" "testing" "github.com/stretchr/testify/require" ) func must(err error) { if err != nil { panic(err) } } func ExampleSpaceSepList() { for _, s := range []string{ `remotea:test/dir remoteb:`, `"remotea:test/space dir" remoteb:`, `"remotea:test/quote""dir" remoteb:`, } { var l SpaceSepList must(l.Set(s)) fmt.Printf("%#v\n", l) } // Output: // fs.SpaceSepList{"remotea:test/dir", "remoteb:"} // fs.SpaceSepList{"remotea:test/space dir", "remoteb:"} // fs.SpaceSepList{"remotea:test/quote\"dir", "remoteb:"} } func ExampleCommaSepList() { for _, s := range []string{ `remotea:test/dir,remoteb:`, `"remotea:test/space dir",remoteb:`, `"remotea:test/quote""dir",remoteb:`, } { var l CommaSepList must(l.Set(s)) fmt.Printf("%#v\n", l) } // Output: // fs.CommaSepList{"remotea:test/dir", "remoteb:"} // fs.CommaSepList{"remotea:test/space dir", "remoteb:"} // fs.CommaSepList{"remotea:test/quote\"dir", "remoteb:"} } func TestSpaceSepListSet(t *testing.T) { type tc struct { in string out SpaceSepList err string } tests := []tc{ {``, nil, ""}, {`\`, SpaceSepList{`\`}, ""}, {`\\`, SpaceSepList{`\\`}, ""}, {`potato`, SpaceSepList{`potato`}, ""}, {`po\tato`, SpaceSepList{`po\tato`}, ""}, {`potato\`, SpaceSepList{`potato\`}, ""}, {`'potato`, SpaceSepList{`'potato`}, ""}, {`pot'ato`, SpaceSepList{`pot'ato`}, ""}, {`potato'`, SpaceSepList{`potato'`}, ""}, {`"potato"`, SpaceSepList{`potato`}, ""}, {`'potato'`, SpaceSepList{`'potato'`}, ""}, {`potato apple`, SpaceSepList{`potato`, `apple`}, ""}, {`potato\ apple`, SpaceSepList{`potato\`, `apple`}, ""}, {`"potato apple"`, SpaceSepList{`potato apple`}, ""}, {`"potato'apple"`, SpaceSepList{`potato'apple`}, ""}, {`"potato''apple"`, SpaceSepList{`potato''apple`}, ""}, {`"potato' 'apple"`, SpaceSepList{`potato' 'apple`}, ""}, {`potato="apple"`, nil, `bare " in non-quoted-field`}, {`apple "potato`, nil, "extraneous"}, {`apple pot"ato`, nil, "bare \" in non-quoted-field"}, {`potato"`, nil, "bare \" in non-quoted-field"}, } for _, tc := range tests { var l SpaceSepList err := l.Set(tc.in) if tc.err == "" { require.NoErrorf(t, err, "input: %q", tc.in) } else { require.Containsf(t, err.Error(), tc.err, "input: %q", tc.in) } require.Equalf(t, tc.out, l, "input: %q", tc.in) } } rclone-v1.71.0/fs/config_test.go000066400000000000000000000014251505210326400165130ustar00rootroot00000000000000package fs import ( "context" "testing" "github.com/stretchr/testify/assert" ) func TestGetConfig(t *testing.T) { ctx := context.Background() // Check nil //lint:ignore SA1012 false positive when running staticcheck, we want to test passing a nil Context and therefore ignore lint suggestion to use context.TODO //nolint:staticcheck // Don't include staticcheck when running golangci-lint to avoid SA1012 config := GetConfig(nil) assert.Equal(t, globalConfig, config) // Check empty config config = GetConfig(ctx) assert.Equal(t, globalConfig, config) // Check adding a config ctx2, config2 := AddConfig(ctx) config2.Transfers++ assert.NotEqual(t, config2, config) // Check can get config back config2ctx := GetConfig(ctx2) assert.Equal(t, config2, config2ctx) } rclone-v1.71.0/fs/configmap.go000066400000000000000000000102261505210326400161510ustar00rootroot00000000000000// Getters and Setters for ConfigMap package fs import ( "os" "github.com/rclone/rclone/fs/config/configmap" ) // A configmap.Getter to read from the environment RCLONE_CONFIG_backend_option_name type configEnvVars string // Get a config item from the environment variables if possible func (configName configEnvVars) Get(key string) (value string, ok bool) { envKey := ConfigToEnv(string(configName), key) value, ok = os.LookupEnv(envKey) if ok { Debugf(nil, "Setting %s=%q for %q from environment variable %s", key, value, configName, envKey) } return value, ok } // A configmap.Getter to read from the environment RCLONE_option_name type optionEnvVars struct { prefix string options Options } // Get a config item from the option environment variables if possible func (oev optionEnvVars) Get(key string) (value string, ok bool) { opt := oev.options.Get(key) if opt == nil { return "", false } var envKey string if oev.prefix == "" { envKey = OptionToEnv(key) } else { envKey = OptionToEnv(oev.prefix + "-" + key) } value, ok = os.LookupEnv(envKey) if ok { Debugf(nil, "Setting %s %s=%q from environment variable %s", oev.prefix, key, value, envKey) } else if opt.NoPrefix { // For options with NoPrefix set, check without prefix too envKey := OptionToEnv(key) value, ok = os.LookupEnv(envKey) if ok { Debugf(nil, "Setting %s=%q for %s from environment variable %s", key, value, oev.prefix, envKey) } } return value, ok } // A configmap.Getter to read either the default value or the set // value from the RegInfo.Options type regInfoValues struct { options Options useDefault bool } // override the values in configMap with the either the flag values or // the default values func (r *regInfoValues) Get(key string) (value string, ok bool) { opt := r.options.Get(key) if opt != nil && (r.useDefault || !opt.IsDefault()) { return opt.String(), true } return "", false } // A configmap.Setter to read from the config file type setConfigFile string // Set a config item into the config file func (section setConfigFile) Set(key, value string) { Debugf(nil, "Saving config %q in section %q of the config file", key, section) err := ConfigFileSet(string(section), key, value) if err != nil { Errorf(nil, "Failed saving config %q in section %q of the config file: %v", key, section, err) } } // A configmap.Getter to read from the config file type getConfigFile string // Get a config item from the config file func (section getConfigFile) Get(key string) (value string, ok bool) { value, ok = ConfigFileGet(string(section), key) // Ignore empty lines in the config file if value == "" { ok = false } return value, ok } // ConfigMap creates a configmap.Map from the Options, prefix and the // configName passed in. If connectionStringConfig has any entries (it may be nil), // then it will be added to the lookup with the highest priority. // // If options is nil then the returned configmap.Map should only be // used for reading non backend specific parameters, such as "type". // // This can be used for global settings if prefix is "" and configName is "" func ConfigMap(prefix string, options Options, configName string, connectionStringConfig configmap.Simple) (config *configmap.Map) { // Create the config config = configmap.New() // Read the config, more specific to least specific // Config from connection string if len(connectionStringConfig) > 0 { config.AddGetter(connectionStringConfig, configmap.PriorityNormal) } // flag values if options != nil { config.AddGetter(®InfoValues{options, false}, configmap.PriorityNormal) } // remote specific environment vars if configName != "" { config.AddGetter(configEnvVars(configName), configmap.PriorityNormal) } // backend specific environment vars if options != nil { config.AddGetter(optionEnvVars{prefix: prefix, options: options}, configmap.PriorityNormal) } // config file if configName != "" { config.AddGetter(getConfigFile(configName), configmap.PriorityConfig) } // default values if options != nil { config.AddGetter(®InfoValues{options, true}, configmap.PriorityDefault) } // Set Config config.AddSetter(setConfigFile(configName)) return config } rclone-v1.71.0/fs/countsuffix.go000066400000000000000000000103741505210326400165670ustar00rootroot00000000000000package fs // CountSuffix is parsed by flag with k/M/G decimal suffixes import ( "errors" "fmt" "math" "sort" "strconv" "strings" ) // CountSuffix is an int64 with a friendly way of printing setting type CountSuffix int64 // Common multipliers for SizeSuffix const ( CountSuffixBase CountSuffix = 1 Kilo = 1000 * CountSuffixBase Mega = 1000 * Kilo Giga = 1000 * Mega Tera = 1000 * Giga Peta = 1000 * Tera Exa = 1000 * Peta ) const ( // CountSuffixMax is the largest CountSuffix multiplier CountSuffixMax = Exa // CountSuffixMaxValue is the largest value that can be used to create CountSuffix CountSuffixMaxValue = math.MaxInt64 // CountSuffixMinValue is the smallest value that can be used to create CountSuffix CountSuffixMinValue = math.MinInt64 ) // Turn CountSuffix into a string and a suffix func (x CountSuffix) string() (string, string) { scaled := float64(0) suffix := "" switch { case x < 0: return "off", "" case x == 0: return "0", "" case x < Kilo: scaled = float64(x) suffix = "" case x < Mega: scaled = float64(x) / float64(Kilo) suffix = "k" case x < Giga: scaled = float64(x) / float64(Mega) suffix = "M" case x < Tera: scaled = float64(x) / float64(Giga) suffix = "G" case x < Peta: scaled = float64(x) / float64(Tera) suffix = "T" case x < Exa: scaled = float64(x) / float64(Peta) suffix = "P" default: scaled = float64(x) / float64(Exa) suffix = "E" } if math.Floor(scaled) == scaled { return fmt.Sprintf("%.0f", scaled), suffix } return fmt.Sprintf("%.3f", scaled), suffix } // String turns CountSuffix into a string func (x CountSuffix) String() string { val, suffix := x.string() return val + suffix } // Unit turns CountSuffix into a string with a unit func (x CountSuffix) Unit(unit string) string { val, suffix := x.string() if val == "off" { return val } return val + " " + suffix + unit } func (x *CountSuffix) multiplierFromSymbol(s byte) (found bool, multiplier float64) { switch s { case 'k', 'K': return true, float64(Kilo) case 'm', 'M': return true, float64(Mega) case 'g', 'G': return true, float64(Giga) case 't', 'T': return true, float64(Tera) case 'p', 'P': return true, float64(Peta) case 'e', 'E': return true, float64(Exa) default: return false, float64(CountSuffixBase) } } // Set a CountSuffix func (x *CountSuffix) Set(s string) error { if len(s) == 0 { return errors.New("empty string") } if strings.ToLower(s) == "off" { *x = -1 return nil } suffix := s[len(s)-1] suffixLen := 1 multiplierFound := false var multiplier float64 switch suffix { case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.': suffixLen = 0 multiplier = float64(Kilo) case 'b', 'B': if len(s) > 1 { suffix = s[len(s)-2] if multiplierFound, multiplier = x.multiplierFromSymbol(suffix); multiplierFound { suffixLen = 2 } } else { multiplier = float64(CountSuffixBase) } default: if multiplierFound, multiplier = x.multiplierFromSymbol(suffix); !multiplierFound { return fmt.Errorf("bad suffix %q", suffix) } } s = s[:len(s)-suffixLen] value, err := strconv.ParseFloat(s, 64) if err != nil { return err } if value < 0 { return fmt.Errorf("size can't be negative %q", s) } value *= multiplier *x = CountSuffix(value) return nil } // Type of the value func (x CountSuffix) Type() string { return "CountSuffix" } // Scan implements the fmt.Scanner interface func (x *CountSuffix) Scan(s fmt.ScanState, ch rune) error { token, err := s.Token(true, nil) if err != nil { return err } return x.Set(string(token)) } // CountSuffixList is a slice CountSuffix values type CountSuffixList []CountSuffix func (l CountSuffixList) Len() int { return len(l) } func (l CountSuffixList) Swap(i, j int) { l[i], l[j] = l[j], l[i] } func (l CountSuffixList) Less(i, j int) bool { return l[i] < l[j] } // Sort sorts the list func (l CountSuffixList) Sort() { sort.Sort(l) } // UnmarshalJSON makes sure the value can be parsed as a string or integer in JSON func (x *CountSuffix) UnmarshalJSON(in []byte) error { return UnmarshalJSONFlag(in, x, func(i int64) error { *x = CountSuffix(i) return nil }) } rclone-v1.71.0/fs/countsuffix_test.go000066400000000000000000000063431505210326400176270ustar00rootroot00000000000000package fs import ( "encoding/json" "fmt" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Check it satisfies the interfaces var ( _ Flagger = (*CountSuffix)(nil) _ FlaggerNP = CountSuffix(0) ) func TestCountSuffixString(t *testing.T) { for _, test := range []struct { in float64 want string }{ {0, "0"}, {102, "102"}, {1000, "1k"}, {1000 * 1000, "1M"}, {1000 * 1000 * 1000, "1G"}, {10 * 1000 * 1000 * 1000, "10G"}, {10.1 * 1000 * 1000 * 1000, "10.100G"}, {-1, "off"}, {-100, "off"}, } { ss := CountSuffix(test.in) got := ss.String() assert.Equal(t, test.want, got) } } func TestCountSuffixUnit(t *testing.T) { for _, test := range []struct { in float64 want string }{ {0, "0 Byte"}, {102, "102 Byte"}, {1000, "1 kByte"}, {1000 * 1000, "1 MByte"}, {1000 * 1000 * 1000, "1 GByte"}, {10 * 1000 * 1000 * 1000, "10 GByte"}, {10.1 * 1000 * 1000 * 1000, "10.100 GByte"}, {10 * 1000 * 1000 * 1000 * 1000, "10 TByte"}, {10 * 1000 * 1000 * 1000 * 1000 * 1000, "10 PByte"}, {1 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000, "1 EByte"}, {-1, "off"}, {-100, "off"}, } { ss := CountSuffix(test.in) got := ss.Unit("Byte") assert.Equal(t, test.want, got) } } func TestCountSuffixSet(t *testing.T) { for _, test := range []struct { in string want int64 err bool }{ {"0", 0, false}, {"1b", 1, false}, {"100B", 100, false}, {"0.1k", 100, false}, {"0.1", 100, false}, {"1K", 1000, false}, {"1k", 1000, false}, {"1KB", 1000, false}, {"1kB", 1000, false}, {"1kb", 1000, false}, {"1", 1000, false}, {"2.5", 1000 * 2.5, false}, {"1M", 1000 * 1000, false}, {"1MB", 1000 * 1000, false}, {"1.g", 1000 * 1000 * 1000, false}, {"10G", 10 * 1000 * 1000 * 1000, false}, {"10T", 10 * 1000 * 1000 * 1000 * 1000, false}, {"10P", 10 * 1000 * 1000 * 1000 * 1000 * 1000, false}, {"off", -1, false}, {"OFF", -1, false}, {"", 0, true}, {"1q", 0, true}, {"1.q", 0, true}, {"1q", 0, true}, {"-1K", 0, true}, {"1i", 0, true}, {"1iB", 0, true}, {"1Ki", 0, true}, {"1KiB", 0, true}, } { ss := CountSuffix(0) err := ss.Set(test.in) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, int64(ss)) } } func TestCountSuffixScan(t *testing.T) { var v CountSuffix n, err := fmt.Sscan(" 17M ", &v) require.NoError(t, err) assert.Equal(t, 1, n) assert.Equal(t, CountSuffix(17000000), v) } func TestCountSuffixUnmarshalJSON(t *testing.T) { for _, test := range []struct { in string want int64 err bool }{ {`"0"`, 0, false}, {`"102B"`, 102, false}, {`"1K"`, 1000, false}, {`"2.5"`, 1000 * 2.5, false}, {`"1M"`, 1000 * 1000, false}, {`"1.g"`, 1000 * 1000 * 1000, false}, {`"10G"`, 10 * 1000 * 1000 * 1000, false}, {`"off"`, -1, false}, {`""`, 0, true}, {`"1q"`, 0, true}, {`"-1K"`, 0, true}, {`0`, 0, false}, {`102`, 102, false}, {`1000`, 1000, false}, {`1000000000`, 1000000000, false}, {`1.1.1`, 0, true}, } { var ss CountSuffix err := json.Unmarshal([]byte(test.in), &ss) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, int64(ss)) } } rclone-v1.71.0/fs/cutoffmode.go000066400000000000000000000007101505210326400163360ustar00rootroot00000000000000package fs type cutoffModeChoices struct{} func (cutoffModeChoices) Choices() []string { return []string{ CutoffModeHard: "HARD", CutoffModeSoft: "SOFT", CutoffModeCautious: "CAUTIOUS", } } // CutoffMode describes the possible delete modes in the config type CutoffMode = Enum[cutoffModeChoices] // CutoffMode constants const ( CutoffModeHard CutoffMode = iota CutoffModeSoft CutoffModeCautious CutoffModeDefault = CutoffModeHard ) rclone-v1.71.0/fs/cutoffmode_test.go000066400000000000000000000031541505210326400174020ustar00rootroot00000000000000package fs import ( "encoding/json" "strconv" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Check it satisfies the interfaces var ( _ Flagger = (*CutoffMode)(nil) _ FlaggerNP = CutoffMode(0) ) func TestCutoffModeString(t *testing.T) { for _, test := range []struct { in CutoffMode want string }{ {CutoffModeHard, "HARD"}, {CutoffModeSoft, "SOFT"}, {99, "Unknown(99)"}, } { cm := test.in got := cm.String() assert.Equal(t, test.want, got, test.in) } } func TestCutoffModeSet(t *testing.T) { for _, test := range []struct { in string want CutoffMode err bool }{ {"hard", CutoffModeHard, false}, {"SOFT", CutoffModeSoft, false}, {"Cautious", CutoffModeCautious, false}, {"Potato", 0, true}, } { cm := CutoffMode(0) err := cm.Set(test.in) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, cm, test.in) } } func TestCutoffModeUnmarshalJSON(t *testing.T) { for _, test := range []struct { in string want CutoffMode err bool }{ {`"hard"`, CutoffModeHard, false}, {`"SOFT"`, CutoffModeSoft, false}, {`"Cautious"`, CutoffModeCautious, false}, {`"Potato"`, 0, true}, {strconv.Itoa(int(CutoffModeHard)), CutoffModeHard, false}, {strconv.Itoa(int(CutoffModeSoft)), CutoffModeSoft, false}, {`99`, 0, true}, {`-99`, 0, true}, } { var cm CutoffMode err := json.Unmarshal([]byte(test.in), &cm) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, cm, test.in) } } rclone-v1.71.0/fs/daemon_other.go000066400000000000000000000003251505210326400166510ustar00rootroot00000000000000// Daemonization stub for non-Unix platforms (common definitions) //go:build windows || plan9 || js package fs // IsDaemon returns true if this process runs in background func IsDaemon() bool { return false } rclone-v1.71.0/fs/daemon_unix.go000066400000000000000000000006671505210326400165240ustar00rootroot00000000000000// Daemonization interface for Unix platforms (common definitions) //go:build !windows && !plan9 && !js package fs import ( "os" ) // We use a special environment variable to let the child process know its role. const ( DaemonMarkVar = "_RCLONE_DAEMON_" DaemonMarkChild = "_rclone_daemon_" ) // IsDaemon returns true if this process runs in background func IsDaemon() bool { return os.Getenv(DaemonMarkVar) == DaemonMarkChild } rclone-v1.71.0/fs/deletemode.go000066400000000000000000000004171505210326400163160ustar00rootroot00000000000000package fs // DeleteMode describes the possible delete modes in the config type DeleteMode byte // DeleteMode constants const ( DeleteModeOff DeleteMode = iota DeleteModeBefore DeleteModeDuring DeleteModeAfter DeleteModeOnly DeleteModeDefault = DeleteModeAfter ) rclone-v1.71.0/fs/dir.go000066400000000000000000000052261505210326400147700ustar00rootroot00000000000000package fs import ( "context" "time" ) // Dir describes an unspecialized directory for directory/container/bucket lists type Dir struct { f Info // Fs this directory is part of remote string // name of the directory modTime time.Time // modification or creation time - IsZero for unknown size int64 // size of directory and contents or -1 if unknown items int64 // number of objects or -1 for unknown id string // optional ID parent string // optional parent directory ID } // NewDir creates an unspecialized Directory object // // If the modTime is unknown pass in time.Time{} func NewDir(remote string, modTime time.Time) *Dir { return &Dir{ f: Unknown, remote: remote, modTime: modTime, size: -1, items: -1, } } // NewDirCopy creates an unspecialized copy of the Directory object passed in func NewDirCopy(ctx context.Context, d Directory) *Dir { return &Dir{ f: d.Fs(), remote: d.Remote(), modTime: d.ModTime(ctx), size: d.Size(), items: d.Items(), id: d.ID(), } } // Fs returns the Fs that this directory is part of func (d *Dir) Fs() Info { return d.f } // String returns the name func (d *Dir) String() string { return d.remote } // Remote returns the remote path func (d *Dir) Remote() string { return d.remote } // SetRemote sets the remote func (d *Dir) SetRemote(remote string) *Dir { d.remote = remote return d } // ID gets the optional ID func (d *Dir) ID() string { return d.id } // SetID sets the optional ID func (d *Dir) SetID(id string) *Dir { d.id = id return d } // ParentID returns the IDs of the Dir parent if known func (d *Dir) ParentID() string { return d.parent } // SetParentID sets the optional parent ID of the Dir func (d *Dir) SetParentID(parent string) *Dir { d.parent = parent return d } // ModTime returns the modification date of the file // // If one isn't available it returns the configured --default-dir-time func (d *Dir) ModTime(ctx context.Context) time.Time { if !d.modTime.IsZero() { return d.modTime } ci := GetConfig(ctx) return time.Time(ci.DefaultTime) } // Size returns the size of the file func (d *Dir) Size() int64 { return d.size } // SetSize sets the size of the directory func (d *Dir) SetSize(size int64) *Dir { d.size = size return d } // Items returns the count of items in this directory or this // directory and subdirectories if known, -1 for unknown func (d *Dir) Items() int64 { return d.items } // SetItems sets the number of items in the directory func (d *Dir) SetItems(items int64) *Dir { d.items = items return d } // Check interfaces var ( _ DirEntry = (*Dir)(nil) _ Directory = (*Dir)(nil) ) rclone-v1.71.0/fs/dir_wrapper.go000066400000000000000000000052311505210326400165240ustar00rootroot00000000000000package fs import ( "context" "time" ) // DirWrapper wraps a Directory object so the Remote can be overridden type DirWrapper struct { Directory // Directory we are wrapping remote string // name of the directory failSilently bool // if set, ErrorNotImplemented should not be considered an error for this directory } // NewDirWrapper creates a wrapper for a directory object // // This passes through optional methods and should be used for // wrapping backends to wrap native directories. func NewDirWrapper(remote string, d Directory) *DirWrapper { return &DirWrapper{ Directory: d, remote: remote, } } // NewLimitedDirWrapper creates a DirWrapper that should fail silently instead of erroring for ErrorNotImplemented. // // Intended for exceptional dirs lacking abilities that the Fs otherwise usually supports // (ex. a Combine root which can't set metadata/modtime, regardless of support by wrapped backend) func NewLimitedDirWrapper(remote string, d Directory) *DirWrapper { dw := NewDirWrapper(remote, d) dw.failSilently = true return dw } // String returns the name func (d *DirWrapper) String() string { return d.remote } // Remote returns the remote path func (d *DirWrapper) Remote() string { return d.remote } // SetRemote sets the remote func (d *DirWrapper) SetRemote(remote string) *DirWrapper { d.remote = remote return d } // Metadata returns metadata for an DirEntry // // It should return nil if there is no Metadata func (d *DirWrapper) Metadata(ctx context.Context) (Metadata, error) { do, ok := d.Directory.(Metadataer) if !ok { return nil, nil } return do.Metadata(ctx) } // SetMetadata sets metadata for an DirEntry // // It should return fs.ErrorNotImplemented if it can't set metadata func (d *DirWrapper) SetMetadata(ctx context.Context, metadata Metadata) error { do, ok := d.Directory.(SetMetadataer) if !ok { if d.failSilently { Debugf(d, "Can't SetMetadata for this directory (%T from %v) -- skipping", d.Directory, d.Fs()) return nil } return ErrorNotImplemented } return do.SetMetadata(ctx, metadata) } // SetModTime sets the metadata on the DirEntry to set the modification date // // If there is any other metadata it does not overwrite it. func (d *DirWrapper) SetModTime(ctx context.Context, t time.Time) error { do, ok := d.Directory.(SetModTimer) if !ok { if d.failSilently { Debugf(d, "Can't SetModTime for this directory (%T from %v) -- skipping", d.Directory, d.Fs()) return nil } return ErrorNotImplemented } return do.SetModTime(ctx, t) } // Check interfaces var ( _ DirEntry = (*DirWrapper)(nil) _ Directory = (*DirWrapper)(nil) _ FullDirectory = (*DirWrapper)(nil) ) rclone-v1.71.0/fs/direntries.go000066400000000000000000000042301505210326400163540ustar00rootroot00000000000000package fs import "fmt" // DirEntries is a slice of Object or *Dir type DirEntries []DirEntry // Len is part of sort.Interface. func (ds DirEntries) Len() int { return len(ds) } // Swap is part of sort.Interface. func (ds DirEntries) Swap(i, j int) { ds[i], ds[j] = ds[j], ds[i] } // Less is part of sort.Interface. func (ds DirEntries) Less(i, j int) bool { return CompareDirEntries(ds[i], ds[j]) < 0 } // ForObject runs the function supplied on every object in the entries func (ds DirEntries) ForObject(fn func(o Object)) { for _, entry := range ds { o, ok := entry.(Object) if ok { fn(o) } } } // ForObjectError runs the function supplied on every object in the entries func (ds DirEntries) ForObjectError(fn func(o Object) error) error { for _, entry := range ds { o, ok := entry.(Object) if ok { err := fn(o) if err != nil { return err } } } return nil } // ForDir runs the function supplied on every Directory in the entries func (ds DirEntries) ForDir(fn func(dir Directory)) { for _, entry := range ds { dir, ok := entry.(Directory) if ok { fn(dir) } } } // ForDirError runs the function supplied on every Directory in the entries func (ds DirEntries) ForDirError(fn func(dir Directory) error) error { for _, entry := range ds { dir, ok := entry.(Directory) if ok { err := fn(dir) if err != nil { return err } } } return nil } // DirEntryType returns a string description of the DirEntry, either // "object", "directory" or "unknown type XXX" func DirEntryType(d DirEntry) string { switch d.(type) { case Object: return "object" case Directory: return "directory" } return fmt.Sprintf("unknown type %T", d) } // CompareDirEntries returns 1 if a > b, 0 if a == b and -1 if a < b // If two dir entries have the same name, compare their types (directories are before objects) func CompareDirEntries(a, b DirEntry) int { aName := a.Remote() bName := b.Remote() if aName > bName { return 1 } else if aName < bName { return -1 } typeA := DirEntryType(a) typeB := DirEntryType(b) // same name, compare types if typeA > typeB { return 1 } else if typeA < typeB { return -1 } return 0 } rclone-v1.71.0/fs/direntries_test.go000066400000000000000000000011441505210326400174140ustar00rootroot00000000000000package fs_test import ( "sort" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest/mockdir" "github.com/rclone/rclone/fstest/mockobject" "github.com/stretchr/testify/assert" ) func TestDirEntriesSort(t *testing.T) { a := mockobject.New("a") aDir := mockdir.New("a") b := mockobject.New("b") bDir := mockdir.New("b") c := mockobject.New("c") cDir := mockdir.New("c") anotherc := mockobject.New("c") dirEntries := fs.DirEntries{bDir, b, aDir, a, c, cDir, anotherc} sort.Stable(dirEntries) assert.Equal(t, fs.DirEntries{aDir, a, bDir, b, cDir, c, anotherc}, dirEntries) } rclone-v1.71.0/fs/dirtree/000077500000000000000000000000001505210326400153145ustar00rootroot00000000000000rclone-v1.71.0/fs/dirtree/dirtree.go000066400000000000000000000140241505210326400173020ustar00rootroot00000000000000// Package dirtree contains the DirTree type which is used for // building filesystem hierarchies in memory. package dirtree import ( "bytes" "fmt" "path" "sort" "time" "github.com/rclone/rclone/fs" ) // DirTree is a map of directories to entries type DirTree map[string]fs.DirEntries // New returns a fresh DirTree func New() DirTree { return make(DirTree) } // parentDir finds the parent directory of path func parentDir(entryPath string) string { dirPath := path.Dir(entryPath) if dirPath == "." { dirPath = "" } return dirPath } // Add an entry to the tree // it doesn't create parents func (dt DirTree) Add(entry fs.DirEntry) { dirPath := parentDir(entry.Remote()) dt[dirPath] = append(dt[dirPath], entry) } // AddDir adds a directory entry to the tree // this creates the directory itself if required // it doesn't create parents func (dt DirTree) AddDir(entry fs.DirEntry) { dirPath := entry.Remote() if dirPath == "" { return } dt.Add(entry) // create the directory itself if it doesn't exist already if _, ok := dt[dirPath]; !ok { dt[dirPath] = nil } } // AddEntry adds the entry and creates the parents for it regardless // of whether it is a file or a directory. func (dt DirTree) AddEntry(entry fs.DirEntry) { switch entry.(type) { case fs.Directory: dt.AddDir(entry) case fs.Object: dt.Add(entry) default: panic("unknown entry type") } remoteParent := parentDir(entry.Remote()) dt.checkParent("", remoteParent, nil) } // Find returns the DirEntry for filePath or nil if not found // // None that Find does a O(N) search so can be slow func (dt DirTree) Find(filePath string) (parentPath string, entry fs.DirEntry) { parentPath = parentDir(filePath) for _, entry := range dt[parentPath] { if entry.Remote() == filePath { return parentPath, entry } } return parentPath, nil } // checkParent checks that dirPath has a *Dir in its parent // // If dirs is not nil it must contain entries for every *Dir found in // the tree. It is used to speed up the checking when calling this // repeatedly. func (dt DirTree) checkParent(root, dirPath string, dirs map[string]struct{}) { var parentPath string for { if dirPath == root { return } // Can rely on dirs to have all directories in it so // we don't need to call Find. if dirs != nil { if _, found := dirs[dirPath]; found { return } parentPath = parentDir(dirPath) } else { var entry fs.DirEntry parentPath, entry = dt.Find(dirPath) if entry != nil { return } } dt[parentPath] = append(dt[parentPath], fs.NewDir(dirPath, time.Now())) if dirs != nil { dirs[dirPath] = struct{}{} } dirPath = parentPath } } // CheckParents checks every directory in the tree has *Dir in its parent func (dt DirTree) CheckParents(root string) { dirs := make(map[string]struct{}) // Find all the directories and stick them in dirs for _, entries := range dt { for _, entry := range entries { if _, ok := entry.(fs.Directory); ok { dirs[entry.Remote()] = struct{}{} } } } for dirPath := range dt { dt.checkParent(root, dirPath, dirs) } } // Sort sorts all the Entries func (dt DirTree) Sort() { for _, entries := range dt { sort.Stable(entries) } } // Dirs returns the directories in sorted order func (dt DirTree) Dirs() (dirNames []string) { for dirPath := range dt { dirNames = append(dirNames, dirPath) } sort.Strings(dirNames) return dirNames } // Prune remove directories from a directory tree. dirNames contains // all directories to remove as keys, with true as values. dirNames // will be modified in the function. func (dt DirTree) Prune(dirNames map[string]bool) error { // We use map[string]bool to avoid recursion (and potential // stack exhaustion). // First we need delete directories from their parents. for dName, remove := range dirNames { if !remove { // Currently all values should be // true, therefore this should not // happen. But this makes function // more predictable. fs.Infof(dName, "Directory in the map for prune, but the value is false") continue } if dName == "" { // if dName is root, do nothing (no parent exist) continue } parent := parentDir(dName) // It may happen that dt does not have a dName key, // since directory was excluded based on a filter. In // such case the loop will be skipped. for i, entry := range dt[parent] { switch x := entry.(type) { case fs.Directory: if x.Remote() == dName { // the slice is not sorted yet // to delete item // a) replace it with the last one dt[parent][i] = dt[parent][len(dt[parent])-1] // b) remove last dt[parent] = dt[parent][:len(dt[parent])-1] // we modify a slice within a loop, but we stop // iterating immediately break } case fs.Object: // do nothing default: return fmt.Errorf("unknown object type %T", entry) } } } for len(dirNames) > 0 { // According to golang specs, if new keys were added // during range iteration, they may be skipped. for dName, remove := range dirNames { if !remove { fs.Infof(dName, "Directory in the map for prune, but the value is false") continue } // First, add all subdirectories to dirNames. // It may happen that dt[dName] does not exist. // If so, the loop will be skipped. for _, entry := range dt[dName] { switch x := entry.(type) { case fs.Directory: excludeDir := x.Remote() dirNames[excludeDir] = true case fs.Object: // do nothing default: return fmt.Errorf("unknown object type %T", entry) } } // Then remove current directory from DirTree delete(dt, dName) // and from dirNames delete(dirNames, dName) } } return nil } // String emits a simple representation of the DirTree func (dt DirTree) String() string { out := new(bytes.Buffer) for _, dir := range dt.Dirs() { _, _ = fmt.Fprintf(out, "%s/\n", dir) for _, entry := range dt[dir] { flag := "" if _, ok := entry.(fs.Directory); ok { flag = "/" } _, _ = fmt.Fprintf(out, " %s%s\n", path.Base(entry.Remote()), flag) } } return out.String() } rclone-v1.71.0/fs/dirtree/dirtree_test.go000066400000000000000000000074111505210326400203430ustar00rootroot00000000000000package dirtree import ( "fmt" "testing" "github.com/rclone/rclone/fstest/mockdir" "github.com/rclone/rclone/fstest/mockobject" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestNew(t *testing.T) { dt := New() assert.Equal(t, "", dt.String()) } func TestParentDir(t *testing.T) { assert.Equal(t, "root/parent", parentDir("root/parent/file")) assert.Equal(t, "parent", parentDir("parent/file")) assert.Equal(t, "", parentDir("parent")) assert.Equal(t, "", parentDir("")) } func TestDirTreeAdd(t *testing.T) { dt := New() o := mockobject.New("potato") dt.Add(o) assert.Equal(t, `/ potato `, dt.String()) o = mockobject.New("dir/subdir/sausage") dt.Add(o) assert.Equal(t, `/ potato dir/subdir/ sausage `, dt.String()) } func TestDirTreeAddDir(t *testing.T) { dt := New() d := mockdir.New("potato") dt.Add(d) assert.Equal(t, `/ potato/ `, dt.String()) d = mockdir.New("dir/subdir/sausage") dt.AddDir(d) assert.Equal(t, `/ potato/ dir/subdir/ sausage/ dir/subdir/sausage/ `, dt.String()) d = mockdir.New("") dt.AddDir(d) assert.Equal(t, `/ potato/ dir/subdir/ sausage/ dir/subdir/sausage/ `, dt.String()) } func TestDirTreeAddEntry(t *testing.T) { dt := New() d := mockdir.New("dir/subdir/sausagedir") dt.AddEntry(d) o := mockobject.New("dir/subdir2/sausage2") dt.AddEntry(o) assert.Equal(t, `/ dir/ dir/ subdir/ subdir2/ dir/subdir/ sausagedir/ dir/subdir/sausagedir/ dir/subdir2/ sausage2 `, dt.String()) } func TestDirTreeFind(t *testing.T) { dt := New() parent, foundObj := dt.Find("dir/subdir/sausage") assert.Equal(t, "dir/subdir", parent) assert.Nil(t, foundObj) o := mockobject.New("dir/subdir/sausage") dt.Add(o) parent, foundObj = dt.Find("dir/subdir/sausage") assert.Equal(t, "dir/subdir", parent) assert.Equal(t, o, foundObj) } func TestDirTreeCheckParent(t *testing.T) { dt := New() o := mockobject.New("dir/subdir/sausage") dt.Add(o) assert.Equal(t, `dir/subdir/ sausage `, dt.String()) dt.checkParent("", "dir/subdir", nil) assert.Equal(t, `/ dir/ dir/ subdir/ dir/subdir/ sausage `, dt.String()) } func TestDirTreeCheckParents(t *testing.T) { dt := New() dt.Add(mockobject.New("dir/subdir/sausage")) dt.Add(mockobject.New("dir/subdir2/sausage2")) dt.CheckParents("") dt.Sort() // sort since the exact order of adding parents is not defined assert.Equal(t, `/ dir/ dir/ subdir/ subdir2/ dir/subdir/ sausage dir/subdir2/ sausage2 `, dt.String()) } func TestDirTreeSort(t *testing.T) { dt := New() dt.Add(mockobject.New("dir/subdir/B")) dt.Add(mockobject.New("dir/subdir/A")) assert.Equal(t, `dir/subdir/ B A `, dt.String()) dt.Sort() assert.Equal(t, `dir/subdir/ A B `, dt.String()) } func TestDirTreeDirs(t *testing.T) { dt := New() dt.Add(mockobject.New("dir/subdir/sausage")) dt.Add(mockobject.New("dir/subdir2/sausage2")) dt.CheckParents("") assert.Equal(t, []string{ "", "dir", "dir/subdir", "dir/subdir2", }, dt.Dirs()) } func TestDirTreePrune(t *testing.T) { dt := New() dt.Add(mockobject.New("file")) dt.Add(mockobject.New("dir/subdir/sausage")) dt.Add(mockobject.New("dir/subdir2/sausage2")) dt.Add(mockobject.New("dir/file")) dt.Add(mockobject.New("dir2/file")) dt.CheckParents("") err := dt.Prune(map[string]bool{ "dir": true, }) require.NoError(t, err) assert.Equal(t, `/ file dir2/ dir2/ file `, dt.String()) } func BenchmarkCheckParents(b *testing.B) { for _, N := range []int{1e2, 1e3, 1e4, 1e5, 1e6} { b.Run(fmt.Sprintf("%d", N), func(b *testing.B) { b.StopTimer() dt := New() for i := range N { remote := fmt.Sprintf("dir%09d/file%09d.txt", i, 1) o := mockobject.New(remote) dt.Add(o) } b.StartTimer() for n := 0; n < b.N; n++ { dt.CheckParents("") } }) } } rclone-v1.71.0/fs/driveletter/000077500000000000000000000000001505210326400162075ustar00rootroot00000000000000rclone-v1.71.0/fs/driveletter/driveletter.go000066400000000000000000000005321505210326400210670ustar00rootroot00000000000000//go:build !windows // Package driveletter returns whether a name is a valid drive letter package driveletter // IsDriveLetter returns a bool indicating whether name is a valid // Windows drive letter // // On non windows platforms we don't have drive letters so we always // return false func IsDriveLetter(name string) bool { return false } rclone-v1.71.0/fs/driveletter/driveletter_windows.go000066400000000000000000000005411505210326400226410ustar00rootroot00000000000000//go:build windows // Package driveletter returns whether a name is a valid drive letter package driveletter // IsDriveLetter returns a bool indicating whether name is a valid // Windows drive letter func IsDriveLetter(name string) bool { if len(name) != 1 { return false } c := name[0] return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') } rclone-v1.71.0/fs/dump.go000066400000000000000000000015451505210326400151570ustar00rootroot00000000000000package fs // DumpFlags describes the Dump options in force type DumpFlags = Bits[dumpChoices] // DumpFlags definitions const ( DumpHeaders DumpFlags = 1 << iota DumpBodies DumpRequests DumpResponses DumpAuth DumpFilters DumpGoRoutines DumpOpenFiles DumpMapper ) type dumpChoices struct{} func (dumpChoices) Choices() []BitsChoicesInfo { return []BitsChoicesInfo{ {uint64(DumpHeaders), "headers"}, {uint64(DumpBodies), "bodies"}, {uint64(DumpRequests), "requests"}, {uint64(DumpResponses), "responses"}, {uint64(DumpAuth), "auth"}, {uint64(DumpFilters), "filters"}, {uint64(DumpGoRoutines), "goroutines"}, {uint64(DumpOpenFiles), "openfiles"}, {uint64(DumpMapper), "mapper"}, } } func (dumpChoices) Type() string { return "DumpFlags" } // DumpFlagsList is a list of dump flags used in the help var DumpFlagsList = DumpHeaders.Help() rclone-v1.71.0/fs/dump_test.go000066400000000000000000000056641505210326400162240ustar00rootroot00000000000000package fs import ( "encoding/json" "strconv" "testing" "github.com/stretchr/testify/assert" ) // Check it satisfies the interfaces var ( _ Flagger = (*DumpFlags)(nil) _ FlaggerNP = DumpFlags(0) ) func TestDumpFlagsString(t *testing.T) { assert.Equal(t, "", DumpFlags(0).String()) assert.Equal(t, "headers", (DumpHeaders).String()) assert.Equal(t, "headers,bodies", (DumpHeaders | DumpBodies).String()) assert.Equal(t, "headers,bodies,requests,responses,auth,filters", (DumpHeaders | DumpBodies | DumpRequests | DumpResponses | DumpAuth | DumpFilters).String()) assert.Equal(t, "headers,Unknown-0x8000", (DumpHeaders | DumpFlags(0x8000)).String()) } func TestDumpFlagsSet(t *testing.T) { for _, test := range []struct { in string want DumpFlags wantErr string }{ {"", DumpFlags(0), ""}, {"bodies", DumpBodies, ""}, {"bodies,headers,auth", DumpBodies | DumpHeaders | DumpAuth, ""}, {"bodies,headers,auth", DumpBodies | DumpHeaders | DumpAuth, ""}, {"headers,bodies,requests,responses,auth,filters", DumpHeaders | DumpBodies | DumpRequests | DumpResponses | DumpAuth | DumpFilters, ""}, {"headers,bodies,unknown,auth", 0, "invalid choice \"unknown\""}, } { f := DumpFlags(0xffffffffffffffff) initial := f err := f.Set(test.in) if err != nil { if test.wantErr == "" { t.Errorf("Got an error when not expecting one on %q: %v", test.in, err) } else { assert.Contains(t, err.Error(), test.wantErr) } assert.Equal(t, initial, f, test.want) } else { if test.wantErr != "" { t.Errorf("Got no error when expecting one on %q", test.in) } else { assert.Equal(t, test.want, f) } } } } func TestDumpFlagsType(t *testing.T) { f := DumpFlags(0) assert.Equal(t, "DumpFlags", f.Type()) } func TestDumpFlagsUnmarshallJSON(t *testing.T) { for _, test := range []struct { in string want DumpFlags wantErr string }{ {`""`, DumpFlags(0), ""}, {`"bodies"`, DumpBodies, ""}, {`"bodies,headers,auth"`, DumpBodies | DumpHeaders | DumpAuth, ""}, {`"bodies,headers,auth"`, DumpBodies | DumpHeaders | DumpAuth, ""}, {`"headers,bodies,requests,responses,auth,filters"`, DumpHeaders | DumpBodies | DumpRequests | DumpResponses | DumpAuth | DumpFilters, ""}, {`"headers,bodies,unknown,auth"`, 0, "invalid choice \"unknown\""}, {`0`, DumpFlags(0), ""}, {strconv.Itoa(int(DumpBodies)), DumpBodies, ""}, {strconv.Itoa(int(DumpBodies | DumpHeaders | DumpAuth)), DumpBodies | DumpHeaders | DumpAuth, ""}, } { f := DumpFlags(0xffffffffffffffff) initial := f err := json.Unmarshal([]byte(test.in), &f) if err != nil { if test.wantErr == "" { t.Errorf("Got an error when not expecting one on %q: %v", test.in, err) } else { assert.Contains(t, err.Error(), test.wantErr) } assert.Equal(t, initial, f, test.want) } else { if test.wantErr != "" { t.Errorf("Got no error when expecting one on %q", test.in) } else { assert.Equal(t, test.want, f) } } } } rclone-v1.71.0/fs/enum.go000066400000000000000000000044461505210326400151610ustar00rootroot00000000000000package fs import ( "encoding/json" "fmt" "strings" ) // Enum is an option which can only be one of the Choices. // // Suggested implementation is something like this: // // type choice = Enum[choices] // // const ( // choiceA choice = iota // choiceB // choiceC // ) // // type choices struct{} // // func (choices) Choices() []string { // return []string{ // choiceA: "A", // choiceB: "B", // choiceC: "C", // } // } type Enum[C Choices] byte // Choices returns the valid choices for this type. // // It must work on the zero value. // // Note that when using this in an Option the ExampleChoices will be // filled in automatically. type Choices interface { // Choices returns the valid choices for this type Choices() []string } // String renders the Enum as a string func (e Enum[C]) String() string { choices := e.Choices() if int(e) >= len(choices) { return fmt.Sprintf("Unknown(%d)", e) } return choices[e] } // Choices returns the possible values of the Enum. func (e Enum[C]) Choices() []string { var c C return c.Choices() } // Help returns a comma separated list of all possible states. func (e Enum[C]) Help() string { return strings.Join(e.Choices(), ", ") } // Set the Enum entries func (e *Enum[C]) Set(s string) error { for i, choice := range e.Choices() { if strings.EqualFold(s, choice) { *e = Enum[C](i) return nil } } return fmt.Errorf("invalid choice %q from: %s", s, e.Help()) } // Type of the value. // // If C has a Type() string method then it will be used instead. func (e Enum[C]) Type() string { var c C if do, ok := any(c).(typer); ok { return do.Type() } return strings.Join(e.Choices(), "|") } // Scan implements the fmt.Scanner interface func (e *Enum[C]) Scan(s fmt.ScanState, ch rune) error { token, err := s.Token(true, nil) if err != nil { return err } return e.Set(string(token)) } // UnmarshalJSON parses it as a string or an integer func (e *Enum[C]) UnmarshalJSON(in []byte) error { choices := e.Choices() return UnmarshalJSONFlag(in, e, func(i int64) error { if i < 0 || i >= int64(len(choices)) { return fmt.Errorf("%d is out of range: must be 0..%d", i, len(choices)) } *e = Enum[C](i) return nil }) } // MarshalJSON encodes it as string func (e *Enum[C]) MarshalJSON() ([]byte, error) { return json.Marshal(e.String()) } rclone-v1.71.0/fs/enum_test.go000066400000000000000000000050721505210326400162140ustar00rootroot00000000000000package fs import ( "encoding/json" "fmt" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) type choices struct{} func (choices) Choices() []string { return []string{ choiceA: "A", choiceB: "B", choiceC: "C", } } type choice = Enum[choices] const ( choiceA choice = iota choiceB choiceC ) // Check it satisfies the interfaces var ( _ Flagger = (*choice)(nil) _ FlaggerNP = choice(0) ) func TestEnumString(t *testing.T) { for _, test := range []struct { in choice want string }{ {choiceA, "A"}, {choiceB, "B"}, {choiceC, "C"}, {choice(100), "Unknown(100)"}, } { got := test.in.String() assert.Equal(t, test.want, got) } } func TestEnumType(t *testing.T) { assert.Equal(t, "A|B|C", choiceA.Type()) } // Enum with Type() on the choices type choicestype struct{} func (choicestype) Choices() []string { return []string{} } func (choicestype) Type() string { return "potato" } type choicetype = Enum[choicestype] func TestEnumTypeWithFunction(t *testing.T) { assert.Equal(t, "potato", choicetype(0).Type()) } func TestEnumHelp(t *testing.T) { assert.Equal(t, "A, B, C", choice(0).Help()) } func TestEnumSet(t *testing.T) { for _, test := range []struct { in string want choice err bool }{ {"A", choiceA, false}, {"B", choiceB, false}, {"C", choiceC, false}, {"D", choice(100), true}, } { var got choice err := got.Set(test.in) if test.err { require.Error(t, err) } else { require.NoError(t, err) assert.Equal(t, test.want, got) } } } func TestEnumScan(t *testing.T) { var v choice n, err := fmt.Sscan(" A ", &v) require.NoError(t, err) assert.Equal(t, 1, n) assert.Equal(t, choiceA, v) } func TestEnumUnmarshalJSON(t *testing.T) { for _, test := range []struct { in string want choice err string }{ {`"A"`, choiceA, ""}, {`"B"`, choiceB, ""}, {`0`, choiceA, ""}, {`1`, choiceB, ""}, {`"D"`, choice(0), `invalid choice "D" from: A, B, C`}, {`100`, choice(0), `100 is out of range: must be 0..3`}, } { var got choice err := json.Unmarshal([]byte(test.in), &got) if test.err != "" { require.Error(t, err, test.in) assert.ErrorContains(t, err, test.err) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, got, test.in) } } func TestEnumMarshalJSON(t *testing.T) { for _, test := range []struct { in choice want string }{ {choiceA, `"A"`}, {choiceB, `"B"`}, } { got, err := json.Marshal(&test.in) require.NoError(t, err) assert.Equal(t, test.want, string(got), fmt.Sprintf("%#v", test.in)) } } rclone-v1.71.0/fs/features.go000066400000000000000000000701031505210326400160240ustar00rootroot00000000000000// Filesystem features and optional interfaces package fs import ( "context" "io" "reflect" "strings" "time" ) // Features describe the optional features of the Fs type Features struct { // Feature flags, whether Fs CaseInsensitive bool // has case insensitive files DuplicateFiles bool // allows duplicate files ReadMimeType bool // can read the mime type of objects WriteMimeType bool // can set the mime type of objects CanHaveEmptyDirectories bool // can have empty directories BucketBased bool // is bucket based (like s3, swift, etc.) BucketBasedRootOK bool // is bucket based and can use from root SetTier bool // allows set tier functionality on objects GetTier bool // allows to retrieve storage tier of objects ServerSideAcrossConfigs bool // can server-side copy between different remotes of the same type IsLocal bool // is the local backend SlowModTime bool // if calling ModTime() generally takes an extra transaction SlowHash bool // if calling Hash() generally takes an extra transaction ReadMetadata bool // can read metadata from objects WriteMetadata bool // can write metadata to objects UserMetadata bool // can read/write general purpose metadata ReadDirMetadata bool // can read metadata from directories (implements Directory.Metadata) WriteDirMetadata bool // can write metadata to directories (implements Directory.SetMetadata) WriteDirSetModTime bool // can write metadata to directories (implements Directory.SetModTime) UserDirMetadata bool // can read/write general purpose metadata to/from directories DirModTimeUpdatesOnWrite bool // indicate writing files to a directory updates its modtime FilterAware bool // can make use of filters if provided for listing PartialUploads bool // uploaded file can appear incomplete on the fs while it's being uploaded NoMultiThreading bool // set if can't have multiplethreads on one download open Overlay bool // this wraps one or more backends to add functionality ChunkWriterDoesntSeek bool // set if the chunk writer doesn't need to read the data more than once DoubleSlash bool // set if backend supports double slashes in paths // Purge all files in the directory specified // // Implement this if you have a way of deleting all the files // quicker than just running Remove() on the result of List() // // Return an error if it doesn't exist Purge func(ctx context.Context, dir string) error // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given // // It returns the destination Object and a possible error // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantCopy Copy func(ctx context.Context, src Object, remote string) (Object, error) // Move src to this remote using server-side move operations. // // This is stored with the remote path given // // It returns the destination Object and a possible error // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantMove Move func(ctx context.Context, src Object, remote string) (Object, error) // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists DirMove func(ctx context.Context, src Fs, srcRemote, dstRemote string) error // MkdirMetadata makes the directory passed in as dir. // // It shouldn't return an error if it already exists. // // If the metadata is not nil it is set. // // It returns the directory that was created. MkdirMetadata func(ctx context.Context, dir string, metadata Metadata) (Directory, error) // ChangeNotify calls the passed function with a path // that has had changes. If the implementation // uses polling, it should adhere to the given interval. ChangeNotify func(context.Context, func(string, EntryType), <-chan time.Duration) // UnWrap returns the Fs that this Fs is wrapping UnWrap func() Fs // WrapFs returns the Fs that is wrapping this Fs WrapFs func() Fs // SetWrapper sets the Fs that is wrapping this Fs SetWrapper func(f Fs) // DirCacheFlush resets the directory cache - used in testing // as an optional interface DirCacheFlush func() // PublicLink generates a public link to the remote path (usually readable by anyone) PublicLink func(ctx context.Context, remote string, expire Duration, unlink bool) (string, error) // Put in to the remote path with the modTime given of the given size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error // // May create duplicates or return errors if src already // exists. PutUnchecked func(ctx context.Context, in io.Reader, src ObjectInfo, options ...OpenOption) (Object, error) // PutStream uploads to the remote path with the modTime given of indeterminate size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error PutStream func(ctx context.Context, in io.Reader, src ObjectInfo, options ...OpenOption) (Object, error) // MergeDirs merges the contents of all the directories passed // in into the first one and rmdirs the other directories. MergeDirs func(ctx context.Context, dirs []Directory) error // DirSetModTime sets the metadata on the directory to set the modification date DirSetModTime func(ctx context.Context, dir string, modTime time.Time) error // CleanUp the trash in the Fs // // Implement this if you have a way of emptying the trash or // otherwise cleaning up old versions of files. CleanUp func(ctx context.Context) error // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively that doing a directory traversal. ListR ListRFn // ListP lists the objects and directories of the Fs starting // from dir non recursively to out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. ListP func(ctx context.Context, dir string, callback ListRCallback) error // About gets quota information from the Fs About func(ctx context.Context) (*Usage, error) // OpenWriterAt opens with a handle for random access writes // // Pass in the remote desired and the size if known. // // It truncates any existing object OpenWriterAt func(ctx context.Context, remote string, size int64) (WriterAtCloser, error) // OpenChunkWriter returns the chunk size and a ChunkWriter // // Pass in the remote and the src object // You can also use options to hint at the desired chunk size // OpenChunkWriter func(ctx context.Context, remote string, src ObjectInfo, options ...OpenOption) (info ChunkWriterInfo, writer ChunkWriter, err error) // UserInfo returns info about the connected user UserInfo func(ctx context.Context) (map[string]string, error) // Disconnect the current user Disconnect func(ctx context.Context) error // Command the backend to run a named command // // The command run is name // args may be used to read arguments from // opts may be used to read optional arguments from // // The result should be capable of being JSON encoded // If it is a string or a []string it will be shown to the user // otherwise it will be JSON encoded and shown to the user like that Command func(ctx context.Context, name string, arg []string, opt map[string]string) (any, error) // Shutdown the backend, closing any background tasks and any // cached connections. Shutdown func(ctx context.Context) error } // Disable nil's out the named feature. If it isn't found then it // will log a message. func (ft *Features) Disable(name string) *Features { // Prefix boolean values with ! to set the feature invert := false if strings.HasPrefix(name, "!") { name = name[1:] invert = true } v := reflect.ValueOf(ft).Elem() vType := v.Type() for i := range v.NumField() { vName := vType.Field(i).Name field := v.Field(i) if strings.EqualFold(name, vName) { if !field.CanSet() { Errorf(nil, "Can't set Feature %q", name) } else { if invert { if field.Type().Kind() == reflect.Bool { field.Set(reflect.ValueOf(true)) Debugf(nil, "Set feature %q", name) } else { Errorf(nil, "Can't set Feature %q to true", name) } } else { zero := reflect.Zero(field.Type()) field.Set(zero) Debugf(nil, "Reset feature %q", name) } } } } return ft } // List returns a slice of all the possible feature names func (ft *Features) List() (out []string) { v := reflect.ValueOf(ft).Elem() vType := v.Type() for i := range v.NumField() { out = append(out, vType.Field(i).Name) } return out } // Enabled returns a map of features with keys showing whether they // are enabled or not func (ft *Features) Enabled() (features map[string]bool) { v := reflect.ValueOf(ft).Elem() vType := v.Type() features = make(map[string]bool, v.NumField()) for i := range v.NumField() { vName := vType.Field(i).Name field := v.Field(i) if field.Kind() == reflect.Func { // Can't compare functions features[vName] = !field.IsNil() } else { zero := reflect.Zero(field.Type()) features[vName] = field.Interface() != zero.Interface() } } return features } // DisableList nil's out the comma separated list of named features. // If it isn't found then it will log a message. func (ft *Features) DisableList(list []string) *Features { for _, feature := range list { ft.Disable(strings.TrimSpace(feature)) } return ft } // Fill fills in the function pointers in the Features struct from the // optional interfaces. It returns the original updated Features // struct passed in. func (ft *Features) Fill(ctx context.Context, f Fs) *Features { if do, ok := f.(Purger); ok { ft.Purge = do.Purge } if do, ok := f.(Copier); ok { ft.Copy = do.Copy } if do, ok := f.(Mover); ok { ft.Move = do.Move } if do, ok := f.(DirMover); ok { ft.DirMove = do.DirMove } if do, ok := f.(MkdirMetadataer); ok { ft.MkdirMetadata = do.MkdirMetadata } if do, ok := f.(ChangeNotifier); ok { ft.ChangeNotify = do.ChangeNotify } if do, ok := f.(UnWrapper); ok { ft.UnWrap = do.UnWrap } if do, ok := f.(Wrapper); ok { ft.WrapFs = do.WrapFs ft.SetWrapper = do.SetWrapper ft.Overlay = true // if implement UnWrap then must be an Overlay } if do, ok := f.(DirCacheFlusher); ok { ft.DirCacheFlush = do.DirCacheFlush } if do, ok := f.(PublicLinker); ok { ft.PublicLink = do.PublicLink } if do, ok := f.(PutUncheckeder); ok { ft.PutUnchecked = do.PutUnchecked } if do, ok := f.(PutStreamer); ok { ft.PutStream = do.PutStream } if do, ok := f.(MergeDirser); ok { ft.MergeDirs = do.MergeDirs } if do, ok := f.(DirSetModTimer); ok { ft.DirSetModTime = do.DirSetModTime } if do, ok := f.(CleanUpper); ok { ft.CleanUp = do.CleanUp } if do, ok := f.(ListRer); ok { ft.ListR = do.ListR } if do, ok := f.(ListPer); ok { ft.ListP = do.ListP } if do, ok := f.(Abouter); ok { ft.About = do.About } if do, ok := f.(OpenWriterAter); ok { ft.OpenWriterAt = do.OpenWriterAt } if do, ok := f.(OpenChunkWriter); ok { ft.OpenChunkWriter = do.OpenChunkWriter } if do, ok := f.(UserInfoer); ok { ft.UserInfo = do.UserInfo } if do, ok := f.(Disconnecter); ok { ft.Disconnect = do.Disconnect } if do, ok := f.(Commander); ok { ft.Command = do.Command } if do, ok := f.(Shutdowner); ok { ft.Shutdown = do.Shutdown } return ft.DisableList(GetConfig(ctx).DisableFeatures) } // Mask the Features with the Fs passed in // // Only optional features which are implemented in both the original // Fs AND the one passed in will be advertised. Any features which // aren't in both will be set to false/nil, except for UnWrap/Wrap which // will be left untouched. func (ft *Features) Mask(ctx context.Context, f Fs) *Features { mask := f.Features() ft.CaseInsensitive = ft.CaseInsensitive && mask.CaseInsensitive ft.DuplicateFiles = ft.DuplicateFiles && mask.DuplicateFiles ft.ReadMimeType = ft.ReadMimeType && mask.ReadMimeType ft.WriteMimeType = ft.WriteMimeType && mask.WriteMimeType ft.ReadMetadata = ft.ReadMetadata && mask.ReadMetadata ft.WriteMetadata = ft.WriteMetadata && mask.WriteMetadata ft.UserMetadata = ft.UserMetadata && mask.UserMetadata ft.ReadDirMetadata = ft.ReadDirMetadata && mask.ReadDirMetadata ft.WriteDirMetadata = ft.WriteDirMetadata && mask.WriteDirMetadata ft.WriteDirSetModTime = ft.WriteDirSetModTime && mask.WriteDirSetModTime ft.UserDirMetadata = ft.UserDirMetadata && mask.UserDirMetadata ft.DirModTimeUpdatesOnWrite = ft.DirModTimeUpdatesOnWrite && mask.DirModTimeUpdatesOnWrite ft.CanHaveEmptyDirectories = ft.CanHaveEmptyDirectories && mask.CanHaveEmptyDirectories ft.BucketBased = ft.BucketBased && mask.BucketBased ft.BucketBasedRootOK = ft.BucketBasedRootOK && mask.BucketBasedRootOK ft.SetTier = ft.SetTier && mask.SetTier ft.GetTier = ft.GetTier && mask.GetTier ft.ServerSideAcrossConfigs = ft.ServerSideAcrossConfigs && mask.ServerSideAcrossConfigs // ft.IsLocal = ft.IsLocal && mask.IsLocal Don't propagate IsLocal ft.SlowModTime = ft.SlowModTime && mask.SlowModTime ft.SlowHash = ft.SlowHash && mask.SlowHash ft.FilterAware = ft.FilterAware && mask.FilterAware ft.PartialUploads = ft.PartialUploads && mask.PartialUploads ft.NoMultiThreading = ft.NoMultiThreading && mask.NoMultiThreading // ft.Overlay = ft.Overlay && mask.Overlay don't propagate Overlay ft.ChunkWriterDoesntSeek = ft.ChunkWriterDoesntSeek && mask.ChunkWriterDoesntSeek ft.DoubleSlash = ft.DoubleSlash && mask.DoubleSlash if mask.Purge == nil { ft.Purge = nil } if mask.Copy == nil { ft.Copy = nil } if mask.Move == nil { ft.Move = nil } if mask.DirMove == nil { ft.DirMove = nil } if mask.MkdirMetadata == nil { ft.MkdirMetadata = nil } if mask.ChangeNotify == nil { ft.ChangeNotify = nil } // if mask.UnWrap == nil { // ft.UnWrap = nil // } // if mask.Wrapper == nil { // ft.Wrapper = nil // } if mask.DirCacheFlush == nil { ft.DirCacheFlush = nil } if mask.PublicLink == nil { ft.PublicLink = nil } if mask.PutUnchecked == nil { ft.PutUnchecked = nil } if mask.PutStream == nil { ft.PutStream = nil } if mask.MergeDirs == nil { ft.MergeDirs = nil } if mask.DirSetModTime == nil { ft.DirSetModTime = nil } if mask.CleanUp == nil { ft.CleanUp = nil } if mask.ListR == nil { ft.ListR = nil } if mask.ListP == nil { ft.ListP = nil } if mask.About == nil { ft.About = nil } if mask.OpenWriterAt == nil { ft.OpenWriterAt = nil } if mask.OpenChunkWriter == nil { ft.OpenChunkWriter = nil } if mask.UserInfo == nil { ft.UserInfo = nil } if mask.Disconnect == nil { ft.Disconnect = nil } // Command is always local so we don't mask it if mask.Shutdown == nil { ft.Shutdown = nil } return ft.DisableList(GetConfig(ctx).DisableFeatures) } // Wrap makes a Copy of the features passed in, overriding the UnWrap/Wrap // method only if available in f. func (ft *Features) Wrap(f Fs) *Features { ftCopy := new(Features) *ftCopy = *ft if do, ok := f.(UnWrapper); ok { ftCopy.UnWrap = do.UnWrap } if do, ok := f.(Wrapper); ok { ftCopy.WrapFs = do.WrapFs ftCopy.SetWrapper = do.SetWrapper } return ftCopy } // WrapsFs adds extra information between `f` which wraps `w` func (ft *Features) WrapsFs(f Fs, w Fs) *Features { wFeatures := w.Features() if wFeatures.WrapFs != nil && wFeatures.SetWrapper != nil { wFeatures.SetWrapper(f) } return ft } // Purger is an optional interfaces for Fs type Purger interface { // Purge all files in the directory specified // // Implement this if you have a way of deleting all the files // quicker than just running Remove() on the result of List() // // Return an error if it doesn't exist Purge(ctx context.Context, dir string) error } // Copier is an optional interface for Fs type Copier interface { // Copy src to this remote using server-side copy operations. // // This is stored with the remote path given // // It returns the destination Object and a possible error // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantCopy Copy(ctx context.Context, src Object, remote string) (Object, error) } // Mover is an optional interface for Fs type Mover interface { // Move src to this remote using server-side move operations. // // This is stored with the remote path given // // It returns the destination Object and a possible error // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantMove Move(ctx context.Context, src Object, remote string) (Object, error) } // DirMover is an optional interface for Fs type DirMover interface { // DirMove moves src, srcRemote to this remote at dstRemote // using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists DirMove(ctx context.Context, src Fs, srcRemote, dstRemote string) error } // MkdirMetadataer is an optional interface for Fs type MkdirMetadataer interface { // MkdirMetadata makes the directory passed in as dir. // // It shouldn't return an error if it already exists. // // If the metadata is not nil it is set. // // It returns the directory that was created. MkdirMetadata(ctx context.Context, dir string, metadata Metadata) (Directory, error) } // ChangeNotifier is an optional interface for Fs type ChangeNotifier interface { // ChangeNotify calls the passed function with a path // that has had changes. If the implementation // uses polling, it should adhere to the given interval. // At least one value will be written to the channel, // specifying the initial value and updated values might // follow. A 0 Duration should pause the polling. // The ChangeNotify implementation must empty the channel // regularly. When the channel gets closed, the implementation // should stop polling and release resources. ChangeNotify(context.Context, func(string, EntryType), <-chan time.Duration) } // EntryType can be associated with remote paths to identify their type type EntryType int // Constants const ( // EntryDirectory should be used to classify remote paths in directories EntryDirectory EntryType = iota // 0 // EntryObject should be used to classify remote paths in objects EntryObject // 1 ) // UnWrapper is an optional interfaces for Fs type UnWrapper interface { // UnWrap returns the Fs that this Fs is wrapping UnWrap() Fs } // Wrapper is an optional interfaces for Fs type Wrapper interface { // Wrap returns the Fs that is wrapping this Fs WrapFs() Fs // SetWrapper sets the Fs that is wrapping this Fs SetWrapper(f Fs) } // DirCacheFlusher is an optional interface for Fs type DirCacheFlusher interface { // DirCacheFlush resets the directory cache - used in testing // as an optional interface DirCacheFlush() } // PutUncheckeder is an optional interface for Fs type PutUncheckeder interface { // Put in to the remote path with the modTime given of the given size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error // // May create duplicates or return errors if src already // exists. PutUnchecked(ctx context.Context, in io.Reader, src ObjectInfo, options ...OpenOption) (Object, error) } // PutStreamer is an optional interface for Fs type PutStreamer interface { // PutStream uploads to the remote path with the modTime given of indeterminate size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error PutStream(ctx context.Context, in io.Reader, src ObjectInfo, options ...OpenOption) (Object, error) } // PublicLinker is an optional interface for Fs type PublicLinker interface { // PublicLink generates a public link to the remote path (usually readable by anyone) PublicLink(ctx context.Context, remote string, expire Duration, unlink bool) (string, error) } // MergeDirser is an option interface for Fs type MergeDirser interface { // MergeDirs merges the contents of all the directories passed // in into the first one and rmdirs the other directories. MergeDirs(ctx context.Context, dirs []Directory) error } // DirSetModTimer is an optional interface for Fs type DirSetModTimer interface { // DirSetModTime sets the metadata on the directory to set the modification date DirSetModTime(ctx context.Context, dir string, modTime time.Time) error } // CleanUpper is an optional interfaces for Fs type CleanUpper interface { // CleanUp the trash in the Fs // // Implement this if you have a way of emptying the trash or // otherwise cleaning up old versions of files. CleanUp(ctx context.Context) error } // ListRer is an optional interfaces for Fs type ListRer interface { // ListR lists the objects and directories of the Fs starting // from dir recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. // // Don't implement this unless you have a more efficient way // of listing recursively that doing a directory traversal. ListR(ctx context.Context, dir string, callback ListRCallback) error } // ListPer is an optional interfaces for Fs type ListPer interface { // ListP lists the objects and directories of the Fs starting // from dir non recursively into out. // // dir should be "" to start from the root, and should not // have trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. // // It should call callback for each tranche of entries read. // These need not be returned in any particular order. If // callback returns an error then the listing will stop // immediately. ListP(ctx context.Context, dir string, callback ListRCallback) error } // RangeSeeker is the interface that wraps the RangeSeek method. // // Some of the returns from Object.Open() may optionally implement // this method for efficiency purposes. type RangeSeeker interface { // RangeSeek behaves like a call to Seek(offset int64, whence // int) with the output wrapped in an io.LimitedReader // limiting the total length to limit. // // RangeSeek with a limit of < 0 is equivalent to a regular Seek. RangeSeek(ctx context.Context, offset int64, whence int, length int64) (int64, error) } // Abouter is an optional interface for Fs type Abouter interface { // About gets quota information from the Fs About(ctx context.Context) (*Usage, error) } // OpenWriterAter is an optional interface for Fs type OpenWriterAter interface { // OpenWriterAt opens with a handle for random access writes // // Pass in the remote desired and the size if known. // // It truncates any existing object OpenWriterAt(ctx context.Context, remote string, size int64) (WriterAtCloser, error) } // OpenWriterAtFn describes the OpenWriterAt function pointer type OpenWriterAtFn func(ctx context.Context, remote string, size int64) (WriterAtCloser, error) // ChunkWriterInfo describes how a backend would like ChunkWriter called type ChunkWriterInfo struct { ChunkSize int64 // preferred chunk size Concurrency int // how many chunks to write at once LeavePartsOnError bool // if set don't delete parts uploaded so far on error } // OpenChunkWriter is an option interface for Fs to implement chunked writing type OpenChunkWriter interface { // OpenChunkWriter returns the chunk size and a ChunkWriter // // Pass in the remote and the src object // You can also use options to hint at the desired chunk size OpenChunkWriter(ctx context.Context, remote string, src ObjectInfo, options ...OpenOption) (info ChunkWriterInfo, writer ChunkWriter, err error) } // OpenChunkWriterFn describes the OpenChunkWriter function pointer type OpenChunkWriterFn func(ctx context.Context, remote string, src ObjectInfo, options ...OpenOption) (info ChunkWriterInfo, writer ChunkWriter, err error) // ChunkWriter is returned by OpenChunkWriter to implement chunked writing type ChunkWriter interface { // WriteChunk will write chunk number with reader bytes, where chunk number >= 0 WriteChunk(ctx context.Context, chunkNumber int, reader io.ReadSeeker) (bytesWritten int64, err error) // Close complete chunked writer finalising the file. Close(ctx context.Context) error // Abort chunk write // // You can and should call Abort without calling Close. Abort(ctx context.Context) error } // UserInfoer is an optional interface for Fs type UserInfoer interface { // UserInfo returns info about the connected user UserInfo(ctx context.Context) (map[string]string, error) } // Disconnecter is an optional interface for Fs type Disconnecter interface { // Disconnect the current user Disconnect(ctx context.Context) error } // CommandHelp describes a single backend Command // // These are automatically inserted in the docs type CommandHelp struct { Name string // Name of the command, e.g. "link" Short string // Single line description Long string // Long multi-line description Opts map[string]string // maps option name to a single line help } // Commander is an interface to wrap the Command function type Commander interface { // Command the backend to run a named command // // The command run is name // args may be used to read arguments from // opts may be used to read optional arguments from // // The result should be capable of being JSON encoded // If it is a string or a []string it will be shown to the user // otherwise it will be JSON encoded and shown to the user like that Command(ctx context.Context, name string, arg []string, opt map[string]string) (any, error) } // Shutdowner is an interface to wrap the Shutdown function type Shutdowner interface { // Shutdown the backend, closing any background tasks and any // cached connections. Shutdown(ctx context.Context) error } // ObjectsChan is a channel of Objects type ObjectsChan chan Object // Objects is a slice of Object~s type Objects []Object // ObjectPair is a pair of Objects used to describe a potential copy // operation. type ObjectPair struct { Src, Dst Object } // UnWrapFs unwraps f as much as possible and returns the base Fs func UnWrapFs(f Fs) Fs { for { unwrap := f.Features().UnWrap if unwrap == nil { break // not a wrapped Fs, use current } next := unwrap() if next == nil { break // no base Fs found, use current } f = next } return f } // UnWrapObject unwraps o as much as possible and returns the base object func UnWrapObject(o Object) Object { for { u, ok := o.(ObjectUnWrapper) if !ok { break // not a wrapped object, use current } next := u.UnWrap() if next == nil { break // no base object found, use current } o = next } return o } // UnWrapObjectInfo returns the underlying Object unwrapped as much as // possible or nil. func UnWrapObjectInfo(oi ObjectInfo) Object { o, ok := oi.(Object) if !ok { return nil } return UnWrapObject(o) } rclone-v1.71.0/fs/filter/000077500000000000000000000000001505210326400151435ustar00rootroot00000000000000rclone-v1.71.0/fs/filter/filter.go000066400000000000000000000511061505210326400167620ustar00rootroot00000000000000// Package filter controls the filtering of files package filter import ( "context" "crypto/md5" "encoding/binary" "errors" "fmt" "math/rand/v2" "path" "slices" "strconv" "strings" "time" "github.com/rclone/rclone/fs" "golang.org/x/sync/errgroup" "golang.org/x/text/unicode/norm" ) // This is the globally active filter // // This is accessed through GetConfig and AddConfig var globalConfig = mustNewFilter(nil) // OptionsInfo describes the Options in use var OptionsInfo = fs.Options{{ Name: "delete_excluded", Default: false, Help: "Delete files on dest excluded from sync", Groups: "Filter", }, { Name: "exclude_if_present", Default: []string{}, Help: "Exclude directories if filename is present", Groups: "Filter", }, { Name: "files_from", Default: []string{}, Help: "Read list of source-file names from file (use - to read from stdin)", Groups: "Filter", }, { Name: "files_from_raw", Default: []string{}, Help: "Read list of source-file names from file without any processing of lines (use - to read from stdin)", Groups: "Filter", }, { Name: "min_age", Default: fs.DurationOff, Help: "Only transfer files older than this in s or suffix ms|s|m|h|d|w|M|y", Groups: "Filter", }, { Name: "max_age", Default: fs.DurationOff, Help: "Only transfer files younger than this in s or suffix ms|s|m|h|d|w|M|y", Groups: "Filter", }, { Name: "min_size", Default: fs.SizeSuffix(-1), Help: "Only transfer files bigger than this in KiB or suffix B|K|M|G|T|P", Groups: "Filter", }, { Name: "max_size", Default: fs.SizeSuffix(-1), Help: "Only transfer files smaller than this in KiB or suffix B|K|M|G|T|P", Groups: "Filter", }, { Name: "ignore_case", Default: false, Help: "Ignore case in filters (case insensitive)", Groups: "Filter", }, { Name: "hash_filter", Default: "", Help: "Partition filenames by hash k/n or randomly @/n", Groups: "Filter", }, { Name: "filter", Default: []string{}, ShortOpt: "f", Help: "Add a file filtering rule", Groups: "Filter", }, { Name: "filter_from", Default: []string{}, Help: "Read file filtering patterns from a file (use - to read from stdin)", Groups: "Filter", }, { Name: "exclude", Default: []string{}, Help: "Exclude files matching pattern", Groups: "Filter", }, { Name: "exclude_from", Default: []string{}, Help: "Read file exclude patterns from file (use - to read from stdin)", Groups: "Filter", }, { Name: "include", Default: []string{}, Help: "Include files matching pattern", Groups: "Filter", }, { Name: "include_from", Default: []string{}, Help: "Read file include patterns from file (use - to read from stdin)", Groups: "Filter", }, { Name: "metadata_filter", Default: []string{}, Help: "Add a metadata filtering rule", Groups: "Filter,Metadata", }, { Name: "metadata_filter_from", Default: []string{}, Help: "Read metadata filtering patterns from a file (use - to read from stdin)", Groups: "Filter,Metadata", }, { Name: "metadata_exclude", Default: []string{}, Help: "Exclude metadatas matching pattern", Groups: "Filter,Metadata", }, { Name: "metadata_exclude_from", Default: []string{}, Help: "Read metadata exclude patterns from file (use - to read from stdin)", Groups: "Filter,Metadata", }, { Name: "metadata_include", Default: []string{}, Help: "Include metadatas matching pattern", Groups: "Filter,Metadata", }, { Name: "metadata_include_from", Default: []string{}, Help: "Read metadata include patterns from file (use - to read from stdin)", Groups: "Filter,Metadata", }} // Options configures the filter type Options struct { DeleteExcluded bool `config:"delete_excluded"` RulesOpt // embedded so we don't change the JSON API ExcludeFile []string `config:"exclude_if_present"` FilesFrom []string `config:"files_from"` FilesFromRaw []string `config:"files_from_raw"` MetaRules RulesOpt `config:"metadata"` MinAge fs.Duration `config:"min_age"` MaxAge fs.Duration `config:"max_age"` MinSize fs.SizeSuffix `config:"min_size"` MaxSize fs.SizeSuffix `config:"max_size"` IgnoreCase bool `config:"ignore_case"` HashFilter string `config:"hash_filter"` } func init() { fs.RegisterGlobalOptions(fs.OptionsInfo{Name: "filter", Opt: &Opt, Options: OptionsInfo, Reload: Reload}) } // Opt is the default config for the filter var Opt = Options{ MinAge: fs.DurationOff, // These have to be set here as the options are parsed once before the defaults are set MaxAge: fs.DurationOff, MinSize: fs.SizeSuffix(-1), MaxSize: fs.SizeSuffix(-1), } // FilesMap describes the map of files to transfer type FilesMap map[string]struct{} // Filter describes any filtering in operation type Filter struct { Opt Options ModTimeFrom time.Time ModTimeTo time.Time fileRules rules dirRules rules metaRules rules files FilesMap // files if filesFrom dirs FilesMap // dirs from filesFrom hashFilterN uint64 // if non 0 do hash filtering hashFilterK uint64 // select partition K/N } // NewFilter parses the command line options and creates a Filter // object. If opt is nil, then DefaultOpt will be used func NewFilter(opt *Options) (f *Filter, err error) { f = &Filter{} // Make a copy of the options if opt != nil { f.Opt = *opt } else { f.Opt = Opt } // Filter flags if f.Opt.MinAge.IsSet() { f.ModTimeTo = time.Now().Add(-time.Duration(f.Opt.MinAge)) fs.Debugf(nil, "--min-age %v to %v", f.Opt.MinAge, f.ModTimeTo) } if f.Opt.MaxAge.IsSet() { f.ModTimeFrom = time.Now().Add(-time.Duration(f.Opt.MaxAge)) if !f.ModTimeTo.IsZero() && f.ModTimeTo.Before(f.ModTimeFrom) { return nil, fmt.Errorf("filter: --min-age %q can't be larger than --max-age %q", opt.MinAge, opt.MaxAge) } fs.Debugf(nil, "--max-age %v to %v", f.Opt.MaxAge, f.ModTimeFrom) } if f.Opt.HashFilter != "" { f.hashFilterK, f.hashFilterN, err = parseHashFilter(f.Opt.HashFilter) if err != nil { return nil, err } fs.Debugf(nil, "Using --hash-filter %d/%d", f.hashFilterK, f.hashFilterN) } err = parseRules(&f.Opt.RulesOpt, f.Add, f.Clear) if err != nil { return nil, err } err = parseRules(&f.Opt.MetaRules, f.metaRules.Add, f.metaRules.clear) if err != nil { return nil, err } inActive := f.InActive() for _, rule := range f.Opt.FilesFrom { if !inActive { return nil, fmt.Errorf("the usage of --files-from overrides all other filters, it should be used alone or with --files-from-raw") } f.initAddFile() // init to show --files-from set even if no files within err := forEachLine(rule, false, func(line string) error { return f.AddFile(line) }) if err != nil { return nil, err } } for _, rule := range f.Opt.FilesFromRaw { // --files-from-raw can be used with --files-from, hence we do // not need to get the value of f.InActive again if !inActive { return nil, fmt.Errorf("the usage of --files-from-raw overrides all other filters, it should be used alone or with --files-from") } f.initAddFile() // init to show --files-from set even if no files within err := forEachLine(rule, true, func(line string) error { return f.AddFile(line) }) if err != nil { return nil, err } } if fs.GetConfig(context.Background()).Dump&fs.DumpFilters != 0 { fmt.Println("--- start filters ---") fmt.Println(f.DumpFilters()) fmt.Println("--- end filters ---") } return f, nil } // Parse the --hash-filter arguments into k/n func parseHashFilter(hashFilter string) (k, n uint64, err error) { slash := strings.IndexRune(hashFilter, '/') if slash < 0 { return 0, 0, fmt.Errorf("filter: --hash-filter: no / found") } kStr, nStr := hashFilter[:slash], hashFilter[slash+1:] n, err = strconv.ParseUint(nStr, 10, 64) if err != nil { return 0, 0, fmt.Errorf("filter: --hash-filter: can't parse N=%q: %v", nStr, err) } if n == 0 { return 0, 0, fmt.Errorf("filter: --hash-filter: N must be greater than 0") } if kStr == "@" { k = rand.Uint64N(n) } else { k, err = strconv.ParseUint(kStr, 10, 64) if err != nil { return 0, 0, fmt.Errorf("filter: --hash-filter: can't parse K=%q: %v", kStr, err) } k %= n } return k, n, nil } func mustNewFilter(opt *Options) *Filter { f, err := NewFilter(opt) if err != nil { panic(err) } return f } // addDirGlobs adds directory globs from the file glob passed in func (f *Filter) addDirGlobs(Include bool, glob string) error { for _, dirGlob := range globToDirGlobs(glob) { // Don't add "/" as we always include the root if dirGlob == "/" { continue } dirRe, err := GlobPathToRegexp(dirGlob, f.Opt.IgnoreCase) if err != nil { return err } f.dirRules.add(Include, dirRe) } return nil } // Add adds a filter rule with include or exclude status indicated func (f *Filter) Add(Include bool, glob string) error { isDirRule := strings.HasSuffix(glob, "/") isFileRule := !isDirRule // Make excluding "dir/" equivalent to excluding "dir/**" if isDirRule && !Include { glob += "**" } if strings.Contains(glob, "**") { isDirRule, isFileRule = true, true } re, err := GlobPathToRegexp(glob, f.Opt.IgnoreCase) if err != nil { return err } if isFileRule { f.fileRules.add(Include, re) // If include rule work out what directories are needed to scan // if exclude rule, we can't rule anything out // Unless it is `*` which matches everything // NB ** and /** are DirRules if Include || glob == "*" { err = f.addDirGlobs(Include, glob) if err != nil { return err } } } if isDirRule { f.dirRules.add(Include, re) } return nil } // AddRule adds a filter rule with include/exclude indicated by the prefix // // These are // // - glob // - glob // ! // // '+' includes the glob, '-' excludes it and '!' resets the filter list // // Line comments may be introduced with '#' or ';' func (f *Filter) AddRule(rule string) error { return addRule(rule, f.Add, f.Clear) } // initAddFile creates f.files and f.dirs func (f *Filter) initAddFile() { if f.files == nil { f.files = make(FilesMap) f.dirs = make(FilesMap) } } // AddFile adds a single file to the files from list func (f *Filter) AddFile(file string) error { f.initAddFile() file = strings.Trim(file, "/") f.files[file] = struct{}{} // Put all the parent directories into f.dirs for { file = path.Dir(file) if file == "." { break } if _, found := f.dirs[file]; found { break } f.dirs[file] = struct{}{} } return nil } // Files returns all the files from the `--files-from` list // // It may be nil if the list is empty func (f *Filter) Files() FilesMap { return f.files } // Clear clears all the filter rules func (f *Filter) Clear() { f.fileRules.clear() f.dirRules.clear() f.metaRules.clear() } // InActive returns false if any filters are active func (f *Filter) InActive() bool { return (f.files == nil && f.ModTimeFrom.IsZero() && f.ModTimeTo.IsZero() && f.Opt.MinSize < 0 && f.Opt.MaxSize < 0 && f.fileRules.len() == 0 && f.dirRules.len() == 0 && f.metaRules.len() == 0 && len(f.Opt.ExcludeFile) == 0 && f.hashFilterN == 0) } // IncludeRemote returns whether this remote passes the filter rules. func (f *Filter) IncludeRemote(remote string) bool { // filesFrom takes precedence if f.files != nil { _, include := f.files[remote] return include } if f.hashFilterN != 0 { // Normalise the remote first in case we are using a // case insensitive remote or a remote which needs // unicode normalisation. This means all the remotes // which could be normalised together will be in the // same partition. normalized := norm.NFC.String(remote) normalized = strings.ToLower(normalized) hashBytes := md5.Sum([]byte(normalized)) hash := binary.LittleEndian.Uint64(hashBytes[:]) partition := hash % f.hashFilterN if partition != f.hashFilterK { return false } } return f.fileRules.include(remote) } // ListContainsExcludeFile checks if exclude file is present in the list. func (f *Filter) ListContainsExcludeFile(entries fs.DirEntries) bool { if len(f.Opt.ExcludeFile) == 0 { return false } for _, entry := range entries { obj, ok := entry.(fs.Object) if ok { basename := path.Base(obj.Remote()) if slices.Contains(f.Opt.ExcludeFile, basename) { return true } } } return false } // IncludeDirectory returns a function which checks whether this // directory should be included in the sync or not. func (f *Filter) IncludeDirectory(ctx context.Context, fs fs.Fs) func(string) (bool, error) { return func(remote string) (bool, error) { remote = strings.Trim(remote, "/") // first check if we need to remove directory based on // the exclude file excl, err := f.DirContainsExcludeFile(ctx, fs, remote) if err != nil { return false, err } if excl { return false, nil } // filesFrom takes precedence if f.files != nil { _, include := f.dirs[remote] return include, nil } remote += "/" return f.dirRules.include(remote), nil } } // DirContainsExcludeFile checks if exclude file is present in a // directory. If fs is nil, it works properly if ExcludeFile is an // empty string (for testing). func (f *Filter) DirContainsExcludeFile(ctx context.Context, fremote fs.Fs, remote string) (bool, error) { if len(f.Opt.ExcludeFile) > 0 { for _, excludeFile := range f.Opt.ExcludeFile { exists, err := fs.FileExists(ctx, fremote, path.Join(remote, excludeFile)) if err != nil { return false, err } if exists { return true, nil } } } return false, nil } // Include returns whether this object should be included into the // sync or not and logs the reason for exclusion if not included func (f *Filter) Include(remote string, size int64, modTime time.Time, metadata fs.Metadata) bool { // filesFrom takes precedence if f.files != nil { _, include := f.files[remote] if !include { fs.Debugf(remote, "Excluded (FilesFrom Filter)") } return include } if !f.ModTimeFrom.IsZero() && modTime.Before(f.ModTimeFrom) { fs.Debugf(remote, "Excluded (ModTime Filter)") return false } if !f.ModTimeTo.IsZero() && modTime.After(f.ModTimeTo) { fs.Debugf(remote, "Excluded (ModTime Filter)") return false } if f.Opt.MinSize >= 0 && size < int64(f.Opt.MinSize) { fs.Debugf(remote, "Excluded (Size Filter)") return false } if f.Opt.MaxSize >= 0 && size > int64(f.Opt.MaxSize) { fs.Debugf(remote, "Excluded (Size Filter)") return false } if f.metaRules.len() > 0 { metadatas := make([]string, 0, len(metadata)+1) for key, value := range metadata { metadatas = append(metadatas, fmt.Sprintf("%s=%s", key, value)) } if len(metadata) == 0 { // If there is no metadata, add a null one // otherwise the default action isn't taken metadatas = append(metadatas, "\x00=\x00") } if !f.metaRules.includeMany(metadatas) { fs.Debugf(remote, "Excluded (Metadata Filter)") return false } } include := f.IncludeRemote(remote) if !include { fs.Debugf(remote, "Excluded (Path Filter)") } return include } // IncludeObject returns whether this object should be included into // the sync or not. This is a convenience function to avoid calling // o.ModTime(), which is an expensive operation. func (f *Filter) IncludeObject(ctx context.Context, o fs.Object) bool { var modTime time.Time if !f.ModTimeFrom.IsZero() || !f.ModTimeTo.IsZero() { modTime = o.ModTime(ctx) } else { modTime = time.Unix(0, 0) } var metadata fs.Metadata if f.metaRules.len() > 0 { var err error metadata, err = fs.GetMetadata(ctx, o) if err != nil { fs.Errorf(o, "Failed to read metadata: %v", err) metadata = nil } } return f.Include(o.Remote(), o.Size(), modTime, metadata) } // DumpFilters dumps the filters in textual form, 1 per line func (f *Filter) DumpFilters() string { rules := []string{} if !f.ModTimeFrom.IsZero() { rules = append(rules, fmt.Sprintf("Last-modified date must be equal or greater than: %s", f.ModTimeFrom.String())) } if !f.ModTimeTo.IsZero() { rules = append(rules, fmt.Sprintf("Last-modified date must be equal or less than: %s", f.ModTimeTo.String())) } if f.Opt.MinSize >= 0 { rules = append(rules, fmt.Sprintf("Minimum size is: %s", f.Opt.MinSize.ByteUnit())) } if f.Opt.MaxSize >= 0 { rules = append(rules, fmt.Sprintf("Maximum size is: %s", f.Opt.MaxSize.ByteUnit())) } rules = append(rules, "--- File filter rules ---") for _, rule := range f.fileRules.rules { rules = append(rules, rule.String()) } rules = append(rules, "--- Directory filter rules ---") for _, dirRule := range f.dirRules.rules { rules = append(rules, dirRule.String()) } if f.metaRules.len() > 0 { rules = append(rules, "--- Metadata filter rules ---") for _, metaRule := range f.metaRules.rules { rules = append(rules, metaRule.String()) } } return strings.Join(rules, "\n") } // HaveFilesFrom returns true if --files-from has been supplied func (f *Filter) HaveFilesFrom() bool { return f.files != nil } var errFilesFromNotSet = errors.New("--files-from not set so can't use Filter.ListR") // MakeListR makes function to return all the files set using --files-from func (f *Filter) MakeListR(ctx context.Context, NewObject func(ctx context.Context, remote string) (fs.Object, error)) fs.ListRFn { return func(ctx context.Context, dir string, callback fs.ListRCallback) error { ci := fs.GetConfig(ctx) if !f.HaveFilesFrom() { return errFilesFromNotSet } var ( checkers = ci.Checkers remotes = make(chan string, checkers) g, gCtx = errgroup.WithContext(ctx) ) for range checkers { g.Go(func() (err error) { var entries = make(fs.DirEntries, 1) for remote := range remotes { entries[0], err = NewObject(gCtx, remote) if err == fs.ErrorObjectNotFound { // Skip files that are not found } else if err != nil { return err } else { err = callback(entries) if err != nil { return err } } } return nil }) } outer: for remote := range f.files { select { case remotes <- remote: case <-gCtx.Done(): break outer } } close(remotes) return g.Wait() } } // UsesDirectoryFilters returns true if the filter uses directory // filters and false if it doesn't. // // This is used in deciding whether to walk directories or use ListR func (f *Filter) UsesDirectoryFilters() bool { if len(f.dirRules.rules) == 0 { return false } rule := f.dirRules.rules[0] re := rule.Regexp.String() if rule.Include && re == "^.*$" { return false } return true } // Context key for config type configContextKeyType struct{} var configContextKey = configContextKeyType{} // GetConfig returns the global or context sensitive config func GetConfig(ctx context.Context) *Filter { if ctx == nil { return globalConfig } c := ctx.Value(configContextKey) if c == nil { return globalConfig } return c.(*Filter) } // CopyConfig copies the global config (if any) from srcCtx into // dstCtx returning the new context. func CopyConfig(dstCtx, srcCtx context.Context) context.Context { if srcCtx == nil { return dstCtx } c := srcCtx.Value(configContextKey) if c == nil { return dstCtx } return context.WithValue(dstCtx, configContextKey, c) } // AddConfig returns a mutable config structure based on a shallow // copy of that found in ctx and returns a new context with that added // to it. func AddConfig(ctx context.Context) (context.Context, *Filter) { c := GetConfig(ctx) cCopy := new(Filter) *cCopy = *c newCtx := context.WithValue(ctx, configContextKey, cCopy) return newCtx, cCopy } // ReplaceConfig replaces the filter config in the ctx with the one // passed in and returns a new context with that added to it. func ReplaceConfig(ctx context.Context, f *Filter) context.Context { newCtx := context.WithValue(ctx, configContextKey, f) return newCtx } // Context key for the "use filter" flag type useFlagContextKeyType struct{} var useFlagContextKey = useFlagContextKeyType{} // GetUseFilter obtains the "use filter" flag from context // The flag tells filter-aware backends (Drive) to constrain List using filter func GetUseFilter(ctx context.Context) bool { if ctx != nil { if pVal := ctx.Value(useFlagContextKey); pVal != nil { return *(pVal.(*bool)) } } return false } // SetUseFilter returns a context having (re)set the "use filter" flag func SetUseFilter(ctx context.Context, useFilter bool) context.Context { if useFilter == GetUseFilter(ctx) { return ctx // Minimize depth of nested contexts } pVal := new(bool) *pVal = useFilter return context.WithValue(ctx, useFlagContextKey, pVal) } // Reload the filters from the flags func Reload(ctx context.Context) (err error) { fi := GetConfig(ctx) newFilter, err := NewFilter(&Opt) if err != nil { return err } *fi = *newFilter return nil } rclone-v1.71.0/fs/filter/filter_test.go000066400000000000000000000552341505210326400200270ustar00rootroot00000000000000package filter import ( "context" "fmt" "os" "strings" "sync" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest/mockobject" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestNewFilterDefault(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) assert.False(t, f.Opt.DeleteExcluded) assert.Equal(t, fs.SizeSuffix(-1), f.Opt.MinSize) assert.Equal(t, fs.SizeSuffix(-1), f.Opt.MaxSize) assert.Len(t, f.fileRules.rules, 0) assert.Len(t, f.dirRules.rules, 0) assert.Len(t, f.metaRules.rules, 0) assert.Nil(t, f.files) assert.True(t, f.InActive()) } func TestParseHashFilter(t *testing.T) { for _, test := range []struct { hashFilter string n uint64 k uint64 err string }{ {hashFilter: "", err: "no / found"}, {hashFilter: "17", err: "no / found"}, {hashFilter: "-1/2", err: "can't parse K="}, {hashFilter: "1/-2", err: "can't parse N="}, {hashFilter: "0/0", err: "N must be greater than 0"}, {hashFilter: "0/18446744073709551615", k: 0, n: 18446744073709551615}, {hashFilter: "0/18446744073709551616", err: "can't parse N="}, {hashFilter: "18446744073709551615/1", k: 0, n: 1}, {hashFilter: "18446744073709551616/1", err: "can't parse K="}, {hashFilter: "1/2", k: 1, n: 2}, {hashFilter: "17/3", k: 2, n: 3}, {hashFilter: "@/1", k: 0, n: 1}, } { gotK, gotN, gotErr := parseHashFilter(test.hashFilter) if test.err != "" { assert.Error(t, gotErr) assert.ErrorContains(t, gotErr, test.err, test.hashFilter) } else { assert.Equal(t, test.k, gotK, test.hashFilter) assert.Equal(t, test.n, gotN, test.hashFilter) assert.NoError(t, gotErr, test.hashFilter) } } } // testFile creates a temp file with the contents func testFile(t *testing.T, contents string) string { out, err := os.CreateTemp("", "filter_test") require.NoError(t, err) defer func() { err := out.Close() require.NoError(t, err) }() _, err = out.Write([]byte(contents)) require.NoError(t, err) s := out.Name() return s } func TestNewFilterForbiddenMixOfFilesFromAndFilterRule(t *testing.T) { Opt := Opt // Set up the input Opt.FilterRule = []string{"- filter1", "- filter1b"} Opt.FilesFrom = []string{testFile(t, "#comment\nfiles1\nfiles2\n")} rm := func(p string) { err := os.Remove(p) if err != nil { t.Logf("error removing %q: %v", p, err) } } // Reset the input defer func() { rm(Opt.FilesFrom[0]) }() _, err := NewFilter(&Opt) require.Error(t, err) require.Contains(t, err.Error(), "the usage of --files-from overrides all other filters") } func TestNewFilterForbiddenMixOfFilesFromRawAndFilterRule(t *testing.T) { Opt := Opt // Set up the input Opt.FilterRule = []string{"- filter1", "- filter1b"} Opt.FilesFromRaw = []string{testFile(t, "#comment\nfiles1\nfiles2\n")} rm := func(p string) { err := os.Remove(p) if err != nil { t.Logf("error removing %q: %v", p, err) } } // Reset the input defer func() { rm(Opt.FilesFromRaw[0]) }() _, err := NewFilter(&Opt) require.Error(t, err) require.Contains(t, err.Error(), "the usage of --files-from-raw overrides all other filters") } func TestNewFilterWithFilesFromAlone(t *testing.T) { Opt := Opt // Set up the input Opt.FilesFrom = []string{testFile(t, "#comment\nfiles1\nfiles2\n")} rm := func(p string) { err := os.Remove(p) if err != nil { t.Logf("error removing %q: %v", p, err) } } // Reset the input defer func() { rm(Opt.FilesFrom[0]) }() f, err := NewFilter(&Opt) require.NoError(t, err) assert.Len(t, f.files, 2) for _, name := range []string{"files1", "files2"} { _, ok := f.files[name] if !ok { t.Errorf("Didn't find file %q in f.files", name) } } } func TestNewFilterWithFilesFromRaw(t *testing.T) { Opt := Opt // Set up the input Opt.FilesFromRaw = []string{testFile(t, "#comment\nfiles1\nfiles2\n")} rm := func(p string) { err := os.Remove(p) if err != nil { t.Logf("error removing %q: %v", p, err) } } // Reset the input defer func() { rm(Opt.FilesFromRaw[0]) }() f, err := NewFilter(&Opt) require.NoError(t, err) assert.Len(t, f.files, 3) for _, name := range []string{"#comment", "files1", "files2"} { _, ok := f.files[name] if !ok { t.Errorf("Didn't find file %q in f.files", name) } } } func TestNewFilterFullExceptFilesFromOpt(t *testing.T) { Opt := Opt mins := fs.SizeSuffix(100 * 1024) maxs := fs.SizeSuffix(1000 * 1024) // Set up the input Opt.DeleteExcluded = true Opt.FilterRule = []string{"- filter1", "- filter1b"} Opt.FilterFrom = []string{testFile(t, "#comment\n+ filter2\n- filter3\n")} Opt.ExcludeRule = []string{"exclude1"} Opt.ExcludeFrom = []string{testFile(t, "#comment\nexclude2\nexclude3\n")} Opt.IncludeRule = []string{"include1"} Opt.IncludeFrom = []string{testFile(t, "#comment\ninclude2\ninclude3\n")} Opt.MinSize = mins Opt.MaxSize = maxs rm := func(p string) { err := os.Remove(p) if err != nil { t.Logf("error removing %q: %v", p, err) } } // Reset the input defer func() { rm(Opt.FilterFrom[0]) rm(Opt.ExcludeFrom[0]) rm(Opt.IncludeFrom[0]) }() f, err := NewFilter(&Opt) require.NoError(t, err) assert.True(t, f.Opt.DeleteExcluded) assert.Equal(t, f.Opt.MinSize, mins) assert.Equal(t, f.Opt.MaxSize, maxs) got := f.DumpFilters() want := `Minimum size is: 100 KiB Maximum size is: 1000 KiB --- File filter rules --- + (^|/)include1$ + (^|/)include2$ + (^|/)include3$ - (^|/)exclude1$ - (^|/)exclude2$ - (^|/)exclude3$ - (^|/)filter1$ - (^|/)filter1b$ + (^|/)filter2$ - (^|/)filter3$ - ^.*$ --- Directory filter rules --- + ^.*$ - ^.*$` assert.Equal(t, want, got) assert.False(t, f.InActive()) } type includeTest struct { in string size int64 modTime int64 want bool } func testInclude(t *testing.T, f *Filter, tests []includeTest) { t.Helper() for _, test := range tests { got := f.Include(test.in, test.size, time.Unix(test.modTime, 0), nil) assert.Equal(t, test.want, got, fmt.Sprintf("in=%q, size=%v, modTime=%v", test.in, test.size, time.Unix(test.modTime, 0))) } } type includeDirTest struct { in string want bool } func testDirInclude(t *testing.T, f *Filter, tests []includeDirTest) { for _, test := range tests { got, err := f.IncludeDirectory(context.Background(), nil)(test.in) require.NoError(t, err) assert.Equal(t, test.want, got, test.in) } } func TestNewFilterIncludeFiles(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) err = f.AddFile("file1.jpg") require.NoError(t, err) err = f.AddFile("/file2.jpg") require.NoError(t, err) assert.Equal(t, FilesMap{ "file1.jpg": {}, "file2.jpg": {}, }, f.files) assert.Equal(t, FilesMap{}, f.dirs) testInclude(t, f, []includeTest{ {"file1.jpg", 0, 0, true}, {"file2.jpg", 1, 0, true}, {"potato/file2.jpg", 2, 0, false}, {"file3.jpg", 3, 0, false}, }) assert.False(t, f.InActive()) } func TestNewFilterIncludeFilesDirs(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) for _, path := range []string{ "path/to/dir/file1.png", "/path/to/dir/file2.png", "/path/to/file3.png", "/path/to/dir2/file4.png", } { err = f.AddFile(path) require.NoError(t, err) } assert.Equal(t, FilesMap{ "path": {}, "path/to": {}, "path/to/dir": {}, "path/to/dir2": {}, }, f.dirs) testDirInclude(t, f, []includeDirTest{ {"path", true}, {"path/to", true}, {"path/to/", true}, {"/path/to", true}, {"/path/to/", true}, {"path/to/dir", true}, {"path/to/dir2", true}, {"path/too", false}, {"path/three", false}, {"four", false}, }) } func TestNewFilterHaveFilesFrom(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) assert.Equal(t, false, f.HaveFilesFrom()) require.NoError(t, f.AddFile("file")) assert.Equal(t, true, f.HaveFilesFrom()) } func TestNewFilterMakeListR(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) // Check error if no files listR := f.MakeListR(context.Background(), nil) err = listR(context.Background(), "", nil) assert.EqualError(t, err, errFilesFromNotSet.Error()) // Add some files for _, path := range []string{ "path/to/dir/file1.png", "/path/to/dir/file2.png", "/path/to/file3.png", "/path/to/dir2/file4.png", "notfound", } { err = f.AddFile(path) require.NoError(t, err) } assert.Equal(t, 5, len(f.files)) // NewObject function for MakeListR newObjects := FilesMap{} var newObjectMu sync.Mutex NewObject := func(ctx context.Context, remote string) (fs.Object, error) { newObjectMu.Lock() defer newObjectMu.Unlock() if remote == "notfound" { return nil, fs.ErrorObjectNotFound } else if remote == "error" { return nil, assert.AnError } newObjects[remote] = struct{}{} return mockobject.New(remote), nil } // Callback for ListRFn listRObjects := FilesMap{} var callbackMu sync.Mutex listRcallback := func(entries fs.DirEntries) error { callbackMu.Lock() defer callbackMu.Unlock() for _, entry := range entries { listRObjects[entry.Remote()] = struct{}{} } return nil } // Make the listR and call it listR = f.MakeListR(context.Background(), NewObject) err = listR(context.Background(), "", listRcallback) require.NoError(t, err) // Check that the correct objects were created and listed want := FilesMap{ "path/to/dir/file1.png": {}, "path/to/dir/file2.png": {}, "path/to/file3.png": {}, "path/to/dir2/file4.png": {}, } assert.Equal(t, want, newObjects) assert.Equal(t, want, listRObjects) // Now check an error is returned from NewObject require.NoError(t, f.AddFile("error")) err = listR(context.Background(), "", listRcallback) require.EqualError(t, err, assert.AnError.Error()) // The checker will exit by the error above ci := fs.GetConfig(context.Background()) ci.Checkers = 1 // Now check an error is returned from NewObject require.NoError(t, f.AddFile("error")) err = listR(context.Background(), "", listRcallback) require.EqualError(t, err, assert.AnError.Error()) } func TestNewFilterMinSize(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) f.Opt.MinSize = 100 testInclude(t, f, []includeTest{ {"file1.jpg", 100, 0, true}, {"file2.jpg", 101, 0, true}, {"potato/file2.jpg", 99, 0, false}, }) assert.False(t, f.InActive()) } func TestNewFilterMaxSize(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) f.Opt.MaxSize = 100 testInclude(t, f, []includeTest{ {"file1.jpg", 100, 0, true}, {"file2.jpg", 101, 0, false}, {"potato/file2.jpg", 99, 0, true}, }) assert.False(t, f.InActive()) } func TestNewFilterMinAndMaxAge(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) f.ModTimeFrom = time.Unix(1440000002, 0) f.ModTimeTo = time.Unix(1440000003, 0) testInclude(t, f, []includeTest{ {"file1.jpg", 100, 1440000000, false}, {"file2.jpg", 101, 1440000001, false}, {"file3.jpg", 102, 1440000002, true}, {"potato/file1.jpg", 98, 1440000003, true}, {"potato/file2.jpg", 99, 1440000004, false}, }) assert.False(t, f.InActive()) } func TestNewFilterMinAge(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) f.ModTimeTo = time.Unix(1440000002, 0) testInclude(t, f, []includeTest{ {"file1.jpg", 100, 1440000000, true}, {"file2.jpg", 101, 1440000001, true}, {"file3.jpg", 102, 1440000002, true}, {"potato/file1.jpg", 98, 1440000003, false}, {"potato/file2.jpg", 99, 1440000004, false}, }) assert.False(t, f.InActive()) } func TestNewFilterMaxAge(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) f.ModTimeFrom = time.Unix(1440000002, 0) testInclude(t, f, []includeTest{ {"file1.jpg", 100, 1440000000, false}, {"file2.jpg", 101, 1440000001, false}, {"file3.jpg", 102, 1440000002, true}, {"potato/file1.jpg", 98, 1440000003, true}, {"potato/file2.jpg", 99, 1440000004, true}, }) assert.False(t, f.InActive()) } func TestNewFilterMatches(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) add := func(s string) { err := f.AddRule(s) require.NoError(t, err) } add("+ cleared") add("!") add("- /file1.jpg") add("+ /file2.png") add("+ /*.jpg") add("- /*.png") add("- /potato") add("+ /sausage1") add("+ /sausage2*") add("+ /sausage3**") add("+ /a/*.jpg") add("- *") testInclude(t, f, []includeTest{ {"cleared", 100, 0, false}, {"file1.jpg", 100, 0, false}, {"file2.png", 100, 0, true}, {"FILE2.png", 100, 0, false}, {"afile2.png", 100, 0, false}, {"file3.jpg", 101, 0, true}, {"file4.png", 101, 0, false}, {"potato", 101, 0, false}, {"sausage1", 101, 0, true}, {"sausage1/potato", 101, 0, false}, {"sausage2potato", 101, 0, true}, {"sausage2/potato", 101, 0, false}, {"sausage3/potato", 101, 0, true}, {"a/one.jpg", 101, 0, true}, {"a/one.png", 101, 0, false}, {"unicorn", 99, 0, false}, }) testDirInclude(t, f, []includeDirTest{ {"sausage1", false}, {"sausage2", false}, {"sausage2/sub", false}, {"sausage2/sub/dir", false}, {"sausage3", true}, {"SAUSAGE3", false}, {"sausage3/sub", true}, {"sausage3/sub/dir", true}, {"sausage4", false}, {"a", true}, }) assert.False(t, f.InActive()) } func TestNewFilterMatchesIgnoreCase(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) f.Opt.IgnoreCase = true add := func(s string) { err := f.AddRule(s) require.NoError(t, err) } add("+ /file2.png") add("+ /sausage3**") add("- *") testInclude(t, f, []includeTest{ {"file2.png", 100, 0, true}, {"FILE2.png", 100, 0, true}, }) testDirInclude(t, f, []includeDirTest{ {"sausage3", true}, {"SAUSAGE3", true}, }) assert.False(t, f.InActive()) } func TestNewFilterMatchesRegexp(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) add := func(s string) { err := f.AddRule(s) require.NoError(t, err) } add(`+ /{{file\d+\.png}}`) add(`+ *.{{(?i)jpg}}`) add(`- *`) testInclude(t, f, []includeTest{ {"file2.png", 100, 0, true}, {"sub/file2.png", 100, 0, false}, {"file123.png", 100, 0, true}, {"File123.png", 100, 0, false}, {"something.jpg", 100, 0, true}, {"deep/path/something.JPG", 100, 0, true}, {"something.gif", 100, 0, false}, }) testDirInclude(t, f, []includeDirTest{ {"anything at all", true}, }) assert.False(t, f.InActive()) } func TestNewFilterHashFilter(t *testing.T) { const e1 = "filé1.jpg" // one of the unicode E characters const e2 = "filé1.jpg" // a different unicode E character assert.NotEqual(t, e1, e2) for i := 0; i <= 4; i++ { opt := Opt opt.HashFilter = fmt.Sprintf("%d/4", i) opt.ExcludeRule = []string{"*.bin"} f, err := NewFilter(&opt) require.NoError(t, err) t.Run(opt.HashFilter, func(t *testing.T) { testInclude(t, f, []includeTest{ {"file1.jpg", 0, 0, i == 0 || i == 4}, {"FILE1.jpg", 0, 0, i == 0 || i == 4}, {"file2.jpg", 1, 0, i == 2}, {"File2.jpg", 1, 0, i == 2}, {"file3.jpg", 2, 0, i == 1}, {"file4.jpg", 3, 0, i == 2}, {"file5.jpg", 4, 0, i == 0 || i == 4}, {"file6.jpg", 5, 0, i == 1}, {"file7.jpg", 6, 0, i == 3}, {"file8.jpg", 7, 0, i == 3}, {"file9.jpg", 7, 0, i == 1}, {e1, 0, 0, i == 3}, {e2, 0, 0, i == 3}, {"hello" + e1, 0, 0, i == 2}, {"HELLO" + e2, 0, 0, i == 2}, {"hello1" + e1, 0, 0, i == 1}, {"Hello1" + e2, 0, 0, i == 1}, {"exclude.bin", 8, 0, false}, }) }) assert.False(t, f.InActive()) } } type includeTestMetadata struct { in string metadata fs.Metadata want bool } func testIncludeMetadata(t *testing.T, f *Filter, tests []includeTestMetadata) { for _, test := range tests { got := f.Include(test.in, 0, time.Time{}, test.metadata) assert.Equal(t, test.want, got, fmt.Sprintf("in=%q, metadata=%+v", test.in, test.metadata)) } } func TestNewFilterMetadataInclude(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) add := func(s string) { err := f.metaRules.AddRule(s) require.NoError(t, err) } add(`+ t*=t*`) add(`- *`) testIncludeMetadata(t, f, []includeTestMetadata{ {"nil", nil, false}, {"empty", fs.Metadata{}, false}, {"ok1", fs.Metadata{"thing": "thang"}, true}, {"ok2", fs.Metadata{"thing1": "thang1"}, true}, {"missing", fs.Metadata{"Thing1": "Thang1"}, false}, }) assert.False(t, f.InActive()) } func TestNewFilterMetadataExclude(t *testing.T) { f, err := NewFilter(nil) require.NoError(t, err) add := func(s string) { err := f.metaRules.AddRule(s) require.NoError(t, err) } add(`- thing=thang`) add(`+ *`) testIncludeMetadata(t, f, []includeTestMetadata{ {"nil", nil, true}, {"empty", fs.Metadata{}, true}, {"ok1", fs.Metadata{"thing": "thang"}, false}, {"missing1", fs.Metadata{"thing1": "thang1"}, true}, }) assert.False(t, f.InActive()) } func TestFilterAddDirRuleOrFileRule(t *testing.T) { for _, test := range []struct { included bool glob string want string }{ { false, "potato", `--- File filter rules --- - (^|/)potato$ --- Directory filter rules ---`, }, { true, "potato", `--- File filter rules --- + (^|/)potato$ --- Directory filter rules --- + ^.*$`, }, { false, "potato/", `--- File filter rules --- - (^|/)potato/.*$ --- Directory filter rules --- - (^|/)potato/.*$`, }, { true, "potato/", `--- File filter rules --- --- Directory filter rules --- + (^|/)potato/$`, }, { false, "*", `--- File filter rules --- - (^|/)[^/]*$ --- Directory filter rules --- - ^.*$`, }, { true, "*", `--- File filter rules --- + (^|/)[^/]*$ --- Directory filter rules --- + ^.*$`, }, { false, ".*{,/**}", `--- File filter rules --- - (^|/)\.[^/]*(|/.*)$ --- Directory filter rules --- - (^|/)\.[^/]*(|/.*)$`, }, { true, "a/b/c/d", `--- File filter rules --- + (^|/)a/b/c/d$ --- Directory filter rules --- + (^|/)a/b/c/$ + (^|/)a/b/$ + (^|/)a/$`, }, } { f, err := NewFilter(nil) require.NoError(t, err) err = f.Add(test.included, test.glob) require.NoError(t, err) got := f.DumpFilters() assert.Equal(t, test.want, got, fmt.Sprintf("Add(%v, %q)", test.included, test.glob)) } } func testFilterForEachLine(t *testing.T, useStdin, raw bool) { file := testFile(t, `; comment one # another comment two # indented comment three four five six `) defer func() { err := os.Remove(file) require.NoError(t, err) }() lines := []string{} fileName := file if useStdin { in, err := os.Open(file) require.NoError(t, err) oldStdin := os.Stdin os.Stdin = in defer func() { os.Stdin = oldStdin _ = in.Close() }() fileName = "-" } err := forEachLine(fileName, raw, func(s string) error { lines = append(lines, s) return nil }) require.NoError(t, err) if raw { assert.Equal(t, "; comment,one,# another comment,,,two, # indented comment,three ,four ,five, six ", strings.Join(lines, ",")) } else { assert.Equal(t, "one,two,three,four,five,six", strings.Join(lines, ",")) } } func TestFilterForEachLine(t *testing.T) { testFilterForEachLine(t, false, false) } func TestFilterForEachLineStdin(t *testing.T) { testFilterForEachLine(t, true, false) } func TestFilterForEachLineWithRaw(t *testing.T) { testFilterForEachLine(t, false, true) } func TestFilterForEachLineStdinWithRaw(t *testing.T) { testFilterForEachLine(t, true, true) } func TestFilterMatchesFromDocs(t *testing.T) { for _, test := range []struct { glob string included bool file string ignoreCase bool }{ {"file.jpg", true, "file.jpg", false}, {"file.jpg", true, "directory/file.jpg", false}, {"file.jpg", false, "afile.jpg", false}, {"file.jpg", false, "directory/afile.jpg", false}, {"/file.jpg", true, "file.jpg", false}, {"/file.jpg", false, "afile.jpg", false}, {"/file.jpg", false, "directory/file.jpg", false}, {"*.jpg", true, "file.jpg", false}, {"*.jpg", true, "directory/file.jpg", false}, {"*.jpg", false, "file.jpg/anotherfile.png", false}, {"dir/**", true, "dir/file.jpg", false}, {"dir/**", true, "dir/dir1/dir2/file.jpg", false}, {"dir/**", false, "directory/file.jpg", false}, {"dir/**", false, "adir/file.jpg", false}, {"l?ss", true, "less", false}, {"l?ss", true, "lass", false}, {"l?ss", false, "floss", false}, {"h[ae]llo", true, "hello", false}, {"h[ae]llo", true, "hallo", false}, {"h[ae]llo", false, "hullo", false}, {"{one,two}_potato", true, "one_potato", false}, {"{one,two}_potato", true, "two_potato", false}, {"{one,two}_potato", false, "three_potato", false}, {"{one,two}_potato", false, "_potato", false}, {"\\*.jpg", true, "*.jpg", false}, {"\\\\.jpg", true, "\\.jpg", false}, {"\\[one\\].jpg", true, "[one].jpg", false}, {"potato", true, "potato", false}, {"potato", false, "POTATO", false}, {"potato", true, "potato", true}, {"potato", true, "POTATO", true}, } { f, err := NewFilter(nil) require.NoError(t, err) if test.ignoreCase { f.Opt.IgnoreCase = true } err = f.Add(true, test.glob) require.NoError(t, err) err = f.Add(false, "*") require.NoError(t, err) included := f.Include(test.file, 0, time.Unix(0, 0), nil) if included != test.included { t.Errorf("%q match %q: want %v got %v", test.glob, test.file, test.included, included) } } } func TestNewFilterUsesDirectoryFilters(t *testing.T) { for i, test := range []struct { rules []string want bool }{ { rules: []string{}, want: false, }, { rules: []string{ "+ *", }, want: false, }, { rules: []string{ "+ *.jpg", "- *", }, want: false, }, { rules: []string{ "- *.jpg", }, want: false, }, { rules: []string{ "- *.jpg", "+ *", }, want: false, }, { rules: []string{ "+ dir/*.jpg", "- *", }, want: true, }, { rules: []string{ "+ dir/**", }, want: true, }, { rules: []string{ "- dir/**", }, want: true, }, { rules: []string{ "- /dir/**", }, want: true, }, } { what := fmt.Sprintf("#%d", i) f, err := NewFilter(nil) require.NoError(t, err) for _, rule := range test.rules { err := f.AddRule(rule) require.NoError(t, err, what) } got := f.UsesDirectoryFilters() assert.Equal(t, test.want, got, fmt.Sprintf("%s: %s", what, f.DumpFilters())) } } func TestGetConfig(t *testing.T) { ctx := context.Background() // Check nil //lint:ignore SA1012 false positive when running staticcheck, we want to test passing a nil Context and therefore ignore lint suggestion to use context.TODO //nolint:staticcheck // Don't include staticcheck when running golangci-lint to avoid SA1012 config := GetConfig(nil) assert.Equal(t, globalConfig, config) // Check empty config config = GetConfig(ctx) assert.Equal(t, globalConfig, config) // Check adding a config ctx2, config2 := AddConfig(ctx) require.NoError(t, config2.AddRule("+ *.jpg")) assert.NotEqual(t, config2, config) // Check can get config back config2ctx := GetConfig(ctx2) assert.Equal(t, config2, config2ctx) // Check ReplaceConfig f, err := NewFilter(nil) require.NoError(t, err) ctx3 := ReplaceConfig(ctx, f) assert.Equal(t, globalConfig, GetConfig(ctx3)) } rclone-v1.71.0/fs/filter/filterflags/000077500000000000000000000000001505210326400174455ustar00rootroot00000000000000rclone-v1.71.0/fs/filter/filterflags/filterflags.go000066400000000000000000000006001505210326400222720ustar00rootroot00000000000000// Package filterflags implements command line flags to set up a filter package filterflags import ( "github.com/rclone/rclone/fs/config/flags" "github.com/rclone/rclone/fs/filter" "github.com/spf13/pflag" ) // AddFlags adds the non filing system specific flags to the command func AddFlags(flagSet *pflag.FlagSet) { flags.AddFlagsFromOptions(flagSet, "", filter.OptionsInfo) } rclone-v1.71.0/fs/filter/glob.go000066400000000000000000000136641505210326400164270ustar00rootroot00000000000000// rsync style glob parser package filter import ( "bytes" "fmt" "regexp" "strings" "github.com/rclone/rclone/fs" ) // GlobPathToRegexp converts an rsync style glob path to a regexp func GlobPathToRegexp(glob string, ignoreCase bool) (*regexp.Regexp, error) { return globToRegexp(glob, true, true, ignoreCase) } // GlobStringToRegexp converts an rsync style glob string to a regexp // // Without adding of anchors but with ignoring of case, i.e. called // `GlobStringToRegexp(glob, false, true)`, it takes a lenient approach // where the glob "sum" would match "CheckSum", more similar to text // search functions than strict glob filtering. // // With adding of anchors and not ignoring case, i.e. called // `GlobStringToRegexp(glob, true, false)`, it uses a strict glob // interpretation where the previous example would have to be changed to // "*Sum" to match "CheckSum". func GlobStringToRegexp(glob string, addAnchors bool, ignoreCase bool) (*regexp.Regexp, error) { return globToRegexp(glob, false, addAnchors, ignoreCase) } // globToRegexp converts an rsync style glob to a regexp // // Set pathMode true for matching of path/file names, e.g. // special treatment of path separator `/` and double asterisk `**`, // see filtering.md for details. // // Set addAnchors true to add start of string `^` and end of string `$` anchors. func globToRegexp(glob string, pathMode bool, addAnchors bool, ignoreCase bool) (*regexp.Regexp, error) { var re bytes.Buffer if ignoreCase { _, _ = re.WriteString("(?i)") } if addAnchors { if pathMode { if strings.HasPrefix(glob, "/") { glob = glob[1:] _ = re.WriteByte('^') } else { _, _ = re.WriteString("(^|/)") } } else { _, _ = re.WriteString("^") } } consecutiveStars := 0 insertStars := func() error { if consecutiveStars > 0 { if pathMode { switch consecutiveStars { case 1: _, _ = re.WriteString(`[^/]*`) case 2: _, _ = re.WriteString(`.*`) default: return fmt.Errorf("too many stars in %q", glob) } } else { switch consecutiveStars { case 1: _, _ = re.WriteString(`.*`) default: return fmt.Errorf("too many stars in %q", glob) } } } consecutiveStars = 0 return nil } overwriteLastChar := func(c byte) { buf := re.Bytes() buf[len(buf)-1] = c } inBraces := false inBrackets := 0 slashed := false inRegexp := false // inside {{ ... }} inRegexpEnd := false // have received }} waiting for more var next, last rune for _, c := range glob { next, last = c, next if slashed { _, _ = re.WriteRune(c) slashed = false continue } if inRegexpEnd { if c == '}' { // Regexp is ending with }} choose longest segment // Replace final ) with } overwriteLastChar('}') _ = re.WriteByte(')') continue } else { inRegexpEnd = false } } if inRegexp { if c == '}' && last == '}' { inRegexp = false inRegexpEnd = true // Replace final } with ) overwriteLastChar(')') } else { _, _ = re.WriteRune(c) } continue } if c != '*' { err := insertStars() if err != nil { return nil, err } } if inBrackets > 0 { _, _ = re.WriteRune(c) if c == '[' { inBrackets++ } if c == ']' { inBrackets-- } continue } switch c { case '\\': _, _ = re.WriteRune(c) slashed = true case '*': consecutiveStars++ case '?': if pathMode { _, _ = re.WriteString(`[^/]`) } else { _, _ = re.WriteString(`.`) } case '[': _, _ = re.WriteRune(c) inBrackets++ case ']': return nil, fmt.Errorf("mismatched ']' in glob %q", glob) case '{': if inBraces { if last == '{' { inRegexp = true inBraces = false } else { return nil, fmt.Errorf("can't nest '{' '}' in glob %q", glob) } } else { inBraces = true _ = re.WriteByte('(') } case '}': if !inBraces { return nil, fmt.Errorf("mismatched '{' and '}' in glob %q", glob) } _ = re.WriteByte(')') inBraces = false case ',': if inBraces { _ = re.WriteByte('|') } else { _, _ = re.WriteRune(c) } case '.', '+', '(', ')', '|', '^', '$': // regexp meta characters not dealt with above _ = re.WriteByte('\\') _, _ = re.WriteRune(c) default: _, _ = re.WriteRune(c) } } err := insertStars() if err != nil { return nil, err } if inBrackets > 0 { return nil, fmt.Errorf("mismatched '[' and ']' in glob %q", glob) } if inBraces { return nil, fmt.Errorf("mismatched '{' and '}' in glob %q", glob) } if inRegexp { return nil, fmt.Errorf("mismatched '{{' and '}}' in glob %q", glob) } if addAnchors { _ = re.WriteByte('$') } result, err := regexp.Compile(re.String()) if err != nil { return nil, fmt.Errorf("bad glob pattern %q (regexp %q): %w", glob, re.String(), err) } return result, nil } var ( // Can't deal with // / or ** in {} // {{ regexp }} tooHardRe = regexp.MustCompile(`({[^{}]*(\*\*|/)[^{}]*})|\{\{|\}\}`) // Squash all / squashSlash = regexp.MustCompile(`/{2,}`) ) // globToDirGlobs takes a file glob and turns it into a series of // directory globs. When matched with a directory (with a trailing /) // this should answer the question as to whether this glob could be in // this directory. func globToDirGlobs(glob string) (out []string) { if tooHardRe.MatchString(glob) { // Can't figure this one out so return any directory might match fs.Infof(nil, "Can't figure out directory filters from %q: looking in all directories", glob) out = append(out, "/**") return out } // Get rid of multiple /s glob = squashSlash.ReplaceAllString(glob, "/") // Split on / or ** // (** can contain /) for { i := strings.LastIndex(glob, "/") j := strings.LastIndex(glob, "**") what := "" if j > i { i = j what = "**" } if i < 0 { if len(out) == 0 { out = append(out, "/**") } break } glob = glob[:i] newGlob := glob + what + "/" if len(out) == 0 || out[len(out)-1] != newGlob { out = append(out, newGlob) } } return out } rclone-v1.71.0/fs/filter/glob_test.go000066400000000000000000000136641505210326400174660ustar00rootroot00000000000000package filter import ( "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestGlobStringToRegexp(t *testing.T) { for _, test := range []struct { in string want string error string }{ {``, ``, ``}, {`potato`, `potato`, ``}, {`potato,sausage`, `potato,sausage`, ``}, {`/potato`, `/potato`, ``}, {`potato?sausage`, `potato.sausage`, ``}, {`potat[oa]`, `potat[oa]`, ``}, {`potat[a-z]or`, `potat[a-z]or`, ``}, {`potat[[:alpha:]]or`, `potat[[:alpha:]]or`, ``}, {`'.' '+' '(' ')' '|' '^' '$'`, `'\.' '\+' '\(' '\)' '\|' '\^' '\$'`, ``}, {`*.jpg`, `.*\.jpg`, ``}, {`a{b,c,d}e`, `a(b|c|d)e`, ``}, {`potato**`, ``, `too many stars`}, {`potato**sausage`, ``, `too many stars`}, {`*.p[lm]`, `.*\.p[lm]`, ``}, {`[\[\]]`, `[\[\]]`, ``}, {`***potato`, ``, `too many stars`}, {`***`, ``, `too many stars`}, {`ab]c`, ``, `mismatched ']'`}, {`ab[c`, ``, `mismatched '[' and ']'`}, {`ab{x{cd`, ``, `can't nest`}, {`ab{}}cd`, ``, `mismatched '{' and '}'`}, {`ab}c`, ``, `mismatched '{' and '}'`}, {`ab{c`, ``, `mismatched '{' and '}'`}, {`*.{jpg,png,gif}`, `.*\.(jpg|png|gif)`, ``}, {`[a--b]`, ``, `bad glob pattern`}, {`a\*b`, `a\*b`, ``}, {`a\\b`, `a\\b`, ``}, {`a{{.*}}b`, `a(.*)b`, ``}, {`a{{.*}`, ``, `mismatched '{{' and '}}'`}, {`{{regexp}}`, `(regexp)`, ``}, {`\{{{regexp}}`, `\{(regexp)`, ``}, {`/{{regexp}}`, `/(regexp)`, ``}, {`/{{\d{8}}}`, `/(\d{8})`, ``}, {`/{{\}}}`, `/(\})`, ``}, {`{{(?i)regexp}}`, `((?i)regexp)`, ``}, } { for _, ignoreCase := range []bool{false, true} { for _, addAnchors := range []bool{false, true} { gotRe, err := GlobStringToRegexp(test.in, addAnchors, ignoreCase) if test.error == "" { require.NoError(t, err, test.in) prefix := "" suffix := "" if ignoreCase { prefix += "(?i)" } if addAnchors { prefix += "^" suffix += "$" } got := gotRe.String() assert.Equal(t, prefix+test.want+suffix, got, test.in) } else { require.Error(t, err, test.in) assert.Contains(t, err.Error(), test.error, test.in) assert.Nil(t, gotRe) } } } } } func TestGlobPathToRegexp(t *testing.T) { for _, test := range []struct { in string want string error string }{ {``, `(^|/)$`, ``}, {`potato`, `(^|/)potato$`, ``}, {`potato,sausage`, `(^|/)potato,sausage$`, ``}, {`/potato`, `^potato$`, ``}, {`potato?sausage`, `(^|/)potato[^/]sausage$`, ``}, {`potat[oa]`, `(^|/)potat[oa]$`, ``}, {`potat[a-z]or`, `(^|/)potat[a-z]or$`, ``}, {`potat[[:alpha:]]or`, `(^|/)potat[[:alpha:]]or$`, ``}, {`'.' '+' '(' ')' '|' '^' '$'`, `(^|/)'\.' '\+' '\(' '\)' '\|' '\^' '\$'$`, ``}, {`*.jpg`, `(^|/)[^/]*\.jpg$`, ``}, {`a{b,c,d}e`, `(^|/)a(b|c|d)e$`, ``}, {`potato**`, `(^|/)potato.*$`, ``}, {`potato**sausage`, `(^|/)potato.*sausage$`, ``}, {`*.p[lm]`, `(^|/)[^/]*\.p[lm]$`, ``}, {`[\[\]]`, `(^|/)[\[\]]$`, ``}, {`***potato`, ``, `too many stars`}, {`***`, ``, `too many stars`}, {`ab]c`, ``, `mismatched ']'`}, {`ab[c`, ``, `mismatched '[' and ']'`}, {`ab{x{cd`, ``, `can't nest`}, {`ab{}}cd`, ``, `mismatched '{' and '}'`}, {`ab}c`, ``, `mismatched '{' and '}'`}, {`ab{c`, ``, `mismatched '{' and '}'`}, {`*.{jpg,png,gif}`, `(^|/)[^/]*\.(jpg|png|gif)$`, ``}, {`[a--b]`, ``, `bad glob pattern`}, {`a\*b`, `(^|/)a\*b$`, ``}, {`a\\b`, `(^|/)a\\b$`, ``}, {`a{{.*}}b`, `(^|/)a(.*)b$`, ``}, {`a{{.*}`, ``, `mismatched '{{' and '}}'`}, {`{{regexp}}`, `(^|/)(regexp)$`, ``}, {`\{{{regexp}}`, `(^|/)\{(regexp)$`, ``}, {`/{{regexp}}`, `^(regexp)$`, ``}, {`/{{\d{8}}}`, `^(\d{8})$`, ``}, {`/{{\}}}`, `^(\})$`, ``}, {`{{(?i)regexp}}`, `(^|/)((?i)regexp)$`, ``}, } { for _, ignoreCase := range []bool{false, true} { gotRe, err := GlobPathToRegexp(test.in, ignoreCase) if test.error == "" { require.NoError(t, err, test.in) prefix := "" if ignoreCase { prefix = "(?i)" } got := gotRe.String() assert.Equal(t, prefix+test.want, got, test.in) } else { require.Error(t, err, test.in) assert.Contains(t, err.Error(), test.error, test.in) assert.Nil(t, gotRe) } } } } func TestGlobToDirGlobs(t *testing.T) { for _, test := range []struct { in string want []string }{ {`*`, []string{"/**"}}, {`/*`, []string{"/"}}, {`*.jpg`, []string{"/**"}}, {`/*.jpg`, []string{"/"}}, {`//*.jpg`, []string{"/"}}, {`///*.jpg`, []string{"/"}}, {`/a/*.jpg`, []string{"/a/", "/"}}, {`/a//*.jpg`, []string{"/a/", "/"}}, {`/a///*.jpg`, []string{"/a/", "/"}}, {`/a/b/*.jpg`, []string{"/a/b/", "/a/", "/"}}, {`a/*.jpg`, []string{"a/"}}, {`a/b/*.jpg`, []string{"a/b/", "a/"}}, {`*/*/*.jpg`, []string{"*/*/", "*/"}}, {`a/b/`, []string{"a/b/", "a/"}}, {`a/b`, []string{"a/"}}, {`a/b/*.{jpg,png,gif}`, []string{"a/b/", "a/"}}, {`/a/{jpg,png,gif}/*.{jpg,png,gif}`, []string{"/a/{jpg,png,gif}/", "/a/", "/"}}, {`a/{a,a*b,a**c}/d/`, []string{"/**"}}, {`/a/{a,a*b,a/c,d}/d/`, []string{"/**"}}, {`/a/{{.*}}/d/`, []string{"/**"}}, {`**`, []string{"**/"}}, {`a**`, []string{"a**/"}}, {`a**b`, []string{"a**/"}}, {`a**b**c**d`, []string{"a**b**c**/", "a**b**/", "a**/"}}, {`a**b/c**d`, []string{"a**b/c**/", "a**b/", "a**/"}}, {`/A/a**b/B/c**d/C/`, []string{"/A/a**b/B/c**d/C/", "/A/a**b/B/c**d/", "/A/a**b/B/c**/", "/A/a**b/B/", "/A/a**b/", "/A/a**/", "/A/", "/"}}, {`/var/spool/**/ncw`, []string{"/var/spool/**/", "/var/spool/", "/var/", "/"}}, {`var/spool/**/ncw/`, []string{"var/spool/**/ncw/", "var/spool/**/", "var/spool/", "var/"}}, {"/file1.jpg", []string{`/`}}, {"/file2.png", []string{`/`}}, {"/*.jpg", []string{`/`}}, {"/*.png", []string{`/`}}, {"/potato", []string{`/`}}, {"/sausage1", []string{`/`}}, {"/sausage2*", []string{`/`}}, {"/sausage3**", []string{`/sausage3**/`, "/"}}, {"/a/*.jpg", []string{`/a/`, "/"}}, } { _, err := GlobPathToRegexp(test.in, false) assert.NoError(t, err) got := globToDirGlobs(test.in) assert.Equal(t, test.want, got, test.in) } } rclone-v1.71.0/fs/filter/rules.go000066400000000000000000000126121505210326400166260ustar00rootroot00000000000000package filter import ( "bufio" "fmt" "os" "regexp" "slices" "strings" "github.com/rclone/rclone/fs" ) // RulesOpt is configuration for a rule set type RulesOpt struct { FilterRule []string `config:"filter"` FilterFrom []string `config:"filter_from"` ExcludeRule []string `config:"exclude"` ExcludeFrom []string `config:"exclude_from"` IncludeRule []string `config:"include"` IncludeFrom []string `config:"include_from"` } // rule is one filter rule type rule struct { Include bool Regexp *regexp.Regexp } // Match returns true if rule matches path func (r *rule) Match(path string) bool { return r.Regexp.MatchString(path) } // String the rule func (r *rule) String() string { c := "-" if r.Include { c = "+" } return fmt.Sprintf("%s %s", c, r.Regexp.String()) } // rules is a slice of rules type rules struct { rules []rule existing map[string]struct{} } type addFn func(Include bool, glob string) error // add adds a rule if it doesn't exist already func (rs *rules) add(Include bool, re *regexp.Regexp) { if rs.existing == nil { rs.existing = make(map[string]struct{}) } newRule := rule{ Include: Include, Regexp: re, } newRuleString := newRule.String() if _, ok := rs.existing[newRuleString]; ok { return // rule already exists } rs.rules = append(rs.rules, newRule) rs.existing[newRuleString] = struct{}{} } // Add adds a filter rule with include or exclude status indicated func (rs *rules) Add(Include bool, glob string) error { re, err := GlobPathToRegexp(glob, false /* f.Opt.IgnoreCase */) if err != nil { return err } rs.add(Include, re) return nil } type clearFn func() // clear clears all the rules func (rs *rules) clear() { rs.rules = nil rs.existing = nil } // len returns the number of rules func (rs *rules) len() int { return len(rs.rules) } // include returns whether this remote passes the filter rules. func (rs *rules) include(remote string) bool { for _, rule := range rs.rules { if rule.Match(remote) { return rule.Include } } return true } // include returns whether this collection of strings remote passes // the filter rules. // // the first rule is evaluated on all the remotes and if it matches // then the result is returned. If not the next rule is tested and so // on. func (rs *rules) includeMany(remotes []string) bool { for _, rule := range rs.rules { if slices.ContainsFunc(remotes, rule.Match) { return rule.Include } } return true } // forEachLine calls fn on every line in the file pointed to by path // // It ignores empty lines and lines starting with '#' or ';' if raw is false func forEachLine(path string, raw bool, fn func(string) error) (err error) { var scanner *bufio.Scanner if path == "-" { scanner = bufio.NewScanner(os.Stdin) } else { in, err := os.Open(path) if err != nil { return err } scanner = bufio.NewScanner(in) defer fs.CheckClose(in, &err) } for scanner.Scan() { line := scanner.Text() if !raw { line = strings.TrimSpace(line) if len(line) == 0 || line[0] == '#' || line[0] == ';' { continue } } err := fn(line) if err != nil { return err } } return scanner.Err() } // AddRule adds a filter rule with include/exclude indicated by the prefix // // These are // // # Comment // + glob // - glob // ! // // '+' includes the glob, '-' excludes it and '!' resets the filter list // // Line comments may be introduced with '#' or ';' func addRule(rule string, add addFn, clear clearFn) error { switch { case rule == "!": clear() return nil case strings.HasPrefix(rule, "- "): return add(false, rule[2:]) case strings.HasPrefix(rule, "+ "): return add(true, rule[2:]) } return fmt.Errorf("malformed rule %q", rule) } // AddRule adds a filter rule with include/exclude indicated by the prefix // // These are // // # Comment // + glob // - glob // ! // // '+' includes the glob, '-' excludes it and '!' resets the filter list // // Line comments may be introduced with '#' or ';' func (rs *rules) AddRule(rule string) error { return addRule(rule, rs.Add, rs.clear) } // Parse the rules passed in and add them to the function func parseRules(opt *RulesOpt, add addFn, clear clearFn) (err error) { addImplicitExclude := false foundExcludeRule := false for _, rule := range opt.IncludeRule { err = add(true, rule) if err != nil { return err } addImplicitExclude = true } for _, rule := range opt.IncludeFrom { err := forEachLine(rule, false, func(line string) error { return add(true, line) }) if err != nil { return err } addImplicitExclude = true } for _, rule := range opt.ExcludeRule { err = add(false, rule) if err != nil { return err } foundExcludeRule = true } for _, rule := range opt.ExcludeFrom { err := forEachLine(rule, false, func(line string) error { return add(false, line) }) if err != nil { return err } foundExcludeRule = true } if addImplicitExclude && foundExcludeRule { fs.Errorf(nil, "Using --filter is recommended instead of both --include and --exclude as the order they are parsed in is indeterminate") } for _, rule := range opt.FilterRule { err = addRule(rule, add, clear) if err != nil { return err } } for _, rule := range opt.FilterFrom { err := forEachLine(rule, false, func(rule string) error { return addRule(rule, add, clear) }) if err != nil { return err } } if addImplicitExclude { err = add(false, "/**") if err != nil { return err } } return nil } rclone-v1.71.0/fs/fingerprint.go000066400000000000000000000027301505210326400165360ustar00rootroot00000000000000package fs import ( "context" "fmt" "strings" "github.com/rclone/rclone/fs/hash" ) // Fingerprint produces a unique-ish string for an object. // // This is for detecting whether an object has changed since we last // saw it, not for checking object identity between two different // remotes - operations.Equal should be used for that. // // If fast is set then Fingerprint will only include attributes where // usually another operation is not required to fetch them. For // example if fast is set then this won't include hashes on the local // backend. func Fingerprint(ctx context.Context, o ObjectInfo, fast bool) string { var ( out strings.Builder f = o.Fs() features = f.Features() ) fmt.Fprintf(&out, "%d", o.Size()) // Whether we want to do a slow operation or not // // fast true false true false // opIsSlow true true false false // do Op false true true true // // If !fast (slow) do the operation or if !OpIsSlow == // OpIsFast do the operation. // // Eg don't do this for S3 where modtimes are expensive if !fast || !features.SlowModTime { if f.Precision() != ModTimeNotSupported { fmt.Fprintf(&out, ",%v", o.ModTime(ctx).UTC()) } } // Eg don't do this for SFTP/local where hashes are expensive? if !fast || !features.SlowHash { hashType := f.Hashes().GetOne() if hashType != hash.None { hash, err := o.Hash(ctx, hashType) if err == nil { fmt.Fprintf(&out, ",%v", hash) } } } return out.String() } rclone-v1.71.0/fs/fingerprint_test.go000066400000000000000000000035461505210326400176030ustar00rootroot00000000000000package fs_test import ( "context" "fmt" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fstest/mockfs" "github.com/rclone/rclone/fstest/mockobject" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestFingerprint(t *testing.T) { ctx := context.Background() fMock, err := mockfs.NewFs(ctx, "test", "root", nil) require.NoError(t, err) f := fMock.(*mockfs.Fs) f.SetHashes(hash.NewHashSet(hash.MD5)) for i, test := range []struct { fast bool slowModTime bool slowHash bool want string }{ {fast: false, slowModTime: false, slowHash: false, want: "4,0001-01-01 00:00:00 +0000 UTC,8d777f385d3dfec8815d20f7496026dc"}, {fast: false, slowModTime: false, slowHash: true, want: "4,0001-01-01 00:00:00 +0000 UTC,8d777f385d3dfec8815d20f7496026dc"}, {fast: false, slowModTime: true, slowHash: false, want: "4,0001-01-01 00:00:00 +0000 UTC,8d777f385d3dfec8815d20f7496026dc"}, {fast: false, slowModTime: true, slowHash: true, want: "4,0001-01-01 00:00:00 +0000 UTC,8d777f385d3dfec8815d20f7496026dc"}, {fast: true, slowModTime: false, slowHash: false, want: "4,0001-01-01 00:00:00 +0000 UTC,8d777f385d3dfec8815d20f7496026dc"}, {fast: true, slowModTime: false, slowHash: true, want: "4,0001-01-01 00:00:00 +0000 UTC"}, {fast: true, slowModTime: true, slowHash: false, want: "4,8d777f385d3dfec8815d20f7496026dc"}, {fast: true, slowModTime: true, slowHash: true, want: "4"}, } { what := fmt.Sprintf("#%d fast=%v,slowModTime=%v,slowHash=%v", i, test.fast, test.slowModTime, test.slowHash) o := mockobject.New("potato").WithContent([]byte("data"), mockobject.SeekModeRegular) o.SetFs(f) f.Features().SlowModTime = test.slowModTime f.Features().SlowHash = test.slowHash got := fs.Fingerprint(ctx, o, test.fast) assert.Equal(t, test.want, got, what) } } rclone-v1.71.0/fs/fs.go000066400000000000000000000075411505210326400146240ustar00rootroot00000000000000// Package fs is a generic file system interface for rclone object storage systems package fs import ( "context" "errors" "io" "math" "time" ) // Constants const ( // ModTimeNotSupported is a very large precision value to show // mod time isn't supported on this Fs ModTimeNotSupported = 100 * 365 * 24 * time.Hour // MaxLevel is a sentinel representing an infinite depth for listings MaxLevel = math.MaxInt32 // The suffix added to a translated symbolic link LinkSuffix = ".rclonelink" ) // Globals var ( // ErrorNotFoundInConfigFile is returned by NewFs if not found in config file ErrorNotFoundInConfigFile = errors.New("didn't find section in config file") ErrorCantPurge = errors.New("can't purge directory") ErrorCantCopy = errors.New("can't copy object - incompatible remotes") ErrorCantMove = errors.New("can't move object - incompatible remotes") ErrorCantDirMove = errors.New("can't move directory - incompatible remotes") ErrorCantUploadEmptyFiles = errors.New("can't upload empty files to this remote") ErrorDirExists = errors.New("can't copy directory - destination already exists") ErrorCantSetModTime = errors.New("can't set modified time") ErrorCantSetModTimeWithoutDelete = errors.New("can't set modified time without deleting existing object") ErrorDirNotFound = errors.New("directory not found") ErrorObjectNotFound = errors.New("object not found") ErrorLevelNotSupported = errors.New("level value not supported") ErrorListAborted = errors.New("list aborted") ErrorListBucketRequired = errors.New("bucket or container name is needed in remote") ErrorIsFile = errors.New("is a file not a directory") ErrorIsDir = errors.New("is a directory not a file") ErrorNotAFile = errors.New("is not a regular file") ErrorNotDeleting = errors.New("not deleting files as there were IO errors") ErrorNotDeletingDirs = errors.New("not deleting directories as there were IO errors") ErrorOverlapping = errors.New("can't sync or move files on overlapping remotes (try excluding the destination with a filter rule)") ErrorDirectoryNotEmpty = errors.New("directory not empty") ErrorImmutableModified = errors.New("immutable file modified") ErrorPermissionDenied = errors.New("permission denied") ErrorCantShareDirectories = errors.New("this backend can't share directories with link") ErrorNotImplemented = errors.New("optional feature not implemented") ErrorCommandNotFound = errors.New("command not found") ErrorFileNameTooLong = errors.New("file name too long") ) // CheckClose is a utility function used to check the return from // Close in a defer statement. func CheckClose(c io.Closer, err *error) { cerr := c.Close() if *err == nil { *err = cerr } } // FileExists returns true if a file remote exists. // If remote is a directory, FileExists returns false. func FileExists(ctx context.Context, fs Fs, remote string) (bool, error) { _, err := fs.NewObject(ctx, remote) if err != nil { if err == ErrorObjectNotFound || err == ErrorNotAFile || err == ErrorPermissionDenied { return false, nil } return false, err } return true, nil } // GetModifyWindow calculates the maximum modify window between the given Fses // and the Config.ModifyWindow parameter. func GetModifyWindow(ctx context.Context, fss ...Info) time.Duration { window := time.Duration(GetConfig(ctx).ModifyWindow) for _, f := range fss { if f != nil { precision := f.Precision() if precision == ModTimeNotSupported { return ModTimeNotSupported } if precision > window { window = precision } } } return window } rclone-v1.71.0/fs/fs_test.go000066400000000000000000000245241505210326400156630ustar00rootroot00000000000000package fs import ( "context" "encoding/json" "errors" "fmt" "os" "strings" "sync" "testing" "time" "github.com/spf13/pflag" "github.com/stretchr/testify/require" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/lib/pacer" "github.com/stretchr/testify/assert" ) func TestFeaturesDisable(t *testing.T) { ft := new(Features) ft.Copy = func(ctx context.Context, src Object, remote string) (Object, error) { return nil, nil } ft.CaseInsensitive = true assert.NotNil(t, ft.Copy) assert.Nil(t, ft.Purge) ft.Disable("copy") assert.Nil(t, ft.Copy) assert.Nil(t, ft.Purge) assert.True(t, ft.CaseInsensitive) assert.False(t, ft.DuplicateFiles) ft.Disable("caseinsensitive") assert.False(t, ft.CaseInsensitive) assert.False(t, ft.DuplicateFiles) } func TestFeaturesList(t *testing.T) { ft := new(Features) names := strings.Join(ft.List(), ",") assert.True(t, strings.Contains(names, ",Copy,")) } func TestFeaturesEnabled(t *testing.T) { ft := new(Features) ft.CaseInsensitive = true ft.Purge = func(ctx context.Context, dir string) error { return nil } enabled := ft.Enabled() flag, ok := enabled["CaseInsensitive"] assert.Equal(t, true, ok) assert.Equal(t, true, flag, enabled) flag, ok = enabled["Purge"] assert.Equal(t, true, ok) assert.Equal(t, true, flag, enabled) flag, ok = enabled["DuplicateFiles"] assert.Equal(t, true, ok) assert.Equal(t, false, flag, enabled) flag, ok = enabled["Copy"] assert.Equal(t, true, ok) assert.Equal(t, false, flag, enabled) assert.Equal(t, len(ft.List()), len(enabled)) } func TestFeaturesDisableList(t *testing.T) { ft := new(Features) ft.Copy = func(ctx context.Context, src Object, remote string) (Object, error) { return nil, nil } ft.CaseInsensitive = true assert.NotNil(t, ft.Copy) assert.Nil(t, ft.Purge) assert.True(t, ft.CaseInsensitive) assert.False(t, ft.DuplicateFiles) ft.DisableList([]string{"copy", "caseinsensitive"}) assert.Nil(t, ft.Copy) assert.Nil(t, ft.Purge) assert.False(t, ft.CaseInsensitive) assert.False(t, ft.DuplicateFiles) } // Check it satisfies the interface var _ pflag.Value = (*Option)(nil) func TestOption(t *testing.T) { d := &Option{ Name: "potato", Value: SizeSuffix(17 << 20), } assert.Equal(t, "17Mi", d.String()) assert.Equal(t, "SizeSuffix", d.Type()) err := d.Set("18M") assert.NoError(t, err) assert.Equal(t, SizeSuffix(18<<20), d.Value) err = d.Set("sdfsdf") assert.Error(t, err) } var errFoo = errors.New("foo") type dummyPaced struct { retry bool called int wait *sync.Cond } func (dp *dummyPaced) fn() (bool, error) { if dp.wait != nil { dp.wait.L.Lock() dp.wait.Wait() dp.wait.L.Unlock() } dp.called++ return dp.retry, errFoo } func TestPacerCall(t *testing.T) { ctx := context.Background() config := GetConfig(ctx) expectedCalled := config.LowLevelRetries if expectedCalled == 0 { ctx, config = AddConfig(ctx) expectedCalled = 20 config.LowLevelRetries = expectedCalled } p := NewPacer(ctx, pacer.NewDefault(pacer.MinSleep(1*time.Millisecond), pacer.MaxSleep(2*time.Millisecond))) dp := &dummyPaced{retry: true} err := p.Call(dp.fn) require.Equal(t, expectedCalled, dp.called) require.Implements(t, (*fserrors.Retrier)(nil), err) } func TestPacerCallNoRetry(t *testing.T) { p := NewPacer(context.Background(), pacer.NewDefault(pacer.MinSleep(1*time.Millisecond), pacer.MaxSleep(2*time.Millisecond))) dp := &dummyPaced{retry: true} err := p.CallNoRetry(dp.fn) require.Equal(t, 1, dp.called) require.Implements(t, (*fserrors.Retrier)(nil), err) } // Test options var ( nouncOption = Option{ Name: "nounc", } copyLinksOption = Option{ Name: "copy_links", Default: false, NoPrefix: true, ShortOpt: "L", Advanced: true, } caseInsensitiveOption = Option{ Name: "case_insensitive", Default: false, Value: true, Advanced: true, } testOptions = Options{nouncOption, copyLinksOption, caseInsensitiveOption} ) func TestOptionsSetValues(t *testing.T) { assert.Nil(t, testOptions[0].Default) assert.Equal(t, false, testOptions[1].Default) assert.Equal(t, false, testOptions[2].Default) testOptions.setValues() assert.Equal(t, "", testOptions[0].Default) assert.Equal(t, false, testOptions[1].Default) assert.Equal(t, false, testOptions[2].Default) } func TestOptionsGet(t *testing.T) { opt := testOptions.Get("copy_links") assert.Equal(t, ©LinksOption, opt) opt = testOptions.Get("not_found") assert.Nil(t, opt) } func TestOptionsOveridden(t *testing.T) { m := configmap.New() m1 := configmap.Simple{ "nounc": "m1", "copy_links": "m1", } m.AddGetter(m1, configmap.PriorityNormal) m2 := configmap.Simple{ "nounc": "m2", "case_insensitive": "m2", } m.AddGetter(m2, configmap.PriorityConfig) m3 := configmap.Simple{ "nounc": "m3", } m.AddGetter(m3, configmap.PriorityDefault) got := testOptions.Overridden(m) assert.Equal(t, configmap.Simple{ "copy_links": "m1", "nounc": "m1", }, got) } func TestOptionsNonDefault(t *testing.T) { m := configmap.Simple{} got := testOptions.NonDefault(m) assert.Equal(t, configmap.Simple{}, got) m["case_insensitive"] = "false" got = testOptions.NonDefault(m) assert.Equal(t, configmap.Simple{}, got) m["case_insensitive"] = "true" got = testOptions.NonDefault(m) assert.Equal(t, configmap.Simple{"case_insensitive": "true"}, got) } func TestOptionMarshalJSON(t *testing.T) { out, err := json.MarshalIndent(&caseInsensitiveOption, "", "") assert.NoError(t, err) require.Equal(t, `{ "Name": "case_insensitive", "FieldName": "", "Help": "", "Default": false, "Value": true, "Hide": 0, "Required": false, "IsPassword": false, "NoPrefix": false, "Advanced": true, "Exclusive": false, "Sensitive": false, "DefaultStr": "false", "ValueStr": "true", "Type": "bool" }`, string(out)) } func TestOptionGetValue(t *testing.T) { assert.Equal(t, "", nouncOption.GetValue()) assert.Equal(t, false, copyLinksOption.GetValue()) assert.Equal(t, true, caseInsensitiveOption.GetValue()) } func TestOptionString(t *testing.T) { assert.Equal(t, "", nouncOption.String()) assert.Equal(t, "false", copyLinksOption.String()) assert.Equal(t, "true", caseInsensitiveOption.String()) } func TestOptionStringStringArray(t *testing.T) { opt := Option{ Name: "string_array", Default: []string(nil), } assert.Equal(t, "", opt.String()) opt.Default = []string{} assert.Equal(t, "", opt.String()) opt.Default = []string{"a", "b"} assert.Equal(t, "a,b", opt.String()) opt.Default = []string{"hello, world!", "goodbye, world!"} assert.Equal(t, `"hello, world!","goodbye, world!"`, opt.String()) } func TestOptionStringSizeSuffix(t *testing.T) { opt := Option{ Name: "size_suffix", Default: SizeSuffix(0), } assert.Equal(t, "0", opt.String()) opt.Default = SizeSuffix(-1) assert.Equal(t, "off", opt.String()) opt.Default = SizeSuffix(100) assert.Equal(t, "100B", opt.String()) opt.Default = SizeSuffix(1024) assert.Equal(t, "1Ki", opt.String()) } func TestOptionSet(t *testing.T) { o := caseInsensitiveOption assert.Equal(t, true, o.Value) err := o.Set("FALSE") assert.NoError(t, err) assert.Equal(t, false, o.Value) o = copyLinksOption assert.Equal(t, nil, o.Value) err = o.Set("True") assert.NoError(t, err) assert.Equal(t, true, o.Value) err = o.Set("INVALID") assert.Error(t, err) assert.Equal(t, true, o.Value) } func TestOptionType(t *testing.T) { assert.Equal(t, "string", nouncOption.Type()) assert.Equal(t, "bool", copyLinksOption.Type()) assert.Equal(t, "bool", caseInsensitiveOption.Type()) } func TestOptionFlagName(t *testing.T) { assert.Equal(t, "local-nounc", nouncOption.FlagName("local")) assert.Equal(t, "copy-links", copyLinksOption.FlagName("local")) assert.Equal(t, "local-case-insensitive", caseInsensitiveOption.FlagName("local")) } func TestOptionEnvVarName(t *testing.T) { assert.Equal(t, "RCLONE_LOCAL_NOUNC", nouncOption.EnvVarName("local")) assert.Equal(t, "RCLONE_LOCAL_COPY_LINKS", copyLinksOption.EnvVarName("local")) assert.Equal(t, "RCLONE_LOCAL_CASE_INSENSITIVE", caseInsensitiveOption.EnvVarName("local")) } func TestOptionGetters(t *testing.T) { // Set up env vars envVars := [][2]string{ {"RCLONE_CONFIG_LOCAL_POTATO_PIE", "yes"}, {"RCLONE_COPY_LINKS", "TRUE"}, {"RCLONE_LOCAL_NOUNC", "NOUNC"}, } for _, ev := range envVars { assert.NoError(t, os.Setenv(ev[0], ev[1])) } defer func() { for _, ev := range envVars { assert.NoError(t, os.Unsetenv(ev[0])) } }() oldConfigFileGet := ConfigFileGet ConfigFileGet = func(section, key string) (string, bool) { if section == "sausage" && key == "key1" { return "value1", true } return "", false } defer func() { ConfigFileGet = oldConfigFileGet }() // set up getters // A configmap.Getter to read from the environment RCLONE_CONFIG_backend_option_name configEnvVarsGetter := configEnvVars("local") // A configmap.Getter to read from the environment RCLONE_option_name optionEnvVarsGetter := optionEnvVars{"local", testOptions} // A configmap.Getter to read either the default value or the set // value from the RegInfo.Options regInfoValuesGetterFalse := ®InfoValues{ options: testOptions, useDefault: false, } regInfoValuesGetterTrue := ®InfoValues{ options: testOptions, useDefault: true, } // A configmap.Setter to read from the config file configFileGetter := getConfigFile("sausage") for i, test := range []struct { get configmap.Getter key string wantValue string wantOk bool }{ {configEnvVarsGetter, "not_found", "", false}, {configEnvVarsGetter, "potato_pie", "yes", true}, {optionEnvVarsGetter, "not_found", "", false}, {optionEnvVarsGetter, "copy_links", "TRUE", true}, {optionEnvVarsGetter, "nounc", "NOUNC", true}, {optionEnvVarsGetter, "case_insensitive", "", false}, {regInfoValuesGetterFalse, "not_found", "", false}, {regInfoValuesGetterFalse, "case_insensitive", "true", true}, {regInfoValuesGetterFalse, "copy_links", "", false}, {regInfoValuesGetterTrue, "not_found", "", false}, {regInfoValuesGetterTrue, "case_insensitive", "true", true}, {regInfoValuesGetterTrue, "copy_links", "false", true}, {configFileGetter, "not_found", "", false}, {configFileGetter, "key1", "value1", true}, } { what := fmt.Sprintf("%d: %+v: %q", i, test.get, test.key) gotValue, gotOk := test.get.Get(test.key) assert.Equal(t, test.wantValue, gotValue, what) assert.Equal(t, test.wantOk, gotOk, what) } } rclone-v1.71.0/fs/fserrors/000077500000000000000000000000001505210326400155235ustar00rootroot00000000000000rclone-v1.71.0/fs/fserrors/enospc_error.go000066400000000000000000000006211505210326400205510ustar00rootroot00000000000000//go:build !plan9 package fserrors import ( "syscall" liberrors "github.com/rclone/rclone/lib/errors" ) // IsErrNoSpace checks a possibly wrapped error to // see if it contains a ENOSPC error func IsErrNoSpace(cause error) (isNoSpc bool) { liberrors.Walk(cause, func(c error) bool { if c == syscall.ENOSPC { isNoSpc = true return true } isNoSpc = false return false }) return } rclone-v1.71.0/fs/fserrors/enospc_error_notsupported.go000066400000000000000000000003161505210326400234000ustar00rootroot00000000000000//go:build plan9 package fserrors // IsErrNoSpace on plan9 returns false because // plan9 does not support syscall.ENOSPC error. func IsErrNoSpace(cause error) (isNoSpc bool) { isNoSpc = false return } rclone-v1.71.0/fs/fserrors/error.go000066400000000000000000000266541505210326400172200ustar00rootroot00000000000000// Package fserrors provides errors and error handling package fserrors import ( "context" "errors" "fmt" "io" "net/http" "slices" "strings" "time" liberrors "github.com/rclone/rclone/lib/errors" ) // Must be satisfied for errors.Is/errors.As/Errors.Unwrap type unwrapper interface { Unwrap() error } // Retrier is an optional interface for error as to whether the // operation should be retried at a high level. // // This should be returned from Update or Put methods as required type Retrier interface { error Retry() bool } // retryError is a type of error type retryError string // Error interface func (r retryError) Error() string { return string(r) } // Retry interface func (r retryError) Retry() bool { return true } // Check interfaces var _ Retrier = retryError("") // RetryErrorf makes an error which indicates it would like to be retried func RetryErrorf(format string, a ...any) error { return retryError(fmt.Sprintf(format, a...)) } // wrappedRetryError is an error wrapped so it will satisfy the // Retrier interface and return true type wrappedRetryError struct { error } // Retry interface func (err wrappedRetryError) Retry() bool { return true } // Check interfaces var _ Retrier = wrappedRetryError{error(nil)} var _ unwrapper = wrappedRetryError{} // RetryError makes an error which indicates it would like to be retried func RetryError(err error) error { if err == nil { err = errors.New("needs retry") } return wrappedRetryError{err} } func (err wrappedRetryError) Unwrap() error { return err.error } // IsRetryError returns true if err conforms to the Retry interface // and calling the Retry method returns true. func IsRetryError(err error) (isRetry bool) { liberrors.Walk(err, func(err error) bool { if r, ok := err.(Retrier); ok { isRetry = r.Retry() return true } return false }) return } // Fataler is an optional interface for error as to whether the // operation should cause the entire operation to finish immediately. // // This should be returned from Update or Put methods as required type Fataler interface { error Fatal() bool } // wrappedFatalError is an error wrapped so it will satisfy the // Retrier interface and return true type wrappedFatalError struct { error } // Fatal interface func (err wrappedFatalError) Fatal() bool { return true } // Check interfaces var _ Fataler = wrappedFatalError{error(nil)} var _ unwrapper = wrappedFatalError{} // FatalError makes an error which indicates it is a fatal error and // the sync should stop. func FatalError(err error) error { if err == nil { err = errors.New("fatal error") } return wrappedFatalError{err} } func (err wrappedFatalError) Unwrap() error { return err.error } // IsFatalError returns true if err conforms to the Fatal interface // and calling the Fatal method returns true. func IsFatalError(err error) (isFatal bool) { liberrors.Walk(err, func(err error) bool { if r, ok := err.(Fataler); ok { isFatal = r.Fatal() return true } return false }) return } // NoRetrier is an optional interface for error as to whether the // operation should not be retried at a high level. // // If only NoRetry errors are returned in a sync then the sync won't // be retried. // // This should be returned from Update or Put methods as required type NoRetrier interface { error NoRetry() bool } // wrappedNoRetryError is an error wrapped so it will satisfy the // Retrier interface and return true type wrappedNoRetryError struct { error } // NoRetry interface func (err wrappedNoRetryError) NoRetry() bool { return true } // Check interfaces var _ NoRetrier = wrappedNoRetryError{error(nil)} var _ unwrapper = wrappedNoRetryError{} // NoRetryError makes an error which indicates the sync shouldn't be // retried. func NoRetryError(err error) error { return wrappedNoRetryError{err} } func (err wrappedNoRetryError) Unwrap() error { return err.error } // IsNoRetryError returns true if err conforms to the NoRetry // interface and calling the NoRetry method returns true. func IsNoRetryError(err error) (isNoRetry bool) { liberrors.Walk(err, func(err error) bool { if r, ok := err.(NoRetrier); ok { isNoRetry = r.NoRetry() return true } return false }) return } // NoLowLevelRetrier is an optional interface for error as to whether // the operation should not be retried at a low level. // // NoLowLevelRetry errors won't be retried by low level retry loops. type NoLowLevelRetrier interface { error NoLowLevelRetry() bool } // wrappedNoLowLevelRetryError is an error wrapped so it will satisfy the // NoLowLevelRetrier interface and return true type wrappedNoLowLevelRetryError struct { error } // NoLowLevelRetry interface func (err wrappedNoLowLevelRetryError) NoLowLevelRetry() bool { return true } // Check interfaces var _ NoLowLevelRetrier = wrappedNoLowLevelRetryError{error(nil)} var _ unwrapper = wrappedNoLowLevelRetryError{} // NoLowLevelRetryError makes an error which indicates the sync // shouldn't be low level retried. func NoLowLevelRetryError(err error) error { return wrappedNoLowLevelRetryError{err} } // Unwrap returns the underlying error func (err wrappedNoLowLevelRetryError) Unwrap() error { return err.error } // IsNoLowLevelRetryError returns true if err conforms to the NoLowLevelRetry // interface and calling the NoLowLevelRetry method returns true. func IsNoLowLevelRetryError(err error) (isNoLowLevelRetry bool) { liberrors.Walk(err, func(err error) bool { if r, ok := err.(NoLowLevelRetrier); ok { isNoLowLevelRetry = r.NoLowLevelRetry() return true } return false }) return } // RetryAfter is an optional interface for error as to whether the // operation should be retried after a given delay // // This should be returned from Update or Put methods as required and // will cause the entire sync to be retried after a delay. type RetryAfter interface { error RetryAfter() time.Time } // ErrorRetryAfter is an error which expresses a time that should be // waited for until trying again type ErrorRetryAfter time.Time // NewErrorRetryAfter returns an ErrorRetryAfter with the given // duration as an endpoint func NewErrorRetryAfter(d time.Duration) ErrorRetryAfter { return ErrorRetryAfter(time.Now().Add(d)) } // Error returns the textual version of the error func (e ErrorRetryAfter) Error() string { return fmt.Sprintf("try again after %v (%v)", time.Time(e).Format(time.RFC3339Nano), time.Until(time.Time(e))) } // RetryAfter returns the time the operation should be retried at or // after func (e ErrorRetryAfter) RetryAfter() time.Time { return time.Time(e) } // Check interfaces var _ RetryAfter = ErrorRetryAfter{} // RetryAfterErrorTime returns the time that the RetryAfter error // indicates or a Zero time.Time func RetryAfterErrorTime(err error) (retryAfter time.Time) { liberrors.Walk(err, func(err error) bool { if r, ok := err.(RetryAfter); ok { retryAfter = r.RetryAfter() return true } return false }) return } // IsRetryAfterError returns true if err is an ErrorRetryAfter func IsRetryAfterError(err error) bool { return !RetryAfterErrorTime(err).IsZero() } // CountableError is an optional interface for error. It stores a boolean // which signifies if the error has already been counted or not type CountableError interface { error Count() IsCounted() bool } // wrappedCountableError is an error wrapped so it will satisfy the // Retrier interface and return true type wrappedCountableError struct { error isCounted bool } // CountableError interface func (err *wrappedCountableError) Count() { err.isCounted = true } // CountableError interface func (err *wrappedCountableError) IsCounted() bool { return err.isCounted } func (err wrappedCountableError) Unwrap() error { return err.error } // IsCounted returns true if err conforms to the CountableError interface // and has already been counted func IsCounted(err error) bool { if r, ok := err.(CountableError); ok { return r.IsCounted() } return false } // Count sets the isCounted variable on the error if it conforms to the // CountableError interface func Count(err error) { if r, ok := err.(CountableError); ok { r.Count() } } // Check interface var _ CountableError = &wrappedCountableError{error: error(nil)} var _ unwrapper = wrappedCountableError{} // FsError makes an error which can keep a record that it is already counted // or not func FsError(err error) error { if err == nil { err = errors.New("countable error") } return &wrappedCountableError{error: err} } // Cause is a souped up errors.Cause which can unwrap some standard // library errors too. It returns true if any of the intermediate // errors had a Timeout() or Temporary() method which returned true. func Cause(cause error) (retriable bool, err error) { liberrors.Walk(cause, func(c error) bool { // Check for net error Timeout() if x, ok := c.(interface { Timeout() bool }); ok && x.Timeout() { retriable = true } // Check for net error Temporary() if x, ok := c.(interface { Temporary() bool }); ok && x.Temporary() { retriable = true } err = c return false }) return } // retriableErrorStrings is a list of phrases which when we find it // in an error, we know it is a networking error which should be // retried. // // This is incredibly ugly - if only errors.Cause worked for all // errors and all errors were exported from the stdlib. var retriableErrorStrings = []string{ "use of closed network connection", // internal/poll/fd.go "unexpected EOF reading trailer", // net/http/transfer.go "transport connection broken", // net/http/transport.go "http: ContentLength=", // net/http/transfer.go "server closed idle connection", // net/http/transport.go "bad record MAC", // crypto/tls/alert.go "stream error:", // net/http/h2_bundle.go "tls: use of closed connection", // crypto/tls/conn.go } // Errors which indicate networking errors which should be retried // // These are added to in retriable_errors*.go var retriableErrors = []error{ io.EOF, io.ErrUnexpectedEOF, } // ShouldRetry looks at an error and tries to work out if retrying the // operation that caused it would be a good idea. It returns true if // the error implements Timeout() or Temporary() or if the error // indicates a premature closing of the connection. func ShouldRetry(err error) bool { if err == nil { return false } // If error has been marked to NoLowLevelRetry then don't retry if IsNoLowLevelRetryError(err) { return false } // Find root cause if available retriable, err := Cause(err) if retriable { return true } // Check if it is a retriable error if slices.Contains(retriableErrors, err) { return true } // Check error strings (yuch!) too errString := err.Error() for _, phrase := range retriableErrorStrings { if strings.Contains(errString, phrase) { return true } } return false } // ShouldRetryHTTP returns a boolean as to whether this resp deserves. // It checks to see if the HTTP response code is in the slice // retryErrorCodes. func ShouldRetryHTTP(resp *http.Response, retryErrorCodes []int) bool { if resp == nil { return false } return slices.Contains(retryErrorCodes, resp.StatusCode) } // ContextError checks to see if ctx is in error. // // If it is in error then it overwrites *perr with the context error // if *perr was nil and returns true. // // Otherwise it returns false. func ContextError(ctx context.Context, perr *error) bool { if ctxErr := ctx.Err(); ctxErr != nil { if *perr == nil { *perr = ctxErr } return true } return false } rclone-v1.71.0/fs/fserrors/error_syscall_test.go000066400000000000000000000031301505210326400217710ustar00rootroot00000000000000//go:build !plan9 // +build !plan9 package fserrors import ( "fmt" "net" "net/url" "os" "syscall" "testing" "github.com/stretchr/testify/assert" ) // make a plausible network error with the underlying errno func makeNetErr(errno syscall.Errno) error { return &net.OpError{ Op: "write", Net: "tcp", Source: &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 123}, Addr: &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8080}, Err: &os.SyscallError{ Syscall: "write", Err: errno, }, } } func TestWithSyscallCause(t *testing.T) { for i, test := range []struct { err error wantRetriable bool wantErr error }{ {makeNetErr(syscall.EAGAIN), true, syscall.EAGAIN}, {makeNetErr(syscall.Errno(123123123)), false, syscall.Errno(123123123)}, } { gotRetriable, gotErr := Cause(test.err) what := fmt.Sprintf("test #%d: %v", i, test.err) assert.Equal(t, test.wantErr, gotErr, what) assert.Equal(t, test.wantRetriable, gotRetriable, what) } } func TestWithSyscallShouldRetry(t *testing.T) { for i, test := range []struct { err error want bool }{ {makeNetErr(syscall.EAGAIN), true}, {makeNetErr(syscall.Errno(123123123)), false}, { wrap(&url.Error{ Op: "post", URL: "http://localhost/", Err: makeNetErr(syscall.EPIPE), }, "potato error"), true, }, { wrap(&url.Error{ Op: "post", URL: "http://localhost/", Err: makeNetErr(syscall.Errno(123123123)), }, "listing error"), false, }, } { got := ShouldRetry(test.err) assert.Equal(t, test.want, got, fmt.Sprintf("test #%d: %v", i, test.err)) } } rclone-v1.71.0/fs/fserrors/error_test.go000066400000000000000000000105621505210326400202460ustar00rootroot00000000000000package fserrors import ( "context" "errors" "fmt" "io" "net/url" "testing" "time" "github.com/stretchr/testify/assert" ) // withMessage wraps an error with a message // // This is for backwards compatibility with the now removed github.com/pkg/errors type withMessage struct { cause error msg string } func (w *withMessage) Error() string { return w.msg + ": " + w.cause.Error() } func (w *withMessage) Cause() error { return w.cause } // wrap returns an error annotating err with a stack trace // at the point Wrap is called, and the supplied message. // If err is nil, Wrap returns nil. func wrap(err error, message string) error { if err == nil { return nil } return &withMessage{ cause: err, msg: message, } } var errUseOfClosedNetworkConnection = errors.New("use of closed network connection") type myError1 struct { Err error } func (e myError1) Error() string { return e.Err.Error() } type myError2 struct { Err error } func (e *myError2) Error() string { if e == nil { return "myError2(nil)" } if e.Err == nil { return "myError2{Err: nil}" } return e.Err.Error() } type myError3 struct { Err int } func (e *myError3) Error() string { return "hello" } type myError4 struct { e error } func (e *myError4) Error() string { return e.e.Error() } type myError5 struct{} func (e *myError5) Error() string { return "" } func (e *myError5) Temporary() bool { return true } type errorCause struct { e error } func (e *errorCause) Error() string { return fmt.Sprintf("%#v", e) } func (e *errorCause) Cause() error { return e.e } func TestCause(t *testing.T) { e3 := &myError3{3} e4 := &myError4{io.EOF} e5 := &myError5{} eNil1 := &myError2{nil} eNil2 := &myError2{Err: (*myError2)(nil)} errPotato := errors.New("potato") nilCause1 := &errorCause{nil} nilCause2 := &errorCause{(*myError2)(nil)} for i, test := range []struct { err error wantRetriable bool wantErr error }{ {nil, false, nil}, {errPotato, false, errPotato}, {fmt.Errorf("potato: %w", errPotato), false, errPotato}, {fmt.Errorf("potato2: %w", wrap(errPotato, "potato")), false, errPotato}, {errUseOfClosedNetworkConnection, false, errUseOfClosedNetworkConnection}, {eNil1, false, eNil1}, {eNil2, false, eNil2.Err}, {myError1{io.EOF}, false, io.EOF}, {&myError2{io.EOF}, false, io.EOF}, {e3, false, e3}, {e4, false, e4}, {e5, true, e5}, {&errorCause{errPotato}, false, errPotato}, {nilCause1, false, nilCause1}, {nilCause2, false, nilCause2.e}, } { gotRetriable, gotErr := Cause(test.err) what := fmt.Sprintf("test #%d: %v", i, test.err) assert.Equal(t, test.wantErr, gotErr, what) assert.Equal(t, test.wantRetriable, gotRetriable, what) } } func TestShouldRetry(t *testing.T) { for i, test := range []struct { err error want bool }{ {nil, false}, {errors.New("potato"), false}, {fmt.Errorf("connection: %w", errUseOfClosedNetworkConnection), true}, {io.EOF, true}, {io.ErrUnexpectedEOF, true}, {&url.Error{Op: "post", URL: "/", Err: io.EOF}, true}, {&url.Error{Op: "post", URL: "/", Err: errUseOfClosedNetworkConnection}, true}, {&url.Error{Op: "post", URL: "/", Err: fmt.Errorf("net/http: HTTP/1.x transport connection broken: %v", fmt.Errorf("http: ContentLength=%d with Body length %d", 100663336, 99590598))}, true}, } { got := ShouldRetry(test.err) assert.Equal(t, test.want, got, fmt.Sprintf("test #%d: %v", i, test.err)) } } func TestRetryAfter(t *testing.T) { e := NewErrorRetryAfter(time.Second) after := e.RetryAfter() dt := time.Until(after) assert.True(t, dt >= 900*time.Millisecond && dt <= 1100*time.Millisecond) assert.True(t, IsRetryAfterError(e)) assert.False(t, IsRetryAfterError(io.EOF)) assert.Equal(t, time.Time{}, RetryAfterErrorTime(io.EOF)) assert.False(t, IsRetryAfterError(nil)) assert.Contains(t, e.Error(), "try again after") t0 := time.Now() err := fmt.Errorf("potato: %w", ErrorRetryAfter(t0)) assert.Equal(t, t0, RetryAfterErrorTime(err)) assert.True(t, IsRetryAfterError(err)) assert.Contains(t, e.Error(), "try again after") } func TestContextError(t *testing.T) { var err = io.EOF ctx, cancel := context.WithCancel(context.Background()) assert.False(t, ContextError(ctx, &err)) assert.Equal(t, io.EOF, err) cancel() assert.True(t, ContextError(ctx, &err)) assert.Equal(t, io.EOF, err) err = nil assert.True(t, ContextError(ctx, &err)) assert.Equal(t, context.Canceled, err) } rclone-v1.71.0/fs/fserrors/retriable_errors.go000066400000000000000000000004741505210326400214240ustar00rootroot00000000000000//go:build !plan9 package fserrors import ( "syscall" ) func init() { retriableErrors = append(retriableErrors, syscall.EPIPE, syscall.ETIMEDOUT, syscall.ECONNREFUSED, syscall.EHOSTDOWN, syscall.EHOSTUNREACH, syscall.ECONNABORTED, syscall.EAGAIN, syscall.EWOULDBLOCK, syscall.ECONNRESET, ) } rclone-v1.71.0/fs/fserrors/retriable_errors_windows.go000066400000000000000000000031741505210326400231760ustar00rootroot00000000000000//go:build windows package fserrors import ( "syscall" ) // Windows error code list // https://docs.microsoft.com/en-us/windows/win32/winsock/windows-sockets-error-codes-2 const ( WSAENETDOWN syscall.Errno = 10050 WSAENETUNREACH syscall.Errno = 10051 WSAENETRESET syscall.Errno = 10052 WSAECONNABORTED syscall.Errno = 10053 WSAECONNRESET syscall.Errno = 10054 WSAENOBUFS syscall.Errno = 10055 WSAENOTCONN syscall.Errno = 10057 WSAESHUTDOWN syscall.Errno = 10058 WSAETIMEDOUT syscall.Errno = 10060 WSAECONNREFUSED syscall.Errno = 10061 WSAEHOSTDOWN syscall.Errno = 10064 WSAEHOSTUNREACH syscall.Errno = 10065 WSAEDISCON syscall.Errno = 10101 WSAEREFUSED syscall.Errno = 10112 WSAHOST_NOT_FOUND syscall.Errno = 11001 //nolint:revive // Don't include revive when running golangci-lint to avoid var-naming: don't use ALL_CAPS in Go names; use CamelCase (revive) WSATRY_AGAIN syscall.Errno = 11002 //nolint:revive // Don't include revive when running golangci-lint to avoid var-naming: don't use ALL_CAPS in Go names; use CamelCase (revive) ) func init() { // append some lower level errors since the standardized ones // don't seem to happen retriableErrors = append(retriableErrors, syscall.WSAECONNRESET, WSAENETDOWN, WSAENETUNREACH, WSAENETRESET, WSAECONNABORTED, WSAECONNRESET, WSAENOBUFS, WSAENOTCONN, WSAESHUTDOWN, WSAETIMEDOUT, WSAECONNREFUSED, WSAEHOSTDOWN, WSAEHOSTUNREACH, WSAEDISCON, WSAEREFUSED, WSAHOST_NOT_FOUND, WSATRY_AGAIN, syscall.ERROR_HANDLE_EOF, syscall.ERROR_NETNAME_DELETED, syscall.ERROR_BROKEN_PIPE, ) } rclone-v1.71.0/fs/fshttp/000077500000000000000000000000001505210326400151665ustar00rootroot00000000000000rclone-v1.71.0/fs/fshttp/dialer.go000066400000000000000000000067461505210326400167720ustar00rootroot00000000000000package fshttp import ( "context" "net" "runtime" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "golang.org/x/net/ipv4" "golang.org/x/net/ipv6" ) // Dialer structure contains default dialer and timeout, tclass support type Dialer struct { net.Dialer timeout time.Duration tclass int } // NewDialer creates a Dialer structure with Timeout, Keepalive, // LocalAddr and DSCP set from rclone flags. func NewDialer(ctx context.Context) *Dialer { ci := fs.GetConfig(ctx) dialer := &Dialer{ Dialer: net.Dialer{ Timeout: time.Duration(ci.ConnectTimeout), KeepAlive: 30 * time.Second, }, timeout: time.Duration(ci.Timeout), tclass: int(ci.TrafficClass), } if ci.BindAddr != nil { dialer.Dialer.LocalAddr = &net.TCPAddr{IP: ci.BindAddr} } return dialer } // Dial connects to the network address. func (d *Dialer) Dial(network, address string) (net.Conn, error) { return d.DialContext(context.Background(), network, address) } var warnDSCPFail, warnDSCPWindows sync.Once // DialContext connects to the network address using the provided context. func (d *Dialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) { // If local address is 0.0.0.0 or ::0 force IPv4 or IPv6 // This works around https://github.com/golang/go/issues/48723 // Which means 0.0.0.0 and ::0 both bind to both IPv4 and IPv6 if ip, ok := d.Dialer.LocalAddr.(*net.TCPAddr); ok && ip.IP.IsUnspecified() && (network == "tcp" || network == "udp") { if ip.IP.To4() != nil { network += "4" // IPv4 address } else { network += "6" // IPv6 address } } c, err := d.Dialer.DialContext(ctx, network, address) if err != nil { return c, err } if d.tclass != 0 { // IPv6 addresses must have two or more ":" if strings.Count(c.RemoteAddr().String(), ":") > 1 { err = ipv6.NewConn(c).SetTrafficClass(d.tclass) } else { err = ipv4.NewConn(c).SetTOS(d.tclass) // Warn of silent failure on Windows (IPv4 only, IPv6 caught by error handler) if runtime.GOOS == "windows" { warnDSCPWindows.Do(func() { fs.LogLevelPrintf(fs.LogLevelWarning, nil, "dialer: setting DSCP on Windows/IPv4 fails silently; see https://github.com/golang/go/issues/42728") }) } } if err != nil { warnDSCPFail.Do(func() { fs.LogLevelPrintf(fs.LogLevelWarning, nil, "dialer: failed to set DSCP socket options: %v", err) }) } } t := &timeoutConn{ Conn: c, timeout: d.timeout, } return t, t.nudgeDeadline() } // A net.Conn that sets deadline for every Read/Write operation type timeoutConn struct { net.Conn timeout time.Duration } // Nudge the deadline for an idle timeout on by c.timeout if non-zero func (c *timeoutConn) nudgeDeadline() error { if c.timeout > 0 { return c.SetDeadline(time.Now().Add(c.timeout)) } return nil } // Read bytes with rate limiting and idle timeouts func (c *timeoutConn) Read(b []byte) (n int, err error) { // Ideally we would LimitBandwidth(len(b)) here and replace tokens we didn't use n, err = c.Conn.Read(b) accounting.TokenBucket.LimitBandwidth(accounting.TokenBucketSlotTransportRx, n) if err == nil && n > 0 && c.timeout > 0 { err = c.nudgeDeadline() } return n, err } // Write bytes with rate limiting and idle timeouts func (c *timeoutConn) Write(b []byte) (n int, err error) { accounting.TokenBucket.LimitBandwidth(accounting.TokenBucketSlotTransportTx, len(b)) n, err = c.Conn.Write(b) if err == nil && n > 0 && c.timeout > 0 { err = c.nudgeDeadline() } return n, err } rclone-v1.71.0/fs/fshttp/http.go000066400000000000000000000362701505210326400165040ustar00rootroot00000000000000// Package fshttp contains the common http parts of the config, Transport and Client package fshttp import ( "bytes" "context" "crypto/tls" "crypto/x509" "encoding/pem" "errors" "fmt" "net" "net/http" "net/http/cookiejar" "net/http/httputil" "net/url" "os" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/lib/structs" "github.com/youmark/pkcs8" "golang.org/x/net/publicsuffix" ) const ( separatorReq = ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" separatorResp = "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<" ) var ( transport *Transport noTransport = new(sync.Once) cookieJar, _ = cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List}) logMutex sync.Mutex // UnixSocketConfig describes the option to configure the path to a unix domain socket to connect to UnixSocketConfig = fs.Option{ Name: "unix_socket", Help: "Path to a unix domain socket to dial to, instead of opening a TCP connection directly", Advanced: true, Default: "", } ) // ResetTransport resets the existing transport, allowing it to take new settings. // Should only be used for testing. func ResetTransport() { noTransport = new(sync.Once) } // LoadKeyPair loads a TLS certificate and private key from PEM-encoded files, // with extended support for encrypted private keys. // // This function is designed as a robust replacement for tls.X509KeyPair, // providing the same core functionality but adding support for // password-protected private keys. // // The certificate file (certFile) must contain one or more PEM-encoded // certificates. The first certificate is treated as the leaf certificate, and // any subsequent certificates are treated as its chain. // // The key file (keyFile) must contain a PEM-encoded private key. Supported // formats are: // // - Unencrypted PKCS#1 ("BEGIN RSA PRIVATE KEY") // - Unencrypted PKCS#8 ("BEGIN PRIVATE KEY") // - Encrypted PKCS#8 ("BEGIN ENCRYPTED PRIVATE KEY") // - Legacy PEM encryption (e.g., DEK-Info headers), which are automatically detected. // // The password parameter is used to decrypt the private key. If the // key is not encrypted, this parameter is ignored and can be an empty // string. The password should be an obscured string. // // On success, it returns a fully populated tls.Certificate struct, including the // Leaf certificate field. func LoadKeyPair(certFile, keyFile, password string) (cert tls.Certificate, err error) { certPEM, err := os.ReadFile(certFile) if err != nil { return cert, fmt.Errorf("read cert: %w", err) } keyPEM, err := os.ReadFile(keyFile) if err != nil { return cert, fmt.Errorf("read key: %w", err) } if password != "" { password, err = obscure.Reveal(password) if err != nil { return cert, fmt.Errorf("reveal key password: %w", err) } } // Fast path: unencrypted PKCS#1/PKCS#8 cert, err = tls.X509KeyPair(certPEM, keyPEM) if err == nil { if len(cert.Certificate) == 0 { return cert, errors.New("no certificates parsed") } leaf, err := x509.ParseCertificate(cert.Certificate[0]) if err != nil { return cert, fmt.Errorf("parse leaf: %w", err) } cert.Leaf = leaf return cert, nil } // Decrypt / parse key manually block, rest := pem.Decode(keyPEM) if block == nil { return cert, errors.New("no PEM block in key") } if len(rest) != 0 { fs.Debugf(nil, "Trailing data (%d bytes) in key PEM loaded from %q", len(rest), keyFile) } var privKey any switch { case block.Type == "ENCRYPTED PRIVATE KEY": if password == "" { return cert, errors.New("key is encrypted but no --client-pass provided") } privKey, err = pkcs8.ParsePKCS8PrivateKey(block.Bytes, []byte(password)) if err != nil { return cert, fmt.Errorf("parse encrypted PKCS#8: %w", err) } case x509.IsEncryptedPEMBlock(block): //nolint:staticcheck // this is Legacy and insecure if password == "" { return cert, errors.New("key is encrypted but no --client-pass provided") } der, err := x509.DecryptPEMBlock(block, []byte(password)) //nolint:staticcheck // this is Legacy and insecure if err != nil { return cert, fmt.Errorf("decrypt PEM key: %w", err) } // Try PKCS#8, then RSA PKCS#1, then EC if k, kerr1 := x509.ParsePKCS8PrivateKey(der); kerr1 == nil { privKey = k } else if k, kerr2 := x509.ParsePKCS1PrivateKey(der); kerr2 == nil { privKey = k } else if k, kerr3 := x509.ParseECPrivateKey(der); kerr3 == nil { privKey = k } else { return cert, fmt.Errorf("parse decrypted key: pkcs8: %v, pkcs1: %v, ec: %v", kerr1, kerr2, kerr3) } default: // Unencrypted specific types switch block.Type { case "PRIVATE KEY": k, kerr := x509.ParsePKCS8PrivateKey(block.Bytes) if kerr != nil { return cert, fmt.Errorf("parse PKCS#8: %w", kerr) } privKey = k case "RSA PRIVATE KEY": k, kerr := x509.ParsePKCS1PrivateKey(block.Bytes) if kerr != nil { return cert, fmt.Errorf("parse PKCS#1 RSA: %w", kerr) } privKey = k case "EC PRIVATE KEY": k, kerr := x509.ParseECPrivateKey(block.Bytes) if kerr != nil { return cert, fmt.Errorf("parse EC: %w", kerr) } privKey = k default: return cert, fmt.Errorf("unsupported key type %q", block.Type) } } // Build cert chain from PEM var certDERs [][]byte for rest := certPEM; ; { var b *pem.Block b, rest = pem.Decode(rest) if b == nil { break } if b.Type == "CERTIFICATE" { certDERs = append(certDERs, b.Bytes) } } if len(certDERs) == 0 { return cert, fmt.Errorf("no CERTIFICATE blocks in %s", certFile) } cert = tls.Certificate{ Certificate: certDERs, PrivateKey: privKey, } // Leaf is always the first certificate cert.Leaf, err = x509.ParseCertificate(cert.Certificate[0]) if err != nil { return cert, fmt.Errorf("parse leaf: %w", err) } return cert, nil } // NewTransportCustom returns an http.RoundTripper with the correct timeouts. // The customize function is called if set to give the caller an opportunity to // customize any defaults in the Transport. func NewTransportCustom(ctx context.Context, customize func(*http.Transport)) *Transport { ci := fs.GetConfig(ctx) // Start with a sensible set of defaults then override. // This also means we get new stuff when it gets added to go t := new(http.Transport) structs.SetDefaults(t, http.DefaultTransport.(*http.Transport)) if ci.HTTPProxy != "" { proxyURL, err := url.Parse(ci.HTTPProxy) if err != nil { t.Proxy = func(*http.Request) (*url.URL, error) { return nil, fmt.Errorf("failed to set --http-proxy from %q: %w", ci.HTTPProxy, err) } } else { t.Proxy = http.ProxyURL(proxyURL) } } else { t.Proxy = http.ProxyFromEnvironment } t.MaxIdleConnsPerHost = 2 * (ci.Checkers + ci.Transfers + 1) t.MaxIdleConns = 2 * t.MaxIdleConnsPerHost t.TLSHandshakeTimeout = time.Duration(ci.ConnectTimeout) t.ResponseHeaderTimeout = time.Duration(ci.Timeout) t.DisableKeepAlives = ci.DisableHTTPKeepAlives // TLS Config t.TLSClientConfig = &tls.Config{ InsecureSkipVerify: ci.InsecureSkipVerify, } // Load client certs if ci.ClientCert != "" || ci.ClientKey != "" { if ci.ClientCert == "" || ci.ClientKey == "" { fs.Fatalf(nil, "Both --client-cert and --client-key must be set") } cert, err := LoadKeyPair(ci.ClientCert, ci.ClientKey, ci.ClientPass) if err != nil { fs.Fatalf(nil, "Failed to load --client-cert/--client-key pair: %v", err) } t.TLSClientConfig.Certificates = []tls.Certificate{cert} } // Load CA certs if len(ci.CaCert) != 0 { caCertPool := x509.NewCertPool() for _, cert := range ci.CaCert { caCert, err := os.ReadFile(cert) if err != nil { fs.Fatalf(nil, "Failed to read --ca-cert file %q : %v", cert, err) } ok := caCertPool.AppendCertsFromPEM(caCert) if !ok { fs.Fatalf(nil, "Failed to add certificates from --ca-cert file %q", cert) } } t.TLSClientConfig.RootCAs = caCertPool } t.DisableCompression = ci.NoGzip t.DialContext = func(reqCtx context.Context, network, addr string) (net.Conn, error) { return NewDialer(ctx).DialContext(reqCtx, network, addr) } t.IdleConnTimeout = 60 * time.Second t.ExpectContinueTimeout = time.Duration(ci.ExpectContinueTimeout) if ci.Dump&(fs.DumpHeaders|fs.DumpBodies|fs.DumpAuth|fs.DumpRequests|fs.DumpResponses) != 0 { fs.Debugf(nil, "You have specified to dump information. Please be noted that the "+ "Accept-Encoding as shown may not be correct in the request and the response may not show "+ "Content-Encoding if the go standard libraries auto gzip encoding was in effect. In this case"+ " the body of the request will be gunzipped before showing it.") } if ci.DisableHTTP2 { t.TLSNextProto = map[string]func(string, *tls.Conn) http.RoundTripper{} } // customize the transport if required if customize != nil { customize(t) } // Wrap that http.Transport in our own transport return newTransport(ci, t) } // NewTransport returns an http.RoundTripper with the correct timeouts func NewTransport(ctx context.Context) *Transport { (*noTransport).Do(func() { transport = NewTransportCustom(ctx, nil) }) return transport } // NewClient returns an http.Client with the correct timeouts func NewClient(ctx context.Context) *http.Client { return NewClientCustom(ctx, nil) } // NewClientCustom returns an http.Client with the correct timeouts. // It allows customizing the transport, using NewTransportCustom. func NewClientCustom(ctx context.Context, customize func(*http.Transport)) *http.Client { ci := fs.GetConfig(ctx) client := &http.Client{ Transport: NewTransportCustom(ctx, customize), } if ci.Cookie { client.Jar = cookieJar } return client } // NewClientWithUnixSocket returns an http.Client with the correct timeout. // It internally uses NewClientCustom with a custom dialer connecting to // the specified unix domain socket. func NewClientWithUnixSocket(ctx context.Context, path string) *http.Client { return NewClientCustom(ctx, func(t *http.Transport) { t.DialContext = func(reqCtx context.Context, network, addr string) (net.Conn, error) { return NewDialer(ctx).DialContext(reqCtx, "unix", path) } }) } // Transport is our http Transport which wraps an http.Transport // * Sets the User Agent // * Does logging // * Updates metrics type Transport struct { *http.Transport ci *fs.ConfigInfo dump fs.DumpFlags filterRequest func(req *http.Request) userAgent string headers []*fs.HTTPOption metrics *Metrics // Mutex for serializing attempts at reloading the certificates reloadMutex sync.Mutex } // newTransport wraps the http.Transport passed in and logs all // roundtrips including the body if logBody is set. func newTransport(ci *fs.ConfigInfo, transport *http.Transport) *Transport { return &Transport{ Transport: transport, ci: ci, dump: ci.Dump, userAgent: ci.UserAgent, headers: ci.Headers, metrics: DefaultMetrics, } } // SetRequestFilter sets a filter to be used on each request func (t *Transport) SetRequestFilter(f func(req *http.Request)) { t.filterRequest = f } // A mutex to protect this map var checkedHostMu sync.RWMutex // A map of servers we have checked for time var checkedHost = make(map[string]struct{}, 1) // Check the server time is the same as ours, once for each server func checkServerTime(req *http.Request, resp *http.Response) { host := req.URL.Host if req.Host != "" { host = req.Host } checkedHostMu.RLock() _, ok := checkedHost[host] checkedHostMu.RUnlock() if ok { return } dateString := resp.Header.Get("Date") if dateString == "" { return } date, err := http.ParseTime(dateString) if err != nil { fs.Debugf(nil, "Couldn't parse Date: from server %s: %q: %v", host, dateString, err) return } dt := time.Since(date) const window = 5 * 60 * time.Second if dt > window || dt < -window { fs.Logf(nil, "Time may be set wrong - time from %q is %v different from this computer", host, dt) } checkedHostMu.Lock() checkedHost[host] = struct{}{} checkedHostMu.Unlock() } // cleanAuth gets rid of one authBuf header within the first 4k func cleanAuth(buf, authBuf []byte) []byte { // Find how much buffer to check n := min(len(buf), 4096) // See if there is an Authorization: header i := bytes.Index(buf[:n], authBuf) if i < 0 { return buf } i += len(authBuf) // Overwrite the next 4 chars with 'X' for j := 0; i < len(buf) && j < 4; j++ { if buf[i] == '\n' { break } buf[i] = 'X' i++ } // Snip out to the next '\n' j := bytes.IndexByte(buf[i:], '\n') if j < 0 { return buf[:i] } n = copy(buf[i:], buf[i+j:]) return buf[:i+n] } var authBufs = [][]byte{ []byte("Authorization: "), []byte("X-Auth-Token: "), } // cleanAuths gets rid of all the possible Auth headers func cleanAuths(buf []byte) []byte { for _, authBuf := range authBufs { buf = cleanAuth(buf, authBuf) } return buf } var expireWindow = 30 * time.Second func isCertificateExpired(cc *tls.Config) bool { return len(cc.Certificates) > 0 && cc.Certificates[0].Leaf != nil && time.Until(cc.Certificates[0].Leaf.NotAfter) < expireWindow } func (t *Transport) reloadCertificates() { t.reloadMutex.Lock() defer t.reloadMutex.Unlock() // Check that the certificate is expired before trying to reload it // it might have been reloaded while we were waiting to lock the mutex if !isCertificateExpired(t.TLSClientConfig) { return } cert, err := LoadKeyPair(t.ci.ClientCert, t.ci.ClientKey, t.ci.ClientPass) if err != nil { fs.Fatalf(nil, "Failed to load --client-cert/--client-key pair: %v", err) } t.TLSClientConfig.Certificates = []tls.Certificate{cert} } // RoundTrip implements the RoundTripper interface. func (t *Transport) RoundTrip(req *http.Request) (resp *http.Response, err error) { // Check if certificates are being used and the certificates are expired if isCertificateExpired(t.TLSClientConfig) { t.reloadCertificates() } // Limit transactions per second if required accounting.LimitTPS(req.Context()) // Force user agent req.Header.Set("User-Agent", t.userAgent) // Set user defined headers for _, option := range t.headers { req.Header.Set(option.Key, option.Value) } // Filter the request if required if t.filterRequest != nil { t.filterRequest(req) } // Logf request if t.dump&(fs.DumpHeaders|fs.DumpBodies|fs.DumpAuth|fs.DumpRequests|fs.DumpResponses) != 0 { buf, _ := httputil.DumpRequestOut(req, t.dump&(fs.DumpBodies|fs.DumpRequests) != 0) if t.dump&fs.DumpAuth == 0 { buf = cleanAuths(buf) } logMutex.Lock() fs.Debugf(nil, "%s", separatorReq) fs.Debugf(nil, "%s (req %p)", "HTTP REQUEST", req) fs.Debugf(nil, "%s", string(buf)) fs.Debugf(nil, "%s", separatorReq) logMutex.Unlock() } // Do round trip resp, err = t.Transport.RoundTrip(req) // Logf response if t.dump&(fs.DumpHeaders|fs.DumpBodies|fs.DumpAuth|fs.DumpRequests|fs.DumpResponses) != 0 { logMutex.Lock() fs.Debugf(nil, "%s", separatorResp) fs.Debugf(nil, "%s (req %p)", "HTTP RESPONSE", req) if err != nil { fs.Debugf(nil, "Error: %v", err) } else { buf, _ := httputil.DumpResponse(resp, t.dump&(fs.DumpBodies|fs.DumpResponses) != 0) fs.Debugf(nil, "%s", string(buf)) } fs.Debugf(nil, "%s", separatorResp) logMutex.Unlock() } // Update metrics t.metrics.onResponse(req, resp) if err == nil { checkServerTime(req, resp) } return resp, err } rclone-v1.71.0/fs/fshttp/http_test.go000066400000000000000000000131401505210326400175320ustar00rootroot00000000000000package fshttp import ( "context" "crypto/rand" "crypto/rsa" "crypto/tls" "crypto/x509" "crypto/x509/pkix" "encoding/pem" "fmt" "math/big" "net/http" "net/http/httptest" "os" "testing" "time" "github.com/rclone/rclone/fs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestCleanAuth(t *testing.T) { for _, test := range []struct { in string want string }{ {"", ""}, {"floo", "floo"}, {"Authorization: ", "Authorization: "}, {"Authorization: \n", "Authorization: \n"}, {"Authorization: A", "Authorization: X"}, {"Authorization: A\n", "Authorization: X\n"}, {"Authorization: AAAA", "Authorization: XXXX"}, {"Authorization: AAAA\n", "Authorization: XXXX\n"}, {"Authorization: AAAAA", "Authorization: XXXX"}, {"Authorization: AAAAA\n", "Authorization: XXXX\n"}, {"Authorization: AAAA\n", "Authorization: XXXX\n"}, {"Authorization: AAAAAAAAA\nPotato: Help\n", "Authorization: XXXX\nPotato: Help\n"}, {"Sausage: 1\nAuthorization: AAAAAAAAA\nPotato: Help\n", "Sausage: 1\nAuthorization: XXXX\nPotato: Help\n"}, } { got := string(cleanAuth([]byte(test.in), authBufs[0])) assert.Equal(t, test.want, got, test.in) } } func TestCleanAuths(t *testing.T) { for _, test := range []struct { in string want string }{ {"", ""}, {"floo", "floo"}, {"Authorization: AAAAAAAAA\nPotato: Help\n", "Authorization: XXXX\nPotato: Help\n"}, {"X-Auth-Token: AAAAAAAAA\nPotato: Help\n", "X-Auth-Token: XXXX\nPotato: Help\n"}, {"X-Auth-Token: AAAAAAAAA\nAuthorization: AAAAAAAAA\nPotato: Help\n", "X-Auth-Token: XXXX\nAuthorization: XXXX\nPotato: Help\n"}, } { got := string(cleanAuths([]byte(test.in))) assert.Equal(t, test.want, got, test.in) } } var certSerial = int64(0) // Create a test certificate and key pair that is valid for a specific // duration func createTestCert(validity time.Duration) (keyPEM []byte, certPEM []byte, err error) { key, err := rsa.GenerateKey(rand.Reader, 1024) if err != nil { return } keyBytes := x509.MarshalPKCS1PrivateKey(key) // PEM encoding of private key keyPEM = pem.EncodeToMemory( &pem.Block{ Type: "RSA PRIVATE KEY", Bytes: keyBytes, }, ) // Now create the certificate notBefore := time.Now() notAfter := notBefore.Add(validity).Add(expireWindow) certSerial += 1 template := x509.Certificate{ SerialNumber: big.NewInt(certSerial), Subject: pkix.Name{CommonName: "localhost"}, SignatureAlgorithm: x509.SHA256WithRSA, NotBefore: notBefore, NotAfter: notAfter, BasicConstraintsValid: true, KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageKeyAgreement | x509.KeyUsageKeyEncipherment | x509.KeyUsageDataEncipherment, ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth}, } derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key) if err != nil { return } certPEM = pem.EncodeToMemory( &pem.Block{ Type: "CERTIFICATE", Bytes: derBytes, }, ) return } func writeTestCert(t *testing.T, ci *fs.ConfigInfo, validity time.Duration) { keyPEM, certPEM, err := createTestCert(1 * time.Second) assert.NoError(t, err, "Cannot create test cert") err = os.WriteFile(ci.ClientCert, certPEM, 0666) assert.NoError(t, err, "Failed to write cert") err = os.WriteFile(ci.ClientKey, keyPEM, 0666) assert.NoError(t, err, "Failed to write key") } func TestCertificates(t *testing.T) { startTime := time.Now() // Starting a TLS server expectedSerial := int64(0) ts := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { cert := r.TLS.PeerCertificates require.Greater(t, len(cert), 0, "No certificates received") expectedSerial += 1 assert.Equal(t, expectedSerial, cert[0].SerialNumber.Int64(), "Did not get the correct serial number in certificate") // Check that the certificate hasn't expired. We cannot use cert validation // functions because those check for signature as well and our certificates // are not properly signed if time.Now().After(cert[0].NotAfter) { assert.Fail(t, "Certificate expired", "Certificate expires at %s, current time is %s", cert[0].NotAfter.Sub(startTime), time.Since(startTime)) } // Write some test data to fulfill the request w.Header().Set("Content-Type", "text/plain") _, _ = fmt.Fprintln(w, "test data") })) defer ts.Close() // Modify servers config to request a client certificate // we cannot validate the certificate since we are not properly signing it ts.TLS.ClientAuth = tls.RequestClientCert // Set --client-cert and --client-key in config to // a pair of temp files // create a test cert/key pair and write it to the files ctx := context.TODO() ci := fs.GetConfig(ctx) // Create a test certificate and write it to a temp file ci.ClientCert = t.TempDir() + "client.cert" ci.ClientKey = t.TempDir() + "client.key" validity := 1 * time.Second writeTestCert(t, ci, validity) // Now create the client with the above settings // we need to disable TLS verification since we don't // care about server certificate client := NewClient(ctx) tt := client.Transport.(*Transport) tt.TLSClientConfig.InsecureSkipVerify = true // Now make requests, the first request should be within // the valid window _, err := client.Get(ts.URL) assert.NoError(t, err) // Wait for the 2* valid duration of the certificate so that has definitely expired time.Sleep(2 * validity) // Create a new cert and write it to files writeTestCert(t, ci, validity) // The new cert should be auto-loaded before we make this request _, err = client.Get(ts.URL) assert.NoError(t, err) } rclone-v1.71.0/fs/fshttp/prometheus.go000066400000000000000000000022131505210326400177060ustar00rootroot00000000000000package fshttp import ( "fmt" "net/http" "github.com/prometheus/client_golang/prometheus" ) // Metrics provide Transport HTTP level metrics. type Metrics struct { StatusCode *prometheus.CounterVec } // NewMetrics creates a new metrics instance, the instance shall be assigned to // DefaultMetrics before any processing takes place. func NewMetrics(namespace string) *Metrics { return &Metrics{ StatusCode: prometheus.NewCounterVec(prometheus.CounterOpts{ Namespace: namespace, Subsystem: "http", Name: "status_code", }, []string{"host", "method", "code"}), } } // DefaultMetrics specifies metrics used for new Transports. var DefaultMetrics = (*Metrics)(nil) // Collectors returns all prometheus metrics as collectors for registration. func (m *Metrics) Collectors() []prometheus.Collector { if m == nil { return nil } return []prometheus.Collector{ m.StatusCode, } } func (m *Metrics) onResponse(req *http.Request, resp *http.Response) { if m == nil { return } var statusCode = 0 if resp != nil { statusCode = resp.StatusCode } m.StatusCode.WithLabelValues(req.Host, req.Method, fmt.Sprint(statusCode)).Inc() } rclone-v1.71.0/fs/fspath/000077500000000000000000000000001505210326400151435ustar00rootroot00000000000000rclone-v1.71.0/fs/fspath/fuzz.go000066400000000000000000000013631505210326400164730ustar00rootroot00000000000000//go:build gofuzz /* Fuzz test the Parse function Generate corpus go test -v -make-corpus Install go fuzz go get -u github.com/dvyukov/go-fuzz/go-fuzz github.com/dvyukov/go-fuzz/go-fuzz-build Compile and fuzz go-fuzz-build go-fuzz Tidy up rm -rf corpus/ crashers/ suppressions/ git co ../../go.mod ../../go.sum */ package fspath func Fuzz(data []byte) int { path := string(data) parsed, err := Parse(path) if err != nil { return 0 } if parsed.Name == "" { if parsed.ConfigString != "" { panic("bad ConfigString") } if parsed.Path != path { panic("local path not preserved") } } else { if parsed.ConfigString+":"+parsed.Path != path { panic("didn't split properly") } } return 0 } rclone-v1.71.0/fs/fspath/path.go000066400000000000000000000254551505210326400164410ustar00rootroot00000000000000// Package fspath contains routines for fspath manipulation package fspath import ( "errors" "path" "path/filepath" "regexp" "strings" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/driveletter" ) const ( configNameRe = `[\w\p{L}\p{N}.+@]+(?:[ -]+[\w\p{L}\p{N}.+@-]+)*` // May contain Unicode numbers and letters, as well as `_` (covered by \w), `-`, `.`, `+`, `@` and space, but not start with `-` (it complicates usage, see #4261) or space, and not end with space illegalPartOfConfigNameRe = `^[ -]+|[^\w\p{L}\p{N}.+@ -]+|[ ]+$` ) var ( errInvalidCharacters = errors.New("config name contains invalid characters - may only contain numbers, letters, `_`, `-`, `.`, `+`, `@` and space, while not start with `-` or space, and not end with space") errCantBeEmpty = errors.New("can't use empty string as a path") errBadConfigParam = errors.New("config parameters may only contain `0-9`, `A-Z`, `a-z`, `_` and `.`") errEmptyConfigParam = errors.New("config parameters can't be empty") errConfigNameEmpty = errors.New("config name can't be empty") errConfigName = errors.New("config name needs a trailing `:`") errParam = errors.New("config parameter must end with `,` or `:`") errValue = errors.New("unquoted config value must end with `,` or `:`") errQuotedValue = errors.New("unterminated quoted config value") errAfterQuote = errors.New("expecting `:` or `,` or another quote after a quote") errSyntax = errors.New("syntax error in config string") // configNameMatcher is a pattern to match an rclone config name configNameMatcher = regexp.MustCompile(`^` + configNameRe + `$`) // illegalPartOfConfigNameMatcher is a pattern to match a sequence of characters not allowed in an rclone config name illegalPartOfConfigNameMatcher = regexp.MustCompile(illegalPartOfConfigNameRe) // remoteNameMatcher is a pattern to match an rclone remote name at the start of a config remoteNameMatcher = regexp.MustCompile(`^:?` + configNameRe + `(?::$|,)`) ) // CheckConfigName returns an error if configName is invalid func CheckConfigName(configName string) error { if !configNameMatcher.MatchString(configName) { return errInvalidCharacters } return nil } // MakeConfigName makes an input into something legal to be used as a config name. // Returns a string where any sequences of illegal characters are replaced with // a single underscore. If the input is already valid as a config name, it is // returned unchanged. If the input is an empty string, a single underscore is // returned. func MakeConfigName(name string) string { if name == "" { return "_" } if configNameMatcher.MatchString(name) { return name } return illegalPartOfConfigNameMatcher.ReplaceAllString(name, "_") } // checkRemoteName returns an error if remoteName is invalid func checkRemoteName(remoteName string) error { if remoteName == ":" || remoteName == "::" { return errConfigNameEmpty } if !remoteNameMatcher.MatchString(remoteName) { return errInvalidCharacters } return nil } // Return true if c is a valid character for a config parameter func isConfigParam(c rune) bool { return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_' || c == '.') } // Parsed is returned from Parse with the results of the connection string decomposition // // If Name is "" then it is a local path in Path // // Note that ConfigString + ":" + Path is equal to the input of Parse except that Path may have had // \ converted to / type Parsed struct { Name string // Just the name of the config: "remote" or ":backend" ConfigString string // The whole config string: "remote:" or ":backend,value=6:" Path string // The file system path, may be empty Config configmap.Simple // key/value config parsed out of ConfigString may be nil } // Parse deconstructs a path into a Parsed structure // // If the path is a local path then parsed.Name will be returned as "". // // So "remote:path/to/dir" will return Parsed{Name:"remote", Path:"path/to/dir"}, // and "/path/to/local" will return Parsed{Name:"", Path:"/path/to/local"} // // Note that this will turn \ into / in the fsPath on Windows // // An error may be returned if the remote name has invalid characters or the // parameters are invalid or the path is empty. func Parse(path string) (parsed Parsed, err error) { parsed.Path = filepath.ToSlash(path) if path == "" { return parsed, errCantBeEmpty } // If path has no `:` in, it must be a local path if !strings.ContainsRune(path, ':') { return parsed, nil } // States for parser const ( stateConfigName = uint8(iota) stateParam stateValue stateQuotedValue stateAfterQuote stateDone ) var ( state = stateConfigName // current state of parser i int // position in path prev int // previous position in path c rune // current rune under consideration quote rune // kind of quote to end this quoted string param string // current parameter value doubled bool // set if had doubled quotes ) loop: for i, c = range path { // Example Parse // remote,param=value,param2="qvalue":/path/to/file switch state { // Parses "remote," case stateConfigName: if i == 0 && c == ':' { continue } else if c == '/' || c == '\\' { // `:` or `,` not before a path separator must be a local path, // except if the path started with `:` in which case it was intended // to be an on the fly remote so return an error. if path[0] == ':' { return parsed, errInvalidCharacters } return parsed, nil } else if c == ':' || c == ',' { parsed.Name = path[:i] err := checkRemoteName(parsed.Name + ":") if err != nil { return parsed, err } prev = i + 1 if c == ':' { // If we parsed a drive letter, must be a local path if driveletter.IsDriveLetter(parsed.Name) { parsed.Name = "" return parsed, nil } state = stateDone break loop } state = stateParam parsed.Config = make(configmap.Simple) } // Parses param= and param2= case stateParam: if c == ':' || c == ',' || c == '=' { param = path[prev:i] if len(param) == 0 { return parsed, errEmptyConfigParam } prev = i + 1 if c == '=' { state = stateValue break } parsed.Config[param] = "true" if c == ':' { state = stateDone break loop } state = stateParam } else if !isConfigParam(c) { return parsed, errBadConfigParam } // Parses value case stateValue: if c == '\'' || c == '"' { if i == prev { quote = c state = stateQuotedValue prev = i + 1 doubled = false break } } else if c == ':' || c == ',' { value := path[prev:i] prev = i + 1 parsed.Config[param] = value if c == ':' { state = stateDone break loop } state = stateParam } // Parses "qvalue" case stateQuotedValue: if c == quote { state = stateAfterQuote } // Parses : or , or quote after "qvalue" case stateAfterQuote: if c == ':' || c == ',' { value := path[prev : i-1] // replace any doubled quotes if there were any if doubled { value = strings.ReplaceAll(value, string(quote)+string(quote), string(quote)) } prev = i + 1 parsed.Config[param] = value if c == ':' { state = stateDone break loop } else { state = stateParam } } else if c == quote { // Here is a doubled quote to indicate a literal quote state = stateQuotedValue doubled = true } else { return parsed, errAfterQuote } } } // Depending on which state we were in when we fell off the // end of the state machine we can return a sensible error. switch state { default: return parsed, errSyntax case stateConfigName: return parsed, errConfigName case stateParam: return parsed, errParam case stateValue: return parsed, errValue case stateQuotedValue: return parsed, errQuotedValue case stateAfterQuote: return parsed, errAfterQuote case stateDone: break } parsed.ConfigString = path[:i] parsed.Path = path[i+1:] // change native directory separators to / if there are any parsed.Path = filepath.ToSlash(parsed.Path) return parsed, nil } // SplitFs splits a remote a remoteName and an remotePath. // // SplitFs("remote:path/to/file") -> ("remote:", "path/to/file") // SplitFs("/to/file") -> ("", "/to/file") // // If it returns remoteName as "" then remotePath is a local path // // The returned values have the property that remoteName + remotePath == // remote (except under Windows where \ will be translated into /) func SplitFs(remote string) (remoteName string, remotePath string, err error) { parsed, err := Parse(remote) if err != nil { return "", "", err } remoteName, remotePath = parsed.ConfigString, parsed.Path if remoteName != "" { remoteName += ":" } return remoteName, remotePath, nil } // Split splits a remote into a parent and a leaf // // if it returns leaf as an empty string then remote is a directory // // if it returns parent as an empty string then that means the current directory // // The returned values have the property that parent + leaf == remote // (except under Windows where \ will be translated into /) func Split(remote string) (parent string, leaf string, err error) { remoteName, remotePath, err := SplitFs(remote) if err != nil { return "", "", err } // Construct new remote name without last segment parent, leaf = path.Split(remotePath) return remoteName + parent, leaf, nil } // Make filePath absolute so it can't read above the root func makeAbsolute(filePath string) string { leadingSlash := strings.HasPrefix(filePath, "/") filePath = path.Join("/", filePath) if !leadingSlash && strings.HasPrefix(filePath, "/") { filePath = filePath[1:] } return filePath } // JoinRootPath joins filePath onto remote // // If the remote has a leading "//" this is preserved to allow Windows // network paths to be used as remotes. // // If filePath is empty then remote will be returned. // // If the path contains \ these will be converted to / on Windows. func JoinRootPath(remote, filePath string) string { remote = filepath.ToSlash(remote) if filePath == "" { return remote } filePath = filepath.ToSlash(filePath) filePath = makeAbsolute(filePath) if strings.HasPrefix(remote, "//") { return "/" + path.Join(remote, filePath) } parsed, err := Parse(remote) remoteName, remotePath := parsed.ConfigString, parsed.Path if err != nil { // Couldn't parse so assume it is a path remoteName = "" remotePath = remote } remotePath = path.Join(remotePath, filePath) if remoteName != "" { remoteName += ":" // if have remote: then normalise the remotePath if remotePath == "." { remotePath = "" } } return remoteName + remotePath } rclone-v1.71.0/fs/fspath/path_test.go000066400000000000000000000403121505210326400174650ustar00rootroot00000000000000package fspath import ( "flag" "fmt" "os" "path/filepath" "runtime" "testing" "github.com/rclone/rclone/fs/config/configmap" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var ( makeCorpus = flag.Bool("make-corpus", false, "Set to make the fuzzing corpus") ) func TestCheckConfigName(t *testing.T) { for _, test := range []struct { in string problem error fixed string }{ {"remote", nil, "remote"}, {"REMOTE", nil, "REMOTE"}, {"", errInvalidCharacters, "_"}, {":remote:", errInvalidCharacters, "_remote_"}, {"remote:", errInvalidCharacters, "remote_"}, {"rem:ote", errInvalidCharacters, "rem_ote"}, {"rem/ote", errInvalidCharacters, "rem_ote"}, {"rem\\ote", errInvalidCharacters, "rem_ote"}, {"[remote", errInvalidCharacters, "_remote"}, {"*", errInvalidCharacters, "_"}, {"-remote", errInvalidCharacters, "_remote"}, {"r-emote-", nil, "r-emote-"}, {"---rem:::ote???", errInvalidCharacters, "_rem_ote_"}, {"_rem_ote_", nil, "_rem_ote_"}, {".", nil, "."}, {"..", nil, ".."}, {".r.e.m.o.t.e.", nil, ".r.e.m.o.t.e."}, {"rem ote", nil, "rem ote"}, {"user@example.com", nil, "user@example.com"}, {"user+junkmail@example.com", nil, "user+junkmail@example.com"}, {"blåbær", nil, "blåbær"}, {"chữ Quốc ngữ", nil, "chữ Quốc ngữ"}, {"remote ", errInvalidCharacters, "remote_"}, {" remote", errInvalidCharacters, "_remote"}, {" remote ", errInvalidCharacters, "_remote_"}, } { problem := CheckConfigName(test.in) assert.Equal(t, test.problem, problem, test.in) fixed := MakeConfigName(test.in) assert.Equal(t, test.fixed, fixed, test.in) } } func TestCheckRemoteName(t *testing.T) { for _, test := range []struct { in string want error }{ {":remote:", nil}, {":REMOTE:", nil}, {":s3:", nil}, {"remote:", nil}, {".:", nil}, {"..:", nil}, {".r.e.m.o.t.e.:", nil}, {"-r-emote-:", errInvalidCharacters}, {"rem ote:", nil}, {"user@example.com:", nil}, {"user+junkmail@example.com:", nil}, {"blåbær:", nil}, {"chữ Quốc ngữ:", nil}, {"remote :", errInvalidCharacters}, {" remote:", errInvalidCharacters}, {" remote :", errInvalidCharacters}, {"", errInvalidCharacters}, {"rem:ote", errInvalidCharacters}, {"rem:ote:", errInvalidCharacters}, {"remote", errInvalidCharacters}, {"rem/ote:", errInvalidCharacters}, {"rem\\ote:", errInvalidCharacters}, {"[remote:", errInvalidCharacters}, {"*:", errInvalidCharacters}, } { got := checkRemoteName(test.in) assert.Equal(t, test.want, got, test.in) } } func TestParse(t *testing.T) { for testNumber, test := range []struct { in string wantParsed Parsed wantErr error win bool // only run these tests on Windows noWin bool // only run these tests on !Windows }{ { in: "", wantErr: errCantBeEmpty, }, { in: ":", wantErr: errConfigName, }, { in: "::", wantErr: errConfigNameEmpty, }, { in: ":/:", wantErr: errInvalidCharacters, }, { in: "/:", wantParsed: Parsed{ ConfigString: "", Path: "/:", }, }, { in: "\\backslash:", wantParsed: Parsed{ ConfigString: "", Path: "/backslash:", }, win: true, }, { in: "\\backslash:", wantParsed: Parsed{ ConfigString: "", Path: "\\backslash:", }, noWin: true, }, { in: "/slash:", wantParsed: Parsed{ ConfigString: "", Path: "/slash:", }, }, { in: "with\\backslash:", wantParsed: Parsed{ ConfigString: "", Path: "with/backslash:", }, win: true, }, { in: "with\\backslash:", wantParsed: Parsed{ ConfigString: "", Path: "with\\backslash:", }, noWin: true, }, { in: "with/slash:", wantParsed: Parsed{ ConfigString: "", Path: "with/slash:", }, }, { in: "/path/to/file", wantParsed: Parsed{ ConfigString: "", Path: "/path/to/file", }, }, { in: "/path:/to/file", wantParsed: Parsed{ ConfigString: "", Path: "/path:/to/file", }, }, { in: "./path:/to/file", wantParsed: Parsed{ ConfigString: "", Path: "./path:/to/file", }, }, { in: "./:colon.txt", wantParsed: Parsed{ ConfigString: "", Path: "./:colon.txt", }, }, { in: "path/to/file", wantParsed: Parsed{ ConfigString: "", Path: "path/to/file", }, }, { in: ".:", wantParsed: Parsed{ ConfigString: ".", Name: ".", Path: "", }, }, { in: "..:", wantParsed: Parsed{ ConfigString: "..", Name: "..", Path: "", }, }, { in: ".:colon.txt", wantParsed: Parsed{ ConfigString: ".", Name: ".", Path: "colon.txt", }, }, { in: "remote:path/to/file", wantParsed: Parsed{ ConfigString: "remote", Name: "remote", Path: "path/to/file", }, }, { in: "rem*ote:path/to/file", wantErr: errInvalidCharacters, }, { in: "remote:/path/to/file", wantParsed: Parsed{ ConfigString: "remote", Name: "remote", Path: "/path/to/file", }, }, { in: "rem.ote:/path/to/file", wantParsed: Parsed{ ConfigString: "rem.ote", Name: "rem.ote", Path: "/path/to/file", }, }, { in: "rem ote:/path/to/file", wantParsed: Parsed{ ConfigString: "rem ote", Name: "rem ote", Path: "/path/to/file", }, }, { in: "remote :/path/to/file", wantErr: errInvalidCharacters, }, { in: " remote:/path/to/file", wantErr: errInvalidCharacters, }, { in: " remote :/path/to/file", wantErr: errInvalidCharacters, }, { in: "rem#ote:/path/to/file", wantErr: errInvalidCharacters, }, { in: ":backend:/path/to/file", wantParsed: Parsed{ ConfigString: ":backend", Name: ":backend", Path: "/path/to/file", }, }, { in: ":back.end:/path/to/file", wantParsed: Parsed{ ConfigString: ":back.end", Name: ":back.end", Path: "/path/to/file", }, }, { in: ":bac*kend:/path/to/file", wantErr: errInvalidCharacters, }, { in: `C:\path\to\file`, wantParsed: Parsed{ Name: "", Path: `C:/path/to/file`, }, win: true, }, { in: `C:\path\to\file`, wantParsed: Parsed{ Name: "C", ConfigString: "C", Path: `\path\to\file`, }, noWin: true, }, { in: `\path\to\file`, wantParsed: Parsed{ Name: "", Path: `/path/to/file`, }, win: true, }, { in: `\path\to\file`, wantParsed: Parsed{ Name: "", Path: `\path\to\file`, }, noWin: true, }, { in: `.`, wantParsed: Parsed{ Name: "", Path: `.`, }, noWin: true, }, { in: `..`, wantParsed: Parsed{ Name: "", Path: `..`, }, noWin: true, }, { in: `remote:\path\to\file`, wantParsed: Parsed{ Name: "remote", ConfigString: "remote", Path: `/path/to/file`, }, win: true, }, { in: `remote:\path\to\file`, wantParsed: Parsed{ Name: "remote", ConfigString: "remote", Path: `\path\to\file`, }, noWin: true, }, { in: `D:/path/to/file`, wantParsed: Parsed{ Name: "", Path: `D:/path/to/file`, }, win: true, }, { in: `D:/path/to/file`, wantParsed: Parsed{ Name: "D", ConfigString: "D", Path: `/path/to/file`, }, noWin: true, }, { in: `:backend,param1:/path/to/file`, wantParsed: Parsed{ ConfigString: `:backend,param1`, Name: ":backend", Path: "/path/to/file", Config: configmap.Simple{ "param1": "true", }, }, }, { in: `:backend,param1=value:/path/to/file`, wantParsed: Parsed{ ConfigString: `:backend,param1=value`, Name: ":backend", Path: "/path/to/file", Config: configmap.Simple{ "param1": "value", }, }, }, { in: `:backend,param1=value1,param2,param3=value3:/path/to/file`, wantParsed: Parsed{ ConfigString: `:backend,param1=value1,param2,param3=value3`, Name: ":backend", Path: "/path/to/file", Config: configmap.Simple{ "param1": "value1", "param2": "true", "param3": "value3", }, }, }, { in: `:backend,param1=value1,param2="value2",param3='value3':/path/to/file`, wantParsed: Parsed{ ConfigString: `:backend,param1=value1,param2="value2",param3='value3'`, Name: ":backend", Path: "/path/to/file", Config: configmap.Simple{ "param1": "value1", "param2": "value2", "param3": "value3", }, }, }, { in: `:backend,param-1=value:/path/to/file`, wantErr: errBadConfigParam, }, { in: `:backend,param1="value"x:/path/to/file`, wantErr: errAfterQuote, }, { in: `:backend,`, wantErr: errParam, }, { in: `:backend,param=value`, wantErr: errValue, }, { in: `:backend,param="value'`, wantErr: errQuotedValue, }, { in: `:backend,param1="value"`, wantErr: errAfterQuote, }, { in: `:backend,=value:`, wantErr: errEmptyConfigParam, }, { in: `:backend,:`, wantErr: errEmptyConfigParam, }, { in: `:backend,,:`, wantErr: errEmptyConfigParam, }, { in: `:backend,param=:path`, wantParsed: Parsed{ ConfigString: `:backend,param=`, Name: ":backend", Path: "path", Config: configmap.Simple{ "param": "", }, }, }, { in: `:backend,param="with""quote":path`, wantParsed: Parsed{ ConfigString: `:backend,param="with""quote"`, Name: ":backend", Path: "path", Config: configmap.Simple{ "param": `with"quote`, }, }, }, { in: `:backend,param='''''':`, wantParsed: Parsed{ ConfigString: `:backend,param=''''''`, Name: ":backend", Path: "", Config: configmap.Simple{ "param": `''`, }, }, }, { in: `:backend,param=''bad'':`, wantErr: errAfterQuote, }, } { gotParsed, gotErr := Parse(test.in) if runtime.GOOS == "windows" && test.noWin { continue } if runtime.GOOS != "windows" && test.win { continue } assert.Equal(t, test.wantErr, gotErr, test.in) if test.wantErr == nil { assert.Equal(t, test.wantParsed, gotParsed, test.in) } if *makeCorpus { // write the test corpus for fuzzing require.NoError(t, os.MkdirAll("corpus", 0777)) require.NoError(t, os.WriteFile(fmt.Sprintf("corpus/%02d", testNumber), []byte(test.in), 0666)) } } } func TestSplitFs(t *testing.T) { for _, test := range []struct { remote, wantRemoteName, wantRemotePath string wantErr error }{ {"", "", "", errCantBeEmpty}, {"remote:", "remote:", "", nil}, {"remote:potato", "remote:", "potato", nil}, {"remote:/", "remote:", "/", nil}, {"remote:/potato", "remote:", "/potato", nil}, {"remote:/potato/potato", "remote:", "/potato/potato", nil}, {"remote:potato/sausage", "remote:", "potato/sausage", nil}, {"rem.ote:potato/sausage", "rem.ote:", "potato/sausage", nil}, {"rem ote:", "rem ote:", "", nil}, {"remote :", "", "", errInvalidCharacters}, {" remote:", "", "", errInvalidCharacters}, {" remote :", "", "", errInvalidCharacters}, {".:", ".:", "", nil}, {"..:", "..:", "", nil}, {".:potato/sausage", ".:", "potato/sausage", nil}, {"..:potato/sausage", "..:", "potato/sausage", nil}, {":remote:", ":remote:", "", nil}, {":remote:potato", ":remote:", "potato", nil}, {":remote:/", ":remote:", "/", nil}, {":remote:/potato", ":remote:", "/potato", nil}, {":remote:/potato/potato", ":remote:", "/potato/potato", nil}, {":remote:potato/sausage", ":remote:", "potato/sausage", nil}, {":rem.ote:potato/sausage", ":rem.ote:", "potato/sausage", nil}, {":rem[ote:potato/sausage", "", "", errInvalidCharacters}, {":.:", ":.:", "", nil}, {":..:", ":..:", "", nil}, {":.:potato/sausage", ":.:", "potato/sausage", nil}, {":..:potato/sausage", ":..:", "potato/sausage", nil}, {"/", "", "/", nil}, {"/root", "", "/root", nil}, {"/a/b", "", "/a/b", nil}, {"root", "", "root", nil}, {"a/b", "", "a/b", nil}, {"root/", "", "root/", nil}, {"a/b/", "", "a/b/", nil}, } { gotRemoteName, gotRemotePath, gotErr := SplitFs(test.remote) assert.Equal(t, test.wantErr, gotErr) assert.Equal(t, test.wantRemoteName, gotRemoteName, test.remote) assert.Equal(t, test.wantRemotePath, gotRemotePath, test.remote) if gotErr == nil { assert.Equal(t, test.remote, gotRemoteName+gotRemotePath, fmt.Sprintf("%s: %q + %q != %q", test.remote, gotRemoteName, gotRemotePath, test.remote)) } } } func TestSplit(t *testing.T) { for _, test := range []struct { remote, wantParent, wantLeaf string wantErr error }{ {"", "", "", errCantBeEmpty}, {"remote:", "remote:", "", nil}, {"remote:potato", "remote:", "potato", nil}, {"remote:/", "remote:/", "", nil}, {"remote:/potato", "remote:/", "potato", nil}, {"remote:/potato/potato", "remote:/potato/", "potato", nil}, {"remote:potato/sausage", "remote:potato/", "sausage", nil}, {"rem.ote:potato/sausage", "rem.ote:potato/", "sausage", nil}, {"rem ote:", "rem ote:", "", nil}, {"remote :", "", "", errInvalidCharacters}, {" remote:", "", "", errInvalidCharacters}, {" remote :", "", "", errInvalidCharacters}, {".:", ".:", "", nil}, {"..:", "..:", "", nil}, {".:potato/sausage", ".:potato/", "sausage", nil}, {"..:potato/sausage", "..:potato/", "sausage", nil}, {":remote:", ":remote:", "", nil}, {":remote:potato", ":remote:", "potato", nil}, {":remote:/", ":remote:/", "", nil}, {":remote:/potato", ":remote:/", "potato", nil}, {":remote:/potato/potato", ":remote:/potato/", "potato", nil}, {":remote:potato/sausage", ":remote:potato/", "sausage", nil}, {":rem.ote:potato/sausage", ":rem.ote:potato/", "sausage", nil}, {":rem[ote:potato/sausage", "", "", errInvalidCharacters}, {":.:", ":.:", "", nil}, {":..:", ":..:", "", nil}, {":.:potato/sausage", ":.:potato/", "sausage", nil}, {":..:potato/sausage", ":..:potato/", "sausage", nil}, {"/", "/", "", nil}, {"/root", "/", "root", nil}, {"/a/b", "/a/", "b", nil}, {"root", "", "root", nil}, {"a/b", "a/", "b", nil}, {"root/", "root/", "", nil}, {"a/b/", "a/b/", "", nil}, } { gotParent, gotLeaf, gotErr := Split(test.remote) assert.Equal(t, test.wantErr, gotErr) assert.Equal(t, test.wantParent, gotParent, test.remote) assert.Equal(t, test.wantLeaf, gotLeaf, test.remote) if gotErr == nil { assert.Equal(t, test.remote, gotParent+gotLeaf, fmt.Sprintf("%s: %q + %q != %q", test.remote, gotParent, gotLeaf, test.remote)) } } } func TestMakeAbsolute(t *testing.T) { for _, test := range []struct { in string want string }{ {"", ""}, {".", ""}, {"/.", "/"}, {"../potato", "potato"}, {"/../potato", "/potato"}, {"./../potato", "potato"}, {"//../potato", "/potato"}, {"././../potato", "potato"}, {"././potato/../../onion", "onion"}, } { got := makeAbsolute(test.in) assert.Equal(t, test.want, got, test) } } func TestJoinRootPath(t *testing.T) { for _, test := range []struct { remote string filePath string want string }{ {"", "", ""}, {"", "/", "/"}, {"/", "", "/"}, {"/", "/", "/"}, {"/", "//", "/"}, {"/root", "", "/root"}, {"/root", "/", "/root"}, {"/root", "//", "/root"}, {"/a/b", "", "/a/b"}, {"//", "/", "//"}, {"//server", "path", "//server/path"}, {"//server/sub", "path", "//server/sub/path"}, {"//server", "//path", "//server/path"}, {"//server/sub", "//path", "//server/sub/path"}, {"//", "/", "//"}, {"//server", "path", "//server/path"}, {"//server/sub", "path", "//server/sub/path"}, {"//server", "//path", "//server/path"}, {"//server/sub", "//path", "//server/sub/path"}, {filepath.FromSlash("//server/sub"), filepath.FromSlash("//path"), "//server/sub/path"}, {"s3:", "", "s3:"}, {"s3:", ".", "s3:"}, {"s3:.", ".", "s3:"}, {"s3:", "..", "s3:"}, {"s3:dir", "sub", "s3:dir/sub"}, {"s3:dir", "/sub", "s3:dir/sub"}, {"s3:dir", "./sub", "s3:dir/sub"}, {"s3:/dir", "/sub/", "s3:/dir/sub"}, {"s3:dir", "..", "s3:dir"}, {"s3:dir", "/..", "s3:dir"}, {"s3:dir", "/../", "s3:dir"}, } { got := JoinRootPath(test.remote, test.filePath) assert.Equal(t, test.want, got, test) } } rclone-v1.71.0/fs/hash/000077500000000000000000000000001505210326400146015ustar00rootroot00000000000000rclone-v1.71.0/fs/hash/hash.go000066400000000000000000000231271505210326400160600ustar00rootroot00000000000000// Package hash provides hash utilities for Fs. package hash import ( "crypto/md5" "crypto/sha1" "crypto/sha256" "crypto/sha512" "encoding/base64" "encoding/hex" "errors" "fmt" "hash" "hash/crc32" "io" "strings" "github.com/jzelinskie/whirlpool" "github.com/zeebo/blake3" "github.com/zeebo/xxh3" ) // Type indicates a standard hashing algorithm type Type int type hashDefinition struct { width int name string alias string newFunc func() hash.Hash hashType Type } var ( type2hash = map[Type]*hashDefinition{} name2hash = map[string]*hashDefinition{} alias2hash = map[string]*hashDefinition{} supported = []Type{} ) // RegisterHash adds a new Hash to the list and returns it Type func RegisterHash(name, alias string, width int, newFunc func() hash.Hash) Type { hashType := Type(1 << len(supported)) supported = append(supported, hashType) definition := &hashDefinition{ name: name, alias: alias, width: width, newFunc: newFunc, hashType: hashType, } type2hash[hashType] = definition name2hash[name] = definition alias2hash[alias] = definition return hashType } // SupportOnly makes the hash package only support the types passed // in. Used for testing. // // It returns the previously supported types. func SupportOnly(new []Type) (old []Type) { old = supported supported = new return old } // ErrUnsupported should be returned by filesystem, // if it is requested to deliver an unsupported hash type. var ErrUnsupported = errors.New("hash type not supported") var ( // None indicates no hashes are supported None Type // MD5 indicates MD5 support MD5 Type // SHA1 indicates SHA-1 support SHA1 Type // Whirlpool indicates Whirlpool support Whirlpool Type // CRC32 indicates CRC-32 support CRC32 Type // SHA256 indicates SHA-256 support SHA256 Type // SHA512 indicates SHA-512 support SHA512 Type // BLAKE3 indicates BLAKE3 support BLAKE3 Type // XXH3 indicates XXH3 support, also known as XXH3-64, a variant of xxHash XXH3 Type // XXH128 indicates XXH128 support, also known as XXH3-128, a variant of xxHash XXH128 Type ) type xxh128Hasher struct { xxh3.Hasher } // Sum overrides xxh3.Sum to return value based on Sum128 instead of the default Sum64. func (h *xxh128Hasher) Sum(b []byte) []byte { buf := h.Sum128().Bytes() return buf[:] } func init() { MD5 = RegisterHash("md5", "MD5", 32, md5.New) SHA1 = RegisterHash("sha1", "SHA-1", 40, sha1.New) Whirlpool = RegisterHash("whirlpool", "Whirlpool", 128, whirlpool.New) CRC32 = RegisterHash("crc32", "CRC-32", 8, func() hash.Hash { return crc32.NewIEEE() }) SHA256 = RegisterHash("sha256", "SHA-256", 64, sha256.New) SHA512 = RegisterHash("sha512", "SHA-512", 128, sha512.New) BLAKE3 = RegisterHash("blake3", "BLAKE3", 64, func() hash.Hash { return blake3.New() }) XXH3 = RegisterHash("xxh3", "XXH3", 16, func() hash.Hash { return xxh3.New() }) XXH128 = RegisterHash("xxh128", "XXH128", 32, func() hash.Hash { return &xxh128Hasher{} }) } // Supported returns a set of all the supported hashes by // HashStream and MultiHasher. func Supported() Set { return NewHashSet(supported...) } // Width returns the width in characters for any HashType func Width(hashType Type, base64Encoded bool) int { if hash := type2hash[hashType]; hash != nil { if base64Encoded { return base64.URLEncoding.EncodedLen(hash.width / 2) } return hash.width } return 0 } // Stream will calculate hashes of all supported hash types. func Stream(r io.Reader) (map[Type]string, error) { return StreamTypes(r, Supported()) } // StreamTypes will calculate hashes of the requested hash types. func StreamTypes(r io.Reader, set Set) (map[Type]string, error) { hashers, err := fromTypes(set) if err != nil { return nil, err } _, err = io.Copy(toMultiWriter(hashers), r) if err != nil { return nil, err } var ret = make(map[Type]string) for k, v := range hashers { ret[k] = hex.EncodeToString(v.Sum(nil)) } return ret, nil } // String returns a string representation of the hash type. // The function will panic if the hash type is unknown. func (h Type) String() string { if h == None { return "none" } if hash := type2hash[h]; hash != nil { return hash.name } panic(fmt.Sprintf("internal error: unknown hash type: 0x%x", int(h))) } // Set a Type from a flag. // Both name and alias are accepted. func (h *Type) Set(s string) error { if s == "none" || s == "None" { *h = None return nil } if hash := name2hash[strings.ToLower(s)]; hash != nil { *h = hash.hashType return nil } if hash := alias2hash[s]; hash != nil { *h = hash.hashType return nil } return fmt.Errorf("unknown hash type %q", s) } // Type of the value func (h Type) Type() string { return "string" } // fromTypes will return hashers for all the requested types. // The types must be a subset of SupportedHashes, // and this function must support all types. func fromTypes(set Set) (map[Type]hash.Hash, error) { if !set.SubsetOf(Supported()) { return nil, fmt.Errorf("requested set %08x contains unknown hash types", int(set)) } hashers := map[Type]hash.Hash{} for _, t := range set.Array() { hash := type2hash[t] if hash == nil { panic(fmt.Sprintf("internal error: Unsupported hash type %v", t)) } hashers[t] = hash.newFunc() } return hashers, nil } // toMultiWriter will return a set of hashers into a // single multiwriter, where one write will update all // the hashers. func toMultiWriter(h map[Type]hash.Hash) io.Writer { // Convert to to slice var w = make([]io.Writer, 0, len(h)) for _, v := range h { w = append(w, v) } return io.MultiWriter(w...) } // A MultiHasher will construct various hashes on // all incoming writes. type MultiHasher struct { w io.Writer size int64 h map[Type]hash.Hash // Hashes } // NewMultiHasher will return a hash writer that will write all // supported hash types. func NewMultiHasher() *MultiHasher { h, err := NewMultiHasherTypes(Supported()) if err != nil { panic("internal error: could not create multihasher") } return h } // NewMultiHasherTypes will return a hash writer that will write // the requested hash types. func NewMultiHasherTypes(set Set) (*MultiHasher, error) { hashers, err := fromTypes(set) if err != nil { return nil, err } m := MultiHasher{h: hashers, w: toMultiWriter(hashers)} return &m, nil } func (m *MultiHasher) Write(p []byte) (n int, err error) { n, err = m.w.Write(p) m.size += int64(n) return n, err } // Sums returns the sums of all accumulated hashes as hex encoded // strings. func (m *MultiHasher) Sums() map[Type]string { dst := make(map[Type]string) for k, v := range m.h { dst[k] = hex.EncodeToString(v.Sum(nil)) } return dst } // Sum returns the specified hash from the multihasher func (m *MultiHasher) Sum(hashType Type) ([]byte, error) { h, ok := m.h[hashType] if !ok { return nil, ErrUnsupported } return h.Sum(nil), nil } // SumString returns the specified hash from the multihasher as a hex or base64 encoded string func (m *MultiHasher) SumString(hashType Type, base64Encoded bool) (string, error) { sum, err := m.Sum(hashType) if err != nil { return "", err } if base64Encoded { return base64.URLEncoding.EncodeToString(sum), nil } return hex.EncodeToString(sum), nil } // Size returns the number of bytes written func (m *MultiHasher) Size() int64 { return m.size } // A Set Indicates one or more hash types. type Set int // NewHashSet will create a new hash set with the hash types supplied func NewHashSet(t ...Type) Set { h := Set(None) return h.Add(t...) } // Add one or more hash types to the set. // Returns the modified hash set. func (h *Set) Add(t ...Type) Set { for _, v := range t { *h |= Set(v) } return *h } // Contains returns true if the func (h Set) Contains(t Type) bool { return int(h)&int(t) != 0 } // Overlap returns the overlapping hash types func (h Set) Overlap(t Set) Set { return Set(int(h) & int(t)) } // SubsetOf will return true if all types of h // is present in the set c func (h Set) SubsetOf(c Set) bool { return int(h)|int(c) == int(c) } // GetOne will return a hash type. // Currently the first is returned, but it could be // improved to return the strongest. func (h Set) GetOne() Type { v := int(h) i := uint(0) for v != 0 { if v&1 != 0 { return Type(1 << i) } i++ v >>= 1 } return None } // Array returns an array of all hash types in the set func (h Set) Array() (ht []Type) { v := int(h) i := uint(0) for v != 0 { if v&1 != 0 { ht = append(ht, Type(1<>= 1 } return ht } // Count returns the number of hash types in the set func (h Set) Count() int { if int(h) == 0 { return 0 } // credit: https://code.google.com/u/arnehormann/ x := uint64(h) x -= (x >> 1) & 0x5555555555555555 x = (x>>2)&0x3333333333333333 + x&0x3333333333333333 x += x >> 4 x &= 0x0f0f0f0f0f0f0f0f x *= 0x0101010101010101 return int(x >> 56) } // String returns a string representation of the hash set. // The function will panic if it contains an unknown type. func (h Set) String() string { a := h.Array() var r []string for _, v := range a { r = append(r, v.String()) } return "[" + strings.Join(r, ", ") + "]" } // Equals checks to see if src == dst, but ignores empty strings // and returns true if either is empty. func Equals(src, dst string) bool { if src == "" || dst == "" { return true } return src == dst } // HelpString returns help message with supported hashes func HelpString(indent int) string { padding := strings.Repeat(" ", indent) var help strings.Builder help.WriteString(padding) help.WriteString("Supported hashes are:\n") for _, h := range supported { fmt.Fprintf(&help, "%s * %v\n", padding, h.String()) } return help.String() } rclone-v1.71.0/fs/hash/hash_test.go000066400000000000000000000144551505210326400171230ustar00rootroot00000000000000package hash_test import ( "bytes" "fmt" "io" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/spf13/pflag" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Check it satisfies the interface var _ pflag.Value = (*hash.Type)(nil) func TestHashSet(t *testing.T) { var h hash.Set assert.Equal(t, 0, h.Count()) a := h.Array() assert.Len(t, a, 0) h = h.Add(hash.MD5) fs.Log(nil, fmt.Sprint(h)) assert.Equal(t, 1, h.Count()) assert.Equal(t, hash.MD5, h.GetOne()) a = h.Array() assert.Len(t, a, 1) assert.Equal(t, a[0], hash.MD5) // Test overlap, with all hashes h = h.Overlap(hash.Supported()) assert.Equal(t, 1, h.Count()) assert.Equal(t, hash.MD5, h.GetOne()) assert.True(t, h.SubsetOf(hash.Supported())) assert.True(t, h.SubsetOf(hash.NewHashSet(hash.MD5))) h = h.Add(hash.SHA1) assert.Equal(t, 2, h.Count()) one := h.GetOne() if !(one == hash.MD5 || one == hash.SHA1) { t.Fatalf("expected to be either MD5 or SHA1, got %v", one) } assert.True(t, h.SubsetOf(hash.Supported())) assert.False(t, h.SubsetOf(hash.NewHashSet(hash.MD5))) assert.False(t, h.SubsetOf(hash.NewHashSet(hash.SHA1))) assert.True(t, h.SubsetOf(hash.NewHashSet(hash.MD5, hash.SHA1))) a = h.Array() assert.Len(t, a, 2) ol := h.Overlap(hash.NewHashSet(hash.MD5)) assert.Equal(t, 1, ol.Count()) assert.True(t, ol.Contains(hash.MD5)) assert.False(t, ol.Contains(hash.SHA1)) ol = h.Overlap(hash.NewHashSet(hash.MD5, hash.SHA1)) assert.Equal(t, 2, ol.Count()) assert.True(t, ol.Contains(hash.MD5)) assert.True(t, ol.Contains(hash.SHA1)) } type hashTest struct { input []byte output map[hash.Type]string } var hashTestSet = []hashTest{ { input: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, output: map[hash.Type]string{ hash.MD5: "bf13fc19e5151ac57d4252e0e0f87abe", hash.SHA1: "3ab6543c08a75f292a5ecedac87ec41642d12166", hash.Whirlpool: "eddf52133d4566d763f716e853d6e4efbabd29e2c2e63f56747b1596172851d34c2df9944beb6640dbdbe3d9b4eb61180720a79e3d15baff31c91e43d63869a4", hash.CRC32: "a6041d7e", hash.SHA256: "c839e57675862af5c21bd0a15413c3ec579e0d5522dab600bc6c3489b05b8f54", hash.SHA512: "008e7e9b5d94d37bf5e07c955890f730f137a41b8b0db16cb535a9b4cb5632c2bccff31685ec470130fe10e2258a0ab50ab587472258f3132ccf7d7d59fb91db", hash.BLAKE3: "0a7276a407a3be1b4d31488318ee05a335aad5a3b82c4420e592a8178c9e86bb", hash.XXH3: "4b83b0c51c543525", hash.XXH128: "438de241a57d684214f67657f7aad93b", }, }, // Empty data set { input: []byte{}, output: map[hash.Type]string{ hash.MD5: "d41d8cd98f00b204e9800998ecf8427e", hash.SHA1: "da39a3ee5e6b4b0d3255bfef95601890afd80709", hash.Whirlpool: "19fa61d75522a4669b44e39c1d2e1726c530232130d407f89afee0964997f7a73e83be698b288febcf88e3e03c4f0757ea8964e59b63d93708b138cc42a66eb3", hash.CRC32: "00000000", hash.SHA256: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", hash.SHA512: "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e", hash.BLAKE3: "af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262", hash.XXH3: "2d06800538d394c2", hash.XXH128: "99aa06d3014798d86001c324468d497f", }, }, } func TestMultiHasher(t *testing.T) { for _, test := range hashTestSet { mh := hash.NewMultiHasher() n, err := io.Copy(mh, bytes.NewBuffer(test.input)) require.NoError(t, err) assert.Len(t, test.input, int(n)) sums := mh.Sums() for k, v := range sums { expect, ok := test.output[k] require.True(t, ok, "test output for hash not found") assert.Equal(t, expect, v) } // Test that all are present for k, v := range test.output { expect, ok := sums[k] require.True(t, ok, "test output for hash not found") assert.Equal(t, expect, v) } } } func TestMultiHasherTypes(t *testing.T) { h := hash.SHA1 for _, test := range hashTestSet { mh, err := hash.NewMultiHasherTypes(hash.NewHashSet(h)) if err != nil { t.Fatal(err) } n, err := io.Copy(mh, bytes.NewBuffer(test.input)) require.NoError(t, err) assert.Len(t, test.input, int(n)) sums := mh.Sums() assert.Len(t, sums, 1) assert.Equal(t, sums[h], test.output[h]) } } func TestHashStream(t *testing.T) { for _, test := range hashTestSet { sums, err := hash.Stream(bytes.NewBuffer(test.input)) require.NoError(t, err) for k, v := range sums { expect, ok := test.output[k] require.True(t, ok) assert.Equal(t, v, expect) } // Test that all are present for k, v := range test.output { expect, ok := sums[k] require.True(t, ok) assert.Equal(t, v, expect) } } } func TestHashStreamTypes(t *testing.T) { h := hash.SHA1 for _, test := range hashTestSet { sums, err := hash.StreamTypes(bytes.NewBuffer(test.input), hash.NewHashSet(h)) require.NoError(t, err) assert.Len(t, sums, 1) assert.Equal(t, sums[h], test.output[h]) } } func TestHashSetStringer(t *testing.T) { h := hash.NewHashSet(hash.SHA1, hash.MD5) assert.Equal(t, "[md5, sha1]", h.String()) h = hash.NewHashSet(hash.SHA1) assert.Equal(t, "[sha1]", h.String()) h = hash.NewHashSet() assert.Equal(t, "[]", h.String()) } func TestHashStringer(t *testing.T) { h := hash.MD5 assert.Equal(t, "md5", h.String()) h = hash.SHA1 assert.Equal(t, "sha1", h.String()) h = hash.None assert.Equal(t, "none", h.String()) } func TestHashSetter(t *testing.T) { var ht hash.Type assert.NoError(t, ht.Set("none")) assert.Equal(t, hash.None, ht) assert.NoError(t, ht.Set("None")) assert.Equal(t, hash.None, ht) assert.NoError(t, ht.Set("md5")) assert.Equal(t, hash.MD5, ht) assert.NoError(t, ht.Set("MD5")) assert.Equal(t, hash.MD5, ht) assert.NoError(t, ht.Set("sha1")) assert.Equal(t, hash.SHA1, ht) assert.NoError(t, ht.Set("SHA-1")) assert.Equal(t, hash.SHA1, ht) assert.NoError(t, ht.Set("SHA1")) assert.Equal(t, hash.SHA1, ht) assert.NoError(t, ht.Set("Sha1")) assert.Equal(t, hash.SHA1, ht) assert.Error(t, ht.Set("Sha-1")) } func TestHashTypeStability(t *testing.T) { assert.Equal(t, hash.Type(0), hash.None) assert.Equal(t, hash.Type(1), hash.MD5) assert.Equal(t, hash.Type(2), hash.SHA1) assert.True(t, hash.Supported().Contains(hash.MD5)) assert.True(t, hash.Supported().Contains(hash.SHA1)) assert.False(t, hash.Supported().Contains(hash.None)) } rclone-v1.71.0/fs/list/000077500000000000000000000000001505210326400146315ustar00rootroot00000000000000rclone-v1.71.0/fs/list/helpers.go000066400000000000000000000027371505210326400166330ustar00rootroot00000000000000package list import ( "context" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" ) // Listing helpers used by backends // Helper is used in the implementation of ListR to accumulate DirEntries type Helper struct { callback fs.ListRCallback entries fs.DirEntries } // NewHelper should be called from ListR with the callback passed in func NewHelper(callback fs.ListRCallback) *Helper { return &Helper{ callback: callback, } } // send sends the stored entries to the callback if there are >= max // entries. func (lh *Helper) send(max int) (err error) { if len(lh.entries) >= max { err = lh.callback(lh.entries) lh.entries = lh.entries[:0] } return err } // Add an entry to the stored entries and send them if there are more // than a certain amount func (lh *Helper) Add(entry fs.DirEntry) error { if entry == nil { return nil } lh.entries = append(lh.entries, entry) return lh.send(100) } // Flush the stored entries (if any) sending them to the callback func (lh *Helper) Flush() error { return lh.send(1) } // WithListP implements the List interface with ListP // // It should be used in backends which support ListP to implement // List. func WithListP(ctx context.Context, dir string, list fs.ListPer) (entries fs.DirEntries, err error) { err = list.ListP(ctx, dir, func(newEntries fs.DirEntries) error { accounting.Stats(ctx).Listed(int64(len(newEntries))) entries = append(entries, newEntries...) return nil }) return entries, err } rclone-v1.71.0/fs/list/helpers_test.go000066400000000000000000000071071505210326400176660ustar00rootroot00000000000000package list import ( "context" "errors" "fmt" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest/mockobject" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Mock callback to collect the entries func mockCallback(entries fs.DirEntries) error { // Do nothing or log for testing purposes return nil } func TestNewListRHelper(t *testing.T) { callback := mockCallback helper := NewHelper(callback) assert.NotNil(t, helper) assert.Equal(t, fmt.Sprintf("%p", callback), fmt.Sprintf("%p", helper.callback)) assert.Empty(t, helper.entries) } func TestListRHelperAdd(t *testing.T) { callbackInvoked := false callback := func(entries fs.DirEntries) error { callbackInvoked = true return nil } helper := NewHelper(callback) entry := mockobject.Object("A") require.NoError(t, helper.Add(entry)) assert.Len(t, helper.entries, 1) assert.False(t, callbackInvoked, "Callback should not be invoked before reaching 100 entries") // Check adding a nil entry doesn't change anything require.NoError(t, helper.Add(nil)) assert.Len(t, helper.entries, 1) assert.False(t, callbackInvoked, "Callback should not be invoked before reaching 100 entries") } func TestListRHelperSend(t *testing.T) { entry := mockobject.Object("A") callbackInvoked := false callback := func(entries fs.DirEntries) error { callbackInvoked = true assert.Equal(t, 100, len(entries)) for _, obj := range entries { assert.Equal(t, entry, obj) } return nil } helper := NewHelper(callback) // Add 100 entries to force the callback to be invoked for i := 0; i < 100; i++ { require.NoError(t, helper.Add(entry)) } assert.Len(t, helper.entries, 0) assert.True(t, callbackInvoked, "Callback should be invoked after 100 entries") } func TestListRHelperFlush(t *testing.T) { entry := mockobject.Object("A") callbackInvoked := false callback := func(entries fs.DirEntries) error { callbackInvoked = true assert.Equal(t, 1, len(entries)) for _, obj := range entries { assert.Equal(t, entry, obj) } return nil } helper := NewHelper(callback) require.NoError(t, helper.Add(entry)) assert.False(t, callbackInvoked, "Callback should not have been invoked yet") require.NoError(t, helper.Flush()) assert.True(t, callbackInvoked, "Callback should be invoked on flush") assert.Len(t, helper.entries, 0, "Entries should be cleared after flush") } type mockListPfs struct { t *testing.T entries fs.DirEntries err error errorAfter int } func (f *mockListPfs) ListP(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { assert.Equal(f.t, "dir", dir) count := 0 for entries := f.entries; len(entries) > 0; entries = entries[2:] { err = callback(entries[:2]) if err != nil { return err } count += 2 if f.err != nil && count >= f.errorAfter { return f.err } } return nil } // check interface var _ fs.ListPer = (*mockListPfs)(nil) func TestListWithListP(t *testing.T) { ctx := context.Background() var entries fs.DirEntries for i := 0; i < 26; i++ { entries = append(entries, mockobject.New(fmt.Sprintf("%c", 'A'+i))) } t.Run("NoError", func(t *testing.T) { f := &mockListPfs{ t: t, entries: entries, } gotEntries, err := WithListP(ctx, "dir", f) require.NoError(t, err) assert.Equal(t, entries, gotEntries) }) t.Run("Error", func(t *testing.T) { f := &mockListPfs{t: t, entries: entries, err: errors.New("BOOM"), errorAfter: 10, } gotEntries, err := WithListP(ctx, "dir", f) assert.Equal(t, f.err, err) assert.Equal(t, entries[:10], gotEntries) }) } rclone-v1.71.0/fs/list/list.go000066400000000000000000000123101505210326400161300ustar00rootroot00000000000000// Package list contains list functions package list import ( "context" "fmt" "sort" "strings" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/lib/bucket" ) // DirSorted reads Object and *Dir into entries for the given Fs. // // dir is the start directory, "" for root // // If includeAll is specified all files will be added, otherwise only // files and directories passing the filter will be added. // // Files will be returned in sorted order func DirSorted(ctx context.Context, f fs.Fs, includeAll bool, dir string) (entries fs.DirEntries, err error) { // Get unfiltered entries from the fs entries, err = f.List(ctx, dir) accounting.Stats(ctx).Listed(int64(len(entries))) if err != nil { return nil, err } // This should happen only if exclude files lives in the // starting directory, otherwise ListDirSorted should not be // called. fi := filter.GetConfig(ctx) if !includeAll && fi.ListContainsExcludeFile(entries) { fs.Debugf(dir, "Excluded") return nil, nil } return filterAndSortDir(ctx, entries, includeAll, dir, fi.IncludeObject, fi.IncludeDirectory(ctx, f)) } // listP for every backend func listP(ctx context.Context, f fs.Fs, dir string, callback fs.ListRCallback) error { if doListP := f.Features().ListP; doListP != nil { return doListP(ctx, dir, callback) } // Fallback to List entries, err := f.List(ctx, dir) if err != nil { return err } return callback(entries) } // DirSortedFn reads Object and *Dir into entries for the given Fs. // // dir is the start directory, "" for root // // If includeAll is specified all files will be added, otherwise only // files and directories passing the filter will be added. // // Files will be returned through callback in sorted order func DirSortedFn(ctx context.Context, f fs.Fs, includeAll bool, dir string, callback fs.ListRCallback, keyFn KeyFn) (err error) { stats := accounting.Stats(ctx) fi := filter.GetConfig(ctx) // Sort the entries, in or out of memory sorter, err := NewSorter(ctx, f, callback, keyFn) if err != nil { return fmt.Errorf("failed to create directory sorter: %w", err) } defer sorter.CleanUp() // Get unfiltered entries from the fs err = listP(ctx, f, dir, func(entries fs.DirEntries) error { stats.Listed(int64(len(entries))) // This should happen only if exclude files lives in the // starting directory, otherwise ListDirSorted should not be // called. if !includeAll && fi.ListContainsExcludeFile(entries) { fs.Debugf(dir, "Excluded") return nil } entries, err := filterDir(ctx, entries, includeAll, dir, fi.IncludeObject, fi.IncludeDirectory(ctx, f)) if err != nil { return err } return sorter.Add(entries) }) if err != nil { return err } return sorter.Send() } // Filter the entries passed in func filterDir(ctx context.Context, entries fs.DirEntries, includeAll bool, dir string, IncludeObject func(ctx context.Context, o fs.Object) bool, IncludeDirectory func(remote string) (bool, error)) (newEntries fs.DirEntries, err error) { newEntries = entries[:0] // in place filter prefix := "" if dir != "" { prefix = dir if !bucket.IsAllSlashes(dir) { prefix += "/" } } for _, entry := range entries { ok := true // check includes and types switch x := entry.(type) { case fs.Object: // Make sure we don't delete excluded files if not required if !includeAll && !IncludeObject(ctx, x) { ok = false fs.Debugf(x, "Excluded") } case fs.Directory: if !includeAll { include, err := IncludeDirectory(x.Remote()) if err != nil { return nil, err } if !include { ok = false fs.Debugf(x, "Excluded") } } default: return nil, fmt.Errorf("unknown object type %T", entry) } // check remote name belongs in this directory remote := entry.Remote() switch { case !ok: // ignore case !strings.HasPrefix(remote, prefix): ok = false fs.Errorf(entry, "Entry doesn't belong in directory %q (too short) - ignoring", dir) case remote == dir: ok = false fs.Errorf(entry, "Entry doesn't belong in directory %q (same as directory) - ignoring", dir) case strings.ContainsRune(remote[len(prefix):], '/') && !bucket.IsAllSlashes(remote[len(prefix):]): ok = false fs.Errorf(entry, "Entry doesn't belong in directory %q (contains subdir) - ignoring", dir) default: // ok } if ok { newEntries = append(newEntries, entry) } } return newEntries, nil } // filter and sort the entries func filterAndSortDir(ctx context.Context, entries fs.DirEntries, includeAll bool, dir string, IncludeObject func(ctx context.Context, o fs.Object) bool, IncludeDirectory func(remote string) (bool, error)) (newEntries fs.DirEntries, err error) { // Filter the directory entries (in place) entries, err = filterDir(ctx, entries, includeAll, dir, IncludeObject, IncludeDirectory) if err != nil { return nil, err } // Sort the directory entries by Remote // // We use a stable sort here just in case there are // duplicates. Assuming the remote delivers the entries in a // consistent order, this will give the best user experience // in syncing as it will use the first entry for the sync // comparison. sort.Stable(entries) return entries, nil } rclone-v1.71.0/fs/list/list_test.go000066400000000000000000000066761505210326400172110ustar00rootroot00000000000000package list import ( "context" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest/mockdir" "github.com/rclone/rclone/fstest/mockobject" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // NB integration tests for DirSorted are in // fs/operations/listdirsorted_test.go func TestFilterAndSortIncludeAll(t *testing.T) { da := mockdir.New("a") oA := mockobject.Object("A") db := mockdir.New("b") oB := mockobject.Object("B") dc := mockdir.New("c") oC := mockobject.Object("C") dd := mockdir.New("d") oD := mockobject.Object("D") entries := fs.DirEntries{da, oA, db, oB, dc, oC, dd, oD} includeObject := func(ctx context.Context, o fs.Object) bool { return o != oB } includeDirectory := func(remote string) (bool, error) { return remote != "c", nil } // no filter newEntries, err := filterAndSortDir(context.Background(), entries, true, "", includeObject, includeDirectory) require.NoError(t, err) assert.Equal(t, newEntries, fs.DirEntries{oA, oB, oC, oD, da, db, dc, dd}, ) // filter newEntries, err = filterAndSortDir(context.Background(), entries, false, "", includeObject, includeDirectory) require.NoError(t, err) assert.Equal(t, newEntries, fs.DirEntries{oA, oC, oD, da, db, dd}, ) } func TestFilterAndSortCheckDir(t *testing.T) { // Check the different kinds of error when listing "dir" da := mockdir.New("dir") da2 := mockdir.New("dir/") // double slash dir - allowed for bucket based remotes oA := mockobject.Object("diR/a") db := mockdir.New("dir/b") oB := mockobject.Object("dir/B/sub") dc := mockdir.New("dir/c") oC := mockobject.Object("dir/C") dd := mockdir.New("dir/d") oD := mockobject.Object("dir/D") entries := fs.DirEntries{da, da2, oA, db, oB, dc, oC, dd, oD} newEntries, err := filterAndSortDir(context.Background(), entries, true, "dir", nil, nil) require.NoError(t, err) assert.Equal(t, fs.DirEntries{da2, oC, oD, db, dc, dd}, newEntries, ) } func TestFilterAndSortCheckDirRoot(t *testing.T) { // Check the different kinds of error when listing the root "" da := mockdir.New("") da2 := mockdir.New("/") // doubleslash dir allowed on bucket based remotes oA := mockobject.Object("A") db := mockdir.New("b") oB := mockobject.Object("B/sub") dc := mockdir.New("c") oC := mockobject.Object("C") dd := mockdir.New("d") oD := mockobject.Object("D") entries := fs.DirEntries{da, da2, oA, db, oB, dc, oC, dd, oD} newEntries, err := filterAndSortDir(context.Background(), entries, true, "", nil, nil) require.NoError(t, err) assert.Equal(t, fs.DirEntries{da2, oA, oC, oD, db, dc, dd}, newEntries, ) } type unknownDirEntry string func (o unknownDirEntry) Fs() fs.Info { return fs.Unknown } func (o unknownDirEntry) String() string { return string(o) } func (o unknownDirEntry) Remote() string { return string(o) } func (o unknownDirEntry) ModTime(ctx context.Context) (t time.Time) { return t } func (o unknownDirEntry) Size() int64 { return 0 } func TestFilterAndSortUnknown(t *testing.T) { // Check that an unknown entry produces an error da := mockdir.New("") oA := mockobject.Object("A") ub := unknownDirEntry("b") oB := mockobject.Object("B/sub") entries := fs.DirEntries{da, oA, ub, oB} newEntries, err := filterAndSortDir(context.Background(), entries, true, "", nil, nil) assert.Error(t, err, "error") assert.Nil(t, newEntries) } rclone-v1.71.0/fs/list/sorter.go000066400000000000000000000226611505210326400165050ustar00rootroot00000000000000package list import ( "cmp" "context" "errors" "fmt" "slices" "strings" "sync" "time" "github.com/lanrat/extsort" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/lib/errcount" "golang.org/x/sync/errgroup" ) // NewObjecter is the minimum facilities we need from the fs.Fs passed into NewSorter. type NewObjecter interface { // NewObject finds the Object at remote. If it can't be found // it returns the error ErrorObjectNotFound. NewObject(ctx context.Context, remote string) (fs.Object, error) } // Sorter implements an efficient mechanism for sorting list entries. // // If there are a large number of entries (above `--list-cutoff`), // this may be done on disk instead of in memory. // // Supply entries with the Add method, call Send at the end to deliver // the sorted entries and finalise with CleanUp regardless of whether // you called Add or Send. // // Sorted entries are delivered to the callback supplied to NewSorter // when the Send method is called. type Sorter struct { ctx context.Context // context for everything ci *fs.ConfigInfo // config we are using cancel func() // cancel all background operations mu sync.Mutex // protect the below f NewObjecter // fs that we are listing callback fs.ListRCallback // where to send the sorted entries to entries fs.DirEntries // accumulated entries keyFn KeyFn // transform an entry into a sort key cutoff int // number of entries above which we start extsort extSort bool // true if we are ext sorting inputChan chan string // for sending data to the ext sort outputChan <-chan string // for receiving data from the ext sort errChan <-chan error // for getting errors from the ext sort sorter *extsort.StringSorter // external string sort errs *errcount.ErrCount // accumulate errors } // KeyFn turns an entry into a sort key type KeyFn func(entry fs.DirEntry) string // identityKeyFn maps an entry to its Remote func identityKeyFn(entry fs.DirEntry) string { return entry.Remote() } // NewSorter creates a new Sorter with callback for sorted entries to // be delivered to. keyFn is used to process each entry to get a key // function, if nil then it will just use entry.Remote() func NewSorter(ctx context.Context, f NewObjecter, callback fs.ListRCallback, keyFn KeyFn) (*Sorter, error) { ci := fs.GetConfig(ctx) ctx, cancel := context.WithCancel(ctx) if keyFn == nil { keyFn = identityKeyFn } return &Sorter{ ctx: ctx, ci: ci, cancel: cancel, f: f, callback: callback, keyFn: keyFn, cutoff: ci.ListCutoff, errs: errcount.New(), }, nil } // Turn a directory entry into a combined key and data for extsort func (ls *Sorter) entryToKey(entry fs.DirEntry) string { // To start with we just use the Remote to recover the object // To make more efficient we would serialize the object here remote := entry.Remote() remote = strings.TrimRight(remote, "/") if _, isDir := entry.(fs.Directory); isDir { remote += "/" } key := ls.keyFn(entry) + "\x00" + remote return key } // Turn an exsort key back into a directory entry func (ls *Sorter) keyToEntry(ctx context.Context, key string) (entry fs.DirEntry, err error) { null := strings.IndexRune(key, '\x00') if null < 0 { return nil, errors.New("sorter: failed to deserialize: missing null") } remote := key[null+1:] if remote, isDir := strings.CutSuffix(remote, "/"); isDir { // Is a directory // // Note this creates a very minimal directory entry which should be fine for the // bucket based remotes this code will be run on. entry = fs.NewDir(remote, time.Time{}) } else { obj, err := ls.f.NewObject(ctx, remote) if err != nil { fs.Errorf(ls.f, "sorter: failed to re-create object %q: %v", remote, err) return nil, fmt.Errorf("sorter: failed to re-create object: %w", err) } entry = obj } return entry, nil } func (ls *Sorter) sendEntriesToExtSort(entries fs.DirEntries) (err error) { for _, entry := range entries { select { case ls.inputChan <- ls.entryToKey(entry): case err = <-ls.errChan: if err != nil { return err } } } select { case err = <-ls.errChan: default: } return err } func (ls *Sorter) startExtSort() (err error) { fs.Logf(ls.f, "Switching to on disk sorting as more than %d entries in one directory detected", ls.cutoff) ls.inputChan = make(chan string, 100) // Options to control the extsort opt := extsort.Config{ NumWorkers: 8, // small effect ChanBuffSize: 1024, // small effect SortedChanBuffSize: 1024, // makes a lot of difference ChunkSize: 32 * 1024, // tuned for 50 char records (UUID sized) // Defaults // ChunkSize: int(1e6), // amount of records to store in each chunk which will be written to disk // NumWorkers: 2, // maximum number of workers to use for parallel sorting // ChanBuffSize: 1, // buffer size for merging chunks // SortedChanBuffSize: 10, // buffer size for passing records to output // TempFilesDir: "", // empty for use OS default ex: /tmp } ls.sorter, ls.outputChan, ls.errChan = extsort.Strings(ls.inputChan, &opt) go ls.sorter.Sort(ls.ctx) // Show we are extsorting now ls.extSort = true // Send the accumulated entries to the sorter fs.Debugf(ls.f, "Sending accumulated directory entries to disk") err = ls.sendEntriesToExtSort(ls.entries) fs.Debugf(ls.f, "Done sending accumulated directory entries to disk") clear(ls.entries) ls.entries = nil return err } // Add entries to the list sorter. // // Does not call the callback. // // Safe to call from concurrent go routines func (ls *Sorter) Add(entries fs.DirEntries) error { ls.mu.Lock() defer ls.mu.Unlock() if ls.extSort { err := ls.sendEntriesToExtSort(entries) if err != nil { return err } } else { ls.entries = append(ls.entries, entries...) if len(ls.entries) >= ls.cutoff { err := ls.startExtSort() if err != nil { return err } } } return nil } // Number of entries to batch in list helper const listHelperBatchSize = 100 // listHelper is used to turn keys into entries concurrently type listHelper struct { ls *Sorter // parent keys []string // keys being built up entries fs.DirEntries // entries processed concurrently as a batch errs []error // errors processed concurrently } // NewlistHelper should be with the callback passed in func (ls *Sorter) newListHelper() *listHelper { return &listHelper{ ls: ls, entries: make(fs.DirEntries, listHelperBatchSize), errs: make([]error, listHelperBatchSize), } } // send sends the stored entries to the callback if there are >= max // entries. func (lh *listHelper) send(max int) (err error) { if len(lh.keys) < max { return nil } // Turn this batch into objects in parallel g, gCtx := errgroup.WithContext(lh.ls.ctx) g.SetLimit(lh.ls.ci.Checkers) for i, key := range lh.keys { i, key := i, key // can remove when go1.22 is minimum version g.Go(func() error { lh.entries[i], lh.errs[i] = lh.ls.keyToEntry(gCtx, key) return nil }) } err = g.Wait() if err != nil { return err } // Account errors and collect OK entries toSend := lh.entries[:0] for i := range lh.keys { entry, err := lh.entries[i], lh.errs[i] if err != nil { lh.ls.errs.Add(err) } else if entry != nil { toSend = append(toSend, entry) } } // fmt.Println(lh.keys) // fmt.Println(toSend) err = lh.ls.callback(toSend) clear(lh.entries) clear(lh.errs) lh.keys = lh.keys[:0] return err } // Add an entry to the stored entries and send them if there are more // than a certain amount func (lh *listHelper) Add(key string) error { lh.keys = append(lh.keys, key) return lh.send(100) } // Flush the stored entries (if any) sending them to the callback func (lh *listHelper) Flush() error { return lh.send(1) } // Send the sorted entries to the callback. func (ls *Sorter) Send() (err error) { ls.mu.Lock() defer ls.mu.Unlock() if ls.extSort { close(ls.inputChan) list := ls.newListHelper() outer: for { select { case key, ok := <-ls.outputChan: if !ok { break outer } err := list.Add(key) if err != nil { return err } case err := <-ls.errChan: if err != nil { return err } } } err = list.Flush() if err != nil { return err } return ls.errs.Err("sorter") } // Sort the directory entries by Remote // // We use a stable sort here just in case there are // duplicates. Assuming the remote delivers the entries in a // consistent order, this will give the best user experience // in syncing as it will use the first entry for the sync // comparison. slices.SortStableFunc(ls.entries, func(a, b fs.DirEntry) int { return cmp.Compare(ls.keyFn(a), ls.keyFn(b)) }) return ls.callback(ls.entries) } // CleanUp the Sorter, cleaning up any memory / files. // // It is safe and encouraged to call this regardless of whether you // called Send or not. // // This does not call the callback func (ls *Sorter) CleanUp() { ls.mu.Lock() defer ls.mu.Unlock() ls.cancel() clear(ls.entries) ls.entries = nil ls.extSort = false } // SortToChan makes a callback for the Sorter which sends the output // to the channel provided. func SortToChan(out chan<- fs.DirEntry) fs.ListRCallback { return func(entries fs.DirEntries) error { for _, entry := range entries { out <- entry } return nil } } rclone-v1.71.0/fs/list/sorter_test.go000066400000000000000000000201101505210326400175270ustar00rootroot00000000000000package list import ( "cmp" "context" "fmt" "slices" "strings" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest/mockdir" "github.com/rclone/rclone/fstest/mockobject" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestSorter(t *testing.T) { ctx := context.Background() da := mockdir.New("a") oA := mockobject.Object("A") callback := func(entries fs.DirEntries) error { require.Equal(t, fs.DirEntries{oA, da}, entries) return nil } ls, err := NewSorter(ctx, nil, callback, nil) require.NoError(t, err) assert.Equal(t, fmt.Sprintf("%p", callback), fmt.Sprintf("%p", ls.callback)) assert.Equal(t, fmt.Sprintf("%p", identityKeyFn), fmt.Sprintf("%p", ls.keyFn)) assert.Equal(t, fs.DirEntries(nil), ls.entries) // Test Add err = ls.Add(fs.DirEntries{da}) require.NoError(t, err) assert.Equal(t, fs.DirEntries{da}, ls.entries) err = ls.Add(fs.DirEntries{oA}) require.NoError(t, err) assert.Equal(t, fs.DirEntries{da, oA}, ls.entries) // Test Send err = ls.Send() require.NoError(t, err) // Test Cleanup ls.CleanUp() assert.Equal(t, fs.DirEntries(nil), ls.entries) } func TestSorterIdentity(t *testing.T) { ctx := context.Background() cmpFn := func(a, b fs.DirEntry) int { return cmp.Compare(a.Remote(), b.Remote()) } callback := func(entries fs.DirEntries) error { assert.True(t, slices.IsSortedFunc(entries, cmpFn)) assert.Equal(t, "a", entries[0].Remote()) return nil } ls, err := NewSorter(ctx, nil, callback, nil) require.NoError(t, err) defer ls.CleanUp() // Add things in reverse alphabetical order for i := 'z'; i >= 'a'; i-- { err = ls.Add(fs.DirEntries{mockobject.Object(string(i))}) require.NoError(t, err) } assert.Equal(t, "z", ls.entries[0].Remote()) assert.False(t, slices.IsSortedFunc(ls.entries, cmpFn)) // Check they get sorted err = ls.Send() require.NoError(t, err) } func TestSorterKeyFn(t *testing.T) { ctx := context.Background() keyFn := func(entry fs.DirEntry) string { s := entry.Remote() return string('z' - s[0]) } cmpFn := func(a, b fs.DirEntry) int { return cmp.Compare(keyFn(a), keyFn(b)) } callback := func(entries fs.DirEntries) error { assert.True(t, slices.IsSortedFunc(entries, cmpFn)) assert.Equal(t, "z", entries[0].Remote()) return nil } ls, err := NewSorter(ctx, nil, callback, keyFn) require.NoError(t, err) defer ls.CleanUp() // Add things in reverse sorted order for i := 'a'; i <= 'z'; i++ { err = ls.Add(fs.DirEntries{mockobject.Object(string(i))}) require.NoError(t, err) } assert.Equal(t, "a", ls.entries[0].Remote()) assert.False(t, slices.IsSortedFunc(ls.entries, cmpFn)) // Check they get sorted err = ls.Send() require.NoError(t, err) } // testFs implements enough of the fs.Fs interface for Sorter type testFs struct { t *testing.T entriesMap map[string]fs.DirEntry } // NewObject finds the Object at remote. If it can't be found // it returns the error ErrorObjectNotFound. func (f *testFs) NewObject(ctx context.Context, remote string) (fs.Object, error) { entry, ok := f.entriesMap[remote] assert.True(f.t, ok, "entry not found") if !ok { return nil, fs.ErrorObjectNotFound } obj, ok := entry.(fs.Object) assert.True(f.t, ok, "expected entry to be object: %#v", entry) if !ok { return nil, fs.ErrorObjectNotFound } return obj, nil } // String outputs info about the Fs func (f *testFs) String() string { return "testFs" } // used to sort the entries case insensitively func keyCaseInsensitive(entry fs.DirEntry) string { return strings.ToLower(entry.Remote()) } // Test the external sorting func testSorterExt(t *testing.T, cutoff, N int, wantExtSort bool, keyFn KeyFn) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) ci.ListCutoff = cutoff // Make the directory entries entriesMap := make(map[string]fs.DirEntry, N) for i := 0; i < N; i++ { remote := fmt.Sprintf("%010d", i) prefix := "a" if i%3 == 0 { prefix = "A" } remote = prefix + remote if i%2 == 0 { entriesMap[remote] = mockobject.New(remote) } else { entriesMap[remote] = mockdir.New(remote) } } assert.Equal(t, N, len(entriesMap)) f := &testFs{t: t, entriesMap: entriesMap} // In the callback delete entries from the map when they are // found prevKey := "" callback := func(entries fs.DirEntries) error { for _, gotEntry := range entries { remote := gotEntry.Remote() key := remote if keyFn != nil { key = keyFn(gotEntry) } require.Less(t, prevKey, key, "Not sorted") prevKey = key wantEntry, ok := entriesMap[remote] assert.True(t, ok, "Entry not found %q", remote) _, wantDir := wantEntry.(fs.Directory) _, gotDir := wantEntry.(fs.Directory) _, wantObj := wantEntry.(fs.Object) _, gotObj := wantEntry.(fs.Object) require.True(t, (wantDir && gotDir) || (wantObj && gotObj), "Wrong types %#v, %#v", wantEntry, gotEntry) delete(entriesMap, remote) } return nil } ls, err := NewSorter(ctx, f, callback, keyFn) require.NoError(t, err) // Send the entries in random (map) order for _, entry := range entriesMap { err = ls.Add(fs.DirEntries{entry}) require.NoError(t, err) } // Check we are extsorting if required assert.Equal(t, wantExtSort, ls.extSort) // Test Send err = ls.Send() require.NoError(t, err) // All the entries should have been seen assert.Equal(t, 0, len(entriesMap)) // Test Cleanup ls.CleanUp() assert.Equal(t, fs.DirEntries(nil), ls.entries) } // Test the external sorting func TestSorterExt(t *testing.T) { for _, test := range []struct { cutoff int N int wantExtSort bool keyFn KeyFn }{ {cutoff: 1000, N: 100, wantExtSort: false}, {cutoff: 100, N: 1000, wantExtSort: true}, {cutoff: 1000, N: 100, wantExtSort: false, keyFn: keyCaseInsensitive}, {cutoff: 100, N: 1000, wantExtSort: true, keyFn: keyCaseInsensitive}, {cutoff: 100001, N: 100000, wantExtSort: false}, {cutoff: 100000, N: 100001, wantExtSort: true}, // {cutoff: 100_000, N: 1_000_000, wantExtSort: true}, // {cutoff: 100_000, N: 10_000_000, wantExtSort: true}, } { t.Run(fmt.Sprintf("cutoff=%d,N=%d,wantExtSort=%v,keyFn=%v", test.cutoff, test.N, test.wantExtSort, test.keyFn != nil), func(t *testing.T) { testSorterExt(t, test.cutoff, test.N, test.wantExtSort, test.keyFn) }) } } // benchFs implements enough of the fs.Fs interface for Sorter type benchFs struct{} // NewObject finds the Object at remote. If it can't be found // it returns the error ErrorObjectNotFound. func (benchFs) NewObject(ctx context.Context, remote string) (fs.Object, error) { // Recreate the mock objects return mockobject.New(remote), nil } // String outputs info about the Fs func (benchFs) String() string { return "benchFs" } func BenchmarkSorterExt(t *testing.B) { const cutoff = 1000 const N = 10_000_000 ctx := context.Background() ctx, ci := fs.AddConfig(ctx) ci.ListCutoff = cutoff keyFn := keyCaseInsensitive // In the callback check entries are in order prevKey := "" entriesReceived := 0 callback := func(entries fs.DirEntries) error { for _, gotEntry := range entries { remote := gotEntry.Remote() key := remote if keyFn != nil { key = keyFn(gotEntry) } require.Less(t, prevKey, key, "Not sorted") prevKey = key entriesReceived++ } return nil } f := benchFs{} ls, err := NewSorter(ctx, f, callback, keyFn) require.NoError(t, err) // Send the entries in reverse order in batches of 1000 like the backends do var entries = make(fs.DirEntries, 0, 1000) for i := N - 1; i >= 0; i-- { remote := fmt.Sprintf("%050d", i) // UUID length plus a bit prefix := "a" if i%3 == 0 { prefix = "A" } remote = prefix + remote if i%2 == 0 { entries = append(entries, mockobject.New(remote)) } else { entries = append(entries, mockdir.New(remote)) } if len(entries) > 1000 { err = ls.Add(entries) require.NoError(t, err) entries = entries[:0] } } err = ls.Add(entries) require.NoError(t, err) // Check we are extsorting assert.True(t, ls.extSort) // Test Send err = ls.Send() require.NoError(t, err) // All the entries should have been seen assert.Equal(t, N, entriesReceived) // Cleanup ls.CleanUp() } rclone-v1.71.0/fs/log.go000066400000000000000000000224131505210326400147700ustar00rootroot00000000000000package fs import ( "context" "encoding/json" "fmt" "log/slog" "os" "slices" ) // LogLevel describes rclone's logs. These are a subset of the syslog log levels. type LogLevel = Enum[logLevelChoices] // Log levels. These are the syslog levels of which we only use a // subset. // // LOG_EMERG system is unusable // LOG_ALERT action must be taken immediately // LOG_CRIT critical conditions // LOG_ERR error conditions // LOG_WARNING warning conditions // LOG_NOTICE normal, but significant, condition // LOG_INFO informational message // LOG_DEBUG debug-level message const ( LogLevelEmergency LogLevel = iota LogLevelAlert LogLevelCritical LogLevelError // Error - can't be suppressed LogLevelWarning LogLevelNotice // Normal logging, -q suppresses LogLevelInfo // Transfers, needs -v LogLevelDebug // Debug level, needs -vv LogLevelOff ) type logLevelChoices struct{} func (logLevelChoices) Choices() []string { return []string{ LogLevelEmergency: "EMERGENCY", LogLevelAlert: "ALERT", LogLevelCritical: "CRITICAL", LogLevelError: "ERROR", LogLevelWarning: "WARNING", LogLevelNotice: "NOTICE", LogLevelInfo: "INFO", LogLevelDebug: "DEBUG", LogLevelOff: "OFF", } } func (logLevelChoices) Type() string { return "LogLevel" } // slogLevel definitions defined as slog.Level constants. // The integer values determine severity for filtering. // Lower values are less severe (e.g., Debug), higher values are more severe (e.g., Emergency). // We fit our extra values into slog's scale. const ( // slog.LevelDebug slog.Level = -4 // slog.LevelInfo slog.Level = 0 SlogLevelNotice = slog.Level(2) // Between Info (0) and Warn (4) // slog.LevelWarn slog.Level = 4 // slog.LevelError slog.Level = 8 SlogLevelCritical = slog.Level(12) // More severe than Error SlogLevelAlert = slog.Level(16) // More severe than Critical SlogLevelEmergency = slog.Level(20) // Most severe SlogLevelOff = slog.Level(24) // A very high value ) // Map our level numbers to slog level numbers var levelToSlog = []slog.Level{ LogLevelEmergency: SlogLevelEmergency, LogLevelAlert: SlogLevelAlert, LogLevelCritical: SlogLevelCritical, LogLevelError: slog.LevelError, LogLevelWarning: slog.LevelWarn, LogLevelNotice: SlogLevelNotice, LogLevelInfo: slog.LevelInfo, LogLevelDebug: slog.LevelDebug, LogLevelOff: SlogLevelOff, } // LogValueItem describes keyed item for a JSON log entry type LogValueItem struct { key string value any render bool } // LogValue should be used as an argument to any logging calls to // augment the JSON output with more structured information. // // key is the dictionary parameter used to store value. func LogValue(key string, value any) LogValueItem { return LogValueItem{key: key, value: value, render: true} } // LogValueHide should be used as an argument to any logging calls to // augment the JSON output with more structured information. // // key is the dictionary parameter used to store value. // // String() will return a blank string - this is useful to put items // in which don't print into the log. func LogValueHide(key string, value any) LogValueItem { return LogValueItem{key: key, value: value, render: false} } // String returns the representation of value. If render is false this // is an empty string so LogValueItem entries won't show in the // textual representation of logs. func (j LogValueItem) String() string { if !j.render { return "" } if do, ok := j.value.(fmt.Stringer); ok { return do.String() } return fmt.Sprint(j.value) } // LogLevelToSlog converts an rclone log level to log/slog log level. func LogLevelToSlog(level LogLevel) slog.Level { slogLevel := slog.LevelError // NB level is unsigned so we don't check < 0 here if int(level) < len(levelToSlog) { slogLevel = levelToSlog[level] } return slogLevel } func logSlog(level LogLevel, text string, attrs []any) { slog.Log(context.Background(), LogLevelToSlog(level), text, attrs...) } func logSlogWithObject(level LogLevel, o any, text string, attrs []any) { if o != nil { attrs = slices.Concat(attrs, []any{ "object", fmt.Sprintf("%+v", o), "objectType", fmt.Sprintf("%T", o), }) } logSlog(level, text, attrs) } // LogPrint produces a log string from the arguments passed in func LogPrint(level LogLevel, o any, text string) { logSlogWithObject(level, o, text, nil) } // LogPrintf produces a log string from the arguments passed in func LogPrintf(level LogLevel, o any, text string, args ...any) { text = fmt.Sprintf(text, args...) var fields []any for _, arg := range args { if item, ok := arg.(LogValueItem); ok { fields = append(fields, item.key, item.value) } } logSlogWithObject(level, o, text, fields) } // LogLevelPrint writes logs at the given level func LogLevelPrint(level LogLevel, o any, text string) { if GetConfig(context.TODO()).LogLevel >= level { LogPrint(level, o, text) } } // LogLevelPrintf writes logs at the given level func LogLevelPrintf(level LogLevel, o any, text string, args ...any) { if GetConfig(context.TODO()).LogLevel >= level { LogPrintf(level, o, text, args...) } } // Panic writes alert log output for this Object or Fs and calls panic(). // It should always be seen by the user. func Panic(o any, text string) { if GetConfig(context.TODO()).LogLevel >= LogLevelAlert { LogPrint(LogLevelAlert, o, text) } panic(text) } // Panicf writes alert log output for this Object or Fs and calls panic(). // It should always be seen by the user. func Panicf(o any, text string, args ...any) { if GetConfig(context.TODO()).LogLevel >= LogLevelAlert { LogPrintf(LogLevelAlert, o, text, args...) } panic(fmt.Sprintf(text, args...)) } // Fatal writes critical log output for this Object or Fs and calls os.Exit(1). // It should always be seen by the user. func Fatal(o any, text string) { if GetConfig(context.TODO()).LogLevel >= LogLevelCritical { LogPrint(LogLevelCritical, o, text) } os.Exit(1) } // Fatalf writes critical log output for this Object or Fs and calls os.Exit(1). // It should always be seen by the user. func Fatalf(o any, text string, args ...any) { if GetConfig(context.TODO()).LogLevel >= LogLevelCritical { LogPrintf(LogLevelCritical, o, text, args...) } os.Exit(1) } // Error writes error log output for this Object or Fs. It // should always be seen by the user. func Error(o any, text string) { LogLevelPrint(LogLevelError, o, text) } // Errorf writes error log output for this Object or Fs. It // should always be seen by the user. func Errorf(o any, text string, args ...any) { LogLevelPrintf(LogLevelError, o, text, args...) } // Print writes log output for this Object or Fs, same as Logf. func Print(o any, text string) { LogLevelPrint(LogLevelNotice, o, text) } // Printf writes log output for this Object or Fs, same as Logf. func Printf(o any, text string, args ...any) { LogLevelPrintf(LogLevelNotice, o, text, args...) } // Log writes log output for this Object or Fs. This should be // considered to be Notice level logging. It is the default level. // By default rclone should not log very much so only use this for // important things the user should see. The user can filter these // out with the -q flag. func Log(o any, text string) { LogLevelPrint(LogLevelNotice, o, text) } // Logf writes log output for this Object or Fs. This should be // considered to be Notice level logging. It is the default level. // By default rclone should not log very much so only use this for // important things the user should see. The user can filter these // out with the -q flag. func Logf(o any, text string, args ...any) { LogLevelPrintf(LogLevelNotice, o, text, args...) } // Infoc writes info on transfers for this Object or Fs. Use this // level for logging transfers, deletions and things which should // appear with the -v flag. // There is name class on "Info", hence the name "Infoc", "c" for constant. func Infoc(o any, text string) { LogLevelPrint(LogLevelInfo, o, text) } // Infof writes info on transfers for this Object or Fs. Use this // level for logging transfers, deletions and things which should // appear with the -v flag. func Infof(o any, text string, args ...any) { LogLevelPrintf(LogLevelInfo, o, text, args...) } // Debug writes debugging output for this Object or Fs. Use this for // debug only. The user must have to specify -vv to see this. func Debug(o any, text string) { LogLevelPrint(LogLevelDebug, o, text) } // Debugf writes debugging output for this Object or Fs. Use this for // debug only. The user must have to specify -vv to see this. func Debugf(o any, text string, args ...any) { LogLevelPrintf(LogLevelDebug, o, text, args...) } // LogDirName returns an object for the logger, logging a root // directory which would normally be "" as the Fs func LogDirName(f Fs, dir string) any { if dir != "" { return dir } return f } // PrettyPrint formats JSON for improved readability in debug logs. // If it can't Marshal JSON, it falls back to fmt. func PrettyPrint(in any, label string, level LogLevel) { if GetConfig(context.TODO()).LogLevel < level { return } inBytes, err := json.MarshalIndent(in, "", "\t") if err != nil || string(inBytes) == "{}" || string(inBytes) == "[]" { LogPrintf(level, label, "\n%+v\n", in) return } LogPrintf(level, label, "\n%s\n", string(inBytes)) } rclone-v1.71.0/fs/log/000077500000000000000000000000001505210326400144375ustar00rootroot00000000000000rclone-v1.71.0/fs/log/event_log.go000066400000000000000000000004531505210326400167520ustar00rootroot00000000000000// Windows event logging stubs for non windows machines //go:build !windows package log import ( "fmt" "runtime" ) // Starts windows event log if configured. func startWindowsEventLog(*OutputHandler) error { return fmt.Errorf("windows event log not supported on %s platform", runtime.GOOS) } rclone-v1.71.0/fs/log/event_log_windows.go000066400000000000000000000040231505210326400205210ustar00rootroot00000000000000// Windows event logging //go:build windows package log import ( "fmt" "log/slog" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/lib/atexit" "golang.org/x/sys/windows" "golang.org/x/sys/windows/svc/eventlog" ) const ( errorID = uint32(windows.ERROR_INTERNAL_ERROR) infoID = uint32(windows.ERROR_SUCCESS) sourceName = "rclone" ) var ( windowsEventLog *eventlog.Log ) func startWindowsEventLog(handler *OutputHandler) error { // Don't install Windows event log if it is disabled. if Opt.WindowsEventLogLevel == fs.LogLevelOff { return nil } // Install the event source - we don't care if this fails as Windows has sensible fallbacks. _ = eventlog.InstallAsEventCreate(sourceName, eventlog.Info|eventlog.Warning|eventlog.Error) // Open the event log // If sourceName didn't get registered then Windows will use "Application" instead which is fine. // Though in my tests it seemsed to use sourceName regardless. elog, err := eventlog.Open(sourceName) if err != nil { return fmt.Errorf("open event log: %w", err) } // Set the global for the handler windowsEventLog = elog // Close it on exit atexit.Register(func() { err := elog.Close() if err != nil { fs.Errorf(nil, "Failed to close Windows event log: %v", err) } }) // Add additional JSON logging to the eventLog handler. handler.AddOutput(true, eventLog) fs.Infof(nil, "Logging to Windows event log at level %v", Opt.WindowsEventLogLevel) return nil } // We use levels ERROR, NOTICE, INFO, DEBUG // Need to map to ERROR, WARNING, INFO func eventLog(level slog.Level, text string) { // Check to see if this level is required if level < fs.LogLevelToSlog(Opt.WindowsEventLogLevel) { return } // Now log to windows eventLog switch level { case fs.SlogLevelEmergency, fs.SlogLevelAlert, fs.SlogLevelCritical, slog.LevelError: _ = windowsEventLog.Error(errorID, text) case slog.LevelWarn: _ = windowsEventLog.Warning(infoID, text) case fs.SlogLevelNotice, slog.LevelInfo, slog.LevelDebug: _ = windowsEventLog.Info(infoID, text) } } rclone-v1.71.0/fs/log/log.go000066400000000000000000000177721505210326400155650ustar00rootroot00000000000000// Package log provides logging for rclone package log import ( "context" "fmt" "io" "os" "reflect" "runtime" "strings" "time" "github.com/rclone/rclone/fs" "gopkg.in/natefinch/lumberjack.v2" ) // OptionsInfo descripts the Options in use var OptionsInfo = fs.Options{{ Name: "log_file", Default: "", Help: "Log everything to this file", Groups: "Logging", }, { Name: "log_file_max_size", Default: fs.SizeSuffix(-1), Help: `Maximum size of the log file before it's rotated (eg "10M")`, Groups: "Logging", }, { Name: "log_file_max_backups", Default: 0, Help: "Maximum number of old log files to retain.", Groups: "Logging", }, { Name: "log_file_max_age", Default: fs.Duration(0), Help: `Maximum duration to retain old log files (eg "7d")`, Groups: "Logging", }, { Name: "log_file_compress", Default: false, Help: "If set, compress rotated log files using gzip.", Groups: "Logging", }, { Name: "log_format", Default: logFormatDate | logFormatTime, Help: "Comma separated list of log format options", Groups: "Logging", }, { Name: "syslog", Default: false, Help: "Use Syslog for logging", Groups: "Logging", }, { Name: "syslog_facility", Default: "DAEMON", Help: "Facility for syslog, e.g. KERN,USER", Groups: "Logging", }, { Name: "log_systemd", Default: false, Help: "Activate systemd integration for the logger", Groups: "Logging", }, { Name: "windows_event_log_level", Default: fs.LogLevelOff, Help: "Windows Event Log level DEBUG|INFO|NOTICE|ERROR|OFF", Groups: "Logging", Hide: func() fs.OptionVisibility { if runtime.GOOS == "windows" { return 0 } return fs.OptionHideBoth }(), }} // Options contains options for controlling the logging type Options struct { File string `config:"log_file"` // Log everything to this file MaxSize fs.SizeSuffix `config:"log_file_max_size"` // Max size of log file MaxBackups int `config:"log_file_max_backups"` // Max backups of log file MaxAge fs.Duration `config:"log_file_max_age"` // Max age of of log file Compress bool `config:"log_file_compress"` // Set to compress log file Format logFormat `config:"log_format"` // Comma separated list of log format options UseSyslog bool `config:"syslog"` // Use Syslog for logging SyslogFacility string `config:"syslog_facility"` // Facility for syslog, e.g. KERN,USER,... LogSystemdSupport bool `config:"log_systemd"` // set if using systemd logging WindowsEventLogLevel fs.LogLevel `config:"windows_event_log_level"` } func init() { fs.RegisterGlobalOptions(fs.OptionsInfo{Name: "log", Opt: &Opt, Options: OptionsInfo}) } // Opt is the options for the logger var Opt Options // enum for the log format type logFormat = fs.Bits[logFormatChoices] const ( logFormatDate logFormat = 1 << iota logFormatTime logFormatMicroseconds logFormatUTC logFormatLongFile logFormatShortFile logFormatPid logFormatNoLevel logFormatJSON ) type logFormatChoices struct{} func (logFormatChoices) Choices() []fs.BitsChoicesInfo { return []fs.BitsChoicesInfo{ {Bit: uint64(logFormatDate), Name: "date"}, {Bit: uint64(logFormatTime), Name: "time"}, {Bit: uint64(logFormatMicroseconds), Name: "microseconds"}, {Bit: uint64(logFormatUTC), Name: "UTC"}, {Bit: uint64(logFormatLongFile), Name: "longfile"}, {Bit: uint64(logFormatShortFile), Name: "shortfile"}, {Bit: uint64(logFormatPid), Name: "pid"}, {Bit: uint64(logFormatNoLevel), Name: "nolevel"}, {Bit: uint64(logFormatJSON), Name: "json"}, } } // fnName returns the name of the calling +2 function func fnName() string { pc, _, _, ok := runtime.Caller(2) name := "*Unknown*" if ok { name = runtime.FuncForPC(pc).Name() dot := strings.LastIndex(name, ".") if dot >= 0 { name = name[dot+1:] } } return name } // Trace debugs the entry and exit of the calling function // // It is designed to be used in a defer statement, so it returns a // function that logs the exit parameters. // // Any pointers in the exit function will be dereferenced func Trace(o any, format string, a ...any) func(string, ...any) { if fs.GetConfig(context.Background()).LogLevel < fs.LogLevelDebug { return func(format string, a ...any) {} } name := fnName() fs.LogPrintf(fs.LogLevelDebug, o, name+": "+format, a...) return func(format string, a ...any) { for i := range a { // read the values of the pointed to items typ := reflect.TypeOf(a[i]) if typ.Kind() == reflect.Ptr { value := reflect.ValueOf(a[i]) if value.IsNil() { a[i] = nil } else { pointedToValue := reflect.Indirect(value) a[i] = pointedToValue.Interface() } } } fs.LogPrintf(fs.LogLevelDebug, o, ">"+name+": "+format, a...) } } // Stack logs a stack trace of callers with the o and info passed in func Stack(o any, info string) { if fs.GetConfig(context.Background()).LogLevel < fs.LogLevelDebug { return } arr := [16 * 1024]byte{} buf := arr[:] n := runtime.Stack(buf, false) buf = buf[:n] fs.LogPrintf(fs.LogLevelDebug, o, "%s\nStack trace:\n%s", info, buf) } // This is called from fs when the config is reloaded // // The config should really be here but we can't move it as it is // externally visible in the rc. func logReload(ci *fs.ConfigInfo) error { Handler.SetLevel(fs.LogLevelToSlog(ci.LogLevel)) if Opt.WindowsEventLogLevel != fs.LogLevelOff && Opt.WindowsEventLogLevel > ci.LogLevel { return fmt.Errorf("--windows-event-log-level %q must be >= --log-level %q", Opt.WindowsEventLogLevel, ci.LogLevel) } return nil } func init() { fs.LogReload = logReload } // InitLogging start the logging as per the command line flags func InitLogging() { // Note that ci only has the defaults in at this point // We set real values in logReload ci := fs.GetConfig(context.Background()) // Log file output if Opt.File != "" { var w io.Writer if Opt.MaxSize == 0 { // No log rotation - just open the file as normal // We'll capture tracebacks like this too. f, err := os.OpenFile(Opt.File, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0640) if err != nil { fs.Fatalf(nil, "Failed to open log file: %v", err) } _, err = f.Seek(0, io.SeekEnd) if err != nil { fs.Errorf(nil, "Failed to seek log file to end: %v", err) } redirectStderr(f) w = f } else { // Round with a minimum of 1 if set round := func(x float64) int { if x <= 0 { return 0 } else if x <= 1 { return 1 } return int(x + 0.5) } // Log rotation active f := &lumberjack.Logger{ Filename: Opt.File, MaxSize: round(float64(Opt.MaxSize) / float64(fs.Mebi)), // MiB MaxBackups: Opt.MaxBackups, MaxAge: round(time.Duration(Opt.MaxAge).Hours() / 24), // Days Compress: Opt.Compress, LocalTime: true, // format log file names in localtime } w = f } Handler.setWriter(w) } // --use-json-log implies JSON formatting if ci.UseJSONLog { Opt.Format |= logFormatJSON } // Set slog level to initial log level Handler.SetLevel(fs.LogLevelToSlog(fs.InitialLogLevel())) // Set the format to the configured format Handler.setFormat(Opt.Format) // Syslog output if Opt.UseSyslog { if Opt.File != "" { fs.Fatalf(nil, "Can't use --syslog and --log-file together") } startSysLog(Handler) } // Activate systemd logger support if systemd invocation ID is // detected and output is going to stderr (not logging to a file or syslog) if !Redirected() { if isJournalStream() { Opt.LogSystemdSupport = true } } // Systemd logging output if Opt.LogSystemdSupport { startSystemdLog(Handler) } // Windows event logging if Opt.WindowsEventLogLevel != fs.LogLevelOff { err := startWindowsEventLog(Handler) if err != nil { fs.Fatalf(nil, "Failed to start windows event log: %v", err) } } } // Redirected returns true if the log has been redirected from stdout func Redirected() bool { return Opt.UseSyslog || Opt.File != "" } rclone-v1.71.0/fs/log/logflags/000077500000000000000000000000001505210326400162355ustar00rootroot00000000000000rclone-v1.71.0/fs/log/logflags/logflags.go000066400000000000000000000005341505210326400203640ustar00rootroot00000000000000// Package logflags implements command line flags to set up the log package logflags import ( "github.com/rclone/rclone/fs/config/flags" "github.com/rclone/rclone/fs/log" "github.com/spf13/pflag" ) // AddFlags adds the log flags to the flagSet func AddFlags(flagSet *pflag.FlagSet) { flags.AddFlagsFromOptions(flagSet, "", log.OptionsInfo) } rclone-v1.71.0/fs/log/redirect_stderr.go000066400000000000000000000005411505210326400201520ustar00rootroot00000000000000// Log the panic to the log file - for oses which can't do this //go:build !windows && !darwin && !dragonfly && !freebsd && !linux && !nacl && !netbsd && !openbsd package log import ( "os" "github.com/rclone/rclone/fs" ) // redirectStderr to the file passed in func redirectStderr(f *os.File) { fs.Errorf(nil, "Can't redirect stderr to file") } rclone-v1.71.0/fs/log/redirect_stderr_unix.go000066400000000000000000000011761505210326400212220ustar00rootroot00000000000000// Log the panic under unix to the log file //go:build !windows && !solaris && !plan9 && !js package log import ( "os" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "golang.org/x/sys/unix" ) // redirectStderr to the file passed in func redirectStderr(f *os.File) { passPromptFd, err := unix.Dup(int(os.Stderr.Fd())) if err != nil { fs.Fatalf(nil, "Failed to duplicate stderr: %v", err) } config.PasswordPromptOutput = os.NewFile(uintptr(passPromptFd), "passPrompt") err = unix.Dup2(int(f.Fd()), int(os.Stderr.Fd())) if err != nil { fs.Fatalf(nil, "Failed to redirect stderr to file: %v", err) } } rclone-v1.71.0/fs/log/redirect_stderr_windows.go000066400000000000000000000014631505210326400217300ustar00rootroot00000000000000// Log the panic under windows to the log file // // Code from minix, via // // https://play.golang.org/p/kLtct7lSUg //go:build windows package log import ( "os" "syscall" "github.com/rclone/rclone/fs" ) var ( kernel32 = syscall.MustLoadDLL("kernel32.dll") procSetStdHandle = kernel32.MustFindProc("SetStdHandle") ) func setStdHandle(stdhandle int32, handle syscall.Handle) error { r0, _, e1 := syscall.SyscallN(procSetStdHandle.Addr(), uintptr(stdhandle), uintptr(handle)) if r0 == 0 { if e1 != 0 { return error(e1) } return syscall.EINVAL } return nil } // redirectStderr to the file passed in func redirectStderr(f *os.File) { err := setStdHandle(syscall.STD_ERROR_HANDLE, syscall.Handle(f.Fd())) if err != nil { fs.Fatalf(nil, "Failed to redirect stderr to file: %v", err) } } rclone-v1.71.0/fs/log/slog.go000066400000000000000000000237231505210326400157410ustar00rootroot00000000000000// Interfaces for the slog package package log import ( "bytes" "context" "fmt" "io" "log/slog" "os" "runtime" "strings" "sync" "time" "github.com/rclone/rclone/fs" ) // Handler is the standard handler for the logging. var Handler = defaultHandler() // Create the default OutputHandler // // This logs to stderr with standard go logger format at level INFO. // // This will be adjusted by InitLogging to be the configured levels // but it is important we have a logger running regardless of whether // InitLogging has been called yet or not. func defaultHandler() *OutputHandler { // Default options for default handler opts := &slog.HandlerOptions{ Level: fs.LogLevelToSlog(fs.InitialLogLevel()), } // Create our handler h := NewOutputHandler(os.Stderr, opts, logFormatDate|logFormatTime) // Set the slog default handler slog.SetDefault(slog.New(h)) // Make log.Printf logs at level Notice slog.SetLogLoggerLevel(fs.SlogLevelNotice) return h } // Map slog level names to string var slogNames = map[slog.Level]string{ slog.LevelDebug: "DEBUG", slog.LevelInfo: "INFO", fs.SlogLevelNotice: "NOTICE", slog.LevelWarn: "WARNING", slog.LevelError: "ERROR", fs.SlogLevelCritical: "CRITICAL", fs.SlogLevelAlert: "ALERT", fs.SlogLevelEmergency: "EMERGENCY", } // Convert a slog level to string using rclone's extra levels func slogLevelToString(level slog.Level) string { levelStr := slogNames[level] if levelStr == "" { levelStr = level.String() } return levelStr } // ReplaceAttr function to customize the level key's string value in logs func mapLogLevelNames(groups []string, a slog.Attr) slog.Attr { if a.Key == slog.LevelKey { level, ok := a.Value.Any().(slog.Level) if !ok { return a } levelStr := strings.ToLower(slogLevelToString(level)) a.Value = slog.StringValue(levelStr) } return a } // get the file and line number of the caller skipping skip levels func getCaller(skip int) string { var pc [64]uintptr n := runtime.Callers(skip, pc[:]) if n == 0 { return "" } frames := runtime.CallersFrames(pc[:n]) more := true var frame runtime.Frame for more { frame, more = frames.Next() file := frame.File if strings.Contains(file, "/log/") || strings.HasSuffix(file, "log.go") { continue } line := frame.Line // shorten file name n := 0 for i := len(file) - 1; i > 0; i-- { if file[i] == '/' { n++ if n >= 2 { file = file[i+1:] break } } } return fmt.Sprintf("%s:%d", file, line) } return "" } // OutputHandler is a slog.Handler that writes log records in a format // identical to the standard library's `log` package (e.g., "YYYY/MM/DD HH:MM:SS message"). // // It can also write logs in JSON format identical to logrus. type OutputHandler struct { opts slog.HandlerOptions levelVar slog.LevelVar writer io.Writer mu sync.Mutex output []outputFn // log to writer if empty or the last item outputExtra []outputExtra // log to all these additional places format logFormat jsonBuf bytes.Buffer jsonHandler *slog.JSONHandler } // Records the type and function pointer for extra logging output. type outputExtra struct { json bool output outputFn } // Define the type of the override logger type outputFn func(level slog.Level, text string) // NewOutputHandler creates a new OutputHandler with the specified flags. // // This is designed to use log/slog but produce output which is // backwards compatible with previous rclone versions. // // If opts is nil, default options are used, with Level set to // slog.LevelInfo. func NewOutputHandler(out io.Writer, opts *slog.HandlerOptions, format logFormat) *OutputHandler { h := &OutputHandler{ writer: out, format: format, } if opts != nil { h.opts = *opts } if h.opts.Level == nil { h.opts.Level = slog.LevelInfo } // Set the level var with the configured level h.levelVar.Set(h.opts.Level.Level()) // And use it from now on h.opts.Level = &h.levelVar // Create the JSON logger in case we need it jsonOpts := slog.HandlerOptions{ Level: h.opts.Level, ReplaceAttr: mapLogLevelNames, } h.jsonHandler = slog.NewJSONHandler(&h.jsonBuf, &jsonOpts) return h } // SetOutput sets a new output handler for the log output. // // This is for temporarily overriding the output. func (h *OutputHandler) SetOutput(fn outputFn) { h.mu.Lock() defer h.mu.Unlock() h.output = append(h.output, fn) } // ResetOutput resets the log output to what is was. func (h *OutputHandler) ResetOutput() { h.mu.Lock() defer h.mu.Unlock() if len(h.output) > 0 { h.output = h.output[:len(h.output)-1] } } // AddOutput adds an additional logging destination of the type specified. func (h *OutputHandler) AddOutput(json bool, fn outputFn) { h.mu.Lock() defer h.mu.Unlock() h.outputExtra = append(h.outputExtra, outputExtra{ json: json, output: fn, }) } // SetLevel sets a new log level, returning the old one. func (h *OutputHandler) SetLevel(level slog.Level) slog.Level { h.mu.Lock() defer h.mu.Unlock() oldLevel := h.levelVar.Level() h.levelVar.Set(level) return oldLevel } // Set the writer for the log to that passed. func (h *OutputHandler) setWriter(writer io.Writer) { h.writer = writer } // Set the format flags to that passed in. func (h *OutputHandler) setFormat(format logFormat) { h.format = format } // clear format flags that this output type doesn't want func (h *OutputHandler) clearFormatFlags(bitMask logFormat) { h.format &^= bitMask } // set format flags that this output type requires func (h *OutputHandler) setFormatFlags(bitMask logFormat) { h.format |= bitMask } // Enabled returns whether this logger is enabled for this level. func (h *OutputHandler) Enabled(_ context.Context, level slog.Level) bool { minLevel := slog.LevelInfo if h.opts.Level != nil { minLevel = h.opts.Level.Level() } return level >= minLevel } // Create a log header in Go standard log format. func (h *OutputHandler) formatStdLogHeader(buf *bytes.Buffer, level slog.Level, t time.Time, object string, lineInfo string) { // Add time in Go standard format if requested if h.format&(logFormatDate|logFormatTime|logFormatMicroseconds) != 0 { if h.format&logFormatUTC != 0 { t = t.UTC() } if h.format&logFormatDate != 0 { year, month, day := t.Date() fmt.Fprintf(buf, "%04d/%02d/%02d ", year, month, day) } if h.format&(logFormatTime|logFormatMicroseconds) != 0 { hour, min, sec := t.Clock() fmt.Fprintf(buf, "%02d:%02d:%02d", hour, min, sec) if h.format&logFormatMicroseconds != 0 { fmt.Fprintf(buf, ".%06d", t.Nanosecond()/1e3) } buf.WriteByte(' ') } } // Add source code filename:line if requested if h.format&(logFormatShortFile|logFormatLongFile) != 0 && lineInfo != "" { buf.WriteString(lineInfo) buf.WriteByte(':') buf.WriteByte(' ') } // Add PID if requested if h.format&logFormatPid != 0 { fmt.Fprintf(buf, "[%d] ", os.Getpid()) } // Add log level if required if h.format&logFormatNoLevel == 0 { levelStr := slogLevelToString(level) fmt.Fprintf(buf, "%-6s: ", levelStr) } // Add object if passed if object != "" { buf.WriteString(object) buf.WriteByte(':') buf.WriteByte(' ') } } // Create a log in standard Go log format into buf. func (h *OutputHandler) textLog(ctx context.Context, buf *bytes.Buffer, r slog.Record) error { var lineInfo string if h.format&(logFormatShortFile|logFormatLongFile) != 0 { lineInfo = getCaller(2) } var object string r.Attrs(func(attr slog.Attr) bool { if attr.Key == "object" { object = attr.Value.String() return false } return true }) h.formatStdLogHeader(buf, r.Level, r.Time, object, lineInfo) buf.WriteString(r.Message) if buf.Len() == 0 || buf.Bytes()[buf.Len()-1] != '\n' { // Ensure newline buf.WriteByte('\n') } return nil } // Create a log in JSON format into buf. func (h *OutputHandler) jsonLog(ctx context.Context, buf *bytes.Buffer, r slog.Record) (err error) { // Call the JSON handler to create the JSON in buf r.AddAttrs( slog.String("source", getCaller(2)), ) h.mu.Lock() err = h.jsonHandler.Handle(ctx, r) if err == nil { _, err = h.jsonBuf.WriteTo(buf) } h.mu.Unlock() return err } // Handle outputs a log in the current format func (h *OutputHandler) Handle(ctx context.Context, r slog.Record) (err error) { var ( bufJSON *bytes.Buffer bufText *bytes.Buffer buf *bytes.Buffer ) // Check whether we need to build Text or JSON logs or both needJSON := h.format&logFormatJSON != 0 needText := !needJSON for _, out := range h.outputExtra { if out.json { needJSON = true } else { needText = true } } if needJSON { var bufJSONBack [256]byte bufJSON = bytes.NewBuffer(bufJSONBack[:0]) err = h.jsonLog(ctx, bufJSON, r) if err != nil { return err } } if needText { var bufTextBack [256]byte bufText = bytes.NewBuffer(bufTextBack[:0]) err = h.textLog(ctx, bufText, r) if err != nil { return err } } h.mu.Lock() defer h.mu.Unlock() // Do the log, either to the default destination or to the alternate logging system if h.format&logFormatJSON != 0 { buf = bufJSON } else { buf = bufText } if len(h.output) > 0 { h.output[len(h.output)-1](r.Level, buf.String()) err = nil } else { _, err = h.writer.Write(buf.Bytes()) } // Log to any additional destinations required for _, out := range h.outputExtra { if out.json { out.output(r.Level, bufJSON.String()) } else { out.output(r.Level, bufText.String()) } } return err } // WithAttrs creates a new handler with the same writer, options, and flags. // Attributes are ignored for the output format of this specific handler. func (h *OutputHandler) WithAttrs(attrs []slog.Attr) slog.Handler { return NewOutputHandler(h.writer, &h.opts, h.format) } // WithGroup creates a new handler with the same writer, options, and flags. // Groups are ignored for the output format of this specific handler. func (h *OutputHandler) WithGroup(name string) slog.Handler { return NewOutputHandler(h.writer, &h.opts, h.format) } // Check interface var _ slog.Handler = (*OutputHandler)(nil) rclone-v1.71.0/fs/log/slog_test.go000066400000000000000000000205021505210326400167700ustar00rootroot00000000000000package log import ( "bytes" "context" "fmt" "os" "regexp" "strings" "testing" "time" "log/slog" "github.com/rclone/rclone/fs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var ( utcPlusOne = time.FixedZone("UTC+1", 1*60*60) t0 = time.Date(2020, 1, 2, 3, 4, 5, 123456000, utcPlusOne) ) // Test slogLevelToString covers all mapped levels and an unknown level. func TestSlogLevelToString(t *testing.T) { tests := []struct { level slog.Level want string }{ {slog.LevelDebug, "DEBUG"}, {slog.LevelInfo, "INFO"}, {fs.SlogLevelNotice, "NOTICE"}, {slog.LevelWarn, "WARNING"}, {slog.LevelError, "ERROR"}, {fs.SlogLevelCritical, "CRITICAL"}, {fs.SlogLevelAlert, "ALERT"}, {fs.SlogLevelEmergency, "EMERGENCY"}, // Unknown level should fall back to .String() {slog.Level(1234), slog.Level(1234).String()}, } for _, tc := range tests { got := slogLevelToString(tc.level) assert.Equal(t, tc.want, got) } } // Test mapLogLevelNames replaces only the LevelKey attr and lowercases it. func TestMapLogLevelNames(t *testing.T) { a := slog.Any(slog.LevelKey, slog.LevelWarn) mapped := mapLogLevelNames(nil, a) val, ok := mapped.Value.Any().(string) if !ok || val != "warning" { t.Errorf("mapLogLevelNames did not lowercase level: got %v", mapped.Value.Any()) } // non-level attr should remain unchanged other := slog.String("foo", "bar") out := mapLogLevelNames(nil, other) assert.Equal(t, out.Value, other.Value, "mapLogLevelNames changed a non-level attr") } // Test getCaller returns a file:line string of the correct form. func TestGetCaller(t *testing.T) { out := getCaller(0) assert.NotEqual(t, "", out) match := regexp.MustCompile(`^([^:]+):(\d+)$`).FindStringSubmatch(out) assert.NotNil(t, match) // Can't test this as it skips the /log/ directory! // assert.Equal(t, "slog_test.go", match[1]) } // Test formatStdLogHeader for various flag combinations. func TestFormatStdLogHeader(t *testing.T) { cases := []struct { name string format logFormat lineInfo string object string wantPrefix string }{ {"dateTime", logFormatDate | logFormatTime, "", "", "2020/01/02 03:04:05 "}, {"time", logFormatTime, "", "", "03:04:05 "}, {"date", logFormatDate, "", "", "2020/01/02 "}, {"dateTimeUTC", logFormatDate | logFormatTime | logFormatUTC, "", "", "2020/01/02 02:04:05 "}, {"dateTimeMicro", logFormatDate | logFormatTime | logFormatMicroseconds, "", "", "2020/01/02 03:04:05.123456 "}, {"micro", logFormatMicroseconds, "", "", "03:04:05.123456 "}, {"shortFile", logFormatShortFile, "foo.go:10", "03:04:05 ", "foo.go:10: "}, {"longFile", logFormatLongFile, "foo.go:10", "03:04:05 ", "foo.go:10: "}, {"timePID", logFormatPid, "", "", fmt.Sprintf("[%d] ", os.Getpid())}, {"levelObject", 0, "", "myobj", "INFO : myobj: "}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { h := &OutputHandler{format: tc.format} buf := &bytes.Buffer{} h.formatStdLogHeader(buf, slog.LevelInfo, t0, tc.object, tc.lineInfo) if !strings.HasPrefix(buf.String(), tc.wantPrefix) { t.Errorf("%s: got %q; want prefix %q", tc.name, buf.String(), tc.wantPrefix) } }) } } // Test Enabled honors the HandlerOptions.Level. func TestEnabled(t *testing.T) { h := NewOutputHandler(&bytes.Buffer{}, nil, 0) assert.True(t, h.Enabled(context.Background(), slog.LevelInfo)) assert.False(t, h.Enabled(context.Background(), slog.LevelDebug)) opts := &slog.HandlerOptions{Level: slog.LevelDebug} h2 := NewOutputHandler(&bytes.Buffer{}, opts, 0) assert.True(t, h2.Enabled(context.Background(), slog.LevelDebug)) } // Test clearFormatFlags and setFormatFlags bitwise ops. func TestClearSetFormatFlags(t *testing.T) { h := &OutputHandler{format: logFormatDate | logFormatTime} h.clearFormatFlags(logFormatTime) assert.True(t, h.format&logFormatTime == 0) h.setFormatFlags(logFormatMicroseconds) assert.True(t, h.format&logFormatMicroseconds != 0) } // Test SetOutput and ResetOutput override the default writer. func TestSetResetOutput(t *testing.T) { buf := &bytes.Buffer{} h := NewOutputHandler(buf, nil, 0) var gotOverride string out := func(_ slog.Level, txt string) { gotOverride = txt } h.SetOutput(out) r := slog.NewRecord(t0, slog.LevelInfo, "hello", 0) require.NoError(t, h.Handle(context.Background(), r)) assert.NotEqual(t, "", gotOverride) require.Equal(t, "", buf.String()) h.ResetOutput() require.NoError(t, h.Handle(context.Background(), r)) require.NotEqual(t, "", buf.String()) } // Test AddOutput sends to extra destinations. func TestAddOutput(t *testing.T) { buf := &bytes.Buffer{} h := NewOutputHandler(buf, nil, logFormatDate|logFormatTime) var extraText string out := func(_ slog.Level, txt string) { extraText = txt } h.AddOutput(false, out) r := slog.NewRecord(t0, slog.LevelInfo, "world", 0) require.NoError(t, h.Handle(context.Background(), r)) assert.Equal(t, "2020/01/02 03:04:05 INFO : world\n", buf.String()) assert.Equal(t, "2020/01/02 03:04:05 INFO : world\n", extraText) } // Test AddOutputJSON sends JSON to extra destinations. func TestAddOutputJSON(t *testing.T) { buf := &bytes.Buffer{} h := NewOutputHandler(buf, nil, logFormatDate|logFormatTime) var extraText string out := func(_ slog.Level, txt string) { extraText = txt } h.AddOutput(true, out) r := slog.NewRecord(t0, slog.LevelInfo, "world", 0) require.NoError(t, h.Handle(context.Background(), r)) assert.NotEqual(t, "", extraText) assert.Equal(t, "2020/01/02 03:04:05 INFO : world\n", buf.String()) assert.True(t, strings.HasPrefix(extraText, `{"time":"2020-01-02T03:04:05.123456+01:00","level":"info","msg":"world","source":"`)) assert.True(t, strings.HasSuffix(extraText, "\"}\n")) } // Test AddOutputUseJSONLog sends text to extra destinations. func TestAddOutputUseJSONLog(t *testing.T) { buf := &bytes.Buffer{} h := NewOutputHandler(buf, nil, logFormatDate|logFormatTime|logFormatJSON) var extraText string out := func(_ slog.Level, txt string) { extraText = txt } h.AddOutput(false, out) r := slog.NewRecord(t0, slog.LevelInfo, "world", 0) require.NoError(t, h.Handle(context.Background(), r)) assert.NotEqual(t, "", extraText) assert.True(t, strings.HasPrefix(buf.String(), `{"time":"2020-01-02T03:04:05.123456+01:00","level":"info","msg":"world","source":"`)) assert.True(t, strings.HasSuffix(buf.String(), "\"}\n")) assert.Equal(t, "2020/01/02 03:04:05 INFO : world\n", extraText) } // Test WithAttrs and WithGroup return new handlers with same settings. func TestWithAttrsAndGroup(t *testing.T) { buf := &bytes.Buffer{} h := NewOutputHandler(buf, nil, logFormatDate) h2 := h.WithAttrs([]slog.Attr{slog.String("k", "v")}) if _, ok := h2.(*OutputHandler); !ok { t.Error("WithAttrs returned wrong type") } h3 := h.WithGroup("grp") if _, ok := h3.(*OutputHandler); !ok { t.Error("WithGroup returned wrong type") } } // Test textLog and jsonLog directly for basic correctness. func TestTextLogAndJsonLog(t *testing.T) { h := NewOutputHandler(&bytes.Buffer{}, nil, logFormatDate|logFormatTime) r := slog.NewRecord(t0, slog.LevelWarn, "msg!", 0) r.AddAttrs(slog.String("object", "obj")) // textLog bufText := &bytes.Buffer{} require.NoError(t, h.textLog(context.Background(), bufText, r)) out := bufText.String() if !strings.Contains(out, "WARNING") || !strings.Contains(out, "obj:") || !strings.HasSuffix(out, "\n") { t.Errorf("textLog output = %q", out) } // jsonLog bufJSON := &bytes.Buffer{} require.NoError(t, h.jsonLog(context.Background(), bufJSON, r)) j := bufJSON.String() if !strings.Contains(j, `"level":"warning"`) || !strings.Contains(j, `"msg":"msg!"`) { t.Errorf("jsonLog output = %q", j) } } // Table-driven test for JSON vs text Handle behavior. func TestHandleFormatFlags(t *testing.T) { r := slog.NewRecord(t0, slog.LevelInfo, "hi", 0) cases := []struct { name string format logFormat wantJSON bool }{ {"textMode", 0, false}, {"jsonMode", logFormatJSON, true}, } for _, tc := range cases { buf := &bytes.Buffer{} h := NewOutputHandler(buf, nil, tc.format) require.NoError(t, h.Handle(context.Background(), r)) out := buf.String() if tc.wantJSON { if !strings.HasPrefix(out, "{") || !strings.Contains(out, `"level":"info"`) { t.Errorf("%s: got %q; want JSON", tc.name, out) } } else { if !strings.Contains(out, "INFO") { t.Errorf("%s: got %q; want text INFO", tc.name, out) } } } } rclone-v1.71.0/fs/log/syslog.go000066400000000000000000000005371505210326400163130ustar00rootroot00000000000000// Syslog interface for non-Unix variants only //go:build windows || nacl || plan9 package log import ( "runtime" "github.com/rclone/rclone/fs" ) // Starts syslog if configured, returns true if it was started func startSysLog(handler *OutputHandler) bool { fs.Fatalf(nil, "--syslog not supported on %s platform", runtime.GOOS) return false } rclone-v1.71.0/fs/log/syslog_unix.go000066400000000000000000000036051505210326400173550ustar00rootroot00000000000000// Syslog interface for Unix variants only //go:build !windows && !nacl && !plan9 package log import ( "log/slog" "log/syslog" "os" "path" "github.com/rclone/rclone/fs" ) var ( syslogFacilityMap = map[string]syslog.Priority{ "KERN": syslog.LOG_KERN, "USER": syslog.LOG_USER, "MAIL": syslog.LOG_MAIL, "DAEMON": syslog.LOG_DAEMON, "AUTH": syslog.LOG_AUTH, "SYSLOG": syslog.LOG_SYSLOG, "LPR": syslog.LOG_LPR, "NEWS": syslog.LOG_NEWS, "UUCP": syslog.LOG_UUCP, "CRON": syslog.LOG_CRON, "AUTHPRIV": syslog.LOG_AUTHPRIV, "FTP": syslog.LOG_FTP, "LOCAL0": syslog.LOG_LOCAL0, "LOCAL1": syslog.LOG_LOCAL1, "LOCAL2": syslog.LOG_LOCAL2, "LOCAL3": syslog.LOG_LOCAL3, "LOCAL4": syslog.LOG_LOCAL4, "LOCAL5": syslog.LOG_LOCAL5, "LOCAL6": syslog.LOG_LOCAL6, "LOCAL7": syslog.LOG_LOCAL7, } ) // Starts syslog func startSysLog(handler *OutputHandler) bool { facility, ok := syslogFacilityMap[Opt.SyslogFacility] if !ok { fs.Fatalf(nil, "Unknown syslog facility %q - man syslog for list", Opt.SyslogFacility) } Me := path.Base(os.Args[0]) w, err := syslog.New(syslog.LOG_NOTICE|facility, Me) if err != nil { fs.Fatalf(nil, "Failed to start syslog: %v", err) } handler.clearFormatFlags(logFormatDate | logFormatTime | logFormatMicroseconds | logFormatUTC | logFormatLongFile | logFormatShortFile | logFormatPid) handler.setFormatFlags(logFormatNoLevel) handler.SetOutput(func(level slog.Level, text string) { switch level { case fs.SlogLevelEmergency: _ = w.Emerg(text) case fs.SlogLevelAlert: _ = w.Alert(text) case fs.SlogLevelCritical: _ = w.Crit(text) case slog.LevelError: _ = w.Err(text) case slog.LevelWarn: _ = w.Warning(text) case fs.SlogLevelNotice: _ = w.Notice(text) case slog.LevelInfo: _ = w.Info(text) case slog.LevelDebug: _ = w.Debug(text) } }) return true } rclone-v1.71.0/fs/log/systemd.go000066400000000000000000000006001505210326400164520ustar00rootroot00000000000000// Systemd interface for non-Unix variants only //go:build !unix package log import ( "runtime" "github.com/rclone/rclone/fs" ) // Enables systemd logs if configured or if auto-detected func startSystemdLog(handler *OutputHandler) bool { fs.Fatalf(nil, "--log-systemd not supported on %s platform", runtime.GOOS) return false } func isJournalStream() bool { return false } rclone-v1.71.0/fs/log/systemd_unix.go000066400000000000000000000024701505210326400175240ustar00rootroot00000000000000// Systemd interface for Unix variants only //go:build unix package log import ( "log/slog" "github.com/coreos/go-systemd/v22/journal" "github.com/rclone/rclone/fs" ) // Enables systemd logs if configured or if auto-detected func startSystemdLog(handler *OutputHandler) bool { handler.clearFormatFlags(logFormatDate | logFormatTime | logFormatMicroseconds | logFormatUTC | logFormatLongFile | logFormatShortFile | logFormatPid) handler.setFormatFlags(logFormatNoLevel) handler.SetOutput(func(level slog.Level, text string) { _ = journal.Print(slogLevelToSystemdPriority(level), "%-6s: %s\n", level, text) }) return true } var slogLevelToSystemdPrefix = map[slog.Level]journal.Priority{ fs.SlogLevelEmergency: journal.PriEmerg, fs.SlogLevelAlert: journal.PriAlert, fs.SlogLevelCritical: journal.PriCrit, slog.LevelError: journal.PriErr, slog.LevelWarn: journal.PriWarning, fs.SlogLevelNotice: journal.PriNotice, slog.LevelInfo: journal.PriInfo, slog.LevelDebug: journal.PriDebug, } func slogLevelToSystemdPriority(l slog.Level) journal.Priority { prio, ok := slogLevelToSystemdPrefix[l] if !ok { return journal.PriInfo } return prio } func isJournalStream() bool { if usingJournald, _ := journal.StderrIsJournalStream(); usingJournald { return true } return false } rclone-v1.71.0/fs/log_test.go000066400000000000000000000037351505210326400160350ustar00rootroot00000000000000package fs import ( "encoding/json" "fmt" "strconv" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Check it satisfies the interfaces var ( _ Flagger = (*LogLevel)(nil) _ FlaggerNP = LogLevel(0) _ fmt.Stringer = LogValueItem{} ) type withString struct{} func (withString) String() string { return "hello" } func TestLogValue(t *testing.T) { x := LogValue("x", 1) assert.Equal(t, "1", x.String()) x = LogValue("x", withString{}) assert.Equal(t, "hello", x.String()) x = LogValueHide("x", withString{}) assert.Equal(t, "", x.String()) } func TestLogLevelString(t *testing.T) { for _, test := range []struct { in LogLevel want string }{ {LogLevelEmergency, "EMERGENCY"}, {LogLevelDebug, "DEBUG"}, {99, "Unknown(99)"}, } { logLevel := test.in got := logLevel.String() assert.Equal(t, test.want, got, test.in) } } func TestLogLevelSet(t *testing.T) { for _, test := range []struct { in string want LogLevel err bool }{ {"EMERGENCY", LogLevelEmergency, false}, {"DEBUG", LogLevelDebug, false}, {"Potato", 100, true}, } { logLevel := LogLevel(100) err := logLevel.Set(test.in) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, logLevel, test.in) } } func TestLogLevelUnmarshalJSON(t *testing.T) { for _, test := range []struct { in string want LogLevel err bool }{ {`"EMERGENCY"`, LogLevelEmergency, false}, {`"DEBUG"`, LogLevelDebug, false}, {`"Potato"`, 100, true}, {strconv.Itoa(int(LogLevelEmergency)), LogLevelEmergency, false}, {strconv.Itoa(int(LogLevelDebug)), LogLevelDebug, false}, {"Potato", 100, true}, {`99`, 100, true}, {`-99`, 100, true}, } { logLevel := LogLevel(100) err := json.Unmarshal([]byte(test.in), &logLevel) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, logLevel, test.in) } } rclone-v1.71.0/fs/logger/000077500000000000000000000000001505210326400151355ustar00rootroot00000000000000rclone-v1.71.0/fs/logger/logger.go000066400000000000000000000010051505210326400167370ustar00rootroot00000000000000// Package logger implements testing for the sync (and bisync) logger package logger import ( _ "github.com/rclone/rclone/backend/all" // import all backends "github.com/rclone/rclone/cmd" _ "github.com/rclone/rclone/cmd/all" // import all commands _ "github.com/rclone/rclone/lib/plugin" // import plugins ) // Main enables the testscript package. See: // https://bitfieldconsulting.com/golang/cli-testing // https://pkg.go.dev/github.com/rogpeppe/go-internal@v1.11.0/testscript func Main() { cmd.Main() } rclone-v1.71.0/fs/logger/logger_test.go000066400000000000000000000014601505210326400200030ustar00rootroot00000000000000//go:build !plan9 // +build !plan9 package logger_test import ( "path/filepath" "testing" "github.com/rclone/rclone/fs/logger" "github.com/rogpeppe/go-internal/testscript" ) // TestMain drives the tests func TestMain(m *testing.M) { // This enables the testscript package. See: // https://bitfieldconsulting.com/golang/cli-testing // https://pkg.go.dev/github.com/rogpeppe/go-internal@v1.11.0/testscript testscript.Main(m, map[string]func(){ "rclone": logger.Main, }) } func TestLogger(t *testing.T) { // Usage: https://bitfieldconsulting.com/golang/cli-testing testscript.Run(t, testscript.Params{ Dir: "testdata/script", Setup: func(env *testscript.Env) error { env.Setenv("SRC", filepath.Join("$WORK", "src")) env.Setenv("DST", filepath.Join("$WORK", "dst")) return nil }, }) } rclone-v1.71.0/fs/logger/testdata/000077500000000000000000000000001505210326400167465ustar00rootroot00000000000000rclone-v1.71.0/fs/logger/testdata/script/000077500000000000000000000000001505210326400202525ustar00rootroot00000000000000rclone-v1.71.0/fs/logger/testdata/script/TestBeforeVsAfter.txtar000066400000000000000000000040651505210326400247000ustar00rootroot00000000000000# tests whether an md5sum file generated post-sync matches our pre-sync prediction # Filling src and dst with two different versions of rclone source!: exec rclone copyurl https://github.com/rclone/rclone/archive/refs/tags/v1.49.1.zip $SRC/src.zip exec rclone copyurl https://github.com/rclone/rclone/archive/refs/tags/v1.54.1.zip $DST/dst.zip exec unzip $SRC/src.zip -d $SRC exec unzip $DST/dst.zip -d $DST # generating sumfiles: exec rclone md5sum $SRC --output-file $WORK/src-before.txt exec rclone md5sum $DST --output-file $WORK/dst-before.txt # running sync with output files: exec rclone sync $SRC $DST --match $WORK/SYNCmatch.txt --combined $WORK/SYNCcombined.txt --missing-on-src $WORK/SYNCmissingonsrc.txt --missing-on-dst $WORK/SYNCmissingondst.txt --error $WORK/SYNCerr.txt --differ $WORK/SYNCdiffer.txt --dest-after $WORK/SYNCdestafter.txt --format 'hp' --separator ' ' # generating sumfiles: exec rclone md5sum $SRC --output-file $WORK/src-after.txt exec rclone md5sum $DST --output-file $WORK/dst-after.txt # sorting them by line and diffing: exec sort $WORK/src-before.txt -o $WORK/src-before.txt exec sort $WORK/dst-before.txt -o $WORK/dst-before.txt exec sort $WORK/src-after.txt -o $WORK/src-after.txt exec sort $WORK/dst-after.txt -o $WORK/dst-after.txt exec sort $WORK/SYNCmatch.txt -o $WORK/SYNCmatch.txt exec sort $WORK/SYNCcombined.txt -o $WORK/SYNCcombined.txt exec sort $WORK/SYNCmissingonsrc.txt -o $WORK/SYNCmissingonsrc.txt exec sort $WORK/SYNCmissingondst.txt -o $WORK/SYNCmissingondst.txt exec sort $WORK/SYNCerr.txt -o $WORK/SYNCerr.txt exec sort $WORK/SYNCdiffer.txt -o $WORK/SYNCdiffer.txt exec sort $WORK/SYNCdestafter.txt -o $WORK/SYNCdestafter.txt # diff src before vs src after: cmp $WORK/src-before.txt $WORK/src-after.txt # diff dst before vs dst after: ! cmp $WORK/dst-before.txt $WORK/dst-after.txt # diff src before vs dst after: cmp $WORK/src-before.txt $WORK/dst-after.txt # diff dst before vs src after: ! cmp $WORK/dst-before.txt $WORK/src-after.txt # diff md5sum dst after vs sync dest-after: cmp $WORK/dst-after.txt $WORK/SYNCdestafter.txtrclone-v1.71.0/fs/logger/testdata/script/TestCheckVsSync.txtar000066400000000000000000000044021505210326400243610ustar00rootroot00000000000000# tests whether rclone check and rclone sync output exactly the same file lists. # Filling src and dst with makefiles: exec rclone test makefiles $SRC --seed 1 exec rclone test makefiles $DST --seed 2 exec rclone test makefiles $SRC --seed 3 exec rclone test makefiles $DST --seed 3 # running rclone check for baseline test: # error is expected here: ! exec rclone check $SRC $DST --match $WORK/CHECKmatch.txt --combined $WORK/CHECKcombined.txt --missing-on-src $WORK/CHECKmissingonsrc.txt --missing-on-dst $WORK/CHECKmissingondst.txt --error $WORK/CHECKerr.txt --differ $WORK/CHECKdiffer.txt -q # running sync with output files: exec rclone sync $SRC $DST --match $WORK/SYNCmatch.txt --combined $WORK/SYNCcombined.txt --missing-on-src $WORK/SYNCmissingonsrc.txt --missing-on-dst $WORK/SYNCmissingondst.txt --error $WORK/SYNCerr.txt --differ $WORK/SYNCdiffer.txt # sorting them by line and diffing: exec sort $WORK/CHECKmatch.txt -o $WORK/CHECKmatch.txt exec sort $WORK/CHECKcombined.txt -o $WORK/CHECKcombined.txt exec sort $WORK/CHECKmissingonsrc.txt -o $WORK/CHECKmissingonsrc.txt exec sort $WORK/CHECKmissingondst.txt -o $WORK/CHECKmissingondst.txt exec sort $WORK/CHECKerr.txt -o $WORK/CHECKerr.txt exec sort $WORK/CHECKdiffer.txt -o $WORK/CHECKdiffer.txt exec sort $WORK/SYNCmatch.txt -o $WORK/SYNCmatch.txt exec sort $WORK/SYNCcombined.txt -o $WORK/SYNCcombined.txt exec sort $WORK/SYNCmissingonsrc.txt -o $WORK/SYNCmissingonsrc.txt exec sort $WORK/SYNCmissingondst.txt -o $WORK/SYNCmissingondst.txt exec sort $WORK/SYNCerr.txt -o $WORK/SYNCerr.txt exec sort $WORK/SYNCdiffer.txt -o $WORK/SYNCdiffer.txt # diff match check vs. sync: cmp $WORK/CHECKmatch.txt $WORK/SYNCmatch.txt # diff combined check vs. sync: cmp $WORK/CHECKcombined.txt $WORK/SYNCcombined.txt # diff missingonsrc check vs. sync: cmp $WORK/CHECKmissingonsrc.txt $WORK/SYNCmissingonsrc.txt # diff missingondst check vs. sync: cmp $WORK/CHECKmissingondst.txt $WORK/SYNCmissingondst.txt # diff error check vs. sync: cmp $WORK/CHECKerr.txt $WORK/SYNCerr.txt # diff differ check vs. sync: cmp $WORK/CHECKdiffer.txt $WORK/SYNCdiffer.txt # verify accuracy exec rclone check $SRC $DST exec diff -rya --suppress-common-lines $SRC $DST [!windows] exec rsync -aEvhPu $SRC/ $WORK/rsyncDst [!windows] exec rclone check $DST $WORK/rsyncDstrclone-v1.71.0/fs/logger/testdata/script/TestRepoCompare.txtar000066400000000000000000000050701505210326400244140ustar00rootroot00000000000000# tests whether rclone check and rclone sync output exactly the same file lists. # uses two different old versions of rclone source code for the src and dst # to produce a more realistic test than makefiles # (has lots of files with same name but different content) # Filling src and dst with two different versions of rclone source!: exec rclone copyurl https://github.com/rclone/rclone/archive/refs/tags/v1.49.1.zip $SRC/src.zip exec rclone copyurl https://github.com/rclone/rclone/archive/refs/tags/v1.54.1.zip $DST/dst.zip exec unzip $SRC/src.zip -d $SRC exec unzip $DST/dst.zip -d $DST # running rclone check for baseline test: # error is expected here: ! exec rclone check $SRC $DST --match $WORK/CHECKmatch.txt --combined $WORK/CHECKcombined.txt --missing-on-src $WORK/CHECKmissingonsrc.txt --missing-on-dst $WORK/CHECKmissingondst.txt --error $WORK/CHECKerr.txt --differ $WORK/CHECKdiffer.txt -q # running sync with output files: exec rclone sync $SRC $DST --match $WORK/SYNCmatch.txt --combined $WORK/SYNCcombined.txt --missing-on-src $WORK/SYNCmissingonsrc.txt --missing-on-dst $WORK/SYNCmissingondst.txt --error $WORK/SYNCerr.txt --differ $WORK/SYNCdiffer.txt # sorting them by line and diffing: exec sort $WORK/CHECKmatch.txt -o $WORK/CHECKmatch.txt exec sort $WORK/CHECKcombined.txt -o $WORK/CHECKcombined.txt exec sort $WORK/CHECKmissingonsrc.txt -o $WORK/CHECKmissingonsrc.txt exec sort $WORK/CHECKmissingondst.txt -o $WORK/CHECKmissingondst.txt exec sort $WORK/CHECKerr.txt -o $WORK/CHECKerr.txt exec sort $WORK/CHECKdiffer.txt -o $WORK/CHECKdiffer.txt exec sort $WORK/SYNCmatch.txt -o $WORK/SYNCmatch.txt exec sort $WORK/SYNCcombined.txt -o $WORK/SYNCcombined.txt exec sort $WORK/SYNCmissingonsrc.txt -o $WORK/SYNCmissingonsrc.txt exec sort $WORK/SYNCmissingondst.txt -o $WORK/SYNCmissingondst.txt exec sort $WORK/SYNCerr.txt -o $WORK/SYNCerr.txt exec sort $WORK/SYNCdiffer.txt -o $WORK/SYNCdiffer.txt # diff match check vs. sync: cmp $WORK/CHECKmatch.txt $WORK/SYNCmatch.txt # diff combined check vs. sync: cmp $WORK/CHECKcombined.txt $WORK/SYNCcombined.txt # diff missingonsrc check vs. sync: cmp $WORK/CHECKmissingonsrc.txt $WORK/SYNCmissingonsrc.txt # diff missingondst check vs. sync: cmp $WORK/CHECKmissingondst.txt $WORK/SYNCmissingondst.txt # diff error check vs. sync: cmp $WORK/CHECKerr.txt $WORK/SYNCerr.txt # diff differ check vs. sync: cmp $WORK/CHECKdiffer.txt $WORK/SYNCdiffer.txt # verify accuracy exec rclone check $SRC $DST exec diff -rya --suppress-common-lines $SRC $DST [!windows] exec rsync -aEvhPu $SRC/ $WORK/rsyncDst [!windows] exec rclone check $DST $WORK/rsyncDstrclone-v1.71.0/fs/march/000077500000000000000000000000001505210326400147505ustar00rootroot00000000000000rclone-v1.71.0/fs/march/march.go000066400000000000000000000365311505210326400164010ustar00rootroot00000000000000// Package march traverses two directories in lock step package march import ( "cmp" "context" "fmt" "path" "slices" "strings" "sync" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/dirtree" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/fs/walk" "github.com/rclone/rclone/lib/transform" "golang.org/x/text/unicode/norm" ) // matchTransformFn converts a name into a form which is used for // comparison in matchListings. type matchTransformFn func(name string) string // list a directory into callback returning err type listDirFn func(dir string, callback fs.ListRCallback) (err error) // March holds the data used to traverse two Fs simultaneously, // calling Callback for each match type March struct { // parameters Ctx context.Context // context for background goroutines Fdst fs.Fs // source Fs Fsrc fs.Fs // dest Fs Dir string // directory NoTraverse bool // don't traverse the destination SrcIncludeAll bool // don't include all files in the src DstIncludeAll bool // don't include all files in the destination Callback Marcher // object to call with results NoCheckDest bool // transfer all objects regardless without checking dst NoUnicodeNormalization bool // don't normalize unicode characters in filenames // internal state srcListDir listDirFn // function to call to list a directory in the src dstListDir listDirFn // function to call to list a directory in the dst transforms []matchTransformFn } // Marcher is called on each match type Marcher interface { // SrcOnly is called for a DirEntry found only in the source SrcOnly(src fs.DirEntry) (recurse bool) // DstOnly is called for a DirEntry found only in the destination DstOnly(dst fs.DirEntry) (recurse bool) // Match is called for a DirEntry found both in the source and destination Match(ctx context.Context, dst, src fs.DirEntry) (recurse bool) } // init sets up a march over opt.Fsrc, and opt.Fdst calling back callback for each match // Note: this will flag filter-aware backends on the source side func (m *March) init(ctx context.Context) { ci := fs.GetConfig(ctx) m.srcListDir = m.makeListDir(ctx, m.Fsrc, m.SrcIncludeAll, m.srcKey) if !m.NoTraverse { m.dstListDir = m.makeListDir(ctx, m.Fdst, m.DstIncludeAll, m.dstKey) } // Now create the matching transform // ..normalise the UTF8 first if !m.NoUnicodeNormalization { m.transforms = append(m.transforms, norm.NFC.String) } // ..if destination is caseInsensitive then make it lower case // case Insensitive | src | dst | lower case compare | // | No | No | No | // | Yes | No | No | // | No | Yes | Yes | // | Yes | Yes | Yes | if m.Fdst.Features().CaseInsensitive || ci.IgnoreCaseSync { m.transforms = append(m.transforms, strings.ToLower) } } // srcOrDstKey turns a directory entry into a sort key using the defined transforms. func (m *March) srcOrDstKey(entry fs.DirEntry, isSrc bool) string { if entry == nil { return "" } name := path.Base(entry.Remote()) _, isDirectory := entry.(fs.Directory) if isSrc { name = transform.Path(m.Ctx, name, isDirectory) } for _, transform := range m.transforms { name = transform(name) } // Suffix entries to make identically named files and // directories sort consistently with directories first. if isDirectory { name += "D" } else { name += "F" } return name } // srcKey turns a directory entry into a sort key using the defined transforms. func (m *March) srcKey(entry fs.DirEntry) string { return m.srcOrDstKey(entry, true) } // dstKey turns a directory entry into a sort key using the defined transforms. func (m *March) dstKey(entry fs.DirEntry) string { return m.srcOrDstKey(entry, false) } // makeListDir makes constructs a listing function for the given fs // and includeAll flags for marching through the file system. // Note: this will optionally flag filter-aware backends! func (m *March) makeListDir(ctx context.Context, f fs.Fs, includeAll bool, keyFn list.KeyFn) listDirFn { ci := fs.GetConfig(ctx) fi := filter.GetConfig(ctx) if !(ci.UseListR && f.Features().ListR != nil) && // !--fast-list active and !(ci.NoTraverse && fi.HaveFilesFrom()) { // !(--files-from and --no-traverse) return func(dir string, callback fs.ListRCallback) (err error) { dirCtx := filter.SetUseFilter(m.Ctx, f.Features().FilterAware && !includeAll) // make filter-aware backends constrain List return list.DirSortedFn(dirCtx, f, includeAll, dir, callback, keyFn) } } // This returns a closure for use when --fast-list is active or for when // --files-from and --no-traverse is set var ( mu sync.Mutex started bool dirs dirtree.DirTree dirsErr error ) return func(dir string, callback fs.ListRCallback) (err error) { mu.Lock() defer mu.Unlock() if !started { dirCtx := filter.SetUseFilter(m.Ctx, f.Features().FilterAware && !includeAll) // make filter-aware backends constrain List dirs, dirsErr = walk.NewDirTree(dirCtx, f, m.Dir, includeAll, ci.MaxDepth) started = true } if dirsErr != nil { return dirsErr } entries, ok := dirs[dir] if !ok { return fs.ErrorDirNotFound } delete(dirs, dir) // We use a stable sort here just in case there are // duplicates. Assuming the remote delivers the entries in a // consistent order, this will give the best user experience // in syncing as it will use the first entry for the sync // comparison. slices.SortStableFunc(entries, func(a, b fs.DirEntry) int { return cmp.Compare(keyFn(a), keyFn(b)) }) return callback(entries) } } // listDirJob describe a directory listing that needs to be done type listDirJob struct { srcRemote string dstRemote string srcDepth int dstDepth int noSrc bool noDst bool } // Run starts the matching process off func (m *March) Run(ctx context.Context) error { ci := fs.GetConfig(ctx) fi := filter.GetConfig(ctx) m.init(ctx) srcDepth := ci.MaxDepth if srcDepth < 0 { srcDepth = fs.MaxLevel } dstDepth := srcDepth if fi.Opt.DeleteExcluded { dstDepth = fs.MaxLevel } var mu sync.Mutex // Protects vars below var jobError error var errCount int // Start some directory listing go routines var wg sync.WaitGroup // sync closing of go routines var traversing sync.WaitGroup // running directory traversals checkers := ci.Checkers in := make(chan listDirJob, checkers) for range checkers { wg.Add(1) go func() { defer wg.Done() for { select { case <-m.Ctx.Done(): return case job, ok := <-in: if !ok { return } jobs, err := m.processJob(job) if err != nil { mu.Lock() // Keep reference only to the first encountered error if jobError == nil { jobError = err } errCount++ mu.Unlock() } if len(jobs) > 0 { traversing.Add(len(jobs)) go func() { // Now we have traversed this directory, send these // jobs off for traversal in the background for _, newJob := range jobs { select { case <-m.Ctx.Done(): // discard job if finishing traversing.Done() case in <- newJob: } } }() } traversing.Done() } } }() } // Start the process traversing.Add(1) in <- listDirJob{ srcRemote: m.Dir, srcDepth: srcDepth - 1, dstRemote: m.Dir, dstDepth: dstDepth - 1, noDst: m.NoCheckDest, } go func() { // when the context is cancelled discard the remaining jobs <-m.Ctx.Done() for range in { traversing.Done() } }() traversing.Wait() close(in) wg.Wait() if errCount > 1 { return fmt.Errorf("march failed with %d error(s): first error: %w", errCount, jobError) } return jobError } // Check to see if the context has been cancelled func (m *March) aborting() bool { select { case <-m.Ctx.Done(): return true default: } return false } // Process the two listings, matching up the items in the two slices // using the transform function on each name first. // // Into srcOnly go Entries which only exist in the srcList // Into dstOnly go Entries which only exist in the dstList // Into match go matchPair's of src and dst which have the same name // // This checks for duplicates and checks the list is sorted. func (m *March) matchListings(srcChan, dstChan <-chan fs.DirEntry, srcOnly, dstOnly func(fs.DirEntry), match func(dst, src fs.DirEntry)) error { var ( srcPrev, dstPrev fs.DirEntry srcPrevName, dstPrevName string src, dst fs.DirEntry srcHasMore, dstHasMore = true, true srcName, dstName string ) srcDone := func() { srcPrevName = srcName srcPrev = src src = nil srcName = "" } dstDone := func() { dstPrevName = dstName dstPrev = dst dst = nil dstName = "" } for { if m.aborting() { return m.Ctx.Err() } // Reload src and dst if needed - we set them to nil if used if src == nil { src, srcHasMore = <-srcChan srcName = m.srcKey(src) } if dst == nil { dst, dstHasMore = <-dstChan dstName = m.dstKey(dst) } if !srcHasMore && !dstHasMore { break } if src != nil && srcPrev != nil { if srcName == srcPrevName && fs.DirEntryType(srcPrev) == fs.DirEntryType(src) { fs.Logf(src, "Duplicate %s found in source - ignoring", fs.DirEntryType(src)) srcDone() // skip the src and retry the dst continue } else if srcName < srcPrevName { // this should never happen since we sort the listings panic("Out of order listing in source") } } if dst != nil && dstPrev != nil { if dstName == dstPrevName && fs.DirEntryType(dst) == fs.DirEntryType(dstPrev) { fs.Logf(dst, "Duplicate %s found in destination - ignoring", fs.DirEntryType(dst)) dstDone() // skip the dst and retry the src continue } else if dstName < dstPrevName { // this should never happen since we sort the listings panic("Out of order listing in destination") } } switch { case src != nil && dst != nil: // we can't use CompareDirEntries because srcName, dstName could // be different from src.Remote() or dst.Remote() srcType := fs.DirEntryType(src) dstType := fs.DirEntryType(dst) if srcName > dstName || (srcName == dstName && srcType > dstType) { dstOnly(dst) dstDone() } else if srcName < dstName || (srcName == dstName && srcType < dstType) { srcOnly(src) srcDone() } else { match(dst, src) dstDone() srcDone() } case src == nil: dstOnly(dst) dstDone() case dst == nil: srcOnly(src) srcDone() } } return nil } // processJob processes a listDirJob listing the source and // destination directories, comparing them and returning a slice of // more jobs // // returns errors using processError func (m *March) processJob(job listDirJob) ([]listDirJob, error) { var ( jobs []listDirJob srcChan = make(chan fs.DirEntry, 100) dstChan = make(chan fs.DirEntry, 100) srcListErr, dstListErr error wg sync.WaitGroup ci = fs.GetConfig(m.Ctx) ) // List the src and dst directories if !job.noSrc { srcChan := srcChan // duplicate this as we may override it later wg.Add(1) go func() { defer wg.Done() srcListErr = m.srcListDir(job.srcRemote, func(entries fs.DirEntries) error { for _, entry := range entries { srcChan <- entry } return nil }) close(srcChan) }() } else { close(srcChan) } startedDst := false if !m.NoTraverse && !job.noDst { startedDst = true wg.Add(1) go func() { defer wg.Done() dstListErr = m.dstListDir(job.dstRemote, func(entries fs.DirEntries) error { for _, entry := range entries { dstChan <- entry } return nil }) close(dstChan) }() } // If NoTraverse is set, then try to find a matching object // for each item in the srcList to head dst object if m.NoTraverse && !m.NoCheckDest { startedDst = true workers := ci.Checkers originalSrcChan := srcChan srcChan = make(chan fs.DirEntry, 100) type matchTask struct { src fs.DirEntry // src object to find in destination dstMatch chan<- fs.DirEntry // channel to receive matching dst object or nil } matchTasks := make(chan matchTask, workers) dstMatches := make(chan (<-chan fs.DirEntry), workers) // Create the tasks from the originalSrcChan. These are put into matchTasks for // processing and dstMatches so they can be retrieved in order. go func() { for src := range originalSrcChan { srcChan <- src dstMatch := make(chan fs.DirEntry, 1) matchTasks <- matchTask{ src: src, dstMatch: dstMatch, } dstMatches <- dstMatch } close(matchTasks) }() // Get the tasks from the queue and find a matching object. var workerWg sync.WaitGroup for range workers { workerWg.Add(1) go func() { defer workerWg.Done() for t := range matchTasks { leaf := path.Base(t.src.Remote()) dst, err := m.Fdst.NewObject(m.Ctx, path.Join(job.dstRemote, leaf)) if err != nil { dst = nil } t.dstMatch <- dst } }() } // Close dstResults when all the workers have finished go func() { workerWg.Wait() close(dstMatches) }() // Read the matches in order and send them to dstChan if found. wg.Add(1) go func() { defer wg.Done() for dstMatch := range dstMatches { dst := <-dstMatch // Note that dst may be nil here // We send these on so we don't deadlock the reader dstChan <- dst } close(srcChan) close(dstChan) }() } if !startedDst { close(dstChan) } // Work out what to do and do it err := m.matchListings(srcChan, dstChan, func(src fs.DirEntry) { recurse := m.Callback.SrcOnly(src) if recurse && job.srcDepth > 0 { jobs = append(jobs, listDirJob{ srcRemote: src.Remote(), dstRemote: src.Remote(), srcDepth: job.srcDepth - 1, noDst: true, }) } }, func(dst fs.DirEntry) { recurse := m.Callback.DstOnly(dst) if recurse && job.dstDepth > 0 { jobs = append(jobs, listDirJob{ srcRemote: dst.Remote(), dstRemote: dst.Remote(), dstDepth: job.dstDepth - 1, noSrc: true, }) } }, func(dst, src fs.DirEntry) { recurse := m.Callback.Match(m.Ctx, dst, src) if recurse && job.srcDepth > 0 && job.dstDepth > 0 { jobs = append(jobs, listDirJob{ srcRemote: src.Remote(), dstRemote: dst.Remote(), srcDepth: job.srcDepth - 1, dstDepth: job.dstDepth - 1, }) } }) if err != nil { return nil, err } // Wait for listings to complete and report errors wg.Wait() if srcListErr != nil { if job.srcRemote != "" { fs.Errorf(job.srcRemote, "error reading source directory: %v", srcListErr) } else { fs.Errorf(m.Fsrc, "error reading source root directory: %v", srcListErr) } srcListErr = fs.CountError(m.Ctx, srcListErr) return nil, srcListErr } if dstListErr == fs.ErrorDirNotFound { // Copy the stuff anyway } else if dstListErr != nil { if job.dstRemote != "" { fs.Errorf(job.dstRemote, "error reading destination directory: %v", dstListErr) } else { fs.Errorf(m.Fdst, "error reading destination root directory: %v", dstListErr) } dstListErr = fs.CountError(m.Ctx, dstListErr) return nil, dstListErr } return jobs, nil } rclone-v1.71.0/fs/march/march_test.go000066400000000000000000000311501505210326400174300ustar00rootroot00000000000000// Internal tests for march package march import ( "context" "errors" "fmt" "strings" "sync" "testing" _ "github.com/rclone/rclone/backend/local" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/fs/walk" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/mockdir" "github.com/rclone/rclone/fstest/mockobject" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "golang.org/x/text/unicode/norm" ) // Some times used in the tests var ( t1 = fstest.Time("2001-02-03T04:05:06.499999999Z") ) func TestMain(m *testing.M) { fstest.TestMain(m) } type marchTester struct { ctx context.Context // internal context for controlling go-routines cancel func() // cancel the context srcOnly fs.DirEntries dstOnly fs.DirEntries match fs.DirEntries entryMutex sync.Mutex errorMu sync.Mutex // Mutex covering the error variables err error noRetryErr error fatalErr error noTraverse bool } // DstOnly have an object which is in the destination only func (mt *marchTester) DstOnly(dst fs.DirEntry) (recurse bool) { mt.entryMutex.Lock() mt.dstOnly = append(mt.dstOnly, dst) mt.entryMutex.Unlock() switch dst.(type) { case fs.Object: return false case fs.Directory: return true default: panic("Bad object in DirEntries") } } // SrcOnly have an object which is in the source only func (mt *marchTester) SrcOnly(src fs.DirEntry) (recurse bool) { mt.entryMutex.Lock() mt.srcOnly = append(mt.srcOnly, src) mt.entryMutex.Unlock() switch src.(type) { case fs.Object: return false case fs.Directory: return true default: panic("Bad object in DirEntries") } } // Match is called when src and dst are present, so sync src to dst func (mt *marchTester) Match(ctx context.Context, dst, src fs.DirEntry) (recurse bool) { mt.entryMutex.Lock() mt.match = append(mt.match, src) mt.entryMutex.Unlock() switch src.(type) { case fs.Object: return false case fs.Directory: // Do the same thing to the entire contents of the directory _, ok := dst.(fs.Directory) if ok { return true } // FIXME src is dir, dst is file err := errors.New("can't overwrite file with directory") fs.Errorf(dst, "%v", err) mt.processError(err) default: panic("Bad object in DirEntries") } return false } func (mt *marchTester) processError(err error) { if err == nil { return } mt.errorMu.Lock() defer mt.errorMu.Unlock() switch { case fserrors.IsFatalError(err): if !mt.aborting() { fs.Errorf(nil, "Cancelling sync due to fatal error: %v", err) mt.cancel() } mt.fatalErr = err case fserrors.IsNoRetryError(err): mt.noRetryErr = err default: mt.err = err } } func (mt *marchTester) currentError() error { mt.errorMu.Lock() defer mt.errorMu.Unlock() if mt.fatalErr != nil { return mt.fatalErr } if mt.err != nil { return mt.err } return mt.noRetryErr } func (mt *marchTester) aborting() bool { return mt.ctx.Err() != nil } func TestMarch(t *testing.T) { for _, test := range []struct { what string fileSrcOnly []string dirSrcOnly []string fileDstOnly []string dirDstOnly []string fileMatch []string dirMatch []string noTraverse bool fastList bool }{ { what: "source only", fileSrcOnly: []string{"test", "test2", "test3", "sub dir/test4"}, dirSrcOnly: []string{"sub dir"}, }, { what: "identical", fileMatch: []string{"test", "test2", "sub dir/test3", "sub dir/sub sub dir/test4"}, dirMatch: []string{"sub dir", "sub dir/sub sub dir"}, }, { what: "typical sync", fileSrcOnly: []string{"srcOnly", "srcOnlyDir/sub"}, dirSrcOnly: []string{"srcOnlyDir"}, fileMatch: []string{"match", "matchDir/match file"}, dirMatch: []string{"matchDir"}, fileDstOnly: []string{"dstOnly", "dstOnlyDir/sub"}, dirDstOnly: []string{"dstOnlyDir"}, }, { what: "no traverse source only", fileSrcOnly: []string{"test", "test2", "test3", "sub dir/test4"}, dirSrcOnly: []string{"sub dir"}, noTraverse: true, }, { what: "no traverse identical", fileMatch: []string{"test", "test2", "sub dir/test3", "sub dir/sub sub dir/test4"}, noTraverse: true, }, { what: "no traverse typical sync", fileSrcOnly: []string{"srcOnly", "srcOnlyDir/sub"}, fileMatch: []string{"match", "matchDir/match file"}, noTraverse: true, }, { what: "fast list source only", fileSrcOnly: []string{"test", "test2", "test3", "sub dir/test4"}, dirSrcOnly: []string{"sub dir"}, fastList: true, }, { what: "fast list identical", fileMatch: []string{"test", "test2", "sub dir/test3", "sub dir/sub sub dir/test4"}, dirMatch: []string{"sub dir", "sub dir/sub sub dir"}, fastList: true, }, { what: "fast list typical sync", fileSrcOnly: []string{"srcOnly", "srcOnlyDir/sub"}, dirSrcOnly: []string{"srcOnlyDir"}, fileMatch: []string{"match", "matchDir/match file"}, dirMatch: []string{"matchDir"}, fileDstOnly: []string{"dstOnly", "dstOnlyDir/sub"}, dirDstOnly: []string{"dstOnlyDir"}, fastList: true, }, } { t.Run(fmt.Sprintf("TestMarch-%s", test.what), func(t *testing.T) { r := fstest.NewRun(t) var srcOnly []fstest.Item var dstOnly []fstest.Item var match []fstest.Item ctx, cancel := context.WithCancel(context.Background()) for _, f := range test.fileSrcOnly { srcOnly = append(srcOnly, r.WriteFile(f, "hello world", t1)) } for _, f := range test.fileDstOnly { dstOnly = append(dstOnly, r.WriteObject(ctx, f, "hello world", t1)) } for _, f := range test.fileMatch { match = append(match, r.WriteBoth(ctx, f, "hello world", t1)) } ctx, ci := fs.AddConfig(ctx) ci.UseListR = test.fastList fi := filter.GetConfig(ctx) // Local backend doesn't implement ListR, so monkey patch it for this test if test.fastList && r.Flocal.Features().ListR == nil { r.Flocal.Features().ListR = func(ctx context.Context, dir string, callback fs.ListRCallback) error { r.Flocal.Features().ListR = nil // disable ListR to avoid infinite recursion return walk.ListR(ctx, r.Flocal, dir, true, -1, walk.ListAll, callback) } defer func() { r.Flocal.Features().ListR = nil }() } mt := &marchTester{ ctx: ctx, cancel: cancel, noTraverse: test.noTraverse, } m := &March{ Ctx: ctx, Fdst: r.Fremote, Fsrc: r.Flocal, Dir: "", NoTraverse: test.noTraverse, Callback: mt, DstIncludeAll: fi.Opt.DeleteExcluded, } mt.processError(m.Run(ctx)) mt.cancel() err := mt.currentError() require.NoError(t, err) precision := fs.GetModifyWindow(ctx, r.Fremote, r.Flocal) fstest.CompareItems(t, mt.srcOnly, srcOnly, test.dirSrcOnly, precision, "srcOnly") fstest.CompareItems(t, mt.dstOnly, dstOnly, test.dirDstOnly, precision, "dstOnly") fstest.CompareItems(t, mt.match, match, test.dirMatch, precision, "match") }) } } // matchPair is a matched pair of direntries returned by matchListings type matchPair struct { src, dst fs.DirEntry } func TestMatchListings(t *testing.T) { var ( a = mockobject.Object("a") A = mockobject.Object("A") b = mockobject.Object("b") c = mockobject.Object("c") d = mockobject.Object("d") uE1 = mockobject.Object("é") // one of the unicode E characters uE2 = mockobject.Object("é") // a different unicode E character dirA = mockdir.New("A") dirb = mockdir.New("b") ) for _, test := range []struct { what string input fs.DirEntries // pairs of input src, dst srcOnly fs.DirEntries dstOnly fs.DirEntries matches []matchPair // pairs of output transforms []matchTransformFn }{ { what: "only src or dst", input: fs.DirEntries{ a, nil, b, nil, c, nil, d, nil, }, srcOnly: fs.DirEntries{ a, b, c, d, }, }, { what: "typical sync #1", input: fs.DirEntries{ a, nil, b, b, nil, c, nil, d, }, srcOnly: fs.DirEntries{ a, }, dstOnly: fs.DirEntries{ c, d, }, matches: []matchPair{ {b, b}, }, }, { what: "typical sync #2", input: fs.DirEntries{ a, a, b, b, nil, c, d, d, }, dstOnly: fs.DirEntries{ c, }, matches: []matchPair{ {a, a}, {b, b}, {d, d}, }, }, { what: "One duplicate", input: fs.DirEntries{ A, A, a, a, a, nil, b, b, }, matches: []matchPair{ {A, A}, {a, a}, {b, b}, }, }, { what: "Two duplicates", input: fs.DirEntries{ a, a, a, a, a, nil, }, matches: []matchPair{ {a, a}, }, }, { what: "Case insensitive duplicate - no transform", input: fs.DirEntries{ a, a, A, A, }, matches: []matchPair{ {A, A}, {a, a}, }, }, { what: "Case insensitive duplicate - transform to lower case", input: fs.DirEntries{ a, A, A, a, }, matches: []matchPair{ {a, A}, // the first duplicate will be returned with a stable sort }, transforms: []matchTransformFn{strings.ToLower}, }, { what: "Unicode near-duplicate that becomes duplicate with normalization", input: fs.DirEntries{ uE1, uE1, uE2, uE2, }, matches: []matchPair{ {uE1, uE1}, }, transforms: []matchTransformFn{norm.NFC.String}, }, { what: "Unicode near-duplicate with no normalization", input: fs.DirEntries{ uE1, uE1, uE2, uE2, }, matches: []matchPair{ {uE1, uE1}, {uE2, uE2}, }, }, { what: "File and directory are not duplicates - srcOnly", input: fs.DirEntries{ dirA, nil, A, nil, }, srcOnly: fs.DirEntries{ dirA, A, }, }, { what: "File and directory are not duplicates - matches", input: fs.DirEntries{ dirA, dirA, A, A, }, matches: []matchPair{ {dirA, dirA}, {A, A}, }, }, { what: "Sync with directory #1", input: fs.DirEntries{ dirA, nil, A, nil, b, b, nil, c, nil, d, }, srcOnly: fs.DirEntries{ dirA, A, }, dstOnly: fs.DirEntries{ c, d, }, matches: []matchPair{ {b, b}, }, }, { what: "Sync with 2 directories", input: fs.DirEntries{ dirA, dirA, A, nil, nil, dirb, nil, b, }, srcOnly: fs.DirEntries{ A, }, dstOnly: fs.DirEntries{ dirb, b, }, matches: []matchPair{ {dirA, dirA}, }, }, { what: "Sync with duplicate files and dirs", input: fs.DirEntries{ dirA, A, A, dirA, }, matches: []matchPair{ {dirA, dirA}, {A, A}, }, }, } { t.Run(fmt.Sprintf("TestMatchListings-%s", test.what), func(t *testing.T) { ctx := context.Background() var wg sync.WaitGroup // Skeleton March for testing m := March{ Ctx: context.Background(), transforms: test.transforms, } // Make a channel to send the source (0) or dest (1) using a list.Sorter makeChan := func(offset int) <-chan fs.DirEntry { out := make(chan fs.DirEntry) key := m.dstKey if offset == 0 { key = m.srcKey } ls, err := list.NewSorter(ctx, nil, list.SortToChan(out), key) require.NoError(t, err) wg.Add(1) go func() { defer wg.Done() for i := 0; i < len(test.input); i += 2 { entry := test.input[i+offset] if entry != nil { require.NoError(t, ls.Add(fs.DirEntries{entry})) } } require.NoError(t, ls.Send()) ls.CleanUp() close(out) }() return out } var srcOnly fs.DirEntries srcOnlyFn := func(entry fs.DirEntry) { srcOnly = append(srcOnly, entry) } var dstOnly fs.DirEntries dstOnlyFn := func(entry fs.DirEntry) { dstOnly = append(dstOnly, entry) } var matches []matchPair matchFn := func(dst, src fs.DirEntry) { matches = append(matches, matchPair{dst: dst, src: src}) } err := m.matchListings(makeChan(0), makeChan(1), srcOnlyFn, dstOnlyFn, matchFn) require.NoError(t, err) wg.Wait() assert.Equal(t, test.srcOnly, srcOnly, test.what, "srcOnly differ") assert.Equal(t, test.dstOnly, dstOnly, test.what, "dstOnly differ") assert.Equal(t, test.matches, matches, test.what, "matches differ") // now swap src and dst srcOnly, dstOnly, matches = nil, nil, nil err = m.matchListings(makeChan(0), makeChan(1), srcOnlyFn, dstOnlyFn, matchFn) require.NoError(t, err) wg.Wait() assert.Equal(t, test.srcOnly, srcOnly, test.what, "srcOnly differ") assert.Equal(t, test.dstOnly, dstOnly, test.what, "dstOnly differ") assert.Equal(t, test.matches, matches, test.what, "matches differ") }) } } rclone-v1.71.0/fs/metadata.go000066400000000000000000000104031505210326400157630ustar00rootroot00000000000000package fs import ( "bytes" "context" "encoding/json" "fmt" "os/exec" "strings" "time" ) // Metadata represents Object metadata in a standardised form // // See docs/content/metadata.md for the interpretation of the keys type Metadata map[string]string // MetadataHelp represents help for a bit of system metadata type MetadataHelp struct { Help string Type string Example string ReadOnly bool } // MetadataInfo is help for the whole metadata for this backend. type MetadataInfo struct { System map[string]MetadataHelp Help string } // Set k to v on m // // If m is nil, then it will get made func (m *Metadata) Set(k, v string) { if *m == nil { *m = make(Metadata, 1) } (*m)[k] = v } // Merge other into m // // If m is nil, then it will get made func (m *Metadata) Merge(other Metadata) { for k, v := range other { if *m == nil { *m = make(Metadata, len(other)) } (*m)[k] = v } } // MergeOptions gets any Metadata from the options passed in and // stores it in m (which may be nil). // // If there is no m then metadata will be nil func (m *Metadata) MergeOptions(options []OpenOption) { for _, opt := range options { if metadataOption, ok := opt.(MetadataOption); ok { m.Merge(Metadata(metadataOption)) } } } // GetMetadata from an DirEntry // // If the object has no metadata then metadata will be nil func GetMetadata(ctx context.Context, o DirEntry) (metadata Metadata, err error) { do, ok := o.(Metadataer) if !ok { return nil, nil } return do.Metadata(ctx) } // mapItem descripts the item to be mapped type mapItem struct { SrcFs string SrcFsType string DstFs string DstFsType string Remote string Size int64 MimeType string `json:",omitempty"` ModTime time.Time IsDir bool ID string `json:",omitempty"` Metadata Metadata `json:",omitempty"` } // This runs an external program on the metadata which can be used to // map it from one form to another. func metadataMapper(ctx context.Context, cmdLine SpaceSepList, dstFs Fs, o DirEntry, metadata Metadata) (newMetadata Metadata, err error) { ci := GetConfig(ctx) cmd := exec.Command(cmdLine[0], cmdLine[1:]...) in := mapItem{ DstFs: ConfigString(dstFs), DstFsType: Type(dstFs), Remote: o.Remote(), Size: o.Size(), MimeType: MimeType(ctx, o), ModTime: o.ModTime(ctx), IsDir: false, Metadata: metadata, } fInfo := o.Fs() if f, ok := fInfo.(Fs); ok { in.SrcFs = ConfigString(f) in.SrcFsType = Type(f) } else { in.SrcFs = fInfo.Name() + ":" + fInfo.Root() in.SrcFsType = "unknown" } if do, ok := o.(IDer); ok { in.ID = do.ID() } inBytes, err := json.MarshalIndent(in, "", "\t") if err != nil { return nil, fmt.Errorf("metadata mapper: failed to marshal input: %w", err) } if ci.Dump.IsSet(DumpMapper) { Debugf(nil, "Metadata mapper sent: \n%s\n", string(inBytes)) } var stdout, stderr bytes.Buffer cmd.Stdin = bytes.NewBuffer(inBytes) cmd.Stdout = &stdout cmd.Stderr = &stderr start := time.Now() err = cmd.Run() Debugf(o, "Calling metadata mapper %v", cmdLine) duration := time.Since(start) if err != nil { return nil, fmt.Errorf("metadata mapper: failed on %v: %q: %w", cmdLine, strings.TrimSpace(stderr.String()), err) } if ci.Dump.IsSet(DumpMapper) { Debugf(nil, "Metadata mapper received: \n%s\n", stdout.String()) } var out mapItem err = json.Unmarshal(stdout.Bytes(), &out) if err != nil { return nil, fmt.Errorf("metadata mapper: failed to read output: %q: %w", stdout.String(), err) } Debugf(o, "Metadata mapper returned in %v", duration) return out.Metadata, nil } // GetMetadataOptions from an DirEntry and merge it with any in options // // If --metadata isn't in use it will return nil. // // If the object has no metadata then metadata will be nil. // // This should be passed the destination Fs for the metadata mapper func GetMetadataOptions(ctx context.Context, dstFs Fs, o DirEntry, options []OpenOption) (metadata Metadata, err error) { ci := GetConfig(ctx) if !ci.Metadata { return nil, nil } metadata, err = GetMetadata(ctx, o) if err != nil { return nil, err } metadata.MergeOptions(options) if len(ci.MetadataMapper) != 0 { metadata, err = metadataMapper(ctx, ci.MetadataMapper, dstFs, o, metadata) if err != nil { return nil, err } } return metadata, nil } rclone-v1.71.0/fs/metadata_mapper_code.go000066400000000000000000000030201505210326400203160ustar00rootroot00000000000000//go:build ignore // A simple metadata mapper for testing purposes package main import ( "encoding/json" "fmt" "log" "os" ) func check[T comparable](in map[string]any, key string, want T) { value, ok := in[key] if !ok { fmt.Fprintf(os.Stderr, "%s key not found\n", key) os.Exit(1) } if value.(T) != want { fmt.Fprintf(os.Stderr, "%s wrong - expecting %s but got %s\n", key, want, value) os.Exit(1) } } func main() { // Read the input var in map[string]any err := json.NewDecoder(os.Stdin).Decode(&in) if err != nil { log.Fatal(err) } // Check the input metadata, ok := in["Metadata"] if !ok { fmt.Fprintf(os.Stderr, "Metadata key not found\n") os.Exit(1) } check(in, "Size", 5.0) check(in, "SrcFs", "memory:") check(in, "SrcFsType", "object.memoryFs") check(in, "DstFs", "dstFs:dstFsRoot") check(in, "DstFsType", "mockfs") check(in, "Remote", "file.txt") check(in, "MimeType", "text/plain; charset=utf-8") check(in, "ModTime", "2001-02-03T04:05:06.000000007Z") check(in, "IsDir", false) //check(in, "ID", "Potato") // Map the metadata metadataOut := map[string]string{} var out = map[string]any{ "Metadata": metadataOut, } for k, v := range metadata.(map[string]any) { switch k { case "error": fmt.Fprintf(os.Stderr, "Error: %s\n", v) os.Exit(1) case "key1": v = "two " + v.(string) case "key3": continue } metadataOut[k] = v.(string) } metadataOut["key0"] = "cabbage" // Write the output json.NewEncoder(os.Stdout).Encode(&out) if err != nil { log.Fatal(err) } } rclone-v1.71.0/fs/metadata_test.go000066400000000000000000000075451505210326400170370ustar00rootroot00000000000000package fs_test import ( "context" "fmt" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/object" "github.com/rclone/rclone/fstest/mockfs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestMetadataSet(t *testing.T) { var m fs.Metadata assert.Nil(t, m) m.Set("key", "value") assert.NotNil(t, m) assert.Equal(t, "value", m["key"]) m.Set("key", "value2") assert.Equal(t, "value2", m["key"]) } func TestMetadataMerge(t *testing.T) { for _, test := range []struct { in fs.Metadata merge fs.Metadata want fs.Metadata }{ { in: fs.Metadata{}, merge: fs.Metadata{}, want: fs.Metadata{}, }, { in: nil, merge: nil, want: nil, }, { in: nil, merge: fs.Metadata{}, want: nil, }, { in: nil, merge: fs.Metadata{"a": "1", "b": "2"}, want: fs.Metadata{"a": "1", "b": "2"}, }, { in: fs.Metadata{"a": "1", "b": "2"}, merge: nil, want: fs.Metadata{"a": "1", "b": "2"}, }, { in: fs.Metadata{"a": "1", "b": "2"}, merge: fs.Metadata{"b": "B", "c": "3"}, want: fs.Metadata{"a": "1", "b": "B", "c": "3"}, }, } { what := fmt.Sprintf("in=%v, merge=%v", test.in, test.merge) test.in.Merge(test.merge) assert.Equal(t, test.want, test.in, what) } } func TestMetadataMergeOptions(t *testing.T) { for _, test := range []struct { in fs.Metadata opts []fs.OpenOption want fs.Metadata }{ { opts: []fs.OpenOption{}, want: nil, }, { opts: []fs.OpenOption{&fs.HTTPOption{}}, want: nil, }, { opts: []fs.OpenOption{fs.MetadataOption{"a": "1", "b": "2"}}, want: fs.Metadata{"a": "1", "b": "2"}, }, { opts: []fs.OpenOption{ &fs.HTTPOption{}, fs.MetadataOption{"a": "1", "b": "2"}, fs.MetadataOption{"b": "B", "c": "3"}, &fs.HTTPOption{}, }, want: fs.Metadata{"a": "1", "b": "B", "c": "3"}, }, { in: fs.Metadata{"a": "first", "z": "OK"}, opts: []fs.OpenOption{ &fs.HTTPOption{}, fs.MetadataOption{"a": "1", "b": "2"}, fs.MetadataOption{"b": "B", "c": "3"}, &fs.HTTPOption{}, }, want: fs.Metadata{"a": "1", "b": "B", "c": "3", "z": "OK"}, }, } { what := fmt.Sprintf("in=%v, opts=%v", test.in, test.opts) test.in.MergeOptions(test.opts) assert.Equal(t, test.want, test.in, what) } } func TestMetadataMapper(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) ci.Metadata = true require.NoError(t, ci.MetadataMapper.Set("go run metadata_mapper_code.go")) now := time.Date(2001, 2, 3, 4, 5, 6, 7, time.UTC) f, err := mockfs.NewFs(ctx, "dstFs", "dstFsRoot", nil) require.NoError(t, err) t.Run("Normal", func(t *testing.T) { o := object.NewMemoryObject("file.txt", now, []byte("hello")).WithMetadata(fs.Metadata{ "key1": "potato", "key2": "sausage", "key3": "gravy", }) metadata, err := fs.GetMetadataOptions(ctx, f, o, nil) require.NoError(t, err) assert.Equal(t, fs.Metadata{ "key0": "cabbage", "key1": "two potato", "key2": "sausage", }, metadata) }) t.Run("Error", func(t *testing.T) { o := object.NewMemoryObject("file.txt", now, []byte("hello")).WithMetadata(fs.Metadata{ "error": "Red Alert", }) metadata, err := fs.GetMetadataOptions(ctx, f, o, nil) require.Error(t, err) assert.ErrorContains(t, err, "Red Alert") require.Nil(t, metadata) }) t.Run("Merge", func(t *testing.T) { o := object.NewMemoryObject("file.txt", now, []byte("hello")).WithMetadata(fs.Metadata{ "key1": "potato", "key2": "sausage", "key3": "gravy", }) metadata, err := fs.GetMetadataOptions(ctx, f, o, []fs.OpenOption{fs.MetadataOption(fs.Metadata{ "option": "optionValue", "key1": "new potato", "key2": "salami", })}) require.NoError(t, err) assert.Equal(t, fs.Metadata{ "key0": "cabbage", "key1": "two new potato", "key2": "salami", "option": "optionValue", }, metadata) }) } rclone-v1.71.0/fs/mimetype.go000066400000000000000000000040511505210326400160360ustar00rootroot00000000000000package fs import ( "context" "mime" "path" "strings" ) // Add a minimal number of mime types to augment go's built in types // for environments which don't have access to a mime.types file (e.g. // Termux on android) func init() { for _, t := range []struct { mimeType string extensions string }{ {"audio/flac", ".flac"}, {"audio/mpeg", ".mpga,.mpega,.mp2,.mp3,.m4a"}, {"audio/ogg", ".oga,.ogg,.opus,.spx"}, {"audio/x-wav", ".wav"}, {"image/tiff", ".tiff,.tif"}, {"video/dv", ".dif,.dv"}, {"video/fli", ".fli"}, {"video/mpeg", ".mpeg,.mpg,.mpe"}, {"video/MP2T", ".ts"}, {"video/mp4", ".mp4"}, {"video/quicktime", ".qt,.mov"}, {"video/ogg", ".ogv"}, {"video/webm", ".webm"}, {"video/x-msvideo", ".avi"}, {"video/x-matroska", ".mpv,.mkv"}, {"application/x-subrip", ".srt"}, } { for _, ext := range strings.Split(t.extensions, ",") { if mime.TypeByExtension(ext) == "" { err := mime.AddExtensionType(ext, t.mimeType) if err != nil { panic(err) } } } } } // MimeTypeFromName returns a guess at the mime type from the name func MimeTypeFromName(remote string) (mimeType string) { mimeType = mime.TypeByExtension(path.Ext(remote)) if !strings.ContainsRune(mimeType, '/') { mimeType = "application/octet-stream" } return mimeType } // MimeType returns the MimeType from the object, either by calling // the MimeTyper interface or using MimeTypeFromName func MimeType(ctx context.Context, o DirEntry) (mimeType string) { // Read the MimeType from the optional interface if available if do, ok := o.(MimeTyper); ok { mimeType = do.MimeType(ctx) // Debugf(o, "Read MimeType as %q", mimeType) if mimeType != "" { return mimeType } } return MimeTypeFromName(o.Remote()) } // MimeTypeDirEntry returns the MimeType of a DirEntry // // It returns "inode/directory" for directories, or uses // MimeType(Object) func MimeTypeDirEntry(ctx context.Context, item DirEntry) string { switch x := item.(type) { case Object: return MimeType(ctx, x) case Directory: return "inode/directory" } return "" } rclone-v1.71.0/fs/mount_helper.go000066400000000000000000000167041505210326400167160ustar00rootroot00000000000000package fs import ( "errors" "fmt" "os" "path/filepath" "runtime" "strings" ) func init() { // This block is run super-early, before configuration harness kick in if IsMountHelper() { if args, err := convertMountHelperArgs(os.Args); err == nil { os.Args = args } else { Fatalf(nil, "Failed to parse command line: %v", err) } } } // PassDaemonArgsAsEnviron tells how CLI arguments are passed to the daemon // When false, arguments are passed as is, visible in the `ps` output. // When true, arguments are converted into environment variables (more secure). var PassDaemonArgsAsEnviron bool // Comma-separated list of mount options to ignore. // Leading and trailing commas are required. const helperIgnoredOpts = ",rw,_netdev,nofail,user,dev,nodev,suid,nosuid,exec,noexec,auto,noauto," // Valid option name characters const helperValidOptChars = "-_0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" // Parser errors var ( errHelperBadOption = errors.New("option names may only contain `0-9`, `A-Z`, `a-z`, `-` and `_`") errHelperOptionName = errors.New("option name can't start with `-` or `_`") errHelperEmptyOption = errors.New("option name can't be empty") errHelperQuotedValue = errors.New("unterminated quoted value") errHelperAfterQuote = errors.New("expecting `,` or another quote after a quote") errHelperSyntax = errors.New("syntax error in option string") errHelperEmptyCommand = errors.New("command name can't be empty") errHelperEnvSyntax = errors.New("environment variable must have syntax env.NAME=[VALUE]") ) // IsMountHelper returns true if rclone was invoked as mount helper: // as /sbin/mount.rlone (by /bin/mount) // or /usr/bin/rclonefs (by fusermount or directly) func IsMountHelper() bool { if runtime.GOOS == "windows" { return false } me := filepath.Base(os.Args[0]) return me == "mount.rclone" || me == "rclonefs" } // convertMountHelperArgs converts "-o" styled mount helper arguments // into usual rclone flags func convertMountHelperArgs(origArgs []string) ([]string, error) { if IsDaemon() { // The arguments have already been converted by the parent return origArgs, nil } args := []string{} command := "mount" parseOpts := false gotDaemon := false gotVerbose := false vCount := 0 for _, arg := range origArgs[1:] { if !parseOpts { switch arg { case "-o", "--opt": parseOpts = true case "-v", "-vv", "-vvv", "-vvvv": vCount += len(arg) - 1 case "-h", "--help": args = append(args, "--help") default: if strings.HasPrefix(arg, "-") { return nil, fmt.Errorf("flag %q is not supported in mount mode", arg) } args = append(args, arg) } continue } opts, err := parseHelperOptionString(arg) if err != nil { return nil, err } parseOpts = false for _, opt := range opts { if strings.Contains(helperIgnoredOpts, ","+opt+",") || strings.HasPrefix(opt, "x-systemd") { continue } param, value, _ := strings.Cut(opt, "=") // Set environment variables if strings.HasPrefix(param, "env.") { if param = param[4:]; param == "" { return nil, errHelperEnvSyntax } _ = os.Setenv(param, value) continue } switch param { // Change command to run case "command": if value == "" { return nil, errHelperEmptyCommand } command = value continue // Flag StartDaemon to pass arguments as environment case "args2env": PassDaemonArgsAsEnviron = true continue // Handle verbosity options case "v", "vv", "vvv", "vvvv": vCount += len(param) continue case "verbose": gotVerbose = true // Don't add --daemon if it was explicitly included case "daemon": gotDaemon = true // Alias for the standard mount option "ro" case "ro": param = "read-only" } arg = "--" + strings.ToLower(strings.ReplaceAll(param, "_", "-")) if value != "" { arg += "=" + value } args = append(args, arg) } } if parseOpts { return nil, fmt.Errorf("dangling -o without argument") } if vCount > 0 && !gotVerbose { args = append(args, fmt.Sprintf("--verbose=%d", vCount)) } if strings.Contains(command, "mount") && !gotDaemon { // Default to daemonized mount args = append(args, "--daemon") } if len(args) > 0 && args[0] == command { // Remove artefact of repeated conversion args = args[1:] } prepend := []string{origArgs[0], command} return append(prepend, args...), nil } // parseHelperOptionString deconstructs the -o value into slice of options // in a way similar to connection strings. // Example: // // param1=value,param2="qvalue",param3='item1,item2',param4="a ""b"" 'c'" // // An error may be returned if the remote name has invalid characters // or the parameters are invalid or the path is empty. // // The algorithm was adapted from fspath.Parse with some modifications: // - allow `-` in option names // - handle special options `x-systemd.X` and `env.X` // - drop support for :backend: and /path func parseHelperOptionString(optString string) (opts []string, err error) { if optString = strings.TrimSpace(optString); optString == "" { return nil, nil } // States for parser const ( stateParam = uint8(iota) stateValue stateQuotedValue stateAfterQuote stateDone ) var ( state = stateParam // current state of parser i int // position in path prev int // previous position in path c rune // current rune under consideration quote rune // kind of quote to end this quoted string param string // current parameter value doubled bool // set if had doubled quotes ) for i, c = range optString + "," { switch state { // Parses param= and param2= case stateParam: switch c { case ',', '=': param = optString[prev:i] if len(param) == 0 { return nil, errHelperEmptyOption } if param[0] == '-' { return nil, errHelperOptionName } prev = i + 1 if c == '=' { state = stateValue break } opts = append(opts, param) case '.': if pref := optString[prev:i]; pref != "env" && pref != "x-systemd" { return nil, errHelperBadOption } default: if !strings.ContainsRune(helperValidOptChars, c) { return nil, errHelperBadOption } } case stateValue: switch c { case '\'', '"': if i == prev { quote = c prev = i + 1 doubled = false state = stateQuotedValue } case ',': value := optString[prev:i] prev = i + 1 opts = append(opts, param+"="+value) state = stateParam } case stateQuotedValue: if c == quote { state = stateAfterQuote } case stateAfterQuote: switch c { case ',': value := optString[prev : i-1] // replace any doubled quotes if there were any if doubled { value = strings.ReplaceAll(value, string(quote)+string(quote), string(quote)) } prev = i + 1 opts = append(opts, param+"="+value) state = stateParam case quote: // Here is a doubled quote to indicate a literal quote state = stateQuotedValue doubled = true default: return nil, errHelperAfterQuote } } } // Depending on which state we were in when we fell off the // end of the state machine we can return a sensible error. if state == stateParam && prev > len(optString) { state = stateDone } switch state { case stateQuotedValue: return nil, errHelperQuotedValue case stateAfterQuote: return nil, errHelperAfterQuote case stateDone: break default: return nil, errHelperSyntax } return opts, nil } rclone-v1.71.0/fs/mount_helper_test.go000066400000000000000000000021601505210326400177440ustar00rootroot00000000000000package fs import ( "os" "strings" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestMountHelperArgs(t *testing.T) { type testCase struct { src []string dst []string env string err string } normalCases := []testCase{{ src: []string{}, dst: []string{"mount", "--daemon"}, }, { src: []string{"-o", `x-systemd.automount,vvv,env.HTTPS_PROXY="a b;c,d?EF",ro,rw,args2env,_netdev`}, dst: []string{"mount", "--read-only", "--verbose=3", "--daemon"}, env: "HTTPS_PROXY=a b;c,d?EF", }} for _, tc := range normalCases { exe := []string{"rclone"} src := append(exe, tc.src...) res, err := convertMountHelperArgs(src) if tc.err != "" { require.Error(t, err) assert.Contains(t, err.Error(), tc.err) continue } require.NoError(t, err) require.Greater(t, len(res), 1) assert.Equal(t, exe[0], res[0]) dst := res[1:] //log.Printf("%q -> %q", tc.src, dst) assert.Equal(t, tc.dst, dst) if tc.env != "" { idx := strings.Index(tc.env, "=") name, value := tc.env[:idx], tc.env[idx+1:] assert.Equal(t, value, os.Getenv(name)) } } } rclone-v1.71.0/fs/newfs.go000066400000000000000000000162301505210326400153310ustar00rootroot00000000000000// NewFs and its helpers package fs import ( "context" "crypto/md5" "encoding/base64" "fmt" "maps" "os" "path/filepath" "slices" "strings" "sync" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/fs/fspath" ) // Store the hashes of the overridden config var ( overriddenConfigMu sync.Mutex overriddenConfig = make(map[string]string) ) // NewFs makes a new Fs object from the path // // The path is of the form remote:path // // Remotes are looked up in the config file. If the remote isn't // found then NotFoundInConfigFile will be returned. // // On Windows avoid single character remote names as they can be mixed // up with drive letters. func NewFs(ctx context.Context, path string) (Fs, error) { Debugf(nil, "Creating backend with remote %q", path) if ConfigFileHasSection(path) { Logf(nil, "%q refers to a local folder, use %q to refer to your remote or %q to hide this warning", path, path+":", "./"+path) } fsInfo, configName, fsPath, config, err := ConfigFs(path) if err != nil { return nil, err } overridden := fsInfo.Options.Overridden(config) if len(overridden) > 0 { extraConfig := overridden.String() //Debugf(nil, "detected overridden config %q", extraConfig) md5sumBinary := md5.Sum([]byte(extraConfig)) configHash := base64.RawURLEncoding.EncodeToString(md5sumBinary[:]) // 5 characters length is 5*6 = 30 bits of base64 overriddenConfigMu.Lock() var suffix string for maxLength := 5; ; maxLength++ { suffix = "{" + configHash[:maxLength] + "}" existingExtraConfig, ok := overriddenConfig[suffix] if !ok || existingExtraConfig == extraConfig { break } } Debugf(configName, "detected overridden config - adding %q suffix to name", suffix) // Add the suffix to the config name // // These need to work as filesystem names as the VFS cache will use them configName += suffix // Store the config suffixes for reversing in ConfigString overriddenConfig[suffix] = extraConfig overriddenConfigMu.Unlock() } ctx, err = addConfigToContext(ctx, configName, config) if err != nil { return nil, err } f, err := fsInfo.NewFs(ctx, configName, fsPath, config) if f != nil && (err == nil || err == ErrorIsFile) { addReverse(f, fsInfo) } return f, err } // Add "global" config or "override" to ctx and the global config if required. // // This looks through keys prefixed with "global." or "override." in // config and sets ctx and optionally the global context if "global.". func addConfigToContext(ctx context.Context, configName string, config configmap.Getter) (newCtx context.Context, err error) { overrideConfig := make(configmap.Simple) globalConfig := make(configmap.Simple) for i := range ConfigOptionsInfo { opt := &ConfigOptionsInfo[i] globalName := "global." + opt.Name value, isSet := config.Get(globalName) if isSet { // Set both override and global if global overrideConfig[opt.Name] = value globalConfig[opt.Name] = value } overrideName := "override." + opt.Name value, isSet = config.Get(overrideName) if isSet { overrideConfig[opt.Name] = value } } if len(overrideConfig) == 0 && len(globalConfig) == 0 { return ctx, nil } newCtx, ci := AddConfig(ctx) overrideKeys := slices.Collect(maps.Keys(overrideConfig)) slices.Sort(overrideKeys) globalKeys := slices.Collect(maps.Keys(globalConfig)) slices.Sort(globalKeys) // Set the config in the newCtx err = configstruct.Set(overrideConfig, ci) if err != nil { return ctx, fmt.Errorf("failed to set override config variables %q: %w", overrideKeys, err) } Debugf(configName, "Set overridden config %q for backend startup", overrideKeys) // Set the global context only if len(globalConfig) != 0 { globalCI := GetConfig(context.Background()) err = configstruct.Set(globalConfig, globalCI) if err != nil { return ctx, fmt.Errorf("failed to set global config variables %q: %w", globalKeys, err) } Debugf(configName, "Set global config %q at backend startup", overrideKeys) } return newCtx, nil } // ConfigFs makes the config for calling NewFs with. // // It parses the path which is of the form remote:path // // Remotes are looked up in the config file. If the remote isn't // found then NotFoundInConfigFile will be returned. func ConfigFs(path string) (fsInfo *RegInfo, configName, fsPath string, config *configmap.Map, err error) { // Parse the remote path fsInfo, configName, fsPath, connectionStringConfig, err := ParseRemote(path) if err != nil { return } config = ConfigMap(fsInfo.Prefix, fsInfo.Options, configName, connectionStringConfig) return } // ParseRemote deconstructs a path into configName, fsPath, looking up // the fsName in the config file (returning NotFoundInConfigFile if not found) func ParseRemote(path string) (fsInfo *RegInfo, configName, fsPath string, connectionStringConfig configmap.Simple, err error) { parsed, err := fspath.Parse(path) if err != nil { return nil, "", "", nil, err } configName, fsPath = parsed.Name, parsed.Path var fsName string var ok bool if configName != "" { if strings.HasPrefix(configName, ":") { fsName = configName[1:] } else { m := ConfigMap("", nil, configName, parsed.Config) fsName, ok = m.Get("type") if !ok { return nil, "", "", nil, fmt.Errorf("%w (%q)", ErrorNotFoundInConfigFile, configName) } } } else { fsName = "local" configName = "local" } fsInfo, err = Find(fsName) return fsInfo, configName, fsPath, parsed.Config, err } // configString returns a canonical version of the config string used // to configure the Fs as passed to fs.NewFs func configString(f Info, full bool) string { name := f.Name() if open := strings.IndexRune(name, '{'); full && open >= 0 && strings.HasSuffix(name, "}") { suffix := name[open:] overriddenConfigMu.Lock() config, ok := overriddenConfig[suffix] overriddenConfigMu.Unlock() if ok { name = name[:open] + "," + config } else { Errorf(f, "Failed to find config for suffix %q", suffix) } } root := f.Root() if name == "local" && f.Features().IsLocal { return root } return name + ":" + root } // ConfigString returns a canonical version of the config string used // to configure the Fs as passed to fs.NewFs. For Fs with extra // parameters this will include a canonical {hexstring} suffix. func ConfigString(f Info) string { return configString(f, false) } // FullPath returns the full path with remote:path/to/object // for an object. func FullPath(o Object) string { return fspath.JoinRootPath(ConfigString(o.Fs()), o.Remote()) } // ConfigStringFull returns a canonical version of the config string // used to configure the Fs as passed to fs.NewFs. This string can be // used to re-instantiate the Fs exactly so includes all the extra // parameters passed in. func ConfigStringFull(f Fs) string { return configString(f, true) } // TemporaryLocalFs creates a local FS in the OS's temporary directory. // // No cleanup is performed, the caller must call Purge on the Fs themselves. func TemporaryLocalFs(ctx context.Context) (Fs, error) { path, err := os.MkdirTemp("", "rclone-spool") if err == nil { err = os.Remove(path) } if err != nil { return nil, err } path = filepath.ToSlash(path) return NewFs(ctx, path) } rclone-v1.71.0/fs/newfs_internal_test.go000066400000000000000000000030641505210326400202650ustar00rootroot00000000000000package fs import ( "context" "testing" "github.com/rclone/rclone/fs/config/configmap" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // When no override/global keys exist, ctx must be returned unchanged. func TestAddConfigToContext_NoChanges(t *testing.T) { ctx := context.Background() newCtx, err := addConfigToContext(ctx, "unit-test", configmap.Simple{}) require.NoError(t, err) assert.Equal(t, newCtx, ctx) } // A single override.key must create a new ctx, but leave the // background ctx untouched. func TestAddConfigToContext_OverrideOnly(t *testing.T) { override := configmap.Simple{ "override.user_agent": "potato", } ctx := context.Background() globalCI := GetConfig(ctx) original := globalCI.UserAgent newCtx, err := addConfigToContext(ctx, "unit-test", override) require.NoError(t, err) assert.NotEqual(t, newCtx, ctx) assert.Equal(t, original, globalCI.UserAgent) ci := GetConfig(newCtx) assert.Equal(t, "potato", ci.UserAgent) } // A single global.key must create a new ctx and update the // background/global config. func TestAddConfigToContext_GlobalOnly(t *testing.T) { global := configmap.Simple{ "global.user_agent": "potato2", } ctx := context.Background() globalCI := GetConfig(ctx) original := globalCI.UserAgent defer func() { globalCI.UserAgent = original }() newCtx, err := addConfigToContext(ctx, "unit-test", global) require.NoError(t, err) assert.NotEqual(t, newCtx, ctx) assert.Equal(t, "potato2", globalCI.UserAgent) ci := GetConfig(newCtx) assert.Equal(t, "potato2", ci.UserAgent) } rclone-v1.71.0/fs/newfs_test.go000066400000000000000000000031761505210326400163750ustar00rootroot00000000000000package fs_test import ( "context" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest/mockfs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestNewFs(t *testing.T) { ctx := context.Background() // Register mockfs temporarily oldRegistry := fs.Registry mockfs.Register() defer func() { fs.Registry = oldRegistry }() f1, err := fs.NewFs(ctx, ":mockfs:/tmp") require.NoError(t, err) assert.Equal(t, ":mockfs", f1.Name()) assert.Equal(t, "/tmp", f1.Root()) assert.Equal(t, ":mockfs:/tmp", fs.ConfigString(f1)) f2, err := fs.NewFs(ctx, ":mockfs,potato:/tmp") require.NoError(t, err) assert.Equal(t, ":mockfs{S_NHG}", f2.Name()) assert.Equal(t, "/tmp", f2.Root()) assert.Equal(t, ":mockfs{S_NHG}:/tmp", fs.ConfigString(f2)) assert.Equal(t, ":mockfs,potato='true':/tmp", fs.ConfigStringFull(f2)) f3, err := fs.NewFs(ctx, ":mockfs,potato='true':/tmp") require.NoError(t, err) assert.Equal(t, ":mockfs{S_NHG}", f3.Name()) assert.Equal(t, "/tmp", f3.Root()) assert.Equal(t, ":mockfs{S_NHG}:/tmp", fs.ConfigString(f3)) assert.Equal(t, ":mockfs,potato='true':/tmp", fs.ConfigStringFull(f3)) // Check that the overrides work globalCI := fs.GetConfig(ctx) original := globalCI.UserAgent defer func() { globalCI.UserAgent = original }() f4, err := fs.NewFs(ctx, ":mockfs,global.user_agent='julian':/tmp") require.NoError(t, err) assert.Equal(t, ":mockfs", f4.Name()) assert.Equal(t, "/tmp", f4.Root()) assert.Equal(t, ":mockfs:/tmp", fs.ConfigString(f4)) assert.Equal(t, ":mockfs:/tmp", fs.ConfigStringFull(f4)) assert.Equal(t, "julian", globalCI.UserAgent) } rclone-v1.71.0/fs/object/000077500000000000000000000000001505210326400151245ustar00rootroot00000000000000rclone-v1.71.0/fs/object/object.go000066400000000000000000000212401505210326400167200ustar00rootroot00000000000000// Package object defines some useful Objects package object import ( "bytes" "context" "errors" "io" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" ) // StaticObjectInfo is an ObjectInfo which can be constructed from scratch type StaticObjectInfo struct { remote string modTime time.Time size int64 storable bool hashes map[hash.Type]string fs fs.Info meta fs.Metadata mimeType string } // NewStaticObjectInfo returns a static ObjectInfo // If hashes is nil and fs is not nil, the hash map will be replaced with // empty hashes of the types supported by the fs. func NewStaticObjectInfo(remote string, modTime time.Time, size int64, storable bool, hashes map[hash.Type]string, f fs.Info) *StaticObjectInfo { info := &StaticObjectInfo{ remote: remote, modTime: modTime, size: size, storable: storable, hashes: hashes, fs: f, } if f != nil && hashes == nil { set := f.Hashes().Array() info.hashes = make(map[hash.Type]string) for _, ht := range set { info.hashes[ht] = "" } } if f == nil { info.fs = MemoryFs } return info } // WithMetadata adds meta to the ObjectInfo func (i *StaticObjectInfo) WithMetadata(meta fs.Metadata) *StaticObjectInfo { i.meta = meta return i } // WithMimeType adds meta to the ObjectInfo func (i *StaticObjectInfo) WithMimeType(mimeType string) *StaticObjectInfo { i.mimeType = mimeType return i } // Fs returns read only access to the Fs that this object is part of func (i *StaticObjectInfo) Fs() fs.Info { return i.fs } // Remote returns the remote path func (i *StaticObjectInfo) Remote() string { return i.remote } // String returns a description of the Object func (i *StaticObjectInfo) String() string { return i.remote } // ModTime returns the modification date of the file func (i *StaticObjectInfo) ModTime(ctx context.Context) time.Time { return i.modTime } // Size returns the size of the file func (i *StaticObjectInfo) Size() int64 { return i.size } // Storable says whether this object can be stored func (i *StaticObjectInfo) Storable() bool { return i.storable } // Hash returns the requested hash of the contents func (i *StaticObjectInfo) Hash(ctx context.Context, h hash.Type) (string, error) { if len(i.hashes) == 0 { return "", hash.ErrUnsupported } if hash, ok := i.hashes[h]; ok { return hash, nil } return "", hash.ErrUnsupported } // Metadata on the object func (i *StaticObjectInfo) Metadata(ctx context.Context) (fs.Metadata, error) { return i.meta, nil } // MimeType returns the content type of the Object if // known, or "" if not func (i *StaticObjectInfo) MimeType(ctx context.Context) string { return i.mimeType } // Check interfaces var ( _ fs.ObjectInfo = (*StaticObjectInfo)(nil) _ fs.Metadataer = (*StaticObjectInfo)(nil) _ fs.MimeTyper = (*StaticObjectInfo)(nil) ) // MemoryFs is an in memory Fs, it only supports FsInfo and Put var MemoryFs memoryFs // memoryFs is an in memory fs type memoryFs struct{} // Name of the remote (as passed into NewFs) func (memoryFs) Name() string { return "memory" } // Root of the remote (as passed into NewFs) func (memoryFs) Root() string { return "" } // String returns a description of the FS func (memoryFs) String() string { return "memory" } // Precision of the ModTimes in this Fs func (memoryFs) Precision() time.Duration { return time.Nanosecond } // Returns the supported hash types of the filesystem func (memoryFs) Hashes() hash.Set { return hash.Supported() } // Features returns the optional features of this Fs func (memoryFs) Features() *fs.Features { return &fs.Features{} } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (memoryFs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { return nil, nil } // NewObject finds the Object at remote. If it can't be found // it returns the error ErrorObjectNotFound. func (memoryFs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return nil, fs.ErrorObjectNotFound } // Put in to the remote path with the modTime given of the given size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (memoryFs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { o := NewMemoryObject(src.Remote(), src.ModTime(ctx), nil) return o, o.Update(ctx, in, src, options...) } // Mkdir makes the directory (container, bucket) // // Shouldn't return an error if it already exists func (memoryFs) Mkdir(ctx context.Context, dir string) error { return errors.New("memoryFs: can't make directory") } // Rmdir removes the directory (container, bucket) if empty // // Return an error if it doesn't exist or isn't empty func (memoryFs) Rmdir(ctx context.Context, dir string) error { return fs.ErrorDirNotFound } var _ fs.Fs = MemoryFs // MemoryObject is an in memory object type MemoryObject struct { remote string modTime time.Time content []byte meta fs.Metadata fs fs.Fs } // NewMemoryObject returns an in memory Object with the modTime and content passed in func NewMemoryObject(remote string, modTime time.Time, content []byte) *MemoryObject { return &MemoryObject{ remote: remote, modTime: modTime, content: content, fs: MemoryFs, } } // WithMetadata adds meta to the MemoryObject func (o *MemoryObject) WithMetadata(meta fs.Metadata) *MemoryObject { o.meta = meta return o } // Content returns the underlying buffer func (o *MemoryObject) Content() []byte { return o.content } // Fs returns read only access to the Fs that this object is part of func (o *MemoryObject) Fs() fs.Info { return o.fs } // SetFs sets the Fs that this memory object thinks it is part of // It will ignore nil f func (o *MemoryObject) SetFs(f fs.Fs) *MemoryObject { if f != nil { o.fs = f } return o } // Remote returns the remote path func (o *MemoryObject) Remote() string { return o.remote } // String returns a description of the Object func (o *MemoryObject) String() string { return o.remote } // ModTime returns the modification date of the file func (o *MemoryObject) ModTime(ctx context.Context) time.Time { return o.modTime } // Size returns the size of the file func (o *MemoryObject) Size() int64 { return int64(len(o.content)) } // Storable says whether this object can be stored func (o *MemoryObject) Storable() bool { return true } // Hash returns the requested hash of the contents func (o *MemoryObject) Hash(ctx context.Context, h hash.Type) (string, error) { hash, err := hash.NewMultiHasherTypes(hash.Set(h)) if err != nil { return "", err } _, err = hash.Write(o.content) if err != nil { return "", err } return hash.Sums()[h], nil } // SetModTime sets the metadata on the object to set the modification date func (o *MemoryObject) SetModTime(ctx context.Context, modTime time.Time) error { o.modTime = modTime return nil } // Open opens the file for read. Call Close() on the returned io.ReadCloser func (o *MemoryObject) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { var offset, limit int64 = 0, -1 for _, option := range options { switch x := option.(type) { case *fs.RangeOption: offset, limit = x.Decode(o.Size()) case *fs.SeekOption: offset = x.Offset default: if option.Mandatory() { fs.Logf(o, "Unsupported mandatory option: %v", option) } } } content := o.content offset = max(offset, 0) if limit < 0 { content = content[offset:] } else { content = content[offset:min(offset+limit, int64(len(content)))] } return io.NopCloser(bytes.NewBuffer(content)), nil } // Update in to the object with the modTime given of the given size // // This reuses the internal buffer if at all possible. func (o *MemoryObject) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (err error) { size := src.Size() if size == 0 { o.content = nil } else if size < 0 || int64(cap(o.content)) < size { o.content, err = io.ReadAll(in) } else { o.content = o.content[:size] _, err = io.ReadFull(in, o.content) } o.modTime = src.ModTime(ctx) return err } // Remove this object func (o *MemoryObject) Remove(ctx context.Context) error { return errors.New("memoryObject.Remove not supported") } // Metadata on the object func (o *MemoryObject) Metadata(ctx context.Context) (fs.Metadata, error) { return o.meta, nil } // Check interfaces var ( _ fs.Object = (*MemoryObject)(nil) _ fs.Metadataer = (*MemoryObject)(nil) ) rclone-v1.71.0/fs/object/object_test.go000066400000000000000000000137501505210326400177660ustar00rootroot00000000000000package object_test import ( "bytes" "context" "io" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/object" "github.com/stretchr/testify/assert" ) func TestStaticObject(t *testing.T) { now := time.Now() remote := "path/to/object" size := int64(1024) o := object.NewStaticObjectInfo(remote, now, size, true, nil, object.MemoryFs) assert.Equal(t, object.MemoryFs, o.Fs()) assert.Equal(t, remote, o.Remote()) assert.Equal(t, remote, o.String()) assert.Equal(t, now, o.ModTime(context.Background())) assert.Equal(t, size, o.Size()) assert.Equal(t, true, o.Storable()) Hash, err := o.Hash(context.Background(), hash.MD5) assert.NoError(t, err) assert.Equal(t, "", Hash) o = object.NewStaticObjectInfo(remote, now, size, true, nil, nil) _, err = o.Hash(context.Background(), hash.MD5) assert.Equal(t, hash.ErrUnsupported, err) assert.Equal(t, object.MemoryFs, o.Fs()) hs := map[hash.Type]string{ hash.MD5: "potato", } o = object.NewStaticObjectInfo(remote, now, size, true, hs, nil) Hash, err = o.Hash(context.Background(), hash.MD5) assert.NoError(t, err) assert.Equal(t, "potato", Hash) _, err = o.Hash(context.Background(), hash.SHA1) assert.Equal(t, hash.ErrUnsupported, err) } func TestMemoryFs(t *testing.T) { f := object.MemoryFs assert.Equal(t, "memory", f.Name()) assert.Equal(t, "", f.Root()) assert.Equal(t, "memory", f.String()) assert.Equal(t, time.Nanosecond, f.Precision()) assert.Equal(t, hash.Supported(), f.Hashes()) assert.Equal(t, &fs.Features{}, f.Features()) entries, err := f.List(context.Background(), "") assert.NoError(t, err) assert.Nil(t, entries) o, err := f.NewObject(context.Background(), "obj") assert.Equal(t, fs.ErrorObjectNotFound, err) assert.Nil(t, o) buf := bytes.NewBufferString("potato") now := time.Now() src := object.NewStaticObjectInfo("remote", now, int64(buf.Len()), true, nil, nil) o, err = f.Put(context.Background(), buf, src) assert.NoError(t, err) hash, err := o.Hash(context.Background(), hash.SHA1) assert.NoError(t, err) assert.Equal(t, "3e2e95f5ad970eadfa7e17eaf73da97024aa5359", hash) err = f.Mkdir(context.Background(), "dir") assert.Error(t, err) err = f.Rmdir(context.Background(), "dir") assert.Equal(t, fs.ErrorDirNotFound, err) } func TestMemoryObject(t *testing.T) { remote := "path/to/object" now := time.Now() content := []byte("potatoXXXXXXXXXXXXX") content = content[:6] // make some extra cap o := object.NewMemoryObject(remote, now, content) assert.Equal(t, content, o.Content()) assert.Equal(t, object.MemoryFs, o.Fs()) assert.Equal(t, remote, o.Remote()) assert.Equal(t, remote, o.String()) assert.Equal(t, now, o.ModTime(context.Background())) assert.Equal(t, int64(len(content)), o.Size()) assert.Equal(t, true, o.Storable()) Hash, err := o.Hash(context.Background(), hash.MD5) assert.NoError(t, err) assert.Equal(t, "8ee2027983915ec78acc45027d874316", Hash) Hash, err = o.Hash(context.Background(), hash.SHA1) assert.NoError(t, err) assert.Equal(t, "3e2e95f5ad970eadfa7e17eaf73da97024aa5359", Hash) newNow := now.Add(time.Minute) err = o.SetModTime(context.Background(), newNow) assert.NoError(t, err) assert.Equal(t, newNow, o.ModTime(context.Background())) checkOpen := func(rc io.ReadCloser, expected string) { t.Helper() actual, err := io.ReadAll(rc) assert.NoError(t, err) err = rc.Close() assert.NoError(t, err) assert.Equal(t, expected, string(actual)) } checkContent := func(o fs.Object, expected string) { t.Helper() rc, err := o.Open(context.Background()) assert.NoError(t, err) checkOpen(rc, expected) } checkContent(o, string(content)) rc, err := o.Open(context.Background(), &fs.RangeOption{Start: 1, End: 3}) assert.NoError(t, err) checkOpen(rc, "ota") rc, err = o.Open(context.Background(), &fs.RangeOption{Start: 1, End: -1}) assert.NoError(t, err) checkOpen(rc, "otato") rc, err = o.Open(context.Background(), &fs.RangeOption{Start: 1, End: 4096}) assert.NoError(t, err) checkOpen(rc, "otato") rc, err = o.Open(context.Background(), &fs.RangeOption{Start: -1, End: 4}) assert.NoError(t, err) checkOpen(rc, "tato") rc, err = o.Open(context.Background(), &fs.SeekOption{Offset: 3}) assert.NoError(t, err) checkOpen(rc, "ato") rc, err = o.Open(context.Background(), &fs.SeekOption{Offset: -100}) assert.NoError(t, err) checkOpen(rc, "potato") // check it fits within the buffer newNow = now.Add(2 * time.Minute) newContent := bytes.NewBufferString("Rutabaga") assert.True(t, newContent.Len() < cap(content)) // fits within cap(content) src := object.NewStaticObjectInfo(remote, newNow, int64(newContent.Len()), true, nil, nil) err = o.Update(context.Background(), newContent, src) assert.NoError(t, err) checkContent(o, "Rutabaga") assert.Equal(t, newNow, o.ModTime(context.Background())) assert.Equal(t, "Rutaba", string(content)) // check we reused the buffer // not within the buffer newStr := "0123456789" newStr = newStr + newStr + newStr + newStr + newStr + newStr + newStr + newStr + newStr + newStr newContent = bytes.NewBufferString(newStr) assert.True(t, newContent.Len() > cap(content)) // does not fit within cap(content) src = object.NewStaticObjectInfo(remote, newNow, int64(newContent.Len()), true, nil, nil) err = o.Update(context.Background(), newContent, src) assert.NoError(t, err) checkContent(o, newStr) assert.Equal(t, "Rutaba", string(content)) // check we didn't reuse the buffer // now try streaming newStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" newContent = bytes.NewBufferString(newStr) src = object.NewStaticObjectInfo(remote, newNow, -1, true, nil, nil) err = o.Update(context.Background(), newContent, src) assert.NoError(t, err) checkContent(o, newStr) // and zero length newStr = "" newContent = bytes.NewBufferString(newStr) src = object.NewStaticObjectInfo(remote, newNow, 0, true, nil, nil) err = o.Update(context.Background(), newContent, src) assert.NoError(t, err) checkContent(o, newStr) err = o.Remove(context.Background()) assert.Error(t, err) } rclone-v1.71.0/fs/open_options.go000066400000000000000000000220661505210326400167270ustar00rootroot00000000000000// Options for Open package fs import ( "context" "errors" "fmt" "net/http" "strconv" "strings" "github.com/rclone/rclone/fs/hash" ) // OpenOption is an interface describing options for Open type OpenOption interface { fmt.Stringer // Header returns the option as an HTTP header Header() (key string, value string) // Mandatory returns whether this option can be ignored or not Mandatory() bool } // RangeOption defines an HTTP Range option with start and end. If // either start or end are < 0 then they will be omitted. // // End may be bigger than the Size of the object in which case it will // be capped to the size of the object. // // Note that the End is inclusive, so to fetch 100 bytes you would use // RangeOption{Start: 0, End: 99} // // If Start is specified but End is not then it will fetch from Start // to the end of the file. // // If End is specified, but Start is not then it will fetch the last // End bytes. // // Examples: // // RangeOption{Start: 0, End: 99} - fetch the first 100 bytes // RangeOption{Start: 100, End: 199} - fetch the second 100 bytes // RangeOption{Start: 100, End: -1} - fetch bytes from offset 100 to the end // RangeOption{Start: -1, End: 100} - fetch the last 100 bytes // // A RangeOption implements a single byte-range-spec from // https://tools.ietf.org/html/rfc7233#section-2.1 type RangeOption struct { Start int64 End int64 } // Header formats the option as an http header func (o *RangeOption) Header() (key string, value string) { key = "Range" value = "bytes=" if o.Start >= 0 { value += strconv.FormatInt(o.Start, 10) } value += "-" if o.End >= 0 { value += strconv.FormatInt(o.End, 10) } return key, value } // ParseRangeOption parses a RangeOption from a Range: header. // It only accepts single ranges. func ParseRangeOption(s string) (po *RangeOption, err error) { const preamble = "bytes=" if !strings.HasPrefix(s, preamble) { return nil, errors.New("range: header invalid: doesn't start with " + preamble) } s = s[len(preamble):] if strings.ContainsRune(s, ',') { return nil, errors.New("range: header invalid: contains multiple ranges which isn't supported") } dash := strings.IndexRune(s, '-') if dash < 0 { return nil, errors.New("range: header invalid: contains no '-'") } start, end := strings.TrimSpace(s[:dash]), strings.TrimSpace(s[dash+1:]) o := RangeOption{Start: -1, End: -1} if start != "" { o.Start, err = strconv.ParseInt(start, 10, 64) if err != nil || o.Start < 0 { return nil, errors.New("range: header invalid: bad start") } } if end != "" { o.End, err = strconv.ParseInt(end, 10, 64) if err != nil || o.End < 0 { return nil, errors.New("range: header invalid: bad end") } } return &o, nil } // String formats the option into human-readable form func (o *RangeOption) String() string { return fmt.Sprintf("RangeOption(%d,%d)", o.Start, o.End) } // Mandatory returns whether the option must be parsed or can be ignored func (o *RangeOption) Mandatory() bool { return true } // Decode interprets the RangeOption into an offset and a limit // // The offset is the start of the stream and the limit is how many // bytes should be read from it. If the limit is -1 then the stream // should be read to the end. func (o *RangeOption) Decode(size int64) (offset, limit int64) { if o.Start >= 0 { offset = o.Start if o.End >= 0 { limit = o.End - o.Start + 1 } else { limit = -1 } } else { if o.End >= 0 { offset = size - o.End } else { offset = 0 } limit = -1 } return offset, limit } // FixRangeOption looks through the slice of options and adjusts any // RangeOption~s found that request a fetch from the end into an // absolute fetch using the size passed in and makes sure the range does // not exceed filesize. Some remotes (e.g. Onedrive, Box) don't support // range requests which index from the end. // // It also adjusts any SeekOption~s, turning them into absolute // RangeOption~s instead. func FixRangeOption(options []OpenOption, size int64) { if size < 0 { // Can't do anything for unknown length objects return } else if size == 0 { // if size 0 then remove RangeOption~s // replacing with a NullOptions~s which won't be rendered for i := range options { if _, ok := options[i].(*RangeOption); ok { options[i] = NullOption{} } } return } for i, option := range options { switch x := option.(type) { case *RangeOption: // If start is < 0 then fetch from the end if x.Start < 0 { x = &RangeOption{Start: size - x.End, End: -1} options[i] = x } // If end is too big or undefined, fetch to the end if x.End > size || x.End < 0 { x = &RangeOption{Start: x.Start, End: size - 1} options[i] = x } case *SeekOption: options[i] = &RangeOption{Start: x.Offset, End: size - 1} } } } // SeekOption defines an HTTP Range option with start only. type SeekOption struct { Offset int64 } // Header formats the option as an http header func (o *SeekOption) Header() (key string, value string) { key = "Range" value = fmt.Sprintf("bytes=%d-", o.Offset) return key, value } // String formats the option into human-readable form func (o *SeekOption) String() string { return fmt.Sprintf("SeekOption(%d)", o.Offset) } // Mandatory returns whether the option must be parsed or can be ignored func (o *SeekOption) Mandatory() bool { return true } // HTTPOption defines a general purpose HTTP option type HTTPOption struct { Key string Value string } // Header formats the option as an http header func (o *HTTPOption) Header() (key string, value string) { return o.Key, o.Value } // String formats the option into human-readable form func (o *HTTPOption) String() string { return fmt.Sprintf("HTTPOption(%q,%q)", o.Key, o.Value) } // Mandatory returns whether the option must be parsed or can be ignored func (o *HTTPOption) Mandatory() bool { return false } // HashesOption defines an option used to tell the local fs to limit // the number of hashes it calculates. type HashesOption struct { Hashes hash.Set } // Header formats the option as an http header func (o *HashesOption) Header() (key string, value string) { return "", "" } // String formats the option into human-readable form func (o *HashesOption) String() string { return fmt.Sprintf("HashesOption(%v)", o.Hashes) } // Mandatory returns whether the option must be parsed or can be ignored func (o *HashesOption) Mandatory() bool { return false } // NullOption defines an Option which does nothing type NullOption struct { } // Header formats the option as an http header func (o NullOption) Header() (key string, value string) { return "", "" } // String formats the option into human-readable form func (o NullOption) String() string { return "NullOption()" } // Mandatory returns whether the option must be parsed or can be ignored func (o NullOption) Mandatory() bool { return false } // MetadataOption defines an Option which does nothing type MetadataOption Metadata // Header formats the option as an http header func (o MetadataOption) Header() (key string, value string) { return "", "" } // String formats the option into human-readable form func (o MetadataOption) String() string { return fmt.Sprintf("MetadataOption(%v)", Metadata(o)) } // Mandatory returns whether the option must be parsed or can be ignored func (o MetadataOption) Mandatory() bool { return false } // MetadataAsOpenOptions fetch any metadata to set as open options func MetadataAsOpenOptions(ctx context.Context) (options []OpenOption) { ci := GetConfig(ctx) if ci.MetadataSet != nil { options = append(options, MetadataOption(ci.MetadataSet)) } return options } // ChunkOption defines an Option which returns a preferred chunk size type ChunkOption struct { ChunkSize int64 } // Header formats the option as an http header func (o *ChunkOption) Header() (key string, value string) { return "", "" } // Mandatory returns whether the option must be parsed or can be ignored func (o *ChunkOption) Mandatory() bool { return false } // String formats the option into human-readable form func (o *ChunkOption) String() string { return fmt.Sprintf("ChunkOption(%v)", o.ChunkSize) } // OpenOptionAddHeaders adds each header found in options to the // headers map provided the key was non empty. func OpenOptionAddHeaders(options []OpenOption, headers map[string]string) { for _, option := range options { key, value := option.Header() if key != "" && value != "" { headers[key] = value } } } // OpenOptionHeaders adds each header found in options to the // headers map provided the key was non empty. // // It returns a nil map if options was empty func OpenOptionHeaders(options []OpenOption) (headers map[string]string) { if len(options) == 0 { return nil } headers = make(map[string]string, len(options)) OpenOptionAddHeaders(options, headers) return headers } // OpenOptionAddHTTPHeaders Sets each header found in options to the // http.Header map provided the key was non empty. func OpenOptionAddHTTPHeaders(headers http.Header, options []OpenOption) { for _, option := range options { key, value := option.Header() if key != "" && value != "" { headers.Set(key, value) } } } rclone-v1.71.0/fs/open_options_test.go000066400000000000000000000170221505210326400177620ustar00rootroot00000000000000package fs import ( "fmt" "net/http" "testing" "github.com/rclone/rclone/fs/hash" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestParseRangeOption(t *testing.T) { for _, test := range []struct { in string want RangeOption err string }{ {in: "", err: "doesn't start with bytes="}, {in: "bytes=1-2,3-4", err: "contains multiple ranges"}, {in: "bytes=100", err: "contains no '-'"}, {in: "bytes=x-8", err: "bad start"}, {in: "bytes=8-x", err: "bad end"}, {in: "bytes=1-2", want: RangeOption{Start: 1, End: 2}}, {in: "bytes=-123456789123456789", want: RangeOption{Start: -1, End: 123456789123456789}}, {in: "bytes=123456789123456789-", want: RangeOption{Start: 123456789123456789, End: -1}}, {in: "bytes= 1 - 2 ", want: RangeOption{Start: 1, End: 2}}, {in: "bytes=-", want: RangeOption{Start: -1, End: -1}}, {in: "bytes= - ", want: RangeOption{Start: -1, End: -1}}, } { got, err := ParseRangeOption(test.in) what := fmt.Sprintf("parsing %q", test.in) if test.err != "" { require.Contains(t, err.Error(), test.err) require.Nil(t, got, what) } else { require.NoError(t, err, what) assert.Equal(t, test.want, *got, what) } } } func TestRangeOptionDecode(t *testing.T) { for _, test := range []struct { in RangeOption size int64 wantOffset int64 wantLimit int64 }{ {in: RangeOption{Start: 1, End: 10}, size: 100, wantOffset: 1, wantLimit: 10}, {in: RangeOption{Start: 10, End: 10}, size: 100, wantOffset: 10, wantLimit: 1}, {in: RangeOption{Start: 10, End: 9}, size: 100, wantOffset: 10, wantLimit: 0}, {in: RangeOption{Start: 1, End: -1}, size: 100, wantOffset: 1, wantLimit: -1}, {in: RangeOption{Start: -1, End: 90}, size: 100, wantOffset: 10, wantLimit: -1}, {in: RangeOption{Start: -1, End: -1}, size: 100, wantOffset: 0, wantLimit: -1}, } { gotOffset, gotLimit := test.in.Decode(test.size) what := fmt.Sprintf("%+v size=%d", test.in, test.size) assert.Equal(t, test.wantOffset, gotOffset, "offset "+what) assert.Equal(t, test.wantLimit, gotLimit, "limit "+what) } } func TestRangeOption(t *testing.T) { opt := &RangeOption{Start: 1, End: 10} var _ OpenOption = opt // check interface assert.Equal(t, "RangeOption(1,10)", opt.String()) key, value := opt.Header() assert.Equal(t, "Range", key) assert.Equal(t, "bytes=1-10", value) assert.Equal(t, true, opt.Mandatory()) opt = &RangeOption{Start: -1, End: 10} assert.Equal(t, "RangeOption(-1,10)", opt.String()) key, value = opt.Header() assert.Equal(t, "Range", key) assert.Equal(t, "bytes=-10", value) assert.Equal(t, true, opt.Mandatory()) opt = &RangeOption{Start: 1, End: -1} assert.Equal(t, "RangeOption(1,-1)", opt.String()) key, value = opt.Header() assert.Equal(t, "Range", key) assert.Equal(t, "bytes=1-", value) assert.Equal(t, true, opt.Mandatory()) opt = &RangeOption{Start: -1, End: -1} assert.Equal(t, "RangeOption(-1,-1)", opt.String()) key, value = opt.Header() assert.Equal(t, "Range", key) assert.Equal(t, "bytes=-", value) assert.Equal(t, true, opt.Mandatory()) } func TestSeekOption(t *testing.T) { opt := &SeekOption{Offset: 1} var _ OpenOption = opt // check interface assert.Equal(t, "SeekOption(1)", opt.String()) key, value := opt.Header() assert.Equal(t, "Range", key) assert.Equal(t, "bytes=1-", value) assert.Equal(t, true, opt.Mandatory()) } func TestHTTPOption(t *testing.T) { opt := &HTTPOption{Key: "k", Value: "v"} var _ OpenOption = opt // check interface assert.Equal(t, `HTTPOption("k","v")`, opt.String()) key, value := opt.Header() assert.Equal(t, "k", key) assert.Equal(t, "v", value) assert.Equal(t, false, opt.Mandatory()) } func TestHashesOption(t *testing.T) { opt := &HashesOption{hash.Set(hash.MD5 | hash.SHA1)} var _ OpenOption = opt // check interface assert.Equal(t, `HashesOption([md5, sha1])`, opt.String()) key, value := opt.Header() assert.Equal(t, "", key) assert.Equal(t, "", value) assert.Equal(t, false, opt.Mandatory()) } func TestNullOption(t *testing.T) { opt := NullOption{} var _ OpenOption = opt // check interface assert.Equal(t, "NullOption()", opt.String()) key, value := opt.Header() assert.Equal(t, "", key) assert.Equal(t, "", value) assert.Equal(t, false, opt.Mandatory()) } func TestMetadataOption(t *testing.T) { opt := MetadataOption{"onion": "ice cream"} var _ OpenOption = opt // check interface assert.Equal(t, "MetadataOption(map[onion:ice cream])", opt.String()) key, value := opt.Header() assert.Equal(t, "", key) assert.Equal(t, "", value) assert.Equal(t, false, opt.Mandatory()) } func TestFixRangeOptions(t *testing.T) { for _, test := range []struct { name string in []OpenOption size int64 want []OpenOption }{ { name: "Nil options", in: nil, want: nil, }, { name: "Empty options", in: []OpenOption{}, want: []OpenOption{}, }, { name: "Unknown size -1", in: []OpenOption{ &RangeOption{Start: 1, End: -1}, }, want: []OpenOption{ &RangeOption{Start: 1, End: -1}, }, size: -1, }, { name: "Fetch a range with size=0", in: []OpenOption{ &HTTPOption{Key: "a", Value: "1"}, &RangeOption{Start: 1, End: 10}, &HTTPOption{Key: "b", Value: "2"}, }, want: []OpenOption{ &HTTPOption{Key: "a", Value: "1"}, NullOption{}, &HTTPOption{Key: "b", Value: "2"}, }, size: 0, }, { name: "Fetch a range", in: []OpenOption{ &HTTPOption{Key: "a", Value: "1"}, &RangeOption{Start: 1, End: 10}, &HTTPOption{Key: "b", Value: "2"}, }, want: []OpenOption{ &HTTPOption{Key: "a", Value: "1"}, &RangeOption{Start: 1, End: 10}, &HTTPOption{Key: "b", Value: "2"}, }, size: 100, }, { name: "Fetch to end", in: []OpenOption{ &RangeOption{Start: 1, End: -1}, }, want: []OpenOption{ &RangeOption{Start: 1, End: 99}, }, size: 100, }, { name: "Fetch the last 10 bytes", in: []OpenOption{ &RangeOption{Start: -1, End: 10}, }, want: []OpenOption{ &RangeOption{Start: 90, End: 99}, }, size: 100, }, { name: "Fetch with end bigger than size", in: []OpenOption{ &RangeOption{Start: 10, End: 200}, }, want: []OpenOption{ &RangeOption{Start: 10, End: 99}, }, size: 100, }, { name: "SeekOption", in: []OpenOption{ &HTTPOption{Key: "a", Value: "1"}, &SeekOption{Offset: 10}, &HTTPOption{Key: "b", Value: "2"}, }, want: []OpenOption{ &HTTPOption{Key: "a", Value: "1"}, &RangeOption{Start: 10, End: 99}, &HTTPOption{Key: "b", Value: "2"}, }, size: 100, }, } { FixRangeOption(test.in, test.size) assert.Equal(t, test.want, test.in, test.name) } } var testOpenOptions = []OpenOption{ &HTTPOption{Key: "a", Value: "1"}, &RangeOption{Start: 1, End: 10}, &HTTPOption{Key: "b", Value: "2"}, NullOption{}, &HashesOption{hash.Set(hash.MD5 | hash.SHA1)}, } func TestOpenOptionAddHeaders(t *testing.T) { m := map[string]string{} want := map[string]string{ "a": "1", "Range": "bytes=1-10", "b": "2", } OpenOptionAddHeaders(testOpenOptions, m) assert.Equal(t, want, m) } func TestOpenOptionHeaders(t *testing.T) { want := map[string]string{ "a": "1", "Range": "bytes=1-10", "b": "2", } m := OpenOptionHeaders(testOpenOptions) assert.Equal(t, want, m) assert.Nil(t, OpenOptionHeaders([]OpenOption{})) } func TestOpenOptionAddHTTPHeaders(t *testing.T) { headers := http.Header{} want := http.Header{ "A": {"1"}, "Range": {"bytes=1-10"}, "B": {"2"}, } OpenOptionAddHTTPHeaders(headers, testOpenOptions) assert.Equal(t, want, headers) } rclone-v1.71.0/fs/operations/000077500000000000000000000000001505210326400160415ustar00rootroot00000000000000rclone-v1.71.0/fs/operations/check.go000066400000000000000000000424201505210326400174470ustar00rootroot00000000000000package operations import ( "bufio" "bytes" "context" "errors" "fmt" "io" "os" "regexp" "strings" "sync" "sync/atomic" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/march" "github.com/rclone/rclone/lib/readers" "golang.org/x/text/unicode/norm" ) // checkFn is the type of the checking function used in CheckFn() // // It should check the two objects (a, b) and return if they differ // and whether the hash was used. // // If there are differences then this should Errorf the difference and // the reason but return with err = nil. It should not CountError in // this case. type checkFn func(ctx context.Context, a, b fs.Object) (differ bool, noHash bool, err error) // CheckOpt contains options for the Check functions type CheckOpt struct { Fdst, Fsrc fs.Fs // fses to check Check checkFn // function to use for checking OneWay bool // one way only? Combined io.Writer // a file with file names with leading sigils MissingOnSrc io.Writer // files only in the destination MissingOnDst io.Writer // files only in the source Match io.Writer // matching files Differ io.Writer // differing files Error io.Writer // files with errors of some kind } // checkMarch is used to march over two Fses in the same way as // sync/copy type checkMarch struct { ctx context.Context ioMu sync.Mutex wg sync.WaitGroup tokens chan struct{} differences atomic.Int32 noHashes atomic.Int32 srcFilesMissing atomic.Int32 dstFilesMissing atomic.Int32 matches atomic.Int32 opt CheckOpt } // report outputs the fileName to out if required and to the combined log func (c *checkMarch) report(o fs.DirEntry, out io.Writer, sigil rune) { c.reportFilename(o.String(), out, sigil) } func (c *checkMarch) reportFilename(filename string, out io.Writer, sigil rune) { if out != nil { SyncFprintf(out, "%s\n", filename) } if c.opt.Combined != nil { SyncFprintf(c.opt.Combined, "%c %s\n", sigil, filename) } } // DstOnly have an object which is in the destination only func (c *checkMarch) DstOnly(dst fs.DirEntry) (recurse bool) { switch dst.(type) { case fs.Object: if c.opt.OneWay { return false } err := fmt.Errorf("file not in %v", c.opt.Fsrc) fs.Errorf(dst, "%v", err) _ = fs.CountError(c.ctx, err) c.differences.Add(1) c.srcFilesMissing.Add(1) c.report(dst, c.opt.MissingOnSrc, '-') case fs.Directory: // Do the same thing to the entire contents of the directory if c.opt.OneWay { return false } return true default: panic("Bad object in DirEntries") } return false } // SrcOnly have an object which is in the source only func (c *checkMarch) SrcOnly(src fs.DirEntry) (recurse bool) { switch src.(type) { case fs.Object: err := fmt.Errorf("file not in %v", c.opt.Fdst) fs.Errorf(src, "%v", err) _ = fs.CountError(c.ctx, err) c.differences.Add(1) c.dstFilesMissing.Add(1) c.report(src, c.opt.MissingOnDst, '+') case fs.Directory: // Do the same thing to the entire contents of the directory return true default: panic("Bad object in DirEntries") } return false } // check to see if two objects are identical using the check function func (c *checkMarch) checkIdentical(ctx context.Context, dst, src fs.Object) (differ bool, noHash bool, err error) { ci := fs.GetConfig(ctx) tr := accounting.Stats(ctx).NewCheckingTransfer(src, "checking") defer func() { tr.Done(ctx, err) }() if sizeDiffers(ctx, src, dst) { err = fmt.Errorf("sizes differ") fs.Errorf(src, "%v", err) return true, false, nil } if ci.SizeOnly { return false, false, nil } return c.opt.Check(ctx, dst, src) } // Match is called when src and dst are present, so sync src to dst func (c *checkMarch) Match(ctx context.Context, dst, src fs.DirEntry) (recurse bool) { switch srcX := src.(type) { case fs.Object: dstX, ok := dst.(fs.Object) if ok { if SkipDestructive(ctx, src, "check") { return false } c.wg.Add(1) c.tokens <- struct{}{} // put a token to limit concurrency go func() { defer func() { <-c.tokens // get the token back to free up a slot c.wg.Done() }() differ, noHash, err := c.checkIdentical(ctx, dstX, srcX) if err != nil { fs.Errorf(src, "%v", err) _ = fs.CountError(ctx, err) c.report(src, c.opt.Error, '!') } else if differ { c.differences.Add(1) err := errors.New("files differ") // the checkFn has already logged the reason _ = fs.CountError(ctx, err) c.report(src, c.opt.Differ, '*') } else { c.matches.Add(1) c.report(src, c.opt.Match, '=') if noHash { c.noHashes.Add(1) fs.Debugf(dstX, "OK - could not check hash") } else { fs.Debugf(dstX, "OK") } } }() } else { err := fmt.Errorf("is file on %v but directory on %v", c.opt.Fsrc, c.opt.Fdst) fs.Errorf(src, "%v", err) _ = fs.CountError(ctx, err) c.differences.Add(1) c.dstFilesMissing.Add(1) c.report(src, c.opt.MissingOnDst, '+') } case fs.Directory: // Do the same thing to the entire contents of the directory _, ok := dst.(fs.Directory) if ok { return true } err := fmt.Errorf("is file on %v but directory on %v", c.opt.Fdst, c.opt.Fsrc) fs.Errorf(dst, "%v", err) _ = fs.CountError(ctx, err) c.differences.Add(1) c.srcFilesMissing.Add(1) c.report(dst, c.opt.MissingOnSrc, '-') default: panic("Bad object in DirEntries") } return false } // CheckFn checks the files in fsrc and fdst according to Size and // hash using checkFunction on each file to check the hashes. // // checkFunction sees if dst and src are identical // // it returns true if differences were found // it also returns whether it couldn't be hashed func CheckFn(ctx context.Context, opt *CheckOpt) error { ci := fs.GetConfig(ctx) if opt.Check == nil { return errors.New("internal error: nil check function") } c := &checkMarch{ ctx: ctx, tokens: make(chan struct{}, ci.Checkers), opt: *opt, } // set up a march over fdst and fsrc m := &march.March{ Ctx: ctx, Fdst: c.opt.Fdst, Fsrc: c.opt.Fsrc, Dir: "", Callback: c, NoTraverse: ci.NoTraverse, NoUnicodeNormalization: ci.NoUnicodeNormalization, } fs.Debugf(c.opt.Fdst, "Waiting for checks to finish") err := m.Run(ctx) c.wg.Wait() // wait for background go-routines return c.reportResults(ctx, err) } func (c *checkMarch) reportResults(ctx context.Context, err error) error { if c.dstFilesMissing.Load() > 0 { fs.Logf(c.opt.Fdst, "%d files missing", c.dstFilesMissing.Load()) } if c.srcFilesMissing.Load() > 0 { entity := "files" if c.opt.Fsrc == nil { entity = "hashes" } fs.Logf(c.opt.Fsrc, "%d %s missing", c.srcFilesMissing.Load(), entity) } fs.Logf(c.opt.Fdst, "%d differences found", c.differences.Load()) if errs := accounting.Stats(ctx).GetErrors(); errs > 0 { fs.Logf(c.opt.Fdst, "%d errors while checking", errs) } if c.noHashes.Load() > 0 { fs.Logf(c.opt.Fdst, "%d hashes could not be checked", c.noHashes.Load()) } if c.matches.Load() > 0 { fs.Logf(c.opt.Fdst, "%d matching files", c.matches.Load()) } if err != nil { return err } if c.differences.Load() > 0 { // Return an already counted error so we don't double count this error too err = fserrors.FsError(fmt.Errorf("%d differences found", c.differences.Load())) fserrors.Count(err) return err } return nil } // Check the files in fsrc and fdst according to Size and hash func Check(ctx context.Context, opt *CheckOpt) error { optCopy := *opt optCopy.Check = func(ctx context.Context, dst, src fs.Object) (differ bool, noHash bool, err error) { same, ht, err := CheckHashes(ctx, src, dst) if err != nil { return true, false, err } if ht == hash.None { return false, true, nil } if !same { err = fmt.Errorf("%v differ", ht) fs.Errorf(src, "%v", err) return true, false, nil } return false, false, nil } return CheckFn(ctx, &optCopy) } // CheckEqualReaders checks to see if in1 and in2 have the same // content when read. // // it returns true if differences were found func CheckEqualReaders(in1, in2 io.Reader) (differ bool, err error) { const bufSize = 64 * 1024 buf1 := make([]byte, bufSize) buf2 := make([]byte, bufSize) for { n1, err1 := readers.ReadFill(in1, buf1) n2, err2 := readers.ReadFill(in2, buf2) // check errors if err1 != nil && err1 != io.EOF { return true, err1 } else if err2 != nil && err2 != io.EOF { return true, err2 } // err1 && err2 are nil or io.EOF here // process the data if n1 != n2 || !bytes.Equal(buf1[:n1], buf2[:n2]) { return true, nil } // if both streams finished the we have finished if err1 == io.EOF && err2 == io.EOF { break } } return false, nil } // CheckIdenticalDownload checks to see if dst and src are identical // by reading all their bytes if necessary. // // it returns true if differences were found func CheckIdenticalDownload(ctx context.Context, dst, src fs.Object) (differ bool, err error) { ci := fs.GetConfig(ctx) err = Retry(ctx, src, ci.LowLevelRetries, func() error { differ, err = checkIdenticalDownload(ctx, dst, src) return err }) return differ, err } // Does the work for CheckIdenticalDownload func checkIdenticalDownload(ctx context.Context, dst, src fs.Object) (differ bool, err error) { var in1, in2 io.ReadCloser in1, err = Open(ctx, dst) if err != nil { return true, fmt.Errorf("failed to open %q: %w", dst, err) } tr1 := accounting.Stats(ctx).NewTransfer(dst, nil) defer func() { tr1.Done(ctx, nil) // error handling is done by the caller }() in1 = tr1.Account(ctx, in1).WithBuffer() // account and buffer the transfer in2, err = Open(ctx, src) if err != nil { return true, fmt.Errorf("failed to open %q: %w", src, err) } tr2 := accounting.Stats(ctx).NewTransfer(dst, nil) defer func() { tr2.Done(ctx, nil) // error handling is done by the caller }() in2 = tr2.Account(ctx, in2).WithBuffer() // account and buffer the transfer // To assign err variable before defer. differ, err = CheckEqualReaders(in1, in2) return } // CheckDownload checks the files in fsrc and fdst according to Size // and the actual contents of the files. func CheckDownload(ctx context.Context, opt *CheckOpt) error { optCopy := *opt optCopy.Check = func(ctx context.Context, a, b fs.Object) (differ bool, noHash bool, err error) { differ, err = CheckIdenticalDownload(ctx, a, b) if err != nil { return true, true, fmt.Errorf("failed to download: %w", err) } return differ, false, nil } return CheckFn(ctx, &optCopy) } // ApplyTransforms handles --no-unicode-normalization and --ignore-case-sync for CheckSum // so that it matches behavior of Check (where it's handled by March) func ApplyTransforms(ctx context.Context, s string) string { ci := fs.GetConfig(ctx) return ToNormal(s, !ci.NoUnicodeNormalization, ci.IgnoreCaseSync) } // ToNormal normalizes case and unicode form and returns the transformed string. // It is similar to ApplyTransforms but does not use a context. // If normUnicode == true, s will be transformed to NFC. // If normCase == true, s will be transformed to lowercase. // If both are true, both transformations will be performed. func ToNormal(s string, normUnicode, normCase bool) string { if normUnicode { s = norm.NFC.String(s) } if normCase { s = strings.ToLower(s) } return s } // CheckSum checks filesystem hashes against a SUM file func CheckSum(ctx context.Context, fsrc, fsum fs.Fs, sumFile string, hashType hash.Type, opt *CheckOpt, download bool) error { var options CheckOpt if opt != nil { options = *opt } else { // default options for hashsum -c options.Combined = os.Stdout } // CheckSum treats Fsrc and Fdst specially: options.Fsrc = nil // no file system here, corresponds to the sum list options.Fdst = fsrc // denotes the file system to check opt = &options // override supplied argument if !download && (hashType == hash.None || !opt.Fdst.Hashes().Contains(hashType)) { return fmt.Errorf("%s: hash type is not supported by file system: %s", hashType, opt.Fdst) } if sumFile == "" { return fmt.Errorf("not a sum file: %s", fsum) } sumObj, err := fsum.NewObject(ctx, sumFile) if err != nil { return fmt.Errorf("cannot open sum file: %w", err) } hashes, err := ParseSumFile(ctx, sumObj) if err != nil { return fmt.Errorf("failed to parse sum file: %w", err) } ci := fs.GetConfig(ctx) c := &checkMarch{ ctx: ctx, tokens: make(chan struct{}, ci.Checkers), opt: *opt, } lastErr := ListFn(ctx, opt.Fdst, func(obj fs.Object) { c.checkSum(ctx, obj, download, hashes, hashType) }) c.wg.Wait() // wait for background go-routines // make census of unhandled sums fi := filter.GetConfig(ctx) for filename, hash := range hashes { if hash == "" { // the sum has been successfully consumed continue } if !fi.IncludeRemote(filename) { // the file was filtered out continue } // filesystem missed the file, sum wasn't consumed err := fmt.Errorf("file not in %v", opt.Fdst) fs.Errorf(filename, "%v", err) _ = fs.CountError(ctx, err) if lastErr == nil { lastErr = err } c.dstFilesMissing.Add(1) c.reportFilename(filename, opt.MissingOnDst, '+') } return c.reportResults(ctx, lastErr) } // checkSum checks single object against golden hashes func (c *checkMarch) checkSum(ctx context.Context, obj fs.Object, download bool, hashes HashSums, hashType hash.Type) { normalizedRemote := ApplyTransforms(ctx, obj.Remote()) c.ioMu.Lock() sumHash, sumFound := hashes[normalizedRemote] hashes[normalizedRemote] = "" // mark sum as consumed c.ioMu.Unlock() if !sumFound && c.opt.OneWay { return } var err error tr := accounting.Stats(ctx).NewCheckingTransfer(obj, "hashing") defer tr.Done(ctx, err) if !sumFound { err = errors.New("sum not found") _ = fs.CountError(ctx, err) fs.Errorf(obj, "%v", err) c.differences.Add(1) c.srcFilesMissing.Add(1) c.report(obj, c.opt.MissingOnSrc, '-') return } if !download { var objHash string objHash, err = obj.Hash(ctx, hashType) c.matchSum(ctx, sumHash, objHash, obj, err, hashType) return } c.wg.Add(1) c.tokens <- struct{}{} // put a token to limit concurrency go func() { var ( objHash string err error in io.ReadCloser ) defer func() { c.matchSum(ctx, sumHash, objHash, obj, err, hashType) <-c.tokens // get the token back to free up a slot c.wg.Done() }() if in, err = Open(ctx, obj); err != nil { return } tr := accounting.Stats(ctx).NewTransfer(obj, nil) in = tr.Account(ctx, in).WithBuffer() // account and buffer the transfer defer func() { tr.Done(ctx, nil) // will close the stream }() hashVals, err2 := hash.StreamTypes(in, hash.NewHashSet(hashType)) if err2 != nil { err = err2 // pass to matchSum return } objHash = hashVals[hashType] }() } // matchSum sums up the results of hashsum matching for an object func (c *checkMarch) matchSum(ctx context.Context, sumHash, objHash string, obj fs.Object, err error, hashType hash.Type) { switch { case err != nil: _ = fs.CountError(ctx, err) fs.Errorf(obj, "Failed to calculate hash: %v", err) c.report(obj, c.opt.Error, '!') case sumHash == "": err = errors.New("duplicate file") _ = fs.CountError(ctx, err) fs.Errorf(obj, "%v", err) c.report(obj, c.opt.Error, '!') case objHash == "": fs.Debugf(nil, "%v = %s (sum)", hashType, sumHash) fs.Debugf(obj, "%v - could not check hash (%v)", hashType, c.opt.Fdst) c.noHashes.Add(1) c.matches.Add(1) c.report(obj, c.opt.Match, '=') case objHash == sumHash: fs.Debugf(obj, "%v = %s OK", hashType, sumHash) c.matches.Add(1) c.report(obj, c.opt.Match, '=') default: err = errors.New("files differ") _ = fs.CountError(ctx, err) fs.Debugf(nil, "%v = %s (sum)", hashType, sumHash) fs.Debugf(obj, "%v = %s (%v)", hashType, objHash, c.opt.Fdst) fs.Errorf(obj, "%v", err) c.differences.Add(1) c.report(obj, c.opt.Differ, '*') } } // HashSums represents a parsed SUM file type HashSums map[string]string // ParseSumFile parses a hash SUM file and returns hashes as a map func ParseSumFile(ctx context.Context, sumFile fs.Object) (HashSums, error) { rd, err := Open(ctx, sumFile) if err != nil { return nil, err } parser := bufio.NewReader(rd) const maxWarn = 3 numWarn := 0 re := regexp.MustCompile(`^([^ ]+) [ *](.+)$`) hashes := HashSums{} for lineNo := 0; true; lineNo++ { lineBytes, _, err := parser.ReadLine() if err == io.EOF { break } if err != nil { return nil, err } line := string(lineBytes) if line == "" { continue } fields := re.FindStringSubmatch(ApplyTransforms(ctx, line)) if fields == nil { numWarn++ if numWarn <= maxWarn { fs.Logf(sumFile, "improperly formatted checksum line %d", lineNo) } continue } sum, file := fields[1], fields[2] if hashes[file] != "" { numWarn++ if numWarn <= maxWarn { fs.Logf(sumFile, "duplicate file on checksum line %d", lineNo) } continue } // We've standardised on lower case checksums in rclone internals. hashes[file] = strings.ToLower(sum) } if numWarn > maxWarn { fs.Logf(sumFile, "%d warning(s) suppressed...", numWarn-maxWarn) } if err = rd.Close(); err != nil { return nil, err } return hashes, nil } rclone-v1.71.0/fs/operations/check_test.go000066400000000000000000000436651505210326400205220ustar00rootroot00000000000000package operations_test import ( "bytes" "context" "errors" "fmt" "io" "sort" "strings" "testing" "github.com/rclone/rclone/cmd/bisync/bilib" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/lib/readers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "golang.org/x/text/unicode/norm" ) func testCheck(t *testing.T, checkFunction func(ctx context.Context, opt *operations.CheckOpt) error) { r := fstest.NewRun(t) ctx := context.Background() ci := fs.GetConfig(ctx) addBuffers := func(opt *operations.CheckOpt) { opt.Combined = new(bytes.Buffer) opt.MissingOnSrc = new(bytes.Buffer) opt.MissingOnDst = new(bytes.Buffer) opt.Match = new(bytes.Buffer) opt.Differ = new(bytes.Buffer) opt.Error = new(bytes.Buffer) } sortLines := func(in string) []string { if in == "" { return []string{} } lines := strings.Split(in, "\n") sort.Strings(lines) return lines } checkBuffer := func(name string, want map[string]string, out io.Writer) { expected := want[name] buf, ok := out.(*bytes.Buffer) require.True(t, ok) assert.Equal(t, sortLines(expected), sortLines(buf.String()), name) } checkBuffers := func(opt *operations.CheckOpt, want map[string]string) { checkBuffer("combined", want, opt.Combined) checkBuffer("missingonsrc", want, opt.MissingOnSrc) checkBuffer("missingondst", want, opt.MissingOnDst) checkBuffer("match", want, opt.Match) checkBuffer("differ", want, opt.Differ) checkBuffer("error", want, opt.Error) } check := func(i int, wantErrors int64, wantChecks int64, oneway bool, wantOutput map[string]string) { t.Run(fmt.Sprintf("%d", i), func(t *testing.T) { accounting.GlobalStats().ResetCounters() opt := operations.CheckOpt{ Fdst: r.Fremote, Fsrc: r.Flocal, OneWay: oneway, } addBuffers(&opt) var err error buf := bilib.CaptureOutput(func() { err = checkFunction(ctx, &opt) }) gotErrors := accounting.GlobalStats().GetErrors() gotChecks := accounting.GlobalStats().GetChecks() if wantErrors == 0 && err != nil { t.Errorf("%d: Got error when not expecting one: %v", i, err) } if wantErrors != 0 && err == nil { t.Errorf("%d: No error when expecting one", i) } if wantErrors != gotErrors { t.Errorf("%d: Expecting %d errors but got %d", i, wantErrors, gotErrors) } if gotChecks > 0 && !strings.Contains(string(buf), "matching files") { t.Errorf("%d: Total files matching line missing", i) } if wantChecks != gotChecks { t.Errorf("%d: Expecting %d total matching files but got %d", i, wantChecks, gotChecks) } checkBuffers(&opt, wantOutput) }) } file1 := r.WriteBoth(ctx, "rutabaga", "is tasty", t3) r.CheckRemoteItems(t, file1) r.CheckLocalItems(t, file1) check(1, 0, 1, false, map[string]string{ "combined": "= rutabaga\n", "missingonsrc": "", "missingondst": "", "match": "rutabaga\n", "differ": "", "error": "", }) file2 := r.WriteFile("potato2", "------------------------------------------------------------", t1) r.CheckLocalItems(t, file1, file2) check(2, 1, 1, false, map[string]string{ "combined": "+ potato2\n= rutabaga\n", "missingonsrc": "", "missingondst": "potato2\n", "match": "rutabaga\n", "differ": "", "error": "", }) file3 := r.WriteObject(ctx, "empty space", "-", t2) r.CheckRemoteItems(t, file1, file3) check(3, 2, 1, false, map[string]string{ "combined": "- empty space\n+ potato2\n= rutabaga\n", "missingonsrc": "empty space\n", "missingondst": "potato2\n", "match": "rutabaga\n", "differ": "", "error": "", }) file2r := file2 if ci.SizeOnly { file2r = r.WriteObject(ctx, "potato2", "--Some-Differences-But-Size-Only-Is-Enabled-----------------", t1) } else { r.WriteObject(ctx, "potato2", "------------------------------------------------------------", t1) } r.CheckRemoteItems(t, file1, file2r, file3) check(4, 1, 2, false, map[string]string{ "combined": "- empty space\n= potato2\n= rutabaga\n", "missingonsrc": "empty space\n", "missingondst": "", "match": "rutabaga\npotato2\n", "differ": "", "error": "", }) file3r := file3 file3l := r.WriteFile("empty space", "DIFFER", t2) r.CheckLocalItems(t, file1, file2, file3l) check(5, 1, 3, false, map[string]string{ "combined": "* empty space\n= potato2\n= rutabaga\n", "missingonsrc": "", "missingondst": "", "match": "potato2\nrutabaga\n", "differ": "empty space\n", "error": "", }) file4 := r.WriteObject(ctx, "remotepotato", "------------------------------------------------------------", t1) r.CheckRemoteItems(t, file1, file2r, file3r, file4) check(6, 2, 3, false, map[string]string{ "combined": "* empty space\n= potato2\n= rutabaga\n- remotepotato\n", "missingonsrc": "remotepotato\n", "missingondst": "", "match": "potato2\nrutabaga\n", "differ": "empty space\n", "error": "", }) check(7, 1, 3, true, map[string]string{ "combined": "* empty space\n= potato2\n= rutabaga\n", "missingonsrc": "", "missingondst": "", "match": "potato2\nrutabaga\n", "differ": "empty space\n", "error": "", }) } func TestCheck(t *testing.T) { testCheck(t, operations.Check) } func TestCheckFsError(t *testing.T) { ctx := context.Background() dstFs, err := fs.NewFs(ctx, "nonexistent") if err != nil { t.Fatal(err) } srcFs, err := fs.NewFs(ctx, "nonexistent") if err != nil { t.Fatal(err) } opt := operations.CheckOpt{ Fdst: dstFs, Fsrc: srcFs, OneWay: false, } err = operations.Check(ctx, &opt) require.Error(t, err) } func TestCheckDownload(t *testing.T) { testCheck(t, operations.CheckDownload) } func TestCheckSizeOnly(t *testing.T) { ctx := context.Background() ci := fs.GetConfig(ctx) ci.SizeOnly = true defer func() { ci.SizeOnly = false }() TestCheck(t) } func TestCheckEqualReaders(t *testing.T) { b65a := make([]byte, 65*1024) b65b := make([]byte, 65*1024) b65b[len(b65b)-1] = 1 b66 := make([]byte, 66*1024) differ, err := operations.CheckEqualReaders(bytes.NewBuffer(b65a), bytes.NewBuffer(b65a)) assert.NoError(t, err) assert.Equal(t, differ, false) differ, err = operations.CheckEqualReaders(bytes.NewBuffer(b65a), bytes.NewBuffer(b65b)) assert.NoError(t, err) assert.Equal(t, differ, true) differ, err = operations.CheckEqualReaders(bytes.NewBuffer(b65a), bytes.NewBuffer(b66)) assert.NoError(t, err) assert.Equal(t, differ, true) differ, err = operations.CheckEqualReaders(bytes.NewBuffer(b66), bytes.NewBuffer(b65a)) assert.NoError(t, err) assert.Equal(t, differ, true) myErr := errors.New("sentinel") wrap := func(b []byte) io.Reader { r := bytes.NewBuffer(b) e := readers.ErrorReader{Err: myErr} return io.MultiReader(r, e) } differ, err = operations.CheckEqualReaders(wrap(b65a), bytes.NewBuffer(b65a)) assert.Equal(t, myErr, err) assert.Equal(t, differ, true) differ, err = operations.CheckEqualReaders(wrap(b65a), bytes.NewBuffer(b65b)) assert.Equal(t, myErr, err) assert.Equal(t, differ, true) differ, err = operations.CheckEqualReaders(wrap(b65a), bytes.NewBuffer(b66)) assert.Equal(t, myErr, err) assert.Equal(t, differ, true) differ, err = operations.CheckEqualReaders(wrap(b66), bytes.NewBuffer(b65a)) assert.Equal(t, myErr, err) assert.Equal(t, differ, true) differ, err = operations.CheckEqualReaders(bytes.NewBuffer(b65a), wrap(b65a)) assert.Equal(t, myErr, err) assert.Equal(t, differ, true) differ, err = operations.CheckEqualReaders(bytes.NewBuffer(b65a), wrap(b65b)) assert.Equal(t, myErr, err) assert.Equal(t, differ, true) differ, err = operations.CheckEqualReaders(bytes.NewBuffer(b65a), wrap(b66)) assert.Equal(t, myErr, err) assert.Equal(t, differ, true) differ, err = operations.CheckEqualReaders(bytes.NewBuffer(b66), wrap(b65a)) assert.Equal(t, myErr, err) assert.Equal(t, differ, true) } func TestParseSumFile(t *testing.T) { r := fstest.NewRun(t) ctx := context.Background() const sumFile = "test.sum" samples := []struct { hash, sep, name string ok bool }{ {"1", " ", "file1", true}, {"2", " *", "file2", true}, {"3", " ", " file3 ", true}, {"4", " ", "\tfile3\t", true}, {"5", " ", "file5", false}, {"6", "\t", "file6", false}, {"7", " \t", " file7 ", false}, {"", " ", "file8", false}, {"", "", "file9", false}, } for _, eol := range []string{"\n", "\r\n"} { data := &bytes.Buffer{} wantNum := 0 for _, s := range samples { _, _ = data.WriteString(s.hash + s.sep + s.name + eol) if s.ok { wantNum++ } } _ = r.WriteObject(ctx, sumFile, data.String(), t1) file := fstest.NewObject(ctx, t, r.Fremote, sumFile) sums, err := operations.ParseSumFile(ctx, file) assert.NoError(t, err) assert.Equal(t, wantNum, len(sums)) for _, s := range samples { if s.ok { assert.Equal(t, s.hash, sums[s.name]) } } } } func testCheckSum(t *testing.T, download bool) { const dataDir = "data" const sumFile = "test.sum" hashType := hash.MD5 const ( testString1 = "Hello, World!" testDigest1 = "65a8e27d8879283831b664bd8b7f0ad4" testDigest1Upper = "65A8E27D8879283831B664BD8B7F0AD4" testString2 = "I am the walrus" testDigest2 = "87396e030ef3f5b35bbf85c0a09a4fb3" testDigest2Mixed = "87396e030EF3f5b35BBf85c0a09a4FB3" ) type wantType map[string]string ctx := context.Background() r := fstest.NewRun(t) subRemote := r.FremoteName if !strings.HasSuffix(subRemote, ":") { subRemote += "/" } subRemote += dataDir dataFs, err := fs.NewFs(ctx, subRemote) require.NoError(t, err) if !download && !dataFs.Hashes().Contains(hashType) { t.Skipf("%s lacks %s, skipping", dataFs, hashType) } makeFile := func(name, content string) fstest.Item { remote := dataDir + "/" + name return r.WriteObject(ctx, remote, content, t1) } makeSums := func(sums operations.HashSums) fstest.Item { files := make([]string, 0, len(sums)) for name := range sums { files = append(files, name) } sort.Strings(files) buf := &bytes.Buffer{} for _, name := range files { _, _ = fmt.Fprintf(buf, "%s %s\n", sums[name], name) } return r.WriteObject(ctx, sumFile, buf.String(), t1) } sortLines := func(in string) []string { if in == "" { return []string{} } lines := strings.Split(in, "\n") sort.Strings(lines) return lines } checkResult := func(runNo int, want wantType, name string, out io.Writer) { expected := want[name] buf, ok := out.(*bytes.Buffer) require.True(t, ok) assert.Equal(t, sortLines(expected), sortLines(buf.String()), "wrong %s result in run %d", name, runNo) } checkRun := func(runNo, wantChecks, wantErrors int, want wantType) { accounting.GlobalStats().ResetCounters() opt := operations.CheckOpt{ Combined: new(bytes.Buffer), Match: new(bytes.Buffer), Differ: new(bytes.Buffer), Error: new(bytes.Buffer), MissingOnSrc: new(bytes.Buffer), MissingOnDst: new(bytes.Buffer), } var err error buf := bilib.CaptureOutput(func() { err = operations.CheckSum(ctx, dataFs, r.Fremote, sumFile, hashType, &opt, download) }) gotErrors := int(accounting.GlobalStats().GetErrors()) if wantErrors == 0 { assert.NoError(t, err, "unexpected error in run %d", runNo) } if wantErrors > 0 { assert.Error(t, err, "no expected error in run %d", runNo) } assert.Equal(t, wantErrors, gotErrors, "wrong error count in run %d", runNo) gotChecks := int(accounting.GlobalStats().GetChecks()) if wantChecks > 0 || gotChecks > 0 { assert.Contains(t, string(buf), "matching files", "missing matching files in run %d", runNo) } assert.Equal(t, wantChecks, gotChecks, "wrong number of checks in run %d", runNo) checkResult(runNo, want, "combined", opt.Combined) checkResult(runNo, want, "missingonsrc", opt.MissingOnSrc) checkResult(runNo, want, "missingondst", opt.MissingOnDst) checkResult(runNo, want, "match", opt.Match) checkResult(runNo, want, "differ", opt.Differ) checkResult(runNo, want, "error", opt.Error) } check := func(runNo, wantChecks, wantErrors int, wantResults wantType) { runName := fmt.Sprintf("subtest%d", runNo) t.Run(runName, func(t *testing.T) { checkRun(runNo, wantChecks, wantErrors, wantResults) }) } file1 := makeFile("banana", testString1) fcsums := makeSums(operations.HashSums{ "banana": testDigest1, }) r.CheckRemoteItems(t, fcsums, file1) check(1, 1, 0, wantType{ "combined": "= banana\n", "missingonsrc": "", "missingondst": "", "match": "banana\n", "differ": "", "error": "", }) file2 := makeFile("potato", testString2) fcsums = makeSums(operations.HashSums{ "banana": testDigest1, }) r.CheckRemoteItems(t, fcsums, file1, file2) check(2, 2, 1, wantType{ "combined": "- potato\n= banana\n", "missingonsrc": "potato\n", "missingondst": "", "match": "banana\n", "differ": "", "error": "", }) fcsums = makeSums(operations.HashSums{ "banana": testDigest1, "potato": testDigest2, }) r.CheckRemoteItems(t, fcsums, file1, file2) check(3, 2, 0, wantType{ "combined": "= potato\n= banana\n", "missingonsrc": "", "missingondst": "", "match": "banana\npotato\n", "differ": "", "error": "", }) fcsums = makeSums(operations.HashSums{ "banana": testDigest2, "potato": testDigest2, }) r.CheckRemoteItems(t, fcsums, file1, file2) check(4, 2, 1, wantType{ "combined": "* banana\n= potato\n", "missingonsrc": "", "missingondst": "", "match": "potato\n", "differ": "banana\n", "error": "", }) fcsums = makeSums(operations.HashSums{ "banana": testDigest1, "potato": testDigest2, "orange": testDigest2, }) r.CheckRemoteItems(t, fcsums, file1, file2) check(5, 2, 1, wantType{ "combined": "+ orange\n= potato\n= banana\n", "missingonsrc": "", "missingondst": "orange\n", "match": "banana\npotato\n", "differ": "", "error": "", }) fcsums = makeSums(operations.HashSums{ "banana": testDigest1, "potato": testDigest1, "orange": testDigest2, }) r.CheckRemoteItems(t, fcsums, file1, file2) check(6, 2, 2, wantType{ "combined": "+ orange\n* potato\n= banana\n", "missingonsrc": "", "missingondst": "orange\n", "match": "banana\n", "differ": "potato\n", "error": "", }) // test mixed-case checksums file1 = makeFile("banana", testString1) file2 = makeFile("potato", testString2) fcsums = makeSums(operations.HashSums{ "banana": testDigest1Upper, "potato": testDigest2Mixed, }) r.CheckRemoteItems(t, fcsums, file1, file2) check(7, 2, 0, wantType{ "combined": "= banana\n= potato\n", "missingonsrc": "", "missingondst": "", "match": "banana\npotato\n", "differ": "", "error": "", }) } func TestCheckSum(t *testing.T) { testCheckSum(t, false) } func TestCheckSumDownload(t *testing.T) { testCheckSum(t, true) } func TestApplyTransforms(t *testing.T) { var ( hashType = hash.MD5 content = "Hello, World!" hash = "65a8e27d8879283831b664bd8b7f0ad4" nfc = norm.NFC.String(norm.NFD.String("測試_Русский___ě_áñ")) nfd = norm.NFD.String(nfc) nfcx2 = nfc + nfc nfdx2 = nfd + nfd both = nfc + nfd upper = "HELLO, WORLD!" lower = "hello, world!" upperlowermixed = "HeLlO, wOrLd!" ) testScenario := func(checkfileName, remotefileName, scenario string) { r := fstest.NewRunIndividual(t) ctx := context.Background() ci := fs.GetConfig(ctx) opt := operations.CheckOpt{} remotefile := r.WriteObject(ctx, remotefileName, content, t2) // test whether remote is capable of running test entries, err := r.Fremote.List(ctx, "") assert.NoError(t, err) if entries.Len() == 1 && entries[0].Remote() != remotefileName { t.Skipf("Fs is incapable of running test, skipping: %s (expected: %s (%s) actual: %s (%s))", scenario, remotefileName, detectEncoding(remotefileName), entries[0].Remote(), detectEncoding(entries[0].Remote())) } checkfile := r.WriteFile("test.sum", hash+" "+checkfileName, t2) r.CheckLocalItems(t, checkfile) assert.False(t, checkfileName == remotefile.Path, "Values match but should not: %s %s", checkfileName, remotefile.Path) testname := scenario + " (without normalization)" println(testname) ci.NoUnicodeNormalization = true ci.IgnoreCaseSync = false accounting.GlobalStats().ResetCounters() err = operations.CheckSum(ctx, r.Fremote, r.Flocal, "test.sum", hashType, &opt, true) assert.Error(t, err, "no expected error for %s %v %v", testname, checkfileName, remotefileName) testname = scenario + " (with normalization)" println(testname) ci.NoUnicodeNormalization = false ci.IgnoreCaseSync = true accounting.GlobalStats().ResetCounters() err = operations.CheckSum(ctx, r.Fremote, r.Flocal, "test.sum", hashType, &opt, true) assert.NoError(t, err, "unexpected error for %s %v %v", testname, checkfileName, remotefileName) } testScenario(upper, lower, "upper checkfile vs. lower remote") testScenario(lower, upper, "lower checkfile vs. upper remote") testScenario(lower, upperlowermixed, "lower checkfile vs. upperlowermixed remote") testScenario(upperlowermixed, upper, "upperlowermixed checkfile vs. upper remote") testScenario(nfd, nfc, "NFD checkfile vs. NFC remote") testScenario(nfc, nfd, "NFC checkfile vs. NFD remote") testScenario(nfdx2, both, "NFDx2 checkfile vs. both remote") testScenario(nfcx2, both, "NFCx2 checkfile vs. both remote") testScenario(both, nfdx2, "both checkfile vs. NFDx2 remote") testScenario(both, nfcx2, "both checkfile vs. NFCx2 remote") } func detectEncoding(s string) string { if norm.NFC.IsNormalString(s) && norm.NFD.IsNormalString(s) { return "BOTH" } if !norm.NFC.IsNormalString(s) && norm.NFD.IsNormalString(s) { return "NFD" } if norm.NFC.IsNormalString(s) && !norm.NFD.IsNormalString(s) { return "NFC" } return "OTHER" } rclone-v1.71.0/fs/operations/copy.go000066400000000000000000000320671505210326400173520ustar00rootroot00000000000000// This file implements operations.Copy // // This is probably the most important operation in rclone. package operations import ( "context" "errors" "fmt" "hash/crc32" "io" "path" "strings" "time" "unicode/utf8" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/lib/atexit" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/transform" ) // State of the copy type copy struct { f fs.Fs // destination fs.Fs dstFeatures *fs.Features // Features() for fs.Fs dst fs.Object // destination object to update, may be nil remote string // destination path, used if dst is nil src fs.Object // source object ci *fs.ConfigInfo // current config maxTries int // max number of tries to do the copy doUpdate bool // whether we are updating an existing file or not hashType hash.Type // common hash to use hashOption *fs.HashesOption // open option for the common hash tr *accounting.Transfer // accounting for the transfer inplace bool // set if we are updating inplace and not using a partial name remoteForCopy string // the name used for the transfer, either remote or remote+".partial" } // Used to remove a failed copy func (c *copy) removeFailedCopy(ctx context.Context, o fs.Object) { if o == nil { return } fs.Infof(o, "Removing failed copy") err := o.Remove(ctx) if err != nil { fs.Infof(o, "Failed to remove failed copy: %s", err) } } // Used to remove a failed partial copy func (c *copy) removeFailedPartialCopy(ctx context.Context, f fs.Fs, remote string) { o, err := f.NewObject(ctx, remote) if errors.Is(err, fs.ErrorObjectNotFound) { // Assume object has been deleted return } if err != nil { fs.Infof(remote, "Failed to remove failed partial copy: %s", err) return } c.removeFailedCopy(ctx, o) } // TruncateString s to n bytes. // // If s is valid UTF-8 then this may truncate to fewer than n bytes to // make the returned string also valid UTF-8. func TruncateString(s string, n int) string { truncated := s[:n] if !utf8.ValidString(s) { // If input string wasn't valid UTF-8 then just return the truncation return truncated } for len(truncated) > 0 { if utf8.ValidString(truncated) { return truncated } // Remove 1 byte until valid truncated = truncated[:len(truncated)-1] } return truncated } // Check to see if we should be using a partial name and return the name for the copy and the inplace flag func (c *copy) checkPartial(ctx context.Context) (remoteForCopy string, inplace bool, err error) { remoteForCopy = c.remote if c.ci.Inplace || c.dstFeatures.Move == nil || !c.dstFeatures.PartialUploads || strings.HasSuffix(c.remote, ".rclonelink") { return remoteForCopy, true, nil } if len(c.ci.PartialSuffix) > 16 { return remoteForCopy, true, fmt.Errorf("expecting length of --partial-suffix to be not greater than %d but got %d", 16, len(c.ci.PartialSuffix)) } // Avoid making the leaf name longer if it's already lengthy to avoid // trouble with file name length limits. // generate a stable random suffix by hashing the fingerprint hash := crc32.ChecksumIEEE([]byte(fs.Fingerprint(ctx, c.src, true))) suffix := fmt.Sprintf(".%x%s", hash, c.ci.PartialSuffix) base := path.Base(remoteForCopy) if len(base) > 100 { remoteForCopy = TruncateString(remoteForCopy, len(remoteForCopy)-len(suffix)) + suffix } else { remoteForCopy += suffix } return remoteForCopy, false, nil } // Check to see if we have hit max transfer limits func (c *copy) checkLimits(ctx context.Context) (err error) { if c.ci.MaxTransfer < 0 { return nil } var bytesSoFar int64 if c.ci.CutoffMode == fs.CutoffModeCautious { bytesSoFar = accounting.Stats(ctx).GetBytesWithPending() + c.src.Size() } else { bytesSoFar = accounting.Stats(ctx).GetBytes() } if bytesSoFar >= int64(c.ci.MaxTransfer) { if c.ci.CutoffMode == fs.CutoffModeHard { return accounting.ErrorMaxTransferLimitReachedFatal } return accounting.ErrorMaxTransferLimitReachedGraceful } return nil } // Server side copy c.src to (c.f, c.remoteForCopy) if possible or return fs.ErrorCantCopy if not func (c *copy) serverSideCopy(ctx context.Context) (actionTaken string, newDst fs.Object, err error) { doCopy := c.dstFeatures.Copy serverSideCopyOK := false if doCopy == nil { serverSideCopyOK = false } else if SameConfig(c.src.Fs(), c.f) { serverSideCopyOK = true } else if SameRemoteType(c.src.Fs(), c.f) { serverSideCopyOK = c.dstFeatures.ServerSideAcrossConfigs || c.ci.ServerSideAcrossConfigs } if !serverSideCopyOK { return actionTaken, nil, fs.ErrorCantCopy } in := c.tr.Account(ctx, nil) // account the transfer in.ServerSideTransferStart() newDst, err = doCopy(ctx, c.src, c.remoteForCopy) if err == nil { in.ServerSideCopyEnd(newDst.Size()) // account the bytes for the server-side transfer } _ = in.Close() if errors.Is(err, fs.ErrorCantCopy) { c.tr.Reset(ctx) // skip incomplete accounting - will be overwritten by the manual copy } actionTaken = "Copied (server-side copy)" return actionTaken, newDst, err } // Copy c.src to (c.f, c.remoteForCopy) using multiThreadCopy func (c *copy) multiThreadCopy(ctx context.Context, uploadOptions []fs.OpenOption) (actionTaken string, newDst fs.Object, err error) { newDst, err = multiThreadCopy(ctx, c.f, c.remoteForCopy, c.src, c.ci.MultiThreadStreams, c.tr, uploadOptions...) if c.doUpdate { actionTaken = "Multi-thread Copied (replaced existing)" } else { actionTaken = "Multi-thread Copied (new)" } return actionTaken, newDst, err } // Copy the stream from in to (c.f, c.remoteForCopy) and close it // // Use Rcat to handle both remotes supporting and not supporting PutStream. func (c *copy) rcat(ctx context.Context, in io.ReadCloser) (actionTaken string, newDst fs.Object, err error) { // Make any metadata to pass to rcat var meta fs.Metadata if c.ci.Metadata { meta, err = fs.GetMetadata(ctx, c.src) if err != nil { fs.Errorf(c.src, "Failed to read metadata: %v", err) } } // NB Rcat closes in0 fsrc, ok := c.src.Fs().(fs.Fs) if !ok { fsrc = nil } newDst, err = rcatSrc(ctx, c.f, c.remoteForCopy, in, c.src.ModTime(ctx), meta, fsrc) if c.doUpdate { actionTaken = "Copied (Rcat, replaced existing)" } else { actionTaken = "Copied (Rcat, new)" } return actionTaken, newDst, err } // Copy the stream from in to (c.f, c.remoteForCopy) and close it func (c *copy) updateOrPut(ctx context.Context, in io.ReadCloser, uploadOptions []fs.OpenOption) (actionTaken string, newDst fs.Object, err error) { // account and buffer the transfer inAcc := c.tr.Account(ctx, in).WithBuffer() var wrappedSrc fs.ObjectInfo = c.src // We try to pass the original object if possible if c.src.Remote() != c.remoteForCopy { wrappedSrc = fs.NewOverrideRemote(c.src, c.remoteForCopy) } if c.doUpdate && c.inplace { err = c.dst.Update(ctx, inAcc, wrappedSrc, uploadOptions...) // Make sure newDst is c.dst since we updated it if err == nil { newDst = c.dst } } else { newDst, err = c.f.Put(ctx, inAcc, wrappedSrc, uploadOptions...) } closeErr := inAcc.Close() if err == nil { err = closeErr } if c.doUpdate { actionTaken = "Copied (replaced existing)" } else { actionTaken = "Copied (new)" } return actionTaken, newDst, err } // Do a manual copy by reading the bytes and writing them func (c *copy) manualCopy(ctx context.Context) (actionTaken string, newDst fs.Object, err error) { // Remove partial files on premature exit if !c.inplace { defer atexit.Unregister(atexit.Register(func() { ctx := context.Background() c.removeFailedPartialCopy(ctx, c.f, c.remoteForCopy) })) } // Options for the upload uploadOptions := []fs.OpenOption{c.hashOption} for _, option := range c.ci.UploadHeaders { uploadOptions = append(uploadOptions, option) } if c.ci.MetadataSet != nil { uploadOptions = append(uploadOptions, fs.MetadataOption(c.ci.MetadataSet)) } // Options for the download downloadOptions := []fs.OpenOption{c.hashOption} for _, option := range c.ci.DownloadHeaders { downloadOptions = append(downloadOptions, option) } if doMultiThreadCopy(ctx, c.f, c.src) { return c.multiThreadCopy(ctx, uploadOptions) } var in io.ReadCloser in, err = Open(ctx, c.src, downloadOptions...) if err != nil { return actionTaken, nil, fmt.Errorf("failed to open source object: %w", err) } // Note that c.rcat and c.updateOrPut close in if c.src.Size() == -1 { return c.rcat(ctx, in) } return c.updateOrPut(ctx, in, uploadOptions) } // Verify the copy func (c *copy) verify(ctx context.Context, newDst fs.Object) (err error) { // Verify sizes are the same after transfer if sizeDiffers(ctx, c.src, newDst) { return fmt.Errorf("corrupted on transfer: sizes differ src(%s) %d vs dst(%s) %d", c.src.Fs(), c.src.Size(), newDst.Fs(), newDst.Size()) } // Verify hashes are the same after transfer - ignoring blank hashes if c.hashType != hash.None { // checkHashes has logs and counts errors equal, _, srcSum, dstSum, _ := checkHashes(ctx, c.src, newDst, c.hashType) if !equal { return fmt.Errorf("corrupted on transfer: %v hashes differ src(%s) %q vs dst(%s) %q", c.hashType, c.src.Fs(), srcSum, newDst.Fs(), dstSum) } } return nil } // copy src object to dst or f if nil. If dst is nil then it uses // remote as the name of the new object. // // It returns the destination object if possible. Note that this may // be nil. func (c *copy) copy(ctx context.Context) (newDst fs.Object, err error) { var actionTaken string retry := true for tries := 0; retry && tries < c.maxTries; tries++ { // Check we haven't hit any accounting limits err = c.checkLimits(ctx) if err != nil { return nil, err } // Try server side copy actionTaken, newDst, err = c.serverSideCopy(ctx) // If can't server-side copy, do it manually if errors.Is(err, fs.ErrorCantCopy) { actionTaken, newDst, err = c.manualCopy(ctx) } // End if ctx is in error if fserrors.ContextError(ctx, &err) { break } // Retry if err returned a retry error retry = false if fserrors.IsRetryError(err) || fserrors.ShouldRetry(err) { retry = true } else if t, ok := pacer.IsRetryAfter(err); ok { fs.Debugf(c.src, "Sleeping for %v (as indicated by the server) to obey Retry-After error: %v", t, err) time.Sleep(t) retry = true } if retry { fs.Debugf(c.src, "Received error: %v - low level retry %d/%d", err, tries, c.maxTries) c.tr.Reset(ctx) // skip incomplete accounting - will be overwritten by retry continue } } if err != nil { err = fs.CountError(ctx, err) fs.Errorf(c.src, "Failed to copy: %v", err) if !c.inplace { c.removeFailedPartialCopy(ctx, c.f, c.remoteForCopy) } return newDst, err } // Verify the copy err = c.verify(ctx, newDst) if err != nil { fs.Errorf(newDst, "%v", err) err = fs.CountError(ctx, err) c.removeFailedCopy(ctx, newDst) return nil, err } // Move the copied file to its real destination. if !c.inplace && c.remoteForCopy != c.remote { movedNewDst, err := c.dstFeatures.Move(ctx, newDst, c.remote) if err != nil { fs.Errorf(newDst, "partial file rename failed: %v", err) err = fs.CountError(ctx, err) c.removeFailedCopy(ctx, newDst) return nil, err } fs.Debugf(newDst, "renamed to: %s", c.remote) newDst = movedNewDst } // Log what we have done if newDst != nil && c.src.String() != newDst.String() { actionTaken = fmt.Sprintf("%s to: %s", actionTaken, newDst.String()) } fs.Infof(c.src, "%s%s", actionTaken, fs.LogValueHide("size", fs.SizeSuffix(c.src.Size()))) return newDst, nil } // Copy src object to dst or f if nil. If dst is nil then it uses // remote as the name of the new object. // // It returns the destination object if possible. Note that this may // be nil. func Copy(ctx context.Context, f fs.Fs, dst fs.Object, remote string, src fs.Object) (newDst fs.Object, err error) { ci := fs.GetConfig(ctx) tr := accounting.Stats(ctx).NewTransfer(src, f) defer func() { tr.Done(ctx, err) }() if SkipDestructive(ctx, src, "copy") { in := tr.Account(ctx, nil) in.DryRun(src.Size()) return newDst, nil } c := ©{ f: f, dstFeatures: f.Features(), dst: dst, remote: transform.Path(ctx, remote, false), src: src, ci: ci, tr: tr, maxTries: ci.LowLevelRetries, doUpdate: dst != nil, } c.hashType, c.hashOption = CommonHash(ctx, f, src.Fs()) if c.dst != nil { c.remote = transform.Path(ctx, c.dst.Remote(), false) } // Are we using partials? // // If so set the flag and update the name we use for the copy c.remoteForCopy, c.inplace, err = c.checkPartial(ctx) if err != nil { return nil, err } // Do the copy now everything is set up return c.copy(ctx) } // CopyFile moves a single file possibly to a new name func CopyFile(ctx context.Context, fdst fs.Fs, fsrc fs.Fs, dstFileName string, srcFileName string) (err error) { return moveOrCopyFile(ctx, fdst, fsrc, dstFileName, srcFileName, true, false) } rclone-v1.71.0/fs/operations/copy_test.go000066400000000000000000000347751505210326400204210ustar00rootroot00000000000000package operations_test import ( "context" "crypto/rand" "errors" "fmt" "os" "path" "runtime" "sort" "strings" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fstest" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestTruncateString(t *testing.T) { for _, test := range []struct { in string n int want string }{ { in: "", n: 0, want: "", }, { in: "Hello World", n: 5, want: "Hello", }, { in: "ááááá", n: 5, want: "áá", }, { in: "ááááá\xFF\xFF", n: 5, want: "áá\xc3", }, { in: "世世世世世", n: 7, want: "世世", }, { in: "🙂🙂🙂🙂🙂", n: 16, want: "🙂🙂🙂🙂", }, { in: "🙂🙂🙂🙂🙂", n: 15, want: "🙂🙂🙂", }, { in: "🙂🙂🙂🙂🙂", n: 14, want: "🙂🙂🙂", }, { in: "🙂🙂🙂🙂🙂", n: 13, want: "🙂🙂🙂", }, { in: "🙂🙂🙂🙂🙂", n: 12, want: "🙂🙂🙂", }, { in: "🙂🙂🙂🙂🙂", n: 11, want: "🙂🙂", }, { in: "𝓝𝓸𝓫𝓸𝓭𝔂 𝓲𝓼 𝓱𝓸𝓶𝓮 ᴬ ⱽⁱˢⁱᵗ ᶠʳᵒᵐ ᵗʰᵉ ⱽⁱˢⁱᵒⁿᵃʳʸ", n: 100, want: "𝓝𝓸𝓫𝓸𝓭𝔂 𝓲𝓼 𝓱𝓸𝓶𝓮 ᴬ ⱽⁱˢⁱᵗ ᶠʳᵒᵐ ᵗʰᵉ ⱽⁱˢ", }, { in: "a𝓝𝓸𝓫𝓸𝓭𝔂 𝓲𝓼 𝓱𝓸𝓶𝓮 ᴬ ⱽⁱˢⁱᵗ ᶠʳᵒᵐ ᵗʰᵉ ⱽⁱˢⁱᵒⁿᵃʳʸ", n: 100, want: "a𝓝𝓸𝓫𝓸𝓭𝔂 𝓲𝓼 𝓱𝓸𝓶𝓮 ᴬ ⱽⁱˢⁱᵗ ᶠʳᵒᵐ ᵗʰᵉ ⱽⁱˢ", }, { in: "aa𝓝𝓸𝓫𝓸𝓭𝔂 𝓲𝓼 𝓱𝓸𝓶𝓮 ᴬ ⱽⁱˢⁱᵗ ᶠʳᵒᵐ ᵗʰᵉ ⱽⁱˢⁱᵒⁿᵃʳʸ", n: 100, want: "aa𝓝𝓸𝓫𝓸𝓭𝔂 𝓲𝓼 𝓱𝓸𝓶𝓮 ᴬ ⱽⁱˢⁱᵗ ᶠʳᵒᵐ ᵗʰᵉ ⱽⁱ", }, { in: "aaa𝓝𝓸𝓫𝓸𝓭𝔂 𝓲𝓼 𝓱𝓸𝓶𝓮 ᴬ ⱽⁱˢⁱᵗ ᶠʳᵒᵐ ᵗʰᵉ ⱽⁱˢⁱᵒⁿᵃʳʸ", n: 100, want: "aaa𝓝𝓸𝓫𝓸𝓭𝔂 𝓲𝓼 𝓱𝓸𝓶𝓮 ᴬ ⱽⁱˢⁱᵗ ᶠʳᵒᵐ ᵗʰᵉ ⱽⁱ", }, { in: "aaaa𝓝𝓸𝓫𝓸𝓭𝔂 𝓲𝓼 𝓱𝓸𝓶𝓮 ᴬ ⱽⁱˢⁱᵗ ᶠʳᵒᵐ ᵗʰᵉ ⱽⁱˢⁱᵒⁿᵃʳʸ", n: 100, want: "aaaa𝓝𝓸𝓫𝓸𝓭𝔂 𝓲𝓼 𝓱𝓸𝓶𝓮 ᴬ ⱽⁱˢⁱᵗ ᶠʳᵒᵐ ᵗʰᵉ ⱽ", }, } { got := operations.TruncateString(test.in, test.n) assert.Equal(t, test.want, got, fmt.Sprintf("In %q", test.in)) assert.LessOrEqual(t, len(got), test.n) assert.GreaterOrEqual(t, len(got), test.n-3) } } func TestCopyFile(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteFile("file1", "file1 contents", t1) r.CheckLocalItems(t, file1) file2 := file1 file2.Path = "sub/file2" err := operations.CopyFile(ctx, r.Fremote, r.Flocal, file2.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) err = operations.CopyFile(ctx, r.Fremote, r.Flocal, file2.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) err = operations.CopyFile(ctx, r.Fremote, r.Fremote, file2.Path, file2.Path) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) } // Find the longest file name for writing to local func maxLengthFileName(t *testing.T, r *fstest.Run) string { require.NoError(t, r.Flocal.Mkdir(context.Background(), "")) // create the root const maxLen = 16 * 1024 name := strings.Repeat("A", maxLen) i := sort.Search(len(name), func(i int) (fail bool) { filePath := path.Join(r.LocalName, name[:i]) err := os.WriteFile(filePath, []byte{0}, 0777) if err != nil { return true } err = os.Remove(filePath) if err != nil { t.Logf("Failed to remove test file: %v", err) } return false }) return name[:i-1] } // Check we can copy a file of maximum name length func TestCopyLongFile(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) if !r.Fremote.Features().IsLocal { t.Skip("Test only runs on local") } // Find the maximum length of file we can write name := maxLengthFileName(t, r) t.Logf("Max length of file name is %d", len(name)) file1 := r.WriteFile(name, "file1 contents", t1) r.CheckLocalItems(t, file1) err := operations.CopyFile(ctx, r.Fremote, r.Flocal, file1.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file1) } func TestCopyFileBackupDir(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) if !operations.CanServerSideMove(r.Fremote) { t.Skip("Skipping test as remote does not support server-side move or copy") } ci.BackupDir = r.FremoteName + "/backup" file1 := r.WriteFile("dst/file1", "file1 contents", t1) r.CheckLocalItems(t, file1) file1old := r.WriteObject(ctx, "dst/file1", "file1 contents old", t1) r.CheckRemoteItems(t, file1old) err := operations.CopyFile(ctx, r.Fremote, r.Flocal, file1.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t, file1) file1old.Path = "backup/dst/file1" r.CheckRemoteItems(t, file1old, file1) } // Test with CompareDest set func TestCopyFileCompareDest(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.CompareDest = []string{r.FremoteName + "/CompareDest"} fdst, err := fs.NewFs(ctx, r.FremoteName+"/dst") require.NoError(t, err) // check empty dest, empty compare file1 := r.WriteFile("one", "one", t1) r.CheckLocalItems(t, file1) err = operations.CopyFile(ctx, fdst, r.Flocal, file1.Path, file1.Path) require.NoError(t, err) file1dst := file1 file1dst.Path = "dst/one" r.CheckRemoteItems(t, file1dst) // check old dest, empty compare file1b := r.WriteFile("one", "onet2", t2) r.CheckRemoteItems(t, file1dst) r.CheckLocalItems(t, file1b) err = operations.CopyFile(ctx, fdst, r.Flocal, file1b.Path, file1b.Path) require.NoError(t, err) file1bdst := file1b file1bdst.Path = "dst/one" r.CheckRemoteItems(t, file1bdst) // check old dest, new compare file3 := r.WriteObject(ctx, "dst/one", "one", t1) file2 := r.WriteObject(ctx, "CompareDest/one", "onet2", t2) file1c := r.WriteFile("one", "onet2", t2) r.CheckRemoteItems(t, file2, file3) r.CheckLocalItems(t, file1c) err = operations.CopyFile(ctx, fdst, r.Flocal, file1c.Path, file1c.Path) require.NoError(t, err) r.CheckRemoteItems(t, file2, file3) // check empty dest, new compare file4 := r.WriteObject(ctx, "CompareDest/two", "two", t2) file5 := r.WriteFile("two", "two", t2) r.CheckRemoteItems(t, file2, file3, file4) r.CheckLocalItems(t, file1c, file5) err = operations.CopyFile(ctx, fdst, r.Flocal, file5.Path, file5.Path) require.NoError(t, err) r.CheckRemoteItems(t, file2, file3, file4) // check new dest, new compare err = operations.CopyFile(ctx, fdst, r.Flocal, file5.Path, file5.Path) require.NoError(t, err) r.CheckRemoteItems(t, file2, file3, file4) // check empty dest, old compare file5b := r.WriteFile("two", "twot3", t3) r.CheckRemoteItems(t, file2, file3, file4) r.CheckLocalItems(t, file1c, file5b) err = operations.CopyFile(ctx, fdst, r.Flocal, file5b.Path, file5b.Path) require.NoError(t, err) file5bdst := file5b file5bdst.Path = "dst/two" r.CheckRemoteItems(t, file2, file3, file4, file5bdst) } // Test with CopyDest set func TestCopyFileCopyDest(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) if r.Fremote.Features().Copy == nil { t.Skip("Skipping test as remote does not support server-side copy") } ci.CopyDest = []string{r.FremoteName + "/CopyDest"} fdst, err := fs.NewFs(ctx, r.FremoteName+"/dst") require.NoError(t, err) // check empty dest, empty copy file1 := r.WriteFile("one", "one", t1) r.CheckLocalItems(t, file1) err = operations.CopyFile(ctx, fdst, r.Flocal, file1.Path, file1.Path) require.NoError(t, err) file1dst := file1 file1dst.Path = "dst/one" r.CheckRemoteItems(t, file1dst) // check old dest, empty copy file1b := r.WriteFile("one", "onet2", t2) r.CheckRemoteItems(t, file1dst) r.CheckLocalItems(t, file1b) err = operations.CopyFile(ctx, fdst, r.Flocal, file1b.Path, file1b.Path) require.NoError(t, err) file1bdst := file1b file1bdst.Path = "dst/one" r.CheckRemoteItems(t, file1bdst) // check old dest, new copy, backup-dir ci.BackupDir = r.FremoteName + "/BackupDir" file3 := r.WriteObject(ctx, "dst/one", "one", t1) file2 := r.WriteObject(ctx, "CopyDest/one", "onet2", t2) file1c := r.WriteFile("one", "onet2", t2) r.CheckRemoteItems(t, file2, file3) r.CheckLocalItems(t, file1c) err = operations.CopyFile(ctx, fdst, r.Flocal, file1c.Path, file1c.Path) require.NoError(t, err) file2dst := file2 file2dst.Path = "dst/one" file3.Path = "BackupDir/one" r.CheckRemoteItems(t, file2, file2dst, file3) ci.BackupDir = "" // check empty dest, new copy file4 := r.WriteObject(ctx, "CopyDest/two", "two", t2) file5 := r.WriteFile("two", "two", t2) r.CheckRemoteItems(t, file2, file2dst, file3, file4) r.CheckLocalItems(t, file1c, file5) err = operations.CopyFile(ctx, fdst, r.Flocal, file5.Path, file5.Path) require.NoError(t, err) file4dst := file4 file4dst.Path = "dst/two" r.CheckRemoteItems(t, file2, file2dst, file3, file4, file4dst) // check new dest, new copy err = operations.CopyFile(ctx, fdst, r.Flocal, file5.Path, file5.Path) require.NoError(t, err) r.CheckRemoteItems(t, file2, file2dst, file3, file4, file4dst) // check empty dest, old copy file6 := r.WriteObject(ctx, "CopyDest/three", "three", t2) file7 := r.WriteFile("three", "threet3", t3) r.CheckRemoteItems(t, file2, file2dst, file3, file4, file4dst, file6) r.CheckLocalItems(t, file1c, file5, file7) err = operations.CopyFile(ctx, fdst, r.Flocal, file7.Path, file7.Path) require.NoError(t, err) file7dst := file7 file7dst.Path = "dst/three" r.CheckRemoteItems(t, file2, file2dst, file3, file4, file4dst, file6, file7dst) } func TestCopyInplace(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) if !r.Fremote.Features().PartialUploads { t.Skip("Partial uploads not supported") } ci.Inplace = true file1 := r.WriteFile("file1", "file1 contents", t1) r.CheckLocalItems(t, file1) file2 := file1 file2.Path = "sub/file2" err := operations.CopyFile(ctx, r.Fremote, r.Flocal, file2.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) err = operations.CopyFile(ctx, r.Fremote, r.Flocal, file2.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) err = operations.CopyFile(ctx, r.Fremote, r.Fremote, file2.Path, file2.Path) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) } func TestCopyLongFileName(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) if !r.Fremote.Features().PartialUploads { t.Skip("Partial uploads not supported") } ci.Inplace = false // the default file1 := r.WriteFile("file1", "file1 contents", t1) r.CheckLocalItems(t, file1) file2 := file1 file2.Path = "sub/" + strings.Repeat("file2", 30) err := operations.CopyFile(ctx, r.Fremote, r.Flocal, file2.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) err = operations.CopyFile(ctx, r.Fremote, r.Flocal, file2.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) err = operations.CopyFile(ctx, r.Fremote, r.Fremote, file2.Path, file2.Path) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) } func TestCopyFileMaxTransfer(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) defer accounting.Stats(ctx).ResetCounters() const sizeCutoff = 2048 // Make random incompressible data randomData := make([]byte, sizeCutoff) _, err := rand.Read(randomData) require.NoError(t, err) randomString := string(randomData) file1 := r.WriteFile("TestCopyFileMaxTransfer/file1", "file1 contents", t1) file2 := r.WriteFile("TestCopyFileMaxTransfer/file2", "file2 contents"+randomString, t2) file3 := r.WriteFile("TestCopyFileMaxTransfer/file3", "file3 contents"+randomString, t2) file4 := r.WriteFile("TestCopyFileMaxTransfer/file4", "file4 contents"+randomString, t2) // Cutoff mode: Hard ci.MaxTransfer = sizeCutoff ci.CutoffMode = fs.CutoffModeHard if runtime.GOOS == "darwin" { // disable server-side copies as they don't count towards transfer size stats r.Flocal.Features().Disable("Copy") if r.Fremote.Features().IsLocal { r.Fremote.Features().Disable("Copy") } } // file1: Show a small file gets transferred OK accounting.Stats(ctx).ResetCounters() err = operations.CopyFile(ctx, r.Fremote, r.Flocal, file1.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t, file1, file2, file3, file4) r.CheckRemoteItems(t, file1) // file2: show a large file does not get transferred accounting.Stats(ctx).ResetCounters() err = operations.CopyFile(ctx, r.Fremote, r.Flocal, file2.Path, file2.Path) require.NotNil(t, err, "Did not get expected max transfer limit error") if !errors.Is(err, accounting.ErrorMaxTransferLimitReachedFatal) { t.Log("Expecting error to contain accounting.ErrorMaxTransferLimitReachedFatal") // Sometimes the backends or their SDKs don't pass the // error through properly, so check that it at least // has the text we expect in. assert.Contains(t, err.Error(), "max transfer limit reached") } r.CheckLocalItems(t, file1, file2, file3, file4) r.CheckRemoteItems(t, file1) // Cutoff mode: Cautious ci.CutoffMode = fs.CutoffModeCautious // file3: show a large file does not get transferred accounting.Stats(ctx).ResetCounters() err = operations.CopyFile(ctx, r.Fremote, r.Flocal, file3.Path, file3.Path) require.NotNil(t, err) assert.True(t, errors.Is(err, accounting.ErrorMaxTransferLimitReachedGraceful)) r.CheckLocalItems(t, file1, file2, file3, file4) r.CheckRemoteItems(t, file1) if isChunker(r.Fremote) { t.Log("skipping remainder of test for chunker as it involves multiple transfers") return } // Cutoff mode: Soft ci.CutoffMode = fs.CutoffModeSoft // file4: show a large file does get transferred this time accounting.Stats(ctx).ResetCounters() err = operations.CopyFile(ctx, r.Fremote, r.Flocal, file4.Path, file4.Path) require.NoError(t, err) r.CheckLocalItems(t, file1, file2, file3, file4) r.CheckRemoteItems(t, file1, file4) } rclone-v1.71.0/fs/operations/dedupe.go000066400000000000000000000322631505210326400176440ustar00rootroot00000000000000// dedupe - gets rid of identical files remotes which can have duplicate file names (drive, mega) package operations import ( "context" "fmt" "path" "sort" "strings" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/walk" ) // dedupeRename renames the objs slice to different names func dedupeRename(ctx context.Context, f fs.Fs, remote string, objs []fs.Object) { doMove := f.Features().Move if doMove == nil { fs.Fatalf(nil, "Fs %v doesn't support Move", f) } ext := path.Ext(remote) base := remote[:len(remote)-len(ext)] outer: for i, o := range objs { suffix := 1 newName := fmt.Sprintf("%s-%d%s", base, i+suffix, ext) _, err := f.NewObject(ctx, newName) for ; err != fs.ErrorObjectNotFound; suffix++ { if err != nil { err = fs.CountError(ctx, err) fs.Errorf(o, "Failed to check for existing object: %v", err) continue outer } if suffix > 100 { fs.Errorf(o, "Could not find an available new name") continue outer } newName = fmt.Sprintf("%s-%d%s", base, i+suffix, ext) _, err = f.NewObject(ctx, newName) } if !SkipDestructive(ctx, o, "rename") { newObj, err := doMove(ctx, o, newName) if err != nil { err = fs.CountError(ctx, err) fs.Errorf(o, "Failed to rename: %v", err) continue } fs.Infof(newObj, "renamed from: %v", o) } } } // dedupeDeleteAllButOne deletes all but the one in keep func dedupeDeleteAllButOne(ctx context.Context, keep int, remote string, objs []fs.Object) { count := 0 for i, o := range objs { if i == keep { continue } err := DeleteFile(ctx, o) if err == nil { count++ } } if count > 0 { fs.Logf(remote, "Deleted %d extra copies", count) } } // dedupeDeleteIdentical deletes all but one of identical (by hash) copies func dedupeDeleteIdentical(ctx context.Context, ht hash.Type, remote string, objs []fs.Object) (remainingObjs []fs.Object) { ci := fs.GetConfig(ctx) // Make map of IDs IDs := make(map[string]int, len(objs)) for _, o := range objs { if do, ok := o.(fs.IDer); ok { if ID := do.ID(); ID != "" { IDs[ID]++ } } } // Remove duplicate IDs newObjs := objs[:0] for _, o := range objs { if do, ok := o.(fs.IDer); ok { if ID := do.ID(); ID != "" { if IDs[ID] <= 1 { newObjs = append(newObjs, o) } else { fs.Logf(o, "Ignoring as it appears %d times in the listing and deleting would lead to data loss", IDs[ID]) } } } } objs = newObjs // See how many of these duplicates are identical dupesByID := make(map[string][]fs.Object, len(objs)) for _, o := range objs { ID := "" if ci.SizeOnly && o.Size() >= 0 { ID = fmt.Sprintf("size %d", o.Size()) } else if ht != hash.None { hashValue, err := o.Hash(ctx, ht) if err == nil && hashValue != "" { ID = fmt.Sprintf("%v %s", ht, hashValue) } } if ID == "" { remainingObjs = append(remainingObjs, o) } else { dupesByID[ID] = append(dupesByID[ID], o) } } // Delete identical duplicates, filling remainingObjs with the ones remaining for ID, dupes := range dupesByID { remainingObjs = append(remainingObjs, dupes[0]) if len(dupes) > 1 { fs.Logf(remote, "Deleting %d/%d identical duplicates (%s)", len(dupes)-1, len(dupes), ID) for _, o := range dupes[1:] { err := DeleteFile(ctx, o) if err != nil { remainingObjs = append(remainingObjs, o) } } } } return remainingObjs } // dedupeList lists the duplicates and does nothing func dedupeList(ctx context.Context, f fs.Fs, ht hash.Type, remote string, objs []fs.Object, byHash bool) { fmt.Printf("%s: %d duplicates\n", remote, len(objs)) for i, o := range objs { hashValue := "" if ht != hash.None { var err error hashValue, err = o.Hash(ctx, ht) if err != nil { hashValue = err.Error() } } if byHash { fmt.Printf(" %d: %12d bytes, %s, %s\n", i+1, o.Size(), o.ModTime(ctx).Local().Format("2006-01-02 15:04:05.000000000"), o.Remote()) } else { fmt.Printf(" %d: %12d bytes, %s, %v %32s\n", i+1, o.Size(), o.ModTime(ctx).Local().Format("2006-01-02 15:04:05.000000000"), ht, hashValue) } } } // dedupeInteractive interactively dedupes the slice of objects func dedupeInteractive(ctx context.Context, f fs.Fs, ht hash.Type, remote string, objs []fs.Object, byHash bool) bool { dedupeList(ctx, f, ht, remote, objs, byHash) commands := []string{"sSkip and do nothing", "kKeep just one (choose which in next step)"} if !byHash { commands = append(commands, "rRename all to be different (by changing file.jpg to file-1.jpg)") } commands = append(commands, "qQuit") switch config.Command(commands) { case 's': case 'k': keep := config.ChooseNumber("Enter the number of the file to keep", 1, len(objs)) dedupeDeleteAllButOne(ctx, keep-1, remote, objs) case 'r': dedupeRename(ctx, f, remote, objs) case 'q': return false } return true } // DeduplicateMode is how the dedupe command chooses what to do type DeduplicateMode int // Deduplicate modes const ( DeduplicateInteractive DeduplicateMode = iota // interactively ask the user DeduplicateSkip // skip all conflicts DeduplicateFirst // choose the first object DeduplicateNewest // choose the newest object DeduplicateOldest // choose the oldest object DeduplicateRename // rename the objects DeduplicateLargest // choose the largest object DeduplicateSmallest // choose the smallest object DeduplicateList // list duplicates only ) func (x DeduplicateMode) String() string { switch x { case DeduplicateInteractive: return "interactive" case DeduplicateSkip: return "skip" case DeduplicateFirst: return "first" case DeduplicateNewest: return "newest" case DeduplicateOldest: return "oldest" case DeduplicateRename: return "rename" case DeduplicateLargest: return "largest" case DeduplicateSmallest: return "smallest" case DeduplicateList: return "list" } return "unknown" } // Set a DeduplicateMode from a string func (x *DeduplicateMode) Set(s string) error { switch strings.ToLower(s) { case "interactive": *x = DeduplicateInteractive case "skip": *x = DeduplicateSkip case "first": *x = DeduplicateFirst case "newest": *x = DeduplicateNewest case "oldest": *x = DeduplicateOldest case "rename": *x = DeduplicateRename case "largest": *x = DeduplicateLargest case "smallest": *x = DeduplicateSmallest case "list": *x = DeduplicateList default: return fmt.Errorf("unknown mode for dedupe %q", s) } return nil } // Type of the value func (x *DeduplicateMode) Type() string { return "string" } // Directory with entry count and links to parents type dedupeDir struct { dir fs.Directory parent string count int } // Map of directories by ID with recursive counts type dedupeDirsMap map[string]*dedupeDir func (dm dedupeDirsMap) get(id string) *dedupeDir { d := dm[id] if d == nil { d = &dedupeDir{} dm[id] = d } return d } func (dm dedupeDirsMap) increment(parent string) { if parent != "" { d := dm.get(parent) d.count++ dm.increment(d.parent) } } // dedupeFindDuplicateDirs scans f for duplicate directories func dedupeFindDuplicateDirs(ctx context.Context, f fs.Fs) (duplicateDirs [][]*dedupeDir, err error) { dirsByID := dedupeDirsMap{} dirs := map[string][]*dedupeDir{} ci := fs.GetConfig(ctx) err = walk.ListR(ctx, f, "", false, ci.MaxDepth, walk.ListAll, func(entries fs.DirEntries) error { for _, entry := range entries { tr := accounting.Stats(ctx).NewCheckingTransfer(entry, "merging") remote := entry.Remote() parentRemote := path.Dir(remote) if parentRemote == "." { parentRemote = "" } // Obtain ID of the object parent, if known. // (This usually means that backend allows duplicate paths) // Fall back to remote parent path, if unavailable. var parent string if entryParentIDer, ok := entry.(fs.ParentIDer); ok { parent = entryParentIDer.ParentID() } if parent == "" { parent = parentRemote } var ID string if entryIDer, ok := entry.(fs.IDer); ok { ID = entryIDer.ID() } if ID == "" { ID = remote } if fsDir, ok := entry.(fs.Directory); ok { d := dirsByID.get(ID) d.dir = fsDir d.parent = parent dirs[remote] = append(dirs[remote], d) } dirsByID.increment(parent) tr.Done(ctx, nil) } return nil }) if err != nil { return nil, fmt.Errorf("find duplicate dirs: %w", err) } // Make sure parents are before children duplicateNames := []string{} for name, ds := range dirs { if len(ds) > 1 { duplicateNames = append(duplicateNames, name) } } sort.Strings(duplicateNames) for _, name := range duplicateNames { duplicateDirs = append(duplicateDirs, dirs[name]) } return } // dedupeMergeDuplicateDirs merges all the duplicate directories found func dedupeMergeDuplicateDirs(ctx context.Context, f fs.Fs, duplicateDirs [][]*dedupeDir) error { mergeDirs := f.Features().MergeDirs if mergeDirs == nil { return fmt.Errorf("%v: can't merge directories", f) } dirCacheFlush := f.Features().DirCacheFlush if dirCacheFlush == nil { return fmt.Errorf("%v: can't flush dir cache", f) } for _, dedupeDirs := range duplicateDirs { if SkipDestructive(ctx, dedupeDirs[0].dir, "merge duplicate directories") { continue } // Put largest directory in front to minimize movements fsDirs := []fs.Directory{} largestCount := -1 largestIdx := 0 for i, d := range dedupeDirs { fsDirs = append(fsDirs, d.dir) if d.count > largestCount { largestIdx = i largestCount = d.count } } fsDirs[largestIdx], fsDirs[0] = fsDirs[0], fsDirs[largestIdx] fs.Infof(fsDirs[0], "Merging contents of duplicate directories") err := mergeDirs(ctx, fsDirs) if err != nil { err = fs.CountError(ctx, err) fs.Errorf(nil, "merge duplicate dirs: %v", err) } } dirCacheFlush() return nil } // sort oldest first func sortOldestFirst(objs []fs.Object) { sort.Slice(objs, func(i, j int) bool { return objs[i].ModTime(context.TODO()).Before(objs[j].ModTime(context.TODO())) }) } // sort smallest first func sortSmallestFirst(objs []fs.Object) { sort.Slice(objs, func(i, j int) bool { return objs[i].Size() < objs[j].Size() }) } // Deduplicate interactively finds duplicate files and offers to // delete all but one or rename them to be different. Only useful with // Google Drive which can have duplicate file names. func Deduplicate(ctx context.Context, f fs.Fs, mode DeduplicateMode, byHash bool) error { ci := fs.GetConfig(ctx) // find a hash to use ht := f.Hashes().GetOne() what := "names" if byHash { if ht == hash.None { return fmt.Errorf("%v has no hashes", f) } what = ht.String() + " hashes" } fs.Infof(f, "Looking for duplicate %s using %v mode.", what, mode) // Find duplicate directories first and fix them if !byHash { duplicateDirs, err := dedupeFindDuplicateDirs(ctx, f) if err != nil { return err } if len(duplicateDirs) > 0 { if mode != DeduplicateList { err = dedupeMergeDuplicateDirs(ctx, f, duplicateDirs) if err != nil { return err } } else { for _, dedupeDirs := range duplicateDirs { remote := dedupeDirs[0].dir.Remote() fmt.Printf("%s: %d duplicates of this directory\n", remote, len(dedupeDirs)) } } } } // Now find duplicate files files := map[string][]fs.Object{} err := walk.ListR(ctx, f, "", false, ci.MaxDepth, walk.ListObjects, func(entries fs.DirEntries) error { entries.ForObject(func(o fs.Object) { tr := accounting.Stats(ctx).NewCheckingTransfer(o, "checking") defer tr.Done(ctx, nil) var remote string var err error if byHash { remote, err = o.Hash(ctx, ht) if err != nil { fs.Errorf(o, "Failed to hash: %v", err) remote = "" } } else { remote = o.Remote() } if remote != "" { files[remote] = append(files[remote], o) } }) return nil }) if err != nil { return err } for remote, objs := range files { if len(objs) <= 1 { continue } fs.Logf(remote, "Found %d files with duplicate %s", len(objs), what) if !byHash && mode != DeduplicateList { objs = dedupeDeleteIdentical(ctx, ht, remote, objs) if len(objs) <= 1 { fs.Logf(remote, "All duplicates removed") continue } } switch mode { case DeduplicateInteractive: if !dedupeInteractive(ctx, f, ht, remote, objs, byHash) { return nil } case DeduplicateFirst: dedupeDeleteAllButOne(ctx, 0, remote, objs) case DeduplicateNewest: sortOldestFirst(objs) dedupeDeleteAllButOne(ctx, len(objs)-1, remote, objs) case DeduplicateOldest: sortOldestFirst(objs) dedupeDeleteAllButOne(ctx, 0, remote, objs) case DeduplicateRename: dedupeRename(ctx, f, remote, objs) case DeduplicateLargest: sortSmallestFirst(objs) dedupeDeleteAllButOne(ctx, len(objs)-1, remote, objs) case DeduplicateSmallest: sortSmallestFirst(objs) dedupeDeleteAllButOne(ctx, 0, remote, objs) case DeduplicateSkip: fs.Logf(remote, "Skipping %d files with duplicate %s", len(objs), what) case DeduplicateList: dedupeList(ctx, f, ht, remote, objs, byHash) default: //skip } } return nil } rclone-v1.71.0/fs/operations/dedupe_test.go000066400000000000000000000223521505210326400207010ustar00rootroot00000000000000package operations_test import ( "context" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fs/walk" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/lib/random" "github.com/spf13/pflag" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Check flag satisfies the interface var _ pflag.Value = (*operations.DeduplicateMode)(nil) func skipIfCantDedupe(t *testing.T, f fs.Fs) { if !f.Features().DuplicateFiles { t.Skip("Can't test deduplicate - no duplicate files possible") } if f.Features().PutUnchecked == nil { t.Skip("Can't test deduplicate - no PutUnchecked") } if f.Features().MergeDirs == nil { t.Skip("Can't test deduplicate - no MergeDirs") } } func skipIfNoHash(t *testing.T, f fs.Fs) { if f.Hashes().GetOne() == hash.None { t.Skip("Can't run this test without a hash") } } func skipIfNoModTime(t *testing.T, f fs.Fs) { if f.Precision() >= fs.ModTimeNotSupported { t.Skip("Can't run this test without modtimes") } } func TestDeduplicateInteractive(t *testing.T) { r := fstest.NewRun(t) skipIfCantDedupe(t, r.Fremote) skipIfNoHash(t, r.Fremote) file1 := r.WriteUncheckedObject(context.Background(), "one", "This is one", t1) file2 := r.WriteUncheckedObject(context.Background(), "one", "This is one", t1) file3 := r.WriteUncheckedObject(context.Background(), "one", "This is one", t1) r.CheckWithDuplicates(t, file1, file2, file3) err := operations.Deduplicate(context.Background(), r.Fremote, operations.DeduplicateInteractive, false) require.NoError(t, err) r.CheckRemoteItems(t, file1) } func TestDeduplicateSkip(t *testing.T) { r := fstest.NewRun(t) skipIfCantDedupe(t, r.Fremote) haveHash := r.Fremote.Hashes().GetOne() != hash.None file1 := r.WriteUncheckedObject(context.Background(), "one", "This is one", t1) files := []fstest.Item{file1} if haveHash { file2 := r.WriteUncheckedObject(context.Background(), "one", "This is one", t1) files = append(files, file2) } file3 := r.WriteUncheckedObject(context.Background(), "one", "This is another one", t1) files = append(files, file3) r.CheckWithDuplicates(t, files...) err := operations.Deduplicate(context.Background(), r.Fremote, operations.DeduplicateSkip, false) require.NoError(t, err) r.CheckWithDuplicates(t, file1, file3) } func TestDeduplicateSizeOnly(t *testing.T) { r := fstest.NewRun(t) skipIfCantDedupe(t, r.Fremote) ctx := context.Background() ci := fs.GetConfig(ctx) file1 := r.WriteUncheckedObject(context.Background(), "one", "This is one", t1) file2 := r.WriteUncheckedObject(context.Background(), "one", "THIS IS ONE", t1) file3 := r.WriteUncheckedObject(context.Background(), "one", "This is another one", t1) r.CheckWithDuplicates(t, file1, file2, file3) ci.SizeOnly = true defer func() { ci.SizeOnly = false }() err := operations.Deduplicate(context.Background(), r.Fremote, operations.DeduplicateSkip, false) require.NoError(t, err) r.CheckWithDuplicates(t, file1, file3) } func TestDeduplicateFirst(t *testing.T) { r := fstest.NewRun(t) skipIfCantDedupe(t, r.Fremote) file1 := r.WriteUncheckedObject(context.Background(), "one", "This is one", t1) file2 := r.WriteUncheckedObject(context.Background(), "one", "This is one A", t1) file3 := r.WriteUncheckedObject(context.Background(), "one", "This is one BB", t1) r.CheckWithDuplicates(t, file1, file2, file3) err := operations.Deduplicate(context.Background(), r.Fremote, operations.DeduplicateFirst, false) require.NoError(t, err) // list until we get one object var objects, size int64 for try := 1; try <= *fstest.ListRetries; try++ { objects, size, _, err = operations.Count(context.Background(), r.Fremote) require.NoError(t, err) if objects == 1 { break } time.Sleep(time.Second) } assert.Equal(t, int64(1), objects) if size != file1.Size && size != file2.Size && size != file3.Size { t.Errorf("Size not one of the object sizes %d", size) } } func TestDeduplicateNewest(t *testing.T) { r := fstest.NewRun(t) skipIfCantDedupe(t, r.Fremote) skipIfNoModTime(t, r.Fremote) file1 := r.WriteUncheckedObject(context.Background(), "one", "This is one", t1) file2 := r.WriteUncheckedObject(context.Background(), "one", "This is one too", t2) file3 := r.WriteUncheckedObject(context.Background(), "one", "This is another one", t3) r.CheckWithDuplicates(t, file1, file2, file3) err := operations.Deduplicate(context.Background(), r.Fremote, operations.DeduplicateNewest, false) require.NoError(t, err) r.CheckRemoteItems(t, file3) } func TestDeduplicateNewestByHash(t *testing.T) { r := fstest.NewRun(t) skipIfNoHash(t, r.Fremote) skipIfNoModTime(t, r.Fremote) contents := random.String(100) file1 := r.WriteObject(context.Background(), "one", contents, t1) file2 := r.WriteObject(context.Background(), "also/one", contents, t2) file3 := r.WriteObject(context.Background(), "another", contents, t3) file4 := r.WriteObject(context.Background(), "not-one", "stuff", t3) r.CheckRemoteItems(t, file1, file2, file3, file4) err := operations.Deduplicate(context.Background(), r.Fremote, operations.DeduplicateNewest, true) require.NoError(t, err) r.CheckRemoteItems(t, file3, file4) } func TestDeduplicateOldest(t *testing.T) { r := fstest.NewRun(t) skipIfCantDedupe(t, r.Fremote) file1 := r.WriteUncheckedObject(context.Background(), "one", "This is one", t1) file2 := r.WriteUncheckedObject(context.Background(), "one", "This is one too", t2) file3 := r.WriteUncheckedObject(context.Background(), "one", "This is another one", t3) r.CheckWithDuplicates(t, file1, file2, file3) err := operations.Deduplicate(context.Background(), r.Fremote, operations.DeduplicateOldest, false) require.NoError(t, err) r.CheckRemoteItems(t, file1) } func TestDeduplicateLargest(t *testing.T) { r := fstest.NewRun(t) skipIfCantDedupe(t, r.Fremote) file1 := r.WriteUncheckedObject(context.Background(), "one", "This is one", t1) file2 := r.WriteUncheckedObject(context.Background(), "one", "This is one too", t2) file3 := r.WriteUncheckedObject(context.Background(), "one", "This is another one", t3) r.CheckWithDuplicates(t, file1, file2, file3) err := operations.Deduplicate(context.Background(), r.Fremote, operations.DeduplicateLargest, false) require.NoError(t, err) r.CheckRemoteItems(t, file3) } func TestDeduplicateSmallest(t *testing.T) { r := fstest.NewRun(t) skipIfCantDedupe(t, r.Fremote) file1 := r.WriteUncheckedObject(context.Background(), "one", "This is one", t1) file2 := r.WriteUncheckedObject(context.Background(), "one", "This is one too", t2) file3 := r.WriteUncheckedObject(context.Background(), "one", "This is another one", t3) r.CheckWithDuplicates(t, file1, file2, file3) err := operations.Deduplicate(context.Background(), r.Fremote, operations.DeduplicateSmallest, false) require.NoError(t, err) r.CheckRemoteItems(t, file1) } func TestDeduplicateRename(t *testing.T) { r := fstest.NewRun(t) skipIfCantDedupe(t, r.Fremote) file1 := r.WriteUncheckedObject(context.Background(), "one.txt", "This is one", t1) file2 := r.WriteUncheckedObject(context.Background(), "one.txt", "This is one too", t2) file3 := r.WriteUncheckedObject(context.Background(), "one.txt", "This is another one", t3) file4 := r.WriteUncheckedObject(context.Background(), "one-1.txt", "This is not a duplicate", t1) r.CheckWithDuplicates(t, file1, file2, file3, file4) err := operations.Deduplicate(context.Background(), r.Fremote, operations.DeduplicateRename, false) require.NoError(t, err) require.NoError(t, walk.ListR(context.Background(), r.Fremote, "", true, -1, walk.ListObjects, func(entries fs.DirEntries) error { entries.ForObject(func(o fs.Object) { remote := o.Remote() if remote != "one-1.txt" && remote != "one-2.txt" && remote != "one-3.txt" && remote != "one-4.txt" { t.Errorf("Bad file name after rename %q", remote) } size := o.Size() if size != file1.Size && size != file2.Size && size != file3.Size && size != file4.Size { t.Errorf("Size not one of the object sizes %d", size) } if remote == "one-1.txt" && size != file4.Size { t.Errorf("Existing non-duplicate file modified %q", remote) } }) return nil })) } // This should really be a unit test, but the test framework there // doesn't have enough tools to make it easy func TestMergeDirs(t *testing.T) { r := fstest.NewRun(t) mergeDirs := r.Fremote.Features().MergeDirs if mergeDirs == nil { t.Skip("Can't merge directories") } file1 := r.WriteObject(context.Background(), "dupe1/one.txt", "This is one", t1) file2 := r.WriteObject(context.Background(), "dupe2/two.txt", "This is one too", t2) file3 := r.WriteObject(context.Background(), "dupe3/three.txt", "This is another one", t3) objs, dirs, err := walk.GetAll(context.Background(), r.Fremote, "", true, 1) require.NoError(t, err) assert.Equal(t, 3, len(dirs)) assert.Equal(t, 0, len(objs)) err = mergeDirs(context.Background(), dirs) require.NoError(t, err) file2.Path = "dupe1/two.txt" file3.Path = "dupe1/three.txt" r.CheckRemoteItems(t, file1, file2, file3) objs, dirs, err = walk.GetAll(context.Background(), r.Fremote, "", true, 1) require.NoError(t, err) assert.Equal(t, 1, len(dirs)) assert.Equal(t, 0, len(objs)) assert.Equal(t, "dupe1", dirs[0].Remote()) } rclone-v1.71.0/fs/operations/listdirsorted_test.go000066400000000000000000000101751505210326400223260ustar00rootroot00000000000000package operations_test import ( "context" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/fstest" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // testListDirSorted is integration testing code in fs/list/list.go // which can't be tested there due to import loops. func testListDirSorted(t *testing.T, listFn func(ctx context.Context, f fs.Fs, includeAll bool, dir string) (entries fs.DirEntries, err error)) { r := fstest.NewRun(t) ctx := context.Background() fi := filter.GetConfig(ctx) fi.Opt.MaxSize = 10 defer func() { fi.Opt.MaxSize = -1 }() files := []fstest.Item{ r.WriteObject(context.Background(), "a.txt", "hello world", t1), r.WriteObject(context.Background(), "zend.txt", "hello", t1), r.WriteObject(context.Background(), "sub dir/hello world", "hello world", t1), r.WriteObject(context.Background(), "sub dir/hello world2", "hello world", t1), r.WriteObject(context.Background(), "sub dir/ignore dir/.ignore", "-", t1), r.WriteObject(context.Background(), "sub dir/ignore dir/should be ignored", "to ignore", t1), r.WriteObject(context.Background(), "sub dir/sub sub dir/hello world3", "hello world", t1), } r.CheckRemoteItems(t, files...) var items fs.DirEntries var err error // Turn the DirEntry into a name, ending with a / if it is a // dir str := func(i int) string { item := items[i] name := item.Remote() switch item.(type) { case fs.Object: case fs.Directory: name += "/" default: t.Fatalf("Unknown type %+v", item) } return name } items, err = listFn(context.Background(), r.Fremote, true, "") require.NoError(t, err) require.Len(t, items, 3) assert.Equal(t, "a.txt", str(0)) assert.Equal(t, "sub dir/", str(1)) assert.Equal(t, "zend.txt", str(2)) items, err = listFn(context.Background(), r.Fremote, false, "") require.NoError(t, err) require.Len(t, items, 2) assert.Equal(t, "sub dir/", str(0)) assert.Equal(t, "zend.txt", str(1)) items, err = listFn(context.Background(), r.Fremote, true, "sub dir") require.NoError(t, err) require.Len(t, items, 4) assert.Equal(t, "sub dir/hello world", str(0)) assert.Equal(t, "sub dir/hello world2", str(1)) assert.Equal(t, "sub dir/ignore dir/", str(2)) assert.Equal(t, "sub dir/sub sub dir/", str(3)) items, err = listFn(context.Background(), r.Fremote, false, "sub dir") require.NoError(t, err) require.Len(t, items, 2) assert.Equal(t, "sub dir/ignore dir/", str(0)) assert.Equal(t, "sub dir/sub sub dir/", str(1)) // testing ignore file fi.Opt.ExcludeFile = []string{".ignore"} items, err = listFn(context.Background(), r.Fremote, false, "sub dir") require.NoError(t, err) require.Len(t, items, 1) assert.Equal(t, "sub dir/sub sub dir/", str(0)) items, err = listFn(context.Background(), r.Fremote, false, "sub dir/ignore dir") require.NoError(t, err) require.Len(t, items, 0) items, err = listFn(context.Background(), r.Fremote, true, "sub dir/ignore dir") require.NoError(t, err) require.Len(t, items, 2) assert.Equal(t, "sub dir/ignore dir/.ignore", str(0)) assert.Equal(t, "sub dir/ignore dir/should be ignored", str(1)) fi.Opt.ExcludeFile = nil items, err = listFn(context.Background(), r.Fremote, false, "sub dir/ignore dir") require.NoError(t, err) require.Len(t, items, 2) assert.Equal(t, "sub dir/ignore dir/.ignore", str(0)) assert.Equal(t, "sub dir/ignore dir/should be ignored", str(1)) } // TestListDirSorted is integration testing code in fs/list/list.go // which can't be tested there due to import loops. func TestListDirSorted(t *testing.T) { testListDirSorted(t, list.DirSorted) } // TestListDirSortedFn is integration testing code in fs/list/list.go // which can't be tested there due to import loops. func TestListDirSortedFn(t *testing.T) { listFn := func(ctx context.Context, f fs.Fs, includeAll bool, dir string) (entries fs.DirEntries, err error) { callback := func(newEntries fs.DirEntries) error { entries = append(entries, newEntries...) return nil } err = list.DirSortedFn(ctx, f, includeAll, dir, callback, nil) return entries, err } testListDirSorted(t, listFn) } rclone-v1.71.0/fs/operations/logger.go000066400000000000000000000276741505210326400176670ustar00rootroot00000000000000package operations import ( "bytes" "context" "errors" "fmt" "io" mutex "sync" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/spf13/pflag" ) // Sigil represents the rune (-+=*!?) used by Logger to categorize files by their match/differ/missing status. type Sigil rune // String converts sigil to more human-readable string func (sigil Sigil) String() string { switch sigil { case '-': return "MissingOnSrc" case '+': return "MissingOnDst" case '=': return "Match" case '*': return "Differ" case '!': return "Error" // case '.': // return "Completed" case '?': return "Other" } return "unknown" } // Writer directs traffic from sigil -> LoggerOpt.Writer func (sigil Sigil) Writer(opt LoggerOpt) io.Writer { switch sigil { case '-': return opt.MissingOnSrc case '+': return opt.MissingOnDst case '=': return opt.Match case '*': return opt.Differ case '!': return opt.Error } return nil } // Sigil constants const ( MissingOnSrc Sigil = '-' MissingOnDst Sigil = '+' Match Sigil = '=' Differ Sigil = '*' TransferError Sigil = '!' Other Sigil = '?' // reserved but not currently used ) // LoggerFn uses fs.DirEntry instead of fs.Object so it can include Dirs // For LoggerFn example, see bisync.WriteResults() or sync.SyncLoggerFn() // Usage example: s.logger(ctx, operations.Differ, src, dst, nil) type LoggerFn func(ctx context.Context, sigil Sigil, src, dst fs.DirEntry, err error) type loggerContextKey struct{} type loggerOptContextKey struct{} var loggerKey = loggerContextKey{} var loggerOptKey = loggerOptContextKey{} // LoggerOpt contains options for the Sync Logger functions // TODO: refactor Check in here too? type LoggerOpt struct { // Fdst, Fsrc fs.Fs // fses to check // Check checkFn // function to use for checking // OneWay bool // one way only? LoggerFn LoggerFn // function to use for logging Combined io.Writer // a file with file names with leading sigils MissingOnSrc io.Writer // files only in the destination MissingOnDst io.Writer // files only in the source Match io.Writer // matching files Differ io.Writer // differing files Error io.Writer // files with errors of some kind DestAfter io.Writer // files that exist on the destination post-sync JSON *bytes.Buffer // used by bisync to read/write struct as JSON DeleteModeOff bool //affects whether Logger expects MissingOnSrc to be deleted // lsf options for destAfter ListFormat ListFormat JSONOpt ListJSONOpt LJ *listJSON Format string TimeFormat string Separator string DirSlash bool // Recurse bool HashType hash.Type FilesOnly bool DirsOnly bool Csv bool Absolute bool } // NewDefaultLoggerFn creates a logger function that writes the sigil and path to configured files that match the sigil func NewDefaultLoggerFn(opt *LoggerOpt) LoggerFn { var lock mutex.Mutex return func(ctx context.Context, sigil Sigil, src, dst fs.DirEntry, err error) { lock.Lock() defer lock.Unlock() if err == fs.ErrorIsDir && !opt.FilesOnly && opt.DestAfter != nil { opt.PrintDestAfter(ctx, sigil, src, dst, err) return } _, srcOk := src.(fs.Object) _, dstOk := dst.(fs.Object) var filename string if !srcOk && !dstOk { return } else if srcOk && !dstOk { filename = src.String() } else { filename = dst.String() } if sigil.Writer(*opt) != nil { SyncFprintf(sigil.Writer(*opt), "%s\n", filename) } if opt.Combined != nil { SyncFprintf(opt.Combined, "%c %s\n", sigil, filename) fs.Debugf(nil, "Sync Logger: %s: %c %s\n", sigil.String(), sigil, filename) } if opt.DestAfter != nil { opt.PrintDestAfter(ctx, sigil, src, dst, err) } } } // WithLogger stores logger in ctx and returns a copy of ctx in which loggerKey = logger func WithLogger(ctx context.Context, logger LoggerFn) context.Context { return context.WithValue(ctx, loggerKey, logger) } // WithLoggerOpt stores loggerOpt in ctx and returns a copy of ctx in which loggerOptKey = loggerOpt func WithLoggerOpt(ctx context.Context, loggerOpt LoggerOpt) context.Context { return context.WithValue(ctx, loggerOptKey, loggerOpt) } // GetLogger attempts to retrieve LoggerFn from context, returns it if found, otherwise returns no-op function func GetLogger(ctx context.Context) (LoggerFn, bool) { logger, ok := ctx.Value(loggerKey).(LoggerFn) if !ok { logger = func(ctx context.Context, sigil Sigil, src, dst fs.DirEntry, err error) {} } return logger, ok } // GetLoggerOpt attempts to retrieve LoggerOpt from context, returns it if found, otherwise returns NewLoggerOpt() func GetLoggerOpt(ctx context.Context) LoggerOpt { loggerOpt, ok := ctx.Value(loggerOptKey).(LoggerOpt) if ok { return loggerOpt } return NewLoggerOpt() } // WithSyncLogger starts a new logger with the options passed in and saves it to ctx for retrieval later func WithSyncLogger(ctx context.Context, opt LoggerOpt) context.Context { ctx = WithLoggerOpt(ctx, opt) return WithLogger(ctx, func(ctx context.Context, sigil Sigil, src, dst fs.DirEntry, err error) { if opt.LoggerFn != nil { opt.LoggerFn(ctx, sigil, src, dst, err) } else { SyncFprintf(opt.Combined, "%c %s\n", sigil, dst.Remote()) } }) } // NewLoggerOpt returns a new LoggerOpt struct with defaults func NewLoggerOpt() LoggerOpt { opt := LoggerOpt{ Combined: new(bytes.Buffer), MissingOnSrc: new(bytes.Buffer), MissingOnDst: new(bytes.Buffer), Match: new(bytes.Buffer), Differ: new(bytes.Buffer), Error: new(bytes.Buffer), DestAfter: new(bytes.Buffer), JSON: new(bytes.Buffer), } return opt } // Winner predicts which side (src or dst) should end up winning out on the dst. type Winner struct { Obj fs.DirEntry // the object that should exist on dst post-sync, if any Side string // whether the winning object was from the src or dst Err error // whether there's an error preventing us from predicting winner correctly (not whether there was a sync error more generally) } // WinningSide can be called in a LoggerFn to predict what the dest will look like post-sync // // This attempts to account for every case in which dst (intentionally) does not match src after a sync. // // Known issues / cases we can't confidently predict yet: // // --max-duration / CutoffModeHard // --compare-dest / --copy-dest (because equal() is called multiple times for the same file) // server-side moves of an entire dir at once (because we never get the individual file objects in the dir) // High-level retries, because there would be dupes (use --retries 1 to disable) // Possibly some error scenarios func WinningSide(ctx context.Context, sigil Sigil, src, dst fs.DirEntry, err error) Winner { winner := Winner{nil, "none", nil} opt := GetLoggerOpt(ctx) ci := fs.GetConfig(ctx) if err == fs.ErrorIsDir { winner.Err = err if sigil == MissingOnSrc { if (opt.DeleteModeOff || ci.DryRun) && dst != nil { winner.Obj = dst winner.Side = "dst" // whatever's on dst will remain so after DryRun return winner } return winner // none, because dst should just get deleted } if sigil == MissingOnDst && ci.DryRun { return winner // none, because it does not currently exist on dst, and will still not exist after DryRun } else if ci.DryRun && dst != nil { winner.Obj = dst winner.Side = "dst" } else if src != nil { winner.Obj = src winner.Side = "src" } return winner } _, srcOk := src.(fs.Object) _, dstOk := dst.(fs.Object) if !srcOk && !dstOk { return winner // none, because we don't have enough info to continue. } switch sigil { case MissingOnSrc: if opt.DeleteModeOff || ci.DryRun { // i.e. it's a copy, not sync (or it's a DryRun) winner.Obj = dst winner.Side = "dst" // whatever's on dst will remain so after DryRun return winner } return winner // none, because dst should just get deleted case Match, Differ, MissingOnDst: if sigil == MissingOnDst && ci.DryRun { return winner // none, because it does not currently exist on dst, and will still not exist after DryRun } winner.Obj = src winner.Side = "src" // presume dst will end up matching src unless changed below if sigil == Match && (ci.SizeOnly || ci.CheckSum || ci.IgnoreSize || ci.UpdateOlder || ci.NoUpdateModTime) { winner.Obj = dst winner.Side = "dst" // ignore any differences with src because of user flags } if ci.IgnoreTimes { winner.Obj = src winner.Side = "src" // copy src to dst unconditionally } if (sigil == Match || sigil == Differ) && (ci.IgnoreExisting || ci.Immutable) { winner.Obj = dst winner.Side = "dst" // dst should remain unchanged if it already exists (and we know it does because it's Match or Differ) } if ci.DryRun { winner.Obj = dst winner.Side = "dst" // dst should remain unchanged after DryRun (note that we handled MissingOnDst earlier) } return winner case TransferError: winner.Obj = dst winner.Side = "dst" // usually, dst should not change if there's an error if dst == nil { winner.Obj = src winner.Side = "src" // but if for some reason we have a src and not a dst, go with it } if winner.Obj != nil { if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, errors.New("max transfer duration reached as set by --max-duration")) { winner.Err = err // we can't confidently predict what survives if CutoffModeHard } return winner // we know at least one of the objects } } // should only make it this far if it's TransferError and both src and dst are nil winner.Side = "none" winner.Err = fmt.Errorf("unknown case -- can't determine winner. %v", err) fs.Debugf(winner.Obj, "%v", winner.Err) return winner } // SetListFormat sets opt.ListFormat for destAfter // TODO: possibly refactor duplicate code from cmd/lsf, where this is mostly copied from func (opt *LoggerOpt) SetListFormat(ctx context.Context, cmdFlags *pflag.FlagSet) { // Work out if the separatorFlag was supplied or not separatorFlag := cmdFlags.Lookup("separator") separatorFlagSupplied := separatorFlag != nil && separatorFlag.Changed // Default the separator to , if using CSV if opt.Csv && !separatorFlagSupplied { opt.Separator = "," } var list ListFormat list.SetSeparator(opt.Separator) list.SetCSV(opt.Csv) list.SetDirSlash(opt.DirSlash) list.SetAbsolute(opt.Absolute) var JSONOpt = ListJSONOpt{ NoModTime: true, NoMimeType: true, DirsOnly: opt.DirsOnly, FilesOnly: opt.FilesOnly, // Recurse: opt.Recurse, } for _, char := range opt.Format { switch char { case 'p': list.AddPath() case 't': list.AddModTime(opt.TimeFormat) JSONOpt.NoModTime = false case 's': list.AddSize() case 'h': list.AddHash(opt.HashType) JSONOpt.ShowHash = true JSONOpt.HashTypes = []string{opt.HashType.String()} case 'i': list.AddID() case 'm': list.AddMimeType() JSONOpt.NoMimeType = false case 'e': list.AddEncrypted() JSONOpt.ShowEncrypted = true case 'o': list.AddOrigID() JSONOpt.ShowOrigIDs = true case 'T': list.AddTier() case 'M': list.AddMetadata() JSONOpt.Metadata = true default: fs.Errorf(nil, "unknown format character %q", char) } } opt.ListFormat = list opt.JSONOpt = JSONOpt } // NewListJSON makes a new *listJSON for destAfter func (opt *LoggerOpt) NewListJSON(ctx context.Context, fdst fs.Fs, remote string) { opt.LJ, _ = newListJSON(ctx, fdst, remote, &opt.JSONOpt) //fs.Debugf(nil, "%v", opt.LJ) } // JSONEntry returns a *ListJSONItem for destAfter func (opt *LoggerOpt) JSONEntry(ctx context.Context, entry fs.DirEntry) (*ListJSONItem, error) { return opt.LJ.entry(ctx, entry) } // PrintDestAfter writes a *ListJSONItem to opt.DestAfter func (opt *LoggerOpt) PrintDestAfter(ctx context.Context, sigil Sigil, src, dst fs.DirEntry, err error) { entry := WinningSide(ctx, sigil, src, dst, err) if entry.Obj != nil { JSONEntry, _ := opt.JSONEntry(ctx, entry.Obj) _, _ = fmt.Fprintln(opt.DestAfter, opt.ListFormat.Format(JSONEntry)) } } rclone-v1.71.0/fs/operations/lsjson.go000066400000000000000000000230621505210326400177030ustar00rootroot00000000000000package operations import ( "context" "errors" "fmt" "path" "strings" "time" "github.com/rclone/rclone/backend/crypt" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/walk" ) // ListJSONItem in the struct which gets marshalled for each line type ListJSONItem struct { Path string Name string EncryptedPath string `json:",omitempty"` Encrypted string `json:",omitempty"` Size int64 MimeType string `json:",omitempty"` ModTime Timestamp //`json:",omitempty"` IsDir bool Hashes map[string]string `json:",omitempty"` ID string `json:",omitempty"` OrigID string `json:",omitempty"` Tier string `json:",omitempty"` IsBucket bool `json:",omitempty"` Metadata fs.Metadata `json:",omitempty"` } // Timestamp a time in the provided format type Timestamp struct { When time.Time Format string } // MarshalJSON turns a Timestamp into JSON func (t Timestamp) MarshalJSON() (out []byte, err error) { if t.When.IsZero() { return []byte(`""`), nil } return []byte(`"` + t.When.Format(t.Format) + `"`), nil } // Returns a time format for the given precision func formatForPrecision(precision time.Duration) string { switch { case precision <= time.Nanosecond: return "2006-01-02T15:04:05.000000000Z07:00" case precision <= 10*time.Nanosecond: return "2006-01-02T15:04:05.00000000Z07:00" case precision <= 100*time.Nanosecond: return "2006-01-02T15:04:05.0000000Z07:00" case precision <= time.Microsecond: return "2006-01-02T15:04:05.000000Z07:00" case precision <= 10*time.Microsecond: return "2006-01-02T15:04:05.00000Z07:00" case precision <= 100*time.Microsecond: return "2006-01-02T15:04:05.0000Z07:00" case precision <= time.Millisecond: return "2006-01-02T15:04:05.000Z07:00" case precision <= 10*time.Millisecond: return "2006-01-02T15:04:05.00Z07:00" case precision <= 100*time.Millisecond: return "2006-01-02T15:04:05.0Z07:00" } return time.RFC3339 } // ListJSONOpt describes the options for ListJSON type ListJSONOpt struct { Recurse bool `json:"recurse"` NoModTime bool `json:"noModTime"` NoMimeType bool `json:"noMimeType"` ShowEncrypted bool `json:"showEncrypted"` ShowOrigIDs bool `json:"showOrigIDs"` ShowHash bool `json:"showHash"` DirsOnly bool `json:"dirsOnly"` FilesOnly bool `json:"filesOnly"` Metadata bool `json:"metadata"` HashTypes []string `json:"hashTypes"` // hash types to show if ShowHash is set, e.g. "MD5", "SHA-1" } // state for ListJson type listJSON struct { fsrc fs.Fs remote string format string opt *ListJSONOpt cipher *crypt.Cipher hashTypes []hash.Type dirs bool files bool canGetTier bool isBucket bool showHash bool } func newListJSON(ctx context.Context, fsrc fs.Fs, remote string, opt *ListJSONOpt) (*listJSON, error) { lj := &listJSON{ fsrc: fsrc, remote: remote, opt: opt, dirs: true, files: true, } // Dirs Files // !FilesOnly,!DirsOnly true true // !FilesOnly,DirsOnly true false // FilesOnly,!DirsOnly false true // FilesOnly,DirsOnly true true if !opt.FilesOnly && opt.DirsOnly { lj.files = false } else if opt.FilesOnly && !opt.DirsOnly { lj.dirs = false } if opt.ShowEncrypted { fsInfo, _, _, config, err := fs.ConfigFs(fs.ConfigStringFull(fsrc)) if err != nil { return nil, fmt.Errorf("ListJSON failed to load config for crypt remote: %w", err) } if fsInfo.Name != "crypt" { return nil, errors.New("the remote needs to be of type \"crypt\"") } lj.cipher, err = crypt.NewCipher(config) if err != nil { return nil, fmt.Errorf("ListJSON failed to make new crypt remote: %w", err) } } features := fsrc.Features() lj.canGetTier = features.GetTier lj.format = formatForPrecision(fsrc.Precision()) lj.isBucket = features.BucketBased && remote == "" && fsrc.Root() == "" // if bucket-based remote listing the root mark directories as buckets lj.showHash = opt.ShowHash lj.hashTypes = fsrc.Hashes().Array() if len(opt.HashTypes) != 0 { lj.showHash = true lj.hashTypes = []hash.Type{} for _, hashType := range opt.HashTypes { var ht hash.Type err := ht.Set(hashType) if err != nil { return nil, err } lj.hashTypes = append(lj.hashTypes, ht) } } return lj, nil } // Convert a single entry to JSON // // It may return nil if there is no entry to return func (lj *listJSON) entry(ctx context.Context, entry fs.DirEntry) (*ListJSONItem, error) { switch entry.(type) { case fs.Directory: if lj.opt.FilesOnly { return nil, nil } case fs.Object: if lj.opt.DirsOnly { return nil, nil } default: fs.Errorf(nil, "Unknown type %T in listing", entry) } item := &ListJSONItem{ Path: entry.Remote(), Name: path.Base(entry.Remote()), Size: entry.Size(), } if entry.Remote() == "" { item.Name = "" } if !lj.opt.NoModTime { item.ModTime = Timestamp{When: entry.ModTime(ctx), Format: lj.format} } if !lj.opt.NoMimeType { item.MimeType = fs.MimeTypeDirEntry(ctx, entry) } if lj.cipher != nil { switch entry.(type) { case fs.Directory: item.EncryptedPath = lj.cipher.EncryptDirName(entry.Remote()) case fs.Object: item.EncryptedPath = lj.cipher.EncryptFileName(entry.Remote()) default: fs.Errorf(nil, "Unknown type %T in listing", entry) } item.Encrypted = path.Base(item.EncryptedPath) } if lj.opt.Metadata { metadata, err := fs.GetMetadata(ctx, entry) if err != nil { fs.Errorf(entry, "Failed to read metadata: %v", err) } else if metadata != nil { item.Metadata = metadata } } if do, ok := entry.(fs.IDer); ok { item.ID = do.ID() } if o, ok := entry.(fs.Object); lj.opt.ShowOrigIDs && ok { if do, ok := fs.UnWrapObject(o).(fs.IDer); ok { item.OrigID = do.ID() } } switch x := entry.(type) { case fs.Directory: item.IsDir = true item.IsBucket = lj.isBucket case fs.Object: item.IsDir = false if lj.showHash { item.Hashes = make(map[string]string) for _, hashType := range lj.hashTypes { hash, err := x.Hash(ctx, hashType) if err != nil { fs.Errorf(x, "Failed to read hash: %v", err) } else if hash != "" { item.Hashes[hashType.String()] = hash } } } if lj.canGetTier { if do, ok := x.(fs.GetTierer); ok { item.Tier = do.GetTier() } } default: fs.Errorf(nil, "Unknown type %T in listing in ListJSON", entry) } return item, nil } // ListJSON lists fsrc using the options in opt calling callback for each item func ListJSON(ctx context.Context, fsrc fs.Fs, remote string, opt *ListJSONOpt, callback func(*ListJSONItem) error) error { lj, err := newListJSON(ctx, fsrc, remote, opt) if err != nil { return err } err = walk.ListR(ctx, fsrc, remote, false, ConfigMaxDepth(ctx, lj.opt.Recurse), walk.ListAll, func(entries fs.DirEntries) (err error) { for _, entry := range entries { item, err := lj.entry(ctx, entry) if err != nil { return fmt.Errorf("creating entry failed in ListJSON: %w", err) } if item != nil { err = callback(item) if err != nil { return fmt.Errorf("callback failed in ListJSON: %w", err) } } } return nil }) if err != nil { return fmt.Errorf("error in ListJSON: %w", err) } return nil } // StatJSON returns a single JSON stat entry for the fsrc, remote path // // The item returned may be nil if it is not found or excluded with DirsOnly/FilesOnly func StatJSON(ctx context.Context, fsrc fs.Fs, remote string, opt *ListJSONOpt) (item *ListJSONItem, err error) { // FIXME this could me more efficient we had a new primitive // NewDirEntry() which returned an Object or a Directory lj, err := newListJSON(ctx, fsrc, remote, opt) if err != nil { return nil, err } // Root is always a directory. When we have a NewDirEntry // primitive we need to call it, but for now this will do. if remote == "" { if !lj.dirs { return nil, nil } // Check the root directory exists entries, err := fsrc.List(ctx, "") accounting.Stats(ctx).Listed(int64(len(entries))) if err != nil { return nil, err } return lj.entry(ctx, fs.NewDir("", time.Now())) } // Could be a file or a directory here if lj.files && !strings.HasSuffix(remote, "/") { // NewObject can return the sentinel errors ErrorObjectNotFound or ErrorIsDir // ErrorObjectNotFound can mean the source is a directory or not found obj, err := fsrc.NewObject(ctx, remote) if err == fs.ErrorObjectNotFound { if !lj.dirs { return nil, nil } } else if err == fs.ErrorIsDir { if !lj.dirs { return nil, nil } // This could return a made up ListJSONItem here // but that wouldn't have the IDs etc in } else if err != nil { if !lj.dirs { return nil, err } } else { return lj.entry(ctx, obj) } } // Must be a directory here // // Remove trailing / as rclone listings won't have them remote = strings.TrimRight(remote, "/") parent := path.Dir(remote) if parent == "." || parent == "/" { parent = "" } entries, err := fsrc.List(ctx, parent) accounting.Stats(ctx).Listed(int64(len(entries))) if err == fs.ErrorDirNotFound { return nil, nil } else if err != nil { return nil, err } equal := func(a, b string) bool { return a == b } if fsrc.Features().CaseInsensitive { equal = strings.EqualFold } var foundEntry fs.DirEntry for _, entry := range entries { if equal(entry.Remote(), remote) { foundEntry = entry break } } if foundEntry == nil { return nil, nil } return lj.entry(ctx, foundEntry) } rclone-v1.71.0/fs/operations/lsjson_test.go000066400000000000000000000236241505210326400207460ustar00rootroot00000000000000package operations_test import ( "context" "sort" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fstest" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Compare a and b in a file system independent way func compareListJSONItem(t *testing.T, a, b *operations.ListJSONItem, precision time.Duration) { assert.Equal(t, a.Path, b.Path, "Path") assert.Equal(t, a.Name, b.Name, "Name") // assert.Equal(t, a.EncryptedPath, b.EncryptedPath, "EncryptedPath") // assert.Equal(t, a.Encrypted, b.Encrypted, "Encrypted") if !a.IsDir { assert.Equal(t, a.Size, b.Size, "Size") } // assert.Equal(t, a.MimeType, a.Mib.MimeType, "MimeType") if !a.IsDir { fstest.AssertTimeEqualWithPrecision(t, "ListJSON", a.ModTime.When, b.ModTime.When, precision) } assert.Equal(t, a.IsDir, b.IsDir, "IsDir") // assert.Equal(t, a.Hashes, a.b.Hashes, "Hashes") // assert.Equal(t, a.ID, b.ID, "ID") // assert.Equal(t, a.OrigID, a.b.OrigID, "OrigID") // assert.Equal(t, a.Tier, b.Tier, "Tier") // assert.Equal(t, a.IsBucket, a.Isb.IsBucket, "IsBucket") } func TestListJSON(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteBoth(ctx, "file1", "file1", t1) file2 := r.WriteBoth(ctx, "sub/file2", "sub/file2", t2) r.CheckRemoteItems(t, file1, file2) precision := fs.GetModifyWindow(ctx, r.Fremote) for _, test := range []struct { name string remote string opt operations.ListJSONOpt want []*operations.ListJSONItem }{ { name: "Default", opt: operations.ListJSONOpt{}, want: []*operations.ListJSONItem{{ Path: "file1", Name: "file1", Size: 5, ModTime: operations.Timestamp{When: t1}, IsDir: false, }, { Path: "sub", Name: "sub", IsDir: true, }}, }, { name: "FilesOnly", opt: operations.ListJSONOpt{ FilesOnly: true, }, want: []*operations.ListJSONItem{{ Path: "file1", Name: "file1", Size: 5, ModTime: operations.Timestamp{When: t1}, IsDir: false, }}, }, { name: "DirsOnly", opt: operations.ListJSONOpt{ DirsOnly: true, }, want: []*operations.ListJSONItem{{ Path: "sub", Name: "sub", IsDir: true, }}, }, { name: "Recurse", opt: operations.ListJSONOpt{ Recurse: true, }, want: []*operations.ListJSONItem{{ Path: "file1", Name: "file1", Size: 5, ModTime: operations.Timestamp{When: t1}, IsDir: false, }, { Path: "sub", Name: "sub", IsDir: true, }, { Path: "sub/file2", Name: "file2", Size: 9, ModTime: operations.Timestamp{When: t2}, IsDir: false, }}, }, { name: "SubDir", remote: "sub", opt: operations.ListJSONOpt{}, want: []*operations.ListJSONItem{{ Path: "sub/file2", Name: "file2", Size: 9, ModTime: operations.Timestamp{When: t2}, IsDir: false, }}, }, { name: "NoModTime", opt: operations.ListJSONOpt{ FilesOnly: true, NoModTime: true, }, want: []*operations.ListJSONItem{{ Path: "file1", Name: "file1", Size: 5, ModTime: operations.Timestamp{When: time.Time{}}, IsDir: false, }}, }, { name: "NoMimeType", opt: operations.ListJSONOpt{ FilesOnly: true, NoMimeType: true, }, want: []*operations.ListJSONItem{{ Path: "file1", Name: "file1", Size: 5, ModTime: operations.Timestamp{When: t1}, IsDir: false, }}, }, { name: "ShowHash", opt: operations.ListJSONOpt{ FilesOnly: true, ShowHash: true, }, want: []*operations.ListJSONItem{{ Path: "file1", Name: "file1", Size: 5, ModTime: operations.Timestamp{When: t1}, IsDir: false, }}, }, { name: "HashTypes", opt: operations.ListJSONOpt{ FilesOnly: true, ShowHash: true, HashTypes: []string{"MD5"}, }, want: []*operations.ListJSONItem{{ Path: "file1", Name: "file1", Size: 5, ModTime: operations.Timestamp{When: t1}, IsDir: false, }}, }, { name: "Metadata", opt: operations.ListJSONOpt{ FilesOnly: false, Metadata: true, }, want: []*operations.ListJSONItem{{ Path: "file1", Name: "file1", Size: 5, ModTime: operations.Timestamp{When: t1}, IsDir: false, }, { Path: "sub", Name: "sub", IsDir: true, }}, }, } { t.Run(test.name, func(t *testing.T) { var got []*operations.ListJSONItem require.NoError(t, operations.ListJSON(ctx, r.Fremote, test.remote, &test.opt, func(item *operations.ListJSONItem) error { got = append(got, item) return nil })) sort.Slice(got, func(i, j int) bool { return got[i].Path < got[j].Path }) require.Equal(t, len(test.want), len(got), "Wrong number of results") for i := range test.want { compareListJSONItem(t, test.want[i], got[i], precision) if test.opt.NoMimeType { assert.Equal(t, "", got[i].MimeType) } else { assert.NotEqual(t, "", got[i].MimeType) } if test.opt.Metadata { features := r.Fremote.Features() if features.ReadMetadata && !got[i].IsDir { assert.Greater(t, len(got[i].Metadata), 0, "Expecting metadata for file") } if features.ReadDirMetadata && got[i].IsDir { assert.Greater(t, len(got[i].Metadata), 0, "Expecting metadata for dir") } } if test.opt.ShowHash { hashes := got[i].Hashes assert.NotNil(t, hashes) if len(test.opt.HashTypes) > 0 && len(hashes) > 0 { assert.Equal(t, 1, len(hashes)) } if hashes["crc32"] != "" { assert.Equal(t, "9ee760e5", hashes["crc32"]) } if hashes["dropbox"] != "" { assert.Equal(t, "f4d62afeaee6f35d3efdd8c66623360395165473bcc958f835343eb3f542f983", hashes["dropbox"]) } if hashes["mailru"] != "" { assert.Equal(t, "66696c6531000000000000000000000000000000", hashes["mailru"]) } if hashes["md5"] != "" { assert.Equal(t, "826e8142e6baabe8af779f5f490cf5f5", hashes["md5"]) } if hashes["quickxor"] != "" { assert.Equal(t, "6648031bca100300000000000500000000000000", hashes["quickxor"]) } if hashes["sha1"] != "" { assert.Equal(t, "60b27f004e454aca81b0480209cce5081ec52390", hashes["sha1"]) } if hashes["sha256"] != "" { assert.Equal(t, "c147efcfc2d7ea666a9e4f5187b115c90903f0fc896a56df9a6ef5d8f3fc9f31", hashes["sha256"]) } if hashes["whirlpool"] != "" { assert.Equal(t, "02fa11755b6470bfc5aab6d94cde5cf2939474fb5b0ebbf8ddf3d32bf06aa438eb92eac097047c02017dc1c317ee83fa8a2717ca4d544b4ee75b3231d1c466b0", hashes["whirlpool"]) } } else { assert.Nil(t, got[i].Hashes) } } }) } } func TestStatJSON(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteBoth(ctx, "file1", "file1", t1) file2 := r.WriteBoth(ctx, "sub/file2", "sub/file2", t2) r.CheckRemoteItems(t, file1, file2) precision := fs.GetModifyWindow(ctx, r.Fremote) for _, test := range []struct { name string remote string opt operations.ListJSONOpt want *operations.ListJSONItem }{ { name: "Root", remote: "", opt: operations.ListJSONOpt{}, want: &operations.ListJSONItem{ Path: "", Name: "", IsDir: true, }, }, { name: "RootFilesOnly", remote: "", opt: operations.ListJSONOpt{ FilesOnly: true, }, want: nil, }, { name: "RootDirsOnly", remote: "", opt: operations.ListJSONOpt{ DirsOnly: true, }, want: &operations.ListJSONItem{ Path: "", Name: "", IsDir: true, }, }, { name: "Dir", remote: "sub", opt: operations.ListJSONOpt{}, want: &operations.ListJSONItem{ Path: "sub", Name: "sub", IsDir: true, }, }, { name: "DirWithTrailingSlash", remote: "sub/", opt: operations.ListJSONOpt{}, want: &operations.ListJSONItem{ Path: "sub", Name: "sub", IsDir: true, }, }, { name: "File", remote: "file1", opt: operations.ListJSONOpt{}, want: &operations.ListJSONItem{ Path: "file1", Name: "file1", Size: 5, ModTime: operations.Timestamp{When: t1}, IsDir: false, }, }, { name: "NotFound", remote: "notfound", opt: operations.ListJSONOpt{}, want: nil, }, { name: "DirFilesOnly", remote: "sub", opt: operations.ListJSONOpt{ FilesOnly: true, }, want: nil, }, { name: "FileFilesOnly", remote: "file1", opt: operations.ListJSONOpt{ FilesOnly: true, }, want: &operations.ListJSONItem{ Path: "file1", Name: "file1", Size: 5, ModTime: operations.Timestamp{When: t1}, IsDir: false, }, }, { name: "NotFoundFilesOnly", remote: "notfound", opt: operations.ListJSONOpt{ FilesOnly: true, }, want: nil, }, { name: "DirDirsOnly", remote: "sub", opt: operations.ListJSONOpt{ DirsOnly: true, }, want: &operations.ListJSONItem{ Path: "sub", Name: "sub", IsDir: true, }, }, { name: "FileDirsOnly", remote: "file1", opt: operations.ListJSONOpt{ DirsOnly: true, }, want: nil, }, { name: "NotFoundDirsOnly", remote: "notfound", opt: operations.ListJSONOpt{ DirsOnly: true, }, want: nil, }, } { t.Run(test.name, func(t *testing.T) { got, err := operations.StatJSON(ctx, r.Fremote, test.remote, &test.opt) require.NoError(t, err) if test.want == nil { assert.Nil(t, got) return } require.NotNil(t, got) compareListJSONItem(t, test.want, got, precision) }) } t.Run("RootNotFound", func(t *testing.T) { f, err := fs.NewFs(ctx, r.FremoteName+"/notfound") require.NoError(t, err) _, err = operations.StatJSON(ctx, f, "", &operations.ListJSONOpt{}) // This should return an error except for bucket based remotes assert.True(t, err != nil || f.Features().BucketBased, "Need an error for non bucket based backends") }) } rclone-v1.71.0/fs/operations/multithread.go000066400000000000000000000272321505210326400207200ustar00rootroot00000000000000package operations import ( "bufio" "context" "errors" "fmt" "io" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/lib/atexit" "github.com/rclone/rclone/lib/multipart" "github.com/rclone/rclone/lib/pool" "golang.org/x/sync/errgroup" ) const ( multithreadChunkSize = 64 << 10 ) // Return a boolean as to whether we should use multi thread copy for // this transfer func doMultiThreadCopy(ctx context.Context, f fs.Fs, src fs.Object) bool { ci := fs.GetConfig(ctx) // Disable multi thread if... // ...it isn't configured if ci.MultiThreadStreams <= 1 { return false } // ...if the source doesn't support it if src.Fs().Features().NoMultiThreading { return false } // ...size of object is less than cutoff if src.Size() < int64(ci.MultiThreadCutoff) { return false } // ...destination doesn't support it dstFeatures := f.Features() if dstFeatures.OpenChunkWriter == nil && dstFeatures.OpenWriterAt == nil { return false } // ...if --multi-thread-streams not in use and source and // destination are both local if !ci.MultiThreadSet && dstFeatures.IsLocal && src.Fs().Features().IsLocal { return false } return true } // state for a multi-thread copy type multiThreadCopyState struct { ctx context.Context partSize int64 size int64 src fs.Object acc *accounting.Account numChunks int noBuffering bool // set to read the input without buffering } // Copy a single chunk into place func (mc *multiThreadCopyState) copyChunk(ctx context.Context, chunk int, writer fs.ChunkWriter) (err error) { defer func() { if err != nil { fs.Debugf(mc.src, "multi-thread copy: chunk %d/%d failed: %v", chunk+1, mc.numChunks, err) } }() start := int64(chunk) * mc.partSize if start >= mc.size { return nil } end := min(start+mc.partSize, mc.size) size := end - start // Reserve the memory first so we don't open the source and wait for memory buffers for ages var rw *pool.RW if !mc.noBuffering { rw = multipart.NewRW().Reserve(size) defer fs.CheckClose(rw, &err) } fs.Debugf(mc.src, "multi-thread copy: chunk %d/%d (%d-%d) size %v starting", chunk+1, mc.numChunks, start, end, fs.SizeSuffix(size)) rc, err := Open(ctx, mc.src, &fs.RangeOption{Start: start, End: end - 1}) if err != nil { return fmt.Errorf("multi-thread copy: failed to open source: %w", err) } defer fs.CheckClose(rc, &err) var rs io.ReadSeeker if mc.noBuffering { // Read directly if we are sure we aren't going to seek // and account with accounting rc.SetAccounting(mc.acc.AccountRead) rs = rc } else { // Read the chunk into buffered reader _, err = io.CopyN(rw, rc, size) if err != nil { return fmt.Errorf("multi-thread copy: failed to read chunk: %w", err) } // Account as we go rw.SetAccounting(mc.acc.AccountRead) rs = rw } // Write the chunk bytesWritten, err := writer.WriteChunk(ctx, chunk, rs) if err != nil { return fmt.Errorf("multi-thread copy: failed to write chunk: %w", err) } fs.Debugf(mc.src, "multi-thread copy: chunk %d/%d (%d-%d) size %v finished", chunk+1, mc.numChunks, start, end, fs.SizeSuffix(bytesWritten)) return nil } // Given a file size and a chunkSize // it returns the number of chunks, so that chunkSize * numChunks >= size func calculateNumChunks(size int64, chunkSize int64) int { numChunks := size / chunkSize if size%chunkSize != 0 { numChunks++ } return int(numChunks) } // Copy src to (f, remote) using streams download threads. It tries to use the OpenChunkWriter feature // and if that's not available it creates an adapter using OpenWriterAt func multiThreadCopy(ctx context.Context, f fs.Fs, remote string, src fs.Object, concurrency int, tr *accounting.Transfer, options ...fs.OpenOption) (newDst fs.Object, err error) { openChunkWriter := f.Features().OpenChunkWriter ci := fs.GetConfig(ctx) noBuffering := false usingOpenWriterAt := false if openChunkWriter == nil { openWriterAt := f.Features().OpenWriterAt if openWriterAt == nil { return nil, errors.New("multi-thread copy: neither OpenChunkWriter nor OpenWriterAt supported") } openChunkWriter = openChunkWriterFromOpenWriterAt(openWriterAt, int64(ci.MultiThreadChunkSize), int64(ci.MultiThreadWriteBufferSize), f) // If we are using OpenWriterAt we don't seek the chunks so don't need to buffer fs.Debugf(src, "multi-thread copy: disabling buffering because destination uses OpenWriterAt") noBuffering = true usingOpenWriterAt = true } else if src.Fs().Features().IsLocal { // If the source fs is local we don't need to buffer fs.Debugf(src, "multi-thread copy: disabling buffering because source is local disk") noBuffering = true } else if f.Features().ChunkWriterDoesntSeek { // If the destination Fs promises not to seek its chunks // (except for retries) then we don't need buffering. fs.Debugf(src, "multi-thread copy: disabling buffering because destination has set ChunkWriterDoesntSeek") noBuffering = true } if src.Size() < 0 { return nil, fmt.Errorf("multi-thread copy: can't copy unknown sized file") } if src.Size() == 0 { return nil, fmt.Errorf("multi-thread copy: can't copy zero sized file") } info, chunkWriter, err := openChunkWriter(ctx, remote, src, options...) if err != nil { return nil, fmt.Errorf("multi-thread copy: failed to open chunk writer: %w", err) } uploadCtx, cancel := context.WithCancel(ctx) defer cancel() uploadedOK := false defer atexit.OnError(&err, func() { cancel() if info.LeavePartsOnError || uploadedOK { return } fs.Debugf(src, "multi-thread copy: cancelling transfer on exit") abortErr := chunkWriter.Abort(ctx) if abortErr != nil { fs.Debugf(src, "multi-thread copy: abort failed: %v", abortErr) } })() if info.ChunkSize > src.Size() { fs.Debugf(src, "multi-thread copy: chunk size %v was bigger than source file size %v", fs.SizeSuffix(info.ChunkSize), fs.SizeSuffix(src.Size())) info.ChunkSize = src.Size() } // Use the backend concurrency if it is higher than --multi-thread-streams or if --multi-thread-streams wasn't set explicitly if !ci.MultiThreadSet || info.Concurrency > concurrency { fs.Debugf(src, "multi-thread copy: using backend concurrency of %d instead of --multi-thread-streams %d", info.Concurrency, concurrency) concurrency = info.Concurrency } numChunks := calculateNumChunks(src.Size(), info.ChunkSize) if concurrency > numChunks { fs.Debugf(src, "multi-thread copy: number of streams %d was bigger than number of chunks %d", concurrency, numChunks) concurrency = numChunks } if concurrency < 1 { concurrency = 1 } g, gCtx := errgroup.WithContext(uploadCtx) g.SetLimit(concurrency) mc := &multiThreadCopyState{ ctx: gCtx, size: src.Size(), src: src, partSize: info.ChunkSize, numChunks: numChunks, noBuffering: noBuffering, } // Make accounting mc.acc = tr.Account(gCtx, nil) fs.Debugf(src, "Starting multi-thread copy with %d chunks of size %v with %v parallel streams", mc.numChunks, fs.SizeSuffix(mc.partSize), concurrency) for chunk := range mc.numChunks { // Fail fast, in case an errgroup managed function returns an error if gCtx.Err() != nil { break } chunk := chunk g.Go(func() error { return mc.copyChunk(gCtx, chunk, chunkWriter) }) } err = g.Wait() if err != nil { return nil, err } err = chunkWriter.Close(ctx) if err != nil { return nil, fmt.Errorf("multi-thread copy: failed to close object after copy: %w", err) } uploadedOK = true // file is definitely uploaded OK so no need to abort obj, err := f.NewObject(ctx, remote) if err != nil { return nil, fmt.Errorf("multi-thread copy: failed to find object after copy: %w", err) } // OpenWriterAt doesn't set metadata so we need to set it on completion if usingOpenWriterAt { setModTime := true if ci.Metadata { do, ok := obj.(fs.SetMetadataer) if ok { meta, err := fs.GetMetadataOptions(ctx, f, src, options) if err != nil { return nil, fmt.Errorf("multi-thread copy: failed to read metadata from source object: %w", err) } if _, foundMeta := meta["mtime"]; !foundMeta { meta.Set("mtime", src.ModTime(ctx).Format(time.RFC3339Nano)) } err = do.SetMetadata(ctx, meta) if err != nil { return nil, fmt.Errorf("multi-thread copy: failed to set metadata: %w", err) } setModTime = false } else { fs.Errorf(obj, "multi-thread copy: can't set metadata as SetMetadata isn't implemented in: %v", f) } } if setModTime { err = obj.SetModTime(ctx, src.ModTime(ctx)) switch err { case nil, fs.ErrorCantSetModTime, fs.ErrorCantSetModTimeWithoutDelete: default: return nil, fmt.Errorf("multi-thread copy: failed to set modification time: %w", err) } } } fs.Debugf(src, "Finished multi-thread copy with %d parts of size %v", mc.numChunks, fs.SizeSuffix(mc.partSize)) return obj, nil } // writerAtChunkWriter converts a WriterAtCloser into a ChunkWriter type writerAtChunkWriter struct { remote string size int64 writerAt fs.WriterAtCloser chunkSize int64 chunks int writeBufferSize int64 f fs.Fs closed bool } // WriteChunk writes chunkNumber from reader func (w *writerAtChunkWriter) WriteChunk(ctx context.Context, chunkNumber int, reader io.ReadSeeker) (int64, error) { fs.Debugf(w.remote, "writing chunk %v", chunkNumber) bytesToWrite := w.chunkSize if chunkNumber == (w.chunks-1) && w.size%w.chunkSize != 0 { bytesToWrite = w.size % w.chunkSize } var writer io.Writer = io.NewOffsetWriter(w.writerAt, int64(chunkNumber)*w.chunkSize) if w.writeBufferSize > 0 { writer = bufio.NewWriterSize(writer, int(w.writeBufferSize)) } n, err := io.Copy(writer, reader) if err != nil { return -1, err } if n != bytesToWrite { return -1, fmt.Errorf("expected to write %v bytes for chunk %v, but wrote %v bytes", bytesToWrite, chunkNumber, n) } // if we were buffering, flush to disk switch w := writer.(type) { case *bufio.Writer: err = w.Flush() if err != nil { return -1, fmt.Errorf("multi-thread copy: flush failed: %w", err) } } return n, nil } // Close the chunk writing func (w *writerAtChunkWriter) Close(ctx context.Context) error { if w.closed { return nil } w.closed = true return w.writerAt.Close() } // Abort the chunk writing func (w *writerAtChunkWriter) Abort(ctx context.Context) error { err := w.Close(ctx) if err != nil { fs.Errorf(w.remote, "multi-thread copy: failed to close file before aborting: %v", err) } obj, err := w.f.NewObject(ctx, w.remote) if err != nil { return fmt.Errorf("multi-thread copy: failed to find temp file when aborting chunk writer: %w", err) } return obj.Remove(ctx) } // openChunkWriterFromOpenWriterAt adapts an OpenWriterAtFn into an OpenChunkWriterFn using chunkSize and writeBufferSize func openChunkWriterFromOpenWriterAt(openWriterAt fs.OpenWriterAtFn, chunkSize int64, writeBufferSize int64, f fs.Fs) fs.OpenChunkWriterFn { return func(ctx context.Context, remote string, src fs.ObjectInfo, options ...fs.OpenOption) (info fs.ChunkWriterInfo, writer fs.ChunkWriter, err error) { ci := fs.GetConfig(ctx) writerAt, err := openWriterAt(ctx, remote, src.Size()) if err != nil { return info, nil, err } if writeBufferSize > 0 { fs.Debugf(src.Remote(), "multi-thread copy: write buffer set to %v", writeBufferSize) } chunkWriter := &writerAtChunkWriter{ remote: remote, size: src.Size(), chunkSize: chunkSize, chunks: calculateNumChunks(src.Size(), chunkSize), writerAt: writerAt, writeBufferSize: writeBufferSize, f: f, } info = fs.ChunkWriterInfo{ ChunkSize: chunkSize, Concurrency: ci.MultiThreadStreams, } return info, chunkWriter, nil } } rclone-v1.71.0/fs/operations/multithread_test.go000066400000000000000000000240501505210326400217520ustar00rootroot00000000000000package operations import ( "context" "errors" "fmt" "io" "sync" "testing" "time" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/object" "github.com/rclone/rclone/fstest/mockfs" "github.com/rclone/rclone/fstest/mockobject" "github.com/rclone/rclone/lib/random" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestDoMultiThreadCopy(t *testing.T) { ctx := context.Background() ci := fs.GetConfig(ctx) f, err := mockfs.NewFs(ctx, "potato", "", nil) require.NoError(t, err) src := mockobject.New("file.txt").WithContent([]byte(random.String(100)), mockobject.SeekModeNone) srcFs, err := mockfs.NewFs(ctx, "sausage", "", nil) require.NoError(t, err) src.SetFs(srcFs) oldStreams := ci.MultiThreadStreams oldCutoff := ci.MultiThreadCutoff oldIsSet := ci.MultiThreadSet defer func() { ci.MultiThreadStreams = oldStreams ci.MultiThreadCutoff = oldCutoff ci.MultiThreadSet = oldIsSet }() ci.MultiThreadStreams, ci.MultiThreadCutoff = 4, 50 ci.MultiThreadSet = false nullWriterAt := func(ctx context.Context, remote string, size int64) (fs.WriterAtCloser, error) { panic("don't call me") } f.Features().OpenWriterAt = nullWriterAt assert.True(t, doMultiThreadCopy(ctx, f, src)) ci.MultiThreadStreams = 0 assert.False(t, doMultiThreadCopy(ctx, f, src)) ci.MultiThreadStreams = 1 assert.False(t, doMultiThreadCopy(ctx, f, src)) ci.MultiThreadStreams = 2 assert.True(t, doMultiThreadCopy(ctx, f, src)) ci.MultiThreadCutoff = 200 assert.False(t, doMultiThreadCopy(ctx, f, src)) ci.MultiThreadCutoff = 101 assert.False(t, doMultiThreadCopy(ctx, f, src)) ci.MultiThreadCutoff = 100 assert.True(t, doMultiThreadCopy(ctx, f, src)) f.Features().OpenWriterAt = nil assert.False(t, doMultiThreadCopy(ctx, f, src)) f.Features().OpenWriterAt = nullWriterAt assert.True(t, doMultiThreadCopy(ctx, f, src)) f.Features().IsLocal = true srcFs.Features().IsLocal = true assert.False(t, doMultiThreadCopy(ctx, f, src)) ci.MultiThreadSet = true assert.True(t, doMultiThreadCopy(ctx, f, src)) ci.MultiThreadSet = false assert.False(t, doMultiThreadCopy(ctx, f, src)) srcFs.Features().IsLocal = false assert.True(t, doMultiThreadCopy(ctx, f, src)) srcFs.Features().IsLocal = true assert.False(t, doMultiThreadCopy(ctx, f, src)) f.Features().IsLocal = false assert.True(t, doMultiThreadCopy(ctx, f, src)) srcFs.Features().IsLocal = false assert.True(t, doMultiThreadCopy(ctx, f, src)) srcFs.Features().NoMultiThreading = true assert.False(t, doMultiThreadCopy(ctx, f, src)) srcFs.Features().NoMultiThreading = false assert.True(t, doMultiThreadCopy(ctx, f, src)) } func TestMultithreadCalculateNumChunks(t *testing.T) { for _, test := range []struct { size int64 chunkSize int64 wantNumChunks int }{ {size: 1, chunkSize: multithreadChunkSize, wantNumChunks: 1}, {size: 1 << 20, chunkSize: 1, wantNumChunks: 1 << 20}, {size: 1 << 20, chunkSize: 2, wantNumChunks: 1 << 19}, {size: (1 << 20) + 1, chunkSize: 2, wantNumChunks: (1 << 19) + 1}, {size: (1 << 20) - 1, chunkSize: 2, wantNumChunks: 1 << 19}, } { t.Run(fmt.Sprintf("%+v", test), func(t *testing.T) { mc := &multiThreadCopyState{ size: test.size, } mc.numChunks = calculateNumChunks(test.size, test.chunkSize) assert.Equal(t, test.wantNumChunks, mc.numChunks) }) } } // Skip if not multithread, returning the chunkSize otherwise func skipIfNotMultithread(ctx context.Context, t *testing.T, r *fstest.Run) int { features := r.Fremote.Features() if features.OpenChunkWriter == nil && features.OpenWriterAt == nil { t.Skip("multithread writing not supported") } // Only support one hash for the local backend otherwise we end up spending a huge amount of CPU on hashing! if r.Fremote.Features().IsLocal { oldHashes := hash.SupportOnly([]hash.Type{r.Fremote.Hashes().GetOne()}) t.Cleanup(func() { _ = hash.SupportOnly(oldHashes) }) } ci := fs.GetConfig(ctx) chunkSize := int(ci.MultiThreadChunkSize) if features.OpenChunkWriter != nil { //OpenChunkWriter func(ctx context.Context, remote string, src ObjectInfo, options ...OpenOption) (info ChunkWriterInfo, writer ChunkWriter, err error) const fileName = "chunksize-probe" src := object.NewStaticObjectInfo(fileName, time.Now(), int64(100*fs.Mebi), true, nil, nil) info, writer, err := features.OpenChunkWriter(ctx, fileName, src) require.NoError(t, err) chunkSize = int(info.ChunkSize) err = writer.Abort(ctx) require.NoError(t, err) } return chunkSize } func TestMultithreadCopy(t *testing.T) { r := fstest.NewRun(t) ctx := context.Background() chunkSize := skipIfNotMultithread(ctx, t, r) // Check every other transfer for metadata checkMetadata := false ctx, ci := fs.AddConfig(ctx) for _, upload := range []bool{false, true} { for _, test := range []struct { size int streams int }{ {size: chunkSize*2 - 1, streams: 2}, {size: chunkSize * 2, streams: 2}, {size: chunkSize*2 + 1, streams: 2}, } { checkMetadata = !checkMetadata ci.Metadata = checkMetadata fileName := fmt.Sprintf("test-multithread-copy-%v-%d-%d", upload, test.size, test.streams) t.Run(fmt.Sprintf("upload=%v,size=%v,streams=%v", upload, test.size, test.streams), func(t *testing.T) { if *fstest.SizeLimit > 0 && int64(test.size) > *fstest.SizeLimit { t.Skipf("exceeded file size limit %d > %d", test.size, *fstest.SizeLimit) } var ( contents = random.String(test.size) t1 = fstest.Time("2001-02-03T04:05:06.499999999Z") file1 fstest.Item src, dst fs.Object err error testMetadata = fs.Metadata{ // System metadata supported by all backends "mtime": t1.Format(time.RFC3339Nano), // User metadata "potato": "jersey", } ) var fSrc, fDst fs.Fs if upload { file1 = r.WriteFile(fileName, contents, t1) r.CheckRemoteItems(t) r.CheckLocalItems(t, file1) fDst, fSrc = r.Fremote, r.Flocal } else { file1 = r.WriteObject(ctx, fileName, contents, t1) r.CheckRemoteItems(t, file1) r.CheckLocalItems(t) fDst, fSrc = r.Flocal, r.Fremote } src, err = fSrc.NewObject(ctx, fileName) require.NoError(t, err) do, canSetMetadata := src.(fs.SetMetadataer) if checkMetadata && canSetMetadata { // Set metadata on the source if required err := do.SetMetadata(ctx, testMetadata) if err == fs.ErrorNotImplemented { canSetMetadata = false } else { require.NoError(t, err) fstest.CheckEntryMetadata(ctx, t, r.Flocal, src, testMetadata) } } accounting.GlobalStats().ResetCounters() tr := accounting.GlobalStats().NewTransfer(src, nil) defer func() { tr.Done(ctx, err) }() dst, err = multiThreadCopy(ctx, fDst, fileName, src, test.streams, tr) require.NoError(t, err) assert.Equal(t, src.Size(), dst.Size()) assert.Equal(t, fileName, dst.Remote()) fstest.CheckListingWithPrecision(t, fSrc, []fstest.Item{file1}, nil, fs.GetModifyWindow(ctx, fDst, fSrc)) fstest.CheckListingWithPrecision(t, fDst, []fstest.Item{file1}, nil, fs.GetModifyWindow(ctx, fDst, fSrc)) if checkMetadata && canSetMetadata && fDst.Features().ReadMetadata { fstest.CheckEntryMetadata(ctx, t, fDst, dst, testMetadata) } require.NoError(t, dst.Remove(ctx)) require.NoError(t, src.Remove(ctx)) }) } } } type errorObject struct { fs.Object size int64 wg *sync.WaitGroup } // Open opens the file for read. Call Close() on the returned io.ReadCloser // // Remember this is called multiple times whenever the backend seeks (eg having read checksum) func (o errorObject) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { fs.Debugf(nil, "Open with options = %v", options) rc, err := o.Object.Open(ctx, options...) if err != nil { return nil, err } // Return an error reader for the second segment for _, option := range options { if ropt, ok := option.(*fs.RangeOption); ok { end := ropt.End + 1 if end >= o.size { // Give the other chunks a chance to start time.Sleep(time.Second) // Wait for chunks to upload first o.wg.Wait() fs.Debugf(nil, "Returning error reader") return errorReadCloser{rc}, nil } } } o.wg.Add(1) return wgReadCloser{rc, o.wg}, nil } type errorReadCloser struct { io.ReadCloser } func (rc errorReadCloser) Read(p []byte) (n int, err error) { fs.Debugf(nil, "BOOM: simulated read failure") return 0, errors.New("BOOM: simulated read failure") } type wgReadCloser struct { io.ReadCloser wg *sync.WaitGroup } func (rc wgReadCloser) Close() (err error) { rc.wg.Done() return rc.ReadCloser.Close() } // Make sure aborting the multi-thread copy doesn't overwrite an existing file. func TestMultithreadCopyAbort(t *testing.T) { r := fstest.NewRun(t) ctx := context.Background() chunkSize := skipIfNotMultithread(ctx, t, r) size := 2*chunkSize + 1 if *fstest.SizeLimit > 0 && int64(size) > *fstest.SizeLimit { t.Skipf("exceeded file size limit %d > %d", size, *fstest.SizeLimit) } // first write a canary file which we are trying not to overwrite const fileName = "test-multithread-abort" contents := random.String(100) t1 := fstest.Time("2001-02-03T04:05:06.499999999Z") canary := r.WriteObject(ctx, fileName, contents, t1) r.CheckRemoteItems(t, canary) // Now write a local file to upload file1 := r.WriteFile(fileName, random.String(size), t1) r.CheckLocalItems(t, file1) src, err := r.Flocal.NewObject(ctx, fileName) require.NoError(t, err) accounting.GlobalStats().ResetCounters() tr := accounting.GlobalStats().NewTransfer(src, nil) defer func() { tr.Done(ctx, err) }() wg := new(sync.WaitGroup) dst, err := multiThreadCopy(ctx, r.Fremote, fileName, errorObject{src, int64(size), wg}, 1, tr) assert.Error(t, err) assert.Nil(t, dst) if r.Fremote.Features().PartialUploads { r.CheckRemoteItems(t) } else { r.CheckRemoteItems(t, canary) o, err := r.Fremote.NewObject(ctx, fileName) require.NoError(t, err) require.NoError(t, o.Remove(ctx)) } } rclone-v1.71.0/fs/operations/operations.go000066400000000000000000002465431505210326400205710ustar00rootroot00000000000000// Package operations does generic operations on filesystems and objects package operations import ( "bytes" "context" "encoding/base64" "encoding/csv" "encoding/hex" "encoding/json" "errors" "fmt" "io" "mime" "net/http" "os" "path" "path/filepath" "runtime" "sort" "strconv" "strings" "sync" "sync/atomic" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/object" "github.com/rclone/rclone/fs/walk" "github.com/rclone/rclone/lib/atexit" "github.com/rclone/rclone/lib/errcount" "github.com/rclone/rclone/lib/pacer" "github.com/rclone/rclone/lib/random" "github.com/rclone/rclone/lib/readers" "github.com/rclone/rclone/lib/transform" "golang.org/x/sync/errgroup" "golang.org/x/text/unicode/norm" ) // CheckHashes checks the two files to see if they have common // known hash types and compares them // // Returns. // // equal - which is equality of the hashes // // hash - the HashType. This is HashNone if either of the hashes were // unset or a compatible hash couldn't be found. // // err - may return an error which will already have been logged // // If an error is returned it will return equal as false func CheckHashes(ctx context.Context, src fs.ObjectInfo, dst fs.Object) (equal bool, ht hash.Type, err error) { common := src.Fs().Hashes().Overlap(dst.Fs().Hashes()) // fs.Debugf(nil, "Shared hashes: %v", common) if common.Count() == 0 { return true, hash.None, nil } equal, ht, _, _, err = checkHashes(ctx, src, dst, common.GetOne()) return equal, ht, err } var errNoHash = errors.New("no hash available") // checkHashes does the work of CheckHashes but takes a hash.Type and // returns the effective hash type used. func checkHashes(ctx context.Context, src fs.ObjectInfo, dst fs.Object, ht hash.Type) (equal bool, htOut hash.Type, srcHash, dstHash string, err error) { // Calculate hashes in parallel g, ctx := errgroup.WithContext(ctx) var srcErr, dstErr error g.Go(func() (err error) { srcHash, srcErr = src.Hash(ctx, ht) if srcErr != nil { return srcErr } if srcHash == "" { fs.Debugf(src, "Src hash empty - aborting Dst hash check") return errNoHash } return nil }) g.Go(func() (err error) { dstHash, dstErr = dst.Hash(ctx, ht) if dstErr != nil { return dstErr } if dstHash == "" { fs.Debugf(dst, "Dst hash empty - aborting Src hash check") return errNoHash } return nil }) err = g.Wait() if err == errNoHash { return true, hash.None, srcHash, dstHash, nil } if srcErr != nil { err = fs.CountError(ctx, srcErr) fs.Errorf(src, "Failed to calculate src hash: %v", err) } if dstErr != nil { err = fs.CountError(ctx, dstErr) fs.Errorf(dst, "Failed to calculate dst hash: %v", err) } if err != nil { return false, ht, srcHash, dstHash, err } if srcHash != dstHash { fs.Debugf(src, "%v = %s (%v)", ht, srcHash, src.Fs()) fs.Debugf(dst, "%v = %s (%v)", ht, dstHash, dst.Fs()) } else { fs.Debugf(src, "%v = %s OK", ht, srcHash) } return srcHash == dstHash, ht, srcHash, dstHash, nil } // Equal checks to see if the src and dst objects are equal by looking at // size, mtime and hash // // If the src and dst size are different then it is considered to be // not equal. If --size-only is in effect then this is the only check // that is done. If --ignore-size is in effect then this check is // skipped and the files are considered the same size. // // If the size is the same and the mtime is the same then it is // considered to be equal. This check is skipped if using --checksum. // // If the size is the same and mtime is different, unreadable or // --checksum is set and the hash is the same then the file is // considered to be equal. In this case the mtime on the dst is // updated if --checksum is not set. // // Otherwise the file is considered to be not equal including if there // were errors reading info. func Equal(ctx context.Context, src fs.ObjectInfo, dst fs.Object) bool { return equal(ctx, src, dst, defaultEqualOpt(ctx)) } // DirsEqual is like Equal but for dirs instead of objects. // It returns true if two dirs should be considered "equal" for the purposes of syncCopyMove // (in other words, true == "skip updating modtime/metadata for this dir".) // Unlike Equal, it does not consider size or checksum, as these do not apply to directories. func DirsEqual(ctx context.Context, src, dst fs.Directory, opt DirsEqualOpt) (equal bool) { if dst == nil { return false } ci := fs.GetConfig(ctx) if ci.SizeOnly || ci.Immutable || ci.IgnoreExisting || opt.ModifyWindow == fs.ModTimeNotSupported { return true } if ci.IgnoreTimes { return false } if !(opt.SetDirModtime || opt.SetDirMetadata) { return true } srcModTime, dstModTime := src.ModTime(ctx), dst.ModTime(ctx) if srcModTime.IsZero() || dstModTime.IsZero() { return false } dt := dstModTime.Sub(srcModTime) if dt < opt.ModifyWindow && dt > -opt.ModifyWindow { fs.Debugf(dst, "Directory modification time the same (differ by %s, within tolerance %s)", dt, opt.ModifyWindow) return true } if ci.UpdateOlder && dt >= opt.ModifyWindow { fs.Debugf(dst, "Destination directory is newer than source, skipping") return true } return false } // sizeDiffers compare the size of src and dst taking into account the // various ways of ignoring sizes func sizeDiffers(ctx context.Context, src, dst fs.ObjectInfo) bool { ci := fs.GetConfig(ctx) if ci.IgnoreSize || src.Size() < 0 || dst.Size() < 0 { return false } return src.Size() != dst.Size() } var checksumWarning sync.Once // options for equal function() type equalOpt struct { sizeOnly bool // if set only check size checkSum bool // if set check checksum+size instead of modtime+size updateModTime bool // if set update the modtime if hashes identical and checking with modtime+size forceModTimeMatch bool // if set assume modtimes match } // default set of options for equal() func defaultEqualOpt(ctx context.Context) equalOpt { ci := fs.GetConfig(ctx) return equalOpt{ sizeOnly: ci.SizeOnly, checkSum: ci.CheckSum, updateModTime: !ci.NoUpdateModTime, forceModTimeMatch: false, } } // DirsEqualOpt represents options for DirsEqual function() type DirsEqualOpt struct { ModifyWindow time.Duration // Max time diff to be considered the same SetDirModtime bool // whether to consider dir modtime SetDirMetadata bool // whether to consider dir metadata } var modTimeUploadOnce sync.Once // emit a log if we are about to upload a file to set its modification time func logModTimeUpload(dst fs.Object) { modTimeUploadOnce.Do(func() { fs.Logf(dst.Fs(), "Forced to upload files to set modification times on this backend.") }) } // EqualFn allows replacing Equal() with a custom function during NeedTransfer() type ( EqualFn func(ctx context.Context, src fs.ObjectInfo, dst fs.Object) bool equalFnContextKey struct{} ) var equalFnKey = equalFnContextKey{} // WithEqualFn stores equalFn in ctx and returns a copy of ctx in which equalFnKey = equalFn func WithEqualFn(ctx context.Context, equalFn EqualFn) context.Context { return context.WithValue(ctx, equalFnKey, equalFn) } func equal(ctx context.Context, src fs.ObjectInfo, dst fs.Object, opt equalOpt) bool { ci := fs.GetConfig(ctx) logger, _ := GetLogger(ctx) if sizeDiffers(ctx, src, dst) { fs.Debugf(src, "Sizes differ (src %d vs dst %d)", src.Size(), dst.Size()) logger(ctx, Differ, src, dst, nil) return false } if opt.sizeOnly { fs.Debugf(src, "Sizes identical") logger(ctx, Match, src, dst, nil) return true } // Assert: Size is equal or being ignored // If checking checksum and not modtime if opt.checkSum { // Check the hash same, ht, _ := CheckHashes(ctx, src, dst) if !same { fs.Debugf(src, "%v differ", ht) logger(ctx, Differ, src, dst, nil) return false } if ht == hash.None { common := src.Fs().Hashes().Overlap(dst.Fs().Hashes()) if common.Count() == 0 { checksumWarning.Do(func() { fs.Logf(dst.Fs(), "--checksum is in use but the source and destination have no hashes in common; falling back to --size-only") }) } fs.Debugf(src, "Size of src and dst objects identical") } else { fs.Debugf(src, "Size and %v of src and dst objects identical", ht) } logger(ctx, Match, src, dst, nil) return true } srcModTime := src.ModTime(ctx) if !opt.forceModTimeMatch { // Sizes the same so check the mtime modifyWindow := fs.GetModifyWindow(ctx, src.Fs(), dst.Fs()) if modifyWindow == fs.ModTimeNotSupported { fs.Debugf(src, "Sizes identical") logger(ctx, Match, src, dst, nil) return true } dstModTime := dst.ModTime(ctx) dt := dstModTime.Sub(srcModTime) if dt < modifyWindow && dt > -modifyWindow { fs.Debugf(src, "Size and modification time the same (differ by %s, within tolerance %s)", dt, modifyWindow) logger(ctx, Match, src, dst, nil) return true } fs.Debugf(src, "Modification times differ by %s: %v, %v", dt, srcModTime, dstModTime) } // Check if the hashes are the same same, ht, _ := CheckHashes(ctx, src, dst) if !same { fs.Debugf(src, "%v differ", ht) logger(ctx, Differ, src, dst, nil) return false } if ht == hash.None && !ci.RefreshTimes { // if couldn't check hash, return that they differ logger(ctx, Differ, src, dst, nil) return false } // mod time differs but hash is the same to reset mod time if required if opt.updateModTime { if !SkipDestructive(ctx, src, "update modification time") { // Size and hash the same but mtime different // Error if objects are treated as immutable if ci.Immutable { fs.Errorf(dst, "Timestamp mismatch between immutable objects") logger(ctx, Differ, src, dst, nil) return false } // Update the mtime of the dst object here err := dst.SetModTime(ctx, srcModTime) if errors.Is(err, fs.ErrorCantSetModTime) { logModTimeUpload(dst) fs.Infof(dst, "src and dst identical but can't set mod time without re-uploading") logger(ctx, Differ, src, dst, nil) return false } else if errors.Is(err, fs.ErrorCantSetModTimeWithoutDelete) { logModTimeUpload(dst) fs.Infof(dst, "src and dst identical but can't set mod time without deleting and re-uploading") // Remove the file if BackupDir isn't set. If BackupDir is set we would rather have the old file // put in the BackupDir than deleted which is what will happen if we don't delete it. if ci.BackupDir == "" { err = dst.Remove(ctx) if err != nil { fs.Errorf(dst, "failed to delete before re-upload: %v", err) } } logger(ctx, Differ, src, dst, nil) return false } else if err != nil { err = fs.CountError(ctx, err) fs.Errorf(dst, "Failed to set modification time: %v", err) } else { fs.Infof(src, "Updated modification time in destination") } } } logger(ctx, Match, src, dst, nil) return true } // CommonHash returns a single hash.Type and a HashOption with that // type which is in common between the two fs.Fs. func CommonHash(ctx context.Context, fa, fb fs.Info) (hash.Type, *fs.HashesOption) { ci := fs.GetConfig(ctx) // work out which hash to use - limit to 1 hash in common var common hash.Set hashType := hash.None if !ci.IgnoreChecksum { common = fb.Hashes().Overlap(fa.Hashes()) if common.Count() > 0 { hashType = common.GetOne() common = hash.Set(hashType) } } return hashType, &fs.HashesOption{Hashes: common} } // SameObject returns true if src and dst could be pointing to the // same object. func SameObject(src, dst fs.Object) bool { srcFs, dstFs := src.Fs(), dst.Fs() if !SameConfig(srcFs, dstFs) { // If same remote type then check ID of objects if available doSrcID, srcIDOK := src.(fs.IDer) doDstID, dstIDOK := dst.(fs.IDer) if srcIDOK && dstIDOK && SameRemoteType(srcFs, dstFs) { srcID, dstID := doSrcID.ID(), doDstID.ID() if srcID != "" && srcID == dstID { return true } } return false } srcPath := path.Join(srcFs.Root(), src.Remote()) dstPath := path.Join(dstFs.Root(), dst.Remote()) if srcFs.Features().IsLocal && dstFs.Features().IsLocal && runtime.GOOS == "darwin" { if norm.NFC.String(srcPath) == norm.NFC.String(dstPath) { return true } } if dst.Fs().Features().CaseInsensitive { srcPath = strings.ToLower(srcPath) dstPath = strings.ToLower(dstPath) } return srcPath == dstPath } // Move src object to dst or fdst if nil. If dst is nil then it uses // remote as the name of the new object. // // Note that you must check the destination does not exist before // calling this and pass it as dst. If you pass dst=nil and the // destination does exist then this may create duplicates or return // errors. // // It returns the destination object if possible. Note that this may // be nil. // // This is accounted as a check. func Move(ctx context.Context, fdst fs.Fs, dst fs.Object, remote string, src fs.Object) (newDst fs.Object, err error) { return move(ctx, fdst, dst, remote, src, false) } // MoveTransfer moves src object to dst or fdst if nil. If dst is nil // then it uses remote as the name of the new object. // // This is identical to Move but is accounted as a transfer. func MoveTransfer(ctx context.Context, fdst fs.Fs, dst fs.Object, remote string, src fs.Object) (newDst fs.Object, err error) { return move(ctx, fdst, dst, remote, src, true) } // move - see Move for help func move(ctx context.Context, fdst fs.Fs, dst fs.Object, remote string, src fs.Object, isTransfer bool) (newDst fs.Object, err error) { origRemote := remote // avoid double-transform on fallback to copy remote = transform.Path(ctx, remote, false) ci := fs.GetConfig(ctx) newDst = dst if ci.DryRun && dst != nil && SameObject(src, dst) && src.Remote() == transform.Path(ctx, dst.Remote(), false) { return // avoid SkipDestructive log for objects that won't really be moved } var tr *accounting.Transfer if isTransfer { tr = accounting.Stats(ctx).NewTransfer(src, fdst) } else { tr = accounting.Stats(ctx).NewCheckingTransfer(src, "moving") } defer func() { if err == nil { accounting.Stats(ctx).Renames(1) } tr.Done(ctx, err) }() action := "move" if remote != src.Remote() { action += " to " + remote } if SkipDestructive(ctx, src, action) { in := tr.Account(ctx, nil) in.DryRun(src.Size()) return newDst, nil } // See if we have Move available if doMove := fdst.Features().Move; doMove != nil && (SameConfig(src.Fs(), fdst) || (SameRemoteType(src.Fs(), fdst) && (fdst.Features().ServerSideAcrossConfigs || ci.ServerSideAcrossConfigs))) { // Delete destination if it exists and is not the same file as src (could be same file while seemingly different if the remote is case insensitive) if dst != nil { remote = transform.Path(ctx, dst.Remote(), false) if !SameObject(src, dst) { err = DeleteFile(ctx, dst) if err != nil { return newDst, err } } else if src.Remote() == remote { return newDst, nil } else if needsMoveCaseInsensitive(fdst, fdst, remote, src.Remote(), false) { doMove = func(ctx context.Context, src fs.Object, remote string) (fs.Object, error) { return MoveCaseInsensitive(ctx, fdst, fdst, remote, src.Remote(), false, src) } } } else if needsMoveCaseInsensitive(fdst, fdst, remote, src.Remote(), false) { doMove = func(ctx context.Context, src fs.Object, remote string) (fs.Object, error) { return MoveCaseInsensitive(ctx, fdst, fdst, remote, src.Remote(), false, src) } } // Move dst <- src in := tr.Account(ctx, nil) // account the transfer in.ServerSideTransferStart() newDst, err = doMove(ctx, src, remote) switch err { case nil: if newDst != nil && src.String() != newDst.String() { fs.Infof(src, "Moved (server-side) to: %s", newDst.String()) } else { fs.Infof(src, "Moved (server-side)") } in.ServerSideMoveEnd(newDst.Size()) // account the bytes for the server-side transfer _ = in.Close() return newDst, nil case fs.ErrorCantMove: fs.Debugf(src, "Can't move, switching to copy") _ = in.Close() default: err = fs.CountError(ctx, err) fs.Errorf(src, "Couldn't move: %v", err) _ = in.Close() return newDst, err } } // Move not found or didn't work so copy dst <- src if origRemote != remote { dst = nil } newDst, err = Copy(ctx, fdst, dst, origRemote, src) if err != nil { fs.Errorf(src, "Not deleting source as copy failed: %v", err) return newDst, err } // Delete src if no error on copy return newDst, DeleteFile(ctx, src) } // CanServerSideMove returns true if fdst support server-side moves or // server-side copies // // Some remotes simulate rename by server-side copy and delete, so include // remotes that implements either Mover or Copier. func CanServerSideMove(fdst fs.Fs) bool { canMove := fdst.Features().Move != nil canCopy := fdst.Features().Copy != nil return canMove || canCopy } // SuffixName adds the current --suffix to the remote, obeying // --suffix-keep-extension if set func SuffixName(ctx context.Context, remote string) string { ci := fs.GetConfig(ctx) if ci.Suffix == "" { return remote } if ci.SuffixKeepExtension { return transform.SuffixKeepExtension(remote, ci.Suffix) } return remote + ci.Suffix } // DeleteFileWithBackupDir deletes a single file respecting --dry-run // and accumulating stats and errors. // // If backupDir is set then it moves the file to there instead of // deleting func DeleteFileWithBackupDir(ctx context.Context, dst fs.Object, backupDir fs.Fs) (err error) { tr := accounting.Stats(ctx).NewCheckingTransfer(dst, "deleting") defer func() { tr.Done(ctx, err) }() err = accounting.Stats(ctx).DeleteFile(ctx, dst.Size()) if err != nil { return err } action, actioned := "delete", "Deleted" if backupDir != nil { action, actioned = "move into backup dir", "Moved into backup dir" } skip := SkipDestructive(ctx, dst, action) if skip { // do nothing } else if backupDir != nil { err = MoveBackupDir(ctx, backupDir, dst) } else { err = dst.Remove(ctx) } if err != nil { fs.Errorf(dst, "Couldn't %s: %v", action, err) err = fs.CountError(ctx, err) } else if !skip { fs.Infof(dst, "%s", actioned) } return err } // DeleteFile deletes a single file respecting --dry-run and accumulating stats and errors. // // If useBackupDir is set and --backup-dir is in effect then it moves // the file to there instead of deleting func DeleteFile(ctx context.Context, dst fs.Object) (err error) { return DeleteFileWithBackupDir(ctx, dst, nil) } // DeleteFilesWithBackupDir removes all the files passed in the // channel // // If backupDir is set the files will be placed into that directory // instead of being deleted. func DeleteFilesWithBackupDir(ctx context.Context, toBeDeleted fs.ObjectsChan, backupDir fs.Fs) error { var wg sync.WaitGroup ci := fs.GetConfig(ctx) wg.Add(ci.Checkers) var errorCount atomic.Int32 var fatalErrorCount atomic.Int32 for range ci.Checkers { go func() { defer wg.Done() for dst := range toBeDeleted { err := DeleteFileWithBackupDir(ctx, dst, backupDir) if err != nil { errorCount.Add(1) logger, _ := GetLogger(ctx) logger(ctx, TransferError, nil, dst, err) if fserrors.IsFatalError(err) { fs.Errorf(dst, "Got fatal error on delete: %s", err) fatalErrorCount.Add(1) return } } } }() } fs.Debugf(nil, "Waiting for deletions to finish") wg.Wait() if errorCount.Load() > 0 { err := fmt.Errorf("failed to delete %d files", errorCount.Load()) if fatalErrorCount.Load() > 0 { return fserrors.FatalError(err) } return err } return nil } // DeleteFiles removes all the files passed in the channel func DeleteFiles(ctx context.Context, toBeDeleted fs.ObjectsChan) error { return DeleteFilesWithBackupDir(ctx, toBeDeleted, nil) } // ReadFile reads the object into memory and accounts it func ReadFile(ctx context.Context, o fs.Object) (b []byte, err error) { tr := accounting.Stats(ctx).NewTransfer(o, nil) defer func() { tr.Done(ctx, err) }() in0, err := Open(ctx, o) if err != nil { return nil, fmt.Errorf("failed to open %v: %w", o, err) } in := tr.Account(ctx, in0).WithBuffer() // account and buffer the transfer defer fs.CheckClose(in, &err) // closes in0 also b, err = io.ReadAll(in) if err != nil { return nil, fmt.Errorf("failed to read %v: %w", o, err) } return b, nil } // SameRemoteType returns true if fdst and fsrc are the same type func SameRemoteType(fdst, fsrc fs.Info) bool { return fmt.Sprintf("%T", fdst) == fmt.Sprintf("%T", fsrc) } // SameConfig returns true if fdst and fsrc are using the same config // file entry func SameConfig(fdst, fsrc fs.Info) bool { return fdst.Name() == fsrc.Name() } // SameConfigArr returns true if any of []fsrcs has same config file entry with fdst func SameConfigArr(fdst fs.Info, fsrcs []fs.Fs) bool { for _, fsrc := range fsrcs { if fdst.Name() == fsrc.Name() { return true } } return false } // Same returns true if fdst and fsrc point to the same underlying Fs func Same(fdst, fsrc fs.Info) bool { return SameConfig(fdst, fsrc) && strings.Trim(fdst.Root(), "/") == strings.Trim(fsrc.Root(), "/") } // fixRoot returns the Root with a trailing / if not empty. // // It returns a case folded version for case insensitive file systems func fixRoot(f fs.Info) (s string, folded string) { s = strings.Trim(filepath.ToSlash(f.Root()), "/") if s != "" { s += "/" } folded = s if f.Features().CaseInsensitive { folded = strings.ToLower(s) } return s, folded } // OverlappingFilterCheck returns true if fdst and fsrc point to the same // underlying Fs and they overlap without fdst being excluded by any filter rule. func OverlappingFilterCheck(ctx context.Context, fdst fs.Fs, fsrc fs.Fs) bool { if !SameConfig(fdst, fsrc) { return false } fdstRoot, fdstRootFolded := fixRoot(fdst) fsrcRoot, fsrcRootFolded := fixRoot(fsrc) if fdstRootFolded == fsrcRootFolded { return true } else if strings.HasPrefix(fdstRootFolded, fsrcRootFolded) { fdstRelative := fdstRoot[len(fsrcRoot):] return filterCheck(ctx, fsrc, fdstRelative) } else if strings.HasPrefix(fsrcRootFolded, fdstRootFolded) { fsrcRelative := fsrcRoot[len(fdstRoot):] return filterCheck(ctx, fdst, fsrcRelative) } return false } // filterCheck checks if dir is included in f func filterCheck(ctx context.Context, f fs.Fs, dir string) bool { fi := filter.GetConfig(ctx) includeDirectory := fi.IncludeDirectory(ctx, f) include, err := includeDirectory(dir) if err != nil { fs.Errorf(f, "Failed to discover whether directory is included: %v", err) return true } return include } // SameDir returns true if fdst and fsrc point to the same // underlying Fs and they are the same directory. func SameDir(fdst, fsrc fs.Info) bool { if !SameConfig(fdst, fsrc) { return false } _, fdstRootFolded := fixRoot(fdst) _, fsrcRootFolded := fixRoot(fsrc) return fdstRootFolded == fsrcRootFolded } // Retry runs fn up to maxTries times if it returns a retriable error func Retry(ctx context.Context, o any, maxTries int, fn func() error) (err error) { for tries := 1; tries <= maxTries; tries++ { // Call the function which might error err = fn() if err == nil { break } // End if ctx is in error if fserrors.ContextError(ctx, &err) { break } // Retry if err returned a retry error if fserrors.IsRetryError(err) || fserrors.ShouldRetry(err) { fs.Debugf(o, "Received error: %v - low level retry %d/%d", err, tries, maxTries) continue } else if t, ok := pacer.IsRetryAfter(err); ok { fs.Debugf(o, "Sleeping for %v (as indicated by the server) to obey Retry-After error: %v", t, err) time.Sleep(t) continue } break } return err } // ListFn lists the Fs to the supplied function // // Lists in parallel which may get them out of order func ListFn(ctx context.Context, f fs.Fs, fn func(fs.Object)) error { ci := fs.GetConfig(ctx) return walk.ListR(ctx, f, "", false, ci.MaxDepth, walk.ListObjects, func(entries fs.DirEntries) error { entries.ForObject(fn) return nil }) } // StdoutMutex mutex for synchronized output on stdout var StdoutMutex sync.Mutex // SyncPrintf is a global var holding the Printf function so that it // can be overridden. // // This writes to stdout holding the StdoutMutex. If you are going to // override it and write to os.Stdout then you should hold the // StdoutMutex too. var SyncPrintf = func(format string, a ...any) { StdoutMutex.Lock() defer StdoutMutex.Unlock() fmt.Printf(format, a...) } // SyncFprintf - Synchronized fmt.Fprintf // // Ignores errors from Fprintf. // // Prints to stdout if w is nil func SyncFprintf(w io.Writer, format string, a ...any) { if w == nil || w == os.Stdout { SyncPrintf(format, a...) } else { StdoutMutex.Lock() defer StdoutMutex.Unlock() _, _ = fmt.Fprintf(w, format, a...) } } // SizeString make string representation of size for output // // Optional human-readable format including a binary suffix func SizeString(size int64, humanReadable bool) string { if humanReadable { if size < 0 { return "-" + fs.SizeSuffix(-size).String() } return fs.SizeSuffix(size).String() } return strconv.FormatInt(size, 10) } // SizeStringField make string representation of size for output in fixed width field // // Optional human-readable format including a binary suffix // Argument rawWidth is used to format field with of raw value. When humanReadable // option the width is hard coded to 9, since SizeSuffix strings have precision 3 // and longest value will be "999.999Ei". This way the width can be optimized // depending to the humanReadable option. To always use a longer width the return // value can always be fed into another format string with a specific field with. func SizeStringField(size int64, humanReadable bool, rawWidth int) string { str := SizeString(size, humanReadable) if humanReadable { return fmt.Sprintf("%9s", str) } return fmt.Sprintf("%[2]*[1]s", str, rawWidth) } // CountString make string representation of count for output // // Optional human-readable format including a decimal suffix func CountString(count int64, humanReadable bool) string { if humanReadable { if count < 0 { return "-" + fs.CountSuffix(-count).String() } return fs.CountSuffix(count).String() } return strconv.FormatInt(count, 10) } // CountStringField make string representation of count for output in fixed width field // // Similar to SizeStringField, but human readable with decimal prefix and field width 8 // since there is no 'i' in the decimal prefix symbols (e.g. "999.999E") func CountStringField(count int64, humanReadable bool, rawWidth int) string { str := CountString(count, humanReadable) if humanReadable { return fmt.Sprintf("%8s", str) } return fmt.Sprintf("%[2]*[1]s", str, rawWidth) } // List the Fs to the supplied writer // // Shows size and path - obeys includes and excludes. // // Lists in parallel which may get them out of order func List(ctx context.Context, f fs.Fs, w io.Writer) error { ci := fs.GetConfig(ctx) return ListFn(ctx, f, func(o fs.Object) { SyncFprintf(w, "%s %s\n", SizeStringField(o.Size(), ci.HumanReadable, 9), o.Remote()) }) } // ListLong lists the Fs to the supplied writer // // Shows size, mod time and path - obeys includes and excludes. // // Lists in parallel which may get them out of order func ListLong(ctx context.Context, f fs.Fs, w io.Writer) error { ci := fs.GetConfig(ctx) return ListFn(ctx, f, func(o fs.Object) { tr := accounting.Stats(ctx).NewCheckingTransfer(o, "listing") defer func() { tr.Done(ctx, nil) }() modTime := o.ModTime(ctx) SyncFprintf(w, "%s %s %s\n", SizeStringField(o.Size(), ci.HumanReadable, 9), modTime.Local().Format("2006-01-02 15:04:05.000000000"), o.Remote()) }) } // HashSum returns the human-readable hash for ht passed in. This may // be UNSUPPORTED or ERROR. If it isn't returning a valid hash it will // return an error. func HashSum(ctx context.Context, ht hash.Type, base64Encoded bool, downloadFlag bool, o fs.Object) (string, error) { var sum string var err error // If downloadFlag is true, download and hash the file. // If downloadFlag is false, call o.Hash asking the remote for the hash if downloadFlag { // Setup: Define accounting, open the file with NewReOpen to provide restarts, account for the transfer, and setup a multi-hasher with the appropriate type // Execution: io.Copy file to hasher, get hash and encode in hex tr := accounting.Stats(ctx).NewTransfer(o, nil) defer func() { tr.Done(ctx, err) }() // Open with NewReOpen to provide restarts var options []fs.OpenOption for _, option := range fs.GetConfig(ctx).DownloadHeaders { options = append(options, option) } var in io.ReadCloser in, err = Open(ctx, o, options...) if err != nil { return "ERROR", fmt.Errorf("failed to open file %v: %w", o, err) } // Account and buffer the transfer in = tr.Account(ctx, in).WithBuffer() // Setup hasher hasher, err := hash.NewMultiHasherTypes(hash.NewHashSet(ht)) if err != nil { return "UNSUPPORTED", fmt.Errorf("hash unsupported: %w", err) } // Copy to hasher, downloading the file and passing directly to hash _, err = io.Copy(hasher, in) if err != nil { return "ERROR", fmt.Errorf("failed to copy file to hasher: %w", err) } // Get hash as hex or base64 encoded string sum, err = hasher.SumString(ht, base64Encoded) if err != nil { return "ERROR", fmt.Errorf("hasher returned an error: %w", err) } } else { tr := accounting.Stats(ctx).NewCheckingTransfer(o, "hashing") defer func() { tr.Done(ctx, err) }() sum, err = o.Hash(ctx, ht) if base64Encoded { hexBytes, _ := hex.DecodeString(sum) sum = base64.URLEncoding.EncodeToString(hexBytes) } if err == hash.ErrUnsupported { return "", fmt.Errorf("hash unsupported: %w", err) } if err != nil { return "", fmt.Errorf("failed to get hash %v from backend: %w", ht, err) } } return sum, nil } // HashLister does an md5sum equivalent for the hash type passed in // Updated to handle both standard hex encoding and base64 // Updated to perform multiple hashes concurrently func HashLister(ctx context.Context, ht hash.Type, outputBase64 bool, downloadFlag bool, f fs.Fs, w io.Writer) error { width := hash.Width(ht, outputBase64) // Use --checkers concurrency unless downloading in which case use --transfers concurrency := fs.GetConfig(ctx).Checkers if downloadFlag { concurrency = fs.GetConfig(ctx).Transfers } concurrencyControl := make(chan struct{}, concurrency) var wg sync.WaitGroup err := ListFn(ctx, f, func(o fs.Object) { wg.Add(1) concurrencyControl <- struct{}{} go func() { defer func() { <-concurrencyControl wg.Done() }() sum, err := HashSum(ctx, ht, outputBase64, downloadFlag, o) if err != nil { fs.Errorf(o, "%v", fs.CountError(ctx, err)) return } SyncFprintf(w, "%*s %s\n", width, sum, o.Remote()) }() }) wg.Wait() return err } // HashSumStream outputs a line compatible with md5sum to w based on the // input stream in and the hash type ht passed in. If outputBase64 is // set then the hash will be base64 instead of hexadecimal. func HashSumStream(ht hash.Type, outputBase64 bool, in io.ReadCloser, w io.Writer) error { hasher, err := hash.NewMultiHasherTypes(hash.NewHashSet(ht)) if err != nil { return fmt.Errorf("hash unsupported: %w", err) } written, err := io.Copy(hasher, in) fs.Debugf(nil, "Creating %s hash of %d bytes read from input stream", ht, written) if err != nil { return fmt.Errorf("failed to copy input to hasher: %w", err) } sum, err := hasher.SumString(ht, outputBase64) if err != nil { return fmt.Errorf("hasher returned an error: %w", err) } width := hash.Width(ht, outputBase64) SyncFprintf(w, "%*s -\n", width, sum) return nil } // Count counts the objects and their sizes in the Fs // // Obeys includes and excludes func Count(ctx context.Context, f fs.Fs) (objects int64, size int64, sizelessObjects int64, err error) { err = ListFn(ctx, f, func(o fs.Object) { atomic.AddInt64(&objects, 1) objectSize := o.Size() if objectSize < 0 { atomic.AddInt64(&sizelessObjects, 1) } else if objectSize > 0 { atomic.AddInt64(&size, objectSize) } }) return } // ConfigMaxDepth returns the depth to use for a recursive or non recursive listing. func ConfigMaxDepth(ctx context.Context, recursive bool) int { ci := fs.GetConfig(ctx) depth := ci.MaxDepth if !recursive && depth < 0 { depth = 1 } return depth } // ListDir lists the directories/buckets/containers in the Fs to the supplied writer func ListDir(ctx context.Context, f fs.Fs, w io.Writer) error { ci := fs.GetConfig(ctx) return walk.ListR(ctx, f, "", false, ConfigMaxDepth(ctx, false), walk.ListDirs, func(entries fs.DirEntries) error { entries.ForDir(func(dir fs.Directory) { if dir != nil { SyncFprintf(w, "%s %13s %s %s\n", SizeStringField(dir.Size(), ci.HumanReadable, 12), dir.ModTime(ctx).Local().Format("2006-01-02 15:04:05"), CountStringField(dir.Items(), ci.HumanReadable, 9), dir.Remote()) } }) return nil }) } // Mkdir makes a destination directory or container func Mkdir(ctx context.Context, f fs.Fs, dir string) error { if SkipDestructive(ctx, fs.LogDirName(f, dir), "make directory") { return nil } fs.Infof(fs.LogDirName(f, dir), "Making directory") err := f.Mkdir(ctx, dir) if err != nil { err = fs.CountError(ctx, err) return err } return nil } // MkdirMetadata makes a destination directory or container with metadata // // If the destination Fs doesn't support this it will fall back to // Mkdir and in this case newDst will be nil. func MkdirMetadata(ctx context.Context, f fs.Fs, dir string, metadata fs.Metadata) (newDst fs.Directory, err error) { do := f.Features().MkdirMetadata if do == nil { return nil, Mkdir(ctx, f, dir) } logName := fs.LogDirName(f, dir) if SkipDestructive(ctx, logName, "make directory") { return nil, nil } fs.Debugf(fs.LogDirName(f, dir), "Making directory with metadata") newDst, err = do(ctx, dir, metadata) if err != nil { err = fs.CountError(ctx, err) return nil, err } if mtime, ok := metadata["mtime"]; ok { fs.Infof(logName, "Made directory with metadata (mtime=%s)", mtime) } else { fs.Infof(logName, "Made directory with metadata") } return newDst, err } // MkdirModTime makes a destination directory or container with modtime // // It will try to make the directory with MkdirMetadata and if that // succeeds it will return a non-nil newDst. In all other cases newDst // will be nil. // // If the directory was created with MkDir then it will attempt to use // Fs.DirSetModTime to update the directory modtime if available. func MkdirModTime(ctx context.Context, f fs.Fs, dir string, modTime time.Time) (newDst fs.Directory, err error) { logName := fs.LogDirName(f, dir) if SkipDestructive(ctx, logName, "make directory") { return nil, nil } metadata := fs.Metadata{ "mtime": modTime.Format(time.RFC3339Nano), } newDst, err = MkdirMetadata(ctx, f, dir, metadata) if err != nil { return nil, err } if newDst != nil { // The directory was created and we have logged already return newDst, nil } // The directory was created with Mkdir then we should try to set the time if do := f.Features().DirSetModTime; do != nil { err = do(ctx, dir, modTime) } fs.Infof(logName, "Made directory with modification time %v", modTime) return newDst, err } // TryRmdir removes a container but not if not empty. It doesn't // count errors but may return one. func TryRmdir(ctx context.Context, f fs.Fs, dir string) error { accounting.Stats(ctx).DeletedDirs(1) if SkipDestructive(ctx, fs.LogDirName(f, dir), "remove directory") { return nil } fs.Infof(fs.LogDirName(f, dir), "Removing directory") return f.Rmdir(ctx, dir) } // Rmdir removes a container but not if not empty func Rmdir(ctx context.Context, f fs.Fs, dir string) error { err := TryRmdir(ctx, f, dir) if err != nil { err = fs.CountError(ctx, err) return err } return err } // Purge removes a directory and all of its contents func Purge(ctx context.Context, f fs.Fs, dir string) (err error) { doFallbackPurge := true if doPurge := f.Features().Purge; doPurge != nil { doFallbackPurge = false accounting.Stats(ctx).DeletedDirs(1) if SkipDestructive(ctx, fs.LogDirName(f, dir), "purge directory") { return nil } err = doPurge(ctx, dir) if errors.Is(err, fs.ErrorCantPurge) { doFallbackPurge = true } } if doFallbackPurge { // DeleteFiles and Rmdir observe --dry-run err = DeleteFiles(ctx, listToChan(ctx, f, dir)) if err != nil { return err } err = Rmdirs(ctx, f, dir, false) } if err != nil { err = fs.CountError(ctx, err) return err } return nil } // Delete removes all the contents of a container. Unlike Purge, it // obeys includes and excludes. func Delete(ctx context.Context, f fs.Fs) error { ci := fs.GetConfig(ctx) delChan := make(fs.ObjectsChan, ci.Checkers) delErr := make(chan error, 1) go func() { delErr <- DeleteFiles(ctx, delChan) }() err := ListFn(ctx, f, func(o fs.Object) { delChan <- o }) close(delChan) delError := <-delErr if err == nil { err = delError } return err } // RemoveExisting removes an existing file in a safe way so that it // can be restored if the operation fails. // // This first detects if there is an existing file and renames it to a // temporary name if there is. // // The returned cleanup function should be called on a defer statement // with a pointer to the error returned. It will revert the changes if // there is an error or delete the existing file if not. func RemoveExisting(ctx context.Context, f fs.Fs, remote string, operation string) (cleanup func(*error), err error) { existingObj, err := f.NewObject(ctx, remote) if err != nil { return func(*error) {}, nil } doMove := f.Features().Move if doMove == nil { return nil, fmt.Errorf("%s: destination file exists already and can't rename", operation) } // Avoid making the leaf name longer if it's already lengthy to avoid // trouble with file name length limits. suffix := "." + random.String(8) var remoteSaved string if len(path.Base(remote)) > 100 { remoteSaved = TruncateString(remote, len(remote)-len(suffix)) + suffix } else { remoteSaved = remote + suffix } fs.Debugf(existingObj, "%s: renaming existing object to %q before starting", operation, remoteSaved) existingObj, err = doMove(ctx, existingObj, remoteSaved) if err != nil { return nil, fmt.Errorf("%s: failed to rename existing file: %w", operation, err) } return func(perr *error) { if *perr == nil { fs.Debugf(existingObj, "%s: removing renamed existing file after operation", operation) err := existingObj.Remove(ctx) if err != nil { *perr = fmt.Errorf("%s: failed to remove renamed existing file: %w", operation, err) } } else { fs.Debugf(existingObj, "%s: renaming existing back after failed operation", operation) _, renameErr := doMove(ctx, existingObj, remote) if renameErr != nil { fs.Errorf(existingObj, "%s: failed to restore existing file after failed operation: %v", operation, renameErr) } } }, nil } // listToChan will transfer all objects in the listing to the output // // If an error occurs, the error will be logged, and it will close the // channel. // // If the error was ErrorDirNotFound then it will be ignored func listToChan(ctx context.Context, f fs.Fs, dir string) fs.ObjectsChan { ci := fs.GetConfig(ctx) o := make(fs.ObjectsChan, ci.Checkers) go func() { defer close(o) err := walk.ListR(ctx, f, dir, true, ci.MaxDepth, walk.ListObjects, func(entries fs.DirEntries) error { entries.ForObject(func(obj fs.Object) { o <- obj }) return nil }) if err != nil && err != fs.ErrorDirNotFound { err = fmt.Errorf("failed to list: %w", err) err = fs.CountError(ctx, err) fs.Errorf(nil, "%v", err) } }() return o } // CleanUp removes the trash for the Fs func CleanUp(ctx context.Context, f fs.Fs) error { doCleanUp := f.Features().CleanUp if doCleanUp == nil { return fmt.Errorf("%v doesn't support cleanup", f) } if SkipDestructive(ctx, f, "clean up old files") { return nil } return doCleanUp(ctx) } // wrap a Reader and a Closer together into a ReadCloser type readCloser struct { io.Reader io.Closer } // Cat any files to the io.Writer // // if offset == 0 it will be ignored // if offset > 0 then the file will be seeked to that offset // if offset < 0 then the file will be seeked that far from the end // // if count < 0 then it will be ignored // if count >= 0 then only that many characters will be output func Cat(ctx context.Context, f fs.Fs, w io.Writer, offset, count int64, sep []byte) error { var mu sync.Mutex ci := fs.GetConfig(ctx) return ListFn(ctx, f, func(o fs.Object) { var err error tr := accounting.Stats(ctx).NewTransfer(o, nil) defer func() { tr.Done(ctx, err) }() opt := fs.RangeOption{Start: offset, End: -1} size := o.Size() if opt.Start < 0 { opt.Start += size } if count >= 0 { opt.End = opt.Start + count - 1 } var options []fs.OpenOption if opt.Start > 0 || opt.End >= 0 { options = append(options, &opt) } for _, option := range ci.DownloadHeaders { options = append(options, option) } var in io.ReadCloser in, err = Open(ctx, o, options...) if err != nil { err = fs.CountError(ctx, err) fs.Errorf(o, "Failed to open: %v", err) return } if count >= 0 { in = &readCloser{Reader: &io.LimitedReader{R: in, N: count}, Closer: in} } in = tr.Account(ctx, in).WithBuffer() // account and buffer the transfer // take the lock just before we output stuff, so at the last possible moment mu.Lock() defer mu.Unlock() _, err = io.Copy(w, in) if err != nil { err = fs.CountError(ctx, err) fs.Errorf(o, "Failed to send to output: %v", err) } if len(sep) > 0 { _, err = w.Write(sep) if err != nil { err = fs.CountError(ctx, err) fs.Errorf(o, "Failed to send separator to output: %v", err) } } }) } // Rcat reads data from the Reader until EOF and uploads it to a file on remote // // in is closed at the end of the transfer func Rcat(ctx context.Context, fdst fs.Fs, dstFileName string, in io.ReadCloser, modTime time.Time, meta fs.Metadata) (dst fs.Object, err error) { return rcatSrc(ctx, fdst, dstFileName, in, modTime, meta, nil) } // rcatSrc reads data from the Reader until EOF and uploads it to a file on remote // // in is closed at the end of the transfer // // Pass in fsrc if known or nil if not func rcatSrc(ctx context.Context, fdst fs.Fs, dstFileName string, in io.ReadCloser, modTime time.Time, meta fs.Metadata, fsrc fs.Fs) (dst fs.Object, err error) { if SkipDestructive(ctx, dstFileName, "upload from pipe") { // prevents "broken pipe" errors _, err = io.Copy(io.Discard, in) return nil, err } ci := fs.GetConfig(ctx) tr := accounting.Stats(ctx).NewTransferRemoteSize(dstFileName, -1, nil, fdst) defer func() { tr.Done(ctx, err) }() var streamIn io.Reader = tr.Account(ctx, in).WithBuffer() readCounter := readers.NewCountingReader(streamIn) var trackingIn io.Reader var hasher *hash.MultiHasher var options []fs.OpenOption if !ci.IgnoreChecksum { hashes := hash.NewHashSet(fdst.Hashes().GetOne()) // just pick one hash hashOption := &fs.HashesOption{Hashes: hashes} options = append(options, hashOption) hasher, err = hash.NewMultiHasherTypes(hashes) if err != nil { return nil, err } trackingIn = io.TeeReader(readCounter, hasher) } else { trackingIn = readCounter } for _, option := range ci.UploadHeaders { options = append(options, option) } if ci.MetadataSet != nil { options = append(options, fs.MetadataOption(ci.MetadataSet)) } // get the sums from the hasher if in use, or nil getSums := func() (sums map[hash.Type]string) { if hasher != nil { sums = hasher.Sums() } return sums } // Read the start of the input and check if it is small enough for direct upload buf := make([]byte, ci.StreamingUploadCutoff) fileIsSmall := false if n, err := io.ReadFull(trackingIn, buf); err == io.EOF || err == io.ErrUnexpectedEOF { fileIsSmall = true buf = buf[:n] } // Read the data we have already read in buf and any further unread streamIn = io.MultiReader(bytes.NewReader(buf), trackingIn) doPutStream := fdst.Features().PutStream // Upload the input if fileIsSmall || doPutStream == nil { var rs io.ReadSeeker if fileIsSmall { fs.Debugf(fdst, "File to upload is small (%d bytes), uploading instead of streaming", len(buf)) rs = bytes.NewReader(buf) } else { fs.Debugf(fdst, "Target remote doesn't support streaming uploads, creating temporary local FS to spool file") spool, err := os.CreateTemp("", "rclone-spool") if err != nil { return nil, fmt.Errorf("failed to create temporary spool file: %v", err) } fileName := spool.Name() defer func() { err := spool.Close() if err != nil { fs.Errorf(fileName, "Failed to close temporary spool file: %v", err) } err = os.Remove(fileName) if err != nil { fs.Errorf(fileName, "Failed to delete temporary spool file: %v", err) } }() _, err = io.Copy(spool, streamIn) if err != nil { return nil, fmt.Errorf("failed to copy to temporary spool file: %v", err) } rs = spool } // Upload with Put with retries - since we have downloaded the file we know the size, and the hashes sums := getSums() size := int64(readCounter.BytesRead()) objInfo := object.NewStaticObjectInfo(dstFileName, modTime, size, false, sums, fsrc).WithMetadata(meta) err = Retry(ctx, objInfo, ci.LowLevelRetries, func() error { _, err = rs.Seek(0, io.SeekStart) if err != nil { return fmt.Errorf("failed to rewind temporary spool file: %v", err) } dst, err = fdst.Put(ctx, rs, objInfo, options...) return err }) } else { // Upload with PutStream with no retries objInfo := object.NewStaticObjectInfo(dstFileName, modTime, -1, false, nil, fsrc).WithMetadata(meta) dst, err = doPutStream(ctx, streamIn, objInfo, options...) } if err != nil { return dst, err } // Check transfer sums := getSums() opt := defaultEqualOpt(ctx) if sums != nil { // force --checksum on if we have hashes opt.checkSum = true } src := object.NewStaticObjectInfo(dstFileName, modTime, int64(readCounter.BytesRead()), false, sums, fdst).WithMetadata(meta) if !equal(ctx, src, dst, opt) { err = fmt.Errorf("corrupted on transfer") err = fs.CountError(ctx, err) fs.Errorf(dst, "%v", err) return dst, err } return dst, nil } // PublicLink adds a "readable by anyone with link" permission on the given file or folder. func PublicLink(ctx context.Context, f fs.Fs, remote string, expire fs.Duration, unlink bool) (string, error) { doPublicLink := f.Features().PublicLink if doPublicLink == nil { return "", fmt.Errorf("%v doesn't support public links", f) } return doPublicLink(ctx, remote, expire, unlink) } // Rmdirs removes any empty directories (or directories only // containing empty directories) under f, including f. // // Rmdirs obeys the filters func Rmdirs(ctx context.Context, f fs.Fs, dir string, leaveRoot bool) error { ci := fs.GetConfig(ctx) fi := filter.GetConfig(ctx) dirEmpty := make(map[string]bool) dirEmpty[dir] = !leaveRoot err := walk.Walk(ctx, f, dir, false, ci.MaxDepth, func(dirPath string, entries fs.DirEntries, err error) error { if err != nil { err = fs.CountError(ctx, err) fs.Errorf(f, "Failed to list %q: %v", dirPath, err) return nil } for _, entry := range entries { switch x := entry.(type) { case fs.Directory: // add a new directory as empty dir := x.Remote() _, found := dirEmpty[dir] if !found { dirEmpty[dir] = true } case fs.Object: // mark the parents of the file as being non-empty dir := x.Remote() for dir != "" { dir = path.Dir(dir) if dir == "." || dir == "/" { dir = "" } empty, found := dirEmpty[dir] // End if we reach a directory which is non-empty if found && !empty { break } dirEmpty[dir] = false } } } return nil }) if err != nil { return fmt.Errorf("failed to rmdirs: %w", err) } // Group directories to delete by level var toDelete [][]string for dir, empty := range dirEmpty { if empty { // If a filter matches the directory then that // directory is a candidate for deletion if fi.IncludeRemote(dir + "/") { level := strings.Count(dir, "/") + 1 // The root directory "" is at the top level if dir == "" { level = 0 } if len(toDelete) < level+1 { toDelete = append(toDelete, make([][]string, level+1-len(toDelete))...) } toDelete[level] = append(toDelete[level], dir) } } } errCount := errcount.New() // Delete all directories at the same level in parallel for level := len(toDelete) - 1; level >= 0; level-- { dirs := toDelete[level] if len(dirs) == 0 { continue } fs.Debugf(nil, "removing %d level %d directories", len(dirs), level) sort.Strings(dirs) g, gCtx := errgroup.WithContext(ctx) g.SetLimit(ci.Checkers) for _, dir := range dirs { // End early if error if gCtx.Err() != nil { break } dir := dir g.Go(func() error { err := TryRmdir(gCtx, f, dir) if err != nil { err = fs.CountError(ctx, err) fs.Errorf(dir, "Failed to rmdir: %v", err) errCount.Add(err) } return nil // don't return errors, just count them }) } err := g.Wait() if err != nil { return err } } return errCount.Err("failed to remove directories") } // GetCompareDest sets up --compare-dest func GetCompareDest(ctx context.Context) (CompareDest []fs.Fs, err error) { ci := fs.GetConfig(ctx) CompareDest, err = cache.GetArr(ctx, ci.CompareDest) if err != nil { return nil, fserrors.FatalError(fmt.Errorf("failed to make fs for --compare-dest %q: %w", ci.CompareDest, err)) } return CompareDest, nil } // compareDest checks --compare-dest to see if src needs to // be copied // // Returns True if src is in --compare-dest func compareDest(ctx context.Context, dst, src fs.Object, CompareDest fs.Fs) (NoNeedTransfer bool, err error) { var remote string if dst == nil { remote = src.Remote() } else { remote = dst.Remote() } CompareDestFile, err := CompareDest.NewObject(ctx, remote) switch err { case fs.ErrorObjectNotFound: return false, nil case nil: break default: return false, err } opt := defaultEqualOpt(ctx) opt.updateModTime = false if equal(ctx, src, CompareDestFile, opt) { fs.Debugf(src, "Destination found in --compare-dest, skipping") return true, nil } return false, nil } // GetCopyDest sets up --copy-dest func GetCopyDest(ctx context.Context, fdst fs.Fs) (CopyDest []fs.Fs, err error) { ci := fs.GetConfig(ctx) CopyDest, err = cache.GetArr(ctx, ci.CopyDest) if err != nil { return nil, fserrors.FatalError(fmt.Errorf("failed to make fs for --copy-dest %q: %w", ci.CopyDest, err)) } if !SameConfigArr(fdst, CopyDest) { return nil, fserrors.FatalError(errors.New("parameter to --copy-dest has to be on the same remote as destination")) } for _, cf := range CopyDest { if cf.Features().Copy == nil { return nil, fserrors.FatalError(errors.New("can't use --copy-dest on a remote which doesn't support server side copy")) } } return CopyDest, nil } // copyDest checks --copy-dest to see if src needs to // be copied // // Returns True if src was copied from --copy-dest func copyDest(ctx context.Context, fdst fs.Fs, dst, src fs.Object, CopyDest, backupDir fs.Fs) (NoNeedTransfer bool, err error) { var remote string if dst == nil { remote = src.Remote() } else { remote = dst.Remote() } CopyDestFile, err := CopyDest.NewObject(ctx, remote) switch err { case fs.ErrorObjectNotFound: return false, nil case nil: break default: return false, err } opt := defaultEqualOpt(ctx) opt.updateModTime = false if equal(ctx, src, CopyDestFile, opt) { if dst == nil || !Equal(ctx, src, dst) { if dst != nil && backupDir != nil { err = MoveBackupDir(ctx, backupDir, dst) if err != nil { return false, fmt.Errorf("moving to --backup-dir failed: %w", err) } // If successful zero out the dstObj as it is no longer there dst = nil } _, err := Copy(ctx, fdst, dst, remote, CopyDestFile) if err != nil { fs.Errorf(src, "Destination found in --copy-dest, error copying") return false, nil } fs.Debugf(src, "Destination found in --copy-dest, using server-side copy") return true, nil } fs.Debugf(src, "Unchanged skipping") return true, nil } fs.Debugf(src, "Destination not found in --copy-dest") return false, nil } // CompareOrCopyDest checks --compare-dest and --copy-dest to see if src // does not need to be copied // // Returns True if src does not need to be copied func CompareOrCopyDest(ctx context.Context, fdst fs.Fs, dst, src fs.Object, CompareOrCopyDest []fs.Fs, backupDir fs.Fs) (NoNeedTransfer bool, err error) { ci := fs.GetConfig(ctx) if len(ci.CompareDest) > 0 { for _, compareF := range CompareOrCopyDest { NoNeedTransfer, err := compareDest(ctx, dst, src, compareF) if NoNeedTransfer || err != nil { return NoNeedTransfer, err } } } else if len(ci.CopyDest) > 0 { for _, copyF := range CompareOrCopyDest { NoNeedTransfer, err := copyDest(ctx, fdst, dst, src, copyF, backupDir) if NoNeedTransfer || err != nil { return NoNeedTransfer, err } } } return false, nil } // NeedTransfer checks to see if src needs to be copied to dst using // the current config. // // Returns a flag which indicates whether the file needs to be // transferred or not. func NeedTransfer(ctx context.Context, dst, src fs.Object) bool { ci := fs.GetConfig(ctx) logger, _ := GetLogger(ctx) if dst == nil { fs.Debugf(src, "Need to transfer - File not found at Destination") logger(ctx, MissingOnDst, src, nil, nil) return true } // If we should ignore existing files, don't transfer if ci.IgnoreExisting { fs.Debugf(src, "Destination exists, skipping") logger(ctx, Match, src, dst, nil) return false } // If we should upload unconditionally if ci.IgnoreTimes { fs.Debugf(src, "Transferring unconditionally as --ignore-times is in use") logger(ctx, Differ, src, dst, nil) return true } // If UpdateOlder is in effect, skip if dst is newer than src if ci.UpdateOlder { srcModTime := src.ModTime(ctx) dstModTime := dst.ModTime(ctx) dt := dstModTime.Sub(srcModTime) // If have a mutually agreed precision then use that modifyWindow := fs.GetModifyWindow(ctx, dst.Fs(), src.Fs()) if modifyWindow == fs.ModTimeNotSupported { // Otherwise use 1 second as a safe default as // the resolution of the time a file was // uploaded. modifyWindow = time.Second } switch { case dt >= modifyWindow: fs.Debugf(src, "Destination is newer than source, skipping") logger(ctx, Match, src, dst, nil) return false case dt <= -modifyWindow: // force --checksum on for the check and do update modtimes by default opt := defaultEqualOpt(ctx) opt.forceModTimeMatch = true if equal(ctx, src, dst, opt) { fs.Debugf(src, "Unchanged skipping") return false } default: // Do a size only compare unless --checksum is set opt := defaultEqualOpt(ctx) opt.sizeOnly = !ci.CheckSum if equal(ctx, src, dst, opt) { fs.Debugf(src, "Destination mod time is within %v of source and files identical, skipping", modifyWindow) return false } fs.Debugf(src, "Destination mod time is within %v of source but files differ, transferring", modifyWindow) } } else { // Check to see if changed or not equalFn, ok := ctx.Value(equalFnKey).(EqualFn) if ok { return !equalFn(ctx, src, dst) } if Equal(ctx, src, dst) && !SameObject(src, dst) { fs.Debugf(src, "Unchanged skipping") return false } } return true } // RcatSize reads data from the Reader until EOF and uploads it to a file on remote. // Pass in size >=0 if known, <0 if not known func RcatSize(ctx context.Context, fdst fs.Fs, dstFileName string, in io.ReadCloser, size int64, modTime time.Time, meta fs.Metadata) (dst fs.Object, err error) { var obj fs.Object if size >= 0 { var err error // Size known use Put tr := accounting.Stats(ctx).NewTransferRemoteSize(dstFileName, size, nil, fdst) defer func() { tr.Done(ctx, err) }() body := io.NopCloser(in) // we let the server close the body in := tr.Account(ctx, body) // account the transfer (no buffering) if SkipDestructive(ctx, dstFileName, "upload from pipe") { // prevents "broken pipe" errors _, err = io.Copy(io.Discard, in) return nil, err } info := object.NewStaticObjectInfo(dstFileName, modTime, size, true, nil, fdst).WithMetadata(meta) obj, err = fdst.Put(ctx, in, info) if err != nil { fs.Errorf(dstFileName, "Post request put error: %v", err) return nil, err } } else { // Size unknown use Rcat obj, err = Rcat(ctx, fdst, dstFileName, in, modTime, meta) if err != nil { fs.Errorf(dstFileName, "Post request rcat error: %v", err) return nil, err } } return obj, nil } // copyURLFunc is called from CopyURLFn type copyURLFunc func(ctx context.Context, dstFileName string, in io.ReadCloser, size int64, modTime time.Time) (err error) // copyURLFn copies the data from the url to the function supplied func copyURLFn(ctx context.Context, dstFileName string, url string, autoFilename, dstFileNameFromHeader bool, fn copyURLFunc) (err error) { client := fshttp.NewClient(ctx) resp, err := client.Get(url) if err != nil { return err } defer fs.CheckClose(resp.Body, &err) if resp.StatusCode < 200 || resp.StatusCode >= 300 { return fmt.Errorf("CopyURL failed: %s", resp.Status) } modTime, err := http.ParseTime(resp.Header.Get("Last-Modified")) if err != nil { modTime = time.Now() } if autoFilename { if dstFileNameFromHeader { _, params, err := mime.ParseMediaType(resp.Header.Get("Content-Disposition")) headerFilename := path.Base(strings.ReplaceAll(params["filename"], "\\", "/")) if err != nil || headerFilename == "" { return fmt.Errorf("CopyURL failed: filename not found in the Content-Disposition header") } fs.Debugf(headerFilename, "filename found in Content-Disposition header.") return fn(ctx, headerFilename, resp.Body, resp.ContentLength, modTime) } dstFileName = path.Base(resp.Request.URL.Path) if dstFileName == "." || dstFileName == "/" { return fmt.Errorf("CopyURL failed: file name wasn't found in url") } fs.Debugf(dstFileName, "File name found in url") } return fn(ctx, dstFileName, resp.Body, resp.ContentLength, modTime) } // CopyURL copies the data from the url to (fdst, dstFileName) func CopyURL(ctx context.Context, fdst fs.Fs, dstFileName string, url string, autoFilename, dstFileNameFromHeader bool, noClobber bool) (dst fs.Object, err error) { err = copyURLFn(ctx, dstFileName, url, autoFilename, dstFileNameFromHeader, func(ctx context.Context, dstFileName string, in io.ReadCloser, size int64, modTime time.Time) (err error) { if noClobber { _, err = fdst.NewObject(ctx, dstFileName) if err == nil { return errors.New("CopyURL failed: file already exist") } } dst, err = RcatSize(ctx, fdst, dstFileName, in, size, modTime, nil) return err }) return dst, err } // CopyURLToWriter copies the data from the url to the io.Writer supplied func CopyURLToWriter(ctx context.Context, url string, out io.Writer) (err error) { return copyURLFn(ctx, "", url, false, false, func(ctx context.Context, dstFileName string, in io.ReadCloser, size int64, modTime time.Time) (err error) { _, err = io.Copy(out, in) return err }) } // BackupDir returns the correctly configured --backup-dir func BackupDir(ctx context.Context, fdst fs.Fs, fsrc fs.Fs, srcFileName string) (backupDir fs.Fs, err error) { ci := fs.GetConfig(ctx) if ci.BackupDir != "" { backupDir, err = cache.Get(ctx, ci.BackupDir) if err != nil { return nil, fserrors.FatalError(fmt.Errorf("failed to make fs for --backup-dir %q: %w", ci.BackupDir, err)) } if !SameConfig(fdst, backupDir) { return nil, fserrors.FatalError(errors.New("parameter to --backup-dir has to be on the same remote as destination")) } if srcFileName == "" { if OverlappingFilterCheck(ctx, backupDir, fdst) { return nil, fserrors.FatalError(errors.New("destination and parameter to --backup-dir mustn't overlap")) } if OverlappingFilterCheck(ctx, backupDir, fsrc) { return nil, fserrors.FatalError(errors.New("source and parameter to --backup-dir mustn't overlap")) } } else if ci.Suffix == "" { if SameDir(fdst, backupDir) { return nil, fserrors.FatalError(errors.New("destination and parameter to --backup-dir mustn't be the same")) } if SameDir(fsrc, backupDir) { return nil, fserrors.FatalError(errors.New("source and parameter to --backup-dir mustn't be the same")) } } } else if ci.Suffix != "" { // --backup-dir is not set but --suffix is - use the destination as the backupDir backupDir = fdst } else { return nil, fserrors.FatalError(errors.New("internal error: BackupDir called when --backup-dir and --suffix both empty")) } if !CanServerSideMove(backupDir) { return nil, fserrors.FatalError(errors.New("can't use --backup-dir on a remote which doesn't support server-side move or copy")) } return backupDir, nil } // MoveBackupDir moves a file to the backup dir func MoveBackupDir(ctx context.Context, backupDir fs.Fs, dst fs.Object) (err error) { remoteWithSuffix := SuffixName(ctx, dst.Remote()) overwritten, _ := backupDir.NewObject(ctx, remoteWithSuffix) _, err = Move(ctx, backupDir, overwritten, remoteWithSuffix, dst) return err } // needsMoveCaseInsensitive returns true if moveCaseInsensitive is needed func needsMoveCaseInsensitive(fdst fs.Fs, fsrc fs.Fs, dstFileName string, srcFileName string, cp bool) bool { dstFilePath := path.Join(fdst.Root(), dstFileName) srcFilePath := path.Join(fsrc.Root(), srcFileName) if !cp && fdst.Name() == fsrc.Name() && dstFileName != srcFileName && norm.NFC.String(dstFilePath) == norm.NFC.String(srcFilePath) { return true } return !cp && fdst.Name() == fsrc.Name() && fdst.Features().CaseInsensitive && dstFileName != srcFileName && strings.EqualFold(dstFilePath, srcFilePath) } // MoveCaseInsensitive handles changing case of a file on a case insensitive remote. // This will move the file to a temporary name then // move it back to the intended destination. This is required // to avoid issues with certain remotes and avoid file deletion. // returns nil, nil if !needsMoveCaseInsensitive. // this does not account a transfer -- the caller should do that if desired. func MoveCaseInsensitive(ctx context.Context, fdst fs.Fs, fsrc fs.Fs, dstFileName string, srcFileName string, cp bool, srcObj fs.Object) (newDst fs.Object, err error) { logger, _ := GetLogger(ctx) // Choose operations Op := MoveTransfer if cp { Op = Copy } if SkipDestructive(ctx, srcFileName, "rename to "+dstFileName) { // avoid fatalpanic on --dry-run (trying to access non-existent tmpObj) return nil, nil } // Create random name to temporarily move file to tmpObjName := dstFileName + "-rclone-move-" + random.String(8) tmpObjFail, err := fdst.NewObject(ctx, tmpObjName) if err != fs.ErrorObjectNotFound { if err == nil { logger(ctx, TransferError, nil, tmpObjFail, err) return nil, errors.New("found an already existing file with a randomly generated name. Try the operation again") } logger(ctx, TransferError, nil, tmpObjFail, err) return nil, fmt.Errorf("error while attempting to move file to a temporary location: %w", err) } fs.Debugf(srcObj, "moving to %v", tmpObjName) tmpObj, err := Op(ctx, fdst, nil, tmpObjName, srcObj) if err != nil { logger(ctx, TransferError, srcObj, tmpObj, err) return nil, fmt.Errorf("error while moving file to temporary location: %w", err) } fs.Debugf(srcObj, "moving to %v", dstFileName) newDst, err = Op(ctx, fdst, nil, dstFileName, tmpObj) logger(ctx, MissingOnDst, tmpObj, nil, err) return newDst, err } // moveOrCopyFile moves or copies a single file possibly to a new name func moveOrCopyFile(ctx context.Context, fdst fs.Fs, fsrc fs.Fs, dstFileName string, srcFileName string, cp bool, allowOverlap bool) (err error) { ci := fs.GetConfig(ctx) logger, usingLogger := GetLogger(ctx) dstFilePath := path.Join(fdst.Root(), dstFileName) srcFilePath := path.Join(fsrc.Root(), srcFileName) if fdst.Name() == fsrc.Name() && dstFilePath == srcFilePath && !allowOverlap { fs.Debugf(fdst, "don't need to copy/move %s, it is already at target location", dstFileName) if usingLogger { srcObj, _ := fsrc.NewObject(ctx, srcFileName) dstObj, _ := fsrc.NewObject(ctx, dstFileName) logger(ctx, Match, srcObj, dstObj, nil) } return nil } // Choose operations Op := MoveTransfer if cp { Op = Copy } // Find src object srcObj, err := fsrc.NewObject(ctx, srcFileName) if err != nil { logger(ctx, TransferError, srcObj, nil, err) return err } // Find dst object if it exists var dstObj fs.Object if !ci.NoCheckDest { dstObj, err = fdst.NewObject(ctx, dstFileName) if errors.Is(err, fs.ErrorObjectNotFound) { dstObj = nil } else if err != nil { logger(ctx, TransferError, nil, dstObj, err) return err } } // Special case for changing case of a file on a case insensitive remote // This will move the file to a temporary name then // move it back to the intended destination. This is required // to avoid issues with certain remotes and avoid file deletion. if needsMoveCaseInsensitive(fdst, fsrc, dstFileName, srcFileName, cp) { tr := accounting.Stats(ctx).NewTransfer(srcObj, fdst) defer func() { tr.Done(ctx, err) }() _, err = MoveCaseInsensitive(ctx, fdst, fsrc, dstFileName, srcFileName, cp, srcObj) return err } var backupDir fs.Fs var copyDestDir []fs.Fs if ci.BackupDir != "" || ci.Suffix != "" { backupDir, err = BackupDir(ctx, fdst, fsrc, srcFileName) if err != nil { return fmt.Errorf("creating Fs for --backup-dir failed: %w", err) } } if len(ci.CompareDest) > 0 { copyDestDir, err = GetCompareDest(ctx) if err != nil { return err } } else if len(ci.CopyDest) > 0 { copyDestDir, err = GetCopyDest(ctx, fdst) if err != nil { return err } } needTransfer := NeedTransfer(ctx, dstObj, srcObj) if needTransfer { NoNeedTransfer, err := CompareOrCopyDest(ctx, fdst, dstObj, srcObj, copyDestDir, backupDir) if err != nil { return err } if NoNeedTransfer { needTransfer = false } } if needTransfer { // If destination already exists, then we must move it into --backup-dir if required if dstObj != nil && backupDir != nil { err = MoveBackupDir(ctx, backupDir, dstObj) if err != nil { logger(ctx, TransferError, dstObj, nil, err) return fmt.Errorf("moving to --backup-dir failed: %w", err) } // If successful zero out the dstObj as it is no longer there logger(ctx, MissingOnDst, dstObj, nil, nil) dstObj = nil } _, err = Op(ctx, fdst, dstObj, dstFileName, srcObj) } else if !cp { if ci.IgnoreExisting { fs.Debugf(srcObj, "Not removing source file as destination file exists and --ignore-existing is set") logger(ctx, Match, srcObj, dstObj, nil) } else if !SameObject(srcObj, dstObj) { err = DeleteFile(ctx, srcObj) logger(ctx, Differ, srcObj, dstObj, nil) } } return err } // MoveFile moves a single file possibly to a new name // // This is treated as a transfer. func MoveFile(ctx context.Context, fdst fs.Fs, fsrc fs.Fs, dstFileName string, srcFileName string) (err error) { return moveOrCopyFile(ctx, fdst, fsrc, dstFileName, srcFileName, false, false) } // TransformFile transforms a file in place using --name-transform // // This is treated as a transfer. func TransformFile(ctx context.Context, fdst fs.Fs, srcFileName string) (err error) { return moveOrCopyFile(ctx, fdst, fdst, srcFileName, srcFileName, false, true) } // SetTier changes tier of object in remote func SetTier(ctx context.Context, fsrc fs.Fs, tier string) error { return ListFn(ctx, fsrc, func(o fs.Object) { objImpl, ok := o.(fs.SetTierer) if !ok { fs.Errorf(fsrc, "Remote object does not implement SetTier") return } err := objImpl.SetTier(tier) if err != nil { fs.Errorf(fsrc, "Failed to do SetTier, %v", err) } }) } // SetTierFile changes tier of a single file in remote func SetTierFile(ctx context.Context, o fs.Object, tier string) error { do, ok := o.(fs.SetTierer) if !ok { return errors.New("remote object does not implement SetTier") } err := do.SetTier(tier) if err != nil { fs.Errorf(o, "Failed to do SetTier, %v", err) return err } return nil } // TouchDir touches every file in directory with time t func TouchDir(ctx context.Context, f fs.Fs, remote string, t time.Time, recursive bool) error { ci := fs.GetConfig(ctx) g, gCtx := errgroup.WithContext(ctx) g.SetLimit(ci.Transfers) err := walk.ListR(ctx, f, remote, false, ConfigMaxDepth(ctx, recursive), walk.ListObjects, func(entries fs.DirEntries) error { entries.ForObject(func(o fs.Object) { if !SkipDestructive(ctx, o, "touch") { g.Go(func() error { fs.Debugf(f, "Touching %q", o.Remote()) err := o.SetModTime(gCtx, t) if err != nil { err = fmt.Errorf("failed to touch: %w", err) err = fs.CountError(gCtx, err) fs.Errorf(o, "%v", err) } return nil }) } }) return nil }) _ = g.Wait() return err } // ListFormat defines files information print format type ListFormat struct { separator string dirSlash bool absolute bool output []func(entry *ListJSONItem) string csv *csv.Writer buf bytes.Buffer } // SetSeparator changes separator in struct func (l *ListFormat) SetSeparator(separator string) { l.separator = separator } // SetDirSlash defines if slash should be printed func (l *ListFormat) SetDirSlash(dirSlash bool) { l.dirSlash = dirSlash } // SetAbsolute prints a leading slash in front of path names func (l *ListFormat) SetAbsolute(absolute bool) { l.absolute = absolute } // SetCSV defines if the output should be csv // // Note that you should call SetSeparator before this if you want a // custom separator func (l *ListFormat) SetCSV(useCSV bool) { if useCSV { l.csv = csv.NewWriter(&l.buf) if l.separator != "" { l.csv.Comma = []rune(l.separator)[0] } } else { l.csv = nil } } // SetOutput sets functions used to create files information func (l *ListFormat) SetOutput(output []func(entry *ListJSONItem) string) { l.output = output } // AddModTime adds file's Mod Time to output func (l *ListFormat) AddModTime(timeFormat string) { if timeFormat == "" { timeFormat = "2006-01-02 15:04:05" } else { timeFormat = transform.TimeFormat(timeFormat) } l.AppendOutput(func(entry *ListJSONItem) string { return entry.ModTime.When.Local().Format(timeFormat) }) } // AddSize adds file's size to output func (l *ListFormat) AddSize() { l.AppendOutput(func(entry *ListJSONItem) string { return strconv.FormatInt(entry.Size, 10) }) } // normalisePath makes sure the path has the correct slashes for the current mode func (l *ListFormat) normalisePath(entry *ListJSONItem, remote string) string { if l.absolute && !strings.HasPrefix(remote, "/") { remote = "/" + remote } if entry.IsDir && l.dirSlash { remote += "/" } return remote } // AddPath adds path to file to output func (l *ListFormat) AddPath() { l.AppendOutput(func(entry *ListJSONItem) string { return l.normalisePath(entry, entry.Path) }) } // AddEncrypted adds the encrypted path to file to output func (l *ListFormat) AddEncrypted() { l.AppendOutput(func(entry *ListJSONItem) string { return l.normalisePath(entry, entry.Encrypted) }) } // AddHash adds the hash of the type given to the output func (l *ListFormat) AddHash(ht hash.Type) { hashName := ht.String() l.AppendOutput(func(entry *ListJSONItem) string { if entry.IsDir { return "" } return entry.Hashes[hashName] }) } // AddID adds file's ID to the output if known func (l *ListFormat) AddID() { l.AppendOutput(func(entry *ListJSONItem) string { return entry.ID }) } // AddOrigID adds file's Original ID to the output if known func (l *ListFormat) AddOrigID() { l.AppendOutput(func(entry *ListJSONItem) string { return entry.OrigID }) } // AddTier adds file's Tier to the output if known func (l *ListFormat) AddTier() { l.AppendOutput(func(entry *ListJSONItem) string { return entry.Tier }) } // AddMimeType adds file's MimeType to the output if known func (l *ListFormat) AddMimeType() { l.AppendOutput(func(entry *ListJSONItem) string { return entry.MimeType }) } // AddMetadata adds file's Metadata to the output if known func (l *ListFormat) AddMetadata() { l.AppendOutput(func(entry *ListJSONItem) string { metadata := entry.Metadata if metadata == nil { metadata = make(fs.Metadata) } out, err := json.Marshal(metadata) if err != nil { return fmt.Sprintf("Failed to read metadata: %v", err.Error()) } return string(out) }) } // AppendOutput adds string generated by specific function to printed output func (l *ListFormat) AppendOutput(functionToAppend func(item *ListJSONItem) string) { l.output = append(l.output, functionToAppend) } // Format prints information about the DirEntry in the format defined func (l *ListFormat) Format(entry *ListJSONItem) (result string) { var out []string for _, fun := range l.output { out = append(out, fun(entry)) } if l.csv != nil { l.buf.Reset() _ = l.csv.Write(out) // can't fail writing to bytes.Buffer l.csv.Flush() result = strings.TrimRight(l.buf.String(), "\n") } else { result = strings.Join(out, l.separator) } return result } // FormatForLSFPrecision Returns a time format for the given precision func FormatForLSFPrecision(precision time.Duration) string { switch { case precision <= time.Nanosecond: return "2006-01-02 15:04:05.000000000" case precision <= 10*time.Nanosecond: return "2006-01-02 15:04:05.00000000" case precision <= 100*time.Nanosecond: return "2006-01-02 15:04:05.0000000" case precision <= time.Microsecond: return "2006-01-02 15:04:05.000000" case precision <= 10*time.Microsecond: return "2006-01-02 15:04:05.00000" case precision <= 100*time.Microsecond: return "2006-01-02 15:04:05.0000" case precision <= time.Millisecond: return "2006-01-02 15:04:05.000" case precision <= 10*time.Millisecond: return "2006-01-02 15:04:05.00" case precision <= 100*time.Millisecond: return "2006-01-02 15:04:05.0" } return "2006-01-02 15:04:05" } // DirMove renames srcRemote to dstRemote // // It does this by loading the directory tree into memory (using ListR // if available) and doing renames in parallel. func DirMove(ctx context.Context, f fs.Fs, srcRemote, dstRemote string) (err error) { ci := fs.GetConfig(ctx) if SkipDestructive(ctx, srcRemote, "dirMove") { accounting.Stats(ctx).Renames(1) return nil } // Use DirMove if possible if doDirMove := f.Features().DirMove; doDirMove != nil { err = doDirMove(ctx, f, srcRemote, dstRemote) if err == nil { accounting.Stats(ctx).Renames(1) } if err != fs.ErrorCantDirMove && err != fs.ErrorDirExists { return err } fs.Infof(f, "Can't DirMove - falling back to file moves: %v", err) } // Load the directory tree into memory tree, err := walk.NewDirTree(ctx, f, srcRemote, true, -1) if err != nil { return fmt.Errorf("RenameDir tree walk: %w", err) } // Get the directories in sorted order dirs := tree.Dirs() // Make the destination directories - must be done in order not in parallel for _, dir := range dirs { dstPath := dstRemote + dir[len(srcRemote):] err := f.Mkdir(ctx, dstPath) if err != nil { return fmt.Errorf("RenameDir mkdir: %w", err) } } // Rename the files in parallel type rename struct { o fs.Object newPath string } renames := make(chan rename, ci.Checkers) g, gCtx := errgroup.WithContext(context.Background()) for range ci.Checkers { g.Go(func() error { for job := range renames { dstOverwritten, _ := f.NewObject(gCtx, job.newPath) _, err := Move(gCtx, f, dstOverwritten, job.newPath, job.o) if err != nil { return err } select { case <-gCtx.Done(): return gCtx.Err() default: } } return nil }) } for dir, entries := range tree { dstPath := dstRemote + dir[len(srcRemote):] for _, entry := range entries { if o, ok := entry.(fs.Object); ok { renames <- rename{o, path.Join(dstPath, path.Base(o.Remote()))} } } } close(renames) err = g.Wait() if err != nil { return fmt.Errorf("RenameDir renames: %w", err) } // Remove the source directories in reverse order for i := len(dirs) - 1; i >= 0; i-- { err := f.Rmdir(ctx, dirs[i]) if err != nil { return fmt.Errorf("RenameDir rmdir: %w", err) } } return nil } // DirMoveCaseInsensitive does DirMove in two steps (to temp name, then real name) // which is necessary for some case-insensitive backends func DirMoveCaseInsensitive(ctx context.Context, f fs.Fs, srcRemote, dstRemote string) (err error) { tmpDstRemote := dstRemote + "-rclone-move-" + random.String(8) err = DirMove(ctx, f, srcRemote, tmpDstRemote) if err != nil { return err } return DirMove(ctx, f, tmpDstRemote, dstRemote) } // FsInfo provides information about a remote type FsInfo struct { // Name of the remote (as passed into NewFs) Name string // Root of the remote (as passed into NewFs) Root string // String returns a description of the FS String string // Precision of the ModTimes in this Fs in Nanoseconds Precision time.Duration // Returns the supported hash types of the filesystem Hashes []string // Features returns the optional features of this Fs Features map[string]bool // MetadataInfo returns info about the metadata for this backend MetadataInfo *fs.MetadataInfo } // GetFsInfo gets the information (FsInfo) about a given Fs func GetFsInfo(f fs.Fs) *FsInfo { features := f.Features() info := &FsInfo{ Name: f.Name(), Root: f.Root(), String: f.String(), Precision: f.Precision(), Hashes: make([]string, 0, 4), Features: features.Enabled(), MetadataInfo: nil, } for _, hashType := range f.Hashes().Array() { info.Hashes = append(info.Hashes, hashType.String()) } fsInfo, _, _, _, err := fs.ParseRemote(fs.ConfigString(f)) if err == nil && fsInfo != nil && fsInfo.MetadataInfo != nil { info.MetadataInfo = fsInfo.MetadataInfo } return info } var ( interactiveMu sync.Mutex // protects the following variables skipped = map[string]bool{} ) // skipDestructiveChoose asks the user which action to take // // Call with interactiveMu held func skipDestructiveChoose(ctx context.Context, subject any, action string) (skip bool) { // Lock the StdoutMutex - must not call fs.Log anything // otherwise it will deadlock with --interactive --progress StdoutMutex.Lock() fmt.Printf("\nrclone: %s \"%v\"?\n", action, subject) i := config.CommandDefault([]string{ "yYes, this is OK", "nNo, skip this", fmt.Sprintf("sSkip all %s operations with no more questions", action), fmt.Sprintf("!Do all %s operations with no more questions", action), "qExit rclone now.", }, 0) StdoutMutex.Unlock() switch i { case 'y': skip = false case 'n': skip = true case 's': skip = true skipped[action] = true fs.Logf(nil, "Skipping all %s operations from now on without asking", action) case '!': skip = false skipped[action] = false fs.Logf(nil, "Doing all %s operations from now on without asking", action) case 'q': fs.Logf(nil, "Quitting rclone now") atexit.Run() os.Exit(0) default: skip = true fs.Errorf(nil, "Bad choice %c", i) } return skip } // SkipDestructive should be called whenever rclone is about to do an destructive operation. // // It will check the --dry-run flag and it will ask the user if the --interactive flag is set. // // subject should be the object or directory in use // // action should be a descriptive word or short phrase // // Together they should make sense in this sentence: "Rclone is about // to action subject". func SkipDestructive(ctx context.Context, subject any, action string) (skip bool) { var flag string ci := fs.GetConfig(ctx) switch { case ci.DryRun: flag = "--dry-run" skip = true case ci.Interactive: flag = "--interactive" interactiveMu.Lock() defer interactiveMu.Unlock() var found bool skip, found = skipped[action] if !found { skip = skipDestructiveChoose(ctx, subject, action) } default: return false } if skip { size := int64(-1) if do, ok := subject.(interface{ Size() int64 }); ok { size = do.Size() } if size >= 0 { fs.Logf(subject, "Skipped %s as %s is set (size %v)", fs.LogValue("skipped", action), flag, fs.LogValue("size", fs.SizeSuffix(size))) } else { fs.Logf(subject, "Skipped %s as %s is set", fs.LogValue("skipped", action), flag) } } return skip } // Return the best way of describing the directory for the logs func dirName(f fs.Fs, dst fs.Directory, dir string) any { if dst != nil { if dst.Remote() != "" { return dst } // Root is described as the Fs return f } if dir != "" { return dir } // Root is described as the Fs return f } // CopyDirMetadata copies the src directory to dst or f if nil. If dst is nil then it uses // dir as the name of the new directory. // // It returns the destination directory if possible. Note that this may // be nil. func CopyDirMetadata(ctx context.Context, f fs.Fs, dst fs.Directory, dir string, src fs.Directory) (newDst fs.Directory, err error) { ci := fs.GetConfig(ctx) logName := dirName(f, dst, dir) if SkipDestructive(ctx, logName, "update directory metadata") { return nil, nil } // Options for the directory metadata options := []fs.OpenOption{} if ci.MetadataSet != nil { options = append(options, fs.MetadataOption(ci.MetadataSet)) } // Read metadata from src and add options and use metadata mapper metadata, err := fs.GetMetadataOptions(ctx, f, src, options) if err != nil { return nil, err } // Fall back to ModTime if metadata not available if metadata == nil { metadata = fs.Metadata{} } if metadata["mtime"] == "" { metadata["mtime"] = src.ModTime(ctx).Format(time.RFC3339Nano) } // Now set the metadata if dst == nil { do := f.Features().MkdirMetadata if do == nil { return nil, fmt.Errorf("internal error: expecting %v to have MkdirMetadata method: %w", f, fs.ErrorNotImplemented) } newDst, err = do(ctx, dir, metadata) } else { do, ok := dst.(fs.SetMetadataer) if !ok { return nil, fmt.Errorf("internal error: expecting directory %s (%T) from %v to have SetMetadata method: %w", logName, dst, f, fs.ErrorNotImplemented) } err = do.SetMetadata(ctx, metadata) newDst = dst } if err != nil { return nil, err } fs.Infof(logName, "Updated directory metadata") return newDst, nil } // SetDirModTime sets the modtime on dst or dir // // If dst is nil then it uses dir as the name of the directory. // // It returns the destination directory if possible. Note that this // may be nil. // // It does not create the directory. func SetDirModTime(ctx context.Context, f fs.Fs, dst fs.Directory, dir string, modTime time.Time) (newDst fs.Directory, err error) { logName := dirName(f, dst, dir) ci := fs.GetConfig(ctx) if ci.NoUpdateDirModTime { fs.Debugf(logName, "Skipping set directory modification time as --no-update-dir-modtime is set") return nil, nil } if SkipDestructive(ctx, logName, "set directory modification time") { return nil, nil } if dst != nil { dir = dst.Remote() } // Try to set the ModTime with the Directory.SetModTime method first as this is the most efficient if dst != nil { if do, ok := dst.(fs.SetModTimer); ok { err := do.SetModTime(ctx, modTime) if errors.Is(err, fs.ErrorNotImplemented) { // Fall through and run the code below if not implemented // This can happen for fs.DirWrapper instances } else if err != nil { return dst, err } else { fs.Infof(logName, "Set directory modification time (using SetModTime)") return dst, nil } } } // Next try to set the ModTime with the Fs.DirSetModTime method as this works for non-metadata backends if do := f.Features().DirSetModTime; do != nil { err := do(ctx, dir, modTime) if err != nil { return dst, err } fs.Infof(logName, "Set directory modification time (using DirSetModTime)") return dst, nil } // Something should have worked so return an error return nil, fmt.Errorf("no method to set directory modtime found for %v (%T): %w", f, dst, fs.ErrorNotImplemented) } rclone-v1.71.0/fs/operations/operations_internal_test.go000066400000000000000000000020401505210326400235020ustar00rootroot00000000000000// Internal tests for operations package operations import ( "context" "fmt" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/object" "github.com/stretchr/testify/assert" ) func TestSizeDiffers(t *testing.T) { ctx := context.Background() ci := fs.GetConfig(ctx) when := time.Now() for _, test := range []struct { ignoreSize bool srcSize int64 dstSize int64 want bool }{ {false, 0, 0, false}, {false, 1, 2, true}, {false, 1, -1, false}, {false, -1, 1, false}, {true, 0, 0, false}, {true, 1, 2, false}, {true, 1, -1, false}, {true, -1, 1, false}, } { src := object.NewStaticObjectInfo("a", when, test.srcSize, true, nil, nil) dst := object.NewStaticObjectInfo("a", when, test.dstSize, true, nil, nil) oldIgnoreSize := ci.IgnoreSize ci.IgnoreSize = test.ignoreSize got := sizeDiffers(ctx, src, dst) ci.IgnoreSize = oldIgnoreSize assert.Equal(t, test.want, got, fmt.Sprintf("ignoreSize=%v, srcSize=%v, dstSize=%v", test.ignoreSize, test.srcSize, test.dstSize)) } } rclone-v1.71.0/fs/operations/operations_test.go000066400000000000000000001617721505210326400216300ustar00rootroot00000000000000// Integration tests - test rclone by doing real transactions to a // storage provider to and from the local disk. // // By default it will use a local fs, however you can provide a // -remote option to use a different remote. The test_all.go script // is a wrapper to call this for all the test remotes. // // FIXME not safe for concurrent running of tests until fs.Config is // no longer a global // // NB When writing tests // // Make sure every series of writes to the remote has a // fstest.CheckItems() before use. This make sure the directory // listing is now consistent and stops cascading errors. // // Call accounting.GlobalStats().ResetCounters() before every fs.Sync() as it // uses the error count internally. package operations_test import ( "bytes" "context" "errors" "fmt" "io" "net/http" "net/http/httptest" "os" "regexp" "strings" "testing" "time" _ "github.com/rclone/rclone/backend/all" // import all backends "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/fstests" "github.com/rclone/rclone/lib/pacer" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "golang.org/x/text/cases" "golang.org/x/text/language" ) // Some times used in the tests var ( t1 = fstest.Time("2001-02-03T04:05:06.499999999Z") t2 = fstest.Time("2011-12-25T12:59:59.123456789Z") t3 = fstest.Time("2011-12-30T12:59:59.000000000Z") ) // TestMain drives the tests func TestMain(m *testing.M) { fstest.TestMain(m) } func TestMkdir(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) err := operations.Mkdir(ctx, r.Fremote, "") require.NoError(t, err) fstest.CheckListing(t, r.Fremote, []fstest.Item{}) err = operations.Mkdir(ctx, r.Fremote, "") require.NoError(t, err) } func TestLsd(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteObject(ctx, "sub dir/hello world", "hello world", t1) r.CheckRemoteItems(t, file1) var buf bytes.Buffer err := operations.ListDir(ctx, r.Fremote, &buf) require.NoError(t, err) res := buf.String() assert.Contains(t, res, "sub dir\n") } func TestLs(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteBoth(ctx, "potato2", "------------------------------------------------------------", t1) file2 := r.WriteBoth(ctx, "empty space", "-", t2) r.CheckRemoteItems(t, file1, file2) var buf bytes.Buffer err := operations.List(ctx, r.Fremote, &buf) require.NoError(t, err) res := buf.String() assert.Contains(t, res, " 1 empty space\n") assert.Contains(t, res, " 60 potato2\n") } func TestLsWithFilesFrom(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) file1 := r.WriteBoth(ctx, "potato2", "------------------------------------------------------------", t1) file2 := r.WriteBoth(ctx, "empty space", "-", t2) r.CheckRemoteItems(t, file1, file2) // Set the --files-from equivalent f, err := filter.NewFilter(nil) require.NoError(t, err) require.NoError(t, f.AddFile("potato2")) require.NoError(t, f.AddFile("notfound")) // Change the active filter ctx = filter.ReplaceConfig(ctx, f) var buf bytes.Buffer err = operations.List(ctx, r.Fremote, &buf) require.NoError(t, err) assert.Equal(t, " 60 potato2\n", buf.String()) // Now try with --no-traverse ci.NoTraverse = true buf.Reset() err = operations.List(ctx, r.Fremote, &buf) require.NoError(t, err) assert.Equal(t, " 60 potato2\n", buf.String()) } func TestLsLong(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteBoth(ctx, "potato2", "------------------------------------------------------------", t1) file2 := r.WriteBoth(ctx, "empty space", "-", t2) r.CheckRemoteItems(t, file1, file2) var buf bytes.Buffer err := operations.ListLong(ctx, r.Fremote, &buf) require.NoError(t, err) res := buf.String() lines := strings.Split(strings.Trim(res, "\n"), "\n") assert.Equal(t, 2, len(lines)) timeFormat := "2006-01-02 15:04:05.000000000" precision := r.Fremote.Precision() location := time.Now().Location() checkTime := func(m, filename string, expected time.Time) { modTime, err := time.ParseInLocation(timeFormat, m, location) // parse as localtime if err != nil { t.Errorf("Error parsing %q: %v", m, err) } else { fstest.AssertTimeEqualWithPrecision(t, filename, expected, modTime, precision) } } m1 := regexp.MustCompile(`(?m)^ 1 (\d{4}-\d\d-\d\d \d\d:\d\d:\d\d\.\d{9}) empty space$`) if ms := m1.FindStringSubmatch(res); ms == nil { t.Errorf("empty space missing: %q", res) } else { checkTime(ms[1], "empty space", t2.Local()) } m2 := regexp.MustCompile(`(?m)^ 60 (\d{4}-\d\d-\d\d \d\d:\d\d:\d\d\.\d{9}) potato2$`) if ms := m2.FindStringSubmatch(res); ms == nil { t.Errorf("potato2 missing: %q", res) } else { checkTime(ms[1], "potato2", t1.Local()) } } func TestHashSums(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteBoth(ctx, "potato2", "------------------------------------------------------------", t1) file2 := r.WriteBoth(ctx, "empty space", "-", t2) r.CheckRemoteItems(t, file1, file2) hashes := r.Fremote.Hashes() var quickXorHash hash.Type err := quickXorHash.Set("QuickXorHash") require.NoError(t, err) for _, test := range []struct { name string download bool base64 bool ht hash.Type want []string }{ { ht: hash.MD5, want: []string{ "336d5ebc5436534e61d16e63ddfca327 empty space\n", "d6548b156ea68a4e003e786df99eee76 potato2\n", }, }, { ht: hash.MD5, download: true, want: []string{ "336d5ebc5436534e61d16e63ddfca327 empty space\n", "d6548b156ea68a4e003e786df99eee76 potato2\n", }, }, { ht: hash.SHA1, want: []string{ "3bc15c8aae3e4124dd409035f32ea2fd6835efc9 empty space\n", "9dc7f7d3279715991a22853f5981df582b7f9f6d potato2\n", }, }, { ht: hash.SHA1, download: true, want: []string{ "3bc15c8aae3e4124dd409035f32ea2fd6835efc9 empty space\n", "9dc7f7d3279715991a22853f5981df582b7f9f6d potato2\n", }, }, { ht: quickXorHash, want: []string{ "2d00000000000000000000000100000000000000 empty space\n", "4001dad296b6b4a52d6d694b67dad296b6b4a52d potato2\n", }, }, { ht: quickXorHash, download: true, want: []string{ "2d00000000000000000000000100000000000000 empty space\n", "4001dad296b6b4a52d6d694b67dad296b6b4a52d potato2\n", }, }, { ht: quickXorHash, base64: true, want: []string{ "LQAAAAAAAAAAAAAAAQAAAAAAAAA= empty space\n", "QAHa0pa2tKUtbWlLZ9rSlra0pS0= potato2\n", }, }, { ht: quickXorHash, base64: true, download: true, want: []string{ "LQAAAAAAAAAAAAAAAQAAAAAAAAA= empty space\n", "QAHa0pa2tKUtbWlLZ9rSlra0pS0= potato2\n", }, }, } { if !hashes.Contains(test.ht) { continue } name := cases.Title(language.Und, cases.NoLower).String(test.ht.String()) if test.download { name += "Download" } if test.base64 { name += "Base64" } t.Run(name, func(t *testing.T) { var buf bytes.Buffer err := operations.HashLister(ctx, test.ht, test.base64, test.download, r.Fremote, &buf) require.NoError(t, err) res := buf.String() for _, line := range test.want { assert.Contains(t, res, line) } }) } } func TestHashSumsWithErrors(t *testing.T) { ctx := context.Background() memFs, err := fs.NewFs(ctx, ":memory:") require.NoError(t, err) // Make a test file content := "-" item1 := fstest.NewItem("file1", content, t1) _ = fstests.PutTestContents(ctx, t, memFs, &item1, content, true) // MemoryFS supports MD5 buf := &bytes.Buffer{} err = operations.HashLister(ctx, hash.MD5, false, false, memFs, buf) require.NoError(t, err) assert.Contains(t, buf.String(), "336d5ebc5436534e61d16e63ddfca327 file1\n") // MemoryFS can't do SHA1, but UNSUPPORTED must not appear in the output buf.Reset() err = operations.HashLister(ctx, hash.SHA1, false, false, memFs, buf) require.NoError(t, err) assert.NotContains(t, buf.String(), " UNSUPPORTED ") // ERROR must not appear in the output either assert.NotContains(t, buf.String(), " ERROR ") // TODO mock an unreadable file } func TestHashStream(t *testing.T) { reader := strings.NewReader("") in := io.NopCloser(reader) out := &bytes.Buffer{} for _, test := range []struct { input string ht hash.Type wantHex string wantBase64 string }{ { input: "", ht: hash.MD5, wantHex: "d41d8cd98f00b204e9800998ecf8427e -\n", wantBase64: "1B2M2Y8AsgTpgAmY7PhCfg== -\n", }, { input: "", ht: hash.SHA1, wantHex: "da39a3ee5e6b4b0d3255bfef95601890afd80709 -\n", wantBase64: "2jmj7l5rSw0yVb_vlWAYkK_YBwk= -\n", }, { input: "Hello world!", ht: hash.MD5, wantHex: "86fb269d190d2c85f6e0468ceca42a20 -\n", wantBase64: "hvsmnRkNLIX24EaM7KQqIA== -\n", }, { input: "Hello world!", ht: hash.SHA1, wantHex: "d3486ae9136e7856bc42212385ea797094475802 -\n", wantBase64: "00hq6RNueFa8QiEjhep5cJRHWAI= -\n", }, } { reader.Reset(test.input) require.NoError(t, operations.HashSumStream(test.ht, false, in, out)) assert.Equal(t, test.wantHex, out.String()) _, _ = reader.Seek(0, io.SeekStart) out.Reset() require.NoError(t, operations.HashSumStream(test.ht, true, in, out)) assert.Equal(t, test.wantBase64, out.String()) out.Reset() } } func TestSuffixName(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) for _, test := range []struct { remote string suffix string keepExt bool want string }{ {"test.txt", "", false, "test.txt"}, {"test.txt", "", true, "test.txt"}, {"test.txt", "-suffix", false, "test.txt-suffix"}, {"test.txt", "-suffix", true, "test-suffix.txt"}, {"test.txt.csv", "-suffix", false, "test.txt.csv-suffix"}, {"test.txt.csv", "-suffix", true, "test-suffix.txt.csv"}, {"test", "-suffix", false, "test-suffix"}, {"test", "-suffix", true, "test-suffix"}, {"test.html", "-suffix", true, "test-suffix.html"}, {"test.html.txt", "-suffix", true, "test-suffix.html.txt"}, {"test.csv.html.txt", "-suffix", true, "test-suffix.csv.html.txt"}, {"test.badext.csv.html.txt", "-suffix", true, "test.badext-suffix.csv.html.txt"}, {"test.badext", "-suffix", true, "test-suffix.badext"}, } { ci.Suffix = test.suffix ci.SuffixKeepExtension = test.keepExt got := operations.SuffixName(ctx, test.remote) assert.Equal(t, test.want, got, fmt.Sprintf("%+v", test)) } } func TestCount(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) file1 := r.WriteBoth(ctx, "potato2", "------------------------------------------------------------", t1) file2 := r.WriteBoth(ctx, "empty space", "-", t2) file3 := r.WriteBoth(ctx, "sub dir/potato3", "hello", t2) r.CheckRemoteItems(t, file1, file2, file3) // Check the MaxDepth too ci.MaxDepth = 1 objects, size, sizeless, err := operations.Count(ctx, r.Fremote) require.NoError(t, err) assert.Equal(t, int64(2), objects) assert.Equal(t, int64(61), size) assert.Equal(t, int64(0), sizeless) } func TestDelete(t *testing.T) { ctx := context.Background() fi, err := filter.NewFilter(nil) require.NoError(t, err) fi.Opt.MaxSize = 60 ctx = filter.ReplaceConfig(ctx, fi) r := fstest.NewRun(t) file1 := r.WriteObject(ctx, "small", "1234567890", t2) // 10 bytes file2 := r.WriteObject(ctx, "medium", "------------------------------------------------------------", t1) // 60 bytes file3 := r.WriteObject(ctx, "large", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", t1) // 100 bytes r.CheckRemoteItems(t, file1, file2, file3) err = operations.Delete(ctx, r.Fremote) require.NoError(t, err) r.CheckRemoteItems(t, file3) } func isChunker(f fs.Fs) bool { return strings.HasPrefix(f.Name(), "TestChunker") } func skipIfChunker(t *testing.T, f fs.Fs) { if isChunker(f) { t.Skip("Skipping test on chunker backend") } } func TestMaxDelete(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) accounting.GlobalStats().ResetCounters() ci.MaxDelete = 2 defer r.Finalise() skipIfChunker(t, r.Fremote) // chunker does copy/delete on s3 file1 := r.WriteObject(ctx, "small", "1234567890", t2) // 10 bytes file2 := r.WriteObject(ctx, "medium", "------------------------------------------------------------", t1) // 60 bytes file3 := r.WriteObject(ctx, "large", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", t1) // 100 bytes r.CheckRemoteItems(t, file1, file2, file3) err := operations.Delete(ctx, r.Fremote) require.Error(t, err) objects, _, _, err := operations.Count(ctx, r.Fremote) require.NoError(t, err) assert.Equal(t, int64(1), objects) } // TestMaxDeleteSizeLargeFile one of the files is larger than allowed func TestMaxDeleteSizeLargeFile(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) accounting.GlobalStats().ResetCounters() ci.MaxDeleteSize = 70 defer r.Finalise() skipIfChunker(t, r.Fremote) // chunker does copy/delete on s3 file1 := r.WriteObject(ctx, "small", "1234567890", t2) // 10 bytes file2 := r.WriteObject(ctx, "medium", "------------------------------------------------------------", t1) // 60 bytes file3 := r.WriteObject(ctx, "large", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", t1) // 100 bytes r.CheckRemoteItems(t, file1, file2, file3) err := operations.Delete(ctx, r.Fremote) require.Error(t, err) r.CheckRemoteItems(t, file3) } func TestMaxDeleteSize(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) accounting.GlobalStats().ResetCounters() ci.MaxDeleteSize = 160 defer r.Finalise() skipIfChunker(t, r.Fremote) // chunker does copy/delete on s3 file1 := r.WriteObject(ctx, "small", "1234567890", t2) // 10 bytes file2 := r.WriteObject(ctx, "medium", "------------------------------------------------------------", t1) // 60 bytes file3 := r.WriteObject(ctx, "large", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", t1) // 100 bytes r.CheckRemoteItems(t, file1, file2, file3) err := operations.Delete(ctx, r.Fremote) require.Error(t, err) objects, _, _, err := operations.Count(ctx, r.Fremote) require.NoError(t, err) assert.Equal(t, int64(1), objects) // 10 or 100 bytes } func TestReadFile(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) defer r.Finalise() contents := "A file to read the contents." file := r.WriteObject(ctx, "ReadFile", contents, t1) r.CheckRemoteItems(t, file) o, err := r.Fremote.NewObject(ctx, file.Path) require.NoError(t, err) buf, err := operations.ReadFile(ctx, o) require.NoError(t, err) assert.Equal(t, contents, string(buf)) } func TestRetry(t *testing.T) { ctx := context.Background() var i int var err error fn := func() error { i-- if i <= 0 { return nil } return err } i, err = 3, fmt.Errorf("Wrapped EOF is retriable: %w", io.EOF) assert.Equal(t, nil, operations.Retry(ctx, nil, 5, fn)) assert.Equal(t, 0, i) i, err = 10, pacer.RetryAfterError(errors.New("BANG"), 10*time.Millisecond) assert.Equal(t, err, operations.Retry(ctx, nil, 5, fn)) assert.Equal(t, 5, i) i, err = 10, fs.ErrorObjectNotFound assert.Equal(t, fs.ErrorObjectNotFound, operations.Retry(ctx, nil, 5, fn)) assert.Equal(t, 9, i) } func TestCat(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteBoth(ctx, "file1", "ABCDEFGHIJ", t1) file2 := r.WriteBoth(ctx, "file2", "012345678", t2) r.CheckRemoteItems(t, file1, file2) for _, test := range []struct { offset int64 count int64 separator string a string b string }{ {0, -1, "", "ABCDEFGHIJ", "012345678"}, {0, 5, "", "ABCDE", "01234"}, {-3, -1, "", "HIJ", "678"}, {1, 3, "", "BCD", "123"}, {0, -1, "\n", "ABCDEFGHIJ", "012345678"}, } { var buf bytes.Buffer err := operations.Cat(ctx, r.Fremote, &buf, test.offset, test.count, []byte(test.separator)) require.NoError(t, err) res := buf.String() if res != test.a+test.separator+test.b+test.separator && res != test.b+test.separator+test.a+test.separator { t.Errorf("Incorrect output from Cat(%d,%d,%s): %q", test.offset, test.count, test.separator, res) } } } func TestPurge(t *testing.T) { ctx := context.Background() r := fstest.NewRunIndividual(t) // make new container (azureblob has delayed mkdir after rmdir) r.Mkdir(ctx, r.Fremote) // Make some files and dirs r.ForceMkdir(ctx, r.Fremote) file1 := r.WriteObject(ctx, "A1/B1/C1/one", "aaa", t1) //..and dirs we expect to delete require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A2")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1/B2")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1/B2/C2")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1/B1/C3")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A3")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A3/B3")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A3/B3/C4")) //..and one more file at the end file2 := r.WriteObject(ctx, "A1/two", "bbb", t2) fstest.CheckListingWithPrecision( t, r.Fremote, []fstest.Item{ file1, file2, }, []string{ "A1", "A1/B1", "A1/B1/C1", "A2", "A1/B2", "A1/B2/C2", "A1/B1/C3", "A3", "A3/B3", "A3/B3/C4", }, fs.GetModifyWindow(ctx, r.Fremote), ) require.NoError(t, operations.Purge(ctx, r.Fremote, "A1/B1")) fstest.CheckListingWithPrecision( t, r.Fremote, []fstest.Item{ file2, }, []string{ "A1", "A2", "A1/B2", "A1/B2/C2", "A3", "A3/B3", "A3/B3/C4", }, fs.GetModifyWindow(ctx, r.Fremote), ) require.NoError(t, operations.Purge(ctx, r.Fremote, "")) fstest.CheckListingWithPrecision( t, r.Fremote, []fstest.Item{}, []string{}, fs.GetModifyWindow(ctx, r.Fremote), ) } func TestRmdirsNoLeaveRoot(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) r.Mkdir(ctx, r.Fremote) // Make some files and dirs we expect to keep r.ForceMkdir(ctx, r.Fremote) file1 := r.WriteObject(ctx, "A1/B1/C1/one", "aaa", t1) //..and dirs we expect to delete require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A2")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1/B2")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1/B2/C2")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1/B1/C3")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A3")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A3/B3")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A3/B3/C4")) //..and one more file at the end file2 := r.WriteObject(ctx, "A1/two", "bbb", t2) fstest.CheckListingWithPrecision( t, r.Fremote, []fstest.Item{ file1, file2, }, []string{ "A1", "A1/B1", "A1/B1/C1", "A2", "A1/B2", "A1/B2/C2", "A1/B1/C3", "A3", "A3/B3", "A3/B3/C4", }, fs.GetModifyWindow(ctx, r.Fremote), ) require.NoError(t, operations.Rmdirs(ctx, r.Fremote, "A3/B3/C4", false)) fstest.CheckListingWithPrecision( t, r.Fremote, []fstest.Item{ file1, file2, }, []string{ "A1", "A1/B1", "A1/B1/C1", "A2", "A1/B2", "A1/B2/C2", "A1/B1/C3", "A3", "A3/B3", }, fs.GetModifyWindow(ctx, r.Fremote), ) require.NoError(t, operations.Rmdirs(ctx, r.Fremote, "", false)) fstest.CheckListingWithPrecision( t, r.Fremote, []fstest.Item{ file1, file2, }, []string{ "A1", "A1/B1", "A1/B1/C1", }, fs.GetModifyWindow(ctx, r.Fremote), ) // Delete the files so we can remove everything including the root for _, file := range []fstest.Item{file1, file2} { o, err := r.Fremote.NewObject(ctx, file.Path) require.NoError(t, err) require.NoError(t, o.Remove(ctx)) } require.NoError(t, operations.Rmdirs(ctx, r.Fremote, "", false)) fstest.CheckListingWithPrecision( t, r.Fremote, []fstest.Item{}, []string{}, fs.GetModifyWindow(ctx, r.Fremote), ) } func TestRmdirsLeaveRoot(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) r.Mkdir(ctx, r.Fremote) r.ForceMkdir(ctx, r.Fremote) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1/B1")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1/B1/C1")) fstest.CheckListingWithPrecision( t, r.Fremote, []fstest.Item{}, []string{ "A1", "A1/B1", "A1/B1/C1", }, fs.GetModifyWindow(ctx, r.Fremote), ) require.NoError(t, operations.Rmdirs(ctx, r.Fremote, "A1", true)) fstest.CheckListingWithPrecision( t, r.Fremote, []fstest.Item{}, []string{ "A1", }, fs.GetModifyWindow(ctx, r.Fremote), ) } func TestRmdirsWithFilter(t *testing.T) { ctx := context.Background() ctx, fi := filter.AddConfig(ctx) require.NoError(t, fi.AddRule("+ /A1/B1/**")) require.NoError(t, fi.AddRule("- *")) r := fstest.NewRun(t) r.Mkdir(ctx, r.Fremote) r.ForceMkdir(ctx, r.Fremote) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1/B1")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1/B1/C1")) fstest.CheckListingWithPrecision( t, r.Fremote, []fstest.Item{}, []string{ "A1", "A1/B1", "A1/B1/C1", }, fs.GetModifyWindow(ctx, r.Fremote), ) require.NoError(t, operations.Rmdirs(ctx, r.Fremote, "", false)) fstest.CheckListingWithPrecision( t, r.Fremote, []fstest.Item{}, []string{ "A1", }, fs.GetModifyWindow(ctx, r.Fremote), ) } func TestCopyURL(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) contents := "file contents\n" file1 := r.WriteFile("file1", contents, t1) file2 := r.WriteFile("file2", contents, t1) r.Mkdir(ctx, r.Fremote) r.CheckRemoteItems(t) // check when reading from regular HTTP server status := 0 nameHeader := false headerFilename := "headerfilename.txt" handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if status != 0 { http.Error(w, "an error occurred", status) } if nameHeader { w.Header().Set("Content-Disposition", `attachment; filename="folder\`+headerFilename+`"`) } _, err := w.Write([]byte(contents)) assert.NoError(t, err) }) ts := httptest.NewServer(handler) defer ts.Close() o, err := operations.CopyURL(ctx, r.Fremote, "file1", ts.URL, false, false, false) require.NoError(t, err) assert.Equal(t, int64(len(contents)), o.Size()) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{file1}, nil, fs.ModTimeNotSupported) // Check file clobbering _, err = operations.CopyURL(ctx, r.Fremote, "file1", ts.URL, false, false, true) require.Error(t, err) // Check auto file naming status = 0 urlFileName := "filename.txt" o, err = operations.CopyURL(ctx, r.Fremote, "", ts.URL+"/"+urlFileName, true, false, false) require.NoError(t, err) assert.Equal(t, int64(len(contents)), o.Size()) assert.Equal(t, urlFileName, o.Remote()) // Check header file naming nameHeader = true o, err = operations.CopyURL(ctx, r.Fremote, "", ts.URL, true, true, false) require.NoError(t, err) assert.Equal(t, int64(len(contents)), o.Size()) assert.Equal(t, headerFilename, o.Remote()) // Check auto file naming when url without file name _, err = operations.CopyURL(ctx, r.Fremote, "file1", ts.URL, true, false, false) require.Error(t, err) // Check header file naming without header set nameHeader = false _, err = operations.CopyURL(ctx, r.Fremote, "file1", ts.URL, true, true, false) require.Error(t, err) // Check an error is returned for a 404 status = http.StatusNotFound o, err = operations.CopyURL(ctx, r.Fremote, "file1", ts.URL, false, false, false) require.Error(t, err) assert.Contains(t, err.Error(), "Not Found") assert.Nil(t, o) status = 0 // check when reading from unverified HTTPS server ci.InsecureSkipVerify = true fshttp.ResetTransport() defer fshttp.ResetTransport() tss := httptest.NewTLSServer(handler) defer tss.Close() o, err = operations.CopyURL(ctx, r.Fremote, "file2", tss.URL, false, false, false) require.NoError(t, err) assert.Equal(t, int64(len(contents)), o.Size()) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{file1, file2, fstest.NewItem(urlFileName, contents, t1), fstest.NewItem(headerFilename, contents, t1)}, nil, fs.ModTimeNotSupported) } func TestCopyURLToWriter(t *testing.T) { ctx := context.Background() contents := "file contents\n" // check when reading from regular HTTP server status := 0 handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if status != 0 { http.Error(w, "an error occurred", status) return } _, err := w.Write([]byte(contents)) assert.NoError(t, err) }) ts := httptest.NewServer(handler) defer ts.Close() // test normal fetch var buf bytes.Buffer err := operations.CopyURLToWriter(ctx, ts.URL, &buf) require.NoError(t, err) assert.Equal(t, contents, buf.String()) // test fetch with error status = http.StatusNotFound buf.Reset() err = operations.CopyURLToWriter(ctx, ts.URL, &buf) require.Error(t, err) assert.Contains(t, err.Error(), "Not Found") assert.Equal(t, 0, len(buf.String())) } func TestMoveFile(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteFile("file1", "file1 contents", t1) r.CheckLocalItems(t, file1) file2 := file1 file2.Path = "sub/file2" err := operations.MoveFile(ctx, r.Fremote, r.Flocal, file2.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t) r.CheckRemoteItems(t, file2) r.WriteFile("file1", "file1 contents", t1) r.CheckLocalItems(t, file1) err = operations.MoveFile(ctx, r.Fremote, r.Flocal, file2.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t) r.CheckRemoteItems(t, file2) err = operations.MoveFile(ctx, r.Fremote, r.Fremote, file2.Path, file2.Path) require.NoError(t, err) r.CheckLocalItems(t) r.CheckRemoteItems(t, file2) } func TestMoveFileWithIgnoreExisting(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) file1 := r.WriteFile("file1", "file1 contents", t1) r.CheckLocalItems(t, file1) ci.IgnoreExisting = true err := operations.MoveFile(ctx, r.Fremote, r.Flocal, file1.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t) r.CheckRemoteItems(t, file1) // Recreate file with updated content file1b := r.WriteFile("file1", "file1 modified", t2) r.CheckLocalItems(t, file1b) // Ensure modified file did not transfer and was not deleted err = operations.MoveFile(ctx, r.Fremote, r.Flocal, file1.Path, file1b.Path) require.NoError(t, err) r.CheckLocalItems(t, file1b) r.CheckRemoteItems(t, file1) } func TestCaseInsensitiveMoveFile(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) if !r.Fremote.Features().CaseInsensitive { return } file1 := r.WriteFile("file1", "file1 contents", t1) r.CheckLocalItems(t, file1) file2 := file1 file2.Path = "sub/file2" err := operations.MoveFile(ctx, r.Fremote, r.Flocal, file2.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t) r.CheckRemoteItems(t, file2) r.WriteFile("file1", "file1 contents", t1) r.CheckLocalItems(t, file1) err = operations.MoveFile(ctx, r.Fremote, r.Flocal, file2.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t) r.CheckRemoteItems(t, file2) file2Capitalized := file2 file2Capitalized.Path = "sub/File2" err = operations.MoveFile(ctx, r.Fremote, r.Fremote, file2Capitalized.Path, file2.Path) require.NoError(t, err) r.CheckLocalItems(t) r.CheckRemoteItems(t, file2Capitalized) } func TestCaseInsensitiveMoveFileDryRun(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) if !r.Fremote.Features().CaseInsensitive { return } file1 := r.WriteObject(ctx, "hello", "world", t1) r.CheckRemoteItems(t, file1) ci.DryRun = true err := operations.MoveFile(ctx, r.Fremote, r.Fremote, "HELLO", file1.Path) require.NoError(t, err) r.CheckRemoteItems(t, file1) } func TestMoveFileBackupDir(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) if !operations.CanServerSideMove(r.Fremote) { t.Skip("Skipping test as remote does not support server-side move or copy") } ci.BackupDir = r.FremoteName + "/backup" file1 := r.WriteFile("dst/file1", "file1 contents", t1) r.CheckLocalItems(t, file1) file1old := r.WriteObject(ctx, "dst/file1", "file1 contents old", t1) r.CheckRemoteItems(t, file1old) err := operations.MoveFile(ctx, r.Fremote, r.Flocal, file1.Path, file1.Path) require.NoError(t, err) r.CheckLocalItems(t) file1old.Path = "backup/dst/file1" r.CheckRemoteItems(t, file1old, file1) } // testFsInfo is for unit testing fs.Info type testFsInfo struct { name string root string stringVal string precision time.Duration hashes hash.Set features fs.Features } // Name of the remote (as passed into NewFs) func (i *testFsInfo) Name() string { return i.name } // Root of the remote (as passed into NewFs) func (i *testFsInfo) Root() string { return i.root } // String returns a description of the FS func (i *testFsInfo) String() string { return i.stringVal } // Precision of the ModTimes in this Fs func (i *testFsInfo) Precision() time.Duration { return i.precision } // Returns the supported hash types of the filesystem func (i *testFsInfo) Hashes() hash.Set { return i.hashes } // Returns the supported hash types of the filesystem func (i *testFsInfo) Features() *fs.Features { return &i.features } func TestSameConfig(t *testing.T) { a := &testFsInfo{name: "name", root: "root"} for _, test := range []struct { name string root string expected bool }{ {"name", "root", true}, {"name", "rooty", true}, {"namey", "root", false}, {"namey", "roott", false}, } { b := &testFsInfo{name: test.name, root: test.root} actual := operations.SameConfig(a, b) assert.Equal(t, test.expected, actual) actual = operations.SameConfig(b, a) assert.Equal(t, test.expected, actual) } } func TestSame(t *testing.T) { a := &testFsInfo{name: "name", root: "root"} for _, test := range []struct { name string root string expected bool }{ {"name", "root", true}, {"name", "rooty", false}, {"namey", "root", false}, {"namey", "roott", false}, } { b := &testFsInfo{name: test.name, root: test.root} actual := operations.Same(a, b) assert.Equal(t, test.expected, actual) actual = operations.Same(b, a) assert.Equal(t, test.expected, actual) } } // testFs is for unit testing fs.Fs type testFs struct { testFsInfo } func (i *testFs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { return nil, nil } func (i *testFs) NewObject(ctx context.Context, remote string) (fs.Object, error) { return nil, nil } func (i *testFs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return nil, nil } func (i *testFs) Mkdir(ctx context.Context, dir string) error { return nil } func (i *testFs) Rmdir(ctx context.Context, dir string) error { return nil } // copied from TestOverlapping because the behavior of OverlappingFilterCheck should be identical to Overlapping // when no filters are set func TestOverlappingFilterCheckWithoutFilter(t *testing.T) { ctx := context.Background() src := &testFs{testFsInfo{name: "name", root: "root"}} slash := string(os.PathSeparator) // native path separator for _, test := range []struct { name string root string expected bool }{ {"name", "root", true}, {"name", "/root", true}, {"namey", "root", false}, {"name", "rooty", false}, {"namey", "rooty", false}, {"name", "roo", false}, {"name", "root/toot", true}, {"name", "root/toot/", true}, {"name", "root" + slash + "toot", true}, {"name", "root" + slash + "toot" + slash, true}, {"name", "", true}, {"name", "/", true}, } { dst := &testFs{testFsInfo{name: test.name, root: test.root}} what := fmt.Sprintf("(%q,%q) vs (%q,%q)", src.name, src.root, dst.name, dst.root) actual := operations.OverlappingFilterCheck(ctx, src, dst) assert.Equal(t, test.expected, actual, what) actual = operations.OverlappingFilterCheck(ctx, dst, src) assert.Equal(t, test.expected, actual, what) } } func TestOverlappingFilterCheckWithFilter(t *testing.T) { ctx := context.Background() fi, err := filter.NewFilter(nil) require.NoError(t, err) require.NoError(t, fi.Add(false, "/exclude/")) require.NoError(t, fi.Add(false, "/Exclude2/")) require.NoError(t, fi.Add(true, "*")) ctx = filter.ReplaceConfig(ctx, fi) src := &testFs{testFsInfo{name: "name", root: "root"}} src.features.CaseInsensitive = true slash := string(os.PathSeparator) // native path separator for _, test := range []struct { name string root string expected bool }{ {"name", "root", true}, {"name", "ROOT", true}, // case insensitive is set {"name", "/root", true}, {"name", "root/", true}, {"name", "root" + slash, true}, {"name", "root/exclude", false}, {"name", "root/Exclude2", false}, {"name", "root/include", true}, {"name", "root/exclude/", false}, {"name", "root/Exclude2/", false}, {"name", "root/exclude/sub", false}, {"name", "root/Exclude2/sub", false}, {"name", "/root/exclude/", false}, {"name", "root" + slash + "exclude", false}, {"name", "root" + slash + "exclude" + slash, false}, {"namey", "root/include", false}, {"namey", "root/include/", false}, {"namey", "root" + slash + "include", false}, {"namey", "root" + slash + "include" + slash, false}, } { dst := &testFs{testFsInfo{name: test.name, root: test.root}} dst.features.CaseInsensitive = true what := fmt.Sprintf("(%q,%q) vs (%q,%q)", src.name, src.root, dst.name, dst.root) actual := operations.OverlappingFilterCheck(ctx, dst, src) assert.Equal(t, test.expected, actual, what) actual = operations.OverlappingFilterCheck(ctx, src, dst) assert.Equal(t, test.expected, actual, what) } } func TestListFormat(t *testing.T) { item0 := &operations.ListJSONItem{ Path: "a", Name: "a", Encrypted: "encryptedFileName", Size: 1, MimeType: "application/octet-stream", ModTime: operations.Timestamp{ When: t1, Format: "2006-01-02T15:04:05.000000000Z07:00"}, IsDir: false, Hashes: map[string]string{ "md5": "0cc175b9c0f1b6a831c399e269772661", "sha1": "86f7e437faa5a7fce15d1ddcb9eaeaea377667b8", "dropbox": "bf5d3affb73efd2ec6c36ad3112dd933efed63c4e1cbffcfa88e2759c144f2d8", "quickxor": "6100000000000000000000000100000000000000"}, ID: "fileID", OrigID: "fileOrigID", } item1 := &operations.ListJSONItem{ Path: "subdir", Name: "subdir", Encrypted: "encryptedDirName", Size: -1, MimeType: "inode/directory", ModTime: operations.Timestamp{ When: t2, Format: "2006-01-02T15:04:05.000000000Z07:00"}, IsDir: true, Hashes: map[string]string(nil), ID: "dirID", OrigID: "dirOrigID", } var list operations.ListFormat list.AddPath() list.SetDirSlash(false) assert.Equal(t, "subdir", list.Format(item1)) list.SetDirSlash(true) assert.Equal(t, "subdir/", list.Format(item1)) list.SetOutput(nil) assert.Equal(t, "", list.Format(item1)) list.AppendOutput(func(item *operations.ListJSONItem) string { return "a" }) list.AppendOutput(func(item *operations.ListJSONItem) string { return "b" }) assert.Equal(t, "ab", list.Format(item1)) list.SetSeparator(":::") assert.Equal(t, "a:::b", list.Format(item1)) list.SetOutput(nil) list.AddModTime("") assert.Equal(t, t1.Local().Format("2006-01-02 15:04:05"), list.Format(item0)) list.SetOutput(nil) list.SetSeparator("|") list.AddID() list.AddOrigID() assert.Equal(t, "fileID|fileOrigID", list.Format(item0)) assert.Equal(t, "dirID|dirOrigID", list.Format(item1)) list.SetOutput(nil) list.AddMimeType() assert.Contains(t, list.Format(item0), "/") assert.Equal(t, "inode/directory", list.Format(item1)) list.SetOutput(nil) list.AddMetadata() assert.Equal(t, "{}", list.Format(item0)) assert.Equal(t, "{}", list.Format(item1)) list.SetOutput(nil) list.AddPath() list.SetAbsolute(true) assert.Equal(t, "/a", list.Format(item0)) list.SetAbsolute(false) assert.Equal(t, "a", list.Format(item0)) list.SetOutput(nil) list.AddSize() assert.Equal(t, "1", list.Format(item0)) list.AddPath() list.AddModTime("") list.SetDirSlash(true) list.SetSeparator("__SEP__") assert.Equal(t, "1__SEP__a__SEP__"+t1.Local().Format("2006-01-02 15:04:05"), list.Format(item0)) assert.Equal(t, "-1__SEP__subdir/__SEP__"+t2.Local().Format("2006-01-02 15:04:05"), list.Format(item1)) for _, test := range []struct { ht hash.Type want string }{ {hash.MD5, "0cc175b9c0f1b6a831c399e269772661"}, {hash.SHA1, "86f7e437faa5a7fce15d1ddcb9eaeaea377667b8"}, } { list.SetOutput(nil) list.AddHash(test.ht) assert.Equal(t, test.want, list.Format(item0)) } list.SetOutput(nil) list.SetSeparator("|") list.SetCSV(true) list.AddSize() list.AddPath() list.AddModTime("") list.SetDirSlash(true) assert.Equal(t, "1|a|"+t1.Local().Format("2006-01-02 15:04:05"), list.Format(item0)) assert.Equal(t, "-1|subdir/|"+t2.Local().Format("2006-01-02 15:04:05"), list.Format(item1)) list.SetOutput(nil) list.SetSeparator("|") list.AddPath() list.AddEncrypted() assert.Equal(t, "a|encryptedFileName", list.Format(item0)) assert.Equal(t, "subdir/|encryptedDirName/", list.Format(item1)) } func TestDirMove(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) r.Mkdir(ctx, r.Fremote) // Make some files and dirs r.ForceMkdir(ctx, r.Fremote) files := []fstest.Item{ r.WriteObject(ctx, "A1/one", "one", t1), r.WriteObject(ctx, "A1/two", "two", t2), r.WriteObject(ctx, "A1/B1/three", "three", t3), r.WriteObject(ctx, "A1/B1/C1/four", "four", t1), r.WriteObject(ctx, "A1/B1/C2/five", "five", t2), } require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1/B2")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "A1/B1/C3")) fstest.CheckListingWithPrecision( t, r.Fremote, files, []string{ "A1", "A1/B1", "A1/B2", "A1/B1/C1", "A1/B1/C2", "A1/B1/C3", }, fs.GetModifyWindow(ctx, r.Fremote), ) require.NoError(t, operations.DirMove(ctx, r.Fremote, "A1", "A2")) for i := range files { files[i].Path = strings.ReplaceAll(files[i].Path, "A1/", "A2/") } fstest.CheckListingWithPrecision( t, r.Fremote, files, []string{ "A2", "A2/B1", "A2/B2", "A2/B1/C1", "A2/B1/C2", "A2/B1/C3", }, fs.GetModifyWindow(ctx, r.Fremote), ) // Disable DirMove features := r.Fremote.Features() features.DirMove = nil require.NoError(t, operations.DirMove(ctx, r.Fremote, "A2", "A3")) for i := range files { files[i].Path = strings.ReplaceAll(files[i].Path, "A2/", "A3/") } fstest.CheckListingWithPrecision( t, r.Fremote, files, []string{ "A3", "A3/B1", "A3/B2", "A3/B1/C1", "A3/B1/C2", "A3/B1/C3", }, fs.GetModifyWindow(ctx, r.Fremote), ) // Try with a DirMove method that exists but returns fs.ErrorCantDirMove (ex. combine moving across upstreams) // Should fall back to manual move (copy + delete) features.DirMove = func(ctx context.Context, src fs.Fs, srcRemote string, dstRemote string) error { return fs.ErrorCantDirMove } assert.NoError(t, operations.DirMove(ctx, r.Fremote, "A3", "A4")) for i := range files { files[i].Path = strings.ReplaceAll(files[i].Path, "A3/", "A4/") } fstest.CheckListingWithPrecision( t, r.Fremote, files, []string{ "A4", "A4/B1", "A4/B2", "A4/B1/C1", "A4/B1/C2", "A4/B1/C3", }, fs.GetModifyWindow(ctx, r.Fremote), ) } func TestGetFsInfo(t *testing.T) { r := fstest.NewRun(t) f := r.Fremote info := operations.GetFsInfo(f) assert.Equal(t, f.Name(), info.Name) assert.Equal(t, f.Root(), info.Root) assert.Equal(t, f.String(), info.String) assert.Equal(t, f.Precision(), info.Precision) hashSet := hash.NewHashSet() for _, hashName := range info.Hashes { var ht hash.Type require.NoError(t, ht.Set(hashName)) hashSet.Add(ht) } assert.Equal(t, f.Hashes(), hashSet) assert.Equal(t, f.Features().Enabled(), info.Features) } func TestRcat(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) check := func(t *testing.T, withChecksum, ignoreChecksum bool) { ci.CheckSum, ci.IgnoreChecksum = withChecksum, ignoreChecksum var prefix string if withChecksum { prefix = "with_checksum_" } else { prefix = "no_checksum_" } if ignoreChecksum { prefix = "ignore_checksum_" } r := fstest.NewRun(t) if *fstest.SizeLimit > 0 && int64(ci.StreamingUploadCutoff) > *fstest.SizeLimit { savedCutoff := ci.StreamingUploadCutoff ci.StreamingUploadCutoff = fs.SizeSuffix(*fstest.SizeLimit) t.Logf("Adjust StreamingUploadCutoff to size limit %s (was %s)", ci.StreamingUploadCutoff, savedCutoff) } fstest.CheckListing(t, r.Fremote, []fstest.Item{}) data1 := "this is some really nice test data" path1 := prefix + "small_file_from_pipe" data2 := string(make([]byte, ci.StreamingUploadCutoff+1)) path2 := prefix + "big_file_from_pipe" in := io.NopCloser(strings.NewReader(data1)) _, err := operations.Rcat(ctx, r.Fremote, path1, in, t1, nil) require.NoError(t, err) in = io.NopCloser(strings.NewReader(data2)) _, err = operations.Rcat(ctx, r.Fremote, path2, in, t2, nil) require.NoError(t, err) file1 := fstest.NewItem(path1, data1, t1) file2 := fstest.NewItem(path2, data2, t2) r.CheckRemoteItems(t, file1, file2) } for i := range 4 { withChecksum := (i & 1) != 0 ignoreChecksum := (i & 2) != 0 t.Run(fmt.Sprintf("withChecksum=%v,ignoreChecksum=%v", withChecksum, ignoreChecksum), func(t *testing.T) { check(t, withChecksum, ignoreChecksum) }) } } func TestRcatMetadata(t *testing.T) { r := fstest.NewRun(t) if !r.Fremote.Features().UserMetadata { t.Skip("Skipping as destination doesn't support user metadata") } test := func(disableUploadCutoff bool) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) ci.Metadata = true data := "this is some really nice test data with metadata" path := "rcat_metadata" meta := fs.Metadata{ "key": "value", "sausage": "potato", } if disableUploadCutoff { ci.StreamingUploadCutoff = 0 data += " uploadCutoff=0" path += "_uploadcutoff0" } fstest.CheckListing(t, r.Fremote, []fstest.Item{}) in := io.NopCloser(strings.NewReader(data)) _, err := operations.Rcat(ctx, r.Fremote, path, in, t1, meta) require.NoError(t, err) file := fstest.NewItem(path, data, t1) r.CheckRemoteItems(t, file) o, err := r.Fremote.NewObject(ctx, path) require.NoError(t, err) gotMeta, err := fs.GetMetadata(ctx, o) require.NoError(t, err) // Check the specific user data we set is set // Likely there will be other values assert.Equal(t, "value", gotMeta["key"]) assert.Equal(t, "potato", gotMeta["sausage"]) // Delete the test file require.NoError(t, o.Remove(ctx)) } t.Run("Normal", func(t *testing.T) { test(false) }) t.Run("ViaDisk", func(t *testing.T) { test(true) }) } func TestRcatSize(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) const body = "------------------------------------------------------------" file1 := r.WriteFile("potato1", body, t1) file2 := r.WriteFile("potato2", body, t2) // Test with known length bodyReader := io.NopCloser(strings.NewReader(body)) obj, err := operations.RcatSize(ctx, r.Fremote, file1.Path, bodyReader, int64(len(body)), file1.ModTime, nil) require.NoError(t, err) assert.Equal(t, int64(len(body)), obj.Size()) assert.Equal(t, file1.Path, obj.Remote()) // Test with unknown length bodyReader = io.NopCloser(strings.NewReader(body)) // reset Reader io.NopCloser(strings.NewReader(body)) obj, err = operations.RcatSize(ctx, r.Fremote, file2.Path, bodyReader, -1, file2.ModTime, nil) require.NoError(t, err) assert.Equal(t, int64(len(body)), obj.Size()) assert.Equal(t, file2.Path, obj.Remote()) // Check files exist r.CheckRemoteItems(t, file1, file2) } func TestRcatSizeMetadata(t *testing.T) { r := fstest.NewRun(t) if !r.Fremote.Features().UserMetadata { t.Skip("Skipping as destination doesn't support user metadata") } ctx := context.Background() ctx, ci := fs.AddConfig(ctx) ci.Metadata = true meta := fs.Metadata{ "key": "value", "sausage": "potato", } const body = "------------------------------------------------------------" file1 := r.WriteFile("potato1", body, t1) file2 := r.WriteFile("potato2", body, t2) // Test with known length bodyReader := io.NopCloser(strings.NewReader(body)) obj, err := operations.RcatSize(ctx, r.Fremote, file1.Path, bodyReader, int64(len(body)), file1.ModTime, meta) require.NoError(t, err) assert.Equal(t, int64(len(body)), obj.Size()) assert.Equal(t, file1.Path, obj.Remote()) // Test with unknown length bodyReader = io.NopCloser(strings.NewReader(body)) // reset Reader io.NopCloser(strings.NewReader(body)) obj, err = operations.RcatSize(ctx, r.Fremote, file2.Path, bodyReader, -1, file2.ModTime, meta) require.NoError(t, err) assert.Equal(t, int64(len(body)), obj.Size()) assert.Equal(t, file2.Path, obj.Remote()) // Check files exist r.CheckRemoteItems(t, file1, file2) // Check metadata OK for _, path := range []string{file1.Path, file2.Path} { o, err := r.Fremote.NewObject(ctx, path) require.NoError(t, err) gotMeta, err := fs.GetMetadata(ctx, o) require.NoError(t, err) // Check the specific user data we set is set // Likely there will be other values assert.Equal(t, "value", gotMeta["key"]) assert.Equal(t, "potato", gotMeta["sausage"]) } } func TestTouchDir(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) if r.Fremote.Precision() == fs.ModTimeNotSupported { t.Skip("Skipping test as remote does not support modtime") } file1 := r.WriteBoth(ctx, "potato2", "------------------------------------------------------------", t1) file2 := r.WriteBoth(ctx, "empty space", "-", t2) file3 := r.WriteBoth(ctx, "sub dir/potato3", "hello", t2) r.CheckRemoteItems(t, file1, file2, file3) accounting.GlobalStats().ResetCounters() timeValue := time.Date(2010, 9, 8, 7, 6, 5, 4, time.UTC) err := operations.TouchDir(ctx, r.Fremote, "", timeValue, true) require.NoError(t, err) if accounting.Stats(ctx).GetErrors() != 0 { err = accounting.Stats(ctx).GetLastError() require.True(t, errors.Is(err, fs.ErrorCantSetModTime) || errors.Is(err, fs.ErrorCantSetModTimeWithoutDelete)) } else { file1.ModTime = timeValue file2.ModTime = timeValue file3.ModTime = timeValue r.CheckRemoteItems(t, file1, file2, file3) } } var testMetadata = fs.Metadata{ // System metadata supported by all backends "mtime": t1.Format(time.RFC3339Nano), // User metadata "potato": "jersey", } func TestMkdirMetadata(t *testing.T) { const name = "dir with metadata" ctx := context.Background() ctx, ci := fs.AddConfig(ctx) ci.Metadata = true r := fstest.NewRun(t) features := r.Fremote.Features() if features.MkdirMetadata == nil { t.Skip("Skipping test as remote does not support MkdirMetadata") } newDst, err := operations.MkdirMetadata(ctx, r.Fremote, name, testMetadata) require.NoError(t, err) require.NotNil(t, newDst) require.True(t, features.ReadDirMetadata, "Expecting ReadDirMetadata to be supported if MkdirMetadata is supported") // Check the returned directory and one read from the listing fstest.CheckEntryMetadata(ctx, t, r.Fremote, newDst, testMetadata) fstest.CheckEntryMetadata(ctx, t, r.Fremote, fstest.NewDirectory(ctx, t, r.Fremote, name), testMetadata) } func TestMkdirModTime(t *testing.T) { const name = "directory with modtime" ctx := context.Background() r := fstest.NewRun(t) if r.Fremote.Features().DirSetModTime == nil && r.Fremote.Features().MkdirMetadata == nil { t.Skip("Skipping test as remote does not support DirSetModTime or MkdirMetadata") } newDst, err := operations.MkdirModTime(ctx, r.Fremote, name, t2) require.NoError(t, err) // Check the returned directory and one read from the listing // newDst may be nil here depending on how the modtime was set if newDst != nil { fstest.CheckDirModTime(ctx, t, r.Fremote, newDst, t2) } fstest.CheckDirModTime(ctx, t, r.Fremote, fstest.NewDirectory(ctx, t, r.Fremote, name), t2) } func TestCopyDirMetadata(t *testing.T) { const nameNonExistent = "non existent directory" const nameExistent = "existing directory" ctx := context.Background() ctx, ci := fs.AddConfig(ctx) ci.Metadata = true r := fstest.NewRun(t) if !r.Fremote.Features().WriteDirMetadata && r.Fremote.Features().MkdirMetadata == nil { t.Skip("Skipping test as remote does not support WriteDirMetadata or MkdirMetadata") } // Create a source local directory with metadata newSrc, err := operations.MkdirMetadata(ctx, r.Flocal, "dir with metadata to be copied", testMetadata) require.NoError(t, err) require.NotNil(t, newSrc) // First try with the directory not existing newDst, err := operations.CopyDirMetadata(ctx, r.Fremote, nil, nameNonExistent, newSrc) require.NoError(t, err) require.NotNil(t, newDst) // Check the returned directory and one read from the listing fstest.CheckEntryMetadata(ctx, t, r.Fremote, newDst, testMetadata) fstest.CheckEntryMetadata(ctx, t, r.Fremote, fstest.NewDirectory(ctx, t, r.Fremote, nameNonExistent), testMetadata) // Then try with the directory existing require.NoError(t, r.Fremote.Rmdir(ctx, nameNonExistent)) require.NoError(t, r.Fremote.Mkdir(ctx, nameExistent)) existingDir := fstest.NewDirectory(ctx, t, r.Fremote, nameExistent) newDst, err = operations.CopyDirMetadata(ctx, r.Fremote, existingDir, "SHOULD BE IGNORED", newSrc) require.NoError(t, err) require.NotNil(t, newDst) // Check the returned directory and one read from the listing fstest.CheckEntryMetadata(ctx, t, r.Fremote, newDst, testMetadata) fstest.CheckEntryMetadata(ctx, t, r.Fremote, fstest.NewDirectory(ctx, t, r.Fremote, nameExistent), testMetadata) } func TestSetDirModTime(t *testing.T) { const name = "set modtime on existing directory" ctx, ci := fs.AddConfig(context.Background()) r := fstest.NewRun(t) if r.Fremote.Features().DirSetModTime == nil && !r.Fremote.Features().WriteDirSetModTime { t.Skip("Skipping test as remote does not support DirSetModTime or WriteDirSetModTime") } // Check that we obey --no-update-dir-modtime - this should return nil, nil ci.NoUpdateDirModTime = true newDst, err := operations.SetDirModTime(ctx, r.Fremote, nil, "set modtime on non existent directory", t2) require.NoError(t, err) require.Nil(t, newDst) ci.NoUpdateDirModTime = false // First try with the directory not existing - should return an error newDst, err = operations.SetDirModTime(ctx, r.Fremote, nil, "set modtime on non existent directory", t2) require.Error(t, err) require.Nil(t, newDst) // Then try with the directory existing require.NoError(t, r.Fremote.Mkdir(ctx, name)) existingDir := fstest.NewDirectory(ctx, t, r.Fremote, name) newDst, err = operations.SetDirModTime(ctx, r.Fremote, existingDir, "SHOULD BE IGNORED", t2) require.NoError(t, err) require.NotNil(t, newDst) // Check the returned directory and one read from the listing // The modtime will only be correct on newDst if it had a SetModTime method if _, ok := newDst.(fs.SetModTimer); ok { fstest.CheckDirModTime(ctx, t, r.Fremote, newDst, t2) } fstest.CheckDirModTime(ctx, t, r.Fremote, fstest.NewDirectory(ctx, t, r.Fremote, name), t2) // Now wrap the directory to make the SetModTime method return fs.ErrorNotImplemented and check that it falls back correctly wrappedDir := fs.NewDirWrapper(existingDir.Remote(), fs.NewDir(existingDir.Remote(), existingDir.ModTime(ctx))) newDst, err = operations.SetDirModTime(ctx, r.Fremote, wrappedDir, "SHOULD BE IGNORED", t1) require.NoError(t, err) require.NotNil(t, newDst) fstest.CheckDirModTime(ctx, t, r.Fremote, fstest.NewDirectory(ctx, t, r.Fremote, name), t1) } func TestDirsEqual(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) ci.Metadata = true r := fstest.NewRun(t) if !r.Fremote.Features().WriteDirMetadata && r.Fremote.Features().MkdirMetadata == nil { t.Skip("Skipping test as remote does not support WriteDirMetadata or MkdirMetadata") } opt := operations.DirsEqualOpt{ ModifyWindow: fs.GetModifyWindow(ctx, r.Flocal, r.Fremote), SetDirModtime: true, SetDirMetadata: true, } // Create a source local directory with metadata src, err := operations.MkdirMetadata(ctx, r.Flocal, "dir with metadata to be copied", testMetadata) require.NoError(t, err) require.NotNil(t, src) // try with nil dst -- should be false equal := operations.DirsEqual(ctx, src, nil, opt) assert.False(t, equal) // make a dest with an equal modtime dst, err := operations.MkdirModTime(ctx, r.Fremote, "dst", src.ModTime(ctx)) require.NoError(t, err) // try with equal modtimes -- should be true equal = operations.DirsEqual(ctx, src, dst, opt) assert.True(t, equal) // try with unequal modtimes -- should be false dst, err = operations.SetDirModTime(ctx, r.Fremote, dst, "", t2) require.NoError(t, err) equal = operations.DirsEqual(ctx, src, dst, opt) assert.False(t, equal) // try with unequal modtimes that are within modify window -- should be true halfWindow := opt.ModifyWindow / 2 dst, err = operations.SetDirModTime(ctx, r.Fremote, dst, "", src.ModTime(ctx).Add(halfWindow)) require.NoError(t, err) equal = operations.DirsEqual(ctx, src, dst, opt) assert.True(t, equal) // test ignoretimes -- should be false ci.IgnoreTimes = true equal = operations.DirsEqual(ctx, src, dst, opt) assert.False(t, equal) // test immutable -- should be true ci.IgnoreTimes = false ci.Immutable = true dst, err = operations.SetDirModTime(ctx, r.Fremote, dst, "", t3) require.NoError(t, err) equal = operations.DirsEqual(ctx, src, dst, opt) assert.True(t, equal) // test dst newer than src with --update -- should be true ci.Immutable = false ci.UpdateOlder = true equal = operations.DirsEqual(ctx, src, dst, opt) assert.True(t, equal) // test no SetDirModtime or SetDirMetadata -- should be true ci.UpdateOlder = false opt.SetDirMetadata, opt.SetDirModtime = false, false equal = operations.DirsEqual(ctx, src, dst, opt) assert.True(t, equal) } func TestRemoveExisting(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) if r.Fremote.Features().Move == nil { t.Skip("Skipping as remote can't Move") } file1 := r.WriteObject(ctx, "sub dir/test remove existing", "hello world", t1) file2 := r.WriteObject(ctx, "sub dir/test remove existing with long name 123456789012345678901234567890123456789012345678901234567890123456789", "hello long name world", t1) r.CheckRemoteItems(t, file1, file2) var returnedError error // Check not found first cleanup, err := operations.RemoveExisting(ctx, r.Fremote, "not found", "TEST") assert.Equal(t, err, nil) r.CheckRemoteItems(t, file1, file2) cleanup(&returnedError) r.CheckRemoteItems(t, file1, file2) // Remove file1 cleanup, err = operations.RemoveExisting(ctx, r.Fremote, file1.Path, "TEST") assert.Equal(t, err, nil) //r.CheckRemoteItems(t, file1, file2) // Check file1 with temporary name exists var buf bytes.Buffer err = operations.List(ctx, r.Fremote, &buf) require.NoError(t, err) res := buf.String() assert.NotContains(t, res, " 11 "+file1.Path+"\n") assert.Contains(t, res, " 11 "+file1.Path+".") assert.Contains(t, res, " 21 "+file2.Path+"\n") cleanup(&returnedError) r.CheckRemoteItems(t, file2) // Remove file2 with an error cleanup, err = operations.RemoveExisting(ctx, r.Fremote, file2.Path, "TEST") assert.Equal(t, err, nil) // Check file2 with truncated temporary name exists buf.Reset() err = operations.List(ctx, r.Fremote, &buf) require.NoError(t, err) res = buf.String() assert.NotContains(t, res, " 21 "+file2.Path+"\n") assert.NotContains(t, res, " 21 "+file2.Path+".") assert.Contains(t, res, " 21 "+file2.Path[:100]) returnedError = errors.New("BOOM") cleanup(&returnedError) r.CheckRemoteItems(t, file2) // Remove file2 cleanup, err = operations.RemoveExisting(ctx, r.Fremote, file2.Path, "TEST") assert.Equal(t, err, nil) // Check file2 with truncated temporary name exists buf.Reset() err = operations.List(ctx, r.Fremote, &buf) require.NoError(t, err) res = buf.String() assert.NotContains(t, res, " 21 "+file2.Path+"\n") assert.NotContains(t, res, " 21 "+file2.Path+".") assert.Contains(t, res, " 21 "+file2.Path[:100]) returnedError = nil cleanup(&returnedError) r.CheckRemoteItems(t) } rclone-v1.71.0/fs/operations/operationsflags/000077500000000000000000000000001505210326400212415ustar00rootroot00000000000000rclone-v1.71.0/fs/operations/operationsflags/operationsflags.go000066400000000000000000000132611505210326400247730ustar00rootroot00000000000000// Package operationsflags defines the flags used by rclone operations. // It is decoupled into a separate package so it can be replaced. package operationsflags import ( "context" _ "embed" "io" "os" "strings" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/flags" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/operations" "github.com/spf13/cobra" "github.com/spf13/pflag" ) //go:embed operationsflags.md var help string // Help returns the help string cleaned up to simplify appending func Help() string { return strings.TrimSpace(help) + "\n\n" } // AddLoggerFlagsOptions contains options for the Logger Flags type AddLoggerFlagsOptions struct { Combined string // a file with file names with leading sigils MissingOnSrc string // files only in the destination MissingOnDst string // files only in the source Match string // matching files Differ string // differing files ErrFile string // files with errors of some kind DestAfter string // files that exist on the destination post-sync } // AnySet checks if any of the logger flags have a non-blank value func (o AddLoggerFlagsOptions) AnySet() bool { return anyNotBlank(o.Combined, o.MissingOnSrc, o.MissingOnDst, o.Match, o.Differ, o.ErrFile, o.DestAfter) } func anyNotBlank(s ...string) bool { for _, x := range s { if x != "" { return true } } return false } // AddLoggerFlags adds the logger flags to the cmdFlags command func AddLoggerFlags(cmdFlags *pflag.FlagSet, opt *operations.LoggerOpt, flagsOpt *AddLoggerFlagsOptions) { flags.StringVarP(cmdFlags, &flagsOpt.Combined, "combined", "", flagsOpt.Combined, "Make a combined report of changes to this file", "Sync") flags.StringVarP(cmdFlags, &flagsOpt.MissingOnSrc, "missing-on-src", "", flagsOpt.MissingOnSrc, "Report all files missing from the source to this file", "Sync") flags.StringVarP(cmdFlags, &flagsOpt.MissingOnDst, "missing-on-dst", "", flagsOpt.MissingOnDst, "Report all files missing from the destination to this file", "Sync") flags.StringVarP(cmdFlags, &flagsOpt.Match, "match", "", flagsOpt.Match, "Report all matching files to this file", "Sync") flags.StringVarP(cmdFlags, &flagsOpt.Differ, "differ", "", flagsOpt.Differ, "Report all non-matching files to this file", "Sync") flags.StringVarP(cmdFlags, &flagsOpt.ErrFile, "error", "", flagsOpt.ErrFile, "Report all files with errors (hashing or reading) to this file", "Sync") flags.StringVarP(cmdFlags, &flagsOpt.DestAfter, "dest-after", "", flagsOpt.DestAfter, "Report all files that exist on the dest post-sync", "Sync") // lsf flags for destAfter flags.StringVarP(cmdFlags, &opt.Format, "format", "F", "p", "Output format - see lsf help for details", "Sync") flags.StringVarP(cmdFlags, &opt.TimeFormat, "timeformat", "t", "", "Specify a custom time format, or 'max' for max precision supported by remote (default: 2006-01-02 15:04:05)", "") flags.StringVarP(cmdFlags, &opt.Separator, "separator", "s", ";", "Separator for the items in the format", "Sync") flags.BoolVarP(cmdFlags, &opt.DirSlash, "dir-slash", "d", true, "Append a slash to directory names", "Sync") opt.HashType = hash.MD5 flags.FVarP(cmdFlags, &opt.HashType, "hash", "", "Use this hash when `h` is used in the format MD5|SHA-1|DropboxHash", "Sync") flags.BoolVarP(cmdFlags, &opt.FilesOnly, "files-only", "", true, "Only list files", "Sync") flags.BoolVarP(cmdFlags, &opt.DirsOnly, "dirs-only", "", false, "Only list directories", "Sync") flags.BoolVarP(cmdFlags, &opt.Csv, "csv", "", false, "Output in CSV format", "Sync") flags.BoolVarP(cmdFlags, &opt.Absolute, "absolute", "", false, "Put a leading / in front of path names", "Sync") // flags.BoolVarP(cmdFlags, &recurse, "recursive", "R", false, "Recurse into the listing", "") } // ConfigureLoggers verifies and sets up writers for log files requested via CLI flags func ConfigureLoggers(ctx context.Context, fdst fs.Fs, command *cobra.Command, opt *operations.LoggerOpt, flagsOpt AddLoggerFlagsOptions) (func(), error) { closers := []io.Closer{} if opt.TimeFormat == "max" { opt.TimeFormat = operations.FormatForLSFPrecision(fdst.Precision()) } opt.SetListFormat(ctx, command.Flags()) opt.NewListJSON(ctx, fdst, "") open := func(name string, pout *io.Writer) error { if name == "" { return nil } if name == "-" { *pout = os.Stdout return nil } out, err := os.Create(name) if err != nil { return err } *pout = out closers = append(closers, out) return nil } if err := open(flagsOpt.Combined, &opt.Combined); err != nil { return nil, err } if err := open(flagsOpt.MissingOnSrc, &opt.MissingOnSrc); err != nil { return nil, err } if err := open(flagsOpt.MissingOnDst, &opt.MissingOnDst); err != nil { return nil, err } if err := open(flagsOpt.Match, &opt.Match); err != nil { return nil, err } if err := open(flagsOpt.Differ, &opt.Differ); err != nil { return nil, err } if err := open(flagsOpt.ErrFile, &opt.Error); err != nil { return nil, err } if err := open(flagsOpt.DestAfter, &opt.DestAfter); err != nil { return nil, err } close := func() { for _, closer := range closers { err := closer.Close() if err != nil { fs.Errorf(nil, "Failed to close report output: %v", err) } } } ci := fs.GetConfig(ctx) if ci.NoTraverse && opt.Combined != nil { fs.LogPrintf(fs.LogLevelWarning, nil, "--no-traverse does not list any deletes (-) in --combined output\n") } if ci.NoTraverse && opt.MissingOnSrc != nil { fs.LogPrintf(fs.LogLevelWarning, nil, "--no-traverse makes --missing-on-src produce empty output\n") } if ci.NoTraverse && opt.DestAfter != nil { fs.LogPrintf(fs.LogLevelWarning, nil, "--no-traverse makes --dest-after produce incomplete output\n") } return close, nil } rclone-v1.71.0/fs/operations/operationsflags/operationsflags.md000066400000000000000000000037131505210326400247670ustar00rootroot00000000000000## Logger Flags The `--differ`, `--missing-on-dst`, `--missing-on-src`, `--match` and `--error` flags write paths, one per line, to the file name (or stdout if it is `-`) supplied. What they write is described in the help below. For example `--differ` will write all paths which are present on both the source and destination but different. The `--combined` flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it. These are reminiscent of diff files. - `= path` means path was found in source and destination and was identical - `- path` means path was missing on the source, so only in the destination - `+ path` means path was missing on the destination, so only in the source - `* path` means path was present in source and destination but different. - `! path` means there was an error reading or hashing the source or dest. The `--dest-after` flag writes a list file using the same format flags as [`lsf`](/commands/rclone_lsf/#synopsis) (including [customizable options for hash, modtime, etc.](/commands/rclone_lsf/#synopsis)) Conceptually it is similar to rsync's `--itemize-changes`, but not identical -- it should output an accurate list of what will be on the destination after the command is finished. When the `--no-traverse` flag is set, all logs involving files that exist only on the destination will be incomplete or completely missing. Note that these logger flags have a few limitations, and certain scenarios are not currently supported: - `--max-duration` / `CutoffModeHard` - `--compare-dest` / `--copy-dest` - server-side moves of an entire dir at once - High-level retries, because there would be duplicates (use `--retries 1` to disable) - Possibly some unusual error scenarios Note also that each file is logged during execution, as opposed to after, so it is most useful as a predictor of what SHOULD happen to each file (which may or may not match what actually DID.) rclone-v1.71.0/fs/operations/rc.go000066400000000000000000000650641505210326400170070ustar00rootroot00000000000000package operations import ( "context" "errors" "fmt" "io" "mime" "mime/multipart" "net/http" "path" "strings" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/rc" "github.com/rclone/rclone/lib/diskusage" ) func init() { rc.Add(rc.Call{ Path: "operations/list", AuthRequired: true, Fn: rcList, Title: "List the given remote and path in JSON format", Help: `This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" - opt - a dictionary of options to control the listing (optional) - recurse - If set recurse directories - noModTime - If set return modification time - showEncrypted - If set show decrypted names - showOrigIDs - If set show the IDs for each item if known - showHash - If set return a dictionary of hashes - noMimeType - If set don't show mime types - dirsOnly - If set only show directories - filesOnly - If set only show files - metadata - If set return metadata of objects also - hashTypes - array of strings of hash types to show if showHash set Returns: - list - This is an array of objects as described in the lsjson command See the [lsjson](/commands/rclone_lsjson/) command for more information on the above and examples. `, }) } // List the directory func rcList(ctx context.Context, in rc.Params) (out rc.Params, err error) { f, remote, err := rc.GetFsAndRemote(ctx, in) if err != nil { return nil, err } var opt ListJSONOpt err = in.GetStruct("opt", &opt) if rc.NotErrParamNotFound(err) { return nil, err } list := []*ListJSONItem{} err = ListJSON(ctx, f, remote, &opt, func(item *ListJSONItem) error { list = append(list, item) return nil }) if err != nil { return nil, err } out = make(rc.Params) out["list"] = list return out, nil } func init() { rc.Add(rc.Call{ Path: "operations/stat", AuthRequired: true, Fn: rcStat, Title: "Give information about the supplied file or directory", Help: `This takes the following parameters - fs - a remote name string eg "drive:" - remote - a path within that remote eg "dir" - opt - a dictionary of options to control the listing (optional) - see operations/list for the options The result is - item - an object as described in the lsjson command. Will be null if not found. Note that if you are only interested in files then it is much more efficient to set the filesOnly flag in the options. See the [lsjson](/commands/rclone_lsjson/) command for more information on the above and examples. `, }) } // List the directory func rcStat(ctx context.Context, in rc.Params) (out rc.Params, err error) { f, remote, err := rc.GetFsAndRemote(ctx, in) if err != nil { return nil, err } var opt ListJSONOpt err = in.GetStruct("opt", &opt) if rc.NotErrParamNotFound(err) { return nil, err } item, err := StatJSON(ctx, f, remote, &opt) if err != nil { return nil, err } out = make(rc.Params) out["item"] = item return out, nil } func init() { rc.Add(rc.Call{ Path: "operations/about", AuthRequired: true, Fn: rcAbout, Title: "Return the space used on the remote", Help: `This takes the following parameters: - fs - a remote name string e.g. "drive:" The result is as returned from rclone about --json See the [about](/commands/rclone_about/) command for more information on the above. `, }) } // About the remote func rcAbout(ctx context.Context, in rc.Params) (out rc.Params, err error) { f, err := rc.GetFs(ctx, in) if err != nil { return nil, err } doAbout := f.Features().About if doAbout == nil { return nil, fmt.Errorf("%v doesn't support about", f) } u, err := doAbout(ctx) if err != nil { return nil, fmt.Errorf("about call failed: %w", err) } err = rc.Reshape(&out, u) if err != nil { return nil, fmt.Errorf("about Reshape failed: %w", err) } return out, nil } func init() { for _, copy := range []bool{false, true} { copy := copy name := "Move" if copy { name = "Copy" } rc.Add(rc.Call{ Path: "operations/" + strings.ToLower(name) + "file", AuthRequired: true, Fn: func(ctx context.Context, in rc.Params) (rc.Params, error) { return rcMoveOrCopyFile(ctx, in, copy) }, Title: name + " a file from source remote to destination remote", Help: `This takes the following parameters: - srcFs - a remote name string e.g. "drive:" for the source, "/" for local filesystem - srcRemote - a path within that remote e.g. "file.txt" for the source - dstFs - a remote name string e.g. "drive2:" for the destination, "/" for local filesystem - dstRemote - a path within that remote e.g. "file2.txt" for the destination `, }) } } // Copy a file func rcMoveOrCopyFile(ctx context.Context, in rc.Params, cp bool) (out rc.Params, err error) { srcFs, srcRemote, err := rc.GetFsAndRemoteNamed(ctx, in, "srcFs", "srcRemote") if err != nil { return nil, err } dstFs, dstRemote, err := rc.GetFsAndRemoteNamed(ctx, in, "dstFs", "dstRemote") if err != nil { return nil, err } return nil, moveOrCopyFile(ctx, dstFs, srcFs, dstRemote, srcRemote, cp, false) } func init() { for _, op := range []struct { name string title string help string noRemote bool needsRequest bool }{ {name: "mkdir", title: "Make a destination directory or container"}, {name: "rmdir", title: "Remove an empty directory or container"}, {name: "purge", title: "Remove a directory or container and all of its contents"}, {name: "rmdirs", title: "Remove all the empty directories in the path", help: "- leaveRoot - boolean, set to true not to delete the root\n"}, {name: "delete", title: "Remove files in the path", noRemote: true}, {name: "deletefile", title: "Remove the single file pointed to"}, {name: "copyurl", title: "Copy the URL to the object", help: "- url - string, URL to read from\n - autoFilename - boolean, set to true to retrieve destination file name from url\n"}, {name: "uploadfile", title: "Upload file using multiform/form-data", help: "- each part in body represents a file to be uploaded\n", needsRequest: true}, {name: "cleanup", title: "Remove trashed files in the remote or path", noRemote: true}, {name: "settier", title: "Changes storage tier or class on all files in the path", noRemote: true}, {name: "settierfile", title: "Changes storage tier or class on the single file pointed to"}, } { op := op remote := "- remote - a path within that remote e.g. \"dir\"\n" if op.noRemote { remote = "" } rc.Add(rc.Call{ Path: "operations/" + op.name, AuthRequired: true, NeedsRequest: op.needsRequest, Fn: func(ctx context.Context, in rc.Params) (rc.Params, error) { return rcSingleCommand(ctx, in, op.name, op.noRemote) }, Title: op.title, Help: `This takes the following parameters: - fs - a remote name string e.g. "drive:" ` + remote + op.help + ` See the [` + op.name + `](/commands/rclone_` + op.name + `/) command for more information on the above. `, }) } } // Run a single command, e.g. Mkdir func rcSingleCommand(ctx context.Context, in rc.Params, name string, noRemote bool) (out rc.Params, err error) { var ( f fs.Fs remote string ) if noRemote { f, err = rc.GetFs(ctx, in) } else { f, remote, err = rc.GetFsAndRemote(ctx, in) } if err != nil { return nil, err } switch name { case "mkdir": return nil, Mkdir(ctx, f, remote) case "rmdir": return nil, Rmdir(ctx, f, remote) case "purge": return nil, Purge(ctx, f, remote) case "rmdirs": leaveRoot, err := in.GetBool("leaveRoot") if rc.NotErrParamNotFound(err) { return nil, err } return nil, Rmdirs(ctx, f, remote, leaveRoot) case "delete": return nil, Delete(ctx, f) case "deletefile": o, err := f.NewObject(ctx, remote) if err != nil { return nil, err } return nil, DeleteFile(ctx, o) case "copyurl": url, err := in.GetString("url") if err != nil { return nil, err } autoFilename, _ := in.GetBool("autoFilename") noClobber, _ := in.GetBool("noClobber") headerFilename, _ := in.GetBool("headerFilename") _, err = CopyURL(ctx, f, remote, url, autoFilename, headerFilename, noClobber) return nil, err case "uploadfile": var request *http.Request request, err := in.GetHTTPRequest() if err != nil { return nil, err } contentType := request.Header.Get("Content-Type") mediaType, params, err := mime.ParseMediaType(contentType) if err != nil { return nil, err } if strings.HasPrefix(mediaType, "multipart/") { mr := multipart.NewReader(request.Body, params["boundary"]) for { p, err := mr.NextPart() if err == io.EOF { return nil, nil } if err != nil { return nil, err } if p.FileName() != "" { obj, err := Rcat(ctx, f, path.Join(remote, p.FileName()), p, time.Now(), nil) if err != nil { return nil, err } fs.Debugf(obj, "Upload Succeeded") } } } return nil, nil case "cleanup": return nil, CleanUp(ctx, f) case "settier": if !f.Features().SetTier { return nil, fmt.Errorf("remote %s does not support settier", f.Name()) } tier, err := in.GetString("tier") if err != nil { return nil, err } return nil, SetTier(ctx, f, tier) case "settierfile": if !f.Features().SetTier { return nil, fmt.Errorf("remote %s does not support settier", f.Name()) } tier, err := in.GetString("tier") if err != nil { return nil, err } o, err := f.NewObject(ctx, remote) if err != nil { return nil, err } return nil, SetTierFile(ctx, o, tier) } panic("unknown rcSingleCommand type") } func init() { rc.Add(rc.Call{ Path: "operations/size", AuthRequired: true, Fn: rcSize, Title: "Count the number of bytes and files in remote", Help: `This takes the following parameters: - fs - a remote name string e.g. "drive:path/to/dir" Returns: - count - number of files - bytes - number of bytes in those files See the [size](/commands/rclone_size/) command for more information on the above. `, }) } // Size a directory func rcSize(ctx context.Context, in rc.Params) (out rc.Params, err error) { f, err := rc.GetFs(ctx, in) if err != nil { return nil, err } count, bytes, sizeless, err := Count(ctx, f) if err != nil { return nil, err } out = make(rc.Params) out["count"] = count out["bytes"] = bytes out["sizeless"] = sizeless return out, nil } func init() { rc.Add(rc.Call{ Path: "operations/publiclink", AuthRequired: true, Fn: rcPublicLink, Title: "Create or retrieve a public link to the given file or folder.", Help: `This takes the following parameters: - fs - a remote name string e.g. "drive:" - remote - a path within that remote e.g. "dir" - unlink - boolean - if set removes the link rather than adding it (optional) - expire - string - the expiry time of the link e.g. "1d" (optional) Returns: - url - URL of the resource See the [link](/commands/rclone_link/) command for more information on the above. `, }) } // Make a public link func rcPublicLink(ctx context.Context, in rc.Params) (out rc.Params, err error) { f, remote, err := rc.GetFsAndRemote(ctx, in) if err != nil { return nil, err } unlink, _ := in.GetBool("unlink") expire, err := in.GetDuration("expire") if rc.IsErrParamNotFound(err) { expire = time.Duration(fs.DurationOff) } else if err != nil { return nil, err } url, err := PublicLink(ctx, f, remote, fs.Duration(expire), unlink) if err != nil { return nil, err } out = make(rc.Params) out["url"] = url return out, nil } func init() { rc.Add(rc.Call{ Path: "operations/fsinfo", Fn: rcFsInfo, Title: "Return information about the remote", Help: `This takes the following parameters: - fs - a remote name string e.g. "drive:" This returns info about the remote passed in; ` + "```" + ` { // optional features and whether they are available or not "Features": { "About": true, "BucketBased": false, "BucketBasedRootOK": false, "CanHaveEmptyDirectories": true, "CaseInsensitive": false, "ChangeNotify": false, "CleanUp": false, "Command": true, "Copy": false, "DirCacheFlush": false, "DirMove": true, "Disconnect": false, "DuplicateFiles": false, "GetTier": false, "IsLocal": true, "ListR": false, "MergeDirs": false, "MetadataInfo": true, "Move": true, "OpenWriterAt": true, "PublicLink": false, "Purge": true, "PutStream": true, "PutUnchecked": false, "ReadMetadata": true, "ReadMimeType": false, "ServerSideAcrossConfigs": false, "SetTier": false, "SetWrapper": false, "Shutdown": false, "SlowHash": true, "SlowModTime": false, "UnWrap": false, "UserInfo": false, "UserMetadata": true, "WrapFs": false, "WriteMetadata": true, "WriteMimeType": false }, // Names of hashes available "Hashes": [ "md5", "sha1", "whirlpool", "crc32", "sha256", "dropbox", "mailru", "quickxor" ], "Name": "local", // Name as created "Precision": 1, // Precision of timestamps in ns "Root": "/", // Path as created "String": "Local file system at /", // how the remote will appear in logs // Information about the system metadata for this backend "MetadataInfo": { "System": { "atime": { "Help": "Time of last access", "Type": "RFC 3339", "Example": "2006-01-02T15:04:05.999999999Z07:00" }, "btime": { "Help": "Time of file birth (creation)", "Type": "RFC 3339", "Example": "2006-01-02T15:04:05.999999999Z07:00" }, "gid": { "Help": "Group ID of owner", "Type": "decimal number", "Example": "500" }, "mode": { "Help": "File type and mode", "Type": "octal, unix style", "Example": "0100664" }, "mtime": { "Help": "Time of last modification", "Type": "RFC 3339", "Example": "2006-01-02T15:04:05.999999999Z07:00" }, "rdev": { "Help": "Device ID (if special file)", "Type": "hexadecimal", "Example": "1abc" }, "uid": { "Help": "User ID of owner", "Type": "decimal number", "Example": "500" } }, "Help": "Textual help string\n" } } ` + "```" + ` This command does not have a command line equivalent so use this instead: rclone rc --loopback operations/fsinfo fs=remote: `, }) } // Fsinfo the remote func rcFsInfo(ctx context.Context, in rc.Params) (out rc.Params, err error) { f, err := rc.GetFs(ctx, in) if err != nil { return nil, err } info := GetFsInfo(f) err = rc.Reshape(&out, info) if err != nil { return nil, fmt.Errorf("fsinfo Reshape failed: %w", err) } return out, nil } func init() { rc.Add(rc.Call{ Path: "backend/command", AuthRequired: true, Fn: rcBackend, Title: "Runs a backend command.", Help: `This takes the following parameters: - command - a string with the command name - fs - a remote name string e.g. "drive:" - arg - a list of arguments for the backend command - opt - a map of string to string of options Returns: - result - result from the backend command Example: rclone rc backend/command command=noop fs=. -o echo=yes -o blue -a path1 -a path2 Returns ` + "```" + ` { "result": { "arg": [ "path1", "path2" ], "name": "noop", "opt": { "blue": "", "echo": "yes" } } } ` + "```" + ` Note that this is the direct equivalent of using this "backend" command: rclone backend noop . -o echo=yes -o blue path1 path2 Note that arguments must be preceded by the "-a" flag See the [backend](/commands/rclone_backend/) command for more information. `, }) } // Make a public link func rcBackend(ctx context.Context, in rc.Params) (out rc.Params, err error) { f, err := rc.GetFs(ctx, in) if err != nil { return nil, err } doCommand := f.Features().Command if doCommand == nil { return nil, fmt.Errorf("%v: doesn't support backend commands", f) } command, err := in.GetString("command") if err != nil { return nil, err } opt := map[string]string{} err = in.GetStructMissingOK("opt", &opt) if err != nil { return nil, err } arg := []string{} err = in.GetStructMissingOK("arg", &arg) if err != nil { return nil, err } result, err := doCommand(ctx, command, arg, opt) if err != nil { return nil, fmt.Errorf("command %q failed: %w", command, err) } out = make(rc.Params) out["result"] = result return out, nil } // This should really be in fs/rc/internal.go but can't go there due // to a circular dependency on config. func init() { rc.Add(rc.Call{ Path: "core/du", Fn: rcDu, Title: "Returns disk usage of a locally attached disk.", Help: ` This returns the disk usage for the local directory passed in as dir. If the directory is not passed in, it defaults to the directory pointed to by --cache-dir. - dir - string (optional) Returns: ` + "```" + ` { "dir": "/", "info": { "Available": 361769115648, "Free": 361785892864, "Total": 982141468672 } } ` + "```" + ` `, }) } // Terminates app func rcDu(ctx context.Context, in rc.Params) (out rc.Params, err error) { dir, err := in.GetString("dir") if rc.IsErrParamNotFound(err) { dir = config.GetCacheDir() } else if err != nil { return nil, err } info, err := diskusage.New(dir) if err != nil { return nil, err } out = rc.Params{ "dir": dir, "info": info, } return out, nil } func init() { rc.Add(rc.Call{ Path: "operations/check", AuthRequired: true, Fn: rcCheck, Title: "check the source and destination are the same", Help: `Checks the files in the source and destination match. It compares sizes and hashes and logs a report of files that don't match. It doesn't alter the source or destination. This takes the following parameters: - srcFs - a remote name string e.g. "drive:" for the source, "/" for local filesystem - dstFs - a remote name string e.g. "drive2:" for the destination, "/" for local filesystem - download - check by downloading rather than with hash - checkFileHash - treat checkFileFs:checkFileRemote as a SUM file with hashes of given type - checkFileFs - treat checkFileFs:checkFileRemote as a SUM file with hashes of given type - checkFileRemote - treat checkFileFs:checkFileRemote as a SUM file with hashes of given type - oneWay - check one way only, source files must exist on remote - combined - make a combined report of changes (default false) - missingOnSrc - report all files missing from the source (default true) - missingOnDst - report all files missing from the destination (default true) - match - report all matching files (default false) - differ - report all non-matching files (default true) - error - report all files with errors (hashing or reading) (default true) If you supply the download flag, it will download the data from both remotes and check them against each other on the fly. This can be useful for remotes that don't support hashes or if you really want to check all the data. If you supply the size-only global flag, it will only compare the sizes not the hashes as well. Use this for a quick check. If you supply the checkFileHash option with a valid hash name, the checkFileFs:checkFileRemote must point to a text file in the SUM format. This treats the checksum file as the source and dstFs as the destination. Note that srcFs is not used and should not be supplied in this case. Returns: - success - true if no error, false otherwise - status - textual summary of check, OK or text string - hashType - hash used in check, may be missing - combined - array of strings of combined report of changes - missingOnSrc - array of strings of all files missing from the source - missingOnDst - array of strings of all files missing from the destination - match - array of strings of all matching files - differ - array of strings of all non-matching files - error - array of strings of all files with errors (hashing or reading) `, }) } // Writer which writes into the slice provided type stringWriter struct { out *[]string } // Write writes len(p) bytes from p to the underlying data stream. It returns // the number of bytes written from p (0 <= n <= len(p)) and any error // encountered that caused the write to stop early. Write must return a non-nil // error if it returns n < len(p). Write must not modify the slice data, // even temporarily. // // Implementations must not retain p. func (s stringWriter) Write(p []byte) (n int, err error) { result := string(p) result = strings.TrimSuffix(result, "\n") *s.out = append(*s.out, result) return len(p), nil } // Check two directories func rcCheck(ctx context.Context, in rc.Params) (out rc.Params, err error) { srcFs, err := rc.GetFsNamed(ctx, in, "srcFs") if err != nil && !rc.IsErrParamNotFound(err) { return nil, err } dstFs, err := rc.GetFsNamed(ctx, in, "dstFs") if err != nil { return nil, err } checkFileFs, checkFileRemote, err := rc.GetFsAndRemoteNamed(ctx, in, "checkFileFs", "checkFileRemote") if err != nil && !rc.IsErrParamNotFound(err) { return nil, err } checkFileHash, err := in.GetString("checkFileHash") if err != nil && !rc.IsErrParamNotFound(err) { return nil, err } checkFileSet := 0 if checkFileHash != "" { checkFileSet++ } if checkFileFs != nil { checkFileSet++ } if checkFileRemote != "" { checkFileSet++ } if checkFileSet > 0 && checkFileSet < 3 { return nil, fmt.Errorf("need all of checkFileFs, checkFileRemote, checkFileHash to be set together") } var checkFileHashType hash.Type if checkFileHash != "" { if err := checkFileHashType.Set(checkFileHash); err != nil { return nil, err } if srcFs != nil { return nil, rc.NewErrParamInvalid(errors.New("only supply dstFs when using checkFileHash")) } } else if srcFs == nil { return nil, rc.NewErrParamInvalid(errors.New("need srcFs parameter when not using checkFileHash")) } oneway, _ := in.GetBool("oneWay") download, _ := in.GetBool("download") opt := &CheckOpt{ Fsrc: srcFs, Fdst: dstFs, OneWay: oneway, } out = rc.Params{} getOutput := func(name string, Default bool) io.Writer { active, err := in.GetBool(name) if err != nil { active = Default } if !active { return nil } result := []string{} out[name] = &result return stringWriter{&result} } opt.Combined = getOutput("combined", false) opt.MissingOnSrc = getOutput("missingOnSrc", true) opt.MissingOnDst = getOutput("missingOnDst", true) opt.Match = getOutput("match", false) opt.Differ = getOutput("differ", true) opt.Error = getOutput("error", true) if checkFileHash != "" { out["hashType"] = checkFileHashType.String() err = CheckSum(ctx, dstFs, checkFileFs, checkFileRemote, checkFileHashType, opt, download) } else { if download { err = CheckDownload(ctx, opt) } else { out["hashType"] = srcFs.Hashes().Overlap(dstFs.Hashes()).GetOne().String() err = Check(ctx, opt) } } if err != nil { out["status"] = err.Error() out["success"] = false } else { out["status"] = "OK" out["success"] = true } return out, nil } func init() { rc.Add(rc.Call{ Path: "operations/hashsum", AuthRequired: true, Fn: rcHashsum, Title: "Produces a hashsum file for all the objects in the path.", Help: `Produces a hash file for all the objects in the path using the hash named. The output is in the same format as the standard md5sum/sha1sum tool. This takes the following parameters: - fs - a remote name string e.g. "drive:" for the source, "/" for local filesystem - this can point to a file and just that file will be returned in the listing. - hashType - type of hash to be used - download - check by downloading rather than with hash (boolean) - base64 - output the hashes in base64 rather than hex (boolean) If you supply the download flag, it will download the data from the remote and create the hash on the fly. This can be useful for remotes that don't support the given hash or if you really want to check all the data. Note that if you wish to supply a checkfile to check hashes against the current files then you should use operations/check instead of operations/hashsum. Returns: - hashsum - array of strings of the hashes - hashType - type of hash used Example: $ rclone rc --loopback operations/hashsum fs=bin hashType=MD5 download=true base64=true { "hashType": "md5", "hashsum": [ "WTSVLpuiXyJO_kGzJerRLg== backend-versions.sh", "v1b_OlWCJO9LtNq3EIKkNQ== bisect-go-rclone.sh", "VHbmHzHh4taXzgag8BAIKQ== bisect-rclone.sh", ] } See the [hashsum](/commands/rclone_hashsum/) command for more information on the above. `, }) } // Hashsum a directory func rcHashsum(ctx context.Context, in rc.Params) (out rc.Params, err error) { ctx, f, err := rc.GetFsNamedFileOK(ctx, in, "fs") if err != nil { return nil, err } download, _ := in.GetBool("download") base64, _ := in.GetBool("base64") hashType, err := in.GetString("hashType") if err != nil { return nil, fmt.Errorf("%s\n%w", hash.HelpString(0), err) } var ht hash.Type err = ht.Set(hashType) if err != nil { return nil, fmt.Errorf("%s\n%w", hash.HelpString(0), err) } hashes := []string{} err = HashLister(ctx, ht, base64, download, f, stringWriter{&hashes}) out = rc.Params{ "hashType": ht.String(), "hashsum": hashes, } return out, err } rclone-v1.71.0/fs/operations/rc_test.go000066400000000000000000000613121505210326400200360ustar00rootroot00000000000000package operations_test import ( "context" "fmt" "net/http" "net/http/httptest" "net/url" "os" "path" "sort" "strings" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fs/rc" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/lib/diskusage" "github.com/rclone/rclone/lib/rest" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func rcNewRun(t *testing.T, method string) (*fstest.Run, *rc.Call) { if *fstest.RemoteName != "" { t.Skip("Skipping test on non local remote") } r := fstest.NewRun(t) call := rc.Calls.Get(method) assert.NotNil(t, call) cache.Put(r.LocalName, r.Flocal) cache.Put(r.FremoteName, r.Fremote) return r, call } // operations/about: Return the space used on the remote func TestRcAbout(t *testing.T) { r, call := rcNewRun(t, "operations/about") r.Mkdir(context.Background(), r.Fremote) // Will get an error if remote doesn't support About expectedErr := r.Fremote.Features().About == nil in := rc.Params{ "fs": r.FremoteName, } out, err := call.Fn(context.Background(), in) if expectedErr { assert.Error(t, err) return } require.NoError(t, err) // Can't really check the output much! assert.NotEqual(t, int64(0), out["Total"]) } // operations/cleanup: Remove trashed files in the remote or path func TestRcCleanup(t *testing.T) { r, call := rcNewRun(t, "operations/cleanup") in := rc.Params{ "fs": r.LocalName, } out, err := call.Fn(context.Background(), in) require.Error(t, err) assert.Equal(t, rc.Params(nil), out) assert.Contains(t, err.Error(), "doesn't support cleanup") } // operations/copyfile: Copy a file from source remote to destination remote func TestRcCopyfile(t *testing.T) { r, call := rcNewRun(t, "operations/copyfile") file1 := r.WriteFile("file1", "file1 contents", t1) r.Mkdir(context.Background(), r.Fremote) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t) in := rc.Params{ "srcFs": r.LocalName, "srcRemote": "file1", "dstFs": r.FremoteName, "dstRemote": "file1-renamed", } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) r.CheckLocalItems(t, file1) file1.Path = "file1-renamed" r.CheckRemoteItems(t, file1) } // operations/copyurl: Copy the URL to the object func TestRcCopyurl(t *testing.T) { r, call := rcNewRun(t, "operations/copyurl") contents := "file1 contents\n" file1 := r.WriteFile("file1", contents, t1) r.Mkdir(context.Background(), r.Fremote) r.CheckRemoteItems(t) ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _, err := w.Write([]byte(contents)) assert.NoError(t, err) })) defer ts.Close() in := rc.Params{ "fs": r.FremoteName, "remote": "file1", "url": ts.URL, "autoFilename": false, "noClobber": false, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) in = rc.Params{ "fs": r.FremoteName, "remote": "file1", "url": ts.URL, "autoFilename": false, "noClobber": true, } out, err = call.Fn(context.Background(), in) require.Error(t, err) assert.Equal(t, rc.Params(nil), out) urlFileName := "filename.txt" in = rc.Params{ "fs": r.FremoteName, "remote": "", "url": ts.URL + "/" + urlFileName, "autoFilename": true, "noClobber": false, } out, err = call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) in = rc.Params{ "fs": r.FremoteName, "remote": "", "url": ts.URL, "autoFilename": true, "noClobber": false, } out, err = call.Fn(context.Background(), in) require.Error(t, err) assert.Equal(t, rc.Params(nil), out) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{file1, fstest.NewItem(urlFileName, contents, t1)}, nil, fs.ModTimeNotSupported) } // operations/delete: Remove files in the path func TestRcDelete(t *testing.T) { r, call := rcNewRun(t, "operations/delete") file1 := r.WriteObject(context.Background(), "small", "1234567890", t2) // 10 bytes file2 := r.WriteObject(context.Background(), "medium", "------------------------------------------------------------", t1) // 60 bytes file3 := r.WriteObject(context.Background(), "large", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", t1) // 100 bytes r.CheckRemoteItems(t, file1, file2, file3) in := rc.Params{ "fs": r.FremoteName, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) r.CheckRemoteItems(t) } // operations/deletefile: Remove the single file pointed to func TestRcDeletefile(t *testing.T) { r, call := rcNewRun(t, "operations/deletefile") file1 := r.WriteObject(context.Background(), "small", "1234567890", t2) // 10 bytes file2 := r.WriteObject(context.Background(), "medium", "------------------------------------------------------------", t1) // 60 bytes r.CheckRemoteItems(t, file1, file2) in := rc.Params{ "fs": r.FremoteName, "remote": "small", } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) r.CheckRemoteItems(t, file2) } // operations/list: List the given remote and path in JSON format. func TestRcList(t *testing.T) { r, call := rcNewRun(t, "operations/list") file1 := r.WriteObject(context.Background(), "a", "a", t1) file2 := r.WriteObject(context.Background(), "subdir/b", "bb", t2) r.CheckRemoteItems(t, file1, file2) in := rc.Params{ "fs": r.FremoteName, "remote": "", } out, err := call.Fn(context.Background(), in) require.NoError(t, err) list := out["list"].([]*operations.ListJSONItem) assert.Equal(t, 2, len(list)) checkFile1 := func(got *operations.ListJSONItem) { assert.WithinDuration(t, t1, got.ModTime.When, time.Second) assert.Equal(t, "a", got.Path) assert.Equal(t, "a", got.Name) assert.Equal(t, int64(1), got.Size) assert.Equal(t, "application/octet-stream", got.MimeType) assert.Equal(t, false, got.IsDir) } checkFile1(list[0]) checkSubdir := func(got *operations.ListJSONItem) { assert.Equal(t, "subdir", got.Path) assert.Equal(t, "subdir", got.Name) // assert.Equal(t, int64(-1), got.Size) // size can vary for directories assert.Equal(t, "inode/directory", got.MimeType) assert.Equal(t, true, got.IsDir) } checkSubdir(list[1]) in = rc.Params{ "fs": r.FremoteName, "remote": "", "opt": rc.Params{ "recurse": true, }, } out, err = call.Fn(context.Background(), in) require.NoError(t, err) list = out["list"].([]*operations.ListJSONItem) assert.Equal(t, 3, len(list)) checkFile1(list[0]) checkSubdir(list[1]) checkFile2 := func(got *operations.ListJSONItem) { assert.WithinDuration(t, t2, got.ModTime.When, time.Second) assert.Equal(t, "subdir/b", got.Path) assert.Equal(t, "b", got.Name) assert.Equal(t, int64(2), got.Size) assert.Equal(t, "application/octet-stream", got.MimeType) assert.Equal(t, false, got.IsDir) } checkFile2(list[2]) } // operations/stat: Stat the given remote and path in JSON format. func TestRcStat(t *testing.T) { r, call := rcNewRun(t, "operations/stat") file1 := r.WriteObject(context.Background(), "subdir/a", "a", t1) r.CheckRemoteItems(t, file1) fetch := func(t *testing.T, remotePath string) *operations.ListJSONItem { in := rc.Params{ "fs": r.FremoteName, "remote": remotePath, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) return out["item"].(*operations.ListJSONItem) } t.Run("Root", func(t *testing.T) { stat := fetch(t, "") assert.Equal(t, "", stat.Path) assert.Equal(t, "", stat.Name) assert.Equal(t, int64(-1), stat.Size) assert.Equal(t, "inode/directory", stat.MimeType) assert.Equal(t, true, stat.IsDir) }) t.Run("File", func(t *testing.T) { stat := fetch(t, "subdir/a") assert.WithinDuration(t, t1, stat.ModTime.When, time.Second) assert.Equal(t, "subdir/a", stat.Path) assert.Equal(t, "a", stat.Name) assert.Equal(t, int64(1), stat.Size) assert.Equal(t, "application/octet-stream", stat.MimeType) assert.Equal(t, false, stat.IsDir) }) t.Run("Subdir", func(t *testing.T) { stat := fetch(t, "subdir") assert.Equal(t, "subdir", stat.Path) assert.Equal(t, "subdir", stat.Name) // assert.Equal(t, int64(-1), stat.Size) // size can vary for directories assert.Equal(t, "inode/directory", stat.MimeType) assert.Equal(t, true, stat.IsDir) }) t.Run("NotFound", func(t *testing.T) { stat := fetch(t, "notfound") assert.Nil(t, stat) }) } // operations/settier: Set the storage tier of a fs func TestRcSetTier(t *testing.T) { ctx := context.Background() r, call := rcNewRun(t, "operations/settier") if !r.Fremote.Features().SetTier { t.Skip("settier not supported") } file1 := r.WriteObject(context.Background(), "file1", "file1 contents", t1) r.CheckRemoteItems(t, file1) // Because we don't know what the current tier options here are, let's // just get the current tier, and reuse that o, err := r.Fremote.NewObject(ctx, file1.Path) require.NoError(t, err) trr, ok := o.(fs.GetTierer) require.True(t, ok) ctier := trr.GetTier() in := rc.Params{ "fs": r.FremoteName, "tier": ctier, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) } // operations/settier: Set the storage tier of a file func TestRcSetTierFile(t *testing.T) { ctx := context.Background() r, call := rcNewRun(t, "operations/settierfile") if !r.Fremote.Features().SetTier { t.Skip("settier not supported") } file1 := r.WriteObject(context.Background(), "file1", "file1 contents", t1) r.CheckRemoteItems(t, file1) // Because we don't know what the current tier options here are, let's // just get the current tier, and reuse that o, err := r.Fremote.NewObject(ctx, file1.Path) require.NoError(t, err) trr, ok := o.(fs.GetTierer) require.True(t, ok) ctier := trr.GetTier() in := rc.Params{ "fs": r.FremoteName, "remote": "file1", "tier": ctier, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) } // operations/mkdir: Make a destination directory or container func TestRcMkdir(t *testing.T) { ctx := context.Background() r, call := rcNewRun(t, "operations/mkdir") r.Mkdir(context.Background(), r.Fremote) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{}, []string{}, fs.GetModifyWindow(ctx, r.Fremote)) in := rc.Params{ "fs": r.FremoteName, "remote": "subdir", } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{}, []string{"subdir"}, fs.GetModifyWindow(ctx, r.Fremote)) } // operations/movefile: Move a file from source remote to destination remote func TestRcMovefile(t *testing.T) { r, call := rcNewRun(t, "operations/movefile") file1 := r.WriteFile("file1", "file1 contents", t1) r.Mkdir(context.Background(), r.Fremote) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t) in := rc.Params{ "srcFs": r.LocalName, "srcRemote": "file1", "dstFs": r.FremoteName, "dstRemote": "file1-renamed", } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) r.CheckLocalItems(t) file1.Path = "file1-renamed" r.CheckRemoteItems(t, file1) } // operations/purge: Remove a directory or container and all of its contents func TestRcPurge(t *testing.T) { ctx := context.Background() r, call := rcNewRun(t, "operations/purge") file1 := r.WriteObject(context.Background(), "subdir/file1", "subdir/file1 contents", t1) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{file1}, []string{"subdir"}, fs.GetModifyWindow(ctx, r.Fremote)) in := rc.Params{ "fs": r.FremoteName, "remote": "subdir", } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{}, []string{}, fs.GetModifyWindow(ctx, r.Fremote)) } // operations/rmdir: Remove an empty directory or container func TestRcRmdir(t *testing.T) { ctx := context.Background() r, call := rcNewRun(t, "operations/rmdir") r.Mkdir(context.Background(), r.Fremote) assert.NoError(t, r.Fremote.Mkdir(context.Background(), "subdir")) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{}, []string{"subdir"}, fs.GetModifyWindow(ctx, r.Fremote)) in := rc.Params{ "fs": r.FremoteName, "remote": "subdir", } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{}, []string{}, fs.GetModifyWindow(ctx, r.Fremote)) } // operations/rmdirs: Remove all the empty directories in the path func TestRcRmdirs(t *testing.T) { ctx := context.Background() r, call := rcNewRun(t, "operations/rmdirs") r.Mkdir(context.Background(), r.Fremote) assert.NoError(t, r.Fremote.Mkdir(context.Background(), "subdir")) assert.NoError(t, r.Fremote.Mkdir(context.Background(), "subdir/subsubdir")) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{}, []string{"subdir", "subdir/subsubdir"}, fs.GetModifyWindow(ctx, r.Fremote)) in := rc.Params{ "fs": r.FremoteName, "remote": "subdir", } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{}, []string{}, fs.GetModifyWindow(ctx, r.Fremote)) assert.NoError(t, r.Fremote.Mkdir(context.Background(), "subdir")) assert.NoError(t, r.Fremote.Mkdir(context.Background(), "subdir/subsubdir")) in = rc.Params{ "fs": r.FremoteName, "remote": "subdir", "leaveRoot": true, } out, err = call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{}, []string{"subdir"}, fs.GetModifyWindow(ctx, r.Fremote)) } // operations/size: Count the number of bytes and files in remote func TestRcSize(t *testing.T) { r, call := rcNewRun(t, "operations/size") file1 := r.WriteObject(context.Background(), "small", "1234567890", t2) // 10 bytes file2 := r.WriteObject(context.Background(), "subdir/medium", "------------------------------------------------------------", t1) // 60 bytes file3 := r.WriteObject(context.Background(), "subdir/subsubdir/large", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", t1) // 50 bytes r.CheckRemoteItems(t, file1, file2, file3) in := rc.Params{ "fs": r.FremoteName, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params{ "count": int64(3), "bytes": int64(120), "sizeless": int64(0), }, out) } // operations/publiclink: Create or retrieve a public link to the given file or folder. func TestRcPublicLink(t *testing.T) { r, call := rcNewRun(t, "operations/publiclink") in := rc.Params{ "fs": r.FremoteName, "remote": "", "expire": "5m", "unlink": false, } _, err := call.Fn(context.Background(), in) require.Error(t, err) assert.Contains(t, err.Error(), "doesn't support public links") } // operations/fsinfo: Return information about the remote func TestRcFsInfo(t *testing.T) { r, call := rcNewRun(t, "operations/fsinfo") in := rc.Params{ "fs": r.FremoteName, } got, err := call.Fn(context.Background(), in) require.NoError(t, err) want := operations.GetFsInfo(r.Fremote) assert.Equal(t, want.Name, got["Name"]) assert.Equal(t, want.Root, got["Root"]) assert.Equal(t, want.String, got["String"]) assert.Equal(t, float64(want.Precision), got["Precision"]) var hashes []any for _, hash := range want.Hashes { hashes = append(hashes, hash) } assert.Equal(t, hashes, got["Hashes"]) var features = map[string]any{} for k, v := range want.Features { features[k] = v } assert.Equal(t, features, got["Features"]) } // operations/uploadfile : Tests if upload file succeeds func TestUploadFile(t *testing.T) { r, call := rcNewRun(t, "operations/uploadfile") ctx := context.Background() testFileName := "uploadfile-test.txt" testFileContent := "Hello World" r.WriteFile(testFileName, testFileContent, t1) testItem1 := fstest.NewItem(testFileName, testFileContent, t1) testItem2 := fstest.NewItem(path.Join("subdir", testFileName), testFileContent, t1) currentFile, err := os.Open(path.Join(r.LocalName, testFileName)) require.NoError(t, err) defer func() { assert.NoError(t, currentFile.Close()) }() formReader, contentType, _, err := rest.MultipartUpload(ctx, currentFile, url.Values{}, "file", testFileName) require.NoError(t, err) httpReq := httptest.NewRequest("POST", "/", formReader) httpReq.Header.Add("Content-Type", contentType) in := rc.Params{ "_request": httpReq, "fs": r.FremoteName, "remote": "", } _, err = call.Fn(context.Background(), in) require.NoError(t, err) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{testItem1}, nil, fs.ModTimeNotSupported) assert.NoError(t, r.Fremote.Mkdir(context.Background(), "subdir")) currentFile2, err := os.Open(path.Join(r.LocalName, testFileName)) require.NoError(t, err) defer func() { assert.NoError(t, currentFile2.Close()) }() formReader, contentType, _, err = rest.MultipartUpload(ctx, currentFile2, url.Values{}, "file", testFileName) require.NoError(t, err) httpReq = httptest.NewRequest("POST", "/", formReader) httpReq.Header.Add("Content-Type", contentType) in = rc.Params{ "_request": httpReq, "fs": r.FremoteName, "remote": "subdir", } _, err = call.Fn(context.Background(), in) require.NoError(t, err) fstest.CheckListingWithPrecision(t, r.Fremote, []fstest.Item{testItem1, testItem2}, nil, fs.ModTimeNotSupported) } // operations/command: Runs a backend command func TestRcCommand(t *testing.T) { r, call := rcNewRun(t, "backend/command") in := rc.Params{ "fs": r.FremoteName, "command": "noop", "opt": map[string]string{ "echo": "true", "blue": "", }, "arg": []string{ "path1", "path2", }, } got, err := call.Fn(context.Background(), in) if err != nil { assert.False(t, r.Fremote.Features().IsLocal, "mustn't fail on local remote") assert.Contains(t, err.Error(), "command not found") return } want := rc.Params{"result": map[string]any{ "arg": []string{ "path1", "path2", }, "name": "noop", "opt": map[string]string{ "blue": "", "echo": "true", }, }} assert.Equal(t, want, got) errTxt := "explosion in the sausage factory" in["opt"].(map[string]string)["error"] = errTxt _, err = call.Fn(context.Background(), in) assert.Error(t, err) assert.Contains(t, err.Error(), errTxt) } // operations/command: Runs a backend command func TestRcDu(t *testing.T) { ctx := context.Background() _, call := rcNewRun(t, "core/du") in := rc.Params{} out, err := call.Fn(ctx, in) if err == diskusage.ErrUnsupported { t.Skip(err) } assert.NotEqual(t, "", out["dir"]) info := out["info"].(diskusage.Info) assert.True(t, info.Total != 0) assert.True(t, info.Total > info.Free) assert.True(t, info.Total > info.Available) assert.True(t, info.Free >= info.Available) } // operations/check: check the source and destination are the same func TestRcCheck(t *testing.T) { ctx := context.Background() r, call := rcNewRun(t, "operations/check") r.Mkdir(ctx, r.Fremote) MD5SUMS := ` 0ef726ce9b1a7692357ff70dd321d595 file1 deadbeefcafe00000000000000000000 subdir/file2 0386a8b8fcf672c326845c00ba41b9e2 subdir/subsubdir/file4 ` file1 := r.WriteBoth(ctx, "file1", "file1 contents", t1) file2 := r.WriteFile("subdir/file2", MD5SUMS, t2) file3 := r.WriteObject(ctx, "subdir/subsubdir/file3", "file3 contents", t3) file4a := r.WriteFile("subdir/subsubdir/file4", "file4 contents", t3) file4b := r.WriteObject(ctx, "subdir/subsubdir/file4", "file4 different contents", t3) // operations.HashLister(ctx, hash.MD5, false, false, r.Fremote, os.Stdout) r.CheckLocalItems(t, file1, file2, file4a) r.CheckRemoteItems(t, file1, file3, file4b) pstring := func(items ...fstest.Item) *[]string { xs := make([]string, len(items)) for i, item := range items { xs[i] = item.Path } return &xs } for _, testName := range []string{"Normal", "Download"} { t.Run(testName, func(t *testing.T) { in := rc.Params{ "srcFs": r.LocalName, "dstFs": r.FremoteName, "combined": true, "missingOnSrc": true, "missingOnDst": true, "match": true, "differ": true, "error": true, } if testName == "Download" { in["download"] = true } out, err := call.Fn(ctx, in) require.NoError(t, err) combined := []string{ "= " + file1.Path, "+ " + file2.Path, "- " + file3.Path, "* " + file4a.Path, } sort.Strings(combined) sort.Strings(*out["combined"].(*[]string)) want := rc.Params{ "missingOnSrc": pstring(file3), "missingOnDst": pstring(file2), "differ": pstring(file4a), "error": pstring(), "match": pstring(file1), "combined": &combined, "status": "3 differences found", "success": false, } if testName == "Normal" { want["hashType"] = "md5" } assert.Equal(t, want, out) }) } t.Run("CheckFile", func(t *testing.T) { // The checksum file is treated as the source and srcFs is not used in := rc.Params{ "dstFs": r.FremoteName, "combined": true, "missingOnSrc": true, "missingOnDst": true, "match": true, "differ": true, "error": true, "checkFileFs": r.LocalName, "checkFileRemote": file2.Path, "checkFileHash": "md5", } out, err := call.Fn(ctx, in) require.NoError(t, err) combined := []string{ "= " + file1.Path, "+ " + file2.Path, "- " + file3.Path, "* " + file4a.Path, } sort.Strings(combined) sort.Strings(*out["combined"].(*[]string)) if strings.HasPrefix(out["status"].(string), "file not in") { out["status"] = "file not in" } want := rc.Params{ "missingOnSrc": pstring(file3), "missingOnDst": pstring(file2), "differ": pstring(file4a), "error": pstring(), "match": pstring(file1), "combined": &combined, "hashType": "md5", "status": "file not in", "success": false, } assert.Equal(t, want, out) }) } // operations/hashsum: hashsum a directory func TestRcHashsum(t *testing.T) { ctx := context.Background() r, call := rcNewRun(t, "operations/hashsum") r.Mkdir(ctx, r.Fremote) file1Contents := "file1 contents" file1 := r.WriteBoth(ctx, "hashsum-file1", file1Contents, t1) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file1) hasher := hash.NewMultiHasher() _, err := hasher.Write([]byte(file1Contents)) require.NoError(t, err) for _, test := range []struct { ht hash.Type base64 bool download bool }{ { ht: r.Fremote.Hashes().GetOne(), }, { ht: r.Fremote.Hashes().GetOne(), base64: true, }, { ht: hash.Whirlpool, base64: false, download: true, }, { ht: hash.Whirlpool, base64: true, download: true, }, } { t.Run(fmt.Sprintf("hash=%v,base64=%v,download=%v", test.ht, test.base64, test.download), func(t *testing.T) { file1Hash, err := hasher.SumString(test.ht, test.base64) require.NoError(t, err) in := rc.Params{ "fs": r.FremoteName, "hashType": test.ht.String(), "base64": test.base64, "download": test.download, } out, err := call.Fn(ctx, in) require.NoError(t, err) assert.Equal(t, test.ht.String(), out["hashType"]) want := []string{ fmt.Sprintf("%s hashsum-file1", file1Hash), } assert.Equal(t, want, out["hashsum"]) }) } } // operations/hashsum: hashsum a single file func TestRcHashsumFile(t *testing.T) { ctx := context.Background() r, call := rcNewRun(t, "operations/hashsum") r.Mkdir(ctx, r.Fremote) file1Contents := "file1 contents" file1 := r.WriteBoth(ctx, "hashsum-file1", file1Contents, t1) file2Contents := "file2 contents" file2 := r.WriteBoth(ctx, "hashsum-file2", file2Contents, t1) r.CheckLocalItems(t, file1, file2) r.CheckRemoteItems(t, file1, file2) // Make an fs pointing to just the file fsString := path.Join(r.FremoteName, file1.Path) in := rc.Params{ "fs": fsString, "hashType": "MD5", "download": true, } out, err := call.Fn(ctx, in) require.NoError(t, err) assert.Equal(t, "md5", out["hashType"]) assert.Equal(t, []string{"0ef726ce9b1a7692357ff70dd321d595 hashsum-file1"}, out["hashsum"]) } rclone-v1.71.0/fs/operations/reopen.go000066400000000000000000000217261505210326400176700ustar00rootroot00000000000000package operations import ( "context" "errors" "io" "sync" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fserrors" ) // AccountFn is a function which will be called after every read // from the ReOpen. // // It may return an error which will be passed back to the user. type AccountFn func(n int) error // ReOpen is a wrapper for an object reader which reopens the stream on error type ReOpen struct { ctx context.Context mu sync.Mutex // mutex to protect the below src fs.Object // object to open baseOptions []fs.OpenOption // options to pass to initial open and where offset == 0 options []fs.OpenOption // option to pass on subsequent opens where offset != 0 rangeOption fs.RangeOption // adjust this range option on re-opens rc io.ReadCloser // underlying stream size int64 // total size of object - can be -ve start int64 // absolute position to start reading from end int64 // absolute position to end reading (exclusive) offset int64 // offset in the file we are at, offset from start newOffset int64 // if different to offset, reopen needed maxTries int // maximum number of retries tries int // number of retries we've had so far in this stream err error // if this is set then Read/Close calls will return it opened bool // if set then rc is valid and needs closing account AccountFn // account for a read reads int // count how many times the data has been read accountOn int // only account on or after this read } var ( errFileClosed = errors.New("file already closed") errTooManyTries = errors.New("failed to reopen: too many retries") errInvalidWhence = errors.New("reopen Seek: invalid whence") errNegativeSeek = errors.New("reopen Seek: negative position") errSeekPastEnd = errors.New("reopen Seek: attempt to seek past end of data") errBadEndSeek = errors.New("reopen Seek: can't seek from end with unknown sized object") ) // NewReOpen makes a handle which will reopen itself and seek to where // it was on errors up to maxTries times. // // If an fs.HashesOption is set this will be applied when reading from // the start. // // If an fs.RangeOption is set then this will applied when reading from // the start, and updated on retries. func NewReOpen(ctx context.Context, src fs.Object, maxTries int, options ...fs.OpenOption) (rc *ReOpen, err error) { h := &ReOpen{ ctx: ctx, src: src, maxTries: maxTries, baseOptions: options, size: src.Size(), start: 0, offset: 0, newOffset: -1, // -1 means no seek required } h.mu.Lock() defer h.mu.Unlock() // Filter the options for subsequent opens h.options = make([]fs.OpenOption, 0, len(options)+1) var limit int64 = -1 for _, option := range options { switch x := option.(type) { case *fs.HashesOption: // leave hash option out when ranging case *fs.RangeOption: h.start, limit = x.Decode(h.end) case *fs.SeekOption: h.start, limit = x.Offset, -1 default: h.options = append(h.options, option) } } // Put our RangeOption on the end h.rangeOption.Start = h.start h.options = append(h.options, &h.rangeOption) // If a size range is set then set the end point of the file to that if limit >= 0 && h.size >= 0 { h.end = h.start + limit h.rangeOption.End = h.end - 1 // remember range options are inclusive } else { h.end = h.size h.rangeOption.End = -1 } err = h.open() if err != nil { return nil, err } return h, nil } // Open makes a handle which will reopen itself and seek to where it // was on errors. // // If an fs.HashesOption is set this will be applied when reading from // the start. // // If an fs.RangeOption is set then this will applied when reading from // the start, and updated on retries. // // It will obey LowLevelRetries in the ctx as the maximum number of // tries. // // Use this instead of calling the Open method on fs.Objects func Open(ctx context.Context, src fs.Object, options ...fs.OpenOption) (rc *ReOpen, err error) { maxTries := fs.GetConfig(ctx).LowLevelRetries return NewReOpen(ctx, src, maxTries, options...) } // open the underlying handle - call with lock held // // we don't retry here as the Open() call will itself have low level retries func (h *ReOpen) open() error { var opts []fs.OpenOption if h.offset == 0 { // if reading from the start using the initial options opts = h.baseOptions } else { // otherwise use the filtered options opts = h.options // Adjust range start to where we have got to h.rangeOption.Start = h.start + h.offset } // Make a copy of the options as fs.FixRangeOption modifies them :-( opts = append(make([]fs.OpenOption, 0, len(opts)), opts...) h.tries++ if h.tries > h.maxTries { h.err = errTooManyTries } else { h.rc, h.err = h.src.Open(h.ctx, opts...) } if h.err != nil { if h.tries > 1 { fs.Debugf(h.src, "Reopen failed after offset %d bytes read: %v", h.offset, h.err) } return h.err } h.opened = true return nil } // reopen the underlying handle by closing it and reopening it. func (h *ReOpen) reopen() (err error) { // close underlying stream if needed if h.opened { h.opened = false _ = h.rc.Close() } return h.open() } // account for n bytes being read func (h *ReOpen) accountRead(n int) error { if h.account == nil { return nil } // Don't start accounting until we've reached this many reads // // rw.reads will be 1 the first time this is called // rw.accountOn 2 means start accounting on the 2nd read through if h.reads >= h.accountOn { return h.account(n) } return nil } // Read bytes retrying as necessary func (h *ReOpen) Read(p []byte) (n int, err error) { h.mu.Lock() defer h.mu.Unlock() if h.err != nil { // return a previous error if there is one return n, h.err } // re-open if seek needed if h.newOffset >= 0 { if h.offset != h.newOffset { fs.Debugf(h.src, "Seek from %d to %d", h.offset, h.newOffset) h.offset = h.newOffset err = h.reopen() if err != nil { return 0, err } } h.newOffset = -1 } // Read a full buffer startOffset := h.offset var nn int for n < len(p) && err == nil { nn, err = h.rc.Read(p[n:]) n += nn h.offset += int64(nn) if err != nil && err != io.EOF { h.err = err if !fserrors.IsNoLowLevelRetryError(err) { fs.Debugf(h.src, "Reopening on read failure after offset %d bytes: retry %d/%d: %v", h.offset, h.tries, h.maxTries, err) if h.reopen() == nil { err = nil } } } } // Count a read of the data if we read from the start successfully if startOffset == 0 && n != 0 { h.reads++ } // Account the read accErr := h.accountRead(n) if err == nil { err = accErr } return n, err } // Seek sets the offset for the next Read or Write to offset, interpreted // according to whence: SeekStart means relative to the start of the file, // SeekCurrent means relative to the current offset, and SeekEnd means relative // to the end (for example, offset = -2 specifies the penultimate byte of the // file). Seek returns the new offset relative to the start of the file or an // error, if any. // // Seeking to an offset before the start of the file is an error. Seeking // to any positive offset may be allowed, but if the new offset exceeds the // size of the underlying object the behavior of subsequent I/O operations is // implementation-dependent. func (h *ReOpen) Seek(offset int64, whence int) (int64, error) { h.mu.Lock() defer h.mu.Unlock() if h.err != nil { // return a previous error if there is one return 0, h.err } var abs int64 var size = h.end - h.start switch whence { case io.SeekStart: abs = offset case io.SeekCurrent: if h.newOffset >= 0 { abs = h.newOffset + offset } else { abs = h.offset + offset } case io.SeekEnd: if h.size < 0 { return 0, errBadEndSeek } abs = size + offset default: return 0, errInvalidWhence } if abs < 0 { return 0, errNegativeSeek } if h.size >= 0 && abs > size { return size, errSeekPastEnd } h.tries = 0 // Reset open count on seek h.newOffset = abs // New offset - applied in Read return abs, nil } // Close the stream func (h *ReOpen) Close() error { h.mu.Lock() defer h.mu.Unlock() if !h.opened { return errFileClosed } h.opened = false h.err = errFileClosed return h.rc.Close() } // SetAccounting should be provided with a function which will be // called after every read from the RW. // // It may return an error which will be passed back to the user. func (h *ReOpen) SetAccounting(account AccountFn) *ReOpen { h.account = account return h } // DelayAccounting makes sure the accounting function only gets called // on the i-th or later read of the data from this point (counting // from 1). // // This is useful so that we don't account initial reads of the data // e.g. when calculating hashes. // // Set this to 0 to account everything. func (h *ReOpen) DelayAccounting(i int) { h.accountOn = i h.reads = 0 } rclone-v1.71.0/fs/operations/reopen_test.go000066400000000000000000000242431505210326400207240ustar00rootroot00000000000000package operations import ( "context" "errors" "io" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fstest/mockobject" "github.com/rclone/rclone/lib/pool" "github.com/rclone/rclone/lib/readers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // check interfaces var ( _ io.ReadSeekCloser = (*ReOpen)(nil) _ pool.DelayAccountinger = (*ReOpen)(nil) ) var errorTestError = errors.New("test error") // this is a wrapper for a mockobject with a custom Open function // // breaks indicate the number of bytes to read before returning an // error type reOpenTestObject struct { fs.Object t *testing.T wantStart int64 breaks []int64 unknownSize bool } // Open opens the file for read. Call Close() on the returned io.ReadCloser // // This will break after reading the number of bytes in breaks func (o *reOpenTestObject) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { // Lots of backends do this - make sure it works as it modifies options fs.FixRangeOption(options, o.Size()) gotHash := false gotRange := false startPos := int64(0) for _, option := range options { switch x := option.(type) { case *fs.HashesOption: gotHash = true case *fs.RangeOption: gotRange = true startPos = x.Start if o.unknownSize { assert.Equal(o.t, int64(-1), x.End) } case *fs.SeekOption: startPos = x.Offset } } assert.Equal(o.t, o.wantStart, startPos) // Check if ranging, mustn't have hash if offset != 0 if gotHash && gotRange { assert.Equal(o.t, int64(0), startPos) } rc, err := o.Object.Open(ctx, options...) if err != nil { return nil, err } if len(o.breaks) > 0 { // Pop a breakpoint off N := o.breaks[0] o.breaks = o.breaks[1:] o.wantStart += N // If 0 then return an error immediately if N == 0 { return nil, errorTestError } // Read N bytes then an error r := io.MultiReader(&io.LimitedReader{R: rc, N: N}, readers.ErrorReader{Err: errorTestError}) // Wrap with Close in a new readCloser rc = readCloser{Reader: r, Closer: rc} } return rc, nil } func TestReOpen(t *testing.T) { for _, testName := range []string{"Normal", "WithRangeOption", "WithSeekOption", "UnknownSize"} { t.Run(testName, func(t *testing.T) { // Contents for the mock object var ( reOpenTestcontents = []byte("0123456789") expectedRead = reOpenTestcontents rangeOption *fs.RangeOption seekOption *fs.SeekOption unknownSize = false ) switch testName { case "Normal": case "WithRangeOption": rangeOption = &fs.RangeOption{Start: 1, End: 7} // range is inclusive expectedRead = reOpenTestcontents[1:8] case "WithSeekOption": seekOption = &fs.SeekOption{Offset: 2} expectedRead = reOpenTestcontents[2:] case "UnknownSize": rangeOption = &fs.RangeOption{Start: 1, End: -1} expectedRead = reOpenTestcontents[1:] unknownSize = true default: panic("bad test name") } // Start the test with the given breaks testReOpen := func(breaks []int64, maxRetries int) (*ReOpen, *reOpenTestObject, error) { srcOrig := mockobject.New("potato").WithContent(reOpenTestcontents, mockobject.SeekModeNone) srcOrig.SetUnknownSize(unknownSize) src := &reOpenTestObject{ Object: srcOrig, t: t, breaks: breaks, unknownSize: unknownSize, } opts := []fs.OpenOption{} if rangeOption == nil && seekOption == nil { opts = append(opts, &fs.HashesOption{Hashes: hash.NewHashSet(hash.MD5)}) } if rangeOption != nil { opts = append(opts, rangeOption) src.wantStart = rangeOption.Start } if seekOption != nil { opts = append(opts, seekOption) src.wantStart = seekOption.Offset } rc, err := NewReOpen(context.Background(), src, maxRetries, opts...) return rc, src, err } t.Run("Basics", func(t *testing.T) { // open h, _, err := testReOpen(nil, 10) assert.NoError(t, err) // Check contents read correctly got, err := io.ReadAll(h) assert.NoError(t, err) assert.Equal(t, expectedRead, got) // Check read after end var buf = make([]byte, 1) n, err := h.Read(buf) assert.Equal(t, 0, n) assert.Equal(t, io.EOF, err) // Rewind the stream _, err = h.Seek(0, io.SeekStart) require.NoError(t, err) // Check contents read correctly got, err = io.ReadAll(h) assert.NoError(t, err) assert.Equal(t, expectedRead, got) // Check close assert.NoError(t, h.Close()) // Check double close assert.Equal(t, errFileClosed, h.Close()) // Check read after close n, err = h.Read(buf) assert.Equal(t, 0, n) assert.Equal(t, errFileClosed, err) }) t.Run("ErrorAtStart", func(t *testing.T) { // open with immediate breaking h, _, err := testReOpen([]int64{0}, 10) assert.Equal(t, errorTestError, err) assert.Nil(t, h) }) t.Run("WithErrors", func(t *testing.T) { // open with a few break points but less than the max h, _, err := testReOpen([]int64{2, 1, 3}, 10) assert.NoError(t, err) // check contents got, err := io.ReadAll(h) assert.NoError(t, err) assert.Equal(t, expectedRead, got) // check close assert.NoError(t, h.Close()) }) t.Run("TooManyErrors", func(t *testing.T) { // open with a few break points but >= the max h, _, err := testReOpen([]int64{2, 1, 3}, 3) assert.NoError(t, err) // check contents got, err := io.ReadAll(h) assert.Equal(t, errorTestError, err) assert.Equal(t, expectedRead[:6], got) // check old error is returned var buf = make([]byte, 1) n, err := h.Read(buf) assert.Equal(t, 0, n) assert.Equal(t, errTooManyTries, err) // Check close assert.Equal(t, errFileClosed, h.Close()) }) t.Run("Seek", func(t *testing.T) { // open h, src, err := testReOpen([]int64{2, 1, 3}, 10) assert.NoError(t, err) // Seek to end pos, err := h.Seek(int64(len(expectedRead)), io.SeekStart) assert.NoError(t, err) assert.Equal(t, int64(len(expectedRead)), pos) // Seek to start pos, err = h.Seek(0, io.SeekStart) assert.NoError(t, err) assert.Equal(t, int64(0), pos) // Should not allow seek past end pos, err = h.Seek(int64(len(expectedRead))+1, io.SeekCurrent) if !unknownSize { assert.Equal(t, errSeekPastEnd, err) assert.Equal(t, len(expectedRead), int(pos)) } else { assert.Equal(t, nil, err) assert.Equal(t, len(expectedRead)+1, int(pos)) // Seek back to start to get tests in sync pos, err = h.Seek(0, io.SeekStart) assert.NoError(t, err) assert.Equal(t, int64(0), pos) } // Should not allow seek to negative position start pos, err = h.Seek(-1, io.SeekCurrent) assert.Equal(t, errNegativeSeek, err) assert.Equal(t, 0, int(pos)) // Should not allow seek with invalid whence pos, err = h.Seek(0, 3) assert.Equal(t, errInvalidWhence, err) assert.Equal(t, 0, int(pos)) // check read dst := make([]byte, 5) n, err := h.Read(dst) assert.Nil(t, err) assert.Equal(t, 5, n) assert.Equal(t, expectedRead[:5], dst) // Test io.SeekCurrent pos, err = h.Seek(-3, io.SeekCurrent) assert.Nil(t, err) assert.Equal(t, 2, int(pos)) // Reset the start after a seek, taking into account the offset setWantStart := func(x int64) { src.wantStart = x if rangeOption != nil { src.wantStart += rangeOption.Start } else if seekOption != nil { src.wantStart += seekOption.Offset } } // check read setWantStart(2) n, err = h.Read(dst) assert.Nil(t, err) assert.Equal(t, 5, n) assert.Equal(t, expectedRead[2:7], dst) pos, err = h.Seek(-2, io.SeekCurrent) assert.Nil(t, err) assert.Equal(t, 5, int(pos)) // Test io.SeekEnd pos, err = h.Seek(-3, io.SeekEnd) if !unknownSize { assert.Nil(t, err) assert.Equal(t, len(expectedRead)-3, int(pos)) } else { assert.Equal(t, errBadEndSeek, err) assert.Equal(t, 0, int(pos)) // sync pos, err = h.Seek(1, io.SeekCurrent) assert.Nil(t, err) assert.Equal(t, 6, int(pos)) } // check read dst = make([]byte, 3) setWantStart(int64(len(expectedRead) - 3)) n, err = h.Read(dst) assert.Nil(t, err) assert.Equal(t, 3, n) assert.Equal(t, expectedRead[len(expectedRead)-3:], dst) // check close assert.NoError(t, h.Close()) _, err = h.Seek(0, io.SeekCurrent) assert.Equal(t, errFileClosed, err) }) t.Run("AccountRead", func(t *testing.T) { h, _, err := testReOpen(nil, 10) assert.NoError(t, err) var total int h.SetAccounting(func(n int) error { total += n return nil }) dst := make([]byte, 3) n, err := h.Read(dst) assert.Equal(t, 3, n) assert.NoError(t, err) assert.Equal(t, 3, total) }) t.Run("AccountReadDelay", func(t *testing.T) { h, _, err := testReOpen(nil, 10) assert.NoError(t, err) var total int h.SetAccounting(func(n int) error { total += n return nil }) rewind := func() { _, err := h.Seek(0, io.SeekStart) require.NoError(t, err) } h.DelayAccounting(3) dst := make([]byte, 16) n, err := h.Read(dst) assert.Equal(t, len(expectedRead), n) assert.Equal(t, io.EOF, err) assert.Equal(t, 0, total) rewind() n, err = h.Read(dst) assert.Equal(t, len(expectedRead), n) assert.Equal(t, io.EOF, err) assert.Equal(t, 0, total) rewind() n, err = h.Read(dst) assert.Equal(t, len(expectedRead), n) assert.Equal(t, io.EOF, err) assert.Equal(t, len(expectedRead), total) rewind() n, err = h.Read(dst) assert.Equal(t, len(expectedRead), n) assert.Equal(t, io.EOF, err) assert.Equal(t, 2*len(expectedRead), total) rewind() }) t.Run("AccountReadError", func(t *testing.T) { // Test accounting errors h, _, err := testReOpen(nil, 10) assert.NoError(t, err) h.SetAccounting(func(n int) error { return errorTestError }) dst := make([]byte, 3) n, err := h.Read(dst) assert.Equal(t, 3, n) assert.Equal(t, errorTestError, err) }) }) } } rclone-v1.71.0/fs/override.go000066400000000000000000000034701505210326400160300ustar00rootroot00000000000000package fs import "context" // OverrideRemote is a wrapper to override the Remote for an // ObjectInfo type OverrideRemote struct { ObjectInfo remote string } // NewOverrideRemote returns an OverrideRemoteObject which will // return the remote specified func NewOverrideRemote(oi ObjectInfo, remote string) *OverrideRemote { // re-wrap an OverrideRemote if or, ok := oi.(*OverrideRemote); ok { return &OverrideRemote{ ObjectInfo: or.ObjectInfo, remote: remote, } } return &OverrideRemote{ ObjectInfo: oi, remote: remote, } } // Remote returns the overridden remote name func (o *OverrideRemote) Remote() string { return o.remote } // String returns the overridden remote name func (o *OverrideRemote) String() string { return o.remote } // MimeType returns the mime type of the underlying object or "" if it // can't be worked out func (o *OverrideRemote) MimeType(ctx context.Context) string { if do, ok := o.ObjectInfo.(MimeTyper); ok { return do.MimeType(ctx) } return "" } // ID returns the ID of the Object if known, or "" if not func (o *OverrideRemote) ID() string { if do, ok := o.ObjectInfo.(IDer); ok { return do.ID() } return "" } // UnWrap returns the Object that this Object is wrapping or nil if it // isn't wrapping anything func (o *OverrideRemote) UnWrap() Object { if o, ok := o.ObjectInfo.(Object); ok { return o } return nil } // GetTier returns storage tier or class of the Object func (o *OverrideRemote) GetTier() string { if do, ok := o.ObjectInfo.(GetTierer); ok { return do.GetTier() } return "" } // Metadata returns metadata for an object // // It should return nil if there is no Metadata func (o *OverrideRemote) Metadata(ctx context.Context) (Metadata, error) { if do, ok := o.ObjectInfo.(Metadataer); ok { return do.Metadata(ctx) } return nil, nil } rclone-v1.71.0/fs/override_dir.go000066400000000000000000000014171505210326400166650ustar00rootroot00000000000000package fs // OverrideDirectory is a wrapper to override the Remote for an // Directory type OverrideDirectory struct { Directory remote string } // NewOverrideDirectory returns an OverrideDirectoryObject which will // return the remote specified func NewOverrideDirectory(oi Directory, remote string) *OverrideDirectory { // re-wrap an OverrideDirectory if or, ok := oi.(*OverrideDirectory); ok { return &OverrideDirectory{ Directory: or.Directory, remote: remote, } } return &OverrideDirectory{ Directory: oi, remote: remote, } } // Remote returns the overridden remote name func (o *OverrideDirectory) Remote() string { return o.remote } // String returns the overridden remote name func (o *OverrideDirectory) String() string { return o.remote } rclone-v1.71.0/fs/override_dir_test.go000066400000000000000000000001261505210326400177200ustar00rootroot00000000000000package fs // Check interfaces satisfied var _ Directory = (*OverrideDirectory)(nil) rclone-v1.71.0/fs/override_test.go000066400000000000000000000001451505210326400170630ustar00rootroot00000000000000package fs // Check all optional interfaces satisfied var _ FullObjectInfo = (*OverrideRemote)(nil) rclone-v1.71.0/fs/pacer.go000066400000000000000000000043551505210326400153060ustar00rootroot00000000000000// Pacer with logging and calculator package fs import ( "context" "time" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/lib/pacer" ) // Pacer is a simple wrapper around a pacer.Pacer with logging. type Pacer struct { *pacer.Pacer } type logCalculator struct { pacer.Calculator } // NewPacer creates a Pacer for the given Fs and Calculator. func NewPacer(ctx context.Context, c pacer.Calculator) *Pacer { ci := GetConfig(ctx) retries := max(ci.LowLevelRetries, 1) maxConnections := max(ci.MaxConnections, 0) p := &Pacer{ Pacer: pacer.New( pacer.InvokerOption(pacerInvoker), pacer.MaxConnectionsOption(maxConnections), pacer.RetriesOption(retries), pacer.CalculatorOption(c), ), } p.SetCalculator(c) return p } func (d *logCalculator) Calculate(state pacer.State) time.Duration { oldSleepTime := state.SleepTime newSleepTime := d.Calculator.Calculate(state) if state.ConsecutiveRetries > 0 { if newSleepTime != oldSleepTime { Debugf("pacer", "Rate limited, increasing sleep to %v", newSleepTime) } } else { if newSleepTime != oldSleepTime { Debugf("pacer", "Reducing sleep to %v", newSleepTime) } } return newSleepTime } // SetCalculator sets the pacing algorithm. Don't modify the Calculator object // afterwards, use the ModifyCalculator method when needed. // // It will choose the default algorithm if nil is passed in. func (p *Pacer) SetCalculator(c pacer.Calculator) { switch c.(type) { case *logCalculator: Logf("pacer", "Invalid Calculator in fs.Pacer.SetCalculator") case nil: c = &logCalculator{pacer.NewDefault()} default: c = &logCalculator{c} } p.Pacer.SetCalculator(c) } // ModifyCalculator calls the given function with the currently configured // Calculator and the Pacer lock held. func (p *Pacer) ModifyCalculator(f func(pacer.Calculator)) { p.Pacer.ModifyCalculator(func(c pacer.Calculator) { switch _c := c.(type) { case *logCalculator: f(_c.Calculator) default: Logf("pacer", "Invalid Calculator in fs.Pacer: %t", c) f(c) } }) } func pacerInvoker(try, retries int, f pacer.Paced) (retry bool, err error) { retry, err = f() if retry { Debugf("pacer", "low level retry %d/%d (error %v)", try, retries, err) err = fserrors.RetryError(err) } return } rclone-v1.71.0/fs/parseduration.go000066400000000000000000000152031505210326400170660ustar00rootroot00000000000000package fs import ( "encoding/json" "fmt" "math" "strconv" "strings" "time" ) // Duration is a time.Duration with some more parsing options type Duration time.Duration // DurationOff is the default value for flags which can be turned off const DurationOff = Duration((1 << 63) - 1) // Turn Duration into a string func (d Duration) String() string { if d == DurationOff { return "off" } for i := len(ageSuffixes) - 2; i >= 0; i-- { ageSuffix := &ageSuffixes[i] if math.Abs(float64(d)) >= float64(ageSuffix.Multiplier) { timeUnits := float64(d) / float64(ageSuffix.Multiplier) return strconv.FormatFloat(timeUnits, 'f', -1, 64) + ageSuffix.Suffix } } return time.Duration(d).String() } // IsSet returns if the duration is != DurationOff func (d Duration) IsSet() bool { return d != DurationOff } // We use time conventions var ageSuffixes = []struct { Suffix string Multiplier time.Duration }{ {Suffix: "d", Multiplier: time.Hour * 24}, {Suffix: "w", Multiplier: time.Hour * 24 * 7}, {Suffix: "M", Multiplier: time.Hour * 24 * 30}, {Suffix: "y", Multiplier: time.Hour * 24 * 365}, // Default to second {Suffix: "", Multiplier: time.Second}, } // parse the age as suffixed ages func parseDurationSuffixes(age string) (time.Duration, error) { var period float64 for _, ageSuffix := range ageSuffixes { if strings.HasSuffix(age, ageSuffix.Suffix) { numberString := age[:len(age)-len(ageSuffix.Suffix)] var err error period, err = strconv.ParseFloat(numberString, 64) if err != nil { return time.Duration(0), err } period *= float64(ageSuffix.Multiplier) break } } return time.Duration(period), nil } // time formats to try parsing ages as - in order var timeFormats = []string{ time.RFC3339, "2006-01-02T15:04:05", "2006-01-02 15:04:05", "2006-01-02", } // parse the date as time in various date formats func parseTimeDates(date string) (t time.Time, err error) { var instant time.Time for _, timeFormat := range timeFormats { instant, err = time.ParseInLocation(timeFormat, date, time.Local) if err == nil { return instant, nil } } return t, err } // parse the age as time before the epoch in various date formats func parseDurationDates(age string, epoch time.Time) (d time.Duration, err error) { instant, err := parseTimeDates(age) if err != nil { return d, err } return epoch.Sub(instant), nil } // parseDurationFromNow parses a duration string. Allows ParseDuration to match the time // package and easier testing within the fs package. func parseDurationFromNow(age string, getNow func() time.Time) (d time.Duration, err error) { if age == "off" { return time.Duration(DurationOff), nil } // Attempt to parse as a time.Duration first d, err = time.ParseDuration(age) if err == nil { return d, nil } d, err = parseDurationSuffixes(age) if err == nil { return d, nil } d, err = parseDurationDates(age, getNow()) if err == nil { return d, nil } return d, err } // ParseDuration parses a duration string. Accept ms|s|m|h|d|w|M|y suffixes. Defaults to second if not provided func ParseDuration(age string) (time.Duration, error) { return parseDurationFromNow(age, timeNowFunc) } // ReadableString parses d into a human-readable duration with units. // Examples: "3s", "1d2h23m20s", "292y24w3d23h47m16s". func (d Duration) ReadableString() string { return d.readableString(0) } // ShortReadableString parses d into a human-readable duration with units. // This method returns it in short format, including the 3 most significant // units only, sacrificing precision if necessary. E.g. returns "292y24w3d" // instead of "292y24w3d23h47m16s", and "3d23h47m" instead of "3d23h47m16s". func (d Duration) ShortReadableString() string { return d.readableString(3) } // readableString parses d into a human-readable duration with units. // Parameter maxNumberOfUnits limits number of significant units to include, // sacrificing precision. E.g. with argument 3 it returns "292y24w3d" instead // of "292y24w3d23h47m16s", and "3d23h47m" instead of "3d23h47m16s". Zero or // negative argument means include all. // Based on https://github.com/hako/durafmt func (d Duration) readableString(maxNumberOfUnits int) string { switch d { case DurationOff: return "off" case 0: return "0s" } readableString := "" // Check for minus durations. if d < 0 { readableString += "-" } duration := time.Duration(math.Abs(float64(d))) // Convert duration. seconds := int64(duration.Seconds()) % 60 minutes := int64(duration.Minutes()) % 60 hours := int64(duration.Hours()) % 24 days := int64(duration/(24*time.Hour)) % 365 % 7 // Edge case between 364 and 365 days. // We need to calculate weeks from what is left from years leftYearDays := int64(duration/(24*time.Hour)) % 365 weeks := leftYearDays / 7 if leftYearDays >= 364 && leftYearDays < 365 { weeks = 52 } years := int64(duration/(24*time.Hour)) / 365 milliseconds := int64(duration/time.Millisecond) - (seconds * 1000) - (minutes * 60000) - (hours * 3600000) - (days * 86400000) - (weeks * 604800000) - (years * 31536000000) // Create a map of the converted duration time. durationMap := map[string]int64{ "ms": milliseconds, "s": seconds, "m": minutes, "h": hours, "d": days, "w": weeks, "y": years, } // Construct duration string. numberOfUnits := 0 for _, u := range [...]string{"y", "w", "d", "h", "m", "s", "ms"} { v := durationMap[u] strval := strconv.FormatInt(v, 10) if v == 0 { continue } readableString += strval + u numberOfUnits++ if maxNumberOfUnits > 0 && numberOfUnits >= maxNumberOfUnits { break } } return readableString } // Set a Duration func (d *Duration) Set(s string) error { duration, err := ParseDuration(s) if err != nil { return err } *d = Duration(duration) return nil } // Type of the value func (d Duration) Type() string { return "Duration" } // UnmarshalJSON makes sure the value can be parsed as a string or integer in JSON func (d *Duration) UnmarshalJSON(in []byte) error { // Check if the input is a string value. if len(in) >= 2 && in[0] == '"' && in[len(in)-1] == '"' { strVal := string(in[1 : len(in)-1]) // Remove the quotes // Attempt to parse the string as a duration. parsedDuration, err := ParseDuration(strVal) if err != nil { return err } *d = Duration(parsedDuration) return nil } // Handle numeric values. var i int64 err := json.Unmarshal(in, &i) if err != nil { return err } *d = Duration(i) return nil } // Scan implements the fmt.Scanner interface func (d *Duration) Scan(s fmt.ScanState, ch rune) error { token, err := s.Token(true, func(rune) bool { return true }) if err != nil { return err } return d.Set(string(token)) } rclone-v1.71.0/fs/parseduration_test.go000066400000000000000000000165071505210326400201350ustar00rootroot00000000000000package fs import ( "encoding/json" "fmt" "strings" "testing" "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Check it satisfies the interfaces var ( _ Flagger = (*Duration)(nil) _ FlaggerNP = Duration(0) ) func TestParseDuration(t *testing.T) { now := time.Date(2020, 9, 5, 8, 15, 5, 250, time.UTC) getNow := func() time.Time { return now } for _, test := range []struct { in string want time.Duration err bool }{ {"0", 0, false}, {"", 0, true}, {"1ms", time.Millisecond, false}, {"1s", time.Second, false}, {"1m", time.Minute, false}, {"1.5m", (3 * time.Minute) / 2, false}, {"1h", time.Hour, false}, {"1d", time.Hour * 24, false}, {"1w", time.Hour * 24 * 7, false}, {"1M", time.Hour * 24 * 30, false}, {"1y", time.Hour * 24 * 365, false}, {"1.5y", time.Hour * 24 * 365 * 3 / 2, false}, {"-1s", -time.Second, false}, {"1.s", time.Second, false}, {"1x", 0, true}, {"off", time.Duration(DurationOff), false}, {"1h2m3s", time.Hour + 2*time.Minute + 3*time.Second, false}, {"2001-02-03", now.Sub(time.Date(2001, 2, 3, 0, 0, 0, 0, time.Local)), false}, {"2001-02-03 10:11:12", now.Sub(time.Date(2001, 2, 3, 10, 11, 12, 0, time.Local)), false}, {"2001-08-03 10:11:12", now.Sub(time.Date(2001, 8, 3, 10, 11, 12, 0, time.Local)), false}, {"2001-02-03T10:11:12", now.Sub(time.Date(2001, 2, 3, 10, 11, 12, 0, time.Local)), false}, {"2001-02-03T10:11:12.123Z", now.Sub(time.Date(2001, 2, 3, 10, 11, 12, 123, time.UTC)), false}, {"2001-02-03T10:11:12.123+00:00", now.Sub(time.Date(2001, 2, 3, 10, 11, 12, 123, time.UTC)), false}, } { duration, err := parseDurationFromNow(test.in, getNow) if test.err { require.Error(t, err) } else { require.NoError(t, err) } if strings.HasPrefix(test.in, "2001-") { ok := duration > test.want-time.Second && duration < test.want+time.Second assert.True(t, ok, test.in) } else { assert.Equal(t, test.want, duration) } } } func TestDurationString(t *testing.T) { now := time.Date(2020, 9, 5, 8, 15, 5, 250, time.UTC) getNow := func() time.Time { return now } for _, test := range []struct { in time.Duration want string }{ {time.Duration(0), "0s"}, {time.Second, "1s"}, {time.Minute, "1m0s"}, {time.Millisecond, "1ms"}, {time.Second, "1s"}, {(3 * time.Minute) / 2, "1m30s"}, {time.Hour, "1h0m0s"}, {time.Hour * 24, "1d"}, {time.Hour * 24 * 7, "1w"}, {time.Hour * 24 * 30, "1M"}, {time.Hour * 24 * 365, "1y"}, {time.Hour * 24 * 365 * 3 / 2, "1.5y"}, {-time.Second, "-1s"}, {time.Second, "1s"}, {time.Duration(DurationOff), "off"}, {time.Hour + 2*time.Minute + 3*time.Second, "1h2m3s"}, {time.Hour * 24, "1d"}, {time.Hour * 24 * 7, "1w"}, {time.Hour * 24 * 30, "1M"}, {time.Hour * 24 * 365, "1y"}, {time.Hour * 24 * 365 * 3 / 2, "1.5y"}, {-time.Hour * 24 * 365 * 3 / 2, "-1.5y"}, } { got := Duration(test.in).String() assert.Equal(t, test.want, got) // Test the reverse reverse, err := parseDurationFromNow(test.want, getNow) assert.NoError(t, err) assert.Equal(t, test.in, reverse) } } func TestDurationReadableString(t *testing.T) { for _, test := range []struct { negative bool in time.Duration wantLong string wantShort string }{ // Edge Cases {false, time.Duration(DurationOff), "off", "off"}, // Base Cases {false, time.Duration(0), "0s", "0s"}, {true, time.Millisecond, "1ms", "1ms"}, {true, time.Second, "1s", "1s"}, {true, time.Minute, "1m", "1m"}, {true, (3 * time.Minute) / 2, "1m30s", "1m30s"}, {true, time.Hour, "1h", "1h"}, {true, time.Hour * 24, "1d", "1d"}, {true, time.Hour * 24 * 7, "1w", "1w"}, {true, time.Hour * 24 * 365, "1y", "1y"}, // Composite Cases {true, time.Hour + 2*time.Minute + 3*time.Second, "1h2m3s", "1h2m3s"}, {true, time.Hour * 24 * (365 + 14), "1y2w", "1y2w"}, {true, time.Hour*24*4 + time.Hour*3 + time.Minute*2 + time.Second, "4d3h2m1s", "4d3h2m"}, {true, time.Hour * 24 * (365*3 + 7*2 + 1), "3y2w1d", "3y2w1d"}, {true, time.Hour*24*(365*3+7*2+1) + time.Hour*2 + time.Second, "3y2w1d2h1s", "3y2w1d"}, {true, time.Hour*24*(365*3+7*2+1) + time.Second, "3y2w1d1s", "3y2w1d"}, {true, time.Hour*24*(365+7*2+3) + time.Hour*4 + time.Minute*5 + time.Second*6 + time.Millisecond*7, "1y2w3d4h5m6s7ms", "1y2w3d"}, {true, time.Duration(DurationOff) / time.Millisecond * time.Millisecond, "292y24w3d23h47m16s853ms", "292y24w3d"}, // Should have been 854ms but some precision are lost with floating point calculations } { got := Duration(test.in).ReadableString() assert.Equal(t, test.wantLong, got) got = Duration(test.in).ShortReadableString() assert.Equal(t, test.wantShort, got) // Test Negative Case if test.negative { got = Duration(-test.in).ReadableString() assert.Equal(t, "-"+test.wantLong, got) got = Duration(-test.in).ShortReadableString() assert.Equal(t, "-"+test.wantShort, got) } } } func TestDurationScan(t *testing.T) { now := time.Date(2020, 9, 5, 8, 15, 5, 250, time.UTC) oldTimeNowFunc := timeNowFunc timeNowFunc = func() time.Time { return now } defer func() { timeNowFunc = oldTimeNowFunc }() for _, test := range []struct { in string want Duration }{ {"17m", Duration(17 * time.Minute)}, {"-12h", Duration(-12 * time.Hour)}, {"0", Duration(0)}, {"off", DurationOff}, {"2022-03-26T17:48:19Z", Duration(now.Sub(time.Date(2022, 03, 26, 17, 48, 19, 0, time.UTC)))}, {"2022-03-26 17:48:19", Duration(now.Sub(time.Date(2022, 03, 26, 17, 48, 19, 0, time.Local)))}, } { var got Duration n, err := fmt.Sscan(test.in, &got) require.NoError(t, err) assert.Equal(t, 1, n) assert.Equal(t, test.want, got) } } func TestParseUnmarshalJSON(t *testing.T) { for _, test := range []struct { in string want time.Duration err bool }{ {`""`, 0, true}, {`"0"`, 0, false}, {`"1ms"`, time.Millisecond, false}, {`"1s"`, time.Second, false}, {`"1m"`, time.Minute, false}, {`"1h"`, time.Hour, false}, {`"1d"`, time.Hour * 24, false}, {`"1w"`, time.Hour * 24 * 7, false}, {`"1M"`, time.Hour * 24 * 30, false}, {`"1y"`, time.Hour * 24 * 365, false}, {`"off"`, time.Duration(DurationOff), false}, {`"error"`, 0, true}, {"0", 0, false}, {"1000000", time.Millisecond, false}, {"1000000000", time.Second, false}, {"60000000000", time.Minute, false}, {"3600000000000", time.Hour, false}, {"9223372036854775807", time.Duration(DurationOff), false}, {"error", 0, true}, } { var duration Duration err := json.Unmarshal([]byte(test.in), &duration) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, Duration(test.want), duration, test.in) } } func TestUnmarshalJSON(t *testing.T) { tests := []struct { name string input string want Duration wantErr bool }{ {"off string", `"off"`, DurationOff, false}, {"max int64", `9223372036854775807`, DurationOff, false}, {"duration string", `"1h"`, Duration(time.Hour), false}, {"invalid string", `"invalid"`, 0, true}, {"negative int", `-1`, Duration(-1), false}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var d Duration err := json.Unmarshal([]byte(tt.input), &d) if (err != nil) != tt.wantErr { t.Errorf("UnmarshalJSON() error = %v, wantErr %v", err, tt.wantErr) return } if d != tt.want { t.Errorf("UnmarshalJSON() got = %v, want %v", d, tt.want) } }) } } rclone-v1.71.0/fs/parsetime.go000066400000000000000000000033531505210326400162020ustar00rootroot00000000000000package fs import ( "encoding/json" "fmt" "time" ) // Time is a time.Time with some more parsing options type Time time.Time // For overriding in unittests. var ( timeNowFunc = time.Now ) // Turn Time into a string func (t Time) String() string { if !t.IsSet() { return "off" } return time.Time(t).Format(time.RFC3339Nano) } // IsSet returns if the time is not zero func (t Time) IsSet() bool { return !time.Time(t).IsZero() } // ParseTime parses a time or duration string as a Time. func ParseTime(date string) (t time.Time, err error) { if date == "off" { return time.Time{}, nil } now := timeNowFunc() // Attempt to parse as a text time t, err = parseTimeDates(date) if err == nil { return t, nil } // Attempt to parse as a time.Duration offset from now d, err := time.ParseDuration(date) if err == nil { return now.Add(-d), nil } d, err = parseDurationSuffixes(date) if err == nil { return now.Add(-d), nil } return t, err } // Set a Time func (t *Time) Set(s string) error { parsedTime, err := ParseTime(s) if err != nil { return err } *t = Time(parsedTime) return nil } // Type of the value func (t Time) Type() string { return "Time" } // UnmarshalJSON makes sure the value can be parsed as a string in JSON func (t *Time) UnmarshalJSON(in []byte) error { var s string err := json.Unmarshal(in, &s) if err != nil { return err } return t.Set(s) } // MarshalJSON marshals as a time.Time value func (t Time) MarshalJSON() ([]byte, error) { return json.Marshal(time.Time(t)) } // Scan implements the fmt.Scanner interface func (t *Time) Scan(s fmt.ScanState, ch rune) error { token, err := s.Token(true, func(rune) bool { return true }) if err != nil { return err } return t.Set(string(token)) } rclone-v1.71.0/fs/parsetime_test.go000066400000000000000000000125601505210326400172410ustar00rootroot00000000000000package fs import ( "encoding/json" "fmt" "testing" "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Check it satisfies the interfaces var ( _ Flagger = (*Time)(nil) _ FlaggerNP = Time{} ) func TestParseTime(t *testing.T) { now := time.Date(2020, 9, 5, 8, 15, 5, 250, time.UTC) oldTimeNowFunc := timeNowFunc timeNowFunc = func() time.Time { return now } defer func() { timeNowFunc = oldTimeNowFunc }() for _, test := range []struct { in string want time.Time err bool }{ {"", time.Time{}, true}, {"1ms", now.Add(-time.Millisecond), false}, {"1s", now.Add(-time.Second), false}, {"1", now.Add(-time.Second), false}, {"1m", now.Add(-time.Minute), false}, {"1.5m", now.Add(-(3 * time.Minute) / 2), false}, {"1h", now.Add(-time.Hour), false}, {"1d", now.Add(-time.Hour * 24), false}, {"1w", now.Add(-time.Hour * 24 * 7), false}, {"1M", now.Add(-time.Hour * 24 * 30), false}, {"1y", now.Add(-time.Hour * 24 * 365), false}, {"1.5y", now.Add(-time.Hour * 24 * 365 * 3 / 2), false}, {"-1.5y", now.Add(time.Hour * 24 * 365 * 3 / 2), false}, {"-1s", now.Add(time.Second), false}, {"-1", now.Add(time.Second), false}, {"0", now, false}, {"100", now.Add(-100 * time.Second), false}, {"-100", now.Add(100 * time.Second), false}, {"1.s", now.Add(-time.Second), false}, {"1x", time.Time{}, true}, {"-1x", time.Time{}, true}, {"off", time.Time{}, false}, {"1h2m3s", now.Add(-(time.Hour + 2*time.Minute + 3*time.Second)), false}, {"2001-02-03", time.Date(2001, 2, 3, 0, 0, 0, 0, time.Local), false}, {"2001-02-03 10:11:12", time.Date(2001, 2, 3, 10, 11, 12, 0, time.Local), false}, {"2001-08-03 10:11:12", time.Date(2001, 8, 3, 10, 11, 12, 0, time.Local), false}, {"2001-02-03T10:11:12", time.Date(2001, 2, 3, 10, 11, 12, 0, time.Local), false}, {"2001-02-03T10:11:12.123Z", time.Date(2001, 2, 3, 10, 11, 12, 123000000, time.UTC), false}, {"2001-02-03T10:11:12.123+00:00", time.Date(2001, 2, 3, 10, 11, 12, 123000000, time.UTC), false}, } { parsedTime, err := ParseTime(test.in) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.True(t, test.want.Equal(parsedTime), "%v should be parsed as %v instead of %v", test.in, test.want, parsedTime) } } func TestTimeString(t *testing.T) { now := time.Date(2020, 9, 5, 8, 15, 5, 250, time.UTC) oldTimeNowFunc := timeNowFunc timeNowFunc = func() time.Time { return now } defer func() { timeNowFunc = oldTimeNowFunc }() for _, test := range []struct { in time.Time want string }{ {now, "2020-09-05T08:15:05.00000025Z"}, {time.Date(2021, 8, 5, 8, 15, 5, 0, time.UTC), "2021-08-05T08:15:05Z"}, {time.Time{}, "off"}, } { got := Time(test.in).String() assert.Equal(t, test.want, got) // Test the reverse reverse, err := ParseTime(test.want) assert.NoError(t, err) assert.Equal(t, test.in, reverse) } } func TestTimeScan(t *testing.T) { now := time.Date(2020, 9, 5, 8, 15, 5, 250, time.UTC) oldTimeNowFunc := timeNowFunc timeNowFunc = func() time.Time { return now } defer func() { timeNowFunc = oldTimeNowFunc }() for _, test := range []struct { in string want Time }{ {"17m", Time(now.Add(-17 * time.Minute))}, {"-12h", Time(now.Add(12 * time.Hour))}, {"0", Time(now)}, {"off", Time(time.Time{})}, {"2022-03-26T17:48:19Z", Time(time.Date(2022, 03, 26, 17, 48, 19, 0, time.UTC))}, {"2022-03-26 17:48:19", Time(time.Date(2022, 03, 26, 17, 48, 19, 0, time.Local))}, } { var got Time n, err := fmt.Sscan(test.in, &got) require.NoError(t, err) assert.Equal(t, 1, n) assert.Equal(t, test.want, got) } } func TestParseTimeUnmarshalJSON(t *testing.T) { now := time.Date(2020, 9, 5, 8, 15, 5, 250, time.UTC) oldTimeNowFunc := timeNowFunc timeNowFunc = func() time.Time { return now } defer func() { timeNowFunc = oldTimeNowFunc }() for _, test := range []struct { in string want time.Time err bool }{ {`""`, time.Time{}, true}, {"0", time.Time{}, true}, {"1", time.Time{}, true}, {"1", time.Time{}, true}, {`"2022-03-26T17:48:19Z"`, time.Date(2022, 03, 26, 17, 48, 19, 0, time.UTC), false}, {`"0"`, now, false}, {`"1ms"`, now.Add(-time.Millisecond), false}, {`"1s"`, now.Add(-time.Second), false}, {`"1"`, now.Add(-time.Second), false}, {`"1m"`, now.Add(-time.Minute), false}, {`"1h"`, now.Add(-time.Hour), false}, {`"-1h"`, now.Add(time.Hour), false}, {`"1d"`, now.Add(-time.Hour * 24), false}, {`"1w"`, now.Add(-time.Hour * 24 * 7), false}, {`"1M"`, now.Add(-time.Hour * 24 * 30), false}, {`"1y"`, now.Add(-time.Hour * 24 * 365), false}, {`"off"`, time.Time{}, false}, {`"error"`, time.Time{}, true}, {"error", time.Time{}, true}, } { var parsedTime Time err := json.Unmarshal([]byte(test.in), &parsedTime) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, Time(test.want), parsedTime, test.in) } } func TestParseTimeMarshalJSON(t *testing.T) { for _, test := range []struct { in time.Time want string err bool }{ {time.Time{}, `"0001-01-01T00:00:00Z"`, false}, {time.Date(2022, 03, 26, 17, 48, 19, 0, time.UTC), `"2022-03-26T17:48:19Z"`, false}, } { gotBytes, err := json.Marshal(test.in) got := string(gotBytes) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, got, test.in) } } rclone-v1.71.0/fs/rc/000077500000000000000000000000001505210326400142625ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/cache.go000066400000000000000000000112431505210326400156550ustar00rootroot00000000000000// Utilities for accessing the Fs cache package rc import ( "context" "errors" "fmt" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/fspath" ) // getFsName gets an fs name from fsName either from the cache or direct func getFsName(in Params, fsName string) (fsString string, err error) { fsString, err = in.GetString(fsName) if err != nil { if !IsErrParamInvalid(err) { return fsString, err } fsString, err = getConfigMap(in, fsName) if err != nil { return fsString, err } } return fsString, err } // GetFsNamed gets an fs.Fs named fsName either from the cache or creates it afresh func GetFsNamed(ctx context.Context, in Params, fsName string) (f fs.Fs, err error) { fsString, err := getFsName(in, fsName) if err != nil { return nil, err } return cache.Get(ctx, fsString) } // GetFsNamedFileOK gets an fs.Fs named fsName either from the cache or creates it afresh // // If the fs.Fs points to a single file then it returns a new ctx with // filters applied to make the listings return only that file. func GetFsNamedFileOK(ctx context.Context, in Params, fsName string) (newCtx context.Context, f fs.Fs, err error) { fsString, err := getFsName(in, fsName) if err != nil { return ctx, nil, err } f, err = cache.Get(ctx, fsString) if err == nil { return ctx, f, nil } else if !errors.Is(err, fs.ErrorIsFile) { return ctx, nil, err } // f points to the directory above the file so find the remote name _, fileName, err := fspath.Split(fsString) if err != nil { return ctx, f, err } ctx, fi := filter.AddConfig(ctx) if !fi.InActive() { return ctx, f, fmt.Errorf("can't limit to single files when using filters: %q", fileName) } // Limit transfers to this file err = fi.AddFile(fileName) if err != nil { return ctx, f, fmt.Errorf("failed to limit to single file: %w", err) } return ctx, f, nil } // getConfigMap gets the config as a map from in and converts it to a // config string // // It uses the special parameters _name to name the remote and _root // to make the root of the remote. func getConfigMap(in Params, fsName string) (fsString string, err error) { var m configmap.Simple err = in.GetStruct(fsName, &m) if err != nil { return fsString, err } pop := func(key string) string { value := m[key] delete(m, key) return value } Type := pop("type") name := pop("_name") root := pop("_root") if name != "" { fsString = name } else if Type != "" { fsString = ":" + Type } else { return fsString, errors.New(`couldn't find "type" or "_name" in JSON config definition`) } config := m.String() if config != "" { fsString += "," fsString += config } fsString += ":" fsString += root return fsString, nil } // GetFs gets an fs.Fs named "fs" either from the cache or creates it afresh func GetFs(ctx context.Context, in Params) (f fs.Fs, err error) { return GetFsNamed(ctx, in, "fs") } // GetFsAndRemoteNamed gets the fsName parameter from in, makes a // remote or fetches it from the cache then gets the remoteName // parameter from in too. func GetFsAndRemoteNamed(ctx context.Context, in Params, fsName, remoteName string) (f fs.Fs, remote string, err error) { remote, err = in.GetString(remoteName) if err != nil { return } f, err = GetFsNamed(ctx, in, fsName) return } // GetFsAndRemote gets the `fs` parameter from in, makes a remote or // fetches it from the cache then gets the `remote` parameter from in // too. func GetFsAndRemote(ctx context.Context, in Params) (f fs.Fs, remote string, err error) { return GetFsAndRemoteNamed(ctx, in, "fs", "remote") } func init() { Add(Call{ Path: "fscache/clear", Fn: rcCacheClear, Title: "Clear the Fs cache.", AuthRequired: true, Help: ` This clears the fs cache. This is where remotes created from backends are cached for a short while to make repeated rc calls more efficient. If you change the parameters of a backend then you may want to call this to clear an existing remote out of the cache before re-creating it. `, }) } // Clear the fs cache func rcCacheClear(ctx context.Context, in Params) (out Params, err error) { cache.Clear() return nil, nil } func init() { Add(Call{ Path: "fscache/entries", Fn: rcCacheEntries, Title: "Returns the number of entries in the fs cache.", AuthRequired: true, Help: ` This returns the number of entries in the fs cache. Returns - entries - number of items in the cache `, }) } // Return the Entries the fs cache func rcCacheEntries(ctx context.Context, in Params) (out Params, err error) { return Params{ "entries": cache.Entries(), }, nil } rclone-v1.71.0/fs/rc/cache_test.go000066400000000000000000000121551505210326400167170ustar00rootroot00000000000000package rc import ( "context" "fmt" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fstest/mockfs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func mockNewFs(t *testing.T) func() { ctx := context.Background() f, err := mockfs.NewFs(ctx, "/", "", nil) require.NoError(t, err) cache.Put("/", f) f, err = mockfs.NewFs(ctx, "mock", "/", nil) require.NoError(t, err) cache.Put("mock:/", f) cache.Put(":mock:/", f) f, err = mockfs.NewFs(ctx, "mock", "dir/", nil) require.NoError(t, err) cache.PutErr("mock:dir/file.txt", f, fs.ErrorIsFile) return func() { cache.Clear() } } func TestGetFsNamed(t *testing.T) { defer mockNewFs(t)() in := Params{ "potato": "/", } f, err := GetFsNamed(context.Background(), in, "potato") require.NoError(t, err) assert.NotNil(t, f) in = Params{ "sausage": "/", } f, err = GetFsNamed(context.Background(), in, "potato") require.Error(t, err) assert.Nil(t, f) } func TestGetFsNamedStruct(t *testing.T) { defer mockNewFs(t)() in := Params{ "potato": Params{ "type": "mock", "_root": "/", }, } f, err := GetFsNamed(context.Background(), in, "potato") require.NoError(t, err) assert.NotNil(t, f) in = Params{ "potato": Params{ "_name": "mock", "_root": "/", }, } f, err = GetFsNamed(context.Background(), in, "potato") require.NoError(t, err) assert.NotNil(t, f) } func TestGetFsNamedFileOK(t *testing.T) { defer mockNewFs(t)() ctx := context.Background() in := Params{ "potato": "/", } newCtx, f, err := GetFsNamedFileOK(ctx, in, "potato") require.NoError(t, err) assert.NotNil(t, f) assert.Equal(t, ctx, newCtx) in = Params{ "sausage": "/", } newCtx, f, err = GetFsNamedFileOK(ctx, in, "potato") require.Error(t, err) assert.Nil(t, f) assert.Equal(t, ctx, newCtx) in = Params{ "potato": "mock:dir/file.txt", } newCtx, f, err = GetFsNamedFileOK(ctx, in, "potato") assert.Nil(t, err) assert.NotNil(t, f) assert.NotEqual(t, ctx, newCtx) fi := filter.GetConfig(newCtx) assert.False(t, fi.InActive()) assert.True(t, fi.IncludeRemote("file.txt")) assert.False(t, fi.IncludeRemote("other.txt")) } func TestGetConfigMap(t *testing.T) { for _, test := range []struct { in Params fsName string wantFsString string wantErr string }{ { in: Params{ "Fs": Params{}, }, fsName: "Fs", wantErr: `couldn't find "type" or "_name" in JSON config definition`, }, { in: Params{ "Fs": Params{ "notastring": true, }, }, fsName: "Fs", wantErr: `cannot unmarshal bool`, }, { in: Params{ "Fs": Params{ "_name": "potato", }, }, fsName: "Fs", wantFsString: "potato:", }, { in: Params{ "Fs": Params{ "type": "potato", }, }, fsName: "Fs", wantFsString: ":potato:", }, { in: Params{ "Fs": Params{ "type": "sftp", "_name": "potato", "parameter": "42", "parameter2": "true", "_root": "/path/to/somewhere", }, }, fsName: "Fs", wantFsString: "potato,parameter='42',parameter2='true':/path/to/somewhere", }, } { gotFsString, gotErr := getConfigMap(test.in, test.fsName) what := fmt.Sprintf("%+v", test.in) assert.Equal(t, test.wantFsString, gotFsString, what) if test.wantErr == "" { assert.NoError(t, gotErr) } else { require.Error(t, gotErr) assert.Contains(t, gotErr.Error(), test.wantErr) } } } func TestGetFs(t *testing.T) { defer mockNewFs(t)() in := Params{ "fs": "/", } f, err := GetFs(context.Background(), in) require.NoError(t, err) assert.NotNil(t, f) } func TestGetFsAndRemoteNamed(t *testing.T) { defer mockNewFs(t)() in := Params{ "fs": "/", "remote": "hello", } f, remote, err := GetFsAndRemoteNamed(context.Background(), in, "fs", "remote") require.NoError(t, err) assert.NotNil(t, f) assert.Equal(t, "hello", remote) f, _, err = GetFsAndRemoteNamed(context.Background(), in, "fsX", "remote") require.Error(t, err) assert.Nil(t, f) f, _, err = GetFsAndRemoteNamed(context.Background(), in, "fs", "remoteX") require.Error(t, err) assert.Nil(t, f) } func TestGetFsAndRemote(t *testing.T) { defer mockNewFs(t)() in := Params{ "fs": "/", "remote": "hello", } f, remote, err := GetFsAndRemote(context.Background(), in) require.NoError(t, err) assert.NotNil(t, f) assert.Equal(t, "hello", remote) t.Run("RcFscache", func(t *testing.T) { getEntries := func() int { call := Calls.Get("fscache/entries") require.NotNil(t, call) in := Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) return out["entries"].(int) } t.Run("Entries", func(t *testing.T) { assert.NotEqual(t, 0, getEntries()) }) t.Run("Clear", func(t *testing.T) { call := Calls.Get("fscache/clear") require.NotNil(t, call) in := Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.Nil(t, out) }) t.Run("Entries2", func(t *testing.T) { assert.Equal(t, 0, getEntries()) }) }) } rclone-v1.71.0/fs/rc/config.go000066400000000000000000000121451505210326400160610ustar00rootroot00000000000000// Implement config options reading and writing // // This is done here rather than in fs/fs.go so we don't cause a circular dependency package rc import ( "context" "fmt" "strings" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/filter" ) func init() { Add(Call{ Path: "options/blocks", Fn: rcOptionsBlocks, Title: "List all the option blocks", Help: `Returns: - options - a list of the options block names`, }) } // Show the list of all the option blocks func rcOptionsBlocks(ctx context.Context, in Params) (out Params, err error) { options := []string{} for _, opt := range fs.OptionsRegistry { options = append(options, opt.Name) } out = make(Params) out["options"] = options return out, nil } func init() { Add(Call{ Path: "options/get", Fn: rcOptionsGet, Title: "Get all the global options", Help: `Returns an object where keys are option block names and values are an object with the current option values in. Parameters: - blocks: optional string of comma separated blocks to include - all are included if this is missing or "" Note that these are the global options which are unaffected by use of the _config and _filter parameters. If you wish to read the parameters set in _config or _filter use options/local. This shows the internal names of the option within rclone which should map to the external options very easily with a few exceptions. `, }) } // Filter the blocks according to name func filterBlocks(in Params, f func(oi fs.OptionsInfo)) (err error) { blocksStr, err := in.GetString("blocks") if err != nil && !IsErrParamNotFound(err) { return err } blocks := map[string]struct{}{} for _, name := range strings.Split(blocksStr, ",") { if name != "" { blocks[name] = struct{}{} } } for _, oi := range fs.OptionsRegistry { if _, found := blocks[oi.Name]; found || len(blocks) == 0 { f(oi) } } return nil } // Show the list of all the option blocks func rcOptionsGet(ctx context.Context, in Params) (out Params, err error) { out = make(Params) err = filterBlocks(in, func(oi fs.OptionsInfo) { out[oi.Name] = oi.Opt }) return out, err } func init() { Add(Call{ Path: "options/info", Fn: rcOptionsInfo, Title: "Get info about all the global options", Help: `Returns an object where keys are option block names and values are an array of objects with info about each options. Parameters: - blocks: optional string of comma separated blocks to include - all are included if this is missing or "" These objects are in the same format as returned by "config/providers". They are described in the [option blocks](#option-blocks) section. `, }) } // Show the info of all the option blocks func rcOptionsInfo(ctx context.Context, in Params) (out Params, err error) { out = make(Params) err = filterBlocks(in, func(oi fs.OptionsInfo) { out[oi.Name] = oi.Options }) return out, err } func init() { Add(Call{ Path: "options/local", Fn: rcOptionsLocal, Title: "Get the currently active config for this call", Help: `Returns an object with the keys "config" and "filter". The "config" key contains the local config and the "filter" key contains the local filters. Note that these are the local options specific to this rc call. If _config was not supplied then they will be the global options. Likewise with "_filter". This call is mostly useful for seeing if _config and _filter passing is working. This shows the internal names of the option within rclone which should map to the external options very easily with a few exceptions. `, }) } // Show the current config func rcOptionsLocal(ctx context.Context, in Params) (out Params, err error) { out = make(Params) out["config"] = fs.GetConfig(ctx) out["filter"] = filter.GetConfig(ctx).Opt return out, nil } func init() { Add(Call{ Path: "options/set", Fn: rcOptionsSet, Title: "Set an option", Help: `Parameters: - option block name containing an object with - key: value Repeated as often as required. Only supply the options you wish to change. If an option is unknown it will be silently ignored. Not all options will have an effect when changed like this. For example: This sets DEBUG level logs (-vv) (these can be set by number or string) rclone rc options/set --json '{"main": {"LogLevel": "DEBUG"}}' rclone rc options/set --json '{"main": {"LogLevel": 8}}' And this sets INFO level logs (-v) rclone rc options/set --json '{"main": {"LogLevel": "INFO"}}' And this sets NOTICE level logs (normal without -v) rclone rc options/set --json '{"main": {"LogLevel": "NOTICE"}}' `, }) } // Set an option in an option block func rcOptionsSet(ctx context.Context, in Params) (out Params, err error) { for name, options := range in { opt, ok := fs.OptionsRegistry[name] if !ok { return nil, fmt.Errorf("unknown option block %q", name) } err := Reshape(opt.Opt, options) if err != nil { return nil, fmt.Errorf("failed to write options from block %q: %w", name, err) } if opt.Reload != nil { err = opt.Reload(ctx) if err != nil { return nil, fmt.Errorf("failed to reload options from block %q: %w", name, err) } } } return out, nil } rclone-v1.71.0/fs/rc/config_test.go000066400000000000000000000115411505210326400171170ustar00rootroot00000000000000package rc import ( "context" "encoding/json" "errors" "fmt" "testing" "github.com/rclone/rclone/fs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func clearOptionBlock() func() { oldOptionBlock := fs.OptionsRegistry fs.OptionsRegistry = map[string]fs.OptionsInfo{} return func() { fs.OptionsRegistry = oldOptionBlock } } var testInfo = fs.Options{{ Name: "string", Default: "str", Help: "It is a string", }, { Name: "int", Default: 17, Help: "It is an int", }} var testOptions = struct { String string Int int }{ String: "hello", Int: 42, } func registerTestOptions() { fs.RegisterGlobalOptions(fs.OptionsInfo{Name: "potato", Opt: &testOptions, Options: testInfo}) } func registerTestOptionsReload(reload func(context.Context) error) { fs.RegisterGlobalOptions(fs.OptionsInfo{Name: "potato", Opt: &testOptions, Options: testInfo, Reload: reload}) } func TestAddOption(t *testing.T) { defer clearOptionBlock()() assert.Equal(t, len(fs.OptionsRegistry), 0) registerTestOptions() assert.Equal(t, len(fs.OptionsRegistry), 1) assert.Equal(t, &testOptions, fs.OptionsRegistry["potato"].Opt) } func TestAddOptionReload(t *testing.T) { defer clearOptionBlock()() assert.Equal(t, len(fs.OptionsRegistry), 0) reload := func(ctx context.Context) error { return nil } registerTestOptionsReload(reload) assert.Equal(t, len(fs.OptionsRegistry), 1) assert.Equal(t, &testOptions, fs.OptionsRegistry["potato"].Opt) assert.Equal(t, fmt.Sprintf("%p", reload), fmt.Sprintf("%p", fs.OptionsRegistry["potato"].Reload)) } func TestOptionsBlocks(t *testing.T) { defer clearOptionBlock()() registerTestOptions() call := Calls.Get("options/blocks") require.NotNil(t, call) in := Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, Params{"options": []string{"potato"}}, out) } func TestOptionsGet(t *testing.T) { defer clearOptionBlock()() registerTestOptions() call := Calls.Get("options/get") require.NotNil(t, call) in := Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, Params{"potato": &testOptions}, out) in = Params{"blocks": "sausage,potato,rhubarb"} out, err = call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, Params{"potato": &testOptions}, out) in = Params{"blocks": "sausage"} out, err = call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, Params{}, out) } func TestOptionsGetMarshal(t *testing.T) { defer clearOptionBlock()() ctx := context.Background() ci := fs.GetConfig(ctx) // Add some real options fs.RegisterGlobalOptions(fs.OptionsInfo{Name: "main", Opt: ci, Options: nil}) fs.RegisterGlobalOptions(fs.OptionsInfo{Name: "rc", Opt: &Opt, Options: nil}) // get them call := Calls.Get("options/get") require.NotNil(t, call) in := Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) // Check that they marshal _, err = json.Marshal(out) require.NoError(t, err) } func TestOptionsInfo(t *testing.T) { defer clearOptionBlock()() registerTestOptions() call := Calls.Get("options/info") require.NotNil(t, call) in := Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, Params{"potato": testInfo}, out) in = Params{"blocks": "sausage,potato,rhubarb"} out, err = call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, Params{"potato": testInfo}, out) in = Params{"blocks": "sausage"} out, err = call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, Params{}, out) } func TestOptionsSet(t *testing.T) { defer clearOptionBlock()() var reloaded int registerTestOptionsReload(func(ctx context.Context) error { if reloaded > 1 { return errors.New("error while reloading") } reloaded++ return nil }) call := Calls.Get("options/set") require.NotNil(t, call) in := Params{ "potato": Params{ "Int": 50, }, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.Nil(t, out) assert.Equal(t, 50, testOptions.Int) assert.Equal(t, "str", testOptions.String) assert.Equal(t, 2, reloaded) // error from reload _, err = call.Fn(context.Background(), in) require.Error(t, err) assert.Contains(t, err.Error(), "error while reloading") // unknown option block in = Params{ "sausage": Params{ "Int": 50, }, } _, err = call.Fn(context.Background(), in) require.Error(t, err) assert.Contains(t, err.Error(), "unknown option block") // bad shape in = Params{ "potato": []string{"a", "b"}, } _, err = call.Fn(context.Background(), in) require.Error(t, err) assert.Contains(t, err.Error(), "failed to write options") } rclone-v1.71.0/fs/rc/internal.go000066400000000000000000000354361505210326400164400ustar00rootroot00000000000000// Define the internal rc functions package rc import ( "context" "fmt" "net/http" "os" "os/exec" "runtime" "strings" "time" "github.com/coreos/go-semver/semver" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/obscure" "github.com/rclone/rclone/lib/atexit" "github.com/rclone/rclone/lib/buildinfo" "github.com/rclone/rclone/lib/debug" ) func init() { Add(Call{ Path: "rc/noopauth", AuthRequired: true, Fn: rcNoop, Title: "Echo the input to the output parameters requiring auth", Help: ` This echoes the input parameters to the output parameters for testing purposes. It can be used to check that rclone is still alive and to check that parameter passing is working properly.`, }) Add(Call{ Path: "rc/noop", Fn: rcNoop, Title: "Echo the input to the output parameters", Help: ` This echoes the input parameters to the output parameters for testing purposes. It can be used to check that rclone is still alive and to check that parameter passing is working properly.`, }) } // Echo the input to the output parameters func rcNoop(ctx context.Context, in Params) (out Params, err error) { return in, nil } func init() { Add(Call{ Path: "rc/error", Fn: rcError, Title: "This returns an error", Help: ` This returns an error with the input as part of its error string. Useful for testing error handling.`, }) } // Return an error regardless func rcError(ctx context.Context, in Params) (out Params, err error) { return nil, fmt.Errorf("arbitrary error on input %+v", in) } func init() { Add(Call{ Path: "rc/list", Fn: rcList, Title: "List all the registered remote control commands", Help: ` This lists all the registered remote control commands as a JSON map in the commands response.`, }) } // List the registered commands func rcList(ctx context.Context, in Params) (out Params, err error) { out = make(Params) out["commands"] = Calls.List() return out, nil } func init() { Add(Call{ Path: "core/pid", Fn: rcPid, Title: "Return PID of current process", Help: ` This returns PID of current process. Useful for stopping rclone process.`, }) } // Return PID of current process func rcPid(ctx context.Context, in Params) (out Params, err error) { out = make(Params) out["pid"] = os.Getpid() return out, nil } func init() { Add(Call{ Path: "core/memstats", Fn: rcMemStats, Title: "Returns the memory statistics", Help: ` This returns the memory statistics of the running program. What the values mean are explained in the go docs: https://golang.org/pkg/runtime/#MemStats The most interesting values for most people are: - HeapAlloc - this is the amount of memory rclone is actually using - HeapSys - this is the amount of memory rclone has obtained from the OS - Sys - this is the total amount of memory requested from the OS - It is virtual memory so may include unused memory `, }) } // Return the memory statistics func rcMemStats(ctx context.Context, in Params) (out Params, err error) { out = make(Params) var m runtime.MemStats runtime.ReadMemStats(&m) out["Alloc"] = m.Alloc out["TotalAlloc"] = m.TotalAlloc out["Sys"] = m.Sys out["Mallocs"] = m.Mallocs out["Frees"] = m.Frees out["HeapAlloc"] = m.HeapAlloc out["HeapSys"] = m.HeapSys out["HeapIdle"] = m.HeapIdle out["HeapInuse"] = m.HeapInuse out["HeapReleased"] = m.HeapReleased out["HeapObjects"] = m.HeapObjects out["StackInuse"] = m.StackInuse out["StackSys"] = m.StackSys out["MSpanInuse"] = m.MSpanInuse out["MSpanSys"] = m.MSpanSys out["MCacheInuse"] = m.MCacheInuse out["MCacheSys"] = m.MCacheSys out["BuckHashSys"] = m.BuckHashSys out["GCSys"] = m.GCSys out["OtherSys"] = m.OtherSys return out, nil } func init() { Add(Call{ Path: "core/gc", Fn: rcGc, Title: "Runs a garbage collection.", Help: ` This tells the go runtime to do a garbage collection run. It isn't necessary to call this normally, but it can be useful for debugging memory problems. `, }) } // Do a garbage collection run func rcGc(ctx context.Context, in Params) (out Params, err error) { runtime.GC() return nil, nil } func init() { Add(Call{ Path: "core/version", Fn: rcVersion, Title: "Shows the current version of rclone and the go runtime.", Help: ` This shows the current version of go and the go runtime: - version - rclone version, e.g. "v1.53.0" - decomposed - version number as [major, minor, patch] - isGit - boolean - true if this was compiled from the git version - isBeta - boolean - true if this is a beta version - os - OS in use as according to Go - arch - cpu architecture in use according to Go - goVersion - version of Go runtime in use - linking - type of rclone executable (static or dynamic) - goTags - space separated build tags or "none" `, }) } // Return version info func rcVersion(ctx context.Context, in Params) (out Params, err error) { version, err := semver.NewVersion(fs.Version[1:]) if err != nil { return nil, err } linking, tagString := buildinfo.GetLinkingAndTags() out = Params{ "version": fs.Version, "decomposed": version.Slice(), "isGit": strings.HasSuffix(fs.Version, "-DEV"), "isBeta": version.PreRelease != "", "os": runtime.GOOS, "arch": runtime.GOARCH, "goVersion": runtime.Version(), "linking": linking, "goTags": tagString, } return out, nil } func init() { Add(Call{ Path: "core/obscure", Fn: rcObscure, Title: "Obscures a string passed in.", Help: ` Pass a clear string and rclone will obscure it for the config file: - clear - string Returns: - obscured - string `, }) } // Return obscured string func rcObscure(ctx context.Context, in Params) (out Params, err error) { clear, err := in.GetString("clear") if err != nil { return nil, err } obscured, err := obscure.Obscure(clear) if err != nil { return nil, err } out = Params{ "obscured": obscured, } return out, nil } func init() { Add(Call{ Path: "core/quit", Fn: rcQuit, Title: "Terminates the app.", Help: ` (Optional) Pass an exit code to be used for terminating the app: - exitCode - int `, }) } // Terminates app func rcQuit(ctx context.Context, in Params) (out Params, err error) { code, err := in.GetInt64("exitCode") if IsErrParamInvalid(err) { return nil, err } if IsErrParamNotFound(err) { code = 0 } exitCode := int(code) go func(exitCode int) { time.Sleep(time.Millisecond * 1500) atexit.Run() os.Exit(exitCode) }(exitCode) return nil, nil } func init() { Add(Call{ Path: "debug/set-mutex-profile-fraction", Fn: rcSetMutexProfileFraction, Title: "Set runtime.SetMutexProfileFraction for mutex profiling.", Help: ` SetMutexProfileFraction controls the fraction of mutex contention events that are reported in the mutex profile. On average 1/rate events are reported. The previous rate is returned. To turn off profiling entirely, pass rate 0. To just read the current rate, pass rate < 0. (For n>1 the details of sampling may change.) Once this is set you can look use this to profile the mutex contention: go tool pprof http://localhost:5572/debug/pprof/mutex Parameters: - rate - int Results: - previousRate - int `, }) } func rcSetMutexProfileFraction(ctx context.Context, in Params) (out Params, err error) { rate, err := in.GetInt64("rate") if err != nil { return nil, err } previousRate := runtime.SetMutexProfileFraction(int(rate)) out = make(Params) out["previousRate"] = previousRate return out, nil } func init() { Add(Call{ Path: "debug/set-block-profile-rate", Fn: rcSetBlockProfileRate, Title: "Set runtime.SetBlockProfileRate for blocking profiling.", Help: ` SetBlockProfileRate controls the fraction of goroutine blocking events that are reported in the blocking profile. The profiler aims to sample an average of one blocking event per rate nanoseconds spent blocked. To include every blocking event in the profile, pass rate = 1. To turn off profiling entirely, pass rate <= 0. After calling this you can use this to see the blocking profile: go tool pprof http://localhost:5572/debug/pprof/block Parameters: - rate - int `, }) } func rcSetBlockProfileRate(ctx context.Context, in Params) (out Params, err error) { rate, err := in.GetInt64("rate") if err != nil { return nil, err } runtime.SetBlockProfileRate(int(rate)) return nil, nil } func init() { Add(Call{ Path: "debug/set-soft-memory-limit", Fn: rcSetSoftMemoryLimit, Title: "Call runtime/debug.SetMemoryLimit for setting a soft memory limit for the runtime.", Help: ` SetMemoryLimit provides the runtime with a soft memory limit. The runtime undertakes several processes to try to respect this memory limit, including adjustments to the frequency of garbage collections and returning memory to the underlying system more aggressively. This limit will be respected even if GOGC=off (or, if SetGCPercent(-1) is executed). The input limit is provided as bytes, and includes all memory mapped, managed, and not released by the Go runtime. Notably, it does not account for space used by the Go binary and memory external to Go, such as memory managed by the underlying system on behalf of the process, or memory managed by non-Go code inside the same process. Examples of excluded memory sources include: OS kernel memory held on behalf of the process, memory allocated by C code, and memory mapped by syscall.Mmap (because it is not managed by the Go runtime). A zero limit or a limit that's lower than the amount of memory used by the Go runtime may cause the garbage collector to run nearly continuously. However, the application may still make progress. The memory limit is always respected by the Go runtime, so to effectively disable this behavior, set the limit very high. math.MaxInt64 is the canonical value for disabling the limit, but values much greater than the available memory on the underlying system work just as well. See https://go.dev/doc/gc-guide for a detailed guide explaining the soft memory limit in more detail, as well as a variety of common use-cases and scenarios. SetMemoryLimit returns the previously set memory limit. A negative input does not adjust the limit, and allows for retrieval of the currently set memory limit. Parameters: - mem-limit - int `, }) } func rcSetSoftMemoryLimit(ctx context.Context, in Params) (out Params, err error) { memLimit, err := in.GetInt64("mem-limit") if err != nil { return nil, err } oldMemLimit := debug.SetMemoryLimit(memLimit) out = Params{ "existing-mem-limit": oldMemLimit, } return out, nil } func init() { Add(Call{ Path: "debug/set-gc-percent", Fn: rcSetGCPercent, Title: "Call runtime/debug.SetGCPercent for setting the garbage collection target percentage.", Help: ` SetGCPercent sets the garbage collection target percentage: a collection is triggered when the ratio of freshly allocated data to live data remaining after the previous collection reaches this percentage. SetGCPercent returns the previous setting. The initial setting is the value of the GOGC environment variable at startup, or 100 if the variable is not set. This setting may be effectively reduced in order to maintain a memory limit. A negative percentage effectively disables garbage collection, unless the memory limit is reached. See https://pkg.go.dev/runtime/debug#SetMemoryLimit for more details. Parameters: - gc-percent - int `, }) } func rcSetGCPercent(ctx context.Context, in Params) (out Params, err error) { gcPercent, err := in.GetInt64("gc-percent") if err != nil { return nil, err } oldGCPercent := debug.SetGCPercent(int(gcPercent)) out = Params{ "existing-gc-percent": oldGCPercent, } return out, nil } func init() { Add(Call{ Path: "core/command", AuthRequired: true, Fn: rcRunCommand, NeedsRequest: true, NeedsResponse: true, Title: "Run a rclone terminal command over rc.", Help: `This takes the following parameters: - command - a string with the command name. - arg - a list of arguments for the backend command. - opt - a map of string to string of options. - returnType - one of ("COMBINED_OUTPUT", "STREAM", "STREAM_ONLY_STDOUT", "STREAM_ONLY_STDERR"). - Defaults to "COMBINED_OUTPUT" if not set. - The STREAM returnTypes will write the output to the body of the HTTP message. - The COMBINED_OUTPUT will write the output to the "result" parameter. Returns: - result - result from the backend command. - Only set when using returnType "COMBINED_OUTPUT". - error - set if rclone exits with an error code. - returnType - one of ("COMBINED_OUTPUT", "STREAM", "STREAM_ONLY_STDOUT", "STREAM_ONLY_STDERR"). Example: rclone rc core/command command=ls -a mydrive:/ -o max-depth=1 rclone rc core/command -a ls -a mydrive:/ -o max-depth=1 Returns: ` + "```" + ` { "error": false, "result": "" } OR { "error": true, "result": "" } ` + "```" + ` `, }) } // rcRunCommand runs an rclone command with the given args and flags func rcRunCommand(ctx context.Context, in Params) (out Params, err error) { command, err := in.GetString("command") if err != nil { command = "" } var opt = map[string]string{} err = in.GetStructMissingOK("opt", &opt) if err != nil { return nil, err } var arg = []string{} err = in.GetStructMissingOK("arg", &arg) if err != nil { return nil, err } returnType, err := in.GetString("returnType") if err != nil { returnType = "COMBINED_OUTPUT" } var httpResponse http.ResponseWriter httpResponse, err = in.GetHTTPResponseWriter() if err != nil { return nil, fmt.Errorf("response object is required\n%w", err) } var allArgs = []string{} if command != "" { // Add the command e.g.: ls to the args allArgs = append(allArgs, command) } // Add all from arg allArgs = append(allArgs, arg...) // Add flags to args for e.g. --max-depth 1 comes in as { max-depth 1 }. // Convert it to [ max-depth, 1 ] and append to args list for key, value := range opt { if len(key) == 1 { allArgs = append(allArgs, "-"+key) } else { allArgs = append(allArgs, "--"+key) } allArgs = append(allArgs, value) } // Get the path for the current executable which was used to run rclone. ex, err := os.Executable() if err != nil { return nil, err } cmd := exec.CommandContext(ctx, ex, allArgs...) if returnType == "COMBINED_OUTPUT" { // Run the command and get the output for error and stdout combined. out, err := cmd.CombinedOutput() if err != nil { return Params{ "result": string(out), "error": true, }, nil } return Params{ "result": string(out), "error": false, }, nil } else if returnType == "STREAM_ONLY_STDOUT" { cmd.Stdout = httpResponse } else if returnType == "STREAM_ONLY_STDERR" { cmd.Stderr = httpResponse } else if returnType == "STREAM" { cmd.Stdout = httpResponse cmd.Stderr = httpResponse } else { return nil, fmt.Errorf("unknown returnType %q", returnType) } err = cmd.Run() return nil, err } rclone-v1.71.0/fs/rc/internal_test.go000066400000000000000000000115451505210326400174720ustar00rootroot00000000000000package rc import ( "context" "fmt" "net/http" "net/http/httptest" "os" "runtime" "strings" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/obscure" ) func TestMain(m *testing.M) { // Pretend to be rclone version if we have a version string parameter if os.Args[len(os.Args)-1] == "version" { fmt.Printf("rclone %s\n", fs.Version) os.Exit(0) } // Pretend to error if we have an unknown command if os.Args[len(os.Args)-1] == "unknown_command" { fmt.Printf("rclone %s\n", fs.Version) fmt.Fprintf(os.Stderr, "Unknown command\n") os.Exit(1) } os.Exit(m.Run()) } func TestInternalNoop(t *testing.T) { call := Calls.Get("rc/noop") assert.NotNil(t, call) in := Params{ "String": "hello", "Int": 42, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, in, out) } func TestInternalError(t *testing.T) { call := Calls.Get("rc/error") assert.NotNil(t, call) in := Params{} out, err := call.Fn(context.Background(), in) require.Error(t, err) require.Nil(t, out) } func TestInternalList(t *testing.T) { call := Calls.Get("rc/list") assert.NotNil(t, call) in := Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, Params{"commands": Calls.List()}, out) } func TestCorePid(t *testing.T) { call := Calls.Get("core/pid") assert.NotNil(t, call) in := Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) pid := out["pid"] assert.NotEqual(t, nil, pid) _, ok := pid.(int) assert.Equal(t, true, ok) } func TestCoreMemstats(t *testing.T) { call := Calls.Get("core/memstats") assert.NotNil(t, call) in := Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) sys := out["Sys"] assert.NotEqual(t, nil, sys) _, ok := sys.(uint64) assert.Equal(t, true, ok) } func TestCoreGC(t *testing.T) { call := Calls.Get("core/gc") assert.NotNil(t, call) in := Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.Nil(t, out) assert.Equal(t, Params(nil), out) } func TestCoreVersion(t *testing.T) { call := Calls.Get("core/version") assert.NotNil(t, call) in := Params{} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, fs.Version, out["version"]) assert.Equal(t, runtime.GOOS, out["os"]) assert.Equal(t, runtime.GOARCH, out["arch"]) assert.Equal(t, runtime.Version(), out["goVersion"]) _ = out["isGit"].(bool) v := out["decomposed"].([]int64) assert.True(t, len(v) >= 2) } func TestCoreObscure(t *testing.T) { call := Calls.Get("core/obscure") assert.NotNil(t, call) in := Params{ "clear": "potato", } out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, in["clear"], obscure.MustReveal(out["obscured"].(string))) } func TestCoreQuit(t *testing.T) { //The call should return an error if param exitCode is not parsed to int call := Calls.Get("core/quit") assert.NotNil(t, call) in := Params{ "exitCode": "potato", } _, err := call.Fn(context.Background(), in) require.Error(t, err) } // core/command: Runs a raw rclone command func TestCoreCommand(t *testing.T) { call := Calls.Get("core/command") test := func(command string, returnType string, wantOutput string, fail bool) { var rec = httptest.NewRecorder() var w http.ResponseWriter = rec in := Params{ "command": command, "opt": map[string]string{}, "arg": []string{}, "_response": w, } if returnType != "" { in["returnType"] = returnType } else { returnType = "COMBINED_OUTPUT" } stream := strings.HasPrefix(returnType, "STREAM") got, err := call.Fn(context.Background(), in) if stream && fail { assert.Error(t, err) } else { assert.NoError(t, err) } if !stream { assert.Equal(t, wantOutput, got["result"]) assert.Equal(t, fail, got["error"]) } else { assert.Equal(t, wantOutput, rec.Body.String()) } assert.Equal(t, http.StatusOK, rec.Result().StatusCode) } version := fmt.Sprintf("rclone %s\n", fs.Version) errorString := "Unknown command\n" t.Run("OK", func(t *testing.T) { test("version", "", version, false) }) t.Run("Fail", func(t *testing.T) { test("unknown_command", "", version+errorString, true) }) t.Run("Combined", func(t *testing.T) { test("unknown_command", "COMBINED_OUTPUT", version+errorString, true) }) t.Run("Stderr", func(t *testing.T) { test("unknown_command", "STREAM_ONLY_STDERR", errorString, true) }) t.Run("Stdout", func(t *testing.T) { test("unknown_command", "STREAM_ONLY_STDOUT", version, true) }) t.Run("Stream", func(t *testing.T) { test("unknown_command", "STREAM", version+errorString, true) }) } rclone-v1.71.0/fs/rc/jobs/000077500000000000000000000000001505210326400152175ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/jobs/job.go000066400000000000000000000257701505210326400163330ustar00rootroot00000000000000// Package jobs manages background jobs that the rc is running. package jobs import ( "context" "errors" "fmt" "runtime/debug" "slices" "sync" "sync/atomic" "time" "github.com/google/uuid" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/rc" ) // Fill in these to avoid circular dependencies func init() { cache.JobOnFinish = OnFinish cache.JobGetJobID = GetJobID } // Job describes an asynchronous task started via the rc package type Job struct { mu sync.Mutex ID int64 `json:"id"` Group string `json:"group"` StartTime time.Time `json:"startTime"` EndTime time.Time `json:"endTime"` Error string `json:"error"` Finished bool `json:"finished"` Success bool `json:"success"` Duration float64 `json:"duration"` Output rc.Params `json:"output"` Stop func() `json:"-"` listeners []*func() // realErr is the Error before printing it as a string, it's used to return // the real error to the upper application layers while still printing the // string error message. realErr error } // mark the job as finished func (job *Job) finish(out rc.Params, err error) { job.mu.Lock() job.EndTime = time.Now() if out == nil { out = make(rc.Params) } job.Output = out job.Duration = job.EndTime.Sub(job.StartTime).Seconds() if err != nil { job.realErr = err job.Error = err.Error() job.Success = false } else { job.realErr = nil job.Error = "" job.Success = true } job.Finished = true // Notify listeners that the job is finished for i := range job.listeners { go (*job.listeners[i])() } job.mu.Unlock() running.kickExpire() // make sure this job gets expired } func (job *Job) removeListener(fn *func()) { job.mu.Lock() defer job.mu.Unlock() for i, ln := range job.listeners { if ln == fn { job.listeners = slices.Delete(job.listeners, i, i+1) return } } } // OnFinish adds listener to job that will be triggered when job is finished. // It returns a function to cancel listening. func (job *Job) OnFinish(fn func()) func() { job.mu.Lock() defer job.mu.Unlock() if job.Finished { go fn() } else { job.listeners = append(job.listeners, &fn) } return func() { job.removeListener(&fn) } } // run the job until completion writing the return status func (job *Job) run(ctx context.Context, fn rc.Func, in rc.Params) { defer func() { if r := recover(); r != nil { job.finish(nil, fmt.Errorf("panic received: %v \n%s", r, string(debug.Stack()))) } }() job.finish(fn(ctx, in)) } // Jobs describes a collection of running tasks type Jobs struct { mu sync.RWMutex jobs map[int64]*Job opt *rc.Options expireRunning bool } var ( running = newJobs() jobID atomic.Int64 executeID = uuid.New().String() ) // newJobs makes a new Jobs structure func newJobs() *Jobs { return &Jobs{ jobs: map[int64]*Job{}, opt: &rc.Opt, } } // SetOpt sets the options when they are known func SetOpt(opt *rc.Options) { running.opt = opt } // SetInitialJobID allows for setting jobID before starting any jobs. func SetInitialJobID(id int64) { if !jobID.CompareAndSwap(0, id) { panic("Setting jobID is only possible before starting any jobs") } } // kickExpire makes sure Expire is running func (jobs *Jobs) kickExpire() { jobs.mu.Lock() defer jobs.mu.Unlock() if !jobs.expireRunning { time.AfterFunc(time.Duration(jobs.opt.JobExpireInterval), jobs.Expire) jobs.expireRunning = true } } // Expire expires any jobs that haven't been collected func (jobs *Jobs) Expire() { jobs.mu.Lock() defer jobs.mu.Unlock() now := time.Now() for ID, job := range jobs.jobs { job.mu.Lock() if job.Finished && now.Sub(job.EndTime) > time.Duration(jobs.opt.JobExpireDuration) { delete(jobs.jobs, ID) } job.mu.Unlock() } if len(jobs.jobs) != 0 { time.AfterFunc(time.Duration(jobs.opt.JobExpireInterval), jobs.Expire) jobs.expireRunning = true } else { jobs.expireRunning = false } } // IDs returns the IDs of the running jobs func (jobs *Jobs) IDs() (IDs []int64) { jobs.mu.RLock() defer jobs.mu.RUnlock() IDs = []int64{} for ID := range jobs.jobs { IDs = append(IDs, ID) } return IDs } // Get a job with a given ID or nil if it doesn't exist func (jobs *Jobs) Get(ID int64) *Job { jobs.mu.RLock() defer jobs.mu.RUnlock() return jobs.jobs[ID] } // Check to see if the group is set func getGroup(ctx context.Context, in rc.Params, id int64) (context.Context, string, error) { group, err := in.GetString("_group") if rc.NotErrParamNotFound(err) { return ctx, "", err } delete(in, "_group") if group == "" { group = fmt.Sprintf("job/%d", id) } ctx = accounting.WithStatsGroup(ctx, group) return ctx, group, nil } // See if _async is set returning a boolean and a possible new context func getAsync(ctx context.Context, in rc.Params) (context.Context, bool, error) { isAsync, err := in.GetBool("_async") if rc.NotErrParamNotFound(err) { return ctx, false, err } delete(in, "_async") // remove the async parameter after parsing if isAsync { // unlink this job from the current context ctx = context.Background() } return ctx, isAsync, nil } // See if _config is set and if so adjust ctx to include it func getConfig(ctx context.Context, in rc.Params) (context.Context, error) { if _, ok := in["_config"]; !ok { return ctx, nil } ctx, ci := fs.AddConfig(ctx) err := in.GetStruct("_config", ci) if err != nil { return ctx, err } delete(in, "_config") // remove the parameter return ctx, nil } // See if _filter is set and if so adjust ctx to include it func getFilter(ctx context.Context, in rc.Params) (context.Context, error) { if _, ok := in["_filter"]; !ok { return ctx, nil } // Copy of the current filter options opt := filter.GetConfig(ctx).Opt // Update the options from the parameter err := in.GetStruct("_filter", &opt) if err != nil { return ctx, err } fi, err := filter.NewFilter(&opt) if err != nil { return ctx, err } ctx = filter.ReplaceConfig(ctx, fi) delete(in, "_filter") // remove the parameter return ctx, nil } type jobKeyType struct{} // Key for adding jobs to ctx var jobKey = jobKeyType{} // NewJob creates a Job and executes it, possibly in the background if _async is set func (jobs *Jobs) NewJob(ctx context.Context, fn rc.Func, in rc.Params) (job *Job, out rc.Params, err error) { id := jobID.Add(1) in = in.Copy() // copy input so we can change it ctx, isAsync, err := getAsync(ctx, in) if err != nil { return nil, nil, err } ctx, err = getConfig(ctx, in) if err != nil { return nil, nil, err } ctx, err = getFilter(ctx, in) if err != nil { return nil, nil, err } ctx, group, err := getGroup(ctx, in, id) if err != nil { return nil, nil, err } ctx, cancel := context.WithCancel(ctx) stop := func() { cancel() // Wait for cancel to propagate before returning. <-ctx.Done() } job = &Job{ ID: id, Group: group, StartTime: time.Now(), Stop: stop, } jobs.mu.Lock() jobs.jobs[job.ID] = job jobs.mu.Unlock() // Add the job to the context ctx = context.WithValue(ctx, jobKey, job) if isAsync { go job.run(ctx, fn, in) out = make(rc.Params) out["jobid"] = job.ID err = nil } else { job.run(ctx, fn, in) out = job.Output err = job.realErr } return job, out, err } // NewJob creates a Job and executes it on the global job queue, // possibly in the background if _async is set func NewJob(ctx context.Context, fn rc.Func, in rc.Params) (job *Job, out rc.Params, err error) { return running.NewJob(ctx, fn, in) } // OnFinish adds listener to jobid that will be triggered when job is finished. // It returns a function to cancel listening. func OnFinish(jobID int64, fn func()) (func(), error) { job := running.Get(jobID) if job == nil { return func() {}, errors.New("job not found") } return job.OnFinish(fn), nil } // GetJob gets the Job from the context if possible func GetJob(ctx context.Context) (job *Job, ok bool) { job, ok = ctx.Value(jobKey).(*Job) return job, ok } // GetJobID gets the Job from the context if possible func GetJobID(ctx context.Context) (jobID int64, ok bool) { job, ok := GetJob(ctx) if !ok { return -1, ok } return job.ID, true } func init() { rc.Add(rc.Call{ Path: "job/status", Fn: rcJobStatus, Title: "Reads the status of the job ID", Help: `Parameters: - jobid - id of the job (integer). Results: - finished - boolean - duration - time in seconds that the job ran for - endTime - time the job finished (e.g. "2018-10-26T18:50:20.528746884+01:00") - error - error from the job or empty string for no error - finished - boolean whether the job has finished or not - id - as passed in above - startTime - time the job started (e.g. "2018-10-26T18:50:20.528336039+01:00") - success - boolean - true for success false otherwise - output - output of the job as would have been returned if called synchronously - progress - output of the progress related to the underlying job `, }) } // Returns the status of a job func rcJobStatus(ctx context.Context, in rc.Params) (out rc.Params, err error) { jobID, err := in.GetInt64("jobid") if err != nil { return nil, err } job := running.Get(jobID) if job == nil { return nil, errors.New("job not found") } job.mu.Lock() defer job.mu.Unlock() out = make(rc.Params) err = rc.Reshape(&out, job) if err != nil { return nil, fmt.Errorf("reshape failed in job status: %w", err) } return out, nil } func init() { rc.Add(rc.Call{ Path: "job/list", Fn: rcJobList, Title: "Lists the IDs of the running jobs", Help: `Parameters: None. Results: - executeId - string id of rclone executing (change after restart) - jobids - array of integer job ids (starting at 1 on each restart) `, }) } // Returns list of job ids. func rcJobList(ctx context.Context, in rc.Params) (out rc.Params, err error) { out = make(rc.Params) out["jobids"] = running.IDs() out["executeId"] = executeID return out, nil } func init() { rc.Add(rc.Call{ Path: "job/stop", Fn: rcJobStop, Title: "Stop the running job", Help: `Parameters: - jobid - id of the job (integer). `, }) } // Stops the running job. func rcJobStop(ctx context.Context, in rc.Params) (out rc.Params, err error) { jobID, err := in.GetInt64("jobid") if err != nil { return nil, err } job := running.Get(jobID) if job == nil { return nil, errors.New("job not found") } job.mu.Lock() defer job.mu.Unlock() out = make(rc.Params) job.Stop() return out, nil } func init() { rc.Add(rc.Call{ Path: "job/stopgroup", Fn: rcGroupStop, Title: "Stop all running jobs in a group", Help: `Parameters: - group - name of the group (string). `, }) } // Stops all running jobs in a group func rcGroupStop(ctx context.Context, in rc.Params) (out rc.Params, err error) { group, err := in.GetString("group") if err != nil { return nil, err } running.mu.RLock() defer running.mu.RUnlock() for _, job := range running.jobs { if job.Group == group { job.mu.Lock() job.Stop() job.mu.Unlock() } } out = make(rc.Params) return out, nil } rclone-v1.71.0/fs/rc/jobs/job_test.go000066400000000000000000000372101505210326400173620ustar00rootroot00000000000000package jobs import ( "context" "errors" "runtime" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/rc" "github.com/rclone/rclone/fstest/testy" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestNewJobs(t *testing.T) { jobs := newJobs() assert.Equal(t, 0, len(jobs.jobs)) } func TestJobsKickExpire(t *testing.T) { testy.SkipUnreliable(t) jobs := newJobs() jobs.opt.JobExpireInterval = fs.Duration(time.Millisecond) assert.Equal(t, false, jobs.expireRunning) jobs.kickExpire() jobs.mu.Lock() assert.Equal(t, true, jobs.expireRunning) jobs.mu.Unlock() time.Sleep(10 * time.Millisecond) jobs.mu.Lock() assert.Equal(t, false, jobs.expireRunning) jobs.mu.Unlock() } func TestJobsExpire(t *testing.T) { testy.SkipUnreliable(t) ctx := context.Background() wait := make(chan struct{}) jobs := newJobs() jobs.opt.JobExpireInterval = fs.Duration(time.Millisecond) assert.Equal(t, false, jobs.expireRunning) var gotJobID int64 var gotJob *Job job, out, err := jobs.NewJob(ctx, func(ctx context.Context, in rc.Params) (rc.Params, error) { defer close(wait) var ok bool gotJobID, ok = GetJobID(ctx) assert.True(t, ok) gotJob, ok = GetJob(ctx) assert.True(t, ok) return in, nil }, rc.Params{"_async": true}) require.NoError(t, err) assert.Equal(t, 1, len(out)) <-wait assert.Equal(t, job.ID, gotJobID, "check can get JobID from ctx") assert.Equal(t, job, gotJob, "check can get Job from ctx") assert.Equal(t, 1, len(jobs.jobs)) jobs.Expire() assert.Equal(t, 1, len(jobs.jobs)) jobs.mu.Lock() job.mu.Lock() job.EndTime = time.Now().Add(-time.Duration(rc.Opt.JobExpireDuration) - 60*time.Second) assert.Equal(t, true, jobs.expireRunning) job.mu.Unlock() jobs.mu.Unlock() time.Sleep(250 * time.Millisecond) jobs.mu.Lock() assert.Equal(t, false, jobs.expireRunning) assert.Equal(t, 0, len(jobs.jobs)) jobs.mu.Unlock() } var noopFn = func(ctx context.Context, in rc.Params) (rc.Params, error) { return nil, nil } func TestJobsIDs(t *testing.T) { ctx := context.Background() jobs := newJobs() job1, _, err := jobs.NewJob(ctx, noopFn, rc.Params{"_async": true}) require.NoError(t, err) job2, _, err := jobs.NewJob(ctx, noopFn, rc.Params{"_async": true}) require.NoError(t, err) wantIDs := []int64{job1.ID, job2.ID} gotIDs := jobs.IDs() require.Equal(t, 2, len(gotIDs)) if gotIDs[0] != wantIDs[0] { gotIDs[0], gotIDs[1] = gotIDs[1], gotIDs[0] } assert.Equal(t, wantIDs, gotIDs) } func TestJobsGet(t *testing.T) { ctx := context.Background() jobs := newJobs() job, _, err := jobs.NewJob(ctx, noopFn, rc.Params{"_async": true}) require.NoError(t, err) assert.Equal(t, job, jobs.Get(job.ID)) assert.Nil(t, jobs.Get(123123123123)) } var longFn = func(ctx context.Context, in rc.Params) (rc.Params, error) { time.Sleep(1 * time.Hour) return nil, nil } var shortFn = func(ctx context.Context, in rc.Params) (rc.Params, error) { time.Sleep(time.Millisecond) return nil, nil } var ctxFn = func(ctx context.Context, in rc.Params) (rc.Params, error) { <-ctx.Done() return nil, ctx.Err() } var ctxParmFn = func(paramCtx context.Context, returnError bool) func(ctx context.Context, in rc.Params) (rc.Params, error) { return func(ctx context.Context, in rc.Params) (rc.Params, error) { <-paramCtx.Done() if returnError { return nil, ctx.Err() } return rc.Params{}, nil } } const ( sleepTime = 100 * time.Millisecond floatSleepTime = float64(sleepTime) / 1e9 / 2 ) // sleep for some time so job.Duration is non-0 func sleepJob() { time.Sleep(sleepTime) } func TestJobFinish(t *testing.T) { ctx := context.Background() jobs := newJobs() job, _, err := jobs.NewJob(ctx, longFn, rc.Params{"_async": true}) require.NoError(t, err) sleepJob() assert.Equal(t, true, job.EndTime.IsZero()) assert.Equal(t, rc.Params(nil), job.Output) assert.Equal(t, 0.0, job.Duration) assert.Equal(t, "", job.Error) assert.Equal(t, false, job.Success) assert.Equal(t, false, job.Finished) wantOut := rc.Params{"a": 1} job.finish(wantOut, nil) assert.Equal(t, false, job.EndTime.IsZero()) assert.Equal(t, wantOut, job.Output) assert.True(t, job.Duration >= floatSleepTime) assert.Equal(t, "", job.Error) assert.Equal(t, true, job.Success) assert.Equal(t, true, job.Finished) job, _, err = jobs.NewJob(ctx, longFn, rc.Params{"_async": true}) require.NoError(t, err) sleepJob() job.finish(nil, nil) assert.Equal(t, false, job.EndTime.IsZero()) assert.Equal(t, rc.Params{}, job.Output) assert.True(t, job.Duration >= floatSleepTime) assert.Equal(t, "", job.Error) assert.Equal(t, true, job.Success) assert.Equal(t, true, job.Finished) job, _, err = jobs.NewJob(ctx, longFn, rc.Params{"_async": true}) require.NoError(t, err) sleepJob() job.finish(wantOut, errors.New("potato")) assert.Equal(t, false, job.EndTime.IsZero()) assert.Equal(t, wantOut, job.Output) assert.True(t, job.Duration >= floatSleepTime) assert.Equal(t, "potato", job.Error) assert.Equal(t, false, job.Success) assert.Equal(t, true, job.Finished) } // We've tested the functionality of run() already as it is // part of NewJob, now just test the panic catching func TestJobRunPanic(t *testing.T) { ctx := context.Background() wait := make(chan struct{}) boom := func(ctx context.Context, in rc.Params) (rc.Params, error) { sleepJob() defer close(wait) panic("boom") } jobs := newJobs() job, _, err := jobs.NewJob(ctx, boom, rc.Params{"_async": true}) require.NoError(t, err) <-wait runtime.Gosched() // yield to make sure job is updated // Wait a short time for the panic to propagate for i := uint(0); i < 10; i++ { job.mu.Lock() e := job.Error job.mu.Unlock() if e != "" { break } time.Sleep(time.Millisecond << i) } job.mu.Lock() assert.Equal(t, false, job.EndTime.IsZero()) assert.Equal(t, rc.Params{}, job.Output) assert.True(t, job.Duration >= floatSleepTime) assert.Contains(t, job.Error, "panic received: boom") assert.Equal(t, false, job.Success) assert.Equal(t, true, job.Finished) job.mu.Unlock() } func TestJobsNewJob(t *testing.T) { ctx := context.Background() jobID.Store(0) jobs := newJobs() job, out, err := jobs.NewJob(ctx, noopFn, rc.Params{"_async": true}) require.NoError(t, err) assert.Equal(t, int64(1), job.ID) assert.Equal(t, rc.Params{"jobid": int64(1)}, out) assert.Equal(t, job, jobs.Get(1)) assert.NotEmpty(t, job.Stop) } func TestStartJob(t *testing.T) { ctx := context.Background() jobID.Store(0) job, out, err := NewJob(ctx, longFn, rc.Params{"_async": true}) assert.NoError(t, err) assert.Equal(t, rc.Params{"jobid": int64(1)}, out) assert.Equal(t, int64(1), job.ID) } func TestExecuteJob(t *testing.T) { jobID.Store(0) job, out, err := NewJob(context.Background(), shortFn, rc.Params{}) assert.NoError(t, err) assert.Equal(t, int64(1), job.ID) assert.Equal(t, rc.Params{}, out) } func TestExecuteJobWithConfig(t *testing.T) { ctx := context.Background() jobID.Store(0) called := false jobFn := func(ctx context.Context, in rc.Params) (rc.Params, error) { ci := fs.GetConfig(ctx) assert.Equal(t, 42*fs.Mebi, ci.BufferSize) called = true return nil, nil } _, _, err := NewJob(context.Background(), jobFn, rc.Params{ "_config": rc.Params{ "BufferSize": "42M", }, }) require.NoError(t, err) assert.Equal(t, true, called) // Retest with string parameter jobID.Store(0) called = false _, _, err = NewJob(ctx, jobFn, rc.Params{ "_config": `{"BufferSize": "42M"}`, }) require.NoError(t, err) assert.Equal(t, true, called) // Check that wasn't the default ci := fs.GetConfig(ctx) assert.NotEqual(t, 42*fs.Mebi, ci.BufferSize) } func TestExecuteJobWithFilter(t *testing.T) { ctx := context.Background() called := false jobID.Store(0) jobFn := func(ctx context.Context, in rc.Params) (rc.Params, error) { fi := filter.GetConfig(ctx) assert.Equal(t, fs.SizeSuffix(1024), fi.Opt.MaxSize) assert.Equal(t, []string{"a", "b", "c"}, fi.Opt.IncludeRule) called = true return nil, nil } _, _, err := NewJob(ctx, jobFn, rc.Params{ "_filter": rc.Params{ "IncludeRule": []string{"a", "b", "c"}, "MaxSize": "1k", }, }) require.NoError(t, err) assert.Equal(t, true, called) } func TestExecuteJobWithGroup(t *testing.T) { ctx := context.Background() jobID.Store(0) called := false jobFn := func(ctx context.Context, in rc.Params) (rc.Params, error) { called = true group, found := accounting.StatsGroupFromContext(ctx) assert.Equal(t, true, found) assert.Equal(t, "myparty", group) return nil, nil } _, _, err := NewJob(ctx, jobFn, rc.Params{ "_group": "myparty", }) require.NoError(t, err) assert.Equal(t, true, called) } func TestExecuteJobErrorPropagation(t *testing.T) { ctx := context.Background() jobID.Store(0) testErr := errors.New("test error") errorFn := func(ctx context.Context, in rc.Params) (out rc.Params, err error) { return nil, testErr } _, _, err := NewJob(ctx, errorFn, rc.Params{}) assert.Equal(t, testErr, err) } func TestRcJobStatus(t *testing.T) { ctx := context.Background() jobID.Store(0) _, _, err := NewJob(ctx, longFn, rc.Params{"_async": true}) assert.NoError(t, err) call := rc.Calls.Get("job/status") assert.NotNil(t, call) in := rc.Params{"jobid": 1} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, float64(1), out["id"]) assert.Equal(t, "", out["error"]) assert.Equal(t, false, out["finished"]) assert.Equal(t, false, out["success"]) in = rc.Params{"jobid": 123123123} _, err = call.Fn(context.Background(), in) require.Error(t, err) assert.Contains(t, err.Error(), "job not found") in = rc.Params{"jobidx": 123123123} _, err = call.Fn(context.Background(), in) require.Error(t, err) assert.Contains(t, err.Error(), "Didn't find key") } func TestRcJobList(t *testing.T) { ctx := context.Background() jobID.Store(0) _, _, err := NewJob(ctx, longFn, rc.Params{"_async": true}) assert.NoError(t, err) call := rc.Calls.Get("job/list") assert.NotNil(t, call) in := rc.Params{} out1, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out1) assert.Equal(t, []int64{1}, out1["jobids"], "should have job listed") _, _, err = NewJob(ctx, longFn, rc.Params{"_async": true}) assert.NoError(t, err) call = rc.Calls.Get("job/list") assert.NotNil(t, call) in = rc.Params{} out2, err := call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out2) assert.Equal(t, 2, len(out2["jobids"].([]int64)), "should have all jobs listed") require.NotNil(t, out1["executeId"], "should have executeId") assert.Equal(t, out1["executeId"], out2["executeId"], "executeId should be the same") } func TestRcAsyncJobStop(t *testing.T) { ctx := context.Background() jobID.Store(0) _, _, err := NewJob(ctx, ctxFn, rc.Params{"_async": true}) assert.NoError(t, err) call := rc.Calls.Get("job/stop") assert.NotNil(t, call) in := rc.Params{"jobid": 1} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.Empty(t, out) in = rc.Params{"jobid": 123123123} _, err = call.Fn(context.Background(), in) require.Error(t, err) assert.Contains(t, err.Error(), "job not found") in = rc.Params{"jobidx": 123123123} _, err = call.Fn(context.Background(), in) require.Error(t, err) assert.Contains(t, err.Error(), "Didn't find key") time.Sleep(10 * time.Millisecond) call = rc.Calls.Get("job/status") assert.NotNil(t, call) in = rc.Params{"jobid": 1} out, err = call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, float64(1), out["id"]) assert.Equal(t, "context canceled", out["error"]) assert.Equal(t, true, out["finished"]) assert.Equal(t, false, out["success"]) } func TestRcSyncJobStop(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) go func() { jobID.Store(0) job, out, err := NewJob(ctx, ctxFn, rc.Params{}) assert.Error(t, err) assert.Equal(t, int64(1), job.ID) assert.Equal(t, rc.Params{}, out) }() time.Sleep(10 * time.Millisecond) call := rc.Calls.Get("job/stop") assert.NotNil(t, call) in := rc.Params{"jobid": 1} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.Empty(t, out) in = rc.Params{"jobid": 123123123} _, err = call.Fn(context.Background(), in) require.Error(t, err) assert.Contains(t, err.Error(), "job not found") in = rc.Params{"jobidx": 123123123} _, err = call.Fn(context.Background(), in) require.Error(t, err) assert.Contains(t, err.Error(), "Didn't find key") cancel() time.Sleep(10 * time.Millisecond) call = rc.Calls.Get("job/status") assert.NotNil(t, call) in = rc.Params{"jobid": 1} out, err = call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, float64(1), out["id"]) assert.Equal(t, "context canceled", out["error"]) assert.Equal(t, true, out["finished"]) assert.Equal(t, false, out["success"]) } func TestRcJobStopGroup(t *testing.T) { ctx := context.Background() jobID.Store(0) _, _, err := NewJob(ctx, ctxFn, rc.Params{ "_async": true, "_group": "myparty", }) require.NoError(t, err) _, _, err = NewJob(ctx, ctxFn, rc.Params{ "_async": true, "_group": "myparty", }) require.NoError(t, err) call := rc.Calls.Get("job/stopgroup") assert.NotNil(t, call) in := rc.Params{"group": "myparty"} out, err := call.Fn(context.Background(), in) require.NoError(t, err) require.Empty(t, out) in = rc.Params{} _, err = call.Fn(context.Background(), in) require.Error(t, err) assert.Contains(t, err.Error(), "Didn't find key") time.Sleep(10 * time.Millisecond) call = rc.Calls.Get("job/status") assert.NotNil(t, call) for i := 1; i <= 2; i++ { in = rc.Params{"jobid": i} out, err = call.Fn(context.Background(), in) require.NoError(t, err) require.NotNil(t, out) assert.Equal(t, "myparty", out["group"]) assert.Equal(t, "context canceled", out["error"]) assert.Equal(t, true, out["finished"]) assert.Equal(t, false, out["success"]) } } func TestOnFinish(t *testing.T) { jobID.Store(0) done := make(chan struct{}) ctx, cancel := context.WithCancel(context.Background()) job, _, err := NewJob(ctx, ctxParmFn(ctx, false), rc.Params{"_async": true}) assert.NoError(t, err) stop, err := OnFinish(job.ID, func() { close(done) }) defer stop() assert.NoError(t, err) cancel() select { case <-done: case <-time.After(time.Second): t.Fatal("Timeout waiting for OnFinish to fire") } } func TestOnFinishAlreadyFinished(t *testing.T) { jobID.Store(0) done := make(chan struct{}) ctx, cancel := context.WithCancel(context.Background()) defer cancel() job, _, err := NewJob(ctx, shortFn, rc.Params{}) assert.NoError(t, err) stop, err := OnFinish(job.ID, func() { close(done) }) defer stop() assert.NoError(t, err) select { case <-done: case <-time.After(time.Second): t.Fatal("Timeout waiting for OnFinish to fire") } } func TestOnFinishDataRace(t *testing.T) { jobID.Store(0) job, _, err := NewJob(context.Background(), ctxFn, rc.Params{"_async": true}) assert.NoError(t, err) var expect, got uint64 finished := make(chan struct{}) stop, stopped := make(chan struct{}), make(chan struct{}) go func() { Loop: for { select { case <-stop: break Loop default: _, err := OnFinish(job.ID, func() { finished <- struct{}{} }) assert.NoError(t, err) expect += 1 } } close(stopped) }() time.Sleep(10 * time.Millisecond) job.Stop() // Wait for the first OnFinish to fire <-finished got += 1 // Stop the OnFinish producer close(stop) <-stopped timeout := time.After(5 * time.Second) for { if got == expect { break } select { case <-finished: got += 1 case <-timeout: t.Fatal("Timeout waiting for all OnFinish calls to fire") } } } rclone-v1.71.0/fs/rc/js/000077500000000000000000000000001505210326400146765ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/js/.gitignore000066400000000000000000000000071505210326400166630ustar00rootroot00000000000000*.wasm rclone-v1.71.0/fs/rc/js/LICENSE.wasmexec000066400000000000000000000027071505210326400175240ustar00rootroot00000000000000Copyright (c) 2018 The Go Authors. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Google Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. rclone-v1.71.0/fs/rc/js/Makefile000066400000000000000000000001231505210326400163320ustar00rootroot00000000000000build: GOARCH=wasm GOOS=js go build -o rclone.wasm serve: build go run serve.go rclone-v1.71.0/fs/rc/js/README.md000066400000000000000000000015251505210326400161600ustar00rootroot00000000000000# Rclone as WASM This directory contains files to use the rclone rc as a library in the browser. This works by compiling rclone to WASM and loading that in via javascript. This contains the following files - `index.html` - test web page to load the module - `loader.js` - java script to load the module - see here for usage - `main.go` - main go code exporting the rclone rc - `Makefile` - test makefile - `README.md` - this readme - `serve.go` - test program to serve the web page - `wasm_exec.js` - interface code from the go source - don't edit ## Compiling This can be compiled by using `make` or alternatively `GOARCH=wasm GOOS=js go build -o rclone.wasm` ## Running Run the test server with `make serve` and examine the page at http://localhost:3000/ - look at the javascript console and look at the end of `loader.js` for how that works. rclone-v1.71.0/fs/rc/js/index.html000066400000000000000000000004011505210326400166660ustar00rootroot00000000000000 Rclone

    Welcome to rclone - check the console

    rclone-v1.71.0/fs/rc/js/loader.js000066400000000000000000000023621505210326400165050ustar00rootroot00000000000000var rc; var rcValidResolve var rcValid = new Promise(resolve => { rcValidResolve = resolve }); var script = document.createElement('script'); script.src = "wasm_exec.js"; script.onload = function () { if (!WebAssembly.instantiateStreaming) { // polyfill WebAssembly.instantiateStreaming = async (resp, importObject) => { const source = await (await resp).arrayBuffer(); return await WebAssembly.instantiate(source, importObject); }; } const go = new Go(); WebAssembly.instantiateStreaming(fetch("rclone.wasm"), go.importObject).then((result) => { go.run(result.instance); }); }; document.head.appendChild(script); rcValid.then(() => { // Some examples of using the rc call // // The rc call takes two parameters, method and input object and // returns an output object. // // If the output object has an "error" and a "status" then it is an // error (it would be nice to signal this out of band). console.log("core/version", rc("core/version", null)) console.log("rc/noop", rc("rc/noop", {"string":"one",number:2})) console.log("operations/mkdir", rc("operations/mkdir", {"fs":":memory:","remote":"bucket"})) console.log("operations/list", rc("operations/list", {"fs":":memory:","remote":"bucket"})) }) rclone-v1.71.0/fs/rc/js/main.go000066400000000000000000000067211505210326400161570ustar00rootroot00000000000000// Rclone as a wasm library // // This library exports the core rc functionality //go:build js package main import ( "context" "encoding/json" "errors" "fmt" "log" "net/http" "runtime" "syscall/js" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/rc" // Core functionality we need _ "github.com/rclone/rclone/fs/operations" _ "github.com/rclone/rclone/fs/sync" // _ "github.com/rclone/rclone/backend/all" // import all backends // Backends _ "github.com/rclone/rclone/backend/memory" ) var ( document js.Value jsJSON js.Value ) func getElementById(name string) js.Value { node := document.Call("getElementById", name) if node.IsUndefined() { log.Fatalf("Couldn't find element %q", name) } return node } func time() int { return js.Global().Get("Date").New().Call("getTime").Int() } func paramToValue(in rc.Params) (out js.Value) { return js.Value{} } // errorValue turns an error into a js.Value func errorValue(method string, in js.Value, err error) js.Value { fs.Errorf(nil, "rc: %q: error: %v", method, err) // Adjust the error return for some well known errors status := http.StatusInternalServerError switch { case errors.Is(err, fs.ErrorDirNotFound) || errors.Is(err, fs.ErrorObjectNotFound): status = http.StatusNotFound case rc.IsErrParamInvalid(err) || rc.IsErrParamNotFound(err): status = http.StatusBadRequest } return js.ValueOf(map[string]interface{}{ "status": status, "error": err.Error(), "input": in, "path": method, }) } // rcCallback is a callback for javascript to access the api // // FIXME should this should return a promise so we can return errors properly? func rcCallback(this js.Value, args []js.Value) interface{} { ctx := context.Background() // FIXME log.Printf("rcCallback: this=%v args=%v", this, args) if len(args) != 2 { return errorValue("", js.Undefined(), errors.New("need two parameters to rc call")) } method := args[0].String() inRaw := args[1] var in = rc.Params{} switch inRaw.Type() { case js.TypeNull: case js.TypeObject: inJSON := jsJSON.Call("stringify", inRaw).String() err := json.Unmarshal([]byte(inJSON), &in) if err != nil { return errorValue(method, inRaw, fmt.Errorf("couldn't unmarshal input: %w", err)) } default: return errorValue(method, inRaw, errors.New("in parameter must be null or object")) } call := rc.Calls.Get(method) if call == nil { return errorValue(method, inRaw, fmt.Errorf("method %q not found", method)) } out, err := call.Fn(ctx, in) if err != nil { return errorValue(method, inRaw, fmt.Errorf("method call failed: %w", err)) } if out == nil { return nil } var out2 map[string]interface{} err = rc.Reshape(&out2, out) if err != nil { return errorValue(method, inRaw, fmt.Errorf("result reshape failed: %w", err)) } return js.ValueOf(out2) } func main() { log.Printf("Running on goos/goarch = %s/%s", runtime.GOOS, runtime.GOARCH) if js.Global().IsUndefined() { log.Fatalf("Didn't find Global - not running in browser") } document = js.Global().Get("document") if document.IsUndefined() { log.Fatalf("Didn't find document - not running in browser") } jsJSON = js.Global().Get("JSON") if jsJSON.IsUndefined() { log.Fatalf("can't find JSON") } // Set rc js.Global().Set("rc", js.FuncOf(rcCallback)) // Signal that it is valid rcValidResolve := js.Global().Get("rcValidResolve") if rcValidResolve.IsUndefined() { log.Fatalf("Didn't find rcValidResolve") } rcValidResolve.Invoke() // Wait forever select {} } rclone-v1.71.0/fs/rc/js/serve.go000066400000000000000000000005661505210326400163600ustar00rootroot00000000000000//go:build none package main import ( "fmt" "log" "mime" "net/http" ) func main() { mime.AddExtensionType(".wasm", "application/wasm") mime.AddExtensionType(".js", "application/javascript") mux := http.NewServeMux() mux.Handle("/", http.FileServer(http.Dir("."))) fmt.Printf("Serving on http://localhost:3000/\n") log.Fatal(http.ListenAndServe(":3000", mux)) } rclone-v1.71.0/fs/rc/js/wasm_exec.js000066400000000000000000000465451505210326400172250ustar00rootroot00000000000000// Copyright 2018 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE.wasmexec file. "use strict"; (() => { const enosys = () => { const err = new Error("not implemented"); err.code = "ENOSYS"; return err; }; if (!globalThis.fs) { let outputBuf = ""; globalThis.fs = { constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1, }, // unused writeSync(fd, buf) { outputBuf += decoder.decode(buf); const nl = outputBuf.lastIndexOf("\n"); if (nl != -1) { console.log(outputBuf.substring(0, nl)); outputBuf = outputBuf.substring(nl + 1); } return buf.length; }, write(fd, buf, offset, length, position, callback) { if (offset !== 0 || length !== buf.length || position !== null) { callback(enosys()); return; } const n = this.writeSync(fd, buf); callback(null, n); }, chmod(path, mode, callback) { callback(enosys()); }, chown(path, uid, gid, callback) { callback(enosys()); }, close(fd, callback) { callback(enosys()); }, fchmod(fd, mode, callback) { callback(enosys()); }, fchown(fd, uid, gid, callback) { callback(enosys()); }, fstat(fd, callback) { callback(enosys()); }, fsync(fd, callback) { callback(null); }, ftruncate(fd, length, callback) { callback(enosys()); }, lchown(path, uid, gid, callback) { callback(enosys()); }, link(path, link, callback) { callback(enosys()); }, lstat(path, callback) { callback(enosys()); }, mkdir(path, perm, callback) { callback(enosys()); }, open(path, flags, mode, callback) { callback(enosys()); }, read(fd, buffer, offset, length, position, callback) { callback(enosys()); }, readdir(path, callback) { callback(enosys()); }, readlink(path, callback) { callback(enosys()); }, rename(from, to, callback) { callback(enosys()); }, rmdir(path, callback) { callback(enosys()); }, stat(path, callback) { callback(enosys()); }, symlink(path, link, callback) { callback(enosys()); }, truncate(path, length, callback) { callback(enosys()); }, unlink(path, callback) { callback(enosys()); }, utimes(path, atime, mtime, callback) { callback(enosys()); }, }; } if (!globalThis.process) { globalThis.process = { getuid() { return -1; }, getgid() { return -1; }, geteuid() { return -1; }, getegid() { return -1; }, getgroups() { throw enosys(); }, pid: -1, ppid: -1, umask() { throw enosys(); }, cwd() { throw enosys(); }, chdir() { throw enosys(); }, }; } if (!globalThis.crypto) { throw new Error( "globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)", ); } if (!globalThis.performance) { throw new Error( "globalThis.performance is not available, polyfill required (performance.now only)", ); } if (!globalThis.TextEncoder) { throw new Error( "globalThis.TextEncoder is not available, polyfill required", ); } if (!globalThis.TextDecoder) { throw new Error( "globalThis.TextDecoder is not available, polyfill required", ); } const encoder = new TextEncoder("utf-8"); const decoder = new TextDecoder("utf-8"); globalThis.Go = class { constructor() { this.argv = ["js"]; this.env = {}; this.exit = (code) => { if (code !== 0) { console.warn("exit code:", code); } }; this._exitPromise = new Promise((resolve) => { this._resolveExitPromise = resolve; }); this._pendingEvent = null; this._scheduledTimeouts = new Map(); this._nextCallbackTimeoutID = 1; const setInt64 = (addr, v) => { this.mem.setUint32(addr + 0, v, true); this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true); }; const getInt64 = (addr) => { const low = this.mem.getUint32(addr + 0, true); const high = this.mem.getInt32(addr + 4, true); return low + high * 4294967296; }; const loadValue = (addr) => { const f = this.mem.getFloat64(addr, true); if (f === 0) { return undefined; } if (!isNaN(f)) { return f; } const id = this.mem.getUint32(addr, true); return this._values[id]; }; const storeValue = (addr, v) => { const nanHead = 0x7FF80000; if (typeof v === "number" && v !== 0) { if (isNaN(v)) { this.mem.setUint32(addr + 4, nanHead, true); this.mem.setUint32(addr, 0, true); return; } this.mem.setFloat64(addr, v, true); return; } if (v === undefined) { this.mem.setFloat64(addr, 0, true); return; } let id = this._ids.get(v); if (id === undefined) { id = this._idPool.pop(); if (id === undefined) { id = this._values.length; } this._values[id] = v; this._goRefCounts[id] = 0; this._ids.set(v, id); } this._goRefCounts[id]++; let typeFlag = 0; switch (typeof v) { case "object": if (v !== null) { typeFlag = 1; } break; case "string": typeFlag = 2; break; case "symbol": typeFlag = 3; break; case "function": typeFlag = 4; break; } this.mem.setUint32(addr + 4, nanHead | typeFlag, true); this.mem.setUint32(addr, id, true); }; const loadSlice = (addr) => { const array = getInt64(addr + 0); const len = getInt64(addr + 8); return new Uint8Array(this._inst.exports.mem.buffer, array, len); }; const loadSliceOfValues = (addr) => { const array = getInt64(addr + 0); const len = getInt64(addr + 8); const a = new Array(len); for (let i = 0; i < len; i++) { a[i] = loadValue(array + i * 8); } return a; }; const loadString = (addr) => { const saddr = getInt64(addr + 0); const len = getInt64(addr + 8); return decoder.decode( new DataView(this._inst.exports.mem.buffer, saddr, len), ); }; const timeOrigin = Date.now() - performance.now(); this.importObject = { go: { // Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters) // may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported // function. A goroutine can switch to a new stack if the current stack is too small (see morestack function). // This changes the SP, thus we have to update the SP used by the imported function. // func wasmExit(code int32) "runtime.wasmExit": (sp) => { sp >>>= 0; const code = this.mem.getInt32(sp + 8, true); this.exited = true; delete this._inst; delete this._values; delete this._goRefCounts; delete this._ids; delete this._idPool; this.exit(code); }, // func wasmWrite(fd uintptr, p unsafe.Pointer, n int32) "runtime.wasmWrite": (sp) => { sp >>>= 0; const fd = getInt64(sp + 8); const p = getInt64(sp + 16); const n = this.mem.getInt32(sp + 24, true); fs.writeSync( fd, new Uint8Array(this._inst.exports.mem.buffer, p, n), ); }, // func resetMemoryDataView() "runtime.resetMemoryDataView": (sp) => { sp >>>= 0; this.mem = new DataView(this._inst.exports.mem.buffer); }, // func nanotime1() int64 "runtime.nanotime1": (sp) => { sp >>>= 0; setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000); }, // func walltime() (sec int64, nsec int32) "runtime.walltime": (sp) => { sp >>>= 0; const msec = (new Date()).getTime(); setInt64(sp + 8, msec / 1000); this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true); }, // func scheduleTimeoutEvent(delay int64) int32 "runtime.scheduleTimeoutEvent": (sp) => { sp >>>= 0; const id = this._nextCallbackTimeoutID; this._nextCallbackTimeoutID++; this._scheduledTimeouts.set( id, setTimeout( () => { this._resume(); while (this._scheduledTimeouts.has(id)) { // for some reason Go failed to register the timeout event, log and try again // (temporary workaround for https://github.com/golang/go/issues/28975) console.warn("scheduleTimeoutEvent: missed timeout event"); this._resume(); } }, getInt64(sp + 8) + 1, // setTimeout has been seen to fire up to 1 millisecond early ), ); this.mem.setInt32(sp + 16, id, true); }, // func clearTimeoutEvent(id int32) "runtime.clearTimeoutEvent": (sp) => { sp >>>= 0; const id = this.mem.getInt32(sp + 8, true); clearTimeout(this._scheduledTimeouts.get(id)); this._scheduledTimeouts.delete(id); }, // func getRandomData(r []byte) "runtime.getRandomData": (sp) => { sp >>>= 0; crypto.getRandomValues(loadSlice(sp + 8)); }, // func finalizeRef(v ref) "syscall/js.finalizeRef": (sp) => { sp >>>= 0; const id = this.mem.getUint32(sp + 8, true); this._goRefCounts[id]--; if (this._goRefCounts[id] === 0) { const v = this._values[id]; this._values[id] = null; this._ids.delete(v); this._idPool.push(id); } }, // func stringVal(value string) ref "syscall/js.stringVal": (sp) => { sp >>>= 0; storeValue(sp + 24, loadString(sp + 8)); }, // func valueGet(v ref, p string) ref "syscall/js.valueGet": (sp) => { sp >>>= 0; const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16)); sp = this._inst.exports.getsp() >>> 0; // see comment above storeValue(sp + 32, result); }, // func valueSet(v ref, p string, x ref) "syscall/js.valueSet": (sp) => { sp >>>= 0; Reflect.set( loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32), ); }, // func valueDelete(v ref, p string) "syscall/js.valueDelete": (sp) => { sp >>>= 0; Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16)); }, // func valueIndex(v ref, i int) ref "syscall/js.valueIndex": (sp) => { sp >>>= 0; storeValue( sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)), ); }, // valueSetIndex(v ref, i int, x ref) "syscall/js.valueSetIndex": (sp) => { sp >>>= 0; Reflect.set( loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24), ); }, // func valueCall(v ref, m string, args []ref) (ref, bool) "syscall/js.valueCall": (sp) => { sp >>>= 0; try { const v = loadValue(sp + 8); const m = Reflect.get(v, loadString(sp + 16)); const args = loadSliceOfValues(sp + 32); const result = Reflect.apply(m, v, args); sp = this._inst.exports.getsp() >>> 0; // see comment above storeValue(sp + 56, result); this.mem.setUint8(sp + 64, 1); } catch (err) { sp = this._inst.exports.getsp() >>> 0; // see comment above storeValue(sp + 56, err); this.mem.setUint8(sp + 64, 0); } }, // func valueInvoke(v ref, args []ref) (ref, bool) "syscall/js.valueInvoke": (sp) => { sp >>>= 0; try { const v = loadValue(sp + 8); const args = loadSliceOfValues(sp + 16); const result = Reflect.apply(v, undefined, args); sp = this._inst.exports.getsp() >>> 0; // see comment above storeValue(sp + 40, result); this.mem.setUint8(sp + 48, 1); } catch (err) { sp = this._inst.exports.getsp() >>> 0; // see comment above storeValue(sp + 40, err); this.mem.setUint8(sp + 48, 0); } }, // func valueNew(v ref, args []ref) (ref, bool) "syscall/js.valueNew": (sp) => { sp >>>= 0; try { const v = loadValue(sp + 8); const args = loadSliceOfValues(sp + 16); const result = Reflect.construct(v, args); sp = this._inst.exports.getsp() >>> 0; // see comment above storeValue(sp + 40, result); this.mem.setUint8(sp + 48, 1); } catch (err) { sp = this._inst.exports.getsp() >>> 0; // see comment above storeValue(sp + 40, err); this.mem.setUint8(sp + 48, 0); } }, // func valueLength(v ref) int "syscall/js.valueLength": (sp) => { sp >>>= 0; setInt64(sp + 16, parseInt(loadValue(sp + 8).length)); }, // valuePrepareString(v ref) (ref, int) "syscall/js.valuePrepareString": (sp) => { sp >>>= 0; const str = encoder.encode(String(loadValue(sp + 8))); storeValue(sp + 16, str); setInt64(sp + 24, str.length); }, // valueLoadString(v ref, b []byte) "syscall/js.valueLoadString": (sp) => { sp >>>= 0; const str = loadValue(sp + 8); loadSlice(sp + 16).set(str); }, // func valueInstanceOf(v ref, t ref) bool "syscall/js.valueInstanceOf": (sp) => { sp >>>= 0; this.mem.setUint8( sp + 24, (loadValue(sp + 8) instanceof loadValue(sp + 16)) ? 1 : 0, ); }, // func copyBytesToGo(dst []byte, src ref) (int, bool) "syscall/js.copyBytesToGo": (sp) => { sp >>>= 0; const dst = loadSlice(sp + 8); const src = loadValue(sp + 32); if ( !(src instanceof Uint8Array || src instanceof Uint8ClampedArray) ) { this.mem.setUint8(sp + 48, 0); return; } const toCopy = src.subarray(0, dst.length); dst.set(toCopy); setInt64(sp + 40, toCopy.length); this.mem.setUint8(sp + 48, 1); }, // func copyBytesToJS(dst ref, src []byte) (int, bool) "syscall/js.copyBytesToJS": (sp) => { sp >>>= 0; const dst = loadValue(sp + 8); const src = loadSlice(sp + 16); if ( !(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray) ) { this.mem.setUint8(sp + 48, 0); return; } const toCopy = src.subarray(0, dst.length); dst.set(toCopy); setInt64(sp + 40, toCopy.length); this.mem.setUint8(sp + 48, 1); }, "debug": (value) => { console.log(value); }, }, }; } async run(instance) { if (!(instance instanceof WebAssembly.Instance)) { throw new Error("Go.run: WebAssembly.Instance expected"); } this._inst = instance; this.mem = new DataView(this._inst.exports.mem.buffer); this._values = [ // JS values that Go currently has references to, indexed by reference id NaN, 0, null, true, false, globalThis, this, ]; this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id this._ids = new Map([ // mapping from JS values to reference ids [0, 1], [null, 2], [true, 3], [false, 4], [globalThis, 5], [this, 6], ]); this._idPool = []; // unused ids that have been garbage collected this.exited = false; // whether the Go program has exited // Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory. let offset = 4096; const strPtr = (str) => { const ptr = offset; const bytes = encoder.encode(str + "\0"); new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes); offset += bytes.length; if (offset % 8 !== 0) { offset += 8 - (offset % 8); } return ptr; }; const argc = this.argv.length; const argvPtrs = []; this.argv.forEach((arg) => { argvPtrs.push(strPtr(arg)); }); argvPtrs.push(0); const keys = Object.keys(this.env).sort(); keys.forEach((key) => { argvPtrs.push(strPtr(`${key}=${this.env[key]}`)); }); argvPtrs.push(0); const argv = offset; argvPtrs.forEach((ptr) => { this.mem.setUint32(offset, ptr, true); this.mem.setUint32(offset + 4, 0, true); offset += 8; }); // The linker guarantees global data starts from at least wasmMinDataAddr. // Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr. const wasmMinDataAddr = 4096 + 8192; if (offset >= wasmMinDataAddr) { throw new Error( "total length of command line and environment variables exceeds limit", ); } this._inst.exports.run(argc, argv); if (this.exited) { this._resolveExitPromise(); } await this._exitPromise; } _resume() { if (this.exited) { throw new Error("Go program has already exited"); } this._inst.exports.resume(); if (this.exited) { this._resolveExitPromise(); } } _makeFuncWrapper(id) { const go = this; return function () { const event = { id: id, this: this, args: arguments }; go._pendingEvent = event; go._resume(); return event.result; }; } }; })(); rclone-v1.71.0/fs/rc/params.go000066400000000000000000000204771505210326400161060ustar00rootroot00000000000000// Parameter parsing package rc import ( "encoding/json" "errors" "fmt" "maps" "math" "net/http" "strconv" "time" "github.com/rclone/rclone/fs" ) // Params is the input and output type for the Func type Params map[string]any // ErrParamNotFound - this is returned from the Get* functions if the // parameter isn't found along with a zero value of the requested // item. // // Returning an error of this type from an rc.Func will cause the http // method to return http.StatusBadRequest type ErrParamNotFound string // Error turns this error into a string func (e ErrParamNotFound) Error() string { return fmt.Sprintf("Didn't find key %q in input", string(e)) } // IsErrParamNotFound returns whether err is ErrParamNotFound func IsErrParamNotFound(err error) bool { _, isNotFound := err.(ErrParamNotFound) return isNotFound } // NotErrParamNotFound returns true if err != nil and // !IsErrParamNotFound(err) // // This is for checking error returns of the Get* functions to ignore // error not found returns and take the default value. func NotErrParamNotFound(err error) bool { return err != nil && !IsErrParamNotFound(err) } // ErrParamInvalid - this is returned from the Get* functions if the // parameter is invalid. // // Returning an error of this type from an rc.Func will cause the http // method to return http.StatusBadRequest type ErrParamInvalid struct { error } // NewErrParamInvalid returns new ErrParamInvalid from given error func NewErrParamInvalid(err error) ErrParamInvalid { return ErrParamInvalid{err} } // IsErrParamInvalid returns whether err is ErrParamInvalid func IsErrParamInvalid(err error) bool { _, isInvalid := err.(ErrParamInvalid) return isInvalid } // Reshape reshapes one blob of data into another via json serialization // // out should be a pointer type // // This isn't a very efficient way of dealing with this! func Reshape(out any, in any) error { b, err := json.Marshal(in) if err != nil { return fmt.Errorf("Reshape failed to Marshal: %w", err) } err = json.Unmarshal(b, out) if err != nil { return fmt.Errorf("Reshape failed to Unmarshal: %w", err) } return nil } // Copy shallow copies the Params func (p Params) Copy() (out Params) { out = make(Params, len(p)) maps.Copy(out, p) return out } // Get gets a parameter from the input // // If the parameter isn't found then error will be of type // ErrParamNotFound and the returned value will be nil. func (p Params) Get(key string) (any, error) { value, ok := p[key] if !ok { return nil, ErrParamNotFound(key) } return value, nil } // GetHTTPRequest gets a http.Request parameter associated with the request with the key "_request" // // If the parameter isn't found then error will be of type // ErrParamNotFound and the returned value will be nil. func (p Params) GetHTTPRequest() (*http.Request, error) { key := "_request" value, err := p.Get(key) if err != nil { return nil, err } request, ok := value.(*http.Request) if !ok { return nil, ErrParamInvalid{fmt.Errorf("expecting http.request value for key %q (was %T)", key, value)} } return request, nil } // GetHTTPResponseWriter gets a http.ResponseWriter parameter associated with the request with the key "_response" // // If the parameter isn't found then error will be of type // ErrParamNotFound and the returned value will be nil. func (p Params) GetHTTPResponseWriter() (http.ResponseWriter, error) { key := "_response" value, err := p.Get(key) if err != nil { return nil, err } request, ok := value.(http.ResponseWriter) if !ok { return nil, ErrParamInvalid{fmt.Errorf("expecting http.ResponseWriter value for key %q (was %T)", key, value)} } return request, nil } // GetString gets a string parameter from the input // // If the parameter isn't found then error will be of type // ErrParamNotFound and the returned value will be "". func (p Params) GetString(key string) (string, error) { value, err := p.Get(key) if err != nil { return "", err } str, ok := value.(string) if !ok { return "", ErrParamInvalid{fmt.Errorf("expecting string value for key %q (was %T)", key, value)} } return str, nil } // GetInt64 gets an int64 parameter from the input // // If the parameter isn't found then error will be of type // ErrParamNotFound and the returned value will be 0. func (p Params) GetInt64(key string) (int64, error) { value, err := p.Get(key) if err != nil { return 0, err } switch x := value.(type) { case int: return int64(x), nil case int64: return x, nil case float64: if x > math.MaxInt64 || x < math.MinInt64 { return 0, ErrParamInvalid{fmt.Errorf("key %q (%v) overflows int64 ", key, value)} } return int64(x), nil case string: i, err := strconv.ParseInt(x, 10, 0) if err != nil { return 0, ErrParamInvalid{fmt.Errorf("couldn't parse key %q (%v) as int64: %w", key, value, err)} } return i, nil } return 0, ErrParamInvalid{fmt.Errorf("expecting int64 value for key %q (was %T)", key, value)} } // GetFloat64 gets a float64 parameter from the input // // If the parameter isn't found then error will be of type // ErrParamNotFound and the returned value will be 0. func (p Params) GetFloat64(key string) (float64, error) { value, err := p.Get(key) if err != nil { return 0, err } switch x := value.(type) { case float64: return x, nil case int: return float64(x), nil case int64: return float64(x), nil case string: f, err := strconv.ParseFloat(x, 64) if err != nil { return 0, ErrParamInvalid{fmt.Errorf("couldn't parse key %q (%v) as float64: %w", key, value, err)} } return f, nil } return 0, ErrParamInvalid{fmt.Errorf("expecting float64 value for key %q (was %T)", key, value)} } // GetBool gets a boolean parameter from the input // // If the parameter isn't found then error will be of type // ErrParamNotFound and the returned value will be false. func (p Params) GetBool(key string) (bool, error) { value, err := p.Get(key) if err != nil { return false, err } switch x := value.(type) { case int: return x != 0, nil case int64: return x != 0, nil case float64: return x != 0, nil case bool: return x, nil case string: b, err := strconv.ParseBool(x) if err != nil { return false, ErrParamInvalid{fmt.Errorf("couldn't parse key %q (%v) as bool: %w", key, value, err)} } return b, nil } return false, ErrParamInvalid{fmt.Errorf("expecting bool value for key %q (was %T)", key, value)} } // GetStruct gets a struct from key from the input into the struct // pointed to by out. out must be a pointer type. // // If the parameter isn't found then error will be of type // ErrParamNotFound and out will be unchanged. func (p Params) GetStruct(key string, out any) error { value, err := p.Get(key) if err != nil { return err } err = Reshape(out, value) if err != nil { if valueStr, ok := value.(string); ok { // try to unmarshal as JSON if string err = json.Unmarshal([]byte(valueStr), out) if err == nil { return nil } } return ErrParamInvalid{fmt.Errorf("key %q: %w", key, err)} } return nil } // GetStructMissingOK works like GetStruct but doesn't return an error // if the key is missing func (p Params) GetStructMissingOK(key string, out any) error { _, ok := p[key] if !ok { return nil } return p.GetStruct(key, out) } // GetDuration get the duration parameters from in func (p Params) GetDuration(key string) (time.Duration, error) { s, err := p.GetString(key) if err != nil { return 0, err } duration, err := fs.ParseDuration(s) if err != nil { return 0, ErrParamInvalid{fmt.Errorf("parse duration: %w", err)} } return duration, nil } // GetFsDuration get the duration parameters from in func (p Params) GetFsDuration(key string) (fs.Duration, error) { d, err := p.GetDuration(key) return fs.Duration(d), err } // Error creates the standard response for an errored rc call using an // rc.Param from a path, input Params, error and a suggested HTTP // response code. // // It returns a Params and an updated status code func Error(path string, in Params, err error, status int) (Params, int) { // Adjust the status code for some well known errors switch { case errors.Is(err, fs.ErrorDirNotFound) || errors.Is(err, fs.ErrorObjectNotFound): status = http.StatusNotFound case IsErrParamInvalid(err) || IsErrParamNotFound(err): status = http.StatusBadRequest } result := Params{ "status": status, "error": err.Error(), "input": in, "path": path, } return result, status } rclone-v1.71.0/fs/rc/params_test.go000066400000000000000000000233551505210326400171430ustar00rootroot00000000000000package rc import ( "errors" "fmt" "net/http" "net/http/httptest" "testing" "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/rclone/rclone/fs" ) func TestErrParamNotFoundError(t *testing.T) { e := ErrParamNotFound("key") assert.Equal(t, "Didn't find key \"key\" in input", e.Error()) } func TestIsErrParamNotFound(t *testing.T) { assert.Equal(t, true, IsErrParamNotFound(ErrParamNotFound("key"))) assert.Equal(t, false, IsErrParamNotFound(nil)) assert.Equal(t, false, IsErrParamNotFound(errors.New("potato"))) } func TestNotErrParamNotFound(t *testing.T) { assert.Equal(t, false, NotErrParamNotFound(ErrParamNotFound("key"))) assert.Equal(t, false, NotErrParamNotFound(nil)) assert.Equal(t, true, NotErrParamNotFound(errors.New("potato"))) } func TestIsErrParamInvalid(t *testing.T) { e := ErrParamInvalid{errors.New("potato")} assert.Equal(t, true, IsErrParamInvalid(e)) assert.Equal(t, false, IsErrParamInvalid(nil)) assert.Equal(t, false, IsErrParamInvalid(errors.New("potato"))) } func TestReshape(t *testing.T) { in := Params{ "String": "hello", "Float": 4.2, } var out struct { String string Float float64 } require.NoError(t, Reshape(&out, in)) assert.Equal(t, "hello", out.String) assert.Equal(t, 4.2, out.Float) var inCopy = Params{} require.NoError(t, Reshape(&inCopy, out)) assert.Equal(t, in, inCopy) // Now a failure to marshal var in2 func() require.Error(t, Reshape(&inCopy, in2)) // Now a failure to unmarshal require.Error(t, Reshape(&out, "string")) } func TestParamsCopy(t *testing.T) { in := Params{ "ok": 1, "x": "seventeen", "nil": nil, } out := in.Copy() assert.Equal(t, in, out) if &in == &out { t.Error("didn't copy") } } func TestParamsGet(t *testing.T) { in := Params{ "ok": 1, } v1, e1 := in.Get("ok") assert.NoError(t, e1) assert.Equal(t, 1, v1) v2, e2 := in.Get("notOK") assert.Error(t, e2) assert.Equal(t, nil, v2) assert.Equal(t, ErrParamNotFound("notOK"), e2) } func TestParamsGetString(t *testing.T) { in := Params{ "string": "one", "notString": 17, } v1, e1 := in.GetString("string") assert.NoError(t, e1) assert.Equal(t, "one", v1) v2, e2 := in.GetString("notOK") assert.Error(t, e2) assert.Equal(t, "", v2) assert.Equal(t, ErrParamNotFound("notOK"), e2) v3, e3 := in.GetString("notString") assert.Error(t, e3) assert.Equal(t, "", v3) assert.Equal(t, true, IsErrParamInvalid(e3), e3.Error()) } func TestParamsGetInt64(t *testing.T) { for _, test := range []struct { value any result int64 errString string }{ {"123", 123, ""}, {"123x", 0, "couldn't parse"}, {int(12), 12, ""}, {int64(13), 13, ""}, {float64(14), 14, ""}, {float64(9.3e18), 0, "overflows int64"}, {float64(-9.3e18), 0, "overflows int64"}, } { t.Run(fmt.Sprintf("%T=%v", test.value, test.value), func(t *testing.T) { in := Params{ "key": test.value, } v1, e1 := in.GetInt64("key") if test.errString == "" { require.NoError(t, e1) assert.Equal(t, test.result, v1) } else { require.NotNil(t, e1) require.Error(t, e1) assert.Contains(t, e1.Error(), test.errString) assert.Equal(t, int64(0), v1) } }) } in := Params{ "notInt64": []string{"a", "b"}, } v2, e2 := in.GetInt64("notOK") assert.Error(t, e2) assert.Equal(t, int64(0), v2) assert.Equal(t, ErrParamNotFound("notOK"), e2) v3, e3 := in.GetInt64("notInt64") assert.Error(t, e3) assert.Equal(t, int64(0), v3) assert.Equal(t, true, IsErrParamInvalid(e3), e3.Error()) } func TestParamsGetFloat64(t *testing.T) { for _, test := range []struct { value any result float64 errString string }{ {"123.1", 123.1, ""}, {"123x1", 0, "couldn't parse"}, {int(12), 12, ""}, {int64(13), 13, ""}, {float64(14), 14, ""}, } { t.Run(fmt.Sprintf("%T=%v", test.value, test.value), func(t *testing.T) { in := Params{ "key": test.value, } v1, e1 := in.GetFloat64("key") if test.errString == "" { require.NoError(t, e1) assert.Equal(t, test.result, v1) } else { require.NotNil(t, e1) require.Error(t, e1) assert.Contains(t, e1.Error(), test.errString) assert.Equal(t, float64(0), v1) } }) } in := Params{ "notFloat64": []string{"a", "b"}, } v2, e2 := in.GetFloat64("notOK") assert.Error(t, e2) assert.Equal(t, float64(0), v2) assert.Equal(t, ErrParamNotFound("notOK"), e2) v3, e3 := in.GetFloat64("notFloat64") assert.Error(t, e3) assert.Equal(t, float64(0), v3) assert.Equal(t, true, IsErrParamInvalid(e3), e3.Error()) } func TestParamsGetDuration(t *testing.T) { for _, test := range []struct { value any result time.Duration errString string }{ {"86400", time.Hour * 24, ""}, {"1y", time.Hour * 24 * 365, ""}, {"60", time.Minute * 1, ""}, {"0", 0, ""}, {"-45", -time.Second * 45, ""}, {"2", time.Second * 2, ""}, {"2h4m7s", time.Hour*2 + 4*time.Minute + 7*time.Second, ""}, {"3d", time.Hour * 24 * 3, ""}, {"off", time.Duration(fs.DurationOff), ""}, {"", 0, "parse duration"}, {12, 0, "expecting string"}, {"34y", time.Hour * 24 * 365 * 34, ""}, {"30d", time.Hour * 24 * 30, ""}, {"2M", time.Hour * 24 * 60, ""}, {"wrong", 0, "parse duration"}, } { t.Run(fmt.Sprintf("%T=%v", test.value, test.value), func(t *testing.T) { in := Params{ "key": test.value, } v1, e1 := in.GetDuration("key") if test.errString == "" { require.NoError(t, e1) assert.Equal(t, test.result, v1) } else { require.NotNil(t, e1) require.Error(t, e1) assert.Contains(t, e1.Error(), test.errString) assert.Equal(t, time.Duration(0), v1) } }) } in := Params{ "notDuration": []string{"a", "b"}, } v2, e2 := in.GetDuration("notOK") assert.Error(t, e2) assert.Equal(t, time.Duration(0), v2) assert.Equal(t, ErrParamNotFound("notOK"), e2) v3, e3 := in.GetDuration("notDuration") assert.Error(t, e3) assert.Equal(t, time.Duration(0), v3) assert.Equal(t, true, IsErrParamInvalid(e3), e3.Error()) } func TestParamsGetBool(t *testing.T) { for _, test := range []struct { value any result bool errString string }{ {true, true, ""}, {false, false, ""}, {"true", true, ""}, {"false", false, ""}, {"fasle", false, "couldn't parse"}, {int(12), true, ""}, {int(0), false, ""}, {int64(13), true, ""}, {int64(0), false, ""}, {float64(14), true, ""}, {float64(0), false, ""}, } { t.Run(fmt.Sprintf("%T=%v", test.value, test.value), func(t *testing.T) { in := Params{ "key": test.value, } v1, e1 := in.GetBool("key") if test.errString == "" { require.NoError(t, e1) assert.Equal(t, test.result, v1) } else { require.NotNil(t, e1) require.Error(t, e1) assert.Contains(t, e1.Error(), test.errString) assert.Equal(t, false, v1) } }) } in := Params{ "notBool": []string{"a", "b"}, } v2, e2 := Params{}.GetBool("notOK") assert.Error(t, e2) assert.Equal(t, false, v2) assert.Equal(t, ErrParamNotFound("notOK"), e2) v3, e3 := in.GetBool("notBool") assert.Error(t, e3) assert.Equal(t, false, v3) assert.Equal(t, true, IsErrParamInvalid(e3), e3.Error()) } func TestParamsGetStruct(t *testing.T) { in := Params{ "struct": Params{ "String": "one", "Float": 4.2, }, } var out struct { String string Float float64 } e1 := in.GetStruct("struct", &out) assert.NoError(t, e1) assert.Equal(t, "one", out.String) assert.Equal(t, 4.2, out.Float) e2 := in.GetStruct("notOK", &out) assert.Error(t, e2) assert.Equal(t, "one", out.String) assert.Equal(t, 4.2, out.Float) assert.Equal(t, ErrParamNotFound("notOK"), e2) in["struct"] = "string" e3 := in.GetStruct("struct", &out) assert.Error(t, e3) assert.Equal(t, "one", out.String) assert.Equal(t, 4.2, out.Float) assert.Equal(t, true, IsErrParamInvalid(e3), e3.Error()) } func TestParamsGetStructString(t *testing.T) { in := Params{ "struct": `{"String": "one", "Float": 4.2}`, } var out struct { String string Float float64 } e1 := in.GetStruct("struct", &out) assert.NoError(t, e1) assert.Equal(t, "one", out.String) assert.Equal(t, 4.2, out.Float) } func TestParamsGetStructMissingOK(t *testing.T) { in := Params{ "struct": Params{ "String": "one", "Float": 4.2, }, } var out struct { String string Float float64 } e1 := in.GetStructMissingOK("struct", &out) assert.NoError(t, e1) assert.Equal(t, "one", out.String) assert.Equal(t, 4.2, out.Float) e2 := in.GetStructMissingOK("notOK", &out) assert.NoError(t, e2) assert.Equal(t, "one", out.String) assert.Equal(t, 4.2, out.Float) in["struct"] = "string" e3 := in.GetStructMissingOK("struct", &out) assert.Error(t, e3) assert.Equal(t, "one", out.String) assert.Equal(t, 4.2, out.Float) assert.Equal(t, true, IsErrParamInvalid(e3), e3.Error()) } func TestParamsGetHTTPRequest(t *testing.T) { in := Params{} req, err := in.GetHTTPRequest() assert.Nil(t, req) assert.Error(t, err) assert.Equal(t, true, IsErrParamNotFound(err), err.Error()) in = Params{ "_request": 42, } req, err = in.GetHTTPRequest() assert.Nil(t, req) assert.Error(t, err) assert.Equal(t, true, IsErrParamInvalid(err), err.Error()) r := new(http.Request) in = Params{ "_request": r, } req, err = in.GetHTTPRequest() assert.NotNil(t, req) assert.NoError(t, err) assert.Equal(t, r, req) } func TestParamsGetHTTPResponseWriter(t *testing.T) { in := Params{} wr, err := in.GetHTTPResponseWriter() assert.Nil(t, wr) assert.Error(t, err) assert.Equal(t, true, IsErrParamNotFound(err), err.Error()) in = Params{ "_response": 42, } wr, err = in.GetHTTPResponseWriter() assert.Nil(t, wr) assert.Error(t, err) assert.Equal(t, true, IsErrParamInvalid(err), err.Error()) var w http.ResponseWriter = httptest.NewRecorder() in = Params{ "_response": w, } wr, err = in.GetHTTPResponseWriter() assert.NotNil(t, wr) assert.NoError(t, err) assert.Equal(t, w, wr) } rclone-v1.71.0/fs/rc/rc.go000066400000000000000000000117721505210326400152250ustar00rootroot00000000000000// Package rc implements a remote control server and registry for rclone // // To register your internal calls, call rc.Add(path, function). Your // function should take and return a Param. It can also return an // error. Use rc.NewError to wrap an existing error along with an // http response type if another response other than 500 internal // error is required on error. package rc import ( "encoding/json" "io" _ "net/http/pprof" // install the pprof http handlers "time" "github.com/rclone/rclone/fs" libhttp "github.com/rclone/rclone/lib/http" ) // OptionsInfo describes the Options in use var OptionsInfo = fs.Options{{ Name: "rc", Default: false, Help: "Enable the remote control server", Groups: "RC", }, { Name: "rc_files", Default: "", Help: "Path to local files to serve on the HTTP server", Groups: "RC", }, { Name: "rc_serve", Default: false, Help: "Enable the serving of remote objects", Groups: "RC", }, { Name: "rc_serve_no_modtime", Default: false, Help: "Don't read the modification time (can speed things up)", Groups: "RC", }, { Name: "rc_no_auth", Default: false, Help: "Don't require auth for certain methods", Groups: "RC", }, { Name: "rc_web_gui", Default: false, Help: "Launch WebGUI on localhost", Groups: "RC", }, { Name: "rc_web_gui_update", Default: false, Help: "Check and update to latest version of web gui", Groups: "RC", }, { Name: "rc_web_gui_force_update", Default: false, Help: "Force update to latest version of web gui", Groups: "RC", }, { Name: "rc_web_gui_no_open_browser", Default: false, Help: "Don't open the browser automatically", Groups: "RC", }, { Name: "rc_web_fetch_url", Default: "https://api.github.com/repos/rclone/rclone-webui-react/releases/latest", Help: "URL to fetch the releases for webgui", Groups: "RC", }, { Name: "rc_enable_metrics", Default: false, Help: "Enable the Prometheus metrics path at the remote control server", Groups: "RC,Metrics", }, { Name: "rc_job_expire_duration", Default: fs.Duration(60 * time.Second), Help: "Expire finished async jobs older than this value", Groups: "RC", }, { Name: "rc_job_expire_interval", Default: fs.Duration(10 * time.Second), Help: "Interval to check for expired async jobs", Groups: "RC", }, { Name: "metrics_addr", Default: []string{}, Help: "IPaddress:Port or :Port to bind metrics server to", Groups: "Metrics", }}. AddPrefix(libhttp.ConfigInfo, "rc", "RC"). AddPrefix(libhttp.AuthConfigInfo, "rc", "RC"). AddPrefix(libhttp.TemplateConfigInfo, "rc", "RC"). AddPrefix(libhttp.ConfigInfo, "metrics", "Metrics"). AddPrefix(libhttp.AuthConfigInfo, "metrics", "Metrics"). AddPrefix(libhttp.TemplateConfigInfo, "metrics", "Metrics"). SetDefault("rc_addr", []string{"localhost:5572"}) func init() { fs.RegisterGlobalOptions(fs.OptionsInfo{Name: "rc", Opt: &Opt, Options: OptionsInfo}) } // Options contains options for the remote control server type Options struct { HTTP libhttp.Config `config:"rc"` Auth libhttp.AuthConfig `config:"rc"` Template libhttp.TemplateConfig `config:"rc"` Enabled bool `config:"rc"` // set to enable the server Files string `config:"rc_files"` // set to enable serving files locally Serve bool `config:"rc_serve"` // set to serve files from remotes ServeNoModTime bool `config:"rc_serve_no_modtime"` // don't read the modification time NoAuth bool `config:"rc_no_auth"` // set to disable auth checks on AuthRequired methods WebUI bool `config:"rc_web_gui"` // set to launch the web ui WebGUIUpdate bool `config:"rc_web_gui_update"` // set to check new update WebGUIForceUpdate bool `config:"rc_web_gui_force_update"` // set to force download new update WebGUINoOpenBrowser bool `config:"rc_web_gui_no_open_browser"` // set to disable auto opening browser WebGUIFetchURL string `config:"rc_web_fetch_url"` // set the default url for fetching webgui EnableMetrics bool `config:"rc_enable_metrics"` // set to disable prometheus metrics on /metrics MetricsHTTP libhttp.Config `config:"metrics"` MetricsAuth libhttp.AuthConfig `config:"metrics"` MetricsTemplate libhttp.TemplateConfig `config:"metrics"` JobExpireDuration fs.Duration `config:"rc_job_expire_duration"` JobExpireInterval fs.Duration `config:"rc_job_expire_interval"` } // Opt is the default values used for Options var Opt Options // WriteJSON writes JSON in out to w func WriteJSON(w io.Writer, out Params) error { enc := json.NewEncoder(w) enc.SetIndent("", "\t") return enc.Encode(out) } rclone-v1.71.0/fs/rc/rc_test.go000066400000000000000000000005351505210326400162570ustar00rootroot00000000000000package rc import ( "bytes" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestWriteJSON(t *testing.T) { var buf bytes.Buffer err := WriteJSON(&buf, Params{ "String": "hello", "Int": 42, }) require.NoError(t, err) assert.Equal(t, `{ "Int": 42, "String": "hello" } `, buf.String()) } rclone-v1.71.0/fs/rc/rcflags/000077500000000000000000000000001505210326400157035ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/rcflags/rcflags.go000066400000000000000000000007221505210326400176540ustar00rootroot00000000000000// Package rcflags implements command line flags to set up the remote control package rcflags import ( "github.com/rclone/rclone/fs/config/flags" "github.com/rclone/rclone/fs/rc" "github.com/spf13/pflag" ) // FlagPrefix is the prefix used to uniquely identify command line flags. const FlagPrefix = "rc-" // AddFlags adds the remote control flags to the flagSet func AddFlags(flagSet *pflag.FlagSet) { flags.AddFlagsFromOptions(flagSet, "", rc.OptionsInfo) } rclone-v1.71.0/fs/rc/rcserver/000077500000000000000000000000001505210326400161155ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/rcserver/metrics.go000066400000000000000000000046631505210326400201230ustar00rootroot00000000000000// Package rcserver implements the HTTP endpoint to serve the remote control package rcserver import ( "context" "fmt" "net/http" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus/promhttp" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/fshttp" "github.com/rclone/rclone/fs/rc" "github.com/rclone/rclone/fs/rc/jobs" libhttp "github.com/rclone/rclone/lib/http" ) const path = "/metrics" var promHandlerFunc http.HandlerFunc func init() { rcloneCollector := accounting.NewRcloneCollector(context.Background()) prometheus.MustRegister(rcloneCollector) m := fshttp.NewMetrics("rclone") for _, c := range m.Collectors() { prometheus.MustRegister(c) } fshttp.DefaultMetrics = m promHandlerFunc = promhttp.Handler().ServeHTTP } // MetricsStart the remote control server if configured // // If the server wasn't configured the *Server returned may be nil func MetricsStart(ctx context.Context, opt *rc.Options) (*MetricsServer, error) { jobs.SetOpt(opt) // set the defaults for jobs if len(opt.MetricsHTTP.ListenAddr) > 0 { // Serve on the DefaultServeMux so can have global registrations appear s, err := newMetricsServer(ctx, opt) if err != nil { return nil, err } return s, s.Serve() } return nil, nil } // MetricsServer contains everything to run the rc server type MetricsServer struct { ctx context.Context // for global config server *libhttp.Server promHandlerFunc http.Handler opt *rc.Options } func newMetricsServer(ctx context.Context, opt *rc.Options) (*MetricsServer, error) { s := &MetricsServer{ ctx: ctx, opt: opt, promHandlerFunc: promHandlerFunc, } var err error s.server, err = libhttp.NewServer(ctx, libhttp.WithConfig(opt.MetricsHTTP), libhttp.WithAuth(opt.MetricsAuth), libhttp.WithTemplate(opt.MetricsTemplate), ) if err != nil { return nil, fmt.Errorf("failed to init server: %w", err) } router := s.server.Router() router.Get(path, promHandlerFunc) return s, nil } // Serve runs the http server in the background. // // Use s.Close() and s.Wait() to shutdown server func (s *MetricsServer) Serve() error { s.server.Serve() return nil } // Wait blocks while the server is serving requests func (s *MetricsServer) Wait() { s.server.Wait() } // Shutdown gracefully shuts down the server func (s *MetricsServer) Shutdown() error { return s.server.Shutdown() } rclone-v1.71.0/fs/rc/rcserver/metrics_test.go000066400000000000000000000044551505210326400211610ustar00rootroot00000000000000package rcserver import ( "context" "fmt" "net/http" "regexp" "testing" _ "github.com/rclone/rclone/backend/local" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/config/configfile" "github.com/rclone/rclone/fs/rc" "github.com/stretchr/testify/require" ) // Run a suite of tests func testMetricsServer(t *testing.T, tests []testRun, opt *rc.Options) { t.Helper() ctx := context.Background() configfile.Install() rcServer, err := newMetricsServer(ctx, opt) require.NoError(t, err) testURL := rcServer.server.URLs()[0] mux := rcServer.server.Router() emulateCalls(t, tests, mux, testURL) } // return an enabled rc func newMetricsTestOpt() rc.Options { opt := rc.Opt opt.MetricsHTTP.ListenAddr = []string{testBindAddress} return opt } func TestMetrics(t *testing.T) { stats := accounting.GlobalStats() tests := makeMetricsTestCases(stats) opt := newMetricsTestOpt() testMetricsServer(t, tests, &opt) // Test changing a couple options stats.Bytes(500) for range 30 { require.NoError(t, stats.DeleteFile(context.Background(), 0)) } stats.Errors(2) stats.Bytes(324) tests = makeMetricsTestCases(stats) testMetricsServer(t, tests, &opt) } func makeMetricsTestCases(stats *accounting.StatsInfo) (tests []testRun) { tests = []testRun{{ Name: "Bytes Transferred Metric", URL: "metrics", Method: "GET", Status: http.StatusOK, Contains: regexp.MustCompile(fmt.Sprintf("rclone_bytes_transferred_total %d", stats.GetBytes())), }, { Name: "Checked Files Metric", URL: "metrics", Method: "GET", Status: http.StatusOK, Contains: regexp.MustCompile(fmt.Sprintf("rclone_checked_files_total %d", stats.GetChecks())), }, { Name: "Errors Metric", URL: "metrics", Method: "GET", Status: http.StatusOK, Contains: regexp.MustCompile(fmt.Sprintf("rclone_errors_total %d", stats.GetErrors())), }, { Name: "Deleted Files Metric", URL: "metrics", Method: "GET", Status: http.StatusOK, Contains: regexp.MustCompile(fmt.Sprintf("rclone_files_deleted_total %d", stats.GetDeletes())), }, { Name: "Files Transferred Metric", URL: "metrics", Method: "GET", Status: http.StatusOK, Contains: regexp.MustCompile(fmt.Sprintf("rclone_files_transferred_total %d", stats.GetTransfers())), }, } return } rclone-v1.71.0/fs/rc/rcserver/rcserver.go000066400000000000000000000307531505210326400203070ustar00rootroot00000000000000// Package rcserver implements the HTTP endpoint to serve the remote control package rcserver import ( "context" "encoding/base64" "encoding/json" "flag" "fmt" "mime" "net/http" "net/url" "path/filepath" "regexp" "sort" "strings" "time" "github.com/go-chi/chi/v5/middleware" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/fs/rc" "github.com/rclone/rclone/fs/rc/jobs" "github.com/rclone/rclone/fs/rc/webgui" libhttp "github.com/rclone/rclone/lib/http" "github.com/rclone/rclone/lib/http/serve" "github.com/rclone/rclone/lib/random" "github.com/skratchdot/open-golang/open" ) // Start the remote control server if configured // // If the server wasn't configured the *Server returned may be nil func Start(ctx context.Context, opt *rc.Options) (*Server, error) { jobs.SetOpt(opt) // set the defaults for jobs if opt.Enabled { // Serve on the DefaultServeMux so can have global registrations appear s, err := newServer(ctx, opt, http.DefaultServeMux) if err != nil { return nil, err } return s, s.Serve() } return nil, nil } // Server contains everything to run the rc server type Server struct { ctx context.Context // for global config server *libhttp.Server files http.Handler pluginsHandler http.Handler opt *rc.Options } func newServer(ctx context.Context, opt *rc.Options, mux *http.ServeMux) (*Server, error) { fileHandler := http.Handler(nil) pluginsHandler := http.Handler(nil) // Add some more mime types which are often missing _ = mime.AddExtensionType(".wasm", "application/wasm") _ = mime.AddExtensionType(".js", "application/javascript") cachePath := filepath.Join(config.GetCacheDir(), "webgui") extractPath := filepath.Join(cachePath, "current/build") // File handling if opt.Files != "" { if opt.WebUI { fs.Logf(nil, "--rc-files overrides --rc-web-gui command\n") } fs.Logf(nil, "Serving files from %q", opt.Files) fileHandler = http.FileServer(http.Dir(opt.Files)) } else if opt.WebUI { if err := webgui.CheckAndDownloadWebGUIRelease(opt.WebGUIUpdate, opt.WebGUIForceUpdate, opt.WebGUIFetchURL, config.GetCacheDir()); err != nil { fs.Errorf(nil, "Error while fetching the latest release of Web GUI: %v", err) } if opt.NoAuth { fs.Logf(nil, "It is recommended to use web gui with auth.") } else { if opt.Auth.BasicUser == "" && opt.Auth.HtPasswd == "" { opt.Auth.BasicUser = "gui" fs.Infof(nil, "No username specified. Using default username: %s \n", rc.Opt.Auth.BasicUser) } if opt.Auth.BasicPass == "" && opt.Auth.HtPasswd == "" { randomPass, err := random.Password(128) if err != nil { fs.Fatalf(nil, "Failed to make password: %v", err) } opt.Auth.BasicPass = randomPass fs.Infof(nil, "No password specified. Using random password: %s \n", randomPass) } } opt.Serve = true fs.Logf(nil, "Serving Web GUI") fileHandler = http.FileServer(http.Dir(extractPath)) pluginsHandler = http.FileServer(http.Dir(webgui.PluginsPath)) } s := &Server{ ctx: ctx, opt: opt, files: fileHandler, pluginsHandler: pluginsHandler, } var err error s.server, err = libhttp.NewServer(ctx, libhttp.WithConfig(opt.HTTP), libhttp.WithAuth(opt.Auth), libhttp.WithTemplate(opt.Template), ) if err != nil { return nil, fmt.Errorf("failed to init server: %w", err) } router := s.server.Router() router.Use( middleware.SetHeader("Accept-Ranges", "bytes"), middleware.SetHeader("Server", "rclone/"+fs.Version), ) // Add the debug handler which is installed in the default mux router.Handle("/debug/pprof/*", mux) // FIXME split these up into individual functions router.Get("/*", s.handler) router.Head("/*", s.handler) router.Post("/*", s.handler) router.Options("/*", s.handler) return s, nil } // Serve runs the http server in the background. // // Use s.Close() and s.Wait() to shutdown server func (s *Server) Serve() error { s.server.Serve() for _, URL := range s.server.URLs() { fs.Logf(nil, "Serving remote control on %s", URL) // Open the files in the browser if set if s.files != nil { openURL, err := url.Parse(URL) if err != nil { return fmt.Errorf("invalid serving URL: %w", err) } // Add username, password into the URL if they are set user, pass := s.opt.Auth.BasicUser, s.opt.Auth.BasicPass if user != "" && pass != "" { openURL.User = url.UserPassword(user, pass) // Base64 encode username and password to be sent through url loginToken := user + ":" + pass parameters := url.Values{} encodedToken := base64.URLEncoding.EncodeToString([]byte(loginToken)) fs.Debugf(nil, "login_token %q", encodedToken) parameters.Add("login_token", encodedToken) openURL.RawQuery = parameters.Encode() openURL.RawPath = "/#/login" } // Don't open browser if serving in testing environment or required not to do so. if flag.Lookup("test.v") == nil && !s.opt.WebGUINoOpenBrowser { if err := open.Start(openURL.String()); err != nil { fs.Errorf(nil, "Failed to open Web GUI in browser: %v. Manually access it at: %s", err, openURL.String()) } } else { fs.Logf(nil, "Web GUI is not automatically opening browser. Navigate to %s to use.", openURL.String()) } } } return nil } // writeError writes a formatted error to the output func writeError(path string, in rc.Params, w http.ResponseWriter, err error, status int) { fs.Errorf(nil, "rc: %q: error: %v", path, err) params, status := rc.Error(path, in, err, status) w.Header().Set("Content-Type", "application/json") w.WriteHeader(status) err = rc.WriteJSON(w, params) if err != nil { // can't return the error at this point fs.Errorf(nil, "rc: writeError: failed to write JSON output from %#v: %v", in, err) } } // handler reads incoming requests and dispatches them func (s *Server) handler(w http.ResponseWriter, r *http.Request) { path := strings.TrimLeft(r.URL.Path, "/") switch r.Method { case "POST": s.handlePost(w, r, path) case "OPTIONS": s.handleOptions(w, r, path) case "GET", "HEAD": s.handleGet(w, r, path) default: writeError(path, nil, w, fmt.Errorf("method %q not allowed", r.Method), http.StatusMethodNotAllowed) return } } func (s *Server) handlePost(w http.ResponseWriter, r *http.Request, path string) { ctx := r.Context() contentType := r.Header.Get("Content-Type") var ( contentTypeMediaType string contentTypeParams map[string]string ) if contentType != "" { var err error contentTypeMediaType, contentTypeParams, err = mime.ParseMediaType(contentType) if err != nil { writeError(path, nil, w, fmt.Errorf("failed to parse Content-Type: %w", err), http.StatusBadRequest) return } } values := r.URL.Query() if contentTypeMediaType == "application/x-www-form-urlencoded" { // Parse the POST and URL parameters into r.Form, for others r.Form will be empty value err := r.ParseForm() if err != nil { writeError(path, nil, w, fmt.Errorf("failed to parse form/URL parameters: %w", err), http.StatusBadRequest) return } values = r.Form } // Read the POST and URL parameters into in in := make(rc.Params) for k, vs := range values { if len(vs) > 0 { in[k] = vs[len(vs)-1] } } // Parse a JSON blob from the input if contentTypeMediaType == "application/json" { // Check the charset is utf-8 or unset if charset, ok := contentTypeParams["charset"]; ok && !strings.EqualFold(charset, "utf-8") { writeError(path, in, w, fmt.Errorf("unsupported charset %q for JSON input", charset), http.StatusBadRequest) return } err := json.NewDecoder(r.Body).Decode(&in) if err != nil { writeError(path, in, w, fmt.Errorf("failed to read input JSON: %w", err), http.StatusBadRequest) return } } // Find the call call := rc.Calls.Get(path) if call == nil { writeError(path, in, w, fmt.Errorf("couldn't find method %q", path), http.StatusNotFound) return } // Check to see if it requires authorisation if !s.opt.NoAuth && call.AuthRequired && !s.server.UsingAuth() { writeError(path, in, w, fmt.Errorf("authentication must be set up on the rc server to use %q or the --rc-no-auth flag must be in use", path), http.StatusForbidden) return } inOrig := in.Copy() if call.NeedsRequest { // Add the request to RC in["_request"] = r } if call.NeedsResponse { in["_response"] = w } fs.Debugf(nil, "rc: %q: with parameters %+v", path, in) job, out, err := jobs.NewJob(ctx, call.Fn, in) if job != nil { w.Header().Add("x-rclone-jobid", fmt.Sprintf("%d", job.ID)) } if err != nil { writeError(path, inOrig, w, err, http.StatusInternalServerError) return } if out == nil { out = make(rc.Params) } fs.Debugf(nil, "rc: %q: reply %+v: %v", path, out, err) w.Header().Set("Content-Type", "application/json") err = rc.WriteJSON(w, out) if err != nil { // can't return the error at this point - but have a go anyway writeError(path, inOrig, w, err, http.StatusInternalServerError) fs.Errorf(nil, "rc: handlePost: failed to write JSON output: %v", err) } } func (s *Server) handleOptions(w http.ResponseWriter, r *http.Request, path string) { w.WriteHeader(http.StatusOK) } func (s *Server) serveRoot(w http.ResponseWriter, r *http.Request) { remoteNames := config.GetRemoteNames() sort.Strings(remoteNames) directory := serve.NewDirectory("", s.server.HTMLTemplate()) directory.Name = "List of all rclone remotes." q := url.Values{} for _, remoteName := range remoteNames { q.Set("fs", remoteName) directory.AddHTMLEntry("["+remoteName+":]", true, -1, time.Time{}) } sortParm := r.URL.Query().Get("sort") orderParm := r.URL.Query().Get("order") directory.ProcessQueryParams(sortParm, orderParm) directory.Serve(w, r) } func (s *Server) serveRemote(w http.ResponseWriter, r *http.Request, path string, fsName string) { f, err := cache.Get(s.ctx, fsName) if err != nil { writeError(path, nil, w, fmt.Errorf("failed to make Fs: %w", err), http.StatusInternalServerError) return } if path == "" || strings.HasSuffix(path, "/") { path = strings.Trim(path, "/") entries, err := list.DirSorted(r.Context(), f, false, path) if err != nil { writeError(path, nil, w, fmt.Errorf("failed to list directory: %w", err), http.StatusInternalServerError) return } // Make the entries for display directory := serve.NewDirectory(path, s.server.HTMLTemplate()) for _, entry := range entries { _, isDir := entry.(fs.Directory) var modTime time.Time if !s.opt.ServeNoModTime { modTime = entry.ModTime(r.Context()) } directory.AddHTMLEntry(entry.Remote(), isDir, entry.Size(), modTime) } sortParm := r.URL.Query().Get("sort") orderParm := r.URL.Query().Get("order") directory.ProcessQueryParams(sortParm, orderParm) directory.Serve(w, r) } else { path = strings.Trim(path, "/") o, err := f.NewObject(r.Context(), path) if err != nil { writeError(path, nil, w, fmt.Errorf("failed to find object: %w", err), http.StatusInternalServerError) return } serve.Object(w, r, o) } } // Match URLS of the form [fs]/remote var fsMatch = regexp.MustCompile(`^\[(.*?)\](.*)$`) func (s *Server) handleGet(w http.ResponseWriter, r *http.Request, path string) { // Look to see if this has an fs in the path fsMatchResult := fsMatch.FindStringSubmatch(path) switch { case fsMatchResult != nil && s.opt.Serve: // Serve /[fs]/remote files s.serveRemote(w, r, fsMatchResult[2], fsMatchResult[1]) return case path == "metrics" && s.opt.EnableMetrics: promHandlerFunc(w, r) return case path == "*" && s.opt.Serve: // Serve /* as the remote listing s.serveRoot(w, r) return case s.files != nil: if s.opt.WebUI { pluginsMatchResult := webgui.PluginsMatch.FindStringSubmatch(path) if len(pluginsMatchResult) > 2 { ok := webgui.ServePluginOK(w, r, pluginsMatchResult) if !ok { r.URL.Path = fmt.Sprintf("/%s/%s/app/build/%s", pluginsMatchResult[1], pluginsMatchResult[2], pluginsMatchResult[3]) s.pluginsHandler.ServeHTTP(w, r) return } return } else if webgui.ServePluginWithReferrerOK(w, r, path) { return } } // Serve the files r.URL.Path = "/" + path s.files.ServeHTTP(w, r) return case path == "" && s.opt.Serve: // Serve the root as a remote listing s.serveRoot(w, r) return } http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound) } // Wait blocks while the server is serving requests func (s *Server) Wait() { s.server.Wait() } // Shutdown gracefully shuts down the server func (s *Server) Shutdown() error { return s.server.Shutdown() } rclone-v1.71.0/fs/rc/rcserver/rcserver_test.go000066400000000000000000000524431505210326400213460ustar00rootroot00000000000000package rcserver import ( "bytes" "context" "encoding/json" "fmt" "io" "net/http" "net/http/httptest" "os" "path/filepath" "regexp" "strings" "testing" "time" "github.com/go-chi/chi/v5" _ "github.com/rclone/rclone/backend/local" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configfile" "github.com/rclone/rclone/fs/rc" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) const ( testBindAddress = "localhost:0" defaultTestTemplate = "testdata/golden/testindex.html" testFs = "testdata/files" remoteURL = "[" + testFs + "]/" // initial URL path to fetch from that remote ) func TestMain(m *testing.M) { // Pretend to be rclone version if we have a version string parameter if os.Args[len(os.Args)-1] == "version" { fmt.Printf("rclone %s\n", fs.Version) os.Exit(0) } // Pretend to error if we have an unknown command if os.Args[len(os.Args)-1] == "unknown_command" { fmt.Printf("rclone %s\n", fs.Version) fmt.Fprintf(os.Stderr, "Unknown command\n") os.Exit(1) } os.Exit(m.Run()) } // Test the RC server runs and we can do HTTP fetches from it. // We'll do the majority of the testing with the httptest framework func TestRcServer(t *testing.T) { opt := rc.Opt opt.HTTP.ListenAddr = []string{testBindAddress} opt.Template.Path = defaultTestTemplate opt.Enabled = true opt.Serve = true opt.Files = testFs mux := http.NewServeMux() rcServer, err := newServer(context.Background(), &opt, mux) require.NoError(t, err) assert.NoError(t, rcServer.Serve()) defer func() { assert.NoError(t, rcServer.Shutdown()) rcServer.Wait() }() testURL := rcServer.server.URLs()[0] // Do the simplest possible test to check the server is alive // Do it a few times to wait for the server to start var resp *http.Response for range 10 { resp, err = http.Get(testURL + "file.txt") if err == nil { break } time.Sleep(10 * time.Millisecond) } require.NoError(t, err) body, err := io.ReadAll(resp.Body) _ = resp.Body.Close() require.NoError(t, err) require.NoError(t, resp.Body.Close()) assert.Equal(t, http.StatusOK, resp.StatusCode) assert.Equal(t, "this is file1.txt\n", string(body)) } type testRun struct { Name string URL string User string Pass string Status int Method string Range string Body string ContentType string Expected string Contains *regexp.Regexp Headers map[string]string } // Run a suite of tests func testServer(t *testing.T, tests []testRun, opt *rc.Options) { t.Helper() ctx := context.Background() configfile.Install() if opt.Template.Path == "" { opt.Template.Path = defaultTestTemplate } rcServer, err := newServer(ctx, opt, http.DefaultServeMux) require.NoError(t, err) testURL := rcServer.server.URLs()[0] mux := rcServer.server.Router() emulateCalls(t, tests, mux, testURL) } func emulateCalls(t *testing.T, tests []testRun, mux chi.Router, testURL string) { for _, test := range tests { t.Run(test.Name, func(t *testing.T) { t.Helper() method := test.Method if method == "" { method = "GET" } var inBody io.Reader if test.Body != "" { buf := bytes.NewBufferString(test.Body) inBody = buf } req, err := http.NewRequest(method, "http://1.2.3.4/"+test.URL, inBody) require.NoError(t, err) if test.Range != "" { req.Header.Add("Range", test.Range) } if test.ContentType != "" { req.Header.Add("Content-Type", test.ContentType) } if test.User != "" && test.Pass != "" { req.SetBasicAuth(test.User, test.Pass) } w := httptest.NewRecorder() mux.ServeHTTP(w, req) resp := w.Result() assert.Equal(t, test.Status, resp.StatusCode) body, err := io.ReadAll(resp.Body) require.NoError(t, err) if test.ContentType == "application/json" && test.Expected != "" { expectedNormalized := normalizeJSON(t, test.Expected) actualNormalized := normalizeJSON(t, string(body)) assert.Equal(t, expectedNormalized, actualNormalized, "Normalized JSON does not match") } else if test.Contains == nil { // go1.23 started putting an html wrapper bodyNormalized := strings.TrimPrefix(string(body), "\n\n") assert.Equal(t, test.Expected, bodyNormalized) } else { assert.True(t, test.Contains.Match(body), fmt.Sprintf("body didn't match: %v: %v", test.Contains, string(body))) } for k, v := range test.Headers { if v == "testURL" { v = testURL } assert.Equal(t, v, resp.Header.Get(k), k) } }) } } // return an enabled rc func newTestOpt() rc.Options { opt := rc.Opt opt.Enabled = true opt.HTTP.ListenAddr = []string{testBindAddress} return opt } func TestFileServing(t *testing.T) { tests := []testRun{{ Name: "index", URL: "", Status: http.StatusOK, Expected: `
    dir/
file.txt
modtime/
    `, }, { Name: "notfound", URL: "notfound", Status: http.StatusNotFound, Expected: "404 page not found\n", }, { Name: "dirnotfound", URL: "dirnotfound/", Status: http.StatusNotFound, Expected: "404 page not found\n", }, { Name: "dir", URL: "dir/", Status: http.StatusOK, Expected: `
    file2.txt
    `, }, { Name: "file", URL: "file.txt", Status: http.StatusOK, Expected: "this is file1.txt\n", Headers: map[string]string{ "Content-Length": "18", }, }, { Name: "file2", URL: "dir/file2.txt", Status: http.StatusOK, Expected: "this is dir/file2.txt\n", }, { Name: "file-head", URL: "file.txt", Method: "HEAD", Status: http.StatusOK, Expected: ``, Headers: map[string]string{ "Content-Length": "18", }, }, { Name: "file-range", URL: "file.txt", Status: http.StatusPartialContent, Range: "bytes=8-12", Expected: `file1`, }} opt := newTestOpt() opt.Serve = true opt.Files = testFs testServer(t, tests, &opt) } func TestRemoteServing(t *testing.T) { tests := []testRun{ // Test serving files from the test remote { Name: "index", URL: remoteURL + "", Status: http.StatusOK, Expected: ` Directory listing of /

    Directory listing of /

    dir/
    modtime/
    file.txt
    `, }, { Name: "notfound-index", URL: "[notfound]/", Status: http.StatusNotFound, Expected: `{ "error": "failed to list directory: directory not found", "input": null, "path": "", "status": 404 } `, }, { Name: "notfound", URL: remoteURL + "notfound", Status: http.StatusNotFound, Expected: `{ "error": "failed to find object: object not found", "input": null, "path": "notfound", "status": 404 } `, }, { Name: "dirnotfound", URL: remoteURL + "dirnotfound/", Status: http.StatusNotFound, Expected: `{ "error": "failed to list directory: directory not found", "input": null, "path": "dirnotfound", "status": 404 } `, }, { Name: "dir", URL: remoteURL + "dir/", Status: http.StatusOK, Expected: ` Directory listing of /dir

    Directory listing of /dir

    file2.txt
    `, }, { Name: "file", URL: remoteURL + "file.txt", Status: http.StatusOK, Expected: "this is file1.txt\n", Headers: map[string]string{ "Content-Length": "18", }, }, { Name: "file with no slash after ]", URL: strings.TrimRight(remoteURL, "/") + "file.txt", Status: http.StatusOK, Expected: "this is file1.txt\n", Headers: map[string]string{ "Content-Length": "18", }, }, { Name: "file2", URL: remoteURL + "dir/file2.txt", Status: http.StatusOK, Expected: "this is dir/file2.txt\n", }, { Name: "file-head", URL: remoteURL + "file.txt", Method: "HEAD", Status: http.StatusOK, Expected: ``, Headers: map[string]string{ "Content-Length": "18", }, }, { Name: "file-range", URL: remoteURL + "file.txt", Status: http.StatusPartialContent, Range: "bytes=8-12", Expected: `file1`, }, { Name: "bad-remote", URL: "[notfoundremote:]/", Status: http.StatusInternalServerError, Expected: `{ "error": "failed to make Fs: didn't find section in config file (\"notfoundremote\")", "input": null, "path": "/", "status": 500 } `, }} opt := newTestOpt() opt.Serve = true opt.Files = testFs testServer(t, tests, &opt) } func TestRC(t *testing.T) { tests := []testRun{{ Name: "rc-root", URL: "", Method: "POST", Status: http.StatusNotFound, Expected: `{ "error": "couldn't find method \"\"", "input": {}, "path": "", "status": 404 } `, }, { Name: "rc-noop", URL: "rc/noop", Method: "POST", Status: http.StatusOK, Expected: "{}\n", }, { Name: "rc-error", URL: "rc/error", Method: "POST", Status: http.StatusInternalServerError, Expected: `{ "error": "arbitrary error on input map[]", "input": {}, "path": "rc/error", "status": 500 } `, }, { Name: "core-gc", URL: "core/gc", // returns nil, nil so check it is made into {} Method: "POST", Status: http.StatusOK, Expected: "{}\n", }, { Name: "url-params", URL: "rc/noop?param1=potato¶m2=sausage", Method: "POST", Status: http.StatusOK, Expected: `{ "param1": "potato", "param2": "sausage" } `, }, { Name: "json", URL: "rc/noop", Method: "POST", Body: `{ "param1":"string", "param2":true }`, ContentType: "application/json", Status: http.StatusOK, Expected: `{ "param1": "string", "param2": true } `, }, { Name: "json-mixed-case-content-type", URL: "rc/noop", Method: "POST", Body: `{ "param1":"string", "param2":true }`, ContentType: "ApplicAtion/JsOn", Status: http.StatusOK, Expected: `{ "param1": "string", "param2": true } `, }, { Name: "json-and-url-params", URL: "rc/noop?param1=potato¶m2=sausage", Method: "POST", Body: `{ "param1":"string", "param3":true }`, ContentType: "application/json", Status: http.StatusOK, Expected: `{ "param1": "string", "param2": "sausage", "param3": true } `, }, { Name: "json-bad", URL: "rc/noop?param1=potato¶m2=sausage", Method: "POST", Body: `{ param1":"string", "param3":true }`, ContentType: "application/json", Status: http.StatusBadRequest, Expected: `{ "error": "failed to read input JSON: invalid character 'p' looking for beginning of object key string", "input": { "param1": "potato", "param2": "sausage" }, "path": "rc/noop", "status": 400 } `, }, { Name: "json-charset", URL: "rc/noop", Method: "POST", Body: `{ "param1":"string", "param2":true }`, ContentType: "application/json; charset=utf-8", Status: http.StatusOK, Expected: `{ "param1": "string", "param2": true } `, }, { Name: "json-mixed-case-charset", URL: "rc/noop", Method: "POST", Body: `{ "param1":"string", "param2":true }`, ContentType: "aPPlication/jSoN; charset=UtF-8", Status: http.StatusOK, Expected: `{ "param1": "string", "param2": true } `, }, { Name: "json-bad-charset", URL: "rc/noop", Method: "POST", Body: `{ "param1":"string", "param2":true }`, ContentType: "application/json; charset=latin1", Status: http.StatusBadRequest, Expected: `{ "error": "unsupported charset \"latin1\" for JSON input", "input": {}, "path": "rc/noop", "status": 400 } `, }, { Name: "form", URL: "rc/noop", Method: "POST", Body: `param1=string¶m2=true`, ContentType: "application/x-www-form-urlencoded", Status: http.StatusOK, Expected: `{ "param1": "string", "param2": "true" } `, }, { Name: "form-and-url-params", URL: "rc/noop?param1=potato¶m2=sausage", Method: "POST", Body: `param1=string¶m3=true`, ContentType: "application/x-www-form-urlencoded", Status: http.StatusOK, Expected: `{ "param1": "potato", "param2": "sausage", "param3": "true" } `, }, { Name: "form-bad", URL: "rc/noop?param1=potato¶m2=sausage", Method: "POST", Body: `%zz`, ContentType: "application/x-www-form-urlencoded", Status: http.StatusBadRequest, Expected: `{ "error": "failed to parse form/URL parameters: invalid URL escape \"%zz\"", "input": null, "path": "rc/noop", "status": 400 } `, }, { Name: "malformed-content-type", URL: "rc/noop", Method: "POST", ContentType: "malformed/", Status: http.StatusBadRequest, Expected: `{ "error": "failed to parse Content-Type: mime: expected token after slash", "input": null, "path": "rc/noop", "status": 400 } `, }} opt := newTestOpt() opt.Serve = true opt.Files = testFs testServer(t, tests, &opt) } func TestRCWithAuth(t *testing.T) { tests := []testRun{{ Name: "core-command", URL: "core/command", Method: "POST", Body: `command=version`, ContentType: "application/x-www-form-urlencoded", Status: http.StatusOK, Expected: fmt.Sprintf(`{ "error": false, "result": "rclone %s\n" } `, fs.Version), }, { Name: "core-command-bad-returnType", URL: "core/command", Method: "POST", Body: `command=version&returnType=POTATO`, ContentType: "application/x-www-form-urlencoded", Status: http.StatusInternalServerError, Expected: `{ "error": "unknown returnType \"POTATO\"", "input": { "command": "version", "returnType": "POTATO" }, "path": "core/command", "status": 500 } `, }, { Name: "core-command-stream", URL: "core/command", Method: "POST", Body: `command=version&returnType=STREAM`, ContentType: "application/x-www-form-urlencoded", Status: http.StatusOK, Expected: fmt.Sprintf(`rclone %s {} `, fs.Version), }, { Name: "core-command-stream-error", URL: "core/command", Method: "POST", Body: `command=unknown_command&returnType=STREAM`, ContentType: "application/x-www-form-urlencoded", Status: http.StatusOK, Expected: fmt.Sprintf(`rclone %s Unknown command { "error": "exit status 1", "input": { "command": "unknown_command", "returnType": "STREAM" }, "path": "core/command", "status": 500 } `, fs.Version), }} opt := newTestOpt() opt.Serve = true opt.Files = testFs opt.NoAuth = true testServer(t, tests, &opt) } var matchRemoteDirListing = regexp.MustCompile(`Directory listing of /`) func TestServingRoot(t *testing.T) { tests := []testRun{{ Name: "rootlist", URL: "*", Status: http.StatusOK, Contains: matchRemoteDirListing, }} opt := newTestOpt() opt.Serve = true opt.Files = testFs testServer(t, tests, &opt) } func TestServingRootNoFiles(t *testing.T) { tests := []testRun{{ Name: "rootlist", URL: "", Status: http.StatusOK, Contains: matchRemoteDirListing, }} opt := newTestOpt() opt.Serve = true opt.Files = "" testServer(t, tests, &opt) } func TestNoFiles(t *testing.T) { tests := []testRun{{ Name: "file", URL: "file.txt", Status: http.StatusNotFound, Expected: "Not Found\n", }, { Name: "dir", URL: "dir/", Status: http.StatusNotFound, Expected: "Not Found\n", }} opt := newTestOpt() opt.Serve = true opt.Files = "" testServer(t, tests, &opt) } func TestNoServe(t *testing.T) { tests := []testRun{{ Name: "file", URL: remoteURL + "file.txt", Status: http.StatusNotFound, Expected: "404 page not found\n", }, { Name: "dir", URL: remoteURL + "dir/", Status: http.StatusNotFound, Expected: "404 page not found\n", }} opt := newTestOpt() opt.Serve = false opt.Files = testFs testServer(t, tests, &opt) } func TestAuthRequired(t *testing.T) { tests := []testRun{{ Name: "auth", URL: "rc/noopauth", Method: "POST", Body: `{}`, ContentType: "application/javascript", Status: http.StatusForbidden, Expected: `{ "error": "authentication must be set up on the rc server to use \"rc/noopauth\" or the --rc-no-auth flag must be in use", "input": {}, "path": "rc/noopauth", "status": 403 } `, }} opt := newTestOpt() opt.Serve = false opt.Files = "" opt.NoAuth = false testServer(t, tests, &opt) } func TestNoAuth(t *testing.T) { tests := []testRun{{ Name: "auth", URL: "rc/noopauth", Method: "POST", Body: `{}`, ContentType: "application/javascript", Status: http.StatusOK, Expected: "{}\n", }} opt := newTestOpt() opt.Serve = false opt.Files = "" opt.NoAuth = true testServer(t, tests, &opt) } func TestWithUserPass(t *testing.T) { tests := []testRun{{ Name: "authMissing", URL: "rc/noopauth", Method: "POST", Body: `{}`, ContentType: "application/javascript", Status: http.StatusUnauthorized, Expected: "401 Unauthorized\n", }, { Name: "authWrong", URL: "rc/noopauth", Method: "POST", Body: `{}`, ContentType: "application/javascript", Status: http.StatusUnauthorized, Expected: "401 Unauthorized\n", User: "user1", Pass: "pass2", }, { Name: "authOK", URL: "rc/noopauth", Method: "POST", Body: `{}`, ContentType: "application/javascript", Status: http.StatusOK, Expected: "{}\n", User: "user", Pass: "pass", }} opt := newTestOpt() opt.Serve = false opt.Files = "" opt.NoAuth = false opt.Auth.BasicUser = "user" opt.Auth.BasicPass = "pass" testServer(t, tests, &opt) } func TestRCAsync(t *testing.T) { tests := []testRun{{ Name: "ok", URL: "rc/noop", Method: "POST", ContentType: "application/json", Body: `{ "_async":true }`, Status: http.StatusOK, Contains: regexp.MustCompile(`(?s)\{.*\"jobid\":.*\}`), }, { Name: "bad", URL: "rc/noop", Method: "POST", ContentType: "application/json", Body: `{ "_async":"truthy" }`, Status: http.StatusBadRequest, Expected: `{ "error": "couldn't parse key \"_async\" (truthy) as bool: strconv.ParseBool: parsing \"truthy\": invalid syntax", "input": { "_async": "truthy" }, "path": "rc/noop", "status": 400 } `, }} opt := newTestOpt() opt.Serve = true opt.Files = "" testServer(t, tests, &opt) } // Check the debug handlers are attached func TestRCDebug(t *testing.T) { tests := []testRun{{ Name: "index", URL: "debug/pprof/", Method: "GET", ContentType: "text/html", Status: http.StatusOK, Contains: regexp.MustCompile(`Types of profiles available`), }, { Name: "goroutines", URL: "debug/pprof/goroutine?debug=1", Method: "GET", ContentType: "text/html", Status: http.StatusOK, Contains: regexp.MustCompile(`goroutine profile`), }} opt := newTestOpt() opt.Serve = true opt.Files = "" testServer(t, tests, &opt) } func TestServeModTime(t *testing.T) { for file, mtime := range map[string]time.Time{ "dir": time.Date(2023, 4, 12, 21, 15, 17, 0, time.UTC), "modtime.txt": time.Date(2021, 1, 18, 5, 2, 28, 0, time.UTC), } { path := filepath.Join(testFs, "modtime", file) err := os.Chtimes(path, mtime, mtime) require.NoError(t, err) } opt := newTestOpt() opt.Serve = true opt.Template.Path = "testdata/golden/testmodtime.html" tests := []testRun{{ Name: "modtime", Method: "GET", URL: remoteURL + "modtime/", Status: http.StatusOK, Expected: "* dir/ - 2023-04-12T21:15:17Z\n* modtime.txt - 2021-01-18T05:02:28Z\n", }} testServer(t, tests, &opt) opt.ServeNoModTime = true tests = []testRun{{ Name: "no modtime", Method: "GET", URL: remoteURL + "modtime/", Status: http.StatusOK, Expected: "* dir/ - 0001-01-01T00:00:00Z\n* modtime.txt - 0001-01-01T00:00:00Z\n", }} testServer(t, tests, &opt) } func TestContentTypeJSON(t *testing.T) { tests := []testRun{ { Name: "Check Content-Type for JSON response", URL: "rc/noop", Method: "POST", Body: `{}`, ContentType: "application/json", Status: http.StatusOK, Expected: "{}\n", Headers: map[string]string{ "Content-Type": "application/json", }, }, { Name: "Check Content-Type for JSON error response", URL: "rc/error", Method: "POST", Body: `{}`, ContentType: "application/json", Status: http.StatusInternalServerError, Expected: `{ "error": "arbitrary error on input map[]", "input": {}, "path": "rc/error", "status": 500 } `, Headers: map[string]string{ "Content-Type": "application/json", }, }, } opt := newTestOpt() testServer(t, tests, &opt) } func normalizeJSON(t *testing.T, jsonStr string) string { var jsonObj map[string]any err := json.Unmarshal([]byte(jsonStr), &jsonObj) require.NoError(t, err, "JSON unmarshalling failed") normalizedJSON, err := json.Marshal(jsonObj) require.NoError(t, err, "JSON marshalling failed") return string(normalizedJSON) } rclone-v1.71.0/fs/rc/rcserver/testdata/000077500000000000000000000000001505210326400177265ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/rcserver/testdata/files/000077500000000000000000000000001505210326400210305ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/rcserver/testdata/files/dir/000077500000000000000000000000001505210326400216065ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/rcserver/testdata/files/dir/file2.txt000066400000000000000000000000261505210326400233460ustar00rootroot00000000000000this is dir/file2.txt rclone-v1.71.0/fs/rc/rcserver/testdata/files/file.txt000066400000000000000000000000221505210326400225020ustar00rootroot00000000000000this is file1.txt rclone-v1.71.0/fs/rc/rcserver/testdata/files/modtime/000077500000000000000000000000001505210326400224665ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/rcserver/testdata/files/modtime/dir/000077500000000000000000000000001505210326400232445ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/rcserver/testdata/files/modtime/dir/.gitkeep000066400000000000000000000000001505210326400246630ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/rcserver/testdata/files/modtime/modtime.txt000066400000000000000000000000001505210326400246530ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/rcserver/testdata/golden/000077500000000000000000000000001505210326400211765ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/rcserver/testdata/golden/testindex.html000066400000000000000000000003421505210326400240720ustar00rootroot00000000000000 {{ .Title }}

    {{ .Title }}

    {{ range $i := .Entries }}{{ $i.Leaf }}
    {{ end }} rclone-v1.71.0/fs/rc/rcserver/testdata/golden/testmodtime.html000066400000000000000000000001431505210326400244200ustar00rootroot00000000000000{{ range .Entries }}* {{ .Leaf }} - {{ .ModTime.UTC.Format "2006-01-02T15:04:05Z07:00" }} {{ end }}rclone-v1.71.0/fs/rc/registry.go000066400000000000000000000040231505210326400164600ustar00rootroot00000000000000// Define the registry package rc import ( "context" "sort" "strings" "sync" ) // Func defines a type for a remote control function type Func func(ctx context.Context, in Params) (out Params, err error) // Call defines info about a remote control function and is used in // the Add function to create new entry points. type Call struct { Path string // path to activate this RC Fn Func `json:"-"` // function to call Title string // help for the function AuthRequired bool // if set then this call requires authorisation to be set Help string // multi-line markdown formatted help NeedsRequest bool // if set then this call will be passed the original request object as _request NeedsResponse bool // if set then this call will be passed the original response object as _response } // Registry holds the list of all the registered remote control functions type Registry struct { mu sync.RWMutex call map[string]*Call } // NewRegistry makes a new registry for remote control functions func NewRegistry() *Registry { return &Registry{ call: make(map[string]*Call), } } // Add a call to the registry func (r *Registry) Add(call Call) { r.mu.Lock() defer r.mu.Unlock() call.Path = strings.Trim(call.Path, "/") call.Help = strings.TrimSpace(call.Help) // fs.Debugf(nil, "Adding path %q to remote control registry", call.Path) // disabled to make initialization less verbose r.call[call.Path] = &call } // Get a Call from a path or nil func (r *Registry) Get(path string) *Call { r.mu.RLock() defer r.mu.RUnlock() return r.call[path] } // List of all calls in alphabetical order func (r *Registry) List() (out []*Call) { r.mu.RLock() defer r.mu.RUnlock() var keys []string for key := range r.call { keys = append(keys, key) } sort.Strings(keys) for _, key := range keys { out = append(out, r.call[key]) } return out } // Calls is the global registry of Call objects var Calls = NewRegistry() // Add a function to the global registry func Add(call Call) { Calls.Add(call) } rclone-v1.71.0/fs/rc/webgui/000077500000000000000000000000001505210326400155445ustar00rootroot00000000000000rclone-v1.71.0/fs/rc/webgui/plugins.go000066400000000000000000000176101505210326400175610ustar00rootroot00000000000000// Package webgui provides plugin functionality to the Web GUI. package webgui import ( "encoding/json" "errors" "fmt" "net/http" "net/http/httputil" "net/url" "os" "path/filepath" "regexp" "strings" "sync" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/rc" ) // PackageJSON is the structure of package.json of a plugin type PackageJSON struct { Name string `json:"name"` Version string `json:"version"` Description string `json:"description"` Author string `json:"author"` Copyright string `json:"copyright"` License string `json:"license"` Private bool `json:"private"` Homepage string `json:"homepage"` TestURL string `json:"testUrl"` Repository struct { Type string `json:"type"` URL string `json:"url"` } `json:"repository"` Bugs struct { URL string `json:"url"` } `json:"bugs"` Rclone RcloneConfig `json:"rclone"` } // RcloneConfig represents the rclone specific config type RcloneConfig struct { HandlesType []string `json:"handlesType"` PluginType string `json:"pluginType"` RedirectReferrer bool `json:"redirectReferrer"` Test bool `json:"-"` } func (r *PackageJSON) isTesting() bool { return r.Rclone.Test } var ( //loadedTestPlugins *Plugins cachePath string loadedPlugins *Plugins pluginsProxy = &httputil.ReverseProxy{} // PluginsMatch is used for matching author and plugin name in the url path PluginsMatch = regexp.MustCompile(`^plugins\/([^\/]*)\/([^\/\?]+)[\/]?(.*)$`) // PluginsPath is the base path where webgui plugins are stored PluginsPath string pluginsConfigPath string availablePluginsJSONPath = "availablePlugins.json" initSuccess = false initMutex = &sync.Mutex{} ) // Plugins represents the structure how plugins are saved onto disk type Plugins struct { mutex sync.Mutex LoadedPlugins map[string]PackageJSON `json:"loadedPlugins"` fileName string } func newPlugins(fileName string) *Plugins { p := Plugins{LoadedPlugins: map[string]PackageJSON{}} p.fileName = fileName p.mutex = sync.Mutex{} return &p } func initPluginsOrError() error { if !rc.Opt.WebUI { return errors.New("WebUI needs to be enabled for plugins to work") } initMutex.Lock() defer initMutex.Unlock() if !initSuccess { cachePath = filepath.Join(config.GetCacheDir(), "webgui") PluginsPath = filepath.Join(cachePath, "plugins") pluginsConfigPath = filepath.Join(PluginsPath, "config") loadedPlugins = newPlugins(availablePluginsJSONPath) err := loadedPlugins.readFromFile() if err != nil { fs.Errorf(nil, "error reading available plugins: %v", err) } initSuccess = true } return nil } func (p *Plugins) readFromFile() (err error) { err = CreatePathIfNotExist(pluginsConfigPath) if err != nil { return err } availablePluginsJSON := filepath.Join(pluginsConfigPath, p.fileName) _, err = os.Stat(availablePluginsJSON) if err == nil { data, err := os.ReadFile(availablePluginsJSON) if err != nil { return err } err = json.Unmarshal(data, &p) if err != nil { fs.Logf(nil, "%s", err) } return nil } else if os.IsNotExist(err) { // path does not exist err = p.writeToFile() if err != nil { return err } } return nil } func (p *Plugins) addPlugin(pluginName string, packageJSONPath string) (err error) { p.mutex.Lock() defer p.mutex.Unlock() data, err := os.ReadFile(packageJSONPath) if err != nil { return err } var pkgJSON = PackageJSON{} err = json.Unmarshal(data, &pkgJSON) if err != nil { return err } p.LoadedPlugins[pluginName] = pkgJSON err = p.writeToFile() if err != nil { return err } return nil } func (p *Plugins) writeToFile() (err error) { availablePluginsJSON := filepath.Join(pluginsConfigPath, p.fileName) file, err := json.MarshalIndent(p, "", " ") if err != nil { fs.Logf(nil, "%s", err) } err = os.WriteFile(availablePluginsJSON, file, 0755) if err != nil { fs.Logf(nil, "%s", err) } return nil } func (p *Plugins) removePlugin(name string) (err error) { p.mutex.Lock() defer p.mutex.Unlock() err = p.readFromFile() if err != nil { return err } _, ok := p.LoadedPlugins[name] if !ok { return fmt.Errorf("plugin %s not loaded", name) } delete(p.LoadedPlugins, name) err = p.writeToFile() if err != nil { return err } return nil } // GetPluginByName returns the plugin object for the key (author/plugin-name) func (p *Plugins) GetPluginByName(name string) (out *PackageJSON, err error) { p.mutex.Lock() defer p.mutex.Unlock() po, ok := p.LoadedPlugins[name] if !ok { return nil, fmt.Errorf("plugin %s not loaded", name) } return &po, nil } // getAuthorRepoBranchGitHub gives author, repoName and branch from a github.com url // // url examples: // https://github.com/rclone/rclone-webui-react/ // http://github.com/rclone/rclone-webui-react // https://github.com/rclone/rclone-webui-react/tree/caman-js // github.com/rclone/rclone-webui-react func getAuthorRepoBranchGitHub(url string) (author string, repoName string, branch string, err error) { repoURL := url repoURL = strings.Replace(repoURL, "https://", "", 1) repoURL = strings.Replace(repoURL, "http://", "", 1) urlSplits := strings.Split(repoURL, "/") if len(urlSplits) < 3 || len(urlSplits) > 5 || urlSplits[0] != "github.com" { return "", "", "", fmt.Errorf("invalid github url: %s", url) } // get branch name if len(urlSplits) == 5 && urlSplits[3] == "tree" { return urlSplits[1], urlSplits[2], urlSplits[4], nil } return urlSplits[1], urlSplits[2], "master", nil } func filterPlugins(plugins *Plugins, compare func(packageJSON *PackageJSON) bool) map[string]PackageJSON { output := map[string]PackageJSON{} for key, val := range plugins.LoadedPlugins { if compare(&val) { output[key] = val } } return output } // getDirectorForProxy is a helper function for reverse proxy of test plugins func getDirectorForProxy(origin *url.URL) func(req *http.Request) { return func(req *http.Request) { req.Header.Add("X-Forwarded-Host", req.Host) req.Header.Add("X-Origin-Host", origin.Host) req.URL.Scheme = "http" req.URL.Host = origin.Host req.URL.Path = origin.Path } } // ServePluginOK checks the plugin url and uses reverse proxy to allow redirection for content not being served by rclone func ServePluginOK(w http.ResponseWriter, r *http.Request, pluginsMatchResult []string) (ok bool) { testPlugin, err := loadedPlugins.GetPluginByName(fmt.Sprintf("%s/%s", pluginsMatchResult[1], pluginsMatchResult[2])) if err != nil { return false } if !testPlugin.Rclone.Test { return false } origin, _ := url.Parse(fmt.Sprintf("%s/%s", testPlugin.TestURL, pluginsMatchResult[3])) director := getDirectorForProxy(origin) pluginsProxy.Director = director pluginsProxy.ServeHTTP(w, r) return true } var referrerPathReg = regexp.MustCompile(`^(https?):\/\/(.+):([0-9]+)?\/(.*)\/?\?(.*)$`) // ServePluginWithReferrerOK check if redirectReferrer is set for the referred a plugin, if yes, // sends a redirect to actual url. This function is useful for plugins to refer to absolute paths when // the referrer in http.Request is set func ServePluginWithReferrerOK(w http.ResponseWriter, r *http.Request, path string) (ok bool) { err := initPluginsOrError() if err != nil { return false } referrer := r.Referer() referrerPathMatch := referrerPathReg.FindStringSubmatch(referrer) if len(referrerPathMatch) > 3 { referrerPluginMatch := PluginsMatch.FindStringSubmatch(referrerPathMatch[4]) if len(referrerPluginMatch) > 2 { pluginKey := fmt.Sprintf("%s/%s", referrerPluginMatch[1], referrerPluginMatch[2]) currentPlugin, err := loadedPlugins.GetPluginByName(pluginKey) if err != nil { return false } if currentPlugin.Rclone.RedirectReferrer { path = fmt.Sprintf("/plugins/%s/%s/%s", referrerPluginMatch[1], referrerPluginMatch[2], path) http.Redirect(w, r, path, http.StatusMovedPermanently) return true } } } return false } rclone-v1.71.0/fs/rc/webgui/rc.go000066400000000000000000000200471505210326400165020ustar00rootroot00000000000000package webgui import ( "context" "fmt" "os" "path/filepath" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/rc" ) func init() { rc.Add(rc.Call{ Path: "pluginsctl/listTestPlugins", AuthRequired: true, Fn: rcListTestPlugins, Title: "Show currently loaded test plugins", Help: `Allows listing of test plugins with the rclone.test set to true in package.json of the plugin. This takes no parameters and returns: - loadedTestPlugins - list of currently available test plugins. E.g. rclone rc pluginsctl/listTestPlugins `, }) } func rcListTestPlugins(_ context.Context, _ rc.Params) (out rc.Params, err error) { err = initPluginsOrError() if err != nil { return nil, err } return rc.Params{ "loadedTestPlugins": filterPlugins(loadedPlugins, func(json *PackageJSON) bool { return json.isTesting() }), }, nil } func init() { rc.Add(rc.Call{ Path: "pluginsctl/removeTestPlugin", AuthRequired: true, Fn: rcRemoveTestPlugin, Title: "Remove a test plugin", Help: `This allows you to remove a plugin using it's name. This takes the following parameters: - name - name of the plugin in the format ` + "`author`/`plugin_name`" + `. Example: rclone rc pluginsctl/removeTestPlugin name=rclone/rclone-webui-react `, }) } func rcRemoveTestPlugin(_ context.Context, in rc.Params) (out rc.Params, err error) { err = initPluginsOrError() if err != nil { return nil, err } name, err := in.GetString("name") if err != nil { return nil, err } err = loadedPlugins.removePlugin(name) if err != nil { return nil, err } return nil, nil } func init() { rc.Add(rc.Call{ Path: "pluginsctl/addPlugin", AuthRequired: true, Fn: rcAddPlugin, Title: "Add a plugin using url", Help: `Used for adding a plugin to the webgui. This takes the following parameters: - url - http url of the github repo where the plugin is hosted (http://github.com/rclone/rclone-webui-react). Example: rclone rc pluginsctl/addPlugin `, }) } func rcAddPlugin(_ context.Context, in rc.Params) (out rc.Params, err error) { err = initPluginsOrError() if err != nil { return nil, err } pluginURL, err := in.GetString("url") if err != nil { return nil, err } author, repoName, repoBranch, err := getAuthorRepoBranchGitHub(pluginURL) if err != nil { return nil, err } branch, err := in.GetString("branch") if err != nil || branch == "" { branch = repoBranch } version, err := in.GetString("version") if err != nil || version == "" { version = "latest" } err = CreatePathIfNotExist(PluginsPath) if err != nil { return nil, err } // fetch and package.json // https://raw.githubusercontent.com/rclone/rclone-webui-react/master/package.json pluginID := fmt.Sprintf("%s/%s", author, repoName) currentPluginPath := filepath.Join(PluginsPath, pluginID) err = CreatePathIfNotExist(currentPluginPath) if err != nil { return nil, err } packageJSONUrl := fmt.Sprintf("https://raw.githubusercontent.com/%s/%s/%s/package.json", author, repoName, branch) packageJSONFilePath := filepath.Join(currentPluginPath, "package.json") err = DownloadFile(packageJSONFilePath, packageJSONUrl) if err != nil { return nil, err } // register in plugins // download release and save in plugins//repo-name/app // https://api.github.com/repos/rclone/rclone-webui-react/releases/latest releaseURL, tag, _, err := GetLatestReleaseURL(fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/%s", author, repoName, version)) if err != nil { return nil, err } zipName := tag + ".zip" zipPath := filepath.Join(currentPluginPath, zipName) err = DownloadFile(zipPath, releaseURL) if err != nil { return nil, err } extractPath := filepath.Join(currentPluginPath, "app") err = CreatePathIfNotExist(extractPath) if err != nil { return nil, err } err = os.RemoveAll(extractPath) if err != nil { fs.Logf(nil, "No previous downloads to remove") } fs.Logf(nil, "Unzipping plugin binary") err = Unzip(zipPath, extractPath) if err != nil { return nil, err } err = loadedPlugins.addPlugin(pluginID, packageJSONFilePath) if err != nil { return nil, err } return nil, nil } func init() { rc.Add(rc.Call{ Path: "pluginsctl/listPlugins", AuthRequired: true, Fn: rcGetPlugins, Title: "Get the list of currently loaded plugins", Help: `This allows you to get the currently enabled plugins and their details. This takes no parameters and returns: - loadedPlugins - list of current production plugins. - testPlugins - list of temporarily loaded development plugins, usually running on a different server. E.g. rclone rc pluginsctl/listPlugins `, }) } func rcGetPlugins(_ context.Context, _ rc.Params) (out rc.Params, err error) { err = initPluginsOrError() if err != nil { return nil, err } err = loadedPlugins.readFromFile() if err != nil { return nil, err } return rc.Params{ "loadedPlugins": filterPlugins(loadedPlugins, func(packageJSON *PackageJSON) bool { return !packageJSON.isTesting() }), "loadedTestPlugins": filterPlugins(loadedPlugins, func(packageJSON *PackageJSON) bool { return packageJSON.isTesting() }), }, nil } func init() { rc.Add(rc.Call{ Path: "pluginsctl/removePlugin", AuthRequired: true, Fn: rcRemovePlugin, Title: "Remove a loaded plugin", Help: `This allows you to remove a plugin using it's name. This takes parameters: - name - name of the plugin in the format ` + "`author`/`plugin_name`" + `. E.g. rclone rc pluginsctl/removePlugin name=rclone/video-plugin `, }) } func rcRemovePlugin(_ context.Context, in rc.Params) (out rc.Params, err error) { err = initPluginsOrError() if err != nil { return nil, err } name, err := in.GetString("name") if err != nil { return nil, err } err = loadedPlugins.removePlugin(name) if err != nil { return nil, err } return nil, nil } func init() { rc.Add(rc.Call{ Path: "pluginsctl/getPluginsForType", AuthRequired: true, Fn: rcGetPluginsForType, Title: "Get plugins with type criteria", Help: `This shows all possible plugins by a mime type. This takes the following parameters: - type - supported mime type by a loaded plugin e.g. (video/mp4, audio/mp3). - pluginType - filter plugins based on their type e.g. (DASHBOARD, FILE_HANDLER, TERMINAL). Returns: - loadedPlugins - list of current production plugins. - testPlugins - list of temporarily loaded development plugins, usually running on a different server. Example: rclone rc pluginsctl/getPluginsForType type=video/mp4 `, }) } func rcGetPluginsForType(_ context.Context, in rc.Params) (out rc.Params, err error) { err = initPluginsOrError() if err != nil { return nil, err } handlesType, err := in.GetString("type") if err != nil { handlesType = "" } pluginType, err := in.GetString("pluginType") if err != nil { pluginType = "" } var loadedPluginsResult map[string]PackageJSON var loadedTestPluginsResult map[string]PackageJSON if pluginType == "" || pluginType == "FileHandler" { loadedPluginsResult = filterPlugins(loadedPlugins, func(packageJSON *PackageJSON) bool { for i := range packageJSON.Rclone.HandlesType { if packageJSON.Rclone.HandlesType[i] == handlesType && !packageJSON.Rclone.Test { return true } } return false }) loadedTestPluginsResult = filterPlugins(loadedPlugins, func(packageJSON *PackageJSON) bool { for i := range packageJSON.Rclone.HandlesType { if packageJSON.Rclone.HandlesType[i] == handlesType && packageJSON.Rclone.Test { return true } } return false }) } else { loadedPluginsResult = filterPlugins(loadedPlugins, func(packageJSON *PackageJSON) bool { return packageJSON.Rclone.PluginType == pluginType && !packageJSON.isTesting() }) loadedTestPluginsResult = filterPlugins(loadedPlugins, func(packageJSON *PackageJSON) bool { return packageJSON.Rclone.PluginType == pluginType && packageJSON.isTesting() }) } return rc.Params{ "loadedPlugins": loadedPluginsResult, "loadedTestPlugins": loadedTestPluginsResult, }, nil } rclone-v1.71.0/fs/rc/webgui/rc_test.go000066400000000000000000000066411505210326400175450ustar00rootroot00000000000000package webgui import ( "context" "path/filepath" "strings" "testing" "github.com/rclone/rclone/fs/rc" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) const testPluginName = "rclone-test-plugin" const testPluginAuthor = "rclone" const testPluginKey = testPluginAuthor + "/" + testPluginName const testPluginURL = "https://github.com/" + testPluginAuthor + "/" + testPluginName + "/" func init() { rc.Opt.WebUI = true } func setCacheDir(t *testing.T) { cacheDir := t.TempDir() PluginsPath = filepath.Join(cacheDir, "plugins") pluginsConfigPath = filepath.Join(cacheDir, "config") loadedPlugins = newPlugins(availablePluginsJSONPath) err := loadedPlugins.readFromFile() assert.Nil(t, err) } func addPlugin(t *testing.T) { addPlugin := rc.Calls.Get("pluginsctl/addPlugin") assert.NotNil(t, addPlugin) in := rc.Params{ "url": testPluginURL, } out, err := addPlugin.Fn(context.Background(), in) if err != nil && strings.Contains(err.Error(), "bad HTTP status") { t.Skipf("skipping test as plugin download failed: %v", err) } require.Nil(t, err) assert.Nil(t, out) } func removePlugin(t *testing.T) { addPlugin := rc.Calls.Get("pluginsctl/removePlugin") assert.NotNil(t, addPlugin) in := rc.Params{ "name": testPluginKey, } out, err := addPlugin.Fn(context.Background(), in) assert.NotNil(t, err) assert.Nil(t, out) } //func TestListTestPlugins(t *testing.T) { // addPlugin := rc.Calls.Get("pluginsctl/listTestPlugins") // assert.NotNil(t, addPlugin) // in := rc.Params{} // out, err := addPlugin.Fn(context.Background(), in) // assert.Nil(t, err) // expected := rc.Params{ // "loadedTestPlugins": map[string]PackageJSON{}, // } // assert.Equal(t, expected, out) //} //func TestRemoveTestPlugin(t *testing.T) { // addPlugin := rc.Calls.Get("pluginsctl/removeTestPlugin") // assert.NotNil(t, addPlugin) // in := rc.Params{ // "name": "", // } // out, err := addPlugin.Fn(context.Background(), in) // assert.NotNil(t, err) // assert.Nil(t, out) //} func TestAddPlugin(t *testing.T) { setCacheDir(t) addPlugin(t) _, ok := loadedPlugins.LoadedPlugins[testPluginKey] assert.True(t, ok) //removePlugin(t) //_, ok = loadedPlugins.LoadedPlugins[testPluginKey] //assert.False(t, ok) } func TestListPlugins(t *testing.T) { setCacheDir(t) addPlugin := rc.Calls.Get("pluginsctl/listPlugins") assert.NotNil(t, addPlugin) in := rc.Params{} out, err := addPlugin.Fn(context.Background(), in) assert.Nil(t, err) expected := rc.Params{ "loadedPlugins": map[string]PackageJSON{}, "loadedTestPlugins": map[string]PackageJSON{}, } assert.Equal(t, expected, out) } func TestRemovePlugin(t *testing.T) { setCacheDir(t) addPlugin(t) removePluginCall := rc.Calls.Get("pluginsctl/removePlugin") assert.NotNil(t, removePlugin) in := rc.Params{ "name": testPluginKey, } out, err := removePluginCall.Fn(context.Background(), in) assert.Nil(t, err) assert.Nil(t, out) removePlugin(t) assert.Equal(t, len(loadedPlugins.LoadedPlugins), 0) } func TestPluginsForType(t *testing.T) { addPlugin := rc.Calls.Get("pluginsctl/getPluginsForType") assert.NotNil(t, addPlugin) in := rc.Params{ "type": "", "pluginType": "FileHandler", } out, err := addPlugin.Fn(context.Background(), in) assert.Nil(t, err) assert.NotNil(t, out) in = rc.Params{ "type": "video/mp4", "pluginType": "", } _, err = addPlugin.Fn(context.Background(), in) assert.Nil(t, err) assert.NotNil(t, out) } rclone-v1.71.0/fs/rc/webgui/webgui.go000066400000000000000000000172051505210326400173620ustar00rootroot00000000000000// Package webgui defines the Web GUI helpers. package webgui import ( "archive/zip" "encoding/json" "errors" "fmt" "io" "net/http" "os" "path/filepath" "strconv" "strings" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/lib/file" ) // GetLatestReleaseURL returns the latest release details of the rclone-webui-react func GetLatestReleaseURL(fetchURL string) (string, string, int, error) { resp, err := http.Get(fetchURL) if err != nil { return "", "", 0, fmt.Errorf("failed getting latest release of rclone-webui: %w", err) } defer fs.CheckClose(resp.Body, &err) if resp.StatusCode != http.StatusOK { return "", "", 0, fmt.Errorf("bad HTTP status %d (%s) when fetching %s", resp.StatusCode, resp.Status, fetchURL) } results := gitHubRequest{} if err := json.NewDecoder(resp.Body).Decode(&results); err != nil { return "", "", 0, fmt.Errorf("could not decode results from http request: %w", err) } if len(results.Assets) < 1 { return "", "", 0, errors.New("could not find an asset in the release. " + "check if asset was successfully added in github release assets") } res := results.Assets[0].BrowserDownloadURL tag := results.TagName size := results.Assets[0].Size return res, tag, size, nil } // CheckAndDownloadWebGUIRelease is a helper function to download and setup latest release of rclone-webui-react func CheckAndDownloadWebGUIRelease(checkUpdate bool, forceUpdate bool, fetchURL string, cacheDir string) (err error) { cachePath := filepath.Join(cacheDir, "webgui") tagPath := filepath.Join(cachePath, "tag") extractPath := filepath.Join(cachePath, "current") extractPathExist, extractPathStat, err := exists(extractPath) if err != nil { return err } if extractPathExist && !extractPathStat.IsDir() { return errors.New("Web GUI path exists, but is a file instead of folder. Please check the path " + extractPath) } // Get the latest release details WebUIURL, tag, size, err := GetLatestReleaseURL(fetchURL) if err != nil { return fmt.Errorf("error checking for web gui release update, skipping update: %w", err) } dat, err := os.ReadFile(tagPath) tagsMatch := false if err != nil { fs.Errorf(nil, "Error reading tag file at %s ", tagPath) checkUpdate = true } else if string(dat) == tag { tagsMatch = true } fs.Debugf(nil, "Current tag: %s, Release tag: %s", string(dat), tag) if !tagsMatch { fs.Infof(nil, "A release (%s) for gui is present at %s. Use --rc-web-gui-update to update. Your current version is (%s)", tag, WebUIURL, string(dat)) } // if the old file exists does not exist or forced update is enforced. // TODO: Add hashing to check integrity of the previous update. if !extractPathExist || checkUpdate || forceUpdate { if tagsMatch { fs.Logf(nil, "No update to Web GUI available.") if !forceUpdate { return nil } fs.Logf(nil, "Force update the Web GUI binary.") } zipName := tag + ".zip" zipPath := filepath.Join(cachePath, zipName) cachePathExist, cachePathStat, _ := exists(cachePath) if !cachePathExist { if err := file.MkdirAll(cachePath, 0755); err != nil { return errors.New("Error creating cache directory: " + cachePath) } } if cachePathExist && !cachePathStat.IsDir() { return errors.New("Web GUI path is a file instead of folder. Please check it " + extractPath) } fs.Logf(nil, "A new release for gui (%s) is present at %s", tag, WebUIURL) fs.Logf(nil, "Downloading webgui binary. Please wait. [Size: %s, Path : %s]\n", strconv.Itoa(size), zipPath) // download the zip from latest url err = DownloadFile(zipPath, WebUIURL) if err != nil { return err } err = os.RemoveAll(extractPath) if err != nil { fs.Logf(nil, "No previous downloads to remove") } fs.Logf(nil, "Unzipping webgui binary") err = Unzip(zipPath, extractPath) if err != nil { return err } err = os.RemoveAll(zipPath) if err != nil { fs.Logf(nil, "Downloaded ZIP cannot be deleted") } err = os.WriteFile(tagPath, []byte(tag), 0644) if err != nil { fs.Infof(nil, "Cannot write tag file. You may be required to redownload the binary next time.") } } else { fs.Logf(nil, "Web GUI exists. Update skipped.") } return nil } // DownloadFile is a helper function to download a file from url to the filepath func DownloadFile(filepath string, url string) (err error) { // Get the data resp, err := http.Get(url) if err != nil { return err } defer fs.CheckClose(resp.Body, &err) if resp.StatusCode != http.StatusOK { return fmt.Errorf("bad HTTP status %d (%s) when fetching %s", resp.StatusCode, resp.Status, url) } // Create the file out, err := os.Create(filepath) if err != nil { return err } defer fs.CheckClose(out, &err) // Write the body to file _, err = io.Copy(out, resp.Body) return err } // Unzip is a helper function to Unzip a file specified in src to path dest func Unzip(src, dest string) (err error) { dest = filepath.Clean(dest) + string(os.PathSeparator) r, err := zip.OpenReader(src) if err != nil { return err } defer fs.CheckClose(r, &err) if err := file.MkdirAll(dest, 0755); err != nil { return err } // Closure to address file descriptors issue with all the deferred .Close() methods extractAndWriteFile := func(f *zip.File) error { path := filepath.Join(dest, f.Name) // Check for Zip Slip: https://github.com/rclone/rclone/issues/3529 if !strings.HasPrefix(path, dest) { return fmt.Errorf("%s: illegal file path", path) } rc, err := f.Open() if err != nil { return err } defer fs.CheckClose(rc, &err) if f.FileInfo().IsDir() { if err := file.MkdirAll(path, 0755); err != nil { return err } } else { if err := file.MkdirAll(filepath.Dir(path), 0755); err != nil { return err } f, err := file.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644) if err != nil { return err } defer fs.CheckClose(f, &err) _, err = io.Copy(f, rc) if err != nil { return err } } return nil } for _, f := range r.File { err := extractAndWriteFile(f) if err != nil { return err } } return nil } func exists(path string) (existence bool, stat os.FileInfo, err error) { stat, err = os.Stat(path) if err == nil { return true, stat, nil } if os.IsNotExist(err) { return false, nil, nil } return false, stat, err } // CreatePathIfNotExist creates the path to a folder if it does not exist func CreatePathIfNotExist(path string) (err error) { exists, stat, _ := exists(path) if !exists { if err := file.MkdirAll(path, 0755); err != nil { return errors.New("Error creating : " + path) } } if exists && !stat.IsDir() { return errors.New("Path is a file instead of folder. Please check it " + path) } return nil } // gitHubRequest Maps the GitHub API request to structure type gitHubRequest struct { URL string `json:"url"` Prerelease bool `json:"prerelease"` CreatedAt time.Time `json:"created_at"` PublishedAt time.Time `json:"published_at"` TagName string `json:"tag_name"` Assets []struct { URL string `json:"url"` ID int `json:"id"` NodeID string `json:"node_id"` Name string `json:"name"` Label string `json:"label"` ContentType string `json:"content_type"` State string `json:"state"` Size int `json:"size"` DownloadCount int `json:"download_count"` CreatedAt time.Time `json:"created_at"` UpdatedAt time.Time `json:"updated_at"` BrowserDownloadURL string `json:"browser_download_url"` } `json:"assets"` TarballURL string `json:"tarball_url"` ZipballURL string `json:"zipball_url"` Body string `json:"body"` } rclone-v1.71.0/fs/registry.go000066400000000000000000000407371505210326400160700ustar00rootroot00000000000000// Filesystem registry and backend options package fs import ( "context" "encoding/json" "fmt" "reflect" "regexp" "slices" "sort" "strings" "sync" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/config/configstruct" "github.com/rclone/rclone/lib/errcount" ) // Registry of filesystems var Registry []*RegInfo // optDescription is a basic description option var optDescription = Option{ Name: "description", Help: "Description of the remote.", Default: "", Advanced: true, } // RegInfo provides information about a filesystem type RegInfo struct { // Name of this fs Name string // Description of this fs - defaults to Name Description string // Prefix for command line flags for this fs - defaults to Name if not set Prefix string // Create a new file system. If root refers to an existing // object, then it should return an Fs which points to // the parent of that object and ErrorIsFile. NewFs func(ctx context.Context, name string, root string, config configmap.Mapper) (Fs, error) `json:"-"` // Function to call to help with config - see docs for ConfigIn for more info Config func(ctx context.Context, name string, m configmap.Mapper, configIn ConfigIn) (*ConfigOut, error) `json:"-"` // Options for the Fs configuration Options Options // The command help, if any CommandHelp []CommandHelp // Aliases - other names this backend is known by Aliases []string // Hide - if set don't show in the configurator Hide bool // MetadataInfo help about the metadata in use in this backend MetadataInfo *MetadataInfo } // FileName returns the on disk file name for this backend func (ri *RegInfo) FileName() string { return strings.ReplaceAll(ri.Name, " ", "") } // Options is a slice of configuration Option for a backend type Options []Option // Add more options returning a new options slice func (os Options) Add(newOptions Options) Options { return append(os, newOptions...) } // AddPrefix adds more options with a prefix returning a new options slice func (os Options) AddPrefix(newOptions Options, prefix string, groups string) Options { for _, opt := range newOptions { // opt is a copy so can modify opt.Name = prefix + "_" + opt.Name opt.Groups = groups os = append(os, opt) } return os } // Set the default values for the options func (os Options) setValues() { for i := range os { o := &os[i] if o.Default == nil { o.Default = "" } // Create options for Enums if do, ok := o.Default.(Choices); ok && len(o.Examples) == 0 { o.Exclusive = true o.Required = true o.Examples = make(OptionExamples, len(do.Choices())) for i, choice := range do.Choices() { o.Examples[i].Value = choice } } } } // Get the Option corresponding to name or return nil if not found func (os Options) Get(name string) *Option { for i := range os { opt := &os[i] if opt.Name == name { return opt } } return nil } // SetDefault sets the default for the Option corresponding to name // // Writes an ERROR level log if the option is not found func (os Options) SetDefault(name string, def any) Options { opt := os.Get(name) if opt == nil { Errorf(nil, "Couldn't find option %q to SetDefault on", name) } else { opt.Default = def } return os } // Overridden discovers which config items have been overridden in the // configmap passed in, either by the config string, command line // flags or environment variables func (os Options) Overridden(m *configmap.Map) configmap.Simple { var overridden = configmap.Simple{} for i := range os { opt := &os[i] value, isSet := m.GetPriority(opt.Name, configmap.PriorityNormal) if isSet { overridden.Set(opt.Name, value) } } return overridden } // NonDefault discovers which config values aren't at their default func (os Options) NonDefault(m configmap.Getter) configmap.Simple { var nonDefault = configmap.Simple{} for i := range os { opt := &os[i] value, isSet := m.Get(opt.Name) if !isSet { continue } defaultValue := fmt.Sprint(opt.Default) if value != defaultValue { nonDefault.Set(opt.Name, value) } } return nonDefault } // HasAdvanced discovers if any options have an Advanced setting func (os Options) HasAdvanced() bool { for i := range os { opt := &os[i] if opt.Advanced { return true } } return false } // OptionVisibility controls whether the options are visible in the // configurator or the command line. type OptionVisibility byte // Constants Option.Hide const ( OptionHideCommandLine OptionVisibility = 1 << iota OptionHideConfigurator OptionHideBoth = OptionHideCommandLine | OptionHideConfigurator ) // Option is describes an option for the config wizard // // This also describes command line options and environment variables. // // It is also used to describe options for the API. // // To create a multiple-choice option, specify the possible values // in the Examples property. Whether the option's value is required // to be one of these depends on other properties: // - Default is to allow any value, either from specified examples, // or any other value. To restrict exclusively to the specified // examples, also set Exclusive=true. // - If empty string should not be allowed then set Required=true, // and do not set Default. type Option struct { Name string // name of the option in snake_case FieldName string // name of the field used in the rc JSON - will be auto filled normally Help string // help, start with a single sentence on a single line that will be extracted for command line help Groups string `json:",omitempty"` // groups this option belongs to - comma separated string for options classification Provider string `json:",omitempty"` // set to filter on provider Default any // default value, nil => "", if set (and not to nil or "") then Required does nothing Value any // value to be set by flags Examples OptionExamples `json:",omitempty"` // predefined values that can be selected from list (multiple-choice option) ShortOpt string `json:",omitempty"` // the short option for this if required Hide OptionVisibility // set this to hide the config from the configurator or the command line Required bool // this option is required, meaning value cannot be empty unless there is a default IsPassword bool // set if the option is a password NoPrefix bool // set if the option for this should not use the backend prefix Advanced bool // set if this is an advanced config option Exclusive bool // set if the answer can only be one of the examples (empty string allowed unless Required or Default is set) Sensitive bool // set if this option should be redacted when using rclone config redacted } // BaseOption is an alias for Option used internally type BaseOption Option // MarshalJSON turns an Option into JSON // // It adds some generated fields for ease of use // - DefaultStr - a string rendering of Default // - ValueStr - a string rendering of Value // - Type - the type of the option func (o *Option) MarshalJSON() ([]byte, error) { return json.Marshal(struct { BaseOption DefaultStr string ValueStr string Type string }{ BaseOption: BaseOption(*o), DefaultStr: fmt.Sprint(o.Default), ValueStr: o.String(), Type: o.Type(), }) } // GetValue gets the current value which is the default if not set func (o *Option) GetValue() any { val := o.Value if val == nil { val = o.Default if val == nil { val = "" } } return val } // IsDefault returns true if the value is the default value func (o *Option) IsDefault() bool { if o.Value == nil { return true } Default := o.Default if Default == nil { Default = "" } return reflect.DeepEqual(o.Value, Default) } // String turns Option into a string func (o *Option) String() string { v := o.GetValue() switch x := v.(type) { case []string: // Treat empty string array as empty string // This is to make the default value of the option help nice if len(x) == 0 { return "" } // Encode string arrays as CSV // The default Go encoding can't be decoded uniquely return CommaSepList(x).String() case SizeSuffix: str := x.String() // Suffix bare numbers with "B" unless they are 0 // // This makes sure that fs.SizeSuffix roundtrips through string if len(str) > 0 && str != "0" { if lastDigit := str[len(str)-1]; lastDigit >= '0' && lastDigit <= '9' { str += "B" } } return str } return fmt.Sprint(v) } // Set an Option from a string func (o *Option) Set(s string) (err error) { v := o.GetValue() if stringArray, isStringArray := v.([]string); isStringArray { if stringArray == nil { stringArray = []string{} } // If this is still the default value then overwrite the defaults if reflect.ValueOf(o.Default).Pointer() == reflect.ValueOf(v).Pointer() { stringArray = []string{} } o.Value = append(stringArray, s) return nil } newValue, err := configstruct.StringToInterface(v, s) if err != nil { return err } o.Value = newValue return nil } type typer interface { Type() string } // Type of the value func (o *Option) Type() string { v := o.GetValue() // Try to call Type method on non-pointer if do, ok := v.(typer); ok { return do.Type() } // Special case []string if _, isStringArray := v.([]string); isStringArray { return "stringArray" } return reflect.TypeOf(v).Name() } // FlagName for the option func (o *Option) FlagName(prefix string) string { name := strings.ReplaceAll(o.Name, "_", "-") // convert snake_case to kebab-case if !o.NoPrefix { name = prefix + "-" + name } return name } // EnvVarName for the option func (o *Option) EnvVarName(prefix string) string { return OptionToEnv(prefix + "-" + o.Name) } // Copy makes a shallow copy of the option func (o *Option) Copy() *Option { copy := new(Option) *copy = *o return copy } // OptionExamples is a slice of examples type OptionExamples []OptionExample // Len is part of sort.Interface. func (os OptionExamples) Len() int { return len(os) } // Swap is part of sort.Interface. func (os OptionExamples) Swap(i, j int) { os[i], os[j] = os[j], os[i] } // Less is part of sort.Interface. func (os OptionExamples) Less(i, j int) bool { return os[i].Help < os[j].Help } // Sort sorts an OptionExamples func (os OptionExamples) Sort() { sort.Sort(os) } // OptionExample describes an example for an Option type OptionExample struct { Value string Help string Provider string `json:",omitempty"` } // Register a filesystem // // Fs modules should use this in an init() function func Register(info *RegInfo) { info.Options.setValues() if info.Prefix == "" { info.Prefix = info.Name } info.Options = append(info.Options, optDescription) Registry = append(Registry, info) for _, alias := range info.Aliases { // Copy the info block and rename and hide the alias and options aliasInfo := *info aliasInfo.Name = alias aliasInfo.Prefix = alias aliasInfo.Hide = true aliasInfo.Options = slices.Clone(info.Options) for i := range aliasInfo.Options { aliasInfo.Options[i].Hide = OptionHideBoth } Registry = append(Registry, &aliasInfo) } } // Find looks for a RegInfo object for the name passed in. The name // can be either the Name or the Prefix. // // Services are looked up in the config file func Find(name string) (*RegInfo, error) { for _, item := range Registry { if item.Name == name || item.Prefix == name || item.FileName() == name { return item, nil } } return nil, fmt.Errorf("didn't find backend called %q", name) } // MustFind looks for an Info object for the type name passed in // // Services are looked up in the config file. // // Exits with a fatal error if not found func MustFind(name string) *RegInfo { fs, err := Find(name) if err != nil { Fatalf(nil, "Failed to find remote: %v", err) } return fs } // OptionsInfo holds info about an block of options type OptionsInfo struct { Name string // name of this options block for the rc Opt any // pointer to a struct to set the options in Options Options // description of the options Reload func(context.Context) error // if not nil, call when options changed and on init } // OptionsRegistry is a registry of global options var OptionsRegistry = map[string]OptionsInfo{} // RegisterGlobalOptions registers global options to be made into // command line options, rc options and environment variable reading. // // Packages which need global options should use this in an init() function func RegisterGlobalOptions(oi OptionsInfo) { oi.Options.setValues() OptionsRegistry[oi.Name] = oi if oi.Opt != nil && oi.Options != nil { err := oi.Check() if err != nil { Fatalf(nil, "%v", err) } } // Load the default values into the options. // // These will be from the ultimate defaults or environment // variables. // // The flags haven't been processed yet so this will be run // again when the flags are ready. err := oi.load() if err != nil { Fatalf(nil, "Failed to load %q default values: %v", oi.Name, err) } } var optionName = regexp.MustCompile(`^[a-z0-9_]+$`) // Check ensures that for every element of oi.Options there is a field // in oi.Opt that matches it. // // It also sets Option.FieldName to be the name of the field for use // in JSON. func (oi *OptionsInfo) Check() error { errCount := errcount.New() items, err := configstruct.Items(oi.Opt) if err != nil { return err } itemsByName := map[string]*configstruct.Item{} for i := range items { item := &items[i] itemsByName[item.Name] = item if !optionName.MatchString(item.Name) { err = fmt.Errorf("invalid name in `config:%q` in Options struct", item.Name) errCount.Add(err) Errorf(nil, "%s", err) } } for i := range oi.Options { option := &oi.Options[i] // Check name is correct if !optionName.MatchString(option.Name) { err = fmt.Errorf("invalid Name: %q", option.Name) errCount.Add(err) Errorf(nil, "%s", err) continue } // Check item exists item, found := itemsByName[option.Name] if !found { err = fmt.Errorf("key %q in OptionsInfo not found in Options struct", option.Name) errCount.Add(err) Errorf(nil, "%s", err) continue } // Check type optType := fmt.Sprintf("%T", option.Default) itemType := fmt.Sprintf("%T", item.Value) if optType != itemType { err = fmt.Errorf("key %q in has type %q in OptionsInfo.Default but type %q in Options struct", option.Name, optType, itemType) //errCount.Add(err) Errorf(nil, "%s", err) } // Set FieldName option.FieldName = item.Field } return errCount.Err(fmt.Sprintf("internal error: options block %q", oi.Name)) } // load the defaults from the options // // Reload the options if required func (oi *OptionsInfo) load() error { if oi.Options == nil { Errorf(nil, "No options defined for config block %q", oi.Name) return nil } m := ConfigMap("", oi.Options, "", nil) err := configstruct.Set(m, oi.Opt) if err != nil { return fmt.Errorf("failed to initialise %q options: %w", oi.Name, err) } if oi.Reload != nil { err = oi.Reload(context.Background()) if err != nil { return fmt.Errorf("failed to reload %q options: %w", oi.Name, err) } } return nil } // GlobalOptionsInit initialises the defaults of global options to // their values read from the options, environment variables and // command line parameters. func GlobalOptionsInit() error { var keys []string for key := range OptionsRegistry { keys = append(keys, key) } sort.Slice(keys, func(i, j int) bool { // Sort alphabetically, but with "main" first if keys[i] == "main" { return true } if keys[j] == "main" { return false } return keys[i] < keys[j] }) for _, key := range keys { opt := OptionsRegistry[key] err := opt.load() if err != nil { return err } } return nil } // Type returns a textual string to identify the type of the remote func Type(f Fs) string { typeName := fmt.Sprintf("%T", f) typeName = strings.TrimPrefix(typeName, "*") typeName = strings.TrimSuffix(typeName, ".Fs") return typeName } var ( typeToRegInfoMu sync.Mutex typeToRegInfo = map[string]*RegInfo{} ) // Add the RegInfo to the reverse map func addReverse(f Fs, fsInfo *RegInfo) { typeToRegInfoMu.Lock() defer typeToRegInfoMu.Unlock() typeToRegInfo[Type(f)] = fsInfo } // FindFromFs finds the *RegInfo used to create this Fs, provided // it was created by fs.NewFs or cache.Get // // It returns nil if not found func FindFromFs(f Fs) *RegInfo { typeToRegInfoMu.Lock() defer typeToRegInfoMu.Unlock() return typeToRegInfo[Type(f)] } rclone-v1.71.0/fs/sizesuffix.go000066400000000000000000000131711505210326400164070ustar00rootroot00000000000000package fs // SizeSuffix is parsed by flag with K/M/G binary suffixes import ( "encoding/json" "errors" "fmt" "math" "sort" "strconv" "strings" ) // SizeSuffix is an int64 with a friendly way of printing setting type SizeSuffix int64 // Common multipliers for SizeSuffix const ( SizeSuffixBase SizeSuffix = 1 << (iota * 10) Kibi Mebi Gibi Tebi Pebi Exbi ) const ( // SizeSuffixMax is the largest SizeSuffix multiplier SizeSuffixMax = Exbi // SizeSuffixMaxValue is the largest value that can be used to create SizeSuffix SizeSuffixMaxValue = math.MaxInt64 // SizeSuffixMinValue is the smallest value that can be used to create SizeSuffix SizeSuffixMinValue = math.MinInt64 ) // Turn SizeSuffix into a string and a suffix func (x SizeSuffix) string() (string, string) { scaled := float64(0) suffix := "" switch { case x < 0: return "off", "" case x == 0: return "0", "" case x < Kibi: scaled = float64(x) suffix = "" case x < Mebi: scaled = float64(x) / float64(Kibi) suffix = "Ki" case x < Gibi: scaled = float64(x) / float64(Mebi) suffix = "Mi" case x < Tebi: scaled = float64(x) / float64(Gibi) suffix = "Gi" case x < Pebi: scaled = float64(x) / float64(Tebi) suffix = "Ti" case x < Exbi: scaled = float64(x) / float64(Pebi) suffix = "Pi" default: scaled = float64(x) / float64(Exbi) suffix = "Ei" } if math.Floor(scaled) == scaled { return fmt.Sprintf("%.0f", scaled), suffix } return fmt.Sprintf("%.3f", scaled), suffix } // String turns SizeSuffix into a string func (x SizeSuffix) String() string { val, suffix := x.string() return val + suffix } // Unit turns SizeSuffix into a string with a unit func (x SizeSuffix) unit(unit string) string { val, suffix := x.string() if val == "off" { return val } return val + " " + suffix + unit } // BitUnit turns SizeSuffix into a string with bit unit func (x SizeSuffix) BitUnit() string { return x.unit("bit") } // BitRateUnit turns SizeSuffix into a string with bit rate unit func (x SizeSuffix) BitRateUnit() string { return x.unit("bit/s") } // ByteUnit turns SizeSuffix into a string with byte unit func (x SizeSuffix) ByteUnit() string { return x.unit("B") } // ByteRateUnit turns SizeSuffix into a string with byte rate unit func (x SizeSuffix) ByteRateUnit() string { return x.unit("B/s") } func (x *SizeSuffix) multiplierFromSymbol(s byte) (found bool, multiplier float64) { switch s { case 'k', 'K': return true, float64(Kibi) case 'm', 'M': return true, float64(Mebi) case 'g', 'G': return true, float64(Gibi) case 't', 'T': return true, float64(Tebi) case 'p', 'P': return true, float64(Pebi) case 'e', 'E': return true, float64(Exbi) default: return false, float64(SizeSuffixBase) } } // Set a SizeSuffix func (x *SizeSuffix) Set(s string) error { if len(s) == 0 { return errors.New("empty string") } if strings.ToLower(s) == "off" { *x = -1 return nil } suffix := s[len(s)-1] suffixLen := 1 multiplierFound := false var multiplier float64 switch suffix { case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.': suffixLen = 0 multiplier = float64(Kibi) case 'b', 'B': if len(s) > 2 && s[len(s)-2] == 'i' { suffix = s[len(s)-3] suffixLen = 3 if multiplierFound, multiplier = x.multiplierFromSymbol(suffix); !multiplierFound { return fmt.Errorf("bad suffix %q", suffix) } // Could also support SI form MB, and treat it equivalent to MiB, but perhaps better to reserve it for CountSuffix? //} else if len(s) > 1 { // suffix = s[len(s)-2] // if multiplierFound, multiplier = x.multiplierFromSymbol(suffix); multiplierFound { // suffixLen = 2 // } //} } else { multiplier = float64(SizeSuffixBase) } case 'i', 'I': if len(s) > 1 { suffix = s[len(s)-2] suffixLen = 2 multiplierFound, multiplier = x.multiplierFromSymbol(suffix) } if !multiplierFound { return fmt.Errorf("bad suffix %q", suffix) } default: if multiplierFound, multiplier = x.multiplierFromSymbol(suffix); !multiplierFound { return fmt.Errorf("bad suffix %q", suffix) } } s = s[:len(s)-suffixLen] value, err := strconv.ParseFloat(s, 64) if err != nil { return err } if value < 0 { return fmt.Errorf("size can't be negative %q", s) } value *= multiplier *x = SizeSuffix(value) return nil } // Type of the value func (x SizeSuffix) Type() string { return "SizeSuffix" } // Scan implements the fmt.Scanner interface func (x *SizeSuffix) Scan(s fmt.ScanState, ch rune) error { token, err := s.Token(true, nil) if err != nil { return err } return x.Set(string(token)) } // SizeSuffixList is a slice SizeSuffix values type SizeSuffixList []SizeSuffix func (l SizeSuffixList) Len() int { return len(l) } func (l SizeSuffixList) Swap(i, j int) { l[i], l[j] = l[j], l[i] } func (l SizeSuffixList) Less(i, j int) bool { return l[i] < l[j] } // Sort sorts the list func (l SizeSuffixList) Sort() { sort.Sort(l) } // UnmarshalJSONFlag unmarshals a JSON input for a flag. If the input // is a string then it calls the Set method on the flag otherwise it // calls the setInt function with a parsed int64. func UnmarshalJSONFlag(in []byte, x interface{ Set(string) error }, setInt func(int64) error) error { // Try to parse as string first var s string err := json.Unmarshal(in, &s) if err == nil { return x.Set(s) } // If that fails parse as integer var i int64 err = json.Unmarshal(in, &i) if err != nil { return err } return setInt(i) } // UnmarshalJSON makes sure the value can be parsed as a string or integer in JSON func (x *SizeSuffix) UnmarshalJSON(in []byte) error { return UnmarshalJSONFlag(in, x, func(i int64) error { *x = SizeSuffix(i) return nil }) } rclone-v1.71.0/fs/sizesuffix_test.go000066400000000000000000000100071505210326400174410ustar00rootroot00000000000000package fs import ( "encoding/json" "fmt" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Check it satisfies the interfaces var ( _ Flagger = (*SizeSuffix)(nil) _ FlaggerNP = SizeSuffix(0) ) func TestSizeSuffixString(t *testing.T) { for _, test := range []struct { in float64 want string }{ {0, "0"}, {102, "102"}, {1024, "1Ki"}, {1024 * 1024, "1Mi"}, {1024 * 1024 * 1024, "1Gi"}, {10 * 1024 * 1024 * 1024, "10Gi"}, {10.1 * 1024 * 1024 * 1024, "10.100Gi"}, {-1, "off"}, {-100, "off"}, } { ss := SizeSuffix(test.in) got := ss.String() assert.Equal(t, test.want, got) } } func TestSizeSuffixByteUnit(t *testing.T) { for _, test := range []struct { in float64 want string }{ {0, "0 B"}, {102, "102 B"}, {1024, "1 KiB"}, {1024 * 1024, "1 MiB"}, {1024 * 1024 * 1024, "1 GiB"}, {10 * 1024 * 1024 * 1024, "10 GiB"}, {10.1 * 1024 * 1024 * 1024, "10.100 GiB"}, {10 * 1024 * 1024 * 1024 * 1024, "10 TiB"}, {10 * 1024 * 1024 * 1024 * 1024 * 1024, "10 PiB"}, {1 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "1 EiB"}, {-1, "off"}, {-100, "off"}, } { ss := SizeSuffix(test.in) got := ss.ByteUnit() assert.Equal(t, test.want, got) } } func TestSizeSuffixBitRateUnit(t *testing.T) { for _, test := range []struct { in float64 want string }{ {0, "0 bit/s"}, {1024, "1 Kibit/s"}, {1024 * 1024, "1 Mibit/s"}, {1024 * 1024 * 1024, "1 Gibit/s"}, {10 * 1024 * 1024 * 1024, "10 Gibit/s"}, {10.1 * 1024 * 1024 * 1024, "10.100 Gibit/s"}, {10 * 1024 * 1024 * 1024 * 1024, "10 Tibit/s"}, {10 * 1024 * 1024 * 1024 * 1024 * 1024, "10 Pibit/s"}, {1 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "1 Eibit/s"}, {-1, "off"}, {-100, "off"}, } { ss := SizeSuffix(test.in) got := ss.BitRateUnit() assert.Equal(t, test.want, got) } } func TestSizeSuffixSet(t *testing.T) { for _, test := range []struct { in string want int64 err bool }{ {"0", 0, false}, {"1b", 1, false}, {"102B", 102, false}, {"0.1k", 102, false}, {"0.1", 102, false}, {"1K", 1024, false}, {"1k", 1024, false}, //{"1KB", 1024, false}, //{"1kB", 1024, false}, //{"1kb", 1024, false}, {"1KI", 1024, false}, {"1Ki", 1024, false}, {"1kI", 1024, false}, {"1ki", 1024, false}, {"1KiB", 1024, false}, {"1KiB", 1024, false}, {"1kib", 1024, false}, {"1", 1024, false}, {"2.5", 1024 * 2.5, false}, {"1M", 1024 * 1024, false}, //{"1MB", 1024 * 1024, false}, {"1Mi", 1024 * 1024, false}, {"1MiB", 1024 * 1024, false}, {"1.g", 1024 * 1024 * 1024, false}, {"10G", 10 * 1024 * 1024 * 1024, false}, {"10T", 10 * 1024 * 1024 * 1024 * 1024, false}, {"10P", 10 * 1024 * 1024 * 1024 * 1024 * 1024, false}, {"off", -1, false}, {"OFF", -1, false}, {"", 0, true}, {"1q", 0, true}, {"1.q", 0, true}, {"1q", 0, true}, {"-1K", 0, true}, {"1i", 0, true}, {"1iB", 0, true}, {"1MB", 0, true}, } { ss := SizeSuffix(0) err := ss.Set(test.in) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, int64(ss)) } } func TestSizeSuffixScan(t *testing.T) { var v SizeSuffix n, err := fmt.Sscan(" 17M ", &v) require.NoError(t, err) assert.Equal(t, 1, n) assert.Equal(t, SizeSuffix(17<<20), v) } func TestSizeSuffixUnmarshalJSON(t *testing.T) { for _, test := range []struct { in string want int64 err bool }{ {`"0"`, 0, false}, {`"102B"`, 102, false}, {`"1K"`, 1024, false}, {`"2.5"`, 1024 * 2.5, false}, {`"1M"`, 1024 * 1024, false}, {`"1.g"`, 1024 * 1024 * 1024, false}, {`"10G"`, 10 * 1024 * 1024 * 1024, false}, {`"off"`, -1, false}, {`""`, 0, true}, {`"1q"`, 0, true}, {`"-1K"`, 0, true}, {`0`, 0, false}, {`102`, 102, false}, {`1024`, 1024, false}, {`1000000000`, 1000000000, false}, {`1.1.1`, 0, true}, } { var ss SizeSuffix err := json.Unmarshal([]byte(test.in), &ss) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, int64(ss)) } } rclone-v1.71.0/fs/sync/000077500000000000000000000000001505210326400146325ustar00rootroot00000000000000rclone-v1.71.0/fs/sync/pipe.go000066400000000000000000000126571505210326400161310ustar00rootroot00000000000000package sync import ( "context" "fmt" "math/bits" "strconv" "strings" "sync" "github.com/aalpar/deheap" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fserrors" ) // compare two items for order by type lessFn func(a, b fs.ObjectPair) bool // pipe provides an unbounded channel like experience // // Note unlike channels these aren't strictly ordered. type pipe struct { mu sync.Mutex c chan struct{} queue []fs.ObjectPair closed bool totalSize int64 stats func(items int, totalSize int64) less lessFn fraction int } func newPipe(orderBy string, stats func(items int, totalSize int64), maxBacklog int) (*pipe, error) { if maxBacklog < 0 { maxBacklog = (1 << (bits.UintSize - 1)) - 1 // largest positive int } less, fraction, err := newLess(orderBy) if err != nil { return nil, fserrors.FatalError(err) } p := &pipe{ c: make(chan struct{}, maxBacklog), stats: stats, less: less, fraction: fraction, } if p.less != nil { deheap.Init(p) } return p, nil } // Len satisfy heap.Interface - must be called with lock held func (p *pipe) Len() int { return len(p.queue) } // Len satisfy heap.Interface - must be called with lock held func (p *pipe) Less(i, j int) bool { return p.less(p.queue[i], p.queue[j]) } // Swap satisfy heap.Interface - must be called with lock held func (p *pipe) Swap(i, j int) { p.queue[i], p.queue[j] = p.queue[j], p.queue[i] } // Push satisfy heap.Interface - must be called with lock held func (p *pipe) Push(item any) { p.queue = append(p.queue, item.(fs.ObjectPair)) } // Pop satisfy heap.Interface - must be called with lock held func (p *pipe) Pop() any { old := p.queue n := len(old) item := old[n-1] old[n-1] = fs.ObjectPair{} // avoid memory leak p.queue = old[0 : n-1] return item } // Put a pair into the pipe // // It returns ok = false if the context was cancelled // // It will panic if you call it after Close() // // Note that pairs where src==dst aren't counted for stats func (p *pipe) Put(ctx context.Context, pair fs.ObjectPair) (ok bool) { if ctx.Err() != nil { return false } p.mu.Lock() if p.less == nil { // no order-by p.queue = append(p.queue, pair) } else { deheap.Push(p, pair) } size := pair.Src.Size() if size > 0 && pair.Src != pair.Dst { p.totalSize += size } p.stats(len(p.queue), p.totalSize) p.mu.Unlock() select { case <-ctx.Done(): return false case p.c <- struct{}{}: } return true } // Get a pair from the pipe // // If fraction is > the mixed fraction set in the pipe then it gets it // from the other end of the heap if order-by is in effect // // It returns ok = false if the context was cancelled or Close() has // been called. func (p *pipe) GetMax(ctx context.Context, fraction int) (pair fs.ObjectPair, ok bool) { if ctx.Err() != nil { return } select { case <-ctx.Done(): return case _, ok = <-p.c: if !ok { return } } p.mu.Lock() if p.less == nil { // no order-by pair = p.queue[0] p.queue[0] = fs.ObjectPair{} // avoid memory leak p.queue = p.queue[1:] } else if p.fraction < 0 || fraction < p.fraction { pair = deheap.Pop(p).(fs.ObjectPair) } else { pair = deheap.PopMax(p).(fs.ObjectPair) } size := pair.Src.Size() if size > 0 && pair.Src != pair.Dst { p.totalSize -= size } if p.totalSize < 0 { p.totalSize = 0 } p.stats(len(p.queue), p.totalSize) p.mu.Unlock() return pair, true } // Get a pair from the pipe // // It returns ok = false if the context was cancelled or Close() has // been called. func (p *pipe) Get(ctx context.Context) (pair fs.ObjectPair, ok bool) { return p.GetMax(ctx, -1) } // Stats reads the number of items in the queue and the totalSize func (p *pipe) Stats() (items int, totalSize int64) { p.mu.Lock() items, totalSize = len(p.queue), p.totalSize p.mu.Unlock() return items, totalSize } // Close the pipe // // Writes to a closed pipe will panic as will double closing a pipe func (p *pipe) Close() { p.mu.Lock() close(p.c) p.closed = true p.mu.Unlock() } // newLess returns a less function for the heap comparison or nil if // one is not required func newLess(orderBy string) (less lessFn, fraction int, err error) { fraction = -1 if orderBy == "" { return nil, fraction, nil } parts := strings.Split(strings.ToLower(orderBy), ",") switch parts[0] { case "name": less = func(a, b fs.ObjectPair) bool { return a.Src.Remote() < b.Src.Remote() } case "size": less = func(a, b fs.ObjectPair) bool { return a.Src.Size() < b.Src.Size() } case "modtime": less = func(a, b fs.ObjectPair) bool { ctx := context.Background() return a.Src.ModTime(ctx).Before(b.Src.ModTime(ctx)) } default: return nil, fraction, fmt.Errorf("unknown --order-by comparison %q", parts[0]) } descending := false if len(parts) > 1 { switch parts[1] { case "ascending", "asc": case "descending", "desc": descending = true case "mixed": fraction = 50 if len(parts) > 2 { fraction, err = strconv.Atoi(parts[2]) if err != nil { return nil, fraction, fmt.Errorf("bad mixed fraction --order-by %q", parts[2]) } } default: return nil, fraction, fmt.Errorf("unknown --order-by sort direction %q", parts[1]) } } if (fraction >= 0 && len(parts) > 3) || (fraction < 0 && len(parts) > 2) { return nil, fraction, fmt.Errorf("bad --order-by string %q", orderBy) } if descending { oldLess := less less = func(a, b fs.ObjectPair) bool { return !oldLess(a, b) } } return less, fraction, nil } rclone-v1.71.0/fs/sync/pipe_test.go000066400000000000000000000160041505210326400171560ustar00rootroot00000000000000package sync import ( "container/heap" "context" "sync" "sync/atomic" "testing" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest/mockobject" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Check interface satisfied var _ heap.Interface = (*pipe)(nil) func TestPipe(t *testing.T) { var queueLength int var queueSize int64 stats := func(n int, size int64) { queueLength, queueSize = n, size } // Make a new pipe p, err := newPipe("", stats, 10) require.NoError(t, err) checkStats := func(expectedN int, expectedSize int64) { n, size := p.Stats() assert.Equal(t, expectedN, n) assert.Equal(t, expectedSize, size) assert.Equal(t, expectedN, queueLength) assert.Equal(t, expectedSize, queueSize) } checkStats(0, 0) ctx := context.Background() obj1 := mockobject.New("potato").WithContent([]byte("hello"), mockobject.SeekModeNone) pair1 := fs.ObjectPair{Src: obj1, Dst: nil} pairD := fs.ObjectPair{Src: obj1, Dst: obj1} // this object should not count to the stats // Put an object ok := p.Put(ctx, pair1) assert.Equal(t, true, ok) checkStats(1, 5) // Put an object to be deleted ok = p.Put(ctx, pairD) assert.Equal(t, true, ok) checkStats(2, 5) // Close the pipe showing reading on closed pipe is OK p.Close() // Read from pipe pair2, ok := p.Get(ctx) assert.Equal(t, pair1, pair2) assert.Equal(t, true, ok) checkStats(1, 0) // Read from pipe pair2, ok = p.Get(ctx) assert.Equal(t, pairD, pair2) assert.Equal(t, true, ok) checkStats(0, 0) // Check read on closed pipe pair2, ok = p.Get(ctx) assert.Equal(t, fs.ObjectPair{}, pair2) assert.Equal(t, false, ok) // Check panic on write to closed pipe assert.Panics(t, func() { p.Put(ctx, pair1) }) // Make a new pipe p, err = newPipe("", stats, 10) require.NoError(t, err) ctx2, cancel := context.WithCancel(ctx) // cancel it in the background - check read ceases go cancel() pair2, ok = p.Get(ctx2) assert.Equal(t, fs.ObjectPair{}, pair2) assert.Equal(t, false, ok) // check we can't write ok = p.Put(ctx2, pair1) assert.Equal(t, false, ok) } // TestPipeConcurrent runs concurrent Get and Put to flush out any // race conditions and concurrency problems. func TestPipeConcurrent(t *testing.T) { const ( N = 1000 readWriters = 10 ) stats := func(n int, size int64) {} // Make a new pipe p, err := newPipe("", stats, 10) require.NoError(t, err) var wg sync.WaitGroup obj1 := mockobject.New("potato").WithContent([]byte("hello"), mockobject.SeekModeNone) pair1 := fs.ObjectPair{Src: obj1, Dst: nil} ctx := context.Background() var count atomic.Int64 for range readWriters { wg.Add(2) go func() { defer wg.Done() for range N { // Read from pipe pair2, ok := p.Get(ctx) assert.Equal(t, pair1, pair2) assert.Equal(t, true, ok) count.Add(-1) } }() go func() { defer wg.Done() for range N { // Put an object ok := p.Put(ctx, pair1) assert.Equal(t, true, ok) count.Add(1) } }() } wg.Wait() assert.Equal(t, int64(0), count.Load()) } func TestPipeOrderBy(t *testing.T) { var ( stats = func(n int, size int64) {} ctx = context.Background() obj1 = mockobject.New("b").WithContent([]byte("1"), mockobject.SeekModeNone) obj2 = mockobject.New("a").WithContent([]byte("22"), mockobject.SeekModeNone) pair1 = fs.ObjectPair{Src: obj1} pair2 = fs.ObjectPair{Src: obj2} ) for _, test := range []struct { orderBy string swapped1 bool swapped2 bool fraction int }{ {"", false, true, -1}, {"size", false, false, -1}, {"name", true, true, -1}, {"modtime", false, true, -1}, {"size,ascending", false, false, -1}, {"name,asc", true, true, -1}, {"modtime,ascending", false, true, -1}, {"size,descending", true, true, -1}, {"name,desc", false, false, -1}, {"modtime,descending", true, false, -1}, {"size,mixed,50", false, false, 25}, {"size,mixed,51", true, true, 75}, } { t.Run(test.orderBy, func(t *testing.T) { p, err := newPipe(test.orderBy, stats, 10) require.NoError(t, err) readAndCheck := func(swapped bool) { var readFirst, readSecond fs.ObjectPair var ok1, ok2 bool if test.fraction < 0 { readFirst, ok1 = p.Get(ctx) readSecond, ok2 = p.Get(ctx) } else { readFirst, ok1 = p.GetMax(ctx, test.fraction) readSecond, ok2 = p.GetMax(ctx, test.fraction) } assert.True(t, ok1) assert.True(t, ok2) if swapped { assert.True(t, readFirst == pair2 && readSecond == pair1) } else { assert.True(t, readFirst == pair1 && readSecond == pair2) } } ok := p.Put(ctx, pair1) assert.True(t, ok) ok = p.Put(ctx, pair2) assert.True(t, ok) readAndCheck(test.swapped1) // insert other way round ok = p.Put(ctx, pair2) assert.True(t, ok) ok = p.Put(ctx, pair1) assert.True(t, ok) readAndCheck(test.swapped2) }) } } func TestNewLess(t *testing.T) { t.Run("blankOK", func(t *testing.T) { less, _, err := newLess("") require.NoError(t, err) assert.Nil(t, less) }) t.Run("tooManyParts", func(t *testing.T) { _, _, err := newLess("size,asc,toomanyparts") require.Error(t, err) assert.Contains(t, err.Error(), "bad --order-by string") }) t.Run("tooManyParts2", func(t *testing.T) { _, _, err := newLess("size,mixed,50,toomanyparts") require.Error(t, err) assert.Contains(t, err.Error(), "bad --order-by string") }) t.Run("badMixed", func(t *testing.T) { _, _, err := newLess("size,mixed,32.7") require.Error(t, err) assert.Contains(t, err.Error(), "bad mixed fraction") }) t.Run("unknownComparison", func(t *testing.T) { _, _, err := newLess("potato") require.Error(t, err) assert.Contains(t, err.Error(), "unknown --order-by comparison") }) t.Run("unknownSortDirection", func(t *testing.T) { _, _, err := newLess("name,sideways") require.Error(t, err) assert.Contains(t, err.Error(), "unknown --order-by sort direction") }) var ( obj1 = mockobject.New("b").WithContent([]byte("1"), mockobject.SeekModeNone) obj2 = mockobject.New("a").WithContent([]byte("22"), mockobject.SeekModeNone) pair1 = fs.ObjectPair{Src: obj1} pair2 = fs.ObjectPair{Src: obj2} ) for _, test := range []struct { orderBy string pair1LessPair2 bool pair2LessPair1 bool wantFraction int }{ {"size", true, false, -1}, {"name", false, true, -1}, {"modtime", false, false, -1}, {"size,ascending", true, false, -1}, {"name,asc", false, true, -1}, {"modtime,ascending", false, false, -1}, {"size,descending", false, true, -1}, {"name,desc", true, false, -1}, {"modtime,descending", true, true, -1}, {"modtime,mixed", false, false, 50}, {"modtime,mixed,30", false, false, 30}, } { t.Run(test.orderBy, func(t *testing.T) { less, gotFraction, err := newLess(test.orderBy) assert.Equal(t, test.wantFraction, gotFraction) require.NoError(t, err) require.NotNil(t, less) pair1LessPair2 := less(pair1, pair2) assert.Equal(t, test.pair1LessPair2, pair1LessPair2) pair2LessPair1 := less(pair2, pair1) assert.Equal(t, test.pair2LessPair1, pair2LessPair1) }) } } rclone-v1.71.0/fs/sync/rc.go000066400000000000000000000033271505210326400155720ustar00rootroot00000000000000package sync import ( "context" "github.com/rclone/rclone/fs/rc" ) func init() { for _, name := range []string{"sync", "copy", "move"} { name := name moveHelp := "" if name == "move" { moveHelp = "- deleteEmptySrcDirs - delete empty src directories if set\n" } rc.Add(rc.Call{ Path: "sync/" + name, AuthRequired: true, Fn: func(ctx context.Context, in rc.Params) (rc.Params, error) { return rcSyncCopyMove(ctx, in, name) }, Title: name + " a directory from source remote to destination remote", Help: `This takes the following parameters: - srcFs - a remote name string e.g. "drive:src" for the source - dstFs - a remote name string e.g. "drive:dst" for the destination - createEmptySrcDirs - create empty src directories on destination if set ` + moveHelp + ` See the [` + name + `](/commands/rclone_` + name + `/) command for more information on the above.`, }) } } // Sync/Copy/Move a file func rcSyncCopyMove(ctx context.Context, in rc.Params, name string) (out rc.Params, err error) { srcFs, err := rc.GetFsNamed(ctx, in, "srcFs") if err != nil { return nil, err } dstFs, err := rc.GetFsNamed(ctx, in, "dstFs") if err != nil { return nil, err } createEmptySrcDirs, err := in.GetBool("createEmptySrcDirs") if rc.NotErrParamNotFound(err) { return nil, err } switch name { case "sync": return nil, Sync(ctx, dstFs, srcFs, createEmptySrcDirs) case "copy": return nil, CopyDir(ctx, dstFs, srcFs, createEmptySrcDirs) case "move": deleteEmptySrcDirs, err := in.GetBool("deleteEmptySrcDirs") if rc.NotErrParamNotFound(err) { return nil, err } return nil, MoveDir(ctx, dstFs, srcFs, deleteEmptySrcDirs, createEmptySrcDirs) } panic("unknown rcSyncCopyMove type") } rclone-v1.71.0/fs/sync/rc_test.go000066400000000000000000000053411505210326400166270ustar00rootroot00000000000000package sync import ( "context" "testing" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/rc" "github.com/rclone/rclone/fstest" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func rcNewRun(t *testing.T, method string) (*fstest.Run, *rc.Call) { if *fstest.RemoteName != "" { t.Skip("Skipping test on non local remote") } r := fstest.NewRun(t) call := rc.Calls.Get(method) assert.NotNil(t, call) cache.Put(r.LocalName, r.Flocal) cache.Put(r.FremoteName, r.Fremote) return r, call } // sync/copy: copy a directory from source remote to destination remote func TestRcCopy(t *testing.T) { r, call := rcNewRun(t, "sync/copy") r.Mkdir(context.Background(), r.Fremote) file1 := r.WriteBoth(context.Background(), "file1", "file1 contents", t1) file2 := r.WriteFile("subdir/file2", "file2 contents", t2) file3 := r.WriteObject(context.Background(), "subdir/subsubdir/file3", "file3 contents", t3) r.CheckLocalItems(t, file1, file2) r.CheckRemoteItems(t, file1, file3) in := rc.Params{ "srcFs": r.LocalName, "dstFs": r.FremoteName, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) r.CheckLocalItems(t, file1, file2) r.CheckRemoteItems(t, file1, file2, file3) } // sync/move: move a directory from source remote to destination remote func TestRcMove(t *testing.T) { r, call := rcNewRun(t, "sync/move") r.Mkdir(context.Background(), r.Fremote) file1 := r.WriteBoth(context.Background(), "file1", "file1 contents", t1) file2 := r.WriteFile("subdir/file2", "file2 contents", t2) file3 := r.WriteObject(context.Background(), "subdir/subsubdir/file3", "file3 contents", t3) r.CheckLocalItems(t, file1, file2) r.CheckRemoteItems(t, file1, file3) in := rc.Params{ "srcFs": r.LocalName, "dstFs": r.FremoteName, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) r.CheckLocalItems(t) r.CheckRemoteItems(t, file1, file2, file3) } // sync/sync: sync a directory from source remote to destination remote func TestRcSync(t *testing.T) { r, call := rcNewRun(t, "sync/sync") r.Mkdir(context.Background(), r.Fremote) file1 := r.WriteBoth(context.Background(), "file1", "file1 contents", t1) file2 := r.WriteFile("subdir/file2", "file2 contents", t2) file3 := r.WriteObject(context.Background(), "subdir/subsubdir/file3", "file3 contents", t3) r.CheckLocalItems(t, file1, file2) r.CheckRemoteItems(t, file1, file3) in := rc.Params{ "srcFs": r.LocalName, "dstFs": r.FremoteName, } out, err := call.Fn(context.Background(), in) require.NoError(t, err) assert.Equal(t, rc.Params(nil), out) r.CheckLocalItems(t, file1, file2) r.CheckRemoteItems(t, file1, file2) } rclone-v1.71.0/fs/sync/sync.go000066400000000000000000001317221505210326400161430ustar00rootroot00000000000000// Package sync is the implementation of sync/copy/move package sync import ( "context" "errors" "fmt" "path" "slices" "sort" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/march" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/lib/errcount" "github.com/rclone/rclone/lib/transform" "golang.org/x/sync/errgroup" ) // ErrorMaxDurationReached defines error when transfer duration is reached // Used for checking on exit and matching to correct exit code. var ErrorMaxDurationReached = errors.New("max transfer duration reached as set by --max-duration") // ErrorMaxDurationReachedFatal is returned from when the max // duration limit is reached. var ErrorMaxDurationReachedFatal = fserrors.FatalError(ErrorMaxDurationReached) type syncCopyMove struct { // parameters fdst fs.Fs fsrc fs.Fs deleteMode fs.DeleteMode // how we are doing deletions DoMove bool copyEmptySrcDirs bool deleteEmptySrcDirs bool dir string // internal state ci *fs.ConfigInfo // global config fi *filter.Filter // filter config ctx context.Context // internal context for controlling go-routines cancel func() // cancel the context inCtx context.Context // internal context for controlling march inCancel func() // cancel the march context noTraverse bool // if set don't traverse the dst noCheckDest bool // if set transfer all objects regardless without checking dst noUnicodeNormalization bool // don't normalize unicode characters in filenames deletersWg sync.WaitGroup // for delete before go routine deleteFilesCh chan fs.Object // channel to receive deletes if delete before trackRenames bool // set if we should do server-side renames trackRenamesStrategy trackRenamesStrategy // strategies used for tracking renames dstFilesMu sync.Mutex // protect dstFiles dstFiles map[string]fs.Object // dst files, always filled srcFiles map[string]fs.Object // src files, only used if deleteBefore srcFilesChan chan fs.Object // passes src objects srcFilesResult chan error // error result of src listing dstFilesResult chan error // error result of dst listing dstEmptyDirsMu sync.Mutex // protect dstEmptyDirs dstEmptyDirs map[string]fs.DirEntry // potentially empty directories srcEmptyDirsMu sync.Mutex // protect srcEmptyDirs srcEmptyDirs map[string]fs.DirEntry // potentially empty directories srcMoveEmptyDirs map[string]fs.DirEntry // potentially empty directories when moving files out of them checkerWg sync.WaitGroup // wait for checkers toBeChecked *pipe // checkers channel transfersWg sync.WaitGroup // wait for transfers toBeUploaded *pipe // copiers channel errorMu sync.Mutex // Mutex covering the errors variables err error // normal error from copy process noRetryErr error // error with NoRetry set fatalErr error // fatal error commonHash hash.Type // common hash type between src and dst modifyWindow time.Duration // modify window between fsrc, fdst renameMapMu sync.Mutex // mutex to protect the below renameMap map[string][]fs.Object // dst files by hash - only used by trackRenames renamerWg sync.WaitGroup // wait for renamers toBeRenamed *pipe // renamers channel trackRenamesWg sync.WaitGroup // wg for background track renames trackRenamesCh chan fs.Object // objects are pumped in here renameCheck []fs.Object // accumulate files to check for rename here compareCopyDest []fs.Fs // place to check for files to server side copy backupDir fs.Fs // place to store overwrites/deletes checkFirst bool // if set run all the checkers before starting transfers maxDurationEndTime time.Time // end time if --max-duration is set logger operations.LoggerFn // LoggerFn used to report the results of a sync (or bisync) to an io.Writer usingLogger bool // whether we are using logger setDirMetadata bool // if set we set the directory metadata setDirModTime bool // if set we set the directory modtimes setDirModTimeAfter bool // if set we set the directory modtimes at the end of the sync setDirModTimeMu sync.Mutex // protect setDirModTimes and modifiedDirs setDirModTimes []setDirModTime // directories that need their modtime set setDirModTimesMaxLevel int // max level of the directories to set modifiedDirs map[string]struct{} // dirs with changed contents (if s.setDirModTimeAfter) allowOverlap bool // whether we allow src and dst to overlap (i.e. for convmv) } // For keeping track of delayed modtime sets type setDirModTime struct { src fs.Directory dst fs.Directory dir string modTime time.Time level int // the level of the directory, 0 is root } type trackRenamesStrategy byte const ( trackRenamesStrategyHash trackRenamesStrategy = 1 << iota trackRenamesStrategyModtime trackRenamesStrategyLeaf ) func (strategy trackRenamesStrategy) hash() bool { return (strategy & trackRenamesStrategyHash) != 0 } func (strategy trackRenamesStrategy) modTime() bool { return (strategy & trackRenamesStrategyModtime) != 0 } func (strategy trackRenamesStrategy) leaf() bool { return (strategy & trackRenamesStrategyLeaf) != 0 } func newSyncCopyMove(ctx context.Context, fdst, fsrc fs.Fs, deleteMode fs.DeleteMode, DoMove bool, deleteEmptySrcDirs bool, copyEmptySrcDirs bool, allowOverlap bool) (*syncCopyMove, error) { if (deleteMode != fs.DeleteModeOff || DoMove) && operations.OverlappingFilterCheck(ctx, fdst, fsrc) && !allowOverlap { return nil, fserrors.FatalError(fs.ErrorOverlapping) } ci := fs.GetConfig(ctx) fi := filter.GetConfig(ctx) s := &syncCopyMove{ ci: ci, fi: fi, fdst: fdst, fsrc: fsrc, deleteMode: deleteMode, DoMove: DoMove, copyEmptySrcDirs: copyEmptySrcDirs, deleteEmptySrcDirs: deleteEmptySrcDirs, dir: "", srcFilesChan: make(chan fs.Object, ci.Checkers+ci.Transfers), srcFilesResult: make(chan error, 1), dstFilesResult: make(chan error, 1), dstEmptyDirs: make(map[string]fs.DirEntry), srcEmptyDirs: make(map[string]fs.DirEntry), srcMoveEmptyDirs: make(map[string]fs.DirEntry), noTraverse: ci.NoTraverse, noCheckDest: ci.NoCheckDest, noUnicodeNormalization: ci.NoUnicodeNormalization, deleteFilesCh: make(chan fs.Object, ci.Checkers), trackRenames: ci.TrackRenames, commonHash: fsrc.Hashes().Overlap(fdst.Hashes()).GetOne(), modifyWindow: fs.GetModifyWindow(ctx, fsrc, fdst), trackRenamesCh: make(chan fs.Object, ci.Checkers), checkFirst: ci.CheckFirst, setDirMetadata: ci.Metadata && fsrc.Features().ReadDirMetadata && fdst.Features().WriteDirMetadata, setDirModTime: (!ci.NoUpdateDirModTime && fsrc.Features().CanHaveEmptyDirectories) && (fdst.Features().WriteDirSetModTime || fdst.Features().MkdirMetadata != nil || fdst.Features().DirSetModTime != nil), setDirModTimeAfter: !ci.NoUpdateDirModTime && (!copyEmptySrcDirs || fsrc.Features().CanHaveEmptyDirectories && fdst.Features().DirModTimeUpdatesOnWrite), modifiedDirs: make(map[string]struct{}), allowOverlap: allowOverlap, } s.logger, s.usingLogger = operations.GetLogger(ctx) if deleteMode == fs.DeleteModeOff { loggerOpt := operations.GetLoggerOpt(ctx) loggerOpt.DeleteModeOff = true loggerOpt.LoggerFn = s.logger ctx = operations.WithLoggerOpt(ctx, loggerOpt) } backlog := ci.MaxBacklog if s.checkFirst { fs.Infof(s.fdst, "Running all checks before starting transfers") backlog = -1 } var err error s.toBeChecked, err = newPipe(ci.OrderBy, accounting.Stats(ctx).SetCheckQueue, backlog) if err != nil { return nil, err } s.toBeUploaded, err = newPipe(ci.OrderBy, accounting.Stats(ctx).SetTransferQueue, backlog) if err != nil { return nil, err } s.toBeRenamed, err = newPipe(ci.OrderBy, accounting.Stats(ctx).SetRenameQueue, backlog) if err != nil { return nil, err } if ci.MaxDuration > 0 { s.maxDurationEndTime = time.Now().Add(time.Duration(ci.MaxDuration)) fs.Infof(s.fdst, "Transfer session %v deadline: %s", ci.CutoffMode, s.maxDurationEndTime.Format("2006/01/02 15:04:05")) } // If a max session duration has been defined add a deadline // to the main context if cutoff mode is hard. This will cut // the transfers off. if !s.maxDurationEndTime.IsZero() && ci.CutoffMode == fs.CutoffModeHard { s.ctx, s.cancel = context.WithDeadline(ctx, s.maxDurationEndTime) } else { s.ctx, s.cancel = context.WithCancel(ctx) } // Input context - cancel this for graceful stop. // // If a max session duration has been defined add a deadline // to the input context if cutoff mode is graceful or soft. // This won't stop the transfers but will cut the // list/check/transfer pipelines. if !s.maxDurationEndTime.IsZero() && ci.CutoffMode != fs.CutoffModeHard { s.inCtx, s.inCancel = context.WithDeadline(s.ctx, s.maxDurationEndTime) } else { s.inCtx, s.inCancel = context.WithCancel(s.ctx) } if s.noTraverse && s.deleteMode != fs.DeleteModeOff { if !fi.HaveFilesFrom() { fs.Errorf(nil, "Ignoring --no-traverse with sync") } s.noTraverse = false } s.trackRenamesStrategy, err = parseTrackRenamesStrategy(ci.TrackRenamesStrategy) if err != nil { return nil, err } if s.noCheckDest { if s.deleteMode != fs.DeleteModeOff { return nil, errors.New("can't use --no-check-dest with sync: use copy instead") } if ci.Immutable { return nil, errors.New("can't use --no-check-dest with --immutable") } if s.backupDir != nil { return nil, errors.New("can't use --no-check-dest with --backup-dir") } } if s.trackRenames { // Don't track renames for remotes without server-side move support. if !operations.CanServerSideMove(fdst) { fs.Errorf(fdst, "Ignoring --track-renames as the destination does not support server-side move or copy") s.trackRenames = false } if s.trackRenamesStrategy.hash() && s.commonHash == hash.None { fs.Errorf(fdst, "Ignoring --track-renames as the source and destination do not have a common hash") s.trackRenames = false } if s.trackRenamesStrategy.modTime() && s.modifyWindow == fs.ModTimeNotSupported { fs.Errorf(fdst, "Ignoring --track-renames as either the source or destination do not support modtime") s.trackRenames = false } if s.deleteMode == fs.DeleteModeOff { fs.Errorf(fdst, "Ignoring --track-renames as it doesn't work with copy or move, only sync") s.trackRenames = false } } if s.trackRenames { // track renames needs delete after if s.deleteMode != fs.DeleteModeOff { s.deleteMode = fs.DeleteModeAfter } if s.noTraverse { fs.Errorf(nil, "Ignoring --no-traverse with --track-renames") s.noTraverse = false } } // Make Fs for --backup-dir if required if ci.BackupDir != "" || ci.Suffix != "" { var err error s.backupDir, err = operations.BackupDir(ctx, fdst, fsrc, "") if err != nil { return nil, err } } if len(ci.CompareDest) > 0 { var err error s.compareCopyDest, err = operations.GetCompareDest(ctx) if err != nil { return nil, err } } else if len(ci.CopyDest) > 0 { var err error s.compareCopyDest, err = operations.GetCopyDest(ctx, fdst) if err != nil { return nil, err } } return s, nil } // Check to see if the context has been cancelled func (s *syncCopyMove) aborting() bool { return s.ctx.Err() != nil } // This reads the map and pumps it into the channel passed in, closing // the channel at the end func (s *syncCopyMove) pumpMapToChan(files map[string]fs.Object, out chan<- fs.Object) { outer: for _, o := range files { if s.aborting() { break outer } select { case out <- o: case <-s.ctx.Done(): break outer } } close(out) s.srcFilesResult <- nil } // This checks the types of errors returned while copying files func (s *syncCopyMove) processError(err error) { if err == nil { return } if err == context.DeadlineExceeded { err = fserrors.NoRetryError(err) } else if err == accounting.ErrorMaxTransferLimitReachedGraceful { if s.inCtx.Err() == nil { fs.Logf(nil, "%v - stopping transfers", err) // Cancel the march and stop the pipes s.inCancel() } } else if err == context.Canceled && s.inCtx.Err() != nil { // Ignore context Canceled if we have called s.inCancel() return } s.errorMu.Lock() defer s.errorMu.Unlock() switch { case fserrors.IsFatalError(err): if !s.aborting() { fs.Errorf(nil, "Cancelling sync due to fatal error: %v", err) s.cancel() } s.fatalErr = err case fserrors.IsNoRetryError(err): s.noRetryErr = err default: s.err = err } } // Returns the current error (if any) in the order of precedence // // fatalErr // normal error // noRetryErr func (s *syncCopyMove) currentError() error { s.errorMu.Lock() defer s.errorMu.Unlock() if s.fatalErr != nil { return s.fatalErr } if s.err != nil { return s.err } return s.noRetryErr } // pairChecker reads Objects~s on in send to out if they need transferring. // // FIXME potentially doing lots of hashes at once func (s *syncCopyMove) pairChecker(in *pipe, out *pipe, fraction int, wg *sync.WaitGroup) { defer wg.Done() for { pair, ok := in.GetMax(s.inCtx, fraction) if !ok { return } src := pair.Src var err error tr := accounting.Stats(s.ctx).NewCheckingTransfer(src, "checking") // Check to see if can store this if src.Storable() { needTransfer := operations.NeedTransfer(s.ctx, pair.Dst, pair.Src) if needTransfer { NoNeedTransfer, err := operations.CompareOrCopyDest(s.ctx, s.fdst, pair.Dst, pair.Src, s.compareCopyDest, s.backupDir) if err != nil { s.processError(err) s.logger(s.ctx, operations.TransferError, pair.Src, pair.Dst, err) } if NoNeedTransfer { needTransfer = false } } // Fix case for case insensitive filesystems if s.ci.FixCase && !s.ci.Immutable && src.Remote() != pair.Dst.Remote() { if newDst, err := operations.Move(s.ctx, s.fdst, nil, src.Remote(), pair.Dst); err != nil { fs.Errorf(pair.Dst, "Error while attempting to rename to %s: %v", src.Remote(), err) s.processError(err) } else { fs.Infof(pair.Dst, "Fixed case by renaming to: %s", src.Remote()) pair.Dst = newDst } } if needTransfer { // If files are treated as immutable, fail if destination exists and does not match if s.ci.Immutable && pair.Dst != nil { err := fs.CountError(s.ctx, fserrors.NoRetryError(fs.ErrorImmutableModified)) fs.Errorf(pair.Dst, "Source and destination exist but do not match: %v", err) s.processError(err) } else { if pair.Dst != nil { s.markDirModifiedObject(pair.Dst) } else { s.markDirModifiedObject(src) } // If destination already exists, then we must move it into --backup-dir if required if pair.Dst != nil && s.backupDir != nil { err := operations.MoveBackupDir(s.ctx, s.backupDir, pair.Dst) if err != nil { s.processError(err) s.logger(s.ctx, operations.TransferError, pair.Src, pair.Dst, err) } else { // If successful zero out the dst as it is no longer there and copy the file pair.Dst = nil ok = out.Put(s.inCtx, pair) if !ok { return } } } else { ok = out.Put(s.inCtx, pair) if !ok { return } } } } else { // If moving need to delete the files we don't need to copy if s.DoMove { // Delete src if no error on copy if operations.SameObject(src, pair.Dst) { fs.Logf(src, "Not removing source file as it is the same file as the destination") } else if s.ci.IgnoreExisting { fs.Debugf(src, "Not removing source file as destination file exists and --ignore-existing is set") } else if s.checkFirst && s.ci.OrderBy != "" { // If we want perfect ordering then use the transfers to delete the file // // We send src == dst, to say we want the src deleted ok = out.Put(s.inCtx, fs.ObjectPair{Src: src, Dst: src}) if !ok { return } } else { deleteFileErr := operations.DeleteFile(s.ctx, src) s.processError(deleteFileErr) s.logger(s.ctx, operations.TransferError, pair.Src, pair.Dst, deleteFileErr) } } } } tr.Done(s.ctx, err) } } // pairRenamer reads Objects~s on in and attempts to rename them, // otherwise it sends them out if they need transferring. func (s *syncCopyMove) pairRenamer(in *pipe, out *pipe, fraction int, wg *sync.WaitGroup) { defer wg.Done() for { pair, ok := in.GetMax(s.inCtx, fraction) if !ok { return } src := pair.Src if !s.tryRename(src) { // pass on if not renamed fs.Debugf(src, "Need to transfer - No matching file found at Destination") ok = out.Put(s.inCtx, pair) if !ok { return } } } } // pairCopyOrMove reads Objects on in and moves or copies them. func (s *syncCopyMove) pairCopyOrMove(ctx context.Context, in *pipe, fdst fs.Fs, fraction int, wg *sync.WaitGroup) { defer wg.Done() var err error for { pair, ok := in.GetMax(s.inCtx, fraction) if !ok { return } src := pair.Src dst := pair.Dst if s.DoMove { if src != dst { _, err = operations.MoveTransfer(ctx, fdst, dst, src.Remote(), src) } else { // src == dst signals delete the src err = operations.DeleteFile(ctx, src) } } else { _, err = operations.Copy(ctx, fdst, dst, src.Remote(), src) } s.processError(err) if err != nil { s.logger(ctx, operations.TransferError, src, dst, err) } } } // This starts the background checkers. func (s *syncCopyMove) startCheckers() { s.checkerWg.Add(s.ci.Checkers) for i := range s.ci.Checkers { fraction := (100 * i) / s.ci.Checkers go s.pairChecker(s.toBeChecked, s.toBeUploaded, fraction, &s.checkerWg) } } // This stops the background checkers func (s *syncCopyMove) stopCheckers() { s.toBeChecked.Close() fs.Debugf(s.fdst, "Waiting for checks to finish") s.checkerWg.Wait() } // This starts the background transfers func (s *syncCopyMove) startTransfers() { s.transfersWg.Add(s.ci.Transfers) for i := range s.ci.Transfers { fraction := (100 * i) / s.ci.Transfers go s.pairCopyOrMove(s.ctx, s.toBeUploaded, s.fdst, fraction, &s.transfersWg) } } // This stops the background transfers func (s *syncCopyMove) stopTransfers() { s.toBeUploaded.Close() fs.Debugf(s.fdst, "Waiting for transfers to finish") s.transfersWg.Wait() } // This starts the background renamers. func (s *syncCopyMove) startRenamers() { if !s.trackRenames { return } s.renamerWg.Add(s.ci.Checkers) for i := range s.ci.Checkers { fraction := (100 * i) / s.ci.Checkers go s.pairRenamer(s.toBeRenamed, s.toBeUploaded, fraction, &s.renamerWg) } } // This stops the background renamers func (s *syncCopyMove) stopRenamers() { if !s.trackRenames { return } s.toBeRenamed.Close() fs.Debugf(s.fdst, "Waiting for renames to finish") s.renamerWg.Wait() } // This starts the collection of possible renames func (s *syncCopyMove) startTrackRenames() { if !s.trackRenames { return } s.trackRenamesWg.Add(1) go func() { defer s.trackRenamesWg.Done() for o := range s.trackRenamesCh { s.renameCheck = append(s.renameCheck, o) } }() } // This stops the background rename collection func (s *syncCopyMove) stopTrackRenames() { if !s.trackRenames { return } close(s.trackRenamesCh) s.trackRenamesWg.Wait() } // This starts the background deletion of files for --delete-during func (s *syncCopyMove) startDeleters() { if s.deleteMode != fs.DeleteModeDuring && s.deleteMode != fs.DeleteModeOnly { return } s.deletersWg.Add(1) go func() { defer s.deletersWg.Done() err := operations.DeleteFilesWithBackupDir(s.ctx, s.deleteFilesCh, s.backupDir) s.processError(err) }() } // This stops the background deleters func (s *syncCopyMove) stopDeleters() { if s.deleteMode != fs.DeleteModeDuring && s.deleteMode != fs.DeleteModeOnly { return } close(s.deleteFilesCh) s.deletersWg.Wait() } // This deletes the files in the dstFiles map. If checkSrcMap is set // then it checks to see if they exist first in srcFiles the source // file map, otherwise it unconditionally deletes them. If // checkSrcMap is clear then it assumes that the any source files that // have been found have been removed from dstFiles already. func (s *syncCopyMove) deleteFiles(checkSrcMap bool) error { if accounting.Stats(s.ctx).Errored() && !s.ci.IgnoreErrors { fs.Errorf(s.fdst, "%v", fs.ErrorNotDeleting) // log all deletes as errors for remote, o := range s.dstFiles { if checkSrcMap { _, exists := s.srcFiles[remote] if exists { continue } } s.logger(s.ctx, operations.TransferError, nil, o, fs.ErrorNotDeleting) } return fs.ErrorNotDeleting } // Delete the spare files toDelete := make(fs.ObjectsChan, s.ci.Checkers) go func() { outer: for remote, o := range s.dstFiles { if checkSrcMap { _, exists := s.srcFiles[remote] if exists { continue } } if s.aborting() { break } select { case <-s.ctx.Done(): break outer case toDelete <- o: } } close(toDelete) }() return operations.DeleteFilesWithBackupDir(s.ctx, toDelete, s.backupDir) } // This deletes the empty directories in the slice passed in. It // ignores any errors deleting directories func (s *syncCopyMove) deleteEmptyDirectories(ctx context.Context, f fs.Fs, entriesMap map[string]fs.DirEntry) error { if len(entriesMap) == 0 { return nil } if accounting.Stats(ctx).Errored() && !s.ci.IgnoreErrors { fs.Errorf(f, "%v", fs.ErrorNotDeletingDirs) return fs.ErrorNotDeletingDirs } var entries fs.DirEntries for _, entry := range entriesMap { entries = append(entries, entry) } // Now delete the empty directories starting from the longest path sort.Sort(entries) var errorCount int var okCount int for i := len(entries) - 1; i >= 0; i-- { entry := entries[i] dir, ok := entry.(fs.Directory) if ok { // TryRmdir only deletes empty directories err := operations.TryRmdir(ctx, f, dir.Remote()) if err != nil { fs.Debugf(fs.LogDirName(f, dir.Remote()), "Failed to Rmdir: %v", err) errorCount++ } else { okCount++ } } else { fs.Errorf(f, "Not a directory: %v", entry) } } if errorCount > 0 { fs.Debugf(f, "failed to delete %d directories", errorCount) } if okCount > 0 { fs.Debugf(f, "deleted %d directories", okCount) } return nil } // mark the parent of entry as not empty and if entry is a directory mark it as potentially empty. func (s *syncCopyMove) markParentNotEmpty(entry fs.DirEntry) { s.srcEmptyDirsMu.Lock() defer s.srcEmptyDirsMu.Unlock() // Mark entry as potentially empty if it is a directory _, isDir := entry.(fs.Directory) if isDir { s.srcEmptyDirs[entry.Remote()] = entry // if DoMove and --delete-empty-src-dirs flag is set then record the parent but // don't remove any as we are about to move files out of them them making the // directory empty. if s.DoMove && s.deleteEmptySrcDirs { s.srcMoveEmptyDirs[entry.Remote()] = entry } } parentDir := path.Dir(entry.Remote()) if isDir && s.copyEmptySrcDirs { // Mark its parent as not empty if parentDir == "." { parentDir = "" } delete(s.srcEmptyDirs, parentDir) } if !isDir { // Mark ALL its parents as not empty for { if parentDir == "." { parentDir = "" } delete(s.srcEmptyDirs, parentDir) if parentDir == "" || parentDir == "/" { break } parentDir = path.Dir(parentDir) } } } // parseTrackRenamesStrategy turns a config string into a trackRenamesStrategy func parseTrackRenamesStrategy(strategies string) (strategy trackRenamesStrategy, err error) { if len(strategies) == 0 { return strategy, nil } for _, s := range strings.Split(strategies, ",") { switch s { case "hash": strategy |= trackRenamesStrategyHash case "modtime": strategy |= trackRenamesStrategyModtime case "leaf": strategy |= trackRenamesStrategyLeaf case "size": // ignore default: return strategy, fmt.Errorf("unknown track renames strategy %q", s) } } return strategy, nil } // renameID makes a string with the size and the other identifiers of the requested rename strategies // // it may return an empty string in which case no hash could be made func (s *syncCopyMove) renameID(obj fs.Object, renamesStrategy trackRenamesStrategy, precision time.Duration) string { var builder strings.Builder fmt.Fprintf(&builder, "%d", obj.Size()) if renamesStrategy.hash() { var err error hash, err := obj.Hash(s.ctx, s.commonHash) if err != nil { fs.Debugf(obj, "Hash failed: %v", err) return "" } if hash == "" { return "" } builder.WriteRune(',') builder.WriteString(hash) } // for renamesStrategy.modTime() we don't add to the hash but we check the times in // popRenameMap if renamesStrategy.leaf() { builder.WriteRune(',') builder.WriteString(path.Base(obj.Remote())) } return builder.String() } // pushRenameMap adds the object with hash to the rename map func (s *syncCopyMove) pushRenameMap(hash string, obj fs.Object) { s.renameMapMu.Lock() s.renameMap[hash] = append(s.renameMap[hash], obj) s.renameMapMu.Unlock() } // popRenameMap finds the object with hash and pop the first match from // renameMap or returns nil if not found. func (s *syncCopyMove) popRenameMap(hash string, src fs.Object) (dst fs.Object) { s.renameMapMu.Lock() defer s.renameMapMu.Unlock() dsts, ok := s.renameMap[hash] if ok && len(dsts) > 0 { // Element to remove i := 0 // If using track renames strategy modtime then we need to check the modtimes here if s.trackRenamesStrategy.modTime() { i = -1 srcModTime := src.ModTime(s.ctx) for j, dst := range dsts { dstModTime := dst.ModTime(s.ctx) dt := dstModTime.Sub(srcModTime) if dt < s.modifyWindow && dt > -s.modifyWindow { i = j break } } // If nothing matched then return nil if i < 0 { return nil } } // Remove the entry and return it dst = dsts[i] dsts = slices.Delete(dsts, i, i+1) if len(dsts) > 0 { s.renameMap[hash] = dsts } else { delete(s.renameMap, hash) } } return dst } // makeRenameMap builds a map of the destination files by hash that // match sizes in the slice of objects in s.renameCheck func (s *syncCopyMove) makeRenameMap() { fs.Infof(s.fdst, "Making map for --track-renames") // first make a map of possible sizes we need to check possibleSizes := map[int64]struct{}{} for _, obj := range s.renameCheck { possibleSizes[obj.Size()] = struct{}{} } // pump all the dstFiles into in in := make(chan fs.Object, s.ci.Checkers) go s.pumpMapToChan(s.dstFiles, in) // now make a map of size,hash for all dstFiles s.renameMap = make(map[string][]fs.Object) var wg sync.WaitGroup wg.Add(s.ci.Checkers) for range s.ci.Checkers { go func() { defer wg.Done() for obj := range in { // only create hash for dst fs.Object if its size could match if _, found := possibleSizes[obj.Size()]; found { tr := accounting.Stats(s.ctx).NewCheckingTransfer(obj, "renaming") hash := s.renameID(obj, s.trackRenamesStrategy, s.modifyWindow) if hash != "" { s.pushRenameMap(hash, obj) } tr.Done(s.ctx, nil) } } }() } wg.Wait() fs.Infof(s.fdst, "Finished making map for --track-renames") } // tryRename renames an src object when doing track renames if // possible, it returns true if the object was renamed. func (s *syncCopyMove) tryRename(src fs.Object) bool { // Calculate the hash of the src object hash := s.renameID(src, s.trackRenamesStrategy, fs.GetModifyWindow(s.ctx, s.fsrc, s.fdst)) if hash == "" { return false } // Get a match on fdst dst := s.popRenameMap(hash, src) if dst == nil { return false } // Find dst object we are about to overwrite if it exists dstOverwritten, _ := s.fdst.NewObject(s.ctx, src.Remote()) // Rename dst to have name src.Remote() _, err := operations.Move(s.ctx, s.fdst, dstOverwritten, src.Remote(), dst) if err != nil { fs.Debugf(src, "Failed to rename to %q: %v", dst.Remote(), err) return false } // remove file from dstFiles if present s.dstFilesMu.Lock() delete(s.dstFiles, dst.Remote()) s.dstFilesMu.Unlock() fs.Infof(src, "Renamed from %q", dst.Remote()) return true } // Syncs fsrc into fdst // // If Delete is true then it deletes any files in fdst that aren't in fsrc // // If DoMove is true then files will be moved instead of copied. // // dir is the start directory, "" for root func (s *syncCopyMove) run() error { if operations.Same(s.fdst, s.fsrc) && !s.allowOverlap { fs.Errorf(s.fdst, "Nothing to do as source and destination are the same") return nil } // Start background checking and transferring pipeline s.startCheckers() s.startRenamers() if !s.checkFirst { s.startTransfers() } s.startDeleters() s.dstFiles = make(map[string]fs.Object) s.startTrackRenames() // set up a march over fdst and fsrc m := &march.March{ Ctx: s.inCtx, Fdst: s.fdst, Fsrc: s.fsrc, Dir: s.dir, NoTraverse: s.noTraverse, Callback: s, DstIncludeAll: s.fi.Opt.DeleteExcluded, NoCheckDest: s.noCheckDest, NoUnicodeNormalization: s.noUnicodeNormalization, } s.processError(m.Run(s.ctx)) s.stopTrackRenames() if s.trackRenames { // Build the map of the remaining dstFiles by hash s.makeRenameMap() // Attempt renames for all the files which don't have a matching dst for _, src := range s.renameCheck { ok := s.toBeRenamed.Put(s.inCtx, fs.ObjectPair{Src: src, Dst: nil}) if !ok { break } } } // Stop background checking and transferring pipeline s.stopCheckers() if s.checkFirst { fs.Infof(s.fdst, "Checks finished, now starting transfers") s.startTransfers() } s.stopRenamers() s.stopTransfers() s.stopDeleters() // Delete files after if s.deleteMode == fs.DeleteModeAfter { if s.currentError() != nil && !s.ci.IgnoreErrors { fs.Errorf(s.fdst, "%v", fs.ErrorNotDeleting) } else { s.processError(s.deleteFiles(false)) } } // Update modtimes for directories if necessary if s.setDirModTime && s.setDirModTimeAfter { s.processError(s.setDelayedDirModTimes(s.ctx)) } // Prune empty directories if s.deleteMode != fs.DeleteModeOff { if s.currentError() != nil && !s.ci.IgnoreErrors { fs.Errorf(s.fdst, "%v", fs.ErrorNotDeletingDirs) } else { s.processError(s.deleteEmptyDirectories(s.ctx, s.fdst, s.dstEmptyDirs)) } } // Delete empty fsrc subdirectories // if DoMove and --delete-empty-src-dirs flag is set if s.DoMove && s.deleteEmptySrcDirs { // delete potentially empty subdirectories that were part of the move s.processError(s.deleteEmptyDirectories(s.ctx, s.fsrc, s.srcMoveEmptyDirs)) } // Read the error out of the contexts if there is one s.processError(s.ctx.Err()) s.processError(s.inCtx.Err()) // If the duration was exceeded then add a Fatal Error so we don't retry if !s.maxDurationEndTime.IsZero() && time.Since(s.maxDurationEndTime) > 0 { fs.Errorf(s.fdst, "%v", ErrorMaxDurationReachedFatal) s.processError(ErrorMaxDurationReachedFatal) } // Print nothing to transfer message if there were no transfers and no errors if s.deleteMode != fs.DeleteModeOnly && accounting.Stats(s.ctx).GetTransfers() == 0 && s.currentError() == nil { fs.Infof(nil, "There was nothing to transfer") } // cancel the contexts to free resources s.inCancel() s.cancel() return s.currentError() } // DstOnly have an object which is in the destination only func (s *syncCopyMove) DstOnly(dst fs.DirEntry) (recurse bool) { if s.deleteMode == fs.DeleteModeOff { if s.usingLogger { switch x := dst.(type) { case fs.Object: s.logger(s.ctx, operations.MissingOnSrc, nil, x, nil) case fs.Directory: // it's a directory that we'd normally skip, because we're not deleting anything on the dest // however, to make sure every file is logged, we need to list it, so we need to return true here. // we skip this when not using logger. s.logger(s.ctx, operations.MissingOnSrc, nil, dst, fs.ErrorIsDir) return true } } return false } switch x := dst.(type) { case fs.Object: s.logger(s.ctx, operations.MissingOnSrc, nil, x, nil) switch s.deleteMode { case fs.DeleteModeAfter: // record object as needs deleting s.dstFilesMu.Lock() s.dstFiles[x.Remote()] = x s.dstFilesMu.Unlock() case fs.DeleteModeDuring, fs.DeleteModeOnly: select { case <-s.ctx.Done(): return case s.deleteFilesCh <- x: } default: panic(fmt.Sprintf("unexpected delete mode %d", s.deleteMode)) } case fs.Directory: // Do the same thing to the entire contents of the directory // Record directory as it is potentially empty and needs deleting if s.fdst.Features().CanHaveEmptyDirectories { s.dstEmptyDirsMu.Lock() s.dstEmptyDirs[dst.Remote()] = dst s.dstEmptyDirsMu.Unlock() s.logger(s.ctx, operations.MissingOnSrc, nil, dst, fs.ErrorIsDir) } return true default: panic("Bad object in DirEntries") } return false } // keeps track of dirs with changed contents, to avoid setting modtimes on dirs that haven't changed func (s *syncCopyMove) markDirModified(dir string) { if !s.setDirModTimeAfter { return } s.setDirModTimeMu.Lock() defer s.setDirModTimeMu.Unlock() s.modifiedDirs[dir] = struct{}{} } // like markDirModified, but accepts an Object instead of a string. // the marked dir will be this object's parent. func (s *syncCopyMove) markDirModifiedObject(o fs.Object) { dir := path.Dir(o.Remote()) if dir == "." { dir = "" } s.markDirModified(dir) } // copyDirMetadata copies the src directory modTime or Metadata to dst // or f if nil. If dst is nil then it uses dir as the name of the new // directory. // // It returns the destination directory if possible. Note that this may // be nil. func (s *syncCopyMove) copyDirMetadata(ctx context.Context, f fs.Fs, dst fs.Directory, dir string, src fs.Directory) (newDst fs.Directory) { var err error if dst != nil && src.Remote() == dst.Remote() && operations.OverlappingFilterCheck(ctx, s.fdst, s.fsrc) { return nil // src and dst can be the same in convmv } equal := operations.DirsEqual(ctx, src, dst, operations.DirsEqualOpt{ModifyWindow: s.modifyWindow, SetDirModtime: s.setDirModTime, SetDirMetadata: s.setDirMetadata}) if !s.setDirModTimeAfter && equal { return nil } newDst = dst if !equal { if s.setDirMetadata && s.copyEmptySrcDirs { newDst, err = operations.CopyDirMetadata(ctx, f, dst, dir, src) } else if dst == nil && s.setDirModTime && s.copyEmptySrcDirs { newDst, err = operations.MkdirModTime(ctx, f, dir, src.ModTime(ctx)) } else if dst == nil && s.copyEmptySrcDirs { err = operations.Mkdir(ctx, f, dir) } else if dst != nil && s.setDirModTime { newDst, err = operations.SetDirModTime(ctx, f, dst, dir, src.ModTime(ctx)) } } if transform.Transforming(ctx) && newDst != nil && src.Remote() != newDst.Remote() { s.markParentNotEmpty(src) } // If we need to set modtime after and we created a dir, then save it for later if s.setDirModTime && s.setDirModTimeAfter && err == nil { if newDst != nil { dir = newDst.Remote() } level := strings.Count(dir, "/") + 1 // The root directory "" is at the top level if dir == "" { level = 0 } s.setDirModTimeMu.Lock() // Keep track of the maximum level inserted if level > s.setDirModTimesMaxLevel { s.setDirModTimesMaxLevel = level } set := setDirModTime{ src: src, dst: newDst, dir: dir, modTime: src.ModTime(ctx), level: level, } s.setDirModTimes = append(s.setDirModTimes, set) s.setDirModTimeMu.Unlock() fs.Debugf(nil, "Added delayed dir = %q, newDst=%v", dir, newDst) } s.processError(err) if err != nil { return nil } return newDst } // Set the modtimes for directories func (s *syncCopyMove) setDelayedDirModTimes(ctx context.Context) error { s.setDirModTimeMu.Lock() defer s.setDirModTimeMu.Unlock() // Timestamp all directories at the same level in parallel, deepest first // We do this by iterating the slice multiple times to save memory // There could be a lot of directories in this slice. errCount := errcount.New() for level := s.setDirModTimesMaxLevel; level >= 0; level-- { g, gCtx := errgroup.WithContext(ctx) g.SetLimit(s.ci.Checkers) for _, item := range s.setDirModTimes { if item.level != level { continue } // End early if error if gCtx.Err() != nil { break } if _, ok := s.modifiedDirs[item.dir]; !ok { continue } if !s.copyEmptySrcDirs { if _, isEmpty := s.srcEmptyDirs[item.dir]; isEmpty { continue } } item := item if s.setDirModTimeAfter { // mark dir's parent as modified dir := path.Dir(item.dir) if dir == "." { dir = "" } s.modifiedDirs[dir] = struct{}{} // lock is already held } g.Go(func() error { var err error if s.setDirMetadata { _, err = operations.CopyDirMetadata(gCtx, s.fdst, item.dst, item.dir, item.src) } else { _, err = operations.SetDirModTime(gCtx, s.fdst, item.dst, item.dir, item.modTime) } if err != nil { err = fs.CountError(ctx, err) fs.Errorf(item.dir, "Failed to update directory timestamp or metadata: %v", err) errCount.Add(err) } return nil // don't return errors, just count them }) } err := g.Wait() if err != nil { return err } } return errCount.Err("failed to set directory modtime") } // SrcOnly have an object which is in the source only func (s *syncCopyMove) SrcOnly(src fs.DirEntry) (recurse bool) { if s.deleteMode == fs.DeleteModeOnly { return false } switch x := src.(type) { case fs.Object: s.logger(s.ctx, operations.MissingOnDst, x, nil, nil) s.markParentNotEmpty(src) if s.trackRenames { // Save object to check for a rename later select { case <-s.ctx.Done(): return case s.trackRenamesCh <- x: } } else { // Check CompareDest && CopyDest NoNeedTransfer, err := operations.CompareOrCopyDest(s.ctx, s.fdst, nil, x, s.compareCopyDest, s.backupDir) if err != nil { s.processError(err) s.logger(s.ctx, operations.TransferError, x, nil, err) } if !NoNeedTransfer { // No need to check since doesn't exist fs.Debugf(src, "Need to transfer - File not found at Destination") s.markDirModifiedObject(x) ok := s.toBeUploaded.Put(s.inCtx, fs.ObjectPair{Src: x, Dst: nil}) if !ok { return } } } case fs.Directory: // Do the same thing to the entire contents of the directory s.markParentNotEmpty(src) s.logger(s.ctx, operations.MissingOnDst, src, nil, fs.ErrorIsDir) // Create the directory and make sure the Metadata/ModTime is correct s.copyDirMetadata(s.ctx, s.fdst, nil, transform.Path(s.ctx, x.Remote(), true), x) s.markDirModified(transform.Path(s.ctx, x.Remote(), true)) return true default: panic("Bad object in DirEntries") } return false } // Match is called when src and dst are present, so sync src to dst func (s *syncCopyMove) Match(ctx context.Context, dst, src fs.DirEntry) (recurse bool) { switch srcX := src.(type) { case fs.Object: s.markParentNotEmpty(src) if s.deleteMode == fs.DeleteModeOnly { return false } dstX, ok := dst.(fs.Object) if ok { // No logger here because we'll handle it in equal() ok = s.toBeChecked.Put(s.inCtx, fs.ObjectPair{Src: srcX, Dst: dstX}) if !ok { return false } } else { // FIXME src is file, dst is directory err := errors.New("can't overwrite directory with file") fs.Errorf(dst, "%v", err) s.processError(err) s.logger(ctx, operations.TransferError, srcX, dstX, err) } case fs.Directory: // Do the same thing to the entire contents of the directory srcX = fs.NewOverrideDirectory(srcX, transform.Path(ctx, src.Remote(), true)) src = srcX if !transform.Transforming(ctx) || src.Remote() != dst.Remote() { s.markParentNotEmpty(src) } dstX, ok := dst.(fs.Directory) if ok { s.logger(s.ctx, operations.Match, src, dst, fs.ErrorIsDir) // Create the directory and make sure the Metadata/ModTime is correct s.copyDirMetadata(s.ctx, s.fdst, dstX, "", srcX) if s.ci.FixCase && !s.ci.Immutable && src.Remote() != dst.Remote() { // Fix case for case insensitive filesystems // Fix each dir before recursing into subdirs and files err := operations.DirMoveCaseInsensitive(s.ctx, s.fdst, dst.Remote(), src.Remote()) if err != nil { fs.Errorf(dst, "Error while attempting to rename to %s: %v", src.Remote(), err) s.processError(err) } else { fs.Infof(dst, "Fixed case by renaming to: %s", src.Remote()) } } return true } // FIXME src is dir, dst is file err := errors.New("can't overwrite file with directory") fs.Errorf(dst, "%v", err) s.processError(err) s.logger(ctx, operations.TransferError, src.(fs.ObjectInfo), dst.(fs.ObjectInfo), err) default: panic("Bad object in DirEntries") } return false } // Syncs fsrc into fdst // // If Delete is true then it deletes any files in fdst that aren't in fsrc // // If DoMove is true then files will be moved instead of copied. // // dir is the start directory, "" for root func runSyncCopyMove(ctx context.Context, fdst, fsrc fs.Fs, deleteMode fs.DeleteMode, DoMove bool, deleteEmptySrcDirs bool, copyEmptySrcDirs bool, allowOverlap bool) error { ci := fs.GetConfig(ctx) if deleteMode != fs.DeleteModeOff && DoMove { return fserrors.FatalError(errors.New("can't delete and move at the same time")) } // Run an extra pass to delete only if deleteMode == fs.DeleteModeBefore { if ci.TrackRenames { return fserrors.FatalError(errors.New("can't use --delete-before with --track-renames")) } // only delete stuff during in this pass do, err := newSyncCopyMove(ctx, fdst, fsrc, fs.DeleteModeOnly, false, deleteEmptySrcDirs, copyEmptySrcDirs, allowOverlap) if err != nil { return err } err = do.run() if err != nil { return err } // Next pass does a copy only deleteMode = fs.DeleteModeOff } do, err := newSyncCopyMove(ctx, fdst, fsrc, deleteMode, DoMove, deleteEmptySrcDirs, copyEmptySrcDirs, allowOverlap) if err != nil { return err } return do.run() } // Sync fsrc into fdst func Sync(ctx context.Context, fdst, fsrc fs.Fs, copyEmptySrcDirs bool) error { ci := fs.GetConfig(ctx) return runSyncCopyMove(ctx, fdst, fsrc, ci.DeleteMode, false, false, copyEmptySrcDirs, false) } // CopyDir copies fsrc into fdst func CopyDir(ctx context.Context, fdst, fsrc fs.Fs, copyEmptySrcDirs bool) error { return runSyncCopyMove(ctx, fdst, fsrc, fs.DeleteModeOff, false, false, copyEmptySrcDirs, false) } // moveDir moves fsrc into fdst func moveDir(ctx context.Context, fdst, fsrc fs.Fs, deleteEmptySrcDirs bool, copyEmptySrcDirs bool) error { return runSyncCopyMove(ctx, fdst, fsrc, fs.DeleteModeOff, true, deleteEmptySrcDirs, copyEmptySrcDirs, false) } // Transform renames fdst in place func Transform(ctx context.Context, fdst fs.Fs, deleteEmptySrcDirs bool, copyEmptySrcDirs bool) error { return runSyncCopyMove(ctx, fdst, fdst, fs.DeleteModeOff, true, deleteEmptySrcDirs, copyEmptySrcDirs, true) } // MoveDir moves fsrc into fdst func MoveDir(ctx context.Context, fdst, fsrc fs.Fs, deleteEmptySrcDirs bool, copyEmptySrcDirs bool) error { fi := filter.GetConfig(ctx) if operations.Same(fdst, fsrc) { fs.Errorf(fdst, "Nothing to do as source and destination are the same") return nil } // First attempt to use DirMover if exists, same Fs and no filters are active if fdstDirMove := fdst.Features().DirMove; fdstDirMove != nil && operations.SameConfig(fsrc, fdst) && fi.InActive() { if operations.SkipDestructive(ctx, fdst, "server-side directory move") { return nil } fs.Debugf(fdst, "Using server-side directory move") err := fdstDirMove(ctx, fsrc, "", "") switch err { case fs.ErrorCantDirMove, fs.ErrorDirExists: fs.Infof(fdst, "Server side directory move failed - fallback to file moves: %v", err) case nil: fs.Infof(fdst, "Server side directory move succeeded") return nil default: err = fs.CountError(ctx, err) fs.Errorf(fdst, "Server side directory move failed: %v", err) return err } } // Otherwise move the files one by one return moveDir(ctx, fdst, fsrc, deleteEmptySrcDirs, copyEmptySrcDirs) } rclone-v1.71.0/fs/sync/sync_test.go000066400000000000000000003046551505210326400172110ustar00rootroot00000000000000// Test sync/copy/move package sync import ( "bytes" "context" "errors" "fmt" "io" "os" "os/exec" "runtime" "sort" "strings" "testing" "time" mutex "sync" // renamed as "sync" already in use _ "github.com/rclone/rclone/backend/all" // import all backends "github.com/rclone/rclone/cmd/bisync/bilib" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/lib/transform" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "golang.org/x/text/unicode/norm" ) // Some times used in the tests var ( t1 = fstest.Time("2001-02-03T04:05:06.499999999Z") t2 = fstest.Time("2011-12-25T12:59:59.123456789Z") t3 = fstest.Time("2011-12-30T12:59:59.000000000Z") ) // TestMain drives the tests func TestMain(m *testing.M) { fstest.TestMain(m) } // Check dry run is working func TestCopyWithDryRun(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) file1 := r.WriteFile("sub dir/hello world", "hello world", t1) r.Mkdir(ctx, r.Fremote) ci.DryRun = true ctx = predictDstFromLogger(ctx) err := CopyDir(ctx, r.Fremote, r.Flocal, false) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // error expected here because dry-run require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t) } // Now without dry run func TestCopy(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteFile("sub dir/hello world", "hello world", t1) _, err := operations.SetDirModTime(ctx, r.Flocal, nil, "sub dir", t2) if err != nil && !errors.Is(err, fs.ErrorNotImplemented) { require.NoError(t, err) } r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = CopyDir(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file1) // Check that the modtimes of the directories are as expected r.CheckDirectoryModTimes(t, "sub dir") } func testCopyMetadata(t *testing.T, createEmptySrcDirs bool) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) ci.Metadata = true r := fstest.NewRun(t) features := r.Fremote.Features() if !features.ReadMetadata && !features.WriteMetadata && !features.UserMetadata && !features.ReadDirMetadata && !features.WriteDirMetadata && !features.UserDirMetadata { t.Skip("Skipping as metadata not supported") } if createEmptySrcDirs && !features.CanHaveEmptyDirectories { t.Skip("Skipping as can't have empty directories") } const content = "hello metadata world!" const dirPath = "metadata sub dir" const emptyDirPath = "empty metadata sub dir" const filePath = dirPath + "/hello metadata world" fileMetadata := fs.Metadata{ // System metadata supported by all backends "mtime": t1.Format(time.RFC3339Nano), // User metadata "potato": "jersey", } dirMetadata := fs.Metadata{ // System metadata supported by all backends "mtime": t2.Format(time.RFC3339Nano), // User metadata "potato": "king edward", } // Make the directory with metadata - may fall back to Mkdir _, err := operations.MkdirMetadata(ctx, r.Flocal, dirPath, dirMetadata) require.NoError(t, err) // Make the empty directory with metadata - may fall back to Mkdir _, err = operations.MkdirMetadata(ctx, r.Flocal, emptyDirPath, dirMetadata) require.NoError(t, err) // Upload the file with metadata in := io.NopCloser(bytes.NewBufferString(content)) _, err = operations.Rcat(ctx, r.Flocal, filePath, in, t1, fileMetadata) require.NoError(t, err) file1 := fstest.NewItem(filePath, content, t1) // Reset the time of the directory _, err = operations.SetDirModTime(ctx, r.Flocal, nil, dirPath, t2) if err != nil && !errors.Is(err, fs.ErrorNotImplemented) { require.NoError(t, err) } ctx = predictDstFromLogger(ctx) err = CopyDir(ctx, r.Fremote, r.Flocal, createEmptySrcDirs) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file1) // Check that the modtimes of the directories are as expected r.CheckDirectoryModTimes(t, dirPath) // Check that the metadata on the directory and file is correct if features.WriteMetadata && features.ReadMetadata { fstest.CheckEntryMetadata(ctx, t, r.Fremote, fstest.NewObject(ctx, t, r.Fremote, filePath), fileMetadata) } if features.WriteDirMetadata && features.ReadDirMetadata { fstest.CheckEntryMetadata(ctx, t, r.Fremote, fstest.NewDirectory(ctx, t, r.Fremote, dirPath), dirMetadata) } if !createEmptySrcDirs { // dir must not exist _, err := fstest.NewDirectoryRetries(ctx, t, r.Fremote, emptyDirPath, 1) assert.Error(t, err, "Not expecting to find empty directory") assert.True(t, errors.Is(err, fs.ErrorDirNotFound), fmt.Sprintf("expecting wrapped %#v not: %#v", fs.ErrorDirNotFound, err)) } else { // dir must exist dir := fstest.NewDirectory(ctx, t, r.Fremote, emptyDirPath) if features.ReadDirMetadata { fstest.CheckEntryMetadata(ctx, t, r.Fremote, dir, dirMetadata) } } } func TestCopyMetadata(t *testing.T) { testCopyMetadata(t, true) } func TestCopyMetadataNoEmptyDirs(t *testing.T) { testCopyMetadata(t, false) } func TestCopyMissingDirectory(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) r.Mkdir(ctx, r.Fremote) nonExistingFs, err := fs.NewFs(ctx, "/non-existing") if err != nil { t.Fatal(err) } ctx = predictDstFromLogger(ctx) err = CopyDir(ctx, r.Fremote, nonExistingFs, false) require.Error(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) } // Now with --no-traverse func TestCopyNoTraverse(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.NoTraverse = true file1 := r.WriteFile("sub dir/hello world", "hello world", t1) ctx = predictDstFromLogger(ctx) err := CopyDir(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file1) } func TestCopyNoTraverseDeadlock(t *testing.T) { r := fstest.NewRun(t) if !r.Fremote.Features().IsLocal { t.Skip("Only runs on local") } const nFiles = 200 t1 := fstest.Time("2001-02-03T04:05:06.499999999Z") // Create lots of source files. items := make([]fstest.Item, nFiles) for i := range items { name := fmt.Sprintf("file%d.txt", i) items[i] = r.WriteFile(name, fmt.Sprintf("content%d", i), t1) } r.CheckLocalItems(t, items...) // Set --no-traverse ctx, ci := fs.AddConfig(context.Background()) ci.NoTraverse = true // Initial copy to establish destination. require.NoError(t, CopyDir(ctx, r.Fremote, r.Flocal, false)) r.CheckRemoteItems(t, items...) // Second copy which shouldn't deadlock require.NoError(t, CopyDir(ctx, r.Flocal, r.Fremote, false)) r.CheckRemoteItems(t, items...) } // Now with --check-first func TestCopyCheckFirst(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.CheckFirst = true file1 := r.WriteFile("sub dir/hello world", "hello world", t1) ctx = predictDstFromLogger(ctx) err := CopyDir(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file1) } // Now with --no-traverse func TestSyncNoTraverse(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.NoTraverse = true file1 := r.WriteFile("sub dir/hello world", "hello world", t1) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file1) } // Test copy with depth func TestCopyWithDepth(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) file1 := r.WriteFile("sub dir/hello world", "hello world", t1) file2 := r.WriteFile("hello world2", "hello world2", t2) // Check the MaxDepth too ci.MaxDepth = 1 ctx = predictDstFromLogger(ctx) err := CopyDir(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1, file2) r.CheckRemoteItems(t, file2) } // Test copy with files from func testCopyWithFilesFrom(t *testing.T, noTraverse bool) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) file1 := r.WriteFile("potato2", "hello world", t1) file2 := r.WriteFile("hello world2", "hello world2", t2) // Set the --files-from equivalent f, err := filter.NewFilter(nil) require.NoError(t, err) require.NoError(t, f.AddFile("potato2")) require.NoError(t, f.AddFile("notfound")) // Change the active filter ctx = filter.ReplaceConfig(ctx, f) ci.NoTraverse = noTraverse ctx = predictDstFromLogger(ctx) err = CopyDir(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1, file2) r.CheckRemoteItems(t, file1) } func TestCopyWithFilesFrom(t *testing.T) { testCopyWithFilesFrom(t, false) } func TestCopyWithFilesFromAndNoTraverse(t *testing.T) { testCopyWithFilesFrom(t, true) } // Test copy empty directories func TestCopyEmptyDirectories(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteFile("sub dir/hello world", "hello world", t1) _, err := operations.MkdirModTime(ctx, r.Flocal, "sub dir2/sub sub dir2", t2) require.NoError(t, err) _, err = operations.SetDirModTime(ctx, r.Flocal, nil, "sub dir2", t2) require.NoError(t, err) r.Mkdir(ctx, r.Fremote) // Set the modtime on "sub dir" to something specific // Without this it fails on the CI and in VirtualBox with variances of up to 10mS _, err = operations.SetDirModTime(ctx, r.Flocal, nil, "sub dir", t1) require.NoError(t, err) ctx = predictDstFromLogger(ctx) err = CopyDir(ctx, r.Fremote, r.Flocal, true) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteListing( t, []fstest.Item{ file1, }, []string{ "sub dir", "sub dir2", "sub dir2/sub sub dir2", }, ) // Check that the modtimes of the directories are as expected r.CheckDirectoryModTimes(t, "sub dir", "sub dir2", "sub dir2/sub sub dir2") } // Test copy empty directories when we are configured not to create them func TestCopyNoEmptyDirectories(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteFile("sub dir/hello world", "hello world", t1) err := operations.Mkdir(ctx, r.Flocal, "sub dir2") require.NoError(t, err) _, err = operations.MkdirModTime(ctx, r.Flocal, "sub dir2/sub sub dir2", t2) require.NoError(t, err) r.Mkdir(ctx, r.Fremote) err = CopyDir(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) r.CheckRemoteListing( t, []fstest.Item{ file1, }, []string{ "sub dir", }, ) } // Test move empty directories func TestMoveEmptyDirectories(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteFile("sub dir/hello world", "hello world", t1) _, err := operations.MkdirModTime(ctx, r.Flocal, "sub dir2", t2) require.NoError(t, err) subDir := fstest.NewDirectory(ctx, t, r.Flocal, "sub dir") subDirT := subDir.ModTime(ctx) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = MoveDir(ctx, r.Fremote, r.Flocal, false, true) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteListing( t, []fstest.Item{ file1, }, []string{ "sub dir", "sub dir2", }, ) // Check that the modtimes of the directories are as expected r.CheckDirectoryModTimes(t, "sub dir2") // Note that "sub dir" mod time is updated when file1 is deleted from it // So check it more manually got := fstest.NewDirectory(ctx, t, r.Fremote, "sub dir") fstest.CheckDirModTime(ctx, t, r.Fremote, got, subDirT) } // Test that --no-update-dir-modtime is working func TestSyncNoUpdateDirModtime(t *testing.T) { r := fstest.NewRun(t) if r.Fremote.Features().DirSetModTime == nil { t.Skip("Skipping test as backend does not support DirSetModTime") } ctx, ci := fs.AddConfig(context.Background()) ci.NoUpdateDirModTime = true const name = "sub dir no update dir modtime" // Set the modtime on name to something specific _, err := operations.MkdirModTime(ctx, r.Flocal, name, t1) require.NoError(t, err) // Create the remote directory with the current time require.NoError(t, r.Fremote.Mkdir(ctx, name)) // Read its modification time wantT := fstest.NewDirectory(ctx, t, r.Fremote, name).ModTime(ctx) ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, true) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteListing( t, []fstest.Item{}, []string{ name, }, ) // Read the new directory modification time - it should not have changed gotT := fstest.NewDirectory(ctx, t, r.Fremote, name).ModTime(ctx) fstest.AssertTimeEqualWithPrecision(t, name, wantT, gotT, r.Fremote.Precision()) } // Test move empty directories when we are not configured to create them func TestMoveNoEmptyDirectories(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteFile("sub dir/hello world", "hello world", t1) err := operations.Mkdir(ctx, r.Flocal, "sub dir2") require.NoError(t, err) r.Mkdir(ctx, r.Fremote) err = MoveDir(ctx, r.Fremote, r.Flocal, false, false) require.NoError(t, err) r.CheckRemoteListing( t, []fstest.Item{ file1, }, []string{ "sub dir", }, ) } // Test sync empty directories func TestSyncEmptyDirectories(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteFile("sub dir/hello world", "hello world", t1) _, err := operations.MkdirModTime(ctx, r.Flocal, "sub dir2", t2) require.NoError(t, err) // Set the modtime on "sub dir" to something specific // Without this it fails on the CI and in VirtualBox with variances of up to 10mS _, err = operations.SetDirModTime(ctx, r.Flocal, nil, "sub dir", t1) require.NoError(t, err) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, true) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteListing( t, []fstest.Item{ file1, }, []string{ "sub dir", "sub dir2", }, ) // Check that the modtimes of the directories are as expected r.CheckDirectoryModTimes(t, "sub dir", "sub dir2") } // Test delayed mod time setting func TestSyncSetDelayedModTimes(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) if !r.Fremote.Features().DirModTimeUpdatesOnWrite { t.Skip("Backend doesn't have DirModTimeUpdatesOnWrite set") } // Create directories without timestamps require.NoError(t, r.Flocal.Mkdir(ctx, "a1/b1/c1/d1/e1/f1")) require.NoError(t, r.Flocal.Mkdir(ctx, "a1/b2/c1/d1/e1/f1")) require.NoError(t, r.Flocal.Mkdir(ctx, "a1/b1/c1/d2/e1/f1")) require.NoError(t, r.Flocal.Mkdir(ctx, "a1/b1/c1/d2/e1/f2")) dirs := []string{ "a1", "a1/b1", "a1/b1/c1", "a1/b1/c1/d1", "a1/b1/c1/d1/e1", "a1/b1/c1/d1/e1/f1", "a1/b1/c1/d2", "a1/b1/c1/d2/e1", "a1/b1/c1/d2/e1/f1", "a1/b1/c1/d2/e1/f2", "a1/b2", "a1/b2/c1", "a1/b2/c1/d1", "a1/b2/c1/d1/e1", "a1/b2/c1/d1/e1/f1", } r.CheckLocalListing(t, []fstest.Item{}, dirs) // Timestamp the directories in reverse order ts := t1 for i := len(dirs) - 1; i >= 0; i-- { dir := dirs[i] _, err := operations.SetDirModTime(ctx, r.Flocal, nil, dir, ts) require.NoError(t, err) ts = ts.Add(time.Minute) } r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, true) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteListing(t, []fstest.Item{}, dirs) // Check that the modtimes of the directories are as expected r.CheckDirectoryModTimes(t, dirs...) } // Test sync empty directories when we are not configured to create them func TestSyncNoEmptyDirectories(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteFile("sub dir/hello world", "hello world", t1) err := operations.Mkdir(ctx, r.Flocal, "sub dir2") require.NoError(t, err) r.Mkdir(ctx, r.Fremote) err = Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) r.CheckRemoteListing( t, []fstest.Item{ file1, }, []string{ "sub dir", }, ) } // Test a server-side copy if possible, or the backup path if not func TestServerSideCopy(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteObject(ctx, "sub dir/hello world", "hello world", t1) r.CheckRemoteItems(t, file1) FremoteCopy, _, finaliseCopy, err := fstest.RandomRemote() require.NoError(t, err) defer finaliseCopy() t.Logf("Server side copy (if possible) %v -> %v", r.Fremote, FremoteCopy) ctx = predictDstFromLogger(ctx) err = CopyDir(ctx, FremoteCopy, r.Fremote, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) fstest.CheckItems(t, FremoteCopy, file1) } // Test copying a file over itself func TestCopyOverSelf(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteObject(ctx, "sub dir/hello world", "hello world", t1) r.CheckRemoteItems(t, file1) file2 := r.WriteFile("sub dir/hello world", "hello world again", t2) r.CheckLocalItems(t, file2) ctx = predictDstFromLogger(ctx) err := CopyDir(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteItems(t, file2) } // Test server-side copying a file over itself func TestServerSideCopyOverSelf(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteObject(ctx, "sub dir/hello world", "hello world", t1) r.CheckRemoteItems(t, file1) FremoteCopy, _, finaliseCopy, err := fstest.RandomRemote() require.NoError(t, err) defer finaliseCopy() t.Logf("Server side copy (if possible) %v -> %v", r.Fremote, FremoteCopy) ctx = predictDstFromLogger(ctx) err = CopyDir(ctx, FremoteCopy, r.Fremote, false) require.NoError(t, err) testLoggerVsLsf(ctx, FremoteCopy, r.Fremote, operations.GetLoggerOpt(ctx).JSON, t) fstest.CheckItems(t, FremoteCopy, file1) file2 := r.WriteObject(ctx, "sub dir/hello world", "hello world again", t2) r.CheckRemoteItems(t, file2) ctx = predictDstFromLogger(ctx) err = CopyDir(ctx, FremoteCopy, r.Fremote, false) require.NoError(t, err) testLoggerVsLsf(ctx, FremoteCopy, r.Fremote, operations.GetLoggerOpt(ctx).JSON, t) fstest.CheckItems(t, FremoteCopy, file2) } // Test moving a file over itself func TestMoveOverSelf(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteObject(ctx, "sub dir/hello world", "hello world", t1) r.CheckRemoteItems(t, file1) file2 := r.WriteFile("sub dir/hello world", "hello world again", t2) r.CheckLocalItems(t, file2) ctx = predictDstFromLogger(ctx) err := MoveDir(ctx, r.Fremote, r.Flocal, false, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t) r.CheckRemoteItems(t, file2) } // Test server-side moving a file over itself func TestServerSideMoveOverSelf(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteObject(ctx, "sub dir/hello world", "hello world", t1) r.CheckRemoteItems(t, file1) FremoteCopy, _, finaliseCopy, err := fstest.RandomRemote() require.NoError(t, err) defer finaliseCopy() t.Logf("Server side copy (if possible) %v -> %v", r.Fremote, FremoteCopy) ctx = predictDstFromLogger(ctx) err = CopyDir(ctx, FremoteCopy, r.Fremote, false) require.NoError(t, err) testLoggerVsLsf(ctx, FremoteCopy, r.Fremote, operations.GetLoggerOpt(ctx).JSON, t) fstest.CheckItems(t, FremoteCopy, file1) file2 := r.WriteObject(ctx, "sub dir/hello world", "hello world again", t2) r.CheckRemoteItems(t, file2) // ctx = predictDstFromLogger(ctx) err = MoveDir(ctx, FremoteCopy, r.Fremote, false, false) require.NoError(t, err) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // not currently supported r.CheckRemoteItems(t) fstest.CheckItems(t, FremoteCopy, file2) // check that individual file moves also work without MoveDir file3 := r.WriteObject(ctx, "sub dir/hello world", "hello world a third time", t3) r.CheckRemoteItems(t, file3) ctx = predictDstFromLogger(ctx) fs.Debugf(nil, "testing file moves") err = moveDir(ctx, FremoteCopy, r.Fremote, false, false) require.NoError(t, err) testLoggerVsLsf(ctx, FremoteCopy, r.Fremote, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteItems(t) fstest.CheckItems(t, FremoteCopy, file3) } // Check that if the local file doesn't exist when we copy it up, // nothing happens to the remote file func TestCopyAfterDelete(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteObject(ctx, "sub dir/hello world", "hello world", t1) r.CheckLocalItems(t) r.CheckRemoteItems(t, file1) err := operations.Mkdir(ctx, r.Flocal, "") require.NoError(t, err) ctx = predictDstFromLogger(ctx) err = CopyDir(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t) r.CheckRemoteItems(t, file1) } // Check the copy downloading a file func TestCopyRedownload(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteObject(ctx, "sub dir/hello world", "hello world", t1) r.CheckRemoteItems(t, file1) ctx = predictDstFromLogger(ctx) err := CopyDir(ctx, r.Flocal, r.Fremote, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // Test with combined precision of local and remote as we copied it there and back r.CheckLocalListing(t, []fstest.Item{file1}, nil) } // Create a file and sync it. Change the last modified date and resync. // If we're only doing sync by size and checksum, we expect nothing to // to be transferred on the second sync. func TestSyncBasedOnCheckSum(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.CheckSum = true file1 := r.WriteFile("check sum", "-", t1) r.CheckLocalItems(t, file1) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // We should have transferred exactly one file. assert.Equal(t, toyFileTransfers(r), accounting.GlobalStats().GetTransfers()) r.CheckRemoteItems(t, file1) // Change last modified date only file2 := r.WriteFile("check sum", "-", t2) r.CheckLocalItems(t, file2) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // We should have transferred no files assert.Equal(t, int64(0), accounting.GlobalStats().GetTransfers()) r.CheckLocalItems(t, file2) r.CheckRemoteItems(t, file1) } // Create a file and sync it. Change the last modified date and the // file contents but not the size. If we're only doing sync by size // only, we expect nothing to to be transferred on the second sync. func TestSyncSizeOnly(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.SizeOnly = true file1 := r.WriteFile("sizeonly", "potato", t1) r.CheckLocalItems(t, file1) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // We should have transferred exactly one file. assert.Equal(t, toyFileTransfers(r), accounting.GlobalStats().GetTransfers()) r.CheckRemoteItems(t, file1) // Update mtime, md5sum but not length of file file2 := r.WriteFile("sizeonly", "POTATO", t2) r.CheckLocalItems(t, file2) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // We should have transferred no files assert.Equal(t, int64(0), accounting.GlobalStats().GetTransfers()) r.CheckLocalItems(t, file2) r.CheckRemoteItems(t, file1) } // Create a file and sync it. Keep the last modified date but change // the size. With --ignore-size we expect nothing to to be // transferred on the second sync. func TestSyncIgnoreSize(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.IgnoreSize = true file1 := r.WriteFile("ignore-size", "contents", t1) r.CheckLocalItems(t, file1) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // We should have transferred exactly one file. assert.Equal(t, toyFileTransfers(r), accounting.GlobalStats().GetTransfers()) r.CheckRemoteItems(t, file1) // Update size but not date of file file2 := r.WriteFile("ignore-size", "longer contents but same date", t1) r.CheckLocalItems(t, file2) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // We should have transferred no files assert.Equal(t, int64(0), accounting.GlobalStats().GetTransfers()) r.CheckLocalItems(t, file2) r.CheckRemoteItems(t, file1) } func TestSyncIgnoreTimes(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) file1 := r.WriteBoth(ctx, "existing", "potato", t1) r.CheckRemoteItems(t, file1) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // We should have transferred exactly 0 files because the // files were identical. assert.Equal(t, int64(0), accounting.GlobalStats().GetTransfers()) ci.IgnoreTimes = true accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // We should have transferred exactly one file even though the // files were identical. assert.Equal(t, toyFileTransfers(r), accounting.GlobalStats().GetTransfers()) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file1) } func TestSyncIgnoreExisting(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) file1 := r.WriteFile("existing", "potato", t1) ci.IgnoreExisting = true accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file1) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // Change everything r.WriteFile("existing", "newpotatoes", t2) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) // Items should not change r.CheckRemoteItems(t, file1) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) } func TestSyncIgnoreErrors(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.IgnoreErrors = true file1 := r.WriteFile("a/potato2", "------------------------------------------------------------", t1) file2 := r.WriteObject(ctx, "b/potato", "SMALLER BUT SAME DATE", t2) file3 := r.WriteBoth(ctx, "c/non empty space", "AhHa!", t2) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "d")) r.CheckLocalListing( t, []fstest.Item{ file1, file3, }, []string{ "a", "c", }, ) r.CheckRemoteListing( t, []fstest.Item{ file2, file3, }, []string{ "b", "c", "d", }, ) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) _ = fs.CountError(ctx, errors.New("boom")) assert.NoError(t, Sync(ctx, r.Fremote, r.Flocal, false)) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalListing( t, []fstest.Item{ file1, file3, }, []string{ "a", "c", }, ) r.CheckRemoteListing( t, []fstest.Item{ file1, file3, }, []string{ "a", "c", }, ) } func TestSyncAfterChangingModtimeOnly(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) file1 := r.WriteFile("empty space", "-", t2) file2 := r.WriteObject(ctx, "empty space", "-", t1) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) ci.DryRun = true accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) ci.DryRun = false accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file1) } func TestSyncAfterChangingModtimeOnlyWithNoUpdateModTime(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) if r.Fremote.Hashes().Count() == 0 { t.Logf("Can't check this if no hashes supported") return } ci.NoUpdateModTime = true file1 := r.WriteFile("empty space", "-", t2) file2 := r.WriteObject(ctx, "empty space", "-", t1) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) } func TestSyncDoesntUpdateModtime(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) if fs.GetModifyWindow(ctx, r.Fremote) == fs.ModTimeNotSupported { t.Skip("Can't run this test on fs which doesn't support mod time") } file1 := r.WriteFile("foo", "foo", t2) file2 := r.WriteObject(ctx, "foo", "bar", t1) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file1) // We should have transferred exactly one file, not set the mod time assert.Equal(t, toyFileTransfers(r), accounting.GlobalStats().GetTransfers()) } func TestSyncAfterAddingAFile(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteBoth(ctx, "empty space", "-", t2) file2 := r.WriteFile("potato", "------------------------------------------------------------", t3) r.CheckLocalItems(t, file1, file2) r.CheckRemoteItems(t, file1) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1, file2) r.CheckRemoteItems(t, file1, file2) } func TestSyncAfterChangingFilesSizeOnly(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteObject(ctx, "potato", "------------------------------------------------------------", t3) file2 := r.WriteFile("potato", "smaller but same date", t3) r.CheckRemoteItems(t, file1) r.CheckLocalItems(t, file2) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file2) r.CheckRemoteItems(t, file2) } // Sync after changing a file's contents, changing modtime but length // remaining the same func TestSyncAfterChangingContentsOnly(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) var file1 fstest.Item if r.Fremote.Precision() == fs.ModTimeNotSupported { t.Logf("ModTimeNotSupported so forcing file to be a different size") file1 = r.WriteObject(ctx, "potato", "different size to make sure it syncs", t3) } else { file1 = r.WriteObject(ctx, "potato", "smaller but same date", t3) } file2 := r.WriteFile("potato", "SMALLER BUT SAME DATE", t2) r.CheckRemoteItems(t, file1) r.CheckLocalItems(t, file2) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file2) r.CheckRemoteItems(t, file2) } // Sync after removing a file and adding a file --dry-run func TestSyncAfterRemovingAFileAndAddingAFileDryRun(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) file1 := r.WriteFile("potato2", "------------------------------------------------------------", t1) file2 := r.WriteObject(ctx, "potato", "SMALLER BUT SAME DATE", t2) file3 := r.WriteBoth(ctx, "empty space", "-", t2) ci.DryRun = true accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) ci.DryRun = false require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file3, file1) r.CheckRemoteItems(t, file3, file2) } // Sync after removing a file and adding a file func testSyncAfterRemovingAFileAndAddingAFile(ctx context.Context, t *testing.T) { r := fstest.NewRun(t) file1 := r.WriteFile("potato2", "------------------------------------------------------------", t1) file2 := r.WriteObject(ctx, "potato", "SMALLER BUT SAME DATE", t2) file3 := r.WriteBoth(ctx, "empty space", "-", t2) r.CheckRemoteItems(t, file2, file3) r.CheckLocalItems(t, file1, file3) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1, file3) r.CheckRemoteItems(t, file1, file3) } func TestSyncAfterRemovingAFileAndAddingAFile(t *testing.T) { testSyncAfterRemovingAFileAndAddingAFile(context.Background(), t) } // Sync after removing a file and adding a file func testSyncAfterRemovingAFileAndAddingAFileSubDir(ctx context.Context, t *testing.T) { r := fstest.NewRun(t) file1 := r.WriteFile("a/potato2", "------------------------------------------------------------", t1) file2 := r.WriteObject(ctx, "b/potato", "SMALLER BUT SAME DATE", t2) file3 := r.WriteBoth(ctx, "c/non empty space", "AhHa!", t2) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "d")) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "d/e")) r.CheckLocalListing( t, []fstest.Item{ file1, file3, }, []string{ "a", "c", }, ) r.CheckRemoteListing( t, []fstest.Item{ file2, file3, }, []string{ "b", "c", "d", "d/e", }, ) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalListing( t, []fstest.Item{ file1, file3, }, []string{ "a", "c", }, ) r.CheckRemoteListing( t, []fstest.Item{ file1, file3, }, []string{ "a", "c", }, ) } func TestSyncAfterRemovingAFileAndAddingAFileSubDir(t *testing.T) { testSyncAfterRemovingAFileAndAddingAFileSubDir(context.Background(), t) } // Sync after removing a file and adding a file with IO Errors func TestSyncAfterRemovingAFileAndAddingAFileSubDirWithErrors(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteFile("a/potato2", "------------------------------------------------------------", t1) file2 := r.WriteObject(ctx, "b/potato", "SMALLER BUT SAME DATE", t2) file3 := r.WriteBoth(ctx, "c/non empty space", "AhHa!", t2) require.NoError(t, operations.Mkdir(ctx, r.Fremote, "d")) r.CheckLocalListing( t, []fstest.Item{ file1, file3, }, []string{ "a", "c", }, ) r.CheckRemoteListing( t, []fstest.Item{ file2, file3, }, []string{ "b", "c", "d", }, ) ctx = predictDstFromLogger(ctx) accounting.GlobalStats().ResetCounters() _ = fs.CountError(ctx, errors.New("boom")) err := Sync(ctx, r.Fremote, r.Flocal, false) assert.Equal(t, fs.ErrorNotDeleting, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalListing( t, []fstest.Item{ file1, file3, }, []string{ "a", "c", }, ) r.CheckRemoteListing( t, []fstest.Item{ file1, file2, file3, }, []string{ "a", "b", "c", "d", }, ) } // Sync test delete after func TestSyncDeleteAfter(t *testing.T) { ctx := context.Background() ci := fs.GetConfig(ctx) // This is the default so we've checked this already // check it is the default require.Equal(t, ci.DeleteMode, fs.DeleteModeAfter, "Didn't default to --delete-after") } // Sync test delete during func TestSyncDeleteDuring(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) ci.DeleteMode = fs.DeleteModeDuring testSyncAfterRemovingAFileAndAddingAFile(ctx, t) } // Sync test delete before func TestSyncDeleteBefore(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) ci.DeleteMode = fs.DeleteModeBefore testSyncAfterRemovingAFileAndAddingAFile(ctx, t) } // Copy test delete before - shouldn't delete anything func TestCopyDeleteBefore(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.DeleteMode = fs.DeleteModeBefore file1 := r.WriteObject(ctx, "potato", "hopefully not deleted", t1) file2 := r.WriteFile("potato2", "hopefully copied in", t1) r.CheckRemoteItems(t, file1) r.CheckLocalItems(t, file2) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := CopyDir(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteItems(t, file1, file2) r.CheckLocalItems(t, file2) } // Test with exclude func TestSyncWithExclude(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteBoth(ctx, "potato2", "------------------------------------------------------------", t1) file2 := r.WriteBoth(ctx, "empty space", "-", t2) file3 := r.WriteFile("enormous", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", t1) // 100 bytes r.CheckRemoteItems(t, file1, file2) r.CheckLocalItems(t, file1, file2, file3) fi, err := filter.NewFilter(nil) require.NoError(t, err) fi.Opt.MaxSize = 40 ctx = filter.ReplaceConfig(ctx, fi) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteItems(t, file2, file1) // Now sync the other way round and check enormous doesn't get // deleted as it is excluded from the sync accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Flocal, r.Fremote, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file2, file1, file3) } // Test with exclude and delete excluded func TestSyncWithExcludeAndDeleteExcluded(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteBoth(ctx, "potato2", "------------------------------------------------------------", t1) // 60 bytes file2 := r.WriteBoth(ctx, "empty space", "-", t2) file3 := r.WriteBoth(ctx, "enormous", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", t1) // 100 bytes r.CheckRemoteItems(t, file1, file2, file3) r.CheckLocalItems(t, file1, file2, file3) fi, err := filter.NewFilter(nil) require.NoError(t, err) fi.Opt.MaxSize = 40 fi.Opt.DeleteExcluded = true ctx = filter.ReplaceConfig(ctx, fi) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteItems(t, file2) // Check sync the other way round to make sure enormous gets // deleted even though it is excluded accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Flocal, r.Fremote, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file2) } // Test with UpdateOlder set func TestSyncWithUpdateOlder(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) if fs.GetModifyWindow(ctx, r.Fremote) == fs.ModTimeNotSupported { t.Skip("Can't run this test on fs which doesn't support mod time") } t2plus := t2.Add(time.Second / 2) t2minus := t2.Add(time.Second / 2) oneF := r.WriteFile("one", "one", t1) twoF := r.WriteFile("two", "two", t3) threeF := r.WriteFile("three", "three", t2) fourF := r.WriteFile("four", "four", t2) fiveF := r.WriteFile("five", "five", t2) r.CheckLocalItems(t, oneF, twoF, threeF, fourF, fiveF) oneO := r.WriteObject(ctx, "one", "ONE", t2) twoO := r.WriteObject(ctx, "two", "TWO", t2) threeO := r.WriteObject(ctx, "three", "THREE", t2plus) fourO := r.WriteObject(ctx, "four", "FOURFOUR", t2minus) r.CheckRemoteItems(t, oneO, twoO, threeO, fourO) ci.UpdateOlder = true ci.ModifyWindow = fs.Duration(fs.ModTimeNotSupported) ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) r.CheckRemoteItems(t, oneO, twoF, threeO, fourF, fiveF) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // no modtime if r.Fremote.Hashes().Count() == 0 { t.Logf("Skip test with --checksum as no hashes supported") return } // now enable checksum ci.CheckSum = true err = Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) r.CheckRemoteItems(t, oneO, twoF, threeF, fourF, fiveF) } // Test with a max transfer duration func testSyncWithMaxDuration(t *testing.T, cutoffMode fs.CutoffMode) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) if *fstest.RemoteName != "" { t.Skip("Skipping test on non local remote") } r := fstest.NewRun(t) maxDuration := fs.Duration(250 * time.Millisecond) ci.MaxDuration = maxDuration ci.CutoffMode = cutoffMode ci.CheckFirst = true ci.OrderBy = "size" ci.Transfers = 1 ci.Checkers = 1 bytesPerSecond := 10 * 1024 accounting.TokenBucket.SetBwLimit(fs.BwPair{Tx: fs.SizeSuffix(bytesPerSecond), Rx: fs.SizeSuffix(bytesPerSecond)}) defer accounting.TokenBucket.SetBwLimit(fs.BwPair{Tx: -1, Rx: -1}) // write one small file which we expect to transfer and one big one which we don't file1 := r.WriteFile("file1", string(make([]byte, 16)), t1) file2 := r.WriteFile("file2", string(make([]byte, 50*1024)), t1) r.CheckLocalItems(t, file1, file2) r.CheckRemoteItems(t) if runtime.GOOS == "darwin" { r.Flocal.Features().Disable("Copy") // macOS cloning is too fast for this test! if r.Fremote.Features().IsLocal { r.Fremote.Features().Disable("Copy") // macOS cloning is too fast for this test! } } accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) // not currently supported (but tests do pass for CutoffModeSoft) startTime := time.Now() err := Sync(ctx, r.Fremote, r.Flocal, false) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.True(t, errors.Is(err, ErrorMaxDurationReached)) if cutoffMode == fs.CutoffModeHard { r.CheckRemoteItems(t, file1) assert.Equal(t, int64(1), accounting.GlobalStats().GetTransfers()) } else { r.CheckRemoteItems(t, file1, file2) assert.Equal(t, int64(2), accounting.GlobalStats().GetTransfers()) } elapsed := time.Since(startTime) const maxTransferTime = 20 * time.Second what := fmt.Sprintf("expecting elapsed time %v between %v and %v", elapsed, maxDuration, maxTransferTime) assert.True(t, elapsed >= time.Duration(maxDuration), what) assert.True(t, elapsed < maxTransferTime, what) } func TestSyncWithMaxDuration(t *testing.T) { t.Run("Hard", func(t *testing.T) { testSyncWithMaxDuration(t, fs.CutoffModeHard) }) t.Run("Soft", func(t *testing.T) { testSyncWithMaxDuration(t, fs.CutoffModeSoft) }) } // Test with TrackRenames set func TestSyncWithTrackRenames(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.TrackRenames = true defer func() { ci.TrackRenames = false }() haveHash := r.Fremote.Hashes().Overlap(r.Flocal.Hashes()).GetOne() != hash.None canTrackRenames := haveHash && operations.CanServerSideMove(r.Fremote) t.Logf("Can track renames: %v", canTrackRenames) f1 := r.WriteFile("potato", "Potato Content", t1) f2 := r.WriteFile("yam", "Yam Content", t2) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) require.NoError(t, Sync(ctx, r.Fremote, r.Flocal, false)) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteItems(t, f1, f2) r.CheckLocalItems(t, f1, f2) // Now rename locally. f2 = r.RenameFile(f2, "yaml") accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) require.NoError(t, Sync(ctx, r.Fremote, r.Flocal, false)) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteItems(t, f1, f2) // Check we renamed something if we should have if canTrackRenames { renames := accounting.GlobalStats().Renames(0) assert.Equal(t, canTrackRenames, renames != 0, fmt.Sprintf("canTrackRenames=%v, renames=%d", canTrackRenames, renames)) } } func TestParseRenamesStrategyModtime(t *testing.T) { for _, test := range []struct { in string want trackRenamesStrategy wantErr bool }{ {"", 0, false}, {"modtime", trackRenamesStrategyModtime, false}, {"hash", trackRenamesStrategyHash, false}, {"size", 0, false}, {"modtime,hash", trackRenamesStrategyModtime | trackRenamesStrategyHash, false}, {"hash,modtime,size", trackRenamesStrategyModtime | trackRenamesStrategyHash, false}, {"size,boom", 0, true}, } { got, err := parseTrackRenamesStrategy(test.in) assert.Equal(t, test.want, got, test.in) assert.Equal(t, test.wantErr, err != nil, test.in) } } func TestRenamesStrategyModtime(t *testing.T) { both := trackRenamesStrategyHash | trackRenamesStrategyModtime hash := trackRenamesStrategyHash modTime := trackRenamesStrategyModtime assert.True(t, both.hash()) assert.True(t, both.modTime()) assert.True(t, hash.hash()) assert.False(t, hash.modTime()) assert.False(t, modTime.hash()) assert.True(t, modTime.modTime()) } func TestSyncWithTrackRenamesStrategyModtime(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.TrackRenames = true ci.TrackRenamesStrategy = "modtime" canTrackRenames := operations.CanServerSideMove(r.Fremote) && r.Fremote.Precision() != fs.ModTimeNotSupported t.Logf("Can track renames: %v", canTrackRenames) f1 := r.WriteFile("potato", "Potato Content", t1) f2 := r.WriteFile("yam", "Yam Content", t2) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) require.NoError(t, Sync(ctx, r.Fremote, r.Flocal, false)) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteItems(t, f1, f2) r.CheckLocalItems(t, f1, f2) // Now rename locally. f2 = r.RenameFile(f2, "yaml") accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) require.NoError(t, Sync(ctx, r.Fremote, r.Flocal, false)) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteItems(t, f1, f2) // Check we renamed something if we should have if canTrackRenames { renames := accounting.GlobalStats().Renames(0) assert.Equal(t, canTrackRenames, renames != 0, fmt.Sprintf("canTrackRenames=%v, renames=%d", canTrackRenames, renames)) } } func TestSyncWithTrackRenamesStrategyLeaf(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.TrackRenames = true ci.TrackRenamesStrategy = "leaf" canTrackRenames := operations.CanServerSideMove(r.Fremote) && r.Fremote.Precision() != fs.ModTimeNotSupported t.Logf("Can track renames: %v", canTrackRenames) f1 := r.WriteFile("potato", "Potato Content", t1) f2 := r.WriteFile("sub/yam", "Yam Content", t2) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) require.NoError(t, Sync(ctx, r.Fremote, r.Flocal, false)) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteItems(t, f1, f2) r.CheckLocalItems(t, f1, f2) // Now rename locally. f2 = r.RenameFile(f2, "yam") accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) require.NoError(t, Sync(ctx, r.Fremote, r.Flocal, false)) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckRemoteItems(t, f1, f2) // Check we renamed something if we should have if canTrackRenames { renames := accounting.GlobalStats().Renames(0) assert.Equal(t, canTrackRenames, renames != 0, fmt.Sprintf("canTrackRenames=%v, renames=%d", canTrackRenames, renames)) } } func toyFileTransfers(r *fstest.Run) int64 { remote := r.Fremote.Name() transfers := 1 if strings.HasPrefix(remote, "TestChunker") && strings.HasSuffix(remote, "S3") { transfers++ // Extra Copy because S3 emulates Move as Copy+Delete. } return int64(transfers) } // Test a server-side move if possible, or the backup path if not func testServerSideMove(ctx context.Context, t *testing.T, r *fstest.Run, withFilter, testDeleteEmptyDirs bool) { FremoteMove, _, finaliseMove, err := fstest.RandomRemote() require.NoError(t, err) defer finaliseMove() file1 := r.WriteBoth(ctx, "potato2", "------------------------------------------------------------", t1) file2 := r.WriteBoth(ctx, "empty space", "-", t2) file3u := r.WriteBoth(ctx, "potato3", "------------------------------------------------------------ UPDATED", t2) if testDeleteEmptyDirs { err := operations.Mkdir(ctx, r.Fremote, "tomatoDir") require.NoError(t, err) } r.CheckRemoteItems(t, file2, file1, file3u) t.Logf("Server side move (if possible) %v -> %v", r.Fremote, FremoteMove) // Write just one file in the new remote r.WriteObjectTo(ctx, FremoteMove, "empty space", "-", t2, false) file3 := r.WriteObjectTo(ctx, FremoteMove, "potato3", "------------------------------------------------------------", t1, false) fstest.CheckItems(t, FremoteMove, file2, file3) // Do server-side move accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) // not currently supported -- doesn't list all contents of dir. err = MoveDir(ctx, FremoteMove, r.Fremote, testDeleteEmptyDirs, false) require.NoError(t, err) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) if withFilter { r.CheckRemoteItems(t, file2) } else { r.CheckRemoteItems(t) } if testDeleteEmptyDirs { r.CheckRemoteListing(t, nil, []string{}) } fstest.CheckItems(t, FremoteMove, file2, file1, file3u) // Create a new empty remote for stuff to be moved into FremoteMove2, _, finaliseMove2, err := fstest.RandomRemote() require.NoError(t, err) defer finaliseMove2() if testDeleteEmptyDirs { err := operations.Mkdir(ctx, FremoteMove, "tomatoDir") require.NoError(t, err) } // Move it back to a new empty remote, dst does not exist this time accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err = MoveDir(ctx, FremoteMove2, FremoteMove, testDeleteEmptyDirs, false) require.NoError(t, err) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) if withFilter { fstest.CheckItems(t, FremoteMove2, file1, file3u) fstest.CheckItems(t, FremoteMove, file2) } else { fstest.CheckItems(t, FremoteMove2, file2, file1, file3u) fstest.CheckItems(t, FremoteMove) } if testDeleteEmptyDirs { fstest.CheckListingWithPrecision(t, FremoteMove, nil, []string{}, fs.GetModifyWindow(ctx, r.Fremote)) } } // Test MoveDir on Local func TestServerSideMoveLocal(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) f1 := r.WriteFile("dir1/file1.txt", "hello", t1) f2 := r.WriteFile("dir2/file2.txt", "hello again", t2) r.CheckLocalItems(t, f1, f2) dir1, err := fs.NewFs(ctx, r.Flocal.Root()+"/dir1") require.NoError(t, err) dir2, err := fs.NewFs(ctx, r.Flocal.Root()+"/dir2") require.NoError(t, err) err = MoveDir(ctx, dir2, dir1, false, false) require.NoError(t, err) } // Test move func TestMoveWithDeleteEmptySrcDirs(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteFile("sub dir/hello world", "hello world", t1) file2 := r.WriteFile("nested/sub dir/file", "nested", t1) r.Mkdir(ctx, r.Fremote) // run move with --delete-empty-src-dirs ctx = predictDstFromLogger(ctx) err := MoveDir(ctx, r.Fremote, r.Flocal, true, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalListing( t, nil, []string{}, ) r.CheckRemoteItems(t, file1, file2) } func TestMoveWithoutDeleteEmptySrcDirs(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) file1 := r.WriteFile("sub dir/hello world", "hello world", t1) file2 := r.WriteFile("nested/sub dir/file", "nested", t1) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err := MoveDir(ctx, r.Fremote, r.Flocal, false, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalListing( t, nil, []string{ "sub dir", "nested", "nested/sub dir", }, ) r.CheckRemoteItems(t, file1, file2) } func TestMoveWithIgnoreExisting(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) file1 := r.WriteFile("existing", "potato", t1) file2 := r.WriteFile("existing-b", "tomato", t1) ci.IgnoreExisting = true accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err := MoveDir(ctx, r.Fremote, r.Flocal, false, false) require.NoError(t, err) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalListing( t, []fstest.Item{}, []string{}, ) r.CheckRemoteListing( t, []fstest.Item{ file1, file2, }, []string{}, ) // Recreate first file with modified content file1b := r.WriteFile("existing", "newpotatoes", t2) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err = MoveDir(ctx, r.Fremote, r.Flocal, false, false) require.NoError(t, err) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // Source items should still exist in modified state r.CheckLocalListing( t, []fstest.Item{ file1b, }, []string{}, ) // Dest items should not have changed r.CheckRemoteListing( t, []fstest.Item{ file1, file2, }, []string{}, ) } // Test a server-side move if possible, or the backup path if not func TestServerSideMove(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) testServerSideMove(ctx, t, r, false, false) } // Test a server-side move if possible, or the backup path if not func TestServerSideMoveWithFilter(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) fi, err := filter.NewFilter(nil) require.NoError(t, err) fi.Opt.MinSize = 40 ctx = filter.ReplaceConfig(ctx, fi) testServerSideMove(ctx, t, r, true, false) } // Test a server-side move if possible func TestServerSideMoveDeleteEmptySourceDirs(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) testServerSideMove(ctx, t, r, false, true) } // Test a server-side move with overlap func TestServerSideMoveOverlap(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) if r.Fremote.Features().DirMove != nil { t.Skip("Skipping test as remote supports DirMove") } subRemoteName := r.FremoteName + "/rclone-move-test" FremoteMove, err := fs.NewFs(ctx, subRemoteName) require.NoError(t, err) file1 := r.WriteObject(ctx, "potato2", "------------------------------------------------------------", t1) r.CheckRemoteItems(t, file1) // Subdir move with no filters should return ErrorCantMoveOverlapping // ctx = predictDstFromLogger(ctx) err = MoveDir(ctx, FremoteMove, r.Fremote, false, false) assert.EqualError(t, err, fs.ErrorOverlapping.Error()) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // Now try with a filter which should also fail with ErrorCantMoveOverlapping fi, err := filter.NewFilter(nil) require.NoError(t, err) fi.Opt.MinSize = 40 ctx = filter.ReplaceConfig(ctx, fi) // ctx = predictDstFromLogger(ctx) err = MoveDir(ctx, FremoteMove, r.Fremote, false, false) assert.EqualError(t, err, fs.ErrorOverlapping.Error()) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) } // Test a sync with overlap func TestSyncOverlap(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) subRemoteName := r.FremoteName + "/rclone-sync-test" FremoteSync, err := fs.NewFs(ctx, subRemoteName) require.NoError(t, err) checkErr := func(err error) { require.Error(t, err) assert.True(t, fserrors.IsFatalError(err)) assert.Equal(t, fs.ErrorOverlapping.Error(), err.Error()) } ctx = predictDstFromLogger(ctx) checkErr(Sync(ctx, FremoteSync, r.Fremote, false)) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) ctx = predictDstFromLogger(ctx) checkErr(Sync(ctx, r.Fremote, FremoteSync, false)) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) ctx = predictDstFromLogger(ctx) checkErr(Sync(ctx, r.Fremote, r.Fremote, false)) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) ctx = predictDstFromLogger(ctx) checkErr(Sync(ctx, FremoteSync, FremoteSync, false)) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) } // Test a sync with filtered overlap func TestSyncOverlapWithFilter(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) fi, err := filter.NewFilter(nil) require.NoError(t, err) require.NoError(t, fi.Add(false, "/rclone-sync-test/")) require.NoError(t, fi.Add(false, "*/layer2/")) fi.Opt.ExcludeFile = []string{".ignore"} filterCtx := filter.ReplaceConfig(ctx, fi) subRemoteName := r.FremoteName + "/rclone-sync-test" FremoteSync, err := fs.NewFs(ctx, subRemoteName) require.NoError(t, FremoteSync.Mkdir(ctx, "")) require.NoError(t, err) subRemoteName2 := r.FremoteName + "/rclone-sync-test-include/layer2" FremoteSync2, err := fs.NewFs(ctx, subRemoteName2) require.NoError(t, FremoteSync2.Mkdir(ctx, "")) require.NoError(t, err) subRemoteName3 := r.FremoteName + "/rclone-sync-test-ignore-file" FremoteSync3, err := fs.NewFs(ctx, subRemoteName3) require.NoError(t, FremoteSync3.Mkdir(ctx, "")) require.NoError(t, err) r.WriteObject(context.Background(), "rclone-sync-test-ignore-file/.ignore", "-", t1) checkErr := func(err error) { require.Error(t, err) assert.True(t, fserrors.IsFatalError(err)) assert.Equal(t, fs.ErrorOverlapping.Error(), err.Error()) accounting.GlobalStats().ResetCounters() } checkNoErr := func(err error) { require.NoError(t, err) } accounting.GlobalStats().ResetCounters() filterCtx = predictDstFromLogger(filterCtx) checkNoErr(Sync(filterCtx, FremoteSync, r.Fremote, false)) checkErr(Sync(ctx, FremoteSync, r.Fremote, false)) checkNoErr(Sync(filterCtx, r.Fremote, FremoteSync, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkErr(Sync(ctx, r.Fremote, FremoteSync, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkErr(Sync(filterCtx, r.Fremote, r.Fremote, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkErr(Sync(ctx, r.Fremote, r.Fremote, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkErr(Sync(filterCtx, FremoteSync, FremoteSync, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkErr(Sync(ctx, FremoteSync, FremoteSync, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkNoErr(Sync(filterCtx, FremoteSync2, r.Fremote, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkErr(Sync(ctx, FremoteSync2, r.Fremote, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkNoErr(Sync(filterCtx, r.Fremote, FremoteSync2, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkErr(Sync(ctx, r.Fremote, FremoteSync2, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkErr(Sync(filterCtx, FremoteSync2, FremoteSync2, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkErr(Sync(ctx, FremoteSync2, FremoteSync2, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkNoErr(Sync(filterCtx, FremoteSync3, r.Fremote, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkErr(Sync(ctx, FremoteSync3, r.Fremote, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) // Destination is excluded so this test makes no sense // checkNoErr(Sync(filterCtx, r.Fremote, FremoteSync3, false)) checkErr(Sync(ctx, r.Fremote, FremoteSync3, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkErr(Sync(filterCtx, FremoteSync3, FremoteSync3, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) filterCtx = predictDstFromLogger(filterCtx) checkErr(Sync(ctx, FremoteSync3, FremoteSync3, false)) testLoggerVsLsf(filterCtx, r.Fremote, r.Flocal, operations.GetLoggerOpt(filterCtx).JSON, t) } // Test with CompareDest set func TestSyncCompareDest(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.CompareDest = []string{r.FremoteName + "/CompareDest"} fdst, err := fs.NewFs(ctx, r.FremoteName+"/dst") require.NoError(t, err) // check empty dest, empty compare file1 := r.WriteFile("one", "one", t1) r.CheckLocalItems(t, file1) accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) // not currently supported due to duplicate equal() checks err = Sync(ctx, fdst, r.Flocal, false) // testLoggerVsLsf(ctx, fdst, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) file1dst := file1 file1dst.Path = "dst/one" r.CheckRemoteItems(t, file1dst) // check old dest, empty compare file1b := r.WriteFile("one", "onet2", t2) r.CheckRemoteItems(t, file1dst) r.CheckLocalItems(t, file1b) accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err = Sync(ctx, fdst, r.Flocal, false) // testLoggerVsLsf(ctx, fdst, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) file1bdst := file1b file1bdst.Path = "dst/one" r.CheckRemoteItems(t, file1bdst) // check old dest, new compare file3 := r.WriteObject(ctx, "dst/one", "one", t1) file2 := r.WriteObject(ctx, "CompareDest/one", "onet2", t2) file1c := r.WriteFile("one", "onet2", t2) r.CheckRemoteItems(t, file2, file3) r.CheckLocalItems(t, file1c) accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err = Sync(ctx, fdst, r.Flocal, false) // testLoggerVsLsf(ctx, fdst, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckRemoteItems(t, file2, file3) // check empty dest, new compare file4 := r.WriteObject(ctx, "CompareDest/two", "two", t2) file5 := r.WriteFile("two", "two", t2) r.CheckRemoteItems(t, file2, file3, file4) r.CheckLocalItems(t, file1c, file5) accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err = Sync(ctx, fdst, r.Flocal, false) // testLoggerVsLsf(ctx, fdst, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckRemoteItems(t, file2, file3, file4) // check new dest, new compare accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err = Sync(ctx, fdst, r.Flocal, false) // testLoggerVsLsf(ctx, fdst, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckRemoteItems(t, file2, file3, file4) // Work out if we actually have hashes for uploaded files haveHash := false if ht := fdst.Hashes().GetOne(); ht != hash.None { file2obj, err := fdst.NewObject(ctx, "one") if err == nil { file2objHash, err := file2obj.Hash(ctx, ht) if err == nil { haveHash = file2objHash != "" } } } // check new dest, new compare, src timestamp differs // // we only check this if we the file we uploaded previously // actually has a hash otherwise the differing timestamp is // always copied. if haveHash { file5b := r.WriteFile("two", "two", t3) r.CheckLocalItems(t, file1c, file5b) accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err = Sync(ctx, fdst, r.Flocal, false) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckRemoteItems(t, file2, file3, file4) } else { t.Log("No hash on uploaded file so skipping compare timestamp test") } // check empty dest, old compare file5c := r.WriteFile("two", "twot3", t3) r.CheckRemoteItems(t, file2, file3, file4) r.CheckLocalItems(t, file1c, file5c) accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err = Sync(ctx, fdst, r.Flocal, false) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) file5cdst := file5c file5cdst.Path = "dst/two" r.CheckRemoteItems(t, file2, file3, file4, file5cdst) } // Test with multiple CompareDest func TestSyncMultipleCompareDest(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) precision := fs.GetModifyWindow(ctx, r.Fremote, r.Flocal) ci.CompareDest = []string{r.FremoteName + "/pre-dest1", r.FremoteName + "/pre-dest2"} // check empty dest, new compare fsrc1 := r.WriteFile("1", "1", t1) fsrc2 := r.WriteFile("2", "2", t1) fsrc3 := r.WriteFile("3", "3", t1) r.CheckLocalItems(t, fsrc1, fsrc2, fsrc3) fdest1 := r.WriteObject(ctx, "pre-dest1/1", "1", t1) fdest2 := r.WriteObject(ctx, "pre-dest2/2", "2", t1) r.CheckRemoteItems(t, fdest1, fdest2) accounting.GlobalStats().ResetCounters() fdst, err := fs.NewFs(ctx, r.FremoteName+"/dest") require.NoError(t, err) // ctx = predictDstFromLogger(ctx) require.NoError(t, Sync(ctx, fdst, r.Flocal, false)) // testLoggerVsLsf(ctx, fdst, operations.GetLoggerOpt(ctx).JSON, t) fdest3 := fsrc3 fdest3.Path = "dest/3" fstest.CheckItemsWithPrecision(t, fdst, precision, fsrc3) r.CheckRemoteItems(t, fdest1, fdest2, fdest3) } // Test with CopyDest set func TestSyncCopyDest(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) if r.Fremote.Features().Copy == nil { t.Skip("Skipping test as remote does not support server-side copy") } ci.CopyDest = []string{r.FremoteName + "/CopyDest"} fdst, err := fs.NewFs(ctx, r.FremoteName+"/dst") require.NoError(t, err) // check empty dest, empty copy file1 := r.WriteFile("one", "one", t1) r.CheckLocalItems(t, file1) accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err = Sync(ctx, fdst, r.Flocal, false) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // not currently supported require.NoError(t, err) file1dst := file1 file1dst.Path = "dst/one" r.CheckRemoteItems(t, file1dst) // check old dest, empty copy file1b := r.WriteFile("one", "onet2", t2) r.CheckRemoteItems(t, file1dst) r.CheckLocalItems(t, file1b) accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err = Sync(ctx, fdst, r.Flocal, false) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) file1bdst := file1b file1bdst.Path = "dst/one" r.CheckRemoteItems(t, file1bdst) // check old dest, new copy, backup-dir ci.BackupDir = r.FremoteName + "/BackupDir" file3 := r.WriteObject(ctx, "dst/one", "one", t1) file2 := r.WriteObject(ctx, "CopyDest/one", "onet2", t2) file1c := r.WriteFile("one", "onet2", t2) r.CheckRemoteItems(t, file2, file3) r.CheckLocalItems(t, file1c) accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err = Sync(ctx, fdst, r.Flocal, false) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) file2dst := file2 file2dst.Path = "dst/one" file3.Path = "BackupDir/one" r.CheckRemoteItems(t, file2, file2dst, file3) ci.BackupDir = "" // check empty dest, new copy file4 := r.WriteObject(ctx, "CopyDest/two", "two", t2) file5 := r.WriteFile("two", "two", t2) r.CheckRemoteItems(t, file2, file2dst, file3, file4) r.CheckLocalItems(t, file1c, file5) accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) err = Sync(ctx, fdst, r.Flocal, false) require.NoError(t, err) file4dst := file4 file4dst.Path = "dst/two" r.CheckRemoteItems(t, file2, file2dst, file3, file4, file4dst) // check new dest, new copy accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err = Sync(ctx, fdst, r.Flocal, false) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckRemoteItems(t, file2, file2dst, file3, file4, file4dst) // check empty dest, old copy file6 := r.WriteObject(ctx, "CopyDest/three", "three", t2) file7 := r.WriteFile("three", "threet3", t3) r.CheckRemoteItems(t, file2, file2dst, file3, file4, file4dst, file6) r.CheckLocalItems(t, file1c, file5, file7) accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err = Sync(ctx, fdst, r.Flocal, false) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) file7dst := file7 file7dst.Path = "dst/three" r.CheckRemoteItems(t, file2, file2dst, file3, file4, file4dst, file6, file7dst) } // Test with BackupDir set func testSyncBackupDir(t *testing.T, backupDir string, suffix string, suffixKeepExtension bool) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) if !operations.CanServerSideMove(r.Fremote) { t.Skip("Skipping test as remote does not support server-side move") } r.Mkdir(ctx, r.Fremote) if backupDir != "" { ci.BackupDir = r.FremoteName + "/" + backupDir backupDir += "/" } else { ci.BackupDir = "" backupDir = "dst/" // Exclude the suffix from the sync otherwise the sync // deletes the old backup files flt, err := filter.NewFilter(nil) require.NoError(t, err) require.NoError(t, flt.AddRule("- *"+suffix)) // Change the active filter ctx = filter.ReplaceConfig(ctx, flt) } ci.Suffix = suffix ci.SuffixKeepExtension = suffixKeepExtension // Make the setup so we have one, two, three in the dest // and one (different), two (same) in the source file1 := r.WriteObject(ctx, "dst/one", "one", t1) file2 := r.WriteObject(ctx, "dst/two", "two", t1) file3 := r.WriteObject(ctx, "dst/three.txt", "three", t1) file2a := r.WriteFile("two", "two", t1) file1a := r.WriteFile("one", "oneA", t2) r.CheckRemoteItems(t, file1, file2, file3) r.CheckLocalItems(t, file1a, file2a) fdst, err := fs.NewFs(ctx, r.FremoteName+"/dst") require.NoError(t, err) accounting.GlobalStats().ResetCounters() err = Sync(ctx, fdst, r.Flocal, false) require.NoError(t, err) // one should be moved to the backup dir and the new one installed file1.Path = backupDir + "one" + suffix file1a.Path = "dst/one" // two should be unchanged // three should be moved to the backup dir if suffixKeepExtension { file3.Path = backupDir + "three" + suffix + ".txt" } else { file3.Path = backupDir + "three.txt" + suffix } r.CheckRemoteItems(t, file1, file2, file3, file1a) // Now check what happens if we do it again // Restore a different three and update one in the source file3a := r.WriteObject(ctx, "dst/three.txt", "threeA", t2) file1b := r.WriteFile("one", "oneBB", t3) r.CheckRemoteItems(t, file1, file2, file3, file1a, file3a) // This should delete three and overwrite one again, checking // the files got overwritten correctly in backup-dir accounting.GlobalStats().ResetCounters() err = Sync(ctx, fdst, r.Flocal, false) require.NoError(t, err) // one should be moved to the backup dir and the new one installed file1a.Path = backupDir + "one" + suffix file1b.Path = "dst/one" // two should be unchanged // three should be moved to the backup dir if suffixKeepExtension { file3a.Path = backupDir + "three" + suffix + ".txt" } else { file3a.Path = backupDir + "three.txt" + suffix } r.CheckRemoteItems(t, file1b, file2, file3a, file1a) } func TestSyncBackupDir(t *testing.T) { testSyncBackupDir(t, "backup", "", false) } func TestSyncBackupDirWithSuffix(t *testing.T) { testSyncBackupDir(t, "backup", ".bak", false) } func TestSyncBackupDirWithSuffixKeepExtension(t *testing.T) { testSyncBackupDir(t, "backup", "-2019-01-01", true) } func TestSyncBackupDirSuffixOnly(t *testing.T) { testSyncBackupDir(t, "", ".bak", false) } // Test with Suffix set func testSyncSuffix(t *testing.T, suffix string, suffixKeepExtension bool) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) if !operations.CanServerSideMove(r.Fremote) { t.Skip("Skipping test as remote does not support server-side move") } r.Mkdir(ctx, r.Fremote) ci.Suffix = suffix ci.SuffixKeepExtension = suffixKeepExtension // Make the setup so we have one, two, three in the dest // and one (different), two (same) in the source file1 := r.WriteObject(ctx, "dst/one", "one", t1) file2 := r.WriteObject(ctx, "dst/two", "two", t1) file3 := r.WriteObject(ctx, "dst/three.txt", "three", t1) file2a := r.WriteFile("two", "two", t1) file1a := r.WriteFile("one", "oneA", t2) file3a := r.WriteFile("three.txt", "threeA", t1) r.CheckRemoteItems(t, file1, file2, file3) r.CheckLocalItems(t, file1a, file2a, file3a) fdst, err := fs.NewFs(ctx, r.FremoteName+"/dst") require.NoError(t, err) accounting.GlobalStats().ResetCounters() err = operations.CopyFile(ctx, fdst, r.Flocal, "one", "one") require.NoError(t, err) err = operations.CopyFile(ctx, fdst, r.Flocal, "two", "two") require.NoError(t, err) err = operations.CopyFile(ctx, fdst, r.Flocal, "three.txt", "three.txt") require.NoError(t, err) // one should be moved to the backup dir and the new one installed file1.Path = "dst/one" + suffix file1a.Path = "dst/one" // two should be unchanged // three should be moved to the backup dir if suffixKeepExtension { file3.Path = "dst/three" + suffix + ".txt" } else { file3.Path = "dst/three.txt" + suffix } file3a.Path = "dst/three.txt" r.CheckRemoteItems(t, file1, file2, file3, file1a, file3a) // Now check what happens if we do it again // Restore a different three and update one in the source file3b := r.WriteFile("three.txt", "threeBDifferentSize", t3) file1b := r.WriteFile("one", "oneBB", t3) r.CheckRemoteItems(t, file1, file2, file3, file1a, file3a) // This should delete three and overwrite one again, checking // the files got overwritten correctly in backup-dir accounting.GlobalStats().ResetCounters() err = operations.CopyFile(ctx, fdst, r.Flocal, "one", "one") require.NoError(t, err) err = operations.CopyFile(ctx, fdst, r.Flocal, "two", "two") require.NoError(t, err) err = operations.CopyFile(ctx, fdst, r.Flocal, "three.txt", "three.txt") require.NoError(t, err) // one should be moved to the backup dir and the new one installed file1a.Path = "dst/one" + suffix file1b.Path = "dst/one" // two should be unchanged // three should be moved to the backup dir if suffixKeepExtension { file3a.Path = "dst/three" + suffix + ".txt" } else { file3a.Path = "dst/three.txt" + suffix } file3b.Path = "dst/three.txt" r.CheckRemoteItems(t, file1b, file3b, file2, file3a, file1a) } func TestSyncSuffix(t *testing.T) { testSyncSuffix(t, ".bak", false) } func TestSyncSuffixKeepExtension(t *testing.T) { testSyncSuffix(t, "-2019-01-01", true) } // Check we can sync two files with differing UTF-8 representations func TestSyncUTFNorm(t *testing.T) { ctx := context.Background() if runtime.GOOS == "darwin" { t.Skip("Can't test UTF normalization on OS X") } r := fstest.NewRun(t) // Two strings with different unicode normalization (from OS X) Encoding1 := "Testêé" Encoding2 := "Testêé" assert.NotEqual(t, Encoding1, Encoding2) assert.Equal(t, norm.NFC.String(Encoding1), norm.NFC.String(Encoding2)) file1 := r.WriteFile(Encoding1, "This is a test", t1) r.CheckLocalItems(t, file1) file2 := r.WriteObject(ctx, Encoding2, "This is a old test", t2) r.CheckRemoteItems(t, file2) accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // can't test this on macOS require.NoError(t, err) // We should have transferred exactly one file, but kept the // normalized state of the file. assert.Equal(t, toyFileTransfers(r), accounting.GlobalStats().GetTransfers()) r.CheckLocalItems(t, file1) file1.Path = file2.Path r.CheckRemoteItems(t, file1) } // Test --immutable func TestSyncImmutable(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) ci.Immutable = true // Create file on source file1 := r.WriteFile("existing", "potato", t1) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t) // Should succeed accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file1) // Modify file data and timestamp on source file2 := r.WriteFile("existing", "tomatoes", t2) r.CheckLocalItems(t, file2) r.CheckRemoteItems(t, file1) // Should fail with ErrorImmutableModified and not modify local or remote files accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, false) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) assert.EqualError(t, err, fs.ErrorImmutableModified.Error()) r.CheckLocalItems(t, file2) r.CheckRemoteItems(t, file1) } // Test --ignore-case-sync func TestSyncIgnoreCase(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) // Only test if filesystems are case sensitive if r.Fremote.Features().CaseInsensitive || r.Flocal.Features().CaseInsensitive { t.Skip("Skipping test as local or remote are case-insensitive") } ci.IgnoreCaseSync = true // Create files with different filename casing file1 := r.WriteFile("existing", "potato", t1) r.CheckLocalItems(t, file1) file2 := r.WriteObject(ctx, "EXISTING", "potato", t1) r.CheckRemoteItems(t, file2) // Should not copy files that are differently-cased but otherwise identical accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // can't test this on macOS require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, file2) } // Test --fix-case func TestFixCase(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) r := fstest.NewRun(t) // Only test if remote is case insensitive if !r.Fremote.Features().CaseInsensitive { t.Skip("Skipping test as local or remote are case-sensitive") } ci.FixCase = true // Create files with different filename casing file1a := r.WriteFile("existing", "potato", t1) file1b := r.WriteFile("existingbutdifferent", "donut", t1) file1c := r.WriteFile("subdira/subdirb/subdirc/hello", "donut", t1) file1d := r.WriteFile("subdira/subdirb/subdirc/subdird/filewithoutcasedifferences", "donut", t1) r.CheckLocalItems(t, file1a, file1b, file1c, file1d) file2a := r.WriteObject(ctx, "EXISTING", "potato", t1) file2b := r.WriteObject(ctx, "EXISTINGBUTDIFFERENT", "lemonade", t1) file2c := r.WriteObject(ctx, "SUBDIRA/subdirb/SUBDIRC/HELLO", "lemonade", t1) file2d := r.WriteObject(ctx, "SUBDIRA/subdirb/SUBDIRC/subdird/filewithoutcasedifferences", "lemonade", t1) r.CheckRemoteItems(t, file2a, file2b, file2c, file2d) // Should force rename of dest file that is differently-cased accounting.GlobalStats().ResetCounters() err := Sync(ctx, r.Fremote, r.Flocal, false) require.NoError(t, err) r.CheckLocalItems(t, file1a, file1b, file1c, file1d) r.CheckRemoteItems(t, file1a, file1b, file1c, file1d) } // Test that aborting on --max-transfer works func TestMaxTransfer(t *testing.T) { ctx := context.Background() ctx, ci := fs.AddConfig(ctx) ci.MaxTransfer = 3 * 1024 ci.Transfers = 1 ci.Checkers = 1 ci.CutoffMode = fs.CutoffModeHard test := func(t *testing.T, cutoff fs.CutoffMode) { r := fstest.NewRun(t) ci.CutoffMode = cutoff if r.Fremote.Name() != "local" { t.Skip("This test only runs on local") } // Create file on source file1 := r.WriteFile("file1", string(make([]byte, 5*1024)), t1) file2 := r.WriteFile("file2", string(make([]byte, 2*1024)), t1) file3 := r.WriteFile("file3", string(make([]byte, 3*1024)), t1) r.CheckLocalItems(t, file1, file2, file3) r.CheckRemoteItems(t) if runtime.GOOS == "darwin" { // disable server-side copies as they don't count towards transfer size stats r.Flocal.Features().Disable("Copy") if r.Fremote.Features().IsLocal { r.Fremote.Features().Disable("Copy") } } accounting.GlobalStats().ResetCounters() // ctx = predictDstFromLogger(ctx) // not currently supported err := Sync(ctx, r.Fremote, r.Flocal, false) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) expectedErr := fserrors.FsError(accounting.ErrorMaxTransferLimitReachedFatal) if cutoff != fs.CutoffModeHard { expectedErr = accounting.ErrorMaxTransferLimitReachedGraceful } fserrors.Count(expectedErr) assert.Equal(t, expectedErr, err) } t.Run("Hard", func(t *testing.T) { test(t, fs.CutoffModeHard) }) t.Run("Soft", func(t *testing.T) { test(t, fs.CutoffModeSoft) }) t.Run("Cautious", func(t *testing.T) { test(t, fs.CutoffModeCautious) }) } func testSyncConcurrent(t *testing.T, subtest string) { const ( NFILES = 20 NCHECKERS = 4 NTRANSFERS = 4 ) ctx, ci := fs.AddConfig(context.Background()) ci.Checkers = NCHECKERS ci.Transfers = NTRANSFERS r := fstest.NewRun(t) stats := accounting.GlobalStats() itemsBefore := []fstest.Item{} itemsAfter := []fstest.Item{} for i := range NFILES { nameBoth := fmt.Sprintf("both%d", i) nameOnly := fmt.Sprintf("only%d", i) switch subtest { case "delete": fileBoth := r.WriteBoth(ctx, nameBoth, "potato", t1) fileOnly := r.WriteObject(ctx, nameOnly, "potato", t1) itemsBefore = append(itemsBefore, fileBoth, fileOnly) itemsAfter = append(itemsAfter, fileBoth) case "truncate": fileBoth := r.WriteBoth(ctx, nameBoth, "potato", t1) fileFull := r.WriteObject(ctx, nameOnly, "potato", t1) fileEmpty := r.WriteFile(nameOnly, "", t1) itemsBefore = append(itemsBefore, fileBoth, fileFull) itemsAfter = append(itemsAfter, fileBoth, fileEmpty) } } r.CheckRemoteItems(t, itemsBefore...) stats.ResetErrors() ctx = predictDstFromLogger(ctx) err := Sync(ctx, r.Fremote, r.Flocal, false) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) if errors.Is(err, fs.ErrorCantUploadEmptyFiles) { t.Skipf("Skip test because remote cannot upload empty files") } assert.NoError(t, err, "Sync must not return a error") assert.False(t, stats.Errored(), "Low level errors must not have happened") r.CheckRemoteItems(t, itemsAfter...) } func TestSyncConcurrentDelete(t *testing.T) { testSyncConcurrent(t, "delete") } func TestSyncConcurrentTruncate(t *testing.T) { testSyncConcurrent(t, "truncate") } // Test that sync replaces dir modtimes in dst if they've changed func testSyncReplaceDirModTime(t *testing.T, copyEmptySrcDirs bool) { accounting.GlobalStats().ResetCounters() ctx, _ := fs.AddConfig(context.Background()) r := fstest.NewRun(t) file1 := r.WriteFile("file1", "file1", t2) file2 := r.WriteFile("test_dir1/file2", "file2", t2) file3 := r.WriteFile("test_dir2/sub_dir/file3", "file3", t2) r.CheckLocalItems(t, file1, file2, file3) _, err := operations.MkdirModTime(ctx, r.Flocal, "empty_dir", t2) require.NoError(t, err) // A directory that's empty on both src and dst _, err = operations.MkdirModTime(ctx, r.Flocal, "empty_on_remote", t2) require.NoError(t, err) _, err = operations.MkdirModTime(ctx, r.Fremote, "empty_on_remote", t2) require.NoError(t, err) // set logging // (this checks log output as DirModtime operations do not yet have stats, and r.CheckDirectoryModTimes also does not tell us what actions were taken) oldLogLevel := fs.GetConfig(context.Background()).LogLevel defer func() { fs.GetConfig(context.Background()).LogLevel = oldLogLevel }() // reset to old val after test // need to do this as fs.Infof only respects the globalConfig fs.GetConfig(context.Background()).LogLevel = fs.LogLevelInfo // First run accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) output := bilib.CaptureOutput(func() { err := CopyDir(ctx, r.Fremote, r.Flocal, copyEmptySrcDirs) require.NoError(t, err) }) require.NotNil(t, output) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) // Save all dirs dirs := []string{"test_dir1", "test_dir2", "test_dir2/sub_dir", "empty_on_remote"} if copyEmptySrcDirs { dirs = append(dirs, "empty_dir") } // Change dir modtimes for _, dir := range dirs { _, err := operations.SetDirModTime(ctx, r.Flocal, nil, dir, t1) if err != nil && !errors.Is(err, fs.ErrorNotImplemented) { require.NoError(t, err) } } // Run again accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) output = bilib.CaptureOutput(func() { err := CopyDir(ctx, r.Fremote, r.Flocal, copyEmptySrcDirs) require.NoError(t, err) }) require.NotNil(t, output) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1, file2, file3) r.CheckRemoteItems(t, file1, file2, file3) // Check that the modtimes of the directories are as expected r.CheckDirectoryModTimes(t, dirs...) } func TestSyncReplaceDirModTime(t *testing.T) { testSyncReplaceDirModTime(t, false) } func TestSyncReplaceDirModTimeWithEmptyDirs(t *testing.T) { testSyncReplaceDirModTime(t, true) } // Tests that nothing is transferred when src and dst already match // Run the same sync twice, ensure no action is taken the second time func testNothingToTransfer(t *testing.T, copyEmptySrcDirs bool) { accounting.GlobalStats().ResetCounters() ctx, _ := fs.AddConfig(context.Background()) r := fstest.NewRun(t) file1 := r.WriteFile("sub dir/hello world", "hello world", t1) file2 := r.WriteFile("sub dir2/very/very/very/very/very/nested/subdir/hello world", "hello world", t1) r.CheckLocalItems(t, file1, file2) _, err := operations.SetDirModTime(ctx, r.Flocal, nil, "sub dir", t2) if err != nil && !errors.Is(err, fs.ErrorNotImplemented) { require.NoError(t, err) } r.Mkdir(ctx, r.Fremote) _, err = operations.MkdirModTime(ctx, r.Fremote, "sub dir", t3) require.NoError(t, err) // set logging // (this checks log output as DirModtime operations do not yet have stats, and r.CheckDirectoryModTimes also does not tell us what actions were taken) oldLogLevel := fs.GetConfig(context.Background()).LogLevel defer func() { fs.GetConfig(context.Background()).LogLevel = oldLogLevel }() // reset to old val after test // need to do this as fs.Infof only respects the globalConfig fs.GetConfig(context.Background()).LogLevel = fs.LogLevelInfo accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) output := bilib.CaptureOutput(func() { err = CopyDir(ctx, r.Fremote, r.Flocal, copyEmptySrcDirs) require.NoError(t, err) }) require.NotNil(t, output) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1, file2) r.CheckRemoteItems(t, file1, file2) // Check that the modtimes of the directories are as expected r.CheckDirectoryModTimes(t, "sub dir", "sub dir2", "sub dir2/very", "sub dir2/very/very", "sub dir2/very/very/very/very/very/nested/subdir") // check that actions were taken assert.True(t, strings.Contains(string(output), "Copied"), `expected to find at least one "Copied" log: `+string(output)) if r.Fremote.Features().DirSetModTime != nil || r.Fremote.Features().MkdirMetadata != nil { assert.True(t, strings.Contains(string(output), "Set directory modification time"), `expected to find at least one "Set directory modification time" log: `+string(output)) } assert.False(t, strings.Contains(string(output), "There was nothing to transfer"), `expected to find no "There was nothing to transfer" logs, but found one: `+string(output)) assert.True(t, accounting.GlobalStats().GetTransfers() >= 2) // run it again and make sure no actions were taken accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) output = bilib.CaptureOutput(func() { err = CopyDir(ctx, r.Fremote, r.Flocal, copyEmptySrcDirs) require.NoError(t, err) }) require.NotNil(t, output) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1, file2) r.CheckRemoteItems(t, file1, file2) // Check that the modtimes of the directories are as expected r.CheckDirectoryModTimes(t, "sub dir", "sub dir2", "sub dir2/very", "sub dir2/very/very", "sub dir2/very/very/very/very/very/nested/subdir") // check that actions were NOT taken assert.False(t, strings.Contains(string(output), "Copied"), `expected to find no "Copied" logs, but found one: `+string(output)) if r.Fremote.Features().DirSetModTime != nil || r.Fremote.Features().MkdirMetadata != nil { assert.False(t, strings.Contains(string(output), "Set directory modification time"), `expected to find no "Set directory modification time" logs, but found one: `+string(output)) assert.False(t, strings.Contains(string(output), "Updated directory metadata"), `expected to find no "Updated directory metadata" logs, but found one: `+string(output)) assert.False(t, strings.Contains(string(output), "directory"), `expected to find no "directory"-related logs, but found one: `+string(output)) // catch-all } assert.True(t, strings.Contains(string(output), "There was nothing to transfer"), `expected to find a "There was nothing to transfer" log: `+string(output)) assert.Equal(t, int64(0), accounting.GlobalStats().GetTransfers()) // check nested empty dir behavior (FIXME: probably belongs in a separate test) if r.Fremote.Features().DirSetModTime == nil && r.Fremote.Features().MkdirMetadata == nil { return } file3 := r.WriteFile("sub dir2/sub dir3/hello world", "hello again, world", t1) _, err = operations.SetDirModTime(ctx, r.Flocal, nil, "sub dir2", t1) assert.NoError(t, err) _, err = operations.SetDirModTime(ctx, r.Fremote, nil, "sub dir2", t1) assert.NoError(t, err) _, err = operations.MkdirModTime(ctx, r.Flocal, "sub dirEmpty/sub dirEmpty2", t2) assert.NoError(t, err) _, err = operations.SetDirModTime(ctx, r.Flocal, nil, "sub dirEmpty", t2) assert.NoError(t, err) accounting.GlobalStats().ResetCounters() ctx = predictDstFromLogger(ctx) output = bilib.CaptureOutput(func() { err = CopyDir(ctx, r.Fremote, r.Flocal, copyEmptySrcDirs) require.NoError(t, err) }) require.NotNil(t, output) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) r.CheckLocalItems(t, file1, file2, file3) r.CheckRemoteItems(t, file1, file2, file3) // Check that the modtimes of the directories are as expected r.CheckDirectoryModTimes(t, "sub dir", "sub dir2", "sub dir2/very", "sub dir2/very/very", "sub dir2/very/very/very/very/very/nested/subdir", "sub dir2/sub dir3") if copyEmptySrcDirs { r.CheckDirectoryModTimes(t, "sub dirEmpty", "sub dirEmpty/sub dirEmpty2") assert.True(t, strings.Contains(string(output), "sub dirEmpty:"), `expected to find at least one "sub dirEmpty:" log: `+string(output)) } else { assert.False(t, strings.Contains(string(output), "sub dirEmpty:"), `expected to find no "sub dirEmpty:" logs, but found one (empty dir was synced and shouldn't have been): `+string(output)) } assert.True(t, strings.Contains(string(output), "sub dir3:"), `expected to find at least one "sub dir3:" log: `+string(output)) assert.False(t, strings.Contains(string(output), "sub dir2/very:"), `expected to find no "sub dir2/very:" logs, but found one (unmodified dir was marked modified): `+string(output)) } func TestNothingToTransferWithEmptyDirs(t *testing.T) { testNothingToTransfer(t, true) } func TestNothingToTransferWithoutEmptyDirs(t *testing.T) { testNothingToTransfer(t, false) } // for testing logger: func predictDstFromLogger(ctx context.Context) context.Context { opt := operations.NewLoggerOpt() var lock mutex.Mutex opt.LoggerFn = func(ctx context.Context, sigil operations.Sigil, src, dst fs.DirEntry, err error) { lock.Lock() defer lock.Unlock() // ignore dirs for our purposes here if err == fs.ErrorIsDir { return } winner := operations.WinningSide(ctx, sigil, src, dst, err) if winner.Obj != nil { file := winner.Obj obj, ok := file.(fs.ObjectInfo) checksum := "" timeFormat := "2006-01-02 15:04:05" if ok { if obj.Fs().Hashes().GetOne() == hash.MD5 { // skip if no MD5 checksum, _ = obj.Hash(ctx, hash.MD5) } timeFormat = operations.FormatForLSFPrecision(obj.Fs().Precision()) } errMsg := "" if winner.Err != nil { errMsg = ";" + winner.Err.Error() } operations.SyncFprintf(opt.JSON, "%s;%s;%v;%s%s\n", file.ModTime(ctx).Local().Format(timeFormat), checksum, file.Size(), transform.Path(ctx, file.Remote(), false), errMsg) // TODO: should the transform be handled in the sync instead of here? } } return operations.WithSyncLogger(ctx, opt) } func DstLsf(ctx context.Context, Fremote fs.Fs) *bytes.Buffer { opt := operations.ListJSONOpt{ NoModTime: false, NoMimeType: true, DirsOnly: false, FilesOnly: true, Recurse: true, ShowHash: true, HashTypes: []string{"MD5"}, } var list operations.ListFormat list.SetSeparator(";") timeFormat := operations.FormatForLSFPrecision(Fremote.Precision()) if Fremote.Precision() == fs.ModTimeNotSupported { timeFormat = "none" } list.AddModTime(timeFormat) list.AddHash(hash.MD5) list.AddSize() list.AddPath() out := new(bytes.Buffer) err := operations.ListJSON(ctx, Fremote, "", &opt, func(item *operations.ListJSONItem) error { _, _ = fmt.Fprintln(out, list.Format(item)) return nil }) if err != nil { fs.Errorf(Fremote, "ListJSON error: %v", err) } return out } func LoggerMatchesLsf(logger, lsf *bytes.Buffer) error { loggerSplit := bytes.Split(logger.Bytes(), []byte("\n")) sort.SliceStable(loggerSplit, func(i int, j int) bool { return string(loggerSplit[i]) < string(loggerSplit[j]) }) lsfSplit := bytes.Split(lsf.Bytes(), []byte("\n")) sort.SliceStable(lsfSplit, func(i int, j int) bool { return string(lsfSplit[i]) < string(lsfSplit[j]) }) loggerJoined := bytes.Join(loggerSplit, []byte("\n")) lsfJoined := bytes.Join(lsfSplit, []byte("\n")) if bytes.Equal(loggerJoined, lsfJoined) { return nil } Diff(string(loggerJoined), string(lsfJoined)) return fmt.Errorf("logger does not match lsf! \nlogger: \n%s \nlsf: \n%s", loggerJoined, lsfJoined) } func Diff(rev1, rev2 string) { fmt.Printf("Diff of %q and %q\n", "logger", "lsf") cmd := exec.Command("bash", "-c", fmt.Sprintf(`diff <(echo "%s") <(echo "%s")`, rev1, rev2)) out, _ := cmd.Output() _, _ = os.Stdout.Write(out) } func testLoggerVsLsf(ctx context.Context, fdst, fsrc fs.Fs, logger *bytes.Buffer, t *testing.T) { var newlogger bytes.Buffer canTestModtime := fs.GetModifyWindow(ctx, fdst) != fs.ModTimeNotSupported canTestHash := fdst.Hashes().Contains(hash.MD5) if !canTestHash || !canTestModtime { loggerSplit := bytes.Split(logger.Bytes(), []byte("\n")) for i, line := range loggerSplit { elements := bytes.Split(line, []byte(";")) if len(elements) >= 2 { if !canTestModtime { elements[0] = []byte("none") } if !canTestHash { elements[1] = []byte("") } } loggerSplit[i] = bytes.Join(elements, []byte(";")) } newlogger.Write(bytes.Join(loggerSplit, []byte("\n"))) } else { newlogger.Write(logger.Bytes()) } if fsrc.Precision() == fdst.Precision() && fsrc.Hashes().Contains(hash.MD5) && canTestHash { lsf := DstLsf(ctx, fdst) err := LoggerMatchesLsf(&newlogger, lsf) require.NoError(t, err) } } rclone-v1.71.0/fs/sync/sync_transform_test.go000066400000000000000000000415611505210326400212760ustar00rootroot00000000000000// Test transform package sync import ( "cmp" "context" "fmt" "path" "slices" "strings" "testing" _ "github.com/rclone/rclone/backend/all" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fs/walk" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/lib/transform" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "golang.org/x/text/unicode/norm" ) var debug = `` func TestTransform(t *testing.T) { type args struct { TransformOpt []string TransformBackOpt []string Lossless bool // whether the TransformBackAlgo is always losslessly invertible } tests := []struct { name string args args }{ {name: "NFC", args: args{ TransformOpt: []string{"nfc"}, TransformBackOpt: []string{"nfd"}, Lossless: false, }}, {name: "NFD", args: args{ TransformOpt: []string{"nfd"}, TransformBackOpt: []string{"nfc"}, Lossless: false, }}, {name: "base64", args: args{ TransformOpt: []string{"base64encode"}, TransformBackOpt: []string{"base64encode"}, Lossless: false, }}, {name: "prefix", args: args{ TransformOpt: []string{"prefix=PREFIX"}, TransformBackOpt: []string{"trimprefix=PREFIX"}, Lossless: true, }}, {name: "suffix", args: args{ TransformOpt: []string{"suffix=SUFFIX"}, TransformBackOpt: []string{"trimsuffix=SUFFIX"}, Lossless: true, }}, {name: "truncate", args: args{ TransformOpt: []string{"truncate=10"}, TransformBackOpt: []string{"truncate=10"}, Lossless: false, }}, {name: "encoder", args: args{ TransformOpt: []string{"encoder=Colon,SquareBracket"}, TransformBackOpt: []string{"decoder=Colon,SquareBracket"}, Lossless: true, }}, {name: "ISO-8859-1", args: args{ TransformOpt: []string{"ISO-8859-1"}, TransformBackOpt: []string{"ISO-8859-1"}, Lossless: false, }}, {name: "charmap", args: args{ TransformOpt: []string{"all,charmap=ISO-8859-7"}, TransformBackOpt: []string{"all,charmap=ISO-8859-7"}, Lossless: false, }}, {name: "lowercase", args: args{ TransformOpt: []string{"all,lowercase"}, TransformBackOpt: []string{"all,lowercase"}, Lossless: false, }}, {name: "ascii", args: args{ TransformOpt: []string{"all,ascii"}, TransformBackOpt: []string{"all,ascii"}, Lossless: false, }}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { r := fstest.NewRun(t) defer r.Finalise() ctx := context.Background() r.Mkdir(ctx, r.Flocal) r.Mkdir(ctx, r.Fremote) items := makeTestFiles(t, r, "dir1") deleteDSStore(t, r) r.CheckRemoteListing(t, items, nil) r.CheckLocalListing(t, items, nil) err := transform.SetOptions(ctx, tt.args.TransformOpt...) require.NoError(t, err) err = Sync(ctx, r.Fremote, r.Flocal, true) assert.NoError(t, err) compareNames(ctx, t, r, items) err = transform.SetOptions(ctx, tt.args.TransformBackOpt...) require.NoError(t, err) err = Sync(ctx, r.Fremote, r.Flocal, true) assert.NoError(t, err) compareNames(ctx, t, r, items) if tt.args.Lossless { deleteDSStore(t, r) r.CheckRemoteItems(t, items...) } }) } } const alphabet = "abcdefg123456789" var extras = []string{"apple", "banana", "appleappleapplebanana", "splitbananasplit"} func makeTestFiles(t *testing.T, r *fstest.Run, dir string) []fstest.Item { t.Helper() n := 0 // Create test files items := []fstest.Item{} for _, c := range alphabet { var out strings.Builder for i := rune(0); i < 7; i++ { out.WriteRune(c + i) } fileName := path.Join(dir, fmt.Sprintf("%04d-%s.txt", n, out.String())) fileName = strings.ToValidUTF8(fileName, "") fileName = strings.NewReplacer(":", "", "<", "", ">", "", "?", "").Replace(fileName) // remove characters illegal on windows if debug != "" { fileName = debug } item := r.WriteObject(context.Background(), fileName, fileName, t1) r.WriteFile(fileName, fileName, t1) items = append(items, item) n++ if debug != "" { break } } for _, extra := range extras { item := r.WriteObject(context.Background(), extra, extra, t1) r.WriteFile(extra, extra, t1) items = append(items, item) } return items } func deleteDSStore(t *testing.T, r *fstest.Run) { ctxDSStore, fi := filter.AddConfig(context.Background()) err := fi.AddRule(`+ *.DS_Store`) assert.NoError(t, err) err = fi.AddRule(`- **`) assert.NoError(t, err) err = operations.Delete(ctxDSStore, r.Fremote) assert.NoError(t, err) } func compareNames(ctx context.Context, t *testing.T, r *fstest.Run, items []fstest.Item) { var entries fs.DirEntries deleteDSStore(t, r) err := walk.ListR(context.Background(), r.Fremote, "", true, -1, walk.ListObjects, func(e fs.DirEntries) error { entries = append(entries, e...) return nil }) assert.NoError(t, err) entries = slices.DeleteFunc(entries, func(E fs.DirEntry) bool { // remove those pesky .DS_Store files if strings.Contains(E.Remote(), ".DS_Store") { err := operations.DeleteFile(context.Background(), E.(fs.Object)) assert.NoError(t, err) return true } return false }) require.Equal(t, len(items), entries.Len()) // sort by CONVERTED name slices.SortStableFunc(items, func(a, b fstest.Item) int { aConv := transform.Path(ctx, a.Path, false) bConv := transform.Path(ctx, b.Path, false) return cmp.Compare(aConv, bConv) }) slices.SortStableFunc(entries, func(a, b fs.DirEntry) int { return cmp.Compare(a.Remote(), b.Remote()) }) for i, e := range entries { expect := transform.Path(ctx, items[i].Path, false) msg := fmt.Sprintf("expected %v, got %v", detectEncoding(expect), detectEncoding(e.Remote())) assert.Equal(t, expect, e.Remote(), msg) } } func detectEncoding(s string) string { if norm.NFC.IsNormalString(s) && norm.NFD.IsNormalString(s) { return "BOTH" } if !norm.NFC.IsNormalString(s) && norm.NFD.IsNormalString(s) { return "NFD" } if norm.NFC.IsNormalString(s) && !norm.NFD.IsNormalString(s) { return "NFC" } return "OTHER" } func TestTransformCopy(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) err := transform.SetOptions(ctx, "all,suffix_keep_extension=_somesuffix") require.NoError(t, err) file1 := r.WriteFile("sub dir/hello world.txt", "hello world", t1) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, true) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, fstest.NewItem("sub dir_somesuffix/hello world_somesuffix.txt", "hello world", t1)) } func TestDoubleTransform(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) err := transform.SetOptions(ctx, "all,prefix=tac", "all,prefix=tic") require.NoError(t, err) file1 := r.WriteFile("toe/toe", "hello world", t1) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, true) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, fstest.NewItem("tictactoe/tictactoe", "hello world", t1)) } func TestFileTag(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) err := transform.SetOptions(ctx, "file,prefix=tac", "file,prefix=tic") require.NoError(t, err) file1 := r.WriteFile("toe/toe/toe", "hello world", t1) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, true) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, fstest.NewItem("toe/toe/tictactoe", "hello world", t1)) } func TestNoTag(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) err := transform.SetOptions(ctx, "prefix=tac", "prefix=tic") require.NoError(t, err) file1 := r.WriteFile("toe/toe/toe", "hello world", t1) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, true) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, fstest.NewItem("toe/toe/tictactoe", "hello world", t1)) } func TestDirTag(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) err := transform.SetOptions(ctx, "dir,prefix=tac", "dir,prefix=tic") require.NoError(t, err) r.WriteFile("toe/toe/toe.txt", "hello world", t1) _, err = operations.MkdirModTime(ctx, r.Flocal, "empty_dir", t1) require.NoError(t, err) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, true) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalListing(t, []fstest.Item{fstest.NewItem("toe/toe/toe.txt", "hello world", t1)}, []string{"empty_dir", "toe", "toe/toe"}) r.CheckRemoteListing(t, []fstest.Item{fstest.NewItem("tictactoe/tictactoe/toe.txt", "hello world", t1)}, []string{"tictacempty_dir", "tictactoe", "tictactoe/tictactoe"}) } func TestAllTag(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) err := transform.SetOptions(ctx, "all,prefix=tac", "all,prefix=tic") require.NoError(t, err) r.WriteFile("toe/toe/toe.txt", "hello world", t1) _, err = operations.MkdirModTime(ctx, r.Flocal, "empty_dir", t1) require.NoError(t, err) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, true) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalListing(t, []fstest.Item{fstest.NewItem("toe/toe/toe.txt", "hello world", t1)}, []string{"empty_dir", "toe", "toe/toe"}) r.CheckRemoteListing(t, []fstest.Item{fstest.NewItem("tictactoe/tictactoe/tictactoe.txt", "hello world", t1)}, []string{"tictacempty_dir", "tictactoe", "tictactoe/tictactoe"}) err = operations.Check(ctx, &operations.CheckOpt{Fsrc: r.Flocal, Fdst: r.Fremote}) // should not error even though dst has transformed names assert.NoError(t, err) } func TestRunTwice(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) err := transform.SetOptions(ctx, "dir,prefix=tac", "dir,prefix=tic") require.NoError(t, err) file1 := r.WriteFile("toe/toe/toe.txt", "hello world", t1) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, true) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, fstest.NewItem("tictactoe/tictactoe/toe.txt", "hello world", t1)) // result should not change second time, since src is unchanged ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, true) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, fstest.NewItem("tictactoe/tictactoe/toe.txt", "hello world", t1)) } func TestSyntax(t *testing.T) { ctx := context.Background() err := transform.SetOptions(ctx, "prefix") assert.Error(t, err) // should error as required value is missing err = transform.SetOptions(ctx, "banana") assert.Error(t, err) // should error as unrecognized option err = transform.SetOptions(ctx, "=123") assert.Error(t, err) // should error as required key is missing err = transform.SetOptions(ctx, "prefix=123") assert.NoError(t, err) // should not error } func TestConflicting(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) err := transform.SetOptions(ctx, "prefix=tac", "trimprefix=tac") require.NoError(t, err) file1 := r.WriteFile("toe/toe/toe", "hello world", t1) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, true) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) // should result in no change as prefix and trimprefix cancel out r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, fstest.NewItem("toe/toe/toe", "hello world", t1)) } func TestMove(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) err := transform.SetOptions(ctx, "all,prefix=tac", "all,prefix=tic") require.NoError(t, err) r.WriteFile("toe/toe/toe.txt", "hello world", t1) _, err = operations.MkdirModTime(ctx, r.Flocal, "empty_dir", t1) require.NoError(t, err) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = MoveDir(ctx, r.Fremote, r.Flocal, true, true) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalListing(t, []fstest.Item{}, []string{}) r.CheckRemoteListing(t, []fstest.Item{fstest.NewItem("tictactoe/tictactoe/tictactoe.txt", "hello world", t1)}, []string{"tictacempty_dir", "tictactoe", "tictactoe/tictactoe"}) } func TestTransformFile(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) err := transform.SetOptions(ctx, "all,prefix=tac", "all,prefix=tic") require.NoError(t, err) r.WriteFile("toe/toe/toe.txt", "hello world", t1) _, err = operations.MkdirModTime(ctx, r.Flocal, "empty_dir", t1) require.NoError(t, err) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = MoveDir(ctx, r.Fremote, r.Flocal, true, true) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalListing(t, []fstest.Item{}, []string{}) r.CheckRemoteListing(t, []fstest.Item{fstest.NewItem("tictactoe/tictactoe/tictactoe.txt", "hello world", t1)}, []string{"tictacempty_dir", "tictactoe", "tictactoe/tictactoe"}) err = transform.SetOptions(ctx, "all,trimprefix=tic", "all,trimprefix=tac") require.NoError(t, err) err = operations.TransformFile(ctx, r.Fremote, "tictactoe/tictactoe/tictactoe.txt") require.NoError(t, err) r.CheckLocalListing(t, []fstest.Item{}, []string{}) r.CheckRemoteListing(t, []fstest.Item{fstest.NewItem("toe/toe/toe.txt", "hello world", t1)}, []string{"tictacempty_dir", "tictactoe", "tictactoe/tictactoe", "toe", "toe/toe"}) } func TestManualTransformFile(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) r.Flocal.Features().DisableList([]string{"Copy", "Move"}) r.Fremote.Features().DisableList([]string{"Copy", "Move"}) err := transform.SetOptions(ctx, "all,prefix=tac", "all,prefix=tic") require.NoError(t, err) r.WriteFile("toe/toe/toe.txt", "hello world", t1) _, err = operations.MkdirModTime(ctx, r.Flocal, "empty_dir", t1) require.NoError(t, err) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = MoveDir(ctx, r.Fremote, r.Flocal, true, true) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalListing(t, []fstest.Item{}, []string{}) r.CheckRemoteListing(t, []fstest.Item{fstest.NewItem("tictactoe/tictactoe/tictactoe.txt", "hello world", t1)}, []string{"tictacempty_dir", "tictactoe", "tictactoe/tictactoe"}) err = transform.SetOptions(ctx, "all,trimprefix=tic", "all,trimprefix=tac") require.NoError(t, err) err = operations.TransformFile(ctx, r.Fremote, "tictactoe/tictactoe/tictactoe.txt") require.NoError(t, err) r.CheckLocalListing(t, []fstest.Item{}, []string{}) r.CheckRemoteListing(t, []fstest.Item{fstest.NewItem("toe/toe/toe.txt", "hello world", t1)}, []string{"tictacempty_dir", "tictactoe", "tictactoe/tictactoe", "toe", "toe/toe"}) } func TestBase64(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) err := transform.SetOptions(ctx, "all,base64encode") require.NoError(t, err) file1 := r.WriteFile("toe/toe/toe.txt", "hello world", t1) r.Mkdir(ctx, r.Fremote) ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, true) testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, fstest.NewItem("dG9l/dG9l/dG9lLnR4dA==", "hello world", t1)) // round trip err = transform.SetOptions(ctx, "all,base64decode") require.NoError(t, err) ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Flocal, r.Fremote, true) testLoggerVsLsf(ctx, r.Flocal, r.Fremote, operations.GetLoggerOpt(ctx).JSON, t) require.NoError(t, err) r.CheckLocalItems(t, file1) r.CheckRemoteItems(t, fstest.NewItem("dG9l/dG9l/dG9lLnR4dA==", "hello world", t1)) } func TestError(t *testing.T) { ctx := context.Background() r := fstest.NewRun(t) err := transform.SetOptions(ctx, "all,prefix=ta/c") // has illegal character require.NoError(t, err) file1 := r.WriteFile("toe/toe/toe", "hello world", t1) r.Mkdir(ctx, r.Fremote) // ctx = predictDstFromLogger(ctx) err = Sync(ctx, r.Fremote, r.Flocal, true) // testLoggerVsLsf(ctx, r.Fremote, r.Flocal, operations.GetLoggerOpt(ctx).JSON, t) assert.Error(t, err) r.CheckLocalListing(t, []fstest.Item{file1}, []string{"toe", "toe/toe"}) r.CheckRemoteListing(t, []fstest.Item{file1}, []string{"toe", "toe/toe"}) } rclone-v1.71.0/fs/terminalcolormode.go000066400000000000000000000007601505210326400177270ustar00rootroot00000000000000package fs // TerminalColorMode describes how ANSI codes should be handled type TerminalColorMode = Enum[terminalColorModeChoices] // TerminalColorMode constants const ( TerminalColorModeAuto TerminalColorMode = iota TerminalColorModeNever TerminalColorModeAlways ) type terminalColorModeChoices struct{} func (terminalColorModeChoices) Choices() []string { return []string{ TerminalColorModeAuto: "AUTO", TerminalColorModeNever: "NEVER", TerminalColorModeAlways: "ALWAYS", } } rclone-v1.71.0/fs/terminalcolormode_test.go000066400000000000000000000034711505210326400207700ustar00rootroot00000000000000package fs import ( "encoding/json" "strconv" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestTerminalColorModeString(t *testing.T) { for _, test := range []struct { in TerminalColorMode want string }{ {TerminalColorModeAuto, "AUTO"}, {TerminalColorModeAlways, "ALWAYS"}, {TerminalColorModeNever, "NEVER"}, {36, "Unknown(36)"}, } { tcm := test.in assert.Equal(t, test.want, tcm.String(), test.in) } } func TestTerminalColorModeSet(t *testing.T) { for _, test := range []struct { in string want TerminalColorMode expectError bool }{ {"auto", TerminalColorModeAuto, false}, {"ALWAYS", TerminalColorModeAlways, false}, {"Never", TerminalColorModeNever, false}, {"INVALID", 0, true}, } { tcm := TerminalColorMode(0) err := tcm.Set(test.in) if test.expectError { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, tcm, test.in) } } func TestTerminalColorModeUnmarshalJSON(t *testing.T) { for _, test := range []struct { in string want TerminalColorMode expectError bool }{ {`"auto"`, TerminalColorModeAuto, false}, {`"ALWAYS"`, TerminalColorModeAlways, false}, {`"Never"`, TerminalColorModeNever, false}, {`"Invalid"`, 0, true}, {strconv.Itoa(int(TerminalColorModeAuto)), TerminalColorModeAuto, false}, {strconv.Itoa(int(TerminalColorModeAlways)), TerminalColorModeAlways, false}, {strconv.Itoa(int(TerminalColorModeNever)), TerminalColorModeNever, false}, {`99`, 0, true}, {`-99`, 0, true}, } { var tcm TerminalColorMode err := json.Unmarshal([]byte(test.in), &tcm) if test.expectError { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, tcm, test.in) } } rclone-v1.71.0/fs/tristate.go000066400000000000000000000026701505210326400160510ustar00rootroot00000000000000package fs import ( "encoding/json" "fmt" "strconv" "strings" ) // Tristate is a boolean that can has the states, true, false and // unset/invalid/nil type Tristate struct { Value bool Valid bool } // String renders the tristate as true/false/unset func (t Tristate) String() string { if !t.Valid { return "unset" } if t.Value { return "true" } return "false" } // Set the List entries func (t *Tristate) Set(s string) error { s = strings.ToLower(s) if s == "" || s == "nil" || s == "null" || s == "unset" { t.Valid = false return nil } value, err := strconv.ParseBool(s) if err != nil { return fmt.Errorf("failed to parse Tristate %q: %w", s, err) } t.Value = value t.Valid = true return nil } // Type of the value func (Tristate) Type() string { return "Tristate" } // Scan implements the fmt.Scanner interface func (t *Tristate) Scan(s fmt.ScanState, ch rune) error { token, err := s.Token(true, nil) if err != nil { return err } return t.Set(string(token)) } // UnmarshalJSON parses it as a bool or nil for unset func (t *Tristate) UnmarshalJSON(in []byte) error { var b *bool err := json.Unmarshal(in, &b) if err != nil { return err } if b != nil { t.Valid = true t.Value = *b } else { t.Valid = false } return nil } // MarshalJSON encodes it as a bool or nil for unset func (t *Tristate) MarshalJSON() ([]byte, error) { if !t.Valid { return json.Marshal(nil) } return json.Marshal(t.Value) } rclone-v1.71.0/fs/tristate_test.go000066400000000000000000000047721505210326400171150ustar00rootroot00000000000000package fs import ( "encoding/json" "fmt" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Check it satisfies the interfaces var ( _ Flagger = (*Tristate)(nil) _ FlaggerNP = Tristate{} ) func TestTristateString(t *testing.T) { for _, test := range []struct { in Tristate want string }{ {Tristate{}, "unset"}, {Tristate{Valid: false, Value: false}, "unset"}, {Tristate{Valid: false, Value: true}, "unset"}, {Tristate{Valid: true, Value: false}, "false"}, {Tristate{Valid: true, Value: true}, "true"}, } { got := test.in.String() assert.Equal(t, test.want, got) } } func TestTristateSet(t *testing.T) { for _, test := range []struct { in string want Tristate err bool }{ {"", Tristate{Valid: false, Value: false}, false}, {"nil", Tristate{Valid: false, Value: false}, false}, {"null", Tristate{Valid: false, Value: false}, false}, {"UNSET", Tristate{Valid: false, Value: false}, false}, {"true", Tristate{Valid: true, Value: true}, false}, {"1", Tristate{Valid: true, Value: true}, false}, {"false", Tristate{Valid: true, Value: false}, false}, {"0", Tristate{Valid: true, Value: false}, false}, {"potato", Tristate{Valid: false, Value: false}, true}, } { var got Tristate err := got.Set(test.in) if test.err { require.Error(t, err) } else { require.NoError(t, err) assert.Equal(t, test.want, got) } } } func TestTristateScan(t *testing.T) { var v Tristate n, err := fmt.Sscan(" true ", &v) require.NoError(t, err) assert.Equal(t, 1, n) assert.Equal(t, Tristate{Valid: true, Value: true}, v) } func TestTristateUnmarshalJSON(t *testing.T) { for _, test := range []struct { in string want Tristate err bool }{ {`null`, Tristate{}, false}, {`true`, Tristate{Valid: true, Value: true}, false}, {`false`, Tristate{Valid: true, Value: false}, false}, {`potato`, Tristate{}, true}, {``, Tristate{}, true}, } { var got Tristate err := json.Unmarshal([]byte(test.in), &got) if test.err { require.Error(t, err, test.in) } else { require.NoError(t, err, test.in) } assert.Equal(t, test.want, got, test.in) } } func TestTristateMarshalJSON(t *testing.T) { for _, test := range []struct { in Tristate want string }{ {Tristate{}, `null`}, {Tristate{Valid: true, Value: true}, `true`}, {Tristate{Valid: true, Value: false}, `false`}, } { got, err := json.Marshal(&test.in) require.NoError(t, err) assert.Equal(t, test.want, string(got), fmt.Sprintf("%#v", test.in)) } } rclone-v1.71.0/fs/types.go000066400000000000000000000255321505210326400153600ustar00rootroot00000000000000// Filesystem related types and interfaces // Note that optional interfaces are found in features.go package fs import ( "context" "encoding/json" "io" "math" "time" "github.com/rclone/rclone/fs/hash" ) // Fs is the interface a cloud storage system must provide type Fs interface { Info // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. List(ctx context.Context, dir string) (entries DirEntries, err error) // NewObject finds the Object at remote. If it can't be found // it returns the error ErrorObjectNotFound. // // If remote points to a directory then it should return // ErrorIsDir if possible without doing any extra work, // otherwise ErrorObjectNotFound. NewObject(ctx context.Context, remote string) (Object, error) // Put in to the remote path with the modTime given of the given size // // When called from outside an Fs by rclone, src.Size() will always be >= 0. // But for unknown-sized objects (indicated by src.Size() == -1), Put should either // return an error or upload it properly (rather than e.g. calling panic). // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error Put(ctx context.Context, in io.Reader, src ObjectInfo, options ...OpenOption) (Object, error) // Mkdir makes the directory (container, bucket) // // Shouldn't return an error if it already exists Mkdir(ctx context.Context, dir string) error // Rmdir removes the directory (container, bucket) if empty // // Return an error if it doesn't exist or isn't empty Rmdir(ctx context.Context, dir string) error } // Info provides a read only interface to information about a filesystem. type Info interface { // Name of the remote (as passed into NewFs) Name() string // Root of the remote (as passed into NewFs) Root() string // String returns a description of the FS String() string // Precision of the ModTimes in this Fs Precision() time.Duration // Returns the supported hash types of the filesystem Hashes() hash.Set // Features returns the optional features of this Fs Features() *Features } // Object is a filesystem like object provided by an Fs type Object interface { ObjectInfo // SetModTime sets the metadata on the object to set the modification date SetModTime(ctx context.Context, t time.Time) error // Open opens the file for read. Call Close() on the returned io.ReadCloser Open(ctx context.Context, options ...OpenOption) (io.ReadCloser, error) // Update in to the object with the modTime given of the given size // // When called from outside an Fs by rclone, src.Size() will always be >= 0. // But for unknown-sized objects (indicated by src.Size() == -1), Upload should either // return an error or update the object properly (rather than e.g. calling panic). Update(ctx context.Context, in io.Reader, src ObjectInfo, options ...OpenOption) error // Removes this object Remove(ctx context.Context) error } // ObjectInfo provides read only information about an object. type ObjectInfo interface { DirEntry // Hash returns the selected checksum of the file // If no checksum is available it returns "" Hash(ctx context.Context, ty hash.Type) (string, error) // Storable says whether this object can be stored Storable() bool } // DirEntry provides read only information about the common subset of // a Dir or Object. These are returned from directory listings - type // assert them into the correct type. type DirEntry interface { // Fs returns read only access to the Fs that this object is part of Fs() Info // String returns a description of the Object String() string // Remote returns the remote path Remote() string // ModTime returns the modification date of the file // It should return a best guess if one isn't available ModTime(context.Context) time.Time // Size returns the size of the file Size() int64 } // Directory is a filesystem like directory provided by an Fs type Directory interface { DirEntry // Items returns the count of items in this directory or this // directory and subdirectories if known, -1 for unknown Items() int64 // ID returns the internal ID of this directory if known, or // "" otherwise ID() string } // FullDirectory contains all the optional interfaces for Directory // // Use for checking making wrapping Directories implement everything type FullDirectory interface { Directory Metadataer SetMetadataer SetModTimer } // MimeTyper is an optional interface for Object type MimeTyper interface { // MimeType returns the content type of the Object if // known, or "" if not MimeType(ctx context.Context) string } // IDer is an optional interface for Object type IDer interface { // ID returns the ID of the Object if known, or "" if not ID() string } // ParentIDer is an optional interface for Object type ParentIDer interface { // ParentID returns the ID of the parent directory if known or nil if not ParentID() string } // ObjectUnWrapper is an optional interface for Object type ObjectUnWrapper interface { // UnWrap returns the Object that this Object is wrapping or // nil if it isn't wrapping anything UnWrap() Object } // SetTierer is an optional interface for Object type SetTierer interface { // SetTier performs changing storage tier of the Object if // multiple storage classes supported SetTier(tier string) error } // GetTierer is an optional interface for Object type GetTierer interface { // GetTier returns storage tier or class of the Object GetTier() string } // Metadataer is an optional interface for DirEntry type Metadataer interface { // Metadata returns metadata for an DirEntry // // It should return nil if there is no Metadata Metadata(ctx context.Context) (Metadata, error) } // SetMetadataer is an optional interface for DirEntry type SetMetadataer interface { // SetMetadata sets metadata for an DirEntry // // It should return fs.ErrorNotImplemented if it can't set metadata SetMetadata(ctx context.Context, metadata Metadata) error } // SetModTimer is an optional interface for Directory. // // Object implements this as part of its requires set of interfaces. type SetModTimer interface { // SetModTime sets the metadata on the DirEntry to set the modification date // // If there is any other metadata it does not overwrite it. SetModTime(ctx context.Context, t time.Time) error } // FullObjectInfo contains all the read-only optional interfaces // // Use for checking making wrapping ObjectInfos implement everything type FullObjectInfo interface { ObjectInfo MimeTyper IDer ObjectUnWrapper GetTierer Metadataer } // FullObject contains all the optional interfaces for Object // // Use for checking making wrapping Objects implement everything type FullObject interface { Object MimeTyper IDer ObjectUnWrapper GetTierer SetTierer Metadataer SetMetadataer } // ObjectOptionalInterfaces returns the names of supported and // unsupported optional interfaces for an Object func ObjectOptionalInterfaces(o Object) (supported, unsupported []string) { store := func(ok bool, name string) { if ok { supported = append(supported, name) } else { unsupported = append(unsupported, name) } } _, ok := o.(MimeTyper) store(ok, "MimeType") _, ok = o.(IDer) store(ok, "ID") _, ok = o.(ObjectUnWrapper) store(ok, "UnWrap") _, ok = o.(SetTierer) store(ok, "SetTier") _, ok = o.(GetTierer) store(ok, "GetTier") _, ok = o.(Metadataer) store(ok, "Metadata") _, ok = o.(SetMetadataer) store(ok, "SetMetadata") return supported, unsupported } // DirectoryOptionalInterfaces returns the names of supported and // unsupported optional interfaces for a Directory func DirectoryOptionalInterfaces(d Directory) (supported, unsupported []string) { store := func(ok bool, name string) { if ok { supported = append(supported, name) } else { unsupported = append(unsupported, name) } } _, ok := d.(Metadataer) store(ok, "Metadata") _, ok = d.(SetMetadataer) store(ok, "SetMetadata") _, ok = d.(SetModTimer) store(ok, "SetModTime") return supported, unsupported } // ListRCallback defines a callback function for ListR to use // // It is called for each tranche of entries read from the listing and // if it returns an error, the listing stops. type ListRCallback func(entries DirEntries) error // ListRFn is defines the call used to recursively list a directory // with ListR or page through a directory with ListP type ListRFn func(ctx context.Context, dir string, callback ListRCallback) error // Flagger describes the interface rclone config types flags must satisfy type Flagger interface { // These are from pflag.Value which we don't want to pull in here String() string Set(string) error Type() string json.Unmarshaler } // FlaggerNP describes the interface rclone config types flags must // satisfy as non-pointers // // These are from pflag.Value and need to be tested against // non-pointer value due the the way the backend flags are inserted // into the flags. type FlaggerNP interface { String() string Type() string } // NewUsageValue makes a valid value func NewUsageValue[T interface { int64 | uint64 | float64 }](value T) *int64 { p := new(int64) if value > T(int64(math.MaxInt64)) { *p = math.MaxInt64 } else { *p = int64(value) } return p } // Usage is returned by the About call // // If a value is nil then it isn't supported by that backend type Usage struct { Total *int64 `json:"total,omitempty"` // quota of bytes that can be used Used *int64 `json:"used,omitempty"` // bytes in use Trashed *int64 `json:"trashed,omitempty"` // bytes in trash Other *int64 `json:"other,omitempty"` // other usage e.g. gmail in drive Free *int64 `json:"free,omitempty"` // bytes which can be uploaded before reaching the quota Objects *int64 `json:"objects,omitempty"` // objects in the storage system } // WriterAtCloser wraps io.WriterAt and io.Closer type WriterAtCloser interface { io.WriterAt io.Closer } type unknownFs struct{} // Name of the remote (as passed into NewFs) func (unknownFs) Name() string { return "unknown" } // Root of the remote (as passed into NewFs) func (unknownFs) Root() string { return "" } // String returns a description of the FS func (unknownFs) String() string { return "unknown" } // Precision of the ModTimes in this Fs func (unknownFs) Precision() time.Duration { return ModTimeNotSupported } // Returns the supported hash types of the filesystem func (unknownFs) Hashes() hash.Set { return hash.Set(hash.None) } // Features returns the optional features of this Fs func (unknownFs) Features() *Features { return &Features{} } // Unknown holds an Info for an unknown Fs // // This is used when we need an Fs but don't have one. var Unknown Info = unknownFs{} rclone-v1.71.0/fs/version.go000066400000000000000000000003631505210326400156740ustar00rootroot00000000000000package fs // Version of rclone containing the complete version string var Version string func init() { if Version == "" { if VersionSuffix == "" { Version = VersionTag } else { Version = VersionTag + "-" + VersionSuffix } } } rclone-v1.71.0/fs/versioncheck.go000066400000000000000000000002671505210326400166750ustar00rootroot00000000000000//go:build !go1.24 package fs // Upgrade to Go version 1.24 to compile rclone - latest stable go // compiler recommended. func init() { Go_version_1_24_required_for_compilation() } rclone-v1.71.0/fs/versionsuffix.go000066400000000000000000000001511505210326400171140ustar00rootroot00000000000000package fs // VersionSuffix of rclone containing the pre-release label if any var VersionSuffix = "DEV" rclone-v1.71.0/fs/versiontag.go000066400000000000000000000000771505210326400163720ustar00rootroot00000000000000package fs // VersionTag of rclone var VersionTag = "v1.71.0" rclone-v1.71.0/fs/walk/000077500000000000000000000000001505210326400146145ustar00rootroot00000000000000rclone-v1.71.0/fs/walk/walk.go000066400000000000000000000440361505210326400161100ustar00rootroot00000000000000// Package walk walks directories package walk import ( "context" "errors" "fmt" "path" "sort" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/dirtree" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/list" ) // ErrorSkipDir is used as a return value from Walk to indicate that the // directory named in the call is to be skipped. It is not returned as // an error by any function. var ErrorSkipDir = errors.New("skip this directory") // ErrorCantListR is returned by WalkR if the underlying Fs isn't // capable of doing a recursive listing. var ErrorCantListR = errors.New("recursive directory listing not available") // Func is the type of the function called for directory // visited by Walk. The path argument contains remote path to the directory. // // If there was a problem walking to directory named by path, the // incoming error will describe the problem and the function can // decide how to handle that error (and Walk will not descend into // that directory). If an error is returned, processing stops. The // sole exception is when the function returns the special value // ErrorSkipDir. If the function returns ErrorSkipDir, Walk skips the // directory's contents entirely. type Func func(path string, entries fs.DirEntries, err error) error // Walk lists the directory. // // If includeAll is not set it will use the filters defined. // // If maxLevel is < 0 then it will recurse indefinitely, else it will // only do maxLevel levels. // // It calls fn for each tranche of DirEntries read. // // Note that fn will not be called concurrently whereas the directory // listing will proceed concurrently. // // Parent directories are always listed before their children. // // This is implemented by WalkR if Config.UseListR is true // and f supports it and level > 1, or WalkN otherwise. // // If --files-from and --no-traverse is set then a DirTree will be // constructed with just those files in and then walked with WalkR // // Note: this will flag filter-aware backends! // // NB (f, path) to be replaced by fs.Dir at some point func Walk(ctx context.Context, f fs.Fs, path string, includeAll bool, maxLevel int, fn Func) error { ci := fs.GetConfig(ctx) fi := filter.GetConfig(ctx) ctx = filter.SetUseFilter(ctx, f.Features().FilterAware && !includeAll) // make filter-aware backends constrain List if ci.NoTraverse && fi.HaveFilesFrom() { return walkR(ctx, f, path, includeAll, maxLevel, fn, fi.MakeListR(ctx, f.NewObject)) } // FIXME should this just be maxLevel < 0 - why the maxLevel > 1 if (maxLevel < 0 || maxLevel > 1) && ci.UseListR && f.Features().ListR != nil { return walkListR(ctx, f, path, includeAll, maxLevel, fn) } return walkListDirSorted(ctx, f, path, includeAll, maxLevel, fn) } // ListType is uses to choose which combination of files or directories is requires type ListType byte // Types of listing for ListR const ( ListObjects ListType = 1 << iota // list objects only ListDirs // list dirs only ListAll = ListObjects | ListDirs // list files and dirs ) // Objects returns true if the list type specifies objects func (l ListType) Objects() bool { return (l & ListObjects) != 0 } // Dirs returns true if the list type specifies dirs func (l ListType) Dirs() bool { return (l & ListDirs) != 0 } // Filter in (inplace) to only contain the type of list entry required func (l ListType) Filter(in *fs.DirEntries) { if l == ListAll { return } out := (*in)[:0] for _, entry := range *in { switch entry.(type) { case fs.Object: if l.Objects() { out = append(out, entry) } case fs.Directory: if l.Dirs() { out = append(out, entry) } default: fs.Errorf(nil, "Unknown object type %T", entry) } } *in = out } // ListR lists the directory recursively. // // If includeAll is not set it will use the filters defined. // // If maxLevel is < 0 then it will recurse indefinitely, else it will // only do maxLevel levels. // // If synthesizeDirs is set then for bucket-based remotes it will // synthesize directories from the file structure. This uses extra // memory so don't set this if you don't need directories, likewise do // set this if you are interested in directories. // // It calls fn for each tranche of DirEntries read. Note that these // don't necessarily represent a directory // // Note that fn will not be called concurrently whereas the directory // listing will proceed concurrently. // // Directories are not listed in any particular order so you can't // rely on parents coming before children or alphabetical ordering // // This is implemented by using ListR on the backend if possible and // efficient, otherwise by Walk. // // Note: this will flag filter-aware backends // // NB (f, path) to be replaced by fs.Dir at some point func ListR(ctx context.Context, f fs.Fs, path string, includeAll bool, maxLevel int, listType ListType, fn fs.ListRCallback) error { fi := filter.GetConfig(ctx) // FIXME disable this with --no-fast-list ??? `--disable ListR` will do it... doListR := f.Features().ListR // Can't use ListR if... if doListR == nil || // ...no ListR fi.HaveFilesFrom() || // ...using --files-from maxLevel >= 0 || // ...using bounded recursion len(fi.Opt.ExcludeFile) > 0 || // ...using --exclude-file fi.UsesDirectoryFilters() { // ...using any directory filters return listRwalk(ctx, f, path, includeAll, maxLevel, listType, fn) } ctx = filter.SetUseFilter(ctx, f.Features().FilterAware && !includeAll) // make filter-aware backends constrain List return listR(ctx, f, path, includeAll, listType, fn, doListR, listType.Dirs() && f.Features().BucketBased) } // listRwalk walks the file tree for ListR using Walk // Note: this will flag filter-aware backends (via Walk) func listRwalk(ctx context.Context, f fs.Fs, path string, includeAll bool, maxLevel int, listType ListType, fn fs.ListRCallback) error { var listErr error walkErr := Walk(ctx, f, path, includeAll, maxLevel, func(path string, entries fs.DirEntries, err error) error { // Carry on listing but return the error at the end if err != nil { listErr = err err = fs.CountError(ctx, err) fs.Errorf(path, "error listing: %v", err) return nil } listType.Filter(&entries) return fn(entries) }) if listErr != nil { return listErr } return walkErr } // dirMap keeps track of directories made for bucket-based remotes. // true => directory has been sent // false => directory has been seen but not sent type dirMap struct { mu sync.Mutex m map[string]bool root string } // make a new dirMap func newDirMap(root string) *dirMap { return &dirMap{ m: make(map[string]bool), root: root, } } // add adds a directory and parents with sent func (dm *dirMap) add(dir string, sent bool) { for { if dir == dm.root || dir == "" { return } currentSent, found := dm.m[dir] if found { // If it has been sent already then nothing more to do if currentSent { return } // If not sent already don't override if !sent { return } // currentSent == false && sent == true so needs overriding } dm.m[dir] = sent // Add parents in as unsent dir = parentDir(dir) sent = false } } // parentDir finds the parent directory of path func parentDir(entryPath string) string { dirPath := path.Dir(entryPath) if dirPath == "." { dirPath = "" } return dirPath } // add all the directories in entries and their parents to the dirMap func (dm *dirMap) addEntries(entries fs.DirEntries) error { dm.mu.Lock() defer dm.mu.Unlock() for _, entry := range entries { switch x := entry.(type) { case fs.Object: dm.add(parentDir(x.Remote()), false) case fs.Directory: dm.add(x.Remote(), true) default: return fmt.Errorf("unknown object type %T", entry) } } return nil } // send any missing parents to fn func (dm *dirMap) sendEntries(fn fs.ListRCallback) (err error) { // Count the strings first so we allocate the minimum memory n := 0 for _, sent := range dm.m { if !sent { n++ } } if n == 0 { return nil } dirs := make([]string, 0, n) // Fill the dirs up then sort it for dir, sent := range dm.m { if !sent { dirs = append(dirs, dir) } } sort.Strings(dirs) // Now convert to bulkier Dir in batches and send now := time.Now() list := list.NewHelper(fn) for _, dir := range dirs { err = list.Add(fs.NewDir(dir, now)) if err != nil { return err } } return list.Flush() } // listR walks the file tree using ListR func listR(ctx context.Context, f fs.Fs, path string, includeAll bool, listType ListType, fn fs.ListRCallback, doListR fs.ListRFn, synthesizeDirs bool) error { fi := filter.GetConfig(ctx) includeDirectory := fi.IncludeDirectory(ctx, f) if !includeAll { includeAll = fi.InActive() } var dm *dirMap if synthesizeDirs { dm = newDirMap(path) } var mu sync.Mutex err := doListR(ctx, path, func(entries fs.DirEntries) (err error) { accounting.Stats(ctx).Listed(int64(len(entries))) if synthesizeDirs { err = dm.addEntries(entries) if err != nil { return err } } listType.Filter(&entries) if !includeAll { filteredEntries := entries[:0] for _, entry := range entries { var include bool switch x := entry.(type) { case fs.Object: include = fi.IncludeObject(ctx, x) case fs.Directory: include, err = includeDirectory(x.Remote()) if err != nil { return err } default: return fmt.Errorf("unknown object type %T", entry) } if include { filteredEntries = append(filteredEntries, entry) } } entries = filteredEntries } mu.Lock() defer mu.Unlock() return fn(entries) }) if err != nil { return err } if synthesizeDirs { err = dm.sendEntries(fn) if err != nil { return err } } return nil } // walkListDirSorted lists the directory. // // It implements Walk using non recursive directory listing. func walkListDirSorted(ctx context.Context, f fs.Fs, path string, includeAll bool, maxLevel int, fn Func) error { return walk(ctx, f, path, includeAll, maxLevel, fn, list.DirSorted) } // walkListR lists the directory. // // It implements Walk using recursive directory listing if // available, or returns ErrorCantListR if not. func walkListR(ctx context.Context, f fs.Fs, path string, includeAll bool, maxLevel int, fn Func) error { listR := f.Features().ListR if listR == nil { return ErrorCantListR } return walkR(ctx, f, path, includeAll, maxLevel, fn, listR) } type listDirFunc func(ctx context.Context, fs fs.Fs, includeAll bool, dir string) (entries fs.DirEntries, err error) func walk(ctx context.Context, f fs.Fs, path string, includeAll bool, maxLevel int, fn Func, listDir listDirFunc) error { var ( wg sync.WaitGroup // sync closing of go routines traversing sync.WaitGroup // running directory traversals doClose sync.Once // close the channel once mu sync.Mutex // stop fn being called concurrently ci = fs.GetConfig(ctx) // current config ) // listJob describe a directory listing that needs to be done type listJob struct { remote string depth int } in := make(chan listJob, ci.Checkers) errs := make(chan error, 1) quit := make(chan struct{}) closeQuit := func() { doClose.Do(func() { close(quit) go func() { for range in { traversing.Done() } }() }) } for range ci.Checkers { wg.Add(1) go func() { defer wg.Done() for { select { case job, ok := <-in: if !ok { return } entries, err := listDir(ctx, f, includeAll, job.remote) var jobs []listJob if err == nil && job.depth != 0 { entries.ForDir(func(dir fs.Directory) { // Recurse for the directory jobs = append(jobs, listJob{ remote: dir.Remote(), depth: job.depth - 1, }) }) } mu.Lock() err = fn(job.remote, entries, err) mu.Unlock() // NB once we have passed entries to fn we mustn't touch it again if err != nil && err != ErrorSkipDir { traversing.Done() err = fs.CountError(ctx, err) fs.Errorf(job.remote, "error listing: %v", err) closeQuit() // Send error to error channel if space select { case errs <- err: default: } continue } if err == nil && len(jobs) > 0 { traversing.Add(len(jobs)) go func() { // Now we have traversed this directory, send these // jobs off for traversal in the background for _, newJob := range jobs { in <- newJob } }() } traversing.Done() case <-quit: return } } }() } // Start the process traversing.Add(1) in <- listJob{ remote: path, depth: maxLevel - 1, } traversing.Wait() close(in) wg.Wait() close(errs) // return the first error returned or nil return <-errs } func walkRDirTree(ctx context.Context, f fs.Fs, startPath string, includeAll bool, maxLevel int, listR fs.ListRFn) (dirtree.DirTree, error) { fi := filter.GetConfig(ctx) dirs := dirtree.New() // Entries can come in arbitrary order. We use toPrune to keep // all directories to exclude later. toPrune := make(map[string]bool) includeDirectory := fi.IncludeDirectory(ctx, f) var mu sync.Mutex err := listR(ctx, startPath, func(entries fs.DirEntries) error { accounting.Stats(ctx).Listed(int64(len(entries))) mu.Lock() defer mu.Unlock() for _, entry := range entries { slashes := strings.Count(entry.Remote(), "/") excluded := true switch x := entry.(type) { case fs.Object: // Make sure we don't delete excluded files if not required if includeAll || fi.IncludeObject(ctx, x) { if maxLevel < 0 || slashes <= maxLevel-1 { dirs.Add(x) excluded = false } } // Make sure we include any parent directories of excluded objects if excluded { dirPath := parentDir(x.Remote()) slashes-- if maxLevel >= 0 { for ; slashes > maxLevel-1; slashes-- { dirPath = parentDir(dirPath) } } inc, err := includeDirectory(dirPath) if err != nil { return err } if inc || includeAll { // If the directory doesn't exist already, create it _, obj := dirs.Find(dirPath) if obj == nil { dirs.AddDir(fs.NewDir(dirPath, time.Now())) } } } // Check if we need to prune a directory later. if !includeAll && len(fi.Opt.ExcludeFile) > 0 { basename := path.Base(x.Remote()) for _, excludeFile := range fi.Opt.ExcludeFile { if basename == excludeFile { excludeDir := parentDir(x.Remote()) toPrune[excludeDir] = true } } } case fs.Directory: inc, err := includeDirectory(x.Remote()) if err != nil { return err } if includeAll || inc { if maxLevel < 0 || slashes <= maxLevel-1 { if slashes == maxLevel-1 { // Just add the object if at maxLevel dirs.Add(x) } else { dirs.AddDir(x) } } } default: return fmt.Errorf("unknown object type %T", entry) } } return nil }) if err != nil { return nil, err } dirs.CheckParents(startPath) if len(dirs) == 0 { dirs[startPath] = nil } err = dirs.Prune(toPrune) if err != nil { return nil, err } dirs.Sort() return dirs, nil } // Create a DirTree using List func walkNDirTree(ctx context.Context, f fs.Fs, path string, includeAll bool, maxLevel int, listDir listDirFunc) (dirtree.DirTree, error) { dirs := make(dirtree.DirTree) fn := func(dirPath string, entries fs.DirEntries, err error) error { if err == nil { dirs[dirPath] = entries } return err } err := walk(ctx, f, path, includeAll, maxLevel, fn, listDir) if err != nil { return nil, err } return dirs, nil } // NewDirTree returns a DirTree filled with the directory listing // using the parameters supplied. // // If includeAll is not set it will use the filters defined. // // If maxLevel is < 0 then it will recurse indefinitely, else it will // only do maxLevel levels. // // This is implemented by WalkR if f supports ListR and level > 1, or // WalkN otherwise. // // If --files-from and --no-traverse is set then a DirTree will be // constructed with just those files in. // // NB (f, path) to be replaced by fs.Dir at some point func NewDirTree(ctx context.Context, f fs.Fs, path string, includeAll bool, maxLevel int) (dirtree.DirTree, error) { ci := fs.GetConfig(ctx) fi := filter.GetConfig(ctx) // if --no-traverse and --files-from build DirTree just from files if ci.NoTraverse && fi.HaveFilesFrom() { return walkRDirTree(ctx, f, path, includeAll, maxLevel, fi.MakeListR(ctx, f.NewObject)) } // if have ListR; and recursing; and not using --files-from; then build a DirTree with ListR if ListR := f.Features().ListR; (maxLevel < 0 || maxLevel > 1) && ListR != nil && !fi.HaveFilesFrom() { return walkRDirTree(ctx, f, path, includeAll, maxLevel, ListR) } // otherwise just use List return walkNDirTree(ctx, f, path, includeAll, maxLevel, list.DirSorted) } func walkR(ctx context.Context, f fs.Fs, path string, includeAll bool, maxLevel int, fn Func, listR fs.ListRFn) error { dirs, err := walkRDirTree(ctx, f, path, includeAll, maxLevel, listR) if err != nil { return err } skipping := false skipPrefix := "" emptyDir := fs.DirEntries{} for _, dirPath := range dirs.Dirs() { if skipping { // Skip over directories as required if strings.HasPrefix(dirPath, skipPrefix) { continue } skipping = false } entries := dirs[dirPath] if entries == nil { entries = emptyDir } err = fn(dirPath, entries, nil) if err == ErrorSkipDir { skipping = true skipPrefix = dirPath if skipPrefix != "" { skipPrefix += "/" } } else if err != nil { return err } } return nil } // GetAll runs ListR getting all the results func GetAll(ctx context.Context, f fs.Fs, path string, includeAll bool, maxLevel int) (objs []fs.Object, dirs []fs.Directory, err error) { err = ListR(ctx, f, path, includeAll, maxLevel, ListAll, func(entries fs.DirEntries) error { for _, entry := range entries { switch x := entry.(type) { case fs.Object: objs = append(objs, x) case fs.Directory: dirs = append(dirs, x) } } return nil }) return } rclone-v1.71.0/fs/walk/walk_test.go000066400000000000000000000544251505210326400171520ustar00rootroot00000000000000package walk import ( "context" "errors" "fmt" "io" "strings" "sync" "testing" "github.com/rclone/rclone/fs" _ "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/filter" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fstest/mockdir" "github.com/rclone/rclone/fstest/mockfs" "github.com/rclone/rclone/fstest/mockobject" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var errDirNotFound, errorBoom error func init() { errDirNotFound = fserrors.FsError(fs.ErrorDirNotFound) fserrors.Count(errDirNotFound) errorBoom = fserrors.FsError(errors.New("boom")) fserrors.Count(errorBoom) } type ( listResult struct { entries fs.DirEntries err error } listResults map[string]listResult errorMap map[string]error listDirs struct { mu sync.Mutex t *testing.T fs fs.Fs includeAll bool results listResults walkResults listResults walkErrors errorMap finalError error checkMaps bool maxLevel int } ) func newListDirs(t *testing.T, f fs.Fs, includeAll bool, results listResults, walkErrors errorMap, finalError error) *listDirs { return &listDirs{ t: t, fs: f, includeAll: includeAll, results: results, walkErrors: walkErrors, walkResults: listResults{}, finalError: finalError, checkMaps: true, maxLevel: -1, } } // NoCheckMaps marks the maps as to be ignored at the end func (ls *listDirs) NoCheckMaps() *listDirs { ls.checkMaps = false return ls } // SetLevel(1) turns off recursion func (ls *listDirs) SetLevel(maxLevel int) *listDirs { ls.maxLevel = maxLevel return ls } // ListDir returns the expected listing for the directory func (ls *listDirs) ListDir(ctx context.Context, f fs.Fs, includeAll bool, dir string) (entries fs.DirEntries, err error) { ls.mu.Lock() defer ls.mu.Unlock() assert.Equal(ls.t, ls.fs, f) assert.Equal(ls.t, ls.includeAll, includeAll) // Fetch results for this path result, ok := ls.results[dir] if !ok { ls.t.Errorf("Unexpected list of %q", dir) return nil, errors.New("unexpected list") } delete(ls.results, dir) // Put expected results for call of WalkFn ls.walkResults[dir] = result return result.entries, result.err } // ListR returns the expected listing for the directory using ListR func (ls *listDirs) ListR(ctx context.Context, dir string, callback fs.ListRCallback) (err error) { ls.mu.Lock() defer ls.mu.Unlock() var errorReturn error for dirPath, result := range ls.results { // Put expected results for call of WalkFn // Note that we don't call the function at all if we got an error if result.err != nil { errorReturn = result.err } if errorReturn == nil { err = callback(result.entries) require.NoError(ls.t, err) ls.walkResults[dirPath] = result } } ls.results = listResults{} return errorReturn } // IsFinished checks everything expected was used up func (ls *listDirs) IsFinished() { if ls.checkMaps { assert.Equal(ls.t, errorMap{}, ls.walkErrors) assert.Equal(ls.t, listResults{}, ls.results) assert.Equal(ls.t, listResults{}, ls.walkResults) } } // WalkFn is called by the walk to test the expectations func (ls *listDirs) WalkFn(dir string, entries fs.DirEntries, err error) error { ls.mu.Lock() defer ls.mu.Unlock() // ls.t.Logf("WalkFn(%q, %v, %q)", dir, entries, err) // Fetch expected entries and err result, ok := ls.walkResults[dir] if !ok { ls.t.Errorf("Unexpected walk of %q (result not found)", dir) return errors.New("result not found") } delete(ls.walkResults, dir) // Check arguments are as expected assert.Equal(ls.t, result.entries, entries) assert.Equal(ls.t, result.err, err) // Fetch return value returnErr, ok := ls.walkErrors[dir] if !ok { ls.t.Errorf("Unexpected walk of %q (error not found)", dir) return errors.New("error not found") } delete(ls.walkErrors, dir) return returnErr } // Walk does the walk and tests the expectations func (ls *listDirs) Walk() { err := walk(context.Background(), nil, "", ls.includeAll, ls.maxLevel, ls.WalkFn, ls.ListDir) assert.True(ls.t, errors.Is(ls.finalError, err)) ls.IsFinished() } // WalkR does the walkR and tests the expectations func (ls *listDirs) WalkR() { err := walkR(context.Background(), nil, "", ls.includeAll, ls.maxLevel, ls.WalkFn, ls.ListR) assert.Equal(ls.t, ls.finalError, err) if ls.finalError == nil { ls.IsFinished() } } func testWalkEmpty(t *testing.T) *listDirs { return newListDirs(t, nil, false, listResults{ "": {entries: fs.DirEntries{}, err: nil}, }, errorMap{ "": nil, }, nil, ) } func TestWalkEmpty(t *testing.T) { testWalkEmpty(t).Walk() } func TestWalkREmpty(t *testing.T) { testWalkEmpty(t).WalkR() } func testWalkEmptySkip(t *testing.T) *listDirs { return newListDirs(t, nil, true, listResults{ "": {entries: fs.DirEntries{}, err: nil}, }, errorMap{ "": ErrorSkipDir, }, nil, ) } func TestWalkEmptySkip(t *testing.T) { testWalkEmptySkip(t).Walk() } func TestWalkREmptySkip(t *testing.T) { testWalkEmptySkip(t).WalkR() } func testWalkNotFound(t *testing.T) *listDirs { return newListDirs(t, nil, true, listResults{ "": {err: errDirNotFound}, }, errorMap{ "": errDirNotFound, }, errDirNotFound, ) } func TestWalkNotFound(t *testing.T) { testWalkNotFound(t).Walk() } func TestWalkRNotFound(t *testing.T) { testWalkNotFound(t).WalkR() } func TestWalkNotFoundMaskError(t *testing.T) { // this doesn't work for WalkR newListDirs(t, nil, true, listResults{ "": {err: errDirNotFound}, }, errorMap{ "": nil, }, nil, ).Walk() } func TestWalkNotFoundSkipError(t *testing.T) { // this doesn't work for WalkR newListDirs(t, nil, true, listResults{ "": {err: errDirNotFound}, }, errorMap{ "": ErrorSkipDir, }, nil, ).Walk() } func testWalkLevels(t *testing.T, maxLevel int) *listDirs { da := mockdir.New("a") oA := mockobject.Object("A") db := mockdir.New("a/b") oB := mockobject.Object("a/B") dc := mockdir.New("a/b/c") oC := mockobject.Object("a/b/C") dd := mockdir.New("a/b/c/d") oD := mockobject.Object("a/b/c/D") return newListDirs(t, nil, false, listResults{ "": {entries: fs.DirEntries{oA, da}, err: nil}, "a": {entries: fs.DirEntries{oB, db}, err: nil}, "a/b": {entries: fs.DirEntries{oC, dc}, err: nil}, "a/b/c": {entries: fs.DirEntries{oD, dd}, err: nil}, "a/b/c/d": {entries: fs.DirEntries{}, err: nil}, }, errorMap{ "": nil, "a": nil, "a/b": nil, "a/b/c": nil, "a/b/c/d": nil, }, nil, ).SetLevel(maxLevel) } func TestWalkLevels(t *testing.T) { testWalkLevels(t, -1).Walk() } func TestWalkRLevels(t *testing.T) { testWalkLevels(t, -1).WalkR() } func TestWalkLevelsNoRecursive10(t *testing.T) { testWalkLevels(t, 10).Walk() } func TestWalkRLevelsNoRecursive10(t *testing.T) { testWalkLevels(t, 10).WalkR() } func TestWalkNDirTree(t *testing.T) { ls := testWalkLevels(t, -1) entries, err := walkNDirTree(context.Background(), nil, "", ls.includeAll, ls.maxLevel, ls.ListDir) require.NoError(t, err) assert.Equal(t, `/ A a/ a/ B b/ a/b/ C c/ a/b/c/ D d/ a/b/c/d/ `, entries.String()) } func testWalkLevelsNoRecursive(t *testing.T) *listDirs { da := mockdir.New("a") oA := mockobject.Object("A") return newListDirs(t, nil, false, listResults{ "": {entries: fs.DirEntries{oA, da}, err: nil}, }, errorMap{ "": nil, }, nil, ).SetLevel(1) } func TestWalkLevelsNoRecursive(t *testing.T) { testWalkLevelsNoRecursive(t).Walk() } func TestWalkRLevelsNoRecursive(t *testing.T) { testWalkLevelsNoRecursive(t).WalkR() } func testWalkLevels2(t *testing.T) *listDirs { da := mockdir.New("a") oA := mockobject.Object("A") db := mockdir.New("a/b") oB := mockobject.Object("a/B") return newListDirs(t, nil, false, listResults{ "": {entries: fs.DirEntries{oA, da}, err: nil}, "a": {entries: fs.DirEntries{oB, db}, err: nil}, }, errorMap{ "": nil, "a": nil, }, nil, ).SetLevel(2) } func TestWalkLevels2(t *testing.T) { testWalkLevels2(t).Walk() } func TestWalkRLevels2(t *testing.T) { testWalkLevels2(t).WalkR() } func testWalkSkip(t *testing.T) *listDirs { da := mockdir.New("a") db := mockdir.New("a/b") dc := mockdir.New("a/b/c") return newListDirs(t, nil, false, listResults{ "": {entries: fs.DirEntries{da}, err: nil}, "a": {entries: fs.DirEntries{db}, err: nil}, "a/b": {entries: fs.DirEntries{dc}, err: nil}, }, errorMap{ "": nil, "a": nil, "a/b": ErrorSkipDir, }, nil, ) } func TestWalkSkip(t *testing.T) { testWalkSkip(t).Walk() } func TestWalkRSkip(t *testing.T) { testWalkSkip(t).WalkR() } func walkErrors(t *testing.T, expectedErr error) *listDirs { lr := listResults{} em := errorMap{} de := make(fs.DirEntries, 10) for i := range de { path := string('0' + rune(i)) de[i] = mockdir.New(path) lr[path] = listResult{entries: nil, err: fs.ErrorDirNotFound} em[path] = fs.ErrorDirNotFound } lr[""] = listResult{entries: de, err: nil} em[""] = nil return newListDirs(t, nil, true, lr, em, expectedErr, ).NoCheckMaps() } func testWalkErrors(t *testing.T) *listDirs { return walkErrors(t, errDirNotFound) } func testWalkRErrors(t *testing.T) *listDirs { return walkErrors(t, fs.ErrorDirNotFound) } func TestWalkErrors(t *testing.T) { testWalkErrors(t).Walk() } func TestWalkRErrors(t *testing.T) { testWalkRErrors(t).WalkR() } func makeTree(level int, terminalErrors bool) (listResults, errorMap) { lr := listResults{} em := errorMap{} var fill func(path string, level int) fill = func(path string, level int) { de := fs.DirEntries{} if level > 0 { for _, a := range "0123456789" { subPath := string(a) if path != "" { subPath = path + "/" + subPath } de = append(de, mockdir.New(subPath)) fill(subPath, level-1) } } lr[path] = listResult{entries: de, err: nil} em[path] = nil if level == 0 && terminalErrors { em[path] = errorBoom } } fill("", level) return lr, em } func testWalkMulti(t *testing.T) *listDirs { lr, em := makeTree(3, false) return newListDirs(t, nil, true, lr, em, nil, ) } func TestWalkMulti(t *testing.T) { testWalkMulti(t).Walk() } func TestWalkRMulti(t *testing.T) { testWalkMulti(t).WalkR() } func testWalkMultiErrors(t *testing.T) *listDirs { lr, em := makeTree(3, true) return newListDirs(t, nil, true, lr, em, errorBoom, ).NoCheckMaps() } func TestWalkMultiErrors(t *testing.T) { testWalkMultiErrors(t).Walk() } func TestWalkRMultiErrors(t *testing.T) { testWalkMultiErrors(t).Walk() } // a very simple listRcallback function func makeListRCallback(entries fs.DirEntries, err error) fs.ListRFn { return func(ctx context.Context, dir string, callback fs.ListRCallback) error { if err == nil { err = callback(entries) } return err } } func TestWalkRDirTree(t *testing.T) { for _, test := range []struct { entries fs.DirEntries want string err error root string level int exclude string }{ { entries: fs.DirEntries{}, want: "/\n", level: -1, }, { entries: fs.DirEntries{mockobject.Object("a")}, want: `/ a `, level: -1, }, { entries: fs.DirEntries{mockobject.Object("a/b")}, want: `/ a/ a/ b `, level: -1, }, { entries: fs.DirEntries{mockobject.Object("a/b/c/d")}, want: `/ a/ a/ b/ a/b/ c/ a/b/c/ d `, level: -1, }, { entries: fs.DirEntries{mockobject.Object("a")}, err: errorBoom, level: -1, }, { entries: fs.DirEntries{ mockobject.Object("0/1/2/3"), mockobject.Object("4/5/6/7"), mockobject.Object("8/9/a/b"), mockobject.Object("c/d/e/f"), mockobject.Object("g/h/i/j"), mockobject.Object("k/l/m/n"), mockobject.Object("o/p/q/r"), mockobject.Object("s/t/u/v"), mockobject.Object("w/x/y/z"), }, want: `/ 0/ 4/ 8/ c/ g/ k/ o/ s/ w/ 0/ 1/ 0/1/ 2/ 0/1/2/ 3 4/ 5/ 4/5/ 6/ 4/5/6/ 7 8/ 9/ 8/9/ a/ 8/9/a/ b c/ d/ c/d/ e/ c/d/e/ f g/ h/ g/h/ i/ g/h/i/ j k/ l/ k/l/ m/ k/l/m/ n o/ p/ o/p/ q/ o/p/q/ r s/ t/ s/t/ u/ s/t/u/ v w/ x/ w/x/ y/ w/x/y/ z `, level: -1, }, { entries: fs.DirEntries{ mockobject.Object("a/b/c/d/e/f1"), mockobject.Object("a/b/c/d/e/f2"), mockobject.Object("a/b/c/d/e/f3"), }, want: `a/b/c/ d/ a/b/c/d/ e/ a/b/c/d/e/ f1 f2 f3 `, root: "a/b/c", level: -1, }, { entries: fs.DirEntries{ mockobject.Object("A"), mockobject.Object("a/B"), mockobject.Object("a/b/C"), mockobject.Object("a/b/c/D"), mockobject.Object("a/b/c/d/E"), }, want: `/ A a/ a/ B b/ a/b/ `, level: 2, }, { entries: fs.DirEntries{ mockobject.Object("a/b/c"), mockobject.Object("a/b/c/d/e"), }, want: `/ a/ a/ b/ a/b/ `, level: 2, }, { entries: fs.DirEntries{ mockobject.Object("a/.bzEmpty"), mockobject.Object("a/b1/.bzEmpty"), mockobject.Object("a/b2/.bzEmpty"), }, want: `/ a/ a/ .bzEmpty b1/ b2/ a/b1/ .bzEmpty a/b2/ .bzEmpty `, level: -1, exclude: ""}, { entries: fs.DirEntries{ mockobject.Object("a/.bzEmpty"), mockobject.Object("a/b1/.bzEmpty"), mockobject.Object("a/b2/.bzEmpty"), }, want: `/ a/ a/ b1/ b2/ a/b1/ a/b2/ `, level: -1, exclude: ".bzEmpty", }, } { ctx := context.Background() if test.exclude != "" { fi, err := filter.NewFilter(nil) require.NoError(t, err) require.NoError(t, fi.Add(false, test.exclude)) // Change the active filter ctx = filter.ReplaceConfig(ctx, fi) } r, err := walkRDirTree(ctx, nil, test.root, test.exclude == "", test.level, makeListRCallback(test.entries, test.err)) what := fmt.Sprintf("%+v", test) assert.Equal(t, test.err, err, what) assert.Equal(t, test.want, r.String(), what) } } func TestWalkRDirTreeExclude(t *testing.T) { ctx := context.Background() fi := filter.GetConfig(ctx) for _, test := range []struct { entries fs.DirEntries want string err error root string level int excludeFile string includeAll bool }{ {fs.DirEntries{mockobject.Object("a"), mockobject.Object("ignore")}, "", nil, "", -1, "ignore", false}, {fs.DirEntries{mockobject.Object("a")}, `/ a `, nil, "", -1, "ignore", false}, {fs.DirEntries{ mockobject.Object("a"), mockobject.Object("b/b"), mockobject.Object("b/.ignore"), }, `/ a `, nil, "", -1, ".ignore", false}, {fs.DirEntries{ mockobject.Object("a"), mockobject.Object("b/.ignore"), mockobject.Object("b/b"), }, `/ a b/ b/ .ignore b `, nil, "", -1, ".ignore", true}, {fs.DirEntries{ mockobject.Object("a"), mockobject.Object("b/b"), mockobject.Object("b/c/d/e"), mockobject.Object("b/c/ign"), mockobject.Object("b/c/x"), }, `/ a b/ b/ b `, nil, "", -1, "ign", false}, {fs.DirEntries{ mockobject.Object("a"), mockobject.Object("b/b"), mockobject.Object("b/c/d/e"), mockobject.Object("b/c/ign"), mockobject.Object("b/c/x"), }, `/ a b/ b/ b c/ b/c/ d/ ign x b/c/d/ e `, nil, "", -1, "ign", true}, } { fi.Opt.ExcludeFile = []string{test.excludeFile} r, err := walkRDirTree(context.Background(), nil, test.root, test.includeAll, test.level, makeListRCallback(test.entries, test.err)) assert.Equal(t, test.err, err, fmt.Sprintf("%+v", test)) assert.Equal(t, test.want, r.String(), fmt.Sprintf("%+v", test)) } // Set to default value, to avoid side effects fi.Opt.ExcludeFile = nil } func TestListType(t *testing.T) { assert.Equal(t, true, ListObjects.Objects()) assert.Equal(t, false, ListObjects.Dirs()) assert.Equal(t, false, ListDirs.Objects()) assert.Equal(t, true, ListDirs.Dirs()) assert.Equal(t, true, ListAll.Objects()) assert.Equal(t, true, ListAll.Dirs()) var ( a = mockobject.Object("a") b = mockobject.Object("b") dir = mockdir.New("dir") adir = mockobject.Object("dir/a") dir2 = mockdir.New("dir2") origEntries = fs.DirEntries{ a, b, dir, adir, dir2, } dirEntries = fs.DirEntries{ dir, dir2, } objEntries = fs.DirEntries{ a, b, adir, } ) copyOrigEntries := func() (out fs.DirEntries) { out = make(fs.DirEntries, len(origEntries)) copy(out, origEntries) return out } got := copyOrigEntries() ListAll.Filter(&got) assert.Equal(t, origEntries, got) got = copyOrigEntries() ListObjects.Filter(&got) assert.Equal(t, objEntries, got) got = copyOrigEntries() ListDirs.Filter(&got) assert.Equal(t, dirEntries, got) } func TestListR(t *testing.T) { ctx := context.Background() objects := fs.DirEntries{ mockobject.Object("a"), mockobject.Object("b"), mockdir.New("dir"), mockobject.Object("dir/a"), mockobject.Object("dir/b"), mockobject.Object("dir/c"), } f, err := mockfs.NewFs(ctx, "mock", "/", nil) require.NoError(t, err) var got []string clearCallback := func() { got = nil } callback := func(entries fs.DirEntries) error { for _, entry := range entries { got = append(got, entry.Remote()) } return nil } doListR := func(ctx context.Context, dir string, callback fs.ListRCallback) error { var os fs.DirEntries for _, o := range objects { if dir == "" || strings.HasPrefix(o.Remote(), dir+"/") { os = append(os, o) } } return callback(os) } fi, err := filter.NewFilter(nil) require.NoError(t, err) require.NoError(t, fi.AddRule("+ b")) require.NoError(t, fi.AddRule("- *")) // Change the active filter ctx = filter.ReplaceConfig(ctx, fi) // Base case clearCallback() err = listR(ctx, f, "", true, ListAll, callback, doListR, false) require.NoError(t, err) require.Equal(t, []string{"a", "b", "dir", "dir/a", "dir/b", "dir/c"}, got) // Base case - with Objects clearCallback() err = listR(ctx, f, "", true, ListObjects, callback, doListR, false) require.NoError(t, err) require.Equal(t, []string{"a", "b", "dir/a", "dir/b", "dir/c"}, got) // Base case - with Dirs clearCallback() err = listR(ctx, f, "", true, ListDirs, callback, doListR, false) require.NoError(t, err) require.Equal(t, []string{"dir"}, got) // With filter clearCallback() err = listR(ctx, f, "", false, ListAll, callback, doListR, false) require.NoError(t, err) require.Equal(t, []string{"b", "dir", "dir/b"}, got) // With filter - with Objects clearCallback() err = listR(ctx, f, "", false, ListObjects, callback, doListR, false) require.NoError(t, err) require.Equal(t, []string{"b", "dir/b"}, got) // With filter - with Dir clearCallback() err = listR(ctx, f, "", false, ListDirs, callback, doListR, false) require.NoError(t, err) require.Equal(t, []string{"dir"}, got) // With filter and subdir clearCallback() err = listR(ctx, f, "dir", false, ListAll, callback, doListR, false) require.NoError(t, err) require.Equal(t, []string{"dir/b"}, got) // Now bucket-based objects = fs.DirEntries{ mockobject.Object("a"), mockobject.Object("b"), mockobject.Object("dir/a"), mockobject.Object("dir/b"), mockobject.Object("dir/subdir/c"), mockdir.New("dir/subdir"), } // Base case clearCallback() err = listR(ctx, f, "", true, ListAll, callback, doListR, true) require.NoError(t, err) require.Equal(t, []string{"a", "b", "dir/a", "dir/b", "dir/subdir/c", "dir/subdir", "dir"}, got) // With filter clearCallback() err = listR(ctx, f, "", false, ListAll, callback, doListR, true) require.NoError(t, err) require.Equal(t, []string{"b", "dir/b", "dir/subdir", "dir"}, got) // With filter and subdir clearCallback() err = listR(ctx, f, "dir", false, ListAll, callback, doListR, true) require.NoError(t, err) require.Equal(t, []string{"dir/b", "dir/subdir"}, got) // With filter and subdir - with Objects clearCallback() err = listR(ctx, f, "dir", false, ListObjects, callback, doListR, true) require.NoError(t, err) require.Equal(t, []string{"dir/b"}, got) // With filter and subdir - with Dirs clearCallback() err = listR(ctx, f, "dir", false, ListDirs, callback, doListR, true) require.NoError(t, err) require.Equal(t, []string{"dir/subdir"}, got) } func TestDirMapAdd(t *testing.T) { type add struct { dir string sent bool } for i, test := range []struct { root string in []add want map[string]bool }{ { root: "", in: []add{ {"", true}, }, want: map[string]bool{}, }, { root: "", in: []add{ {"a/b/c", true}, }, want: map[string]bool{ "a/b/c": true, "a/b": false, "a": false, }, }, { root: "", in: []add{ {"a/b/c", true}, {"a/b", true}, }, want: map[string]bool{ "a/b/c": true, "a/b": true, "a": false, }, }, { root: "", in: []add{ {"a/b", true}, {"a/b/c", false}, }, want: map[string]bool{ "a/b/c": false, "a/b": true, "a": false, }, }, { root: "root", in: []add{ {"root/a/b", true}, {"root/a/b/c", false}, }, want: map[string]bool{ "root/a/b/c": false, "root/a/b": true, "root/a": false, }, }, } { t.Run(fmt.Sprintf("%d", i), func(t *testing.T) { dm := newDirMap(test.root) for _, item := range test.in { dm.add(item.dir, item.sent) } assert.Equal(t, test.want, dm.m) }) } } func TestDirMapAddEntries(t *testing.T) { dm := newDirMap("") entries := fs.DirEntries{ mockobject.Object("dir/a"), mockobject.Object("dir/b"), mockdir.New("dir"), mockobject.Object("dir2/a"), mockobject.Object("dir2/b"), } require.NoError(t, dm.addEntries(entries)) assert.Equal(t, map[string]bool{"dir": true, "dir2": false}, dm.m) } func TestDirMapSendEntries(t *testing.T) { var got []string clearCallback := func() { got = nil } callback := func(entries fs.DirEntries) error { for _, entry := range entries { got = append(got, entry.Remote()) } return nil } // general test dm := newDirMap("") entries := fs.DirEntries{ mockobject.Object("dir/a"), mockobject.Object("dir/b"), mockdir.New("dir"), mockobject.Object("dir2/a"), mockobject.Object("dir2/b"), mockobject.Object("dir1/a"), mockobject.Object("dir3/b"), } require.NoError(t, dm.addEntries(entries)) clearCallback() err := dm.sendEntries(callback) require.NoError(t, err) assert.Equal(t, []string{ "dir1", "dir2", "dir3", }, got) // return error from callback callback2 := func(entries fs.DirEntries) error { return io.EOF } err = dm.sendEntries(callback2) require.Equal(t, io.EOF, err) // empty dm = newDirMap("") clearCallback() err = dm.sendEntries(callback) require.NoError(t, err) assert.Equal(t, []string(nil), got) } rclone-v1.71.0/fstest/000077500000000000000000000000001505210326400145565ustar00rootroot00000000000000rclone-v1.71.0/fstest/fstest.go000066400000000000000000000472621505210326400164300ustar00rootroot00000000000000// Package fstest provides utilities for testing the Fs package fstest // FIXME put name of test FS in Fs structure import ( "bytes" "compress/gzip" "context" "flag" "fmt" "io" "os" "path" "path/filepath" "regexp" "runtime" "sort" "strings" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/accounting" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configfile" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/log" "github.com/rclone/rclone/fs/walk" "github.com/rclone/rclone/fstest/testy" "github.com/rclone/rclone/lib/random" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "golang.org/x/text/unicode/norm" ) // Globals var ( RemoteName = flag.String("remote", "", "Remote to test with, defaults to local filesystem") Verbose = flag.Bool("verbose", false, "Set to enable logging") DumpHeaders = flag.Bool("dump-headers", false, "Set to dump headers (needs -verbose)") DumpBodies = flag.Bool("dump-bodies", false, "Set to dump bodies (needs -verbose)") Individual = flag.Bool("individual", false, "Make individual bucket/container/directory for each test - much slower") LowLevelRetries = flag.Int("low-level-retries", 10, "Number of low level retries") UseListR = flag.Bool("fast-list", false, "Use recursive list if available. Uses more memory but fewer transactions.") // SizeLimit signals tests to skip maximum test file size and skip inappropriate runs SizeLimit = flag.Int64("size-limit", 0, "Limit maximum test file size") // ListRetries is the number of times to retry a listing to overcome eventual consistency ListRetries = flag.Int("list-retries", 3, "Number or times to retry listing") // MatchTestRemote matches the remote names used for testing MatchTestRemote = regexp.MustCompile(`^rclone-test-[abcdefghijklmnopqrstuvwxyz0123456789]{12}$`) ) // Initialise rclone for testing func Initialise() { ctx := context.Background() ci := fs.GetConfig(ctx) // Never ask for passwords, fail instead. // If your local config is encrypted set environment variable // "RCLONE_CONFIG_PASS=hunter2" (or your password) ci.AskPassword = false // Override the config file from the environment - we don't // parse the flags any more so this doesn't happen // automatically if envConfig := os.Getenv("RCLONE_CONFIG"); envConfig != "" { _ = config.SetConfigPath(envConfig) } configfile.Install() accounting.Start(ctx) if *Verbose { ci.LogLevel = fs.LogLevelDebug } if *DumpHeaders { ci.Dump |= fs.DumpHeaders } if *DumpBodies { ci.Dump |= fs.DumpBodies } ci.LowLevelRetries = *LowLevelRetries ci.UseListR = *UseListR log.InitLogging() _ = fs.LogReload(ci) } // Item represents an item for checking type Item struct { Path string Hashes map[hash.Type]string ModTime time.Time Size int64 } // NewItem creates an item from a string content func NewItem(Path, Content string, modTime time.Time) Item { i := Item{ Path: Path, ModTime: modTime, Size: int64(len(Content)), } hash := hash.NewMultiHasher() buf := bytes.NewBufferString(Content) _, err := io.Copy(hash, buf) if err != nil { fs.Fatalf(nil, "Failed to create item: %v", err) } i.Hashes = hash.Sums() return i } // CheckTimeEqualWithPrecision checks the times are equal within the // precision, returns the delta and a flag func CheckTimeEqualWithPrecision(t0, t1 time.Time, precision time.Duration) (time.Duration, bool) { dt := t0.Sub(t1) if dt >= precision || dt <= -precision { return dt, false } return dt, true } // AssertTimeEqualWithPrecision checks that want is within precision // of got, asserting that with t and logging remote func AssertTimeEqualWithPrecision(t *testing.T, remote string, want, got time.Time, precision time.Duration) { dt, ok := CheckTimeEqualWithPrecision(want, got, precision) assert.True(t, ok, fmt.Sprintf("%s: Modification time difference too big |%s| > %s (want %s vs got %s) (precision %s)", remote, dt, precision, want, got, precision)) } // CheckModTime checks the mod time to the given precision func (i *Item) CheckModTime(t *testing.T, obj fs.Object, modTime time.Time, precision time.Duration) { AssertTimeEqualWithPrecision(t, obj.Remote(), i.ModTime, modTime, precision) } // CheckHashes checks all the hashes the object supports are correct func (i *Item) CheckHashes(t *testing.T, obj fs.Object) { require.NotNil(t, obj) types := obj.Fs().Hashes().Array() for _, Hash := range types { // Check attributes sum, err := obj.Hash(context.Background(), Hash) require.NoError(t, err) assert.True(t, hash.Equals(i.Hashes[Hash], sum), fmt.Sprintf("%s/%s: %v hash incorrect - expecting %q got %q", obj.Fs().String(), obj.Remote(), Hash, i.Hashes[Hash], sum)) } } // Check checks all the attributes of the object are correct func (i *Item) Check(t *testing.T, obj fs.Object, precision time.Duration) { i.CheckHashes(t, obj) assert.Equal(t, i.Size, obj.Size(), fmt.Sprintf("%s: size incorrect file=%d vs obj=%d", i.Path, i.Size, obj.Size())) i.CheckModTime(t, obj, obj.ModTime(context.Background()), precision) } // Normalize runs a utf8 normalization on the string if running on OS // X. This is because OS X denormalizes file names it writes to the // local file system. func Normalize(name string) string { if runtime.GOOS == "darwin" { name = norm.NFC.String(name) } return name } // Items represents all items for checking type Items struct { byName map[string]*Item byNameAlt map[string]*Item items []Item } // NewItems makes an Items func NewItems(items []Item) *Items { is := &Items{ byName: make(map[string]*Item), byNameAlt: make(map[string]*Item), items: items, } // Fill up byName for i := range items { is.byName[Normalize(items[i].Path)] = &items[i] } return is } // Find checks off an item func (is *Items) Find(t *testing.T, obj fs.Object, precision time.Duration) { remote := Normalize(obj.Remote()) i, ok := is.byName[remote] if !ok { i, ok = is.byNameAlt[remote] assert.True(t, ok, fmt.Sprintf("Unexpected file %q", remote)) } if i != nil { delete(is.byName, i.Path) i.Check(t, obj, precision) } } // Done checks all finished func (is *Items) Done(t *testing.T) { if len(is.byName) != 0 { for name := range is.byName { t.Logf("Not found %q", name) } } assert.Equal(t, 0, len(is.byName), fmt.Sprintf("%d objects not found", len(is.byName))) } // makeListingFromItems returns a string representation of the items // // it returns two possible strings, one normal and one for windows func makeListingFromItems(items []Item) string { nameLengths := make([]string, len(items)) for i, item := range items { remote := Normalize(item.Path) nameLengths[i] = fmt.Sprintf("%s (%d)", remote, item.Size) } sort.Strings(nameLengths) return strings.Join(nameLengths, ", ") } // makeListingFromObjects returns a string representation of the objects func makeListingFromObjects(objs []fs.Object) string { nameLengths := make([]string, len(objs)) for i, obj := range objs { nameLengths[i] = fmt.Sprintf("%s (%d)", Normalize(obj.Remote()), obj.Size()) } sort.Strings(nameLengths) return strings.Join(nameLengths, ", ") } // filterEmptyDirs removes any empty (or containing only directories) // directories from expectedDirs func filterEmptyDirs(t *testing.T, items []Item, expectedDirs []string) (newExpectedDirs []string) { dirs := map[string]struct{}{"": {}} for _, item := range items { base := item.Path for { base = path.Dir(base) if base == "." || base == "/" { break } dirs[base] = struct{}{} } } for _, expectedDir := range expectedDirs { if _, found := dirs[expectedDir]; found { newExpectedDirs = append(newExpectedDirs, expectedDir) } else { t.Logf("Filtering empty directory %q", expectedDir) } } return newExpectedDirs } // CheckListingWithRoot checks the fs to see if it has the // expected contents with the given precision. // // If expectedDirs is non nil then we check those too. Note that no // directories returned is also OK as some remotes don't return // directories. // // dir is the directory used for the listing. func CheckListingWithRoot(t *testing.T, f fs.Fs, dir string, items []Item, expectedDirs []string, precision time.Duration) { if expectedDirs != nil && !f.Features().CanHaveEmptyDirectories { expectedDirs = filterEmptyDirs(t, items, expectedDirs) } is := NewItems(items) ctx := context.Background() oldErrors := accounting.Stats(ctx).GetErrors() var objs []fs.Object var dirs []fs.Directory var err error retries := *ListRetries sleep := time.Second / 2 wantListing := makeListingFromItems(items) gotListing := "" listingOK := false for i := 1; i <= retries; i++ { objs, dirs, err = walk.GetAll(ctx, f, dir, true, -1) if err != nil && err != fs.ErrorDirNotFound { t.Fatalf("Error listing: %v", err) } gotListing = makeListingFromObjects(objs) listingOK = wantListing == gotListing if listingOK && (expectedDirs == nil || len(dirs) == len(expectedDirs)) { // Put an extra sleep in if we did any retries just to make sure it really // is consistent if i != 1 { extraSleep := 5*time.Second + sleep t.Logf("Sleeping for %v just to make sure", extraSleep) time.Sleep(extraSleep) } break } sleep *= 2 t.Logf("Sleeping for %v for list eventual consistency: %d/%d", sleep, i, retries) time.Sleep(sleep) if doDirCacheFlush := f.Features().DirCacheFlush; doDirCacheFlush != nil { t.Logf("Flushing the directory cache") doDirCacheFlush() } } assert.True(t, listingOK, fmt.Sprintf("listing wrong, want\n %s got\n %s", wantListing, gotListing)) for _, obj := range objs { require.NotNil(t, obj) is.Find(t, obj, precision) } is.Done(t) // Don't notice an error when listing an empty directory if len(items) == 0 && oldErrors == 0 && accounting.Stats(ctx).GetErrors() == 1 { accounting.Stats(ctx).ResetErrors() } // Check the directories if expectedDirs != nil { expectedDirsCopy := make([]string, len(expectedDirs)) for i, dir := range expectedDirs { expectedDirsCopy[i] = Normalize(dir) } actualDirs := []string{} for _, dir := range dirs { actualDirs = append(actualDirs, Normalize(dir.Remote())) } sort.Strings(actualDirs) sort.Strings(expectedDirsCopy) assert.Equal(t, expectedDirsCopy, actualDirs, "directories") } } // CheckListingWithPrecision checks the fs to see if it has the // expected contents with the given precision. // // If expectedDirs is non nil then we check those too. Note that no // directories returned is also OK as some remotes don't return // directories. func CheckListingWithPrecision(t *testing.T, f fs.Fs, items []Item, expectedDirs []string, precision time.Duration) { CheckListingWithRoot(t, f, "", items, expectedDirs, precision) } // CheckListing checks the fs to see if it has the expected contents func CheckListing(t *testing.T, f fs.Fs, items []Item) { precision := f.Precision() CheckListingWithPrecision(t, f, items, nil, precision) } // CheckItemsWithPrecision checks the fs with the specified precision // to see if it has the expected items. func CheckItemsWithPrecision(t *testing.T, f fs.Fs, precision time.Duration, items ...Item) { CheckListingWithPrecision(t, f, items, nil, precision) } // CheckItems checks the fs to see if it has only the items passed in // using a precision of fs.Config.ModifyWindow func CheckItems(t *testing.T, f fs.Fs, items ...Item) { CheckListingWithPrecision(t, f, items, nil, fs.GetModifyWindow(context.TODO(), f)) } // CompareItems compares a set of DirEntries to a slice of items and a list of dirs // The modtimes are compared with the precision supplied func CompareItems(t *testing.T, entries fs.DirEntries, items []Item, expectedDirs []string, precision time.Duration, what string) { is := NewItems(items) var objs []fs.Object var dirs []fs.Directory wantListing := makeListingFromItems(items) for _, entry := range entries { switch x := entry.(type) { case fs.Directory: dirs = append(dirs, x) case fs.Object: objs = append(objs, x) // do nothing default: t.Fatalf("unknown object type %T", entry) } } gotListing := makeListingFromObjects(objs) listingOK := wantListing == gotListing assert.True(t, listingOK, fmt.Sprintf("%s not equal, want\n %s got\n %s", what, wantListing, gotListing)) for _, obj := range objs { require.NotNil(t, obj) is.Find(t, obj, precision) } is.Done(t) // Check the directories if expectedDirs != nil { expectedDirsCopy := make([]string, len(expectedDirs)) for i, dir := range expectedDirs { expectedDirsCopy[i] = Normalize(dir) } actualDirs := []string{} for _, dir := range dirs { actualDirs = append(actualDirs, Normalize(dir.Remote())) } sort.Strings(actualDirs) sort.Strings(expectedDirsCopy) assert.Equal(t, expectedDirsCopy, actualDirs, "directories not equal") } } // Time parses a time string or logs a fatal error func Time(timeString string) time.Time { t, err := time.Parse(time.RFC3339Nano, timeString) if err != nil { fs.Fatalf(nil, "Failed to parse time %q: %v", timeString, err) } return t } // LocalRemote creates a temporary directory name for local remotes func LocalRemote() (path string, err error) { path, err = os.MkdirTemp("", "rclone") if err == nil { // Now remove the directory err = os.Remove(path) } path = filepath.ToSlash(path) return } // RandomRemoteName makes a random bucket or subdirectory name // // Returns a random remote name plus the leaf name func RandomRemoteName(remoteName string) (string, string, error) { var err error var leafName string // Make a directory if remote name is null if remoteName == "" { remoteName, err = LocalRemote() if err != nil { return "", "", err } } else { if !strings.HasSuffix(remoteName, ":") { remoteName += "/" } leafName = "rclone-test-" + random.String(12) if !MatchTestRemote.MatchString(leafName) { fs.Fatalf(nil, "%q didn't match the test remote name regexp", leafName) } remoteName += leafName } return remoteName, leafName, nil } // RandomRemote makes a random bucket or subdirectory on the remote // from the -remote parameter // // Call the finalise function returned to Purge the fs at the end (and // the parent if necessary) // // Returns the remote, its url, a finaliser and an error func RandomRemote() (fs.Fs, string, func(), error) { var err error var parentRemote fs.Fs remoteName := *RemoteName remoteName, _, err = RandomRemoteName(remoteName) if err != nil { return nil, "", nil, err } remote, err := fs.NewFs(context.Background(), remoteName) if err != nil { return nil, "", nil, err } finalise := func() { Purge(remote) if parentRemote != nil { Purge(parentRemote) if err != nil { fs.Logf(nil, "Failed to purge %v: %v", parentRemote, err) } } } return remote, remoteName, finalise, nil } // Purge is a simplified re-implementation of operations.Purge for the // test routine cleanup to avoid circular dependencies. // // It logs errors rather than returning them func Purge(f fs.Fs) { ctx := context.Background() var err error doFallbackPurge := true if doPurge := f.Features().Purge; doPurge != nil { doFallbackPurge = false fs.Debugf(f, "Purge remote") err = doPurge(ctx, "") if err == fs.ErrorCantPurge { doFallbackPurge = true } } if doFallbackPurge { dirs := []string{""} err = walk.ListR(ctx, f, "", true, -1, walk.ListAll, func(entries fs.DirEntries) error { var err error entries.ForObject(func(obj fs.Object) { fs.Debugf(f, "Purge object %q", obj.Remote()) err = obj.Remove(ctx) if err != nil { fs.Logf(nil, "purge failed to remove %q: %v", obj.Remote(), err) } }) entries.ForDir(func(dir fs.Directory) { dirs = append(dirs, dir.Remote()) }) return nil }) sort.Strings(dirs) for i := len(dirs) - 1; i >= 0; i-- { dir := dirs[i] fs.Debugf(f, "Purge dir %q", dir) err := f.Rmdir(ctx, dir) if err != nil { fs.Logf(nil, "purge failed to rmdir %q: %v", dir, err) } } } if err != nil { fs.Logf(nil, "purge failed: %v", err) } } // NewObject finds the object on the remote func NewObject(ctx context.Context, t *testing.T, f fs.Fs, remote string) fs.Object { var obj fs.Object var err error sleepTime := 1 * time.Second for i := 1; i <= *ListRetries; i++ { obj, err = f.NewObject(ctx, remote) if err == nil { break } t.Logf("Sleeping for %v for findObject eventual consistency: %d/%d (%v)", sleepTime, i, *ListRetries, err) time.Sleep(sleepTime) sleepTime = (sleepTime * 3) / 2 } require.NoError(t, err) return obj } // NewDirectoryRetries finds the directory with remote in f // // If directory can't be found it returns an error wrapping fs.ErrorDirNotFound // // One day this will be an rclone primitive func NewDirectoryRetries(ctx context.Context, t *testing.T, f fs.Fs, remote string, retries int) (fs.Directory, error) { var err error var dir fs.Directory sleepTime := 1 * time.Second root := path.Dir(remote) if root == "." { root = "" } for i := 1; i <= retries; i++ { var entries fs.DirEntries entries, err = f.List(ctx, root) if err != nil { continue } for _, entry := range entries { var ok bool dir, ok = entry.(fs.Directory) if ok && dir.Remote() == remote { return dir, nil } } err = fmt.Errorf("directory %q not found in %q: %w", remote, root, fs.ErrorDirNotFound) if i < retries { t.Logf("Sleeping for %v for NewDirectoryRetries eventual consistency: %d/%d (%v)", sleepTime, i, retries, err) time.Sleep(sleepTime) sleepTime = (sleepTime * 3) / 2 } } return dir, err } // NewDirectory finds the directory with remote in f // // One day this will be an rclone primitive func NewDirectory(ctx context.Context, t *testing.T, f fs.Fs, remote string) fs.Directory { dir, err := NewDirectoryRetries(ctx, t, f, remote, *ListRetries) require.NoError(t, err) return dir } // CheckEntryMetadata checks the metadata on the directory // // This checks a limited set of metadata on the directory func CheckEntryMetadata(ctx context.Context, t *testing.T, f fs.Fs, entry fs.DirEntry, wantMeta fs.Metadata) { features := f.Features() do, ok := entry.(fs.Metadataer) require.True(t, ok, "Didn't find expected Metadata() method on %T", entry) gotMeta, err := do.Metadata(ctx) require.NoError(t, err) for k, v := range wantMeta { switch k { case "mtime", "atime", "btime", "ctime": // Check the system time Metadata wantT, err := time.Parse(time.RFC3339, v) require.NoError(t, err) gotT, err := time.Parse(time.RFC3339, gotMeta[k]) require.NoError(t, err) AssertTimeEqualWithPrecision(t, entry.Remote(), wantT, gotT, f.Precision()) default: // Check the User metadata if we can _, isDir := entry.(fs.Directory) if (isDir && features.UserDirMetadata) || (!isDir && features.UserMetadata) { assert.Equal(t, v, gotMeta[k]) } } } } // CheckDirModTime checks the modtime on the directory func CheckDirModTime(ctx context.Context, t *testing.T, f fs.Fs, dir fs.Directory, wantT time.Time) { if f.Features().DirSetModTime == nil && f.Features().MkdirMetadata == nil { fs.Debugf(f, "Skipping modtime test as remote does not support DirSetModTime or MkdirMetadata") return } gotT := dir.ModTime(ctx) precision := f.Precision() // For unknown reasons the precision of modification times of // directories on the CI is about >15mS. The tests work fine // when run in Virtualbox though so I conjecture this is // something to do with the file system used there. if runtime.GOOS == "windows" && testy.CI() { precision = 100 * time.Millisecond } AssertTimeEqualWithPrecision(t, dir.Remote(), wantT, gotT, precision) } // Gz returns a compressed version of its input string func Gz(t *testing.T, s string) string { var buf bytes.Buffer zw := gzip.NewWriter(&buf) _, err := zw.Write([]byte(s)) require.NoError(t, err) err = zw.Close() require.NoError(t, err) return buf.String() } rclone-v1.71.0/fstest/fstests/000077500000000000000000000000001505210326400162515ustar00rootroot00000000000000rclone-v1.71.0/fstest/fstests/fstests.go000066400000000000000000002723511505210326400203050ustar00rootroot00000000000000// Package fstests provides generic integration tests for the Fs and // Object interfaces. // // These tests are concerned with the basic functionality of a // backend. The tests in fs/sync and fs/operations tests more // cornercases that these tests don't. package fstests import ( "bytes" "context" "errors" "fmt" "io" "math/bits" "os" "path" "path/filepath" "reflect" "slices" "sort" "strconv" "strings" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/fspath" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/object" "github.com/rclone/rclone/fs/operations" "github.com/rclone/rclone/fs/walk" "github.com/rclone/rclone/fstest" "github.com/rclone/rclone/fstest/testserver" "github.com/rclone/rclone/lib/encoder" "github.com/rclone/rclone/lib/random" "github.com/rclone/rclone/lib/readers" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // InternalTester is an optional interface for Fs which allows to execute internal tests // // This interface should be implemented in 'backend'_internal_test.go and not in 'backend'.go type InternalTester interface { InternalTest(*testing.T) } // ChunkedUploadConfig contains the values used by TestFsPutChunked // to determine the limits of chunked uploading type ChunkedUploadConfig struct { // Minimum allowed chunk size MinChunkSize fs.SizeSuffix // Maximum allowed chunk size, 0 is no limit MaxChunkSize fs.SizeSuffix // Rounds the given chunk size up to the next valid value // nil will disable rounding // e.g. the next power of 2 CeilChunkSize func(fs.SizeSuffix) fs.SizeSuffix // More than one chunk is required on upload NeedMultipleChunks bool // Skip this particular remote Skip bool } // SetUploadChunkSizer is a test only interface to change the upload chunk size at runtime type SetUploadChunkSizer interface { // Change the configured UploadChunkSize. // Will only be called while no transfer is in progress. SetUploadChunkSize(fs.SizeSuffix) (fs.SizeSuffix, error) } // SetUploadCutoffer is a test only interface to change the upload cutoff size at runtime type SetUploadCutoffer interface { // Change the configured UploadCutoff. // Will only be called while no transfer is in progress. SetUploadCutoff(fs.SizeSuffix) (fs.SizeSuffix, error) } // SetCopyCutoffer is a test only interface to change the copy cutoff size at runtime type SetCopyCutoffer interface { // Change the configured CopyCutoff. // Will only be called while no transfer is in progress. // Return fs.ErrorNotImplemented if you can't implement this SetCopyCutoff(fs.SizeSuffix) (fs.SizeSuffix, error) } // NextPowerOfTwo returns the current or next bigger power of two. // All values less or equal 0 will return 0 func NextPowerOfTwo(i fs.SizeSuffix) fs.SizeSuffix { return 1 << uint(64-bits.LeadingZeros64(uint64(i)-1)) } // NextMultipleOf returns a function that can be used as a CeilChunkSize function. // This function will return the next multiple of m that is equal or bigger than i. // All values less or equal 0 will return 0. func NextMultipleOf(m fs.SizeSuffix) func(fs.SizeSuffix) fs.SizeSuffix { if m <= 0 { panic(fmt.Sprintf("invalid multiplier %s", m)) } return func(i fs.SizeSuffix) fs.SizeSuffix { if i <= 0 { return 0 } return (((i - 1) / m) + 1) * m } } // dirsToNames returns a sorted list of names func dirsToNames(dirs []fs.Directory) []string { names := []string{} for _, dir := range dirs { names = append(names, fstest.Normalize(dir.Remote())) } sort.Strings(names) return names } // objsToNames returns a sorted list of object names func objsToNames(objs []fs.Object) []string { names := []string{} for _, obj := range objs { names = append(names, fstest.Normalize(obj.Remote())) } sort.Strings(names) return names } // retry f() until no retriable error func retry(t *testing.T, what string, f func() error) { const maxTries = 10 var err error for tries := 1; tries <= maxTries; tries++ { err = f() // exit if no error, or error is not retriable if err == nil || !fserrors.IsRetryError(err) { break } t.Logf("%s error: %v - low level retry %d/%d", what, err, tries, maxTries) time.Sleep(2 * time.Second) } require.NoError(t, err, what) } // check interface // PutTestContentsMetadata puts file with given contents to the remote and checks it but unlike TestPutLarge doesn't remove // // It uploads the object with the mimeType and metadata passed in if set. // // It returns the object which will have been checked if check is set func PutTestContentsMetadata(ctx context.Context, t *testing.T, f fs.Fs, file *fstest.Item, useFileHashes bool, contents string, check bool, mimeType string, metadata fs.Metadata, options ...fs.OpenOption) fs.Object { var ( err error obj fs.Object uploadHash *hash.MultiHasher ) retry(t, "Put", func() error { buf := bytes.NewBufferString(contents) uploadHash = hash.NewMultiHasher() in := io.TeeReader(buf, uploadHash) file.Size = int64(buf.Len()) // The caller explicitly indicates whether the hashes in the file parameter should be used. If hashes is nil, // then NewStaticObjectInfo will calculate default hashes for use in the check. hashes := file.Hashes if !useFileHashes { hashes = nil } obji := object.NewStaticObjectInfo(file.Path, file.ModTime, file.Size, true, hashes, nil) if mimeType != "" || metadata != nil { // force the --metadata flag on temporarily if metadata != nil { ci := fs.GetConfig(ctx) previousMetadata := ci.Metadata ci.Metadata = true defer func() { ci.Metadata = previousMetadata }() } obji.WithMetadata(metadata).WithMimeType(mimeType) } obj, err = f.Put(ctx, in, obji, options...) return err }) file.Hashes = uploadHash.Sums() if check { // Overwrite time with that in metadata if it is already specified mtime, ok := metadata["mtime"] if ok { modTime, err := time.Parse(time.RFC3339Nano, mtime) require.NoError(t, err) file.ModTime = modTime } file.Check(t, obj, f.Precision()) // Re-read the object and check again obj = fstest.NewObject(ctx, t, f, file.Path) file.Check(t, obj, f.Precision()) } return obj } // PutTestContents puts file with given contents to the remote and checks it but unlike TestPutLarge doesn't remove func PutTestContents(ctx context.Context, t *testing.T, f fs.Fs, file *fstest.Item, contents string, check bool) fs.Object { return PutTestContentsMetadata(ctx, t, f, file, false, contents, check, "", nil) } // testPut puts file with random contents to the remote func testPut(ctx context.Context, t *testing.T, f fs.Fs, file *fstest.Item) (string, fs.Object) { return testPutMimeType(ctx, t, f, file, "", nil) } // testPutMimeType puts file with random contents to the remote and the mime type given func testPutMimeType(ctx context.Context, t *testing.T, f fs.Fs, file *fstest.Item, mimeType string, metadata fs.Metadata) (string, fs.Object) { contents := random.String(100) // We just generated new contents, but file may contain hashes generated by a previous operation if len(file.Hashes) > 0 { file.Hashes = make(map[hash.Type]string) } return contents, PutTestContentsMetadata(ctx, t, f, file, false, contents, true, mimeType, metadata) } // testPutLarge puts file to the remote, checks it and removes it on success. // // If stream is set, then it uploads the file with size -1 func testPutLarge(ctx context.Context, t *testing.T, f fs.Fs, file *fstest.Item, stream bool) { var ( err error obj fs.Object uploadHash *hash.MultiHasher ) retry(t, "PutLarge", func() error { r := readers.NewPatternReader(file.Size) uploadHash = hash.NewMultiHasher() in := io.TeeReader(r, uploadHash) size := file.Size if stream { size = -1 } obji := object.NewStaticObjectInfo(file.Path, file.ModTime, size, true, nil, nil) obj, err = f.Put(ctx, in, obji) if file.Size == 0 && err == fs.ErrorCantUploadEmptyFiles { t.Skip("Can't upload zero length files") } return err }) file.Hashes = uploadHash.Sums() file.Check(t, obj, f.Precision()) // Re-read the object and check again obj = fstest.NewObject(ctx, t, f, file.Path) file.Check(t, obj, f.Precision()) // Download the object and check it is OK downloadHash := hash.NewMultiHasher() download, err := obj.Open(ctx) require.NoError(t, err) n, err := io.Copy(downloadHash, download) require.NoError(t, err) assert.Equal(t, file.Size, n) require.NoError(t, download.Close()) assert.Equal(t, file.Hashes, downloadHash.Sums()) // Remove the object require.NoError(t, obj.Remove(ctx)) } // TestPutLarge puts file to the remote, checks it and removes it on success. func TestPutLarge(ctx context.Context, t *testing.T, f fs.Fs, file *fstest.Item) { testPutLarge(ctx, t, f, file, false) } // TestPutLargeStreamed puts file of unknown size to the remote, checks it and removes it on success. func TestPutLargeStreamed(ctx context.Context, t *testing.T, f fs.Fs, file *fstest.Item) { testPutLarge(ctx, t, f, file, true) } // ReadObject reads the contents of an object as a string func ReadObject(ctx context.Context, t *testing.T, obj fs.Object, limit int64, options ...fs.OpenOption) string { what := fmt.Sprintf("readObject(%q) limit=%d, options=%+v", obj, limit, options) in, err := obj.Open(ctx, options...) require.NoError(t, err, what) var r io.Reader = in if limit >= 0 { r = &io.LimitedReader{R: r, N: limit} } contents, err := io.ReadAll(r) require.NoError(t, err, what) err = in.Close() require.NoError(t, err, what) return string(contents) } // ExtraConfigItem describes a config item for the tests type ExtraConfigItem struct{ Name, Key, Value string } // Opt is options for Run type Opt struct { RemoteName string NilObject fs.Object ExtraConfig []ExtraConfigItem SkipBadWindowsCharacters bool // skips unusable characters for windows if set SkipFsMatch bool // if set skip exact matching of Fs value TiersToTest []string // List of tiers which can be tested in setTier test ChunkedUpload ChunkedUploadConfig UnimplementableFsMethods []string // List of Fs methods which can't be implemented in this wrapping Fs UnimplementableObjectMethods []string // List of Object methods which can't be implemented in this wrapping Fs UnimplementableDirectoryMethods []string // List of Directory methods which can't be implemented in this wrapping Fs SkipFsCheckWrap bool // if set skip FsCheckWrap SkipObjectCheckWrap bool // if set skip ObjectCheckWrap SkipDirectoryCheckWrap bool // if set skip DirectoryCheckWrap SkipInvalidUTF8 bool // if set skip invalid UTF-8 checks SkipLeadingDot bool // if set skip leading dot checks QuickTestOK bool // if set, run this test with make quicktest } // returns true if x is found in ss func stringsContains(x string, ss []string) bool { return slices.Contains(ss, x) } // toUpperASCII returns a copy of the string s with all Unicode // letters mapped to their upper case. func toUpperASCII(s string) string { return strings.Map(func(r rune) rune { if 'a' <= r && r <= 'z' { r -= 'a' - 'A' } return r }, s) } // removeConfigID removes any {xyz} parts of the name put in for // config disambiguation func removeConfigID(s string) string { bra := strings.IndexRune(s, '{') ket := strings.IndexRune(s, '}') if bra >= 0 && ket > bra { s = s[:bra] + s[ket+1:] } return s } // InternalTestFiles is the state of the remote at the moment the internal tests are called var InternalTestFiles []fstest.Item // Run runs the basic integration tests for a remote using the options passed in. // // They are structured in a hierarchical way so that dependencies for the tests can be created. // // For example some tests require the directory to be created - these // are inside the "FsMkdir" test. Some tests require some tests files // - these are inside the "FsPutFiles" test. func Run(t *testing.T, opt *Opt) { var ( f fs.Fs remoteName = opt.RemoteName subRemoteName string subRemoteLeaf string file1 = fstest.Item{ ModTime: fstest.Time("2001-02-03T04:05:06.499999999Z"), Path: "file name.txt", } file1Contents string file1MimeType = "text/csv" file1Metadata = fs.Metadata{"rclone-test": "potato"} file2 = fstest.Item{ ModTime: fstest.Time("2001-02-03T04:05:10.123123123Z"), Path: `hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`, } isLocalRemote bool purged bool // whether the dir has been purged or not ctx = context.Background() ci = fs.GetConfig(ctx) unwrappableFsMethods = []string{"Command"} // these Fs methods don't need to be wrapped ever ) if strings.HasSuffix(os.Getenv("RCLONE_CONFIG"), "/notfound") && *fstest.RemoteName == "" && !opt.QuickTestOK { t.Skip("quicktest only") } // Skip the test if the remote isn't configured skipIfNotOk := func(t *testing.T) { if f == nil { t.Skipf("WARN: %q not configured", remoteName) } } // Skip if remote is not ListR capable, otherwise set the useListR // flag, returning a function to restore its value skipIfNotListR := func(t *testing.T) func() { skipIfNotOk(t) if f.Features().ListR == nil { t.Skip("FS has no ListR interface") } previous := ci.UseListR ci.UseListR = true return func() { ci.UseListR = previous } } // Skip if remote is not SetTier and GetTier capable skipIfNotSetTier := func(t *testing.T) { skipIfNotOk(t) if !f.Features().SetTier || !f.Features().GetTier { t.Skip("FS has no SetTier & GetTier interfaces") } } // Return true if f (or any of the things it wraps) is bucket // based but not at the root. isBucketBasedButNotRoot := func(f fs.Fs) bool { f = fs.UnWrapFs(f) return f.Features().BucketBased && strings.Contains(strings.Trim(f.Root(), "/"), "/") } // Initialise the remote fstest.Initialise() // Set extra config if supplied for _, item := range opt.ExtraConfig { config.FileSetValue(item.Name, item.Key, item.Value) } if *fstest.RemoteName != "" { remoteName = *fstest.RemoteName } oldFstestRemoteName := fstest.RemoteName fstest.RemoteName = &remoteName defer func() { fstest.RemoteName = oldFstestRemoteName }() t.Logf("Using remote %q", remoteName) var err error if remoteName == "" { remoteName, err = fstest.LocalRemote() require.NoError(t, err) isLocalRemote = true } // Start any test servers if required finish, err := testserver.Start(remoteName) require.NoError(t, err) defer finish() // Make the Fs we are testing with, initialising the local variables // subRemoteName - name of the remote after the TestRemote: // subRemoteLeaf - a subdirectory to use under that // remote - the result of fs.NewFs(TestRemote:subRemoteName) subRemoteName, subRemoteLeaf, err = fstest.RandomRemoteName(remoteName) require.NoError(t, err) f, err = fs.NewFs(context.Background(), subRemoteName) if errors.Is(err, fs.ErrorNotFoundInConfigFile) { t.Logf("Didn't find %q in config file - skipping tests", remoteName) return } require.NoError(t, err, fmt.Sprintf("unexpected error: %v", err)) // Get fsInfo which contains type, etc. of the fs fsInfo, _, _, _, err := fs.ConfigFs(subRemoteName) require.NoError(t, err, fmt.Sprintf("unexpected error: %v", err)) // Skip the rest if it failed skipIfNotOk(t) // Check to see if Fs that wrap other Fs implement all the optional methods t.Run("FsCheckWrap", func(t *testing.T) { skipIfNotOk(t) if opt.SkipFsCheckWrap { t.Skip("Skipping FsCheckWrap on this Fs") } ft := new(fs.Features).Fill(ctx, f) if ft.UnWrap == nil && !f.Features().Overlay { t.Skip("Not a wrapping Fs") } v := reflect.ValueOf(ft).Elem() vType := v.Type() for i := range v.NumField() { vName := vType.Field(i).Name if stringsContains(vName, opt.UnimplementableFsMethods) { continue } if stringsContains(vName, unwrappableFsMethods) { continue } field := v.Field(i) // skip the bools if field.Type().Kind() == reflect.Bool { continue } if field.IsNil() { t.Errorf("Missing Fs wrapper for %s", vName) } } }) // Check to see if Fs advertises commands and they work and have docs t.Run("FsCommand", func(t *testing.T) { skipIfNotOk(t) doCommand := f.Features().Command if doCommand == nil { t.Skip("No commands in this remote") } // Check the correct error is generated _, err := doCommand(context.Background(), "NOTFOUND", nil, nil) assert.Equal(t, fs.ErrorCommandNotFound, err, "Incorrect error generated on command not found") // Check there are some commands in the fsInfo fsInfo, _, _, _, err := fs.ConfigFs(remoteName) require.NoError(t, err) assert.True(t, len(fsInfo.CommandHelp) > 0, "Command is declared, must return some help in CommandHelp") }) // TestFsRmdirNotFound tests deleting a nonexistent directory t.Run("FsRmdirNotFound", func(t *testing.T) { skipIfNotOk(t) if isBucketBasedButNotRoot(f) { t.Skip("Skipping test as non root bucket-based remote") } err := f.Rmdir(ctx, "") assert.Error(t, err, "Expecting error on Rmdir nonexistent") }) // Make the directory err = f.Mkdir(ctx, "") require.NoError(t, err) fstest.CheckListing(t, f, []fstest.Item{}) // TestFsString tests the String method t.Run("FsString", func(t *testing.T) { skipIfNotOk(t) str := f.String() require.NotEqual(t, "", str) }) // TestFsName tests the Name method t.Run("FsName", func(t *testing.T) { skipIfNotOk(t) got := removeConfigID(f.Name()) var want string if isLocalRemote { want = "local" } else { want = remoteName[:strings.LastIndex(remoteName, ":")] comma := strings.IndexRune(remoteName, ',') if comma >= 0 { want = want[:comma] } } require.Equal(t, want, got) }) // TestFsRoot tests the Root method t.Run("FsRoot", func(t *testing.T) { skipIfNotOk(t) got := f.Root() want := subRemoteName colon := strings.LastIndex(want, ":") if colon >= 0 { want = want[colon+1:] } if isLocalRemote { // only check last path element on local require.Equal(t, filepath.Base(subRemoteName), filepath.Base(got)) } else { require.Equal(t, want, got) } }) // TestFsRmdirEmpty tests deleting an empty directory t.Run("FsRmdirEmpty", func(t *testing.T) { skipIfNotOk(t) err := f.Rmdir(ctx, "") require.NoError(t, err) }) // TestFsMkdir tests making a directory // // Tests that require the directory to be made are within this t.Run("FsMkdir", func(t *testing.T) { skipIfNotOk(t) err := f.Mkdir(ctx, "") require.NoError(t, err) fstest.CheckListing(t, f, []fstest.Item{}) err = f.Mkdir(ctx, "") require.NoError(t, err) // TestFsMkdirRmdirSubdir tests making and removing a sub directory t.Run("FsMkdirRmdirSubdir", func(t *testing.T) { skipIfNotOk(t) dir := "dir/subdir" err := operations.Mkdir(ctx, f, dir) require.NoError(t, err) fstest.CheckListingWithPrecision(t, f, []fstest.Item{}, []string{"dir", "dir/subdir"}, fs.GetModifyWindow(ctx, f)) err = operations.Rmdir(ctx, f, dir) require.NoError(t, err) fstest.CheckListingWithPrecision(t, f, []fstest.Item{}, []string{"dir"}, fs.GetModifyWindow(ctx, f)) err = operations.Rmdir(ctx, f, "dir") require.NoError(t, err) fstest.CheckListingWithPrecision(t, f, []fstest.Item{}, []string{}, fs.GetModifyWindow(ctx, f)) }) // TestFsListEmpty tests listing an empty directory t.Run("FsListEmpty", func(t *testing.T) { skipIfNotOk(t) fstest.CheckListing(t, f, []fstest.Item{}) }) // TestFsListDirEmpty tests listing the directories from an empty directory TestFsListDirEmpty := func(t *testing.T) { skipIfNotOk(t) objs, dirs, err := walk.GetAll(ctx, f, "", true, 1) if !f.Features().CanHaveEmptyDirectories { if err != fs.ErrorDirNotFound { require.NoError(t, err) } } else { require.NoError(t, err) } assert.Equal(t, []string{}, objsToNames(objs)) assert.Equal(t, []string{}, dirsToNames(dirs)) } t.Run("FsListDirEmpty", TestFsListDirEmpty) // TestFsListRDirEmpty tests listing the directories from an empty directory using ListR t.Run("FsListRDirEmpty", func(t *testing.T) { defer skipIfNotListR(t)() TestFsListDirEmpty(t) }) // TestFsListDirNotFound tests listing the directories from an empty directory TestFsListDirNotFound := func(t *testing.T) { skipIfNotOk(t) objs, dirs, err := walk.GetAll(ctx, f, "does not exist", true, 1) if !f.Features().CanHaveEmptyDirectories { if err != fs.ErrorDirNotFound { assert.NoError(t, err) assert.Equal(t, 0, len(objs)+len(dirs)) } } else { assert.Equal(t, fs.ErrorDirNotFound, err) } } t.Run("FsListDirNotFound", TestFsListDirNotFound) // TestFsListRDirNotFound tests listing the directories from an empty directory using ListR t.Run("FsListRDirNotFound", func(t *testing.T) { defer skipIfNotListR(t)() TestFsListDirNotFound(t) }) // FsEncoding tests that file name encodings are // working by uploading a series of unusual files // Must be run in an empty directory t.Run("FsEncoding", func(t *testing.T) { skipIfNotOk(t) if testing.Short() { t.Skip("not running with -short") } // check no files or dirs as pre-requisite fstest.CheckListingWithPrecision(t, f, []fstest.Item{}, []string{}, fs.GetModifyWindow(ctx, f)) for _, test := range []struct { name string path string }{ // See lib/encoder/encoder.go for list of things that go here {"control chars", "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x7F"}, {"dot", "."}, {"dot dot", ".."}, {"punctuation", "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"}, {"leading space", " leading space"}, {"leading tilde", "~leading tilde"}, {"leading CR", "\rleading CR"}, {"leading LF", "\nleading LF"}, {"leading HT", "\tleading HT"}, {"leading VT", "\vleading VT"}, {"leading dot", ".leading dot"}, {"trailing space", "trailing space "}, {"trailing CR", "trailing CR\r"}, {"trailing LF", "trailing LF\n"}, {"trailing HT", "trailing HT\t"}, {"trailing VT", "trailing VT\v"}, {"trailing dot", "trailing dot."}, {"invalid UTF-8", "invalid utf-8\xfe"}, {"URL encoding", "test%46.txt"}, } { t.Run(test.name, func(t *testing.T) { if opt.SkipInvalidUTF8 && test.name == "invalid UTF-8" { t.Skip("Skipping " + test.name) } if opt.SkipLeadingDot && test.name == "leading dot" { t.Skip("Skipping " + test.name) } // turn raw strings into Standard encoding fileName := encoder.Standard.Encode(test.path) dirName := fileName t.Logf("testing %q", fileName) assert.NoError(t, f.Mkdir(ctx, dirName)) file := fstest.Item{ ModTime: time.Now(), Path: dirName + "/" + fileName, // test creating a file and dir with that name } _, o := testPut(context.Background(), t, f, &file) fstest.CheckListingWithPrecision(t, f, []fstest.Item{file}, []string{dirName}, fs.GetModifyWindow(ctx, f)) assert.NoError(t, o.Remove(ctx)) assert.NoError(t, f.Rmdir(ctx, dirName)) fstest.CheckListingWithPrecision(t, f, []fstest.Item{}, []string{}, fs.GetModifyWindow(ctx, f)) }) } }) // TestFsNewObjectNotFound tests not finding an object t.Run("FsNewObjectNotFound", func(t *testing.T) { skipIfNotOk(t) // Object in an existing directory o, err := f.NewObject(ctx, "potato") assert.Nil(t, o) assert.Equal(t, fs.ErrorObjectNotFound, err) // Now try an object in a nonexistent directory o, err = f.NewObject(ctx, "directory/not/found/potato") assert.Nil(t, o) assert.Equal(t, fs.ErrorObjectNotFound, err) }) // TestFsPutError tests uploading a file where there is an error // // It makes sure that aborting a file half way through does not create // a file on the remote. // // go test -v -run 'TestIntegration/Test(Setup|Init|FsMkdir|FsPutError)$' t.Run("FsPutError", func(t *testing.T) { skipIfNotOk(t) var N int64 = 5 * 1024 if *fstest.SizeLimit > 0 && N > *fstest.SizeLimit { N = *fstest.SizeLimit t.Logf("Reduce file size due to limit %d", N) } // Read N bytes then produce an error contents := random.String(int(N)) buf := bytes.NewBufferString(contents) er := &readers.ErrorReader{Err: errors.New("potato")} in := io.MultiReader(buf, er) obji := object.NewStaticObjectInfo(file2.Path, file2.ModTime, 2*N, true, nil, nil) _, err := f.Put(ctx, in, obji) // assert.Nil(t, obj) - FIXME some remotes return the object even on nil assert.NotNil(t, err) retry(t, "FsPutError: test object does not exist", func() error { obj, err := f.NewObject(ctx, file2.Path) if err == nil { return fserrors.RetryErrorf("object is present") } assert.Nil(t, obj) assert.Equal(t, fs.ErrorObjectNotFound, err) return nil }) }) t.Run("FsPutZeroLength", func(t *testing.T) { skipIfNotOk(t) TestPutLarge(ctx, t, f, &fstest.Item{ ModTime: fstest.Time("2001-02-03T04:05:06.499999999Z"), Path: "zero-length-file", Size: int64(0), }) }) t.Run("FsOpenWriterAt", func(t *testing.T) { skipIfNotOk(t) openWriterAt := f.Features().OpenWriterAt if openWriterAt == nil { t.Skip("FS has no OpenWriterAt interface") } path := "writer-at-subdir/writer-at-file" out, err := openWriterAt(ctx, path, -1) require.NoError(t, err) var n int n, err = out.WriteAt([]byte("def"), 3) assert.NoError(t, err) assert.Equal(t, 3, n) n, err = out.WriteAt([]byte("ghi"), 6) assert.NoError(t, err) assert.Equal(t, 3, n) n, err = out.WriteAt([]byte("abc"), 0) assert.NoError(t, err) assert.Equal(t, 3, n) assert.NoError(t, out.Close()) obj := fstest.NewObject(ctx, t, f, path) assert.Equal(t, "abcdefghi", ReadObject(ctx, t, obj, -1), "contents of file differ") assert.NoError(t, obj.Remove(ctx)) assert.NoError(t, f.Rmdir(ctx, "writer-at-subdir")) }) // TestFsOpenChunkWriter tests writing in chunks to fs // then reads back the contents and check if they match // go test -v -run 'TestIntegration/FsMkdir/FsOpenChunkWriter' t.Run("FsOpenChunkWriter", func(t *testing.T) { skipIfNotOk(t) openChunkWriter := f.Features().OpenChunkWriter if openChunkWriter == nil { t.Skip("FS has no OpenChunkWriter interface") } size5MBs := 5 * 1024 * 1024 contents1 := random.String(size5MBs) contents2 := random.String(size5MBs) size1MB := 1 * 1024 * 1024 contents3 := random.String(size1MB) path := "writer-at-subdir/writer-at-file" objSrc := object.NewStaticObjectInfo(path+"-WRONG-REMOTE", file1.ModTime, -1, true, nil, nil) _, out, err := openChunkWriter(ctx, path, objSrc, &fs.ChunkOption{ ChunkSize: int64(size5MBs), }) require.NoError(t, err) var n int64 n, err = out.WriteChunk(ctx, 1, strings.NewReader(contents2)) assert.NoError(t, err) assert.Equal(t, int64(size5MBs), n) n, err = out.WriteChunk(ctx, 2, strings.NewReader(contents3)) assert.NoError(t, err) assert.Equal(t, int64(size1MB), n) n, err = out.WriteChunk(ctx, 0, strings.NewReader(contents1)) assert.NoError(t, err) assert.Equal(t, int64(size5MBs), n) assert.NoError(t, out.Close(ctx)) obj := fstest.NewObject(ctx, t, f, path) originalContents := contents1 + contents2 + contents3 fileContents := ReadObject(ctx, t, obj, -1) isEqual := originalContents == fileContents assert.True(t, isEqual, "contents of file differ") assert.NoError(t, obj.Remove(ctx)) assert.NoError(t, f.Rmdir(ctx, "writer-at-subdir")) }) // TestFsChangeNotify tests that changes are properly // propagated // // go test -v -remote TestDrive: -run '^Test(Setup|Init|FsChangeNotify)$' -verbose t.Run("FsChangeNotify", func(t *testing.T) { skipIfNotOk(t) // Check have ChangeNotify doChangeNotify := f.Features().ChangeNotify if doChangeNotify == nil { t.Skip("FS has no ChangeNotify interface") } err := operations.Mkdir(ctx, f, "dir") require.NoError(t, err) pollInterval := make(chan time.Duration) dirChanges := map[string]struct{}{} objChanges := map[string]struct{}{} doChangeNotify(ctx, func(x string, e fs.EntryType) { fs.Debugf(nil, "doChangeNotify(%q, %+v)", x, e) if strings.HasPrefix(x, file1.Path[:5]) || strings.HasPrefix(x, file2.Path[:5]) { fs.Debugf(nil, "Ignoring notify for file1 or file2: %q, %v", x, e) return } if e == fs.EntryDirectory { dirChanges[x] = struct{}{} } else if e == fs.EntryObject { objChanges[x] = struct{}{} } }, pollInterval) defer func() { close(pollInterval) }() pollInterval <- time.Second var dirs []string for _, idx := range []int{1, 3, 2} { dir := fmt.Sprintf("dir/subdir%d", idx) err = operations.Mkdir(ctx, f, dir) require.NoError(t, err) dirs = append(dirs, dir) } var objs []fs.Object for _, idx := range []int{2, 4, 3} { file := fstest.Item{ ModTime: time.Now(), Path: fmt.Sprintf("dir/file%d", idx), } _, o := testPut(ctx, t, f, &file) objs = append(objs, o) } // Looks for each item in wants in changes - // if they are all found it returns true contains := func(changes map[string]struct{}, wants []string) bool { for _, want := range wants { _, ok := changes[want] if !ok { return false } } return true } // Wait a little while for the changes to come in wantDirChanges := []string{"dir/subdir1", "dir/subdir3", "dir/subdir2"} wantObjChanges := []string{"dir/file2", "dir/file4", "dir/file3"} ok := false for tries := 1; tries < 10; tries++ { ok = contains(dirChanges, wantDirChanges) && contains(objChanges, wantObjChanges) if ok { break } t.Logf("Try %d/10 waiting for dirChanges and objChanges", tries) time.Sleep(3 * time.Second) } if !ok { t.Errorf("%+v does not contain %+v or \n%+v does not contain %+v", dirChanges, wantDirChanges, objChanges, wantObjChanges) } // tidy up afterwards for _, o := range objs { assert.NoError(t, o.Remove(ctx)) } dirs = append(dirs, "dir") for _, dir := range dirs { assert.NoError(t, f.Rmdir(ctx, dir)) } }) // TestFsPut files writes file1, file2 and tests an update // // Tests that require file1, file2 are within this t.Run("FsPutFiles", func(t *testing.T) { skipIfNotOk(t) file1Contents, _ = testPut(ctx, t, f, &file1) /* file2Contents = */ testPut(ctx, t, f, &file2) file1Contents, _ = testPutMimeType(ctx, t, f, &file1, file1MimeType, file1Metadata) // Note that the next test will check there are no duplicated file names // TestFsListDirFile2 tests the files are correctly uploaded by doing // Depth 1 directory listings TestFsListDirFile2 := func(t *testing.T) { skipIfNotOk(t) list := func(dir string, expectedDirNames, expectedObjNames []string) { var objNames, dirNames []string for i := 1; i <= *fstest.ListRetries; i++ { objs, dirs, err := walk.GetAll(ctx, f, dir, true, 1) if errors.Is(err, fs.ErrorDirNotFound) { objs, dirs, err = walk.GetAll(ctx, f, dir, true, 1) } require.NoError(t, err) objNames = objsToNames(objs) dirNames = dirsToNames(dirs) if len(objNames) >= len(expectedObjNames) && len(dirNames) >= len(expectedDirNames) { break } t.Logf("Sleeping for 1 second for TestFsListDirFile2 eventual consistency: %d/%d", i, *fstest.ListRetries) time.Sleep(1 * time.Second) } assert.Equal(t, expectedDirNames, dirNames) assert.Equal(t, expectedObjNames, objNames) } dir := file2.Path deepest := true for dir != "" { expectedObjNames := []string{} expectedDirNames := []string{} child := dir dir = path.Dir(dir) if dir == "." { dir = "" expectedObjNames = append(expectedObjNames, file1.Path) } if deepest { expectedObjNames = append(expectedObjNames, file2.Path) deepest = false } else { expectedDirNames = append(expectedDirNames, child) } list(dir, expectedDirNames, expectedObjNames) } } t.Run("FsListDirFile2", TestFsListDirFile2) // TestFsListRDirFile2 tests the files are correctly uploaded by doing // Depth 1 directory listings using ListR t.Run("FsListRDirFile2", func(t *testing.T) { defer skipIfNotListR(t)() TestFsListDirFile2(t) }) // Test the files are all there with walk.ListR recursive listings t.Run("FsListR", func(t *testing.T) { skipIfNotOk(t) objs, dirs, err := walk.GetAll(ctx, f, "", true, -1) require.NoError(t, err) assert.Equal(t, []string{ "hello? sausage", "hello? sausage/êé", "hello? sausage/êé/Hello, 世界", "hello? sausage/êé/Hello, 世界/ \" ' @ < > & ? + ≠", }, dirsToNames(dirs)) assert.Equal(t, []string{ "file name.txt", "hello? sausage/êé/Hello, 世界/ \" ' @ < > & ? + ≠/z.txt", }, objsToNames(objs)) }) // Test the files are all there with // walk.ListR recursive listings on a sub dir t.Run("FsListRSubdir", func(t *testing.T) { skipIfNotOk(t) objs, dirs, err := walk.GetAll(ctx, f, path.Dir(path.Dir(path.Dir(path.Dir(file2.Path)))), true, -1) require.NoError(t, err) assert.Equal(t, []string{ "hello? sausage/êé", "hello? sausage/êé/Hello, 世界", "hello? sausage/êé/Hello, 世界/ \" ' @ < > & ? + ≠", }, dirsToNames(dirs)) assert.Equal(t, []string{ "hello? sausage/êé/Hello, 世界/ \" ' @ < > & ? + ≠/z.txt", }, objsToNames(objs)) }) // TestFsListDirRoot tests that DirList works in the root TestFsListDirRoot := func(t *testing.T) { skipIfNotOk(t) rootRemote, err := fs.NewFs(context.Background(), remoteName) require.NoError(t, err) _, dirs, err := walk.GetAll(ctx, rootRemote, "", true, 1) require.NoError(t, err) assert.Contains(t, dirsToNames(dirs), subRemoteLeaf, "Remote leaf not found") } t.Run("FsListDirRoot", TestFsListDirRoot) // TestFsListRDirRoot tests that DirList works in the root using ListR t.Run("FsListRDirRoot", func(t *testing.T) { defer skipIfNotListR(t)() TestFsListDirRoot(t) }) // TestFsListSubdir tests List works for a subdirectory TestFsListSubdir := func(t *testing.T) { skipIfNotOk(t) fileName := file2.Path var err error var objs []fs.Object var dirs []fs.Directory for range 2 { dir, _ := path.Split(fileName) dir = dir[:len(dir)-1] objs, dirs, err = walk.GetAll(ctx, f, dir, true, -1) } require.NoError(t, err) require.Len(t, objs, 1) assert.Equal(t, fileName, objs[0].Remote()) require.Len(t, dirs, 0) } t.Run("FsListSubdir", TestFsListSubdir) // TestFsListRSubdir tests List works for a subdirectory using ListR t.Run("FsListRSubdir", func(t *testing.T) { defer skipIfNotListR(t)() TestFsListSubdir(t) }) // TestFsListLevel2 tests List works for 2 levels TestFsListLevel2 := func(t *testing.T) { skipIfNotOk(t) objs, dirs, err := walk.GetAll(ctx, f, "", true, 2) if err == fs.ErrorLevelNotSupported { return } require.NoError(t, err) assert.Equal(t, []string{file1.Path}, objsToNames(objs)) assert.Equal(t, []string{"hello? sausage", "hello? sausage/êé"}, dirsToNames(dirs)) } t.Run("FsListLevel2", TestFsListLevel2) // TestFsListRLevel2 tests List works for 2 levels using ListR t.Run("FsListRLevel2", func(t *testing.T) { defer skipIfNotListR(t)() TestFsListLevel2(t) }) // TestFsListFile1 tests file present t.Run("FsListFile1", func(t *testing.T) { skipIfNotOk(t) fstest.CheckListing(t, f, []fstest.Item{file1, file2}) }) // TestFsNewObject tests NewObject t.Run("FsNewObject", func(t *testing.T) { skipIfNotOk(t) obj := fstest.NewObject(ctx, t, f, file1.Path) file1.Check(t, obj, f.Precision()) }) // FsNewObjectCaseInsensitive tests NewObject on a case insensitive file system t.Run("FsNewObjectCaseInsensitive", func(t *testing.T) { skipIfNotOk(t) if !f.Features().CaseInsensitive { t.Skip("Not Case Insensitive") } obj := fstest.NewObject(ctx, t, f, toUpperASCII(file1.Path)) file1.Check(t, obj, f.Precision()) t.Run("Dir", func(t *testing.T) { obj := fstest.NewObject(ctx, t, f, toUpperASCII(file2.Path)) file2.Check(t, obj, f.Precision()) }) }) // TestFsListFile1and2 tests two files present t.Run("FsListFile1and2", func(t *testing.T) { skipIfNotOk(t) fstest.CheckListing(t, f, []fstest.Item{file1, file2}) }) // TestFsNewObjectDir tests NewObject on a directory which should produce fs.ErrorIsDir if possible or fs.ErrorObjectNotFound if not t.Run("FsNewObjectDir", func(t *testing.T) { skipIfNotOk(t) dir := path.Dir(file2.Path) obj, err := f.NewObject(ctx, dir) assert.Nil(t, obj) assert.True(t, err == fs.ErrorIsDir || err == fs.ErrorObjectNotFound, fmt.Sprintf("Wrong error: expecting fs.ErrorIsDir or fs.ErrorObjectNotFound but got: %#v", err)) }) // TestFsPurge tests Purge t.Run("FsPurge", func(t *testing.T) { skipIfNotOk(t) // Check have Purge doPurge := f.Features().Purge if doPurge == nil { t.Skip("FS has no Purge interface") } // put up a file to purge fileToPurge := fstest.Item{ ModTime: fstest.Time("2001-02-03T04:05:06.499999999Z"), Path: "dirToPurge/fileToPurge.txt", } _, _ = testPut(ctx, t, f, &fileToPurge) fstest.CheckListingWithPrecision(t, f, []fstest.Item{file1, file2, fileToPurge}, []string{ "dirToPurge", "hello? sausage", "hello? sausage/êé", "hello? sausage/êé/Hello, 世界", "hello? sausage/êé/Hello, 世界/ \" ' @ < > & ? + ≠", }, fs.GetModifyWindow(ctx, f)) // Now purge it err = operations.Purge(ctx, f, "dirToPurge") require.NoError(t, err) fstest.CheckListingWithPrecision(t, f, []fstest.Item{file1, file2}, []string{ "hello? sausage", "hello? sausage/êé", "hello? sausage/êé/Hello, 世界", "hello? sausage/êé/Hello, 世界/ \" ' @ < > & ? + ≠", }, fs.GetModifyWindow(ctx, f)) }) // TestFsPurge tests Purge on the Root t.Run("FsPurgeRoot", func(t *testing.T) { skipIfNotOk(t) // Check have Purge doPurge := f.Features().Purge if doPurge == nil { t.Skip("FS has no Purge interface") } // put up a file to purge fileToPurge := fstest.Item{ ModTime: fstest.Time("2001-02-03T04:05:06.499999999Z"), Path: "dirToPurgeFromRoot/fileToPurgeFromRoot.txt", } _, _ = testPut(ctx, t, f, &fileToPurge) fstest.CheckListingWithPrecision(t, f, []fstest.Item{file1, file2, fileToPurge}, []string{ "dirToPurgeFromRoot", "hello? sausage", "hello? sausage/êé", "hello? sausage/êé/Hello, 世界", "hello? sausage/êé/Hello, 世界/ \" ' @ < > & ? + ≠", }, fs.GetModifyWindow(ctx, f)) // Create a new Fs pointing at the directory remoteName := subRemoteName + "/" + "dirToPurgeFromRoot" fPurge, err := fs.NewFs(context.Background(), remoteName) require.NoError(t, err) // Now purge it from the root err = operations.Purge(ctx, fPurge, "") require.NoError(t, err) fstest.CheckListingWithPrecision(t, f, []fstest.Item{file1, file2}, []string{ "hello? sausage", "hello? sausage/êé", "hello? sausage/êé/Hello, 世界", "hello? sausage/êé/Hello, 世界/ \" ' @ < > & ? + ≠", }, fs.GetModifyWindow(ctx, f)) }) // TestFsListRootedSubdir tests putting and listing with an Fs that is rooted at a subdirectory 2 levels down TestFsListRootedSubdir := func(t *testing.T) { skipIfNotOk(t) newF, err := cache.Get(ctx, subRemoteName+"/hello? sausage/êé") assert.NoError(t, err) nestedFile := fstest.Item{ ModTime: fstest.Time("2001-02-03T04:05:06.499999999Z"), Path: "a/b/c/d/e.txt", } _, _ = testPut(ctx, t, newF, &nestedFile) objs, dirs, err := walk.GetAll(ctx, newF, "", true, 10) require.NoError(t, err) assert.Equal(t, []string{`Hello, 世界/ " ' @ < > & ? + ≠/z.txt`, nestedFile.Path}, objsToNames(objs)) assert.Equal(t, []string{`Hello, 世界`, `Hello, 世界/ " ' @ < > & ? + ≠`, "a", "a/b", "a/b/c", "a/b/c/d"}, dirsToNames(dirs)) // cleanup err = operations.Purge(ctx, newF, "a") require.NoError(t, err) } t.Run("FsListRootedSubdir", TestFsListRootedSubdir) // TestFsCopy tests Copy t.Run("FsCopy", func(t *testing.T) { skipIfNotOk(t) // Check have Copy doCopy := f.Features().Copy if doCopy == nil { t.Skip("FS has no Copier interface") } // Test with file2 so have + and ' ' in file name var file2Copy = file2 file2Copy.Path += "-copy" // do the copy src := fstest.NewObject(ctx, t, f, file2.Path) dst, err := doCopy(ctx, src, file2Copy.Path) if err == fs.ErrorCantCopy { t.Skip("FS can't copy") } require.NoError(t, err, fmt.Sprintf("Error: %#v", err)) // check file exists in new listing fstest.CheckListing(t, f, []fstest.Item{file1, file2, file2Copy}) // Check dst lightly - list above has checked ModTime/Hashes assert.Equal(t, file2Copy.Path, dst.Remote()) // check that mutating dst does not mutate src err = dst.SetModTime(ctx, fstest.Time("2004-03-03T04:05:06.499999999Z")) if err != fs.ErrorCantSetModTimeWithoutDelete && err != fs.ErrorCantSetModTime { assert.NoError(t, err) assert.False(t, src.ModTime(ctx).Equal(dst.ModTime(ctx)), "mutating dst should not mutate src -- is it Copying by pointer?") } // Delete copy err = dst.Remove(ctx) require.NoError(t, err) // Test that server side copying files does the correct thing with metadata t.Run("Metadata", func(t *testing.T) { if !f.Features().WriteMetadata { t.Skip("Skipping test as can't write metadata") } ctx, ci := fs.AddConfig(ctx) ci.Metadata = true // Create file with metadata const srcName = "test metadata copy.txt" const dstName = "test metadata copied.txt" t1 := fstest.Time("2003-02-03T04:05:06.499999999Z") t2 := fstest.Time("2004-03-03T04:05:06.499999999Z") contents := random.String(100) fileSrc := fstest.NewItem(srcName, contents, t1) var testMetadata = fs.Metadata{ // System metadata supported by all backends "mtime": t1.Format(time.RFC3339Nano), // User metadata "potato": "jersey", } oSrc := PutTestContentsMetadata(ctx, t, f, &fileSrc, false, contents, true, "text/plain", testMetadata) fstest.CheckEntryMetadata(ctx, t, f, oSrc, testMetadata) // Copy it with --metadata-set ci.MetadataSet = fs.Metadata{ // System metadata supported by all backends "mtime": t2.Format(time.RFC3339Nano), // User metadata "potato": "royal", } oDst, err := doCopy(ctx, oSrc, dstName) require.NoError(t, err) fileDst := fileSrc fileDst.Path = dstName fileDst.ModTime = t2 fstest.CheckListing(t, f, []fstest.Item{file1, file2, fileSrc, fileDst}) // Check metadata is correct fstest.CheckEntryMetadata(ctx, t, f, oDst, ci.MetadataSet) oDst = fstest.NewObject(ctx, t, f, dstName) fstest.CheckEntryMetadata(ctx, t, f, oDst, ci.MetadataSet) // Remove test files require.NoError(t, oSrc.Remove(ctx)) require.NoError(t, oDst.Remove(ctx)) }) }) // TestFsMove tests Move t.Run("FsMove", func(t *testing.T) { skipIfNotOk(t) // Check have Move doMove := f.Features().Move if doMove == nil { t.Skip("FS has no Mover interface") } // state of files now: // 1: file name.txt // 2: hello sausage?/../z.txt var file1Move = file1 var file2Move = file2 // check happy path, i.e. no naming conflicts when rename and move are two // separate operations file2Move.Path = "other.txt" src := fstest.NewObject(ctx, t, f, file2.Path) dst, err := doMove(ctx, src, file2Move.Path) if err == fs.ErrorCantMove { t.Skip("FS can't move") } require.NoError(t, err) // check file exists in new listing fstest.CheckListing(t, f, []fstest.Item{file1, file2Move}) // Check dst lightly - list above has checked ModTime/Hashes assert.Equal(t, file2Move.Path, dst.Remote()) // 1: file name.txt // 2: other.txt // Check conflict on "rename, then move" file1Move.Path = "moveTest/other.txt" src = fstest.NewObject(ctx, t, f, file1.Path) _, err = doMove(ctx, src, file1Move.Path) require.NoError(t, err) fstest.CheckListing(t, f, []fstest.Item{file1Move, file2Move}) // 1: moveTest/other.txt // 2: other.txt // Check conflict on "move, then rename" src = fstest.NewObject(ctx, t, f, file1Move.Path) _, err = doMove(ctx, src, file1.Path) require.NoError(t, err) fstest.CheckListing(t, f, []fstest.Item{file1, file2Move}) // 1: file name.txt // 2: other.txt src = fstest.NewObject(ctx, t, f, file2Move.Path) _, err = doMove(ctx, src, file2.Path) require.NoError(t, err) fstest.CheckListing(t, f, []fstest.Item{file1, file2}) // 1: file name.txt // 2: hello sausage?/../z.txt // Tidy up moveTest directory require.NoError(t, f.Rmdir(ctx, "moveTest")) // Test that server side moving files does the correct thing with metadata t.Run("Metadata", func(t *testing.T) { if !f.Features().WriteMetadata { t.Skip("Skipping test as can't write metadata") } ctx, ci := fs.AddConfig(ctx) ci.Metadata = true // Create file with metadata const name = "test metadata move.txt" const newName = "test metadata moved.txt" t1 := fstest.Time("2003-02-03T04:05:06.499999999Z") t2 := fstest.Time("2004-03-03T04:05:06.499999999Z") file := fstest.NewItem(name, name, t1) contents := random.String(100) var testMetadata = fs.Metadata{ // System metadata supported by all backends "mtime": t1.Format(time.RFC3339Nano), // User metadata "potato": "jersey", } o := PutTestContentsMetadata(ctx, t, f, &file, false, contents, true, "text/plain", testMetadata) fstest.CheckEntryMetadata(ctx, t, f, o, testMetadata) // Move it with --metadata-set ci.MetadataSet = fs.Metadata{ // System metadata supported by all backends "mtime": t2.Format(time.RFC3339Nano), // User metadata "potato": "royal", } newO, err := doMove(ctx, o, newName) require.NoError(t, err) file.Path = newName file.ModTime = t2 fstest.CheckListing(t, f, []fstest.Item{file1, file2, file}) // Check metadata is correct fstest.CheckEntryMetadata(ctx, t, f, newO, ci.MetadataSet) newO = fstest.NewObject(ctx, t, f, newName) fstest.CheckEntryMetadata(ctx, t, f, newO, ci.MetadataSet) // Remove test file require.NoError(t, newO.Remove(ctx)) }) }) // Move src to this remote using server-side move operations. // // Will only be called if src.Fs().Name() == f.Name() // // If it isn't possible then return fs.ErrorCantDirMove // // If destination exists then return fs.ErrorDirExists // TestFsDirMove tests DirMove // // go test -v -run 'TestIntegration/Test(Setup|Init|FsMkdir|FsPutFile1|FsPutFile2|FsUpdateFile1|FsDirMove)$ t.Run("FsDirMove", func(t *testing.T) { skipIfNotOk(t) // Check have DirMove doDirMove := f.Features().DirMove if doDirMove == nil { t.Skip("FS has no DirMover interface") } // Check it can't move onto itself err := doDirMove(ctx, f, "", "") require.Equal(t, fs.ErrorDirExists, err) // new remote newRemote, _, removeNewRemote, err := fstest.RandomRemote() require.NoError(t, err) defer removeNewRemote() const newName = "new_name/sub_new_name" // try the move err = newRemote.Features().DirMove(ctx, f, "", newName) require.NoError(t, err) // check remotes // remote should not exist here _, err = f.List(ctx, "") assert.True(t, errors.Is(err, fs.ErrorDirNotFound)) //fstest.CheckListingWithPrecision(t, remote, []fstest.Item{}, []string{}, remote.Precision()) file1Copy := file1 file1Copy.Path = path.Join(newName, file1.Path) file2Copy := file2 file2Copy.Path = path.Join(newName, file2.Path) fstest.CheckListingWithPrecision(t, newRemote, []fstest.Item{file2Copy, file1Copy}, []string{ "new_name", "new_name/sub_new_name", "new_name/sub_new_name/hello? sausage", "new_name/sub_new_name/hello? sausage/êé", "new_name/sub_new_name/hello? sausage/êé/Hello, 世界", "new_name/sub_new_name/hello? sausage/êé/Hello, 世界/ \" ' @ < > & ? + ≠", }, newRemote.Precision()) // move it back err = doDirMove(ctx, newRemote, newName, "") require.NoError(t, err) // check remotes fstest.CheckListingWithPrecision(t, f, []fstest.Item{file2, file1}, []string{ "hello? sausage", "hello? sausage/êé", "hello? sausage/êé/Hello, 世界", "hello? sausage/êé/Hello, 世界/ \" ' @ < > & ? + ≠", }, f.Precision()) fstest.CheckListingWithPrecision(t, newRemote, []fstest.Item{}, []string{ "new_name", }, newRemote.Precision()) }) // TestFsRmdirFull tests removing a non empty directory t.Run("FsRmdirFull", func(t *testing.T) { skipIfNotOk(t) if isBucketBasedButNotRoot(f) { t.Skip("Skipping test as non root bucket-based remote") } err := f.Rmdir(ctx, "") require.Error(t, err, "Expecting error on RMdir on non empty remote") }) // TestFsPrecision tests the Precision of the Fs t.Run("FsPrecision", func(t *testing.T) { skipIfNotOk(t) precision := f.Precision() if precision == fs.ModTimeNotSupported { return } if precision > time.Second || precision < 0 { t.Fatalf("Precision out of range %v", precision) } // FIXME check expected precision }) // TestObjectString tests the Object String method t.Run("ObjectString", func(t *testing.T) { skipIfNotOk(t) obj := fstest.NewObject(ctx, t, f, file1.Path) assert.Equal(t, file1.Path, obj.String()) if opt.NilObject != nil { assert.Equal(t, "", opt.NilObject.String()) } }) // TestObjectFs tests the object can be found t.Run("ObjectFs", func(t *testing.T) { skipIfNotOk(t) obj := fstest.NewObject(ctx, t, f, file1.Path) // If this is set we don't do the direct comparison of // the Fs from the object as it may be different if opt.SkipFsMatch { return } testRemote := f if obj.Fs() != testRemote { // Check to see if this wraps something else if doUnWrap := testRemote.Features().UnWrap; doUnWrap != nil { testRemote = doUnWrap() } } assert.Equal(t, obj.Fs(), testRemote) }) // TestObjectRemote tests the Remote is correct t.Run("ObjectRemote", func(t *testing.T) { skipIfNotOk(t) obj := fstest.NewObject(ctx, t, f, file1.Path) assert.Equal(t, file1.Path, obj.Remote()) }) // TestObjectHashes checks all the hashes the object supports t.Run("ObjectHashes", func(t *testing.T) { skipIfNotOk(t) obj := fstest.NewObject(ctx, t, f, file1.Path) file1.CheckHashes(t, obj) }) // TestObjectModTime tests the ModTime of the object is correct TestObjectModTime := func(t *testing.T) { skipIfNotOk(t) obj := fstest.NewObject(ctx, t, f, file1.Path) file1.CheckModTime(t, obj, obj.ModTime(ctx), f.Precision()) } t.Run("ObjectModTime", TestObjectModTime) // TestObjectMimeType tests the MimeType of the object is correct t.Run("ObjectMimeType", func(t *testing.T) { skipIfNotOk(t) features := f.Features() obj := fstest.NewObject(ctx, t, f, file1.Path) do, ok := obj.(fs.MimeTyper) if !ok { require.False(t, features.ReadMimeType, "Features.ReadMimeType is set but Object.MimeType method not found") t.Skip("MimeType method not supported") } mimeType := do.MimeType(ctx) if !features.ReadMimeType { require.Equal(t, "", mimeType, "Features.ReadMimeType is not set but Object.MimeType returned a non-empty MimeType") } else if features.WriteMimeType { assert.Equal(t, file1MimeType, mimeType, "can read and write mime types but failed") } else { if strings.ContainsRune(mimeType, ';') { assert.Equal(t, "text/plain; charset=utf-8", mimeType) } else { assert.Equal(t, "text/plain", mimeType) } } }) // TestObjectMetadata tests the Metadata of the object is correct t.Run("ObjectMetadata", func(t *testing.T) { skipIfNotOk(t) ctx, ci := fs.AddConfig(ctx) ci.Metadata = true features := f.Features() obj := fstest.NewObject(ctx, t, f, file1.Path) do, objectHasMetadata := obj.(fs.Metadataer) if objectHasMetadata || features.ReadMetadata || features.WriteMetadata || features.UserMetadata { fsInfo := fs.FindFromFs(f) require.NotNil(t, fsInfo) require.NotNil(t, fsInfo.MetadataInfo, "Object declares metadata support but no MetadataInfo in RegInfo") } if !objectHasMetadata { require.False(t, features.ReadMetadata, "Features.ReadMetadata is set but Object.Metadata method not found") t.Skip("Metadata method not supported") } metadata, err := do.Metadata(ctx) require.NoError(t, err) // check standard metadata for k, v := range metadata { switch k { case "atime", "btime", "mtime": mtime, err := time.Parse(time.RFC3339Nano, v) require.NoError(t, err) if k == "mtime" { fstest.AssertTimeEqualWithPrecision(t, file1.Path, file1.ModTime, mtime, f.Precision()) } } } if !features.ReadMetadata { if metadata != nil && !features.Overlay { require.Equal(t, "", metadata, "Features.ReadMetadata is not set but Object.Metadata returned a non nil Metadata: %#v", metadata) } } else if features.WriteMetadata { require.NotNil(t, metadata) if features.UserMetadata { // check all the metadata bits we uploaded are present - there may be more we didn't write for k, v := range file1Metadata { assert.Equal(t, v, metadata[k], "can read and write metadata but failed on key %q (want=%+v, got=%+v)", k, file1Metadata, metadata) } } // Now test we can set the mtime and content-type via the metadata and these take precedence t.Run("mtime", func(t *testing.T) { path := "metadatatest" mtimeModTime := fstest.Time("2002-02-03T04:05:06.499999999Z") modTime := fstest.Time("2003-02-03T04:05:06.499999999Z") item := fstest.NewItem(path, path, modTime) metaMimeType := "application/zip" mimeType := "application/gzip" metadata := fs.Metadata{ "mtime": mtimeModTime.Format(time.RFC3339Nano), "content-type": metaMimeType, } // This checks the mtime is correct also and returns the re-read object _, obj := testPutMimeType(ctx, t, f, &item, mimeType, metadata) defer func() { assert.NoError(t, obj.Remove(ctx)) }() // Check content-type got updated too if features.ReadMimeType && features.WriteMimeType { // read the object from scratch o, err := f.NewObject(ctx, path) require.NoError(t, err) // Check the mimetype is correct do, ok := o.(fs.MimeTyper) require.True(t, ok) gotMimeType := do.MimeType(ctx) assert.Equal(t, metaMimeType, gotMimeType) } }) } // else: Have some metadata here we didn't write - can't really check it! }) // TestObjectSetMetadata tests the SetMetadata of the object t.Run("ObjectSetMetadata", func(t *testing.T) { skipIfNotOk(t) ctx, ci := fs.AddConfig(ctx) ci.Metadata = true features := f.Features() // Test to see if SetMetadata is supported on an existing object before creating a new one obj := fstest.NewObject(ctx, t, f, file1.Path) _, objectHasSetMetadata := obj.(fs.SetMetadataer) if !objectHasSetMetadata { t.Skip("SetMetadata method not supported") } if !features.Overlay { require.True(t, features.WriteMetadata, "Features.WriteMetadata is false but Object.SetMetadata found") } if !features.ReadMetadata { t.Skip("SetMetadata can't be tested without ReadMetadata") } // Create file with metadata const fileName = "test set metadata.txt" t1 := fstest.Time("2003-02-03T04:05:06.499999999Z") t2 := fstest.Time("2004-03-03T04:05:06.499999999Z") contents := random.String(100) file := fstest.NewItem(fileName, contents, t1) var testMetadata = fs.Metadata{ // System metadata supported by all backends "mtime": t1.Format(time.RFC3339Nano), // User metadata "potato": "jersey", } obj = PutTestContentsMetadata(ctx, t, f, &file, true, contents, true, "text/plain", testMetadata) fstest.CheckEntryMetadata(ctx, t, f, obj, testMetadata) do, objectHasSetMetadata := obj.(fs.SetMetadataer) require.True(t, objectHasSetMetadata) // Set new metadata err := do.SetMetadata(ctx, fs.Metadata{ // System metadata supported by all backends "mtime": t2.Format(time.RFC3339Nano), // User metadata "potato": "royal", }) if err == fs.ErrorNotImplemented { t.Log("SetMetadata returned fs.ErrorNotImplemented") } else { require.NoError(t, err) file.ModTime = t2 fstest.CheckListing(t, f, []fstest.Item{file1, file2, file}) // Check metadata is correct fstest.CheckEntryMetadata(ctx, t, f, obj, ci.MetadataSet) obj = fstest.NewObject(ctx, t, f, fileName) fstest.CheckEntryMetadata(ctx, t, f, obj, ci.MetadataSet) } // Remove test file require.NoError(t, obj.Remove(ctx)) }) // TestObjectSetModTime tests that SetModTime works t.Run("ObjectSetModTime", func(t *testing.T) { skipIfNotOk(t) newModTime := fstest.Time("2011-12-13T14:15:16.999999999Z") obj := fstest.NewObject(ctx, t, f, file1.Path) err := obj.SetModTime(ctx, newModTime) if err == fs.ErrorCantSetModTime || err == fs.ErrorCantSetModTimeWithoutDelete { t.Log(err) return } require.NoError(t, err) file1.ModTime = newModTime file1.CheckModTime(t, obj, obj.ModTime(ctx), f.Precision()) // And make a new object and read it from there too TestObjectModTime(t) }) // TestObjectSize tests that Size works t.Run("ObjectSize", func(t *testing.T) { skipIfNotOk(t) obj := fstest.NewObject(ctx, t, f, file1.Path) assert.Equal(t, file1.Size, obj.Size()) }) // TestObjectOpen tests that Open works t.Run("ObjectOpen", func(t *testing.T) { skipIfNotOk(t) obj := fstest.NewObject(ctx, t, f, file1.Path) assert.Equal(t, file1Contents, ReadObject(ctx, t, obj, -1), "contents of file1 differ") }) // TestObjectOpenSeek tests that Open works with SeekOption t.Run("ObjectOpenSeek", func(t *testing.T) { skipIfNotOk(t) obj := fstest.NewObject(ctx, t, f, file1.Path) assert.Equal(t, file1Contents[50:], ReadObject(ctx, t, obj, -1, &fs.SeekOption{Offset: 50}), "contents of file1 differ after seek") }) // TestObjectOpenRange tests that Open works with RangeOption // // go test -v -run 'TestIntegration/Test(Setup|Init|FsMkdir|FsPutFile1|FsPutFile2|FsUpdateFile1|ObjectOpenRange)$' t.Run("ObjectOpenRange", func(t *testing.T) { skipIfNotOk(t) obj := fstest.NewObject(ctx, t, f, file1.Path) for _, test := range []struct { ro fs.RangeOption wantStart, wantEnd int }{ {fs.RangeOption{Start: 5, End: 15}, 5, 16}, {fs.RangeOption{Start: 80, End: -1}, 80, 100}, {fs.RangeOption{Start: 81, End: 100000}, 81, 100}, {fs.RangeOption{Start: -1, End: 20}, 80, 100}, // if start is omitted this means get the final bytes // {fs.RangeOption{Start: -1, End: -1}, 0, 100}, - this seems to work but the RFC doesn't define it } { got := ReadObject(ctx, t, obj, -1, &test.ro) foundAt := strings.Index(file1Contents, got) help := fmt.Sprintf("%#v failed want [%d:%d] got [%d:%d]", test.ro, test.wantStart, test.wantEnd, foundAt, foundAt+len(got)) assert.Equal(t, file1Contents[test.wantStart:test.wantEnd], got, help) } }) // TestObjectPartialRead tests that reading only part of the object does the correct thing t.Run("ObjectPartialRead", func(t *testing.T) { skipIfNotOk(t) obj := fstest.NewObject(ctx, t, f, file1.Path) assert.Equal(t, file1Contents[:50], ReadObject(ctx, t, obj, 50), "contents of file1 differ after limited read") }) // TestObjectUpdate tests that Update works t.Run("ObjectUpdate", func(t *testing.T) { skipIfNotOk(t) contents := random.String(200) var h *hash.MultiHasher file1.Size = int64(len(contents)) obj := fstest.NewObject(ctx, t, f, file1.Path) remoteBefore := obj.Remote() obji := object.NewStaticObjectInfo(file1.Path+"-should-be-ignored.bin", file1.ModTime, int64(len(contents)), true, nil, obj.Fs()) retry(t, "Update object", func() error { buf := bytes.NewBufferString(contents) h = hash.NewMultiHasher() in := io.TeeReader(buf, h) return obj.Update(ctx, in, obji) }) remoteAfter := obj.Remote() assert.Equal(t, remoteBefore, remoteAfter, "Remote should not change") file1.Hashes = h.Sums() // check the object has been updated file1.Check(t, obj, f.Precision()) // Re-read the object and check again obj = fstest.NewObject(ctx, t, f, file1.Path) file1.Check(t, obj, f.Precision()) // check contents correct assert.Equal(t, contents, ReadObject(ctx, t, obj, -1), "contents of updated file1 differ") file1Contents = contents }) // TestObjectStorable tests that Storable works t.Run("ObjectStorable", func(t *testing.T) { skipIfNotOk(t) obj := fstest.NewObject(ctx, t, f, file1.Path) require.NotNil(t, !obj.Storable(), "Expecting object to be storable") }) // TestFsIsFile tests that an error is returned along with a valid fs // which points to the parent directory. t.Run("FsIsFile", func(t *testing.T) { skipIfNotOk(t) remoteName := subRemoteName + "/" + file2.Path file2Copy := file2 file2Copy.Path = "z.txt" fileRemote, err := fs.NewFs(context.Background(), remoteName) require.NotNil(t, fileRemote) assert.Equal(t, fs.ErrorIsFile, err) // Check Fs.Root returns the right thing t.Run("FsRoot", func(t *testing.T) { skipIfNotOk(t) got := fileRemote.Root() remoteDir := path.Dir(remoteName) want := remoteDir colon := strings.LastIndex(want, ":") if colon >= 0 { want = want[colon+1:] } if isLocalRemote { // only check last path element on local require.Equal(t, filepath.Base(remoteDir), filepath.Base(got)) } else { require.Equal(t, want, got) } }) if strings.HasPrefix(remoteName, "TestChunker") && strings.Contains(remoteName, "Nometa") { // TODO fix chunker and remove this bypass t.Logf("Skip listing check -- chunker can't yet handle this tricky case") return } fstest.CheckListing(t, fileRemote, []fstest.Item{file2Copy}) }) // TestFsIsFileNotFound tests that an error is not returned if no object is found t.Run("FsIsFileNotFound", func(t *testing.T) { skipIfNotOk(t) remoteName := subRemoteName + "/not found.txt" fileRemote, err := fs.NewFs(context.Background(), remoteName) require.NoError(t, err) fstest.CheckListing(t, fileRemote, []fstest.Item{}) }) // Test that things work from the root t.Run("FromRoot", func(t *testing.T) { if features := f.Features(); features.BucketBased && !features.BucketBasedRootOK { t.Skip("Can't list from root on this remote") } parsed, err := fspath.Parse(subRemoteName) require.NoError(t, err) configName, configLeaf := parsed.ConfigString, parsed.Path if configName == "" { configName, configLeaf = path.Split(subRemoteName) } else { configName += ":" } t.Logf("Opening root remote %q path %q from %q", configName, configLeaf, subRemoteName) rootRemote, err := fs.NewFs(context.Background(), configName) require.NoError(t, err) file1Root := file1 file1Root.Path = path.Join(configLeaf, file1Root.Path) file2Root := file2 file2Root.Path = path.Join(configLeaf, file2Root.Path) var dirs []string dir := file2.Path for { dir = path.Dir(dir) if dir == "" || dir == "." || dir == "/" { break } dirs = append(dirs, path.Join(configLeaf, dir)) } // Check that we can see file1 and file2 from the root t.Run("List", func(t *testing.T) { fstest.CheckListingWithRoot(t, rootRemote, configLeaf, []fstest.Item{file1Root, file2Root}, dirs, rootRemote.Precision()) }) // Check that listing the entries is OK t.Run("ListEntries", func(t *testing.T) { entries, err := rootRemote.List(context.Background(), configLeaf) require.NoError(t, err) fstest.CompareItems(t, entries, []fstest.Item{file1Root}, dirs[len(dirs)-1:], rootRemote.Precision(), "ListEntries") }) // List the root with ListR t.Run("ListR", func(t *testing.T) { doListR := rootRemote.Features().ListR if doListR == nil { t.Skip("FS has no ListR interface") } file1Found, file2Found := false, false stopTime := time.Now().Add(10 * time.Second) errTooMany := errors.New("too many files") errFound := errors.New("found") err := doListR(context.Background(), "", func(entries fs.DirEntries) error { for _, entry := range entries { remote := entry.Remote() if remote == file1Root.Path { file1Found = true } if remote == file2Root.Path { file2Found = true } if file1Found && file2Found { return errFound } } if time.Now().After(stopTime) { return errTooMany } return nil }) if !errors.Is(err, errFound) && !errors.Is(err, errTooMany) { assert.NoError(t, err) } if !errors.Is(err, errTooMany) { assert.True(t, file1Found, "file1Root %q not found", file1Root.Path) assert.True(t, file2Found, "file2Root %q not found", file2Root.Path) } else { t.Logf("Too many files to list - giving up") } }) // Create a new file t.Run("Put", func(t *testing.T) { file3Root := fstest.Item{ ModTime: time.Now(), Path: path.Join(configLeaf, "created from root.txt"), } _, file3Obj := testPut(ctx, t, rootRemote, &file3Root) fstest.CheckListingWithRoot(t, rootRemote, configLeaf, []fstest.Item{file1Root, file2Root, file3Root}, nil, rootRemote.Precision()) // And then remove it t.Run("Remove", func(t *testing.T) { require.NoError(t, file3Obj.Remove(context.Background())) fstest.CheckListingWithRoot(t, rootRemote, configLeaf, []fstest.Item{file1Root, file2Root}, nil, rootRemote.Precision()) }) }) }) // TestPublicLink tests creation of sharable, public links // go test -v -run 'TestIntegration/Test(Setup|Init|FsMkdir|FsPutFile1|FsPutFile2|FsUpdateFile1|PublicLink)$' t.Run("PublicLink", func(t *testing.T) { skipIfNotOk(t) publicLinkFunc := f.Features().PublicLink if publicLinkFunc == nil { t.Skip("FS has no PublicLinker interface") } type PublicLinkFunc func(ctx context.Context, remote string, expire fs.Duration, unlink bool) (link string, err error) wrapPublicLinkFunc := func(f PublicLinkFunc) PublicLinkFunc { return func(ctx context.Context, remote string, expire fs.Duration, unlink bool) (link string, err error) { link, err = publicLinkFunc(ctx, remote, expire, unlink) if err == nil { return } // For OneDrive Personal, link expiry is a premium feature // Don't let it fail the test (https://github.com/rclone/rclone/issues/5420) if fsInfo.Name == "onedrive" && strings.Contains(err.Error(), "accountUpgradeRequired") { t.Log("treating accountUpgradeRequired as success for PublicLink") link, err = "bogus link to "+remote, nil } return } } expiry := fs.Duration(120 * time.Second) doPublicLink := wrapPublicLinkFunc(publicLinkFunc) // if object not found link, err := doPublicLink(ctx, file1.Path+"_does_not_exist", expiry, false) require.Error(t, err, "Expected to get error when file doesn't exist") require.Equal(t, "", link, "Expected link to be empty on error") // sharing file for the first time link1, err := doPublicLink(ctx, file1.Path, expiry, false) require.NoError(t, err) require.NotEqual(t, "", link1, "Link should not be empty") link2, err := doPublicLink(ctx, file2.Path, expiry, false) require.NoError(t, err) require.NotEqual(t, "", link2, "Link should not be empty") require.NotEqual(t, link1, link2, "Links to different files should differ") // sharing file for the 2nd time link1, err = doPublicLink(ctx, file1.Path, expiry, false) require.NoError(t, err) require.NotEqual(t, "", link1, "Link should not be empty") // sharing directory for the first time path := path.Dir(file2.Path) link3, err := doPublicLink(ctx, path, expiry, false) if err != nil && (errors.Is(err, fs.ErrorCantShareDirectories) || errors.Is(err, fs.ErrorObjectNotFound)) { t.Log("skipping directory tests as not supported on this backend") } else { require.NoError(t, err) require.NotEqual(t, "", link3, "Link should not be empty") // sharing directory for the second time link3, err = doPublicLink(ctx, path, expiry, false) require.NoError(t, err) require.NotEqual(t, "", link3, "Link should not be empty") // sharing the "root" directory in a subremote subRemote, _, removeSubRemote, err := fstest.RandomRemote() require.NoError(t, err) defer removeSubRemote() // ensure sub remote isn't empty buf := bytes.NewBufferString("somecontent") obji := object.NewStaticObjectInfo("somefile", time.Now(), int64(buf.Len()), true, nil, nil) retry(t, "Put", func() error { _, err := subRemote.Put(ctx, buf, obji) return err }) link4, err := wrapPublicLinkFunc(subRemote.Features().PublicLink)(ctx, "", expiry, false) require.NoError(t, err, "Sharing root in a sub-remote should work") require.NotEqual(t, "", link4, "Link should not be empty") } }) // TestSetTier tests SetTier and GetTier functionality t.Run("SetTier", func(t *testing.T) { skipIfNotSetTier(t) obj := fstest.NewObject(ctx, t, f, file1.Path) setter, ok := obj.(fs.SetTierer) assert.NotNil(t, ok) getter, ok := obj.(fs.GetTierer) assert.NotNil(t, ok) // If interfaces are supported TiersToTest should contain // at least one entry supportedTiers := opt.TiersToTest assert.NotEmpty(t, supportedTiers) // test set tier changes on supported storage classes or tiers for _, tier := range supportedTiers { err := setter.SetTier(tier) assert.Nil(t, err) got := getter.GetTier() assert.Equal(t, tier, got) } }) // Check to see if Fs that wrap other Objects implement all the optional methods t.Run("ObjectCheckWrap", func(t *testing.T) { skipIfNotOk(t) if opt.SkipObjectCheckWrap { t.Skip("Skipping FsCheckWrap on this Fs") } ft := new(fs.Features).Fill(ctx, f) if ft.UnWrap == nil { t.Skip("Not a wrapping Fs") } obj := fstest.NewObject(ctx, t, f, file1.Path) _, unsupported := fs.ObjectOptionalInterfaces(obj) for _, name := range unsupported { if !stringsContains(name, opt.UnimplementableObjectMethods) { t.Errorf("Missing Object wrapper for %s", name) } } }) // Run tests for bucket based Fs // TestIntegration/FsMkdir/FsPutFiles/Bucket t.Run("Bucket", func(t *testing.T) { // Test if this Fs is bucket based - this test won't work for wrapped bucket based backends. if !f.Features().BucketBased { t.Skip("Not a bucket based backend") } if f.Features().CanHaveEmptyDirectories { t.Skip("Can have empty directories") } if !f.Features().DoubleSlash { t.Skip("Can't have // in paths") } // Create some troublesome file names fileNames := []string{ file1.Path, file2.Path, ".leadingdot", "/.leadingdot", "///tripleslash", "//doubleslash", "dir/.leadingdot", "dir///tripleslash", "dir//doubleslash", } dirNames := []string{ "hello? sausage", "hello? sausage/êé", "hello? sausage/êé/Hello, 世界", "hello? sausage/êé/Hello, 世界/ \" ' @ < > & ? + ≠", "/", "//", "///", "dir", "dir/", "dir//", } t1 := fstest.Time("2003-02-03T04:05:06.499999999Z") var objs []fs.Object for _, fileName := range fileNames[2:] { contents := "bad file name: " + fileName file := fstest.NewItem(fileName, contents, t1) objs = append(objs, PutTestContents(ctx, t, f, &file, contents, true)) } // Check they arrived // This uses walk.Walk with a max size set to make sure we don't use ListR check := func(f fs.Fs, dir string, wantFileNames, wantDirNames []string) { t.Helper() var gotFileNames, gotDirNames []string require.NoError(t, walk.Walk(ctx, f, dir, true, 100, func(path string, entries fs.DirEntries, err error) error { if err != nil { return err } for _, entry := range entries { if _, isObj := entry.(fs.Object); isObj { gotFileNames = append(gotFileNames, entry.Remote()) } else { gotDirNames = append(gotDirNames, entry.Remote()) } } return nil })) sort.Strings(wantDirNames) sort.Strings(wantFileNames) sort.Strings(gotDirNames) sort.Strings(gotFileNames) assert.Equal(t, wantFileNames, gotFileNames) assert.Equal(t, wantDirNames, gotDirNames) } check(f, "", fileNames, dirNames) check(f, "/", []string{ "/.leadingdot", "///tripleslash", "//doubleslash", }, []string{ "//", "///", }) check(f, "//", []string{ "///tripleslash", "//doubleslash", }, []string{ "///", }) check(f, "dir", []string{ "dir/.leadingdot", "dir///tripleslash", "dir//doubleslash", }, []string{ "dir/", "dir//", }) check(f, "dir/", []string{ "dir///tripleslash", "dir//doubleslash", }, []string{ "dir//", }) check(f, "dir//", []string{ "dir///tripleslash", }, nil) // Now create a backend not at the root of a bucket f2, err := fs.NewFs(ctx, subRemoteName+"/dir") require.NoError(t, err) check(f2, "", []string{ ".leadingdot", "//tripleslash", "/doubleslash", }, []string{ "/", "//", }) check(f2, "/", []string{ "//tripleslash", "/doubleslash", }, []string{ "//", }) check(f2, "//", []string{ "//tripleslash", }, []string(nil)) // Remove the objects for _, obj := range objs { assert.NoError(t, obj.Remove(ctx)) } // Check they are gone fstest.CheckListingWithPrecision(t, f, []fstest.Item{file1, file2}, []string{ "hello? sausage", "hello? sausage/êé", "hello? sausage/êé/Hello, 世界", "hello? sausage/êé/Hello, 世界/ \" ' @ < > & ? + ≠", }, fs.GetModifyWindow(ctx, f)) }) // State of remote at the moment the internal tests are called InternalTestFiles = []fstest.Item{file1, file2} // TestObjectRemove tests Remove t.Run("ObjectRemove", func(t *testing.T) { skipIfNotOk(t) // remove file1 obj := fstest.NewObject(ctx, t, f, file1.Path) err := obj.Remove(ctx) require.NoError(t, err) // check listing without modtime as TestPublicLink may change the modtime fstest.CheckListingWithPrecision(t, f, []fstest.Item{file2}, nil, fs.ModTimeNotSupported) // Show the internal tests file2 is gone InternalTestFiles = []fstest.Item{file2} }) // TestAbout tests the About optional interface t.Run("ObjectAbout", func(t *testing.T) { skipIfNotOk(t) // Check have About doAbout := f.Features().About if doAbout == nil { t.Skip("FS does not support About") } // Can't really check the output much! usage, err := doAbout(context.Background()) require.NoError(t, err) require.NotNil(t, usage) assert.NotEqual(t, int64(0), usage.Total) }) // Just file2 remains for Purge to clean up // TestFsPutStream tests uploading files when size isn't known in advance. // This may trigger large buffer allocation in some backends, keep it // close to the end of suite. (See fs/operations/xtra_operations_test.go) t.Run("FsPutStream", func(t *testing.T) { skipIfNotOk(t) if f.Features().PutStream == nil { t.Skip("FS has no PutStream interface") } for _, contentSize := range []int{0, 100} { t.Run(strconv.Itoa(contentSize), func(t *testing.T) { file := fstest.Item{ ModTime: fstest.Time("2001-02-03T04:05:06.499999999Z"), Path: "piped data.txt", Size: -1, // use unknown size during upload } var ( err error obj fs.Object uploadHash *hash.MultiHasher ) retry(t, "PutStream", func() error { contents := random.String(contentSize) buf := bytes.NewBufferString(contents) uploadHash = hash.NewMultiHasher() in := io.TeeReader(buf, uploadHash) file.Size = -1 obji := object.NewStaticObjectInfo(file.Path, file.ModTime, file.Size, true, nil, nil) obj, err = f.Features().PutStream(ctx, in, obji) return err }) file.Hashes = uploadHash.Sums() file.Size = int64(contentSize) // use correct size when checking file.Check(t, obj, f.Precision()) // Re-read the object and check again obj = fstest.NewObject(ctx, t, f, file.Path) file.Check(t, obj, f.Precision()) require.NoError(t, obj.Remove(ctx)) }) } }) // TestInternal calls InternalTest() on the Fs t.Run("Internal", func(t *testing.T) { skipIfNotOk(t) if it, ok := f.(InternalTester); ok { it.InternalTest(t) } else { t.Skipf("%T does not implement InternalTester", f) } }) }) // TestFsPutChunked may trigger large buffer allocation with // some backends (see fs/operations/xtra_operations_test.go), // keep it closer to the end of suite. t.Run("FsPutChunked", func(t *testing.T) { skipIfNotOk(t) if testing.Short() { t.Skip("not running with -short") } if opt.ChunkedUpload.Skip { t.Skip("skipping as ChunkedUpload.Skip is set") } setUploadChunkSizer, _ := f.(SetUploadChunkSizer) if setUploadChunkSizer == nil { t.Skipf("%T does not implement SetUploadChunkSizer", f) } setUploadCutoffer, _ := f.(SetUploadCutoffer) minChunkSize := max(opt.ChunkedUpload.MinChunkSize, 100) if opt.ChunkedUpload.CeilChunkSize != nil { minChunkSize = opt.ChunkedUpload.CeilChunkSize(minChunkSize) } maxChunkSize := max(2*fs.Mebi, 2*minChunkSize) if opt.ChunkedUpload.MaxChunkSize > 0 && maxChunkSize > opt.ChunkedUpload.MaxChunkSize { maxChunkSize = opt.ChunkedUpload.MaxChunkSize } if opt.ChunkedUpload.CeilChunkSize != nil { maxChunkSize = opt.ChunkedUpload.CeilChunkSize(maxChunkSize) } next := func(f func(fs.SizeSuffix) fs.SizeSuffix) fs.SizeSuffix { s := f(minChunkSize) if s > maxChunkSize { s = minChunkSize } return s } chunkSizes := fs.SizeSuffixList{ minChunkSize, minChunkSize + (maxChunkSize-minChunkSize)/3, next(NextPowerOfTwo), next(NextMultipleOf(100000)), next(NextMultipleOf(100001)), maxChunkSize, } chunkSizes.Sort() // Set the minimum chunk size, upload cutoff and reset it at the end oldChunkSize, err := setUploadChunkSizer.SetUploadChunkSize(minChunkSize) require.NoError(t, err) var oldUploadCutoff fs.SizeSuffix if setUploadCutoffer != nil { oldUploadCutoff, err = setUploadCutoffer.SetUploadCutoff(minChunkSize) require.NoError(t, err) } defer func() { _, err := setUploadChunkSizer.SetUploadChunkSize(oldChunkSize) assert.NoError(t, err) if setUploadCutoffer != nil { _, err := setUploadCutoffer.SetUploadCutoff(oldUploadCutoff) assert.NoError(t, err) } }() var lastCs fs.SizeSuffix for _, cs := range chunkSizes { if cs <= lastCs { continue } if opt.ChunkedUpload.CeilChunkSize != nil { cs = opt.ChunkedUpload.CeilChunkSize(cs) } lastCs = cs t.Run(cs.String(), func(t *testing.T) { _, err := setUploadChunkSizer.SetUploadChunkSize(cs) require.NoError(t, err) if setUploadCutoffer != nil { _, err = setUploadCutoffer.SetUploadCutoff(cs) require.NoError(t, err) } var testChunks []fs.SizeSuffix if opt.ChunkedUpload.NeedMultipleChunks { // If NeedMultipleChunks is set then test with > cs testChunks = []fs.SizeSuffix{cs + 1, 2 * cs, 2*cs + 1} } else { testChunks = []fs.SizeSuffix{cs - 1, cs, 2*cs + 1} } for _, fileSize := range testChunks { t.Run(fmt.Sprintf("%d", fileSize), func(t *testing.T) { TestPutLarge(ctx, t, f, &fstest.Item{ ModTime: fstest.Time("2001-02-03T04:05:06.499999999Z"), Path: fmt.Sprintf("chunked-%s-%s.bin", cs.String(), fileSize.String()), Size: int64(fileSize), }) t.Run("Streamed", func(t *testing.T) { if f.Features().PutStream == nil { t.Skip("FS has no PutStream interface") } TestPutLargeStreamed(ctx, t, f, &fstest.Item{ ModTime: fstest.Time("2001-02-03T04:05:06.499999999Z"), Path: fmt.Sprintf("chunked-%s-%s-streamed.bin", cs.String(), fileSize.String()), Size: int64(fileSize), }) }) }) } }) } }) // Copy files with chunked copy if available t.Run("FsCopyChunked", func(t *testing.T) { skipIfNotOk(t) if testing.Short() { t.Skip("not running with -short") } // Check have Copy doCopy := f.Features().Copy if doCopy == nil { t.Skip("FS has no Copier interface") } if opt.ChunkedUpload.Skip { t.Skip("skipping as ChunkedUpload.Skip is set") } do, _ := f.(SetCopyCutoffer) if do == nil { t.Skipf("%T does not implement SetCopyCutoff", f) } minChunkSize := max(opt.ChunkedUpload.MinChunkSize, 100) if opt.ChunkedUpload.CeilChunkSize != nil { minChunkSize = opt.ChunkedUpload.CeilChunkSize(minChunkSize) } // Test setting the copy cutoff before we get going _, err := do.SetCopyCutoff(minChunkSize) if errors.Is(err, fs.ErrorNotImplemented) { t.Skipf("%T does not support SetCopyCutoff: %v", f, err) } require.NoError(t, err) chunkSizes := fs.SizeSuffixList{ minChunkSize, minChunkSize + 1, 2*minChunkSize - 1, 2 * minChunkSize, 2*minChunkSize + 1, } for _, chunkSize := range chunkSizes { t.Run(fmt.Sprintf("%d", chunkSize), func(t *testing.T) { contents := random.String(int(chunkSize)) item := fstest.NewItem("chunked-copy", contents, fstest.Time("2001-05-06T04:05:06.499999999Z")) src := PutTestContents(ctx, t, f, &item, contents, true) defer func() { assert.NoError(t, src.Remove(ctx)) }() var itemCopy = item itemCopy.Path += ".copy" // Set copy cutoff to minimum value so we make chunks origCutoff, err := do.SetCopyCutoff(minChunkSize) require.NoError(t, err) defer func() { _, err = do.SetCopyCutoff(origCutoff) require.NoError(t, err) }() // Do the copy dst, err := doCopy(ctx, src, itemCopy.Path) require.NoError(t, err) defer func() { assert.NoError(t, dst.Remove(ctx)) }() // Check size assert.Equal(t, src.Size(), dst.Size()) // Check modtime srcModTime := src.ModTime(ctx) dstModTime := dst.ModTime(ctx) assert.True(t, srcModTime.Equal(dstModTime)) // Make sure contents are correct gotContents := ReadObject(ctx, t, dst, -1) assert.Equal(t, contents, gotContents) }) } }) // TestFsUploadUnknownSize ensures Fs.Put() and Object.Update() don't panic when // src.Size() == -1 // // This may trigger large buffer allocation in some backends, keep it // closer to the suite end. (See fs/operations/xtra_operations_test.go) t.Run("FsUploadUnknownSize", func(t *testing.T) { skipIfNotOk(t) t.Run("FsPutUnknownSize", func(t *testing.T) { defer func() { assert.Nil(t, recover(), "Fs.Put() should not panic when src.Size() == -1") }() contents := random.String(100) in := bytes.NewBufferString(contents) obji := object.NewStaticObjectInfo("unknown-size-put.txt", fstest.Time("2002-02-03T04:05:06.499999999Z"), -1, true, nil, nil) obj, err := f.Put(ctx, in, obji) if err == nil { require.NoError(t, obj.Remove(ctx), "successfully uploaded unknown-sized file but failed to remove") } // if err != nil: it's okay as long as no panic }) t.Run("FsUpdateUnknownSize", func(t *testing.T) { unknownSizeUpdateFile := fstest.Item{ ModTime: fstest.Time("2002-02-03T04:05:06.499999999Z"), Path: "unknown-size-update.txt", } testPut(ctx, t, f, &unknownSizeUpdateFile) defer func() { assert.Nil(t, recover(), "Object.Update() should not panic when src.Size() == -1") }() newContents := random.String(200) in := bytes.NewBufferString(newContents) obj := fstest.NewObject(ctx, t, f, unknownSizeUpdateFile.Path) obji := object.NewStaticObjectInfo(unknownSizeUpdateFile.Path, unknownSizeUpdateFile.ModTime, -1, true, nil, obj.Fs()) err := obj.Update(ctx, in, obji) if err == nil { require.NoError(t, obj.Remove(ctx), "successfully updated object with unknown-sized source but failed to remove") } // if err != nil: it's okay as long as no panic }) }) // TestFsRootCollapse tests if the root of an fs "collapses" to the // absolute root. It creates a new fs of the same backend type with its // root set to a *nonexistent* folder, and attempts to read the info of // an object in that folder, whose name is taken from a directory that // exists in the absolute root. // This test is added after // https://github.com/rclone/rclone/issues/3164. t.Run("FsRootCollapse", func(t *testing.T) { deepRemoteName := subRemoteName + "/deeper/nonexisting/directory" deepRemote, err := fs.NewFs(context.Background(), deepRemoteName) require.NoError(t, err) colonIndex := strings.IndexRune(deepRemoteName, ':') firstSlashIndex := strings.IndexRune(deepRemoteName, '/') firstDir := deepRemoteName[colonIndex+1 : firstSlashIndex] _, err = deepRemote.NewObject(ctx, firstDir) require.Equal(t, fs.ErrorObjectNotFound, err) // If err is not fs.ErrorObjectNotFound, it means the backend is // somehow confused about root and absolute root. }) // FsDirSetModTime tests setting the mod time on a directory if possible t.Run("FsDirSetModTime", func(t *testing.T) { const name = "dir-mod-time" do := f.Features().DirSetModTime if do == nil { t.Skip("FS has no DirSetModTime interface") } // Set ModTime on non existing directory should return error t1 := fstest.Time("2001-02-03T04:05:06.499999999Z") err := do(ctx, name, t1) require.Error(t, err) // Make the directory and try again err = f.Mkdir(ctx, name) require.NoError(t, err) err = do(ctx, name, t1) require.NoError(t, err) // Check the modtime got set properly dir := fstest.NewDirectory(ctx, t, f, name) fstest.CheckDirModTime(ctx, t, f, dir, t1) // Tidy up err = f.Rmdir(ctx, name) require.NoError(t, err) }) var testMetadata = fs.Metadata{ // System metadata supported by all backends "mtime": "2001-02-03T04:05:06.499999999Z", // User metadata "potato": "jersey", } var testMetadata2 = fs.Metadata{ // System metadata supported by all backends "mtime": "2002-02-03T04:05:06.499999999Z", // User metadata "potato": "king edwards", } // FsMkdirMetadata tests creating a directory with metadata if possible t.Run("FsMkdirMetadata", func(t *testing.T) { ctx, ci := fs.AddConfig(ctx) ci.Metadata = true const name = "dir-metadata" do := f.Features().MkdirMetadata if do == nil { t.Skip("FS has no MkdirMetadata interface") } assert.True(t, f.Features().WriteDirMetadata, "Backends must support Directory.SetMetadata and Fs.MkdirMetadata") // Create the directory from fresh dir, err := do(ctx, name, testMetadata) require.NoError(t, err) require.NotNil(t, dir) // Check the returned directory and one read from the listing fstest.CheckEntryMetadata(ctx, t, f, dir, testMetadata) fstest.CheckEntryMetadata(ctx, t, f, fstest.NewDirectory(ctx, t, f, name), testMetadata) // Now update the metadata on the existing directory t.Run("Update", func(t *testing.T) { dir, err := do(ctx, name, testMetadata2) require.NoError(t, err) require.NotNil(t, dir) // Check the returned directory and one read from the listing fstest.CheckEntryMetadata(ctx, t, f, dir, testMetadata2) // The TestUnionPolicy2 has randomness in it so it sets metadata on // one directory but can read a different one from the listing. if f.Name() != "TestUnionPolicy2" { fstest.CheckEntryMetadata(ctx, t, f, fstest.NewDirectory(ctx, t, f, name), testMetadata2) } }) // Now test the Directory methods t.Run("CheckDirectory", func(t *testing.T) { _, ok := dir.(fs.Object) assert.False(t, ok, "Directory must not type assert to Object") _, ok = dir.(fs.ObjectInfo) assert.False(t, ok, "Directory must not type assert to ObjectInfo") }) // Tidy up err = f.Rmdir(ctx, name) require.NoError(t, err) }) // FsDirectory checks methods on the directory object t.Run("FsDirectory", func(t *testing.T) { ctx, ci := fs.AddConfig(ctx) ci.Metadata = true const name = "dir-methods" features := f.Features() if !features.CanHaveEmptyDirectories { t.Skip("Can't test if can't have empty directories") } if !features.ReadDirMetadata && !features.WriteDirMetadata && !features.WriteDirSetModTime && !features.UserDirMetadata && !features.Overlay && features.UnWrap == nil { t.Skip("FS has no Directory methods and doesn't Wrap") } // Create a directory to start with err := f.Mkdir(ctx, name) require.NoError(t, err) // Get the directory object dir := fstest.NewDirectory(ctx, t, f, name) _, ok := dir.(fs.Object) assert.False(t, ok, "Directory must not type assert to Object") _, ok = dir.(fs.ObjectInfo) assert.False(t, ok, "Directory must not type assert to ObjectInfo") // Now test the directory methods t.Run("ReadDirMetadata", func(t *testing.T) { if !features.ReadDirMetadata { t.Skip("Directories don't support ReadDirMetadata") } if f.Name() == "TestUnionPolicy3" { t.Skipf("Test unreliable on %q", f.Name()) } fstest.CheckEntryMetadata(ctx, t, f, dir, fs.Metadata{ "mtime": dir.ModTime(ctx).Format(time.RFC3339Nano), }) }) t.Run("WriteDirMetadata", func(t *testing.T) { if !features.WriteDirMetadata { t.Skip("Directories don't support WriteDirMetadata") } assert.NotNil(t, features.MkdirMetadata, "Backends must support Directory.SetMetadata and Fs.MkdirMetadata") do, ok := dir.(fs.SetMetadataer) require.True(t, ok, "Expected to find SetMetadata method on Directory") err := do.SetMetadata(ctx, testMetadata) require.NoError(t, err) fstest.CheckEntryMetadata(ctx, t, f, dir, testMetadata) fstest.CheckEntryMetadata(ctx, t, f, fstest.NewDirectory(ctx, t, f, name), testMetadata) }) t.Run("WriteDirSetModTime", func(t *testing.T) { if !features.WriteDirSetModTime { t.Skip("Directories don't support WriteDirSetModTime") } assert.NotNil(t, features.DirSetModTime, "Backends must support Directory.SetModTime and Fs.DirSetModTime") t1 := fstest.Time("2001-02-03T04:05:10.123123123Z") do, ok := dir.(fs.SetModTimer) require.True(t, ok, "Expected to find SetMetadata method on Directory") err := do.SetModTime(ctx, t1) require.NoError(t, err) fstest.CheckDirModTime(ctx, t, f, dir, t1) fstest.CheckDirModTime(ctx, t, f, fstest.NewDirectory(ctx, t, f, name), t1) }) // Check to see if Fs that wrap other Directories implement all the optional methods t.Run("DirectoryCheckWrap", func(t *testing.T) { if opt.SkipDirectoryCheckWrap { t.Skip("Skipping DirectoryCheckWrap on this Fs") } if !features.Overlay && features.UnWrap == nil { t.Skip("Not a wrapping Fs") } _, unsupported := fs.DirectoryOptionalInterfaces(dir) for _, name := range unsupported { if !stringsContains(name, opt.UnimplementableDirectoryMethods) { t.Errorf("Missing Directory wrapper for %s", name) } } }) // Tidy up err = f.Rmdir(ctx, name) require.NoError(t, err) }) // Purge the folder err = operations.Purge(ctx, f, "") if !errors.Is(err, fs.ErrorDirNotFound) { require.NoError(t, err) } purged = true fstest.CheckListing(t, f, []fstest.Item{}) // Check purging again if not bucket-based if !isBucketBasedButNotRoot(f) { err = operations.Purge(ctx, f, "") assert.Error(t, err, "Expecting error after on second purge") if !errors.Is(err, fs.ErrorDirNotFound) { t.Log("Warning: this should produce fs.ErrorDirNotFound") } } }) // Check directory is purged if !purged { _ = operations.Purge(ctx, f, "") } t.Run("FsShutdown", func(t *testing.T) { do := f.Features().Shutdown if do == nil { t.Skip("Shutdown method not supported") } require.NoError(t, do(ctx)) require.NoError(t, do(ctx), "must be able to call Shutdown twice") }) // Remove the local directory so we don't clutter up /tmp if strings.HasPrefix(remoteName, "/") { t.Log("remoteName", remoteName) // Remove temp directory err := os.Remove(remoteName) require.NoError(t, err) } } rclone-v1.71.0/fstest/mockdir/000077500000000000000000000000001505210326400162065ustar00rootroot00000000000000rclone-v1.71.0/fstest/mockdir/dir.go000066400000000000000000000003761505210326400173210ustar00rootroot00000000000000// Package mockdir makes a mock fs.Directory object package mockdir import ( "time" "github.com/rclone/rclone/fs" ) // New makes a mock directory object with the name given func New(name string) fs.Directory { return fs.NewDir(name, time.Time{}) } rclone-v1.71.0/fstest/mockfs/000077500000000000000000000000001505210326400160405ustar00rootroot00000000000000rclone-v1.71.0/fstest/mockfs/mockfs.go000066400000000000000000000074651505210326400176650ustar00rootroot00000000000000// Package mockfs provides mock Fs for testing. package mockfs import ( "context" "errors" "fmt" "io" "path" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configmap" "github.com/rclone/rclone/fs/hash" ) // Register with Fs func Register() { fs.Register(&fs.RegInfo{ Name: "mockfs", Description: "Mock FS", NewFs: NewFs, Options: []fs.Option{{ Name: "potato", Help: "Does it have a potato?.", Required: true, }}, }) } // Fs is a minimal mock Fs type Fs struct { name string // the name of the remote root string // The root directory (OS path) features *fs.Features // optional features rootDir fs.DirEntries // directory listing of root hashes hash.Set // which hashes we support } // ErrNotImplemented is returned by unimplemented methods var ErrNotImplemented = errors.New("not implemented") // NewFs returns a new mock Fs func NewFs(ctx context.Context, name string, root string, config configmap.Mapper) (fs.Fs, error) { f := &Fs{ name: name, root: root, } f.features = (&fs.Features{}).Fill(ctx, f) return f, nil } // AddObject adds an Object for List to return // Only works for the root for the moment func (f *Fs) AddObject(o fs.Object) { f.rootDir = append(f.rootDir, o) // Make this object part of mockfs if possible do, ok := o.(interface{ SetFs(f fs.Fs) }) if ok { do.SetFs(f) } } // Name of the remote (as passed into NewFs) func (f *Fs) Name() string { return f.name } // Root of the remote (as passed into NewFs) func (f *Fs) Root() string { return f.root } // String returns a description of the FS func (f *Fs) String() string { return fmt.Sprintf("Mock file system at %s", f.root) } // Precision of the ModTimes in this Fs func (f *Fs) Precision() time.Duration { return time.Second } // Hashes returns the supported hash types of the filesystem func (f *Fs) Hashes() hash.Set { return f.hashes } // SetHashes sets the hashes that this supports func (f *Fs) SetHashes(hashes hash.Set) { f.hashes = hashes } // Features returns the optional features of this Fs func (f *Fs) Features() *fs.Features { return f.features } // List the objects and directories in dir into entries. The // entries can be returned in any order but should be for a // complete directory. // // dir should be "" to list the root, and should not have // trailing slashes. // // This should return ErrDirNotFound if the directory isn't // found. func (f *Fs) List(ctx context.Context, dir string) (entries fs.DirEntries, err error) { if dir == "" { return f.rootDir, nil } return entries, fs.ErrorDirNotFound } // NewObject finds the Object at remote. If it can't be found // it returns the error ErrorObjectNotFound. func (f *Fs) NewObject(ctx context.Context, remote string) (fs.Object, error) { dirPath := path.Dir(remote) if dirPath == "" || dirPath == "." { for _, entry := range f.rootDir { if entry.Remote() == remote { return entry.(fs.Object), nil } } } return nil, fs.ErrorObjectNotFound } // Put in to the remote path with the modTime given of the given size // // May create the object even if it returns an error - if so // will return the object and the error, otherwise will return // nil and the error func (f *Fs) Put(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) (fs.Object, error) { return nil, ErrNotImplemented } // Mkdir makes the directory (container, bucket) // // Shouldn't return an error if it already exists func (f *Fs) Mkdir(ctx context.Context, dir string) error { return ErrNotImplemented } // Rmdir removes the directory (container, bucket) if empty // // Return an error if it doesn't exist or isn't empty func (f *Fs) Rmdir(ctx context.Context, dir string) error { return ErrNotImplemented } // Assert it is the correct type var _ fs.Fs = (*Fs)(nil) rclone-v1.71.0/fstest/mockobject/000077500000000000000000000000001505210326400166765ustar00rootroot00000000000000rclone-v1.71.0/fstest/mockobject/mockobject.go000066400000000000000000000135621505210326400213540ustar00rootroot00000000000000// Package mockobject provides a mock object which can be created from a string package mockobject import ( "bytes" "context" "errors" "fmt" "io" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/hash" ) var errNotImpl = errors.New("not implemented") // Object is a mock fs.Object useful for testing type Object string // New returns mock fs.Object useful for testing func New(name string) Object { return Object(name) } // String returns a description of the Object func (o Object) String() string { return string(o) } // Fs returns read only access to the Fs that this object is part of func (o Object) Fs() fs.Info { return nil } // Remote returns the remote path func (o Object) Remote() string { return string(o) } // Hash returns the selected checksum of the file // If no checksum is available it returns "" func (o Object) Hash(ctx context.Context, t hash.Type) (string, error) { return "", errNotImpl } // ModTime returns the modification date of the file // It should return a best guess if one isn't available func (o Object) ModTime(ctx context.Context) (t time.Time) { return t } // Size returns the size of the file func (o Object) Size() int64 { return 0 } // Storable says whether this object can be stored func (o Object) Storable() bool { return true } // SetModTime sets the metadata on the object to set the modification date func (o Object) SetModTime(ctx context.Context, t time.Time) error { return errNotImpl } // Open opens the file for read. Call Close() on the returned io.ReadCloser func (o Object) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { return nil, errNotImpl } // Update in to the object with the modTime given of the given size func (o Object) Update(ctx context.Context, in io.Reader, src fs.ObjectInfo, options ...fs.OpenOption) error { return errNotImpl } // Remove this object func (o Object) Remove(ctx context.Context) error { return errNotImpl } // SeekMode specifies the optional Seek interface for the ReadCloser returned by Open type SeekMode int const ( // SeekModeNone specifies no seek interface SeekModeNone SeekMode = iota // SeekModeRegular specifies the regular io.Seek interface SeekModeRegular // SeekModeRange specifies the fs.RangeSeek interface SeekModeRange ) // SeekModes contains all valid SeekMode's var SeekModes = []SeekMode{SeekModeNone, SeekModeRegular, SeekModeRange} // ContentMockObject mocks an fs.Object and has content, mod time type ContentMockObject struct { Object content []byte seekMode SeekMode f fs.Fs unknownSize bool modTime time.Time } // WithContent returns an fs.Object with the given content. func (o Object) WithContent(content []byte, mode SeekMode) *ContentMockObject { return &ContentMockObject{ Object: o, content: content, seekMode: mode, } } // SetFs sets the return value of the Fs() call func (o *ContentMockObject) SetFs(f fs.Fs) { o.f = f } // SetUnknownSize makes the mock object return -1 for size if true func (o *ContentMockObject) SetUnknownSize(unknownSize bool) { o.unknownSize = unknownSize } // Fs returns read only access to the Fs that this object is part of // // This is nil unless SetFs has been called func (o *ContentMockObject) Fs() fs.Info { return o.f } // Open opens the file for read. Call Close() on the returned io.ReadCloser func (o *ContentMockObject) Open(ctx context.Context, options ...fs.OpenOption) (io.ReadCloser, error) { size := int64(len(o.content)) var offset, limit int64 = 0, -1 for _, option := range options { switch x := option.(type) { case *fs.SeekOption: offset = x.Offset case *fs.RangeOption: offset, limit = x.Decode(size) default: if option.Mandatory() { return nil, fmt.Errorf("unsupported mandatory option: %v", option) } } } if limit == -1 || offset+limit > size { limit = size - offset } var r *bytes.Reader if o.seekMode == SeekModeNone { r = bytes.NewReader(o.content[offset : offset+limit]) } else { r = bytes.NewReader(o.content) _, err := r.Seek(offset, io.SeekStart) if err != nil { return nil, err } } switch o.seekMode { case SeekModeNone: return &readCloser{r}, nil case SeekModeRegular: return &readSeekCloser{r}, nil case SeekModeRange: return &readRangeSeekCloser{r}, nil default: return nil, errors.New(o.seekMode.String()) } } // Size returns the size of the file func (o *ContentMockObject) Size() int64 { if o.unknownSize { return -1 } return int64(len(o.content)) } // Hash returns the selected checksum of the file // If no checksum is available it returns "" func (o *ContentMockObject) Hash(ctx context.Context, t hash.Type) (string, error) { hasher, err := hash.NewMultiHasherTypes(hash.NewHashSet(t)) if err != nil { return "", err } _, err = hasher.Write(o.content) if err != nil { return "", err } return hasher.Sums()[t], nil } // ModTime returns the modification date of the file // It should return a best guess if one isn't available func (o *ContentMockObject) ModTime(ctx context.Context) time.Time { return o.modTime } // SetModTime sets the metadata on the object to set the modification date func (o *ContentMockObject) SetModTime(ctx context.Context, t time.Time) error { o.modTime = t return nil } type readCloser struct{ io.Reader } func (r *readCloser) Close() error { return nil } type readSeekCloser struct{ io.ReadSeeker } func (r *readSeekCloser) Close() error { return nil } type readRangeSeekCloser struct{ io.ReadSeeker } func (r *readRangeSeekCloser) RangeSeek(offset int64, whence int, length int64) (int64, error) { return r.ReadSeeker.Seek(offset, whence) } func (r *readRangeSeekCloser) Close() error { return nil } func (m SeekMode) String() string { switch m { case SeekModeNone: return "SeekModeNone" case SeekModeRegular: return "SeekModeRegular" case SeekModeRange: return "SeekModeRange" default: return fmt.Sprintf("SeekModeInvalid(%d)", m) } } rclone-v1.71.0/fstest/run.go000066400000000000000000000256621505210326400157240ustar00rootroot00000000000000/* This provides Run for use in creating test suites To use this declare a TestMain // TestMain drives the tests func TestMain(m *testing.M) { fstest.TestMain(m) } And then make and destroy a Run in each test func TestMkdir(t *testing.T) { r := fstest.NewRun(t) defer r.Finalise() // test stuff } This will make r.Fremote and r.Flocal for a remote and a local remote. The remote is determined by the -remote flag passed in. */ package fstest import ( "bytes" "context" "flag" "fmt" "log" "os" "path" "path/filepath" "sort" "testing" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/cache" "github.com/rclone/rclone/fs/fserrors" "github.com/rclone/rclone/fs/hash" "github.com/rclone/rclone/fs/object" "github.com/rclone/rclone/fs/walk" "github.com/rclone/rclone/lib/file" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Run holds the remotes for a test run type Run struct { LocalName string Flocal fs.Fs Fremote fs.Fs FremoteName string Precision time.Duration cleanRemote func() mkdir map[string]bool // whether the remote has been made yet for the fs name Logf, Fatalf func(text string, args ...any) } // TestMain drives the tests func TestMain(m *testing.M) { flag.Parse() if !*Individual { oneRun = newRun() } rc := m.Run() if !*Individual { oneRun.Finalise() } os.Exit(rc) } // oneRun holds the master run data if individual is not set var oneRun *Run // newRun initialise the remote and local for testing and returns a // run object. // // r.Flocal is an empty local Fs // r.Fremote is an empty remote Fs // // Finalise() will tidy them away when done. func newRun() *Run { r := &Run{ Logf: log.Printf, Fatalf: log.Fatalf, mkdir: make(map[string]bool), } Initialise() var err error r.Fremote, r.FremoteName, r.cleanRemote, err = RandomRemote() if err != nil { r.Fatalf("Failed to open remote %q: %v", *RemoteName, err) } r.LocalName, err = os.MkdirTemp("", "rclone") if err != nil { r.Fatalf("Failed to create temp dir: %v", err) } r.LocalName = filepath.ToSlash(r.LocalName) r.Flocal, err = fs.NewFs(context.Background(), r.LocalName) if err != nil { r.Fatalf("Failed to make %q: %v", r.LocalName, err) } r.Precision = fs.GetModifyWindow(context.Background(), r.Fremote, r.Flocal) return r } // run f(), retrying it until it returns with no error or the limit // expires and it calls t.Fatalf func retry(t *testing.T, what string, f func() error) { var err error for try := 1; try <= *ListRetries; try++ { err = f() if err == nil { return } t.Logf("%s failed - try %d/%d: %v", what, try, *ListRetries, err) time.Sleep(time.Second) } t.Logf("%s failed: %v", what, err) } // newRunIndividual initialise the remote and local for testing and // returns a run object. Pass in true to make individual tests or // false to use the global one. // // r.Flocal is an empty local Fs // r.Fremote is an empty remote Fs // // Finalise() will tidy them away when done. func newRunIndividual(t *testing.T, individual bool) *Run { ctx := context.Background() var r *Run if individual { r = newRun() } else { // If not individual, use the global one with the clean method overridden r = new(Run) *r = *oneRun r.cleanRemote = func() { var toDelete []string err := walk.ListR(ctx, r.Fremote, "", true, -1, walk.ListAll, func(entries fs.DirEntries) error { for _, entry := range entries { switch x := entry.(type) { case fs.Object: retry(t, fmt.Sprintf("removing file %q", x.Remote()), func() error { return x.Remove(ctx) }) case fs.Directory: toDelete = append(toDelete, x.Remote()) } } return nil }) if err == fs.ErrorDirNotFound { return } require.NoError(t, err) sort.Strings(toDelete) for i := len(toDelete) - 1; i >= 0; i-- { dir := toDelete[i] retry(t, fmt.Sprintf("removing dir %q", dir), func() error { return r.Fremote.Rmdir(ctx, dir) }) } // Check remote is empty CheckListingWithPrecision(t, r.Fremote, []Item{}, []string{}, r.Fremote.Precision()) // Clear the remote cache cache.Clear() } } r.Logf = t.Logf r.Fatalf = t.Fatalf r.Logf("Remote %q, Local %q, Modify Window %q", r.Fremote, r.Flocal, fs.GetModifyWindow(ctx, r.Fremote)) t.Cleanup(r.Finalise) return r } // NewRun initialise the remote and local for testing and returns a // run object. Call this from the tests. // // r.Flocal is an empty local Fs // r.Fremote is an empty remote Fs func NewRun(t *testing.T) *Run { return newRunIndividual(t, *Individual) } // NewRunIndividual as per NewRun but makes an individual remote for this test func NewRunIndividual(t *testing.T) *Run { return newRunIndividual(t, true) } // RenameFile renames a file in local func (r *Run) RenameFile(item Item, newpath string) Item { oldFilepath := path.Join(r.LocalName, item.Path) newFilepath := path.Join(r.LocalName, newpath) if err := os.Rename(oldFilepath, newFilepath); err != nil { r.Fatalf("Failed to rename file from %q to %q: %v", item.Path, newpath, err) } item.Path = newpath return item } // WriteFile writes a file to local func (r *Run) WriteFile(filePath, content string, t time.Time) Item { item := NewItem(filePath, content, t) // FIXME make directories? filePath = path.Join(r.LocalName, filePath) dirPath := path.Dir(filePath) err := file.MkdirAll(dirPath, 0770) if err != nil { r.Fatalf("Failed to make directories %q: %v", dirPath, err) } err = os.WriteFile(filePath, []byte(content), 0600) if err != nil { r.Fatalf("Failed to write file %q: %v", filePath, err) } err = os.Chtimes(filePath, t, t) if err != nil { r.Fatalf("Failed to chtimes file %q: %v", filePath, err) } return item } // ForceMkdir creates the remote func (r *Run) ForceMkdir(ctx context.Context, f fs.Fs) { err := f.Mkdir(ctx, "") if err != nil { r.Fatalf("Failed to mkdir %q: %v", f, err) } r.mkdir[f.String()] = true } // Mkdir creates the remote if it hasn't been created already func (r *Run) Mkdir(ctx context.Context, f fs.Fs) { if !r.mkdir[f.String()] { r.ForceMkdir(ctx, f) } } // WriteObjectTo writes an object to the fs, remote passed in func (r *Run) WriteObjectTo(ctx context.Context, f fs.Fs, remote, content string, modTime time.Time, useUnchecked bool) Item { put := f.Put if useUnchecked { put = f.Features().PutUnchecked if put == nil { r.Fatalf("Fs doesn't support PutUnchecked") } } r.Mkdir(ctx, f) // calculate all hashes f supports for content hash, err := hash.NewMultiHasherTypes(f.Hashes()) if err != nil { r.Fatalf("Failed to make new multi hasher: %v", err) } _, err = hash.Write([]byte(content)) if err != nil { r.Fatalf("Failed to make write to hash: %v", err) } hashSums := hash.Sums() const maxTries = 10 for tries := 1; ; tries++ { in := bytes.NewBufferString(content) objinfo := object.NewStaticObjectInfo(remote, modTime, int64(len(content)), true, hashSums, nil) _, err := put(ctx, in, objinfo) if err == nil { break } // Retry if err returned a retry error if fserrors.IsRetryError(err) && tries < maxTries { r.Logf("Retry Put of %q to %v: %d/%d (%v)", remote, f, tries, maxTries, err) time.Sleep(2 * time.Second) continue } r.Fatalf("Failed to put %q to %q: %v", remote, f, err) } return NewItem(remote, content, modTime) } // WriteObject writes an object to the remote func (r *Run) WriteObject(ctx context.Context, remote, content string, modTime time.Time) Item { return r.WriteObjectTo(ctx, r.Fremote, remote, content, modTime, false) } // WriteUncheckedObject writes an object to the remote not checking for duplicates func (r *Run) WriteUncheckedObject(ctx context.Context, remote, content string, modTime time.Time) Item { return r.WriteObjectTo(ctx, r.Fremote, remote, content, modTime, true) } // WriteBoth calls WriteObject and WriteFile with the same arguments func (r *Run) WriteBoth(ctx context.Context, remote, content string, modTime time.Time) Item { r.WriteFile(remote, content, modTime) return r.WriteObject(ctx, remote, content, modTime) } // CheckWithDuplicates does a test but allows duplicates func (r *Run) CheckWithDuplicates(t *testing.T, items ...Item) { var want, got []string // construct a []string of desired items for _, item := range items { want = append(want, fmt.Sprintf("%q %d", item.Path, item.Size)) } sort.Strings(want) // do the listing objs, _, err := walk.GetAll(context.Background(), r.Fremote, "", true, -1) if err != nil && err != fs.ErrorDirNotFound { t.Fatalf("Error listing: %v", err) } // construct a []string of actual items for _, o := range objs { got = append(got, fmt.Sprintf("%q %d", o.Remote(), o.Size())) } sort.Strings(got) assert.Equal(t, want, got) } // CheckLocalItems checks the local fs with proper precision // to see if it has the expected items. func (r *Run) CheckLocalItems(t *testing.T, items ...Item) { CheckItemsWithPrecision(t, r.Flocal, r.Precision, items...) } // CheckRemoteItems checks the remote fs with proper precision // to see if it has the expected items. func (r *Run) CheckRemoteItems(t *testing.T, items ...Item) { CheckItemsWithPrecision(t, r.Fremote, r.Precision, items...) } // CheckLocalListing checks the local fs with proper precision // to see if it has the expected contents. // // If expectedDirs is non nil then we check those too. Note that no // directories returned is also OK as some remotes don't return // directories. func (r *Run) CheckLocalListing(t *testing.T, items []Item, expectedDirs []string) { CheckListingWithPrecision(t, r.Flocal, items, expectedDirs, r.Precision) } // CheckRemoteListing checks the remote fs with proper precision // to see if it has the expected contents. // // If expectedDirs is non nil then we check those too. Note that no // directories returned is also OK as some remotes don't return // directories. func (r *Run) CheckRemoteListing(t *testing.T, items []Item, expectedDirs []string) { CheckListingWithPrecision(t, r.Fremote, items, expectedDirs, r.Precision) } // CheckDirectoryModTimes checks that the directory names in r.Flocal has the correct modtime compared to r.Fremote func (r *Run) CheckDirectoryModTimes(t *testing.T, names ...string) { if r.Fremote.Features().DirSetModTime == nil && r.Fremote.Features().MkdirMetadata == nil { fs.Debugf(r.Fremote, "Skipping modtime test as remote does not support DirSetModTime or MkdirMetadata") return } ctx := context.Background() for _, name := range names { wantT := NewDirectory(ctx, t, r.Flocal, name).ModTime(ctx) got := NewDirectory(ctx, t, r.Fremote, name) CheckDirModTime(ctx, t, r.Fremote, got, wantT) } } // Clean the temporary directory func (r *Run) cleanTempDir() { err := os.RemoveAll(r.LocalName) if err != nil { r.Logf("Failed to clean temporary directory %q: %v", r.LocalName, err) } } // Finalise cleans the remote and local func (r *Run) Finalise() { // r.Logf("Cleaning remote %q", r.Fremote) r.cleanRemote() // r.Logf("Cleaning local %q", r.LocalName) r.cleanTempDir() // Clear the remote cache cache.Clear() } rclone-v1.71.0/fstest/test_all/000077500000000000000000000000001505210326400163655ustar00rootroot00000000000000rclone-v1.71.0/fstest/test_all/clean.go000066400000000000000000000041571505210326400200050ustar00rootroot00000000000000// Clean the left over test files package main import ( "context" "fmt" "regexp" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fspath" "github.com/rclone/rclone/fs/list" "github.com/rclone/rclone/fs/operations" ) // MatchTestRemote matches the remote names used for testing (copied // from fstest/fstest.go so we don't have to import that and get all // its flags) var MatchTestRemote = regexp.MustCompile(`^rclone-test-[abcdefghijklmnopqrstuvwxyz0123456789]{12,24}(_segments)?$`) // cleanFs runs a single clean fs for left over directories func cleanFs(ctx context.Context, remote string, cleanup bool) error { f, err := fs.NewFs(context.Background(), remote) if err != nil { return err } var lastErr error if cleanup { fs.Logf(nil, "%q - running cleanup", remote) err = operations.CleanUp(ctx, f) if err != nil { lastErr = err fs.Errorf(f, "Cleanup failed: %v", err) } } entries, err := list.DirSorted(ctx, f, true, "") if err != nil { return err } err = entries.ForDirError(func(dir fs.Directory) error { dirPath := dir.Remote() fullPath := fspath.JoinRootPath(remote, dirPath) if MatchTestRemote.MatchString(dirPath) { if *dryRun { fs.Logf(nil, "Not Purging %s - -dry-run", fullPath) return nil } fs.Logf(nil, "Purging %s", fullPath) dir, err := fs.NewFs(context.Background(), fullPath) if err != nil { err = fmt.Errorf("NewFs failed: %w", err) lastErr = err fs.Errorf(fullPath, "%v", err) return nil } err = operations.Purge(ctx, dir, "") if err != nil { err = fmt.Errorf("purge failed: %w", err) lastErr = err fs.Errorf(dir, "%v", err) return nil } } return nil }) if err != nil { return err } return lastErr } // cleanRemotes cleans the list of remotes passed in func cleanRemotes(conf *Config) error { var lastError error for _, backend := range conf.Backends { remote := backend.Remote fs.Logf(nil, "%q - Cleaning", remote) err := cleanFs(context.Background(), remote, backend.CleanUp) if err != nil { lastError = err fs.Logf(nil, "Failed to purge %q: %v", remote, err) } } return lastError } rclone-v1.71.0/fstest/test_all/config.go000066400000000000000000000124541505210326400201670ustar00rootroot00000000000000// Config handling package main import ( "fmt" "os" "path" "slices" "github.com/rclone/rclone/fs" yaml "gopkg.in/yaml.v3" ) // Test describes an integration test to run with `go test` type Test struct { Path string // path to the source directory FastList bool // if it is possible to add -fast-list to tests Short bool // if it is possible to run the test with -short AddBackend bool // set if Path needs the current backend appending NoRetries bool // set if no retries should be performed NoBinary bool // set to not build a binary in advance LocalOnly bool // if set only run with the local backend } // Backend describes a backend test // // FIXME make bucket-based remotes set sub-dir automatically??? type Backend struct { Backend string // name of the backend directory Remote string // name of the test remote FastList bool // set to test with -fast-list Short bool // set to test with -short OneOnly bool // set to run only one backend test at once MaxFile string // file size limit CleanUp bool // when running clean, run cleanup first Ignore []string // test names to ignore the failure of Tests []string // paths of tests to run, blank for all IgnoreTests []string // paths of tests not to run, blank for none ListRetries int // -list-retries if > 0 ExtraTime float64 // factor to multiply the timeout by Env []string // environment variables to set in form KEY=VALUE } // includeTest returns true if this backend should be included in this // test func (b *Backend) includeTest(t *Test) bool { // Is this test ignored if slices.Contains(b.IgnoreTests, t.Path) { return false } // Empty b.Tests imples do all of them except the ignored if len(b.Tests) == 0 { return true } return slices.Contains(b.Tests, t.Path) } // MakeRuns creates Run objects the Backend and Test // // There can be several created, one for each combination of optional // flags (e.g. FastList) func (b *Backend) MakeRuns(t *Test) (runs []*Run) { if !b.includeTest(t) { return runs } maxSize := fs.SizeSuffix(0) if b.MaxFile != "" { if err := maxSize.Set(b.MaxFile); err != nil { fs.Logf(nil, "Invalid maxfile value %q: %v", b.MaxFile, err) } } fastlists := []bool{false} if b.FastList && t.FastList { fastlists = append(fastlists, true) } ignore := make(map[string]struct{}, len(b.Ignore)) for _, item := range b.Ignore { ignore[item] = struct{}{} } for _, fastlist := range fastlists { if t.LocalOnly && b.Backend != "local" { continue } run := &Run{ Remote: b.Remote, Backend: b.Backend, Path: t.Path, FastList: fastlist, Short: (b.Short && t.Short), NoRetries: t.NoRetries, OneOnly: b.OneOnly, NoBinary: t.NoBinary, SizeLimit: int64(maxSize), Ignore: ignore, ListRetries: b.ListRetries, ExtraTime: b.ExtraTime, Env: b.Env, } if t.AddBackend { run.Path = path.Join(run.Path, b.Backend) } runs = append(runs, run) } return runs } // Config describes the config for this program type Config struct { Tests []Test Backends []Backend } // NewConfig reads the config file func NewConfig(configFile string) (*Config, error) { d, err := os.ReadFile(configFile) if err != nil { return nil, fmt.Errorf("failed to read config file: %w", err) } config := &Config{} err = yaml.Unmarshal(d, &config) if err != nil { return nil, fmt.Errorf("failed to parse config file: %w", err) } // d, err = yaml.Marshal(&config) // if err != nil { // log.Fatalf("error: %v", err) // } // fmt.Printf("--- m dump:\n%s\n\n", string(d)) return config, nil } // MakeRuns makes Run objects for each combination of Backend and Test // in the config func (c *Config) MakeRuns() (runs Runs) { for _, backend := range c.Backends { for _, test := range c.Tests { runs = append(runs, backend.MakeRuns(&test)...) } } return runs } // Filter the Backends with the remotes passed in. // // If no backend is found with a remote is found then synthesize one func (c *Config) filterBackendsByRemotes(remotes []string) { var newBackends []Backend for _, name := range remotes { found := false for i := range c.Backends { if c.Backends[i].Remote == name { newBackends = append(newBackends, c.Backends[i]) found = true } } if !found { fs.Logf(nil, "Remote %q not found - inserting with default flags", name) // Lookup which backend fsInfo, _, _, _, err := fs.ConfigFs(name) if err != nil { fs.Fatalf(nil, "couldn't find remote %q: %v", name, err) } newBackends = append(newBackends, Backend{Backend: fsInfo.FileName(), Remote: name}) } } c.Backends = newBackends } // Filter the Backends with the backendNames passed in func (c *Config) filterBackendsByBackends(backendNames []string) { var newBackends []Backend for _, name := range backendNames { for i := range c.Backends { if c.Backends[i].Backend == name { newBackends = append(newBackends, c.Backends[i]) } } } c.Backends = newBackends } // Filter the incoming tests into the backends selected func (c *Config) filterTests(paths []string) { var newTests []Test for _, path := range paths { for i := range c.Tests { if c.Tests[i].Path == path { newTests = append(newTests, c.Tests[i]) } } } c.Tests = newTests } rclone-v1.71.0/fstest/test_all/config.yaml000066400000000000000000000433041505210326400205220ustar00rootroot00000000000000tests: - path: backend addbackend: true nobinary: true short: true - path: fs/operations fastlist: true - path: fs/sync fastlist: true - path: cmd/bisync - path: cmd/gitannex - path: vfs - path: cmd/serve/restic localonly: true # - path: cmd/serve/docker # localonly: true - path: cmd/selfupdate localonly: true backends: - backend: "local" remote: "" fastlist: false - backend: "b2" remote: "TestB2:" fastlist: true listretries: 5 ignore: # This test fails because B2 versions make the empty bucket undeleteable. # It isn't possible to turn off versions, and setting hard_delete doesn't stop # versions being made on overwrite. - TestRmdirsNoLeaveRoot - backend: "crypt" remote: "TestCryptDrive:" fastlist: true ignore: - TestCopyFileMaxTransfer # - backend: "crypt" # remote: "TestCryptSwift:" # fastlist: false ## chunker - backend: "chunker" remote: "TestChunkerLocal:" fastlist: true - backend: "chunker" remote: "TestChunkerNometaLocal:" fastlist: true - backend: "chunker" remote: "TestChunkerChunk3bLocal:" fastlist: true maxfile: 6k - backend: "chunker" remote: "TestChunkerChunk3bNometaLocal:" fastlist: true maxfile: 6k - backend: "chunker" remote: "TestChunkerChunk3bNoRenameLocal:" fastlist: true maxfile: 6k # - backend: "chunker" # remote: "TestChunkerMailru:" # fastlist: true # ignore: # - TestApplyTransforms # - backend: "chunker" # remote: "TestChunkerChunk50bMailru:" # fastlist: true # maxfile: 10k # ignore: # - TestApplyTransforms # - backend: "chunker" # remote: "TestChunkerChunk50bYandex:" # fastlist: true # maxfile: 1k # ignore: # # Needs investigation # - TestDeduplicateNewestByHash # - backend: "chunker" # remote: "TestChunkerChunk50bBox:" # fastlist: true # maxfile: 1k # ignore: # - TestIntegration/FsMkdir/FsChangeNotify - backend: "chunker" remote: "TestChunkerS3:" fastlist: true - backend: "chunker" remote: "TestChunkerChunk50bS3:" fastlist: true maxfile: 1k - backend: "chunker" remote: "TestChunkerChunk50bMD5HashS3:" fastlist: true maxfile: 1k - backend: "chunker" remote: "TestChunkerChunk50bSHA1HashS3:" fastlist: true maxfile: 1k - backend: "chunker" remote: "TestChunkerOverCrypt:" fastlist: true maxfile: 6k - backend: "chunker" remote: "TestChunkerChunk50bMD5QuickS3:" fastlist: true maxfile: 1k - backend: "chunker" remote: "TestChunkerChunk50bSHA1QuickS3:" fastlist: true maxfile: 1k ## end chunker - backend: "cloudinary" remote: "TestCloudinary:" fastlist: false ignore: # fs/operations - TestCheckSum - TestCheckSumDownload - TestHashSums/Md5 - TestReadFile - TestCopyURL - TestMoveFileWithIgnoreExisting - TestCopyFileCompareDest #vfs - TestFileSetModTime/cache=off,open=false,write=false - TestFileSetModTime/cache=off,open=true,write=false - TestRWFileHandleWriteNoWrite ignoretests: - cmd/gitannex - backend: "combine" remote: "TestCombine:dir1" fastlist: false ## begin compress - backend: "compress" remote: "TestCompress:" fastlist: false # - backend: "compress" # remote: "TestCompressSwift:" # fastlist: false - backend: "compress" remote: "TestCompressDrive:" fastlist: false - backend: "compress" remote: "TestCompressS3:" fastlist: false ## end compress - backend: "drive" remote: "TestDrive:" fastlist: true ignore: # Test with CutoffModeHard does not result in ErrorMaxTransferLimitReachedFatal # because googleapi replaces it with a non-fatal error - TestCopyFileMaxTransfer - backend: "dropbox" remote: "TestDropbox:" fastlist: false # - backend: "filefabric" # remote: "TestFileFabric:" # fastlist: false # extratime: 2.0 - backend: "gofile" remote: "TestGoFile:" fastlist: true - backend: "filescom" remote: "TestFilesCom:" fastlist: false ignoretests: - cmd/bisync - backend: "googlecloudstorage" remote: "TestGoogleCloudStorage:" fastlist: true ignoretests: - cmd/gitannex - backend: "googlecloudstorage" remote: "TestGoogleCloudStorage,directory_markers:" fastlist: true ignoretests: - cmd/gitannex - backend: "googlephotos" remote: "TestGooglePhotos:" tests: - backend - backend: "hidrive" remote: "TestHiDrive:" fastlist: false - backend: "imagekit" remote: "TestImageKit:" fastlist: false ignore: - TestIntegration/FsMkdir/FsPutZeroLength ignoretests: - cmd/bisync - backend: "internetarchive" remote: "TestIA:rclone-integration-test" fastlist: true tests: - backend ignore: - TestIntegration/FsMkdir/FsEncoding extratime: 2.0 - backend: "jottacloud" remote: "TestJottacloud:" fastlist: true ignoretests: - cmd/bisync - backend: "memory" remote: ":memory:" fastlist: true - backend: "netstorage" remote: "TestnStorage:" fastlist: true ignoretests: - cmd/bisync - backend: "onedrive" remote: "TestOneDrive:" fastlist: false ignore: # This test doesn't work on a standard Onedrive account returning # accessDenied: accountUpgradeRequired: Account Upgrade is required for this operation. - TestIntegration/FsMkdir/FsPutFiles/PublicLink - backend: "onedrive" remote: "TestOneDriveBusiness:" fastlist: false # - backend: "onedrive" # remote: "TestOneDriveCn:" # fastlist: false - backend: "s3" remote: "TestS3:" fastlist: true - backend: "s3" remote: "TestS3,directory_markers:" fastlist: true - backend: "s3" remote: "TestS3Rclone:" fastlist: true ignoretests: - cmd/bisync - cmd/gitannex - backend: "s3" remote: "TestS3Minio:" fastlist: true ignore: - TestIntegration/FsMkdir/FsPutFiles/SetTier - TestIntegration/FsMkdir/FsEncoding/control_chars - TestIntegration/FsMkdir/FsEncoding/leading_LF - TestIntegration/FsMkdir/FsEncoding/leading_VT - TestIntegration/FsMkdir/FsEncoding/punctuation - TestIntegration/FsMkdir/FsEncoding/trailing_LF - TestIntegration/FsMkdir/FsEncoding/trailing_VT - backend: "s3" remote: "TestS3MinioEdge:" fastlist: true ignore: - TestIntegration/FsMkdir/FsPutFiles/SetTier ignoretests: - cmd/gitannex - backend: "s3" remote: "TestS3Wasabi:" fastlist: true ignore: - TestIntegration/FsMkdir/FsEncoding/leading_CR - TestIntegration/FsMkdir/FsEncoding/leading_LF - TestIntegration/FsMkdir/FsEncoding/leading_HT - TestIntegration/FsMkdir/FsEncoding/leading_VT - TestIntegration/FsMkdir/FsPutFiles/FsPutStream/0 - backend: "s3" remote: "TestS3GCS:" fastlist: true ignore: - TestIntegration/FsMkdir/FsEncoding/control_chars - TestIntegration/FsMkdir/FsEncoding/leading_CR - TestIntegration/FsMkdir/FsEncoding/leading_LF - TestIntegration/FsMkdir/FsEncoding/trailing_CR - TestIntegration/FsMkdir/FsEncoding/trailing_LF - TestIntegration/FsMkdir/FsPutFiles/PublicLink - TestIntegration/FsMkdir/FsPutFiles/SetTier - TestIntegration/FsMkdir/FsPutFiles/Internal/Metadata/GzipEncoding - TestIntegration/FsMkdir/FsPutFiles/Internal/Versions/VersionAt/AfterDelete/List - TestIntegration/FsMkdir/FsPutFiles/Internal/Versions/VersionAt/AfterDelete/NewObject - TestIntegration/FsMkdir/FsPutFiles/Internal/Versions/VersionAt/AfterTwo/List - TestIntegration/FsMkdir/FsPutFiles/Internal/Versions/VersionAt/AfterTwo/NewObject - TestBisyncRemoteRemote/extended_filenames # Disabled due to excessive rate limiting at DO which cause the tests never to pass # This hits the rate limit as documented here: https://www.digitalocean.com/docs/spaces/#limits # 2 COPYs per 5 minutes on any individual object in a Space # - backend: "s3" # remote: "TestS3DigitalOcean:" # fastlist: true # ignore: # - TestIntegration/FsMkdir/FsPutFiles/FsCopy # - TestIntegration/FsMkdir/FsPutFiles/SetTier # - backend: "s3" # remote: "TestS3Ceph:" # fastlist: true # ignore: # - TestIntegration/FsMkdir/FsPutFiles/FsCopy # - TestIntegration/FsMkdir/FsPutFiles/SetTier - backend: "s3" remote: "TestS3Alibaba:" fastlist: true # - backend: "s3" # remote: "TestS3Qiniu:" # fastlist: true # ignore: # - TestIntegration/FsMkdir/FsEncoding/control_chars # - TestIntegration/FsMkdir/FsEncoding/leading_VT # - TestIntegration/FsMkdir/FsEncoding/trailing_VT # - TestIntegration/FsMkdir/FsPutFiles/FromRoot/ListR # - TestIntegration/FsMkdir/FsPutFiles/SetTier # - TestIntegration/FsMkdir/FsPutFiles/FsPutStream/0 # - TestIntegration/FsMkdir/FsPutFiles/Internal/Metadata - backend: "s3" remote: "TestS3R2:" fastlist: true ignore: - TestIntegration/FsMkdir/FsPutFiles/SetTier # - backend: "s3" # remote: "TestS3FlashBlade:" # fastlist: true - backend: "sftp" remote: "TestSFTPOpenssh:" fastlist: false ignoretests: - cmd/gitannex - backend: "sftp" remote: "TestSFTPRclone:" fastlist: false ignoretests: - cmd/gitannex - backend: "sftp" remote: "TestSFTPRcloneSSH:" fastlist: false ignoretests: - cmd/gitannex - backend: "sftp" remote: "TestSFTPRsyncNet:" fastlist: false ignore: - TestIntegration/FsMkdir/FsEncoding/trailing_space - TestIntegration/FsMkdir/FsEncoding/trailing_CR - TestIntegration/FsMkdir/FsEncoding/trailing_LF - TestIntegration/FsMkdir/FsEncoding/trailing_HT - TestIntegration/FsMkdir/FsEncoding/trailing_VT - TestIntegration/FsMkdir/FsEncoding/trailing_dot - TestIntegration/FsMkdir/FsEncoding/invalid_UTF-8 - TestIntegration/FsMkdir/FsEncoding/URL_encoding ignoretests: - cmd/bisync - backend: "sugarsync" remote: "TestSugarSync:Test" fastlist: false ignore: - TestIntegration/FsMkdir/FsPutFiles/PublicLink - backend: "swift" remote: "TestSwiftAIO:" fastlist: true ignoretests: - cmd/gitannex - backend: "swift" remote: "TestSwiftAIOsegments:" fastlist: true ignoretests: - cmd/gitannex # - backend: "swift" # remote: "TestSwift:" # fastlist: true # ignoretests: # - cmd/bisync # - backend: "swift" # remote: "TestSwiftCeph:" # fastlist: true # ignore: # - TestIntegration/FsMkdir/FsPutFiles/FsCopy - backend: "yandex" remote: "TestYandex:" fastlist: false - backend: "ftp" remote: "TestFTPProftpd:" fastlist: false ignoretests: - cmd/gitannex - backend: "ftp" remote: "TestFTPPureftpd:" fastlist: false ignoretests: - cmd/gitannex - backend: "ftp" remote: "TestFTPVsftpd:" fastlist: false ignoretests: - cmd/gitannex - backend: "ftp" remote: "TestFTPRclone:" fastlist: false ignoretests: - cmd/gitannex - backend: "box" remote: "TestBox:" fastlist: false - backend: "fichier" remote: "TestFichier:" fastlist: false listretries: 5 tests: - backend # Disabled due to account cancellation - no longer available to me # - backend: "qingstor" # remote: "TestQingStor:" # fastlist: false # oneonly: true # cleanup: true # ignore: # # This test fails because of a broken bucket in the account! # - TestIntegration/FsMkdir/FsPutFiles/FromRoot/ListR - backend: "azureblob" remote: "TestAzureBlob:" fastlist: true ignore: # It just isn't possible to preserve the existing file with azure blob # and make sure we don't leak uncomitted blocks. - TestMultithreadCopyAbort - backend: "azureblob" remote: "TestAzureBlob,directory_markers:" fastlist: true ignore: # It just isn't possible to preserve the existing file with azure blob # and make sure we don't leak uncomitted blocks. - TestMultithreadCopyAbort - backend: "azurefiles" remote: "TestAzureFiles:" - backend: "pcloud" remote: "TestPcloud:" fastlist: true - backend: "pikpak" remote: "TestPikPak:" fastlist: false ignore: # fs/operations - TestCheckSum - TestHashSums/Md5 # fs/sync - TestSyncWithTrackRenames # integration - TestIntegration/FsMkdir/FsPutFiles/ObjectMimeType # This test fails with message # "share_status_prohibited" (9): Sorry, the sharing service is under maintenance in the current region. - TestIntegration/FsMkdir/FsPutFiles/PublicLink ignoretests: - cmd/bisync - cmd/gitannex - backend: "pixeldrain" remote: "TestPixeldrain:" ignore: - TestIntegration/FsMkdir/FsEncoding/invalid_UTF-8 fastlist: false ignoretests: - cmd/bisync - backend: "webdav" remote: "TestWebdavNextcloud:" ignore: - TestIntegration/FsMkdir/FsEncoding/punctuation - TestIntegration/FsMkdir/FsEncoding/invalid_UTF-8 fastlist: false ignoretests: - cmd/bisync - cmd/gitannex - backend: "webdav" remote: "TestWebdavOwncloud:" ignore: - TestIntegration/FsMkdir/FsEncoding/punctuation - TestIntegration/FsMkdir/FsEncoding/invalid_UTF-8 fastlist: false ignoretests: - cmd/bisync - cmd/gitannex - backend: "webdav" remote: "TestWebdavInfiniteScale:" ignore: - TestIntegration/FsMkdir/FsEncoding/punctuation - TestIntegration/FsMkdir/FsEncoding/invalid_UTF-8 env: - RCLONE_NO_CHECK_CERTIFICATE=true fastlist: false ignoretests: - cmd/bisync - cmd/gitannex - backend: "webdav" remote: "TestWebdavRclone:" ignore: - TestFileReadAtZeroLength fastlist: false ignoretests: - cmd/gitannex - backend: "cache" remote: "TestCache:" fastlist: false ignoretests: - cmd/bisync - backend: "mega" remote: "TestMega:" fastlist: false ignore: - TestIntegration/FsMkdir/FsPutFiles/PublicLink - TestDirRename - TestFileRename ignoretests: - cmd/bisync - backend: "opendrive" remote: "TestOpenDrive:" fastlist: false ignoretests: - cmd/bisync - backend: "union" remote: "TestUnion:" fastlist: false - backend: "koofr" remote: "TestKoofr:" fastlist: false # - backend: "koofr" # remote: "TestDigiStorage:" # fastlist: false - backend: "linkbox" remote: "TestLinkbox:" fastlist: false ignore: - TestIntegration/FsMkdir/FsEncoding/invalid_UTF-8 - TestRWFileHandleWriteNoWrite - TestCaseInsensitiveMoveFile - TestFixCase - TestListDirSorted # Can't upload files starting with . - FIXME fix with encoding - TestSyncOverlapWithFilter # Can't upload files starting with . - FIXME fix with encoding ignoretests: - cmd/bisync - cmd/gitannex - backend: "premiumizeme" remote: "TestPremiumizeMe:" fastlist: false - backend: "protondrive" remote: "TestProtonDrive:" fastlist: false ignoretests: - cmd/bisync - cmd/gitannex - backend: "putio" remote: "TestPutio:" fastlist: false extratime: 2.0 ignore: - TestIntegration/FsMkdir/FsEncoding/URL_encoding ignoretests: - cmd/bisync # - backend: "sharefile" # remote: "TestSharefile:" # fastlist: false - backend: "sia" remote: "TestSia:" fastlist: false ignoretests: - cmd/gitannex - backend: "mailru" remote: "TestMailru:" subdir: false fastlist: false oneonly: true ignore: - TestApplyTransforms ignoretests: - cmd/bisync - backend: "seafile" remote: "TestSeafileV6:" fastlist: false ignore: - TestIntegration/FsMkdir/FsPutFiles/FsDirMove ignoretests: - cmd/gitannex - backend: "seafile" remote: "TestSeafile:" fastlist: true ignoretests: - cmd/gitannex - backend: "seafile" remote: "TestSeafileEncrypted:" fastlist: true ignoretests: - cmd/gitannex - backend: "smb" remote: "TestSMB:rclone" fastlist: false ignoretests: - cmd/gitannex - backend: "smb" remote: "TestSMBKerberos:rclone" fastlist: false env: - KRB5_CONFIG=/tmp/rclone_krb5/krb5.conf - KRB5CCNAME=/tmp/rclone_krb5/ccache ignoretests: - cmd/gitannex - backend: "smb" remote: "TestSMBKerberosCcache:rclone" fastlist: false env: - KRB5_CONFIG=/tmp/rclone_krb5_ccache/krb5.conf ignoretests: - cmd/gitannex - backend: "storj" remote: "TestStorj:" fastlist: true ignoretests: - cmd/bisync - backend: "zoho" remote: "TestZoho:" fastlist: false tests: - backend - backend: "hdfs" remote: "TestHdfs:" fastlist: false ignore: - TestSyncUTFNorm ignoretests: - cmd/gitannex # - backend: "uptobox" # remote: "TestUptobox:" # fastlist: false # ignore: # - TestRWFileHandleWriteNoWrite - backend: "oracleobjectstorage" remote: "TestOracleObjectStorage:" fastlist: true ignore: - TestIntegration/FsMkdir/FsEncoding/control_chars - TestIntegration/FsMkdir/FsEncoding/leading_CR - TestIntegration/FsMkdir/FsEncoding/leading_LF - TestIntegration/FsMkdir/FsEncoding/trailing_CR - TestIntegration/FsMkdir/FsEncoding/trailing_LF - TestIntegration/FsMkdir/FsEncoding/leading_HT - TestIntegration/FsMkdir/FsPutFiles/FsPutStream/0 ignoretests: - cmd/bisync - cmd/gitannex - backend: "quatrix" remote: "TestQuatrix:" fastlist: false ignoretests: - cmd/bisync - backend: "ulozto" remote: "TestUlozto:" fastlist: false # - backend: "iclouddrive" # remote: "TestICloudDrive:" # fastlist: false - backend: "filelu" remote: "TestFileLu:" fastlist: false ignore: - TestRWFileHandleWriteNoWrite ignoretests: - cmd/bisync - cmd/gitannex rclone-v1.71.0/fstest/test_all/report.go000066400000000000000000000177631505210326400202450ustar00rootroot00000000000000package main import ( "encoding/json" "fmt" "html/template" "os" "os/exec" "path" "regexp" "runtime" "sort" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/lib/file" "github.com/skratchdot/open-golang/open" ) const timeFormat = "2006-01-02-150405" // Report holds the info to make a report on a series of test runs type Report struct { LogDir string // output directory for logs and report StartTime time.Time // time started DateTime string // directory name for output Duration time.Duration // time the run took Failed Runs // failed runs Passed Runs // passed runs Runs []ReportRun // runs to report Version string // rclone version Previous string // previous test name if known IndexHTML string // path to the index.html file URL string // online version Branch string // rclone branch Commit string // rclone commit GOOS string // Go OS GOARCH string // Go Arch GoVersion string // Go Version } // ReportRun is used in the templates to report on a test run type ReportRun struct { Name string Runs Runs } // Parse version numbers // v1.49.0 // v1.49.0-031-g2298834e-beta // v1.49.0-032-g20793a5f-sharefile-beta // match 1 is commit number // match 2 is branch name var parseVersion = regexp.MustCompile(`^v(?:[0-9.]+)-(?:\d+)-g([0-9a-f]+)(?:-(.*))?-beta$`) // FIXME take -issue or -pr parameter... // NewReport initialises and returns a Report func NewReport() *Report { r := &Report{ StartTime: time.Now(), Version: fs.Version, GOOS: runtime.GOOS, GOARCH: runtime.GOARCH, GoVersion: runtime.Version(), } r.DateTime = r.StartTime.Format(timeFormat) // Find previous log directory if possible names, err := os.ReadDir(*outputDir) if err == nil && len(names) > 0 { r.Previous = names[len(names)-1].Name() } // Create output directory for logs and report r.LogDir = path.Join(*outputDir, r.DateTime) err = file.MkdirAll(r.LogDir, 0777) if err != nil { fs.Fatalf(nil, "Failed to make log directory: %v", err) } // Online version r.URL = *urlBase + r.DateTime + "/index.html" // Get branch/commit out of version parts := parseVersion.FindStringSubmatch(r.Version) if len(parts) >= 3 { r.Commit = parts[1] r.Branch = parts[2] } if r.Branch == "" { r.Branch = "master" } return r } // End should be called when the tests are complete func (r *Report) End() { r.Duration = time.Since(r.StartTime) sort.Sort(r.Failed) sort.Sort(r.Passed) r.Runs = []ReportRun{ {Name: "Failed", Runs: r.Failed}, {Name: "Passed", Runs: r.Passed}, } } // AllPassed returns true if there were no failed tests func (r *Report) AllPassed() bool { return len(r.Failed) == 0 } // RecordResult should be called with a Run when it has finished to be // recorded into the Report func (r *Report) RecordResult(t *Run) { if !t.passed() { r.Failed = append(r.Failed, t) } else { r.Passed = append(r.Passed, t) } } // Title returns a human-readable summary title for the Report func (r *Report) Title() string { if r.AllPassed() { return fmt.Sprintf("PASS: All tests finished OK in %v", r.Duration) } return fmt.Sprintf("FAIL: %d tests failed in %v", len(r.Failed), r.Duration) } // LogSummary writes the summary to the log file func (r *Report) LogSummary() { fs.Logf(nil, "Logs in %q", r.LogDir) // Summarise results fs.Logf(nil, "SUMMARY") fs.Log(nil, r.Title()) if !r.AllPassed() { for _, t := range r.Failed { fs.Logf(nil, " * %s", toShell(t.nextCmdLine())) fs.Logf(nil, " * Failed tests: %v", t.FailedTests) } } } // LogJSON writes the summary to index.json in LogDir func (r *Report) LogJSON() { out, err := json.MarshalIndent(r, "", "\t") if err != nil { fs.Fatalf(nil, "Failed to marshal data for index.json: %v", err) } err = os.WriteFile(path.Join(r.LogDir, "index.json"), out, 0666) if err != nil { fs.Fatalf(nil, "Failed to write index.json: %v", err) } } // LogHTML writes the summary to index.html in LogDir func (r *Report) LogHTML() { r.IndexHTML = path.Join(r.LogDir, "index.html") out, err := os.Create(r.IndexHTML) if err != nil { fs.Fatalf(nil, "Failed to open index.html: %v", err) } defer func() { err := out.Close() if err != nil { fs.Fatalf(nil, "Failed to close index.html: %v", err) } }() err = reportTemplate.Execute(out, r) if err != nil { fs.Fatalf(nil, "Failed to execute template: %v", err) } _ = open.Start("file://" + r.IndexHTML) } var reportHTML = ` {{ .Title }}

    {{ .Title }}

    {{ if .Commit}}{{ end }} {{ if .Previous}}{{ end }}
    Version{{ .Version }}
    Test{{ .DateTime}}
    Branch{{ .Branch }}
    Commit{{ .Commit }}
    Go{{ .GoVersion }} {{ .GOOS }}/{{ .GOARCH }}
    Duration{{ .Duration }}
    Previous{{ .Previous }}
    UpOlder Tests
    {{ range .Runs }} {{ if .Runs }}

    {{ .Name }}: {{ len .Runs }}

    {{ $prevBackend := "" }} {{ $prevRemote := "" }} {{ range .Runs}} {{ end }}
    Backend Remote Test FastList Failed Logs
    {{ if ne $prevBackend .Backend }}{{ .Backend }}{{ end }}{{ $prevBackend = .Backend }} {{ if ne $prevRemote .Remote }}{{ .Remote }}{{ end }}{{ $prevRemote = .Remote }} {{ .Path }} {{ .FastList }} {{ .FailedTestsCSV }} {{ range $i, $v := .Logs }}#{{ $i }} {{ end }}
    {{ end }} {{ end }} ` var reportTemplate = template.Must(template.New("Report").Parse(reportHTML)) // EmailHTML sends the summary report to the email address supplied func (r *Report) EmailHTML() { if *emailReport == "" || r.IndexHTML == "" { return } fs.Logf(nil, "Sending email summary to %q", *emailReport) cmdLine := []string{"mail", "-a", "Content-Type: text/html", *emailReport, "-s", "rclone integration tests: " + r.Title()} cmd := exec.Command(cmdLine[0], cmdLine[1:]...) in, err := os.Open(r.IndexHTML) if err != nil { fs.Fatalf(nil, "Failed to open index.html: %v", err) } cmd.Stdin = in cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr err = cmd.Run() if err != nil { fs.Fatalf(nil, "Failed to send email: %v", err) } _ = in.Close() } // uploadTo uploads a copy of the report online to the dir given func (r *Report) uploadTo(uploadDir string) { dst := path.Join(*uploadPath, uploadDir) fs.Logf(nil, "Uploading results to %q", dst) cmdLine := []string{"rclone", "sync", "--stats-log-level", "NOTICE", r.LogDir, dst} cmd := exec.Command(cmdLine[0], cmdLine[1:]...) cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr err := cmd.Run() if err != nil { fs.Fatalf(nil, "Failed to upload results: %v", err) } } // Upload uploads a copy of the report online func (r *Report) Upload() { if *uploadPath == "" || r.IndexHTML == "" { return } // Upload into dated directory r.uploadTo(r.DateTime) // And again into current r.uploadTo("current") } rclone-v1.71.0/fstest/test_all/run.go000066400000000000000000000255521505210326400175310ustar00rootroot00000000000000// Run a test package main import ( "bytes" "context" "fmt" "go/build" "io" "os" "os/exec" "path" "regexp" "runtime" "sort" "strconv" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fstest/testserver" ) // Control concurrency per backend if required var ( oneOnlyMu sync.Mutex oneOnly = map[string]*sync.Mutex{} ) // Run holds info about a running test // // A run just runs one command line, but it can be run multiple times // if retries are needed. type Run struct { // Config Remote string // name of the test remote Backend string // name of the backend Path string // path to the source directory FastList bool // add -fast-list to tests Short bool // add -short NoRetries bool // don't retry if set OneOnly bool // only run test for this backend at once NoBinary bool // set to not build a binary SizeLimit int64 // maximum test file size Ignore map[string]struct{} ListRetries int // -list-retries if > 0 ExtraTime float64 // multiply the timeout by this Env []string // environment variables in form KEY=VALUE // Internals CmdLine []string CmdString string Try int err error output []byte FailedTests []string RunFlag string LogDir string // directory to place the logs TrialName string // name/log file name of current trial TrialNames []string // list of all the trials } // Runs records multiple Run objects type Runs []*Run // Sort interface func (rs Runs) Len() int { return len(rs) } func (rs Runs) Swap(i, j int) { rs[i], rs[j] = rs[j], rs[i] } func (rs Runs) Less(i, j int) bool { a, b := rs[i], rs[j] if a.Backend < b.Backend { return true } else if a.Backend > b.Backend { return false } if a.Remote < b.Remote { return true } else if a.Remote > b.Remote { return false } if a.Path < b.Path { return true } else if a.Path > b.Path { return false } if !a.FastList && b.FastList { return true } else if a.FastList && !b.FastList { return false } return false } // dumpOutput prints the error output func (r *Run) dumpOutput() { fs.Log(nil, "------------------------------------------------------------") fs.Logf(nil, "---- %q ----", r.CmdString) fs.Log(nil, string(r.output)) fs.Log(nil, "------------------------------------------------------------") } // trie for storing runs type trie map[string]trie // turn a trie into multiple regexp matches // // We can't ever have a / in a regexp as it doesn't work. func match(current trie) []string { var names []string var parts []string for name, value := range current { matchName := "^" + name + "$" if len(value) == 0 { names = append(names, name) } else { for _, part := range match(value) { parts = append(parts, matchName+"/"+part) } } } sort.Strings(names) if len(names) > 1 { parts = append(parts, "^("+strings.Join(names, "|")+")$") } else if len(names) == 1 { parts = append(parts, "^"+names[0]+"$") } sort.Strings(parts) return parts } // This converts a slice of test names into a regexp which matches // them. func testsToRegexp(tests []string) string { var split = trie{} // Make a trie showing which parts are used at each level for _, test := range tests { var parent = split for _, name := range strings.Split(test, "/") { current := parent[name] if current == nil { current = trie{} parent[name] = current } parent = current } } parts := match(split) return strings.Join(parts, "|") } var failRe = regexp.MustCompile(`(?m)^\s*--- FAIL: (Test.*?) \(`) // findFailures looks for all the tests which failed func (r *Run) findFailures() { oldFailedTests := r.FailedTests r.FailedTests = nil excludeParents := map[string]struct{}{} ignored := 0 for _, matches := range failRe.FindAllSubmatch(r.output, -1) { failedTest := string(matches[1]) // Skip any ignored failures if _, found := r.Ignore[failedTest]; found { ignored++ } else { r.FailedTests = append(r.FailedTests, failedTest) } // Find all the parents of this test parts := strings.Split(failedTest, "/") for i := len(parts) - 1; i >= 1; i-- { excludeParents[strings.Join(parts[:i], "/")] = struct{}{} } } // Exclude the parents var newTests = r.FailedTests[:0] for _, failedTest := range r.FailedTests { if _, excluded := excludeParents[failedTest]; !excluded { newTests = append(newTests, failedTest) } } r.FailedTests = newTests if len(r.FailedTests) == 0 && ignored > 0 { fs.Logf(nil, "%q - Found %d ignored errors only - marking as good", r.CmdString, ignored) r.err = nil r.dumpOutput() return } if len(r.FailedTests) != 0 { r.RunFlag = testsToRegexp(r.FailedTests) } else { r.RunFlag = "" } if r.passed() && len(r.FailedTests) != 0 { fs.Logf(nil, "%q - Expecting no errors but got: %v", r.CmdString, r.FailedTests) r.dumpOutput() } else if !r.passed() && len(r.FailedTests) == 0 { fs.Logf(nil, "%q - Expecting errors but got none: %v", r.CmdString, r.FailedTests) r.dumpOutput() r.FailedTests = oldFailedTests } } // nextCmdLine returns the next command line func (r *Run) nextCmdLine() []string { CmdLine := r.CmdLine if r.RunFlag != "" { CmdLine = append(CmdLine, "-test.run", r.RunFlag) } return CmdLine } // trial runs a single test func (r *Run) trial() { CmdLine := r.nextCmdLine() CmdString := toShell(CmdLine) msg := fmt.Sprintf("%q - Starting (try %d/%d)", CmdString, r.Try, *maxTries) fs.Log(nil, msg) logName := path.Join(r.LogDir, r.TrialName) out, err := os.Create(logName) if err != nil { fs.Fatalf(nil, "Couldn't create log file: %v", err) } defer func() { err := out.Close() if err != nil { fs.Fatalf(nil, "Failed to close log file: %v", err) } }() _, _ = fmt.Fprintln(out, msg) // Early exit if --try-run if *dryRun { fs.Logf(nil, "Not executing as --dry-run: %v", CmdLine) _, _ = fmt.Fprintln(out, "--dry-run is set - not running") return } // Start the test server if required finish, err := testserver.Start(r.Remote) if err != nil { fs.Logf(nil, "%s: Failed to start test server: %v", r.Remote, err) _, _ = fmt.Fprintf(out, "%s: Failed to start test server: %v\n", r.Remote, err) r.err = err return } defer finish() // Internal buffer var b bytes.Buffer multiOut := io.MultiWriter(out, &b) cmd := exec.Command(CmdLine[0], CmdLine[1:]...) cmd.Stderr = multiOut cmd.Stdout = multiOut cmd.Dir = r.Path cmd.Env = append(os.Environ(), r.Env...) start := time.Now() r.err = cmd.Run() r.output = b.Bytes() duration := time.Since(start) r.findFailures() if r.passed() { msg = fmt.Sprintf("%q - Finished OK in %v (try %d/%d)", CmdString, duration, r.Try, *maxTries) } else { msg = fmt.Sprintf("%q - Finished ERROR in %v (try %d/%d): %v: Failed %v", CmdString, duration, r.Try, *maxTries, r.err, r.FailedTests) } fs.Log(nil, msg) _, _ = fmt.Fprintln(out, msg) } // passed returns true if the test passed func (r *Run) passed() bool { return r.err == nil } // GOPATH returns the current GOPATH func GOPATH() string { gopath := os.Getenv("GOPATH") if gopath == "" { gopath = build.Default.GOPATH } return gopath } // BinaryName turns a package name into a binary name func (r *Run) BinaryName() string { binary := path.Base(r.Path) + ".test" if runtime.GOOS == "windows" { binary += ".exe" } return binary } // BinaryPath turns a package name into a binary path func (r *Run) BinaryPath() string { return path.Join(r.Path, r.BinaryName()) } // PackagePath returns the path to the package func (r *Run) PackagePath() string { return path.Join(GOPATH(), "src", r.Path) } // MakeTestBinary makes the binary we will run func (r *Run) MakeTestBinary() { binary := r.BinaryPath() binaryName := r.BinaryName() fs.Logf(nil, "%s: Making test binary %q", r.Path, binaryName) CmdLine := []string{"go", "test", "-c"} if *race { CmdLine = append(CmdLine, "-race") } if *dryRun { fs.Logf(nil, "Not executing: %v", CmdLine) return } cmd := exec.Command(CmdLine[0], CmdLine[1:]...) cmd.Dir = r.Path err := cmd.Run() if err != nil { fs.Fatalf(nil, "Failed to make test binary: %v", err) } if _, err := os.Stat(binary); err != nil { fs.Fatalf(nil, "Couldn't find test binary %q", binary) } } // RemoveTestBinary removes the binary made in makeTestBinary func (r *Run) RemoveTestBinary() { if *dryRun { return } binary := r.BinaryPath() err := os.Remove(binary) // Delete the binary when finished if err != nil { fs.Logf(nil, "Error removing test binary %q: %v", binary, err) } } // Name returns the run name as a file name friendly string func (r *Run) Name() string { ns := []string{ r.Backend, strings.ReplaceAll(r.Path, "/", "."), r.Remote, } if r.FastList { ns = append(ns, "fastlist") } ns = append(ns, fmt.Sprintf("%d", r.Try)) s := strings.Join(ns, "-") s = strings.ReplaceAll(s, ":", "") return s } // Init the Run func (r *Run) Init() { prefix := "-test." if r.NoBinary { prefix = "-" r.CmdLine = []string{"go", "test"} } else { r.CmdLine = []string{"./" + r.BinaryName()} } testTimeout := *timeout if r.ExtraTime > 0 { testTimeout = time.Duration(float64(testTimeout) * r.ExtraTime) } r.CmdLine = append(r.CmdLine, prefix+"v", prefix+"timeout", testTimeout.String(), "-remote", r.Remote) listRetries := *listRetries if r.ListRetries > 0 { listRetries = r.ListRetries } if listRetries > 0 { r.CmdLine = append(r.CmdLine, "-list-retries", fmt.Sprint(listRetries)) } r.Try = 1 ci := fs.GetConfig(context.Background()) if *verbose { r.CmdLine = append(r.CmdLine, "-verbose") ci.LogLevel = fs.LogLevelDebug } if *runOnly != "" { r.CmdLine = append(r.CmdLine, prefix+"run", *runOnly) } if r.FastList { r.CmdLine = append(r.CmdLine, "-fast-list") } if r.Short { r.CmdLine = append(r.CmdLine, "-short") } if r.SizeLimit > 0 { r.CmdLine = append(r.CmdLine, "-size-limit", strconv.FormatInt(r.SizeLimit, 10)) } r.CmdString = toShell(r.CmdLine) } // Logs returns all the log names func (r *Run) Logs() []string { return r.TrialNames } // FailedTestsCSV returns the failed tests as a comma separated string, limiting the number func (r *Run) FailedTestsCSV() string { const maxTests = 5 ts := r.FailedTests if len(ts) > maxTests { ts = ts[:maxTests:maxTests] ts = append(ts, fmt.Sprintf("… (%d more)", len(r.FailedTests)-maxTests)) } return strings.Join(ts, ", ") } // Run runs all the trials for this test func (r *Run) Run(LogDir string, result chan<- *Run) { if r.OneOnly { oneOnlyMu.Lock() mu := oneOnly[r.Backend] if mu == nil { mu = new(sync.Mutex) oneOnly[r.Backend] = mu } oneOnlyMu.Unlock() mu.Lock() defer mu.Unlock() } r.Init() r.LogDir = LogDir for r.Try = 1; r.Try <= *maxTries; r.Try++ { r.TrialName = r.Name() + ".txt" r.TrialNames = append(r.TrialNames, r.TrialName) fs.Logf(nil, "Starting run with log %q", r.TrialName) r.trial() if r.passed() || r.NoRetries { break } } if !r.passed() { r.dumpOutput() } result <- r } rclone-v1.71.0/fstest/test_all/run_test.go000066400000000000000000000066751505210326400205750ustar00rootroot00000000000000package main import ( "fmt" "os/exec" "regexp" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestTestsToRegexp(t *testing.T) { for _, test := range []struct { in []string want string }{ { in: []string{}, want: "", }, { in: []string{"TestOne"}, want: "^TestOne$", }, { in: []string{"TestOne", "TestTwo"}, want: "^(TestOne|TestTwo)$", }, { in: []string{"TestOne", "TestTwo", "TestThree"}, want: "^(TestOne|TestThree|TestTwo)$", }, { in: []string{"TestOne/Sub1"}, want: "^TestOne$/^Sub1$", }, { in: []string{ "TestOne/Sub1", "TestTwo", }, want: "^TestOne$/^Sub1$|^TestTwo$", }, { in: []string{ "TestOne/Sub1", "TestOne/Sub2", "TestTwo", }, want: "^TestOne$/^(Sub1|Sub2)$|^TestTwo$", }, { in: []string{ "TestOne/Sub1", "TestOne/Sub2/SubSub1", "TestTwo", }, want: "^TestOne$/^Sub1$|^TestOne$/^Sub2$/^SubSub1$|^TestTwo$", }, { in: []string{ "TestTests/A1", "TestTests/B/B1", "TestTests/C/C3/C31", }, want: "^TestTests$/^A1$|^TestTests$/^B$/^B1$|^TestTests$/^C$/^C3$/^C31$", }, } { got := testsToRegexp(test.in) assert.Equal(t, test.want, got, fmt.Sprintf("in=%v want=%q got=%q", test.in, test.want, got)) } } var runRe = regexp.MustCompile(`(?m)^\s*=== RUN\s*(Test.*?)\s*$`) // Test the regexp work with the -run flag in actually selecting the right tests func TestTestsToRegexpLive(t *testing.T) { for _, test := range []struct { in []string want []string }{ { in: []string{ "TestTests/A1", "TestTests/C/C3", }, want: []string{ "TestTests", "TestTests/A1", "TestTests/C", "TestTests/C/C3", "TestTests/C/C3/C31", "TestTests/C/C3/C32", }, }, { in: []string{ "TestTests", "TestTests/A1", "TestTests/B", "TestTests/B/B1", "TestTests/C", }, want: []string{ "TestTests", "TestTests/A1", "TestTests/B", "TestTests/B/B1", "TestTests/C", "TestTests/C/C1", "TestTests/C/C2", "TestTests/C/C3", "TestTests/C/C3/C31", "TestTests/C/C3/C32", }, }, { in: []string{ "TestTests/A1", "TestTests/B/B1", "TestTests/C/C3/C31", }, want: []string{ "TestTests", "TestTests/A1", "TestTests/B", "TestTests/B/B1", "TestTests/C", "TestTests/C/C3", "TestTests/C/C3/C31", }, }, { in: []string{ "TestTests/B/B1", "TestTests/C/C3/C31", }, want: []string{ "TestTests", "TestTests/B", "TestTests/B/B1", "TestTests/C", "TestTests/C/C3", "TestTests/C/C3/C31", }, }, } { runRegexp := testsToRegexp(test.in) cmd := exec.Command("go", "test", "-v", "-run", runRegexp) out, err := cmd.CombinedOutput() require.NoError(t, err) var got []string for _, match := range runRe.FindAllSubmatch(out, -1) { got = append(got, string(match[1])) } assert.Equal(t, test.want, got, fmt.Sprintf("in=%v want=%v got=%v, runRegexp=%q", test.in, test.want, got, runRegexp)) } } var nilTest = func(t *testing.T) {} // Nested tests for TestTestsToRegexpLive to run func TestTests(t *testing.T) { t.Run("A1", nilTest) t.Run("A2", nilTest) t.Run("B", func(t *testing.T) { t.Run("B1", nilTest) t.Run("B2", nilTest) }) t.Run("C", func(t *testing.T) { t.Run("C1", nilTest) t.Run("C2", nilTest) t.Run("C3", func(t *testing.T) { t.Run("C31", nilTest) t.Run("C32", nilTest) }) }) } rclone-v1.71.0/fstest/test_all/test_all.go000066400000000000000000000116331505210326400205270ustar00rootroot00000000000000// Run tests for all the remotes. Run this with package names which // need integration testing. // // See the `test` target in the Makefile. package main /* FIXME Make TesTrun have a []string of flags to try - that then makes it generic */ import ( "encoding/csv" "flag" "fmt" "math/rand" "os" "path" "regexp" "strings" "time" _ "github.com/rclone/rclone/backend/all" // import all fs "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/config/configfile" "github.com/rclone/rclone/lib/pacer" ) var ( // Flags maxTries = flag.Int("maxtries", 5, "Number of times to try each test") maxN = flag.Int("n", 20, "Maximum number of tests to run at once") testRemotes = flag.String("remotes", "", "Comma separated list of remotes to test, e.g. 'TestSwift:,TestS3'") testBackends = flag.String("backends", "", "Comma separated list of backends to test, e.g. 's3,googlecloudstorage") testTests = flag.String("tests", "", "Comma separated list of tests to test, e.g. 'fs/sync,fs/operations'") clean = flag.Bool("clean", false, "Instead of testing, clean all left over test directories") runOnly = flag.String("run", "", "Run only those tests matching the regexp supplied") timeout = flag.Duration("timeout", 60*time.Minute, "Maximum time to run each test for before giving up") race = flag.Bool("race", false, "If set run the tests under the race detector") configFile = flag.String("config", "fstest/test_all/config.yaml", "Path to config file") outputDir = flag.String("output", path.Join(os.TempDir(), "rclone-integration-tests"), "Place to store results") emailReport = flag.String("email", "", "Set to email the report to the address supplied") dryRun = flag.Bool("dry-run", false, "Print commands which would be executed only") urlBase = flag.String("url-base", "https://pub.rclone.org/integration-tests/", "Base for the online version") uploadPath = flag.String("upload", "", "Set this to an rclone path to upload the results here") verbose = flag.Bool("verbose", false, "Set to enable verbose logging in the tests") listRetries = flag.Int("list-retries", -1, "Number or times to retry listing - set to override the default") ) // if matches then is definitely OK in the shell var shellOK = regexp.MustCompile("^[A-Za-z0-9./_:-]+$") // converts an argv style input into a shell command func toShell(args []string) (result string) { for _, arg := range args { if result != "" { result += " " } if shellOK.MatchString(arg) { result += arg } else { result += "'" + arg + "'" } } return result } func main() { flag.Parse() conf, err := NewConfig(*configFile) if err != nil { fs.Log(nil, "test_all should be run from the root of the rclone source code") fs.Fatal(nil, fmt.Sprint(err)) } configfile.Install() // Seed the random number generator randInstance := rand.New(rand.NewSource(time.Now().UTC().UnixNano())) // Filter selection if *testRemotes != "" { // CSV parse to support connection string remotes with commas like -remotes local,\"TestGoogleCloudStorage,directory_markers:\" r := csv.NewReader(strings.NewReader(*testRemotes)) remotes, err := r.Read() if err != nil { fs.Fatalf(*testRemotes, "error CSV-parsing -remotes string: %v", err) } fs.Debugf(*testRemotes, "using remotes: %v", remotes) conf.filterBackendsByRemotes(remotes) } if *testBackends != "" { conf.filterBackendsByBackends(strings.Split(*testBackends, ",")) } if *testTests != "" { conf.filterTests(strings.Split(*testTests, ",")) } // Just clean the directories if required if *clean { err := cleanRemotes(conf) if err != nil { fs.Fatalf(nil, "Failed to clean: %v", err) } return } var names []string for _, remote := range conf.Backends { names = append(names, remote.Remote) } fs.Logf(nil, "Testing remotes: %s", strings.Join(names, ", ")) // Runs we will do for this test in random order runs := conf.MakeRuns() randInstance.Shuffle(len(runs), runs.Swap) // Create Report report := NewReport() // Make the test binaries, one per Path found in the tests done := map[string]struct{}{} for _, run := range runs { if _, found := done[run.Path]; !found { done[run.Path] = struct{}{} if !run.NoBinary { run.MakeTestBinary() defer run.RemoveTestBinary() } } } // workaround for cache backend as we run simultaneous tests _ = os.Setenv("RCLONE_CACHE_DB_WAIT_TIME", "30m") // start the tests results := make(chan *Run, len(runs)) awaiting := 0 tokens := pacer.NewTokenDispenser(*maxN) for _, run := range runs { tokens.Get() go func(run *Run) { defer tokens.Put() run.Run(report.LogDir, results) }(run) awaiting++ } // Wait for the tests to finish for ; awaiting > 0; awaiting-- { t := <-results report.RecordResult(t) } // Log and exit report.End() report.LogSummary() report.LogJSON() report.LogHTML() report.EmailHTML() report.Upload() if !report.AllPassed() { os.Exit(1) } } rclone-v1.71.0/fstest/testserver/000077500000000000000000000000001505210326400167645ustar00rootroot00000000000000rclone-v1.71.0/fstest/testserver/images/000077500000000000000000000000001505210326400202315ustar00rootroot00000000000000rclone-v1.71.0/fstest/testserver/images/test-hdfs/000077500000000000000000000000001505210326400221325ustar00rootroot00000000000000rclone-v1.71.0/fstest/testserver/images/test-hdfs/Dockerfile000066400000000000000000000026771505210326400241400ustar00rootroot00000000000000# A very minimal hdfs server for integration testing rclone FROM debian:stretch RUN apt-get update \ && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends openjdk-8-jdk \ net-tools curl python krb5-user krb5-kdc krb5-admin-server \ && rm -rf /var/lib/apt/lists/* ENV JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/ ENV HADOOP_VERSION 3.2.1 ENV HADOOP_URL https://www.apache.org/dist/hadoop/common/hadoop-$HADOOP_VERSION/hadoop-$HADOOP_VERSION.tar.gz RUN set -x \ && curl -fSL "$HADOOP_URL" -o /tmp/hadoop.tar.gz \ && tar -xvf /tmp/hadoop.tar.gz -C /opt/ \ && rm /tmp/hadoop.tar.gz* RUN ln -s /opt/hadoop-$HADOOP_VERSION/etc/hadoop /etc/hadoop RUN mkdir /opt/hadoop-$HADOOP_VERSION/logs RUN mkdir /hadoop-data RUN mkdir -p /hadoop/dfs/name RUN mkdir -p /hadoop/dfs/data ENV HADOOP_HOME=/opt/hadoop-$HADOOP_VERSION ENV HADOOP_CONF_DIR=/etc/hadoop ENV MULTIHOMED_NETWORK=1 ENV USER=root ENV PATH $HADOOP_HOME/bin/:$PATH ADD core-site.xml /etc/hadoop/core-site.xml ADD hdfs-site.xml /etc/hadoop/hdfs-site.xml ADD httpfs-site.xml /etc/hadoop/httpfs-site.xml ADD kms-site.xml /etc/hadoop/kms-site.xml ADD mapred-site.xml /etc/hadoop/mapred-site.xml ADD yarn-site.xml /etc/hadoop/yarn-site.xml ADD krb5.conf /etc/ ADD kdc.conf /etc/krb5kdc/ RUN echo '*/admin@KERBEROS.RCLONE *' > /etc/krb5kdc/kadm5.acl ADD run.sh /run.sh RUN chmod a+x /run.sh CMD ["/run.sh"] rclone-v1.71.0/fstest/testserver/images/test-hdfs/README.md000066400000000000000000000016411505210326400234130ustar00rootroot00000000000000# Test HDFS This is a docker image for rclone's integration tests which runs an hdfs filesystem in a docker image. ## Build ``` docker build --rm -t rclone/test-hdfs . docker push rclone/test-hdfs ``` # Test configure remote: ``` [TestHdfs] type = hdfs namenode = 127.0.0.1:8020 username = root ``` run tests ``` cd backend/hdfs GO111MODULE=on go test -v ``` hdfs logs will be available in `.stdout.log` and `.stderr.log` # Kerberos test can be run against kerberos-enabled hdfs 1. configure local krb5.conf ``` [libdefaults] default_realm = KERBEROS.RCLONE [realms] KERBEROS.RCLONE = { kdc = localhost } ``` 2. enable kerberos in remote configuration ``` [TestHdfs] ... service_principal_name = hdfs/localhost data_transfer_protection = privacy ``` 3. run test ``` cd backend/hdfs KERBEROS=true GO111MODULE=on go test -v ```rclone-v1.71.0/fstest/testserver/images/test-hdfs/core-site.xml000066400000000000000000000014511505210326400245470ustar00rootroot00000000000000 fs.defaultFShdfs://localhost:8020 hadoop.http.staticuser.userroot hadoop.proxyuser.root.groupsroot,nogroup hadoop.proxyuser.root.hosts* hadoop.security.authenticationkerberos hadoop.security.authorizationtrue hadoop.rpc.protectionintegrity hadoop.user.group.static.mapping.overridesuser=supergroup rclone-v1.71.0/fstest/testserver/images/test-hdfs/hdfs-site.xml000066400000000000000000000045361505210326400245520ustar00rootroot00000000000000 dfs.client.use.datanode.hostnametrue dfs.datanode.data.dirfile:///hadoop/dfs/data dfs.datanode.use.datanode.hostnametrue dfs.namenode.accesstime.precision3600000 dfs.namenode.http-bind-host0.0.0.0 dfs.namenode.https-bind-host0.0.0.0 dfs.namenode.name.dirfile:///hadoop/dfs/name dfs.namenode.rpc-bind-host0.0.0.0 dfs.namenode.safemode.extension5000 dfs.namenode.servicerpc-bind-host0.0.0.0 dfs.replication2 nfs.dump.dir/tmp ignore.secure.ports.for.testingtrue dfs.safemode.extension0 dfs.block.access.token.enabletrue dfs.encrypt.data.transfertrue dfs.encrypt.data.transfer.algorithmrc4 dfs.encrypt.data.transfer.cipher.suitesAES/CTR/NoPadding dfs.namenode.kerberos.principal hdfs/_HOST@KERBEROS.RCLONE dfs.web.authentication.kerberos.principalHTTP/_HOST@KERBEROS.RCLONE dfs.datanode.kerberos.principal hdfs/_HOST@KERBEROS.RCLONE dfs.namenode.keytab.file /etc/hadoop/kerberos.key dfs.web.authentication.kerberos.keytab/etc/hadoop/kerberos.key dfs.datanode.keytab.file /etc/hadoop/kerberos.key rclone-v1.71.0/fstest/testserver/images/test-hdfs/httpfs-site.xml000066400000000000000000000000411505210326400251210ustar00rootroot00000000000000 rclone-v1.71.0/fstest/testserver/images/test-hdfs/kdc.conf000066400000000000000000000001211505210326400235340ustar00rootroot00000000000000[realms] KERBEROS.RCLONE = { acl_file = /etc/krb5kdc/kadm5.acl } rclone-v1.71.0/fstest/testserver/images/test-hdfs/kms-site.xml000066400000000000000000000000411505210326400244030ustar00rootroot00000000000000 rclone-v1.71.0/fstest/testserver/images/test-hdfs/krb5.conf000066400000000000000000000003251505210326400236440ustar00rootroot00000000000000[libdefaults] default_realm = KERBEROS.RCLONE dns_lookup_realm = false dns_lookup_kdc = false forwardable = true proxiable = true [realms] KERBEROS.RCLONE = { kdc = localhost } rclone-v1.71.0/fstest/testserver/images/test-hdfs/mapred-site.xml000066400000000000000000000003051505210326400250640ustar00rootroot00000000000000 mapreduce.framework.nameyarn yarn.nodemanager.bind-host0.0.0.0 rclone-v1.71.0/fstest/testserver/images/test-hdfs/run.sh000077500000000000000000000021411505210326400232730ustar00rootroot00000000000000#!/usr/bin/env bash KERBEROS=${KERBEROS-"false"} if [ $KERBEROS = "true" ]; then echo prepare kerberos ADMIN_PASSWORD="kerberos" USER_PASSWORD="user" echo -e "$ADMIN_PASSWORD\n$ADMIN_PASSWORD" | kdb5_util -r "KERBEROS.RCLONE" create -s echo -e "$ADMIN_PASSWORD\n$ADMIN_PASSWORD" | kadmin.local -q "addprinc hadoop/admin" echo -e "$USER_PASSWORD\n$USER_PASSWORD" | kadmin.local -q "addprinc user" kadmin.local -q 'addprinc -randkey hdfs/localhost' kadmin.local -q 'addprinc -randkey hdfs/rclone-hdfs' kadmin.local -q 'addprinc -randkey HTTP/localhost' kadmin.local -p hadoop/admin -q "ktadd -k /etc/hadoop/kerberos.key hdfs/localhost hdfs/rclone-hdfs HTTP/localhost" service krb5-kdc restart echo -e "$USER_PASSWORD\n" | kinit user klist echo kerberos ready else echo drop kerberos from configuration files sed -i '/KERBEROS BEGIN/,/KERBEROS END/d' /etc/hadoop/core-site.xml sed -i '/KERBEROS BEGIN/,/KERBEROS END/d' /etc/hadoop/hdfs-site.xml fi echo format namenode hdfs namenode -format test hdfs namenode & hdfs datanode & exec sleep infinity rclone-v1.71.0/fstest/testserver/images/test-hdfs/yarn-site.xml000066400000000000000000000023751505210326400245760ustar00rootroot00000000000000 yarn.log-aggregation-enabletrue yarn.log.server.urlhttp://localhost:8188/applicationhistory/logs/ yarn.nodemanager.aux-services.mapreduce.shuffle.classorg.apache.hadoop.mapred.ShuffleHandler yarn.nodemanager.aux-servicesmapreduce_shuffle yarn.nodemanager.bind-host0.0.0.0 yarn.nodemanager.bind-host0.0.0.0 yarn.nodemanager.remote-app-log-dir/app-logs yarn.timeline-service.bind-host0.0.0.0 yarn.timeline-service.enabledtrue yarn.timeline-service.generic-application-history.enabledtrue yarn.timeline-service.hostnamehistoryserver.hadoop yarn.timeline-service.leveldb-timeline-store.path/hadoop/yarn/timeline rclone-v1.71.0/fstest/testserver/images/test-sftp-openssh/000077500000000000000000000000001505210326400236375ustar00rootroot00000000000000rclone-v1.71.0/fstest/testserver/images/test-sftp-openssh/Dockerfile000066400000000000000000000004201505210326400256250ustar00rootroot00000000000000# A very minimal sftp server for integration testing rclone FROM alpine:latest # User rclone, password password RUN \ apk add openssh && \ ssh-keygen -A && \ adduser -D rclone && \ echo "rclone:password" | chpasswd ENTRYPOINT [ "/usr/sbin/sshd", "-D" ] rclone-v1.71.0/fstest/testserver/images/test-sftp-openssh/README.md000066400000000000000000000005321505210326400251160ustar00rootroot00000000000000# Test SFTP Openssh This is a docker image for rclone's integration tests which runs an openssh server in a docker image. ## Build ``` docker build --rm -t rclone/test-sftp-openssh . docker push rclone/test-sftp-openssh ``` # Test ``` rclone lsf -R --sftp-host 172.17.0.2 --sftp-user rclone --sftp-pass $(rclone obscure password) :sftp: ``` rclone-v1.71.0/fstest/testserver/init.d/000077500000000000000000000000001505210326400201515ustar00rootroot00000000000000rclone-v1.71.0/fstest/testserver/init.d/PORTS.md000066400000000000000000000025031505210326400214020ustar00rootroot00000000000000# Ports for tests All these tests need to run on a different port. They should be bound to localhost so they are not accessible externally. | Port | Test | |:-----:|:----:| | 88 | TestHdfs | | 750 | TestHdfs | | 8020 | TestHdfs | | 8086 | TestSeafileV6 | | 8087 | TestSeafile | | 8088 | TestSeafileEncrypted | | 9866 | TestHdfs | | 28620 | TestWebdavRclone | | 28621 | TestSFTPRclone | | 28622 | TestFTPRclone | | 28623 | TestSFTPRcloneSSH | | 28624 | TestS3Rclone | | 28625 | TestS3Minio | | 28626 | TestS3MinioEdge | | 28627 | TestSFTPOpenssh | | 28628 | TestSwiftAIO | | 28629 | TestWebdavNextcloud | | 28630 | TestSMB | | 28631 | TestFTPProftpd | | 28632 | TestSwiftAIOsegments | | 28633 | TestSMBKerberos | | 28634 | TestSMBKerberos | | 28635 | TestS3Exaba | | 28636 | TestS3Exaba | | 28637 | TestSMBKerberosCcache | | 28638 | TestSMBKerberosCcache | | 38081 | TestWebdavOwncloud | ## Non localhost tests All these use `$(docker_ip)` which means they don't work on macOS or Windows. It is proabably possible to make them work with some effort but will require port forwarding a range of ports and configuring the FTP server to only use that range of ports. The FTP server will likely need know it is behind a NAT so it advertises the correct external IP. - TestFTPProftpd - TestFTPPureftpd - TestFTPVsftpd - TestFTPVsftpdTLS rclone-v1.71.0/fstest/testserver/init.d/README.md000066400000000000000000000024171505210326400214340ustar00rootroot00000000000000This directory contains scripts to start and stop servers for testing. The commands are named after the remotes in use. They should be executable files with the following parameters: start - starts the server stop - stops the server status - returns non-zero exit code if the server is not running These will be called automatically by test_all if that remote is required. When start is run it should output config parameters for that remote. If a `_connect` parameter is output then that will be used for a connection test. For example if `_connect=127.0.0.1:80` then a TCP connection will be made to `127.0.0.1:80` and only when that succeeds will the test continue. If in addition to `_connect`, `_connect_delay=5s` is also present then after the connection succeeds rclone will wait `5s` before continuing. This is for servers that aren't quite ready even though they have opened their TCP ports. `run.bash` contains boilerplate to be included in a bash script for interpreting the command line parameters. `docker.bash` contains library functions to help with docker implementations. ## TODO - sftpd - https://github.com/panubo/docker-sshd ? - openstack swift - https://github.com/bouncestorage/docker-swift - ceph - https://github.com/ceph/cn - other ftp servers rclone-v1.71.0/fstest/testserver/init.d/TestFTPProftpd000077500000000000000000000007341505210326400227330ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=proftpd USER=rclone PASS=RaidedBannedPokes5 . $(dirname "$0")/docker.bash start() { docker run --rm -d --name $NAME \ -e "FTP_USERNAME=rclone" \ -e "FTP_PASSWORD=$PASS" \ hauptmedia/proftpd echo type=ftp echo host=$(docker_ip) echo user=$USER echo pass=$(rclone obscure $PASS) echo encoding=Asterisk,Ctl,Dot,Slash echo _connect=$(docker_ip):21 } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestFTPPureftpd000077500000000000000000000012341505210326400231020ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=pureftpd USER=rclone PASS=AcridSpiesBooks2 . $(dirname "$0")/docker.bash start() { docker run --rm -d --name $NAME \ -e "FTP_USER_NAME=rclone" \ -e "FTP_USER_PASS=$PASS" \ -e "FTP_USER_HOME=/data" \ -e "FTP_MAX_CLIENTS=50" \ -e "FTP_MAX_CONNECTIONS=50" \ -e "FTP_PASSIVE_PORTS=30000:40000" \ stilliard/pure-ftpd echo type=ftp echo host=$(docker_ip) echo user=$USER echo pass=$(rclone obscure $PASS) echo encoding=BackSlash,Ctl,Del,Dot,RightSpace,Slash,SquareBracket echo _connect=$(docker_ip):21 } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestFTPRclone000077500000000000000000000006141505210326400225340ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=rclone-serve-ftp USER=rclone PASS=FuddleIdlingJell5 IP=127.0.0.1 PORT=28622 start() { run rclone serve ftp --user $USER --pass $PASS --addr ${IP}:${PORT} ${DATADIR} echo type=ftp echo host=${IP} echo port=$PORT echo user=$USER echo pass=$(rclone obscure $PASS) echo _connect=${IP}:${PORT} } . $(dirname "$0")/rclone-serve.bash rclone-v1.71.0/fstest/testserver/init.d/TestFTPVsftpd000077500000000000000000000007421505210326400225620ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=vsftpd USER=rclone PASS=TiffedRestedSian4 . $(dirname "$0")/docker.bash start() { docker run --rm -d --name $NAME \ -e "FTP_USER=rclone" \ -e "FTP_PASS=$PASS" \ fauria/vsftpd echo type=ftp echo host=$(docker_ip) echo user=$USER echo pass=$(rclone obscure $PASS) echo writing_mdtm=true echo encoding=Ctl,LeftPeriod,Slash echo _connect=$(docker_ip):21 } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestFTPVsftpdTLS000077500000000000000000000007451505210326400231500ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=vsftpdtls USER=rclone PASS=TiffedRestedSian4 . $(dirname "$0")/docker.bash start() { docker run --rm -d --name $NAME \ -e "FTP_USER=rclone" \ -e "FTP_PASS=$PASS" \ rclone/vsftpd echo type=ftp echo host=$(docker_ip) echo user=$USER echo pass=$(rclone obscure $PASS) echo writing_mdtm=true echo encoding=Ctl,LeftPeriod,Slash echo _connect=$(docker_ip):21 } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestHdfs000077500000000000000000000014441505210326400216260ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=rclone-hdfs KERBEROS=${KERBEROS-"false"} . $(dirname "$0")/docker.bash start() { docker run --rm -d --name "rclone-hdfs" \ --hostname "rclone-hdfs" \ -e "KERBEROS=$KERBEROS" \ -p 127.0.0.1:9866:9866 \ -p 127.0.0.1:8020:8020 \ -p 127.0.0.1:750:750 \ -p 127.0.0.1:88:88 \ rclone/test-hdfs sleep 30 if [ $KERBEROS = "true" ]; then docker cp rclone-hdfs:/tmp/krb5cc_0 /tmp/krb5cc_`id -u` fi echo type=hdfs echo namenode=127.0.0.1:8020 echo username=root echo _connect=${namenode} } stop() { if status ; then docker logs $NAME > .stdout.log 2> .stderr.log docker kill $NAME echo "$NAME stopped" fi } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestS3Exaba000077500000000000000000000012561505210326400221710ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=exaba USER="Use the webui to find the access_key_id" PASS="Use the webui to find the secret_access_key" PORT=28635 WEBUIPORT=28636 . $(dirname "$0")/docker.bash start() { docker run --rm -d --name $NAME \ -e "CLUSTER_NAME=rclone" \ -e "CLUSTER_SIZE_GB=20" \ -p 127.0.0.1:${PORT}:9000 \ -p 127.0.0.1:${WEBUIPORT}:9006 \ exaba/exaba echo type=s3 echo provider=Exaba echo access_key_id=$USER echo secret_access_key=$PASS echo endpoint=http://127.0.0.1:${PORT}/ echo webui=http://127.0.0.1:${WEBUIPORT}/ echo _connect=127.0.0.1:${PORT} } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestS3Minio000077500000000000000000000010341505210326400222160ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=minio USER=rclone PASS=AxedBodedGinger7 PORT=28625 . $(dirname "$0")/docker.bash start() { docker run --rm -d --name $NAME \ -e "MINIO_ACCESS_KEY=$USER" \ -e "MINIO_SECRET_KEY=$PASS" \ -p 127.0.0.1:${PORT}:9000 \ minio/minio server /data echo type=s3 echo provider=Minio echo access_key_id=$USER echo secret_access_key=$PASS echo endpoint=http://127.0.0.1:${PORT}/ echo _connect=127.0.0.1:${PORT} } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestS3MinioEdge000077500000000000000000000010511505210326400230020ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=minio-edge USER=rclone PASS=DeniseOxygenEiffel4 PORT=28626 . $(dirname "$0")/docker.bash start() { docker run --rm -d --name $NAME \ -e "MINIO_ACCESS_KEY=$USER" \ -e "MINIO_SECRET_KEY=$PASS" \ -p 127.0.0.1:${PORT}:9000 \ minio/minio:edge server /data echo type=s3 echo provider=Minio echo access_key_id=$USER echo secret_access_key=$PASS echo endpoint=http://127.0.0.1:${PORT}/ echo _connect=127.0.0.1:${PORT} } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestS3Rclone000077500000000000000000000007531505210326400223740ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=rclone-serve-s3 ACCESS_KEY_ID=rclone SECRET_ACCESS_KEY=JoltRogueVerde5 IP=127.0.0.1 PORT=28624 start() { run rclone serve s3 --auth-key ${ACCESS_KEY_ID},${SECRET_ACCESS_KEY} --addr ${IP}:${PORT} ${DATADIR} echo type=s3 echo provider=Rclone echo endpoint=http://${IP}:${PORT}/ echo access_key_id=${ACCESS_KEY_ID} echo secret_access_key=${SECRET_ACCESS_KEY} echo _connect=${IP}:${PORT} } . $(dirname "$0")/rclone-serve.bash rclone-v1.71.0/fstest/testserver/init.d/TestSFTPOpenssh000077500000000000000000000007251505210326400230570ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=rclone-sftp-openssh USER=rclone PASS=password PORT=28627 . $(dirname "$0")/docker.bash start() { docker run --rm -d --name ${NAME} \ -p 127.0.0.1:${PORT}:22 \ rclone/test-sftp-openssh echo type=sftp echo host=127.0.0.1 echo port=$PORT echo user=$USER echo pass=$(rclone obscure $PASS) echo copy_is_hardlink=true echo _connect=127.0.0.1:${PORT} } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestSFTPRclone000077500000000000000000000006211505210326400226550ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=rclone-serve-sftp USER=rclone PASS=CranesBallotDorsey5 IP=127.0.0.1 PORT=28621 start() { run rclone serve sftp --user $USER --pass $PASS --addr ${IP}:${PORT} ${DATADIR} echo type=sftp echo host=${IP} echo port=$PORT echo user=$USER echo pass=$(rclone obscure $PASS) echo _connect=${IP}:${PORT} } . $(dirname "$0")/rclone-serve.bash rclone-v1.71.0/fstest/testserver/init.d/TestSFTPRcloneSSH000077500000000000000000000071711505210326400232420ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=rclone-serve-sftp-ssh IP=127.0.0.1 PORT=28623 PRIVATE_KEY=/tmp/${NAME}.key PUBLIC_KEY=/tmp/${NAME}.pub start() { cat >${PRIVATE_KEY} <<'#EOF' -----BEGIN OPENSSH PRIVATE KEY----- b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABlwAAAAdzc2gtcn NhAAAAAwEAAQAAAYEAv7e6d+AbxELvRk7sZipketuqgE4/vVbf/6PMuOd1OSPyOOsAOs41 tvc4Sk4S+/6ReHW4l1DKy5IH0smOsA1k58kKFkN1NChHU5z0CitAiZwdl7zqvxNJqlMmYi GTubhQdMnDrq0AAnhyr9TFrcZmYPcp9tHcpt9VQWeLYR/16tT53WnpgTuMWlgyM58bpCh/ cDO7gOjSyXHhPPxrU1qdr5g/5T9HFgQfi2CX8vk4pDY+Qw1Lnp1MMpKT4i9xWGMU8oDJG3 08RrzUi9tz1RTePtbs4xXOy8cXOZaAODDQok4iWvJEpGgJYLjhNuHzZiUDcfc1SkXvONui 7j5RC/rsQOYB5Sd7ATlF4HymAxZJ3iPu+eYBZi7lwIPeug+42WlVon+D5dOYmrgcPpAZv7 67Lthv62FMmvc1SHHGPZLS3dWfbZeXayve9+wIkKFEuDN76zYAavjSRm9fBKny6J+noJgp bDMVNnTfNA28fsNbsCS6OsBjLbiFjMHxhuYACMaVAAAFgBfF8CkXxfApAAAAB3NzaC1yc2 EAAAGBAL+3unfgG8RC70ZO7GYqZHrbqoBOP71W3/+jzLjndTkj8jjrADrONbb3OEpOEvv+ kXh1uJdQysuSB9LJjrANZOfJChZDdTQoR1Oc9AorQImcHZe86r8TSapTJmIhk7m4UHTJw6 6tAAJ4cq/Uxa3GZmD3KfbR3KbfVUFni2Ef9erU+d1p6YE7jFpYMjOfG6Qof3Azu4Do0slx 4Tz8a1Nana+YP+U/RxYEH4tgl/L5OKQ2PkMNS56dTDKSk+IvcVhjFPKAyRt9PEa81Ivbc9 UU3j7W7OMVzsvHFzmWgDgw0KJOIlryRKRoCWC44Tbh82YlA3H3NUpF7zjbou4+UQv67EDm AeUnewE5ReB8pgMWSd4j7vnmAWYu5cCD3roPuNlpVaJ/g+XTmJq4HD6QGb++uy7Yb+thTJ r3NUhxxj2S0t3Vn22Xl2sr3vfsCJChRLgze+s2AGr40kZvXwSp8uifp6CYKWwzFTZ03zQN vH7DW7AkujrAYy24hYzB8YbmAAjGlQAAAAMBAAEAAAGABOxf8oIj1Gdvo5uVQI5oJCuN9l uMEX2wpOz87earwPrmVoXabKgtAvTYUjgtDqGb9L75LZGak529a7FXY7gEVlt4UdgLo3pB UqleLwCrWJ1UuTfVw3BoXOJjwvNfys4r6sPfrZWtwWJ8d318UhkdOfI+9qKvCu4DT3msP6 NFenFbtU7p+zKfSRaou2CjohSUKTp63zWbbCbrhNhqnSpfkEnVojp8xdj3QmoJnOi/hqAJ +0jVH06kzUusVounWoC41pTr1Dlnvy+gWhJcZtHNBXixL6JCM9XGh+z0XFgO8YTiHMdTfz Q2wf06TdXzOcM6XwPn3azyKmk7sn2v0s1pxGw8eu8tbmdU46xaLijwipn/B7NMsjk2gnqN eptwb/SQmIZZcloQZYLx9PejarAHe2NJ5BSJqOrSHZHYXjiSKj4X55lGdDOVCUCf4lmStQ qCS2LiM8Uhfga6f3X5EIBY75kqzmovDnPrqjufnCfYjBzQZ/m/txCbnZ9sTdQfXoVFAAAA wQC/5nbU5HzZtg7bA3kfBRUNGUSl8nM2zENY9Rxc8sZiL7iH3s1HAVyz8Frvmc1Wgt6EF+ WhtmNFklOmdYwq0W5+2qRdUN2P9QL+GKbuyp4AvwRmCFNhgm2GrCWQj/rkZ61vYS3bM8J8 MNJglvU2FktXvwFODhf6Kv/7fZQnJCf2LTMG6hIKF4LdBOSS/0V5MH2v4xu2U64wqQAQnu KzG4sRedsSHBGSknROJ7eGvGPZLh56PRb2gYPItoHcTMHqB6UAAADBAM4Xv6tHQFZtL+ul FwVVKhr3EKGY3+RV9IBXvXDkhee4i594Yl67BFUSU4eDb4xuek24znwKn+UFERzp+1X02h I1dZRdKtzJWOUQIF0FMPHbaPTuS7viT1OrL/PnG1yXUa+ii0qLExYI9qe463e8w6fNwhaT Em2wiDZcxr8SjQfqimyfmDizVlLE/xdgJ56eJ+OyXLjpezKKQif9YcFUW/eHej3YEcok6o WDwYpXG8z+VwOnOV4UN/sS8pLkJUdpqwAAAMEA7iTUVH3IvXMno0xYrVdhgNtZZGfQnryt pRfG/f5eQ1tjEQwE31mrbBcR278YWlQZwrMWZ0hDaJ3Q/Cp0+JySlm17jsA33lnTRmCHF4 WolX/LlFtH6jLr9SB8GOsn/8lC6IcvkED0UYYBjXipl6Unh9ZPnpbmJK9SgZWKNTGS1NBw xcVWIZTKOrpCD+zWH6KCviuhd3J5vBgkSVxTUzDqA7TmnMnUUxDQAAaU7Eqtt3CJuxsJIs vmZ2QrVK8TstC/AAAACm5jd0Bkb2dnZXI= -----END OPENSSH PRIVATE KEY----- #EOF chmod 600 ${PRIVATE_KEY} cat >${PUBLIC_KEY} <<'#EOF' ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQC/t7p34BvEQu9GTuxmKmR626qATj+9Vt//o8y453U5I/I46wA6zjW29zhKThL7/pF4dbiXUMrLkgfSyY6wDWTnyQoWQ3U0KEdTnPQKK0CJnB2XvOq/E0mqUyZiIZO5uFB0ycOurQACeHKv1MWtxmZg9yn20dym31VBZ4thH/Xq1PndaemBO4xaWDIznxukKH9wM7uA6NLJceE8/GtTWp2vmD/lP0cWBB+LYJfy+TikNj5DDUuenUwykpPiL3FYYxTygMkbfTxGvNSL23PVFN4+1uzjFc7Lxxc5loA4MNCiTiJa8kSkaAlguOE24fNmJQNx9zVKRe8426LuPlEL+uxA5gHlJ3sBOUXgfKYDFkneI+755gFmLuXAg966D7jZaVWif4Pl05iauBw+kBm/vrsu2G/rYUya9zVIccY9ktLd1Z9tl5drK9737AiQoUS4M3vrNgBq+NJGb18EqfLon6egmClsMxU2dN80Dbx+w1uwJLo6wGMtuIWMwfGG5gAIxpU= user@rclone-serve-test #EOF chmod 600 ${PUBLIC_KEY} run rclone serve sftp --authorized-keys "${PUBLIC_KEY}" --addr ${IP}:${PORT} ${DATADIR} echo type=sftp echo ssh=ssh -i ${PRIVATE_KEY} -o StrictHostKeyChecking=no -p ${PORT} user@${IP} echo _connect=${IP}:${PORT} } . $(dirname "$0")/rclone-serve.bash rclone-v1.71.0/fstest/testserver/init.d/TestSMB000077500000000000000000000012211505210326400213540ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=smb USER=rclone PASS=GNF3Cqeu WORKGROUP=thepub PORT=28630 . $(dirname "$0")/docker.bash start() { docker run --rm -d --name $NAME \ -p 127.0.0.1:${PORT}:445 \ -p 127.0.0.1:${PORT}:445/udp \ dperson/samba \ -p \ -u "rclone;${PASS}" \ -w "${WORKGROUP}" \ -s "public;/share" \ -s "rclone;/rclone;yes;no;no;rclone" echo type=smb echo host=127.0.0.1 echo user=$USER echo port=$PORT echo pass=$(rclone obscure $PASS) echo domain=$WORKGROUP echo _connect=127.0.0.1:${PORT} } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestSMBKerberos000077500000000000000000000040261505210326400230570ustar00rootroot00000000000000#!/usr/bin/env bash set -e IMAGE=rclone/test-smb-kerberos NAME=smb-kerberos USER=rclone DOMAIN=RCLONE REALM=RCLONE.LOCAL SMB_PORT=28633 KRB5_PORT=28634 # KRB5_CONFIG and KRB5CCNAME should be set by the caller but default # them here for the integration tests export TEMP_DIR=/tmp/rclone_krb5 mkdir -p "${TEMP_DIR}" export KRB5_CONFIG=${KRB5_CONFIG:-${TEMP_DIR}/krb5.conf} export KRB5CCNAME=${KRB5CCNAME:-${TEMP_DIR}/ccache} . $(dirname "$0")/docker.bash start() { docker build -t ${IMAGE} --load - <> /etc/samba/smb.conf [global] server signing = auto [public] path = /share browseable = yes read only = yes guest ok = yes [rclone] path = /rclone browseable = yes read only = no guest ok = no valid users = rclone EOS CMD ["samba", "-i"] EOF docker run --rm -d --name ${NAME} \ -p 127.0.0.1:${SMB_PORT}:445 \ -p 127.0.0.1:${SMB_PORT}:445/udp \ -p 127.0.0.1:${KRB5_PORT}:88 \ ${IMAGE} # KRB5_CONFIG and KRB5CCNAME are set by the caller cat > ${KRB5_CONFIG} <> /etc/samba/smb.conf [global] server signing = auto [public] path = /share browseable = yes read only = yes guest ok = yes [rclone] path = /rclone browseable = yes read only = no guest ok = no valid users = rclone EOS CMD ["samba", "-i"] EOF docker run --rm -d --name ${NAME} \ -p 127.0.0.1:${SMB_PORT}:445 \ -p 127.0.0.1:${SMB_PORT}:445/udp \ -p 127.0.0.1:${KRB5_PORT}:88 \ ${IMAGE} cat > "${KRB5_CONFIG}" </dev/null ; then echo "$NAME running" else echo "$NAME not running" return 1 fi return 0 } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestSeafileEncrypted000077500000000000000000000040501505210326400241640ustar00rootroot00000000000000#!/usr/bin/env bash set -e # local variables TEST_LIBRARY=Encrypted TEST_LIBRARY_PASSWORD=SecretKey # environment variables passed on docker-compose export NAME=seafile7encrypted export MYSQL_ROOT_PASSWORD=pixenij4zacoguq0kopamid6 export SEAFILE_ADMIN_EMAIL=seafile@rclone.org export SEAFILE_ADMIN_PASSWORD=pixenij4zacoguq0kopamid6 export SEAFILE_IP=127.0.0.1 export SEAFILE_PORT=8088 export SEAFILE_TEST_DATA=${SEAFILE_TEST_DATA:-/tmp/seafile-test-data} export SEAFILE_VERSION=latest # make sure the data directory exists mkdir -p ${SEAFILE_TEST_DATA}/${NAME} # docker-compose project directory COMPOSE_DIR=$(dirname "$0")/seafile start() { docker-compose --project-directory ${COMPOSE_DIR} --project-name ${NAME} --file ${COMPOSE_DIR}/docker-compose.yml up -d # it takes some time for the database to be created sleep 60 # authentication token answer should be like: {"token":"dbf58423f1632b5b679a13b0929f1d0751d9250c"} TOKEN=`curl --silent \ --data-urlencode username=${SEAFILE_ADMIN_EMAIL} -d password=${SEAFILE_ADMIN_PASSWORD} \ http://${SEAFILE_IP}:${SEAFILE_PORT}/api2/auth-token/ \ | sed 's/^{"token":"\(.*\)"}$/\1/'` # create encrypted library curl -X POST -d "name=${TEST_LIBRARY}&passwd=${TEST_LIBRARY_PASSWORD}" -H "Authorization: Token ${TOKEN}" "http://${SEAFILE_IP}:${SEAFILE_PORT}/api2/repos/" echo _connect=${SEAFILE_IP}:${SEAFILE_PORT} echo type=seafile echo url=http://${SEAFILE_IP}:${SEAFILE_PORT}/ echo user=${SEAFILE_ADMIN_EMAIL} echo pass=$(rclone obscure ${SEAFILE_ADMIN_PASSWORD}) echo library=${TEST_LIBRARY} echo library_key=$(rclone obscure ${TEST_LIBRARY_PASSWORD}) } stop() { if status ; then docker-compose --project-directory ${COMPOSE_DIR} --project-name ${NAME} --file ${COMPOSE_DIR}/docker-compose.yml down fi } status() { if docker ps --format "{{.Names}}" | grep ^${NAME}_seafile_1$ >/dev/null ; then echo "$NAME running" else echo "$NAME not running" return 1 fi return 0 } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestSeafileV6000077500000000000000000000030621505210326400225240ustar00rootroot00000000000000#!/usr/bin/env bash set -e # local variables NAME=seafile6 SEAFILE_IP=127.0.0.1 SEAFILE_PORT=8086 SEAFILE_ADMIN_EMAIL=seafile@rclone.org SEAFILE_ADMIN_PASSWORD=qebiwob7wafixif8sojiboj4 SEAFILE_TEST_DATA=${SEAFILE_TEST_DATA:-/tmp/seafile-test-data} SEAFILE_VERSION=latest . $(dirname "$0")/docker.bash start() { # make sure the data directory exists mkdir -p ${SEAFILE_TEST_DATA}/${NAME} docker run --rm -d --name $NAME \ -e SEAFILE_SERVER_HOSTNAME=${SEAFILE_IP}:${SEAFILE_PORT} \ -e SEAFILE_ADMIN_EMAIL=${SEAFILE_ADMIN_EMAIL} \ -e SEAFILE_ADMIN_PASSWORD=${SEAFILE_ADMIN_PASSWORD} \ -v ${SEAFILE_TEST_DATA}/${NAME}:/shared \ -p ${SEAFILE_IP}:${SEAFILE_PORT}:80 \ seafileltd/seafile:${SEAFILE_VERSION} # it takes some time for the database to be created sleep 60 # authentication token answer should be like: {"token":"dbf58423f1632b5b679a13b0929f1d0751d9250c"} TOKEN=`curl --silent \ --data-urlencode username=${SEAFILE_ADMIN_EMAIL} -d password=${SEAFILE_ADMIN_PASSWORD} \ http://${SEAFILE_IP}:${SEAFILE_PORT}/api2/auth-token/ \ | sed 's/^{"token":"\(.*\)"}$/\1/'` # create default library curl -X POST -H "Authorization: Token ${TOKEN}" "http://${SEAFILE_IP}:${SEAFILE_PORT}/api2/default-repo/" echo _connect=${SEAFILE_IP}:${SEAFILE_PORT} echo type=seafile echo url=http://${SEAFILE_IP}:${SEAFILE_PORT}/ echo user=${SEAFILE_ADMIN_EMAIL} echo pass=$(rclone obscure ${SEAFILE_ADMIN_PASSWORD}) echo library=My Library } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestSia000077500000000000000000000025711505210326400214600ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=Sia # shellcheck disable=SC1090 . "$(dirname "$0")"/docker.bash # wait until Sia test network is up, # the Sia renter forms contracts on the blockchain # and the renter is upload ready wait_for_sia() { until curl -A Sia-Agent -s "$1" | grep -q '"ready":true' do sleep 5 done } export -f wait_for_sia start() { # use non-production sia port in test SIA_CONN="127.0.0.1:39980" # nebulouslabs/siaantfarm is stale, use up-to-date image ANTFARM_IMAGE=ivandeex/sia-antfarm:latest # pull latest antfarm image (dont use local image) docker pull --quiet $ANTFARM_IMAGE # start latest antfarm with default config docker run --rm --detach --name "$NAME" \ --publish "${SIA_CONN}:9980" \ $ANTFARM_IMAGE # wait until the test network is upload ready timeout 300 bash -c "wait_for_sia ${SIA_CONN}/renter/uploadready" # confirm backend type in the generated rclone.conf echo "type=sia" # override keys in the Sia section of generated rclone.conf echo "api_url=http://${SIA_CONN}/" # hint test harness where to probe for connection echo "_connect=${SIA_CONN}" } stop() { if status ; then docker logs "$NAME" >> sia-test.log 2>&1 docker kill "$NAME" echo "${NAME} stopped" fi } # shellcheck disable=SC1090 . "$(dirname "$0")"/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestSwiftAIO000077500000000000000000000006461505210326400223720ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=swift-aio PORT=28628 . $(dirname "$0")/docker.bash start() { docker run --rm -d --name ${NAME} \ -p 127.0.0.1:${PORT}:8080 \ bouncestorage/swift-aio echo type=swift echo env_auth=false echo user=test:tester echo key=testing echo auth=http://127.0.0.1:${PORT}/auth/v1.0 echo _connect=127.0.0.1:${PORT} } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestSwiftAIOsegments000077500000000000000000000007151505210326400241350ustar00rootroot00000000000000#!/bin/bash set -e NAME=swift-aio-segments PORT=28632 . $(dirname "$0")/docker.bash start() { docker run --rm -d --name ${NAME} \ -p 127.0.0.1:${PORT}:8080 \ bouncestorage/swift-aio echo type=swift echo env_auth=false echo user=test:tester echo key=testing echo auth=http://127.0.0.1:${PORT}/auth/v1.0 echo use_segments_container=false echo _connect=127.0.0.1:${PORT} } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestWebdavInfiniteScale000077500000000000000000000025071505210326400246110ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=infinitescale USER=admin PASS=admin PORT=9200 CONF_DIR=/tmp/ocis-config mkdir -p ${CONF_DIR} chmod 777 ${CONF_DIR} || true . $(dirname "$0")/docker.bash start() { docker run --rm --name $NAME \ -v ${CONF_DIR}:/etc/ocis \ -e "OCIS_INSECURE=true" \ -e "IDM_ADMIN_PASSWORD=$PASS" \ -e "OCIS_FORCE_CONFIG_OVERWRITE=true" \ -e "OCIS_URL=https://127.0.0.1:$PORT" \ owncloud/ocis \ init docker run --rm -d --name $NAME \ -e "OCIS_LOG_LEVEL=debug" \ -e "OCIS_LOG_PRETTY=true" \ -e "OCIS_URL=https://127.0.0.1:$PORT" \ -e "OCIS_ADMIN_USER_ID=some-admin-user-id-0000-100000000000" \ -e "IDM_ADMIN_PASSWORD=$PASS" \ -e "OCIS_INSECURE=true" \ -e "PROXY_ENABLE_BASIC_AUTH=true" \ -v ${CONF_DIR}:/etc/ocis \ -p 127.0.0.1:${PORT}:9200 \ owncloud/ocis echo type=webdav echo url=https://127.0.0.1:${PORT}/dav/spaces/some-admin-user-id-0000-100000000000 echo user=$USER echo pass=$(rclone obscure $PASS) echo vendor=infinitescale echo _connect=127.0.0.1:${PORT} echo _connect_delay=5s } stop() { # Clean up the mess docker stop infinitescale rm -f ./ocis.yaml } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestWebdavNextcloud000077500000000000000000000012341505210326400240350ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=nextcloud USER=rclone PASS=ArmorAbleMale6 PORT=28629 . $(dirname "$0")/docker.bash start() { docker run --rm -d --name $NAME \ -e "SQLITE_DATABASE=nextcloud.db" \ -e "NEXTCLOUD_ADMIN_USER=rclone" \ -e "NEXTCLOUD_ADMIN_PASSWORD=$PASS" \ -e "NEXTCLOUD_TRUSTED_DOMAINS=*.*.*.*" \ -p 127.0.0.1:${PORT}:80 \ nextcloud:latest echo type=webdav echo url=http://127.0.0.1:${PORT}/remote.php/dav/files/$USER/ echo user=$USER echo pass=$(rclone obscure $PASS) echo vendor=nextcloud echo _connect=127.0.0.1:${PORT} } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestWebdavOwncloud000077500000000000000000000015251505210326400236650ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=owncloud USER=rclone PASS=HarperGrayerFewest5 PORT=38081 . $(dirname "$0")/docker.bash start() { docker run --rm -d --name $NAME \ -e "OWNCLOUD_DOMAIN=${OWNCLOUD_DOMAIN}" \ -e "OWNCLOUD_DB_TYPE=sqlite" \ -e "OWNCLOUD_DB_NAME=owncloud.db" \ -e "OWNCLOUD_ADMIN_USERNAME=$USER" \ -e "OWNCLOUD_ADMIN_PASSWORD=$PASS" \ -e "OWNCLOUD_MYSQL_UTF8MB4=true" \ -e "OWNCLOUD_REDIS_ENABLED=false" \ -e "OWNCLOUD_TRUSTED_DOMAINS=127.0.0.1" \ -p 127.0.0.1:${PORT}:8080 \ owncloud/server echo type=webdav echo url=http://127.0.0.1:${PORT}/remote.php/webdav/ echo user=$USER echo pass=$(rclone obscure $PASS) echo vendor=owncloud echo _connect=127.0.0.1:${PORT} } . $(dirname "$0")/run.bash rclone-v1.71.0/fstest/testserver/init.d/TestWebdavRclone000077500000000000000000000006451505210326400233170ustar00rootroot00000000000000#!/usr/bin/env bash set -e NAME=rclone-serve-webdav USER=rclone PASS=PagansSwimExpiry9 IP=127.0.0.1 PORT=28620 start() { run rclone serve webdav --user $USER --pass $PASS --addr ${IP}:${PORT} ${DATADIR} echo type=webdav echo vendor=rclone echo url=http://${IP}:${PORT}/ echo user=$USER echo pass=$(rclone obscure $PASS) echo _connect=${IP}:$PORT } . $(dirname "$0")/rclone-serve.bash rclone-v1.71.0/fstest/testserver/init.d/docker.bash000066400000000000000000000006611505210326400222620ustar00rootroot00000000000000#!/usr/bin/env bash stop() { if status ; then docker stop "$NAME" echo "$NAME stopped" fi } status() { if docker ps --format '{{.Names}}' | grep -q "^${NAME}$" ; then echo "$NAME running" else echo "$NAME not running" return 1 fi return 0 } docker_ip() { docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{"\n"}}{{end}}' "$NAME" | head -n 1 } rclone-v1.71.0/fstest/testserver/init.d/rclone-serve.bash000066400000000000000000000014151505210326400234150ustar00rootroot00000000000000#!/usr/bin/env bash # start an "rclone serve" server PIDFILE=/tmp/${NAME}.pid DATADIR=/tmp/${NAME}-data stop() { if status ; then pid=$(cat "$PIDFILE") kill "$pid" rm "$PIDFILE" echo "$NAME stopped" fi } status() { if [ -e "$PIDFILE" ]; then pid=$(cat "$PIDFILE") if kill -0 "$pid" >/dev/null 2>&1; then # echo "$NAME running" return 0 else rm "$PIDFILE" fi fi # echo "$NAME not running" return 1 } run() { if ! status ; then mkdir -p "$DATADIR" nohup "$@" >> "/tmp/${NAME}.log" 2>&1 "$PIDFILE" disown "$pid" fi } # shellcheck disable=SC1090 . "$(dirname "$0")/run.bash" rclone-v1.71.0/fstest/testserver/init.d/run.bash000066400000000000000000000002451505210326400216150ustar00rootroot00000000000000#!/usr/bin/env bash case "$1" in start) start ;; stop) stop ;; status) status ;; *) echo "usage: $0 start|stop|status" >&2 exit 1 ;; esac rclone-v1.71.0/fstest/testserver/init.d/seafile/000077500000000000000000000000001505210326400215615ustar00rootroot00000000000000rclone-v1.71.0/fstest/testserver/init.d/seafile/docker-compose.yml000066400000000000000000000015371505210326400252240ustar00rootroot00000000000000version: '2.0' services: db: image: mariadb:10.5 environment: - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD} - MYSQL_LOG_CONSOLE=true volumes: - ${SEAFILE_TEST_DATA}/${NAME}/seafile-mysql/db:/var/lib/mysql memcached: image: memcached:1.6.9 entrypoint: memcached -m 256 seafile: image: seafileltd/seafile-mc:${SEAFILE_VERSION} ports: - "${SEAFILE_IP}:${SEAFILE_PORT}:80" volumes: - ${SEAFILE_TEST_DATA}/${NAME}/seafile-data:/shared environment: - DB_HOST=db - DB_ROOT_PASSWD=${MYSQL_ROOT_PASSWORD} - TIME_ZONE=Etc/UTC - SEAFILE_ADMIN_EMAIL=${SEAFILE_ADMIN_EMAIL} - SEAFILE_ADMIN_PASSWORD=${SEAFILE_ADMIN_PASSWORD} - SEAFILE_SERVER_LETSENCRYPT=false - SEAFILE_SERVER_HOSTNAME=${SEAFILE_IP}:${SEAFILE_PORT} depends_on: - db - memcached rclone-v1.71.0/fstest/testserver/testserver.go000066400000000000000000000123061505210326400215230ustar00rootroot00000000000000// Package testserver starts and stops test servers if required package testserver import ( "bytes" "errors" "fmt" "net" "os" "os/exec" "path/filepath" "regexp" "strings" "sync" "time" "github.com/rclone/rclone/fs" "github.com/rclone/rclone/fs/fspath" ) var ( once sync.Once configDir string // where the config is stored // Note of running servers runningMu sync.Mutex running = map[string]int{} errNotFound = errors.New("command not found") ) // Assume we are run somewhere within the rclone root func findConfig() (string, error) { dir := filepath.Join("fstest", "testserver", "init.d") for range 5 { fi, err := os.Stat(dir) if err == nil && fi.IsDir() { return filepath.Abs(dir) } else if !os.IsNotExist(err) { return "", err } dir = filepath.Join("..", dir) } return "", errors.New("couldn't find testserver config files - run from within rclone source") } // run the command returning the output and an error func run(name, command string) (out []byte, err error) { cmdPath := filepath.Join(configDir, name) fi, err := os.Stat(cmdPath) if err != nil || fi.IsDir() { return nil, errNotFound } cmd := exec.Command(cmdPath, command) out, err = cmd.CombinedOutput() if err != nil { err = fmt.Errorf("failed to run %s %s\n%s: %w", cmdPath, command, string(out), err) } return out, err } // Check to see if the server is running func isRunning(name string) bool { _, err := run(name, "status") return err == nil } // envKey returns the environment variable name to set name, key func envKey(name, key string) string { return fmt.Sprintf("RCLONE_CONFIG_%s_%s", strings.ToUpper(name), strings.ToUpper(key)) } // match a line of config var=value var matchLine = regexp.MustCompile(`^([a-zA-Z_]+)=(.*)$`) // Start the server and set its env vars // Call with the mutex held func start(name string) error { fs.Logf(name, "Starting server") out, err := run(name, "start") if err != nil { return err } // parse the output and set environment vars from it var connect string var connectDelay time.Duration for _, line := range bytes.Split(out, []byte("\n")) { line = bytes.TrimSpace(line) part := matchLine.FindSubmatch(line) if part != nil { key, value := part[1], part[2] if string(key) == "_connect" { connect = string(value) continue } else if string(key) == "_connect_delay" { connectDelay, err = time.ParseDuration(string(value)) if err != nil { return fmt.Errorf("bad _connect_delay: %w", err) } continue } // fs.Debugf(name, "key = %q, envKey = %q, value = %q", key, envKey(name, string(key)), value) err = os.Setenv(envKey(name, string(key)), string(value)) if err != nil { return err } } } if connect == "" { fs.Logf(name, "Started server") return nil } // If we got a _connect value then try to connect to it const maxTries = 30 var rdBuf = make([]byte, 1) for i := 1; i <= maxTries; i++ { if i != 0 { time.Sleep(time.Second) } fs.Logf(name, "Attempting to connect to %q try %d/%d", connect, i, maxTries) conn, err := net.DialTimeout("tcp", connect, time.Second) if err != nil { fs.Debugf(name, "Connection to %q failed try %d/%d: %v", connect, i, maxTries, err) continue } err = conn.SetReadDeadline(time.Now().Add(time.Second)) if err != nil { return fmt.Errorf("failed to set deadline: %w", err) } n, err := conn.Read(rdBuf) _ = conn.Close() fs.Debugf(name, "Read %d, error: %v", n, err) if err != nil && !errors.Is(err, os.ErrDeadlineExceeded) { // Try again continue } if connectDelay > 0 { fs.Logf(name, "Connect delay %v", connectDelay) time.Sleep(connectDelay) } fs.Logf(name, "Started server and connected to %q", connect) return nil } return fmt.Errorf("failed to connect to %q on %q", name, connect) } // Start starts the named test server which can be stopped by the // function returned. func Start(remoteName string) (fn func(), err error) { if remoteName == "" { // don't start the local backend return func() {}, nil } parsed, err := fspath.Parse(remoteName) if err != nil { return nil, err } name := parsed.ConfigString if name == "" { // don't start the local backend return func() {}, nil } // Make sure we know where the config is once.Do(func() { configDir, err = findConfig() }) if err != nil { return nil, err } runningMu.Lock() defer runningMu.Unlock() if running[name] <= 0 { // if server isn't running check to see if this server has // been started already but not by us and stop it if so if os.Getenv(envKey(name, "type")) == "" && isRunning(name) { stop(name) } if !isRunning(name) { err = start(name) if err == errNotFound { // if no file found then don't start or stop return func() {}, nil } else if err != nil { return nil, err } running[name] = 0 } else { running[name] = 1 } } running[name]++ return func() { runningMu.Lock() defer runningMu.Unlock() stop(name) }, nil } // Stops the named test server // Call with the mutex held func stop(name string) { running[name]-- if running[name] <= 0 { _, err := run(name, "stop") if err != nil { fs.Errorf(name, "Failed to stop server: %v", err) } running[name] = 0 fs.Logf(name, "Stopped server") } } rclone-v1.71.0/fstest/testy/000077500000000000000000000000001505210326400157265ustar00rootroot00000000000000rclone-v1.71.0/fstest/testy/testy.go000066400000000000000000000005431505210326400174270ustar00rootroot00000000000000// Package testy contains test utilities for rclone package testy import ( "os" "testing" ) // CI returns true if we are running on the CI server func CI() bool { return os.Getenv("CI") != "" } // SkipUnreliable skips this test if running on CI func SkipUnreliable(t *testing.T) { if !CI() { return } t.Skip("Skipping Unreliable Test on CI") } rclone-v1.71.0/go.mod000066400000000000000000000276661505210326400143750ustar00rootroot00000000000000module github.com/rclone/rclone go 1.24.0 require ( bazil.org/fuse v0.0.0-20230120002735-62a210ff1fd5 github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.2 github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.11.0 github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.2 github.com/Azure/azure-sdk-for-go/sdk/storage/azfile v1.5.2 github.com/Azure/go-ntlmssp v0.0.0-20221128193559-754e69321358 github.com/Files-com/files-sdk-go/v3 v3.2.218 github.com/Max-Sum/base32768 v0.0.0-20230304063302-18e6ce5945fd github.com/a8m/tree v0.0.0-20240104212747-2c8764a5f17e github.com/aalpar/deheap v0.0.0-20210914013432-0cc84d79dec3 github.com/abbot/go-http-auth v0.4.0 github.com/anacrolix/dms v1.7.2 github.com/anacrolix/log v0.16.0 github.com/atotto/clipboard v0.1.4 github.com/aws/aws-sdk-go-v2 v1.38.0 github.com/aws/aws-sdk-go-v2/config v1.31.0 github.com/aws/aws-sdk-go-v2/credentials v1.18.4 github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.18.4 github.com/aws/aws-sdk-go-v2/service/s3 v1.87.0 github.com/aws/smithy-go v1.22.5 github.com/buengese/sgzip v0.1.1 github.com/cloudinary/cloudinary-go/v2 v2.12.0 github.com/cloudsoda/go-smb2 v0.0.0-20250228001242-d4c70e6251cc github.com/colinmarc/hdfs/v2 v2.4.0 github.com/coreos/go-semver v0.3.1 github.com/coreos/go-systemd/v22 v22.5.0 github.com/dop251/scsu v0.0.0-20220106150536-84ac88021d00 github.com/dropbox/dropbox-sdk-go-unofficial/v6 v6.0.5 github.com/gabriel-vasile/mimetype v1.4.9 github.com/gdamore/tcell/v2 v2.8.1 github.com/go-chi/chi/v5 v5.2.2 github.com/go-darwin/apfs v0.0.0-20211011131704-f84b94dbf348 github.com/go-git/go-billy/v5 v5.6.2 github.com/google/uuid v1.6.0 github.com/hanwen/go-fuse/v2 v2.8.0 github.com/henrybear327/Proton-API-Bridge v1.0.0 github.com/henrybear327/go-proton-api v1.0.0 github.com/jcmturner/gokrb5/v8 v8.4.4 github.com/jlaffaye/ftp v0.2.1-0.20240918233326-1b970516f5d3 github.com/josephspurrier/goversioninfo v1.5.0 github.com/jzelinskie/whirlpool v0.0.0-20201016144138-0675e54bb004 github.com/klauspost/compress v1.18.0 github.com/koofr/go-httpclient v0.0.0-20240520111329-e20f8f203988 github.com/koofr/go-koofrclient v0.0.0-20221207135200-cbd7fc9ad6a6 github.com/lanrat/extsort v1.4.0 github.com/mattn/go-colorable v0.1.14 github.com/mattn/go-runewidth v0.0.16 github.com/minio/minio-go/v7 v7.0.95 github.com/mitchellh/go-homedir v1.1.0 github.com/moby/sys/mountinfo v0.7.2 github.com/ncw/swift/v2 v2.0.4 github.com/oracle/oci-go-sdk/v65 v65.98.0 github.com/patrickmn/go-cache v2.1.0+incompatible github.com/peterh/liner v1.2.2 github.com/pkg/sftp v1.13.9 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 github.com/prometheus/client_golang v1.23.0 github.com/putdotio/go-putio/putio v0.0.0-20200123120452-16d982cac2b8 github.com/quasilyte/go-ruleguard/dsl v0.3.22 github.com/rclone/gofakes3 v0.0.4 github.com/rfjakob/eme v1.1.2 github.com/rivo/uniseg v0.4.7 github.com/rogpeppe/go-internal v1.14.1 github.com/shirou/gopsutil/v4 v4.25.7 github.com/skratchdot/open-golang v0.0.0-20200116055534-eef842397966 github.com/spf13/cobra v1.9.1 github.com/spf13/pflag v1.0.7 github.com/stretchr/testify v1.10.0 github.com/t3rm1n4l/go-mega v0.0.0-20241213151442-a19cff0ec7b5 github.com/unknwon/goconfig v1.0.0 github.com/willscott/go-nfs v0.0.3 github.com/winfsp/cgofuse v1.6.0 github.com/xanzy/ssh-agent v0.3.3 github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 github.com/yunify/qingstor-sdk-go/v3 v3.2.0 github.com/zeebo/blake3 v0.2.4 github.com/zeebo/xxh3 v1.0.2 go.etcd.io/bbolt v1.4.2 goftp.io/server/v2 v2.0.1 golang.org/x/crypto v0.41.0 golang.org/x/net v0.43.0 golang.org/x/oauth2 v0.30.0 golang.org/x/sync v0.16.0 golang.org/x/sys v0.35.0 golang.org/x/text v0.28.0 golang.org/x/time v0.12.0 google.golang.org/api v0.247.0 gopkg.in/natefinch/lumberjack.v2 v2.2.1 gopkg.in/validator.v2 v2.0.1 gopkg.in/yaml.v3 v3.0.1 storj.io/uplink v1.13.1 ) require ( cloud.google.com/go/auth v0.16.4 // indirect cloud.google.com/go/auth/oauth2adapt v0.2.8 // indirect cloud.google.com/go/compute/metadata v0.8.0 // indirect github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 // indirect github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2 // indirect github.com/ProtonMail/bcrypt v0.0.0-20211005172633-e235017c1baf // indirect github.com/ProtonMail/gluon v0.17.1-0.20230724134000-308be39be96e // indirect github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f // indirect github.com/ProtonMail/go-srp v0.0.7 // indirect github.com/ProtonMail/gopenpgp/v2 v2.9.0 // indirect github.com/PuerkitoBio/goquery v1.10.3 // indirect github.com/akavel/rsrc v0.10.2 // indirect github.com/anacrolix/generics v0.0.3 // indirect github.com/andybalholm/cascadia v1.3.3 // indirect github.com/appscode/go-querystring v0.0.0-20170504095604-0126cfb3f1dc // indirect github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.0 // indirect github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.3 // indirect github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.3 // indirect github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.3 // indirect github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 // indirect github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.3 // indirect github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.0 // indirect github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.8.3 // indirect github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.3 // indirect github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.3 // indirect github.com/aws/aws-sdk-go-v2/service/sso v1.28.0 // indirect github.com/aws/aws-sdk-go-v2/service/ssooidc v1.33.0 // indirect github.com/aws/aws-sdk-go-v2/service/sts v1.37.0 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/bradenaw/juniper v0.15.3 // indirect github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8 // indirect github.com/calebcase/tmpfile v1.0.3 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/chilts/sid v0.0.0-20190607042430-660e94789ec9 // indirect github.com/cloudflare/circl v1.6.1 // indirect github.com/cloudsoda/sddl v0.0.0-20250224235906-926454e91efc // indirect github.com/cpuguy83/go-md2man/v2 v2.0.7 // indirect github.com/creasty/defaults v1.8.0 // indirect github.com/cronokirby/saferith v0.33.0 // indirect github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/ebitengine/purego v0.8.4 // indirect github.com/emersion/go-message v0.18.2 // indirect github.com/emersion/go-vcard v0.0.0-20241024213814-c9703dde27ff // indirect github.com/felixge/httpsnoop v1.0.4 // indirect github.com/flynn/noise v1.1.0 // indirect github.com/gdamore/encoding v1.0.1 // indirect github.com/geoffgarside/ber v1.2.0 // indirect github.com/go-ini/ini v1.67.0 // indirect github.com/go-logr/logr v1.4.3 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-ole/go-ole v1.3.0 // indirect github.com/go-openapi/errors v0.22.2 // indirect github.com/go-openapi/strfmt v0.23.0 // indirect github.com/go-playground/locales v0.14.1 // indirect github.com/go-playground/universal-translator v0.18.1 // indirect github.com/go-playground/validator/v10 v10.27.0 // indirect github.com/go-resty/resty/v2 v2.16.5 // indirect github.com/goccy/go-json v0.10.5 // indirect github.com/gofrs/flock v0.12.1 // indirect github.com/gogo/protobuf v1.3.2 // indirect github.com/golang-jwt/jwt/v5 v5.3.0 // indirect github.com/google/s2a-go v0.1.9 // indirect github.com/googleapis/enterprise-certificate-proxy v0.3.6 // indirect github.com/googleapis/gax-go/v2 v2.15.0 // indirect github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e // indirect github.com/gorilla/schema v1.4.1 // indirect github.com/hashicorp/errwrap v1.1.0 // indirect github.com/hashicorp/go-cleanhttp v0.5.2 // indirect github.com/hashicorp/go-multierror v1.1.1 // indirect github.com/hashicorp/go-retryablehttp v0.7.8 // indirect github.com/hashicorp/go-uuid v1.0.3 // indirect github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/jcmturner/aescts/v2 v2.0.0 // indirect github.com/jcmturner/dnsutils/v2 v2.0.0 // indirect github.com/jcmturner/gofork v1.7.6 // indirect github.com/jcmturner/goidentity/v6 v6.0.1 // indirect github.com/jcmturner/rpc/v2 v2.0.3 // indirect github.com/jtolio/noiseconn v0.0.0-20231127013910-f6d9ecbf1de7 // indirect github.com/klauspost/cpuid/v2 v2.3.0 // indirect github.com/kr/fs v0.1.0 // indirect github.com/kylelemons/godebug v1.1.0 // indirect github.com/leodido/go-urn v1.4.0 // indirect github.com/lpar/date v1.0.0 // indirect github.com/lucasb-eyer/go-colorful v1.2.0 // indirect github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 // indirect github.com/mattn/go-isatty v0.0.20 // indirect github.com/minio/crc64nvme v1.1.1 // indirect github.com/minio/md5-simd v1.1.2 // indirect github.com/minio/xxml v0.0.3 // indirect github.com/mitchellh/mapstructure v1.5.0 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/oklog/ulid v1.3.1 // indirect github.com/panjf2000/ants/v2 v2.11.3 // indirect github.com/pengsrc/go-shared v0.2.1-0.20190131101655-1999055a4a14 // indirect github.com/philhofer/fwd v1.2.0 // indirect github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect github.com/pkg/errors v0.9.1 // indirect github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect github.com/prometheus/client_model v0.6.2 // indirect github.com/prometheus/common v0.65.0 // indirect github.com/prometheus/procfs v0.17.0 // indirect github.com/rasky/go-xdr v0.0.0-20170124162913-1a41d1a06c93 // indirect github.com/relvacode/iso8601 v1.6.0 // indirect github.com/rs/xid v1.6.0 // indirect github.com/russross/blackfriday/v2 v2.1.0 // indirect github.com/ryszard/goskiplist v0.0.0-20150312221310-2dfbae5fcf46 // indirect github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 // indirect github.com/samber/lo v1.51.0 // indirect github.com/shabbyrobe/gocovmerge v0.0.0-20230507112040-c3350d9342df // indirect github.com/sirupsen/logrus v1.9.3 // indirect github.com/sony/gobreaker v1.0.0 // indirect github.com/spacemonkeygo/monkit/v3 v3.0.24 // indirect github.com/tinylib/msgp v1.3.0 // indirect github.com/tklauser/go-sysconf v0.3.15 // indirect github.com/tklauser/numcpus v0.10.0 // indirect github.com/willscott/go-nfs-client v0.0.0-20240104095149-b44639837b00 // indirect github.com/yusufpapurcu/wmi v1.2.4 // indirect github.com/zeebo/errs v1.4.0 // indirect go.mongodb.org/mongo-driver v1.17.4 // indirect go.opentelemetry.io/auto/sdk v1.1.0 // indirect go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.62.0 // indirect go.opentelemetry.io/otel v1.37.0 // indirect go.opentelemetry.io/otel/metric v1.37.0 // indirect go.opentelemetry.io/otel/trace v1.37.0 // indirect go.yaml.in/yaml/v2 v2.4.2 // indirect golang.org/x/exp v0.0.0-20250811191247-51f88131bc50 // indirect golang.org/x/tools v0.36.0 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20250811230008-5f3141c8851a // indirect google.golang.org/grpc v1.74.2 // indirect google.golang.org/protobuf v1.36.7 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect moul.io/http2curl/v2 v2.3.0 // indirect sigs.k8s.io/yaml v1.6.0 // indirect storj.io/common v0.0.0-20250808122759-804533d519c1 // indirect storj.io/drpc v0.0.35-0.20250513201419-f7819ea69b55 // indirect storj.io/eventkit v0.0.0-20250410172343-61f26d3de156 // indirect storj.io/infectious v0.0.2 // indirect storj.io/picobuf v0.0.4 // indirect ) require ( github.com/IBM/go-sdk-core/v5 v5.21.0 github.com/Microsoft/go-winio v0.6.2 // indirect github.com/ProtonMail/go-crypto v1.3.0 github.com/golang-jwt/jwt/v4 v4.5.2 github.com/pkg/xattr v0.4.12 golang.org/x/mobile v0.0.0-20250808145247-395d808d53cd golang.org/x/term v0.34.0 ) rclone-v1.71.0/go.sum000066400000000000000000003142301505210326400144040ustar00rootroot00000000000000bazil.org/fuse v0.0.0-20230120002735-62a210ff1fd5 h1:A0NsYy4lDBZAC6QiYeJ4N+XuHIKBpyhAVRMHRQZKTeQ= bazil.org/fuse v0.0.0-20230120002735-62a210ff1fd5/go.mod h1:gG3RZAMXCa/OTes6rr9EwusmR1OH1tDDy+cg9c5YliY= cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= cloud.google.com/go/auth v0.16.4 h1:fXOAIQmkApVvcIn7Pc2+5J8QTMVbUGLscnSVNl11su8= cloud.google.com/go/auth v0.16.4/go.mod h1:j10ncYwjX/g3cdX7GpEzsdM+d+ZNsXAbb6qXA7p1Y5M= cloud.google.com/go/auth/oauth2adapt v0.2.8 h1:keo8NaayQZ6wimpNSmW5OPc283g65QNIiLpZnkHRbnc= cloud.google.com/go/auth/oauth2adapt v0.2.8/go.mod h1:XQ9y31RkqZCcwJWNSx2Xvric3RrU88hAYYbjDWYDL+c= cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= cloud.google.com/go/compute/metadata v0.8.0 h1:HxMRIbao8w17ZX6wBnjhcDkW6lTFpgcaobyVfZWqRLA= cloud.google.com/go/compute/metadata v0.8.0/go.mod h1:sYOGTp851OV9bOFJ9CH7elVvyzopvWQFNNghtDQ/Biw= cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.2 h1:Hr5FTipp7SL07o2FvoVOX9HRiRH3CR3Mj8pxqCcdD5A= github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.2/go.mod h1:QyVsSSN64v5TGltphKLQ2sQxe4OBQg0J1eKRcVBnfgE= github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.11.0 h1:MhRfI58HblXzCtWEZCO0feHs8LweePB3s90r7WaR1KU= github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.11.0/go.mod h1:okZ+ZURbArNdlJ+ptXoyHNuOETzOl1Oww19rm8I2WLA= github.com/Azure/azure-sdk-for-go/sdk/azidentity/cache v0.3.2 h1:yz1bePFlP5Vws5+8ez6T3HWXPmwOK7Yvq8QxDBD3SKY= github.com/Azure/azure-sdk-for-go/sdk/azidentity/cache v0.3.2/go.mod h1:Pa9ZNPuoNu/GztvBSKk9J1cDJW6vk/n0zLtV4mgd8N8= github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 h1:9iefClla7iYpfYWdzPCRDozdmndjTm8DXdpCzPajMgA= github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2/go.mod h1:XtLgD3ZD34DAaVIIAyG3objl5DynM3CQ/vMcbBNJZGI= github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.8.1 h1:/Zt+cDPnpC3OVDm/JKLOs7M2DKmLRIIp3XIx9pHHiig= github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage v1.8.1/go.mod h1:Ng3urmn6dYe8gnbCMoHHVl5APYz2txho3koEkV2o2HA= github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.2 h1:FwladfywkNirM+FZYLBR2kBz5C8Tg0fw5w5Y7meRXWI= github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.2/go.mod h1:vv5Ad0RrIoT1lJFdWBZwt4mB1+j+V8DUroixmKDTCdk= github.com/Azure/azure-sdk-for-go/sdk/storage/azfile v1.5.2 h1:l3SabZmNuXCMCbQUIeR4W6/N4j8SeH/lwX+a6leZhHo= github.com/Azure/azure-sdk-for-go/sdk/storage/azfile v1.5.2/go.mod h1:k+mEZ4f1pVqZTRqtSDW2AhZ/3wT5qLpsUA75C/k7dtE= github.com/Azure/go-ntlmssp v0.0.0-20221128193559-754e69321358 h1:mFRzDkZVAjdal+s7s0MwaRv9igoPqLRdzOLzw/8Xvq8= github.com/Azure/go-ntlmssp v0.0.0-20221128193559-754e69321358/go.mod h1:chxPXzSsl7ZWRAuOIE23GDNzjWuZquvFlgA8xmpunjU= github.com/AzureAD/microsoft-authentication-extensions-for-go/cache v0.1.1 h1:WJTmL004Abzc5wDB5VtZG2PJk5ndYDgVacGqfirKxjM= github.com/AzureAD/microsoft-authentication-extensions-for-go/cache v0.1.1/go.mod h1:tCcJZ0uHAmvjsVYzEFivsRTN00oz5BEsRgQHu5JZ9WE= github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2 h1:oygO0locgZJe7PpYPXT5A29ZkwJaPqcva7BVeemZOZs= github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= github.com/Files-com/files-sdk-go/v3 v3.2.218 h1:tIvcbHXNY/bq+Sno6vajOJOxhe5XbU59Fa1ohOybK+s= github.com/Files-com/files-sdk-go/v3 v3.2.218/go.mod h1:E0BaGQbcMUcql+AfubCR/iasWKBxX5UZPivnQGC2z0M= github.com/IBM/go-sdk-core/v5 v5.21.0 h1:DUnYhvC4SoC8T84rx5omnhY3+xcQg/Whyoa3mDPIMkk= github.com/IBM/go-sdk-core/v5 v5.21.0/go.mod h1:Q3BYO6iDA2zweQPDGbNTtqft5tDcEpm6RTuqMlPcvbw= github.com/Masterminds/semver/v3 v3.2.0 h1:3MEsd0SM6jqZojhjLWWeBY+Kcjy9i6MQAeY7YgDP83g= github.com/Masterminds/semver/v3 v3.2.0/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ= github.com/Max-Sum/base32768 v0.0.0-20230304063302-18e6ce5945fd h1:nzE1YQBdx1bq9IlZinHa+HVffy+NmVRoKr+wHN8fpLE= github.com/Max-Sum/base32768 v0.0.0-20230304063302-18e6ce5945fd/go.mod h1:C8yoIfvESpM3GD07OCHU7fqI7lhwyZ2Td1rbNbTAhnc= github.com/Microsoft/go-winio v0.5.2/go.mod h1:WpS1mjBmmwHBEWmogvA2mj8546UReBk4v8QkMxJ6pZY= github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= github.com/ProtonMail/bcrypt v0.0.0-20210511135022-227b4adcab57/go.mod h1:HecWFHognK8GfRDGnFQbW/LiV7A3MX3gZVs45vk5h8I= github.com/ProtonMail/bcrypt v0.0.0-20211005172633-e235017c1baf h1:yc9daCCYUefEs69zUkSzubzjBbL+cmOXgnmt9Fyd9ug= github.com/ProtonMail/bcrypt v0.0.0-20211005172633-e235017c1baf/go.mod h1:o0ESU9p83twszAU8LBeJKFAAMX14tISa0yk4Oo5TOqo= github.com/ProtonMail/gluon v0.17.1-0.20230724134000-308be39be96e h1:lCsqUUACrcMC83lg5rTo9Y0PnPItE61JSfvMyIcANwk= github.com/ProtonMail/gluon v0.17.1-0.20230724134000-308be39be96e/go.mod h1:Og5/Dz1MiGpCJn51XujZwxiLG7WzvvjE5PRpZBQmAHo= github.com/ProtonMail/go-crypto v0.0.0-20230321155629-9a39f2531310/go.mod h1:8TI4H3IbrackdNgv+92dI+rhpCaLqM0IfpgCgenFvRE= github.com/ProtonMail/go-crypto v1.3.0 h1:ILq8+Sf5If5DCpHQp4PbZdS1J7HDFRXz/+xKBiRGFrw= github.com/ProtonMail/go-crypto v1.3.0/go.mod h1:9whxjD8Rbs29b4XWbB8irEcE8KHMqaR2e7GWU1R+/PE= github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f h1:tCbYj7/299ekTTXpdwKYF8eBlsYsDVoggDAuAjoK66k= github.com/ProtonMail/go-mime v0.0.0-20230322103455-7d82a3887f2f/go.mod h1:gcr0kNtGBqin9zDW9GOHcVntrwnjrK+qdJ06mWYBybw= github.com/ProtonMail/go-srp v0.0.7 h1:Sos3Qk+th4tQR64vsxGIxYpN3rdnG9Wf9K4ZloC1JrI= github.com/ProtonMail/go-srp v0.0.7/go.mod h1:giCp+7qRnMIcCvI6V6U3S1lDDXDQYx2ewJ6F/9wdlJk= github.com/ProtonMail/gopenpgp/v2 v2.9.0 h1:ruLzBmwe4dR1hdnrsEJ/S7psSBmV15gFttFUPP/+/kE= github.com/ProtonMail/gopenpgp/v2 v2.9.0/go.mod h1:IldDyh9Hv1ZCCYatTuuEt1XZJ0OPjxLpTarDfglih7s= github.com/PuerkitoBio/goquery v1.10.3 h1:pFYcNSqHxBD06Fpj/KsbStFRsgRATgnf3LeXiUkhzPo= github.com/PuerkitoBio/goquery v1.10.3/go.mod h1:tMUX0zDMHXYlAQk6p35XxQMqMweEKB7iK7iLNd4RH4Y= github.com/a8m/tree v0.0.0-20240104212747-2c8764a5f17e h1:KMVieI1/Ub++GYfnhyFPoGE3g5TUiG4srE3TMGr5nM4= github.com/a8m/tree v0.0.0-20240104212747-2c8764a5f17e/go.mod h1:j5astEcUkZQX8lK+KKlQ3NRQ50f4EE8ZjyZpCz3mrH4= github.com/aalpar/deheap v0.0.0-20210914013432-0cc84d79dec3 h1:hhdWprfSpFbN7lz3W1gM40vOgvSh1WCSMxYD6gGB4Hs= github.com/aalpar/deheap v0.0.0-20210914013432-0cc84d79dec3/go.mod h1:XaUnRxSCYgL3kkgX0QHIV0D+znljPIDImxlv2kbGv0Y= github.com/abbot/go-http-auth v0.4.0 h1:QjmvZ5gSC7jm3Zg54DqWE/T5m1t2AfDu6QlXJT0EVT0= github.com/abbot/go-http-auth v0.4.0/go.mod h1:Cz6ARTIzApMJDzh5bRMSUou6UMSp0IEXg9km/ci7TJM= github.com/akavel/rsrc v0.10.2 h1:Zxm8V5eI1hW4gGaYsJQUhxpjkENuG91ki8B4zCrvEsw= github.com/akavel/rsrc v0.10.2/go.mod h1:uLoCtb9J+EyAqh+26kdrTgmzRBFPGOolLWKpdxkKq+c= github.com/anacrolix/dms v1.7.2 h1:JAAJJIlXp+jT2yEah1EbR1AFpGALHL238uSKFXec2qw= github.com/anacrolix/dms v1.7.2/go.mod h1:excFJW5MKBhn5yt5ZMyeE9iFVqnO6tEGQl7YG/2tUoQ= github.com/anacrolix/generics v0.0.3 h1:wMkQgQzq0obSy1tMkxDu7Ife7PsegOBWHDRaSW31EnM= github.com/anacrolix/generics v0.0.3/go.mod h1:MN3ve08Z3zSV/rTuX/ouI4lNdlfTxgdafQJiLzyNRB8= github.com/anacrolix/log v0.16.0 h1:DSuyb5kAJwl3Y0X1TRcStVrTS9ST9b0BHW+7neE4Xho= github.com/anacrolix/log v0.16.0/go.mod h1:m0poRtlr41mriZlXBQ9SOVZ8yZBkLjOkDhd5Li5pITA= github.com/andybalholm/cascadia v1.3.3 h1:AG2YHrzJIm4BZ19iwJ/DAua6Btl3IwJX+VI4kktS1LM= github.com/andybalholm/cascadia v1.3.3/go.mod h1:xNd9bqTn98Ln4DwST8/nG+H0yuB8Hmgu1YHNnWw0GeA= github.com/appscode/go-querystring v0.0.0-20170504095604-0126cfb3f1dc h1:LoL75er+LKDHDUfU5tRvFwxH0LjPpZN8OoG8Ll+liGU= github.com/appscode/go-querystring v0.0.0-20170504095604-0126cfb3f1dc/go.mod h1:w648aMHEgFYS6xb0KVMMtZ2uMeemhiKCuD2vj6gY52A= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw= github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4= github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI= github.com/aws/aws-sdk-go-v2 v1.38.0 h1:UCRQ5mlqcFk9HJDIqENSLR3wiG1VTWlyUfLDEvY7RxU= github.com/aws/aws-sdk-go-v2 v1.38.0/go.mod h1:9Q0OoGQoboYIAJyslFyF1f5K1Ryddop8gqMhWx/n4Wg= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.0 h1:6GMWV6CNpA/6fbFHnoAjrv4+LGfyTqZz2LtCHnspgDg= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.0/go.mod h1:/mXlTIVG9jbxkqDnr5UQNQxW1HRYxeGklkM9vAFeabg= github.com/aws/aws-sdk-go-v2/config v1.31.0 h1:9yH0xiY5fUnVNLRWO0AtayqwU1ndriZdN78LlhruJR4= github.com/aws/aws-sdk-go-v2/config v1.31.0/go.mod h1:VeV3K72nXnhbe4EuxxhzsDc/ByrCSlZwUnWH52Nde/I= github.com/aws/aws-sdk-go-v2/credentials v1.18.4 h1:IPd0Algf1b+Qy9BcDp0sCUcIWdCQPSzDoMK3a8pcbUM= github.com/aws/aws-sdk-go-v2/credentials v1.18.4/go.mod h1:nwg78FjH2qvsRM1EVZlX9WuGUJOL5od+0qvm0adEzHk= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.3 h1:GicIdnekoJsjq9wqnvyi2elW6CGMSYKhdozE7/Svh78= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.3/go.mod h1:R7BIi6WNC5mc1kfRM7XM/VHC3uRWkjc396sfabq4iOo= github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.18.4 h1:0SzCLoPRSK3qSydsaFQWugP+lOBCTPwfcBOm6222+UA= github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.18.4/go.mod h1:JAet9FsBHjfdI+TnMBX4ModNNaQHAd3dc/Bk+cNsxeM= github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.3 h1:o9RnO+YZ4X+kt5Z7Nvcishlz0nksIt2PIzDglLMP0vA= github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.3/go.mod h1:+6aLJzOG1fvMOyzIySYjOFjcguGvVRL68R+uoRencN4= github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.3 h1:joyyUFhiTQQmVK6ImzNU9TQSNRNeD9kOklqTzyk5v6s= github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.3/go.mod h1:+vNIyZQP3b3B1tSLI0lxvrU9cfM7gpdRXMFfm67ZcPc= github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 h1:bIqFDwgGXXN1Kpp99pDOdKMTTb5d2KyU5X/BZxjOkRo= github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3/go.mod h1:H5O/EsxDWyU+LP/V8i5sm8cxoZgc2fdNR9bxlOFrQTo= github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.3 h1:ZV2XK2L3HBq9sCKQiQ/MdhZJppH/rH0vddEAamsHUIs= github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.3/go.mod h1:b9F9tk2HdHpbf3xbN7rUZcfmJI26N6NcJu/8OsBFI/0= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.0 h1:6+lZi2JeGKtCraAj1rpoZfKqnQ9SptseRZioejfUOLM= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.0/go.mod h1:eb3gfbVIxIoGgJsi9pGne19dhCBpK6opTYpQqAmdy44= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.8.3 h1:3ZKmesYBaFX33czDl6mbrcHb6jeheg6LqjJhQdefhsY= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.8.3/go.mod h1:7ryVb78GLCnjq7cw45N6oUb9REl7/vNUwjvIqC5UgdY= github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.3 h1:ieRzyHXypu5ByllM7Sp4hC5f/1Fy5wqxqY0yB85hC7s= github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.3/go.mod h1:O5ROz8jHiOAKAwx179v+7sHMhfobFVi6nZt8DEyiYoM= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.3 h1:SE/e52dq9a05RuxzLcjT+S5ZpQobj3ie3UTaSf2NnZc= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.3/go.mod h1:zkpvBTsR020VVr8TOrwK2TrUW9pOir28sH5ECHpnAfo= github.com/aws/aws-sdk-go-v2/service/s3 v1.87.0 h1:egoDf+Geuuntmw79Mz6mk9gGmELCPzg5PFEABOHB+6Y= github.com/aws/aws-sdk-go-v2/service/s3 v1.87.0/go.mod h1:t9MDi29H+HDbkolTSQtbI0HP9DemAWQzUjmWC7LGMnE= github.com/aws/aws-sdk-go-v2/service/sso v1.28.0 h1:Mc/MKBf2m4VynyJkABoVEN+QzkfLqGj0aiJuEe7cMeM= github.com/aws/aws-sdk-go-v2/service/sso v1.28.0/go.mod h1:iS5OmxEcN4QIPXARGhavH7S8kETNL11kym6jhoS7IUQ= github.com/aws/aws-sdk-go-v2/service/ssooidc v1.33.0 h1:6csaS/aJmqZQbKhi1EyEMM7yBW653Wy/B9hnBofW+sw= github.com/aws/aws-sdk-go-v2/service/ssooidc v1.33.0/go.mod h1:59qHWaY5B+Rs7HGTuVGaC32m0rdpQ68N8QCN3khYiqs= github.com/aws/aws-sdk-go-v2/service/sts v1.37.0 h1:MG9VFW43M4A8BYeAfaJJZWrroinxeTi2r3+SnmLQfSA= github.com/aws/aws-sdk-go-v2/service/sts v1.37.0/go.mod h1:JdeBDPgpJfuS6rU/hNglmOigKhyEZtBmbraLE4GK1J8= github.com/aws/smithy-go v1.22.5 h1:P9ATCXPMb2mPjYBgueqJNCA5S9UfktsW0tTxi+a7eqw= github.com/aws/smithy-go v1.22.5/go.mod h1:t1ufH5HMublsJYulve2RKmHDC15xu1f26kHCp/HgceI= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/bradenaw/juniper v0.15.3 h1:RHIAMEDTpvmzV1wg1jMAHGOoI2oJUSPx3lxRldXnFGo= github.com/bradenaw/juniper v0.15.3/go.mod h1:UX4FX57kVSaDp4TPqvSjkAAewmRFAfXf27BOs5z9dq8= github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8 h1:GKTyiRCL6zVf5wWaqKnf+7Qs6GbEPfd4iMOitWzXJx8= github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8/go.mod h1:spo1JLcs67NmW1aVLEgtA8Yy1elc+X8y5SRW1sFW4Og= github.com/buengese/sgzip v0.1.1 h1:ry+T8l1mlmiWEsDrH/YHZnCVWD2S3im1KLsyO+8ZmTU= github.com/buengese/sgzip v0.1.1/go.mod h1:i5ZiXGF3fhV7gL1xaRRL1nDnmpNj0X061FQzOS8VMas= github.com/bwesterb/go-ristretto v1.2.0/go.mod h1:fUIoIZaG73pV5biE2Blr2xEzDoMj7NFEuV9ekS419A0= github.com/bytedance/sonic v1.13.2 h1:8/H1FempDZqC4VqjptGo14QQlJx8VdZJegxs6wwfqpQ= github.com/bytedance/sonic v1.13.2/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4= github.com/bytedance/sonic/loader v0.2.4 h1:ZWCw4stuXUsn1/+zQDqeE7JKP+QO47tz7QCNan80NzY= github.com/bytedance/sonic/loader v0.2.4/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI= github.com/calebcase/tmpfile v1.0.3 h1:BZrOWZ79gJqQ3XbAQlihYZf/YCV0H4KPIdM5K5oMpJo= github.com/calebcase/tmpfile v1.0.3/go.mod h1:UAUc01aHeC+pudPagY/lWvt2qS9ZO5Zzof6/tIUzqeI= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/chilts/sid v0.0.0-20190607042430-660e94789ec9 h1:z0uK8UQqjMVYzvk4tiiu3obv2B44+XBsvgEJREQfnO8= github.com/chilts/sid v0.0.0-20190607042430-660e94789ec9/go.mod h1:Jl2neWsQaDanWORdqZ4emBl50J4/aRBBS4FyyG9/PFo= github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= github.com/cloudflare/circl v1.1.0/go.mod h1:prBCrKB9DV4poKZY1l9zBXg2QJY7mvgRvtMxxK7fi4I= github.com/cloudflare/circl v1.6.1 h1:zqIqSPIndyBh1bjLVVDHMPpVKqp8Su/V+6MeDzzQBQ0= github.com/cloudflare/circl v1.6.1/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs= github.com/cloudinary/cloudinary-go/v2 v2.12.0 h1:uveBJeNpJztKDwFW/B+Wuklq584hQmQXlo+hGTSOGZ8= github.com/cloudinary/cloudinary-go/v2 v2.12.0/go.mod h1:ireC4gqVetsjVhYlwjUJwKTbZuWjEIynbR9zQTlqsvo= github.com/cloudsoda/go-smb2 v0.0.0-20250228001242-d4c70e6251cc h1:t8YjNUCt1DimB4HCIXBztwWMhgxr5yG5/YaRl9Afdfg= github.com/cloudsoda/go-smb2 v0.0.0-20250228001242-d4c70e6251cc/go.mod h1:CgWpFCFWzzEA5hVkhAc6DZZzGd3czx+BblvOzjmg6KA= github.com/cloudsoda/sddl v0.0.0-20250224235906-926454e91efc h1:0xCWmFKBmarCqqqLeM7jFBSw/Or81UEElFqO8MY+GDs= github.com/cloudsoda/sddl v0.0.0-20250224235906-926454e91efc/go.mod h1:uvR42Hb/t52HQd7x5/ZLzZEK8oihrFpgnodIJ1vte2E= github.com/cloudwego/base64x v0.1.5 h1:XPciSp1xaq2VCSt6lF0phncD4koWyULpl5bUxbfCyP4= github.com/cloudwego/base64x v0.1.5/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w= github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= github.com/colinmarc/hdfs/v2 v2.4.0 h1:v6R8oBx/Wu9fHpdPoJJjpGSUxo8NhHIwrwsfhFvU9W0= github.com/colinmarc/hdfs/v2 v2.4.0/go.mod h1:0NAO+/3knbMx6+5pCv+Hcbaz4xn/Zzbn9+WIib2rKVI= github.com/coreos/go-semver v0.3.1 h1:yi21YpKnrx1gt5R+la8n5WgS0kCrsPp33dmEyHReZr4= github.com/coreos/go-semver v0.3.1/go.mod h1:irMmmIw/7yzSRPWryHsK7EYSg09caPQL03VsM8rvUec= github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs= github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= github.com/cpuguy83/go-md2man/v2 v2.0.7 h1:zbFlGlXEAKlwXpmvle3d8Oe3YnkKIK4xSRTd3sHPnBo= github.com/cpuguy83/go-md2man/v2 v2.0.7/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= github.com/creasty/defaults v1.8.0 h1:z27FJxCAa0JKt3utc0sCImAEb+spPucmKoOdLHvHYKk= github.com/creasty/defaults v1.8.0/go.mod h1:iGzKe6pbEHnpMPtfDXZEr0NVxWnPTjb1bbDy08fPzYM= github.com/cronokirby/saferith v0.33.0 h1:TgoQlfsD4LIwx71+ChfRcIpjkw+RPOapDEVxa+LhwLo= github.com/cronokirby/saferith v0.33.0/go.mod h1:QKJhjoqUtBsXCAVEjw38mFqoi7DebT7kthcD7UzbnoA= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dnaeon/go-vcr v1.2.0 h1:zHCHvJYTMh1N7xnV7zf1m1GPBF9Ad0Jk/whtQ1663qI= github.com/dnaeon/go-vcr v1.2.0/go.mod h1:R4UdLID7HZT3taECzJs4YgbbH6PIGXB6W/sc5OLb6RQ= github.com/dop251/scsu v0.0.0-20220106150536-84ac88021d00 h1:xJBhC00smQpSZw3Kr0ErMUBXhUSjYoLRm2szxdbRBL0= github.com/dop251/scsu v0.0.0-20220106150536-84ac88021d00/go.mod h1:nNICngOdmNImBb/vuL+dSc0aIg3ryNATpjxThNoPw4g= github.com/dropbox/dropbox-sdk-go-unofficial/v6 v6.0.5 h1:FT+t0UEDykcor4y3dMVKXIiWJETBpRgERYTGlmMd7HU= github.com/dropbox/dropbox-sdk-go-unofficial/v6 v6.0.5/go.mod h1:rSS3kM9XMzSQ6pw91Qgd6yB5jdt70N4OdtrAf74As5M= github.com/dsnet/try v0.0.3 h1:ptR59SsrcFUYbT/FhAbKTV6iLkeD6O18qfIWRml2fqI= github.com/dsnet/try v0.0.3/go.mod h1:WBM8tRpUmnXXhY1U6/S8dt6UWdHTQ7y8A5YSkRCkq40= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/ebitengine/purego v0.8.4 h1:CF7LEKg5FFOsASUj0+QwaXf8Ht6TlFxg09+S9wz0omw= github.com/ebitengine/purego v0.8.4/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ= github.com/emersion/go-message v0.18.2 h1:rl55SQdjd9oJcIoQNhubD2Acs1E6IzlZISRTK7x/Lpg= github.com/emersion/go-message v0.18.2/go.mod h1:XpJyL70LwRvq2a8rVbHXikPgKj8+aI0kGdHlg16ibYA= github.com/emersion/go-vcard v0.0.0-20241024213814-c9703dde27ff h1:4N8wnS3f1hNHSmFD5zgFkWCyA4L1kCDkImPAtK7D6tg= github.com/emersion/go-vcard v0.0.0-20241024213814-c9703dde27ff/go.mod h1:HMJKR5wlh/ziNp+sHEDV2ltblO4JD2+IdDOWtGcQBTM= github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/flynn/noise v1.1.0 h1:KjPQoQCEFdZDiP03phOvGi11+SVVhBG2wOWAorLsstg= github.com/flynn/noise v1.1.0/go.mod h1:xbMo+0i6+IGbYdJhF31t2eR1BIU0CYc12+BNAKwUTag= github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY= github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= github.com/gabriel-vasile/mimetype v1.4.9 h1:5k+WDwEsD9eTLL8Tz3L0VnmVh9QxGjRmjBvAG7U/oYY= github.com/gabriel-vasile/mimetype v1.4.9/go.mod h1:WnSQhFKJuBlRyLiKohA/2DtIlPFAbguNaG7QCHcyGok= github.com/gdamore/encoding v1.0.1 h1:YzKZckdBL6jVt2Gc+5p82qhrGiqMdG/eNs6Wy0u3Uhw= github.com/gdamore/encoding v1.0.1/go.mod h1:0Z0cMFinngz9kS1QfMjCP8TY7em3bZYeeklsSDPivEo= github.com/gdamore/tcell/v2 v2.8.1 h1:KPNxyqclpWpWQlPLx6Xui1pMk8S+7+R37h3g07997NU= github.com/gdamore/tcell/v2 v2.8.1/go.mod h1:bj8ori1BG3OYMjmb3IklZVWfZUJ1UBQt9JXrOCOhGWw= github.com/geoffgarside/ber v1.2.0 h1:/loowoRcs/MWLYmGX9QtIAbA+V/FrnVLsMMPhwiRm64= github.com/geoffgarside/ber v1.2.0/go.mod h1:jVPKeCbj6MvQZhwLYsGwaGI52oUorHoHKNecGT85ZCc= github.com/gin-contrib/sse v1.0.0 h1:y3bT1mUWUxDpW4JLQg/HnTqV4rozuW4tC9eFKTxYI9E= github.com/gin-contrib/sse v1.0.0/go.mod h1:zNuFdwarAygJBht0NTKiSi3jRf6RbqeILZ9Sp6Slhe0= github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU= github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y= github.com/go-chi/chi/v5 v5.2.2 h1:CMwsvRVTbXVytCk1Wd72Zy1LAsAh9GxMmSNWLHCG618= github.com/go-chi/chi/v5 v5.2.2/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops= github.com/go-darwin/apfs v0.0.0-20211011131704-f84b94dbf348 h1:JnrjqG5iR07/8k7NqrLNilRsl3s1EPRQEGvbPyOce68= github.com/go-darwin/apfs v0.0.0-20211011131704-f84b94dbf348/go.mod h1:Czxo/d1g948LtrALAZdL04TL/HnkopquAjxYUuI02bo= github.com/go-git/go-billy/v5 v5.6.2 h1:6Q86EsPXMa7c3YZ3aLAQsMA0VlWmy43r6FHqa/UNbRM= github.com/go-git/go-billy/v5 v5.6.2/go.mod h1:rcFC2rAsp/erv7CMz9GczHcuD0D32fWzH+MJAU+jaUU= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A= github.com/go-ini/ini v1.67.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= github.com/go-openapi/errors v0.22.2 h1:rdxhzcBUazEcGccKqbY1Y7NS8FDcMyIRr0934jrYnZg= github.com/go-openapi/errors v0.22.2/go.mod h1:+n/5UdIqdVnLIJ6Q9Se8HNGUXYaY6CN8ImWzfi/Gzp0= github.com/go-openapi/strfmt v0.23.0 h1:nlUS6BCqcnAk0pyhi9Y+kdDVZdZMHfEKQiS4HaMgO/c= github.com/go-openapi/strfmt v0.23.0/go.mod h1:NrtIpfKtWIygRkKVsxh7XQMDQW5HKQl6S5ik2elW+K4= github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s= github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA= github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY= github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY= github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY= github.com/go-playground/validator/v10 v10.27.0 h1:w8+XrWVMhGkxOaaowyKH35gFydVHOvC0/uWoy2Fzwn4= github.com/go-playground/validator/v10 v10.27.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo= github.com/go-resty/resty/v2 v2.16.5 h1:hBKqmWrr7uRc3euHVqmh1HTHcKn99Smr7o5spptdhTM= github.com/go-resty/resty/v2 v2.16.5/go.mod h1:hkJtXbA2iKHzJheXYvQ8snQES5ZLGKMwQ07xAwp/fiA= github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI= github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4= github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= github.com/gofrs/flock v0.12.1 h1:MTLVXXHf8ekldpJk3AKicLij9MdwOWkZ+a/jHHZby9E= github.com/gofrs/flock v0.12.1/go.mod h1:9zxTsyu5xtJ9DK+1tFZyibEV7y3uwDxPPfbxeeHCoD0= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang-jwt/jwt/v4 v4.5.2 h1:YtQM7lnr8iZ+j5q71MGKkNw9Mn7AjHM68uc9g5fXeUI= github.com/golang-jwt/jwt/v4 v4.5.2/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo= github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20240509144519-723abb6459b7 h1:velgFPYr1X9TDwLIfkV7fWqsFlf7TeP11M/7kPd/dVI= github.com/google/pprof v0.0.0-20240509144519-723abb6459b7/go.mod h1:kf6iHlnVGwgKolg33glAes7Yg/8iWP8ukqeldJSO7jw= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/s2a-go v0.1.9 h1:LGD7gtMgezd8a/Xak7mEWL0PjoTQFvpRudN895yqKW0= github.com/google/s2a-go v0.1.9/go.mod h1:YA0Ei2ZQL3acow2O62kdp9UlnvMmU7kA6Eutn0dXayM= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/enterprise-certificate-proxy v0.3.6 h1:GW/XbdyBFQ8Qe+YAmFU9uHLo7OnF5tL52HFAgMmyrf4= github.com/googleapis/enterprise-certificate-proxy v0.3.6/go.mod h1:MkHOF77EYAE7qfSuSS9PU6g4Nt4e11cnsDUowfwewLA= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= github.com/googleapis/gax-go/v2 v2.15.0 h1:SyjDc1mGgZU5LncH8gimWo9lW1DtIfPibOG81vgd/bo= github.com/googleapis/gax-go/v2 v2.15.0/go.mod h1:zVVkkxAQHa1RQpg9z2AUCMnKhi0Qld9rcmyfL1OZhoc= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e h1:JKmoR8x90Iww1ks85zJ1lfDGgIiMDuIptTOhJq+zKyg= github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gorilla/schema v1.4.1 h1:jUg5hUjCSDZpNGLuXQOgIWGdlgrIdYvgQ0wZtdK1M3E= github.com/gorilla/schema v1.4.1/go.mod h1:Dg5SSm5PV60mhF2NFaTV1xuYYj8tV8NOPRo4FggUMnM= github.com/gorilla/securecookie v1.1.1 h1:miw7JPhV+b/lAHSXz4qd/nN9jRiAFV5FwjeKyCS8BvQ= github.com/gorilla/securecookie v1.1.1/go.mod h1:ra0sb63/xPlUeL+yeDciTfxMRAA+MP+HVt/4epWDjd4= github.com/gorilla/sessions v1.2.1 h1:DHd3rPN5lE3Ts3D8rKkQ8x/0kqfeNmBAaiSi+o7FsgI= github.com/gorilla/sessions v1.2.1/go.mod h1:dk2InVEVJ0sfLlnXv9EAgkf6ecYs/i80K/zI+bUmuGM= github.com/hanwen/go-fuse/v2 v2.8.0 h1:wV8rG7rmCz8XHSOwBZhG5YcVqcYjkzivjmbaMafPlAs= github.com/hanwen/go-fuse/v2 v2.8.0/go.mod h1:yE6D2PqWwm3CbYRxFXV9xUd8Md5d6NG0WBs5spCswmI= github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I= github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ= github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= github.com/hashicorp/go-hclog v1.6.3 h1:Qr2kF+eVWjTiYmU7Y31tYlP1h0q/X3Nl3tPGdaB11/k= github.com/hashicorp/go-hclog v1.6.3/go.mod h1:W4Qnvbt70Wk/zYJryRzDRU/4r0kIg0PVHBcfoyhpF5M= github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo= github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM= github.com/hashicorp/go-retryablehttp v0.7.8 h1:ylXZWnqa7Lhqpk0L1P1LzDtGcCR0rPVUrx/c8Unxc48= github.com/hashicorp/go-retryablehttp v0.7.8/go.mod h1:rjiScheydd+CxvumBsIrFKlx3iS0jrZ7LvzFGFmuKbw= github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= github.com/hashicorp/go-uuid v1.0.3 h1:2gKiV6YVmrJ1i2CKKa9obLvRieoRGviZFL26PcT/Co8= github.com/hashicorp/go-uuid v1.0.3/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= github.com/henrybear327/Proton-API-Bridge v1.0.0 h1:gjKAaWfKu++77WsZTHg6FUyPC5W0LTKWQciUm8PMZb0= github.com/henrybear327/Proton-API-Bridge v1.0.0/go.mod h1:gunH16hf6U74W2b9CGDaWRadiLICsoJ6KRkSt53zLts= github.com/henrybear327/go-proton-api v1.0.0 h1:zYi/IbjLwFAW7ltCeqXneUGJey0TN//Xo851a/BgLXw= github.com/henrybear327/go-proton-api v1.0.0/go.mod h1:w63MZuzufKcIZ93pwRgiOtxMXYafI8H74D77AxytOBc= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/jcmturner/aescts/v2 v2.0.0 h1:9YKLH6ey7H4eDBXW8khjYslgyqG2xZikXP0EQFKrle8= github.com/jcmturner/aescts/v2 v2.0.0/go.mod h1:AiaICIRyfYg35RUkr8yESTqvSy7csK90qZ5xfvvsoNs= github.com/jcmturner/dnsutils/v2 v2.0.0 h1:lltnkeZGL0wILNvrNiVCR6Ro5PGU/SeBvVO/8c/iPbo= github.com/jcmturner/dnsutils/v2 v2.0.0/go.mod h1:b0TnjGOvI/n42bZa+hmXL+kFJZsFT7G4t3HTlQ184QM= github.com/jcmturner/gofork v1.7.6 h1:QH0l3hzAU1tfT3rZCnW5zXl+orbkNMMRGJfdJjHVETg= github.com/jcmturner/gofork v1.7.6/go.mod h1:1622LH6i/EZqLloHfE7IeZ0uEJwMSUyQ/nDd82IeqRo= github.com/jcmturner/goidentity/v6 v6.0.1 h1:VKnZd2oEIMorCTsFBnJWbExfNN7yZr3EhJAxwOkZg6o= github.com/jcmturner/goidentity/v6 v6.0.1/go.mod h1:X1YW3bgtvwAXju7V3LCIMpY0Gbxyjn/mY9zx4tFonSg= github.com/jcmturner/gokrb5/v8 v8.4.4 h1:x1Sv4HaTpepFkXbt2IkL29DXRf8sOfZXo8eRKh687T8= github.com/jcmturner/gokrb5/v8 v8.4.4/go.mod h1:1btQEpgT6k+unzCwX1KdWMEwPPkkgBtP+F6aCACiMrs= github.com/jcmturner/rpc/v2 v2.0.3 h1:7FXXj8Ti1IaVFpSAziCZWNzbNuZmnvw/i6CqLNdWfZY= github.com/jcmturner/rpc/v2 v2.0.3/go.mod h1:VUJYCIDm3PVOEHw8sgt091/20OJjskO/YJki3ELg/Hc= github.com/jlaffaye/ftp v0.0.0-20190624084859-c1312a7102bf/go.mod h1:lli8NYPQOFy3O++YmYbqVgOcQ1JPCwdOy+5zSjKJ9qY= github.com/jlaffaye/ftp v0.2.1-0.20240918233326-1b970516f5d3 h1:ZxO6Qr2GOXPdcW80Mcn3nemvilMPvpWqxrNfK2ZnNNs= github.com/jlaffaye/ftp v0.2.1-0.20240918233326-1b970516f5d3/go.mod h1:dvLUr/8Fs9a2OBrEnCC5duphbkz/k/mSy5OkXg3PAgI= github.com/josephspurrier/goversioninfo v1.5.0 h1:9TJtORoyf4YMoWSOo/cXFN9A/lB3PniJ91OxIH6e7Zg= github.com/josephspurrier/goversioninfo v1.5.0/go.mod h1:6MoTvFZ6GKJkzcdLnU5T/RGYUbHQbKpYeNP0AgQLd2o= github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM= github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo= github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= github.com/jtolio/noiseconn v0.0.0-20231127013910-f6d9ecbf1de7 h1:JcltaO1HXM5S2KYOYcKgAV7slU0xPy1OcvrVgn98sRQ= github.com/jtolio/noiseconn v0.0.0-20231127013910-f6d9ecbf1de7/go.mod h1:MEkhEPFwP3yudWO0lj6vfYpLIB+3eIcuIW+e0AZzUQk= github.com/jzelinskie/whirlpool v0.0.0-20201016144138-0675e54bb004 h1:G+9t9cEtnC9jFiTxyptEKuNIAbiN5ZCQzX2a74lj3xg= github.com/jzelinskie/whirlpool v0.0.0-20201016144138-0675e54bb004/go.mod h1:KmHnJWQrgEvbuy0vcvj00gtMqbvNn1L+3YUZLK/B92c= github.com/keybase/go-keychain v0.0.1 h1:way+bWYa6lDppZoZcgMbYsvC7GxljxrskdNInRtuthU= github.com/keybase/go-keychain v0.0.1/go.mod h1:PdEILRW3i9D8JcdM+FmY6RwkHGnhHxXwkPPMeUgOK1k= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y= github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/koofr/go-httpclient v0.0.0-20240520111329-e20f8f203988 h1:CjEMN21Xkr9+zwPmZPaJJw+apzVbjGL5uK/6g9Q2jGU= github.com/koofr/go-httpclient v0.0.0-20240520111329-e20f8f203988/go.mod h1:/agobYum3uo/8V6yPVnq+R82pyVGCeuWW5arT4Txn8A= github.com/koofr/go-koofrclient v0.0.0-20221207135200-cbd7fc9ad6a6 h1:FHVoZMOVRA+6/y4yRlbiR3WvsrOcKBd/f64H7YiWR2U= github.com/koofr/go-koofrclient v0.0.0-20221207135200-cbd7fc9ad6a6/go.mod h1:MRAz4Gsxd+OzrZ0owwrUHc0zLESL+1Y5syqK/sJxK2A= github.com/kr/fs v0.1.0 h1:Jskdu9ieNAYnjxsi0LbQp1ulIKZV1LAFgK1tWhpZgl8= github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/lanrat/extsort v1.4.0 h1:jysS/Tjnp7mBwJ6NG8SY+XYFi8HF3LujGbqY9jOWjco= github.com/lanrat/extsort v1.4.0/go.mod h1:hceP6kxKPKebjN1RVrDBXMXXECbaI41Y94tt6MDazc4= github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ= github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI= github.com/lpar/date v1.0.0 h1:bq/zVqFTUmsxvd/CylidY4Udqpr9BOFrParoP6p0x/I= github.com/lpar/date v1.0.0/go.mod h1:KjYe0dDyMQTgpqcUz4LEIeM5VZwhggjVx/V2dtc8NSo= github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY= github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0= github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 h1:PpXWgLPs+Fqr325bN2FD2ISlRRztXibcX6e8f5FR5Dc= github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg= github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE= github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc= github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= github.com/minio/crc64nvme v1.1.1 h1:8dwx/Pz49suywbO+auHCBpCtlW1OfpcLN7wYgVR6wAI= github.com/minio/crc64nvme v1.1.1/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg= github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34= github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM= github.com/minio/minio-go/v6 v6.0.46/go.mod h1:qD0lajrGW49lKZLtXKtCB4X/qkMf0a5tBvN2PaZg7Gg= github.com/minio/minio-go/v7 v7.0.95 h1:ywOUPg+PebTMTzn9VDsoFJy32ZuARN9zhB+K3IYEvYU= github.com/minio/minio-go/v7 v7.0.95/go.mod h1:wOOX3uxS334vImCNRVyIDdXX9OsXDm89ToynKgqUKlo= github.com/minio/sha256-simd v0.1.1/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM= github.com/minio/xxml v0.0.3 h1:ZIpPQpfyG5uZQnqqC0LZuWtPk/WT8G/qkxvO6jb7zMU= github.com/minio/xxml v0.0.3/go.mod h1:wcXErosl6IezQIMEWSK/LYC2VS7LJ1dAkgvuyIN3aH4= github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y= github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/moby/sys/mountinfo v0.7.2 h1:1shs6aH5s4o5H2zQLn796ADW1wMrIwHsyJ2v9KouLrg= github.com/moby/sys/mountinfo v0.7.2/go.mod h1:1YOa8w8Ih7uW0wALDUgT1dTTSBrZ+HiBLGws92L2RU4= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M= github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/ncw/swift/v2 v2.0.4 h1:hHWVFxn5/YaTWAASmn4qyq2p6OyP/Hm3vMLzkjEqR7w= github.com/ncw/swift/v2 v2.0.4/go.mod h1:cbAO76/ZwcFrFlHdXPjaqWZ9R7Hdar7HpjRXBfbjigk= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= github.com/oklog/ulid v1.3.1 h1:EGfNDEx6MqHz8B3uNV6QAib1UR2Lm97sHi3ocA6ESJ4= github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U= github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= github.com/onsi/ginkgo/v2 v2.17.3 h1:oJcvKpIb7/8uLpDDtnQuf18xVnwKp8DTD7DQ6gTd/MU= github.com/onsi/ginkgo/v2 v2.17.3/go.mod h1:nP2DPOQoNsQmsVyv5rDA8JkXQoCs6goXIvr/PRJ1eCc= github.com/onsi/gomega v1.37.0 h1:CdEG8g0S133B4OswTDC/5XPSzE1OeP29QOioj2PID2Y= github.com/onsi/gomega v1.37.0/go.mod h1:8D9+Txp43QWKhM24yyOBEdpkzN8FvJyAwecBgsU4KU0= github.com/oracle/oci-go-sdk/v65 v65.98.0 h1:ZKsy97KezSiYSN1Fml4hcwjpO+wq01rjBkPqIiUejVc= github.com/oracle/oci-go-sdk/v65 v65.98.0/go.mod h1:RGiXfpDDmRRlLtqlStTzeBjjdUNXyqm3KXKyLCm3A/Q= github.com/panjf2000/ants/v2 v2.11.3 h1:AfI0ngBoXJmYOpDh9m516vjqoUu2sLrIVgppI9TZVpg= github.com/panjf2000/ants/v2 v2.11.3/go.mod h1:8u92CYMUc6gyvTIw8Ru7Mt7+/ESnJahz5EVtqfrilek= github.com/patrickmn/go-cache v2.1.0+incompatible h1:HRMgzkcYKYpi3C8ajMPV8OFXaaRUnok+kx1WdO15EQc= github.com/patrickmn/go-cache v2.1.0+incompatible/go.mod h1:3Qf8kWWT7OJRJbdiICTKqZju1ZixQ/KpMGzzAfe6+WQ= github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4= github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY= github.com/pengsrc/go-shared v0.2.1-0.20190131101655-1999055a4a14 h1:XeOYlK9W1uCmhjJSsY78Mcuh7MVkNjTzmHx1yBzizSU= github.com/pengsrc/go-shared v0.2.1-0.20190131101655-1999055a4a14/go.mod h1:jVblp62SafmidSkvWrXyxAme3gaTfEtWwRPGz5cpvHg= github.com/peterh/liner v1.2.2 h1:aJ4AOodmL+JxOZZEL2u9iJf8omNRpqHc/EbrK+3mAXw= github.com/peterh/liner v1.2.2/go.mod h1:xFwJyiKIXJZUKItq5dGHZSTBRAuG/CpeNpWLyiNRNwI= github.com/philhofer/fwd v1.2.0 h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM= github.com/philhofer/fwd v1.2.0/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= github.com/pkg/diff v0.0.0-20200914180035-5b29258ca4f7/go.mod h1:zO8QMzTeZd5cpnIkz/Gn6iK0jDfGicM1nynOkkPIl28= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/sftp v1.13.9 h1:4NGkvGudBL7GteO3m6qnaQ4pC0Kvf0onSVc9gR3EWBw= github.com/pkg/sftp v1.13.9/go.mod h1:OBN7bVXdstkFFN/gdnHPUb5TE8eb8G1Rp9wCItqjkkA= github.com/pkg/xattr v0.4.12 h1:rRTkSyFNTRElv6pkA3zpjHpQ90p/OdHQC1GmGh1aTjM= github.com/pkg/xattr v0.4.12/go.mod h1:di8WF84zAKk8jzR1UBTEWh9AUlIZZ7M/JNt8e9B6ktU= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 h1:o4JXh1EVt9k/+g42oCprj/FisM4qX9L3sZB3upGN2ZU= github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= github.com/prometheus/client_golang v1.23.0 h1:ust4zpdl9r4trLY/gSjlm07PuiBq2ynaXXlptpfy8Uc= github.com/prometheus/client_golang v1.23.0/go.mod h1:i/o0R9ByOnHX0McrTMTyhYvKE4haaf2mW08I+jGAjEE= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= github.com/prometheus/common v0.65.0 h1:QDwzd+G1twt//Kwj/Ww6E9FQq1iVMmODnILtW1t2VzE= github.com/prometheus/common v0.65.0/go.mod h1:0gZns+BLRQ3V6NdaerOhMbwwRbNh9hkGINtQAsP5GS8= github.com/prometheus/procfs v0.17.0 h1:FuLQ+05u4ZI+SS/w9+BWEM2TXiHKsUQ9TADiRH7DuK0= github.com/prometheus/procfs v0.17.0/go.mod h1:oPQLaDAMRbA+u8H5Pbfq+dl3VDAvHxMUOVhe0wYB2zw= github.com/putdotio/go-putio/putio v0.0.0-20200123120452-16d982cac2b8 h1:Y258uzXU/potCYnQd1r6wlAnoMB68BiCkCcCnKx1SH8= github.com/putdotio/go-putio/putio v0.0.0-20200123120452-16d982cac2b8/go.mod h1:bSJjRokAHHOhA+XFxplld8w2R/dXLH7Z3BZ532vhFwU= github.com/quasilyte/go-ruleguard/dsl v0.3.22 h1:wd8zkOhSNr+I+8Qeciml08ivDt1pSXe60+5DqOpCjPE= github.com/quasilyte/go-ruleguard/dsl v0.3.22/go.mod h1:KeCP03KrjuSO0H1kTuZQCWlQPulDV6YMIXmpQss17rU= github.com/quic-go/quic-go v0.53.0 h1:QHX46sISpG2S03dPeZBgVIZp8dGagIaiu2FiVYvpCZI= github.com/quic-go/quic-go v0.53.0/go.mod h1:e68ZEaCdyviluZmy44P6Iey98v/Wfz6HCjQEm+l8zTY= github.com/rasky/go-xdr v0.0.0-20170124162913-1a41d1a06c93 h1:UVArwN/wkKjMVhh2EQGC0tEc1+FqiLlvYXY5mQ2f8Wg= github.com/rasky/go-xdr v0.0.0-20170124162913-1a41d1a06c93/go.mod h1:Nfe4efndBz4TibWycNE+lqyJZiMX4ycx+QKV8Ta0f/o= github.com/rclone/gofakes3 v0.0.4 h1:LswpC49VY/UJ1zucoL5ktnOEX6lq3qK7e1aFIAfqCbk= github.com/rclone/gofakes3 v0.0.4/go.mod h1:j/UoS+2/Mr7xAlfKhyVC58YyFQmh9uoQA5YZQXQUqmg= github.com/relvacode/iso8601 v1.6.0 h1:eFXUhMJN3Gz8Rcq82f9DTMW0svjtAVuIEULglM7QHTU= github.com/relvacode/iso8601 v1.6.0/go.mod h1:FlNp+jz+TXpyRqgmM7tnzHHzBnz776kmAH2h3sZCn0I= github.com/rfjakob/eme v1.1.2 h1:SxziR8msSOElPayZNFfQw4Tjx/Sbaeeh3eRvrHVMUs4= github.com/rfjakob/eme v1.1.2/go.mod h1:cVvpasglm/G3ngEfcfT/Wt0GwhkuO32pf/poW6Nyk1k= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= github.com/rivo/uniseg v0.4.3/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/ryszard/goskiplist v0.0.0-20150312221310-2dfbae5fcf46 h1:GHRpF1pTW19a8tTFrMLUcfWwyC0pnifVo2ClaLq+hP8= github.com/ryszard/goskiplist v0.0.0-20150312221310-2dfbae5fcf46/go.mod h1:uAQ5PCi+MFsC7HjREoAz1BU+Mq60+05gifQSsHSDG/8= github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06 h1:OkMGxebDjyw0ULyrTYWeN0UNCCkmCWfjPnIA2W6oviI= github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06/go.mod h1:+ePHsJ1keEjQtpvf9HHw0f4ZeJ0TLRsxhunSI2hYJSs= github.com/samber/lo v1.51.0 h1:kysRYLbHy/MB7kQZf5DSN50JHmMsNEdeY24VzJFu7wI= github.com/samber/lo v1.51.0/go.mod h1:4+MXEGsJzbKGaUEQFKBq2xtfuznW9oz/WrgyzMzRoM0= github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= github.com/shabbyrobe/gocovmerge v0.0.0-20230507112040-c3350d9342df h1:S77Pf5fIGMa7oSwp8SQPp7Hb4ZiI38K3RNBKD2LLeEM= github.com/shabbyrobe/gocovmerge v0.0.0-20230507112040-c3350d9342df/go.mod h1:dcuzJZ83w/SqN9k4eQqwKYMgmKWzg/KzJAURBhRL1tc= github.com/shirou/gopsutil/v4 v4.25.7 h1:bNb2JuqKuAu3tRlPv5piSmBZyMfecwQ+t/ILq+1JqVM= github.com/shirou/gopsutil/v4 v4.25.7/go.mod h1:XV/egmwJtd3ZQjBpJVY5kndsiOO4IRqy9TQnmm6VP7U= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/skratchdot/open-golang v0.0.0-20200116055534-eef842397966 h1:JIAuq3EEf9cgbU6AtGPK4CTG3Zf6CKMNqf0MHTggAUA= github.com/skratchdot/open-golang v0.0.0-20200116055534-eef842397966/go.mod h1:sUM3LWHvSMaG192sy56D9F7CNvL7jUJVXoqM1QKLnog= github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM= github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= github.com/smartystreets/goconvey v0.0.0-20190330032615-68dc04aab96a h1:pa8hGb/2YqsZKovtsgrwcDH1RZhVbTKCjLp47XpqCDs= github.com/smartystreets/goconvey v0.0.0-20190330032615-68dc04aab96a/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= github.com/snabb/httpreaderat v1.0.1 h1:whlb+vuZmyjqVop8x1EKOg05l2NE4z9lsMMXjmSUCnY= github.com/snabb/httpreaderat v1.0.1/go.mod h1:lpbGrKDWF37yvRbtRvQsbesS6Ty5c83t8ztannPoMsA= github.com/sony/gobreaker v0.5.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= github.com/sony/gobreaker v1.0.0 h1:feX5fGGXSl3dYd4aHZItw+FpHLvvoaqkawKjVNiFMNQ= github.com/sony/gobreaker v1.0.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY= github.com/spacemonkeygo/monkit/v3 v3.0.24 h1:cKixJ+evHnfJhWNyIZjBy5hoW8LTWmrJXPo18tzLNrk= github.com/spacemonkeygo/monkit/v3 v3.0.24/go.mod h1:XkZYGzknZwkD0AKUnZaSXhRiVTLCkq7CWVa3IsE72gA= github.com/spf13/cobra v1.9.1 h1:CXSaggrXdbHK9CF+8ywj8Amf7PBRmPCOJugH954Nnlo= github.com/spf13/cobra v1.9.1/go.mod h1:nDyEzZ8ogv936Cinf6g1RU9MRY64Ir93oCnqb9wxYW0= github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/pflag v1.0.7 h1:vN6T9TfwStFPFM5XzjsvmzZkLuaLX+HS+0SeFLRgU6M= github.com/spf13/pflag v1.0.7/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.3.1-0.20190311161405-34c6fa2dc709/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/t3rm1n4l/go-mega v0.0.0-20241213151442-a19cff0ec7b5 h1:Sa+sR8aaAMFwxhXWENEnE6ZpqhZ9d7u1RT2722Rw6hc= github.com/t3rm1n4l/go-mega v0.0.0-20241213151442-a19cff0ec7b5/go.mod h1:UdZiFUFu6e2WjjtjxivwXWcwc1N/8zgbkBR9QNucUOY= github.com/tailscale/depaware v0.0.0-20210622194025-720c4b409502/go.mod h1:p9lPsd+cx33L3H9nNoecRRxPssFKUwwI50I3pZ0yT+8= github.com/tinylib/msgp v1.3.0 h1:ULuf7GPooDaIlbyvgAxBV/FI7ynli6LZ1/nVUNu+0ww= github.com/tinylib/msgp v1.3.0/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0= github.com/tklauser/go-sysconf v0.3.15 h1:VE89k0criAymJ/Os65CSn1IXaol+1wrsFHEB8Ol49K4= github.com/tklauser/go-sysconf v0.3.15/go.mod h1:Dmjwr6tYFIseJw7a3dRLJfsHAMXZ3nEnL/aZY+0IuI4= github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfjso= github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ= github.com/tv42/httpunix v0.0.0-20191220191345-2ba4b9c3382c h1:u6SKchux2yDvFQnDHS3lPnIRmfVJ5Sxy3ao2SIdysLQ= github.com/tv42/httpunix v0.0.0-20191220191345-2ba4b9c3382c/go.mod h1:hzIxponao9Kjc7aWznkXaL4U4TWaDSs8zcsY4Ka08nM= github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI= github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE= github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= github.com/unknwon/goconfig v1.0.0 h1:rS7O+CmUdli1T+oDm7fYj1MwqNWtEJfNj+FqcUHML8U= github.com/unknwon/goconfig v1.0.0/go.mod h1:qu2ZQ/wcC/if2u32263HTVC39PeOQRSmidQk3DuDFQ8= github.com/willscott/go-nfs v0.0.3 h1:Z5fHVxMsppgEucdkKBN26Vou19MtEM875NmRwj156RE= github.com/willscott/go-nfs v0.0.3/go.mod h1:VhNccO67Oug787VNXcyx9JDI3ZoSpqoKMT/lWMhUIDg= github.com/willscott/go-nfs-client v0.0.0-20240104095149-b44639837b00 h1:U0DnHRZFzoIV1oFEZczg5XyPut9yxk9jjtax/9Bxr/o= github.com/willscott/go-nfs-client v0.0.0-20240104095149-b44639837b00/go.mod h1:Tq++Lr/FgiS3X48q5FETemXiSLGuYMQT2sPjYNPJSwA= github.com/winfsp/cgofuse v1.6.0 h1:re3W+HTd0hj4fISPBqfsrwyvPFpzqhDu8doJ9nOPDB0= github.com/winfsp/cgofuse v1.6.0/go.mod h1:uxjoF2jEYT3+x+vC2KJddEGdk/LU8pRowXmyVMHSV5I= github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM= github.com/xanzy/ssh-agent v0.3.3/go.mod h1:6dzNDKs0J9rVPHPhaGCukekBHKqfl+L3KghI1Bc68Uw= github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78 h1:ilQV1hzziu+LLM3zUTJ0trRztfwgjqKnBWNtSRkbmwM= github.com/youmark/pkcs8 v0.0.0-20240726163527-a2c0da244d78/go.mod h1:aL8wCCfTfSfmXjznFBSZNN13rSJjlIOI1fUNAtF7rmI= github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= github.com/yunify/qingstor-sdk-go/v3 v3.2.0 h1:9sB2WZMgjwSUNZhrgvaNGazVltoFUUfuS9f0uCWtTr8= github.com/yunify/qingstor-sdk-go/v3 v3.2.0/go.mod h1:KciFNuMu6F4WLk9nGwwK69sCGKLCdd9f97ac/wfumS4= github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= github.com/zeebo/assert v1.3.1 h1:vukIABvugfNMZMQO1ABsyQDJDTVQbn+LWSMy1ol1h6A= github.com/zeebo/assert v1.3.1/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0= github.com/zeebo/blake3 v0.2.4 h1:KYQPkhpRtcqh0ssGYcKLG1JYvddkEA8QwCM/yBqhaZI= github.com/zeebo/blake3 v0.2.4/go.mod h1:7eeQ6d2iXWRGF6npfaxl2CU+xy2Fjo2gxeyZGCRUjcE= github.com/zeebo/errs v1.4.0 h1:XNdoD/RRMKP7HD0UhJnIzUy74ISdGGxURlYG8HSWSfM= github.com/zeebo/errs v1.4.0/go.mod h1:sgbWHsvVuTPHcqJJGQ1WhI5KbWlHYz+2+2C/LSEtCw4= github.com/zeebo/pcg v1.0.1 h1:lyqfGeWiv4ahac6ttHs+I5hwtH/+1mrhlCtVNQM2kHo= github.com/zeebo/pcg v1.0.1/go.mod h1:09F0S9iiKrwn9rlI5yjLkmrug154/YRW6KnnXVDM/l4= github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0= github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA= go.etcd.io/bbolt v1.4.2 h1:IrUHp260R8c+zYx/Tm8QZr04CX+qWS5PGfPdevhdm1I= go.etcd.io/bbolt v1.4.2/go.mod h1:Is8rSHO/b4f3XigBC0lL0+4FwAQv3HXEEIgFMuKHceM= go.mongodb.org/mongo-driver v1.17.4 h1:jUorfmVzljjr0FLzYQsGP8cgN/qzzxlY9Vh0C9KFXVw= go.mongodb.org/mongo-driver v1.17.4/go.mod h1:Hy04i7O2kC4RS06ZrhPRqj/u4DTYkFDAAccj+rVKqgQ= go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.62.0 h1:Hf9xI/XLML9ElpiHVDNwvqI0hIFlzV8dgIr35kV1kRU= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.62.0/go.mod h1:NfchwuyNoMcZ5MLHwPrODwUF1HWCXWrL31s8gSAdIKY= go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ= go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I= go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE= go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E= go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI= go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg= go.opentelemetry.io/otel/sdk/metric v1.37.0 h1:90lI228XrB9jCMuSdA0673aubgRobVZFhbjxHHspCPc= go.opentelemetry.io/otel/sdk/metric v1.37.0/go.mod h1:cNen4ZWfiD37l5NhS+Keb5RXVWZWpRE+9WyVCpbo5ps= go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4= go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU= go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI= go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU= goftp.io/server/v2 v2.0.1 h1:H+9UbCX2N206ePDSVNCjBftOKOgil6kQ5RAQNx5hJwE= goftp.io/server/v2 v2.0.1/go.mod h1:7+H/EIq7tXdfo1Muu5p+l3oQ6rYkDZ8lY7IM5d5kVdQ= golang.org/x/arch v0.14.0 h1:z9JUEZWr8x4rR0OU6c4/4t6E6jOZ8/QBS2bBYBm4tx4= golang.org/x/arch v0.14.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190513172903-22d7a77e9e5f/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58= golang.org/x/crypto v0.7.0/go.mod h1:pYwdfH91IfpZVANVyUOhSIPZaFoJGxTFbZhFTx+dXZU= golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc= golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M= golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8= golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M= golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4= golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= golang.org/x/exp v0.0.0-20250811191247-51f88131bc50 h1:3yiSh9fhy5/RhCSntf4Sy0Tnx50DmMpQ4MQdKKk4yg4= golang.org/x/exp v0.0.0-20250811191247-51f88131bc50/go.mod h1:rT6SFzZ7oxADUDx58pcaKFTcZ+inxAa9fTrYx/uVYwg= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= golang.org/x/mobile v0.0.0-20250808145247-395d808d53cd h1:Qd7qm8Xr8riwtdI4F+SWrlnKK/7tLDyTQ5YNv42tvtU= golang.org/x/mobile v0.0.0-20250808145247-395d808d53cd/go.mod h1:Rg5Br31eIKqfc+43CRdWRfPfFqV9DjN92usHvW9563E= golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ= golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc= golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk= golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM= golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4= golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE= golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI= golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw= golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201204225414-ed752295db88/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211117180635-dee7805ff2e1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220408201424-a24fb2fb8a0f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.19.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U= golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU= golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk= golang.org/x/term v0.19.0/go.mod h1:2CuTdWZ7KHSQwUzKva0cbMg6q2DMI3Mmxp+gKJbskEk= golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY= golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM= golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek= golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s= golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4= golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY= golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng= golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE= golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20190829051458-42f498d34c4d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20201211185031-d93e913c1a58/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58= golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk= golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg= golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= google.golang.org/api v0.247.0 h1:tSd/e0QrUlLsrwMKmkbQhYVa109qIintOls2Wh6bngc= google.golang.org/api v0.247.0/go.mod h1:r1qZOPmxXffXg6xS5uhx16Fa/UFY8QU/K4bfKrnvovM= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20250603155806-513f23925822 h1:rHWScKit0gvAPuOnu87KpaYtjK5zBMLcULh7gxkCXu4= google.golang.org/genproto v0.0.0-20250603155806-513f23925822/go.mod h1:HubltRL7rMh0LfnQPkMH4NPDFEWp0jw3vixw7jEM53s= google.golang.org/genproto/googleapis/api v0.0.0-20250603155806-513f23925822 h1:oWVWY3NzT7KJppx2UKhKmzPq4SRe0LdCijVRwvGeikY= google.golang.org/genproto/googleapis/api v0.0.0-20250603155806-513f23925822/go.mod h1:h3c4v36UTKzUiuaOKQ6gr3S+0hovBtUrXzTG/i3+XEc= google.golang.org/genproto/googleapis/rpc v0.0.0-20250811230008-5f3141c8851a h1:tPE/Kp+x9dMSwUm/uM0JKK0IfdiJkwAbSMSeZBXXJXc= google.golang.org/genproto/googleapis/rpc v0.0.0-20250811230008-5f3141c8851a/go.mod h1:gw1tLEfykwDz2ET4a12jcXt4couGAm7IwsVaTy0Sflo= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/grpc v1.74.2 h1:WoosgB65DlWVC9FqI82dGsZhWFNBSLjQ84bjROOpMu4= google.golang.org/grpc v1.74.2/go.mod h1:CtQ+BGjaAIXHs/5YS3i473GqwBBa1zGQNevxdeBEXrM= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= google.golang.org/protobuf v1.36.7 h1:IgrO7UwFQGJdRNXH/sQux4R1Dj1WAKcLElzeeRaXV2A= google.golang.org/protobuf v1.36.7/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= gopkg.in/ini.v1 v1.42.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= gopkg.in/validator.v2 v2.0.1 h1:xF0KWyGWXm/LM2G1TrEjqOu4pa6coO9AlWSf3msVfDY= gopkg.in/validator.v2 v2.0.1/go.mod h1:lIUZBlB3Im4s/eYp39Ry/wkR02yOPhZ9IwIRBjuPuG8= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= moul.io/http2curl/v2 v2.3.0 h1:9r3JfDzWPcbIklMOs2TnIFzDYvfAZvjeavG6EzP7jYs= moul.io/http2curl/v2 v2.3.0/go.mod h1:RW4hyBjTWSYDOxapodpNEtX0g5Eb16sxklBqmd2RHcE= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= sigs.k8s.io/yaml v1.6.0 h1:G8fkbMSAFqgEFgh4b1wmtzDnioxFCUgTZhlbj5P9QYs= sigs.k8s.io/yaml v1.6.0/go.mod h1:796bPqUfzR/0jLAl6XjHl3Ck7MiyVv8dbTdyT3/pMf4= storj.io/common v0.0.0-20250808122759-804533d519c1 h1:z7ZjU+TlPZ2Lq2S12hT6+Fr7jFsBxPMrPBH4zZpZuUA= storj.io/common v0.0.0-20250808122759-804533d519c1/go.mod h1:YNr7/ty6CmtpG5C9lEPtPXK3hOymZpueCb9QCNuPMUY= storj.io/drpc v0.0.35-0.20250513201419-f7819ea69b55 h1:8OE12DvUnB9lfZcHe7IDGsuhjrY9GBAr964PVHmhsro= storj.io/drpc v0.0.35-0.20250513201419-f7819ea69b55/go.mod h1:Y9LZaa8esL1PW2IDMqJE7CFSNq7d5bQ3RI7mGPtmKMg= storj.io/eventkit v0.0.0-20250410172343-61f26d3de156 h1:5MZ0CyMbG6Pi0rRzUWVG6dvpXjbBYEX2oyXuj+tT+sk= storj.io/eventkit v0.0.0-20250410172343-61f26d3de156/go.mod h1:CpnM6kfZV58dcq3lpbo/IQ4/KoutarnTSHY0GYVwnYw= storj.io/infectious v0.0.2 h1:rGIdDC/6gNYAStsxsZU79D/MqFjNyJc1tsyyj9sTl7Q= storj.io/infectious v0.0.2/go.mod h1:QEjKKww28Sjl1x8iDsjBpOM4r1Yp8RsowNcItsZJ1Vs= storj.io/picobuf v0.0.4 h1:qswHDla+YZ2TovGtMnU4astjvrADSIz84FXRn0qgP6o= storj.io/picobuf v0.0.4/go.mod h1:hSMxmZc58MS/2qSLy1I0idovlO7+6K47wIGUyRZa6mg= storj.io/uplink v1.13.1 h1:C8RdW/upALoCyuF16Lod9XGCXEdbJAS+ABQy9JO/0pA= storj.io/uplink v1.13.1/go.mod h1:x0MQr4UfFsQBwgVWZAtEsLpuwAn6dg7G0Mpne1r516E= rclone-v1.71.0/graphics/000077500000000000000000000000001505210326400150465ustar00rootroot00000000000000rclone-v1.71.0/graphics/cover.jpg000066400000000000000000460604321505210326400167050ustar00rootroot00000000000000rExifMM*" (26JZb"'j~   51500,00*CanonCanon EOS 7D2014:03:16 17:26:02Nick Craig-Wood33 2013:07:26 08:57:212013:07:26 08:57:21`<  &4<(1DZiCanonCanon EOS 7DAfterShot Pro 1.2.0.7Nick Craig-Woodhttp://ns.adobe.com/xap/1.0/ Nick Craig-Wood XICC_PROFILE HlcmsmntrRGB XYZ  1acspAPPLIEC sRGB-lcmscprtP3desclwtptbkptrXYZgXYZ,bXYZ@dmndTpdmddvuedLview$lumimeas $tech0 rTRC< gTRC< bTRC< textCopyright (c) 1998 Hewlett-Packard CompanydescsRGB IEC61966-2.1sRGB IEC61966-2.1XYZ QXYZ XYZ o8XYZ bXYZ $descIEC http://www.iec.chIEC http://www.iec.chdesc.IEC 61966-2.1 Default RGB colour space - sRGB.IEC 61966-2.1 Default RGB colour space - sRGBdesc,Reference Viewing Condition in IEC61966-2.1,Reference Viewing Condition in IEC61966-2.1view_. \XYZ L VPWmeassig CRT curv #(-27;@EJOTY^chmrw| %+28>ELRY`gnu| &/8AKT]gqz !-8COZfr~ -;HUcq~ +:IXgw'7HYj{+=Oat 2FZn  % : O d y  ' = T j " 9 Q i  * C \ u & @ Z t .Id %A^z &Ca~1Om&Ed#Cc'Ij4Vx&IlAe@e Ek*Qw;c*R{Gp@j>i  A l !!H!u!!!"'"U"""# #8#f###$$M$|$$% %8%h%%%&'&W&&&''I'z''( (?(q(())8)k))**5*h**++6+i++,,9,n,,- -A-v--..L.../$/Z///050l0011J1112*2c223 3F3334+4e4455M555676r667$7`7788P8899B999:6:t::;-;k;;<' >`>>?!?a??@#@d@@A)AjAAB0BrBBC:C}CDDGDDEEUEEF"FgFFG5G{GHHKHHIIcIIJ7J}JK KSKKL*LrLMMJMMN%NnNOOIOOP'PqPQQPQQR1R|RSS_SSTBTTU(UuUVV\VVWDWWX/X}XYYiYZZVZZ[E[[\5\\]']x]^^l^__a_``W``aOaabIbbcCccd@dde=eef=ffg=ggh?hhiCiijHjjkOkklWlmm`mnnknooxop+ppq:qqrKrss]sttptu(uuv>vvwVwxxnxy*yyzFz{{c{|!||}A}~~b~#G k͂0WGrׇ;iΉ3dʋ0cʍ1fΏ6n֑?zM _ɖ4 uL$h՛BdҞ@iءG&vVǥ8nRĩ7u\ЭD-u`ֲK³8%yhYѹJº;.! zpg_XQKFAǿ=ȼ:ɹ8ʷ6˶5̵5͵6ζ7ϸ9к<Ѿ?DINU\dlvۀ܊ݖޢ)߯6DScs 2F[p(@Xr4Pm8Ww)KmXPhotoshop 3.08BIM<Z%G720130726<085721tNick Craig-WoodC     C   @ }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?.>;H7;gXp10z$:ԜYYuN5,c> T|vg?4އY{B2,)o=}cN&k;HBrÁϽsK;HQap:x:~ƥçeE.g/VjȥJ)X2 nyr 2㯭ok;nvI5N*q'/|֪@&tfȏۭ+"өZzHl}_|d.1aJ[tn֧S]/ "6dR(Q'Gr~>Pd~d<#ɷ;sL:nQq[gv?qmd.q=^8W*Ѭd('kKC1e]=q÷z4}*Ԝco ^'b 1H zWN-E잭y;)y_V!.Lb֜ҟфj{꺊֯klDb*.î{g5 4r[jMzjSF]HJ1AڴjS6c(T\2i#Rn ] B3w֥G*]&e6V<.GZS̹?Xzp}̸236,@ǧ'{Km7>-IH"dtUrcy~եTci_^Vx̱ו!cVۧ.ft(P5ma;Ht1f l{;~u*捿uJN̕fpQi<9>!'#T:k=H-rUmʰvHz$wG,yjVs"J46զe^8RFxֹd*TwrqkKWb9d|},fc^=*Jadr˷ ēse8Qœ9v 4l&jN4}ƢK[_\{3w!Ԃ2mt[3;+ Wv8O-HlSYtaZ (Ld.'Ƥ(~]DP%YF$H: {czgdFfEgw+}idVB'=z+S.[qV hO&*sW7i&ԕ^[w9c\Hbw9^;ڹeOJoFJ49$MFX='o@>[hښR]RI"42HѩHP5i;X:pV1* g8 =79(I%gk)9n]7l>ޣI9$1bcv_4!yq*Oex Bo.&Mۀ<1[[%JjY][ѧhW} Mbc̻\'-}bĜg8ﻦG"6>ݜU#O{\8xrUbϧCSXQ{u.8RRi&rg>c3ck:tv"5#*j_OrqgR,ku.i.d ,#ɻ'=9B*.szS匕[i7#4:`޹PV3\Q 0+>$*vNȬ+I2O}kOvrK׹TLI&n$HPd mONqYӭN\"4sޚ]B* zԚ)%N/O v4O3R&K4b=z(Uw1,tDdʺZI%g=9<ҝM{r_M.My  q0ZOrZ,qI0Q8;I~\εwoog5 4Fde?*JpRi:g}۾L!_ʏAk 4cne#Vy켾ce(c2%@}}9SWTmaR4-MkwNUiٕ1YIƵE -/?qIKFbeY PG9(iZmg4b}n2[)+FǙdx'bG=uk̑D`އ;ʳ樬K%ZX5mH"#4]NOp1#SEKM-,{23эw|YFG'8эV|EmE٤LnTz^[Fq*TWoa4-`yJS'd)rՄ=J^Z_.5}ڮThɥ~[ug*V>D q'Lhdq>nWrJֿ8hMk~݂hnacFSIe䁞zzѩNTRO$kU)Mv~ f-]t .I;sXWaV-:k~UTdkMv w*eWܷDvΆTy+?Ȏ]4FDҺyq09;va-!-F>g#Q p;oB;{UTjnhj{wqi2?k ŗFx9:Yʝw8ќoNI2wacz )PrZ֣j)Z"ZlV4\h5{:kt@%F~VU.͍B:as}0qF)qt*jJWͮMI'8/k.,m<)SV%Hf Q6TydR1S㧯2Co*W++bkʧ2[{)t 9*R:ަv@"7Gz47ZvBNN y< NR)4:MP ,Eʙ΀\v5=nԮI-Ko$Co0@x됹=X{-\ڜ]W^p"F}*[mňe潗Gyy6#'8?OΈһ:)J<[> a#mϙ:1ǽgkTcR:)Z]o CQe0;OiI]N5S(J֜|jG]3\4d"p2#Ӝcu)ם;ϧݹkQT2z߿5DX-҃nmh21}j9ElU|=iTͿè1& "G&pgRGVJ:}*4i;G&`#0;c7w#5o$zowq;Mnر'#<3ǭ(M=:cZ՗եв<IJ3u=~;hu)ٿl:dT$8B1lc[ԩy][:s]obmqXU~S{~cxQr"3VӢD+4 ${C*va-FX`O${ zvyvei fZT\0&(.OF+Xig12q~BF)RRoE$2`_d~tJ&t{K=/hTm"e ¦1SD.ӀY^Zۿ9yV^rL.6/2H㠨qWryIPsM=mc:biX*z᫚ǚJqycUr~gLf.֏qE>u*wA K Yͷ֪߰QhG&߹-.v>9-u*;IGF!o6̊\ּNNgI-ʪq?l˨&m4ɺOmթk9rh*̞R eGoÊqt6eVR'42c([A;FT3qNRT\l+<~vDl 8]g/fl~F0Yo+۸/ qReU坾⶷9eH(,=RQѥEhޤC1m`:Y{O.⥫q.$;zAֶѧ ?ꛆP9ڜcje9C?)ݴ/J٣yS#2ej$Ɲk|ܯq,Q33(^Y]+@_[.OڱTyTz1?4.Y>~3ңާ i0-w0zVRT.m}YS0gUTvj1>zW++bfT !KrX6r[sqsZ2 8ʠ`隙KvfkRXĜNe-'e'۠1p2_x}kB2ޝJ2dVY#d;}[] M.LR 8=k-!Յ?7 v"!OօFVNmbBn&+£t'$jVfZ< # +~aU=Oz[^`FюQ}r[Z5݈F |Nհ˞ΣFn-{0?ϯl;htq-qi?圚5#R|`@/ܹd{:F<ښTJXibHGrܨ9}\ɩrrG}++L1\zQRqX{ٓCp,P $r{sU#糴"y|kwȓ1lu)8F7mbx+89sYʧ,aIZ;a׶Ҍimngm~cw(MN/Yl8(Q嗼iMC)yYO8+D)lk)GJY.+9E~s.YFwÒf7vq[^;4jK6mνzS.intFrI!ŕKe qkUJqԗR9XG.W,$ZBPަҍ)YCyZ|2ZڐOd`g8lB%e$.b$ *aג[=U%1d屜?κF]ѡèǿ8|V&9fvwc^ 3M{DlFB'6LmA%>jبӧF %i ?*q%Fs3sF*6zjGo0KU#_/ }wUSHRvAkjeb699^߅O2&0kJkR MO!9 % ֜YObJ&ǐ/w:Vr5) !/mE*q'?}gnqy.~8 V=ZROVs=_QepeQf={Feq>Rn >ea zZ1r/wgs_Ş?a-nT}Hܯr(Ȏ?gbձ~>T6$fY7lm1ݸcֹ*rRUt723n?3UtcJ+ߩW[Bwd͎gx\ϡ'/]_)?s/#Hъۆr:N KTԔe!f ے}YF..f2NkEr\y%Upd>@ ]'8EO 6kfl{y]p=)+J1Ft%H&?qcMI+ژqw$f$V1i=*8Roο6?qCZүk\)cl/8qma- $$Ѿ$ gvssV|%+$TU?7@;~5j\Jqd}0WffOCS-GI:K¼{ǒv?0a?tnrzlBħtª>v?=T(IXqq\uMnM";a*F_<QXOlgG4{1y=Y"5AƑJGx'Nx{Mlk3K1F:~)Kdsь[-?4;䲰֢U~e$*>>QSW) 2(͑+D~zcѣ'9+IJ",92bŤOh+K\;E@ܳ0j(W'v-mmҾrYG{DIg#Cd?Z,hO4.g[.?vWI>P8u2PQL7+Y=X³3d^<:'N^#"@w$뚩Ro.MI;v8DL@>Y4e(z y<6[{S*#rGTZX\{=+?aƓM*3fs۵i({\ӺM%#JJ@Ui`/x⳵=͗I[VdQr};k8Z N\dQ,(lI'B)i;)N.1Dq#cws%'atn HWzeH?1YKK`_pTaD` `%JN 5]?pVM0q\kh6^uW (t9zޒ^2$n`+'jszw5 Y=]-n,fSQ#EY?v?±︥zEYY$lR;G9D.[EjqRZ|`,ҴNYT z}}=_rMrI܏v^K%|3({٢2|+q*~[t$_226N2@d4y->^dyQ!anکϥf˩2m' "pspKpzבXӔө5)m#tI-cdX*p\:*B>'T)%ͅՀ_E8FVZ*4)a?'I;ʴʶ#Tqa`QJaj'eqZ2纳ٍ%.}Ν WO`(mZPF߽k7ȗ*t֖ew4wp`HTӌc~'$$h72E0r:)b#OU8SOM8ed9{\I£Q:܇uľm qp=ҹS=;ӍIF[_qU]dXK7'r:gdnSQ"KG(23Cک˟~0kV&Ri+̍cNG<aXI;hs8pO9oA9Z.eTQ䊳!-;J0I0\ꚗ~$~DoiQy+7Vci^/2**|{%RM_+ dI<鎵F5J7I{htJ{'ԭk5O ~ozd~ZU!ʚ+G\;[LV%x H-϶+)7Ζ}Nt-Zk-v]꼪k^YUwcNNg oeVݭki#;VP:~h^?_>W+Z-|-e .{ܑ~^_V[hm #yr(dڮP38֫N۲|3H{l)]]c-#y9z玖NDG2)IZtj4`FI|a(:u+1u-~3}XW-*} ,sp`cgNU?ӧR^{}GK|cuU wq=U*ԭ6vCë/G^>srT؊˵go3$]ۗxX__.NQ$vxXmP3+ѩzyu4ܤl2~1ϧi/-"T Yb#Iv`G8zT9#No}M$HRáVqW-:m:c){7k?68nP3B7$ޝ^Ԫ$WInĆq.(112Xa !m *rz޷/Zy8ain۾Xl:gܾ[6@$q]7N*~Ft߯9 ~R_qO}h咧/j_wnue_^޾ߍg^,SZnk.VaioǴ Wx+JrbQ8ԍ7(;]-BѺ\naj7ۃu}\*ti5웓[H3O ,!U2@8dӍ_RE(bU 1c@A{|Μ۵z1OK6LcI$9$𧆝?fԼʪ>JjFc&#E`^TFRD#)RwOHKˋ$EIh+3t{9U_ճ !xv,`hW8=89ngttq~L6\aX=usTߣSV-!Hla-2FmsNm+߷*0t,yED~= cN8x3Jhv޽~Ccwh2o3W\^aJRWqdmvS~\~R9@JZm?f Wvp7sT7\[v8\JقF^tȫ5ɲceo}D> VA%?C(5 |БY3I jR" {dsNNir륎\=>w(]>ág_3%TGE#,y>+4U{!Yo۰,QvcڸASiy*'ZQ3;]mQUR z4O?-O?|=mX>ߛ,r[#VciRJJ.Ϧ]I- 9d9?噍H흼㱮 ¥z%~ V؎Ct>FPIJfҗ :Jd݀={A Z>Τ,-^hsK?檷4";}`J1^Xm,,ґ6Wu*Gֻ&[5HL^FN;v^}թNQa/ e9zzVuϵȇ3ŸvN_5kƑ*ĩ*A'操ir\N;,6hȒHi sֻiЧ6qT#)7t v\] DŽ'8+ c+Ji1uc $fY-#n['st'ǵUi8J]:nThQi[Gߣ,r$<|c߮1S6Z4|lTI*[''1]9Ju=XwF]^ *fp ;M9{I=-R[}o_!bllۘ0A9zWji+sԓQyqךj6.C[(4_>]֢\Nk}4 #2/ʭ!~vʔR9iVj]"HeM5ڸ·IV8cjtBMSzA$R}<WW4iǞ*ݹ[ͽL;Y_-0wd 91kR5c-Wro.Zfa,4)&tu'BagwI6+32M)"7Ed]ّ[Ʈ㭵6qXEuDuV3J[r]c7%1E?y}p%{7̈;f;>`xȭ;DaӴZ" 1j'ׁ]riyhߩ$;pfۜ85qz7-ZA26{"([揖aq4To5iԻtK!-W]7#WT=Ve9V3]?|2+w YN.|cߑecXEpfqt[V${ ap9Vf354QaXʈb9y֕m)ƴy"43,v?30A[eunGPM+#d[&1>X9nY]l*4FoȦ]IBu.iNM#Њ.:]u2l̼+ U?0`GOָ{Kw9%/kSn b."e.UXtu)GV|ҕ7kw#61z}GQҹNJWk@x*؉|Ԏ_>xhJTotխ`U@^YnC >f<1&?zQN3zFU=߸u=iӂi'g1|~^҉J+[PKNʣD* 曌bf)ӌZ'۱S.IYXl2dm``z%N1[%-qࢡe,0 ҲsTQYc!md3JQ3-Is-һk,pJ*lö@={VӧO&T&[~hU $a9=+3u-kȞhT[:+IUUK m9cZ.R? kc V2tԯZiy!k_y=?$n݄ ]'@2};bt^쓏U,fr* +J[la:1ŪBX Ui%_0ە=G8DqƜiSz Ge?ZrKBTQr @y?N+I%3iE{ܜ}z*yquNGzIr>kg \9)FNcjnP1NwԨi77sy.]br8fWT.ȘPѫc{è,:5")nvP,mh( a %b·,by [ʄ[t?w'~#޲ʤ-tB׵GGHlw֊OXVPmw帲E[WV_N=XӤ*hǞ O"bu82rsuU)MjiF"Nx[=lz{+tʌ!TW`b'ވ=<gRjEoAHU\21tGp޹W}5 FVd:X`ȠNO`=+8ye&}WتN>q'37v${TӣIn޾ΥN6A=W%H2*JN]}WQVVi2G$\ۉn Oǧ|zTᠥ);׵up#*~OkQOM[$ӟa]%}#K U5k[O&S$ҵЁ8#Nzt?wa¥9ҩOӡA ~ʫnpzڤUrqaIX^V# w<9\Wי}s9Dh.<uNh[_IJ˷VchbZs'=I=ѕ:^Vr+%m6D9iF--{EJ4RtOVI$4[wTNp?Jqiug,GvnFdrYwFqQsls8*Iiu#xd8 >qgk8Q:yiԓZ=nD#|o2e&Y˓ s1].okivqӎ^Uu}$Aeuq;zzSqt cw2[1<~MJ̹V"/n/e껈Q\qWoeMqV۶ ۤiw'Ny<ڶ#fR9`a4Fs&![pvO{N3Rb^3ͩF"-ЎDEefU-鎂Ɲ="|7׵c,r6aX \'=Z[7 ӌ7?6VdZI&>34rgU^;tvCkexdGs8܊;[^D8* {lXmO-1;znCҧBD$\yJS=R6wvo:Ir+GZ[W*0&V?+O9cnqE sz[M{MlUMߗt6+hhexZ6q<AMT_?O4pq*ui;AEur[S|lcrJl#Ѝ=Z^jXK{Y.Bø7?pdsǥM:no]yv49ѕVnUpᛀ3~;Uj\/ԘTA0WfS f\珽UgͿ:()4qw&FG=mv={qrѧN5zߎQ5)HW3Fk3¬Kܮ(ܕޖ~{[BjWE,GM `#}kJu"]mATå9UoS܎qu?tjFWm[(cN4UnyXDl*'[4zdIgt/"pw{g8gS)r|dдa#tگ^pAQ[JnӥSԚ72Ƶ',Kv6aـ2ޥiFVv>ޝ rkM,z ,r>V@kEiR2R"mZH]%xV*"=ʃpT'Zi`J5V߷[OqN==)֣J5Yk}¶R}[Ѝȹ:ڬyV'ӿc3Wt +_3JQ7ؘxa#*Hl~ sƿ<}QRtދmHOD],wq'%n9Щ|~U%W8 C 5"QաiˣJz#|{6M)KkD,5hDUz20sM8O,}&Kn;hq=q'e9Zͅn[{.rKU]ݏI'ڕJqQ\͝ԣ/cq&IIIrNTJ E˧C4ߴ^5k nwex:O+QQs~5cxBEEP_[2f!2gc=3S%RTF\+5+=.6mbN8# Ei2u9Ry$#(އmGE؜,MI4w#ks.e,|98={ե*qGHNީcj& [vY83׏ʹ\ios^Ό}}o\ ` bEjYrҴz}LkaO zD.j[򱃃zf?~;~ c+NmW&[iC4i2$V>}_٥GQR-+6+HG֯7"ީ,aom&`-:~ڞOYNR6Uod~}t"U*. n6LWY2yk7w֬)*Zi!md0{g"(/S]Mi7638U-oNi+|T~e(۸#߰kNU 1׫Lȱɲ0u:~fQak=}kY['# ̫݇WULhۡ5#SjKmʈ!5efߴө'e0RԒjIrR$2βFE|J+(꿴}Q]Q6i[xcӡʋK}o%Q]:Ī8UV34zNO[_!ZQiGv[]^Gp0#OoZ{:rk_%FU{(Ö v[` ޥ ڴ!՞5nn\s](s ;\' |,Ulc6QJX5)(vk[EXٶ]sF%a>HG<}Hevfٟzsޱ%'k:fvrGk31X.@Y3>W?|gL~N$ynY6^ MyR^hCdg6d#׃\ӕg6}},D W݉%7B5+ڊg9wg)T*Q澿AJ"U9ueaЭL$j,6_E:餯p:i2ddU# rF g~^WV7io{}EH˖Кv[l<$jҺFHNIU7tpIY>|]i8l\N"<_.X!/"kC$m8#zD˕IqjQsA"奪mV|}1m?ө&NOUł?.IDlA޴Sih/asM[.m0Qv|ҹ'p0sVc_!Ue}΋@׌ʴ= 2k)-"yLJuxehYEH'<z+- Sj*c(UrFHTWSԏ,i%MkӎR,g=J)舍 =),K( szcӊҨ7)(;רa(W(YEۖ'RGַԞ~hBEѥQHc3aH#k?ƥg0O_2i>1pXm{gִ=82a QWVFJMK*ՇPcVy%浇Nӻz_B6[T>a?(=xW~cT9X]%6E2z49ӡݲͭ!tv67^׵9ReSw=Ll`}k?ab}>mC窟.6SWs=(teC4鸢%9_$x۷=JT}'? C𕏏`qW-L59BJmU4l~^0{zW%L7c*u$tA,1Xٔ_)ʹ>kC)Qq r[}qLۤdU>e qߜƼjяԗ ,ݸayi&ui|V7h1q[I#Xpr*Wӕڍq֣)S[1lȠ$\ݳxu0WVu%c~2Y ZthȩUWLhUbG²8ԇ:5_jM(4H"V}ᤏ14nҍlD[ܵ$'uE;TH'wNcҸqQ璋[ѭZЎ՞1.#݌vqon{cں֔ouSFR L` wyap+)r{u]J"x6pxo⵩(Yuȅ:[+8my@= g+J+7ʎVcwtr39%7d)gg,e1mGԧ{Z]O^2_ikيv#bj`qZSvVE{=tDacnO:tQv'Iq-!q xk,EKI-vfZs_M:*`NJRG IV̱mdJI1q`sF"4{_;(Q_G-^FE.EYr9ϨGޓQ]Rب#GN4Sc*qNRV G`Aon׶x9Qߊ458%#t,*xȒ9vUe1c%W/Cj4i _Fmӈ 6o61 TM#o] OwR^VК*cWsZ­;=S//VED;o%ӵL#(c:2sGFvlyHPaEl6U/~UtN3B#]N-Lg#&F?ufq/-׉$e_-ٹX`6{zuKo:"׫j VP[/s9-j0y8G1R-ӿ&KyfB,j,qwUNT;ˊ+yp:rsp=kLE:kT]JiҌ-rhLȭ呐v"q1Q5 M]{y rԏLv=s#[/:`-[WUU7Yc(›_" 1jZnȴ\|̐Đ9 p35S.kWw5WAEfc&zUϪ^h+BhѓCx $'p8ׯ]YVP8׏ִjJnM~Nu9GG#HH=r{ϷNOit፨J չ6Hc(CI$`8~98JVSMInMLKWwBzCxw#s ?V4a9FqQ&\4#F1N5q&eT+^k8R&g^SOΝu{pI9mZ('?tLir۩ 4)xR5!;=#+/m:\G]!&Rϛ8nx{Bвp/6 H'3YTw|Vױqev;Pȉ'ϙ==zk֊߽*Haՠݼiɽvo^jcN:~rx*M5$vQx9TTKhO[4w|(=p5(_kܬ>&xtU I[XFܯ=kh1_3JR- U#-h1mfzg yNswzH9F夔mi2A85D*R} g7V$,mݎrWS]xV?ln1s0)f`hG9ӭsJP䧣ue4^B'Xc~^@ Le)trI+_F@76/~ҺQNrܤݻ|iѫ+)s~Xy{F'otx}t-B"XE+Kwf՝TNTӧ[MdR45H4s2;oȱe-bR˟9Q =k-_^зg""la#/0SooQ]4]YN"NXnp<Ď7f« 床!g'aŽ={12*eim}ӕI%4ElFvF}qRahnMr,khӟ7mG&a~$գڝO{>[eLwYٱcֺ)J+7ϔIV[rIY&໤nY<jT}Y ,3D3<3RN"-ô6an~Sl.Q՚T'fYv[ӞNE(REG)E+FY[oөe'_c,C}z lsj5%+,+(oOQUshcFQ*d73#\~J-5RN*m;Otۿsү2BߺÊ15`n}qVZt~נc11qӑZJ{~==4^Յ7}t,-:y$r~j9_5&W_1g$|8uZEϚO7喥T^1Zʪ'ߊU*siDg>Q?+SVR$P1H*U6sU|ҿAFQ|33|O ]^&+F?~7c8EߏyTќҪEwcv2Þ;gdvQ4H<ŚETn9T*ΝXX̌FpoׯZr躄cw˹( dۻ;vI?R~o#ש3M,kF[ǠHS/6Nch=)e*6vVgӕ% HschӚSiRZu<|sO|VV𯼒kT"2v,勷Pyd|ϭI`ymqmQv"kvle۴ Ov1q>7FګƽHc*ֺ!!fGqS$INZZP<ϒ鐥Oȫ/r)Q3} &U#v#;JI舄-A(ӕycοBg*M,,ʥѹ_z٣}rd?C98ƵZ:4㶗jok.iG@1Ϲ$a#z}k)5-SKЬ&[q+|ZB9;D=2rWp) 8J614R+ &U\uE&N2Mجn[R#}3fYڧ26e"b)#¨*ݎx*bKEJ3Wlf;vҳ7*&ѭ'qVfHosk)ũs-yiӽ([d59[{9Kdr9nC=ן eTH$pH[.YYʄ?;ү' >d*\"u%Y_n7/ |'TqzB&Y@ݝςOQ2;J%95s q֧XnI7T0>[ 1 i[cyJ2`=G`KUm'ybhGU4!xxǷ^YGe{/g\#M/ͷj~kh!*-}Ė=FB820x)KqOJD7 vhn@9)F.Ug/rJ֚݉?MsȪd(Nyl yQ׵tH}OoBv+bls$(N1T<ק(.B~^9'vi˪% 5ؒ+fedܻr*L<чW33=~nI<;$ϛK&]68ˡ2+oF(l0d>QuE5h'.Xm 6}_҉JugbHd,$JJ\R;+`\v˵U~mǖNb|]I{/g;Z^w9#N.2YD~ mvΣ⨗Cjry.6q`*F1RY]A3GY`L2y/y(fW'~|35HԈ?>¦RaH١ N9=1S(=LiєyDXZdiJ7V\ViƞU9JR喍<H.8k]SRuuSc};j,c~է:nIҳq[ ^K# RRF&#U20}xSPۘ4ֶ!$X??ʞ7rqJ\;3v7/ Ү<\9_3t>F۽O҉EJW8y*F{tr6F\qTwPze!Uݤp?jrreE|{ $w)}k9'R)'@ eލR}:B$Uᕆߕ8JKÕ|FF^ϖy:8W TqQHc y5TÞ2Vs}Yqʫ)IՍ]UL(5kw(v*8NjzF 3hZ@HU? Gk9*JD[L<70$dx}ӱ *,=<{a|>nzT%tRˠ]Vog߭mUejɳ͗Sy}x>洕:9b)yaU9.KcBetx%f .8<ͦRUV+甴p_<_VyugDy#$Dlգb6UjpUVm;FyPYqrk}PIVIvk - }*4"N>XdyX[2'C9(J9TjO,Z8FnNm^r{_F̊Ur V\n6c.kdw}PrQڢ>~Aj}GHoBxNrr-aiU#Wv*jGݻw<5ㅓ8^|VR,ZZ2g RG"7 m+n_RTGJ}˩?ɶ:K̳Hd'p; D%{AN=D{Z,$_iGnQSV2U8Νԓco-4-x~稬pKU#Aݹz~TN1˕US!L<,+ x\l$q҅&1žƣ;q?a(K:6I$ۏ@?:ϖrYsS7#ʇJdx냒yڪ*:R6O(h;wS4Q)"i7.2ӛ6f4>h<ʨNPjH*S={dt.Y^;$J~ m?Sm:5}d($‘W$0+]Py#u&ˁg 0?qSN3#(%Z+h>x jvsssUh|xW'-s=VQ4{߽vW?xFEIG%[$X 6dΟvtJPG{4 վzn2·2hX@X!*<\r7vă*~lqZ 6K(W| rʌx9y,g85Rgt )F {qDef䔩lCO漶ykKG֟3h4t;z}{1jdq ܯS~G9r.ە? 6GkB({k?ۓ2FŸc(ΛbGou&HVG[cp֦7Щ{9TiCr)+,th }Y=z cV*y*aRcFJ!Dq۪?oQ8sJSRQFŸIwάqʓ$kN18Uw}`dDҲ '(=*5`a䥠 έ)`["o'5./', u#޶iZoL[|^zӧ9ZsJ53I~de2GnBa SN*:q Rib sөy-`RV 6Kt}C SZiŐ,)l2#|ֵzaƹ%L1rXzdqWr}VU޺.8;IV+(.09@Rjn1-˨آqdyONrIٓZ! 'd_5~+͌U*/nms6IB*ۼS$ce$=IF9H:ԊEXT wج%OZjc'{B~y[ jW~MXTW=b9HI]Ѳc籮z>Ǘ8OoI>T*meQ@q$r}+͕ԩWhN/tϷ˸D9EF"1ZOM/&f'S^{QQͽE%+)4Keaw-/`"U(st N;V>4L?gF2_ms($jW\c 8=;w~)Ԧo4Tȱ@99G4nWi$<賤aUǶ}9GjSF֊z̪^ݶL\4Esط&1Җ_=]bBؓ,OǞo)rTSF.QW-nl֯h(2׫eYw&BF6=s5].׭~"%[yʹ$Lq"߂XLcNť}*Gݔ}K 3ʭWvy;VRS89G[t(#QێJ_݇SԆ߉~1'珳MֿNa{i<8Oj}sQ-_3Js*ju!1J0;du:3;jJ;Blآ۪ `GR'qRMrGKj>_B\;Kw,qD ܎0\S8nj1NV_'$B5۰mTnX_N^)r˥&AF°+p=~ԣ TzU9j8-.x"fEՒC\LT{6`9]IMGFO?lUYĄm$ҌG#2WgFUVn%O-!$6gFpi˗Ml@c?=={թM41zh6-n7-I*fc q5NWN3eju%T K,#9x=}+/iTju*/Ni"xc[[ )!VdfgzduZE=]'>q{|o#\מzym+vcyz1tkiեk/ǣN}kTVX! P|sګPvZ)>+ϫI"~fUJI>zJ/v8k{LF)ok$e1۽3HFNT(*Txm§iŶz[ܬ~\x~rF)ԕM,_*SNJI{Qd2>InOHn'ssi)*n/[vJXx˞_䊡ufV翷jUek3OcVI Rcl-dgGs8>^]oRU{Z 4mJAh吟,Nx#WE .i;|uiͺJI=^0Bg}; sT]&[ih[iZ?w,vA$yn:{э;:ݺmٝTJ-$e6e'ۑSTw~dԫJQPQ[_PK'L-)+WwKEO#Ge(m"hVU4}6ⶽm]ߓ)O+Eٿ! òVTeMpg~5tZK!Fi=}iWy_#(ִ]ҍe2NcɎ)fktOlb9' dV#;?.x\=JtaONh2F[W ƈN28Nk8XY}m/{Gۺ6KY$n+Ӡe'+;XSU2)ė1ʬAS:}k:*<ܶGUhM]장vʻ726fqyQrSj%QpM+ mc4>+4(v[CO Iݷ'ԩ݃w~R4``۔l}qV4g:1qnF]?K7RnݑW,z=g>aGԖݞs ?x#&8w*VwK˨rRHUs޽sߵiS뾝IZTݏKB R>Ӟxp}+NJ+\nO-ªy,JU_OѯN1Pqγ⽝ xY~_gڲOQj?nɑ*JN*%D,{ff Y#^hF/K4F27nk3J\WTjF2Ti +|\Nz{=kj~Wkc)֌e'aH tە0~)F:iMCݺ} 23hc\8֦Z7:q6C&UYoqp SqjߩJjb9 4#5]8\gjUH֓rE$_ NUeA\[hku Hԏ?UvV3V<ܯrhP㜱CcJ.я3섈H Um/ ShiƴyБ4L#ڽZ.*u% o%c!S0z_3d-Fn9̒L-nqߎbj TWĜ!d`y;mMi%NM$oV䏯E,wiHU 2𼏽[Ǘ>wOy?2EBy,zJ^&IF8Cviw|݇s?/g%weԈJ/!;|玤9dynsBE[#B ʣZji.JRuc`{oנ'ʷ7}TotEy~΢# i&rB8֪u{eV`gk556X&#}xcM'**bU_ڿH++0 '34ݛVJь+ 3!(qxsIFTz~$ŒyrrXYdw#k g3sZӏ;Q#Dh/ʿ(&5\}nU8'Q3|ҌdZ]xq=cyh&?<5*1iJ4;b]؆kyk$8?UNYϕ-,,c]uZGw]p㯯j^2VU1^EwK&oFOǞef=9Sq/ʲ$@60=YS[lPC݋O$'Ώ'=ÎjVj^`&[o s߮xiTF+PB-E~V\snJ2{2ؒ >Ua=OZESs՛WJ[{QZrqLo#xե3Ff^} sUzt1Sϣؚ Y[k2NH8ץsƥJKȲVsdx #=(H%;#MFZ]Iob2.*b9d>ԩNmm|L7B}]7Yᘑ mߕf9n9ӒQ*R,jsTM)T}r\w{X`fWh@8ϡRMMjRJ,XlVcv+QU%Nj-v0Α*LYwn#fnMRS +qnVI /+.A45'fJڒ^ aQ|I#uRaOkRF'bf<oU qNZxʍwzzimbhnmP 4rױ5Ӄ۩Z8SVԵ,˖~V3tqe;#je%+&g|XI9'xl:6o̱yp$>9ӊP啛'Ny6W}#0vO,tc~Ģ36_8\tZ>&XZ:;2#vE$L}sW[㪟XRi'$̱# Gr{mBZiQ[]6v8Vvʨ*c޴tդ^4ybe :0<ذ_SZ-WǑy tBZF}Hf,axj g[sFiI~pG,[U7eێ>Xs~M~ RÍ,\\,cb1~ZίD[TEFxЮ xt#E9Jw>qQNbx @SwUHϥtJʗsF&_!2Iē8e08 ޝ9rޞ"FnM]` "G$l.Xfe˃ϯa^LZQӯOSVXɫ骾\l+2anmk+#oSw#p[AFnlqǦ*[-5}o~S3Lc+d|8zSF2)חU~(yFAϷ1D+GބOeΔ'k$ b:QۡV/-]oRM5J`gRUZ88JTYC/VѺ&Dh"h_.{Gk 3%[nJ64Ԛ۵ >`ZFTmg8ǛXЬ49j@3*Do9^>PNsQRIl19WF2G!UP[32Su#ZQRrsṎ;$b>4R̻$U?x"X:omNYW=6}]A>fU^v2#GJRt)5~:+S9TeVyK2# 6rz=jNm'kz_S*圬ܒioY6W8nnIt_S|FH(ddekn\G=2szY[^ R.JBXo^ff~cz㞼?Uw[LTIrF;60cYKGQqs׌zwYVk~[eSrdpF_ͷq\}u8?gB4?7t $62F3!N{gT6WݵksQ'{zֳ6YH708l\xBI5weр)ӯ*.瑰ۛ }9j2Po/yU"_$a[Tn6rU\ҧV0i%[]OJx*u骑v>ᎄI ·7G qVؚU0iJ]|F)A+m-+r:dr:rR|:릥Tc˱V!`*$L}+I&z4ke8ҧ i^v fyH70b95K[}ܜӊdLd '$yqZƜeM.;^uArQ"$9!P9Sϫr5QN*Z7m.m❵ #%HV1sqc<ޔ>Qwt}qGi_kmVkxY-Ww&I8,H' ڶʵJ.ӷ6NHEG~.e,追e?h3o SZq8yExYUc.d?1?N3NpȒ&]BfO #489¦=S]gظX5yhB y{Xk$m)QQ4&ҷTf;Q]1U12;z$]]_I܎DYw9=^Z.{_ֆ4=A%%WQ Ago姙?7,8,9* -wwi3xxe%g{7pY\H,#LRO9㠭FrJ^V.TEegbQ$3qw3xw,Gݲ5i0ϧao+_C9v_>Ku\D$Zr,Em߯{Zע秊R4ڋ['_6[rsy8lnju5Վ$iG,޿/$u# 8jzJM+o!t}Fh}V3]Qfi+geo/Ĩci;N+ђ7_NsouITlʪVU1 K-Wp{î!n0#o=$\me9}Z}>m+3M=JєOqVvz][1h&˸c'֔ 7wQxƜ}ջ,SwjLd+zr:tԖKFVQI*NT[v x'mO[^R4?#^ En\eǡ=j+r GtQyd+Ċ6uRJR]cӽzXawz&R3ss:ZWqN)bjƷ4UK=e*f9^~}-VITI%t,_ZdS4`l~?\u9:%N\jiiz]軲\*J*NaN4sG]>v&>fē{uKԧN7xW1m hRR+E k6QhXm7fzTTiS~?'fN5*%[[+fV`d).܎x]Ij}Zv#Y '}c~u*2N+R1%[2OY& ycU(͹ٌEVic\CpGrW%r8K]ݭrZTw';v]&D0ȍu*.t*a9_O;Ն-.IEw4q?Zq(B2HeY.vl~S=+٨ǿEm)V`zt`Sgc ۯ]MrQԩ,;YIL:zjThPR[[RPW|0 ܛc*K}<"-Ŗ#y=x^E'ޝ9֠Mj~a+oryl>Tp:gA)'8-Wsj*rNϷ~l7 28?0SR;TrSQNmF\]Ie~fsufXcZ!dO;y,af[vߎ#Tƚ~7kv?rK^#udbdyxkԕǕoݺrʴBRM-_Dy򁟘ޭѯʥ'%taE֕Yi,R40 푣`<WBSҦ#R0B\5,*X`ch*2k˩:?XYv۫0ڃHO2F8'-NM5}~rQv1֫;vŲjӅ۹<> AԦsns?πq [Ͽ{:z8XR[2do3bx=ZNUVGMʊ袖K`.Vܞ9汝?ktؚ~ήrL'<{਴3)T\tz?#_+Z]dR~쟘d0^#*݉4$x/F;I#F8EEjteF2U"D[n$;1Ts;MtCGf#ӫR~]~cEO(wm?g+^b#)_kꇯt !VrkssyF8vh؟컻jI}FUR׷MHOƥ#nCgkэK=mg3FTw^cg_t_cHǿjҤcukX8bqS(h[,r*0G׏rܯttTNeW} :p @ʷSTm//GN4]ѿ h1PD#*#h1_xG h~ۚ)o~zuq+30]A O8=Gq_oi۱ذEr;IL譬F?*)]ot,'XݛprS#,rG󩩅mnHkj'gTaΜIE^lyFq湴p3z!]kkBXߕ[51m,jeeg0]!+Z%r(JZ1_=ϝ? ul9ZSБ0;H=hsyaZRNnk_#JB-%CuhH1 y`F;sEOgZm}/)FBC{,Vf:֑nvo,g+ө$j\2۱I?{=A95IKzXlR OZm W{jʍh9'68*q }=-sZF{q´jַ|M$ (a mr;ֻeUU.EW}OḆ .w?(>_i*Qc^ҤZO EHQӂqHŒyZ1enP6dž  =G+ukIo멋\I'nH&sٵni׆)Cɿj"`)IR>lC VJj =>oاfk8Ubn^jy];(*+ovmt䃀9lqq]*[K̑Ktne\_\KiB=+tffegR>l;G6F"SJ`K;^ni% G~?ҮUGܡQoܒHRKĻ6UH\q:pk(.y7= ׾p[9m$]f *ۊ>χ*s{v꼟QFvڒS##U5(g؊8'2{i!rv!϶}52JI掊xxִhC^.w|M2SMO#FF2ZTi.X=m%e}F9G0}=c7!q`jW7Nu-kl|rԻfxV'$EGssL#WAؘf-orxs3Ucz> - 4rE#)8yÃޱ|3~NKZ+WdVu<dC#mI8Z|ѩʴrZe %o7go?*bFߖ_ w]?Țt*{I/ycd24{!&=>G4c+M[zx)o=_A--*Y<N+jUi9A^mTuE*~ci!46Bqmt%MJIKt*:*4~G#mk gk}<5]Ek;_sa֔m&򘣋ʓ* p*9Y=:ƭVst0a_QZ.Z:-7tn\Dp *q_M8;cJ\uZ2atcr zU%:T֚WtKt믥|7S ;q+H?kCURMr+4:h)A'Y$=瓩Nn߭ Z?VP[gnq[(J~=@өU.IՒQT r,wRoe7^k]zof$G~`P(>c.g60yYO*iNu/i/u7}!_>cG_^kZ5=\yxR3QKKٮo khLzv=/gB^X#xl+dd?3ޙR{nj\?AѲʋ ѹ8LXc6,\a1ߕ#ۧGzJ mic|.A235QcGsUpvr-+9z~U {wfүA٥maoó$#\LiV{/Q(CVG#hZ]1sW:j_yՇW>Dq(X_rI7lgZ-Wݶ"ejk{t[bu*Cߎ?TҎۻ1Jz']}K t*7䞘EH}^D*{wZ>qڲ07ßҳٙ*:2I_gn[i7EG3R>p iNSkR[wŌƤYG̽rA=F:wU|,*T%$Nq|fE+"6ݺxzU#q*J!Ȑ1!v اĹG ג֭-HGq3ڲu§/-k:m ZٙCZ]TuX4{K1cW"%9J%i+],.n򑴎溥 nc)թYӿ-w}ͪ32p8G޾'7[?B/. =k;hէRu^EW|[2sՊ,,GziomU~VR'BZYJQ*eR!]O;|<'#})N2m)KvK#GWRѱ:=yՕJγ=+ݽg m?6ޛqZ/.G^kFve2JcuV1c uQֹyi<]J%抿iI VI¶c8f<ZS|~4),cn߾qV߳ʩ:1Ț׫ԑ`[3o²Oʥ59p~7}5V;a$l?3tp4%s}kCߋr[BkU řz~93N:.tݥtz؛U/*{wZC2|uBݣ1iF6vz`MEy5ܩR"ZTցF,U;O|zLJ9J/5MgF$ o̎&*r 8W ЧkiaԜilAb0 P8#qGҵAʢi٭Mh.c$lI7g>}+ᕯp88̕^LFb 3]_SSDZ5oRq'{s[)suW[Q_qf5lUUb߼z|Ҏ|юCLr =9oK.oNjcqIE!ן+ϕśԄR'&΃tj<098;CdǙ2kw#&Y$mnjޮԞ8],O6H7mcUFviSݣFum{'Q蚊Q]F6#S63Uy_?$.o6W׆O^򌮝wr|7dd}jjY$:RuV?W#fʚ(\;.Y,t^9~7ZuEXwrp>R5TbZ D܌?3*~`\#KqRllj(Fgqci] IdE 4V2OS9GE$cBëD".aV}ҲGUZ!ݸɷq]ۏ'>qqT(%{h0n n4MߏfQ;SIh`U9#itZ`s|?._N[Z;yb@w;"Pc*R~J5x#p&:CWa<ZӛE>Z|Do(fV~<{M*MHE|LݾC9Zss=iJȑ[uLm2Z3elp=_~*Wks\B{lm ȣܑuiFr De,0YA yҺ6,*SNZyXRpp#aC9dqe;F܏χc 㯭gZ3r\6!>cN۹WЎN*G-hҜ.ȧ)+By':s]{DˆeI;0G9=8QRCש}`I1HpUxzUۥs(q)9Ѥٙ79?Ҵ7)ǙB[*۪ ޹ ?O¶#g2nμX4N{Su [%SE&GGŻh7qnkj|ܭǕN1fK*<#]۝zwVQm><3 _,N-լИ^lT78u}zܣ߉WUBBr#e) 1?qҳ}^Ҝu$>I_y66[^Ww#rt)#̌6>]O8̉J>ϕBȦffF0vD ߧU]/UKY6|Qs1P9='< 88;ɏ+[̩tvZ6]buMˀ|S2ܘN*cqcԨt#QNg_\ZR\+x˴'<6O֪QV28N;ᗅLt_L? %QҨq"[*Fv(ppUOz\̩7Laymn4h.R%ɜIv}?US7_~g)7AJDA~n'\P#R_ 챴bed בNxxm5an7"lIJU_wfc`&nlUYyݷ,zNz~(edgԖ` }0ZZ2Ӣ줙"Hǐ239zϙN\Si4R?$O(] .Wʅ`λPFE%xsYz˵PhK6f}LpTb;8N{W IJ )KjF̧ϊ@>cӥsi]U\\$,$aV5Yg5)%MYw 26Y2dJo~⫁ FZywi 0bX~qIqA !o>w7rN{=JccHj*޽24ތw|s=H9Sg֤JkUr$tʢ5;pN}xk5m.K^ǝʤ\[bKe{5G.~?tMƝ ,4BfGm?+ǭJTFۑ# o.<\bO`dg?#aZHgNR:jźG*\5%Tkpz\5R`2TE^+K?2Cv-4pnp lדs-]_G RZ5>7q[JIB2vS͇M:>K}4y\%2z7~v=U;ݿjpm;OR˱HoQRhV*_jW4^C8Q6$}HQ*iN2_S8K5؆sn;$dqڳnnrSi5,yCmp{ǖH̨9Tktzچ#3ݏ8S|S:[UMuIjyS\mU.0pqjʤ'%Y>dB4I BC~wn@bq/!I^3}W;:qz/̪Q0mnV9aUqԃZ\ޫOOs )-4mmt#HAf%ִ)YdK)Q(~i6(Q)$֍K+_0T{ã k#2m)1{`5Z+ig9 -$deC3߷Dc}bq^d!>POǽE:5{ZhS{3BmC%EװIxY-XF0x'"kFڵ7R%Ī_A3nk_b MKR=]Z뱌%]CZ_ԚTkʪuL^py:~0pwi_ue̕ТH _H(sjNN{z+Tn%3p9"@zcWDTTZnNY*zEkr3C#H8b r:gJ5uwKVN4eȚ<A:񺔓,}xmZw/U:9WzaX׌f?tƟ-1]mq]ՙy T89+c)޻d cr,,1Eo]FT5KO1-6Y06T9>F-G(ίi0` QF;![#'+1|NXᣊ6%DY&ndq'>4wIK)& mUۋm9*Q9<<>~^eMnoNz~59I/k>O )se-,4s6h\mq"m8SC$ۇc•_,)J**AƝ] d˹o5IsHw.e@!ZTax-}?QRw̖{^}nF_nG3עX79O~ƕ%NHh5DHs̳>sʕM:xxP\,vx2N4Q[J b)%ib8,b۰a ,IRïk+5ndSNiWBy`PwI\}*u_5*FW^q$c* H<zf=~mYe[F3[t'W-I+=HPvA_w֫*qՙN Ey|^xDkF:GSY9TWA Hrhr?eRi\)ӍKD~vqng b1F_7Kq&fZ["jTv+}~9đk7G )yF%MYu]ͫS}z4E9ز0ܫ 9c.h9[M/i 3M_Rzzsȭ)Uκ1wixGm$mi5FN2zW,*c9=MuӡN;V4Wn+p!Y6TqӏL8ݼm *N8В9by˝ѷVg? ߏjT饫eF6i%y&UYn8ڶc̥~YGX˭ؾcexF_Vģxђ漚Lc$e7v &p@_Ju=z5Jwtf\Qw99j|;~l' qמfQ.k]1 I" -rZTTN>lsOcULq?*)joNkkݠjf9`x(EsI @$xX'd9WMөM-?.Y&V _,H{U)TVm:|A*Zc{>ov'?nΝEm*2[Emf--հ}3 S-ܜe?aNٗv#~8s{5U$Y-Xף,|;WTcNw)&}4kY2wezݱ޴];"ZGԯy$jƴJ't喝;Yܒ9Vl]1tmJ5yF.~\⟳ybM-KZas,EbU,4SnS{EoM4 R(̯I!}RcqqdI#nܪ8N.\2TRU'q;Յd1sП2wW&_wW,2K7_֊D(ՄfWXپfRÁDjSRteFQ d5ͨ 1ҹK|iыVd7`m4@QO/՝~Pz+w/ʭqn_iZe)W7>]=_{Ҳ򴮵ӯaZ]I$^p=aNTdڳ(ӧ&%qnm2G\:<S?N?odZPxc :EŻr;pIwrRݽ \E8ɛKd7+=y[йIԊ澄lNs2o3qq={єn)_ȕ6z[j9}RQk{TYYxc4{i|74r- b!Q^ K*xyj۷k,< Dž)BWzʥjtUHVWϽ]ish+Je;LV@z&3B{b+:zt6Ie{F%@[~9NGʥ=ISc'&n5]~U d9VVn f;l*Y =5w{:i>p<̱^)0quASJåNn?Z']\oFe*0h#nYS>%0Y{.Z)PI̤/D\n*QW -4&A:ᕎ3OsR\LcBHWk~%f+asF:#GXQ2c̄I'p+j(7OR}q՗VcX\ONYѺ*ĖɖY| 60ztkbN*ʛ뷑$lDjy\'Xթh$sLae9x|z}c0[wBHm[Ȃ7&\=cO}ot1Ռҋ6Դ ooc)TtSWL[U\?L,D-b0M[aiÑ\ϿMeQSTVpΦ2x˵XhY1}**F1H58S,&|0_^_ιdR^HP ^tᘾds_zӷk_]>_ƫN_nV'uʎδVʐ=A9ҳKt<gS}E,V.oc3uZԤF2߉xz)I%~G6 ZCl$UFɽG$7|9SswHJ<R~ڳQ#[tiytmXǡyԨӬR-r.0gOi).w;q|};+I-䁐# jQ54#Sn-qeV*~KM[!X$*XI'qSڳ僔קT0R7zvcR!]끞Dߺ}V^ZzmֺI$U|.psK X|DW}Ȍ曘GӌzGLU /-:Rj>j+KϾ&scWEܭӎ@kORJ+˷Xۻ ,q]yc=*J׿z,,InJbNċUݸwzv+e )=WKv􂌣w-SWoTnS'%c c8>5KZZwΦ2/, GX~-VswኧRZRRUYE#/KXK[x{^0cӷ5RSv^Ο5T0SG$.Fx8=+<-'qsR嶿-| jh=AGA`8ZЌoWm?kkÜTOaEn,9}çXsZY/BkMi̖DVcy]9eR# &*QZ+.fãN=֓W{É0jUYUhѻj{1Q~'/h K.:UNv;"ínޣky-ĊGsgFiwg*KiF->T\:+z}}k Aө7t}t}bjb0ԩu"٭fQ2*+;ocޜqXzW?#mSgY&63}O6E aWG2Rz~w:egizjWS5̬+)1Ơ#JSP 7eZUJV*d$bFWgӞ2kZj{7(^T;]MK0[ұ,u{l#+C捪ʟ<׽G$F>S6G8k>iF^'ehalqPs?N®z:ߡ(ZV5Qe,KgO)9t(Q?4$ ! {v^Hڹq_*thz$,.™r=s+J\l9Rx}ŭFRCd tdJϖ*~sK*:n-8IXBd˂1'8b'SeRKد#c y+8#>%K׷UMkЂn b`0y>My]g62T&h o$X}à_\Jqr멎Q;?{}m(&$h9^QJ>N9Դi[+D6܏*6U]3:qW/eI|4vVkF?1wgB{fbʃr۹Vb%d} qj ~Ż݂yx9X݄RQUIvo532r@ p}HVqN1mu}4?)Ӕmlv^[KEKIV11clH U?}wNOG|0iNʚV2F"CV#ߝ֟C߱id-4uJ`w&QEg~Mj:7I-4V {ۧKU4(?.3=1cRJ-I=lMw'n[K~g ̑SsF̪ oҽ=9%^]R){I=$Dv ,QA'p;T֩BQ秣Jٿ^E:rZ&˯ȕ]|]wLOyThZɚʜ) N{S}%2B7?#l.,Jo޽N2q~^k&ӹ YK4ݺ]fx玣oF1K^˯ETQTݺ;-Vckk:R=H֧N2wlۣ1zzǚnR-L#R }d|dY ׯjJJ6o޿OrTOFW h$hK+8};sOZtskiu}papxU}-%@ň6 @JqJV冩nzCico:Jv"/SvC`z>Г4>^'ٻĸ1U93*.6q2u6q* ƌ!ZN&V9ZPv #tӨi:#iw[ #r}DFfiKgӞ1R:/RLZ*Нut-Fʻdsں8?'ӌT:}WEԑ-u$mnY2a~c'u*9+r[K_eݝ%;9mCl) iR_A9?,Mm+Erߢ9ѧRw]mke0m!#J/|΅0y ʘg׼4Rb(vfɛ,rGZjrZ;F1Wvu$wF *9I8V.U%}C,C{RO2s\ԪJ[v} 7,#efrxc"Z?x\W2)ѡ*pdy<'?iRzZrIG]z'H):2 $I?OJ*T{zjvʌ^LܦFUWsV|KѧR%%С4rEp>q1Hsnֳw9T}'6d "ok{c߽ycR3թS;Ċ+iܒHP`N쑏^J<9ciیdQO lJ);<tQNTySmo5pGUev;WF%:=}kRfX>V oֺX]wޟ4xE[eSyhXdrDe=kHє6kjBMU[d)Ƌc&2XaY$FךIJ.P唯'eTO'j uRnT&>H]t++F\Fl/3zTDhƮ۹jE7٢ϖtW9S3kI&ݔ xqzg<חhKJKS+Yp8\5WZjTjW݈b ЯͿ~cۚ1j-)JqW_/#Sy? 2B3_ ֫Ys-j{(܍ާ+r|I 瞽Ard_}f#(F׷9^/68I/q{s◳ѿ̿=߯;$mOdUF2WvnЧv]rk/$Y\2VU*ߧsXVM~Tխ)TO ]˚(J%mRiQUd:q_CJ?f֫E{hvj*\` sA]W̎yPQWr׾Ը]iupT\dgyzSzoHT7G- TI66[`s>T*s-*ѧRK?8Xјa뢏 FQRD$38f;N[sKg)Q HaEUfsz IerT{ou)|]{|*X۱4ݫZ5AJ6W jJVA^I T޷-y]xǚ?1b!,U$5ckٶ]洭N/z4ѢܺhmF>^zɪjmNIN6[.U[/23 t޹}pK`g.y{a--) g$rs5%Χ,=$I7;3HZiO'=Fާ?*Z.E;ŹYwN>~;FJ7tzTM85ü_g8agU($9ԧ,G, 쯮W.!oGϠ R$$l$*Lnpr'8։QéF;[;b*F.*_O0F#$2nԎ$>Fzx%i !€3zR9I}WNR9-]2mg;08^WUJ׍"bէL-"o2sqnN89qJJ>nN*qK߷r sʱrF\wҴZ,"isJNv}D=/Uw8=$J14jrGm_kε8\ۭ/Q@[n 0ԩ!R+$[H"?+8u"uOt%}[3.6q۵cRU).{!/Ybʍ%X =:[Ge#Vo.:(M,ǏUTd;:'rW~ָ|GU9a% |Vm Z(Pxæ餾O9&*S'w/.m}IԜ`}6L1{=u1;d\60TN3wR5-X}]ssTM}Hc} *JQ߿c읉gR0ǂ9[(%t{L$EwcYQ(I$z'- 1R0\kVv#Jc,a8dQ*u |/ތ䞟D'rZF+wR:NmN$]♶ǷfN"I&oN5t69Eeenɭc8K\8) (5]mUWwBQnG ܔ[M4pƲF6G^duc]CP*F?ww E:n*?FtTr{rK: "=zq2N^=w3_Ǚ4ӭɚ[ENdUoq^c+IH(>e othc! [ Ȭe9/ҤycRҗ[hJdFLi˙'1 ԫ}<yTiEٲ#5J wc8B7y([pse8ztiJ?>ƍJ+(7]mNUi+&v 4o:TXJ 5O1peZ|ө 6b̋ONzkZ#4{A>W?wkoiد֗%_5܆PƻwpO88pQ[* Tvȵ*jUYaq0W-GSOF7ԄɑсVSýLr:TBi.aӂhU#ou\Wz8Ѝ0{?URQv߷YZ\Bc3!(_iR2F9c%e,q<,{Ȗ?$8ܞ}kSciI}îrIƢPP(ӬVi]bGu"r)ncA9ƅ*m#(ʜe]; e">S2yqczሗzyy+.gRd19kFRzY?q XB*2R@r=ZM:иΜi?@GUt*!]=zbVthZou\ $,'`QƄSJ8*JJQ)HGe9H$s=.6NVXJq_rJ^;˷ @ǿ[TMӌ۵ݟ9}m.MNv7.vbF$JB[M1KR*ɕL2?iqp_B0u. i$Udn:w:tTc.X%= ҩNKOeiym(G `GJP2W%Ot\ȳ5ĩo"< ~Nk:y֛&, |#.H;=6լ#8M}}f KNpGR1PMTN2|ګrCMkzqe7/3~qˈВkXd; r>=i)%ШVIv|CMѶHnGqDT˚ס:eK|yU2Uas?U[H'~]S1 -Evr@UӺ.L 9ԟƶ*9o}KAlXcl.}N=ծ#V7j FZ,:erG9q['mVT;̼u"Kr7[%ۻ1nWQ{fi%*$1<6 3p+J8'vBJM[H/5;O'=Ga:i%coЍf|dX^)Ƿk]NHR2Ѿ_3 9Tx2]?1*$vvdsy!`r4N7kS?rMBs͹ea}ِV޵„ԫIw]f߄[j0:p;tʜ4$3"rg_if pzs[<ޝw'5:4kf8Us?eQSRMܬ&qig H^\E8f_h힜*ޥNZ6GtcR7}S="U`-ב=FhN*< eu-7v%NnD6 `Ӵc#95avԯ8CnrvmmFrkӠYէH&#ȉe܄6z}k֧>oܽ6h-IC1v%'ZJ/$0Pvzõz noI9DJ6ijkMTI@VV7;Ym# skьavo(tDHB"ǷCȮ8:?nmuEuSutĿ̼iNM'/=nܡOt\3c!1uW&m"in4]߹F=3ӎ*t-l,A4(rT_p5{Et9ejnUGa}X)\0#>WLNF6^xoUI43Te:mFIGnFIA].^:K »sdy'jX؊m]y[&K++2WWՐA0,S(ÿn'*]Ey[!2UmR7,@Uە |1J--;pɻ9>ڪ>=XJQc-X9TUv QAW瘮YnesZuTCfL]͘7 9uP\Ƥe+\lIU$8Dmv{9{v,=7}Jq49ǖ'!fd ʦVïBQVCdϖ񺴧]Z}9"xՓ nA*Nw rvlpeذaǠVce9F6ҽyWĝܤԞó,1ms?3ql'~Mn~^[> >ϝϩmLjj)z_dj<`8Ϸ5VF\RA*Fww367nߊқv6Q.IMPYX1k۝TbɚQ,;Ѳ3~9<ꥌ.iX;;K.|$:mNZ BTpV!13Zs$i#D1i;YQ5^o`ԑ.d7e vN1jbsNiJ<1m6qϽLeǹW,,fnB9~4%^"tybUzÀ;sQqSh2KTKFÜqcRS}EͣFm+HvJrJ|DR!uތUHy?N{Vr+.q+1=Ә~Vc&7aszJ}۳|^)17-rs?TNTICk(WRʾ=9^ՋtbCYbEa'{?M0:qw+2DZ UziIir\܏΍]ɹY0?pk[MZK}Hgq-h6'ӷinUzn^fr"cNVȣ!(_0FOޢS励HRve+W]W^tκ!J)-G$ac>ooO;-IDz&rB$e{U]vz.hݡ*3G|oyW04z$oԹ6i*tEOk} -yB_ qhp9 .6` v sGZ1QFUjr{]\*2 $r}Jj=ѽK(VyڥVFʆ4/v2tԢaCM70+3moQZJ<;{Go|ã2yaG .=<צcHy-X/xg ʡmlB+Zye=Qef[m';y#<]rm$$髢6r 5m c ?ִ˭ٴUH@y"O;sm_^~T6H(٫er(q?QHXּ&&bf``֣^{$Dy4⾙eaE9u-*Rx !Z=ۓ$xOˊfm|,eu ڟ75RgFD -y,8RN:}p+ [3ԍIs-^G.GvzB[Oky 3'l2o^GL.ij-uD!gQO=~,F3>dՙ[q,rO`{x１4ԣryIRep2>RJK#A RȳIIh}p3MGKUjj.eA'~z**Tm+Z NJ*\rN}|JҠ3T*ysq[э%XJlf }::ޜi֩(g@~RLv|+>5i(Bu`Ae,6MMv4ONޤ3j߉#8FQ߹8δ9´́j2sԂU}#$fKFUVGU,c;~ ;!;Hգ? = =K)SQw{/|$2\fmѪKؙFu5OO2G!y/Ip~{#XSZE76:Ig(TUȔc܉lvP o^Ʋtct$?~Om9z1>u#9VWZΐ~N]4MEDާ7Ւګ v^[K{S RcvbF q҈Ӆ]:ר2E<]W(zM=4+hy8g?5N+AD(TJ|X^٨N4Nto2,F7K\J{6QU{ʙқ.˙+$iԖ|R3WYJ1W OtTF}X܍Fn(yDL=zd+^ɘ55vlcOUS?dC*ʋ6ny>+ޕ"B3;Ƭss,KU=G `gU29]qzt?qܪe*q@"bMA\.3ҴdD!GBvVwDj|ރRHTeS@] A3~LWߎq^:e(F;:"` 9dlvz˜W4mj),cc>\?QYNoS(/t mTEgyTVJյ++B% pv/$ԯ)idyw=9{IF$ƔwIHn6V}0z}k-E}S2W{v!"7F#ġsN<3nI2ϴxa$gMUgF=VۯB;&́ےBߌ51M'ZMGKXغH4:_0z܀ ~,/֭ӧ2"3!dY#c0r1UEJy_!dѮ U]^U9oV:e(7GiFMdqJ`zMRh%e6wF\Q ̤ 89#5|^Vd),Ɖiq+,fm˞&-7%'N nhbNsUNRnQ <t$c̛e TVѬh(_gސ,3T\hLeF6gYat"|JT2GZcʴ{Oio]"҈*6Է8fiV4q姼^XfQOZ9a[ީ6Cn<]hdpQN*/S1'f2;ռSc8j{k2?jJ[ۧ2;FF0p:Jj8l_, UPp8&#%foEpW9 ~{/r:ѩV}K&# TJlsT:1SIgo(Oޒ,p[{W5XTBcZJZR^ j#ŷcj:t8KP)FZ_4q݀Z)=OWԞj5܎52.ͽFIiE6:ƛU9Z !vs.0wpQh|ͯ,]LL\#qF.apO=x(Ss} U:Jc"#Y5VZás&ͫӍ:1,y썇l_S1ҹO\m}6Lde{t]:*J4U7͎? rW= 4NV!ZXBѶX0{XVHE'~*qf*L&W װףF3eJ!}ySG ?: (hmu#:u+b(m4խ۩V $XF̌U_79 J17NdY"[["T6gnZ[UJu4Ty91 NUo:jJ^V}{k[xcU2, ϖ03~PiGUXT#K^ݺ \+ЯƢ2~\p=~Nq]XZqq_2Roө$RۅU^szZPVO27`(u`H>_oY(G:_"ZX6jxi&6U#PKyݕG̢MO׉p4TT} bU'$ wrec^bҏ4SмWh'J\;cefenCƗ/ت5S?y̞oC_Fd`ϽB{u:սJxv]۶gXKaî2@'DZ犅N=7cJ>U] v] z̋9{U\rCZ[m$r(\ϠsT_])RǑ{3"YB61qδ:REyF5;jblXwe#v ӷ^;V1^}#ƳqN7"xYcd",rߧ~=yi9":~MZͅP'̣9$d\JҶ;18u qqCKu>ڴ):m]\kwne!  w˞#3q`ϰsrYRk}ʗϗ8XJETGo}ta,m6]2a)9Z>֝t*syBHY_kdFFsz]qT7I?&)D]^O̾Dk\ %{L2Siy?ӱ#IEmulc>W䎩]::vʑd;y8ooя(C`eHݪOۗvr2UUᚃtyqvInR3m4k'8;zQNRVM[ҦB~Rl%O?*\ҕhy^GX -T~y cx" UihkCtb+.>e9\6jqgW5*haWYy%ӹI-vT Pbyhf$<ҮjVV`;-9esf|>P%}9qHʷ$zmS8{=?0/eXجklnjg`VէF4Z?P5JkI&Akv'M~y jNN_ӻFpOM2rLk#u׎;ZQ咓79Ckw1!oWe3,j:c{sh3/q\JXHJݹKmZFF#SKiqi4*]G.-9?Gm=u4b_GxZWi_1y?wy։JYr94HZW;[нO$lCe ܌U*2S\~SSP-OMNrc]8SG\sG-g%|$˧>o,V}TI#榜r֧^/4ӽ"3z $*ǧ9<2ԌݓԌ5znNR;`o.IwHTF q[VNkCS\Dh;ӰȮaXYfV/qӀnuIZ1|ߪB]?y zqֵ v|Ϲ^GUT"8
9ϷNw^[nAզZKб#X47!'#Q}_fuV,+"2BV>_yy㏡ֶt**iSWIkmЭ4β\ntjo$xUQƣn/QS#wOnyihY`VXج]?TaFV;@Q}3ƴ:I&RDRg+YƕHeeo2XI&H~s]fҭTouSij̯aR'Mҽl 7!Wf^h͹kQ(n4}3E'fl=׷m<g!{u+sa[ᅌ6zUNTotδ*,Dk۹FώqӵU8<u&}-#];[Wv{tXƟB5*I.[˴ι^[/gN6Z&gF]ˏJ\NVo3fBOsڹ *U)uo̕&pf0ps}p9=+ JPc*t}}n9>f GRsVQ9iyl$Y/|Ss$dFF;z9VEjߪ-iw6D2oA!@$ZѕTk=WNXea&fe$q8aTaބ~Q%nw,n7wK6Xۧ SF5} ;=', >)s49ay\TܤĐL+K~9ܜڲ*=%k>:s^E6syܒ.'ӰkFJ<*ST5õE)eiMIKUMw+ytP7_LFrG#9NZWKqXF$4wIk.}9Jʌ.S:0)^ aL$7'/E>YQޤ^U5e'Adg ?w~ɾgnJqn=UCR:jbs1ܐK$s|"x9"ыK]N:ҥKXX%ăLyr7gaZ{7,֝G:[laѩQԲ9kk+2^ds3w^qӍ)*q__wӧNͮX;vf23 kR1M] ,V#+ˈ! ɕm+c:I.:&gry ILFKl jty1R1N|'4/CFA+jPq,NչiE$)ԩF魃梫FWwV27{{XXج\@[vu%Rcͥ#$.2oPogM^28Tnnec>ۛkҨ=@fvC[2O|S5;Pvm-G Jf03ӿj:tyQk~gl0Qb>\[NiNG~46_FQ8;%S$afFT$dl`+|sl{[ tJTIss~PmVb+xUVW߮׽Dnmqkq~$rFi0<jW4gNR'nHmoG.8 wҴVv84pnmxYh# ~yYT.2)T;&`[vpZձ صנ\ٷ*Cnǯnխ>X+Z*ߡͻky5ob*nTO#4UnjhR/Ӯ $-f lҠRd56Jtl롥<=:{oCm4rKA늪u+T ҲziSoniߝzJTkŸ|u0*n\ʦ;eۂ`W 8˙=,T=VYn8b"xZڵHKTW۹RT`zu֐Jm"YBǷZ|Rz~X&]>&Sb(=1J蚌~EN51^KlrQŃ&"= k1ׇRvcVG1[3td}$ Y駅iSzd7bV$sTr`7&e(intT-l-xSoȄ,Kmo'$r>[8OLiF.Rj7Gu8`yOI&.h]m=Fr)Pңnwنr~]UxdTᅧ*2A  Š~TݺrF+Pz;rEfE!C6Y{}Hk:xy׭ekCe},k˩[1R^P[%ݓ+=Lʭ HdVd3^ԺZ[[^E Vӣ2E3~gaًdg9ԗ4?N[IlB& 6wcVZ#Zl?oTa,!I$Y䜳-2|U ֔'SI.qiF%ggؖS[-7-=:qׁXaZ=;.mn;-;<طE&b#סJQ]*xzmdK$4rKG31i$9<$NǖK-[nIheĥ zg=\}bJLγ3d턒<ս\qZwԪ/"}Wu2I O[m$+nk{7n#֩)%ktՈ,2|G&msNsA]43}w9kKm4Zjs#y|<(ZwgDO٧ dU؝=sxaF+t5Pp[sx_~>"iUM9T 9*bTnz;G^Zj1z,%eOkF~<瑂3Y5)TףsN6ON? kpN%S|#XǖiIJsk>1\-` ۰8*ʭ:u}κ<בmZGy ja[QӮOU9JR_ϦNR4UJ8b ʪV9n?m sOY~GE&#/BLm޿[rNZrt.Z4m.r1V5=vש(ʽ7%n2ZlcX:@P媔d#F6)Y_B!WHcʕ? ׎0qڌNrqSzI>~#hݸ[bbϻ8Ny8p*cRUwGEJ4jAN +T9fǟ_Uc8?BnYMۦMάZm-~]YF|ji\Ttܐ$fePzIQ"ptV6,D=x;R~Ap/f hex0<95&jT]YV?1Whn@3V匔]Ru}A]eclɹJ\eN߯~yk̉n^ߤrD`Yv= p)]d4~]aeVpW߯1nRt#f_#9ji8i?cEJ;@Ϋ'ږ98yUS {8_%S:+ZޅV?vf?~*%En2Lm,y¶y5}b6{^PUZzpj~i;.zj2j:x{(^W&5'QԕrMS&d$UH'S~#Jӏ*[ogi*Ɨx(``t8+S칪;>YYc\vI.߇9ЧSIhiBƱ*JtLe{[VIhḫH"q0;Z+%Rmwuo'l6Hsr9t =ktdOc_ZUA*+Vڡvz]9umȘ.XEh >Q6dqOs޳GsEKOF\Bd:r֧SkƕRz'&+mފ\LZ+r. $U֝_}@3VP&۝-?_}*zWv^[ZU47j8m ׯ={v)>F}\iÚ6ŢbxܭVN1KA+"&QMʿi(˗byey1,ohHlpyV3wK:Žabp㎧γTݛ37#W#$żs6OgtE8O3y2@'Xc# sTtIro-mj+X>gsq\)9Yjk:T//ǶMy˙-,eJ40u+Y7}F}e?x8qzkўuJn5H}ߩѪn*¬{$8j9N:kgסjjc̔3/`Ou~w}-rZ7>KIʋ,^ṶnNyNSo",v=[F+.֔dKg7)fIEdRm( zosq]MkГO  T yX_3JQqdW.SeԐyNs!G;c#88ӿwG7:niG Ǜ+)d8^MISw#V5Q-$"1}t+:qV:%*5)IَՊ t5нk?\R/-RnSϹeTy)yg(ъ7kiRȟ t%(O2ܮ8׊5%2wVM_ )KUЅev.Ìkjԗt,BO6Ȯwr2m81JM'0aq7-{'bkH#t=FG#C[Z>NǧXY-[$!@W+.*{\om%[P{Q}YՇ*rniۣ YC#."@>sJJ W^5N ]5-efH6+S5 L$)J_-''*d c6Nrȇ5$p[VWٵW^W1ygHFxavo,8RZs\xwPq\m.k*pMS.vp1\(Os2*KvcL/͏\p/j}֗Cٹw pv0~YTP$$jh' 4RaY"K (qwJJJJtc/k+wo紞;G"ۗ<ˏִӓs1![[ xw[+[@9aW<Mk,`t1ư]ɏ6]W&VQVLIA檕*_xU뷥alUWAr'zNђ_p)Yٲ>PJw9Sqz-oil2㕷Mi!i<C sQY3V*N[KK77#}k'C0^ Jrj*SKmERݙWo:z]>EdW >h t,~EУ5‘aoY]owaJӏϠFz>[g Щ>F2[pD(ͻ zt=kxF25sv}-e "$ehR0G91XVo%Pd#T;t ET24B9ⲕXI8Jܣ"| uֶI].ȭZUOl>Tr|(_VMhmNI[#F7gw^JZPv>FNV28E^Ic:0w8NpXh+r($ʹa[=UiQMo-Nѣ ?=k>&2.` }Ӗckshe+u%fQ1r:ҶN?)uas#q y>g&M.*^lȝ#hX[+#W٤._%w~sVrT6O#|<]H[wۢ`<$U{^v^fF5gLel\׌A'JQiߕ漒Qil K$_G'Ts?#<<-DS o(u(:ru­>g:K2ӷ9b 2C(Tz5)_-ײ-ZU\ƭ>ǯKrj%n[ BC`O*b+Tѱy.=8ROk:u"vKORP C bv c9U\2ZHPp%rYFYsN8j͍[hRxQ2JDc5e 1w,Y ZY<OYےͷn TF;^dMjfFS&Z5'1G=yzW4嬣+Q?ݫN@t_ƽ=G*4ͬEyf6# 8e۴*9ֽH{{vIlep-yyNijtв5uEos")2uB9ɖ́Z^e-6wlqXg/dѩzrwX` Np uzUKs%qw!q"IU6G8}*e{Y2$n'w(٣.XNfI\*͹V?U.](TGbŃ"=(,7nYWjO~~ft::jV4JrV#dbȬʿ>l>g*>&M2ȣ{mպ9_=3{ӕOwD_$c+XƢ?^.2ߩ!8ß~_J%,a}|Ǡ?~Ok[y<*ѷ5?){HI~e8WZ^8<uOu`+45 Dcp㢞0OiMrW=%<ʿ(8ZԩK-/dp7,Q 9sk]O}J&GiYnLc*RE"7WomګY+;O.5?wtR=?![FIŦgQ[qܰocz1VZ[D(ATi{qepG"Iwn|^:ƥϖT&Wr+\~)—<=?.)IRk6yLn#>XOg۠]z¢RSSi2(B YO)IJ1J0caex6qƌ+zKt;vۏEOݽ VfD (zp~֦rІc.1"{GCޢ4o}u!*FR92ޝRM[~%[3,c!x>-t&t}Snօy.ZL8:s2R鷡1h]^]Hi6F3;d#&8K[lk8ҝ*K&; A$U#ʒDʞinB |UVS)Y){o";)fˍ|μEȪqIjX&QUݕl+uV-̒ 3lԜ+mR,ybH\.;B+Y:KsG5+;i7eX{og9(o"3^$gHymn/yF2Rz2adel|U#2!٢K9VdیÎ11T5WE!%8D#PG=>[۴ieOn:~uUm)]z|&3Km,4s>[KtJ"XǖIm8#XcFJ͈ҵ3Y}jyِ]BXO8U>^i)!+0J=8޵|ܨs-dD ڶ{V|ՊY-z1#<׬@ZlM{7;hOh̑U[g‘:Vsva=+*3o^:.Y%\;nki^5ǗYԏNqѢIV֡ S$ .yrv86{tZV&շHm]ͻoqU{5(W,eh"o2ԁ4*7*IIe"SE9H" ~V)bZђmʇ4GVX{UӋ՚{IN^ȖIwUr9W;:|mʄy) VTRpnR3^+8ʚnƊ4Ɏ UhZFv>29<oxgM?x!q}5b܋H<*1xY*2l9eǠлe7ͻzgGVFV̖Y^m;V rҥ˴[ZGo1OƣZedl\+?L^Y9.ȸ--e4k$Ʌ~\$y_S F?g [@cǟ3j-qIJ"ЌqX¶ܜ0?:5&cB,̙EtK!}sSuF19v7ŀ _Uf߷t--ͪVhju3o{?< ʝ;꼂F]!m/#nLeTGI^c:G3s{Dy疗#W  ~āz{ܹ֒RNf0A]I8T iK*Y-c'&JQ~O7iF*0Cgk T|&$Wb5;Z4X8⦤%压b$Q2/ ts%"8\-sTܐ؉`7~fsCByiӢ޶r-ȩzrZ1#1`d>[`w c7eG#q!nf6H^Cu2\os*_uW3\3_@@'Yҗ#/gNUy0Uls؃ް*rڢSo߹VF /nF\q8ⴍ>}:ZMy%~<$Ҏ\ ^DO')uJ^.5:t}H@=kYyӒЇȟ*'osΪR\2="[i ,N:ZFZB9;ߧb8F~Uj3"IcqU54d*tı*LU`|vR>iޔtca%RQ%QZKm M14d.AGUWb" ݮ>V>*FQܚcZ<2-]R6VSeeN50u"{Mʑn|sL{ڮy2oN1ןRRʚ*w\/"%XcN/51NjIby<|\U% ZeVjV_70L+ ݔ1k%S(v}mPJV~9syaiO}UQF!i}kN=ԃwVe{xሴ$o%V?[#ێߍi?xG-5}}g#T'r>B z䍥k4j7ETGj%qwwMDI߁GR2ߖԎqmK|d0GN;KMzK&N^P[ÍλBU ?\}oo3, СIVY!L~P=+GhWSͯuض[vvm`=N5jF7KYj޿؄IW ˌqϮ)<\JkU -N*ӥ~W-,DF:]]|嶴,˶6VA+}kKєnѩF)YE7GnB(ӏ28)׫}%uܪp1HS\e{[ۙJquNch.[a8HVE4Qem̻G{p33*az: ݱm~eѭ]ב,Gd1½TRzYR0+ 9mSݽߟR-\JDyAMd=s]upR]]ҍ<* 4ulvG$f8ߵg9ӣZ0'M,REvЭUrp#{m=;qҴr1}7.)ID.H}uݞ@,=XU |}5fnY9u Xü,{;zsRyjjhӧ쮝bhvH0@yEyQR5iS>Ѝ[IckDHʌ< [{Oh6;yV#;Wlk5ʶ3ɜW]at/N99:WM=W3t2VGxDq.9܃G\j8yŧkyb[>NȪ*q]e~?iF..m)o],2DMxJ}@q׮ ?A7h>xʲOm ,{c]ag8X>K,D[GN}~@M~8G2X$1[S8nZzK235r\j7'\*jBRN.*tge,@V'&wl|`t?/Z֥F3|'ӷ yZ) leQ cN* E?i%Y[Il$ .el29:"qT)1 DjO~ѕ10`Ɇ=F9⮓B7_ֈ=ɲ!ʱR:E)VU*)E^D{[K:\~ޘ#=x%8㪷?*74q2JMCq׌u8*DgwFQ;4۳!dYF"!GF2q:RT}?P\ƥUKe/,]qq&9kT|BkŹ:߽g%9{},:ۖD뷨Ҥmj+nEn9{tqWVڒRl=ԑ=ʣ.v<~y?umiSNUit]}t,lN+hYm"9F6FI$meg:2vy=7w2;GWkˑe^2<6: zflm]nYraXA~aq,2}a9)bpWCRZXlQ$1$d0#ԏǧLqҥjT)J=VVSwcZ{1JD7v EĦ=Hcbڧy{:u[iO8-V@24l =S޵tkFz>\j'6cp{?±\czQۃD1GměrWː l y'qiN1Pw4+4 "B+Iߞ@%.ugTZ9a.o>)cdfaϓF:p(ub*(kaګڽ''Hj>UpTq.T5sӕHIP\˥.䷑=TraP`?tJe~qKsiY3d =xDʴf,EĠ9Q'(ղ*hyd,rPsFPpZPQnl2EJ!U@NI<_^+N_zƤcE7/TI n5CW*+4ޗ(nR8noUx9沋'cw/dSfYH0wNY(O0(sS^o_[O2Hfc$x[?B4_O'$ubYVQVvʶ7Q߱ ?,/*pb1Qږ&K c?r;zQuRNm$_ci.nkZ24[E:5_iKؤFkFIHz>:֞ҌPe(;An !>n?vЗ:TmM]I+eG^}~Q˧3c+ˆ!O&p`x=knWm8ʴ_:>Zn7tz_z[SQ5LPn+w]8קKާF=q]\^yP±~eh[Փv9㟛#Jq9R}z<\oo*bK~E*:.wtv9P;^ ʨV Sd9[GrUQ\Dn{z:ViJ%%}܂8[vGGl7.kcJr 6|y, @svp=맚!ҨZ5tfxSێ6 ֜c+;R\G<0yrnRH৸ШǑݝ4`Q1UUE'9sw9iW"9 =/.mNYӊJ/M ۼj2Fndew.l.T -ϨTVZJ|oeZa uN<}F2N1Vۘa %ٹF{A+81*VyrKq,vJ_9?9J5lʮ+ N>*\$6O}ɒK`rFzgmNݽɧ*ʊHl%Al|ʹu/u=t*n}w۔ qo#^܏b9KeQNuN}*4n 1TTmpU+98%w$(]8cT7;v~JyU(t$H̲q'symoLrΏmQV~_RdV{ycX$އ DvL#Ni#c  qt2jl-z8J\PK xEE?6 =GZcNO[0qjԩw:[hSLeSz4> [y*d |c-q)P֑SӰV&3ԨY5(mDmwZ8c}F1NJU&꼗f6[ncRv+|`gN0Ӌt$Taya$qZ.eŸ7QT(.Ib%kȷ﮿Չ#ınn\Aj,yloab)Tk[\An>}j%=L5MݼwDpUFTn8뎿L.^QRE#57Tk#|ζLӖzfFO!r+^8vFj5EkθBf~NｓמF aS`<1̐I`\)qDsS~XԍNEZ0YG UH()ȕ>Όeث?ϯRVRJ#kT=X᣶s,YXqsҦNPUNcVymVāwcon;Vu#*o"l>#سiyv^ 4\VPwXS#,SC$opx<\ܮR~FtJ!ؚ9,pHρ8޲eQg^2I}kg18;A<gQ-3OwRk*®0=y;PR7*'~L;vkϙR( s#NQ}lV#JH!Xur+}Km S(RƎ"Y{I)7lZtb|@Y{_=eg+mђ_/s z' _HS_+UIw9d"<$a*1mX#1>cJNW#Qʜ%L {6#ׄ8zRqDuz;$p@;޼{sP#~Ub̋* F9#}+ "ݎZXE{"]0t#+0N^:Yq[eJe]_2 {c?upIy5Jݴf=jMKu񪽿b.G]hu{Z\W]Žei8e{zj{G.wnRSIi}5vmbJҳ, \=j*>H;Z98qv6ʸc*v%yǮxޥF*ܗvRWֱ9v?,vw9HJUU2%𛅎2ı˝ҹe.ԣ)Q4yr6a:cNrKRUM9|nX6<ˎ+iF+RuSEJ6lCt!V s3^zSѿ.zr|qEp&mtt*ҧF 'Fr[ѡlVٓU1s~T涞FqU9튘V&XyqS,E:\Ӿp#}$m"FVId=po(lqSuӒzK?rmW 9>TutS^R&}O /+!*(9]~E98V^_/NU"ӷOM6V@Fd|sN+%n﫳:Su!k @KmgUHƦ"hTkZ;q Is2ͅOs{I{8+dUۛeEsu$8㞜}3ϭgQE$+Te乐3]IͺfKqO+5(({~^U(I]uvny$],۳7~9V5nӭ][(ʥ~IDwn85zd'Q}i{{_B8A5 x-c-#RE1YsWT/fӳmו795Qy V6ی(+)ϕ[m>[ Q[$ n`fs8ԡ~FcaZHlh$rde {ʶnyTOo/:\bX|1VvrvHXm<,*<3q_r0}zźvF4hoQV-ş1'pZ{ISҜ.vܫc+c̖96:O|qS,=LE8/hVmÍƜK"6$h> q家_ѕ egRQ\bʗ%03rR'<;ىu+{NP+GffH? UFuдROOc1]zОݣi3/g=yX:XВ}֭2̲ȫs8=xɭ#&B8iTI}\!ݣeͅhWs}=+X{}>"u1t+M=-_ȭl.>嵄qFc\=zS*jF&qW Cp_sRCnmq~'88xcRvׯX QZ6buoFEaZQ}w*_z/d`cZE'$8ޥJQJfnp7qg=?Ʀ"忪rbyn}a]Fo;z"caWk886OEo;d]9u$H͹GE˜<0=1Ў}XU).o.oȊ)tře0s+arXs{ jaQ^oo^USRGr,Dm#0' 秷UH4ܯoNU*RKO̚$3 F<T*iӍͯo"-$eV2|)ۀ[ƶF*oRqcyYI9/{yq\nH&-g{tֺ c$t$ӭ2ͅ??Q}L<+R^[ͱX_g&tWCbY! Ns^xmd֏]C8b0MnژcUCI^>c9?mbvU祾⽌_8=>Sk(*Fl8`Gӵ]Jѿ^5'rkwؖʙ$,%~@><'=֩I)5o>]LhO}/'řXYv7TdqjUIs8ïP{:RW}# NgwWM_+?xZ3YN魗bY4[/;`~a@%U-dv^қ鿧b! drYLGCWM:SGZ8TȓV y+m^CpiZͫ֏$"꯯kشL!RNz<0w4jRn\N <=Nc<>ѓmRʃgsoVQ3)QKge"dI$0y<#}I=zW*'W}[wVSF.V]FcT_89ZJE֧W7Vu$sUX-k@ppF'vV3r5NWRZ-mAe3_ )rG* J-EٵtS#+Ion~O{|gϧtfetJFc>j_.|ޝ~ʵ~oDsƭm5YEjѫ=8Ԕco TE7 94bNms9{YBMgYE 5*̼c1-Jxo׷߱^Xz.w CE:ϛK-Ho|?ZRR?4FqpJ̊v<ӁYSz+^klYgôdFP1bT=sֿ㵈Zu(v^dZیWvޔW+;N$Y8ly/nvHԌ-E՝}i22,HF2AbG5KR>Y-dVYjZTV8e<ªӁ: ov޶XZka֑Gf) zs+R;_7RRƬE"RJB1n{!%fw#G*N5U:)Ӆ(E]?C#J]A=1YU=XK5Rjem[^!|yVn?JX"mZ4sYKUn7n?]TpWg){G+);$80ŝv<tAkc<^::~OLh{b'V9}jkvZR^zX%2guR[8e֫eN_bEqi+:S)?ySOp Nc v{)]+ߧR\jVpJnڻz6HyBӻ[g_g=qat>˷cƲR5 ג5ȅl[QpOi{/u?Ds[%@B<`~?JWtҜZ>CbF_ħ`c=;eSjW"ZE-vWN>ͧ$SivFΉi+]ú8Qww(Ɲt7q-Y^FMmS=su21zq.ZmuZ܈e4qzcιC1cq rQ'v3qߥ{jqOSQ%bNB$-L2r3޽n(ʜ], h6ĜO|diSYC!ipN7Ǟ<?0{TUGNcA-QK|6=1VowF6Km4v,z'<3 Z؉gxZd}q5.wTyTRe0n#T:rJ͓*u-fYI#$,{p7l`2(27Wj3ݍ(yVí)&+8B ޮ·9FQ/!ͭ su~_g?tÖr lQ (.[:Zr)nk(l6VA#g*WzԪrGsNzV\OuJ/t.\Ҧޞf]Ӽn>8-Zij7/w[\=7HQb-e ؜}ko+ *|~>~f.6-0==~W:qob_?C܆@W$mǡ{WZ?֧RUo[yj;!p9i5ت)6,˨I<&bd$sWyFV1K3eB"GaHI8ߩQPtב]ʫl"V^USiTco9'59ӣhm]yFJvzz_ PK{!3C9f2ΰFFpƟ'SMv 2+:w5VQQKO#g0#V^}|5G')],zYFolk|4aޮtk7ђ8N3[b&֋R O1 !PYxөe*߈*I+r=ip 9g-15دrrCRַ_DoR9+ek㢶[wI7zņqqN"yM_<`wS} ƥI)I̛p|G#g}+jwU68):.d3Tтz`:2I_;^El5bǾ6Q@lҺ#YTE(\۹88Xny9J#usN-맟HnZᔅ|`=UV۹4(<oP6?{Tn^[+gpjR63y[F@\r1#_fyjKX[Gu4;#϶3[TԚ5U+J dY1[>*W4,CISp]_N 6*M a:(Ž\݈kkżCB+6wS*ٖeNjjS/bub_U((I)5f[gi< dtEjq& cJ̏YYF~=9FgX$e1,q/ǵ~lcޕZuaE(>^NM2 yҌy&xs\[gVpsu)<>"]JkvVD$\ԧ^1J~UFvmaUa'8LbJ6 *s^MuרBmRC}ᷓ۾k^5RQ?g[&x˶N'J*jݍqm^˸طC= sמyһv<Pz}%Q¢}\F;u} 3c޷EͭL0x{уנ浸$OVLrt=E:]_)ON2:D[4Ryn\ ~cUQZ~I1/7ܦvs.{c=+r꪿s(vmV8h|dW35*iz>cΔd"pVha r}kJtI$1'=~8?'dƸթ-cҜƕV8 ̐1#nW>hMhFnwx4uTw|q[8Ԧs_.t&U$ 'Ȍu?ujw׹XG5H/.wX aڡ}TJ5;UzddnYT7@/Oktdkm)&!mh"aOӊu*aӶ\ʎWpɱ]Ė}OAOۡ5?vOmE ZIYIP 0%FZ{ vX`yPǝB=@>r^qJo-2CuEZF$V@;8փii̝u G]ӨjN ȍR/sjR$^!]Dړѧܘ`)v۹pIb Nh1+Eqҋ+p/u䛩26[\ ?gi #9Z-LaQJe+\=w>J~8=XrcV]U]M~>?JNQe:~GmDVӌ5NT"jV⩶]lF\I:Ez4]Gu24vDmzn`C+(.۴ >֩dԩ^k_$X~wHy3d&H 3G#ӥhjXyFmv~dӤ?8lie r+:xx{?r6Sјg$|եt]4\UH%bk>gͣf2O&vF33ȧ}1jK\*S =_`X;cTU(8]i{QG-_^P{c]Snt^HɅQշ=}kЧQ#c%M"HiP]ۏո]gtw*leE8}Ya3-OӊJy~gdJTX}KoH|%Z@y{:}zC/mt-hܠI'>toZMÕ:7M-0?*r@EvR]kOοؠkvXh4=59gTӧw_q"(ߘN]To 'XۙV+읬^L@C<䓞{Uԟ<ت/QlDr"}ƛ@^=] ha5p^;`BJ)Rcz>RET,<"R]+.O>}H[Xrqw8?j!));*қiZ"?Ɖ)]jjhhH< "rw0=Xgz)47%&t$QF6'vq؟s+otp;ZV鹱WM%@6Ѧ͌z?QZB.̣%9F,dekwMSH9Y\o vpHV{)h$oG*)o>s{] cfC'~b  <*6-z{NhMMjSo<{HHՉ~to  SfuJmJ[4aX? 1^:z-U9B~lo+4ʪˇI}:}sZF= ds"+;P3קjވ.#?HT0&f\{8Q=?.{ԥ9r[^pݏ|cnn6 Jlۖhc%v8 j6][sgnq5ce'#\|2Leui"CebO|Urg.nni;yefPn8_suبz!"&ԍcn>X#Ӄڡha-8ZQӍT\)yp3UvPi(ԔtVcΑrG$>oeMIm娒텊V/;v#kiTe̟ȈDa'ʍ匶8Y-V=)(6đ& 2ц 4n3Sr }.j UbKo#"qo}9=e:(I)'z+vcmG;zURZE:t⹭K4pY0qScOƮd*-yF(T~[WQ@9Nia3*+7 KX% =:έs.YI YzgiV0ce47jIJDpG|Y5]It>9DX;~9\zXɣ^ 3:Oh掺Zn_ОȱFVb۰_clVMJn2UV:[+ sҎg(N5$fIl"H yFz8N\)JFݼ=<7ߛ8 NJ69B1Q<щ`zwOFЌE((e*Alnq۽'`JTW4ѓ i&SQ~wzuQF1ro)J㭚WfP x:VʎwN\ndx ]~Rȥ[%?)rtFnKrvIAYJhU  I$Mm܌yK@4ƈ~qKbb'##[|qzZQ\\$lm3v)=ɋZ$p&O rO֧];NJ5I}Z%ṱ)˚-!Z6fNy#~Wj T*F=+єߴ(7'+s474bƒ[ȼ/̸N{~*n߱*Ǩ$P6`e|]bA{cވ{.oȖi$V'qvO'\2Ȯ8l<ciֶn[ExOɹ[ɭ%gsYF5-9XgK[%p7H%~?rVZT4GĆy];tⶨƔyy[붑-p+1]u{mh>f\W?73ÕaSIJ_ב-lx͸+/e9ڢP}w"Yc9-&㹉(=~igDPa'w g'Y6D*> 9G*c)S֞@8VEnϽ9~&5#f` 9D<Μy~.Fv=sYGFHIIWQW60};L~HQ#@{I=,.Zt|ц3RKRݙϖkWAkj̥lzpGTJҷ}B#ۼז۵=TrYJTR!sG)*O̿ xu10]H' x K'ˌ"zCKO i]yrȬ$s{TTjiuͳG]ɝc#jKFs^/#3tff'w}4u[XeHSdmTgR.TlN?DT妹{.gF{':~{ܮ(Ս~sI/eE?2#}Hʦ< YS}!IH||ܚ#EM3H2,rp*x2&wZN۠e䴲\3sUO^"=Vhii 8#f pꤞq8:5%I>ku^nX]ÂۇZ#Nݎ:U$%S $`zұRu kb `WR 8c?:R,:-&T^!ֲGzNl Ԏݻ~UJ>W)ɱD[e jbG@8 ~OVKknΊ5#*{Y|m928^tvBʝD}odc\U%uE_:|Gmܻ~p37kԔeQl9I,[8$ ?5}sE~G&#oGf_1UM;B6ǧi_Ljr ܗ`wVDlǷ,OnRrKj EHԇ{ɦZ5G H+5\i[o2-$xax^LoA>Yi9_хN4TpI'xUc?/YS:y_B]m4%ʘC(Uo1AO=_{[ܘrE'}~L]P#~֏ 8$w:ӎ-دo񄫰~T\:թ[7yOըҳzyЄI" Q=j(ъQK]s^_sTO1fQ ۺMTO߾ N0 2i İ7I"7xH#FP[nM8J1vobŜl$Wh]hTSK NQ}<,e@cdT։]E)Q)Y-ؠI2+"^ҕ4]JRNkhӖMИœoy 2$ֲE fu#F?()F\ݯlڌoN WCXռz/ w<~U:=+ZE W[4aY[嚹4OB[Q{CB2pn`%e W=A=S5Kz_qVkAm* y;u)ٽʜb1 SK}2IW DdװJWԺM}Ö$vguVҒ&hwm\mLmҸJӏz[O(FRWb49\C1ST` ~SA';_m]U$lNq!#$] #ڼTkv:gƒ۪K%ْd_]Ó'WNcNGjvQZLcEJnPYC|Ǿ8p5* Ş%ʾc&qz{tZT_B~*׳I9"gmO?smg6&[2%rǷs`c'>r"2Jw̑2,/:wK $"8i+ihnriVi:F0q޴"و5T{gT7{Zz.2o"c21+(޽kUhɩvGug [//2cݞ <9VUauϿJr_j5"} ,fDUT8R18'uCa8|iU*:KT&mf*˻.U\ۊZ~EKF}uy$"F#;G {5*=[,[*\LXV9rBnUȡM$ItcRq7ʥ}DeVC"AFyeJ.L=*Rwk)Yđ̋$f<9v?eNө]NiIk뭉"Hgm۱>gC+s*M:ÒjOTT[Ӻ]Ռєyo4jnר s*?32%p7W&VP#Prxө~e`+Fj 9& rm<~_s 4SкX &[v,A:K$vp9euR̖ghT*MZM_ ]1ݹFKz_C8{G ۪$ OgR:u_٬/o>1]0KPKc>jYFM)];Gw*y8,ۯzpZm)Fgg G6yXz ukԌhjjqV*Z+:;I\]݈QǧJ%9s5{-ocO޻bT)JI;`dn32}RazRS=ͽ5ŴƥC/@8q֝iJ6Q*Jr 6d2ob&@=|VuΤU4}_c*q_4ܗ] 'V3JkXъQaQT^l$VGm|xԜ}cF2K[iC.sF%7zO®f?35:v_˜|"Chv{zb0ҕ5R5B4FU~U8O {8œ}SGnWc$yq5JھtG)m2_fsZSKUgNw[X%yݫ3+n8¨:z]jY/Ϊ8Z)szl3 /T 'NB=OR:}Nq^G$̚9+Vۉ{d܌USqnRwM J54Z~#qپI66Ɍk%+%ąhM~V|9`t?uQKN+ k)'k N77=OҴ, P6ҴۃnP>l?Q=Qi U{N_$=N3N\[.^4~V9xx>ǿiԒ(Ԕa"LlK.TB9~5TS9εKM+'קȒ0eWd n8=jqЄ{/$,o3q75c?45(.dVP'f \dIJ}07cG?֒VRvfU+si_|V!¬N8>~[9Z+ u*,'0qckNW-hH'dx,Y@80}kJ|gޤ#'zvԉ&d a/D-5Bc.qJʬJ߻p6Ʈ597*OjI%$Q&@Rz~}lQ*"t|t5$Lܭa!؅T^G9R-mFWȭotGqՑ;9=?5fN^Ƥߺ ihjYaUQG_enRj`~QtId1FpG +Z[)^e /nŧʑn[ 9QߛcJӔ(EDm̒Gv5oiGVo6CrE{$tV20府}==*ʤgi'ӏ& Fm_ 弑O2fU1ۏ)=vfJ2VUG*Ks:; iӃzSMJ|<. ҵL1^H=h+Cg*ͧ~Eys\+g=NX7DT5دvX+c=2FzZS= xxinOԆ O[va|,Cc#N:t?eN*gRP|fl#ui"^?k9Vsi|(ӗ+o~AǑt_X83룦4yA"I3@30 Uww<j.k&r{EouzM›YbGc*n%j8+EkDBǕ#uVWԪ="&ᰫNAB(Oi+}|SIdAO5cUG<Q~u%R4vMw߼y|te-mTSO]$p,Amc< <ܲ b=K;Xq9~rdCSݓ_BS1 4s.–;sVٜ2e . ϛ,qAmJ"m(F7buXLpӜVwrMNq9D\ͭ O^VrnUE~RGQXךޝJ&:pMwtR/>bۆcHzrHӅ*UV.M8tG k缓CۊѲi"xV'nAԺʍm3N)Ao|hLMDVuӴ45;%tKoF,2ӡt''=#e&"Smj qVMp̹s@ֲRmtL(֣ _?B;56Ygn?1YSFVVۧu8ӕoƚ[Yo2CE裰 7zCU(γ(/巸mBL"`è@\WNKEkv3M[_n_:#,I808#ՍjqOhXחt5k45gVLUx>luX2+]yԣ,E5Z-?A,GM2i9ae/9o{>Gwϭ1퍙y-ߛYb/SKt!J+pҭm3y^ָyqz}:+S})ycHK X@x'cU^p5k' v0@q右n[j΢MY~G$#EOhzZE>M9JPm/y m,6n*ː9AǸ]r9c3 VrlC4Q$p±W?aU-/S,i+qy=3]*s=3{X>rBO*baNZR,h&4XLT c5YAi*N:.ǐ ;vdNXe(III}X_uY/ۖM_1P3 ֚Jd[;iԊxmvq׃ֳ7'c[NH8;hЖKx &60FGҶ"M`JHz0IԢh-UآDu46@p޹St\NSnZ@.$yŒIU#V<5)j 5˨M+G gּrΗaOusE꼂lE[` vzuk+mqNԄF 򀱆v8ֹqgOe.,͂zz~5RofT%V1F>|,F5MfN.4}I!u2+\t^2I>5K{uھvVEX[mr*ܱ{? TǞ>ӿ~_v8֓TT>a v1N@  g]q(sǕmUߥ^SjNjWí@K <5̢059hU3ym61Ug{t8U+{oqۋKČee30ڻO#?iNTS2}ht U4ѷc'i`q 4}OSXkmw}gk$m Nl{$NU"o~ҖO{oˡoi ^NWfO9nz{ GuNZW* }܄PPks8iFU%N0l[ac'w[NK͓d| gt==XoE(FQī1l~O_1F0Sg~/Ԛ9nXQr3szqWF5%̹ڎ/ӽ~VB2NS[ |b"lH=Tרܗ$};ƭ.Y>Vlj} D66, v@{u*Y+;gE8֏4lw+ZjdpIksE;׼V5LuZw+ɧYͱZۿ}:bT/v dkZNpVv]ג+ٗX&>aBQף:t6imm{9VnhwrkɤsZ|<.ݑ{NZi&+{;*֣avyACVk u7r"U^#ӚXzU 7u{21|ޮm.^ÄW)qW=Ooδ)۹aNty5bm*5em]tFj-W3ete/gNVO]mg+Ord^G8<;= j˾u:%O~J2O]^# ^@32|(HRvS8Gnk.ދOgs{;mgMXOhۤG]$@B:S*F=kCѣ5rlmihmc"#Ug|,'-"H;3no3 񑃎Ae:pҎ|75J:km楲O'iZҞ&[]I`jJ5Xx--bkjT-VqcksE]_bH^L=-Tn6=<.siI}Kt]=8u$7o}Un{7q)[P=ݧqo;^d$е@s0x9ц9'esӕHŹ]̲( l22y1<9֢]\BKMK[dvRP+CΏpR{$bfx!EEg3;Wrrb'ZN1@ɅE<Ǐsנ/gOv+-Y8z܉OfHbrNg6;K.#h٦I(#<IaԌҋM=SvNukR?ik$ #[XUefܣ"0^ϖ |RۢB˴* n*|-0HnmNonZ1r{uVF={L̻U6e?)QggڲRJ[kNUet,q 3̡Qd,䎊N{1NPqkVڥ6}E+t܅Tpwܲ3͎z`\]?3*jՒkBB*d&  m9tӥ.hRQT]%,#imb W$![z_BeMƲl]"6 m |'/a)T涋S:QzVDo1!Ue$ p?Gҏ~QO_C8q.Ė^Yo1[jw%ѵJZ幓d/`g_]wBZQ+F[sa#mϜg7.s튪8z*{+~;K ._koQ4Fn k6>}i([5 )>nwܠ2gsSN8{J{&ՎKV(N{c\UuO+_9YqnG ==?°ZJWs!e^(nC22>nG~kx\?T6!HKb8Ur}98<5N~ʵ޽Wbq~D"qԞ;F-A'ҝNF׺QKrѵԞ9"uR,wmc?O4NMMc>l;T1nnf G0g-1ۑxT(G_X.[1 r$j@feČzWDumY"Rb]{%AU3 ^:VD9@nz+J4w:#!{+}3G7';Ri-ULc{$l'tT z~4UvZt6jFk2'n{yMͭzpxsuӷ!kH#c21p:G@{cRZ3hb%Z+%L\%fA;VδUIt1H8GCuZdB)xzҾ/bC cF-w]$q4Hfzq_eT^˖53‡u٘@?/~HӖ쌫Sj3W6nVϛ}_AGZRQR+ٱflm6/,=֍8Z%+yat1.>7  >ƺ\iV82XrNyX_xֱ=$0RڮQR乖֟wo&Sl{UY 8n^[R%OU ]PFyɶ@KFؚ!&:tyb^RlY0ǎ1;§ލuh+!9ZjmU89%ͥ=Ğ{b/OrՍEea42Hn rKD-6˙#\C$.z9ǵg(ǛsHƚVəѲʹX>%(FKaBL"UC6cf#Ј'3lKg :8{Xqfd_pDUs>cӔ[ky!Tv9W,LN\ux4qY{Wc$=/mw0 w5cNI8rVsagw^Hn_ʾR?c._I.fDҲ4oNU?iRÛFjb60 g*1e_F*r|1=YA'gS9F[ԧB8M#`<-`cb ǵLijm+Þ6ķbVKS.YGLquU(*ju;-oGOȇ<⽏Q*8\>u<ʫk*ɒNU@ˊSϵ%F0cr/@a G1SN6ujhO^D"R!Dr>v<*yqwD"k[xóme݆s߶g(ڋua$wTW D+B<6?9951:[a.j1QRLV]b#SM̎+:vn˱qS[dۧЗInUq!@$8[FRFo/1֣%WѢ@(۰XpLQdиT_N?dwSBD('ɫkZܺҥZj>}VnV^f$d9ێh3vSq^k'\Q# g;z՝Z3ײ/ak; sF^I)E6OE XZG̓23m,fuѫQԔn 4g'ld}+hӧy= թM a2Ck2.#==%Sf_ceN|<8-ozsYMTQ4NC`[o ݕ!YHSuc+:Τ}?"FNZz Y|p*XiPѧwau'YǛva-$ŨQHHО@'He$>?iʕ?!̒3{{T֕I[^Խv9򉹸2_nr?1DcRjw\d2(?31m{ңFQSJRI+u}FǏ1s{GU--d!x&PC.Ny꿇F#Zކ5j:Qpwjc $!b09>*Ö2ZoمVҦ]k#H4 M5eO^LSӱ)1$ /*2OQqW*֩h/"!MjXI`YU8v.:irF S a{M?SZxm5m4扭Pm$tNf՗6F+y aV6Vu,v+hR=W0W(o.7+\^uWnA\2:s{zEy)I3|zr3oc^*Tqَ5?/ҝOe8r){/a7BuRn$.emoJnouiВ6.%oh]8򭨸N1rF\gQim2[[.e m<榜T*I߸*KG-FD%x`߇[V= kn$2]c"3|JqiW{vGː0s&Orr2pp3DaM.?R=ƨ~3gOgnWׯ{z ,mAb5{ۇp5ѫmsiGrJUmA{f1$*v9 =NkL-*Y=: 5$]I $N3OJ8iԍlGٮ: BUXʆm#`V8|ҭ:&ѼdE "0ђ1=iSu$j5K_=Y!7*c@ӭO5$e*s^.jB\e.R?rzv۪6XFM4G$GFUʀylw?zÅO$ d屓۽sGԓmݭot2e8/wkVdhwm`1`2qZ?BjNB8y! 9G\u9Vye&c*rY|5J)ՌbtaWBKil;6G9B cN1Yko=?ΊUmF$y;St-{>kK;[do,E/$cZb*JޏoovoC2yqD`.7`I^:h]NHIk5[c+̲_y<`];ϖ2_/+Q8iQR6Ս<{Xԕ =/.iGKgUf۸(}: JF6Ubӧw}XYDjʉ,y;d ѤIu,6!S[^II¢Va>ܐOuZKuIXI"a2F }ZZj͕.W(r-hcE 19ޕ(#[vJ'.InV.{!O*;hnc-ZS%nѭ)$qGcw͏ִ ޽NiǑo)wKms U`c-mbx'<k ]%NQ`C4Fx;Gzw"sKTuʱ&#cy< dҧ?Bet~mulW:#R;^>_DDAHY»)ߕ(ߛ]K&[iˋobv==+K=jTtN\\a>ֺXuFt&,eN8<GG$fg0c'J&SJqhKc1d;wG9qӖaV7-]v9 {{Pfl߸s(V͗ioRo/fkY3Qlt$hp>QN09MadB;S旼c(#y3~~u]Nt/+d/w6mTj5F//#UNYv?RqNZXkf+ W :gߊq]ɧV\ۆ4ٝgZ-4:ޒgnU>]sLkR`4$_kcq.3sJ{4WS 3ۼʙ1R.ݾה+m1=sYԊiFH-hP6aP <;J2J.5̖NSqUG݅FN,{Ҥ0PGmgҎ^i[rg>TgZ%8|%&YdY cRAH{f8N71. K!0XOR$Ӫ#nB>fe?9}Q*$SLk,`6sߕU|κqTַЎWegU˸cpϾVkXT:g2>jq5"nQ0Y%_rY<6sJrKK\`ewyp/>Zhls[|.zԩk1 H R\g=AZعJQ"K α[TtWM[kՏY&v~j(cYF]-7.޿!$qUKQ檤Ȳ.!$l>_YsZITR+o)##Zst揑̑%Qt>Y5$MHJ1xd]˺M X}:V斕D~~hdr!rEۻƼ`s汕K]~"W}Jlk$j_s.=֝ID<3շrg'xKW{$ĈfGcQrg\l* se.>Y#hĪޛv3J2 g jd]tdx߭7e9K[qH# ĬK/n;>sJRբeRO^6#==V<Ҍ5F_?/tזS\VUc^p?</jt.[?QF_rv}z'Xo~e/zq"L[|̛8R4n6YI6[Eq2ѣ"˳8珠Nc5}!dE@]S7MYSyGdV<~>cbRJt cnĻ4'N;SUKtuI^T+2KkXٱ#8$=pMtTq1MruvӸ>WYV 2TeqbG9%(KBdf9_1Xl:jb㬗fۍn̘D~nC ӊ_} v,WHT .^zJ'>h%9ǚŏ;s|ު>K&iwJ&9L cS(ŜVb2xđ~a+dqۧ9zRb>1[YY*2yetc*2v^QE-df&-TL1_ӧR>뽉!(c_xpF<.rpTvֳՙѯ|i$1ҟ.)r7 U.XjytVcQ.@$UfGv9*тwyQ˞o5>.>ƒLTqR@2b%Ti ,?wP?yPHtmA$dB+Sz)"KwگӶ;M} 9RvԎi7ue?W/[J.ȑyeAB?1zٮ zcU6!X.C\wqۍI#o}{绸V!dA4cr 3+'ר?^~CQS!ŽG$[\d{s׌>(+J.J;~k6ݣe)'+PFW4\v2$8s,X;u%싍Jl#v`OI1gҴQuFqiʢt5i>RUs-/{;)'Toݮ y~=*6f|ە;C4i|78i6LMThG myUBI/m*wL!inhw1[Q*ce\բҒeV߻xoR-_SS+ғr۝_9w:azhų'~nTȤg#I:1RAytUU݅QЁyy>{5uh*d7'?.R҉L4-5-b6^9V,_+84wFfv-+(:QSݱ|WlY$~B|*{dz+raMʒkm6*2rsב)F3FQꊭ{"DA_έK1T}e|1Ym)J-%- ǰg%@=Ɨٜ- dhl*ZG_氓$ t\Ī(`{gr{*Tna_mYu3*&X$3Ԩ7~'mɭ6% uRu>I%,U=t{]lOmoݻGq^ݽ*rq_В0^{KUbzMgRylQւE/#\CC.KMfyc 8${*jc[P(V]ǹᤗwrsx҈U ibRV;nU6ȍ>^>٨D*js$I*#[з<DI48S=B;xJl,ΪM]>Y-v2Jrۿ)Odˊ":ep"F媲'h#$sG5:_UHaE*O>b=J{Hr{4?.?_ESW~Jő-Y&R%IYMުV-Q6sH軿q;?*b.]oa@ <;(UO{TYG G@0OִTh IrTZ.O *'vYF*g-HQ)o%˞NzvMa !bcoBJR*c SфAa FyBg*oߚA/ЫcVejciyTdwW m$2V*>^ی] yh|H$Bc3w{zhN̟mC٨f];WD|{h$NY^)TN7B^?4F0V?Fӗ#&)wp'`TrRm8%oj_o\9ѓ<ڵ^KecHYb$g{Qԫ+UMּݺI.$bʻ`˸G^Q~]5Wt`1VmxZk¿7|yFpsԩKY5,K pIDaq#ԊTJ]JG{ _&=Cf C$Q9U'+çQ8mIeHʣr?RTt "H|)ldL~ʗ<גC@ND{Oޓ 'X:|өZe=1ܢ #/-v?֧\U)^̊UQ Q͹u=2j%R5_W)8m#f3{n5R7G:i%Uinۗs+u:Pߩp VSF`)#u8}k7MBkgx\ivU騱_t X_l#` 8DF5 za)J״m:Li [.A8#MjU:r\yVuèWܒTl|A>zb[]8l^#1JZ>~kI>lj/#E68 T_C%׺l"-@|=9a'R[2=-KuT#fp;hԔtv+[cyo2B7#y?ujW,}]j<̪%mcq鞀S5?u+̜UHƴZi>'6=8~SFmE4sca"=:f"֡mW_q$L[,oکnܶH8ʺcKF ,D#=7 d.>UrGCYTQ_nylh#2ϸ=x:Ve*CqwZ_]ശQ6݅s{11M+}u6c)\1 V4gsEF(!:Hn9F6*x=9%Wy9m4\~;j¼yåH򬮰ztԎKØԩW% /+oGe`Oqh2 &v@JiS=;/jI#*ᝆJ$.Vj]$RU]#$$MVXGI-wﱥIajY+m܎ Ϊ띋G}~(ʣIvΜ]ץCFJ;Z*cQ!=k70,lmF4 qLI/37V%I`*M/J[}c*^ZE7Limܰ4i8P1ϱQF2抻_ǑT^,FRO3Oj5W\GL5N#đ-7{g^%F5%+QwRC,3YcPW{9a9:iueĎ'V2ilg:G>ƴ)]5֏4,Vo:G2eFWfѕ*؎(&5܃sӵcN*=U;8vKMȮ'fnBW2֑Wcԕ4JKm5I,YZIw09oֱԩJOShAGh%C<'jrU9z+osy\䖭N[ʶ>˙No_?BhHDC̑cJ@F~ibc{='w9VM&,o$8˜f#M;ܸ]{^EeKX+i"RަvqWZ,!8L7gJ6Kokuq(..{qi/isv{-b V*=xV)G7f~^cm ]m47%hPt?m(>iΦ"\ߨae&Yޙ*uJMz~iIBڽ}<#+!6qӿQ9ΪTWrݕwcrtONQUVN2GGU8yҏs[n=dieV6BzjuTg/O[uo YH21GmD]Oc+>^GO'VqOM-LD2x =kJqkUa5[}nY}OU(;yu:Xش `F۽RF+XJS;[y(ڗ ^F Gֺ}}k:rnemؑ$$S,.匰$u⷇4i>?Rek5x ) $jGUs>hVT}WT^ mBr̀2}>դ}_s؜VOPWotts{F<deA#3Ǖ~uFTkz ֨ALiq'b8۶R:ͽyU#iTmnx  1Cyw*8E&אEu-4qr$~yFWZ:Q lV Ӹ=+H򳍭T'>9&o+5F2)RU8ImfoMПB;s]P*to/.~[9:oFA:$W2djnӊҜ%7tpԔi'SHIJ*bO מ5)oxhoث=ĈiY'zg~5:TKhu8nJϹY Gae## T`+YYFGNV]7b 70Cc!AeVˡMU׿M|=mQަQ5]7 φEe,[ws~Q9Eq ˳s-rX29i(>tͨ1_pSTo)aXmjI 񞼎ǙRSOAs+}#,ef<^玢2ޟ 2/Jmqq2[$p]'>]qԎFLdU[+mꎬ/NkR q>L{p峓L(8WjsӜܟ"ݴ(UsМhגqR\(tp{c3Mw6M*Ǵ|ssqTRPQR\7~^1U6*Emr9--[h$Is~J'SIK MXO$hP;C gڹg(J.~vQTh%q@6,Td W'ȥNtiyjrЛʆM2 a',$#29#1rIskBWq,B˿=YkzrdXk_)/$'(ue5>O(ӗ3ҁt9^9QmczjQ׭=ffW#n9 -.kDq)ͥ䖿xMs,vZ2xr1֔἟m*e=wœ2OnWtjYw` Z7Nrù7mPxVedJqƜSqJQ~Sqw8ӭZzH2FO\~iJqi]H/b@bY$fKPA㌂G|ssW(Gv&Skrw-5fG#nǐr_J䲧;jRNUHdr8ҍJ*4jS+>IvG!\-"J`@B;Fy%j =I7fy"imnd-}=X֥mo2anqޔr{9ڦ#[;FѬPy95qvKK?hXe]ɹ#+.iF\I wSneUnk.eCV6kK2g[3sW.q T$VTaFnhس&ok:ҌF1J-٭Q*DYQ澩$5rGͶ"XZQ{֮F念]U6&sӞ9ԗ}TT -[ˎ|D]Ŷ6?_S4'Ȇyźμ"+vnsLW%J`zz9*ԯfYb%aaA=JQS*8[z;a[,٣O\.sJt(=hI9.`乗%Uش<# F4<בLO G(Xl<)QRҷ;z[Dr+~ b0;e$ov3=J|W[iT`CI,`NRT2'Ў;.xn~p~^IOq]mC_5Tu3.m [nq*:u#$նۿP)84$77 {չ*mS(ЗineQ%||EpTewf4jI-O)b!uL*3b)SQNf֧+_N1G}F:c<mʼ9J'*Z[ %խzd]cQM(>eڹc*ӲVz]-GJJsEfX{ ɹۆ͇tOO?RjN<o!-+uI+G jq'ޅZL:mrF0;k+8b(X+b)W5p8,f_!|NRN|i (.e$bxnZV'j2zW*ܜm/+]Nzҵ;ZȂxS|U3Z:r[o4Q/g%5[̑'p=q6u/+~^QRTԧF\XTtu},{3NFOP1+:t׵KZTgm[Hx6p$8+^ΜWsh\Dd)HYWU;N%q5LjRU+VKwenfs8Mw Y7FV;rx#'{u9jto3G(ҏdȯ]-ı`˒~giQ^f8tN5!ޚs$3Ajm[KMC(f+Nq*7Mz٥#ѕ%S _}lks8mEpH$x8L>Ǚ+kw{ާ^h+U|:]e2pL:A}GnN[qRh@(Aw(SF[Z}ǣԏ,tr쐂+BT6㿧ASR,rOmFVռWKi#RFҝ9:R헸﮺mF9246̦>$z3dG)6&XП$m]Y qC)׃ӎWX[6r,'pU EJ^Wznj>|o$FH(@ bCLcԔE[욵A A:a@x(T]?'X\T.Ӿn<)emm)dAsSYʲw?.o!KAmx#s 31UG/i%o_#F~PnmAgJ,p7[魗tL>B*bVL8lC|zM;qpkEmog0F*bUx/S?잕ZEB+Ƨ,^Dv/b}tF>rVL$7J\4`=@%jj2U8mԒfmaƊ|dð3\NJ-ʻzuT4'^d=7*۹BWRmYȸe20|$lH1'Q[6՝ߥt5o޶ݽFމU6Ո xg8W)z8rdL#yUGԳVIXuo+RV4x Zrԧ<8{ӧq/ڡ|^Z0dc,>n^}?B+':kܚ|){ܞGC.%T5MJ#8ҦVռEZvn@:9-HkpфR$j1%f ?0jO/c[h1Lmrs5ȋb]w8rIM__Byj'Y]l{{J\[̊ 0$~iu=BVTSijG lZдpEkҥJ1c4ѦA5"Y| rXXOⴧ%sjb~"*2XdgJ R”kF$BDȭTV%>o@+z4a6 C<ђ$qnۧS'h8:qr[_ҝZu ԥouev۵P2~cw5?{~ Ei{bKX{XVۭ5i]s4VSC4ʧt-r=3=*Qa{7Ӧ+nR]̟JtҴp-#?`$PםFW_y<'̑Ȥd7ho;NyYe*zhV gК2UAy~_b6}c]R|RFSF6pս@{-N/ F@^0yrخWQ5꽍ϵUN01CM/+Ϳ-=MjJXX8n Kè36fhl䁖uDkC^3B{{ eYcu>dz=Oi; Ji^j[̢Nt}UqȬed*_3G),2~=5j=ngR*嵽Hw.5P1s]*J8wȷW:[s%A!};A{V_Z\v,[:k5=דH7$q>'(+[\,iۨjЂ_jm309UJVv'ZN^y*#}ʝ>I7}:U*V\<[={OC]U01wv3To}cKyxc ~=GW^8ƋOY8؝рO91=X-Nk4}3%m2}q0EL)я[-=Jvc(<<3,,cR(e^'U2+e(<SMӌߢFyo$6EfLxֶtjI5=kG`Qm`\r1x汝U*r/-Y'-OA,FۓQtFeTZ'`kvKL^T-6EdܙO޳RXMo[kQ{okc~0Rjt}FJ?=y=rI=֭N<>0fG yJhZFjqO_2h#i\3r?z4yj$N] 1mRqM5 TRӕVOo84⢯X5{== *uZR{6V"$⭪xbg_&.#'w=_]+k{t/*; 6 rŻk.  F1nWCzW e9 Ӝ¾ NQ^>Y+f;Km]JςcuB<d_=VݍɞZۖWz= &ԃ1OfsϹG_,7b6G'&PVer5Хm+y[׹}5o؟i7-Edܪ$߯o^|S,%/1/^ubTA{=oWҪ^;V}lT%Եo]42qdx<Gus~$}|ždӓ9&QR/X]et8ƢQ@cɍˮv.@h꣮s9Gv CfNiԹIӓn$Q+bw3݌˄#ަQ-3gKHR')y+RjYһV2| O-H cUĂJo{כ^16Ҍ'z摢}$3sUWѾQGHQg,'6NOX1H*JZ,FG$GG6>ks?=6m8*iYKM.rU^c_#*zMw81ZT{QJy݄$E2GdgLםGȢriWQA2ԟ0bL۱17=D1}UB:5!˵L&`qҲ*ڭ<=t5D52%Y"㯵MR;IB^Xqk:u5QvH~U?ϭi[\whi+w3Ʋ:Ȝ?T`q϶F?cS픥Fu騻;YM 2G=95Ε*4^FztkyR^+ʏ\ed)ܚ)F*0nl*1U-_bLPܪiTn5cN[U%NURKH+k׭N++yC\1A޷9‹qz^Қv0[KwVQc8 Sm[Fiԇa~ԒߎU9r\v嶍Σn镼 dp;4F2u/{l?$w^$p`IY`6;  #U w~4*qi:("iIh*|d֜p2N1ڔ}|@1~Uc,n5-눮,l#E9TrӷDWq˰ȠļqMMT۷_֑)Ei%S؟\VrruKTb#O;DHmʪ ;vʕ#G-J1U9Zɶ 4PZH =ju%*/6XUjگ6@<.|O-i[8l}}1[֌,>:ү'\%&F{kY6ps  WgClUe[1Ҙm`mvX[tޮ5*S;/rʵlB=ƭ,k1rvA ,ufҫNkzVZ8"EW!pOj뜣jw8Jk2YrNx,DdM}9&Z%GhcrYQt5n5SkNFkNY]t0=}zffu\+|WKԟLYm9F=VI!b7a$UݳKcx:j{sF"Z5eY%[!>llpGⱭ *W˺9+r6INނ|ONU*TFޤ?oGʲeC=)׭(ƍ7/n]HŸ*kb6BLc~ڜc?{]6$ۿBk&iLEm<~׊ƧхBWE+J'eܹ2`s֒ܚ~J+e*9Ynnkg'ڳN2W)VJ>bN =(ӏ~GT]iǚ*$K]C2"hu$GVŹoaNd4]F d&*D/\IZ40xW}6H+5-|,ǣzRg?siT:k hB4H,,a۾di{w}Ro# kC8 VTzۯ_ի8܆-1Z ݒ3*(.OR,T)Z=|HߐmlHZa'f:ujY;ĩ$1/ֺyjJmWqb*QIIOR'JIVf'*I=})Kp5I-|=o1jEJ>E^ݶzh}Qm?.p83N/M;͋*j.626 ,l&>b3;Wd#:8Np68M̋P84'+WnV:.JڭvjUd#|b拋[:nT} n|Y{RF#RPјrE4el˶2[9k=oVZ32^Viyk-ɸ}݂‰(g C pRq}:s\xSm-i#oR@ 3(\guuF3'i6*1;~_PԹyYRptř?{Gu#oJTa&y1&o ΌRmj>Zi-[RE]] T=oB"5 =Y]:աM F"\\ đ]yc^G:懴YsF;ʅL?.ߺciZ9xUmbb[9]ѕșSFJߠB]aQWF8yH)b%dWܪ@lg}:ԧg)_Rt[zB^IeC<.߮NqVTOɋK^]FfbIISv9cFu<ŻjbNp@ZGG1.f|0ҩNUc+_5 ٍem'ʐqr8O_Ҵ)I΄-iMyyi.\3NYJ8+U#KݷAV4x7GݩTjsϮԣ B!UVSTn2}zV|u9^Bh{zQyӪFayI X?UJ\Mwv9}EyTlhh+UwF8ڶ1QoUgٮDmTܑ7IG1QybȡFj,x!P)ݵ@N8 tƧrGdǒɷ98l~~G.z?P]DY#qcWcnIFNXBlȯݷ#$<4c/uݿԬ=\Dyb>9q46V=}qf=iGEbj1IٴhV%@ a3[(#¤I̡I9F"dtӷs҆\q Y,͖1?Q7nU+te5QԂmmX>hĶRxһi[ +{ofZk{zHjI[3;%#Ԕit䖩m UItgx5**掬:q{DWE&2;撗Z-'4fQzkЧ(QoN]C6Q1+3L旴}zb'rCa3zZcQVnޥ"T?*ǃ{tn1FǚN F4SHϰ3؂{selk(ʋ4s**sJtW_"̒E+QJYES |$oFru=)֧R/ݲ<$o(mpgfUOY2a({ؒ]fhZEi=˖:-ՕJΦOz֪>[ 9>s }5dʕgtF-W:VmBpffVhƶNVC5% ƾY9n`<9Z{ބKݎyvfU\I-<x}J1 V)([fC"0c1Sj%Tos'{+:c]ˆ3Tt_o_M [};ɷ9_wG5N]w$C,4j+Qǥ_;4u%nVnd2}4owܮݿ^[JQ} T\nĒΏ̥~WYrӎNT>HܭtJ\zdEؚn$+`]vi*tUwۻ}!;;>ʮ\$vd1,VW\47ZY;2czKy1c4`=Fs8J+@\Ӳ]4%`$]zf/&DFD]XS1u'ih%IE' XAtdyjhZ֖c#2n@[nw+oTKݍh>Z[Ou^?j>kI+ʌ$],76񹛆F9{ډϱ8rӒonwvOU]n\zq18*d 9h1=GvS(vGo_o,KxxpxXN\R *~[zAO8"+ 9sJ\ 6y=+:mÕ5qǵx֔FJZ=4kh i E+Ӎ8FݎhcUD@;}1֦IE9*ܕ4 2E,Ѱ#3 V.?;mNISrOK%K(tqqdsƤV~BySHY#n=B:)9GPЮ2@>Vr9 oR^m̆)vQbI1.gZF1:4$e6̨[fb}O^LV(ߠ?hfaᡍPT=z`tϯ>FN-%fƻ/wOKjm/vW}QۼٷsO_ҺyiJ+ZX FoUZF]!$njӿ/bMb{m+\e%codz K"N?\9\FJ<Ժw ovOS.h蚒8ri; ֑+48JTe :$L+R=OoaUΕ[En(F)\ ~DeDdVc٦Z:XԌ /2 }mʣ^$SV,u 5Fh(Ea0meSԸDǟj5٥:tӸ"<۳9*-lg`kN%V܎xƪQ\N_2l}*)9Ɵf4j!"RLǶ>yU?vOQ6̱I.}heO-7wYKoQ23Y$?(&N3tiXVIn<-v0G\\@цb0^VսjD)"y 6>eRKϯ(RanpE.kFvS>^nD7'Ìz}hQ˖ZO&Cs,c"(kHudL9$WmpZ#KcT,V #EpZW(^秹AR.]Hc79Xյ8R방bL.UK.ҎǂIs:֜\9s+]˖5hjs󩊍IiO7gتX~ۋ4_Z)5+ -KQVBۜo]Cy*>khs^1~f34Ux]s׷Q)tfl)r'$-=@*g%٤*лѮmAnK6O ݻ6vM2ʷ kipz涂\ƕ$Y-78YnMi]{g47)JcT)qc[sm#)jFڴ=L~Z#/2ʟ#{ bY.@VUn޿VQ.UB rI*SgiYfV\%yF,8ΪPuE&-.WSh.m%x8#s8(/=F1\.5p7ʘ4?txQX\gI^&Yr2NR㸈]6zN^fR6oR-^~~U֜i˧nwHڹZr dxm.Ñ+Q̫a"H#*KG!cߎډ|Zۚ-[_5eA?g6{4Q,-q;Qr09=*6M6`Q3ӧJu*MS9ryeWm<W,l?wN,SoH&UݕO<%ʮƔe:jRKaXؼ#մ]Y:m+2v.>񫓼m#(2ofX_$H UF͵€GXY=N+Lb?T78<S'N,S$|+dw1>iJ:%-k"U|tp \M jJRIֳ嚨I, XUݍqū:#rjIR/媖-.*3BOp2FI!`ێyU*[a<1](ch4Z}ΣE>Pvi0{u73΢c-7\c\-Ujvx9%;c([b z|&Ac~bFnjS| 攣~UC扡iDd)ޙ?B%ˣlFa<;-Fd&㔯w[ . 4ZO3s厇 b姻)U.BS5XO>23JSg }>Јn/c]0S&޼g={Vy|;SYݣ7ѕE4oc>yEs]drt[aקOOdhe{-؂r;nfӌ=V|ҩ|riɮb6vg\YEukZ˽&ϻ'ZҌvV 4Bowo2~iFI˔UFUHYoz/̲D90}zsQ+{fN*5L:%kxG0?CPLޣ|͇h r^_,RHr=!ڈ+hQ9#\RPQ ch|+AN?2Ja|O9?`ԣ/wo2Nd)m$|[pqr3~PIܨJ5fӰ}O”j&2#2ńFwqsMK:RrYHX9#6}hXz)k`bE!cY_vyztzW=H1z;a!Iդ~fGҰo 6;'3nl?AEHr3$"sqx{{%%^+ZP_r(I&wU8޽랤*FnRg-JU9Z[bg}{:TFTTa)>CCH]\|aڸ=rQ:(Rc w̑_9te9UILpKěٌ#\x8>IJQIcNWqkͪ \j2ٳj?RmY:i662I?J䫈pkMcIsw^CL%F3n'oz *w_R ;~Dd ȷ>f;R8<:ub׻cܝx2|+O%~b[;_NUK^w;#QhR'Vl o?eRNEcT\8y ~]Sֺ#RJ|>msSR* qPO$Î2XT*4&ʌ=_td^k ,?#5}iuW-JnROOފI6*t}7ׯ%)k#3.8P *kRRd:qף,Nhc?-$ 168zךrrkVTT}KԮQ<1n `݆!}01ׯpr{VUT*Sr[Yj(Op̷}gcx֡(ƦwI}Ef>pO$ *.\]-jϙ'Ե's09.YJIS=CofߘgR~Ќ*u-Vi! mo۰~:{R:{Ob#)Bi];߸Ʊ4j_!F }#ΜhJW]icMN-u}-mQkQ܋)T+aO$,ю;㸝[f@2N9 raE7̮6AufI-qM(쥂dZ;SZOOX#dEs=VwJ֬V[vxe]`=S] 4}QVmF?' 6 y:9mmg.+LHU#\ֳ'3p|Ϫ;vByͨ<H991's#Tp^KGF|hf8>%F>*ݚa_W!Okk}Z}s\/ yaA}1%#ԩWm{|ูC:?ζTԋKqG5ӧQ\Bq˩۹$gӷCVTT4D𤋮JXMۡռg>cث1quWRI5v!Bg&mdUbI7,ybsgI(|ЕKjCogg#Oq*ӜGp$h Nጔ=q2wN}nLԼT#!fb$\c'ӣF o}WRG{ea$D `9#>QihT ʔ#d3NҫU9ө*̨s:Xh9 y*jw;BJulcuQXhc6l0u֪Og}>HꦩƌyV$pya{{vҹi֝f)ʴpM n bz\c޽Vhݯko$rZ.u[{*yVy >-E s3ni3܎=*tǑMbbeT^[vYƤ*IWR_h]{R98ԷʭRN/CEH IJ:3I9J $i"69?.SNl̤ms,r+q9\scshQ6k)9A:QNdMG0Hb{5$]o3zvnM\\"U[<\ +9=Ӱ$ e`Y@qtV|PƿVj[_HҔi,Rr3I8#ƚo5#F'uj64|ytzJ2YO^8ƚlrhZa,+ c&x gU}ZZ7[JYaag[ڶJRyǪLfQ {YDFsO\y{1}b;_]H{GI]rwCWteO]B2J4:!ܭqFYpz׷ynh쿿c:李 QͶC`#e\V%;?Ck)ZM&eɺFfa旴rޏLycQ'F՜?\ .4բ{t:Rbtv'xcUII_x G1#6RmcPp ?ZUQFMFK蕮~hq#0mUt~Usiv j{vӢ\WjDeᙽYʤcQJorZ5a;VD6KE$G+ՃnRQS_ߨǝbe'䁜 \^6f2oh9c8fc֮4tSʜrKvľZI#dk uױ,?4^?PK`Oʬmc'(ԧuߡufZ+cTHEeH+==:RJjLiєW#ӧi9L1~6fܧQrv"[#.26~fs}hH+5ksi[}/I4,eUo-}^szr(:|GTg[^‹wYYNy$g1+jT㈊oF)Q\WB 忘3Hz׭P/n)eh`e窜z*ѕT\_qepo7˵co k*U$)5IG)!o#nUn{dv?C]Ӎ[=ׅIRsobdw YxڤN{sӊ*lI:_O!-V?5Vvͷ$V/ 7ךex/ۏ~bzwceNN(ʿ*^G f?:Ve~P35N5$5/yDɲw#~f޲3g[(#[=|kЌe~e:['x"x<ͳ!)wo~Q]ѭHG5f{xw6tn6F1\#!$lnS #NQM'+og+ȸjs2N׹y>J$r8h[R2:##ئ+Dnm^ΦQR9B-_ޖS5Ɏ󼲻*`=;g5Q\' Fշ4{fhf0'7.8ԟz4cceZ{kw6д* g;uUnb7u#SpGu "}= JVĪIק(ݲdR՛v3?p8W\cx4iW@D;Wܣ?*/{M}EQ(&wLB3L[,$u =@@q[TcU_-Utخw.zmb]4tO|~r}שR0dAiT-ѤjZ-Эqv^{Y$"ڃ g}5*ai^Z. f@zk:rmRSN/Omyf}\J1,rv f&{v|I鞦)'rSԋo[_Ic{WݮO4>M ya(aFp:gۊ猟- {iwe*ui%g)Kyh8mv$lHx 5R5ӷc8,G4>^)\-To*޴E[Eks؍Zub  mX2q;_AQOy#^X8 _^]f1,1+v\}kTiƢktcRDykY-h :}u^&cIui2O / dS(j9n͗e eIZHQJu~w,ſ0#x*hIIv%ݲq%W*9Ӆ|q;win^i-<0ޠC 曭B7D|lϽsϚZ+w$euN2Zԗ3K\m/Nݩ)K4YAoӯje2.̫(-ʞ)^6Fzܖ0[ݲӊbJZ䎋g\lU ](#W:ͲknkI]uVkv{bE%W SWU{JOKidUci8=*Q:جDt.<"KgW\#\4]Q 4QOrКI`[eQi1M;*|=|Hx#^:,]kѯQַWs|s[J1=33ue s"qZhBS yYnΑy;PGzVw_y#rNOtwW,Dk\\KǧL$o1%$aֱm/˚f{BJ(,=s'ͺ%Su,U'cTU\dw/^7,=r>^TO.Lb\y7Ў})֌>&N?gZ+7d44jfnr=Jݩ çҽ63]rswQNWu4_u*E68 22B=k o:o v?SG$pFm`#>9tBSEL ES{;ěČ>ؐ]Ifޤw%Rܵά**Vw(t/:@BX2>SӞ*4''CirM7T%2&Kݫ;q*ǒRoc?m8sQO4ٓXavSWDW4ߢgSIWm>ũf[3d4Tr^v;R3}W+nW#tG} u1ktkE:cek; f{y cmׯ=Ö<ԣ8JvM^VWhfmc jTo^n.lϔ&-N~9=D#F<_ןZu)ǖqK_=F[%R]ykTeaZrU%͵_==Ų-HyQqֽ FQX0*<]b8c;_2yi ˴+*d:\qxڤ|6ti /A3][7l?4@Ӄi(|FsRA;O /ÎF = hӊ\v<=lEӔ։}:]EHp%RH#ӣR+Y}Xx/}i*彭맞ǡFFZۯ۹^x-T|lA V:QFiy!IwbxuLTNK8.I&{iIܥ:nOCҞ?UvZ_{6t~7*~#3C ~Qdy1J^OF.EriرoA*1f`y*Wt)F\]{}Y=aUD*:cl qR餛oӱ^m[D ٮFUJ$ ^+>6kbiz/'Y=7I nqLBQ_Te9Mwno$T9lߛ>ڳ ^=#TFi{-2Đ YU "F#ӃSV施znIZֿo>#{K Cf?:Hϸ_n:bĨr6_Xu5ZzRG{}2ʎƃ-.r\F]?%Nj)kO$.pBYU]nK p(:u{kS*r~vDK i70}ۏJ.φ?tu^5JYSdOpq9dsӊi'QCͫcNrkGgt5%>АĶʭ4r\)ӚJ36VzTٻn,$7m-$je:gkPz.~bh|m#yº+Kw.\ߺ:ߥ{',g ۆX*2ϝ8=9֫E{4[dVUӌ#'~//qfpέv_>ŸE"IiY-۝Jr: =Fj%iI{m[=p^ ҩ~{=|sWU#8aV>%7Y[{H12Q֎RrznEY#3ɖA i|QqQ?u>ocd@V2̱O}*/i[/qS I+sɦ$;a@7p(NThV.rʳ)V?\g*9lR"Y69ɭJzTj4yIs17-ssa<>"[,eOlW]:6K1Ɋ9C+VՕ%h̲HTo=_ N\~zeVe?s=^}ʞ':*ua* AA1NFe)Ѝ3BVoWkBW*8O?W+% BnXSZѷzdXYcYh ={QNUjIՒ~ִqWtcwŶR~$ɭ FҋVɯ>NʹwXۛ0lS(:5N4INk?ʋv d*i{;?^4*Y?R+O&78;qگ<ܶ1Gj}ZIWːA tZެR_S 3RJkձníB zsSp_O3W Ėo!y$lTr; YU~{5r8Re ?L*R4 SJr:a-RruXN#¦4T+S"4~~(|m5i$o06ǧ45J騩ί*dQ *yxVWXU7Q*GԖ4HU +9l *]ԩe7+/{keo2E)Ȫٵ|Cj|Rm;7}>i1@ڽ@ۚ(s8No?cX4IʹRY1uSN;ks϶ Z22{oݮs>YY%u\Tjޣ2H[Ž=5Qro|ͧ[ = ,ŏ1X N0+߮ʌW,ybY+^(ӏsdK^]/tQ'ݓn\UOr$ASZɂ:7JՎ"J.HW,UwVqTY FZ=lrbdݢ30a1{a}}|浜tk2+#~X郌ϯ5RS]ԊcL/5SLӥcS7oK޿~ʥM.R=q@rsZT\(5^FS)y`rm=998[Ԛ%݉\Dj>@*ʷ5iGK-ij埔O:Ҝc'hs xRI}g$n..ܨKgy1ᎽHԧ9ߺiZJwFVXa(O%WtkV9uMKVi|ͭ$&:˻蟻{aa%X>M%$ cSF$[{RvDIK3L]V63?/N}k:BPWBtܪG̐L9 _LֳM%jsܝ ֳ6i  zߩѣiF:~?quFQ쮬OMlQF&Ykc<jƟMoM7gVΛ{nlMndUlrpy>QR 05tcoqL?뮍eMŽʏ,yeȱ:1)# =Ԅ}wW~W]/TvjfS.+_NzWE8akSI?yé\=\;͵CK6N01׊助,Km ތ}:ͳʰ+agvTQfx7V*|rϾ@Yif9;]]A6%Ruf; q5U*\;KN_)E)^ޞM8=Rx$\2WngF4yz},kFtW̙/O 7Zz2c4iƚrm\Y:Ȳ?0kۡ*OӅ[kFhY^ϖ2U38MzmKGKlkDB-DPikK:qi0,M+.Y#okjpZ G벯_39[FѓKsۖ.}bX# e|GN' Dbw.3I]1_HfePWAֵGduN4"]R__$H`9$`/*im~g/.">e #3J͉޳(={"7yafV`8#^4V[6Ev Ol+TJE^`g Ccӊ(2qbhG22HVFuRI47 "ܠ]f=ezcQgDraVA'|d~SmƜs6iKmcǵg82)+odvw7qF?s$}= gOQqOddKq~R:VկO_O~WZ̬-Om$M(>i} =86ug~>V ա\#*w0WqsGkVNVU>ڜ-Q WVdm}hݹ=}ϵ4]|u7tK |x*Ǐ̀9CJRYU}H1O l3vJq)T#gק9:xFK]$K%gg\n#{Jտc%DmiD۰Y~NzvCPbN+N3Zn jF8UY7s9*9jqa8liLxjߪ4Q!I2;`r0F3j1NY'wO|.A<̹Uh{og9%rI&@ 0G9>F|՟Hbi63ۘӞ>aߧ~Tԋq:|K E (8%{ZW-gU> y=^mDSvNA[KWWF9J.5f#_%gQWf8={֒oPifPWon%Dٹy0hW`zd9=kTԕJq^9[C{e~s QzMt݂VQD؂pGXF̠ #^a,}aɽzyrCq#*,G'ےzZ•9ѺoG׿RiiwEY.緺Yd'h G:M]xUJ5-0ܫ2m zZNrziӲBTjLQ2HD>f ~ہYWiN:ҬRdI8 9wd8ӊwht9S?b) hK ӜuVzRXef/-<#L8>*%i%It*Qu%Y&O&6oa ƪP(DF4yMw/?Ȭ*lyT^$k*4䶾1$gSr=~1ӞkOiGk9yJDKwh'k)sUKMwVg+FKc+kn| #YG[/sj&VV6=47B$tʛ%x ҅ݛ~} Hi%uN՜evs)Q朒2#Za8' 5RӭU+{,:2{/!(uYdž ߞY$cR ʖcC ;|rXrITiTg$պfp^䗚?7k3GW0g}qYTyt3hֺߑb`ZevǸ[*WxTҜ/|+{$`V-++UsGkZz}9CT,6 #3)Bݶ1SJ;n 4vETazVN)EΈBrS~ȈYn5GP6Ђ15ڴzBirڣ?R'YfV̑Z3cN5R+Ѧ˿t[Z#)0 3&U' dcڜ%MKuQ IM]cy<3ÚN5QKbv $,-[i'sz8ӺpR8YJ=ԆfQD;S'se(ԕK⣈tꟚfxLy+ˮjt(S>mnHJYI7q ?"2q\OKDLh'p,@|Z8efz񗴼M,&XVHٚ%\xENdI?аcwʸr9voi/7UvWG79eVK``]3y3ΧWֺW?.~ipC2mtVRK3LR.LhFG7)z*2Ey^߲+QS_ vɵ@Us׎MkiwSn^oDGL&nRW )kINpEW&~@&˪\[v1\vʧK]oB(Ng~a +XlmmX@C[{)j"{iyH,$~_cgqz:֧p$[cfXw*qϮg;Fލ~%QjRsK #NƥmqʗZQw*w6v䞃9ߥt{I]niZOfaPxqG3⮭ѤiR4!+$ ?C7c㎝+)K 3?qM>Vke[j0u`*QtuZʌ2yz2woje(-'Rީao,Ϊ#Ve:RqtNB5eE'ED@ ɮj*},)FS喝 ~\S,gZE[[_3xN2UX^LG0 6 #{ոKŽ"Ukʚqя' a!۞[5R閭BrN673׮acN-A_C9էSW^cvb3Cpmy=+nqj*?a*B\W}Яko eˌ|{v=7# NJ%%GV2rzs*P |`򢏒B.jaӤGFLklmOx)8ɰ#NvvZz|Ơ1=v{jqtc:տ=ABV),˶F?j馪{= qTjVɭaccMO^~8өOߋΜEyvZhLJlsϿҽ(mM%/$عfde]͖X3ٜim=*l<_#p95E=u6!g}7,,wwl*PFNW,$*CtUSSck%ؚ dv+ иn6Eu7p˵#BM#xrǙIhބ IY7.UqӠ%)kOB@@pq>ǖO?t**U#̴lullBRѺ>h>u y&bthmUx9_=ͪ*$UW}H``8<~>M<;~2HRP$fC Ϸ[sR_Ȋq⹕V˜3Ṳ4Χ7H%vF_3l|m'4ػ-H7h8R\h5jst+ ?yc9Go(^U%Ѕ%`Wm;Vg{MH1dqϹTmAƯ584Q[1YygܥwR[`#bn\˩JZ)q""ƦF8cV6dV$WG"*m41=w7۷T`~_(˖:v{Onܥ`TlT)[Gd@8չ~Թ\f*P8+d3XĖkvߓKN0hY" H9U'8? 柴OD5|AmU]WZsՕ&ؖYU]庌O\rwz2ݼ}gX߯*oӗJ.4+nг䰒Mأ#8#ӞNUc5%QoR }ʱ`Bɞ ]Qm'$\_NqSXyV* w30;zJ^R9۠-|¶Z4ӖB"ʥgL575d\4mf>cmc'Ka.QڒkdRdق?\JƬyeԗILjqF0GŦ.4O^*ı3UN-+t9rNwQ<8sj{XVr1b4xm:h>V*udor]~I ӯOJNQʣ咺ȋ } xϟ:}tWr9H|Œn0唝jSKxyn6XK;U895r)c.H_ʾ1N*So7w۩mDcr1ϦO󢧻gRRkJMpHmld~\{ɩYdovWxTDylȍKSjiQ ?Yaui15''u' #*c#7Snێv0*>iPm4nwrIPx#'ҳ[iVTX5l=8:WD/4tlE\$Jmrs8+zfJ-{>Ӕ~o4bdd-cee".]ܒ_hcQ#$gWzL~/KI4xR8 {Tr-ˏqW{~#QϛnYY;7ǥk(}_R^$ĺDB̩1WUpgO| -Զnpb}sU.nc(5#h-{١UWӦOץ\_.N[Dͭa3>f&eQp3=kCJ,$} +m OsMխaޜ[KFYI]f֍@Hx֜csUړ4,Y {+WI]_]ju+I 96ekcF*Wߠef95|{:I-`G]#܏JwG5X^bHVVqWBt$AW~:?=-Eٕ۸2s>s%+sΓUGFѓRʩ$7'zu9]{y"ǽqR.7QOSc.[GR1,JRQ<6dN9G+n)mmnF)VRwczr*T~_es(?JQ喤2q |1Ŏ3'U/1{9|+W .˅۸' ΚwwFGhqĶYT`cI|yPnzq|S\:ƌLvPs9e;nW]p+kwmR|dS LF?x݃n<+E&i~_2;/ʒAG 䲀>85rX~ďV~sTԪue(܆wbY.d:֑QӔtІA5kqUXP%۶w1OR;JGQsӃn$nZ3nV;b8EC̔D/=$mOQiOzNB(/ސJѻqCޮIF2 2T&x=~=ҔofU:4UN.%ݻc9?NK)Fu$'+]r FTu9֚tJ1~e7$,dެ+>h-K__Vc=Nѻ#>}kH7Hꌜo=cTJ2Bs9W0\ЄǼynel9j_թFiWrK0ym:dUI Џ- e+{katS嗼iOTe@7,lN1h(([ST:oqY0ƤjJ.EqelF%v~l(OVS:t*KUn{i'HU݆XV993~P̰Fcuܱv<52RjSu}FG%0F]y8W3Ź_2E0H8U澬ƥN]l4JcfS?<\+6Nd1\Jkcrղ8?Ls}|Wt|Ƨn9NSWRU"U>ТC`}@-RxŨUskc oR:eOzk4u#)uиVl1oz_ݽni޷#@c7 :1Mr9FT(/Ь"0_g#לҟg*8g۰A"G#tVu=89\ %)] mgbv Uq~Uu+AD'}p3׏\beN+*6|,xךQr>JKHYB6K|uzV.Q-N)B0vԍPjlXUI6eS6xfw93KSLCXr)JMبەDhG`sX򮺜EHˈo}k)*v$ʒ-$(u%R'4O@rʬAx] \”_Ϸɭ'wJ(؀Ri#ϝ59])慒v;'<;KMœ+rZzqo-YqNQSOcۡ]"V5l+dV4NRC?2C覭'ѿ>[7l˷syOӚQ2Kbjrs(OC:yd[yLvͮ TB,vup^ 0l_q;\{tFM}M(ؐ+HJ4'b+dF38eN |:. NȊN1Tk笘#4woW=A4JRqVTђ,}>KQOFe\eUb65!fmsRvrhӌj>h G!+[Tr1~5T+"R+-j3e1(ђ{>Jrlsau}.4F,q-w)(1~@V|ksJk1fffbVRĊt+>`T*yN|ؚ|tX$yeAۨvi>ӡ&C$3mҲNkOOVE(Dɹ[rcq8ϭiJW8*rʴ`In7/] m޿N ʷ,uv:s6HֲZy6\g~ʜNXԭ*YVbdKOiqӫ't-ᵖLI4**;޴揳S۩N8|膤=]xkg 3qӎkɔ\&gliǗ^C2aSڪrr 8ڹjJlrYU*k}Jw̶C򍤪@-(-J*^t,ՇDɴ#gRy8$d~y汯:4'_5"[_ q`1UJh)84*KfG˻4+/2vb@;@,bS>ej0guIm I$FcݑӶ?5)Ӕ1VNO[h! s rI뜌qui?8sQR"nvo"#(d8sއN8_R%e%.e$MUݜtEEJժEXtҨq+٢Iı)^kU:i]+bj*i;jǬFÏ1ANx-YJm~'x,#2zu"jI+NӶ>28aDPUvm'؞cQƋQmSzjO,]Duf |)nyۑQ|G*T| 8-ђ}JݷHJGp?_Z*U"}Y4Ӆ9*ZXOWb xc8ݑPJosƬQZ'Q'1tvnUY}#NrnUL>K[nʆ\:&qdvkOAE<ג^q.rLr>z]?_&MNRM.ߓ]S"!5yNTIT[rVȎ4j9%Uߑc$ځw:~Td}U*iē<0O:5STgAr֫S݂Isiu֓}{kď|0⽳^7TΝ>h}Fm=ĉ;#rUUH8<9']Art3*KFxh@wO1MiTպ/ Z m* XXSn9F3'M${utFR -"QD.d'8OcIs(zZFM]|B8c6Z5w:ןR*Si%t0SK5vK&f+1zSc)SyJ&˯.G<~Ӎ5jkwqO Ky| NNyYJ5UIa9|^@Jü\;_^sS'!GksRivA[:TfP >>5NK+1cYכqb8ssQJruϮև*嶛㈛Ɩk|Cg'?ȡB;vnE6ukL)pch]v?Z*JTZ1ҍ7BPMw>7f| )?{9ϭm헱~ګdQupZK vm0Ts^HVʵՇpQbxLaTzwˇ\ܭ[eFnfeA[ӞsW GQI뿙'1nxvm28<ӺǟJ1*,a]y8j$zsI-EYxɍz1.^Z8.J{42y+ +?vkhJRS$*[SdEsh֖o%Ă8a!1V©[mpǽ:ZM;8Y$O''*)rJmN8NjYkW}|KܜQ898VN.lp֎"8?Bgg,6X#:JU*NU? ¼Mi}HPhgf$glO*4k=uR\T 'YI#&2CeH>) XJR߯9pyT)^>Imǒ?6]*qm-+QZ1Th1ʒ̄-sIrz)*2G+HەXg9[q}ZrZ- Fd]/ G<ZܲmG9\"Z0ĉͫ dh֊]Y(SWPF _)w̥A=/z^4/m{1bmu2K&ՌRGɮs]7Q2s{"Hn e |[Wc)b)Bc[Ym5 71uYFTmƣo,6 řNP{UUM|RG/uoHDr3@$t#w*)Sj*̔K,۹ӿQ5[?þgednFssPxܣ'voGsйNKkr I8u%?QƟke,;q~yoЩǚ=y{2cqWwkGuߩUIS]{ y;Xv6=3 UR[5cCM=Jr2/~?tϚTԓt1ѧrMƤ$m=srɽOR<ΕJlFn&W2G#/A*H>p;r3W#MY_ dCq~tcRی-a:ӄ}=uөe~Ji~^FnwgyVח7-qЂkcjlRL=|.sVԌV3[XI&e秿LUFfgX}YM[ɎHY~?uF^7Rij/M$حػIm!Oq4ѭ(H1ZFf瞝}Nd؊̐VUS RNJ85)rFIxc=>SBN3voe0?JX֌Pq^O;ߛm8^qZQ?BD|ʪۏmyj*F29,Mi4eRέFtzAN8NT^.[Xun$TƤl8tMnu EJyl3y'SsdMNikF.YT^wnesGRi;ՉF԰dn&PwO?aRJ4Rn]}IVO/lW#9vOK'^5*Zש 7̬F35R?a=VQJW&βL+–9'ֹdogRDL#(NGP~R.Ue3Rpz[AopB\G/ce3Ө gNUmch-S[IZefspz9.ORxdq(I<'8l\ pUA>dIS Deb;5sQԄy^}Gۥ919SeWTi֧_GԵf3,2*@98'FQ2=5TZURִ!'}"rFu4 ԑͶeyx^o@ktc]9Jl]|-m~1U%܎N9FjM~jy~hD &vym ay?µiQ O+ cMI&q,X1׮HJF2MꋍiS-ޏr`A#>U*xOzs\vJJK:,̬R0 ǿOJ)J-IJ=-Ry.ff3*X~hR}NPkc$iؒ|ɚ $ss"+G8=U%N1ѽ޺1\+UN]u0te㽯Eno1WyONyshJ8t%eUVOnN-M9:0:1Tm<ۀY7c1TV~>iʥpV㑁ڳ;|2'U%v}7KdzF1\=Wi(MIԌ{M$NȝvƬ̣}ɬ;KMQ 4ٍX!-㞧9?¦R|J1I]]txֆq"dV Qp9ߠqU*MymۧO^]̄yeu~93ZG݋|||c$ܣ?*1ҜNȮj2fm67io232}YUq|g){6wJ믠K+"-Ϝފ~w'/b:=~.**| 0fߟ1{19Cv<;[O}~_-<=+$Ly#{)Hc~p{VգR[7ݞ~o\Q,-a!elmi[~08ÿij+v{pEkrCjedfY':ۙ_teM6֯"O3nޠZ?W\˷y%NTԮ~ʰnWj1)ʿ$RV[-tcO%{;NKiDm* tOzp"4# F%+BIeZ\ ge8U6ݺk'3aٻcu#kbjTR}NoTZ+t8N9+LTT>=e= Z5?,.'=:ҒeO&ڗ3R2*.ʞ"SRS9akb3nu7oHт?1~e6rwmQney#e 7yjNѻ֬ѧ-WNTt{Ju4oh0dRb>8xWeMݯJ\[/'q1ʆ'xUKq5hWm|aY0 jc%;hk\#Q}]BFdnfV;ps=Z؉Ƨ,b~˷raFRs}H-YU+m+ZrjzJv!̑Ho`<۸JaA6 Q0rLFtݮ-aQԌſ]t-]FO5+nFaX#y$mXtiWj-_t>ҡw 8?λ#J\}-F#hf%,T= YEr5jTu7uΜT~^mO2ڴ_*?3wK<kQnQWa?g߫ : b^1Z9̝1zkɮm_ciRFZ4QjeP *3⺥'TiYuP['xZ529sӿ^=t)i}_c<=aTvvms}Ӎz(ʚ*}R#V4s_wdbp8# sE:1Wz~w/aPoRAYK3IUnuR=Ꮉaih5HCYsӧO%c.hD 54Ў .O/q&9=:ץc9W`VT o˕};VtԵUtF*j\:mdaҏ,r4?y[Bcm$̲~+ xgzV0IqOEeITv^Kn' $oE_\zJe74{o2n r1*ꓫrR ){HFOͻ$@l;cqwLOaNt\&84&9F^ou!xC* ?^=ƻ)rџOa}4^In%b.WǪT/i&̮؆6U0LծDm2C[1GRU[GB{i iNqʕEKJ2JzC/9AAonʜc 4 W(վKe(f Gw#pN2)Fzu^[H䯃r}܇}ae 6ݜlAjxnJGp !y<ztꧢZ[=hӅtn0*:ڧ},0A@>jZv[ѣMrmO#jʧrr1O.U kw3EV '5G]Ti{XT[QH6VP9nǽ ۦ Se w"PwpG?δ[2 JnKtbU؋yާ)~dSIK-J10F7Fہ~#FؼE}U_֣a԰b C 1ן~+GI]JtckE}&IܚTˎѻFBϓpd$tUn64pRҌCm^Fip[>]<<+Krjt7} ɺ]ʅU`6Ns:Qio88ԒsN렰 o2m!9sV[.{]ugܷ+Kr$hq|s:~Е9%Mmjͥvfll-+gs'ԏ_uӌܕӸVTlSF $HKmqs>/8=[~A_440[9SQ&wi7eYXc<׻t+FӳKs)rIЦ˦te9E(E*f`{vk Q%*g۞0p11Z*Υ8]Zc(V2~oXJ=Ti!cq7 un}ý]MЊkTHb3OA3<<&R2f{ap6ګ繨%Q%Ս2\rqt\\.ԴW1UiY%<;s\a+v3C>Z!=:~8bG6"=>ihZAlg]:ĭIUZ}{_5C.6{㓁cI[CqNG|ܽ{_asIjyq1%;|o%%[Ԏ~^_M{gZ mwuEVBꐮeϧOV*Qv3){뷐MDo3G^y+GI+{ըKY]|<_`D  >MUhV΍?gFԵaV|Xdg78t\wUΊrAcY-e(1lyqڧE$>ezXuNvvW"IdIXV?e/#܎F*:Nw9ԵntGʧ呤he9Leӡ+ͧM7ȦݽzykxhEē368q[ƴt~BdMR]4!o7fCmc<کƓԝƦ+ S.\Vih!QG)ƚ;PWөN.5#Vn-%2G$Nɱ8 11ү+[$<_}Ҿٛt/̻g=+K'}bYvltӮ]׉2>4S_;RU&Vyc zaZNkؚ|T7gTǯ'u9F5i/c%;Ǚ#f=s׏_\թ>^롵oƒErkTXE`Uv_J<}{IRKE-A,n\ZՄZt}#IX(I O9)SQkk| Cqw xnWxYv#3Rq{b,EiEidR*0;N=1u)1ZisʚݫnmĶ=h;.I :q\49^tdY {`=p{fcnS[ԋH Uh]͒p2p8=+5cNv_)SD[ٯ>X 0|nI#WJ4d'"8DҟӨ b~Q\~(Ǟ]zhcRUZho\fY>JP=8j>׹Y" 9%;E5N[=%ʢƫ.bc$sn57O}17>[H@S y<8ڷjJ{>ǝS쉰{$?NiE٦tWpdvh $ CmN=VScd`k[fo[jB7~T**sE|Z+,e1${~Rҹ}n2RpoZE@=xy-:Z¥{C&*DQَ3k*RwEqQfVat{w##ұS̤\0ucKSCy&2`4Ucs޺VVaZ1!0Hᑙm9]/~Ss4)7Hgf8vž?QtNqYZR~fUui$,a@+zp} qiq撿[v20>[Ɵ<+&CNZ'o?{hάsFJ8kRS  +ӱR~^k6=jhRNZe}W~Nd|b-$<ʝX7VԾ]Ug^kkJ9(_W>{.d8b ;۟-B8vr9iUR;!JBW2%j9QxŨ܎:妞BIð_ ֱ2wvOZ* PjD;dqmFqoх?ݯ[~DPMYdX'8R*;=ZMywf2rۀPGL~=jFT)CgnjD 28N1X֭kR-fͣ\4dyن\RqKC1)+V|ɹv6Gsck)J4 *|y$!V8fmenkNS|XƏ.eд$*+E)L#$m>eo[] qlYA9/ʰN}uV}ITӇ2KD\@o(^ݺoTjQe4*0鯮6#ZTBefanazƒMlTiC=;YD}^rsJX.Z'R=4^͖(ٲxTp0q?*S_95nOA:"i#8ⴌyzuGݧ+f2ݜ1Y'O}ϗQڬ3o_0s=++|a{~dkFdir^uҲs܈ѝ8L$ K+L3YUzޜߚu#)>RT7_rEmJK"elzZp dRr2fFFfeU_y<|{ʰdiǣ\/m;MO?0qvRPߟf2,'DR=դcaF.sQ[JF$RQkmj%p0(~U9dE`Gװ>G8ߢ F!Ti/q6R1Nzw#];^ZUebrp=zJu*?coO/9'붫% @B6^cf*u#I.[}:J4~F-ַ1'[n?O횩JQ*3ET\WhFWY(,w`#' %'mNz!&e\y{}Hj~T(wZ.~)n wt\XZn3ק)VU~D9yٓt7C޵e*rĒn%uE;Tzֺ=?kժbZP9axȥzz/]tG]-niNISj/Tzرo'4jL 8RW.ܲum¡ml:ح(~顩ro(W!nYzi S4%^B[!65EKfz1ܻ~$ !+k%2X|n<)~egUvBegmM)8EH`XI) NҽJ2\莙THF:+o.J(w2FN2k3FsJi~Ӳ{F ?!G ; "x3[vF9e]1ȭ1 תIF0Zqv#/])6Wn1z卥XS&#x 7,-9;֍b{Q]u)akpG攥ki[Jj۱$Y1V\v֫12戍ͷs}i>emޯa);den6n;:HW3ۧUw%Zi4Dv6ѕ }_cTy;agSg& tI>mܲBU I͞@> Ԅj% Sq) 7``#8ٴ9.kh2ϷT`XzwƧ+F-Ft W r0}j{ٛSo8AX#i_-@9Smm4N˩Y+|RNt)6hr\$~#ۖ>gN11qks8JjY=Ivм;%RxۿZLhQrOKQC؊ybe%4aN1a\+܋}涗2NLR{&XsF$dlFrITIoja6 nj2ZAz?gV>^z`ҳuK H7q~2qu^D" ˍf7.)J>Z;yo>Yp[?)Fs)<۫M%0y5Υ&c*6RF7 ׭KcS^Y簆F!b2`<ݿ wN6;iѓ2cLZW- c=\S-Ik2:O2k1;?EH-]:pVwCX{jI¯g}M [e],~{jZ1~qs(,UsQJSKtɴ=@:sh惚Qj1"f";2~pPI*f d(M8q=k;ƚ b,74I2XgryxZWj:i"bC727Z- pl뉰h$TjF4_2a4,V3'=ެۜ._电 ,gYJ֩A(ّ+Ҧ[ I[KW,vhTRoeO"c'pjj9r_Cx֗*ܝf}-!v;䎽:麋R8.`8UuV W̏n?iGSIiSDC$q\ġ#ǚ*sJ5dEo.4D{^=*^-K ^7u8F7wz=0ڬ}3=(z⩮g$>L_Eu)E\βYǬBрYs+g>QlU:1WԖIp6Yˢ%thtQۂm##mXS\?}ĀAPJ65u-R9ї_/#n~X(=xԔ/(qo<#wЏcRRENRj]"!QHۗ-* JnE%MP)$\25Ԝ֩&n723O dqMEZ,U!(k6Bnz*rx&f/0DvÑN*Y{G)r+_ ~fMd֓QP[4m~J1Չ$T4*n7~b\\ ̕#Q*~ yGBdn0W,9ȱ4v v?z(Xiu*;grؑUɅ:rQ%ٳ +s=?zu3u-E#0=*RSWwCE#) >Uєb䯨F1!DZ$| y*k޼|r)7U_%pzӌӹ8s6 ĉ":ǾEW<>Sтoa\YI3+K$rpyFU%-9"EY%YbUS$GLT]cAܠaJ5~z "x̤t=kNHTUDUF{Tkqʬ5C Uls]\U=vi?26*yˢ8'S< 0H tfyGi+̭c`䌜|׊єWouM(iOoDEPpP;V~ܯk*\i2ӡV!V뚩$ϒ3eTH_*ۆJǷ(^8z)$݊9gnNx'ֳu7NSQ ʭ7c>Ğ+"RVܵ?-(XaTyқ9Y\RU*xC xǥc78)ԥkْǽ#m{SngvNw׸,0*;T'%37ܴm#g9oGgǦzhJQbv $>c&ݘl'85qFGڔg]$7LsEIsj# iazUSQ jd},:wT6Goϸ?Ɨ]>rA-3gjv+8+&4y+ #yjQXweQSǞ*2{?5$ gܲ2ћO(kyA<ýMV _4mM3gSi ;6ޞf5{ ƱefPq?PN8.XYF﹭Hƥ5r4iъ[ P5;G|{Q.k_aC1wOXAoi]/~J2#Sp׹*e2XnWr)KVAeAR,A]_uy762f#jeUXm+ڳ|]%N<[!(r*8g'=F9{}ɖeo+j坱}OZre)5m IJInIA=֒r4iNCXF2JљR~s׭sfԩQ܎FRQɹVEp+d2[cg%OO>̆Kp"Yc\`cQߟ!*ƥ3H杚H6J7(k1ߐum*\ϙJܑi]% gQ&G,TCE)ITZBS" K#*g֪:6VlrrǑZF1ql:)UoM2/=H=Sf4Q \>敔H{ҿesiJI*Ztke̙o9rqHTdهXr'ۜU*T9cɭ.FC?1>F'ة?iQYv o*r.jPӼyufh,vg}a{R=r9-RdIdhǯ׭g%([JZu輆]4ot+>]x2ϧNjJQ;od購FrKgO5V'-__SIc)j%=|,m\+}7uǦqN4<=Ts.A#@%iɀFq\/7ڰJQ-~Cdk-GȀ_03 GpԨSZ9 Uԭ(0l v\ҳSvs˒%z~t1sldsR8ۣס~¥y;=:Oo5cr̫76@?:r~JۿVs:u0M>hw$|PX<α;h(ekz {s06'sSRbWg'UYHP#~oڼF9ֲˮ:)Ol` hL([6pn^3R,5~DʝGRQNɻ 4 F_γQZXѴ IjPl\#>@kjJR)+>8ƥKijpaVI:u+Q۾u:45ebG]z{)b%ɲ߷9[C~"gIDvss~PsFRek2YZݕeiaݱ! 񏘧QOjM>4[[t>zUy-&oO"I&U6Bui/W9J:$N 9錎5N9kk14jkA\mż{YتcG4J1ܥy_R:td忘J~Wf5nVu%PΥuuDog72_@8>c,?,UCHά+:O^vƷ7"Ȯvx9NrN2TvIu4ZIic mȪrv-Z+G ZWKG2FU9VaΨF:sqT::ԩIN|kmw|- Q3rFcNGtZVgG~֢*2V{b9ӒwsZIi#$zy$JڌV_rFk{_1hI gn dJ*]!uH%ˈٲ0O=OʳJw~GDi(St{U~t%1rPG8jr/o-#:idk##3t?5ȩԧ>'BG _厵4+C5!R6wB֖~ecTDC'khؘ*Փf-ޣm2ŴmS n8Tg?f*4񒨧Q%e$ၷs`r0qkJR其47R_57yoFw:~ۦxzz1XK!_2EVsUc=^G]*:ɐ]DGv:1<3Umv˚u1fv<"Ei<&pXumNM=^c)TFisE]{~a]ZG9qNXs]Xԍ4W}?6Ekm,6e8zǏJ44:ppz~?x[);r~\Oe(sMc{x{:KM}@YHSsDܻ~fqנᆓ~},˴:q+IE93yQHsSwbZM s74UIlu޵SwsahԔZmr( VaX9HP6qߊ8ŠQΝZqN/'q cbHf<__SJE__D6v7X`$|lyY+E;^˨5! Wiܣ+8J\b1(VZ[Uܴjʡ3w'z}jhЩޞ9*T2iDpp'QZq\VQ<ֺ ;UcvF2B#'qd,70e{T*F2jFq,2{_#i6B+>N22'XjtqZkԐmɽEp rqǭgZ2S-Κ)Fz%&*G'NSΝ㧛xz*K˥FR7G>ت|:n4~cs~(˚ѵ>Wc'L˖UzTJ)ltsJVv}Q[]22G:"Zj^Kgm*ѩ8Suy,ѮKK 8ߍz0è6ۜ؈Tq",g>d۔Ŕ6 ?V2儜)?rN冂d37,9#89?JBTe9PrGRI l䄖X (CUURUa0T1-*;,))Gy]5=0UJZGtt |ǿ_OgxK~gE5 F>ɒh˹w{VK^~EC /d-m$ca'д7MluU QN}1NJ|~'DFҬ_ګ^9sxx]MB"uI X< ~C$-J/Spz꼋vZI ($# 0}=Їy:R]I8#x)Qߜ#~YGNݒ[.([3+U9Ӎ9'%1Gw>|n͹6Bst^x4yTI+*U%^s]4!,iYԧK-}ío- #c9oL^J*w3êҳV:X*amۆvo8#ԟ=&d]Fm7r8cRd3@~vǚ6NthIOO#&yYrV=WN? ֥LPTn[5NOOJHx!gᏧLBJ9}QoG(|hel =3W)8= -ucYH;s<)B7͒ۍR84ɥp .3d ;gۥiz[z7|dPG&䞺Q*ۨ- &+iFNWF*+HlWw˴ p89#O޵Ε(՟##wg/έ)+\ImHu~'VܜZTGM bʱ2yaH=NZ\`'IǧJ)JZSZj5Ĩo01i%`1WS+rgM)Oؿog B"7m \ 2,B rj9-[*Wͯc/P"*#e۵uAҺ!v{[E)ёZ-VWGm?Ojg6Hԩ7Wi#fT]-׷OzRQƵԮ"Gd yVS\Jͽ 9qެɆ_oqޟi5cZʝ)%MiRw7 yqgO\SeBo ~mޣQgRZmN+qЊV6Q.>nǡTӔSR2NMtU0(<HH'׽m>XV3S̨wey ?#ǡ>76ofi>݉v6TWı=3ۦ+YJc22s5/ocTrޣ߇՛Ltu3vCF8(NJ<;Py8(ǰIw. qxVҊR9~=>dqFW_efcR7iyT.Q]Uc#=do%jըy>NqrT\K匥rZςMm"E7p3+vJ*QMK_;OMQy؏3?tskN2wcPz<ͺVf 8#؏JF1Tsvo_BK5[䐺6}K-jtG#G1A6SQFTU)ӌ]KدrmrzҼ6{J7IlrΖ#8%+q#d#:;|Åt,W]NxVatdQme۞O};N+RIEm9 &3m̹_C1ߕś;h3kÍ8\uRҭNTTa5q^*$cYW%T=OK,jބl%#], ϱ*r,=h焵rȍ52WH9F2ӡ?_}Xi:P6C+qUofHӒjLQvg鐼ezts]NX̽2۔w3$L (TիzΧm=K cķ^{W,+ɨƍD.cY6Ck`:c#ZQ9$(Xn"&;ۑq;#zǨVU}:2%Z"HTi 'eG_ȱKIcTHP e9s)Ի{iד}z?B&Heߕwu6TeNtTU&؞=F~lך6OS*-OpCpy>8R$b}m؛t >.|b^Y;Nr}cRgRTyZۧ[G=+Pʘ>kOh{p10EFrNv'S^r匽l%ڣB!Oa!UqЪZZZ2IeUij*ɒ xW\WR*S֓A=Ѵ{Hc(ӽcXi^>yRdR9a15ú`I*Fpi $u Lo̹U=[S>[ :Cm } vW<9:ڹrGބnXCKѭ TF6VdIX z^|gY5[;)ӏ5Ug>u3QmXsBsɭFZ~yuVk]{z܀dWy ~Rz~EJ|oE*4]X˚+H^f6yǠcMǛsA׋K!ݷ5Sʞ?jS$V+rgln=>*+73T{5tUlY jo2'PvPxsX^Ҵum{TNm=Y#Itt۫6ݪz`#8Ҫ+&FhG-#HadFU|du>T=xZ:z5m"[6 b%/Z8?k:\WW漊pjH \zfN>]--z*[=B NNyQLt⧇RkuS["K\,(Y,̘A>Mĭc{OlK&UcÒ1\W4yjVpVwxVdbdnq<d Lc R{h@X\m9EeWҔ!t촸m$ڶnr`.=Qs jUvۢ3R\[q"LAiecp0NiZ49qQV.V GB:ZjF FcNxt?VR4yDQRbҺk/h~3g k;YOm*M&orSS*Uߓ*t%h$~V)yqL$#,eUTn-O`cN3{[R5+n:)ˍۆ7dg±59]ܬ%;$&&{[UHq FHN;WU5%Q;>'J9R;|wU*tM;[9Ral qJQwGgW,~+Uuj1NPkG̈́XSy|peiBOO O[ ; rGcs~nnhC[^ﾶ90Q7.ĖvFQ$}*ኅv+)]j[NnG27vDyrGa] 1M)i~^k< nX„e_3#گJq\{3)E;DAYʮxirRc9V~ͻc1\G=ʭ#q޴vRǕVo;;:s9CV5JXLeF[.af_mUtbG*"鈀Z䬾Y-_.WpmPn?wĆaϩTm#E5e i8yf\cwTʨS^I--Fm1$H9YVUB݈FX-"2JH>^UUv9z\}vwwMzmj<=Ag Z$2_0x+(Bۮ-]ߓ t}|?>!H+s~zUNMm_MlG5D}ش[ 誠H:V*M5hRgJWVw%\*bH.BNWq[S姇{~+fЫK]vI?"Vւ]gC~P=;9JͶvR#i_EԎX?hY|YxQ ҧ4_o6i[ AէSVKy.% l5+y5Q'>XὤSe3|%sNrRkBQ76tQsM{ڛԕ qQKnwCv`i!tʔzcڊ>δyvq<*eDnh>ބB r*?֪Ju# ~EG~ 4d2HĸmFrK}wn[kҫEǿO4@q)8uF]tSQQ~+ qn xZꔧVo+OƌuAr- vơpAXSk+vU9Si߱d!|3A#s]ԍMhՌjr[.E ԒO8rSZ6Rӭ_*4o/RI70H!X8[Ա=!/mYZ%w^zub+::nR+U2oċ/=8IXSx:QNO48rJ^M$clRZ6deRN1zwg%&*8Ш~yHXn8Gb{4aFTg*r~P(1!g*znյYTSi{u1%fGzKye*m )ץN29{mLP)T%-V\jϺm$\.v/<؃YM6m'(ŴǩqTF;QY״q4]h薍zp<恹W Үu8FݿtQʑ-٘B <瓽S,-1ʯ#4k) cA{^xuºr3ۧ51U#ҽ]NfRhOF ,FMʤ0>Rq}Y S%,6ƅ#ȱ෡ ]*SQ[Z PUR*Rb_^x8[O)Ք\6ORZi4p$P۰3} )r~NER~oB|UZ/G3 _2eF:~E[ZUX1L߀*m{a*/i㭓[&7'T5Z2mGVS-#yP׃tcZdãV5HiŷjCp;ǿaVzjm ˗N#DLȪ\&:pH}S??6j)^BLUn|:H|=wN*TT׿Y2Cmĥ$Ulk 00:pq~(~'txeMy$pʪQ(dlrRmؚXeY-y;M:kxRII5 wj?)b#kԧ&t3^Њ¬ |p^iSJ}l~Z]~e淆CRMc':.EuVIJPkm.1+kO+wͻ܏⦬ iTGm[z5,~W *ӵiN}Te*5ę1 H\Eֹ)U%aΧQiX絉8ʶdg_|v#kIgF5'RvMopy-E,!F1*c+|ۡ9rB% B|duPhՓb)gM;+p9yk\1cӿMݾݑ,DG*c=+4I#v7_@Wjv?ZFT];c[y1FQ&Nw9G?+uq54v;3u]0z~];|_ծo)ԧhQz8=xukrNVk"MW݂t8Z^^Uj~Iv$V:xvOFu9"m>^Ȯ9^}=9*Xz҇DOV S|;A6L!?18=(iM9+ܙ{NVװĒin'Vt9˺{K%>X=)dczzaߝ>ޟ4Rlko!P-NYX#=?i$8Ɲa,m<.\c={)R(V[G;B*2y .j#FWB)#(mWrE,*ΜJ9om}xˇ:H#FU2FnqӽtsTN:` w {q~^:`uQ$\E:e̟mln*y=pky'ZU_QKu^dYr=#Vi*(MHg Ӭ}%On]7l s(; ƤэUI>y}8Ǵ9@vsgoPy4#Kӗʎc^ r=xR߷aZ9Z=WaM̑Vo =#fsj#Zr7[r & eb>yYJOhyW]Z$AQ3pٴ:ׯ\Sz;&Ռ}ץұxZ9o ,pIoQ"+|ҵޝO^%JuOVuZcD4o6g}x64H09R}6o#$399_ICS\tJ<}KɧFfvVR>c+ݣ)9Zu#(п>B YX;NG?z(s\ђq FVE/u]\j]mb[- ͖%Vgֺyy*pH4r pgiǷ]eG|c8m,UK*W]?ֺ(DrHl൵F82qS)JU72u%&dki v;[d sTT溛SV1h(bF~O9҅(JheffU] N9?cK_>jO]B}Ǘ+ʿ)!^1+7GY-KcX,h`{TͲ}qVᑣYvUG^zOͩ)FZt%CD7F>bNݏ"іUq2a4eGr9㓁QvL2+ VA-ZN\ڦ)˕+$jBnd+͏&DR_rs*e\w篡.T//wRlW UO\Q|[dA}%r'\ |Ҧ+e^y 8;c>a-9k>g xxضzy]8ӻZZGξO2)#Ω~כW/Q3)J5 NuΧ1n-#v0a&r#9Y<ѲKQ>eА+7dO^jiliєe܍/lB%s^cj(_u#3ޤC,rl|[Ԕ\?4$37;NxSZƇ,o7~Z^hdO3]-˾p,TZ-+VTMJNhWk\\ž0s +n<ïLQNP{[AFpv^Omm@cֱ8F8JZ\l*ciUFqt2Cͣ%9'Uh>JT/aJ.8TZrnNuV,EKJPncۓ UzNT\arb9pf]7m~U`q?U)QyVQݳ!&Rmm!g-tc=}oiRˠNdmDG oĐ dJu/]_ڏGqwaHF4Hq),Diޭmٔ}LC]}ug 5:fnΟo 琻X6ۿ+ vֽ,}4\+F75T >^ ~nO?mn*jIBwM]_~ǂ+bC3,jqS7̺yS|WcmfTwXV7ˢJQzc2,_c|Iݿ#' 2.ߛҬ9 ͖|ȃPaF.qӯWR7;m3ԧ8u{E), q&2y#YUN]W u#)ΜRwGw(6pVc'π>/]vWά=JÄ֪IxRc&d(<*ymX߷˧N<^Zؒس ec8*%[^rVH9IWXUhOmei[pVm'iǽLa xwiМܭmZnmʘ/> {rk\oGZAE#G!>Za37EFDVo.YXoqYq=z¤jtOJl}WAG\Aq`r\9GUa(E.S[\$y&a*C]x-ǥs2x䴶UW-0n۴5٬>8H1Qm̗m#)P8<}:xF {RjI+]ƈ%Y<%%^3?lM?}`E۷854IߠJ'UʹVۙTpNwc=8+9r}LpTQ|/"/rq8Ե:%Dᔲmfelp3՜Uq?A-C2l#AtVIkǙGŕX[4G,nCV.gQh,-5ҍFi$%,'$r9=V^QPoa^kEeE!g FOs3Wc]hR[ M,)GXGiʮRYnb1pI ,gtbc uTxʜj5}K0fee#<q=+SIZ}{nϒ9>거?8^\ 8#픬kۜG#yѱ]O<:ުQj[Y"C*ypL~Ve\\pNLjR:뱼\}Df3degZӖ[Ӽny kX%X#:sGKr(KEK1~UBsUF5q$*m~\ԔznjF$H|dKh==jc}o7aj2m#,sm㟙OϡHէ;[[s{*zI>s:ƭEtk9K*W;p=M"ݾcaX!HG }92HMmSާ|U/d@QU2ۇ^g)ч$?/@_me5#<72Nڊї%чpxα\JnG2;ΊДksMk\ΤiRZGG[=BskwRZu(1\`Ȍ#95>j鿡=J%k&kRcbW=NꃔoV[#7'F殃a(mǃ]j{Eiu 8xƋw~Er3dm 涄I'k:tDdd2I"j']ZM[Jcw~@ .2:pz?S7ڃvF6!~mdKy pid}{m7hMH՝EV ̬u\ڜ+bkEԙ;[VqZR;j:ԓ=I(BbFrsⶋ^aeG޽vI.Jz~]9N8-ރI1mO3j<:s14]Pn#[S, wu/= h_w'ie ?tOx<2ΤgNiװvvN8R[H9ք 0~Vm3Q ft&,eV,[sV{I75^#$1bYPOe'=Dgt{jqa ]G#2qse߃N>J\КEwЅFT }rJ7kr×Я-̤J@sTcɱT|Ni)#yJr^x5cfwajk-EU`zr'` -r5 hY>P˓$g<P+ҥ*hK-uDSg9<֦7{N2Th+MbL|9ѝKts?o^Bd 9:TRW6:|Z/:Юn}V*ms7nbd p?ƫތNvB{Qom4Su)܎i$JU+8yuS^U[/Fedʒ6bo&;+9;JfXn6yM$H "$_^8e=EK3RvV&1J+՚Fg7mA͕.w,x.2:22溏D, "8eO@N*%+$茩"MЕ[` cr/ީǗWbG,\14{JF=SW:qL2+¿zY1ֹ棼Wc.iKo' Wlje\sgk3JیVl[Sو;¸ry8%imuG{;>{46PҀ$baTjSbky_&40@ tE*r^ IE,Fe#FT%ѴT^뎧 *|].U$04`OQhս2N1܎IUgXGYjc9T6_!HHysȩ$iNN[ߵgd)# :pAr\ܪI>+ wW,j)#ڳ?w\RHdB[qEg)4 <_1eO+$y5\⑌TR6[p%Bņ\3ut=c.d.PTo~ #c5^<z)J\3g#MŌdןOҗf'mHbXѐ*S߃UEFU>(Hs) `؆T"ha/~DqVxxI6iIf!eyڶcI97sU 5Q[wiUFpJT;vD3'bUFsDyK|YAWmI 8\dˣg%ن.v=!]p*tޣDF%Uw2mf[_x3ʬ&R(afUI̸ʥGkX"ko-1ibbcu'L0W{Jn&|HF9y~"lmpZ7G~jrN6ql|PH;8*K3HT *]׎,Z%I&$cʱ7sXKtC/0'LbDԅ9RP&X 9څOm:qܞ&dxʍesL᥉WMDci#J~eiYVeO?ŞV#jэ:>diH%̊6Ǔ0 ~i{8)u<^a>&Wnጊ9dir]ME7F*mS=,@L0ͻ8~~-9&@KV/'y\HdlaW,7~~f+ݗgiWI X? Gzc~y[CH䕖܍ggU\,|92r1dI5;n;CpHGJJVڔ]?{dʷS.++JCSH"-gf\!B9q1E8˖5r?R^vg߷k$9';UÊ.5Qy$Grju 9κ9ci }b拹ls#隮hu*|SkE[L<͸+oQӿ֦Q2*rZw^]ʷ7 -C:qr+hFQN>͡sDeYٌ&9b}qҴc)GDDw g%vk*\{pp8fw6N3n5`%뵡3(O8jjBV_S9OQM_b$B`m ޕSd ԆF;f9c8;I=pyQWzJ#](U863;'ΪJ{fUn`eyJJRn#c'] AsrΡF#2qJOqZf,r@ $w eMm)h½'FJt꿻s9JWZRu|sm'$e;Fy vhʍj<5N-a =3lmMFi/ pHTc^T+%+mah5Y }x2:%Q?Ϙ̎/FW?֦NM iRz鍣w$WOx"2)I V`D.(|H,ImK(%fll WdS+~`Ҁ9f<(p"h8֤,ҬSdMl/\G Ї\s1?1@y횗y8ʥ, OpU*4,'qDI~뎝+>kTQB+ LG :~\ye h{if'm6@ sN+H2۰Λѭ I3JUC/5.{,<[zYJK*Gg GO|rVlyUW 2LL~^٨.dtH3&e:%))KOC91T7*ƹUUfz4̮iMFTȞbSr^g/wVgb9ݔdž^\s*qRobT!uqK#.wH1}1 xyӻ5$E@l+XpGZ0Je~VP)< *@1Upq-6P#Qzs2| hR`۷:{uj\53e$3Hߙډ{5ʊ]F&a& sQm=(2e.Ę%px*} ~tI"U$UHԀVAԏζ?weaytlnҨ+ө/2œ*\­&څscw9f]_zȯp| [ qQr-_e%d{SGrqV5#ͺrwoAZQ < a[Aֳ唴LזQ#&.tUl2C)8>4Gsr=vĎwG =FIGQ.g359{> }&Yi莈ƍH+H\FgxhZ[10+ȮۤBc+2so[GT=He?Ch˟z>Q;͜w8ǜzuGa)ḬynElkUkjDJޝP6| Ÿ:hN3W)VSdDm -V5/nXuV^b՚y$+C9J]Hz"(a3y=y'9rz墣-FX#+-s0 ^?ZΤƤFBtf#c##ϷN#k]%*wyd.1m[N$_蠏4W޵ZzEteN1NLX3!_cPK9-DN 341 K|汌r֧R5tQG;Un1ӿ#z&+XR$GyO<46UYmdǵk([ $N}qH^xVN<9֕5u,"8f\mm13ʗ749i(M$\LcpٸvJT̩/ԑ^ = .:qMg%.U%)Fa׿F-ԩKv?Ď6c=d^tړ[ܒkD#VyK.WqY*Ҳijݬc)Ԕ˧F%ac?)9UNy==1Xʔ׆(&"QWi7|î1X=9+bJݺI"77#iZ֯u26ᕾiֵZ(g:RZE l]@'#oNkZNI44[CI$A2" @##"6k~oG$W»Hy܏ul5SAS]Tr;YD/\I#\.cd~GN9㹬iQv{ש#ꕱz7,LXfa |$}]1|yV}5TZ]wB6 ZBHFc]|:iPmv1lg:QZJN/~Ue);-l=8_f2*z< s1ˬzrt.+"HqU6I?Cڊ LeQsҝ[y-AyjA9z<9#u'= .J1FUx+O= ]E]V4*t⤭n#Y%gWT;%] Ɲ7v69c!Nr8ZtRN*GMFe[0_pq<\я+SGtH;f { sZ΍hѺz<=LOz$v^>J Dz؎Wε^ARNDHw1(sҰT%N*%1ƨR?-pd`c'5Nyoݍ1q1=Z!6C `jJ>ͷdwNfbrWxݹpvbӔuUף؂%s{yG_rG8$gVhԧM˕&gN-'y_1wB1=z֔]=y*]XIPauhB~e51>d]J_kzl'F`00}=*T3lƤcǥf,yflnA{XK߿# 4NRwK57FB HU6ʼAIa3hS "MIv h! q\NߙZ/TK VnTS=5O5֥.㍷t͍_ִ9+cN%\7!șcmX~̑ y"`c2@?^7լgVNe6e乑vȡ-gzdZڴhZKTLcUZ7UY.AҲeNvWKG]ji}#3|$OcR$$&eZ1G׏udwx@1gyJ}UTEfߚ-1̻z WE8juSqq傿2ޛOמ+!+¤bhn6nYА=@85\u4[:>I+ K\\EH<Ņ,wB/GfSiY<UU8\׊S R>_2?'PV^9*RrilU^+Fˈyaf(|?\֟kD:滐ǺH<嚽 ofRXȋ܌n)5-N <ͽ˥VB,qA'mFt5F]$O~F ed+i)FQ*j]<<'plc.}AJ۽W-cyxlg~EVlZhͼc$r2| H3/}_:^n=;̖؆ڹ\~] Gx*M4y2$}Hӏ.OlҠ2_08YǥtF2qFq+,r7*ErrdqriӦܥ܂hZ VE|p[Oi')S-E#:Z?3r |ÿշ$9nuBL=9&r7$5bb@%\` qkB΢OqtJͼ0\d#djS%GR*1Y&QY=d٥9T#evwUW.ddz`kʣV.3v{G$,RH6޽9~匚F~Ҕow43.ج|:uS%,2.[5C$lnf=VdF8;؞݈`_R~MEO^4ԪNYn#Ҫr1^E{owȞSG&T:}=J61oqyRY2J!e|ڧ~W<(|1Rgn8p$ qXwntӵԗo7|u*?Q&3"Mk&NW<:´;iӝ8j@$H fn9孍BJRDAcMʜvsN7O*AlH26d?{%+$4^9ol&)PJORG=i_B܌e,GK ĒGq&ThBoN`u SiʌN/bZoNuGk?gkv:Q)].eGoݐtojە|&){78r%UUw`Be' hhF}b] A^% |U s֮ZqmL9Lφ8,&rr; %i/1]¶ѻ׵rdֽ8Ԗici[\07A~18˖Ӗ̖2ɻrx{ߌcE^XQB3ֽ= \,mS.A1kJ1y،DKA$S-J`3rcq}E&i+b~q4F2 *TZjZ>V-W gXJOn)a};c232y=zqYJRvlN.ZM}co)rn,ߙȱؿ=Em1^ JsHW-trD"rwu=jjgFm[x@7H`_nݍsʴi{cR.X쵺{T.;7~;V5*J41YҖw\@F| n=2W5;# 2#O#&F%1|^z~?\B9ӲzLy?GF#=fM T/"xUT᰹L+ TO[oh֢]WmۡU&q:>ZJǛO^=g?{{}k&ӒVΉӯJQ׾J1+# K3`\΢zʛk$DawsYԧuii._k s,*VeWv)c/9W=80qƱѭʖyIE3H\\Q].gR7cmR^ XdE\yx?OT7uשj0 x "!۴X0'n}hԣ.I[Ro1A3 hCJ7Is'SWGEu.$5=\b9}՞:Vĥx[NOr|dUʛ#4]8|#9yCG۩F1SsM5!trNVm$@Ƿj騣**I|cJz2(8-:}=t*W޷gVR=b$HnnyWHUA3CeR)ѵ-nvF^ڣ[dOp±7/ ?n+JQ_B]:N~>d6CknɌA_O^c&>e4{-FFY77DžQ#ZR]:1z?kA˵d-+emcx"KYZ~2uoȆ8/ٌ?̩UV'91ǭuSRxWͪegm*U.ZYϸٞ}=Ums\:qאq3-k魺us*`B.$#im.vI~SK}F5Rf5ߙ64[<2ͽ{^ڴ/Y5۸n(.$=0>sVj-tee5܊}rzNF- #|V:7ԚHc1vz?/\W?:Tw[4ю,UV,ø5>΍;ꙷSmu!E2"t9p-w'-Fݛ#k$1Kcˀ`}sڶNR&YjU#%'L5wvHEVRbN21թZP0B5tZSQ]s0 GA#TuOXgxzG__K-@@H=I5\Щ.F;\zkjnfcj^(#8TԵ8rIkn#,&QķwӷX%Pcw㨢c]Q(T.I 04Nk~އ%L":v] K *fa,K;3ǩ F1oӦͱ4KmVvGy#y,N__XejhIW pUfc"?z\J2{YIIFZm"H,&@s힘MF7ծbFIlL O9cyjG%TtIFO~)#mz#+6Z?|w<=3z IM=mUJum9lGzHU3}iSTp^vvt&poD5.nrx1Y5#Qzt;R-^d2ܬyqɻv .w= tJUԌT}|y%JoԹuHXK$c?6H s{gvwO[UhUܑ%_!7]cqVk4Z>ͨ;p-ϺCw30$<-SzۿVgG7sܽkrlX$ bm@C5~rx'ko:xZZOUt-|0i[vЋ}:y(Ϩ,jNi1"H@BtJP,#8&FֽK[^Jew>EYa6WxNs߶q꫒+Ͼcj\վg[۶M]şx(?һ=9I;zuj:M^ݺ)ichۢ9 y㡮ZsI?¶WViv[^K1ͣZhVf 7=Fsr=>/Ti⥇:Tt,27Sn7r[=gSrrַRpQmÐč H|51ܞ|.N]}-f/hS}u-*7x)XղϹ[wLzWF:5mm|,z4j#vƞ^Uy=Hӌ0]IǙ;8燩j(MՖ&TU$W^X`};v~&;8YRkMÖb+'FFzr_՝E8|:s:`yH{sU9S)nc[ r-:yXd=|?꣇Y.h+S2Jw-kJD}8v'*Z6ioV{b,[Ff+wNZ] (EodyRޤ$סϧCT],gqS\]2+0W сt~'ֱ>Y{I;561{>WCcU#zv2ӐW?׵jBTRWȵ4,fF~GLn L(ƲOmxiAkPжHoJڼB[t bߟbdQm:WNc.Y}ƯКhc hA-11]uR>ƔcmC<^\y+ uaN_3)I)9%weRiae \3r8?tF|ʹ4m_ӣ*4WdWYE26bpze9SѣUedOYqcTc126z\5K#Ԏƛ'CDIzBLLa=}$jGm=f(pr[q}J*MEܚr8ծOی5r7ma`N94XI{O-ol?#¢Oٕ5~_od_9%NiJ7cR@|Ilmx?>uKQzю J)Zг, EU;ǵ|i#Ⱅ:tk)tvO=Jq(߷Wkj<YєB*h-?*sB|v[i՜k*Ntmet<1ҵVN_ Z%^doRh`I.&%;ccO]UXSŝyF*~'ϑ<7@8GN>S^Os1/=oAl;TgkN{~Z5J:.en̙Z`O ~wsEIF1N/c8eM|K"N pm27r%Z$uЩQ*{Fox7YsaN]"Jj^qHZ5kr_N13S)ncV6Hbr}{s*%#Օ{ᷕr>NGS׌gڧF/~ cR_,EVРHV)ri)T]V'}5Dp,Zh;yYbqץ:*Km7X4pV˛^<&*ק?O(2bьѭ hm>iH#{TsPZ'F,V ѳy>[C&|I{{}+xӍjZt*Qݑ!VXʅċ!^9y烌ct986{tɈRN~Hct#3oH'ܒzwMZo=:2*Mkt_NH]˒x㌏Yԧy.ftsF++o,IrѴ`Qp0x~u:;X3'=6RA \,Vi2Ў\TTs ظS5wf9[qd+H\@ z3nnMtv#nRO0En;tɭ*KNѕXGkGT$3Nw3w')Bhz<%X |yS}npWRtluI(Ҵ^9a4{T;U`L#$sNwJ%z*)k~4 ] })Vӡ)J4cL-cMBF6 pGZhpB}RϺm̥mqϽsǖ65vC{*=HqEy]AG|סN9ZIVYIPIo{v<»"Ii?ݶ{i%Hbz:OozrSNz. * cx+jgS{$aΞ Dg'm̛G<7CiG?e:iSSt;8[b+,8GkhsFP`x+<spZލOyz\=~NzJ٣Ѿ&Vo5l_{fNTOM۶Wp6nfu} EhMivȬOg˲*6O]t3$-/n~2eG?6Я0Yn7#DdbV=؇wb*'-S3be?)m:w>IFSqj >e 3*£2)ʶ>~U׌zZqeu.M-!HdAzPMi&[*̛~9v_?\Ƨ/*f,8#cG򘯅<ڒIF:$r:Սsyr0#=Lf1Esrj{Nw}7`t~qҖ"8*1.-^My)E-fӡ5)Ipq?”IӅM)U؎Wi ڪܱlҦ)4O4Ͽckk)fFA:oi󜎹kHƤlf%Rҵݟ a5l,G 3[ƴ*^R\k[TIdX 2O,_,:g!J!8vs~䆭o?BxI7"69ts\`?[z5ͬr,Kq4T9ʶSm~ʲZۤV6-c5* Ƿ᧧cx˯bKHYDM˅xZʩ&kC֯&5̌`+8irQ_9hR㧗߳3įnw'ƥq4{QOQnYd$$4#.Ӗ->veQ,Hq1֬4r8]4/~֍L<9`ł&Bv?wۊɨ-Xz֬v$x,16v1^eRy{vȅMʩmWo8zp:WEZTyd9c(ڌ獬YJv2Ã~CˇEשhm4OQq.Z\-̪T#{Xn$}Xzgy)JUoi((Ke׻Gf.g9\JUKl}|<2LE8L12yWe=֕T'܆+iT2||=;)ӏ,Ѧx>;m#]; s(Y?_t$IE[8tLK?DGj-3_ff~Oqs`qƝ=onl7A3*2LAUC?¥ZnVV-sj9Jܿ2IK[v-eiؒ08TfAvK[vyU-e+>4euҷU%SlI-qwF6oJjQc*4 |TEu) o~SB:SƌjTՏEHDrظh%>hwjrq#'vp2xN1J5gEH r<RY$ݗKw*ӂ]GXUy?BwߢefTPpz}:RֆUPl16l @{rKMX1掽}jܰ[m~eluS+ӥIJEU\i^W](Τ9t{\$byjϯJ8Sti`9ݕ?#"尻fSlgoʊe ~MӭE>"Uڭ{w=G_ֹe-OSj)IK<3s|\?^]Ѥ;ϡZ-vNMͼ;YFA{*iV:[:ѕtːGn*cZ%oy`hX&|+ݹ⊒M/}'y$+edY#q/O\{JR7OD9\Mɺ>_L"UcRJSvЪܙ1{yzVϖVVWZ?}k~\ͻs$eN#hg)p{Z^Ν9֜ȱ-^xcH_ǍK2|hZ'~Ud>% vm`kJR1e׭J*Ҽ[VcMox9JNTLNQșa@# :g_~{VidV_0// q޺F3:{sS>Z&#V/NSԪu+I{isڴ$H ڤu =}JIΈ—-mH4c5Q磁Rj\RIJ"=,v}>1"&Czժagi!<2WhY(}kOv1~*TUTw"F v̽:Q׊R-U#)?u> KSϡi{ӖM?=z {cTcvƹHū3Ǯgz6zc(Qө j7_m -ۯ*3e$ deo(LvgS+rӧPƻɎ}./ TF<ڶrNn58 tuݜFsmOݎʷ*3m."JTᇼcF2TQ۞wy-u߷#\m l$aJ%TROm j|;m1j<q{,,z%QHߛMGK8*coc rGdh:%=R 9Q4y<[ƤcnM|OxŘ=$qo}^u j*,8_.6|WDdc\=ۓw4*_׌S]~ɹsTcp~cNI^+ToM"a;:lCOv:ǖKO9iSՐ\亴vr3ӱcʥUHSqu12UY{/{:q|rJEi/v/UIN?¯R^ԖMkU$ھNIh6| YԎGYiw$=54۩eQ[+o]GJ@[#h6Fpes۷_/*vT~Ց;#G4.[-7h] Q=Q*RijM 2Tf9!Wt8j,"iλ~[G̒93:n6_e9{1sI,ffb̛n@SVV&G*z'"}Uq&.WVn+6+a9*9-e3xnemv1^k 0\sLWG+Щ{Klغr _z41j%mcMiO֦2MNK%mR(W[v6V?+)%#Q:M4uA'܏{UK+8KZ3$ov؎ji{>}NfEpi$cgxOgXz}J]2[\htʹXNWC7J<ڭŻmHٖF;cxɽJ-B$׎4ъ%8UrE1n`T] "Cڟo;w:tyQex$TE bTa騯dѯͷhʌg$es)I2+#D/3Xzgߠo~jw[V]JHL?v>U UGSy^sH{39gc+ܜ9"+{7zr S ~b3zCq S929I/=J."o2uЅ'yW&#fS 8ԹI5-ao"*e32;c}>frG;h^NcFy3jM({$%)O+ğcZudwOq);E.ۺ spWc_Sy=rj%fr98U o_wSN bg+ƪRr õDU[ldy(99ӷj|sS)l|֪W+(9.fY UOZ5*vG5>J9"_TnAHV(\R7 BKy;ty"Ԓmt"{+-,[*84}+ѾҩhteݦX,>fYAڳc}s֏-HVBc70GeeN֞GnDjgt"4?)Q} Z{NhI9I=H'l&\GW_j_s3۵܁a20>08"/P4oqgVfb8S}E/e]F黑$Jdutx.8`y?R-JvoUQKx淕[לc2vz򜽣ւI8I|R&lfm ~Y}΄eqӨ8>N&+G[;N*F/ʧu}I")>I1vrjc!Fw(n3ST䒊]{uWD\+M?~590z'v!2 A}eQEZڙT攴o-wVV[yQZ2#)NvD-W$L(3c?.9Z[ԩE;4]ȉmm*3 s*b"k狅fczsJSV7%TK?[ԖiicSY21<p cewʢqXIC2oןOZb$XU半QY:M8{W5B-Ď[hܬ}ujoKHțڸ񩒖$RckͿ FODccwQʞLgP~E)$F>T$hco4J/>ԟ2B\g8ݭ: VMcg#pG].nHMFTFѶLiuƴZf؋yFHTksilKy"j.dq{Q.M:]%2fuu3ZmlN;+Og_vWs(ɩhL8Y8N+ޓ} TjZ;D58ʴr%c6GۺkC'`GXrH\) UY4rmG9<sZC/:R5 LV;#QX]Rz!-jy sǠ_z|ҧ('em@ѩۓ#).iGMnW1nuc&~I;5)\,H>`n>c*}ݤiiT)c[PFң-]3Jbtll~sϾ3mN_tS_bG+"BH:T+|Ҽ﷗vI9RەsΪ.{FDc8|W܌>KhÕF\c7Μ|śzڢQ5=Ѳ43.c泲9)s8%ˋ[5[[D{e&H^=>d&A ˒1z4ͳ_ +,7@*VL !?2(>i]FKxdUIi~\7qߌw*w,=VQW=K*W_gQsaaB7I\```JQW#%ETz!C;+9FT?^iZJ~7a[ڸߒ:Z/:RrVG%I#}=ݲAҰ~s*'R" ̢>d6x_SӚ6Tqvz< [k{{єuoIOټ6wug#X3)FZWnn\9 N4't,CI$lPyvC~5%+6Ѭa*t#{X# 1 vd8Ӕ>o9VC 1=Zg#JWs4 bhT#aRF9#=iʔc%fsr/g=,kn@DZ8I*]>Y{KO[K2YNF9Ҷrte)6n|%aӦN/ҳyeMӺ ʮ˻ 9n[n eYI#ǐvp+ކR$C5H|[?Jr=jTc[.V(A H0 >9-n%:Q[R6XhH0`ayhEtyee;?+*Kv3ʧ>/Rfk2GkZm(٦*zu.x6)tU[@]qح-n[jpU^ʜ&,6U>Q NG=q\=TnyI%d8*;z8EjT߼4F]Ğ5]f*pg>) sE$H[q+YQn־G=*jPP[ǹB U9LsIF<:r"Cl?\.<g/iy; !U߷PX֣[TrTEktWIemGr?wILc޸ӧ^V8vPKX=*2wr/O.Rډw e?p<r8'#U(SKjÙk:*2]qЎxZ9h.?kn0+/,(JQN!=#_]I<*iVThܤ'{qZdBIm@K}㻁VPG$ԍ~X:*\&ɬR2A:=*^;JQtGR76X+C1eU8Ӧ;V#k?Q ܧ!˅|L{ 4HRIlceT[U2obriѫzױsa~ m]Gvg.ߧLj7qoQ /eN s֣*->ZҌ"dI-Ё$Ƚ:rpxnUߦTĪ/~>hΡQLE $r1dAR>Sc+7trމ5]VA/ݐ~S>v)|[#Y:k"}G,h]sv鞵TAF0t擺,2My(`Ȓ*arIӜ8yVc[O#k=uǷv<Ɠn4nOE绷Noбsom"Ilؿq:sӼ9ۼevVpژc-ܓx S|,#'d׹Io,3-[kP"8=vkAK DBѻnH4P?\'w;,6󲼟pc$ZjV^Τf.)J$09Cf['~aȧ(;^_c9=K(mlZ&6e(1͕lݏc΅)^+3\ܝ!" qqi $ E\>_=Bxz*} BYwSzgc5otdfIdyȱv?_*U(k\JKfGk`mR׭)FU).g÷Zj;$OQyqگ(SyNU)zD,jȲWTnz}*>*^e0աb> 24rN/9ScujrY$~ftԝG;szlbFۥܪd szu>劧_;~OrO1 As]qiuScMŻyddP?LδXi(6^]A]yer[cb܀}}+LZ͒zd̤+u#0J.OWveG܆lc"$ #]acx J[zXI74qgx9fnp*(UQ*GVWK:H,X*F3 ]vSF$rH.LT#@U.l9#[{̟{ֶK7}5;.]Ă=@r#sp,[J2[sGMM %hY^~ee?]_rrq֮.<*r{Ic1*U ~G{c5-o rK]D!_,mVÍ xS}*PTA,Lw">9ۭZ2i/(ޝ:,Kp`Xviw;@$ji}ϫ:>EتmAӵ ^V`3D4R23I^c68+NYKEӯcYTNVd+7dJ5.EJ~+֘[*ʭ8vGҴNNZOb2fڱ,9;G=9Z|"iTn[vm6ygk+8_\s*V.]41r#%ui#ϐ&nwqYsI{ۭqi[RJ H'@cR"J֯,c՚+a}v)N&2emp2:gqZF\IQFRT$`l =M:ѕ=oReRQܒo de+$bM=9u&ˇwE*۩hDw:e8p~֕ZJұ:T+ۋ?IW$[ߏb9SU*ҊV͉q@Os^j/0BoTZ\^y%|qa#zz~ E#(_m5܃ʷkkQ=+SV8N)[t,2`_Χchr7f+j1 ?̣9ӽP|Jڶ. Ӝz59دʗ鸉=pqqJg4tqJ޿5&#8㧸M8ƥG%C ;oCYEH#f,FXy=\(ΟӫFugͤ]̨n;}꣇樒*2]W$H5'ʻc4˔芔ukTOkrEJ3\!.^G8KKo'3/W9)G$QEhdE("țי׊"Ti%cJjI- iqx]ٱK ~*{9>Ug[NK맧Q?7ۿQK.xu+\Z{)dA7_ܣhGT]VrջJ0y!hRC`z e*oǒ:"s*Z%ey H*Hs*E<;>KvMvpźrI?ӥWN.^.&jrQ,!rkgӯ\2$~>4nɖ&kB7v*ϖZ~lcrz>)ՋG{2f݀8ҴW6N.jt(IYnInf$Wk~nI#?\^lrfV M  V x:OmmA%V8`L Nsc̢uZqR] JT:w|d8*9aƥvOO.4ԑeF=6/+G g%NSNЅеDcb5ڤvڱnY[*7({,$U6;WWQ]sʤj&ZyY7:X<溏Β?jYSqL江/&1\=6 biQ{y?ΊHZKS)UtWm'&V1rZ;0XZ2u_2mvvvxҹ/iuѢ,Jc0F!do==랝%x*=8!D $ g_޹*WEg=BhGIc&nagQ(8__Ste^[̱<a$;uNjb$ߡ+ӝ^arzl8ŕlx=1؎:qS))i잟yYӌ}~lͽf7fې9ϭ:&Z[St2DYF@:ÙэNR ,!k4eNd8uȬ}-ߡ4Hlaog럥GMsCm Y rq:Nxԟ+.k'6ۨ%3UpXOk2cZ[{D8]*ߝ(Ӆ8К:bhW,R!#|HlZVo:׾;'Gs6kFNNZƤjF-jT^]_WdF]5I$/|9=cK7~tNdM}~D*м~dn7p tVkdu-tNWIk I𣇫~ZMۢ˷hgoR%fo3zέʶwyV/xaUd]̪;*F\nݴ:zם{a[M/ҚJWE˖CLeaJ^1霚x|=߽3:%[Dאxdo 7U~'?J &w9pZIS[Dl7 YB"䡳]>w~GD:To8A FWF"1O8{j.ڥhwׯ)Bsd1W=8J7؉Sc܉{vBC|ăFF+L<>X%l [*O؊a̟zdQv|mW>q.^XK]wpYv*?,2\c>r_U'(+oQ\(%L8u |NsJ-Aocgfܲ6cBq8J|o{zmfe:s==]FUB nx\ GN0յv'0V5uuoN'Kcr6|`+7^qیֵ%9Um08=m 4۝ˉS"y@CzBSQב֗Q^74ppK6dw([BK|U_$MիE[7 foMh)TM,0LjmX`^:NkyYϡ6s[<-W%~e1:խ8ӭ.VZGeoI?iU@9c>,,/sRr]i>mo$,sy=~<.5*wWnc%4[bD&%ϕ|G\}k(ɨt^lUJIK`sTbc(jѯvih6]-Z +>ߌsVu)T4(s6#-GlV I##+.FͱJ565%)n.%2>%Wٹ_E625ƝMj5{-Kv^Xc kwm,G821JV1z_p~ HmK6%\H܌/#Z3ZRj 7MUU-JFv8]A@x\:V]а%Hn-mƹaNr:1jp*k^Ԏ{]MK|愨;uF2Ƕ+GRJ2KK#aЩ[OvF(݌=+6ѝOwz_ԒhW+`0Ͽk)JVKOqIZǘdVٕշ,|`6Fszjӊ;SJt9+Zn$.|mB0>^:qrV_QNQzhMp|5l +q遏YTPvsKߓHxF\ǿӿYQ.FJH1.~W$IUfI!J}GiZX˚}ŅPToʪU9fc/ y7>Ec޼N<ҕ֋'޺ߢ+\r͓ϰ^+uƷ*{_2Rn~w:{k>XԻjǩNS2J\eDjcoa\|>VnRM M_݉D$NqN:&Swn HF+UQldv%)Qx>~nd{J#Vqj6}w-ԏQ 6U }Zʥ:5K1j{dVy2ي6fYbIF`?Ӧ-U3yFvR{.y.$1#8ZE@tӭ:3t*0tc/Йm q*ȡrFp3tJQ/6ק؇F%ezYm?eh%ylx#w60y'g^^=j@9׭Ii2i _U,nX x Z*KF)=~kѣF1uEsu,vݴqt)HK**e>ckkvo9b#_2R`*%l&ܷ$c9غrV2$龌qe9.$M>2=zڹ)T9ҥ'}| %ţn@oluڴ(5iV_#J=/4jbck*S)FTiѴthpQӯAF>02}:vqR2ybaekbȬY>PXsZ2?W{ST+8Q@tڿwrc/fJ5eiE뢵ѓFQtqvOJ֟ZZ4JnvՐNhVi txlUSr^cNQڼmL]3yaozUԒRZӣj<]cVfc3g'?ZꩪVv8F;ư"rw7Q\e2{7qZ|V>c(\9=*N*.cЎQxi-S/ڔrM.XLCk{sGK+^.[u!InF;P>S]]|xSE- 9 ( YkqM~0I>IZШa܋N7[m2y,6?7z~5NX=J5RM=-}5,[=M˙?vNxGE˦\-;/Z]u 4Q7D &}#J+ܱ[zzn-\' :˴>߭hTTPäՍTh<*'*Zwއ I{J? ]A턮Q̥AIiw*~,mh%=71FH#+{:eaPSxƼԱq cj6͐zһ1鄽P^ I3 v-"NQW3Iw*ˎP#}0fmf$U㿽Tdg)%B869r~^={tm-u H 4$|= BSy{QMUrhRT~k=99\*{o̒Wۉ6nn}ԾO>FE-㕑Ll~ϴ'֟7-0NP׽R;DT}0Kt-?!X˚z**)\8ee['vs_MM\,L$2_F~֜1rZ- AiPՓIOLqY18U4ovld/'Px*Jt[v<ꊤ*rV]NoQ̿f[i$ܥDϽ|.20M6Uw6f +zcpFz׉RRTbCd錍[s'{t*kT\ɮZ֭$ZfHҮd(wRz>t:=iSQw*bYv!c#IzJF4g,T=2VOeծtP3nmwqZQĪNv쭯pv}D6|ᘖO^VDMt @e?wF'8#޹RWU*1[#h7bY$ʨOBGsL}2}j4Nwu FnaS%]8*ps0q]}^gV3**5K"lK2u(8?7k4~x_1ӻz0l֑UV9rNNs㚹TښnGt迋Vj 22Y`vy5JkR<>!N2d'˕~ZyٌqZlwONq̒]bg{m =OYrqR[I6ɸ>X7GJ*Je*q\*;T IU0yk ֳGٽ*5)׵-Xr |y;{UӧRQJ߲ `#]}]<<&vG T3+Nδe^G~ާⶎ*Rt8zz˕e[y#tq= Qm_g"Jn)'}%[Ku![;03#̴eQZ7aDWسC?0J0u5wR:YƟpb]̸Ezw}&l|=zvƊPBԤa~:91{9EMuG|]{}^E`Tf:tUa.gR/$Zx;}ŋ@f̕[ 01?UG:5U&ͪ`ؤm&ٛj=u(-CmV@89>N+֓K}cTRf5@.ߛ N#WONyadހ3Urp;JKWts-E tLwci'{gWotB~"Ï@<d}Mrphc"w=ӗ5K5aR>ڌ:ymd50&$)ԣ+VwwG=:2VUk ʓ,^Vygs֣߮yLW"]e?bvPdo#:vTOMi_#l7Ik']])k;.sU:ҩn3Sޤ7o++z]jח)پ]ϵkl(\*6ܝiFRN^Vs%)u#"5V,^ߗzv\4Kӌ'XųyUU?31SGwN2%O[HUFXr1޺)F9+j7N;[̒&Mvcҫ*+Cq'mmU UT&qǵO2mPvVp>`8 xנ9Jzl<] J M_$Ѫ+7TKIGWي4Ks T$!@瞂c̝yV)&$Y.$n6FUQH8?.y+6&Wd+$\mro\nT5%>i|= iԌTUy-31>[TZ2zFp=%oQhVY-ThI^I=`cʝF+[TP$n2Tvl޳i?gQuH#c-:d|́鑁#}=,*-Z|ɐ>?un67SQi빅Hsd6Hh]W =1Ota*[Fd“ 91Z{'#UV3ZBK[n SYOwg/tN]}DOFϖŒ qU,?g{[(Xե:Ӓv&TOyw^T6T|98`+;(Lqӝ;rak#t[Fc\iV|a3n6'd}OJJ2e(ŵ y̫n˦F@|E:IֵˡNQgW,I)Em e5R0뛔}Kr+?&O1XmW&Q81WԔd=[ 0R qFu'r5_*tr%ЯRfjWu{tkHTl1N-kR¼)?XA8JUc *k]Y}5w0w1>]i8=GkTR1V|ʫdRn[Yy55X6{*1bORVYJ ,dj!ugCV$M7Cdfq6T|u%Y`gwFI"FHUG\c*s8zpidg5$ABz|{RgvV|8\n? lݏg č7"VlO}Jҥ:sg:xz4OĺQw!f I/ƫ+qq~kch"Ww3N˚/ٶ۹cQpWTݖaVVtr0:g=5w{/",FrSj]vЕ&f*`peZi_SjVRZh vcXNݭqoqNג.8tcX6E {lI0I$N=]Kʧ-Ou]Y]y.TJ+FmNjc'kZnY[hٗ-?_{WL*JlFsj;w$"%C![i  5#~TkgR7Bk993oTBoKЩq3mvUSt). c?,0s#R:Mnm 7#%dc=Jro-M)ө 2Z dM"۝̓O)KXgOWBcI3XrNwgFx޶4r8ƞv3Y?p+6H ӚZ9Yrݟ[ʢ{m!;STՔ9r64ʱxqdz SaQ^-Y#=}kROW6狦4^b;/}NpsIRMEY}3̍!Yf)7erNDnUl6xN;薆j4Xq0g32y5qn.ɚJGҜⵔRQ;[67r`[c|%Λ؉%`gf}cTsҺ%)F}UNQinV}v^[q73[Crtsq a9fہ`zRrISP#fN ۳I{+;utGYAU1SRbKRl0yel;slLcDi7!v78Hce~a:V𗻫4"WhwRtdelGNo֢/Mufsh`ɬRQT^{7'Lm @L4*otWY$]y AV\w |l̻|aDeK#Y]s;[ٚA>}O~I)U(nKB[[%E(*dPRh+Z 3K:2ኮs#s5tEIЪ*BuuX5u@ Ђ1YQ̣$a囔v'l`>\~Qu&/Jڽyf_*6[ ILԮYK]NpK7:qc I\J wf]iƢ^hҙY,-y.I$ɫBNͿnKq *F4r4+Lsx<]neR^֏/6W3"Ơ<*Oz:Yiit\FuYފԶ'R妢5Ib#~ew=a;DY?jNȶ_"3< w#Jƥk"IL= ~^p1f\\elD>7І0&6vr=h$2nXݦO(q'z Χ4e1ѱ\LJQK11TK;N*OtKҫSY˙ٔ}uI+rNJ6ͻ:ߺ[H E7JWihI̪C۸`6A&㩔u P:?+n^=b/Z*|ѳ#噈UR<#8ΝdW/k4Nw*iey<Ԓ9jTfǒz20h,kd篨yTOs|=/`Fo-wnS)YF1WoRb@ČO°qPZQ۸H bmXn>ޕ̹nx1n׹0eݑ .nq'?Ҋr2芧zrUŏϳqR/JˡT_~Qc.Jnx95f&TەM'PB:H Ԭ62<?XۗZ +.F=rW8}=G)^נ+6`V3tq'(WnlK߯ [^&2䄭'AgK ۹{ǐGߢJfXg<Ӕ .[Xʋ̼33ϕEyէFoB^3 ƥY'ys/i8D.X\OV ~\*}D0)FR~,7nf_qpAcFǷ~YJIw}g?ʮ>ncN?zЎ)(d8Ұ4&<ҵHcrLl98%)]*qQ*̉ۢ;w1;u<{ըn̪T峎iIB6w$}}{^Χ74iJ)9$ckxf|t44MIrcϒoHUFX1UQ{M.Ћt6,φ B`gk9V1cQ["HFfVbXL:rMGK$mSSk Irٔ#rqcc>iMYٓ@,Q̑n,{YI˙ʥU;25Dq08~)7ԑCnYN6$"~^ﲻ}iJ ֶOȴUCxlm\T6gV׿F0Z1n1?JrSmGNw23hҢ%ө:u[avuDˌG1X@<` QuHBĮ\Y\ հK/QXK6$L/U\n+ JҌֽ my|VX?'ͧSYa*i͓Iݲ``;~1hӔjrr;{kkG87`7JʢIELYO%mW(vs=ȣޭ̩~M;$=иY͕#q5Ks"m3U<qEh,ta)>5 e$+'';u#$b%))84pђWbg+1Dyn·m6S iw q~1K˗RѼI Xp&GK̨qP-źBQICF겮 JG,gHXU/W6SJ>OO-Qw.v$RqWf,6Q*뎙Ԙv6{YZnef|ۿzsUǚ%Ɯ"[v&2=[4ԯ-(G|WKxٚk22q*9,OO+pV8덗'H]|N;]ƍ*v] $?ﯥL}R84q.P"߽;:$'a()Y{ īfڥ+q1ޔy)F*H-sWo˄lޣXQv3?i%}]X6^ (ד)GKNfQhճ/wHk껌IY>\ I3מ(PP\T[,SKhxUM]*֓QꆸȒk]*̽)EK&rR'S$+`17ִ{'/f'נ%)!(?gFv} oM̟hcR =~jRQ] 刮8TWusJ>6sJz4*1)>BFXdv:~6F+Q~}f?4ݛbrGIX*˖?u«~8)6sԡV2_Kۤ F^{#?J1U칡rw慑X}.$GWVdrp}dДK`e T@cuK*%ۧ2nfn ԖsR*aN\/i1_2Fp7Osju^MZrdgVbd>]p>]o1zWޱtڕRkuvF< i9qҴJk޶Vʢ>HSMw0j/L5#)I#PXy$fےzgerk,D캓DOmwRP&ѶI=9Wd6oeݗښLn|SU~_q:R㣺:1)/O>}ͻ9 ˓GcmRXxPnkޏm9m0$]+|$x~>r)*U!^HXm'RcT:qXQI55Ϛ1J1 Rd=jS2}.ƴfDFKڭt[(ӔTCJҗ3IY2úH~gS"^'<JXu6mt΄y}2l5m: #?*]7(ʟ=;Pfm =3ȧVG/1 O4Mlv37ʽs|wehO_#ДViöV׽oRNZ_EE5}Mbϔʰª6s](Ǘ#zor-YpĐh* :zu!lȰ.UnnǵsQO_U8)21iky5f냒W?EH=]d(z{ P,ANzVFoQZ)UڷkuB܏1m`w+}EƜ$uʛpHgL+8u5e.h?w2\`hUh]VJjsZ- EIHR;(Q6qJHKE?+#]8#{^+(IyuF3ԫvK`.}=$?:^Ҝ_ZvW[(,o݁X)TqѴRxF޻Wn0?J+.eU^儆XX̡H8$9bTv1N{׷{%H=:ڳTyj\iRroV0Ķg"c.ܱⴭ8ӔfߖXʝ9Э)'O+o3$r2YT gZ3t#kuYBE:ͭf;[Wc?xJRR+NT/X <~{Zj~揵M7qR䷉UIf+`#s 'RJN#HW^j˸Kj$© I ӭi*iSoU{ouYuؒf_&Hw1/ y>ՄTՖU5:*gm-"(r>\ *adSKUخSI 28δT5*J2\1wc˪$FGRioXYFw˪Z7$X% ln8XUњJ4kbuj:=z$eh.-XY0xn?aRR-=uPR5W}%O2YXr/lgv9]뱬[z>5 *Lp3ڦVVR4 IgdYxv8㓞WM}z3Ʋ.Wx؉d;m8f,ʲc88d =+Bt/2@"#HĮݖRn{QBc5VON}$W`>88J1 O^Gghc _#8\7R^2z^_WkV^s<ߵiWyZҫF5]+y~E#:+Mzs\R,\ErDi0c=3ݨo.Ugu:SiQ#4j;6oǎ=ZrO}\Ia𶭭nɱ@Zb ƶS:1IZtiʬwbh yJ8s<#:R:Q[_3NNN:ϧzN}z+J\Ew/C0Q$}cS]՟qq npOOJh+4+ΥkH|\0VQ#'=yǽvJ1IhSl0UG}pG*.hrhӍ?;yH-I 8F9st}޿qqr& +*mѲI Nu[b֌cM/5j77 0aim㿡犕U1QZ& mqH dlss^p^}L1֧/gbEqn#jMtҖ"*/cue50ctqc=?3EIA%Ȝ:= Zed0\[ݲL9$Ʊ֜js5eNJ针IػWjz8IoF=>,[λVhN8]]5#*:]jtO/dUhwxCy>8u{bEF*+u=]{+H~ljc9^kqRV8Rz6^=^LTKwu$ibff.rq׽uCQqdhN%К8wH;7' kӒO^C4 ]PTqc;ӊr2hΟ4SWkAf8yhf_sԟNt#(GZ ܲm,,2=r#?tJ{F>ڏz>]~&wd}ŽEJ*V٣Ų$lE𧌎ru}MiѻuW;Z-0*sۃҴeo{.tM*,p1 tl9=vGW-gx6"s .$R_^+OE_JY5s]ǵ1U.tFv99$G$2NUvn)9?^UN^WG\(qt(~И(ԕ"Dc'Hۘ2׭E<̒X۫{jcNQ}cJ7{_e̜͵UDh1 P̬4U9RUN6Gk}kaeY>/ບCۼ18<Ўt{g5N|%a{JxZ{K]\I4hwqުJ4yno/eQE`\:ܣ_kOMT,A*lYڪdI㯿N{tGXmFP/Kq 80۵Hx&rOOsiʜ#]kxcb lQK`t'zގCé8ԒQWoo$[HnJok.~nUՍKdJOmiY`PI>ꢥ8껓R.]YrJ *.ϔ1\(^mQOy!+vl޵9smM 49e NxVPpr=')sX}|Z 2Bss9#׽\cehY#Wx?^4Ș`Koňøpz1ݒHR5E2P˕gs8arG٪_f2 n&y2*yztްfC,\#WReC:LaTf۵?TTR1i꺧HЪ2H q\HA|ʩNbe{7\e瞧9XJ3.w:ZouqP_46ѝ/} #i:OK_14t KDܻ>%.{h3f g9>HJ_H%xj`պ-٤A= ?zVUjE}GXSvжwJ֐²Yq t/5BVMuI:ɸ6gޱT~.fߡjoC!HUܿӏ ԥԪTZkH *'ʡ60k֫i^Sʤ}+ysEQ)ւC.E6k@E2$ ?cDZP}N?JTOUƇa@8_ʸ4Vz~~_ 4lf+`NhԌW9jӣ*ikmJcUAj+asϧUIK?s5MѢ7̞;|g8c0, 8ֱ:+ium-;?5Ui9٣,v\89銥.M^NCHd̓VPwt~U9J+nU<<*ϞRt"DP ,)3t$r:v ;ɥaZJGNջ}2^\,K',*W--wao܍z>4*v°A~QOO:=Miۯ،5Ơ`U1`TjMioNXi)m\J_p $}isJW2ͫ=_+.W wF|ukjA-G(˹Z6 lEOc8]rʵJV_4[f6"Np@~i{5b7 [zGߎgNk8qj$eRQ.V˥۵~'ny]pRM=.4iZZkkh~d,n7Cx95,=>ggoNw~nYd' bV89ʝITL0N8K;p1d(w1PN<QUZKW]WE]LV>Km}D-YJkp@Tr˦t{l?+ԵoqM6eR}2rO8ӭhݸERv\-,WCk`noX`۞y\ܲO/VRlrGr)KOv0AGvBTy( ȶ3mURʙ)~bz֞1qӯo-!(J7ۧܠyjbTf&26u q}JU=%~7[=U9JV^w0 -»qe6F sY>ETUet]ۮERR<[|EKFщ ('ֻj:Unuv_~ ӊvnjefU]#OZ妽[^uڭ>ZnN^ۭЅXc1;dc(2ƣKQm w ksDmqیʄ*(Z%f/GF3)OgvI-I=ϲ1%;zryqk%ekzZQԖgxR{¾3VT6QtjpJd7c}˕FTFpqr8є5Rz.[ukTsAM{M7]7p `liQF*mk_rj`c%:ޗޢ=mV*~x;cmo\8zӖ[-HaE>UxЂ?L5\MSNqX?{X$&oߩH݇G==;:?+Y9!d;P9A?A-jsS8ⰸ-V䗖(Ym UFwj,vצyHF9B:6[!yfVe0y52'*{~oy0 ?lO/$5*[7v8K WJjV/260?@kاu(Uk4Re3ilS+0ZO-wd9<JrMJ\\N̗3iNh<+:8?^f$/o'aaSҴJkKo4kʴ+bY#[*]īso\cq1cm7m?y| SU(f_}WRwhIwr00Cq]Q.]u:y3اwKYۇp9Ҩ]-/<=i>y_LIB[*K*JwߗΤ9}t_!I ` xCg2+S^fmY~Iz\Pm_Џ)>YtcKT8"?6^khSW2A~ca.߶G95>oj][{hInlFTyHY@\#~حѧ(Kkctin߉n,pmhz{'.}J9O'HR6癶l`uڦ/UҫM8-ӿB/}|Hw6NI珠ֲT>Yj]N:)Ji)j_Bc-#@ c|"_fl lrF8yI6㞟n'`Rnl0RۯGIP|ƊT5%gW ԍ!aXl#t~fv1ۨF-Tk},=<=-_Zkk!hae˟qkj4zizƥ_fJ<;4ճ=lb;gVNIy}?5}7J ەc>bzڽ:qjV:UK~$ jHpNaFGr>)IsiN1['+jZv4Bř#=x㜜UѩdN#NU.ͫi9bUXTl;=rQ}hTKH\[3ɈюI??oj菱MoNVI[ؠ#Fr #8|>t}|g̻MaƲRٓ?c[I%0H1>sc@kQV%{/UJܼqAIlnflYw1OcZklc~o\̪Vo1Ca/叧k[1u9lE)݌>Ǿs^יG%*vCg[a4[pɒّ4֯Y^N9kV TU66ߟE- ec57,ѷ,.euv$-=a2" *V\ ]5 M4RHE 6PfO,Lo<EɾZ*ĻͺMt*9AP4؊sVQgIS۵ meaqՔh%#y/ >9s`cXrݓ#ǧj߯%ĸܮ!I^`ڪGٴ۳;*^R4ګ_++-MyZgq bEH#f#'x;TKjq;ߪ{=;ʬ֐زaP)}_uzmnlNK+nt[XHFrGJ>._ÿa֊mP4SlU5WֽaZwM%حYė;c9cwӯlSvf1%9'kzK/tJRҰ{9Q<]ɞI~ie%/ך=d\+ӭ'Q/뿠X|︻l^Jn*qjm7} l[odGPO~ڶUuc<:KFa[(d<2q]0өʩ)TZIm EQȱgqn$~h븢a&XzOLWgjiJJ-b[x 1VMUn|c(wHFޜiM1RolDw=W)Tn3iV x I9sTRMO"Xէw_+G(vOjtbV#寻c -C`x}9XW+aeʟ _kk|=3cq^J9WxFkۙb)JZImm s5?}$䜌qTNۓ2ROu_!Fy2I=ORM_Йb+[-B1te(Yu&"E(cc;`zt'~JmRW[ďe Ү~n?NE>hʮvUѫ˥,Gifj{rz犪]Goh] f B9sV4ʜWrF5+GZhK&rz{uUNpS3tNUgK[{7˴rp~9Zu*JЊrݮQ6ܴ"];2j9sڻFnZ+aV|־ߘK$0׆\\n:.!N&bR-ݽo$#ӥtKRRQ4v#+[W#UQǙGDܢ#|U&eV*A'$LtN4=]<TjSnO|^ 8I:yejN$}zÎXUdV#aFLʤݽ*)l5bIc1U2|ӯT9J8K ;Jn|#Y!c5ܤm^z=l=YUEm٢Ki|3ee$:h*Tc0jq]AD}+nN.AN`s׭5KM0T۰y`U!ez:2) lb(9DeE4YCBHwvak",Oy<ƹMS֢U5hG~QjʞTsr$uM-9#=W*G#z9$pkF|g#9өJ-#8R[S&m^:sʹjܟF*ֻ[z,=mW Ί,}@T:RGO_*|qir~@F7rH?xF31q?1#=j:I2Rqt!2as?Ozq~:e|7aAm$q2,+7G ׵cRS攝̪VN.).C[I#Eo6qjThѫ~bKAE^~u?dL74񜏢?vr{}nK*+7̹۞ xS8ۚT,ֶ$%{2׭tS8aܶӍNg]yzH#Xdoe<ܒp)H+{b+y-H%C81rw:SqS׾rlN>sq..@MNRꍒV: ˏ;O{NZTvMz)eRl$Kf+Oڵa*;-٬ʵx'/A z$W)8>ү/^ ){d-My=݃nª3SkJp/=8}b npQѝVR4jz)Ryo"VGYaa4|(H4K~!rH3(W`zq[RTu#(8wXXdWY-&Vu)Z,2RdcpFWFztʟ,9TnPMXǥW%:tZRjߏQÖ ILk(h_4;F?xڞblĥd۷9}0{fc-M%HEɹ܏*=^V}wSN Vwz]aT@s>%Ͳ茱KNރ.\$+*+ʯe{ªUm8yjUjr~ȣ+z~j#)gd󥶋 1I7n'b'*7u#Žw=~Qҷ?CSbDO[ګֵq ߍEOݾցlaƛ9 >) iki@8?1DeukE4s!לʸ,v3kx ǚ?5K_nVmͷcu}e\]Pߠ)G0W*7n#=z|=,-}zۂDa1pxO8#]M>߁iHk~ߧd\mLV#3?iȨ֕Jw_}IX 'j'h=8gRZOӒzM2ccZZܪZm<-̌9U\ +ղ[R&LF)^>鼨F _=׉vӑҴ3)VV;<&yv p9Zz1Ԫe*HĜs󊨹r6"y~k\4N}zcZڛQGz~ϗx[Bȥ>Fp?Nu9aQrr|>`2$v(HZzqq iimĐN3k[ֵͩXFwZnHVџʶz{U:Qx:܍.Kw UbTD^4lZV7:Fx'? JVN)4cxyĭn{/ZGܯvtOq,reߙG{uy$sSZJ$ږW.Qӵgrv+ݗ2}4Ͻwf%=W埭jWrRtdDďdz*aG cWqo34#@8hRISNmɻ%{o1{99 [;&lgPhՌyMycx۟εTz/'[xȞG|8(6F%g"[л9219QvTye&!.&gb3yVДrS=ánm(iTF^it3K3nX߯^q%CsTkQcCYkn{gҧB#SYԵg"C,sGmszS(˖ϡ\Λ+q&YphL=*i˒|ҰyB*ݼt{qJ&)]_>/ʴg$S8$wRGmi gӚǖ>^ETs_!:227gqIz]ɦW-]KHPCersxZTck0\Ct$Q's^?gCRe$fYI`.9NQ4._vzRfq?CS(= ̭ߙ*,77`ON*%h#KGvېzwOY]ΛG3NWr6ZFPaFk0 jf˯Cjc*vM^ #n$r:zP3?g$ڹQo 3# i~UEP?S;(C.dGY̻Wlg1U9l9?iGHXW%PJ9e=\XR.m܁7J~ǥhH.nvǞ#=ǥ)^:`R\ܭw3 {rx=кQ5[v󰌱2=۠J<4ʷO0v2\cU ZkrtǖbO#TR>ZtnYP)F[))^1r g $FUC62HqU(D8'6Tku1\yr/NO֦ۛV2)㸚L<"Pqp>QQq_ol?*\}3*$SN[LJ*^>BB7ƑBGQǵi:jGIXmߔ6r8=S&4T2n.W9̫̅O9<?Zio_v]K|[p~Vbr}#+w(WЪT\XVSӔ9dkpJ[Zem텔`|ހzЙS湥bsy8ʀxӊKVsʜ 6bxXdf#:r1rqq#iJ:;[=B6Ao+9Tunr-[Rժ1C{pr)Scל˷(2F0V'ɻ+gk%*QR_Uzv}at8ZH՛G?0ۑ{V|JXteuٖc-β䄜N߇ұQes΍X-$pmu«2㒻m|N\M !TA#i1:&G$f{΋'x''߮<5yn*4kmbA&[q yj)\ar yJJܷ\\u5ỌܺR*6uDJ,{Z35x#?g(m c)YF .~l4nTg*m]4i"i6ݍxҒ$Jyە"M۔h_^k;;C;%yP[xYLʜe(G]Mj7Vo3{>L|Q~rRR)QR`,`e`2ǞN{TXݧթKW8c3>m}? ٌ${x?u2wt`(8~X'w>OY;1֕"t*4+)?;OˌqXJ: G^wӢ5-A\'-׍RQ\nKr$Vlu#qҩ:i$6Rٚ9ǨDct*2td41-0s* u4ϥiZrDۥ4-#@%NQ_aqX'%AM9J> 7ךV]U+sq-fThuڽT1 1TeRNJU 6͎p:-9 8(o=GJ$0g$T۝ni?r26f1+޲vm0EWjq։sF8-#;A__]L_7eN' +r6g9L+9GVB~'5Pr.FhT*#ޗfI1LO~s~%͢ OIFIߥLex1Vut'|{*S4}^Chj*+Kuy{vSeO o\ ;|ΡNzd皊cXSR @ȒC.TUqڮ^N2+]|Q:XjҨ*Q휜e_ȪqKy9tJ*Fuyy)Ê+Ncu#Y"eS^i=z+x[uϙ,[?_T{F*+]tA ͞T n'~Ty(~cNR奿W2c}IZ*~|0FMbLgph5Moh֧' =Pm2"U1~xYӔn6Irꈣ|&w1榧V4[w{K/"Szq(tDlWi&_&uf-}%V,G g7{)HI6Hs00{|ډT;- !KjM5*#0^;Q޳䅘Fj["gfqVM\zc>SXԧ.䎺YydccUqcfrna"T5Wi$ TJE3\Da8 lBnh誋( y}xD_%8pRK ǥ FDFx~Y+;FK!ŃyF1GLh|W hc3H2%C fF~zFᢽܝ+9TV]7A=>SˈWMl?h䝧`3׵yҥvP9q7n Q?ҦQ$WUQ.KMʬQ@pz_JW'{9]q%{$B|6QtRZ1b%Yx^sҺjJ>;|uz%w YCl2yU?3Ԕ-&bNU)XVWFr@8lu+JRRk&dF |1`HsUjIY/;]. y24l،HsBi˧59qƱ"Kn Jg]jܯZIr\6YVkcRKMt HǘwnfWЌUέJ/{XSTry#Á^?`qLW2+¬͏8ms8αqU}X9SI#SPvX;9Pcy✕o#d>%ͶX(:Ɯ}HҤhY[%*fMb2A}j9SZOCJtc>i%uBZC~&GWuOS0ھv:ð[FydvfA{gװ9+=^#:*|kMlmV5Lw9Q>X]ugJ"^FYYK^A:]]-ߚ]K<Y|?`$<E]Ci?aO$(Cy1չ }x9Z:*1OvgJ2Pn'o29c`'hv)) R*pL-Y{9-Iʭgz[[aImw[-^s["ٞXx[d&58N.)- --| mгX3UGFZW:|GːTl30PF@ԧ>jq[˃]Ǟ8}QbｗMNzxJqu~pr-[{/˹_ZFJ*__C"(K`Nr| ?>՚וkg 2czҮ|U؎XUUle8=kivtb]Ff<`|mAF33Z{чM6}~G:Rpr-ר[]IsV*&ZN[mz[tGuUluo*hJ+)J <*dsBpH1e'gZ\~m69~Ƃ@>u۸G’t1:~ǖA h `EVebgz t&Փw1Td\[y"Wdɷ}8 xj)$%NU)6v&AcTeۜ({{ҩi5wcj|OtYm!a䓎aWFm#j8j&F*>Ϫ,Hf 7mYGʤ,zӧCh46t[H]۶h{\vb3a{O^q5{/ R,4_Ÿ{udi "y9ɮqz%q];k(YH uaHJ IlwS>U4mԆ8^]'&m2w>{T'Hm7;G ̪w+U2ny"븓rGUdUܥr9#mGݗjzӧ#!rHrx>y**z%tQLb͜g>~^rrz4R勼VMӔcZ}2;1f )/{Isr1\H3៘`ڴ]uVj侉_BʞRE}8\`_Z2c iTOul.Ivݳ#cD*J1V*1)9rY0Ob(V2[Yl&^A^_ʉ;ڜ%Rueou4AXlɽ pޝ8EO:Nbi%k3.qm*4>iYJ1RKO# 4q I=n%c̛XH֦2)(:؜TqZ"3߻_s*vܺuf}Q Gu.Y g3𨚌Շcn#䵜l&rR}@J9ym*rjRn|`.qFsȩ(?sSؗ3$pFeRm '߅<`Gֱ"=v[ou}0oos\;y]*+sa5 RI8쇕VmLtO GݛJ9n^I\ I'k_Z]BM@V8#YSs9u)}Ry/~UϷҕ/g 8V¤4Ԏ"w˞xOJoMB*T!mv*{M-?*P-dSM DW]T>Ы$Ӌt jk_o†dU;E^GX:qn+)she2;gh['kZTjʝ7%+Ǡ[]CRU:'ۉnO#V`dœiӊkm!Yӓ@\I/ix:U "ϑw&6X Nwc)uHxѼc=x4S^^>ft|IYyFgVa.~\d$8F8ttwowDǸz<>6ZU ՝]ɱmO0*ȑvHG8?jSa_5z+lgB&R\vGH`dB8UOnu<T>#bEm%f qVcɍS5F8y-O؜ElGmjB BvڪyNpG|iE-/Ri?E8lUCI"rvgw{RsI;>㦍 啖 \ӷ$d*u'N=:v-F+kE^W"rmCiJt!Ewyr)a 8BeiC[~$2O$7I9py֮GH*sWՏ3 rv9I9;;Yƍl .E̎3\gmĻY{9늬:'QݦV(Fu#RroնbA*ìl/͎0O𺱕>u>XK4稜g-Y6LjA=@޹3WRZZx4%הQ_2V2*)18߯^O K0ibd!km\F͜{}kh¤i-iVM_$gHlOjTZkZ4Kȅ DUR=:%V>._ RH'mZpƦ#BW Err->]ȨKJKv! j;|iMnHێ?*r*]٤([k ;< 㚪4/g{%E)*ЏqTVlS;ҭq3U z}r̸¯E`z*cvsJl4}Ώ2F389)ڣ뜣R*[i{SlmӹGs59EMv1T(Xq6E ,ӏZVP]HCYN˿-@w66syeejŴv%?ykW?{qt+-C:;m%lϭmNT)}ۿCŭKzŏF^@|@z1K]Ƅ.Q;XuWWQAFeQ6hٙd#nO-ybX\rF[ԝ3zتTଣUvZ;y$k d^|c=jr>mI7rk'm6T[w ZJyo#\ \G4iiY+"yDIOPӧC u*ahƜwх ʼoad\gp<֣KC[(i 5ԳE&6qU*_U^_3RZell4JNїSPZqQµK",.ܬn}W#ߎ%$S美-Ln DZt"<6ChE9'fEtXv.YG9>e*i?5gkL 6mˆ0ve$#>Q;Wk}GJN<ܰv>8niR;":殪Jqjyy&fH #4S }}O>WgJۤ̿yFe)]ky%2ı #O1-Bab Iw?aҴYcX/PpY\eGLq895q~t[GJ[__$15B~eFck-޾aNR~dtmp,d(swƶѭ_?*sߎ:~Ҍ]]D:T쒵7 qbn(#pN:W2skQk1)gwz}jJKWM(xFV8pHfF玼UGNe=Sĭ{݀NdI<k5~"lg!g$tcJ*m&`88׈#Rs\^鏡cEroeJ9'I4,Eo$9|7^ZJ5U-HX\<) ,Jp@㎇NR1z}>FѣQy"i$Ϳ@g #}ףR<֍5eg *]KTEO1n4w.-X ;yZ\yf~fJm{_X(81Wm̋U#OZӔ4tFsI,,ҩ'$T\ל4V6Ec_)oTϜÐ~jEmmkKRR܋԰Z7ުy¬|1=zT_6;eR2]Zv%oq[x5Te2Z\?bZOo7\i{'%72~+pY1.:d?NNyeη-NhM-p6HNN} DkE>ѧ88&ۨe)Tݓ.x+*dzKFK+[bDy6n[<UFJ0rtߩi'+;wwv}h$8c؏qu_.L)5"yEKO7hW,e5Ys0jAiič~_3A8l^G BvKAu,-3H$[ q'*Z%%mMIb)W2V[x"I }۾|]W0SD5?5L!EF3ێ'Z4G 8=YT>3q|F\/]mA䞵Tǝh~k׌Ԗ2&5ƻs{@ % ro[u_-]] ~N7Fە0\ONM5]~nܖ@1F 7qԣ.~w+~EXӊWYHܨ9 `*ޝm'~yzڳN:huVNy9F:z!G2H%Hۙ0qn{u8~lE S=:KRp$-ӂ9{bDesJzVֿiV$a9~)T6<=j>ҫ1>M{ *[l߿Nլjʴ.­^;8?N\/&N$MhƥEu^Ҕ)ˑ;﮶,] U3sAҗ=^jS.6|3,0%jrЌ}Z1j輎J5RšnWyzI[3֝Mj64_"&":Ƿ__=.zY6 h.вHAVF+0l˚)|3N|N3}kԍt*5%xn6V%O1B5BX$ L/˟Q3ZsltԌyn+p#S篹?Uʒ(0 NNOJKR2U-bY~Wf[et@# SS]Ď8Z9ɧ/soh Z֥[M8E?zV '5T1BDZ|.-̭nA{c뿖1O VV,An [jBNxN4{:9*OXt}~7\o,7>` OqªQQwu*kOQRhwy"'c1tcDNTwd_:56$HYN{O=.Z>Stq҄%ݼl \r4SN^W3JQ%㥽1rYӓ~kJ!dtLBm1==)J1m3xƎ$ｮ5̸ s1>Fe)FNQz>={ ێ2y&y<})6zIk<ϛ1㿭sʧ5{/ޤcB]oQ`KVR7>AV4]=| T"yd*i%&GpАN[zۑDSQasQ*k_^O1[Tsw=R,uZv&o{+YtD,g7S̫n!߀:=3SOKS O9gk[H֒2x?SY{0򩅾UddYّrI>U# zNrV pB*2^O#b(ƿQirУSh֧R)=?O2Icfdj_=u' TھD4ZVv\1b0=0=?j1" Sv$;p$ nf2x=QJ')ElOWNjC$Ŕcە㯿JQ{kqiJ oBx\E$ t| 3PMcʶTKt5M+wD\2@=:߿ҜDcJSWwře+<Ƌ:zv2/2r ̸,F]>IlaT*z7t;2фl/>nz֕9c%o)VI߻Cn`X#yèk:'-K[?$P#5_1qRqۑ;US\ԪG#Cd4+C|탂kӿe:y`m?OK6.XȞL[Qm\nj=U-eӷ(h{,+i՘т9OgNjT]9YNvVq,Ѷ<ݳpnyZQQF4UD]uoګIk/ }qD{:mZЏ,R[nx[@Y/ɵ% F01>/iF-ϪѢܢ :$i%RѢ*lq;>4զOGk ?**x̣̽O[FkSj}N\B*.H3Y>Y7n۸5ģRpoNǖӓ溒c.I?v=NiS 9^ 7[E C<GǙr@=WG\}qT@GhTڼ8B檴I/Q{h9pVڌ~snyF:=2w_4:cO62 c6sק^+FkJ0OT 1OH6'LW:QRݷFm7/ӏƸ߲NmūۻMȿlq;.kxHM붤aeR9mÍ>TrIMيI>[mr~HTU/aX[-yӿif1$|+8my:z7$Vt}n ƺ9ߙ7Jl`Uy=֔o/w)V\joȶi y㸪h'*գvH% ք 00G]oAC2+%P0w˞ݽZ]1䬬K.ݫ4|t۸'.ZPWr{LEa%m@Lȉi:QߧtJ*w:c'**Uj&i7.sخVk ɓ>C(~+Mj§yKvݷsװs喯}U%fwX0ɵygU_S8wIUmnb{>^kܮQQrW}$>Ъŷ|ʏO,U*TNNf%^n/o[i{v_:c+[{-nȭ#(]\=IlG+Z*eWI\wr1MTt"jF[]UQr8ZEvLeHD,1vO~MWveFj]K;Z~_2ݐ9;zTfz8z6KCu(v=7':t$5T5edڃ{fLw] ;sZI3!4~ΣlTbݡ:r1ߪ i,ETFbTdvީ~nVxגM0`TgxMks!J+损,sկ;R+tr86y=ɧu1ߛM$;Lqu;br2Ok6:m?@o&hvasMk)KG2dگ$ WJNQJ1KFUPُn*cӚ;cI<;s%)JliRJ3)g\sm SF{~4{NX)JaHb5 op?wN-ez2ݞv9G{Fn 4Hr^HeH*(εxy-OvS$gG~Ats*8rhPYv;vtGZ.h]8UrHx0jz~ QҜboA'1۷2IאsS?G4cD[Lʬ۶H׬Y&o%I$Up̣q=j{%r(S_M gF@MpFo\Q)K+CuۯF5WVi$U@{zT N5$ȷf]ZmJ2_*ܧMs9Z&y*XԺ9爔#ds$g10_9=c<)jVHHР%Xdp_5<ڴ. |pxbM8  Y;6nNkR/ud$3O^N(Ο;'kr&i! V^1E.ta(IaBQgFYLWH[_-tݩ1R5?y䕮di-Y&@nH-YF+oV+JOoQ cm$@L8?J<:w+j]=⹆c3Y;W5r|亦Us{.F-ݏw"odsNG4dO 7v^A!R<":~?xyo23g>2Z#Tlߠ˜JaW۷$hs_̙JZ"(hE$fszjf۵H.X68QQOHkYlU[Fs+zQkNҔdЭZ07|ǟZ*7ʯ23b6玜3dN#+iZw ~U aqM-XZiJd+UXYEsӵ#y$\+#`{3Z/vrs[lR0G>̢yU"]$F5sX@6=s ӌ乖Dmߘ4m=})/Y~eD$[ޣH̽U4$[Gq?#nۃөTw$Q\7Ő9RAjeRQvYYz!!ltݒrGO֚*"3ЙIY1.*N:&)JTwc Cy^xNIgTmIQ dP(eʵ4N_ h7i)!e#(4GvHsn,$mX>'cis5Mus#=,Jcl.g\!F;o.,eYVU֦1*o-^ 0>_A8>W55$?v:,dV A~b>\1''MԓDVA `3v(/Q$Wa˵MYm>rKVm:\ϡ]/͹ozyycߑ^b* AoõL*!s)ǦwrK,yۣf$*uu 9ζn4f5% i@#T*jYKszfCʫidbzv3tЭۢb1s4ֺK(Y'sHa;@OlǶsަ>riMJ.]th Sr[,lnqFF7v㯥(:%uȱi"E+$jW$GCnæ+)+]I{EmBl7YF@K+XJqibwDWsk9S3|my3yS$?#SgBTiM" v[kc'ڎeT]E(r6=s#Hr SՉ|ՖFb VFHgO'\W\[\QYn6,je|8zRn2R"YLۚ3<TRqHڝѕ9ZT%32;Q>_S: ,q~QG,chG3 2.$y iۓ7t+]KݸYԋnsΚ5b,J|ƕ~1b';U:sОiJӖt #ٲTc9ގ^Iht¤㭅xV4eUSn7Ir?Nc9QV8V1WV4Z8=;UFٷd7\]t{:~es}oxU<ZCTܲBW9ˡ2.fÖvFhXà,@#֗/$ymy#_pycT˚lkN}?$ƞ`6(֓4v'#+cITe;_ݐ_|(:?Z^2"1:r1bݤsx$RNhܷ}Meo0>e'S繷f`w:)&6Jj|O Ay8ms8u Qj6]{2;?Z/#HSiY0ty,Yz,ujyQQoͽm8  p‰@QWqn~tif/v;KF.gW.P.l7BV><~&^QF9dd>\! ^Q[Q#h$[v۵K؜q8|ڤ(_g_;ml{ -t/BH rm q=9c{ìFIgP)J;Jɍ-,߼qܠ<S+gGvWgC&2b1돭iƤ,?j=WevQmWk7(mj˱6m7(qϭՍ;(o)Ic]ܑΧxJ%R>n1ʡ1998?L`Զ'RfWyIknN_$cNR+C~âZ,Ic`Em9F^K{*զB.O61o wvJUuV'Pry *:T r3W hN<L QKM<4 |m,DzsGz|R5*W_k4@?0$x;y>B0FK~"ھئUqvRN3u}ۊ;I|(Kmc=9cmw_=k3ң#ݸ_5QPyZFVѼҿ4w2ĶbuV5(871/6،\[d%Vg?JCVʢq]_D:Xu rNT{}GZNWOz1qs"OGc&ys' Ky8W}}qX>S{Hqףn>7Xq(faoHOJI%ڋNPzݍY \q?7v=L=9J̈exFJÙ#w򑑷tȫn0>[kYoЙ (HWCcF:`.K$ Th<]}$Ab[ T-܀r?*!6eVZw,eGlz낷6"2RQnM$U%A~_nyr89"W%i2mݴ}3XU<$_:aܩ螺K*B&c"c%'RͽocXu*|S7<-mrVHn_z%/&x1WWH%Rb#kHԧ*vF+<-~D6J[Gg"yj6N0G\<[mί`?;+| >+I+WocJʍNJ{lCV"5UmHr0ҹi{X˝1N"$6plQV=Oq~5"T}7:ߣ)U:VnV3 O\~KY})<:չ+}ebi6~jIM?cgUSR:ۤUSq&QJ7By ¦P,?.r-^EaPe {{LP[ih(S6Iia;*˹W~G)JƵ:":'ke`#q\'4PK,? 1460^+,ջ$\4q6ٹV@vC4\RVg&Kul%jljXW4ԥN.Ыt4wĆ/SstPO?jSoTB{E+s3ɕW{J|iN:q[FOٱpv1Ӧ}@䊪qZiv\iyӡ]ȳvžO0I g +:}[yJYb$JW}c̒]q3^ hWc'CRg9sA3\C60*W#eO:n:~껝TeNA yXʐx3c=={5rT֛3(%RO%^x6<_7_(`}2x'ZҎ+ޕiGTkXy坫,A۹a{Y;G8wٽἅ%#!S펝]KqG#m7 |l)Q8šrb.a%Ӣ{q6׉Fͻw{g1C 4Dʤ}ѡ%s*w0gZTd鴗{؇R4hRW}Kgqn'"pۿ[RZ:eJ4˰x@M񷁎>4NRhԔ̮+Ck)=:JВF.O6TpT5iog7$lgJL*퍤e鷃rzVtڲ[hhlUk.<&\b<'(Ri_Pmm]2]TF=.Əo95h.*r*Kr,`ZyJ&DRl{>T4wtp#h'|b;yRO.b2nzOZզ97*Q vvU9s2f{U,EJ]{~?vZ2LsƖn?/|O\<.e3ѣ[m-իkv6aU#F0}9K9n[ۨ@RI,&"PUJ ;tO2 Hqf m%Hp=+IJ+'(9UnZŸK0醓r~PqxjIW:Gtv#mSyjq ?:rK҆_mjv#it+$>[MI+Xl}+:vW&H3ưU{U74u1jJi4OsVou#QV%_/Rzyws!h٤q{Urؘ\Xvo*RWjڹqN)Qo bhۀ >9slӹxzUtI v%gYܯ9׽MhJK'cR);]>bHc)D1ðyJr+[?+#*2+A#IZys.'LV3QmКF'6*Hn.V|]iN2e^JIXH吱lB13מsQ.EjuFWAn1J3Ѓ550M[>J;w&b΂8G/46yRJ^cWd-ˈ琈9< 8 tb*G܄ʌ6n"k-o fyO#R^X+o5VM4#0ۯNRIFVdr>˲5člq}`xSJ*52Hh<]yh,wR1n22 Zo8գUɵ܌M [av̟*<®4iՒވҍJkya[hRT9E;y7o󦵫ZQ{o{Α <̮m Kva+2E>"{*xv t)˖nbTי?O.D.6+w[ˈ*Oc]эخJK"zqrts v-Y3l vY$1ۿiǚ7M\Tlv15ÅgVenvnߧsۥvЩ*.8Esrc.X͑>]^>ӝ;3Z?"` W~札=FTiV2Bbe+7+iq2tuo,`:ȬKzJhE+u)ݺsmxؓS:ab6}JC[ _1Uc(˚~T8kI!d?ޮQXW2D&jL6rNNOaW$䋓WߤVg;.Yy|=?Z.L7Mt.sYwnAv9d>z\2JT+N:,eWa%z r6qDmn~X<©*7f3QglhWgiTu>%dRj3|Ҷv0(UӕipQUtӥf@"p¹ZQխ;eRa"TQ+/fN&YRWS7)ҡ}-4RJ:ʹuNm#1Y3_n~5o̮.bR- MswsKYryߦ+8ьvl^mQbf5#6cMISS>Z.Uf #p0㟥O'v3NpȜ@fq9\֤6ӧO 5}(<n^zV!^r9PIigu^ȁ|FW'30Qzr:FNV4nZC\ոKwsb-#b*aF1ԞOn*J5h95wm %?z)r٭^{k]<ژfɰd}:ucRͷBpr:):얚ߩN!]0 +oP@?8T4oѨյ]&bqj2PlQ? =%XsǪIn=+u?N6:.Cqgl?sR՜1T/}4R- Zz.z;pkFI;Y;Q'-ikܒ6|ˌY38!$22mQs5ʪN[+tF҄TZM|bRcSEUv1ҳG޾)Nrv|,c)zgs9'trT$Ր4Vc*˸/c+j*NiۿFKfmYW?ҝMi%VVb,V*k3O1>s'8wVWPOJ?G˖^U6qYGkm|D[g屒[QƻCB ЗaF*uҫ{%k6SJIqnH9PzvU%Nf#ҕ']n,y1;¾bop?:V5) 7VwBDFue*yWzT ? SRTRɽj?!%ɄU^VNP3ȱ=#qXſyf}76Kio1¤C|ۓ54׼>"5#YUw'E$^W@Ó}OjR1o\@-Y8+ Kq|q\=[m Os$Uq\/dE?N Y"1#*cS9G-u%:R$[30(i|F9ۊJIV&Qv^cM+Bn{sq?E?u6BR'C>jM5$,g=F81_"aFI9P[s+mr g9e}(Y-15b :c㿵O]јSIKF"ATw 7ǷZgAi~_>o$6MJ…㝧OOܥ&\Ǖ_V@!o3r67``OJN4#Dq#[uX-& Ӑ;W%]tLe*[kE}z Ed,Yh2P(Rh{KDqyImd٫}$*ϑ"ɞU/yVZHbܜuҲmGU(z|:5rӏO+l5HJ߹UWwаZ@l ץrb**U"zi/f^8G@ڪsc#V6J ۚK,Jճ!%[{zu+.Qa9cʷcchhmHSdrzȩNEԆ .n|ng^mSvRkO$yTV *$* 8AWSsALrƜOZyY;oZs3vײ{K.?>/?8たU/ih]B?ZJSkv ^9>7.80S8oˡ%;FM;O!Uc~aM(Ӡ.hoԭpסV=JdXr|#$;LduzqO>2%iTJ4X('LӚժFJmBRmu}dA RZWkaThu*hD1H(trƋÙ?PS)%-6m %XQ.;ժF8YvK`B)?{m 7^Qvb$ߩQbܓl縌oWV^*%M5u#4M,m ~LkьSik{~FJp=` -c68z{W^RSA߭cͺ<B8r+?r&X|嗴[2C$wIA|<܎a~Z--~91>SKB1ff<5UIZcB4ڻ[q oqpFNzzQO_g61~:̰j H3q޺p|IL%e* .BJ[en֔gnSgvJ jh廆LkTkh4Sǵ@O5u){ˮt:%ӳ̅d[Y66.gw'it-^/59rI"kh$i<9aztmRW.mhdԆ/c]*Y2n ylz'+osW[5RA$p[~6@#sӧ)+Z]/mך5Db1@tjZ1sU9Th6O*L,a[n7O鎙,DZJSKڕ=:I7Lշ$ͯTaKIhg+ ,WMJ1ӧS0VncJH 8RYs- bʺcrwrF<ªUZCY;2u*^StHUWoU@,H^Öxi&zשQ##nq8]u]l؅Rl excׁqW6#Nr:wZ_?qF,W5躍V[Oی8##<\OfvGt3tkܚQp;h 6Oq^9mmV.-(-]MI$, +8tֵtΣZ )+ !DldcƇ-5Ϫާ%wl ;+Gq(+G$02LeSϯJ.Fյm<>24\=>ϖJ.ҶMHJ^ia,0^S1>qT5%I!r)91Ie>O+JtVntW[~(%%Y1VH.'cYR7vC8T5#{{x^FfYdV.1y"Un~_SB)~k<-Ŕ/ىѫmOץzFRPmSH8r|1%SGӟEZpc~FyrIG~Q0DbYOZN3[_͉Q:֊n]oDw%UQzϧJ)өNohw4KWnRi%Y%eAs+ZwoMU(wO&Hm۬ G3.m={V..YN\"ݺ!'A݇L::ҧ?jck;iR:Y>ТPKRmӏ)өIGjZ55u VͤP3lUInînirO5Ťa5 >(Fm>m jReM[}<58 VqNy59iOsvZيJ2Hx i S +qV)mC3 w׽lzm#<;QN k[hB\oFiFcv߽eN:뫥V1߮LừLnS>lXIT+6+Ikw˩b쥬h $_~J87Bբ;{"'lxc%VW|ɞFݕƾjFӷ$m*46ASQ8g4Lfk.ɜ|>gk9R:V:cp~i"k1.&6Yv͆$p:|zVj)J]-wn< +q*(?t]^\a'N6OH&[r&7S*j<Oit+"n/iFz(gZMۤKk?乒!7Oۥrԧ7Ei}~ܴq]Do|IQsۥVJ1IsZjZTNFuDxcc'-NI'3G3i2},\A!C' ӚW‚Zxb##t.VjKz=XB"I19ڛyfnֱWo#7=p I%̣w HzVĥw..R==u-͝wW,qr+, F=O=|ђ)^&5hޢԚ L'dU]Gk?F17ʽ<۳+B3ӿZǗiZZ"Ţ #X`!18i['^=zm30K 9JiI7gY`Z6WvaqQӥj^*Qۧ|D#R^>Mc֛ KuW168<9PU"oUөiOoݮ&G'C+ &VSطp3,pv30=Q妹[cB;Gnۉmׯa_IcҊz/[Grn^_2\]8ٮ g|ȘI]|jR/!d19]1GbU#ȅW>c%ԙvʻi`ԣ.Tv 7 ya$jycJYLqڧl-!*=+9i̺EW/ϕUb7s׿89~J>L֊$Y`SFkO{&iXϔX"D8x-̛1dğX#׸y8m]VV\,gr<x~evgRӚf-n,x8n3TD^0E*cŸmwyRT1u-p` gd{KOK9[uCo=݉$aa}͌ѣw9P'hٕr*9h{/~6v˹^ ޹>җ%ՕJ}P٭$E-vVHEJu(~dVN;AWfs=ZJ6iINckn2 +›qo^n:qW:%Z. Hc7H8<8?i1羻NU*lM+6n%._n[>mHt>^XTQ? >¥]X;q95Rqj٬= mqou4?jr^#Olz ܮQN|UJԢUJWRaO-\e8&N2\7jƜCk];I6`g9hHRjʜbٷ{} ]6)bqJNM)t[U`|mUH3+:t{}qN#GnK9-HOYO ør֟Gt鷾:UVLrwQJ<+u{>^lΝ95{02yI6$8<㈔/NuNr{}#Kq>WuJr$&iSFV) ɖ9HX( S??=zTE%-h_5,j 3{@ߥsTֵvͰNK4u뉤e8U^V5*J*+Q.&]o7Réʯiw$TJm)/E] Xt8ⷊB3h4.,+a%=)JPnS ᥈bXPEЏiKd;=ޟ\RR#ՒQ_=7SPmXmMRx+^ϸ1 `bao!$kܦHV!0f7nU-pp8{GS撜Y$sHٕXF9NA=*,4O޵CmfuijAMIk{)cZZzzIo+(vŷ2!nG9#ZU0Z^_sIb!JIaEZ5ww;:ʥ PzMy[%$L9?A+pmw:*Ӄr!+;]WsdߞquF[8Ƨ-fQgXɒ//p$`g#H2*RS:~-WNx~#ET;qsD(g-*jwv|Ә8M7|}+: QSU,֓6Ve$*:5*J5$:iӥBεrNKiٗ|y88z4ܥiuG/5hE"k- ڣ=~RZ%編%3ݪȼ4'pE^Bh.ir^I4]dzVlo;y5F~-ԮUGuncJ^أݜ9#F*;YDH{G_S:rkIPΟϪ:)J[[Ot񯛼#rvz{WRkli):rWOaal^ɋ9]9!FFxr˹Z%)-a˦L-dQgbE%QoE%̠кTIn珺H>`A1q:Q*qmcۤ*Ff9xFn= ^SWOO2D;:ʪ]2}q#wQZIVꪎiDb;kQ%IJrH۲ޙ){8P`SZKudL#n@l^W4% ^bFH`yns3j9)r|1tf~VFYes*$(:oƴM%k&)ZI XXUןPEbBj2^ωC6ykNi85(vM^㦁lNvQpqG汍\Wk:rvo?1ѴLJ{BmׯJW ֥_yi$!升QO'+Kִ9ty4+v A @df?S5OqM[VݤG&I7{.Uz}aO洳2\/wuؖ);^G$\sU/kхbC$|ϟ+c=ƲQƓѝQQrխHQLjd:=1{5k#9J?1,lye`GNXd ڶ:͹+Y]/((Тm8',qh3RrqE>yԶW<p0O__JhGX'$躈pf;sUTm.Uz oh~Upqv~B[\HL*ǝ][jr[s۶f-8-YFUnXsЌ>mlɩV/b3\g'N7ݞ\[_FgJX&#طUǚqxY'K2rW!at#F15Ny\fXWG_F]X$DcP@<=+9KDi>XA;0R\o' }kJ2拃VFc^3p.>Ճ49Xv籩kS䓂Օe_2z8G=R\CxI\+3|."_SIS\7n>Q]IUf9{U^úגGt'rf 2)?1yϮ:tzz*nLٵBO8 7rz{WDe̟c?(:+@ =pn}+N}.iƊl\\'nU-W8y{ql'%XrʻH'>H5knﴬgsJ=GNRqJbЯ^)t<̌nK(0<~9TO+٪ Bљ7I9cϸ-j+AF%a,8LͅH==OZI:ܰ[-BU6)}t:E(ݢTco7tR̀SYIԲ[4yo{q. ˅f~*S?h֟sz(13K6c{ɅI匮 1<5]~Y`*n8NsƏ*jIοw(aRG}-Qe#^vѩ S8B?Zޥy>3N[׷Qy 6p>(nTeNROВ HYfTO9>ʦqq}CѢ(f嗑㹢t.eFp5XB!yge叏c BRm2 噆F랜aZ.HjQyXėQDfnw7aRrV)T$]6q߷_ \3ztjΚmkqcml9^ z"jTMr1kx}w.y#\PcoRIZ8/…0p%&h+l_hC yW8gQ)EQjo[,T)i8称>b{CK8HPΎۼTq֜ҹ٬]={ D61$װF23XXՅ9|򩄢M:qXw-BҴ'WDʒ_?BTR XG#˙u#Њ&vXEir˙FC0ARGnLu5GLR;IZ,V-#sr>M{9; j@dUځUN8GԗT&L$SlJBu'?g̺xxղl%ki !+yjsbk֤cBuw@eە];sl9R{ÜEW-~ K < 9GnsGGgDp;{ >.^VT"NpK}:Cwl&m J<׍9iQc/uh5"x6Fb̸ezc5Z/KHR-?tO=rp>ZH>ΥF[q ~XXϥ9[KJOJ׾ޅhXͷ,]#95Qwc:QE1ڻ *}44gN+gMn\Ȗ9bLGLcSyoc5%vOb4Ŝ,1ׯV+mR$$Gs{1铎3J1=&Q˄ 9'?URHӌjDs\D .NWDnp;ǶOg%&2dFVK]NI֑mphYcx#YqJ1wo@{~#o.c, Y{Yg-o&# U Eg*2J] דL}ٰK ^j┵6I'nxdhzgzdT]Gk~I2ؘ6ATRWf5*҅KGwdVK4Knʜd`s kFB:ҨN6U?1ppq}xybPj9mQY} IqzZsT8o_e?d;.8ǩE˹8Bu$wԆX%0PUr58ʝ u)-.nOs$8w۷C,jJ--nuSN1ثu$;`7wު6QL=ɹ&2}AS!E<׵Le&#Jtnm򤺑/vV W|%u ]&W)TA?G/2wrk*y2(_3 o9؋#4*eۀj=<3/IIҮQ5I{d͊mݴ.Oҍ3} :\U庅nh2d ؎g۱cRhQt+˚DwO89#;PTҧ|W7^ѿ+wQ^F`jgJ1nb9ڢ,Ӟ=jUZC HY̒EnIIIFєod_"5i`$9^98gm% j!v=1\=?UOYh yrqڿ\*}i>XUa:u)ecǷ\ciNT:n]Phϖ[G<R%*Ԇd0P/>\۹4*3װԍ=9rryH;K=$X g9҅(sҋj'uBevcTߍLyeК\3VOad"3c vr 8jJTqû_ԭ`$yv*y r;)lgZ\7HW8b??T8jITD{F_1C6pFO8Rv}Nw; ܢLn9vGZKֵ.Q~ٖn&bdZxyeQJm8]kЄmkQGUSkEIIq՝c}G rF^r?.n`&2?v 3TOC{zfeW?u[z={DVY}CVl6/q{T rAZQ7pᜭGrŽVUMT\.N+_tRh6,Qȫ|#2;G"V7Ԅ9ȑͷBwmlsɬTdRTmQlא2¶#o?g)rJܩթF1NZoB<[޽=GNxkB2]Ԭ}ECy6xd8lכIŗJHEN/Ѓl1:Hv׎:W%YS[!{8QIВ>a̐fG OːOV|VwyUlH +3ykTz?3{׻DwK42wm~=:rQNC*%O5VyUb9W-I{ӷtt򨨦W}2%o,VrN:w7GTsT6Ϯ3NoVClC +mYxgyF]4~a(tu$x DPKG/c*S}ˣZh,`C;xi.X_LjFgr"ُuT1NN+r[vV`XF9\p}1槕J?KT]%v*&դ*7 Ү}1NG hڷcSqnqM?7E«Gwq^HQ䬎>K^ VTK5fU ~bq'Ʀ27}S el\bM__79eb;I'90+xHj4)(nWPYΤ#2g ZqR^}TE2($J/dipp _*reӧ7J7whU[Y{9R(];Ej~kIa-u@啋2pAx?})ʍlBڿ"CE.apvO0ҧ7D$f?ӌV%%^}JJdtʝEiirE;cm5p2Hvm<}!(rE."1 Jvna2Je sӊt܌\M!vkK fy&cV=>V2TuAЧC Ꟶ\ĭ| csfFi9+{eQku$P(Vel 휌֔aScjїPqӣ$J ~`Nr1ө#^f$rEUDbw+c=pq֜ybfiʭoy1d/W|.UҹQןjS[ݵ#$7hpL!< u(-8 2êvri.;k(fR^8°e!KD/uN4c4ZE2;9*00ۊԣiөF"knwQs+V88yFmT?{گ b81scZKOvOZ8]G CD[*HɉA$skThӣ aZ#^ܿ# 9\*(CgD(ƞ"՞d$}###sprq㇩+Y´(d,>AlWe2N5(Kzqb^"<F sNuSVkWJW kTvzg9+l;RNNW}uVR'0hX6lqzV6ii UJ*Wo_AV*|r_%rs\rhyRw j2ǹY|-qu/zt}wGEנ/>c)UغF)/O$Ȍy2y2n^래?JHŤ~GE~Mˠvb+m@ qGLQ(ѝ˳&*BӊБaѧZ9$_G>/a%Bkعls@! 6 8Oֺ9c7rrZ%h̘v4VUe{,&8y>f]A$ wg9$1ҢT9ov\zakwbΠQ1ӔհCr[yya1Y9iR2=A<i|STJ>.k[E"w=}u$ٍOgRf]%m8rS롥>h\ɤQ9[=3N^ҵODcQNQTZ~(lB?>x|EV1[y#J8iIQV}~yLnb6q=1N1TJuK]m]e&faeyOR{w'^!QƩz+U-EF[5N+S飇3mYS._wrJ,L_Y>Lye?LsU)'{]ƭ̲8C.^ԫFs7SsTi̒n#9'vV* zՌ{4 UeUade+խi'G0˿Ȓ:pd#/ `2q׌zUӫ7eY,qnKբQb4\4GJ.4/O> wi.\Í7GA_p(r_Wy6{[Kz|A,Q $$@%r:F4)˙o;o:ZnQI&~҅Ge#n~yN5$?O3[Ejέ6.Q'ҴR*m08ϙs-Ǣ/.|@)L|8 X:un_.Pp,9(J-eS20G!L޵JI[˧j:HѦ7mR\{3ZҧF>;5*4Em@02商6'#$ֽ ZW]F;}ۙp>O:){ҵe -ӃheBif+~}?:*'qaΥ5oOHM>H9quOƻaFN~Ԓ2dEpnXG`Ү-sѣA5hJ ?v? H9:mpO [413y`thc5%mkEu6ю>_Zu+Jy[MYodFa*,Tccf{ac>2^8ohžNj4|~hw^8bBݴ'*<;ӧbllZ^dSۙx8I%IJ.s沧wo/ȨKǚkWЧ ⍆wBon9\?nGi/껝TTT\s6񱸻)FJVr[ٞ .Y[p*I=k(e)mwI([dt2/ԫ*mB;~?2+bB;z4jj=4*qsmbs¢o+K9Aq(> Ɲ:KHӾin{U2=<Ӕy98+h*\DA3G{JܐZ.(_%\+pO kCRi?Go*%7fR9h50}*/?w'|N~i+,āGeqީv*&q#"Xs;31.mQ$"1ڹRMSNܖ7HUi :qZs>[t\8yI=SHeo5ڌ?/XIʦjUhJmCxאENBEDYNR˖luR0^>*\CtʻYQ ̀0xu\N>!cJ,зC{vSZ +.4jQ8*7й3]$q.1z.hG[%7Dqe_I<$6p9霏^kpMLdhGٷKYUmP#REzZ];IoW->^i]<;M} +*I _Srjkr{kc8U#%n̺q"C 9#S낝myZG,ycW77X;t;#Y~'-L=:n~dKm;K[Hgtˆ8=x9=xJ;H筃{GnI|Ƒ̃?(W2njjWE' bfVo\%RR쎪U7ȫo@NFxVrm{rF1]?T,/Ap͞s8ndl{;&v0yk)$$grOkk- VRdtjJKéCaWlf!U>\'G.u%')רsq#50s׽LNj4s:uIr'׿,5hd1Hc!*9}$hƟ~ՎҗSOt&2C"g͂pxD-=Ԩ/2E'e2]C#\jhOF!Y,<,ch#>܁[Wk*oe"1yh`ёJȍDsƪ[< Q+nȪ2ԯ n)uDTH$&1'th4*ewfWgly ӣe~-&YGqy$s~0?Z/N.ׯTs*j_?%YUc)mŗq$ =0xj<ߺ詉jw f9hټ5G%WWѻms+up{% +{yEGR^D0NraO#F٥8$+^M&-_KhU|ٳ'(S.ok/V}d b{ ?mJ'N=NHF['Gv#EϿIԏpniTPx,{4W2-?(HMomF'"QN-OHD2G-kp09T#ȽMMhF$=5ۭ/Ӡ!Q)|DWn#Yaiw|0 8mNєקF:>^Qȥ$Vc`ېVZjrWOgS+h޽lWq#F!81Ĝ('Y{U)EhxTK꼭эJ3NUTh#leN\+K1Ҽv5-Cy49z9={K{/m2pP̒4G8Rzl?ֲz+imzh*Q{{$I_ixm༙I95hV^qΣ~$)B62ޒɸ6?,EUYjŹj |l{szu[n1SK_nLF+1W={=+9JJL+=Xܬ1p6tzOgncZsNOv(k-wK#11r7&>\ &u*+[Kh>.ʱLXճ,LHc=z>ܭ->Lө~ɓKmy8;H WϿv)(Tm^Fj|םhCk":r˞XSZ2̱vC`j0]\U:2wz[\G%g%G!Cg954eVG׿k+\gT彿1lOC7oM7 m8֒NZ+ t}̖#{dfh؜p1]sN'h/;_{iF"Tq\v؎́^@# b%zcgn-=]_Cz=In'o7$y'$#u=+Tܽy*rIh^w KP-ɸm9LtZuГmkk}lwV(רR~o i-C =AӏjڍFߚqkԍ8K{}">agܟƏgy?~gNUb9g`BX5sF? (Rʥ;juioSVuѤb'r#Oojwze z6n7s5a#FUW6xp>V/vwmj3:xzrVzfoiqG#$#ʤ,E겔ս;."kF{y?%2G>v+)5V!OZZ46-#HfO/HOZB} hF)zج[[iٔ :㿰Y:|FbcFfG`| GUV̆8ͼn;s9Ϸjcg9R *Jp}{_e]Q:'5'h]PFvV3ߵssKGwSg7}&\G'6u#~*u9$*jrVbmϘ>-~Q 8Q>߇M~[: Nt):gEe 09jQ֚tO7com$zα͍Hn$:ۥx>W,j.G9X+V=ՈNc+NWO^ryQۢ`"FݸMowu䩆R:E^]#c-&W,%(R;#:ShaqitkJQ,Cy;NiNq41 8ǿ^v[jeRtᇌed@ye 3?:׃nݖFQ$'f,l8Orc;.Ɵ>{=bT\Ñ4E62r[Y&1-X H=:\ܘlOK_WԙcO}~~CS]W<)EuH:?nބUjZ5Ao1@v<%;PU(5u -v]+ |g9.hZM/mK'wk&Y}W}DmGiv̱,d=O+JV_PM$Eݰ< }3W ɭoΧϯaL.#YZG=+U'f`;"bBi+ӖަQ_q u0J!V$;SiS $֜.=ud#c pJq{XQ<i<q\˛F>MOomxy<I})FI:%k._r "UCGLsJVt9#̙a#dW7\OOGE݊ygB:523H1[X"IhW&0677em:өdw<[$,wN+%(Ӗϼ+Aݿ\wj]LI9{3gYȝ|7)8=Gc+cfC:lf^\teR==qTs㩕wq#VO2Ffܧ|l=kTa8tݳK0d2yX1gaƅ9JH/-2n9n;c5ԡV[RoÖi0.z}=a~֧7,XsQgeXRűqҼlvg-ju={=~Ȉ:y|5)1z[b]m W9W,vJג:?hX[DVFd`Y 9s/7~dJJrI\K'c-4qH/%I6t'qyKkbܟ<ׯf!eI ¼9ֹQu$jt|@pyN:cMS4mdY`WV^ l=G甡FepmKjL~SݮJJ9b]?[^a.O 7k`q c)~]JjjWib]e#1\eKֺz*ԥ+M}gr.U8K)$_&y-d=z7 @ՌIiuc87!Zؤ豆2۰9=OتFTnVG=dᶕV5 ZۢM;I%Ȫ"iۻ;r{V#Njm?فIPiMѨrH_90yR A[} jUn[h cVךoi-/CFN5v#*5<#km$(V*cS^~"RyZu;**tl:K pk\IoSʒ ~5Rm'{EG2  mLҹ%wOib+In+YZ56F@H#|c޻p:u#}ر5FۈiY$R*iՓI*̋T{V%EUda>X{jͿU(eKr3jV5cB3\cG]LY(ZQ̊1D۷+HZQ/GXAe;1=G?i)K5gt}zK_2[Yx3Ӛ(SEƒIh_$o圪]FgRIiӨ'yu'p.-_h33'R*3NǵREgqgR71iuLC_pa'SN}%.,vy(^H xlu"5*Tu1FKMN%XM)aҖiÕ[ERon5!$Imlayxrz;vGCncT/0~_/i'ʬ @3N1W95*9pF:dDfʧqyJۡՇZc$]ڹA{=Ү zdVC`㇏5̑]{ңQq5'KE;1y9GںO^ORRCn,?uwol0s9EiѺZ/6N^mj.ItaLCwN>'5ˈc:WNh UkyH9'´X7Jo{h6{,j@A˙z =E̴JuIbQTm"x'+je/,ƜQjI<3+2$w5ƋlÞQGMzo&Ya\Y9q[K=ls֡%8Ż M:WGwn,Tnڂ(ccmǦ2FI}+Gg5oTk*u$!mj>~eFQd0iR5I99Is'm(NodGv9$/2yʁ c^}k>j>rR0M[bk7 'ep>0 p}btAbHe]}3rOk:4~[^ysKjVКH%®ŗyv#OG:G^=UO2Y#צxǚRդ#y-fhN3Wn8=+J\{F#MŸ7#^n&v``3Snd,%.Y-4I$hd}Oi*~*唣Ar-Ă{rVIeS6"nx>?ZcnYװnT>\y,ʹaE$kZ&7oi8E oo{fe|tiIޯo=:d̼}hK屑 q95yR#خjr~/!%H*gKs|8>f*!iB9uR6^USQSwש6N\R@),jYY$P̱߰Ϸjdy!|9O#;㞕2ZrTױTTialX[Ȓ\m䜓9)RڦgR:S[],k37+מz5{[o0u*ݶRZEv'#۽D}"woK#geԖ6e^I?jTyo(ÿ2iOr b)"9p[#YƟ%gqE4 #++ɟ36w0=ҊֿSFrWhaE&V6v튉Q}u)Fq5ci-F䞇qֿUIiދkz#:$ʥxlQC+ E^ȑ#¶6*O#]Tj:~bKMJ.tM4!hP õ\jԍNg_|wѾiI3E?1AnslRG)=lt>hO,A;]ۏ˅8]x\EJ9BRW&gR+.2g]SZb{+jY2啘m#4Fv| $4CÁ2[9r9ڹzJWWR4bm(F琤nStWFQ{$ْ4/}@zwzW\gJ=%c,Jtg͌pKzr8\:/*w+ر[ƪUp8c}e# 5*Ɵ*Vot(ۍGOiNWZu/m.,<uv 5qVua}ނ\^L"f:aQf]Ԓz1Ⱥw1Y:}xzmy# USWJ̆I>Z\߭TgzxTnbZAu˙:2WЈM %m<@{~|Rjn1zI8|1l|>mpb9rVśd^Wk>{ŨuKUQmKfۼXu#TQvjf}iGlY0b}kjjtt]3.˹.#R[….[6cUY.IUIYT%nwr2s2+~e˲IKmcXg $k 9<:դW3N6UTm$AU]n\ߎNqz:b"9c<ki(K̎XJjKD .z0SVIhtQJՆhgo,ǵyU,;*b)sKKt\GqVm.}2>TIբtk#)fV=$ڷ撕UN~XҾڻp**)ܸ864%}אn.KqUN.ftRk*7,Wcvs舘9ϗ^p-n.~Ld$e*4"5FhVsA ?QW ?J6MhC6Rưy;|N? }k2ӌeR2 -it夒CnO/cN71[ٌmC-<dJ}5G9Z]:h K(mW\'[j}ɥKVv _sӯ8\VQ= 爔9tؕ&dU3k+8|a J<[~zyQ'9,sMnfLeqqէkWrۙJmۛwPsϛfr7*~Xh3j:gcsOݻJj!ie3μ4@${VūTcN7_ЉV H="% 85<Ҏ\>}޲Ȗ߼?*)+שys+#uB+ os9Y@}E o'G5_6푬- ufmĝi*?XQZi.UQ߯!2"ۋ"SF:zVQ#X4,{m= #j/Z5DqVJPZY-1RӠj{iXNQ-]wUd ssJ [fc5Zl_-U8d!nI9?lRJ1"YF ?*,zW<:ӼVKoF|mlڠJt>"(IkuMfR'SÚuNH%XM,\t眞R-RRoK?B4KvJ~vOҵFRw]M*jkFw)+[J#.ei$I Yܨ( i:qqI0qQZؐ\<6#yHI6ހuG<>՗%T9{9+[a#3BDj7F܎{)>]PJ1ŵk% A1ӯCޫУZ$#eP̾ERZQs$`w>΁:n6;wY9y-ʶ̜ʚRAl^8m0 6wTjJ1wm>J'嫶\{?ɪW;N\KglAə~ew*?ɭ#*Oo} epH$H9s?P|N"ٗYǧoM6VgmYbH^|-An[9$'{sjm>b-ԪI21 sAcҍFOtťkƜĭszQg:Ew pƍ"݁ kJ!rVvʮ2db#} $ 2lݏl8$C-Jl2󹿈Uqs^)od>=b73+a*%(9]\e,n#s|ۛ'֛jت}"\HA_nONIjIr$?ʶ9?^+hɔmR$ _ȬܭR\ױ Ȇ@ξdavykNN:N\Ma$giΪk';ڂmRHe iSf4ku51E H8szt\8J.{Sۆjmݹՙwmqִy4qPh\P[=éeQ=VQb'OE.IJ\N.dhr@Ssz`PyE- 5JiՖm'Kv'JSC{[TT۬P/H r'q-\5Iyzg5R} :'M !;?Ycfx=Nm !k[Q( ndD w9?Jb*ӭGފdWrcni3+ךq|*BdZMzWw˸mfW#YrvAqp2U!wcEhևTcQF.+NjY6_#sUMqZcE4ke~MfgRUEIi!U;rd]G~f%+ U=Hoߡ#2ƻR6t\GGVPezj7mgIPʧ8~OfuRTT\o$pe>ynjܩwi ۏRU8tXHwӏj9yeb\]>R8S\c7Z0åhIF|X\ SSLdm B2GjSc9iq/5WjNpnj{E(QZ2Xa6 q+h\_~6&{cպH&6#ijqJMKI4[ #6;Gz(ҊK7yVtB"*V5iƶkF2#3I#~PΥ9Eh'=GmU29{[\wC׊2U4u4S맠Da8'S喚)Kyo %,@T _AZF^DЍ>i{iYm, %eQ&26=Ժws:TW{]j>\Eub v~sQԬngh7w£;Nq蒒V3Ilĸ]I 67Pg)K~>SVZ;__QO3F Г9\sI>RsSJvEyD186BQ#cE21SW+0t͞ Q[ܘ4B|d6ux'Fb4F+_0d۹1$q8,Q>eJmVO8vt((kF:=YZX.VV_ddI˃UFcvyIb=wz\X/.l*AG'ӞR+cV2E'xUU,{pI9z%%W.d-$ 8%W]jtVP ϊe?tF8=qK}Ԭoȱ\|z$i4F~Y\չi'ʴ ѕ'$նFgW>V7|=YiGC" =]dV H0kjVTU:1dq5#p.Wsg*q#S(^}L)TpZfX 8X՗p;cpԌzӥMy+=ȯ4mQHɹp{f0>{_<ܩSlŲ!IIrBY<@Ƥ]:ߡe*Q]umáv{xȣ;yw= ʥ:.fDR9199JtsU9yvk\IzFkJp:)]M:q&VxZ[-ūۀ!1N}1E3T[gQSJ2]!$r2F39T'k095tmVV_04KT1di{8=^ۡ}$A/mYآ:ӏT^} 5$xC57H`>AؑYʤUI[&R+/}. LR[+DLʫp8=@YSE)nAӫtWW0qa+ EB1`梵oUbյ<6GJ?ҧRZ>ijU*Qݾ^s 珑+q9tT*Ӷ/ܼtVݑ@c[}kT}fu+z`6i*gꄗ+Lu)NiΓխJ p?.vs_AjoQtyū{gr|hatFӥm,OV=zlSgO,nxR/<Zrӷm %N2+it0M% YIR98=ƈǖ}?S(,U6W'%)5nҥg)l>q; Ѥp>zҝ9Oݦ7]m⯕ 7&y-}jr$R:PMM`YfXb͸[*V|zSR4۔oͩ%Ko2l]zrV./J.Z.vblXֈBV2x~TԐV3ȫ'{zgkU*^jsJn2SqpM!8GCt]YR"HLM#U''=HSުyv}{"jRB<6$04nnc,[=ҥ(J[E{u#e[Ѯ_ ;p>ӭF̌i۵Csiwje#mXc^*`Ӎ)}T۔chyhrzgsS#'+YtlȬwڪQxj4cSV9eFr}[,V|TGU~beBN*8x0u;WyF76Tqgވ.[u4GF<{j mmo,mO,6}cUZi1hsǪGuL$9=+̕7M4_]UDF#?PVW}H4#٢h5?c>STjɥ=%HՌ(581+oкqNVkQ˾P5q3x4QNԣ9%%Y'O2O0zt㨣w_"RvB"|6qQԔ-=o1rUvQ&)YUI!h3 a}tBJ[e#Um%OO+(83SZwLlĖnOQی]>|V=~9ZSéFRE?+Ƭ`џ2{ %k~C iijVͣN߽Nخw^1Ogx:?WaBYlF-H9ϧj2ց)Yc2Fʪm_,]6v*R,zlo D [Ajetei!lzgzZΤ4q* U)Ǟ.Zt= [-R6 C;UOXyUۦ_gzi'a\,3:ޖdV:t.uI%d\u _]?Gu] 6(ً?+7ְeOwc:*itNHa1;qFUKm:7M!6%I\z`V*i,=>[I% 8Y&/K 9>vzuiJ)/-˧8ҧ>UJ`߻i$'N=TwF2.SWMB]8 J¥+S,2~u$}Z8Byq޴iY$wF(˓Fvc)+rH@q#N羗jߗͧ=?vJV$2BdT,eJ烟8ް9JꍥQ֩nזT+#Lǟcp`v(9m]v%V rlrJK1)W&N(~訪8jFx:βWm6Ri&?.]ѻor0>S9*aT뷗vJIdwh|đZH=ߑ5S:.>]ܵϼ5ݵa@;g'ڻ)wu1T\ؒx.sː:5-#Ֆ.͏7$1b9Ef>8'qӧS"Ml̐ H73z]/-}WȚqZJO[Y-JR!=1]?5H2~6p ,vXWO<}4u=y-,14,Rv~9=Bm{: 07䞼dvSսMaZ1j1z=Y s+˛rm=wF$rӠGi7c(!M<;u3-} qZu RwrF~x[o3g\R]}B$з]9<uy׫nme@щ#$ ӐkQmt]83 FBxOotGic:|1ѰEŶu<}=N^hpY'̓в~nq]*4ӾdQ#Lc1rqڪrmc*1ao=ªGPe$g8ϧүOPu;]?;tCͻڧs[k*nim$]/ ''=Tcxʜ/R8Q»[N 'iBUFE A-˻#01{:?שGESסbe}f8Q)MáXnf[^<HGI<-koj1ܯy,@߻ w(e FT<49R9/&W79 gk^m/o4G *OEcl/!SN?NՌ:]ԩO(EWo9Z3veo=8)B&g8Eiz|xؕ_wS.X˩p~ f!_=vFAo(TU+_fh]Gjz3SOL)K^$ܰԍxni4"]$vhdg#h .:s_—NiEԈ c.O y'9mUJ?*~҃صNKH~cm—sJN2JO\ׂoiO̐Wp$8?#sjݮ c** j> fuP8#8QRo[b()+}cf 1Cg9汩(jTԥwhdGdk]ʿzE\cWzViJb`.+$%NWOzrT虍LGeࡋ䍜hz׸ͧd)FJYݤFGLsQN4W܊)թ8z'@eo4]I%O^5}nz.eV_^kFJ>7 ߰'{.&R[+Ͼz, tJ̶\I|0OrQ\R#_n^ЍRKG`'ΕGEsJV<|>{ ]H-~SӇqN륟ّᢳWvcߌ&9 zq횬Di-ǧO9HYg6(iVOE?Xգ6zWkftj5:;L6bݎ =\*M.TKhΤ剢t]L[ "f^>9֗&lEX Ds9r6X& )-<˕IÖwĔAV~e'kG+ c#}L12Fֽߞ6YfG .c11O\zu"%&NZHMpRH`I\ujqe%:+Z7Z[]پʧsSX8ͯ*.HI;~Hڣѳ(lA:Mi*ϒRs3rІ[gb3ެqjeGdƥlV!2DX<5YhgjSf])?"d8c6Bu>JrKv֛^JҔ44>n@A9=8ⳕZqz=6B;Nam<9μS]^]R+So%hiN'v:bW 0p205cOR(֫nD.dF߻Oٻ/ԷR3Mkq iFiW8;WEg$s,UeNH|&k瀉%.s^^+ Rj[֖'B.z=m{r.THʪwI#.O?uS'Ybyy7Q-#]e=VjBi-zB?mi,4{n =>^9xJ5oxӎ$սJ&n;Nz>>~VedrTQ$܊xKܖ12u\-eUЧ7-դk*#ij!%AST^FqR*wM)%kkϰ,ߗh!q8ϯb-Z~_oeu VHCJ̀ʡx9#2i(ڝޞ_~m*4j.MgUۃ$|/S=x=u5,;}t*Y(^qQYG;1nmܱI&B/8H2c.DM-OpX4k0O`=)U;+}}Zfίۯ4Ar.ĞNnHP{=]3sSU*KrtXpi6hF&QTo}~Z^Xe[# ##djK ']OxxޓRoD5ܫ$eDL"Re=mZ.ZkO]4k_<ά'/#zJTvzX`{񩇃Q{~}靲WFK^` qdܧw|tR'YZ:o矕ƽz?NmZAfMv-$!,H}SKGDuj bKgҦ2"\ͣ[;~=;b[UROd{º)sƣpWXb*c0c z[-]cU~ytS5_\/+f 3% ĨCҸ5(G^4u؄^m2vH>69QHsnL{eAjěԪ |TUn7iebs'Y,'=TJM9oO}bI.UĹX卲1㑚.U"N*rN2^ Km68'wKu*|W_BhaXzҗ_иaSs0y6*z ՍyǕSMSҒP\[VY5l|v8=3WFU"VŨQK=D.bܪnܝ gXʤԚV:Ԟ{m|hCϡڤSZZ+߯B[XܕP+P}6Ee͇RׯFmQ>d$xEHw|dQIdSYTƌdpKȗ%~Y!}~*TڽSU)Ѩ}FS"+7C]+:sN66ԭU./$kݳɷʓ~TkE~omtc;IaR)!F/X铣F\fmac?/$1ϯ*Tڶ~ƤG&kIGeXny^}k _mpOMp(c#`8-K]RE}L)KE6 )w U3pWnX丏1ʱ1 >3Y27:*GG5e{?ܑGhét緸涩Niڛq䵗vneXdެVlo#׬h%&iG`ߺ3S q**)dN =kSKE1JQ5n4 s5:2Gu%xG[%hgܪ{X+;lC7ȣy \ez(:nNϯRNi|Nd]MɳvuKw1J<ӨjI#_ҳJqWi+&uMr~`誥/S:8jq'{o+f ƢA-'}k8V7퓄\]ZVy1UT}U+܍ \s{cc^Ңi~KδqIouɷkhn7Fˀ܃={TƤOTs$RMB?^)ޔ׭]ƢTʴK,A;CG6^x6ݿ#8QN7w-t ~jÅ# qWG-:5MVGٸ^ZE+mW+*%c,F7װJu%UzvLo2rRX4>i>9&ݐرmg{,yЙK",J˻o3j~Kocs>f6ǩ4yةT6RU[wµJ-+-QrFޔ qVF}J~wksOz˗cIr^bᗓc'ge(^N6fS|ۓ\s8:FCdJgP)r롓y"; _ d qV̞REJ wyN}:V j6cFJ:m:^~ꐼS7]F E w.!by漩SD<=y{^OS5a%bxGb{d ּF5FPV1_ձ6VQ]mh 5ۼ-}L(ҏ+#6V&v!K G$`[mQQFVO.fpr#hl~0+͞Vfu0EtSS4Wy= z`[k[-1èN}~: XڲQRN5#tg'.*}][]|˾Lhw7 |\n=OF3WS5ǭ()Um*#Bfb Uvp+IyT*jJZ1 2mmq]1.mUɭ^4" )o"o0A-u)tw-BkT̐⸚2O,ZBRtU;gxZ5gcq庖93j3Z砤}ļ;I{1* Hrm OXX{;+;&7cpqq?Z5ƽ}_.8Twmy H-$Y]|sZTqaOM=m[G-.>V8ǮxEUetL +=ַt|_D7q~pX>?W4TT M Fxmc`V5:=?c%6ۧR^Υ8Ԓi!mb%7fMq,1yWJ-;ae(_ v6W70'@ӯ\Ԕ\U켿"iʤ=孾D/G3)UU1 c'=[FҴ[&1RMh:!\ތʬ8csOF5.m:ԍ>W-y %`\lt=}F=j]_7N;ԊscǣzMm\mNq}WM$фRw>kЊ%uDstaizoZ-sc)5.ShiIk$دtm^vAȣ惵y_ݺG,t,2 ͌t'c޶u񪔝ܙ4ͤ*$2(kdzu$⢕ͱӧ%ޫam.%Y䴖w%H=F3YF5/ :4b'~^~a +(RE>3FNϦyOeQ8SS&V^1 mg';~Gj 9$he]Q|oZ_Żb0ʸ8ˀ,w*R9fRwyx-t oXu%j047bٸp28O~qG!WK/rڃVte0WvA<<J>ε>U ӧRRӳՍ{1I Y"xЊz 27͹ӽvRzj7{;d*n7^75ZZtk-򾤓BtMpA=uS6:*ѭ~GaK6V(PsZJI>DɫN| Z4J#cvى?_YJXȦilC8&;5tjrEm5_,Y2+1ܠЎTYƝ歪\YQq}lM4I+$JVvNAqsʵ975{%ݝkAJ[=?_Fd%dzv$Իs7۩<Ӷfsw Īt޺9TNښ$!MGNr>%Si9JT#X TyəI ~^+{Qv.3A"#"|yk{N=;U駗s<,凌;k^P+Ր2gzYNx|'$F eM\}jaF}^oTiIn﹊6]]>cǷ\·U9"]{5dG*I;xk1e̜$UڑaD8l`pF{ѭNYR.J-IY-{y IO۲ m228GZy=|E:-R4qG]̱ف9=89=W(Q:hrŜ0[YZ^eT;g#SG^.ϩN*t,av`dK.RSir[`'mc(|'sNk?gNԭZVKA(\mΜ2Z=M*RW|$*WߞյjH4i2-_Ԗ;sn T(7JvJ-1e13n]Up6{ںөB*6OyIEs&|haF z29\1N GP[X?r-f>cRMCf':\?G:X7˙ .ysӌnپ#J1zZWd{HrF: U)֊Mh3}[ 9u&˛co-BvFNg3WIU(NjVY@̰c6 սxⰜ'*ZdsG}@'WEhԩI8#O]䷷_@ ~.dl}:~%|#(ǣnDTnQu)[('4@ :9%M7t#Q{ rF?v덮:kSriۣ/5"HjmTc{YGJo~xzSkek; UFQu%6z=hhq٭K6#Fz=ZF4-(%Eԧ7 7|:SҒFH~d* :폥vFPPrQjyѿ٣,G9(֓E2F)[M }zeۻdv^ RQknLna"Tk9NOхrUdr.oN\z:ױ$K[knOX*9F\_1 Vs:2F{l.34jk%aG%{<Ǩi*=k9S$E-ʹ3 #c_ݜ'Ќmu'mcΖ2]AM3Cq$+y{1^@ f sSMK}ĸ*F|1Xt׊Zx}<A]hO bp1ӧGߡu"ϩ'rŵxҽsJVb㉩MĒ\?k /1PK ~t73{Nަ˧vƟ5/}妵D2@uNQIQ0qz ̠yH`yN^gU)ia.|A >_7HO~eI)Qc<{nkoC8Ge@z`g+Vz5VcVC4Y,zu}tf>ۭ=H$\9'wZSOB=.FevEes鞕I;zFDզǒUf 𭽯7]B<ѼkH 4QpIj5-JONːĶ6){IJ7Yߙh2@ݖ5kTKqH$R#~֑gZJtr1$q T|/d#Uozy]4z +uip`3)R5su)MҵΫj=X\(RtWfǑoqOT%:.g-;u#M/1/&pǞj=5::8^oie~f_+j)b9n߇Oٚq9R>RZӝ]̣(Ư+ٰn%mFsWN\Mܣȩ nP@Βmp"˻-1Q׽?f>\JYm\maq>Ϩ hE}kf[ i+\03֢24e(k;Cfɍ}z?w_fV&qaUd-8P.hx &Ύni{9 muU̐gN=+ozt{t:ܹr$1[^ǜ(Nc)]GkZaϘTӞݿIZdթjEKR''Wa&mQdtG_ZKEЌ(%-?2 % >ʯ#3/˸}O';֔kSƥ9GR7,]ce"Y{K(NZ4ԉnsxmlBys)sS}J5--קMά܍ѳ*bMcRIcx&WsWۅS)SkW (] 0c܌sUOJ\q;8I$(ٕv֪N33+/2&y|';y'*ӺCfPIS秿LbuFQZOγJ?z36;**q50*/sRӕpd63cSG5_wd8ReM@W)"e܀~J1QcfZ*2PO]/W^{IBۛ?{ڴ.zqQR1OVr&K$Ĉps1gi.l4,Y[\FAOڪ^0MQjҢi\9#MX82ǿ:Q)sE)jNxꉕYn[kng¨O_j1ب^͸/[Ζ|;?xJ|JL=8jɣ򄈫KF|dSxJU*J1~pׅbXvQFSWFԖNY n8~58]ΙS#ؕV}$g@fp2(ʟ6._ieCV8~]ޝNg 1i*XCfZs=ɔC{~Ḓְ ]B(4dc)(KV3BF*RK^y;i$hَcZF>onm<󕛦G'능h%)6ж"1մFU˓9=HQ kt+FVݾe_ϟʴa){ũGz +:헖u#򭎺Uj;+ǣ%7OllPHsI:qN1y+:.Cq"0EULf-2wnx縫XƝ'oyTpm1NGc&(KZ!0kU qI0+9/h2唓oKS]w6q䞜:TcdOSY_ʋc 'MN;QWhNGRzֱqWGWN:y2p*N3 9+Z:t ko2O0+2ߓz֜'{WDUHgxt[J{/2:.$<~/$L(sb4@ٜ*c:ө(Ӻ^fl-G,b q~՟R\rKUt;}UJ)F榪Ebq4Sg?w'B0q 9lE 4-sϵs29B3藺ljcgSv3|wT&ya''E\sEZ"FhCcyO)R'gXJ2,z^\ ̒?ا/IPrۘsy{ S|8OGI! }~uzh7nQ^I"1ְE' 4UQ%$I+N1)ܥeتזm5Ū2VU=?O,/mL%EIYf\̣FkjkQt!nS{1B di]J1$ܬB;\K.A9S円1q KfYo-xLy:>X8EhnUSoA|HO⦜bvҧe;$XXBfY%*qӌ{µu#f8-I%Wdڨ@Pi'=yy[-99[ƭ<Ӟޟ_zGoN|һ~̵Mr]DY0҅_+ *TQb[TS*^3= .-{KuE[EڊhrO`#UΣ4 iCϱn%8hlwQ߹#0c`~;Tiͧi{oMg65c֮RctsjzZ^ 4=<*sҽ˩R\߰r>Rwm2^sG2NTA4Ee(/wMJ\KC__=KfgYMxo5_imZJZ *sn˵Obr=GZsKɜqtryQq-7|'>T:%/#4h);88=+.-.Uyn̻T5<ޣvH''NKW6Zؚigh r=4F1}fgpКy!$.V7<2~lxxJoNVGtnv=8 Vh}Y4BW%U[b9>krmG%tm{ hfTV=zϖQ2jPVM1[3@W)O'_4yuz+IS4Ѳk$m)۴t co҅)Yt7>YE mn4Aݼ MІ7N{} =x=jc)jmQRO.QS9knVm7; Sܘٍ ".\;3g'׏e'u Xn\j)wL[9ȹ,+ N}r0H39>S,Tw:9dd1SR,563~izgZ%5ЕDOC6WWON ,lʋ%B $Nr1XEs;EؙTps!>yeJ\VfyDHI|@S#g֢N] "*-]q-dfn۷jR0y6e$2n8'O/.FynGmѾX&{cW/n7C/%g`ž( %Ny 曌>֦po*ι 0*=ߵKCNj>4[~IJ9g`7}_@l*<8_ؼEH^U8f1ptB5U=9}{9i[rNH Rw6߿ֱ F5VDnUTl v#Z^+W:&ũ7a&ς;o;lv~{iShRNW_q2S J2O,};YHK}ǡ沨4m)Khm$eTr6`prh^Ϛ?yRZV!&B[ 5qI|F3EYr߫>9<#܂YYW8#sU=+H8>}z~ԩfHa+Ղ{9ZÏ,햷~\\-!Vo0rFEg~kF7DK$0Cp8{?2NITz$ȸOݒfY5s$lړ%$gYEf~cNrw-4+j䴊Qg?ϚS拕vQ*jQian|3z^5Ex[kI"37ͻ$O=MsԦ}lIXX)xȆ c#) n.+)T*xNlhp^<%aUTƒ:Z26Hicېs>ՅIJm㔽jZ;Jۃy ,`dߵyGQJvah)=R"oj2nqq1jc6fqS?o5y2 '#OOzqQ~U9hMo&k3,Ѯ㸠2;\ܾ.NIy[rLci*]y]F:ΟRc"+Vq OsqkR/qSRԮAK1$8]:OR[_#~t۔w]J4SnL(ïWOj&cR5GZWQЫG4s1NpA+Ч͹PRiJK{y&o܌70{溣wq ݋/ڞEdڤ)E #TYEe5ZtO7|D!99*aUʴ_LwNݽBFĨjDo9tՅѽINo9cI14{cR~H:_ҴZRVT[$8*YT R^\j|Q$]یaN~｠}^1w+qEkɻss"܎IJ AA@cwPN;Vϖ-:t׿ A 7Y~QW5ާ~SYʜ}U# ;ߖ̑X3)UmpPrW=zVReަNi/t,sM{HEF[CJ_#.$j%T<URS[N4E6[}{"d,pOz4y8Z>엙Z[kp+iVh\?__J8سr'aT_ܩ=*v{:ѓ[ g yrgtSJTմX2^F1A/|Q֮yQX$ݚ*>KAj.=L?q>uUhQ)++;[rpmf{\%EOSє0yIkigV̹J݂GL:RM?yn{(ы>_R+Ɣ] Wp 9V y5>5(=<^gP1˂H dA'ޕe ~v=1p[#Ѥ04G ڱr[z2jI%.Y-=|אØ*T*h*)Jϯt Ne `A3gr3})s0w.r8d!mȾd)^NWS]RZՌ0$>c3-$ɉ8c ߯7Y*m<;UjZ{vDL L^dbRNJ DyRUh\CrENq N֕|BvCiv]3G Pcvjl}ˌzvcW]p4/qK%+Fs2odmtikRY.KXbr 7$=kJU+b)Fz7H ,I3pۍ<29^.J]yI-LSW(EtTOM(j%c*3>"<7=ӓTgnk nUc1Bmz?<*gF4至'gnIy{ X(OE/ge;*<)K4?>+Yϖ˻.je"$DɖϿ-ƌk_qF8vԯ}w$Xx<׎_/,X20i-ܷj.o%H$Qv}osY:,n|ש$)(hVc 2K6nT)Zz(mtyyQ=I%Q,ҮVx sFA#p'lȬc*_O=ISnjZfEvy93U:t[eUEϢ˛` q v+xrsTjs5O150xmÓ9'=jeF1E G}Wȫ,"6V8*= ]eQM39:ܜ^w1T@ֹxF䪖dq\t[ٴKЯw[-ǖ(vCJ>FgƱ8>Z+!'?Ly[)U]jrmڕ$- ѠUĜϧZe)mZTc'89zyKyf59_a[M4 wvs]8*(ʝ4ti`%rٟi,pQyS}$SĶW |mӎ0f54QhtN mYw(, 'ʴs&w؈Tzj *-͹&8Azw{TrJrJ1jWkUԐa̖%beUɈ\ٷ݉h);[g+Ԓ(8 898c)էE(m9JWKMW2LX.7ۣB`mH=jB3iw[ݻ\ԧM4p5] ߟN=*58hJr[从VC3mF?1?S=k qM+^CbʜMOY$`m\jTRmˡU]#)5 i0nc\9#]TN)NխR*]4Ua=ט4((GVsq4a\}IZo40Io7]muW;HIW+2)^yRNME/_~wv׷_!#5fS$q[~EN@u>Nrs{=[~>} {rwc54U&FFwVKj[?4pRN2M-\۵-WnUBT׮=k=Tk"JWTne#A}+ҧ :1Fb;)b $z{ٿ=4c*i%̌R" zӕ>Vg*ӕHF989DeOUz3lfM6W`glNG\ = )ҢJm5H'Jyn I* }x3횘ןw[KaV_DA rysd 5%Vu4NTnrٙ4m#C>iy4k=-[(Cy8C/˴s82ӌc'4U0N]yy /&@9U;dOQ-R5#f5oTՄ[nBq4jn8*rrWzZtڒױ _-̱M;rMJyX97P2nqGLt9fDKNߟNlM7SwW;qӹ?ֳxi SyބQV?ܴDK*Ga99i՗u+ۥiK-e#?u|`U{0Nhb7]/徶?ĨޝmrkeS>m汕?m.g+7K,>/zh@VF8m[_+~'(ԐyH PW5QvήlE4ԭWH^*FG2;z=ot쉔cO2u&Fl#R>`2x>O QlޫvgTqfA1+T3 k'ޞ#R}2m"1GPxN>7֣V/ܚ A ++[nqC8յ~mpM4'cJw4ReLK·`A?u(qRTp{iOQs<Z>{ɽ3)N*+[o?/u(YB_Bz+Ej"'Rbij߽FFNxU*UKGkN ~!>\+n)ftd>ںt_,;JtF:iA_"9$dǡ#qeRRm_vs{Vc_1dXB$jxkx֭ϫjReMimYO*fEeˇk\*Z+˔YXݢ=~|p1OJSR1tUbWjof29P퍙V=|c." <Ͳ*T*Һz1g&wf?/%0q~J"sSNIŋyI ҼL${X8n ǧ^+Yn] М+v*I=Ɩ4K}A=+iY;HxF.6OG#97aHSdֶ(hF:0OOu2J=yߵsJ?xSKN[|U9?*Q=rk8ʵI IEsZBܪ[}%FTymfT+Jěq<==}k85S( ZC0{mM򫷃q޺9Jq|:"hc/bH*8_j۱}k^,S$T9d+ %RڥNu_6!q'U+ `tR՜ڷeHݤ|˻nOm>g=H9 s|KdgJn^]QHPF#_Nu"6`֔a,ź|$VzRCJ\,jmmw{DcL˴?x69']q$-mmLrjaVVWIS泭R8oG*զqMh晾"۶|U^U,.C C&6ie_ޫ՛,H[ӣ[/MC*t{E)Ze38w RSePgx~81,CKLQn]6#ڿ*+m$g{Vܲty.m{\BM;.",ml%ReHU#Q΋_R4F; c{hRaHzVs̭Z-W F%Zuڭ"dxqۨ?y6ҿql id_/~ ۆ 쎜}+Sk靕eEK.ŘV6تYUX.x$(ӿuW?NY&mGt +#Hr9;z9n~ jKݎBϚMՙ^GҳiVZMS*8v~=֊Rj#:cOYw߹5:UhՂ98hSg*!RrRN9>Yr c+^,^~vv" #]ʃ<+g\ѣ-Nzy !ʟ*w,ʬ 2szWD}o[S:t۔u{'j oÅܬFҢrNIjpU_vMͼL˹s8*2RqֽJxyJM73KFQW[nnwAg3E0 H>}CrZƽ VmoN?Q]FERQF::o*caG'gK s-,lM+fE4 )eۏȂ BtZ}:8(/vj1N;&BXh/+p~Eb 8zhڛryr1^9t{EvCj}lWFZMЫcrC:`?A}:KShԧJ\;5DdoNL}dtSoCKcn\3s?ʖ59cX+&Ϙ0:Q~YƤ-H OSJ_ dKOqF<nW72f~vy$R$`#+۠f{WNV$qfe XJ-Ðs/Ϙ>4\#=Ow܄1UcQޜ&%9cf!nz~ҜJ.{?gSC%E;n۝ ZG9FDWDdeX˂5SUedݹ9j$LJQS&M03>rUG)T6a_qrL'Qg-:t3oQgd G?vt*E_o0`?- (=y?rӜtL%N3x^BEbȓ,q#66\Wh¤| Whi/ GY(zK '+Aեp[8#H_Y,:dz:e+#H _ ,q"q$^mLl?-7vl}؃=,He@9<ԧ&}M%c:Kzg$s7qWTiE\ݾuCCэwǯ9ߵDԧ=:4J.[irhi%9Vڸ7Brs8JwPZ1Sʭ'(Ed`㷷kZrmYS4+)4o/ֹkb*B*9>Eu%:y,ۃ=8=:V$Ms~^s_iBA7!Rv秱Xٺr^Vk*q%AY4Hw+GƄM>S5,շ2ʜc;ս^WK~PJ2WMG~tm L*$҃/Q4yemm9?O5RmrO0y"~(|OH#a ގWׯN}sYV̺WY գFʞ8tJSKUhy>IY:̱*@zw<~Yԏ&,xS*5@4 AV]:nx՗_"eO~b nB}sϗ74}^n#YI7mM#0{u49)_z(ԖB[ppU7* ͪZ۹J_JvgY$jf cj]W+66eOTǕUژUp jwvrF_l|V +|3++9{`~xjչTZc+9^'t3+m t8aV1弝8iRNM$/Cp"Z-_̏ʏʊ(^5G8URwiAzl?W\D+meۻ `ڪrQSJ޺nUt^ac2FʬVEJ)>W˨%˶,p&Xq,)Y?sew~!8䷒e|}USslS̑cd]NoF48"J]F$IŒ|=AJO15*˗R++p<9e)+j1apRR4f<ߏoJJ$^6{l>|XXĜtJHЭSl'ԆKIkdV<Cjڥk_=wQMFM5VoN~8_2ehGۓzJjru4.vX 9OҊQUSHݣ 7̽ꪜ?fGױik*<ծ6Jsq{[T#d~Җ"ͯAn"&l$S159{ۧ]Jt<ȋNʖ~8F<͜u=kF8^[d9Ԏ`Lk)TEj3֟gخ 0ZyGn};jSecB|Hf̼UofqAaURQ6_?cR;GEĨ+`:0F*e2d_OQUZ{hC?ڕ]92+:ۖEM{9^t}>Ejo4S*ٖ7ֻ)͒~qOJ$1jr,7VFSs8ǖZ](WSKG><~< 9IVN#T\ִuS:cI;N3;Vj4Щ^$$Ѯ w|SnZ'oTvv u!=qrGPz+)TM?~;rlKkoG!ޫIOW4e7SKO3:Ɲ 5ut?0#TyRUlF2SZدpё4~fÃdv_ٸou2N+׷MTo/#^|JV:={O(\,'6WP~B09+zpu$յ^#89ߛ@vO*;vVn32{shtGͫ&J~={xm(Xʘ,3ZTiߊ^.BxN:Ju}b3m(Դ\JQ5r@+9|yTq^-;tGRMvM||T:ze)YnC[ۊGLu"hIF;˨@QH7c|kX}AvNv9Ӡ瑥˞0GsǿoZ4}:Vܪ+ːpqN\QY'&o-i+8b*ɷvB^e8IJZU9_%ڱ,r[yT h Fs}w'k%S*qZz0Q|>RH6 xԤk-7mC:>UۖYPߩ,3ēmKĬFLĎk?c|6&eZKK0)$hf|ͧԔo*5[M2K-̅8F7{ahޥW$x4ı7pn3~kKfuƤb-{1JG-m)| 9޸֭Es-e1V;ƼqQ]e:SU&m4ЁJ#\!vZz~JR㧮K;Q_zxt*IU:j4:oqGUPJ{8C_SPh9 Gޟ7~?ce$MiJWQ&T0zI/cOOyni ʁ"L{FdPaAN9:VeN)} ackK1ww3<T(s=I'.֤7O9pH:2-^Q#c$hh;6x>դ2IIkd9-'&ɣX些fҌ)+;jiIl3/LOqu)kL4ef+yi+w>o85QYЧZ_Hc&eQq&6p>²*ίhuZ\\_*;S*[8Jڌ8)}_>Ȏy_f9>9FڑZ(ӌ[ y幑ռ'ۨ=3]=9.hjYKvEUI"eeSX$Sfmܸ<#ӊ3ST4"Ii̴}$r0ٺ.HԜn峞x}+Ji{DtFyg1ѴBg5eo3 Enx/BŻMe-ǚaw9%͸Vu*FNh-ח+30Rxǧs3r[״=G3Ij*yvȸnHkYJ'VvNc "?.pNק9KZF}ؽ7X6^9?Z5#HE8 .jM"Hz\.yF +4D|6!8IiFjABB"L_ʺ!9&ɕJ2Ͳ 2Q;>}7G#{4岫wLpm9R}uXmc*Rт>|1lj܂kg_).1=gNnc$V 2n'FkHVU:݃ʡcTzF+Ƒ6\ cz=-B6JZҎb6۶*W4jsqFo;& sB-<\L\QSV5/ &̚O&_eRNI})I^f8:onHŔBI[##r1rQmO<4Woj{$ r{>Z~>޵RR2{]yѵDq )ʟB;V[IuF!е[.t o5pqs:v8Pٷ$W ]Ip۟*ǿEH14Zh,wBQ푌~KB^{YiNܩ8+r/ġuoev¾PPb]rHԅd|3lU0::Ƨ,cJu]˸<ڹ۹i{ϳ1&ɂzr#8}jeyWb*r9tКVo.SfOa:]2'lt{>zM=-e2C eg)Kl,E^E [tޝ:.sÅ GOzC^R+Hݩ_XHz8=j}배t_.HėnbfUI_0H6LiLwjr\'IT\]$t99P^\+IGHͅ@ h#y^&Fҋ-<3%̋ĀquE[7 hi4rȑn!VӏQ 0tzs)蹓r.nt$Hb >捗wFq5NIJU)o (>PvZsU9dԥVש%$*rjR94kǙ;xy= \JuR2 C7.T/tF2m-ʧN2=HRY?pӌ`VfXzqw35AV{3&D`GAsTsI_6%RK2(>u+ROU#.d6Ke)#. i"̍kǨfdQxR}ӚOToB qnd30w/Zru4R~!s)F."UW}GKhqƗ-K+23 f޽)rȮ$a~ ~>JܺhQInE{k4S!?1v9R9󌊫C`9/s9ٽL jjC'PTRڬ\cR:3qʷz+IZ7Ao(4nwNW;ӱ|MJqq˝r&w+AWhJVTBeIgvHZIAGQԭ۹T2nd s+Q[TpN\>RFy7n9>8Z2Z] 7]ث%ռ֑[}wx#1ʕHR¦".]_刷'x8۞0/5|{. XІ=;sϭpQyѥ8+Z[F0lDo#)m)y\MjJӄcWpc)GJ:uTwxcY ˵s0G>+H=4zޟJwo/s۹d=Az΋i4lTЃPR>ߘܜ޶T'̵Mh{n㸙 n=OWRA{ %7;55x$|ʽpO>ғs D_Ziϯw<9h/rOn3ܩE.4S="]O?}r#AS8hߟ)SUI,h^ZIG+Q׳Zl0%3ӎXvpq.WkIi}K7FUHx NO538$O%$ݓ k`Үc7 VӧlUF&S٧ܚi2Ӓb8cߵayzV8EV[: v0UTwagi.1R9QQN\ڮo q0!P~灊攥QItJ-n4HlCpH񁚊tܜ CnBi^` qqZsTj7Qd$W;ǐ'҈ĿiJ19iV݋n?vqaSnv2jm0/sIp[tnwL9T98i˞1i2¨8U%኶RÖRRۡj~fF.yr09=r(u&5=UUf*|Ƿ]hP7Xn?-ѱoR4$ c.- iԗ4y!_x:+Vڤ1=j~ނRpkƵfbʌp}ֹĭG81ypo?0UjVY+o)*d-jW.H==J1iE~}IBӟ/6s^ehNy~Q#-̑I*A#N;{q5c]ɝw6J@Q_]cu4ʢHd֑W&olFq&%fQ#d\{2Ŝ* .dW\r1YJnQF{8)+5Hx'*BoΚD"8d+"9t8S(J7*R `XK ~;sϚK2iR}m5,\CQN-dhⓣ3/B›uSOaRD[&֎@͵x#>޵mvqG߶VRys$D;i33Eb騦ϝ?ao-H:Erߩ.bYFTwʧ>R1[þe4߸L<mv#=TiYqeTxS?0]ߞqQ(#I5Zbjn~zuJN#I !a l_q\y1XO7uaQxnwZ-spORzֳQp9U |34DYFͻl88Ԁs[J4osG9F6$O3~]9hkTה8 .}xJ%N9*܎Ck,bjpGBq(Tbʕ |Ȃ DV78:dxe(c%n5V3 y>XbMr*RKvoʟ2L$&sGFZ(-7rKvIx,(_ZΜe yrƤm' E`dfW0\zէaNcyߨ=Vq1,xUj/c۾R8n eVi :׌Vz^:yC!*{ԮEZ5"Ċ+cov ޕ:-9`FYdZӍ~Y Ky teVٻl/VUaܲnRv~&1M s6?ycn*jRMHݫ^ yYUY/ӏVnZϸ,RQntjT"՚F?WLlFONyr;uU%5Ӓd1BÂWSZJkcH\Iￓ$#;(8o] ~]J2Tf%#1XPHlʵJ~Y.AvHPN@CJҤVeIvJ8~yiNXZ "n ѷ%ҝŒlTѳ.dkNgZ Bt;SkCRZX7$Bʪvzgֹ(jt9;b8^ud)D =N:v52E*v N706~.Nm>fǏ?5ѬJ <α8{zVj1R2zÌ7SUf|qqjS_xVjEFo?AthQBHx{W7ٍ~jr\ЎI4RȶAԵ؅evy0;|&s\(&>u%dԌInG#+O8G\u)Kp)y,H2671ݞs+ Q5Q(ieD13|zNrFHXl)MBOM[8U&*eG7&Jt/(%)U9Km3S=/Qy k" s`qӧNkY9k#VQd^<9=M(J0."rz؇ϒ!3I F1gӃө'u5eT6!|**^h~Ʃ+N8r6S2(ksmleW+8~ֹA\lFZ H!]dGN>JJp*TcQ)k&YAϖ~"JvG,‹m;cKt 0By g\ Ənj˷4/upW?{iuF"Kޒ~d!69WGXF'QMwn_*եN<Ѯ<˿>^6kJܾѨ3ϧꑛ7 eRco~\#ڦR|W/ /d*F+{zwN"xJ6{1]do2dRc'?kQlS׾^DS]2|Y4yzc̩Uo*~yаmb 庅qOWYƝdyRBR[2$4''']9ԠsѯSVִ{.,L׫} .\nE6x{W,ySVkvzu(Ԕ5-Vo$`cOP=^H9mAHH㕤;s`q]EpÚ&[I"ުbWUC;%;%kYyoOq[өwaaZnS2g`Sc54VwOdD|n 1hcSk' :߽vhiFڼNjSih:3h<֑ʧۤ;Xְ\}/R67A-^^8 ?HuQʗ"ђ0n1HlrN=s'%f!\S:?:'(ӟ7-F R*F% w|9'?uSmT溄c:3K]aERA9җ5k(km-OEd2M kNF4iuDmhFVU J4yom,?/!&6Y#۴?t<85#R4ܧtki=ſKk傼J*V~[aR'$]mJY]|g{waN+hN7Skn$\0=9 T}Y%:xzѼm=., r&&6檴i){)rG&3H֏܍X›MYtK*ξ~M?]@Vym}>յ:>7NU#efϿ\\(44}Bdo:e`Xϊ#J-ډBJ7qZE8\` ">I rNu vglHw.V1:u)Qz'VRwar,N⪵̯ BI;Ө\K;w]g2;ƸR7ʵ<-e?yn/ 8U7ʬÖ~sޮ$K߻N1H}d rmy8&*ʬy8=zu}U .;Fl3sUl guֳR#Sia2HxB=9ꜯ'FtӜn_I&H6w?2}85Jtߥ `7@G=+RY_-tq+[Ęqy7nOaKBzҤoV6WG,c2<~a]l)K_ܒA*}ӏ2zs)qQj6軈\Hy#nx=NG +T(_'tIKj*)Adzr<\jӫN+|/yae+IYnE5ɖӆ!݅f,#s[*qQ N2zoo!cxcR%^6;v{tRP6rGΆ2.1;TqŪudt'=զ[je.\R[MOSIKO/F\| wBԿv߼ t w$%N4v[hI8~ x 4H:۵.YIEiRjzIo8KVYB7nzxFvnNp林ON%1A S,j`:IGߎi i8ͻ)jխZO=vKZja*f26G̏r63ֶXF0 {j{>\3A!nB0tFHvTjM޶$]|]GDyʩ\vOz^;uTHӃJa5F-vn4RzK Z-_B͋Fc)N:WDNVNH5g{.,p,яR_"Z8w6'0Q,N:WF1֟rpy)S2WiOoAvua;mZO nIؖܰ`(Q=׎kXF5c:hE>tY$ GR1<9ˡׇO~Mmcq˶UFr:iiѩF=]=G.(Yeߙݒ[]SRz2*{>A˒a Ҍcu$h_2M66zފ73ySeg-yxF 0˓qں)ǚC5O5t@IjinThǝB;x>SV>dpUUmަ=^ռƖ4L|fy5R5t&2I5x#dTOEѻ쏴5w`X.Y6ݒ-OVTJWzEYN2I ,o'WC*= Ԍ-UE4n<..IrGL.+jvOȯim9j!v̖aknFG>\Μ}M^1sM8a>.Wގ~qIsV玝u$KFnqHҷuHJQb X3uS] '̚W:񔨥_B gkX?q'p0qSt)J/KVwԆH]HmN2rvߊޚ(mgjO!QN&VCy`Ƕ}hN4ê_.vׅ $A^ ǨO-|ھ8KGٮhJ$3sOכ𫮛yhȥrɼxӹP/juVBD B1UZE;;,_z0F}cJ0,L--1eu4mNrx)]ԣgIR ps7t^Z2c4]K3 :pzs8{Kv]HR;NVe{Sju#ij6줯ԽiQHqŠAfh'.pF4>֯-[\JcTo-w^Aݨ|RNMԹVѬX5cՌW*zYKtdhUg-:n] *&=F5Ȟ^1Ǘ -Ms.x\ަT`9jBQO ϑ*烀} S6iIPBdymsȌSV9e/z] JVfH՘4lg3:Oֱݻ_c2\ܖ9 7*Nk:҃M(꺝ȒeY6$hʬpFOӥcVZ=NR撧Xc 8'_Q+kT:&[ qXէ:SIr%ɭn'V- "ᕉ s۷r֊cʚI-GovbkRQ=")!ˑK۟caV5VV9pu"muݳ5G5\ =OΊ^ϕ/~)^+BU1@NO2+U)SqO[ \JC(TXТ{ƹeV2-sOp*w֮@fs1Q28ՌԄbc],G<~$64bNIq5Nr巼t3q5MވH+ s`46ö=77\wTe(ZkG{i\$6.B߾P<#'}kOzTcy΍:vMɸH~=(6Lw]G\H| ]`~5J5'SУ(w[6$I|Hsuf.#xCoEݞ0H@N*ksTikyZ:tֿ1"Y5¹FFBg?P?AS(y_/mm_yae1s(Tb FwHRTVSsrKh9'{[ #݃Z]4]'*Uj>B;dWęL0p{%uNj5RW~zHNu+Г+FҍxEKߢي@瓞)ƚu=޻iӿ1yqyƬLxhӕ8mnisVD3Ģx.\3 #]B T㌌t:]-S EG~ml{K3$2ylï_g\}v:FUf1b_kmC썚Lð{ݹԻхZt_M۸{BI,&2wmoA힟Zh{41utdUmt xH76`qR|o/3 H#tv]q8ʵ:*WuۧcR֒hOOz;I[{_Ux/9(MSqbמe;T2G?ZQW+yթԩYm[-ad#k8!=z֎V}ʼn|AF9=q}[aTiwWF|5'8/X8qn@泭F1p==Nx_dqDpgR>M]gQ%9rWI$ >6<Ņ:+.$ԛt5{+P:Aa@һ#zq^8g%966vߍg>GcSԝ%13)Rdة.x9 iFv"w![]y-cb@kҍ(ԦsY2XՊwM+ۨ{v`IZ66¿,~=jN.wqiSi6~`cb~UO8O?i5'Ŏc[7YGωrGr;J겨ڍն iFդH񭤒V]xz5*Gz+M4"thS ꯫ج?򨭇rҖCxF'ddMtzryjhDؘUɑ\Hovaoܿ) }kw+\MZ Eh<4fgmr 1 'Z{//V"b,o[PӠ0k=I<}?*~nWיUlVX+$!db\t֧IBO~Ҍ/Tid s3#8?H=^&2dzr#h]H3E`y_nzkH[ԌKUW]-emʹL`ND.ƿ{;_ζV]- z+y| /|+Zp[WV,5=zfxU%a6A%ʼȻKʿ0:(߮^g*Y{7yzV:y9Yn8`cwޮe ;}ӍjU9V." 4ųwAۊԯR #N~{de$I&YFAr9~}qNiu)a8ZMvJb>Fgd㷵o(Tom:壒D76h7FvH%*8rÚwSuiTb⢾2hQ<8UXd`zWZ<*=t%Q\y&9/RʬWsaOWz'ڰWlx`u+8Xu=5Qai5A4#IwHw4k7U9廆$so戶[8*t+UӥJW[=B,pX:?֕ju}vVsu?< , ܪXeJ2//#4(ۅKwI"7)en=º))Ԃxr[%:3q[֎=n[h?A nmó4qϯ\jT9huy[Ӹ4^e p@kYsE{MOicBdUVJ=9Gny*Qq^Vuޭ ŕv$10>gV4NI_/SrjӲ YkYȭDΡJ|9Qm5BQu$1.%$YU l<sqӚ֞"4JR˸+(X =qҳ|;kvK>ZVWyYv2^7azcܴuٿhƤe9A6"I-lUU| FA+8qdmR҃軮fUMjQ\ `F>#*IxN ,Vs'>d)'"*5{E"˵dݺ1:(N1"kQ.U~#Z6۰<۷~bqqX|fHCyC+d # 3sm6ڍIZ[w@@9R䨤kQBJomfy[d{*N;c֮PuUFODфeʯ{[bF{G.9ۜF4Kk^l9{uIt1nCq=x)О_lסգw ȍ>݄ekGh56o EQKnٽTI|wc#O_ߓ8pKeoe_frW FKo~gJ^q%ݮ_A88+ju)֧x_MsiSS죎E7(`@Nq\8'aѭ&SD`$wګ}?b^]﷡iJt6V=b- 6kVXWm>fZj[SɟhE3|~#19lc\x2dU*N<ׯ#H{|2z [э_ fQmLIR䚗Q(/@k$&[v~_sK},TR>K٢KkWs4&wۇʤڊ8\E1XtDW#t5QǙ+WNiZQˠRvΪ8ߩ9"z"u#5~X [ȾfDïj{пk4ڎzmRP#~U ۯ+j]%FKobxBdH5\<9RSr|,-I(++d9ldOJsIh)'f* r::uJ8vKcNuiief[HYZmm5ڊ/~i84hi[4h*ᾣ˭ztyGNqiܱ%odFCw}kl=|I&k l2ldۀOOvF-9i^ dv*6WcFڽ˔UK6Ib WI9:?-9N>\ӥwѕ)ǜ<-ZS5QJЎ(C6v9+Ҧ58%LnܻIqߐkn7ːK3|ܽθԗS1>Վ~\溾J򕛵!G!i?LRZv/;!ܿ'Z11 q,|mӥiZ-"eEl<PYԊh*B(mrQQ3zJ՘zܵjY}sދ{8J= 3lQ>r4;f>sʹM_co~^Jwٹ^ΛFpk))]5l+>IFWL=S1V?++}˖:BQ15XT37ˁӎ1wWh+necV`2|ȳrk~D9,oMlͻT-"ɍOuݫ_2wed7NsjqԜ* {p-IzV5(yհ"Rľ[N/&r ?NztpQ87E9-{ eB86«n8TԄyo}SR-Cjk'\mUrԧ$]Jv猪Q>Z…*1mt]MA%]#`$~x8yU#6ښRXm z4Jlyӗ2P.Hl ʡՌS*8]9ӸIz)޼iNi65*rOb6I$eUqa(:&ؚLs$>gr1SN?ƾg,imխeS/ޑ 99.3\J:rueMZIlL-cUb??wθa@'z'(׹IRMl=Ȱ\Dۮ0Fx7|Z^ &CV+n$zYӭuZr-n:S,rId<߻\y9YF5*$tگ$ū1|cF4'ץRkB<Hgг#Vy>{JR[mm?R8ӗ<IEZΦ0cqq:h+Qi5w,YU +mE۞8NA%4~Q֔\r1I:uP:``UH+}*),q41 >IXڕ5x"Io4oEJo󷩜֥%6/_-\/wBHw{Ǝ+2[ҩGݓ+-s[Ȯ22p?zqf$k};i,+.0)&ߺ27/B0}1ֹgcիQ%-S VP :gtkF\JN6 ViF\<瞧L8kr哚߯kjUXR4 >7z08ޟq_NԒZ+ˆXnF~V8=n*Zzh8TYaȊViFU3mڹRkZw}[zwcY˶ʨ#>`zy]Wӱ˚"9G* 1*ֲs_#Z|-%Z6Q-t_/q V>F\.Ozqme5eK[6;F"x7s߭DVOG;-N̯h*c^P}f߽%Z>vkH[*b1f*t\N'z&if"( U>:};w+Z1u%=$PBz Q8$է[~d"BaGe*6h q(ӒJ)FS7DN/8Pth̴9\jvu 3+n;pfxTB+0c\9<ӕWTiԝ5i$1$ߙ{{'wӔU'(ʱ&[B탎QBp2狝]DOoaw.Eoi*)sRҌb-~Eu%<["zތbgc1N.j=f2#FPg;OҧI˚߉2"^0]s\v"YJ.P*5R1MnJX{s8VFQ{;ٻAKy#0Sv\c=J.rxuyb՞a ߃]JڝHX˙!be1ƾ^NNc*pM_gR7O]aD|M/N?Z#uyycY#am#ۧMwF!ndzkSӿ7mnmqB~єJ2nDEIg:М֟V3RQf-52ڡ?n1"_9A87ߧ3!ew0;[Gˮհչf>} k=VR:*Ftb1h6Y[i\r@҉]f^8iKdky ѸzΥjw9hӏ,0y|?z¦0n1U%uٵ4,GBd?*?|~U:ҕ+Il -^dԺ0]3`cԔuLEPqէg&0"͹jWW8;3\:p>ߑ?C _{RVeT(Th^+/w/>TC#!Urv2Hy+y˖k~^SڳwB9-W 2NsV\F,^֞Ȉ` +r{=*Ms$98Rz+M%3\hNi%[R T,Hcyʌ鎽kѫJpvYBIihY'zԪF-G}K8l얞\UdpHm:pxUb#$׷؊u)^i97 "Tu[λ)ч6jULEbl?! Xmn>,e8lg/BKN;LdV2vH9t)ӣˣWs?mOUxmg5[veg%`ׂy$qUF( 4_DWv+Md![h*0qz DiWSHqQvRi]1ۇ$u>gFݎMʩ0b\ǧZSH'FU%li3;WjH4j)7^nk%ogFNEm}Fm aW=Ow%MJIF23,[w ۷8Ԍ*^V9:nؤ44ڤN:\-ˊ)=W^t]HUR_eR9ֶ?iw 'ЬF27}.=ZP،瓜ztTm5vr*XF (\M~9 `J֖"cdϧۧ 5},B+- *0`˩byh8hέ|EMO?g#I&W-hrnN˹TV26B[߅wF9Ir5Rj2߯q/$m6XmRqZSVRvhE,M. 3SZZݛT~tTo2xzҪE SX{%%ED gB?>4{xkNQot=Y8+ CUH)ӫ$4Ngmub92ge(|X }}w}J@DvP@=A|Rs\֥RZRs2` ~E¤nd3\\y- ǹfn8NNS墛ح q뵛oj1۵\j5&D(Vv2[:tZQQ}ÇvQf 7ߓߎ4eI9n7Xy^[MY+,l2N:xTQ;o[VW Kd; Q)Ӳ$Yԩ03QֲhT*vN0VD9-i94^ߘI(z}:~cܑ.R/'Tc%SàW?6e8Mߩan)Q;Cv+>nYqJ1NW oH) <@X۴lp}xǵLjTN=^al&c P8Q+ ,@9[9rްاO&tbҜ8U"=SQK_7 ##j<'q啢gͦښ8 c ]ӯ\}>w}gE%Kqwgz V/MGR}l=GO18`}cNN:tǚ/U{XQvڸA'SҪu=m+J5,ҵYbm* g=j%WӧHFU(ŞXU;ԌZ)u,nUF'CӯtsFVmN1}bZGnHC=u&71U:^Ⱦ[mUpvWp3*eM7*>m4SnY+,zcqֵ~j/F˜PpJotNWw—R[ndZ~e5}FcbD[rn[F k]S!bK)'vZr7C<]2mʾW(vt;ԕ%sT32 ܟƗv斈!HɌ۵ r 瞿rJ壐U>`sW~VaR_"X6,aO89ҡϸEyu#kgP#F V`wzGW4RPrhmӳù^FtJV'%$!̫̿$`̸`rӕ4<YXn]ͺe~_)8Fnrf8TR6V2PawqU:si˗Ԯٌld#Zqճs*.U䃎ǾGԊmP 4~-Uظ(,{ti?i."\fT`S3Ƕ=ʸ Tymm Qr{VY-xd՘4zE%Vev3`a}sHӔs_`1ՑKD#UY t(︪J|uA[s`VqNNz-ƍ8't`^#sp^gmT"iYe癹K.r L!ON.2_|oQsY)Y&Qb}D#̑ ׵hWII.QU/g5biEګ~8<~<e8U4y1,`=ⳔOdzw-Y͹`Hb@>mfti斣9|[=kNO;3իO WW_qby&CqUM^2-EINmsMjyȤ|JRV[9F'3<6V(dڟ,`ZH+"h8cdp1sImt_^ZY>QgqӨ5W2N61vߑbپΒ\ hìK"#=9 I~gE:rN1y-E^UI^I*I;[֍:PWMnLy}F0'tDUO_zn*2/c-m,Y+,olܛ'(?5)y=Ȓ%i$#fe<:ߗ˚rVI;.]C'JJ2*%bIv`QvmP&^grDnQq#?JΞKJ0;}H1–4a_Z^7r{HIIY帉2zzJ5R$dܿ0 }Hqު*n']­G8u+fmR7<+(JU$jiyzeΊkQ;EG,!5˱4T^F*+_?#9R4f3UZK~$A#L-W@˩*mG/mĐ<2|ʹ۸]8K\!!i;yj[`D{6`$Y̭'׏ǨG,i֌_), dD30;U%c (m8R}ExF\i8=2~Z*u/p6] KH9R|R6GMDwIx}GNJ9)JL&l1/@XJ*^T9pCی֮Pl)خ {WamFFy?NjsnmOFν1<?wԋvwwَ)*Gam-GNBu3[~o9y}9x&Oy.$b|Th'1VęNk1cFE(CnfYN0?^k>II;oƕ7Qk_[W3nWk?lnHdۺ `klޔ].mwEmPXUs#(:tʣw"ܴN$g`4WwN3Nk.]w*pSMvfKxsɜt}>j}15[^HW͑"H}pr=JQ֭*T-a]-f*V$A1:t&ULD-#󠱶Gc n8RG$Ga9-9iLxJ`vG6=OA:?VUE(/h3432wi{}(NXu8@-y[~ w4/XՄn"+$(2G=;2-&aSvVk\j[_Cb p85'eCͭ E-b}/|d>yz`=1sԔΝغtc^/8[lU/L\3)i.o_䈤 # t{J㽟BQnwռȂ@g r;zTUوo j>7vy-6b_u*yvѺJ+1֮OiOMV#ޤ-nmÐ1 ҕ5u+inrVBo"M.KtNEKgu*vtqiGzw9ۧ*ר6iT1ߙ|}1JtjTҡ/rII:augnNϧ?ܷ%oǫ܉I7V_.9A߃r+(J;^ڥX Z (taYKM9mTqOA*,ƯGnʪT(Z:(RkV[6gFy6 p9NRK8b_M\O+HW͑ԩmG<H):vOCҍ5;yuddh?4%@Pr9$AZr|w\$E4*X[xp; >էKKgJc.J) n&I{eS$0}G\TLKOo 88jb0ꮏ_*}٭32C$eA8`:kNiTF ߻ls_ZUK&vfUʯ{$mFpKCȩSgIrfhd;[Yňs}B SIᢊU =OCF1Uʝk[ЈBTڕ9+f$3˦Be(㐤٭z [uz2}] dWW q0?>V_S e/v,+Vݷ 䌑{NIZ|1kQgO?NEۤqfo=:].Uh0m!|C/BxFdnG(=IdcwnVU9^vыSLG*zWsC(8:Vh#̿cӢ]3Ne8º)ԍ=$ܒLm*M+y$;SC'F*_#8*Y!=1*2w~Ob{G0mbr1:vk|ъ+ST_6D$L}OQIQR Q6qr߻oƭsFKMJhB7Hl#l ͖o׷Zӣf4eKeKP6YwW){=R"Tj*ADmE wy{I G׊QE5&FGF:Er;_2c] uU~%Bo 0݄}HsT|t! 1I?*RwOQTN=# Rsg`OgC(F2D6B7GZ|tRF:;>lX6y 32ߝ[̯'oC(J1q%]ncPхEOUJ[^ϖMHU 1Ui%p;wztIݮ"q]GOA+Q}𲁌c*EUZqzj_wk$ʢx┡ SWm=ޥfWye ܂#>ϡ1-tYGDPnoS"cJNKT ltq2d`3'1ϭ(i#TS)&EmSAsFTtM>i;I,Or9ǭqʌ|cՖ*𬌋,*~pEjuE(Fu%(vͫ>f28|5?=(Q,=ȠX}X6NO}O\5TM^Xǹe7,c# Bz繭]ik?8zqmtZ@>O\U:6:TW0ۙ U~*X~t9ѧN-xԕ%V"V驾in ߺt~]H 42;ap_SOє۲q֕IFOwqm56_˒/qN{:M*U>[F][ "F1q߁JRKٻ;Npn ]CG[ k1?>3i&2jE٭=FW?KDן.j1Ī6s9V `ZQ_t*oEf慄.mk/Xϡ=3ڳ:dkP'[d/]if~cenn接8 Ც`[k@(jLƛ&~Rkd>Ưo$gCӡ{ӕxj6{v"uI;v*NJVzHۿG`8<s~ګI;'KpZE({4eIYXSZrݵazoxdSѷq=gщjMY\-ԢVDуRǦ;V1SOob;$wCm乊2q[rBt SYW .m(^]9< ub>;z3*]m;p[dܲrb_c-#|TeN*4t|W q&tcp=3?Jjt}կqT,DTڳ梨r+xr-LynqI8\^ Xt.G #]j>U\yu:cN4bPi׊WZYxש&'uƍsd6֯C,ۗtym8{Tj*˕yUQqAqāL#xR3ִXEB*]X^}J-#0\>uƜyC)QT{!+LphPv`G^9=kԍ?vXzNQm4%[ܩ$,ʡ,1kJt;)b(ӟզ+v;bJkʵ2>/m:ip hZO,#]=6uoG"1j`;N3N:jBvZ=ܑa "e׾k .gەH7vO1X=;1]4-}ISM%Pȑ0B۷JQZkSӔez=J,j8fWj?_dE>X}:[̸E(dS5:qw:#ߐ̬˻-@\y,O,ꤖ˧؜ĀˀZ6AGZJ5z,e >J莚jq/!RE0TIĒ`n㐸|UKs8aNw] Jdf%lHxWR=QRur2d=8c J\j1.V>o(VE䪾@9#֑%%s:k?"O1+:ܤSHTlʠY'O?OO]NQEGc9QktJMe.52ܕDe\msI$lfݱٻCWFc rsӯbYbI$#<h2\iԙԧ=!H2[y gS'e%N>ҚZVȱeyPWU^ҶITH¤є7t(X4fEKprr9tW4Tͨ{*1DPeu ;`: ZRwN[Rd1o`㓎?SS(2ͽ>vb<ۼg]Δn_{[) "i~\3^EÙT,qoKΪ[cyuY,B]VԢuIђ?0d+ccUT[散=&v#|th8G֏twF8PО# ZU޳aF^z7b&5ReĒY-ԈxBvFxxө*Ev8J85Z_˩? Xpv!qQe맽J0Ikm=IbI6]2d1+yNrkzشym#.yVTRՃFRת'cWYTǞ){W(q#6Җ~xLC U;uHs菳;ۗgOByI;gA'ֹg8^DHo&I|1B* tE+2TEDv2^2$8Ϩ6kӿ#^’3,OU;٭*{IAFz2QԒTխ_&V?721TkSiI;~IѬsKˍm{d;g3Fo.(FW4r?>Ҏ$أ-92(u4J]̍怟8ۻ?:әV+~RRJHQ@R)Yku]sךqɻX::I."mq8ɮ\D*t, ڣGb\ wpm?#qAQ\# n8ǵ IiHѮ pg~G% qOv}/}4` S-lݯ:;am؎'{猔l*4~x=l6[ςaU Đ9S;U(U+kEnKbZ~xbI&ɹpB1c#*zPUd?ęsӞJvt_jwuL]O1Ww# ; heF5;JI.!kl k"cq?4->Ju+TY.Я̗]WQi? 95SCWA )[d0+ήOT奇C([-ش 3\m 2899Si7=7tkEE9I'gyzxy9;'ӎk|7dyU~Ѥὴ$nZWT\nç9qҷs.:.guЊ/!-ky+W#JǚW5okub}^k)VX$ljT#WZd}oo;#Z5(IG{%Wb;y&65Uf;w/OW*2MruVoBPL.C uJ4Ug'ԑ}',se<'uC/kw-<ΪrFmsk%WQ 0RvyAɮ8ԣ% ];YySͬ4I}i1$QfҼsMm FOhoS˩Itn_ g#̻w~nҪN7ߟ7XUf}22bXaachюkkFWtk\mkzhW+~t;>1[wjqS滖 p7&7γ[ĕ]98U>[jz4N+Ȉ -^`Lͽq3tVQO3XHVztDwmiMv2mqq Sr9#9ZjtjK9Pqw[>}%Iyys+ {Pr!(5]S?Vw-㢵I!UvHHH+LEnh u*jqɅI ku^%%i>t}c6KUbI-7V+z]ck*t*Vw-F س*mjrr'N+Q}_]ORQKZַr QXrɃϧ嶖LjPw *K`rxk^_i~niN>Ғ잶<!ު_0 93_HJVjkX \i8URpOnkbw3exod~cunc?ro; quZ*T*;/Ի$07T5Mؼ{m\nsr0sD0}2_kO f5DpmEc N>xlc%̌44~c*g΢V'umZs9aQ[B0v#xw"]@c!W7'8\1%{T嵴:3zQb%N4- iLھLqӇ#SN"im;20^//4c4 O)N1_iV1`ʵ5xYt} 1",ۤۖBtӝOfOޤz7y֋Vw7lsG՟RL1S=UآYf|6+XgN?ZJ]^]TJj7vfۢ2cW>YS=wa<:2? RL Ѳ0gg\RZQf8q [V6Ceeqҷ Λc8D*p]h,bEX؟رOӢԥG448[L׶PN<(@Ā*@TcJSW2ӿMq5NQmVb+*:ȯjp[sڔ}{)T2ק[hB&vu*ZqRWaiΌg:ϭ  * &cLCؿk't2JUED+,rHܞOʊu#[I.VoiJÚQapna;xT)FJrW} kk)O48ݴ(8ccԨk_rFN&ʬ,cXWZ_ևr~•UwzYFΝ:QטGmCd$l$,I=:TBN1o=[,|קV45vvvS]즕UbWiNIz/QN4iv/)J5)mw.hrAPsmq1Z8m-zyB2'Eo,+H˻?3g듏zҥQ~h9NUvcc(I=zk[AlcU w e/PCNbZBI:2HcBU t㞽Q2,iF^DK`G*/wu7*4J:U+I fmX;FqJΝI'%t̨ʍv1jK}v$"P5[X9Sw莚{;_bUn߆!o#ojUǑ6N4/B[ӵmJ\_4iӃka:M,Qo7a#+ߧCk:دv2l":68^ަlPw5Iu,s i֩*ON-nlUYKTOtYќEeF^a99Ҵ(0؈?g}}Rs,J҄ONRPydY5ϒ)ݖ19ck:ь)RVٿAE%L: Y8d sb*|+~ݵ&$5wuuKW6_*!VZ5S@3޺-jiv){q[-idaHze9;1QQu;+Vc^ѴŹ}M'B6?M R_ -=NI?+mʘs}k^T^ *TIŧ^ҋf^ra==9䤶48SGzVH8P1Nkѥh{Gv+EBd q;O9UNm}HhZ[4[ndr{{tq-%I9'(u,3*-UBSJ}9L y[3v6lwMQE%[,۷gi t&9UR"d/E˩I\̟*v>Lm#.WcJTX[t~G-ϯuS%f$QWө=}+ҧ:#Ȋte([ {3^;Fi)$Uu&5l0U`[zgѮf9Z+ne c?ֻ)GA]HF,"RS.G3ֺ)TdN;2ք6aXoq]pB%NS敗Cg>ii%>T"8 />R}XJ?"4[9\7tqh8X32~6_,ޣ▦NU*KصB876Hs³猥cJ-vewVJy'"E Jv(PRVݲo x9ZkSFַvN>|zT잭S|l̸!Ē6H6OSKY*k=+K.uϭr(.3zH3o 08pr,V++5if7bpX+܊[3$كD7$l걳/b~b>9(RQvnыwpQ};}*y}ZcwcQtI$YXdۧqz.[;+GތZЭ%<.|_qc>YYA?RU#*c`۲{ ڰs)F^me 3dU9be9FKW}DFoUelF?M8ԒIOĚ[}LU֩NZgG8I7i#f€u }ǯ/u]Q)7ёZ 4 lHy%/uXpYB@̑oUBp=jsJKsJVzz[F G͎3ּT]=RJMO܊[y^2HTavm{+#J*{[ȥ|KCA'm֦ذ[:OSk^z`Ti?o/qQ5+32G9.hm~u%-'S%l[9#'#D2ok{.--cAW;zZΝӣ&J!4d9ؼkhӏ5Ṃ9kz1-Y~ `zU{H{L.XƮ?4֒yVH!U~8kRejv s{5#[;%emě wMg(˚>ˮocNLG}lIF*ݠG-DQ\^?ƫzW(wn$cs.ܖfpz+JTܪ)6*<1o!["RwI܎,D]GTsFj2撲4qlǕ>XƼa+Mk3Xlh HG [!c+sTN:Dx(-%-,q٭"- ;UƥS(-tONXnUymR~s=H:{֔#UNhsm;bo1T/#qϵiWVӭתz:4nY?N~-(Ul5h_mnm;ZqSjrȄ@r 1)G'ބY7MFՏq#qp:T;Q>x[B'pr8`*(FKWFUGwumo}>⭹"H +*=e.hr~ZPZR[%I"YW c~\*GdDs=]Fh#n#۟ڻ#M.j*dXYr01ӎFuy$4:Y$gITr0Lc sN~ӛkmmWuuc)ϖW nlt+=6J5F-,x$Vܬ09#=*hWϯόQV@o9c/rX#?/zU#Ͳ^5:p|#kkk$hBteCӊΝ/iiAO'}k(| \+1]L1~ʻdh)WmmVO15l,y`z5vNIhZL*lJ8q`V~=N5z|ɦ4I,*Vrrs_zVpb*:v-ČWVS6Jf@̸V=@84M_qcRxux/_3pa/{W/i>R}ӻ;ZD/qD*~qѕ,G~4a&6I$Vd{9jҝ:QnT8OO{]G!H4mN8:z\꣒u9u[yʤ%$->pۊʁtNb%Mj\<4.!X2~ p '!R_2^8֔SVjbEsĐ8Vɒ;dp?*qobגP^K %N$L%ӌiS~!-{[cr{mB2qAJ.K[;Y7b9UV4E֍d'W%9SSok.m?pN:Sڳ/u(ƜTv4Ċnѷh{T*cSm+jO,F1nyMuB0w6)G+Kݳ5v;CIrb3OgirTݿMhsc`c0N2? ƜTxIm*IL=DzciU*Q(F^Sj)Dd1X=zuJ^SnVUPdw`mw#57++9gOKTd∟"1a+YJ9?}tE9{_IkcpukJtV->ATQt}7ɧDX 81p=GK8]%,'5YC,I"[k6N3S(%oGS Mk.e,Ym:qޏiNRT߹KIΧӠMʪP0b34㇩4b+qжK$_fAH{Ma%jԓp؁9?mۜy:jp㫿RJͮR,8GMhUV՝g L9lxJ-Ž=Ae$Q @YwUF/m2ݛcU~G=Q <~fu|w⵴>Ns6nGj֧/qJ'R~]Vku{{*qzU(ʮ =X_$r1ܴTl%(8-D.U {Ob:s_,wjIzݫ\?L[TkSI?z~،G5FXkp?\Qֺ#FN)-m]ZJImGx#jJ2OFw4)>U~ϥ1C7:teR{Jl]BI2u< e:jkO롇/" pN-&"t2}k)[dFrߠxbD}&/?[y,iŧ$mo {,0V_u'*c[IBI]{NKV+FTR\fvocl V9|}ëGSCm^6;"l۹NRFXԼ ,S(,9S9Vqtcʺ_pWV84Z{d[o\n7yrSsMkR}jXmH]RBm"c(;@ TFgtc8ԭRIZ5#vU-f`6xz.R]޷3%{}D̙Zr[xz.$UG{L\X1GzX] 73ku-"s'ϿoJTuӍ:|[-~vEUN˷\Zac$t{nI r&Y@e]kKݗg`,D\gQ[> LyP1H?LNkJV_xztw6IZVnǜFz S*5+j*ѧ6}lHD[̧+Fܜ5R1| [lkjG=z4qsZm0̬21\=mY2Ŷ{cfdmSV抎E8Ҍz|3XInl,ebP21S:%*_ٮE g~l};V#ԊTdqFoE;yPU\ڝ:ҍ. rCpnyA:rsr*F<^Velq")Tlu#޴uF4RU.H/J^Qp~xb8i^Nkvki9,cfiqWq⳩%VF.&IǖB$נ_Zqʔy "Lțm lA;toNfycϩz5; #ryqnUfc֡VwM51e\ۦ}0az`OT.[a9U/r/n,V^~k)ImJ7S Ao1lq<ֻ:h= v Sl'vAc>Шqv)o[yR(mʡf/2ѕMK6zCY+o-w!u?0JFdVZEEg[伱4K68< djNMLJNW"4ΗMT_BbiXWfOIY0B1wjvFӔo?ágOX$g[`)0N+4LDiۡv70xpz+sMr:7h?"'N^jB]5]-ǢtuNhIdcOSiOq=ʹ 5ym`tֳdD|5[Ku,gXȤ'׵M2Yg %(B[(-U)z-!r7:mOہ1Z*:5hIժն{|f Byeh:ye6V"Œ¾ZE2*r%F[xl~^z*su+ԥ+r[yu @:WrUJܲWZu0ڬ~`z֒i۩\Թ2>fGPpsKl,:M^A ݺFq~ʺ-I魔WRÙainv;ГGҥ(6݉:hE,kV.8? czbiHqIT *iҍ=δ|oAnE E?LcSFSmNde"7۸ qӷJ9YB|{\]4az%Bÿ8+&]B r<`k9Gv[7E\|oNv~J`֨ۙ$s?ZEBWvISD%p@|Kre^נ Xpme?$cjS)G)7ty&Yds_OXlv:Ѭ%2\,c-p>ibٸni|'hdlc*q k~qܓ-Lc+&cǑ[Eƪp:pJNR34|ܰ;T.Z~mrm[#c_8L֟/6!7+_I,syYnc9^~R87I=Fpcm sc5$%# <%FU dc5eFmF>ҥ奶Oo*VXY^qNkiy;6"=埙RETPSKŧfmoR+qɧɳg*M˥9b%Nخ F>luHbӍj-;5Ui=9Y:tTqz[tVvc9%+)ʣW!ty10Ü21_{݉o*$^!Sa9J2QQ(/řc|$dzc>FRd hfy 2 O1m./B;!Cڝ~j֑ї*rѿ3muo-U<Q.[3ʱ\qۯ5ehts^U""#2!*#m e|YUqpw#LqWȯA9S{h2yY ڽ~vTeQ\Aઅ6ܜ~u r䕣J>X>Vo{sg{܉TrmJ8jZTSm%g$VԞd°¨iO;"4{ȹI67':p0.j{ XkF0ǠjF1N*|Y)# s9Eң2ē")X5"]:HNn'$9өq ٮuc;N31ڢIJ.v]})B~Er.gf 4BLV<qS}.S/gtHemʾN{\.ھ马J$%8aFVFd/&X'0I8>viAJˢeK EWso-o>xQ;8r׌MTFnMsgYUW~R9`N w.U7!<_9w+p?=O޼vsXZќ*M)]}Bnlk ܨem#=*eˇ{>*SK_$pX@&T $j cڦIԏV_Y40IU|$H3ҳ&NZD$ܾo AkHZV+`zSK YAk۵ 2Ǚ|9m"5 ?=;+J~Ƣ\?q)#>}B+ojZ=Ln}v㎙T{J4|cX(]t !n[cI#'%F{vէ-:k<I<TT2@w[ {j4cZz'aD6@ђ˻w±ZWz *eoRAty]ܨ<iEY_cIb%OG C3hƌmjKk'ogWjYOr1DNƟj+vLjOٮu.i*q[R+V2F\^y'tTuIrr?RY#7QnwI#'89#{iw]MBݽIiMt>OtF0j7ҤW2wZmM< `2a`?q[S_ʖu1ttG#r͌|NA Q\֌w-<zיcv㷴5ƿt`+gZ8r(Ķ8߼2w2X~?.kOȚ4cn[j4&TY\)8UR~g4VV]ܴu ' 2 wҶNgKQ&x,ŹTӞTQ*MM%(Ii[_-Hܠ?ҽXSu5ycGAii-ӛUݟq8V>;+ЃH 6BnlP\{pUz֡Tr>}$R?XʴmHwֵRJqE;Eosyo`q5x1TSܓJmpVYs?>^]6fiӎweh#,8;d!-2Ҫ7/s ƚNn-`7gs  ;:Sm^D$ܩEٕ?(aӏҳ )sF8 1 ؑJ~ejSg³59und0,$6vHzR4oͥ?hZy4^S-&W-s{WG̝9Ta NP)-R ThY[o?Zil⍽e&&2DfUNX~#5*7m̨:~̞hݹv1}jiөenqP#dX[gPǠoDȺfui5ь,tj<wOzǒ#έ*+^eiC}fnwǦ??ƪO-:1Q%H$qK6){qX΍N[:~gq9&pzu'!u)W{&P"6k.OLgj9J^KKzh󹘆W UW12f[{EU4U.@+<ѭff(§*HCo#\k3;p=hZɻ\ʎt:_o$2yT<+R1ozwoLIX"~ ϯ^+'}hmS->Cv$o/7ap:trW38=ȷͽiUkcrE~p>>ނ}/0EYR"IݼO}+UƝmӛ|ɹ~}m`N96ug{_b$a|#cQ#FAMopUem9XmNEJZBhFӷj<;/dPkuQ_j( ZZ~tivEדkU-oKt*Tk{NZr_5q#F;Ia=qF1z}Ob Q{뿚IĈ-Sruzwq:qT|KxTK\43E56ϩR(|.;×WӪ]SkO*$U\sG9Sk_(S:Pm\b.29ReaSJ:؅]$s2(is$0RJ.[9%ru V(ʬ>Rd? 5!)K??+W;NJ_y*[uNNsakiMJg4T`ӢLq?Ǧ+,EmfR*IM [UtV-+?dO}oЙCFi'ɑB-%eu1N sJjTS;_5Zl7f9vDMǻdd+`V3̭[mۧyHX,ϙsgRA8Jt|j='Q,'IvB $:+*c -~åtS).biҏz h1wPTsWNwrK+Mk"ݯWtSBф?#`gv~u+Tvz ¥ZϧeX7ڴ媿Iqzo|^7w߻fRG?vT#JI;Yђ9̏R8 )JgDPum"H"e'n r89%5) ZIܮ*0Fж|`KzLbF6̎zժJz_F500d ZJrӏ~%wzU~Zɿ-2B#Ƣڧw"/|+sܰkS9W:iY"_$ 6vP=Ab<*H7Fvf<uIۖ]>Ryc߼UXtoso24WRՎOijiMzD27H_f;O֦*I۞u%_U#K7*Ү6+ImFkEʗq,M6l:w[2c#l:TJ+**pgqϾ*y2VTiCW}[rtO1>*J^{v8(הVƵ?y*GjRq.tuWeY41ᙙg,Dj;Y^1;I̚M32|23ׯ@OR}.Z+z@bl wN~|{YU |˞Mjdzʽy˘6{_bե6!z~UыWCЕ8ʟ2$PZwg2˚NK馜078jrmaQw-,r23mee;Y[i^\*yχg"W2ͶVP3 ۸85**-Z#RRz\h2J 㞽iƚ]Ҧ"I<8|kjGݗ]I'LsapTx$:Q$Q7$FYmvӸ#8fk/iUG(KИC粛yB0dR{s=?gRJ;%[Դ%wy`m~n{֑HRYYҋkz̲F̘GLrG#Dw!C+缾j+c$JܬZ{PN[h#\YB 3fHǨa9QfU[O5I>U/zTw$F%[208'Vߛ8kJh5m,;c =TGFcFicu$ n:lSv*/wԴTI46 5ԄXuOw->d"@eUWffoޱ6=ҡ\ͳJٷYդOp s޲駳%f8@$jA˞goS ޜ{'AcI`Wk!pG-iJymzܕ's $uzG'SO={0Jz^>L7HK+~1FTkJ)G*D\n-{`cGS>U{^P(6woBvV]#Au#*EC%u}#|H'NOLIRKCL6MU+7%8-F?WP}<^IƓt6w̯"n^3T!)ES_O+,6-1*¤RҎ˧s*rjond/n#}$w2j㌂}kX5!m4Qswzz{M%iĒL  Fs#nx'j5*k(V^vz߽ VhgY 82d tIZʥtoW~m ֭̔b:\&ap3*AWteNTUH5RMK"+m+ϩNkG q"sfZ)v]?c(˞wOP FҾAR31YaS.G =4EOmZKE~x[ lܫ39ANՌ#JRO塵9IJӱj+ko4f!(p{WJyϦzeƼeVZ=`,k (q# N8vI+:'** Y[hG+#"fB݇=>xǥkZ~wle*4Fۼܪ06a<Jܫm4UjqMmlR6Lr΀=s[S{tO웺 5ċIy8!W?rQNwRB5_Ў `V[~^Np TpۘuJnߐ.KsnB2%U== ٸ*_iGRnBj#n@<.: JTh{;%˳V|KᒺH&Tt+'{TF\z{)Q{iks4k% [h>U8 sAUZoO{mm>S)}?$5 7޳*qnWR߷a\\rѴq!o.Dmpza>Z);٭[~?RZu~kiV8mv'1vsӧ薖Z[cFueʔm̯*ܼ?-岂z<,/gW7et>So7#3ӥV~>+R5$Gtnqa\IS?3l˚U4IdM$n[{^ bäMUժbdo~ňHٱJu`b)t_/CNiH@iDIy_*2}O'3iѩM&:||D,DcmV[i$gd}9'=oAZQrtK7ly c's0-6=~Qʓvud$Cnqۑ>RЪYaڄ_6=G\^b3F:C]jT|Լ]W` [[3sAf+BZ= QOr}k[[H[P3<?JMg[Ԗ{b Xx_]0oKk^[E,"ed?)c:TzF1t6XŘfOI>}b]{:1x:vSo= Ȭ[nwmž*e&)N[u|Ė[K!Ð+`zm׌o<"'NF-r$]ʇcwld㧡TSNj_чYSg[VVklCo8+jabOzMƼ LXO?*)WX)Fd|&{3*CN9wqk_zZ=v+GNU*KݽF+|FT’J)U!|Ko˺ma#n#~\o|Jpr/Cz| ]vnBztr8-B9Gj߯}qMr+M_W\7[SF4S}/"Ip?#~jcO Jzh9ЎSj&oʧt{Jܽ?&Wvҍ偤Fʧ m9ϯ?$uxzPW{3JjKH\k.866r}(ѭGU]*jʜץ幔2q%pp3[ԩ.[- +ac뮯KuдFu&bd.[tjIÛDDzrNr^k6Ci KEܟ'˴6@ǧkb#QO#΍?ޮg&\k+3a9LrG[N7'ϰTvlP2ɷs1J樤}}Na;;n}mkTW`1V)Skkn\k)KZȮ(w?|%rǒ5+A1qVu'=v_>H08oWqzNi'y>c)Wݠ{ 쪲,rrS-B⩼*[>]1ZO|ǭe*4SitWCTý{2IW74uH#VUTpz)ԔHb=[YʱmE؍J<~LV ^M:ZKsr:(Uܧ'ROTx|LO"YLیv?ƹUJQV]nYn[J,bO=c|0$l'uU⶧wF|qUF~wiaj:k޶3FX5j$vE?W'Z^]QՄF$,@C/1$*3’1|VօmSzkck@,?ϽzXIGdK$>ԟyKczקMvroI/z&Ŵ~;{UQwOKFRR7.ZYcG&bW#QM[jSҶ͕?m܋v -`u^j1ntdFH|Tn|ݏfu^of2E8E?UM>AzRmnHe,+zgԣ)r{?{_BV)Ckc#q&4쒸o_z~zYh+}3[rMJ~dq #>m.ZwRәj~\qWLU#Ed TG9ץ ,:=ȍ2)do}}+]q#wm8'5Zc+[V7+/OzTveYh|FI}=lgNQEIߠGnC.e%.VΞhrj 䟗z\!6J)m;~V&[&Qd/N?Rsݫ s-`Thn=FMg+.nnG"16vp0zkE8U9dBA&Uh_o'$ck+㧘'=jm~4l'Y'djds}yֈi:)ԍE̻"ͺOknQNR\"*rS^שxs _[O2<>X*c>U۶瑎ӭO45眺:7UxB!T2t0᝙>e}gA(sq:s+qo#-/*0x};ӕIےq M(kO0/"9psjs5+G&aeϩϰYT|\HgI#UWvn {ZLnṳZ a՛߮kUFqշWbdcf 8ʵxx]:Rbי.}5!Ί0D \pT7S}^dXfqUi2~:y';_ӕSV8ehJ,{N@ ֹ1S$q¥I׷˱snO<卥,qV&DprDXwm'ݎFzjFׯ4o31I\*^^=Sib)KN.")Քa),[o|GTpp<}፩s]-^$MR8ـ[RF=?)ދќn"RDq$wKƬܝqG*(֕;ʭ{*RythpCInT`89Jו{[Ј1w%YM$8q 3*?w~W^QD+UF wY8oOYG>d%Ш6;U}zbVQmO6Qjz%г$XX3# ǿJTi:MՊѢ(&>tmA&rۺ?^k*-|-=LicR*tխnВkbuFR"?˿oήj!b+LBmt ۴t׷s\cI]lOBcLc9UNWytJiV|_BIoȣkȲoA+IJ"N:ziN0V{G{;̓1w==;WU8;￑ɈsT^,#]+*sN-4ЯeN+ҥHj +ч#{N2i9S4M4XqSo?@I4kGvֶ߂+A-Hs=a/NZ<% )klI=M*ImZ0 F'pLӨJvZﱴ{^fM( T{gu!Fϕ;ߗxG(YDh+n Tn;OqZqJDԔh$1KⶑgV_1 ׎HYU$Y߾CiFH2i.3*ҥ99Ϩ(sZu A(EC#KBۙv*]Oiu+~?፣*v[u0Ayyagbs9'𩔧O߅t匝87o/R%Y-b7uQ֭ԕwy9]=Pҁfmۻd8ǵ_,yPK8t5 Խ ~Q$}(kY[TRw/.H|I$9,GQ]#ٽ/}]Yb)Y;fyQ,OHw vNiTrZ~Z5Z`H&琢-w1{+:_7Rngo AZBX-5Շ4.B07 ,R6vn*8:kXK wn Cc 2?geF}'u M:ydKpQ3*tk2f8 dcԄOƮ1}m엳"kw0,sߜu9P+wve8$zicHFr15>XS =Gt̜I$l;O=q*Hvk(b)J<1sߜJ[.?XQt଼Hn?uhH9 ;qA*撓fXWQ\Gpř)|WZ4ߗk)I_ϡB'V N?Oj5h91rM{kCg GkSdj #0 Gڧ)= japA5ǝ'>r-T ULnWi:gOjci;drIrN}0jѧ$ʴ̯2*ەrpz+ԕ4bʵ *-Ffg8{rI]QKS5B?#슆V̑Dž 3jjb1M9Gٵ[ )#Jn{~ɽ/RQ&ۆ)'eJ?T()hj dU=O5uhT76/gԾ%9X*^00[sljҋ: Wqyn6qvCb1g'RSoq6y. GrmpGW-iJ F=t=KՔm+}5֧=m$<Ƌ6n 5#(ztʌg4EaW&:67yc5R߉υSC'h@Bt}0}JS%R*;sT'v ymӁZ>/ڜcZVvzO= {ͯR\_v.r4mJ -``wʾxԝLU嵝˘c>ݎ3> O[irMS~V1rʌѲ$øpq]~>.1Vt- bN}(jTFjFVBfm ֯:>3iWݠжvD.HY)׿oʊN7hތhYYy[afFLm10xV>|fi Zr?owF8ǛK~'*xKHߣkndy Li)[dM Vl8<}*#5V$8{nP1Hwpqpq){ϑp:mU[ubč2 ϱZ V9/]ԉ&ݏ>eTdg 8j˿_Rw}<1#6c݀zc?jʥNiGϯ\jH$@ݐN7ԮzQrb3}l Ew%UjD[]*'ZzT']ړ%r"n~bic#9s)DҾ2("R,yܩӮG];.֒Հu*A񷞿Ƥ#ZӾdFB=O}j%S}C xK%eU)NԥN⣺};z֍Mv[_lp=9j1_"!JSuVuڬQM~eO@{gׯ^5R;P,m-)'*'yӍHR]ȹ# ׷o*aQ5W}c ̑B7_cSS֥G(ꁐCٞUeٵC۽DN1VGߓ_p˗u۝ʹWNw8SkϠ"cYw*|_#5JIZΚ T^ek!^IIm՛ngRoSNhD4N#a2.8RԚ#-:"FV""𱲜<>a/u۹qVG[kzJ$dȕiJK&PeQITz$zT}am$NGm$edqC˚jN-ꞁm[үe̴;)KTJE,$R۾O Fx9OCRpIK~*6 ҹ\ʟ,7kxYX7?Z5ek%\\LY 2rp>5/MJ4 2HLwwqsǦ3[)vʧF]+O-ZDbȾ`*x#ߨZ#~Xɩ'e+It; _sE8NjS<\X1#ζG=gRG4נotҮp+1=e6elmڔ}~akAAP__Vj'#N_ǵ IlN*1l]5;TdvϽ}Q7+K+ªA]WJ0Clՙ~e fVb:]+[7![Ygyo*+s֪cAJKw~jހ^"Yl,lIA:up,tzzj/_wZb5dݠF?:e<:'O2T#++}({˖$3ϹvTEGPЂfO P*y^9QB_D@OVl^8VobBI2b>dR7ʸ 92q\Z1JU$Ħ%V̽o&j!K$bգ'$ýKcLi)=F|34f7qҦ2R~FjEY{+1 3OըmoyX2[17>zs-$h?7ˍ,_+Sϧ5VQ:s囿 h]q$ʸUf9'ZCߒoD'ONm6avӰ7'v.U*KX;w+Byho隝^j\ܺj@;˖i$O26bm鑌t7zެ!x.d1UVf*W,%J^q^5,wɎ1Dob)ʯYe*6Ao֝N/FR{m$[vvU(gYRs*TVK%BhogtFTk)\ZeXgmI'꽤k jSfVƠDZ4|Nr,/ymN5'VԲ,v?W疈ꔰҨH<Ȑm!Ulrz&m{h)fef`va Ƨ =0s=hVPTMbU(#kuiV6>eUs>U#Iӏa-ٿ{2#FϧlڳRN:4m{|bM/E洔|s{HqO[iHgKhSq󏽞Ύ^h%.-jϚL.y#R64B4oNÏ5>6[~^s] Ϊd1}>cEWYs񎃯={Uqmr]}uk` 4sFn=HӨ{vCVkG",Wk*~oqKq׷J5uNP拆7[l2#<\\X=Ǧdfo%}; ۈ{cS5;IFмC6[?_lVR'SzNܦ y "G.QOCG-㮇7 O]csH F>ꟽnwg(KPN?;1aqu9>а2B؇NHdkH:jakWwQi"sm8eۆgU:ҕ99- eGOK!"`cߏR*V_2> +߻< UPW7QUխ: AH"^@H9(Qf 2Tڶ')pȱ4VrøUtC*bA q< fbUf02~nLAڵ(iG^Fr;X$o=וʾ[e8U^ӅS5OoԚeܪ,n_ªT[ʤ#ߡuZr] ^YiݦmE9Ka--!8?ҩz KZ*f;,onJ{7 VFW%##ӌuءgڕH:9}x˕/O@IyY,'ށ(YV:Ys7ҧwEk ڧr3 ~)~|NɡkDՙ˴xeg(N)_N̪l2y^49ch{dNFlF#MTfF"U#NUED@nTT^fqyOJKV9gf WlYݍY}^M=:ITh\e[3JKMNh(ԧ{*sq Wq2NQNS&g췖]b>xuJUt$^q)k69ZR3F{a#tU}r KcQ]$xբ>][_!<ד`Hy6hbÚ06lJȎ<ƙ~l4(WԘ4֝.ĄJ<͇l1~Rr؞XS Հ6 zST֕Jnz~@sDCUfQxF1o~Ta1+`=_u"XcgneRy<~k)F:]ؙsFQԆY[VɻܝqIM&5N,w֮]Lf{ܧFlKq5 IoĔ5Xc G#)>X3Qg;UYNOY/iN{^Xo!)gHws~ytmEg[%ܞeߓoƦ"eva'i%;dep v P Ruh3;)8FO^EڄUc ZVq8ՌWWخ3Gc6Ӝd2Ȭ=cSm>ŅWnr#Uݳ${bv \gMN[H#-ʭ'_\zZGBcC=p19^+9{9{ؙ{k4 32Lw ԓX+m:XI>kUo-ToN_a=j#[7%g**FQJK+<eef\e=ʵTޗ3]gu۴H^FGLqަUy*TyW+԰AU~bz爌ʕ xz5b-ʃ2UVzdm'9\x5'M/ztڏ)Uv^}̵sT_VR9+JP){ļ\%F{/ױ^RS ю36ͨq=waNUHq||W|5 <_Oʫ ENk&v׋G$,6GcmcҺ*Q#^a긻8^7Ktl2Nxn'9B9N6UIG[+; e1\.'2޺S/_tk|Ia&`lzW?;ZY:u2FL#G!Lrp=N+eFQf4jFQrI>HeYb1 }}zs޴jss2>3k$̰Vs{ڪ<ӓsX֏AӃvDg1{e8TiNz8s B5PLdM6[fw(lDe2IGoNhF8z3"6^IٓGo,qdFH2'9ItJ41k*n0wWZn{m5f9^ G:)ѩv#Gj)P;s⪓K-¤)9FkMAq-(0Ȅng~ tF:ѭ,šuOԖbF[zu$MSrՈ=>Xuarlf} #?ՐYV^ T%ScNIM4 ~RV?/kP횮YFI&zEiЎ{Yc׀#}-~ۑң4P7{N4cb'Y-1ncyV\KG؂H5ha獠I?ϥg*%̗O̞^ysF/ma7O?/rzce){Fucjk]mO9UoyҏgoppwI\r켎J7 wj_P֧l22۾e$r2GSʹCuބF+k]]Okbieי9*㊔ؿJ8JKF&K:UhNO4Ry-Qꖅ{sەm #mI8:Ig_ vѯQt^\2"/z1#XgiT]ƎmKHC7ncX@D:#N<Ƣ-8=F6{zf"FlsU_pF%܂KU ]@ozk8E97Ny妛; kk[iZW]mKxXdW?{ⶔ}Ģ|5XJU+L&m<㐷Ʌ!y듌vYʵJ>ۿܤoKIZG`l*޹;x 2ho*pUM$qıƭ10zsh+e)T>Rܮq*'3]toRɭIf?WA[w*øTAFt.!*G5X9?ZΕժԞ4aym{}EHS'trIve5w~dDs 1bKy60eeDF=xLU%%.TօJ.o w̙fmeTM+*L;+*ǃDžߨdbr+ʜ\1&9F͝swu'|åilLcZKڕ!QYa~κcVRmtJ&|kE qq$g$czuc&[s%MM=[؎,͸'cjF5CVRcq, 4&Oӿ)1y9JRk{o`Hǖ#`N8={g/gR'RINKM5#Z&e*ܪ^5*rSM=O0} nw䁻9◳oy?OiO{w {I'k̫.Fб#a'Rȩ#%OGg*mS~}u}Ĭmwz SiI2#Gyh] vB덫p}~"w7Oܵ{rض$ kdRfPdy~rVOh8˕WI(6&HӶٶ={VΪ֦Nw}cSI݌Ҳ-Fn59mv]FE0† qsU^H7:ATs[KoІݘ=\Щ+}C%|#/}hoRc W4Tk r3YN#{ܒPS ͈Is aA=<23sr2WNQmAvV>/q+Ε8t.I\}k3ܿ89+yjT[;2ݵT$Nu˙m|fGW3\呕l= Enx-޺j`;~dXF%)Q5ʖzNPOy8KÖkE(>.4b#[b{K8gRq$}((iy.;!>yTg=3m*ҫӖZV"u>gi޴kU8ԩMm7r;i%9T2.9#o~|mqR}XQ]dp4xBH|-8? .q،4TwH$ {c0EfBXoA1kk4țFD~Sʊ*GRc(cOoNUVH;I'iNjW?M|w:j`5ѽuu&<~5M 603ֻ-8v켶J/i(ǭ/|V>T*FwcK[oWvkW2b1Ў1cOZ!:W`v0[~Y&7c\ NRO4K?>"Yb6HEb(JZGvֲ0Ti:jjCmeskm ^`fo c^ҍI.i[Msp/Y_&Nٕp;2#:ں:J2uyF]5В &E.\\Z4)F ]Tùgo[FhZs,BD<.Ii$/ *(BTCvV0(ڐI8}j*ӧ7g߯s>yE'tRY,*4W·ial T'n_eٞS挡~_7N[{ ^Cܭ- $2\Ebp>^{tWQxӡ 'gS[-Sů[*4L}X\4[ۿk+}^j28Y|P}e>fr8< dQF]\F.7ml+򼽬#An3ҳqRNPNm뿥κtWu# '^oI9 rGլy#R7K-}ӦG=H~{y?2k|/2ooB8^'oFsJ]L"Y`>j)ƌGIzlrS >A\~e5p˩U[VKl3ҝ ?q߭>XUS]ns[&IoIi;W}cL-9rIH|VI>a}nҹiVu-eSWkF7s[l ?_S]rn[%5i]_[0JV+ekv+3XVN1V]/K{2J8]+n[S2J]zbFz7ɶ5 `zn:VStjJ:ʔI+mr6 ؍qʐv84TIo?1ӝ5߽ t~;p0r2{tG,Vbdъس"1pL] nv瞕Nrb#IuKfAi=WUFxpG?,U%8j,BY[M<2d1{l=v=kjFW%OPoLӰ8.)$qj4ChRVX&Py=zV1uNyhO6Z}]\J{RFL vvE*|OQszGnLy<;s>nsx+nog(Z_M<;'.$frM7e\23zЬ^bRl]àRv 'p_܀0Aֽjx5\ODiOT\P-̬n*s )ik5꜓wmđ8{". OJƦ*ӽ45ҽ<خIVe2qϡ0ITO[ŽwZ!9=MU:1UV*59j?uDLk2hv2qMLcNP~>ʷ(Z/̰K}H|2V*Zܿ#β4A]F>L.qwGޓz"E6= \ma@''9cڊ']֧MyY-r:GTW-6NF*[z%&ѶB̪[ӷoI:xBtzcu/.6eTAqEk}4*y=K46оYn?}>ھԸJ2n;hX5b8.r^=55?w6{jJ,E4~cB$+/&my#ەRQ:zyAl$ v#݆=3ںӍYZ.leLEnHJIYPp M>C㷷8q)^Oi^Js[M>;WRcY&U3YShOo>J50kU׸p#a˒_~U 'mmIe^q_oαQtc9hi.Vӗ[[g$2ͷGA֜]HٿL6"c=IbediA S9ޢ5M_: 6m_JmGns;#y{kFiNTF1vMs;Jad=;N.[?4{p^Y\FB8KB0GͺR Gb}:=5iӣZWIy9dtl㌐>iB-j*z~sc;5CQʪEXLeQ (E&aNMq!y<[,: An]2:{Y[QFpGFtNѲyr6>PIN+:m4g*s~cPqG*۔lcފ4E*jQB>X]Y8 ȧ њu ޾bmf ~?J5ݚ~biF̲ډig1vg}3+7NnY/e܂u={}Aoh/#IF׵ķY/6fݵ*jFҭ?ke,̍ aǃӭU7m4SWszdMLj[[o,u=:^QnZth鶿e5 p?AR qѿ*2FeBIܙ郎z_l4cϔky%,HdX$ڪF}QL5"XԲkv:z{y%lUd-{'NxE(Ԗ"2pvF"2IitEX4kǙ69¹)QKUՎU+AF4guz,-0Pzq+S۹qui bO#q+|V^줣cjR֟`L$ 4,Nnh_\_NlhQəvappWm9F48zsoy4FJʪq?.Oozʚ{y{61 <`+{>搗SB8L#'r?J|Vqd-t \ht7Se6y'%|>+[_34ג7-.8\|x?$tRS[bnYߏj)IGn]}ާⴔaH[ fF\yKIHNQWIhw~aGJUZtgWBT|fW6̆WX]'kG(Q)Mtᜇd\2uFnU8EyDTotN2oީf`݈\jrەWnnwY^!U=3nKȹnI*Aݖav­֬OpV7 цz{H{HNi "(cs])#J9Z[FE+Z*\ ݛDf\0V`׏JhͣEtiBr>V^ڙ֔c$rB)r'_ֳ4s"o<45Qq'N*<ɎX tணF:hr'j _MzV>S:]̬{r֩Տ‡t׹{>c#=TFoQI3 ՚Ff z'ֿLw3dy`\ny dƳMZF2i+3*c2+̣Fq҅RMX#ZQ̭Ad+|/Ri)Kܣuh^]ͻaHe*Rm%#[W8<%Rro\>!3*iOg?3rG5~quVR5*кVB/ˀ5y_*jb-5su)i-=uӠ6܎{+VDܞЅi+G2WN+ˬ.VQ?)'['חZ-+KsJ尬%Վ4Bz1{w="ygSҲ̀en.OJjF)軄ѳxJ*{NXJΤmZaˊBt݂yϧL}+5*IUƌӊRkoqG4Qf)w\>9Re4{B0Cެ2ۤd򲒼sS=s_+h۫Ke1*k1>U&ۢ^ՋNh'Z0Z6i9ou\:1хciO1e߯XsVzؑ[Zd_Jp'dn>H6~Vpє._Q@IE.$;t9ihԧ5#XeoCUmQjR]6eRU%$IvKTɀiO#qZ^ J1vWO>ZԂx#ܷ##nWW'[ax'9ƤSomo"T.'A@۱"#咽F4jsJ*sڷK+Jކ*S!Mٲ݀ӽTiƤ3{Q?'/lt#רڼq+sIq*ҥ?i[aoSU]9i2b>X:qnyd%k4][ 0ҝ:_/{?h,,wGO^N}z)vwo B"ekB/Y fTW*QZM4Сưi0B8B;*K/-H{e\FѲ;TꒇU}a0]O͍.ܹu'gJcbҴe-#^V_!eb7+r}v:1N(tԟVxm-? NpG2e-6VFr⒖6%[X`]~flӽr5RF̨ ʢ!-&m·`We>dC tFIۦQ>y#I݄g CݻRjAMrwq=e?S28CmrwݼsQNZtIPv^}F[Ɠyye—\c뎕.υ9]XLSq۱\hp|ߑu9b4cmws/2v޺0J*r鿚0Ӕ<}>xDbII <ܮ9R{)kmS JI;?'}ȚvOM:1qeH6fmY˖WϹe=VWllY+c=ZZ[9!F#o&FEw0:tʌ%ֲ#ZmuC#.1n$ 82vG]jIC!yasy{ zҢ:5LE:koB<2іp{=qjFTOiM{ZBY9o'k*~VU)J0nDyǢȆ$3 sNU%ȹusEF.;_D)nyo=ǮG~G^je{y.imi;ysyrK ]V8dc;{}iVR4oxʱUAkOb;bQ>uS_c~_d7PfD;F a؃ڶ*4F2枷Zv&[5k,lgP=:*Qi~v5i1n|$~:bҩxz==6 K۠3FmȀO| {V^Τ$7_9ptՕ嵝2)xI 9FqTe|,h,mN;JSywY81 gO\ܳԪ#M4Ḷ;լW*mrOE-Cn-xniRT??!y~3ֶʩ}Ӻ*qԑn3z(ROkZm.6c𭻕\#-q Sym/ȝV;ܖ޻1ܜ5.f|r־F_0mUF0G<:[O!7.99;v֝Hi+鱔 n~dr]ܐ;^Jjϖht՟}Qe(,yRl%zy[͕cvWz}8j-]HTm&S4&*9ϯӌc̥̕*Ym۪EH7o(E=OO^Ā}k:u=I(mb20x9:u܈ӏ3a^yǚE_3'fv>v_{lbfI݈HtW5RQib<>6;T:qj;*<}?1.#dZ;waZP7jZ*K̮"Ck 5 [ *ӒR]C)(I5t:)NhlssM95SWV2Es>{?mSjOOsҧYM:6e-Wr1[FrEIac  :;ⵗ4&r*{/kGDWX;vF$mƦMMFIM|c3 AU#{'469x8v{zf!/ݻ4eFWkB+{vr,-:f*1^I7'{bD$ݴF8QNkX#ޒȹğuTp;{7HD&psD]K"%yhTID+ Fy~fW]_к#R4Ey {O-R>w+`>lWu#$Ѯ-;ŽUvh̏ zgum_VkODwvm_de?_ts+nVmopp;\dE:~)5WXHW?|[RΪ^k^Lw#og$qk0尥^TM=Ȯ',:ݺ_s"5ΩFr/NUf,>},D֑EQ=ZlAyϚjNNlZX I=ͼ/$`,xg$ۥDbLSJ6;HyI~bs#}*9%yJ[}^"OE˹1 JT㥊QԗyluÅww {Oy]#n?pd;m cSotOMPIM($(x}شFq Qٷ#vݝgQoA֚}Rdm 䑦'h]iVCsګ(NZk6` ar[=pӗ6#ZjWer9Kr3az7cirVPy|HND]:q>XFUh!ʳG+R،DT";n2IoUi]yЩ}ylh?c9G/4LN>VJ+[v7F)m7=ӕ_SXx2|K,>X};^}+J[u/uר}vJs8I>"Fy}5Νyso mdde܌RrHcLݺ~͛?gFqRݙWȕx`:YtG^>W%%YlIuqSAx2voܫn` tj/g(Fu3K$p77? (+Og'fŜ3䵜{XS'͆1Y֌#>tɝ9U)VO[u&;l` %mYxF)CZ/SqȄI*FʏjK{LRZ&W2,[yM()]QSvw K]HzcghԾG-d׵2.m1;;;%I}Js3;-2y\I+F+ +'5r{~t vU'w\I Ǘ,{8?Tv)udWnfpy2qRJmJkc(lH|qg' Y-ܝmUi<`??g%R%fj9ƒ#S(^rUtn#y|!?lqN~ˍ_sc|۶gQYC 9i솴И ] yR_"NXTĀ5bHUBV?vqqө7/$A3̬ѻ2qԎپmNt yPnXwc5+XrΞ~CCyfVV_\{gZԖ6s)KWoR8"+csDS8ђOX!m2v,du>קYT6N)Eh +$fL+Bn݈S%.i-JU=6,i f-ߦI=3\b9gWOQso-#\yjOC{q[Tw*Nq[m[d&@ sҳQ}{*w&H[vª?29a){9\B @ͱgn߮Ob;S(ʫG<ԍogiV5hg>XJSI6ZQLX(34q?J9i¥Zy6aHI&  dMȚ|X)6Uk3<`㿵rɺN9SExp|b+ӌ:5Zsb2(,<\;+J\[Kxk)t 5S3Ub*sX?̉B^TZC3>! ؒ6;x;TQM7J(iCF͸U ׷ZKy+BS~K@y8ԍQ0$q^޸7ߝӣJVj50K"6m_j_-8YͫJ| )VPzU?lm+za ;V5UUG>rԌiB:~xxw'  F=V25Q=z0m|*Li;pzBcOGLG˫.b(e]UyI)SM$,[Cb9N =ETGWu s*%Hǖ\]{js2T+JPdImcEg_-Qs89 ]tU}Uѥy?[̍$? F^n})VrFI%[A+{]qraҴgkWUݾ>c{[O[ĆCpC3N;UGm]@bVMmu1aa a\6?t#FT9on<-Zc躖2nIդ,݃Nc\O 'Ԋ$fdmǴ?ׇVc܌Lc nUD i4a~bs瞹Ni8N08TNz-][v^?L=>H($3}WsθƻegZ+L|g9ďjXrR^tނђec,"??BQ9[]Za,6*Nwqڝn^]Q _1`W̌|8kJx~Isb*{?gUob+h&m]ʻS ʽz84JKG{iب:vTDe@;#q_aN\G,ZkBHFE%nhQ_1ﵣ[Y%Y#d )z](nJÐ%Kmfa(-q<֔sty.a 5GUQ ~cQ.(ӭ\`rO!UcUq9Rrz1KB7yvFHIJ)OmbĊޝuryZ, $]JƲcsǾ)IF*+k5Лn˕?.WG\~}9^*1)E77 0G@$^}:2+4CdvE#!`z~GBTkYб2ݟnqfԩ+NX${v昡H-߃y+QJ*e|r-u TMfHx(+KD0B29<'{rg%h b͒-F$=IV~RVo@iy$x}63{}3R[E Hˑ w޹iI8q1j)EI%Ԓ@NZC~VE{vmcfxx5./Cƥ>z_PK3f̍7('-q5MTgF.FykwQh<t=1XTIY3;S i4Ȼw5,^ȸڭzN;ZN<~}4TWѯ>\D-cڒ*v9 =5V*T"1Z$MkXPW#ǡzW/FZ;8ōFU :xrW屍5^%d@NdgfRUw?y17Q_K1oԊh+O-%RvI'?.0!NThTJrm6{p8dV]um*:zGz˖nc]SR+O,FS3W"$_3j5#"@ȉɿtAzP件 +s{N6Q!?*w =+2efw/i(xf T/جUs=o*OiҞ|%]Ţaj:+{&wkemN:۔y]n6\4p[ YUe(>"U){tfds5n9E_S`Ɵ&(ԩhv"9 #Qq8=Gl뷗Iב-OgvLʳC 23m\0`6`7|TBIILiJ4'wנ崙|D_.zueݎJ \#iQ´IG" c3tV:hUNm'Fs!Y۔UeIgGZjWrxjZM+jf5VWI~߯cSߒk?yK0p$`F01SZ3K),Ƭ+, x'폥].Jk?ƵjGwcl7uY&ċ8✨Uۡ !RWw6[o7g>]v9LgTS&U̙`ѷ&ቑWbg[JoCyVH[m"I +7qOJ>휕ܚ>3\ecB3ʎUxY&:B rbcS'JZ5)SvOBA#yYCMuӧ'M>fܸͪҕ() 8JNr\H]:܌5rӓvȣrJ/t P:F[89n>q8uѩ-ڷkN)6y;U@^Hi:8RU'ȍ9I^CfM{h_>FjEaoGF,,{Mp*cђ\9Y~Pːv z+GW:QKAU-٣ؒǻ;W{ hW-qO#2~l9s(63 :8ԞLߡ4q?5ܹT39J.m"kFxmHX8Gm˪VyT^\Ǚp1VMWR~nzkݤKm0߆\S-Y+]Rj~֧/aI1/U* n;gڦ4{Oh^fI=lCgd(i9]jSRv3НeE*u+'b>ҵRUiSqKr (X ,)S>RCF]vwt-OSU&ކrG/g6IxuhnvCr' _:4;tGm#-,`0n1D%(uRT4f/7 }:sʦ!pY"g,ѷyk*U*r\mBh՞+-՜S:Ԛ_!;ϺǏÚ.=nY$%I60,jsJ1mwTe@2~Ptw>*8 uJZ,`-[ЫIcs,(8ʛwL%yh~_ܯf[̀nh% &1q\NGz|ʗɰ:e=:溩VT(I7ˮϩ)Eh.ZYc#:íe*ʬEj'D[vtF2nrw1;;~CftK8jʌ'q\Q&iNNls:[m> u2Afm -w)ڹo8k2R_K=NRdD%3co]s8*n iQ[^$q̠hcTqZ-:KFrJĦHZh˪."c;G{O,eaaηjByHRzcXJwjseoԑ#pFߗrW?h/im_L3+GF,O|088Teލt84ʥKc[{zW+%kMQSM;uRk]F}3OBG5*u%+.t`?k\mGuy2Y OZƵU5kΜh}EݑQ$4K&Nx9ٷ-8)۞նn:W4tG)J.c{Q}6nrW$c?/e)ߕ[A50n%DO-bMd3^s' =jTWo#YbXwdF#leHnr9놶U=m?NZqMMK}|,GמjF}ڏ˩ySnMki%bʧ n*Z}5g+[B #,QG/܎+qwO*[Aoɉ͓&H#T5)ۙr|qB l|>UXCXiF.+si#NF* b|#9*ZMuXZyZZ@-$V_#䃜}+KݗaUʖi$ITIffv;u:ZTS㧚$wyǡ<`ުkҊTtLDuo[k8!Ʊ͖s\ q3 ⊕Y6k]mk&\{>޾d6m#,{iV*HB;0Tt<e{/!0]ګE2yH[;A~?\sut+G-%p% 緭Gmhʭ(U$XƁcݟN_G4Ju++op_3-NTY;Em8ӎ!y*щMFpgNɭ|:q$# ~m zڲdp~KGÔ1ݸ4p\p}+JQ*hY/+TkUolIgNQex^9vc8 3#M:Ҧ*v bD#̽hYl63dlYZ0_SiVyonKZqq$'6\v_$SQ 0)I̥"M.Xd0:OOhsz>WW_MZ@cwHd~ܧZNPG)Ƙխ≚f$2'̠QiJO]SR5iihBə|<#ǯZTWoWc){7Ow$l_cٹ#*O :VZQ]^_cm> VIVʫ3 Tsۯ^}k(j[IF;bUY/S|TqJT:o~zat-y^x-nԝ8=$u}j='*W;by|Բ;7+2IBq;9ү'{y:%*tq-B5cc'NN>)5%̿RT񄖝{fhd3+B&P'p;pA8SމOȞZQ(AGo)UAvD]8v3FZ~^CL[(7OXZs(r+6E.,ʹPw N3یr*vzmW8ib ~)YXL $+c*sN1ڸcn]鯡R6ivɭ$dQrd],pN^FV[(bRzVJhl"[n$=jJ5kmb{z9!v*z4i[m?MUJn.*w0keiڲڟ+m]&UNvQ]-㍹sjI㓃q_jXXͩml9NJrRjZ[eňvq,-6j'=Wy%Y3jp\<n[p(z`#'EuJ Vv3u^ciܭrOv<g.ZqRQՇnw{ ygJG2~I]9jҩ oI9irGJsT(kNሦY-'WYcB^}iFI]//K~hʔ*VLtT[*$zZэ<>uTir1ݜv$3IEU ܆g8 BO[_hk~eP[3"su>_N mY鷝MYJ.pۧ业F*']J5>+ziJ0t2;ymU2m9 }McV4(=u\F y,aIz}J2em$Tvv7/)3[mːp}1*XFˠ#wg3r{kJѩ^+TgO%2K(>==k sVunchE%5.M%U`).]6oFTGx'8lhYNF1=_y~v~Ֆ8KNC Þޣ+=7T(]r!"KmBgN=kQo_?#jҔuۧ$٦vB2U6^@׌}+Jrז7mv#Mn#=ϰWe5Gy嫈q\Z k\4{fhQ=泩~Ge4wK[% &`}1Tnz%_aܠw]BȬ +o3p#qTZZ=U^gmh6ݻp$mVR8NK}J5DCxUbZ7d0E2Is5̻c Uv^yyi7#¬*~˰nf0vLqR8u3JiA{{otIsɆH`dm#7$GsSO7oщEݔثg88bGݍѭDŽj2ݏg/;1Rݸr1Ң_f]z8؊sj->CZ,{ys3*45bW"[ۓ j=hO +ʏQ#H8zJnX9+BNURʹ =M*QSu,Vw7*ہ#MJr3vG nEkb$flqt=kj+߷ciӅ74V6ٻ*KHǭis]ϣ8өY n"`youǾ:DTiՈɫbȳ3yg1Fp;zz~>VQn*eRW=R evl 2{gqҸ[n-'t{z >ܑ_azdcNq\̆z '|C#g$FHt߱5ISW+VWw^9\!WnueކI6asˎ"<{^8j]G,1SX릣Ar-v6ur U5寡ÅcW8RῙj_Z_Fp?1 2wdm*ei_4}wtVExS*}bA<QU&Iy+oa)%`dc9j2׻oN+iF-[J r$a ?:ս]a'Neͽ+;/:텱~(?Rw^D>qng# xm:#̾#x\U Q"=ŗs}c=5̶= 5%pYdVU)"3㞤WOtݭ{~g-:+Ւo2o-i@mqœkRkƥ>]$1ƩhhF 3AZ[.O"s)QF 3_0cd"9WC-$ҢmXA>kv7@OAV+5kcJa F+&NVz錧Qh~ݎ~ٱaHGl^}bh[vDIzssڽ oڄ>f ߈m;Ч'Jte_ؽlϺ8ye?='ֽ~]Wc[OcB*6cnsϊz_Vtӏ#ZV}q;wvB藽+4gcnWJ]IS Trڵ"E-[#_+ܼF>=+9{ڣZ\OQO01玴J/{F.̒Ủȼ*{5Nnk_4iˮY+6=}O֮5}nER:)q:ʲF$]TI1jW!Ip]^*;o'$K]C8]*ҩ~?޺ҸIJfwk9VF6XH ) Tj{Fo="fFfXF\ڿwVu%RJa]R[N:Nu&Mr/BxV͵nsik#dc˻mӶj}ތhْ8qcvy3Er+qݳYTܭu3˜Jg==e>H~Q&WwS=R+#*"Z5|·\wfu)]v2<2Y{Q*ҼHqx UsqϿҥr"2fʂI$MQ{t>⊓|̗(egٍآn^9 '9jVJ9ۧZhWXxj]y-^"](N3acڲjosT2 v=Y{X*$!'yqI?1YԬ"{N md})wQoq"H~Q$C%L4_hG=Zjb[W [GՏEz?ys ~DrGccgn힟zIJ挮ty˂2<>WRwg\$hP tYc=+U#$ߡƄm7bԨ2eG!W|EYB^z+1*-w3pT>VrSG 5p |qaQ'S㗳"4binٕ%cd$)89W'R_34M"ܪ<Σt:u?wש9xZmkC4Šmuy u gR}-zq_$W> ߎU*d: ;5{7l̮]sXԧͭߧ]? VJG51t̾ Xi.m, C緽g|O;Nu xRm|E$`֕)K[RigQF]SeFŖ g+:4ԋmmRH1]p .2qމ/ťo՘js]JIfNd~\,{v<3EJԜk[^FzQspiwsmr5g{do|+pA{oqYo rI4C0H[~cZI.( z6XٹO${ti^]f9J].#(Ȅ*<<lvzv8,Edo6fWXg$*3Zte(sU縑&ɕ߿C9yc{$gFu'i'o]G]#˷OQ\~1j 5+mX+ҕENwƥg'q[$xmoeǧQiGbB\)h29 YF5cOvaReY <Ă1!UN$SF4[ԾUe-n1[|@T)qs%CzZrJk ,aZ#/oҴgnшNKFQf&[y9[0tov]\5be,$ vL~mYTXITQ__3Q8ߨշYY˅8,goNJRqOukޚluGo38}eJSy\-vb*9F -05~u1r0zd{Rj)&*>Қ}Hn|]ךtzw_57q[l][,#=cǿz4})K.@KS{@C"Fʥ[n?ZZq{4]4ӹpAff;;{g5^΄eu~/0l@am ʪʐQ8I:--T*tR~?"+[u#Qiv!ˑ*|/=pu8}QMkUbעna-VTsߧOUb(ƜThXUo·Urs\=إ(ΤrZ -m*w '~Qsrʦ2I;i~n8jc3"&{G~fCY7+ԺKϯF"T aw(3r8 S֫&ߗ^\m:'#֕)a^jPQkңI7Yw>9U*mh;8V.^,4dLp7+.d~SjzsoFר V/9/ӵaq뢝_v+ŒT/Rrxٌ#bARszs[s)E5t*/!' 'Qج'RR|Όӗ#js8˹%yȥ_,#n9:~K.dZL8eV˳NHV+ƕΤ^Krv-zڹ]ZіFivIH;n>m$֝Jtcd,Uc\Q*X\5n 5X[ռ!w>ʧҢd9ʩ5AeN?J5ev0Ⱥ}cD6AGdbY1Ofєboڜyw_$1ƾQR2 $qU9VzmO2?*p7H˶DcOjҝ4봿9ӔT&.' R:VjqQ*Mml H`~Yњ%j" Y@!Xd)W9<}(9.k9єo[-] N>ԣ7}XJa[JIđJo!,.w>Y򺉫(_RG^^2Ku$o 2ͱ 2} ֪j)r*}i_hB4vl 9cfѥaoF3po%r)'o> %3/kqgZ{I\RcF񒜶$Y:O i֨.X3wn $vEV`2 qڧ8Y}cLE~k 7uC'ĝT|}jtc'o*5#/eSRlQFd_3 xiԌ9;eN$y Hң|(J]eO);L uegNc3S~J#n0Ie^׭pONT8)JI_k#!$ǔ_~#(V%TNۯB;Q.|'8ֳj!fzu0}An#0yxX#b'+挜eڟ:ِ tϯ5~kiE8] D4m۟5)NczUilZ.639y+(ƌ%k '5֐GaJƜEUi**l&=V5#O8Ƶ騭[U+cepcXaKPEtC%J|wB[Ē*;Ucc^1ʓSxYC˼c4{Vv|c5N9s~̣(Ut[k5:=}F7QX(,[9!q`g+)Fַt)_$_ĭw+L~}N)Z<;v2yI71}pRrӭG$oBm$vfX^MHՀ\?.pzF4ҕ[$\{>%8sFgu/]BL6ϱ:T/m̴c9{)Y $&M|e8>RN\4S槤ra;6@{q8s5ߪcO*zղ}MHل"[_ʶsks8T'zѵ瘧U#p$Z^N<~$ߐKmcރcMwgLR[Smmo9=*eGjgTjKBݷTx-'|t_z֑Y>1ʊvo_R85 I%gNx?λnPG-J kKn,F~\(}v(2{dqJg?[2v>1hwkG/d޷{#*~}/f8<)|%/}]#H{GOGF3}P=ⴧS|6v}lHnio##<=4SF28gu_[Ko!*jpr33!#Ίq:t^RW+m/Op%p GQ]os4+iFO ӏ;`|µRAE-n+&-citi2`~V.RUuE$pŴB|@rs׏ƺ{>V&QwM o#*>a?N).Sqsq>ty CFˌM+~%TIvamWXGc9ӭv(݊cJiWlˑN1Tznkyjj5^bڵ3n!WnNNp=^7#E9vЯquj$eC@^Ij8)ѓ]4hI$*~s k)uFl-E7uD \ȡa=}*#R]JMTI{n͠.y r3A](*+Jqw[Xo-*슽w#Nު<\בqMs`̌ۛ¸'e/Դ*}ʲMH.m.@o;=JTR45O![likңZO~eIFWH#UbVF:F+B>XhLdZZرs3GvU ۲~b=Ҷ+4TE.1VT8'ZjQVWInf"6^Fq)T-M>h(:$F-̛8[]I p\ncu4ȧkCG P^m޲\`p{g[5'ƴ%[۰8< }zըjgRĖ˒cZR2N2[qڊO޻gq#gK6ȣ8uqRpѽLJƪ>}OUG݋N6i5YV#>aqENiZu9T甗('?fܫ2늩JpRN!{z7#VOk|V.*eFU%hԵk%6Uyva9*:rt͞^-ԵT{^j8h|l\"g#ֆlُ_Id.F1?!==*%fȩFqѿG6c&wdl_z%kd5a@U&UV )F;ksrIk؎hR5f5x i?iPIR1ry9{Ts=/sӟre9\(ՕS[Уv毙OB nC\)ƢJ3ܥ,p@cfrӿ֜ޢ2k۱̀;w:ZFͨƥ?߹9IUɵ;x=?*Ԓ4ܩ< f#x9\ǵ)Ԋf*$} !ؾ] /m;bS|B)ũ]]yw]媧ϐzwZO࿞~Ɵ/,%lLN/&T3mܧ:IGsPiEYM/͐x=01X2TUkup]Y?c֮^DW^kM_jЪ퍿w'ʍ`Y^0rkv_"qg$:};[)rغԕ r.>U?sty)=IhH^dXU=NO%KO[1gt}|3I W3GGk)JZ=MqSbk"-$ufm p=yTJRqƴ5Kr;"4[?̐zGcJtI`Jj.}zRg) x<)Ŏ%`PY؟ 6F}l9)֍_D7%ycfb~0~UrNͨO➝`1O&V6+S84meYAFm"㶕YcVw{۵ ˘HE_--̉mbIxFj+ZDXy7+q7!:{$Չ!xc=-1ګn j%K*\f ^oSs,azJTw7GXҢDU|ֹX^fqk߶"ʣ̊jrV$A=ԌeYr[W7,PBqax e Ws?ֳR/[)rҼ扒4m sz<:!/>!X)Iyy^~~TFT얯Up.Bd`7#c?J(߱ju=kbhUdX1`޲rvH%V`&(fF~xmFx^? .i;0Ơ6ZFjyE;Fbk{+wgB7|+Cӟ_Zid*|[7Ku?4GNO<"+W qżJ7rsԋV*+VR7HgFBgg/{TrҌe\,{msg+>~ecOcʓ܉rZR!{^Q.sj/S[ zBD[`vN)JN7f0ZZSOQ"Q>Բ.#䌀w"(iՌ\k+HZ1*enzg֟jsGTއ[[bđ<2)Y,<-A!I?0irCV*Z+\8Qdke.9ׂ>jeV1䏡yJZ}/Wh<ֵ?wc'Ӝ{URۓ!m:,v3ׁNU"ΏpF*^nUcYՂ@۸hJ3\u*FKNoq%\3)<}>SN7 aR-D6kO0b;폭4eçN07BžSr4]~SonåfdQfUvP#b/w}T}[on0;׷OHG- V\Iݕ=p*lԣ.id\14fFF7c؏ZFN9}im6ʫ,63=Mg]Vk-%mwli~`3tYWC,E8MۛR8xR|nPpj%+ƜngYQw7!}G?(;1Օ8(@EKpc]:å(4{؍,ˋb,$#4'{8|?,БcpdK&R*K>Vʢweo3[bDHV8L d7\}5DaTҜ];&>$"9.VO-Xs[K RNtI >Wos{U{ZqΦK:{~a*N@d>e$gYII %N+\+\cQqSMYkMŞdh>`E@T\8օofq*KߣP#[\s %e=@S;Ѩ{Q=ukB"l5t.rq+ЩשTI>,WP3pʶ#$iFTܚzt#Yg* <̇U=1Trv\J<%DX1NqX1Qp֝9Q!.6̻VI7*-##}\jԌͺe5c.Eg@+g/IӠ8ңŲCp#m]Ŕ)#sQ0eZjo5l}rN}kiʦ)y Hyڸ>NMKӨ#eHogw˞_nIw b P,FG?˥aG{zڎߟVhD/pQUf@8s5JwƝ<hWWlN+FE^G%zVi==F*-H&"U#ҹcw;y5#Zڨu,7FQ0 ^2D' RXz)~7%KwOi HNkVOs#ȭce/D1+{NyCB~L-" $O~~x8 Z%٭#4?#eF쁆]4b.y=(Ib>u>ry^A}ke94(ӍDskF7mBVyޟֽ<= (Tm'a֪C%EFU]95ƬS6ą<ª ss+4FdwCTf2VlwʭU|'3T4*kq ٬  ]@qqS%khs˖w{>5Lȯ+vII$BHSo2hV[p㞠㎵nh|ΘB& |y9ϷZV[isMk[8*y>e$21ВAmS!l|"v,k ͸'?Lp痽5u]m5Y<"\ *YXŒgvɎس0{sڮ1tT:\"_"&qZNOӿ*#:Ty\A,N1\c֔l܍RqvXK2ɐ` 9n8Ӛ|C)0>wO0FOt{mZۑ*2#|,GOD-X1}>QI*2rpx2EM(?htwGs2 sN}[GrZ:a|̈́L˸Dz֎)]ޡJK X% 4$g}S%-#ФJ>ѿ|! :8˘P3GYHR ,bu%RVx[%V+c݅#}:|m$F3Q[ r,+#nlLpy?ZFQnXT+Sr\wlփk5lL}k潌N=c"C7T +:/Nݼ*\5ס-s+^K,Xe gy==G>{6ʈJ "8o2s\wUJVOb`+*$|tv4N3mkܗ͐Bnc9<泣KVwNt;]7L&ܑߧnƶONi?Cioa4kݹyP9<tOTgê҅K qoU78== xZjRf+bi,^>XwmnJ>&I;cx›)ɓj$#mUF>}iF5h~^g%sNxIu~OKqh&< t]1QI9Xx{KBpݐs2Gy*TYkv2:䜕Qʲt~w FH~Ɯ=J}aŭ5I> o1O8Vq$dcZ4}-]\A }W)TZ{}3*ehjw!&8e~t>QiRΑ)$J2sN6r%YPp]%W;6Ǚ<1&*F]{Qmy[+'QR98V8Aӊd :Z#d[[2[MLHFxYƤ5?WbȉsJ|hٺ / y5}MSZlxTԜ1qb{yLGsK|\1ۂpqk^VsJxri[]<̞9dy,х]Yі"59ZN*J2S軮w PAoqdb1?Ng+ا1}zxB9YG-I$Jˎ1UO0nk6){=_Wа?cĊc}21]P8X:0j]տ5܄DZX*FG?mFU!%#RmO2O)Rdj{jS_53MŮ䉱G_^Z)>+]hբ>-sgm N}wSةb$YRfJ%2\dO[QR}]0 6$a)xG'ֽNZp~ZXRUWD z~|Јʧ,pakĞ^YF;'8ۊҗ24Rb^'-F%?;|8+r2O7;_yFn$g GBs*QXǑ!ZUG۹F%Cz\5W>)Qm[ثA$Ӡc_ WN+Ri*M&ؖ 0[O([O_͐ܖh$2/ru"QTsqPyB5Vl0g>˖R'UD#;؛cSzYK}(E,iZfMܠp*9*2,vob[y!R20vR2p5/-Dve/lW\%c!LtܸiAHt-?"rZ:܅ mY!pğ:p\TeʬMgԧyrt. Fzu6RRʱκXؓp9{涗,$#OAn"c^=3ֲZ2=6E]t"{st&Uqm6p<˯rʤTM'nT4U0U`WqݿNJލ:ӻ).Ud/g 1/H=O=]ӏ)VI422&iP[x*z'sZBNٺqQNv\-QN/?T0UGuo$gFݣ\y Ɂ8y}iF~]MK=Rb%T\OQg>iҍKlko&p7)lk9Sg*Ot- f wHrrLҭJtjB[vmWvqu~=:W?-}[Zkmۼf`Y[\+ddG*߭e%~%J1M]6p<[t ҳN*{Z>]N-9[vjxZ?Xn70aHVHTXTvH AϻV>ʤou.Mm<0m7-a+ǟːIq~$cQRPkW۠쀄>SUMhuzE4r' &k? Ǯ`Z2rʂq|'bQ$-638]xjKyΗΏm>1#lc@N:z:Ɲ8ӦLVrͻmѕU~88v3Qn~o+ *Fc.ƥ:ΤD:0P7 6{?J~ЫxzXL$66rgMJ7jku!;hN!!awc횈oSrEepmGlZ8O=N?LfNKK>8˄W\n_W7Lx)Y![n AaT*Ҋ1h)`JSUUׯF2[S,y71wQ[3qҲhܓ.EF?,O3 geR)V8WvqQ([m%f8`[9'y?vU-ӎ89~cVሌg#oWIM4PFk:]'^Q~d镇y;Z8Û4h{6^+A/pXVm~=Rr{i*J%M]v:x%nw) 0WN7mK-9 ʡc Z6 vӡj''OGz^[_RVyk=zvʦUJqqkXtՙQݟbr FrU\y~ a$I3IJ˹9vSYFRoЧ({v+oo'p,0q #ק,v#GrB/ij7N7}]d&?1qϦjSi3u# rn<%~~~Q{SkqӝWdzߣ#ibdk1]KW9>Ƴt /AKZ_r9 QEo1bVP:qXU%Q(%eC]HXf I!s}IS)7ӹz[G,GRU7< [$zҢ.^ɽ/gMExFyڪW6GOΉ.6ȿ <WR8Z_М=jq%VI'm6ݻBP?u8TxZ|Ym䍈eGH=>4߉iKKN`W؊#) C}+j>Wr5%+?Я$e1^abɳ^@#88⣖{t*4mزʲw|ӆ^>|޲j[o E^wi%Phn#Ym e?-=l$94FaaaR+D ^*NOj]쪣gM9,4⮻iyb$6z:mayvƾZ7$0 NjvOo=_lm,=8R]OI?SOR1K3 *ӧ-In%V@u\>x>c"RʑMmQt;RD~!-^7>>hn6qӞM:rKB[=媷Ji뮚X >D~B#d/$`={֊家Dg rsXjFel~Q&UQYr}5?y[m܆&urdy7:Tvy\ƎQJ22iNğckVYfi6#W;l'ߢ9*h>"SWmjkhHo%0qv>ƻ+Qq~svJPm5/&Oi~h^35:th~Ndflʭv7 yls}+)E84f _''Znռcwvn'B0džV##4k뾖7R"b[ۤQ4Wl 2¬TӶ9JR/ӎgM6as+ X`ZF :ͫ'ͧ*SSIe9jeo38{+HJU*-uzjzXx%dBDJ͞5Nm9%('0O{Y^5dd&tۃ\ܵ-|-Gs=ln\6HAֳ?KrW"-?,ӑ}r^:rum}/sH„R)m]aCHN>9+)OV"U+I$eJ*>^W;֕*J:ZkZO-Ŵ7htT`sװAY&_Jk8jbU I8$tN2C>oV!q4nw_˕;4{=x^gc.]؞Ky KO1b9N }'w(5z]/tO٭޻n̕RiyXP)G^3羨Thت+9Y.<Y6`AHyVVԣvީedGۄnቆ21c>8Wo]6ESh9sr?;y ,B$gCgZNu//4Yt2"V;u1zэj WzRU)|23&}c<⊲oc8yדHFCnX$}H'Q*ܩ Lq_Yt_I%WԷnַȹV 3lsWi"읺(UvU*3Moc=\)k;wwI"KKY bVhy +*iTd+/6OmmjW˕[oAcy]uH^ّ_J4=9>{T'k'ԪĺȻYmݞ"쥬ԛl崖(Xcmc:W4SemlϯNk[BXs Y#v76'{{cD'(/_>TQo21o]b( IW?:iG_-Z8Nt4嶹1$RnqЎY䌢;״ݷ]W虠k@W m*ۖ +-tߕ!N/\]Vv"s>' 4بՍM~^>օUcӂɦ]s2)e˞}qV{Gv3b{8uhK;1i ש,:tssɵY[AMe]4S.OI 5qrJ:F*{10*Qj͵F{pD<ǹR{RhJkMUng{ƶH|ŷR;|tYJ4{=c)|O۔3Fv sz}{['OJ6`Qp8PǙF3e!d>dErʓWv9N]̌SJDSlNѬh|sC(ed54VC]{T^H]$nMj4VCgKأ_(ݻڹr+X8ku'kh $Y٢BiWv=Y_ *TOIuЅරY\͹cذ =:Ҧ9k&o/ReJ-=Y<~Moc89]QNqkU~q1rW$P9_ڭ8Q2ʿ\13ӌ{0R/N ]/ɞS;Y"%|V͑8Ee(k(*[GFx!H}O<nQ-8zTDk lCir8J2\kR8Zk:)v>Q}Wr.[>,>O-m0f3,y]ʼ$p1ҹ+Jr~=#mwr̻U['*q~+}NmYͿrn)?{:ʻ#MTs:G5t-cp ŒQE*/=vZwhD`E0]ˍ:ѧ輿̵ΑEH۶ytn:5te)_s^,!a*=JU/$Z*VQymuȼf殛zC^TyuB2RZ4E˸]z\;e=ί +:hȩU[v@C;3qG??]SRT)%i ӯ랢LvFYdeeRycԗCm*}XQɒ6p.6B/<nko:KFsֽ MǕ;-39RNm:%NV˾b{b;v 6f)Uu1S/a`:>xg% ȿ*ʛNy(>:[l4Hx+XK$m-ŸT+v2RV8jX?x=YiX^ۗڵ̷WDl*ݕcXj9T1nHsi2?e(NV*9G5^\U>HY$.͋eOf8󩔟.2jfO%eln3?&m#._#6Fe&n!n޹8]HLȷ9(~^3w9jI+/ 3G1qe^Vd7{DĉvٵL=i#3+(jҠ";tv KsPlJ.: dKe~r?qʴ1,~ŃufgŹA-UYrT}qj*VLFJ{f_*s=8g]٩:kM4<'#Ʀ5bc?xKdJe^)T]JZ-_C$D.\f+'sjs@DK!- b9g-eROz VB{LFFfQZq>k*E+G Eo]ۮ^]zҼ؜2nUCv ˟*XNQn.b[Ч&Ϙ>l37x8b>18ۿBxy#0Ǟké|שrZt7ɵSx¤)4/ЉR(Hr-Ϩ#9UeNI9_Չӹ*ZEtaa~m88~UZZ?:N08~]3HR`89\mwΨ*o}/ϔ}b7+nPm2}9?u#EǻSnE)FVw 9Czҵ*:Гz>Z\qVll7`?>*ҧkO>u$ßX6L9^x<;zʳ(;i~*5#(_$+\&5ܨ0̓^uFf8ya*v[Z@T*];eȥȝճ=k4_߾_0+EIa.КԣSVJgpmc1$`dv*}RVpojߙɈ[H|,=n| c#RZ-U*5r=Đ,+vP:ϵiRn^N> %,e#+:5W}C=hS] Na7/q5o' (\_1ز)|͎p񟧽E:Qխ|%J13B+6"1o?uYJ*1Z]$nb5-ɬ(§5^eb*ʞ)[bY#3.я1m?Wasm"*['{W*ץ+_ufϮ#wR!N6kD}Ųo8d*FCxO(5R*ߖn!VS)&C0Z/٧HpI/\5~a r{R)Vf$/ @Aa83rE+w˻]95{w (YG޳bԻkoUu=Tyf9L3ѓkhԊvg\06FFw)NXÜ:Q7E/9gA%6ϘIPRGCg+/?^&+9YIy R=<#_"Y}e]7$Tg1<ϝwg';NPhjUY{Hkɋ9m,k>o}0sS*Y-cSn%7){F30 y9sS['4iQu/1 o65̬ٞ=3緥i}oE֥ZҒ&O*&`eeo/#>>tƪtU)G'ېdPª~UojB>Ӗ5Z?tc$pKd6b#p~e>^Uc2^]%66^ qγ#*kU|-;MFHٶ5LF4)rȒGn׎I6*_SszڌiS$VNUjaEFDI3nXq65*JU{k=_吗}Ť-iFydξcQBO}963dyIwc }x^ԦeBSKv#I8W̅XX-n\~YN3#zuKGUv>8wXnflTfz^k?̈$ؒDqx֬QO}LOc%囸M:5#(ݑkKF?ȟyWBο1S}khԌkSN~^Do%8mmv rT*J}} j{Zk?f#ge{u===*Ռb.>ydiɕdUb UO$奿R񧅡'J ;Cٱ{WSFc5M:\7xRY`I}gF95zN=5'ȊX}C$hfr=pMt5kS/gh'}eN3А8㊌E8ԕfpvl:.~Y[s9`d`gcMӽ9NWLLmI:e$3j5=_St~#oF~_o5Ss%' &}ŬM;YzsngkTi{;2D[L+ QJr,>&g*hXYɛo1|#8\FDge4tK}Ŷ6#ں!ȭMv:))r'.->lmxQO-:g֊2cpЭﺿb+f3Y;i!pqG$ԥUhZJ 67ƽWM(zI-\_]/$jfXcx] qܜU4Gޕ7m$Bĕk!ִ唥ꊧxZAwI,ws/vO7]LkXN4FϺ9$).b "Fp9[ҝ>iTUTJtqq,5mYwJ?]54ҎtWtbmWgM8EߝϏ`')sYa{w,R}*. Ʒy<<$I|$m\}x$r*uҜcδ!]DM2Iq޴pmV$[$e4g~k j)F۹s}+W*BIUS抒E bI(|p{2Rbտxڬ#߽e'hiƤg fԚ8o<_0mǀ6~w+YScw4Wb2YHs/~7SidX$ߴf$H;fYVȝhJO/1`gf.TngZJ\uuQFgyu{kZ ?v!J?ˁS%YRsZ$% )$,der>kZ=tF*R|/7eʂ:8#]))B[utbH( 9?N}*c.W-#U#y- |[’B#K+_^@eN}HTXN Fy99tg;ٿȘ\=*E ) ,y'9:R=]My}ӽ&1 \zuۿg[RiŠؒI g!6J1fE=U5IeY~̿3p#'ךO Ru^޽I$.[m31,qF.T2S}#o1~LIrԕΤ$mFm*F:nkXU%:pzm/j!9+m#8Ҧ׶| sZ xfe}qi'O *-ZH<jI\t!F~$iVMWɦ %ş>}y; ҟ;tS暫pi)U_ [,s҈ǖOu89bt7p,jyUWxjt{os4.! ܣ9ZIX\Ov]L!f*߻W^A 2x?v6.hy5vT*q ܼҜzu㽚71*AO'ORcȩ'41m2vܐHyҦ21InW1y?,s*+ͼo ޼vSw4⎽2PyҲv=sߌUcgZXdxF|;Vrm˙jcv[^G-cQ勞Ј3!?;[{5sFRݩNAA(܋S} \'kX񏼖WwKm/9f$0sSӦ?9Xȧ1oƈh({*ӵ9Y*b.c6=G JU-˭˻+0Y(,O>+8RtN rn3ȰR{+E)JVtKs~{$fzS&=YT8v)G+sdnczU 4qZ͵kr.>R?E_->ng**_NYQgyci˯=pp +שϷoATe+Rw{q5 kml;cH9=GtɵS*PܪcJUjkm^X~hIv[-,lۻz5SVaziUD-}qY{9Jv>zkKm؆9ȷef8}0s].h{\hmIf rG)*[]MSM%^O]G37"HNNZJzOW[}]ڙ`Q垄p#i +ʓK(duFYRi 4KTdCPencd|>^:U*(:R2V~}} qV6>4}8CM8!ƞݻKx #nUeڠ p11kiS2uJ6};L}dcg5 [bȣ,ӵ*j=NiN:IE{r@E+rxo1M{kHS:c)Fkb;u.3,gk啬|+rRC4Ys vrӦh_NXZՙ 8x]GY2xfR[40cϡt'4IEt vZ%#֝)&㭷-]\M/$+]ۏROL3SFD3Nt۔_֪T;G VVzK`nE!׿52HYI*r,HIpTՍ9I.V#'=_nx_K͙s$ᥑUvM8;YT/oN4޶L./6<}.nZwr$r +2<WB4/?lѤ'FG:1KK1f Tv1V\rzT{J{8Sj[Ds"sr<~>Ι8JVj˸JF[oWgTq{CHy*á8nT;–-nK\U2~ӱ[ ˹[ $zqkKJuӡiw1n^ɭxsWэeFe%TT_:%.x{e8 dv~9is b/xŁ.dnȿ0?29Izv' yp )?}IWP6>ιVU,IXo+0h,|Kngݻc$8N8G5/c{#YCscfL뜟ώE&4ODItrDaW$z޳Yٕ1!V<.TRkt;Oqe.6+ToB87ư)V;UI7zь"M/V>X 19qӥg)^əԌTT_Hc]^+1ڠc#yd4^5i.SNY|/O"B(YdDT/>Zp"0䶚x ˌ}/=SpaT^HI;s+(+<];kQ׮y2G)]śpqg@8*jRO^{ym7g'N*T5b}r[nY `׏ҹ.u#.ӳE 3D8m;06џ*d)5uծ"@̍74Y=~T)Ԍy^TpT{y2"+yy2IQͱe)G4=xmS17n=)q-kaHO%6Ysn|8 u*8-'KⶉJq#/x4#yw ԫa٫;l[[l.Ѹ*CnG*4 Mg ʤc'<=Pů Y= g~qNQBTkU׭ q󿙁'AY7dQsàU?fnU*SZ{F}fwva{{k8E>RRGy>P.$+{vemysNh[hڶ5yy:u$M K,hHH>z;.xn[y7ߵEh.ݤ*c9%U{>XN*ׯbXyʏ˚HN~*)"#8NTz;KE3nXv yyR/ix{u}<[][ E0c*jWDSQ]Vo'a$pL0*;~}몊hXjF66O Wia޿$'j5ѥsoѣI{N߁"B\)s ncUz=Iºhҩ%mu,}apgsQ]togDʥOuȐĒk@eݶ;vki(wnZ姬c\y?ȻϠ1?[UԑRYX-+^"Ԓ??ΘʲI +Mn\G=kNZjjm*U mm$iM/Y}JֱU0ڣvA"yfwm1GU)Z2ٙSR"EB ޙďqP*mʧ_QmѲww98mk'nrlF9xȮ|S+D,@Mp M)^Ӎ?dЅc>s&sBmO򩊔b1=Ά{hPЇk0%U?#ӚsE+(iDgFsmForTn=2YԨHFҳHsUVn]ЫN -V Y#dڴe-p˅pW Mc(ԩ+7c}S8LDw#p]sӿq7Jӫ+m_&9K⸽9qz[,<9_yZHֲjZ0 JwBp==j$(sKI+;N &9mz%J+ʄbv#i'>a+ض*N7FU*TQRUDO8 ;4 y~Pnqq_z߼O/y-[R0DE*2ϴ:/nN%߲sK?1Vh溚ph|>Sߏ~U#GGkWNrM]xL04r_?ÏoCTkH7O;gMŸ7:rM&n y%$pzg=:}Fsݮ)TJ,VCS$s20֜E|76Iϧ̎xdx1O،f^v}vf|i=,{_|dc|ܖ_VK%o`@vrNqۧZ8x[g-,W1O4e\8dNk?5/WcԌ.w~HKye\sؚ*B.n}NFWufZ Gj|*q}w_ȟm6vc9]QQA7pN}:v*gTF~$5(YA{EQrA9.%YMW'#}:滩.:}(SN:[(#eݹuђ)V:7AmcRA7tF-Eʺ_1AFq\l|?wJ:9YA_&yP5a0ggGNol`[Gd41#ʪd^=y]UװSMԵGH!x߃ZMJ&21raJ2~gm&z ثAwՍKK'ڤIPX>\Te+4+ĀK 9]6*HEAYXY'ɍ<9-&wojq.2.W7N ZEE9TYJ?6V\ o9b:Juߗ^Wiw.ee{E=e6MEA #&fb<ΡI=;WTcD'oޥ+fͼH7N ;y[Q+u.U=w`+&?Ŏ ԻЪ3(z'vX?l\j%vVr=zYth 0<<^IErof%cI.\I'\ӂNWX_nNkoą!I<:sNk^hFKVt7ʻ~_3r;4k#mUD?εS5V9.a2L3~>F8J(UEJ̴v-AlN=vU sTjpwoQO"b/q-d8=x=e)ɷDOo6\617m'>ՔoJj rruTE3|t͡h֣O}GHlE(?׊QTn kJR(M؏P4[EyhpApq즢.QWkKOqv~`w=8]"cuԥz֏%4%oM]01kkngx< 7} Ջ/!kal~L^N@Vޖ"4ܝî! r;+{NJjuV3eME淼Ѥ|}Ҫk\ԩ'% 9Tce2q}J5K]=\,գ+#o;IcD83h4ӹdPN~_j\4tKw\ڴȩn37sNrzq~ڔ_7\Z!ON`0*%ƿW:0O !V4y~{F(i~,>UzqnWo>6g8z*F4>GVԙ7 0FLQۨu,-[ ?ytEv֑-ʱQ} sJWKsTNV0J]Ã~Ң[xTr8Dʖ.߼pUW qQ\ׯ_S8[y[%rY {OUJjMSE{Yo>ԕ.bVVܱGyU"U?rֻ?V:tjn%qphZn\xO m,G[$۴w9"BU#x U:,Z|Ϻ]?(^g58rW&Rܚ-:7vyI!`$sJx|G.зn#yB1V5"~_ORD"ȻY|a<gΤRk ,<*zf3Nz>[j8xfwП-Lۗj(Mz~U*Fg"[E`4?\]7:Rn}/ ӧ|E:*EFH*RVM_u=,:׳zu-AQۈe?)ʫsj1GRuil`C$A 3Fțn<:qOFtVqR<[H5/9hەUGActG pnE$cr9G_I8X rJY;v Z.uH۪-$0|ôQcӒ{XiQs# %!H YoҮ8*|yRQEu릅IJ{zW'%8{W6B5k4@xOjcOH΋kJQ]Ck,G3\ǙNB;F882=c*r5^уe)Tm4V(-v)>tZjoN!{pe#_ cEy^N5KtL`.@Uɺ!pRF8 Sy%ReE֋GM}~`\1]n{\bQ/٭WrCvહ'*?\$+bh=WBp*ʮFܑ1r'o֊$wD6gm3?QRL.N:0[VL?u\kQi9*~Yfv+vYX8k5~uV_BNJYN$vi:K1Sߘ>g0o̙bUE(;[n7D\mWBڭXձnϰLctؙ;LvJk/Yь="+s:F6 }kJ2KB+[ӳ_pFcI&zoFr;+ù4ҽc,=Ohm,!2y3q+[.7,>A+tihS tjILdF#$ Px>TlE6Ҵc֧ͪ].fkinm |(8aR~/_=ѭOoQ}[tv6U8hH9\ZWm^Eq<6Rc,~p@u)SGjp1r<Zk|BLb6Hߜ~F16/(85nĐoewmYvSa\"0knyn71[˓i r3R xƪ' )o˅i,͏9SF=Ygmb!m37AZQd֌g*~/!LybXmx zvHJK?cG觭$)1Gm\C p==Nr߭uڱM6Axp9'N;hʴ}|D=c:̰GCdw9 qi7(k$u/?!YƷ0[Dz2QTu83a*ќVYyze[Dy ^{VPr9F+G[Չ*p<;{kHl zF6w~f1RNX~2r%o?qH"6='9r+9(J;_[=R]:kש^u)u뮗Euu"&U}Xr~n0 EiTUOOJJfON}FY,@<;8Csԍ4K)&ջ="aVFB>ߎpy]Q(۽|pԧ ь][ +Kt6$Xʭ19zbo+-GtiE8߉ I< \MNG͟C:Y)ZwqTKV ZǑọ+XgojD9Vc997Nt#zݶǁ_EN WԖ&2gy{~5ɸ&:9I[Y&eeٛ'q]ќEAשCLUzKȫ[$Ypyjb)SG΍YstF-d$hQsTѓz(ŷb$gs mQ,<Zcrjczy-HJ_= 1Z}I c_Br\4F1:wfpyGi~y pUJU*/S[:2u&ۏMoQXna)O łZѓ&(aiiHueԎ@c%f9:4yxVK¢tXEW A<`s? #W^y8zQj aNahNP})aʥFkZyIRӫ[=o.f&-2v8䟭qbm:i~^ Mӏ3w6$0"}wJ:1/GgY~; uwpT3DN  JKZ8D).^q2cVW q/ZJXJea ]@Y,yJ1 *!qA'{WfJwxTi ImFxMdFT\bM8E[kPr[yܠw'# \|dznv".#zOVb5PLq\:WN*^m{LN&7Ӡc evUl|?{N=(W\=/.6uӗZ%^-brvj1NKCT(/-,Dqo*WLt=<֞"*v:rkwVXF?qHV@NA >GjRQjZە+ߡbB|-Wvq緥s.nWȭ59^ᩘnՠXLl]Tm@#֑C<˒:%~m\Hh~^2zg g$gޮ!TG&7YWJ$H#4jK4>@88'CXj~tZs'Gyr&XI&0풸϶rkjH񘊒-h^ɭQ!7/=1O OT9m=m,Kbѩs'8 7`Nn,DiUqit5S?EݦmXiPmf2AF9=U]BݕBpPl{PHO[F>:nskӾZĻEsߕ(+=Q#jqz#>V p~yXӧz^xw&O%F$卛Gs3CLkJ lWxb@ڥUhG B j1{vWV{X<ȀDu=A #VFBqj8%rv *8Ta߿6婋ՕʰZ^4IxAB #Ic\V)E^?fqrԓiiKRde#>ڷ*1]X_*rWէ%&*.Y`ytKњPifOQj.lĪ${SmE7 m}Θۯ4$V;T|;Or=ٔcEvGoy,t+& 098y8/,^F:NwW}>HMf_976Bn[?cz\xHdhXF=+P=$s$TF^ih[sF5)W k[F\lg$OSXIRQeM=\-8}{g֮?iڋ^o}YB®xp3{ΰTb sj9?Y003>ju.n2-v5)kw̫Ӧ+:)iSR,켄_ٌª# ~[ӧݍ+Q;^K[鲼RI+,T<7Ee ~o32%u|z4[c*3)9AsJ0J:*N40]WdRǟjR4UU-z?ϠFLI33Ыcwέ{;iҭ*_d1-)6yk?\t]^gkuvBtdo"9~e+\ڢ&bNv9>Z1jvB ĵ!2I% f݆:UÝo+Y#Q .pۜn c=JlR_yN1⤿".te.!x=W4*/ѰXx'm xjJ>ITݼL|1ϹF=*7s\Qj5FG[{upn`1Nj-b+ū HyV|$G_[SJlC(߹%Ȫw#'~5It*zҭI5oQ{#,~$egHfvgp:ySU$U*Fch,ɷldwsZʭHP[*7I+ʲ-SNTm)Q/{nM{U K29je=%iēF 1~ٱ#=z[ƌy9o$J`pzTK{m*WEh>.y?v(ǚI=J~гi#X !ҽI6Z22+峜ֺ}ʝG4NK`ȣ}+hZu9EMH|UIYQ*,SM8EK/tʳjr=Ϙ<ȨhSSMy!| o+ j6vW&}&6ݥ Hv>u%GR,y\le,NURWE v<2W sFv|+Zܙ{z3ZP;vҽ{K6hpڶ7er We)(84n.Pwuz{WE:% mRhqŠ)nM aø%[;Sd+h٧rŲ+*}=k5kNKllg9>t{F4S)"9isV?Ư{ЛXPR=U;J>Ż3Y8> ˡ r:|ڷ)ʝ)LHͽ,EqϽsXGRJI06V8=GsJiJ2l˸Df W} Ue[So$b! U'e[wj)rTȂI#qbXp1v E1Hs{Kߴ ={K/}ZNq M$fvYXmeq4 ]_ԩ 78ʉUv۝:uֹ劜1)TrJFEn瞣XOrOs~Ɵ$mgJ1K=-yșUY㯷ֳrq[z! QW fcah탬l)|4}qhєp%UQ+t+4c&c)4; hB]tJZۙqe!kUo7wFK0AjoZVvOۤi 4m\b]0$sM4Fr!h^+r$V]WoʵikgthTnfONfV!>`9B.R~^FRV{39XuSo[ka.V}=:ܯ$&·H!ۑVjK38JNֳ *.&_Z[sUiY7~dM%JROӞUIBe)S¦媶JdnĊ;Or1ǧV.M?P+bu{ArŶ9nb3pv9`:֑TW{jmZ]J\gfLrGZSrE;An!/˻y'CCRUerSt]៘EM.T#Z~qLN C)t㯽k(N]uZ((yr) yc-هls{VԹyԧcR4,PL31]\UGiY[,H+/ʸfp8YFRZ}#Ti_a1B׏j%'kJKk,~n-$`r{sZ9x2M; ";eG99=>*so2ʥ!{@Tq8'N>m|:ZuqRE@e+E:tdb/i-a%]6yfnQLV>3nVx\{BLlhԅ"%G=?;qҟ]GIrFE_εZu#ȶ{,=gOwQ Lb q屐tR{;%/ڝHƝ֫o]ve?0pF3W':KtsT,;q ޓBqj_g5.[#N5wރmS ڭ[hZIŊ7M^KF;lvem$98\=6L%Y=.4Ьe {OҽSQ-*TQ܎IKuspʼi#9YW~VaA^m}$f6D2uQ*9g 旹 RKy#  /#pߏU\j:Qj^ۑJ$tq4XCB6 Yԧg*Smu, fɴ3)ܻ(4FMNmR4VEO:S3|_ZTiεbUe㣶|;9~?NQFZQI.J?U$@L4mG)&xDa$imnvIF~R:sҚr-Z_iW9jbH̻6Fz֬c>XjvF5OZۯoQ6;t\;YEaR5*Rr7@6eAמq5ѽRZ4 Ig[.Fnv.=={+OcS٥gӱFU"5ҡMn v/wMJyy&$YaU${G6?EReNz 4щmWt 9{oG1DFJvRY|ؤ[s94^71_zͦxܙgjż 9*pIzڧN2ŒJOte*9f|ު=WM<<5+LEI:Yơy"O=Xv>\5#V)?vvdQUBq*W*2wbؿ\'-qҳ\>QG;2Ww.,e$m^q1ޮr~KoV9'\^Cc&=ܥ~LrsOEYJ.Fͥ)!F>=뚶Y$Ռd$c3 c7w޶%d^2}v^~b/ȃ\EGٸr{h=TRvv~=>\nEN*Wi~dVKx&я&~c=zFVz4c*;E7ζyۛ#1[ԍ)R*I5*j޽|[a&2|ɶG݌c8zNjS1#x!LQA'NT𵽤g8SHi׺E,~R HszWUrڷr{*1eBB~ZNGz˚jG6iZWݭ:)-s1F3]䔯`q1w%)lfibC#a|h<4m$ v8P6x>߭o KQ8mr)̷ UGs1]|:p}U%J8slv\RVՕxK6EH63,l SNU&29irr8k~~V/cխQ 6?}V1߳n,\Sgd'o?sVjTw*x%N;ح7Ytv/Qd>vNWKMbb;;nd]ۗ+c#:y`{G.mA|$/Gᶕ^x549] f#.k*U'M]A dfWd% #9]х8sӗ2ü,x $~:2HۗmBqu/Ȟ~U9?WRpRTy"Io$rՆHX?i{9Z<2܋ -ܴm2y>Y2޾ז2M+ri.df=\[ՒH”9Uܑ|ɖqw\}XsWT\l?ZNTXx ,7eXc_2O"BNHb֩5F1w[;ԍfRYwg߮:~#/rSNT:w<3w4|6GOQ35(g*2A_5V\Fbyʤ{T[Ȓ.F;SiF<(7ި@MןEƵ:ɩ_NKi:i0.p\ܒԪ~o.15k$^c 8'#ߧT)skORN|ߵJ$~dB2qw=+x2 NU%BI#R̄^A\޺*(Ɨ$ݵ̹jNK0?*fM]\Tl- iٶ3dG~cw+w[yu*4moj@L%/v_8olWG;yZsNK$YnLqjyytKS5)5bE{w3Fs?Lg?ynH%TF{H j8lӛEi*GJQIB\[}*F጑W[xz)8Xgpm>Cy$#1d$ 2z[JRU Wr-peb_7VOj}*&5,FpeJL T8ڝ',%L \p/=uo0*R̔S$3*G~:L~%WW.x,d/zt5Q7f-Yǘ x4K7{|Ip˻!BR4d&&U"n;Z8b&Gs|IF-;GmhQ=x sqW.j̟Sq#&T9yJ2V_? =~P# R̓s=Ӣc.vX9mcdnrySU)O;yapJ~ϔ)֧{-|xVH$쫻RxIGX%'5<6֫=li(}01̯qDSߗdU)r\pAYrIF5+y.cY2`b7zWD%'cXʧmoԉ7/l%D$#F :g5 s[f.%^EA<{ZS,qn~s4W #]O3vrJ6єnXGoe`Ͻ%?fи9ҊF}ERNx3ӧDi:y(ۮ[:[)!^-OOKNXFاq5%1[nGaNh凳өю&WWǛ K14jW<hzkW*`iYq9P܎Aoʜ].^i=qw_3=S",a[qq#߿5U"POc(n-m.V3>Ė4'߰Ȩj|FNÞXcTHڻtNTZIZ OyFWLCߟʇt՝һv߷ȩHZw#_M㎪qUB0\m*r{ wryM;|2nIֶ"*b(զ$ۧE*w5?(i Ԅօ. rcǿONmqrn=C Hp 5&_$ ~UZ+8R).oĴwߍh'$JJ|ф,]Cg9e_ݰ̒/L*aRr*P&-0s29mv O zUN'nOJ-~>RZݕ,T[ @f^ Oc9;t1EdAR3$Y0f[vʧxP)ƌ\Zm+֌Zݺ26l!E\Ȭ[q!Y SꅱFYw>N~R%͡O;;=.{Ҥ+%ΪƥK^FvVb>\pF8u R3oķeLbO=rAgҦnNvea3%ZA8\؟fo=J✕NdkHLMdۏJN2Qb#-nXʬ`s?^՜k+YuIJ8D/&\3*2W*9e%uct2]΂{H&?|ֆ5iOY_О"W + ŷ;sӯ?ʲ&G{t'(ݭ#KΝl<}wAmǗdo<q|ϗ.$j˛mIVi/FGr_=<,{FyW0wJ3cZu){M+fUdT8Ս+\Hj#ko4m$6 OP峹c(}&Uvˍ}?!YGvLd8ܴ) "|$#9~\etnFҚ%If7*g8dgAsqY*݋>RL+ Ȼ Oe)W5#Q}~ JTS] UoWcˬNZy{m,F*p2?<3?YrvԖb2^q!o+`%{KJ;$fdAoڔ}]J˖q{[Ff̍LTܤ7cSgI,˨n!9z^íЛZa=)/jZ1[l:*#H=1NⳒ~εF۠ i#M9ۚ>CrmGAM*pNs*n,eTE)qwqFs7T:G1sv>V0Qkq{yɽ10#sԍ9h܌sBFgRʡOEs89EAr"Kd~gndbGOWTÚƛݚkBxlHʹv2W/RXUG|+dzj=Sot}*WKȹtVqA):F%m料dr]d!nKd@އ(Tc)6O=={Ȫ5Sk*,UV ws*\e\=<;G G̽ss}FJRr &˸ZEpQ)Gm cO_!( ߓWp~f~4cM|H"9HRG8EAҥ8ӊRP ֹVx?iAiʂXig<ҪIrsnj[ظe"mF3t5C*0N -WHȌ.vt9>taN)EwmZim]J[p`sUړFR6iZYmYfM.>g 8cNJTmُH#WV,$sԌyW®dߙ,+؉d]+|}G>QyT,4jE^c,,c+A2\6Bq}ב"݉8-GӞ?AҰF1/6ԅٶ{95?w&8U{V%X Ba*ے+⳨wL|'u] pfXաWSłc+)TӔrtWI2q#0j.ќZhJrG`w|}?Z.juiK裏̊H$hdّ'wZQuS*ם9yGheDA7bqr+98|ȡFj.2[W84kaNEsʲE-Q7+U܋ylztvJ猹d }oԎ|Zo%oݶ+ ;+.iF6.u)=FfWnŽ6rH_z{Gt9e~ey.eaZ?` d{u"GC8ժr7^*4wȪaHb)ѧԕ'u}]Hm-VVY '\9M#I`ݚm]],A=5FpHѧg-}Fy.0du tOg5>X[h6A6fHs8nN%xdv08xXm6y$d래dNO^0\%$݂ HV Ozt}W.̼f!0& I%}+m|`ss۶kogFU/(:1MuaOpyUVª׀O5ӫOIn"J*(f@ۈ*SgEǖQѽ(v3CpI~7F ̡?PGG ]nF0cn3evMvRF44o{LDZ^ "谔dbCzz,aTwqq8k5~hV։,qhﴰާF[jƧk:*ʵ7)&uӪ'Ȳw,W3g Ԃ>ќ*o`jG{4ȸT nsxF SJܳ_DI"F^s_ǏNk35 Yw%W*9a*<{wEF)XITG,Ǚ<=2r|+o*T{,AGM7ڤ8gҽ)F0\IJۓJ[}5ܺ.by?!Yӣ%{U'ZW}} ]R(xJ$t]ot$n,@~;QKvޕHԏ$m.sdɪN*PDvyTc>RFM݉'d!VF,m'sY:t+XZ]iٷNݕ99*d:2ͭ$D_.x²w9r9gRSPk7#7f&cerL$I[r3湣R:ǔQZK~$W,|#7+y=y˚K=ʅE#|yW.TY`߿qȞd[+Zi]q<  v񓃑׃Xڜe rzϦig -512);^~g+B\zʛգaCyUX}ϧ=+SٛGŪki!pqD::MA]u2V" K:MrQdݑ{0FTx'kO5U]ݻ/rڪ? H>laWʸGڷө>\{ce8NqGߵv1%tT3J}kl8 FSQI'-][miv uJ{5/(uWg-|2ͻnvөFXE!Ԕ~|b;*;5;$>cc\ӧ9j9EPIO_1mMr332\*畭k~!uWϴC5Irqں!Oԧ=-ת1(w0n<أmm+ӭۧѕl=GVI#r/?:J,rK Z/Bx+b5ܱ$nZU%4҃ۡ>3kj6qxǾOvL֕.ZyuI+}f,#=:WV4%u58)S=%D;em*{g)ԗj}mme"+[imwyRG_ºcNn9Gtj6E12z}{滰zVMk͓[1I"}+9#A* k:5kts(Uf*pwt]kݍqj֗=#y#@W puNҒ3SVkMI{0RPFqzWJ2dkRiJ-=9)OwtRwIH!Rs q|pУt91;}-7vs{zs5y rnG# +r1=}(Sft jw'J"ԥN1.!uձ4N27|=~^MCEħON-Cyk{WS"F^.qAZjΊu#j27Muj";}j*:4ϵ?"ICBйLd\܁|^};}2U+T.BZ Zݯ nhbUNK]RajJ} /~ɰy|NUy>7XTQ_ccM0rY5-\r+URnt*RG-[$ݵ*2$ՊMm'SBʥHojo%c!o q HI ̊%oИXK2n>f$Fy>)? dƜK|*g6컚D6a&QowR9<\mcp'?x5e/ʎь+[nPITH1a~rʥ%*y$1Xr/ZREu[ ɹ#/l}Ny<?uI]ԍOƑK"'_7!z΢&R9a6r@cnI3EӔZΰԅ]" }2_72#mHqrkEX+mjr"1vo'v,<LG1acysҹBTWVCЍ /4z۰GLN #l(dg>є#[S&RLfhx2;[fTI۾%ˤWy-' 3mp!$qz<Ѝ4 6Zm+WA%ݰW8R˙y4j0[,#HFo%wy)I'mm}ךιaFZ>G;@6~SڽV?jSZTު;",X$FbxJ:lv{;TEѾ2KDѐŃ)nVp`WJu-}w-$)TȪY@ rsڶORoKcnݿt,Ґbv-#7N ]kl"VHV6>܌A[vIrAr+8r =V|6I{8ﮮ[Hi&TC"و9 1>pknH祿hrҴ k3/aӿ*m&=~\:}hH%!9'$d*q:~7捭O*֋Ѯ2el,ʱ,Ol1pw[SmWO]65qw}BKF]=FʫH=~5iӣR1SL?rvYU63*G}6q2W%v?3u=O^L\_R>XVdke q 5ǘ YA<{UԫG}>yBi>̹w%Q6VHIfF] 9MpʌˑovKT)”m및d)H8=3kh|-;5]G-h{;B]?y b6eEP:OӎJ[vJqqr߸[nIvxsǚjV)Q$_3_dP,_q$+u=բסҗ=۸K9LwȳW2=*rݴbcZ~# -fqn=9YE:U%OGKȻ"c5HNKFaw ʟ϶_3uk-ԉF!r2}~QWyԪFUӢ" \A2"n؏JR͢:*Z"!b|Q8UG޲E:ZIIzuB,Y$%OÊגP:biFR~re+-ݺ6J%Ik4k(>_B*խ8b$*Tr}V'̴i "+y{s gJ-ӒK_KBfl64sYTS5otjU;k"[X&\p;;КM.FS sBɽ :3eϼ(ԟ4V}6/QI]mn$`ҽk 6ݻ~0+g*Mmzb(1IM+i,#/?Y~{֒(٥Ԫr:%[ *,I"{Oct KXvH|ϛ IcyzҲe'm?9EF/#-* KnZ^(Ǹʦ*VI5,Pĥ`Fhc ml;Iw5YcndbYUP: 9# w SW/NïbHea#{g85 q՝ T4n{"w|Ƹ|3S)SzZT'5~čg$ ǖQn0v5TOM_ҥ ]-{;HZ'iI\|jUScHbciy?賴Q2rq׎:2>߳| Jړp(T_/-I4jue 0vwvd^>_|Ec?iJmT%̽M74gdPO_XxΌ[C"ME⩽[xQUr9>4R[ң[ٷm:C34asIRO@+FR_tQJji#X~™ fXz_gO3ܣO[!Gyh#R[OY .{ UOrZ\]%nrw7˻gsJ;OQv'>sV=]; `g fN|EL-Hѻ̓I=>C9sqޟ,wT#׸ѺG,rU8\Ł<9FV"1umZ:K c'ʹ@զ!B,9p^֚Y#J0yڶ*QM_U*b+"Z;KYPOLc##K#`n-4U-#vq/=sǹ%FJӎUyU߼!<ϧZTy'mo(I-:Z2fvc+Az[RIi"ܮ.- wj`:by?es*%WEнeՍ)#Bz48+Sjrc@i$svfw}?ZΦUV9m=$:;8ڦNIkYz={EKo6MS dj26<.O}J᭓֩$ЪR]~շj':k9dJU$]nD2gcJI-( FlؿS$ULסzM;X֍F/YJ;dX1\.еF]X`ȭiKkNMEHfH|r~johؘ[?gd vֽm'H]E$rn٘ÿOoMަ 4d(69>zrwvhօ8Ѥ)]ؼ77<Քti]g3]gpZWD~,t%9b[\Jteuh Mm#^ե<:^u$YatX ےG^Qh?>7̕j٢a)^p:i3 hnJ?v}zWeRg45m 0K8]ksE9.nknjL{OuF^CR1c,㝬̛x!)/#HϛaC-c.NOֺ({NmK4r\Dy^OkJi6Kȵ$1=ܙ727Uۡ1s]y7YЧ9YsJߴ[)ޓvDqz쌫kY@nR (>I-LQXu5>_C:`*߾W1ҹ%YYl_ϸI2}W jBeR;u)tݽ'~]e č Hw==#ݿc2̣wr\}:d}y/JzGsRO[n@Dav#}=1\2.kH<Ē*ӏۥg[>emICxw[\͏b1q1 q'=^>G2d$HYh9+4%1*ɷwžl=Ηc?ɗ4i`GM^}*3q}JKbI`̱m5ը'Pnd?j8Ff]R՜:Ì7fG 5,W,=?#VԮHL*T.***]zSէІKiB˿`;[EGR>}15:Jf,S;=,#BY(tVQ.e{TMVnF4)=I/yS&x-cD*:&o%jѥu3cknfO'}^/#ckXN2Q[l?VNn7fL%Z>ZvcATG7ۂ@'oc9S{nitB?+|s&ߓJ*CErDbQɏir睻|c~kmf]B=-ـI7e(F>bqjRy>UGMx26C80:*AWtq;nH<.Lj ͵>=O4hEv2kNmmCm`7+:%NQkhSzhĦ<"ȫRM2CTv q u\+*;T:uB' OQ۶={VtgQOlNQM/zíLr2ݴU9=OIvK47=#F: Ҕ7c8S\`H?sq3I!} r>*tR7_?OBZ䠮ߑ#2$iԣN.NvJ7BR.T)s Ol ;x2O5CIN+^[ש֭R58EBq I&V7 6c?~MmV2oNeԣuRӗ]ۣ19OC&RewZϕ230ps**Knwޕzq6Gw ^ȮMz4cC>hXiD[WhzNI|>^N P?Xq5Uۻ"$W URUmTE+ 5B/cH.rNJSQNUJnP)BuPq gO3+O[_V:hDmay'V*nkERyc5O$s<M8Pz~T^F\#_֤bK F#ʜ=j9rGE[dcQf=O#VΕj^8>")FOEӨ,E$hĕ'sK^ QNSOJwq/-X9O3qݸ` t9V)t&0ϞQxۖ/&N/ԍ:~[^ےIr%\C|?O^){޽:RR۸ȭX\K̻0~5JoXyR{ۨKS#=L~[G彿2)b hVf2HNsZU}uD̿Qmi+*q[ӭ"IS٩sn.d31| ֊û>~JO#"fcHZ5OJ>F-D UzF~4RGpbIՇF3Bit[zMyܻ1I}}j?w]XIG~>H(jE=GY-yܓϸ% K$2G=nuj{թ'N>ӳILG!`ۭƶv;0ߺ#ɀT=OҺ;WfwZ D֬v? |iIGn3I8GQS(˖ieQwzEvT++vcNcQ,D%9z@B]̶݋A;*%jlsm-qg*\ AFPz@$& -6Pǯ>V9`}NR]k{*!*@9890xTOOoe1|vNsb8Swo*^O#aYdzcVJTR).6rڴ:N1"_~9撕H&ZC5لy*a"֑wM*u%݈č$2yA=F1JR]>j0Rd#f^wrMEN4.BqFlGq-c"Á׎Jʣ^GO[i%ʊ,;KrZf_Гk/uͭ]mxMՑPkv@rn#gWEhbjK_-.E&"̬0榤ggt֑MI~(1 -烞3SE=biՍJ*3_zO6!g?( w 淔-i7宩rI!DǵVhdx_Qv8Y$6;z^+ ?x{[[#Һ˹O3pcp7sV*s%}^hHyl(l6arR,[jJq{O{KCYFr6hRfΰ_0o¶O<޺^+i NbЄublۈ19<YIΔ+kS~1}!]֍yRri#rk8Ӛޜbέ:*)RZ- q]YUʎ۞i*ҔotG*ZO~5l16w/N_Ȏ)Ie/e{!"5]#0f1sNLjҜy}JivW̬.OQ[{YTJnX-rVF\A}si)TO+ _.6!d.晚ݤ=:x83U(N-7c*pRțraUnR{ܓiBծdkE/Vi짧[jeRySѢ`ŦF. #@aמrkIKzo OTBYOLܢ8ԫJW%((Ŷlnp==\{Gw*RNCM~VI'*%ߡ б 9J,)vYPSƣh5Y&iR ~)FӖ+іVijɻn<׏ozRCKW%eUjTn\8]Ps;WObtH6>`@*Tkb^4n[D~;Nr{}+8/TjŘmNcUnd|qp8885>-:9=-nE,&ܱs;XI߷.d5%>`i$jnc?K^KMpsHwH|Ў95#'wc:wF"9E6V2&ڈm.:Wj[ea@}y:=,ywd\H6#c0sS% Ɯɫ^Ai^yzi=m ǯLjJ2iiӔcș游n$eV{U#=f[QSdiٍZMT*oLJc1HOUJ\NX{6)Ѿۑ<6+6 zk(smC8xC IOWs[$Ld`s{^0.5̹|[ki.c7V`srqE{)]-HR +*މ!U5 6,0?xev8ƚ瓵B\I?6076OfѦg[ё\ b7R$e`)TU:ߡKT)^)ϒR8Fms|ʦui:jV95- <{{r۷VR˅bIayzu;jއ=Jo$1Mb #ҜmNVӣ)JMigb͜ w.Ƕ)9F[n)KJȞ!_d~?Rʝh/NqȰNK寝&M~\:iNzaN,+}"VS*]'ҴP3* -IzaK#p2<zTэHNZ#N-o#HfX#~VʺeNqV}v"y^$ٰq5n0m?S5!Z"^E[;a=F8_QϯLҌT=E(M`%Ԭj7#(4 оhƚZd<-^U_ֳ|^ZK_[I%ff Usi$b=g{ŌBehvFwl|v%/i.U2jPђLVM}s]Ks(ҩ%?ӵۺ#ǾE U#(;-}M'JKc$jH߷T-Ӧ>ZeʬgSӌUX&P/NQrgc,Ehk.5bTYK<{TהcxiZ<Ҳ[hMNK$vt1F_ݒen@㞜s{VvjO^;SPO.{y-#D\o}N~Z2&DMw|nq0wQژҏ|F`Xv6|dmjT8L.1ؖp'ǟ?A JR3Sz2=/,bO2EY$ɷp}F3ެkF=3Rܚ 6%(H0h5R{0~zbGDXch*c%cITōB]¢T[4q2!6f0ߎ~;ۑ#;[pI0f dh=K9V"iѨU{9IfivW$Mm&0#jye{UW;$XSTy+'un(ػ2r;:gʛl1tÙDy{dfbV#ͲO:ȨW e;JymG+P#U!@[M_eNi+k*ƻ<nxD\%$c).&ςEqB?NuibfQ?>SbZ_R˲}C(ڭ*1=ys˞u9׸Ț6 S~zS.meSZYGUҷι$NөXPv!hͱ۷E<)QX9Z5KmMI#Xq9=gO2؇*o2zlcg?Λyu1EAY;yvKpSVN>'[NmYasL͸PtMiaN<3 cJRH(T$)(b_O-1PTGmq<ݠqZsFWFҕ65LKJѯ2Cqq4T#)_Q%Gr;U1捼Rԙ{YRP66х_\*1叻lR.Ae]spˢ&V+mC%'mv ŲG@}FyNU=_# S=m.l ڡA#a:\jO}>a\-}zt {܅^{DchRr֫At֓Q"l\UG|>N"e-̲"Ϲ2dm+Q}CۨPoF|[zJ žcvsr:.lWh|9}+r78?Ժ*hο+bF-޳՘œ2i%I|v [ϖTl*1-$Pa |zdʑLKՄ9^1.퐼X*6QOoz.O,7r1Z4sJiM+knO}wmjOz#<,ʉSFLck#)%*F0LlWTwe*2濪#xG&y#9iqzclޱ"iM\=Hք]ƿ(X9gu$;T%ZYӡWEJn3o P=qʱM룹#SGEZD1M bTt`}+^ϕXΜµ[BxC yjc*WsS)FT^ੴ K3*m{!sQp8Z'!yce3'򎞟Xb4YsT=mhxFA Y}Uћ{Ԣ{b+PEo dGګ>-эN#N:Y=Z}8 ;vݯd{yFӢ.j9sGjIG y|` djΤwG[[%c'_[XUU<n}Nc|XJ{ke[eknˑ>s޶R<4SȐKu41bM1#Pr:y?7~:B3ikH[ݢɘy$2Uw*AVޫƜ*kgHE$@v\p)ݧngՎ.jI $' j oW%:5kCGdf;<=qWm^Zv4#*XhgszqGJ嗺^Ӕ$}w^)cBCI7x>jҧ+ŕ#ةfQڴeFA? $'5qRiƝ>gv_o}O݆l<+t䔛vKJiu.1Cxg>26:`shǟo.iU"^] iKmla$|;^)s]ViξZ˃"v&ҏB½ 2N27f !cEhW **Kmȵ 3,8p1ߊ%w)V&HL nI}G\Qr/Oz!~̘6cΝkt3JRV[p"D$eRʫ>ka?gmG\R]CO#"`kZOŸl·SJ};$[cݵ8Nj#NUekTRuq[vpO<=zWdiBSwvq{Qa6*yUijcE;L[iZ%/9}kJr'J1Q` Q# UN=j3rOgر. y2~(`Թ[~$2'qUChu{H:dIAur}iSV"vB8_$8iUj]){5sK{(\wO߱RJ7RBY] B-tF_XSH"TK"5+TE=lJd!|۳}=?:*[{'(TRȥ7cmlݺ-҈v 9|~)+&E|V"y7-n(ZˡERw!yE# n*)_k}滽Co%3-?%Sj=QN E}1!Whnh㑏jY4g*ѩG:j*[F_1zFsqҧ'~֤T)w[i`y7\Vjݒ"47o[.b2pSƳ]2u(vI:9JY8|wV2r:SKtd2EP*V;dn[{SqsN2+u۪tw2z2kIN*/WutۤagR2vfߠZ+GtwK 88k2:9wlA,',5F~?,{7-]?R)=vȦ6i6|9=z~U8RnԕhSQ{ &ls-OjR59S2ifD tdu2IZI-Hta*>eVk:xrV:u斢FMs1 zrzvWHu*oUh|Z 9?^G?f SS2M%o%6 I0(={&jB|z2U+Q˳]tَ}61QN0: qׯkiF4⭽;'k5w K6R=;bUiݿqV# ]mynfM{{zVPҍ+Tqab[;}/˷k_-Z4y;.p݁ž6c둞ƲQӏ,7&M{^[h;?tO?k\n}_Q#H#bU]qR6]U8tY'>d&`s0~uW+"h*-ObLB-Cwێ^tRQjVM-MSB\}/|X$9t1EXK=GN RP?N捝gCsUK~5ZH*.ÙEϹ[MGb8 2MoP+yWq^h%yèߧAKo$8M# G=:\SI;t9:P5y4U#ׯtaFgŠ&efOGo{W(ڟV&}k]]7dXRW8 v)ю"RQKveE8nZ+S'45)KK;]Wjv=Zac9IW/5Lq~nwqWɻMT+ԘFqr8V|C2m݆_/cʯINr:WFQw9㈌o ;v}Gr.ķJǙ#Sc)ozj/cl:m;xUVncDS9x z NK[SR}Z."8et16]cִ̤ƫVgčT)S?O~+Us?{F^>r3\ ]TU1-5h 1̎Fk&y9eZ2`ʗw#aɿ!9qZ G}l=M7ʌGȞYO(Q=j:8ԗ7 bEϯZJ*W1ŵaHOU5ZSMȪae{)zg:˚I[c*S#%o'EsteJ+}8N+om}e%+׾=*(Ԙ:>γW-DӋRmc IʝJvZ*4#ʷ͒H^9|J5kUy<i Hd-;m#ry89Qe^:^]YKgPC*9YXc;<~ukVu*WifZ66BÉpP´J՞5 kZY ڡX`L<2kz2_vN,-.WSo@k%NrF3<|{vQ.h.X(r֖!f|/<siSVJ!pWOױnZUu;䥿ADj?ifo:Geq܍IY#UݒVWj#AUY{ܲB2%?3bytsէ"٭H[vAs׏Vqz5W#[kb-bFU+7/>Οͭpc)V|} Xm۷sMc*|R‹X㉤Id?uJURWiJKYw%ݥU*6'SWܨӊ,̲*<ONO5#F"QW>+I-,Q+l6fs~SO[)(iR ;e ncr@檴Z"kK-QN(e~wlrFRPaVDFqǹs#«tc̞BITmFn3$Bv<ѳJ5Zu 0 xr%•J|(z$F$Yw ,b2 t>{uy1V6$FfU2|g#Yi(0ّm4fۏ*6NqIjb)ZFw&&-!'Wnyu=k9)s8TakqC!Đ1gp9@9Zƥ>JrDT® 2h$zH$m)SNՇ^_yISR+]уNұFԝ+)|аm!9vjNK.[ORddv͕l3pA XVQǕSN1tefyŴn3XsE)-3U졭+]/cHvRUMW$ckaFVV\46l" O-'cJ2Wt^+T*0wO[yy$[DeWRW`+דF5=+ZtUI{K*\vU2Y60vH[۝~$S+h$.0qJ1iS˦ՔY֛ifxy{v}?ujiNӫLHV.$gs9b5+v TFbȌm MlwqN_gNoa)o7 -#Tԋ$nͨptӔr Q*X>ҲNt߿MjSԏWYAe#q+yQۓ*umA*>G^rGJ R^a*SnvoJi |.H8EU(ɭrF=c%{+[(ϒ>c$~?cS(pi٭ :r*i[MwoV"[FEHFF-x1]zptB(RjZo>QČxTy޺%/bZ%ק͓OQN[yu˙`1y<+nV rďZNxM[goͱʔkArD+5v6 IQӧb:t5Z-o84kJT'dرmaƜ&3.L|ܟUsQ(Y7sJ6j~2;$KǷ |F]Y9=FskX2M-7~z.Lʧӹ!yò.\6N0 =L>hޝYIQ'kN( 8v$̖I9CNx ՄK*x8=8E[_ͰI:rwk&#.̷nyEJu'f}l_#` OG̒'}]ym dzwD{F*[N6'䬵+qG+YdC>ҫr=7u25vS.l3\\6y+>IAkiBQөTV}\OtmⅢ,(Jt_ڔyhnKk'Km[Xɭ|B*ҥF{E_9n-d[#iYTҎiOlц"kDላ̎6 ;HQ8q[J5/KzZOud3Bvm6]K(L 'q{V*vO빟$.ߞ&m"*\@ݸ= ԩߚב2K[ϣ: ͡_&[XƜӺ}} 'V}|afeF LR1(h[Uƚ$bԗ[ 8Xehd*Q3ӢH>)it쭩RT'i&K'o?0ĀpzԎ+W{y >JiC#72vĎ>1u]yVN2} f FwQ<+2bjF֋kZ8ǚq|Oy$s*nz8xƣTy_?R#~JUлذ cgRvnȆ{`Ѷ້Wy^u#EÜ-8=WmwE d[o>\Rn[7c֥*qQdGw9nN>*T&wZ{?md۬wON6#tv)q"gSM Em*C-–i6=iQg[Еna463G!cFqy\g~4nS` )`==뗖\F%Nt͍u_7#w};~TR*rm_I.-E+~%A?횿rSQ}?n,{D9/;iU6>w&_|g_` K#8,;bGnsTcxyEꖫT5IaQ[/^koG{mzoS OE[ߧ#rt̶KRXmgl~hO, {Jc;0imZz2bXQL9Fj; gOkinCh#nW \ʞ\q^V,*̒@['Wu)lU)ԥw6G2m} O#b)T/^.IӌU-K72liW+{RNϣ[vٙQSoQ e- =O?uׄ|J h)^ݓHX.n?J/iINcz-Kz0-,N#$.v={֑匓ӭ5ÏIh_jDHAlDr)8ENVyTrh.Ԏ+KhIwʾGOɭV ラ9s]-,Ey[I u>z~TckUz%)㑮k|G%6{F:E6?;f b:gqg2R|w9ԧ ]GZ0G*FsOTSC J.Crn-knϠӵ58Μ6Չc_I1oOsQGDF * ;s+e++x)YpݥKdi 6Y~zxI^[#QmjԴx(3g+d^8ml2HnYYYKz{5F5 2*aԔa jq Y|b\ƸUv^ұTA]썩Tj$++EϙDf~Y;XΜg1Uɵ_!`JB[,{g}+q䦭{HY#;(v ojkKei5@#YH~Uj47t,7Z֟ՉnlxUIi7nld 9NqlmSJ1rkEIo/ڱ!8VrPtb>n#c$VjݿV~Tf-[O{}V;`G\vYQM6fE;B6V|F[fMkwNpXP<[q לڔTZNuMd-{XmV12>lqDo(i7R2"Kk,#[{`ǯZUKњb++F׶ԱnKy';Zi>^5IXW .|ە;WarN?3 RrZeVB3FG)S84P޿/CjX^H6S}Aj`esNNZzcJĤY*!yO³(ɑ <"q}vҮ1ھ?U+Z,/5kGq|(߷t a[ CSb>$8Pd)Z_?QN#2.㞤i3R׶-;lB׏jXyKsKN4uV]S\yYn1\08mhJgtm<=H.AݵC^2wcRMIa;O˿FssJQLkB^잻z631Wn>W%|b?k3rsHNҋE~uN\EgX ;+|+gmV- "6b26.]B9dS mnvw rTrėhv+萹}zݕ$bwzsqDSfMttY\2JeTf~<ᔮ24eР-8oו{sT>[Ϯ\nq*X~Z69J SJQ1VV+̝is4?}ލlgK)^qםS*rg >c!TpלW.#M6sT(N;Yo 2W ҏ/uQ>1j v>Buߡ_֩TVK#fwv..zX8 %og2,}-U#9ϸYb)*wSd{Unړ/[랸zc ԟ1o~11v⪲|>zھ}~Fe+;p]ۣOorɹX3dmGnyƪN-kML/XaEiCP}k)/ftP?a-~\K>"3}OL+9*if$erdf]x?O^՗4OtoCH75bf'l[wMY?dw&0f=u$RUFGU<Mֿr./S}iRc˷ݱ)FRu/mɕhe('Ͽ5j((e+FkY96Yk6qLɫ(hCx1*߫=R|+n#STJKmH!]Oa浌jUﯯ>QõU] )+Ʀ_/yY}4-Fx|9~O/ݗ iF44$cf?^9Z~VPzrwbrrc^sZ<'/JZI%n3Olּ]4C18\>L#8CX9d+'aQ)E_7 (718X8JSd^Jtѧ#XVq;l \Gs'8\5C4*Vݓaz1.ӽ~PT<}j~NM)MVAZ]|ؕ|T3CR_orrLl hFnkKQ[< O\z ooJ)'}]8\ɏN96S=ミjXBvz*\)QB^5$3򅏠Ns]2¹FJ-M᳖1nЖoWڲF^A|j˚j*He`Ɍ#NUJ||˯9SZ"1B4sh^v=Hr}tQNy_"xNL&>aNyYǖSvK~t̖i!XW]ۓ\GK捥) FЮ_2dywu;yhSMo[F*Tө{T0L$}`n{׏\(ENV [ycncYf_3\|=~jR3+M_/ԚYFZjװdn7Ȋ~FOwgtNZIE_PEʣ?xqʌ#Q4sѡIǕޠb "yaӏV(˕SPHmKVeU ҎlCV5&hr=K [c)=)”}VrR֛."l 8J1q4}Wo-NҾ]<_4V*~rsxtX\˧8uLP\ wJPUJ:2PM^Y,P*ܵʬXb{g*R"F:FRI݄dP}98֢T纛mF0䋺xv48EK^ԩSUd#kH!E<׀O]{tkŌI:b[nssZJZZԏQiqq5+J5{FhTtZu$wULk;ɨmSں御ur yIx`!O#>ہKF5n_xRϰءcS[#'ON>)OXqjYkf>e۾}kyؙaW<a֡%gT?[ӌMC*W^Cmc7)o|`ϿvPTt)-I^yO_zZTu*)L)(,.@jUZTEF$ɏXܶp(=zRM鿯ߖXb3+6c{q]Isゼc(EikE+ά[ޙ8zsR+MYyE45W)uh٘2~_'ߕmUE7tG~vQ5d.[\z Sz_aTX;9uOqRJWRq֟x[o!' <Âk*wF>څI7O@1"$ {w=qz֕pӥW~gTj)ESN:yO ޜg=}yb9eG5,kxTnO)sF~};T"~fCosx'9S RNgZ2/,䴢0^1t֯ew Q6jǎFH'mp3Rr9ԕ7#"(U̓&F*Y,233ʜ}]=K']rH=O_¹N2kn;Gͷ1UV}lU=ZTN=P%kp\ cUN2ZS4nm[KIǖ4VQNKKj^fv2 QF8m15ZtW@~."ٙYydy{}*8FVΤ(B.nRI^wTe[kHzs^N r˯([[I复$Ӟ>3]59:~dnۭ̋y+߰j;ZT*Sj=aRfW=j>0pΡ# #Aj/q~j|QR,RWn??gwsn79dk墙e_+̠=j2$at}?ȖDtjn.r8=*F]>i?`N!Wic:$ۻ$^qW~YCoa$f 7l_@<*ME#M¥RuYfd1ⴍKh*REۥMy @3e+ɧJT'r孻hےW9TRqvUJ_"9su4!0UGǯ]Fw4YJ6]S) s*kF镜Zh\}c?²g L,:;hK_#bFNp};s4F dw6k62G9'\~ZUisH.L-8EiUUsqUN2RΛ*2 k%xٖ1H#S}:gު)ӓќvX x>Vn8hr~CV,H# ːm]O{ud֗1Y~5|64J#M|i66v.T9kg]9xhfxcd"B3b;wdΪJEKR-\«qៜ|JZ*[6A$* mex1Tr{qՍiT,y)5e;s?1TZ6r`d!O=pҢzNiܮ<Ɯ. \#`N5"ѨXua4l$OtC<4m F<{✥?VEfIˎ<4jIgqzj*5G& r[n<֢^~Ҝ\e$;y8gq廲997{cgvfD$眜q ԞD*pRZ:*ӐH WARS>_}n,2 mns#`Mgͥa^ӽ5o2H'1(_9<{qY¤j]'-Qj_,r:=ˣ ˚SbL?1RO:M Sd" Y6Fڬg\:qIJ.-E3nx}cZRZq@em##yyЪԓQzH䴊hX#GvUL-?ۚ~s7n: *7>ڒQܚTie2r7UqWY;NU3,QͺxRߦt $ryj 3zuSH拋VkAIJ`:c5PĺjiVub$5^N%TH|׆F'MLT:#NG R q=x)T`TWi- n-YL<=?J^Ҝi*tE/!^T6׏^F|=IY)v}̤6+d *̚s$Ӱ.B yhֲeRI[O#Nrmh%-W;W(ӔgsySV üXEIyw|fe)]~UeE7L][qO4nc)F4R؍P:˸&7'#o~Tr*sT=!o['Z^XMTGЯ5ŧ2<2ʱcO^إӫCRvzOK!X: 8JORke%ȡAI-3,<ʊ['P*5VfE\9sG3ǗKd2Ɖ" `p2~aj*_SѥMMy!&"ȉW\U> v+)KJ1Nj%ϻl"m-#95,h٧{.k$%c6c1̯4`9+4mFMr(@|Ȳٔ6pGq89]oNXuNM'u*S*,OU=IJ-k4Vv)"f̪#j='̙ի(j7"euuzd=q=?N4#Fc-"s{_:L^vmz/ϥrS}C N*NkH ?+* R;8z^Z=S鶟vb:Y9ʒ2qǭg7.u{ݻ=m G(>e#;Yi$؜2JJ/g]^EXݾ?,אBZB ێOm8sEI0^)̭o' ow+{gITe4K"I4r2EcLgzUETQ8{ϛk[%۹|Y:8iUf0d8Ua&f#oL|~tUN:1sTft~V=3,R0:9o[-Q?Om?Z.9  u9* %!ME*9cjbFѧ(&C#7L FxZFQ3NSR$X+*mq|$}8>F<ۚIJ. ,)%~lƉGDT?w?eh*ܱ\6Hgg$)Kz>mԎU{K)M(<)ˮՍ8֔Xm\y "͙ ^ZHgfr-.ߍ,ߊtaRtmVaY3׏j]=EK[ȑdg {(WlR3ߌuu is{'"!TgH3.v=*'yl1iӍ~㧚KṶ,\|w8'+^p^{1d5?0zNcw %ᕂכ|V p3\эiSn<찏Wm8U`0?i}tSI-BYlj>b:q펕(өyIy\^׺ 2J+ OQ JQ^[8Ҕީy[k̒Ubm(v:;iBP'wZ#c'k{* kKU[Imqiۙ9m6@"dڪLp23OsU*trvIJBp1Olq[NiGPU(pz5b&v:/漎GTg[싁9<{B" z˖ozs:hi ,i QoH${x\|[z˺kODY <牼tN9Q\xGMSM}ȎM@۲v7}/b7qCO k)Lf!u:Z[0c7C)2VY#bz猐*BQiᒌM]]bdӟZ*Q]XCp'*S]I{Fk6x-+33dc׀3e.y{șaӖ_U2+ֶ2vF88 5}ȩZqkE*$jxU?^GqS̱ <э9z/@wXkv9A ,;{܁DƤ\SץqT/j܊%6VU^vq6o> Vʾ ]nɭ֍:5T;epV-=IWmh݀zڟ4Z>mȭJЌo~ wgtW(+mS+IV*ZzW/k{qJZUcۀgN9nON7pI[b?K4m"l<݇]jJ*b%=Gkv)A6$ 'ā`$zGt>Ya2|ΪrYܱ+hi>o7g Ql茡MrW_QV2d]U~.U1Sk Q!s6c+d`;~9S&ȉNKK;]>tqq#HUOx]IÛ:-z)7 9VlVMaӎ5:is;hdM8 2qwݝ4+=Ry2GG]瞣۶NjڰTR\9.pwdq_cUƳ=t.eu~؊6؏9]=+i_Foj5IX̶Igϧ9(8>K=|m@fY:hLH?9V1&JO _e9% >nۦ:VGiQF$fWvV^?6JtҌdMovoF64m`vg+xJ-U9#I#EEVfء=+^h.uj2}NKUCq )+qR䗺U:N4 HYO-G& p?\rGNJ[u`d3qBIp0{n^FzSڔfy7/iZYzF[, ޛ拻 >ʏj:sҾ|e{;Vr8zuh{ȆyA[v sZҔU5n.Va].7r~cjݟK8r}@[}O1d09_p~_I=|#*4W(T(ɉ;ppp{WDc.g CI$%ee- ]:$gMƩj2שXZYo.4PFN8Nr7s敹ߡTOO1cr|5%qU_k_>e ڢ4N\LeU\n2LRҔhR2U9в\*HpF#洄%NZOR%OFݛ@L$`ҢP s꫽Al7;?33V?2,/O=GlWWu4rM;}vd=UڹJD+CeЬ;{y @.3HT/ERuƵEBOquL nQx={Oh*.3WheBO5?{";}0ڸTLM!iasHe1[JjyY"Try\Z۶,w.p1g*Ny'ud$ذ F\''RfzU*QI_dGk-09Y0~`v9Oh\ʤ#BmrQYk`={ )smJM.qA]#cTV%FjޣbGYSbHVb݁t{cS\YS\7m "-*jY_=3ε7-b(QU0ܵ]-ZJCiʅm5*B1㇦H+X4[|7 dvHqW,i~EEGY'}G,p+w l~RqsTױ^NkA,Ij,e͜s;e.y[o^-dTVUCz$%wƦcy' g>&1ӑU袼4iTwV- x8͸~ T}ua).F6D #eE$npl$xrbo[KiJ1RMͶIcv0X){Ҹ#*O.ҧRK-e8cğ@uUTkBG+YuلGjA*U}*nN |'Z }Endᴙbҗ/"wHkAucԝE cv$=iN4k8Ri3#J]cķlUX7NHmaNg5*3aҵk(qY\r橥+#ˉv.3_=?AS,=j=Z6+[K1i|ءvWVqR9bt3^5 ۽ʕbf}s񿑬hyik;Sߙ8Zfس𪍱'+ێWDE C*t6a9F`pxb^x9FZk2wmPY8iT$>{~BV+7QZ[hI(Qdܥ6zcVuF=$MZmb8NN}cޣߔ&!E{;X.}<WqzW\JHz)ВM7Q,>rl>n99ǭe:t5[~*nO?2U,rVVmUE]c3y>®yyt9#Rm+TI"@yH̪4MX=qOn+ Qz=m>t+JQ^?'DY!݅Pd+ c GnJ [ϱ FPً*ÂN9鎢{W3RKF-K<$gnXlqZFQ/t:jVi(8lyoHUv_\>{~U7Nd9B?P0-1_~5usW=z۷d9 pF8?6^ԩM8=n}WT˙ iR{% }vtXT&X|62.6Z[$f1mf-@y%)Vxj4at]::K$*&( }}18ImCi,5)4nAp%B[Ftm:Кҵ71ӯ֥)Y[VhG.#x>Ⴣc?#ϧC*GD^1ت-LOϰڶi+c.kj,2,KvXy,y?ʹS^z4m;Kq VFC=>šMKΤU+uM]۫Oȍ qy$3:ܖhH2{qܒNߩ!>ho f6vZ$88{* F:r7r_wQ[,K zQֹE7&cUwk`h6a_0/͜=z~Q*4!X8GGիxLl0m3UZq:;_̯<}+>f5*'=qq4hrbV_ OwN~g,_8Tu֯,=(S!Wd|>q2 U {?e^t^iF/E|ZKy wI|1qP)TT)I"U*cۮGkJ46lu9+bӦ|zzHo|]Bˏ/spÜvkjڷnUqtڟCV)5%X|*>oߴvv*׼1X\)'玜W~݊׹WNIRIo_B~ ` VVϖqZʷߡG(S[w"x-*Q>ߵ]J䵎zojO-͖cߡԚҧiYi׵ivopZlbe,R4^_c,UXɏXą?3 < ޸ݎi=]].ͨƌVk^:80:rcU$+(xsKc{Ɯrե-2ʱ2ƾe9 pH9@%*x1[FeZ|[V|UelaO,'ՕI7q _S0כ˯orT*4FI,<J4o~f\_5ʬߣmsǨަT̅B2*wŞ/Yrb xG38SpO[XjodoT>DYyQcӐySWъӴuvI+yB#p=9R{GyZ+?ϸCE.fj dSeS~ΚsK46-QW .5OӁU^&*K4FNͥf㥄Op1&U rOƫY(=[LDZN-}~kȓ"gRFc_j$~L#]}#~8+=%RnBTR@ TDԻ *+JN<;fMoebkkETifxҔQ};WY] ɮtK[qiY+6ZO5ĉQđ퍓0Xqߎ?\SJ'kК${#ݥc|9Y(sJ,uF-hl])8=U$t155tבr#-~:Ȩӊ*sZ{_B7gxTU|v2=t# {NJRM#ru,.|KIy$]MGKIJҶ.ȑ9[feFANϓ-+WnhGw9vhlFsӯӯtB,T>::n-kKUDVa9)ӌg)F~4FU|؟*1ystF5$)Hԕ8hЂXU>!j ƠsΦXsy6%Um_86 s9犥Nz>JܲrVv]fWz|\:dt4)R|r:[qCz֤yP=jSeziT/Ж餹q\yVsjJU#Ew ݙ|0GGq8Xɭ-c;{n֗BvѾYGh=;^"?gSH??!oIq b1ߎ8NKDw6I i>kiU.ipFGyUЛjqeCʳF67b8#vy2kJEF^F) n81)t˹^Zy+-=~l캘I&3+s(Vp#d37pm%~\N:Ej\͢LmK[dF/9LO\v%:j `b$O^dQئo-)eSߡsTԣR+[.Sr}{۠ITڧ>8ҲVyCa1O(M/ńvNP+ P-!-zS׳nWȌGO.]B ~;%F,Ӳ3ԭU%drͿ/-շ,~*8yBM7"D^61';^jR]R~T+ugyEbŎЬ2r23S[ b-5Mr:kvi6Hbg lgZ8-(UqQ*u>V㫚2WHVb_y\ҵ&11SPj:_Iwa( Ў#{]06/Kt,hSq3mVLQcڍE9^vU]6b2IgqҢ_$8JҲO6L[ؘ՘}“ߧJpfSa*s=97tO]|d] 6{XƝ]r_KX%/y KMءhStQs9+5<luY+'\׻획Td -UiTylnߍ}W6c[ 9$r[KqU\}Go}kpztG-8F~7$)GJb<ޤiV_#7FW't!r+S)sYefB.ǷޟTJ][.>ndq̥?C+Xh(ނU+;=1/\ژ8Ո^̧۷֦8~[9r\#I=~Orn]Jt=mЉfAs:b13TKlA|ګ?´sji% 5k>^`y~nogh,*k.Nr}}+b[Bi[vεF<ܫ[E ܨUXxnoWO\f], O5FH'+aD<۷v4J-ŴL8/Ab8Sdc=}~*.R.QZ>yB2cYQg%RN_̮m2`6USjVrV*`b[vJM\ױzٙ;88MD`ޭX "kw8f_kO4k}Km}뜝i9y'e Ji5rOOHLx_^3W};)?On^wNsֺ.mM#( tmy= .?1aI7ynoz)\EAgcye1"\4tcȢ,9;elsNZܚm|,̝ܳGFs%dnZc%nϿ5:*|>Cl\3gk^]Kn8f<U֗5q>^U$hpY1'9J7pTc.b\ce@?^\4xQrB.~SkNTwSkSS_"w*};>C~F?<͐7SXVOV{[KliA,B/9Ӧs:ftU&Iƕe0wN}g*#&:37ڃِ3Iis++Zf7=. _-:Νrzz~g?- ZYWJ'̫d{$)mCNSIJm.qr{F`W5Ec&Hkmc+$2ZG)"u ʗ.*V?.EeUªs 9+9Erek~ ɥpg]L9M>yO)_$'#>݋rwk^IR܅PG<lF>bzz(Wg;8ӕ|Ȟ5UڍF~RU\Zhu#*tҍ ȓ{1KJ}43W>I]2*.ᓜ߯ⴔTeʒI4kQole\:sֹ})^*[/RPyeϿ Ԁ0=]:{diN*JҋMXg_"ɱNߛۥ:K[[=RLɹFU>X+;>_J6n#`kyc`2^Z=g;zR;{hX_ypz qzoغu^X0\H TCߧjIԣ 9AT}tЊ ąvֹe(ԨG{iݰYJz&FEǺYYB>? ZSh6m\d $g2F(aO5rIyh?ncNWlH\#,{vk{^/OE&8JUj( H!U[yy'#k^i;;$G$D3Eo+}oN|-GnjAIe_)y0@A֬эhhw^'p3(i-(>R\<`Wuu//Fsۢ4|F̻mx\V|ɦSm+vˆۜzQzqy[U-*,֌{+4~rQ$o~'=)mhvTC:./b <sj#'IbNFŴ,mmkVM6@o3/i^Ma(Q14%䑳Hm׶>2dVNj_-,1\%wۙ82x­q%c")ƍ1c0@&R{JnVݍ.h_.N8R'NZzs v./+^y Y%EI+SJiT,EV06}htJ%v?w F=zQj")I˦dv^]̥D˔Of۶q0Ԓ@CUV9SSI~k)S%=:dݵ_#fGmG',$a,#z%#8r -~a"=J筅H& Ka#euxw\O9igG{SE7k$,Jz韭T"V#.jݼvM oIbY<*cӎkkGD%fD0w砪Jr]ls҃ eG l|q4㇣(IYk,#=p8ZsG#|>""<W Vs=9u*Tuob0GZ@\:Qw[_R%Z֯V>$~CLjm{z}9џ'*T}X;fdfC#AI_Șū;Q, $;j}:tʔc{MSGmBTw_L+Pu"W T8Q%663;ksQHea*RT U ?kF8_NވѦq?2tb5o!Q^;k)ӊ˗F=\t˱>o"ZL JO[v:(ևR6+6qڶ-,*Gn?֎ZzeY.sFFXTh*29ZۓLN3bafaowZ^δo9T6_Ac`k3͑G9l`WE^3M9y_0 cY4&$Q׏^xNҼ8@$uېNzrzzS 9_(?ʚPnP(?.Uj^ q(Ԓq#$Oܖ>^2qۮNzVьw'{QU}Egl@m͍N*FufVmm\cO58%rSl❺4Ei6 `Jҧy=NFT|\-cܮ3þ3Ҷζ"2OO=ƤE$VRpۻ'J%̹Qʤy}DP|2UVeqҶe/W?w+!l B0y(Ƭ$]YQN*+Η,dc¬  >bmW.WZ.zrVz$WPupgGcѭ>L5GRYYc{sӿPϠ\>{mp۷Olxisrtg^"1N*3D7䷳D~bp:[ELE E+6U[ՑymP&N+{?2O?#4+yu$̌ʕF[ h)sZlXi!8l`ve=SJw2] .Y8`s#_ZBamikn$Bd|C6T6sc~ך[K=ٗr.VF a.C唥tH/$6K}͌F^RG4a 2rnw+.2"Ir?*=x|fܫ+*KVln޻^STR=]B9SXgdq?zN));ϾUtg6q>InӔI d͙[ Ijp3ɬRUց(޳]+O,IV?w$)iY6e*Wѽ{RivQ8:.gy$_ Zbf"i#e9i=As4lv>Y<OiW:hFS$ۿS"Vfw{c֛Q$#OM< 2\>k`nnϥ96iS;5+L'I1B4ܠ>U*/ӯ,-Mؚh|ҺL+ g uz}G4UC8N1m`[gHSPGA{OJA*)GD57+]Ԏ'ziJ|=I-1_~N~aOgFS!aR7fVxEV_na+o(ѩIN2ۛf'Ahn;ZЎF.[ w7p_ʱV3g'TZi\tc,@ۀ h(;;x}4_;c89M-} C xqdVg3MTe=*> qv*ۃڊnpnKK'!wrqcn[2Asso mk}qIڵTغӫ{ho%v#)yO^GbJ[~B-ByF-K(lq yg=JѢ5f:9[zY!y'6/&v,&XC1#o{ t]G[&KQ |r #_WknT+Ndm9'k6RO5U,iZۓ[^VkQx]G>m?52>VU u, b7yyǮFyUJn8ԍL!hЙql \kBg)FW߸Omw+F̬x+:2tp$֌e:aُ#nO_NVS7E%fNV.{/C j1O{hmGi %0 'סEUJ:#)ƒKD]#GN=S*1#i=ѝ=̫q{oݳ.AE\Ӟ+_vPz:4Zxi̖v$ڲ#Gqmge&K|Ȯg8ZKHcGNZ{e;L;74k<c+ݝ }]d;s]4~Z' 31,ۊƹ8m߽)F\ƝZjf:E#;ͻt)JM2FkMc%] 24?CUs[ sdpbmjs6rJOʿةU7|1mN*PqmX哊Z>\]D*`Vs:}*)Ɯ/bpeNݹv w};On8޳2Z*Ȼa"y :5RK#ʲ_J.t6?iMǙ'co-)[.s};ҕ)(B3pr˲iՙN kðdf5%{=:~yVgbY;(澭R8ۿyAk&vSQyУx[Q:WsYܱuOa8卥VPc9;VM.UV.Oݩa+,-rM\e*rP}LF*Wz H<$B ~`x洩mtgRL?$__̻qvDjrj+=BG |O< :ACOvs*ҫQ&m5K6XХ'2^sZ+4= N\&O. YI;6\4)62xu=I!3N|/U)8_D]**Vtn%KR=y9gZmS]մOcNRz--Ե g|wC'(=q)ifʧR`^D$m 0c\gG(4eBThڞAeHmdgvzL1{ϡetH,1ݰ<V6qQanl$iQN3 >O`٭"ME$q(O1/;UFɥ){5oyu rcoOgf*Z哒N/q<1ڨn)ԧg*54ٓ\Y-̐  9?²fWuJY5kWhU>}M\}M3Z,zu$UA8?wq)Дe ,;9xvoN:]^MA XʯXAS:4kǚ{eyPgj~S뚙(2rYbI"9Kdtԝ/i(Omv9'Vu}IJ2%E//oלQ(]B4r(-ze #|zy*J_Or, ̜0v󬹽tR{V`[~G>/=Y\Oa<"Ͽ֎Y5a8j]ȋܣ#UQ߱ѨGs3Or8$eƈ\˕wDfVh>ι;P}=A Ql Ǒ89N60*W;\<+,zsN}xcQ(I4Kr{ LIaq9)sZ*/GbV/, ML{(FsrAQۥ.װߘ^O|?k:$Ւ”{%t2ɑ]'[1̱n+$kF|ⷩv)J 9G98np׷5ҧ8.RDkBϔI*},:0ߢ &C ¶9T:oKVH-wS۸*$?7On+NQ* W*[V@؍Q[?Ó*9kZ0-/y̩,r1_OOkEԺ##wimǎW/+{j]_ejqlҿW#O>Z]ZJJKK-ȼA,H&01:ZUj-~Oܞ_a]ߩߕU^W$FV$Y5-yh/xǷǵLr犱h$K~cg[o2$ynN1Os\ilg.h5eݮr#Wi zڳJ..Of8RMI_KRv8 z##9U:pg'CUU쬯kXqU9rF#NU,}WQc*yqNWy^7'.daOF3 qՓwrvFj++YD:n>eyңR/VrkrKNUm:i]7d咧׹_Sw] XXS걫W#{:s\zb\m.WӟʹU;)eXث+⳩NѺ~5iƽhnn,6"3Hc){IrJxQM,̏+:bH/SE:M|0\0qwWSF9h"ŕ퍆d,6<~ʢ8S$zyˆ3`nw9*QѯQ|i v19zv..z=[TI~憐^+{S4lC ɺf؂xZޞ)GG,pj>aa{hK"|%x8\F'؊uu#3ed³2ssH4niV۷"&Yq`W ?iiZކاBVSz#۩I"yGx(4$oeӾKP$5;Y$\Al NӎHQ*W &tj֌K, ssx<GJ\{֞}:3ƚ բc34jZ0Ԟ^+U6rBS[T#y$-8`3Dn?toN>Th -1SsܫE[?6: ʊ4.UZq鯓$ī9z|u5(FuPNJ}"e`YXnFn:9is\r}=ZoΏr\4>^ҮR]i:r~wXTm'2մ\I"TJ2V]?w$!V0*LgtKF*nYԕh/mrI,NіMJR~-yfWr*r9G99E7k*YSeY&gvⴌQ9mq#W2f=9_AkEhUpͼG='tp8\w90:"vGGFXOqߥLcm(Ufz3ԽoyO.ΡTm/ g== \ܮSz%vGvr.]k/g*Tx|__ZPs?tU^Wj7v"Be #č9=qU(rU]mA*H6RN<[J]Umۏ.5î~c ՛wf^ڜW]#6(r/+9eV|^rF 8UVᙶ^Qƌӟa;9*$HTy^Qע (i  2îsV~Z֣ٙ){v*io,ȶ:Gycc׏ӟSg[U*khJ5^#Y\srݘ¥:&N1HPv`;|ҟS8x|NބnىfE#q`?*m&rQH~\q4埖qQV_iE"mVuHT UTJƷ,s˕HӒ7K8ZP\yn>F:+ӿ4y]7R3,2J~&w @PIrԧSk?W9{۾q^壒&H.<9~JrumeRN]//j܌Q\VZCk’ָ͕۫v~^L9W-iT=k[$[n#1H̀ Ű!a\r|_"ܧ[wopequQ$ѫK6A9v,W_E'Cn2CeU2$tdϚj<~# Z*{7eh$jʊqN+h'%X>M7V2HhY/*9=2hr[V=ȫ`-u/(V;O$5BvT~a}iԭ&QTN;n QYBLXUTLqЃO,.Ǟi*nK^9"VC,cnrs?F<ֆQ*V~W^J}!Ue#n1WM/`׏TU(U}ף1." }ү˻C29r޷1H9%*Pۣhixvvƾcqz{ V/uaj/.GU*MG(s<13*ň-ǩ=p?*3;9-:s9SuKϻ#Hiᕊ]̿pzp:VѭG=5]:R-;Ǻ&-tF6xӜvzwⴌ96fS揳[$G Ω̾b89#WZ<X9&Vie{vӜjS}ӷe@!EF8'{gԊo9yiٻI+z"# ]X|w؃WW}:t8T4'ĐF5" eA;p#m:zPcy=h$ +w1SgjFicj8;_[L660G*F1XڌcFb|LĪ/߃[ԋntBt%_7YdfYFw1<zVԹauEt\)Fܐ9<JrћJRt_9mcLs"Io|_j1)R73?9P7p{g$֑^VF\/fr9]#lvL.3|yohЍ׽oS|#+{{׊RIZDFG,S˝\'QJ=4!3ƻ~`2M9KT;{/[VӄW]O;ֶRzu/u;2)h<ˇ=zqmoN-U$\>#vZѺ;UFu_݂VYfe،ʹg'5mM'SM hcu^+isL%Rq,پI']:|,59IԳvzjEs_5hnx>Jg<תb ۲=1' NNp)ƴ]2UǙt2!oz,jWkLU#5TfƵIa!JG^ܾҝ/vЖ_qeVm7 76qԜsqYF۟wQU?J[8]S,F.Rg%;B$tFV*FKn|?:_>P @yu7#e5hZ}s#POPzu\_^t}S-V1V[$bާuvQi{K4}6瓖W;7ol*cFeN^P|˩iNu?a]^os)Tɺ/捚+@y=q/i/vێ_VlI7 2Q08JT($FhݕnEo<:H͵X}1~TI6 =QoC B/cU۷zg='w' ic`GPpy;$]Hֽ1E6 sUK2IJ8i'Xޫ|{+H*%xZ[M[|ypF2 Zivr{-NN80l;3c9vsS6. 2G2D "'<}1 2s'M8_nd,{Z59\S9].Nz=]ՇD$U nb;Tӏ-ޚjTڧOfV >F*|:{NI;Xh\~c{V59`ՖX4 -^q=qXwr2sKEH';ClsCԛdUc2Pz{XʚJr+JӋ^l=RCwyʿ+çghTpLo>ttz`rLy9WBjqU31xsI.J1NFswcxj4z̙lq¬*%y ~ʹubUj%ro&9[2p*f7đ27O뻿Q$Ml#2wncTͰES#4f+6{TʚlS\ahluHP[N;W-h1%)Gi#73 btqӭr?ŷ렩iI;|I)c.Aen3ޡbJ4uo 9*R:o Ħ UޅIIye'I/ǹ+:!Z}B8m[{c}xSe&㌪TdO{U^۹Iq8\2)])Xb)եF-{y@mb'%hzV5)֗*ө50HVkPfec$: έ] )T).(6堅qQaZBhթ_ Ћ|.qVTتʯ/V5{UIJ9\ikSGuz۫&D#>;c:*{ۡӇM^JֶqHV1R7rO`ycZ*}|^Rqj9`Uv|u=2GZ(_O[Kp'A2yvyFJ4N1Ң6vf  ,wUԡo븣.=Z2S̬p>q󓴌zyM:pr|ҺrĐWT>nO\U.Syֽ-ñ%c"2$Xg_rFﶽ#ZVku^};a: E<zsW*44(r˖W]z`uQo\(^Aa7I<Y^tg^iSwZ;HMtvCcOQ.VRm7"fnbdSRFk3OIi´%RN-~Oͅr V18SVF*(226F8zǵyխQYNRKUdPᲾr|vpsяJ=>G%*qi]?Xݔ4͆&^qLZQj{UFnGtdo!~fv1c&կ1n2[ime~c:ƤOPF ɨVRݽ"Q秫$s_4^k(FH$ksa҂oY$j{:V.SOHϗf|wjT҉NVA夶fulcLU$mOK^e̕<`۶W e^6oNzp{$z W^t~L8~u7=ڏe[>4ϴ*GYRJuNAzJv>ሙxbYXm\sj2ZVKRTl{Ȍʮ"̤*H?Gn)EYYԗ,ҷwL2 q '-~;V敜Tt]t+g B2y#CI-mm53Y* ^rwˈ2~훫To9Tr׷h!kW@URNNNNr88e U:&;xXg[5v"Ό(,2vnzsta*5$_yPDZKb$>k1ڊ yZG˲r$絺hXP&. ltz֔˝ʤ{؊ѡ *1*2,nWD}5tpK``AXӈURTh:{Ӫ(rn_.8\5ϿaӇ%s'~'NQiE*W6Ox9Mr_2HYHS~5+S(>:hօF֏mē/;;n9V/Ȋ؏꛳KNcpM* U~03}bin5<9ֶ-D,C#)c9v9#MGYi~WUU׻U¨%;g@zX{ח#xPi I&Ьi.8=p3iFy9V6x~ȬzLyt'Rn6+nufi|~klɻ1ZqJ keJ1䏼Kt\?5XhEYFmmʢ 4+.1N+*tw{yΜb++,] K0ڣ.z=KRXun6,QyY99+R;pq*\qFX,y3[ɹT~E1Ƿ\\5/w<,ުhCi5oP6q~ַ kygvL>X$7qx>uDc: ͲT2KNpxIxJ3طl|f8+S9#XקFRI5[A&qAu#Fc&7ԙDkveB]3|AYƜ/ьTsR4"yCnSѸ8եPgN4)| 9sʬtA-wT/͐q'?B2oF穥Q7FvU2sߨ(ۻ41Q&jńCli 2F^{Кu{ SM 1-+ܳ~{}+)St}[(FܲQⷆLqeCOt#͇W5ݶSNXHU[z1fTHJY{ Ҷ"8;L1\J:v$2;nFe7*|u&vuABpmGC(SM9on|5gR4V?+s1:]oVPWPJX|-J3Q}=>e4Yͻlrp@?cz69Sk{GUgr+UˢiIAw]H!fKHvl1ῄ۾3uSQSXr)([~aDGeb>m/hS~XuzڵAdDj~BF>֟S_i(F0ZO%H!sp^{g]84 ,e.] +qjB>[BNYO 1 ĆQ=Z/+ջ8d70_qsӮ3].%[FI46;kh'YK0} }{ЌEqRB['ע=*ܨTryrji.ԧ/"ܺ~iiIꍪQXz~Ǧ^Yv(m63=3MJU"x^7~鱜t^øSn7;Δi軠asol6LclJ̫b9FxG̐7 yJ+zٍ&KF~9ӕ:2K}/cN_^ -F[M p2׿zۖB5ܺ-L2r).~VݞQSG]LjRl>u`V8PO@O>jhݱƛ\Y" Ec 6F;cִ׿qJO)r "FneֱOQµXwm"? |;ӯDW:b!"=Hg< pY]U[捇r*%E^[֩ I=uw8%\1߹N@,O'vwI'SN?RWKK#f5!>^23:i϶/,jGϩ+FT"mc2ÎqӞVu(EC׎5{VKGp(6OM*5|YH' USSrUUۡ ڤwn?p9'u#r rF?>UJi"3cߎ}yj%ߡ*]2_!~;|1Q,<\lNcҊF 73+T)bԝg0=hWT!*=_z:|ֳ%ei·019h̿bzR~mR[N7IZt^ ²ǘ9*>NRrM 7( U.1bX~URy]YWBKf !qߜ^}L:L\f<֕y]ҸG+mNysr.ZdKG {4.h-;yE Ǐ8{TH\аaX(?2䞃ߟWMk'ZnjhbR?2;qyF"ݴ:+%6޿q]4tƥ>g^Jn< #?_ҷos*qDV_ݕ_㿶+ݳ:`o}Ek̪6Qק4w{"&U2G`ls\W<ݝiFeٛwp"S s!gQ)>kg'.]㠐/<4Wv!Ẓ,w1ӟ^^JZD㵣yi~Nt9̛_pZwC^miJ]8B)kQ#owoCR9YP:6Fw\2 yxQ6@b𻊮#q@;WZrqGEЫ廍#yqWR^Z=ERrU#*EV}>9>F1-hq[ƲmnGͅtZhgkq6^3y9xܭL:UyeȗeI*DCam+>#VG>JIѲmz2rZN*6T7@NnN}Fl?2 Nǻ'<~UVŽwJqީ6vO}ql4E J=z[n1ÚƍhTﯖ5+٭}wSf}9?*'y%kR}ڑؕ l#=Ϯ?:wiA5mSuR^KQ0/j''20񌩸٧^CT`y6?f*6r+9{;rF>m֋㶬 Qn|8\:7ܿzFNӕ}O+HԋgH|22{c~jI{];~iҩFiIt'َBcd$c8ϭuWO:m_-/ {ޢ!\W Ӑ=VN:D%]w,mhOq%kܝ2>nd6Vc>ݸ |g'8cS62s{j*؊m ",hW166F o//>^ib~#?!i"6X-8tЩN24[;F=}qYT(F :t!E];t _RIlU%8i'kQW;!hE00I$X\=.W wF.iu#yQx#:uhW%kvz=IZO"G22[ c3뫧N/:o-FP}Fe]NcyH84z42ݜw}}>V,׿AEY=;zu_J<˖J[h_eMګlwsQN<9b8ogX@[Xz6G۷*g|? _K07LTn'$Y7x>9(E|cR#I İ%dg9\㟯jS).vuGN4-[hY2={F7aŒcFZn@ח|˷fBq\S|RԣE-ÍD- ZPqzyiɿ//BԏXoa읞S7@=㞕Q+Ԗ/9QtgPQU a=ƅݵ^g|-5oe5`O&[2?i't3lLc,;VMň\#D7oZSӲvfM?IXĄp@@sDcMT6!vG ^R;)e YQ(qo2enIu"Hq`!g{$RF66L^e8y(cNxNNQqrz*ꪒV?'$V%d-ZNRwW95#NpW6v~'$Cҳ*N.QF:|њr}I&\;GsRE8{ڣRFrw6Hۻ ӯSJzU8Vv-iEǖfI#n?UӍ'>e&%7 VfbNlcN5*TM.ebkԉas?[mpQ+o^䑤M-nُx =8RQTEAkGR\!"fXt }灏^|u-(kgL",ϲ8ܸۜ#UʤU=7:iJy]#$՘azc_j1涗2/oU]ҿm m^F#Xv`sKF.]nqE7ԑdy!e 1"=Is(ŷ֧\cO|אW/1݃ޣߩM]TO׿9a'O`ѩ)J$Lqe.YIH sĨFf 'N0)J.Try}]5yegǞJKCǧҍ>ﰁ"ixf*wcMi/m iF}mh/.UC|8?8}t]?⹽53 1kj.5%nҫOK2o-68ǹsߥiuu7e V|U˓p7`zrxǠJrueFWROЗ˷ReHljQU\JF10%#;ߵLek]LxُQ<)8giNrob%[3. $3t9S0O+_Uo&\mpq jꋛן7//Rh!]"1#ҭ:86+ש"> m+Eԕ.{v7n`[EnW.eܪt}!0~f7=sꪵNk5"6+,+pbx9sN{0e;??A$I\dm>jԩO-JQ,?YndJ$GjҢӡYFUc~= "B(ݕ9uֹ8U5YEA-wݻo#Sƍ zMr>EhWgQ%HUsl#Y |"ss?OHٴԖX@1Pw(\&juITȪ|K)۵QL%޲Գ|VO{+i$[ jErXk[0RijH|Å~FsJSl^4//v^cbSpcxp;l9FJ1P"_, R6Hм|ӓקZRtʤiQ{[dlKllF_vs򭹪r;9s;IE Zy,<>NhOEZ33sNӏƊ1ayn8 ԷF*>{Hm\wTn:2}u!ճB+ʥpNH)QG&ڶה8%nZ"EV n@N*ܽʏ;켈:ٕfڲV'Knҩ{[em>6:w"8zt]yG>aIۚڝ8TRNfc" 0ޠqWE8ʍ."QA=UɹXϭ;OvVx?:5m@vc?1q#QTuEcPE"qx{+H˚nVZ驦*^U.?fZiF$ߑ*mm9fwzۖ{u!"+Vwuqdk*q":҇5!mQYB0nC\KFgS\I/"H0,#մ*GdyYJ/MG0ל=GtJPגkGVwQIZWlݣ>WSg=pA6q5<KU^y-EI"Tq5t')#JjkVk1@}wWӱ<թP\*,rEϗ!w9%tp*iܙ# Rv攪]:X܎{[uS5lˆ8=#4T7)tܬ7NI. b1Um~i?y?2(iu>%}?Yn )S]1Ե9rdsA8U x=yTy:RQ4^E1ۖ8=:UsSwڬc~@nȒDۘ5i2R4{Twȅ^a䀲8>rtQIhs¤d-5Ȓ7+cvOjOqTO\rj2Z9v7sWqY WV]0#`7qN<ֿYYF(Q_a֜5t-Z-eˍnem(~>/z[Ka:nDD|è?C[{HaMJI$k!^Fe*c)kdIpzd<5nQ5O暳Ӹǖۗ+ WyKͅTݴYfۢǟ9#ǡ՜)or9SC-6&Emcr\t#̴F\w6[б_*I[9Ӗ&yT|OWĉڨ_P197=GầWi3W+)uibnAB悔9ދBL#H31'}T)J? vKfzGҴn|{I4$G& RT0ߚ)RoFUQ睬 :gNU%;v2to&+Vso2n9RV<ܮ*Jˡ hbirA<{t%8Ƨ3sN0] #*=Gu'RƔ SqOu?S&gd '[F +t#ʣNu)]?sh&dnAg ӚUylrOeOTọ/.-.<ܲ)Ql;vH<7?ΔwUE#G ˏV0Ck!`{kxۓGRtc{d"sfTGG,+de_Q׽G=o6Ooc {TrpMMpmfH<ʡH翦*-տ)'Y7XUacs[{`ٜ>Z--G7Feu+[عBZEnd0SIoOɭ=<ˢzԹfiR#?vMmSZ^'\8Fř`KqfSs/Z>5ތԏO[\[Z4UJvzuNմ5Krէ{Բaٯ&1īm=+O݈G̱jiؤLJCy}O^f*RS=̫|., =8:*0tHZʖrda|b=/v;*QțиyG+/ZVW9&1 tcclHoM]ؙ LZԔeknc~lUdf b29zzݡ|25Ю[``H3:zUԔd%%UI71}kIF1z愵_2\,2D̶Hq҅Ӽ*'?\5i3}o'j_n=y1&,fU9d*MQnYm\GZ\p'h9y#97tfGlsZTenLXB,Xp@cs`eRߨ:HX=nj} (RQw!]c3|s[u&Xe#x=y>4O.- _|՛g"hwԪTJD<0ǻw̻JRqնi+#HʓJrdʎ8*5$̵$M×xXϯ~RbrI1V0vzp=8E;]tdƏ5OsV- DmTr>SI泩YnmS8مڔʱlQsDә55 .ғ78 }w#ሷF-ت'|&x9#k QFQSt׫*+L$>tnzdVR*TBTX-0OnO)jfJzإqwnT;ӗ-5 jIq4C'2Hߜ>ӕRRS&Q݅u9ssI^f#yƫ zojoMSdȚLIfo1`c1Zlժ{:N~qVo/ki aisT}ƥ9O}4[bHkg瞕.散?uƱl1YiGoKO {J{X;G~PG8Ng+hԊX6&hJqшR];+\~ (Z#;ӹ?{Rƴ]ƞZr6p3ӓJ~ňd!xAݽʍij~TjV#牱 !~y7|s߸aҲMͱ8Fb2ErH8%(GlNi$$+x6{Ҍ/}#LW,){맡5CXO8+~R0sKbѝap.|J Rg#s:aZJ7ka7Mo_/*p?1 ܍7P+sԜ#q>]Xp+ؾNNһG+#$70I'ޕ9Khyy-ŷe13+.x2wwBtf5DdHblUm_j{9bmwCYRd*Hw㠪jh۹uc쓲Uu>R&uo9u485RX_=~d?ј6FRԜ1iF>Up=C9 H>~;О*597_X+Rm2hvX"k|.Ls[K%jw_FkSú޾QyŚQj}Bq7r==R*KŅx'WmgK9ޱgF dgz۵u9ӷ:Ik?EX"bVUdjzp~]jqƌh;ͻ[hQYٟjz| 9_^QM~~oLgZ1VJ򣬆XT%|/lœcE>TrNndB7ەNсk U(UbzitCnUHQOAJG6]6 *+oMm!ڝd삍*w5LQIluRrH=:څoEo oVϰ[/хIs'#:iQ*sJjh`)En%w5{8ԣ%L8U<JĀQl/z>ƈӍ;r*qu\cUc.6/qSznnn!ejYrg>ZFTyyvɚ8V9%_&>iKDE烻}+W2*ؙS9R+;#i4T72 I韼9n}GOoi&}3*:^Aj)[ՋF")ҕӷ,y;\$duuB2J[+hIf_25 s`UeGsǿM Fmڻ *yGJ?z5>VQIh7.vc>\娹u.6"rD~c f?1Ҕl0$l=Cʜeڝ(5n$XA>zڊS Deʞ3+ڠg5̗s|=:}-a|21d*fUJVgWfb2G PGXh=?\z8{FYr§5JV(n%P<z.X\4h{MGi! % vy#4rlg'u7 *&S'Ҵڳ1*iC^ރP6~r+Fp:~yQr2>4Y$G[s:SǷ]9+ݕ"1nW B<`!~Q)KEsH֕ۨɅ"&ff KLySowk,2(f'8)KC8a*Fm7RHsn`z-rZ:V`,V̙Lqs֮O)I-|#g~o܎cOvq]Xlfb}SX<7VҔu~b[\sܪtyP9SwȱF" ;qsEsG;/+ĩ.÷ko?tYJ/EaYԆFUᕕ퍠15]ވD:t{hF~l3w*|T=;x"&Tk P~\EaRTz>ÖoO6i$.0$!'Q % wlfb8Xb!+لcZ!syo1UcaWp=S(Zu9P:|^a׌nӞg:ܔ_iN_]LZG6&]GbȮH;NeUμ;v vHN.1YN#ur.O!"̬҅2*d^w=sk){jvcH$SC6x?u.T(7{~$.k"8$czgҳUu~GxUitJ~oFFgk~2ЊykV,0LqmRTp'<`vX׼1Y1eJᨦ)++imJT' &qsvyt!N;[NTf֫V[1f"1߯`:TkSەպ#Rvz#ڑ(vڣ d`Z*J\/1a GۊQR2J¯,dxFF7b&ʯwcZTz#Jt+׹ {ėk6Dyˇgk91q*[Zr-R9⪝h*}=4&TjNtKbE7RO0~Áy=O:Vy>BRPvZ_ l q,FWTЛG$`s:rïo\=^:mrK2bɸx<tSON)Bz_p0iǘ|lBQ~?iɅǮ쵸%r'? }p{kj;KTc:{z$IRDhbC%\qSFi&EaR:IY$I?s=Fz@yκi0no7ՃIc-R}8eʹĜcVsǚRDRNm_9|HU+7#wO\WJ4ԗ1^in놖Xf$nsltNQwZW.T}k,^RC a$Rr$ʱ^-GF5IYIy\r#v~$9n{)2}^ciKR9v_țwj*8{VөuF,.ZLqx̋ՕV|AHs8h QRm[Zĩp窨zҟ7]کmkX{k84 ?w'q?^2;WE:>HMIkqٶZ4#!c# z∦{(Ǟz$M"ہ3aTsy*KszTYYS/gw#zʣG$NXZi][I*$BT|ˀrO<޴^U9_}[ˈV}Aݎs9k:r#R_1^@Km9nǯd9jծHH砌,FC` y5:m%hŻÕƑnF3ˑLs]IEӺCJt[]i F>TjS6RKnl *ڽFƴyG] T,N#`<ꢵ=+e$nV>ռ\d/ڨU#H᝛d&5w$*NPtB@̬Uw.@4Ju-Ш$FZbxka݂a6sJ6.3*Y~~ds-mi$ORw7a]RM_IJM/r l8>Tr2@>S6R>&(R[k(-Cm߮}kiU#cSy+aW揚0c =jd;XW4M )}_j :WTtL*S&MJyLgA=9{ (ƛO]H wnXc.LQ7A$vEw\WR9E)lRTwm LR#?mNR-:9jJ)~UYL[aU*[S'nr@yDīnX7¶#v} k@ m6\g?Ϊ牝?w[61Kr!w ݜgG7NƒhKᶷY;[AMm)JZ_RFW6vI7s nqHn?K[_NMUUڱ$I"FRh)I(oղ.g{ʫұTu^ҕ8y>ʒxam6pa}V^ҴkZ~R|At+\@`z/$p}G] ڧTUW#lI6ف98<{O5ڰN"x-[Fuo3*B`ݷ?:׷ mZh,㹶념my| *Ttޏp쑢66ʄpJKZF4]կgiY ?5ۮ:}8,~RU._[(Eh~^u)GMwF^ɂ6֋~摷o{='i-cNMOu=ڲiS\}A s\^)}H]C;HB28uɢTU;r9r9-%"XnlO_jw-^+5rIrrO qTr-Ljzv/Emwk#!IY;*鑟^sg(Ө .ޤZAH۷*e[$q.i'Bǘ@ଁJY F8r\ʔqs-bEXV>p{QR7=n[c;fs 7ʭNO?JjfL<5'wem.E}$+0Eo}cy͎*Rטu.$l`$`w/v~W*ҥБJ;E`h[>#ctr.m/t:i~T'haxoktaur5 IQ;}xJ3TFW*, Ck:y!P$zVJ6)Ц׽"ϧ=L>̿ 70G>;zs::j0G#<ݽsڇFUu",dO4̫!;6 }?vXTjkȳ S(Kxjd.Fn”x51olѴ y%积n=*SӞZ_iuw/\vQR :AգKǾRGqp AB=}kʪhT#MAEEH+,B6y nT+'*wz$>ёg?Q[i>[,Ƕݣ._O\\s;)FDKVrWg(S?cN>vؖ%б-P2I(s9Eܓ@ѾfSO>_y>j>귓$ď.hh90ƧSƜTM1H!B˜dYB<{⥼%2oʍocӷ\RMikcDIs6vp=r+9(R)(AIo6fflqzԓӿsJ5(O:崗N|UZьw.Ӆ<?:TͦtVJ[Ψ\ۢm/B?yZr*s}2> 2st대ְNT;jtTUz΄Ȝ`:VucS}2%M*8,{@lqA>-J1cFQuKarH6eJJ12W3FU*(eq5+HC>gȿ2qsי)UZ]E$$AO+Gr߻p|{Z=FKKA&yd=O=Aj9|ߡNjEԎQbyIa>V*ʅCs#Q7jiFTtdT?2z}gt]f1g1*@y7)`A鎣n+i_};`N:[u$x[g߷"U%9#beF*~}eWxyN'FQzzm4VA&IUܿPxV~S/̒6b9p1|pzұxGڅIƊ[!:[` W4&zU)u{%tOg 図zy*{W-Ŵ3Mfф`9R@UTK'XU)Fɥ+=<(&M?6G lLc۾V8IN]4JBd =9ǿX?r/y5&"-X1,$`͎N;}kJQj_{XQ*̟ vwqq+TjJW=%*QmL$Af+b0FdVr)b)T_,o_ѣ))BױJ57b_T0#hRCBĮ$/͌*jJ= a;Jim !Q,-,NxU'+o9)S}wbѫcy_J藲KAVҔ׼_:e22n9fnAxӤU TR-Jak[5VP1"[9䎧鎝 KR9b8P^~eͧ*E;mKoxoC}zW%:qk_Z"y_k>w$h#Xٙ~]frIW?5.W?eX-xpyy6223(o]-p*F0WiFe[[DXe*Je؎p>=Ml:~^i2QG5tt>섡ݻ?OQ.xӼֆx\%*kIlndlݐ* }9~?yNt5߽jG0J~vquNWJ۳aJk] Ζi9D$ `1CW"#ٹSz~^C$dPYJW{kOi)۱5ix~ϵ`[p?^ұujԗ/@3QWY5;D*#ϙzX=Y[k,:̑v}5i_+;9Kyw6]{ tTxy僴uky^lbUxѢ8G |X쯥Vjs%ro^\#[[Ǚ>fF@ x/zrNUWN5W}!AVH ' ժInԩS 26QqC285rI+-Mk9PܞkNJsG~~Jy[Ks^S}~+Y<q ڲzouPG{l 9C{+H&c<9JRn3QVoyR俼$lO.<*ZԜ}~pWZHfAa"08\=8]ݨiO?[j>o-HPK$zm4-$+S2Odϧa:*2QWni9k',vHJemUݵ^tϭo9J64U|/b6<]yqG)rŨ%S:2Fl5>B%3AR#ߟ\tEgkɤW$޿6 `gz"5<-^h^`wm\g~}ʔ-/P;6fW}εͯ".X+"^4ڲ$‘Ш|NG v?Gva>Q.ψGssM+6$ 3$en/Z64INi^Cks~cc;oלJqY'w:괷VFYyFvG^y<; MI^ɔ*kl2OhfY9N1WΤ_zikb8o~U2k9aIuөQ8StKMzzll<&IF|9,v],;m^^)1$%~lPUr[_ƾB[g#}}Fݤz_h+/nҌFrvJ J6=utD%'q8_SֺuQRiF*H\Wt<ٿs6ǭy.J4}o,hkMcI$ޥU>fKyGS?G !Y.f\qtӊg*.-5gYfʌ=w8B)&oG[tk}ch*jQeg6mU-p{U(nW[CaH'|826]8>Zɱ';OzU)+*_@%<^)j}W INE .Z$YHX,v+A9K+cF*\ v8uR\۰ shVQ-,|ќ2SN2ʳanYvYs4i`%df }3YVTz^F߻שYvĒnvpx(83)Ir[3Xf099'iMzŹӰ?l aNS]m~=\yq38j14VH_"1qӅV\w %eq3&:j\Qy#:URNK8<1rN=q?kibZt֣"Bc_|H3~`FAx+nog+Mlq $BIv!׿V]:SKc:u%6d_j<o0zL׊VW[s-3=d[e˔=` C\@J=~5%gӿQ7HW[bocOWNjETʥhikkRH jm${uK+m}uEU+"írљm#:^ެybBR/Xz,0?Nt2[i̲NdcmcT#Q);k!֧)=53E!Xc ˰sӶ}TP-+gОe^Gɷ~?ZEr^Ҥk)wIn6[3,a>Ռ=fABK-M)[ 7?ΥK_c9|;=ƣ/v|pSEҍ^YIn9I:wW!"AvDvI=y jB%5*5}^Nneگ|ݰ1۽ahѲW֩\wG6uAd67*ݏҰʷnyJc.qsmI(nVQGdWqb%XՎI<ˉ!Te>ڬ=j'fةUKv(UdRNu?ʹSzs-'7k-^J)l ǰ攠鵫fqE8`-$roY>V;ӏcޭFSoӹ:rQ=ɡ]roP@&3~x5z=5iQ 1;yv3܃?ݨ=?1tWWo{mA7c -d97~qF5T/%۰ˍΛlvaאHN\T*b%eB2'e?-|ԟOlRMޗѓMsq|F928 pNGNQ)Jt;#*5)'fƵDb VRN;V2_+17LgyV7xv'zzqJ\rSھYT!aCGSSJ%R<_C07C͹e}(|m*jXxK`6䑰z{} p.\*cQ[MzwjqMhr<6\;~E){4#ԝ5Z\!5U>^2A+Q 4}V}GZ.eel yr>dKWrݫߧdlIj+g {ʢ1ViJN=eNንG{q^kUsu;fcNF=뢍8JjkJoMjנ!kFUaN.liR:==zqMnAv x.x;+Xu.ܩTޞc V~m3U%R<͚VU*$C>qHHR#]l{c^J%?"'qIwB t_Ƣ\؝$FcbLR>_ս=~}mƖHJGSN"6ߧrFyO fNJ?kJAk苕jj]ʾaVӌ}ҳu5oP ݳU`̫W ts5e.{-*xz>ՒEn6*~fniS=dW.J/GكJk2VMzsӏZ>zW&Z[4k"W##NQtM*S$άp *]]G~cߵWb +1&;hVF{u>{PR*2dv^Dfy7\U_|/,sJVI^o?U*?鶨Le98}JnF罟^Lf/$^^1[i~C,%/g)I,bCe,Rr<βF vوI|qq=k8ښ1FU.ۼfɏ39J΍KUԥ*o+)mK6sɤS>"][KV^}QqԌdQկ]5+;|/#+?[,۳ZEF([ui2dFC3AOcTNTNx[bJImS$dȺqa[ӧ'KhO [٤Uq9Ѥt1ùv"k>S׀@ߦ)W͇r~Λ?(yEӻ1<qq$Rd;n Kvm)KNg9H]g<:5`J|>_#r:tMYW5)IU4VUs i0VkyS1.8Rnd~osʌ?.3*uG4M**4nz#R#*jiKԭզ,2?y3,Wq  >'mN4ߙ 23Z6Ey4|,*ܐ[N֬cۨ,&oUsg#+*6tU#帐Uc>,yUWRWM\n~mÀ 8Hk[J""i^$؅e 2+I{k哕tksv+m2+|uF1:(hڦNWyƴUd[#AuStӨNWW yt1qZQ猿yC\2¼-㬽JwEF|fp`}:QԧY)}=Mij|)$]{T3돻%+\KrIy" .Ivۓ#ڴJQydi$*&08'=^s^#j8z148^z$WGE?JKm[#`Z2{:s߷j(Ӧڝ'$֝ S4m)oI}qԁֺ#S'c$7~[JٸUY>`9\9}7RNGTcZ[./˿r+S4$UZ.VmE'J3|;RST_Vy^?&h'0ߧ5MW:S씭vw"m?G&~ni؞X.EK%i> ޼%z'$sZd{IQ1uܤZ6zte]HB['Ғc*3nVW_c ;X8kN\ҷ\֧fu+dUmt 3D>7D!sֳu%)6 G.%:e? *ߩM*>4[snxٿv+IMo1vAN8={޷}Ÿ<'?^iZvXahg qUNUũΗ4\hɸyW'l6́#$}T*q&=i+/3v]ܻ~5 {yFNQRd`1c.Y|'TSR^U\dFəTNz/󭹣yn8iѭWw[h[H5l0ᱏ񣖤{V'iwVq5:Im7n X*cEE^S%ZQOBHVQNwJhS$MdAX.(;P-w9\yֺ=C>?.rzqQ4{kg=|FX"km6ߺK0+H{Vҩ8T~ZyMElT?2={U71NI_fH7P@a)3C'8L ~Λr⹰Wl?KW3#?"T\tS.[CJ(J1y;lX3I,L߼'o͝_ZڏE7Nrq:ɵV:Vr%4iۨt$[iŅ-(OdW*E [FѳBWkcoʪR慑:~pkhU~*u8Olz}+7OVJrw IJ\a"u`pyq5N1IzRr}IagVuc [k1oǃHe9M|vr|viHU)VX<#<eŻT躑楫hѼ*Ppzyӛ`smu6$L+&ogt t'Wi>gӎsYɾ^+ZsM=ɴ2X_.*zggEII˖[plw=U_eϛ߁$r(wOn: .[hٯ)r㌴f?ۯ֮1B*qDXs.Y2sRhiR9I4q1VUs:tB[h$ʲm?3t3J|spv!ڹ;s߶H*-+ݚB<u޳1^.[ ?b![Q[rsi' 4Ή_%-M jNׯUNvei}^vc/d}Em[mrMWHmLNjzZxjWD3?ە hnUpiV5v:jm۳TR\(ҎZ"mEݻ88Q VO.87wԊ -o(ګkl{5k ӉFx#M+<NqTk){fN{vB˹FV'o?ZjQn[vY۾Pcv<#ҧ_1cF"'HGTcB3huϾF_g}ns[S]#ISb̹Cb0Lӡ⊕9$v$[XɺV>rI?vcۊԎ= j8as5]ⴻTn8sZRĎ|V#G)3[OQ,;$q? ޏ?c9PN6]FN6ܪ+z%fCXG vHىIsDc8M[AD2*pWiRIJ*^^b[!,1 ,$eOl⳩JaF.Qz=lNbn#ÚsEmMՌyӿSԎ]rZ#»,+I|O+NiI"iwK[b[V]Nq$1nn9?jƣ=U_i%["H|$j3M6d>ݿ+NjqyZ8ZҼ~`i?v݊T}'̳:f $c )[Z&kE&+ڬy1:QwQZĻc B(*Nzs]̣Shѣg&ˉգn?[|ƥHGZZRzj'bR9dXn)1I]Ì$I-F$VF*=Aקj5Z[8QiBD jƣQ c1[GEҳ{¯4U6~Aq3sKl֍s6Cj?XrX!"4j;tgʳT,Uvc֜!c4["ΰ(#YȘ*Ri幊85UbWK{TBr~ >Qbx}ܞ}zs54- Qe[y%*JF/ŽxZK;&gZpI'ܲ,bZEc>(SHԫN[Y,h^#E铏f2К,w n>d*Yӿүg+Y[t)y6>K8>HɻzJ׺AX ck9O[I?#N~h!7de*Zo,-I%/EgcOYGtoؓ|r,l>%]ʼV^[Vm{dH{5a{^K([ rN6/uitV>ej.9Ԁ?Jq3Kݷm4?ڮ"lyV(r\t߹f1yR_1OzGZ⧩Uv%Z 2p u{zU)F3Ckͻ  ~b{>eI/c-\2DHmH_/nq=S\b\hC$jȫb@u=qNQwzIΣF*eQ9J2u6cWR[ui7;<+;GLyiWYɒyOTlz;fARqd|YcfDVd`}3X?|H\Pvd(ʓ-QdUQ/͖ jg*qѷ~YQ7*g=k8 Ö+Qw~DM8F3u{;I"#MSߧQ(r2F9tfʔijC,nQT\ƮBPW #?+!JSvZ5rK(A_)7 pl(T׮8ⲨvU*B1w%1O#۪I0`1RL7^r_"ǖ>{[rU}XFҕ E'uDV5+ߨ OקT9]HӬ{v3AWSN{Pο~:'̖W0+9+¤vgU%֊9bi#*nr ؃M?v^dK+O]zNܨXY|xiiרRi.Y $`0JZ*2+ԋOݾi!THʱ7n{>XsiۛaS~N˫5$Xjm9lrSZ^lHRݸSs<\W cg)J:3bn[Xl |eܭv$ʱs4y#}HDI&e'&"Ԣfuc%r+=kaqs⏬F>:i̭hXKʫevɌvҸ=x8ƥ9Uu c^7`~K?J*~JtgN$x"Xt[hvSYmsSSu;y|(;SSwM%NMF ԆO*yۏ¹2{ZUa7Ko! J$+!HX,{G9_JU%FEՋs.'c6O14`y|fghףV%2ăȚy#̐98=BPz_S)*#{-e6[W8y~u_6sTԌ.#K2c5~~x8\ )2k7ԛ_q%Ȑ6\$bF}U`tyʤkRJ4nU)ԝݍkFvjKu0jUwC-#YQV%;zڹj1i$>?@Yʟe1cGo;kzsJuۙ[ex.|lUXp $N:1 iӯ^9rIX#Yٖ3mq۶k8U"i}=ifcD5 ?Z*S㜄e9?瓊n5U1PiE=>Vb& (x#)ӟS&Ӊ-.׈n=]%%ͭ啓Z?hb8Uv%xzV^ך=KadH -7|wKXMM%d)(O~)7B,9OCXF2vFƞA ,|643nR3Vo<%Uf^3'9#SSi(Qp[{q޺'NS5ɧR['{ʹ{"D 0q}R9I$ݸϚұf9=G'VԣSEFR[VM,T.U3D̹ݳ:0o7B#*Ű'ߵoW)'U٭[tXV3o &{#>Խs9ajJ<=I$ӢK6@l3n |u8OJ7̩ ߗLC3 =[uem\]B|\Ko Xc?Tyyh;u2)-ma,2[ܐ}1ֵ&^>MRI42yjղ:rsby+IjsJ#K]fqlpqFܖ5`D:22FуyXk/%QŒ_QE#c^Hf`ӧ_񪜹ccң'aȐ 0gOCY?ce"],M2 9#59*}bS5p${;YVYWR mIrŷk9e#; ,GhֳT*F@+[L*8xjQ*SQi kQϿa(4ޅ7vGv;$u߳DԍN[?qB6W*O⪧,trҍHۄNEf9o*Lgc*qk]NA}fWFOiF;9hQ1$mkRwѩ pk$Pwp۵)Vr4{:ҿb <9P3+7愡70y&K2GRUetfN1Y8=Ч;Mv$dm6=}}?{ԓMi}SJ˻99vߊt*i,[$}H+~MkfFiʹj 981v8ѕ;sIY%u)w²IJ6$@fwaQPiG>k-2W9#8G)Y=M1Xыn&a6ʃgp㌎wz yn/%)6HM"HUr?͜25R+V|cN[ZXmfDfe-'s~NRoϊRreCfi&Lw.WiÞG'F߮4VGD,$Y awFX'6֔-S{r^ѓb- p3r֩';kL-t$I[nrH]s{ ԯRPN*>5$!WhraۑZ1W_M}E-jYeK#fW'V:p2H>S5ʴ+FЊ٧Fhd ڼ3\#^SJ׺bKUmzzZEZ1(1 2{Io?/@q۟~[b)*7{-A3D*y] <㑚&ՙ%NTIXϕyp u{:|I*i);N0{(Ϛ:ӻW4K>wM墎9pr>Eg{(J4;eDLɷ˓^ݽhzy#p{$x6ymJ>Tovm H VL[3gˁڻ4I N-4JQ]PT=x##gѰJUUh&#2 Y]d'w*s#Yv2[kx*<ʞ9(|m[ dU;zsjB5=KJ]<1F" cvwqC_ˆM5#?g2 v|]ČwջrZnk|\kQ#^2Kz[Qz~B٭+<%7L־b8Г]:&m2XDjOR}kVfv\Mc]9wӥJ厌*k[Xfr2Y _ҊiRv(tĦh۔*=xQN2ͨbiS96JȒEQF#z]a^:XVhT2G'oz/^\ҭȞȊg0I99 κ1'{IĒRdl涔Jnɦ4qٵl,r Vї=kRR}?#=l5h{VtI}87>krVjN׿aC @{N ˖ M3>6UdBR";[$s@Q$:t]1;kCզ6ӽo ™m ό}@k$gRK P}#XݞWTnlqd+YT1s鞾³6r}4!lR8#:2,xڇTf^8eX.>rX)c9U-$6MFkai,"A/GJ6Hbîe/"mo[lw.K`6{u)ќRuQ[[[C5I 1)yss~MOftTO幟R+##8ϖFsӜsmIK[v9ܩԋ7/+=żzR'[0vZ[ʭ#/2{޶sIVhܥ{V{}ɻ3)cVQR*{gAFW[9.m#IQ[2`Fm Oj#SM"eRmnI5˺Z?.0qG֝iW+ Hv^bʗNsLUI;{GLq&5qUAYƜSletr֭.d/B¸W h^/r8FI^}Z7VWw6<۾1KRU)8e`R)-YxFׯO_¹s_S[M+"Mқy,,1ׯ9=+YF<؊Ti=y#PG?Ӷ>&,=SѮ[Y#w+f;ęUUQ|JҲ(ԩh-T#i;;g{ *]0A*}/E`]( y21u,njN1Вw Ty*#nA>t4wR*t\Dcr,\{TN2qkQw5Yʾn8&卻W&3N\"[\2xfJq;ʼdӎtJx┯b9$ry;{S8^?/+NNȱ>sex5OveE{-Mǜa($yzwLjJ[n}'|Lo +#e(qG!2&U1F`x{^k娭Τe9<߲O03 c1~k9~&u֦u]~cX$ d泗=m-!d^bs3˵a8*4v#:98v#qj+S*Μ[!ܧeRѮN3ӓaRy\0=;1;wV .08=:}j}\SӚ U%3B!E*n`#gsrڿ{ˡ8t{"H2?6K%N宧7֢SMz1+*9<g*r5N)JR=ɑn#H#4;|ǟ\b빭WʏDj- p҇ 09)ӵNyV:1w$37R}?Z娣풅\JHreGd3Pq=5-s[Sϩ%8FFěFyqQr=sXgR%-֭TCIh֞^O+5RGelI~(QHMj;&ȥ ;~L9ԓI"<-7k4 w @q~]sʏ&N~k^rַ.#9ae`c$L}FkFde3j)٢mҳI<{vztc&ؑ.cGc%a޺#ԲkK֚_FWbwJFBdvtJZ(*U#`l&pQ#w>oNQQiJsFM.WZ1z^~mQ#>?eZ*mreF2zqndXh9'v 1㹭o9qU4קr5HdP2;rrz5:qtdu*5J\&9P@nJs=殎/;y'RZ__Ȇ{YU]N8Rvz[U8{,̻|偐@ߞyiK*J]=Ӣ>tq[Vˡ79#Fo&r6Hb8'nstQm|.yv^u{"K}";c(VXV5`AtSZF1ݺxZu)Rmt-̷&B2|PT*V$v;BTOTEK|+Hɰ'GT{s t'ӽUEyKOLcT1Ɗʨq0qЊT#)*G/D7Ww=OLRL;rQ¤\p?1ܫAm".&sڊu%7X2v͵fc#Ÿ~s-M-z>ZI'~Ԣ#{NJdS$nlN"У_8%Gӕ[_ O>6Yw,29sVЖ/R2脜;xeQ9?*gN5}mYi)-zcaxz#Ƕ8Q h|pPN6q^9ETztJkC)9Ƨ,i_jH[̊ u ";!ݪ7|wԚ*)0/+FmѢEWvw_\a*2痿VcS|ͧue?BtxZID2>ĝ?m%GAhͿ#˖ LG-fR#Mc齔rxnx\ӧoҖ"$%4{E&࿹#ЎzJOUөF4qs=jyf=7 gtQFTf<؈>]ߚ#4by<À8^hRx'`K[v q?x+^*cZ}/gD֟k gq'ZT]jx~ogdݑif6 c=:{YO̪vi+dI$,͸Q2լ%.dau[z e[[`HuYN}*B/]u5eEND&9$S,(o:v?g{- \K'.itv_p h<.p yN3ָ'mo];V<ڥW#mI<[~@ӽi%}3/e!$ס7 C"1S\:ˈtJ8gxd1t/sFnޣ<®R*rܩ={&l6E9#1ުK},$Re}F&^x<*һȪ݈s/řVM}We>g)գI#2EnlR{=)Qiu0KJV17syUI#ֺja]=gX;7~d+Ei}O`ҳۿ\ɨD:HZO+zU .-(껡n26Bp9㯩5dy~)Jt2[+XJޓh<]X{61I-4< q(<9 t*ݶgp1Mۮ e¬Y*@ w8<ץMiSol=L<[{gqU3n:{åtaSҳZMkI DpBq׭Mnik*jICqEq5BddU{S*t踥X㕖=>Jlv)98'Z^U$Z443:U[r&&c< r@5N$Z59wȘx2"P:8.iRKkb[f H|Y$T=999Vhөw{%,>"u"ܕBn !0 䋽O[͊dܬ+H1^3ZJ2rZFq.neNb6ՉUYK7895<*Mku)YVwZCorL3cc\2OB8:lE9ʣ/Y09'Νt{4&7bq#<鹣-#u=?u5*q%]WAEs{{ b*kJ䞣%-"hXpHV)HU#[0ŀ^:g5ߙ86Sn>x#yVo?jXo=k*V"9Zv]VB-ʲ|{g$YէR59Yv*ʕ5רe 1R]㦽J @Zvª޿tc 9ϥe5E5+Ӎ'~Gqrab0FKY )⹥=-g^DI>#C">g: En#Mmd2AwzIp1w888L\=tb Eg*iۯWY syG :sֲg~ENRoV,V>"J\9ְ0/RJ)rCl"bw|<А:FqM\pԣa s_Fc VdnkNn^ivGeDhq?ҿYb:qղO5̰yQXYmɭC2ywqrskae^V{b*WSJI_rSJܭ/}eZR.Xnz&AIKyIʫpI_aV)Z);#TU;t~竅G˒8.P{/x5r+}6E І߯\؏z:&}Fк3|mq^=G9Ӕ$F)܊HOG:+0Eq<[>ar_c.Ҳg l:6G nWo(ίg3k},G$P$8<ϧyjKsthՌy.H߻vtƼgcFSR5T4nqC7˜ ~*z[{ʠU)F(3:#vdqYNg$߽?a/i]߹()Z!Qf9G8,{~嶊|RdQ/0ן5]nL/,6{xco*N*=+ohEh`~<f1hUiP{eNIEic&'kvR3ϧ#ZrNvIU4G n[t8=SN-8ӣ7amUb꯸v^G\q)^S'Ϊtmky6)`Wj'=1Z֝F0TN7ko/ $,c e_ W(fp>gΚ-\[2G̬d}\vRg˹NRܒ$F6(ZqV iM|t_۽y U*$oO4+nU)Z6^6|߱+5Ī[!v9OZ4+s4Nzy%ۖ~Uvn;W߯2^{f|arD|ʤ: eDA˚{&T?R{rfz;c )2\zMPVwk@{)@f ] ב)>UݯMqԥ(I53ym8UmO.Q^^3ʰvqz6VF*tUr)l~b6,F?N{V~_YJ;G֧>iykn\ˮon`.#\,62 g+c+m{J?#g2 yJ{-zu}~)aZn~i`8uVk^+{/5{I4]z0EA>JTQYw7K5~nz64Zi(~`\.q96GaSj}SUjЕ>koקth$e̠6 t1,X]IomW YvF ߯IpoInlmPx-1ӞGnqXJI_]T'9؍RSmX;H5,=H[[ɣ"OۛU#=J#&hi4IIo џ-F#9y/r)^ކ8V)STEa>h=x8<z*RwXQUpr;sD(Km~DRX|*Wo`c}+&֝sA,AVB3F݆ I$`RnK1I5oH0y0#$JӊrlSI)ΨU ,y9}>q){?M:Ovnn#ዅV#?@=84v"IsA4ek-; m6OqFLy#8OZ Fdfer}i/cSU=XsI0mV!N\5~UƷ%?u]Ȃ8ܴƒRw6HzuTMVZR$bump,DowrmZ"I[|hĊ,;ⵝOݨ]1>_zr.n/!H LlĒ:#j\t*Tٸ&U1;twݫ}Mu+k+G3#X+5R01OoqEf'ZWuXe1=+ջ&⽥YſUh`fWY3;HCSF2ӺMjR&}zzPcY<'[{}((B aGnk5Q]E߮{*ʒ]zut$Y$?ρ۞'◽{:%fJʻqq$14^C(SI]|X c8<;tN+XROd:Tj-HT3P^~kU9d.zr7+`v*#/*75{.lG}2 ;|hͪ!Qo %a|^'*Ws؃]%DUT8&݉^-a66w*Z1V{_Osl-c009:5Ɯm﫤1k< 7a֊qqiOr_$& P|#HaIҩB;pqJl"H<>n:tcR*n*Ԋsd: Τu۱=vI!=2YCu8ӳ#G&Xc8 Gq򭦪9(fR<$hb.?8|j,26.ѓ{{VeMXSQzX 4o}8\֒u9#:qJu,m$.e`qY_cV)7/Q36ŷ Us9r ;I"BpYT}x:s^EkZ*k{ioRMl1;+{Զ4Գu*Is0U(mg~n+5(F^qj8%Xe?0G\p}ץR,R4' v?sɪRVW= |ҌyZ2?0e9zG,Q= n{o2%c1rVѦl엖SvӸmv|۟5QKVZvB,(UN9a8={{Dբҋ <|p ާj7w[4e(F\40Ĺxca2:t=crweܩuH:z;5{JTcZCBZEe Ss1ɕiTõ-5]l ,SKwM)q=8kHъ̡:y ec{ⶔ4Vg}9BI]- neڌ:gu}Q&Bniʝc>[ټ0}]mʳA-SFڎ"֏(\JTn2WT}uOlrjɺj7K#sєaTI6 uPenxwȮFthJbvQP@_9e(m߈ۊf夎UFDRQ8hgXtFU2w}j6_VCuwՇZQ6I{Гv!V[5a?_=HRW1T{^>?N1NHSn1+nsLZ.2֤sG a|W弩],cZ5/R:Jv9+#gjES^8EH ^]d@@$¬1g)oׇ>H;5by.UBZGV_s. r@>>~3Mk] Ɓce*Itzz{?gh%~*3TRkrľm^CyzG܍hԧ)>Uʶw_Ț9Kw$rdl\gӯnԏ5N]E^߁"\$+"?z\V9i *2vh} YSS}ֆ2Z1SwK2%ɗǂ3Tp}W➆2Z_B9tX,8F<#ʯ}t;eZ50OYt,[I+Z+M݌|7 \g%<}d[xg ٿEhs՛t[X񭔑\mڹǓc \҄\gRRO=ʥ|ŕhzt:G)[݄gTJ$n9^ݤG*vZ/$Ȭn1y|Ug(Su=iۧRu4kbR5& `7*zJ459'kA,,85»/Lr21Wշ3u-e VhHw~*g)s9!Ƭc-lsEV9_?MJjؽ>V4.,Uxʮ̝*yr:wNy/[F?ֵtz mJ0m1y y8<q튽*hΈ֧g~Đ^]in#k0s*(fIg>2RэTOyPgJuo+NWA1^y#$p/,AڬqxTOF#J-أdO'Z_BQN*1MwʸFr}UU}_ثypmfP>T~)r}*J9J*Gir,*XWi^9͐uѧ"T[S>R8$=NOڲLK]ldIi5AV!Uz9R5' -7a1dlǠ zXTc;EhΚu=KD*WUgRT}8ȍ!I$VE;vsމT;Ӵ9ީm~ʲn#<=kUK KXj\Ems){YJ8p669mlv[9Q)I\մWv0e݊зkzFCmJ#XۖS: =Uv⍸Ҫ ĺw75Sy:L'GQZJei7veK-Gm=%rT.m6/ZMi*4*C6Ӹ?#Ҧ>޲7ֶ'h6+'ϔHms姺؛ihN**rQk_I Ťmk|6>\`ï*mJWooPˇEo""$j̬d|gnz }=iGݒmߙ:7<*H$l rT7kxuJ\szlYiDG vƛAqzLo6gUM4حr1^$/F,+4 kc.@=*`΍>[92Qdxc$ fʿ$pA'#3*?i+V=#:GVr%/y-j>KvlHC վdzs|ܑ9Jie&&R\|:ӞGL/k&s:4w'{q`ά];y ;|^zt_QiY/y]( bXJ2&RtLvVV\q;ÙƝ9J^E}*[?(IYԏ4lכ<#FBw;\uo.S|kkܒad]gS𢍔.E{h74>rHp}#zRԯi(Gm4cG$-^?Zidԗ-5-F0>m~\#Y{83rq+"H+wwqi7+'hŶs=+t:қm'5zeN6)ԩF0h}{w_R?6I0dBILǝ(<㟯8ԏ(U4^X(b^lylۤN`2-}[VHĭ;#x=3jԜZTht>ݭK*'yFS和]7%Goa ׿Jc-g5rMyIPc dw9$cҔ#QDsBV;xk(ʤ-X^<ѕh ( T'rҖ[^)gWM]\|9֊~˚^+SFw_' ^p;ڃnؤ!@޻v+9T槪Ei{? Ϟ8ݲ}r:p+T&R)htܰ䳰*GˁoުHj4Sv^)v/^q>rr,ӕ' %KkYJ쑉#99=GtiJi1QATWZ[돴[ay͒P2y8'dUfy;(>FJR[C-ȂHޯܧs{q|lUŨ}t&^ҝ&E4Vit2 `G#(ԴwEcO٪j+mK6(çtҧe-,TjΕfD ЭǕ,dJg_ǚ҄jN27glp+sV+]^5ܖ+c3 bHT3|ptqֺySjsJ>VwQ3ncN*ūl5dܒZ C]N2oS \W5^ݤ*!s8"0FT.[ ġd_/jyU?ORԗ,C,[UVezI#?ksJZBF*1Irf,ܲ3,=XsZQ:"u-љ{t]09\+FkRьU<&Ek-=8#ʮQ(٦Lh~$T#nI'ҩ%V Oݒi=զD[<0r7Y^$g^ iWu+Rb E6їDi,0n/gN]62eBκ9%RQҕ(عEcȥ}6jy^5}$ۺ8"k*-s֣\RES4odapdw @K{:t+*qS\̈́i{Vջ@nד\ӝs{t=^wVǖ{8ȪrSyia8(vUlwΟ,CeCL7rUܭڧwZz涣mÔm5*'ǎgSޒl,"#Dw{FSlOYQvCRgjD᯻:qoOC2[oY~NT|mviBEtUX=HȬxHʥt ewaG1lks[ȘĎ$˓^Qe(T^2kTȊ8U07Ah(1q멜+/';xh'|: =huF=. n0da?)8V/`f2֛R;88yƤ<_]=cjǷZΤNESTH~s’@Hvx=+vhgrODF`W˚6 ͝8zYJ2M>g&_Y'?q}GY*/imobxn|S xJ1q5i'2ufUUZz܈=IV3Qkb9):~VH<$#%[l?rjsI{=?%Ou`d;>Y`H`}3'8}'J8<9%,Y769U*bmƵUiIB\\C䈣`W:49O9V<ɭ%ڞƠR\G\c>y:)R%*Y*%B0Y#ی '(ƣZZﱎHҿ7Hf)"f{`wQ^*}֐[țFNdb;d~tn߽R㎧NJCWxGo=BԓAԔGoM6"{ekrq}~(BpWkK/TjJ=~|nJ%8UZQ/׻1Egm~9iԭY+NZ0rgAЕl{qw5lncJ>Tmy &v9nqߧz4w^<l˶q;@]oOu)Ze>3IKRpYHqq F⛷ԥY]-ˡP*gT;O#Fpy?Z\(S䒗UAwlHoS }{UƟ6,kS^j0Vh+22@B+4uJTROu/*IPG2Ο-G'iʘEXqߎhݗC 8˱٭˃_3,=wn>"{ess)8դE-X8=Gb~Iz{9Flciiֵ6# `9zk(4vf|*;K"L sտZth)Or9&Rȋq[F1|SӔ=\lR\2ylG#T\]rq|vD)#ɂ8N'+OTwj=O߳!gUQ*23>ݽЄbS |Mz>Fy7S#H.Icr{F7`T ~(VJiK**ڸ\vyURuل5v#IGzڧZwۡX⹔F;vVey3}+n_ݷR!MoM J^yroYwe*g){|L 7pѩ4Vk=M#˺VOJ$(aȥeӹ`-բhzt#׏JnOSyYIO-c m؟4~MksI{U'}A\"*qX)ϥT}զеǖ=c'^ycm5(4֫&EUڤV^8Zy2NIZ.'6.4ybc\쩤z]I%dPY01ڿ\w#Z)sm դR7)'guⱊQWqE*{t/d:!GrHN)J9J $|A#A1!{sDhӻSחK+o$rHs؞p:ZrSrZcIS|ץê?72\Ke[U%xfq]ߗ[K6]NBQ$F; m8>j[]?4T$\u;SΩQPf4]#c!/?US~Ԍ-l,F`ycrMMje򌌼eְ\3W.֒ nYќ}3ǛZ,LE㥶;JQ>a>gv)5SǛWɐT[=USg)GR6H30wc*\cg*Xo2qH~OA#8d-60NQ2wZBѥIGnv'=O8f+ZeKQ#[I2~<@Ƿ\qֱy<"%{fpU;ۜ D*kϠRY,~XUJ?a'JEtq2;9zڕv*T.&okFhu"c sFM9 3nh<ߩ"mOɧNv۹؏#=>'kO4yRB0 ې:qӎMcYYg9JzנV90|qӃT˚2G1ldjڮ"brԓ`u&O޼Q3ym $c76b7mŒ~qR5yZCɥݑ@8X;G$czzV>4VZLF,{u \f(j -"S UWXGA>j r]~"iJ3kԊ Xpe?˶kӭZ>Ku20Ѷq=jQ˧NTJn w4wFB's\Sҍ~' hmT*#XP󭝝U{Q974]~*)He D]05km{XM sut-1EVsqtSZWEۦ_!IeH랽9=?*Щ{ZiE]VU $6G(IOAVR {?3Bf߱$pYX#/N:8O~5ԈT[Gyd,Vv 93Y֍iSҝI*ܵmBkKqr+7PH'nG-KnAtn^݌M2˻˓#hw{s)Ss79O*jnr,Sژ_޻;nCiӝku(kQ$[+4őhnwmq^F՝9TKfE2#s|h xɮz*T// 4q\F ^?}X}^T^j 23Y vw=:k[b***#u6c1mh8}kyG)~?NZ1Zmsَxy6Wq#'9}(Z+=w Ȓɒ2f(޲3N1TVSsgHJ; cq9r[nF]NR]i5~G䘢B쨸*?sZ{HӺkrgqƔ^,\Ɇe41kl4\cdu1{9bl##:*JoGݻQQ[hEOi 0mlnQv]T#ScZ_'06VV1W5i_RЧNQtimQH@>h\iU}dPI98xEJQrV8Ӕ=01<5̌͹9|{T59aרB螏{TK&#i?tTƝNG)ʌo_6"w3~-jN#7/m^kIβa-bU?O¹/};4]"r#-+z^k_$ђTe E!;CqmܜtUkyQi\)ɮ[7~Бim`{5$W i!1ܹ:N]\yy}c)i=1)Rj=%&kS*>'nʺTQ;Nz2f0f[ 7<+|B^gT"(6;۞zWn/Cҥ 5FrXvC,a¾IcT$Pd"EHSrrI<SzGiQ8HL-^@$r1X*n:%~W߬^0{Yܹ7t2_?9V1ԪWJʩ+rԃ 6~\G>X !7)dvA兽Eͧq UI'~ƙ8$'9;q\J1w_SNl5`e hiP86\QIO>91#cIZF+IO'Њz"Մ@˘[ 8afe:u9dbO3)_)x#=?:ʝ&t{5Jnן^*1rʜ $9E*c`7l9nsU!yM ZbJN8$5y|U3]^=+Ȭ+ѫA._R+Ni#t/vxVfe8kJtksEhH"ģ?n1\+n؎p2?.kj4r˖k^ dy*R0y9QI3~yʣQ8af ASgQ[]ޤb'ihE,|Ƿ_J\U}![ϔAmܻ9̛ڜAKxǫ6 9OJ2M:"~<2J4{]]U=;dYԋm?U#pZB:ٹ[8汭ZVs>Z=|Xl+7l09uo֢K{V5x#, sDMO-{w.R笗ģ,rr8?θ){ע9J2POvo1w V2q^OOgY1%%_{=G9kЧ(Oƥ([?r1mʤۮՍ¤1$a玾rqi[uӧm6wv̋Izv\iʯۯCIʇ:W-[<~"Ϳ^)#p8^GjQ^+;=L#wR1x!!Iߨ rrV?2CdH# 8=;V1q__}9:R BG3rH̹$UISrVZ_:#N1IgpEmwnYq^v={>Z՜"kgF["Rf6>~5GZ/Dim[%ȌVfV^8W%jmTSwu"]?ۯ6CHDYKI8^b_qr]oI#nb*#gp:~=qD}x/y~9$ײ"nA9az4eۜRW{_ΧU!77_p9>(֜\m^J^wi|͹Y[nOqj1{H4yIh_1f x=zfjUFbO&O0>Vp^'WLkJn3hm2G _B6Q[|}}^kC!m$'89 rЪ{Ӣ+i-: "Ur F@>O]ur3]vԢ]FJd_$mc>u"T7=˚U{:  0%AO#'b%N]6EdI=7Lel$t;k=ݕZJnc{[ &6Gn0;zsӿ]J3R|7k꺰_!0_,ʎďCYͺRLHr/n 1.-s/$vTghj1J.y-5QOGYNco,E:Qiu RE,AeTWFNqtZT,U|֧KRױ^V..x*pqgʵiƖד[kHԗȓ͑Krr1ܐ?i/+Fc'+`hR k`Ͼ?N+g=tF*prw$mo &9沥ͫJ '!AќpLIҺI֍+uA׻,hWjn1=?ɨyej]:ZWS%@ 5,۶&7onKGKv{R< G@cY-(h|f5_uҔYQvA)}8'=AJq GoigOmPy6gֽhQv,nq$fO^F{Pө[`nj͈dwmmlSZCGOA={U^2in8SΕKI^V8]8DUTzd:=:@ۼΎfgU˙' (w_I,;qXӔ{W2PX٘ȧ00^UJ2rqNrVO[u'w)9?1lE<5r5T4bimS,6(l|$c;֏kR5.$"αC#}n8Z*JK+ra氱I.m}:j:OJȬNϴs59SI-NE:|qڬVs>Zq Һ(F󿕴X ܬs v檣)Kv**)FOUK"eSGٮX_ꄫb $]V|ٷ#>djNq}""sl-hFczKJ3uF<*ū!Iªv#VPw`?U:sQr%3]p̓^U`w5XէMsZוJ)I~u1ossiJ޶twFEFn۸^{ڵ\#hQ\ܴrWrY7Ψpbt?jHFet`}94hn.7@qڔ {} tQobhǞ'_h4d\vv?pyEKWk*q韛ވRKQ'l.^M *~~U#|ím͹6Q3P>FNv^rZ-OɊ $=<T#Ro]E*˕mYOH4d"6O8>f~Jk)nx= ljn?ҫ$b>NH.َ2,e+@w]Hfz}b2VBNqm]ŷR8 \ZW[_ue#)8''y+j=5*ԣ9%if |ڷ*/-6]:6Ќpe}tgUU4kN[c6VoHniYkU'RH9'X]cr1t#B^~yQ gT9_eQ9)itLʜ"nX䑔1qJJjI]*E;aO4JU%;݅gRWV *cAK%3m^@'1T`{[ikԹFR|:{>+iipR Yk{irj(#LeR0qDF㷘\Fu_-T,ÏyRi2*I_;!. YBʬ1/54|2:pjݭ1xw%fcR@W#o$]T"OZRuDk'۠>X+۷oN5#~(Ԕ$ቒy č}o$<-H;qjaweu1Z^voKK6+`"N3q(,omEQ-@2`'݈dy0䮑zr|B3hB`:cuGܨDZ2zkbhdH?#f; gy9s\lاWpÁ8Q،GwmВ )&,F gj# vPN-uZ[ 08ߚ7_3jҬt};Alp *D7|r@z[sZнNSF&nVh~VeynJl8JjMkrķ ?:mb:VS8ƤJ;:-JY;s}VW}:ь\K[`Ykonv=F92CXPj{jTu)$$ʾ\anWLcزƞcmyN}9TriAD"fxC6/zޔOVEJa4!*~`~dU֌+1R~ܚ;UNSrU?je4(ӧEܪ |O720-ǯ\ZC\Cupm\1fl~Qtqṹ.ݴ6o=vqN)JWgW(?#:MZh!U?%# .gۏJ6ΤdXPa|qSoGԆio14}sNr==8uWZ秈jdNvӃ'\u98*uSA2>erꤜ\uQme|j4S"x?jU*)+7sI{E+%ag _*r͵Xٌ{NN֊ܖd8N0ʹ Ꮸ'֮PӺ&^ڬI~-m#MWg3\VX"N7&A4*rU<2*6#<#3iѵ9[Srb8Rf #[|R94oܽa/3C4;Z扝JM]t$dwm7~L~54c.{O֒^igk{,1 jZĞr}y\֝:mt*κy%s4kF{"MJEb$0mGRi&qj6߰Uj Fo1QsϯkR*S+kӱj BWDh;uܐp̤ 7_ZUsdg*5')4]~p}[B82:; .oun{c>.:{j߳ZԧyD٢G,Uǁ hu3E$rȿ&\AS%#HB<޿1cF\eW?(cɭeΔ;R7>63:N;+ NQݱ;W qs*iEOiQ%]e&0f'˓] PB~ʹ2;b"3z~o>MpE%u_KI'iYj9T{B0BNi0HǦ8<\} F_n/)ȉ̻@ݳJnYYx县2L!U.l ON 0IdXbd7IqXUU^cT"cKŖ9wI;sUm1Om#)mrqϿL_gƘU%u؆$2͵QzDe=J}7\~1$rGOZKmFə7ANKMr=ҶZƥJ4ԥ}4g^\#Kb)fi0N}kHSv7N4Z]||-XBAN8U}rZQi~ʽ:TM%|p N=UQIE\e83u)||Cyx_kkqte;B[l=CvY#N$e$K\y/#U Xc!Ҽt\u'iTJJb\(I**WD#h?(V!a q+Nj)-PJ[7mL<^`޻~e?_N:|拄*i $XIP'cEev g1ަ-F*ٜ5%(sdj+-|?wϸ35'hYhl%|e63ҫ=Q")Fdf0UHC'͏y(g=\ݖd u{Xn=2r:zT/z\J"H( -~pZ۞IY˖wqn# L08Y_n%э:M @G˴mtu>{9SI")'Ig2s8Lan7~]!lv_1Y ^x>>fORE٥j6d#et=_XN;jֻ+w0#>XL g$δ䏳w (]j$ۻ2ϵ܎YSI_̨Ӎ(ަۼaUU[&#>?)Bk~ujEOOAȐܽ|W3`8ajI eN7(o,Hcڬ>e-/mBNexY>Kq"AB{QYfrR"Qnݼ-DXF?!OڳyN^j~vCwAr|oAbN4g-}M[xL'qϨ¤^-H[ߧQ4p0_,-qlTҏ:O#w}\ۋ at47+NTyp۲@l} j)C]A3or֋3<`\:zՍY{HlUEwk"|,M’.>Sgѵ{PH+dz.9&7u=뚤i%cz|w$9Lq=GzΉSN]u'Ν>b~`Kcjֳ݉Gs+RM1B3^;W<*mݫN6C dNCur7g?Ӕm{!l33nt{zv8ҝNjWa\[۪ڬnKgUWcRP؇54/?/#:wډOucIr/51c=2dCBy\rY8|gi zZ[vcwռܜvc)%tz)}ŵ`f=~QjI"#j]^E2ys/i9SSbINJtZIdGʽ6sڳxqޤ)lK((sI-s}+mtЗ(Zd);Ct_̘p8YM:PЪ^hu*W$2xҹSm9}iނ+|b} d5QZ~b9*8ӥӯG`k–A v cz]uӧ$8-ERE6"XnܾJ1ثn'R5${/]QJsVA#Lvz`{WBlݎx j>VHfgH$d jh[#Y~~IVx5%nЍ:tRͥ$z_':Or?,16 M)(ּp#f3O˻=:8Ej$hua}z#IT]K'"i*WvǦqG^J$n"%fP^sȩ^*2}^{8ϖif\ggSԻ4TcN)CE&%>6і<KnLi{GMz%͍ə ?ӽOZdӯS彯ܐyi1\׷+u'ME/h?2F=>3P~z~?ycTMRPt&֝\/-~Gܫǹqy稢I);|GQb So IMѨ wǨIJ -(NN}Zyv@$ Ʋ-AJUe]z ]1~Oң:̽&966yALq׏NKBhJ*-^D.\2VNqbpjf2Rv#WYUAݾB\/ʥI*TB.rBr8'Yԩ˾T+L=a2yh\ӭTkO+MAxY7; r:'v8qQ{wͷCv+1\#F7M=XJSAU, /6#JW&2W-innmy^)]>F=7;C$qA}`GS?ƞΔaδnV#;s>X6pѧnˠ˯:51Y*{tW hѝg*uJKMz6,m̭g?ҸZTjI5{ѭB>⊷g?y7)WgoSGZj5+^j-AIoVqF8 MWZ1Sѥ[19QN3׵gNJ*|DU4rJL1Ɗ#v@*8j8Dʧא\LfcNH ǹ>sN{u+F({z%ȟ7Rث-U.㷦@¶mg?iOމd(řU1uִ񜒾cjעL2r~bsMT:%NTڳ߶"*7mR[!;Ns]ewcR>nՒC s,e## 1˵i.I](֧+rYk q&9cH*Sccde.WV41Q EVq}k+aᡝL?7QٽUӪ5ě`TsN4v'W'ȝbRUovp`{=#Ýt(γ\DͻU{Wz8Ӵ:zqoTXi𠜶N(}5cq=lj;6rX$g$A 4m̷"*VrDE*[O0tSQv1%DH O-xߵ[2:򵡤*SwБ ,I 9Sr=CWDiQ`Y$i7f@ϻ$p8mJv+8FVkpqyDpF8Ny✔+zppkZj<,OI&|Ȧ4 啦V8挮;ƴiەiŖS8 6dgƴ#-[65ѲGo-@]VBpGNF7~"qe q177-n/W6?uF4wON!)VߐSg،x+hF]iR5-DPlyW"7*|юsӑZT(֩%in^+9P#a#nMU,32\ݺ~UKѶ䐥=G<[K|?328tFnrN_Wө{5 q$,) 3ۯtE=R*N7iXq[3 wd1?S4gR4y^ܣMjUR#&wtQݭE.;/\~ A:Dz nӴgdʎGfmŷ0 WM +6ڝJ%-An~Yo1~5]Z5#RR؟H (pe?)=~HM^~TEF]ͻ',rxNyTRWRdS"\\{p ǹiZOrMS}&73(?ҝԔ-;)Kظ[ 3 %1 팁=:.X8Fbb,&Q>u)THβ7/6;,A/'H'<":ҩ*mj!ʆh~̰pGc~hi$њSFRt \΍0 B$ g99֊Z~VeEqڶc5k :Eg"a'ӞkNZz4pG]I k4a;Jsx=R=[{} M4T?)qo#d_s+huB)4%I'ʧ8|ҨCJ)ާBP"˖u{{:~Bĸlv#ae1ÖUP9QSnF^ƣob1E?*OK83ڦͥ\FsxJ-N%Ӿba<_?C9x-<1f2c9rr{s3ںIV6%yK"u;"9r?6dRn|RFk,HGy-J3Tkw;0q掻[.m[")ȋ'{h𛈥3s#ƍTvdwQN>^Wwױful1;T#G:z4O'׊R^סJqVm>K`f*qF+V|CUW4wƪdL۳6YZfhInձn68 ӌXԥ'}QOu$Ci2kc;Npq?^ԧ)FWG-[JjZ%)wGV=>^IGt(ʭ8nEiyYv؟}1=8U9]jNJV[)ۙg t=(GV:r YD8J]̯dӚ>i]NhZkېT+d;{TrI}b⚱bG]ǴoI+/EzgsWR5#z5z:hϷ,=3qEHW%NkmV=Zt6ZKvhU\r?>>2}.8z*idkc39lk9R`Eriw4ʟ)zO/2^WGE"6gdq巖9\Ǩ^d/iοiJɝiݸPmF+Ԩ;FTb%1Yc\PF> jrPrk]=CxkkЧi'[U9Ёڴ~CZJ4mgo4$2yrL8ڧ>Z)T4zjeY{OCd-ebjT{jܲ_ ʛܾJo1R7aQϗq9]~ʧuQY5Y|3r3G=זK sbؐ@bt {\aΪ4k8_tm9i8?9+*t#~L5au>/6ҳ12oU~FV#fu_ySESR+w:lփn;U>=>sA$Nbr\s/x1 8S\I_gmzz1k xh2d/nϋIO#QJmlB{E(Ath{8駙3gI4$66Knmsӭe~{Lghj5B*R'`Gs].JاztoY;qRwN02qڦ"uo[4g%溑]vkkocN[bxxhG_ʜ)--ׯj_.",d#r8N)T>^YwاEM,ŵz?wt*Ɵ,Tˣ4qQcM$?3BBkuc*]2=9֖CZ@%VcY_Z'Ztd"ٕ<4FUR[${z&IVUKI;B3}0OCV5%#wdzu*SGӦEܭ7NFzcF3䝟Z5kVVi܌iv壴c;yg)^o_ Gا{=`LȢQ^m۩S MUWI4+Zn:F~S9##N89/wˣvNߪ؆ݶhoFI{VirU)өi&_BWV-+n:/9R2km/׭CO+ow0aݻ0T7Aʥ<Vba<#8.hɩJIܰ_N0ot ?-ؿ/˂7?KmӬPmM&cHeïYt8py"k q1sɭJ:եN%)3 D1 {qZ*\IԊ I!IXܮr~).d݊u62;eMe9]Ql)ԩ*6,A"E^w89U;=wKp.B-]x,·c#NSٌgIjmU+kl^{F{ F.Ty4N K7E ?6I3GW;9c]NZ{y&3ڲ@ۃi(v{HS$Gnmg)q槑>:*UPԂU Š{ZSSK^I!s#,*"`-(yR\'+Nr>\たz.X]NW葮L{d>8xy]uS(Y)aevcܜ⦜y9OEEB*$9=h4bԶGq*Ѻl|ۗv9}Qc/z1*ݵGvzxұR] b!I#*>i\7QPhJZ5xBCF«Y֠.k-w_CĨmc[[$ānWane2ݓS]6xÖN_ncx!gU(HW3)AŽמ}+ɩ,6~O}tpz?':=+ǐ۬"2eڙ`8@*YIVq2ڕ/M]to[md%! 2'#S RZ_yO.C[K~ѽۑ\wb𵣭Gv<\ח;"RUU Nq0ܱʦq$񌓤ed_,)ˎ?,+7349j`sEZ|#2U$۷ =~Ur_q߮&!A!G&^]VJM;?"献͝ &Dd#HF- QWl|ˋ٥FPD =I,,^^Z mㅒ&yʖ`Ȅ1Sg];m^ipn|@g(=N:U J[+EH ˲o-[1=xQՏ*Mo~}J ?}cO=k˩ JGOiN.N\^޸qҲ㜕Ieԩo#>qk3NX]X].t/Xw8SSJ߾ zxQ ɏR6+2[Iϭy:4캜ңRWf93ݏ3j+n\C~W{k.)?^Nݷ̸PK$)0KF˸\eE%2pFF!X/R6䚉SNk +c\3+##DӌVչ+/ĂV %;Pnܟ:TV7s<=Jܡ5*g[=>1:z%Tj+8;F}si+5oc>7£]3ܯ 6CA#XΌaOiV>I|>XV5'qXQ.u#GEIXn8Z/_4A\I1VzqeRKV jz _oܪ11qQ*u)GT(ʛ"g[Yn޼c=sX)FN718ԭk4I3(V1&oO\V_q0F29a,׿Q]m/8Ƣ QH1 68X9S֟DN^[.3#V=9='$doaRU'+d4hZ?5VAjW`µ"B8?66 tHvgvjJݮZk)7MJLmPѤxÅ߰ZQE+#WȫhYe.pyCqYJk^ޝ41:_O,2I5:Գ)&<Ʊiz:|Ny֜"ӿT:%@DwQ׎49hJ.-]1٭Y+矺09=:ۗwSRkS%52,{KnflS[TW.ɧN=Z9X#n3!nMG#inj޶q"U6LOJ3(} mF9NU&|m%o/ #9u<^){l;lD#КN=?_ `k,`c'$0}qu\d֚~OR!.Mu+X<[9략mϹٯdHڻ>~:kJ6wTF v/?׊t\y [՘l۹@+Ӑ8aSJц"8/Gő3$}zVS>uqQS)zhG#2j ۽;ڱJit{KNILhIxm~bg̞ʌhŻߵ{3$,i gק>V慚l<0u Tۀ4UVVy.J1gw], EFge]εDhiRgo6\KN'O=էNZjKH֒=$jW|V+fT*Ȋ#_3lc\)I\r7#pUI"x~RN1v 4ew6b4 r7`GBiԗ+~/R9Dk)#X.0}y?52TcSj=BkY&NF+ wx?s*ZwS~h f&GܹycluVr1AstcXEGl8?:T(4gNF{.F/'yN[nO^8R^KYKs_4Q3}*e/mzrSVtHvGo&#_+eX UhSnvG5:t+{h̰ffܷ&MB)R6dۤUes2q*ε4mj%l֚ -%;2XmQZʟ+XÙԜ^[aDKOwT}??S qu5~V-G!c$ҭ|DШFK;缰þӚSN)=JX]n f7XUF2G˞WZi urNUuL"і]9k:uVJ(ޒ],^Hd˹8<Tm}Wsє8m>DiHvPE9'h8:97}:2PM˨"2_!T9~Əhw#Kz2I~8 ^qJe*6Vk:y--lG#KrND$F8ng+}+抲7U(RW㥛--±o8<Zp-7.sp/?2-MN6wvXU(ԫ̥ۋhch ny8$)N+G)JI_jticn(0x98=Z4e(= 7/r.]'n+8u"F3*C%A?~Yck}^1M[n<*eu>[`me\<egCsK[M4`)Gq=~æ8IYҳRmƦ^EIVmUpKsǿʪc|wsq]II"XUllw?Jҕz7ӻc;a1m쑕~nr `vkԩChJ\h|εk`2Q)N)QpWr) gYL5N1w%G*Kً-{Uo/UOGGs sI{Z/nFq854yjF#Rm|Q݈RV+%T6qeF--|V%&6HyrQOelrae(C^BeLg~& gW374ۤ4s۷pU>?u]NXҔ˿6 tjѾTnmoC?J~δyt8”U=ݷ$B1{D%f1}-Gm0m'YFo4B)F45)w1zcIK*]b5 /itY߃[ 4>b0翷QRU4Iʕ?g0ǀz`zUJT.%I{m$#o1 ֘xk'k(Œzn }~TY1x'qIjTqQ~Z-o22.db7?eucsϣ#I"T9cF1B7 s}~4G*jRJqvrHE%L$޸qּF+7$d Ev$ Wszp{u==ӲEF?䒰C F2LV҄ter9s-WP2LD ^5;M[FI/aO3ff0G$\C[F,da++>xX'Yxw]Vqp6NkTp/AO0A$ylr?{ r1]ThTJxʑ7F'5+py{L(:[Ƞ |9Y^QZKԒ9XCݻcy UPZ^4TБ[LBnbȍA׵vP旺Ck]5n%?>cڬҺ#*rGU8Jt5bHqryZrt:)ѩ}~iO ~K&mX>ny>RsJ%[X1]R@U:4ؤ>XSY~zUN2G\=-ڐ }0F:$3 4`Ji+ˡp P* ?jN\eZQ]F:7Տh٦W61yq2'h'=jڝQ%v %\Yڪ4g*{J2VF7s Ecgy(+4(^k,k8]{sR*)imB"Xd;?>(5;$SһE{eU*n1Fr}ɫM'rʙ~btd5e8)֍7.X0KhGsA=^T7•ޏ&&-v>Zg¦1Mzﮃ?_0l۷ cBZxze-;=ž9sMW%IK{y% UԊ,sWfB9kx,G9u{.(-G8iLqWoQEJhޞ_2eVU%yGndn>W8A}k[Dy9)Iv%q's7 Tcv5}bȭ^TF7K%% t$?U^ ׁˆOEG*m=H[IM=*d3Y~']> .|`H́[^F1oFUM9ykOs0H|玿J>rꉖMU]wJC CG'iG Zm=.1i9RظR4lqaJQo-ClF+خh}p7|@Ǹբ|a.z֕Um +8泞XU1n9</Cc){im;klQxaܫ$)BT-KO^f=ablֵ#Q tQrJp[I. .n3z*{I-ܸZKw|IVMz8l:Qӫz%fګ,|H08#M9)F%fNjiG$fe $8cM[%XibwZ#P6, f-UR秅ZJor廣Ȗ+IYl[Τei;-śԹFDۺqE8'ZFoK"kKcY-|vYU<9_J=Tj&cG4<1& n+98JeqRIEԙ'ߛC*wB͆w9YMnjkr;ȝebP{>}j BN2RU/-չo9r(F}brJ&hiۮ-J6WqYRNtqjo" $Qm秨ugg+5?j &$$``^sډTZjmrͩ@OʱڽךZg*~ҫ%h%悊[,xϷv5(ys,?Amӌnk5R(]j51J$mc&7 ӹnonU(}d7^tm6xuQU=y]b*$,"fqZ2qҥ[8;Hmgg?n;I8!$xb|B\Qed95 OW 9XGQ9Q:EFI5ބ^$rq_ވڳE(֋bі96̧ L+#Q5hzHal槛%N|ϩPG,N~֨P[|6v?gyhgB/6??c){E)Tgk[s6u|>GxۓgVSʧ(ӒKnU|yI?1pi{{z\T WʎWU[BN{c{;C8ԄS%[#/̻{wUiF:NR- CuvۈdfXlGO~=FNЊVYJy/zrN[XU#5.X1<b #+ۆ`1uA]=ɬ(˟Ț<+B1Qu#5*Q U+SzJmLԸ{;̞^̤Ͼ9UXFndM]\7YvN:$;{2R[Fq"&wqsNc:1읝֖~e)E1'T x#qcNki-`򤴍PW1W#9IztiR_^KY$ުiEkr֬[.eEG),Ó<#RKgFz]IYQwWVkX^JjߧY*yұQpʸ=Q̰}*xi{w憴l{Xsn/udl, HVE<@?+f;;{[{^UO@+oS7SmC}쬬7fEq=Z\vfl,4K ' yl@=j$DMe 'Hee4{VVS_ o&`u׵L*sigŹ=^7øs~@^>Os|+X­^zܱܶQ6gGagmɍ 6׏һw%)Iڤ^;汭z+D9QN7,'XIxB>ZwD}$4UZ۰8CxhǙ3ߠǦ+lEOyBkEU)\M[ٮrJ_0+pjieN*.qzwb(vUB!}+GFtbR#n#c?T(IJ~ε]^l2J72?tԕ:kUhvw˒nB0'8_SX{JqmE^Wdi$m*Sֵa{I> 6g4'NYpJq9{hjpt%S/v pNzJU%MSjta)Jz]Z$YD7W.caʃ=Ң<|XKޝZrM>?"Cn/ sbp@9 N(Ѝ_rN,4Q\%£HKHX} H$zc[ԷBVj]?h\1^z_Jܲ(ӟ7-[I,fIhcv+VNzIF1w?,,X?*8z~cМY>u{Z.DUI~X5Hysmc9-)'k޼(n {|ت:yGQ]oׂx؜eKUH_q ?NiEUjk Ox_z]pSZВk&L8^yxuq^ouYʛ ~i,j5sykd6@} TW_3Z +[?n9Ӟdge)t]-E0FУ*n,e9Rv_2h3&O,rIԋT!CMOކU#<ˎ:bhkeUX&U1g9%-S5*\%UƲG"w {c+{Jtطb/4 y6$Cۑ?gV/E};U]WRV`!Ӥd$f_8$g#Ժ~&IF"? ,JC<Ǟp+)B0MDiq(y?c{ u$a^GxfHwMU;x{:֏hZ4A I<1x28A\^fp斍h!S,6~O3XI=$Ί8iUu$i".I q0C #w𬛟3KZ~Mݻ=GٞId7=8?5i)je,E8E-tWchEl+z\R1H.\Z'd,%k{8+&:'7&t`fFqAª1)'{\)bsl!vVݙ~]\a-3(~ZQ"eބwnSa0^N=+ӔتFM3ѳ'aOT1oFXt&a$`zuEZu]˙dUTz~=6Vs2唷9NrU(|.Ҫ;rH΢w'X;%bcQ__ýsG)%`df)2ٕf3=GRTzFž) ve=lٕ>jpmi}>=/=[#paǷ7.)FHKaoX*}t˹py`޹jTFռ'8 -.qr-ЅB\ާ$r_[y:o*M輆=ϐ(HY2p=:X|IVpKt~e1519_b3FpN+擺W0Gߛ{c4,IGˀێ~*nSn˧(Rn. ]:]I%ªy#j1p_JWI=#,El PgNw6̛m2N{ӝjғTy|#Nybᳵ.9W` ?Tkkz޽>Ap(#]%Tt$gך(#RPuA< ϹbRpIq|tcFDVKŶGk8GVfr kU[P8uU馽.oWu{a֦..۶ΩʛR[hnύbhpg?6{~jOK^Erac8nb2n*Iiэlz茹yc}ݎ,Te,T^khTf!J3u>]*2 ,ЊrĜMKʦ?,5۞mF^5dv)Qtkn#劕,[#xԬʋz<%8w1M?\`yqP[3roN٬p#>\x8P?^=lև7(v7#{ܝ:Q;uѝʢtpyro }XyOC܃k9TOv䶋N;{9{ne)45(;=14sp|qzVԛӪ;:۶Ī3m78?-tB2.d/gNѵ$BcY.,L܎9JsZ]iC騫k};ySVb' d֡d#f+NՕó|SWq侢U)heww͕e`zJU[^Vmw\G"ç=oT->7kr\KŤhc6_XoncʕzJOqm%ԒIHv/:c<_Y哦o;\DbWl'gki/(,Sڭ n23g?w'%G FTj_]_0XZH8\:Rӣ$_b1YEsj_2Ceqi}ў}s9Wk3hVbQ݆Ḡo`F:ǵ\h֞9}I$v+#~j]+}嶆6TedZFpOJQR}J-X`I%r=Qm9&t݈[ &yHvvcwhMzѣE r+vOzJWNYQGDem 48iӫ)/$HnUUm X:3*r]Nű,LKu8VR+Ƌ6Qgי2bYv.9Ub QNaS!{^j^62:|QnT_)J艮Kh "`?Ʊe[QW̋[M l> 4(&Q'ѱO(o' _,O-!'`rϵc]DqǙ4I,JA3\ qzoԢG$qۯ[f^Fs뛛i$!dqѫgqfyrʪKtY!kkSs0IW)JN U۳9(U#g[>Bve`c˜_pѣwgOJi)iB7a#w~{*䋿SZukiM;-m]9H݌ g=kJz]]DVi{wy;4H#s}^Ҝy徶kb9+}բ+qs3:$er~VjNصFJRu!Q82$>c Wpqߌjƺ޽o;po ^u.w$WD_mܹ*sAUOtO7߷QGn?08;~~.W(JWm&:8cg~Sl?*Z4Sa{$fol8{W9Snۛ~JNbis2=T~ҵSr_{8mѸXK!!f_~ ަbQm2[m&$c=z{VҔfMqN&2I"ƻzdU>]ۢ#)Mz<ۜ7{WBn5rkhM$08 GQUyUC\W?|$gn~\8qY“m'RHcB+&vlǮ?*yc(Z= 8T5qjdX"wS.J:ҦocT^.>AHD[+fZN~rӠGrEo#4FVݖ98ʫNi}9k9FnM,DWWeTTkeU*Hg n13ZĎ3h#4iz#^Z#&`x6cE0 yZ8gNIy2$W1%^dg$b on[2ıiY#n#w s2u3Ԅ/>n.]H#عqϿSP(ؙTu#e+LÏ1H^Tbyo(=v$xHxEmw0K};U#S&6 ,nM"1 =3Rm_dy\ѭe^cʋkm|ݲ}IaRRF4li-Kn[4fbP P0=ci7**F׫i`(=C"m1A?7yޭ(΂H$"U\c=;(*u"s$6a挠$P6ngZ}S/oWm% p2_9NDjJ>cRFMa6essGͣi91[m|+ y#f`xϠU9Z1J:: &Sv>2qyc?vocYF]-~AћV23`]? ǖ0tqOO?&UrJ {I v^{r̜SjӥhuJęyq?ztKٌcm(*8$ܓљִiV;nϛv+Yv^FQJ#d9"Hm#g?w}=sYԎoS*QWw-#ne^BǿL%:59DY[;\maӚjZhTu+KTCur=ˮ|WxA[>Q:r}cRYI(?4on%ff;BBevv9@TӢ4R8ȍDB)ͅ''89=e+Eosk!Fd1]^c(RUzܐC&-i6vzuA\2}M)բ+~$r#v¢ bsJjplC&VUF"ݼe%/Onq\XC?;*Nv]<̪,7 1ߌ4)jm-~5)+d6jmUeEenёnG2qvNE귏_Oi0'TvS*mkкe(FDRgqb3|r%TSF~>W3v3Wvm/b_*ݬ~_qw8`yyoge1B3H)9sϾH?FT]m[ʵ(N|KkhWܪ.2ޙ]QFqmGW}t8%qi7}2yMǞrʤ=R-.K%P dX+=__έ*bѽ WV]yFAW؜yuaM+nxpbJ"K!,ֳyɞ ǁqֲou'Fz{8[Qw*'OOj{kԌnتqG Qoe|NONrO8޸*a;Y_Uz خaXbT csi/c*F:Ar);XLwoP:p3{wRH"!Vi2<{tVTdOm(^x -Ux$g=G_Jڝjz{k]{6t& C `Ϸ9l'kVi[e͏qr3e_kI:zg5NT$DV5tQOkfؼUHB^%a/%~^:+Jn75\V&QpwVدiYT3&<\,Rk4{`1GU;]098Jptf^]O^4{G+1@bOI}5s[̺tJ:uHh*ghO+|SW=5*('{G>:xi}~8{uwlcd+'E#F2YhҷFaY|YWskR{[NGN:D2dYX5 rNK9Y-?B?QZIwbͺEqv_-#O?ֹrEwUhضjgXnyAG\[ԋKZƥHF_"aĐF~R6 WJ>VOڧ抧y+{Io+$j|XrIs©:Ww烈hsJ1v^8H[`d\TMޜ9:T8Ǜklva&GF[Wp;Wu){:n.^o~G~F>_pF#Y70ٌpO>(ꔶܴ\i;kxIy6)ڠHvƟ+]#^.Ko~~-SH { Q9.TjSD۸kxci$$!I8G'?4jOWg4q2ڎۗ+G$710vxQ'$)U*]SI3 &6=*z2iu=ԗ(%"`-XU'vƔyNiEwz(>1gP?oN2QȵHԑSʲY7:?UGwڝ/g/i[oԌM2PFbrmةԽMU[EXH(q3>TrUg,WR%;ZiDR(8Bg*ïڏdjRU۴lw94UCtT̕`1TYJ.; G Y"7pthѕ[ }s+yM]sGVs֧YC M%~d3amzQw;)J.ԯ+hf"I5|9Q)=br=a\GV~I(%Op Sw<-&J*J-DmL3?cV</i|wD"fu]c+EJ:rY%#$ p}LuSLRȯG4^e7cbzrHTt9#.D^?1#W 2#9ԨܵM~Lxąff]ys}*~rXpFBI#ܮFӯkE)>Nfߘvݹx]򌞾ztKTuʍi;Y.[kh~Ű(>W,*/iRZ~KAO^pU.ZpbrʜkKk~L_ tKgsF}kΨ{X짊V F-&Q-dx!7nrTq?Nq]CtOdʰF:;ϕ͎;W,NQ{ĩJH}Gr$H$F;a}0V;)5/k_D#d66`g<Yb')r[}==|ᇌ/hH1re hnSH娓Z-fdvx?'?ySڹS~V'W{QQG:|v,fex{ڸm.qcu'L>b,|7?ps<#M2Mٔu2NA&ޙ{WB|T(/C-7,Ff%['ӓ۞1($:(ƞ㌲N~Owl8_AHn}>h|Ae(HI;Z1',:s>/N]Vv{=W^de=)khOUyQsۙ'0kI aSn,`c^km,k[k=Jt- {:$n-zumravq ;_E*?bp086g۠mˋtBa 2b'߮R8SW۩&N;rT=?ȭƍKG )Բ{lı4kvlnj0Ws^X+yݏ\=)EK&%Mꬭy#=1Yg#ISv{Kmo1Q$z1&/%dS7gj\K~#q]6!y2wzQ;VmFRft2D(7ñ@AigR.)+jӌQ]_]M ΁RH|UGϯyd^}Ji(;߷2O&̋&G=kyBW }Q b?:ܱQߒVa*<~#y';qk%ROLҩ:Ϧ%W͔2nO\rJ_.8ҋrk}r:kJ2FQhF d˵2{} K\#RMg d_/zpq[F:*Tmͩ5Hgn"ON*#NU*Isl_攵^ȥRf5b72nu_=VXja rrͼ'?b*ԧ*|ߧ RKevk~9G"[]~i.|1 ysֹyieg){ohϒr}OD)Tݗ1p]w9K6Yyi7qvV`\ [ :1i$un٫kڭHwoV6E[3+($i~Nca)7G}G9F_M/9dl<&T~Ѕ2Knv,w*ʻw{Oc(uuqԈ"ՈɖR|yLU_NRrZceļYsz8E_Uk6oA/PiPzcrὥ;Fo5ƜZws1 c +#*-j9JRvo[ Vfb$:uZiY-|3DfXFv#m 'W@&~cx:~4QTk#E=tqZVW"ӕ6m7J*ӊ;VuzC- `V4BZSoe&8yI{M$hll)= GQ!徟'ȿe)YzCwF_j 헜O׎tT)ErF4kr"X~d}9+=9?k|&rrUVޗ#YygOnqלUJ*^V.u+S۫"T)=ې8U3-Tæ. 3)OwϹF"KhHdmTL"*q#EY_]u}[N+:cƤ9ԩ ?xwmNy泜*iIl4mUE=](o\L*T[[lklq46d杸#ߞ9k~_יTҵ鿚솘F$ O5{F;hmK6p F3Degz%b{ Ux 9s)TF1}|Syaiʧ3wB[̠,8Nmps5EJc䪋a-aIAhF5+iSN-ŲOqq>XLwU9i_pԧN#ux<]4jUz'NTeSޑؤ5"VV^C\\e(KT>CG$RKY/sI'㧥g3̎jnMmr9S2/sm_(~YTrV,[!xvۅf9Jrq+i9IЄ{ RҺU,sN=8-m5!;& 44$"L]pACy/g5sՍJ_8+HjYTr܅[p^!!0P;ױS.[ CBR7Gp?JQ~PrKsrHYc]wxp:LeJu]?Jfy=H&Ma09Nm<ڔT[QEBX qn^]O4l=M#Z]ty'p#qGC\єES*NhI{6rGQ#yjg )^6(#I9ӕkU~ԔSH`gEmVfiԐolz⦴' H$ 1F' *vFsjx]"6 :~䗆͆*G2^(QP5'N$Roz+Ju:P"8R~b㞦 N0 Eʹ7|ˍ܎O= iXT⤞H;ynʿ)׏ҴZ2EO?rC 뺹;Tce=bݑm4oU°nK%d J\ר\w-WNUR c|sflʅ8qSSwes/k_=4romYFs8{cEh4z5(6YgkP,%B/syE^Cݯm3Y7;G[Tz~Fx>iͧ}n?2G#e=5SMuMI*ϒck"w^޵F5GʣQ5˥Q6KAun;N֘XK]Qmj˻@p~bOI%uʚ\W4`{xjdnqA9~|=i`Ɂ*2\X甥%-dJ!F?6F>ésN"H)s>HD3K6SE ]CڷHiO*Ie`.~cz;u6(I_6i0G06'ɨ) 9~]0WU8Ǔy 8;s^:~\pR饁 jev)>_8x#Jƪ?`īG+3/ۈJ2[ΊMБ/9_˵k;:?QhYmA{~>/g9YG_'e%o 8Uf䃎Fp8zF 7 ->zhL͆ݷ;r;gtzK$I hT/=T{|NrRL[_vܣZͷ()1>f1.QnZ Ɠڵwp ~ήT/TĹlM7|>o}\DP n"imvŸ=JӖ1Z6ݼ1#xq-3fsCT8~`$-4rlztIj5wςvI8;ֲQRoWѡ(֪ 0ᙉVfcldE8o[ek Oe\mr2=kgӊqANjtڷ] mXxAQDTo"ԩ9;!5(2G$tsJRӡeR軇(7,3؟_Jz7$MiAwWP!YTcq*ޥtGfGţ2/weUW*0|{/"gfviFk۩<Vle]wUO~q{=(ab6 OB!3u i1)^Iw*>#`0A*tWF)VsoVV] ۭw$;[Vg.veRϥ8\Qƌ$mtS#Zʤj4*.wK7'2$y]W_"RܠĬ^w }WM3HM܇gԑq?ʻp\[я;mo-H<.¿dC$=dҪ8G:|ije\* zʩB>ΚpZ4y fUlˑǨԾFlD 1XVgVTNhOsQ;ӺйXtepcr[KNIIe^դWMo؅-hYԟFF1=OJ?{{8Ƶy%QQV4\m^vdܺ=R2ӖxZnԪ/`֒ISiy".C:]qߚTcErRxZwK~hf)?y p>Zqr@E,D܂[X$2Bmi#jѣ4gk<$bb{W8qF3rwU1R(yN|iq3#W%=^j8yԏ=-jk#3Uߜڈ]Wgf"͵rjjkLi5(YuܱxYR=`mm]: ұbw (^{EҧN1XiŋID$]n<{z Vu5] + [v2 Y<GFsEs(6J~T$+uMXf HqGGp}1\GuAP˯[.l`_S妽!4][ԵfI%2}INJQ~~wR[Pι?ҳ㶿q!6c!Y)- #Ri,?!LX٘6${g/w,y]bX<`G럛hiJ0zYąes#<k/ܨ5osU>F\>\(J=+*\IYb]DjGFڛڌ#{9f2Wr協tg)*rj IP5Č )TQ{-iTMh=4>|%_ru+zo<-/QzyFT_D:F>!n7d,'˪!ZVzƩN-E:mjUkGeKF|Sej4sѧ/i}2ͽ,a~uٗePN9ҫPno#xVe)'_3">y߮H#9tZ4cu\e--e Э[ 5+]nh7/k}PCqGfYUI8;%SDjmR9EUy":t=+4^\ C2ZB\I8w[Ӝc>I=#K iEY<"1#O/XnU!?2GfQ$ rH8'ik(lTXhFNɿйm"<گm}:¥EB<仌+~͵OJnԨR^Z7$A,c ~P*PM8ԍ>iVDGd23/SQعF2 B4q}=\D#:o;ZWi..b(Eć,srzqZSWFTUJtӽwv\)yn8V4l*)]iNYFcsk:kR.Vteh`:d3, 2yaX(\ zq3޹e.y]IiJu#gJƫ%@AZSK9*iY_NesXO1ȌA^kcY}&ߕUw.zGfz"*rN,n2w+`tM{ӳZ{(. k MxN9S[~Og-lG;^PbwOC<#Վ0΅|ϸ7NޙNXi%gy<6m͟`íOe^qhIfGJ̖򧘹Gӯ54lt0awWs#K3Fvl ztXԧ GU8aB.j#I=VrrG,nI,x,Pyc HVՕΤn"@F}0;#zxȭe(*i=κ#N1^)^D;X1q$lM"uWKvnb"m&J?Q7bR(ٽYrfX{㏮iK1\ކFK~îU&H/>v)}t.ѣ.X?QBIEͼʠUQxƳSFR$]B'H㴁W\ ˂9j*+k%8q- .weew/LXYSrL[!9$]_ tjR|<~DOZM㞬},:+֬nW%U.1kVgtv5ҫq=jpi"tZ&;nD9Uw+p32sF3[S):}~3*;H&A7@?󮏬{Fo)JNsh> ْ[=8ѷF~=.jtӧ:88OВ,CV;Y ʮzu+Ԅc̚¥9JN3{$ͺu=Zڧwt%4d[[yㄭ2ьZJQMkaG E]nKM-nۺ*'֗jp^큙L,Ea?tS拜SvkmɓP$Bd|D̅3VJ)kDlcryr1sD}*Ww[d(HB۔>*ynP)~*v]Ǖ3\=iU%źE+~b}Z6:]  \I9C: (r{zƜT%%tb$͌F}d c:nڪ09{Oq|cv{)#!Pb۳kXSq2U7Ru)oqQjRY~l:c8^NnۭHSL̫&r`Ip1?:"NRW<-9Tr&YEpE7p?׵y]tJHiP㒜=x[CYrhTOKmA,w3 M9G,"K$FFH(x(Qg!Usm 0e541IJ"[yۥV_qzp*mR.䝠UId9$iQ8ɻZ8Œɘ{:&Ыrݻr;n3M630I;TG}M;EW"Lrfz)"%RU$56#65i}k;6eSW+n"aȸyMZ{Hotc4q\[mgb`g|I[ )xtj6xLķXdQX_QQ";*dO~2yۭ)}M{̒vJTԵfy{%k3e.T>EMh&g,O.FLC0ٕj+8'؎yTXcZβ=k#?+Rh)*;?1E?v)9EXx>)I'0WЖ~]\\Ο%iF/+#CnY;\֩%BH.OpF9|/JWmt-kwD,{@¸R鸣 -'Q?r4V $f98$?J4.~RhZJ}H'h'_v+o¹RzOF7\t +d.y+>HTIO~k2w؆ F;}Me<<`6tZubFa,2fLi";qzJԎh^kV-dP_RàX ZʣsJ'؉@.ƑC6;S^߭g}'m_gv[뽞p5A>*TOCTpQ^0mA'+vpz޹ԥS ahŹ؀3$\)Gޝ:tQn+GIO1p{d֍9>kNjp} xWȷ[V ˅;n=+|;jQyO64qM$l|mʯR:dW RZnw.e䜔mȒe3,m E9>i.X컅Ei5Im-Ɉ`k:UJ|,GA%dMoXS+\fX.5g8<({oR|Yrݐ\@Fe¬k}<5TU)ѓ|Z;NӷC,1\/)rBskZN3IaWk-B&qP0SSd_>c*{jq5^uܳlGDأc4b^FI4փ^ .G?zc=ވɤRߩ=PoB!o=1ڻ=y *Quu okH #Emnjw==kiFus509#G_2d9V"I6$Ly0pHPHrS-XoNH[s$jѫ+usCZN4O4pGO@PpNx0;pk/AEޝ˥#M4尶]NPm`w(QAs^CNrӧ&X䶏p$8x9IF3ӍA5t~-^?1J9&)KUZ>ƒN~΍[۹'nB~Pske(<Usvmpi sFۘ:~gkN].Sq|b8"ko$ ˏ_ccKZ$J"deC/=kXΜg.E˩"Y\Ol~f#yp֨=}c7Hff gʏLsUNtа#wq472p998jiתm}?o @9.[8ʤZS_ȑ dVI_i g.X7P]X+g2Y|f*yV:LNuuӿ![vSon\dފ +sMS|ٌ0N FMд'kcFǽm=˵Fclq*.w*UnAj~Sq+B?w61cdf;@<?jnѧR3nlY<2o˵uFIUڄ#,ҫ3[^[(Mଝ;rW#z}S_KUTH$ϧi{:jWע6Q|˿B)-,"vVѕHs$Ŀ 64;l c޴QEߡ1՚Pi$ZK)qr6wGI~gkR:ڕM;P ja1zVR%˴|˨KfI]J.P޳ov_>[y>Bda QAۭc*l)ʕ |[mc\2S;zQ3^M8̚X$as;P=G'ߊ1 |ESiT峲٢bIZ8aP0~gg9e)Z Ucb?)$=qWE:ҕJnSvkz)#ݵNw 1}}zrM˛*2%f9'yr*Y1JPNRRNCOhoI1_+ d >~jwotFu7l[{xf#s⧓n1(קl` H[&IOrȬyy婭:1o%a UW\A*|G$ƕG{v1#vїhgYT{*HH9lQ+% z*Ԥq8v9׃ӥ/z18X.,}_:Gڠ* 0~j#N-.N2Ʊӌ|sY{87iyeyTw]JݻzģJ0k;[^t-qmʻXB|4Je-umSӨd%Ϳ+*P*kgӱkųm?bϨ?_\97RRm 1 n#X_-lyJ1K]ͥ5"hXeGH5mlcTޭi6Ip_7a)4dK4Q]ѹ|+<(|_+*2Rf_cU5)ǑDb#Z5Q#2?2mpzw*SeSE$]Fܪ'2H ι/iL$=to#ܭ,.K/fn0q XaJƶ":{Rnww7dW^oA\U-:ʺuju EPU`|??LwͣR8e#'8c񧈍EdMc*nJ7ԉ(W|Us/^3UŒi7Lʯme, #s֩(XΖ5YKNb̬$]0w3(8YVdF4ЮK&c2Fˁ+ǩɭiQqZ=uHb18 +js4VܙQR:1YV`#mQ~`7s=sp/;98SWkAK5 U p8뜞ʦRm[V܉c{5te~aלqjm;J1VXn[[%\SOr>^٥i/u1iJv]n1|bM# F9\#NTט]z[İ7.3)'BM~DF%;̚d6`H!-}3&s{9Mitw&mDFCD"Qztd}9#0(PpzJ9W./ьn%]' -$7;'5]”aQr>b|z+4SoLjT%ex4,–Qmi`I902>y=9\OsT nQ eeGa8zXq&߯pJl6TC6jvǸqʌ#8YQJXF[oQ]zp3ۯt44ЯO)Bm6'II6I ʑd҉U&*j<Ӡ:H 6;Ux֕W0:xX}w_.=GĂÿԫttK?"){sc$gЃT\o}Z qVՍkXUh<o5r|ңFiM{LphNz59FZVWo] l0Mq w8hQM߷CZ2m{?.eLjs!Jrod- ؍M阆9#'5yFwv0c)EiK{c,,2˺ڽV1%u*k}"%rbU#ڍG(y{F-MO[VT*\{`o?tJcNu忩8w]!Y|i#d]J9W.Z^I^'qÈ9֏mn~HxEEgbU$XRYVTSGJѩ':i?멦"B+M&;wp{belI UٌNx> Jh6J4h*z)y7 m=.9GLQqF.P|ONn]%+ nN3q\.\G0Zȧ;ˑ#'p $<Ҝ}mdeNSçI$(i<Dw{өh߿_2Q J<ߎ7;w&Df?v}O˥Tc5Շv܅3 eI!ldct#=GSں%hWtjJVԴ¼*ѕ>){?j9F:[i6Lbhu^q߰F֍/_*g}Ĭ 1frS{lVB)ФɐUvxZ>z:+){:2$ qqyڼ:c1娝2uYTXr;{w N:j"eF!c [9#rKNm~TxVK#oY*>e'izb`{-6Ti΢svQJgݸ܀N?\iʝE/ڧ,fI>a<\R{gȮ]ZW,V 1/1~5FJoTo)];o$rڥW% l8DI+{Yj@dnߗ*㏗%hhLZr:=qf0F?JQihQ`Pw DzU.tgZ9J1 _27hMnӧMiM>WeWڧƺVu&VAPl.9ZIicZu#Fv!XsnYG ź|o;KŜ4/Ʋw$nP<]YaNQ$M"۹sǦ;STfqERakh@6c'GzP.RjZ[#E,A_ݣBn1%v<9-޺G&+. *c8$M8]Ih $ݍled|fE9F] 3MFsqbqRR{R5$սNO(ʮ6+s%~УMW yd5,ˀlt\qnkĚ bݲHe? 6O%MmnN"U)%!Xec`9ٯ:}i}'MVw# i9;'T0Pmӗ//6܎[Hvv^g ʦHSqןZjы["U*lh]æø\\NLuTAx6*c"$3_ҧ+=u=eԴx3`\UQN(ƾZY_b2~ר 6vv{ M&c\ѝХ*kF忙aKьjS9a;}+إvoO U=N7P/;1瓕O{xN:=4uuD6ƓLI+nQћ{8:]<ƶrw'-:zrSu>WNKkm[cON4oG[鿕m,޷[yIEܙn^"28ƔKUz=jT^|ܫ]mFn߱2ōs{7+\G䷜rf㓎G*r]l]Ik3sF8e>5$}uU[Mohm`?(?I.\Ȭ.Sͫ Fk}tu54YYCLѪ.WhyO?1hT}7}<Sʗm뿞쎟Ú^&f]5jct+gG[~>&t~jt4XnTMkbÝq88 q*=6]}4ݝ9I:Z-/謺w~fݎZ5<39Jrmjr[nGȐI%ɍ|뽈 x.1)FR_y']mK $||&cvO|i4ݺ3.#;N9n2c,it9Nܴ^`Qu5-qYrz=Px^}H:wvv]#ͭ's-dod*|}pykPU$D:ܩDÕce+:rs%A=?_1YsƬLs2HYŸhLkFQQ-?e׉۶q5%WKEq2qӠ9Ⱥթ*~ͼ4[o1~u{汅oAN2O8-c89ҹI=.>iK$eVqpⳕ:j,GJ'[GXd.xBqN}^J)GnXe-MQT1''8c3zNvϷ̵v"ea|z ޽Z5ʚIx5T_[>;u~oVL+m`r3+ʭѓƦ.Wi+cJR)C4Xbe T{u5Xi^y%ܮ7nI l~P1ߟyUݩsM"խB[MsfP>K1p~ hʌEIkkiEH>x39^}HNg+&*2K։"HY/^?Oʥ.YhÉ.k]yvQGoH=;\5OqQT[$<8ant5=\2okFvoN\cqޮ1&*UIhJmd6W4J%Τu*<2|UЍ:~MyrÚR^z*J+o呴39K⶝ 7wצkjYUڧ*[=?*26.wmKWVfR;%;١(̓#Ii¤?U8Կ6ʛ[6T`ra{_jlv7d!Mǜ /s5}ܞhƯ7E3*=ZQՉI}: F1}e `'=:U*տFE& ۷?+|:W nW.nUet}+qZ^?6Y@8`HmԦ1u>uYi«ssWSqpw[2ˈ\n!%ڋ,!Yխ e p/5t!'{pq?NOYu)ZoA!yM?*)<%8G+^fչ)r{dF2ƻmtŒj+ά^yz,[ı"-Sjx:jR/好 }j0P]ĎKhT d ܒ[z`rƌ]t{l{(FnnbUL7̀t!+5{.N*\ ?CkL6ڙ;G=9>hk+8a.{S+4{LFA]cI9M~ʥi4K G}si˱-` +YS:-{MI^߁ aßnm8U4;ߺ[cND$oWo=G~zJN- sR .bKrVpnH9>V^S$oPYڮ73Mvg;sںy}T+u0ru7qH^$eڿ6985:u!ˣ{U}z)rwZXpDo}ʣޙ)a]h2ޏ"3wY68=JӣTeR*XP|ǞN'\ZQ-կ]<'R(LqHfC.KeTc==Šڔ-WtpVoK6e;~ܟzW#V[/٩)+$)&Yv|}*i8Txgr9͞?eZ54kB5bЎEM3 vos؟ ڎ"[?)5w<%5U(>}״Mo8l+/mDrmO~(sCV"iF֛dV ϡ>UB4eY%?Sjn MD^~\lueM.m-nkw QE4_38vudܟ72[t09}fK-#wd~f~߅tF%>Y}\|l uU^L/ Ϧk*rݷtr-[=Bdaw^㊌D}e˫} kGݴ_>sf I&Ћp8&U(ۑ?7}97RwZP=8oNצ)7 ,SFUvt9(ԩ {ڮ."RdÒH[t7byyκ{.85)tnW,O9[Ee~FJpRZsڲWe,DSYkU䲠#ێ_No/k)oq賂&ʕybncӁQ(S~%|D" z//[ùYLUoW3oG"օےnf7ff*$tjh~ѕJmߛUb6d,X_z`ahIWwZBH*VqiDT6$7[k`˂x]7[ħRPr7T01Y3#2ocHև$6I#+n8s뎙5GJ.G5-i#i 2q׏Zӗ68-jKГtkCvpQ9*s~FPokd:VP^)5{7cN[IвG/ʬ3u?oGMX:Sw=$')!*ϡT8ҋ]ͣRdD"/(yPXtǵs4ީݯ>jV6U6 NkR*]G3 Żn>_J֢tmYwdq-Q>Qz7ol[&l1m u8N2Ɯa*nzBndɕ>~W+sSR1VMrF3Sk[9 Sh̲*mbd'y݅ަ4 v`53qǷLǵhM''m* vXPΛ7.Fvq޳F*Թa{Q-P_&F^U@G08Oє")=<)OKYnK ^# uW-$qܥK+7 (o1Z2H_ߠhdUQP98tcϧKn|(~r8h>ɧgSie˙aFo1xqr{m>̠-cxX3,l1'ꌩȊҭFcשWŋmqסRe/F|=I$$? i*>$ټ{ҒolhZ=،o991UO)s].mswgG Ncׯjub&]_y6C*0sԎӚUQSNMG>nRw+s~U)8{_J9E m*C#/Umq}aiTw&H3JoۮmEZRyW2$yHi9O=(zD*T:US3ݏ~ ql׽JRi/G3~1堉[wkQT1Zu}ಒC+ْr>N3浍*aE)IA+*Ds}OoFN:Kr{v:vYc;=ֺH޴ӎhXB{]6:zu|_p/I$j-d7lq󭒏iܚ~6hREyu~Z0T<`ΰ3"Ϊu1rV$B5ÐA`7y'κ#Ժ_0H59#SJ0O?AěVfVe;q[rKt^Y糔7̩z)*zz.LmI5E3/uڛTSo aZ9wp#p:ߘVQS/n~YFIaY 8?}jDU5 ]2dp~aӏT%LgRZqL7DW':lQ(%ѝSMӿ^- LaC)Tm`3קj7-Rnuy"rkjGDSng1qKI<y#QsFy=$uY mdÚRH+e_uэ\qҧQN[Z(Ki6g 3rRXK2Oq4'Up랤?mN4iOV:3zZ!k*Sc(Ŷ6p}I6i`\ͼ':sA~TF*U]'2rIn'=\U#N<ߨW(-od5D 6ܞ;u#RVqc.ۆiY cWc0*h[>;Um*r}~tӣh]ku^XסaĢŵ<ݠn}88qŒ\&>T0l3byxui5yhGSR>[G|1|1u%&H8sYv6 ;yTciUqaz)SvH2[y.+q r|}}Icm"vH$sRozTqI Z9 `ou=ԜK\t,o,N[$~8]9GHiK^X4viu^Glpo´Yr]Jtj~.[9:r[o(v+ v>b8:7[~΢]]̱ʠ 5{jQν/KRG6u=Vb5 ݼ%;f7 +bo 뵝PWݴ/u\91s} ί2|J{}n\噷6 'N}yjѻ4xxNy!yح q֞iJnVVKsϘȰb8l0gMW RqR\҇X"r#&㎿ VqQc}pErdJo>gZ sԷhF퍢N[vq{*F1kg:q#4_pDm3Q;iiI=vyo㷌67X'XEH0}=M[ZTU.Vo&|>F۽ۍҿ:%<)OeY~RGL5K:Zѧfi!TU*W5y\S9}=?ue#<-z.<(.R Q j}w/*Ris-70z;Vq^iʝGD+XUj3ןR労4dw{uƻ~i]yqT(]"c)mnV;0'q'?bnT^#GnVlqϿ54.3i זYv%ZH p:Vvc 4wr?uVCG3%Oᚷnҵ*)[[iZ[x-?5vqU#h..`w74>\ ȭcG+53-ެ]c;]qQzlm4n/֑v毛mKc:jLULw6;ӛY*j []FcsoI)+\D=悅JKfhlF兌,/=IчC[JugyZyzto*nֹcicm>{k<Uc/`ҮeNzSiE'N{7cʃu5%FR,kS][VWCjVbr~h=A~1Z3eZJaLp&\o7 <[vq;,TEBQn?3 Bo"o:fż5 GO@k0禗(E$?juHV%d6;goZHۨZvݵ-Y5+1*6GmǁARlJjO2o[~E,.yʮ̸]*1Jl斟^7m}G[es|nl 1#ۥ](WWUIH1y=:teةJy'$3M2Vim.2z.kDeh(-g=ý:|t&cRSKC[jJHdu\/Ȉ=J#8񒶗;~qܝtIW^7>z [ň~bxf܆ܽqrѵ7qZ>.vȓ¬F#n#zZ?2BVN\̆!ymt>ݴg-*q.il2o>8i$Fv<{m~Rb+qE礑<='$}RRY*8ظ꺄7h %گ_NzT>9bI; eX CoQ=zk".,b-eHS!f'UyVjSv^ehbA#5T䓷sb>h%#S+OG>g2&]~cOa906QJjpeQ'*n.űr%+<懹'$kO֒+J<_+2mTݵG vyxz<Ϛ?v jjcHWDW?δT,[Њ-.d%"vo#`H9^kZpvi[0Z+t&6Cۢl276ghS=ssLAd8UfP,| 9G?9OJu!/vOUuKq}3?CS'MF'[F9ʅ[#v~PGgxqOOО1 A%J7aUK'ԚԨ .4OU#$``T§=iFKDZ"O9RXN}{ԓVDbEz L%p9c}}{Rh=KCW PUl|9eRTNkߩ(thB:*WU8N 1XrsK]IFW\r4Jҕ_7c+n<O?,]R=5&|6?je2qR߽>9 kӌdoC?S~4D%ᓖOaEJ)+ќ4&1 c%܋mM!2ʭ}=JF5|ʬ:ȔPWYLBvWp>nҌm8B mG(UamkXXEiS_ pLo szdLF">G":2OWӯ7riΨF$fv〤<+~VO 4/2ǻ~`q]J4eg}JAB'ͷ<=FRZQ?,-qyvCc#=)Rh{jԂCw1 -]}sߠ{ZU1}mnö[b7w+iNN7*Gt7?JNO=_s_uE<(:n{ֵJܚn,d@dg8 pAVjUuGTG~ALH < gJNmɳzIӕHeVO/kmV]֪iYǝ]+uamQRmrH>xؚTԋJj 4-#R_Jqg*^9Mzq]!UST/9]tGTg)HJ1rNM$q4i1'#>dtT䓵̩.c"fa%sѣ[Jk(Uf =?N:x}ΚYl EV\"aN朹yw^d_̎Ѥ +cew מ'eʒ'P/Ԫ@K%3\s>Z11nRpvb&˲{;+ ϒsMs;8Y|Tdj+v+)?ko1]'qJZF rfB,2FtREQ5[jRl!|2'NK8աwY6ݴ) }Iq'}Ƿ\؎[}zT% qN/^&% D?'vN#nIխɅZ?g(s% b""_]oaa2O[HWa/lͷrHb8gUdOݯ 1ӎQ^ \/̚?9&[EY2Ywd'=WU?KXK]bu2xY[l~X;~_Ӝ~F(ͨSR4F-BR4(ʌy@cF>\/wsaJ/77S>҄\}-{9c<8N6mTnN}Kyrw9NSfʤԙผmS1  #<OJ>;m5ku#+7v.mAЅUąUUl4Z`!hrh˵.?7ppG^qYb~NStR] ZtYXkŤՍED~- U%>\i=Q^QQQw m$nBeon*cަ}+wm#0S&@Y#N{*!GOn:\RFef]3(zӌcΝnj7OQ$ٰmW?W,d4q+W[䴊IcO-U$>xg+NIz.ff.KFr^)J3NIvз# ]m.]SFp1Zk%A%>[Uġ|Ϙ1}~nZt*5l>;XGzJ\?KkЫpڬ+?pѲ'ZƜebF=<;;H7-S3Ju.V=F7d0`uy)s's嬩JȂKi 1eRE$/ޥ{sQ)Gv0i (\rwcnNΘVWѣ󥋣whJR)WOWI JGOF5U~CEDp3q=*i)KnU%[iw^_+1h#cO>>]|Œ8kэ)och;ZOPFW~Һj.h9SyGGza-2+*ȱA~>X{9cVΊtV\C2;[& #.r19x#-9ӕ^AeDA8YM?<{YVQko=ʤpڬpyjNhtz/fԶ]IEK91G^1z^kEz 1mj==?ǥM %)Z1hs4rI$׍ͻo\k8Z[bșEJQ-8V;GoYg-q %7AV i<R͟ 婼QRy>LSG`6>NvTRAoc Tj~R?cL$SPc{i[,H,WjϒR7C}^ySmT<3c|ch]Uho_ꍥR\ϙiНJޥ.ewO_^ʲq.kŲ x$ՁB6d)rKFuО IJAm߅\cvQ>'.e9,D)Vtӽ[<Ͳ|͜Sg{n81HA1>v-Q޷$mYs (둟Ps^U:tZ[qEw|n9~^ӎ oN⸱R*c)WW[u3ՕDlВ2ϧt\(km=b)Q>|dI$dQ\rn2qܭ/#fXFn)nsΝoV2W% $lG3Wawcg,hrM>6F=}W(s~7)l-nvݱ噳^ܟ()׏5K_eȩ.T:Z$;do c۷_JT'Tz{;$|0J%J:j}~TrܕR_Moߪ*i܊7wcNY؜gS(S֯Gmxq\ jy#Iey{{~折9JZ-O>2tց#vl7)?T^\[= u!^ʁ_#A}XϹ#EIzxG%^fm>O~iR/[U0TUgs%Ed;w9S_]}޺4d{FHO\?hGUG֫}M59[y ː c DU:w>C0^4鶷ۿrdd:SBɕX᛹cqں#>YZ-=mgUQOko~^4{[5P|I$`lrI8jNc.MOE^+wHlڪ~sݨJQխ- -M;5ʎ W {+]ԨR\.tUFY~Q*tT0V])RxP+܅;k ҧռ[syIVB #\yi3(^1G~Vy?P,Hdcs<~4Q95ڽU^ҧ=G0]6:rFxϾtT挓QZysRKzIN,c'zr*S֡m/nŇP B>1F77Bq= *Y)- DI610kXʴ\Z4*TuՕȒfTo/dQgHɺvky*{,rgDZi.$I0W =GN:`>ԥS wF:Z~omŷdc-#<tF2ok:xSQmwm$Wveա2t 'ۨT՗'{:(,_+Nh>['dʲsHa|~2J7jk)=;4YMF. cc%R_\P;^RܪWApۜGXiQGךΤaNRGVzM-v0_-68ϯ'k8[6Nn/PxB(olgףG>Վ\&ܣN4O2I)b[R:ZuKۻzUJXw-^;T>Vav&7mݒߧ9yE)7f;Ƶ7[QWx&O -u)%bvnY9q{peyT)Y&|QF^zf#J[kK;1!mUF!U`cۊiq*qJVukf׾qQRZ K8d-F%^jyc9M--*6op51G]Y ,Sl92hb9vXIr>S*B*qVqgsb@|g?eh4T|dȩs#nkKFS,+ܱ,vݎ2qX{ZލEku56Dq}:qz5*rvN vfY%j_/w :r7c9FJzEfUZXI2 JVSUo??Aؿ( 4{Gc,13n_-[3}erڄʥNd"+NA{6=I©SfN;~d"䲫m\~u&"|ɮdA&forqR(Z[{E^[Bcd1 ^x+TTFЎ꼮WlETЪ7q?Z¬=tN\C2ƀ`sMe*\K)TyC(>2kq氫F43J5nI"/ȹb@nO\ֹ*52m0'mI J26g4u4 ^ʳ[[FUMǭq(;!HG^&NbV^O̧Q)/nh~( "Ι2y=W+ފ1tO^ r~Uv+?>nJqrЧ?^ N^W4_fI;4޾Z .?;259S&}NV(CHamHX+Vt-8IɫߨǼrBzj%aN>}muQeyXH(\?t)BPwR+M!g]*Ƹ烌[S֥FI$d)8U}z~5N7JRqv9bEhygI=ק}NO]C#Mvބ`=MzTWCң]jKq0ь`Onk4]<v׳O${mhnK`ySqkt('^uh3q.g/Mܒ]]K4[i(Y 1<*Qŗ,l}7^Ҷ צʚz߽(5-oF 7l峽.=P.Ufݭ]=4rY$4q7! 1>2r;Íy{KOeӢtv:1cdڎt起hlM̍Wˌ*<;>^%zqURݖ"G }bWd>ܚWws{iMi%շ;+:nBʹ \FO~Z(ԛTݝߚwO3FUdgknWm[h:Lwgn' y9/3*= ŴvhZ?q;޺.dPz^Jʝ3{jg(e;Yr)9*~ZzIs޸lg/UԬ i~D{in8 1__̉JTj7+/,=g;+Csn5Υ+߫"#wbLGM<μޟSj)F'mDb2q$bnݑ\\\hVum$L+i.Out:eMm={[a7"6}?ZS(]ٔ>kC#XF$`35=?bԿ3E*{y4g;6( c8cӒG':㧮ώLDGˀt:qvލ8>ZPeֹJ\nuSS7Zܳ,:n(:rh:w/06䪎?cjUgL_1@VVem׷~kShqUҳ3.3'~8IGY8eNjew,#sIԚ8ԕqԩ[Kq,YAK9\x|.e/N*ӯP[8ۖ9c3{G+=G%Xl~s\H^+MiT[tca_-M"*vAvݬzbVRϚ:xu'vn[Ը3R(|<CQʴXE~D+嬫!f'ipzu9J58 |o%Oo֢R(ruQ(wAsV%j|~~!.|ut'j}%UOogn[F숡xQ3r'9Ǔ^B{$լVXo4Wr׵48oBL!iZo6T;AA iWcfv}g25IWk͹;DӦ՘Ӄv$2+/Z1Hvⶅ9$㲥H֏#~Yc۽?b>woٌ.Tn2a"6ߚFl'}Eqʴd4Jj^kߵZH&4foE f7(]^ަU*W/3{(Sj!y?6AAJUtRЎ]rǙ2qYΤSK}5t'<HuS3e޷zsͩwPj6z~2Q$F4omUE={ғשIb1T^O0WvfX8 9SQO_>U^i-FߵfH<wm#N^ѭJxٴDgNVe끀N:LSdҲ5JSrd'5W_B2Gcֵ'/S?fȒ(mʯ9'aS&v Sv~\NUN>u+J4-'N⮗]zĒq:ȩlzK84ImO19ݔI3qޚ.7tJQ^eƧ͌c$O}{{F5}D[+a 6xxE>U>ɪ}GnEs{^)9WZzmFղcb (/zԹHc}3O޵Q.2+Gk"䌅w+Ӿ;qm6S32R-,< <$اRz{[dzZYG,=%F^^j4Җ=z=-uŸhV?/ t*2R>Hq)8b%8aFRhls5owY\.J 0xIB2[MNzex[*" H*sIKޒz#)J}7ЅMW+(E>oN1劜TN DY7qI>Զ*nֽ|"#f,p &b+|$$h5\|y?{=Ng4}-fu4{&q^8~ҮT%N<Όb9.%̗9@淍H'&:0oiMIhkF=+,G/QXxS^TSU%庌\UƜj1w:$yѐĀ#fSm9gޮ5(я&zaۏIR>Q(rVN"2U7ynR/{jNJܲ,Flqs^{y:?b@vw  .@В;W;5c o, Y Ff@zךߖ<#Rj6I$FQfpGU/vv+2Ȯax[r;sPd!N+f1;]% UW1oֺCKsӕ=c T3yc2}jQJ*'BNE+],M#3`LIbzuݱ(jDKدoʭR,yzjI?uΌEnZ|VEܼʾ\oc]\7Ni;|݇Y1c'\;zNҕ7̬g|RHvK{[Byѝ,?ݿ?ʎEIwnhlv5qhsk}u$Jcvh$m2%-Yk't8NZFmxuNY=|}ܿuAqR62t'FffN=GB\;lBmE nr2y)*.\8iTN+Qj̏> .\@2IcN:%sҌtV]BB6wmEol95OymEE;ӭmno6x5hƲJ7{hWFkggy /~\cZ<]Κ|\ ɕPH| }zܒ̕OZnOC#e`[>O[Qo'~jOTw^H9!}m0rӜV4RRԛڍ+REicdʯr ::ti-BFSvyag%ͳhџ2egԊN:%.W-żҰWXǂ=Nں#)rvFqݽv&BdsTzҳRM38r_~.cKl#;:˺ru~ qBt乪]bZV l֬a0H}3t)Ӕ~'QJ}Ɨ6 ٖPw}GcXQ4i,?%')MJLpj|0  R^2U6A#S2˸߁-9EJOk >Y\|fx. N2]Z,q#yWn߻߷jTkɫ/1 [ڹm"o+tɐ֬?zsߥ"̛tcjn9FR,hW,*u*F}LFU*^O p&[Q.xҨoFHRYLǨtg=~yQ`<,O$e?_?/zӖ03;)gX7sϥW{\Ƨ47"'kI3a{cx'Ӛ\田*svOo/S"(KFWy۷cNrZQUT I(ׇ̳.[Cڪ(\Чqm2H؝̓s8|D/{T浶*&f{mi= M9&SthXulodd$pXr?YƋ%&]%Z=r~Bڗi晃/W:JK6FV^ţdUaHV ugsԍTݺ9cN2Wmb=3#G#8F+ݹJTfqs^)my;wjNWIXn>Isxd+n#;eB39?iF3QgRT XK TnzӕF[ F4ݚly{{D9O 3!5kju1U-жno۪yr21mI{}(N.;|Ѯŕe՝U̇'HQJ\j^5oLVYrf;KU7FR{uKoysde;F g[F%ڴbf,7m(X+TN{gU' UJΧM Y"D[|N ~Uej|װ[Il[̷c售qOQs٫UN^&O=KO,e}J5BT&秗'mʱ|]B~g EG,V3ʡxvnjX-E:y%[xeeO.2~Fl0PgiJy-q!~ªqu Μ ,ckHb4&C9r=ҤhЯKo'IW;wd8>jPj_49Q+v5 ج`衹b?pn+:nuԪ=^ {fUX7SfՍ4K}Zbsʳ8{FVVI,{)ј&REjǩ|ysѥ7}ŎeY%h7' 0\+^Zv0Gy=?"oXOl%'Ƭ$}9A讦qJ&f #2*b%C_+o-Ȇ`˴9<ҷu;%g${HZEck;sE5F)&W|acb8B5II9O#%,.e˩=ygCYKmhDī,NVLIT{ e+.-2.׌nGs޹}+{tX:,~s tn\=oVF;UUc{r02jϚ;/S!"f>rv')r/Yt8Yi{HN:1 n#\:aU$U`q-w*2Hȅc~c~$ϱ*եkf[#8ysϕudOV6ie&F~E'Sq4FjmSnplU3Q*4T=kUDkh>xw cg%{F䅵2)Q?2ă{ӎ)RWiє,G#h/h*F54>L3|pFGCÊRbUNJy6NhUIpE!vCT:xz"V&2.~foJ'TsqiG lcMAӡڰXsuH2qtcw2|ܮ;{}}jNr+Is1NpjiJnwk&{a gԮyMqԏʙXy{87^i>r\N=ܯ ziū8rgCg="gii|\ZkNK1@Zcs[qU-\q^gR9hʣ(L}~|Ѝ~QOU~~ɲ&;wm1$G+2=jr%27o_=%*qBKZ~aGcA\:9T Z4ⓋIoQSˀy AXKcSzM>- N16>he(ԫO{8iV,C獈)T¾ZjX=z} 甥(V9sO밑B5B0G)*~m6I\ۼ*mg=L=(TKxNXIoG_~uSM\57vEoCO.?-W{r}Vx ~ѵd,l$3mބwvXr^[7/hoo$UdgyvR2}?/ʸ{Ih1TRS!yR;!F=>\=U1z_FzRy5 =<6:a?hkT%x|ʵ9at}o؎;<%H˸3(\ӿz' mn~EJN jW- v!ld:Uqo0>ZSEٯ5#dU|l}?9ⴧޏKpJ4cm~ Fi1t*<¥m'x_Ȱc*G>م_{"RY8(rL\MF]:Ҫ(ASWbA/λebc؍h8 N7gc*rmD2;V 9팷ַ:JwSzM5f?0<8BWHu& ec9_m :uiQ|4B@H @gףh$cQ(Ŕ1}{[|3M/M"EONLOU.hl4.~n2 =mWg5NDVHĬo5iYR\"xʀ>KNUzє#`e8W*Nx^y?%NtJ DL3“͐~3Tcfc y?r8ckxR}1с;'%SJXR5̭+מhמF7*|U_ktэ96~}bUTߘ=F=枽E:q"IUiƒFFOCϷ4{>J ghr^`l}[VmKCjt'}n!X&rȸ'psƣԺxzu)J맨m!cHnO ƪbєu Vu/]jqڤb.b,ł$D3I4KlKB _5#,?{'cSu!K G#:R,tǨǯʗXyQwIb1Y[~;18Iz!SƟ/:kAKY cۤهF\~喨XOb w>/d~ꦩHJyza9O:Wp;}pG3(YX``QR Z0\y2;E嶱Thzь9gd"R rO=~%UkGヹ4Q\0HeTmLp'?C,ϹNUebcrU/qXKVAY=WEv'(?0 Ryy#*Ҋ7^Gnw!Hqج*)_;)T|ܳK{TIUf55"h&5-dɒ$bҮ8fg/Dy#QJ\pϱ<<2F7?:rQ:4^AqSI¤n\o)In'xtr֍Ogn1ZITI?)q-v9j(sZOayf3q[6</oZ'sajU4~տrȪ2}F:_#[Ih} )qhT{,z@<UOw-a彗3ϋil!u69<ӰWޗ]JUײQjYGfXv$תU02ӣ_*u9wzl$ Q'sgB5"_og˱D6'jdv5HYM;ѭ;N<;ZF3s& |@==TO%t-ew+kw0ΫX?u}+ec9Q+~~Xy@)|F8'һ(QVϩMRGBrZmHJ^-+v8/vRF2_T%L-!̜g]fK u,M2x'B} F[hsaY{9@<ѽK'cdM._"#XK1ݹ{VSUN|'.+;X Qwr jMJEslMTyhGg25KT~їnwIO\~"irKXZyI 0*"cc qMsKYjYߧZ<^qA\cR|n#"_åmr)*?w`f *m9>~ts8˕T|K")0eϡ8ϿM,UQTe-o]$q#<#KZsG:ql#~$W }H դ9/zK~vK=ZF1IUN^WY*rG~r:QN^11f=Ŋ-s׃8Ҵl6JtcuPuP>`ݻ=Em˹Vg7ɿr{[FINr*{k TOj%*77zsi8ʝ; R4%Ye')(NI'sQqT&cNăk(; z^Ipm7O"kV2B+T^}(ɓ̙m(SUAL(:RY~ ,q85OkYԆ%d 6CBݎp֨'s5rR EV [x{˴U:1)mk +[~?CYj\~$_@gE/,-,Gr;N<4zBjX\eVMGҳ1V{5[f{7S$k$/8^Λ+n,o,yl~Q=9S('7V. BLaPn'YJ1Mmg"܏:hdeFvp7u`s kJ^kJj̚Xi~uY$7;ǡ&{o*»MjDScǘ 'ֳ39]ru#[`0^1֍M)DJ61}V2J2FяmZB D/۽ a9Vzs˖սK0\dv)c9\V&Cc(w4QYnr)[%ܰn'X\rFwLmM) f qEI{NƟWw!eUed .Xdr{gg޷ԙ"ӷ_"I7ٸQұn^ka! s/?1_qιQu*)^1"5愆$@aC}ӄϸ##SVJ~F|єy#"Yi67n0ћGlӪݯS.x)^̙3q(emYq:\meYG+ʟMonʲ&o^fyW2#]WlsM[KW|,oT2t{#*hЎ̤1L #vzp}~jU++Fw}mܱ\A$jUQ&֌=WK}T>iirng̑l?29y>f1Ν4Zir[0JO>5}:ǑCshgxRP&&抝JԦ#6o|ü6X?:je4m1囏-ȉܮv= SmSܯqp̠n}A9~7,OaȥWEv9zS^|[JSoQ%N"E6*\msʛz="D\ں_vq)ѕ5}~fS[!eA.ۍal'N:? 寅 ϩT8vHEg1޼r$ݻ{5.'mz"1M2:ذqӟQTb-}Cuټ$1ɵH>=>Rn5+a-ZVZZ%.Ha#!f  #]ҍE蕵k:4a, [T$?#mXqӱ?\j9ֵz/#Me'X5č3̻rrG9k:ONR.XMɯV-rvg$;ִg*NN/XJѬN1MV*[Q :9v,]r06=tQGoX ?B:^``*} sW__MaN{O͓%ymw08T{8K~ѩN.4g`'zUoM1bQv9h啚bijG[ UZRZnuN94i_slU,wWDkVtb')??ǠWye۹,CjSֽE-ٞ:qHqNdҌKN_޵{dgq9}>t%[pZu6NZFiWpmr;w)aF5^yNXiW kIx[cœ=Ta {t.Aq،]NRjrʍz'joyiI:LK𫻓xR_Ru*YrimQөyZOq('g=Ҝ\'XZ?:/,j=QFP[ԟd66NXdVm|s8ִ׹$گ&Ǽm4qm>c){ߩ-;-}͛yV2FosҔU/:s鳸iL[r$S:Siy}8j6֯nEvܺ';#qYVS ﾬSfxXHhվRN[<4jFz=_*)SZEm[FSi0zmnﯟ&%{ˍDq z~5#dJq'9?z7'5i1U\}?Riu/> eei=EJ6ZzK12y.9k:toʌhYw̖V݃pv1[B)rkmT_Bf l"652VNMI#i$e@gTsWZMJ#J4Tw{n$17;|*@!\c#x#A]XMAh) õ2eЃ c۵ZbV]ibsYnqj cF[e~Te%%{(؋4|蝾epuJ~ʵkO %K߯h[,h8Рsc>g);/p8UrX:d=mg(:.Աh%LBӀ?ÞkHіJRG ܓzHiBOu33?W Os))I8X@ ꛶]0s.7}e*W_˽iMrqUqa yE+2tӄqm{=ߨi"D8 r}346xƥ;}Wv DA9?ֳ1n}掌>Wn8RاH?uӌe$d[RN 㑣ehKj,sUJn1NFi&fF9,dTs7#U(F\ǩ(kY?xJ@$USQk֗ϹĻcX[瓜d?ch{E奆e`rs߯_º~[SFMwHibp[j?˥eiIF=1HU >R:hsʚO ~'yR2Z IR򐣖2nD[\8K[Xc~UW3qH^<ЕiSp kay!+jG1ӱ8$~FQf1ZV1ʿ6@#e'1Dc{*4)1[}w+pJ6 c(KEo=4[vq" bfm0:w5)jm!YO۾rI..:g(Jz#9'!"򑞽rl*^J\ 4OОkUN2v"s''wh*Īdl,{dQ*qzElk:z5bmaU>V?SQVH2o2FsJ7UӕvZ ɸe]]sǩ< c*r/y-Lc.eN/M?˫ܪO~:\rebFttdw6ᮕhyJR#[֣RQoHOĝ$j^٭5 )So I'M#=x~grx`;Cwot2Xh y nB*)B/Oʥv|w}Ͽ\q_f9j,,<~JvrߙoU2$MRBe ^Fj' NIusS4 \ۻHѽjF,'OAҸI]ơd5n!1#Uc ~ߊʢeͻkOI$Yy=ϭcR1wFga5o 'SMyƜ*4mXmŨaBK|tk;C%;?xFB_+|wp mg]8<2zWPm{]waJjLŊ:]VgawNP&1Ѳ@%ǿ%(VQOv_q8sti=/eg: vZv2^}+2 #gPFs+TJԦ}UsY5nt~m3(=YkM&MIu{sYt0qae~FjФꡑpvpzoªXכw uRR~=Ƶdo׾ b*Mg Y pHGȮK:Qm?!Uk]9I6Ǩ~k/f䝻)ioó4hZY7+~v5>R55*JU%)ZcsO66M`X'^m_:줬r.26a鐂w(9{/|"^w]*}]:vuUԐ%fh.ߔv\c=R֣)9(;udF rrN#=k5jBI;?#sNeǻtH-@},{YX?*a,?,]g?t?N>ƔW%F"mcU$85*B\neAV-[_mlHGEɭzZ}v{ud_-V+|p3k9iwRaˊYmlsSݧ_RM[,oK o;O։.hǫ#J1nڥ)y\WU{Ju_Orql u(ї2w[kOJRkDqCyNW8˂x9iQF0#망̩ԕ{!U%.ܳ<4d_W!Fo4mQ3g }]飶Ҵ[Rٍ0ʬqF/Q϶AR=MtR;}scn$y5Ί|L#t _-o.߇g*rNw3Oh3%`7˖qciӕi5--=ʣM(DQ/ȗ~=떥_g.k&Q Y#/ #Wb#N \u*˷Hϧ4b]ԕ6J,m/! #~xN{Gg'ˮpI܈-[y=jEI-_3Z~+^+[F;U=;r:dc%~b̗k7;v u­ƌn)\.v8dWiU{?^k4i'׷0sU7#x qlSm/vʥ9?n0N[ PRYVО|eu+hNvj?ƶ YGFW_8XgFwst9AoN}Emmqסrkz?#/m x{[D(J$ӎ@QPos{IsdwM"Kq̫'^1\2v=8{Yv&'T["ϓnN{ Q*j^mj(ޒJ#Ͳ}v20x;{ѭmm-ʌԍ&؊e[vB'kӔd|aba c\HI9csR1ҢMͷ cB뫹]bG'`uhdֿd+KD忨ٚAH|\Y~JQ{vj1(omlxN0QE ! _0FK ?x]m}4_~GF4>7j瞃9QR\ͥ䊭̯_ajB1C CU~杣gSI{v1 f=y59Tr߹)A_vh|m:}2?fZKGE:1^oFѽrl8g=~UU(\\JW)9-¶lc6Ît_,V/%nde>iM5 UxZuFf ŲGNzRSGm I=UE;K.,=Jr.ovOMP{>jNYmǯ_ҪjJ3m̙cE&K8h x9>)JWM+(%maR4SOJs:V^ۯOVIv3~ѐF8瓟sֶTw:*:~ZI$S6X%#OjT5 noc]tqǧi}(b*G]DRȮJ:C sus2j*.dӨB$3퍙F ûzN=js&*v,Kqّmx6}/cIN<؁!Uyɭc[Jj2ݽ{,q"&R|c\ӕXsroҝF:@Y W=1 }i5_wCYSqOĭ%x¶pffQ4y)bI$6EUd18ޏN{%d9bMYrNI$玃hSz'JKZ"r +H79J(÷t14+he)dX*8s$fNd+h, l鞕G0WhtY[dvsd.с\5]NJ5/Q:5-MA5v.qSi/[;J>fx8SFw>i<[3.7nS|Zʔmh1Zp~͙~RWIǧ\ezJpO_3pc>g/kεsuVii^x_,iq~Jq梜mӄN]dW#h~9jTc}i%)-[OW{JTw哊br$1*w.8Vi*0-k$#yaKet 30V#n]JsI>gt|ɾʍhʩe c'c͞qZI)v_?jc֤3~Q?ișY8R!InT9NP~{#i^݉.̬4z$:޷jFYJ/ֹ_m'wcӨ"YXHRu<~zq֝+׋e:D*I!hǘպ b"vFR;l -"^joO8>$n  _rOXֿ֧יRu#$Y wYwn>iw)*k_K)\Fޟ6ɅkIQ%[셻2]ьI"iZJѷq1};y"!KS}x8tV裳1PR)-Lp^~k.U9\:P~LYZ*TO\ɮtcJӕ7f<|++gwyjSvSa,D}6= &{nM:z 2W Y֗N1G5:2g[Y[O%$20˻r~55J؅_ͅ-;$v[/ Fn{֫mܶkZ0F--ī崑ɷr~ҋԎ)fpzdߨe{&+ѓKQMsw ;)~YTaEM85-NSʥSR;@L&7¡nJQ6OO+C5-$p@cވ6Os:9w]btvwWpݸ~:Gbg|ʉڴL\*z+ZǟuÞNcdR2:93)=mga#Ge0^:Qޕ>^OyY{RTk`-͕FSmA:Ӌ-%<[MI :VI6Wj16+6y'OHhQiHlIċsN8qZJ1NcJ*jVHi8K,9VH"AʹJz{m##I W=kJ>$:u)߿ߴFL47|vU\hB5kסq08jJ_ƥ9S5jdLѰ9ܚ ^QOI-& dE`kiS 0doOo^qj6|SF^CG^;T8S;8;?B ;2HI\q2Sd#x|V+OpW ޼kgji+b#!_oL_ w>Xi;+&Gil]*)K ~I|?\.i'"wNq$č m\tj˛kuW{[oŹp]3ҳ̜NiPӸc+m`6`q#8#ջKѾ"=WZ1}YTaGtR2gδFmHPzӨtq掝[[$Dn!GۭtFrF壱rQ6ݝwׯOJdﱌhE,)g5z"ۗ=2Gɬ'R֯ J_Z]I!\ =?*ErY;d匠эO-dֹ8Ս%ܥЪq)~\ p89ְENKFYJȍ sƔM̷gys +=qy9sJœ)&{Z4ӿ5HRYiV ^')(~j\ >Z  9?qs(ԍ5-nXUIa ܳ{q׭?r:hӒ?ٖX&erێ9=w.jvE{ɣUiom㏽zVyfV ltld>1x<sYѓIB_ެB(eW : ?y#yul|.eSOpj:\zryϿ rX&ە|J<"ˌem;t~{־5}Zn&=NssX\VU9ש^F;3if1^'zOz/v>uE]>eg8J2uE9jqʩC)Kr%j+v9Ud AГڜܹ79n6VHc2O>BPM4ZHSvc)Jn⭇Z?A,Gnd19puҔikc Iɳd],`~,%N5fZ+yNzq۝[\ҳXXd~(ㄭ[ p͟թ;<}mG\¦E nqW)9")biصjǾEe붪eN^ӱ,aM]lLe!|USl9~̱2 jmХN\/#FNA 6H99(ԓYckƎHl(2K`u}+z2mIh=U""۵FHzSmR7Qd[,q(qx2N~TiknZF;XYVu]v?U,jaqkװKFrJ#֥{_mN2Zw]M4$/,6sVҥSl0*u2P. Qlϖϩ;Rnzܼ$K33|7 FrtӵH˚%n.#n^]!w8^Vݗ:Z4ylO3$l]QT 8ֲ=9rKuFV8n't&;cXFմ*_.5b8Uqּ|tKIҘdD|l/#t:UITH  cVH^=*ԣy(牓ܬa!G=}8k9jTV9Ug^z\o~Ԍj;8<n6gUkw9FX3n>Wzh֯|6/Ap9oZ~SFQ^3/3G~2y"n5-]NzXau{q>w2n94StvՓO@nnu])U_dnjƤJz<Jn꯫m0۲2?zQZSsTsE^"dܾtVIs5!V7flm=9)JM$nޝK&VUX 0י8:rbh(Y@y{U#N<\lRFИamfyЎ gSݒszUUen*AYx[Z.yqܳn$ib+r (\r/ycJ]Ki%̞ZeX|>ՅI'%ʷpYcEЃҴN&q׍JIP2=1LWQ/*vKK뮻 1%eU*y66[H۷nՌ{G_a7$.Bmujy+OҦ[&)Jm 5WWݺ8syt sԩZu4z J:CokCTPI#Q389Tc)&ҢmVu$ 7SV2z߼0sK47qf'=>S8ʥNdC1R{.C\0 #)J݈ױQD*"^6l$OS5g[F}I~;U>Uvs뚗*F-)JjwD6srUԬlescTtG,NMOîYIϴ>419)=KSʥȸ`;+Tm@bEf g;f[8"nWA͜9A}<<5d]jT#NU0J/+ֹRO]XX8ԣȮq 򬣬J%:%p6D -L03^1ڳMFmuعJRAY[b[FL󱙱."yqN#RZdmAb)MJmjy$QƫzE)5⎌=LW18y+Tlg[BHrw d%V?vq]8XЍ&TIq2Y7y~`Xwmcܓ׮88rƣ8kaqX{k? g!dnҪ/sq0;שN\^EխRcJ+u$,;v)Qu\ڽˍ)N;H|$ q}3]}m6&t%V&}J(WRKOm;mğ+0K# p:]Pf9>rMUpɼrv9J9GOq]Ṃ~ܛ…Q:1޺FRw裏Rp̹BOx'bʟ?5ޏZVs-22qz*SSu잝IKy.˴68u!ayu}Ix3QXFY ؐ3ӭvTe:,=Z1J_1!I`F9=:sҺ)TۓJ&r̬qW*GHtr6xl(23F©8FSnߨ&-#hv*-~RMYl#񂊱.~PN |՝ܴPZ ^%cwɏ-#p=uKSy9[YYU|TczD+*[95QqѩJgm HpA q8ӌe-5 ~kC U|0 P U8FRM<[y6+}<-NGQ+$;Xzwc\^+5ZQ~R2$fwnQ=wV:Q*vƙ'FX[<:V4Gr1Gpn5%7r}qy(/=Tܷam14!]W#wi4oXƤF734aYqʲwr*#* /̎fH&ov7!f#OQkĒ?޼G$aЕϸeI{ ]˵3y.~lz\qR8T䬞ڎCs!݃vO9b$i.V&Ǜ &c ̫Х+U9WS myUeld;mU:g8SvVk# n۾O {W=H){u.WaV(IȻ FsnmzV1ui3 aMww93$cgqmt"8//4L画/-pYޢPԵ9cNNI"=sL2tܞ1r+4f1YX⊖Wkc&eRq/1HZIn8<Ұʥ+zO%]E6Uڻdnr_clgQENѩw}<2InD_Z̿R5(R_ȵg*[. 圄WNrI?=)r95Ujzy5m+·k t"sʬ0)F6}3KԦ4שji`Ts?iv0c/vUS6o'q[EMJ oRũ-*#?uI8#n8+{V5Pˡ&˷ c,mTRKX%볿˵GO)Բ۩yҽбv>Vy$UIEk\(ʞϨ(噘Wjq6gI˜֋"(ulA8+Y.;NY$im ןm>{ij1WAtn^MI *N88?ʶQ,GNj7,3:zNMls?gV.Su,lrc[FJ:F?+,2eP0=GRN\թ$NeH,?(Gִeu ]+y,n633ϷJ Qm- (.N^[5-݊ʄevz%3M}>p'b>Qg3R[_&Y7]nvqOlY*kF+$P k򼟾|#'aԤ}·SZ1aB%o)Xt=z?1N1*kR$J"\S2?ts]Wcʧ4۴ɀ zQțn/cjp7fNnhyo#j%pH>yIl|&pF߻OZ^2KGc9URv[KRI1gŔm&6l6r2yFqUS*$n}yǗ#^ߚTUmmԏYXIBBͳ?zZnU߈TmN5yrv#8P?ϭ:Ӵ$qEUCF R?9֔y ^ƥ;K[).-gM6dWDb[Ԍ9E>ȧfVƲ|aN2G^:s] =Rtpt=k~$2y^|3]O1 7~ymN,=hӅH:l6{Fm 6Ϸ8j4qmjnU?%ֱyU3h.^ÑEb~8#;w?Tf1i[QP̬#v6S] ߱MۻFnqZQV5#k$3hbן(dƥhNKa?g vĜ6Xr0=E8/ObשZI$lFcrG'z?*TʕҞ)T^X7)Tdylez9ӭD#̗S: Ԩ⚲-A5mv!@lD$w"*7a󿕦wkrvSߠ}(i h["vHZ8rG?Z<ɲF=} '_3mz=;}*b3.Xh,O/hbI+JM8FRXH}Ċ[rn>8E)7[ӯ>9n&ʸo1Nzu0zV2ћDɲ$򍺪B{Tr>dޅOk㷁^Y9g֡SlZNy5~P7I<#rc<֜=qէF4oTN˷U}ݣ鞕9F2/2Ж?,2]a!9~ڴfGb*LЌ{s捽Z&xInٗ>jƯ4baWؾa˵Uc dqk7N|ʗy\ʼn"Ǵ72>ܟNQ,Y:W]I(\|QR{vcSq8A7yXO?=qYJN732B \m/-C1>?Tsslr$>2EIˑ򁏯sYR4tdB8#`#]9ҹ)={œkBjktR'Uvڿ6OT!x_zjXRbHS՛rj{wcޱ$J\[hv9!XMŻm~IJ-NϪE{+Y$d3/59_r(ԩE6!:X?-UQ$L9 Ӝk*ˇb>gSn%I4Id'>7sXTowH57Eշ_9\! .̇K %[i#<3fExʶ2>?JkOZ^.m"0T?s?}9]lو2 rDc2G/ ּ]=qR˒O7P(].%i~n+]K8zwЎ~PgcPsYz ^T$ئ3;pdz¸Bs5__#VQە٭u9.gkvy$Q*0;`ϿZ 50ΚoN~35tӲ!_=lx}9:gU/m?pYҿ 'WIPoQcX*g=oX\޴x22'S*2Nڶ-M,>#fELdaO9:F<=|r%ͷO1[[rv{>='ZTjrtVf%=*vsW4yy_1Nm]~+M,I]ͽ\Lc^Pv~{4as-o 3mn O#TҦfkT$iEvoьXش/z/ZA'zWMNZTKTM-zlYUAeG?&[{VX9b} t->ifk9-8洩:*{+T.G\2a=\mi9bEs.Y?Ҷ1shԥ|sj_dlݬ'w =D4];-FliX}x۴1Ͼ UxG+?Ky88F{++MI!d7](n;V1eS۱Trm'kEM 8F#_UKSXx^m[L\Wh噆FڥQʥ֙Vk `22m8 ?y&&[Rk_a%)ZSi6pyǾOJUNw|ZG*<:4c۴#ߌu{5DycjW螚hAڼ會3=3Tk5{o}κTjFQY$%b*%VJ=q+\ŶQ5/[ݩQ[6~n'+OFqk%b}/$ru1Np?ƴNgmR]tb)J=v%yk}h UXӥ$Ks 1S)|dv-I$~pY1z,hǛ~lUjQ#Z*"պFo¬r1dSOع9OuW}+$4`nX 8=jr* PجEDVY3LNJ7GT9ͨ V >Te;IýiZ5O}:ь[V'SL RYI$ ?Je)7'dv=(S('k$tٝi^r3ttp:2P 6ے8?{uoM{l=tќ1SFv%-g1*7c{\эJU]M[bKt`hԱ?*6uŒgu؜TwJ;bGxa"F*+HT\hʦE pL2*M0zsS(ʤtJF&-Lb2>z NQ?4o*2Q_D,qº=JZ3c5)w2Q~rv9FsRr]ZG #3|r܏J*S_w݅iomvDX.fzqZӌjxUl^)m&i\tzgRiF}5h=e;VUr ۞=3wsI+R/$],6CӨڱm};%&}4׽~k2?wvF{TԎ/6Vm$"q~eb#IS)nWh1v1?,rsQ5.[V}6>l2Ϲ*N2m(3RӧE 7$d3v5t#YJ??!EÕ!| '^(5{^<>cG岐 #,w*= LiT잽@E~+Z\g{r=aʿt9J7V]/&,nݻߦ85%tQUV"?;(Bpzz~;Lp|$I21o]~b; RVH孇=FNı|98&~lNM$c7*@^9l3YT.[{QR{D$7?dvb6bdsk9S{wm Z۩[u,v+u|}kIQfvnI$2pW9QXJo&KFWa\4h &'3P:~ ZAX#ScjAF/9Ɯ`nG7z^HRBT#'Weg*~1$Z*/-r#lH VT5i{lȱ&kèg }.rez >m??wI.E$mK+e[x+2=qiz*wQw7$!^]Ĩfc vHk R7IG`:iߖ+I[K9ڱ?oTԣx`ьUh%1OI7"^*0f%y`'([O/u]J ugk5_+ZG_ x VU`G4?);YrP T*ޤonRtvhフ_񖻧K~cKeo=[Gq !0ڸr3^V.(vo~gcZ|Ϫvm]]~gG@e9d]3т~W,-6<ܞ>KcimcLYٗCߜ.Wm9bRk%ckK0 x&[6)Yw|<\y'[+4M w.oUo@f0Ov/O/7eJ6:^KRK6pB{c榝X=D=*7QfKLe+mx^_,v4=+:dhp e W5Goy~u |hA@ml.s#+Z;+ZhO$(11'82y)SSI\r>[F7_"y$)mǩ99W5iIE8478rZie'a s9Y>N0xr=*3<{@/U7HAe#9>{V1i]uTN)/b *YTB59v]7_?4_1tm F]-o>_/;Pt{SJSgsʠ֖m>Z%aq[`glw?k(kҳnO@<4k#R ;c2M|>nWCrs)v][c]Fv} |mG©^ݻSЯZM9av6y\9 d=s?c)FΟO"+F3.s^Z~#vܴ6jo/`E vEY6#˔e)Z5'/B($*Tw *^Q~FBVXٙLrqZ,es9-=z{v)P|\-ކQF1liǒ05 g)kPa?O\IL)YH#R,[84JT6ľi'fE"#1BT_G-"io(|H~^9ʎ\ֺ}JeiU;K6I<jjqJMeR#v#Oosw'ǚ$4h=q۟ƪ.J,NS<gRUAzF$,RQZ[H4IwU==m /7՚4f+KCFJw]0iRKĆhU&FSqӡ;$9]K=;1͸dXTRwӔ\m`}*@hڪ8ǎ~k03vvr]5e%?fP69g'޶E.]?wAڴ(ܻ9x=Eg<kK]JBpZ@;l8ǵc[9Q];1s'yK6ݪ[gOq^\'&*R^C.![ [ WGq EʪO~ӝTZDOyF=$hN629z!UEd6&x|njxAYRkoe}~Csm bJ;Wo˟{w1 s(mث2p`n7aI88?c.jqJO-彻 I9ZOg2=񑞹2֔u45]sUyUI\EIw’y?QӥgJ%]wʍIkkTފ+]N0y5#UThv"WQF1)hieتb~/ I/E$ػx|zb9c/z-o(Vĺjk G\{g8.!O=vkr z"VT*8W)u=V]Ik*ӻk#XЭ!x0yJ^RQ|:9"Qv7_&O`7 acRm/㌣NRB0c',HW%)WʹݬߙQǖ҅GkFm60x1[QT-k_jϥr<-q]B!<`}B7Ne(GD֣fH#taˮG~\W=eV>⽟4޿fC(^2{瑟iK4&SN{[ۇS;y31pIwSQBR彵oMd)eϴ7w"[r7~R)hCraI-P/˞$3UN*moКi_]||GvXǠ9<5(Mw£NIkl p푀gFNO溩˞Y:q^=Ȋ/ÎIjTlg5ƜZB8 zGVl(֌-1\ؐ8;.:Ko{}e.w[+]O̥qOߚ9kJn_/+@Hrm1Fb'lV])GI8ۯVF+%<18kʔy#b>2nlmi ҷwI%9-"Dl?2br89ӕ5MJ0e3AfaױkjҩR$q4Nێ3qןsʱ/iUF1{t;(TNW[+mǡN1m""yB3ː=ETTֽUbD~xF-'qOZQB_"DA!6^F;}}{Jԧ5:]"Av߻`o嚴٧NJqj1n*n+WNQ^d-= qݓ;Mb:Oc7V4)kLFmYn1w$T%# { mn FKp<=x֔Ќnt8'S&vo3$qm/$ 8=[juUN憷B4(@xbއ-u&{ED-N[\MhǝSN߁S<m'u"n~V +'{w:fX,3 ?gN,\cjҏ_ArՒhŭĚS=י_j)N)ɜF"Xo.ݒeb: 9Ujty4R8/O7FfJCeUs8uM8Uy 87hl!<>){ͯ+ ԟj%kuR !Y}k^J}ʝJ1quf[k9f0$gPO\+٨}\59+K#9V_'w"U8x9ZSNZ h^[y0-Kmd8җ3mE])8SLJnRn:f[Ari0N1RMNaeKc0l{ʬ=uoO)&2]aqpy4p+JJrje+0?ӕ<rHv! &ۥX0 guW4TI9i},q7NyZ^Hl ~V?Zu)z_mQ+|M^wtSY$fi7m+3Ɗ$f[K25/HZN2\dFNԷ j*vz:̵Wtb5\ۂyz`W_3~_KENwVrI&mhv}kjq]zJױnH̖~j><0ہ;hӔnlP%>]6dciGSLkы*MѩFSrO$:pLQ;zVJkeרeӠϳp6p^jt/a2O~`lYbs](V4/g/gR{~6[1>9IҚ;g#A g0 =<֏4vnZ5HzyqǹP($qE+:*3ڏnC $żݰ1nySוKkŚG]mYNp \}(SJZ WEHv>#ߵRmn{}*ז\EʭФbVmn?5tKI1\_,̯hq50Jro4qTWMݭdh8>e|ZR;>Gߦ잃?%ܦ>`a۟A+N̨֋h@K>f*_Һ.2Nֱɍ`X^v(񝛋ۄOEf O>ޟJgi&̹}Rc9D$g!cBdve*ien\p{ɹ5ބv}"+08}Y8$$.C{w1|[iԧM?{飳IW9Yc5+xS()/S NxԺE9fYR#FS8qfeFJW Ԯ `8'ƥ+cRI^)j[2W G?ZNMJ)WÜ6S9=Hڜظi]Y4"֢Y۸FY4D024pz{\_knv7$ݕ1,NuhgV#ӗgRqݽ<۴dFm1ǩA9ԍKr~>VV#yg,Qʪĭ 'qW}4_3x_!o6"eܿ*Eezq)b!N<"iy&_aӟǎj5UmK⵿ВtFMc ;cduhsSy$==F,M؜VFer1}Ei*m>=iK5%Kjȡs_EJI4Zjq<_4@o7zΜ>~$[Lld 3+5Oi(st8kFXwЬj^rŏVqtgDh(_iYFd8 =Aibu7JXe)__W+̊xnf̀*ܩu8<ޯ[nLjaKQ$_-#dMX:yYCeK`Z2*-QS羁Rn| kg,vP2NO|t]8qltҶߑ*ݴ+xBqv_JSUf0ADU[^jU1frЧY5= YԽSHIГUy.d)SMuڝK_TgV̊K's2+ҵV4Zc ܒHC2֢Ug}%Eʭ~VXG=j%;|}=K7)~U8\ڤ}eImG+#?קN~aɚKN0bj8_#HN2>T$5{> .2~Qk'=Q^)FJt>]~b UHsgY=mҤnt&Ol>bɆejbGïUh0b%7_Ց5ԋ Au 68 cVOۖ2ؽ㈰ lpHA\=TJ>WoHvyv=rsTiYϖ-ݼmu d̵p0I'sOo}J2Oᵖ8ʩݸUOjR{ TV{lV@n9ͦ ңͪk~ d"NVاV5)O̱iupӫO0K4QZƭ=+F0[Olmk{f= dF jaM{G={..Si\X'ZTmуy?CCNArb!{z隙R74~dFIV瞌.4۷2sӯ\VtOEרKM&zIvm`=ު݇4jGWg$Kh&o+)+nx9ZT+1Gkn -!A"Bp8B54ȦIenMkqߩwW(q1'ͺ,=ݗ;ŅzIG7*hטLn7+;nN=qVDu9rieacz!ET1yDQ%1܋k}(X7980qUt[N0+ɼ 'rQPP凐酬PR2#0R&-/qiTEl^h1{c瓕g T嵈hb۶ ʹ1px$U7n2QDk[iyp*ЦY*$Bny }kkˑ_sIJQreu^?v7dQ;X8ԍrm‰6c/C:^xr]u.V#>939=RV"1ʖEa&` 213CNc. ˹QޮQ[F^sOE}ד]$UY OSר'[rǒQ{ŻǯS\*%kd?]Ѝw'=#)i= q26t}|gV!U~*18+]:ܱ <uPݿ V1pmV(ƥnYTRKUa]Kx2 dg*.DjWZ+lV6K~ ! 3nL5j4sNRBx'KUL,lxqG/-y|?6irŝȒ lEfF@>֞2hH7,])V!3U N/5oCѩkSu[u%ȡH6_7<~uwozVI++JbYfx5)Et&8"%g/=?])QpΦ5ƝKP\58ҷhjgqk|VQ33pU/u=N8q:8c'xˍLdt#gt˚0Q8jT ;7kץ!d i5~<ͮg:kxӢZ 1tE'vӷ H;ݑx8kr"k{:KodIHb"fʮ2,:ʴr[FNtj{>(@cvl?yʖ1iɨkr'\>Vz ^}vԑ]di)+!%M m^4шUY:|ZN\1QR]%&Tp |۽DiԖjN[z9 #ưܤe-=IﯘAcf v y8<ڳr625nrv֒Gyqt޶dZmN4-DGl'NJ喲9a)U}4Qk>T0mV`YN9<5\*Kʚ~^CokÞ`W;~~~"ʴh\>qtrg,#Ki.Iv0zNz ˚RנFv[QRZJy7+G\T.[F4]'|ɣ*-ڶV 2%H9هyWb&ʑBIcڽ@Z(FCX4[Nft\8 O|jIli*ϗA1 f,GO+\}+SqѓK$1o2fdA|1F{ޝcU}dBhyIp1=j# Ic9-uuyU(ܫ\s۷jJ6",!-ӏ*Cɳr$>ٮS喬Rt_--{)DX1aVCQ<7,Tgn[ 8lI N;3U$'N5_B.ek{V=ǽk)Qg-<('*6_BŠY#sakUMӣ%$I)5'fdC ?6''o$ұ5W-nRDyRa(:j3ͻ#tm!/2lwϿ[Sv9ĶSܣ&f+q#8x99N6D¤c.{] fcq݅n޸#/z[ԋ澉ioQ\XimI`{NNZJKZvt*G,S܏OaVsz"/2~C絍mx̭r8YK&/3_=Gۢv $ %GҒZ咺"UJ2Zha e\VqT.Ta[TN MjFۗ yҬs8JIk寯/`]M\O$mND/ehZc*In[{I1 Xx#=ICRK'rجBo8#](Aʌ1{g?J囩#z|G*Wy >Keb&Y>bqpx{51N4KN2 16hv}$ 52 {U)I1hݸ~Lk oVlݘt?Jcgcd|.Gn+9d{m\eZTIw;h3j iLͻp_ K.[SN|-ogQGϡ`6y5|l#;s|JRN)~;EQJ9kȂh$_-݁[ v֔eQԼv]Z({$Vç[V[;V*Ğ\G֌*Г%Fze˭lǙgK8>եrrjieTmvob%I?{̋#șp{c;t;)s%%|˃s|1#榚7;:乤ո, 7˵Uc\{zֲabo/ut,7I?͒;A랟1=Q8.gnq6v=K喩j,W-8D G0_. O֪3ӷҜYKD*I/7&HlNRz.в) .Upqʊӡt(Zn%;ZfƢ4NVhn+'3]JIwrJP5VS4ڻ_ljggǚZDYa(Q@h3r3*AT~.XJđ*de7^{|btm۠U9oul2|\{RNN0G^cS9NUвn- _r8bG93jS*2M͟>u+ }7PǙ7JQ_Cki >dx]zo(jL%2Q v-˶NN{g=KuKsדvu p!WjOO=:XZ\QD+?x+4ekhsҥ:ܣmti z6y~;R^v8kTN_3+}wHkrYM!=JJ$W7Qcvֲ,M7@O9US,ԎysQR1^5q?2ԆF;YLvs5R:؈򳽻hE^Ϧk:n}vqJ3{ kxh&AVt#'+U%%i!Z5,ZM__ЃRI`VQ#*v<By=kg*OMȭS~ꋸپDfc9p qNqza(쉡"H ʥUde79 *o"YԛVc,sך8;[,ľL2, AYK* 9YGW99I%}ޞdqͺx^J:[N^ȒIy*Q'=zqץqiJ]ROoA,"3ՀAI]U1_ H8~[J/]'YbU.nO??tݺ>Oru-WMʾƬJ^kFM9F5$]ܴ&f`Elx؟¦i.IIԑ7L7^=Q֒)SVےJyKMܱn#$?8fyܞ G*v*T}?1z6)%'Kʲq?2O 2Iq.xz٭Tc++\m42#;Gp^Xop鏩^jFqn+Ja4߷tͤrbc?|'u6kJTӻ3nmА!Q*ǻjU89J-Wؚmr,n׭kcܪ֦[hI;(+ ޴#s:~1qQGGw,eVa:i֞*8&ܖ2Xأԍ+zwQ%iZ`X} (* %QFh۰÷kZrʊtI4eVQz+GMF7wZ+]ȥ#zVVU*qdhm7#L}@GtKsINTqԸj /5#((U6fļ韭cmDuQ4+eS]p=~8c]{)9v?Tc&6I.Qz HCCCI ":}yW%CFkhC1-lkh8T%p*|o8ͫEȍ-m];yUIꑴeN>Y/#0BVî6ԜU4-,: kxpe9?J˚Q;+U*[\J&] *9Iך(삒#[ff#qV9RTr}KHċc*sn{ gfWee^y[Ö/R`DeN[,I'*dLcN0i~#IYZhyتX~|NoxRU3FX䟛Ϻ񊸽,mŦlmbƻ[(6>֊qøӤ$gnQ cso=xTJV~d,[}r072pc'2?]1emBU_BId "?~ݡHj2޻[-F)jv_iR檿!EK+y"UTrFF}ƣT}\]%3:sk^R4(h6VQ=}茹<Iئ?1FPʛe9[tc{] oxlj.۹NV换9IFI_$ژ~JrN~T׹pqNNef hz&vdU9˸1I7.!##`#v@㏯җ,RohmիDCҳh'U7̬٤}oߧC'ꪎF 0zc99y]= $H9xߓ}sF-=ňYJ%ӥi}\_,jK-ImeOϵ tc\FJevKo?B&[J'Wtlw213~%˹.$ W|sϖ9'`Jt}"kxf?<,w\Q>U$d`< mo6:Vhȯ^TK}Fx$޺Udޢo:Kmd(ٺiRm;yC o zq\6*5箤v]ʍ̣n sבEӨ_qt怤Q#շ$zҦR'mu$j.\z1eY*km5,^;Ҩ Xsϯy}{RcˍmN4%%4^CsއZ7=ƜHY9-RdbgAR1%{0TB~i?x \291jݬI#pfx"}_NJCem],IcS(RP.g%A.ةt{KY맧qdW1m|QRX ^0v:gy硕OoQ& seUGt3F6-e ~ƽ#ևiMEӛ{y$._/(Yz` tʡs)kԋԍ$x.˓ G^Rۖ3+>i_Rn̗ kvPż%sҡ~\N[[ndy>웎G=;N<$ɌQ z{\_ &Cuyb}U5$/'py${gWF@un>U, s>[(E}MӄޔR&YZ5S-GE~i# tI<llHT}+Eӿ."U#w}>Ey!ѷ2q\4ӽi$rt+|͞ \W%iS\~**ܤZyzث4RIN2N9s:r/J2xʍIة?pV,YdFӊ1XwZ>ߩ<ӴZ,Ii A 3d㞝x84zTi$Ȗ8j2B<M1Pnꤏ|qS9M_3L>"zx"ͅܠ8;ޔSS m~]HmxhWXČ0ݱH+ qק_e\[E <ӘS pHڧ9J1_3:3QKw2erNHq[$?R!ɑ\)Uh<1#'9ZkJmiԪ.hǫsƱmb!Eʞ3dr5BFOMR,w+v? Np==?޻(ԍ6mmO"9bM՞kzIg1/@AP3OB@T8ӑ V!;Nc'N$4jS=n٭s4bn :p3qGbnF*wܱ#@NWi`Sdt $0ɺO,I)ܹ`:q'ʡ׌M=,ױI5U10ilȭ,uzڲJI9Χ?+V 7-'VO#w}Tg*G4Whpi8b!ZMuw&Y ʂ71I6nI<~SӒsJ5#FHx[ kU?)Ya݃ҸQFv~WΉWttᯞE&T˶&=Xc8ڕ|ڿO&bX:1ƫHAscOk'MM~'E9J4_D74CLf8Ti֦vquRVhKus|*ldձ@sXկi+'}{u)CL+!w;njc=}aN*1WykY>^T|I?=~,,Ttj\v|Ů㍼"hMvk9Q׵Nw(ٶb3 ެei\?ʸt ִ澮`8a)9F]K&5 was9wVRx-_v{:0rc]3Go F8Ix JrM!:NG&cocq-dmc7:{)rRz{+Jnﶽ-,{P"tlHc~V{GgMLEBB87u8 A\rqZw8FXEA mH<ԅ؟3~?uT qz]Nzg$^kȚ m]W8犙T 8yS'z1Gجg|\pWGי9dxJ pu+;mLu9SgzFJUKg[!GG!V GL?T˗XEfiV-Ϣ9n̛аf.r籬qjrb)vk宩2d;~^#x3ea'xa<896X$iuwW$O+qd}^? Nk%UjS1-fFi/K2͍==M˒N:`ｗ}>CIda=kMVm v$_%Ux_?Nͩ'+{HK~FhCvVb o#! =?ʫ:mgBXzs:ݜLUnw[Œ8 `դfף;*F0 :K2(w"{TӍHKۯ !+JZ5Ӹ丟ɷFӿZ넹h)b%ZNODnpi+I㺜={ҩQ-*^1mȓeͭG˻2 Sjǚֹcj+j9@Y<Ōc׀3y_Bc(ѥyZ֋<,B+3\zW\cN7IلIC0tXN'=*Q~P#$gm onoRgN[h%Th*^6_Q~bhʝ4V9U "~nzNu*Q|TVwmPHےͻ3]\1o!Fdk6 nkҧGmng*q I&lۻuiݽ{S;EkՒ~eQzc]Xqjڜ*ъ*i˧~P+ġ$͌d Tǝʣ]9=,SƌϸFgvnk3K9ƝukRǜf!bx);ThZ]mmm ndw.Q-6.1q[N%j2HhBWZF.^XekP9]RKʕӃz $a؁[ӄyWABn}TdHTvy#<TTkWi/Kh /\EMKt.y=D;7:Ī3|~4sGt*ۨ4Wd+Vex:rU*7ţ_Oz.2&Hu4[FhI#J6u;`?]MFWhFt+~dyq/E]OB~W'3V7*<^*Ưvy5HS'^[C$+mf\Ա?(CmN72VNF{95:vԈУ |ԗV]O9fS1_qYju,W-o6_.Kyݟ Ɵ.i#YEQJ+6C&|Ҟ1ӹ`۹=8YԌIro6 nW4sfM"c/v4N['ڹ*KVrvw)em2!ZG[$sO^=NKN ##v OҲvVJ*sj:+wܿ{Z_SI"~bڄm84aR>[TyVJHnn3 9sVurZX#@~S 3o7~FGJc+QQ]9S\hevS5ԏЄU3מnΕ*r\41]y>"N6:)B{ϧjh.Ry<)q ynwCF_5qfOO 8#ݳ^eho# <-#>Ck1q~x[ QJSu>*bդHe[||8>Rg`SF-4<UidYY\#<8}zU=ٻEח;3ݛZѵutZ~O< }6I:cXrFQJNƤi붇U>cWP;G%jN3g\r=.|S (m{?ck@yc$YU6FLgh'jUZ3.2'93׽L\7MZIM~>ֳ4cF~e GbqƥIsn5*}F܈% Fp1`ڲÑ^d ޛj֛i!G#•K˕=pr\[c6+QG5(ky*ޯŚU9+rqfetяzߙbtVh ` r?M-?CN7$*]mq,ln $5˧:b*GN,iݴr.9ު\Gi{5SmW+ŐF;c׿rKz6lmXVh6HB;Idt5toJƊfJז2o~ℨӗ+E{W3Á; SmI1+'Y V6u g_QKTu%F4欶gDCyI&z6zMV:ka)r=CSvѩU) # BA7_3ӏ`vתߍk:Dquَ$8J1,VQZL4eYG$qICpFuGWer$TɆ#^.!{;OT)^W򹹤'EA嗓WPR9bI2_vs2/ =p5%% _CJݭ١<*A%AA'(~4j1#|ۘ_7:ёK]-ԍYge'l1z~zЊm|vhHVC#qȣN1Y֔]KF>u&#˽{i|򐭿ǸN1:%F0zn˿AC!E1w7=ҔFVcMFrɭ弁7y$d@+nJ#?>ȧ^0Fy9#`]JQv1^m=$MB20v6qʮ8N[68MP鎶`Dy%+ ڏ4oQkfGUU;m 9)Gi}Oeնt] s.2N:U~i( ,UY0Æ!~=֖EIJ/ ]hX2#`7^sRq|SM1i 2βcnLSh22JŻBkJ2KGLcNV?}VQwƒMJZ4Dtf`w|T珧Gܣ,e-:ZiiJ_q^mLyٴ"C6䬑nڋW0zWL{v:%WKg\ׁ:ׂZS8֋̂[YىTc5L-h]hϸQPueL3ǡҼڔjTI[[6_ֆN1nZu#O?D;pXϯְm$|%?i$Io6\9Eۆ 5:ьcݝ^2_i=ܩp,Db<ܺ)ݢGMA$qRъRR{ۯ2tOzȕ2\9SgaZSy;>pVOa]lP4`$q}rGq9{I;[] ,cmMChJ1N="'z @ZS(-70IJ]:U~vI$s^=Rzܙ?z*vAn;qE7NRj,%/ioZXq1<=aA}k:؊p}q-z9`&Ke[v;W}몤h)9ts#OkЊ͎7>Y;_Yч:z5gsn2gWhVel.F J4p]VU"չom/!/r5[ӷ5NQw❫%؆+%o3w@oӭRR9i%*Ncҽ Jh_ hӓh5ʉHZ5ܮc\M®e)E^4R.mFr' ʻGjҟM513obf5ߚvZҋ/?RN-knAN٦Upy_zWw:!b-+sdU=O]q)ݫf"ND4g&g,߯=15E;FSy[T0h~EfqSN56jޝ}OM{:q>ʁe|nӷc7Ve˥In<0}{tas{Jim&- c=?Ȯw7&V_ɐ\^Ȩ|ܴ56WnU_,Mł;+r~^Q汖 Hێvcֻi/~֧Nz~f \"'XӥF*)ڿ6@b:-PJM5Q[2Ǟxt{VqJ2QIu:y#G3ss\)5{u;95\}_~[72ɻU Iǿ5W^KKI_btζ݃nx>?CX11ΌVonq<)-fUm9U?֪9r}[ЯޣCiF2!6 b;ڊ)O0~F|{^ye)4H#RF09=+~YscJ5˾P+GŻsYw`=9Xӛwj|J`,>^`:gZ(.*}ʛE[Ŗ6tgV)6Ku9c;y+mNKBQFj:u%W.Eki'ʢJSVrەnO$rprޘ$VqX18MD(:wEO(䏽D-[pΪf9PsSRa+yw/={7{-}EI W ~T+- :T乖Pn6xמ9cR2sNiԵ,L1z!Cqֵ'k19Jֶ"cVV)QOwX'y5rUQ޳rNI}c- #f/ݿuׂJކ$co2PdyF$#ZfޟqRrtȖb M@= ܜ F4s%Al$fv[-[ZTk.X￝Zi;7#v[ӄwȬ=Iʿ3^Da1Falm\?|KnmV:RPM0"Ȳ)Ȥm?~1QJ-R#{ Pb9&VLUO{t tTNQI=?2bOOyo,YVFhr {\0]t*r.V[=V(VEʬuC~Ҝ˒[yNjSPGI?3fbs}}K{vEN1tLwCl.t "HK_ȬKRjѷQq0BeNu_²RN-om_gGҔy4dN|)ݦZԜ=gNYٌ) FXm+PzqVtRdUekMHbF1);9$c k垬1WBKia+ɶ]I9$GAwWR/i+9YFlV-+9SCA2s~vsURd-4\}F3ՌcOFC *NN.Q}yR)|W49J3v_ 3Ak I~_v}j+JUݣƟ4ao^-³Ssr_N\Kykm`* Zk8߯RT~ߑ$Fs~DUMrӶ;iRMl77n gYG\u FJɨx`nw0Qw>܋V2{"5J]v׿J6ɔgS ѫtyR2^&4aN7wIi5g&N{Φѭh[v,e^- qr'mSoӷd8@mR+7qr~<F4}Vy cicWn^MU>ӷ[F*ԟT_Cb)}~T6ĕ|F:v+HƜms:jF= #Tٷ]XzRrW7soyĎ&|w.0>hlFiӛ`vAܼ8'k֌T9K:*AEkW6DmUo2UަgCN{ͭM֬M,5Ա?ނio'RHރcM2N at8PxһiQyЋz7^dм~TNSR y'̪ܳoHx֮OG}*j&7CoT`UQ+8Cae{t(Nι|cEQ\,~Z3:nڰr1؎oOv(bua~tw!?#r69yJ1Lh\}S:>-h2-C,ialQtϻ3?['ऌ=2kXN[~VM-v&nif V3Lyjr%e(km^HIOOz%N*GR-|I;vUГ|t)kVJ4ۛ9OMtF=J5>KZȭw,/'s~tS]ɗ4!y#$;fN9?^kJvo(A$7ƲpӺJp8ZjR~kܗoĊĊb,_za3 ќiE_?rݷq ۠~t(]C.N0jR^B&Fo0kNw+~Ǟ>Ϳ?ח`5DfH\ziN2rpW$[en~Vg'tMEH== T8(5I3i`~1ܞb=觾2V,tj ۷,ңN3WiitP[hR!;dVrGP}3QetBXxMџ+JwHj cҴԺ1r[ $m G"nk9Smrpb#{؅RV**JJQQ5c^vY!?3vnznh5e権]i_4Gs[~e+H,NG ӚQz4F[n%ٖfl*ItF8善VtGK,S8W^)>_f<f+=-%y vSJUꯑ3i)5u2f+ٹQؑz#^V,+pfxߑ%N[heSBTRic/n+6_jڌ:zUr-]4&e-9>KRY~6mfU*TTwJV"iETjiO$K66v= 4t;q̈:4ɖ}޽*(ԦIS(QjizO<&&[o܅cyENU_ڷb D/5f⪯<>MTK1&̻+Zf^7H 7rzqfsͦsV>DbHQ'ݶ'&F$1jQ |+_1q\_ ڒL&)Ve9mK~aMᲈ۱u9n;aTRȎE5Tɵs|iE%bh;'s+*7ujeNIYTyb,Nʱ7\zul72*"WwZu1$'o~檟eWJVqmnd3";t?m%'9jaSt"(hmVPv;z~Mz\VNIB$$h7\wԒKCVi@ ~2I g^Tk5*R8|[Bޡs^Vv'ڕ*2X\5Ӹﴲ !s(Uz֞.\ۤrSsI$"8R0yӎ⺨Rt:jIƣI]_$c+2*n۞qnY^F.}/qm.\L`+4TxyԌcrӍ*rRvgaYl2X9{7.D-{+C)oW%(^,jT8%^:T7+֌M_sHjCv+)Ϩ"o:*Z6&%,;FlEr?iR1όN\u^=w o+s]\RwOg¾e0oڋ289 O?#嗳oܽnmʹz.fTs?gOhN eg ܺz㌒KV2۬pKwc2 21ul`Ԋ֫)$Ƶ% h/i>dvc7:{Tk̴OsXSKo?g)B3݂aøniyԭV4U.Gs% *+0 #[›z6l)Y6IsCJ ƦtkʛMk5xi^F]>|xǧ4Eܚuů_"xͻEeܫg\ZGetm:c.$kgc`U O|cWRNH482Zb0 t G8&l*{ImXFzi^U%{XR8]}YXF8V捛ᄕJXƻJd.2s4>ii{ 6A6 cU?>ܑmێr̽[$^eF?(UYpڢq:OmN'1:.ssJ9"),V22/#]\q/GlĨ[^9J>a9r}Xҵ3ԂO$r+'v>zA9JК=E6Y7++Dc #JNU=*cRqlqBsIcS~)օig1,vYN=3? gSosiXԬ3sU(Ǖ%cʟ"8ma >9.fq\Eog(ɯ?r=oXg Hp2z}Φ2洚:!AӦDW:p3W5j%{iI>46>bV:MHcd{`p\7+'tXk0%KRN hN3n&F,7sF)qgTFQA KG` /s7rsӟ^UIJ-EQo"ŭ)]Hۺ`8>"bʌ#ϙپNwJ~P+H%rJk1m~S?εbʃSoWCc_9۳cQSRsKF;oa8=Z4UP$ <p3,RWQ和n,!MU֎X\8 F6YEi%aSF?r˗/1N4kUG,wwqj>@CuN8J҉iTPu=ȞbCtl*qیUnD͝h T"l˹Y/pqПʉr*wBN^9vvaKqLU7Ti]^ŻKYe@].sԧZ) Zv"TGuW.3"h>k'u+&֟8gQqV$@qgΤ^J 4 'ydhW;3߮z_rIitc8:~ϕW $ns?(rv*8uME24dEcP(qyBmeZU6[U>vvRrZ2nlL,t.Г}KFd$?Q$0P-XRޝL]"[ X I%?zSc%t3JtfbתЎy^Wmʿw,]_ؖ%Mў.@ϧ#vR>M^ir5gur""ڊ`>(8%LDumI$^Yapv*U%4KݚkA?&ؔ+HdxnHAuIs0V2ܭ%:}e}E; ErR}s=Gִ}^ҷ=J4jZ]mWfSIǯk:o Ymn&q;(ڙf9ן°R1_C:c8ﮄFvuVb/x,zqY(43/k[:!, !e!\<-L.1M_o.l?=019SȩNU{Mm#L+(+ks÷B4~Dyl myҫnnTFix5Rh迭QWFhфm]B;FeXdyf>Gӊ+>ӣYў"N4{vH|#o҈.wrԨ.fӒAg2{d :chמ+(֨V*qW]!Б$WH 7l\umͩTr=К(ʄAn?n-Ԩ-g"Empz>oZr7SkS|ɕm6bIʮP;8/l[rЂ 9P6aal7.]6)?_"Q^qj7#γ>ۯNFVͲFʛ埦qڦ*Te3圔} Nۢ㑘**R0@z~u5j;6nǡE{[fY$$!`끒qu#No/?ѭ'ݴ~#MiWni;ds۽gi hs*XN./1*3(1#B0@.zwuM%atV䫵ѫt\49|坏9=5R1rﮛhVM+ipR ط cs=z r*evaY_m`bVY+˿UaQs>KukW}]QEu%'6n{rM^y7R,"8"ޖ𪦥R7{"㇕:NP߷<3I&dߟ޺#M?vNJJOK6m㎠ִF H>Ϋ.0ø]Tipwz r[A$bQr"F=dv,[4MI3|^zϽ}чάޭy &[?ZNtǀɶhٛ]tF62"H<>)+ A׏iJƍ}}lQnSƢL0sDQ5ownWli3wz*uTn^71>Q{.2Օ.YQI$/$,FR8ٗ8 x5*qѕÙȪOӜkJ;JR8HdK`%;Td5~c֗2ҔTCxroW(F^zUQ-ۜȫɆSqQF3QwG)R#ss{SXX铌i$%im&W}p+ F_ 0 {iFOF@nEinWݓ1kTU/eI{hIfbI9?%Lc `r=xǯZ#(JrVrwf)˖0R`fĭ,Lo?ZxhQXMG&i'vpqdr?S[ ^wZm%ߞXp:*e+:T֧w~TWP_&mBr͆Up \yXXAԕ乖O2Zu):hɦL vd%s=~*ΝE(0kQYy4v/&$ '#Qe9TUNNd'x'>MVTS󞢧-:(,( վUO3WFdwϼD6 vϭt*Nh]K=+*劖ШN6[D଍$py9?{ZF7;sHtۻ]z5LFЪ!Uv>okHÒ-t3ַ5-bKtFfܐ*˜+><ZFQhۖ:nxϠ.\I`U웷.[x?uRGu14" 5WfpK0'1YFJ2Qjh50jnVVw>kyNMM9٦b46fu],S#R <=WO>ا .%ijJ/q{.aYtH]`EV5(۩$Lc=I?*T#ҥ?{C ȅfOq2t+m ~3q<ۙUcHƷF1+!!ld/r}1ߨp ፩*Q#\<+ ̽8}F./Sյ!ӥO8pۇ''g5PE|t!dW`Cz]-Q)I;=F7GUB>A^F KNq+ghvWcbjngy)FHbv*){շ]g)_dhl'mQǯiNqX5;0HԦЋp ]J>fRcNU!V"8-J@sSNof%v}ck ^vx8杶fT`56۬G䌜sz`Tvl䗻Zv 稏k2μ1#Rl%/e&dI'HȶeXYe^2{$i)59Z+*{T}]g͢Z[g܊9XPmP8SU]W-uviT{lFQV'DJ;1,6@??ιFRƧ+N]@bi1X~w@=i(E]nj*AGTձddX2nO|Vq$*yi/Gu%Iz_-v\DrJ2ilEp!8m{=iSJv̛`p@qfƥISѯ_&$WhhZAB7O?Lq\}V-Pđё,v?+mFT+-=GI/rMW27y9JtE5y%i `rc/w}QJ^WSefo_F:&ǹR]4 ,2m?7={sIrɲe/'ޱ^To)Rw_c yXUs9V?Wd8ᱟde?Le]s+b(W%7m2kevgTy4}Vh;wQ`IFk[hzwfj,}4rGR4YUزI;e^H9jGʧQJ Y]1r_ʹbLjF[t,~AzV$G>vbȍ7atʷSk+-h^1m 7@>ApE׶ II|/9cF5.-]n/N6v>N8~d\:߳[v~O'{;FN*HU*mzv6(_b+X%~&b>8no' @ >Rq9Rd]{mNw~|a"cUB5v#~kiB_ܪKUcBX܏ʊn4so0>[ev_+<1qLr88]1*u16OG2=]MH}u^qU %gGYm2>VػzӁOOmVf2FN[em yF@$NyG#4RHFtRm蘮ϙoݰ`3W_ֱF4ۻzu2fK~DwirNIP>r*TZ1ۭZ'ffOrO\{V\ņ(QzHTŽVM9r?,8Ԧ=/ibeUq賻P]p^Zg'uQ֭M)$+ ioyOs <*F> %{mBmٞEc<댩6_Xy kwл .% &AuȮ:EG߹{(Oޫ!yF LNFsӞ%*I{+̪FXi:H/`޴Д_)Fj955 wvV[p#UnzkJVC5;Ft5KCohS3J\DjnBhZ[W];s1?ZjVTgEOqQMo曖?y9ڹqpRW}?QPRkgwПFjTڜmqӍ7O^eՒ(S^ir1{ѧJ>9lFt6g`uH' O'1S*tR;cSQSsRT+(H2ny*v`m=[T9G?!VҒy r~"qߞk2W4,Lh߿KB{L@H$ cǝGf^5HJs8֣?T۳c63yova]JTqN2Sٷ~q~[\"32pkTgTa |/{D u}UVGR2:MNiI4ҧW]m${3Nr^x9<8tc{5%OnO!o3vN[8;v=忧b0ҡz}w,Bl<#N˕ԖqZʟ4vkG# cE\|V&uT5J[&OFw )9iǛETgQJֽ wH[5+91ǩyWe(mo:T![} 'gkWG %×r/8ʺ=r _4P7`A#1is(=,=>x7Yhr{v}89: ޯ7$I|mxUs"O}kJ0,Өyŭ!iӖ<~u?,ڶT(ɴѡ̙VPk`tkNX\Gِ6j)߷<]杍J9IfU>P=qYʟE%TE2'Llzw(h^<óf>';q8ƢFt 㞕vo.R9/6qyyRs7 :9QqCt0rYG#}T:T&`mnds9#U"݊{xK+xSӌuk5r*iA rnoz޴nM\ǗVnsu16ۓL\т#$[Y,rYG/7wTGUܚИT>%^ypsӧlSJiAϠն͕Vs#y(̘S·HEq$|`8 )J4rƝjYnFU#S(:)ToLV96 F<۹3ӧOZTZ7RIUoUyY9I~c\sמM'ku*k䄀ۏPm9]JeP+b͜{~θN+}X4k o%YVL=r=F}\͉VA4'˅ &d=j:|kCG Fͧ۠\~ba\`1*CVvї?͟'5ZI&[lÁ<6Y0:q)ݱVOj25H5ƊuW{KywͿ$V*歃{h#A9\ 0lMrKޚ1ѫX%WdfNCA O^pʍJ]: }%ё ƥ`'9@+s;)Kjq"PGgF+0CQھZzEhx.(~v4M6ey8]0<ڪ2q8{'.^d}ntLn{$lfR0ԞIA+*Of]ѱEkH41Orş*'Row~ԊTy[nnV@Bq}9H'yuf#2p~dR+EIU<~c䢺(ب[4eI eY>\рY.r9U?ɓ{,B\˷m;"mu68h׺YEu-mN8ӭ32ElPv?ީ$unrM>Tݕj%ms}keCf]ېy?/C^=V2T:j1@P NާqԝkL%ZT=Jz\)]z3׊攽"2n?Bk`d2F@;YveNxuN*j&<"Fȿ*9x{޵z4QۆWk4FH_U9ַJSZMj4y~Eqyd1Az(FεOz٣ӢKL$kVvs6iʜzy*MS_uu1Uqm;WTn+)JqS۪;*TfSUq }ܹyiI[)R_#C"/z=]Osө\򱷧dMw{;tcR4`c̎Z>z⁶$2csUU[<:7}Q^@Fe3d${W#)>TEh{MOsC̱LjayNw)8!R4&:) E#FYɻ'+ݏY{Y*GCiues^wԭnJ4y4ܵMpߴ󻎜 |ם(N]LSU#w54̯$esvhʥOꓹKmPU#\%S:vN.2P0n(1RSi$tHq%>fry5:j/"->᳅ˊE*)lR "89=?gVJW_46n=jewFrqծ1^汩UR-ͤwdFt=ƢXWˢKjDm|]^qVRþ^kX#u&$1E!8Ugv$*c)7J0D黊۠oݐU'ǯq˗*ЊqE{ rxӭqO gy/bITVRاql&v7k^mL=Zڃ׷8$"{F@̻'s^>"zu[((E=o!X&nU!O+:6%va:xu9ޫm<ʼn݂ȸ,{v{>ιJ4M=tJߏri\@426=99T8r9_N<9G`z 7oVG٪Vj]euRo 7%|ŷ\ΤW-osu&ֿSLj54F1m鄪BPAj8nfPO z5a8ZQ塝H^XtYwbO,G<*?{]uguE'ʾTok6@rW$c%:zUfy ~DfckzJ^+t2XUfR'u=[iw8Is<ʬ87sZQTE/=϶A5,!ϸ4}ۈ##HRO^굥}BVZOD9慟kp-#8W k]*}m%Y!F<~ЬJ+֤?YcU?wc?2m^nxFɢ7hAiFYXjy(4%UJdho*dgOYj/zwch71W uQ,u?uʂZ*R|^ L $nG9=Ag9:\l_cH6C2|v9=ڪ)r%e߻Vԛ%ܗN+t-n;v={8#RƓnr[7$j&O|{Vhm3:Sq[1s *rJD.h#bܞ}jI{RQq^{h&gqd\8>*[=tcF>m1YnkBnWeO (E"p^htaOF:($Z5)'~̂4[A={VU%Q)UJqm5zȷ$kpǠ5olicZhpH⑘*mfxR +`gqp_kZT慧l42zpjUO8NyrԤ%yv?Jqou%4k8󱨢hk!v ~_"nڎt 8ns$RyM4htZkJ󹺷< RQf{6QK#Ù 4I\zVU)Yu:*O)]$6QVM'jN u%(^RӇfUlV(np0?1[~Ϛ7%Q `Jq޴evHVFWOБgW&$PxW97/V^;[?22Q'zY6,qҕ9T,XT5.weWEhF\{;ߩKNf>+.j6.>T֝W]}HLcp3I+D·nk>ߴ/[Rյj4*-=)ױLCRҽ~y^VGUWcAUk=IgM';4I nӟң><6%V2+6gYTn Anz u6+*=$F}gRNA}îy8kjkmI4ӧN4ԩZr$r+O>~)Y݌E֊)̋Wo5,~SdC#}݌00@#ڸJjfRǧ琻,ܯr~j\)[v ҥKmҼ0~0 'SO~\nCڗOo2̞Kn9<}-}5y84o)d%[ָkTqԺ1S&퍷mf$Ԧ'6#0-+:?95)S;`WQ^6O _f\J>SW:tR2iԬq%?Lcqrp4H+) f\$gi%ԥnUu\u&ݻXm#cN.,z]>m۬* 0Ooi)w^TiTzZL_OWR.(:nsi_UY2fc+l8=g(Ooҍoh)\"=ټÅ  zqEjy7cQxTJڴZb[gvQc#ޣ9ӂvJM>[Z*{yVEOA 5N8z|RrƤefvg b1;(ќEInf2#Ѷ"Xܨlp2Wle-!ԩft)TF5F8VVc5^+Eq"E2|[sZөS9R>Xf"Hu#'`vӯƺT59t_w-AqHR8G?˞%.xUIokH?Cd폟ҺNjI 6Mq1BR=zgQN|V՚GcdWc0=Gly߰+?W{,dzx{JNQw߹LM9s.Ÿk@<ϯdITv @tKWX8뎾QԳ/Rh@,o1d(#z:D+:iݽ.8тkZ>l_Ne[HVU1Un׏·HJVf٧iiuCfG[8YT#TTguOʚt#1ۧrwo…>N~eE]7y["1;1~N1Q6K\ I_-O`LiY1ly p FTxi5evtӧ->T+\q~"68`szJ~F4ʞ}g.ܖGҶWMEEyWEYvI&d֍Ik"ymec5 4I4OSIr Xm*\g9G4MFZ2U1\Z4/ V($tq+z8XӧNRO;nmUfRvҳ'L+|Oubв͸:ϜG''ⲍ:ѕc ][~ 2 6+]å\*W1s֔8Y?22<, =?4r5Wwђ(.%حI4~5ogZ*pՕٜ&ݫ/r:˩8z/ YF>g樚F.RV$qrdڽ>zѕ;Y{Zȅn4A"<2?rW Jr"{jLҔR^?߾3pr*sߏh֦șI7Ug؎me_2Ƭ{jC@|&ۄeQ@ǭD+g]qoЈL"g{BZ3QN>U2Zۥbmž}sUs8K<׻eu,5>v(s8ڔe/itdyZ"[wTUA*.0ZneICDǷ5Fˬ)֔r8ݑ3 c6ѳi.2R"_WeowLvGLo NyUVPmȥFnO\QՒwݾpF^2sަ]Le ѭtVb)n]Y|8y=:{ƜcGM߰Oޏ=KbiCdqG#(=ٵ2}́r}mVQ-Fn1Rve7d%2;yLjϚm\q~)AZ)ZHʖ\ƿ^ϿjS\FWO&M41?ŌuȡrZZ]bkt&(}NhS5le0wgMYqA@#tv ouOfhIvFcŎYF*)n(ƣO$F$eH6`p DOG*|גd/}7UrK1`1Ny>QoI*}W{O8#?O5>k.I|qԄʏke.5#9c*g_Su(>tֿ"XN89u_3k-6ЊFpCrȫe*U?Ro-y؍ǯ=O/i'D<ʕ.FUm"h `&_zҗ<8ZRHvwI"gus[@:F Xnr@'*p;Ҩ3 npO޷t£i(}q{TEtazp8sȭc~fԏz&C>%ܲ!a2}θUQoYmrԊke|$bAd+)rJzS}z*yR4GyyS#3m;O;CUZyG[] [td2NVr##*#\K|Ʊ8i8+ǗՓyT-R} e<Jn,6"aV2VjA-̓( (USӒ}gZR%ιrK5Y]l䅠_)U1ZϙnJdķi18lcq,$yT#W)k[Q *ylHcq;c[QZR)ʝzKCfm>@28giƷ5oG39u5xivܠ 'M:d΅&i$hpXax>}>{[sۻgr!6ƥ?iBu?f u$=:Zᕑu Yܝ&t#ھ^:qӗ%猫Vh FV)9Ji'i*j |ګE8\[8#KI4O%1)@ןfKDNGm\ 6z.R:em ݼRC+H~ Q[ޗ$]׺Qˋ\2 <j^_͊R!po'ehԐH$+QvuV=nnExLsUά9rO:zdW9xZW~؍ *+Iշ/ay֥~XQob nۯW%j歷kkfXʴSL#1ǏR<**͵r?4 H"/ݟǧZ_[^ Dbt(GĞr'=GnԪSc76Vz1#Ho%Wp8Кt#2Ԏ݅}CˏH,`Y{ou2.WlsEXc =z彟(֣oKkwdS*\?W;im5̒oeVnX`kirݾQIKx!r'. <Vt1ʤ} u\2UNӌ@y ; R52aowI ˅lu'>z]B#ݮm-",s@*B#%9{K#Տ-4e@сB?gW4UI{HMhI< ,ŕ$;~c[998SǕn~yU nɬ#ʋ:4gRh݁DTgi#sGVՈHr_cOpۼX+wF*;؉эL;|3¦0擶+K%ݣ̓CV$sGG"JtgQY}QrkPv6v~5(G=A*#U"iۗ)쿐kU)ӤqThr6Vo#Nj}IIA= *m=RMϜ.e*F'KZH(ѴME[yO5yv*{R#L,ef$rZ=(*>\v59|NLVIpWc߽8:ϵcUj4R,-`wgcޕiS:]9~`+Kr Oz/T0$\\ztE347|YDc|BzqbUO_g/|ԍ!YN0OQpk9<=,hʴۢE2cI& Y͈Qo QT{߫C5͆N0j)i:.0NB\XGq4q+ûRy8QN^Nl:y[qw[]F >YT=9bYZVGm6~\'cҜFļxnv4@N',(RumM+b"QϸǼ>?cɚ7;SskLDʺnvFJՂHKKxyw6+~ 5s@e+鎝+g sk_C˗599ItI6#4 sGCަvu~MU^߅$Ecϖ$0_C\Xζ*8JЦnk-ȒB{uFGmbsrvn]m} ֎#4֯oA,a6G川Xs8R0ޚ뿩iN;#-;4' =9溩ʲ:ԩ ӕ[5ѐ6ߵ(ː=FiԜiU =lliŴYuDzeVKAl$lLhڣ w3%QǡJ1jO1 26_,>p DZ]gJ0)Xаfr2?5FqnmVV-V'*T Nҵr洊54c݌~bmWrMFGeOg}ݏV,$<\Ҵ1Rksl-ju(1np2n>?Zw܉2tZ<ؖJBz6J|!Ot#PV9&wzSnvmNp"PM"e pTMߡ4K[lMnռ[ pC׎^k =WZA$gIbWNyoDyaPS"z"n.Umډ{8ryEr'p@n=zZ*R; G%ě+y~?Z#.mC:(/ ٕHW s˚5=rjFJ2r2;$*c-ZRS$lo Yd8l^is]huƏ=zC=>#Ǯl~5 F-MH*|m/1h% <{c8w?>{ݾ?EA-)-#x؍Jy:=$Կ5(rȎc&I~8s:ۜ'w'r(f[W3:G6`OpOMrR[CXZTA. YCn}0qǠ%)C ޽yxmfv!niI6eOwOW@pc1-E ׃qׯN+z1Jr,aPvv$dכZinDecehrGoWYttSNF'[('d*5fPx\q\EkoosoQuoN/%;v7$`I]x#BXwa**byyw!uic+* Hn$qQHﱖ&˚rlVxgXe?xqڱJlBjJˣ #kdz$XdeOPnqڌD$NMz#}XX(V ps|ӄ#QSB Vh;dL)G JjZJ]-MQ͈R14M~^D9TXaKlW 9>ij0J/){jqNjֺV]Y*dp<(CǓמzVu=޽OIʤfr1p=r~uXӴV>rn۔ZT61U^F:}yF/5oDayPw}~C/kvQ[3/$тO-~c6}kBuөq'Y8{358yyOR$k߰yha8ʂuSYbTXI ldTJPrH)SvhYC5X19_.^h.j*V 2 VLnߵogʯz6Vn[t*!nzQsJTӲbiV6@UMQ*Sm$hb=?+ROwA *NѬYn9IKގyz"O/!`8DFބud V"e+RW==yk˙7}<:G@1#4.nX6ۚeXϯL}*(Ƅ&").mf 7B1^|L|h}P'.7g>{.me8?R;(F|7vlfJ0*~ (0Xv1"FbN1ާҺ)ˡ8h/c.i7mmm淌بRݴCDr4J<\`N4nΘMev3]bە5+YF1Ҹ%lA| X.֔)T֌j@#m 1NRw5i+οvD`bZsәikL.pslhwV"ó7Kc3Y]TPI!z/˷ =|ەNRϳԗɑ[ BYzw)$z/Z¶H;xp}}]QyՅI F8G pr8"WBR6_4vri||ǂA{&&c월maZ럘8Ɯr{#fCS+˃ V򌥿zS-\򟘴|l3WNRW}N\۹ ݺ-4X;I(#G8ϱmJN^КU'$tAwh.`bܷT92{u,PI S6rUQ?iv4e ^} $Ӧ3F$qd?O.ɡBU} OhO/v\;qN1QOT/,hVFol[:sZSJvuEy)YgMTr\z/c/iuݢYH@ {Uʝ?iv~El,e%wv\Đ spTG1׃G&\G\@"icXs/8iMO{3Jq^imIL;vݟFԕOi%5\R6op\RyU?ztXfmf탎;֑V&)֏3$V+,{̥8p>lSe{R%]nmV)FZmc嬭QRXVl#9ٵ h;[[ MF:1 zGu6Rw-2kuR, dux_RM*q֖6<&+=zZ*f- 0Yp@9T6K{I,h +HwU9r:tZXBTeF䁞:qX:v2r*[+n=ONN/Seg;ĞZVT:)Rk۩*7{WH|F ^]Z+Aխ)C$R Q@W=8N2;ݒӕԏ< -o%-;8g7RZJ2\z+,M"/hq'N:nKĸo/EPsɬٜrRzy>S7烓2j!D6IGWΦ[n5v~^9#XZO>7 D#ȟrKyܐ~*yl\эvSI"Y[t+S?ZʥTu u%R_G)ByRa=Xof8U܎B6Knդݻ9Fr9)8I/]-)YDcm +Cw5Q{IsK\$Zf?f1Q 42dJ GRcէ# 3H @3EcR*[T}X{ ,`ћ9W5JN=CЯaBFXw=2抻ydzf 2} 52J[*M+ٿQZ̼yg5̱nI;>\5`元u'#+<ݓ~4ʹH^[PW[wjTʷ=7zkdKfI0dEP@獧YS^Hx͸RܟM$DuZ ʍ);i=)Jc0洓W"q$.$YA+Y4SjKmS J{H;שQ =)fVYOLc^|+ILhԔ\b܅SdE}Z,yIqȤWK;8:D8'ʟ/m'ygYUe$HG^miSMFdUW/-!]? w#~;QU&{u#Y-~xS|~UK,jXng*pvւ^]HK-d qc{b.~,U:/MOI D RX&⩴5EM[T4R"}o lG]q%@NxW?뷟JIV[յ{yzH#9Y`:Nhz}-2#4xmg>ۨ{Dyν]yZ H=Ÿ)iSwW ұx?VT\^]>BVc$s4CڊeNk>4xlL]_Q!YVhUTF[$`gOQ--ZҡmXNŭ{p%[;l8]5i E:r-בw{VHuell{xJP#0S>߁a`KhICm*guRiEƝc]W#q|!yzN(R9rEo8ԭS-q)5ݺ3u=sE\=Hyp$JNJ*=?3\r6T:7m=$͢FS!e2m<),>n{r^UV3[b5U%۲N֊1~-vq,|& l!Y83n뷞]QMM|9']t+O#-̘5.X:tZta2q!YYĹFAy\w+!.o(ќzt`7ao3c-69crHqR []tSe 6K.#X46[ Lc?(T+:*ziƲ>t\mV^A=8ޝjF.ͧN~mmj;/!#?hz7^FON߉^3J[1͵]ߗd:m.!yċ`"1= hh'$t;$F\W6VѭNWiFl2%uv-~bp; >Ңi38DɚMYw2<_ֹOܵ˳shэg)o.VasWl}gWSQRK{yF]h̐K(;s}lXd1@NY8 xǧ*Qhɷ/Njx~)jV8{VpVioA´RWcCC$٣+8yJi'N59Qvyӧ9K鬥F ѥ@!q#{e!+(neZ9*M $ 0liU y$xv:ӴV.>j^?CtnUElnWynۿ#88S-oj2cmw^DK[\lĒ7E\N(h.4jaK}Xy,GHAtbI߰Tz=?7ik"8<'TΖQj\Qc3Y $l߻}9}=iJU*MJ ܯS8eN{KU[[hfdcuUhˀ{sNjpۙ[_Cz؜&J"7LS"?y^SN^_?Z_ "yY`t'1ץgENZZ3ITK}:7;ddUh_pI/i^}E_3]N/ney D[9zP7F)Juj)k/tݤL\kHT'S(9Y;F_,{YٙY+9CIN(ޝɍ:sj m%B̸Z,1})THjͧn̚ vPI̕O3<8֑Esl4m#HD< AœN?>?WVeQOvv&?:J̑~U`]'iVO_y;UZK뿡:y&?gx?LN3Sq*?gށ-؊a0/vGo1h-JʜU)FoB݄[1'Td~{}Ło$)I&v$?=zu(sH^Zމ; x2 >ֺݭ.*kB",PUT<;V{K>]2y^ޕN*8Sz[Q"_p Q;TMJ*+ueW3~^^J0)7%sVZd˺ydTU%G]\,WIK*C3;sufk rLRkFKZ:諹BhtCK~TlWݬjԮ̥$ݑ4RH8 ,y<~FQӘ)S8[; lN;HcѫQ8o]ɌQ x~EUs緵|u6ܶ21Ϲ1} <֜9KJw}4 K+7UOAә-3Q:O1RkוPssSF<1jG{-4hI6W13_qJ Z6[w#I*9޾D7gw]>j(e=/p+NW[uNQ6V4S1#U9y!%,!FfB>V'c”u1Žib|c?nN>]HVǕ,2AnLyڶU\:; [亹|c4kw f?d^آsNr6J_ZEK%eR~fDOܯi8iGfKD?wwDi-w2U"}0,,EH۸8${V|furuэŭ|H~'sz>Ӗ師I'%Ϩ<\/w_2/%HteVq㞜U)F{S*{o:H 1`d*ǜǗu9JOb?(Ȍ FsZTyiҲס%̏qkDW/$)ɳg~D.y\E*02x^Ɗ>ht[r *0nAxMe~iY8;rܯqmbq#=Oӿzܧ}:hi+_R8|i$}A|;JU#MEt:Tczt$ n0dym28 rԄjS^ӓJz4U235[,>YAC•H[gT/*$KB7/^8q^~".R-^?|F0vs}kQHxZItCE>|{zVmE+ .}h ᶬm͎HƹeTbVJ5 d]ಫ}OH-kc*|{}?3F|k;2K%*.񏽒S8H.mgZUݖWf+R9%Xhw“`228m.U`ԵZЀ mO,*O[ccE.nfuM*kr[a 2*d{cڽu9v:}DZE1e߅8?ki[_CСR2<[eO*9$4jgc>8YjsС[y45; նȠ9c^=U&{LdR3迫#E\U7f *9݀j)#^J{gkL!d6-ʲܭ pk֣sգROKi;'XTYX`N @<H_\i];\_ jhfڋ$dApX<*J;_wϷm 4)+_Jڛ][!Cc={s; 女[r{fq:豱x.(T $`s5x{M_ }yu ~f\`z:;8p?iS+kB]NM>Ѭt_- pcyyU/j~f0!Q]qPM<{Yw(Vb=9#R)4uR=NXKX[('[h 9+m;gJ娪ҲkS*w]y3I#nM_*ii*ͻ{O@i3͍9lW*^4UK贷a3 hwsfǛ1NQw7 Vͻc2cǨM,:kk(٤ ǹNA=1<qj')1硊mf)v>Vlp1XӕYJG̚Ů-Z2ylcw;u'9QwڜJ2V75n5܂=;k)F\f5*:8m\k/=̆p>c謿GOC0̵aӫ;rZ}(}nf6gf?#^*;iN-O^_lc?2,I@é]؟g&eĐoVM!T//*{wz5~_Fj7k^es -K`a>YŹKCIJc%̟UߡAy Hc5d;NKIf׶LeX)#l*ƵI=EJ0PϺ3uK(ϙ$8ձr8SjJMǩt`斚w1uqubjT`{XTj Ʒ,U#YlJߚ2R[u-h%Hq32'=;`tUq_BV^J=#ewach$wu9.7rj6=/SQ"#hռp9}G1|*{< l2nZ {Lu)'Գ̯JL|>u<+汄I4l21fo+)rk?fXKi *c3Ҵ>iqq&TX2sz87NQؙcF,{Vٴwbll{v=i{yYjO(dI0e lSx\1 Ḧ́cן犨|RK|ݧv\<y}Z[ig9瞄YOR7n+(Lh12S}/ me7b?-ۢ:q9Xsڏg/SW64#hXv_x+RϠEFQ~7P2b9n\)F[[HdePPmaG-\VtvWx|WÊcM"VN{I.#m|<9S9}e N-<3tEb>fbFʍ57#\4hdUz޼)aRmݭMh^ͯQE9DZVRP/h 4fBnRk:Pja[,<_.m幼Fi &=gZ1${QWSJ}u$>{Ȓs榝)QNk_?OkvqG[vs #3p9{MuCӆW&~e`yrG˷{~t>^[?ivQ##w#\өoRԍ"{$3aueLc? r?wtms:1*N"9 n\VvԫSԖ6D<-{}+?k/hg~}=jv+OFfK69=?jQޛt6Ck @~Jʗ_Mѩi;Vee,:uM:Z~*5Nf ̤{W4b "L* x]Xz^"m$)5yl#u*9a?i Šmh"M[*$Pˍ ~=Hm}EDUmۂdqϿva4e.yRN3]4c e2Fe=w QS+{3+Gc$X[ w}G;d]50֜iݴGYL̻|vYܶM|J*sNI";pc ܌=vu4IS]]l lݿvH2qzҩN_E[m ~&ιzt]8ITjt.V;#uzF#Ðݸa1.e{[ڕG;?1۬1>YvqӞⴟVU8)/DSˍUJT3_5>VE)-/!d5q9?TjBanaI]lꪫ*|(*0mElia7fxλV<1=Ora+B{uh؛i_+ܣ8ךR+7kuЪM}1wn82:r/2sv1YӦ{쉣Hc~EU`. w?:4o%N5E%} ,ʨ ,dyN})FU%5uSN/)y>>c\T}!BnB1;dKo{&`_Ln+EQ(=Fr_W-o5e˜OޜVtivC匹g}ǴB=ɢQI52*ImFM.UP˵x9H5Qyiӌe{,:X9>z(U(Is jfV-Cm#NowObjqN+^$<|!,J;s)S4]j[PŗGb1A=;c*OQqW_ucie"7\>/N *mʕZFWhArY[Ϯ}xLEt$O%72`~2A3T.~uJ2TX`tlȨcbN8xǧZh}??uIb["V*) IҴ:,ѵ:rI_~㢚W6vlszsG.NV]R5էgPbydW3zުT?'^Gbrdb{f̣.ry=*yjtW\G-՟E9 $e` 3GqXҥ9aiJ-K_6»pL||Yr)_ѡ̖e̙e{fThv85c+U9ǒKCWdhU?zkq piԺ˸%V*0svTjF:jqm>ʩ4s0#|^ Vҗ2Rܑ^c[b+3tU wWD9FLڝ9E5\H5vdqө?uC_pV5ିB73 1]Q卢F1jpf&(׍zֲ8qSsO x̊Ղl 6}H妛fQgA 7Mʭ9}ke)E6cBD7& Ŋ3NwsY;ֲ-qƐOZךq7Kُ7ey.qc1]1- ӊ敶ݐxan,"bn09A?T|LOḔ4'_ qG-7վ|drn 4 9!j靝r;|FkZr+fJ>We(P@,sYJ̉.IPĸ`=^+kr[Qjtj9R_dRUs$ש*Ο2=zO##6ٱc$Oq"$l~6Ojy~Fm_K.PʨGpNrl{lT\(_U=X6>\2?=֬*F4w&Tåmwb,q O#\R=Y9FIBiQǘ&N9)$7ESFKߠ5];Oϖ9܎23z+J53jbeB\M!,b &\2,Ҳ>Z+|"uˈ 1V 1vXӫJ?x\˼m%I$]͖v3ϵG+өƳfÞr ,ܺh-沌cN/2tMbtgo#i0J??gF~lGfn*}66[$nt(Oݍ $G!ݍ}qSR\N/gV͹\l+'n.;ru5jr%m#d yQjԔdc:|\N+,yQOVrR[2H9n$W*?59S~uZڒE$M9ٌ0Lzߙ?q%d.XK-zsݼF?y3=ɪiEtTyySjiɕ`瑹oz RBG*jV݌Nwq$sJӌS=MZԎ1͝r6X)2ysi%RoWn^Ts+a1S=yT{EsKMu^oOĥ#M[ǚᤸ Xlf*뎥P:~2~7%G4*SxM)]I%ySje7w9 sӿLjcZFu#:ֳ:zܽfC3)c-?(ƣw6Zbb)$?3/]ǭkJ1珴g軳77O6Ȳ3,3) gϯzV;e+9M^Sd '?/ \B)GF*ѕFRbI$[^f9sS8-K]:F^I+S[%aQӦ~{>ﮞ]aGؐ1>^3=N ?֎1֤_q eey2 c*hM%8EJhU;fܬ5sz:(TڻI" *Oa[uiƋm5yD/ 9Qͮ&72rmj#2eN9ؒi< Y ݻVqU:tyu\,EEڥwg_cYY,·Pzy ѡt`00;SS_0km\ ۅ˃ ?.z<~U8vrVjq=.LѲF$I/?\캽?2qFq{Y <%Tlſ\.0+9Eo]7vj(hwT";7{ỵb#GѮqgN E, K&2w +K勈%#.N?j9Fs7Y:߫5deXEf6U9ӌjUI^vY3UvVڦ߯X&n,m-J,V-Lr4;Xd=p@^=t{Z{U;O?дm :֐;˧SSz[41ܳ0 3OsԨGem_LO1tކb啸`,^^8ܼdc5(ZNŹn.gV,ssiESEF~%KHl]s&_^Xӵz3vWFR>V{2ͬ֗*!ePZ2~2/f݆Ջ^?eRmTucmDq >c-4+|mc03ik^7w, $ v' dZ/*MVjF5/Zտw Ѹ=jTT&\mFVP 9 kHЕ߸ 'vI<7 4;*MVV<>YԧO'YKDX7M+3:tC ?)SmSK[M1,qcj+3')Jz(ʅֿ2hȬn:ux$[ʥ䞶},2$2ʣjAZҏ7_BYvʭ۱x㎟9r]$RRW};"9p3Ӿ=;D匥vcf6H60YAqWMFryKDh(բY*\[޹cTU0#w88?N:XCWM-sXT,C}#%._Τg;K5/xnf-IvI=?ө:h֞ɯ+HuU_ngfԳGKiJ]B& K3c&te+zRױjR U[r&rm%$1lߕK9%Svt#X؏N=;5RoTtQ4mp{{}m2Xx88OSg){H=V!^!fed2nܡ_-IFq)̬ZŸEn{>iYF5yPyMJ1;Vu#(^/Szs!LA)VߗdO<ѧe)N1$6sm'{є[fU=nvQW!^XVګ3X8 ´asKRXf{[hE`#lnsϨ_Ek#7^c&ㅸo8 PJ8~e8Q8ƭ7Cjop<ϙxolTMf4~"1K{{wm6YX1#ԣRQOKF1埯)+m8RÎEBQRrN>eպ]GЏ@{\~ΜZ4KO$>jLScr#QNC$I6(FF \zҝjTbPʰ2>cUʦ{Gn }zStJ^ҵ, J8FZ(.~8==ia˖LeHa)E..n-"?`UvQOǽT_@ڏ۷v[+rsS9PqootG Qb B^] 14K1JTJ#+Է'"qiJy k~K.31};}j%)Cޱ)~科4W.Hd4JF'@5;q4NJX_Kh:K.G9$Zԥk>h K'ʃs6q ghԧeR8ӽ:ދ ff>ZC28鑟ڱ婇ղjʏ+jY*V?x\y3̫QF\VTK/l+G=zVG.ThÖNSI[$9gfgfu8 sKs7-=:ӊm%ϱ=vi7~Jp_|Eew:ШDb< gk-'vqEΥ=˧2,99h٘rIbRJ;3F+{]fE*r @K сtcSK+i>Wr>Jp5QmFk9it#U#V~nuzݺiJKr"h޻>o$dzҰS<DJ=ؿ2nVm'2#N.kFkGBw$D.s3I^-'iKSʷi]m¨rWFKP./;DJW G{=J1Y9Z;*J1i6mJroX̋*;۷g[AZۣ3ЧJ~Нm#ӳ ͅCt=Za)l:FD"$L#P3甚Ko(vBI#1\&fm^JrttOɽbInߴW,h|CIZ}HQO8aX)?*xzΕB=nt#!>Lv%ݾϧNكTE8<{jy.E= X -/g.iߕZя%VtKoa+gDF?/=IeܜUI&Rϥ8h]m@٨[mvJrp01^»1o3r|Tܖ&{fm |Ğz֒dvoQ'b'[MHO)xNOvSJ4cwgmAU$ <$$FG͖V`#UT([gR\mly3~Lc9 Vw-pj[ߩb!c.cݜԣLcNzKFwӐ'q?Mܷ:Ԍ'7ͷ ePp1}jr΍NjzK)6yO]zmmEɴK% cFÞN|Hߩ4o&E]̿4Tq*ӸOs3MNpG.AchVyWF IJ&*#\Pz޺N{Jt(QDq|{'h 8㹭>VzT)(-RA2ۋ/8'WDz*~Ź)i͝dHMɹHLP)*wyPH<ۏ[*r%K_Mq[Mwm-2A1^"Um &$pӧy. .ϺJƤ>NcE>i N LW5:zUUsQrtY*77zQzS6y9%>S(>c +שqQ.Y^'({>j=O$J"lH7 8>9|V8Kz>nbfV%tS: rZ|os<ѩ[+_dȌ7R79Gn X>\uEbjS~UF eo{u>4^^z%F ģ{jW;h5;p/8'~ikf~_f7v+b?3|c1#mzIJݔ>-=/g5*QsNæEIm 70(yaѱT%(0ͽμ^"77AQKi4+E$?5/{GcFR y%pZ"%+K;-H[EJYG\g:I)Iتny*S}!QZU'8{oi-K)rX)?1t?ZhiMۭtdmŽ5MsUQَ Dd1>SտZkbDSM,eX;?ƭXƛ۩4J^f2h>l`=XTFPqrӥR1Z!'0"%9^pTdq*I5͜AnR6xV3Z9XZu5Z;ץBdYP lujGE)L%)݈nY{v۔ F8GnWj 2V5Nv0HחW1qZ^2۳z!d&y$i6Bק$ck͛Fw۝tB\g (38m)XϨ<ב>r6cGȑ &tlca9${b0_ӷOo/bv0r4W/s 2QLªUb[;5 w$q q\)Ԕ+ۧѽ:N45Zw,\l;pA;ϭuGC2!Q5n}A,+y$78Uhއ'һ{$U9b)>Ww&ӟ-p2Jm;}J*TqqֆyO|dKμ]r>iVϮ8{G,psnʱM!){t]^EE/TUe&Znr#$gu76\9i\ftUthzi1S*?v/3.<?J]9S_/&5`vvtkNS7$ZK̿OjmYlJq挗c3R"]̖ec|lS[VYiV'8Ns85%yl\9t%1Y>|xb+S9]/OBZH3ݷqssSeiZo8%c z֔c']Iz6]BFD|sgz$-de%8E!n<ٱ'0zs[F+4?wnS-јLK*98>q-Utݷ^]4ol_цz}Sj'ϰ2@FUM眜sS(GqR$?gf;qNץ\Fqw}HEĐXo?:a%h[/h-gVfSGs7%(h4c.gBYɶj;~R3E''J#6M/#C|Ǖcִu%V@-R C3;Vhl(yR)kr5ImDc\ I?f4G4f5@YcHĀOW3MIDh-Q #o^qߎ\bYˆK$P˂pG'wDld sZ2ݕ-͎ZƱǃ3NۚJ:/{BCY$I09y;ֲ8* uh$o4 @:qƊRZĊU%v" nb~S'Z #]n>bIܜ;`uckњ改ЅFY%wyJpOCkX(F\|ƪFQQQ++]B/b8S+HՌSOnэ44D֥ff%]iSKC5t6$HoyDPHonb#)r[]HX;.ō0ʲl3[rI%quK ]_]C(hcE\9Ⳍ}4RL΍+ֿb-ձX'5m8RV*ZKK=Ѫ& F{їQ,ЌE1eS`r3Go ~vԑ!KI bUUX_d yK6Jd^Xn vUR&+3F;Yݯvlq]K[+ʛWi-V=Y֩:rdF @1#kϖWÄ#F;v4f@ǒpkW.Eܚ~2cS!l,j$UCG{axWsF(ʜgqjARr&_Qַ -18o/8'DT~y?6?2^8Vs#)u9b77;c`rx=Si.&Ko%v j¦G>wczwJPwJZ?鸁CǿTMH59nޅ{i!H7Uf&MF=E^^U+$$d&nW).F;VsgxQo!Qm ~}9㟥c)NuR;489J`RS0n(وߌ|K-,w"Et1JIEѕ(I|1ڪ{zTVRʩU#d}"omڨO#jWt$F$QO|R|O U)QNp_0ߩu$ǕJH!W[j2.A9{W`=pnXNEN_/}'}DdBUfck9sF6rі.cW[UAbUxoNgR\4jIif#I\=ogoӹRpdI1Nlhrա([eju#%c9֩*[ty1ʧ~5i[Ӓ܂Yᵊ10iA;g?g.FJ6K7`DCnwymz(V !l`fpٻ8g:nossZ\.!.Q0*?塇یߎ? 圢өzy~ W Ww}pʸZ};_9y=kNAq:,[XnR6ݎz|+Bq׺yڜb̫kk_-XHӌs#(kaTklq*؉II{wH &h6F#Remmv~c#h.$W#~5# R8CirǣBdEXǼ'*]ѷ58EN4e緓'Py=$?4F9=1XcO1ڢjStu2[ ZQ%:p֜U9qr+V7A]Y.1881O,Znu,E<:t8c1hgaU G|z|>ZoRkM,,,[/PXHzj7[R33Bۨo.d]k)Td^((뻺i2ThZ+aNg@qHʮ˕sԜs8\=iFKKg2!&;$QDhթR/K  FS嶶Vc!i#I>LM8#UR4ޫ8V^5 ]XF*\ѣ_}ZۧX9~Iea&ffE*}xmpgs^K}^wѝzc\VRb]i:}M,#~^<6=ɧz7i߾5OkR^t1FpWMw$:#̚^DI;UB72^?Zsi)-.TΪFI+ly<089ʣʬiFJm̎]D%&BN4}ˠN8ɺmJ΃l6e\$qMu.ys_}*XTi%5{W&\hP/bz23ZӣR쒒D@8T @ۼfo}?R4r4RumpmЃ]Ңǚ]{:ZK},BBK4nce{FDTk֢Ԝ[(di ~7k}Nԕg$j%tmw׵W'c)Q/#_2 }HI5ԝ 1r~~QyluJ:WFԶddnozT#5R1tnQyw;ԣ/5nsIݞNr9P+nfc,W52,2YV=O ~zVҵ5抝݊HWnwip1[Szөo ĩ w1r#bddZ]/TکӵoQK,]iwҶ((ʝOh~@3۷* So !TkrO0"Vɼ8(OiNgH;!\i>uy^mx읢%m9tӏ3v.Q:DDڛyX ~7oc?z->inhXٚ=ew8$tZS4[&RM:!UU¥SI*rKX[,A\vm,,f[c`ҡ'h3H%ɟ{a[`9?ϚRUN-k+hUR6C->1 ď{W|nXmyA+/gFTZ4ُjoQZx}JTRzݕ$se‘zzV3Rm%MѲj bk58ʴ2أhs<}1ҸS-ӔbLjeU+I'׿M9ɥ4pin+ *#Ǎ;W=hQ} hV8ADHB«gX~MI9{Pܛ7˵ϹDFcn`uOw>\˙aFOCR]ۇK35r⭳?R6T/kQoR Pz4/v]~~qպc95hݚ)ʖszoK=oº˙۹,Rvќέ&#EJ+y#gQOVt:QK:[hVX4$u?wʟ%B5RN7\R3̋Km'.:8J"JwOw$m>;KyygS{Nsҽ:x܎! 0Nhw vh~ppHw#5Q1OxGu!Ѯ, 恙Z8 [{*s*'{oܩ_5~]:lfkS䤓.Ŕg J?9ʤ'JZvjY-c b5Kn)9Լv.Gk4l6IJ¡w sg)8+_RZ_3EO1w?**8q*YuԈYܯ -0x>_ /kV1v2Jmp󍬘tұ3wDS{:ƽwb,Y"6F$Xzu˱GKyu&*7;!y"*Zvӡ3ORd_LA2sԍ׃Fϙ9ȼCh)2'#OnɅ)+r1tJ0\VWA4{|ۀ^ydOsL":~Ѿw%˻8^6cHq{c*nV6S^o; uܕkd&A'ZrӭyT}v[VӝKY-O+,6n"*weF:%F5'x=ϫ{Jt S;,mLIIe?3ߧ4EӌնlyǖRRoo" żʗR:~Rʛ`_#N(q)խRStr֮ҺZej?hXv+ݞ1>sSM_+~v m{2,C2, {Q7R{JN:m:H=F[X[𤌂:J񱒜}V*JsRWz4NRQ36f}0s'N}+5ihxxÛmmxzyh~$ps'x8.mQe(m4Oɇ[*09"wMuY\FZ2Kax}\ҼeT2@3ey>UiFoy'hc2ݟ?_Z/svK,U_tQ{J1H?&v1ff)sju_A+ffR39j%1@U9_ZݍeQ&ݫf5^JRBǶa*]\; c{Eke,sp*]FVRQEy.1/[z)3rjV\qkYSQ9瞝q52Diʮ8̎nA`IYSc7]JwJЍۂ?&gqҹS33=aBrsk{nuETլC4A!#;fRSԉujJD{&X 3Ҽؘ1E9@"|(ztF<~sSo3 'wbsNyoZqJ]zMrbi_n \\g}}5˥wI#nW^*եmSU ]Bi#Un8L^aF74OáF6QMv۟,MEYwzr;^;bG ȲGF'0NxYөR{]Z۽]^O}%PrNQgK^,;lo_ړөH;GȄE@dX3XTgR0^&;,Y@Y'ӦVnI5AjrY^J$ӹ(6?΍T`8fNf1eWpI{㞿`!+-bh6hݓRzi1k;O2ڧW1Nno)năsV|Ԙ.yr peT1 .xϡ֔]ӆڿ TyyD*7HND{ss]ӲWѱӬߕ^JMC c*c㩇F+M?EKz-I}p6:=n{_iW[LR?~-fS4x˫)Τ]֞j_p%`U,`{*(F\wiZC=S/Щ wght=We:qO]?Ǘ$ Ԍb;뻔H=9S NX )J,Y?'z5RnK]m<4B O);B;ڶUβOF~SEh[j-U9eNnὤy5eۭ_"&gl>ϵ_J<(ԨRC~o&ؔH9<N4$$y U V8!^T]u!HgfI}g8TuRqKZI M4ͰmUCtsrȨVJ1Vh"i >3J&T9e<>bMUU^y:Tƒ]|ͩէʮem4#K5s;|90#9֑ɷ{kfrg;>Ns8-u)[S*ۻOWi2UOUC%Ռ3~mRA9n(䒃nJKJ}z݆hJoU8A(KgDqIjB۩Gϐl]:ڜ42;,̲Gvw.'w8'=g.I-#?W)+-bp `2p{wQ2ONᎥO[=$h:87J2_K.]+Ż*U5S䭾5bT`z|HO(k{/$Y]mF `2@{po gNql{xGy}cf]sZҠjÑCC*2۲ǡ EJZ1FŤʶT+8l#¶lzTQqJݻtcY>dۓ, $Pym1)g]ZW冪ri.ef<R蛗dӭNn~Z9Icqpm1QKJ#-/%@F0K|I$Y j!*|泖hN.2-m'voo3#C G0G 8j(B7NFe+Y-<Qw*̭p ֢Nj+ouC_>v5[1pps>jz5q7r;y."kHǴr9}k:qN*QN֋{X`[A7Dr4[0r~ZՕ4F7}{%܏G`qȬJΒYWk3aY]Fx99?v$$s:|nk{XhH< q<ֱqO5i0]iO/PmI'>}c*u!+s>T֛ۨd@b^[c*F6["22bo>~~7*m+{:tob;x#Zju4pvG gMmRM"cEƧ%A;DQۆ}|Ls#("FGLr0IDi$UP;sьʟ+*}.Eki5.4e^0H+_õ[swK %IQʆ9O֮RVɽȔ*iUt{ߵsQ RxnleN5vB$Н#ܪUdqiN¤O#2Eo+,<ҟ`~eR-#i"G oHq.zUR:1W6qK5og9^iߩrۢ-'H 3eI= ]8yt\pޝߝS,!f#iܲ1#wϠ<uN:'ԗwMJi븓ĈVvUFF r.~lgGbC΍2j7DQYU}>RN\r.͢NW0ʷ;)Srr)[!]͹v'}4(NQéA;ꇉ X#ly =vԔV._4q-w)y>vvA~q]*F"#@Fd*>돴6k#|ъ^"`ۜ.1 uSQRH%Fz=IRܐ|q5Zt#)rMqogneVfbrqg-tFQQק2U$5-̊k8{ݏ;GÑ*˗(_=m㑥i6yӇ3p)pMGpCnʟp]yV#u;,mgynG˻^EeSi S*d>u[ %N I|WZH;OOUA=Ӗ"6z.pS5pHte,,eMk!ٲsp t'uvgTs#4wL{`SרSen:z巔y~6xNN?]i]t*ue_7id۸yje<1ZBYU9mMKs)[4W){v}2~fz˯)iS1暳[/"ܐUFCGqϵM4ȣNxֱ 6IBX;in[$k[Ntv 7"cCQNcRQEZ;GY$_9hXpvu>Ys'dDr\H 3l|wrFx'֜eNR[V:+ѕ:1]4)q+5"7aO&zu'Zz-= R5I4k7A=:vsq(qR^l}"BX8Gϯj5ن"\;[^|iVX{n⦝)(}UjAHsq-nۍZEJ{o]omN?C {WEjtt`'N̗X|(+sD=-}ʭ*)7U] :T]Oj*>0җ5ObBydԐ~a8<s'-.uQҌpufecŒ⹥.m$UGmWAeUܹ\?):?kMea#7<}: 9▖֤=ÿnlfySܤ<}_61 V|-r~*joO.0=g?yVקtdoS4=AjɥVa(jc͂eQ6+q2:kg:q渜G4!DU8ZQݜʳoԘ9bx'j+U{¦ש,q߹`.^3JU7+[/bO9`8ģs}QJ48ɤ b˪J=?EeN\rVGe:X:[RB&$[a]dcRm;"C0VF;t{Ov+ƯX LY609sGq[}t4t}?gk~\Zu?;8>D#3P^cn>ﻏ֕>u'pЍJ0~݋q5]@c=3SQtQU$/=TEnfb001ߧZU]e[ZEGm6~fkLYє^,.ZnIkO?A\䓗NVt%C.fF]F!9ϖ|3N*\U}= 3:Iy< Np0qOsuIZRoJFMZHgv7A#==jcnJs{ҳsaSdlGTz|Vt~^}mn-ތmmAⲥ檝?gQ]K]Zm/wTu{,bN:`N=ǑW4N鷧FIf&q3I$SRΦ<*).8f#ᡑ@eqZFmR!icdǴrg׏U2КqKMEnvD|s¶^]-$yXa[>d0p~Ռc+4_p9Y(Q߽62qӯ+NXԵ݌6I'!$n9'm{>uea"UwRJۃn5Qq**ފ\C'gѿdsU)I|2iJiUZߧ ҹƩ8˩9=5ܨ_yI3me9灎U4J~nJv]WeA=9=9ө69ȵo+A+iْ DiE.ST)Xӊ*kVs·1ENrvVr'qi?LYy6ʥiZ:+Mױ.]fܜzqLj~-IUϞ*+ Is-SiU^S+/+56~䌞xPU'kMoA.gFnS YqS\W^%)-KĿeX ±I]qLg4*ns%BUR=vϽٲc;wqyǽgNQ*5Oe^y3$b4y݂I>4NRS֧ 5\v{;Xdw_.-eU-y^HϨ泗.~&2Em^D6ͳfqג?mS%h`7%gfjQq1F#++p3}Ac*A'ʓݷ<}? T[I'r,I$R}rԩÚ.,J5eg+;71-w*37hi7vu1%O4 p(U-qkQkӊ}amntUW37 )~\N>ϒN1qwj ۯoҺcN%7d˵w$S(q]wgf'O ؚ+FIJ Bd\9?gIFVj"?v;gc/ۊS3[ӌUOkt"*u[?4@NyyqS$$8^ӌUwBVWZ>ǽ=isl\9Qź9ago$9KUXߨҳRQ>_Ԛ'gV 0 :{.y{q`]$ $DEt6mh%żEv8>o.F6dwT[&TckƷ2(;U2wnFxOoX]9̟CYTZGN02W~n,R>]7˅91wd0?Lo%ÈjKV5d'b:ciKJQ-/!Oq A4fL=ϰjTsE|MWmʋ'31^nZh*XxɻIw#xVccp-CJү*tj%ZH7^:V+\Z.I$ɈX:*稣\ܶMjnytߨZFrK:W-gVdE9ulq4zzrK^r#̮챤\n W{Ji%#wNO>qj%AgێGs+-x4)kYQCURU}qS!F8 xy˕̵g%ӆXmas;c#NM*##ZVaOuYNШ};\.a7YdadqZ9Zo1*dkIsYB̭3;,6 2sqX/GK7Ϊ0Wj`AҊӽ;bʹQ;#XN5/dyxT]=7$[,g{mW=}AX+ʜoEԪr$f_L+J)l~XǰUn~F5hzv^Cs/Y8GLSuї3Ԛ+7R YU"ZTe;R"= dzw]~ڊѫ;t#Zj1ZWڃY;xaNUrE?^~0{ee{uөe(sf\^\/twIr_wC3yF.p59SZt}؈ҧRw}Ƭ;5.6CdqO^c(&g^SNZW^\G7mr8*9!R3Jjk~&߻eбg)4F?rv1qM$hkvݰXVyy)U8@Pz>2У*qݺp\Anљsr3WT+O G4[M%Rh/.GoUH=[ScnӫJ^_02[Ku /P1$qgQvt]/[siAx WeGqgTwZ 2YLe=0]+z)JE+],i3%nUHsz֊^ V|D|qZ?i+_DuTN>X`U9߂0Ngj/{2b;6x2tG}EN{0^ҍ]|F$FTȫ u+zu9cI**[Igw4-4j@X `>W6zUjtVɒ奴̗Xӎ⚂(֣jA-AhE1Ur2N9<.U{JQ ]5Nc U g(VߩoJ߁qDU|,z~n*1rvC%Qk33ew 47`iUU}R80p$ 9sRnWM$i^׶ZbӼR2Bfk9]QC'9-A5T(~d2*ڪ̥͙Aݵsֺ\cnȓ ]?51MHqڰn7~5#;IhxF3;SgyէۿA5,(vNqSne[n(?.&ܭG}}Ll.R#ۙK[wv#y YF2qXssjyJfto݌9V9*OQb麚ѩQS{H1ތ3sz~JrM9v?FՓ=ruJ0_l"ܰEpC09*#-aF\Z!#UA'TO]x1AqZz/Rҏ7(-fDvJPaЏ{wFۙ[7QrwLV6d^";wdAsҳ(7lR+9: 'uTن1T\tnS>zrrumK63+)e2><ç+TSVXvD$'p ͌*1QJc'򥺒kU.N{WoS:t aF[9s?_¹j{9پui9)nIe{b6?3%{pO=$OC[!KՁ$݈L IGd8T\Demz_[d{*ڥRu^MpI˽̪VtZʌA'yͽ[HG\cZ^m:7ｻ č²3֐瓓C\ֿaaSӋÔk8nͬs,Ѩ\Bk~9y%^dQSQ+f6+obd ,pd0=9_^V5Fe>%+W=Vե'eXYc $|t9ihկN5N-;hAn?wc5U:w֩S]9hTr[Asu jGC[I$S1Ws~u5=7MK {gY!Ke-ʈ)U#$u<kxǒ[jRz=?_1lYL!p ~\~̪2G](}@a͙ĜᶃϯQ[B5*roN:qmSBLO0Ye3=>=Wc TS#zB¡Tp+*J.([~ZZ̑6q p;:tח0E=GH%Thr{=1ڄ'kt5˚Um jA1o՝1t['gO1  *()jѳϠt띑 ߈i=H"M= ((tcmN:O4/[yV8z$2 !YEh^RMwQ4Imv4o/rHcߊlfe UfDFXc۷oQvky)JK[,Bۡv̀4~^T3Zn^2}yoCӱmHOox/o8?(<3].kt:j4k_ x7|ZRQ%hF"3ɱ\}?ε+Gb)Am)e3 9?j]Ш'<]gbޟN](j}/oeAFN99:UVZKo^o+e߹ n'NRܟkN/8ʭ?+oΒLJ]K29d Ψ3 ֪4u*Q+A=Ԓl$=NmgnEc2Ԍ Tynjsf\iFTR]t^=c8(Ǯq#F;rgZEIT{HWUp^Y{gUc(Lg.v6uҳI|ڵ4uc^IMIq 'Ƴyj11lETyƑITr򆸄G~_A*rB?$n7stƜz̠Y$ n}R\DUh| ipu<`xO#vΓuZK#AT䌜+1ճye%>ONrqizZۅGݫ_6]~]XpzcrsފqçFSUD42nɑ.1[?%tWʲG+2Hb<}zoɭ=_iݴЉ-$HckuwJIiONQ.]t*QIk*u%$v >xYgXUd$;`8#hvzm߱]b|d\ر;9^´9KOyKt0c ц׏9[S(vq |ۙ*$dgQ)USxs]%a%7%a .۴O~K&S4k{wkjT˛mEJdSi$I Sˇ8:ڦ1R39Swo"H xC{fQ&8;;zh*' p1ܓiGVbՐ褖<-b.) jjF4}DS6ؒUYE ۑϽ&ZhM|1?z6_~Z|rXZ Smr;=N4MrO吲_/؂r>9Q )FKo|7ez}OY:q挡(h4 Cq0 f |fJTQ#ySiƬqN3R=\cN̴ѳf`oxVr۫2Kf l/fq[S y"w+~a~UhY&uJiO^'Sm͸zww0[?vyay3(\lY6u52.`+ @EI'ϖax57/2qY!Dq'u?Vqw1a$2ZJ[ Qv E)S >TDqݝ'89EhTqdֻn?;hwHzLsXn\{JR۠@]&8_t\ͫPr[K$Ep}RE0@qW=h2שHc%mcq39/sY˖Qe AX#VVT ۓtjmRSRY,7Kug\'8)K!<˴+*^wIJ?iΏ-ktK-ϐx³ ~N9QN-Qx3nvO-c!W=Ȭj)sʢ[2;ôJFv01qYӦTbSIvkB/X Ų3zSQTΝOgWؖYtk{+Lcnc_fiT^*ğLrda ?608?ӊ*VHTݡ52Q Ǿy9yfJK-,I28C3Sjb鰬&"͇vӟ~+e7-Ej|.5pA;\dҦ UDa*PqwK7>o˷ҹrɯhG2e#Ց?w'ָU9JƴHS=kJ*2|q[ ;tW}e5UU@so?(9ȯ>2kot{)aE7PCȟ{ooCKU֝H-߲!(ǚw[ A)J,n-DAqq5،*rv shÕ|G6#*(Eit4}KgxM^  $pV4Y=9c'?ˊr qR1rѫۮ(#ر&_Ա#ZkKe3/52ÁֿWpksƴq)v~1J":6[OƸg莬TiJ_gnO45w6N»i֩*mE.YTپ}ߧ}ݵλ1.Wʣ#ڕJ^>ovb(ҏk,I xTP}HFVvDMCG5MƜm_^ν4mrIl2dE%Qn׶޽Ă8|Ÿ3Mn.QFJ %G{A .5O}8D [S1:┨TSmmt.j*=%ȑS 1yM٣jQKA9FgikYL{ ?S]SevJgݧݻ )y lq2ۖQY]x3Z5ok'xz*Y$Tx>/Ȍ>#SWqW_X݆ć$=۷jQ;(VɹTޥY ̑>`g*3:]<6[T#ʾ KVXmU/8#}oKc S˒}+OP<{QzӔU4V,K5 X7\/e16YUFFsVt֝Hw.22ЙP2\6)`rNҢeFFttԔݙn2&o,m1,q]}7a,DyH^w \E^Zg$ԓkM*Fyj۩+/YA5T0ljr*~ӿSݭ+YiQm͕܏'6k50,軖pşky8w;^8zQnOq7q>VI|ǯҽ DބJjݮ{nq<;v0u*rDK|Gp:s_gwmV\W1@JMYͻ?WM;?zrӜe]z1}jo?pW*DSGpaL=4[Y-h$jyEU,JL 3Nzִbmc*u%f= P2H8NUH)5$uio3yL/O<{֟|4Feq%Co,6HzNZjab+zjI2ImC2x<+H哉$"{X.yN88ϮySMV"j(>R6Dž#?㚨R3*mFwn,ŶA>Jxo&́R1$mUR0(2v:WOAA}v</ziy-Qin;̹#W''.TȥN1 Pm$̋[A8Vqi1S DRّq}*jJR*&'֝<2KnQv>9tSi_@ÇHr嚘J_h%DYÐm vlN=)GbS쭡vŧi7yzqzqS)zu2}֎oHXCÅQe? JN2սMR4-ff8dzʥ8ӖGnE;diOܮ7#qXKVNL U%O^,RIv]-~gVo3w^z}J3DmN4jKPjݽ2<5Ou=:a ZLL򒱏3j#.[} \^,p  Iɬez24m![i,w;C#V2&Oɥk*Q*G?XJTuJm ]sr_jE:YeNy9B<ڝTxC 娚m]?.Hs-6+evKϘA_Ҹq敺F.ߡem0#|qrG_|{~઻@̱1X=}y}H~KBY&?nOr{RR+7WxӿQ8/smQ呢Pyl+guxb")@Z1*Kׁvֱ,}G_Mc[s3uiڝ)J_#6}qJͤaq+*i#OdiF7mtR*Ԕyzno,{И٘emv ntG4U:L-5NNIV BM1fqkGۦTЯ>zEYztXJ3F2*v^[_c[oUO|Q%qOJ-cU,ޞfT3\XGҳM >~:~UqfҿYEs$VVVRn,p'Nrx.3i􅳽f%v+7 B25j2gJVW}~-F8UV8ط۟cUQ1U[K6։om7Xm8]5YՇ:q}ןn%F_=}J} +T!:Upkɐ;~nH^#ZQ;wӸ |ɯMNtqhs߹[FusMlֵc2]$ڶOd_0+1Hwg'zOZU9*vԣ*puf=FF+oeiљ̯$I+qnd1k4(Vhu~=}FzWZ^Y=J6tZ${w 7Os8jO^<\E~7ZG!DqUWYzWHNo2BeO5فؼ`?uqZ;$pԢW#ZGV 'c(c˖i[v~\a`;`e|kr(;XpK}?}>gN_)%e^+ӣOZ?S1=cj_ *mxsֺq?zι 8c%)^&5('<${r;d8kU#u,#TU[F1بӗ֤ |}=1:%+Ʀpc(XG]w/AʬĿ+d͟©S<эϙ+݅'h*FFВd 0Y'BW;vN{z51R*:h?U\sGRGByg$F'Ws<Õ)l*_"GYFJA=y]b])̙FGStb݌yx܍w3ܯkݺ{sq}Vm9 I}\U2ybVʬ ]>Z,"unQT`qe?-j+MD|$MxR!˙Z+M6 Szq\qqVTn[u34N"V!T.#W j_צ3Vi#[0feFU5J\jF-|W$>e{lljA9#-:wOo~U=]_!$_?y𭽧۟{z[t=#0y 1{OJz_L۩R*˧hr4eN>)IWwعʜ=׷ b,pp=1ӣT]G%}]4U55HIX4}[ojN<|`awg9շ9MvmePP6:~*SwӨiF2:P)`B܊6[?Fx:o䕧)q\ɜ|{臽e&~-JաQ~s|Tjt?wM)Ԝf+6 ̬jVwUHSR݅>lEwN]Ed+N+JѕhF0tcl$ DFmT#c޵4zQ I(ѹ Iȥө{{ZWwjyaYI"6ӜA"#MJ>}ȿiQm8+ 3/tgA/WvoSd7<۷[Xx?_ʦJ2{k}1)Ÿi.nLQ,Q{!]kQo9G+]!ϗm*p}>hNz/̚qQ}&+#k1n9 n0cG\=C9iɅcl?ok(ZÜq槌oK; hٓo>#`y4m{#dSo!ѻ<\ݲ>\;ʦFO {S/l;Z#I{潤$+Y" l̻;gҹOV*# ENI7q+3_n@DZm߿:sSwMp š_vZ6_G3?˚Z[ 1\{qflm5%.] epڢfn<D*U_iN5)=?'cW)cY*z  vQT^/٪~?Keʹi7g<NhMnpңS쿿ro,;rH 00F9#gRh9:3-|ו HߨHqT%)+YXٖV:-Ifs֪)iEҔ!2ڳNUnG=;u=#]VJѭ٤+*-k c<VDC 1sŗ;q~%*=}ZTi{5k}l TIq> *,= ~*S%Z!4VوJc qvɬi¥iT4=F%V1ݹBUI9N{%mkFu*Rtׯȣ|%&?#&(BR{ ӼŤ(=t5WKK[FN׶V٧vʫӀ1ⴏ-*{iK2#fm-$fFsSR_{If{k4y &[gd8~O`q(ѩ{ݺUeZkE0eX%9t9 6B!ce;^Eե8SU#(1 nD;y=:tyƵ&}#*)&iByPO>Vb1:ӧԪ%NԎ9a*VV%4kIR^B!U/+1X5n..UF[5i^ٗFԵ=㥻 _)ٚ6fxc۔^ڤy=?O& [$-tItR\ץ7Nj>[eHFrSu9O51T!N*0z [5&P̾fx\#Z*SӚujSQomoDc1ImѱשefjNRu"FyQUe~~Y~*y˯oS)Kj\/_dNZ!wzck^UN-thN3qt=F/&LYzTUtdPHuvbHOog ;mðfVZPøsTdi4Vb@J~Vh XQiIolsHS I$#czgv4ZiYWرv 9*Wv?.ψrM5_5J9I]qm%eEf7˷ Pqۦj(=n!%QSNϠ!Po]kHżp}⮣q#x1JI5R_Zɴs*4^calcV cnBFmk]XB\-I]6lN4WԲ]u DPy>esOg N_בE(ӊ^VT2F̌ }pG[QEEԨԓtoq1϶C0HYJ~>~NCۃ}F'gZ1b`ʣo23I/)jJ|y3Qn3b kvt8|0ӊԽU-lRGRJI $26a.ODۉTH?繭2BݵN>4WHUX6ҩ qXҫ*u%y+ )uvko A;EiGt4Y;{v#vt8Oz4cNQI?2) O ه"#mlkWtEE6sSkIʚӾk2H; .V%U+N^t3F#$40;WwN-2^7/c$m8~ +S֍un/'%"pGZ){DΚتs]miV8vaX9jU%ʟ4pMK4J[3/S8zT.SR1wH" +SUIT_#xqKRY12yi8< =+J>E)nO> kڕc>PWlŻuGI_(KĒ#,͹d#r׭itѕ,>9%b̶ۅn8ܓDe;Cx5(^uХ;l:մ#)^Rԡ̡uw-3Y 8-ר+z1d)ƕho{Ѱ d6pGOԓH:rץNBWeW]56]:S^h4G6*TyQMɾJzԢm0rxҺ*J*{SrӠ-yonҳjR- 9T.^AqZ0a:n*U:kxZr.NO7"]B[x9ԏJ֦4}u]6xԳ *eR9+R[)JD>djFzzZGܿΉGq۩FWc."ƸXT3xӜ~Zjݜv[.:)X) $ێSܨӨ%)_+$u|nfjjҩ+Z[+ZN̻Kwq]W|ZǗvuq?2u['^OЭN2Q+ʢXFW,R?ZS^Җ9xcgO\6ڦA:>*RN}4/[yqn<NE87^K~ˢq*ƒ#OI&}Cn^ٴ$m`Wwܶ=*JI#OvwL#qj<ݧnBuǷzrQS_QB2ŷ;$TJ2dV/BgX[ʹt~hƧ2AdfsH=;UFtQcWK<[y]qCt>R#cJuet[2l*@;-r\3Yὔ=z_nhVnѪR:iM_{K|qډIF7L#WЙ gOom=N6ޙD+>Wc55f/'cqg%:5v_;wTk1հ>QڱrpЖ!O4;G򐫌kNh|[>o2.m#T9)TTztjbTJ՚֓K,[h>u5ևfJPm꫷ѳkF[lkv<ӳfΙsq^[ +02: 5(ӫ$JnbȧRv'10?:qXSN3I˶r\<nUVwI-Ic(Z rK8Weg riMnMUJOIܚ9 P,1*Ur;~bZ\R{2.^,Uʮ'oUg*1qw.<<pm r{ `#˫$2i>nԚWNRK_>fI̱g[9B%O(Fceg$QGn{ߥT{(ӭ+N8auJJbftCkVt-+HntE%6 %lZs S} M%:թ*vէ?eboy+ѹ#\׏#Ijv2F_5UHk^I>wA]*hRH=-΂P[ȹkNx#|ֺ% r,㋭v쓱݅JV"oӿT]/sQZG2\Q[!bVܼFӍ9FWcWQٮ/y,1geVv2X_*\gVeukEegvlۜkZ>diS]G\Z,7 1OsF1Iɴ1jH˻Ysӵ9{Ogx{+yâ{w֪).Vg|#E+[Ԏ&ib&6'&LefY)E o|*>J\ӕ74+- GѤ*V$ƴQ5W#6~lX}QO'8iXogj!ӭ,܍+qZbyK1񲕽lU2+r@W4s*+9$. gs sJ \%SKfI#8o:p+TgN.;k$n]\m%Ewj:-ys|ձׯ>Etr6vǒ%RFe/,*[$#s WCQҤ]:q14e&To}:VUMsSd֭tK|k"ɹxیc+rť\m4r\܇Y^φOQ};h>]7RzEF?y]R.k5%5YN/zUIF2\а8TY8㑆U9FRvJoөf M,B)_㪸}={3_wa5 [It7Nq=룚/IhuB=TI7"3bFa8ۜgw~K_TZu"d$u#'=3\yv; :ы=r2]z[*ƛ*E()'-ٮ ڃ!fϘzg ?sNW%`>ڤo}IJA˓r<$QSɚSFT$֗K9Uݹf 6ןO4VRRadpFJ?3xݱIr+5-5Ϲ:U=%M-*DpYpT:p?JR)\GJ@dI4c*̚}agj&=.|O9`q*jeGx!%ӒyU]dmgR5%PTƂF&#c=Yt"NvlJŃ/ˌgJUvoc sL;%|!LThB3NkG>i4Ku yn>Pvxa$+FJCyTtqIpH<^߉Rcm,U5đ y p}OJ|D|= +Z*_kHRN@9wӽkkuvPU;ƥiԨQ~ϭ [#4g-RUV<ӺPe#\)I=WFսbT Tp1ޜW@|ϾX^^'?Aޔ%u#3]QoRU8Z'$h-u+m6X!,s9֫ө-Eԕ8tHdhgiw6>\zȥ.]_o0[,fx,TtJm2eV7;WQXi(9 d0mE/omu_а& Vw96yႜx5嶯m*JjP/|H*Fp9zJ0J=_>yAux3#Jsk߻`8abu\O0N:,ZR2?o2wy姟BE`N",Yrz~RD)J;WOsm~T/;^HыO#ԩi-y2N~'JRt㡟nVIQ36灑׊£Ռ:1.}YGH<]o.2RNZUYWITU3T9dζλTO}OZdp*~W}EI&x"Nƹj(ju&)SvX^{VHdet z{N"ԋ'֩7o"hDZ./ˁ<}&4TV5C;ge x෸HN\WNYF2fR\՚]Wb]:$]%Ж)pc$mrI䞹VrSE7硵8v$Jz;x0Nl<LW$ԧ1Rx9,n$;W9;A}\M-≢k6Wǀ ; g)7˧Ó' '~2'uUIiwɬ%Eӭu"-mo}?/d8Uܡ[3AG]3ȕg:7zpd|Tlivcz''._;[|*J3 2U3vi*s{=z9'cu-%iY30Q_Q޴ShR{3+<=wv숚 mlGJ.7_OR\>מ$.3 [nްjJ3H)?idPЉ<9p Ԣ%;mx|>UܼNΑ ЪAt¢KTVR[+vґr'խxӿ*ت6R]WlO 6ޒ<U8Qs&k- 7 ?TyK8 NRk< #+"Y3(=?EjU:i6ױ^kybmFTx95/Y}ʄ{|%%#Ky,mʱ뷓ϡU.E+jOֽ֌SMcĬZbg#FF~P)_vկ";X]ah21ƅFc8J96xxV6o_'n.I3yIncZS{dMٮ2" i+,{X29pA+E]wӴһb8nLʤA=ֶdlZGYɯ_̒Y*`vuqDZ)rrGzV>fKLoP_nx溨<=1\rgXr}3ҌUr&z6g'C-ĉnLjD>fJ3ֶis[c8JR֝?!9B#LG#=8JD=. ,Ғ&Rw'"m: ingtګ?~^xIF2^_;j#;h A^3F[9k~*բQ[Uf/e ezu"ܑg[}dr*t0gR1QF;#ϧj%֤Μ/YWc `y9JΌ,CDcXĆ=߹PSIxq⺡i{WeFu:Gq9&X=sXrv4&:eXff*tzjۙ>Mt84,>o +ue$9l@(ճiohvtx FJjQZ a{}ƧttWo܌g>K<˩Rc+6p*7VnrKrIs'.@>{^^5e;'wy {2G569efґ>yz<KWHqJ_8<`zY)/{IMEo)w@0XIuKDLi4g%vӺm֫nҜdANt09{+wMXQ_1#TnXr5#vDſZ6'RB+$N;W(T]4 G67nz=*T*KB1f+*ϒ$Y##zimRu+$/Srgk{mݼ`5Rx*TIB]n l8e󩝥6rj6kaV=ǖ8~5t9}%G16#mܻͅNW司&RmtDc]ة#g{XF~%_2aWJ0fFS$t+Q5nN7hA0mpz7cQ_ktȽ:T^ yogәdf݅9 "k:|YK=|1,p/ 1& ==Ω*nM_EũTծvy^i7cm:*rr)`fds+qʳ x$NH?ȘөNsH']&и]nsۧjܱ:u9𸺏m2@pr*穎 sc(ӌi]_RQ zcivdxc{bҫ'̴ M?"1$q]D3HPysۧYJ6nK唹k'R:D1fUO@T]ܬܬLb%[&93j10 ~7kEW(E\򣳴#V v tAX]VۋכRJZS4Rvm]Yj-d,ll~_ZmlU?IR3/$U眞Nk李*S-0Hm7nQv{u"vXUrڬ>gM6_J)mМ!N'UK2lkHSKt;9UaP6y<.is5omB=Ys*ޜe/z_"d67kuͷJw--T<{_AK!i9 JOӌ*\)\S K<ƾc9 8Eq _Ҽ\@ty?KĒMqwy]cԎzV)=%)oo?bD͎4d`<}k S"UO9mlu\{ڟ<SMÅ/CؒN?Ѽ5٦+][>MK ?/Ԕԕc0|:#saWB֕:ԜpUꉭY#SLG;:7ݖxx{8n݉gWMà>wۊRU9lނ1-HݖCs<:YUՖfe>U+]0^ԫL )GCc~yJȊYf[t0[O5 4WYXًTdcqVSvF1'ki*YNO8>\N %̒#hׯz{qpP;r~CH}(4,o(Ԕ\ցxC(l7?ֲ^Z=jU#F ?Kta>$mh۰$_Ftѕ8r=z$ۢUcrxT{9[]^8XP~~>N9r۔#5*j=:ȟNJ:T+I=?IUX ʧxlA5-r{kR.To& v^K^} T[m,[l q?Jz)c}Y?Phlf빝7Bqi ź2f zt响(IӲӸ{kѢmĖ\HsTQ|^1ho!meY^#S"F:ީSh*s;*BE1&Ny瞃t#mƤVb$ٔi~PӨTZҩOr_Q#7 ̙ۼg}kGZըӍNV쉾DPI$2*{eS[%tg*nqxo(GlLR+AG׿ɒ,2"{ɳqǷJTVNޢL!ZY8ɏ8\=+.RU[[FDnp ~汌jJM"cNxv6͔'j*.1oU#ZFMS _`8kSOI|ѲnV>zǮk9Yjm g&ޞB8Um![>gQ<`#;7̚7;ٶ'qQGP3Dn#JϒHKm#B&rgkLc=~sj㒌dFJ5o!n<)-\2WbBiIإQkl:gL-x]_#J,j^D>7浿FFK/ sy=sМtZ JްܰqFsY>U-NU)Eyߵ|sy@˵v2nsʤcg,i.]wN&5p{U(EKC7COup.n#۞kB9MSM{bg2:U׳+{B@eܭ*(;SNi=Tz\Km Yݼf2Oڸ%gSTmR)==J?f{89|U4ӌ>:T;ŵ=ƣ-?۴>^ÏNkͩ*iM;Y;_̎ihdafU^>^z眏7+ֶ#K馟gOta1c6^^>f:ziV[Em>fTv[w0?Ş9>ʟ$o%vuE*u!2bH߼& Pr)J#ڭq&ɦVLbJqqz4(a{.a2]:q)-`qssէ%4*7e妽Z["v6UdUשRcNےv ]cr.U݂N89nՇ~_ZZĆaheMαeʪ}ᷯ$k c׽/"F 'q]*rݽm칣#Hvo-+{}k:1*k9S]Iaj-y\l۶.7 z}}^y?TpВV=o9ܿ7I =cRRp~SRnvGqg8FWO<󑎿Jq"2 S{|wmc(5Y>ԡP>aA_9Fږch1µ5~ީޗNcm4C?ⴕ_ce+Igxbi svo+N^ַ,V#QJدm5ͷ٧t# x9w;UJht]}wtSPI$k~hZfd5fL`q:ۿO&t8qZo7s%m0'9*yl;bޯ{cuJ9#x+ni)F,uvQt֚+I$FOD6֕n6 mhgNrIkpNTaQ;wkd,#61;*jsM/oөN44o$ BS6FÌ=sZFQN'-H׼] iC4:iCڭ:?K3+m-s^lRӔ/KY2Vn#Hzt}O jsVԿ| (VfWtcN%S]GK<gH,p+rs:u3X”y_M|kT vmƘ Z1Ee0$?Z/2MiyRZUo);>bl<ֿ6Goyn.N~b>Aުvӻ:rR5Im҆V%Y_3[sJ;n4ƳYﶻMi#HܻC&0#sѩ XšaOzI|+n#8+n=(8=,MoOaFy085gMI9.ٸd~(8 c$s $Si=SSWVY6鸏*.ʝ8կfXeEEպ6 T-•-u8251\h#yvr$ĖKLA8=1϶+HJ}{UڿR.}E$'p$g#?ίX[ѩ/iQr,d wVeq1ܓGZSJԧN\WQqcʼ srQkԧMFjѼˌvGr}4l:ԝIDOvKn0ɍVKroВ(fcC]jmcuIs \`Jx8kh{}չU#RT9^&L01t8<4uӔ#NtVaEye#ǒGWMm<kjj1٤ygϿ Uܿ6]n4]8%@Wͅ7mlɸy+>rQІ[;iSΑ݅_@yiGʚHUN.Qܧr6ZRR;go;Hڮ0Ԩ"!o&SÎէ7:nG(v#*ungR)Tא30Ub{0;ҧ"J\ʜt_Ǹߔl`멳5|M;s, oYwƽi<l 3$lyk)GǙN\whѝ#rwI/uf J{\cW`pSB.Y~&>M88;HM8KF_i c'`émyj|I>ՕXӖK }K)QS_,LjaRI^i 4kŗݏOpQK~Dp)pdP2@ʫ-rOnm-僳bnWvC tX2\Uee9'D1 cʶwL{ 3Nw9jքQNWS;req|ܩW>ۖ<#+ߴb82qk2b&QYW|?*}}+O6vV5v&̊NO=y<2bF)s-)S s} GDZȯJ4T^g,,(N;w4lAMu\K$\g,s꽍DaZU#R+NWԶVHN#4~dy\8;(S3Wo(ҔSnvvL1v4X$]N){"4w7 W;*N蔩so~\o^d*sI!<Gyc-oPNxzｵGsp ̼*{\XӓRogQ$jbqBGA5F]_%cLϒX,3?~1-ѿ-)IfRu"Kn.6j黻7*Z?wOdoϺX` ~V0FqּE8Ӌr3ƕI)>ORƪd6|qʂq¾kBk}|EV{(_.?zǨǶ89ZJ͟;U9=VmM9 C7vҾwNZ.+e:x󾻝&&IC=˩Tj.U)9GDoADxʣ0ݞUSTS{j?#fgyVA5zRmpJݟ6-|3kHM㜌vqTt>EԶPRw+`ƺ)4^o~dU}aC|u9GM5n1c}8Q+H1p7X40$\qk:3ovӓO_2E|Dڿ¬s95<[qԍ{$dy n#=tjrX:w#kdiuFz_vœecq`Y,̬y *1.nm&el 2?,ֱ$k sO+y[ȩyf0dl6r:OnzֲI2jB6C$ѱ}p$]xJ%M8`{="Hvqr1\)AH yX ,Qdu3k%)G4Wwkc% ~ՌkN" x6^[S9eu+ }墀7ʹkGI4PV 9G:>y*1j.TrubBLjncs{םSVvZ(,ECWR\)֔S#TdE̥ۓ\5B5{7կ2ډ'3.'x)MUHQv[&f_?z\ъW.M?kʥ-Rmo},xlED{Kɻ"8TY-p\j_>뷗-w7v1嫫9~^qхJvߟ9T"Hm m9QNVF*+ vq3L%+)aף.W[WW*Օ摚Vm3ym?pTJUyvL$ ^sM5"HT7]ߌdusPe}5m5_s:{!]nK-#-z.3Z!< pQnN'Ҫ>Τe&VNَtn(`ت`3ۭEE}PJvZ| aLgU`î2>SsSWlDGl>i۱XZVS_c;709zZZI^Ԛr*H̱'h˸G?*Q} r!Fg p@ߧUON\}~"hTqjNE7P̛,.=r15Tek[fU9ܦ@-Xo-N@kj|я*2H̰nm"1qO_R5>e."ÿ;Iۊt+F}BE8L `ʤı 䓜gyeQ]fnc{/P W.<rZD/«)n dj](eB+JtSM91PEB|ȃv3UG*1"j ] +nb[:#RSmb\&W3y9שZ-%QVi b"Ff \Gz)JY |QM_.aAdŕXG=qڪ*3۷MiJm_sbMm~ҌyYWQjZ˱& "Rs#:Єeum:#ϕOgWoG%x⁙_8ȭ*Q0ܻtH?Ajav[<\]eoƹTFM&9JҒm Gq޶ce(2M414i%Iͽ =k"-_*J{y.. D6G$\~TF|iʖ`5URC3yUٟ^:ְ)k{yj#y*ҷ]s{ѣ)i]*5ݓ}K c4j1;:1TcZ*IZߠߒGmv,{wD)7{?C -4ce@#+6`܎9䮋ke<2L6oZ+] [PQ|6x?9S浴.e`2ϲ)#U±lm8xgNQZZhCV %>Z'ؘӦEf-^/&dH7#ny5V[M~&T8~X!$W/̿ sTY5eTh癔DѮ2eR3M9BoQ)VXϙ[˨ i{2F{8T88<_m)ƟVTc8oc,xlʪU[~*5"ړ:[/ w eh1Y6ll7^#'q[BQkuZeY!Uo(NT-Iќ}Yl]]ZE07w׸=J{\ҥJ4W+H\7\$SR4G4kNk m1O.FwFdS=k#Wg\)ӭ $y+/R2?uFex_iMKT:JwW?yw:jWppս1[JGH710X` :{VT?v,Z1dXPsj:ďaZ8U8+i.u)ރ[[9fV#3rzu*kkq7! e 7B=sQwqB<9P>[Yr9 kJ7ݚƤwd21g9-O2<>wr8oεF2fcFRvK6%6hD <73qߧ#x4LTTOv-m,>,8fk5(=lmI%i_,l9,s)5&a ~͏(LQhXUݵ1Qc72d_E0UA+j>Zյo4>7Fw1e|rܶp1lJ]MS2#U^XE\ӢQ(j1\cPTXY=31f݂?/ƺIZ~Lm3 {LcrRFԱ5eRэ▾Rym@cw!'`NSܤ1J)A{߂53,3I,1m q޽IN⽌+rn$C1*H,zgǥhT՝7f |B&TS"##`?]tyCGG-^ރسՋ3+^Toʝ(>ySM*Sow]2{C=P[{Br;郞Rj)7P16Vmѷ?)S\;}~ pFԅ\pcWDj9JʌЩo=U G#p{WTjF[uR_VIWic;c#TjJ׋zΥש^di,#*7iBW*.gg'*r6 |x59C⑵qSt}Byi1?0_֨s8B8|Cob&i<-n-?OXΆVQr(}OONz_JU9"#F1oBo7 F:t8~u>fmpUeWi Cqr@##ߞ+1]~'Eib# q#In*.xhN:QNZ?˚_Xb%Sys껱\~MJqױՇ^IE2At-̑ǟU!鏡5NeZ3ԓU:5BVw2dj#T=+>(у )jkhpU*ON>k*L6oAqO®K8ԷVhE +%NWIӣh%?4Kn]qMS]aRSDˀYv^DeOV~E&wlZstTc'wbM{)֭ #?i~~VwqJP:P2k I$%-+gn=iKv3Q抄tS#Debqt(JP"ҸژT$9RRܒM%߆PEOit֩}i˂6iUQ{u2(׋P]L(v˷ g?|W4RcITW_,f<6Fίs/{aF2rM '}F~SSm,T&ւ"ǘbr[+qYF-_ƥNfAoj,5%h 0 2- sSZ\TsrrܘLHƲ+1xSViM_K,-W4̆_4x}jIhtǡxѧԁm_\63ymrFU;v,!YJp[v}j'+ܘRYim,Ui$,ų#s#>9%nޅʌ{~k3jf#,drG'>iV厉s sNNtmt>d#뮮h>^U%dNKwu+c 05ko޹Bk_"з ,$K)ROB ֟,au:6[,ҁQF4baƟ<_kl*bNt&ҞXZ7IH+׾yTS*tcF.X҆\F==MUI{1Ũﮅ)H-Ժof^y \ X^ngEJizyvəc[;FGSN2:ُJ%eo#?-x'= F71VuSW{ idm<8G76撕Qܒ56D6J ǡl<ў[rT$7S4FFKw@R>;J7CE9T<).[):f+te!\n^=:URY-;YsV53]$eiX`3u').UkN-Zm;o3Uڬ~}\c91Tc/Vƥ?[xR\mrq?S[0KKk\Vy2,*X0IsCR[s*'N.^%Hi Gԕ.Ft)Y-ec~rjAȲayH8{)PoԜj]F7I+'JRVFڤeyW[oQ(ت5(Jvce&ܻwosTgfѵ|D=tʗ᝖('PۛsvjNG+KfWS%kG82K4$Ү/?cOދВEMm,jv+ԧne#GiA{ԎZȲ6ʲ$b{ TmQhiQ|5Mͽ aumd#˯QYN56c 1N[?Ȃ W2C80>U;[;~u2u9Ӧ!ʑ ?sbܽz[[5moWiڪ3GzTK5jJQX[ڜ/̹8*רNۛmmHDKEW%~ST^m5s^H0y5cz?&R&`LsrYDDTXc)Jkސ*,KWʹ/穧ntTU$ލHy{16F:|і6<ƪ<է=; Esӹ$C*rw#ksN/z:ԧZRs]:'Z IծT8pFԩInUe=*=m^~DJ]mYͅU2:.m{9sRKi?} +̾bvMJWRa;kH۫U1G?^ZFs/i~&8 hcX p[5HMΈЕOy"2$m1b .3۠kI~T~ -;B T!9M]E`,nzyTj]i\u4YKT`qnvzȭS6ӴV'_;U++Ü 9/X=u x9ѧi6V/ɪJk\R`9c<\_'zN wȋ첽XXة+XZަt;Pu2̲akՉQHzu#>6,R'[ #y8 I>E72qZJ1"u,˨GmFscz汕jRQyWrk"aH#*g8nj)?2S)>]=i.^Kъu;N:q܁S+)Yo߹GGO_M-GKoX9J59*u (b0.߻ٻ/G:ukETpW9TJ9}L1vvA9EbSՙǞ:E6eny}79G.ZqFRSL4YɌr1'jM:u0 aī$ǃOOʥq7?sj޶A4E1epx8sԕJ )$bO[ ?gS^8+HȢKx q\:sFÚYK4eBKs'׊= fwK{ʻӐǃTNj|fmNIR|Շ̈ಳ,$8j0_zE #ꈑ#fb1X+ؚ8ovmWuĒ,FUcQAQR-߯rEhѷ,CF>C?GQ҈lM8nL$0dere#STژocEz+\-eUzqNU$}̥(KTO)ŠpA>՜[wLjI_ >i9//vN:u&uTVٷvߙ:ʤjGݐQǶN_5ϓ,D,KmUQ=XG-:TMTY!EʉaY}>ލ>u}\\yK=!wsNpaJn N5P{(Fqq5dጝOv*nIi$P&TmGO=J74 ^ϫG -s!8'?=Xd▽JU_-RI;ոvC@+:*GK۹hԕ-tJ.o6F\pW~qRD)K_2}:vD$o@8z)H¢Ra2n#*{c4#MK)Fy;ZE fiT% =m)C+Isn]9JTir32t(B$#7%ɻlrrr#~pj2|{ʕ שfmg6nzPS^di&ס7Go5דҌU\VWS}Ĵ'I]M0^c qQXԭd ' 5~nYUHܵUWGoq]Xz҃V˪`f'uڬ7A!ԍ8 '[vrxɯFF2RUonJ+4+*|rAF89$qխasYsV]M2Ö)%9ckW_V9T*rԵCr<ݽeQ]TkdtPcWkeőV0rr$޺&蹼B8/vϿK ˺6y<`+ju-lr.ㅼ\Bcc9]e#+ɧkSG٭w},g%n0ER7RU-kN<|[$|y!`]?i%޾fTRrdX&, cV`vZnzr9;BKXUݴ,l7t;zXJOj)Z2Km=z r| AnqZJ|rq,?H>qghZ=mJ1!bffo ons]J*TTŅ15qxVqZm3t&wei~i$Tc(b! 4t[ PL4q)6:ubRNܟE΅dnݹNO\s1,Μ=<sV=[%TgZrU, R<ZISͫl;*F6{x^craۅnЛTn/5(ӟ IJId;\ֳu9F<6;ffk.cO8'ڳIŢF_z)$H&u ͷbAstfuUJM{ߠݝӸVcv@>IGٽMnY%c9Y{H;S-#unAΠPmPJlFpp1޹e+=֤pq2>b}s2\B#$Og)S??XRS8MŸA)YiZ yUH͝>\dw5k[)Fub8kHSr1st1JZ5Sђ[>6i-',N2yIR-SE: ЊH眳K4s?>WR1¸>aVkF2,0 ;Gx+?5}YSp{'c3;6_?5Nuq48D B"uejT5(}GjҼb4#fNСT I)T߱(ʬ+4[Y+L {A\0onR_tj~ʔu9bR$ıʲޞZw8 뎾FNI\dŷi-P 5 y1y<b/m$S8ʭxIiׯb̈ EXOzӕSkGݿ2Ԓ%\meo8һ쬾֒檛Eg<^MՅ qS>gZJ, 8Ռem: ybs/51TS{IB Vɍȸ$s?ֳIGݒZ~1|ș!"`ƫX;ֻJ<Nb(Vs~V9>t||,E$}$bZ)*0c+Z~ҢW/Q7"`'[MJ #izsJIG92~YkD‟ʏ+M|pr8CD 5.13ci[N23k4)E/zZ/n|o-͞S彖ϖJ_p䷞bҫ8 "*Orcw87uM I UCG1jyd%s ػLv#||zҝ8jv{Em6#U۴`2Hvޣ4gF |˸0Ha`*yfuQ\1񵻿*嗡gMTJNc ˳0c_a񫍹#',=v i1:Z:Y3e'/Y8;cչJĜ# 0_CJ1򗲊@MܮQr+F=Fz?Lק+j%FʲoUb1ִ}{5lF(P;`''n{ºe-lփR'̴s[yU=9* gι:h[sry暌*R[xZXƪzǧ>k$RF-!+T2̕H4N~\Y8?W9?AZE~S¤ZIȅ (Y [=tRQEKQaǵ[^}9J49sHj&le TYHxvonGksZQEǠ&k.A~cb誒|gǷnѳ+&+_ "(VaNY烐?oޤѬ},LXmlQ&ۦiԥ(|%DRfvssJvS5%yZԍmk G1ϘzT":Rs_.p^4*d.9]ͳT(v4J%FHUU7GN*iku~ȸu\f[T:Vhw9?O%y Pc&rHH+=tm(kf_݌aP9 _ҳSg _Q$ I4N¾F˴!.99$B%*~N gbe޲,|OƹEmqrDyMܣhN.I_} h9K[ o4$r/!l~Zj2I1i6Uv~lECT2A{;$' sr9+>GcJi +49#fv@Fu>2o}? M[~l fv 3?Ҧ\|b')k%%۵Ԇ&n2ޑM $'>ⰩMluaiҼ,"۱zL~lbFrѤVdW]`F`عSiL×ٹFWzXGh ~5n⌽H]GV++_/??RvO[YaVVz܎nm!JӞ~ZI3 ?p]~|]Ö=yhewW$Bptҟ|}RQ^4ߟKK:o㷨汬i3Rk^o?5id\/lszV4w-FȢب ێoyR] UI+30 `Xn}?3XTތASpboT7=kLC)+lA#2وnqMgR,[]rGNZN,${AfUH-O<w8+(?Q|w̎hi2$@*TxEg~ݬ[R@rt6cܼ"3:w'g K+9cOmN%$hc۵c2.޺%ъU&K ˿X1[:3Se@_#Lm /G=8qޱJj">t[8VxG-䎝9Vn$:L7 b0]Owr}=T$^Z &?k wɸc885e>Mu|ʥ*2S}^ŇV+WxUwll2n\@#jSm;|7o7IgkoBGM?gRF߯ȭgk Lo>ñ==3Q: g=>ί:w}Gmkd[yp 3$t r4UT?ZҤb[gA$)gT#0NT#ӹT:Nj.[K˴esSRVZknySTy2[7*lُcwF"1=-w^f9Fwo]4Kiff-C.}TjE[l+SZ~c)q ŷSxޏg(ҺWƧ,jkf|%4lnWߏíj6p1["Y{!]䝄玸5#N4ܦJιyuЎK NO^^Ź_wcej1`)al\I+`XnkISh+B.}]Iujt#a|ʜ5ʕu+ ul \ržZ,V_sx{;lu$&Bya&{w99E:vkSNOm7o; |FYEaǨa[ѻ\\ө+{-̹F$ɅE˕(%cNQjVmXhH1{c>hzQ䗯+5"†nKu>*rWFNR斟ɮ3O 4a$(*Vwi:+`i§mS{(䌪ndzrG4ջvZkTU?)_!#0sq uNJQjKR.[9U'rq=+W͉VMOȚF" ڥ<j:ivkN<>FORkxYھ[69'\ W]46J2X, W /_qWe>jzC;pA-U:mDbGt1&=1[FT)w\-;XcjH?qr(TBkaiw Lq*8'8rgFtk,-㙣UěH$˟ZFjQԨ+t2RхTPr'<,ks.ЛWО;r4>jC `kEQ(F4yXeBcZ\Ѳk8RR;1[QHI©v֢uT>k_Wd>Y*>FէIku}yS%UFTc] ,=);s/rmRA #k?ghqBMt9L;UaZPaNPr[+n _Lt_Źkݎ!UX Li #HRWۨ (۾eV(W%O׽iٙЖM[0 _1Tt嗴q[133*p3sZsGښ4Kv 9ʥV'Rޚ0O9=Pn|'~k2p0ovG\+~b<طgG, DXF3㭷:)rӎy&:fymg7O?Nj$"rԩg!mYZ=L(' J?xKލ#h9rxG(1!Dlq.й ?ȩK1+_k?#2Lq/FT+- = Vrrv0Xzrwc͔|ck7_\\ҝ^oKduc0Urfh-mЯ%K'f\7^9ji%!PiV(:g;VOލQ7myP+39ovOdT^|IsDIp8%5VX#UukOR8UeܭjqtqO޽qՑ2"̶gK٣0G9&59ڊmX_Xi߹Nj#V)vۏQVUN*1gƏ3m G˃c/vwv^c}/k 6P\4*\GⴥkRԊim58Y)d1e}@2 mRvo3be8kq)Mt>GZh>n=ֳh ao|j5^Kc\E,7̪Iqǹ|"SMfS e2sy&+KR%(kni~cFf0{vW*2FJX44+˻ Ο4tFQq74$q`KrqUN$udֿydء-8[A>k=nV->cBź4p?S~:?05fuv(J1wES\jZUiv bJ{'%vǗ7 cwnһ}rR}Ik6$c5Gsjt{8B/n:쥛?ʻaGf~V܈Yr>l=몜o#ySl)Iai︱ .lmJ15'Ừ*G k4 eO:Ur+9GPr$I%XMl53*Rtd{vR=zu:u9yWsg]00kQΥYsKO"ɋFwG\ֹ9}/Y+=XʊW5eq#V^h J*< m\=p1qԧ]SP˻qםV0/ݦLW̉6x%^\ĮZQ*i:t*Qs浊!"wuz}>✥v3Jɮn@#.ߐ,N ké*q5oM٤iՄ]3.wwĐ{c8#g۱4hV'}=2M h_]v'ӵx/:IoGD]$#d,nIGSПʳQGw{k>μ%:j $VPy?jB.Y{/)SKf)F_q";q뮧VqfޞCÈ7!p~!yI~~!'FԄR05cNQ=-5ylf3 VUkg>*{;J(֗*^#k ]ך&%NjEvEज़ic=9 wvPjrVmgle`pG##kzt~wm3s{ޝxtŗpX±*=։TjqʚsBU6mßzuCoΚsqCYD;K;zVq)K|!ӔnB-ﳼNFR62,߽b;s+pEVOݻⱕJZ)sRg9.#v>Q=ί+N_aJnTh9VT *#9QVb)F2R}xI99+SrkKQGTo$Do40#RwzW$cR3J>+C 튿z_TT.ﭺԌ mN{MK$/2gV>XOHLJJy{z`uu'5^zk܍9c6 qRUN[]zҜekAn$lpv%GJ3JTA i%3@2=8Yӕ?m)"fU^>sm[w#ghgn?M<}g36+d0fefpTs\e%>0"y{M'LxbUx=?3U%K)h!{_iMF+T)iR!wo$G%5m0e?15ċӡWS/cjcQ=#"RfXqt1Dj%N1}?!{DR?R]?ח++rr]zD/fU=kF2Ah_H_4Oc8'N8.ϖӌ]B-V<:jF"QVehLyk;.2=}Y4mB CrҺLی{Urnng%OaH~OZƬcR\.*WMqu:dz#GyWf<IE=I gvjO^3ӧlTR} Jhmz߰BA#ЯʪOa?N)KUjY>%P?(Su<=aXRFmJԱ3c*1|qϾkJQtcee5('{Z\q Ce<5%m|ۆe.AV3YuISgȸJ[v~eF[r?U݉i)Yc-);q | tQuei꿭H̉ Z5f+\`;T.k#GN"ec/˻i2w RgRђ<Fi|(E'q~5QTvz#YS]oR9-\szTa)I9-;G 4,ܑ\-SUR*'gQv$av`g;=-;苧ݛnKO"4qu8{t,D o7]Tvzͽ.ԋ*KyICƼOG=5RJ}zdatEmfL6͸lֆ(^w_"OcYl5%h9q>Y^">k% +1n/kvM1Y2S֮RR?S5>|4rDv Kq²Nv{tP#a*UOwj% 1W"e*ѳ]d$lá>)ۗ]݋m HŒ}r>}:>dI&}Zѯt Ýimw0ڬ7`r?VjV{+hN>.0 G:GH@{gӺOS:nz$1nfe3޼_i%N)tF.\>I&ʣn:ױԃrѳ:uiTQ~xTh:}_VU)Tݭb&f ̪vi8i*sqhE_r81rNw0:җ*?z"t 8<:d4J"ZƷ,rI$TH79}z~TJ3Sj~( [E.Uo#}ENr~}(gnS;##:{UTsTs'f a&tk  TIaLe(~ڷ'EEv(I.3NGdT׭S%k[v2Uwf### ڪQ樦56NhYY `kI.Hfq|ʺ*{ k漒[1*U:ljo7n0[=SN<SNۮF4y޶dn6@N^<\+M*q1' s߭TՕN%%([~!Yظudm'd.:mIm׫.+. 2GgN, ~Um*{Zu9t{5)m32>l>=QR%MUL{{WTkF4:՗ӿ>u,ܖR18;RJ3w#cȝun߹k8ϿuRCU%mn6'Hc#gӶx>|M&nbVn=k-rC8хǫBNC|W1w(q+!vb˿.9ьq+h˖Q=Qso"}>fl =<p*;H][.[-vYW#<:Vv9TzGd?KHX2?>I^-˦\i~rF+k j9?D%'(J.|w_/&RIF4p=1WW75>^fԫJRjMZ];*l3mbs I'*2X *#oI:tk5Nd/,_r…^HJ* Q7{ 4tn'-O4Uf㓏ZU*<OԦ➽ yAڀ!ܘW ۻjR=c^:a'N?udXvcNsӫ-o}t;jʏ=b%kghY1!{?jUFgN4ߕO:: r7#:UEHЩSwvVa߭rQQqU9_b̩!˓4b6U9k_+3qԽ!TMnGDV8ͻ$PAҭ.dNyFB)Y֛{c\UjMZDøbFŮ KmJQVVMls sQjLeZÆ8JgGj:Fkr˖IV8͐1HweE_R8voN w3,+azҩOY/mRS4o\Dy/fk)|:&'Իxygi"gKJP1)ƹbXp3ӥ͕Rܨgw;ev!]Ny+7)Si_ʤ)ʷ+/Ԏ2[9bGNUש*tKg ѼV==z=7i';;+c 7Q6nemn5ŰcdĞa9={gӰ'RZ+&JjUWs4flz]UeIX¥B,*nb\wC'NQ$ٵXv|#JUfi rkтx+m2S֚ݗ,'yP}{jTyJWعeq,t]@?ֺ)2v[IF+n[.MYNe~S9ǾET7~h֩VV3JImC|d+7@qhrG*߹n7 Y{)raTrDwN} Au7̕%%,%Nco;t5gU:sbs03=Z*f㟥aRQ9J4ԧ75[@aуmjxg=kʋZA&6Uln¹5x{G/M(kfVO+ᕻq5%#]Y}^V!k5Ԗ0?#Ej0z j#yv$Ԓxcr;y~f^ҹch.uvO}my/+?>a)zTR2IlU{x%$$nQv z֦5%Oeg$hՔ$DR|2)5Zy1Q%'mp ʊǧBs:U2.kd46^|ybڻ[Ji*5$ž'$.e"L(ٮZZ6uSN5f>ޛ'f]V3zOZђQ׹VS"efG_c+iƏ4Tl,N.I.2IAe& cp=ɭrg{=퐑x:rn璓w)Q*-ո8Vygh°I&$ITewTtRjVӯXUYVDq.#c?6Kq9Oh7IZǢ[ԭQ5v"Ld~5ԽǕCKqoY,1z<ЋQ۷CJu9yk~$sK4匑?~=AֵS8-{ qzyGڭRw&G~/ܘѩFMjG3mڲ۷=w.ե8Ճ_c:)Vebh {'?fc^e ' `zc5^1c=CQQiv,G-ŬgI>l$==oN73 RdimcPI#VьSmovֲ\Dî ߑZԫ.K.MӣvKDq{c:ϭefJ5ԙ[siq$+|w9ާFjU06ervZJZ}jIl,7rN:`1Z9Nf#5]<̾eqlIls'Hu8j{Oh[@آNp ssR*qeV+][UB{I"ǧ^#8ѩZ<;!RI|Տ,7S7%MD[0V8]M#'~mGKJgi}Jhe~Ȏn](D ǓJq~ҍf؊,ʲ yĖ<ӊΧ>N\En-o-q<.m瑃׎V(NNXcv]-sOod]YװZsS9o*&o ՋJ~ήWoڭV->Mf@2/֖ǣЙbjj7M?[Uc#8TEUے:n ڛ:߭ɅI;EFy̎4n]`u3ֳPj #+);ycgf +Ny-Y^݂U9&D5$MW\CDbݭN+ѥ;}Of{ia=U^ZŽW]< WrO tVºNǞR&1Z< 4UJɳNqޜjG~F…9s݉C Q(Ix_֦Z]jXۗiUVҰ.i]u*}NONĂ edoG9+Ӕ_3 xІϷ[m6lN'Һ*GlٜcFu b:}?ƳR[S^ULɶ\ݠ2?±$2,o~9峎CXN(Gw8qU9dT5ӻX mV?ZEJRZ{|,kņ?9k FlN]z 捺7\TNrvOc¦ <[mq>W\$rƜjTY^I?=&6ǃGF1㯑4TqBgr΍7fH8"4txYJQRw}lm'l+$:TSt9Gq^^?e0C@/# qYr=-b#Z>MSwK~Dk?!I1Hc|Wxg9޲VFZ;ӷQ O1w/L8tb',=5 |}c-+mP[wsLGjIjva%MVqY1W`i>MU6]͠aN2{hSw鯗2cɓzy)J ޽S'$l@rM',yA:~ǕJ#_WwؙXndz~^ڤwF?4mon#ހr"e4hyjf(\0'=?,Z\Ңޅ{j?1'xl 4'G'n9;tGJNs]WK, KW{H~f9&}oBm@ȱȪm˪@#/Q|W]/秩횔d5]N=X5]ܟa޳(մ|mS (TS_w=ۤ"F!~%>&hW_,j0ɍWXnw6d${~Wpدwn}[ߘw+$+(#'#\8FWVg=:xͫzo")ȗ6׌0~ҩʝ6ֿ?gY.ڵܱi "q߿/ NNsFQ1ITՒNd)HIg$In.{;~CWi>4 ˟5NyF.\TBFdꍞ`{l~˹L9^Ы^XîK>{I]XT1үZR&k&L$޻iy'RRF-v2gzJN,-^Nޤ,*jX7uoҝZfK1nUV<(zzqPܹV&dʈHNQסV~w֌ [6/9}+ZTjsrvv#;to :)J>ѓ,ͺ;h:@=ryQe(RH daS>U%AJnOֽ=  V2#t'8)>cZ%kG{s;J]X2G+t.:̎gpou$(,X3#5XgQK)|?7|2eye^7H_zy+Qcu+\ǙS)u# &3|ѫ@gC빝i*AM;p?YRS3Ng-\aazw?*{\'+7.GV$)mp xǿ 1 03sX- R>VzM$PPyjѩc>18=R+6;~J)Ǚo弦"nqc6ev?iy C#p3?JQ]Z\[+'Э w++:˖zEiLD/4P2 <^` ~vJ)(dg8Q_8<:3pDQ{tNQWG?\viثpî8JUyi?U>grl^Y2vmO}?Zބo&8IWNnsk/dqiq=TT^JUwy JXv0Qw/:{/Y*>'sڪOy.wZ-w~hĈ9ןa*2cIP?v6+nz[ .(e ߬o1J<`}Nk->+R7kgJ(Z{_f rFMvԜy6pQkMikD-H+(˖,tٲ8ѓ#+Cc9c|dw`p Uڄ4Vi7{ O![HVF.͸@>ךڍХ_ˈKwONI綹6d[nݺdg5'Nͽe/Sϸ}m>>m ڪȋ'$nxSJG]>eJP ̛ȱ7Gpje*nSӌRmiC"|,l0̹|g8vƴW.rƥwMKCksY!"cc8v8RRktd Q[ 36;x9$u+_N8KQhU~U@rOQTz2ULDˑW.89uGJ@y8_!cW\,iS)9K-_3JRߢ1$vcۤ#/x*cM(N,*LGֶy$D%ujI}Yڪ/1H+irJ)hvQ4ck$"g2y[ː'(Vƾ҇o˧42Ĺm,J1fƼ*z+uԖ#;)@7(m0:>خSꟐFJ5ܞݭ~k.ƍF9?JYgq,! ZYrD\=%F 1Ү.+Fu˹-hcQ<0'ϷjnSG6\\+F[!lO9둎?`5^O2A~K3r:>]ni(k`H 9]*՘TNVa)ʓ(=zOoZ)ӊzS[! ;gnVR,9Qo"2WVS:c?lEΝ*qm>@B`:+t퓎(卑>Q؀&nyPǯ$~T4ע:*J2F0HNNsU(˙>qǝ PynkHrKI(Y qד5|hRn{A,jreP2WnO~iF4j$syI{{ ծX֜}6KjG~ơU[z`wN*Q-ʆykGOWBtWE$$B2鷏5 npLeJO^3Ip'=y__Z-N2?? fPP{ViGS7G#21{{S72D-DqKj*XT@=]R7$H/#9snxiF(895M;z-1n1Zrƴ:8Ǘm$Y??0͌cZwh4oBI22IUNةSp!O)4HW*t5aמ拚V]v,:nb>$}kZ\!$(s-g՚&`ۈgrZ6iI!Eެ?ܫש5=){II-F6J::sޕ=M܊ hQv7n*zgڷ(J!ǖP_1ב( 2=9'OJ<ܯtZ>.╁56(c.W9z }+oqsJm3y1lޔc%4rRh2}ݲ9~Z4֜&yj2ߟV%Sݿb11sц;F* 8'R6M5;n)Ha# ͌`*yefevX$UK=D|?sURtʜc7َxcEYeڿ+*~ݪa9*U̵hmݴOjKm򟽗ӞWͥI7@w>[%V F8<Cދh2J ̅.`g^jg} j{g( Xd_2xͧif#>ʉE*R[u%7?xڨpxAt9c'UK%bA I1~0,6o'6$=Jv݁212}*/y#|zkbYKrw#[@/vA}FYSuRɽ9JZ\O7TgsnHV)JYF۸B 摾ķ17/v{[+?ut,:8ϩYQZ*iF+o剚;u?*gͳ?Q\J2N2敾>G%a=7;sGJHK0^O6?pp G^e[:!%nV YrʪUdoY%m2JQJQbyd#P UGc?犏9jQr9=k<^JQ֌$kSGK2N=Hʭ,Va \ɹxuS9'-63iˉHs\vctyI*ޱK4g)ZɈ0G"$eYCP%{J\I蟠) #e~e;+*|ϡNTzm^w*8>JW^Ҝcv}u&Ty0ovc\G<[Yn s#+ryz0:)jXjjl/8K9eOIv+[Gf^YsJ+BR,u$۬sck*ONֹnr,Y;_fEf?19ӿҫVo6+J}$f $?xgs򕠌Ƥb" Ys>R\nRg+GΥesҌ&C !aʕ;N6`ǥr掫VʞQЍlpy|8jǙ( B:OO,-ǚdo^#Vw~юVq:&DLᔬxv\3sJ[[l[4% 3NlW0Ǹtlb{ߡ 1P߉FjR쬥k`z|wj'+_sq#Ά Yan/ܵK9{]uQoq_= `:uC_Aӵv.2w*@޼iyZzeR4GU͜X:qR}qcL)Ty$sxW3ֲ﷑ŌH]ͫ{YJͤb*,˴eV'83\ROhu:Dhʜ\j+]u+p <`v㯽wJ.%49k7mnM$,#=xⱖ>Zio7!cL8_0bN?0Yk5)Q+iG~ bXo݂it}IN6g)l \qyz֋VSJx)=.<4,NU_/o' X*GR9X:*T撾RԧF'w-E, ,%d '=qֶ(NE\LgIۣMڙl|D;F$&}NOTB2NvVX?y8M4E=n1'woZT|f^4=3 FyL9UxO]tFV>*m=B{RiE6(#1Ԋ)Ulֶọ94/Ic ʢgPLc6OHG/ciT"W}}V+H-~\n=ޞM*Wo)Am k$nb,an9E zۡ u#Ý;maΖ˹38OS:Q_6gq[lW舡_]#fod sglVw:ӂЛOĬ4+*:cU%Z6שҋwzhY[hfBqZNg?JiJjU:+;'R)n˲#6n ԁ ʹcjxu}>~G>/{-FO.ym P7䟥tʕ:\*c)My0LP8һ# HCXB$$cj2mJQq5cz.[ΊcmbhOd}z6V(Ԕd֝ǞD#Ohw#rL,GebV=1ߌVeNFﰨA-$c'jV\u]_%bAp[pO"%&E+C2f?7~$jy=iC5T|\8$ڷR$BOzx?S)FXxSMnVFS3X~_o+h*l`g͒FeU wq8sU6K RӰG,cxVR9.T~1}}]'yC3._z_wIFC/Y2١Tk݅9?'sIH cɨ^4'cwmVl r/YO# ʵؤ #SuNWFiֽDY&GѩU$;n=zJu1eNw`c$2e}b` a-哖z5$&M@GL$oJTGd!D6U\z{d岉*Esw!TjPvl`u9U(ԽXiJ9b9+mn\p1NޒT߳i߷@uiR|nXJ cͤ&9Pwqlo̹$m>8rΜeS'T4%%&]de|nג>}cͩR>#ˆq\Or&e9Fk؍Z)#xn31N{~U/hF-="nZV(1ѕ{\Z۹PıasssӮ+ͯͭing_J ki-QV73+̘ %xڜ24آV#Y7(LKޒo.EZH$t]D~[Y2:H HeFc,x>R\*:zeW3*@+sձθ*J1z};z~%.Ӽl`;~ֹe.XeFyT]HA5'ܽ~1d*q\lScbɍ^qꇈ*ҦWRńo`-WJNF\gk>p:QO:ɹQJlU7sOzƥY{K׺Xu.9#~?Xo/FqeCv;u8֔)K{ySjr'cS㉷+>y#@U59HSil1 5۲݂c=c/{3M_!"MMm: %dTes\Mr["-= =HԌiR\g{fhM+Se qӥWŨNSc^mo$&V VD?9$ V}fڈsg^Mh.攧1/(v4r323 z]x{N32*KPõw/Һ|3z/WO{_[*$G?5FSW JI4[T9z:;w:NNw2[+Iow==W-a2T%f&*U"KN $F8sּʘ9mݜur'rylS u^WD(ݽ & g:q' ђZ0Myu7,mH($|4(Ӕ9_/Z[6+i.gS֎l|awλcIr3r_E/Zj{v}zvJ4"J"ew .B4)N,O}kzqʜf sUٗX h(AQQc;W9EmvFO"M=fiYBq8涇/.Xz{ [b6y1]BnRkqSK^+?mkttƌc%b)Lks񏻩-Uݲ ttS{ 䏅òOO#٤&hm eݷi>E>+:E=H+r?{h>vB]WDhsn\WJ\a Ym;nk+l8}9̞kOcsmGSImA6\⢥C(n~ϩ#5)ԎF&=ɯ6T3*TבVydVi>Y Fl0$ X8əm >wĹ8>=.e  ɐw&) g{skt}Ksh֨dS(Rê^ExXp/FV"EE`.d~#\W^6i֋V[ zיSٹ9U}5qacZ%m:ȳ 2_>m ԌE=T1̳yאtm8.]Լ4L#*n^B]d]y9 ަJЧyEIP:mˌFsQQFc{;#z[W NW`t81 p|z2iSݭ1]U݌ᾇ'>+m.Hx)z,U}R_iRm^m MkUR"Fۀeg>ߡEI+,DmV⏭BUNJiQǙ'2)$@˹WtC8#k*vw0;EB:](weSY:V"#FUDs# )<7g(ݿMQ%1?20mܝ޾NTB8%AScY@ܣ$zcTzK{ulrSi54ұi6dIH[]*ҼXG+T/<}*hX{WwӲ E8ч,dԅd<*évsRmO]EIh|fV'y-:5x'Di9uQ+2Tehptn9֑Rr^]YQ܎Ehn92q։T玊׾}N*aִcRrҥ^y.[hCpZHbz9Su35>jumm-]H_kgrOJ>ͻu7cx}\G4BU 5c3_ǑW2HTD4kK0ՙX(ꄑ~H˲ /Cy:=E%i)*pI*iT WUY{JLcIӪḣuߗ$P\sUaSIzU‘)0ij77Ȳn!TОxa߮ކZS42ѩ7 >Pʌڢ2u \:+3LNd.)]E;ͽ߅#dr)^2{rvfO#aJymw"jsԒleY*l,cF@}:b)Ɨ4_,-LT$b-{hs0IwUskn#RXv9فi2`gDt*Gj#(Qgvv^WU.^YӚqktˍŀ?(9*3$=)r1ȕF&؊o,skNXTvԚ_&)N8+'?vR掞]F^.2 ܳ<#G(OKX;I7lEӦHW5ku1RJn?}N]ϧ?δԧÝRԗ=#jl,X=qZƏKmJWeI}Q+'e.Xr]{wQ(R>oX99~t'**zH!F+u:hQDAiTXʯUQPUӦ{ S0W;wOs-Grd_|qk' ]y==zVRc8hCXcq=GWRq/岙7cONu*F0K;%⤒}s<%ݰ_ZڜR-RUҧtR,C%gzp9ǭ]:2w+Ɵ.gdO'*L#<һ1̬Lp+MJ Gcdz3{BWiIvB"ʨ!v?>{kZpr^ڑ*I^H^F@:zg4ԍ*m˗UW%6sQʸu"(ӗ2mnwДVŷߩ #, _Ozq)T|Τ}er;[bFhDw۷c>Is$Eѣ}{4`]ȥE̍ c:r:iAsi֗9cemmIr.dQռ\yb鋧NWo~K \*2y%[pH֌yNdgu [G,rC**"ķ^qu|s"JIկ!g6 hl| =:ОiQ-NjDZR1e2>lyl%&w}zyg w-V22p?,VDJRD#N'eH&Km VIr/_QR w&, u=+1b1N׿QI n*Ԫ4o+YhF_~V@\ޞVѧSVtJTSWO"R[JJF=jNz6Dz%ZtkF<*RIYU׳7"7 0ztkOJPfNMwLϻ\#<[T~c뎵)IJ߹5׳JbbHp*+]q3޺z[%fά&ky2G~&)/Z1J(]Y#7 ,OC[ÒbKZm>E+&!4bB7jҜ{\((ڮ[ԪoPR(,C"Ge˔[AiGkEJJjWC<ĒL܅^Wq#JԔ駡-+_2)d`wgҕG:m$Ŵž;bRNZ֔b$Ԥ|]UUVe81JrJ>yЦv++hQ2hDg\7!w;֎_rϚjhбͻw 7_Ҹb9s#̕#{xD6fI ͕*F `u%SoM9sKٱۛiuLaː}:Уk-ɭߴj>Km\gEgS jUu]<ΰ2,,ǀIקz^KX?e&pye]cn_ªUܩnr|,pbPaTtju1 4ԙN]%=.9A͜W rWh%xAgRP3 gzzR1 OA32s19$c:FQ+B63q tv2*JxZ?ѳRi7c«aw@TdˈՍ#VE }x^3SSWRZGK~D2NbU5ݥ&RESwVf0S~}*^h1Ymp*sӱ \de 涩F;[ڂ^{9b[3wșOdƬ̛O*z1ISO/X҈Ɵ2Hޜpҧy-{}O"nwwaJ5%dr ynAϵn3zzr| +<ʬZI\C8 ΦYT/ݥwDEl(ިG7tJ&\rW1"dV"zmb$qZ"JFe=wyhg,DX)Z*pC^qT#*4՟nei%X^k-+I!~j1rEE!P2HTd-q:zUJ6^;[bϚ0m`9,ޜz \R/ 4VOrl|5EHʝ*k]a\turv+̯.!Ay۱q]16r0qs=9[UCvc^4m-RN* 6Js,E]ɻ9ZPv{w4gokw wHȋxzp׵mNNUGJﯙf-۳4.ݠ1{g=>{'̝2VzQNRo+@6\f(/;jwhR1DHdLlb9ⴭ)/}R4JV{eT :=U|3T%BZ_!$IbZװJh8mJTNmУ{z mo6ƣ>8t"'&ӖE J)K6RZlv1RLNji8ԺGDrmo2 Yo>Zn^u%B^[hǯJ4U9V s]'!m"ܼsO^:VܴOډaiE-{Vsv ͸` ƹ=e=G޵~|XI*S G< )>nN*g=7sx?o'·M4,$›yxzֱn݉"eq>֩{vB|I۪ƪY0VR<4Nm5&l{Vvg ~46̰pBen9YJc+{ Yz/ 8xldt]ԡ*Ҽ 6/68eƻrxjRu37ߐwWnS'ʭ i*q4.5+BVm%KoP G,NHpuܪF߉cK^t`ReE0Z³(mN*/Ez^?ӭd]q&G y=]vsJt,/4l+N۴r9sLW/,5IZ+NlK&'J%FuR5; qܞpQOa9-4S# [|,mrc<޲Rjs9WUU5Wѭ."{qlJ888T,֥D6[Ƀ[h{cRNߧǙ;Iڷ(1];4jsKБ*Ƣs1:֍0|va XG45V+ɽµeOIS$Y#B H8Vq*Wb]{f4Q.*%y\W o,e dU+g溥RάMz%AZR{XO,LqjRr/mNMo]݌iUG 3Z4y㼶%PmE.ߐ# `Cz=kqn2Ǝ"4ZIݦNF8hƊEE8 nTeA 9:N6zhG(.x=Nx=yط[^viSBNk$yhfǑGN@jMÜ4GZ/{K$X*Lj}^OhneثʪUj~?qi{/غt,ؖB;3\%ƵKՋײ# =2Ly^GR;S'mwr֜kq&"[ueyTȹ *cԕZhkĢisi$q;=n#Ӟ*gebb3^Dgd7[9f~xF(n1/4)EkzfVE_-x ~JIhkGջ=2Gtۛ{vDycZ˛pN8?wWbhb+u/Eڪr15tR=Xzu"JiE-f6gc!a(C=MtT_C886r涶^[1&I02W3/mWӯ]3e5{顗vt0xҸeB5'NR{=Ա<*ҠF62@;tzxPLSFzGk5`_$rH'>N)ƛgm5Z*n1[  w ;?P+j5d{*ѭ^|UԗO[H4$VS*rp3]%)KJ|hӣ(k+v-M2Q ˸O@}yW}_ri֜ivYYw3H\ 0|:z1mDInC*1G'<è TK*k]DbCsQ$:e+В34kGH_]fOݧ|2" $s:K4 5Emٕvsa~CQ:04.g4f0$Pn<o\ٮ11(^z_׎K{2xIm Xz~F"|ٜI]{zRkKyd!eXgm.O^OOJ1]u(7׮$/2vwTTc+5ZNqk6KIءWh8i-4[ʔ&)4ݖ.2dsyawHmRNNytZs\ڌRDc[!dKciڷ D!:ۣo,!Te 6@>^+JхC5JvX'Sۭv߼Tqے=/Pj~bӎq[7ucҧ qϡ2Ȓ 21S˖D-5]s#9R3sa,"i`{2#A:®TN (ƴI`Nq䱍P2I;z$NtRrm9{:[~EqOv`d+.qܜ*}S=Y.${p`v}~])hb̚רA&w|f55kR)>pFuk]M*Ɣԥ;Z1< V6QU$n#'SZ1kҔT6k"<ׯ8X^Ro\u+Sq¤=SY,dRm84y$MogVTeYKo5e$᪑j/4PedMnx>ֺ%)yzN5OE'-ldw3G1<>TʕTrtI[%{ ˷mviihUr(Nq'j9aX|1\ K\qʥt?tN\BKew sV#R澽[#nKPch z*$l:(pn4nDJ2 [ }y*q4Gǟw P=Zty37^ВX昵vq>qSSuRJ*1uXInC5ejZ; *l=vL - DlcױPQt#0K4iѮQ:DOo_-5EҎY+_-WNy8{bʛ0{Q%g8b8cֺyRTێc ;J<:K%*koěIգrNszdrh̙.#K}U|ϕS1ZB\$Jd{ʪ z۷cA+t% $dU;c֊{DF7wafI1`ms trI2YMm \<*~f?6Fz>jO$;eZqxh捔> tr5utc#5v^i5P-4&&+4ʮMІqn*侅rKX=cey,32qS/rz[Wlռ#ں"4pC$2H.eHd,>nAwfvqN1[ZC_1`Xfv$+uOZ2hF\$˵Yr;xl ۵MN:]G^v͎ⶏé)Tw82sl9J $UIFIaM<ʖE_/FOS}qWY- b(.]P<]'F3uB*4sogxKv#_c1ZII㇗7,ݿT2ibFTZE9ؚ覥-eKHl4m-"3 >]u9S GWf>.15GchVhGNQݐo% 8d5N|R)Us+ۛcJj1֌b8,kn 4ofR+˨Etw,v\xrWzv etcs;36TF*GG5))+uKJd9-Gc[oekNv*2mk׻rFwG  [^29wm\ULr+gl~jx< tKƟ04S6bbUerOTd풖 KɍgܨR/Y'$w+sm#͑ʈ{~*r>2hL[\']'yzy?B;<2l]ѕP,wgڮG-%HW@zִjQJKqjFMlfH\L$1޹rɩYʢ_i H2 nUV?Nzv<:FU:F#?qLr"O>§%&ݿsn_.>wJ̪qҎk+lWI{ _̖0#Of8#I.m"2OWm֩4KHϞyoSj8TGÚz1eT4$Xhl ofmZ7OrTVm8LWܥb哔b$,>eLw#_,F9yRu"x"GA9`;UVL'Xpd Rk~;\*RwydT ;2Ǯ8+FyԕZ/!6Q;&鶹8>ުN.N7%IV9 IJ==ږ{Y:{8Ȋd2#mXHb2JQKU#NQ[ڲ66/L%vsה+b&<>_&Qͽ  [?Cpq:wc(mKV\H$f>tO1@-?7ө=z a2e6BbWHmLE9I|!X;Nzz*uj:@>;}jgNd]%{URl6?7XSVL[+9fi '8/h(܆{!vAZTdSwD$J,{ָyds׭JQ1|UvEn:gc޳VXj0NJm{3lo38V!J#/GBe%E0E"nGR\u'%QGsYG~K;/#>^|zFJF18 [mM bFJk>jzy g2)iU^q=jF+SU%̙nTp\H=*)srh9J3JR Xٙd](1'9>㑊nS[1T$^B\Vy!rŹ5WIR*]QhP 31Q3)݀}3fFuj(1B=x}Ee(Ԗ_JT#iv7M)#`9+QѝrZّٰ՝k{m+hfSrD"{+.b,dA=~Z4;t3劵g Fn6,ffVdU]qQ*,rQ橌qo_Eo.IݴSĪk|L(eRMtVmy1Y㍳ׁ=q\#N$wp~Q8-nċ<#߷"9I=sZ}]aGk=[9s rI$㐫NrPMs澻U'p'zu_A5'մtMaEE[Ⱥd(2ˁc'Ԍ"c,h$`p1*T-|*'3Z-,5Kx#onǵLkBq.UF8QjCe47$60| sޞ#5R)~dԭS:]#6 4n14='UK%k)JV="M2dm/׎P9*yGRJp-LOuң&˙O3qp9֭ʣ~M:T IX G%n#B(q vVv&ḙvG6L}9&?('yǵcNRjKWeҏJϖQ~mo=^9KƚT|"޼$JRW~U6hYC۴##cNoW^Ԅ*J}-:3ɵi=ӜDQw_6cR_Wr|z+6&u ,,XolzV>i6ׯkR1'[$T/\uHO쬴yX\Dc% yaFv`OpIi ɻΗwi4[|[=z"^CRN[+^Z[,wHUo9=ngJ\PgNy'-z| eoRhmCF}3ۜUs>[:4hᮗjb\\8G#kj|*IQ'TWytH7lNzJ*b#R)F6S_IGW+V9۞rOӿ\iG:J?g.#&Iǹ+qE%(J*u*Ne̝G{ۭ n!I!?αd~K'46j"@>çUMG:gNY@H|S¥5;rƅh?o&/j XG=j8^_[FOF.R%n_/_*21J2#{7L6!WA_*T3}; wrTK qo{ 7~CִvP却N$ q$6n`X60ANi[QRvmrJXo"i3 X-PnVؐ qҵR5QV_euM6J%G2$뀤=gޔik7ΉUQv"s<8cYn2'Tw=W ^r*WʶXy彸Y؏j'tJ]mV#;;$*5S=r z 4T*&j&VmfLorO'9aYɸ:[FQ{%t\\2Mo':ޜ)>l0xODxmo ޴ ;R/'n̛a)FC8*R&'y` 1.bϗx/c83]1Z-ͥME8Y nUmq5 eRR+ ma7/#5R_*O$'ogN:H֍5#ƹVS)HsZ>vI`M!3Q[,ު9:qWMhEUݙ$S]ʼn\dn+'2FdXJŷ7#OW,K'Fw#psֲtͩ)%!Yo"ܷ?S3^ iNMe4aT,l~a<-H5s Izh|W5˱iM%򔓸3շ#m&oU-s͡R(1&eWszI:N(G?1f9՚zq3'Q%` ň+EE7QI'11=?Jkڞ3>oFeY$.#1nstiG/C]cfhǔp8'`j^tt loU]ڹ>`ףFܚO.f,Sid,wN~^=jזV٬2ndA#R=+أS;nu>-JIw2I $moF~8:Oz#%F-Ԅf},R·rw;fSt\-]4 s䢝|V$k*cw] [CXzsp6༒RKnø<9ZpbFhg^{YK.7,dI~fbտTbӳ-=Ky(\Ӄq^;?F?fQ=vwc^G5*QhF6}L,*˵8ϖZt)R;K4,k|Icuwϧ58ѨoeҔ%+5Vq ͽڸxn;vF9O./#f-X<2\yz5Gv:p.j]d  ?κES^5v>6.{K23 ISJ5#{j`ETyH-k6IT O#Jܲ"vJ1O[oy^wwme>߮AںFQ{ةV.m]n61ف=;}s\Ч(/#.jƣK˫->m#H G[o9Tb'dΑfDgz AQ?0k}|:0_]IƝo"찈N|˄ CNrX+쓛f'*ZXa{UZ@ەcm3?yUgj{Kޏi0tFkHW'ӠBs^MJ}QRwfsoOx_I G{pգ YMs?R!uZԣ:W(MXy`7f Myu(ǙtTXզC ;'q_p+x&l ?_5g֒U2TD;̛N˃SR~4$In$[(RкTd6h]‹̪p+hFۢ=*\ƱGfocvGVKbV)z*^kOgNR~Υ?[rxҹp?yJUZ5 ;|GNyTw4'~Ɍ!D^r}*t4롓'F;ۊ䒶OBcesTe(#K"m#ּF-FЪDDgs\)H_df\lIAK`{n*rQ5!R5!#20+}= f[Q$h.>nwڋ")m-J&SFw6ڸSVSGEE_QM}O̹{?ʼ|WKDtS{\夗#G;?yʤ\MOiVIm؎!q_=[ZuUITi5)V'=WRrc*!LE7y:zkoDi::KvDS9*akYN.i{Wa_}){URo\g5rdUSt4瞞9pjh\J/?[{VhYcs#G;I>>%*zD'5!4 $Urͺ=1#>+:k$䜟K S22NX|}t)4M_:%.mea%sUJTQ)2jqF>Y gO5%aJ]zi#2Ϯފe{U'eduK٤"h^[pR:ӡ{Vh9~C"4'&+il#ub?~~Rs'[CR %D~YH89G(J-F jtrj\AlFr߮~񮿯F2J)ʝ?g _Q&wi'ޒUFISOZ5{+q[4V *ڽ)T}>Zt9iUe dB#޲w5+IEG9]Y[ҦJ3mK5RzY0.*[rы\4ZI_bG>S ଽUz 'uw:h4VC} aCq-#zҦQI;B ?ZҤbӡψ姳Z4gLv+Oiʤi_0Vx,^\g#?מνZqߞ{eu1"g(o%|śҲw伎s)/y'B*&Vrzs:4*yU+JND 6nbFׅSzuHT\bթ*r\n224rpV`DZ㯭c V֣汏/,m 0ă29l*ܺx>Yz>dq;^4fh18S'ֺ=N8ەLTdI5xҖ)&Hp۽=+5V栓v5 _u# ibvI,=NxڹeBRZuZv6=lc;I3y*U :M[l3XC-Ld lFT޽Fy[wҲlP52.~{,JPr.8\`^k16i_dΪ4ʜY5͜c#<# ԨIF}EXv%nTp?Zҝ::ktFK NU$R߻#u^q*ӫJ}Qpًm-#nomO;;.|ng-~_^s܁sTQ_֡]OzOU F36¼n#zlⵋ7sX\vlq~lxP**qIgJ4cQU}ux8# ̧ gf_\;].ďs;Km)4 XsEE-nkSNW_KcBLg Ϡ9V(RUWR۶TƌrFxgt [{gß( ZDe{*I['t`[fw|Q`s8WȜMT2rMTz|Zf8ªA?vSɫp֯7R.̱kQÉ$yN=?@3潼!bmm:<)^,ad6eEb9;WоtmJjCkhs/+zk 4SF8r@\m+!Xdm6$`=+q |\]-|DO>V]VA+ e=N8>ʌ;Z|WW?#^a|OB(c)O5W;_ ֜rtg=i^mp 1QQR}j#I6`|SX`uV2r>\V-SZC/&̻hFAA5N^doC7%TȌ_*6WϵT"%mZQvv>}"[F|ʿ(ノs[TRRKQ9Sqy [.i2.OJ$%{snnɚy'Gg,=Hr:)i[uA ͼn玕_RnZt!I-kfeEy1!R>n #?ts~haZ(SQOP+t̉ (Tp{gҹF5&>oaa7&zxdky>hOKuk*ܸnt{~#mHv \zTVh:TwzNńv'vNQJk,O*V _ݖS]R̤U|6k]۶/^zP援:b9i{@.Xw]9R^Umd !|7czӪܓh)GT۵H! ꡕUX:cьbբFQ=ьyy sybrnlCQq3:q-ܜǷǟގ~-X Sm4mu/ܪNNy8;=T|OE3GSj$aI':٭#RU'R)TԕiVܻCnl+U-m'=Ѷ#IJN\gRq1%F3;Z?ACt)ric^Tz۶bMSϴsO%IJVMh2KiRĢ7'=5aZƔAƛC;jƐA_ws 쌹aNXSM;"g󣹳db.! %0u`xzJI.u+VUF788UiJ7c̥+kn:mZqyGl҅I'K7&Jӟr:dR_|v(]dy(7E& C8P8[GVi֧ϖ-#F kЭ,A1۴v`c>hQ,6e+do .,C]4JQ*Oe%% wo<ܳzs]cM]MQhG 3졓Yyz¢XT֠VLvy+*[a6?9ޅV 7*l[ޟJSzv6-MO7nUvFeE8/X|=FOuvI+4[o8;ҹ*{F8&NE&G͒p8;B:ٷz. D>mOIgRTkw'{68ck)-yaFz$B62/Z;uխF.2ҸmYRaV]۸ҶH:tTV}zD2##źc U#.ȒKQdff9#֪4AN]SNIm0,UK RI(pZrQ0GrZml6LY[䝹'Џ8#^rjZj29Ru |W-XԕNd' 7/y~рX,PZΥ]CٺN~~cG2m-t){GNV6R0$љ|<~ܽt8V$'̐msKNu>ca啛Ņn(JFR5hyO{DEZ߼WW_Zپ_`=)ьn>o9$WiG1y(p608$tֶ}uNsKT1eE3FzWȸӻЯs,#%'kjr%dsוUi=FI ژܯ4kheVR/XZusA;ӗW+F(Qd9.ov&Tyh%5ć!ZFG G%]p`=j/ XVzhH *Nymg6f۷ZF3䖭=>5ZF](徇O%s|4RѶY7QֶVGQ¢;YiJ2=xsUu)YF5Iz/Ĺc$,wΛc2BCNzF2;ZJe7T}^iQ4vp9\ zVsrb&$rhNT):tQqsGdndoxϗ3m 'jFTЩЌ+3=^S>~vӡ.$}fu>kJd6U{=k< n[ |8 ʉF9NљD-vU >J2eO?_A;lX׭9Sg9{E؂cl>ӂD2pxZFz=hvvw iqbgj=-As}̰"#5e*^ TB7i~lbQ"n@v/MTٮ>[9ghbf $mtIu*)T6{K.beTm˻ ϯqNJ5):_ iynVɑ=O'z}+Nj|ycy?"f;=TaYw?Q愾]YJp{Ԩ;nmba/&Y<ⴏfxPM)yal{'>> QF[d 3(۞:Os֫GWm[V*UpzWPqYMӓV*K.U#"N*SzyhM-AGvT('$:Z(]rGyn,ʮ[9ygcp9FޝJֿ50G쒗MwQGً[}/{l~XzU9lIP5xBO34C1ۗrxߎy*sԭamWNnkx 2sO咒q_XSSv!Yobw>WVeӨ^N4QI&sy-҆a1 rp1(-^VҦM2^KH7>늧N5i*|HzΊ@as*}GzYFI(ҕ5|hۏ4c8˚Rv0T.[wP@"7nD={usYE,ΗBF.!Z H6iT8䁒qQ swvLRￓ7Tni$VpTyEߴ,;yc [^}9:tw~!ݸna1#=}:ޏ1֟q##H˷QjdrR2JOdE<yw"nyqִkڠ MFou8YxlI^ƜZO$C/UX>/*ScK[EX˻7âtfvupOO´eT9S4ɯmRF%-$eNWw۩R _cZɒ-P)@GORaʤyef;Dʲw<ްg'hƝf@\kVELh?\|Vq{|Z*k_5ָ#qe%IzRUt} K[GN0]nYI ާƞL8E˙wZk1,tHzkr+6U[WZGLYw&;FaѲǑME(1r^7MA vcF~rK)%k'RWvӱu+,C=qSNim !Iӓ*1Te+¥iy f!C7o}N:Vq-49Y+;XѲk8H=2?JI{Gw:jT_^"qlr(uaaseQs179.=_ҳ썱\.*)fܱXc?Hl'خZ' 384iSz$VrTUW>ՌRRn=HP+$L蛚ןjhc^QI}[EUUnU;FdQfKH"Ua 3ҹeRU'y?lg~~^b۽yەت9C'u'VrmF!oqeL2gE%OL~֦R^f޿5WwwpG\ KbO4M?oiFT$yz#un@mVYK}nqSze^=M?%dfxfdwGݳȬsK޺C_Q^AvתSRT,U躳Q4VV>!V `szŒqnUٿǝU:r2ˆ34XW#Z_UKwS;б]]h#U%C?tʏO([fwe㶷X6Td{בӎι%uiQQdqbcp8Gn0j}KOry:_F62qŜn :CƴRxZ5^푯wiARx@ aI9ZUcY5&.)wK[oy23nh;ߞZ1M5V1b4ww#AQvVDTU1sn,qKX%yqGNqǿ5 W2ONҜ{H{vNJy^6s:QԦ/NŌ2k"jljpJ\U'k-`Yn0<1s4mBOgE9'.mӲedxR6搑3S{zwt-S;pr߯,&&-`#J{*c suFʍ&ܘTnUL.=3ںT`֦'&ٖ3,s]Tc-0ޖ{uf;u?Un@tiSRoOԼEjz׹9#6eq㞃;~Qx+ e8ܸ#|uk49]UbnE+;J(?O«P|jwSqDs,onc83qTb+B7B±HZW2/+zQjFuU`iȍ!Fl\cuq]̌,i«$ WʭV\Nh =z2~KnaIQtߕ6Civ!$2|ۆzqҺ%NRe%hfW&ڥO$ӑWN^esjt&I ۈL/-=}NU'vU+ dpMřFG?w8NCEѕo07ԑߌVtvSSQwm m|(cG_s]ʹ>W\JN#ʪ]I <qsXÖ5Ai=ۙz*=t9O)(;p0۶ڹNZliZ1 5;w:m2+Fv_~}\*{KUFnVwjY @ϡ+>k8nDEJ**X%ylpĪ9(u\\UigUFhB[ RFN<{ڮV-LS?w|lW*óӵpƧSJ(U易"C!N08~$ewb+W|Lgʶ0˽^vrs;+/}ϛ*ޯepgCo-c=b1 ˮҋMި?U4l8'GcҜjӧߵ1[yvXN+~Gm^MgF^\>i;]$K8bhOӗ%k?ĩQܾ}фd,ee-jRIϽw*jEƜmˮ۽BZUY$̖Jrw(u:%J|Mv,="yw,۷=z4#`Wi 09Euz9h(ɿ;q\y?ytq@>jy5hj5qA,QE+J+n=WEFTݙX U% /tQWd:k>ZzLJnı%  ;%Fg+Y4+4z6ןJ֝egøɼȥe_-?xeO)Kc dYU*q?Zg/ujrӧb@aY0pÍz1ST~X뵘H7mCH^ZIXԕO[nAovqyAz}s҇ţ^bJmI'#lt*mQ"cf?)q<_y+oA{n;V͢ˤ+Mn%n0߼ǹ2eFbܑ|M$YXԓ=:j7{TkI+؎ph2B8)="nђ'ٳ"˖-:(ʞֿЎYD~s&<ׯZI ̬byH;cVUʎ8(c+I Fs}FM,б 峟/J2V,)3K)F2;u*IriIk/>Kn\g!~N2Ru=;d3,fyTt^6\c~UNBE.=Z7439Ft!Raez洇5MZ5IF:+VNm]d@|q0GA־[ܧ/i܅KKYi zV.:#H}DSF+͹G&RY&a"oȐ㯯9z֒PnѼc(SGaH1=9QTTԎ6 $Tar<#>v{R59\+Hʎ*v&cFSTmК7hO|\}r;|V݂6Ҷ9KfssJߨ 2@,Ww}N.zt#HnZNc`BֺnK1 \rm|۸ {QǗTg@g* tVܪp'"r+tlN2I*OQެ-"ed+49Y_w r=AҶ#ӎ[sQ#)?;Оq;V2wݕkOĆV;O$9QQJ)YT5DӠ\yQ7>ceFk5V]+HU@p 6k;tƺH 'Vq;'穧(F._4K$s4N#=2wt*iJ3vB\(h[rWvZ9/pTÿveuiQ|,ѐdyqY;niNRc>ї[m&!!hPcӯjKTegH݂έ&ES8G_!Fn:I.1rx>>]?t!x̒#uf8lsu*t~:;m*[dwy30x5;^DWKk$,\ ޕ5#& ޟ4UdnU<:氌~ƝIrbK$Kϛ$!끞zӲٕ0o%bffiLs'h x ~dXlG-Z0rZ,7 ֬%]J:J:${٥*y ڳ3Mu*E@Z.c3g~}T˗]RhJ>I/# $qV2;_8 Bn%fY}}={]XƴcV#0ڋYdoF~FU,qnJBN}XOҤ=e_ Bx#\)ƴiѦY]} *gv"9\m۱T(OK}HBGd96.G^7)NaMni߱+K/3UZmf#?&LQ,(T2.3p-uש?Qmi2(/$Ӌ^WXJ}4gfZfU;J =9qb}ĜuWvV1ܯ~@9u!Vxy t&ܭ֌iW"2 ڔ3%}Kc'N~ڤ=z/yJzhϻ,\24F79ZQ5_sn8Z*WAIwHE5lji.s(\ױYH&v=WU:ʜU~QuKt\p[l c*T۞O汭 2ׯi+r⼡T'r: ZW'7G1SOk=:&EqĊ%;Tc?(鷮zUU){%o"=6Ntܽ 3_1N-0:cY7Nsmu=J6z;~kEv-?6E`O*8^ԍMoc:qB4#=}_ֱ6t|2浤Ay ˵pHT%o#Ω غmEgT I'O G%X#>nYay%5v־'0[tvl+4eU$q$fbǦc`{~ٻ$f4ڞj$sVצk7R5+]#kSRw_!FTJs>+maʤ5E-%~#/_I7۵e=5'Sr #-ZUf98GCL[rƝ5(y5;IvCSF *=rJT۶ߙc[ގuNR41Wvfq1gS)'35*M7Q&4+l_FB{9ʃۭbQqJj3lT+b4M(a8dW!raf[ ҕTk-};Ufv = i=odoq$\nM %YnF7vm!3Fe3I #]n4jZ/ZRy+zu$ccuWxr~s:v[u_:+:ԣ馟GGK;9$vkEL?+{͌N*׋kCvO&踑wG'Ⰼ*v5Qc 5hʰVP{HƟl!ծ$ܱ%\[0wm#V*OUK;bRgc4 鳷qxFaNQVMԚ8*m')n콦lo>G, n~y j>l܎uiʣ-jX苯 k)C-m.ON:%Gk%_u+RVR8t%8A8֫{Jnc2FWCP\c^&^ѯ)5$^jI`Zu7?zXmצA^˛hUN0mWn¯LmT6)ʬ7RzO<+B#'^]'ʥnQ|ʤm{ңojխWyVmVF9w'ۊ(CEt9 ˩jkkN#aWOV\ E8S B>xu *Vaӷy+jvzٜTU#Աk2=a.Xt'{luSzd#A f"[<vS[q:(r5,?lս iV۷MӲ\nR޹]ZjNTc%;eEp?Zg̔)F-1Z->*8H9s5ba+M2ftYYewiC۵Nn51wTR+PB͵Tơe덤 sYcZLB#?1'vTmҏ6%*(`7nQ})(;))J*}QUB v?J/*rrRq侁[2iy?~CԊpW}Clbc$l^760:֏XRIpgv=0IR}}h$H6i#sߓzsJkCG>OԆYFwHAls淾Њ]RE!e4(^OR>[9oB`LU5#f9E̙IcLi7.\ڜ}X<,R('zQC&ݪF3ObcFՑJfʗfנ~Ss-4I3pX-h0G[ߗ]Ί\ZVIUDjy;>ނJ/;vz -Llls'J+_QaY[V~ECPۗͻ >[UB *gNCQмXQǧ_Ʊe+5E(ޤHCFT6YJǮQzg pYhѠ{ᙘ;tS+*Шԩ9ۭ[̼v0,GNj%(ÒOyQyEK$~{sSʣ&Q|E FYw08aXR5 0RH GQ~F42Di$5rNyNeMIP:gߎ5>iN)kX;r}zKץqʖw9Heմb~{Qw\ԍIs&EYG˶Ui8CXJQiu( >˴a#hҳ8>gӡRq%ԙe̒2^%>Ɣx;8&ǽe/Ié]kn鐣i|ʬ,1rz[C*qFw^ǧj:͹/;nGsh/{?lYu=zLo݊?*B>?ۏ*iI"y-ޥmCv]3rz:sJ$EKiTuNww7r~\u2Qb똼?ʫ-N3RcF*gUǷs#)Fz-v؍TuV23'RWE#mhԌF7s\z>KlL7|d\f8\1)h#/n̻qϠqGT׼Z),J HMrT#7HzۉT;dW%J#SL$˰~;~ˡ^-Sc3}3nv~U'ί2fYUXa{ޟњQZU,f^[B\+7H;OOڽ 2CFI3X#Yr|=r +6tcFZ;'%i,ՒEoI1>? vd'j̋n:|3Un:= *tӮخ"F[/*בEqx*ȱdxb XT&ƎT~7w±'ҏ-Oy+F4RjcCql,j[e{ r:u95Mhgoqrc6CWt4/+:wisfl{uҳӡ^ڝI[EUfۂ\[VuzYtaf%egz3g^`%suo[w`y*qvݻmhƗ{}C۷ g)I~G%[j߻ӱgKnVmTJNRp8Z+\bQ6ݕJ4Ӷiybv;U7 y_Q֢W_2k*/[vad~898+4Nש3E7~A# {v]Z6jiumrgwd7x\U+εp^V^O=exn6:ġwl(]9J**P~A/^تFU A+JTFjG]uT}VqQ8d.%Eo,sG-IM^ftQQoWF啊L-9zwqo_+A6Q[fXxl0U+-Gc;Upv_֣!*Azq2nm%e7PDG98:JQQ{>Зz5_{$ڬm<ҸnQ+Մi/_'؇0vяc8V>ҤT:u-N_`Fs}Ԍ{GsT8'jjmC`-#:MgvF1M)Τg @)v&ZR_%J3ZB$yJ#!RWrr?Z)iBќe9]e% 0.Ӄ0]ڋ4QۯM iZ/̭g>*=\?Wht9~>U"G51ֺVvw BMG$0lG)jSJN/3,B31fY P9=SSZ'bS:1M:ni0I -n۷;wϩ{:qO{Fȅ-I^^ܩv^JӌUNNV-#92@Q:ׯaNVh'}5e̗ g xԧrSWxuO/Ȭpw0pxrԭ'QN*~J}B7R'ٵRhQci֑9b7w:kizo(+u(N/pJQ $ĩePGANoGm@ #*R3( g %)9uŭS^Cu(0Uk=8 ~khӌgfsc/yM',cVO_CJ΅dIr[uCM70SXʟQ9B6Q~tJhuuyj*͸.q=ֲ J>sqi{*T^YߜUQJl= vSu/x*K)+}YT0L2U#;Tr֍_wS-OU[$vld]5<On{{VxԧE9;j4 "DNHXUw ?L~5Cާ:ߧab*Tr2E*7'e*~4]JS7pa G7;FNsОԣN14lvF)OH$USsy_VSF5QR5r6ܣ<k4Srƪ?m,:;_52?vV&9DHZ}XǙ_MR8Jw09^::Mr֚_!i&/&pɴo^jRRJq .W$$&FBz׿'>p (+?27\%i#?/lu¹*uumѩRd <뫵vb`ݝ_]p(֭8k>gݨI$Gtȼ>-x\>AƳr$k%F/'o95H|{XUyc9^yG%Cv~n#P$G^Zч4vF4on&13L4AH߿AzVէ|osZu)Ԕ]#h=nq>ecuiԅn쟞pFƠ`⳧*5U?>ڟ ?6[۵eQT~oKcE۵vNZ4a q2B[viA9qڪ?迯Wj 0.>p VeKԩg]dʲ,9~5:qq:9c(gПυZkI$( }k?m-69+E 񵭴Kwqu$d۠e51I>SKwi?f/x)Y'rztg0<#\̰c~Ϟ.fEOrG`呥5 QGz{KNzHGҭ˶&~ׯz,4B[_8mkOO[c|,{UHZ9ޱ瑞=>1.G*1';kϏZޯkg0bZM㓞[O(VjOhݗ?:%WK8٘M/u3 V5oZJK-N{7SO*u=Qc_sz0|?J-ןC>X蕗QO>I>;B/#d;};+3悿.z|pt.۳ N.'E&Gkkr=|;(O] ]jG͎F1G^5Ne*.yxzRsi2|_šYkmW(AW A_;pnSF4l:ǁ*ty!W%̄>Nٷ "U.]2Fdd_km8X_]Mb`\/\U(')ɫirI!*H`rOn3ǚ4js-^\y/n]=I,K[lG)UyRîjrr@(ˍ&/Lck(JvЈp׿bUkx`_26GMJúpO6ہO)ʤi^˥SޛwDhVM{-eye*s&".I=: #֑-]Sm*+>O[oݐWnއV2ֆru)ՌiJRXU`{r;ZƤҼe>M[Ҥ +Bсiq,tdLc/m|^JUD]ʧŽޝ=kӌq0}\k#mX؂}_gO37m}.H %Vq5%uQяcy!dvQq*֗2ԚTvbx8jUi8R:'֔gᨖUm̾jUqֺ)%8)'*(M|~)ӌ}&eR^ҟE溒OkH({Y{g*G\\eI8mg/v{"ޅFm[m\²5hՆ}ʪ)5t֒Km.#VxUK`ӎ+gT6VRZė7HƢ=rrtKݗ%4M9J5$ET z8Q8ǚjޜFRW%3FD1r{}@#SdxÖ^-ʚ--,|mR\.N$WEH9>UൖH ɵ#n kOCZuN).؍,]r'yXӔzRӫE[Ț|h摕#=}74)SúAKϹevVM86ߝtF1;l]iSHɸ:.N\0ur9jԱ)'*s6}p@FR[q&7l$X.D= 9S}tӱH?eFUcJ\1쵑B1"D]t9n9JsUcZT@^(]L˜^:JrMh*( +$:4r8>/$N^\G$cF0qWvumGag1..I㒣s]+]cRJrnTP啎7.sunӿ_/rcer Hʘ Kt~ʢk^^gtc/!Ks Rsh/n3}]IƝw2Mӎgm4H&śpҩRtGGu e"VU#$o4jFWH{i"xnT6!W֪IJ6Bhuݬ`n>#v< ˖+gDgh>.X<<@y5(^fi$L9+/F{b[.OI|oLeL|Pk5՘{J|Tٖ v/0Ui._g*[p Y}5I)>T9Ml>)_3tP>ΪeSu4veUllt'\K5*/)#ec8Y{6?g,,b-0+*ǼzcjF0;4;&ptf]y[sƍp޴Rw{>ogOU:~%y-26ݬ 7t珺}+F5>UEw46yQےI8Ҟs*נ#U%iWi|iQi=YVd662>nҥԺm.Rhi0oz=G~j]VEkrݓ̌w7`=:i{s .Z4hB4P㕏p9۹)^f)ԫKMי5][O8S&T19? ӧ̜ޡi˫.YdַRF|#ᜑz}zҮV>xʄe}Ey&dP@Xu#zEG]Hi6vh)#ic_*<61a(N#Z5КFXaѴőr(ay?h/γR5aI$HTmӃwwSgtZZW*]+H++0V.I'?JTf#ߜlKo28n2MJ9 ki8gDhԌݢO%ry`5v{u?zȧ)vAo54_‰Ʀ9*n~흈 42J[dGt$jQ٧n;̍aO?SMoKڥ>X-~Ԓ1B70zQRz"L_kƬŏQ-@iFwՑEЯʫ#?.sd^^gR?i庭J U$#.h{Vs63xպrwB-Aqw$EPNЧz[QݜJ5"o7ܭ5+ܥJ(U+ld}y*٭>9OǶiq.C2X.9Vԡ+];)֌ε+0 fBTzTZg_,nwʤpy{{DkEfJ-hpxdSnF2;:t+?4 UKAmWy)JRuN_B.\w"q׸iAF)5죃rmӵHmd]O oڴISv)J"IJjU;[88/UM:Rv+E&8mLFT^C꺠1b .иl`g#9ȭeƝ9}gT=:t\ 뾜iJP ԫFoms/ 폯Td˛1]JI>s+3_ֱW ݵlt3=dNb|xîFNQڝdQyw%'9`8in{zV9)SRw:^n!x .BUWh38?/}oM6ջO֛?7=JQ(1TaNet]; #2Bj>WGN3˜%W@ʸ_c?JGUfzʥ?ŵsGlEyǷ9/J0|S@9ڧv#9[VU97ƒZ-Q/;Oݓlu;εWЏmZ[Ț/?(l\}5TMiܺ;Nb|1f RZFWX"cyg4έ3#3EGlZls´T% J2miϹKm9#iFRI Gu"UWVC?Tʟ4Sz~w{\C ݴ<,m!}pzc$ҝJj6F|؉VQ;pZYu(Q$yl|8Dh֌u5&vD}9=S*lݔ}X$m y?+'fC{HǑ?EozwgRr9n83D(˕ɡ<*Qi&[mؖ1IMJqn.<,:ЬwDZpݵV@9eRSǞ96U[X[y||EfB~v#xj4'v:bN˯jS.-жOee88<ZQ%+'OQN*^d ,V^gystKNz4'w۩Yȍ00{)IM#Wk^ffhjrw/9=p=n^9U4SVXk$I#d199;QS=]Ͱ:ҷ/E#\vy0vRJ{t쓽.>f)0 nY9SWg""rvaTR֩4A:u?!Xg^UcW[=;I3T8LБ+:П*Jvm]YUR$g?OSڌ:cTZ"Hvm7TlֱLkӍ7˿VGܷqId뎊X/[FדztJ4ZNYd-~dsm*Ƞ68P a'.mUђ[:bEPY9[ Eǫ9gWJ׹bm` pC$m1`0F#.jN2Ԩ)I:I>kxUe~=0kӷ>ͰQxi,j?wzzTԋѝogSX{u Z>qIF<(΂2rylֹeR2BjhI%妟VV9NO''wm2_gUw`zbQ^)*צla$o-I 黃9O}zѧu'+_&1%P\3YßmtsFȜ֧֦U=&H!P wNQ1kyXδM8mJBī3 r>oWJOɢ"U^9'gӭaQ_wesHrE Rd]hrs۷ZR$L9U:}S$$ ~'ԬEysЗrF0Ϙk*|,T;zu%gK@ GZ?r_wZ;\ ̫%e>mQ6O_% Negv[e1y{sc<`s[0jC\i 6ynk|LW5gǒ*4'JR߻}< *ee\V!@gXJZElc*dD `|OL|''7ɩE{!$x٧NL99큁Ͻc*7୅zj]{Iw+= KGCr^RIriܕd5wmʅYzdt:ź5)>}kW6jm.|בbga6dT??,@*0{Vq%RwhWN<=Hے9QD*nq3֢qC *74/%6Q+l$b?uԗ# qR=VWqAJ*롤sDuKrDګ"s{{ڜ4q2Oo/kXg70$U700r՜#ԣQON o=VV^{z qWe]ޯQc/$Q,rm'nܰ<I{RS([5NIGGwB(Wʅcp9\g kb*GjPvFHY73r?(5o_]XE?eewD"y[v(=ϧӭ(ԋͷi2Iro>bkM9̊t.2B?A[i_^eF1Rku-͢=jI ʀFNӅ *qSV3_cD_b`9Ԍ( 黎Jh-ѝUOM5NOjSJ#SLɝ끌\niNҶfԪԕuZ6z>ݽH}7gJm5kƺS5ShkF2;Je5.[GE8ҭMI1oV5cmcq%7r)ӕ]/ahdg7+]yJà@Ae,鏯jIY {_w9U#3 qZhPc4ܺgl HnN#FEm*2N%By[!O:"lʃ?{'g"U8Λ${IrI[~>(~I`#zc;޵RZ;hmFww>դ3lS;1.N1TJUuii~8$*GϧZ~dem7WdHJk'q#8wvZ/ݱYlOՓ{zVЏڑo'g:D3o,r {*N=H󩴺tF2N3ڔˎEܮI+ ٿSmɾoM7G QE#g^;q3BQ|kQر[:t֮|җ*Rakqebbi}+j0dԞgB6~cxX*[W{y1U)Tsٌ>c' 1ΜmBZ[o8A"6c[sVӚDµJ1R?(C劯ʻ>sen)J&fPn yҌM٣IWApDJ8'$ 8Һ9~fckzi'Ao/ɵp1:=k7ʥd'k yZEċ&oq{BIt\=̊ȻHc~?Z*BGKc`>HNQ}sTNwqmF3lK~Y3dz)ʛU=tJ,^Qu6-qHc$v=J1ݣzu*rU0̬Wsϥb+]V#y\qZN^3)#лem+43ly^{g= qԩ?'DͤS+F`H,y9cds<=ߑ!]rx9Oަ:Q5)\}@DonT|§hvU% {# SKoI yyz&yo}/3*CndIt̻@=$)YXǕ-4Wnv$j{ڱ|ڥƬkrU'Y~f*szW,JLe*M\K?̾sdGQc.Y {:1rІ1p~E}̑x|~U2prQS$5HZlUllt]ʲ8!\I8hԒج:i>gxc[Pk6U]nq:rG\Ryѕ:lkJ<$K2mSk23]siS}~6epϕX?/_<*rsv]LkʟͰ4X ʸ*S)n4W,nϽD -5D[v݁c$U^sj+ε AhW}H<ӌ;G婆lvԎXiko!*Iy2;W-KVJM'2kVqV]b;n4_HÎc}4[ʎ4짤z>nmV%fonNTYөQDm-/е*Ui98gyM))vQ9^$R2&[$}~Ǚvgjݭ- ei:9*SQoS9TR@(]r998tcJQ,TS#u aVY&MnJs>*eIR_FUz|!_VUiFD_3/q{w7ȻIC<8};ҍ 6 ~{CZj̅̈]r@RHu5$ VKҭ르~?*ǹc[v: 9ES*nfeTz)837MYgh #o-#ݥN:=1zRuQ+;ICco"O0nl1B猜Vѕ乿5uݻG3}(2y2ma5e9qq.Mq,HTm-烌֥Rz7pu^M~! I%fy_NOuJ*obeэ8NX[gB|7.b8`GJ^{dtRFIVtVgoF1QgێqU ~C:Ul ԠC:pVn r,SCWh?0 pdvUDcSR%ZK60X3 qں5Z)k~.Ghv3q\O:VѾNq[Aq*c?+ PO_r=+ZM^Ft)>blKx`6~njqI]-Yޟ;{2{c53Ev{486ӆg#[I?afMp{gdC㩵ISNZ`ڹ*I?[\LjBЖSP'kͬGmI,5nz'>Խ'ĕi8e~^7̀1tF1ԮZ1Q49K?isJt1٘o ǒӵoN8ُZNj$lY['=kGEqTJN^5LcxVnpOkh6*#nimCoA^<$ԣ&-}"w0ۿ)qDJE˨(؏(sgN}QRNd=̑A TёETye+3OgQJװiu&݂}j[SJvm-W\I3z]qD%/wyU(~_/8;R{ 48F5an8RF}E9W9 &Ge~m-ѧ W7S\ܫ_ot0#۩fV8+1W1Q[@ۆ oOkNUsZ|+$[9;>i͢5r$2\[0+Wq-Nzxc1mMٚrܬh*1ZQ_4vҺZ\uY1r:B5H4)1g1jwRRz",MsG0y9=*1NJ0qrmgې9Z(F{)tvƷm5e.m9^TBbܹE8䞃-KN_M5CЌc6:]y. [Ӄ>FrOex"K6iGv$ϧg ˧F5fIm$4uBS*9J=캡V`yW YxۺB_dJ;GdP7}6`zJ'rJQ[˯^J\13e뚣d'~`[kx?OJvr(m"i:ώ1qҢ掇\ay3溽H~n##?ʰ2W٥=$t+*j5eNRz'v~euǯz72f]ߪ W=sҟR1ԞvGw`9FG_nqq\r5RFmFi<ӜsVu)"~%/z0;[i8t0pL#Esl#AJʧ$c(#MߞKnHọnv~ʢe!¥(+N]Gb32˴aq%8JJR'+YX؅+ DeR}Q~BIu$M}9r飖rtoQ 7y˸ ǿV5; m KkpхϚZE Ԟ~乵zn.T˜V3ɐ6~\gSX\c78~*)`۷RS;3ITn)$^G*G1|c<c]#e4VVk,ipONk2k5h뭇^[vh]9We-YǚƸ<'-͒JU#‚:u?AYm#e{iUY6ٷAhԭRTo&ȯsc*˸#^9=t\)ԿEs嗱z ]yF<'jF":S_gШq'q콘c'$`ocX7&'V1-K!!W#nf9>8;>݈m³!Or+T9)ѥN|Ҷ' fڱ˜y\UI_cj6wgKI&5\gql=Vӹс8ٵȊ9R&nwsg*4mk9JF$f5ٱ{8^}lD=HҴӓkwQ.mڸ6އЎzu*_O[KOoAFo}f;91[{W|oWCU=:{\GVi!2)\}~S2Wv_VW"0g Ǎǻ qֱZ1kIK-6X! HDܐ=hɶΧV\7|L8߮*cYs&؉NK^ɝd1jF2GCzTa;]/]|j)*Rvo~BFf!ӛ̕vA 7(?71r^3Kt&\pN6{$XdcHYN1{)ӕoy_M?hJӭNV[5\rU$R+54˱ՈiQl7}ڪ+ gVTjZS*کk ظ#y d'#+c$e{z[3M&p+oi>k'ekc:ʖ4Y.%]cH ((^K- 8yP5=uЎX$K_Qȵgb|]Z%vxC;C-k6s\Z\9y_.0Y!Fqq֪Q6yԝ)r4t~=PRy.ʻQANrxMr6zM[}{"Z[EQM$ϵdOg#'85B—}?lzSviUOrsv6Q2gO5*AAko0F(u_ܱɁ֍rێIhj#ZKwgTi*vȃN\;F"7".5W>2nc7e<>Xz=\wOsԍZȺΏޱKSQ}M15R%2ڋwhX7g;Ns֜is} >jog7濭E o#`*p!w|n>U".ZJU=hXiUr’?N>j)%k*AOV9#v*|Qm{iWШ<șa2dU$ 5%KEoO?BșF 3KG9>Z[\TѬMoq6i$ueaԚ2SdBbEX?9]+3XH-%Kn1Np Wqu9Zۯur'R%n˲,$Ky4cT;8:ri_ՇGؒG86%D𴱝=8UڝTkN{AZvc9O-q`]x-̔c?E&mfđLA nh9V^;h\1{(驦"8zpM꯻*4}Iv4|0Į8'ն!S9p*"\ _9Faק*|[_O-u}:"CHYV07`nb t{ϊrkW+GZ86_ZQʬq>fݺ&>5`Â+ڰWҷroGb1Y*nPcpAMƭ+mo%e-3"բlTc|եR6uzUU_92$'3[Iԓ}XSW0[F\{κcRTd%t|ђMhKPr]qַ#hQbMi5qIY~2dFR:)RVe4-HW'3]thΜs- zy X&SrzFvDxxӌZerY#!1ʜ8EFҔhiE᧸DEs3БTgt*>γ[O6G岆mێxڻ)ǚ6Liž층󢉷 *ˑ@xNѵ.iRҶĈ i#MA.|{zViʜ#y$5H}㻮:f5#PJw,9rT5>'U8;QFnZ&ͱ+tSB3wI ᵞ=u߽iSjeIZ?D1ʷ|I"UvI0N7fTW'h^IuI]MX>ޙ"16;#RJܳXtL0Vv(˻im洌*%FMfɱ=ۘ~?C~5,ЗR1VԒh#*33 SuhF\M .oBԉdsZIw:ƜcM۝±+h1X$aKjT^fn<6LWX ʠgj*{jau JیRyƸcrF39׭m7 kuuBoPO+7ͥ͡O6,Ę5fT/ɪe>kF+K'Ai7z7~qSe*H':ֲriE-EI n02:Tˡ̖ɸo:Ȭ`%מ4t?hߘYJCʜ>N*y.Q#23ˈoeri*I݇*H&ySLwܹg.Z:iSp5$nvZ"7x>pҧR1q-dtaP@՝Duɢp!^]2srFqJ.KUF],xfU.A}*eFַ`Eǵ}LVruyjEO2f۵ `k9(2&7KeZbA\B SJAg5_i{z~ƌmm:t QUrn3Vq1{fw!x8څ(.(ԌRnَeZ[-?z{u1"+],EsnUQڹyy^ѥiȯv󵕁u^k4E^TSS :r#p?~ K[N2+>I*۾^W=1޻#(kS_oۭbdo5$;>`VO`rVIi `:w*yvsJWw6-qo)HoveoSJQ[VW?3o?)ק^߆kR|[6559BЫ`c'm /Y_]*k*L9zdw3dِ#joc-2mvd>;bvHce;wu<sJ1oScdEfc瞵 S?T1\d}EprECIs;m[}hY? A?:_yΪFQz[ֱIu*IkNX&34ﱣmeTy8Ɣe)i"yI'mHg[ul,J>_UpqӦ}SMӲ.bEfnMa+|-TyMjd.I^vnu$7ᜪFbfm+]Z ֍Y[fCrV ~uSܿqBۏhrJ0f"ˆel09^YKS\C<"oR1:>} m;[ >dc .9s4OeIJ*ۿ';sG:rs+;=e YT}pԣsB{䉤bnDnx?/u2vk#+AxQ嵵:zrE3"O/=qzqXk.Mc*vwЌC p~(̨S`\G1l={5=]BfoRlfYvyoʼe;kƏA|*[1T=iZ|~Er*rZi2ȫ[V|Qmޭkkkrfy+^hh^0Gj}UcY&< r.{Ueu//;gI~UTFx'Z`Ft[U%}ckh"USw kOmRvq5GN27$ \DAQ#WK+IQz"{tl?yE?_,T>Fo#@Խk+@#IT;{;y<pkxNI9RwɪߨdkUf6U G`}+QcdMPҴQ #h_A~tzGOJO[mB^Ӓ+dy,kcRx$ODөҍwfE-l$ rG' wt4B1dz+ mm+-kOQӜt[{[':Sk^ƀU sՁݩ{8TRurVJ-g~;tO]S)T-uݽ#5Zm|l?±Ƽ|()F7%NZ3?sU0dkHJ5W29BQ34ʻq/ݜzc'{*dZߠVaﻜNvʍj1n2I玠~^750J2#hm)a#ߟj2:m-MZ9:OٕU79߁ZtN {1 qnZGjuQvwk܎iբ۸Uz2<̰1^kaQIrm'nG4j{֩$̆Y6nٙy:ԣ|:#.N|m<z:ux׸aZp,Hپ^LCzVrZ1渙ԓW:5 #DŽ^|^t<cRTsEi+ !>~I236p{?Qǧfy{З3woVE#nF0qS*KOQwBɌLp<լye- BPej,ѡ>Ѵe=FqӭMU#^_hjL,;0y BOqұESw*U?QGI;^q׭g[vסՇSGmtN glI89bJ#z9`m.x>kydҩ(:-|5[Ovଧ99n9't$C#5+X+2;~kXWmmPحA8K/ Nyzu9;I}”c8e+ ERHVf}{dZhmiw}Cs&ZYSbI1ʽJ78R"[.ZD3K O"jVlq$&8zV7lU" w%`!:9czVFL?\nXHgSj>U9jzϏ|Syz|72C|ai={vN5G -&ջ#upŃ)l9:=Rk**4Rmw#eWF}8_A_1ԛ~:VHHaX ̃=spjힶ ˬ]5z% ˹Ywc@ߓǥ ^e(CU4p$syC88vO-FVzqйܻ^ [>v@žnTm=zTZW]t:?߇}*{7Ɉ+gw^9j;Ks8:"+Y\o"mTCT6@e~Hr+_v_tH6Qm&Hc^?6"^}.ZR%w 3͏rE_NZy=nT+?_C:/uɧC >YGHYh>9W?(]j~g<,yf0cMJEWeqFHL})$vXBzVFҵ-n"V[uO =:5 {ZZ'Э+|M^hıIo cLpqae2DZ-\N ҧvÇ \fۜ㿩^4}nɧҵ?[ tJY2=ze)Y.t9Jtzݫne>AܷP0^޿Δ%*~۲jn{Je8{Q|IۜA5iޛQ|ɩt\ty#/~`Q~G_NKV G HcnH$)}jrMw=H0ff2GO_WC9];5ђb go,;0qu(]v:Jѫ.h%94}=@ee*v=wޕ:եUlӣN.fIiTSSx w*SQ-LGNV}:[d0,O'8*eNo^סUAI-D߱Lſ}E>fݯ[ 9'#[n6o?ۮ+xJ-= )JM] 0&8/Fy#~frq+E ,[4R8^TO24(Tx;;vEkjq/+yr1*oyJ- 9zʻe.hZMބ֍u[,gD.p='׵g9'};| ђ8ě:ӟJKЫWkrѶסf}nf N+٨*jIFQ2Cv) NݫJtܪY358`%"忉#s+ïCU)I$66 ~;nsYԍJWW<ʢxD,ef?9Wsi5)N6$1ܱ, lVq;8ӌfW5!4cyˁq޶I&#.Y)S1 EiOW#;[IIv'R0FB^~:ќSBI+}sy莪t~nԎK[\1޻V5)`0}"JZc~X/Un,3\j& Z3+0̚Jyӡn%6_+A]rf2QI'oį9I/U`fp jrFIzQvsޏm-md7R \>TNU)T<4Rm ^69~*.[R1厗FE.-Gܰ)ڱ2ï>µ)JnIؼ< &QFy!q\@ F#zMLF\wz܎|+3+ 7Θ%z⳧)sZ)ˑ'f%)%Řl峜s=c9ӽB+D(Aqپg19Jk)ŮY|vk/&SZ)ՓpѼbuЪTO=Zʣr}t QtߑX<*\}zޔQ{ߡ^u+ݸI)ʤj%=*J;B۹W?.AJ5)YC+ (۸*s0YI9^pr{汬S]*Vj<]䁄2M˝ӿ52yq4튧ZLÚƧ6/Fi/eZ|DsKQљy%{nW?cSV>?SQj;D07n+:ܵl![,;zKO"3bBRwq޳rlg-oa{.I˒4aÝӎ4S$U!Uv vRRk."0坼]P2ʌ_Hm9ϸz.U{ǛNgiѢ89W;W>"Q茪/-#,v.ZU79̝SOʜUӯcUNrM- x[ƐA8n]5%rKZ}ze15k _R:=xț5(_-O$`~m==iƬ~fQFE#0mOҔ#NI߮FU)4wNVH!WGxis8{Hܕ=IdbrX3199B:$qҦ'=$o'̇~);ؚ,bSL T۴rGzc=^(6Qup݆ȯON0nhDj4`퉖=ŒUќI&N\j a;ne\*pNߍid?L<;4,^\nrs\c=}OUSN*+l#73ꛍ(oGUеdߗojOn7lѨXs. 88Z҇4JWnG;*a91O0CrqWԧtq\$8V]sӚU7bH߱m伸8ai8d֑J)7غ|IY"fK!SRm4Y}Fdff\|:5tIt8a)+脖7peV_^^Eco{Aܳ\BI&ʩe~(ǖÝYK'-4y~ۏo{O*Rg-9Tidw}6=hi_cjR;tSow0MsU/}V&Q5+_fS?2ͷq{ TI'+ ljp{w?~Ưp.ʒ@|ho_HG}Bk+q$$D+eJ#u_#7+yU{>Q/y9@:云JVr]Ye\ĪnwϥrʪNDK-=K{ʗ`(q'Vs+NiNz. 큭nk(To$sQMЊ[sk7*5mo"4g)Ufzq< ozmÔRTI/>EϷ20FyGqJ-[yi#, ɗ""vXYp s5kr\eNږ#4lwgvuւpQXZQm'&VjUUyQJޅw3 T]n-x8#󭹽NimxOK$shYOzu!N:h'-unRQF83rKAw2\$I`i >{qEhƍש͊hK@gGݷXFOUJHj,\qb'?T-W Hx {zz֐F+MY{Y)µ s{zڍ*~h^>jqC^gq9TSkniUTR:Mnd]]nfd}>y%S-MrLKmN̯*WcSOF8N}F h$7>nc+կSW#ȷ9\3u=x=+Ǚ#L:NIX3B(E?yfR}T[UMqu>(ΥO.WMA+F/5sZD˸'jRjZ;lc.Et \DZ~kvEJ2I0eZJ5Ol*FRʝ=gv$Έ]Ir*_<ӎgl◯S8(]rˑ*(TqKt1>ՂjL({w$ i0܂yϥl++Tq֩EOݾYp|ZkwNKR)%0./s*յ[v^ܐ v`}~=+yF<\rcԷmj v8Hk g3sPgͱVkϨVogb͘d1R旸SQc+yy@G#didb!z+W=E')[{J|ڽlYDbCbF:9yr|9q\h1~[E(Ԕiz߹ ¬QpUj}On֚qlok0i#T9Y1d2]WXF==j#⹣^µoဏ;l6jRc Kuhrp6?:Dy~W->C줌 rFL\yw0rzTku0$YJl%Cig~٧Maf϶UX ~>S?JVn[+ rђۘ#HRr0zVUVUL=DҼ^$ͤSS^vh'쟓frji{v[gVݻ#a.ju.ۣΌf,x.s۟EYRQߩΫ8d[aS`k7.zQ멉U,mo$LҸg$wiRKcΕ8wQ>Ȗbm{WSG$swsmv3"՝k1 d qA$?zʝ:qJ2TdM<Ī4jY7'S~HҒnVT֔Snv3. Xexu>wЉ8rk"$a9gb\j=h= -㷉E1@dR}թ,kKsQ[kߢj6+0XHj䨔|=}3ⱥ:jkcX:xX?酱[eɕUwSRtbqݽF$\qHd*@H9cXI^IԾbO [$HA޽EcN%,FjAYrVŢ%GVkMBi''?yTJkq8k^'Ӥ[Z"LCJwgYJ-h[O-rFa c ΝY7 *~$nUSO\5N^ni]Dޮ$sSǸ #k)I' Y3:ݎv^soR Ew A1Y}WksVkMRKcVmQӃSc;I4S},r 1=r3SS{bZg&շճbGfE;$ =8sϭq{gJ/vgN-m~4Qb6/[l\Τ)o#/SU( 5X>Ǧ^8֘z崥^k)l.8ьa| c5:u9QCTC96cbWy)TIW]Nq§vA,1"0u,M~S^ +e(%WO_-ty:85d_Qs-b,̑;3$}WU-i[De^Z#G/3olF?t^zVQkG*qqTmVm69*t뷩-[~Nefk50o.qzuXKORU/m؂ kr:YIG˖#9i ME]=5JrM;7t{g;g)9T2*Dy?vg 89szVl HSjR] |XJRA8jNQhaQU:Z,KffOvF#JRzR*QM~!)TyXF=HԍѺ%6E ebg .1_U#&YHHu_+ 4R+FXKos5 +2#8'^cMIjއJugQ];[Kv`ĸ??Zڅ/sYc~LUZGKuiUr=zӽt:v];jTRMm{krO4 Io`p\\tFSqhzIjQ,n: }_})Ԍb՟ɇfeUgצ+҇\M#q+~W $VY9 qg8:%ǒon4hrxXr{c]QRSOaB}´ۗ5zrkhA4U%Mu؎+x5Es*I&$ʜ.;Vҽ⽟5?ޘ=s]&mMz_ HmY|AcHں%NI.u*$.-HyZ=g) wҕW9ZJr+Z_]IJ$͖2#rv҇T6YK0@P6dna 㪚֝FWETN5 Z]tH#G2=?>_.n|úGyxz?ct7)*/Vp4 ߼n۞eF:u  o3ڿw zt>{n{1VؼfMJ[*82eMc>DvWW>kܺ4;49hԱPN><5JoSZqӚ$PDCťeG[{Z#֖馕u57t' uC2|[jyg_ThʥDhJXN+0m}GMk)IK.[p‘ 'ߥk˿3>Z؆Ul]1? v)u!i+ؚp$i-щm9l qS+\Ju)5z㈙'FhR1_I,eanJ@ƬuZ~e8\޻Uqa 㷷5wʙR[E4dx6 =E*5]rQ\lSmn3F#' zqIttZ-"Knaく+9Jj1W)8E};D*Od٫:Z SjMB˒RtnWZ5oI>hkr~ni\Q|e.,➾wJnf'\XԔzrnǬo#Dߒ?0b+ |U\u*USnWҢMԋRGzte32*Aq7w}*I^5NjRJ:xry?9>vZr̹8Z!M2[Fw,8s{ֵKt}z[RrrT?J娒קy oorJ\˕-K;}NĎwsTfpJ񋮗-m lxq:wYI] Zh#gtXKq1>^kH7ԙJQ~v/"ym뎼WF ;yCԤg*>x%$ NJ9өF:vLU[k)6l*܌dF+jM >ti;6F3dVI1sO_o¼rm4K*B^ĐHm^w}NӓrrOnj+ =E)G< s|ʻͶYO#Ν:~k_SωKv2)Up>WGlmEEE]/'mQ[ԪgoQUQUHʆRpTһJIyZIdLۅڙ`299\QKݯOc\EbkD1OZ2´#6)@vT׸ajp;k5z10v |=S,嚺_`.g~"#fٌ/s9x36z5;ۤ0P>U{B<~VjS[ԝ:mw.DZTF38;S?tB3I9B BZ2>|5f#[QM˱RGK8Īwq׏qVRD˩b(Q!>٘={ԹTdn_g2_r̍>G{-LR ;[[380HK&'׃ں#JpT%/wѓq3M(+3,ʑ[<.9=_n:t}ET嵗[n:]vHr8+x8mnmOKa-z|(HdiKb(ƕ6(BsiZ?c iKj˯(_5X,!݆Rǯ?j?ݹ6h^OoDe"}yXFeQ\=5gWU8'\Up{^"qonrF7>\mr|ܰv%F7{]fce;U|yiJ:5f+0TTN=jUU%E=Hٿ&L6@==8zWRqJ߉HTNȱn$>^9D_̭bkyT ޣ8Uo)I${Yʹ/W(CNޝQ"D 52:t6^sGoh[u^_`3n$sܜq]څtsEE8:X;'եB}J4#*nmk(n!Z3-Б;~` EoNJ:=GaS,!9^At9TJRr(z ͂27m( 8}Mnӝ; ̢GLF+/h{uzF֠b<.=3ϮkHB76u#6%XK0+r>>,Tz8[s̭*݉=:19S] r4||͹ ?xy8?vFVKtb9U%oOxJ>6" mr[)huvx?K NZfڮ^e$Q?47߰cHcÌGʫ7Rr]!м{@p35FC}0G'9gּ#eRY&dg2E8i%XKVʻ%x=X[y~&u?sDמjVVyq#,&9Pal]JTgJVhk(!8<#֎Y%nk8-_aCJZ#2`U?'8B+H)ZZ_5'=EoԆ`/(er{ֺMFڠyM͵'9:딐^(˱YW8Q qګI Y˷nJǓ}+yiR?eI*LۏwdgqDz2Z *I7έs4ijױVy%b*c!ߦq[Z1vi]UHsqGSD4muO}+2HWRwn϶xyM9xoP۲V#P~~ǜ Vi38>lĖVEǴ~҈MY 6ZTle=?9J KqkpHą#:c<R%ok6h%Npq ǏץGz/T(h龥i2m?1'8H|ʕJv^ @eP(]WɫŤ|>c. U GG#ӟ8[n<˹^H#iAU[fE/j${'lq֧mrǖZindS a.xZ<֋0F6uĒ_I+G6`9}+N:~~}Ŋy^Fd[l3wNIGSRW*$RrCFI^~SU9NI⸷K$&ѷ$qN:g# {Y281$ɸyt'j_שJ2E8i,cqWGj-S Sv"YC;>T/yooj*JuJRw"img,cywjv2߼b ,p9*סF?h_tk#(qֱqבxЊoBY Ϛ"'~v\cDj03z{U^jgZ]nP|`=zڳ.AF4Ut>|J0̱ʿ2|WU8SoQL+DN=AN*2V#4j>jR7*2S)/rCڏ,3y_qYdjQ^밒L&&hb yw?'(lQ3]K0*V#$?Hܡ³Q|Wd@4uɟXcrn$Vsϩ)l޿*u-(+3lyk|0яS\rݛ3rr۪ LŶlIi99nڿC(T߼pɝ5+it1Kī,ݵK:qT"򥧘ƅ F*"ڣULv뎙it:>z xV;ezqeR#{ƣFQk5ǛmVo,vNx{Z?i;{h:nh)βm "@Ln)T%˷A]ͶIה ۑQXҒMH T-{\41N1Ujx9ѩF]]}4%۲4aɝYd{Jrh+^pz|$ҳX挩Z#2Ccg5u朶;bir>2ܯ4[nY|yS h~g ([.c#n,ʼpp1&"fvzߡ֧r}U< Iov׿q8AɹE~SJt*qMu>i.D c#A3iIEtN:QNU}E }Q۽i9= TaNhgvH/N1ҩS_:VT_KkeD ӀֲRBFպM.g©LlgZ1S]uԩ|9di7} aBzԣFE+#]jJ?zY;`=tJX,Qzrtpڟ(yglj6džq1Wg4ylQʖr[4׻dh*NÒҦ*ZYqK>QntinfO&FƉVMwX{~W;;:jo.D]$g@4"O8Ju*Kӡ)ZJ֟*[w&t0~]Gr3#.1gq#Fժ-HÞN S>րM|FqzS8)ѽ');y#e.j6$nvIp.٣3YdzgwJ'Sȟk)QRn7OtGoe7$lO @#>vdG Ri֌VbO!]ye]QvǸOƪo2T+QB5-+?2@<OjPQ奖۳8iQU,`e4y\RQ=ҲڪPwo苑aZ8V8܉\3]QJu#'n]J7J)wDko$pVo0?cۮiW>ʻ{$G<()1]ql#wIV)Sk]AӔkyaY iiN-i7 F2wcl [q$;UUJܣ<\Ϣf 1VUj=LkK&bN4аvd0}E{ܲ\覰'Uxn=;G<^1J.Zܱl`k+"?ȪB]IVf]#u:Fe72Q?#ԨFNȹNGo vݻJA<޶(-3KX0|RW H<ֶOVKFmJ}Fgffd[w]4c65GXff_siŻo)Y=zyL#*ޟ(F)eE9obKkMN7qW>T*NS;nD?¼_{EQ| <~lgDVRHMKT[͎{U:rFI/哷9;O4RRw*P5$'1ɝjתR}6a#k^<Ɨd}:s[JTNSѿ_.9Ro 6O{qEGJ)CVɺ5F8!ʮ8ZR{{yGV\TRױZ1h]fiژoq~+Yssh#J13D's3~jۍҽ̘n9T}'NNQC}ErF88q4Ӕ[QdƭHU ˷뻜`IJqZ0NNib'b |WqZJT8y1Po,reHK6Tk,"6I7UUY 29Yڢm~3wͻjQ9i!K);ԍ{tLe?R'y&۳Ax[,Ux:8YKcO٦#l)+d; jKB_ã/ї'9?P%M'=bVta+mzQJ6*t U$'s~JzDR\/uneJq>u]3so%ס$_Ljbڱ*̻rϮ?:(IiMHJ2@;fU]_dᇦ :ϕƢ9kFJJUԮeLn 6x_}hTĀ,g&wq\5ʤܢF^) fe o|jyF1(MKE=G8ԩ2ң*uOK<`h^H|a:ӎs׽uN1Km3nYR4Ou=Ǚ6auSq`ʊt勵0zZanb͹s9v0dk]eRdIw华0;c\=E-ٯ!*]"U9^jǒbֿiCq$ißؒ3?:ϖ1ؿc*iZ&8F3gwFm?&+hG]ۂ?qSyϷױ|S>U%>7wq%=ےHL돩Bbynkjf"[tљO]K+:qj"mAy,*7<Ksʲ!m=0xOrs{IrQu#cIH7 nj 8%=n,$gp3F 00~I^{mzzhtzdV@*X=wkt ֦C7?(I[hAdREW*[k̨FR+ p.>+ec(uiڙ3ٷIÀvGR2VLxfϯkyUg UspDRB<)\h;dw19]ÿ~ԣ_R4B#l/>WȜ WΊy^"\G+hÛTR.|9s[F^9JObR69ث's3K&Tࢗb9$hjHAS}Tԭfʷyң đxQH9}3DZ}#М 2? .C"~l֢g2['!dɏ-p'QEʶC^hKѢ!*͑ӧoqYBrFc.ݻ׷ڸkamֿ*Q̊wf fP85ňJRwDeSG=ؼɮ *W):t=OoZƧ2nzMj{'YN/5čBש}Hֽ4~g6ncd+F*~>/g(˥̥Y%ǻ?.ǯ'GZˡ&>Sw۵c!ޕh˗Eudč0h|3p}9{Ewi17UY,NT)a%cJtN2ok_9eݗۨٛSKc3Һo[v&T$?kK4kv=@Q-)G!CpW2|;N=9^16K] 8Z&Y~]>y8*/+zQhK_݆Y#o=8==+_Nӹs,)5]!I'JQ>h%65FoTb׷JP$ׯig(ݽڄrutPN1prT X|ǂ$Qڌckn(֣{רl63l7ߵz!~R.ҳ_$ɢ @{8*n0W>tǭ,E)TxVNH;wЎ8Νʪ$ݴ 'TS4'OCkt릣CI'KIK|}Emz2sJ_9}'YbI}>dnv [֕74{_uK(I;-[b9_.ov9e\;F2\ d *ȓhC|Vcq?65 +QEw%e!dYa[|p*{smZݿ34;F7I 'Z2v8ZQry eۘ^5QF?Nތb,j $bmϧZn3GDN5UfaC$'~飙Խ%%rF"OcŻGlO¶BQIhRV.-kDnުT3S)?[/C:ȞI񿆎02Q!SZ%k|"6?/QL/;X?'=Tqq /W"Uw!m2?>ki=Ί0哄;l@Uj^~Ƥ"`A 1s?|60zc5PI/9N2[qn\˅"`Eqn:p;,jp??\Oo_->aYF뵎}5~Όe#R̕#$\|ecԌ3d =uӣO+^/Y5I([5 ds=sof*%}Bx^Xc#y(\38yKu8"$HW%UӧjoR|P&vP7| x?Fh^eʦf`ʃ[2n1Kϑu0Ek8 Y%FASJc]p<;GONC M"C 繧*qz=ьk(dRKp{+2Ti-Sk29扖1SԞ;WT}ic{6ޝ1D\$sJ:ݶ"8WR.W" hmYN? ѶDvхS)lfHI,Et\*?zҝz; ӭN^¤.ddY K+Gy8g[E)9Tyy^x~wJ8yIKcyVKA: 6scsc^aU:яd}n>lӊq䮓ɸ%Y$y1]goZ*J2>J2RRkq#{#*'~S^FҤj{>o9Vo8cm6m:ʪ嵒l.Rjm}ŦvJ2l͐k{Ziܣo=S[uȶ+IW\/}W oHԪյ_Si[-#T-3?v,p=LIzL__}7mgqoh+,VnFOjrfZ-YF+GZoɨȉ14Ė$0=+h%QOCռ!oGUp)8x=UʍJls'fΪ?}MJ5|_^LVrtmWM{ ^r3,0g#s Rwra*qq0B[p|'N8N*od}HEFѓg9IQt]޿52rNq^s>چ!B_ WŒ̟i2#+cԞҹyYSJܷSpТV; <>SF-6UTI!K|b>~kXƴou^EG$F>!/V'8z(FϷcԋËhrY݌S<ܪi59Ehe|m'ac+ud¼ )K^}|ym 1ïW_Sceѣ-z1$9UO[S.TᬺAD.7a"m#8EkMZWR^I4aUџF+ٮ4㈕dv$k/ىef/g⧑]JZu65˱e8}+HM-$BK~x|nnۧe9}cNz>kgqV v78=AJF:rq9~*tRŤP{ǒ5U~=ki{J84y.h__"վPP*z}wnagolH%/4]}Hr.GRsSe8# Z+q!g}YQu2J *̛uq}Z2yueWBZ1J88焗Wd7Z鶲0>vzXU h1O=^yr8Y_БO;\"lR\UZa tW8~ӳEF3U޽ I{(l1gB1cȮz٤)Rq] Xrunj^2,u9rAȐy2 T>tʿg~<70c9\+R䊍5VBF7oW' rIKR6wl;͒3ZCQ8" o/'u>p8LpݲOJ横&[)rRl]W᪋)򜥨4pCws+i9JWQVD4{#5ZtFƝHBZ}#JZ~`ȹ:ӕ4TycUgQ񫪳{־Ϛ:1ޝE"{xZCǖҔi¯ZrөVqaUWi#59bЧ0cU#.#G>W TUf~$3@*Q]4*J3FF$|xU8X\`1%z$SK`O7l nv\ZPEԧ{-uü%m}!wYCHtEГ慒8 di9q9sV<Ҍ_.GN' RHI;-I̒n+3tчfU{?1RGo♚pc$$6zzd֯F~'iZ^"孪Ƣѥi=*oj➿=17Ԋr=9Z5}HmUG{JΏ%4GUv-'mɹA:T*rs&Tu}e6 = mJ2FrE kn0NxjCP΢ڗ!O?{у6j#~\ZQ'nR:qIuO4BѴ4o'"7s 3z⪟3z5)FkWVK,9ܽkrǕ+jхr6Pfɫ,W/u b5?ʻ[q#z;[*q劓\YFm*XvIrTN1OM4'fmn@l;Z-5T#sCQ{X%RWTRH&]e,em%="H|sCf٭yVCߦrqgk*TjY'krfHżG2N93qUs1iIi#7,{w+YFSp* ,Gu*qjNϹV+꺔偮nEب#Ewռq0KYJ}GEv *ɑ[Kؚj^w,5W,gUe*.q}3\!'Ti˰וhʸ =1]ReM$F*nTGϜA=H k'o#<:",~ +.}**?v)[nJ7u_e-hO,`gZSl#^Rov qn}+Q-RI=Ǚ.E1m=j3E⚔YlC8rtTBu?wk: iܭ!O)ԥ(3.T6ڼ`wMg9{QũlMZ1k@:xjy"5ROA FcVPL -8ȫ%7e,_BX~nX>JR +'j*+ʧ5݉9T/΋4mrffq}$CR ӣb#*tFWzkuӔk՘{K2/NZ\X2EN24Zerwo0:*"RBiԂVy<ϵ#4sZZ-]m"mRI#6eSB{Qs+Zԩ=V\Dw+pA w?4K*J2Jܿw_QO;`yw6jcǩFUe Xس3}AS(F: F-݆$6,ї\ƣU3K RMȭȫc{^߁G mȷ%Hꨅ0t8/jR- UdoH?+\c4QssN+qAoJửtgii*zSF} @"dFk ˖3X28G̟kHo;z }G~kv:ҩ|I(mct8۟vr=8e)JGD'0}#ZrMvJ9'rM\'1Ufu* +5Of猣R:'Wk*C*q_'fIq<i*rOCjrw yϚqԁָIs;hN2iqISleWF*;VetH!Kx1{8\澨0H 4yfS-y}*%WLʧ&$#I+Y]NৎG抓Z[v9ʂK^l|Z4r\N)*}; {V_^dNy$e^IVCFT}+JӠ*RW\teᕔI`0U@M:S|:~(;% KCw|ecr9RYs)6 ,46^V=mO<{TJ$ g`{Jh d}9sJ!zҷ$}" m~ffP7kU#˪[R<̂%gfY:W^[mןݱѫGReȒIJgMf9Té?:K_nw9ȗϸ ODLWNQwڥXʫI]X]G d4?%$} iKV;_4$MHYX/ݞvB4i$徶~Ie,@'%`t5\uetdeJ]ۘ͌0}{5=4GG?\K$tvrBȼ۹9koc*zs|CK7DT`H:^cXFH6X+46sδrZnh¦"6IɭbߺMxNz]5tFO-ˈ >w[^=iBU9 ZI/mt=yoNfOlMG;Fۣ2a=ET6[)At4V(U@X$7Aס Uao9XUqߥRDr)41䙤h(X9w㶦|=JtZLt[qzϥii'ΈC-ˬ~,?1e~rG ^c)N^OTZ/OVGl,tCr{\43TJմKȼOU>UiϿ]̬I-D9,]>^S TFjJ~%zqzt7쥶*r9]C٢RvnJь.vǟ_d6Ya1Yݴ c۵M8Õ佛R^` N7/vsj'J}i pUF>:dJ^^qJ4UA%ȅ 6H<El9cԢ6֋!V$8۷sҳRkȣRQ҉>SM2\Y_rKCIaib%![̦)8#OGkb@۴VMϧҲH)ɵ!ghP(j=R#QN,,l!èzs{nc(׋v?!s 2ImUhtji[vq'R"XZF;hk3; <^N%ULEqu=:S\shʧ?~tM=\I^{>j.7%$c~hvxR;sXK? "?I儘lc&#9NvȭNs̾ʮβ vgY_C t$Ok4k#.לw&c6qQ.B(ηҢCl8|Oc)/O(=HZ Wo {pR3oGHП7\grkCZq=7R)fI0 'p{W/4SN5v^o0vf\n^-Gv=_R1cjcҹTrj*;cF9[at%db~lv5Z2V x fioʙSz~ ]η/Kko5rѓ8nUR~^KBeaw1ܾb +h c%Zn6Dwuڡ2' `dc8ySt(ӭ'(n&Kn,y'8N43Q(u GX۵XN;(+\ }wI4X$G5 ˝_Mx1iIg+ù@nܽ<+GSٸ HiөNК]Wx~U|A9jTNIB?kB>^Y^ЂC,\%N#޺CfoC 18n4_Qpqێ+/eNzKʲã -Sܲز00qہSNZzt+YԢЎh Ul*HLAߦMtQf5QJVI`bgHwa;OqY֧>V65ӷbIMgiXANy=:7+ק(Z|Ce&3+2 'UF-Wg *\˧@I9X 32-@#q?AUnnOwg59Vu2·t]GRrߗR[ifpk Q\~YQz54kMUTFJqFթ>HpT[?4vǑlŎ4|L ޜw<%-{:sC3c:{)BTے%F|Y.0QcϿ5y-R' _y@pӋmXxqBAxne Nx+oeN2Nۓ E$0%?5tySӊqhEOf[#[SK&D-1}-2OjRhkR劳M ZTp nzRҌT+܉d餞 6~O֮J0I0:4lk4d,Ό0 }꓏UKU;Veqq;cg7RU5)Em?j-$P.#`~ySОj'i%[|eFfܠ3xRMQ*V5@pw!I׃rlR}gl1G&AK$C: ۵*EegN2Q}+%0fah@߿[RWDWheug6\_TEs%`T.H k7m6n<)F[sM0G^cPch^1$yv>&ԗ'x"_um1䓂p=]+3-rmRG!Um#8CQ/")FޢK IüU+ tg)qqG,iw"y/&+'͵خg JIr)N+wE [E?39/aQ])~O1ӫ ,?tc'EpI q3o:_If2?ҹj(^f3O^^62>;GJ2LPTu!ZnsNݫeש,4)ӳB\+1y5a*{=ȌTSHo{R2Ld xsz~$Ib!KvО `4Nr6ɬkJބjqz} XgRdvWqss޹Si]pF )s7=̑M h;Ga^v9]I9vT U /nOs8eJW]u}c݆+ұ5F\->b>0F8#JQedm'.Nih8"Ʋ}ָF œס)J2sSjt]<7JUa+`ZjaFn!mڪw/9<㊆Rף*'R$v}-vy3>q8>VU#vcQrӿV]3[Mo]ӂB;52RG=8U9IIٳ̩NK%ov啾\{X|IlA緭qUinKm}acSKr#Ȼ@AAc*X|#Tr\zWiFpWtfܪq<4v[F*^ɕʩ,b3,e@,p=}k!FG~j>Qzv*L/5hd8eV);p΂eR QAQK>:_J)NVKM]: bb-.;GQZ+{թQ-.6D->T`~e9xTb~fucu?Ăib{xeqctO=RHɴ?he.Z7L2N7ݦM$VZH Ǟu8 eHӏkS7~!LH7.>q?ΜiFTm{۩ bt"+VKz֍Oޥ)muqg-zRsF' Wxzs޺%ZUee* F<",S &NW-Jtu "o)ZOB?28Zif9VB9F;uu/j-=s| iVR\]\5fE.ӌ`8ZҍXNIYuJ~ҋ\wbV4ث*S ˥:5*ն~~yj=̑yq0re\s8g?L Rpn[k&40XWhݢɂ9ln$y93SW]Jt0_uJ-ofV2ZgEZRvz=ߑ:o˲9%LǹXrI-s=23z Ō IKt7W3Rz繖#wDogpIa(uױS改kjȪ1wm3Wɶ?+r[dۧj#R"*VSP~uuu|B@̭~(iqݚމ;+JYBpb>cgǥcP黶g^Cx(;9m8*}? E8Ԍb=O3JGX2[aVUQ5ݧjZ/扭7~q47xqM5ܯniim|r9 Oj5⻿#)a|ܖJݼ:-!O9wb*njܗGTV W Ivr=d–Q-Nen<94.@q=qmE~g6"i-41ֿbB<3Q׽ghfXz"Q+<$񓓎9UE6ݯ\褙uf+Ck4x <TjSk??cfH\.Z[u\!46[h%XVm>TF{do䌶~f4Mu qOݖݔUd S\y3'N)\e*qdΎneEl3q_^ueRm?Ng[=E2!N޽w7^ƥֽ݅Nb:6xDӞ"n2F|V9mfKFIl=:gӦ}Gtz*S粋9F OWf5*@$1ƥ buѧNӏkUa<ÁBϷvBֶJz9t[Z_^EYdAweOqބe^u{FjїKAZO4K7?78'LiO^~#|DcJV7.Xkkq5$2< 1=)F0RJ~?Sj5o_~ ^kyv=Qs#qҹ5ٰv<4ITiW:TJg\]ܬqw$aG`ƛh▽LKPokYގ#BG8*I/FUjs(;[ɭJVpL+o_jed9a{Nho ]ȋncc#mlHqg6z-?TcImm-BZ+:e^M㷾+9TqdRZr]Utzk{Hs0>_0 vx=1qpʤڔewUb8i0yD7b8YsSvMXJ҃o_Cj)p\;e@\Qc=McffZ]:7ֲaf#:7w8Sj>q .? [{lx\QBG'9$n+j2ԩb i ^]Wx|Z穦GVzcBy63ohk7V*\M qV5$3k߇kcZ ;+9Ϯ+ϫ=PKYdv6dbjv8zCֱ$G-8ݖXيU3qar.GrLw)ghFz25 G \`A׎Х:e&Vdo(kz~;Ο.NwIr37{h6;$7sj%'d>Jwn]nn@R& 6}ϩ{)ܥ~^<:SLeEC-S) <x=jbrOK_B9WrmݩE^Wbc_2}p;v=Er*#Ѥv=1s)?H*ZfǍu9>?$萋u?P9;jKtNSo?5䢬rV/B'x{WH˘Nh87`ܲ1?5R.2fsݒ]c*a$$@Mp֋ȚUv G9̾J7v2ܓF!x^^"kNɅ9F,SR@o||$^D}cT^RTK:7.)pH9^uj2xn{B=.PɢؑnּT&*RUKnrt>߇ZqhƦLW|Bx 20;zqv5ӧRpcMp1fWV-jkgjuF1nR!|&Տ!޼qe/}}mKKݵ Ha9?P1*Rڸ]F#21'8>Q%' /y(܍M(Ѫ#^1~ ߨg]Ai,C&ciUy?5u#GGD#z?|(Nn=Q7Ţݭ5$7tY?q֕T[&M%(Z~$2kAXt!{#$w,Pq$C5ҳe'Mm.6_:%,b>S8ϽEJoN;_.{ob!~޴No.gk}69(US6MO_0y6Z 랧峿{-abym G~}+yB?ݯT3yʬn]&kl8xhE›U]]>GJtcV=uH<H~FS*dSQO;=謊lʤ/U1>HN ^R$gV6Qpg>?|b(,ѶFF2=ZGѾo_ԮZ owLZeܱcr{w:wK[W(E*ͽAr:\j<^=2qRTTb.)S{ZfE|wspqp+PR:[&_ X$3|߻2?=zUN1_ן-t#kS+])㯿U=sKDO@t;]ЈݘycgecQ\h+FJ]Y$!6IĜpH=3ɨ8\mSb-_EcI$sw(Ÿ꫈JcmX٥%%A8iZ5T{f(= à_|cMGn\kFq$ే 6;z֔yVw_*.\]DxcK#/uU*;9zRs?Z46zT#."]w1em^gⵌ*-Yk{$jo0Xksm?1cO?).fzr'u~ \p̝Nx^ϙSfTR?}bAs sYCߊ^awonߩ9HEMʰX#wcNY9GW_ifS;K2c|n k~l<ת<:tkЯصvpF(RG^;Nk.Z>[:i({u*6dFU#k(Qv>(ŌM;~DZXTR1/6Vl-.iuVBR~?_\B}mF:ӳȎcu+@dw1֔FuWy_$̸<aYQxI'?朮^*Ҝy]̐&E$KAq4T̮ݗKNѿ{dWXmqj5G{cG&J_|gM6%y78u .Saw~n=>c:uFsceSߗz&}KG?k6(S|~*M7e|OѴZJbVH}90%Nªc8ש5F ɩ+ FW6h7j˟H;WdhdSJOhXSnXWKy.$8UaaONC3[B4(sUsϯN3-΋.O큏nyZF<,TLg(ubCi>Tr׷z98F>өԌqFr^@+ps'9_Һ)ԍ^~^ӴIH M%G=>VZcZ*U(KKs=6ݣ?Y%/lUN/Mf^Aex"#ˌ1]^QRܑS^q^QM4< g ׿jRg=J\]X<)w/Fo2BʮI#$pyIJ<=,=o}JKV3.hu+ddxQSn75~F~zwI+ʴ?Ҷrwz^Ѥw]~} U;O8]rc ,J~Vgi8:e>U|c.U8Gʲi`0C$O<;{G74S;SeR#$ǖ{Gq%Y*Ddwg9\QGN;6K$nyzu\>q*wR%qmy#}+_G⯿B_f#32e8?Z¦"ul/"M+1[屷s8Dk.{hF-u"Z6bWV,2';ZdD|;ϥrJաSrgwЫ׏QOUs^b(թ>yu&_}9sʤ݇xzLdV,G=sYהeSS|Ɍ3T-9ZJ# H?(5}VX >6}ZMFV&BKKl2gpBٳ VN34nS/ ;< 9 zJj1MjZR|bF9%] sy:Y{Rdj%>gq޴撒t'eBDRL]qO,Cp*QOn%ʖ,)sֹJI㧉 Z267J'Ulu溥RJ[ZqEA޷<w`tc92c)nm$yp7FpMuN6 ϛ$BI<͡'zS{8Ns 1& 7+q?;GFǝpp!cGtSJ:Y-N1*4{ltӖ۱)Ԩ,d+v٥FkI[ӧr1M/fH)/Qק~yO2^ECXx[:jrʧʢߙiɚ%tA TnsoVjm @#= Dm$Τudn8H2I05S(Fʤhԇx橸Ƨ2W:e-"H.Z[37g:\*w*oZoe{;R5*Cr{}=eZ:9na(5|G2^~ϛFΚN'o&Hfy$mY7BۧB}%#,=ogV܎ fxr=O={!R}(_]nIysY!`FSwzL9xE_o/'h=&ؘDeBj:u]ŏim@8ڏ9TjsϸiGovWI~g)ϝxJ&UWhꪔGK#GqѶew8A;V8B涯#o.6V]#نj1}U*֔TV_7 !{c7%463$}G>;VIT)(ϧB縊&H%6֎1;˩Uz[NR4;[pi<'#jJ;ruKr:Tn[ZȶWqm,%OZRӈ,CwQ쌸fnlGft&\TK]m̅$V #n$~.jqoQS*כn|imEپnsrUjLD}uJvG|lvbʊ1sHoB$?<:u8ӌev<.X ևS11b;kՁ<5NTƍGjC$qE9x8{NjYVC/rzTTqTs<R4h.60CןaҩUʙeOv{{VCrČFsz;ԍ:e{i/ZF๥o!%EeVlR:Ք}nawbXUsG.kƲBInI PQ)G'5ThJWv34zl'SpV>{geJܱ]kTvZ3NݣU- XsԌ/s^GG66M*2?.FP,\umZJa-mn=?iRrBg29jێAK[^c UhËYag؟_˚Jbִ~O')LVL/\ڪ (;n@ޱS74Foe ͛`Tܩ圷c9*E<4j-At +V6v ބNE94n* YFᶳdl'+۶~u*Vg'ȖgdnXrGR~ԩԌpvdM`{~}t멵IFQi5$6P٫3I"veR m2Sp7̴?4[{8YV +!tRjJmG4].Ul-V9KL.za߮1ޜyz6c}^+O&E 'd~"Q(%{ƹF[uZ4f9Uy'JPMFJҥxXǛo++2oXw?Q3jR uk[ :$V*BO޲qo)k_wy0&ccӸR5%ԪǙiEo2Ep<>ԔoҝERMKM,T[JeO=;δ?9gJ,*y,#ЎXK㱅H1b ",_*~+tӭVW^Z?y#<ݣ=@9?:1Ims)\GpRO.b߶Ad|u95y#St}7y9$W]cK/Oγ?i˺fK #L Zq[psP^+h~dV3yZƚJ/NMԊZ'۩M :GW8FrS{O\Zsı<݈n3Nq1Wѧ!ȒH#sEs֟5RҪ=FEWK< e|8`$ i٤*VnHdA_ܷuv%g+ܧE4qȎ|aO'NM:qo=9J[CmUn^R\Ϊ^e+i/18f ?<)FVn:nŁqUz2obrrInldiZm1$m9=zuJg[T|yM4Nn f> ?}ZϚRZN߭!i !Dfݶ<`?ڇ+Ę֦--)!^T&\47mX1 {{Vu*S7j a^[/"TDMi̍2p>>Z{=hөed IrE"g(X ;q9sh{NXz7[\Xe9ّ|O_]:ЧE ~ބޫE[jݢ3x\:F]A"&e>Tn㍸Q*טٸKErZK]=ϧ[¤_0*5:Ԏ`u{yL"' : TZe(?>Čf*G|2L[|xkJF\өZKw$WL=1\XMr>owEנ$yv$zϠF""pIYɯ*J<ݭ'keI _1Ig58ӼwhSN KXVb 9cq^t-Ic}Sj7Uwe Ѱ>s/8;U(_%Ewy:7.쓅>'jR5̴&#_o^ Bflg8UӃJ7CJvU_O?zzKcʤ-'%nlzM.f`^>:6J)"Ww;4줅m+/pG HQ$5Si꿯̊5ʜ7v"DgRMYYT?1quJ1)%Nj<֩&Ӽm\IXV8pey?Uٖ`@W.R^E?3֧ЪZ sYT䞝}Q(QKv+^'^y Ek5멵:e)Or3s5ijf~fY#bXwbx0;`Y >URt{2Vښtmfy#]*8iv߹~zW bI >fsƜL$f;ɾeeaQ)JK+b^4W%YЬqݴ<`=N(唣οӭS Svȴ 06j_r?Z)ՙQi4RY/f+9=xR9ԣqy. hgNwьGS U5撽 QZ4ImR߼$uB: h\o0YQgYio*rKu%kv8RWry 7hRq}JQZ.I^ h1<$fXQ3Nm(-5wV0GoBzvӦ+jPcm%5'\2r2w x87!+79RtL,Îܮ?}롨7]t5VזSy[yd 2[|(+U+#M-,ܽz[?viv >iI~B8>ab{ mϠIZid۝$sӧjiZ̟v{,3(ʷ͙O|㿱ENQtԥD![;eX9>>8+XA\|nY.VSt?BG^ӧz| IVb$9vvr ןNJ;ʔMe[24r+NOh4"<ؒ+ǩj*Ak^XfC챉-B'{=8eR1gRiEWؒdhI60yr֔dѭݧhܵrH[9>JVعT ǽ'9$a/ͅVn.c)JW5&Kkh<vYN6qwb٫Mi`|n22u彟s:sRNRd2&>aێz1޹eR. 4hߗ%rv+k(ٶ35I5~IU&dF*$`/<΢uZR>Pb0#U]X|SӊRutOboE`V|g"^bFGqF\q ioTsKDFjm6U`%j<2W=hI}D%J2彖6[ë́.':\1Jv&Q3P*w[PBBx9֌[}j]mv$Y|UApr+qRӮݼi ."f9 ``q=zEc;zrg(CcL?|mkK)SM)?.R#kEmw0Cc~o cVriA_nv~dZyYAI=1Vҟ&Wd S#d!+Ҧq a}**1qgeʔyj+G&,pVՁ|t}c[OKԔ^#ȖѫHU=zps4E(-zt۸$%w:4x!AZew4JM>K fP*<׎2RIzV2ڿ[io!֓ (`d27{=y.TK*5pev~oB~eoh~2FDu[RK;k-${!?3u?Qi^:S{5r{6(fSҶmZNȹͪ{8 1\LQO) I`qQ)#eSFT--/$uP}{VufgDgN6t@BH=[|?NdIVebᗑF1s0Q͔|OO j%f_ݰ#tMiTkCu_bnyҺЏM %)nKn݇y 6a;=j=IFdk:QQ\*dKD^N8ӏ.oȘӎ"yy*5tY. V{Zb.zs֪R^1Q8ɽ.68|yeӅZj=DiqN)7NH#8xUi%ICx-ѳ x8k1zvhNghi呋ۊszjM:n(܍ i(<AZ- sQRmyUUHVu[Z*H=9S*)ī>>_\yyoĪ-I`܉"G36/ۆT҇[_VqeXʋ@v8ǷMR敺u)ӏ-I4#cirL#RRځq1GqldK`!gSR/Vl0 ]#'j);t3r. Gx)5gesӕxY9p62+E64%D2-Xlg=OlUK-I(;7!툫Ѯk~h-P攭Y=Y6熈+JSQvfj'9%-q绶 11ߚӗʟ4oy-v,lYb ~y*(njkĶƳ+G&ϹW ;pG HV-Do$viSvr;GG2u>:$Xmc]ۗcJ\:2K8V[\rN{@(M%Ӹ{XDG yO?.;1?#JLM{{o(fU_Sh<Цog%o,Y[>I-, zSU=~GEaRuƹ | dvU𫥲%{9.fGs,q3e?VbH1ޔ}%r({ȦW6o9;8$zd;&Z*v;̖JIS;tuҭ~N *s|9<+AszSu& l- ws{Pﯙ0ejwkye-%=RJdv]1"?׊B>f,Q|^j}Ԟ4TJ$~c[LI(rz0$2q=[FS1qxR .e4c vaRQ䣿RG[Tcڱ)\rgyhG|!g>bȡ[p(OO~MӲKcRzzjXVF7Q8\\V_^ƗJBd@m_,sԟʳjXSMŤ-7U+{5<o.ˀvs7G WkVriKFĩ,zۊ/#dAXiYq]Q#6as.>F?/_ӭg(mNA4Jd픴$'^OƤ[9em|]Q H[)87 5C̊k|Iaqv\zv9eZ+Mw JQ^`dF 2K#$c}I^Μi<A 4!ƿ?JT9];wk[\rc=t8oB1!|Ɩ$wg޳(Y;~#:̞I`deV\K/뚧,X{܊Dseu YYv^q֕F5%/fX4cq_]L˺2H%ghгmOy9?r{9(wbRTG= w6e'΢#*7JX斩v!C+@\*`cV|i롞#EsrkfUTq\:5ԩNZ_k_ {>l F;8vYԒI8P[ktn˸1;ay 86>FߦqwoB3HUvqtt^N2*j4ۯ2߽q9$w=r1{W>&I}J>Uv2i ,T?t+ϕJsyUtc>YmA 7vZE_#9b}bF<ȫmD+odžve9'FF0S٘QIo׎j'[TXz`{D}!o#,z*䒩/l7$V쒮ڬ489ԧ*6fQ*X}LR{wVEelݜ``ם*1E'}<e /!h$03̬ GӜxeݻo;xBm~km߂c9rEixSQ*3,S"Ƣ>nT?aުHѨSxAQePIeჃڝWZ,RVB4ӳurar0,HuTSOyzx=nz[ 7H@l.ׂx55hZJVmzV&7W p@7^G_W'wpxVk˧_a,mKly>`А'OcՅ齷{ ٣f9JQQGC|e>J)Cw̅ (h@mɣӔtqQ%V~w_GLu탟ʝZ罍%6{ ~֑6)Vb<%Ғsw[PU)Y7tVJi6,|c$g%ZU*i=?3j4pͷ/'4̰m:^/LUJ˿PZt.;;u~D1Y:$kHm?@҉jYJ\E7$=ᅅओ['q-<[ 篰޹z\Ь_fweLRn CFZ52xOIG߂[z~F1Tgk̒[FkdO ڌ3VƬ(lw3^s6F}#k8Y'ݜRnOhuoQZO毚ᛎO ҧRF@99}2pWR_꘧zH;Tc.qQ+DT#v-qk?Zm{8FoҍG"M/>8a3=ŔM*[n}N :kko_R-[z%fifcO,y'۹QFR{<5h熱khY^ՌRܪ>ի˖*!JeZXFcinH8QG-+߿5(劻vq!?.Lwgj/)GN\qYT#*4hNGFaUi]c)0}h%uq¼My o'OONkNT'h]>}Vy nZ~ ' 2H񆑝2qҺ8*4/mߧOVLZ#\]` 0kjQ(hڴU֛.ޥ=f7U]q^δt>ݭ,1D#O~hһJ;t!SuQ=|X wQKTv/"hvXk62]B5+?Bxu`{vZR\FR+ܛ|),˞c~3]-RJק,:osgQNqU{֑OêV6vB4u8I4vl*$3SRqwZJ #NG>iZ"Qdls JM \U1m OEk*i *oY?Q+?u8 I݋G} w4|#Ǐ?L#(4k5U-°1vi>U#\ڣfyops(=8/͂r囷rU1?f-ch%?Lt/cJ]v$KDy2B[jBFx?JN"4ԕج[ Kpƿwto/4ln%v?wn#ފsqInbp ?ҳQ RJ}67.96T_7JoĎܻ3603G3HWtWN1Z;|yHõ{ϵg;"T״G0bR{ߕUH^Qn8qĮyc9^3Z8tO"`q˖NBy/kJKxcU+r_IS^oJ4RmWo"( |IFk{'ZBWvO!M #c~yefrTޛT?bND㦷c,2 29 xZƇRˎ ӶV-+9xHhaعpz(gRܨN1A-5Vj #á'B>^; L_NA#ӌV}]Anh'uGtq FO>N;~Z,Uݺ~fkѼ68chR.Zjԍ iG#jWPϱ)lp漖!Fu:MKOȍI$9k}q쉒KW#ڲe{ "<6 TNW-7(ϸon(˞ָ*S*7^[[$|6jq\rMȴ(-#BKyysQNZL(ʞ#6ovOwp0=^8ԍ5sNnJkhs6N`hՖ=$_A߹ңKj֟y겠Fnv]#!zsӞ; {MF:O^D 'E(As؏JFOGEg.mSVקS~ʏ:xQNOE'5\kZr\yF)m0Pvz~Gҽt};=wF\*ON15mq46m|7BO![cpp:dp8T"KZPU^zEs:&8# s5<'waTj4俧 yrC8Uc}w~%ϷHGf}-?z^ 77qd+9^$ׁ{V2RVmO}U(/=ji%ay(MU$axҧ ˣ5p+U2(m&㓞܎ZO*iJ?a)'zt욨nFcdN+ӧSь~ZZyy>Gղ:Fq#xVNOiuh`~c5ON1;T2^HU[OOY3"n3&WiԹEVȌ+rwc8:]?O(k^FƉ"u~oO|:UTt]:+/@lْmc1.֌%NR{[dUFm{ԞN+QnQV^u4- 5]q=r)=j؉J^굷3m7e*s%N;u8jTOXxm_1a1\23n n9\\u)FqU'hAi8°ƪJR%oRx5[|/JޛOo^媰Gm Q+3mf;pW'>jrk%&ި޴heU6ue)Y4e{KNi9rYU~`kDDI\ᕔlN~'G2+pXeer9X{Su- 왘33uUapjƢhvm#bkؖknUvf sb'f'Q ̟eˮx`9YEkXDbL1^!]ʹx;+-47*1>۶HsOF4ܞ~/C5*Nm_u^JԮ^xdݤǻ̙w/_H+ZU#_UJR~5U8gߜ)NS5۲GuGN.BX6d63s[*ǟ.eֶvЏ|Rc {P+=9_vkAlv$ffi[ H FF9Sqv*߿&Y-8 %$㑟֪TɨO]~_RZZkE?|Č `gYX[toϧ]hђig̑Ve*A=s횩FI="mѭȍ4_-jhcӿq]$3m3 ͌zs(\ֹ2lq%KnS&/5ъhʝ:rN2LG m*6$qTTSݏ-6$z{C}xG>ݸӦ?Sө("-̍X?.AR8=kIF^B^}"`3j<9m*tfqRN-{B /YT|=I)Va(T\kMt_ݹNpFsJǓ[ )Uݯ YGZDRpӵTcZ4̸Fv77lN}=8)Sn߈߸G7܊/UHt{H)$քbiƴT֚ gg$+i.YF3SQ䔖6E2*x_rksVkC:e'"r'Hls"wJ)YS[XC%0tG^=k1}=JG*VK},5Kh UYH$8+85hm#(%uewmO/u?iXYP''gyPWx`[˙mꔕ:|ߧrgˎC|^jvU4n%H|CM#8J%tLjnJz[̽3y0F | zGΦzՒMȪoN7lEjR$5řgolsEeQRNU"><|8SkVa/ sЏ+^]iF[]>9>:iv+FC3 a Lev}5T0~Ҿ*ÝEuT,}&$aP烒IO\O՟uZ_C[bӴE͋ 8$w|Lw$}/%c)JKZfӳRm]5-.3Ҵ7Y-u49-㙶ȧg AxR J1𔹕3o𑙵{\e~E3RTM3íiGE{xlaz5 GV<*J3Z_GO*XӔmNֺi{;ߦos:1җ"M^?4g[VYcTpx}z=8kSR\[u{5ѯ]&lkYTmu6T7$Q~8Thң(5OShiʓOw M- 3I$sFcb1'y8'9t+F1|[PjW Fcq4W| ،`Sy9%S^ͧ@z]r1<a',OwHۘr~^O )}LeSo{A\F`ݲ3yhFNdK*NJii~n+v,8_x%s(]Hs'ހ6ݻf/9鷨)f3ZQtHLl]zzZ҄v.bcqJ kR^;YZ>W3FGy{'NJ*ɽ?'F4U4RTDʬϸƿ+ZuOmZ:OfޖjU`>ϹO8Ҕ7)*e16feC=RF? V2X$۝͏zߚQڻ9}T/:;cm77LYSVN; wVѮUt#g*mI1E'- Rflwe0z˚׃O}}DmI $/^:VR2P_XIFѿd1Z5^[dn=8J۱O^䞫Հe¦3S=0JBG˷\>ؕz&pOM=RNU]W~[y?29mesWTy\c7 #<ګ~\-ˑ;[B:SNb͒A$pAZOݩtvҜe.vei@iUT)K{J|bkY?N=?:LygnaWVN9cy- p5ԭ'fӪ#lR$w[*Fې3Nz֜vFhž^k[zv3(w sQ\s#R2t{Ju)GbŤ&" }=*Ԍ9c^yU_?5qRFzTI/yze xaD~f6;KJzNc*W{Hd-E]Ѯi}LTeJJ;Y{͒˴8kJu%R-+~MZTfbnMo >XU[#'`dzԾiIY,Iy} K ,j)esU*** 4۔e,@re>7rkQVMoQJH^FU'\>kJ2f*EЇm_O_?o*rt{JqTerCyo-OFjtDhC`BrOz畚1*QݤV;J&6}jdyiZMuYfYwaj=Nrʷ2X_/\cn֬e-^R"ifѳ30 A=?{VT7ˇ5ݵ,[+ndžSJƷ2zt8/ԚfCpUFsm K빞"[!םzыiX<.XmTFrxGq8RFO#=Xrԏ)"5cN0m$;"KUN_f#v={t~1o3k]8m= 36~yGBw9?|ګ{9̪өr_"LhUNN ҟSIQs][xއ޶$tӧ{cCKk,rE3c1!sg5#]u6}|#eݍc ӎ*UQ[hZx-R. Wa*|tTdD2Ƿ_֮+$:Mis)A$}Zrq%)'שx\.-р r3۟ң)_SrOo"\o@_N4}bRղXpr8\cUT=/%r$2uY>U{aѝ{ԲrޏHO>Q=IV1+ӻۺũZ>bdQpK-rnO FQ95tFS^fUU|WwlmG p?AU>gDv{=祴Df?(b~8=kOvQ择]a=2;N՜%M++Z<.3uGbO3?)|zq[F4ά hL!L_7/N0?u%.]7[Fh7.dQZBP''+} d%Yw0==}>4]:4)wkc:Ḻ䝹W_vOsjRt&{xٱPps)Rcɡ]n|13a|ͱ94i"jtYdPѶH>cu=ei%%>U rzwF̹-@X1Wkgw=UN#Z lHQamp83呥j0JJ[\G "vFm{RIR歋UiEE5li1w~%]BXv"I;yd(ݯQRkf`A-YVW{t:J7NC -Iec:*b*I$I,JXg\R Q|-I#(w~_+ZGsI4Lҷ 6}yR*QWVa)ԒD{.~-^F\nx`A~榝Q5QVrl}Tch?ϥm\wh;ٶyQԩG6%*ӫ-\,fY0 :SR¦"!خYYLQIo9"c;yڻJ|O|UbHg^8gNRQ5yVđݣZ22.Nऩ8`׵ke.^tqzDј# <ⶌd}ͪ:~r4o Rf$9Ry;WNNRM.O4E9T~W^%kia6rI{zSU*{@0ňs㊨1JNO6}6 EO??'JJ0<*TR?&h V_D)J7%:OGnd`Dl njUU!WK<!G -JY7*5) ")gʨ, (Sϸ¦I^fu=onXwpG G˸iR1uHNi+Kګ"zzuor~oЉu'Ha![p߭T^쒄jrIM9q?1;VgQ{JoOIi3hHnHzg5e(| ~q6Я-pc&XATiMͰJ5D6\GơTd`t}k.\mÖolZU5)ӡO[GvhDK*(fvszv1+7QKu"=!fyYn:<ڹFvrWvq^OSrwvaa*cGOⱭ?iU5isDUkxߴ21<+_-9`7=dؽK_5,K9tg^xuJݲɶv8`T4ij:?.'Y0<`F"\&4d{/ P]Ƨ3&mHV秠J 1e+rF)'#0?JDܺHK&*ET㧠SRQ8=2V"ųfPK1l.kL; G b{u+5OSc?j%b rqY1[=׏_z6uvyo"s!I`݌`YJ1JULLU{0Iqk%r9?\r9z~Ҏ!=hٕ݃8QPJ9'<Ѡ̄+)= DV5 "+Vt6ya㸖\MrrRپzc|űʭwR6NJ38H={Vȟn} h⤹2i^VʺoBPgzjz֥^4ySLjnH8'*q޺ʄ 6 02h_tGmё`|fx#XT ?OjXu(Ƀ{hJ8:V5#{:ʮUm1nkӑ(Rܒ'Ab9O΢yd:[kQuZIܪxVQS_ ZN[˰ V;V8W[ sTVT8FTm5+ߢXih2yy,< s¥neM3LF!h" *dQda89VΤ2MSJ|˯KMyb-&Ã(򦖆1R\$A ہ1)Jzaх;Cg>dQvŦaʞzZ RRkNE΋]l>٢[ m- W^H=՟Hs W"nǿ\q٧5 Nw\%7԰ FOo8;9*QW5TV}:/6m@(8S`z{ Q}Έ1Q|ϭNō<_4^T)958ʨ8smq$1Vۂ6Fk ÛT\g]S"D+YCT}صRSƤF:+}n>e! NQYt*FMOV[#BJImJI7$̖q ۺsϯN*1ZKt8Yd O3=R?8Ȯꖩ𯘩+4:H6"]ly#:¤5m?3ؿgfb l6Aqzfhmr$iNg.!܆Ż~1zd+7{S,^/+8,Dl1G A==\evzT}3zǁddL$L֐IBTgc2EZ\G^ ]-.W{lGkrkLdu uF#5h%{Kff7_/X}#%(luQ|KadXh c*x=qZS+z{e {,y~Lk -nbp1Ө#zU\%5j+X0čEuF2NQˮFVtpCl|?(tZ{9TDQ'M>l.;m8/`KijJW̒8vm!W< j1~N*1I.ed8]2^͢ӌ^;[*+*IS|xU$׷Amy0˄71㞘V8@hǴ$;7/:jn;[av%*6LOBt*'ԍlC wBʫ1?7|9j.VJnVdu?@?x|לRISf0Ӧկ)o2Tg<Uem1I&647CH<VڰfյcRyNEkxIYO m>EWVU*/qE-m\11Ӧk*4?gOw}FLQ8&п^z: s*4&{z,?>9$gֱbӭ() S[\rN\y`,i!`qI޹yڱσԔ)GYۙ.wcrx^jekhmFTyN2IAEca?Q\29*NZ _-^?]ID~'*|Ғ]+yl0Oy.Y cjNNP(9=k}Ē32=d3M)_`xF7l*ȑۊ}PGQϯ7(H%.IhܖVק?zZZ瞞LrYW;FA t翭m:ܰ}f3y63ϹnUuOKc$^N#7wl.DmГ9c.X}LmNQ‹v:}k ҧgQE:X#?*61?)QSvRlk[t9H&H+YIw'b"?˶0c8+`G\ShRiZ#2 #"ʹ#>rSUk[ۮ.4vL88YSs<\j7;.Ț$DFxiF(< 3|aS%G:xV3,⮏/5R51-D]fEe#RFt&I[VUW 3q;VcRB'`rno泩VgFRe#G6z?U*oF^H??Ib Nds&ϡ[7-mʖAqӨ=}oY^*-]FF*p;VjTglrS&H|psך9bW]w݇\zmjN* Uz݄Yu]ku9jT!>x#h#y3,c(~UJQ:I'luW*Ջ?JrN2$2*ei۝͟*];5%$@dX;_hh~xtoOI69K$ wGZ|Tc˺%:UUo-7GG>*D+\}.\ETr_}ND;s6dzIj芧k9S6ՇQ<Hwg{'%:KoH rn23?_ZZQ7Ԏigqq e6ܧq$O+IsJ*浪?j`2RVsϿT#_2-u]f!&lȭ7SVҥRM3H֔c֌%XLGkβH0:uvWIAy\j=B Pas?L.FQrs$r\ؔ3dTIi48ySmtoN#3&I$;?4yJNznEy$Ll>Ϋ@8#:Y6c'+-5o1M"ʜv1SSލ(NoВH'm25fR |ʟ1@t{O&s*F(' d3ӧ5SݟrRV>5qʼ$ ޸^njګjCG7*߯U(FZΤ}U׸*c*ۗt>Ԏ8;#۞0?srNN18Ik>d*ơB?}=sQRRONdRȲ!]w9{z3QVN[1ҋrk,vƹ)7H{9sރLI-fs{Y{;hgnMb;F0gnyޢ'mʍ9N_NxTFl)c)cu#̍^X@͐V èLFZ&\_+V U0YxwJ59ջvCUrYrM:<0ҭ]U ƾAmμn$ӊwsRЊxʦexy\y9uw_ȵEV5{.<6Lvt^ࢤ)+ZYڲAfY[8kTDaK J5࿈ 4M!%0%~Rsz_pOWjvԞ2T~Ex~32.-|_0v>ݎT-cӹZqNo8bpYߐ1.XiRiVwIw+I>_N)QNV7Y~m} y2 aTPq9+H{YB5*Ҕ\dAn#\upW'FH(ij5mCDY>f,qҳ~%Vrɵ2ܤS/C+HU#, y{M/ZU 9{]ݿ,Z$\}G~?MSz-;QIGM W2JIbsIcZFV?3\F֦Y]i$2x#hFw"2䲓idY2w7!O׾x#Z3\nTeBѩf֏X)QXKp7tTK%rNIʣ^Я[H{v6&DpTBÞ8?w'ҰGJ.GDjtR+HD{xOzҔmeȬd]uen<试XV$xx:ӡFU*&1:vXf85>_˃8tW$isz꬟k~?ȍ7me]GjMGEfa[ȫǍrvǭcNm~ӿCib%V [cq.fZJ ]ZJ*V3thH1ҴulgϞJħY{V<δmUo*iӌbeo"AlS ,w<HьVHTN)'v 65+n~GzwkKK(b~VLE]аhn#| 5mɣ_XQ߫S|ȣsH:ڪiTΖ2jGEke ;YnkSrK=)KF GK/wJ˺6U9`5lϱRYIF30XL2{qJח4-v8EpI!BöFuVG2r%NJj\ǁz3tS'So%M~Bʫd>#+NKO#%:{'R[[8$cOw<Jε*q_)rTV}28ad2R9U\.*E8= c xX2NȒ9I"Bݓ'ۧl{S6N:/[QDPyl]|]ߥo+J4}k}[\E#N֮.Rw)Q'kdCkozTVsW#wS9]__OEV~eљ|H'O/{uub14h[1IHbڻ-%^rNY$\,V\(m>n=+<ܷ[//z .lqG*= )1WV[by.s ToV-̙/0, z<]jDZ[Y?[ӥ*w6W*6PJ7]4vrN+G))/"H&2@d΋aV;7 ^sWOfX;a|y9PUU;rzQui rRiߩj VBCF;qۧӥk̹j8KɒJ|t2`)DboRj$ wIXnp=~ei{M/\$"\+41}Î}Cte)'5)OGԎSr˕ y1iT"黡C *׎T-JNap$]mo=fg)'7aCTBs9T9q%}$V.Eʼk{`9\OKETc89#QD} !̭)82n+@zpy8U#IJLkM%ԌNr7Nc5ʴF)ZXF%|ƛnY5zqoDr2hu~sK0m5Lcׁ]v+5hۡI,r1߂J+31;RZ"Rj09{s79Qֽ-tdc 8_nANQ羧7O޳$G%xcO]NK]DXˎ´yd#no-|!|ަBWwX8v#.cOaԨﹳsҊ ZKVW۟3>{o# T[}H 6<Ř+?BoO]V.mwqm̲ biT`Yz{VrhU~~2&P8HG<v4y]Cmf$&uh9R#VO[́+"*܋u4}-ƻFE,~\ VHҕNxT=V$|G8Tnבq]Y$lfV?78?÷eWޕmqAgPYTy>^Vi^HW̐mP­Z4HRq]A?1ܼ;f+eRc~dI-wv\cyԦ C$lHsH[;>+VMr-8y1#'˞x\5*qq{NgzZC x_$GsV-SLJq}^ >fcf'q_ԫ_$~Um;D%ǹBm9Eװ|T7.F6_SYΝjr'vt$ߧ.d@oʉ#FAN\#.eɱRUTRۉXϾ+fҕ}J73S1Y*_*e ^&>P s/99v+QAɪ^Usګy-.h^ϧ1r2Ķr&׌6`WA;;קN_m+QX}}j*dB6!H8⽼y{?Fe9+N'$Vrđ4ʫԞ{g^z3Z([۱rxfd :d zPW4ϩ:Mb6R_?V]3,( @{b9MkoS%w͙Xգ7v[Eս:(Iu]QNN:V3O"`FFr T[FVILSXhΎ)Ҋ~!7oqj4p,0awZJ)/;ӡ}F0Ƭzv+kv=mGCZQdQKNmߥ̵t({V2**`aqUg*u1k6߫߼}TgJfkQgcͭI-g3KL/=a]1<~U8{߹_[EJ-|rqvL1GaHV$?aWFu{e|hiw2ś16ng'sq֕HG27qNi6mlj6>m;{gER>C͝:uەt6\̈́^\wVp3}:\=m{煛>{qUeC̫N4֦JCuW4ݥk=4kiھLƧj{1<!xK[Vz.כWUUx(\˭S;]ngˉIU*?+/Fr\i{Ry2ߙsӿY9I6IJ_KC4*J4ҋc9h- Vn|-zr+]2%1Dp*'YӨvn%Q~Zi˚-2%j˛a/ Eu{eU'ִ̚7اqn#q -WF3x]ї+{ݶJl,+d ۙF4)iRT{cqzXQ'{gv2y9UnWk{v[v{8eFQQ[u-]ͻ0SIӏCrʧ>q(\ b%\z~U9ҵ#uuvf;Uz“>K*jR@9VT)ˑ\pU܃}V{r캘ւ) efAc'\թ'B-B3,0ry?θk2q\'9hn_<~ e*z%.p|EynJ|8Wf5cgM1yy`Gvй1>|2ؖDȢEڪaO|էSfqTJI cڭ&vnV?[ ҳ׹U*٪dPamF'D7pu ct#Qk1rh$UY_|uEZJ4{zyJyRحƿbvM0Ip59ʜ]:W8q]tРuzt,$:q#7mgwżm#ssUOvF1揿Mt\cwn=uJ1vu6Q4lm .ϼWU#=~9r_wt[ܪ]Kerx'sJQWa(F)hAſ::"G'0 :NJd>_yw H"1CZ{h]~~^JkԖcw$E ˟/hr2i2e5V vEycj6p=?J=+|kq%!UEdC>U):˥iWM b8kTiOVj:w6o'2I Qr?p;g\ҩ9'tb>D1(anv~W$kr-7+iI2ery>;{Vңi%STZ^崁T3nަUjFMs:niE7m6aQ=8QJ-]gRqR]|hx.6`=Olwjr֖ŋ\1szG?gr3R)FI>ǐ l`1`#Ψu(Y-I媫6T2d(L}kHI/cG- adRmQ#u%Zx:Y4+$b5o2MrFHkJ1ߦ޻NU-׷JE5ebF2x1ǽrU!(Aj}NcF{mmʹ ӭm\`պhGyָS*1GCǒQwy2kSR6N-ВlnX<:lX/Nd$֏Vo[yѯ_na8ԥZ6]>DSy8s+-=,Ik<}Фm#SMܲTԑw ~Z\t4&"rgnI'=6̜fvoQlUgQQh#?P=:I%)TL-4h,Y{zgڮ0dъXg[\b{bn{3ڽ|qVkf#Su:j7+kk" 0WX oiNܢ[XBmB=а-O?65)Qan\"5/-ٳqۄ ;X\{}6>*p<%Ǐ/!𞷩9+ ҆U ۀJ`;so7[Vk M]>ߓ<,mDƋ5% Ex :wq1k+ZW.K=/Ͽsp9I~nN ߗ|5/,-ipFǦ }q_?ӣO#OY:x|Cq-eȉq:9*VlFFBuK{d}Dm[Z4Imh*xxZ6Fa%YLy^W*sNVjIǖdyeF0}˱m mmYGiŀ;yq^5y^NPGV^Υ~g#+ %ŕ0;ӑzq EK*(IjgibUBsrgp'Ӯ:ѧITчêrPZ|O//ŰO&f  #(Eէ_ZE42CI@t=F?aXRZsԓc4EP2X9@GkJ^Uso.TrMK~ c1lIld z2W3#N{޹ŴD&Iݜ :ccp笟W0ɫs?##- \/vA^Fࣧn\۷]3ǭ*KH+cp=zg5R'(ʜ4l3KD[2R_#ƣicFXr1~X%~n :qiȂX⍉%fN"2玕OSi˖2W[‹1f+I8::h)ӣ_ۖ(f ca)TqƣMo4aQdȡ]9{5F2*N߯-[l\1pzA&r3*i;;inՌIel '?Ñ[沩3l4cUȏE?,@:`5#i{Jp6ރysܾNk5Z%F1C㌲jp:]M[ϹT.i2`ʸm* =)S7Xvrzo03Q$g=(>YERq{:{w@Ygլ)OG^5֌6.b ̬@1ZӋ}TrJvy [xm)v$ӓ@zӔS_*8{7p5h o)~#/lWg^G7R*%5ݢR$`1nXlNݗ[I8-sas]TT5݈)SMy)WO=i19}"qܫ/VՊodVH G5NJ2sJI>gUE%7YWϗe#𩏻Mg:i}pp *S >ކ(ԧJ:sO>z4$M0wݻ'AO.k~F_YHu;^X`` 5,]E5!AvnI=9gt1]i`yZE9fI*hx8-ZVoB"^䌓VEO'pGYҩi4S[l)7Y ~*ʝ~P*sߪrqʨ>9'#wƟ1FmPU^r77R)BVyiʕ-C}h͘*{}J2Qz3%x;m2,J-^+qh=Mm!(cӓ!Uw5Enqis*JUrȲk#E#$>ԹN<\>y=niw+4o"n(\'ۭk̹7S*%[ [VrxngstRO>Zإy&GʸcvfkN\˚3ݮ%Y~.aќ<;RU,mF%ejQuk:F:2>>JJN3AFoBYȫEܻ[QF8JJrV=i.MBI#vm\2r8QF^ʛ].rM)-{>;>+Ƴ(,vӯ#.Uc-f*qŠI2S29JW3E9Tڦ3K_>kweخxJRz֩]ʚ#ysFsϵi+wqΦ#ZjۉX$er64G-4vb"8[KsҳsFwND I h#sֳIr٣)FTeMor>RUyQ{W,pli:f x?+KH$&=c.:>ѤזƬ^sJKS*cFI^̽dHڲfi(#<ڹ*J5.VDWfz:sB] ))rO6xQAU :1Zn3N P7Nݹ5R7OxG͗ٞ+GG8ݵᕧee7|9Ҍ;QQ~,}O'J:u-myǍ 8KxXxjMZ۩4|߆k/[_Ҥ#ˢi. mn0$Y`8gzj+@HA\Oa=+i2F‘(}CyI~P^LI"F#$xvF*Űo}ȥ<Od9(M !Jt*ObxYEM)R; v%MIǢ܎TX]jeGPTx8>^YsZj\ 6*BDx8ҫV&4wkB{Hut_늚ሶ{#൶Y|-x!SC-$G6jKne=#x#^)S"u0^49+/k=jV8s5s:ݓZv$&#{f\#;a@qV60,SšE@6˄P擌)r= 5I{[y~` 9ϯcЊH1 BnJO3Ei&'w$տ:\ђGLF?h:91qׯBk.29j+8P+~翽DeWWpRVR~,y+lfڪv8=~쮗Sbwⷆ2XGTJpZ0N0}fYqU"1r&FBB0O$4*] w.m~ҜW&U^l+`::=5(O.whO=ܒ${Ty[vHQǩ}Ӎ:kkk)fXm_\uzn33::|q,i"2p7/L_RqLδI5'@p 3'ҫIEI[*i۹4rFZ#2TFsߧ5[FcˇtFٕd#o}OZ/gkS nё\eߵtJRRV*{+r_sڡX U%VOKX,{O,{V_jI}OTkЫxn_"HcF!b0Y4rVTu[n~aCs޴QNvIw{Ȓy $m s榜ӓMG_= 3MT\{8VOV(k٭M9#r;`uVMaSPMiTa X wLzNQ^TMz C1g.~evZZ>E{뽳@ o0gIUOޖ"9j"Ķ߻*vp::=*-MBoLfpJ3+GS*%N-8Wmc4<8<ֲwoQԍWN-6bTr W.z#iJ2oZ3ul;tf c+F߱˙= /=Ϊۼ)!;[Z>(+ؾ{U{sOW:"Dq{hx yc ޟҪRt7Y w<,|:/̔[8dh5>V*-n[\)ʋq_.Ö )crI{F޾!Џ>vQ%n#sF+uJpU򱐃"Gqi:D.XU<ӮH[nWy8&RjI[k[yo4ھXszQZU%.In~ l!e=y5*Q{ M> B1g^B;2uJI.kzfV?+,e>~N!sA[vcJuuv3%HAxqO=VJRQYU`INȯ WJ#RK{uXyթ%U*sKo#> .xoc%N.m\_S|֋7rVWy̍ =u9r+{9Ǚ41uja)ŽG3ܤlaZ0r:MjS;8ۿ45[[YmJRj&U'մߣ off1H{wzZ~nTc'7kYK?a=v|͟l:bS5 ,Zɽ/p.h$- 6Nrt ~wRۂ nFk(YK_{܆ě#v׊"_85,- 7 o㎹zr\nJS#%#YU3>Q:II-0؈eR9f72AiB gp0=A{FRCUcnD>f<ۧ@ a\qVXޑ09cI5+BXo93H9ϧ{+FrI+]8ƣ%q.α#38JW܊4}y4lH>Uտ{$nd=ǖi_z4).C+6ʼnUO'r8b!Nʛ}r1$"O=I]s霜z~Ҧbr:zhV][g r1]]ǚgۄocV%q_(q;{Wnf5%EʝFmLv6kFʪqWSZ 4pѧnkb{LKo*V@[ӣFQumUd{w;́$YIjcduC.vmB9HMߺg۸pNBr=ӥzFQU,n =v>^$}=Ttzhm;m'6>g895N狲OF5QkKc7C,Pֺe*59敛#i#N>F8r={סNmevM.}#k-7*7G,8qᚺqpwiXemʐ.׼EhaUTt>F-KFӚT}ߠNʾd<~} vG֟*8WpSVZ*AƗj8z1=uayOAsλ8Ť*弹Zlu@NQw_z:N#Iku3Z\C3G L穨Nqm!a9j@.,p?rZ@w7L q^9JJSv K_04($fisS+rs=,G#$i'1JGT#KhI-Ż,6_\HQ)YCUWb\/`=Z^;،-Nw~e#IAIUlpǾji/U9_خ"=Օw ~V##ֺhڍp}u,dK(vpWtƒ*2H E5$k[T$ͤ>XhuݩcJ<8$'Һ:\/_2Vښu1BS 98gҚ8ƜSJ_n9V cc:IWG4FPvkj 5vZE ~s9r}?dt;/2%gv&-7 c4{5Z)Y)2ǺY02ێzsҳʎzrꊢI,4srImPG9{by_eHƢW$ 3JUUZ60b8(c^){*bS߀nKIsB>+H*TrbI S 3K 19ELiʝ7%QŦVxyjH$FAQRVؤWgVƱe0}EK5OyBq~(ǹOz>ߡ`SnUeEW uN+aQ[yk?:hw ׿SzRTVI \q~2oUYVyYjk/kIΝmR "IYl`C=c)sZJ1+^̄3&cV$鏥UJu](Rqߑ0o5MTl$1^r1Ϯ}n^Ϛ2/ƛvמ[[xJxu6vfV50|hTVqU{KOֿRB$24RG%hQDvcEǧzO}u)Uj"K2ኃ Ҳl4U}v̩gM.vGdgXQt*^Ϳ{VK=k>hfa?=tsN&Vu O=9\ҍm/ZWMG:;aqq',ƿMh4*6[uU3}샌Q>\\FriN.RG6$ɍ#y~;#YIFf>-"·r}j,5Is(jU|%%$ݑ)d[zFX|g+^۫pD{FXYrc:vESݎ|%fopo6MDe*ڴ̽nOiX:hU[3bzS%M[^fmG__1ub$~b=0~><4MHٕbyH ʿ)u?gqR>ĺȗ %ಲ$cS^^>ޞfٔe^\jCXovUqOO\s[BZ-u*rkz [#Һ({ZzC %'5u=ijIsYCl|/a߮sӢI8wh y c r~WWs*6,;歯{hJfo$5R`ݴ}OҪqiPizhGWL2RHoFRQ8N_d۷YH jVXwHqǿWU4c:pVm-,B7e[)y}sOZ֧&aR5]-$bv+[S-cgЕd=~$}.YVv +23*ƪrwme.TeEETRHoo#l(ht&:K{,L2h8hQRMOE{}dsuX-AGs]T35Nj)E-\Yd-Us׷?峱}_!j,e8Ҫ 0xN˭8mttMͱ($t'341$yAu, QZFJOvn}aYi}Wp3Swg괎%ZI<ؙYwN:wVLy2wʱ玿qUƏ-6.Hʣ|Ib~aU3~oFrRETi.Z|qǕuU9Q~JLXy{X"hn#Ha`yTsZ\ltӣ~.]wfn?k$FF?2j݋W+̬܅W(TKKn]sZZjJh@O s[Wnflңr{+F2R"-ç5²c㧥mO]oQv&7Ǿ;s[8 R-ߘdd{0z ǚ֜|"IKaw0~H_UM-hf`NFKsǮy5,yu*5)Iۻ;UTt)9r/vy%Zᕌr}vZr]:4i <ѥ\Ig :0HU)./͞;_Z7Whűy'Q)[N(u z A&9y?iJZHe\pO qW}4.gG.|rM/y\,:,Kl<5[;1ݹ:C,&[-Ձr{zVї qrҟ[ ;G=Zjd S W $S cנ?ζNe{Z!VR)pd$8ϯO¶T;94پH٥B^pw'j_5^f"RԄM$M۶_&I' d|U2<于&+"MvO*)vZjjZr!e_-iDd,>^{{8/ۉaXerJN]Lm2 lyp6`Gj茡#j|/;Z,NzOⱼN%*V} 8mdRJꔷf Oo"Z4fzԌsƱuZ*1֌l+3\ӈrTJ-Eِ#`˵̰x9瓞(qmu6:~Q lkmo-$==Jg:1rDBo-I8W!Qqww $FXlm1JU%wZ7_/i8\+8S׿ *;ІIfmrq )|<;;nk #4g3}GiSJW[:T^3"ɹv~7i4)E?D7/$1r9".H(ӿO7NI ,ʽzzDee歌&6Mu Mn7I+Ğ=OtN.RՒH#FLJk6qPI:5`'?)O\m;t .#N I_K0QV#?8iF(dvSjSJSkFvϨ>QZQRIy2[$ye͎229fEJ-Msz~Z.Yyu?ARoR$,R\+gp0 uԨk>-NhhƬ\椬캵~cٲ 31:1g'ֹ<tFXZ2z|ydRybh´jE=Nz-rjsT%B(`\Qz*\F4aVӟ2'r[#ojy-cUNɭ.D.>72; C}eR'z\#V)"\b$9sasNbWGMэgQ^a{xđ@hy\sI]y'uuu A} v7J44Ѯ?LtV_y5kj)fQ|=ӿڝJ:nw9N5+sko> \H~obЁ_ps库ׯVA(uܡUpOyS tUHhN3ZJuoT玾BVwjI[2sXΌNzr":#Qrbږ|X#P3ۥm/zR?iZЋ>wvf'`vϧ*Va]IRHd|L@ r{U*rz6rʵGQ[[eH2FOӷ[Ǝ!NY_OB4ӼMFѫ|T;J<`{֕(Ir% 9O$yqhm,X ޶Zg%g6&e)Hwn<}q1UF#Ti~mKy{twI31%$Lbobw9VF.Ii,Dpb>Zg5W)JMu0ey&܌d:~z~RWoVi۲-[,lJ̲8n@Pד].NJn z,avVb'g߯vSlQIݓ;jZGX|{y׵mF1'M4_sks"Og|]QrVKne`%"O34{?jy(C?wo6u+kxӒv2U+%[qvHͻ Gk.N6'?/lI.ᄌب p'Oү<֊2¤%ud3sح~qEm:ԚթEG,;S$GxU`GjFZc)8uaI6(PNFyi.]Ξ_eԖʳ1a#`,.Up1Y2ИƤ[mG2LW'̙Cj.z6ț^im%#YݖRSo[f@K2*ŷUGzE?uark.cf"5*UN1{\7e7(˴av\e lX!6N늎]RD(ٴ}t(";Pdž;q֗/,TdNT|ӈ*P#. KGoanl+֤zVۭE/>vǘQ$*=}Nj\}-L$J!6p"?xKuzc\[(8ME~U-{lvk9{;;15vi|9SV26#xs:mB:#6%R+(H,@~=<"llcnNҳ/iZjY8#gY0̻el8K%iT4yذ\ 6\WW~I?IHc?9]w-'8ӯOwc>jI+__xd3[,-m'za٘|,p8#5&枝D㥺e[D̅%`~hOLv;F[|ȩIJIՋL-5.6Y6+*9^s]^-n^[;@wdeNF1ccF=f4±ׂ˧j?uy&Z)eoW,asqV4Ֆ2]G1h^U0Y$vNGOJ%BWg(RhƬmqg-gE5O,34@&w$?U9d+r˚}dIBڿx8kєem5ȿvT-kAg%Ԯb[<1=EBY{7&9O,XjIks^~ҏ4y3h5Np kc߅POc=Gzxi*u#7juZK<ė}rƻݣoNz+ًr|y;=kST_7˷4 iª$|NJV{GG]># slʑ25Z12Ȝt|ІD:bufd>N|Q_5knf3\>]LJaF{qu^ԣMr%mzӧ.hIY|[[\!wI :EpǕM8S{$opSJͅscKǩ*[岗ssHkOF^le s#=k9F6VMStLYƏPYW),Ӡ=kN1jmzx[|y5iJpV_{K%VT*̞\̽y#i1V3.]K:z7W*cs}>S?jQ50O:o[ܧh+47W!<qb9Sdؕ.Zj wgʸ*GFcxӊ]x7vb71S/۩EזI^VZLF!ќ_˵eQIFJIr$un5oUUu™4ge=Z]ԡZHG :W<8h{wR(  us˘ 7IgQ(&54mmI;v@33vɬaV$KeV<y)';s3)RdɎ߻S6Y5X1RO3)EsR^%MK}-dXnf(N)cjkW)jJX6~FSew?u喒7K^}J7;}o\֜ڧCZ~jm尽= sیp+II2}bиa78h],uB#M[]wh[r|naC*U#둃<74_`N-k2fO=zU<$~Ht湍6n1۰d9% QV$nJI8#2ZSI[x1Op]ܶTsXé)r%e/G~byF/s:pdr^O0i 01Iʎh6qԕg5b4rav6(;>UG~w{uyƕ:mI؅˛{sU80j2%qi+єo= 3ğ*66;\_WV;PIڅe60g= ʜe- L 6-$OqTg%Yduy>jdr3)/oi{~MpԄdաV*WHrdA@wPH\owKP-b2ސ0m6ߗZ4xa.߿GE)4m#dӯzq{+m0n2OBE3B5NтT^.22x:u}i/! ZH`Hndߌ)I˕4uS#o"YpkWmW9n"b, < :pqڼVNV]TY{[K3~Tsp}zƍ>jvzjMzR)PFp(f$߀F4tju+sm*hI7cyWګu;ԫQ2Ͱ_"r `ߡ4GWmRTɸdw僷`{Kj^(8zMIz4*pHv:UVIk_4jUR;Ifys9©G uWvdn_s\ٷ[Rwdv9J ZQfjOI ֒b2I ]pWAʴuF]{ۯmL^yC'C:dgonWv^yQPO^1I7b=}Niҍ7_o x4j1jfeT%Jrv1cݮ,moO98:w+GܔWȿz59؊Y?{$sKk[y?PI!TڛAy:v5\=JNħi^=,H%]XM2z猞:>_zZqONօwi-\q8DZnu*E鮛1 Q԰aH .T~-J^ݎ~t bl`cT]TӗqD; s3*<z~u1zor]V ꁤ 敶fe}RV5ej)IhlbFTrܮtݷ~~UKgz8XAh2{{kTȮYFMLi)ӎ!JW:tܙ*M}=swΖE8m_*eQY:kU?gMh;4A$C*~EqN_יR|u]~HDx"S#y)p۸' FzUNrzko? 6鴚\ûw'iG8]nkJ饉 Pf NI$3 )ݰk&t*_9r0@A}{NZ+^KPb/t6GfU`:/zKru'LE7[3z|-X|;k2ݿ#_R?Z0tu'isENhScY!$1۠T)S2=-%("n+;wBDyl=ʵq^5T9vyȗYVO;`NO}&V8{+v30tjϳWQ?,jpLf壉u~*列SO/D빱8t2NmU՘Ƹ>YcMI2O+xK$~AYfu4R;І=rqӸ80pU8( $n+PšVpJbW!:B62uwRr$-Хj>}2F!I|ޟ'~xOu{M%|hu&HU%yv+h̩Τ3fו_v߿SԥMgnXv߿?4:v=,*<@x)^)i]FtiZ]kbżN^¼MOJI:U_N.o]]2=>uT`bg:Ν[s><魖?0*d;֑sECG꤮ϴhSM%U0A/G#~5*UDYPOcxDI>qsiޓ dg#?5SV^nz/[o+}敠ZZynYeڲ|v'Ӧ+_T)([|Ji+M/xoҼ0BoLa-@-:_cXTVVON#)Z)O= 7~%O&6Ʊɑa2s_9קSQ?º1qQnN½֖j+m^U,NNqӏ]|.ejJ_ Y?g_,=Zb,ʫ~Q $v~mijKTeF;H쪱*Z6=sϯ_T.v]EF"?o^¢RM߾yE9S,ĒcvUbr<8ҳ%kZ IA{h3) |sГK^oҎ"uw 6fyc=?*_ca_~M ^$޿{9SȢC8ӵoqYp|"|=+ۢ:R98CE[ |дk.6zsԒ#ٿiyYmfUR KvʵMJ1FuImߩ]{$ JZ5V%Ͻ'%%nb#߷RS@,@ D42]FJhLsERd?:wOj~{붽={h(phm{yn8RG':ueԚڵ7䌗'#S]%&"~6Fv+p >4i=5M)QqC =UČcIڵRZnO gI&a=&=qS[mF z;ˏqydrCɬ*ab]HEՂppz4}Lhƍ:N"g`+WgݶT'1 K#]ܳr:犮XʹuO4d8U>ǃ<+фeԭ)FSK}6ڒC#I# mb埻FqѩM_LdLJ o⓪hkdFI]yb!'}*jJ:?c9^.^Lۻi$ݵ{]8[iF!^;&cny#e@*}I;FMr΍-{iFF_5Z9U洿DVkH%e!`1'GөOjO-ܚү̜A+Ǿ9cQzSltp){ϠfV(z'; SF1ddv>QE*zr{ƣ].ZehU[ڸYOwSm$tce6#?*bմDficܫNqJd:֒o1V7 ˀ?/γ:8rҰq'tXq{=+ZR2Mٴ]I!Y ]ۨ4MέUZIs2K9hx苄oG5pIBŝnnG=9⳩8uT):eF==?c)8ؘӔ"e?jUsC]4[RzjW=TjMGDMQѪd`8MOc;UAVW^qkNIF3"JЁD&Zu+LYzkz0~[M-)v_-rQ89 N\9IHvJ}k>%:SPM.[\G";b=8SZ3'VNwEwܲod ⺩MJ:NhIUdv͟Ҧrb%Z+A^$0Jq"GYO}(WIuPO'Ni+4'{sdIlw7P1֢>gF8xvK,[._mrg$Q֯vݻ2QIjԦSTP&ۘLrEÓΫJQK[,}n[d{1=q*%g$s5B1u{O|/ hZM&H8=эX[giJP.ﳎB |:m=1@&oNTVI[[OfXGZTj{HL"8ra.g(gNqS]ޞ{VpFI70OOMc F3w-M4)%Q)=gەpbt]#R*%9BRsנFbomh aS]/F2OħPd_ܳ(Q?(U\bX0muMk^}-6f*p.#=p?UzI/4VQvꭰ*Mm,ff:WEӔj-^;Ds~ˈr ǧ歧ۙKԡCs2J4W:gF4M81)YՕO͒{~}}i*/#OrQY[O~J[#mUwcq'# SM);sʝ|U>{ #_=>8)XKۆ < cv3ԞP捖u{[[ 1mRNxMa/}V sd7F#%Rqr[taS-D@mʈr]WiV6=Uv[P١0ivr{ZpRSgS Dzj꼼ff͒BٸjTV̹ZdC6n0XdcֹBZϒ5/.^2;ۺa1uv)ls*k{LaJP8V改V95J:3§};v#Qs8poI\o7V}:\;@NIJ;XE~ʞRc=&:aВ IBU9kTR Oޯx󓁌Wbgl*}bbo*x/$3  ڮtfu)8צáI"śjcAc$\#HqԟFҫ1ޯ*lBplKug+܋-7LO9whb^*S|򼖾R*iAƢwW1[5-klgAw֭ʢM>YrK(>576&IN?De+Gwӡرbҿnrڥkѯ 8ժWe>i^.Lĉ$6uׯJ٭㸪GI% vիNZ/T;-tۣ+\y+.YXUAжO>8VE'km~dg$s9jVOgdoZ+'okVKc_F3O#9_aFQWe 'os*pG$}s%-S8Ӕc{&E};CvmP 9y<=SPMJiSwhu՞'x/EBdbWg=AYөZqoNyb+T(&حuH!E|0sTݚ1ѓՍ83&ާZ)r-W%R5 3H~rG׷:t4y+Qn"s2w`}? ʌ*t)՗=E,7?zsWhݜ*~)E)˗kU 3_Y4OxcbW`ֹeeV\԰߽ˮ>w0U_Xԩ)I-R c7ʸL=zFUc-$ox\Ze*.zs֢Q?vJqU@>Li~LzepOֳ,2TSVZ-&}QvrzW<8pTQ狿beV1.2'SgFol2auąvt*e O=\>j>i;YuؗBb*1^Owsj8>2~N{hĩwst=e+TƧ+id*{kN[$'Jo7K};!UZU%kE;-?η7 BCNXԊmkؙac)^KVU9c1~#J!ƵOԴM+.򝾾ڹhw kRV%O2ºE9zQQ"yU:w8߉odnq8nu.Tf8_cҩ$lxKE@"/ÑU_[R2P_1{JxT6N+R%:Ge|\#c*ZKM;KZT_àNTA,+dZ^ e=1qΞ*|n:η c;H7C2qS\}:Z[>}z~8u :\9,"'= 3唹emT;CrNrK|f6z|IKW1eou܁la=yӮ>(˛[rm+ZL_*PaF>kyR:q7r0+/L|m_3}< 1k9rEK[߈g#;3n'$cC\s$_cTy߽Mc,UnvNGF8a2d<.3v1:5>#tbچV6TMg#o=;Y<<^ ܪm-mQ\4;}TpT8'&yKecI(j[qhBesq='O7׷F.ZRl֖9;tHhȣoڸR#df \T^jX캔o%&͵BrozyU=Fuןp*`2޴:u}{tjT%Nĉ 1O>bbrTIVqXUSFLchIRhE q$6_$d'?G]MЩJ-;o ^l h?n9<8TM%{IN7?otG$qM+6ISztiQQJsTޝ Zt|UҮ{5n6u')I[FIE#Iˏ@9ǥuƕM.6MUOZ_BO. ɝș 81AE8SoE{1J4U_ ?$a$mRB=[ס }iEFmK&HHsj*QW}]T$0r'%dm|H|I8.ng7dnpyތe^;[rHm.i-D2*\}z>˷OSRidEdl_ݑ0?:t֪s"iV;YV>`zYU9#qmlkiEd*[xۑ^# hu{\r؊h8j&Tn~RI#Hz֥G-U8t#I|e[ܮkO''?ZҚlT `?|pp h_T)JГ$gc ###r롬ee=C>ftdyss[EԕsYdGcfOz%ܥRERdnÜ<^j2䍻٫G[dq,jcxnc}G9SVܸOIgb+o[!'>&?)'s/f Kѵ,FШWhx=x=+Y&4ҩ˪$,ՕQ|/j®y{ޔu8ԩOW+$aHw|8#ϯU7F7w/vD2*͍VEVfRHg ^կJVNK6[\m)wڄ.3ԣ'+ǙGIt̜ۨ׶Eco}hTheY"37?ȭ#.+pe<&e,TwԊŐ~:ҪvU8a8#tNVK&,_|F*OOg*R.cDQFOT\3Eedž9\t_JWI;$Cr]KF&8f2<JiVNK}}<جu(/r`n$\`\5Q(6*XyMu}BH6+g sYԏ5M^H{W-4!I% y}9kOV]gRSkK!+xo!lq*dG|}eME)-lgNL -VU]_* W%nۯ1x !df[0 x{5"=N_j-jEk-߼-9/ԓ}ϪF|-!{863(QWpwԭN^R?{3Zx֣'꺦7u68^r:u{ZteZUY "B_9)rzi%%1khYv強60oƺʟ3OczRS}$P rZ/̹\MG 5Mwf+H ovRu :}%y-vNGF\:W7溒nT知tA}FwQoGyճ9<}kIGKֿaQBRME[͖3ѷFpW$c'ZQ3\>gEl/RI;fF=dRqppn=lL6Kwӱ4;F%?1ێշ^ѭ.>UUIx׿N()sXtvm;QYUHۃN=qT5x.XԒ%գ<:~Q旼Fq匚cdk`vkIRYoPpW#ycsq{=SҝJN[*lMKr=^)I7(G٭Ht1FFf>i|]Ή4.ĆfºmrTƏg莀۸]S^WR4Ysjo1vFz{Uiʜ.ߴuLPV##*;t9=zQZyF.h]GZC-?w=i(J`޹/}[os֥(;Ў4X|.pzz~u׬g6#)A_ֹ/Wp_NG~h/gܮYVc+Ov+f5IK s2}r;W{R+-@E]^iMKTiꈞ)<3K:zu+OwRHQ\_ݰS#n, eVSzF+޷6jKf@>V.2&ȤPmQ[vqqvNi˪zr ZF; 00N~ͦЕ)G;_~ j_U#w8mN N;Fwn?NO1u] JMؗ"U-վ1?犗NnYɨI312&WѶcd8ogܩa+N^&.qTu$rN?Z) Wi86#e6/vqOF?=ֲ_̈MOW^H%k%~#W=VU洕|d gҴTFI؊;[hHc*6'^r)IZߠɯlh(7.ʕϯTa=[3RmfЎdit@v0ܭv}v9$>ڧ<{[5HdY#9;x>qJҗ֪{߀WXEU_ag-\qkqMgX̥7C֦+Ɣ)JmЯrHi3'\uzVew,b%ekI)LeٙWg\cyjGNydyZ=W{V7Gm\{tjxlR2\wwA,*۴ !3F'31]9ɻkަn܂T@F 7+ɴc9GBÔ^KT*VN+hlTpWqߵXϵ̳3{E(6F5:j@yq학ؖHRNprqޔeOí:,7!TEfiXnN$p4NO~zNTuz~,[(F>\*/Y2nKJ{eڲ0Of/ZwoOz"{uSȤa*Eѧ%B͎s?IH$2x tnOaJUX͉$vծvd3ۭe7ˢ_\~~5hFm\vJRqIydFZI .2zc9YoRnWՎ,1m.8c^J4uLmmnYeW'sYʴЅl 8fec2=*d}2NV& [I"a=c)T彋y)JQ[|Yủf Xpv zyIhpQ]cS*7IJ یϭg)u2ܪ;[alK c\Ǩ c*{lsOQ{r/̻~~$B~,:w-n,R/7y(*5(#fv˵xOƢ\ry ;6絏rH9>=:敔Җ-GR5,BFĞW7_+hG׬QF2mbKwa6Ed7lֱ%(2*&Q"&W721HB,s,OpƸwۜ<Le)N%x.fF01Rz={= i^mU훬=1S$a]Z&DWC}и ?\HMN\m4)O^C/5[r@CK8ֱ9WSCݘ/#9XK)- ~!ܱ@n8c*|ghQK ::l8hΌZJ܆NB)f\ǀ[h1gR^OE›f?P3񪔹zrƴW [6+F۶;9 r-[q TӆւU/$Y68Nu[V˱V-n#ưUQu]|qy/AZQG8GNQ,D)i in7&5%0㧿F8qZR܁`=a 6@9{[^l)jQ>kda•Uqԓ<!*{~'gӪmt1"?@猟§4V}~B:chrj ᓎ'ҳ4ʽS.<؉<5Egd?;h f?kB 񁎙?<֕%NK\mw;57m6na[ve_.CHa\Òsy5r|ю{moӦh G{Thr'f0ZR{ynsV:*U"daa4y!<8Pzg'ҬaNK34e6kb9Vu9e^(\&INOY//ϲ;=8KW]zs˹CH %LҺ{Vw]O-SkqOΉ6768=I?a)ECVPU1pOOmYHPǹ8$s8=qV%Snf*RT!mC%1pڎR? p=#x/TGe˩jTpwWnaFCFц+$TרA[{'klcZRR)j޵&t.aBfG`GJN2}N\Vj`'Vv:s^:_?29q:ϥr#B0|ӶQ-2G3+T0Ix8VW;ū]=QR7rf{>YݟÒyݻ35~4 -n$-^}nc&#X(1ע2lg:r]]6@.1x$⺨rS"᢮V&:7"|B'9㓁UrKqRI_wcLED-wIyJiFڛDl-C- q۞{_W^h׿9%:<8IdfxC>q'u!5=]^}ɒ&.ؕ۱$V#㊪tߴnNF05{A%Zk` *PH$`񎸡յ9a FPM7LqHxUUPd29E?gN불6\џ72&n*ub aǥEIӧ ҍNz;i㢒{E=HUۓqErR*uv߱aqITN}wZBO0drx溽Z緯UwqtfCepzn=};Vqu'E8+_ /s ޸3Y¤y\'(nt[װkՄuj֍:rqm'}[8U$uSB^r1Ͻu}WuWE4V ڦZ}Y XX,2g9^rzR+VhӢ Wnv*yv3r;K| u>kt^ XbVL3',ں(ӓ債164FW'c҈^f)B Mڻs޺Rw1Q,ifB[dFVq'ˆgP8ڶ7ZrP":hZv'Hfcg'i2c95n2:MUSTш\4;7M&lr$8٫xzpۆH /͆{f.^T㣗+*Ȓ!`hݍܽT>4y+wձ3ޱJ!;tOuYʽXϯZ.Ww6|_.n 7c=PtrL?qڧ#:ӟ,dc "IUI6i#\[U#⮘T]U #eSYQ o 7SHF~g\ ˖VJ_+7Wk}YTIV#^df* S zW=(Gˉ#ݓ6Pǒ3޵0frJ32uqf_˼7:cczڼU"O: q5?M5s$hb#o\ӿ*߸SR՚![*#a>ٯ2Pk=] ȑUYz_5C.j2,ҮCDvFdָ+C/R0EcyJ'ӎGp{+>kR>V_}t ~by{*򝁲 wvi[{Jr)E2Y;r7=~Qn1S58?[\,Rp8^tRuv^3^OSM4pu.͟3Fz?AjZ2M%E͈mC7IguLws9kO烰ؗh$X-.wmny6TK[^KFKnt}sJVШQXmrc=ZN܏IW(.m 'uKyqZ#dn$;}1ָqU,¤ԣe4,*ܫ`HƴtRf3#++;2kCW'73T+L@llN?ɨKoɵf1 1ŽltR)IGoEׯénh'2-ehyyŘ?JҜybՙZ$׎)$psƳ27](kn>3θӧ8{.}fx~y]S#'E-7n] ݉#*#>dߌV/COenG]ў7MWQ&k(GkwK Ԍm '1xSɽJ9rVb:h9e,:oΜr9}mJSyls撍'(_}(GwqN[FPRqjЎkGCW5ݤbS{Zβ˹YnҌ=$L۟Ybv֐iF5-&20wj:N eXUTm0F<'ROHKigW(e}&p+v=.)F;^df $/ lX7OQUxT!F.kwndz ==+)riãH ;Jր>Be"9kƸ^qw\QkNH+ =z+e&q]_$\-8;aRUPNiI=.G 7*X)Ryʧ$C> *q@>IidG44KhH 㷥rΌs4ԧ9DP-~lm# q yrRMȉԧ֖!J6U1'=9^v"5DԪ2}rfA)^iUKOL#~Ϸ׋Yk YwiF|ԍ|3DU{OKBJ5)tC,qGQЎ;px5^Zws4M5܆buU]cB7ɃjΥ?gWݕV{ -x٭[5Y~m{'ïz2jMфeiva.{IgώsJJDlZ>l\+JU[q?U#*۷ִ_]HSIb]VC$:Oʻ#rYhƦaw>Xzyͽ[C{9izF1r^˯}BIټaE^֔׶:*4ڱ?cLF1lL|ryֶQjpʧqZ0W٭Ȫǧ͞D̥Gm%n=5!#i8aLѭjZۨǕ9 LG9e'"I˖ߪDkzg'/inZ_뱷^0]34QL5Է㟡]u#)k}:z*4plXeIpȧm#Y˓{[lE~{A]yoв*?ņ*>Rh>y^YhS*W089RKUR5,Bg\Y1ⲕ?c&ַ*K ۮ1ՄTm#{G-/f71唩sy>ٕ$nK4GܞTN-VZcIߌۚTSKG[ЍGoFGj.wnF6;淕e%g[?f9؆VG+oNAJu\>&I]=rˌ7%HҦt\_ݩR*q{|rnP[ +6B#ZGu}7 tmm_%ϔvve~R?wx#W4*r%//ӹޫSPOWmk_6FhQ岌ޮU┣nnc)%*qz*zzsN7N؛D #|Ռtʼr2=\W]ҟE(ҌImuw3ź6\8U?:)Vi./̫$kӌrGS:&ےb$hYd¤~gNG8ׁa#YHQҽf#~en܂8>2=7Z<vcob {Nc/u5ĆvXUc#3sFT=Ҥ%.˯#b $<0֑OvM]C|)Ijmѷ6]лjc&ӧ*fA435d& 끐}3MNjTT$dN,JoaΥ(wX8,3$lm O9:E+gYFΜS.hÕG i°yV= 5Zi<,H󃱤vy96H=3Ozr/;KwR˶$rL>xǵ{y#TE^DB+ =%. 5lI ZG)?OXw.y#l/ʛ̷ g_xvY&nk֗wX=,yoUfOO˜H )G_12S<_ך=f3:h=JǕ:n {Tq^9=?`nE3coue|7"8˧qqsئo?4<SR^2ƲQ~S:ҭayboK|яչTCNHm-&[R4@78R[ rs_9N9Trr׵_/f굺8Z׈QҚ!.[[5ׅQ%t[ncї)iM$q$q7xGV5\o'ry_^"ľ+6U%aX|Bv3<XZ)95h6>o[)>o+\\w-cQ/z;2aeVR\M7e%ʥZmm6-e "d|^ ir5ewDylSNi?]3xcž,ԭ. _nbfRTzI~nTjb0n'Z7mW_v Hl( 7'h#j叴3('3!| F%HrF8a;s>['eഺۮ:3ӕE.^[I]-5N¾$hlWCx <.z:0:eR^Zi[_[tTw[WGěOQ 2G*,nSZj~%][gwESV㬖emW]w[;gָ'䷛#vҧqӸWV1U$Htg啸_{=E>8xk uH|69sܗ춥|&.Al K 3_f}O"T%f{'N_z$E)(`@ 瑟ס+Ҿ#¸KWNާ|])~'|C\n7ug}*e9'}RQonwr8^r? 顇_4*׳;"+gAOkY7oTڿ_134k9 㑴~5JdQ)8ԋЅd7QQl[qo9'=:uR~΢i:tߘjI!?yJ5#JNm/"FQ}%ne1"s)S6ZF_WêzmB0u/F=^s=دN4U-oЖ[kYc-$aQv78Ǿ>21jk]R_7b!q,n#+$WU=}8&Ԕ1WWV&C$[m8׿JU%N阮8mh>`0z~tz^jiɮĖB ~=s+idt`{D}mt:{U5M$w:WE V6Nf)_Ў#s 1k[DK]4n8V|޺0Ν!ƱLf<=ϠNh:o%MJ#jI' q5NRR{1Y8~KXbҌ EFSy۟smԺ] yGI?t,*U^<}+ ɻ?oDuQX)(۽O9{t狒m9F$rV*۱N3[.i]YөN\m&KD#jU 90թ SKs(kc1f)EJ[+\c/8 ϮGU9^sL#*TwEgY3YzX0֦1Evm'ڶ]ZR!;FWsVt=rtVBGⶔ^ZhǞ9{iee9\r3U*te3ПB7M  X\P9/]=+ܟftO>m8JLneqmgoӭe<Զ9cR]ia_(v3V|%˹$w+n~a@}QS__)w=OmwL\ МgJUly8teVWP3ީF|:-ӲwBa>Yyp#}=6=5Я}J4l|-ǟUҩtFQjX{u;,bn!eCqӸ*TjJsƬjɸz!Gz˵* 0={+WR^1qFR܋;Xvu `Thoum*UWVmg q۟~3Zr[:hьd%y/\*2ȭ|qڷQ+OZkkVېYWnO_a릩jq[ڼJ 3unU qlQje}^G&VvJK7V TeV2ԣi6UCIE';0uֺ9ch'F4EEK\lV.A8UJu6NTׯGgoʬxnUs\Zȕy&ߪ"'UvTm~}(^}¢2If{@m'v aOu-leJW3E 65Gl33ZF^ѴmEƧGq$h6w51a+}i}5FtKlY[YPO0~;:Ttelgr>G ;۬2L?JJ2KQz:FH2nmz:pVZK |zgjYZ::]\4z3>'Ӛ4՗\PM7Ԫavkc9RN^>yRy:96s*ǞqQkvyc=N?Zi.˅?iWȢ Hʿ/M?g*둊\%Eo"E[&#&z+:Jy8ԗ-_rYW0ܹN޴兛1(8k4HRdN \3XM=ΊGڟVDh92b Ys] v^wc9eu(wʜ-(ZŬϗz`8y9K-^&)T\69-pwrϭo.8㟴I4%Qŷ2݃qҳQTʴ&{DdMCqS{F[BIVY7HNqt)*ןvJݾUhvm5:m6cNӓߧ[-b$g+ 1Rs|Vz"9i̯n »ڶQjIB)GvKKq\v}~+BM=h<.ZgR猃+ySu9Q}Ŷ{X5ϗ\1G%Q~M:tjJ򝄙Dna6ˌk:RT|6}oMٖ{mU^?y*6Q&ir:j3?{s{9F|6Qvc:1{c;p *g5- k@v0Urv9=k*J^[n:yB~ؼQ Oݱ TkeRէޥ}Fm}#<”\:smvI:ыѓƤyؒpa $>b# 2r{sQ5NJܐvAWVA8, sVQGM?WEy.wKv1Ѹ~ۏ9[FӪ qw-,f3w׮1Ҕ}8o3KdAs36voSW5NiJs)T\Ah,*eszVR+I&diyK (md{ʜ)Ə );yܯ~5)JwuR5EKi&Ԓ_|y>Yש,=;'dGN5'D=:E1I`wL)Xz՜e ht)^v,[ "\C$ŶEv眶zw{C/(XmQ %5!FH18;\MSw]ki۹~T %Yzf<U*9MDyY[m[ŷ U*Vܮ-o fWa|+-jEL֍E-ߡ"[4jL;yU ~ϭs<t'*t"ؓ#2,r*sep=:=ڒɈN\:dⷓsZf%i60:e;>QOKuJ5ymЅbX,@mxYAdwzҩNm+鯫cOMӜk}ZW~l FvׂH=x^ݫURU%3^^y=s<\e8*MT%#cN8\,^K"=Nkֺ7O$kYlpkl,/VoF"9F&t;VkfTiFA+Kߥ.T9o._2'%nFeO[;'nt{G8dt*r ǎre+&8b)ܔ& qINK]WSU#V*ْ[x`c'ߠN1?/y=T;o'I>s'~ʷU#YQJ>Zrca@]^[2ScfN{yr#mܛϦxt2V+B-8īoȣ3L76x sjJJuJjބOj2xAe2v㞵NQi{k֍ܒKo?2 FŘ&Bp}Ju%͵nbd7h[*psέTb禺 +5)ʥFʩO&l,F[=ʼێ`J9(6=ur̯;2.wڮ>ҤTu*Ke{2O HUGdeh)-u͈;d;ẄHW<(?1V^QӸ|2:UKkUٹ+pI?NQFe.wDR^5_m #h哋w4 w?Ҭy$o1jA##zDpzp;W?~]ٝ7FqnFK$e$A#=y=:ynm{G"k¤gtO8R? ވg_і!9ga^cm^5+>y}mc]0d^-J >k}sV[m*eۻx3ވۚU% ҲCkeh$k͐Jq"(8XNRHiZDaUGv k HɌ|sF[[QqFQNkjE)yq.7c b_בUb2c}9Z4 >RMJ\aN-rHdfՔHA̡-5˰XQ=y~GY+BNe|D ЁӥcN\j-ߪfsҖ"1Oy1E{$+#n'U'7wuu9:~$r4܋l#gO3ǎ+o^N)>nVPdXVB1d{oSHJOjͯna{i5YYI= W<+TGMJ:k[%lL6#Ffp gvv=yyHъ]YżR6m])<;СZ\"muӱ5$O1E'd5H_npQ*ReQS%dͰMǷZ0t׵'wSOwl,xv^UBhNBo:D`슻R1ګ'.LVce-U]"w}u?Vvo#9SD$O/O..rKus#ۚqXLV*Km1m$dÍǯ\>ե Fˮt *0lO=ɭocnjvz:œozOκaR*ѭȱll*>_Jڤ9vQ*+[Sos&&$hTT_iN5w6KǓo߼Q9#'1NQ{\l!MT tiwo݇ $\gG eVӿRh7qXu/E 9s76cwHjB^TSZ^%(F6L*%yڧ/*Ihۚ+KF:e<# ) ?hOgU8OB1:WLdp}k n氏5K=I%(4~se zҪ+m;t^[!H]U~Y#Nܞ{zRJ+sSjPw%^i"M#OɮAJڛ'Gw0VJؑWȸĥ>cl⪧pyeãaV9j,y3kFgCT*Qi6G[sJ.؋r]oQfhlnϷ|{M6hZ#0sȰ=iJI4u"l$_7kn9zd#*kVoF<-FVm˻iFQҴЩS-<2?ޫkXh[3˖mZ#O=;6RiGvۮ$ekVFv}FF̷_G'ˆM˷*r[# 5TmbhUZKmmQ÷9<ƛvztnEwL&r={]8)0e* n OCG{cU.kMR0>uʅo1ڦ\M.5/1TC4el"F\eR,u+4ff?JTUJ1&m n 74FIG8BGr}+%%5Ѧp˽O}z;J[Y Rf3nҧ+4r ,NE4RZJ_%e*Cymf=}oNwmxͻ+;fYOw>^l֮4g5˙k *1>N3px&jӱkȮMʿ3^e/grF[t4%|ÔR_t#H.#I mĒI?g.[n*r'nH͖vcTJ2ocӮ7 LO@<w.]_S5N܈t*䷗9V4\JdS-!Q,,q8B8*I&uث=42Z7Tr+URbzǑ1aZfͻjoP;N6}~qXT?9^N\G -#{Tތ 9=E3DeXzȑ:#ϯcu{;欽$nY[ڬi'8ڱ^V&sƧ,w܄67>|co1^=09'R^Y+?#e1 hlMvsfEN|КJ%>J2< dwW|+:q/)KnueYe]Up㎕yťFP&:;rU ;>*IiFЧuGfpA"p &XcEZQJ5a5Tn{N\֊1ɩ*6L9@pvwn+gs7eK4RoG<8p 88g7L#hT[}a2OR'蝗O%Gx#ڭ˫2sn2ȥ;Ӆb<u905;5b{iY. fYev>}k5~ԊuiѺ̶Z@0eW= ;Bx5%;RP70[F~aHzgyʬu0ʼndՋ~v12O>)_%T"z>q-ģ/`(5+_RrHfV ׎u:kJn1z-,8Xv?$m~՜3nRkSoqq(EHo# v=+:?NsW鿓6cKUw eu*UՉgSk/#|n 7ꑍzr^JwmhNr9'(i.hD4ˤ'~ҋj%9 |9 x.W-jssw%F6LAi6^2ke"#I>P$mVf8ϡaYu9Ǒܖ+V9dmfgEMu]?_}R)蹓k1]Xc7#Q9{tq_:ݼ?ι-oK拣8ۯ S!Vi66p78~$TT|w1"$YfWUc(L+5N7m6oSFW2]5μfI0پU8qzTΧ-;ʌNu}z?/*cRU"SN|HX 7n^F+H1ӷ_ǽqG&4R/}:W0\1Uu{5*J)BN1qfFW334׀?^Èr݌E%#JH>fon>gMIt{/kߡ $ yVvzyaI#+ +.ߚUT}i-܎K/c U[?:ԚP{=nLK٧+6B/#=뚤e$%B칷Y6X?7`15m ]z8-;c>6{uD襱?[FQ0%F)u}wmx>׏9oOA4ߡ#.ڭF=TRZhͪJKs-;uBDCn _BGl? ø/sQ*Oϲʉt[vC68^?Z$Z|uԣ:U}Ğs[ڣysJ$s폯j姅Y麹51XNi6X+B;rH+ORmwsyScڤZoMi[,!ܽO\ykug,.ϓvm[ϺFIseU|S>Rzc(E6eԩ*Uϣ^]Yh;i$-X$x?ʱ操zхy7[_DXdoݷ?\0O~uiѻ;vQ˛V$`d I̽:7?zJO^*jK A~7Oj dt=={֒x|FrE^JZ$Ik{31TURHuyhcx͔YIܣ9==4o^触黿d4iG3YVgcne5q Z$A/) M67G [jNP^ʴ(鶎oacPZ6ڮXe=kOw;}bW UXo0prX5y%ӭ;0y1 .>m حʃaDiϕ;ioԪJZjLUd$pG$$,z3?u276*佬^ ϳKk4fݢrFs:°Rqܬ.*eȿ= ^Y$XїE۴؎sQMƝw]ڜ~ەh;I$zx5+F5\S̹(G~R[Z2$"5NT=S2׼7d2pYVLH6zcx/gMWXӭ'x[MYC O#wOJ:]8ѣM8Cs֭2F3&=ETyZ,DhN߯jmW-wF;=嚕#+/,ǖ2r 5zVr&bוܑC{1Zsn1&#eI&Rs.קZRѕ9BSiH1N$g˚McJi;kt޿"kiȷ*~0L|sgNI#Tl?)FaqOzu`*1Kgؿ,v.@Up0x9ƶs>DuJ4eYIs qw.֖IJ[s6zGWoC8zM,KicLIʎF ]_uC:RBe_h;Z23G: ͻzG4ik$enUj81Wd.L.jN>qg2n7ӟD+#*Kr&뷑`,fo6"%YdN@>BR7R4YuAؤϴ+e+Y(U+9MeFÌ]Нw{VW5.ѽRVۧ,?\3R-M(Z1aخvo9~JtS'9%aqg| WM*p 1UFKF[s+ǯ5:qe$zOon.i)1 Üsh:kkN2enV=<4jp U%qmЌ‰o'T:]4]KWІ O?jmo*{J1&-Hxb2j_"qz-3ot15S4fozXXћ˼m&mRe WW/lY'c֪[J^5/ϼ1Y^}xҢQ劶cy#x٦E%D۹xk>ZuFonn5H#ba\hܚs52^:}kFnթ.vd~pIc1YHJ732sz}é~+qȜdI3g$㓞F=mRd6򿼹H F}j"nQƣ;E|_Ić ߦ2~V*t/!C-mg2 MNma,E:Toe܄(/a WqazQN\r .\r߱ ,11dy?JZohQΝŊdMʭh kS*2Vy<()OZ+pg ,  Kd Q(_^mM1 >ϗR1ii ry||I^ (FZMttI;HZ2r?ZqNf6B%m!cq;qOo7u! Ue>ܣjsԔ՟Z[LF]*tWZ ZNJ-y>&2079w5϶RN AQСy q撶R_W}WagYw?)FFvyU= bg8տ2ע'Y,kn2G$?S\դӵR΢ @ Ur}OjT'Ua?.uoMaXP<+SVn?pzWӽv̙Z->*|NR+gyŷxocK7r%WGq/^a,j߹;ƲSB\CpNwrm:Ջ߅RJ+HԔՒ޾z`y0w'z+G唪T.WXyS疦vn3:!"0 Oz 87cf1ZTG_=>ih޳M$HC'Hlߚޜh\/RatoЩ$s3V###8cF2N#ѫӅ?7wAoqdt<2oe85czX+8Y5o,۽Dn,;°pF;83ajKZxFVw}m,u丙c3*~PZ4ʚW`:|'khYIyԬA!G=ҹjJ1b%zuu:-MC2D,D.a?Z:֝g;Io/h:zY,zd#sbxʿk:ԭk|AӤ'͍@c ϕiT)5_xY]ΆO IFv05:DxЯfBw>ۊ£}1 Cַ c~Z!{_Cū5*n[uy ڍ BGcEf:1|+ǝ.iyWc >ʧbiZeIX-m0QgWS8e:pM!!5N"S\y*sve+tb#x;+Nrz=ߊIN g; Q'|cQ\+E9ŧ˵hg0iݲ3[}Foꎊ 379k}HQg*Xt#JÄE.>婄%} VnXU8RO;TʤcgGm,btpTQ^98IƋ VV3F浘m,D(]ث&-;}kOl[VͺMZӕNt⮮V$#QE23,>]7̉5̻B꩒?(Ӿ:V\։IǗ_| )V$m`\g=~a*>M!l2~zJPN3?ᶾys\¹楳J\MjK\c2RrsϭW74u+-{[9ifHN9<W4t&|mRhmy1 `27Qx&PpC\z֑&*t;6Ŏ6I{3]W:~N飒B۷O- hS9=cbe2JWvJ,q+x 儦$RrNYG^觪} J5o̟Vsj[f+GOݳG=Zn2-?\hBTʑ6R:hG4p edYebG\)&j,]nFNxIF[~d)Ƴ6ߘf_ʰM숍%lrtm[<_5NjSQ\HV_le^x)sl*Tk%\|"q~,<7F5(]n6+nJ@ ds{W=Z|4?kѢ([i8;]Uf@5Rgw9?gVztv",Y{TB*R_xJ[v=+Qd戍8C~92ᕖ>YGˌ gʍ^JɊu0*/q\?B~n9+݁(,sEz\mQ=}P׺)SdDEgi7k6Xx6XjߍeSM4f Z5VymߑÌ}鿑 dyRzZ@dQfP1\ rzw}2(0fQ_=_NJ4Z;oFR>HŶ]%rٌIl93Iظg/RWI&3K?_A힧o{s*Sz_GHHw/$cby9:C<#2Y|yVن8 "##RIs7# 9&'j-ٌR2ʮFI 9W=PFnpv (6 N;/z[[-I#ib-FOQ~U|Թ쭾ڝ0x\czA+48fS_RNI^38֕ZwWmMgK2Vidݎg3Z{>uBi-~9+ ~Լ?,u^FA Vٹ۞GA7w+hӌW}Ej2U:}E2_1wFpHi̔muy%qW%xClUG\XF.N-lK>ؼmaVrFpj8|<R*;hV@'˜ ~WD_-4DRnݍC*BVI6ţ-Ws?F:saRJ5ߡ5xIO%G?wGzҝNQ[꿮uRrjђ٢KJ򴋀gLs\u:FD`ݘ3%מI5<Ά6[ l?uMY/чZ~,j^lfU[s|d֝Di ^ZJ -mL[q,I[Z\͹;4%<I% vA=rryגͶ/i[ރsOz\̹*{ZqR [*mU̸{*R}Jʟ=R9m#+o^׭8J+}_MZ[} Uw z+Wu`ʽ=oWtx y]W4.xΕNT*/d+7Gb'$c'tR{w9jT leXVI'Ltϊ1ٖFSdU/+/O NTa /p\8\ezsOiݮGh$VU_aq~I{)$SjjtbWhPfec97U=7cd"G\ v$ߞ٥Z<һlr}HH%Y>WEfPnj>V:4ԝb=HN=w'2`qf_/|w)W)K_>GO4ig%v[diG^UZfԑ*JGB1dnv*{pyogir-?፥'wo YCq"#&ar78%@qntYhgF{ _FiM1jѪxxK6䆉 "Er吞[󊚕+Uhy薖,8u ~e88JnFW5xTQO~cae[|޾a$1ǧzpz3.Zn6-frq\Rq8֣R0՝Ypf>޶Z$%rT[o2w4)&Ubc>8_gcSJ+s٪w>K׃Z^i6Fv*Gz ZX|7+ؽ4f[&[+83q_X5k<,h}!e\,e;,V24k/g㫎ZS{j7Z$,~]vȍ \sҶ"Z'wϩ,E,->u鿟bCh[^E{2S(WEt>Z9㭼mc%w10Y^W 't}VTd6eϯoRthyA_ AD/ZkWo,'Ȑjhk)5ؼFi=}?Vt7'YbЉ <{QTe8K_^B89F+][N5<<kLL>\99# ~X>i8R~mh^FzO~ xJN6k4*Lr>G_޼F +FNQRgw[WsGcwtU,p2muOĐ}rYxmaa:`ҩ[~%z}:-u&ϞE`8~b@A\t*sևJ࣢x8쮼 |"a0|KQjwNyzLU*rn^H|=*ѯռ W\xo.Bo82q*{#89ZpJw2V\ q;^g|yFmuM[{k׋ߪN*Կ|y],0aT䜾pF 8~5I>nm:uzʌy_3I4%v<qǡҏ4ֽ]G(gOTw*w_x˦Idi#h2{G޷:p1ѧ#մWmrN~s7.#=zy$D$ !׷8_M%άIfAu%*1[ۆv^j!/ݷ9?QZI_УtHCTƣRWTK+U{6FJr3w^tRdͣ)T|m 12AP0ivTu=?QV}BtsG 8‚F^[m$Ru4Fm6I Q gW3玽ʛarnT\#ڦ$)JTtm{sJiF2_^4SC&"la?zV繷JóТvt|{zsRI$͟4ye@O=*yfJB.n^8=ZϚ8_4}[]K15W(d1ݫbj)S絝>bv~i9K%:j)GH 0Wn~R_Sk{Ϧ猱sԓMm|yX( oifWʷ2.eEm?NRr]4Z/^Icgٜ۽kJPn,#ګNMo˩UǝhNx[WYh2p22@ǡ=OyE$sT_bbaE60gӚr.h04[HW*A Vq[N+NڕRqe4t2cfVT3I;A03AQ*QQͶk}WkIt.~SkӦWqԧRDm56ē5ԩn:w=qSF1qz\q&k +(i=z9<ҳ:z?#hLQ%NO0-'.I$I=+sG6ӧ$f Y4wyē9OirJ\Ch##>*OVxvrO[Ў(!Sp[Q}?9]gFoqJrWoةG Wv8jʥNoi;jJ_-n$?$@@穬jW4W9piӋWSwe;+JQ|5+aKnrKd47U#Q\u*QfǗF5*b+7.#ݽIQZ)FV:2w]r8T|>a-GVFoΞ|3ȪȖF>\;<)N: qzz﵉ecqNܵ4QnϪ;2KFw-/`O묣}%85%9 ѱ,P6kZfuj(;$96o :wn5#RI(2+S6^?_ЖCu2r2ǵWrs펵Wob*VVOpQx5R{Kp:f-Rčq8Zr5kb6yAmoǒb5 0CHSO_О+t.vo 9=gM=~2v؛OW\_Htq徤=\UdrF/Мc=TaGٷt+GrI m\/͒n{q涺KJоIrBU'$=)gRQr|M׺! id o66@g~+o~&bMڣ&%oQjT-*MH%UvݜkVN׫z_^˽ 񪤝>ZzwUSRDZ "ڳ4-ʬ8#)ë׹R.k[xčdxT'ЎM>zƊ~*=[h-줚]IO8qJ9TIz[V_W&coudUlv^sDZ5="=2o,̬Hs{b9b֝>iYY@yHjҀ،JPT)ƌo}F䵖4#`"i.:Teʏ"$yEUVqc=Gk7Tw)T"#eaE=G\$4b.0%y;RZ&c;scUT1/P^c4Gdb,"I$Y+vI 3:˒SOgRg3h^_o!8=tRwQvB֑qRO-wsvÑN8)/[t9]'Y-e]'}np?FQѥ*teGN{fgQ~nVqq3i׭i7Mʃʗ V;g)ȎUUVjۍq抻hʃ ܯd@d{iw=T\5QvTQf諾 W<Ӵ]ل*roc, V%S[ *)ӄ',<+xr}Hʌ$tȬ#)n(Ƴq5Cehw A\qGYY%Sl;kY[+0pqۦqygZJMGn|n %v}8Ҕ2b--Ii!v汕G-șэxRwh+6\Zw So-oD"m^=9#)\[n:JU#cj3RoT6majXJS}?ˣkI4o"6ضqj"ڜiɕ.fY&"0[D{uJF_usZF4BK|bo~V9]c)bc[u[{단ILp1vW<ʍ'sT&ן %q#ٶV5Ezn"-4o8T0y$\z`O~2_i6Xvry)X X׀r3k98ѧQ\>'ӯ4q۳ƫBapzϧ&)mOvϟF3JɭoS՗̎N}}3x[+M6ʚw-}:?2RcOy(Rœrx~C Nܵ<ڟXu=>wdlF8p2:gjS兒t1{kS~U˚z#\-G254RrvP;7GOڸrmN9$ +sߎkJjt-Zf\ZɧIa8hdܩ<$jR;1rX[r6v>֯*0.v4TKwKo嬫̿{r'ⴧ%FNӝ5˻۩&R9a ~_qsǥiN.u岶/"Dxp}y+66*u)%ۡj \ħj,2Gܶ߹QWii~wܞx9: 1w9\Ͷ|s #[:Gz K;FWMo$;@Oz#JN*qiiwD,jVPN̩Aqi̩U$L"8(z̥ \gvRyƥx#MwhU3˜{KKƌ嗘gwߖ?ßʻrw2Rݗ+ǿb2>(mʛnQ{[o ZF[rFmx|HW2U9!Z8iJ GƓ:DZBңI&05a*1vJy=;;eiH۸s߱a5/%GeN")pbѫ*;.H;B8@:WU>ZilTQW̞vpa;gsE4ҩ*5a+tviZ*[$#i:qwyF9rPh'1q&6r3׌>[*WdUQpBtz~uT% ѩ _W ȥ1=zғoEuU'nQNO\LWrUTrá7~R$vlؠ;A+rkҔljT; (ˉ6=01O+ 2+,$~Q=ռBO;Ա+ͻ~?YIQ+ʡG?ֹT}r嶏PI<~͏u$ccۭg;sY%M)js2KO:޹F1|RFQVGnm#GJT#Jrr\gu.ұܧEڻ_TF2|u%+!,(c H* _ z1cUWߧڹNڷW4e׹Kd[U!Uzu5)lcBVc6ZVN@|w;r±ey+ѣKWѭ慭tʝNkt膪nG՜g EA"{͝YqOҫ|&^ϗwtЖdR1.Ḇ]6J˗u0=鷶S4 2#brA<Ѧ>`6:J|Iu**:XJ7+ UAʜwl yG#h,8?I1S9J:iɧ~qŢϝFp#pp%VQ{t[FJ+\mC өiQrzMWR[XLV,gcӷ4%=RwB>L͵ Ѿ9zsZbiʷKȖ=!YpB)ⴔ̊W\X!fw6✹k"\dx}/[Vb`/v7cۃV_EԖ̚{尕vݒWϽiW%]l=Il ȝW`7ozחZ6'2 rYzֱ^F{LZIc(`[I9oiOZܶ*jFKLrTR~VkX񡢘_Yz)6JrOݳvH'>)Ɯ-_M$eޭ@z*g.0( ėΖO'g!PvTU8sGsZj)]6dZ\:s_zY;zsZ2(Tad%肙Y@f 8UiS۱AZ_b9LedR3|g=>TmQ;(ȀJU?w?y1҅Vrz<>Fחm}Bf%f+=Jy< ιemsy~#{Ԍ]G0?CTTq.eM"|G$T$}:8P3s޺)aIS_7ЍۙcHތ(W5֨Jku$/#1UF<=.jyLd$)J)-ʵdͲnmı#)ڭ=rVG7#7[Mkqv`dh˷Gn~Og)0N?3v]ՖyٟiO2F$*eR6JN֢Mp-D~YbJu88E5&cN]UH|x7FW=7teiS77׸t#ݴiZO;h ^ 8!7EA}~m_SXʜE bAV$JNzL´4e%^z ^KFc/>cg~>Eܞ;ҭ+]E ] ,ccp{t*'+nmOBϡ`)23Z9^]Y)FNRnUD37āF$ⶦ˶[Q*oWW6Snv{f1MRjR?:ZB L#ڬ˃ B9F\sգNdat/n$ah2嶶Q1n֔J:N}[ [S"|TͪuG?Rbĸert#>Oi2dJv6~Y. QP%3r z{5Tm1Zf ʬnc@zuC1ʭ2l|qW,5Mϕt2&7.빤-v==Hz#mJ4`ؙ_cL:wyrYQhF>hcO㑎;?uU>jtmo,p #I#'<~L[z3C[*[E~o'b?U>yn JE׿C缂-Βof@z:|?mm];,J0|ʫ099+3ۘ~Ҟdq#aV crx*?35)KnWRT\ 0~jw7y$G,QD|ma䟗G" M˯un,o|Ҳ:n8'/9 ^Ў['[+ȸǙ3<~U?bx3~cf m_ݮ9?WJugp͓쏔|zVrS_Ў6$գo)NApG^l;I7Ҍ=+]4ǩԏNY$@%!޹V%[Ui[:RTeR:'s䤷娰g-V{$vxn{7b8\P{jq֣RSDLba~>ǭs>ֲLTڋYf^,dޫ9wc+WWaQ Fqo[؎'A 72)T;V5$xRuGNDZ[MxՎРy㋧/v:M>d~k֋QC<{[Ҥ~q: $B<N8sj aJT!ue˗iߍ1.p8'ߧg9rS]|uK[7mPzRRI~]ΏcRQx֓ хYFϸ^eG/iȞ;>ʵ-@ F9Zg;.'YS|ﾺuЍ$7+ sֱS(zRzS^ML[S{Qoz}5.U؈˟0!]0[8:өZ,{7gF 4WɞFeʤ~:^kz򧄌a_',kVINnɮ 8'Vݤ NX9F:~g*ݭz#ʱ==3ֺ#RM&++oК6y..F<2;l5y͕hG2^WGG2y+4UYX:N-i~C|eԲx(`q=3Ҷpb'dk cϛs{jWEK*cNUcy-d,hی zcҮOvɹ(ӧ}<9Y_*+HԕHo#Vz[:%KYcOKI#j|5tQ5m{y_*@[GOYѧS&Sua4wѮ}.&JAdtһ)J-AٯŜ2E֊UMkI\:Mm*5҇÷1ֲË`Imޱe4D)St}F@ڒ˷qp6U;ǹ9JJI&]ty."YVHգ$+dmp9w9ʕ5$TB_զA @8VbUQxq~9(ԤN*}hVuMxD3m=BGX-7W8$AiHvey;x#2WQµʞ!Fad6\wn29Q?hkzZⴐ._2FϻU[} rT~m3j>Ӛ\H.n9Ǯ}qUqʥwxo11ZGVэIr򜕥Ym$eu\90:{ժҔReӡNQiO"[;L *ܐv>ǧZU^McRש$r"† x,pz׭iG\gITZ5C$C8,wB={B`#둣yE^M'fjnXdp:wqmmk%Ms+z o&18;J%*lcFNQ|@Ei" 7przg5}<'.xv΍*s1U`:9涍?gQ>dq^)T^-[,Y;Yv#?ՕMԒtW V&>Aێ[bnQv)Ӕ_+%5(f"hұܣs]T*mG]ƑeWڣq?*<Sk],٬$ ef# qR쥯baJUj9{I5ӏ<(PϚ8uŒc/y۷]̒sLsg#ִKR:}Vӱ"$L#nrÒ:N\80&܆#ODc&ӌc5Ē%wmOGG]÷S%R85#70|̺HpzWD`*zn:8W· 9m# ԋOCvXf|mǙ[8µ=L-um5_jYYcr\nbeZ<ŒhgU3i/8򭺎ljnp98zN+zT(껖ffGfb JQl1FRvؖ)7%)a7`}fC߳ESg2>u_rYF3:"$z#zti"g?PcZ#H-oQLƭf ?Ϋ݄[[T2kČʹGߎ(֝9OM7gYp%ySБ֎gLE2 n)>;ԼRyȊ%HmK/bK69(ˠFuk^Mȍwٷ_wҴRcNYEh6Ğ3''#߱ݳ4cY{9G[\͖8f1zd}y=aO~ҟˢ)I/([v0: ރoVL=H¥qͺG =x]H_D6߼vǟWooƴJ\?cm|ƵaU"(. Fuh^W_6,|9ۊ-wѝ19Gi~>RyJ#=l=hДUݽ?z\F-عۿ1>5{޼ڽգUF-=jXU0w}5կPY+mPWw簮}^I'mu;+YA򷾖VΆ]+?,?})K>VBudw̖%=CQ側N} Ij\]LN"(d;w6JsңZU+5ӧ,.%Tk/m| P&[$J$G?D֯e'wwoNr%d׾x]YLwV<<?é,ݾGU#Pfn tz+7J2q~ah/*M[[}#U˳UB*aR9jIr*~3昶ȷbXܜy?LzW4FNXɿ&zTIF[yGk '8)VRo=||hm?Oy[mex.'C'?ZR/4=_W~7ItqqqpWtH'zu!*jVu}FұKyXWqߌ:wg":)m{Xvz2dp:`\R]))9$h{[5"J.mV[c\eWZ)Ovp`Ep?9wU빛 6:JU%~[Trb!>Cx?kjEih R&錪'ҷ} FW\Q阴A'Ё>JJ-!,ŷ2B1tWU?hݢ*UEFp_ݽ|SZCciະlUd~ǗD9tvdn$)P1U{?wPtvf0*YF ^կ'+F$y.62Xke [ӱVK-ּ"*H+>>Z|HΤ%Qin}.v%s{hG;Ix_'Tc~Utg(ZԎ)ea嫲e^^c/CݙRc3(/-r{/yԧ 3噕X; v,(6ɍgyUe 9^/|݌kSHnՆb,7vq\iq$۾V8n3^uzjTS99SJKk_?gܯ baW&t"%pOL5DgRcվzM,&Hlkp{189XҬ/{|(Y+r.s1nMy#5;8Z|en]_=9=ȭ'ffo?SN·\'//z޺Š"Vnst۠UUtg <88>Tb_zRmrds^y#ڹ{dcY{:ѱjU#xnؗN9溩Ƈk:Ov'AmH\2=γPvסew#8]_A 5*J*ok'5ʋІ"]LQBQSF4]Og~egsAfVxrr=ΔhKw-YQ9StꈛXՁqt:P2K$X(8,<~u9w]zZ5#M+tA4W+y:[ʭU+o%NTekhWoFr3uޜ˿M~)SkFJ1e:\0;mېa(ԍ⬗} jFTF>{]]cLT`6:zJI]>撧OEM m/Ob=IG\eB |P&tSu=,t4ޝR O62w*eZJM!?wxXөZM6:tcNԞzڷ&Ff^YI=+OgZN˲)9f].|H%R?WR*KTvS|HiR32!=91ThՄt(U*\ԦȊ<[Ouye i#\ܒ?\}y~*u̲B:tǥbEͥbcSqk$$ o1,A jڤ,jZXA6cex⁚<.eŒu#-Ut[$#Z,R3\1 >?pQGt:}IPe-W#3y{Py%7]껧ͩӌUJ;id}|!ѼJ׷Zch)-\ m}YF>ӖKG~5TSq3!Wet[8,~}}뮌KGhJy6]0i׌?̷vߙUdu39 {_GP?z"Ozћ:*1tΚOtVNݪ-G")9pHl^MJSicdžk]/ Zkśr~n:g?.Q^TjO[9J7v efwE[8?sZҍ9){͵iʜ9jmn#4MnW($0Am9[Y^gugRi>k/H쁣WN''}3YB5)Wt˥)a5'thvF)%u/ެe瞇뺕gTgy'+i#/W%m4|J'0*Z/ĺ8bh+?q'k[<.>` bN 랽*'GI?r:n}=C߆|aեZO)2W9' 5:4jᚓ\h]:8e?yݯ:|ҴntYPDzB؞{uke75{RW}oW>=x3y6nT#vqqɯT~>^W>W̕1㾙x5\ZF7Kw-ck 9J\p#Iy}Ҳr趙yK2c鵰N=#cB׼~Ѡӡ5 yE]S-k8-n+|Ѱ$01s_:8G-޽mOu.sHKIGbs㞞}]r>:؈*i~E8D6dέʨ{b4;)FQi&mmNm 4%6۷CJy#A3;H+d?kV9ߒt۴Ȍ* Ynl=JbXY\5 siiWpDP*.GN8j|ƧVӡ$jBgVmŏOz9cKoZͲ#L|HYUGqNc5u/xE~F~{[zۤg+̍nrOpO>4F0~WDRTcV̅tSQ(պz69c#n;~aYR5a GjFkvtї9TK#Iwb). Xx]r%R~ iҒ|XٟhV֜[KC,E9֖d[Sx=35TTdaRxXJ'[65{ϧJR{K "2/H9?^YX$+41B0^x:URIgJϖ>DRFmԲiAϪtb*F?z>M8]ocpWƓ|gWE.NgpWnL$XL'ƪyn5ؚH1)Y@QA޶u/ʞr_"yG;~s]J 㓌ihJh"}]ÖU}N~hUQNPn#*8}{ nVYs zHE;%*ъmz6~3?m)TJReOݥjwѢ⺖v%YʨGҦ= ^N]vRI| -px'Fq9Fk#0J#qU ˞҇*GU5Nվ{UG5O̻ t%o L6>ʛE4i֩9u!Y=mOѻe:%b@릎5f۽U?ut8CWb%]#!zjT=aK-f6uCRz;e)-wУzm|fyې1WF6=~ͣSErw c"mxP@: |v{iFJQdXfWF1fjqܤR4/T{ էR ?-JtSU#/G~>mBT&~wSK;y&\RM}Y̯r)kqտUn>jwƥ:螾d?i+`Ҵ4䮶:rKmIn8ó.Wc±Vt#֤w|6|dsӦ3ӧsRo9.WBܻD>ϛlЫNqhW(q(n0nzt!Jn71",-%ϗ5?O׭B[FZ*Q"HM0lz|ww&4<>yźIvkp$<G1\Mӗ=pPXI?Uc:VTI;#%cRӽ֗MoyTa}f z`geZQGzIU*rU""4]]_`˞dwUhԦcvE>ISjzT$*YUVVTcGJגl%&ܲ0s=kU)fxs.zRZ-6Fc}S`c}*J*Ԕ]I|ʿ{q0 5(5AE'>eiYN?wèZ|Q*єd2o _ҶmeM;Z«AW߷W?{'ҜhIwu{HIq]I_Zזdۜ!S~{_{by!}ʼ[7ޏ:cMm?,\oY[%w-<ϧjjrr8Ō5aoC.YZC:4osbkyU].[GUefc5('"jVJDt4j|ʧyyZ8E%nɹ'ۧƴӵ%^]F2Cܸ$c)F8Ƥp)"rB8m)NpLS{y>l2j-_kLe[C<(YrJęÃ=+(멞th[=VuhJf@X7{qNIsYiltV?fcuѢGlE<̻$v#rV<˖βZgKxkߛ.>Z-cIF+qq"`[\԰ye-eʕFu%: 2A<a<RX+>]?gI;pȕ%9CN^DƧ=^hQ\g>Uۍ~1Xʧ÷&ہ%/2yZƴG*]nU\(SJMQ֩ [ip'y(R#V;Yw{.kUO:VrTz[Be7`+یN?.z +GVrye$}GggRlќK.k"sdL3uU֚mISg5'-1q)J\UE훒c.YJg׏+Z.4g*S7ZWYqf]͐ 8?)曊Qs Zt`_w]bl1ێ#tiWVRfo aTv(<*Q3'wndH rx/5:rrBiQlu$YGy5+HA>UTc|j?y:mU&'+ *Љs՗==g#,$ |2ˑϯzWn|ա =Ӓ]=)mwr:ֲOO.DI; ss76y9-rMlwFNK(hjnaܪ68 zִJTwZeN$ՋK(?->jZ%shR<]ס.c#y2,YdzdZTRX+s|k=nOQ9;KyjOImk)@?:P(5ޔߺ nè,=};2QO#ݨKnlmfέUG}=RD$mlY- wl BJrLszeNthTsHp[q%'x=2+IISKb7NbO")J7Gh@]qLç_&7)EYrH綖D-t`Hy#O8Tzc*؈>cBZ,YN⧡pzbW:9ʍWi lQx#-39R9:pG]U<5pW8;t(6ۨv3nwӷFPpԣN^TO-^3JFVHð崬ݻZ3MȢln#lI3(ars=)q끚ToC͔i7Nz[HBwu汩BQθ_qngxe[&1}^={;캕*J{lhW7&ƵXfʪ9MgwSє}Jj FlUqS9ua} 7p((덪Fw}lg&N_tٔtש%Ұٍ~BgNٞoec@l`D$+?\MATƚY$S]Q#n4e-TދRyg+O-}lW7.GSC!O c2ڭ:t"')uӹzB|}C\diJ75$;~U޻ *O[xT⽢pbrnҸ}FGjX$"kgB2zgQRU{urڬv=HHŁs^~`e+(]>֮" λeqm*CIEYrsϨ⸥IqӆeԮ!ha^s^eZ2B+(*vM2c]3 rs'c%ʬ\SkȖng )U.jtZLgl@Qi"wc3;g]ܚ8XҕE~#ؿуnާQZ)GV}lq`3v 9ynyRe$%yRJgQ aTdzNAF9=+2m;(ebx]VE;[=x'9R7quj/!g]v9;VJNNsZK$I)Dw8rnFi[2;Tf=Tu#?J臻V4cgMͨVf~d'#V;nq {{݇*\Fdl/Y# gӱ7o]WEu>tAmQN1/vZ Nխ[4kpdeϗy'98W(ԶVRO֋N7r,*?3oݷqSG(=Ubdʬ7p=84.3e(nM,ks%v*Ll{)rqcMf3/&Xed8<[(~%ՄZV䗷]F۝c\+,HsMeNj9K/v7hVd<UEzqzcU-#miPrrJQ'ydg=x? NeT@m'y̬F=:Q/i]? G_lrsQ:(GGu+r_ΎEXQ#9#5>jS-VYE]J7nbO'?Eh̪ʴʾ`)dCml8`޲aG?!bk3@dt9޹=`g(sƳ.Tt$zVQiØS%߈u2\o'HIZ+T5Ԫynꑞ xk+WoRƥ9]k,aQ~hlPpϽg*J2*PIlW\/&Q{جjRIݘ;Iqrd bC@zη/Wҋ]YoQcVU-˅݃1+1Ƭ08hUbˇ-935)KȩINݚ∑,/s\S7M#TQ;6&m?q˖:-ObotGhxr)P6FH۞ƥƤ/u3e4b-[Z" 3.N8ҹJQvUhӳ[$Oı.fyf,lߙ#JMU5("GY3&*7-G&fZ==7[D~K)C6I ;d¯2I?S5jJ.Vi^ ewg(-U+a%{dIw'-$Dfa p{V3(ǚ6l]vzhVL |(i{W(̥N?RY XlCu܄;#a76wTfeUT_wcocѶ/hv.Q}kYQeh9F.-'LaQljGF??Z(N+a%Nukw{* S~S+Jn6t4W?.-[>u-ahThѭGZ%EHźp'u ҍ,EjthWmp $AQmOڴ .-isVoXXXH*yn2pp*/M-iNa6rM m M*qqm |{j54I7MCBgcc({T'dU7R b$N[9kǑ- *-1&Yd63)Vi'8[V*jJ&&6kmaoyiF-'@QS<4Lv\>j=)b#;1]9FY9e?Ʈ\J^?Bi%v un; }kӔz"F#@sՅG/^W 8m\JaYW7:qǥtcjRz 2E~U@I=ZU7)s]JͥT0s Q#ںih§j1+DO}v{QhGDa)S\ĉ9?)dub+j5'N-TzyR6nO^>t+%m#FS_鏻ɓmRhAuVPzF~kHHӚu7#Ii,$ Yvlz55QG) u,L {V^{9js.vB'1׭uZ*TڧPZTlW8s{b9s;i*I=# tmî3ZV[):MF?'$1;HeͻYcR$G-r5YLnw犲"9CkagP>drß}=%cXA|SÞ9Gr%Mo$k g rYry'9~GQ*1Rlfmϙ&OCja[ݕ:A+J[%6}{`*msF쌩֢vAs;.6p,ۚ[-cu(T&7mv{\GnSc{O|a0l0= T%CGK!UB.o@9K Zv\-kxӌS LhH.ZN~/֝hSQd,s-+ krxH_jq)I'dSf.UĆϵ+5} )i?B+ߴF>Ao:ڟ, KPX-X>U8n2{T)M+ڏ/RiU:4#2pJӯPrRw2*8{6F+<b8T)ܭw$d_DW#p{w=4TS߸h"]ssY^ tܑ[iތL6s#jx-BIXН6\ʃt`"My5cF.TwDBXcMQaGO޲grkwgnmy9#Wmw}jtrsKB{+G8vœN9~*R$ ևjf@սqYK_CX)ԍҲأ\356 9qҶynʧ)'{X")_7~.OE妩rangcy{8׭q"0M)5Q uƧj.4Jt>^/Gֈ{הeh4І["Ug~*y?8Br""kE i$SMG_-K3$2^wrewCQY[]"VHѭo#FH8~_OƳn疛sV4驫F]h2/A=3krBk0PQh֑pN Vr=S|ߨs1Ay~cav"o{sG[NPhߩj3vv*3z{W=IJ{3˔JERwdT/ݿxQX{o͔]h[~NM姞ΥZW$6٤ oS~k*Q4Bw4Xdec;Kv, قc4+ vu&5{IcL̅H`9YsM 7%&?d|ua =sXNq ?khGs9*R^v]o=+T]ߴ0]@ kU%n݈Fw#dHdv ӀH+WEkdrE:pTwwl DtE0+c*Ӕn㭿xԴm8[D*}nmw/N?#TTcM^B_危kUe).#Rqka<[|{H$ml>a*q󊤱0խ)ʟ&$6[+ K:8+ٶ6k}4S̏$!eq7lyqs(ͻlS [7MsБNj$U-:I3ͬ۶@7r:MoPXByrs23OCxt~YX~Zm9_c=0{Ϊ?wbHoeyMsd秩NR.bXeO3V#9c:#ڢ_=ԗ5)}GٖS ~Fq~I(J#6n~do+M$2\ rמ׸\g>[ʤ% H`f w֊ZT](̳D??1!Dc94F4; `F I5ޝBR|AVI&c$;r=8eRGʙƛק(gXH!cV^D- wtB%6CeI M2.>*#VU:Kg{ sӥy*UVߒ*WRד+Emy~JNބT^|J1emzps:z|ўy({FHr´RdKdPy7mXB]l~uQNOnȚ84m*)N\ɵoFT$NKͩӯȫҶIk]dTN6)%Gjj+#{8V5'8E;/*œjF9_"Hf/Ǔ'BǏT{oy1rG)mVHܼ@O8ǧZV"M1WKE7>'mڢjcu%CC]n|jm[cgmU@9s~7ɜ]EG}:[ІKnn [!w$ =0Ru(4ɣe;yo8l;~"EnlKE5D3Z,mr2Up9>aYRO+?WS40HWVV^vXUUJ/kk;^KX̎bc?oŴpu'vԓ5U-{ocϔiӨ!_fᷕ$iħbמrAJ#k}[vw K*wIn3,b2A*j]9k/v߅Z|6}e>vs;u^Υ.^ۙ;Ь+"k#Japy뎇<6S(+Jƥ95ON;YP* AϡcE7bR.1Iunw3푆?ϩڴSmݑGOZV{^.N$fUlu$tW.Xێ6rƜiU܆P {[XcB򞂸HI=vKUj8K]t켋|B-;`n$)'8.eJݻdinZiٕ/T}m|G4UpUOWВ -ZF!7Rz{q/V g{yCnX`v5?_CRZqZ|+ 8,a;|`r3ې?_ZrM_C9JM5ıo"؇̋wPR7W2Hɫ'ܻ e}O^hDʞ"8/4QqѫmxA|qGTyZUga||ČxfeJ RWЪ=*j/,F fO% cUO^8QWMt6i<.7+vuލZnrFt,f~jpN>]i^JFtʍNnh[`hyfXԐpִr11+;ήY  pO{kZ:wX|w.3F%cd)F{m5pjRw|[IJ%A~>PRG+=Ȟ%w3ӵW9?uS;L99,X`b|尌6z>&IS@ rtXO뎞LE:Qj{sSy _? n*UcL=*}.G* x㷯s[(1fU!a!sm"`\*o9- *qvmj$ S*Nϔdl*ꌦ0B[k"`HG_Oh :~ί1KƸE1o2c ӳ߸R3V儻`P{gedOc229G+ucХTUj.àY)HvH$X\84rFy3$۸X^Y,{9?eK5ED5бY@_{{Oz|C p.c6-~;v{u5+Јܼlt;0ӋRN1J+LL?_ާ0vR7Pq1YU9G,R>* mQn? *J-R:v |CN6y#JNC:.e(Eߵpr36/䎇ʗ4g=SfU8*ƹ?>IJf|u/(my1'tՌ mlڅZķ1'ۃ*pzO~?:FfэOhOFln+;1gT\vaNjnZeFj[O3 $TQQ9ҭ[]c qz6pVqsw֧/lg}FFv[UF/ýeWQ^2oBmrf ݗ'<k;+(GܕGs|GБ1NK]oh}AaxNYHjQtEq]@3޹yfR٫+n1acCQ'd Z?p1X˗4F*;yw.0eͣ$u'V2qRM[i4In qӧzG[U?wegYGrrrָ%%fi~g6[ Nd#_\nU DTK)iWydF=91BKM q3[jI-dGՔi5$<Yl1Hn.wֳUȎZj6~+{. n0?DG 8֧-3tRX]m-v{zWUj>OCFR椬Nv^ƾb\<ʁvSNVTSLtJ2V6M_n!֢Nhƌ>FIݭm@ձ[R.1T}Hpis7d#zowi">mkJ^=9U8ޭVCclE}ۈ,sӜ*=qFԤ}zwvtw:-p4?*gֹeOmnzTܠj]BLYle;H=zd~kϩQA.:hsFA#F2XNqqҲoTܨdٴ{!¬FrwϖqO~eik_+a۴c#v0O*ҧ*FXEy O~*缪Kk[ ;R{aemk|\8T+4\Ԃ[ }ؒ1j|xԩ*R"Sgm>7>u֭oq=j>4Đ\'ʰL΍joXj_2H_9_qʣ;jvEg{uZ-Qxq>ަ2 EG(J+;29$l#Y7eaz #ZisRV}]Ef@[fAYҹ%Jܲ umF?R)7c԰ E#1vm_ni7*i˞Z!X_-8,ӮRWci- b"Twi:|N*xR6eQ9iKݺdݹy>Wi' f_~u)&zJgG5ɲ KuNNTwO{UsMQzEivE*# yߧEuFWqu3mM8zӊ~c+u4t֔E8U}9TwJQFVFܼTu} !8F.9!H@+q@FP~" J_1?qYOliZ3,J]yUcgҒH q20@z䖟!Ys]QՌe*ig-ŷ邳q׏N+Zss < |w9*z}}JiК}J6w|^kyJYi؈HbcnL`W=J|*nJVe7dz՘Uiϡ syybEϡIOE8;$}?NQҹIEi<1 ySV9Z{Y.$L^qfڑKFe*s~^Gy| ;uʛm~z^UI&R͗<dkǚ.WZ;&p+,{}O=q֧*IS޾ew 8ٚNd8oyϠ>Ê\?vVw^a' nJսHe30O%#>j?v'L ힼcqbe[ގ:9*nv)12#f]Fdr[ӜNk9{IEF}~]O᧋՜C$n(>U`}8Iv_XZNz_1ۅXѧOVFi0r5RXg{К審<}I.c-NN;vN.Qi}l-hi^Ti㔅CB򓑷Q9N0=]6O;(8\YϯCG/-MUѵYS\VSp$185ҋ?cgɈj*jl`8A=?1rԷ07#U:?+;S:,0Hfc>=?*u*s]#HSYAGN"S> kGF72VOs**2+[tYg*}NswmhyTВ93 8 f9J_iNNWZ~>ceWZZݯo^ڌZPi_t #ȶb|#3n Z̪S\ބ& yU;G*}VGW!YFjV%Id~#O犘rTTisI:軒Kqo;m)~NR,E)˚8yk< n٩F3ʲZUw- ol=%Oz9&_1[m#B p0ÌuOYCSZjMndd[>־brCC0GEnx*IW]9|0yJ,AϯJ х~D}?#jN77k HC'?2]yu9GTdzӵE'oi6^ .V)plLm28#rE_{[5_=M7ET̰k^}v}45-$'Enָ}8=SQw{b(ik-o}/^|GG2ʶpi@'X5TTpK aٵUcnEs]6K{=ϙ\n<O\UeiF"d5?_\7mbHYdY>Rۀu,𖋨P~KM ?u:}Q7̯3qx+گm{ abʋl)* 9(F.]S~__ng>T}ۻJծR{t~cQL%/#9=_=OR۩|t{v:5$k%۞:(޻R{ZaNR# kxVH\C#?#UsZrRMvaoh+9鑌sw1);hsfF*)Ikz5I"LmBc1x8MhpQ*q8jJX@4m#}:zӊ0*UNײ[-,a\3E[ﲕ2F>a ^:\M5+su;t o |GDf6,0mPs y8[j6SaeԃMnZoA<.&X|!T6QʘEV}mtmh}NG{xR}Z} tWM:yz.C%c~x_S2˽N.3KkmԊcmS]zݦ hVЭ|y$liyBFy^+2~I`s)h߇ Gay*,R-ăyqA1+x}'nWVshsU]d:]fm;c+gzý~f^,|m:bE`kƍՙ~m͞pH޼zw6*rqI^#ncbŁ'8Ϧ+u#*imcr:q]ۺ[32p8=W*k=_QRy=D`Y6Ϗ϶q׫Wљr^l#O0aRqyJ疽 agO=^  9,*|@8ތf[!xb̶b]*4}8V(_"ңO#o*K˳k$. ^z{r*%W&ufݴm&__#.Hl((͸QvlWqG\VqƜȺOTN[n2nR)A=sϿA]jrǕɭ*%z7 gXݎ2}kjiC9U72hLjeu ?3r94FiiszoRwf*Zl6 =iƢnWpF\i0[ʒ%p@oӦT{9% MAV5|wߞG?,y5)Yh޽}E:\l7'˵q:~)Sjv1uoC!!/ 1nOӔ־c+`@#+dޝ{V<вKkבp3]Fy@FxG5u${L,⬭;(K%ǻ嗽k~붇+iJf{E]3;ctڎ秆~F^e@rog|I%%Eߗ+o8tW撲z\y=$(]y 0+$Mʫ(dp˷׀=kJTY9KB+f5lsYʟљteLWi##wR,der,{uJF [ 3H c˕;O8Zi3 :֚- 2m,eOF<1ޜiǖ::;vKle!Uyyb)уr6DUV xAU)J.UyKmV¨Uی.:~UUE-v=X~NDEᷤxW$d޻!RTg4yUnjzZe;?AX >u8+)S-n ]TFY6qN1씨/+<SV7D_-~AߩXǚc#+\Ind)AعGA/gIN5ry}js;J藳ZݳNj|Rv+a.zUQ7ŦϹuTnoݦI_!j20^NT߲NQn*:Ȅʹ, gwӬ[i;全䬴&/qoBs?ҸcSTj9e.\GÿC5ĥ!E\2xs۞RN@~e(m SXu%(Ew[z;Lj۔0N59ыjʋ6՞knIAt:RnZ/.^R\D#o3s;y8S)Q[Rx-e"Wvѐ8$s*%y )=~{U+%ͬ2i s|wGfǶ5݅8\ztU/yYZMR[NU-;n)֕܏&k(ZͼWt+IJ7`y{IRgF&eINV,[yt9Ug+Йfxa]k`R2HzWQ7v\ɒAus*mYwc [ME%ˢTZV{v{qq泔ʭ3^Qv~Դg{Xm_-!oxD%(4~,#.K?\ح`ƛFX`ky=MNR{mfhfETI8?Oʝi(p{Qӌ䞷=ƻo>te8Qӌɥji5^X^M˷ LbSbHW(˳ѕy_Lz[FQo+3j25oB,1y 3aҗ.mbp)[ 0fvKq12q략g(N9U2%7c%g$HPJ>D.WOr+=ȷUު $c?9Wc:Mco`7cr'wU)]&O'xA+X3:t-UdPsj_yC4{A}jE4dϷSt*f%U#)-R}O,eY=^j#UN4@moaӥi/z\՛T~f]m'RR6 ڥJA3N$ypiONHfݶ?Ή(s^.!O,Bmg.k)Ԍ)7~-k|QWE%1}Qvg`9k?Ӎ9~Mxnqr͇#ct+ S"=%yɴvǜ}}э~&21R<ڏk&UK,j}q'<:҄]#C4oYA#չ){r=1dX_1 %隸EƢ]*27?($|be߽󳖕$.kn:sQ[xWne(JT, d9E1ZcЩjj/XlԆ[0LW $viNNJR_Zf)#YF=Qx&g*1goiI2hfn=8[멅l:58u`1dzbʭ$w9JvNj'u{OT[-Ź- ')Ns/z/%gzRN4ba.Zy4eeiO$FM[NQG;RoNy\?ފ~:j.2w r3/$d#.nVHb("3ѕ^_Ҵ_ IN>Uw/!.0N9-u>N1[l.XRӡ1Xnr~e r5BItm2cN ߃K[RNROyiϻ#"Ɇ%V>Rï_uF-Yroz*mv͙5qy&1w{Dg s~wg<\eMFn.-ZX%\}hv?Ư].nd&F .>&Y_̚|R"FsuHzE>GcD=*i%sL ,ʲd8?]8ۣw/g%zњFex%vjdz1U%n( ֲ\\fU mNpOL{Ue:%N^v J!FՍSp3g_348Z}Lʉj>z#==(4y/%+H&gv3n$D#̘Qqe'(%\1FRwbܖ0HE9\7?Q)>g6{=챪ī>^25އ%MsHY#89*>U jRR#rKj;wOsC = T95ϣ+Yk5bV=ͽK31ϸi){6:u5o"aqlbV1x$sנTJ=^ǝNT9Y)1q$.B;gϭ". EaG!I"$r:+:җ4W&Fr+lѸ g&3['97n՜UcJaudTWynf*1n[:V5N2K+O>$,#ghݸܑ\מ8RjK/^v37%Fo39@x5!1խisԽH&ȤI"B7rO:T˚]H;-YQ&>(LwKqIx'SYҋPzt[CT8v==\rMU#jbiUV6mۊs&8ӫ]I&9T@Tqk=#2tս}KCEy,JW{a9+Ѽh&O`y'a{iks8ܱC `zzRXf/cDUёɧCImNb3jx7z(G. GbѬ QO">4&(1i"ińo7%vʹ%QٽƜVS6O(VڼV9}=M*ѣqweZB<՝m8\2e}=gOy&t=*vNO'gJ<)j9{}imIpv´}I8 K, M" zT#6:uU=P}n1i\r3|ʜu[[sp#lTjJWJIS2uBQ;$w9=_2{׭ɷi0gisUѓoSXlE9Yk hhvYmۛ?x#b%R/riteG[G-ز) foFQ_yF<-KmӷN[13r#o*j1rߏjc2},\M8ƥvK̺4NlUݸ+06nsWMI)E;j9ae*ϖJ[uEķo(#vnϡ}Vs:qnRWHm*.1|/'ctQ=0U+Q4ҿȎMx/ʍ?ºj9*m;Kgo];n-כmyxV#%5tK:*Җ{XK8 Yn7sJywێտ9JI_xzT{>/HqnGAW4RݗR>W+Mw켉Z5F Qx׷iOݩfg t^jrmE啋3.J#ӣS7TVVG,c c wBU/gm>eYW,mc ׯ]bܒӠb'^0ZIWXzcBd:s*i{+Z3 `]qN.,KL7v,A׊>j5?f1ifyk=Fk8^leWyrlmUWn~&u6MN^.9UU+}~jF+"5Ir W[$=$.~[3za|ݞ0w wsGXbqfo pzREE>{vctH*9 JdC$lҔo3I19qN6+v 1y۾Un{B1nTc;  4lB9!7dsǝӏߠ3i#i#S}4Z6Mؼ5IUùEi{dIbFa&PxOLZ~ev Z:nAr:'$ib-. U!V2c <' ~]\SmQr-,G6+ǸjR^qӔKuF]2HYFfr c;r8+娹6>PzIi$dGO|6dϹ?B^SQSz5/<"S,px# u4Vu+IYّAۣu1mVlⳣMk)?qgF{I̬7˻Z8Ud>c]ZGV&Q~c.[m^wE`x\>Qד='Z1r凭RQt~IX+yC3t^g c DjIF&8[rA89<=8ӔtEj^ڧKk.ոyG p:zsk2z}QԩMJ։h9Dw,d,ql{{҅=M_jJɲֿk)q%,i#)Qkڦ_C%Rm7IddG!cjȢ>ӟO f=U0VJHOb~n5߇cJ?vIIMd_25fP{<V(֩ *mkKj/.sAQҵMU#kHUx$Rdin8|K}QZRYrnLUboS m Jcoi .[F."-rߗJۚ–FTn[.ޤFc(P6rkh* 9ۻѸ׊*\hkTR]G!tU CCc#5)[}ΨӸpc9*y2TDU>Tf%*M)&9n7"*ۖQ9i\$v~my%3MJ<̯sK}^Dr2m~Mџn8ְB|rᔔw٤gE& nU?vm&5ԓ vcO2F)F@$ZYI?0|9|sЪ#GX1(byT3av}]:|,T*{Ѻ}P\Gg*,Q6L>@krl5Rl&Mb)sV[[K~>D0#+;>n{t{9VMd.\A==rd7*qKp۾xӏ-@Iq?JGݷF\}xrIcp|պIc'vrq1u=XQ8Hnn|[s.֑X>jcUh5)ݫ<@(llepFsU(+rT_)>e:o9rh `:Wc槥Z6Y2i J<`3KKR25YWbK'2kEN1zu69˨ӘY(o5Ky 4)i(ʊW;",*,XuqUʺÛh$Me1+rUGHє}c$,9A$vҺǙv5_w`Z睤bssQn,[V(bmS],#l#cr)/r.kۥHqq՛PݛB9n. YwB13*yo?B]K ְU<RY rCjYW s:|cSQV6yU:o׮$}>i6fhǿ!JFWv\V\n`L=Bٸ/)EODGp'@rǹXXS(.R8SsєqDܦMCco[TwW#/vASȎ#wv9wqל`+(N\ֵGm ^I.==kS)Y=EY1d3 \܃ק9YScy"Ӵ#K4S33)lbF9z蓋ӭ'4ߴ}5*čbMWFG~׭urC٩Ja6inLvHnLjs;>޸FҦ%+{yWdiTRO߉a"Ul>^=qbkss^7$E¥Le\³xʜeeR+.[l7u8W4{>ڶ"\]1Dpafߜҏ,Ti,->[j9Ku󪪲*8Ri&N<}#9&Q`~Gq\%0h( }4՞/;/Hg}GֳrPJQ4 ,pB[=ߵrUՍ%G њ]@cq9dۜrG?"hEua&Y o U9^Pq2"#T/ *zYczs-Wo623I8cz_W籆"Z1/k6ɹ|9w=}麑T.R*=eؼ&ylB~cg U9vI~Fx-L?.}XD+\ϵWq|/c*~ w3tLۓ:Xw 7Ӹ)c6M-6qz1qZJ4cyz$҆B dlr5իu ?Ty[ww%K ]rMy"K?g K%>m`}j#?J$vFp zqUOݖ RK-;mhmm~_s:u*]Q>G 8)%ҶS<$h]^ =:q"IB Iif.3׏JO{^?BSPFӤdcAGZx~h贾+4==ijAm#c>PfU-'Wܽp:3(Ivz}yFf¶ɜCd}+8ԓn_˪JspOpmYʫm]A秠߶M?ǭ˧NZ/H{zrBȲG;4[-iV֌h]jKyH,7cEКRoi*JX7CmT1E);s6i8jy/2ɺ)N'g{]k=x8Ŷ\/weU 3OsNq~o_i_pmv߁UGlNSof:9^)>-pω!ޠ| qYb)TRVSРN!#3[h=ϠE+4^%MA&D2k7\ݓ<e Vby-מTݗ^G7-'}W*#XC7Ѯ;vwU(ESRv,%+^݄9D ͙pSr;j9PV{zrm,_3`.pr:g֦c F^ֳ\Mw%ƞbÌ`y#RMi鯓8ҩ)sIZEYh 9$r0sV2{wӭ-71EGO"کo%9FN9eU/ked[%FNkENqvK﵎YMk~Z5<$][yzڵJ~Nڞhɤj.W-$p@99zzgXįgR1J\Aȑz0l=k3䍗:vzv `;dw#m?OZPIK=:"qU(Эk@(o&0c ONx{8Y60ҧRwIᐳHQVsmn8]wsSe -*ad ӭivoNE$g7 #y򝐫:\~3UySv9M"1$k`# xǽvGow[XB݈J&j!Qm[ȟ`H9T% e"Ȝo~$lȻzѝ歺,Oq屌udRy?޶cQHy0>W9#zvӛ)Դfaa`0#>-XFϨ4a|ڪnuCrݕ̣Ze9UY~_1Azϰ?CQNV҇-ר70X=DZ>r'(%ۈ2ͺ0:zr<Nz $U~ l~|sJTB;D#%0jrԟLқhGǒ/VI;t%ʖܧnV}+ZǸ:JW>n^UFVVvґ8*]_oجg)([X'g$sk^yIhD#8%XBlUV0pr;gjlF0N{ߨ$`RC]98ϩ°tͣ׹yy"Ri YcSSRԙ|ӻ^+fq' D&ך&1FS9Jy~u,m_-'m2}V5۵mm.`-7/,t9sQx0攴!_!dֱr_64Uy9](?- ڣe7,8]9SߩTdYamj4l#6FsZ:<٭b*>Gd6?ac,+1zzVT+7'}ny){Zs{iqyr,;96ACoҧO]5ש#FQRI[{@ij1it q:W8JQvGZIΛyExa+y1LN}9r)s+(ӏ<Mi('g o B5VJ+~Zoy?)!ɖhGga"`H緯p{{kUv=\3 [+9.Z2[چRˌ``6p+b>FE)?kwx4Yt2rRH]FO?ʺ>T"u=ʙO\yz/ma{|:ִTER2I_r?sZJ/٘TZV!&̝6}N._FahN0-2حܷ "5W8WqSkVe)S[V"G77vU(t#={6ۙuU! WJ\Z8Z>ͧwcSG-D)#/Ϸ^LeNIz=*U10kzy߭k|7T kϭQbb4ﾫgzvh]D# uA`#N~lrF+ϥR[i%ZrߵwgW 9V5*r~osd/J@V6m\`Iwz6T0Qw:+$ #fNO\ҼQRQ`D3ª1zsN~KtDe([ ssn'@[8ֹN*-Blwng8QHOzϛΟ43#  '_ tqֻ[T5GwO% Ż1>ns^j4ΉBJi)G2fHfmTcI˘"1Z2hR)|mh;d{r+jv(IY=L]} qթSI]6k:U%R./KizG.b6U n ~f.i.goʞ-lA$hUWF@qZ{QRQgGbHM)X014rJ'$s[kG Ksm`8#jZ:5Ԓr4E {1ܓd#ta72/O_?EjsJ W<Ƨ.w<smtrԲѻv)]O5QȻO8泧=U=r%Yp8hW}9J鳮)7xD!.$-ߡL\b'٨}YHJH2*o׮H[Ѩ';>y<ă;NOqNAG׾\mï@|X5&ծP0Ud3Ʌoa=jcJ:-3ys ^3u/Fz82HaKj.8{G\)֋g/,js.rǦS\b㻱Τ#ԏ+j4R^mM"4i/F4|8f_g$YQQJQF:w1wΥEe8}~?ɮF{ԦȄ-%ԼdGH{Iqm-mwc6:jҥ-H'HZAm'&:ͽLD\=JҤv5O^8϶;{ׅV4qty_,Do"|I\3י(+Ayꚶ2%VrѴx*v^mxGq7 ,dX[VTr2F3ڹjaSOj~#cۅO3s7 @9=x׽Mnms:qdEK4w1zl~IFTgfi\6kЉ{omv^N+ NI;nSv+1VeyR0;A{p>hߟ[:u?UjRcѣ) p yq~nqCJ7Ir#^KGng=TzU9kF[y-b?D.l/ƿ < vҝuZ7rF"0Q$Ո[TG5yy{V^]_c2UrЖ>ߗ_evIZH d۵F8UFC.-m-fGƱc w7zΒuXѕT~.AVQooyc)a߱F伴M]y {9h^ :wE]&_SjHk*oUG G#ED?tC娵3Njg6 :54H5.Sj?.R2cBܴLc-\||[F5ݗO1ױ=-$X]K真Cc9J1Mݠ8"MU'sH@֪QHFKsJ-B-^\yQj>Ҫsg9h5<~&δhU],3[ZpX1,į Ɯ~Ɍ<jƜ%=wN1Qs㹑NYzKm8~q֞"QOYT)VAϨO;do*6^~JGҴӔu_LDmE]~^&ČDn<$3ǰg)UQ6ױ%)IYmaV}Ozי{eX(u&"9Ȭ%YxԌFt=,zqTSp8fA[ 6ZLoec ucE4VךQѻW}F9i 9oNOQ𯛫Fs1/{ˏz$}u>*AJ[yiԣfRKˆ+{ԙ$Iʣ}==kݵGv[*N\O#M*;I.eU#=Ge.ir=)TEhaAI&Im7g` sϜgie[)F'kj_x \Kf?}* Lv= eIKaauunKCR b&r4!?8*}8LFvf/nK%mq x q>O#.^Fy5ѧV^DLtnd2N8?ןSƣGՑZNΰ7$.- m /1lzv)ahRnݾi, Q|V5.#sm(IevFF:\c1/hk1CJO匃\xeL>"ю[9|EJ [f|A<>մXf [ۡ Mo(2H9NqXjsz&\ߪ(UUwwK];Ue^.<5-/>Utq 7d9϶ae5+znq (ԭhH[%ݔُn oݺp=QўU1R5ss NZW 0\s׽|ZZtZoJ/+,{=+lDSЧfw+ FY[v'ƹj8ӽJqW1N#7B? #0z mZ'NSiI/u_2C$)怫n<B@<C7p۵U>_mȝt,To{_abcoi4<0>CQS.kEHߑ3/.DUB8UB>dny9{.YF)Ǒ9<~]NwN2.dDi<-]zrszTdT)|O_1Tyrx,q#RU#nQYTi bgV;-s ?ZҤӒ:)OG_bc\fw^x50'w좹MWv + `UR4Nuhv#v+nj1T7aK_v).<1n!r28ϭt{g-%er{j&HF^Qnczq޳U'NMC ̺!{/K\MmSJKm@'M{>o锯LLG%f?:8FJ^9{NehT|iENw_zU%-(Juӕ'PmE_g<7)n 9oiFk[nUJ_q:KEV]8ݐsӑVs5QG)K^>=[Diԕ^}iQ%%Qv%_<=AN7sbkvw.ʏ.ɗ+97uGz+p۹{`ԣN^}_JP-Ré}\TkkNࢠu/' lg8ۣJN2|1'8{QNi,δcR[İ"$*ѩEؠNX';ceB&Ԇ9NU;)D'- t$f;b|_h%lBɖ=^UdUbvTh;aټh`t0 Z{] SJLe9n>*};FS'ƵKg[ەRn zO{EHԭZ.-L8ya֪bƤjJ;؃PW~ߗ?j:QPnO UeW\`}kyrɧ\-.|1qdu"+ZUZVoQJE"²۰HE99S*2zX+SJi$lYJqù+5&!JJב6++)wtVRU&Lڸ uJS*єSTW7@]k 79UZ3|ВStne1lU*1R !u)Ӕ=u'WԔ#3r~\]cD{:Xm!{?;ߧҩRDeSWtˏ5ٍZHw0GP#֦:q|{Ӎz$Z/nUxf$B\w;xIeӸa3H$2]M*ue#{ghԢ/T]Zsn% 50TcJWm =I=(rq'SJnyuT*ssI=o)'Ng_KX?N98ey[L5/=?fGKTmFTMBϱ9@|={֋gtd&{j+Cr=֫1nsU6|qĥ>ZHf~Ӹc7b>mOy&h.[*l2}4bA)unI<ӹ3ɷ{6J̑F**ֽW۫_ ZmUTrVQeD%ȭ3fozuAĩ`:b'Jٷ,9##rQ{IEyKl01嗾9NӌvczqweN_ `wp)GjRn%ta?Ҹ%ϫ*-בY۸d=@ٟAe(&fY0~82*?{^[ynMf#*>[JټrRJo؊Z1NIROpλCaVD::\i2xN.Q9JU*bG,Qyi^;NhL Npϭiq֕}KDܪv2qKJ޽I#*ɒc?.GN#_J%{}c,5ȅES8qr٩q|V,lj 1F` r}N\"UNuhI;\ݔH jrxⴧӢ]8SԴWLG?T{]YJWEF n ҷRR5iZ >oylAhߪO+zҥ_ei\pNFԈk# @0y痽3?EJVkR+],LdW_9UJ1@##=w?m llUy"}liDy(ˎ s:ݻ#Iʚu#[4y]|+qF= qRrB$AyhR7!C(EgT)Ny9iU*}^4^ kow Gz| U {:撕eӋ};`Ew!fX}0};+ʚo<;Sabb2 A],rAInc[svDt0:io2x^&)X՛oId.d9&KQkSO ,[~ye3d~9F\WGdT*O wRs#N3ӑjޟ="E(̑V;TȲؓˑYKr9R+F+%wԁai.d->o՚T;_KMv>yLwr;}ڵ=բשqJX{%{3AǺqA%JTr*qm[C}<̬u 0=>:4`k)=cb;ua+( ʬ~ldg])e4pǧgU1jrU'=(]j {u1L7^QFʷmȊBVzui˚3mn{x]ݍ:9>>"4kb,7Z\oR;ԊHiAU 9~ϯW,cq[== jSVKu2ګ(vl⳧NNQf[V./EsOTp FJKxGǺ6 Jgt*t{h!uJͥrʼn99G*rm؟gO뭺\*33s+:j1v5)Qz-zVċLu:>!bdhI5H˕}4#fHhR*ps8{w8W$y%%#sK{iBn3siqIoF !e+Q߭cSTFO^eb1پ5/y1I%Ԛ;96dNAqP{JZOn=8ƥy{H?"a0ʫc7jF1Wn8Sƣ%{m}Ie&LRd3`ԃc n4V2Zv-J ϖ` ZF8 >ʤݤiJc&lX]a`WvۿZI*1j]{soig۩$VF<׹y?3zt2敺~fRn^OoRm"p}⣑iI:mu0\Co{]ZOX*c⹧gh9-d..ngBw$]֞ΒVԅHddwwؗܭO:q޵:t䷿mRU'MTdZصӾ jTroLMuהe8Xk+v~F֙YƨIؔV>+ңJH%+uLt%uR87JII-}d嬯;O^=m*9abNVRGw(ݍ埔qZ~Og[HsYm`Čapg"Rt:1Ĺ4I8lSx~gO*PQ)AV1\fHݸ8$?7?@rO2rSˮMl ,$*2zsJ]Hǚ|.+PYR=z5SF4i[v4Rs^ySOb։w+Ϧ2GHsgNK7M\/$ijN@Rʰ쌩ѣKNKA \>JN۳S/vZYFaUcPA+ajN;TjTvQa:.^5<=:m6Z74"z+vy7jǙۧSM.1\1۴MNiFR]6F!cf=x5ף>g&nԥ/fWݻwA2+6#O5իSxJU5u26>uS$dcWoS9NQ~Ar> {lBO ұo}ݺNsM:+^,& =[SūngZ:Ҧ=R~O#e?*1\`9ydHWI! ķDFcSZF^uiɪ۽R6{`d/{~]8=5'{El~YSB ɦ[ϱ3'n`v8qRrvܘgV?7j֌jN:UӨ주e#g8J6 4JI:y܌UNxWO& ]]Bl, 1b4d|zlGDhmurΠOrtbyU%d\7cFj(ƥJz(z$kI_G!5%puG򫺝F:(ȾO#peovkHQio!Vച*ۋqߊѷfpըJO^D1Z['#UO4Bp lfvWq֪Ѻ)0I&q}p$b}%hGdqfWu.gij8ՔdԕeSn9J~bXw#XZ^ySEe~V##TR+y iTOв@\L*|#r=T*\/g4 _/;rJu9iֵg*,YݹHιmuFbIraHp&u!g4M]?>e{8Zaa(#2H+ Y3)ryY"_5, QvoCg6M8UI>~? u%Qӧ+;ը·B`k^jm=u5&߮`H-R v.3cV2נaRMKԄSg!yaH wxҕE*vd 'hv*(2:p%nemį*09GA>fm&\u9y "#au[XHwmhQ#F~>r]=zG)kI-܅V),\R'85*_R!N9MG Aoq;>\:`@j4Z+V+1-kG|:X4V91QۿEX[DciUr=WȖnW}[FXD͜`Na(莉Qoԍlv[aV+9~[9[[/̍x1/&Iqz^ە&qZUc'9lsv|q#KwkOk:}@aY;֏,c蕽H,\n[lR>nkJѦ;y%ՇˇVVc'R!jݵNx }F19z{TG.?wZbuHFeRNs^=9םMuVcMV6HqƕJjT5u=@ޢ>{Q7η+_YHVGX,X{:qb+ViyHmh)pJU3&8F_UKi eVwdP&RIMГ͹cZJ0զeZ%tƌ:.Yk :2'DMթFU=uUrRW"!q%Tc>{sҺ}zsNwJm.U3`8_].ZJBE$dWU;-,Ǚ( %̰vU~W'+JJw=dzHgCTQ7Frn w?zۑKVjrHng3ŘU{6I'#$Z҇h{3rem `㞜30޳S$0z[JRTEM+-+pX91Z{tFZ䅚BInf R7^Iu>YrBIEnBcRN wqךN2ٙ^6a,ݧU׏zV匍axw vOur改0!0`˵\9Q{ѕ0!+GT,h`Mc?0ғw;#SH$E"*$P۹fgrnV|LNZrGt``p8*J]ʒqۋ\p#~1֪=܎j|Q+ɕ"ܷCxj^NV$\Hfl>r̩{X5عER]9֑ܴ~!S%S=j-$t~Jro2~K]ȔnecHCP1Z4iV 󤑌n*G8QQ)[S(Sw#xѫFYv#:R棥T)ՕKu~O7Q2 .$lq|Ͱ<~J3yӢn񲲁I,G5)I~ƿ\.z+~Q i1J\l)·:rO[lx`5XՙUm>cMJ9S9!x-ܣyjT,0~N?:#*ZzN$*#G.C3!IqT6n\IuggsE6ƤRQq." ,I#U PC\ةK)4E$Hns,3OgG8㊈/%:(cmg&򲬭t#׏@G4VRm'cjڤ-/w_a-,9?w0>Yf8?cSwΥ Q7f&cݖ>t(ť3hׄT԰Z,6v/[qYF1]#NS^OoI.h}v"F-=3یP׽k*'u3"چcorǦMBrwՌZkD-vm4$0>~=)M=]N^ūB!!Sv_k 9g*ReQu|#䊎or˿Qя4#u-[ ukC31VI,:+zeQ?1b*9z4-q"x-@UUrvw!Tu4.Wfg%OֵOԅI" o啔EGX"8TW}VDsYJO*henZE`<,p>{WH{FUjhӨ{Fu nB@9O]6:qi+˯xeAt#X Ơ|uJHc휡n76Dua~FNkTb}41V*o~*BېWkhK>VVNAvPqړisU%xNėGr$$^x9_ .jOk]g[m,1n;3xV^`cRj;=I9hՁN+|ѕ;' c rRKgy=:sSZtFUj~e rM;#:jy_ W'ʙזۘyqڹs6ʿWMsͳ%{H='ڰ9.5]01͘UQ^23~`{?rqԝDa'w1GInIǵkN2ǟ%NQ\lW-op# X9(3R~ە,N Lױ y|s鏛Y1cNRd[Rwm`TGk7FVG HsaR$JVH*/ \#/=%ZjAH$fCar3"J99^#?Ab;YasV?{9ch|ˇFhW# n8:aOw՝$7a fyX_M)]c,F8{+PԲź?Bk*V4|SߣQK2ah-\:'v6葲_iPb '{g E%=riF%r)9\o]nqȬkT[ގ>Xg$~C. +${ZO ?\W-mdH%;DI$mAYNI8_{~&XvPCݼ/`xvcB9^r1#¶gXe_z\[o[m~KՊmoWzxD2?|';\55DTNdfOᦎh-U524ۉ=;q\oAFOsǷno}Z2fxUw*q"QpzY^*(թi*jZLѳC"ǻ){JeptjJUi vS51*b!ׁް'k}4K[5kt^a؆[ ͆$\FVJqY;̢D}Q!te$JcQՎvly({HDz}zjbHcE`da@>RJ^z'\:8jDZU6pn6T7܌ӗ"+Ē$l^dn8mp-u!TrSnc9SUHʍEtDdcݱ9% T4HT׋\?$rDnsujҥ:t̟\=N~T ' q2!@{{,t:u[-͑m[t+㕑W*0tⴭSӷ漌#N"aJB/X0trxG)GC<>*1Eei ?g )I3sU;E+wf^kK hdQ6/# ߡ4Qp~ZJ1kRVkmkos;[O4aEfrRRD BO7pY "2.Y=9sXʥ=nT䜡K^p'OcJ T#~dtJtKiRYr^ۣfFlzHȲ,;FH}@Q^\}6tVנEw 4pY`:uǽtEQMݯԨmkv$g_;@m8<W^3RRz 凡<5j",VevM|wޥ9$M|<}I^2@'8>ja(l<@9ҺӦJ5NKGH "W'Ozڧ$tZxx֩!_h:s*T}+GJ]9+Ymr3]r:u*7}F46e3!݌nMF29NM5亹IVHXQF~ 1ԍ+T*&FpV:Qq3ֲ~6hZ3Z].JtXz~ˌ<ItoN=4 F;aUsr6Gn/yV\w1M!{"):)5**IFQ&~+&8J1?ng[ݫ{81G) Cn^QR{+oi*i(sEr-k<UǖT#z#y.Ud@Y]F>㸧sy~K .dHr{8V+TĦՒGmSNz/+;aY^&~fkVLGP8 +r#S,,T9 COdi7Ԏ ؉VQ;]Gbj =8"z1/pc΢}RIǏtUJ$k%s8yFbHR+o.zbuoW_yNJU*Wpw]$Q+]yJ4{]}HUR2qTKT:xuE=70m0*RkV#tV+B?(jے/F:j]Է`L#ڱ~Y)E_ZX'tue(Re"a8zxƦ+H7eQNT7>CeƱ*7('oVqz~ZR~_c-V6`6l/'8`x]cV59=5R: n+5l~geQG{4M=ltƎ=-y7gW`9E${:W!/=Yr/{OM 'Yw*7du$c^Vo.އӬQn1[5ͺ^Kt1ۻTO.hw1Qk7_c?Y'!LTXkrui"AϙtK*\{V#Q傳 /Rq4Ws;w@>8S5g]:R؎&e;Y=<>2oi㞧?X~t:Tƥԯˣ dIIWq 08˚ <]TiG켟Nޛ\/L/`G$9ϭe߇ӿxSMEiZW jSrm=F:iJTiɂK_xWNEA1r2pprI`Vu*˶CVשid)2Wj|ݻnc5)T[sx֛CO>3&ƕO#>\WSKGo]HӨ4 tS((nq)j2f[)J_H|z|}9=kY{Euvd&+7gjT Z'Լ(6ΐ3J_`#Ua=z%JYCNê6^ø:/#,Op篵cwkCT:n)ܮmTOon޵)KRcVͮ[E2EU-#' \UNW,RwUʪ<gR5&p򺆙vcFr<ӳ|2(/+ՅR䎬}o&Ij .3c飾e$?xL$Gcx_ƺfttRy"C#$hMvBJRM/:#FQea991pdݜlN1w.^y-I"?+)< rXm/iйi3Ă#Ã8'Qh٘1v4#D:VF:5`Orb,3d,smmH劓wbX1dr?jMr+ #[kd3gWNVъ-h54i9v6 ?&f'q'&D5)k^tc0^977匯ўcןf< یu滣jy1VkV(ٙyެ})HF5?}XB,I#Q'ڵסQ#6bpψcn}G^s4uE;W;YQnћ]V&Aߐ9ֹ9֥=Z2kf/_^8'g2GAvCe~ee}+˩NgQT>T#N6+ݻqÙゼ9y,a/r:}?Zf/嬣)2BQ ) 2=Jᕔa.X2$yg }1V2 }2G"vcMy8{ؙӦhu4dFTU$;cۚN5-EOF3)1J8$g^%JtFSu2'ieFWorIyҺBWtiyID7IVe[?p֧+Jp⢡Qjg]@}KqӟǡprJ掝ө7؏N {c14.Uvٮ{JoCeG=&>c|Gͻn*SvR*J3鵴B6H5w0'<@AUJU-=.wMIQպ_!\(U ~a?0#oQ'ziӯU8Z>XU7ݑ8銸ʢw}_^Fӌ}TG#, +0_esu%R/g}/3:܊cb7ϖמVw_NwZ]=}:[ZUM~ʭkwZT25kZoإ@vMn9nat]:/ӣErE˭o"kR$g{X.W'A?ruj֌hK <WO߭W)rmQVj*1Gug`d-0g/ kZΔbiOSz b s°p}/?B^cr3t#,<ʕRA1le?Wg`0/رac- D9=%)^gG咔:hC^W-- ;g\~R;-ZQ35 [Q,k7w+Nvw9}1N:y_OGyc7xeV$6G=מ z^"s~dayUeS#_tge\*oɐms3`󌮮_ʯoJto]2(i){km4@|,fg4@qŏ`Y60sӨTqlޫ~}ΫQǖ{^~gd*y^KB7<ͻn %׏5Xij^߉ն5p!3 }hutB0IrGUf׵~a_.-b@ {׃N4}C8Obi٦k/̠F8~URRKxWNJo2I\׏ZZql (z/uj5?|/i3y'zVZWFTj:.߁w*dW[yb)QxБPoMx 9Srvt-_,G̈L~;}=놏<8ʍSʼuRUheLx =+jStjN<:}DC G4.c&!\>HcC3[17uk׳zD])еƷċ&[cqNtKoxK{K+n|π&o V!I۶E]%fp@e> PK~V}zm5> խk۾xƗo;70Feœ8#* Ҿzo_Yy/cd{~Lu2-M$_*98lؠҿx̥ j~WR?nBQۃ XI Yr ۖ׵ʌ)9Mv}oEv*Os>j\h[xʫz#ڢ>mѧV:UL6 =+_W3UMֿÃ,|Jϩ=4S{H#+i<*>i3F8Ժ򜕴/ƍ7>6f!ֵiS)F7I[enKd?zF޵hG-(7nguE]Bم=ʶԌI1:tיVo>%Y%n$ ^DiWT"Z8ȉs7 ԧSǝ2RBXHʏnpj֕]Mi6Jay.UUNCv9K37/ܤޚn 9"?ն/@\v'%.fzeAYKԢ$;ewy9k(έ{޲Zk*bSlIzSZ3yos-J:»c O2ls6y2?y3@H:iSsOVG, _nx8˕mNi5{GWr[m]n*FFp@=:WUGCWkvݕFMmN[;23|ۿxNX(;KsZw+2CnE[N`}kyGKDr27 @7;ygⵧ8+ZQL[gXI$Y0>N2yV6IԺQlO~`8vYro.Xݭ 1[-3ޕJT/iʧjy#v?֔Ur+S=n@gᕻG4yӨmSVw.pxN+:ƬR8eBҤkkr˺E;y?UJ>ƚIt:U"NWRh<*<Ϙ+`X&0[.[EWw̬1YԌ9F4OX?.'LS;˛"L7TsQ*r>~OE\{İ2jGLv)i EŜ1Ҕ]﷩%A*aVi'ӡ> R7WWZ/aIC&|qN,\T/#e?e`ew&6WTiLҵ9QQWf5OyWϧJVQijNZ[FvDs<}G5Gپ_q+IGsG#&h 8'St%2j{_ ܴєz(pLjTU,'5 yJέ*T.dh, G+8GcjtJtHp,H$LCsVmgkTSooj樯&g D!h%H*yk#*M G!o޳\Ls_RUVܻz U)N[HÚW|ҲOVh}uq"GB,O91*#M_:b)9&M<2[VʭWp'Je$ף-Io,`3Z.mr4yߠi%$*r ctԤҾcFp[gߕk'[cHԣJu:hIio^t3)$ f+ج4x+/CN}4VMv\=}+Hrt2NT̳yfMͽ!tϵW'RөԑFX`H$E,^.\2{*ۖgUHR! w4&me )cc'SV8ѩzPݣî9'K2t:'Ery.v,Dcp9k)4G޹I%*G@<J;IܳJmֺ%:"e"_dѻ {X{[ʫu#R*UiVΠ$3[޵t:m̓GprʽJ3O/w(!ʵ:vwױVy$P n"2G<}H)Z´K]ԑ3 Ks>Ug/uؚ4]ϔF3޵ '7g ȴҗ/1iSӞxsZKEsTTM6KYchn sX¥KNSB-Ыuq{bgda[ _~u5y]isJUaXxy 5{ҖIlGhftql֫UE譱*U+1g܍]v ұŠQZnROz6г圆ۜgg>ZͧÆsr{vDf,Jb>۟L5O+ZN4^~ͻ(Z_N?>W (Iw~5*ƞ[;-[ė2p!X\~5Ҫ9ㆭʥA{[CNq8Y*hPc4N-)(c4YIjFVBZ ʢLҍjj["ѷ\Z3fe?e XdVoo8p:gRe$f,$c-vǖ|z稢̢o>EZҖ!ӕDkS(EΞKU}Nl1UU*jvn%s{4`3$*GE6뮢%Ζ̑"IK s2~VqRw"!]KN[\mݎM>iT梨sZ:zh\,o,Tdyz Z#9QDRhlQrHɵQ?JRkwBS'fG,&6xrNkZ~9ˡViW\o~H\^LLN4xcZ $fẽ~Σ*ݭGG'fI^02ت+=ҜeU-S]TpU~L{;Q7чJUjM+yn1 ln͸aP|@=zVןB}SLWo&T.c9%=*.=蠵YP8,0X圽ۜm%dD@>]oqZQ&aOӦ tnaX+fkIǕƌNJOo3]Y d\vΪ{4Ii4%"$XnrJ<NesF# hoWi#`cjZWSkM$A@%H:_,]IT{TXxfORˈѲPOYrosYC{I-wJrQ2gMSP%kVt$,w }O4Guk:|7v ,=\+)Օ:.u0iGwKI))sNJ攥-4R]W{P~$),"YSSGq>kt9SM;wD1ZE]x5Y ۷zcg:jkeZ=KTV+;E*awaXAbt'Q:J]Jh l9㓜~Ru"))eL~dq69ʖ}iƟ8[Zv fg{&XsG#Ȯi/SveSؒT]̤}<ߵUIF5,Ib+FԧfJV=ƑWhqpq?Ulk N+\ZprѲ;O>ݱUNQ}I^i{h5,o~,2NQnv %'n{9*J1n4DjūvV e9>Z~2֝T[>$-YV}X9Jw 4£h`pAvw0j14WR,1@yg ہ㿭g"'i$fcGSijsί&.zG5YEFK_y!Bݿ{~S=+KvJL ¶sjumYB,k{͵؇8~2QƲUUiq!  ߟLW]|-ǞiKedf?6*+igauw(7ouo٬n0H0c${~'q*s4YE8%yim̪N{g=Zj2dфj֝K82Ťb$m9W=ZSh[rO,,ٺN|A5*qITĺ:tKm;Yt:s7i/TM{ ޭ=l^dȪ#ۖ@ьR5H$:/_'9l3+֧+{ SWkN+#2ȋ!va t=9 z^s5~yvkyi%Ǚ |sIA]$bQ{>ƭ̒J K56+Ԅn2 );?ϵt{)8ލH䴙PG;kd9=i;(N^[?!e3Hd<2=j湝LY{NV]5QaGc` >+64wD^bm;}?ekb%I>Wb$m)]z/2suf)ZE94ĞI>VB :VQJ4R)6v7*8# \h6aJtZ%[ |GpƟ40a#4O#[ O*]e-叛ӧOr+-/8œiI[(,|GjƵ t~K,Hv8ޱ_;wJQOU6kPGަ6_ q5>2I88yZqN=YUas9Eeٍa#y$rNhnXXd @d=OZ%JJq}j,y +kId޳"dpA #VyS{W4y5n\4"ycܜyJqr?cTHluբ[MʽfK, n0,#Lz}^tjQb&REvuow_LzM{ϗԅhX=&H`\#)$OgNU2siVԋM5nkvmKYʔaqyJ7HywYTcDhE>+T"N]1TQ+AjmNcy4rS-5{[{[l?*[%]#(ǝ^߉SZ5T]h涏UǙ &%v0N2Z:hTXZr\[5˫HKsqũ}OUE;Bս8eF97`6q5<.=;^EEg7 !K?+I#Y՝Ҥc( }lG,ؐ8aO=O>wg=Jr|"?g?3l 8kW䓜i]UL$}Im3=q{z^̍%f`UpU ?k5F>Z^H- ?8~o-QZ:itcR;Mm*)Nvاv+T#:Dm%n"KVkC嗸 '\)QF*J%N?g.0jVV,U)VQZR/Lq130`݀ϿW7]\*rs)螃6vl*LnX-z}26-(xue ''5g4jRcy]XaG+*O0FAkGdh§$XKfY%Y$v/̸O#4{$l鴜!$(v|q۴c;xss[Hq"j\Rr$ec_3$g qjʟ2"1Ti*Wcdϡ.N" 6S5e|VTe6)Ѽo^1:!}~SQFR_#\MyYeIY[8=󊊎{t:>h.OG$mc\9{VPR)+$_{u  m";uF J`xQR}kiRA* cVbHnv {8ʛ=hF;gK4m Gh̄P@øKhtV $jp>.+{VSE8nK`!IGclWmIQVڜF}ЖWy$#f#umEIȗR P$II2{vqýT}ev1mE&;v~nLz6[5e^7q\i8b?֔)ic˖HM~f` %t2ͣf?lKq4c(T\ 7}Q F7n$3 &?Bj8/8ɷ}zd=ZS*ݔM)6o~Ϩ]kI1pnqO^?JޜW3},Nu/QţWU(&}{.1{s\tiI{%`7(q-M~c:zt_i:r8Ri؍I0&`c_khڜޗ"asF'|ʟ30~JϖdtS4!]Ͷ/=ZIKJNMh:J.8;S%a֫[AѼvdu;snTI4HVIIw;FU 9#ZIFd- ^,,3+ߟO7*U'u_֤W*;#)9Gone/V%f}w'SF6gEZ)uoF^@C{ⴜZ"WfWgXح|;ۜq۠i;.2<}@PRycK۾q0rA`CӧK^c2zw()SޠuEKD2c5&"d@T4ZTK&KOZrK=5܅^)|>z~(/2hV%)KEosnY[o+biөNh7nKaW%prN9#r߯SolkD ȼ~NO#ON0zEF`ore \cU¯=3Mk*q;TRN{2yI(\al951^εZ=-ڡN]cEf!Y{J#xc%؎kq&fcM+wZvv~֕K-5#qm"*WNscQV^=d7nsNzu:Q#;C4qx ny581[3%R~^KNi n$vvʻ3 1ҵRgӒIEq$M41&;'GSz#ԴW_8xa'OD:Kn, yIKIR2y6c1l>\-ʎG<'GjTڟ_Ip<=:Na"Vkj3ʨNάehfe1v>qjU)vMJ[ qcvLRI8̡4%R\0uwFfIIsK}:J猣(娜1faVìx폭c$ܯ'e&D[Dž{ٚo3m<d3S*ʥE5ZS^nv3LqD?2 nF _ßTz+.iVqj/oB~`$9YA%{枛#FsTpoK÷m$ n;`>^,*sї/.C|UU 9W4U8vАK$)fX۾93XՔVNԣ)^2M}Arf}y5kJ;5i++>H/dcLd"3>qɬjӃ̕>4u|ɮ®݀Prs؎湪TZڬ,R\3B$PŒG:wh֍gR&]ĉl2ki~yy-U Snf)%]'˹W#z}j>i-,*jӨz>42GK? W*mhTI|W6WO9yzKD5 +)يƽqr;9ؘη[J[*?u)^~Redml'5f6HȷIe*rC\Ҝa&bez6Arž#>dMsӔjԽ9jFjc."2#Ku.?3e}GڱVkFXhӋ[#Mu$F7zs,:eMJ^xqo#|//cמjj8ԥJv[VTZ7Z5,m'>yQ%o3tV"hnVEȇV_~3|N߉ZSWkd21]7~?jl쭋֑dvJua2`ЏΡ~9s̐^\FO**rr?!Vy$vxFͱ3g ?ݥi+簾2(N=?Lw)B߿H\7pmyKX|=e+ЭpE'*F- %p2q>єѻc:T뾞DwWM77Ix= i6aU~UWs7ްsSRz^Q# '\7c08=M9SvfU+T7]I:$+D N^V|]5aJ5o_X-u$[q]JpQ{yd *+=3{qUR2J*j%~N)l֌DY~G\v:*e?giEDEhR4ڳk!:q0rv{ dgZ,m4}PSVI2ݻvmxX:2TjU*~|T%edXs098$~UeR2W_>EKJ[onq\;`C"ʹq׏ºeupJ{HnV|QBꔉ|-{mrJ._{օVm!NUʲ.t=8{ʛRtiGTOԉ G-oghI6ۨ{Fqs_[5(匬3Je*1= -ͺDDP(kTK~J#JI%%ܷmY7|<ל{iR]lsJQF/' sewh1MQIGZkTk=]GGg'vwk+&9s0?>}:m)0r G3ѢKn.UU=Jr#g_F^tNZ6m.cўnՄ%R/ORZ=HwGgG]\t{p\-Q{Zźs0_-v1?('8֮JPRnCAn}9Ҏ^h1nkZ:~E{Ȗ_3˙~T6VcQo*)ӥfͫ}KmN4_1[d~Tc9SI?/ BJ>oG!?-nFb7n N;u.Jtʜa;ӱ5ͼlFx'oo]ң[[r_чQz:kZ˛)> ΜTZtb+R;fxSM^߁jo)'}5c{O).$KJf\H$]T*IdCkcD_)\g*{^εrۙZo6Ld^?Zs+SvFI$ڑ 6"pI ?ta'4#yBIN淐}胆hCvvs.H;9{97}O@tqup&s#A4BeYfsGw9=yuRNT%zY\!ہkӔ4:{u,K2o;Wo$} tУ4kSjIl9B2cy9?uƚ\z6I,K3adܙlӵW,w"4/{uJ F'd<`=(5ԉ4(+"Rk)eFg<շ7(R ],qrpMZ׸,y>`<9GEM易[yсݱ7<~%%(مԔwC^A2G,Cl[q֔~֬SiА;ʛ`7omx߱to^ Q.Vܶ}ʍow=fma8ToyVZ ܫ岄l،*댡}>4fTǖ$I=E: IӠ"Bp@-z~JFש5ml,! Fݽyc+XA E۹A_ҦqԪu#4KgA B3ef9P%(ꖆ:5ٌdf%ia<6ihՐS٦﷑sUv9Q=>N*5,DS9QL[U KHOk?g+>M~c̳n?¹ N=z\2 i>R͖zJe잁R\ҳ1^Oƍ% :uvwI\1;)u`K4` ֬ԽU;p ,Ė|zw?y3STc$eDy-8=zEXП'**Gi1|ۻqN}%)>iTk$|F[߾B}ϛjƤo5hJOJbXEFde,ǿsW?[rvb+tj]nnzmS=TЪV8^y5Gxwd)8=k4UX{iYI6+VUf;}:Ji5#Qd ʊ?cq;*#+ܻHŀ7˖f%OvW#[:ϖ64-RCO,dV,&~SֱqueUU%&Toׯ}Tc)c)+if ȉVA&v Oʦ J^~oKMх G5rT:Z#Q/u@-1Fy'=r?|G޾[{QIJmzzʻnomͶF8ʹcufNJk[W/,Bn`w9USJ>ߙTSUi%wE `%dԓ}*V!sZ=CύIdF c 0zw洧K]&N\]_qm1nݻ+:э7UK= FZĎ}W?7=pT:U+d)>VxznuF5'){pيYGRg%jrMNj_Bg[?$)s3yݓa5QE-hyPB[]nF?Gk)n6>F~=+Ψ+v"Mo[=zKL(]̱;zrG5փj]'C#Xwq9y^79ef?m&eT[w`wQN;|z9N[\:R/u(4YdiGĹ83S)J%(J+[]nǷv g:(Dq(`w1Fs^x\dQ[i2ܕ<Ş$<˛)eTeVrų8?b/r`ps+5DwrK&w5J~kG˪[4+vhYRI8z׫25=\=JxxϢV)7I oUfI9^U#9⬶=Ԍ1*-q(Y&Zf -r{yǭjr?wJEb/OM/~]OZӬm г/ZꌪU7qά7V9MԶoߟJjJ<~%vMis*Tcy^2vG_X1I}+\s99Vek~#c7 ΍=}Ht]oȻj麻G|zdJuM({ngN.B7[dd-Glⴍ|=$t]ӥKP#z-|nT~d?#;N1ǽgZu=i^[:?QH-s4N3ҼqC5{61F'$t垱G=Nz5 żafr<A=U9dgsSS\]>;GC7˖2>ּUI_Gc֌im~"YAwdon 95kz^Kwi͸m3u+~hTs)ԌZRݴJ<`JHhNzuݣ4)Kx`ہtrG]6 v/<fI8fdRgܘ^@d+nޜ}jqD'QJ׶7T/u?&njTj(|U2|pTj:4sS;z+fڬr t{UFs5+J31rUn= nzFHTtߗTo ` ?AWөrRNۍqyC\cu)+XHns9zcoM uQ];" |ww'k\])=Zܱ]W̛;@?68sQ%cUIr҈ݬ~U]aʾykڪܕ:t=wQRoc#++Bۖ5=`e4yRrzJYw)NA+VvHph´[lmtEl*|ڦ͆b}=hƌl~ʋ+d2 N.єgQ)zc!դRd:kTm"rEFQgڪXm'y+~tZBQ dvNB},3ׂqMV莕?=ʏou5hTt˴\cE\FeFQRM,'y| FO<JKdՍ6wЉXj3y8Zwq%vVLj7%de^rz+F~^gu⸛R*Pv[9¼(ԓmk:}>XhWpT ~&ƑFlG4i*2Vф2O,¿u.Cw>û1NU4؆rUi?75*rujyKܬ>Ur21\#Osiө.Y> rv9=xzWZ4ڊcT55Ѽ`_?ּڽ x:rTyCv6#(k|qI?9֣*iJb')mJA3 vq\ zcti=llkgw \=~rl&4Taz&5c#ji4i,<y.l',ˆYLi`G:߾]1 n"do2@9` hh=>ʜcN]%̂uع] q{W$4e_AҕYMTxybӎ9wSNPvԈqK~ dڬKdpz]9eje 1׏kkeomsF2#i^f1*\M)omALG;&:2}]N24og۶Y%'ӚZbJҗew°Oň=}=ҷ֣Ri68CFW=I]a#2x]Pt%7P?Ox]/I?va5֣$H"[ەo-Wp{s*QlrSNH&1j㷧R\V=HwoĎ e@ˌL*!ZݿogJ/y'@cˎثRkE½4漅*FcUe0N}WBGub_bzȮ#sd7rsך,DjbjL_lvR+;u޺0U4U%=e>U+FQyw4a9jIb#)/嚉N^VodqZ]BX$Oݫz8RnOR%R<ַfC碡4W̖M rOsp3qQTy9UkKoя M9Vx`x?Oq˖49}gpK ( zs]eNRU{ikmC#dUffqұv㹥ZT\uW3өR4ҏ>M79tњGRs۔]ddyz{iװQro[$˧)6ޕ94VRt֯OCOQ~`ѣ,Agc|N02{c'*Ԧ5cԪU pw6c ,#@݀7p1K9E7L*'FIJMjIO-Ys3` 9#`cyR1jEՍZMN*\'|+> /r˻];JRk⶯:xM>b {yer=eJoISaMcHf757cyߑabFTԩO-cF=u5%1MG^?3]JqkB^׶ʭ] :Tayh>5G y]kIXc>NN{^<4hӖZwYe{w 6hz{^ũB>f;l ҝ6Y-l Wғ >[RW{63[$9S YJ%wgZp?UbЗ-k/;ZOe&o%ۆY&$Y*@wa5!I.-4{TNT$٤k~5YIfQC:A氭(΋NW \,w1ži. rrx|cz.irūYʵiœU^N.~.'$?q'9Gn)aa}Y=֍/C'?(QO]hzjEdD'l/r^ҺSUv#0ue ǚ-^kE᭟=+Igo5(-<.ʖeUp?1θ/XOѽ[zE2K NQէ{gum=2Wo|$_C*Py0[ȬZ'*NlwקҼxP)K~kʵ'ޞku'o,fRYIi#R7{R-G=ʢO>EE؆$I'ҫFqv}^O&x$n?.E~8ӿ~{99TeVtV߈-$+`xlzZ^VkQf,*s.Ϧ?(ߪ#*tŷ Cq+0i~ёΦ6ߘ5QGy#,c\,o"9^p2sw3ڕNhI+si*EFH% Uqlzg>ٮҌl5fUrhsqwtAf#ؓN:Tԗe_^r3nZcfe~FF#SNRab%%Eir;x695hJG5Vc I˒;0H|woZXVM(9Qj1鷟nh?3V4˳ƕhsO`Gk ݳrAkewtƥJR1G>c|H7e=*}Jzƞ+3Ij.jTJ0OݩgijeYYwJF9ӜVUtoiu=o[N_ҺinWkM]9P/lˌnkG&kjRNmVm8FD|7mt8;zTF̽.I?m+)M4W p1q[ΪTBNeFWnqmQf g#8#*s}؊1ZfuLX~^&YQ\(m9یwr8.uC>9GvSqPI dcuaܹ#)S=yz-.C Ca5<}uH¬}lg JV1vǜ>*\S|oqAq7y^9̅]fYj70nuJjP(TA|9c[C[iN^VKO3W]?H ri'~}[&^^/zOlEbttcq]Q)Ԗ;ˉ.%f}{eSZ.Ubigb0&8ӓmwUlOq_8ޣRfwRk7lS?/ҵpΥ-RKJhx8ӵnU:ڳS_>7/WNR8eVh˷“:{ztʆ#{z#"آUUp1YKQ\buͣBߟR(ʂx}=ftVY2X f[5cǻ#DJXyIOn MC@!l"]#H],<餓%m*ߒ+IJ.6:*SShK2M6XLF' qxSZJK^2U)ϒ/UW Mw65n+Y<ڼ1W*I=B1;Szrc(KkOަn{W=Gw>Dyj{9cNT_4]4@ae߹S$ʷ[KpX\ZW0pq#R=}Nۚ"ڶ]Z86.{w9;VRk;OTpmn&#ϚGlW$n%60ƈ~]:'W[|R]Cvҳ/',c#:1Tn2~zi#vᾹ(\jJRqeTr1({r:R9^Nҹo]ٗ zֺi2Or4 YY`U8ǖjg*Oo2t ;EE6ݕ sTߠ5H?yy`==k'ͬjtR+Kr;ɦA6H?)rw3xӒvF5*ue*iIr*\܋ЇvEP#E'>>q4N]~qqq+\ipZHdkr߃]1ed&JQrIN7Bi?G\5iʒi-9,_+}DR# Ze.Wiŧ.+n"ioXq#5m4gv4v 3+:XoLTʤ$s@LYWqUsn(Fy"9vGp35رKQ(Ym-K4v˄S5mtG=SGEJua{~[~ tɌx~^Q֦1$mԱm99!LxQ2:}GO:c|;!Cq4-+F3qX*FɥL !`8,<GҔTFQZu¡FO3Q0bC2Hi wr|WDo:T'H[*F<o։sF۩yjJh9ZtEy?w?_8 ֩y̑EFII*;kTZ~U:U% NR`d˓n1dPG;uZҜ]_]wԪOtm܊kṟϷE86i8Wm㼷8Ĭ :Ƥm~)F*TdؐYymim۲ӕIKiۡ4aEF6^Ku ڹ6l ˯4J52FJ7I-][3;,1+2v䎙b+(KкeZ+Z=^ZLcǕ_(+/&N sK1RHҤD$)'#qetWV"[-4m*݃c9<.3I˖*MJN/!cxk;M/}jFjlOijזmj"gd\, NjIItp{)kb RFS*w`#iTbkP,~Q'>OlV1暬 ai]Niɤݛ#1ȓ4x@⦤K*=#$D"xܲon /^GְR2:-k")ݷ'?w\ZtZ o߬љ/^3G:%^ -K$ƪ2NNp9?X(hIΤp]IG;Es=k67g8fTN01II]z*.!+ V9uw4%]jS(?3qeNaSM[bKpEnTr?ɮhMj} ÙHmv>l)$?/OLY)ۙ۱R {͌3cA~Gݙ*L}h՝G\K.qEOg9->H:\W~հGk]#GI ӗ(aW2w6Ғjq7tMeU x0W/>sEvf*"ߧtKxܟ;Ѱ8u{4[U'CXlS4H%X^z޾خtd/#u=4ճo,Hc ?v9m+Z-9F5ǵZB6w;~+g)/?)^*ioK/AXn?1U}eJ#} aHtj?2`3Ћ=r};,&X'$ };$B4ۧ="Ya/)-&^?Vݒ:>h>JFfߎi(JݥdfcHG1Y8ð*2RZ!60<6v n9ϿZgzXiԓܮQ267nwl`<.Fak[F] d9vsYʞoU2/2xK|ƋyU*?f攤h&@av7sV3KS(7k'n- hݼ]`J8s](~oTRH4oGIZr9R{\ýĒͻ,ŋvFh;~,,(Y]βjʋvX7AjR{vs:ha<6 KqszWp;nN5#(y$7X#JDq'=.@ja_#O4JQv%Y ˹x'ORkt}CZԵz}FGafUɌ=xU:x{ZYj. `{>n1c-GuJc. *Yk{^V.!S eb,|{8 \ǣZU}=E̐_'}N6~ͳJh+xs+u-{g⢚]љG8={(|KwF߯IAI{kْ7$heܬaߞ:z#i`OmxS2Op;+2U˺ᰕ#N~^m2Qt1U*|V]+PG ˹f;0[K0]Fӯ:۰F3%t&m݅~]0;~++NpnJY8g|wR(FkT[1ĈR6*b:Wdp=x\U9HG@3 YL/l~Q[xB,ĎIs/~IHHO^3];CU./RxJŷ21W!sֺS79^\ؑm^IGܧ$#Te)Ghw{yk]9sM:4yy,'c Ÿ ]1Qڒ:q }I<3P۹'koDIF7t@VeVf>e'tтsQ.UdvTFrHz֑3bDr2[R"rYZ\m+x~qֶ%RIA$v\ XqǵitӚ1݈i'YWp4m9[MEr~SB7DYeBH:4lgR斿q8y)Io$f$:U?Gd.JTEeQ9=eX#U%i}ۯդV*e̝MHѧS__119YX hDT'Qcx"{vQffñi.U(ƚW^p{nIc?>4e.V9Q޵񵗜+KufQm.{?B )<ʌB̎y W,m 7N >|˸=5-(&NJIP7nFF[S).^oڣSӢ=Vk'H[c>*d؎ocY5,O"DzV2OCݍG pZOun8 g.iI73:ӕIY xLFsoE"3|VW)sԌUIrڲHIlʨѶ.1=GLֱ-S-{fq7QA;Ǖ唹o7JZUv06,쌽NnharcyJٜsӏmN/5[Yd";;OEG,~.NîŕDlۻY8 cŭt䤤$͐хi<c׎[NEN>O^̈fY6l.$oQR]YC R^\Yr\F=xVRb*S*)/ČyrQ*ҷ^p;s*ewwBZ Zʶ%8oA\֔m#s^? v1r3b}zsqMqT)T1/Ffy氍9?Dh{&X%ήB )O;kITc1K.V4LȪvocajqQ+JMQ4ѕgNsۊq娹ӷys$Rw}]n[bVPvn8'8gvwIT"s%j*GA !hsU#Z#8o/-C8ԋqaN^Λ ܳڪŽ^5epW3\1Ng(jƎ+ݬM5M2@`YeU!ª3ڳ Ѫ4=kEG 󙛣rl}^Iu:fJ*VVmWe(3z~i>X)s-aZtU(jM#+vC\weXm76#uڭ ^Nsҹ{JzTz,\1u|ۼv{qHcxקM]u唛ϷYF,+ԁ\}M_5Oi?u TMZմ-V5+azƷ: ]tӧY hdDݞQ!UF2rQpU:UTԙm 88|k7FeR}<`_>NU}ӡ HӳFUkk ܥNArğ1Zѝ5yƦ&NEԞ̘r>cq?uNR^u u*E¯ˠdd̸o?G樚(ʕDlվ`nsZ(PWNgha)b<%դwBW_j)Ei})I;52DDj법(žz%6 BMiSisOmIshq~>S ztSh,J InbBBzzu=(庵΄8%)9EW/.K'a-VH4jcV׎Go^Pw@IVݳ ppGVԣ+H)Q_1fU+p1vR1p?1]#[-n$QG {4]O9{WD4z+\Xh#K1۵jTޅӍ;'vZwaV5Y\zUF59ЙTPC4Kw:܈PKdWDe%1(Isdt{,I8?%-nE&:d\7Zi#F>٧a.$GF{;`I{q4@2MW%. Ӱ3Xjc|/OC9K~Ǥi'NUaV^9<Z_gV{I%{wH `wrFzQ4&GQ9E,~#O#$`uOE-oI&6w~\I880*-egǖ)~bKrV[Xn@fsvWkI;ѨEA9kxWfa6U.cxTIekhˍU$VMŲz 9g8RN}ͥM**I݅-Ǚ30f:-h.]lsJDRhcYY34.9ڪ)kjOZ]?vH4<f=L)֔%cNGy+?7YȬ G~3NREX^:||hћˑJю{OnyN4Lj.fVo4R/*F6᳌܌2G*p0M4L<;cln:e3QedҜz)32n2N0#t+Njr_%nEK<6d].4QQ|=٨6\{]I?JU'sEz#ib*T%K*0I>E1jEB[cIETq؆ޗݛ&ǯLgR9٭^Fw\osm?| {^J鿑 Q[^uP8Djnm"kuHa0=>~Ts|۩eEKWr.~(+26֞Hh$r:FFqZEszrqWd(<؁p$7!z35Ysb&E'Vmʎ7L2'lv6㈼$~cn}7цV!c2n.TIw3#Xw +/r[Ӎ%Vb)gE5aPǿr ZH17*&O3tKin?JдET)Ar;G,Vm@#rs_+;hKGYQ՜1finu):gN^hU:U-[xa8E H,HL=U+JzSwrR˶<* PI':V5'uj+l(wl9 q"J-Ř֩Sϣ_G2۷4``+\҃[Ѯڑ"ݐFx{ʩVyZ8Toy; ~1~?b+kjpٲ% U n0n?GB+\X5~am`w&ۛ=*O<j9Z_c x hd;~wJJ0)(NMK[]\t[W˷S!GQ:z JEtVM{UvAf5,|Oc؜=?***-lR2Z,[[o#I AA=zV3WڃB@ErI~]˜( p8yNO{ Y8o絋7)FVO^9ҸqOUT̤ёv|ƎJ'\wsֳ沶^6'RGGU_{o$w ]B$Նxy8x=,nͥ5tkB;ŸS‚IPǧ jn)RJ;>W2r+(1g껱߁ְ(8ƱPԟy7"I. |R8}+[OufkdFRFFr {Vu>Bh%VF "˒̣c9Z.HVaDfEo,/dϷq{~DWYINrUۅ1YeņvݞpxPRI{b:\OB9X~nY4[G#׵grQ׹G{5bۋZ/,n^Qs.kb,]+\d,~RGlvkBm{7oRiƥF0+olFfvv1-A\*TEƥ^OkA^)!,đF$?47ˎpwtⶢԣF/_["YHmIoq#5^9Tb,=>k}Hfk)vduaxJOAח'ݵ_??-Csz[̉T~8#$c?p#s+Wh*I]hz fQ6崋= + JlhcԕKBO[]-Mʃ<rx{$޽[йo5ݼY;eV8?Z¥?{u;/]-ث -V1v 烐nN1S\z/續Zz--u- їA{q+(WRb!"K;?/zc#r@Hۊጤ9SWR\]7$yXBάɷR6En$5v笴Mtv_PRߚ&>T6M#yAhgcvz"U%$٥oPyuK!(c.n2FX?oI鹎-eQb3՜X<J>tM ߨT9bo-ݘ7gjpd׮k:QZJqo]&L)n21TM*e8Cs/ʣYH_k8ߑhi')SVwv-;rA {doNMWU#=In7w7=?S[Ɯm-N\fjm!s15t8+ة5Zt6;9D*{c{\>|6S+JGm#vm +xq]^1Vz-[wvKM|,%5 3ϷzhŶAJUOk!9TѷE۷n?&E?yV3zX.b503n'OtFt8:y`8^O)c~8{{蒼fZGdڿ2y{=*aMZԦd)Λʅm?@}9*.mSF0rzX+Idߡ \"QYu|mEզVuCo4| nrtU:ZtۤCp1<9EAYX<ء$Gp1]d]Oӝak1r[6ѓ[rqGDukf:)L-tm= ֱ9#˸6N,Pޗr2=:gy.N㵉VY329N1Sm&U:ؙY]/{,otUeW;gS(hvI~^7#e<g9SouM9G#|6?FG=ϷzKHpQ% $407ζh¤h+n֣b2+ʻw-U9OtiOiFkj8W#\?AiJZ%CgJWmFZd oOoOpkMeU_Qi%D1"'VOU:tEY#+yL(Jy8Es>Ql!H`s6߼~\/L`t9;lc0O:2&$0-1KZ[ i-,L Jy=Qߎk *rPON k_eJL~4HᎤFt;MmD6ɾc}ev7ZyU~jd25dU9۸n9'Xc+Ԗڊ8mhf";`l\ ʤN>iǴ6CxMLgTJR̖)E3:[yn{R2m=bU㲚vf1zg eRGiƜv+5`L˷n0?j.b}/+mBI6p*BF9j'gshӗ&4qtʹe =0zW,LWޡN8t{W2%[NЮШ{::~c,D-wûZtUw:IcU{[7z4F k$U\Mg{tdXgM~%B,m/*qu(J:F1z}mŝ垨Z?{]Sͱl]%>cfRq{Vq˪ZFՎ"[OlLEn*_ZIEX)HֺWE6YX㹼#VTr0R kw6xc.8&#r09 g>1*?##FJ SW i+xo9k[ڣr,1޹ JNJ*ϯS*X$ivc5PdHRM]qy([V=бX&+ҶmaIo8e6mPN;bW߯SbjJ\_2GD/#2IԍDAF̵dd)I|p=@] jUjr]aja*4kq8XX̬=iFtvo_ՠWy>VBqG(~ꛌzSFۯK=Vzv+N/Orm>'MB|=}4j{FshXV]KZ5սْFu>R5f=RInѴ#ݴԜ+鞉KOGц]* tK6kR^ʥCҼ lb{{}-paYx83֕g.k^fx5T߷=G@Cq.6yj`=s\Hs+ɔ=7;{eCoۧgZI5k!FSn:Z/dfYmmmۧMqϥqTN^[李6"1IJ]]_<^Lrvwӣf "k]̼>Re(R^cʗ \g=J|Z5vQPÐY-!gU:΍6;dL1"Fۛ<#S-.t]OВ( 1QԵc*rrm 0c˹u ӓ*'تu#MXk qEw:;ON{W6[J.B$| b@0ON}sJ>3,G3wtqNG޻#JNH5Hn[hud+/zQJuH^NW|%'+IZi]I|w?mNVѽnt:=uo4ȹ*[s nһUE"mFB׌wGK?p͹v:q&m)Je9cK߁]qJF'ii?ziʧ4tԣ"xj|&N?ҔKvMJ*IJڕQk3Ai 8ݎu*ƥOh U*TgU(7#݌rFmUYl/\u9z šȊed].yskKJ(\C4"4c:~ t J0|sӿ.Q*F=,y^v#HJc)${ 4U~l}N+58gN؃e-p& #nz75NJ喍ݜ:M[ˉ̅mL׋=eT^ E(uGy)XFt*4NWvv3^f'٩$tTrٱ!y 0evXGYe8#9q\5#/wo3֜Ȅ|mkI&-9^}jsrv4+ N>ʔnW HVS7'=OO׊St_z*I{ˮfV"CǟQs^oQ'm=~5U$r|̞6m̸&OzXj6䓵rb1]c{v'y<O|jaeNIB7,og$C xfz mi(hQ-imrͩY%d`f1{ $^5^.Zhec=%H<)f;p185K ^oZjTeӹbRTD;oF:wNPtotR:kmkf,kI;y9oiWҎ"#QВ dѢɟ3nCJ99._QlW=FAQD}ޞ_Tj8Gik[XW-# 7q;c^*QJqQvcUUW}-] \tvϭ(Z7ORh巸^YB# +=O8ǧSX{Jw}_#Ԧ΂cכȓ êCUPuo{U}^ijI&?AG$:Ҵ^;TTkvdVh#xc3JQd⧊R#1ewmܤ|3R9ksSNɫ>r#,Rm,ۆw)5'k}:t"4+d-SsGlf-`{W58ԡ%v˓87z|DWn27^#R+gS! Ĵm;$hǧSӊʜc9ew)U6{vV5ܟ;Uޜj6 $lKV̱17oVw-YGOUZG<*'AJס:UY{#j.R#*򔤗Me:c8'Z2-\sjevŊkxݛzrtSVԘ?j/%qk$6@O5OZ-MʩZZNIm I;s&ͻFl[G$U)>{X$[}n q\R]zvd,Dde򶀐 ,Nmm@9!JI$$x|a۸8Q(cR*wj)TסNI.e"1!dA>;BRoFLD*L|n1u#yބu{:(gЎ{knOަTcZ7J19|9}Qho9uӞ+Jt]*zq{+3A1[FovzDJuʤjZId+$i2uy:q\iԕ%(ۣ6F4/ˋ| G'qS]q?/a{=Dge:zJZ֢*|җ+ztKBl8\+G%Z\N}1qt=ʟ4dJza7x?q'>jw4F+Taݣ9*yǡ(R8kFNz+DP"|En3=:S(K楊V;Ovi-6H# A9CokƒQ~gݷw"8sӞ*SvN8~DԮھJkݷ}}N*7}_S(;?Էb ]GF6FWo ax)3ӅH_H!_\# z_I/dy)6i ks'{< )Em|"[?.<5,%w1F<~\1^ε%:kϸ~ P+[LTi׏¼sYv<T$P#S,f~fXd$?:Nj̩xt$R3lsŠ'o~u%?,C ,vH֒T]_.2*hGu{/㍷.H/a^H9"-j7_;_44h4MFGdbg{w8mbc#}4wfٞ.: +zNh$.#HaRּ(ԭF]=uR.cQ?r2XRd z q{*d˹TۮSHƻXl-ێ 9ϸZJTxxl-k_OCJHl<ǜ8`>\O5J1r{#ͯ)8OanHs8=1~5:cѥ+ak>K܀@o_ʶF}N5/_-tҵi>k9<H'⾖H\ӊw> NuU#kI=OӿJ㔭[_pFTrv54?3:\4J܎3.x?/NTeR1=vӡ|Mw>mR70 .Bxcc^0q[ő㢪T#ɼq#Ayj?xO$Ark_N/}e,-:vuM}I_:262m``{־GNU(PtZl^4ǽmۚo-Ur29?NyZJUC-4ca^1gc>;4H!UQWRP.ƺzrhxVM<'D|kݵYS}AR#= u1* {ݵk>S ^+Ii cpCHg~_S2W,m-%dW;;yXYn_kU=4z?MzUU9@zJ84vWvaps?zZgh>e]ȻYe "Vm+mL^-w漋qBd1I?.As}|dT-6֊i&fO{28=ztxԤN)uGE#Go#@Y@\GzrM?+aJؒs4 mؾmq֧٪VJRwmĂT ,jLNZkm=kEVolI >H9ۑSZ-X{j"yyZoG8>K_4"忑"+y7eBAOa(|Dcof9[%h~3dwYҪW1N2י\ #VƧpA{z)ʥNVJoO#!$U]vl{+QGqR_2ͥR^(qrI뷰Zӌe+J[9b*SVI%Ef .0fBvޜԹqJgY. 1(KvwMŝ1NZNnΚjr>^wgتkNبYԌEyn W)Kv_quT߱"ۦhLvQ #?|6L؆HK-Ŀ.]?_kJ^Ҝ{Js+7mkyY#.q=OJҜ|ѧZR~OeNٝq`1ߓIsiR+ثH/2dꭓ qas܁SSFR]ޏU9^N# #(QА: )ugJX_F+Kլj/̱9%`~9tӥVurUsզAFb`lcOOƺ)TS'kP!7 U|1~)rt~GuLz?!kX&Qߜg9N2uNt-#y}ݓ8t9E8̾Ft)xaԉtn[!H9$qVQԔ}]HF]D2Iz0Po V)b\u1oSvmn*Lw/ҧN>dU:v֝w\2$VSgդcnȭ!u**IcauQF^g=Zԭ0]Op1޺ԧ{ETRЂ]Qt^iKRGTIEE|+ ԭXT{³.q>QJz5bN㱻̋&ay 1MoZ1U0rw)%ҩS?Ju= :Z߉V8hY|ˆZJ5Nhcp~|M5U`Y74Q#O8;$o%F|G?ׂ?֮>֕{Ѩoz)ۺ_a穭-̚NЃL/ BOmє[+w6m0>/ [pR&a5LҴdBY>[f)OKFXu)Vt`eG>)^Kdvʭzˠɶ,>Z·ͽ5G-&vE*Hcջo*Tˣ}3p>qqϿW<$mבhi˕&ն̲<Y[;d) 899),(`xNRe?z:3g{XtYAyeNr{EDZ8VhgJ1'{i*yۺ1/;~b^k`O1]/;X)GSܹZL,!+Xk_fgM^OjZߵ啗kc 1:kQtt֩BxU}b-nu,F:Vggю}XT[}NjeN)QN>{- l㱭):tܭk#Ksu&Վ!Uvɧ9Җ_1GJ-mHu1D3aOZ#zhacf_nN2&<7mžޑm%Fz>iǚ7dի:xuV;IQg^ZTgȉ)8Y5ﲰKlalJ)ESoc*1Ki=OGKN^Ri}:#q^VR(THMk68N]GQTy̱Wd-_bi _4-560ڽY,2BN쑳;+(Q׿}zV~Pt:e^9s7OGX "ZY.'dƢrsTuM<ɭ;&Y&ÀK =z}jﺬ#Uzp}-o̒)~YeIQ~I+`7:U9U5Qjs;MUsy`nտ2'sny %R\ɍ/ֲN\4ԗRm?5}Vu <9# Ӗ-?u5mgmbW9'ֱ[Cg4tc塒I"$ `jiK]>DU`[/@W P(Ă 8qG|T^s9X6XADZ=*+I;~Wͣc8 䀞q'xtR hHd2W<_,g#:>SL>|c=#ǯ8PtFRIK[jhm"d!Mp9{TÛ+zoO>m&D{U_rppFs;u漒s*Vi%{;Yh8ʶ@(6{}j*r]n>XDg?UʹuNEKra;qmlW ~t:G̿h!m™S#Gӥ)b*wj݌cTyoؖ:QP_jr-ۿS Tٿ3n#<d]B6[HS3g8tN^;kTq3&UFېN@=?ϵtF^8jUouط l-J1* NsԞxǥ8u#ZBԱXC @7ƧnǯgOU4c/w]G}S N^::r˚{L,>"5 pstEHW]J~ tq6DLx]9'9knT-R+M5F?K)xP͂23#Һ}4 u#+ZC$J?zUcFT.4-QolҶh{~Sr7\\4eю8T9M#)F<[Hb]|-IUs(RrGNWlV27t{Li 'JJ1HU\^Q>XܩJXi v(;]%ZqjDǸ*n0G):n8#_^NһȣΑͻoUihҤ*lPjb6CIsVRsŸM5tAH>2qk(UaWi ZUiv#j>UjtыR߮1 #.ysN=R穈֋+Zo7+%܇q>1rEt1\f+(BѰrCTK/#v>W2(/Q76RUJ*GWcl9fӶ=z+F4Dfr՝#hC(La\?#(Gtlޣ2OxP6񜞣 k7;E0iث-lb<.c+?oNNZ[tRrKC[y <Nx\f̆k[X&u0ڽpry= p?g*Н=7L֣#{o*$fo2?3!Lc$`d}+<Ғw.oBVGn۶H+'M\湔l)^RZ7^偾񒏅L7ߵrN:uJ_[+ˍ.RhT#k[kWw>5(4nnq 2|.BҊqeQCEVKEMӧje*+TdҰ;J֒,En=(GKk;:`[b5E Yӫ.VXLa'ϡFQwu:KcE7WT܌vxoZ0_6)Q9FWw߁=Myr`#H泫-鳝F=-Wm.HdB+痡ʽFnrtLuqZ4Df!,jZ2/8=V3Mc[H>[̒b(}hTe9s#na&dyn9?g,=;)iӹrGeиq˼)lv?1\p_/qFȟO-c^ڱܴ9GƬUKʄvD^Oh,lbd|`TmdMc'GYjXh|U}ycҲG+%%[I vm#Uo}Җ]տt˨cK2M{7G^(ӧ+ Nn;vaXX,?-:} t<.xI̕Jݐ˧Z6]ptqASU-g(ѭ>žkXAȮr˧Nrbk[iI?*1S:4ji壶Wq_sf#N3j؈ʴTe; nNO֜F\}kkx"Gd.0e\8j2%)r{h30PN7zyiDff,|I|]k>Tȝ$) [pc_n<4G~ͳ˴R=kǮZ3{R5ҐFN:1wJv̫=In$=sZSsTt6w)WFcЍw鑟W<~e{)\=kSf5,2FEğhVy 3=W<ǕsSi!A"4Ml̫F<_ƸoՂW"- M+aWkS5#*.}wVDe)ʌ\sQ9ӴZcOBO=DeuR8 0bDeYr[_//#i?4B)6lq8C8)r(FUńCmZH:˕z¤djVQIر.2A)AϨ>3>Ӗ-I%٭R!in\f6l|1ON+˖iiFc)B"h| ܆\gQ3t'xFϭo*Ot]:2rZyNJ)N mdž{ȣTmca\W}8ԩ.Mtvr0+ N#xHdPczVQѦ?H߯%+0h *q 2⡊+ id085N1z*<JoF2дkr9 / ?+o~_̞YFbn^axUeQ tS~PiKM/у$>7gn]iԨœտQs}iͷ嵷 HFKFҶe'.A%2'_W#QPrFөz <)p͵6jpH_zEZsƗ&("Ⱦcn,9gi]T P6ap5M*PgATQT%s <͓O0yORI5Rr*{v]-a]Sp=}iԩe{j(Ǚ5-JnXAX?SoRۯւ #èRg&ch|ߨϳǏ)%ʫdc%(4rΜjTRѕV3%1{gS(k5c)[uܚ&7d5f$ \q=vEN[g.! +W9ڽqXԧ([ݐMg֚ 傱^s:sTOa2Hjc39@z95%nf5pBd J}5SwwF6rFۆp+JcTe iZyb3UPT9+ ;[mAOA ,3yedVQS5빝HrU%/=21c`OǺ{c54#xcJ8qkegMb+sӯ?q(ٹgs\nwSH ?us{8$ӭ(ڊ_[upۯ3Ipq׹<֥F=T,T\Kny-d2R<\ϸ4.]Z42RI!odJUPpJN;W]2;{[d;rF9,ĎxJ:8]|#(촙vaj֦cHWwC1s?Q唕:e(iՔnh%A{fTS mN-nQm2 [g϶:zbj:i$&9䍿 mx1ִj>D9X-UX)?olsœJrM=K`r-ĘizإNq{љ#|v#g#>%r~]=F${"dFU ̸AҶ{3^dБQAn{gUfEKk@O*j|i'ƺ!Vq)jODdFybVUi3 VN\%Ԓ;X6mW jm'+*N4Ӱ8kPÔnWEhyJ #=븣ʩqַBk$O${1SkOS(R ԲK.` ܷ<1׷򨌹i3J_m^yBдvrzҗt0 Ӫ8b1,'ο61:`ҩsk-kB2r]em$/'hǧ8[{U o k=sZqyE~Q(gRvUExnrVQ'IӴvdm: msHc˫rO/4Q"E]/–tڳj0ԙar:*}Ι y&l# nܱr#K/maI #;: g5-B>e;4S?r uyv1zrBfg"$S2x'^U>XgUN'C>1+~wR%AFt ѺkV3sQVԁ(ZK)Mh'$rQK}ء0 w08XONo!IT]`r?JѸZ!TqMUodZ(UwH2@*PO gRu%Vm`!3G'?/aָKI3%ZykH6Ճ8cENZww1]8jMl\3m P0{c^uԤub+N =ZȻ9%vi7)q9=Ic)F|rԣ[ymmE24?•G}:r4@2e ޹KMv*Ty$L~ B&QMm=hu"bF9ӻՕXʟ/sFUk[~6XIll_-3*YxZ𔚶 *yO"ȑ}$۾Os9Fhm˰+xe29=Jr\Z|h 䰊l(FFz^i΢>֩*J_5IPžZ3n29q*#.TmNӍ@HPyȼg?*W'ڔRMzy/2{{w4~g++m0>NmZbkesv-Vmr[ڱeȷg4Sviľl7YC*|[@Fڌ~"I$P-WIoU`73U#]gun0\8 csI&zx\UeonM^H渊""ϗ C'qW%JosYIN;5c,e㿥a'- :q %;Wz@_}F/Nb0csq),Y|,'䞝QkDVgNYT)-oM-&78zuc}taFu9:k{ʗncݓroXʭG%άB+=>Z%,s+n.rq0GQ^ RbJǛfxٮuNAU#p댊:s[v*u&WΉsWRKm4ŷ8/3nKLmr_ҽl-:|$t,-jVհd)\,2^x+цszTMz6pd/U"LsӾs8h;/kib@m|F=뢜N1w/eyfi2#%{/PR%wNPG32܊w?#x8GWv8D\ȉF=4nx& eNQjԒM4Jlq{rN*}]BXxJ 6C-eͰ-͏QN71*nUk;xR[f9<+Tg]RFl(>\pܨ!O/iwcsn_@9Fk͹>ΧkMm$U[t(}QHRizyMVFKA\8|׍8~Z6>OI;Kn]d%Wg=ƯFV8̕zkZE(_2\&?Z S~w]k庞;hK̋#ۤ#s 1#xU0Qͽ*\-nD۩0677czSùnaTk<Vl9ӎZrMUUFQt׺o4ҴY!]K7*'~X[ۿ2(Wf-5[S}k*4U%RM4rZ,Up]vrx=i:QWƘzΝ] /'han'*E:p~fܟI+~dPFferW*ufzqi(;ux>зI|sdsGw{mQ֧g-}U巅VO+.ZydauFqOڽlY>d[bm@!Eo̩m.]bTU3QqOe}::X_amsc$U,w'VZS۔P(5-+ۼmwsdu灃jQsI:f:vM[D bUf_,mSan>i_v(8B&$Vm6s1Js+~ҟօY-XϘڿ`bҧJ5bpQvWߗ!lߺQ WmDi֓Roo ЎLi#T]9GF*yҵƴ?yDUW8,y9\|Ğ7UX#ho5Rw'(E/m27 ZTJQ)ӔZFܣ  )7c r,w".T6$V NWnַͧ꺕R{#b%$?9+>(;' pnGUc5M/ 9k{hݷ}ė-l#//$cn=rUMVkVtTv ΋Q YN>a}f)ǣ[8Դ YLda[Y5=ڋЈˑj3}2f8L]cR:O٤=cS.7s`$-k~i;sBZ+laJ9_EƌdjylE\9Reh $eA9[B#~D\Ɠ_>FW5bV&esڴkoe1EB(˻qLGFbn2I L|EW~Qqۊ)J#O 4;1Ӷ{[rE{2sFUJ/rԔ:nyWxs>Zz3vWiE'hr}އDӕ;QZF{h&-B>xTJϯsҩ.W bbNL|έ#ׂҴjYJ)\@(Uu>9!O^G9ڱsw).`'G lBJ<7Tݲr9ffuVWldF9< JGc:,mᗨ?P{榤~\l0+"gv{ѩ-Y=%KȜ=,ʌ6|$72R}U4ahȞ42AۗC:4Q^NXI 'nՒrIqM[2LQi=+iB:2FQFIPF#Hj^OpN*2Z`]61# 7u-N\w_V+nEVrčߥ {r)}7~b%]5S+pR0n)mAZ6r݃`zOZQ2&ӨӔc-&Fx#9Twz~)J_ͼGY0(`±e.TgSR$9ՒVVXSV3ә\tDUArrH+ϭ*okSJN2 T/3v[8g(nohisIa#s_J um|ަӖYա{`vDžƼESF-ӷEٵ]ۙ\1߰ms>I;DZy3yT+*<5Ch.XJuzF[ڋTdouj$?Fu uO7}G==k 8}447T2Irؤk*O,qp*'(ճx4"gYna%o vz7dٔe*jSoж[vX^@zd?*/-NH+FOWοRrJrr9=~S^=x*q٫ KŏǺoH|9W"u:Y~gj+'Z;hߺ >ltO²')*Q)I^hZa?- CIRtJɝ^H-Xaj8OyԲwƤe_gk[@L~V8ss>fFROG ^L6Ibdi9#[Ӗ7**tufˠF}6Rv##RT2nt{ƹᶁE_G+j*)Ie&4|7UulzU%R.c UIV̴hak&V2[ҫ t* i߱xsGE+del|GTB5e{٫ui8n6,4Ob0tmeok? ) pF/ 2p{9sZvS憏z&pEdW-$skϕIFbԟ4+dL̻dzMrVc-:jN1lFV0,_.:KQd0͊Q̹v$6SՏ U S|KM-g_"4>\6J!zջQnO_jҧ74\{>#Rӷc~V+D+6c]2סP' #VFʱw6g3wʢn)R*ZlzQ)+岰#zqW_'+zg)O#wN<0AA"z⧒R?iZ5#U ?Jڜi#+eQ9ǿVќhׯŢlF Y@=8)J7w4q$`9$m)J>VH'݀19O\ͫf4cv5/}Ϙ߇5ٚV}4>U12n 8>4BMyc.lj_ḥe gWdڳRm]ѭtfT0PIxi[k;qc6v0'\|1dj*ֺÒ݌e!iMom㻵pj5^tm=]0|0oNr?Ou{JjJQZ'M:%S!G$yEN@U'ϸQ(V=u0$|UJ26ҦjנˆY*4fm#7Q-XԄRIM:4TeS*FɵYߟ1Gek.",E`͝1ew[c%YiNRsq[.ggY8D50m>=(%E+:dŒ8V5;.6qgԺiŠ^ 0f(HyDTz~ϙFuourt729I?)I>O5~x#|1œdg7q9SNթ1Tn@pd\zϽW=4Q;[qv$nϘzg߭ar>AЗaySR"̭~9JQ^}·N5Zw{ditܾv7ʤka}N\,8{ '%F"fy9WVfll0ѲL8e/I4dEyxI#߶=MQM8EsYO%"YU;/}qғRnUbWR$ ܎'EcRe$|>WZT%x*MIa?y'[Mԭ[ޥm2{ЎǯjujGܨsTsUb7}+fINs?RNMV[u8H3F7r+Ogɱ!h]M-E\DXGkz֡;yk2)!cK6$Jp=Ir埧Uq)Sw>z0586ulj մz8K\Rz wG\Ww-:WÈB}ާ)a[xC͖KY -Sw@:8G1WU|D2V/_ jiow~ ?IXK(v*Ȅ)nÊsTwөAV&-wͺE_Ė?@lw~<O6 UU?Eqpc1 c=b T_JkZu#E|:`-!os A^|3S4jG4 T.XB3Ƴ%J[VIb GʭvJ4\̚TN*H\.+ {-9ksҧ*ܞͭۧoPTC"E$g+(*ot2u0J̆G6Wnfl5q}햾s{JT֯@',Җ 3*8T%uӡY]#1lVʟǡ 4'uqhB"KݲYȥy'8,E_M1Q׵˵梁pKisw&v q8&Uqz-H六e c=iӕ4(Fmɀ3rT+yog=zMXTjQ^͹9|WK9A~%Z(J1V6߳xӂOsu>IJ?C/Fm}}iN/OvVѐ1XUcfu̒y\SO^+Hӌ`o[Rmu!^nգi76݋=ɪKWݫ-o/JLdH<0SrG\^\=v6$38|F K}Xb4fyǰOjyY5(*JoT ut t+cڊJ.VwG-n^GvV-xfh[s`p9>S*+SIѭ0ZMm'ڣ2YĊ\g#~>C ˎEn]x+#J$e[6ќŰ3kIԅ*ǥ -ܼOɜqm5TU"nK:[l#9<5a:Fzz3")O,c$@ q+TV5t5UnmES읒ƑJUq2E41*Z*I߽ANRCugo/Qf&L?tII3FZ$25Hc/O9뢌ydTeR\61*4 HrAߌ⪗2K-V[c>^xǵusٻխT}f7[/ȁUoh%UFIz >YI{[9۶ X'H6mgq9~~ƧSjLX*]t>m9V6G,#iz̭(.`_.NC(Ts탑]J+=1*׃d7g831?tӏ,l%l O501N/tʧNj"#xMU0n7[ۛxYeYߗ*vB%7OB[JFL-1#ҒgtTm m;KlHfbj)oqӍNe%Eqjdw}gCGҶP}uZnd{j$Y gTɌblȦC(2DN6=~(Vou=i?.[s Lm: ^/MngV>O2NC1[ܪA9}zRZ|G.&z7˸K7 MGD\4^̡QG ҈ݛ*K&o] < s5Q;(+yΔ)]{_.5T@Ž1SJ1ql猧G݉_˹yT[3Ts]mM1O2SFȘe?3g͎894F2]N|jym "ܩJ-dlX)/1mMO eOotQu-%ٙ>~S)S{3qQ`6hѕn;q L.nDlOn'VBE`T q߿J*9J*9.c:|*3NF'v:*Q{IE*jrSt 1ֱ4+)U=T{TrT>nTOox>UNlڵ^Vd{ؐXEǙ۝h7Zj)_́o~p|VeU=sw5_t`(Ѣ̌b&6u+ն)Seݖ{CxkwefOT _JזU=:wHVrEW?1?^ߍm%ٿ3L6#z1+;16vLF 83F2,* 3C#xԣS:&I,-њu| H둚u;35a*\$xH\^7t翯*#SJ{Hӟ4!κ%WΛ:nq4W2;ȫueqF\|۹3۞HUVz~5IE[ً5Ymؗ6;XԩWE~fxhudiX+z{ N2eΝEkQ7scv>ՕGRO&*aƻأ8q^OwQSMRMV׮=#[d`˷GԏazZqNQPBmZA;YqұBDjv+Z݈fvy!Y]ѾFRx}x>m)S|XsT#qAG3G#eC(JW'1jJNK ݀!V;5ڼ~chS&fi{y_G,?_On5v骕yIr*)FJZWT6 3g9\eiw)r֕gd3\n!m2`>zNKu:ӧۧR;'UdUad9;q{oJ|RUnZnԽi!Q 1TJ*iF58d鵔|cN5їV&^`Hbˍ E}сǟ_Zi֕5@(" @.>T|V:M.6io uhMrܩ֗7ؕ# Oy Ogp#Ƨ-G2T{rcGsɏc'#c)rvg(I?vbOg$XcODz-Ί5bĩro$"WvG8ݣ)('gڃ]#Vo'Vk]M >I>Oq t9FNSܶ"VK}+a7G~nVG,W-ܕd%Vx+h%j[Km*;y6Y2KcKHGTiV~$m ΛxڱӐ֪-hJ0i^lUS6"ߏ˚a--tFKLj ,Yw*;{8QzeyY]%ݐ˹N WEJqj#.U8k"z0Sd?ʴS5rW/x ΰ+)(H`}8=3E_^U? b8 BY9 <'Oku u"./b2ifp˗kReS?wʷu $qHh8#<8"˩N -uvfϧ?()8%Ǝ*QZo*+'+^?!ZSeF-LahvͅᤑrNz~Ue(Jʓj4?Jig2ȿ$cUۓ {єyޜj{^X? ֒/Gj"A`rF2qdsuR,y֪I Gs(-۾zOQ*of CחoMKdo6Bͷ8\sۧODCk] )mt́|+8=xj'R^Y=Rz{;Dn,_FG#jr)oz8֦֋oP:e?UEO+zJmKNkG]uBq G"J3!_#qTѫi%NU\O>&qeBVyX2wϳQjoCJuۈP¯oO1 Ƿfs^=uӱk{xZ=?BcrNZ<\S-ұy-|{0?cRU;EmNa|v;hE-^d䂿vV6vao#=rOz:_nq:>~koa$`Dqzj=:}RjrJ&Wc*bcPJCF#=ƪ#}uFMKڟ$inE*9~ՍG w@{" prn;J-[^]'ȈXuܿ1FNqֹ=;ogƤ)bEmYK;![G8*GCeE>Ljv?}R5J1''-4kk(\R(ᛓJ+ȑuX„۴.dm\nU*E;^,Mfѷ5,ӯ^ r9V~EY-Tqk9YJIYv,pG#sjwy*br_[iƜk=c\bE'y|y'#1ֳ8E/OB[DezB/C.6teV7ʍ%[dnrڰdhmӫ)8zU.߁f+onp]ƯϦ1SJ;NvOB;kt4LaU_$( =N:zUJ-EI%OD]~No ׺,x s}+.U]ȍ1B"bVѧ:E&e1k8F65 Ck4,١])P9_v6i3Ryb|E|ɻ׾yN.>ƌgM9[g4Fq!9~\Vښ85a۪~QE1c+g]3J5*]=ɡ-ܤ2Hʮ|c'׽iԵ2tJP'}}TyqJ'h3~4 q+y[ Xȭ&-YN2Mto=(yk:*x۳oήq/5iӍR}|hnN n_tr%ku&BHƧ >kO  }SJtܵzHQsBʿ|9>+6.8өk_$И|XvNHdh9q~Q`ԷF ܱ*/#E/g{n3LQv9WۜOƳfA ;XIQ;vs?x[&dW<ƑZ7Xo3p!}sb(]9KKKӊsnJ[Dj.]͹y#kIrG4-K {XU9Mc j͹eTKef+IsϮ>{m PeU#787uc:t+ɿy,T7 vfޱNsdPn+[qBҢ7t"<"X-"BҲeNdȧӶK4Ѻ;a^ONk>kiKWa !ʮXγyOY&bGO0ѻ`1<y+*Wj:Rc2w5/i9)RYrYRCzVU#$2VwktUÑOqJ<[NH%F@oc=GpkWV#lKg+:Q'wFZu$[cHn$]as'rhWxi.Rs\I=~J̴"۸*u \mCʒm/'M?.ُqלV3NQmnTt$wS<8U9 F㎠d:JQWϿE16" $jMh\CSSz3Zk[D ̤q9\.fٝTҜOfy?2Ǚhl^v7y?z5I6S:ri-He7ʬXusQ{}~FREߧ̮(l1# qqYǝ^CXzil[UU{۽f+4u.\=uRiHeE?7lW=XhM1Q[./[p͜6p3*QhZISPzu$h'S<$]]{s׽cy]5W$m%֨@8N0z}?ZN/sgd妍_i;yw@h\ЍN3NAZ8DN!S<DݔgnJS^{5:zw^EsH%VbRI{ⴔi'u}owԊiGY%W8ִ(VvF*.͛iQ'zgyjmUpVupwcɸD9ވE82iD6؈f`0a͜q]nGUYBeeHt$QX m sg?N@=hTrνYB3MkNȑq+v{~?eN2M,cNI!)ޑjYzWb[tRҜl'ؔ3"u|ЌZcԌdqB3/Ϳvl. ?>`ׁ*$5!۶#F5V"'mFQ:!tZt]Ǫ=`B\Xz,sJpVA?]9+e F.ڝ5RTJ6u޲$A?ZykN1TWB6hw|wt5tS,NjBs$Qʫ @X+m@]ۓ3NGD?fa}wБM4ռt=O?.>YFȯiNqGCff]mcLdhdwtc1VF19XX4c2u#s[:Ւ%pX$c*cP~5inf.܋ʎJQnŁrąa#sdߗJ:?s:(d$چeXϏևUJ.]4!Ei-H9O9hƣZBL٪Q\NJ^Q3"Q:h!|ݜ0#G]\єRZ>EVIa][&66|ہ=޵I˗kjxz 5Q.dce-I<+,~eYw.rFx8{VE~n]fČ;^7}T2#F-Xز-/݂xs«nUiG_a=!Md9SGAЁJ5O*Z,!,RU Bzgֵ|ҙ5%cG"ysN߼G^1Z>XS+3i/1}sX}8H\wZ oRr7gsr LէY 7VdihE1,rGұ; ~ui=NZʶWLBnW">}Gq~473F.r*s <ͽmw[B"jVۭɮ)!xe(=*b24RvoVI*dO: vڛJVt"I3vjGAL(3Mc7;=JkEXZ#٢bڤmeg=Q%$k.d3w+o؈7 zz~iB7S>D?E-UV^0q׬ߙv1Fu%B^+7y{py^8UR2NwvF $0tDq݂ggk%]yηCCy@m}ҕ쯅EÄQ5#Az#֩ӄeY幵Ē 7i: g>8j]tBU)_vEqqm;5-Bw*w/~,jo8g>7r[$6y6syciqmاVOnW7dtٸm GNߕ*tK('E6י v2+(66P]]iR|Gmi$hPW==9FMBz7)ůてgʩ`F2xҶIo=o4sq2?/V^QIJMŻ%qfn]FޝNQSK[@{;׮$6Mɳ*s3?VJZT_r1Ejc1D*s?sO-{|>\0v)Jn[9sBvɘx1YNP\Tj|A @2m̓ȥ/yĺGon?A' usH\hjV;no$Y6ۅQ=1DFQsju5'uB%J/Ѻ ?XҳR)Hy6 r1çBz6R捜]-I9t,.7m>^3sٜ9jk=-ߨm0#0~4dxTU&o&s1pG=+)9BLRumXKUEfB~NscJ^u:)b!<"!#X۪K+(mA\Ϡ9oU*FO=D2P}~͗){E$dJZ?3ӟzRe_)IFkGdCnTs5MөMфkՅu YYXyx$cUiF)yi#V5c*}Mc$qz"i Vb`a۽sʤ8B$rE{V=ѷnr}W/'2hP,tџ]Yp${9W4le #q^w* Ojy#Ъ,oeC(Sn8K挹;~|dv,I{$V IeUǥ,EE}Su%խ7Lq׿ 7)s7PEE5vjD1Bw,mMN;?j R]z-UEwٚV:R];G< 'lrxzױ¦YtՃU5fm/30v# 8}& e6KK5t[tީݴ]>gGk#c EE;Yu׵?ysQUr-viZXZʣ&lr?JFQFIY^mFU*|}F!ah"Ic6٤bœa+DR|MVA`G^:E(F2iEʣՖL/t瞿֑i >3ѢfK.v A׽i qc{ܦF[MeeNIliʴF1Бl$iHTrZIk406VW-;[Q-H \ >b9%˪שZ峺5ǿ^}*};#n-g]GnYBrGLvϭsè߱" l]$IY0t'p֧%yhEJ|Wӱ%\- ]|9ǖHSp^^W q*Unxw[[`a#qּYJ9ѕJ~u=hZGbʤ68xF+cZ꛻~ZgحP+eO @wN?Z(&CU5 b**8cW9>E~SwЅkfy\161Nwp=Vr{>1 ٞI%ϋwdοJ0vR)_VX!F7VI`H`} OzX8nuaGK8R8AWt6@9鎿WEJ1/vJq꣧[(gVx۝dI@?{JR g7֗,tk{ /ʫ=lJZN-eU0޷;dp|dtg_ _DeR#8BKTK1ӯ-r(_#wr 'tkNME;pҧgJqgɖ%-q/#z}xi?iS;ja}VMJ>"zqqһ'F_-/|.`X9\2yeRn |88r(R{4qs{Gb`UL1}~JGS=:j2KVL\eeov y(Sn%h֣;E Vۍv ψ͞Tuceٌʲޜv秥cFTZeӪ^PXjo'W%qZ¥okZ8o8k[2C29_vSg+:ӕH5u=nxyUn[gҴ$o4f(+Olq$e<z~%_~,i¶٭m@-MM=9bQ3q6vytkmFC(۽i9L3$:6bJ9mVT!ɇe"-ew^k.2ך܎$+ymvGˁƷj/R:#m5e9kk힌xXrְĪ|rwxy.^Z'{ xVTy?vKu=k#MR`0 |x]#9jg)J1Xe I$|֜#e]U7?UҋJzw!a Y6pO5wttգRֺg-eXn7N)ӏ#wFYI2F# 0.h*UTM W@\ՙ=JQnUQ"7 em6d0iZO")F;&%D˟WwYmlcZEن~2qNRRغ4t8csXr2j97o.mڲyM|Wzu猧N[p>~_uGSd̟m6,c&6U!@=a%MG_em~_t4|i:*-+ۿ`Z ˓P I_ʱߚ=oe*kBWo塋w\-̑ʫuS*m$\Ejtk:NZfс60H`83~+JxyN<,g%)?ڍ6.ylEZ'W^"-Mzr]dohcME^fbkLro.xjs5euo΍9S&{ƃ<l㎹#9eSIT+Qᬜ/Wz?Kk)G_G|O"26 S}X{:5"`V/f׭u;?P2janw+D0➜:ЌUZtm K5kq]F2s9 ߥsqJWy`9YEu^iwmȬfh$n +Ϩ ^u<Hr 3Ez<yce 98zR1~q<- GmwzZmbMr!gnu #ұWjjG9J2/yMɒ5bvqi5=z3 F5}KYYٙX3kRV.R+5']8Eȇl r?{k(JZ=Ɣٶ{Uch||noi̥cj*4YܝFN︠1=ogi'mV4b.yD@`>TE$P+#w;W)zJUja9 klwwnsISgY}wG-ivowm%cNkՕJk L%ťʹx_:22įwְ挕ΊLT[^DdOҺ'N4潦IF?Nw}7oNO98lb9z*SkuishިhŮ]e`~]3kҩ)Jԕgf3 N/siH/?3q퓌SSZjyL;rQw=gúp,a# )88d񏯽qB)'SFQ#gg "p̄*y;JUMϔ4%-67GN:gyjir\38.ܞ:ou5#%b~j ۲=q\4ٌ5+EvCY1{娪KEdRawIp2~W#$w2JWmhJ ;>ìFYdQwֱ= g?3\kh@ z铏^xh.ҽ:cڔSqtOG`t3h3x٦''/iFDegۜ?hֱƟ,֯Jj0NZ&b<搉:)'Lr=UWy~ڀ7G!g;Kzuɺ]H̬[X=r;܎+&VO+jtW4oS1t%CqBv!Rύʟw?ӥeԜ\'nČ@NQz[b jMf^ZE=5ud*m6qבvƭE)FхL+_}:TfU/7mvo˅q(֦mJ)޿^IݞsE8_y%Qܫ+.7 9#=yrΜ\o$!?ՙWcI1Z=e{Xז>ܫv$b3i~: O0*$EVW~lGzwg܃&>\3nrW(J}F~f>>֜f=Eu(g_atNwwK2vBm&6q$`B0Yʣ{jiLKDxIl$Y ~Sk7+zAlG#\mN ƬcS8 '~&iSO.G%JbYd_1{Tߛ9jsƫ[ٚi6TdzqrNz;"/#O>w9<9G"VTR y{F6N0=*Pȕ9JwďmR<"\y~R*2~g=8Գn䬱=pT9evlEtHەntק=TT8J)^BB9L^u\-y+#ܕ-_^3klL̀:zיZ2Sjc{)xҫb7$v=z}+*Ѵ]IL뤴| rW\798>\LQvo3MJKUKxv-dUc8txID chzy<µx]N> & <̨ *9JO}9өO {v'8b7nӞҳo8֍:i4ԍ-,jBrFxֳhWR>HCGue~͹CKe^2e6VG`Ut'}g3N{{і!-c#S*Ӈ23\h{u%VZ52ekOa3c&v`l98?g8i롢5oH{w'@:u#*6W[4S<^CO,n{dԽٕYSk`?1f YԒz}>TףRo{gITW؎I W~IIѩz1%aλtcf Y֔im+qN~nȲd5dʖ_X}biF 5~V:N'׹$7ӘH;Xg#ִtc)Y4+Eu8}7f++ʎ"-vA*|=tEI\gxrgfCSqdu"潠ޭ'ym}lxF:RZ|z\E/sZ>,hd9\r~OjZ?Ʌӝ+.kXY]X[ iap?@~*1K(+nQG32%9cw^5=Dڕf?$nUBOⲌ*^=Q~=%ґ?!_V  duE{*𱴟>(x4[h'R:$ `Pr<]iԕ/h7*ܮH 7PygE C=ɩN<_CǕ7=dx|JX7صrpg#T؟˭ryVJ3ԳLxYKoun.<0@'/zQU#xt¥>h?{Ul;'q^-zqoҩZfM2'y g 8$g9FY{?iEi:䪬'qe y?ϧc9Sۘ:auYC^"κqݻݓb嫣eaʜc[ Bdq$s)_-[{s~u9I-o*$)YHU䬌A#8 u=QcHH!F+܊\\-<+_ɻ4ksH .K  |o ⾭Fz[ ".;km=S⇊#VeV6.vn9<prkU~c)4#o#~$i։gkM'ڭ|7*I+oR3315 wpgc,6"Qy&gx2jsY6/F22F9<_Zi5S.!>d_W*-=5q*ԣRsI$ū,Y9#cM=?/C:Rqzyz֪Ym۟^}(U'N-N;olMԨ_4|ǰֻ߲+NV$",/3ªmIߩa2ʓoʮ/+صݗaF_r,l >W)G/<7Tzzo;KU`$ڸ ┨I?'۾pQkWoOxYGk"0K}918b8 V}?/h,ig%׉ i9`עW 0Zc/0t\Zu<}̬ܩNT99;QG,,71ſ3/dzFvI|UkE V,2s}iOzr(4y"Ҷ|Ƣ S*.:qζ84^4⵷Blɕ叹:XQOOshljYO!;K|:hR\Qӫx$|S~5p4֍{2KJUδ۹V ]Lv|4I s{}1\(Iof޻>V}YIo-cc |#ȣ+]nۋObDi%Qd;nߡU +lNro}mdpU)94LX|񎾈nHtfYy<ߟʥRӲ+P(bz*I:Պqqi +ww`{6V#++w@;oHfRq} F)_ȧи&UY7J[}Tv$sϭk/e8;|Uʖsn|UF" 0E;S[F 65HwU?5&,׺Dqq\f޳K&m + zt\:TQ=H/y'b 4͒Xd\FRUQQ۱T8 p3ǞI9;cޜpQcSy˺fZ7Ffm8ǧ׭8S%vWo7bBPvq]#*۾FuywLYqy>mNծ(a/zVDGx8ݒotQЯiR]Q0*+*߻w1c>I"Y!۴ۘQ銸ϛ޵trٻȰV <^7Q!?&ׂ0Zʤmp?i&Eħw˒QJ,m)}ƊÓX<)"KH<[G'ΤiSjY F 0Oe`U4TQ5LcNSMFA؄GbYFN>cǿQ[TҌ*7%7 7.-UsTQB.Uw$^zR'B:I^6{t.Z 6q9z7wu塝<[hFLFfk+e5CsǕ+S*Wb휒β层n}j?i#^ͩj]YP>O_ҕ:m= ,DS%u%C pϯd4RTj 0In#H<?εܙK#ic<&SfV_U:h&DO>$)>:<֏r5:Pi_6FO^z𪒔}͈QZSKnQJ(F¦|?8˖j[W*܏?{ַ՝Qm[bhnz݉#7 F+<yeɌyz_yʬ2" tUm}M0S;ji2"E~|Ef#]H=khMKONNoqY=3B9P$iɖ1'+Z^clE.m-ح>pGvQ<;N-*Dc?ݎ8UwЅ_pM iTQ榶9QݗO2P[܉ya/e#tT5)J.%q+Ǚ(la'_c]3U GЎșM@ʼ n㞤֊\G9刃>m.2 iFA 9֕*{+Xז8[7t2M-zcǷ=]LM/b8TibIO3wSXSGHƜ2(%mekn?3 Vg\kF(m&k{T8LߌUqqJr+F-4$*}ۛ't OGbDoeFweَhW1SF{S C Ug{ֳ|LhԌ-00KYjGы`1 #=kS/S^2]/:H# 2;3㣑>Ϭa*ovI, [%K5v6qL3]zխN.nIޏ77[&yk?t3gw^}Q^[agYh(tw˻1pzJk;jTcN7i﷠?&Hmi]l~銻Ii&MJq4zcE0@QXʭ VyNN>wlSάY~Rxn>tc%tqFJ}xmfbΪjb#5>"@<39WE8 8'SZ8S89$6rY2vqE9TLRQ֛N۾"FfM;_UG-;@N{V֔۲[k_lFIudڞ4x #+|۳ьtӇ5V+y1efzp=iKHcЫZ:?|`+)>kjM>d&P6A# !&l7~I#ڴ?f/pN?geUq.[Vxl`i ǹo{orM(DIf;Mn01Qv,NdeHfEzq>8U+K۫CEmi$eqXHd]iˑ\)ʢk">ƫy.mΣ\iƜi]9OK,Gp,̓G$~`VY N^yjӎFQt=;^]~E>ȥь_3kK!Q]gYUNpg׷[F7iX+z$KBg~V;1qVeFƸ2 ml5eة{2fAvH IQSn>A٪>){$϶9&2`ezc[(ZSi~92LF :u)kKEjg u9V&Ǘ`oʴFLo(WZwM"XZLѬdv <z0tڜӛ'iuڛ=s'^sN^mFei/WF& .ҵ:nЦEHͼ9^ܺ P$fՂ@b?ʪ4ySKRWф, y9dLh>pZΤeLVd$, cN:8ߩ3W3,FY:co{DrV:z=@t[Iai0>a\;{<ӵrSJk!o e#olQ+IF#Vϗ<>דGhDsrΟ2ѻ7 іO79=k5#oxqV]#1lylrU?Zƚ"4$wDHJnP d^XJTu$yA%4>Ll#gF>1=xԍf1R%ibH]zz`ZSF*hionmrIpķq1X*texŘU2q9<^ԤQR[}㢱 J#.QH{VZ]RFGasl7>f/&~n?ՕE-Le*SN^A H]mŸN+!{:3ﯧ'WIbm098~[t'm l"vyyRt:5)^ھ#U*5{5z, /l6r瓌s\wƴKY5RIqO'$ bt(X,=]eoqU睫̸#yڇmO'خgtH(÷'yMH7ٲiYBirKw!Q +3w= gR&!F)]H#2hֲ4{Nu}OֲBܭf?ZWptɯcX}3cZI>,pʻBÜ[F2nZ{hZ[dDk֖f ĂLqל~uN>ַ}w Obd7-*+jte"۸EcΕ?v98A#3]*ZJ˛m-u&Cla`c޶.:(R,Fݳ>nI;:n`I鞻<LjY"Ey|l}qYµj=)ѧ%EnDk[Hd y#=8-4ȕ^2@V,Ǟ^,mS t1L \@ϴ+*L;^8֐im?᭷s2WmۜkF0J+Ri"OYbUmۺtiGCE+K[]r;6?k JqgMΤ[dG3l8\LybkS5]8U12Y1 u:U/ٹuD{Oiv";#d7Uv{VզSX8hkAF0gƺW9(r\K$Q5Ē4[O8NF8p[ZryyuCTj8J,!PgӮ(9YEHguCc]Tί:ъIoԒ<~m+ln :3y!;Jбeܤ ss؏mrG;XY&YA5'[S,̨bM>!RBpf_@ǦtRI}GLy~ۨ Fc#*qj6njJorL97m%qB+RфYPv]0\6OTbb$RAiM# 3afUeV8퓏sؚӗEva+{IYcn!c9N2Zyѧ{Y[!1M.w0"#;t%%c xeYpzu?J+T9\Δ:G-ҢH6dv?/wEEV{[ 9kn9)ٮ]GHEjbAdɓ_nM{[䊩aUtqcoƏFk9:qZwȍTHeu@ U1qΈ%:3:OԀ >լis8jp#( FKt]`G=8G^Šu%)5;{h{6.-piyh)N:s֔~tZF\C/k(sQߛ)2Y-̊V .Tv#Jӗ*8ƥ} M(v6Pֲ-XT~mO8+Ǵl]sn?ݧʫ{0Ӭm?y78{ RY. =H2®e]ΨӋܙof퓝0<c<ܼ+O-yǝ )EJV"2֎*,q]alraQIsz9檝{T劊O YH 8拝m0Z#2#'TQ5GzFRhdXǩٴקs ۿ:;N 3,m&rV>Hѩik}=t"k8fpoS~>.|z5 H<qN;IEoe)Ha.l!*>쾧k<ϝ=z2[ym$Bmr gj\Wܷ{w";uTiFfcҭ}{hqHZvH'+:y}w&OS],|bíNAm+Z4[H&R);cXCc=N1Kft{,/R.Yk:29-Ȫ6HlcԕO{¤`֏[9#Vk#+F¬8V끞Q(:0FDD"9]Oq{9s.WOR{ʶo*_2F2)y?Ŝm9jRJ+2yUo.i+gרRkV*J-rIiqpVRX+短L%ؼ;59?+g zwa8%s*'n̑1"n:?=NIwW /N߉i,$KnRIf970HRz_Mm Ict5jsW[3:zs%=krZ v<|09`qS$u{j2׏̲BˁquT躞O9q͎c5Ğ_I3UuNjZr%dYHt4aym<7'p֭RRqu {vA>c:7'U"ka7٤SܗTa=N9hym?Ԩe،$6`n\ śrzGAPtP޽KȾPyҠʰs~QO~YF$ {xJ.=But/ǓF%8*۩ǵs[Wߩb͟!.ev e5iMa-Ֆ gX$ImVs\гvrnMI$f #&e$pO=9xM]#<<\_liq"&K6@ _|`W,By~r;-R%2  }}G'5*G5ciԒ )$)MI$< Nwv.h W77 ȢTdlYqߧsV7>f~ҍ99KݗWV l͸ : sTf{.iJd3G=E~NI[F5 |wOAoO_+ ޹#Ŷ1*P [ͬF\d+؟JTmmu"*FE5 QbF; :OZ#&SӍx/.QUd)QpO1SQTGStXlj7ʕb TdSZKNo7lsjJ>Jϩ{FX[cfRz6}Xz+][)smdnh|ح4(,zW`.Vu:NT: 'M%U䳳\dg?ZQv0+pNGs[Ÿ.A:.~}:4OU'wJͷ:e}?o\BT(@;nnVY'0NzZ|vے-ڣ1Ccv>fStJXx#io-;?_5\7NG,r ^n=?55NuZ򄕣}m ܭpxX:S{o,"~JEߕabܩuo!wVsֹNWHe J᷍嶹f#?{sYZ[3(aі(oqq5[G?,S ܯdʱ>vߗ#\LjF\~} VAcijncppV9m2;UyfI Z1"g8a}:8jH"ˍYU~~b,} k&9k(N-Mr:"v[%PzN/J~֊U0 fT yxs:u}m֭F*Q~|'YefHx'?z?]!zխ] (_ .`_.G#&j۴o{sa凒-0yr#."Y ; U*K¦&4\\/2QV9-FBߪh}&7Њpwꬒ)h[>_.ap6-O бbݜ8Ws=Ji/> ps޽vXՅۂG=-;_CIkwjХ휚9iΤ`[Z]Am挪O\Vqe{f%JRR_A'1e-8+9{9( ) Jڔ6pBr 9c)ϖQi9b)ey&[gGl3#yVNtK`cKӨ"[c ]ceQ $`ޤUgWNb0ti(>gVI1XcYƪl-\g2-t6;vÜ6G==JO֦nƼDM$Q&d x4Qjv]v୊6oO H`ܾZƈ[¯S~NKtw_o쭟:-4.'rSҔU}5^K}Q qH#S&[;G~0(.|îX= `831c?Nq]iY% Ҡ~-/쟮 T\w}Ό8Q]in=6ܫ ebxWuƞzk {b+ěPʝSI7践Elr5;@hװ.9q^3jn2gMVSz-eha"$rS溗|濯3NSte_O4%QeI;\bTŸunC8-b(cOnZQ/mmdkNK.KKčof1]Q;Mx5)iuߒ6m wVx` 19>P)=RN*4 98fn`䦔W@Erwkn֒G+Υr2_kMֽ5FrZ%/[GQ23aѡ},vFKX0Ό4 zsד N1sH^enqO) [s܊7r6H}1ZH` m'ƞvw!6k. #ںcRWrwfeL \)sK1Ʌ6۹Qn]w/3l?.ߕ)F*Q橱FWů'aԨ JFS(TU9^} 7> fL^YSVթ;nlȈGUU̅Q׭y>**Q|Ζ,k(p:۷kRq3ܒWb,"XmX|QdQPG$i;R6Y6Dyysyc<'QQuypq2#w>eR\ZQh>nֲ@к,{0sƵuDcFXT8,Q=ʅw 浧%N-'{5VTВ)1<9q抴\IX(ڣPާМӋ$c1+2r>t(Ъ3)K_0[FЋX>^u> k%JFvh~^8ӟʪV:xރZXVGFv{?Pj\藻QJ_p4Ndi&'Uq8女zbH̵ilՄ|q<*f%ZV{hH}Q&L}r6,1<2n+|9#ҜQsi (Y;ifOLҜ%-v0clyi3m@9?/ UI”{F>u\PWל<Rql|/Es-&59 A<>^qYW2G2EToяk2Sn #w#JRFҭMёȳ&d\<%Y>ԗ/la*ij1.^<~){5e:t?#.1wt\diFo2-y{v26:xVNtۄ=Y[*Hq֊j\L n'Z6CcyGX֍7+aR\W/u]p @<ϥaT[hbɔ42^y9YU)ΜcЊr\1Ȫ,.-HOu[22*";c\$mo w6Zo%v?t?ȧG7C('Z1L,Ļ6Ӹ#?di&٤S8FϿO|yqmߓXܯOFAsD1 ݻrUiS7.>J㐑m,_'w_Gt?uJT3ca%21\ݴJs걓{wоnCW[aܪq$syXISQ{_yiqn+ Lؤ$v8#W5J>Jv<Mݙ:i$%\ɀ1#Upz%9Y^.}}fHS+]xo0=J2X|-Y!UϜb\(l(zt9kPwf>֥:n.^ȄxLKHąs>V,DcO^kC&_7h5: ^Qp.VqHuzpO=+(Q(i8OwZ!bcr~GNp*V_[SmEyf6#x^:+aS[%#W+d U+>FNH=} X|NOoj(F+WmGN!+_{Ʊ%U>}O~v)FP=5%SR}JzS׊7?c*cbͬx:EI5QSSThf-@ Vf^ך:u7kƭwm/Yijm|Lg/c*Ύ^/?8c.$I1VrY`'<嚫KDLF53|f1IriԪ877:4OA\&YP/h?S[68Tgu)o4wU_~?fڒ杚Xzk7A&Dm~PGּMmu썡3Beu *+sr?yƤNWWioXWs*'=G#Re(_!u]_z#I7}9WS gtqə#={WVͧsԩ:B}~Mrvv+0x~>ՒsEնHƼԧ{U .2BFTү*U(Zm^MYfQ7ݑ[1Ozٺrwg)J-rsDd{KmmpI@$t>}:ʶMNWBF+gBңf 9A?6a{G9|HTV>FkWNln#q?BI<R޽v/;ƌ1<)rܨǖo;BmC*(GreQ:kuu.+'=;VeSyUvfV۵.ۑ_ũROr-c 8srD)˗pW`*0UY9\w%[B0q{T8k(F Rߴ1\  q(,ZV6y[{Y%Iu=քE)KrGb|qQ.R~~}J*_kc9zӍʥhOr .&˳fSϭkmv+QQlݢd!d|,~ΈΥXr%qܫw65S̨+VKOB;\ZCQrU+F[a֒50$ѐXdl XZ{Җ*JVdf)c`G;y3NtƧ+W9e:,Жj޳J z{w:Zd| ZǵO" M9YӨ4fFkry EA?bU5B ESኒjz}kJ7HJ1GG#kkEԨ"Gǡ?_ΦRo[+ |űFGQ(-FES>Mhb. Y;v*Q3*|݌Y3]vZQV&R|1ujpnџL.b66sr{%VE=H#D1K'9Vp.iTڒՀe2/$POO\Z1ߙLYrH=}kG]rҢ!-s <=ּ >X}wڻ1*nh76B#+pRVQxY/6WFHAFQTi4:QRWk+ѣM~r>P9$cצxFM&ވ-}o^_ 6 Ul}="e'6j5oТo9qs`t3ZӅjQ8SMӨ[<3}] QLEkF<-I(D5͚D#B?´ԨXQ6:c%6\QJW] )թN1wFEi. jijcXҏ2f2~Bu &]O9A:Z߿ ZME跷{~V88J4͇8UM$i6Xy8A)G޴RvVtەVdWLNxqThF~>yc1y)w7}+7N2{G^7:\d>9oFHŹeVFw%guR;_=¹JmP.8QRyCi~}ǝZuVђ)/,y%\ u=QZU{~fэ=urė# aׯִ7N*E;[G~hlui 8E.^o;%71ҭIx+0 ӿsJ3]JimafSZrՍaMj #.XtsSN-%va׻yzd[S4v ̳$x}3YJX&U',NV_!"["} J/gm9cT\aD/% F]uǧiTyo~A*9չKhў5y2I{tuNWΖ"5)ꉝld8T8\iMI.ǥQdwI7lƻǏs]Q!w.1wdko &ٿw p>~iTN/Ӡaetd摗̲ 8\MVY&kq+O?N>Y;Im4$KćT&^~Hz=H0=UݓhrRW{7j7#ceuU!A '?#jTU#MSKaf }j5T(Ɵ/2߮xFM<C7劎YT RZHn%˾gVq"ܝ>?Ǧ)0\Br4;9fUl m'r814Ԛ9`b-Ɨ.涓wcWE^[N51J+F,R8OX?ky&xginBFqҽ*ru95o45J,c+M܌ی}jmrEy[~_e%;o:A#zAP<3d9?r*jG2},^4kQ xQp_ 4lzG8Czu#z[`d7ymn<5{.&W)׉J AOZmK{q`9U?V'Y$R76981}ɩ?g#|9uCyo؏%-c>U}~ҟtoft׶-`ּg+E[r.''m5j?slddutѧMF QR2YѲ$œבҺ*S֦&eN-GEVa$qS?>N4fߖƱQ9]'xTtٯ0n(߿8쓜a ]==J7]ZYZ$aOgvW\yԜ][/wi8U;KO'6Rv$jT ypsEj N.Rvw9NW[M 6û,z㩯)U;C=<'}ÿ:ESƎ) \0VlqSOPN_WŎ>L ~rvʥxԠڳ3 qTdz~PYVER+d'#9WY"7;Ob)޾yp^.[k`<=+|7>;U[SQsz6{c^ԭRT}DqiӣQŻ1PNdI%uV}{{VtR^ѻxxԖ!B}[{c Rk "D6 KBDc\́]i?mѴ!ZL>x8ܷ7!al:]h0wuk[;sԣdgs1|)WE)9vQZc(ƾGG dGN3᧌vhPʖ0O>3'm-CͲxj5N8 {iI$-Ie {׃\gԕǗN=4|d[xQ_1Ϟr;F7W [ydF< &2H|E?gVNWNy5,yl>N+2zuO^âO!dYEX0z|ڹe.jZiӍ:G.`G'5{BQ/{H[58H¶|< sֱ>sRIN+KnG,JQ-4i}_c'/wl>Oڼy_~Q?SH~:}JU=ɏ0C[(Vfar\UKkcOٿi+8wԊ[mљF[g+@߰S֊TϫsrQC&䖑fH=F}zqS; ]>)rͮ[YЪ3yޜjs%~ړR.頍qo }=UψT%N[ꑒEkEroD][%U6d`bءg<³ JOnv|5n*m*Np~Z9dl¤g(G=0MqG()4UFܕ- AŸx8]{9\)OA"EY.3ʁ=;sѶeӃM,7P.+q۸snۀ<2Mh][+5Ӹ$^L"A#20̽*=m.DRky-5N328iRJq* T~ֲ5|ffry5~TjFT܁1ﺣҢUd<6_*z㎞ROs(RU*6ݒKx8+C?/nN<ϩϥuS8ssO3-6ssD}4Rů5Ͱ07JRmeUdŽBF$~nZJNƵ0eGwz=3NNR&kZP|V0 x[΢#Μj-nᶱ} 'TOyzQV]wZJd\ӏұo'vgeΛm\ekK&,.xݎ=}m\-jco-poayeN ~3XQhJѦBs(ib;S kQ7ZSZ}mn;u:p9׵f-|<.7ҙ0|)EF~2?希b) D8ٛ^MT$~dfVOmq5:=~E(aD0lTI׎hq6{5;m:nx3gw?J$v+Rj(4vFEYI#zƳnimH-HbI&$!=}VO2r 6Q!+g g;Vn2Ke%(iv0v?٘f#q]=o$IRm#弳\x/iU7M۸n]ɹpjgJ2I8ũ/B;HTc".ff+KW\S*7iNTtOס$m.ϘI{u9jJ gFҽ|gUPvsMI.d\fӞs #F#gߥC7QWRr}IaG Q:GI9:sRiS긽R,DwfHy:{s~O}8sr'HdXo-ٙ׮Nu);?aN=~EĵmaXqsnG#$\)Ir-OI6rfӌr|pW $cM*'dKcyi7HWrۜ+zgOJ5բk_g, ȶc8~:K9I*S/+n,^dhq;IAxn\jꞂOK1R>{qXJ:7bWRZ+Oa)#w?VQ掷.|퐽*Sjw7~GoNQٙ"\Pkicym3Ҵ;g忠]pq皊qQKy%bXۈ4U,2aJ|N:=/ }G17+sVr;yʇY4R|>ba^g,78j-5y,GK؊\ͥ& Dok۴\{֊R)Ƶ:&C$Ĭ .k44Vi&gjդ\Kr#eޅ[:UU2'jZ;+m{EGK|흧=yܔ(99ѩʶzYZ,#Bd N=+JRDN"5gEr^~CGB'Һ(QJ+GTHnmO!i mzCNЪ-AJ -´Ѭk[lHF1[>*~emnRolm{xϯzripmP4wW2I]"4}kzkV*;Om얯FeBmN#!@ 9][H󨵶9pKTv Tʜs Ue(5Af9`Hnq8[.<V"$s9ۻ\.T[ߚЖkt_qo-Al򓜞OvF5%SNz*%Vu/v| ozJW4gʭO] G4|-`jyV3h׻/d*FG\6{cu!N]Z.>IDoshonٮfޜy\sU9!sJ <#(yD- sUROoɕG-Mtt@1:nOU%W C<8%~($8{Zrq],bƪW+fO>=1\mknʭQ{ZWm;n eعje( Xԩ(T;xTKce'l$'J^5䮺z|+\[+"4x7Ȼw=M9c9{Tڢ;Kcl_X"%bkfUy: +II vٕ9~FynjQQEk=NMha2ɞusדֺN:_x,b-ߡAg|X9=*qjlh$m>y$[3UaO8Nsfn=73<۱!uڠcarOl+Vf҃Q4mBϒdj^k{-Զ 1ymsG#nԎ_56G,khFG.[N 2~nzj%ޞM 0[ivLRzַ4]MN^_qca,BK~}:oB6f NTcQQsjֆѩ+D\I ,d{Wǎz~{84meܩhYPGpKq֏- p_ށl1 ^ZBYۻ9'{Y9J RJϱB8!t[}ѕxQӱ/jʒG/wv`$NQ.*F1\18dU?{V2Lk.wD۵d|.oA:͙Cx 0:Vohٕnd9;N1gFXG9ae֩./̪Ly[ybB`|sJm1^u021F?w#~O\!+ڣ˯QҤ[9 .c2J㩇%vo*bkM~l7^mHsR.O+tf5@FΥٸc\E9s]APO~[ŵ H՛;O'9+͕%)aWMYZJ0)[ oZ密4tEҒeN4G$-UyU=bcԵdVk1m S9FMJOrV$i'Xah,,|/88ڰxYs?̩b1{$KMu")51fQcߗiKmok4Kq9У~Ôye-/C Eews]fdDDPHc"<LJQ.aN D1[miu&9|e-6 Arг3mnpA}sOݔnƝzxM;Ex(g &sNO>kmGr7k$I!ad(*=ֻ)Qzp֩d8^6䛁;}2OJKsTe[TXigYw8N*)NK?Pϫ:#%VDYHee9=x Tn9{>gOnI2VYѱ۽qp#?~#5.I(PC H'~^[{[>XT"QUXZ[IrBĮ3p}Z=U#~YU*lK6,~2 Xeep?^[FQKfNI{fidI0G +ciEpiZe7_Z1GC42UKߺ=GҮKKGK:HnnO'_;y9jmceN+Q+"oi (pq)2rK"fJo%vGuq潉ybX`9x"&6*u%XbD.Cvc:N1v߰$,ci0|0}Qkj$)mdE |99j:zJ wM"4ZVT"ws($Gݺ +iejm?t~cb)Ee\ƪ7ЯAmTŤr1q=i5s?qnbgՃ&qnILv 륻 e|6m=3Sne4}-Y uUe>zX=;ي7Dc, ]N8\ܱNKy&Ȇ%1nOΥAzfdƉ.O] 4o 6w7<}0jev]3Uy#vsI;pJNϯk4Rò[ j#=}Oc%K攤Ӌ 0$W՚L)$\Tfѕ8K~!2DSm+r$79ⱬ.”c+]>༸6xzJc(WExZH2%翽eΥ:xj%IMԪ͟9jғkCʏnopIb5+$uۭLZ, GnI7}wWA\|J2My'aG a=J/h>y{4tB&௚cPͷv’zP=R 0ė rgvN}3ғ}HхhPtB$;b\*' OƹlےG<)FZ[fA` d)ZWrb IBbS}>ZӋ^q^1'<m o3s ¢?ݧ'W=7?4aY˕<=+U˪՘ʍgyK~#lm푎Gc\֌VPYUp,29ް,8k@1bZFVVc#E%PC;.*X=cc?2z/OK_Z?}1l~^ z)8SZ[f_gM;G̺ EsٶĂɖW@/mr}+9{i[O硤m{$qʯ˴ax}ЌR{iF {r3L6Cs5R%ӅH4&\ZERW^ӧyv*\Fz5'5F2N6*;_n.D39 gۥceN~^xg,Bb\@Z`sZӌ}_34:d7!ڬ[w\}?JPTsխMS_i5XiNmFfrbf v2C9&K:oFӟ=^E%!()+f.j4O_M ?d θ!1銨Z-ڴ~aXՖcu$g#l)2ŷJ\$aK%׭TyStzX]?0[QJ+QW}RFŗpxӠɚB&mFUx=+^+o]|I# eeI $Ou4c)Z]UiYf)?/!z*N1֭Fۣ#'p=x<;Tťq_j/0'kzt`m)JGvCʹ/tmt'9s[v6V飆]9]i¤W2 {ju9\t5jC#nN{v\nchƝJzZ~_3zn ^:UOHv*)ٲ7i-xUB`Ͽֺ#$kN4ǟv91[[IUv-u ^HqUʥF:5%VLb :3p2&pqwϭl{U_;P]c=rG=H )jLo.CG69$z=*w⽯*+@wN2:u&ۍiңN/޻o,P\.3z{(כ.˱을,FYx}̣g8G~Zeƛ>iU)2 3׮>[#5iԒnsC# 6pp:7o3GN9Ct@ϖ6Gz_,Ee}ŵ$R3l㓁ҢJ練Uֻ?C2m4B4TEM{T'>S;5~>e Kb^R\rI/I{:y \̅%&dv:cҪ1ylF1~[M ,[fJxcP;T|Խ+[}xnIذbz8mbڶ[m3&ktYX(%X+ov3mm*rQߑ$xch~+.  n>w7/5j[ ͗{$]ʽ2'?\v5 Ys5'ukAw3FR'$WD\jKCK(t2&V^@^^A>4C4⭶Kpȿ&YSӃ>X:#E;6v{)2>TŒ evs׃tS9|+b` r],1olê >qRt1)UQeI${*^sӡ|ҲWseUnrT;s5 ЕOfCspC,#e2)δ3 ikȆɞcvGB>m3UR59]u4w"K{ I"a}@~ \|jr=WF; r,,+v'x,{ǣ9eVRqz~BL#89$*| 7SdO*s}Pb%Ip)>x2i%EVZ;Iii7ieZ:j./1ݾDݎ8Y{\$k#ciZfsrI!F9Kk~?%*59w3I5Lm_^FQy$RNhCi?xʮu2:Xԩ'gRnc-ڬvs9vu-$8gScz AJVAVcbzg?ֹ'k榹/ndR ץsSs q ]LmPjSv>lYԟsJuIoX6d湪VrlJ.,wtNDmߞsFOD,M*}_5IE^c^oNqnF/s隚׳3jŌK?n<7ItgX2ҥE:Ox77'txQZc}UE7ٚ&UUMc8܏ΦX]Rj+k݉Q:wNkJ[tc)V}4ktoY;u9~}*R|W$Lx#myk*b4cecē^mFP#NzݨRKNRM:[nUHP:;-3.Rn=+X=ާ˹;N3ֹ}(Na-{|1D"ݎ~\t*?W!p#̜fIrMZ5^TrFjW?^!XsOZ*2?Yaj5UlѴ3&^@O=8Oi5ZN.²oFmOT,t/'InMU`L<}O~.|D+|6{4VbGEC!,>\4ӧsnXR*K#H<ɶ7r35R~;u.w-Y酯v;0`r:׽vP/lWjQo[\Ҵ[Xw*Ub+Џ^V ֖m趡7B13A p{5Z*1q|,i9+7J'V0 ܞƽ-Wu[4K[t6l" !l}s}+Чgң.edq@I6\ 3]q;Eks$͹¿,xF {Vܩa\۹~UeI?+e~cuԩK hfV jwc'󭩛SǕɒw@3ȧ n3ܩI\o`dn+Q[F-X=]p6kHqb>$+yO7Ҫ^֌c%WlтI?ZeӠyevZ`9|Tq1O^WhcF̎Q#t*Fp l+&:jΥ?vrgIg*+*@8];E$Պ3E v*߽s^1'ZIiiUdO2œOsJ4XyS~pA3Ƴ'3\Δ[GN]HdA'̓= S3VoncLĒ.}0yҼNٕ6)+t^E-k$xڹG\1^*{T~I˷ap#ݜ3k -Z[}oiRWOcVI.>̻̑nʹ#x%XJ)-޾g?-?b5Ar!JaƱ8 d뎥-ʟ<`sjFR+kuP۴Aۑ? T䦥v.v4yieiEeQD 1GgҜIZ0 . 맥{]*Ueی9)))FUy/~񵕻yX9XC-:{F;3L6)4׸[]rɻg\Tc*¥EmLT9G_~hrO3t#c7ᱜtk9ERw R޷ Ӟ-UdD!n" {c9(riӷ4h>Gq#hFOӊ*Qg)TS姧:;Z8r G"9RXJqiUn6ft5_*X0zҽ-+F4]'̞xsڬJ9lgjFWk52EtKpKzhJ)Ymb'\n'ta1K2Nɮ8W6+`+K}-ix8)[j5 _[FYlkcN9kyI']ڥx݌q߭g*N~ׅ^V[%HX,dy/c]JsM7-FkggmKI iVq<ִz4oR/7/1ѬPO0ỳ3?4I~ɭSHB:2f0?Xٝ}g$.X[B4]`: FWFXj2e ޻q"ϻ+"0(N=xyӏCjS6o6It5Nc-LNg}z_-eG]Q:iƥڇ=}H2pMkNu;cNNdN]i/O2}gԊ ϱ4Էt]xsFz.#o5&o;nѹ~?^*eN]\SÕbTK+Y]:ƥo#U?" 6WkF?wN{wN[m̹fЪFA놤c-WFU$Ov_FDi& l6$H~d4L IV$1%:qԿ6rΗ6אy&FӦkkO%[M,$Nq$ǂ~T& wl@ez9JHt9b[cxe6[a-\gԩ.wpÆcs u[JӠޤky|&XEm9%s\f~>kwVN d+J1aeЙSq|ooA1aYmglm<ߚϩ2i3nndx,fI>ZI$L%IEacUOYY Ċϟ5/qk;ϹYVfOmbs֢03R/mDa Y4J*AOjdv]]ʧp\ax=zr1k[`z%[O4,JweccDikW'v Bx 㞇>՜^ƌ]lM-4'9s˗XܩlDgv$sW~F4%OAn#Iby>R <ϙ6*:$&ˋ~ã =r x2COWƩ+)(d8ldfQ 􍬪O@uJ1j72ۑ2 qm=RjG3lˌϭJ~ZIQmJOM)Q lF) qO(%FyErY[4mZU%hy0Шl1̲uS?s˕*a!%DE4Qw9arz~S*iTp=uRxO$Y:4̷?*QVJ[tNwSP{%exn<,[qRi[5+dcMSWW%XԔmb~=F4ynT&\.硩8ϖ=prIC>}" ;,ĕ[!y>l}+snNŷ/2ny7nS0EX7lBm{w9){zךdk"?LYˮ8a=xן*2\|&9{5(~LwEm8+rѦZuŵfg?5Z5hrSLD }Sk1$jđԞxV.RW0E7"mN) Zm~^W=Fgȣ^;i. gKCW;u)ӊV5e)MYGWJve[_w`KTs/gm4Vѕ՗ ^0@s^ѝ9KU+ ;܈h;~aסΛ7N멏w*R=Cö_gGq߿p{ITu)V;yey'z.*Z+~a1,xeS9i|%'ɴM]"~` :u9NQH4eh`W=Z%#7Jt33*2G)* uӏjjNRn8̈́ha2}}Jz[6 `@Xȯ2z{u6Tr,d0ƽRԨ7" v/+r3դo+YjdDvf{] ӏlY8rdUQr1G+^sS9Z-ph;pݳtqzO⣒N6%Ѷ6݀AjܟXGJc> aY?*?Ny:2̽OCDHhl`7#$rT%b% j.^4K[휃\28+GN23 PY`w"j+uO{Um36w FzWjށN{\ÚX8wmڧr 7m|#cէn6VÖZvdu3\±¯o/sb< #=*voMQ0Մ[nٰT}8={W}|-IWRVI̥ZP$vHgs.6~Yl>&4JZRbp,H;~U%*4pNvOlswX4xǏCZҔiIj3A"x@~.(_¸_VЬ=Z|ŵy'jCO=og'cu'I}<ՉwHkg22G"JqrI8X͏V ZbO8RIR_o.)^1qԆyw,i2CzOYԧTS9CW5KY&f~<}Ocoiy/'e8J8U)4ܼD"2lVicVr=̳+WA$#ګ\8xhQD+8w$L.&vibm=I<QѦF2}ض9voflAr{SUFŨ n`@#ҷig[NK;j6IfeH6+⦍ksjSn/\$Z[k$.zf*d*`Qlqwˑ==N)sKi3SJnoWvg W:Cx8ON:.Γɀʳ>޼uNJm⢹[;u65i///snFT 7:V 1їSNrnlI*4{p q qߠ!*IZo4xzSH+}7}܂9b>W}N|=*u=O\y^ZnOf()Gn^Vt+$hc@D0 cyzVܲGd*1U}ėq/$`d=cueRR<47vơ-W=x>ޔ!:1Z!F2IYI]<~XOӥaF~K~Z5Kk7ma$AViMzҔ}Q4YB!e*G9u[vt1^JZm4l/vvp=5)/q^]u(6R67Gq"c {>J>E)-YɁZ"9^F,3M6[pOkNQCkJM;&3F'e"h8u>bETMI*v2Ǟ{֘_zK"kEʍvᱶN!$j6 ßZka3ƤVVϱ=OD$Ӥu#yb@O {Zh(-m.fO?tfn/(#G&*N0,w<+]=EK SF;o /ƫkH14*w`r=,~_̓3F5"ｒj%4I'Ӥ#  ӌzԌm-ϗu*C0%ki4a5ĎI% =LwǿF4RwOS\tUMFt}GLv!xFW ,Zjӭ +Qk^tCi2ѻ cJNZVO赶_PfۆPsqZr.e ET]#׬d6g%YEG,}FjR\Q롭 9y1YU\+ ֗-̪Q4zjNc{|7*0r0?i֩+џ4\eu4tG@w>\znsʱ9Ƨrԥ8r$Ӿ.«>xy73w{ltjJEq:Fy' >lףV7[h~|5״ˍ.Yq}1z#֥ uʕd_w4FM.^ӮHڤHqca}j|тRZ^]>+U)F]۽eicyp'vQ^NghS-heOoKX4zPQ@HY$D_)Va[s8pc!iw$f{ ,N a;sɯ>j_cޒ{tc^[VmL1 6v pO==qjj(^K O|)#f?hܪx L J]S%:-{yؽ/اլڄ:jj.)@ ~|>+ E[oX8|D$˯mx7 \Cy/IRHE[?G{s]|j}⟇գGţ\e z gp<U[ ލ?k.6uj}4,MxVޝq ͽI00qӠb+F]\=t'Q}[]msҾxE(b' 28q»ҶReNڟFYyI?Z𣊯Sgj~,$:u'yYJ>99LuRJ*3MTUӷ]=;:^?]|Ȥ_<#NksL.-d]3,Q>W_3V]JZ9)&GsZtOܵ}{t>a8{u$ )8e?{eZ4%yt&Ohva$h#+qo"Gڥ9M4Jdlz[T\JR2vΰYPmu?ڹwfޝg)ุ!\1L{f[m|Y֎^QrQHnm,*7fY~fS{IKIng-)}$#Y7*ۜ`g.ZzS[}V\xΣՓ]L#U@N ޟju5)|@-O*YѰZ7>Tg898Iwc!4[qQNOZ>Te^=Ř>bz8V= )Kѽ?O!K$/mV]%jQreբz5AIlq Q8 iJe:| +=%d61ha{(ҊOn+b> ̍udu. zstP#/{CxUc{nJylsSJ5Guc9FWCB{J>Ni=zͳ+tD,aBVr߷ izY=S*U!(읟Kuo_:H~՚έjNVI|RWq=d&~Vޣ|Gw.NPQv_y51TRs$y6y?E?jҭh+]zi^drcm8秾:{ކef8sF>7)k~{nba@j0;0s}jۚai_}VVbUrzhiFmc졤릅X(ewmv#r=r%9XmF/]]6kEOTn=c(F*2Kv^gtkrsCB)/# qs//Q;g{b٨0ޫ2ẘS+[UQMtkA{lͱw.6];j9aWz<lr|ʂ#8<_ZrvgM |ysdMW{WFSj.UkM*.p6;dQ{1Hk~ki]۰;v3{UJOmMc%b1JmC_b ڌcRϕsseudѢE rxaiGIzQs]*60&mƝ=U*v3>rHБo$qZ\4Ey;|GR9,:w5(<֖ *}GXeV ϽuBv⎚5]E)2b2pyrtwqU$ShX,]1stw(fȋ0}k2JvT(SS$wgg%aNf\Eu.3kHmʤJeSUԜ] J̚;x%m^ cRTit:,/i'nl%:cd{=;T՞~'Ubnbd.6;kS-s^&ӲK9n#;&i4(ZOU>߉*\yK9jycFQZԚhdhlnī.~7LLV p3zV);E*tqtNGUa:*ƥ:zhKlwFyw*E?:!+On}=::3S.i*l"jJ~]=<)²&2Z3r8VqR莌GEqH%m {u+ɴRس 唡LnVb`1 ~(ɧ*r5[gHmi7#Y]yuBQQ~~y"B?˽+ьlεXԭ?7ic@fel>_j˗өtZ>~s_hvFuͺmrw{;'UyP:Qj54Qi&yەjA럦=*2 1TRt $"En<ƑriEZ_9c}K_.i$X^r6*~^)+,@ +KSrQ7vm\Ŋ񜓓}*c5$ ߍ.1l1gssX2ZWA)[[AUFX`:z ڌ-:iikm0.Vۇ*9 rFy8Q?K:oN~nx c94J2{)Ƽ-ɽ&K((X8VqBfq*ܲJϮ/j.mM  F~^>u@9unF#ϘrN8~RU%i78K_Igv,Hp䬊9T\v,Xi[Ʊܣ 6R06ۓGJ2Cn[l]'ssNQI/z>qg6˜G,q֬:h82h?@YNKQ?=kIT/4-ZJܯsreUQ&\|wd} sƢQ] 7vv ȌĒ:Ъ-Vf\FA-&8䌟O·ssj*_" I >\wsr.=]Mסӽ"YJ$IYz?i_ڕ:U!-Ke{6,Al ^ktO0S[~%mܳQrqrA'zUiԝvѕmfӔ]ʥNx$޻۟~ʌ]h'i mϓ:Q9j{ҟ+u:e;קQ0OkxKqaRT6ӐF9'H9{TP8X=~k)TO *P6ZSVpRWDGw5٣HpqIS.d22O}5$E`:d~c+|JJ`yi68yy*A몄eS}]ASkFQ ~c@8';rVg!aitYu N:EZ7ΪqRc[qazⶇ,}Q!Z}10\Bk9>aǩ=+i˕SU%Dj6ib_sz +HŽ_kGٟViCIs>^Cr*\G{~EM S"k]1ct=?Ny"RThÒn̷o4qw/⢥?9D!uiT64{gi˓eq֫UG`aYV#]cCֹU7hѡ;>[ܾ>oiSuM9,kđI8Eeަ5=,iQMeRU%;rIg+-d,FtV;or:gc(TgNVkiveV)->UG?=W_$Ψєemk{weQ^KqzʯSN""IݹN[t|VvSIrؿkgr42_) ==hFOliEHpa_=ϭiwԯ~Exgm]H8=’FȮv0)EEݻ+"9nG|ѻ.HN6,-+2Wk|I7IjQ,7LxisWmN^i= ި4n@Uޢ/&Q~ŵvhVWp>%]%NqZ^CAen H1ZKS[Eh6 g?$kc8H=#MM\\jCAb.w71?Z#uNfPzgeR#*h34Bٙ;zsb- }hW1&N͐9>ulԏrY#}><>eOǚH#Rׯy"ʷI!k,|\5hqF2adg]D~x O;{s;RRZńT;/f1z珯ZfS枉(5I5U6Ǻ8F{FR[sRҲbko2H_)p{=k7MSXV➻o5]QOL CQ2Œvm*Cq2ߒI9x -c m;˿ТS0y԰<)TT@^enV̬ w9ݻ2/qHNVM`zSZG\KW+poNwH芔%iX rdVF23Mw!X:W;J9GӯJ{9c*N. XP<~'޴WƊcYS*G4aq]/gviZZGF yYSc>I9tF/G>|I4H;|hrQFU5RiIVO|u8Mm)/e-!<qb1N"Z-; \1߹9֩~VCct#vzXoAlf\~_0s[Ǜ68?dܿŹwzI#8USjͩǚ\ӹ1nq v996e9rlOUAUVmtE{rimf g!X܂1U:գs\|c'R>k2wh䌹bҕ dYUi^deSymvmݽ['Ҷ,etc+jKuϛ 񞞴Sdxq۴sG61\/: W(6+ך8%?v{R\bsFj+JKRfIcakʤIhN`XźܪQ͹$JŌIUU]2Qr)s4L.>QsUrdͣ"2nKdZXwӠiiFR6P,ElpA,{p'/?s8|2w,U^\]۲A囶s o:˗oYі ۾PxOEm}MZz.㥆X&-8~i-9 +r"TKm 'ΦC5ߺRZB~ҩÙ+UmH&2=fmp՜(>mԓI,9:ʬsU'٣M@E W9'+^䣮֏l?iܡF*ynS4$Mt+ݬd],^yoïմzrg]N]Ww @{TTJ2vgROHOR)Y7F}pskG1|ЉDa_,<1pa%]oN4vmKyfȕ<;G,Y &Y>UJ猃 s9kSL0n 7 zglAJ2K8ns-Kn 2y>ܑVkeZ8kmI)$3Ve}ƸԥN+EVEX4!UmUm9#׌zw5euw{ t[`U + eIT6}tW'#3wc'<+PƟAo.0rK,l:>J-#jz"r&FH$v1DJjIJI [$q 72ߗyIIWwKbhI>Cۭr*}642#3պtIhc,ZT{^guܞxH q#Tl=+ݕY} %Zlg$|g+hJoΘFUm>I$,k@$?z/VTU*+G\s`OZ}=Yz{D PeQE Ӧj/5עikvվBKl 7a`b\yXe3{+x:{Қ%Dʒ!}QZ"Ӕc~eq~ ] 2[yqʹ+mܹzft96> 2r9=Ӕ}Kަ;?"P ۣ[y*~@?!5܉$_T[܎8?m*"l&7H0`n$1(I6ި9}ȒIY@|/\ ?֮c+7SR+n>⼨E8sMY "V#xWrLpwg Z/riGi2+i-effݝ{s޴:Tj艭^M3+n\ְ_y,֟s#@D[ =匌?+[ZZ4ΙJ~fu-µ1R0 8q{ҧjʄ!vȿi F1JӄЪue npdn5yE}w،+H؁VL)W㾶 6-cf c;}xⴔ9m>dέZO&'iBc$a/6U%*qz,HdUauan2N*rRIĂI"`yE,3N}TU>" {|;{~W#N)6{M*LIWGry'ZF.VFIr;7Y-ī#y {Gaզk\`=RievvNh xƖG}"X1 1LWSFX)'ɤVݻs^8:<=eRQŻ$,z3j{inpUuok%kxV6RD)fSsp:`uJ4tfZqrYṌZo_Kc=;޼]N8VR6mQZyc]e$`m8޲N*|/v>dv1mg^r?ȫKٻ.u$i3F -qN쯩h=ZZ-6%gjeT<JU*ϛU=jEKaᠸEVav*Sq 2-Ri'X<U؁?C^:w'RQ~+BQhw};(n8ǵsj.ReKorH.Z9}hĂsOihOQMud&ۛ vӎ⳩W+^bYkO+J!FPZr "bF.1܅xC sMs8˖'M8Csiew9aiʇM<x2-:Qn̚;+1Dg:dUNj޶4'L2~_3+us9~S)=IV^L%(eg;F{匬o2Uđ;Z56.:Gwq3zu{v$7m^Ke<$W^ugKu4~[gtg_j哩޴pIty[.[nAX%5b翛9*{Og8}~lHB>QgU]zƴVHo,23+me9*4Oy7o#nxGKd{;Xˆ9.g(잺C Ȭw(1x]Z NK5 ֡eUw7}p=+R8ur'ҷZLMY0t'ϟzjE$F@\Sq6܌&*Yn'u#32.Lw{-h6oU%Hڽ q\ !+EU*F89=s4ᆭ{RӿVA [j Fr{?^-4(JyG*(u<ߎzTSi7#T ~̱j%#%NrV [K^[mȈ}h%@`qug)ǖX՚oO$7<zV<ҩ^.TN^n|l~Uyj~K_+ʟ6}>癒;v+ QiQj.חmuצ'['HsBE/ %7&K2y+T~'8cNo#JjrWM{?vV޹(I39ht#:~)|/nrbKc-?0x>W"u7JYT]^UXu׊TbWXj3RzY+7$>d6܃WNeM?S( o$b[EDr>q\\N~jWw[~D3]%mȬw'1wC+A4WahYEhׯX4#i; 0tlocu$v [̮Mm"B$cPK0^7tr8nj8l]z>F&EV#^9],N-&X 'Gkm?L>{:+hVM^{DX6G>?C+ף}= c{۩U܂<2}R)okȢ/BEVs&/ r+ҍ/{MM|ѽ-wݳ]rJ8ƝJR\M>vzg*zt:Sb~e~ff/'rOzQ"[RvfE"_kXӓ&K4Q-cgYـYF@~CGZwncwNvlsN W<Z*P[" Kq~q:ѕi]g K;ffYWշ0FR_gI$l4Yp ymP.3"gV9N1VaZRI O3Kb'j厺IhV⹉ T]inhp4|E׷#Gi[pnK] }9J)uW^?ͱ`m)Gr&ԘU:G[I.ep:RFx+ gg4 :#z՗] {E'ȨqQN_R:>_m3]{A]Nӎۚ2mpRvcp'L6m-3|Ƿzu)rrV„sr=t6f[Fwd-STxKͽᱞyP,sңhI&]cs3Kr;Î~yz#>YSzrpeU^kXʟ6Ԋ.Fef3WnrpֱbaFi+[{#ǕTX/2m$sV3B>{d"ً'>߽h┟c:،D">XHljdP>U 8\ةTqp- as14K3qpJt9RG /^9=kݒzJT&  8WR6D0SBS39K=4q b3c F (ge3hϛDoLe(nf-V%D[؎'>LmvDo%tI`PʷGъ2Z1b攪.dCi#[DTiݙn`YLcpϲ_䷺CTG'R;T`nXszw޸%'es % fyK?-2vp gq+SɽzX(jIZ[f;Y}s=:t43[OֽQOIߢKK}ֽ:\kll"T`u=OLVo2~*㌩ʴ쵿kC ϲTrjz_~D^FE "8y|euմ7l`f`'x⦌w{LJ#>um;Ile}.w}58H%j]9h:._RkdLն۵p;sۖR|^mVʺ>ϕV ϥyi로I+;iwa:K?oLFZm9ab9=-3^0i]c5Lʤ!d44Bwrpw},*"RT쟞{U7-7U)-O"R69ݍۻח(SMt9V!yQt=OGVmvW}؎MAE:qJLKrVwFpU؊~ٹorBWz~iKsjpy 2'5N%y=?6MnVDEʶd;Hԍ][-}>cO<٦ %J iE~iuKR;8dmYL*$sޝHӽ] *GfJ O+PG5 Ӵ`EU_&06ȼeG2{ 9I=_2bdozg1G\9ʽJL5%.uvV(,rtYΤax{#HQ*Q[x݃E݅#ЃWVR"޿Վ)ʓu; i6r2y.21 .u0SgϧyXmVRHV1c3=n+hFdc̒ܩ+h vvI3[Q!X䈶@*= q+&Le[[ȡ%LhYKb99=Og/ΈQ^!QU];Ys׮*M&2wZl\vQ6&ڹ׋Ln#pJ~`r~^eh+zYr_s7*=9Fe~,v8ܨL XZ1vzb^Q&yJK6#fn=ZF[iF6Oa \F%E~mÜvd:t$V!զݴ4|rᱎ֢PocU e,q$3MVq}^\-άNRK)oֹv)Nk@xKIVTo׿^ nfe*R4{FՈT\ }}JRo4muFeUR2Vtc= ul,LWק|vԩ6D2$v(oݍg<鍣QWsؕvGY9]jOv-.G2{ *n2j[2!'?3nn8۱숥-,CW?/^s7Hʧ$!K3-˅OuϿ\˕5+u#Y?wo!dsӨz;ӲўV1S5I'q$% }~ޜכZ2ܝzin%-M!~CNOS^MmۊHQR<~ 2%+,Ŝ`@LNϧS͆&3&vB'5ʋcR+bRmS!ȯSh/k%gtDh㯿JTF7GgjvSX2$K1U?ISrB-rBg7 !NVʎy'G~#IԔi=|SG&1_ 2ⶄg*m5o>rԔjZu&ekhZGWU, dy:SMktSNϩ-Wnyn9#]\V:tB ~CfOܥW߽gZ4TN:)ʧ$Zx-vmOͼdcJz.MBqo[$6RmЏE]H$`3Syeueo%Rq!+N~N[Ǚh"ӌZ{\ΗKeu'?:w޲:l\N#J*/iYZx\8'ǥEjQG{?:8ɻ$bY";'e~eP>|GUn6һќfq"+"1RkuR5-w$&gX]*JEF3y'mQVhsGю؁kybp]gY? 1mڂ=|. 9*B*ӏJk[.!ȼ1ǰךRS:T8(|1yooRNsKB{"Q:dP4rVvguՌݽXMŦBB.#2'[0*75%B;#v99ʫM{-;DnR|:懳'IJWsr2 TzYFQSU{Nz4}V#EuؔI),ˏʭ6SR7[DzsϿN)R4#(ғm|^m:"L7RNԞѥL?55R]ӷTO,dYGъJ5oYMV,x?֛ pNvo[xFјRGƒdu=i%YߧՒ7+,[#wf ͎1C h͔ye<,jÖ+|zy2e?&>Ԭgfn3tKS\=Zty$$FYNР` sߞ{W-JqܣwAOJ[]W5IA xx5s4(rSsn=~v=lͻ9؎֪1T}"K름9'ؿ3 iU”m};q};܋!)4s{G/[eRe'ޤqڡYr8H֬>QyÍө<RK >x@OeN)&tTz۩ K^Ca thӊVzEtմ,x6q}'xN抲P0d3?}2} |F*V{h?|Ap.Ƿ(޸N+:\i#RNif{ MRSXcם345ڞ_khO ռ*LP>c@*TrF:OWܿ;{a4Ks !2w9SE[C Y/׋lj^uٖGXwk繥vQ}nTyH񦫯ǣ F4qfc9\ʥ^uBνmhkӯ9V.grwKeo8YQOITZCFWק|U Y$s-8ѩk[K籶aZ9˖A/av"<{tRxq=w|&ʳ~#G+FR2罗!0r*^dt<}q]IZ(TRAJawzrTEDL*Tׯ_Aham,KqJJGMQى|ڽL!71=WǙ'/Ռ~ah&A& uܲHYveO9fYK;4Iy,IusϯVXʑM?XZ<ƊI~t徵o1Ө$%ah<"ϩUN1M/BzpQZ}HdHe *cURTG,]͵Kc,i<{ޱGޏCw%K)'cUqG_p>*JJvM^]Xd U亸yfh# N2y9(EWcR}ud"p>^$uH\cǷGrH9c( %d[҉Q{Jt(_W@.0n k+o<}µ ђe~ሔ%6}4DcP r3*I9*Ӌשiԕ7t[ZY2<8〉 z~^N'?1wCmlf;duʖ*kiBI{4m(J/yjͰī'=iӭͿ.d},DySnFm'9ҹTu^Ѕ5t}Vmewx.|$N8~qf|*S\7Xi\21 8^vvT&3[nGLǰf.1]Rӿ]Ol ,>jNFPl^DP}+.J۰n5R2'T_tzLC4ʞsJڌcN\'QUgC9I=Hʹ+nS镣$|U sZGӼ_xz2xO4W+"<\;ŻuZ5v[y$&3ls9<ֱI'S8ɴ1O/eyX-J8s澯%NqF}Hͺ(|UtWrm&|ܜȯ<#7HS擒V5c$EQW~!8t:Rjwʤ#uk[OR>,J#o;苑n1ڷKKjJqe Q5δ-K #K',oj<#^nY6As$oH'_j稣'~uw$itH!snjX㠢4aҌjrWbϚk)I{Z*B13Z3m so%ϔpOڼtӒfѬA},E8!ۺVɶ"H㶹i;ن z{"1O-$Y"积>NѣNRm(۫J *H0\#khR]6) /D*MKE**j4qܼ#蔜b7zz7Ȏ;9X†fb1;z ʟ3A*݋ItlnV |ïart4QNgl]7-#$tdpF׻%1x´(GJ\ʳnlހiʧVOAwk+&f˷;GU*2?Wu%y<^Yex,uҪب֒ZE)2f4bQO~ )FdDS4eI-dӧb/mj˚6xijMj˷|<|B®t{Ib" ȽmQ|!?W#/xR/Mg5͍ߕ.&}}⶞5)-CG^on#h8.rg$<޸/eSk˗dQy|z?JRj|XTR4i|[y/~gfIiO,*T4pJZ97+dlt`JR{ P2vO]u,,eo.%Y=>@:ZPz\V H.$Sڽ3dW94ee%r2[@d1F@R"LIけINJ6Z3]qDq_`Ia6+H'?^ug-NwZuy_(j{6];nBCb=DM,PDԅ"YcYZm2XFr;9#N?ͯ~7˸*dʰOҲ*ueK9Vʊf*f5Jǧɪu{:y2ۃ9o9RD27d}q׾*]Nh$^54,Ei`$-66ұ+g/h5M/UX[d8ߛ|O`?/:ΰӏ2b))n-|$ՉQI]/lVro$GdgQ ߳ʣK=/$*̸F~Ɵ`&1Da&ehf`rp2OϮ:V/r[S-7E8$]w.vZWĞˡFQ]3YnN̬YUpF}QxTتJTb6mZ S#Ao9QuF%`[o#mN?r֍:!+X豼άdmUX{qRs;{9ai/_Big}xtޟټD_P14+FF]?׵c(46SqKr18rmʤ*;ϯ]11ƌ1RRtڒHc2G sgmݝ2tegKO*Ʋ$~\m2x$s5,Qɵ-LP;2ƀm8{ IY )僚g{&ڏTpH' [FJZvQSƾE`y̙,6>c@3J2G]id3 *$'o~+3KԧZjvLv»8 qToQ{Ϛm'yHvɗc|no^==NU/gʜf[^d31FAFNբ?x{:vbpd;cےysҔc="/sGi^6FiK.;~"8<׹FQ4y$f2("Uf-,{5*oA{j*6I+6=,UU/Υsx(ʤ]O[?2eE<{g[F^QQRSZrn!OިkJd(9SRgLD]ܹfP~R;߽mj2aMU@^%ai3vYN+bsjDHٙvܟn{Tt<(MlR )kua''=;fT9*JbE%Woʒ,G]''>íO,7fܧMB?!i0 [=2qYQe*s$sHVI2֦ӭ%9~F,%q,h3)s{2V 0eY0㌰=gw-$khdycv0A<cfӭ*NRNւ"- _%K63|sIt9Boil73;3my8hyyKbjGUS6L fIvq8=wQ2wD0rYFYNKmɈn~HNa7{g=p+9CDcZtHn!%XI`pG88bԟC׭Vj}loxG®29`AЎ@5 WJu=}?252I߼i t?:bKSSp]H*SJr_[U(Жn=yCHqV]70D NG29+svYV5{Ȋ!lK2BNڢ(F7u+{8߾-eGkrmNIY؂{k;ܝ*"q?#U SZjdhz} !;IoG=/W"$ԓ֢{^%/ӻ+RSu=9⳩i]2R.KFVU'q㎃֊tci\Bn+MqԂ;w5SԷB#%&۩g6i +Hqzm-nΥY[6CMViu&T:znToJ*6VԞ^p$i9U#s2 #啑+"d_%(>߭O*QT&!Y>͑2B_.T95g.9QQo[3RJޒ#kfʧ?:~iΜ؎[<67~?󧥮kV1wt$d8,ʬp?[掚jHY[,yi?CGfqu=W[#$w'jU&zČg;ry?iʡ%uM)őrc瞸g*=bg(ӄ*5Wlac}3Vr41 J6N7wi7)Mrt禜-ȌI 3עxNLhΚ&7y+iӯyF[ pFSh1HNV$3{W%E{?u6D#xY,zjԹsPV`]ucwP RyӏsK-2eT(ij͐6O ^4O=˝NvU+5*䜣kpH$oٞtDhc(ÒROaUǁשT6ZTtPΉ92#>1w/#iavQzW:{}OiˮWUXZ AR3>YJ6lIYR9# 9zVNI/to嘆m7t?iV0>Iב)STcV4Iê[۳ͮ?L*)]I{LN{.qǷ~5MS}JFmĪ$Ve//91j[GkM©n"XFr۔?{q]\lW48܁T{5(۪4ZkX2lr!ƹvF{uZӧ9GcgN uVdX W d8\G!F8nwf-۟oQ[ǞkjK5$,d8Ē|G'ֺi=y9ucX|2遌wZi(;#juP+@|뎄MT8ݱe}Jh{MK{;?y7w4!5P~lo眞sڳgG+nE.s0Zij~@nebYcx, d^z⚼wO:d !)!TL$`^khS5t%+,^%(藛4e%d,7B)Bn-?zU˚TMN2@|R[h <x8Ǧ}xINs>ݤ,2*iYYYVlҰ$dO'*Mu0L$g!>m{mQYԽHZ8HDjBm>kQ)G}Q5C"S҄d8\W$X,NXUmo6Ѝ$G'ۙzƛ~k_m*S{;rz1ƣ(SjJ _͎'T⒓ȧy޹O qsjnio˰x $`~%sӎ'R}2Wʓk4wz OҦ>鏻m6d7v929%>]JȦF,pݿwnzcݻFSqI}Q a ?1ZaOMVH/7ulAdgy'N<-nTXSye@<݁4/t^L}ɷa㓌r;~Yr3?te{).%c)+r榭Xѕs6AlcLy}6޹2]Hb/!nYc#'>2cG%rG_ 0`;k ~{?g{4KƍeoxǷ?aVtj8ō6j~`EJ`g:k`Aƣx#«͸ p80ڹ|KCsSkkm %(*p}{b%)^-ŶC \\l|g's%(Ƥ-Y# f#mr rZQߧgNyӺ*!5$x8泬-&5h7 6el&q xqR+#տu,-#IP6;Hp=G8Y$Q)K%6:o98=9a˼mN/RmIE9em0ezq߃\+kdw NߊQim#i撅5[ bلBGv6*Xv1&:5hYq,6*޿{89h\EbW^dMmwpyڜOZOܲ]ҧ)v-Z6_n9t:M__ioݳ8߹=1iN/ww*>3SKM(yPy*t{JkKzl}5?vEx~Uqty\[F׏ TVtm-@JٶvыMJlEdXʶ2p[)iXsj&ĒVZ˖/cQʆ@Pe|*qۡ^ͨ>T 2_%rg@xhE]ܗ שZ9#`C, އNά.JRwK^4X]k!1a+B|Θ֬m{9' I39G*W4*u%yI$HC6efncXvGN3sV9cƫY{9Fޛt|!kx"i&c`}j|DGqUF˹:|h]n3'"M l*˒;}:v59yUmd߫x2G$1k4m˸V$K@Y59I#1[3܎:wJn"- M1]45Ƴ[_O!2B0Z7dlLϸV5m=um1wp}?q[FIki*1Йu(I"+(˞{tN]Alc(V}:1ZTԮgGu4Z, zExV)e䂻gIfan" ԀZKu$5%[2dk_#x:s]\ѶJdR[q,B3'. R;H?u՗ {9+X]=,UJ?]I#Tv{N qF?HZufo1V`|RUNU$֖0QIZݭ$ r!L['aK]2}j-U|9}T{%=*+"u uLXPX00q3+YFZ*5NT6K,@,zӿ^ҷc(S[E%Ondt1/dlgwn N}k9svܵN1MtpײmD.{GM9Rȏ"quR[8=ǭtӔhQӌ񓒽^]l`Ut߻#10?SSI]u2YJ[l:;֒d+mutthw4D|92mYOMK&4jMnE5쳺G8Xe$gaoqi4ܭ:)<-yEbIZUPjn1S9eV>U}\|ce'%6A?k*]Nxk"+r2Fw =$赹~-I]nB30t?SQym~ҥ:|ol$ ]6쪮HY'(9F̏v2WRǯzRR~M{׼3.WO8z⧖N*IyHG٩'_,fx%W)P?/YE{t#{H<Ő|1 8JJքiU|-m2 E Iv3Lx}7[8g+V{F .1UQމ.eil ؑѳ Þ1}ƶVC?Q۠ӶШӧ(YFaE, uę^?Ռ79jGNLu*h1or+ =u9>Fzus4G. ۉopo{E~j,ifUrv9=N^4bH.ܲ*26 E_Y6?/Ʊ9J h?iNP̎#Qul\F<ɥOj-bNn 8q\U%˯CN[ӱ! -&L_jkG۹S-%~f6(Pܲgwn qq&fU۳ gtvZ^UV" I5fǙC'$2?:δkWCݎ|K8Gf!9#^+?g)Nm5&F\kz,7FK4nV̎bv9$ҧKFZ*W4_n@YR'A#0'kd.92E5/v0禮֏HL̡ٖl0A>6Jqx<*~6 9bdzt3XWal.aa7*e)*.N?mkS"|-r8'#;=Gzxzя4E.YTؒ@ĥbnU ckmcN^M~'Ei.XyAW=ZeZjwa%(˹hyͅ`'"Jt_#ח+~{r=LGLz|(2FԮ}gRvԙT拌o TU,s;zxW,,/om#*7d#kTuZ*R nhՊ1ܮz+(F< :HdD Wʼzw+I5+(s_'2>>0naMsڶv QuƾcK\kS~ZY䵭"Pf!'~5?,䢛];ɭB:)󤴻S#܈a[ءҏ;frC0z-NOt:$ D)]pGs3C U{mFYad0q?ycNgv9ʵIF8[}+).FIq]4eK[A߹fRCZ:h㔨ʒW{u"h,d}=;Stź}KKEӿ+XzrI$c4͸)9hN˨떷>dkۂ`tc]I;yk%Nڲ腒xfpYU$䞟T%ɦL+T\=#7 nu\1[[ S,/!'w'R6wR{w[f-? F2:s׃[ѧz^};tT[׹j [ w ]tZBpfmXZ[T[l<玙_M mY|Ca)ZyZ&ʾO͸|mQ]J\qDą7;A~:ֱv~E+dS?w jK5Bq3I8~R-ÖJ\ܥq"w͕PW 2w1JW1H c#fFi1߯:ts%UW3o! kt~l`sNW K:Reuj3HxVϔq r'rVv9kRU+% "KnUwt̀mvNןʯn9T[oυǟ%hd,O'ok*Zy%YahCgҵQRӨъ?"VQdX{v\Sӻ\/>ȹ$11kHɭ?T)CⒻJ.&dmm3>+5g>RzƷ1 $<5䌭btZ;a,$R$ ޸<ckumH 2VHgrc#CDe)t*2|ͩY KJ6V% ~}+[F=Mi3﫺I;v[[ix(X!zt oO[JzwB88p˃mOҦQ*?#,nEm)^vDXdUyxG4'fg*qmGb8KHWi'~IʜuZw 08Mk#b*Xpj%*Sw!߄A17p2jy^i<]6L{LW*S֭w 2bFF{}*h>X2[/ |*&'OoޑcNVzMq4I,K|[n:g5/Vki֔Z:ԪD˯g*nns议Cot$ff?tw2._v;?iSc4eMfrDvsj޽NiɇQ ;HV&Tf]mqO 5mnq֍JvNdnBcYtoڣ3W eN>݋ 4t` nS=1"T8kb472*_+ÖֿtrΤYij%I ˶xYs FNNx?u_s uds33+lv8=\=VUY݀$!@bw``>Tc)Ene8ǟ2"PBSTԆubY{؆ endD攔"dsƵMLwdhYVI7ƹ%R20*F>[I/ i N?s_4]bQ_nein1&+WD}_vaO#wX>%Q-VjΟwWORGE*˕q>)'yE? +rAZ49Nq[}gT*9:.ھ"(¬3QPF00qXVӓsƵZܬ4虄"&uV#ch?Φ+9s-;zUJRMlV,E]}RzCr{*5#%}q*T.tt腤WT;z=FOCߥqWEuGjM~RJmN7cҨM) }}p(J-]OOϣ3 XK2UݷvN y_WsQ_>jkO33,*y(HhoR 4m"1k:޺**ZJĒ7CXANQrM:YBY$?,Z:eE 4 yեK_O%SbG!*x:EQEӒ~đ~\=¤.J>Ϛ'W-iemx׊ *&J\zt]Mko*H8`$+휎tZXZT}JňR7$YnO]^g|q"_pF~p߻N;:_5He S{6o~ǧ$wHBkFqhUN7Sm=m.goV\?uIʥ/yiuS'؄Z[Iq!' v:vOUZbծKISIGWpe93v>.]Lk9F1W9#,2& /4TGeBotjzݲv9,=8ʟ,^\׿gmc[k [;"S!P$λSgkӧܭe6z۹O%R˒O{ԃEhƝ9JVv}sI2n1đdžULv3(x0EjǠzxa@)AF2~hFm=6N1ru:][FX㸝D<,;v·7jnBXROsFϿv 8#^9J'4UKȱ6ՌU߃\cs:M.ExޭEG.de&mZL`˒q8I"TEinݩYːy׭)JWݳF輫wm#װbcu邔ב& cY/Ѱ=j\<c'h\lK/)c8ʙfV5nw=q{VzLL N ]I:qfєcMIg\[E8zz]T%EUhFBdGkHJI 3".iS:ֺ%Jlz4*\܈Xf#ܫNsn:r伟^D[RUY;zsҵ8߉isǩ4:%1D0ʦ@Y>XF.LIC}V%:+ mȕ9Iyu.&jCu7QϿr;^-#<=ӟɌ%NM-o5N<|G\tcFVNJ? ʹs&cE噹^{y)v9M[nDMۋ2H\FcN3,Gx9EdE;~j+.M7o%U2Uyܹ8C2.XLk{١rVS9*5z? ZwKgr(c0][K4W $23ۥo#IŜxT~>E4md*#zvfJ+[~F16RM$TYr@>^dnU9%x5klEc*h''=GvaJnse)-4 Z,(Li2:?JʤdJ-;1vʰ1SȼWRISAXtߣ%$*6qzt98F~η*D4Őm*]cyԒCobEeq[!deU G~'iGSZ&^IդಮN26G|vYV_);렗r%HKVڳsr@;jTFLjJaN0i4eǓ,eg7U*NIV1޲:\팪T$8gWw [\/a]QJ{XWA'Ǘ-¶́MR^H%ADiSjG37Or:5qr-B/c-k2<#QIco88ϽEi}^Ӕoxʌ&VLdmǠ?/W$m<#IFK5q32x;d#[ԚO/r_jqxQ?o等,*#/ ܎ǧN›ZѥNVmXvcc,()89 FI-ˏk9tWV;x~r{ʴTչ~^O#Q|Ǹ>`i{5)YKm<30צN;ָVkt "Ŭsۈ*͞@?2[^șѝ:)һ}RHţ3HzqZ?s[uЧeܫx-rGo,V% qלrkʖNZ4J.Wb}m_6p3U)Qfrir;vRɑݣfQ=Hpx'K*qsV~|)aW,n.bX%GvFUTNp1GIr}3/iwDVWNۮ. n2n?6dB4Uӟ/3Z?*WML-+#k6G;;%F9[y.4-5 3+ysT!FK9[ >_.< EQm!cƯ1oo){bip.v|d{n!*urSi|۳0vl}S=9~jRi}󹗴y"VcH'cK~֫NkK]}}1bw8{:bVzg\oq$>T!Wۏ#澳'vIImdzk)ִxVGIpp8<}E)M[=G#'7m>i&A0e0(2x8_ic9k_=9O/꯭Gz %1BFx8'>5o`s(VMS G0ա}{ƻҬfY$"?\ujozƕ7RgR'n,Jwm.˂=A?\.UiJZmu:@<3)B2W$ :gU捻eͣ34ڦ[fg,#9cǫRTkaJwІ_:BrA|<5>Z4;#NKju#k7x_2`:Ӑ;j~ަ3דۊ_Tdf]:\ih<<*F\zKXk9m`pŵcqߩv'N3My>'@4=k[](NT=V&/]?y*i(ҼAkߥvpM7[nŽG^r6&.\6t]/ >aNPJ[d߻ղ7yow%qfWwg8'Hb%vk&aG S;?wZi7S%Ǫ\/:d2y׋MI+vyr￟C].ñUfm'pHpӕ9iymsjt黽wO5Ɖ3Mݑ\Lc$#ͭ(n|+Rz[jvmfamsW+1::Rhg3@=8=+ǣM;}:R?)i~?&IJVO^ jRΎ&AOV$ۧ޲ T`z+>YJw~^/eE^]O#3&Vfs_8eScrRfN$w$gtq 6zZ/Bu{LDm%kAy` d9]n4S^ZvCaiEHj^x d~>Z~ǝfKv5nl܌^S̘U(E"X|UcdIK4;}iKoB*DXdW)$ܻGֳ7 ]+"攤ՖL3Hn#$ڭ"pH[V#"rvRUDΣ[i'ޫW5r-ՎO䵳d{i!2,H=){Ju*$顝:tgس?J4-;g{'b5W:¥:^䕿>a 2E!IW6#ueO\GM'$֫XbfW=@~*qPacxVUM/UR0QΏuu^Z;G7*[DW< e}݋WcV !O޼&@^sڮ<#ޯ*Ϩ3׆9I&zxN=eG|jQ+wV\0oFGRE<=ԛk=i3Fof\@<0r?~K\q2>HV㝧2 sQ;pIGTiԎz k$@4`+FNikK-hA<>jy7%<3LM[Ƒ)Eݞ:|l]9;=ʹ|ӵ\T%cwji).#6a0#5)εegO$p{K_K [XҺɱXɂ)3jTloQҩNQq߮3-1v~R{|κ%N}v dX*rN+hS*q(Ȯv#F98$'8Nba];B8RJyƏK`˽A{v9::-uת4(ъ{iFϵ0oUSˣu;iZܩ%ԢD$g'dUJ1'4F^ҥ9'/vVIc>]?S|J\0S{/N{_*~ua!M{9 dgvA=]y/KȬr۸c& FR=7EoḢZSMS+bʚEX.qoNZ|/RngBj/^?]98?³FU/m m23S*a֧FqmnMZ&$[U2)yVT45-cZo%e«aB-?vvHΤ)ᕙ,w7;CT )S>fHлȹǗ&$1S*. $%w,Ăylg?ZN9UH))+um% >ƥ2.qŒ:V3:е`]ʻ׽M8Ե3*1>a-Ϙ譽}:SQMlƫI;bǨZ!̢ʣ)s]lOA,Isg{z~pSRN;.o3ʬGi>ңDRvGwiȸ{VrI< c$ ҕGilsR_qC+.$, sڲ{(F]~Dioı{m)sloz!4L`?obwC29 ޜB)u9ԩ%W i>fvmIN4]'4 MIz:?;̞^G~3~"JܑrQ{ky!DyQv".~UZlR4wFkmMk}nЃӏCru_xJ0pjlj$BHxSұJsRItV~m/cd3ҥԓgU$OFѭq~SYZFvzPS+;p=\{WUmg6]3ƒ!e/pq5PBWՆ"fȦDܝt ){皣~mvU %[tJB$*nu9G9ll+qmxԒÈ*vWkOglmN1Umo-Dν}Y Yulv[[DO.<[)^2өM>[>ʷ+#Ol'Q'*vzۣ_ASȽc{#TJ*pю%Y#%,JTk#h8Fr{nYUvZ}emFNYNǥme̒wcXjܱW$vww6}o6>z>Nng(rٽm\LV߷nYӧN5UsG]-吟/Ʌ*W|=kQӡ.jsZ$hD^XUPp>},!pgګgp}5o{UPXUH681^Z=}Nyԥ~J1c;Xv9']4v6NRZĴm a<Мu>N[[Rr>A[ j¶1;$vZ8Yw'St&eB(b21NݧӨGdVBe`@x".]^Z(鮢EynSۃ:VrcTCR]G-ܓ4Y}'.X3I}Sh#f$$u毛QMK[߷gV=~TUJtĞ[v-UrU8gotuȬWQȮPq~yWV)э;-/6:rYmUdr (4{:9rEԎ[}- ǵ~*/wNڜ?)4}{ĩ,Wr8mXxUN_7$J*tXÙ~#Tptym2yrYWꡇC2q+So+sKHAQ%V%’czd_kJkNcNK$Mw=VNH)\tcY)jcj>{I1XkykpGL]GYo}N=;ȝ^dEDq'c|$ddQc F;{vh|{X9Čӊ/bߣ鐩Q51s {s20:2Z'̉㲆=݀?Xdg<mJ=*ukQrZ+ ͹.ۀ^HD%$a 1.m]'mIw|I?^)zV}Tݖ֐ YUYK>9NjKvRE6sy+.*XzS/SyVNVW~[ĭH|ZUhޯAu,A7Y# r*v{lBw[K{2vUO\=kU(5W+I1e1,pUf\?t=z'N*UFlVIBT*Rܐy?*eR|$Љ6UmT*3Vծ ,%UxY֓pYRw8(:RjXBtMo*fNycRJ4+:RJND hDJ z8zwz܎G rvYJ갵ϗ5RKB=њxxeg*24t1YMdn>F<ֲҷ/emu7t6(ݤI."79ܻ+ӊe*TfkC,f/5i#;KONTT74oXFR1c#''>c}M(RkPKqL6p?vҦX*|fI#Ym#v6#ׯ8J\0jrivE|iJ6oǡN:kz YDfܡ,Gۜ~]X'rD֫0s?u[!:?κcH:n EvAy)r ,luN{dN"R$=g rJ9*{FMi<"3Ƭ?͖c\Tdi8J5'F'Ө5[Պn$1_sn5z诠ʧ#n}9nc({jGJp<\zbtydqy yRrdqO;{doxXܞNJq;Is]f?/`9QSpʪoz`cZ+_/Ě Ŵ̑`T`TJFqҩ߽rRf%Wk2()"Ȍʹ򗜖<&rǚVbi.^XrU^W,)B*/gV*:Eg#h\X;E9p6D ` itjC3JFRc^TtUNd+ya#d}nQk\-˺l4'~zFЧiAFϱ\IHs3cGy>jqf-4ܮl{bǒZVBC"I=ѫ@HzʊI[P)9:3Ue8 zW7q\s[K2.Y6mJHҕE) tydnw8`5\9Sa/g(jBi$K[Ў (ThƥDH-p\.>lT5v5$ֳM UCsڜo_mYfwU7=Eo%ԼI,ѿyrpG9UMJWWסJ5w&uk)kjpXcsjI{*Kŷu笱̱¡WtmNTs+`LƟ4h;#ͻiST^by6 mH(< ?AgԼa~+,^[)cPKvS5KNXV GN/N8uUdK3c69aϵk"yT=O[a3ߊӗm¥|33DswN;ߥm2eʑ$gR| TiZTZJXf ;.[I]Qz M\]y˽rp1g:n1hG$2<%oAiQSm%{C93ö=ӹR&yv,'nY--h{Ǚ)Veuf9 gvwzUҺ曾U[?mq=>j˾?z$f8?cX[`88>ݪcIF,ZՒ# U*v2: mKsIRlh(PAګ<(ٟJ<kEj4j2e#-ng'r+}38-m8Y3FVHQ*툄drq MTc+6mRrczOi$Q|4a<~Rbxǡı,Cr6^{֔ӽ3q*J7*2KgsE&IJ\=YC&Td fGeNcƠFw/8>j7rD* Whۜs Z1MHKU&%jGơK.ރUj•5*}ߩJJ>̌Ϙ~S1ڹIzhI#.KyVOlc=Vr)hjz;IUV,9K)GfU)R)n%Tk_F1j]s.nmU56!%;T6 [ gni]*\ACLťUik0l'z3TdU?zlC<Y2 2c+*+m%qޯwZN7=ۙac>c8+ipP;,[asP(j\71D# 񞕔LkSv{GJ&ܻTI gĂ}s~0Fk^c!;̒vn}qJQ4L}Xܮp]Y#|T9>k?gRfkV*ܴג 4*иjM՗gYB.JZ#V3e!a" + ;xϷwLb+ֆ9 6:mN+Q(Vc.^ir5B48 nlIMWiFG9\*Jss(z5CmoVf0;A?{;YrWQJJ3zȷ6lF. z #7=c4 (aY3 ޼ʱrR9N㢷Ӟ!"HmV]8:rrYŷ$4-I'}.7[Z:!") 1=;W/iUemXw?0ڿ0oRcKhJ"ޏ/ߜmQև 2OK[5#ŔΧhM]eNkHi?xv9'qY*Rg7׌Tm뱴*J'{ekE_-ɸO*Ӛ;7ts{Ow] HF?6#s(R1pЌ6h"v2̉,n(gS%N]t`-ZⓁN^)o!RXmaUG=9Tj_ԈVZEF- ד=ZΤ/eZu*bg ̱S%vq=Q)Gz3G_㕶t770 װq hF%$~dZ,bn2HYUU=ԵDT)I/{ 2:+Tva]kB;vJ!6i$ gۛQ*]-OQFq99~U$u{HV&z$b/1ՕO9s.k4i*TF%ar3k<`c߭gzrc̩O_༒;{dx>FO|߾>mGSs-ߠ\y-bfl0ڳK^eJFztG 6i6ehq׵(K^F2Nۍ)dc|z4y PhͼC+!~^X{I:NruǑkc}9#ߧ+J*e%q%Ó0kSRo[DEiؒI:A#`(p?˭q֞CLPr]|3nKrA'ұS_qVa*2Ow>ݦ@bg=5)FwؘU{/Hέ1};>ZRn:BZI8GyCl۷ps\uO r(gR4o#O )m$FF|p3߯ajʹ}jVNU ;>HBVs*>i_]^~d˨_ZĦv2,s=޸kJyICLUK;ӯMA7$q`(ݐFO:ӧJipiN;yuE,$3^Zue5Mv7Yӷ\DeKWv37W o{/d3h|b@s.zMrӓiNX<;NMn75g_{zs~U8œȭ4Wm,ݛ ϻS.WN$_Mry kkJUڼax#uTUQ&2/uk-q qWjr쩩IzU^X}ԒIck},l K7̑@,r~ZS{$3J7#gZKupEvDTSHGVcE`tZ60hތ9GKŐZȭ +]FjS71Yױ}ʗ/bS (MZ:}zU*yTq8=Iӧg%.5'JG6h9ʌ3z w*iʊt#7w&Kt$ݫmY#qKoэ+$z (7FI\fgf102;U4j4ּ#$@>N;3Iӧ Zhcw &$?8n}*5+mƥg-~.4f;OLgp#Vn;4Ռ*P2o8be{v8Q!~xұGV 50ۼf˱/n[:Fd`!89\+؈?v-u^߾A'<z|꿯cWPÝVʾe5nXs=5)P73HA%|`$Iʤyhw躖hIuʊv@c>ֳNU(KEM+Y5fEid`۷czҏ)7&rfy^UTI}w9Bo-Wvv^7k o:Xq;Xq@8$jΏsuzqdl[X$(_]P9 z|֕%Dj$L7'OW>(/")\F. ҮXXKɚQvEl[푓|^~kHӕuOCrIi}1=xkލ9ԨY-a_-מxϨ$E_Tiz#u!V}ݻ:uXkkN1snEHT)W#!^5Gf򵥴ֶ7Q<,=3 tGOYuxYnQ5==է77#?bm Wϱ"iKV3~їYLyz-qʜylbH˙[PtOqV~\c?XsB1.?WY' ~s6S;϶GҴo̬-ju9)+1عA䪳f{t<R,އR"9SVȍ HoߥtF̗?lnĀg˿=OmYMOJIioK cI/͆hWUOvF4t˖%O4F'qrIzgֺ!)KF#J1mݑ3h%M_HYX{ut?JF<&V{o)n lcb0qvXKr2Hl[G"̀lH'qۚg)hԨ.k$9󃟧lu%CU(Z]}x#{tӺT=ƵH-"L+A]яߓ*Rela%$[y+ooͱaqt9>N{tS;[2+vu E:3^ΤRk3%Y@m^Z:ItĈ,qX ~+{Nn['4V\|?/㖽, F ܒ}{vgZlҭDӵfC4,cTsI_dMJNV$ %!s#5eeSk)I8ɏs `ݻVuYTs3`˜،{}+ ԟ62F1w{3ƪe 7#yGeRQc+ 72*!}OjF:ZyKK1M${hݷ=+9(gTehdxNV=>9gx^擓UU$@ 8q.N>[*Qs?UYIrZ/B?2kkvί䝭Ԋ򵱍S}ŕڬd]By'{Y߻W*NBIQ'*}`7] Ҕj]-rJ#)!<{Q:LE:,.}u /?&fS'RvK X䷕2dH/ 8>~2N}|N"MJ+Gx'Y7}=~).^i_?П;l"ma+6޼}H?UaN7Zqݻ?B;mdq󿖭w9Бퟥ쨹Eyknb7dw|XF<8O)=K:yN2N+u-+O F#)5w_ֆ&g(cAҴN)|误MbKHHx>*&># +5)jQ"UdL0rmʣI; ?JsJk֩V,/c.K)֒//o;NAn:z4\$ϭOuYVkT2|pcS\qkTa9nbˠDnq\38*~\/q*=ק[jHV%%_ZU*r֫Sҕ%,E=c9>W)_I>,kuQhsT#T!HJB}ǎ9Ҽʕ'֧>~Ҥk!=*ctBxQ촏C .|@((ߑۡRt;/ Z[Y9ݹ#eM܆8v\MSYqBI$C.##>)^7KnNU9TXŶ 2|z:*JU56wC+"7.69gu a9F:=/嗳Ϻ-04c#3dy$+:=oesI". dTۺ5p8znzj+mSoS8o.&e *<@{ץN3 BWOʮO=j:>';r>jjOnrIKDs:߸] z ptױPNgV3# *͌pk٣Oޥ'Rt>Xoc_b@3ۡcOSTޏ=?Z}"(1fc\msߑ bz՜TiI8 'Vi>lo!*Ns˒RD7d&T9$jʜcj[?VNK^}hmͺB͓WRQ&qtԯvuei'1J<񞧯;zvzFnž;bXE}71圣%*>aձ3߭86re%PQm*:'$8֭'̮ͣ 1w'V3;GQ1 n^M15nG.7I!_r͌7{++3+Qa^9Cfd?Z*4/fp[3G"8Ps̸Ӧ{Ƥ[?Q5ĝ<ܹ}EUTd"\.ěx1};TԾɨ8P'Je??>}i(ʚ9{{PS4e1J8!GjOV*U9o+ 3Z,FHϿY˼ь[=2%Uj^G-iK[~4lnZ`)Vg9$k{sJM^nm#\#=8sv5gvMޠ]UHrkNMvNYy3`t-hj#޵_fvۥR&ӵR%sַ$t*^jnYmav_7N00~ѬxhSv6H-UdVm UX!(4aFBG3ƒK4UI.O^=ִGE:q6Ty!ΙڻivsJ;˹]jvЗηH86DF}sƥH6:+GUIk ^#Icw\pNA~HʥDz빔eN&u&6innVi:O~?AX敵zsZ&46$i]Mmo_Ҷ44[v&+N mV37=¹jQ(ۿiFwϠD^V9 gG8etlXԩe%g"f?wמ1P^^9;8777?2;&jQQ$zͳM̍q9=0?(rz4qmkB.n哣3n<}:'5c*pejX̖H ɸ2`](42)Z|1~>U'r?54cNWi?.3R$^Z0&o-{U=۶'n;g=*VmkoC*]vw&@ҴknmC2d1V18VOkzHVzu~hf$+s3zkKKW(5_6eƝ2s3+ƢR1md+ÍsG'>5R4&^Rmdb@*sZRۜ""MuVV^k%_qPmӨ#Ǿ_^sV#)TD 7v7ɹ#+r㎘?mHCύ\ԕZ {9o0(O8cN>י4Sӏ'2~qZFLVG6P{J7M(nSF&lrO* dڍc 9wkS|#Y#*4ŚFq?QOASjKXɾkV6)Q6,6ҿ/˴;VJM)"\?f| *[ igӖTT.DbF۵pGS[B4Kaok![R9FFS}sQYV1̧ZXwn3\ Inwuo攣yoӹomuu1+I0n㿵mOgS rVө%ܾl^c9>J'8;ÝIBf $a}XM&"tjZZIe&|f#Nݫ"I&Ɛ K?Qpf!d$.֒էb֩GKZEcVHoq8^O NVӭ;tl[\;fl4xl|2}~ü\TsrҤt6[ ߴm2˜oBJը֝U-]ʃn1Vc*N>ͥ6[$j F8#z T4 ZWz},W]\4r1i_A)N{Y^GbF'Nٸ Kyʍ=s+J46K|]6tu} Iѡd`} チ81rU-Qӳ_/TjIU۷>,koeWf2K$hଞ_ϴCw˒ ǥLLZ+Mm{Uldˮ_NmmkޅgU+/Nq^>aNRծ_CةXK؋>Xlcf,. 61$+ҩ릧6IFQ}>k{o0!J)= {ZN<^NIG}t/C;UTuuf?(\q9ߵyxە0T\}lJҧLkIH~Ƨ+4[hvN\u08NT잫\M,B{'~pIqtW{|A J)^g?XªzD3o1|c\ ӿn9TmhTo.D-f7V|_̓c] U((,JQ]yžf~aA F;.~Rjrz-b w81xME:u.cjE7wUIAy|~*K3,DeO^oU3C*Ơȫ'̽p ?.jy)JS*~j pdf;pzt(Z;>TӪ@dDQ*ǻ,͎~8bNPwz|uolecc|LWFT:iIhF۫xi7gӦ9z[=[:!ʹtR^hes"[nZEp2zr1LaUa*jӱ4A-c,k;r:S>.gT!R1jVTx26}ҩR5ko~S2UiZK[o_1(nV-1X)U+k8nUZy{dVPMx8S ͽ:uQŨ}a.Z= ĪIN0N?i)G~xt vz Ϛ#ީOO$kJ Uy#xϿ^p?ZġDMO ̹oηWVp~ܿ.1ӧ^*h慜.Td]> t1_$ Yr\Mjr)E[5<4heA#95F^͹[ԚqAdY2Uyi=ҫԩS|ש~J?P~"nZ=׳uC"36oz]?v:+Q峛Ь]I#Px>ZCtX5֠cHF`9JN3~TT3я5JKWId,1!OSx[JiS众12TƔ{eFg.m3,H5gݻ08=JڝTkWsRVK rL"ĬW,lc;j:?#w]OR{˚օJ3F%$V)GUW1#{gު9I:k&ޝJ+̟#JIq۵trGE}#JSZ oeY1 a򮄡]=ɔ+F.å̮ Xv/ zgzm;5ϱ^+nEJk %_7BI6܂y8Ta\'?,SnQJnоn(\JZF3Lgz7 +/˙r}Fp-;noR>z!֩qs4s n za@=xVyy\Np&C"lWG]D3[k~cI8S7%Ss؆EƲ1 YE۲n쪬 t<3]M14UVqdWizڍENiGS$ks>oY\,dF3ވXZԦEVkY;/JRu~kXuRw} YX0e+g<:zwO튝XvWђK~sֳr1Ru*Z/~rBnW8s[*n}*6P-F@ffsӜLQSީ0R۩v2dq7N{W=WdO,g?{fXY+@v+JGqԦԢŘui úČx QZGNv{nYQR>g躗lc,L啘++̭Jks%і-Y5JXEztqTIz1,`{֝?wLjrSOBk]j 6)8-JTjO޾Ƶbe\:?Ƽq#/R"Cwlnrjc,5XsZ'ܹeh*,3{SI%Mxͼ~lsZ2 +ECk_.0TW%t^JغΏmJ1oBWȱI'O=h)!Q' +3O t9B:kJT 5ܞdEU}9YǕ2+ѽ5ȝ Ebɿi|F>s?_jTe{Npɴzߩ$Do˞RQU'hmБ4 w,}wI!zgUZ\r<2P%?1ڝNX"NG}MŶߴ Y8ROO¯OsmG%IV'O2o73dRXqdo}b"#_:]M,:ef_aPho1>ԩJɘz~endVƓnSnr{ˑI-uFKe2i6y9rTԶhڲJkOȵec-l:1JUQ*1.-݊-Y%Qz>9EWJuDrèYG$Ѫd̀O83^2/,_Aݷ[r89ǥD^KR?[u!$vcdݷz($aX8o+]hnRQ۷ -hܤ3}猷-98$[kDt?QNIsrҥO}dd G%dJwey0={+/>Ƴ?u~ey oEVa@{WdcVyqce-17$x[${ cql,ld UY$eX+ V*r]E-Ml$DKc$.l+:ҍ:[o<ckU$̱v~QϷ[4N҅3刽OEw,{tUce8CEj#Y}ufL.VeXcpqҰ=OC<E8a5ǓEUN-yFЖߑ= "[+]g1ߧl q\z۹U$ЕT4!1k;gOOܺrߞ:ۡ$PhpUqǯ+9JZEG5v[G'B2"m3ڲԍ}^qlY+Z'͐On+TKޛVE΃dUQ@ >Q^ Y:;eWzmݴ᱊TԵ4\R)B(\2x(e9YoUc=k]5Zq+NyraW~_^{5֫6Ga퓒{SjL1trwsjsENN}qW^H~t3lP$U#9# *q,uJlrnBF3ۊDbʢz~h 5#`N=8_ٵՆy$+$;a%M;rִʞ^cZ5{2-ominȎ*n3@ȩ*IϙF?6M;v :Iݛ{0ӧuF.)7q/!Vk YXf1WW+ J`DU_kt@8ؚJ2+#7>^3ozy#U%fj`T"m2+-; :dw&.dORj%kddgw3^?OǵtJI^~&M'߹g?ԦcRImohX40qOZYF|Ϧ9%$kacH+T 9Eugm8aqe}?]3啬Ԕ$UV |`Sl4FI6{z͸^Jmڱ%*N*U;l*"9-|֚5`}<朢kC>ju^Raė[T 7_OUi4nxIGK^Y=ۘ#oNN~3ZJ1N,j?VVXr =Og̚*{5ɳg c9,Hb8ʜv aZʠKR8|mF`L(<U{ҋk֌˪$Wt1@~ ӵ=(ь#ԑ!Y'Hn[Qx=ֲoiʪ_ [J%6{~4hC,.21) X]1#zRs$J!`cu x H yZ3J/j{?X+~6$R)XժrHsrh4z/,=I]IZ&lօ;oBtVÌקAR,~iZK{lCm34r(UU9X۫V*{:>ujB@ O2?JpR6UtbZZ.2Ï6hv]E:-;Zҭ.X;a'%apd2zNJe]d TyJ,x*ҍ+4:=W{7"1Lj9~5_sisO WS>ʪѶvny<9c'9gnD>MۛnsqZTm~DhTVۉs%:HjH@#=zO7Jn-4Ƽ3AΌׅLc9ȮIFz/ܥpvf-iisGކX$g.)(=d:rTbw|]2+K]:p Re%˽ږ-wL…L3\Be=>Qw[-]qNJ2Q$\#VX+dq1\UrF1%QU6 dzܪВ}&ئ߼!s֪b(ؒwY(߾v|3odܑJ\Hx?>҅-^j46dYĊ1k&4mI\Ϙn3L{QV(ǟ_d_rIf?J:Ʈ夕Awvnя,_o=GL{K/`kŪ.s8s莈5 \F?h2҂|S*HY*ٛ=Z%+4lJҫFTslszD}5mIm\ ^?LP9]tԞ`O!zvG^.08XƸ $5tA$p1 # s\hךD~Taā$R-pEe^8SѐMۯ]wN9u>[EJ2W{iY$cGy'ow1SwשFD4Qƥo1KgߕsTȏ/6!_$ބV̵AZ>{&)L'<<ϥa*S9F[|!0O1\#mgR/6) -wJr=a>^{^/-܋||3sƦ>oR([}ԁ^.0q܉SWg`[ g?7 ߍs*~I1Oث0s\#9=b>TEh8uUH-Enk#}o!Z)eIorƔH(TI=4n HPHS`[ֶ{ SRIn}$uO0iK,}p? bȊqBNhJ]ڤܪd* mI*w,RllU3'?¶OTIomYj0[|GH.wd?ؘ=G4F4̙XxThO؎V\:֊<0wʩ7e8xEJ퓇ܴ!A>ׅ\M÷nj_dt.hX+(4q]Xm`3䍧kouK]M=GExYUȍ08jlcӒoWYJvoU灌S1揼a7{Dh2܀N2[ZM*.yZhuS+trb9K;88JP<Еn!ڑqOn:F[0m_,# yJRlMm훊imMvNeFE`ԕ{rԖ%ӳq_fWp?ts;γ北ކ?-u'2Tb̩{8o] 8Z.Uy,Ԯө&+Uk!|tJJ\yeN?#&iwH j\dǒI[Dh.*7H. +JV%=AOAS*|B*Rw֥k *d3+`:fSHD֤Pp[e~kcֹQ#p ƏEcފ>kXjrPkqxa|ic3}xǧJǛ;'cj4i¥o]HdK$we1CxJW~G* Sc +yB6e1 Pp3Ү4o#^|)olQOe$JΡߝ%q˖R:*{HS6Dw\HvJ"dz׽mMm¥JbDD¶6* H? :Lp׿!WNyitFiP:pSᵼf|.>V޵cNJ4b=.Ѳ=ytTeuS*oO V$WKu>9ɮQt}5Яu+xZX!P2ۉ$\cs]c3HR֗߿/8Iߓ:>^1q]#C7xjrބU<9I?{v:?LSMIҍ5On2{HAztϽuӧzUvpi+\*-0,:זnȲw|r%G\FQ)F;oUrFjN1:> E24ۿmHJUy^_**lqw#NGE:,ͽǠ<ߒ|S E:~2JPXhbU`Ҝ}<#gIpZR̚k_1"ƤϜ<`ڈSVZiŧԬUEcRUJ$d2hލ9֦bھ5LXF:Pjȝ{$Gs+F0 +FI:OMh/Gr)fUϧ^ryki)BRWwp%FSb?tzqz/'msTF>;ć1o$w``{gS)nm弖onV3,k }p ;c8}j㹧kwu9%o = ˙{e*i6y6)ۗzcT3&皲 T،k3OWܾ\=WON2^=>>>jQNVX[U >0Zxc1`ƒٖq7fhS +ǂۙq i {`cMJ>w< c@ʙLo~ [^ʟ7}eȅ컐;CpMKT)r{j\mt̅UdĠ6r zV3/_3ir]J{C$xi$l͖fiSQJ]~V1Es;_r# 3H첀2H};֔{E)Z2е$,>TdUC*Iy=28+W j+]Ve8zݎ=yɡtu_pFI,}3u J-}59f^#V\O*q'T|suM37}~F64s68㽼8 fdsFϨ>cr䋷i/SGh-MeZ9RRU:Es3A%ƭQn1srqfc9N&0p3Gt|_*dL9CzӜ%Ys[4#xn|xa=qֲ^QͱS:h4`E< ;CnpG8ʣIy^Ϛ{kyoYd==OaڰU9 .UiԖԊ5g t1V2WRk8TQYqyp>TBG$q멩RyTNzt˸[-C]x ;V|ѕO}JڞXd)y\bwngBטԈ,)_Ӯx犉Tf2ƤQ-o-R78'@+i4%:|l$iu>=Xʢ e|ͥ.Uǒm +ddハƹk{z:u8RٯlmRDڰT9S{}ZZ0w RoYxu*#)bgۨ6-3nn&@#>W%IsϚE:V_ 61Uʈ2?7;21׽EJi˚rکz-qZ+9{(I|@Ҥem&꩜(v9qimř@?5۶3֧,?T)I)y,Ʃ5ܻ%q+뻜!+Ymk~*#hK2<6*ɟ@2@>-0ӌzv-.6BPrtn09\4Ԟ Yek9v}lŦFn\}j9GT2NSwbKhtd]5.-Vn_Us5E[w:Ӫv}w)=،JV=XZ[qwvx]n^Y:+j.Gl-$%sQ Ճq.^-l > {{1q^.VWiFSOQamV5<`zwpV՝PY-MV(nŤ#y^K"N%'ozW}n54;(’r,ZKaf3goqqjcӱaJ$އ8ꦥ~ښЎkdge+39=p=:1-i,C!FYmI?Zq.jL/Vh>o]ݼz1(1执u3+׶kHJS^l+vx.hd &˅.*ڜt6W+תo^2a*Uav?5ש7H&3LW%1K[%ѳ;%dfr[ן²RXVlͅ2vIzy$8ۗ] @ 1Q8Nȯ;߹ʐV2ͪ:3y Sna?{}~(C?'l20nlz+mqT匵{6(7UǘۻvXKItѕ9<Ev1Z[{8S01ß^}H{NY̾X@ 7*wv\}?wc+m'*]FA*; }kѭJmoyGդERv6s WJ5UEmu h?36搼͸|giŧB*EUi+sZDae{/pI=VxiZoN3Sww%JtYO7|ӮyV\+1[|rQ^F*ybAǯR+J}ꯈpQG}JCqsgR!b`*W|ݣ h˚WZRоhgqʈ So'ǥtӏ5;ʎ"evoQ!i se~TND˖4U$kuyp TuJp&RN˛=N57m2qAmF1ws01X |t쟝8ͥq$$N;VSMn]NƏ-%Rͤ2,@p3}5vrbz^-IzmMfU5=  c0#f1$W%j՗2}_551RIF-kwM-Q6F}s[URJ*48Z.lEߘ-[4o218遒q>Pw$Ҥ%V)w-Đ"`h[\qZiR2ߩM/ED *_ăG<+{<{co4*wj?08qֵeYzt۶Տ{%qhPQBTO;>Og|יUZ57I [wHce`22=iWCIsTM"o]' xV֨_Ϛn~J5y$8X,/\9DZpnU[+47i;3n,?v6GokWz5}R8={&k"iP19>ʾSj;.FSn :*|ŕo]{Z1zЌu6q6]ʹvfzN?g~KП)UT5ʱ%VS#v?yF3t9ǯj,snѷC+W~D$3T;~_y -@TFoVRrM5%^#6/)dXUؤ4IS'HX׷O֧5N>MnpBoEǗv d3?Z%q˟V 活ś1]ЎmQ6ѶЋz~<f){*Q5Օg5y|liv)s_4R/ؿ=戨)vu*JܞHviX7}s% 1M'P$SFvJ2_du,: s8>QU_O#Nr3f9{bf[rFGPG>_чno"ȳȡCrsE>GN2RkVu-ܜI֔u1u%%O"de=mK. 9a)9N7yEf J+^{747 ",0P=YMu.ُs厯$EWtӰC>zJ3muTjS鿨؆w72ʣx㏧zʥ0AʊDv4E= NrQ(nd7Sjoe)>8ӽe)r7 NOMXchC]n;Bf+iTJEaƧקՄSQna .vhqR<׍YUSV *c'ֱm2J6E[۬t 3^]%aÒ*\$qmuN׉gXN4h֧{(/gi֋klësv>52qdяklm=˲mcvX|eR5-%a4*rU׭c\]·RSk~KkZbZ21sYJE>eF1kWfʢccc}MjuUۿ.ޗ?z*J[{.Eyqyj3:،kٴ!9SRmUM?ZOyw©~:}Omue9+-(pu.{zt%ktOZZ&rBw q8xG]QKIt><(է%'v+kef\7ʾSNd]z:B1VepYyGCY{I{DqJi%'Օ49DsdpNwm9"mE*vk$QƊ2y3ˑnsƜ5jM=KƟ73s輺".#[1 c_;9H\.Y]naՔ'*/Y=V)KI2GUNI:9FNR֣% I5ܩy\J;u[bTG8ZShU#HTSK+;[& SSd8W l~\Y5R\iz2$LʼeW>[Q!˱ORfm[AQu*U-sDdWRRv:KF@p`WhԕNuΜZRP45VYmpj u.;^ޭKsG~s,ꙣS#ynn5xNATd{ai]_!CQ1!'ˌSךRv:ʤ۲;-bOm3Q픩I\RXzJe=kJUi;',Ò[^̐]|DݐNIߵ%%o!Qt9KF]NHFh3J*~#zk:(|w f6iԨN^ۛr "䬱20;:Ωkn?֣ϝ)v+i?+N?ǥ D*rZC?URoc+ w zT%ϬSrQ=;cd:T _WT~Lqf1A*FON,wQq|Yb6pzj*M:2U>%d/S܉sq#Fl|=0HЧOJ6z%I," 6H u+*TvmzK_Ccs0I`Ky|Řl3p{gM\%>oVd[^P&˞\&V˃A9b!y4ߛ3֭O&X٢t#ʜ7߄[Λqr"^0h"UNbq:s\U>e(h'9lgA$8grű@\i\TcW4v2aur^mN[^9/XαKc2 ۾3WRW);qUvYUNLƍk#6cDR$m"䃞Nd4RZb]Ydc>[1bw|lI ,B `0dB `ލ$eL6>\=붇,%S̒TKۥ2K&].y9'˶B-ӹj2c23 ~Y?$՛Q[1u}N'?FoUzrrs2}F)dRc`0tg8BoF8uXUi8fŸ^8".x줒zs_4f<<6CҌcoC/[i _J$!@uoP[R-[xbw.ܣ8߯Z:0<%:zm[jb#m7s܃cڢTgbF\RuM@DO~\\l5nh{b%JRKznGp񷙇\{gYԌ{'µ7ȹc6KhQHzc5Q%J{Ԃlۅd d*cMJ^xsyrySoBa2M(ڹGa\wksyiNn%bۂ }x10֟4W2H"1WqrƼDO}N,G5Kr-5R$ۣg d]:zw9"[Uun O>{WZSvӹ ߚ흑WnUu ^=iԥt<_UYِ#w6Y{gxjm؊#-!}e$2 s1ӿ^ūTkԪ5SKcلqr%Y| ϡ{~NJ5N2HK'_C]rX+>f)np¥_Z%i0d &[hN ?J7;]gEIFto<1+g[oQ0F?k7"~Ÿ=>m&W4 9sB^/JO^WӢd#R)E:tIlIFh{&Uc)g22VITOG;G# ֯ |ɸbdpqQRՕ1r':Qot =(˙_6InlZvQ+n;}ϥnh7UN~GkF|꺉֡܉5뢑=Ea]qӯsڳ)>uYQ三tTDiN1 'y 9VKk;H_>;g2X']rN+*QR+o;Xؕ|yqF,}rÚ:/1dPUHY$_VcO3ۧ8ʜSzt1]uoDF?!ە#KTXxE'vIm[{ Ė;߿Njvn,-#O6AUkiKLҗ,|J8%ugq!c uV1j9䮗oZ5v}XViU)dTrA3tMJQtu2"4u\u=ĻӪfxT䢛[vYy\͇Q[O3u*J6ӥ=j^Wz>s2,1ڣqǵsƤ)Iּeԏ|eV})u%tԧ)ǝek[Y$+r2OךT=[;y wS5n$䷆F;!,FA۞*Jr-{&;0N:nvIooc"*kGVT]^[a 4]!gevp1dƾbk^WM;援ʲV+">_=}??[m[;e+rr=1"jIFzmGWV]WyK_j-BVO%`_B O$ ʆ:+Ż||=ee+-3/Lƻ.Mw:v;7М|=Dq=c]wڥGxRڭzwm:?7]Ufy|fo;8 @<}OI+kԧE5%y?|7#NԖntvSe'{pq+-O}v=X?oկ4UOI=MFpv2aqݍG涗IצaO BҶ'h{ǀu;(f,fOάzw8N:ׇR>ӢGiG˿CԴ4o o[s 9⼜De|xNv&w9f9SܓkTg5:q+mS{vӭf}l+~ g|\o/c*Rj$^-徟R HHN:{x9z6w69Q'hs{Yլ~hٞH]~a؎zt3\eJ8}qC双mf1 j8>6WSQ.[f=eM6nceS~^}{hp>//ˤ,d-56@:8\*fIf8 &>׏.u O]N(NKUX\X̻w1yס澾$.C%K;-^ko?xhuzs8rWpry+aAOkß͡xFX*ٲ0;~lnR5cbbV~#huY]2]ǷWOs./QEu޽ziJ55,>yOn# m)JW՗N.1Zǁ2CykBxXԩ)YsZtW^]cy?w'5rgmj}?d*4ڸYhRu=ub-&UҴω9^AJ5;X##V}?\+ uT?Z?hmt+ ⷗@Y8DZe)ԩ'?S50zߥgeI ;qQs=6%J[ie;cw.)|ʝ֞l¦q v$j1*95c:j+:,h@>PNzt%y[K[η%kӔ̻h0+D *<d 4Y%%eVʍ]>W+q5wI+#P#'Ȯv0n~ e*SiiBͼ3$ $m7MFDQm8?kI^M~q+ܬB?Oӿ8T:t73LR*:6O~nۡYei6VNX`^[V&qq;K4kX&95itܪq͵ѽU̖wyH9ʳybMv|geY$L*fJɵuqT{*vm~\_=?taJna+te[ J3*Pae񞟐s(3IsCpn<ۗ dF-#^)Ζ-'FvKzNqYFJ[nVp*ǿi9(r,-YBSrJ%v6a1ݗFR&4 d*d,ṃNaҕwIlF ̨¥q\c9ڪ7 Sfi&o*y&i+Dt3c<~8TNٙƏ2M,۶+jDlNZe|JNU(9}As\N2HܨEe!76KwKGm }9y؎8]ey"!eF{rFWs*[]"҂ i2y9rIk߂i>^ZβG&m9q_m- JTiri \F aOQFMh.xZ-;EO1ӯiTu+sl&k6E-9SJΌTW2NQ~j6ǻqB9 eOeJԷek'wnGνis^,FR,CŖmY*FU[aG*i^B[ CQFNWTv]- mʹn*後 kO` Cێ1V5#ي^Q{ohfсWA?ZRҺjJ2{,4DN.Ր ?=%V] 9P]BTxNhO֥u-!7lR` v*a'lTi6QO;0yvf%Yd5N&UhGW[XaX>sn0<1,T\Tq榹b' [m(Tm+ovVqf.jAHFz: qcuyК;mزǰHpFO\c8MJM>SB;&Ogm@:~tԩNW(ƴ$k$+ <ӧZR2vz7w> mҫGBol6ɔ Gy= T-J*{oz7D.-Amtq_a=TQrYYjzlPٱXRgFbWߎsӎƴݝSKT_2[}>ZykpÞ=sKGFZۡz?555ڣw52a{=LV7N hp*j5vJbͰbS$mF™u!jJ*ti$e(ʊW7=jGݺ-J>ե`p[Fcr M ۾@ *TיsUir5܎gnO`~S=r?m/rgRJj4A5*$VڪWnN;򪌧M 8ʤo(Mm]3:YJozM=6F,lFs)x9v Jm|U:*)'tzI"yV5Bʶjr^yK2[1@GJiw Ӌt}nFFQw9Q)kМc֨nEuT #7O\~;E#j3N[3o)Uc~Zi*1VQjX,q$@lұE ZRk"RMe %KԌd5g)*%'mn!̊7 w'w8rj<;D$*!;Eff&8ըڒMt!0Emrr:V<ҔASKo}} 4kxZ6OqD #8T5#-_CQKTi9c Jr9Si; ujTJtֶQ-\ްxTl|֑QۯSJn53l;nm"w8>Z)JRJLЂ*TR[j]XS)P}mY,ǨvZ)%g+TR>s@*/q?TYFSQnW-yYX8ýmmnƝl$%SHvm 7Dl3IⷌJ?*FVu m $g^)ԔSRF%I)& p$U>S: {Q3t.[NI11gl۟h!ˡ*sM14WzMZ$2qzufIpU.#izQ^μ)B6O `gIX62yVە=l֜eЉR '·X[w}*~sFZ8*\`0ّXF9c$[ByyjG,_%qN#G=+]cYF31[k۫Dar꾠w9I[v?q1$ _p:V>Ν7FW4o.t~έQuAZKo r 3g֢U*s[KqV .7,~cF!n;ߑ]ZO[/K7k7$~б*|el~8յj)OafBO]6j:#KX+\@U~UaDo}Oy_RkC*Y #?zƤW5ПjR{2+U8)NT#7(yIp_qU-ѥJ\d/64+kUMntx(@ O}z.*x4_uܽGt;bUS 891^9IKw#*ӔemNyhK9mD|}O޴mcmV!/ lydӃ18ΒUdX;F:u[̡ El]T,H ǁJތy9.YS˽YpIYY")WE['ɑws7IZ9iڴa)-= 0Z0}lg_󊯉Y9lo:泎֤ټDYBۛFvlGe=z 5<0I ",T<7aֳz=Z;!my~&tK֤Do;GUUU?qSa*Q ,($s:~a=15QJZNq^a{Y$d'f9cEsѧOYYVb]P=?֪4gSdZKc0\dcFvΘǖj̾fz=N8%_MN~ibOЖɮ%O!Fo/@'oʴ8oNO=Ojǖ_[$k4L'}-JJRІsna#6\suN6s:qNAđmW;W vKXӖ1ds<{ʹcN\bi9+pnY!ZݼFy'ȟS֤єTkB;IT9㞟ZQܚw_&#;.*~ 'JiJAGߎoSimc^!Yb9)ǣ1QI<26ޘ2;^FQGp}v W1l6{~&M=S=R]yK۷u61A䑭Y.duO0{g$R&PNIF&IIZ5VV^Y;h3rtB5T hUV0>遌z VrOpQy;>4RG/ePA+~k{9^+C:,4}bXgj1],^2("(٢f]&A`@# u\ҧk)r&렳im~YGys:4 NNEm"T V݊^{3(ꗩ5%N7QW 3Z 6#",gŅ^mvmsclKnW#mWj1-ʍ?eMI^H9x ʮFC3ӓ֔[7 .wpIlgsv{dh'RˡQtգ&fU@\1)GWIyCo$h4PL1#92:yl9y¦bҊͰ%M8BeT[-+I! Õ:2}Q;8'֝:+QdIo'-;C%8Q3;5ƾ1KGA1'V'xn1,:*S#-^#"{.߻oo5*јSׯfxK"#o̘$}7~Y}^5;{9m]7n,͜~}IJxzTBbAYC++w89Ս9};Ȏkcv^Vު)p=Vѝt.iהy<پ0hG\$ەhܯ?mcƍ#ov۔P>wϚN)>U4An4U)Hn9=L?hߚ*we6MB8nݛk8ު=k4(TS?{V]nW _\]995NҦcy4֞tΖs,l@>S-'i)FJVWzq4[Vvzֆѧ=t_!= v.WpM>O~>Q%QӋE84剓6#O[OĚ~˭hw?{<9T3JҊON=H>ֱK"C7,HppG~sFԿy3j=BE;0{1q:~əh/]+ˋ)80l붢lŒԢ-lɖ`hEe,9kgu{\%n.PHH8V·nڝ_6o.Ybg䓽xU/rI1S)57 e'o?Ϸ8+*NBc $~J+>oש(FQ]zE=}<QE&H@}O\tí\cιS4֞z6r#fLm2mA;S2v9Nn0IiaXٚUcnf'zVR-F\ŁSBJWol~5*2Ƶ:Ri^ ; Fzd};4PeA'u;MMͷjIs랤c*|"1N krBݷ3$d,kSLK.L-`TdU˻H=+Ue)>EnR XmT?zx5 ܋gDYWn Y2NLEh*)er xdi](:畟BԅQނ,Hƍolu:Ⱌi-YJܸu_Ј^B,bN\ׁsרFU'Car4Т2, zҼӌUձʧ54Q!I3_^ӛA{Ogvv,|A+M1pyOQUkCL;kOVc~а%,Bǃ&ܜNp{SIXGo]dc1$|HWLyM/NRo~e]w >lc9)ƼU7(V'o-&s|t>}ύZ*slhS`;C;[JRU78)qI={},&i6>ڱH ~5:mm3«QJ.bcXyFi@dgZu*T5TZ9mK>팻g(PB|i)jvw}KtG$[& = nuA`el$?%R1m^s䈵*Hi$䏻FCv*֥jJLJ,=ݧ^Q Ar9}j]y?#MQc I#mڮ py5kFj*oZ[64Ya .!i:+.pW9wSo&NQniGAiIe(fW3OtƥGm<J0uk: F( fI÷s_EN>e$vӧWJroFTZh=bB7Y%ђDgڼm#j+ѣɶtrVKR\)#Rb;Gz4ԾBNQqYYnңB9Ӝ.؞Dpj+/OC2i$.F|" ˸RyVGBeSkva]<]4ͣݼ$u ~uqCC[f2 uVv\zwcmޥF]G"#jwr[Qq#Bfgܡ9l;t?>ORBBwJ<烜¦2c^ZW^X+naT0*|ҎSbFHAb(9׹~)ݎI]nMmwf|ݽzQ)NDʤQ",I~okaO֔#Zj#hVYg]>fAY֒Z*z]h;V@/W\ZG:8F&Oz哗-IٵfGr$wy)sTEb#y4F۠g(h(<+2L*uW&ܥ˯CJ73o8a~SsTQwhͺӑyh~b>a\v17/rVg)TXYN:f|tpVwqIzm+l4Qčc~ՄNz0o-b"bRFǛ(FNN_[/ݪFL/<"_28Ӵog[ ,EG^ZiLIdRy緱RN*hFew xb2/.I\{W\eћSPwJtM'LxQ6ǽ9PJ8jRQZO>]G,2`'pI}x{8Ťwѧ*ޞ3$uyۗjN9,B*%ֶa+)sAw hd޻hǻvsYԍJic*h ̲n,[t؞k .XW&4* V0p'ʢ|ӳ\tvhc{o5aR۶kHxc嶗 urX0v!N~Q?}KmμMJq(% ]vU'`jT%~?y'ʰXVmy:5&QV{p+) ɸːf>cҶt}];UԥNQM?-t8ui&ޑg޹bs3ӎN0'Bti{ugG[\Ap|BUa'a_AuqՅR9FZE| 3Ԝ~k(aݹV,w6 ؾd++4\i9^24Rټ7ykkur:s^1gMkrFHIhˏzx+Уhzy1vZuYmIzt)LiQ曲_"mwh=z|4 ,E>wRGt}[y a߂O?ntQ]hTyk>*B~Qkxju5y^t' Ur:}F*%eZ2,m.mLsҲ(LpAo3>Y6Ƈf+ӝ>i;:121qz~3\xw1N2dfJ2[,eAOlqs9_Hcg)I+?+*7o;t>Ir*Ze 5r6, {y9^_Vm ۹Nh3$O+Qqrٕn@)&Vc)gRnQVi4C$F`2>IOs2j[cVRG:,L7)e.8cM[$$ɜ7 f\#|t^>D$1O0J۳RXEoq?ښܪ`^]%17A~9 9-}2q=}S*ji{t3yf>=5f|4gNRM޷ڲd0b̭q9g֔)tWԉdfbٕcj\"ݎcZP"&C>v?皚=~G;-X1IrKrDLs\6f>t[ te5YccYJ7HѧC E'p/k2/Ec_ZGc?oRKe~ YV#lq0Hŋ6~bI?Vq%RRo-#|V@wl;zW,캓ZIIsA&kn cR>ҕyQͣ|eGa/&&^Fؤ\g#{HNSK7$+[׭^ii6NGS91hԩ箶B}hfx,ѕFxr1#VSv;%j?eƕ -±o3Xu9GOe%x| }p]빵-ĶǛGudqu 兝Pc~<*s4Jӥϗݦ|*q2`wc Gle>UM>Ь]HY%[C,nU G@zgp3.z#dN ccJVr ̏8۹y؟+n^VЎ]>^9asGcl9sT~*)>_2F/*ڽ ҇BWbV-6fj61 FA>i SӜڸFU#u*2O]~[Քԩi}c9@l|GiN2DӗM4u #2 ,suT!R2rJ4SXշ8cww a5Rrori^ j!6ƭGqfOO̾gRZo,-M1u#ϥm8W1[]Gg6YSjT[ONQ6ʥIrnCci%c"F=V̓Nb^Qi뷡 Yo$H^CTiBISr;K[L,Ud:Fg i~΢S4U77dqœ{zqVTK+JK^ޝOƌYJ+Ǧ>cNrVҚl4hyuB#މJ2'۩mgEis\"Y7HP$Raw1'7ⷳ_ rzWU%i3~fdvQCHFQxr(s7GTǕ'e&1_{s>wIB+Ev̪T)rrS]4i"I$l̸-'(Ӓ} !*.h/tQS(kZ~fqOK= yTmc0cFlSߩJ$?Vnͼ^17 6#sºiԔj.X._C5%ak$| 8~(^Eܔc Eȓ6^OlWU)C>"Xz;nXy?̻5E6q?SJ<|tkT#jG}8.Um&hݙLK.Xn`~SiSbQz5FQMW3%fxX@A>,3߿SZq7*vo <Ӏd'#ְT2eVNTh!%ӏjʤ=5GZ6Zv~S7@sOlrF>z=J|ksGZC7lqcf˜:?q\*g0-56ۥ2q~f-dcFҼmM8&d:]`ԧVМ}JEI -s_SZrZʜyҴ XTs&s;TѲGdZ‘U>Xe'{mF{]J#TVqv ?v^=h=NZj$!axo-ۤox׋j+SMy$VFU V8sǥxI|RݭЎT{J͹FU#fESrv! 6닆sr}njJ_({9G"+UuI 1e^6W vU:e.[ZV'YL˅mpɥQByy[vZѓ PYː+np8ZJ[q +_"[t[DSrUx*qʞG#YƤSgorG8|*JGi:r/}Sb۳l#Xen0x;#Q jKvYUasZTN+'' o cH1d㏼x׏CX7ʟ|эU ]ԙ*Fƚ~V;jVxIJ7]ȇsfi#YYu #<ҷe Rle˺&eY-fnc*=CIJQ|_vQ6TE`ltFk1nrc(8GHdjIA4j]ːn?2Fx9jIT[U+9ZF:Tt]6h`,D~f;w/?U9A?Rj ˷pim١Y(>?^Քiʤ3Etl)Ef16}@c :喖NrPEy;^7(M"+$d0 xzNg7EhQЖܠc`U/*S[UVhaXYhِ3F70fϷZThƍ[n]J?XrwZ|؊H/?]7_TNSjtZi=>D0n8iGHr}'qS2eM$zYqo*.c=8SJaFj~Np5,sYc 䏗 \fپeO[Z]Xe9Y˚vS>j-'ꞿwb`!FFO@=:Z۹UK ݖxӧqOQ.XDӧh;u5ˈw;={VJϭN "f7 cA'#$3YӔb7^U1]-!8CeNq=zJʚ.ޤ k#j_\涩R'̵f5R(IUW;.a܄_^:AU'(PJ$I#c^mcZҍ߯bKJsȸi$eAYFR+$6ik{שrv,7L'ןl֒exN\Ҷ%Ehm?:ݴ㠩u9uS5br0=q냊ҏ+|x_zf}t/g4>C0Yoi#Ըo0r ?y^˦ѽU\rIyG׷dV&uѫ͉|Mn5YL|W~\Dt<>~T}{1u&mQL |ɛwnpݻ/nӔj4㥾z}V;.QGpo%<Å;vn=~{{0.K|osR[K>[y h$u3t$0#aNqwW_R!N#baq|׿]_a᎟Rkk(L&߳~NG-t q GO裚OBu%}>=-Mx͆w9/C+X r#i3*XẸ7yG`yh-yK-_}+F]/Zgc/̪.جԕj0,<\SI|P3I8aGWskOTU\.q]0lD{Ei%Xb=nk̈́rY%S_e%qhbG Ze݀縬Vp~Z(j{6M֓O )4ѫ\0%py ֕Nk.EZKv'a-t;L,q2|qs^~"4Mʥrч<4oS(ko^ۖ8a 7;(RH+rpUb:]v]Zq9UI{zf{>&_xŬ>*[>2v;F+#iT}̷,Jiɵ6xJj[_,Lq3㜁lnۧC>WF8x5徫g;umo^.34j1ݰ ;-2͘Vp򶇩IOZ kqj;9c^\g#TM;yu8qZ|MЮ0"]Z\3G1\ >a`#2<-eR1GELtkai}itKZ*|<1׻RyK_ѭN+٬>1+YVTROv'ʹ0| СEX慛m}3ھ1;YGUiF/7S͒mZi-M[4rSׁ_RiSTOxqQmZV/]Mۍb3Hl(u^0ORy#_g(ݽ n*nc R:{dtzkG2N}'ۨ Z1̅qp85IrǚޯNmPZ-탠-"QSKyZ>jJNqs΋( O Gzf?Eb[oQs.dl`qt>(b+Ju$-PLvaϖ gUFeM[VJJȒ[EmyvWUN*eRms<^'~7 r]V9779aߏ.Zws%6vB9 QLܪ2xej)%66H-=_~ e+5:hwn䖑 -V`C]JH̩GJR4p.L[0[Zԩa9|#ۊ u9\֣))i_iDPI%?gQsʉGQNޝ''X bvndpF9⦄tW2)i*S4q%¯ AS[9?o%fB22e̪SoJ4۲;a{N>>Zo#l\c=jg/uĴPEWs0zqUF46}ث?FF32p}==+2mf\Koʛ[9Nz/AԩסU29WT7(0j=/}]\UGfnc~9+UHNT#DMYBNuRѾkYv̧=(8RvOdS>#_3h7Vc*)f5Cpo&%*2Ѯ ӝWzoR8h\*>*j]抳ԣRXijI2/pwpGG_58IˡJ4ޅFfN0>\ѽ9ZZ$VGt̬};<%RyTnE坺(Z)_2Qʟ1JUC*&\vyFQ)FX3$$vۗv[ۏ>hVShWE8:Iqt#۸٠gi_ѲA=뢜c&eRJ.V~9+USut㭈TcBഌ.+8JkU-Ha@p?v#55v:xz]AO,sܹ*UJ.)ݓF>khʝ+Ov"Tɜ㿧9KnR콧Fdo)1e"a<56/ڣ1IYr*緧\Is OKO>W5EQ࿮#I"T1Ǹ0Oz5!jҵ:Z.,@)réVu+)ۯ=, b]ͺ(P;Tsa֕Z֚im|e(׸X#"Eιl=AN2V7ZN?1-;rqŻ{.~iܚ;'us>6s߾j&iJ_NlyaW+`5/=̮'"E$FZS:2ʙ9cKMb_;?ݳ4*twх)F^i9y3)&R0a"G/,yp\2*S%Reo7(zJ)FIe{TM-ˍ 3.8=WG}z.*˥^eu·{ 81=SE7L<\}ݺF|B<}~.[M/#\:Ȉ5!mٱԐ*:i/]:z?|,ןoֺ)<7mܭ%R޼6Ycln?k4M{"iWIE4lginD}К,e]R5-/uJu=/mI-ʰmQ9J4Xʥ]_qclJdf`%zX姳*iS4̵" $dDK'1^^'`Wq]VolO1jȪbp;+zR7˫ff[u5KbQǿzqZ*qox--{\HVHتr0ytiNo8i\(dAmS;AVMwMngbqVRrGe8eU>_k}6mf*pNGsڳ/}YN֖ff)ڧ#suYEX>8S+%oAя4䬺2"4F~0Zgt'Vu,d*vur}nyp̬@[T%g.E^"RM$$e\ɽFO'#>kӼmJ:Vvr;YbЦ01ܞ9gnds:jwrH~"nM~ҶbI&bMM. 60;5jFmTJ4RkNnNu9!nV&FIRpA98rz}-+dm#Ψ#QWJ}$_Te)]Kv=y2N븩ܐ V4ndZIBX[\$j7s]TF24x],i jF>ߺL|?BX&bTV}3]x$9O[{mzhOl"IO0T0ϿbFtc-ub&yr .Lr;JScТKY4R3)m hn\n7۷xܡf>ZI={/Ԭ,>[ۅ=ZQe]P+IiVaOgE{\JlG'5|bhN4=tk)F1=tJvBH[8]9S{'+go"-!\*tir!Ou"C,"sp6e_|p2zG,&aSj<ɫ6Qck8h[XzG<ⷓgdEգM)/zN-D}ɞ)UA8$u;ҰJSCO(k )1XVVc{Q㬾FjMJ+Uj2H.DV[UQ)n 'ׅ)cRz[;Y-*߹_ҕdgMiZ-ɨ_+)ڧʷ'}=W4i u'O۶$7i $?d+CoiZ:oZ7X<_:FGZsJPqrb{m73$VRѫ@ H̦?*Su~W%$[_ݒX_N+>Xw1۩^ ڭ9;ӌd斯HIIbv Qb$̭ch 'MÐYxG^;֑攮KqQ{-`y6j7#?Ñq֢RN1G W^AoL7яo[SgF?Z^cl~.g=a 1b ?ӌzV 2hXMEhŜR5Se-I6d0ϡQVIk-3ju!vDvd|挓==:޴fJ8zGQOvd;=q\#RWDʔ[{%!<~\Y~hlYӃi]`;5AH~bRVK5][w9!Hd?/5q;#)GjZkM%,k< hnG׎}yt.Hz=̒9x<]a=j1r%oO̪tס,ȟiaܑܪm~5q-Yl 2Cdn¦cZ/C2k^KV>S,09te4*qȶ~KL0n1cֶƒG+[׹I%]Iq g$ZSNi-Lja>Fr^N,"WG'Ϧ+ѣK[u9񌚎:.6!G3B#>]5=a(ڬZogt:\R$+*ޭ9#)S,4ickChyr&WGV䜠ѩd6K3$+Mǒ9_˵uS2JٯfMM* 49wey*vh,L&ݯtǷmN:҆Ёw&(U$h;8y\owY8֥ 0qޚM~(H:ur0qtTi3HZvN2nbQpp,[o1)^G\}1mRTOd 7|u>Ւ 0)]KxeUBޘ8ߓVlto_UZ=cfXT7~P9JJO-$Nf`s0MTcdt9TRB)^k09,pq![1N wCBy}awN*nO^NR'*J=I-*Nv}~N2 Wheio^ښs)~u+bfN#WSXTy+Y&b~qʩ5݃n'r;DЎZW_q:O#Wq:VgQ7Ƕ01ϽW s+]2T wH?ԟSX/J_2BA Ksd:皯B"* --V ʇ9<^ JQ(ȦBy*tg||眜V-b=۩gqap0?q]Y*wps#;UpF9ֳ8D\"gm˙'~c(tZtg?zQ#DRnFUz˓=y%'CJW{w[c+p1s 8ԦMz#$mmP??)G|؟gzlܼRKUgƔoN<DPbX7stqЏTRxw%dHLPETofyݩ~U?ё&ʶ,h1rCXыĊmchltA#UFօIK /w:v!v2߱JV:*I=^c졤®v׹kS4ǚJ%TxXB-sQn+~4-HTO۸铏tGCԿkh$3(ca:|ѽI[SJ@[$6^Î:(W ~eр|1e=_U(D [-!DN08Ec#%ERnEmQږZh; l_z6OC(-z* T${L!yn`iI$_޷̇!)[X#5iša<,FQg,=p+?F&{&&rsVQ(zǘ$Y0=N1O ԖF>W|G:=zVQhFJU 4^QNWNO&EiYr8k$Df8o26 7ïjrc;jͪDCao&jd0g#o{9*;vܑ#*ʹnby㞜Jom2Qm ˵sF3e&#hWq$YԜRmTi(]Tu<#?uYQTQ5%IM-GoƬSv>YKDOr YYDdr.9<߭m/0gQ;-uX(vc=ׯ5Qe9m.Tb9-E14$&2r O޵a V'aڦK~,{}*j1ԨǖHdΑtT`x;DJ7h72[z#֔e)jF ~b8nZG}۲3u?S/yhWv i$7I/38ZXR{ yO6I=+ZtR~lۅI7yw>й&Qt[~7`~Bz1|>]ъYX@wV]˜znʮ<̩Lz.jk ҫ&E\W)ŒbnLf㪟^O DҳO2'qӚQt29G_rX>m0c˜ⲕj6IFPI憻nfʬIV9<Ճ{?i2-L32zg=%z£F)E*|ɡ9~9W,q4o>wrmp#*W?*^sS*{={f1n3Gvɬ(TΤp[:HG:*/.;UVuS:jkЩqc[&V-;Le+1T.T% xo4<~5HF7"5mEqhhoq6kA pJGDucFishUn78sz@?Z攟5F(Բ+Nbd*GʡqUZ#vWJ>ai0bXd/9b9}ϥm*1i=% a.rTJRFUG g縮~ZqNeRK.5fmlX<7$g}q޹EҒhRƤo{{"Mm'dee^__j~8~Bm,LŘպ” )[kV,qao)kvk*ui+Z݇QCBF .GGSϑs\t]wB%7X󀫁Di=[9eRރ^0n67x秧4>W>/i[dsM4N0e]~?±s{ѩwUnPfqG#ҮS0 Q斄msl%fӌ!QК3a/ ^Ao`79L,goWdR̬q;VLBƒL;+Ir(U\[Kz"pm$eVEʫ8³'-:Zw o2 iYS!'L``RuN~L.{[]ŸZQ>KNZє>1j^玞դu}bַ؎YM쫸x?Z{W߸M!H۝t;DcEFN4Y;p|p\m 鎧ZfU(ʜ! ̷n%L謼g] >&y^|EWH,R9m)f1EuBQu6кգCȮ][Ͻmʡ.Ƅi-Az'?p9G9%4CRgh-G409խ'8Ǐ|vHlddsJ1(E7.m=Eor*jwpyqm-B@<OzQ4I;$6t ]=}.a/[R?̒4Pci$m6H=(\e(-쎚5iГ%]s~T{irlϞ厊~Β(4xcs94J>{1)պor TP4d)8N}맖?#Pތ$=m)MB[ۯRFzW4ilZc-]ջzq`-$/\r{rQVU8On5""-yNF1"Y*nͧ|8{l#-Π. Rzgӵ B4C4EJnm,+ޣcGx%3ұr^T(3E;Bdz'Aϰ2׹t#>ܥ+,g7(szdv\N5.~&?b^-XPJ,{tM%^Dam[q!98NӾE:j]7kw[%hT\66|LN4ݍZ7unr\"6Hݎ~JFyM*o ӰeY<'=zszrԔ-א[>;,2grcF:F[q;ϡ4nDy,*+p8Hϗ8DiJjT/IbiU%R!+p’TQڟߺyv:\Lw,ljUp3Y֗K|rU}ַߧG'2YaR˹@?iE&FRZxaPKe@F8x=pYHEZ|s%~h؟d=OhE-VQ٢L ۯml<Ў*R|ЪXuyojƤ*ҖorZi#(~W_ihrKYƵ&31+ěHT,y1X֒A΄Żc31Q"-'9e %,<.HՊĘڨdR2{QQ>gf֧cek^Cusm"G̋K[q5F֞fx?(nno&c,I #z~5ƥt49a򲷟!}QVxWYJyh[ r+iJicT-Gs:5Y[+~\϶ \FjbeO+K]꿦M^ v$r }H}1F"JMYZG-}_BlAi d,:@uߵLeNRZ|VQMBnݟ!ckӋ cJ< sV+S5]E9x7ӿ55*۷PJ{4hlSy>UO^ FMgjf14j ZDpi*u%ʶ3m6-!P2?\כ7vR:IW0|Io3Мty5-v91Ew`:JbN@u^25w<ꑩ̛ޯe)笒f1z_|Ve䤕ᓖ)=y} ]bkT#Pq؎x)Tq{}6rb1]>dMs_b g?6W,?cޮ;'VMzw$W@` ś=w|J>UqVQ{12+mUqҳ~әiF1'`XmL D8R.+ FZZEnbcnaGNaWΊi([$ہn#8gUߑ8GeKInXUHXur=ϘtV7~ʏ^,m?#I9&v}>HʤY$ +{p=(aWW\Ks8l3$S]4MÑ9lN%-(\E4l:c*jQN7Fi\БXȦFڻ[H+rsh̪jտ^RhC$|ozqko.Rx{%b\4DYc @ʰJp9LzKt{INMb]>8c2[g\xedkNtF5tn\>qך0xԗ+XԩJ74H6¬QoN}Gzu ryֶXw0'[=Z;(ti>6"XJ7霏{{EYS2LЂX&-6܀ s^9>k#OiZ51.vr[8#שNt:)Pq9V"+6R6z2Ȉ+f03sמ vJz03? E8]?ap$mPU޻9ʴ5sI؆XRʣv?)IwMmdmc&/ߓigh̿fϘsgڦ,տXEȡplhIƱ<ii7FSХp]YW,һhnq*|!Q6޵RQUZ7PM+F$q99޸8 cFU 43 f.@f,Ppo'~2 1N8\xFS*Ƥe㧔^e灑nOr=pUmHDWi B;vJhIk&P̘9ܟ\Oފߛ9U9qzm'tXG8ɧK>yT\RRK(4WݝZFQ۷MFS9f6w P|e8:V4eFZț΁Y'Ro3⶧'/w;ǖNʗK$eVluY]HH)zҰJkSEE9}-3m0~}j$r]E;6N$wC֦ާ5{,6~GY ݷvs\xF*Ol*epy^X>YGB^ T{+BUv{>1e{ZO2<|9L3G,]34R4L_OYNRij]*ѭO{rЭyefϭgR<5v4TiO--ə-#}yJU.ӡL;v#emŕ'"sAZG z5 FVY['(Ǖ%h-MNCG>+Ԧ9(z[~%V;܏o\<_zOݲwk8ѩQӳo}Z%+2(\pss:X$X2 H?9euo$\1B1w8۱%KKY[_F:Fر @h-_}~3^Kn[**,ñ#$Ni)9Ö+OCO\u 4/B8z攝9=lf#'YEYZOT@X)'I9q5RmmӃRգQnҭ˜p{tojqI~?ՎE>jV.iWH;6p9=9<*jFPmI&^Վ $izQtGUJc?%# ~EqԔ[jgVI%z>Jܬ(7maƎ|șsT&Ix78J29)O枥3H<Ef?%߱(at*>f=_2n /?(烎+͝JZ;U(7C6xe*GJiɷ-HѴM7[UT.08*^^T59-s5&2eZ?2b7 >ٶeH=9uUr$фFE'{Ηd>bc>sS^Tiʍ+D&SfἸD;]W#}JOUd~/d΃Bʮ¥'q#W=jsuv_i:EVN#?gRR|ΌcjQvr!;@Pz\S#ES>[еw*V 5JJ^b$e6{(1H~3YJ'+g8yú?╸x?jޜU iE85uͺv4WМ6w9'{u#8(\֜SKDy޿kfP8]ƭIV3VF+?#C'ٙ7HV`7aq^C枋vy߉th^OQ30cקkuwsѩiJw[u]FVʹlskUcsziƌ[wvrI *\y'+(<3 ʥM߮5TwhmA"dс;{`^}HO< >Rƫr!vA@8=kQwњSűXO ۟0 o.ԥ6m5&MtL~m HוtE(E:KM_Hѯ%_k9$^>U%g,m}˩'kr˳( Lp2z= j|Lڥ9S#(k߹5DBpT] 9 szb&*nY8mRHu彼g{3qב)BI=|2]ݻbvstݞB5t5ѩR#ψm]O\Lap߂3ctSoOu+F!Z5*Rz5M cU4$X7+*l;pxcFJƒQrJѿK_KߡJM][5tE9e CySq'px=ȬQ"q]Hn륑rJ̱Mv;FB3\q W*kTt ɖ%o_$E'Ns^me'yj?IS-ZGnJTZ;y.-5żs/r.ar+*w9NisA{L4ݞ~UFu(n/N}M kq4qԚzjeӮ ǻi;Sӱ-4ֺܝ,y˕@628YIYne퟽eԋ6Ѵq|ϺԎo¶n2ViN\k<`A ^+qIwK5{v)]\Zf˶?<)#ߞkS6_3ͯS/c'lvR@-|{~+_?]I/9'эں܎HT?zB3>[y؎^Y&h)'ʗqW `0U|*j-3&bܫ[KݲE?w*WbjEv?n9f!W'S\׻멍\dkZ4tkAYI1{p68ϯ(Gw151,-p0lF^I '9n:\2U!{7g{Bi!L6ȹ^N;֮!k]c걌k؎XCbEu [?R^+OaMØF2$plR@YT=8\Qyyt^anbQٳEcb_DeN8ߓX-$Uݓv8krjO_?R'*mud[ `r}ܕ 5}trJs|7=*$m`Lwh:)AcSXiwMnHgY|VT@q۞+G5CP_4mf`ªfh%z s.HIuw#)Y#nl`.:ZSFtӕռqOGXV_8mY?.7:jVER]5#D#nmNW5i.dw"41 gtD+QXy`(>N:qTW;c'em#F Po>aF.)\ol;.M2ez}~GT7-O̰gUTu}u]aEW^kR1]Od]،߂zPr|yZQvfU *:Sb:TZ[cupebz[iԯZu0-!` +O'4QrСhԺmnث䵷{CR0Xڜa}'%g-a/>;<yt[kΉcex+9oϱ 6Mu s'3!>UJX:\S(|ŏɄM'<jB7NϧjUm'~nyHͷH<ѩtzrn_y_Vͪt[,Km%*ۯS*ʬ%~u$O,2 cߊzuKDY5Ԗ-8Yw }5lB?3 Rq]ݯЮ.u˩ *]|y=zs޾q5+Us=3IJ*1ОG_QЕD6?}MOXme63|Y]Ny9yIZIk+4u0.\ӤHG2}zENjrSrߠ[oђ+ƙgu&i7QpF'#AmV4j([GF+n.mdVK'jr= yYRvw~Le*Ժ<;cp&$A"H@Nq96mˀ.Vѥ}'7R QZꮝZ_T֏#}<'uoAci qp<OWJ*#Uk(MjZ7\}瘱M G}0r> :[Klk/g[zrV[Ⰽ%mtbYNqztj[OL5q HV8ۘӀq{OZVu9J5cpkZ1_j;*,r. ֹN?,tGymSGkC6rVf;qW\$C2x7G^><3gO xK6H g`ca_:q[Ӗxw۶/M M,d@`k3*i{z^Y*1䭣误b»;O jq:;FN~̡xqےbxGG $wo.c+U.es4 ;4m?\`;֘jQPc?_Sni^ 'xV[8㺏n:1|~5h9iƤm&c|eju@#kyj ;{`TexըϦzIB$tl ;U'cVX?}HP 81ҍI6GM|m{rߵʇ7vxӔ9j;|/ 3˘?ylc.on>󹌰^P+xU{$ :յas/倪T>^ kQ>gq³*K2dw,I?NX+]ȩ*^MmnQ hXw'#OEg.X}1 } "?|JB335JteQ_bdm0+F%NIx$O*8"oذ39 'Vt%~o#(ED\9T.v3LEJ<Y188`Okh>k__ їS_X"E搲A*=*8 iMX;˗⹍hS%^g*$[ȣrOK72NDjN\' lk܎@ tu dz<ԔhPY$2œunA|(\[?B];!gBnޝGcE:ʥج=I~ŶR^4BXnóll*USJMhugN-+ ]ȣ?32YVRVç*W tCnR7ˀxo\]Rߣ:0Z\Rzr'r#RH p=GJV;*TT\j-H16UxӑUO_>ۋOg!xH`Hٽ=a]QN9up4ݽ{C:l#l$#br22U"̺[NWpٚ7'vq׵v|=v )sFQ[U[f~X#n[!ZRWwl쌽yc=J23]fB2q]u#(:e/rЭt k4lg#k*|"76(Mϖ+T'fJN_.q}?܅ÌET'w~xRN۲f[dTiʝ&3 ]a@ҍ8^_-RHvfkL|RSi!R;oD ɵa''Ur2J4nܙ=pg?ʮ=}ɅaLUf_GOV}erʤnu4va0}|} b}5'Ks|z^ΥW}zьN/“򞇷\RP#^qȱonY[$|ls9ɭT=;+U8tx271'jay~4MshZ; rܱO'9(G{v-iz@!0mJspFr8<˚3N".gzj]F$af1  =͚?qf?w"Y=9Z2\|Tkө.iz6Z0 E$fawZ)su閉'I>⑮ϼ:o$~_JԴLbGJŋm=FI " 铎* F>˿FIgb\q5~=F|zى%=ّ2q@cI1BaNkaݸ'Vf>^py%bJJ̚NDfOz}zc5w_2o-Y GDI'ۡ?ayomlF䒻ѫR\:0ꤍqbUIJ2.TſM.Ƒ9=sPdܶ"IJt73.{#vFH9qDUM{jm!"I˹yFGsR4ʵOgَx 0F{{֏VETm}fXU\,*c^}>KmNT+Jz͌,q6BN>+Ӻ}&8Ͳn#pNb'$ #gO~|ɴtOk%ݿ+BrKҟ{̧|BsL~h*N¿2$vP:LNrOXέÕZ[v2'{x?mMikܺ^TTuK%v%b:qnXpU|, RM۷rש9TN.KVE*a ReW7RQߡ=;B,o YX2ʌxhǤiM%K>hy|ʭ1G qډ)C{~c{YDȌо^#X:|ϙic`E^USzxRՈ5=%Uj;q֢y:G4*VTcs LeFӓsW*;$ڴNc|G5v9M]?R࿛l| z>wέ/U..| 9HR1f\jNtҪ;Xkד&P4ǻ3HbQ#Xy1]*tɣF:yh7PU挔FZ|Qi.4+"̼/@}SSL5ɲٕ/XaU82qc7M&뷩L_y`cW8 ;=GvF4e >j)(mAD 6pF1a&J|ɽA4ӯקRr5 s<y<4c=O{db,%z/G/>I:Wy<.,ʼn'm?OA0b3Jʬ3z?iNQDӭJVa}3'Ց-gS:kvFf!86}ߝIUG.T_[Kq!6.C @'j2 tκSCzwXY{Tf=$ʄrH<~epv +uO[5rKLjQ>I#ןjѸƞe:>Q6ۯGMv g9${dNF\iOҜs_D 5#;4go>FRڥݪUJNܑt#h'1SҦM#%ˬ#\46o^{vYs3Y7 h|;G{\e&Qom(U3)FO?ST)I,cXɻ= eTh#u23)V238QoˉԼyZЈV7I 0`sЎy89kKmO#ѫMHoFE 2׷qqRr&/Wmʪ+?e7S*quZQJTe]d+ndi?b1qRղ*auMv#6'ܭe'YZO3scتԿkBo~sJ\)IM-II$;b ƱOeU֫Ku&3Doצ=FyS%- X`Eby(ZmA9躪JCg*m3sD1hFr!Uln s=+Ҍc̥&٤F2ȷܬI'R>@v$c5e>TTi顱~I/*J§ͨU%[{:tqت‡2.dFjjT|ϡR8(hn_.4G{POCR VکW+Ho_ҶVVօZL2Xj*,=AZۚW;$ԢїG\eobu9RLih*c>uMor9}䓵@,;rX 3KAF#y]1BcS%.[#QR4*+%d|L>l8gh;op%XV?5ע9yF<݌eͲ!.<&Fv3-p>zVnmrW%uBʑq|Gz~59sNaʭ?wEЯ(s$ (>\sֳ>hug{A;<鍼6󫄜a"C^Fan![<6R1]8ב1Ӕoo7q+ j06'rh{M#(%[c8Œma!S;pIkIQV3qQNB^x77;5>1 ?_ˊ4 $?}g ?2}LWR7KԙSc4>6{N0sV6HΥ:,FnEwoRʧv҄47YxCFF#zF5%x_R*n0cnzw9B2^{5Ql&gf$'ߥi>{u,}Y~i~z<&˄yj]#Y>Zj덣~nʔe.xRݶCK+4cnLy\J=ܫ1lm|ҺK̗e.f6`,kYc1Y޽Hj'mH$Fv?oZǚ2K6y4B%r1~qm>ǚ]4CgmzHiY18R.QR>o\/|nmŵu,:!}qU~Tݫ́!x*eXgʈ{aq"X'ӟK1ms~HC@֍>qEl|~{_f:ac3|H>n=?QRzƤҐ4yc!$קs˘Q|R+׾-cy'5Q9nru+]*w3:pݱͺh3\w[ Gq]+{/hT'1iU篿V{waxXUl( 3 #(d%$̛$\1;\G9UC*Ƽ}i˚2lӋxfT&:Mr+ij*J`)'r9ִQnGea"1e ?$ѿ%2d.19׊Τl F2+qG?2EČT瞿(\QWvH䷺nWo2>n k= hԭ:4+MѰ%ݽcN.w"9K1 v{1n+Ք$yۿKmyF2w`˯g'khU<(|~UMI*mBn#9YOߐPhot9Ok+I,PZH}z~sJ^[߶F@0rq5"*B0̌4s۷<,rc+t!isrdy'>Vq~f4YByl($,.=YRKeьRNvۻ#vK{X}w]v&vGg?a'̯k*:oدknEfǘw+J6cOєV7^nvʈ$ӜSOVނBA$o|1]lc)JRFۖG5flp7 _^nm_ę~]R#YJM$hU<?⹪ҍH[Qz1E%/Y*a氼sS*r Ȧ%8cXTq*zĶ|aTƄ~uIkC*cSXk1OwӸvNPUA#8f*F1 GbEde c]Il=G-c}٭.M_ho,*$0/Ny,/*Ip0F0xڄ}jrE$?./\_,}xtQO[~f"7~}R>*rZ>:]Cc׽hn5sE9dc7At\Ǚo?4Egi;Z~_qό5%9𱓨+]=鍬LeګI:_Z>JJ՛i&(㌳F͕3$4tUOr& ^bH#*XQe-ӧnڲ^K4mgHW?ӟ?Web#Rȕՙ JLC"(洧NTmGNy,l.bOߗ=4~e_>WvY9]i;%ѓz}vDo2G [mBN,z{ n**3g/wKSZO1vUc?=b&j9T>GW[?( #'~\t/cHF\߰G ɹ[jOUk*$yTO}g4UU>n{tEm.[! YkguCrfx( 7r:UFW>(95snwINN?99Kz7{_*Iq&a8YwTyn6_ sle yiMʝ ]5m"kVX G*Qqi_g.fT^<K Fol~{FTSZnlaȡvǁn;08ڜERcQ)+S!5V~몍"%Nw q 5Ţ$ἼGOýkR2~e*r_H:Ɨ2{n.QI'넥ZTj?]n0D!*rO!is=;5D6qJf}`dVs$r=ںNRʚJϚ.Ou,sn g88 q겱:ur*ZzP- r3mSgnFM(Ɵ=9'=n%77(,$aG\ Ni˖o^i5'iGQG3/?ާH]CJtNV{Qvcughd6v#UɫﵿVk)[*I*ׁև([ӭMJ,n.FʇqpFNAF5>ZJvQfEp?֦?Ľ9jS"u@oG9ym_^`sk٧5ۍoFhw*)ltF_Jf[ң#SM喖EUd .X <֢2qN<G,fsqR{u..,{n6vp}yXGv.5X_m n̏iq\qDt\+ލ>vZzR51eeONOWzWX 6x6U}ѫg_z}y.YTʤը%uܭ=8ę, lns]jcf>e5oCrVD-2F\/Mz1hRO]mCmֻC}Etd'/|& WkR.$qdp6I"W}8?٧`r'hXi+8mR}pHגe#?5GRnm'2k]?}7B0Lv2g=z}}V_S*ߵqzfV@n6v쁀(zZD8g9֦ijVTsǯz$ ?Lh^WRБ]E,;q~PO8k+ԭ&d&NdG#<_p˛]rq_@1Vo71s ~<έ?ylsԅ*= 4YFY09=~yu5GF#V)-t)q{`9ZR+28ժ %_2POF,{;۹J2g8T#pT;`Z3Zg̔l1.Ƭv qQ)oyPNԥeսHw#,+'cۚ畣.rxQ;˯CY iL{s\V!֩y؎[6cݣ Y{+_ST8huAOd^ce;gsְo{q{:58n[,-.^LJUf ӑ_eRiIwvTӔyfMFU[{qֹQiǕkEL%[|]F[n9\p"ь*]>c[vI>I@'#>"*NQOZ7R7cۻX>օ8MNқz|4 %XnN܌8mOoNJӒWM([{(|O: Z[[?aվѺEI¾#^V任;έ 頶 q[ߦF"qW$;iPmTo^?ήVꞝh˞^[ ZyvbCIsǵr[}lyysӨݓc 1\[&引%YsobaHo)8={}%Jίl/g}Ui+\}V8϶Hmd1=SuIt62mz";fK'%w@݌ATak*J7Oi}'zXniTkNK74[.OaEUdC 1Sqb nϺsrJm?;g_[k~U({ڰp%UfS;g^ |~ӎUCi_-yvK )Z'o,%i_b{K0m{Nv-e gi~Cu8ѧRΫNűfʰݏ9WR肷ñv2UqqJcܹDYZ1gOV湯->_wFI,k<'cCn%"Qn ;NV"1T.[اw h䴆gI7v9WGYlmNRzn*Fbdz6qٚ}zt!V>c'yvR̢aʆ5IPyFJ,Y1$0O.WG)i~d8C3oYp^ফrlcՕMt] k"m;F?H\7ڤv&ح|r:\ӕ9"rld( / s8Vr E;G[`\ȩxDO1Ͻc)r*ѲZo/>T~;YH2F7c#=+\ne*Q< ?^-I$KR2dʒ<~WgEˡF1d,ڼ*?cR.;ibUg.גqJn(Jq:D$U!moZ+b}Tokg#,Ou?Jo/S~Fky*gݤi3(}Zާe2hIn m+1F:F2ҋùFmC&I"Fy\eA}zW#s5y)/0F1y21;AyRZ4a)-15Q]vRmv=x؊QhέI]hv}t$i#[ir:c=Wڵ3٥v k|Hn0\pzbBѧmаjrEGkt+IDc?3|n:W*s'rI+yiL|-O/ )ƍt*ӬIKFIq,(۾l,IH3X8k"R(Պ{y/Q6ܜg58ɥ+TqԖbGvm vn+xu%JjSPZ~WzVbʛpr QJƵJ^U8P[/㌛Z)e^v8;iY-:߱*1RIuLnU|I$r8 ۃZJ4mefэjQUw[>"ĤrG,d7dcp+JJtR4U8?{O4q^M6aX9OJKն^jI4eè9%~I̚ЧZA#$y?uFU99(rΏ+6;Xm 7vpǞҪIJ|W45n Zಲ46hP^;ዷCJ'JZ0X?t<(N=MuS}{Hls&nB$dTHƢ}V`eb.WV E9y#\iGeG,6 C؏ˊFu=tKs2-eYw:rhosYIJ}F \\1lo c++jF:4l8VeRBrǟ',bbNn,Opk=cRVm2]\ˌ/Ӝ3Q[\IVi$i|'2i8_ǖNu#$ DO1 :FoNb@]V9^P3>w7=?JKTilT(̆6&;pFɌ'rdgz\O[X>ix' sʆH$cY3$+h@#+n3 o8O~ء213e+t3rO8=iή5 SOBI#=oʧ}F:W?8٘եQe4GFpHU'-XGSyҳsAڱU=7E'kM4dx{{^r%7h$ e=۲|8PFLs²N5u)l}pܝ=Q)F_8:\vG"hofܿp(^@JxGIrϗr[Cjkt\l97SR OS5E4nnt;&b%`H{S֯}C[g-6ri1*M **<]8IAkՇkmd{FەTqá'BcE}x~SLR;2ʌ^FU!&2J^~]Y Jd܎@cUFVVZzFiSԒɳY"kO?oƝ9JVƋ|In /˚ܱk8i|]+8n>O7" r|afVEc撷Cjҍ赯}t#v˶c)Yns?VX* PF9qV|dŌJ4~CǷX=aQ(S*)Ÿ"̯[Ep{jQ6XiV D;)#q޸eJ8S漞慝*ffJwB5i7cNym 2y ͇F YFrPjjI(]zX*2ЋiNˍW.H<Ԩ{6pδyaӷtuV 1\XK~A\z9Z-Ei aH݇s<'a.e&sʝ5>tt{{8*XW~^OeZQש*/24s8 d̻d#2*}FR[GEamaE.P˹#q. yF7{T M֌ ˓Sk(Q^b"Ms[p[kzf)s]tѬ r"xQZ6ڟ4!]R_y[!h ˷v 9wN))XԢicHT-g,2vny\`W4yy8S*vNiSܒMo.]c :WbO:tc;"֑a,,aU9UO_»#e }t9_뫺lKi\QH01Oƞ"xRVʂVM6[ *2ecfPr\9eNcut"-Ya;q8׏-Oq{8OIbX'o1dn|^=Z4NsbirjѪ\gpcǸpVTiS?_gyumUR[6ͬK:F@w")qs:t%n5ֱl%doFrr~T(jMiní5YU)Uӎ?i߱{Jׯﱋ{Lm>b@pGNԌjSoXN{nTlc1l08_\piVv_qʝ=wG迤w^D6m`QN3ޙ+ëQf"4I/.g"F#ƿxeSsw{W7]'8qc%dgR-=AԪ]~oǿ2?jq%@L̇s_D}!PJI9gH'Q5z*iו߆nԷI"q4~b3erx*y\Zc8׶|kXGV%7o=5a)#R$OKdfqӷ?gmb^ݵ9#qja֯FI5hElb@#M#qz J Fϧu/,1L GsןQQU=&P~ٻq!$qZCZOwfWק;oK0UO筇)_>- 1n[0_s?ԩb):\U 0lqYX8 szTE(_JHkelP͇@wt9*1 (Aʛ2dM2)8沦m3h|ۨ42[C>HaU'qǦ9%RQYmnrRzw.ll"*ʎ:9T)wԩٹGmio m54t~=:ҌOS:t+[]v1~?g8ѓOD9vyuY7, 7srZ1f:*F5 cy mTvqwNcYqfi $mm"zTl乹Aƴj7{Z$%ŽL".6#߿Coc4k夬|ͣ|Ї*zv34hi߰cPG~\+r'ڹ)۩B>ay ϖ_VrJg=M}p6Q77,ӌ쥅s8_뱭J2d}AVCoFmqy9*1R}U̾[ MūV2EtFnpq0z4cOT>Xm|ȴ3yUf/6:~vf8Zxs}e9U^d4xB.{;y:ҩS斊ޗ:%%R,~^`˵0aS*ҵ#:Td߱%l'vr8GR:hʤi_{O+;+>ݻ9=֊җ\,4{.uc`l+ʬ GNzQʓfh2'imh)ج1ֶYwGLeNݣf*ireQvM0q=)SW9rE%N^Dsl{;,99ڳZ+QJNnVa(H*#Һhԧ(*yj*o~UC*m>tikvwIRN4GnrF69lQ+JW֧*G)=/vD@[CmbWhb 8fFJޖOB(>Xo罺2I+lI klöAxXF4(򳦭IFZܚ 2Ҳ E=ujƴ+cx-&M#3?_yԩJ-7bҷScmvɭ>c/IO;H?ҿA%J}SVK7Mۍ-v >vS_oFϬOjoa_۵nG |o| 1 3ϭ}iѫnit)b$W/j?OeW7 ke2Cv($yO̼Lv0zs揞_xђjӕTO}c٣O;21۷xrE ~*87{yH7nݽG d޽<e]oGMutϧ3M}ven)0w$tzqWZrj-fR]3"C*Ԡ\[ K I8V*1Vul<%ݞW/ a~/ k4K Nyn Azݤ"tt{#z-FhQ̂MzsדZrtƴTu^n-of*|GϸW5Ԣy8*RMv/x6-/XKC .;F~PKc ˌjQwбB|7n45Z2CcGM|<2𲜢G8mln,16С3 +mHcIIKٸ+ϪhJw:Zi'}xGR]Rfc/>Yأd_$8^VZwoc֥*$kKynPqt-Τ-$9J䜁ܷcÍF9e7? wFPe^ϯG4[(dy&bE<26Glp+eF_w橤oƐEw\:ʠH()i?)ՆzcpӞMR}&eϓmSU|Y49-r1!ørp?Q*95t˚N> fsP5E&8`Iq{Z-SZzW[m⹴Ϛי)yR 9k⸢> xSR>_3Zӳh(G CM?=| Ni差ƵHhmܑW],}ONÊliJqtڻoo.vIGi_0PNTjqI쯡EʹS~O1ocVT_S=*VJwשI59]!Ix`L >߅z4:yT-:%Đ4[vA C^'+GU8厉!M-ndS# rxckێGFRo 2:۴V2entkR*m<}kգ:)^C )r ;6IPl9)N?^9q<=J4} *TZr5Mramę_4<|m67dvws=sYFNvqJoc.I3Nj ޏ}y7?̼6NӓCұ+ԴK9eʚI] VP7zzUFjIi[Rj{o=!-ce<{{'NU2xwJGz/pQg̃|2UǮ}q֋є~G*~n~W%RVg|U>k:x._B'R~[vFݢH6ETc)Ǚ++ J8mmcL7#+(I:Bj{8Yr-V/8VV<󮪒qmmN*3nZK4 "Yf9$CQȑT^ޥ=ߣA%3*Oq9\'ŽV^G_pRhD.;c]P?fIf-'"z̮X~?^ztJ7zɗ(C,lY2e;}z9Q*kňխn v߲?,نBr>lAUN>Χ-V] JU%8vG.9c(yqIqu*SRN/~4iFUAkq`P9=s ;޿+*)/uu\GkQd2lqVn_B>Qp")]W20/W_4.ccR;KoQf*ᝤݴ9)ӵSSՏ5Ϻ+K\Oz~]3c'fuJ]7lT{ϟH22K6넑 {Gއ-KJCBezǵuѩRX{:DsZ@KuܻYDž<al+=(J/Z6g `w1:%7JYAbf1c_~rFQSՔSIc<<)% hp}y>VSuhaԣnqgJUy^ﯯ4zeȱݪ%e񏔎;yciӊrW*i.x?hŤ,(W˙C<"*͹uZly$ЖJKxfU24To_L2)ivzy,]fY}C`nPqm#0KrJ͒(#.\n޿{yud*T&R+?:mUJC΋喷{ȱ)KDk62Inqz9ZOe+ѡz""e- {)\tk.۬DkqnG<ҩX_m{GnE|bu.br{ǥO6fjRm=eFբBi[xQ9ۻ=~TJ.Xu]t= r죫_yZoƻ|?7s4W=LiO1mg(w22uj%a*)ʪ(EHlnzgx=Eu%i/,w<2fb̲lH}h0%F#f(k/t] v NrGzƏ-տS| ۻ o6L*uNR+kdWv+"/Ź\eR1SsBUw#׉#Bўkhz.y̶ѷoS>We)rI\i%$Kq#@<g71 z[7N(Nw+mM s]Z3ʮYFںRйj&Z%f#-2Ӟ?.]cNYKr_6ݴ:kM(׿*?iZvV.%Q$a ZOz^2yJ"f4E'k"7nrʾg$jy#ѭ.TwW)km-RCY ?2ɞWu=GSP漶p֍p;U2$hɳU ^{m UhҎ{B q}#[D1HQWO9GNs'o%mR;s,c,Ozq=+N^>hIt#3*evoǦxkh㯥NjBY i^oHwK H?'NNڑK-V1.%[7cS3UBv_)MmaNЫkxOZYΦ7(k+^ܲoF9W%⼽YNRQs>shepqO_oJ5=?y5ǟRE_GяV1 /e\XӵmŮ1}{2>oҚjt uJ|?Q%iq͸98\P{EJŴd z|j-we9=xz~մOY߹ctWc亍!H]ӜtF.˩:ĶmU (g8S0~S.hԳ78wRj߹Uwm흼ceC˚Z+?FÒI犹ʌ~ϒ ͻEe8<"eOrbpғ<!9=}kΔeaQ":{<$_S}z:攧N2w34v*\یB|ܥ$==?gwo碫=e$/q]7c"qmBy33(}/;8p?RNK[bZyIU26~adl泌cʤ9b#ZэOřOr=q,ncZa kmI'TՍKI3jr+1eQ6KuigBNE9TuyQ:0Y6{rQj[$q*Gl8TƬcs*Nѿ_cOOs3`_ `>+w\c9:=-#fHX[fU##MzʊCUZm45 &ooxC8oqϦ{5QmJ]O鬢mʉ[?b} mORGOi -64v~\Wy k+$o 4>[2'qZETJЯKxQ.$`1͸ z?F[Fq^CoCS#}n)u+0 ֜аF/;W;mpd_2;ڡIjV#wXI(|fVM-w#ln|ʟC'YV\#M S)NJ:/Mݻcm9MBJښF\R:$&)"ɂ*[=}+il~V-bT6vf\l=r0j5Lrڴ>xi̒б źdʠ *{On{{c"g%&-%hGfj[qQ.gQk"EgV(يt^jB%){/RVh|{K?1k+n2Ik30,#ǖ9ֳqcsR G4ge,r}3gR)ƥ:.\3o2nܭ195/#>XGIq$S/$.W?{ۚ121u)]x*۹!!}} \[ Ԕ_B+x+2e,Wdҹrȶ,/gcRt 1 Mtrv?W-IsKFQ|ܭ/2i#D3ʪ1玵(EbjO>(M]@eg۷#)|%iM;m3KhG˞ҕ䝽A;JfٟF}sS+;Kuq;x/] qGZKXQT;-S «+G?jrFPqFe I#}y# v/ٵŁZHZ8!6`Ƴw!sEd{PGm =@~_uBR'eRy[%aI~lShOqBp;e6/Q I;u,@)Y{>P1TR єVK 4jt}ںm |h!70.2W^34+=9i4Ju&Y2u'(Ӧ]HJd(;g<{Oxh9Uʅc0=}:8siTNￓCc,;TZw氹:~m½:tT}K_m# \c\ 璩d&EMѢ1YHp};dzYG]Џ4.ܞ3˄(L^0=eG9kF*{ ]Cub0?~ZU18[ *۴r j{4B}iU}fڟ(\9TǑU?ikﰋuhܢɃ+=Oy.j8M&;Ja'009O~[c ?+j:p$x,NpG8NF{5ͿTj֩)sY%;xUfQNq׎{5Rri顚NMQD`1obiS"5gWcI} j̯4ʋr=TԥHG˷tx\yrz.rG-]: |ʻzt^qU>e7*+sm6Icqܤ~xB;7g*FMNLt U-N9^ѩ_si+J\ٍCxn89(TTNʊ4 c;kؒi., ~$:QJ/Uv)Sf-1傱HcE#=8S\=:r- XͳLUF}h)jtџ-4KoYK3ۑ޳5'̙Zq|FT7Qy gk:]2QMi(KNO 2#$6w9 g٣enq5 rC:~44Q71h-EsP죦{;# Hl ~lSUF1;gwJ)=YF.UUUxvӠjz59g2[X*)% deM'cU*RJm4Lf"O g`>bK_:}TԣEuqnm(>ǚ;JJ3d+~ː/\| {I>_ݐ .vS劺vNGoZF\yAQNU%n*^W6` =:.Ue ƤcV\ڃG1ye7^u_e[˒[0;|υs߭kN7[kV,IL7o˷L^N5gӱjհqNt9.2~;eA ۍgdД}-7݃J 1v%>Y^c3l*rϿ^IT_ ѳ8U%hmBn?19+qU-eh1PNkex'dF7>jJSc:jOujQ,nvynwNV(w.x>ew5Mo􍥹iVqr*ҧn[IVt|%@\ngI'e qmuc)EF/q!4r$cz i} ~얝)Sp#.;t54\-m.>hk,%ƨ6d ' ?5)s4]"[Å'==9]9F\؀G-4[Ec|ՇJ2Z'{iډsq "K J1KZPkUDs YQcVisdck7VR3iCRSomRBf=D.zzDG)\T[z~ww$p\6ݫWۨ*2ER(m,2}>IH}㛌?y.ޝD[̍Le.z鎹IONZU%&eGr-4oݲFTm 0{~'8SJKKunj⥪ք|ov}d_W3)JuMnu|3Uc-Q99NK90{irU1 TIg(݂ {{\U*FȪdU$O/pe"OGBOoq֩6Q:^Akg2)ڿUZNI;kPc+\lnN\t#5NSrb#(~>Q1Ĉ#c`y$މNuysػ`ǁ'#_ ӕ?u:*m<3M6˻w %JgNjr{oTlSWlҔ=U*J.+Y#S `'vߍqJ^W]̱Zm{:]Ily&Af18Y(:zy=h=uX mnU.CtʭVD2kc<8RNI]={+v%$u`1/zbQNzO%7%!{bU2RsXQ{i6m6G! 5ÚO{^hbv^䑕{qUnUS"Z,]U5N9aꥤW^<ְ/jJw}ܚ4yury]Wals=g*-] fƐXx^Npp8+jɂ=cetN;i9Ɂ&ݹ&ߴW6T7yf_&HռR.13:ɈEȬnF59dO"HiD2^@${QWE:5oMԍuم٤y $grx{T&['PNU;j͍9--.tZF,F~^8{Y~nFOl5c͵~~X:59S]?} "1ES3Vckjt1U8= K!.yl.g {4˕39eh#o,(l,8z^]?hlbs{LWd9'ׅ(.ę6WP]iͩF^krxnCȶ8m:]o2~"Lm+7'9\WJ*W;=hQNd8\a/`3!6Uʶ"e);:`C*+mzN^ijeIoBU qΈN*Mq9]#׸oty\2M%>jNQ&\r- cQwr+NJc)¾ؕuRߟlS٩6cfVqP"?.j9yJ啐U aIo~@#~h .hzO "n; rܩGݖ`Slq~k)-GF oïְnJwXܔ6HJg;5U8ѧm]2u !h'FlF?=;Jq壊-zt_ܘ^i*qFZ\WʝW愯bG@M<7sҾ_B.w3J IFpUsyYwe#s\$!NqRgY$Z"r>e;t>x>XԔfzõm9*.#YЌc<ꌜ:]BSyH[n9iSR5WtXޛicSX`󧹊E;Y,#O(4Tݨmp_B֭3mA4q+ogN5}wWJrtv&ch$V}GiQs ʄc_]?UW rƑlxѧxiZIOQTN{%ѥ\G66U:e+0 E\mi"eH̒6' ?ʽJte*H(էNNcbC3]ƹ;8Oҽl=8Tx.oN$>'W}Nt+ȱ3UUi2ǰ[om 8 ``{+4QrfRF̟rF@uJiE 5ц!#3+$Woo9t$v{EeS4py,8Xf_G8]kiC޺:)4*ZOK`ƹ\]4{N(rͺ"#n?&nߡN)U\wu[WhҚ82ЅKH *5){ !s},0v;XsFYN-YP5B « -%K- -oHsJq¯?iHH啱yퟗpM9Z~% 't{.˳1UǕMhZMZ8+0@N[翵pKON7z2- 89\$8)"]-/ch03l,r. Ͽ4v{887Zdnٵ  8T%zvxz1u//u$Esr8?M(ӦOfw[g,Vx=k+\?txxQWx?*i/:<=iFGh[*{ qU/fקTH'G<҉ +9hfAfHTmBne&&$C+ 4s<2ad,&?-;Y=+ьyfU(Tyf[xnJ65<y9(Ӕvy6iJ "(ry>_uTi^]!4+sapզ2Z7CcVIVez;L֌*ZIsI#o3g=ǡ슕9UѢ,ݩg9^7Z oOzs(>JT r$t~瑓yy6u{qh76~yrIRJIߠ{hayE{gXԔz3M$qcRYWV^MD,Rv$ת 6D:Ⱨ;ލ*KX(UW<_~*gJRѳsZjD ήSiQYԧ+G^7"2C,M#.$O??BRqN5JʤXiO~U⽢%u-Um7;rI3gR#5>Ḩ#P3=8s{zJSX3 s2y#c[]7aS]nyLd+b-IsB.1# :Q~fRE+EvO'.793,2\9&u½JG 7J.fp7u=p~ms 2VѮY9VE]oO?zVS(k[]%n^ zo~uyr9TT%~T#]blQמRXo8CuQfc9F,DZt/3+I@2}s\tԣyn=,~%U JjYY-UQ9yF1ʗQNn˷TtEռko4lʄgoCn/-9KOMSLb֏Gu56N 4Vʝ[NZ·-WoumFS\"4ػ [IR݄;Ny+iIJW)]XfQX:*~5$$*_Nj4#[Wsv,Y9nfftdڡrGמ,-H/*PΒ9XǵxEy%=Ij[]i;m\c, (F*+m+7wԎݹug]>tJn]M9hQWhSuFn/~u)wt& wn`}9H~W“=kz2- SwaWqIrou3s޽*Q&Ii#V{{K0J8F}x=Og+[E׫**Zw=XiI}mko72LbVi8㝫;blDJ릻_u 1O9%M+' *O~*ydIo:Iʧl[[kecg\^O# 5QeVF<c,Q*We:mo'fOSBPm+e\ cqN59ds֧*zcţX[ԳFY#!@$1 Z%kY4?_0TyUtW I~$E_pygq^N.8#:x7SѴ o+S_p0pzTTFwM]NAcܱv|~U5*_"E鬒eg!W~^0:OJ4ⴱ¤}\ۃ2FkITL(I 2OU=:|Ԧ+(:f,nqIfF^*TZBb]9lRaڒ<ys߁ӽTW=vFu'e7Vs\]4+;1ͤ8}k9>]ֈښORhi qϽpʬdnj|ȱv %+.;ğzjWOOĚvZ݊Bݗ`Knp9>&5K-╥Y-j }k9Eo[548U8m|neHUlǚqqVViGqc>fPW \n}/正Kʉn% r;slNI$hS̬$LmO} xMv"q"2b٤d֍ {cs%1_NVrMy rǴ.=^xu*J7_4j_^[hMl$m8|2NͳΧF*no`{u̖VRʫ^yWl;j"RNK~z_3ct6jVn Zwd{3WYTCУ/gmA]6%ӟ[RUGݎYRӒ}3]v7q=Up {jv"Ac4Yv 8ӏjXu̝)'Vz ő՗ƥ=\qG4F-+0|N.=X,71G\81*uƧ,z"X#XMJN̂ϯ?c.XW^SxՍl;T@K#Hsr`s֮u<5%N0VIYuٮ!h/Cbu9\OWKsF[5²۹;Oc=iS;ZieWF Q$H!Q`G=[aisT翩&49b>41+meI'UJӫQEKb9TE%hvm $d Ҍyb;ybU$eONN3;V#(Trn֩*ģE"#T.qW+֏,D}OvB=y>T\ϷZ䦒W}yVM"F~wKr}bh_wa*#s w=|ԓTJ-ٯKyVMcNI'QhiF5(qnh20*җOoeJ<+/=Uw6v"kNS%'EuwfYFH㍆[s#ZRgTkS:1MI4,c̬=tcS%[K#Z}HdW商: t|uSOJ ͷn`鎣yJO^lm(PQY=w30g&)[va*~Dng~_xcBW5/iG-?&M 0 p{0X0,yzqWR*IK9G"8]Id OLߎFғӢ-:DຊFTru-*--Z8KuqZYmf*Or}sϥOu"+ h!Wpe^ 9mv3:j1R1aeG?NpK}b9l`q$o2_ML)ś}rrRw_`X2[Zݒ`= 9pӓhN 7KO>r#UCt=yk{ӎ.L=# {0xn|m8NJ{;Y&̕XԻxs}~Ͻ*rc RekKm^1Am$ooa#=kS8<1t.UvxRnåᤸ0xs*/neL1ꖄkj>8Ԧk{|LӨ?~N]_xyB%$yč!|1u}*qɿxPFJx\sl}~]9.nӱ G>PykO`4Nuj,[d$c+1Zt3gZz=?S⋭Z; |;ɶ$Cy+#nFR{3էrvnkxZusE+ЏEF i͞]W5II ivwzx^X՚x$wm@l s+z/uajT'ٜU֕GdCvN=c9FOOS?bu۷GEk\I6"n\{?.ryTE^Z- xM]W,b̊7Fۓ wkOm4y5+6^ݞc. [Zpsdr Gygs%R[oSY-/fX"Cq Щ&ldF)Tٜ}kTJ?yƯG!iW_U,{Nq L*xXl=UW#ȥ y5[diLslZ|>2/#_j(E[wgwoOP^Ꭹ2çUUqp@dqï-9ž9qI.'e:)WO_V$5ՌnaA?g';/S].l%4)!i+ŵ#nkkKF;e9^OT}Ϭ\$׬eGXԴ+8}tԡnfHֵ yh?Ł[۳|l|.Np) uܮQy᳂Iaڑ#h~]Y9-)u~+H *`㡥Xw^۾Ȫ:_"Pǚ2nҌ*z"Kq;;CJ]sKwGòO \ە<0yrxrYٷX.VNqvk~j8Jܯ'J&WNRz1խN+vi%2 ҇d#9`N1+pyW4cRw<ľ=:.4O eNCc8`*iEn{Ȝ\ֶv?5koE[y#IDɃN=^zvJl꺤+Ns==?%u|-rGnzs_`=QRbO1>ؐ搅s?sJsksNRS~nU򑔉uۏU||=鷙8Gso>%ٗۉbOO^ԣ't_nRׯ:(XSsrs\/&= 4ʝ}By^rL̥HmWvGSP ,jujsSOܑ&cn~M)ǙKkv.;Wgݻld޺J/Y.ޕOW$+%fUPܕRcҊqMC~Zޣxjv'8K{^ށST "A3y2 `ddgߝuF_ZTiIsngJAttMFԓVT{dq*F+E0q.i=tz.Bʏuy8܌ K~;jڒZ7vY_98E²Trx秷ZE(Nޡ(*wjԄ[JHW}'%%yV[t]Q,!qʳMێխ9F-b}AnyQ]*Ϛ<)ޔ[Iq=xh.6دkF9nU?#PvƬUFz)rji՜]Fqq!\paFF7׾a˫KpϿϙ"7EMvg؏]u{Jq>Xz~{H;mX(8ᎽG\wʔ+)k&*Ok&ѷW3Ӡޢ f2̚{bٓ8lsߧjXVKkb)򲷑Lۻڴ+˖=6:*BkӡN"Maے\mqSٔo$t=F2͙"֐5U#ݟblљ2TuNm{ӡ&9rvxoe]H |F _S'޳Q}YaTQI=WRkm0Yld FNqOPGk)T$^OV*E'Vhhou/#h-;xn(ǗSX ugtkLnm1$+|@73TI]\^Μwoo̽=ʮu vYK Xa#*wh5o|۹vj%+J= -A5mܼt{rF9O\+.oiNz\\5̼_;2e~mN;:8n%pHO/GE|_kFHmGOy0y8"6ԩrt)s+9ev4ʌy9x7}@|Sk半=+SkV55qV՞7Y6?xddtiUHSJSGn,ɤ$B(u1yhwnӯE}2k:qZЙlA( (*zpGgN4B}-zv~Kgo$^ uEE|Q5.Ӱt@_ aSG޾VTdyVG#dqgv~IꋌiKEV# ̈׏JiR$ޅfc2`Xoq{Wy_zգ:u-W4x0гBm8=F>u+*tQ5{u5l#C9ǟ󻪑\'.,k(KE`#fcxUvV=8ۃc9jכhzZ(pTJҗK5^R9Sr}-e0ZGXc1c:9y{)Z]2F`*R};t)(Ƣu6]쇦 /kO0+oz]ɥU%$LBj|z'|qqW?ee0ԹdYXoEaQ\f*1Іs+HZ>_Nqӗc*qݼ㷸c]20=FU'Z2$p>*)Kz}?x֕֝˖+Z55譡gl p1on/:wW:##E7aLaq洧(ԔsjGnՂNe"]#|`{*I8ƝmHȨLڸ8?{OZi*F4RV xmH`N39t"Ql%^Y$_3;qzQ6=pHV~ui#+3ϡTJU9יRqN6{hיUU0ONG[[a&WDD,~?(ܵ9,:KA< $du'wO\g(J)H${h`iU21۞J肧+7MA9BFw/d0,2;JQG[AH ``g5\ҍ>oxN,3.#76A K"љ$(<ϗic,9;'kt:{;lED,9?UhEռ~dӕID=4,[F]R;kY}ū=3Z&z02OZjNDO$E}-$hmCHHSp=z%(sn .GXᶉUxڋkD#7{G1uvUQcX!G:`^^jmx*U*rO2LpCoA8Q$sP,-ƖPO26# yxǵrҩf;~QFq@p]Yg U)JQP9uch-;ZJ6: 2mȊJ[EԨ'k68Mݲ c=ǨU.)[iH!* R2ܥ)Q̚oGtҵoi͒21Qɩ|jɉS#Zyh U'$w-HNN RߣCDO!sDKBTJrlRj:G$Syįy9qJcͫ&qe{}~D0vcIf u#iZJ/OtJ33}V;Ʉ-UH=nk:tJ7_Q/hr |"R,Xf#rxjTm 붆R*fN*4x:xgSܪ9]^FNbsܞރJ>ouijbcNf!w6d:q]d^2Jdsvce $rpFvJt+ӯyR DEu8A#vq\8'mot,l֡͐ǧ>BۿmiR{EE YI;wUF0o:WQvh<$uݺO_I]$ $DS`T#=QTBk-A4;X7 s UѓI-^FjKubbX 9M7PAOںOm:zR:҃kDbx̲7-p9;*ϕO *RbsfRU8vG"4TjBI&fBƲUyڟJocEMFНK<*ؓUJkOr֐CsA$)Ƭһgr:/Wo/!h_»)2uOOn;WD GF5$4 gPtd-+FۃsgQZ#~r4HQ6ܥ[j9 GJq)&SKZ\+Ŀh*dXٓ=Gs{TaR}BeZ+u @ O_\%.]Yx99 BL|ur˝3q|g4Y&iQj=:zX[cqViv{j^dlHpHZI"~&֢aʕ#J@l˒7>SdDȧԏv&`^ N7[|Rj^ZńH\بv:zd~Ui^ȄQħc2BKN=kOi # k5&8T?37Ok5!N_wsHWK6_3.w(#p9{W=IEK5c86Ld#6,@9ʦU#\,4B8cXd#U;b;L)oԅo@if(d/c,*'=G]ZW=5ۀ!-ޡv'EOHr(@5׹j;XRta/,foUV#w*ПjbuExfTү(, 'nMc^oCC2d_iV5B1Φzm:goIbاȹPGcUgʷs8pT{2-|m/*0 r1ߧҢygy4wrQ=bx`, s0;jQZR=d/6p wҷIs"(,Lw+n^gy6mk}R5pa9Q1YxֵebFyQsWy)>k] b&(cK}0rny+nΊP؝"ʤ5^[/v7؊tԥ}BbPʥce.6>?jWF)jN4 <H?\jygm]4R慹lҕ;$eW擞H=ޟ*%\%Y,ϨZ#:>et-է¶Ểz{QdTE!,*QҴJ:Xr)F@$qldhQsZVƔh%q{"#9c j]7kD 4_4p*uiJՓ6cL{8$F+{Jni[&, w<7NOo֔RҾbQr tq\浊崔/pzs׏̪֯nQ9 @އ1|ߨYc0|e=O<fS/unKȞkce$3 N<@LPN8¹ͽ25Ac]Cq~JΤ2nE9/%;4RqYuUDK,ȧX=F}=#)iWẊc4*oK6A!rYcRNNr*eYSR{\FvcX=q=뚥K$:WkK~F}̗&vvOʾg&'epr7d"qwpz\U#9JaZ1FsӤIXٗm[ Ƨ\Qt:H姀mfʹ0ێ@9l3~&aZ5!lxmwd~5Qe_mY='g.ZlfSeG=sUr%/g=Xۋn EnF\w|5yY$w|7gӭTeʚF)kؖkDĒO>=S] e?^50pI铃]Ҧ*wJ)K̲YOdzvnG9ӏ씐JOr̒i# ݏʟ/^B͸ |zr:Ҵ[=G~Elݞ1?\(riGK>I8%*U1+yR9eIƥܻ *X1}}N<,Q%WwWtc4 nVfD[B_ Kr*rIvMYm3wmN7Qߑ={Kkr5R11{h>ڿ(osW:);=5-jąMF>9u*DE ;$Ivg-9?k.[XwTUĺfnv+#c#=3[F;6wFR :; ?ǭ-,ggub1mW-4Gw͸n>awAQ+ jޛܬQge1Q[sjv؅cϰ˻jz*%j6וh:D6xXj>-X` cpW?|ɷe}=HI15MJۘYJpE܉feoǖ zv=eТrg>f5#)'ЎX4XqQCIUK({֜B# ~ӝlGo&L!lbF'9?֔ymQFRB@g&1[l8+0d\ś UT1Um/%?/ΒVsx-EeaUAԂ9Ue'[JMnFOb=nR-ԝޖCfpQ#8lE~kkabTFgRHGޔ)]eE;jA{c)̛-džGJ'rb$x4(6Sѐoq-9ǁz̼SJvw^nUmW[x9t-zS xsNOrZJ2Qlx]˵$88'^cR:iGY\{qY˖HQ߰[+x-o1XGz泗'NB*CB,Xd+`{\ry H@U5{gN[}I&Gз!sߗ89+iT+y2C"k1BѳmM{+z=5Nsҧ)_ȁDq s:đП^+ I4rʤ#ӯr!s%` nC_!XʜdrR~X,JTvoQ}2VmN2.IuZ&Oxb$+fp?#~Sv~LҚR\:%T[w'{<(=J9{}fRkgB 8^:x-sw 󼠅Ord'ٻ;,%ߜs7#}\kTMHb*7Ԛ%fE~b5IsL匪s:o%vŋOoR gGYG=otR2U$}u-,]dNyS(mNhԗsN~>AUeY, DowG9~RݺdC^,,n*h(U^]`c*rٙX::Ǡrѷq#b$tZFeQf_4ۿ*5#b V=<} miJ)|%ȵy?1v#>s/ߞ[Il:2[w}P[e dp{ҊqM[GR0rW)c R-ݹ@s}ELSqEMD7K,3mi<Ͻ8קjѦeɝmcEԼn!.ukx(V;1qߧCǽiN9KlDj%߱0yq:j2@=ǡbN-F|VԞ/6-#l N^Vhh:|{yF^~¤]ս A߿-rZ.Efc[h+X~3\Nݮ,&E dn`0yJڔyMa˚ZR)/Hϯ<EW*eB}Rj^L2OHAN[ښIY/VIʓKX VgGXR8Ys r3G2-MGe-ĒY@UTb96nQ AW FB8^t\v+,/$1>N-Y>Ӛ^t[7virp? 񮚞{ڎ4y,Nk쐫>Dd"^4iS#(Y\J20 :Ԍֆu(J- V{2;&I3򌎘zcߊBQFu Ri~D(b1ַ@TH# t8DZWw&4->dib$NgǞڳ~}1%._I#dVەygWYSlI=hTV Swu*.I&fFOB0yT\gKaȚtX"qTc߰;jg(n_2i8{}$V¨3z'6"ޑYwcuxhXۏ3JMGZ?ꊩZ^Ca:l4_GO1\~zT8VnV-mˎ ѿ22VwƝJi 4#D>PHS2J6R1"0wȱ\, \NJ1v:NZ_vD;[H ~aw+&yFSNEeU3|sǭ(Ԕj.SQ=Gee-Py*H:rh|9b}u躯Rh%c˗ۺFlg=ҹ˗WW-WM]Nyم<ݰg|~^RZ4g%nXԌԱ/G;𒬘 #<{ZEczT.qF_Θɴ"UfۃG8\6R4#Gp!J+mʀF35|JZN7]ƅXE^ i!4S2RZiy1. mklFAz匴qnY6]5|SK7IT/E]K?Y q%Q.¬[3Py5n]̱RGac|V9"r \V^Nj,įqg314k=uu6~;#}Fί21i$8K'x( RQnDFpviH;v>(۹FOVFI2AV#98:PZ]]؊Ӓul4'!!Í3~+FJO(;.Wf2b[4) n٣Lg>sьBȏrX՜~W}+9[ XJhGo"IEV_*dq+S\ioMk4d>j0*H>uդjrOmLGJ]ĶqdXBǏ,r:9s\ЩMJլL%cQB9{u O5~NE uS 6TGoᨩiVR^DRhW\۷ܱygm$ĄͶ9630=0r=7NSqvKu)QyW[W3 Y=z ~irX%B-w0@̆\mc:Zm*JL&lRxdFS1g\VqV+K Qo w\i4=dl߯ZѬvl%^j|*Ie{h}ʫ|{t{9YˠX-Bk^5|醡~c)G@@>5V^-7e+CkۨQ]Ӯ5I\$ji֣nD׷yjBxf,s(f1דTSZ+EʵɫZXU`v}}Tg'c׹o>Ex+Su \pHۜ20;sJIԳ[si9jEߕ[:>2G,_sξ YѧRkkZYUP\}󞧏}^u8Ƶ.h#B?2(n'd4eׂy$WqZ{y8Џr[gV?~UAStQRQ$;y=NzOZ)|'TiӔQ-ge8htӏ4b >PN}]7dz !ORSMqz_ʐ u;|V&4򦝤9$0*~ebKg9Qe8s=%3vE+m\{U.Qe$tl0%ln$uY򻽻}Ine۹G@)kۯS\ս]J ȖЯ!ܬ`NHb8sY+CJj*RZ[vqNTpz׹NܷݏB1}.4W>]<^ qΪ4r_ 8L`WQ=\kԸ RUV\~0fvQOסuqq<#玃]#zt+IOo7^~2}v(ٳ⣮£Iks*~_]kF.l#~7V׏+:}-Q]+c,6|ʐpqck֖Vͮ܎̻wSRc@02UFIױZc w"c)phu{R6t-ە@59ЍQ<ԔyKm\!03Xԋ嶟Srqz "ƣ)c?:59%!TzݦU1nH,sNƣQ^Ջx/ q/ah^N$/#*1G|W8JFg.Ufmƛxؿ*e߅s4rˑ(ʔkrm1J|\MU~{9&*v4Ic/Q lXr+ɮ])B6F.hua'csch[u2UّuPMGOZK+{ϡJemHjmN8[B59\S6.XS! / +v?)MB[EOA"Pq#&#=sJꦖ^ۚ, %z?vd}/pRGDsz测(39ɤ2FrkH=YHӲZyVIs;*溡%:6qB8M*vWp>qMZ#ſS:u8)ٕPiJ^RḷEXeXs؎8>*5#'7-rYQZgk;_yiЪ `H1}+jKJ9c|ߺ"mK[f_9'JK]v {5,}đy/q;r@~Lj+. +B]fiݣgl,o'lu)rEr):kga{̋*o:dqzUN2c՜~YI6'?ʸNTn盎kE9[Alfp8X9?YP3P.sNm̠I\9j'*Nڛ{q۽[dc6{_zJ+OUrԞ+` c"zsU3}N$Z@hx\s4{:~|^]MmaeYqϯޝ_/ucjqRi6*4k&cr(dє.[jlg-(,œl|~iK[R)JĒy썸!V* d(1%ƚvosn})Y1fi=>11mjg5#+6i@g3HW dxjY/J>W6Ij!h2C9nϚ^䈫:߿WMH6CУ9SECd+!7_0'zM+y:o}Uӹ"qrČۗrG3^H=)ʚM &wuz]Ԧ%mZUNQ)T672s֔c̬cS~hغi̭3c+uֹ& bw]uǛJ*m[w3 U N=kͫR%炨/CXȬĢZ4V3Nx4QoؗTdUr|~N\|F4R^qupEK@X@8ǥpj1v;ԭ.f >?ZFUѼթGk^2 Qҵ+sTtKZ\*.pBV˒oNrnw: $j!xٗkG0qW5ߩ, ;l[ 9j_~J6c tf뭟X-h*c+>շ/4sKKv;'*?0 9סOR8JegKxyհ8uMUQmӇg;v>;/v<$SKaT+W?a\B FR ziwӣF|ѽW>*CIB*0R#Qÿ@y'Q5mۯJ4g[yy #U{*"Օާ'kku#,й7ތ~=+ЧhFϥ觇XIAsNz֫iJt*MBEK-"e`202G\ЬÖԍ?~i&$;d*t#0%`^Xbg/VWsW"U]m?{h0Eylɖn06N8q:xNI*iݾ?;|a&;Gy=umߩ֧Ud/U0$"'vy<䌏5ʽ6#N[[ǜ v6r}n+x\X|cfGJL(EX@NiF2r序ϡe`x]_ԥ~[jRnVyz=~iG4JrR5̬JZ',r0A=N<ꎧԫ,C匏z/~IZD\U~xZ)N#8<%YXߙUm/RIs̄o ԝzK)FmN슭h<Ս?xaFHa9_WJiizI3l2,j1 YkEké*rдӧvIz|\egc,_VFrz$_SukTXMZp68p; ޸5+IZȒEcsGz,K8_NF7yqrO1޸qLΤdZ96fIJ ~FsҼ]=pB.M3EK{f*C49g^.:RU.ֈtnތsac*ʧW֩JRjW|E9h{nflnF $!t*pK=ͬT}u]wGyT*|ܻ ^NrmP0eo~z?J#;_ogX]nI+:*.YZ7tJ#0Tبw;s"HuՎ ]MqBNH2'eԄ]j1Tf}z-EW+&?+F`ZP.XCMNӧs [ ",ю:iV<9#g5*xyYt}l4 ,0+$l[;gth |e$n^V|ѭt= NR]m Mo ydy!NpRij' 蹵lT[[I$I)F-^z5q~O T?$Uwʎ%?1*ydt&VQ:u]rX [1>cʷCʹO)6G?gimWT1yvبwmzNxITI:r۸ł*,JLPrF=FάY_O֩FVQjwXXrNd&%CZJL装jF]uam f41Jn2T S'n#f:JM᎜=am,0]NZ;(y$ISmߩTʵ7˦h&W#ۻ֓V4Q.kt909`JK{I?Tj~L|p u"uJ֭i{lIM򂪪1a?یTԦtw4[b'&YCH]0~4y2u= ӔJwHH#p:Ó[֧NQl]H)NjVbf[rKvO*|rWKCaG]+#nXhڻp{}pzөRu,mVe;~I$$e44 >i،*q^9Qpv9eovkfIE`3gWZY/7ȂKvv|VqTԽK7ciQb#I2Hzq]} )ʬ`R-y.l3̊ǒlϿJ#){H9|yK$IilȻYX /'z{ڴu%gZR4kN2b,іlX2qe5K9gЯh«#*Mɓ%A}z~8#N+|C2tmMmfGTbHai+F:Bf9^@ ŀ5?RptLC_co+I`L{qׯNi3斄cTJVO8mN|CG}cÒh7q9<z?sn=8x'f[RTimKV]p2<|޶Xzݥ}s5DҴf a;y9 v VQPr˚QHAoLJY14̮b^;dT,yQogMcA֓of4xǸUtP'ף}~‹e.%Ŗ2/^9TRkxѩ(I/'w|nsI?b9Ҽ0r\/֍cnxU[kxB~}@ z38F8aib䥩_=g=αKObB@^vkIɥͩS=6~GZB~''ҿ6' l|tW([-WDViA?gWW TyE6uef+&~5'F))Ay~(zu)cȳaH c y~Ǔ=O_CTN)6mwcԿeoZ%ݾ>'$*FЮ2N83q~yZ}c)Jmmix;]!Vbcd#?#?#3N>65no^xV RHg?RXg# 5W$֭{(Z3c="V++|Sڿ=ͲjvP[^giTv][N>w1J4MY8*QۧH_btq¬ܪ8nzz xnYS[y0m6v՝8Syvpqd^ЗvL#$2| %2noRH2I2[i哸0y^p{uJM~G6"]FX`i$b R>QȬӥiIݿ}OFc}=XԧQI$ջ_xSPidBy2Py r}J(#GZ_W%{5䄰[xr0'at.QJ9Nfo[L+1s9gh $;cfqМuOhOOܱD'2v(ej+ԍ_t-?SJ;+nc衇}昌G+JfY6 '5coR#F>^WBM4AZHSxn n?NT\ū] *z}؆(05Ҫ(IF ?LLeN4o=(ҜbuDRAE6ʨەqPxdy{]lTVwwBSN4L .8*G< wQO|S#}~d +*s+IFWܦ6[U}ʘkYSmGN5qa$GvDz}{u΢S n[fb#KqϭtQ*"ֶmRjqteЦ=Yy\3yN^=0Ug;7̜8mm8"h⽕c,{ıV4AӒ}ݻ\J ̎eW.dL1`y!I:z{8ҾgyEzI71ӏǯҷBisN8^_zZɐ&-'4dمH+[W^D:["aX^sZxH* 74AE`o.>vƠgۏW-:e6#Jx{GF*/YA,\llpq[G%'g4o.ޥ-֢J0ߠf_r;w*0j37pq4NgW Bqi~\t9:8{ivlG4P|7uQFl?J1>*0iw}|ɞ+Tc](ԩw'fG [Zwn]@s=;b5lsG2wORhĄr\sci8Ztp7Ka!ac#dHEX< {^yrJ[jWb[[ $gX)9K:eZ Ubq*2".fnW)Σ-ב!hvEYOӷ%RV98;t'[D͎ߊ甥e M:U/OBΗHvUBjʪ 䓱ldag[촻72ݵK*.쎤{\ЬV&2Yyu6ێ}so 5)sATKVXm4ye-d p-u&3R^I-gp>|#|gUT_8wOY;/t@&ݾa媂 \^(7=8TOHa:>E= ]lPgBパs]W/2v1uau!n ,ۗn0?Tju%.j?C忘,lk4Jv2O8jPF #OYk)*ǟ/1s_0am|s*U|1l>O7&ߗ(;V2#3=+Xԗ;IfKoH՘d広z~LT0c<ܼ6@=4vԘ.K¦gۖBwmwƪ.,% *=}1XSVW٨S̯wCp嫱\ g8+IreEBΙa|ی)cwa~ԩQi%S8I] @&YOO%RQW4B2FKq{q#yA2&+wp3xєeN`9QBJ7z ntל=pUR)E)FQh$n{X['_#1=|<a 쌡-]?)ǗKG3_-88~0yT\eVæeUe#zWEF.eOr7oW?A\Ha*!'_隨ӋfXzxw]I {yϧOΪN\,am֥0yTkjsn%z|֝n$OnpmҿnE?g>FTol|uJiV:[]9uy^ђO2;sr۵])KnנTy K߳#E]͝Afuѝ}*=$&?&36lLc'㿟BkS==67 2+2$}#>ʵsWzw&#ii')>NpyL亜ҕȰG;b$Y]hA̽N<n+8+TK{$w xW'6Ms%"I6q2 YF6I!($ėv[K2y,·qoP?6[F[\v,Fmӱ}+i;Jսm ȯekۉb0=kQަ0r}6rgkB67_Zx)nqd0˘]̙>ό%)GRjyVXM9[qTl")k{x?vw}Qr{~NEAN 8*%xQ|XǧgHLm&-H$`qN+*~*r~OYIB pVEJqF=r0 R[5vQ:ʴpۖ+g¹!O6GZTM8rG#C,[ݕ _\9}+.Xd+w,,\wv|A?L݌bvtsIK ?JsFѶ.>⬶,hNXt8f(SIS:qMi0#m >Smy7۠#u/HP'a;rS~rԝs^[bGbt,G )= +]Aj|nUoFR5Խa,w7l1JTrcҪ4eƍjXdѫf?lf>b3cs>קѤu*Rsr^|2'HW5s\nI| &?i'$瞙N59\%:!18q٭9cۥ^6 .1Cz(YEnU%$,i8sߓ~J[Y)FSǖgUS>]JxB98A%ʶ)ShV,>U” BRhh"h]RcX\H7kj"67 *8)AVam~Yx\^ޢ̧RNPe)J/A?{H# d īXKdre;33n}irZ ^+ə' O٣ .me>J_6SĂfV6~}q9N:E(Dms}`MEIouӧ9mrqy\m3;٢wID23$o`4ccψRpx 9S{iNR* qU*\n]mlu8FqV%Rz1&䖓J+ucFdI$/"真OƅOVn47bս̉y;*!YvrzQTwQœ'f,;FecȌ(<>8CZ8GaJݼ9PM1*ۛi\)J4"$73sQ]rQ.ᭋR #_k8ZNR=w/ZŔ f`w#Z[иU!fbm~c㜓;ZVqYӝ쌱Te,\~x?%%)]-c쭿rWa?Fױ;¾dK,ynS8W#Tty~q7k"<*Ɇ~2xjuZ -21zG'?҈ŨfylݒzU$uh1˸]̯nXv$~>r)\$f,Fs ~ujM˖7O- ,8=k7h撏'ùk0/X^٧+9^n$q S\3.v<}+HF2|Znۦqׯo;9J3chTr #:ӽcȺETb@voPY U#$.mcefX|d{l9v[4a];I$z)r2^Nf} r ~&MhHjХ2 sS/^ƖU0I,z2=z\NsZ&R%[d\>ZW|\ͥb Y&V'9zH=2HX,rqiNZ$(E|/QR݌s8b.뗕{{)dG^:3qb\&ᵚ6coGZKrIoԭun#[V19?2ViZ-jB${q$_4c'Vm:EwizSy}Sg]m[fFʽIҜZm挣@blqJ\ܶ*>Xّ1./,?/|sSut͜c[Ok㍣屒 ӓErJީRR AL( FB'~^4>(Mܧ 1_F4+ݽX⢢-Ysݵz\~J|,}w0~uggUu۰hɷة'ʰM>I1tEq62F8nsyb+HM?u}yC23HB،@CoFZq(] _G\ҦEREk}D{&yei*3@ڹa'̬(JSnX)nL{(# c4B(45ͱ,ѬyI _ٶQ \#.o^Ҟk,L c/ }k}۽mTq"Y*(9Xvyw8Ӎ v}z Ċ;.Uc1]|%$rϴ9l<g)F:tBrĢ5,X09cӃr`q[ -4qױjym'[ t󣕙YJosΤ-#/mS? KnaoeR5jt]PTszhؙەߊeknl=?^k?u<{2Ʌd-8>)ąnmo" F;ccgumf_~]?-[x]fD%n>wh:Z1^iЊ-sZneln08[J+>Vهg9'>ߕo]}HF%׭Ayy+i)_nVe<ϡchh~UV۷ ܒ;ֶwR:[)j;Whab8EbOn9e_3J6&" enUdgN rPMmBͻe##򩏶oFqkt}ȵ6{cY`MJ#9gV]9-=~Ɣ߹ }w%U1}lrԔRWV M6 =}Fᮝ>ԾdnުXpv}zUICx+=Ӓv_^Ye;fV]9޳~P6/;infat 0Y$71Čd=Rck\̡[ƢhlqT_;©eUTkM}EE2ܯ4@ ?Zԭ){Z=:աN:تFV]+I=۵I-J=hgʪ:iu-AvdӻFTU3mŎ@sN1PKWXSR[>ZhR1LLXg<;cj眽trnyR..I!w+~  ꮚs-8}5IBo)pHEaR"cyﶄ62C y,)$/AqEG)9OOT4 @Wsce~}OW J:V]_az̑ʋ~o6[N:`c֧I'j#N՜#)is"&Ȍtaj22v_ Nj䢧$odJd.#>ZB*4k9CX='߹^ Wm<0SmEUI( x2E?~%'E_fF$JDsTa|5J>K$Ih;d\g##5N3/~y\[΁~Gtq ub֖~l<`[vY$*S<+,EjNRZk#S#z3!ShksGZ[)ENvVuhJګ/CnsЄm,nu^h䰺݁(NrXc3\^kRo^n8r<oN3:mrn^[]4$R/#_/n6Xˮy9St⥵pocgu}alrI'`1l۳RYMswOjB!~5G(ST.,SJ|v&s'ڳg{8֊Tv 4$_.W;͖{|y89:rET8zս;M &N,2#9xeZQyub"zߥWtp\hYZFvqqv:c:t!x&U^luv\cr4R'dUcᛟnMRvPw!-! r2שj5EGϏj8V24qK_b5YP}B!l$O1%KC^hRv,*;=1YԴBt1ˉ/_rqޱ*R D-8G?ְNw,Pc߯ZwcSj"He??;CW=Oz6nȨKKH\.Xu>VWa:\l\yL.?+-Tt.eȣ&cHVg۸|۶aRnڲIW3:~dYܤ|8!r1ֳũ9K٨3"N_ʹ*rjeiT*.H+;7+;lEJrء*dm8riD7ʺs[37oXJLrEV6*ghJ\!/CN\ɫ?ľhݝ[fm  &TjZɭ0hXdV- ==yx7o1_jmE1/ ֱ*ϻV=}+^ʝվRvO%dul9aR?1ψʶ3V'-Ίɵs1Ӑ 9Ԅ#'gvZW:GpK Y.ߨ#*OS,D1Qp֖1#(.+Hcg#"NMYE⹤ӍnycSht{FTQSm;>7;3 QViװ3F^Wv %)TNf}VzzyG,s#^,j~~?Sq[^Z)D V5la<|+(~SPO$sڹ֟//TzvkZK@5ݴSGq~pe9O(G$ YDylޕUmnJjo{%nFդ-C!}9`+kU{a%ԒBs=A؊wEJ2 &FVpV{FMi@.3z>AdsH1m[9UNjTէ8r}gEp̧i NyҺNgֻyUw˗O2A$d[Ow覣f],g};! ~V5Wj\"&,pʇ$uy=y3D},mw-Hɼa̧ AsTq[/'V lņDWNGN3E8THK6Kt ovpr8yYb5Կ2Hw=rj';R$1z}lq޸];*n;܅㓃 }w/CY[#`LH$"Z-s)T&v#&g>h*PVdhBմܒ6lrBγ.JzLug4f X?+)RU&џ},).*H܍G5κr~ʣx3 \3rTc{z֗4H6d'挖gñ#8R_{R+f.&;[0y-揙.fCBqF*rPȩZNu4h'yUҜ&~C|dn[^_+dH|6N2W*:sMr.3OFUQ讥34k+m}kHMb\A-pɹr(#ۜMTvcRe%nH[Ge%'dj.,z|[!P7.G\yu.sVסM6Z0FE Tɍ` zgҸjS[]<5qNR6-ա Fp+8J}Ɲbna;m| )99r4gdջ?c3mV__z痳.{t(K=gR21>_tՑ$Z޿'VEbT=g)7hqNOY!b $RNg[O^tb}uh$7Pge{Z2T[ag{Gx UJ^Ӝw>ir94cFPMy2ǖҬWʻ Ǔ|1IR*7џDF6#uxl,jKru%-HČFֺMu+O R=H'uH>eܨ0iFTwM<>GNȽn,%.z2h!nwx3JU~饧jJv J4lhǖv6,xh˓Vպz)'=WS9Q\KmU]~kmm۰v}*F1ty\*ҩ(K[v6tZ+)vn**r-{>,$jWttjgOnR3JjF7&uiƝyu&y&8[pcdvTԨ!{*8Rlk{5 yrIAUqo)_q̒e,̧gSp9;IMKD-{;j4, ]]ɞOOsqim~G,h'&yu/*"JKaQ園RrI[~|ɽ[ St{>"lpʼ56ػmohKy[*^}IVf5c)]i? Y,+6O4-~g"Oo~ui@/WQoSj4mp,ۈ9(SB(*-l[g+Jᱻp SW3L#^ŷ* G?1S4_2yI?iȎXv,=YʧùJu(KO2խSE]w1ӟ5]S.f[B_-EPǪg׏AR&O57hGnHrJSy+Pԍ)%{+ߡsv-TџxT~cz4uRcZI".e0Q>dc*9j^\<*sk3$y| |=9QVWs-/;32p筿֖al#`:ӎ8*<ulD#G4ˍgVѮ$9R8J4 ^%2UGMȷ7 S~la'YC˭Zu{Vlex)InY.T2&DUfi1שGݾȗ>ݫ{=*~V2;̵  RK?s^mISN]>E&O:E_B;כ%k@!wDʠ?OJ捑jFRri;BٙJ>:c~#7[Qz$]]7ɍFfnֹSG$ce-fmہgy]IF*ś;GXOk3K j:LaeR6py8?s:1Z9M{Hvc?ʹ:+ݭ=u1/AC/DN>R39AIT.< IlMxTpt0nlaSlF^pqⰵ9jSzb6irɍf bjybV^WO3&h!V=+JJTV4I;;mi Yv],Lu3}'X#<~cF{vSRO-*jZ.dmDfw(1`kE+TZ#*WR2eb~Uf>F5_{tqU}73Kt7 9r/sp%|Kҏea`d\)і)E-qI)lFeeY`yէ,iֵ'b߆G:CYeYJ s˱2s15)ߏn-CwmGܴ; L0ٞ#jI+s*XwקcZ@4ic<2DIQ}<뚤9> Z=Nn<%lC5yy%R[~_SەzuݭקpmoQ O0A8x v`1^Sr_ [?=OV.vWK_ wObv9HJcyxc؎יqN>>?OPyMB~`Z ?^N0тO_ȱk=}[ve$2a̹^s֋[KiRskF=a_(}Eކ[M#_26s=qa0qԬןjy~WZ;>}v\]ymKOӣU1`QЌS=r]Ge٣y0[]Xqr=r=}FC2Tsiv{ JOC1T%aC`#CӭN Rm+]vY%۽<SB&վubLapƾBWhӕmrGM1]ڳG"Tb0xr3^3#gg-j+; rJ#'YzmJWitʍ9oO_3d]>%I]>1;#r?|5z2~_׹ԧNbܵZ=HamDE+e8.)J5#w(gk$Z;w$JNOԎ;V5)qUsF*K^,n$upʞz.nKmoԚXz)b-7!o"݌.CL'(/F|:Sxfg=R{h$W%v fdX˵,wqֹ㇍iY76痽mmĶ"̱VC3QJQopƣUym2kXog;FYhG_޻w(GnM0tR7Z~dFwm1H=3ךOEU%|+ϹbF`юֳOԍϱye\[Y,o ݉p6ke|6Rfݭؕ)cWtC"H+kGN*OF Vh9s1FHU+1 gzҞռw%OoƮ`MQO}^u ͳù|"^@#Qvk4xz~Oo*1<6&hXW+K3"5+$ȧڣ[&%kڔ v}/G_9 J")55}ouiʛMq]1$Ryc]tO(療7ԝ)L*ř~lrI0+j+s+]С.Y7]UB ,[z{ֱGy*i|͖vݞsЏR zWmLR=իVZi ܱhK;A o1[;`?Ҹ"QEGT]>m|hZD$#,z\ۢV^N.i`\C呺{ҭN2w*5-SRI7Y.m[kSvF8cR7OoĹT;\i21o/ƑOR-FKا{N-m[ 9csOz\^םo͢![[}˘WbTf޾F|%hȚ/-)7mVk*U%%MbiW=ԛN|ĺ@eT>b;{דXTQ,ӱPK /'/[h&~lǹy*jNeiTA$ 3IY0L,H#)T̹NJm5懈(5N ā}L!vyzbzTr  v畏 N9Nݮm*u/{hGE㸴3c*S+tJ^ޛ-dQ8~}?N8V0JpmમsN=Q-{RITӏNeFW]wT(߹콬ԟ˱p`*1nfl%ϧJtJZXZQ֚c̛WUe;}TӺ&k J>f ۷d2^>m[mAJRyc)]Bp1TO}ey{\A*MuT}ye*f2;yQmE]r Jҟ-9򷹔!R `̑㸷C{ {4|![)7b5meG?Vmԧ:=9 iCfجwd\tU=t9uOO1v3k6<1:F+:8ak)Dg]3q<־JJ\oݮb̪_1 ';ҟ;ZvomI [Z)QsbQ4ˣ +10Lw9#i¤^ZI˙mʌЮB͆nSBtcwiAbn8ICs,[Teef\^r(k0PF\mAqkc(ٽB<Ҋtđ=.nzg+NYs~Vki{{-cXC|ϻp9ު#˹if̛>-FyRvƗ`̪B<u|qL5e1p@'~-NtjJ%sX%qm@ϵrU/-c*ӽkMt&ȎSJv{ױEOgsS% Iۥn^Yc؛J6n=}c|6GTwzQV}tOlcc zs :ck7(5*ɧ@ðIyj)RJKȞ }UUn-߅hr9S%V"_* v a^VT%U9""RFVF Io:ue)rIn2]?>f UA983[Vcʫ%!)OnX$ɂf:2B׷Kfg*e5A-o'"a'/ ϯZҥӆ83մ}=E4hW&H קu9ceF(ǒQlt- pY{U[=0+Jnx7rGQ5}:i`I2́y s>~I$:rrԻV!r{u#)J$l j=wv dnY~85c ӏ"D[r* px֫rM>[Ztl-${ߨ֝/UM$FzI-;Ɛ,QdS~U}J1u#<İG6m~*XJ K,1[VVc杲@3s^q<忟BFד!WPR7:֫-Z,ƹH[T$Jr-Rp:^' Rv}vGSo"ɸ/#ۮ>4FT-(9.-̋ ǐ0yxOFvcOy+mGi~4k0M x1V#R+ԅ';&o.ݛ Upp99HcxԕZ|hb3׊Tm{:0hhC)etQ]RnkȎEH!$y?|Ю?i{ԕIKk=Ed\/4ս:XͭU5tx&gV*7ӭzVMnc4KH]<6llxFW1Q*+ssFkX+y"%qx$dg\qvkR*$}ִtr#e⠜ruF!+_5ܺ;IR"[o[z&ͽqZҁ┮U㟮>q~a˚2q8n/ݽwϗ'~uz#8Ɵ5 .Ya8?Jki)S+ǩb#wiCn%#瞾{Gʣ.eܳ9Pp o33߯OZ(aҗ4|jfQ- 9$t !,gxc(r3wU !ՆGS9h3乵{~#%;وq=F?K-.^1n aAiBzQq2)㴷fIIԟZǚRGDF)XGwIO/ySs_VeLipñYJQo&9x8QzZSKqŖsFWvu#׸杹trĭbbBۛ%d<%MktUU_ 4[N2aDY R@?tk'(ӞrLpe_u#Eg/vM\RnJ]7a[t\Od՛TVrM$k38>Bȉ mf,U'=rqZ斦>Û޽Re cֳiG^FGݫ*޹ uyo'!ɶQ Ic7#*%isa/{w+1 <:vަPȇFdʓ]nU#sz崮m eg鸪 Rcٍ_*Yu獪6T珼:&)he*.TѪE$DYL i=SL]Fr{m/'POHݷc<ȭ22EZj' #Bcc!\`喬ҩ6A<_gO\~iE{E8EȜ,Ep,'{g<{>]w&Xz[AZ1o;0I捓fm*g]u[OzSEm;%E0ni*l8zUB<׹!$Us0 0},jc(by}TWO6Xr؍nQ$4jN6D,l }0Oё=1E<63qnr8ަR5vT5o2aZL+( O;:kRiSn̄0oeb_1-*% ǘ|n 8:F2rrE4qڲ7}>OgKV̎f-,Uml˳CbZ1*FK͸F cORwyrў6e݅nďzPF~(C"b"s0YG͜z~uVQz k;>TF(JV3!"2 d0#'֗-Wy-q!;]ƪgTԾrӎ~P2 ->ʡpX`lӂ)Jҏ3dʤط .es]JgdRROFIlco5ԑёjw4aX3ZѫWgA2`޹N\.vHH@al~u".]5#V ŏiE^#>ƢK]6*U)>{(YTщרvDƴ^y`HbbullxWƣ*s}B']7򩼩Cg.Wѭ Rkh< ?w6r:v[rƤre- VE4>`\=?WiMߪ:"Q"91%L5zog&jf2N 8} Q߯4C$l_.2p^Ұ7qBZN~$H$F y\ߊʤv^j)Yeaf*bT^sz0+[ c÷|HpjG\} p_ Y ۬N=:\2}.K$A|`Vrww6beq`X=8銹KE#43N$2Ȱ51S? zg=X{9ɻ5!iO C9GҺ#4y^- |j九*uՊrNx'u1Jn}4[ΦSn[N;dw7p:czJ*+5_BнYݾ<,FH=}+e.W+<][|\y~b5%˕W5'- /aSn~f.nԎvu͘/Ȋ1v3.˜ywI?6Ga泏4vVr֣Zd!FҝV~`(\%#җ*~Ќ+!;1lj#.{]K7{60Dߟ Ju9U*ei+. ;L˻$)S9]nO+YvV IJ;+g%dkG]LpqSV#:dhV(#rw~Q改.Q)KqAĈwy'URSR0؏m[-Gx{iN[c 5ӧCt]xF|1;9l g>mE}!#7oa'uC֥hS\cu !"0+G95՗JZYZy{$e(ҦR۩NCu,(n:޶JVʒ}J7_!XnXjn-w5 n:o%olfQYZsGV*O[[ %יnY-~Vi>a B18;ԽaF8^K9)$K|93֊T0؊ﮤS1#Bs 3c?:駇5Զߡ,DaR-=,qƻ>f9=1u)J4ZoiD:r+/eǧ^.`CX ^<ɲF\9l`gS.I4߻ڬ݆Fz1E?z_4q1pv!`E~\(b:cJJWg*jJj/zkY y#M ;UKm]ǜg*Փ9JRWk3n wӧO\֑妮C*5?{+W$Tc],H0OpAFA/|u$Kxa]#׏Sɥ)2۾:ѣEF7Kn%w_m #s8RZ9b)\j$([,q$}_09TRcYyR ĝgg=HӦUw_dm,7Gͷ9FVue˶H#9v7u%''ܰsn*2FA#YǕ[~U#⚕ߕZnvdemzcL~L#ݬZӍC^=Txe9^r398l;ĴҤog3<LGЀNk|oeKI9+'jDk#}Ȼfj0NqŒް.i+o+;oUKiega')ݻ·mm|rH%kaUc @sgֳq+N4I02L]_nqk7+[ t[7j"Ĭ\ 9^]m \d-c>|۶;g#ޔ]5+AT8[zud4HKn$gֱ,^ǖݖe^fٸEmS\̭wנ?-RY-lUݻSm[)5<Vi8ۓzk[X.NȾp+i&㌃{'O߻TUK#6nK29ڀ W<|`u=k'4thPzitrDr皊OCը$W/tdUg4y 9b<#\5HE9#=1xi:M]wgF+{>Ϩ]Iȷvʼm 0v}Xw4O"jSRr_bKTimDhS>_¹}e+vML,iߒ@n(FoOW*wps-H[`ti~~xq\*.Wm NܩYJI7/}jp<ε\TeQ+v-DeURV8ќy^6T>fdI2+8ֺ}ԍ{JId*$?Ag=kogE}""qieyẲ3Euymz*jFdk_BXWZk=u`Lmᕌrc#מn:+ջaqǕ$"eg|3l5*ͷSNv)Ȏq 7^GZsH-œ/1D#y pz=SJ1r*4+~,P,[E"ɖ`;nc׵tkWb#]EybJlps ~:rzƌTFC3)2Qճ۞k<4}oi-Vi1KV?-d$?25$jӕJZ꿭Z/}˚}6n<<֋8utI#6I$y>+백ԏBjnMmyjmm=`09=Ooz/{cJZ }n>zyythžfU* X/nֽ<}4c(Լ$Q2Y[ۂHk֣Kshvы]˖RM(l{9W|dno<׳XxL0}H]ڝ8דw/AƎ7ѳNӔi^3\I}\:瑻8޺)*:72H!nd0y2ى'k5ZJ6hH䙸pyfk-z26?9ۂ>] #z"|2FuiIŖ)a4_6G OΣ>T}CbJ+PsS+^e[Il6$uY7 *ܡ}N1(jJ) FNϦō6+Rv8TIDTRy$:+ff );Sj`;/!F4;ϲncʁOe/ivʧYʚDI,1 (?\m .6}30Ȯn>W,$Ou46;s ss\baɬJe39JW,%$cm`zJcIr@yOp+$O=}V1?'=PAc26*cs\r旼cȞ$~\GCy9;vOR F5kmXd4b%)Ʀܣte62nƤ`{y뭭rJQRFs*2quIFM+jpR}JpۄXW iJ1jԧu%H5*JsN}k4vjJm3o#wX'u8*ŭO"uץu9Ż.[ g`z`W⩪'6GNo2uEQ`* [26\r1׿aҼ_w:qXJ?SMwJy p:eNaK;>rӿsĖocISZ8漴6e魭Fvg G˽Wd9;TsnwU*TU|pyӿ 'cEy{ҥTNh'˭D+UX،`s`Nԧ(s]}y;"~u.^ RE!*ZTjݓKM({Xkv>WQm<۠&rcW Y=|Ѭn"8\'ww*QTӳ paWfBڪ\I۶qNpU!&kwV~I cqNKՓ軘V+GyUě6{گwKEr*GݒZu{{XGq; -6?ßƺ%;u"4؏Y?^q4(IZPy_-NT}oU"[TlSr:yq^S}vhi$[89^y8ȮūrRE"z) Vh>Y([WGyIvmΫGƽ jѿSOԓT2*μ +4Nr[:F`m 8Vє+Y Uvv ֜y٬.Y" I$eW;Hss֎V-GTj:[OB4Sгa1Ly9%IPv3>S,drJ[WxgUxU\G=9ݓUqraZBU׹=kQsJ1i;2#*42w~=2?ȨӚb$[Ikl8;Atf.aI6ɱsz 4:c5+50[T'W,2׹zdAf gj$J$F߸`.'^ǩ5v7\VO/*pnzcox'%)ܴhUVG=i{>j;*S؄;)IU݁5c\ƳR* dX8na#n' zvϥL8 NuO2 dC&K3 ד]n{[bw61Ѹα1R2I&2zF;m9Ͽ\ݜQKhd˯Zn54[ r׾lAg-ʩXpwuUʜS:ZI7=~ZQ$YVCΣySݦױHI8Iٯ&Ii(ú9Di:~?e/kn̞{2vzwfJqd[fy3,lW#$sn0M3e}nL\XcN9}JH3,e;九Jr9bkyAL?z둏lb.hlƛZi[yG/nHD7W<>'ڹ*S:i*Jknfv[*){w<ҫZ2fuգ=ɘ?kӏ(U९-Ǚt6gyurTIs?I9ǖb+6Lže=@?j?u5'JFyvy*YNA8ze"ihλNKv. MְK-:]HGBfD8#6OsojRVdby']AvHĒ6wQR{%uS\F bYx=sߝ-ٞ"^I+c-$Gh+#HW6H8 g4G6-7Rsvz3`x7Hʦ:HRG:z!/Lzyf⪜;SI?s.(uII"neA5' IhJ4~Kv#[{#>K`zV*Ge(#*եY={OVGXaQONW̯byk&IioA5+FkSV<½*sQRһߥ|(ZRY CtΧ2Gd=#QZSb )cUG?Pyt9kSj+ -vHp'qמj~X`QZ= VWkx(1w9)^ѽN՜GN圜<~JQ3oNTkZVRd&]eeۻO\TrT요긤v?>+FJ<.A zg=%Q̒nI]_Klyg)(4Wlβ 3+m x~m EB*qOS6.O+.$yUJSZ1nkm ]Rds̑LqDaӌ/iӡkP2®XnXZg+~x]u}:|xgx9qi#nT.r "XټoFz#j4T)ui[vHH q9 &Lm8ה䝺3:SKz6ON<'kVehzq*F$\y.̅9t9=.歊2W?+3dmE,H}\񓌬T1\+w5"i򙇙o*u9 Zӟ+oc:+m: ʐN$GY#VbHDy/g߹ψ!+-{[IJ2Dr-4U9gOEkt Alݻl}W]6R#UV"yX523G#9ڻ#/{NR0U{zhnn#ںhFHٻ=|oVwO7%u_NW˕艩QJ~Q,gX?.kHnR͡S[ox$c剖Bd\ׯ=: {RuZjqˆ_xpyr\Џ2N_KJ+4͹jy{\pOc+9Kͥ?_szF;h΢-&ݭRE*Qn6#3qU?eGN3:TvLڱćg)^3{/nfݝ ['H|:+:̾w:+Fz6ӦT ͉Hڹf}\:#N* { cpbrԴYof͆SC=+Z+\T_4JVUUo1~9ysCjgNM7oiڬO_j9^0Uܿ. L8:q4]oVDJK1W FAT)FrXFM _11ߞk9+bVlVX(y!bͷu{}+Wb?ɽ\nq$+܌t5RrHpyU;JًSn,ͺc6c,y#u"4zhcٕݔuݼʧ$+Fqqv}c4cn]32FxZ5v)l׃, YF:kc<22yeqּԽ.ݻFu:mlQ- ܸb$c#}v_C?~N]hkE}2z)B4SFeNrP_nLϖ@`29#'p:s[ô՟Uel>ZA3NǨ^0hmMM;_X̕>R()'#GghNI=,j>=^cy5gO¡SθbݕIl,a`t>F6}LeT H>*3rjO7[F%fuϰi<1m+*J7̲8|YԚUֿoJR&ɒ$Q$L1cr'AM|_ 1垯&86uXsUS{ӧNF܂KBV%oyVЂ[T1zA``6cS>KG-1Rv$FQ<|4@8}ڧ-:kԨ*FB6%.)Wv|qE =j|u]?ė-Lg뻣 3onr?»?E\ciRk? ob0;p;`=+ԣǙӎpմ/m ;ul#$zvxSdq_i9I_AL#'?epb=Iz/9$aݻo '}{W-L>F}.gR8]ͧ&9*eiTє(-BM m(y9q)}ښs;+i(-LLf*v1{[Z>}L;4$r_^%ks0Y#1pFx(B wԩK)s'as9XWlM.zcCXӭoG F/waΒ_1~lcr eʜ[]ZrsR$xtU0Hx#W/+ܯcJshWc6Lm:)#\u/i;S>ȠɞI?J~ULd#r>gFRsQ+jr^A?}&KB}3QԨ枋tv-KijJ_ƾq5Gui┩;EDž7[ҩqf?qSZ.FO_ާ93\xE_, p)Б0 s׹+a -=6:=F5kMkC _:pS9cuRu#i+_ϡub"ux=CIup7$ :g<ˇ+]9az6빭Έlff~brG<pxhb*AYeғ>[ěL[+mjСg dy+*t#g=*j_=L !~UCi0pYH9[biNvLka7RGNEtL]dc$8`Wj}4>s0RJ4bgi,[8*xr32,.hyr՜gC:6Hk5&9#`nJ8kw\~sKMheSiK3Ӿ"xUo:fs cAP?3l,⢴`M,mgio o3}kȱxȴЬTysl/'U5˶2FIc}+ҭ[z|Ew;oO0kFxך (Mͭ&M=v>.b(>9˯x=R(l2H FO 7N>Ql?i-.֪/#S⩹T^Vϥf/CFҭ3\ $<Aq8q7l>onfrTX齓hOOGCvz1M|+87>20KMv}sѼGeD%I=?a੅j]_ q6d#'xg(sJuRVCeSz1v浌ceQf>#mÆOVzue>^k F:nZv"_.ti mh"Gb]JK6T̚"p7ɟ:E9;ڛ{咳ˆ> U9dM|=IaDfYvyY2##e:m#5 T"[eeⴧ*+}J۾ՒD6Q)A$8Ͽ֪1wnJǭ*|E?gfʑN[6Ufn8}?5'w o-mvUea~u$dNk-ؘr-=YR4evߗ?]T;◳WZB NmjRrLSA>iTeŒq[Z<74b+En&I5^Ƿ(mFF'Ske /:ߏJ))EB"DtcȒj씫u*~sԌzc5N:Ykn줁6zя3vlA|ww/^ֶKua)Uzw_ʰ\`^'5,YEHWO,p׾]2}nޤTjSQ_ZM|>lt'X¤i%BƣɎ#[F )SUH=3W2rv5#,F#KnMRYZݤP9av<`s09ewNJ:7Q)%}.: хsNGnkUJ>w[t"m{N~tu: U%oG KM pSۆ1䃞n(ߨe)SN}يIѡ]C3?x`?z^rO`(g-WnylE.Ч>e:՛KvWN˩"XK̪ {s5O tbIlcVܬd?$g=1i-iNJhz\z^K(mœ^&c*թ֚M2]5'pqÍSlc\7->_32];'}9˒3ԪR%VTY)C,Syjhn094OԇZT_[O3,sBrUz 늎x5QK@̛6c '%iQW,.3/o1I,Ā7'T2T5ml/,ݦU.ֶc}F5kiܤ]+v0?m][v4^X١I$Eռ{qӡMr* Pyr>Yy_J#SzpP]d"YvNZq|E5qRk0 !=+}sUMya)2]eyIwPs^3ްcO[]aBtNvrdY61={=)ܺu=7#F:1lXUI,9NO{'RV{"W,\"h^#]#FۢdޱB ՚SQJM%׿KoܪIO>NTeN}9?(@w3om?>e.fi*[_݊NCQxjʪ] |j龺YHUVVbϿGQQӋ}^bCe;vM"~cs\֯%ɋZ݈m wv' NhͶ)V嬥++$eEV_;mޣͣFG3cA9.Y6YTN/Ṋ7F5*+WS3ѽ}}~..df3`Ӹk.nks-Ⓙ69&eVa2Aj%ͼlD=$O\)LG.դiק;ib%ztw3oeG-Qkcc6L01ڮ48N3U8'Zamqr#-X|=kK izQya뉖)o2'ndSIwUهUE98ɨj-ڰYxV?ΝxIJԩ*I^h%A[B2cc%:>dtZ8|EI$~+G< aհW[FI78yBR[v +LwHПc*2FEiaK46%p {ԥnJ51_4ᦍ]4aO ⶧MF _,=H[Iff  'I?_j6v%IY[B2aȒ?.8O,cLb}N\M*zAbxdsZԌ.HvU/eET~ИT'sy UC-f͹HT^֦WIN\?[=jN6{ iSLeuU/ Xټ}x;VChIh}z 7wLtcZ䢒̹EǖRI KZBvON}3TOG޺&2yjLV|ߞ߭D0+٧:W\mSw4wA,YX6pT-O?68a6G{og+Ơӌ?Fr9N\Z-DyV܍cr弍=agtZ϶O/_+ OO֔ULV%NyM K,kϯA7~M)I. XI Ur ǷК_6p H0cuGW*II-VCwc wS3VQwbey6ÂpIڦJ.uQKYu}ɔҫ[goϵsrZDg(.Nd1[퍉cߊR՞t7!'ydYL:l`Qa9pj[۫^Colf*@(파c N)؊#W]R'VVM|PsRO %7%«=đ/Wʌ9,b}51*gЊ[+t N]RpK WAO4Mau2w brQzbqWg aN5=X[v{Ph=xR>VTSc[M!d)X:px*teΥ/cT[ndqo3甡eV9*OZ*4_3{_CXtt/5u(ȬۥdjE<*R1piwk 2G6,v##]4C){j M4FY9G̹ njv1l4`Hsb~WKrfZ֥I@mq51˕#sA`~9ZOEA37*~tǗޒ+aGFHFW.2v#V[=%EIiv]QNX)1#(jf '߮2+8\++=,F`nʷiw$WkhC?جwssSOM 2rq|ҖV|lU ) "g$:LΤwbOX/wϧ4EkvU9sTЇd<\3FvAN2IBmfC*ܰlpN:QCr^C0UcHſBFbDn>h \еT n+pwjmiOB;ł(417@;CN2r)ʵ}I3!ܬ'>1mu! H7ǦN)Tb$6)7n|c~R13uC#Ud ݽ)y9STw+K,i:}FNrrϥCo D, #V~r% w"رw}e)N6#QEYciӆTJl~~JQMn]DmSy2h~fVڮ = ~+9icQ* V66ńlO5Gy2y9k̿2\$1XJ6֣$^8#MпW!݆TdQ֢1et)6|ª6Ƹֹ/wrJh#6F+8+[aޯK% s09<Ⱪ $ʏ,mmAa2;G2jrVQ4IQp".qo_~rYYƤ*Fj5&)Wg˻/#9< іѕhc\ J6FF9ba&ȩT+c+},$ׯ_J"ޚ~떈#UYa#nzB3ӽkVZN*䷊YXwd pƝn7[~֩KM#j1謹/,X7njiIw\B0f8#%bgkvU%+FZ/ijhfgy6㷯+ТmJOylN'H˻- kHӗ5%٢l`Efqֺ cJrV"EV]ȼg|V\Lr沋 ;KґssӄRl\jCe,*n+7$zqckKsE6咚M7+#U;sq{~餝IGz ae?7_OKW#'fA-P˞gwQ?1)O&Cq#ąvN-3?e̲HcoT,O9~/g2(EpZ)F[ssӚ,AN^}5ʦ_>6Hm+|:WZDc;8mھEfQ{Ӵe1/̎BncgIT۔𴺗ԃwms,t(r憣vؚuG4,*8?kӿs4=oT|J:|1=ziML#Yr8Ͻe/isF6IhQC?Dg%w;3Bre 瞿v挤ӹTtm~rv9T.^kɹUvGqZ˖TK/[Gs?fuc-"7\X)ӻgԚKT[Fn#^ǥ)D1Z+"4 ~85q6ӌilRLssǚ\2o}Z[[ǵxd^[9>TsA=~hʸ ev"%~^};dը1x h\,opq:a)ԊU-$yvрq99jά`Nf/̮p ܪ8y{t2)y_1*yl8T^E8Vldrc(.ybϽf^~>GɜMpToerj%]cGЌmϞb;0VՄ3^Y]l1HfY5)NHG~1cXQp`\Ҍ"Q["93y$9;8|71I#+f9''Qq|7R p<ڱq_é4'mb2ͺEl7C\iud9ENdQpM+!Xd/sڲRM??}~ӶKN0N=x玟^9FQYc(EJӨ1Y4tv yӗsjt*0$؎FuBOj攴vysIǭ!%6FW XI\Z4t#H)7mQflJ^]P*đ\ V}E`)d ȹ^zqQ8giǕ[dF/-bv1?>Ylm?(RchGkr]o 洫0mSwSIܒ)lmy>.[ˡe좔Uda+6?=HTi`YI W݉;*F:ocn[BU!Wz%*v+s}1s\ԹJX~[_tQv=;v]p{jQ_W-]ʍ8<\:Te̝&I?%֕QV\O>؛Rσ є[{;QMʷ<,Ѷ$swzc ]ӋvvlӖ7mR{"E$6av.:ZT}\)^X?umsLX8QښkpY#YY Q><}wuu+ jY'h~-qo^.2q'Q*u=o*U(ԋ&$MnFeN:xn_wwhtT< 29b8ԍNsM$sfܰ ATS%&LFwLhl[𫎑]wZ+2qT̎5W1=]P>T:Чe+jmMxR:xZ{h\zὋv!ٌvyKU ?ּQ]LRK!F`R'Gj#N44q kI2u8$*6XgN=~!w$WP6y |0yr9%HTԗ,|ק_N1Zyu׼2J*Ѭ߼UC HWm8fPO7gK&4'sXWJ/d~wKH[i>N: p1J 19:u+s9|^j3Ek+ibjTTiyth@O8pbN}럚Gwӡd{iaWDѐvޫҥ*SEԱjP;2D 緰S'= Vwk!7r;Fy]Lzp8DiJ_5iѣ ;edvߜcsSR=QZI[mI2йqsNjIG5Lv𝍴µҔ,53{PS^CezTa9z[C2YwcnH=񏯷}La*Ȑz|}9 gF9:ӕJբ⌧[KmʸV-.n̎G_HӣNDTR/x,=r![N?#Xa+KѴ-\Da%+[ܘyG|yl#ҹv%*kW2q`Y$q =w޹=m.qEJ~_Lo/Mʴpp8@^:qͩǚW3]@2$)+$f;cϯ5aPSBQr)3ns+TC2ːZK{%\cZ=zSKd1 N|㞜wZ KH$siKY.H%VF*@-9'#kͿgvi xl[ٛOɝ͔T=jN9Z0*;QVV[ˏnm9==S\U*FhuB\ַw$nHy,urkf%$gZHޚV7 >38Ty=N?j,2$F̾gܮx<3iMI+j؊twd!/ ($3nV6 E*n>EW}[~[xUcf=wO~H:L G:vwؐZI$d3ҲJZ(O쫩Tw,p=Ǚ˜pp=Q/r-2UӿaǶaܟ7On+`)Պ3M#^JfՂA$ ˻'N? mY788tZi7$dm۶szfLE&nKu)#i<QxGVօKƾrU-f"GR;TABXgnK8*q^Y\ي=Ei8.Um5g,:fmt.$6б\y+|NFG|qֹԕI{;y[= ӡ oBiC4a*zUuܔR{99M?=M c\iWΐIw ׽5g}X:~.mڽ#tț|݈Wc0AJmqiz$.CDs^/gc ^Ri_тe?ø>׽F2sѧ.X/6ߵc4c|)㏕W5sE'jhdux*UOgiJRFnv/L9^}Oz}֝}y^S,ʊʻ9bc.Y{J̳4IljmI5SzT2؊hH.}8J2+3UȻ>c+ {ZW71Ṫm͍̹?oI8ob6e֜+=E 7_׊RRW//a*7  ǟC:܊rԳ Hy 3z2|C~NZ)-/Q0m~@X|s'm{";|@ƪS?ƴo~Hn\mS!Ty&J`8;?x)_IY{E{~f' 5Q[ĕu8,&_1mo;NF885~覣ʤO4ȅ?C)-}e{y&$~:e)uf5,LllrDۙb;jRg{K݈D_.  ^R1ktІ8cm6?jU.hŴqnv]?*ƬgJձJr"iGNՄ;yԿĖxke J:zs\I~n8dEі>?ָ/zfemN?Qν:lGN~+E{X&  OZ1tT|e*uvTʨ;*q{=8-ת:kGNvɚE6Կrw Ju$ND_MEOG^EcVkO Ҷ䑋d=\~ɹ|E89⪥8ք•yF% Uqqx.Q`zNzfztғ5VwV̳Vue>m1ߟJe"D'R/f|ItEHqR&qGaOՏuŽTW,˹Ҥ6+>UeRp;a)ũ%ihÜ*2PZ]W/-qu npg 2G>S|OO/굷Hʦ8.$e @q*wzjQ\kwe%g;"va1x=Z)BwV٦5%+ޘ-U7DUB.n?/{Zu%.|ԧ)jtv mEfl3~9F)Ӕ\Y[!o&dbg+a8XTw4T A^JQNu4l\7[p($gkՍ=nF~` vrbvOoֻfn.T-*s矡E{tҗTZ6Y?#We/S0_q5ʻr) pH8J,7Rei/pY啼fߛi\A޺ K^e:嶤7*ډ!gΪ.1R,f$W9U'?tB1VFykGM3ϻA#)(Xu);s[BF].t+g'+B\FY$_,|9U)VQn\' X٣Z s$lޛRjđ3˹e~f&0xW=JqOC;rw,Am|| s8bQJ>NL12"aG ~}i*wq%S GYu&rԮ-vdNskue8V<*5JjOCR|3"FҠmqEKv'u(A Щf =wrԈ2WXYVEb7d6p>_~U*Tʑp,7."a=JNji.^HVrl%gŰrHz+ʜ`GRWIIlbLo8{"weil+\P3{zqWF2S*q+|!R@OʭQU#Yd1>͛p1QΩFH ^PM\8ƫfB;=;UCq.0O͞cZ,ݙPhʟF G$`I'9~T*u<3Z5Ŝʪ$d0:+9sFXzҿ5v˙~]'@czUTyy5{v}.g?(k^hZ:VZowȋBed 1Rwdcc1 1]Kzk/z!Ӱ$OڔO.<݁y{HꑛB> :6(ٳZrfVXoV oĝں;JgMȎA>Dg$zTUSE={cהc Qz˱φc8mX 7̭km.S1Wi^Z-m+YSF54w զی=1[Kn1 us)X,#R9clH>*1RNkv6޹/RɜTFվe8cE\\#HRm:]rGyN?kT9[jrʌ:.Gaiƥh%_RmEsO9?mMESr`G+k%k]9Yd8$H=: ΤfWQB2w~-Gp)P>jӹS /ٳsGxDOu*HK'qwO֝GN0N SkO#jIY&XTrxQ /nTcݻy[{nc?LzcV^7L(Qv-E,kq^ <{>kΒ)JܢCqu qfbFON^g=ԡQ Yef~~TQJKfҡUE]Y=+KPHp^ʵ"MީhHof;6//h$t#֪0*iYxe)$FYڳqUi3׿*1.qЭM־V1a$\|+yE=Qu2N64Pϕ͆9\nVJQ3_-09Cӓ\J7=RWo] ďs+;0*pǰ&[f$)ʹJrB AJm- HѫU \o sY0*{օoḶ8<?aETyf+JC,m=}i)GU.uU}4d:u䜴EƚNG;xy*+x+-fד^3/f=5{GϺaZgWfsH?k)^r5irJ݌^"߻,>)N59R5I^Qo#>ay# zTiI)7/3%)k^$ˑUE*N0WБJMwDCnZrMG+8o~̷LHv>lBU"mSS=e3& M60 '*Ѧ}EYWlWR-ʑ3q+ǝ>}iԻZ#Rӝzyˮʜf-9+Z7.`s^6#NMG"1έo1ƌmu%3o1fچ'%6. !G7%a`y^vIlke~M2" ;v* YSǖzܺU].U.}cޭR<[O K!c$MiM$d;OηcOVy*F58uԙ#RWlh_~ї2:c)Tmor{C~67;xa^}]-],yӫNT*|Vl $[4>4(F:ɡ(ʋR[<UN>VYcjjKn!%UGJΖs>gbՌ{hnb.w/;p1Nb8#Aih/8=pqG])qqki6c]@]EIߊh཭Ni]23+ >Xe=_CKӣ*JGAk[jޛk zW+kF㮍| ] mIym(v1y԰1RSQt}BhTq n:}R[;R 6V7a.c=1ө߷s=(/clTbpTegk4kKUϻЖt!m2.W[7ߕ\)y4'| 9Ǽ?C^3N2Rv"N)z|[gi=;^-|/z/ڟ֧Sz>2^cnm u(6MhG"01 HHSz)~M-s{ MŽ4}2۲59\qiݮրjuFm /LM)J=oҶwNx''?UF/Cj-J)%0]+K_}Cayo}7aŬwݳ`U֩2JyQ#:;o{8=ҝԔb :݂ ך+~KZ>mYSbq61Vq:(ԧn[Нd ->_L8k'ߧJ3\m$ a}gi5&{#)St~Gqc ɻ2>V+o[݋O3Pe3WBxHi6dT? ⺡GVgZR+En1uBXU?Zenw8+T2S|XDymˑXKzBWoȸ“RF#ضp48 :*+aӧzZn$O5_޸~^W*2nml\ɭ߻F J\׊M~DkXelvcȤseP ʑep8_Jt;YJlQ4mp&0ni\qJGB9,7P~%*Tk.X2 nS<˵i/h^jFWN<dᷰ}ynYSoXRs!X 7N}G\fǕg +߰{$&L+nץm% Zz[Hlڴ֔jfT} _^5:6*l>)z8_p(⩮^+gf}քk2yn9\yz|թJ˱_\*⻫9m;_o~FzuN_ks3Ͱ> j%kZ~]/-#4בƧL0] q*+^m7VS澹ǯ_[?+/XCq,yKVjm.pCЎt  k#o&!P[O8,.&V{zuwעz|o _u7 mc)Hd#],s\'%⒂pSNNUkK[s_AJ̊?4xzkE˔OW𥩼{t|三T~S+#0bTh+A)F1:'zzRrhW>RO=?O¹=q1֣(Kex/ZxL*k_9}ðqN;oZu?<pRmߵ'Hm`Vt9c*JOmѧFswd)ay34ulff\9~4:Qni[3Tj} Eno˺A'n+LEe;cw/- "۟}9_e z]2ӡMu:ZqBm.mIN [lY"i!\'x}{Wy}&O>ubZkf"c(0~~6߽{rr{/Sܢ<_~?SK-; 5X 82UuZݷ{XS>ˮOÏ@AjH24L@tx Ci˖*Vkxٖ_ER_-{N|0rY\_m ܪD;Fo3(\>= o+_]Wϗnk gm2g?q_7}jRi~菡4w),I!sb?s)|F҈Fܮ}UO{}pCaB7a4r?i.UJ*1/Eb+ ɴKIK0x>U'u#Bom/C I6]sWSeI^L*b#Mt݅rq)5*pQJG旑i8ߏ-rzMj"˟z Y#iLr0->zg_iIECQO QO89޴JO7# ҖSFL)C!q6qqES%;#XT299L±0s(yWh6{FЫ Ȳq'ng]OZC:xvQ^koi\q-##UʑF F1F'.²1ں4Q6ІFhbL`+<#]m~i+H+n[UR av9l=G,v:º%ny 636K`nkwR\\Q;KI>I2 :(|ޥ֝SzS2\ G9.%>|:P I>WG59QiolDK{ӷN(goތZڜe1t*/b)]VX0Aӥiu}eAަ~DT,:ngÖwcyeIL$`c^_>X-.bSTd]1є|Ȼ 8ǙBH1VX$|ұ]$m<ֵ1I$N ]4NO`WLi{ZM]}Ib{Uk*8« qQsQ.ELS0fX_ՅAM'$~=J9ʎ:_[Zunexv8֔RajYBdk,|6SO9rǖkR[lm,ϜnݑՊM2N (PZv5ytg%IJ^6(30~-m/BέCptnCnV䶨"fox%5FL Q k⣦咑Ό~7#c=yTdkx68UdPI?UcԍchՖY#ub|Su!MXdֱJů'|d{csT^JteMg?*"r5ZO^Y$j0w~UQu{:se/<#}ccޮ4F\ G2[ Wot=I]ӛoVFV5a'̰u `cE.XȪs-ᴩܤ?j%(1Q6Bs3ƪW"Gvd黍?fasyx۪8ߵTMh~#aFduSҴJz uyj6h',I`?7M8ҋ 1拷Z?yBI<75_-M*x~V"fffM$0u揊HS}[]KwɕO9~e!צ}[_~ڤcxwe:Ѻo{/!mpg\7sڟuIl`gapRvQR_,6܁'N54Q]~} -_]4OʧrqxPm4t =4ƱFc;8ƊvSyYH̫?.{S;Z3Gnnv6Bֶn<8Gzz=oKs!-W:[^ҌÙu-vF(Y=#5S7N<;+2+Q F~g\2(:RU@T7L9eƵZ2D[\A ГqJ2wɩJ64ÙkȖI8z[eߵ`\SMqb9WlSsnb2uz5f} ;-B-s;n#?1'5%˶C/U6Ko+?X#TS]We[W;sӒ{qUESI۽3eCF*1 c,?@;w9{ܺRÿ^K[y#fQ&#UFrFѧ.Nd)bUDl:zdv<ҨEIRR>*ϦZ h.d}QT@{g޴yi^RՕWXPlh؆,1zVJsgGnnvxx8'nz՗hitBw 8hG$l2n*젥M&;yRHֲW$ bg.8/>m NZwzv {tMk!-{91N%ZZ8!T]mO$#۽RgcMTe]fuF5e?+*7#qGN⦔cva)эW}8HZF<?uCvF~Nqn]ikkAj ̼3ӿS8N7xjru=RvVx2EUy:Fޭ_5ɝƵXlA׷K&yp`y\c%硆eʗE^[1%$/8r?0w(ǝ7GwEwe]xיFVfFdՖc9,z֜dzYEo4R]~݂xF\_W7Mr-5Hb#' '8NCUz^MI\.#eVOrgF5c+7mA8ouFLi.ou1l\OqWOs]u||ɮ13)G#'*JJw42A%y宻htl l3n/ y VmN=ժEva!fMO.V@K.s¦ҽtFIPMmg(RУ{̙a*nkYDIdtQ°{ *SQw#f)游\ar7W]5ʽMM4 WVde(pylGdkZ_kbh"HcR=rycJT:N[oԴ0;ecyi.^f2#/+062y~>fF߼;ܼDrĭ }'֟4өa%yHRhEi(va[=ήq:9$зl'pwfeYa~qr1{׻fgJvLXwrQt4wm"q=a^Tgs67qz-g'e$D1i6pRrH#xBs)I9$X-ɂy_+61{.id9TI%k\Z,r'ϳ'S?&e{n}qyHc%-зͅ>h9Rj''}Q&YC'_1ߐz׎ymߡ1OÕstaVF\ftKc: ֤^\E% /B +7R{1=Yr$_N:?zOt%JI>TE4Bgnsn}=k.^NVWkNKeX95G=jKμxmye{Z#yd/w{VQ:Yzٮ9&}2b5,10=p:1S%b@'-o'γ7ްqR|"inʛG5z]')>EanVfQ}xDфcN:sFHTyvzOF~IG H>x?:jPmucNRAK;_Do~^Hu" x5˷g89x+uz46Epf犸GgЯ*kx<1@Y|zA9_A㇘eR"ܸ:+%N>XD7ǯ9ru-[>\=|ȓicSj%yK(ߞ$IvkmThM!( b U~`xW4m. ؏"YIߓu){:ב,LS6nڪӌ3(oBv~t:}mO;F24la1Hv(O89ֶѻAZF#ܟ^?ϭEKEvVIb`Bsң)+#m)v)iKK=99ǒ)0iO)X\n[0JO4FKq+L !wb\c5$0]3~zSNQE)pWYTrN9(&U%9]HSDwA+IFȪӕNF%8_^{J+r/$5b\ İ Ò~zQxFu%;-4>UVk2m8?ZϚ2݅({Ȓ U~ʼr=;+kQz'Z Qd_\u?ʦr.|Ж'O1f2ReUlsS Y%.Wrk9F;!~ގdCl$JbN'*kVCLm #)6WUZ#ZͷC.Cs@~(*2^v\*EVPY\w5e[+Dz?ܩ]y`TՋ׶A>v~e#NRB=Zt2"9?jydF2zjByR/jfn 1;;xHs$Rt3^;)jB&V1ߑJ>Zu#gmJ]u3 |n%llc?^mqSU+Ǿ(H$\-(qe^ϖMi܎a;gꠎ?JXn2DIstZ)ti[$r}+Pݕk7#)Cm?wn㻁*J'~vֳ>q˹F`N@?zƯ+pUon;:w$tp G)䔝8R.X?)VeU *B`?SYTVܸ؊yVWBYUN6szw UMsCWhUi<Ь3'RiVRGl"mmn=1%/lLG'a xBǻ>^8929b'g-UCfLqߖBu*qQ^^㶾14Ԣ?4{G Lsq9\sH֝8edo{1IYf8n#eyrr*rsk{YZ^er tzg8[=zgڷݭ~ƕiښW eP 0LiJTmݣNT"yid?:RcJNT,Iq4j*c2H7'\S岗W̒RTm|* 3KݝaVpNK/A4y4t-?w[nӏ~ֺ=M5sѩRU?zsjق2G2g+X#FWEX&W)o7f'==3ZF)Sn#*4T;.ƙ<I]]d䜱~`Ua¥e4ʷmIᵚB|1~W<5k =S7{_2i")# #>ti;>Jj]GBsx /S%-t~7_'ԏwF1o9Jk rV<=ԂAF:} k/g̮&4w &&x{X%RcPg߹F^.1Z? kLE8g+U1-0VG I5ԩƦ;S'h"ܲ'GJBQS Q5}wx<,s:\iu{E)YX™Mc?ZSN[Sjt"h/ElX䓑?ζjX茥Fc%[qqs HY>Q 9='ȚcdTcZvs/` #ǎ%7ۣFZ:sI+3O2ۆ).S*ѵ+[$WW5>\kO<דUPƝ+IrUw,}N{Vь} tiEo_#->۾\wa⷗ш8o=H~F8]d3z2J7n4HwME^=ehJѽNjʒj6n4en73F.qNZm`\$c,i6va3y&݊)ӋmoR/D/5gV=Ml=KC_Vy6^ ki)6+:2NJV][$ ٙ^G ~^'n*Gg5k[tJ4T͐Yb}2rsxVN+DvnThc|uLM 852﹣ xZpO5ٵHb3UV\o/Cjj{t_A.ګ}sZSRƜ%Gv])ɵݑb=9?vʏ,yֽT.ݴa\x_QFXR'WLʞUA .6zq=OhsʝH_.H,[9]FER( vYFLƗ<ކ4ΥWnR13۳/q돦)diR4hSvyX-U^:i1r34rwQ[{ 1ۓ#<\}GXTwDԏ{EtH[fE]z&7̌J|Vc4/ZP;+1,~#>*J1dx+K[B̳]Ytɯi9nk}Ui]Z/-U?Ϯ)B>g9Ut Kե԰wBVxݏ zV0 lROIgЕnFe̊c`ힴGcJrV@iU<{Q9)JʤR3[n$Sۊ>>z3UQom D.#UrXf#Z{g%}ucsU)Y1%*L#sjUg78k$PjVUH 8Ȩ\WfUjF1J!'Bw0 ?*J嶦8xW 'D/ XOpʼn?n*i{'4"5RΫlX x9eKMN_fwK^c*K7nJF\?3eYYX Qʌqi#㱮Zҩ).iijcj2qR+[\pu7vdζY?tf6b+I(ibڼN34 [2{A =Z8zd}7.fvq<{{NpJT D\.yVI`Fi$w@HqV4~*ս+?Éh$;da{TԌnBû[ gX|Up_\.撧O9ؽža#=[ ƻRlp <G+9|^$2;wpNjƥ9FW[[by=Gw{u,*a_r?^e*w9r֩~ZI}<1Qee `)sq Z5$KKUgɒGIFＸ88}뒵HE8Ty+[Pq$nx zE9oA]WiC vusXTjL懳g;HH_y7n$_ݗ,]OU\iߐhL=FD1ztN}j*4%&ayJ1e q9Ͽc6#膵q7qs\NTkEu*2NvVIFxϵp˚U9ujTmΤ]CfK86 Hdg%[v{dzҝHJ7؜F"i;iaZ7e8qֹ/o%'cm#mQ|;1e.KH2uRTp:okY=; Cl!_֢RKM)ӍL,y7jZ}whn:sJ]7<2I[Gʻb]ai ?C@#su{QV_kOIh:Mrl^L#'?f:o[8eTZۡn}&4Kvf^HFYg>T?Uj<`䝝 7dlcho+jR۳ #[/.Ml-DW̓/r;ci=kN|7ƴb~ew66q۵ǚ*HxST߹Zm:w^~]oZM>ՂDʍ޴J2SZW<7%%&?uhƦUhf8Lt)E%tfig9rrǹUѫhB_if}PZH_fFgffG'uOJƤjQUZ\<%u+I{XQ7g\S_N^+4q+[bcg]~*JW'ZRNkef[~hX`yN8R<{=jTZ/eԸxX,Vs\xxTrGCQ'elɭbxP ׫QIk(˒]:k%ݾé갮\ڿR4to5UH1VU!st:ҽzPͰ璿%K2aNkc֟mixIYf7`Nt8wXYc#/w1~T.>kӧ;;#ҧ'-70*o ߟJgJQv&kr2}$zQ6;)#Mbs]ܟ| G&-JlResI7̦MѺ<۷覭JM|\ m8ZJ/`Ԛذcn mz%.cYc[^fA0 j04Z+un_TVMDGY0Hv>Z_UOctl=qŐ0qУ:8.W!rpis_{m$SWl![fh[9cNtmÚ}c ړ}Vb&cmwF88cNR8ƚ.e1ue\9 qe`Zݽ:ʟ#ͨ/Z,rF[b`w^XOEuq)nڱFWaMjκnT۩2?ʠbN;9{V{MyӚ@H˹|kmxi+FZYdf2(~ZFz0iBP2,|p3ֽ:QqsN=#K+ɭ.g;#ʢU fב[1+VQcR 4[EGHߖڕ3>sHbG09sN[%|$+A$kfs=Wdnf˽+>it9HC\yBmoWyuШAWُ63ӿ*tE(>Lhk18؟ÚRO@)U,Xyvsv=XԥHPte}]w;4{8K}DsX?6PO_}ã)4Xm,f| $Yng9Ԫ^q$viX[_Ҋ-3Nܫ-1U^±g&qjIKc2kH-XwTǦ999-:z\E"T.z:.qq坼ezu 1ס>բ݌VGJ89I;$'khYAnW |~uiѧm^nUzylEBRK+F}튷+ʗuuI~(AN9oO8Z c7!ytm>&#tp?Ѵ[! nZ&iKI:9 cګs8QmuE<=(EȎku[f] wP{zqpH%ZMt$QbI l#fmxݒFN8j>z aW7\+*OZKū'rNHGe!K+$YLۢMv^<64κbn2v;,SIt܇-v21\哶P3#8`zI#$5J~ʥI++^ـeߟiKpoG)b#FZ|RYbAi `O~Z㭍(ƞ!R;UUS8#zBUХƚV# =Iq'\p:zJ͢sCN5=vV.'[H>oiY)$1ڣ,bU.khᘒIܿ3 m9݌p 誼"Ŀ]B6UF>gEKU=}<< $_"&Wh ֿDӫ+%ku?Mq嚱8_A^!*|}zzqi{+OO0H݌u q}GZ0.U8-omRgy4ZL| o=~__9SjQ{GQwVSmʹ^vyMo 9^q׌sNsKRemNRM{H`[EgN=yy( x'}H7ˌA{zVOhSXݶ>-ЮET`z if;#LZV;]:J)oUc]`mns߃\.U9y̹k hejr8浬L0?Gsϕjxz.Xʱ*=]E!yU8S-[F%B9NQ1Od$dU!0_jnQ2{qRWE@F>YGaYN:FmsĚ}} ը9J튤}aBAVFqxzթʥiN9GgXvV'c3@'xɨR2F2we]*I ?3m|:?U%vZ7Js:Z/ 7a^btF"T״V#E/݄*?FRܹ!R?#Z(fOZ*i9:ziSH_W: [-$Ic^v{sTȑ11;6써yI; V>%̟h9!l&T1۷SkգJ4icRcbLGύG^(Ԏ?hko)o"1Og83+ѧ.WՊӧtz%"WPJT,y\={-8}w:Nеm>UQ\>ZmIzT9c'/cTjNqѽъyL&ޕMƤ}1&~qRd{}*I?yP=+9+NZ9[J}NG/ooTprqlsGܵ6e.[n4gUӚ֩NNQ؜EjH63ZDnRHXI=h<a\QMc*>7 `1ۜʥ^Im\MfO`cʲm<*mcfUI4Nu#u֚~Z)WhQw9eN*/vZQk$RF*#=h[޵D^b1$vvoU9ݴNǭ2w&fְS ƛ8^H:WU5.vBKrLjEYqd]Y-rGp:z֔#.I/@MMn";9X;YTcG<նJqwq4[~YYơ3ް,[orT5`cg5C sq޸)9zݳr۩fm"2 #w8=k'%SvMʥ$XJ*Rm*)jmа"(+ Fh ]蠱zvtJFqf T[~g?oeEFւRmMi H_ՏiӟsE97 $@ҳ7=ȩf[mҬ,\8LR'fg٦vV\e9zTRmuPHB*U@oA8#u޼ua% g أp> 1GS);CgxٷkȖ3lןC4P>fFm|^lwsjV-4q>e1b0 zWRw~*KKrʾg?^ ykoSΩW]$O ¨Ջ-œ=#@Vz:\NFooTOC +1⬬pӂэ!v>ּT.V~GQ(z/"ID) #*-Wr: WM8+z59βZ9pnGЙ6&a<~x,Aԩjm}zF1,6ܧOҳ5;-7s=O*6s) ^RNi9ЩRvyG%6CT$duNM;j>h}ċO&8[`+*rBϥw}^u7q{ZTHñ\'qOE8ӕ^Ҵf,1:ʼH@HRA'5rQk/9)J╚vcbnt%H cZ .UN36RJ*J>M]Fep|n$F9~UarM*|qCKN?=W 9ף}ȍ:3^I nfې<\w8X}N=:ϕ-duR}U~ϧ(J4PiI*C2q֮Tbc)=Z,?#$='[R[B,s|zU0VSf(/aLpT)jDhqdGM@}sWS vqZ[m;ls#2:_3۱n+yn>2kSBFK$$ƭGjuڨ]UM;ٹD ^tz!TBHmUfv&`瞽pzTZ\۴ʩST_zB,ʞZssZ-2Rv"xVXy(K/BG_/&kJqf-4sPݰ=r:JJaMRn1npKY>niz8hΖe/5#Oo|'V˒Vey OB9-%N|Ta I\RȚŸ6 mf731Nj*m;%c 7WMЙIJ{)'R5{òy-[ݕepoC˥DѕKܯ8[#|NZF\d'>(Dl_+KMEelUv.s#4OӞZw|?f?Pp{j4*~%+zCЋ$a|\\qԞNGU)?2Wx^dշ! zpjOOJ66cpe@{<j穇SV/1Iq +8?7j1VWeaQ\zw Gtt!`[FGtUfU9F9ۧ}gc Wj 98ԋ/g*|罯y>_ɷnr?^>¦SidelP+jRc !ï3ML@¬[W8' K`gS1U%]5#BYT?Z|- )Qow,[@;urIКOugC.[/"r}O}KG[^# :M-4ާO5ev^d=3ֿPT^}n)^jZjW +:r r=sxO~}${:q;}_NK Z:^[M<#vQ|*$y5(ޤ޽~>_h 6.o"p2y\c CQ';[[߽ĥk#o4:^usgF)#8/8aUE ;[>ڞqٴm.q = Xl|NMuVg|= ,ۤ0$YOo^\*Qvl¿Z]ck'QΆ7XpR`q) ݊k %^h-HӪKm? Dndm"a϶q^/QlEJ$Ҏz=t~X+O>4KZաy㑼\~{ףB1ԕdߡߵ=Υ+^!W!TM|Uªi~|†$cn .Hb/ry?| o̗-Yζ5udkOܚ}m,Yi0#d cw to~|E|QRj8go"X] F[*0rI8eM 1Wmk}5鯟U鲜 N񪓺z}S?|mV$CF0;FHaTs,"*ϙM~gG)IsK7JYkǩxGŕ<|d7QPprz8womONUٷ}N/֕ޚ'k[{OQԮF,eNgv cg#2E1Z}/| -^{tϦ~ ~~]^ui#H\\c3a== $QAo{$kt>_Uj6kmߪ>aL2*[n#y<~X tXf 4onODoi.9 \f/SpyFcJ}KxP<FWI> %*iEy]βH'`͍a8A+ќiK.J5iijvl1xg]L>#ӵgB1b'R5ZXñ}zTQ4ɷpZޔh |积z_x=eꌽ75[f6ۼ۟ʝl-L<9nsӭY5zi4%ϜQRU%ӵ 1S]ü-ĒCWʥMw[c'o|ҳG3H^GqI˕;tlЩ(_RKiŒ$ۖ+&v85){JjV.2e7!ącǽg3D=u*q-cV~㕌`kԣ[ J_wݾxetU+H,j4yg⻢B=58z?̉"2Xc E)=Wc:q퓚M5,#yPʻsj:RuT{mA8U'>y6PݭaJ *0d &IzU2S fLy 2W8p?CZZNȸǚN-ZLЪ@_5Z*N?|e5&WpTcuAMK%^IS儬*}E"o^[pjxTڬ?#Vdi0~VޙlJ?:0w=m4%ѳ|O֊4}NOZJx7wеb 28`BuzrO 2:Vw޺|41FI6P_%ڳcdSZ*Z߱V8;[$UUi#ktɠR6I#61q}rS~kC1_OB+^ <ߙ<6kh敖0d ®Sn>¶2p\Whp"P/YO#uEISc5ؚNA\B8f1USmܯge{L4W"9#dpuN 9ןW=+iK*}.XѧdfF`H?Okٹ^ƥ;Fwj!3Zg‘i8ӌmkRȻufǀ (kQr_L9EL}˸cJՖi%SOi*lKr;fH]~FNK_"HE]mZ;6Jql0B{tNG$MH{kIVzȮ5e~#4W]=ڕ xV8%Ivy{Nz{v~FS.-T3UPq~>hYjL{Jqb_>(UqШ=:iGV_'+iYı*<'#=J7?6˚,dG1Us=nmu?yqO] ܰl*dn8٥>I^L\1LGv1YZ6_ݨ]>%ʜeRgKxZFt;zJSrߒ˖]4DZ)cv¦2m^՘Z[͑³18x5JS{kTY[q6so&lӹZp֐FdrdžݒpHck5%R//"m+bF\*S,-,EqVqm1`ñD%:.k̆流+` <F:{rhg*|[U+u9t{rNNz[S]4b.v$PZhUD,|75(F}`%ی<֛(rэd$z}B wym83{RHmQՍ)9+_Av(|ˢ 3}rO;ӧ&q&HlVQ=yz\%wJQGt1aa2IgⳭ*h&+;@oXZ"$3Fpⵔԇ,[[}w&`.ϺFgf'ӜrJvvI->$?̨3BY`~wUZt}Nf[A3H?*S^8_9G|z|E%ۤVҴYZ:Gt{IH)ƝeMj}B$8āYU9`xCt֍ԋRR~~_i yK]L|0smh^>N (ec|>cov[q v"I!|avӞڕ>W;CQm,oX5@yf8GA۽kh+sJ+YfKc<;N>UdTP7NZ[& ES5o$9"oR?a Kۯ>#n}]NRMTrL ٌy* ӚƟ4-\^b9c ܫl#\q]Z] J2͹E+!c0NO~+)_P#N閭i pąC6}qw5%xccN}Ad csמ#9ZRVY\o lp|~T\˖j=Xq,ܬRGrzk+quߗo0_)㈖ 9ު2;tkrhƕJQ%0&³ pĒJNpHfԩ98i^4*PRű2T6̣o'#ڟlBq5(;V9,q+NYGܘƥ(}l쭱KHWN=92%ڄeRыUK"ǓN'ӧg)GkL+B8rE܎m֫B6GlfMCNh 孾[~έ|ͳ!KWf>i^;"uD*H>:Vq6N#= X&~c {S8SgRQP#{xW+Je+g#|џFq2Ӹ*^hF0fqs߽W]YT"H["}ȳ+gg`S=+9*Z4M:uIJ+[vdy c$dyOF)U'anm]7Ozͯz8EO2H!!UP+6yc~&ަ>19 lWzE!9I^\ܫN{u[W5#I#dw1-#&и<x' 2aQwlHyI`6 gsrrrЊp#UC6vc ޺V1YRLjwGNӱ:i)F1U7̣&ѣmΎdG3e;>櫇7(Cy`wv 9 FN*k(*-ZB&f"翰}M)R,bahw0XFx9)GLG1#$8hd-?ҦKn *rK$m~L/LĂ9ҔmӧKW>gw X8ݝMla *W,7qnE088n+'-:rMַjH$]2B=t!R^ӽkY@cwr}r9N5ԝ#Xӗu'Ky?.V^76{^]TeE-k#{Qӊ\ݳ1 hۼGw6Ōf*H[EKT:SN*2RK)tgrTg5eY2MJ8|`d,;UGG_1sEE;XQL bO̫n@#ɯQԧ-Fc9)z2YUfBޝy|^=h8 y#\.%[wF2|9#PJ]x|a8{9%tP9ID 8#/zFjHs7)W,I8'r- #N2WKAV .ŹZT%pbeC0o9Y>)ٵ xIeT/n>TXN$ m*.1SJNH} l(~sFRy}E|r']~U*u -DH6@㞘C"2jZ^Xge=2ۿϥOҔ/6(!$xМ-PF2%!<^޳1sB0AUf m@UOO\\*gqk'~=gziK#&]OAF>^GRݵw*=D^WHoON XIWج^L(v5Z-JYιo8or8Q/v>9RRd-#V*F)Yj:ҜNi"FU7HFKgb)zEGB'(؆G*sڜؾ0WhXO&Pn`=zT)KSQZ =٣)_J%/wS9Sd[]뷦} a3ZTڱۙW i*;ޒGyF9v5~Iٔ6seK0=MҕnkE x%xpUdN?ZY}:ruDwN*X{Ҧ4e)]_㔶ܼToY 篦8:v.i?`iFWv^zsCն>d y/Q/8cp{^(8?ěNxTWq5!&"n_l$J+wYJ<#OIĭ4C,?u r?^?_|ViG&Mt4Fhsć>nE.H$|,|w{^RSǺ<r06qۜ %q(fw߱88=?3YOFZ#GU^8kMI|ch-mӮ9MFgb $?bv:۳/fgG9,֫Nnv-47vʲl玆2|ܭ1z~= 1Ke;zj.XnV+'DfH'r0Fzͺ 1wEYݣr^FSDg߯8=i|[S{6Y-yDd2s \c׾*TgנSBq;d ϸ)Z=6;*S^[ʲle]2A*xFدwVVc O׶Lm-S4;wZ!ԦFUv۴׎n+S:B,7np3Ox?r}W{I29Yuc# n^dYP`Hh÷5ov;tb+l!${V8ʰp}.hvr9r=&$yLy#8yY2njKiTYuBڠ sӧzܵ.FWPkmwn= V 2ZoF }sg'rۚmEJ̆/-|^g*^Bx%+'-9T.Q**Og&W4(Kd(R[? =}2rmcir&v;Xm ;}k9Su>QkWK7$弼H6秧z~ NœVb#uKYʏǰW?-oi2XMr_nV5;[6pz g˫Ț^Σ׮0(H\ySg)5q='5Vb||ozrǚU/Χ)('KvCV9%^8ym!ζr:KsKJ(DO\R9xo->SHtޯ%6nnޭCZԌ$ˌ]8տȍm-{\y{*~elە)Ju)Yotq]q=ZJo{YTsZ/r .lpyp,q@9ʢjD*K}|3_ #,h ;>ű2Nw#A8m2mVp7skZ^SNH-Z+Ԅ)"dR|w_ךK}+ѯԧk9I!qj,Τ61yQMGX$T[~7m )@Z>sVV6LhOGu =RO?Z֍JӡJpV2ӡYhkQAj7oR=+K~x89<5u$EoՋj*I$7ds! K{gu/cXJTV1q(gTʍZ$EԍGr;)PdYX09jq}{2ok,s?ZXfcRFW} [E˻nO>S*mzaAo# ol8 jv:kT29o>al;8|ҩX]W8_׊ҌM>fO0[i2^e,[jC۞7{O*rӖ>إH;x㉤62>Ve8\JދwM>1\̬p0 ȣZo4z4Ԛ7@fP>򨌥/*S4i-jz;TOJaNJSռەaߍ?tcO8a8vfѭZTW.:Z22T,W4%*JѣRZ54zvU.V7cg(9۽H"䙮$w1]j$̢tF#GDۺ.Xa̪>ʹ(KZDMrbHDn2N8g>i4iSkm9MW*vs}Zt}.G˶pڕ6Oʡ028?&4g=<HTpڹ=2Xf4$*6Xֳ9j娏tfd3 ^Syd3UdzyIzF?k!Tg<'TVeEb/hݬ!m rtJQw@Y3Op#>K3z@*R˕T< Hk`Gm ˹|rNNf :'(|n'\ќu{O}_tq¿/@c Rp}iz#Hՙw ,xpNy1ԍI)t\X3g3fC!X㎤ ⻵hC{ XlGlipI%N{>*e%T9el2ܑ%x[O3qrsHAsZjk9єSWq[(,|;?AXX7,˔er;>qf˻;&9玸T\yZQGR8Ǖ-Ev1]md^qV<ԧ Tf-#=>?'8?+l5F\׃۹nKh%..E?(.~PF7cZ4dԮIf@.!(c 6X` ֜Ѧsb%(ܱ,4gz r}kRYGԑbGǨێR;jF3v[;&M8J s-8z\-g*r弝͍c,sjkS-_q2^N,~<ɢnopG>RQ.i?g_r <(`|OA\ue8UNR"U)O-尝ʳoʪD-lqԌj{wq:o̙5-dG+;r=*Υ5w^(}l[r٦"]F2ޣbe۶tʪ6}x"PfPy#)J;9uO]XYH qMs5dؽ$oHUTP\Bk_ )BnwGg7}m#ysFZJ\$)]s｟S?!ң Sw1Ony)^ _RXU*5~;* Ӟ>[_3RW92vv9ן[s'ǡG1D˨VX卢嗎W=1޽J2yuGc>1wb6Nv^klNXn f6e+1F?OwQv6Jt3GySnuAFAz̬U9FׯBW˶줌 )_r tQc+ZnkFtk[O2՜+ 3X]і;/T{yD6@N:UF|lsGWHaL~R~v8+ܔ|%I]7M^_ 0Qm&9n'e>FT=ӓ򪋄e{J~{~IR3 n ?3xT[YB2Ysx<ְʣ:N{nDd2*fD4uܨ[c!>Xc,ŶY~Of%"ڬV<W,&4)'{!amΤmNgottch3$REp r˪.40[A,isskKY;Q躒 JE+6e}㫪MrƝ;jO࿞/`.kܘm="RC.GˍeS6۹ښ|Gnf|:9ḵ*šm59Szng1$/ʻ\+$ܟ2=/ڵN_hT؄no>a׾x\.bFchnT2Hfi 3@&,/nuw2G7z#֞=J>NMt2!O8&Iuc:Yi8jèT,3ӯzIZt1;F^F;*Tcl=JxdK"\reԷ\OZ GZղCUFK.}2,=G׷J0GG6RS]ٴ2Irm4y}}>TyliO^i޵H#w`3߃k¸kzF{}٩#,$y\ q4)%vtJ#+rzq+[w27LuץKRMXފӚ/а_)L#whaʅ>S_Sm͸?srtgO~y2rv= ?73e''1Wt)G|}̶,gzc2d>N<ۗ칤/D^wrU#@5ʚ˖Ȏ~ehBxֱKB:vD7[A[ayݞIV65zpLŗ -{㿷Ҵã/orpC Œ?WPzT$ VWkMԫc8gXj&sٽG"'@V' ߌtNmLRzHIǗo42f  C~FQ;̊W ~V^`lT-~坐yykz}htT]Fm'+40_)-9v3qKs)SkrX[Сf\չok2`)sǏrdK̒L1l;[qvR|d7vn1~fJǖQ1|Jn۴7p}>N/^K.u͔qcG? \\*t1љZ\²>Xq]=_iI.b}I"v09$7V!4S%%b.w?Oι}uaI^-GrLs'iNI޹jSb0'vKzƳgˌg#SN1ml""i'3i e'I;v}y.i90O+y6hmcy|?# VIJ m,W,U-~V>sXIVN4Ws*a9=;{{TƜbpӭR)Ec3y?wja~|ѭ=G[_[Au/a+:% OVe.V +Bpb{;tS i=NgZĶfL*m2!pgS]d_,yTZ_0G1|U8r8ȩVi-ٖ8T*d8uΔb4T{c 'UNI9q9Z.SDGksªѲ"s9R1#{ʫz4Z#hݐqm')?l*tWmJF–*2/oNQ]驥x~D̷*'xYV.d࢓jXuk,ܮ0n{zqьy]ў*g-X==Nx 5D2$2~IsHw evШ֕qsRmBO-_]NaoO;Qi%gقfH8 ?B5NmZXy)+=zm?/f/.sӧJU+PQwGF5h9/{[v}20X_C]ҧ%vw NN^WeQ# IyQx{Hg6 Ѯ|~SN*%\+QQ Т+Rre1qZgm rKF-^;)#O-Px8dgޱF[2Դ|;Ӌ۴sj>\-cgg:g+ u}Nk򩇩YJ=]_hX3N;|V*mU*R6]9XqY6[8LG<=jZ:qjG]ʨApBOw>i̶[].9J^dԔ%+Rv]y[Bu?qǝ*vwrhUa);vYucS]60\ؒ=Vl[La:߂}hQ֯U#dn.'fQے;`sWMIKtFǝؑou+_2h"THѕvpzL*sbݻo ^F$S?RӌVXxs;^\]M 2LmsG3օNzyOzQ~,ӷs PZ|7} g/y:)UCfNQ(>?Q}[sZ8YnT=9zWj~Ϩ)>K' ΅r#ܠ$?:|{qNQvVfeE5鶣"VI$Um+RvN5#ۣ3<1 r{kj=SFZ] m^цQs<ҽ*04hE˱j_eh*{|#O{_n՝ѳc9C1Gt'.25=,M+ʪ)*IֺiQVq63u>a'*~UlSub*.H۽WxﶸeܬHo,AJ9xg](*+f )F^1աZWQXD%[mŐ}rA~ʼʑ猹*ӕ>]NHUR.Zfr@FT+V=2V#-B[,NX\[ʴYolmA_v9Q;;%E)Zy&H$Myc>Ad:JynaRty77C0|q1Tṃg'(,gY;Pپb9}y*Elք)w Բ UrF01TrxzѭTZ EU䍹NܞJFk5lb=㑁Nѵ:'d\·4f!~={sWobtF H,|z}q]wgdTJ7vG[v$ۧ|H 3ǡ^9sCGU̟t&G!ܷ'qE|4էj;:Kk7rYڪ,^J.ϯ>^z孝&; cm[`33nJqQ4SocA-]i3LDj$'<ӎj~^T5RTlis/(e_/=7ceٽ_̪1I{KpoUجT휰 KBW C`ӧ*ܔ_)ɌJ?߈wl_oϵIRi[V^Zo~RaWuq|BƖ^Ij܎Oߍ6&P#\@)F5Z(ɥ+j@*G &w6La ܶ3xjkFRXOKy &-͒UA{u_z~j2Ujxzk'|ČYJNۙG9(讏JѠG06IVX5o%KUUbN~N89TW{55b%FJUV/5F[pO>aJ2Ș+!>dۙSeO5ꄶx'q5.Fɻ 1; F9 Пc~rd,~aXTSђ[o?%y!y95IqqFM㝻%\,]8Z,Vasؚੇ#Tuj-<}=8+ͫ T%ݞ}b4։+\‘Ċ#v2,9d$q*IE&NYO.(y̰(TY~ G5:׊V 7K,w;$.w<*R[U)b~ӆO6f -6T?֮e+9;.$+ d;)9^֕"߱NHs^6lmy?aj859=[ 1ZCDeourv:CE-P]9qAkЎjtdV}w(l+1sZ#O0}v\ܰr=9㤤eqqW D#6eϮxWJKCЋ4u.fs4sW~G>8E^R믠%X8lϭ]Q)WQ/Xac2rNz$gK-PۍKM-ۂWk.C9yUTl´m5o22,~i¬+^q'dF73^S;^~'eN RdW A20v8&ٜjI[S4JYwHsۓOx46Ԅ%B fΚ`way˚J漏nnYrv+4-QF]8#ד[ )T]K:5ӡH̪kag'vƜk}pn۳m0ޣ<Ɯ#^d #}P@ݴ|N܎iC+>o~DLI ݸ)NfTmUo..G"nE5XddͷoQ1]jq ҽXKm=[%@ LB"N>1:d7};1f;T qac84NWwH<99-V®{3dOOWTo.=R.ɸ$I'JrR#Yq^*%Tq"çQK3zSRQE}|̛'Rfk_cgc[#8~XVkA,-X_[ٔa_fu8(H'iӕM5۪C l&V +p)y:*TX-ˣZ>YA"?XTKKR0P>̆X!%Fެc|J{ zSVteg8 4~_}ԑW\rNVJtU5h `q,ywqX]9Q,1s}>ZW4jkkf5*|!Y&Eį~nN*,2E)yIm89{9Sik? 6} oS>%dcd7F09`1>QڒVziyrt}^ @.4-Ic_% 7.>G  FX /zLvXդC$x]6͑@\9s)屩&c=&GjGt\kjV},sGvg dmdA8NxtWx\ b_Q3d9;}t 1V(jmb{T DomRvd8ke{-TR:;.7<71[F<%[ثj{ܫa|C6|==1ڴJ3w=p?CCzOjJ>27qGGR}z_4෾WqP'Ԝc> ^_F3񟏷>*[B$^Qߛ*s\q9Oҿm:~{STV1͵]I\/ϯN_d:t{7^&d2凩ϿZ FHzvg#m=zo"VPR:9d ]: -Y#^H1W^$;hV|t> [9U/ 둿x#\_ F>/N.|[YC{[;{f9o.5+Fݐ6x?HTpRn;5G[W}{ ?cIݧzZGM^FXء`2(E:tۺWN:p2ɩ>i.~g~&jz-|#Ld//Wlq<•\5c ]ߑ1`u"N޶=x.Ix>@9I<@ljۭNSIj֮4^iսu<}Z<.J^ZJ4j}ͻ :70n~}3>X\/{h{WIw`_ȍT9; sL+D]:.UWKu9,heo/ 89s*1++;oyu)Ԓ KeCe8ak͔g&ڕXʟ-7UؐnNU@Nᓐ[ǚ*>ze;h΢ī#1rŒdzl}dk jK4b$T3%-,Ujeϭ6#qKmߠcu,o7.PO8۽z,49/k+IZ&51bfY?xR&OsJ4*iUZwXqhwn=1Z{?b[N;M_0"23O^@4pǖM1oxa{" v2dd*=9OZ*jWq'Qj+qus,|u_ں)R^N(_Ne(?_eFsINK9ɺnmHwWfT`+J~봷DbkENF~Cgk_TQ|#9㑎@58g˹%*-V%ME)fk{Y6Qt'=3OF:pjoZO l,)mKrlR,US6JGn GZJҟMz]fgTcSzbks-u[慣)D"A#IY/y.KH1JۀOvk:˚KN;sD8W +F27wJ-nm9SJZ1c6 5v'{Z +am~.{/h۾cd솛dڪw*pz<*Ttc5WT0݌\5+PuH(yX#rZI8^;_BV7H< b>a(eceSb0K58fHn}EaiJ3e).ky!89t/vN.NعS\,*Gl=3S'ͪ2q} he0^7p1Q5儵-Z’R*ȹm0hד9h˚)L|`$72y>Ίm]h3!UqZ@ҵqrOXHcfRs#6dfRiJ®5H庍 {u>ukB̶ɻsVמ{Z}^x\ΡH#oOt\ԹngDv3~Rsߓڳ6)0QKR+mn[+h(Ycd(Z M]:VloР#3C{Ǹ+*u?i(LV'tM(R5;qϩM7%+\s5v!{uU&&S}0p2rOmFQya]al۸EH(fR,9r6l2yj$g9D[jt({?!hU3)ߧij(IR'EbDV,}_)J4Ru^K#9bJdx8oi(snU.~vd]kJ*'#zmb9TswEKao*b~\`~?AZNZ6i:*FRdHVwZqW["j{nXAl3V1e1 9]ymf)VQ ,"W q81z]y*4c;hYh&dVpLN$̟mIX|C䆭o2 K3+L8N=;ZKeGN4%[<1ܬur=?c?Ky>RZD9ڲF#TU3qYʟ4+ͭĊ٘FO_}InV'+zXHƪDMΦ֚uF*8uY~%tT$Ee>LC9>])ֆ>%2G$b#,1'p})qyqۂ̒S=k\,*H =z~*?|}h2y.1YfS~C)GPT7Aba[>9 .f0x`y8+L=9!iedȯ4r=p|{b JY߲A&+u󷼌vIW< cX1hķaf$%rq:W<q90kY ڟ#UVF|}AyFZTj{m;0,(z1m#k88g LW *ԁA59G}*uM<ׂΑ!I0Ic<{z5V2(I֕a4B۲ShZ }8糔cJgc{?&W9dP.yZغrK/R)QWr̫r[1sXJK7g ը S3,+nb>=;% Ql|3;Gc~T;INQ佟C:}6YgrmeQ9~uQSFڜս rnIepCmzʝS4￘I#[Ъ\c=eӺݛʤ`s: ^0Omlda^/ŷSF5嵻~dm LIi\w#jѕy97u46QFkdXscʐz8yTo#EI'E%~LɍʸNU{JmaSBNյFBVUY ؘq;E't_F.2bmRyn<KCN)&"⸕|d2xӟLDZmҍJO`hX}>TcSQKQ۸q-6,e}<HBNtb%홲u@NO>]ҞU4е\lQ2y8\cxoQY\$n-Hw$i!F9ִGVtarͫذ'\ۉrztGve[Nh+*Is5xBןj<ԯZ Gǜ?*}e'QQu31zӍ7(!ǖNH.=G6,.慔 ~ouT^T֏ge$ei;تY͞854є`&9&V 8chrښjT䣢ܷˇM"v*qrOs~Zr$9'Oi6뵕C !}k6aޅq4]ɷ+呱60H79U>m+Vi~e"W1(30Q5NG%4"^L UO֦]<+ԟ-w=n͢-wK2;ZӸ-v[}ѻǮy:G˹8˕J'gml ySnJ<|~eaQؑ d &'+*DgW!,p _/c鎤VetTXkwXbUX)88U)*MˠTGͥH7,Rc*lS;h=GXy9_^,\H YsQaU-X$arIjA8g)U\Rt.򏝆[vg֯]#ZkFɐ,.ݵJZd3|ͷ,7`rsڈU*Z(!{Yoby;TʤkGRB<|vb|ΥrR:9 I/"6~^ʦW;=l n^88$zuةFWC?6O>)ӓtNN3څ(Ye-=I& "ƹd{y[F3D[f*Աf۷R̷ɭ7soYOW ~(|&{؆O+ccz}}j{J43K ܼ;>Cpr8ޱ/%;bY7|'$>nhɗP~Um#TKƣjˁc_|Pz\򼥯RoRUޅ{{K\Hn` !9{JVJU.e] oTcrny❢2-_,I;+bg%̚)k+#)g(̇&{V;drXT>c)Tr׷<3]<,[=_sTGЭ+픴3ȭ^+ZԌSV#diWYX?om ۍ=-iiRRqNET>W9"%̑Cق8_᧡j?g+įnfOݖ*WI{ۘ[0i˘eTd!ڪMgFFc+ʧݍ{t`žUppz?ñū-$_h ><ʶc"[=Mٙ= )O6%ku.$v̠n?:*\֤_3靝HUK2>R&ۊc$5b |)EE=XGF.V[ۤ`~\UnhX2]:uȣn|z}}DnsYrKC+21f8 Y4#&aT_o֮U,Yԫ;Fc9.Kj1|fDQԩi~_ezǧB RZ-Bs"* qEM#_b4eS9.ǗOw0٦w|m㞕riކ޻Wmd׿}ᚈxFrlT+]u9|#Lfvf.>)FMC(Y39<ȩSܗ(ʟ3|{ZY>V(AڼQy}I϶գ]'Xoh.ZrVze)nۉmp9&R}ո WnwRۅ?gs)FLg;c;ϷJǙJ.YTvʷE7I$f8j+ݧDY bfl )s7)Sբ̰iRʱEZn3*5љ>_jC)#`?:9Fh֝7f2Yo9g._oS.|,ϙXp?*W1*&HgI>mX9=A;)ӧrd{89oɎee]eXZtvcFD{~nfvy~XVEQfF=Es{yR&,[k[cy4G:#eRq1eoe-sqsUhjTSPyV;YԝVWxXKY4U۩ZPJD"zci{GmU}?eyI ZfU>s֪J4nw~Z4cf26C~f[8ū2QOq 4y}+UE5*Qz7r,غ,{qsXЩEW y9܌rckx뙣Z4^/OC4C3ۏ^sIPĪnuE9A!sFqwWU9:kw4^*Pv}E2~`7q\kҷpq 1^dmUd-btw'b!T[L7SZƾvN翿ʉ?UJyb;yxn+fƍvN 4X;X򹪩~[P1b5=03+*xQsը5<U7۶\U} R5=t0j{4{OkbS-IRcܠ#9랤M^+c$$\^50 wzg:ӊig/8GŘ-RvpLk 8< zVr*{9ivoQ-:²\mf9vQWc?y^Tߨ+$y plR*iBTt:~D$'㤻ڌ/旵{%YҲϝ.6 O$yb{zx8!'?"%Bƾb9xZU.hKUhDgU`I}ryc&9*F T۟-'zןR.i!#K{YW--㓞"0$&rJM4{&]цO8+a=#[ji7/ 31Xnmpp{Z(qDRJJcbEk-|gr랇ڽ:x)җ=+VKݺocN=" >cX|ͻYw=|vW)K~ky;>Z,Kn-9ϨjIGKݿ}1YUݜ{UWR:Rt_/!_@xjZqZFs=?ʸerk9sSvyW[ǠZ? jE}O\RMٛadEǼֆc~yc۷͖Ow׿WqT]3Fv-UVO'lqNI9x3^1th}NlT'vBme/"94mA48Iܸʼi ]}_.0K^Xdb%rs.nY=Mjk)@ i|?*HcWMGtFiF6^UٮYF6Uʡ9=qֱj qWJ~Nd4wLGzuiIJ[ǚLBe; cJHUǻWIԏ*7i2Yu}Q( jda7Fvt X蹪m/_3F[YTho+Co3ΓMuagS]<>KK=KS$iʰ`^aaoеx-_M͏p^:֔o˱o޵w7kVY逑^/,/ u9[J &b7k>lV1{_2'vhlׯWyOBHjX4x=_m4;RO,FBmW˭.eYئ4Jl4JMj͒-ü;7|ooγnk#) E`+*)ԗL3ďRͺF dƲ\+5eMC2,Tys#\l_Pq;-I{2]Hٰ'xVgnf_y>'sckWn_rV<*rCnjw}sݦ$6q$c1ޢV/ YIribY");U涩R<+=*b-W̓dϹG?NOSg}B[y/TM^Ư"-Ynq;F"Q(rJRۻvo4T)'mmq*Gcd/I'8N@t58ʕ۽}?O# r*G1!O9,E8 pHz1"?c9C]j_@ׂE6ϼ:l_ΪxϖV4gC.E{9ku^]#b9dY̎R*r8+J3մRkRkFW]$ڵµ)^2~yJ _"UDr,9 tN/vNXbet=*24SѶ*B;UPїSߩoqJ#gקFKthVFbeV J0F8k,jjvќd_שjHd,1o'>]5-ؒ#pX<uFW$暚jܤ6ܫnc G9*jHdCq: ;q?`+hsjrnp[Lw9RFyo 1VDvł֦!hޖ*Gh՗8uVzgh.2B$Me0h{9~Eѭ{3,LHߝG]F+;l~f\Ha~{4i.OG̬I#<CׯUҦ^BnôLN^ wLM̿yVkbH8g* G>*iqdi; OW̌~ￎqOZ8.I2*a%cڳ9Z2]n0D<BqrW۸S9I+E(SYa{uy{kre*Q{ڳd}zYe bہt)BĮe;˝Dcyk(X8%NQjikFa]+6qT(P'bEE)ik7ZD7HyR,73`u|bjsKݑ*ZˡѳU5eU`~ZD\գ$VO][wO3l`+޽Xǖ}NKoOw̱̿.z'NƉOk-Lޥ+>r[yoW?&FӏtIsJgO0nA&MtEhn*qOML$+t#Thg8;_);(O76TN4i[;ktd"a@~qY>i^rLEJ8>kmObBYfݟ-W\)y"}|bwra(VlC g$>}5bV&`6DPc /ʳ.ל֕mX^ v_]x?]7b찍p[y>i^uЕ)U-^12Kq589$z3>ʍ%Dgo3q=sڅG.xny~eƸXFTuKUc/bKHMMj9iʏm&3m?+FO~G^}X{;>j w GnJ~v;ym*R7-ޯ^D2:^k%9]htS#;y~#|-ͻIrMgYƜnc,R[z~Eђ4jC.S5捠ԭԒi Ȱyd (9Wǚ>΋,_ŸڐZ,+! *ׇx;w> XYj wˑwGå>hcS ,iV=mߏ8˓'}ӽy[t_GpA08yyEvS7}}kn1ky7BO|޺WիyKWj۫ޭ+#EXyx8A ^FZ[_iҳ1WkeH'zhZ.ԵczHT1+M3jDsZQIROžgFJaڲ_}fUYT)A_M ֲlv~\^Uq)Frի hH#=3JJ{-NzU(BWsI}Kp`ȯ&ݭjmLѕ5}/$1ۻ_,=1W$jϩF9*w˯-yM{]4].^U8qjsF%đߝ,[m?a(ԲDtCg3yp y:29? pEwSNnӏ\^@+~bU:~:p`S ֵ43عqgֺWZӕ>_?MR%)fUU:ݡڔdhiܶ'4G 49'9[S<~ZZ\ +;Hoc4 UkZm9(ԧ'/d1bɃqʝ>yjxBSl۵aUU[<θ,lmJWniWw옒F8rz|BrB S*Rv<97B|r!דq^lÙ#S$͟zx0A~U*nJ|jqZ8߄}9\pykǝnk/d>djG9N{d湚$J.FbThnaqkFF4eF}Y,2|=ܮc51JwmhQԮP\n,jiqrThѫJ5!.PՍѫpGҚOOĚi>)$@ӿ#߶OiǞVՃJ;Rl_lb7c#oZS*rJ]ίi/cͺt̏7 .@뎝z8zϹ1nRh iL6~fϠ}qUT~jʊwjMM-찪)Yw鷜 d5GFԵkaϡKpVcdPHں%SzngMXcxv+1[KUsvk7 t]JQOKQQ~䚌2U#qߞ#JVT䴹?Zq[z 5\Fn@ v?9SIY[R)Ӝ(Z'5-b;3,{YW;wTO iӗiYهKrT.^5&QR/Av.Z~*CGH($rOũ\jzvPЗ9ݸocӎ+J8_hܧhN"m1۶_~:p(mR +K]csG*\+4laF>>jUhǝrTj9{0KA#763"Ƴ/'ӷ sGg/[F*vkS$xSyj[, 1qϽcN6MӣZI7ԬޡcV?:#/)cz8Rܕz44U\K^;_ ,jܭ&Un}9~YV|К#~Gx[HϊDHn1܏1bԣy5W]D kDMWV'V;@Sޒes TK] 3oG?S_Zr:rG^Q~dq9v%NMcz[Ŝ/:؞*6ԙrӊIjB6z sS= }>nml=>]N~J6Yt]M S̗tjXyr5#S8f 4Cdc{ūI+ 8;[3{⊲KyJ'͏sW?N8ZKQ+2m# 8\rQBK;zW=Z|I- ,Mt` c=뎥.k'nʻW6mf<`g?:7=ɹP~fm<1c?#mLU/;My$ 9cg-q\C(&ۆ۞5+]ny؎iE1N7Zc4{aUuSkqd2*tn)|{Ny^ g#8ԍ;V­ڲ0edӜW,}])ؚXH$aWc%siFtnu!k[#a*$~cp8fc8-\(G*;hD{G*bT'׽z(jIJ:&g(8驵Zs#m}NG=k鰸XeYPo]:Ӛ%[}ِl|t>Q+Og%|=:VdשG TKMK vf՝,L<+? Oz԰l)VW;Mfh^~J*R)ӳVF0wycs`۞+J͢yܶVA_S~gҪ;UkKCyyA?̞gLݫArߩQ+icH;{ofnʔjKD&+XSN vWhOry'UR7çOL(T+ٗ(ʊW)\Nh2Y{49KR֝?v=yO&g2Vlg5_-jb}Mpb#6Z4sdAcv$Q;9Z_`΋_<}9Z-J޾ݱKieWi'#ʊ%dg9SnڙHsG\ '⼜Esr;fTflKl=gj7;ݯ6 B}; \)u^r,vb˃St6ҊvcFi?FMKWFyW$R1Jz3!&H}\lKo Ӿ{hz%RcɊF&f /C=~nWflJIؐ'_3he ֝+I_v 05<3u,w NX<ǁҽli*iƳA%]OCb́yf+"z)j{TW+J[Xڬ0aj {>wcju ;}k<5_id0wpyֹeFU%sUg(cB=f䵉S {›Rrq}? mε+CYч"'=d_(ө]a gic_a$瞤[Z]Kn#=p pq^pն9s=#LLp_N YԦ^1Ԅz}ıx/GKX~]_0^n*ik/zE튺m~q^T|\ԣNε<WV܋P?'1,$u^mLBTͫ< x>)l7ϩWJ*9MOo/x6ZHגH$eRW zNzt~ Q:JrC?W[;݌X'.5++6dE`p3gGΜbYRM.tvC[Co<cA.)qEtq8 #اS.}nCܧR R6m/mhzWo/ďh\"k:~dWJbNTw )Ht1. FP6-tOm5O]mgMLEʓ\ݺt}O>*xz=z!奈{dd`v^<;߽_T56bɨi2ڇfU_2 (g'0^)'YN*6ЭM/"ռLnsyou~z\Jx W38{ꚿ|P]Hak 0JɁ㞙'J9'QqUQM.<{I3c-YԩN¾o=k^G',GUx>=$|l:y/iu?,TTlV wJg>VI G>`qzؙTm4' 73tR;cA2 (w\0+e a;3kNcw+Xߖy $q5[Jl<\@5=#ĚY}drOȯws&<G+xO!ohڴ!c_*6n9?rbzfJjRVr/oeܲ<aiCokS dpy|"O0fҦ"1J5 d+93z~KkS2WW)5s$ &ݹr~=بф{k_3ڈs:ߡ8wIǗR*6:սrD_p0qԫۙǙs"JJ %azw=G?JFcmu}ZX,$VޠWJϛjL=+Uס;țMr}=_A9e>n{Yn&*ϡ G𷌥O-lѦ9-YUQ3o# c*F<8 RWd׵<,FƊrӳ训sym8Ea4QH޸5FNNz,_ajTZJmGKv}>H[Xd3n hw=zѵ~$[]*Gqyrn8c2Qns)Ԓc;t7J?x?uN1Ͻ~jQz$2EmѪ9u~Ma ou<}#& 7e\scULkJ2ש*S|ы7/%H$ JtQO%ZZtܨUƯM;o"Y)Va<`8wM*qo5,O܃#?'ʽRZ\X\+ihxWYk&DO0w}}LT5w=)eќ+K:bᢐ/0|q8kQNgMmpm >cᲣʤHK$g ZuGG+#iHxq/Ma&Mmq5{CFB vӥN'eLSٮ__BKsuyNFaG?C{;>h1k{dRܽ:Śid-$*{mOzq=تjT\n9e\Q-qMEIC{'1bŴƟg%m˕\t#U s7WsB hI%dh I{mJi*{v&iSLU?#ӽvK%̓EGOtG 1D#v'87:I%R)|n2 'B1t]T(։嵚[e]'>sN?QM ԦHfVڥzc8#+S2l2[-fϡOj`Y:zw!"qS'cR2ΥܳZ8X>xVO,2nqq׎.HVUK{멝}i/XٹP˃WU7[[܊*wOdUX,2F4bˬ$eNQ{潊ɣ]>vV 򲌶3J:4'fvhdey-#U9j%Dwff~m (]:Nq>23]weq<-82ntUESUS1[r3s{.g(Y:,4^mVS8 ׵\y%_tRk^E+_8*]oNBѻv.~ZRi F*?{ sD)ʌosG{}fpP6}ҫ܏iR;åXaU3 K.9?SsTJ6ڨ34QtRw"xA0̲c=8nWϣF*qwwԍc.!G?5VޥJ9^ϡ!GYeus>^>Z{9++eg}zڢV6V27~^y` +кتpVa#|FA2qWmNKZBHVȍ|o==z?L{:1MOVIhsBE%N1^q߃kΝ;#E<5!0ɵ;Dqq?4'q;ܰApE:Q]HU'=ZIYv:jq3)TQi#W'*mewqFN1?iؑf+{tr˚M(=:[!{`ec'==+ s_˩K=:P02L,+ mP;`gӽfZn~ƛS#5dˏ:b•Nnf"FFWnNQzu)6k8@wy<=}:QS] صJjgSY/gguRF7iطmn[_a}?z%(λD[Bv䑏ӟҹ ZӋweho!8UE:rջ,[y glUZҔcQǡq#2oGo+ qu5b`hDeN?v7t\#AI=4KӍ#I )V_i +Hs5d]"dB}ܝHZRsNe9%k>"Vew6Y[=Z%>h"^H@d4ܑƪ1e䑛Ur+])r!-ԭ9ݙ8V2Wx=O$jIUOFax^Y?pcv8TlͩT8!?ٙB?Pkhr73NVd^"c߆XOp:5wݑSrZ"H;,lcFڎ^]KIS~d *DA\meڧG\zpE?gOYf07cGZEsNI]j 34jV-pG8K[ӣ);ٷWRs<,ѳFW~\~9 PcYQy;[JKq.]ˀz? VijŏdAKEWs09裞?*0g&w*G :oNH1v:R@`vmݸs\sKڵz5\YZ2?2NAtGqks_7b̞Mfϖ]mفd79#5c+ZZSֿbۭvFUX9JsnovB.1FʼnHO*ƵG=Z%B=4rܮͿ3`*yb]̖~5Qm`Jn7o^T4ܪ]_z}j]Fci߹J`dΣtGꮪ5'Z䤎Pw*g~(KUQfW:߬guV.wݏVqSqr̄[̰mܲVO+;cVҧQkׇú6z=ўpEvTՓf5ڝnX!r42*3;\ךj./tD${ Ho1x=޺JNQ\HGkR7eK32𾄌֑SS5c%[ vRs]:iEԕ:!y+x)N|]hZv敺 k, ?(Xwgsךڷ?NQʤrbؤqHd\m^8;INnũ ;h2Iڤ{?b ?.{zUIZN*wnnycg?p q[ӦO=Le8ˑ&w.odwp=qYSX꒕8sy{B[ّP&F1sR1mG_S%֬ס<7jR^O| Qٝ1C Iꋟct)i<9<` NzqYƢFҽI[eR[KqЎ@ ˒;'*_)I3.3tuoAӮ.$:sȭyv l9ɬ:qh}K=ln˟yzA:zuj8sj~)V&hIp̉;cCqQ*twc夥f6,/꧄yrQI^V_(FHdH'ׯCQ?ML%6Ati0v~2(k,=*nNW2+! ţc(cqT啣#Ď u *mgEq}Ҧo)a$dEm;c4~Pwf<Ҍyc";JmDd}WߟI9iFZygn.Й2trqsV JZR'y;3Pv8/9VR]_um[;Z}i 5jjqc5/K?[u* eʵ4N1inNMm3?A:V2ӹ*yB;yv{lHg,OCnJU=D0كGϛʳS :7tL(Ā+o-&өvUW]b;YTa:?O[R]; 6my$ߔӶjڒ{6H~}}ReCJ-wfWcopNNO וTݗRWvpd;7svF1K3i{qb+4AFbfm'j}#jUS"-y{6R%VOu}t'rnĐZ8×$*+leIaӕje'fآ7\Mp қK&$WH}je-M:Vw˙$̜/G4tcQ]sBZ`bҶT\)sn49YY6Ǚ\BZ~.X7. kV}}q{wrcʧ{,&>i'FhN1Iܑ{.@lp{: cy+M5P9rbO8Lj(ŧB}zo8U޳z6ʏ7+QV/,lhPی֡ۛiiFEݐ\Z4icUf ׭Dr5)YnB*[26$uONz8H{vJS.iٿĄs'/\NSD*)SF3J^[^2BYmmJ|#snQ9ȩ^9%MB8(Wfmu})9s ]J3K+BvnʼnAJQQ1I6քr1).V=AM^1۸ `4*ѳq򏽒=F}SQj"Qn ̭." 9ǵ4eY^L)*~e{@eٵb;v]é#oʦ<ҽRt- :|mcstZZ&q0yccemW8Q:7|D"I^=ƭ`mNHsXgQK,҉AmFV3~kI逸7R|ꌧ 4rg~]&!pYZ1RiQMps[$FWi7<{_0}'e YXcnT(k*qWױ4r̖*(]z5:lPiIFb.`G ~Ӗ/2XomX 6ln8#Ss{^S3^XlL(;p̪=z҈ʥ4K/Y~W=IZr1婽ѡj EVI9ep'U'k)KܽҗDfcXnbz}F+hSNfT5˦dѶgR39JҝSԇ,E4[y/*ǭKw&tImn7qcdoa_{&%ߘ_>R @=;QPr2ۋm=uV.HkuVeWܸ#03SoИR:G;㸷ۈS+9%Sw/.y-ă^jcqUۋDUPPzϊ<]MN>b5k!vg:Rv%O2f"$8$;NH+*oFQ8U8V0G ߭c(ir ĆrwaTvQո.Z~wfeEf\s99ӌ]^ra:m"2UC稬Z{Sݴ97:uq>J#8 J qv#; </3K+rWE $yV~pUrio݋خƱnP'8W禕Vk3o*M< t1ea˚ڽdHR(DL7y/#$\(Ƨ3z~sK2F\XׯCIF<ؿ_Mcأ$G^Kͫ.Hubq HȤ*.HgbvWoESc4~a^ʃsEEEDҤbt Qo skMKqYJ]Fdo*]m8avJrpVDJ6-:圮2OCK'Kr$Ļ3cQǚ&KЃ8cT&RĴ8W,dyrMMYvJm8㧽c9F6o{ZXR[i#yx'?cZUO3RZ-eP~ }&w=#b r,xzֲ{5rc,yUGsqγEq ̑ƬN SRH^ZA(XVrA;g.ZZ_SR)-q@Weyr=bjD)KE1{T&8Ӕ^kq|gV-6X lN>7\ѩN7ݓ܂H8̑ve ӟt/ӤRKDf3*i $I}hCzjԮ)wws~ƴV7u~@l Vay3?YKRM;hir (O%p܌k*|LS5Ë"\ ~9yt@ʊ ߷#{9Fgf~{,8LөϚovZne;CDѦ g茹[/ҵLW%E~iO)xHcʨQ0xv/.g}}FHlR"D(T 'szUUnXiQkfz-S6 <^٬x`Kdw~լ#MNg\kJJܭ;|ʒ\),Q˜Vӌ]54wkvnd%&{?^A1\]ON6C˲]xUӕIE5q{6W`uFzg%MYyLzwfҜ:זmi5K?=G+;JMj]/)F[ijULeu;jC#٣~{f5@lZqu9uGky[uܚlL,q%?t~}>y'ӭӗ/ &5|ۀ9◶(sySaryYNy4J51TEfLwSInɐq޳kؘ£kif2Y_hױViͤX 2cX~UvrCq3ʟױupTM5n (d9#TI(F}jqj+fj3*Bʣ x#8'4ӕ8_vtӾQwIu~zb#.ߐۏSQj%jtSIw@͂GWW32y[BK;3y*DžT-ZʟmG*)ۧC뮪qX4}2+4z:]|۶BsQۥs0QM&f7g1}N;~tEu/CTq+kHf_;zKZ~\эnHyr2vWhy'ZU%{[FEHק{?hEjd+#}2ӡJ?MI61+23z֧-n_f?lϒ+\۞='*j;5Gy?X3Frʤ#|BP$r%|ۆ1sS+=єSFZ-\Cqeaڬp:7ir#*ͥ`dYOmzVvTwF!j 1Ϣr1?8%;ҹVb8m\IX#]͌`gڪ1Qg>"Qv%pɹ3 `cyaZ0Ubİ\\\.G(ny<z¤-Ց{iBKV1 1RZeF+Ș6ԑmR/nB{{gdǚX,V`I7cx0Vu#E;#RTiF=I2RXTGarTb߶,5̌۶q鎵Rc+s4jgw GI=rzW$w.VgB1w=";I˜O<.>(Ez/JZؒ+GY3B{ۏzyRRy%$]>5N^7*ʝkEDXeG^9g퓲1qQq}/uuR(ۻl,C61g¹5#Vz/yZE}o#lḆN}\~gڸc)FtkkF&݋5AW\3޳Xg?<#(;6Ȱbd_3*v{/#jэ8&}حktLsD̬si=ZJ߷UPo԰І!<$+ \.Yɡ4.>{ڇw,x$`v'{\ħPn5)")BF=k[V]Ό`zԝ^qѣ$wr4$s ur8IkZ>:4zQQ=e)n%X.L"ۃ9r+qWZ$"J8%SI5MMKIC"U_+??c^+Z+[mNPߛ^k㹹G+G& 3~?>{׹F7T\Rз}ņ\7tڽHu,KVV6aeܮG+op̹lɣwv?w>҄fmFd.Ӳcڭo0 猚ԧc+hY7!|}&ԦiIlU7HUc^wG+$m+JA|cev2+3ΈVɢJe*[qz۝}E*/6'瞾Nmjr"γ|[Hwu?Ny)+h:vF>ݻ6()f>ߑ?JMIWi'r;iVV;g~}QY~ܒ(Žܪa2O5%-ecfm0[}*$5I# ;9_+֥/!Hxn;l穬Nn(b"XaswׄJګWV9 r8q59U=C庎l- }1Jrz=qZwf}LcCn<,Ikdz%3mxI~^r5hR~tc@Ak#`Fn1:v8*(Sv}L}k;O }GnkrT%Nnf%y10}^Hz|*)"iU4#&Kefa+10 yּTF}_[["e=gۉ#clnF8eQ:"kM?C)ATʚoRhmŲ[#3B͕ P9G W&ZJy6{֊QZDzq!2|_W}3S#UW1H(O;~l8ƫm$mʳXN,;=zuhO-Y"2tyw52 +jXYhleDPvB|ץ_*RQ~#o-G*I68ѧ:nmXdb$]=?JNOd9h2KEebrK{1ʟ/9}m[5_>Z!_ׂ20yϰzrwq#\3ʞN+>NXRQЩv8V[翧+)rV͸_"=c~mtKax<pYFs2=աm,s+2>}:Q\5HԼcjK{,ǵqv-!=u}z-Hm^rGE9#4sHmpd;UNztkXY]؊~N_Wd6A+pq}rRR~9}N+K;"Fvۙ}G=?s{e+NrC9wQ %et]qֵran25gRWf1uo۴J)9-=S?b=ʞuT$$7tqv26rI^H32*{ f[h` n*|߯&Wh⚨[,,\ -o]gBR@ JqYKqz_ce;UR^ClDp?I螆ʤIrk1sUV^@scN׏r[\8+'UNd6*1éCrk) ZiA+{͢os iO#$.RL]TZPQm;l(h8Aǥe: * Dn?0䞧W3ez)5v[[i$+?*=yB)^m4LObnXsLtN225q툸Hcsu߯zQ'sT)i%[h|YЧ%q%>cH-K4yvbe$䎽q*w1JRJkn qkvyl[55ߘBW-Kclg|kQJ9QWK=֞ ~mEs>זRWD5I]V̍{+SP;\1fumsʯS\Rzթu# K]?Abdnl\F\}A:pdeR̝՝qkxJq"fe-鎽){78)ӝLG#FFJyڙzrx%hЊjwN_rzl M ̪Ϲ9?Ş}e>wQ+u_+ǸXk)òiStw'uF;fw> +c&wNIힼb1nNmJ|t) /8x;E=[sاZ5m{fˢf'R!]z1ƺ"i4ћ]{WmS !PBk5':)ԕffi Ȱزy33~ ɷ{W^+~C4B(| ']r%U_"So{{Ekd# re(sluVXyR"Hx2IA}U}cBGV@h(^Տ/MT~Ʃ슷B͸AʪۯCSfEh r!. Ҵ%ӧt'l]_-|gҹ!IG8j{JI&K Q5}.*8Ys*oSRڜ# J~Ekgs(ۺ3mmdc8:7^M:=I^݌p,cV5a)F4MGw'{ܳk prïֹ}'ݛk*M;K߂\qఏ?)-y򻝲[<ֲqpZ._gv ͭG* %[$z<c/g&%pPj?)aݳ[aq招GZBi'>kG#+7qSӌWνJ1q]{6D3yTsho96mt'jvCһ˚VJϨ協hi=1(+.nkig+SN[t)ˣK inydl8c2zUTRٙGNRM?] }sn?CYhyJJckE n6<`>5#)e9q16iFi.Lp#723O^F/h('(=|VS#=L}+:ṉ [2%{xR 3Ӡz g_:qo]~FU+T%kvr!3^ lhݙw6IӜKڢWb׳ݣȦ=qGrj)Nc'CR-WEve]l͕=WZRoz1SsݼGKD  $V]jvF \Nd[2T]o i w[XmQFIJ猒z8USqmc*2tܞik˼kqp2q#d)[Ks;B$osgQR(ҢDtV0 $W;7+E% ȿhbOU`fR_o##z^ܔX3}'ʭl(<}}9S an\jt=:<-Zwo` A՛-瞹GDJ6Cnn%R8?܁W{eJQհTrZX=[Cl`X{lcj5$?4U3$3#JRD Uy#,ȫGއ^s\rjEJtgs/UT;啇<:NcJͫ<+3qT9OS\~'ov61٬"adH9+ͫG-4pӔyZ[4qLpI:jq:<8*ї3K3iɩEI0;tƾG1(-g)Sc=_$Fpocq_;W 5yf唧ۢC?&ݱUԙuA =NKig4h'-w)8cv =3qN8)/ݥ DmG6sUrq?wѧ%r؞)Oϕ3ުRr_‹terq9_EžZ+ӭv2;m'k0*iڕb\ nrC|q׭F՝XZujVR?A b}xr2}^3ڽl=Ӌ3og)UٛVܻUYٕ|:B%ѝ-;Uw cuF.xfΓeo")WT瓒{:ߖ#>--_CFc &ʶ>st.}IoqaC]K[=qkDc+_qY%XGo۲ZFL Sԇ/5VB'=J>,ʲ۔ln\QqQ} Y( 6Jƥ= jSlg"mAqOghVv c`Jm9WZ0N2[LjٓG=y)ZM.;twF k>y=7G%l5i{љܤyfu>kawS)%Ozeܡy 3;j,yf>zXuMlxx8k+nfF[@< !W/,cn:F髿=Pʔc1|x9sZJ6*3n$jZKݝCpS?4c{J-Ҝcn&ҳ6U.3wKVk-/m5sZ< N+ݧwj:Irm?S4lЖ+yd?ZiaNGFcsҼ4϶BrXm3wf;3Ji|0oFp+S޵cӡZWia5sv7aҁb}UB^ȩagR7'^)Y$*uӚ~]:hXp2 t_E{lfy'>8^tSG-L,k贾Yi_YToPH<t uarKGOZ&˘/c[7Qe}8b,x3*isPR6Q[yDy)acOgs^/J$e2ܟ~:5Yl?4m#ZWlos׳B#ʭFqKF=͆Y:r9ʐ0~+rL*1jG/jMwi5)&?iMQ7mGBc@׌yRi%[i6JQU^mgߣczo_[׌a JP(ydpQt{;xctWwjާosxί46\,o E Bw:܊U[u4J>⫻xT_<`:N2FU.U]^ʢ2/ Fr:qgvk_WS5"Q)ئRѱی^MnswOF}ΉޒUeȧvs^TZ_Os̹N5Mo_1YmYOmį F8[݊vt}QNgIuE#̼SXO+f`߹YU0؜O>0աnZ-;7m]t̿^szٽzpRt8ػF=G:wr|m:{]XԮmEs53G;a籘w[V}V_|,,JQխӻih}6x\ҭ+"koAP|=k!'(ի7NE}VeNMqF#09=ʇʝOju=<>P_ zTK g8Vԩǚƴi}+-Ok.PlF*VF64+G/`n>N2h刧O]!v*lO,y S^CZMB}[ı<ƪ`w0};g*rVL>n[>\,l8o\WW,d1GʟWbC6 CpN3j4iӡ:?vǹSl㷥i88߿Aԩu?"܅9U /8Fl3[cNQF]n *$Y O$qWu5>*Pt"RR.Pˑ$u[ZBB8tO$[5#F+TKVd-%t?q9+"Vktޅ",}wqaR+يu/K _$jOnR7ic*TI-LpX]W'<2ON!Y:-LԑfB-Ia=g)K7u& ֊UU'ֱI'ɷV82^nk8Ӽ${mjȊ# ^)GgHUV1j>6qzv;J1Iſ@7\­8@w<>MBDjD@HSzgNRe$"nc8qǠJ\ф[T{<$O27`x<%hVMgl$^TQ<۹TrCð44hPheM;3{)IM+!bο7cө);oV"9krHT8/ʼեV摔yV[xh6f\άg)4C+fU.v9Tp99=P,9Es[.Ǚ()Is~BRt]F\YWpljeh(Z5*3Ao'32%Ҵt(沕9J$}_*NJIKqR dȝUB'cʵmJьlk*v~+Os0;Vmmy^䕈UYXLc˗i.ӕ^HdvYn0PBOj1| 54[LI S'Y#<+HlU8ʝfLﲅLX\9mQiKL4˱I޺,dc*MVil"0˕SsqkIP2H-)冏8T 8ζwR^MG4W;]D49^ CjsY+Hӎs 1GU{J׃Nwp iOU-`omri*[zF1j[#МܨN>K_% $A2˵r<84|QB;C 1p'J?`֋_Қ .ISV&T]v_?ɭ8£v3IEr<,r s׷?\ 9Wjř{3cwU<qڹNj{8rTǎ^c|N ~[پ,˙N)1 ' Ok*ֲ{FfG(C* c{NeU9 56*FnM>6},dm{|{TӒwrZZRZeG3v{8=5H%ʣ:a+Ioc66߻ S躕'-VB=YXo @<ڻ#QBGDyc(>kOD 1ÁVUэj1&F-ܱs16F~_AZn:NpZ- my*d!(01F:jN[ٓ(Vi-FՉA.@:?U+JKM+u[L$FۅN0ZU*S3ǚͽȖ[>)فy/9E9Y5Ӕ]'-d{Y|ުRcʵNӡ2$,ITo!@팞=֑SB3k:b[e3S+`7z+4R ^QI$4զnH ˹q201%9nTdK;e,*aۨ洏,dw8үMlUq=jk/iwm J2ʴHz7+ah_g5=Y|5Ա"lXsH#ad}y_z)FZF4Mǃ cXY+$8_q[z'X1I{XpV} |JNv/G{<@UlޫW:}K1N&ĩUu3޴bh{gmyTA^率UvK4vKs#Zț\b;;zMwgb' Y1\#Fzhӊ㘠!e^vzN~cR?6wc1%jVfrm"ʭ0UL\׷eJͷ-ӁP? 92o5JMn~^4E˖ɕ*FdPOWFɬIFz3M$0o׃T|͇2÷PmϟǯF3R*U9$gB$-׷&]F1&4 %Bv己I>jדymѐn1ᶐ.03Ϡ} !R*b0 `:񰧎8OM%}C,]cSs+EGD皱sV5%$JcgԆ1i ~VoJ*HꯩVTQJ4a0HPQCS)kdDW-;Z?09w^=ehknfnOȘc*6*>3*#/IkҧՔg;@#M#crk9sK^NDU_yWR0xvX 4c~TW,I"o<\vZNӕ͎Xw#/#9)4i}SscvQר'fjJ1EYp+ qf2V2qMa ,r.ޣnNW8?ʴT yϧR$I>\p6i5:}F?n$h"-$iA֪u*K薞fYSU@YS]%*/ViD<6~U}.kE2ՒDǺuxdYzJh_4mcRC+:x(̆BKW1מտ(ʧ'>!<'׃RScA+IqqNGlg#\l'9GWl۝Ò~|Л>{ĞlL#dpv:ԮtZ&|NЬY*ˍ^st){_B4)W1r3hcTЂWO0)couc驤.ki&BvɄǾGN]rvՊs]eDU[l#ZvJQj˿^7mݎAJ-DK[K?xÊ܊~2Z6wmAb89YVOH}H]DH2.08y6jE8¤Z{ \[I~/<=sJVLu}充FUpsϡFNHRI̟7x3G7qFe7dXKwnoP;*-yS2ZaϚuV%M[g%-//~IfgXY ǓЎ#5{G}Y52MŲL°MCTEݵ`ޔ2jKhR4t8vYrU0V#~96 '#=*΢I.Wt 0{)btlv~jTuFу[!hCyE3`mV = 'I7r2[T)Mh'\գ9UI{+py^\l71`H*c۸'+϶V1ȡpT:FΝՔKy|y_~*eeNW3ou chk˛4G *ۻd;ݘF#h$]؎f @sngZƳ#bc1}*n#z^T:egOdcv񏘜 +{iI8(E( Eox1e{[k9jNR]1+ȫh~1{׾摣N'ӻ*],P+ d tҺԭMH4̧|nb蝑O$>8lsTJuEbI#UDI<~{9iN-)'X( =:g&Cы6(֨G(ߗn~bڠcRtஶ}𶶎 xkV] Fs|FY,&. tTȞEmq]}/?y lʻF㌍ s]PўREyyvbid[h$ݹxcjoBhflOsuiZMKQsQ||t[\ěH׵m(12Uczw!yu~8=99#4^/_2i1QݳӽDiꮎZbE(i:l?U^*RF t}fV3FcFHZ6;Ǯ^J7+zImfd,'?gOٷ5dm}oPm=k͙VOI+QOOK_˿8RkXH8]ԧ(O#SB|tzmJ k(ۤi#Xa39VJefג6#"͍qURaHg*u䬿2"-sxʧ'̿<%cOwnc%q#Q$+[Ӆ*, kB_ FzgkcTӣ}f14 ?+.`ghʜR2I= ˆpG9N{-@HdYH;T:2qK§7/3V $(eߘWڵRZ[CIJ2}5İf%t)AZ4cN<*by[{ZwI+&3))OQ+̸ߎQU*6}QQu=c[kcwcjpK{jJJ߸(̙}w{׭yЪStC̘nLYNT A#'E)FMZ2}ir>þjLkC$UURTq35jڭbFM&޷ka"'UOl59{M^鳊Xi_Kūy" |Jg9#EJ*li}/Bc4jY űZqI^j猉$Wⵍ:J{q5*J\ewWkscn3:Μ%N.1m\[h ̣$przqDRK[>e ȱ8˙TT0[vIʰ1IҸGPA+Jܸ֍Jbeoqڪug(^+DqNiդQʿg3_능OٜkT)dEoOvSk3GbWq߽aRU%-ԣ ݈9?KN_yV#I(FvϮ?*TFFRRvB)(CSLYTzsڹew#%irX2EpQ$UGܪAllqֳQ*FTy*]gCⰒoˢqJ+[C wYr1 0O {¸$SyFnER"y(( cr{dc8R47O[U僋{?1e[)#H8rⱌw~Db>K﷗t0ApHo/f 'ßj2[m3r5u74E,Wr10OsvcЕ >*~WrkzzuSPm=-2ʻ3%sӟʻ);VOWg5bopyʌwCTZ1f6pe!a5(p\PEem Y6*r?ƵN2Mit%7 -PH m3H0Op?#ZJJSdmFMk :4执'ԛFVoK'>M̄_ם**2:u1t/~݈嶷x$: $dOk)q3 =I.dEw!$ P}捀=x\iSn&Ֆ̼ GSw F98kɭj1Nֶ]ODSq('w~z52-rߴV]i1Z+H!|*;u`jRF[R奆N\[Oe 0*=?xV:o96wVsߨc Z4⹑8JUhE>s X׻F^NbennK&|̪zkѣZ.DcqRsr.alF\:3סBGTqW{U4IF| 8b5bF1V{\y|)OzOOÚOg-YZ_bhnV_}1]\$֞֗R7&FǛ}9=:WmfvKdYX[ڶѤy;Oo!hq,`$}:kHՊ4q'v2< r翽\=NYF+,eViN ۼӕJ{y 1qvO+.w S,m*Z݈8m8;l?yJ83fc\ z=QN/7; )q1![?|}y<2Մc潐řG\mg خ|BR -O mfUbzᓗ-KR w 63ֹdiZ@cگٗߧd6廽2x7s#ԥ(1VT%wG-}zS,Svdl,#^O,{(Yi%fצJJ15*>Ycg?֥ɸJRm ]U\n^Ee/urQco#jy}qXs(Ŧcҫ$*ŰAe?ykR*qvhuTYy=k єeN>ҚT>J$  ~#)L9ˣ3.#IkH2;ǚ[3NR2ItbQhQҹkF6Zƚj[Z:,,s\ugdLF:VF(8p[k7n{t~ե[{?%)I9+.ȶ&s8{׍%=4MIvf%|p3(lgu۪t_%cSSO]GdY oaf,<:pqʤ$W͝RuF*N4FE߾>1=s޴8z%TEgweU]gȹOA׏N[km y`+X*O+,=M׹SN".ODVvzv)TV͜w^_ÏZҔ%R\ҽ#Щ)ayi]Z~bB_Vm6=y?jy's''7̭#\2mRzg9WmG 7,צiRBclR:$E8;w:N$nG$6&t3?TXmqkq#&K9}#RJ=_9Bw"[ݜghϹ@1Gs?wœST%JYFhU | |F8JԜ6Nv;%Xg>As R6MtV5l.+{=:rkX͡Y/ݧ#sO<ֽVvhiVrՑdD7&1OzZSu+1nktf ~PހJhμ= ihk2E(jː~=ף՝lQJD2mN"($mq%} xvo+}?Jظ}XX 0goJR9Sm`)?*O?vJ4i@c6`8rWβ6_9c?.?FhQuyFA8QqUN]"B) irHq'Q4I!S63.HoާދceRiZ܉!Ho,ĩ`I=rx)sJF%mF}B&fGb@*1{u,%Jg_qt?=?T5ٔ}zG79#fR1}{TE[ܴr;7|ǰ?.cьXwGfWZsvt#ڦRZ]C- \[v'#_jeh%.2;{eI_R3X23^.Wl|T<5)ɲ^mԑn>n~c8c{9F{>!Krel6$ݼW< |槫_2]] \N6kS:t 8ge/sJps:ܖI+Ii$XA8VT_0VŏY6sp$'pS-aVt/Xs$IXrn]JsO@l5IJ^KJ6}gz $QYѤ3(e^FGLtXԩy9K_#?V"˦XcݹrAkrqƿ䝺KěPn^qǭ~ RSيȑ p#Qcʜ>隙FstQOM,U1Fң]N:iMp'< q2EFR{/ĽSs[rC<1[*NߡUrV輎sWH.?UT kXKrTQ6}:sڷຝk 0Hw~X5jNTt]eO u/*^O <$M'+zrj3JҺ6jZ5դn&]cXےw==>ΤRUJRtz~f suq!Pg>_lZ{+k}{"#F!/.)>jBѱ3#EcY7kYjپzE+\N[TKBb|Aa{GҮhfv:5"#ym[ K ^,y}+ъi|_ڷ'/!xt %K0w@/g(˖~=2QhҬExil͝dJQ੊8l̹DE`d^6m Z,gG_58irOG9k(z_+-Sߡa3/5ԓ0\g*%NLjymGjFEUEG~:W/5-E-՛Zn$r2&;?Gk~mӲf/bI[pݸsӰ\TOKt4J"ZEʶUSO^EpJ2}[<v":fY3 #YMq.yN-t*4VKG`Z9سH%QҸWe Y}aF}HnuN͑?QywN֧Uju*z]J7VkkpC &LaT`Oa>`^X+_fL](8^JpRhdXlm-ףbqtmek /q獝}A浍>Y]F1\42ad1k4Ӄ}#F1Z6oiZ\4>L2(eiY[8$R(jssI4? w0=3ںEJ2{﷙1:I'L`2]ЩDQN?{W}<\hc622(@ϡ^Gor)':<6"UH7cWVRmuVraL=_KF_Y2In쪹c63s9&޷=Eқz'\Fe(34mǿAsZF^"ۣ, ڰ >x=+l/VeVMkTXgoZ1暿WdEخ&4l?*>k4^\VOwO%Ŵ0E1LL1#֢XxШV8Ȩ2ytg?%rO3:Җkȹ]$1wsOgQPE4 -CIq2XѧS2J0Q]qݾUH9* OVƸ(t k1IegG'p){IRУ:n~r+nwGTSoOrVЌc*9Zw](՚]цnqv๴4qeXH铩+U)X.$r.r7U,\}F1\DJ4u4Qd>Pq*%GVC|2Aرǩ~e{]aTmXǨ'Q䶕>S:M}1YԆ#9PHo,UER3/#>faZW돔f ~c*G7g''-2jenp$WRΤ9%,)'y`;kTZkrӮ&+d߄۴OGJ*PN [}I&HGn?*+ї} 8j>iv;yj}XF=>TFD׭Y,s;wXnY{zRr}= ~$Xy^\m'*~F}zqಘҚGK>a{\w;~C (޲wHO ~\dM/a(+.owKOzN0o)=qn>6R]nt{4 Tg/fs TrnVbtXE2=ԨECԶ8?kʱQ;1֧֑,Crch[th<q]{UKC5g,}*i;+O[Kkmc߸**Z3ɕ fnD2G"s\(Z3ZT}CO,մeEbTsǽyx$z{Ez5+GwөzqMMlmrzsӭ|J2'bj"ʭtV<ޱd9p#\\ Lp:zϵ\ QMltBRNT]EŲes['?AE9K!T(Z[ Xާoz\t+Ui^8mp;[G |&6z.\f4uM9wBn 9I;రߡFU'ݓ߄_ H_ٲI2Y!_Q1{ӧ E VSn*=fC/ e{X Qs~hzv#-GP=:]ɝtԼ4G|$QjTK~ǶcUFjCԩNkv~篑3JRx98R'%weNMբ#eU8VQq<{N%ԏ/C/۹xN=r?x80Vǡ)_UرXbCcw*9qR9(ϤtW۵szt:Q枇N|Ml_B(Y)KK$-3H K0 ^ru E3x JU5Z$WK\Jw.c8qxt4y|F1V|_hx5)4屾7g;Y23$s!qaV>I>k]ߧ϶.6Prm[uwߑ?i |h-W\\4YEC g F989~\rXvd+wkv}+2iJ\vnt7Q]@cxm sGR6E6[n*I{N|EnWq_3Ԩ? V:0ΩޘQw_J+cTݾ(Ѩ= _ڵŎ%16 rr>ԍ-}0j&]B4|Hu_q4cSGQno"?a;h6=#ClrxJ U8f/}57c"A+LG?Z)Jҳ&yO R.KO|n3$pu$I}x,#344_džn.#3IJ_EF2.gctb͞#ڋZ4Y:GSG(nu#9+z/[$?ʽL>ҵ馞eN:e]J945k~=k͝:vGP+.t/nW2O̷ֽ,ٴt:qqgHmM!a<: ~FT敏ba( ߩ}֊.n8k+%j8IUNEZlaF^q[4yƾQ摲۰?kj7=xգR/rס5Kpi|F;y=kɩJR3OG[wEjFڕ¤S8 4jXevs}+l,"U[7{y`rnDkwƬKEve+٩K_Skk]y?fQ IO˺eZ[4J{m}N^'mej͐.E Nsۦ1\i4߫sRЊKE;osGI&w.o/(˸|s qv8.w7nz~'e'6{:'y}ܾ ͤ%ADUVث~' 8W+Z[c tJ 2MfkX+doӀzkɩkY| 0t |Гˤ Fp眃H1|uo1thǯ}ORo)xx<skQ-:CNXEԅ.줁cǮ:k1jJM[GcυYF>ͽR۵]̬7rr22O~q\Ƥ_,DJѯ$,̸0ʪd)<5e(Դو]%vOqfX}˽N`i>i w9jF8iu]K hQd;H]p^#%x?iN<˰Dm@feccF=:}: QƜcսR+i;QLĻV6l?%:Ν;ww}`sLV׭;-Z5*餙1)VBFbAy׵oNnp,sۑZJIZ+c,HTs/fKvdi ʱUfT1k7_2rD.D_n N~(Qr]*Jm++292ȱ-&OSܪ^ۘʌ)(+.i/Cy,mA힦圹R:)rzhSkVl l߼L{X]1cgͣpOfJ<ɹA989Ξ`#G_BM%ˇmRdl@$=sn+Nj^"6Th &2"QTSV6+Mlb#jj˳{v9c]:6",.̬i/=1*cҏkhXKv*Dpi;zzj7wS9A;[2Rj p30zZTftc>Y-ח_4L3Bd!W*I9tkq4qwĘn[Gݕ4o.VI$;v'{: l̚wh:OQM7`RZGuT;njc:|i_%:;}Un?7v9SlvMqq؏sO){8;jrԍ>[Im㸎1+N#rXns?yӔ#;w2BRi=օ6 K78b?<ELjm~M^q<"H22X8Z/NŻ(Rxs,w<ed'.oR1J)w.ޥz~HVcԱmhAIne;:KMBoHmIt\G'ʳlJ9ek"g[9efLdZ(Kޘe0=AJ\3hGQQ6׆ ^H<6k9srmFfoqJ F0jdF<|z*Qη-G v+IyW*^ͥz=J!|c8>[\*w$ғ$ma3HWgA.g+Tu!dsUO${\yly)'>W*ɣshT&le & UgI,f*# $.]5>e-v̠ayZ٥kAr ep5yc03z"9avofr{ZsZ/GR&H}NFNUǚZṚ(ja zc-֮Jp۩qrb`cE "sWNKrs5Cw kw 5kݕɩ'v;2eq>^v(F<^ .|;=k?!SM4l-˨±,w kltԥQr=mlDY9נ1)r!EE_(r:7?'QEU*|^3GnVh!vVr_CWiFvtr5*˴suj|gRT8^uf=FV m㑞ZКrvba}qҺ;hͥ5nW(<ٕtP^oܯ|Ƿc'cUnnkHWjV\'{Vu*Sh_s ܤW)G:WEk*u#ha &R 6HQQWka>#+F `0 ;)rqUm]ؑt>EԾ[/KswOOn:UQ}64G'({F![:׎٪i$/fU{îZCxv֪QSܸR{v][r :~I2gJE{z}FON8qұWN-mYsiD l(ߧ]<-f cJ&,9kӜzJQQ'R*59bv};FIfP8QPm'm SٸEgqӊe^}sUYrSI5g*m[e+[w8jRm=Q:#щɳFeݴrZF9[Ԏ.GypG@=yTEH!ִk_y"g=*N]v&#WĿ";].8o? z tJҝ7vcOTd $۟3V0Rhu9+Ni[޻o!K_3 '֮1/y#Gl!_߆f'vZ猥\Ҍ#\w;v/SߞʵN^QTrYsCߘʥqn|՜/F-ȝ"U2BaP;s\eΕa Fq_DdOe%R/~9t/Ubh٠k+Hb 2VsN>AQq^lviDeۻ;19:Y:Min­G ${mpyEd^4Y 8ZEr摩V^YD`{.7#/yث>XB[y#%@<涌Έԗ*kb+9a>fݒB1[[q; u^.1#R;R^ ЬO0~}3Y'ÝɫzEtaAwzgQo5851c4KIVEqxUU'^T $XC~ iwtiƢzʢYWaM͹Sr KP/uܴeYZC򯙒7'q>X, K-!{žf.kaܭ"xz~fOV9iPz*12Gۻtz?u5*cV_2MXUJ< jMJ!o7zZ1Fn2)PG՗sr~zv5JhQ3mU}+9u&-*NgVgݖltޕ1.Š溗C69>Pn\nǥ\RcԊIdOUY T`ƣG[Q {ቤ2 `µc(يMF[3M$ycOɾ@3,|<}}zQ|EvqzD@~TS7fbvIwʭ`c֩r٭te&뛦J?=z{֪_gR\Z Dc}(IJwj9*Z9=ʒ:.ѹ9;tG܈5$[ԏ%PyywN57Ъqci1P`qО 1cWF\FM#:۬jZ)c#.9=(ktFjEh9.7+ mPq9;ӌ~gG*.x}٭kČW1Ӛu2[8jX}Yb;Q;4e:4,dgvpsJMf5mfYG΀Gt"/4JWq#uqӓeb Yg<~8ZԂMu?x>c~QIT`e7סԥBIs59TR,1yUF:\U{>ib[.K}*{@8BrGn?cBxd5c$\ɏ19ד}j%ʭ:jjhX43.\Q F>Yl%16g!JFq0*SR~=?e^.Pw2xREhd=:LTƴW=8~(^6)˳)`y+)K5*gM-<2\"8IuDQ->JJ-ޤ%_,qbxePZbv݉;Xdr#(TyS6yIlgb9trnNQoU"$KR&iec\y]fEGU Y,Vڱ Uu/bTvߡR#/VnA(ԦTeBoS*LY dy]UH0W zUJ1s:qզdTFՉ|:z=iݙsFOvܞb018#~мFb1+ *ML^\*s3J2+fy .飗s8GCZ|G3Ę+zWd(u9O9N^uu5O=Uz5<x]jCvdʝ/y^Z!Hr6'cn,q)ϚsQ*NܻloN$+HʬFgU9_jG/aTdƥ(~m9;TW̥+jqj]tcV?:-p~PkNnh'=8۪Dps6ey9}W4%{TVbrJ"E_|HœHf"m>|33ck: =3ǥ*.2U[BNZ4jKs $#v$t;_.GRlf^Ǧ+.WgKV2Tmi7Ak*U99pZ7"Bv/EsT}*Z/ĜD#ND@mvgizK_;9)z g7#FwHBJRUڮW}z+"ExʬVO_*Q{G ۹ee8YJ9.]:1.fΚu>gI^e?yMNY(rn.J[&7m[oRpJ}0N,<$# ~+Ru*7ӏ"y/$,RKezZB0M)|]~d,ɴ;?z*qlu#)r_iyߖڊ~@w9zTf(㫹aX,o9hU9O(r--ilmaU ak9F\ԨS~^Yy|yutBi~gОXgﲘ›Gl(!Rp@q)s'_\r2of`E-Ёgְ7bp9IXԊ+q6%cn8]2kňPNPO[3Kn/͒h0K`n9@sYGڹ?wDpt#:z'3ĭ cw$2}~Fت:Fƫ*,Rm!z9~Ċ~k7EiS^Wۣ3tn~O͌wR^3?X1{ߚeE[1$z_[)]t9*Pjz_th3W̨@=|񗺍e{G8$hb-¼@}GZҴu6H#31y6vW=”SWz~w=Y]9ҰOSJ{˦6p[ZU)J[W$Uz#!hW <ȮyJ)R^pZt̒En|CKl"PI#'1MHӖN\G*IsۗRAg $`1{՜(rJ i7?603r,z2RK{Xo/1MGj>mofN_G:NbmpnkڊyHϥ\)oo>TQJ2,Gg32GS$dA*]̩'yTB]٠1"i&9sVu#:ȮG1j ӎXEƜ[sTf d ;ti0UiViOm,oTTN:\N}BYW[µ%W)ahT 1=kB1J;4])JRu'ޟdZy2w1UUT 8?2uzy˩  s'vx##cڲGc9ԩԲr4g'\ƸVelҲ8i:t[[Ũ *cʩs={ ҭNkaNqU9d?O"Kc1]w7̓c(r} BVlIq,mKLXmº#4%{oԌ8d^쩝ʃ$t϶~WF6uJT|[64.*k1;ckݣFSj.x]46*Ugӥ E%4c+~Ƶv_ı>]?7<:vQ쎵)Fҧ˶j<W'Ч^U;zԞ5bUluuSUSqVӆܫ+M~y|$gj4ۖ迹hȻ Esz~<7ڈP:i1-ɡeN뚮1ק=֍*IZ_ɧ@XQtc] rЍnf8Y8n}3eI8ړOBahddm¹^FNaT@ScmeJc\v9447b.F G9}nobwԥy[nam^+QN4Te+Ow=xJOKu_N hwdݮ8fʩth5Su_̞+nm-^ݚO3g#vO=OMD3uc, }敕3CbGO[ԣ߱%5֝Vw3!E{0cHS4 ̩ĠniƦl_,`ͣ˜nYh&VɺeW9jeYs]#NXIGCtXbpq9)Ilk.Xu_4LJIAӚiB(J)nYQ >iJG_vU H8r9p?5G8xWoԂA =X{sָ˖: ~UOS}V :9=ndb"2ff "z';9˕4uƤm/rRo/?6)rэOۍ$ XF1dg Q$*qR'X6~R]퉦YJ2GҼfz3֭1*.G\xYKߒK>cN^[; @VdYXnܠμU2"8h ]eb&GT1.1?ɬaNJ+D.h[Nm}mV9|Hۙ=}I yxQ7ш7&9 nϙFy{vi{znaR8DWj-ou eTfTopHvϿ*c5A ޛi5y%e_ 5TAN}t˛9Z2.&vEXծ6W`ws V5#MTQwMeuG(TI'wojJ8լʩUU/0%o'r/n[k YyHr8\gp=Oj]N]P`A^{н`nc.xϥm)k=Jr6q-йhX*@WeJ?eRyF}4zz[B5Y;B1[SO ƛ=oy6232|l[@=z׵wQZaR9KOm/i[2Yخ۱qO3ӵ}&QD%Rդ4spy}?JRC1+g7o2xuQ_szӧvڨSr.3?zir^;a* R|A{ץOqCR1gsV>ۏZ.U(U. i61W'.Nx9]q喌1iX.0̀sOS]Tة>ѝO-0\W5$io6UB, O]T[֔g**I" >V?αuJ+T*MsE4{8$1=1F|jr/{[hQK7AUnUs3`֑nZ^oCn-RIRLe#2S,q9nsLZ$*B-mRIazWtL)T|0Cܹm+b6qߧ&EJQQqq"2d[߹iǞJ?cU_!y&#U'MKw%&{T++6coCTʤ.-rs:ҏ'aVWٙZ=_vm{zu4nc~|Zʒ@ܕʀOvoS.iZiJ[~m3^>]zحTèGMoסM6߹U |GN+EJWagcyLX]a۝?YTvuqZ_1|NcOys(eV۴r1x ]IG#dKwM&r<yFxγ QA?͖9F`XO?J=,J$g/YV"2mngҢ/1Jáj.`K*֛?/LUNҝSWٽS\`>zT:WTLDlKZcV' Ο,dse5oWyFUwU1ޖ">;]Q.gͥ2*)9moϸח+J:wVI-zvXn~KGܞYREX %dc4Aع+~}QZ^B۫`62zgҢΓqfU*BVq2J JHaflk){?5M7yqyPH6~֢9FN`VWsm6L=~R+S*Voh"3*psߩ\(^s6$z+{:݃O9U/ݝTB$4H@rcG59gD +ZE -6EVn]z715DѸu~^||ȸRW]dX@Ť#wկ-nL'.g7W!4,n^ aFxk^^[BOiMOc0dxy W+{1j{:wi/#itz)xRpHY-!;2ʐ*'w zWB4o'{jg_:p-,۳:nj|ۿj.~(sOGYLJټݲ!#okH 0~uQQ9nKDIȶEr۷S$ˡZa+Vem[$ehC1I*rrX J)Qz"kQikth%ͼ3w2njgڵ8Gj+I4+" 㚟ӧCحFak3Oڦmox<`qH5U#icݙʟ7P6WD(%ωL wzmR9Y%s*tghlIjP}ې0==떦kTU#e}M;X*%뻨Rz">^ҝ$cY1GUOP8#S?3 MQ=mM`fL$"*HܼӶ{W',-܎﹭oF Y;dxk5[J o&i[#/N]+ϩ?cw} SqҊm3H ;=G8\d婍OgijY\C0iHrW?/ڹ+/h,I44?rJW ,='AD~+vz䎀sї,Ӕ}1, a_ytө%G $J`ۆf?9rAIUR6J+2r)HaiR"@f_DOˢIujX`k9Ӑ+6RRwh175䎻B\ O17r׷׌s-b>/m4{t|ۙv{  $sSNJu:.HXpE{Egj|kQgvε4Z%ҭ> [1ny\jV,t)h0Ĭbp1t5yl)GS 7$W],B;(W3Mb?nNxPqr}Ψשtg滚?,;jKͰteyz~LdSɎLd^լiCM_o"}%oSR,LeȪc'=9'ǥzZ>V[#Z1RNg{yq?ֺez2)ͤWVe-۶+8y_"+tZ n#yqq}3YՇ.\UJe{q2:N\nMJ~^"`czUSOX1~fK},goY7cKzs^;ѧ\>.fc ){.ޞqiy=|F6|͈tX9$q"1UyJtoQFN9Q{dK+|<`UTIB0TgJNR9eu u5FN}>Hƛ[=6z-'ނQ)_2  g#ޯܫ+mgOR򮞛'e8_)7߷plϦFqLeLj:Rn*=RƐ|\F W Y#ұRvMCnH&_C4vvFaxdgj{r?Z%LR嗓4s4`<_s œiuqg*wVd4_2˳a n?b>[q59VQ%[^JTeT,&k d}+h+.c[iY$|Xgonr,#H^T(e'vݏRܫ3Go۝ܷFNj\yՉreYbco噛s/c#ⱔyet\Q(G"()\¹EN-s X5mߝs4LJ<(vv|Oʪ^ hKL{Eۼ'oιe ?{SxoZU]dݐ8:WRKKn˫[2.teC2 kϫNMG[˛śOQ3338lrI=y^}jrQ,t-X|m|8'#'G^ĺU#EpTZ$e@.##GY,FOxVݎ>"-P+O>Uf[vF~#N/-EG?}@ %+/c-S5˸%++/CM8IXփ}ȞK.O7͍ RL{UHv^-ܳ/-,QGw:51Nz8EZY-AmU,sq瑁m:OsQU5 ǴkչxXo+a\fsd^Rt<>3.h)Q}&ZU ]%v>/o_99 \F8>Ք)ֱ*2ӓyw4 )o u?5qhu5{UUrw2#M-ɩ.rgٕ6ǘ~`s2qǭ{e86!ў5>mYY@ UnH_ =/V5emM?%}"n3'^h.muON>{oGp^]:>^M>!^&H! 9W3rOaOhŸ {UeAV՞'e[Ik d )F}xn[9sl- v>mZĉ#7NqF1_*C-˰ֽs%4/lFXaU݆5>;"+mKª`"H(? /߈tݷpG.Ӆ݆G=RTsGKv)Ԕi{62AjIȅN9x']+dS.a7R4΢l9 8yX<}WVg&xRxVoݔUڽTʽYFnh&j7HNN1#=tˣtϬ)Rk[A"٘yn_G5N+՜ο|m =yGtZzMNz,y|e[Xs?B~*6sԣ;Ody;d )0:0M{MF9o-nDIZ 19,zخ=ީ~G 1߾XYʋNi9Pzv'=F+TWrB7Iy<⮅wج0rTu|(A~egeKݚ?-u籲tK]\H!`2'ݴjGajad5k锫aRiuvo>iL" ]|t۲B{ṾV[uǝSR)F-kZ~w] G []R~^-Ӟ>s[]M1SO܊Ş]cQNUytaYc z5گon6S єԜ=G]aRzў^eG %84k濭lpq׿~mS Tri)ngsu=w^vc`02Xdv$~oZωnm&sG5,~^91Y2?CgT[-g"YZMgZ5 ) Jݹ8eg[Kw>_Q$2τךyr#RI#?xw*XԌR}5 ]R;ru13_ҿ9,Nz3WBZuݥvZov2[; a_fZ2NM/^Uj|)[чSѳE!╺TOAY$WvʿwgAN8GZP+Z݅儕?F-FHX yS(>kQ4}U)ܲ,R"Ϧ;ʻEbqa$i#V]sUtB5ct(W$60"Y2uۨN1QkyP[YF{{]HHn&6bHשuS:5*rIi I6`68=XbFQ;RؖX "2ON[#IOʳ%m&3жwK)r2L%2#,p: z皩齙TK!TgkzP=jϣ} \Fbc#IpP#CB*-_W}M!p۔`n?ӯJnӹGލ{dXtgty.fBJn0[<˹pvkXjK*={m<2VeF-@O>~UR5#QEjgS2[G3}c+*sӃ+&9ܪ8$sLK*wq1GkRZ)"{U6+ˍϠ2mJ6dC8dIVXʾr9[KN5.%%Pc7$+  z 1JF;?~ƒ:ioYl;r>rro0X |d/R}ԣKeJG{4)yt.l ʮʻCs^W 4{aycoMy8\M;ݢcE1 |ۈzLym+=nXX!Tbv8>hH*o#ykš}:%ɢ'ݺDQFv4+^:A2yX]A֐۵c(~Q"=hϡ^Z>U\]u5Taʴ!w;)QnsVE4ajU5[VG˸ҴwF$0w*ާN/,l|hEhh!r n=j঩$"/E~O8S^'~A #H wm9U˚3#63+4vGU9ESRoFP4Bl 7n|~9ɭ%'ncJ>Ou|&dq+!m9Q._trvZ#2O/F3'ڢʌ#(;"X X'E9'QoԴB"Y;v;I?:i;mjuWyoS U0$R(~TQSE,Q]V՗ ׃^*chn%VIH)> du u'ڴcw+_CFn׹%Q!݁T-0ʼԛ[2ӀMĘzrWQYuQڴ~jk6f@sA?lI\ti֗d\7 >cgAkG2cO}2E(lJ~_cvZ2\JC#Kml<iM[1UFЊ6&ymvT8}ZkhmMy(i$Jb)q`s**r#zS+};-O jwz}}*jk̽[[-YS4)Rudf )؀GonN1,̋7;skW{|rRϠH,yy'=;c⧚E9+ALw+3 grp\ױo:PveP+FH ڟ5I{۠ќn/xGUV5rUV[Lq''gRE̴{*{41 #uq{Xi)MkotwF~fs(wwYSrKdVlEn}Gc4}y/:Jyn}#,˷jW v2єys=?!Ή",.*B^qb7/Gr6)dGʪ2e$74db-t #peOL}+J]^u\Ӱŷс4Y\9|SQk~ڴTa-++,n1e_OVPլ)`Y[67=y7rRU'5KaIV [2Gw=뎵,cy9 ./^dF>rltԔ-寗wWw/01pFI8qWH,$p?.Ǧz ٷmsTVjEK: ϺIr:ZJ馇Sݴ?RP\c;׎iJmnE%Ҙ>H䐃ԟ'*̴{h٫ i;FۆYZv1v -c!2Rz:iE'(8T_NI r=17 ,A kєN8^25ڗ8mk7^Z#h8򶻋-hfyeX<B0y|Z]ӔSQnGX[vi#_"zc۽W5h84!$r o"7̱6B 3>'5oP_(`Ŗ\v}z}Dk[]F%ɇr|sq|39SWh)؏y1_-U81r3ˆEPA9#\aSSBxv>ffډB=.em5%m%,}$F q4,ꔹߩmuJF0N ^3 tDgtlt}ێGʽx5R2ҩА瑙vr0w`8\UȽҟ69'g*-~^(m^=K+)KFoOVE|Or^Wbwy;ҹqN{2TC 3.~"–чuVh e<ϵ>gm)FK6Ko)PF<r82i9YHҪ7})Ֆo 6mcw}9[).efR$BB-||Uڬ8jkRa7ܬ9:zk(%%g\ZXّ|y>w$Tj1F<5iS×G6m,aT5rytG'(2rl;sS%F[?3}\ҋo:/xH:4 CZ27$dWqkq aN[^~{=s>JԦZy.d,ye<8}$ܺ)G͌/G=N8Urr(+fI-\hY'z'O'}챆5Q+Ö2Pq"C_SZ)FS+ʼnz6{7&3|}vHaI\"|nzWqImt⹧[ Yݸ^0=ir/u#ЊImh$ 'sq(ˑw9h; 0y 9QGn.kX pȲo9 Ҧ1Rq맗W7meJN3t=,s1zQm]Y=Du.S}AW4]1N\}n-g; ~ _}.F M3 'kޏM6+hDbHўGǹ=*%)3'FN|ay}lycߌT5#%F4!VRخd?sNJcӣ6kwZ62)#"Gp+JrwW1J[BC8o6Uex8kwFgErn%d6ǵoSӷ{V.1nfs+QDg26xcS^F1z ۚh]V=PlG+#Q'(悦c$;lgG@hW2F4N~˕H0ϥcB$Q,%Y72ہ>'V8]Omё\k$j$:q֦0oX#/si}XƳyh$"$)LVӏ5{o>9U%[zgͩ{JQ[d{3HR{tQ%V+O=$ym,jf=x)oiFYy8a|P AGNMs+u:*S5r?êo~d9^K']Y 3JJWU{$:ʞ̩*KeFz9q֊qƓQQ屟 d1B7|qgFP.9'com˫Jv8@*JL5*ԖBH r}B3z rn݇(VՐźbUcdsϡ8+JQ~F] qmagb$%=Gɫ'mi!̑E.6|G^溣(MjMgZV9|}dML$ZJ\RKVzª5UZ|{yfiFݸ{|sS%'%R''fTQ\߿,~z Ju*Uџ"?qhdna~|d0:WD$b -w#[iHcl> }1i5n6:x5-?4ҮfY1y;~S^58k#:wt`sg< w]+-zXzӂU[Ǚq'SDcoc 5RQrR ;/فmlȢReOO" ,8# qTa){ѹRHe4isct5KN Z]5ؑde#h&r21WgqP]*Mikw+uO9ckn*|Ԛ͑B)ܿLR/qQFI=ZnwM>Hw+1i$n;y*^nu#SyVd'dJ#U? a?ֺ]w:)B.wn]x.mLp{4iգMrTn7_* fXMY^U'dSFI!XolR1(hyPtz"Yۣf ;kFdS|6+ےO~$% Ac_.3*̣@82+VN䕝ݲc.70,= W6RdIrdc,=+ṷN `V5®<dާ^y%ѕhZ|]+϶,O鏱NKy|[M#st?TU6om c)J:/zŦ`jrvNOϭaZ79gFZ 7r3+%i[2ow<fq\2vGutJ8QP)f;Sh\QѶj'l`Ww3M'`q◴m~Xэ8j]efI3\ ={w=>i֌m{-l^ XZ$ϴeދg9FJT?Q$s {b|)N^t^6ڝl)lF+I(˕WYGP@MkNJ01Y-Ba*v$ێpX qZիMJ˪iܾv_!NʖJN@%w7=eN>q ."Ȫ )G)];3ѦKbW]z{{Rg**z45<٘99xƧ¶}9IIZ*ے1[b#M{zҷ[ȭys>hc]0RyZQV̞IV&.FRYw',ךʍG([&!^KrHch.v,~wcvֿ,~Hp͸JyG4< Y+؞lxE8OYcxW;RmOfQZUUiuh<7M \G\jNWa4_-np&0+/iNWeScy%:x&ܯ`&M:;kXM4/ub[/ٚj͏)rF0urDإu溓97eVjvTǛ-W*ӕyA#ͪ (~fʦ^6M 刧/uI"6HYa3*eN^C*x|=o~t`H d*G##T=:m4.ZmiA,˜sgWOg*[ZUjWJb[x #?ZRP٪},>;FvAq9<\V6zm7-m{X_.>Twp:R˫w?J3թhd, Be{jzqQ%̤ET%{lH]w<+{U*-mkamR*ȑᙛ t{<{:1'-fUGϘHgY0$^ko)S߈FR;i$_.Gݹy*SRz3=}{+>g ƛ%c?x>A\mF+~ާbj6۩5}٤1ȫ&0y1zWezrHkNZscMkiYg=sju&mJKwmvkoc,p1ܡ1>Ѧ :hΖ_MAE;멭cԷ$nݹ<ޙJcQO*qx6V_,A<~J/u+q5&BFW,Yv̳v6W#9\4 ۻI*=8(:Odm^km_2eٰrcҽ:J[#4ʛN2^JƸ_j0\mA-O##uٻx힜jrj}H䶏̒uc" pzw5//ui(U܆F lm7=uwx9h>$d:u$J~֖C2Oeezy$v^8+Q5- CN,D&H«(p8MF0OZL';^N!$\NUa5%Օvҍ\k:(](r_Eۤמ@ MKiS"dz4Ctk` Pq=xey6+*,E*Zޱ+ȱŶ=ˏܕg==aV6ۯnŪKjؠ[In@lg+ҧ$9cONm=l~Erסc&" t9!zOi.~zy}^X^H7twڧaǘۛjq9I:[_ޛ$Pl7#@B̉T|V}ѓ>R܎*zS*5ۺ\l `8 z3]tjKhF2*}h\/fg_:0dی98ʧq|~;ht@NЯ'}:=*dլ͍"Q$A+HZDOSޕ7gNkkZ훖Mbg@ kݣZ1z+]OB*25TevPc+Ԡ̥Udƥ# ?fx+xӔmYY frF?,E4N*C4E [۞sJ2M! 3J=q/TReQ6a?-NwQ߯R^%>}zc*|]9T+L ̌ϱI%̚ER2I [ׇ=\ɛӄ!WpjDžݷ#OΈ-*|KC9?Z9%3Y;[vC[JYaen51_,k'nU[-: g޲zcj8^ĈѩeU8#󥬵{ۖ;4FwN8y՛#cYUE6ѩVڿF1қ˗k LXP?GOgՙQ] ڼP:g?AYV޵EFG, -ȋVU2ه8*,5$R]u4=0~m9x5Z|z=}r7/pr_|ѣcj{ы1f g{gӌ2=%CLP?#I;C{ɬghoRQ5#f(F8yQ瓚zcJ\I-ֿ ao9`EMJ+ Fl%Mzko6֟u~`W;r[6N+G5n{ć;I&Qyky"HofY>\тTmܸ9\=y\9iEl[I ^Ik'<J$qSZ4c$sW4?Y|bR裇Ni-`k;>Ke¨10;F q'Wp2Uqs4kE1P=AG_%j_ݜd09ƪU9㈥:\#CIiWxJ8{43\/XHFKaRHK1}<=s޹::nɕiF^uh}dDy?kN^iZg<'5{Y͝-|ٙVQ?[t&^;}VvZ U$Ve⳨ZF\-dN]6YW-:rJ[S)n䓉0FpsoJƥYJZtѡ."7*ʯ$A=9oZrr*r{h4HďpP =Gc,uՕxCH9BfV|f8iiqḘrթ(aNQŷV&&ݰ{W5IrO"}ztRQ_.-di5Yʹ3UE87iJ*-r~R:cIv;s#h K`p=A VUs@[G"//|s\u!/-NZ5#tg|^z2y|T+1#2),ꛔ`p+A(7[z."MdTr>x_wsϕJ|˟Ef~amEؘLBH͒GϭDIݯQƞ҂zڮ Trv\oN5$XJ⹚j j|6UxU+rFQYq5U1P/HuD-wa(1өn],r X01GcWuJr:+Se.fm%xV9|m>B98 4o,-ZӍHIۧ*?CB̤.]ۀ֕)N%/v*횉q,&Ǹnkle2_ n.Տ3XbKwv{9BN4mv̧nOָ-^Z.Cym4|`\yp/2U.T}BDqݫ4+4-p6'Ly'us/hQreXos<84B5,o8a:J7xꑃ޳Nq2I2uAu*=i֕>NNZrKkPWh2Gt?ڱ)81.ge6f\.#ҹNQݜ~1;;=>)gX>\%3Fy}E8ەыj:KkKr *HHZ߹Vݚ6l- ܘ?.хPT{8̖jYߙ}}AzKi1QpSmnj/zgDh*Včn09yueuh軧j6ZtT{Ϸ9"'oNlg.9 _Gn{U&6F@5ecJUKSKH Vl C#񎕵7%)KTXRh>bye٥z1SzW%4kX8B1?^9T$cUJ.0cq6+TyeOf`7 >Kjr],,'Lώ#Um9eJrz/=jqע!]B7Y|-6FG>jS|]N?Ԫ9tZm^9|Z8 ʚߩ,\c֮J*t8ݮ4{jO#=}^XƟ={hX.Jp\6ܡ&]hߟ¦ԕȨЏ|-x9zzV^KY>M֖ZÛZ{L4LVO#z-te:.hr}O̍?-Dcވik )i5E[a?7$h''g:w+}#拵L: JEO^O3k1(;L-(3FYcp3р翵b3[y3<:3tndYFm͞4JIӰ:UԌy[}ɖ)<}F{֪Tw-#:X,D[Z֩40oAOyĤ7tSyP}|ө=u~eTURwvk.7fPa7=r O5OI_0V1`aj4ٳI M7e_'h ~Tb?w%ORaOI'YY4{G"6ش| |gsʜhסQʴc-R}PsGˬnF=x<S9]Əa2KKeBs+$mRڵt#m۞⶧#]4Rw< -7xsִ]i-^G^x=zqSs Fђ$yc;[$ݞ8Ƴ\ՆvH$?˚9]lWb2.rsV3Q3_q^YQ&W߻$l\,4r$.oٕAV]-}pJW2Ƥys1LיmbpK- I ,oּ&ʜ'G9Jlm%'Z{4q{wSC[s@c\ׅ2m,6Ω?GqR!Qp1WVTU3QEJi4N݋3p1֗Bco{M4-D0j*RG{.R;!izr_yr푎x;G~xӏOSnjrm6hZ8ow~ѧ(ɶ㲜ckzw/.9y˹6м27eӚ=5dmGS ^M+Cu}#PѮ4IendM:q cOº֌wʷ(߿~$Kx:ǘei3/< =}8ժSZ颷͓m7LykAN3?fZMrX<ɹKrxy+QW3t鸫cאH8 qV^E,'<}Ki{n&;R<Ѓ\ըƤn׷cC=IWbHc_ĚGF*^>gujμ`cx􂶧-\/kt9 4a'U,?3<`=7ե:5b 潼QnAqyhrNPn+d;r2oG4J>cOig-lgtq70?8t>`ܹWOϥ遮e19Szg5 ފIh?'/Ckľ1m/Mh1=}U=|c??.mtخO)ZFd;zg#u?v.{|$ʣdS?5p o/ n3~T*J=@dKn)Uizθ!))z~{=V˿ݛlymr1Y'z|_+j $"V4->ⵜJRN5rr6T&˖f|Y} aQ٤wTi_sz(ܸW$c#xXAE)&>q[<1['/e]+^o&NgѤvYw_]~0<5 V8ym큷h_kͭjVHQl>02BµU=^U6moNw\ԖMzG-?7;v{5ݵKS.†`c,Ǚ+O-ҥviz]۷{=,=Hs潟+Oӽ]xK\WKS%nV6e{qҎ#ڶ~s9b0%7C|[ZlQVMO/f.X{CoKcsW\+<^Go{GI|FHcevo*T͓Qԓ嵻2ũae_ݦ/6S~Zc_vw~>X6[o'f Z5]]9WEF1--s"`#5ГVgg9s|DFF$#9ԩˡՏ$[W/jEU.H@h)FW1]I{ǖ>};Mil!Ug^HѦOE)X=yRWHJ[ĺqл. 2lv6"RSSp_>ϱo[gd%Pc _i'Wxr=;CcM{w<6 t ㎙5TaSW߃̖ԩs _]k&f|fIIY7`R\^iu#b%e}ӧZ]Ww.'{4fOe)E54>}. $^wlޝ+LdW'kv>S:*TfM-z4-j_OeA2I$OP;ϧ,ݸ>Uk;'dkZw2NhbYWyTi+:饎Y[MM)SަoyKce,͹SqZIJ*QU+#e\~ʯY_!b16Iz2#r|[~ֳ:J>n9Im42OtQ롌}9'>.do4.f=ZKCi{HK+n0ɼ>_ -Z?yROo̥QʅT̀3Ͼ+Z*;ԣi+F7W̾uUb{;8$)JM"ovBqA"azӭeRFQ ' 6-׎3ҔvSɿh' =eXҕOqs&sS}"U=آDe*<~ZZnL(wWHNS~08=%s{ 5(g%ϔ.1@<#/yen(h7ݑ׏ιGvbr` dU~nu~*MPDJ-YsgN誑|\QͰڬ=t]aXe)D|hJ6UpzíFV U%w2tg=깒jNNT Iݸc%IJXs0qOUgH{=.$IM'=ˇ hn@c8V-v9)"r䲐ӌe#] 3W-IЉTfs *o_njU&^4i s6WpUG|nTiJY.RGk -~y}#5'dʷB "z瞹Q.Yh_$XY[Au){nO*\C"1ՋBcoN*1mͥy?C>]4HNQ=_Һ**>B)x=i˛xhaMTze[yܭל1[Q*W*qXUDnd}hI^hnR札b4QxAiT$pǠp;LT`ф* tmcIIN>mnF:N7&1<:AnFFgǰJ^[}$mȴah^tEi-OJ\э؊f2먲mG yN´TdV L;NL\9wN<5fHH}}@+_g*)h'VH/q1RDc*FvϷLTMG]O>U"۲T\8A#fɻRbҼH%7>M[敤,<y~UP,oSHXd0nESvq~5.|P8%DXFܱPRHVw $ln ˎއֲvax%%r H#]v-"o!(Z ˆIlA@3\`XKMiKT[Yl$e7kGw3k}*RM]=zKtV0L>W NA#ҰJrTpkyrnQSlQ*.d%eU\9#=JK]6/j#u2.07Aۃ?+y- TԒ&hJ̍C_?J¬Zu:]~d2#yr}=)QԚ2t#pe7/{Ӳ6m?dDe0 [a*cϴ3*]S Q4,yu?Ufͣ絊r\Hecy,V9SV-uƗNG9ra_d<t8~~R7sS^ݶ=w3mɝ.PJEi*DF8ԿmEq0U]>ee#RHF:Ww,hVݏqǧ֋6ã[,Bd嬊vZ)SREG,<}޽:[<׽]o|r>}hhISU(KF-KgvFl壚u}v9Ӄ\WW\_%*J#)4̟y|0ǎO\¤{o"DV;4UU !{Oʽ*R"שΫJ1jhVE$u+OrqP49;M>bϙE;0}N N\#iJ`G"3,j͌9x>C̥Nv, Ahoʾ>?:#EJI/\ެZ-Ÿ0#)5)STRٖ`iTO, =?qieIh@Ss}K|ʩO6*_D fnNJA;NѼ$*&dy$} 1勺*#WUBhpbC|GMNnowb28p_ ܐ{ַ~HIB\&03ljv$1X9r֧JI~d $VDZ\ִ~nNI];~_%#ڪ2|ŽJr˩kT{DPdlyyEP y{[Ӣd#BAxY+}ߛo8+4Y"{XKВc]e$7G\?ֈJts>^[ש4V-ycg<3ǿҢIFIDӍ>ZObVxq?3rkwʜbW7HOͻ{n'ܓ֗haVR躊,% J$}u"0V\~"M̹էf+jY֒@J)Br"TʤDhZZ&ٶ`N3U)B] =jq[ikbf4QW8Q<6[Fǧ_ڳ{*tC+qǯZ]Tv@SۍbGz{\rW{lȂ4_68BZE9FN}xgJ\+ ty-[؞qO"0n!w<<}+*wˋWZ=AC+e{nZrrzdX|6Ud9cӎcIkQSܭs{;!zXxה*qWLZki)a6; ~ՅI'x-]6 l/~[A,&Yx϶A=H)t4CVwdc;u%9{MVKعKF $-<$$oϡ_rQy]HUn yLL7|Vs⮝gJfX+6,Z3МWoqV̢]7m,lnn>bi?z茧Gbg8N~{)X;ҺowFLӶoj UN}K ^QBƨ3c~!rno"{9L $6ΛVL*p6' AkYV'G$c-ˑI5P&} qmTs]D# ewݽ{¢[&^].E,p rwns`Q):"c(MX. I׾6֑_i%5סjKvɷnB&Vvd3$qO99ߌUӞҍ,ڢLc ӯҦUysyTseCVHw pޥ_B}6>7cь9}S؇: ʷ| sO;(ӌ~={pMU;[!z|I(ƥW1׈[g+u(5cIէ*ܷђfGN!;Ӛnn-yQ$YBa$*k^dPF8m>ߊ{SZ9m3~nqEO4yEIE P4\\aڱn1љͽUR(eӞ}ynU@cUn}g)qfV+9ڎ"ZjES̜8Mܣ=.7&(j9Uў G+GqQLR|$eȎ#7 [cg8:ۖ2ʢSߡKP)#swoރhVK[T?09';v䑤inn[*N<"lTl#'aZGQRݵkhԶN|i} gͫfytWr˨I#<WE8{ױTԣQ%Qff렃<ΚNԨ՛Хy&5{cHorG~fݾR؊VexI7eTrGOlҏ7+HF1ר?hvINpk!59eV3F!L7oN?wZW#^Yy ?x9[oBZ4Hwr7q9~ir譯C:u\yy}zN[tԙIc}=1C^sZ)44.Qܲ3z9+I]Giͬm[,м(|FxGӱcЍEWZ'h%WsI|?5RsV ʪ噷7y'zge} kN1z| p6f-vjV-Cbh vf9$ޭrWHьw<>[ׯ֦7 T"Q ~i.QǑ+|+:>m]K{|*?iib9e$W2|,ux∷P/ i؆Yũhvx9j?5:NkK8$gzes4*cIym!+B{-P2is[JNWOg5k.[( mvVd$)*h{}zזD$h& o۷?3pEa8ӕ܌eVrW@. FaUNp1WsZ|L2|ܜ/힙\c:4g^ #CvC '=k5vԕO{m3iǽT2}k)F1W,Ir=ic'G)+29r.f&uaIhdܫDRcg>Zz[s:m9;_R f0/+8LÙ8iii xw|AQ<+JVg=E*sM`\Xlcr'zroT%OJ;3 "6_-׌X^ѷ}h7tnmLrR7p8S.k_FrTR4\]QmźXIyD^#P.-JQ]:=hɵ:`E Mbʇ!'==)rț_jO^VsPymHqj qM婍8ʝ8ʧR1c5ğap$ʬ xqz\q&ӻeIkmvSOn}]AiI9h]m!0y_ u*QrT5yTHs9?T4pҕIǟb \:[BUk?̫y#)_.[W"iGHH ̪@rW|@>te ( h %n2aWq;s^Ryqԣ*RoTTe>f6μ)hrS5&:[ʬ A'WV{Nkz>1//6F7ª1XiEXެ5},٧r"~d\z8b𐋓ӷȡ [؄ET6 #=Wzѕ>k1Tf6Zyߪ)hC n9n{םW#KKR4D;uѩ-bΥj>;3 i9|x~5Wz/XޝeV{ɧnL4FO)UXo,cfF2q]TG3oԺs(1"1{]ԣJ힄e cdսI.!Rw<$jRHxtCڊXwEV*>e&Ev Z0E?_C{;'{fYH<0 z1q+Y}yFݸ>npezL5aԥ~nw;4ݣBP9F.^$yeL{](ɽv:"-iCs=һV?~5P'C2m~^}6F?00,>ڽjXHTG_ӹlyW(f(eFzEŋiKHUfv䱐5/c?g5K+Ghɻjp+OihAs%xYQ6G"f ͅ#^*w.ڴ¤pϿh)h~ۙ=-Ge]m'Si)zHv?hoc#S޻FPC;fTYpN֌9=2 *lq}!M-a܅s$3\/-$ƶIDiWR:ǎՍEDu҇)ny(=/B)![_2I7+N9sY+^NWM~߼9;Q{HgB"A?}*Ts9B^I;/gSݑ<|\{\fU!YWN:V2%kb2F1®x}Cd9{MVm8֦3mY!in$jC)?5e׼G2mc+8{"UUxOcQC?WR0,L)OVZ2AwF!d̛GW9\"12Śo5fw0=?eʤ9}T5E$vj7cj1cOҸN3)81u{Vq4ʼ񌏩=E]9FS=ׅSFtk^=Kn%B3.@!<ׁ^|傽rǑzefs$oר[GZN/^*.]޾ZIu+)ܻY'>ƨIjm_ RSZh㭼dmʀ0@z{T# SY w"0,P@W.^ezM!Q:<խO0񎜟^{ҽ;j_Oԕ[ЌYl6Z_kX'GNH 8ӳi!Fom4$Y1iƷߺ| iݾW{im-Ð\H֭r^ભl+_~_9sr_EfX/VF1GozڟmsF6壽 x~Ж~\ۃ 篰Z{Fb)UqqIcK{Jx{~8uӌ}u:S.mI.BHH'F}{txƥt:|דK4,Y#+nXb@J}1c*SGMNmETRs{zM3^tihCN*zs_A<]fz)no?~lnݕW{-N6wn[WqR71ϯ~:uF*rrZ7ӒE] u]ғIT'(׳`dK;g}'}xmQ 2;ܸ-=vrEuќctޥ4rǞNL;E1ϱ%?ڹ$ʺ"ћ7v vl/r ^/Ϩa);\)XLVG$W`m| si KR"hq$7N;\ݱu1mK=z71lO@S,TGM II( hnO_XrSٶ[Wεdx#mF?-i}/z`.e $~#sX9F=Vߙ{#vdm'>ӛW{Yso IdwUP?:j'9:]JU#jhý{WX%&Y9Q){ڎ{%$*/9ϚcN<cN2ON>C`[$)8{sW?oTmR[^V2oc8wd{J,?n[;jf+˭x+_pQk˖lc ۛn^a2_Q./)lјo>P2OM^hF)[m0JnѨEmάA-qc}~92Po^ÞA'6ӹG͜0:t9qX})"w1Uʩ?=cӒYY Ge@'QFhBK29#aWO=Sڟ$bBym mYp23wzV)ƣF>ΤzJV?=;%-OrӗENQ+#1!Bŏ~<Ҹm7QRiNzp޸FR)7"3ľdaYXz=.is5/- aQ#FuYvJvR٫/ pvl*8県`zc޲翙]έGmlRX,ۂzzzvjroCF,leiP$®ރqcy;3yK!{v$ޫ@Jܯ8΢`݇RGM'Ϸ=v9*T9.5y]˩ :܌MѢjt9Pm{^Y>ja~kIj.<)s-52ۃGR:}r+[>B~F-šSHa98ʝQ(L1qƻ{cڵܛv{OgMZ?S>Oin_nxjo uZKн 9,OGؚ4V4a+w7rm@Ѳ)SܘFnV͹3Hga0~<4eTZ}LY@ 0'=sXe9K_./i8Y_$q]Q- =)EAm;K6dY I+SIӦ+:-4{DycRjm{W)(6p!cDS\z鷑fˤpUn@9z0q]g:R\,"D#] ;Wq>rt0FXk&hI9V\g9e*rԕ_k7zX#G; cۿ=yb݂TqzXShmhO+T 8k4e+6CIS5y,Pۗj{zc9y%{5#b63VCr9 jK*rn/O1qs)ghI"[}m#fucXb#&R RKKm쑧x!`ʧ'S-j;W5QGn8k:yt{2]O*# dӯ")g:Ѧ9r۹cugqpsnܟ|moc)>*VSU٣]ۤ,{{HmM#*i޵]EV,]It|N1=Ju!!x~+"vB<ɶѧ<%[yexχdyV }y(m)ouhjM4(o"*c?z4%n}U͢xXZPoF lkX un]z9BnѦs-{go9[sg9ӵvӿ5{:jY;ף9[2i.g4FLsVX:zj4uo<ѲXhۼ1@ju؇Sԋm顗.1s6k{F-(N*qG[CቒGrI9x)2"WQ5%O%DWy#~Hn^jTnvQ/4'5Xϼ-n eo*{m,<#isE.pɒd ##޺U.k]w .Q${zva|o3`)<Ӡh=Nrr~P6%%ijG ǐ>~RsǸϠR')-4f$?׿v%ʀŒ#=V8|DeVv4%;%oqhav󬐒 ?@}jnz-k=BJ} K=o^p$R=>Y%.[_¥H̬9pXZ'ς_%}zQD\(ԼMsv/i/cQĒ眞*嵬ٍEQ<$ x99o9N>OI5.Q{jK 1[9>e^=ӀkzW泓mG.Qm'K_35$Xak\IؼqϮM\St[뷙{wnW̊$ y'A=+ԝFWqZӼtߙW@4ry9<_h[{:k7fiڛ]^:2jw*g=+-(ŭuz=De%F=f7+njI`=yS/)_K'5u}7 .xc"F?*/]#<5^1',J[C<DDcZO/,y3\wSZӯw0Y R~:k/m u\n6ij!}:f1R:W6@Ӿ`0?{FE&Mil^bLzg9bk߹v/ZHҬQF5Fcc'q:VReUY^ZMZy]Dk.Mz85JPQ{ɉ-<UЌYCJIA 'RP*Ӌs FVkE׸۹F0:V#~RLFNz4+68eG RZe`r,Z1ip){dSTJ#ܬϜcVn<*K[H/;wy8+أh|sZF 6I DHʟ0Vl g`^1{[Il͋(& (;Uڻ| ^8tw4\37Q* @BF?kЧvE{VW+rwQzFv5,z>N+wyji3澆9;UeVdV]|ҧ&q2C.1UX%yGB笯b7Ԯ3{q(@K8,8p{ӗ5*T%v5P/7犔S M͵q2ܞ~VY7U#MGUvVFYhbY]9XJj|8;D~nTgƹgUWag#yLןZ]sRKsf99բ}Ibۘ"pֺ1䍶> XVr4IiUn㹥S0c=;h:wfU6 u?Nhc KcN8FN'!#½*2+YLi ̆ sRX*U!PԺ܍ʪ*:lu5k}E:q-^7QJ[c0'b{H|gߤ9>D d}~J̦1vRŠQ+4G7-xQ561[L{s6$v+<)@#¥5vk->'xxu8Z[[]yy~mZ֚7Z\e/pB\Ca A'-{XD5֚MKn]ګY:ol*iYGmn:@?aI-oL,c#}9<-Lg"%9L5fKgoռ-iDdwU`n3&_RÑqvRRJk-SMr6dׯnNba+ke8l` D0;uʆ# Fum/צNWRJfi7Ny"Jks HA 7/W_?qZ/YehM7ĐەZe" `@yR'٬Dno3C"NyTi{gӞqʶ凲m;ԍ]7aمh$J Ď?xY^*3ԗ*j]cşmIaTfeGR$e3xX׌jZGLhTqSk[U|n!VVMVx_ VXzkpsNiyW~=*n/A^8IV=sߴVەan`I︜giO{zio_SJ;Favcb?[aNַ ˳zvMAdڠ3dOWaSJc77mŻ JV1?_]X)^_q0AM$D,cpx5\$$SxQWS/Fi'-oTu ?a#?kF)~V<77 Yo*@ C X$dc׭e*n{oTt<KTO2XW(&[11(וuۣ]_Gu`N7g$[YKcŽbD1ЅvqSWVx)J/Hd-dY$M67† WinwI#5aSSbؒKc0y% P@ 1חm4c&eƚtM|oy!xEp?0?t#.yZ_3X}]ۥ7m٘Zý_Do2*o}&'oU﷑ׅg/u߉滤iiy`n+4/.1@L`KX`8}4Qk6ҽw]vnxDc9)Gwmu-1|9j-R|m[{K'H>lV[h*m{kocམFV{b8YBw8H9r9c9TSU>|I9Mn_GT{hW9  צx¤V< dVOC/B.ݡTG?*kWF>;RM%o ";|<}$aԞ 5(]sZ3mV}sSR+`y8_ I@ z9{yRl*stn=9|Bԭ<1py#.AO˨VGS07 n{/Hƿ+MpwA\G<xE" Mщ#TTyvGO)~;kUK26݌'Lk:nLsШKl{^F!dq:};E$JliN7#571o.O zu{W%/Vz+\Ydv"ېHʐOo+?eR2nD+..|e:%̄fcX~<^Ueӵf}*%uBaƜwz6Vn#=GYԍFs$đF?s<ӳf;XJ퓭L/A{8ӕZ+!2[sQaU>}ku˧E:Q{odt7h<Ѻu$"lI nU5 {G#. }DeN/{܊KR&;(^ڎ^i^_#_~SH#R6hRGMLm4YI駛(^=Z&Q-(^ӧgP$y[Ƀ*=#RwpJܩ|Z8,ʻ:zz3R9%s>IVm}?J3\םNڕIޤdf_0fNzj5#ͪB{MyP \:ȨF+Nޅhd2[p1\J;Hcq-Lly&3ں!N*\u#/g[G J3GkҶRcE)E++"))AP޵9Kqn[mpcfUv?Z1 Ҧ vkk,Je%=J]k{ITR]P"+Qfr9e)A9jMOi֋aR Y5Vl*>x4Owɣ칮 q.(4) [sOƗ6~ TeHU_~eԒXc4FlrթR)=62JQ 0'{ҌeS|ԘR;z=>1:h,B[P#čߍAXF2O5%* hV.nFFURud:#8ל1ˣAnw|۷t#c5ZVZ.u.+cEKxw˻h՗7GiF]_\)5%yRs#M;;1E?-`fw KZ_6R\=›m+26I H{o,0@ne$$ETf >fUZ:sW~Z|-!9$ 'տu\іc9rӨ{&Wo0ƴ9SoCJϒIH;v_#qv)mLjs?}]>#F2Es ׍mqI^n~}>Sp&UJ/q{înB {,cNtFJLҝJҼom.M<эcR>3h5c&WC:z{V1,9W,eκܛ([!$w޴J2]wɦl88L0%@^LO|:zwPխe ~V~O\ge}QLFȪϿd~u5R+WKPVCnFI~T{9GvqjӌbeYHWyF9eS)r#?㪳ԏH#OM=q)0EVm&Gjd m| x8S}tfs`6!1dEWj63z:rΟked[g;O@xSIJ?f^VQgwwc$NWww5=QGpYWb̥ݺu>:b%M.ftq1Ȯ2[!@7iI!RD,.ʬag'XhZ颫=ŨQQ/N9w9gEƏ72j١]0Z5U9Z8gZTCzG4s7;gb ǜ\ƎYF)F~I%vElD8Vl+I듎{dTFR*P[KI\,8_ u=~(E+FWjA')żp2y=^8rծs c+*r]b]o1?@i)\^RHC7smNR\HR\4CdJ_b]]m@ϥmEֲ\m2B}z~~s'Nc$X3E#,6͛H8v=?W\kJ1q:#(4bZ^%ln`]0D?fdy,/- ןN8єU)Ԥ=eS.񵙳g}jn(Z ~xeܫ623ڍnVˌmq]R52mK)9"Zqަrj\m2Ƌqn܎ o&:) &IdНAo3֫Z Z<jydžT?7?GX_m$0c>X7}U%T}ȷyS,E Y2H'`N4Ĭdm6SN*Xi(uhqvrP71߷zt-l9K<( nF3g׊.Xr3GjsvRԥvJ6c=kx˖:UO- W2G2IsѱVvmEԩ_OC6{Bw2iLWd#$5H%Rtx' x$$Ԥєe(u5ubyj=#91ү^gT}Ccx%ĊF<rpJ~Q 8Uf]<)siTF7o?0Z0фU8M5|ὖx"XrzRiM-wisyGVgSTR[F1c5M%Y C#Nr{sg*6k91yj_jK&%~8r3|))E]_OB1ݿ2~2JȈьo6I"bUW+mJkfbC d_=#?*|sc/f-w3DjDžaڶZkSZ|䯷Fk Ϝ=o`CҎYJ6JeҒ^yőirB]Vju$춹50/yY^\GkwH2[vFwFN:;"9#Xք>%1naVk>X^݋KF%ŷ<\p1s?_j\ѱ5/fQ2uXlR*nӁ}{VoN5ISԒD7 I˕_;gڱT~㊏,$RmiҌ"Gm/9rh/M)%#6Ein>l{sߊJr{t:}cGE JqI=T?\ߖO`~yYcRFۯoǿXF\]>!gkp)nO9y#\cZZuЎ{ѭ6eL,T*6z+mX6UʕZE-&$'3ךΜi;R*־vS&&/2KtOۿOϭa%ͺ"TarnRd#8!\zv9VJi'^-]3ea\y-rWUZ4%ҍ:iuZ"9vA&Y8K@mJ9+rU)*qר%a̷a=9_k?ݤjF#5*rW_:-M:Qw4t\hm 姶;q35RMT81ky24dr '`1yU((ĵ7t,J 7 m0q#NJ|TnGN/B3%Ų83l@'JR}EJ&^()/Z|QeQ5m>RLd2e.O{eͫ%^Mg`cLq!@> ө8$)aǛZ]5!zM+#}֑=#:={2}]bՏ!yڪT%}:XTE$rƵoC)IШ/a#06 nm0:?OWoĺ|1ёFټZ5fߌ{w5I:ɾ=TN1j%;X.HcUR}߱NeQ,Y쌼;1$=8\RvjY!eJ6k][iz[B9FZ8#A9 c1SJۙ^JSqoqp4B}1?:E݋KFz.s(Mξ[]y+5F.64~]/}3] \[7fMw!I=xmYZ54r}fj. $Alkqʤax3M/yfDDXY\dv$=+QaR-v%X 'Gdz'QdΘxmA?*=TF~*-A4dq?S5w&2j{ɗsgy?iFIMJEKN#mdd9\U9>WbŭڰU x`VR/6mͅSn] v+)V ؑmUqS/iNzEWs IǙ<lqV5%OKQI: $oݬ ³Ts[JP9GKIE~,eݷ=gR5m7 5}O !<Ɛ~J5 ɻaJV Z"Ю#P]O%Q:soАo{,3E'ۛyGی1r;Sx(1pvƒNsJ=ZԎVbѨ#u޸>ս:rzwX|2 <fǨ#=3yo#)E,:M<dVKCT|)ېwg=8zq}w:Z.m]~$=`VP/'oϬѐ-?,p/avOS)7 8YFחUlZ86]A%H`]ssۂ+(ƛM ϙ;R 4ȫ$XgSIYr 6-:)D36;akb%uO NUZ߾wO<ѥY(iA ͷ$8n޵7JˡɊjѧիM$O&F,Z'G~V4UjT{-I,ڞծv˜:QͶR/z\бkj k˷!p2Fz{U52QhiPA v~3Lץz4ڷz1~4/63ZI#26u߇v8ay.HE]>\xڽ(Z۰U/uhZ?vH~BEkxr[Xx Uč? jҹ>hlZfScor]T9zrg ytVcnqkHӋ^Bz+H59-FLmFlWXQII l-{rt*,S>;q\g\8deZ37: %[,6fu)ӌwܣ~U{ZPHfeL?-|̲3~`1:ڼ|E=-c.i.^n/ܠt b8cʾg8i9jSӊ-GmgnTv+qjFmr`hc"{Z(F*L͜u#=?ٯ:j)I'wg-Jخg ^]E`[yܛ7oiSY&iNRZhW,4*Hǘ0\7Lcۓֱ)hO#jiEuB$ql"Y~fǥgN4I_ZuKX7 \džM^`81ګN;I?MZrNvN@MIc lqh+oʷ,ݥ5َ?0nV@CDӞ1Wd]k侞V]iY|Ig_Lw]}5q^d~nн'c񮕉qgEƣI_EԎT,ʾ`%VOA9WG(ӌcO&ԃQyHd;g= {1qߛCxTʵ#ZΑrɳ*3n9۟^-^NݴZH^HGy=+ҧ]l,G3EgF h~\sz|+(c%hjZ[Imdzǧ5J.R)Wf2nP r3?UM*U42Y;AڮIsYxtvؑJʱsrMiouQIyY6z{UF^KϦw+f}00OgmΞiIT`}?:I]- J*ȍy[OW?/c±塪8Źt"Ϝ*p8#q\ue85t^r+Yl2=<11R.;(ӧn<Jw&rq7>i< xsGsQIcźef }=e:^җ-eZ@p36^9:fR-G tۅZ, F!WS9KVuGG-BdXe'eR7%E6Ь~fks[-Ұ*h}Ų}?^c"s[qe2YCĤ^h|֥ק֍nɈ'l}k HJ2\{n}ᶮܰm9ԡu$X7>Q(: D8dELJ8VVUS1n,Ԃ#Z {g 2|I+Ps_eܴ~D1eZ"L67CB5xbegJJNPeQZ(kӹH`݉m1a~l|:v(ԔQ4d-ݥU5S/Һ#R26QT#!Z9$W[%JсϽt}cJ1ƜG5ik9_1wF+Mޙ2*'tDkf<*m>a#Zӭ(z۩xX8էtghΰڅS0L.B0&R߱*ŤәoSҦp İ8@x<`}okF2#sH3^Όʸc`6 zWܡ֞FUYTQfQ՛ZL)Hϭ{e#Oz/voi[77giRGL+Ɨ42#+*I!N3}lO'cr!VvpN1oFrvG}QmXV#g;Ho0OoN99km(2喃ݑ"V}[ҟ-ʕZq~7m"#\>TN j1Rv]J&ܫ+>Zs4],lr?޵mnTF=LFO>"ENӻif`sƪ*PG&|wr)06ߗ=9tE^#V\xaVF6:.V5*i̭{6dyn8'N8B(]%R;An-Ĉv'zbe̜*qihPd.dXd?Gֱy8m@3?6ysK͋FNߔ3IyϽK4͹W;^xY6|jrwWɅ Ecڭ TݷH.k2y6z_gRGrIS$"$~\lw30FyqDy|V4nC{=y|$!sHz68iȹluVX7VF~}(]<ܭjc܀1 yێ}kP}i(TޞcV ,Ў8jVTgtDe*2WwV1!.#26g9+y\uoB?yohkkM5Ef-6b'K5 u&Vq$EQwGr}Vp%*ص $*U8?VtدbR=cw}y6´cN*,i}Y0={W=_v/CJX(췿~Io+ yW:6J}y$.%eWc&wc`=GM)X֫'${ *#%v6S8\zhvQ\^.\$k ̄o^x<7iT=e䕒-rXr~8Owu9R"90 -ӧҹFVw4kN]|[sj*6_,Z,--+$crwe[AG+h康tTEWoLkmZT}3%u]ۤUg]zg~>z1W?1JG`_G241 ~]GJS挚GlcP]lLg$<)H: TJ}1:.Ҷh,|G$k+|A?ty҄o'aM۱4wG.Nz=Z2Vwfn: N2_ V뭁3Eq;\Ti5kTG$e$<}zsX~5fU'Nz,M5F=؇9:`uƤcN*K+\JEw v8<sƢձJuʞQ5lsw2ZA[8 =ʤ9x28 ;.akO*/s ˝Fx5PQh8["kv>z8uՍ{䵌̧̊qnk'4gR4uoB+YHE" 0VU/RhQ^'[X,?N0\2-;S{>wZLc7eUyc,p1Ͼ+ntW<-VvVXsA$l8wWَOvsXp&e,#bȡsBIK]ɔ)w]ɕ9nqNhݽpKHױ~f_1f]ı9J6з g|mvNr9HǛcARN\wVsZLQ1u|?(62nX/|hs;UӒܺtkj $,G`HzkJ#-^}?i%7ew-iL/ ֔g't*1VԅOn񬰴аn^<ƽ+.}>]ų$pl3z.Peq{5FVdO/Ϻ5\aqsJOt#)NJ7YZi>ΐh:ak){MnNV{kw&$f+,XxaqF^8PUefhuo{=>xcFwF3㊕51++ 1qל[CUTԚhMU6yf†o~+jjjs[kSэB72 -rՇو#| UHՏx_mZm7Xb[8>ҳS z)(򾞝SRm ,텫8ƫ{*oؒ[AdG3ȧs|@88 O,EGd8Q^oԹ{=܅i!R< j)˗f- %/K|^'V[u#3 @HQܑ^O:rOcH֣{] {M~6R7aߊǖU*^+KcL=׌e%FF sH7i''n:jb!Q%쓶6h%E=P𕐩<ܧkei+>%(ƣW?uVc%ǗnS'ڶPqn+$:_N]u3ìCscyhQ7֌0IO??}EZO*4~\m$!rc`cMcQ^<_zQ=;ۧ*^kW1B$rclF}Ƥ#9﭂- 20=yI4i-h?i:Ȇxhuwp2~zQw4kf*ZZ{glbcI M|6ʤ`+y!pG~Tre۷.+wGO+Q| GaifEf zt擒[Tdp|s Szc)^U_J.Ɠmo ,S۶ُ,`}G旽(<,i':t?}]>Y{$IR[/ <`zqVNҕfi%r葼Y̧OҪ-Ѥ%RQd7Ȕm+(kiuA{HTMJIrkg1o*821^խ?:cw0}Hԫn8Z1R4ӂx'H?1zKBq4ե"ܫ$Is8JVև,e;-Ew㙜 1@F=k;)QotK ڹln|rsXԇ.JHn wnZW8ѣ풌EH74[$`s05Ο3qSm oly7gWJ|Lta/4W B]Yl~y cRW zRn#X yv)z|qNOEʯq2pWW:өLjME/٠l98ɯ:tU69cZ5{w3cTƋw<}*T_mkc+%hQ}}2xǵwby#ÚMqj6YrOB3ϯZi88-Q׆.?{H BgEo;>҄e-4;m:#0x$~}]TJ#fD62\u75sT-exo<~F3{sf2ԤjWPV?1Ymr8ߵu>kIa-SdtCݜobyTbjXmo-N;;U8ɫ"Tʢ֯2D '9Ͻc}L+4B,: 2dj%rm`;~={ס,^]ǹEI-4g#[dNbʩSY%Z̆I!8Mq9"xs# 򝻾^]l՚b!J彴C_)+g1 g8(?}/OSQ-uO[ፖMVmFY3\F%)wh꩎:ح}%L#y8*̣(lyzMҳM~\x~JY:uajEye ~RܓמJեu#Tc*.M\4ӯNۀ?*&~&Y㏆IYD 2Ǝ񖧍)F-,x xwFQi,Iq=9jʤZvFx2CC""+PdzW$>Y#SSt@$fyV5 NY AYJ晔c,OӷX7#)j^ƒr.4yRzvŶVmszz뗕>E9˙sc*ws:{u)J6p(t#]<|95hԩO]ߙ8I9׌}-tn<ٛss_+/sݤJQ[h koFvG>OiXqE=mӋl >^ FўmZoKo*O=Ysǥz1:2Y%mdЃ|rolu DKn;atO<,e=Z]}۩^ƥ^ۆ^:2n't%}hhU2p}ӌ}W~*>~GG&)nVA_G¼\ŇTM.}t?4wW7[q49o[c?R;X?eOvga)8tmm;[T_ZW,Q:)Z?"o"[y <sQ뭵3(Փ_E~JRYCm%CvPE+Iko.5)^Znz_m4i.cfmm@9œJ2j-(*TTw?~9;3e]m]t/qcOMΫ}5}37V6<;:VnI^:J6ߺGEM՝>3Xe1m+6cӦz~nS0B oTӷ!KqnVmA ס[փ~G0}zOOWW֔ V$57/2u| 1Џ<7קKƅIBItn^~8qR/2jb#̙$ @ nByX-=nG*\_7ώn5nnWrơ #۲};qҧYS彏1XDZ4Xz{.UUc1 ;9|E.jvi_}zTBۺ~YtmEO~~l˙&>T${7d oY,,HFpstOZZtШՋm33Gr뽤E\ DZzW>k­:Y;tkd %,Lu.`g :=ɵQ+7t/kO 8ȓ79iK^]su]W^r3>\8oʰj=U莓W5!*yVm#lPH9$pu%%֞z~l~6ӊGG¯G_Kl`Faw+6/ut6ϑf1\=1il٣]\2m?ONku/5ϛW喫t/id͹ӌM2ңH>U/"8ДBѶ cĖFIY:<垟C6(s9-l q~5)oEƚy3V[ Mo5++MכZ=sRQO`<35%iW & Q}}*0z^:yJ5(y$c4'Um18]445/M=:C˓+X_k[ٹ)DJѤc`w WjiRj}ǘcrOY6ӯ~J0#sysԧ;VK2뽃tV~]HѬ7w9JU1\>(qM;RVtoHզ˹w0W/.Gyh?']|r߯O"40E_ sCI8ɴ3t#B|R<`sWZmluʤl~>O,ay6x8s)7g$)lmh󷑜O)F/[ЯfR1 k6s\[rjƋ<'yiXcF9N~^GC*/D*q {zuSG4ޟ)QK; UN^XXǖ/!7+{ꎉF4V{rrxWGS5T56ﶘmEڭҵ4f^e.Iŷ$CCl` ~hunTC, YZs; @q=т^Gg}%̊r`#4时ش\smV5/c7ȶ~^#GT*1`|{:u)ɮ#}3IN\m^S\i-;@YYf=#{ꓩRjUYFil ql^nO<~zR={6|v)ِ|6ǟ_Ҝiݿ·'rbm`#;YZ@ZSJ;qw9O{ Z9GZfOݯ+99⹝9[D-}2;n*]6:0gj2)?FF8MŷGT7e\J7څl͵ 3֢M?R4e_У5ˈ۲=1VYU#MR>`[)r:jeԵsN2}РEUoI7#*%+ʍK}h,)O8OZr+WUV} Nݣo595(Nq}ho*.UI]`{7d^D8e[rnn:[J\i89]tߙd%04dWfqV]u"IX)kfٹHpqSF}b؅~;Yw6X`{8iN:)sE(;84geddr整.PuП˵lVn 9EǓUSGӬ&k nW#AU*?2.g̷GpBHB ͑?Deyrc?gJlm2]xS'-v&K{%7Yc[Sؑkj'_,,VYBHC` \)(ݵpx̋ j[B ZϛmιAymőҜ0|6^EiF0<;RTs +{i<2yWH8F*ևUZxz2W#BcqTt'#09ҕҕ7NzI$6u[2 Nq9xې0&G,ȭyFcIu)\r&7J|޴nDwGՋ2d&ne xuOKNtg$UfE=P;=hxt[{"+1B<ubWoaqu=+X›SN:vMsh @[*:㇧i=_o.F+4'O##,r+kF{~ )IRƵ HJ>U/4cFUigi281h)JQR|7[.Ė/$iG}liu_*|˻*jnTxyoN?#4T`EcN?^:qȖ&,PH7| {w5%QSV]:o}`FI<9jyN8o~8W{Ji[mSlecVw3gzSekOŲA`6MF˂=ԕih&ys/$\lQ'?:#9xC_2KfYt(dUxuG~hFji EYVS+|~u8zM7Cۄ!FI95kԔ}l5;R@iQT(#zkYkh+Eu@ #y-q1yϧVrR|ַKKoH'?iϪ;gNU_/O"Pt[iSfsJt%)hKWYYfʅ#?JQbטN4'}&G2G.I9B{Τ7԰H;R<Ÿx =q*vB(4L8qc,D$֗-n Edbf 5+kFIhi< 2?g]_Zq GW#HZN ~JN5%?yi\ 7B6z.G\fiEҵ*nz\gRR[]o;}xNxkk%{>_BO&r{;g_71T kbDGMD0PsR%[*},C*G Igv\{Ÿ4e$XI%a8#?α_-J1N͢q!g!X<j+y;QR[ݹ3ӎҹ+ K;n. RN62X,9 NnoL*sS) :+w! .eb8n'}Mt#eM)I)$gqQ,BRwZt"tmG8ӧJimL`޺n.L1Nͧ cuwQ̗ őYd.jn\ؚթ8) #8Z'Z3 O; ݸj$+.d} XeЁמsuG5˷R}aA"wPI:y, k%:ԣ% !}.[oU?NRԛدwa$mOOֶ.Vx{+4043WOzm3gZle^q!7qp^r[WBneϟQbܟ3ddО>52.WSYy.XUݽX}حGJ23q16 A9| W.XWb- D9|8դh8NÅ*nhеm9nV4H.JcN9Me5E7h[C{js6?0Ӓ;pq5q&ti5UӮ7[ .]adʬ[^8<ҌG/7jt:eĢ0 /jr%s?gnm5W`f/gsv=GZzޖ#^!c%>Q5b[[[ɢY] }xk(J2M({G,G ʣo}~\CJ7~|%f# S۽}AʚMu.+I4lMܐH4ݬg/v:2ŤO}3Q7kFS}e^NҮ1ѳN_lSӲ y%|% bYY98sX*(ɶ*\#WsJG9ӵ ROSB>=N8CrE8ޑ\7nƿx Nj/sOݹ]ov) 4,^G<ݘ^&쭴n Gcuq\+ܨQE&YߧiSް9|b_ԍө4`gXrz~ja%ϦƊ,앮Ud0(=#N>åy#"Ns?Lwo,GA.w,`u=qյ/Ěny XVbp#c( (T-1 ݘw.kNB؀1WVwaQ+h>BXnWw'j *Ν{{ș\^pr[xe:?gʅX9a0;8OU%Ee~AlbcurygYYuVY1ے~$zZQFQ*]]>[iIH$sZAJ[hiRM('h1pX؟N?}UjTB[ wH< c\򌹝Pr$6I$JM)n>3r*IF*Rg%[yr3(o.p}zzW<ե{!L!NZMњTy+57RK4m.ű L*q96JDqh$aI=stl&՟~v@?u4{a#38}8w*z :3m 72ȌaYfng¤&R}Dja\q#+'2p 't39lRJ!Y,!UB~AYO,hzW?Ȁʡp#wYJ:-xZ$l0mm늊I_C}^SQ}KZM;u*cT5K9*|j'byΉ.#N#ҹ>FӔ$xfgHF2 ޳^Q!#+9%br8UwFrm+sٷ7bq?:F<.e.%JPr{W#*ϕj[h{ql3"n'0@j?nT9c5gkk4ibʲ 0JSc?RjڮWrی"2nqf ǩ9ҫZZ[(J<$K o3ӯ҉.etggI$o.`d3FpGc9 HMmNJS2\[ӻ+5,]MSײ~ rGMΊ2M%rdQ#m$*'-* u Y7@HRr}VqoKyfzZ(_d"V\GCrFGQZIZMH4bqf 3u9lFQ )jFWs*bsqDW5SQVJ=t#kG6?$dp2G^2e8>֧-z**ec f8W)JTQFZ>eO&Ɏo1V [M(8o_E֒}bLċk#srkXY+ vۍ1r!^s߷kZTfZԢB̬ec NGO^ gRtL%:uD_U}Amo4Ud|V~[׭FB]}}y&I%!Uv`۳s:b^po֔TqJZjFmɒ_9#yUlcdT.z&M ۲"Pβ"V.eN #W.jjѽ6ĹoSU*KVyc5+wmv1B9=a_ҴEhޮA-[[E) mj|r{jQ77dwN&UV0\;GӽDͥF;U<##;tF_}lcOnRFZk =acd $/99劧WnM Խ]} Ry`a$cLOޱNa׼woʺ%.YoӾPZgMd>Y$@G*J*U-)#I%|ni{{Fߠ*q.F.0ۀpK@~ZʥYAk\1e8Ix÷{tQ>s49ɵ8o]g(J N1ؔ]rX("lڝ7(-WrO=?\< sn'}=k:uLX=q#WU15μZ3bn'ۘP\$rr28tUMFe*bm4~_6{>iYKJ*k5Qм"XT処̶.Y[Moh8QAuZctuъnk}мǹfDa ;Npq9x˚KKt[քY̏!TtRپåJJn-Yd[c:6sָeK{[pU7|6Nxϰ# i("GVnR޹kJsXFJe'4 |\)= *V^PN-MݲDFnfmZ0z9kI_c˒N.r&&cR>R.mɝxiR.hO>y3aFx7g?ᭇtuڵNYkjɟxbr;ǽiRQL⧈KY."&QێORzJo^}y(ѫjAk$2Q&Pǵ*Sz}QR~^IJa"]IA0{dzm^iBJyF5sMuu`¶K1·NM"4֌c;] I6{Xz8~i{O֖CSNIdpW">5¤xӝHTHԴ[ndj& ~y{X~UùOiK] I#ixߊesՌaRm;/ź^y]SmUFf * -]ai+Z,-F֬ȧ;>($;F%{eOf7< cTnܥWyQrW?.M,#p^>"v9\5{lVX"\*VVA7mʌJZ~&E2M}+3H WO,{'\ב[I~UmeK}G]ƫ,@=s>=Ntc%dT#-ϔGy\Ϲ”WNÍ/;ɑ7=qӽ|wMzҏ,$i!EVN1ny#irhu4lު1W [z5=xRkfmH9sUFkNcݖЗg]ZJJ\.i;(۸͌~s'+>),#fnzzgR1M4tF,G]ǐNq'gGM;L򏱷tYԩz~EJV %fbH?1 {WNF˔ vXޣ=:q?$@f%HzJZ;~lQ\NZ4O2VBtnMg+T]ܷn"C Ylf2j7dMn/+ҹv2}"UVg*0ۆWq=gR.5|󱤌UF7Q.[ٓ*rRs{9fczesޏM{#tImH|m~^:JZNwNRg9kUܣ*Ƨkg&g'\s|7n 3X2ts^iy3oB3Ƭz\yӴRMKc=d*#ⳫG;w .WY$ sHUO^sjKFe+nכs ~e0`Y0przWNIG[jqbҝ%d՟Ln-q9a7^kj7(8KNudE4k'<N "y}2,̪{pQ}-SVi#o2>9l5*)S] bPUCFx;+ʔ})Tr+4#S19f CW,F-z%F4+u6*zRi> tj*KRI fL|;xmqҦ6ߧZBZYh4DWvڰm>F-Ijt&_Ulg1y8eU;cUu#){%ZۛE$ˑQ"lp*֜W؆ 2LWw,׌?J>M&z*T>F-iR$iM,i9a]4FNU'FM-{udg2-1 dkOVqrף귲/[#^};:QӔ[[|ͥF*^ϚO#ЧxU8`#!v3ӞFze[W X1z[KlꬭJeVb3zs/RWt@V3k:b9^~-v:p˖ 5ڳf7Skաha({9cnZޣ:=Aj^2qOu~V4NSJZ8rk˴9$I=h7RZ4^+4{$MJx&#/uFl|ɲn1!~:)7Z+\"nnrG^9u)rXwRVhZIxد*W<>9sFź>Vn e$i{A{mgu)$ mi qN= 嵺I4-I' ?G^W4N˩;4<8khݳe~ɻ'SԜ9g֦iFIۡB]]̊}ȹ͓G=u .7u^=.m*rjH-nʐLU_08g4J8jfR1JYňnRO5ѕ#?X-$ؒ( C9+I4:}[b 卛zV\/?3s=Fxe)DϖNio{?BpQgbi|?Rup6pO)rFs4ەRݶ@)n{~qV]SrHu幜Ȋ*,rr1ʥ7sJ.h]N7ApEA_Zr喨fm n9=EmjSS& Uq\q QNLiҌn]l,OT9{TN3w3f*#ɴ κ=ڐ{J}= R fyW#'ֺ!wAVȡw2spKs39֦<̡!_tP(=z5O8[٫k t.n5:ܯ=ޟ:(W)_^e} q|sqKuZ$ۻ1?].3c#2ENqQw9/_50Y6x#?tЦQ~ֵ:N1W~zlLigsa^˱Ia;~&Eཎ࠴iq$~'\eNz_SVj+[v Yn"֓ q1WNS2k-֟-K 6Fݵr̵}z ׬|vsyo1氭M/is^ZRWIuw))(-zrJUbcnHh6y$G1d q)nz,[^0=X.RhJI]'Q"Pa}y~lƛh2G3f`pƳ(m"\ICy\0+J\XGFIIzz㾉I.?rÅ9kȘ5խ-/ZTnd[xN09to/iMadK8?.$Gc[N=УGCt)ԨTwӿ3|Mt2̖Arֽ4<4b:rӹMK,ĮwQ'~{pí.uHYLebG<CrtIFIXJ`*Ƈlas+r[6}1]nhϙĜW_O#YS9{ZRW]?,nuQHⱓj{ԪZ.m $_bpoSZfESsRZϩz՟'o:C<얐HʲQNJ:[|Bj8Kmאj,]we:7O:0NQ{TjQRJ&-I5'7QO@ x8Ӕ9#*ju xj;kh$_&Ls˷FhQ6?N75mݖW>}ç qȱp.{1\՞MIJqz>=;F BA=q(;]͈[ _tQeng~5Q9MrcN)&8b͹3kOwӋm˱SgjbziwF,ܷk>ӧNR5+0yqJ/lN|V)vF}8WnVtS4OpKp9єnlUc#$3Y7,`75cczj.$i_NKHTvbAt0&x8 ӧRQz^RIc:7X*my9,Zve0Pʫ0m>^mb.$\c~=GqEb.Y4e!bb 7#ԦȖ<cL:6 ix^Zjm_c< s&xs#V^``rΜe.vr*׵0Q\q<@<󣆬dXIdSFog#\ϕ>m RjI||elx_O;q\uV?4uoF?/;doN_qΜc/x/#.$]׬@ydדZydw)]6TY2ʬ``"4p/b9J$mŎH9^5jsǗrIjWk!̫y O&CTE$<U 0WKB-FԚHwSee={g$WU8qlne3l.U#|a 1E`R׻6,L6 a#z~F7Aifimۆ?kь\bR7 ߕVD@` q]㮠RM=7f}Kr_c]Qڟ'̙ w9 ~@UFCYF̏žffUY+?ghr.xZ< Y(ϯn:I-B)Qf Gwn%tQvfu!Q)4d 9eS G<9Z{`,O͞JA[W/ð|ͅmVq0Ex쑛`19.+ݒR!kyO2YN@-'R\QZkEdfvsJ2j)$EME@wXW(ivr߲HŻ^GlC"k ݳ%_S+Qo%fX|ݏZq3iS_!O1?J1\{(Vᵱp$VzW4i4-y75D29!HU*>\C N_q[--לYX2dCJXwNq☒Uۻs0ge8'A7$ܝJ|]Z. `c`$rԔZl,hxviڛ_29,{窧^Vz9Ju=ޟy٦i2JǝA*?CߧJ(ݷmz;%:mo_3)z_cOhk>_3#Iyk3*f'sjDHq{cnϬ{*iCS(-x]=KZHpЮ8t8\Up5L;u5[[\5܋ Vf^w=3 Dct<-[=/c-vc`ƲZOVki SN7]OZu𸾿nVGuf"_:e~7Fܶz\"f:|?iX:ddbg)+FՠdP%V't{X{9ŹE,6i 6 9jj|n2$|-gwh hDCq}.Tw8a)GjjVٍ**'c߷)9=NsJzia(o0qp9J?ch_cβ]#]烎z)}YZxψu&՚yec o6׎rOuVQt}ϣb)ɸ7$F[Kx#Ȝ [q_rK>Vu%]zW'l$)cx<9+uF"ElӝfSvXpI?jpZvӯsG̍&U۱Gkأ)SM6֥ kH˅M݀ʹ<\?(Z﮶;*n_q}Byz|O[_fFE"Eg`r1kh)JX/m-u0#o3r3v#[޼zc'{pT5Ͳ22\eq?v`񌗺Fazz&{_6(v1ю^7ݞ>#'}:*>Cpܓdp<ҝ+2xJHư1/nRFN3+g" NI#R{_2j$jEmk=Ӿäݾ*ˣhLH8-eS+ ΪYY-7,Udʯ͏^ 4]I!S[õ&PAC*c9fg5y4E4q t;jŞ[Rn]۬`-Lsi^v U)SSvcWn=Ǯ v^Q~Z߽ɛNO?a8wE<څ)g\$efaհ֧N%F Fg7Ik窷wuc#,jfEU s9Iߙ3:s_gX|K]osbvݷ;Mx[ENR |U@9W6W{˛VǗ_[Ǩt٘D``;@#>݃qi ukG'X|_X4 Ǹ$;}Fmu>.1zL9]MjS/p]Y+e|9U8FmOmof#<id>y$~U2RL8S>:;WJZG/ )yƳ %K<}t>O95bxȹMrM)'i+00t?JMhݹ.uLg{ MvK5G̳ Oi#r=3gOOϱѝҽ#*}SC+dR!:O98"$i^5ʦ~_.-g#WO8tU$:s9溠F)Y9SRߟG)XKZuj[$1^xmN;l{֐NΟ#**b`q3 280*:g$wqiVЅK MW̞^8*5M*bܩY.ܶT&|Ӛ}579TwD kGb˹AFGb`ktIjMCޓDqjC~`lQ}p1jvԏ4,Xh0f Yz~+H}lѓ]"O!8fZ18i(WSwKR<__o3[hI^dRGy;lF8yN:洍 8TIG>Uv1SzޮQ\ܱkղFFJ=\ iJUyz-t\D"W3Hf8~Py?ZV.I}n(Q%2]7ɜqXJfeF<Ӽ}ʆ])d#NCdUޱg:3d-):Řɒ]ś!x6X{ :rtZ0ɓi}!sN~h=.#'`ݝ0?֪re~&ju6O@J_*}$&wm{r+X8(IA^[t;Ȼs(4l&0\A5 $@yvѨe_΋}C17 =}J47d17b-}v9+륺FJ+}t>JRM30]Q&ϩteҤg)kr(|}̟lϿ?LթI4e+{jK7 ǩ1+OzZs^J7AP:%^i2N>S唗>D~%ʭQ[-Vv2m(׵;sElC|Ӕq +M,:c߽kB`Jb]IsIIFn8۞>J>#r絓F2rCPW=戸Mt #(u 1fuc(x pqW(46ZIGFi7-̾b9Sմpy=I}RP r6GnDs*(ןα)(=r[Ȱ NOXc'~\Q4zov}P̸V]vG'YVQVosLƌSw#kVțX/(§O>ZrZEgwRȖnfUQٵsjj2a6ĊFr̫|zҴ+N6[nmө ԨG>UO֎[˕X*So3K$p>cSb#KWvt#$Tnwr˚]Be!{5#6Gс쇽Q{ER債iT -?̶p0C'h'uӅaGϹ ٸff/'9˾u9jV~#om7<*ҟ7-Nڍԣk_ˈ+bL#8Lyn0xr^i'emgn6VPJs֐7SG)]Qf/+.|) =*q*5#fEG<y}ޤOJKybv5ǵ~Te F6gljUbr}1׊2R4%p'6HC|azJX-3ԯ9{][mUm=kJrtL[| /&,ZǞ@8ޜ(H:1-o3B&*YceUzN"5ױ;kP]Hث)cixԵdbH-.[mcfvў@'?J/RJc52KXiAI7 ev$^9:n[Kp(e@O?Eh(F&hVuUaa;ʮs;܎Oh֧Qv T$9 r`99*uVb^-pM"$/ JΤ"SMk&y<bI;<?jyn>j72qc"q\ +JF4*Sww]>ô&w7<R.ksXӣ*k٫! Hg*08L~4Qz-JehHm6sp1~jr5gU)\ &m"|=*z-IrvCc''Nqf5RMJ+}l-/4Fgn]:{JpK|ѡ6?*x' Xҵ:r4[}I"Gnr\sGzSʩZ_QlNXX=u'9|I=[,b_|2xO=? SyHΤ*֊t[?3r<>{st9)h {fDVrc0KmqiG4QG/^G"RrC:sKBX6Bj7O̠;`xZFtu2Aj3XeePyvZYeRp3^wEQrC*76Ր3*KFR5݋3!C׎djR'g#hZE_#ma>we~'Ŭn$O˜`Q)'ب W!9 2WOi*1緽H2՚.NH4(f-G{TԣrӒI$1/eya?uyd>rDALmc}ML&:+=8wy2\gm(C^ jTrZq(aw8QY܊tˮy(YYX{~Dʒko'7_ʪe8Ў95FWj六P8ԳGº'!_1,N;H9<k/[>R^\_1gvӎqHE%]k8GnLSZKImmn-ϜʻP=~SBN/^E >:=^kvd[嘬;QXd7_x=keN=c^jJvmV}2ˑˍY֌/+s9FJ^x_2[j#;nzϢ1" `c?GG7Qn{2ԕI8͕ΉJ*M2h I HڳWBeFZFe^'g4~Q$WWٷYL*@qG[&gI8|\ġE۰MYF27-Ff$yA ?\~UK*T9r .mWog%ʟ#veD+\3^ƕ$L}+U)TȦ6\0? .ߩ֭&*AOc Q| IF0e'3n&n,IR{3W#1>T_Wq>cy'8Hʭ j6r:=?c}S8ѿ h[,~vQ~VrԢ57ס"LJѾYYa}i*c%Fd^rQ;UN0j$ Φ||i?xLIsΧ,*´?ye +9H'l,>|@ yjN*%vonf;kr1}sR{܏3[V6iC#Fi9f=N*F鴵3Y{)ZYc`]a;z<ǨNd-Ho}**[o2i'} 4>eݶAG 7Wf!wL~'A3NoF4j§Շ)|^O9qSN4FQ5 QIZܩ},G Lch0~P08J5gtR>mBo_%]0KO<4coJvmIcciWwTK=M+֭N1_yA"8| R/i*%\Ryr>12KVM㎵3JV+#;KMPۘ 7y1֔+B}GIo3p" #qՌeRvo6 $>m1L9T(f:qK̂;$vs-.7 z:5i'R>\AAhHIT?ZQ7gZ6] y~cs#kUSyEĦH֦3turö꿑~9?0rkT~ӥRpRd,2G,k[=Oq>g$F4ԛ`rC;9.}kz妙Se-18`vkL=IJ˭MT:i7YIqebaZhVomjqVY[/\3*['*e_Vefy- fvsz3.VOhtKW|Ws2[w*Yv8\CR{i.n"0;fߙYjehťܵn".)XܲNT^Jde︳OV?-G^"U)UMh$Xs&O<QDyus?qnh6( $S69q'9cN<ӡ!F+ԝn\\FyI <:n=ե1 5'Kinyq*$8ŋ*xt_~2.qasp)GVKṣ*} q.ͥ1ӚR%KFhCWuKu,qq+Đf@+nNJaWRJ/SF=&~CkubVT|Mn 0gUr8t~8E%"P-)2* cVp4+SRN>D4s3yp<`vדU#8"jR~˝LY+ooJz^4jօz^q:]?gY|ݹR?,iTJ=:=DxcmmmS9g+Q JP 2-ܳHܕ+d1m~Hʦ>ϞNR)K23'A÷ְ5IݤrZPjz,eh*G'>՛txQ>H-l`2[Yԣ)-%o#UNy 7o- sy7' .i,D%}Ǵm4DrFRO9?ʦtIE5fT㌎usXcG>eus+#ʌ,¨9'8aR7$׌#]ėKkckVP;7$c`AYb%sլδ]б͈ sy'zengUaŅ-onv ژ~s\QlR0e"x7ȱ9? n^'?Fɧfr:4YF2\jީzȍ' I}}OKi9IT]54]F뷅zc}ksIt5FYy$ѪPdg p W(]ngF3׭ZhY&q@ ߁jtSN1qmXBl˓}g)T,*!Zul6Gr8?zXfkʤjM9-?SjdH2Qv䓀G^rGm7-VA,ȩ$4yֻE;aGvHRXUlYpc}V;5I#V4{<-q|[DtQ6.Vq=3q5nXڲ$kp8=9*y%;َ4jn+\9yeeU2OU8QUhf0GN64Tt7*C*.npF1 N+>Tve'e -—\q~5I.V=c ~vʪ^kQ^72>﫯9kURwЯtaI>z9xT.V$eNPrSob|G0};36/X.铎ּe8D<ЕI%s"8XO9Zu8:6~'^VKC_K+ ˾II#w<<+d䣢~>;su]boQ/$V2eX`Oa^UNhVuьc$WWO26cel>_X֏=ܪTX3n@V3O8Q.IJ;v9iQr+~W-Aqsc<;d~+JuԳ꧅STۋOԒR-Ӵs=1Gl{zVrnT= ))UכP%+B,c'b;}k-hcgF1Tֿy %76e@vYsITҍPzy,Ip㎟J2k}+*i"]b͞[H32<0Y[]=M9ܭ[ނAN~T$՚9dbdkQ*pz4mlh[˽iaVG m':єlY>nƅmU\kO{c*slZW cJ2ίhܹdX˷qqzchr('Ύ71w^Tɻt8J*ZZ-(PNW6]yԈG#Mr~U?_z(X(I;m+Ԯpppz^i-iʕ.kJ+J2ǨӚ瓳}e4F-&cʫt85w*ef4B^yxUϵ[sFmY.[^H_מG4nF~Ř &Ak#SuV؉;Ff?t/RV~ZlIWv==o)9>UvIy ǒ9 IrL*՛܎Mo;rOu NERcM6ȚP/7_St(nЭ{M~S2Gc.k #Ilg\q# )銗N_Sީy˺i 3fg$Jԋ#:ow1H'V&יhΤ2[B#9LCұkև)kưH6g2ogֳ8JEm?ޚyaqk>mku~$u6fFvm?0 +ȞK#II4˹,&Ȍ1HyTzv6N/2y?2ş!YUȫ@'ǥcZ%~ӅJ<\k-A$_3 zV:QS:2GT+YhZIW{H̀==?jQJ:w+0M-JM&7ʈsyo*wc+U*J~˚ԊHMs)E9:vyc]iP.w=ZvNΐҤadn\v T*6j)ú@{ QkNTiF5-zo&#}k7ݝ-r4 .QxU;8wk :>ϕ")򳪌yxݏ"ێe~kh31o xZJ[B1TϺV@,#knկe /٦S?UUg̞YD*N is ۻh0q\sZG̭yngD!8Tlm*v3n.M1]hFsӜz#(rz36u  b*q3-ﶫC*$€0Asztyaxĭe2 wu4lNX43u[xcrS-}3jPn]ɭVX_>{$9F Wg-ENӗMiAx"^Kh٣NiNԛsn#r,c\ᧅisKKo[۫7MI?\rsG݈mGqGBja9Z>n>O k9{HΝ9BM3?dd1cZoY!h7ţH.cqu5b^MsKZmQwyʌ*s)89Uчiost' qx;d?c ^&eb84>YJYS|rh$T`@k-Yn'(PڤG?ͷr\AODU57g}<%¼c`?ʦ`D59S}V!#_5bBʛv*{t4 rwd<ӷ0]Hf9=99(9ԝJiIKRer.>mkay\5)MgXǙ~!#zֹvwgGCq[F-;*uW>Ϣ!Xح[<|~6iZ17q+*)f OkyciOo3 8>𴃖MdrjZ8?ګ;g IV7$ !Wp=hutRIԇkkƳ$twK&&ewl׸!q]TcR/d楥kgY< '/X#GSzu =ײO^54`zAqd)ٵ=Yu߈khmfk3̲`yqkjn9ɸk/WSٹ=?m6?xc~Kh(ӯWS'QWV,!GY[=y}2RR%nX'ߩ4Ohȳ$xeY+~S哺} [P$[rbV<Ǔq\!qёBE.a-i q瞝>̧(ԯoC#qs#,ryk*b鶬F> Ru"^VyߝW;x_t8צkpBO]q#&GVG=TUq֯7Ob*ӧNӖ_y1r/F9>b9.8XfV\t?i7bjV&{S>VZ.4oٰh#ΑO__θZ2N]gQZUw#h'p9p+gFNhӣMZZz;? #CF>eG=$o+dz; Z/J6rZ&:>Ε54z/md18wHQt 좸cGY}tvM~VN:O-6s?i[vMī2/̇g<.n]ZSE*ti0'n^-Vwx@[ ՛agAIL9 B)%{|vx?eȺ~5oE֓xJeN;QFXnY*kb0S?m5..H"%fg# nZI=ƙd)䬛j܅~c8Ӕ3n̲pǾGxX3>.Y{uI7$n?^k_z2JkJ푆T6p:uF:v:(*=ıc&rxzURDLT~y.Ma7ef=1UYwFn_&Io*!`N}91[k/z%rOl %4d#U(ƔjJUȆmbBX1Zd%=zUӔT+>[K k[A*?U8nHrnsÙ=3: jz6$uVS_$c~[{R|MI Y A= V)sK}Ǽ[3;6c)6rTiV@ȍ=[yվ'C.cLn<\#/v YK{n2+=xJE9jTWQsSϷ^5/3v4ݯSN] <)FKByjFI'RׄJM̼lz$%NvV]iS/0LO\ץpM3+8_CfIp"umy8ߊhZ-%%eq;YB׀+ыrluB4/zg%d3]sX-K,H#M2x9r]:))Si/IJeq8'<bjr-A-47-p3ihѵ:j1n4jf#m>ӔeCitn"yѩ1$ȧuy:OM{;\O_γQ fBd6|?('9O¢;gǛgv /7%1>գ*NWVp#uc_/Y\+I|q`T|2M(4&P`Q>3dz%"?7͝,QSKdV"`ڌ[\=ݎVu3 Y&p9יUل&fѳ}Ur Z#w}N{Ocb %fxͲ5R;9YUckdN3wG>Ҕk{f4d*瞿7'^]u;U{O>(n[<9t6l*oUHZKE !r9֎NilcӍr\xE+4s2st#O;*4ɨϪOqL$rlJzlyա.WcN=vu|Eͱm0i+1imvghZzYx՛]ߠF6|&ǟfGJF^s5)#~'|1T+Hcfm48Q95ՅF_#?O|.fЯ1C1`ccBU'K[̋J|qW'nRj=A8c(tqwM/he* og:ڙw^3~jiYw:3f608=JQ^6h?_ 涸T%fo3uƹi>9ܣNOOotq7q${ 2+5SdTc=6wI*ϟι䥰Z6tCƺUxMuv\b}M.? %fX^Ed`~}tFr}^QsCKkXqy^@/y_,=Ed.tyLO0FzdFFZFLZ}PJcaѺzzWU9ʥ;0ډlӱ~904kpo-YCV> ;I'5D*M,aŲH9?|^u6gaӍ>VٝվtM>cw 2߯xtS)ac[mG\̐[+s^4yհݽV˩{kK7,̭FO$s~ҽ |I=M[G&{u*ZP63cWR\RyTS[[e lreU9ekt$eiZFv+;Ui}8Ty=ͻ v0{#VKG7Jt4@g{}W3#$`qs8gJN* 9*]8ߋ$s _I6A>JU ,b*OGZLn|+>Iⱌ}ob!(yv-S4+.4 pG=jr{.4g].maT5*x+Fu+ťm= oxfC6czdیu%MEg͡8[zf$IdsnJ6ېN5=+Յ4J_hao-|q`^G!Y|ɤf;` \cs>Σjߒ6)r$v)j2ʬʼdOw+N2kQN:_[lOxFM/M7(. 0$OLDniԩZ.TK:"+ qmsAT4g[?rS5NKɗ<;M.5M4J80R8."-'(l}/c^}?hi 2gr:cw_|H֭)E+o}?#fe)Fpwg_3<ԶyQhKE_&M7N7]2</cx5#wݏ\f%W;@Vi#ö$q3>T֞_N5)Pi=[y3>j . 1?7}1ھo0O_k5)Y='Ec? ߦOӥ|愮ɂTR؁}mv$BG3y1K r2?:5.mSacJ_k.&;Xors psרq\_C+s3Fƞ*U$''p2:tGWv;)RBRc>q)^TeaѤY Gq2Þާ ׭ZU0Y~+FkgJP%,-.+K*cPg}]2Tq1WIꮷW6]ܳZ7W1Ě/A$Y/!oPO|ѣWOҍH=7[o:eJ8xT+~?Mi-ήdZIUۢGBx#=Y_tcqmeO;*K ZCu*ާ=_bI]b0>:DREhUT TzMGx(՚QKqL;E0 ˜=G8#mRv:ǖ[,+ǀ㎌1׵\T߹5^im+I[sdׯ=xtR,z-LIq2jl'_ZuyFqK+\3K2$Ȼ d}W]8Zm٧rdWm籸@e {ϥvQIsu/#ZQme0SG{>xY[*N/j}&/ܚY-ѤLn\maպ+=~Z˯,[Z o CF0=<69TMy(IɽFUg xI?BZD$2@ 6~E?+jW|$ܧeG"[iN Gs{?g+d QcOk(6Ursq] y]~G-iTRVi-vA8cӻ`϶(tbcRQ&׹rcXdy1'w8*2z94ܤӯssVt:|ԚѭbE]@]}(JW[\qc,_hЪvXʔ] ^\jŘ.&EFTOҹO19<ߛqӿk G\1峽!P) GnZ4iеZi[kU~nj}海2/i;)h$«/̼{ qӿXViR2<~0no|~lcoL+ i?iͮs.vc>2isJU9'w!*#7|[nkS\} &-*q>U9th9rMлrnEFIF@#=_lq\vD8yĨo]0/Φ3|C E969&MČp~PFx|jsMdN umnXB3p?YŶcd܉Mȓ=hJ2VJ׸ۋfvazP;Bے/*^V"I!ȼ;m˒CZtot_0j2r3#I G\B*p̣% 7Irn˚ &E}w)ǚZItF+.FȌקOj%DS)CpH6۶?κd{%ͣ};x\ne%B^Z(ԔyV+ g<+H)+=(:ihWTO zTaf3}V{*EhWjUt8cixw aT.rj|Ɔ߫7ێyֱI+}CϹY&A2,P嶆}֐#ju?SZS~Uګqܧ;trLb߃8+:h2iSrWeY.K"/9: ֶJ.7L}y6+iIWkddc'aZE^Sog(ӡ j1i<;w$d#= bV!܁ry9_ʢ猒O/'>kg,q2c'#^vF<*54}ذХ34+ sӑmmImm|f\c=R/iʕej^G{4>a,s},o>mFRTŷm -Fn|IH㿦E^qUL?4S#+}!UHݻbIy^Wr"0(vx;T=["Sޞ.[Cif> ގьe/zI&>k kM$JCynH9*bLUkrR?j =1ڦdXZ0VYp0$ Gs^VҩnKE&㟟<y=3c55h[}^$7ʫ򟘷8;R:s\:/ow+Hʟ?fG~ca e=Zn?_ҳYSu*FIro7ܳgnKkmo~vuUN\ R C4,pW=}+:IVF}nf[Bd<Ȇ]o29fKIms^H1kI5uޛZMf}֝IEӿNḶdɲ;,甫20t~\V?Uܤ40p=;wUTlWy4$̬*=E_|CSݍzbO!dlj_Ʀ%y,<*/uRIZ99U<< hmN}9ᑓʁ"],j~UzrMhVe)N[u A]H=Τ[|i^|cOq׏S+*w4ٻtym 7V>WG++K9TUC+W[)J79>ÜsTFT6U%ȜfJݓNHܲ4ǘpz|،IY 3(Sk-Q4KԊ$>k/*vl$sΒԥPVVG
    EUVhe+'`.3׿V\1mM)U-ܵжT9gD0qmj>kin.>yiV;Ҵ*@m,I| 3;qv~V.T|FK2#I\oWr;tEli)]j{eXpy:վPqrkUdΗ$u-㸶_کRŇj^qwvMdI6 J۷6 $ןAΥ)Tճu|_Ȉ}CjrkɨIQC۩.Э,K!{ZF\}2v-2ǹ.pP;Z|ES^sZu,agIrܞR{ 2ci)TMЕB-Gn۲dkI8o/^,h99T3jݬ4 B|w)8ZNW\=۞88=j*N2ÖU*(r&;H\*y;VE;s2q{ `t^nWvN2KawM;8G=jX#^-F_ב% ,q#]g xPqM58 퓐9=Lc^\H`{Xmv#EIE;DuҾiNeSWilj%QF6.HԩyhG=#2X>߰*Sӹs\ܢ}%ʨON3zfINveFtybGw8L`g:ZS3m=x%vHb;ܥ~Ʀ{sSwbPwI7.6:V>_u%%4xom+OҜ5JTc\ꌤ|ʸ XJ~M!De)6|a!S+s^r|R2"E1_z5`Qިċ&{"NzZwη<^dGB$ hR[XUdtd |yXYv^QH%gcnە'|I6FwvEU-x~nsGS4`H>C,MebF qߨz4$՞ejfF\̒K;{e%wv&{͆9c'xJ΢8S,{A8'5ҟ'/-GF`_>f`sSfrKU;\ۼh@{9ܚV+JFRu%/,V@0G'?ҵgv7(ͩX(6O^1W%(ۨb#N\oM0>`R&ׯ>ޝ鄡8XY\r$dH]WQjVۊ3"9;KXAtO8/jO,/g͞26<tBc"ssb彸EefU]Nz{SwotiNdLҷEٙ+n?Z_Zc98C1ߡ~٥fYFm1=_z>ǖ)]Y0 f7]w=Z:.ERD+ۅkMF/mg+sӞ:SR\B9ss=R̷DYd[#b ֜&5:׋'$34ѻv<q*5бJHc8|і}E٦Tod~)){ϘN/2)ZHNvorxZʢk Y̚iUVyrYrǦOqXOv0M9]ă׶jkWQ冤, hy t? nh̥ؗ ünY'57啊,yHsn[ssϸ5%~VmRpVFA u_E;`~KZe*~]$1g܍s?ɥ܎dg mԜs񪌍TVnG2t`ghrs|մ\R[7HcYeXw1wӿ+X|M*G0DJMn Gדg]~M~offiV'-Y3H]_+LZrirȒ[yp21~1?zzz-t1;h)y 3~\W_4ק/Ers*^SWObڲՕv9Y]/S^8>QZnJzVyąN|0#io c+H]J%beNMB&v9E_WZwrob߯_qmsSn&y{euf~U3Q掚>Kr֥y s8}Z\kFХ6Ͻ< w0}ZhaQylJWfby9_{t玽TFKU#ZW.+]ypnfn^ijJr{UW4kNy :TɧM͡WEV924lq#$+g3bGu$'ZK4L06/={)Q8슧F++X$Hy,_;ry1\ˬU*U/ wOj#m_8MsWKS2׷bHe6NځaN:VU%+|X*s-T[Hq8;w**ra;JM' [yE'#+іFkWrIlDگ"2?ӌVnIM-XfjAsr{q\3wc=fEkI<LwOgVr-dLֽ*0@y$6Xvq9:9{v92w 4{ XZEh|xgStԗ!.eyw+mc|GQXUmcPr=Uep,|v59ǗQƜ)^KƊ c?7Czjw"Eb|k'!>f:`g%,[啶.#e ǖn~SSK!X%ܪC BrKdV<^q(rVДA?wCZu+_dEl7,߰os,I$vO3HЂqӸU"ʤkT_pX[xUG]Cӄ4h "W.jndF2k_Q34˻I?ӀHoUohzS|P@K@I+"EϯA:QR5sw]%2ЪKM1Snk=MJ4͐Ge?E9Z*ܢM#V98׿mwmRrHHr~l QtT;$S&{s rkmRsӞkMcHFQNַVk=%fY01IZSmesN3mZE[ȃMŬEےOc?ʶ[6ueM7=_+;#1I0^=sFﮅSTy{_JkDۆW}jߚR:5]^tlڴ6ң(tf܈Rfجjwsߎ8ǵtNXڔp]43$Hfne ˏ>s+Z>2iX{ͻˉȍr+=Xz/WqZZC-~)OTr9݇4\m/^TyrTT.-`^a'\1ީt+>i!,֛b31#һiԏ3"Xzu-4[wD~X̍3SrlGF{_Bմ-Gv6SS//iZ[,{9_,cIyЀ}4KGKo'BT%Z+c x$v'ӅAQӥLadM{N@8#y9Ou}-`k2Yc6^>R 9ev1ԜgQ>dظЗEFerI{V0~\|ϖ3imhid?6z5$#,D%:I ,p&w`硩/y]OiAkcU˙Ok5i]?Ja TTi6Fzj1qo՛S4SҶ[4/ -fG\UOtB])_O192)8vd$'?\ .h6=< DglW%Si;iRJMF"Cln(~VkmQbB>k-­4ཌྷo8 @cHpOEHrRR,"֢8ccRO.$zCs{s$fY d*α*m6 0Lv01?LW<'9cM?DLֱY[?/rZ#RWM]HӦ诰eRLs}NG~GONeV3 YꞋ|V41ݷ}yd-zTSjӬ6,&of Xu$988whz銖:׶hys<)r+aqӞ q^m-NI.m<`I6#eas?zYF{{TIVN/O>GɑHz%޶=ZuBBUC.N;d׹n/QI}ڛ{[&UYs`;cfR+֧+5 i &wtt5R\sЧ[VJ̽ó̚o =y#je:9Yz)#pj\ZꊓZ3G9B+АJ~Ӻ;wS -fI+¤eo<7 l%+O)ec*|\nlg~5~oeR\Ek10y҉Fm.V).0ާޱR^Ec?wFqJzΧ6*O$fE(98. 5x:cg۳ni'o\1uN.sEo(Rf5 7#98k1Pq}69cz*gGp".׷΍޼F1SG+^:kK4_94:~M:"apO'zu9QҜVՏoT,mQ6UxN__sӌyԫsItN2!v09#5Fk>]WP {k-%FFf۝=JIJ[ϞFӐbERc88vSrieߵZ6AF~eRӭ >9Μ}:yⵜFm hyG#ׁҵN+]W”%w-۵ 4`?zmmڲ('⽚5-|K5EUEey}z G:)Ikx._o?qM?gߡNQqz&Txn h+.[0«|θQZs5tiV)ȘfF *s{RM\X.\yܜ#{9Jk łvx~U\Q撼]9]ه pz'Enn^ J&`Bɻr>V%6N+ܼwQ=+{DTRVq7ƛǜ|/롥:n̖ GdQT~V+^ӥS4L+9!vvӷ?ֈiYEF?xc <F̉ۊۛq9SաSjȪF޾J#ʜ[m+Kr8'W/VO/BW&2؞0sZ{9tWB*7G3b3nylV=]3'A62tsۧ~1y,SkN6 R:\z%bc/ݦѓw7Vw#=7I-MlSw)N?2kQΤZA 2'YO{^Fu<*$sD͖$`.IBLr^8bVRI4Cwc#[GL3#yv/s9N:q~GV"aF ׺v^U$d+isŤ ㋲[bc0w̽ZƤeMJKΥ+ϖ7Ɵq*#QJo sВI429V^UmXpMD&؉X}ǯkNoW3xji:/ۢ1~U1];FT6mu$Oc>en $1[єХ C{wר#QSċ$߻MF8&/IIz*8&"VWnLOj'.#r.p_#J*Jh+w8gUupHWNWƱyfRmTA܋Gj۾1=+(qd>!ʚ|w]ӣ Ԯ8kإ/e qUڳ:>#ҽ$VJ_?$k0-bI2: 3(iֺ'kKM)țfeeKS)rZ~$4ھKdqKNЄi֗+U7uPC=FxSRZƤ]Is43/#3,^ sp ~QJU9B[YY@aggҹN6kSWOVbaUKfrUF96\j4[?ZRﰷq&Z Y?{}{()ZЍnh?y\Λ4ƒ/?̱=+ds氍7Ԗ5Oh./̥I x:柵B6V.4[H G!.OVRҿpr4淳LͺcʸEg*Rj]v:#N=&#ܸ?x>D#* n5%'MJO>5R6ꥁ:K^RgF^ku tA QƻV=GJ)^kLᢢҾ{Il]л>TkG8' q3ڊI9=՜u{iɖKlȓˍKH `:5EՌ Dj?g c!{DO38jW,d8ШVBhP\HVOB;HB/ʔ׻{1Rt!sܲL[Pr C_gt#K,@*>)5O%FŨ2D=rFi<8ZTz1նa뎮e[i\:r+n8| mrx2>jɭF6zz ߹Ve~f*T z4e\GlZMl18|\'gQG}M%ҭ{ӜzkJ~΢m*Ɵ,]8hu6HN\1R^0斿5t\nca2O3U(VROTcRQR[w.$Pi"n?1 8Oֺa(us"W[,v\s~%s[Pʚs"+ψb6t>e!YTy5ez1M$`jb0vn'xuԞ[lM'cSբ"Cov|00:3g]QicڭBrt[_M2O*a۷s=x5FX|(n>(C! ~+WNvo}/v:㈯_k]l;vI%= =)S'V6o[>dv HM;huok%N+{?Nޛ~^}+]9QAɨ'X}sڱBmƏ,\аeT\9^qp)TZ QfV(U815L=ԌFd,Vv1o,\=A2+V(ЯY/ym)T׏RT.TU'ЖNv Ey?6hq cFUJ^74C Y|F>NHJ4i*>m"uѠ&we,:xxos*IFɍӲv=_䖍~]FN}k>]}{OQU}{`IkH^l̙JZ캝߆Pa墟}sQuJTTa0L$AUizZNqVnTgOnnSWHf7Gi2[ q?zICb$EʻH^!]F7S)BW9rcK'񍗔^G_̑Jq^jsEBCՃV-"m4^Ky*K('Ӟ=?{jzQPpգ)'wC$գ Z90ʤ|+4krriZ i}ͷr2nVt]uO-uh!1#r*AJ?IjsZBa(_Lv,O۹^xz9Ke(Wkd>Һ{Y560sMUs~OoCddanRG^>ԳkkhʤjVSW^{HԚlfgYĘ̪OjyҔ]3Zϸ77QƸ+Z? 99c'xX˻ wpwIE;Jj6!e>Rݬz0!̩hռ/dKF@&ڼVi;Nf]ˈ/6++-sߚ-/ceZɱ[#,ҸJ94\)3ԫ;Y{+hU[?̬y5ndه;3 1>uO zQrm_bŌ"L˖NpOn~Bъij\b5iX*̈xQ#ݫ.1u/GrfB͵QP=]NTDql&eI=sIrU9mcKLbs#:Dy³snD.k:4VPI #ہ~9gudv+v(Km9Q-i\h;Oo/çSyq"rk_bj~)\K}e̸/_\sʫ&=MrJdNjrt8kE3\񅶙nKv _1n{Frf+/Z -L'69'FO_)/~nܫw[1<:}I$؅LcRN3qXe^K^񎏬D_gw?׊=+=]sIE,dH%BԁV5$Kˑ%+jzyx.n$ '⸧V0z+?g%iM8> IritݓsOw+e[3Gaezy͸`fNszU)EoԵc$H>i !=Ϸ=+҇Q9SNNoyH~c3֒HI~mWGbUPC7מMgVħc+3c0s=GN3^}H-[=9JQKZHw4rně]ۡ_q/R%RK54njý#Ef<9'ۥi%2kQhmݶ o޶=F89zW8ƟMQY#pXݻxQ<^i;v~5k\,Y]im-{!}8 "+˪_ *؉&N׶=ȼG{Y?$D6^YK qNʨ‘󾸤ӊ٧vgֱ}a)KNޟ'8}4xZ֛ ac$=0l{9lDSN]A{5G~Yj\g-6%C G{XʹV;85iFem<2ɣ.[q*=OaǧQ;Ny1/ VJk{.y 潼Cd 1QxqkZUnoiӴSc}oK ^H2[bZFL?{q~/,n(6i> dmFI^ߕ[-W8>8O\l~O)SwkMWyvjVS:WM.[ t,W7MO_+˫g6>w6z< ΝNu&շKw>#ՌZj.GO9[xՍPcʪsٶ:s^%uZUM%U^62ut,6jG?.C=~0+9Tg-z֥ZR2 Y졞F$ Ȳ3~Ьɥv*4= vZUW^KG ۅ@0xJIKwŽ"QGVzu/AXJb,2ï9=:v>*ro롬b[ەv]zlRv1_a%9ێ:SU4w_%N5L;ﶺ?jEvV)RF'+"y GiT^K50q{5DwEjdx?i~PNG8Dr5=fͤzuszu}frr +< =v<:x:mOzL,94{~;Ko.ډTT |;6sթM-oo> o)=j:uo-vѱ G$qm_)JRR53H׋n!STl34|N |a^Zj5ebcSiBOZ7_/3 1 FЧ7-7GbIÿ~6:5W  5eNQbgO]7zY,(bqɽ-|M;~2Dk9DVe|$I8‘L#tm߮}ncr`SW[;>mnv +ƶzOlPd7K e9O}6OR"T?bR]nUa .տES?7yOnqӆJ[4$n'5^? rNc^K7wq-ն/_v[z+>XR5!)ܿ>^BbQԪa4FmK1U$5|_LwQ4ONKx,Ux8s֥\;9S^wim%ǔdlzz61}+ζRI$K)U݅玞yrٚ<=:Hr0 J.;=0F2 F̟g)،Ff#73)9-~oB;h$[`U?v W,=NUg#E򮣞;\@ zD(h;9z~y-"/@=sIMiMZx ,ͻbÏלWM9)F=g鿧t{8O9|d?6q@=zkЍhiY*|Q̎úm%f~*sl[sH{^NemȦaF%#玽Һ9eʮTkE%J2(̈rIp1JQc9Ss*?*xtdEj47ʭ[.2wһ)kC֦וmɋEAnT-z=8iQO:+ajsGONElA[$0zlqE%={X(~_ fVNݐC*gݚڥ8]CɶSo|1\65qVe+,hѳ*0AҜTSr^K`gc`>TF;kXsM*u%["t/f??V./cU._RcyU˸c 8cշ)CڄD-t|KykևjM8JE/ϰnPszqnZDB2+Ќ\,@V%U_JOw(+`{W74`w~:]5Qrђ9|*grryV2K[m̢9Ul)#s8dsWߡ-VT b1iS:v1VܤI_\ҌwsSsCMdgJ#\+7㨺:pTeFW "yk'e 9du^#nO^?dbfq(DZ$me[-uk(F!Un#'8G^RT#%;>µ,}2;Va5PԲne<pzrI=Qrʗ]ݤm&il^Q/&F'U7.ULqZ{mOvef\ x<εc{sjPuayAŰVc3+h\VjRs?w4$H<(H9c˯lV#FM;،Kqp>Q=Z.[^ڗN)aB"Wd8&8\˖JJRMi^0Oھ2 {UVc2%]n6f>P6}?ZgWqϺW1MA=yӔU9EJHzbl Qs+z*<ڻysjHvO1yz]qP*{.Vlo*:5DWU0~Ln0s{jom54ʚM mynOvf'z151UR5hKQm[y-{vݕ1p=iRR%$>A6MmUG~(4#=ŲI% Mʣ7.Py:R$%+Jvqq´|ͥd.đJ۝fخXwN~bYImXn%m<-u SY1ZtTQ2$/q1Tsm4wQ=^pԆY2UO iQKF3W޹$udhd?ZhJ1^.[ (jޟҹ'/zJS;5[%VܪҦX1ۣ^9R~Cekirl:VjRmnժKϠoXdcQLTN}7}zX3+Ii,F0{v^9jӄobBy'מsDo?z^Kk2\|L~u\Y}-]1WrB~1kSoZhG=;5e$̂ٵ{4_{1.ei/Բ@n#{IrQqmGO?uuĮEp̅4nXy֊2J7n⦱ɮ̯nZ%fG_սlG݊1%6ԣH nsӭoF;#j_:2emsb9ue2wHҤ}pB6*/|u)4t̵]ŵ+,aUWۯ[ZnR"'Kq) ^{ʟWZp*k$ik")@0ay/,1p٫=-#K|Zۻ^~n<g*vdE\N~zqSqәZSM_G<};=ϯ5c +J7k=di M6NINQznZ9S:J;)ee ҷ玾g tb&y#I&-0b)F2rD,,^k2Y$/zuSN&1cX$-Xo%?1?ZPvijQ7>XO-dFcOCOV*rz\ICF_v dc ]nO4/ye1ZTT׷QmV]/͏^}x5#ԔH.KU/銟v:yܺTc$gMm,q۰+v}=0 MIF72oM4m,CΙ =*9{Qo]<~EUEʑUlz-FH7<<1( Q|\Gu%zsYc*I_ISgWu."$ޠwޢݤsǝt0 yMۏnT՛汤ӿ5dM2,w2n\qӮ{ºRJ5#g4F q&|dla1?->TXG-$UD˅%>y9>/iRW2qt4meuc†/_jYJȈhuYM)9~*KnRvjY~fo,"R$d?β;sЩSQ2Km$\y{?n6$Vû_q4զVx/8={hZ;~p4ˎj!qDj.~k잝, )n ݱ1\ҿbM+CZS w15IA\b@d%BHקU9E]866ANLUOiltK%eK8vY8<4V=ΉST,N2cDk.i;((9s^Y1ʋnN/E:;B92'<΢gEHQԵk#+EPs''_´u9iƕJtՙe'03sFVҬ5623rWif>Nמ4P%ʞ.`ʾ`$ʶb}ޅee>ؾE]q^\2Ol|#b?9,ִENy1}^3Q)kcZ~ΤySؐ:x`߷zJ:\#'%r攮i\g=O3$ onWӃ+et8Ȏ4tUK*׊=cN!Fxr6SSPb±cV_S.gx`9{۲YMtQ$xi¢6WԎѿvfcN9;4e%UY•fG#:N⪜jSekÌo#=+JsÔe9]z!Q cAbG޺Qə5%c/SSq|˻s ܪ֖P$ro`2zA8wRorg{\@n)uVAץ{nUu+Z?t[ܬ"9Vdrprǧb5FJP|ۚӛ7&Mԗ,r2n9<ʯnG}ZBڔ ddY-%Vty={Ҋr勽׹q$~_ $tUIS[/;1Z_f^ Aj }w*w/<g[KE9^F!rNmwi}ױBϻjwo$v9WE88A_tKݻ}s>H'iXnfFp.}s#:$yrVǯ{mW"9'b/l9`{ڴyʟ7+5,5rnq}03Su{SM5hsVە?V7} ij+݈fˏ&~A(I'mWj[HknU0,+9[\ƥjiW)-ɵݣxz46h2{gUmˆMZQ.]&)2<81?u9e ]HT>G k= %O1cY{lT/h GurvR^<nԞ q#vD){V#6ّVF$v6~^#ݧ<ֳ4 4mb+#u*QИ.xԌiJ)wd,v9'=zV9uk)(̑1i}Ř3ڢ-+=&ʃ8lsiʫ-[]e)Tbn|^14h?2p>pPwESrWl$2)*I#<֖W3r~\HH̫uvZPRM;|#C% ?fLdgeR2aTrz[ "lr1*͂'P;99{׺zЮdхqʬ =0}q֪)lZjS|R;cUf!ߗ={ s҈Urc%(?V/rȰ+dgڪJ1MКQ4F 3t R`Xnoy캕/g2J/93gTU>T1唒vNR4W--MsӁj=+.J.*u U|S+yUtѕkV-jo oNyDeyJN> -2Lڧ=kj(5F]ΦTGW–yJR7EkS:QKt&OyrH?G8[SQZwѣF0eD*Ρ6)-3z"sH)Z"X@ξf{}*ti'b ˙\M1ZD\['Ӛt[˒]%q-T[ݓJƧ4j[xHG47!<_0Ǡ^V5-+rrT&ԶtIFq=k[I%.YS{mؑ1-TFЌvɮj<{SBkhdBfl󃞣ƹI߯M8{8n46&fQy=\ѫVC9sFMG!Fʼ\}ނ'*p潭Dncry8̓sӾcjXiVNY< ܓs\Lw{u<4wGosӏ}yh,Vvp:f1zƦ"tO>J* 4o<NFg'+)'ucIԍ|Knt˝ֹ*SCrIZ;u"EcK5-c4K0I qT^V ۭ*ܜbGLU3<=8r4[42y1ޫ%;OS-^/奬225?Ǩk:)9c?a/cQPfhDlHu =%JQOg3I#D#""qJI|)j̔3 v[dyi iIٴ6!愸Ǟ{Tg=*2itM.M*[bnª2mr˳{ ,$g7|XtsKOCrmY Y$7>=6L쥈N*oJ=mNA)x8Nw8#;}"r~jtl}=:GZ鍢%zX9F4h_z#'$,|rzWNNQqKgRvJhUY$c38jwV)ETz(w+"Wo=+"2Jnm5 I,7nOep*:挶G]nfOwefUFx>[{8NI)/[R˱i8##clH]+̯7amc z %1Wn4QԋV\J`_ʦJU`=1M$ц,ye= HX:(F^P"{y!>grXz_tr˗uQu%MEZ;+Q%K|]y=@+b$9ya'M(b8G VoI{[WNy[Ut}Im(ɕ;o׊RZMt̎Oymۗ#a(^4V*k KiCps@e^[y֌jF4k*B%ȸ+ D$0s\rj3ap29"_0,vdrΔcZwlL\XmO oGXs{J[uSSM.niYbt|y:tz}ړOtbcef$HCc76,iZXlDӋ^S,!THmu8F1QٚOE KR9/ʹRyLw5ʣ'Uu>\}dUZ2.[B;uF^bۻ=}:wu.U ,xxڹSeT.nRFͷaf+ӍIgJk{[uG%]Mrv>l+;t!RF$H#fR*t'y%)IoSa]ªl͌gkON==|UB\wa'⦝?iSzܞ8JE<cqЃYn3澝z9N#4Mnvȸ ӗ$ٶ*:J̒Ĥl6aPCxt}RK۩է*T⹴[;fCm+ǻ-^}EY.tN`"cjdvk)G7{A_WKbWmu`: xZ^qI-7KO0SD0ZULd8$5+r~  ySw3qc*j:_ȼDI$E$q7/##hnI> A'QJjDkS2+&HbO,6~lgwV֩tV{7%`8=[Tte |ݖ5YQ,{WJeR)J1sZJިK4623cv>oӷ^k,J:rb ?'qIYJ**E59uڂPG߼qkyjsw5KǗ$Q]N9SznW- Q#R)KOj[R܊$c |W.>`? sU$\YDek(JZ~VgsmcT+c#?^2ff*\+pzZdcʥ[E^htZFw;fQ,>3t1 8M21,eHvȐ Ak|ܰ'opTjJGk>؀ěvc28yb#'`jE>k[>c>r]:{wFx9tr8N5#YMȧ {[7Esp$[l Zq6WW/K9N:KRGh|{f7c ޵9YZ?S},@nnQ'_8qib,Ӧ'yԷ>$A$oa,j~V~mSN7Jݺ"N^RQiԄZ=oհy&O?_2=}+ۣ)&xiy:"5u T~ F:ҷCڥZlw[i`s?ͷi;F=I<|_Kh*qtd. ;)«;zV^\V/F$U!OSҚ6;#SM=Q$(, Ϙ[9޷W:Z-ѼEV5ټ`P:t;ϖ*~xu6' Գ2ݜn}i=7SonlylGy%3<4M;,͹7qd~Dk'N~[8݃x^^W&ԅrێNܮ[jnփӏ.qEeU/Ð?2rzGwTYB@*x`9U*Mhghmr ՌsFZI;K"|Qq_NN<˝pFI>Z4bc̴M.U囿]*2]yq7)*0i2OT)KϚ~X74g rOPH+oc)FK#t ,}vn:aƝԡ}k ᘯ%?ɬeG9i@2?95ΕX8۹O >`M sJG$/ANU]lo3(yǭg.i{{t #zONRU^Q$qWhvLIj񔣿eNGg29mۋ/ wN:hڜʤ~b/V/U$;W[lX8Ƥg'gc"kkveu G|+2Z4}-دYߙs{W/t9Sأ<{j l4a3}c^E^%%k W *GHB3Fz}랗%-/b=JK\xV0Glzq{mc*xRRW)346  2^'휩ő*LV[Փt-3wu4Ӕ&~G))?FJo[%䴏p@S6{U?c:rbfv99[IKmSGL8QJ? >d] -ICyq};hэSI-nEY[w :jN&Jr'o_bu$@0=y]4ϝYӧFNZzjZ+}٘#9ݍ},(B0ZӱiYsA6ނ1?ڽ6mIʜmߨNd̢?}$EoNR:#nTBxP3Ȳ{T]7G|3o!b[sG99'T4jΌ&ǖv_Ƕ{1۠^2]D@dǿG57,Rc]ZcKp2}jkj#X[erTJIhIR61]wxc6#*k 8f9>׭iwrSs~6q[!cԇ}B.}4*[ǩZ%\Tª|R>n ܵ%>^Gl.^OQVc"C:BS 드qd^֥8Ԍ\_f] ow;(vy%7^W'?Z~glLZi[-j.U{QV2挒g%ZqSAcMM`v &FW'=jfrFT;ۓ\^dNUY[b`<[M*;uԊ[x"_2阉A<׏s\!˾6ӼBKv08vMe 'RnsfR0>=ZSOڙS`fhRlAc9JtcN-wҩΕݐ8YGL x鍷yHWXa,qsT&rFjC5Vhyj7݁?/cGzRݺ**$RIUTdeay9ShYM+b][`eڹxڤs6F A#F‬gQz}(\Yj}D#4#+p8eSV5{#iY"rֵUQ]*?=jTўw$cY~40'K{0B۸b͏ pONVRuZ.}aER wtcE7w=8:Omnr:M"OʮyYܿ^|cz%fpӭRl]9$͌; +NU٭s:ҌtIO͕eQ'v'sЩbսJTkFQWۯ@O1+N֊Qc7.-Ngg^D[Ҵq[هSߋj],s;dl9pEgZU%$ϋEFPۛcH '?N+拫k jn"k9k{vݟ^A3nS:Ubfg-mݐ;wNz?Jq-jg,f&fE5漇e^B*Q`f*% DDV@73$~õV3N*ZKV|]򥺸Tx@=r>-BblF^MQ ݫ8U6{N#.'or9J롆ދ: &ZLeFx2ڿ1RLiv818Մ*q捵*iԋWuXZN.db.ITvf~ҥjJD>ۅXc3s;sc߰TEm=qAp%/fF9=w^Lc&ܹzƛ} zWdDc JEʯ'ҍ*jI;FFpSD3 mƥrKr[X /~@U*qI7.ħ9玙8tͣ^Y"Rb=~ܻ[ްm~nBvz#)ܸ$xwc[Bqzgƥz S/#:}M-Wq"vC-*3?*#96ͣ?ݨI[y31VtuU(˕kr>!Ot l9===vѨRJRVZ#o.8j0gby9u8+Є4;zMT[w)St-. 09"jq抌5#niB4dۅon=ХIIh9'x,Wv{dz-V鶴hk2$r䓞g]q,lwy)iR%HfnP}N_(z,ѩ}vOmSozb[̱ sqS|ҟM*|_QF5j2p95Zs_P2w pvO1jr?Q˧O$PʒŶ$>)J7Oz:zgU+yVڻstY眣Rw446V,%&iBEHF9ecidtkxJOMhTc.~~WS-ԕU+Hr:QMsE^竆:Jf6L<$8dH*zq\/h Jp^L^f]U@ªM8O[9tFڿ)|5h3#M'gO}|ɶ 'Q{ggR6 !FyUbҾ/h]%NsaБq¥8]u:0%N|s f]Y_8$ǰsJ/(5)uCB,0G Jܬ1׿SMTއZr.n[zr~%eyvs۷9޽R}IkpM2BKnmd?Һʢ:#r8xaM F4x,q^F7iʝS={+?m)٣o8HQUx>!&{ѕ:oX1Q"B?>85Tcn[qrs[wluHbQzk Jn嵍-fHnm~n ؆'cV`GѕgTCo 5F­IJW54릗pf![єd2Q撄W+$M<>v8ʇ'Vn\0L=+ϯJ꧈~˖3j|l5S*k5(iry߈]`1W OPPAl)FU!vhYK'*Ccy<څFRݺi2.ߔۜq^*u>=L\T/_t}O*i_#hImNk4q 20(8帙S%{q-c~TۿvDŽ|+H7D[Zw~ǾÑ$bSxTUK)^k61+nYRwg>z硯CRW*}ǡfXBmOЛBĒLm|P8=xL0уZ;JZK='žcݕn,2XWEvyvSQNvsʥEBuS{7o%zzկYhʔm8UM kا:ѴS涻wzzUOVUU~.g햰Iu0"2 eX_qܽ)vKt5MmqfW$O_)5{z 96۩䗟 wo$6)`h=y랣8⻨ƧK뵈9m)|,=j./wU(Tw4RKm-AgӤ;|Q6l{ELREy5}UJ5J]6[|Qy4+G ^ 㯿b+aFpjTh0jin}Nso4!UT)y#5VF.eяg wcmmR00s۰]|%Fw[*Q/g%\/ &Ȗ8*\t^8WMx1f8YFkqAy40' 9O:m'kv ZPoC+Dg3&nDc p7RclSݵ[pc?ͺ ˬ_'Wc9NS?hSKMt>8eKN3>X,o-XdO:qԫG^=QS')Ox~X q\89ݑ"V=VI|Q$ Hjm`-_I癇iRwKnڻ.1^jjvޗߚnÝ?BXg42[rPAl0G98qdxӕor2ٻUut\c)֭^2o5^wWNo> tZuk \ aqFJ G8.37k|`g9{E(M[Z3|I?&$Y]ZϭMta_w"UHʫLeKYr6G\`7t:=>mKPl- / ,g ]tpo/+֨❑:/+ )||7zWZQ}Λ?oViB6flr{~ Qm+J*NF-bXaU`}2 }pT<[]:JJorWO[ r}AmmF TSMߑQ\ͥ~_?ٮy HC.GApT=ZIUSCk*sYCg' TTʝ7W~_ |+{iix|`Dܫ\VkZj2gxjy.tr[_9-s]K;>'e4}x~ϕ;{#==ZԊvKҒC{ T/<8r\G JQI\ܯ"-HNj-3U:tWK9"] 4+ )#NhVZݭԆ[gsE-͢C).e !>kY+YyyFQVMz G4G f c=7b5:֤"Z j 3g((.XR׺[̯*Hr9Z{:rjĚ CCr8U F+S< ֲ Zԓfhly7), bF8r݉f-c`G=ǨB[1ҩ,w}vYMl4tq͆psSSN?̵֌!}j%IRU+Jo|"꫸QP{KjV3] G0\pۉ'?eN\\g{E:SYʄͷ,P%%j:cq¨I2w0'n g#5ܩ5vJ;뮄VWjį$`yzu(Bx l4r}ڣpcjumJױdlθ^>;Q: ب%dؙ6T$2@㡝Ov>M A6/Us`z⟺bM9~E{MhV!FNzJI.ouK7ѕy ;WJi2Fa1G >/ҹM+ʕEj4 J7;@l޹N.1zvU-d u?OVйZ+wqp#Q[vO1W[{n<_dG98U"ҍ6kE4vҎe P|ьD݁׎*E̅)yqy}k˷=yjMH5I˗AWo)+2cҴ8s:qّ"r̪۲Q[#v{Фǹ+ބri48 nƴhcZX:ṃ#% W#8U8ڍ:6`Hϥm.[#:qf~u{Dk*`>FQtF -^M|#Z4gD>_PGey#yb 2cȠ /A:uq#[lʗws; OvM}mgAӓUR#(ܱN;TBW9sv#.hi գOo"K<ȻR8s~U[~\hB:'БP?ȭnFϹU+ǙKR9i:zrsMDo۰Hdy r~ϗty'IFOa Iۓ9yJ7e] @ϙp2w?٩.]E|D%Y28SEstQrRySx2FTheHfYtoQ[?KK숔UiYwe as]|ܱj*1 r` e{3XUЩ|p"m¶C09>8تxi|WשN`\?23G%yHgRp3zףNiE*LkXˑT",p8q=+ztӯ#RZ<#k$^,t4)8#Z0R7g~ikmAeQxCU9^G2kh@VH=:]9ڦXysɬne6 }fHƒGv/B+F3<ӷz¥9קs/Kt٦17 Ў>tj2){9&O`eTjZU.{zu&)Y-aM}]ï;g7FɝJvtTU"nc>RFK~~-c .gwSPΈƊ>׏-[~iF2z0vDEcczZqAVf?q3%JwcOM/,*$5#+NnMqg< Y\VЌpG^V>XǯȾan3&\NGCz~"&ކj5.9=CS_=Or$\)A d(۳G2MHQ~dL 6m4;`:sϵe&(VD]eFf$OzS5S˦FWuvp}(˙E:#UVgY'v]'>җtf[[/46vvFNp;Q$c'+ 3;Asίv? T-.Mj%%Ӕ@8vmAp:|N~dQR2LT+4 ٟv7bp2dR>EidFH3J R8jv6䒷;YWʵM6x9ڪ\1mCrnrtv`~RrRس LTR2.vf4h> d#@v]àx'c>Ӗ̹1X1-ջ~?Jh H ?0Dx\5JKԲ*6ivc <8?Қ[e "%\uc}Uq.A9SC[Lr[fZF\L%~/] h5{ m<{vN*rCr{Wݷ84vaw28xe`zRtfmuL*(=0Oe+Jkt$L͵ދ8e)(mF4e.E؎GNdMLg˸J)&$K37Ъ(sJzV6 . N}Nr0{s71ϩ%aFqIkHKM QEy/A<}{sITQܴd"h!6l)<;qޜ6**^E\nn[ƥg=Gwx2&z(c}t\=f-N-,q+~O=zu:oF&U9=t1g%U[ Ah-*GN/SNx\Yw01y}ҧS9J*Of=b @ u:qֻ!Ң=ƍ%')k}KkH aM \VR͕jueoo>$9*ٹۊ>̹dBgd߹<"XQO1`(e#JIN.%:T_UȼѯƩ]qzq}+iro~eTGO:]n14wpc+.8I=zpo+}֝ Ӝ%;Oۡ4Oci\<{·QӥgR5rZ[%V4\׶-Y3_+#,tGP9錟8ns{IJ)*2KnM PՏ&"1^qv8=+5qT*>KRoDY_ʞch3X˖s47(ݶ3o+Y 8' }ttSd{'o$w=4y) 5~5@d?m#'潢l.}Kr`9>e_0dI3g/gciƟu83B{f@v䑜*f|jN"ʻԪHQ'ֲm G+I P2(8P0> #Ids/@΄֞fP';ɿ(-65]nV_kFy,ҲSN1WFֲ:%N# #/Rq M!.#݁:s:gw;ߚuMpeupge%Ya<3z2Z\Ȃ8˹beP6N0~_w1Vԙ`؅*# ',H{q\2r4=Jq)Ȑ9R FO9x<=TߨMM[$fG xYch͜2F;E^vK[.,'$5ԚJhmwfo?tpg<:\DcS4Ezdj޾X <.v|v"9|[-痳mX{NU%MGF kd_5If`23jF:9jld:?74 MYʥ>gdMC=cGL)y[]57`mܦ{@e8sV[qo?%dH":m`2zqlٟ}4m3sִ$u[ʌ#g\@iN:E)YN58*XpAvqS~n5[HFmoF;U{?ⳍYJ6FUi~RQ[@WqA,J@߸E(Ԫqr[m""SM:VҴeʭw &9QP}Ǿ85-W:T{Vq!9lq1Rz(K ieه\qѾi(E U==WHRB2)!W'դ9'}9}oup&!cg/,m8Υ+fMl,o?B<'aҎ"$goh9$ wtӝ]Bћ`Lۑ3 m3]4c)J3ҏM'ec\L%K+yYez ]iǝԾZn;Y32E*;f3H'Ԫ:"ľXԩA6ZLcۯzu#^~#ٺ4ݛdE1R$hYwm=ziGS|:Q{-=|O=ٕnkZb˩V1%R^EoSg5RZ0}0 !R[vT=2zY˖IF_q݈#+Is%Kz &q͵;y^3(M5M$HC"oQ#䚋kѝJ|ۿf(#(v9=jq0V;`Q  ?\cңʗ/.1L89V \ϚwsU=nFGKhsk2V8?c[KƵ:^_Rȣl|.FNm6acv2;*/#uLyFJymӨīTa}_ιOᔪb%ϵCk;*b@T +lި1+S:[{xW?e ΫfgWm"aS?jt˴nkמqv<=LcVEeK|C<橴gVUPb@C. #ӟXRcrwׁ$gr(VlcL~u3Sy=Vq_WKM5*ͤ|ͻYpN#9Q,旕FGt_fPFOtrqcW<5wmL⽵MRGwLih)gYGb%wJIյ2̭HjVRưuZJZACߝdH m0#gkֳ3픥1Anr F9S8Ǹb>[ޝ읾~i&6O 8W :ҕU8F=pΘ4)'!yrqRPr5G/(iI$>҉FNPWOzbi &zqްH=GR5[9H]"X: >nz :WR^eUZՒ܆ Yj1 #*mlqlWNi^*5!GSZVqZ8PVKgUo^A<_?RRV%jwW9Bϕ+|s?|2q%(Խ{ϱȱH k 9%zzgҾWJU*r<ս5Ƹx]$,d/3=;G^x˞Ѳq?Xt/ԤE(U%@f\A>:W:fzR(OEԂ$/5dV~4iiHSZwaRr?:ƗI ~ub )+ۣ<{Z9:0gکԌ!{-NHKuM;%ʬ6&%OC ϭLk2NNҾ(5}/p#;u6ys;7wںpD(WgnXXc;'QE~`$R8Ey36ݭ$r2@𨋕{(PyeWZ#=}O4 7z~"iQR{MTnp3E#56n-(\ȁ볾G=>)>FRitHݤg*'ֹ-.k9NU]QJJq"398QGl涧q9E9ڄ|o^I>M Qճ*?k%-pIUX8yze̚h*䁧8 5:mI猿Bڸ B_Uy7vhΤe x$-Ylx*|ʤؐĬ Ro$*~*t}ٔn]ne1W >5IJbޏ;@۰$9ya䬂dgөuq"L1gYks2=QF]2̒ 9OsgUQk~Q˒ۭX%}b S9eJ.ѧʗf9|yA^ml=9GUsxƪ+'s0oM 4lYհ=Ͽ#yR2N.˯M q]]zZ]B}Yd*Mq_qaM+,3*=ᗃ 8wswT*sFO P s1Ȣ9/}}z5u،L\E#)q.cq)J)/[ZםHg޽؟l|v2c={VҟѓPK$~B F]~g8f񣇏%v- &08 {JUiN8+i x\i q8 yF4W,ֈ,]fܓG/^TίmCkO>jo)nH9R{:m.:qֽro7[߱(ڬ|V2k>]Ի;u.F\K@q['N+g^_ky[nF35uٗ jlS]M*ݢ X!A<_껖SiJQ^*3+#3mwkI{ЮYF5Rc:~qiytENi}̻I>ar yҩpGE:q漙+#cP{znOO9cSıY9i&x[7a5{hznI[ɻ/i9sShnZ)6-%W>ޣֶIIs$:׿ԫq-aّC+HN:6NU)fs$~DJә4J##crϚM.W 0)!A]_lzޝowVΈF>Eo\yRI+szAzW=9FdS8֍5*nZ.ry5-*rA %*kݫv9%Ԋ#[Q8CFxHӎUsԦ$Ѵv#o;v:sR:U#is۱nO.bۙViNG_\Rt.^{UYdZC! ppzaS۠FV];JI+'\Ӝ^q{a4K&ًG1w}5K^ՃN6̭k;#R߽"K).%nPchYdu9ܼ =Y{9s+jV5G[lKi[2Fd2c Ar8=ǕncE{)X zT)-/3.":Ǚ jBݧL38'۷8\c$vͪK*n5$6?]YTNVu9~$g,iI6ky%s^F3.5/E+v[,>a_uU9w}<{="@9e' k􇈴ܑeshtfI21Rt[Եpm6eT ֺ-ܵZ׹kbi]~*yw@'ӓ]8:%iN3osm${z<ӵ:]CN3ѓj #fqp}3WnXzRב<4jFҞ5c+W6&kiəHׯ=q[Qi+[ԣ|7f5 d/SH %GcmT4B^E_#RjKMe糶ɮ ַr c9mV5Th61Ӟ"znYaphYVbv)Jw6)P-'[V6Ҷݿ*LUi%(H/{}יnV"zݴT~#T\һBgi;"ԕjZ R4eoyLH͓ Nr}*Vyt1jXu4OV "W㎜{ HQ~~,j8t! #_KƫBvH͖1iqְiGu5l=Jn/c#]ƒt`o\~Οnvz81nyiz]ժ[]¬śtp~cu<? NMҍ n޺ޕc{Jj&x])Qq%OLP\6 Ic!N:YȘ~I7H.i]ܕr\ڦ1^쵳]NS{f!vr}:~J6BTi+$I"-#N),iwg?Ouӓu:5"'g9 v8k427oY6HVhȨT̹ndAnTJ4TZiѭE4HVԤi$>Jls:j8F+N瓕JEl)u>Z(T$ƒNKVO,OCsdln?(<{}kΧ{U4*kܯqE~{f܁]Q3 FLJ+STt:aٕn>ӈm 7r;dQ +Wz}yju' o݊vOxiOn!F̻Jnrq^cYӧIVSfֻy|zu)ao{Y&n8e8SۓR*\tV՟,[-z4!-mGHaԒwp8+)Jboiz#N7MhCMfѝ֎5=49%*._#$|,˖' vTT$lKx<'n0cE~^&Ȇ_d^2Agn37X4mx.RCXr(=ٵ}AZ1>y;w=N;uyto [ehlw^WzT]Ún.~-瞔s5rww"!;'Pi^K'WVX9_΋43RnWZv7E`\8Hzv^DBo l4U<:5}oq.ulGch'~57:s]ujf1[ӏQ(1mHrvHAgaͷ?ŽhI-PJjTQБF!ep IP{V2sJ\_ٷenX{ұ.1獯as$2C}J0F~2Bde1O~V/ &6)fdYcsLkGqW {2Sow o>U6lpXgA޽zsw$i^,=r:gwS/3Дeeq7 2ȭ#RsϾMz4~y9^NNɡLv[keOU8C1(lཆ)-q?]tQul w÷z9mգiXtr<$w?x9.TDcN2tl:f~Xym'ˏ'ޚ}H6BTVhF+Y9Y3I/i-qk,ms(yVRؚ[V3\<"POcy_H .8>u#'~Tev7 {x%w̅U?/x¤3464ˑ: ћv2r{sYQm>4R]ͻ;^!^H<{V3^򉍔+t9?+.=&*SR9<,X=֕xQ/ƊOOo*I #9"Te̥9Xgנ_5ɂ #džfW99鎘5ljʼ%em;_y2E<'wF1WRkk?3ٙ?@-N9~|; ܭ~c pUmQ?RF7t3uB6Iz=YP zwM=k"^}ݍ`#H d.Wv==zҌi7=,.2^/G#ůrN~{p j;p:5+o'dw}N>M߫w4oTw $k'zv0GLq]hև,FM_^ǩxkr$ww-'7,GOPs2 L.%Fj_:blՂ=;G?Jé[̌6.Tj63NciW)>`p~ӎl:i7~┓,o6/>f9]pz-8ӊM^Þ6J2Foا|8j0|:1iSCg}|ZV32/lUۼvE|v*Rm6:[zlɶtR*z_W 7>)gdtҲC,r^9~8sꮼ/}&Cwn<סNwl%NZl;{o!x$ =ʴR_OӧtFe^vЌzS]n>9e76UDm편RqK.7ȑ :¼W:|fҌբiY4R|ln=q{+** ߖ嶻}Iv<++ihl<˅e;WD*ܩqƢmm{&!$tOZ(V娢y877NyO>%[Jٙ@Uܪ30G<lW{|s2 f"y_ݩ_7֕e }yf%^W8zbMoy~/:rRkeg]VKҮG+I ed:s=JWYk[m%λĒ G>"=ohcqq"N.#YQnޤen}3O|ХI>[ѥ,3M6o]nV_0";_e˥*m:FyzZ_R{ .<-0~X6TGtQk4ߗ}[b_錞eo穈ӥ'M^CCEA]tV1|,e\NXOUǧ8)U嵻->c wV䶺߷[xQDzn\2+NA8(L ʎ*"獼w&'Vwi{yz|fZMq;2#r NJv5~{ګiimionb8 J)fW~}̕;ռ ŝͳCdnxVӋ}swF*teb=*TKIVM?=:ե\geSKln開nBqҸ1U#8S$^}NLХ#J`ZkqVRmЍc(,sw;y}qhCI_/R0>ukt{JY\B<xC^ tRj_Nz<5$MC V~_*=oR{gQ"՗;kn[VGf< bH/*+ Ws|_G? ~%^xNUeY+bE;FPq~.Y^&^w))Ak[>joFJHluhYMkx,@HyA5͈zpҶԬNOjmm饛m~66~#ƣfn-ZX_,d+|̓ey5 |ҝ5i~|_G[4>n#[IGR̆mwa.'ݣNcɇwwӷZ'HGpae)%kDޝ,։ҹ!=՛IUT-fgEv$X>|-gMOkFޫ{$o|YtVIZZ}|k6$z=H=xk๵7j2ѭ gUPs{tϡX^9d{eEHǖp2rz唢qJWmG&Ht>UIwjNc̴WHʪjJnT߽$rx?NI84}^ӛk8SFxkS%ѭCHfa'} ?czb)J^z1sO$6~@bq3F9εԴ?/ ~nHQ?zSULEMu3*p${26G]\#h'Ukwk(QPȹ2G.W[P_,eIG:\e?~mz9IMmRZ3IG~ %No(E fe]_0e|Gnj1踩KU&PfYW$2qZFq%R"- v!gwIlUGimNƦ&q^GsE"cjsbFN:|^w_a0'U.G_ítRU";bim2h/7ЎsIT)Z[n^3Mjepry#8ӓS*rbD}us\ iY%YwlBiU5%M 1oEv9qc\ˡPQs4};C_*0 @N{+)GI8a97'+In Wjƪ>oL ˕s5bU*u*%1֗p@Qۿ\$N~.<#=Tlr8MeˈQЎ+!7Kx[;yr4 FG{Rj?f%OBH/gn/mSBdk8(a.W(潐C]͜3]8M>b/>/Ԏι.J(ݓé"yx߻8瞜c:=Lgzv^MCf-Oza(j2,=տ jm~N4W ipܽc++]HƝe`7DۛrF?Uq斫^E*1?ʹG N*IyЏc؎Ƴ%8Ի[!h/~7W||M^TԚ1hgi ^sJ2T[y;[&0ܯ Z>m-|VP{ȩ=&Q&X523mFf98V/~W&ܡut\I[ G6ኳwuǖG?{Z{:QOS:t){F!d~soYqO8.׺Z+<,6cvGj᪒# N9(M7ȆKYo-ۆQx_CjεisJ:/N@?ʫr;exfjV TrYsマBQWOwaF9S$d2%Y_\` }:氼D֣(ƧzZ]݅F>e9 @VeJ> }QjD@d|n7qUS9d?}[BY3{W+^唓sIѕ/ k*QեvT-N)5]#n2}G~Gj1ЪD^A"]K|Q<2zkT1һ#yaH̅|7z/zΤ%RKYjqZ8ՊUbmdS,Wp=QR4PӴmP[~!6?T\u9+VPz~P_E.Z뱼1J?d];Vec.*3QsmM+^sǚLޘ/l#YBWE% q*$SR[kz n#;:g#5M)Κ&ޥKc*(6nrr1ۯJoGڝJcʵrTH0񭽚{5+%/K5 -M?TjK9]&å&f3*fU=GLWLeUAJQr#[tl\(E>^:hyIn]i8;E %&lfAF=:~aiT*]HO:) 1B2[[9*V\*IjfgC川Q6BGm M-jS aɒ8m~hFXr1d;(&cZ[5Ǚobʏ6ƕV.S&<bYF39J~C}Ws#08b7ߩw5ӨRN4n[f6,0}j}ԒhV;_w8vIٻRQs+h Q<ƎfR^dykz#(Un/г C"lG9ϵ+J.eF41g*Жk.0Rݻ\viGo"-,+3(PursWOMB*03{,;=DDkO%lgY^Rhڢd=y_tdǷ==kKFvVEoe~k+=;sx0^|܉grEj*e\C*㣻{6Y g'䅀=b>mXԹeʕkxcbq$"6nݺw|g0z9,eBɑH ryK-Yh塭eđS;`l+cdwrbՑ*++#J2n'2NWȖ;(ѹUlwJ#Nϛs9J2zM4lO̱fn*{M^DU֫K~!_N(mW$Y=#<s4m0@uRFjr]*bߺA%Fy='=i[Ls-JX"dVKG_LcJTӫtBN !-#H}g.n{>yZHߕ|QG*ASVЍ$>]dyjTshӴ^]q5~m}agN&5'dޝB"X_0o/*=**s?}JSh3<\+ޤUrǕVzyF0y6vX, <鑊\:%NvKX2)d+0*8q>D\ehMoMv\@(;;4kRS} y푦bB@ce kETuZUYx2nھſ25, ZPr 韭\5QJ f}$*7zȩE5c*%Zi0HT|gV~퉥N3;e; a`9?4sZƑST$ X|@{}8U##yS~:+̛9w<q7Qsu%#T)[rQ|(H5;05ʘ j|gLe-, }^יF}O4̭ ,x ͞wgҴQ8YIEK23[koWD*FY1bE)UT3wܭg'͡ty9yHc`+Ni=SwDpD[UWkb}G<>\*FbTYYef_-x 498Ǖu'{UdR gS9]ʲI9+' ŕzߧzmm*| , łvU {;ܭϞIK[tdmt*eý 1ܡ3|g?+nfRMw} fEU|\NqwђSZM&'^"}͸U-Ѫ(UTgz;O5uԺ8t_bThV2C4Dp$WO[/is/ι olng@P>Ij5%NsJ2|am$1ں.tzUOBޥ{?bF*jArTNyzVRhef=Cen7~N2qFG_\'Neq4+=ϕ ~\r_揾RQrv#dL1po'6~ck9dnaH^oɷk,;W'+^6y*Kٻs ^# sgV<+*rj@$ ˒L d㡬(Z/c(Txj݄c 1 s$ qۥO7,5qnki퀳m#=kL9=d]3$;ƧGӊ{N]-Cܿ4EJ>v#3[v.v" tՎ0q Ǚi(sK8Jub$VNy=W[7cOwnV'70UaO ޛI'urI#C#FUwrA qULovo(1ׯ,,Ȳۘ9ϯqϵ&c'M"ݹf#2=;Tw&1tbDkq") f;'=T֥r{$u'Ff`~U7MJN=ĭ N{8=ϧ֊*IhiEi̪gmJ 32yӑZG;trŸ*}]N)K"q39C:3I2e5H~Vf-/l+:rrc9UW0GS[DҩRTeomR7t&evsTmbO,U;2 c&һN1+i?yӥ5:kU\dgߞV|^E{'$՟*c_ھQ5+5-nr"[8#>76ʧRG8-H|YJQv{yyA;$WtܱK2Q֫i2 6v!"ib8ڬqoc$UF2iFt68Fw30do)잖2TT}ר6G|b8\Q۳ .rߙv;sag8c\9ɩQ%ɾ*̆L*di'885/z)U}%ifl#ӓ?94U(ɬ3I%$\G3jڣ|95eE9KF=I L^FbosKBjB1JI_1x<#cRyJx[ ԥhKbxۧ5&*1cשi:6p?]>k^Oom+Om;瞜fhq2؄qE|h9(2șU(7Ȏ(rwI#c=XCzbiA+"YL.Y aK|gEtSJnqn#-Dͺ5eެG#=G~kj]SK/9WbBy9cjΝ}涛2 ;,%d?{q>gĮ&b}:l\z1SNm؅]ߕF>KHʜHXtK2R:pUiEͽ ofG)y4;|ztkSI-RcRj.!cu2Xhmc;@#ه'5j~eZJ{{_+lnFc+Ƿj_3ZTaZum= ඖVmXв]}C^SfB-t \mS.oqq-_RR#Ytܼq2u"-$ ֌cu=4bzdIva83qN3ur[E*Mq EW Ќ2 oIm*0h]EEVHQZ5;Ϙ ?BPvԭ ^?V{Ovn!R`>KvQZԤ݉8KKW(0[uUǞh|6uѥ m〉β88R:}y=A=4ʜ%{hTƐGnUTI"(r1=p}ཥ?i[GUt~| 23ߧTkrTЎj\sYF^~~n{>o'b64Ҏ[hӧuz${!pd;\+.hjkIk3<6̲$t?k:y{ʤUZn: :T$yF"UTʶFf? rŹ6mN2UK[Vh 9g5k[(9^Neƅ-c]I#7Еg湣STpIlIc#R+=4 $:;5Vi] u&րO apjc[~8{FukǦW~q$n4ed~};WJOF<v!z gz4a(uʛ6F( VBpM6H`m5MS^M;D2Vl؝1N)|_e"/7H޸?]QqѲmgjHKyAJwCfik7AQ&Xn~USKE[5b#]>~uE.[F;7VcOn&]c1R%)KT2R2`3n 1Ƨ,w%+]'cjVR[]b)qǿ?yo%t_nI\yI!zt^b9RHe7P[ xa>xXyj>QI5=-eAh Ts־O0*{˱JIB6c I9 x_1wzwy:xJͭUN EiadUJ7}/}Ng[ qԮ5 )bmWЎ]ROkqU+QRT]]gLIRl0mq7v~uJR\Gn"h _#hwVUdrGB1sYWNo9+Oܔyzakxé;JFw2XjB{ߡqUԭhxv, y)/ggywk7gY 60qVypbmYmU,ܖ|mɐ`՜krKJe[F^hV6P}Ӯ=:d{jZb1+WNCRB,Gʷ-n$=_ҳg֟=hX̨뵙`;S]HFw:NU.scJRGǗdqa)ߍ{yl:Rkeg5,:ps^uӭ-Th\j~XUegv.a}vМ*idΩ3DJ71+n[{[7R%%gvV9֜1)Ի] bvȃ.F Ӟ*(Lꄿw˳$:~Z/IC4"0ڻG1zu)nLw"Ǵ|3ojZ;_i);ʵo wֱmsj~1N56XI[)JkܵcWx69 | ϖZ/{4-Gf\3x#<MrR v9f|8k4#g|jMr`o $V\:4eQ0 nDvξv9'yTtӠշ;0wu#>k~[ΈϛImNWOֵ<ަq- .gNUD'NUN/W]Jwgʦ`?sɎri*fF2@ r ge*K,uwQ$:*ME-m1F?cS +t܀\>$>QTc4yȣ>n70WzkXO1hGft}n6Sڸ}rJ 11Ɩo `erET]^|ڻdۖg^}l=RV9kSe+[OSմ,ee"K"(nx 5㯴;[cJͧwi+Lxmf9cӁQN<-t:֊uɆLݍʎsַQ\huRۧ_24<2Q.ܐ 9=+q^TN>"Œ$sHHb[ʌ>>CFù[LF':J):c)BMI:(ۚI9UH9Ú2|u?g(hɑPG7?]b7])b>LoUGˎ5T9Ċ/s2bU}H29e853o\A[v}A6.d]]$y/qw%UבԎQ-͡{&  '#m"=/]7̰Ȭ?0꣦"qKbI(ڼg=>]aXc5պ+j`jDؒ4{q) ]P]T/ZXO Ev7_lt\>_?X_A+KILsn8g\u*n?Sf68M cYnirxIS.1R{lca4:ȱɶNwgsYݒ[v3OhwQ{c?ieVh~\9F\/vg:FfqT˿8$%/y4[#4iSH Ei)EFtJuSק)3 w%FWiǨ`}ykJ:̣SRTݔnD.$)+x+3d:hJ+t(J( C֓#=j_.RTsSyf$-)L ׆}OpԝNKsIT%GtVDq\!|GsϿ 'EsSɒ\+GqXbR" cץL#)Ea*Sr-W3 uvW=/'3ya*j-y `MŰɍqqB7jq{S=/1Ԍ^sԩ;kQFD{EG;Z_Ou5gV:+:8rrB/?Onj%RjJ0ʝJ<UZelsМqV2婝:iߙ_.uJʂ{rkIKRZZv_I..$DGe 'Ma\ތz2.ĆwmԽFhjƺf¯{sӧn2G hGy=^J`e#$em20913%+ITt].l@ 8ԽM]J8icGx\ds%5J3ɗv8ןQN<顕nm}qDPXGm0Wb:KПeZ$&!e;Y,X G6#R[6BE&Uܪ2q~~h*wSZ= A˻oNڟև=,LQףnM,Q. Q|=IJ=ʕ{Iۻ=IP ~ZnS9LWJ=vv34ܻlO-[smqYG5ꌣ*~bQAh'5*OUoo$?)zzv+ܘ*sO0KsދwcpA8Ԓ+}~&U#d3.5( FNGx}Ƿ5iI4:QV7$y 6jg=ke?ui i^_r^ QM&b jihoNp[hy爡5fSqg;i*Tbܴ}zÜ6sfET0۞nG>"fסkIn#fD-!d=zzQr8MΙaHD#R"j 5a1kii};]۶P[,oV6UykZΤs-])F\"s_4}J@Ar#ԃ z(Nǥ*UzmjW {Ĝ}?.*2q^:Zo+34-IiFQ(ٽmާe<=|$T+=zͫcڡrH9sJ6{t;F5ݛ?N3&t[ Ơ#n?ӥwԩZXZJv5K?kZaJva6Uy\b0t7VrrvqvQk2?(צzOc2 QZW=Eki}">CZSN7OO# 8x/+.=3\팺V5Ͼk88[ۊLIs11n;~PqԞ:gVTqg{_!+*.cZ5:qWN7>TQʧ>k 2䩶юY [;~^{Dࣃ#ɶhGA)\=?sV)Gp}=7tiiWlo!X(+m;x{~UΪrGʣtj-~+Fa4's#vFx^ehˋ!\uҡ^%VnIU{\6O#!*@/RqTSb;uFXs-2FxҼ^isgJV!y&k g̸͖N/JTu[} qU4ieF2sߎ(.rZw;Όay_jl60%r}z⫚ S{5w^L`h DT(۷W5%(ÖRE)/B˻nk'_1hluGW4Wr9BnRy6BnAF;aqh֔--Jws.zO<*$/zJR䎭w3J%B!~SviߛTNX3\FsGl9C7<c_RC]E($P3Byl: {dWuN4r^ FI#G_+ #ޞK5^Vj3{5X«}9g{4\e ]nr+ym47 "fa2q+tr)tњQRU"l[3|_u#4rID]9=2:wү OsاR|W-/ӣ.eYQJ8H8}+Rz\UlA aY6?JޤVWz"U%ÿg%ʷK{/.|2}޻x Yӥ&qhUyWЃYHLH?ϵW',87Nn zC mTRTݏ&U'ȔNh-=**E›Iv\s,kSNāBݫ1lå-fݻPjq]-T 9gW@aTF\M^OĝD6ʷ_gIl1&qp$ҞqpWsѭT=ŭ'O=F54{mq֌;Jtb1p?鞭Bu/c(2P4zNP-BYfFvDH>I#y}Ҷ)rNQt+徒tUThnOO+M )IK O򷕹7Sʴw:hͧKoK!Cy#LcH9Xzz mkvn$!|ayi|c4-!ݤa d29ǧzRi(-E`AqoAJ++3&tq3JOiJ)?q#DU|^N<X=BQ?g\B%a+(e2 g`+H˖6oݲw+4S;ȫ/ux=xszZ5mSf|}f]_[s*o-bo"ea*{c9T=nȂHʾNIs꩔Rh3&B[(a8STFmϚ%tVJ0;FO<}3\`KX?2dO< h1k{]=NzcNWAǧpT./F&iEml;7Ճ$Z/v8лM\ `S6fLs\U:tkm*b,wm +yZƗ@HW+gw7^mJqk(SVuKVn:4WR,Vl®4ԣ:TTQϘB30tœRFRrK~ohyd|Ǡ=G~+ѧyvA#^HeS/q5 q7QJj)!|YI=N.6Qoi.X+j2Fc˸m}kѣg3xRլI h>Y|rr?!׽tіm&{h_VSg#$3vuycUs֎]>6URE/5_b)=r)Y ۄ?6T6ӂu*4Lu=/o3*,3b0r0@~Em)J/vafh.it}J4ڝ4^KݏJqۃ?zsƬ+l)=7luz'7F1\\g#N`*$wW3Fƽךz0n9fc.[iːx>ǵc(^̬Ow8c4sG 8׿Z? N[+m$ArԋzZX$~m#'wZyƛe[1 O9IajSU,̒o<O2GNt?<%>i7Mhxu1jj-۸8MU:nQZC_NRGd!Ok3mQ85UFRړѧQʚk9 q9YG`pNrG v];S=z]=JIχO9{V*wg;sH=L rѽ +(=CZ:arr@=}W tßӹ|Lp*>ڬ޸5Kݭu ]J*3iFl|=MitxH݅`#*2R#?_Op¤ -nXi16Ġv1NN{~\ѕ\:B:=|߆:[GQ@' y?^60܎ѰVQsMEYo2O[I>Pzp35cʞ($M+SF~c\zҶnH3j*F-[4D;\vA8]kj /XmFIߩQ*TB;Inߞw\*ZW݅=cdfr>f~rz-JKGDj[Q[i=r9, jsFSgKeYvK"XHeGUG]lyLֿm;̕3nyǭztܜJWܤ|C/l[˙=ZgܬއOrV ?WKev%y>Vic ߣ*B+k#*#?u۷nmNu5oQba WrFsIb1XYIKڭW.xa>;6v>G xA,֊K&h$P@I!$8 {ZoWnCrGN[oG|w7¾/Zuff=wd_@eJM;m>^S;ߺ˳~'ͪ1w4qecUQ [#1=Wޖ߫]FԢmoV_?c]2R0YSEXJǗᧇR^kky +WdGwѭMR\68 G|vp *kL0'dϞӔc]?'4$m95)#{ʗTd\99<9rk98i{GtV]5ֵHt{{;MMFՐn,8lyS8iz:jvmBӎ:cKg混{mׂh 2tY$Tg 1O\LzX\:4fzkb8j,/?';ᵭ5g6MPC{$wM39ny<{\wƝ[t4|.erN7n]MG$nQJvQ:|-nNjGSN[y#!;W ;{GjSNN4ռU1 5V;G894NIW<<--MW:1S!r#eR}Im#8sZ0RI{MlTpeY| kw=&3q;%ʄon]'DӧX˲kXݓS\ur*ٺ}S{o۬m5 2 0A9ӵ}?46Kel<Ք4!%1fn psǯJISnEN*xڟU䞗۵k h"UeP܀YGwt<3^#xݩi0-"capmU@ x95ƳqqX΂vkw Y,G]员#i$URgReb[cHv+U5g&0߯F$ Ua#t?JkToƒ8E\$I÷z¤$3Ӥ.M+$%ጶPD 2$bXa$@Td~>[y+SRnMi?a{V o1yб]t=1SNc%OsE~}F|Đ+  vSB2,Uz}mo5kTʛ2[4o[5>_7J۰E3Z+;d`r3B MJ6|_mC MB6ٵZ] ׼Ğ(?P^}vYGC?W9VN fxxn4}tu*ٕ{Ωc ړRjKUug[mkj~)zŗM5&[p` 8-3,:rjmwMiM5[V<>!Smjuo-5t>>Oi] mŮsM|Sp`%?nѤ}խ]t9]L> zҵo뮖[_O zu!.ZRk]ǰU1GC^sөFIuuGjRUGz?CtYþ XnoRդ7s1Y!瑓`/b*Uism'c+c+FUVӵ'jsnxOԂ_g(VnZڑb<.DĪ98t{TbFѺ33>8Fq苜IIIȍ-d&E UPv9F\z:~ҽi5-w' Ns{X\=;Џmo?F<ϔ3/qs׃^8{:kMUTiN𖐖o&ߓS$xG*rb%87NϜx>S6])VVxV͹>ykhԵ̧[]"FʪH\>c)|z34x[.N1<MgFOCrRkC?GXM}"lG<}k疖AQѭ.f:rÎxÒo6t`͘,eBNrcY7(*^}؉턒3mʎ;utiJ-ZR*Ha, $EP V FŕZ0Uh؆c޺VM)9Q}?h*FKd\2v8'GQ6nBȪ{ތO<+~}E AzuSPUB0JekkP8bb zt$wU\J*<쬷"չ#o<ϧ&USKB;r(\9RN=so'rt!X`HXEYE{gTʛo˩2(nPFyB6)^q QI~dfNh իPceTpz<{TU)]ʨee^eT1A9FI]mؔ=O޹}fG;g Sϼ;Wӂl5h$*srRO!7?&Sq9qXʒ亲ƥ`LQ?喉 {J~;t%iE`QqnMX-AfWUfxj:suZ1QƎE[beW;d'zON0?J1Q~Ty}+~ m+߻o~Xheϫ#DE qkN}AG=}+c;q4xVAu{l]@#f:q=MT#(4QVlks$0xX;8iw5*t͞M\YgiF&hn2h mج#W_'.)EUZY Vw\j+cY$i33 $gJee7VR"K}H`xO^p*sjO4y_S:QpX>ⴧJT32rVVPͪ_*KAG'Jt,`*0A6jYo?2 ڴݘԋQhͻ{gXN>agz9)ӌeT}CeFkMo++\z)]9)FYƒBd`x:U)svQT7+z9Sݹ0hC9FJIo+`|=99JjԯM]1I4*.\/EqqەFdzKo~XL]~ol{W%ҧYsY;,n$PјF+-=Y߱_Z暊Zl2z*'VWC$4b{ۻF~d}c'ks抶(]VRyQ.j2N?1N{ǓYTzTFrXo/1Hԍ1]/P-ж>΋"c|pxQ(TʣN>nDĒ3U\t]k4[Ŷhw|ʏO5l)J+jv$1s"&ݣՌd7[d$0HAW<تߖ; T5gJ甹efU4s+ri/ta4]QJZE*؉U1ލyjy=r/M'993=ɭc}|MXKQV9aW,cGWN41fȊIˏ 9#޵w̒V>jhmY\G>0<᳏CY7AOiA\HbVl-|#gJR$EwkKKh2~1ocSK֦d2yDlmjA+S%h*Uøo&UO 7ϷP=:=M 6[6YUlpTҴ6léJ]-By'K{/_ACNQ[%x%|NyZh^K^Pf=I.I =;ϧ/iJ>gl !;Xl򪎮y+VR]#Khς;3⭜#9jq3zt:0򫼝ⷖ5aVDlm$s5~Լm٣N) !o9TʚBiKFѭYnx_F2cQJܶdfᐰVS9`uZ/޻3,!fhY]<۵g&u#N){hS{L6MUmOnGu _s?F3LJ6 ՝K{G$gNiwW nyygzΤ&33z؊(JkX c!MǫlOo`uhׅ3zڴc/u/A-E.' u9|񈊨yra8l3i{nh-o5vhS`[;?5zz>iGm:r%p:\'kٸ۩zXMd/s\uw.FEYxڤp3ڦkkqFQ٭ >]Ϝ~9=;MOz>oЪN*$SGt!˪wtf=kJsQиF<dkVp2G~=?b=դF<˿qX`yWM9s=I}d~FS?C]6rObiÚBwܱgWDTۡ%$э;\ncQBzq^4g&g9T0yAmpF^ ]׊:N/cLcڿVU9#0JV+|W'1%ۅD:sR}jn\;䝯iC2. 6_*+bFhs$}ELysXT]Qcny5?i)Tm+܆IVL̸f#~rkHCCZ H# Xu[sTrstzvwu7g+t>[Sv^_F5ɹc nzs]MW2ӝSm4 sI>cqz.vK⨭`yf}qQ珳Gp-nBDW,sjr$t}qn/ϸ~&~RzJTN4gZyoBu'ұHMn#OZߢ5J}J3\-͓uΊqinE+DUs:AT] VY_%Ղ ^7 MSnte[8/6q`'#H>_S7/ʂ(eZ>$8#Gz_mKuf լ{9nEMdsFGs҅IյAQM[[uVYika|y7dub YN^OC߯%+Ɩ$6V""ѻ4۞NscW+߱Í$!Z[[ip=ܥZ9y[>ab8G/,6[ؽ :\|t\5%({KJĒN^ArT+y9+1ڹ?u<v4a\ۙ*y[osTxאs*^Qn.~fG==3J2z"eM6D r߹wt6o3Q \(Ǖ-N:J;Yϧ- 2JFPv83I=<5c(}KFX`s_QӍZap(ڲS85yy*ܼr_2qfY?q3wyK6DTem $H̬n<稢R2ChW ١I]UdqcjN>KQp[348پgݏϥqޤ[ +BK[dm4L@=Dw*H$cWo]sŵ.R}YYoq;, ,mO3UUmШ:9t&W䑠Vf'- o\'5"JЀI?hv w dWU8s2*|Y"A*ge;H޲ Nzv)r$eNv]e6(ZғN餥tR(M:,JQdH.1c>ݔ=Vu%(ĤUϸsNo ʤyt'24!}ͼ>Pwxn\c'5z/_B#Cq9 ۶ *c{x~VOV;)Ƴ2C%d,u0#ߊ/NQZwgo:p]n֫l荸3 +]-vSNF?i)te+xFv9⺡?Jm=刽*mo,!Kz}>ʧ~w*4e 4"o:"cmw}kJQ:%9GHȮ|飉cf;w|O8~*toȇeRv2w=ߎSTtԣ ]Siu_M^1F;/z&Z./־je 5Uث0T+3md4J 8*Vԫ9m&[JC< 'jU"Uau+0rr7zTQ_u9F~$1=yo%*iPI=_p{G3ac9z撕9>OWu#xlr+&1 G-ӷ\R81Rmv+H0Xo\<匪6֦U(ۛ}V8͊]. 8=ϥTR_l+b+۲KKsF;taezO~0\P8HsչNߧcL={SQ[[1j0]ͻ+YՊy5tys $uT)J,iqwʍYp8یqڸ.X9ӕtZ z7 1Sͭ%rIDME33.@QҌ3cx1VY|n&i#Ƿ8=iJR:m'{u* 1Y)rTK嫪%k`tXʈݔ*/@^2өEn|!kw]YY8*FǙT|KV*y FJ .uiTVTDrw(59~q 2O5&2#XlUk*MEyjik1jMF$1]yv_"F5*j] y"eBJgukS {JqуcH %gCs=vRnMÜׯbn^1g둌qDy'>JpuHǙ=yQLv+ꭇj8^e3yf+Ԍ(|۲8iGH\"1fi5f1bjVҲ-C$jA{qYK.MrbZ%jbYSD}N_ǵd9 iVV˩f+wf #1׊=[j֝Z2O[=.Yljţ0@쬔g=G2ċ=Vrq98;==X $XYeH̹aLєZ@6ɅijI%Z?/N=/m7gT!S$].4 f;p {teVҷ5w;*%oܞR)]3?i:гVk~Uh[e"ehq0FHsI&giM^bZem@S$cGNzTԔj7%l1E?|8Y+\$D1o#۷s]β[c+qmտFhy3.(WTszWF!%?~^ݗr嘑 (_3 ]h?MmĿYEQUp*Z?H矘z].nhXޅXF.Z7t`ʋ!]~#VL~ƳڳfA#2.^*J|Քu]un?]+tU#jmY26wg'$kHї52,зDv (7Sb˫>*[7c sӚҚ^攥+#i#]#i э>Gvau%ܘrG͵溣N֟N2R$X\2 qx ޜyn;y`[M:J2 @^vm9R{|<;de~~KJKVV ?㊎mΧ(E -Va*~5+=.Kt}OS.8$|Å98'szΟn/y4c]`HQCרy=N~gnqk0U>`(J\Q̥{\2]k6Ӆ;~N=kʭN5%Nt#/1zq^6*VHL)(Sk]H9BXU 5[=Ry+Kتԟg,qe.rE)^׽y5]y+qeq#=SZ=璍MQi_,G6wq57,}zTW~c`[mEXy$1KgT6MW\9ƢI=F\Oθeu"RR|4<*p}ɬT}nUOgi`,鸘d ׿Z74FQob$L7̥Xqߞq.-u 6s}]V9<{WNWԱ vNFqB4ed8FG dbycڄi&튠F1x⳩-J0Ia>ؑٿ39avr֧˕ 1B?kaWߚ{_̔Yїcn%\dfNFqU9otVO0WߒcUZF>΢zQ[Fa6m݃+II\⠴y!̓NhI=`o)BQ~*Mi,w#sǗEc?ԕK;ߥ6XA#niP9͌T(8;x2n'XG^c7Og1um$g¬_}ב_ӵrʜi.bL\|)<ۓZ*Mɧ݆p+#R)E]E|a[ϸ=Gji)Y$Z#r:!UOތ1N o)srKuc%M]~__g+=:p%[ޣk8VGXi9=U)}$v1²f@ קY.!}YJtDo`$2.ûɥe*jё9-٘ <%)TM qQQ|*}nO9Ƨ*Uf-iDtp'WWb۽I>A\*EFֿᆒ\!;f?yqsXJZXK}7]HbK8C432 y$-dUjJN}͉bP{>T+c Sy֖Ai{;&#hʤ*I{{|UzԖ<^8ig]cCe"Gj|8=,V4䥲G/ݭ7K[`R ;3q^uI~䥊Qm&i&H[^>rFQyb3aR^կwMF顭شcq]ág sۭDFM*uZiu܃Kk${pF@ГtbwM/iϪ6\$1`.>=;1Uʤ.e-FCvҰnis1K][yVv$qF+2zQֽMm+K߾_ɕyj'.h١Z)>Gdcpf5IJ8^֬# ԩ+-R:{egM3ZF\u)gi=KXp8ݻjrʴzy l7/<~eS4p鎆0b,[vߕ2eICpÍ6K1=LeK"]~X#H  ݖ8E+tfd:ڻ'*~#Q/NRrw[k6HUZ(YFf䞾NiEo%k4k466ya:V9>4&yq ]ziJOc$Q7tjIE\ǧ\zWi#7vyѵ؎7[W9+qЎ3/f7)U9}?^ǜxss|`>ŎEF=l=Y:R+3x IiUt޸Э/ef=JҎ*yheמC vۑ^RJ{S\ӷo+1·Q$ɝq{U֟cN8TJqj-Bh&I r?Ճu$Ҷ"7c:{gO$cWTe(}fӱ^K?(59)&c̹ P Ҍʎj:БFEyoqYsU-`ԧ&\Thڪ3(]N|=zܯ{yY7?3Z{?{ȮZd-'7ePq9R3'#)PS殤 |v09{G&ծ`YɺOqw<2VT}eYR=C[0s8x?`Q,$ qFVIY_qԩ${7OO{k*ZeU#PxIy#hӢjvODnFpp*oFOE{|l.hɖ8Hv%n0JzV~/Mu׵ͥN#tnVGo w X_)ui/wEn±'+P;zu'_tMf/o:1Ӟ}jeM|(\vq$Nq|?NZ˚L%Nw}w,h7 2߃놭9cK0Ѥ̖&>c,2l6ֲN޽}H{ۄM/9x Ŷ*Tcܹja)3FUuҲuCqD;M5َ&fiwsg?*)ߑji ֞TRWrGboF>-?VjF`w|뜮:)^v+^?0v}d)?+.+`g>OgSޝ}Br(el[q\t:zRTJ改#1-3cwb=y"B凖,jm Q}NfmS:kv0mI ޭckS4/z׺(3yVe68=AScqT%yI#Xbj2OvRשW#ܡE1 x*qӸʤطhF~WWc;t{Ts_ah˛bfaf ,y#?犎^ouyIci+G9b*q9wܚq/oLJyWNvour<zdz *S{Zt^}K#<쿼\n-tCtWl<ֿÿ*˞N+ǚ79*~f%dU[q!*=O'5p8Ũ%$fzc ~BӔ]'FGjZ#B204s uFg>[F^m |וG´1aHE't?Njqg*{VfiVCcCQ޷TtNm:m+J[d 2]vjm1znGs쥁?õ9+݈Ḓ $P|/W+.멶JH2%i~6YPsۧ?V:=oeq ;I_qg=9jT{Y);!~N2AU)Y-Nz6d%p`³F~gJW1y%d2/2pGˌzqQ(3yy^M΢fo38s6&؋T|O RMXNSn}?#F#3+ yZ}Z pMnj=O_Lwzư9T7ْ5Ws0NxkXxs 9js~3Xp'}Ⰺ1ZRNGO[qn]Vo E瓜ѩEgͥJW.<žt+Kx-m r@ДSı|#e3]nn%[#`lzcrFɽbN}09=}뎳)XX4qQ\]*a$|$rVS2XɬqThʜygNmgdq>"'T}dOʞ׏.j\i{t%y+`ǣ*E YN챪7w'̩ΝGεgN\Ҿ˱;XV90$q^ujZ'4yoǤ^pwpQ}y({mcK RuONaQ\珘g>C 4|؈7Iir)|+fI|YI!-A$zg0񌠜}$QNN~Ca!̐3 ֻ{|JsM;6s>"U Go9ĥZ՜+ʢ^ƾI<̒FJp:~(I{婴Ҁy/=stcFݥ-K$1-5rvJVW. ͷv5"-s*U\]2ƲsssRIQ+_2ژ.'Ѱ2?t%.~mj[#Zl9[j+m^EHTGa ye]˜cW\cy\_F_%̛biq0g;'ڽ̶HVV:rZ:-h~Y:Wi'-Iifli)~o0!*x#8`?Fzp^ڊNkևغҧM⩻ٴխۮݯV//I_En,Ms)䍀S F3a^3!+jٯdj[y~7<7|*[_ ]T_+U+ wJ΋Tcy%ףZr`aSSK_sửnRѼ*Nۺ[HF=H:ae,DRx|]{>GSMѩF^ mīiRAGBI =iGYw^ݎ|:"(r_~͟ 'U¶Y+<0kR F>};uǯie.<7-ŏXgFDcl1I 663'Z;K#Z_ZK췋3qy eAH |EOUӭR-z'QPU'xr;Zny~j n4swVG򦉁DTb}V=+]t~zw=<'ʤ0[ښ2wc]zWgIo|LC`^[up6+nkz}VS_FW=mg> P2K}s ZږERwsA02q,b]#万/k:ލt9j?Zŧ-,-̎DpVC`TbE}#{[ɥwx)>H6}ުC⧅`Ij5 >)T)_}L=G;Yx1ɶ'>ףIY&Wp@5:*v4psZ,Q-+X5;d{+'et70wsy-p|Y݅cAw5ÉOסՃ[GՎtva#ȽT&cq*(/;qTh⤥ܭ硕∮, Ѭr*qz~5V{opc_SOj)Ժ3[KGcn+2L57eԪ}iӧdt#iwqQ$5r) @ul\UzTEٗ{{;ej߶ٛnn:{e\߾bs*ݫ;ۯSKKevaXT$V# gQqqKN/g*iɽ[)"lNjNިRT+[F^d&]Bc 0<Z6֝t6Khe HUn{WZQU)ǚjh˖UWz4%IT_j $%Sپlߏ^Z5o*ʝKF--:QXfrPrx';lcg)՘+Ekv=Kk%1Br0sAs)Io#ì;ox͢$1 Sd]GeI+yM.]|ϊmtKxqtkY“GLK`+t_Imo^;jJ|NC|Tۺֳ[k}4}f<)g6=C^Ʈn#:U#!n5s=ɾw^Ԏ*TqQ+?侵3_֓1 ߼.HfrY*Fl[￿M<^skF~^i)g/jsȻ*V3r g8Fes0[|34ie|PxWǡExXiF2jĊo3AqQ/b}+{9j*]ewax3֣'mzvQB$Pw2@N:Ww.7YdgkIr(=M%M52 14X+A:\zJu4c匲@m0=s7t%}MQ);k2I;0vsצ9ڳ^Vrkڍ1Ԫɻj̭R{wyZ,RorՕ%fW-hY,c^TKXYtmܟ:t*)X(i,IدۣW4y'c^Zw]w۫EY#1yhx.k.M؜h*obsp=`J}b?RqsFOI.LVP7)Pq]V)|O3e9T~δ(9i{;tV2ƨ0EҲ9Ӌ魋*QYeU&;UX|H8pԄ{YRrzo^,0a5NnV {<, }660sq(;4Ɣz'QwE_j'+i.h-ƛVԖ-KgXZ5no̫:ֲvj[NI6Q%**vA<9E]Mt7BN^ԕׂ`2lyQQ5CZ|DzˈBLRs[Ҍyx.)6"ȡSӑ8mNdջ\lגAD,Q]XzU8LV^AF; A$GvWp˰1I\cֵF*Q%#a,`F~QcҢ:4rVQ!` m͒㷎մ}ڛ+uv2>gi%Niinc715QGנԣZGI73JӏZާ+Eh7M(k)r7}9Ot{hPO2MJxNՔTinL9$-XdX|q }85b$} y[]ظ.X(3)rsLc7B*njdFzW=ZtGg{u9S[n^Hfì]yfs\rc9b+T^]hy"c#URm˰sKWS 1)\ dn qwORsn6?j´5)1#0rʯ͸v#?F6Ƥ^Z:*RZ"-<?m hʌo1/ ;t%%2:BomHg$'{q֏Tg)OI[A3Օ[iS8.Qbiv漆e|Ѳ6ӑ\Z S%*h8F3i>sבw?!WiIBVFوFaI?LzV4eʕȆ Kڤa\Ȳ1^>?L)Z[v&~ä؎vZmlʼ۷FU} 'T;w ӍU7<]=BM1yj@ڧwQװRլȽ48YJ#Sj1rM6>gjXZCc$*Ƅ[rxj#yJG=OIE׶6/mpf ׌+jqvw6RU5ikvC+F[rOr~yu655%M5ڰI[͑v73c=Aⴔsdh,+mڧG&sKi`ķlvh(SڕSv] ay?3|U=CsJܱ$S6kXDKr7.UWh<r=rֱa*kT$\\Džgǜ̀޽jeɲ*(m߲Ot,۹:IֹO.d֕Jሥԉ&dK}޸#E8ZNRyg<"݌J sgS|ZJE(&$dGpÕ`ԟ޺Ot=$rmq#;w6ҤcJ<"M'Eܙ H z`MGݾUj]t|I+uu2GO4X[eF ?69~&P;8fs$oczDeihLi`Y˖^ČFP̀/*FRӕ=)k~Sn%j)]cnLm1nt?t7xl`R8;M{9%#C$i\4Ne̷GDj;ȣu:2Ch6qn4塌)hF[Q?g%gϡ(\>k1-Ps~6h6Z w62qڲũmrjyM<ސ9=#(ԏ7*)Gὴ(ݜd.z'VFї*b4ʯ9NU)ԩ%Bf=9ʂJwS0qjKV8}v5O}JV|rF9]t^Y-Jϔ,[ex_>MǗVejѥNشk&y<=+FӖQydY?IQ]--\eQv^+ۡSgg^hak.X%qF:` WQ]Np _خ1B˃όpI8QN_pSj~3$kɵ9۸zWu6zxZm5c60]"5# c<~M[;cN)߱ oqtV{iX[~s{s>NXݖҖ:]V2\FfՊl݁=Oh?9QU& -2[)XE[)c9/N+Jrvou"ZU X[j$i?}$y#sӠϖN׶_QS,oEdQ>{ '\ˬWoxv) }&,O8N}cgmCTeq 2G1& #?ǽg*|Եp*m5e뗻o1Ʊ 3}+}9jVMcfɡޑI>,c&B*s;8j;` y ^_Fo*F:_QnGAj̙FK,O*k`>{\ݩ$װ9;~1vTdDRڟ(yGPk[Ꙣ~VI-?oʭFR.7r$- L "\m sTb%NMw*}6t"Oc{h._bZ6+qoLr54yl9N2Zeߛ4˷r+@:e|ަV9ʟ/2W} 9!TA۸9hqjqc *;wō@zdQ]TyM./vӱ\l?-Ǯ[ykV;|Ρpݴ4ox9tQrjgEX{#¬_IV#'ּVkOShKݶI!ViPaf5,{K2_s^h/b5hθ;ϭW2I[_ʔm.y-p&\6pљ\6 n#>'4!7>$w ~QLT{Xn^w8< ZGڨ^f-©bAdfi-uSF*kXm_kfxۓJq$E8ko=ŗ${}Ɉj~q9NU#'Gsd̏B-%340܁v9'tkGT#Z/>~b]]xĒ:6 8Ҋq疩E4S+-dB> 21sUEkggNPchY]2otk36lޱfsb8{N͖k$XhvȪ{pA%hUZ:)Ƥf:t?hecssb+'Kko\D7ďQar*ϕ=zzqڱp姯M}6y-^@"̧+3SܻԎx>g{\uż3ede}*s D)b%ϸ}ge?#KmM;'){[vE) fY;9(e~;W[Qv* p 8z+wv~ܔF%e;d5;pyGN;2唓ZJ3rk}IдnRIpp߭a-u|_q=ʉ>N"w0hOSiilQF&<ɩh1{c#ȴm2UW[XK\U)ӒI{o,l,O@_åJ9ZN9sA&ȷY\\s5[U5ZRG+I4_gdo-K`Lߥa%轢{nO}ik-4b69C֪U9tf5%*קbgs$P2 ;cq\q~>=nj\FA$ H[1Pwh6҇h>9diU\+m$c= CZSo(]>m{hrmp ׯӵUtgRtԚv0,J: *c$E5ftSÔ}#\g7A)4)oZt '25ڧy=:zjJQU̗=Jkk^o%X śi6ڷ7}eqZ=כ&rW=tj)9ΚQViK&6WMtF6NU'kȯz_oiѭN= #OD[[آIjvF*T bhQTe +I)= !5ǺFu'WU:+E:c&YUT/ SӘқNJqȯE;C$^5$P瑃{goMޢk~ +nuI+]w)LbIuW̒Adr#UV=-n;Y'!bmۼϊ즹cbF7.W*p|`1_ϥMI;%Ti*vi"۶qcU:pjcRu=ҭͼV_2@هN3fwITe,2#K. +ϥugʔjxW,EZk-H⁶ 1=;tO^GF #V!KadpG8N77<۪e9 nXaV,DpA1bN[rߞzKV6Ig`pj+'D*qkU۩n5Y% bPF;Ε?=j+]nF#DC?³:sQN5nqok5ූdWwkFzINU#~N%;Z}v'kU15³@>SM7֩6ܒ+ M-MXwgo9ϠjO+_1]5y~#Vs"O2/g׽LDivVER2Pp@>_qNDeSߦ*&vncaҳ*$WHTe,2 ל~55weafZ"rk2%rqx=*jsTj:R6msu$^n~<<ҒmlwNdIG"8 9VG#% {]X#(Og7̴%F:־ٌguJ;nrJ n7Ӣ+:J[/Ċci776y {8Tr(kkn8J'v7N՛zZZaӍh/> q 񸼌 㧭O$TyE$4a&c.1'˟ߎ-+=M1161!,6X^5{<;ҺjoiiZ&^3c{Nh5%ۭѶ>eFjmjqNG;Xc-2O=8Im.Ǘ)JvtYx/.og=Z2I-?st޶q-uKa' TuذdaUSO,uԬlOswZb0}TӍK9]~fJbh򱲕_ֱ{4m:nq%BRj}M+IIWͪz"J]XE%%6*YH}CR4N6G$ed,N0{'c cJW/y-]Ϛ^ttܷ$2H6C̛nKu'`ϟ>*>֚i]u^čqUFFUp8#R1ӹf6˅,| 9{w#M(%v>l=Hc#c6*m8Vi݊P[gF&fkg#9xW9jN)UV;ShO8/{?hҾ"Q5e?1՟AU8֧MJjԺ"y+wws}bPI]Ld*ؖHmWɓ_^=9,EHҪVN䱐wLg8'Jk3SwNdc!]YsZnU:ԩ;YI,yW|#du$ڹ镉.[jVĶoW]7nU }9ۏz4s<]dI~pX*ż/x W,yzRh={pc8 "YI8eboja6c/"u]3Vb$K]m`I?tx` ,UV% 4eR_{ x Vܞ}GsӔg SRW]GZZ9.5Bi?Aҽ*R&PQjazWVRsεQ1u+XȂ7 2̿u(Ƣ3 S͙-EM"<{d_3qv8%.j޷@Q5/2{W y9Ի}G= ܫt:g⦼%*R^SPRp!225.J~y&mב2YFUriiwnɆ'|z+(/tF饖ڿ>К4wW^9[ m܂W:$qcQ^DtRYIFmPF{׭v{9T}y$p.ZQ^:;cS' ]Qe{{RYڥg}yjT*n}mIZ^-:G!Pŕ+`9=N9^67i8ޚ$$#$q{Pr ~}9N^Fa ;8t" &QjywŽױ*rۻz+Ӣ{o_t6E~Co$A_m/[:v6&2?USr:(Ə'iXMK 3êg4= -Hǚ)Ѕn7V<ܼnKۖyye59%ń!\~Bsҳr˩.TB\ ĩG `֑rסtedBXgi!t/Nr:N-̊k|zУMF1R*rNqB2vHis-VMp2l0Uk,$$ooHHqGIlTRzZ,epL,l2}}Ҵ/5yܙl壶d'!93^:k≜tn^w rGg?Zos,bJXE zWv}bQyUӚ5knM8-HY-&XlpOzq6wd`7\w9ѥ} iCAd0G6OZF1济e쐭$q;pʃ~5_g4۱HjJb' #k#Q`c}mZES'5nIխ] tmS=֛ ٯU1 ii#V^vOs5-ϛ~*ZFr͓= uStW778ƚiL+qX#Y&ؘk.mHr;-U=kK:xxKdkV7*HeNzc\<ҧQk}㈩ o4Lљɍ̑MJq;[Q}VZ&kq.I'%?j)AIb%NWI+-/㧡}VFRffҙ5 vH[9p=;VrܑLeD׳ߧBtTWo-ګ 8ƪHFlW;{[Ebu/l|[$zz=F3YFy6.jEot#ys26U)' y'g'eص:m$enx|*02IHUb9PYX2#ܳB@['$ rX9yj[]w/_lʷ8gMq1wEƵ8M՚͙F6 AW5Iri6tWX-eۼY[U Q.Ii˳O#Ȳ2̽GbE:8#:]*j0kXVF?+(eA$\2hqӍISp&510-/o_ÞxF^[ KYp`"#}<8FS `VЍM"oٜ7k(#_jқq"G{tH!V%2 A'zJ1T:Q65N eHB1/NR}|ɕ)V5|w,LXnOjJ{[|ǑXvvf_Ǯ{8y*u9TKui ]87. *cY?{{zzz4}b5.K[+p umTImcUe_աA3׮8(zεj2PoDBv6.\miןַ:7n_#gU+)Y5^E;gRVfHeThcl:NUn]C Nk=͟YXc OgLiХW[RX%yܚ;IYf!{=oy-qb+TIKZ#_Bѩe2HCQNmRw<6+'k1vе̐n,oG8'w(V˖2CدR6K#2[OqUڮhKeZn_?v<.Oחky$qƣ7lwRWbTy<Ҋ{xƤun ݶ21QY}kGKJ A4ΊG1!Ӝd׽p9םkZDfXs 22@9u\=S8J#-^J6]Gԕ7NmZ>u\A,اCM ӭ qvJ^n<œFNsTϓWrsRTt=v7:uUrdOt{Sg=Kh?S1խV^O߇Mo,rDmI$޽AȯJqR*SP{? ǧD1Iv=ds>(5=W],FS-6=+3AP,dy{m@sv2^9]uu;]pHXشCT1_̉rʛz>M;"ȿ+q󚯆;t;Ku{왗ɝG|̷_2uORK2k2[4Vk6ǾrN=*g$F>7+Y%h YY0Hw`xm#(;RYFX%wf8s=O׊{drpJ*˹~l1>Qh2c#ɛ>~O*o smm;y^>W^UE۷'qNV{H S$ 洫+}ɭoKy6_g8c=ET֍SF$vF#+#G_(ӋwpJ0zEݓdR.0,xo==rTg| B ׵h#iG;R; |坶ɻWTeˢ)ʥWAh1 yGe9kk VIݎ}qr˗bnU {O9Glg>rby]۷%[WNM{.pv%>\;G7(oU |O}SʝHr")bzq!sʛ*_ZdH¿*N2Ԛr OX۱rb no㷮}}+*S**ӹ(,BlRz[:9yB+ZV9˛byKhyHq>BR2~ƍ++FdmsȹXԖ%irI7:w9?b.\!xf` I'ױI"*8YXH9VVeTtM3C%5jAzd{W#s(c|{> c"O)ڧ<|Wl<ֱWø$OxcX7$y^EhrsߩP>V/ðϛUVIб\Czjq|]BXhH[4(Ye_i6rx,æN:))J{vw:][!lNGQPG޹*MVU91ԭs켏Kˍ1ӏד\E;Ts&EWVH8ǧ^zS}M05wnj^H),2|8'\~ޛg}N;6M<Xl0mzvRN6PVtCӣR%dk:N|[b1yA#tV';AsJ+va^M"yO-cY^xU'!FNUгw}'xm$WY+k8z2lΪ1̿-㑋^=OlVnvsZlvZ/`}aq3Orc0nufԫN7>6w*.a,$`7qdsܜtONmBu:)OM5mbFQLl'۸95aӺ՟/ƥw|a]e3G+ 9,Q H㞘>J5(}<ϙ=jI4엩0hb6h)u^ΝH;G^-we\2dDYeZV{nsЧR5N߯3K릅d4B`1?~+E8Z~ߩ6aojL>Zǵgߗy>sէ̧u4 \\\sӃۿzE t״KkWֶr,qWe$w*зgĢO{ U#*Ri@#f m-ϯ\U#$!"4M3/9nr?ϥe([Qwemo.ayg\nխOI$.]:heu #zʵKVss{:ڙBnmۙYqq~'m:Rl-ŜF\*6E'늙jeZ1g7\=qN)TV,dI!>^̟sն2OD⹣iM@)UfcNr>ѷ1%𶮰sLs?unǑmJ_F/pG#o3 rw$}+Subccjrzw?;Uiچfyq3v1CSIn!*^4^o%n ]&Kh|MFrm .qyUisM;ҧ*>/o;-'ozx;OhWȹrT)>]8\pMgj:m]uN#R5:K]ߕ-Gqz x7Ɛ{ų\66 ,k'BÐvp穙U\[kNo+NنqVeog{zRw@վU;M$$(epQ 8>z,-jZo秧΍J U~}Ru/2 n$qW-Ƿ1x~Ԗ7+I+zlG}HTyJ +iV^]o;#iz`qyXxԧo+' wrWd}৉l>(xGV4^ u&ڣ5n#(b92){9Nuoi(ʌji{ܩ8z>z>q[[{1"T9NH@X ToRb|}wzFNtc]{ꟙZījGO ZXxL̂hY2`)9l`!stڜOTZ緗I-+ZɻwnkR|)'qh~ 5M9e}>I#IFʤFA #haĕt|\_KE}u;G1*qZ-=踻__u>Zg_2XXdԝ?ymrʷ̙+;0AVnwmZ=euij)% z;jڭo|fko4r) u _7`c_ss 4ru#n{1.'{xQbOBT4m?!|qӿ1vTӐAtJ>Ο:0)ʊrVkx]IطЕV\uLgiW2J'S?ڮM~6ծX&nVG\3Z^ʚK_jw]z?6ctvn,دpC]թܒWk罏]U\Υݶoڿw:ȑמDש>o$Đꭀ8?E 4(nV}V[7TSnEvo9 Nβ i E5df;fɏ+)Lz`a啰5{;4Jik)Gd~i~x°xc7sCkV8^g3UYɽ~geRjTԠcu$dh%hPn{ȹJg}^R̪pG388gR^gU8ƜMemw8fm(_^9NXގI>4k N`Ywm=;czӄJQ֡b,۔ }ozS+mjQQ?ć[<6Fl6G@?Q=e(fV3o-چ]yß[ѡ]L_2Ug| iqo˻q@-ScAqqmd#?=NQϴȣUI٤י>;d g\ 8;vhҕg{}}QߚSV}}/M=-eWl0U Aֲ5N֧J>.PwV}t̖ȿIn=;WpzD ,kڴ E0ĜoZTݽ0H~mc228' ]- 1I4`,{n#: =?莐8:Y#[ˏ$l9=iET=ӧ8lrƗ矙*7(*Gݓ_q4VhZid92ps=j\)%{.&ͭTEczjߗ1bX2"${'㎸U9ue()OpR4+i$p;x<8#M;BNO$"\M:%;TP}rF/{kI-|P&HVfU]Te)h+݄6nKL1Aorzg{_qFOcօH{LD3.`߇Z=99&eZi+4O8a1:ZN72N;}+`Aj慯%([ܖoGs C'.Q+WNT}PlK2hj`8N:泩ue*~*J\ʒH”b&'*wQg%%oqk˜#?ֲcF4E£Ti9Vx#VVڢp~n~HMI?Ӎ}ܼf4 0<0(=:=^έK&sׄ%Ct\+ ob7+VvW3)rK]?Er]6Ka998X}IhcYޛy$6ZUˆ2syhڵis*te $DWHg S%͉^U=uסa5pKq9n/㌞O s]GBiIHn_ơ~O,7SOXTmvHfw;rB؞":+zzKn4}]9>)%G6g@ܸuq2=8?LTF-SQ9%w5ъ}۾#,3ïʜnEH  JTԑeZH#cQimvRQ#hdj`@<~9#ZwPS,P}HڳCXYC5̈ҩ*1FBhMWUqڪQ\/ĚԢ▏&DWL<(a$1z}qGSʶJ$-%$oEpHA)Qcw2״ޫȯwlk]jz~ҺaF5V5+t Vɏ0YRfޑɓ2ۦܠ`qG~3:~yB_$514+!1DVSc(QR"`\9w}y_HVuJK0M+)Fl&;4byeʹկv|hqF11.D-z\Ο-(>M,qA0szi0/_/m)AǠF4/I+jF'LJTzR#`isISz-.C/ s ?Unq?֔% XAެ1O]>H~OrngjZyx}*l8t.*QQNkNEG\/S8,W5U'O(Ij\bF.c)MtƤjAF(U1meʂ8+*iǚе-M5Y0*ܓ;WTcg='`<(M²*.wswU/{SƘ(,6~uڏ\}>IbH-ʬq:{kGM5N2u̵fH?sg6FVdu9BNßZu7/gNo"qE64Ynݏ;P(F+tUiV=#>df[uecG–瓃q?l[Uk f1Ilڰ1Y2i.ghDgrJ[<3V<7o/~U/jՔ32\˷59fQIS[-#.#ݷ;߃KjjRjGK.[\+̧eVb̧?C\H擅-%ޟ <^\#?bFq=GyZNبU~Ѩt vx4_%|l`6xnS}N_vPW,Ff"n r3aQKbcs40Ios~R*#)QdzGN~}N B~{5!Lcy\.2:{?#SWkҜ}Hx}TҮN2cOߨ XeFkv\HKaӦ *q6V4Fᤏ7.}:ǽw6}ę"ur嘟}kXMV߿bBg`~ܻ8JR*4:tZ e"Ed1o8NTT_#"/5\H$;rS#咧4ZXnVKR[2L5RG RJ] R%reQ-3N9<ҴVN#R>ϖdf[,7aKu8=iou8DrIMcFr0S}F;rrʍwF:;m$W6V6ح$H[ŔcK >b{5AJh >iUX[}ޜe Zy8wьVvW` vTԍE&Y%.SY"8ݸ9;W4Rާ G)Sw- έ-34pp'\ٿ,+o>F],0/9wYR"{+ߧ;֧d֥Ev{0l" g:jM9(3>H4ž@)(V¶<^2Z2gFEhr84LU#dn^.| 1PG^{-H;4omzh!c.|9܊ƪrʏ544Y\lE줖9zNy+8O{l!F*U=P?T՛KsJiJJrd~U·>*qqVfSlؼLм$,UfATquByF#=9ѩ TR4ew@ʱ (#隵_[Wry/jb _[*\i{VHO'X*6"Sɳ Nh[w1M&H/ dWM:niW1wRGk$ bڿx=8={⺣-WyvG=G"G1GI}{ЩѧS1HYm q&8ߦp1xҶ:ŧ<6;JhsєSo )QeV_ZmJ[Lm?2l2yǿUQOQc>̷53prKsb#V1זS^tW[Kh%Vk2ۯʸ\m9[UK 4II%BnPp@=+>Zra+]gAx Mya;Nn2iZٴ)ie9ndXŻ8܏ƮOҾ(6dK̯k+hfu^1Z%)Tr{j(SM[q-HIa 9Gjs8CIӗn*i%1AbYUv㜌wXE5̈r4ZpC8rq` +Nh{=uC:t%-o,Vp;ֹaU$_/=j(Ԍݚv"-[I-"R.p;\ϖ󂵻y|6D70'XG ۖ*](FJ컆GF,U ~u +Yu7}E?:Zwf5kQ^M_PMf+w F}Q-oTRvk]~'׷14q5:r5t1D /~ՓR]4o=c]iMR\ N`o?*\6r6t-?.xt{z-iI?v=pdiJ^vF:,E(ݱbn>Fj0sT^tL` ʤ{*ccTNmug9UYJU%$v c=wI ))pP>s-[qf>k7tKTr~e+NUc;'Oz:6q&g۴h7#o̝)GFֵIBiJ;ue(i2G#<qY^Ɯlqʪth&2*Sg,WZ֊kZHnF7z3LN7r[vNQjEUHr>VtV;Id=>Ew6e4]P 1CU!J y=@qU%&gYb6bSAkؖ]˹oQsV2o;?*t]%LJa8Aȍ3s]ѩM3XxԢ'ɠ :p=9^kJC)яI#"E$l89=(?=I֩.IEoh{gh2F)m!N9rrRm"$RM`dVaJp8=N Tc)Sh2L1kFq]V^9e[ .SZKir33ׅG)Ps_I' /}q-FAi7qS e)]:""PU0A{_CPeV<\J"·ΑF6Yr> rdҖЙ$Tfnz.Oiάik-+ceTn{sEg?gc*OFBޡKv/NO^(ƷU1VٯQ wB7 OàϷ|g)~^)N/<3!p$emOZҥHT8^˸s#76xNkr6=m#*r穻z- dXUyF8J1ΊjCyf+2qשET֩%jYƓm&v28ڽvGmHE{7jK]]pǰvRTS_wBZZCCF́ZrU|Wh9RwVz3jw/>Uݷ9aG=FtIU$#J̅;ѪdpR89"%~Š1- #mb-z.uӊGk["*2wi9ry֑O? _"F啍c*r{&] fY؏䬑wxBFKn>UN,[& t6iЙ@ 2]9;{sVvF=Zb mቌn+$ϥtGM;FV[" nq'd>R޷ TVi,vߔ$$?J$ʷ7eiyϒ,<*[өBw>[1>SG҄f'de=6zܥ4d];T42&e$IT<(ce`Yd1#6Fx>-.]_?mxN;r3E+#4)ԕhϹO@nqԕ48,FͅPZ3^H&sVbIc;n'Gi02c899ry53U9EGYgy̲y=)u{NKO3u8bXJ[\- %ds _oe*0MH>ץ|"nCNhݫ%ənfE_Sێz51\߮N87vmH+2嶶@'ݨ沩7V:,E.NUYxS~on>TVM5קe#"۶嘣-,Q˓'ӯz2rrjS;{먏o,Y[o|n<a߳3N"~-؎LpF= EZW*(^]./Q"Go | 3JͰvߨy-sP3=sUz? e'e0o6YBUINܱV5)z**.GXD۰V]b){H꺯O?H\-V8i3OROPE{Yu>HʣM74%k$M%yf RDSTc~nNsyڻ4]͢'nk7p9?vwQ˗{h^vk&UOdf43Q8??λ(i}L)ʞ4-H+XC0rTdzhDU*IE4i\7oνT%Z[D3268sϽzJ)Y"/ͪZKc;qѥxo,C$, d>v溣N\/i)Z:..&nWc~]Q˰x +t>o :qeBF:䝯ܝb$]⒧+ٓ)I"hM*wnsJD]RwwS9nM?.{D׷Fg袥-y[Em3Hbuv_޽œ~u'+{;jjZ[)G{nlW~^rS F.-ht0-FOMUE8t_,PB$>F\bT#79/)Pw+v>#tSsX>Izܫ,#n#uRqF̒ifi/UW*ikK$k.}6<[it7o*%Vemպ_9Яz ^ 0dbEW#*s_Vg*RMhs(ra`׷5%cJQ+O$89 Ź#T$7xa,͞kE(FRzɼ)vZ ޫUh-Q @K#qc>;+q+QxO*gƴ-6ro[-?8H|[0>Vb;)Ν:)]w!h۴BeԑX.{T*c1m;27V]ػVػh#yZT^iF>DE(m!"|hn^}9IWzTM^kn&FW[L4VQlꛌi_tV{]{[' n=q]ƒN8u%,!v-؛->{{oydZIY-Ƨ#2dZM+v6dso #{J˦:R[$ngqh -- mo;ʫŌ(x?rԟc:2l ff_0pqiQQO$^Wwj6Cp#&#Oہ5 9>jX# [+1X׾}/i|.*4e#[y$[sz֧.qi+TR1Cs{{WVH#ұF^cV47bǕq@ͻdS9J^F\->,2Mϊʥ؅Ok2Eo-BZƠo`>-JGVf;F, 9}u2:ܽ@#>OZR1Tf}2["IݐFx9⊕9쓲G:Ś+X&h_/g?ts _>T.o?bp%eM46B1 SV_G^k93kcFhE-Uv(9o?^}]=QNXyr<~=UI{j*ʜdMa [INzw'8+s,cjtp/&Y1`7qM\c(0i>~Z$,cdmγ82&k"wUHtE(Sl:dۛq±r #9+9]zR&W?x=\5U{G{ mnݱ{xJ鸳e(߹Xv㹼'E8OA(;Hp*%Qi2dJ[r퍿լe^I?3J*KCRIS[lHQvbY3r+{]{g=Yra`r2pyjm?rp&. Vm݅܏ƽ:j3o]X R0Fͣsd_2'#8h:loNUUDyW8*|;@Hһؘӓz1\oǝx#`̭)eNk֡MֻΊtYJ)贿skɛ'Vm:T}5LI{~k%U\+RNє^ i=ѕnỚeK?{?ΜqQ|w(a,tUҺ=LWS8XCJ-v,lcκ~gEL%:uz!oв|=x򵯩<\Eױۄȃ3 /̣;׏RJ*5]ԊL2)}ծNV݇N|i^pNļ2ڞ+2Qi7*JS:6~_Iq-/쬙~~\g]x8u/y$m tZq*J:ӖmѭH$h/2R>^R;7>nGm/R&3D AsUJPJ4ѓ߯:->9ibS|N1J>]G LUI{|]Z׶$̼67 sNh/ݶF2TFvqB0o#r@\×}՗-껝bdw &鼜(w>\җՌN9=z K;O?6ѷNq^-Uqz7+$=M2l]U~TPp?^O85E>fq0wNꎳB_[ݼlH3_Q581qg$K]ΟM%XBm\wkp+{u=6ﱳefcbO>ֹҌu93*m4aaE3|$ d#޹jTʞH*ܷkl-VLǶ9o/SW +H8D[6W$|e)]- QGk<8YJhtJ&F͟7tg*~cl?:*s$gc7͖ ˣ&/bGofsz |ZI:+Rp6ȇ< ͫLJm 4JٗJi+W4inĩckcbG\~#(=5?o+=ms'Z68_0Yyu:pdާ/! Le߂:Q*jiR# y<+( S? Z\ǠʶK[m"T%R8& 1 Gk8z"';N,UVE$>=xW樜U\,r;Oc|oZOu46l+p VOe0N_~>Xtm %G^%s3˽$Ef5FuN;)Jw]W1Ku7 WVק)rYSwmkrJUh#I}f5lhcQIl^Q\) =j<^)PI9<%(ݷIa&s5ך[yrCbF'kci>r/ a'co^9*q[˧:%(ϥr<;>*nRV"4cQ]s\jvҪstZ/FhJWӿe;!6= q^U)^#ȧib~v=Kl^UsF)Tyx+Xd8⾧4z==:n3VwZLu-v7KXm0-6n'%Z|vuF5=ZǦxk[Yyoȅݲ1}.NZvJ}NY/yB^:3S8V2XW0;\aRrlrXebFϒ'θ߸Z1qnIfb0'RAp∦'B1סZi k{"7L ܤOc5Jo[*{X62I02E%ynmLIFw{,eFnU/Ns8qXrj_eČ,c:=J8QǕ-~65TJ28U}:kW+KR]HhLsPPrh>jt2dɿtFYQmg)Ӗ"PZ|M 'nY=IHJ:"iS2Uay? 9S46d 0O\,S:#*.ޥ;efo9AʼtM>Y9&q^KuPX019| r=j$6-nTʋU9>\Ɛ+sv!*NFG^s[GmNB"䒪qԃ۟UMڗoiuf>mmibШbO wKRgR5+iRv5g|I O~JL[_Ėi&{isěLp\c^5bY+~W/[b#YP]q%"NRkM:q0'V2r l89#wqr-:EGG1C+nU FHⳝ>YY8R疗_֥I-F>c/Ņ~Ug׌B|9jQz7M3/=5VO,Is- ծa\u^zj%NRӱ5ʢS޳@8"!W$yycEʙY=wHޯtӍNk$2fb` };ֺ!('f(M'a|9.ېF7c;IGjƔIo̱m+:2D9eP29K+4Ru,l"ppc#m1Zuzi oڤWa1yҦ6q;YIC*^;wqFr|_f `E+n8%j.hju2ؼr"q9騜rطX@6 tS!Ԍ[{%(mOLhV1Nm%CTWhf'dҗ4 F'X;wq'HkЗzo*^uȌkԻl#V7]M~lVR1{*t˕j)K (KN:]3Ć䑣_-Պ`%g<2SJTXFRDϑ#:rG_pV'32IZ%x̱:Ìߠ%Fn~QԧV湫qj11s`O' 0:~~ 7'6+0jqv{VόʹDvU8R y c{dpoeO4OGd MO'WK33+3Hkc$ieMvO#Tr'kxn2,Wѹ8fQt/i[ϿOߋo6ֱ}% $j@pv Ƿ5֧Yop1)->iy4ic /GPO^慥::V改=Ot=MZ<_bwM6,p̓ʀ~e9Ϸ&8BQS5M}>9a`1*'VGrz^ԋVgiںZ%7 5rGь+EiNCHޤlti|kqXyFMJ"1}n#f6pstN:CW4Ⰺ)|{5){-Vq/}Cѕ1޿cRjET>eԹ o1^]"gEԧ [-G,pHf'63Yƴc+N2d\Fpy]5NLGKbʄvtr11ki|78Htz9oYbpT66 q銸ԋK](Odj%$VRs6U?/҄'ٝTu}ZFv7GsO;C^*KJW]]^;u7Q¤"I]ki{k_g|y[ `fQqi^ڄ+%_K,jkmZMQKTy$dBHu'Q^nmͲʑuݣkj%m?/sl4և%Wۮh֏ʟg59GXH>CNK: `U pWحVug$᣽KU}*/ 8ğD_gW7Z9{iǦm Z=Ěv*H2D`|\#r3?o$ܮۓJ^Y{w|նSD׮:~֟~=n9/ 3Ȍ:|n"%NITv>DêʔS厽SI߶߉Zn;1ȉo\Ʒ]$G ^cUªrgFB_]m/gڒOXi}-vGĎ3>7<Yƒ/08zتpmz_G;V /O. rHCׯySj_Pt#׬%bqF-[-<`t|~#, Z`kSVZ.lumt&T3) ~e{vYyrvޯCסKR>FDs$Fx]Nx9; =4\|}V5Z}Jyvn,YBL =+B鶏qJ2z7!SJ+1ڸ+;}qx8ԔyKcT8~wC5"KdUh&Fe?Ϗʾ/g>Zi>N+_y̎^cnY}jTiZ.;zҚyiq$du6fƞ$o6 4/CӜ/ֱ^QQBu̎y[Vq#RNFys՜6 7{Pxsɑ՟t 87OA}kUV9TOo Y&sMx ~XGW^zZ|k |i<^xOIguѥto7?;nmY%#(8[J5}?SzvܛŚvz$2oy3C~|.I8^Jtݿ 0q*~)m6kZ˒;FJ+0SpwJäEße0p6Zu<^>^>m"C\|y8є99wmv;08\U KY6Z?.W~|]3-4 R%_Is39 /8s9;O:ZZɵvҞ:T>ef%{zc^}g.}S> ֚` dhsF EoZA)&]'k%E[ b);qjv;i4ݛ?UeWƺuqoqkv $ p*MkO˥uJ3;=;^ӕ2gJjvwOT]/دZ. 2W厤mZƁcsgso  9Uڅ\Ek+iyYFJ9(sZ鷫Ziemv߁5OZǫ"]j͏N>a2*2է~*sS\ӯiLO=ym_ZHԿSέcwtFTwY] c]4黥N;/R`Y )O}wtr86c Q9FkCɹIy>m1+F~!\܉CqqZFVFth>h۷s|Oդjۑry'f\ҜdO:qR_Rȸ.gn1c +FQ}{ͧ+Nc岒(';1>ҹ}iZR8wxߋ^-$ *dR21 ` Xu?NJ./|P,6Ks̱W ySzⶌs8MM*B/K>ǹ;*M@MgP\wa\ZWgZlD}#x{;ekg38 {>MrJ0{<"jk|G32mʲ4tZj}uepovgnHc8؍jҶwEHI%nϩ/4K{o1c؊&XnErx#ֹ$|a|g4At |5[W|q'?)A0ѧ_vǩFt.VS0"Dva+qiu7/b צ6HU8jDJt_q\gl+(8?L֒(^mYGq<d*UHA<뜞j}Qhr[%Ǹ2nv.|5Z4.|Ϡ\.#W|MJ{9^|q$ʑ¢O8]@9ƷNUޖRO3D'ZE8'㿮8/mNtp񦔵fi Qk1Q2>`}9ssIKٺi&]clƌ,:ʌT~.,n5W!Bn4qM/hrG ]̹ ~ѵ~'py5(gXJU{wTb#bTظ,F:n;UY\n<̰u߰\G xQNgmSJKtVK=GJ6yXj?#jRZ=JH#e_ֹ-{)V#'ؑ|L`# zJbU(Tݽv)E4 j՛=:SZ7$uR||!?3"n9'ֲRoh*q-.o)ߙ}3Ϡ.YG܊ sN6}J7rB+'}qrI#TW36bDd9b}uQZ2洺4#v&l*J8\_ _9Z4c>W+ (na!N u3je5+Yʵ#_, Fq㌞h8sZ7:wieGL\~sFu*2H~eԱwu44w#{) 7ocֹhFMil[U1R?j|$S6V5_<}9ve uXPV$*ҩOTgʌjԆ[ɿfkBʀ^23ִJ{J*R?. E"hʘ(r==1\IiR$X]f"T_FoQF1SYIkyxu}w=9e0huR4Ӛ]UU)'Js8bȍJMF:>+A_+'ɏxq}t+\]:v-RV'>Q]Q.dUE$܎{+'>v<(V=7CNOSKu"خ~\uޔ.k̊={5b,7Nj.Zq\=oWQJ"4{+F2ϯjyIhy#$mu5$U%p0d攣+b)ѩY=?2캃0̒džb=NO\c=3qpT%GGXW V׭gN4᤿7NFIZKGo;<ܤmM܏zv:Z+8KmZ)J-i7\vr23=*i'o aیDJJbXo޶~j&m `UmIn9ʼ9<ԩJiq*_h[G[Fv4{擺ЙV|OktVFY0U*}x=h捻ὣ-Kr.2M7!Gz랤b.US]?a6U0Dz׎޽kSkmYrnb1J0r 鷷52Mre(<"Gq;XnHXI\S)QmjVtq{ʤVt(^$*VJH?}z8Ls{jS.bv 庣mg HQSϚo sPI+w]H$Xf'V9L)=ïXȉ_,d±W=:=7-M &ţ~@"ȥ}Lisa %HV!yo_aڹ䢢mQ}{Ir{N/#ssFzVbQ .IzM+ʫ)nsRJЌ67- 2!Tt91N6vFݱK^u|0wapAoqXҔeRAYڦկմ(&a7 JRؕ(S%7b1 V}=*rRTnё |v2tgb #8\%#U)^)R065vdv,rI{t.WQUqmspt ssgoAUN2 *4}ʶw mGXclU\$*9J/t˛IvDRWF{Q\R(WRDS̓v #ea"98OԚ+F\gi=%ooləiQo5s|&A ˖ImUwv]e I'($nmEBR`'8G\Ԥ#Vm]{n,2]BbYg`$wR1ji {'՗ (MGvEJqWOBVh1TyR9t]BH5=m,d`^ITj>V[+(%ɎE[9oTg$gTN[~#nlLW#uSIIOK5$Ay-6fcF?tS,qG&Yuܝ!VoMq[b=yZ?ĕ51K8|-٢I'3+Ǿ+Go.hVB܌:dkeirNRi /cmn|lER`,d85FSrk [Dmdu̠\!6cf#8qG};)Eʿ7FryϥD}r卥~ne|+ T%<C\Ӌ[+2/ga,'>bSBkcj$5EˣIJlz#C4rUz^+&Z:ҌTU55۫6]g$SXTMiJOw @d :35̤sQvFKмJalpsܪXjF*:smKE#lqMB0vH|ѴC! m;qSUN[ ڲc_#*1XPFEcSQQt$y]mU¢9? 4hx Im$U3?,ISUcR1zkm`Ћ{t#c8jc8+CVod"}B;*UF#>G,\Ѵi(Z) acnPw^N]=,$A]1=왦Ryd? dGw<\ڥ.[Ilh#D1pn?s\ܒþ&5Aܟ}'PZeX8U~l1'>][54ZO-w6'f)E*؝٣\0(G~t~el &1;ٮn]]94OJgivxF^'IJu:[$Vj߽+ɩ(MRu*H`a3tgj8#I(Yi^['"6mn9Dj'.VyZ*]lnvy;UKhe=߉g(/{75iN-EE+ck_(hqR1V2gys+TyK& 6:~4aԧ)]5xʻU2 v4.oL'bˏnBw/wz[ʥni*˿,v1뚙/s`|׆fC#x^zF}Y4Wf1pfn5o)sס,̪FNnZteF@12'5܏i˖ZDF]y2WE:ΈaF5<`W\%sM|ܶ9}LI0e q V u}kէemuwGcfo rw#' bJgNTY˺X[mmKsq~SF3]T5;.s0X%T{6udXdһ?y+RR+[IYG5R>(tZʥ`v*F{y)Be~Y##5RJj4 U\_p.H+mFO8FpuƢyd&HJi#W_^V\yfk5P̨ЩtyJU*(|8*R廷n$hrͻy?>pk:;{sS$7tFN>`zGOc\ӭe%N6mi1cV7<(OK\_BYgX4͓:}jeZ%V3phf''{{~5ٻl^/,s2a.72'rدf۶^١wFUa'Н_ ~Iߙf)h xh԰m)sۊJ2JlN_ΟOL~.jΝ馒;&c,щnOSg ̟M-2vK.sr:9VЩZzC $jxV2ܒ1{Uqnw+Al\έ"+)>])8h")/%NeI})\g)QtiͪeDe,{ C5tmJN *I幻EH$N?q⯞yTaR]Gr4>@?\*Sq.oʷwQ&k|A<UEIJIS܊/ʸii7*`<=4s1N\H>ՙMn]ۺ8{ZǚQkW}b&%.FF39ZTr\c%A"Z2u㒁 8reR5ٕd# {gXFuLN%+,PZs HT:VQTJ0>WHw)R3uRӾ4sIU!NoB]O%";PrF-(Fю#ZRGqE\yB&X4ď=IqRJڤ'oߜ`=x+jfqVr[}9nbUYWRK'.uye;20 \?E*R9bMJX|ՒD&M#I/ sQ5'gy-O2"/%3.M;IKmf3f_01k-**.e);nOe0h8;YsێMcZK*OkxKG؞ʎm+#\=V5Tytdʒr;ɧ6$,I s;Dc[<>ڸc)JN;|I{!VLm;uퟧj啺qqb]6 -˸f< x?J´c'd2}4-Xٿ{m!}q^'8g6+Uu,3^F#1޼\XKIZ>FDG'ڿ.nvH;31Y }VI;z6r6'}tyr'O0\.፸'j\ޢB='6b. )򧷿>(8}uuq#ͻ3hʯ?(猐2zXՔ*eU^sfnٱJG?ĠXqM-𲩫ap=7.HH(Ea8iXkTM B\Uf-"m}1֮yKv]ZQ;ZQ9zsosiSyH𣬰4{dܻF0SN݈4lڿۜ0;x')Ymi]( Ano3n6ɼ{954\W.uiF~G<+{}twEiiny#b8[A#g#77cЕ^H+~[C$)Q/r.q8$JwxtSK]0ܝG+~V& }^Z[X@"_2=ͻ54%+F~O֥+Xftvw0?:\d⾹(72 q;1i$f> SS.^[GeW(X h0 3ֿN?Gr:q}zҚׇlwH߾T'SP:ƹkE}N\Mju%/umJ=r#Iq׷zbxEq4gxd!Y2i>o&Ls#QVNOʫY=o(Bݯ~Ywyc!r19)ʦZ*d[%\)I5u$סգ^Ou%*ISyA0 cƲb*r7[J˫"q>8z7̭LTai+_tfFT2zMF޼zq!F*Z$:2q)N3MKӍ*Vi-mOZʜirmꎼ (փV 4U>je+7z+'fЖK "hU<{OGl֝IGӦc-}R5#%;^TIKnGLM*$w\h}I|\kAj1ҲJM|_4%%y?1Yli2]U8ƔqԩVB|cwF\. 0zק֝JrS*{ JEuȴ&U{Z֝YVffKb^;Y'F*(4}Ko"G<9wmlsx?c:W^zҌ{mmY6MF@ʹ0kKx}V Gzk{Kw:jc#G?Odźr2 pݷzr?Zk[GRN:c?fm99QR[Iwo%?.;5Lk.ЮUϸzw)I??T>nY}wd 63G'ץ\sxv?CRB) 'lvzc=MBjXFeVQ  9סZJ*<_SWI3^2P7?<קNM]{XX`yy?Һi7Ilvrާ1hu #/<'r%Fz\vRwWo4< v pStEFnDvRظv2m*/\muGܶ;\YEeVBY@9?08󼋔=̚rϵUS7qR}q]PJW'n޿?_a*ӔuІKghi$rxO,zSĪqfn=#VZSqhY}cz,_wѧ.{)Flݎ5M{e!rW cx9vS/{Dt9C.2tT.e1N\ܥc m3ᶮO &jm78GKMr)MrŶ y)(٣?Ikm yJjJtl0G\rn9B*ʆ94;p;OnM9^_Viiys낵78T}w~ O$wO'xNIsVIS.ޞڼz7^*_"U{iSՊ۫\/;ql5ΣZsN`6^}-Z\naێs_=h;}m44B̫+D]ۖ t~$N܊m}eL d{K2'p!pAnB>ym}5aSU[~pu!n9ظ 8ON(8=6W]~3[ UO*%;V4RyS?=?N1V7FeGM:E ^]nU,#9A뎵J^:͜gR-={RR\I&ȲUbz氕~Wse͉ ɴKpWcdg#۱5}'}},l*~ϙE6:(&gʰf :~E.i+bJ:nr񋏲ȸ_.~]匔aRj-Eܾfmb| 1~lFsWq~>G|!zvfk\C^C _M:Nq54#̹qWF*ZV=͋yyMo0XTzB˖P/0g v=:qѬŠ-b;$Ͽ]PN=>}9 3I"67玞tTױwn.6jV ;UGSwwgE){h7Vy}Ҫ)h:rFX.*en{g?9]3ٹG`ge![lTN9>e{*2GI\]>' x=OQ+nP6AhթbXsӓSF7̻ l|z]NDa_98#zW6IET^M5ix,AvQM#)OjmL0-ϩ滩SzKzGȬX W\hIJq]Hҗe}oCW]8d)TZ+FC9O_13{̍+G]рo$uJT{ۤr-̲^sҴ*5 9v ?'9F <ֱi\J@vnq:ycfeNCYRBVr<6,e \<[ k>GtdkLR۶󎟝e24%W啁TTy˵R3v'&4e+6,ED=k5 9toWW˪LtU|)\۷^HRy3T1#7goaT]MHWڔ-& >mbUc3>=И%C2dsYTȤ2^BeC:Wʝc'QF&?)~V=q~XiSI.NeK3F"2Hw#QpZ7R7:mYh|Z{g5L:+$ݑ4蹓1#^>#g{U=Eĺ<:ٿv݀sߜƸ]8Y5|viCjyXczӽuӏ֞MJt#w6IdNwSDF\IZ ?>bp8XW}';R6""ҲnҺ)J\_-/Zyj0 s9һ» K/bߡv8mpa]n鴽.Hꪑ{Q]j;QRCOcx$4tѝ*Omԉ .R<݌V5j.ї̌(3̋ױJQIJܭzI7mmsۻqSUy-zM3ПkiKK4餵멍6]Q8ϰ<йySͯx?3E5 ' )Vt朥R2Arcռϴ&O#s}2Vxdc؂+jskrV{Ǜ~d /nx#Fg4ܬ=L,d~[/.2ّ3GʧFRmjsӜe9F3x\̫jRIF݉KiliZ9~ VWkJF1$Vzk SJܺ4SeP5(5`ݿ]k?v*T"pҊm1aUX\ ҹ%(>̂챌|~J;p@Ou0{褍}dz-ݺޔsZBN[{Ya-8f7*o NkϧYBȫNQ Ԙ 94F?xpeTqӧ8OFi2ɴmn<[ʽiRR*nXqԨGHZлe[GQS&f{+hXH'vSF [B<ͱ|~n08U5Z̧INbn܌}~Edi%- ijQ{Q%$h[r0lؑZJ嶪~1Q'}>[(Ղ(baxBӜTMoȨJU%}z\gQ-A8s=k u#Ѝ]rTEDl*ƒ+EjwOV"9S^}Z:A#vR?aIToCaJv96W5\| {xR2*حJݎA.0F |䌞cϧUWV"{II䶔 ޿F;w=+Qi7Tê5 +!xM4. XVg犗Er4z1"NZd7OՕ?r',s(5d~hdF9Hf2Q-"}lF>]ˀx9畺m쇋YXR:G(t6w|1eraOF~ZJ|F;WӛFZnI sy2W4RV$֧I8+KuϦ=+ɩ%5- z}*N~ vKǒ<#p=OSd2Z3"g6.AwzΤyj]+V^YՕ-U[,yRjށSrZ ̲UQJ7ZkǞkߊX=ǒ;Oֻe^Te${63ܹhд2m;r0=J\ڻSB7 nhڴu(eR7^=kiaMGGyߣqQ{u=j`in#s͖e ^\Qkeyg.^G_LéR0O5W3΍9E*VD;@![rr8=pkŜaEcRn[OxnmG8 s9ֹ^rpTyIk#@:xی<%%|)FVZ3WL<"۷q~dZ|{ڂ1"N%pzkN*txZV,+xE*t?z+V&XXeo?/^Oy]u$U*7nh_m)ӪӡRue6ެŁ }٤IDy#iW;9ϭg rji[O̡|GV]b`ÂGNIEjmRc yV>l#*~bjV$I}~U }Zkmmby]vs<KkW&,Gk#, "0$qۦXWdj(^HڝIF:i CT߅;W'Ӕyo#*QlŰco$H܏9N s;9][$"Is֨i1];E=2m!9ޣ!x<׭NOzRGC|MmUel;cҽ:uӴtTcɤ5vuOXl%/]'9㞕`j8e`{DTuk{6M#~3ӎۈ~GoCocZҚomI.,V0#YUSí31^+4Fgaw~J\м^,Tt\T%&lSXaiG|;w jII-R~ruc/T9I,Q!o/h[ *tҗ2Z܈ԥU.[ٚ1ڪyjs-klZY >dQ}2RT޽4VpRUѤzWns/}8F#j09ˀxp{T59*^>^},zֈWEX[o߁#=9[sj:N+v_oiqɦH(HU\WDe(zLӇWz͛mZп^DX}psK2KNy9vF3|䔵k+7@͵s}\rN֖7e}MXeXnsLpKw$J.-/iEt:3"{!j' ,KOSD F+4!Vq?^_4aF_ZݭJJc{8R\ɯUo{^4*[miƝm9c}ƈ6v600KRb٭9{]ۧ*NqG7,iRw(A6  nRqr{jFr꼥(\En!W0 6%}w.u9voE$[mdxdwP{75Z**2Ml:8٣G6 HjޒL4忑~1f*[Wy9遞+9^[2\)go["(I cwIxS~`s JHr>U{bNsY9$㷹Ұr9K$Hfi7|Fqsߨ& hSEE]'ҰmT uveh̪+p_DWֆKѿ-^i܏=kyQ~a*vk^B6ñyj-eIkO8EU|IpB3Ң)_4UI^+܊y%i0sӟkojg*sMAhmg0 ezӷ}ьeҍck+on럼ˡNRćt*Fg8 uҚڷOױQe[N0f8>_e5Ђ9d,HٽHRmfGeeI/V_by4b략*=&q]*L!t!tUTRt!Efo/!?? ҝӇ;oFL9Veێk?{Y{ 1ž[oV v|D- e$pd|6#g*|=L-[5ml7=G/tvQ~%d§LZ-9XkV;" aׂ3gic=ȑHRw}y5N:gSNviwks==')F2:f(b_Ew/ St)a\)S-w9;σ~ CHh9q%fP4N_Wc6*wu,}+ϖ&ס㪵+?$̌ ΧϦHl*H8V'k:އ~,,- M{d÷eJ+GѩzGIv2q(I}FSh/oj7a2#]Qp9~W`p5=lR8{v$Yy7vCIǒyy=k_ZD}挴okN[×љvgYY|$zbV~՟kG^Z~4:V:~a;cy+N2I ^%7CT,|$hYT[ HϯҼƚro`sJJW>M ,aU/R:JЧ%)+s'\ﷅ+\ǸuGzp;v쥄ʛsz&Y>uйW\f6=d޽=:v[#apx)+=_p7?mt]H4syN GFo}:rb%:k+]Ii,F4Gc^n*H]KKөJxwyMIߘK6m08ݸ[T՛J{(A+J (w֯abMN~W{m;wFxJwQ}]ӵ~jfėZtj+T.@#99pZ׻~>Z3 y4׮otxMN&X`3Ǖ!<z|q MwӮٸ\e9aݞzu^s?~ԉ3M${4 kbDRʌV@x^4uýi]O>BY=:3 E7tɫtצE |on|;'ZhŤkk}9`3 U2KҺig>3!ΥECxIyoO=U~%xm4[o^Co8wZ ;+$ch>"/??4'~+M4Dr[!prX OseNhr{]w}?˳nY:[_}F*?h/kqkfhP@v*|͚pVjV['T[t&0 oiO컾WW]:&~~C𯍿%E#еK&ӜA@݇1u!- Qʡ̞6{饤xStHf{+f!=,e9Koԯg+8ɤAYil&,fHZ5 ?_rb2x8[O7e[#!9R{=_?_tw.!0F1zs ֍;w,MŪ!N:wc<YN>.f#O4>tka'bqx3ۮkQ"'c$ۧ{.g+;9"Xv:^[OK_iF 6>?=x֏Qq8YFMk}53.A$攕Vx8qT(ŧCUj0XՎܜ x9kReLh2LˋfEX]\sA}iMk(ѩ̢l^;nV?. Jө+tyFklT֤KyrIe#b{jJ.-:1Q&~VvV55 aGzi$]8YSVZFu)t. 'W@m[it}?Gm&MNiM٦̷xn]Tg;/w89Fekn~cX7[M/߮sώ|^(R4}gFK%-ě3N|<>*N=U$[Xxf*ͫ/&4mC㏉}V8;d6i'oC ʕBH:g GEtYYhn[O ֻJnq> BԾI]??n0 úM| <)Sn|O+ªuxW]W_DxKN5嬑Z2\s&6$&5u]V;K\^Fۗdwo\eHw}+ җY]S*t"o5Vq?w1 ʧG5E&$2O~\'^J4),-T*WaH 3]NVHi5rƹoXsrq:s};5%%&ߛs矏4;6.ᓓ^YszX:.Uc]|uAFQ+3bn{T_>՝=:kXm.mk{KtxY%˞'Ϧ Tz|=pt쮓[=ErTUOD B'IMO$7m*pTkeGܽۻ]W[CIFBǕʑqV2=-3zrzݟ[2[˰u'OOJ/5~gJ81q=_g?>,]F\NWzw'{vzR)~gI+h_ݴ̅NpJڧ4iӎ"x[χ{gec^bV,7~ yKV1MssEy|&u`[pW pӧ*摭 &֝G Gvjt2Gc#3{Tz3Чby)mjv"ՙvGRqO4Yj+M"i.li>npT:x${渪IUN;[;[c~?0Tz~3Hl^eF"͟#9JwƍoEԉ%X̩`_7Q}zQe焤,D>SBq\Hi=Nj/}Hx:} {G/cD{6>\d^'{JItNC |6US`+/Ö>J/$i(V peϧ`yQIIGýI1ϭ\(ڳZt!6l[x1I^hѧgϹFfV '}8RWMSn}LMm2o, e}F9J\Nxz߉\K Yl64|;' =\!:r*Yg{jL1S;Tzu\(Bi_ [m5b'קCj^nćV ڬ?xr&U:vM$?6N1sXʏ/gO'=G$M3O6,8 =} Tw.f 8;M2N,Y1n$GE=sr;S*JVosЩC٫iZq$>|Y㑿^sZbiǙmt1txeԭ=! Ny9;~}Sr]HVWpRHrH3׹0ף3>hDP^$6| 39ډSTiR}Jkei$&VV.awd0s>NUI eYԕVq̃]bs 2i^i[<4}wɖY-ww#ӊ]9cF*Ww&煣0ޭoQⴕ:rOJiкvCl4u{,jIqנ5⢎yTu(7UuKY13,eA+4jsrtZh. U$(kf-}N5*{Ѱ;@#+=#[GoDFI^0E%ԑy@TzsN4hySqӗMu3Mhfd.[T:nta4L}t-YH߷Y>JEucr$O,^dj)El?3[ir)2jJ)I7nʜ{iNz]X[]Jݏ^tڴtk֖CȻ2I6']w*͂Fq\cxycS},F)cLlN$zW?s:U)n]̓H-m r>m-UՒ-[D"}d6pV9'ץLrŷ'x~]qR ӠB^JkV r$T_, W97n2C7a;ScZ+ߔoғE y `*:!uJպJʒ}tK3)`9}(Qq_2&f8|R;gf4*nMiF:BD>U##tԧN= v:Phڧ2*랽?KSr.in%`s88Suʤ[[{vk"xbI?8W4TJ}aA+2)I dsZFUgjrvkBy"7G]zwMe*2. 2MY\g O2Oм>*H8[;ydKfQ(&ͻǾjMҫPo-,NNr~?*T˕y;BFȁ\,hmapGZb7oS*Ӵb$XYi6Q~Tm+juS[U$UcmxϨuJZ4ȭZQPf:8̑" d.Fc9S[tWRXo-b6%Sm=HIst lalG?̼g$x#a[SsLjԧmYXa EA!}LT9٫լ:HdrF{sZOB4\qyn.3Lm2H]Q^?Й-pOInCGU.[$tӄaS2%{2'ۃǡ泦;-0..BtMI=A5F:ݒIz`I0}֝8I=ERJ*$M~UVI_2=4ߠ__u}Es?$|^iFi]jCaXz4ymdH|xBc %✣rQR1#YxF_v!0{)J+ԗɨ6f$[\F9?6J:ɩ{ lp%rp[+7$fQI.mϗqʜ=NYg.FC;Gm0o c$c=ks|q45uTJvBpsjt3HOYШa ALid^Ӛ穷4lM:1IR1su#2L<{ErUP3A?a*p摕:rɔ3}!vn{|>1rWƙ$UFSc8ʬ5M1q)|eګ G~kIDjJӖϞKY$]Ѱ.?Zϖ+nMI|^z0ɶUS zßlc%?RQZy}ƤD;r6ߘr,+Tn]mǮ7v\SW\ƗJѶ(Xcʙdr:灏x.m c/vEcrO$yYNyPqb38A9Uouizzr{|و]3=k Zd: v2xٻ3T5#Nq1އ8y)r2m-t/ftǹ*yycy/%zYՄa0;t+ڥLrBgi3'953ʚ$Lv%\UG=JJuiNSjKB,v/LON_Υ8)f,!2ܰ񞠏^U8i澶)mH3ʶyNϞKVltbIiϜM>'mdc;|U:uf^Yc wvcQsbZnf^dwmdu\^jTvEӧ>i5$#/m" g9=z~H_A{JG] ֗3MHJoSNk>NkᕚrV?99e9krʜQ+Q^03rOwRj%rк2>(ۓ=Oc;K3[9`Iԧ"TeZ\F976߲@e+Џ{:qb<-2dܑ[8#gw{%S{uYyl#+XW[Ӕ>WحI Һ޺F+Ǽ~o0cN3޽:~KGvr0meݺ3Gn[u&1u?^5lͻb[IPzuoQho{%k5{E2J>i<ԞWF'aQZ2r{]z7ZAm̌6Ь]P{=b{_ZWl-Z,~bVmd]7uD%hyJ7>ʑqt]_A8Rz~S)snR5*S}< [Op<3|Xڴ(m N4_qc#*=cb՛%.cp\O)JoU7-f;NT1aWydZz ycRWZ"$*X_sH~Tr1yڜi X6-ޯdLrM9I率)J>N2oi Q-6*Xh$YFgU#VI`88}k7'k>;eʚR ;[ʬT_r]6'26zzV5:u.$m#h!ݸ75d3\ *^ƼW}uL[N2J,4G3,GHۮ,s'4trƤIBʵ_ݩ$!ozngT[ߡf 6Ȍ%LmX982?JIIߡ)Ruh-[Ics+UBv뎤Nx= #zVU!|<'Ot_%e;NG~sXz9`m46wK9ߞI׶zs[ ];3 F[wW[i)!Hl䞌7gp:hҭU]jfefcqs0O=#̵GEK!fKݾW#⫛Xѩ᣾ǖ S2裏ZƬ.ҹJUZ3,qucdu:."HDQmDܸ]WMJ+g *j,t,"-JӖNݺᢣMR1?7Sz9"èNTտN1[E7/P%O,7߭ZJEpq{NXԏ4~ 7N-fG`Uv5kǦx7P+$ׂoN+jS9R[gIzO͝fcO$z[1)bsѕAI=?]t8M?RSoܽvl[>a8ZS*4g9EZ.oU%UfC+؃Ԏw rD}u"Ԗli,ۖqR7gTo̦Qm U9SnVΎj~:[AfgHlYmn'NA6W6u' MXo Ճ q;L,sj۴2nګ&g[t{]."oV1fZ<ȗqQYԥt{[7mԻ}L~ph. <-׌cһ$\r(ӓh29 yULlr ;F1dE9FߝY< x>Z 8隈ԍ9>mn(sNI| m$L32\*V|ͦZe+i6qE^C1[I:Zw.pd"*ь~F]lQX® 8qU:q.MJ|Ѝ~ F,cq83\rcFN 7)?jbb3SV2ra>-CM~F)#n|sVR|QϚm7"[4C;\)KHҤhԋ5ij4I19&Z]X2o|s'=4iQ{?ס!KqVQ1ҹ&0$r7؍fSosӗuYۙj;D-=2,WmVIf!+#c+!޹ƼeggLU_J퍹=9RՎ-ۻ_J"zƤƼe;-_i]%pI~MUُ~jj6*#g<?Zu煜MGddR0*JqzrWr{(y1!#I8i$`Bq8.~,R2j隶KV񕓕 AA^ۚ+zɇpk͐̐#?_uT*rwvשj;,ô28ƱJ*Xm9sNҿDE'B˹ 㞘U:{~!z4'R?G[*=s*{Jpu-&@"cvP$pwN1ruI f"!b[8xƩFJPi֏>"y:_Sҹwr=3s{cV|[ȵỏe'q`r9:rdk4PhB1#tmq?J1_R--82yv#g?|_÷ZZ_}5O^^}K61>B]_֯V]pԍjwe\n0:qd'q-nK`yK2r0;W/eb4I7w,*d' #מYJP\SԘNI{&ZI$ޕJߦr֔\yiʶ z=rtJ:B8aZ|2FZ|ы 1bwg#鞕9_WRW%?ӱ5Qr2랤c)C9UN*fLa `u?Zᄷ*1S݊c,-UZOQQQBQ[d)JYh-[)y d#܁^-eaRIͷCgIDFŃ|ѾñZF*&-: F\l1ޏ9Z1MJyJHJ|kOg$֖N2mR"ipL]qbzYԆ-(MKtYZ9&VcytOB*7i*+o*a Һc F'dw/[߹VG+>-Vڜ\tVLta~]ь}wVtӌOefXsu_iUN>Ha?1ܕ|_ZI9+!J3-Ү\*;WG!J+NS-9ڤ=Ϸ2)6Uk0;G V8SqV J0\or74!Vsߏʔ-ƞΝQZf]. S@h$GNRqN]e{v+wgo%U*7%n (u2ʭgk9+Q՗֥3.=y1YKԦ޻v+<|wU>}Gu.YJ핧iAYI۸ }jrOC ؀F.̋ݞs}kWcR~ʬ;rW*s͟/ȧt-ownE n~$=;Ԧyҕ>eƳ4+o_2c|f>73sSgaΆf3s1l$׍<2RmXcGf9O'$=YRҍIF2ūX\Y#TXjKz{yh6idY$+0:VeՌ[(k}|"$ G~>1愣;qUV&Evo.k۴v9=py9V']-dWrK oyQ2+8=]N*}+7ݭo2C$Hq=Oz1lwajҗ5dE[' (a{p=a:($e8bJ֦egk2|7 Nw 9^pFMIT:W_wr͵kP\n,1,}@YsJƍ5f~P l1喨֟+ZVɘ,'oݷCc$v=EvS4Z yj#X_0\D~%ѕUu-+Hfɴcֺ#}M%{ "X+x(+®e*0W99islS-/7̭0|a}*ҥG#P(HOhbw "v͐:6hV~=Ωpn:slcVcO-fHղ6_^׽\hUF\c΂4C ep7qɧ.x-u)9/:uZy̫m=}jc9BJ)Kc6yTyo>/ͷ4sJW̞yFI't(xw[+~NH?W7+:[vTQw&? {`#.k҇4^PV4Y$*^diGk 3#0Uw Yn#Ir%v4 ݸ1}}+Q7O_Ҫ<׉7tOGө3E Y~oUu֢lvDi6I,X)ZXr.thcR^NJ˟548?#RJd3[ns.P M6**γt8gF{q30^1 wyMvB\ViMɥkzG< $w AmH]$I'+jQ5Х^-Q˹^%`"(YFaU3׭GI:aSTIY|'хt:{Frm*1WFXQNm]j;I֍y$1"mك˞ knmW_^fF)*_ۯ'?kiI&9NA= J!MJ=Sic>G9-Sú;xyWU:yQ譡Sjn*EOǘ$?B.bVöt!qޕʞy)ֶU[leX[+N8\qͣ/1յ5ˣe_|djO~gߩmim{/+JJӧfMg*_l5U')۱F4K^Aի@mj<ШsJr۱Q4tG"$nx[JJ+K[pi#[Uy95RҜVdMnz5e3p6jg.U*IW}v~4%2L3 ޹Ujߵb#^kMun.LKN'EO7}6U*F.'~͵~w=KpѢg ʷ#׎@kTo5Ӕ}{5=ECJO)Iܿ/9=דR5_:qh4Al`^=ϩ(./K%ӕL?4HgDmaoq۵qƤ6W{t<# h$~IU^QOc6Ie^@qpV ԱG~d,gr{Jm={Szǯ~iud$"Dbw|8+cER;șT</Y]E*Qc?0[j!Jۼ=ͺ#'seT[<hۄ|7v 2|31zSP)^ƓZ8y2*f=Ű'WvКxyF:zM _1Xmqu;8ɻ OF,^ 3mQ8aOl~Զ]:z4kI)P6H] 6f;mđ2_b$c9[ӌ̺s334m&8Ƿ˯R{~iq4^3zuJ.QMo)jɜ?Tkh5nTsWTj:lW,_/&y4%-fY[{bhNrO#BIV jbչv_#|SfEsӾ8,~)^(+ͽ" A;y$hy%J3'\;N~|;V0sdrOb_sl>!wH`-mpÌjR6r=Hb)5'hMƢrJ5xw.tѼ5:Zhrѫ.UfUgА?!\JUyZI^; X[,ZfJcNF69+io^d1S.=+\!efVeW,s:猞G=+0=VLvt>Q\ݺ_ܢ+;;?vVTn#w#qPz^G4c^KKo߰H]`\v8iRmKgYfv4szg=~ov;/V8eEt'v dW9V=W$Olvޟj:[xM,dS|㎕>>hP*2^jb6#nb1f9{s\oRW6˄!MѪ26jooNXˡHƴT6#ZЃ;,>d%s9)\i֔46b|?XO\lXf6੍ve((EuGewd緽6|ݒ%& dGKc2.3 d+Ʈw"n-g.mdP.~dAm'&3= oNongKR2aUWˡe-Y"Io`vn,}º)wI3hԛ~e;b=9oF N }O#-q^ui=Ϳvݖfz`R8G)ri[ȧ#ϵ$a׮2p?\WDek)~r5mMq0=pl㎜g;֜^{Td\ErYێk9G&>M&^8z۴r8{ҳ&ԹS啖VtѢF\6qn}3ӥkbB*JIhBf9=pq?՜ƥ֭ I/,jͷc.NJ^햟R'N/IwI$SD{qQJz.Q,\ XUی;`UiJ7_q)٫mlXB\~UpO2_e^f?.,Ƨw\IܼD-Pືލs`{JeTw09N;tm6'PُV #lcNOJr[\ȪF_jRzL)a1vF^ ϯ?Φ1(ZD+,ʮFUʎIFT^Eā#9 }tϸ.W MUtU,?FY~+?aXѼK|79ǜ<ھtwzGld ϛt9s-D,:zoTG/3|{ Ut9JOb/'|l@c1法>ü7vbBH(fwy];z]OHIj2 1Z^Ο/ckIx̑?u6FzcTkʔoo롃huܬlXqv#׿kYl+0xs&}7@6Գ BRYNNCq҄eN~J}5оQ!Q **ZsOVX|qUNԋlj]̻c% *$~jm6rԕJQ2ldiWnKm_ʹㅗ3Q׵ʔja&fj~ մ[Tc!+w֔q;p*5=9-gIf`+= 4>?^Nq wyӨ.玙ZU2Þn:Zi[D"M&+3(f'8'';H2>#SrJy#- ڛm'\JkoX r%{hqZWMkf x*8JDG ՒkD xmeF8'GB}ʊp1ai:45Y ~2]#KGqpd=0 GǹS%NYD8\,c54&|CO剴{PR;gy8 hŹf2<҂ߞ_[hQf[<WTF^ Ju0j;33r@Hq޾/Iߪ=1 zn[Ŕ~C7a9F4vi9^Q5B%`d攥cϝ]YyWR8,v;ӌuԆ;dS.oz(N|]VtdO53>y=u]\f^9}{&0]n 09}aNЏDgtݙf\78W\aRU̞TtnoS -RQ^-$!-'#V`̪*1:wױc~ǟkSxIǦ6g6-dqvpxYQ^?UXڷ!Ѯ-{H|wXsn/GpX6x9GFRj-SQ]חϧj /Tt4;>kJJ`zBNG:֒y^Mo&:x..?֛|5߅nwX o9QFI>鏡a1sw5zKqHa~IwKf&@,~eO OissS.+I#ܞ<MdեgSVHڵ[oOY/b6Mjy~]yrx`כ{Kw}]8WW ܓv~&Ծ:1+o/wYd*[ AݑYUtw>GE$uGo/SҾ'P1&yuṄw#|8߆~4ZΠvuڲ]gq6.OqPTSGmݯeXe.}ӿK^0_ㅄn8I=7{5ӾD*evZ˫ɥRgF5xKxK>y^>m0~㟽xNaj2_I=5I+lVUV8 $uem|#t1gV! 2zrxFze8ivN_|]C/z'yd#2B*c}} 7K7ږns׭g[֨')K"X²;Iw&SڿB'RډL.W?Os5YIO^(,2MtkmYTzuzTc.[==JG%%m?Oao-\[E"yXHyh?TjFJZmsk[}S:nxi7Tz|O6|F㺜pMNYO'IY9ifөd|)QvoD֝O^ó{ZImcqo24LœbǞ7~8f2kJMo~gNbmn2vZ_;WzWtf[t$k; yHU?wCg#AjF۴tk5]Ob1喎~{^^kk2UJ`8q]Uxn[֒v?se4V*W/ r،e_k~;O|Yg+P_Y%ź̳ tz;Քii{m1lq1t&eת=s~Ư|WMnf싹?eWf_pA;kύ ueB1sխۮ畃ʱN^y+s[b獯!7# O8!#W/i%/ClʷJX-SVײ}|)>դ|jg29'gcjV{%|̋y}@4rҺ=Мdv|Vo/>tr#EQFO>߱Cߌ#Xӣj++Zw960fY#\ê0c^ITj3I]pvEe~1do,W˽s8 떽J+.U( j[A?kTl/ 1_c*ʤz2_d֨ mȬgTa@5G08愝9?LlnJ<]IR7:cqچ)WW]h;-=ݬҩZ:88G=8k R>c kǫ.zkJ$mZ[>ŝE٥ 76VHѺ^A c? )]jcN=w~os&v9!=q)S]kae)IKKu={2mi$0cA~2J1lž*x͜uNe*N55;U.<7VFmλ@`jppeMSZ/ʕV(aWkҌS]{(Ǚ[8UΤ>i^nz6GQn}+8.fխ  eV<:zg{ߖVdqq$r[qŃqQmej/?ZsXB0fv3I8>+}`]fks5۴8q'ߞxگ3^ޅTc4sI$[Y?.II?iu{{&$|>ɩw:=c.K)maCJsk2)2kDu[xcxc<~3XNQfaЩ"my0Hpu dwZJQRnTwd*ͷ ͞<}+9E39J1oe崅妆0&KmOt>g+Seٕ,g_x9@㹪x1ROuml Jƀn+ƣ)sINnRmWَC v5o3gT>PhVy~) h JveihZKmo;f&i9W%s%oԊ1ӛGOR$1a*>zU8lkVQގx:Y"b6F;tϿR洭bi/Yj qq#nPVEUrH3~S[g=l[&kS^7o]æҒRR{C1gApc*>qڶ唤FWZ "ՃElcyg'*zotTuyYM$s֗.tN7}M{pl1FVLnųy(͜nHJV5bkuko( VXzs{R}t:hԔdG9h.$ߏ3~dxFqOޕIT>Q&"8Q[Os 6e]Dw^:a(;A{,y3uZ1,JD1YpjΥII]UHӕ%7@%~;ZTܿmVZ=I#%(*gZ km.Uy[ Asϸm'}QJiFzۨ6\* I^ڜR1t?gR-T$ɱET.FО-?hU(Ho6#a.w"h=YFZt3u=tC- _w9 洓V:˚qZkɝrpTnTA>v⪹;3´9T]:5#V't~1Nd;-3?vht4!VTE;g܏U웹zٮtV_+ew9ϯF}ƵnM ׯo!+ĿݒG [p=A i̤weN|v#f|l>\.B'ϥ\GPEWqmDIJ:c3S|Vf5NYATVH<8V'S~-Nmŧٷu]IJ Nˣ"H_96,*7qd6s>{KETq=, rדZG7KMJ+!wD!I%d0Glcڻ/.NFoR!u6]=[a*=Og asF|rnF?wҪB;UJI^@%m#|w9sֺFU:A[?+򴊫[dگNU=mZ¥m7cJ-RInW>|60̍*$=:^%(RnKVgYԎ4䋍+Ab 1 vw4Vh-?BH-`).CIp22~Z=mU9+_\;2; tu)sZ5:%{#ZvuqwnsӀi{Jkܵy-#KT ̹ـ\%vE)S74hWbF;׃[EFÚ2Դ7U)!aӜo)CMKg",<6 %S׶5D# cߍwf4m@GXuGw Jodj$!1:=iǖ;)frd|ܞ: Z*W%wZ[̾j{w>&d;39sFZy&TcqճTTz3ƻoO=joZN0Z 7>c*s&W̓q)(^bTՖ\) |cϧiqC%ً),y 0=*eg[Nl=Yrr$vfe<ۿyY7EVi \=*MŤ$!is3ꭂp''5+RJTk%!C~]4aXMأ<ⴢUa˜לkJ.rKsMyn;eQ'9\XF5EABb0?Vݻ~p}"漎:拦xye\_FOڸq0R4mgԎ,7A/瞤J)[+I%_5YKaX|Oʴ-&{alw}ǹvn洢5auˏl*d30{<~]*aR>EvebB)<"E`WʷoσҹcREʤd' ȏrS=ⲧ2^|^g,g;p[v>cTnhJj;۩fZ/ ڱsr#Oreq#Řr:MTe(6Rzبۋ3g> ˗Ms]{/\k1,ۛn=iʛSr74^P [ҫߎYӕFi`-`λw*<j .v)JQN-oFͩ"4r?=}iKmoNU>+ׅ0vssUEļG4*(YovT&~GẸ u׿[i#;w`cpxQRrOx[@,P3szQN<9q8IOon$%UXrO":l#owu}$s"#>?+|yBV/t6C! H|ӚwB*I UnvGYA'' WTdn-N0Sة5'p0'zyX2R$Wvo<J4Z~<ϻ2)67g]1ڜͰ%f]e[5Wccv;gN|qZjVs֝s#Zۉ7mp6~mQNq^ڝy[Eec ,~KF~,8N#-Oަ˧ŽxUcՀ+XNڜ«n'\E%xˑtO[Hy&A56ݼyry8g룛 (nȈNWtB͜77LR?,==># ̪B4!MBbXs&A ?ޱm (.&k59ڳ ذ'#Vr9wZSRRb_C*w{59rsVpTmVڶץ(c/g -z|{~oaJ>[eKHaiY()E sv:ԪҖ5챙&AX26}~*gh{L}MRlZ|1f#ɴL O^sXԯeۨUJz_̓y/VO'qI>:Xk514EEߢ`lxPF>{ou$F<9ksJ)dFv&rIœl9=hPZ[v(^B;TFӃmk^9" g+Pp6 1p129&<]J8yZ.Xfŷj_sjÞ)q7y|̌f<sKOaFY[p9gݍu=~.ƌ=VwF M6ݱ&8+7cCi$*'#UXv80 L.]9TlLL31o _JQqKUtc*u)=^asOsnw1*NSQdeZBTtۅ*;I'ZQReѺz=}ER#4(j98zĹb)IA~'EWlUc%${\^͸´e3`{T챏|qL`T9nV-w.͵^ᜀgOLӭR: q(9=nCqĮNy$c5;[Wk<Ƨqu*̘bKPUYdVdv#خZ1iT[-epb?WὨOZ^jҤ]zbRHYeGTK\;]=H >5Hʟi$U\s'}k:Ta#N1s׻z4%H*68 L\cؼj4k0ăsֵ)F<Ƨ罗W?6;h$j *Ԕm(kOj҃0Tuq׊gF:{uj՗;ɵP`h=+X\ֹ֪JM$j0ep2@a{zVKnk o%hhe>^iV=Ҵ8+Qzv~bJNˁ~4eˤmT㎟+:Ђ&rX"7^v?һp8ӯ_v#7H|s&~&O{Vѩ+[f͝4֕LYɚgKufL.@lp=N}^4N;] 5e9sX)S Wnk -n sO1Qy+6S9)H @#9pԩ.nXEZHԲ˩ c}UZRSJQž⬰-ısϫs7g&yXfF򳽤f!xny瑞:үhȚנ'mW ͿqϽrӔRQ.5"hl 0-ݾ˛e*7=AUhS$Qnm]LbF!7 ǭqQz\Z[Wr\X>|T&vo Ŭ1LKy.nF{;¹UyjêX.4|i֎+h~KRL'#OM!sHF0p1ZRTёV1Eؚ%ڱ/X G2O:p vo1@IPTiTU#o}rk޾RfM/osX'9="NϮfzjJ{RڋV&W~V.@~N1/irZBQƲ UUxH UB<(\FRxA_U𻳁sXӗO]|ucsۜqz烍(>e1]m/ob7g$A"pAOLqNv5(VRV].2v<WV;qi}8Ҧ<岷q [ hB&&\ #=t8S"<$m;>f~> 1xJ穆^b&7?Ң5i]Fךue)q'68ӷSm (FtrƼ7c'*]Kf9^6bW~vN CZ7h>*:m%gݖ-㻾RH?|˖1s@}ʤJ7"^UZy` j̮N{rkrqbp,K#ۛh8eR8ijJܞCo[.eup.s3vT$=Su09y]FX+H;]q~\ѦE+=H$ANlr>5jS{~g TJMlKqwo$ehUeV#ԏZ̥_Col^n^݄K,p&5*\za(ݳ9өRSMi%# $sZ,O}b&̆EDD ;{'RNY䒧=,sZ[\-ǗFgl($f% T߹nm=.mN5#+=~Drlqf,2T*Ko#[KUɵQOpiScJu!%N/FmX)Uaᛅ J:ԭ(oi4N>~A{vytRRj%|1(i§*k?e~Qh@(?$3}3t\gijtQ|bleϛnz}O'uROV P}vAW](nvJE6X ȹϮ3]4c$ZgG*{VRu4Rڥ1nvsӚ Qdw#xT@bpq~m}֧O2Zyy]zUy)2_2$ڮTE$rzҏ7C.j%Y V#}RٲqЭ%c#ȧ$i56$@p向m$c˹I9YpFؐ n~RP #AhX/KF2iz YFZ?9~UʕYG {tyk)a#I/~R~rnylqԴ˵mmx\u=0vG?nؒmpx>SF*6u(ݬF ּvwHM:wM Y$S@ךKrR[#oy//di">_KDZ޼*PMKqV)Ti32Inl;1qێb({JmϧJj(Y~>,h+Q {['䞘_/sT|{Hy793B.XW<3W_;~εKާQ_HޣBA=ɍsʾSMٻw\k$q%w6_p91޳bIcru](Y$1dّ}H{⻰G} MhƤkj)erH'|w %{NNnj_ҵ&0˗F: c^R[hԅugT(GU#2^1׵NnQjz8(+hCRPmE],@82q޻ NG)MJܻ~E|+vA]Qq=*QWwa.YeIVC-3@ֻ"N\h"/9ɒ㉛r=|qκN3̺ȽWԖ˅W&v{ ~Z)kmj|wڪ]$`NR\oxwV6P x; G\)оu+4gh9].8diTD4o2B=OL]PMJ9Xs-aӌdIݏ{weD*qqSB-M4^_Y?yPH'viQ3wk'םM~m摰8ݜu*kN1߸$`2tAbKY&xcT(iws|T>pOziܻ12G߱~zV.tCBdho+K8p:Χة^+VԴ('(y$| +>X{7Aq$ ˻OƩS-4$^]Yf屹zҝ9J6Fu}oAe4:\`o`r{t"SE:8yYIC{t2Βm§$:!KݸKr.7A6~HkHҔ暓T{,#o}g3*Чp:M*]4хJRFk9]}1}:rrqZ]f۹x=:ӕcFiW[oUtSV6X.j|} .gpקhsH䌧3<%v@'ɀ3'[#8>Ԧܶ1UE΍fZWF=k 1eTWcO| H6 $'eZ^"6GeW9Ld޹EV"p匕GTu!QT.T\$*#XՊ3`g*JhJ駶ջ3s<{z0Lʥr]j_1)2ʼn\ꏽ…XY *̫w9VZѧ:nxP! M ռZN[Hlž<_pGkX?F<ˆisZŎ\ҕ2AfV'޴M{NK @}60~9j9e 3QC%*&r1ԓlbet~)}%9h|* $M)nfJߧe76GYa1`GSǧ҈ƥH7jMRKg;qzqI'ؿvPtMW5۩^Ö\G&fm=4B\(%t;{bmI$]͏`p2Ju+N;Ir:s玞}"rzV+Y>:z8ndx y*Q~~zrJw8J ǹC~xa OOB}hn[|ȡ8%~`FUqz/iM|2l Jtܷ"8sJ5,!!gS&yOx')=m>]4^DiXL{IIlG\#RZzQp:MmYU.qXԩhNՋ2CJ~`~.{ɩ,-erh s\{^ʩjC`%Ga5/i\J TκO2ᕘ+=׭?k8 ֏NϡWzۯkoiU7-R{zK ]Dn:p]8\C/#l"nv>n0~KaJM 27L9?ʺi˛DsVisK֩(`W ?jӚ.H#{= Mhvn0a.:s[t3TJikA(n>nN{VS,e)t\gt_,l~#%%>i;y[xw8s]0v*|-49}orI?y6tʥE4kb# xvomd˺MѴJڷ)W#<k Z3FKJIcӠm(QMbrdKkcϼO\KrM)v'm)yzues5HBr֢m;1Uc9:kGhHlgk+}}+KIrt6a{]r樎*[to;zU?i*{ʬeMB1ӹ"I4S516=en[^{yUHi$g{kׄ򇻽@/$sFgoU唯mD/xv]/Nmw};8<`R?weg*+Nvx!h&_3|۷p2p=}^v'W8jCNVM3^yV~`9ƼEJqVLۤ5̕Io`۳VJHK;!.kֱU#Km7KR'#w{TiȂ*|C/je3NYKЩr*3:)ߜVS2&<ŝ "I6ɝ/pqg)8WeRd2agUqץ\y-m' ۙKΉmSɫWڴf?3aO9ֻyv]Bu5Idm,lvN^:_3֬#RF䍬1ֻYJh?.I,Wr zW}%hݽGW%]wxlgHWl1p98랾Q.\-UΏcFAvJ2 it"5OU-5䉚Ermw KD ~KaT{(EBҕjePve;uݻ)*p˚MV/uj g9I\jki緞VuCv#F?9+a }upϪ<ˏ՘qNT/u~M,v n~P?W75B)5"֌mıZrY['uܱ-Ԃsׯ٬>=l,^<nTJ^JdߴccHZa/NׯUNI5%qqo1OFrԪK&N %ZԌy%[@IeUG,nF>^i2Tx"pݳwl8{\_36XQyud:VoȝZ@km?3v֊ܺšS(>U%Q3ׯKS{nMo2;TfU|09 U9s(˛Y'Qͷ;>J#sjO%HIY"<0q߭>^i\q6Օ̂Ug s֪,PN [Ry YLCE# dm$ye$ɕ8Hͻ"ѴOۮ0z=)G&=?cێ_fCj2յ)Fh=8?O+)rLQᶐ//cUSއisn̙#ݷbpZW^\(N)!"Y[?Jq^}M;2tEb=FqUys*5j&|uqX0Z-X}HH\8y5ǿcѴz֑~on"VX,xsaSԋm-3]Qm+>7}ʋ浧s#Q;'*aP%$;touppDYA=ss]t' gd ȃ 6d"1N0MEww"o-42DY_>ھhMFt9^\ihW&/31׌S?#NޭK$[1[;dC?;jhR*z{2czפҽ9i2ù/msچ#IdRH[$nJʝ+eR+t|?G0c$w `cǣG8]\*ʎE;^ 88|%8GϦa i:ތfyo 6?L`@眫V>Wv[v_ԧMiy/2|-|0-u[FV_n+RC2gk@`+j}Vvc1Ѳu?ħZ>;<rAVi " v9},6;tRjKDKmo'uV̧ތji~^OG |&MgRk\i#F93z}\ev;ׯ]J^Xo^tzAg~# m$C*Dޮ2py{S_ܺN_/֩Gz5ת}xU> hz"TF'tA0@bNs\tJ TVZ =fpWkƲZĚ]PwƑqa099 TqeQ^+TZyL*ĥ*kXG{m}͟3x<[=yɾU%U'c`cORM,-Uo/C%ruhFPiim,r |?[];5 nଫb6 ^QO|,<ҊOۢf0#4dY5{iuOxF?^d]7R`RIb#ݶ#W<>u C]WMz} /aqNoZyow}wJ/ÿkZBmMHW\'3_;RGNM%ȩTTJ[}ǷWh¯%t -'OyCB eBF<&V˾SוJ)Y&qZZ==Zo2Vkm-g651ΛG"2۫|p9w`ӧ]~WׯӶ(UZ*wQw^Mj} _ s)F/]O竮ݎoH,7l?)͹hDwyöHct#ZS3氕[u=ZzTݮ߽zg;} ip%ܳHŚ_H1Q*-9{mۧcXƗ+_ ]4գ<1^\Z5c$k?>=0sN=}ZNQN!DŽo4iuW;GtJӓA=gּ~g^?zeboEh ǣ]ILg$Ooˀ8⟼neWyԣffe~6v>/%_-3[܁,Dr$aXc׭Gᶱ{|]O^rͽ•dݴwڼ_kwZ-ջ2orzc*3I4j~G^UjoU~F}u7jn#\F^T_*RNӿtR{$䲘Yps79q^>:Z49ӻ~.V0a`&[y~бO>\Io4$KJ1El;X#";${7i~]|GS Vּ#[fRdٛ))yTZi'>ɫ22Mk^/Z񖩨.g9m.$YhV1GA~1\ڮmkڶ_.ե_?Ux/u q2W<ym>k)?Bԛn'Q%{2Gq4lAoNjS˵*"WK2Z-`r~ZqnPSy|z")F|qߥy\)_#j*^]=CGܴ*$Xs}=sJ#M>N:o8_xq|+0RїsЧ<.b{k <7t{gq_̡ r6+,hv=gLW1 :cG¶ںkoQ<ۄx2|yN3tS}bp^Zԕu{Gryc5̑HȠ)x(5(o%o Tk}9uXYcá߆JG^==/i*ufEY)w>WY֚Y+PE?>zr*Z_~GW ,<%ލu{{1^] },jz{[e&Uv//3 <ŵkvéDv xqu1v=$W+VQ]UUpdv۩Se x?)%GBNG4eugS*kgx;=6IpPo+ˈͰTS|uws^җ0icO_)qUiGX#bjI}z.7Oh.4V߅0y|mn&Fo룗wgfZ'+.(Lve¨?v`FO޽ɭap_`/ކf} *TU3:9U¤t[4hW3I\j ӯҾ5=ZkBU~Fv1S9s/s[liEJ1QʹUUk둜εmV:J1wWǦ0)b<|=vʭ?qMt7lG *ȁ߃qӷZ痻&vD+9FI$JU$LW:T{K*Kݴ-pܱM۾fFB㚉9FJV]I7$~\+.Y8g==j~Φ>ҚMjI#R~l6{Zt H*198>w2zBRGKu2IyLk/@xN)ѩwúܺlN{nxRlCr_A;eІe+˜Q<4/ſyKc'͖Ej+sz*KWԔEfcXm~ ۴6s ?gTjB57śyг6`1d9wXэB3# y+Y,m$8仼{AFuSp$]=;$Ҵ m"3)i7 {ֲLSTb,!]уuߘGOQHFud~B>Y/y1mѽIJ1X.Cn rI ORܦeQ+='jꜯ.}ΊnHxd>[?)JU9 -gu:ƍ fq~֟GmXh;aHtu'ڶr:ZMWS%İvo3 9D\t,VguEbb7GEjR24PO~ D qݣ|2~Ҵj(Twz\G}̏YY\#^JVOG:.ij:spȐh~U^+ϷR _o2$̭ov0CV*?{ЏZQ4MiTEN?v,=|u<ZJ>רVUjGkt#h XA+ t4ۋƜR:>vV cen">loS~%-xf%r-v9䟺FO>N*Qc/\k'KGewwS匹/Rm̽t־^P"XaZOI-\tIV f V.JƱݲCx9Zqk͙UvO7"qW;U}[Ӝ:,h59Cez%5~ vQ3c`'~;zTjq%$FOr?!Ufa (݂OǽqԔfnUJ5{2udh ]I>U(U%KV ={*RRI ?gd֣A$;Uoc=ɩ卝(O{/m0+F.UߠXS[]6Wr'5%+#RTyۺg6ІBˏs9%/x佴4JFweo\9Rfk5~aV.!d 9qfjxӭgXr6WN3Ќ)8J7fJգ!|I7Q[T.2~֮]أJ;|M/?,U$iu9#ΈT8}_&}88gI0#p+ܔlg5~ǚKLřkJ<ĜG\~e0IVzYcnݦ\g޺cZ/NR &y"Xd۴xXM˝B.RWD9 R dgڊFzNf}'+CՔ#ō`nB_2v\lHK5)}F]m3 x́vO*hÚOKtGsGvpTzi){I]ZZRI_kdyP$gڦB>'5*nu|-dd+ms9Fo:Qg N*ãIІo'/4s˷]1t'T׺mwH)#ۜD9И՝QcB[ni"@vGEJi߳4ż+))r0#*G~*~u9l`= d<9}o%vwQKJPu+߽"Ƨp8}ni{>]j*}Ř@6vݿ:RJ,{'ecC#GVޘ֜e)YsRe eA23旽-WS:j_pE5@y` ǥk(ٲ^tw3HʬbIryԣ*zka{ 3<%!F cqJQmwK 1Z[B}|<2sy*ƓVV ue#$UpKu`Ƶ(Ɯ9hƥ~P1BbDϻ` YSNgAƚp$+&>YI9=q5^D+I+''##?*FRn6KA\3jqx)IZDF1|7eh`pz-S5*{-V';Jg޺dvӚ6V׷f{?/V7 }_S-%k캛4i 1+xlG3+ӏ,<#UD*~FV}GCJF1ߪ64EVY]sv9M6~J͚VCB+7awregw٥L r?oĎ=h[Uxswo$wzco@_4$7n}^Å7+41Wr7t>R58٣:bcdVI ף2اJ?g*'lgA# c(&}دS&=#0ۺL?Urv'.w]q'WvndER1Mje]H J⭜Ԩ-^(%Gq*+UU OlӁEKm5s,dLM.y,mc葌IrCy1+l}ۼdҸ̵'V=7];_)O2M9ߏ9"3J7EK|syZ?yZBEX>=yy()دj/B˔&/-!O^.3G&́E'q1?(=k8' SEeg+J~Rw)Vu"iTG͢x'9`G#}k7/v3 п"y-Vh<݀rxzqׂkW=9{lEiY $h6Z<5dX#6Eskc+EHܒ .%VoIoh=GVyٵJ r޳U:ǒvv$M Ahf*=榤TV&rMܱU}A=zzU;7h֌ViiU73QQSV Ox>V}:ίIOFi>fYpOʹ'skXQ{ӧZ.z H6nI&cQqQi&)r2:*幽j?*ji4ysҢvgO];pIЭ鯠dk)_$5q}|\3/˸t~qyvEN Tf|K`m<ǵy0:cu{ S}ʌr;7mR2t߱R?(E32A$#J/$퇳ܧq *J?6Q>zOR2FSFI1Uj5}}EK^pݤ/Z)Č2#.ju4F;@d#)2XxÚw;{e(^?0&8޽zs1kWHME7~\Β[&7np8%@OǞ}<[KY#O0o< tsSR^sj-FZ-Y[Qi$zU,Wca.zQ}wIi)Fj_eY!s=>>nWyƧyYZs2ڛ^JQȦ+39ڮAHuޱF{ÚR9?2˹[$hBBc=nI=5u*Q[Oj2$h͢cUKr$g)S;Ղ8ѥבim5dYFXq"뚥j y~/Rdf۷lܷz$A8F_b17em_ nçCֹnZ.hyc U ݣksֆwЖZ8^  ; qAYs~2=Mmgrr4(ʱ*3e(:|Lkb]Gmw'yI tu%}:hԔwO-*G\Hϵn1ێGc9S o/`o#RQG%LT5VW)-5عʭBn&SIszN7Lֿ3;ym[Uq^OEbrF8ɤ+q Yv>Rew n򬒞 qW8Eӏ2ZzHٷv1ECryZjFfXi. >KpT`F͎Z)[V\jFb-w>rKN{zt}nFt9/5БApVer^8s~]FR`ޯ 0FLWꌎ;N(,:6XPۢ{/?wz\э_0u,l!’ֲ.1\dRӽc+Eh:s卋;as&TKEM>[*.ƑLgROV;qZS>^ 8w$ 0ȿ$r1ہ3z?zyk~>f3"@B v#nQjx.7F }U;tusy>F!zv:*YpwBqxyaTwaRY=S YXێ;hOtoNZE-V̡mEj"d|ӑ߿>U9wIƳ[d2"7QpUF3>e.iZO jKeKˋɸ(3g< t\CVR˯{!nEmy y,MnhknDAf%ĭ&\L~V.J5om)(j2xR] G<:+t'\T(;cU{gy&Fj'd}YKYkRQ%ְǶIv\ƹRZ׍懻^vw<0O#Ҳ|/gRByrpFEe*Hד\jLZ[ŹHӊm Qiż7w+M<8O)m}We2eTaor{sª+MlvIԩc܇媔o3jJuum&7CsSZ VƥiEq$,[p;%Jfrs 1Ws ?^Ջ3MJqEjLْ6cn'=IxuRN*:wԱʻR5W Fx{~5re+ +b#yjZXT2A8fol=*nݗ,Mcv: :T{:r4N*Apka:!z)QԖFIrRN1r~u%%G;RiYؿep"˷V8<Tz9J4馞䖏t<ڼ;ӕEGNJ䋊^F<`#>׊R.1Rv6O&9xe^7˪i(mU`9UQrFQaK@7so'ΰnܩE=`6K|1q-NUV7g)X:lf!;W$ㆥjqIUy.&fuۖ2ZNQ0%ؤ Nҳd9%}םZ2*(\?9{c=TIx˛ߖ<HF:q5jW0LVHjN޸\:~VQ]yue)%uifYH!ȟq*׿[w~[**S2:0ӕHT-i+vFE͏4VJMةb J>tr Kt{ m9<²t$vfn3kn-1%.c<tS1.LBS-bC#(d>Z%{ҧ啚|zw yb6R d#==+ѧN1Qr{?81jSJ=R2"7?y_ҸjSRw*ҕ[uYgtnѨ_<W}{Ҝ%-nɚFO݆]qץJOvzzj:cke+It dꍕĩt&icݵ38dW,urյV-_G8)jIJɝy=]BNRmL̛THߎqӚ%OK|<:IIJm9#'=}k RLN0ֺ4g~fboD8>k;#ZDNc\wF۝yWnX7yOd:#NVT^}SV9$|ϞgJ3ܟgNM Vz<5QcSw_ΊdѫhVyb9?^?\i5i`甶8LOZN/hrйi3[*8սZ)ҵRji- I#Jtw Ѱ'^#T[3lCF9Y6,שrsluҋ9йvm9 XͣKRܳ_)opqUӧ.esO{%gJgNe2H]S !F,&Y[_Zʢ.j36mpѩ 9=zV:XAsT/ ,ʱ8啫.h!jNSտt;b~M>W]ϚZ;cclfcqݍtm\ۆ_39qVNOg,& VdUݍ kqԓKz9cQ$Tl`S+Į&cّ|9*2ok!wcpv8 Atm*՗꒷%L.qyOS?kGEb]"#6лX2z*o>fq[ddj2io^K?~(}eV]+99Ԫ.XJpA)hm~yl3yR:s68ׯjN W7B4*;U~+HVft/{qf];c2` 6{x*} ]βn:.f`4ߦj=55A#[a㦫X#3/˖5䎤~Ɣiݣ8ҩ&ܖ㿯k*?Bi7gI>21GduTF I˹ճ#=K/3Je%#ZB~t8#,qVUgd=CE ^0lp3|U*FMc&i͖줕Bq1zʜl۳;5296[* Ga}VO&Qnfg#HB.~kyJ3MwO;la[#TeȔ-Q%ix8;ԋUȧQ 'e* >b:wWPJ&Z^T]"i7_,pyS%G0Akv7uIBWikIgJ擕IuǞ 3ПQcJ[b Pevj[9檍HFZ"TThۺ}aYVڼMgR<6#ESWK$țj'r^*J];Rp$rAyNW:R/̖;(7%w+!OqW:u,dtFXݭ_A+fYfb0Qߞy[jNkm6edV.ܼy^-cNW|tGIL6Ózq\qQ屏r~w|AM¥l<Ju%N\#:}@1 +D͖cQ#&ݙXӒRiiBr򧘪Ŋo&=W۽>-NUǘc`xP>`ߑYV[Ysus{nq7޸J6unգJdЇ]%4j˹#9휯tZw[MMkbCo?T1cfY.-hյ7x>[,Nm#<y\ⶄz5\q}7n3ߌ5:1QݜPGlщcTD۽>U(u-rԊ(BEMӎO8^JƕeI7摕R3n#(ќ\͢͵Z?JO^֭J2y?Np7˔ܞOٮ[ҴX~=hiӷ L<zǠGPg̲.+(g>(idIUR)NK4MNVwk0Rd1kcͭBs`oa'֞4nynZ%{'mѴ3[nj~q˚?}zd]eApsʛiG(Qc:dkK3ˡo 762krI펼Tm2"EUf x/fdԥ 򾣦%?ɟ0As8Z{F]Z4[Aw2sTKFRR6m';p=hi4M8˕'u&+x[w\ֱsҴ۲Grrx_JҤeFZIr/R6PYʴiOF6i^Fsi1mn}bW)qZVKIo}⫭9,dhӲjiRf {FcMΤRZy"=̓)iYV@\zLg|E8T+ӭYKt_-.M+*9ԧy5#ngCaoZmPĝvAǿqNN%nud򂱬yXz鞝kNRyR潲0'>YoָiKS?z*O)T݅G|u産n<i"E@VݏVrf#M4-;bBʿz5*e4Nh:l1U9:iGk%.L*T*el=MN:oТfK"MICsZJ1ҝ:1;ّ{ƛlS6E><xJRN1Oz:X̚6iʺڨǿJKJԔLYx$o8h[x}k2w]w:<}baa-sv_YԚ4^dT9~kji,6hV0 *\ֿs4ytلk(V [ne:#$Ggzwm"ߺyyFU5Zmsj uNmHP2z4woSv+qpwǖ1L9T/id&*[Wϧ \3VGl>O 9e̬ۨdHZM˜) sWzWD3Z/U7)p~nP<ۚ^\Gq β/BѶF{ޜ[[R2}E w}J{<Ȥ2Bǯ֪̅n>{K@VW ‚mDo.MIIWݖ$b=#>z^ӚI B{{U/"^c,ms8RvBw9S'Υ~p|ǁY|>rJ9G]ƛm_]y5QgT='"-?#S6|UDUqtSLyg Hg޻wzsJG.#l2Dڽ%__NW]Hfrn#2I8cǚ+oBQweY0X];Q8G985}J7F$N I+?wfȟ[S9oGyH5*quei3>Dm>7S/ϸF!-FvrsT(HFvWsJ)ݫz Q,PECnP#O{Ԝb&g[{HeLڱ^{]YO5yz/]珘#HJ>ҋ|5m~V?R5iF5(%dm4 kk/Vfam$27*# }@>[kf{Zj)ՍFM'X\y#Il0c!Ss>tjT%m7~2QZ}TO V٩Uj_iH2j5-C[OR)fӃ}쌂3:q{:u%Ύ^sĶRc7nnp1Ѐ3^Tty"~ֿcJrSOmq5- ,yQl?1SC&zuf4TUK[[_KPWڋG$q88ֽ*8{9-ݎX:0断o#-L1y{HUt[e$JҾw6+k}NaN~L/Ilq3rT"?̰[ܴ#;Xgǟ6l^󵰑in2"0B`>kqV[]~ߌ~zk[h/xg^tG=M& n4,En@v@;}+*jIoV|'UnM=޷3>Th!f!b FHܽ3n>F:6TkOR ]|޷4/&D$Y5H$8e` E] O(T)=zMhңc%MKMԺy5zw6k>3Ӵ /:M[d?037 >~JtoRB7t`m=|>s&zW?a`";R˵dHӸLgXswRՋ刋Mo/NUZNXx'';! T<׋.ffe *zZƥ4c$\k\߼9E619#I~,WR,I[dn71*ƤtݿN#첟c*ۋi&Gxc-*-14~e,ʄ!R9 #sRQ ]$>=bqTF >&ٮ><}uIUkVqiu`0z=BA f=K/^=Jx>&8]:?}?[62VŃaWrOELSbw5֬IE&^w/fW e4arQWnild OML IZUcg;yw馾a}!NlvmK<=oY Ǹ~9~Z!{cpNFG_/QWN7O88M^_K+^w'D֤I>y;78a,L(ѫ.fOW_1QԪ5">"| k|/o%EծVY goԑqN`*wI{߷~QNRW[%'mou>Oi]wYME2d[<@9]%S<ŒV2I>͢3mMXpzd}+RcOVQS=WU^٦d⚮}#2C3dȸU$d2{RNݬzQIEZni>mI3_0nϩjb~&kn-jqxjCd=J{ YFJ{ A*Q^uoLҵm+a%Nвw;9V'7+~u& ª@Ы m{2Fn;z_DaZAJ >V8|`rژ=;*Fk}4; [\XXIH) v pԌc鏼XG~Z|q +RM$nin,՟E[D2oGu V% ->>/+΁8keb߃ݸ5SEO&ա[Eɭ?ۘd}0s rh1WI$32p?Dz><c ݙ'9ҼLUJU/Q$f9OS\գvtS[W2#?xݜr}݇R=,=9Fw3sNQƱ;{>$rN4MKQԭX$dcaTNG9iVsvVNWT%'??aN/h cwHX+3W>`^E&M3ԁfʹqQ儕e<L3/8c*أIZ+B*JK%),m:ȟ,~X-zc2,{RNRv< s*̥F~SߌsފnQxzp{koioWj5r)Fi˻abڿ3m9W6G#gV$ͮDycLYe6_jʥ5RIc1M [HU&6kU(2i:^p|D..blr@cR>_^ ũUd_D=\pԧ,Dcg؇- mT |3y]&ǥR5'`faT&2p2y⟳ԞTP^<"̛?Fjn"KV_(.i>uu⊾;^h9;7b\άB𾃽L#*)/{G,$~DS1@%6ⴅ9kSYT$} s\3<('(QMPVl&6m0FXt`zpkJ`zۯRU:K[[RތZ[(R/2WV[ܕe%vO/U!GABm+]#[N6,0a+R6nw8֪8JWӹh^\0E2a d姺9e哔^gKm)Ƶ6Ft쮚/scEeVg!??rϕte Z/i-VfGL:~ZϗKFWCJ<VU᳎q\iwU) Kk*Kv@;89ztY{v&QThZKM\U,>\s3XM+qm/ۢ9*;qӜtʵG ](Fp8z9e>Yr,B ñ?y#mUUBsSݖ[Licgh =~QQ5m- uU~zEZRN_q5 o+*;O~+=QaiGv,oI?Ҫ}ɿ#co3Iɻ-Ldg'̤CTWmH.U qO_Ϛ_rU)Z/CT?ٙxQUylXsysS~T]lrBP,A9}R^6T+QS۠I8%UxU֦ЏڒHZ?݆[pgZwoGaylWTTuz*(/NY<8}|DywZ@q`OJTvwЯ$HxsU;rN2)I"jy'*zG^1t9$9\iA^Eu"<2Ȥ|11U:-7cjr&ۨ_'V,NsҦ5{3g|ܱ]fUl?/njRRF~eCŽkneoEuӂDqvA,"0Ku_ݐë~>n&\k[K˸m8횪s8=IjTnڐjN웙7AW]-m{ܱQAq1olthWouj TTb7gu=5ymhr܂[$3EzN2vf+RKQ"wIcgGtFR\dFN,Z,UFio?㞕NV&eͪuVIǭRNI/ښIW1mQ峟]T4R[jqqF`ݳآs=W*|psJ1ht"VSuTmR芔|n$bV7}HR.Y]5fK;}U*x9?ʚ+2eMI#gc}I]wW REYch[؝kjq9HnUQ }'Jۗ[zabH8\3.~<*~aNU%++/^d.&$1CH}9֫)^&{6PFee9nCJF7A.mu*_:,ry8Ұ\:U˪2g !q#/˖o~)^1[OEOymP9jQv&oC>%E&ERI#gZE1T} ˪ &Mr: ^&/nTFlm $'yc'e.fSI.8̌(A1ҹ*i= aʦ8%+Ghq{qZۭYY/Dȿy:Ms FQ{J=aLU1NZ*+a3&ik#g~e*aAG}ʧU[m Id|}}0}=/FJg)#V= տe+3KF2lMn7}qs8ԉ:iN契 qQNR'>g/s*F^p}?kIGDΧ%}nO޶GGg iNMGB#Z.K,Xqvͻ99 9\y%voFE&)YjX?֪Tt4Ԧ66m{ⳗ'MN+}HIUܭgsޏz:-Le$,W OM%1exn2\/wQڷܩ&\Γ:p swGN=Jrq(r;on7Go~?>6Ts{}&QvVV[\Fcc/p?Uܬv2e&BO_N7ҤSS#DnʱLkN=⮙6y%lUw-K)VԔm ĺmס*~^nfѧ+=%IJ426l'3㱭MF/% Fwkp wq=Ͻq7s5*Eݽ?12oû;G\ҹjSS旻scH(Df>[no0qXʟ{T*mg-u%hWq܄GPAZ~.?f|VJ)O vzWT9R9eieF 젩,sR:دiP [rt=]FU*J59BG>^(zfhOB ј^ֺ)A^hq^D9kiYz:`W;VFu!MEF(eO)UZ1G=:m5R~%ra[70nhU[+2+5KMYWyeR9)!`t~ܟK{O>\k/g)EjVa.Q%=8eөȽ + 70>f(iiRR"Aby8=9*ѩ>hܵ<{̊de@\%FRn(s4-1mrzg#t؇)+$_ȩ,󛦷umZg9rԧwJ3e E!e,X6܇;Zs*wM^өVˈPt%6ӜB׹̥s5 cj nۅ>f 0IUISB\?3'fr.Tc[T>2)Bs^stF;OPG\iG!BoAJwǴsGVW|Z2U*'Λз{A<629G̓9*BżYXUn1i˗{S1NIo#3G{%&ܫ#'׭kD^^I&i[f!uU۴}w c:gzWg\,w7dppݹnYH=A=zQd1'ϣE[xXFo07 T^0AQKW%[v#Kh`D99;N:{z<5CjTjOBR)oL2ªIEvHҧw&hn$9>B? ^5'VsA ٩*Yr+pO=je'N??fzKogTn: XTg>%ƛRxYc&w#?iF\z9+8-KpPH!3lbCɴ uQk ]HKITfgO=ǖd\om}p+)3KJ^(|`~7ڪxާތ"MZW.YNq_۸>YUV,n.0Hl'XsI֧%RE#1"vF۷bcݻ "?R10u9Sos,U>kwCaITME;i8=?ҲN/iZ;zyy78YEGFJ*moff\+9F2G2X7b퉤c3sɧ'._1q|˞zߊQ割U4oRWjcF2~͂>kgN\gHūBHjCе?xS1sJR"M r/IQ 5s%N;5,Fݞ6x,W+ֹRTl\K!-Z8xF 7~ %߸/;[Ӯ:RW[嵢녊i7$hN8OsYѩ/CO%yE-rFgdIʴkK;\)8e}He_1CotF%9<+oiv9gFIZ8GU { B5#ZꞶ:VIv۰͵GT̡3V1OVPy;I"(KsJٝXZ~n}IdyPwn }yRm2'wMvFG>_w[Ќc4E,g;zڶ7kcJ1NN+q -$r9:/L?:֔='6/jWϵ-m,PX㒠Ķp:ҵꉫʴG\c==`<#+~: ҧu%%1 ʣOYԗ4rs`#i v]kFCv;u|:ʀZi̚\W8˕kdwFބvdFZmAt+3G9_ʪ.ؙ-]}j o*bc8nwsڪ*.bSbAg ,*윪I+T ns1 k < iNU&9J"kv[H{jÿk\e=,jxֆlAw ym;wxG܇F>S&DwpL(w,9*s+xMXlDkF2wm;L]:Ef$;v*^Qٷ7$l>f#=#޺Z4{G'{HPo<اw|*܏oq[%o1Y`sE>аʪ8V8) e3U556jRI2։ 7ͺL) )ʤjKZ4%SȊ,dTV8nq)+.~i-鱼Iƭ)sYjT{?w$&8B2lJm^DZExڪ)P8ץ'I:aFO6G{s.Rfۂ[ߏҳ7$/صO[ 0;~FbJ5IXwfhZ?;km˄9}KF,GӿDK{(|cKCY5zj /,ߠUIɻڌgw&Vc5NX[c'ZG.m,Xcrq7;O߱ަQj qy|UJR^٭4-XO$oG7zRV\ѥI+|VʰVSsZr0jd4gGb?>45aZзb 恑h:g1R,)rۆ@ވJeYRkwŨ Z5rSNbŵ0V^UpNje)|VTƲRYTa\tu4Nu#*rWMKp̰:$fco^=REX|UUrM=cz.=1+SIօHVř[St}y泫tߘ`)~r)AzM8SGlpP-27O3==8 TQdjy>ePY[NsI׮)rGF#G2:^ROeD2I>IIS*ڕ8${IkcjgUF~{nqM;n"jH*`Pk@+UizZ?D [}r6U^ { Rj[_q΋kUt7͖9$8U||2=GKIթ*2VWz>O7ș&U|7?xuiR[}BOiSՋВ O1 U۞ >NH-Yug.yio1Kbo/au:cA=j9t]C0y~`S{gO 3zWT0R(V(l~<[fUiI{l<#{-nΝ˶edX~F ~S*qtSJ7mL8ua?~?Z(QK#קJ8[6|˶h’<99?z((mtkh3Bdžfl*1sz#X:8^3GU?0 0OqnnVm۩HckA<ϾU2/rt>Qٴ6Jv}uH*{V6:ӌebyR]nߩ$~5yli*NED ee4}a+`nc)>HWrA?1fV3Xcd+ 0ˍy4gtDˑ-DK/.wdW P0Ga۟Γ[ZJP6I2w9yG{u%-HhqF d Rvn.T,Gs1۴d&2ya~zQkݛ\#1X#-ʹ-ʭoR]m o9 ?W<{R܅jC:|랢sΔyn^JlHlR7GަRъ)B61ȸԌ+UrK\ {A8UwxMyx8pԍc(m,\s 1r>ϖjSyƯ4FS9GWCc[kRdg[~G7Ru2@IVTEn  `RV]=9Z-f5(/1 C@=GZOV]-L(2g$Z?Ao#,LVf06Ϩk'叵ZiBqUpjpG܍f{y|ۏӽc8 %vo!-L1~{HFO` s[47k[TJ9b}_DߕM6[̏v޽xsQrZ߽hxNrkNíaiK/*U<#EE*|sXd"5{}StyV0 @x;S59^[kiu(QgsͷDmVE=~(TE:wZФ[YyRv)G'kߎ4^:Jk_Ek JҲ, ^>lqǠ?ֽ2L*QߕODKjnU*SrC}:0#˦jVY,.O)|+Si*5>]/Gp$j6*'kьʯnve\2}ҁc?v>JoK6ٯ7+Hcv#E:rFkݼYz_R r^ƎFL 63q]X}w:_Sj/.+%M?/ǃN:tdw}N.1R#QhV+r}+Jtڝ֦(ICد é!$B(0WEH1W:%l=[I})$cn:G\4{MIsPJf7e$Wcq)K٫w8y?z:[z,B9?yS=xJ*\҂3*D8m̧=y)p z?ixk/tK!c!^XsϽO3UER"X~Jzu洢Q`VOyrݔV_=*y}ӫ$|s Y{Ҝ%퍹@YFQQ5KݽJ76M Vݷp;[@qkjNVz|\[ZTbGd`Ojrf~Wc=K qk5$O?ԋbDrnW2?ixnZRoą/nVk[L{Q dNu4ܻȬֳ*ʼW,(E =?Ђc4Y!/UrOk弖t8ϹirU>$9+ .TGȵ\ljqY^:|{:31K˝r:<ֱbGLQY#dB$f)h&iќKѹ3ԃVc-r8.R=ף2I @D_sJ:%cUx_25%6<$?iMɮ͹D|81{t8ǚT2$GiY7 ׽9k$*1q{#<6GYr㏦GJoC[FmΕ:G*aT`W/gʯyZkcY74|F#}N)J5#h=eMiMģӣDa^Nk*H9I\*yc&UUp1OjGݲ:ZPjdSswF f;W܏ASRKjHMnEme]el9*N\4p"W ֫ rG((ɉ#TAG_Z:#=JYmaf@$| q4JzjmF:t$m63kmn[z Ǚ՗Ӡ8ӄaMt'[VE+?*rѧ/r-܉YeXHDd(cg⹕.2I\*/,r#RqzF=#%};YesTʤjGk'֋FkY'taX_s~knQԨ/зcCw:zTP=a(I=?@嚦׻̒`d6o0 A'q=? ] dH,81ʻUJymqqڢOmg$HD[Rq"+^yN_SA"k vl#2g#h @sEcQ=N7')ԩS+]Z.snۻz t2mTsrr߾zVrەO[M.6y{ros(JJ}맑qr j~MY7ݜ*Ҍt'+EcwpKw',ԧW=M+vO4ζʱۮwݽ;Vї]sӧ*6Mu1 &ࠜOJ!ӽ)ycӿ@+4u[2U6m[kdg3#6 逸;N^'~,m&/wSGی>BF4pܱW=7I$` S>{z֒QU{~"_mf@U$n۵BdW>'NM;X%/gG^M`i%c ާ20Z6lXDʦIUҴa{ܹoe"DZ\mqv=k2|֕Z.USGicNXɫhe6)xIԻ21[Us =k[*mziI= '9ZF="i5N4?hk7#oO׾GF\DGв匩 вhqUshuAjgIS͆5|8G~+#ڕiZ'rǀū\YG7/3W,T$')(yG7c~S~RIOpM< 1A!`wWrIJ#ߙ~fF4c_K)-lGr0}=89_ջ_qKs4sBӷ\iP:# OI)[iO4p -nf'4nMJrqwiFB\2$jHL`vԛ_|Vk6aq{ s»cv O%Z]K]Grf2q+J_jr`--_" ּޮ*W%[[V53YfQm\FqIqֻJZ?S/6ZӨysecYJQ==T۶qQZc]M:UXHO98XKEa{cGٿ rz \5i=zҮBC'Gxe]j۲sKs:|ҋZ 7A$ -l(9c^eHKUjSZm3<1gَ6D6sƼ\qbvomЩ2#tfqVIG*]ΓNEnW,L3&eqfz tTgRM^BR&W?t՝q|$n:d6N+x{>WwbBYUr~mڎ25FZ'V05t3۱F-6J[9[G ͻ8ޥf]$YTRq~`pz}jP9[rz~f`wˎq=k?anTuyIߟ1N8wkR==?1ӍIT槪gcO6v r=GPG( B*Fd5)iռ_8E u`:ӎ"n k)ʥev*ӵ·HӣmFy>WS*)G:gi+UQm>JIJIxoYZcOh r)U8S+tH[zmXUea@SN(I-vbSNVc{ʻFq{~_q6͡?ؓdZޟ}9Q7k[ѳ0YDzc^$`FF;q]lTi[و6I>\yؠl0%{Vѭyv믧oЩTJY7UNMՐ2b_ 1渪={~G/gxkt:m:IciYRܕx==kϔc-tԌe@fMbb=\o WiJ1qŊYEYXܶuXPsםxDfAb3𪧣z^+'b?--n}jo'\/C ^[m8籬\iHdB ClP^JR-BvǵdTڣE31ЫI$v>bGqƮ2M#8n vq\}3UN7W\l2D#yqq]j]{T[g[ƯSXF.7[)8481^={Wuw)1VN0$rt~bB 9N1ەt:}.~F 叠F:i'wkvjw+)fʍqwtF.KF^⾞dA-o#0C([qS[/BjVF0.pLVӂH,tݻsnخ'9go37,2z?ʱe9tDQ,7#uU'93s"ٶX:A=*2#OЫqy,ZHi V^5ӻ.cɹrf GVu% Ǚt&iO^pɮ]cF򉹊%qYZh#Rԣ;:0]m`s089֮jKzzPXiZ~ ܲyaO\o)EM?2]Ju%۹eyr 7>z~h&NYGfmh6In͘nM8ڢRԌgAΑĪv s3,j(w:v1FRr's0Ou"J(*wњz4iʪmׯ1F܎#)5m ʬ-'ԢԶ&2/%܄OW{O!(~IM% Mpmt[969ZӊK=lC#Fęw'8VNegd۰7NX?J^땎xƜ]<3U9sj-r]*G*I P]8Vp)/Fj]zҔUg)?y߭+V]#Gfr=C޲嵓3{I#b3Li?Z;m nP{wCP߭^ >2;{IG_.Zi~e++ĘXA(jiKѝJ&YO!~Մ5#ИcٛJM SS51*,U@>NǛ[lMc 5VU` 8X9&Ec$v #wFQcd1!h-&caRT{7g7 :,4IoUz GឲueE_!V"U` k:wjabTz{^J:|>+}FTib9]2 8Wh[wuxٷׯ۷S^ZNjciZY1'VfUϿS^\iUz%ϕs85˦KIikȰn@tJU]9Tc++_w?&7cػDZK;WSی;̫qGŠtxY#Ȼv }x;z׃cU>kC)Fi7hyG_vzV]\Hq/F R99$Wv3Fz]T!pvK<:6 A`zq{1XWn(ԕijJ],#[{ǸO,wǠ9q}L4S ST~gu,/T7_;[?{q}9s/R5۪/kDwftFzZu-kJ  LEOԍTb^}!N,c3H[vxSy%J\sFZC?io$_5I%]đ eNvd 3}nsGs5 Do%v̠$<le-{קCꊵHק|@~6y<3ژѡ;xH+G|9j3k=QS< EZ3>TN,MH({N:R]6^QS*[kצsʭ^V/~Y]$i,m|/'qZ˕'5UJ uw۷ORbzڴբk;fx!u*F#˞ÆKFJEw4i$Y}חc泊ym:㍻YO>+Nj|K{{XFwv ?q.(HnHU<=W^kz=ٕ֣G;Ke)G{ٮ+O Nw>*acAGvG}ZPQݛyG 8AFn5fߦzu/>|;ýQעo,cj;Ə1`m fR Rz5g䗟n}̸6hE,[s 7Fk{vk8dZ̶KF\qyJ1׽Ykm ]*5®K|[um_ |7M48fQ x'qv8ckbܭV_r?.γ F:5V}FFˍ?ns##ty*JQnMy8=v|Y—K{#4 3ÏzXhJ1\¼E˪^ZyzUc̵{GM56Mj6o*F[;{xqTlsF0U"Z[0oMiߩxlTi#f/\p:܎^ (;y=_xŏwVvCnpbFBp pHQ\>\K/M?wO/j9SۯS~&;J5Hy _gzln it.w~ҩDҋW-7b bY\aܪ9#=}<&*1z+kw{t=SDe]MGEś1'go;˱qWk8_+洽KĻѲ3lN1;6瓞[ 煖u]?0rshYz Btt6F)g ΎTe(u ;b0xfӾzt qJ岳viGX;Q]7ʼnuf}O1\eD+T/6 \F8e +t1mtI%Yq`WO_J7.dMד=<9?Z`oO1v+p|UlF'/oG'^Ju1٨>f/KcHߊٌ0 Ã)ͳbՅxZ|>vgc>Vg?dUOz.3Pؿ3d/ȊQ񰀪X$x^질#O&Xjq|Kk2=sLu\mNjW:׆e+aqpGbWnox)7$2 U ?q=u}͵+΋&Le']%R;R.fyOO Ic\3nH 9K Ni^̲jG9||hS{~='?\wԝ>gȼR:uF+XG@I^I YX["%L%2,,*!FpOCzASJRz/?3R*М]xo¶+~eUuB*['v41j_mugS,Tw} |m{J[NEDnIn 8wjK^Tj [v^u)/[d-5_x9$Cw ƽ?v>Os:k(Stψ>lm&<0yuv90^@y a,_zTrxW8YHU寙0ӡ_^n]?Rrzn{$ӸFFg=1gB~ζN1D2G;WX?1:ٕ*|F4yon˺>8x/a& so`+ⳌE}:+[.X|( ~UnVe`Zrv+n]=S [3F@$?_c1eϠ*_xD 0Fex?@Qp309G$]~<&Ouq?)eI`~`}߰qZќiZ2z;_j%T<$=fPN!eVI!T q'b]iK[=ӌn/ vwjC]V0Z7cqG{=JkE"C>:RVRR.bF nzJR4[Na.C:[c1˷3Hv8G_&өo6j4TrXd]~AڹRV{d==J(meYLoʣߒ*61\yypS9?efIrRv+ `wm?TUqiWrzv+\Ip\6uڅ8F<_LpEJlfYdR[h rphrxhΪffiLlBp8$ {wyՏFP\"}:H>,Ưn8P `Ǔ\GV)ѧF_Ў+׊6-TjSW]4㏧'^rV/Hٷb qZ2VPfN׿qaHܷ9W_R3a5yY]mF~Y,{saS'A(ӭu'Nkxdsϭt{?rGph+Ik Jr VUL{w}eFsՄiͨt5Ep ?iF1?z7:08G,ij2YnexֶRnĒ3h*Ǩ{tTJNˡTjK;VT[[HYq=A]\Z.Nw kwrCt^=~+y>$ ̫"nڊ|աJ$m(㉌Kqu#)|x%RVOnݫYc#(XL=j~ɻ.8W {w7KQBe{:T^\NWB*~Tu$H_jZƞ5MH͸tL$rȫ(ye~пG^W/Se*ډn +yUJ8[hҮ/lܳ wry8 ۠QQкβ\~%qRlIEaEmRgyٗV{PGNOOcW F_w9VXK#so`)~ssj2,gҰXc|Hor+Z+Vy7di)D|Yd\N8O8JR~F25«m,y<+'(?gnhi=9mTB>W##n3SR5..|E$[,t.b[R43r;EhZ0n1<k *{N6"7s )YHnߗWNdʢ܇KkrфNB&Ldbw1!G4Zo;{[.n2Fyqzw5%4G-?6y$v޶^i[Sʟ-۵Fl8+^U3,O3/"Ďc=(L#ZGv`7sq[GITi-+W6J]y=ڵ)G[B*_pd\.kѦtޝDa,_M* q>e]{iYULqF#E߃޵߹N[ue0ɱ֊qs ?VYP'2YVHv'A5eF3jlEv y9W<85J<ɤu8Y>ť L xUQO7.v]*?4?vjc*֟)2+r}QcG:+z?iv_.8S#0IDyyu^O]->g͟~+r7flJ3`wu֐n1ҳ&Tr-2@qZrn$D]O_Nhn_>Y>gwpL:;m̫>ƮO3Z]B~|mϽO,RNdO=A=y%S<4Er5NDta1*irS11>۴7"Ԋݷ#kǽd1ǖscڹt&P̔SiD<÷ ߞJ˖Rexm̯=ªrs\e7QQ"vT,A8#Y֧ )TZHa ֮Irq^ңzgB-~f?3FH :rGXx$|fHniwNNџCӯ*K{t#g^n>Lp߭eMFg{ɫ]Ipֿ-LU¬1ڽI?{zc9XZ1iNt/{@(梷`gcG+[;9LacݵT`u\$%biьgq E%@mArB=:TwQc:}PDL8n}j|ڽ ԩԽ INO=Ԛ65 1f[-֟74:=K'P_'+/,}*\v\EY,7e#c`88i#FrJͱc_2:9cF\3˷UV ,I9v\ʫMJ/ivܿ`:X-SZ1yQ8q}ja|DTw{^K4%UB.PycT9ʉF+|eIsVڛ7Į.036.Xʞ~dZѕMN|]QjW\_O=YܠsZ9[IZ %EY6U~TӞ՜+騥sj"Z5V am<YԿ./)I$jqw s.R\wHGPx\map!)l5:c՚ј ԍ4ceV$1 zbBѹe)ֺ)6e\>*) QJVldᢐllְOݺg>-͍D_io9=O王y}NG4DimbN`>'Ӄ\Q7/7[ucB6'@$2Ei78U'{}+<.x˵HmJiF<IҵZHR%.ݍу5}FGr,ydׯO[*:RTF%F;iDlW+Qw^Ӗ\m $9 oC~5N)v7\T*fEAsӎ쌣Bhn)_ 3:*6uӜR涥FQQ;t(,E'۫nwYʠu#dԎ=k~)%}ldGyoz)JVtN2Gp,Lr ٷ׷n)KT-Jf۴(ۯ"O%Nz3# {;=ͫ֩[Ў'VHׂ5lcUrERQn/$sebm_$1XkTL$̽n0I6Ʌ\2h$TkrƄ\ж8,,cGPx*9YԺv.%l$aI*MJDsZ\v mŴӶ HRG֜ycZR~'re+:nY0oJϚIYE4 66}ss'q2f.Wdě 6U)Wr7h팒/P3t'e(tLuwv$,etn{Vqbaxމ"7;N檤hIo7G-X\ڻ[ qҹgsNIr Jy%‡RFr NzLt[_2vѕr[?{%IC[K{RN\Q~^EX.<9USsC:uJSRhǓO]?hcwvc_Q*Bj%Sեƾ\4[tH AS.I+꟡RJTsRRgQYe%z`:۹F.0ۿA,ḕO8q򁌏֢.<֊.O}ٗ 9yit9i֌9%FXH$'8+hC^ӧR1m Vd>[ =*jwԊҦt"4ao~ф}koKHB#ow`1<ֺ)\jU^!K;IY BTpF:VXWC-َ0gyǭkh.tv#,Fw^9ⴧ)[_~Y.G{t#Ńde*3s׶+H7/iNnvy8R1=R4Ȏ+D͎DU\85~ΞTyw0:9t|r~T)TMxz1lW7k vk֓#>ǵZpӧFPoF]ku#nwcwȭ#.Uɫ Q7)Dc ddu֮9Q^*ѣͺfArF]=*Nj\JI|Ж;9>&N!-1#ڪj)I"RZ(XI @8{Jv9zj||EOYt qq9GJgϯڵjaYZiAgmeg#&ڊ2jؠ_=⺱e_ߑU-(#TrżpIl+ϴL.OF# TyZVkZ]βYϙcO=A9rԄM#);u-J۸2zbeTZ" W*xx&tQæ`Ŝ÷g(ڣI{ۋG,aY<zֳyΔY^-EBb(:gގm/ʝڏ 1$+,[zR|z6n;hY[FC**0<oƹbF!#UUY*您T^ѫ-Q,5EܬPFrOoW,[53W^j*CiG NqשVש֍GʗOĘ jmXFaSJ>]o픽QI'qsMrΤ,X~k&E{NogF,Lu䖸ʼneP̻ G~K9ՖC6+y6[.x<ϣebNB Ykqݮ#ܠ6@ֹHZ3:FZz'uZ)QI=*e'"\̻thzV?JrWs:OvVD)o<3lR=V5".dbI7#ؿxrf9翵M6ܹab#i rE_/er_zswfpά^{tO5U :4FΩQq,n]`3P~> -FP澾{/+)-cQaAۀx DURwS%%Qp[y>}s3l$NJ{N^\dFQ >yǁqXՄ}̪V(@/}yYήt&уsQnԇ*HVU$nyۭi.v4S,*|C=Fr*M)5e)$ ?-a]`s6t(֩R-,k3 +H 8'JR<{O JҿUbZR\ѳ˂c۵lԌZ3mzK剥(&3fS(\3]TkEli.Yf|I3ִ4SjI۱ŧ<$=ԔV9֩o_#> ^\**ӎ'WdcyK[PxI%ϗmfcJl?ZFU6[5ǚW[$џF9(F6e:vssymnddf]ǖUSJ(ROMkT/gc6&CǮH~&|]ԆI(YqwnN? 8ٚ{Xҗ̧ytcv' ) >:iHeomJ*. h"n G1W)Ts:TR k[;kG(6:cߥRiI7ԨPG'k9M237N#51]f0zu9pav<0Gk1$cES)߹rlQc=3WTTn4[Dmt`>Z囒PeʊOoUY}_Oc(˚kl-;ys %!wl^u׹r^qv*2Ji-!lG򞤁 }+Is%dJ4ǞW~[)#wd+J JoT{,@KTd*IY3=}o.>O&Zh՗|y=.icԭ*i]=|Eţ?"c*qNBgصk էȱfCɞ0\92PT}zN ɕu iR^/c>oŤԕ'xEV"*Ls+)^2,;P T/,ȿr=6#ڧ^}_Osz'X#m ̌;NJFu&U4ث|e!q #2q?N7ӧ_e|ɜ*\sV^1,v^fF ?gzըJ嫖eXb4݀ |mrR>O{~6c+Rz?eZ7'ӯ4QuP7Vu$NTv\ԍLB,J }hYf 㞙hsr:*{sSii&FPvS2Nghi't-mdUG^On溩*{0Svf6IUY*{8n̟9-RI9>אsF1w괬i#'ڜcvmhE4YmS'fڥ7.~`x{ j0{ty #/][}io9Q*6yZm5ٴ "nbcv0O/<**9cr+Y2©ihtyعǙ9~*ꥀ\*qsyc_䟵t3V#i`r:ZQrEoȏlgʮ ;"ۙjQM޲m#?ɮ8n)&ˆ`$;t^Jp;I۽\i^~V5e^j#fʤ a,2`J\ݽMg(6h\37ml$0ӌZN3رo4ˉ?݋V*UFVZdev۹zteB#(h"rq}xU%--vn'Uڿ9!@0w5NMQZF?r|,F1ÃB}N*SuQtE;:fx^17] 9q&0nUa#_3TisGjE[pOSת抍^Hؤok4f wzڪQeqzt1GkFHyX:zQ 優^;QffKIv?Tb-MKؙ?3vTl< wy\nsƝ)^tK*rb߿h9$2_"'֤cKeX_=Ƿ_jT7iDi5{n1.cJIG@NNO<s\i3Tw3v䑷*Lg<\ڵ^YAs6Mq;r88?yZ%MFNE!g =N?ZN?ۼ'{r9;<znfѵfl34=9=rBRvyoѷHYɵUx,:gsKٵ aӽַ.V=z3IӚƦUЖQ$! %I^9=}Sr\6M@ʠҰzQ^EK݊n+\m]ΔT+6(;-!n%?q?ve^-Åb6mc>ZB,J14u1VX>~~e, $q,uBIvsHW׶Z脣Q^5*, syRv֪N.Vٕ8K~e6e9&XTG w#)JkEv0;YymI# ' ;˟iʜ[1oTܻ%+8i\rNzf.M_vFTwO"`6[*ɸ5g)m~qpz%M.OܜVrwfZӋk:%,yNөdSz%F&]ܤo Vffc^?R>^NJ}M4m+InlӷROzYzJpk46eI4Imn#pd$F[GQF7Rzz^+`e=ؚ⽌c(A${E|͂c#$Ǐγsz .5B\̌pe<)JyvmaD-dEW![n4y7hZ2m9,9)7THF1ݭzl*N4yd9+>o{ʴ_E4*;.ssZSjUetTX $~u3埛fC1-Wv W49UT"ݤsʄvF⾔Kw9n WYBUvǟjRj4Aۤ&% WJR傷ptc[+)W誰]䎼)~#5Y *ѽG֛N1\rᾮ 0Y$v*SNjc7hTӻe{vX*<Jӕ*7ͣ0QU9SɯHGuW/0I;j8trҜwv޶O"kYbEKpIZƤeҧPZ5W^xl.̙3\19j dxݑ<ךR䍮ZSĬ`k0ee/su*JNO1m_# l#KظŹ+t'[^{[ {C-3 s<\Rq_7B W:QZN-e}͛c.<}RRt4m <ҟ.=HtB 1Qi>i%8n퀍/R6 rmr2֧g=w Ż*whqRrr]~&N1hT&b@\Zv%)F:}m$+ʫL9cV)1u "@/H7)sYFQHyw]Vݙ{GPV2i>_#UT;9_n,{QM޾F߄延Ybb ^9׵g*;;?y+#"־t%I7aI;#<%ۣ2oK|[, I1b׽cRsm4Ό%h=__3c$_OH[N]TkFҩ)e {XI H_mE'$Uc)M;6u߇cp=Ý68'Z_mƏ-M>2Zϲ2ab0:{tSue[bN6mhxUlҶZkfUA챦ɼF>Ћ6y±qⷕIFQ.Kt[} GUW/ p:{}ؕ*NJ4M*ՎN1 9-`6.ӝjѓ]_Ab*Nj.=y/cgΏleW*=3u'N4hƏ~m;$w3 FQuҹTJiiJvV{WdEU![N:3ךW2GZGz.osss UIdے6~'VQFrבiN%Cc.Ǧx>Z\$LYKoeWa:RzXѵ*k5-.w{X~Y&.ZEs 0d㿥g<q,W'Nqӷ89s&i5Sr2|{D9Gs#`rztA qL)y0*㇧)\ך9[dYm8UL冇3B9J<9u&C+nc Aw&_#dx&df$t99]tʶuggm2mȊ񡸽Ϙ0?x8?1jaJ5}1e4RE#|Ю9#۷Z(ѝm3r漏#Umq/1ii]"14๻K|hČY7|dt^Zt5߷j<1 VNIR29}# PX0#\>I¤ev3*X{)ks:B=O\cjucݯ4Q%ĬsZXC(>Ƥн#*Ns7iU9)_.Gϙ,jw C5Rmtb(商ᔭ+ͭRT"IiSaK. Ny"kWh]Xח:Cny'ϰx֌c6xУ%%el36 }޹jb%Sݶ1Tپ\c Zx|7v6QF^Lܲ24R,d?xdp? &JգkiJWx#WPFWlԭȍrވܧ9$[ 2W}tvW[кW[$رT/^ϮC|ztb$„4}UTǷ*ׯ[*.Glb+{ 1NO~+Glz&ݬr@Z8Ŝ +'gYΝ7/IW|qZQ܍:f`/-kbTrfp? ׁ\򛏺iJ7Zais<[n$i]7>]zrMc(تݒbAcAx'NݭIy1y+^W{=#2n(p ĬiTbanڥ8{V'/uS<i| rq]|%d~ۛOϑ*u8tS6*ɽY8 ;??7ӷsW}(w;)M'ujyc?0'u$:}[_ν>@? 2'<vӍ7iŜeS}?OZKzllgR6)h~JB2\dg~"}Ny8ӓV^\Kǚ[lTp==?Zqqqiv1*1bL'R}8sktΈ2B.cc v-q|qG _LkJrƕhv)ݤӢ(Ufz޿JrjS^8wV󋿢 "Ȭ7mX1Y7RO5ԙIʢ|ڟ< *Y^"PZ+ѝJJwa$Փ]tW¯^FIe;n?qN1knK5ƅI7anU2I;|ӵ{ZnbjZrcjt> H69*gV*e*:/wd\mQG8+9bJ*U#ɭMK䢯ʿ;~'9_[5wmbk_C;mǖ|yچ!ex?R6WkV>]Tݺ$cˑ|հT\Ny(ͿrҲw0oã%լ]ȲHhyaGiNRivS9E$zo-&}8ȪJD;$+YaEtZo-ຍTc1 㩨9msqj&T-"[8<GZ蚞Ҝ*[ ibإ7N<ҕCodٙcrG?NbW3"DL@̯`9u#W>GM?ፌ@r@GSZO*BjY$bwmL'4#WHW)sӥLj{ yvcgT/I}.O!|_"޾jUeryy}7@[.W9Qr >i>f2{ 20t}cQU)>d|"/oZ|2:IdY{Ozq yHwn>anˎ*RהA-X9ues]3H1Vrh+qb&9JiB3Ï߽O,eG٧$RUry[?e/zrTNqo#m@I&ae(ٻ6zlȓֈͼXɉs?g̣ 8S *V*V۞1R9S5Rhk)I_(!WYB%Iڂ^7M$G"iwo; !rKع5k~g5 v>'-tGL;xc2K`rp9+[-z[?FNF4Vo<dqH^Vi*w-ʔ2G7ˀNFG#[~Iw< eOkCJfr>MqL^ԨHʢK]4ۿ3?iȶr{]n{'_,V65^gq-3_/eۣ.Yݽ/=9| ~^c=.^RQ;jbk$(;i=2m;1k>#*R xwG+d/N:=3\W/}LJi-SF:57(F_UYn::ҕ6ۯF-.k}d/m[֫u4p_D+._sWzuZjɶ'^{}c2ӫB|['~~6kAaj&$1Cbeo_SoXHyd]Q  L8]R[ "<3k[JUeZZOL:WZZ+k$.WI< 9ݞszNhgE´eZv}!>0ݦQE.$U`IN2k m⩷yZo~SZ4yu{huG,5[m5)$H2B߼OZj rtn&5 3F V82mq`񁎹^֯=6_OF<^$f[gG9?}=-:+]Z԰4(SJ5QQ0oi c9PAU0姫vHaOr j_"!?ihۯWӞ)Ge]Zot,I9=ǰnUv]OWRUK}.+*BՈ}gqф4UNczKor_Q羟iN5ⴹ>-4SQ'*qdEKUm;2TK]Ekw 7^tIXvT`瓴z[+SVEJ!NN^o>5ym`E>s\Cv*C27HvJc8ϛZfʩ Y;ծ=gz垫 '#=s|5WnO,=d|o^-ѤH$ ܯmo@5rtek^ -wS-{=~> 5;)+9*'8tڽL>{hZ&]u[]QFJ*7|{yF,|m}u4qOkrQTN9:NWzum< h⹣V 4M;oӝf=Amo3$o02AA#~<4^*QRlm*u:N\~5_sCx[ޞrx~;`+pRBʠmA+鑎%өQI6﷮f_WT{w{?ޖsh? U6>bbM r璽#<")JZ{{[^ϡy4qTk.WZ]ַCԿfh/"i |ecn#,^aE(J%f[|yQ 5m>fnmrCk`݌pA*N=:$v2\&M,x'mṸ^LJb0`q$`v%O~J\4%d0>/ZFakuVͣ۵E ,*Es$һ?*Pp_x_MUmU|. =pxש]GﭼG&DAi0R%vF90rG{X\Ri˕>9bIFm>_쫭KTQ{[M^]ci7Im VFl1廇^im;)ӊ廍ӵu_I$*Wʰ3|V@Bq0pToSFKko^#%ַ< |1NY<7 \[|Y !rjI[Z/񘬞:jozEi$ӭ`]3._dTWׯWix,$hQ>t u;h]BX9pnT#{ј`T]&^Vmє;]Ku??O\x6qX*!͸1+ˎ9ყ mSLKq,W('nhhr=`m'38э9j}!ǯ0m,6&͎H_5cEtiGG6{K{@/- lH;?EnarxҕGϺ/x-odi&f Hܜ?˳B5o*p\񞯡߳ρβV8ٿ^c؜F"{8F;]A-\^ӞN-<4lW,'$bȫUs?Y_U\o\_O޽ⱔ;_ uI6$1@Tnœp0:z }:S^:3GKtO q_Y;晦5vNOʧyߧo2V0բ_W_Sϯ7BWڱY6.Gz"o#ԧquEP#Z8sl?\}z {nh.6 UV1\jYs+tmniO^'#J2lg13p:ps?]:qT̨ӓym hb-7͐=Z59cT٥w?fh:Uů<,D}Q^fU,%mΈ׵S Vd³kv$n8_@u>iJ._>VG=vM鴴u|2'~ӌmZzDHVo]{8[5@<0ƜCYFOpg.hor !YQ+iӧ%ttR6WUd\F.)ݕxER3ߡNQ~SFxAE䖷eDxհNN+PuI^\wImF8ֺa1BU-BayrmU³R^V/mivm m@=)J)хhFJ.P^\i'@(ƜK~3pOտАحVF;]U,0H^i7&*QIl[[:Mni9lsbI5(+MAʨF/iGiU-&0xw*wvg2[2;GnzvxJ+WRU#hgjhYJcĜ|nt=8qS?DMWI߯rd]Հmn:ӭi%5M 6xշra\sۂ59{Ֆ-cY'v܌~*Eny3nkY62r?1,N:' [m%k LuYJњKd ," *¬rx##+-SҡRTܡiM.ԉϘF3\s)T#J6kp7B[q3k~TIv2<+ao_PK窰SnsF9Y)h~fDH%U4a{sRo>\in44ٙR+r>SW8/ʢfXe'$eqf\K~jeOq4F22$jؙ#>})4d2nZHa&eY\m_c(TҷRZ:Jb+? Se9zSmI$+_&W z.bvy$(g07S]ɖNޠվ_ZQƜZNml.ɳϦхk#9rII ٷpKrj'9-RvM\dI72cnGM59`ͷk[ΟзN4]J$ab$8=_+5N>pxU<jz%d:\ʢq.kr3iVi]Q?*rX)5t乚KTsדՐJn3 Uqg׵gjnLc-H%VX:K ʕIa7 d՚=̠n0O?kNu#{i:9afQm19KRc_Iū?=DuU9 08eې8-ԙTN-;!Ingo':WU}sSj zGiiR2D]_dnFžf[088#b:R[>`&8aV"7q߭m/7Jqdcnv$pO|Ҝ_nZK:w6.]3|ԟ]8Y bH)Hvҟ2]/m'NvjŤxFY]N)$z rIh]8)o*khhQGR|)Es c<ţ\d =O=޺hS5R3ZZ- y3(ڭԌiMi%5nd9dxl;UYN2=3׷J)WH4cneyi>|?.{rGjikЊ5#Mr[:"6ẉ=p֭=->{Nk6pm\31$9F+O:R42ȷ _XaLt9Zn9av]-$3cht ySlCS擩|btنU7KÚ.̖-T[4#C PB$`sgKRԕ7my-O˵_q:A/i5e8jI;$[v ܌zoucAEu74*T*:=@8$3G--8Ԕ\V= }U[5ɑߩ5ֶ:rI0\$p.Kn_˘r>1YGOujZ_#Qx^cZ7v-{p$,'չG.ލ֝2App篿4+]>KO;FV$/ҵohrFro56ePV*\w]*jn]߶t/5KdUWD+"I!}H??{^G;/2rbzJ||%F5!dQl[d8#'$~'}0jq@ -\K,V= 8sc[nAƔ4oJ6W3O؛'ϑooVB1 '?0\L,HFIs=J}; ,N>^Foֹ w9[L#o۶Ƹ%{lgM{9;| z* s;Mq1Xˮ3냟|,G J2Q+巬?^+8rݣNYKHʷ&C nwzRn Nu=^^YKct\gұm3[*J$vD$l$mj9G#fΥ;ۨVRcn7H"V;P4{=uڏ77D,4χa4_2Μc)r䓘k$*Yqw:q_2cw}m}}Ib4RA*猥c5hy wl#dU3֦nڔxHJӈbܿ)"Z0-S溈:)$WFGܸ8O4bQ/DA$V':+NUN)^穀jb*OV] Էۙ_¥ΤmfK_Rw[w%{REJ0vse63*q׮H-kng){k-]I ʮJぃ\U=kUQ۞uM?iMQ!Xql1/6H9l\vⷧ_U wG_9 Ӟ}w#DwqIV8I8$B甩ʣDF/D"}d1튻KH\қ_9Fyգk+'w+{kg)|5iQ^볱^]J<2Fʰv#s[Gkwثw+ek3;r ҟ,Spj,$pܓ_ڤoU;ys1 x+֪2vVYFTx-6]ʭ+u^,4iWϩiV L8*0}/g K^gniS|Rͱ0(a+OgST&WD}2@jʭ7R:~'bV,$THѶ8ŵkZl-Iw6ٰۀ=zg5WKD9e quZ$6yZְ>l9J<[zp~,{c>dj'ʓ0N4ɑHnW_ڱe9-qnvH3 P?G+{Ynwb 0>ɭ') *{:wVֈG#H&f`98ƻ9nK*=d As.6:{Ti{KTJ*lVdP1MĎy^:WL} i.gd̥{ FY5>acCgַnk^O2ZHmdnuub{KҚKO@,x#b/Nu#H=WB){WRS-}8,cnIgҦM/b#R+k\i*;G&Y \yMٸѨz~/5,|+͢yK7䁒NFOT¤sSFqKƫm8<|jjVQ.[dx;`{T1U^.|Z P0] Hhִ4WQsY%g[Pxr =gu?~W܎M0+[{`vuI$z(Y)h[dNvXI18Jڕnw 8e߂1֞ZlDDiDɕ5 zT%'f)J+/Y]\1f\)aЌT>ҥe)7vQH۲q.HO\UB{-9GԎ(YfUrW=}O 覽g*!2o|,A:(j]nZyK/ (8-o}lDw38`_2 eIl$ⶇ/McǙ+#[P27(vv8~r^R舕<&ےV)Rtoy[3Hkry⎖NEpܘ޽}K=}ƋB^L {$ʄn1Ϸ_=1{HӡkA>$xIM@9-E9i/ΜڤI M74xU01j(I$9YrI;xNYiSTuw3fݼCC "ȸvz/sҹTu#;T}F.3Hc f^~c'ʭUh J\E~#e@-sYJ7snU59[Iryɕ+֢R3(ߏYfIѩӸ8] `m{ ]ѱVCO< T{hokJ5֬f&hV ݰ?zQ2P*\.qa ꬉ=~rmBGְQrW!#[ ?1UU9){NK"k{>Z:Vfʌ'q愹N%wm#3(q*^0kSv1SF>%F}wק1 |#HmuX4DUF\nK A4M`ҡǧ)NƑq([30P ~^vu*5܇ʽBGx&g{E([Wn;w'SWVDytOP ˹.7tbis!kǽA_\~UvӉ8ƴ~UD?QN|QwӪ]Fg;22cWE:Wβ敯9T@)_U`z]2XyF֟%UYx >oF ɥSXmL|8P(ѫ/}Hأy/A1SЈ][7%#U|*PzJoq喧_-K%]3Ib#手dN~e}u5hC =Wj"vhFW)y%|͎s=OܴnɧN2`iVgoGfG[e+MvECZ8W{vi-b.W*;G,cr1zVpj<%ݻ y9ge.Y_ƹ*ط3h~^[,I\5*~MJѤ}xJ%R0jUUXdE-nBQ⨥̥?gFThb- \/;U%vUf/Нz^.O'JqXHms~pc%Fi->-Y?2B]nOa(4Ks,;y;_X$ǘcd*}pY*t_&B=a2ILUenҺYK9jJz0<+v76o-g鎕)IIb˖T/\I'f, NOQzZ2y*6 _=7AY_yGojO2y1ψnXGԏ ?wU:aJөj|cTOǥgfc/gY/2Ui`8tJpHTR4jkvKh򛦂xG!T/;ǮAS۲ISkťe˽S;hz˪VLkIεhC<*o"$mkiJ{Ovw#HD7cU%( R_Mʥ(Rr=CqN1TOIKѯ23#/ʹ ڹN3LD\az.Iቝ)e~˚iI?BZ̺ep*+Md ݽ"1ZVKFe§ F8ާRcBFҭnō~_^J娤"4eK߼g4O YI@\c*2qvZgɇMUOTJJܪ{c8ttV".WemKVPG16=Hd.nYYS7աzcRRVʝk2vYdG/=9CQRSKFehggJ1S{* m3;ax9]jwhR˦Q@[ DJ>^EkN GClԶ#ǹوXnsZYYro#BXIn77jN):+xC-,z15HTe$l .^?rW'9󫏽32)KI$*T7,I$r'QScO?j5Ъv s'*^өSKݨ*iSG{SmQI:K[vmByk.[g 3\9=h33)b:n뎠 #BSC Ҩ~ݸ,ˌdqMM}IKV;>uV\-fO޴Q0JQvHbCov~c$bMX·U9W߻vk Y .+C]UV*exo\\6$Igی3̅|8"kTcvsu%vT-nF^cOLS,Qe]\ ݵ$^?:ſR1gO&*C+t ⼌Tz*Թ#ZI#H30SןZT}~"΢<|YVQ_E+$8s5?(,L`v3^w]ȭӍk@'-3C2ۖB nz`֏ޥ3Zu*ys A6Y Ƽe?Sԧz1[MefR2SvrRRVG%I: wŇy5_i'ky9ƚN6wW]=;HP T$I'ڶN6iN:z=ۛ|3qߧjQ|җ7pJt{+jM;{ yrH#Ys+ ,:uѝWi5Hh«$h_ǯ^0\Ko*1T+&ɕ\HzJWܼ=8='[>\g pp};skHSөO@-?-vvaʽHW/pb'^^G]ъa5N\/qs)Fl+ҡN3[ƌc-ԩ=o[s3nGtF<Ҳ0ܪsEȣ1mݷuFCHӏ-]QHHL>0/ z9MhiN1*OLyn6U}x<ڝY6%u 6w(eV\p{g͢-RݎM6>d^f|é[FRo{t8*Ԩ~Zv唗X4g8#׊ڔydy#E({5o,vҽ[3bhhJy,&Uc-} i=pXK6:)seaszF+teN1WZgFU-}zkfq:"<,kЧk+n<j̻irPOQRQ:=7SICz%p]ğ_`+>v2gʿ7?=GT5:%/]RTg8#;kH1Vhk#mەuNOֶPeNS]Exo&wcUJkj-95>qѩ53v&j[܍/.zw9RzhH4Znc9Aoq?.qZY?uTR;~>vב }w-=I߅jZH֜J|뱟Z^/-đz 郁I]=RRq,voo`;7 x'=?jTem5F}E+XGۈnzvJ)|)Qp4~nTn7yryc9nsӑRM<%$[\.ͼ(tm]gbs=yNU=j!K bL+#( gr=}k /+]#.oeG1@?g}OBE^mWE@RFу>KN.?uڋ++1 Bz5h(hlRyZ:6SI(mvܪJ0\F=JڦQbrA < 줔%K$+%%7`m^~ZR.:_}#6cA#1P~@m.gʋRN$7snߠ8K)Jڦ|[$Cmzz"5%nzNy`Q YZqe&5e#۠>1SfԲ E-G8A{kRq㌽x;[kX?k}33ˍY xZ] Uh}5&{^LsYGc*9eRJ5w0ui$V[rqzg9t7rOMRFflogGOoƱTKƊI'ȶq=+$1ȳ4~E;vaI=~cLթIhvؙcXA H׽cˢ0Mrt,lt?_~ay{FNWeųtAIP߻$s ?/iSOj~YoJSɣF\pc10Dd53mw{>NRReaefxҦQ%\.k50-[1frҭYuHt``Z݊bfF>9RzSܶ^]*rW"Vyd7.1=IQ ;:Xx*qzv%<˹Ts>ԥ$eImiX`H(@FsUg*)Y էy sULH܁߯gReS5..by5HX/#\$91ԧRVcE)ecjqTu>el,#eF\sϯ=]:rgޗv,Rd]BяVN/2߁gmq]ѧޱ4qQv}@wXLCFm z~t-eF_ qs$b82wu<zNohR-DO;ЂA߭rԌc'tsγYy!d̻汿4oHCjeVX[qY)Y7[+Q61ْLÕfQ;;e-B"# 瑌WD/=P}̨yW;~cFҶPբ}LhiT,,C!DyzJ6V*a)%<ݙ8kh|A$Ec`UGFZt}3z˸{zktU:tћ{Ǝ&>c?ZǚSVhًhV]EgnqT.dsJ\fp2)j:;?}$ɥA }lyvzg'U$MN# c}CH薠䍣gǕQr4W*,lP1-g<}oӱSJ6]ݬrPr{mʟ'Wk<a=;}kzj5&gN:4ePuiK|$9 ; tۧsniu< ӛo)H*nàTY ƥ5h.j]8==}sZG7sYQ©neIٙ-$OrIXZOoס=$4+1?g*~-G~EVHۓ}U[|~w5ͺʕuMr5<ĻH"sd8pZ3G=zCu9iaIK<sZ5?wAɮZ]IED2ۤfׁ>W<҂.; !tCێB <g I/{VXm(e ƞzҲG+f'?βR cͭF4?.UxqYJciJN> ȬVݎ9g*.O@({؜^6I݆,Br/oO%ȕwoe9ld9a}Ԓ(.fʷvfcZrW:#in3ėo*ҝ߻G8'>xXmN?ĺfv,rwr9TKCZIu<ėvbYNlasy}CKEENTZxXVe%{cscNT[N 1<s"CK0o$M5Vo'8oҽ(^d5)\łWdMDa(|zZK2Vniɱʤ]V(c _Zqre#i'S.7a}SA*rSz~^LtqܦEf_ƼQ=9))A~Gfq4=k;i 7nk\y69MJ|vZI#POk=OcFtZRİ@"IqԍEW}yԗ΂PE[wS\{FB\=]MTK"9_-={z1)RΕ5ogн ,4zfEFIl67 0P>.N[-cKs`y1]u!SJ_=Zn8tAky c/, j=ӾĬts$Ue۶6cQZb{XNlޫLVqa47|'q^H}Y:G[tͽ">eߌ |ά[8WU9}͝ߞf-&9GNصsNYT^:{Wlg:prf!SU,2q9Y;H=t <֎|ژ- 'q\3JX&}} s{SGs-G$LORVw3t;.k,1\)rGGBhA/& =ZS-^tt+̹O"V c޺#zf莮}'Ѐ^ZꦦٵisHͽ3d3.zh۹iʤwXf//+_5/v mIU7.{ ~N?JƥDk2+7C/pI9# EY:Qk}\ym2}qtʛM+RUNX<Ɖ_F_g>ZYIwFz_ny.|ƐydlqcڪksGJ:i])`-Z=q̷pyYGeJӞԮoKO-e\Ϸ<RRUߛegmUIwOQ5#mΊ4\IsWf&{-q0$gQU8ʋSYiJ8m;ѿu,^VmܜIY\Vbwo |$Iu $3I Bg`7<pvyڤccYjxDռ1i3F8FIw2w[?-8+iaiѕsOѧ7s<I}sA(pʤjio3zI yYQ8FjyNzs⳧MFƝh6ھ/ǚKCܹ35i%^ځlxv1_9e[m=|_>{>Yl֚_s>|F'SV de3x>/eiJ߯Sl<#[M?:tG}lIk9R^ѶnXO GRcsJ.KO}U6>XbIZRwZDm ѹPW=IJ̏BrfH q0=7+f[傋{¶ϵ;PX$d? YJVL7WPyq9r1&QB GY۹nF|Ƌ{CqkUs<.=4R-y}j\˯rǔlH뒥Nl1ִYYffG6튪Ǡ9?֎ekJ/LX(U3G2YdڼmjxԊahcÞ `..'Oq:`%oaS-oU͚'mvWjQ)hh|E$b92zjG˕mͻFv6Nҳ)F\,,dUuߊqRrَIGfM$ʰ9m>TĩLʪbp?Z^oX|c]n@F~\s8ӔL5[VՙKN|rD}ش46,C|XrN<9SG,N˹#gmk-䑉#ONZ1VKf}_~jPĒ~Ca++o/3v3ӯpb)Nխ~AJ (659dFݻoVݎ DcR-OɍI\8{EM}{XZ2˵X s׎:Vp(W$V(ҍ$-tk١⦱vWmFfUVe.U9q\r:<|mjU^n̫Q]owV' G?޼/iQRyO9FSgO ^]xq$rne8\\dlF[N:;#W]֗+zZ3[2H?13#=Ӟp1޸%NwZ?iZcy)%ITVrqҦ>X: -=o9{O,]4jgtnTRXa/>"F.roVܻQ?ߝ$rtʜ=ny#4eʩ˧Ny>cqo)uSB\)c;ּxӍ6Θգ/P\qgC(Vp~2Ԯ VoQ52-f#99b:|S9^鵽y\[. $G\>c;S8>oѴkTa#$F|>#,ۣIơrQ@$S?}GMlz뮯luR-_OW4F2mFSuzmʼo$v{J^֢Vor>%մ:Tn$2rO`z_z'zq+L4j޷Lrg^B6.mW `c4}UrJ˖{b X9bog[Yݽ~GӴGHF..'zskϗS˭[[]k s+{rot4&MӋXufw%A8![gJJ.uyTͽ6./7kk~=#ٴ>,C{$klƠ+$xuYԂgweJi=v{_$?n-Pxq*rp a LVkEv}NF3ձ)Ʀ[G{u4O&E|=DLeV1S 81һ&tyzgF<m{Ӯ?Lwš嶽Djg]k[-69r6+<GR)sʳxii y~G6͈,eTyyc|qYbdowh.,LX 9!~k<Z2I;o W1$zԮvͽmf+g2VIn2ªnhkGUmVյk |AtQç8"^fk鯙FFG22Wa !/kQNǭ߶D:ϋHck+3)EG q\Q.hn}V_өEJ:7ӷ2ƺQ*ߺ9r3ykiQ9+}V8({8ʼG|;i%ޓjnlc@]'Sv}>nc*3.yvTѾ+mྐྵLdW(ˍ)Uemtv}n;w23ޕa4]fַVQiktI[}^!Cm`a`W;q*:wiwUѯ>qpZItWu<:\x?Q"F1j@J B'5^#V{x]\zF;]KY]:H$MᏓ-oy,MzFHg٣VQyrTqOSڦVʟP-)gA5$S`vD'qf٥elnG/Mo0ikI&XX$ 7!Gn&y~[SK6+ihnosz6k]u[i؉*1'cJm(jTfռc^'kNOAjTQpXW{ߋ~)VKvǕp]1׌\rӍϭps.٭bάN,cuP9B'9]\*5Ia5f NSvSֶܬӻr3ZK4-b3y;v Knm'r˚_#qy1;YX(IW;O:w1j)O/JZGM{;-$ &$mXCcvmF޷#'P%ߛЫe9Ҍe;P҅Kյg|3dKmB=qخ98r'cN.0^xNtu2e.U}˅` 0!:ㅌ]mwWM{ MVO>_ Α«d`t?/qGʶ{z媎#_KشmB,pN㹿>c+ cs%9y={AxG[ gXó*p=?*N.7S%JjWzskڇ%d,v2yq铣O=ܴuמ'մ,Is#*F~[ ztZs%oԽirQXk1њrѨWn-㵚}ϸkd kGWIإW׳1ν3Ԓ}=kSpGe*qIkm( qȪ$Zq=IcoJN1*G\bT+_Cbm1lڸ+ׂ9(֍I)QL<ѬhsjsRJ31ˑ0Z>}6:V۩j9& ^3ǯ8?cH+6*IٽHlDȚ9/_o>ԪU-b'cm%Ɗ-NBq*oÙ19hdO#ɅS ʒGuD#'}sE|$j֚g/|ɦQm)3Fr啭^+2&[~~~~U  c~c#k)TGIJ?g{:= b< ;cM VmJ>KVSjFۖI3$( +ԣ R+E=F4&FVtPSڦ1/ǚ QڅuhhcUbdӍHKEuᇩS~K^xoGjFH[GG׮BַcnZ9{?;~-?qS^u wHG!t_0ʛ>CFUeeoWGɀ$y $`pGҕ:2;۱كU#s4wN.rŇwS@r)@dLRٛ֯E[- ;~V_ڔFRF:|7V Q!m6BT68__a[FNQ c۔}9kДg%Zubp"C#$J߳mlzQSo_%ջb}8^g:=2ew&A6uL4݌NdnIDk33 UQFRN6va RM[,A~1$X*cFP٫VKh2%_Nb{AJ>[t*Ҋ۽e$Cŗ c7ZG,}hsշxvM7U%U\*qX!Z顗h]@烏UF3L{R+^ai6Ƨr`pFi~= 3%nbXO ;r֭kN:5U;3X (ש=SyjݑK|nQ6 _P0l涍8ԕgD{_v[[OrIZ ӳu|< rZ`_琴~K.A=rI2kF4ۨv10߻Vo}'AεeӭYԓ DN OE FzUOuJNu\*Ff^ V\NfL$Uz2HJ脪>Zu/wsO{{xW,<_¹:JkK*nt5,b\\bX6q_+I^TNysP_ܬm*^< sO<}X=e:5#sOFvPn2ˑYTTwV糍j[}ˎuUXWޝ:WHթR5ib2Fܮ`spp?![C[[ywv,ZF]J2*(;sSRVlrSM6;ddYv+F϶5pzֹ^2.а̓>_}y#K޴͹,|BUb[듑y4gR7VemVUOvҧS=K\r,&(9'qζN3XM^M#xGYQv}NiV]iVE$Z^y(F\˘TEgUX]H[t_B+~eyBۖcP5 LídΧNrČ awckr2\R)dT[XۈYԬx8?ZujJrI)GݽVd2FOj)QJ:Ìcf$cNG vBe7MiyYWle`n'9tk?gro~ޤWv!2;a#OkjjPXwRJԆ)M' Hۀ) ץmRS|DJ՚/-Wr`tǧ8]1J]LDPAU]ű \N2lwqK24 Nryiz}Ua50,ƨh;͸(ǒI񎵯,c.U֣ qzL#XV}ج rZ֟73\!<Wa$%xJklHnf4/<ɈqڬFսd}lX*tcč=e,U8=ǿ=릔aљ^I{H;?ӭieK9nlTA㰭(Fw9};>vrP߁\eL45YIs#ݺE?W,+Ny{S^E͞}Os#H,uoC$2(=Je;'**mlP%Kʓulr=A9GVj_KEGV|,O??gi5/m4IJm[l1~VRgQ;1M-m|oL-jrOMG1mvyj6U$9@ qU%+ISN*VPmx>=}@%ZJU+[-4Cq}fH'22JqȫpqQTԼchW̳,sgN}M״浯qD˕Ą6~mVozqwKuԮn$*6zw8淔c=ΈJZh ƽY㯷^45j9Tk$I?2]ѷʫUR~kNNTc-_vClGۍ?δQlQi|6Dy2RԪIi$sԕJu-m4h1x\YUWǚ[!ңp}HHiRc'^Q&t9ԩE$ {%ۈ㏣o$>:rQ}84*%"3F+Vъm$M(oNPԉqjI.vQr9a%*c9<ڰ.5;iԫwiH< #/CsǡSUhb[(|%wmn,cjQS?WAH29J5%ͩ~.c>iRy9]y+FΈ^z34+ mrKG7݁?ÏV2JQ+-~V\}9$y͂I>c)rG|O͙ó,@?7jcNqҲDF?>PDc߭/c)OBiч$7Bsm߻P;N7r~EqqwM0e-sN^*rRve{[ym #Fm'ةw42E} g3C]H` zrM8ԩJPQ;|ֻL4;d22px91m*a]S_OTU<+ n[:jQnɤh ;F8qDe$,U:j<՗$3H[I#RLp99jRqѮӧ-䯦V Jfsp}3OeTcKݗh@˄ F0yW?`F4~c`]com=XyVzsF%W Ƿmvhey[2 *7lߨ>+5,cVzGLf֕,JwpȢiNvq8rxyFW+$c奞7ɷQSߕi.XK\J:NKo;[et>e 2O=FyD9c[lɌiմb|ɢH yp'޲9KRJmfiw=F};:ҲM:r%ZXY6\$ j޽~W+~֫M=5A۹{wRKn F#{R9fw.6ZϙHs{9t+Cq (r!ݴ߱nH_Iz_x 09?.;fJQRQ-["ͤmYGf(>NF}år8C:NӲM['t&I#&8z5IE[DgQJC`dslR%qS8oQ'McSSZw'HbQ%ϭs{GϪ**"T+g#2QhC߿AWRRRB*TQQ^@ogp##2=zR<=,EJ#kjsy,> zg\jE+#j5~bcl) %v'֥DRMVt>7% (R0I)I#'m-SvvџooVgZZرc]FVi$n'N뎂ӛIƴNZ$q$S)+6-N>D\.:$-Z L Jo$tFS_}`9YTg'FPTia&c;^11]TyyRr9F2mBլ-y3.Z?$le*gb61?g1q4gq՞"Eܚ8TW5]zӏ,yS,QLaa+ w_bq=H8'4,/XvZVRǯ\8aRu!xcPEImѼ {ϽL-zir<-A> J*~0:wzeU{C-=Rl [lVe>G;oNr{ki>hyy:)#ۤڪ\=r궹ʌܞ`)0mv}ATt; 7kYuN"YPpsڡNNjҒRtVdk|O2s q<kJ%nGrPn.i׊nV}<͍̥rq}^.Z0ndv=/ ègRgyk׌.YRB&i89?MH:HR]1 hʫ8 q\j[N&b ݇veG$z֒ZF4gA)& #iv!r  =+Ԅ`Zt4WJԓVlLH9fXJ<1ƥIKGjmߘ$iǔdoݮ摡ګ@9+F{GR*wKWd_hbn}Tc~t?[,7OR[f"I 3mM3cjZ8xWZ;$kkMFsu>'/c.g:r vt)'k7 9'%G} 54H* 'j%B)&JY]c`3s}BJ0QYGFmh`y,p0z`$z4c(M}(S5(iRżP"?mZ\mt).*4j*r'J}x)/#^1=-lzu^0UdXJ#zCاg沥/ cbwn`G,>=sKFQGk\ض,|Z~jnθ#ԿTF{Es$І@J;3=x?w(ǚ:$r4W(YWv#ƪqܺԮMNGۯ# \V$h`x#`1V.ZJtܘ!*ш[aI}oAJQMÛϱ{Il1#V5<@vǮ)Ea7tי"vYj־f.2 5XԲIff2)?/g(gKսt6P?xt0ks&ΪPu#m7RMqͼG?ɌdgOϧt:*m6e[T~q uhf"96#Oٸr*vM H 1w?-:Vr(J-m*Ao%Ucg u1q 6*8u9ITq[lo74lȰcG=z`ѥRc)ŸCj!T)պw+Ќ\znRvM4-2l+X9l&w޶*rKb|y8g/xF.mTcKmO-ȱ pnWrVs/f-u3*}z^jc%b=hzIψ`_5ݙE.k\nQ<6DyT4]=h\+@?(=?Q* ˱f/3 ydkM_bK;nX3cGJQz~_2HaIcgYYs'sUro$AoIV_=D_WWӜ]cit9=s=+HKCNjnױ]H`EWry8S8Z1RmY6 * 9*vCZ<<3rmӪ|֞1MUYY2I,Dk g*Z 7h%E\g(t4)λpZ"߼j`Nz{M#k5};Q2! Nx#=*9=RϴP:ߛOOJU"^қuG.$Mלd׮9ˑ^&'&;yΓKq *~˱>zsow w(9=QҰ}H;Vi,r?U>iME*oN K^G͹7{ϯ_\)F2q[ub݇&*ȭ=?JeGmŞ`͖Ǚݳ}eqnD0^Enҕ(3;5)EvBWVӹa#+nY' ~'mZ樔6LGw]^ueSI#s󊦯RztҶ>.w|Iqn 4% =z,%҈xTކ 7'{[v2oaqIXx][$ dgaW+F*SnY8kIFYQGʺ9ki\pogeWP2p}H=+ms)NTؑ5]c;':Z_B9rԌ]0ME_4ylؤtuua{r{Q4Rf}8UU5rQ8Xn-u ~:X:Z>XfҪ=7r^՟fSs2ygjݵ-jV# krF:{Q,b'm-髾2d*䪷QJP[-i֬׌Q$ 0ہZQ4e*rr9ϗ~^@znTl,,ՙ]'YO>V-` '߃tc+CFxf{(3Bcrq+:֔oo빜QEyϋf-#̫6g'9:ROuuSA2+I̋"!iw >yPFr+Wx-%V0gbm)n5l.^+[ԦӔ4֪5HKNJRQ r]P:[FJ4c5J0^Օ+UG`͒GL(ߛ`'՝ihѱki5=M:X0/s\u*ס#&ޙ pFͰEIIi:biGhיcnTy>dhyk/qT.K|j5h9woG[.SkۧJ2fO*b+d$c)E9ib'Sk.4UT0!K`n#=;w:CۧT4SMk2:ᕕ}Eh)Y]%ܳ+%oLk,{^Uv0q_Iө'ugmzX:4Eem5ٷ8s˷2H#Qr _K.m_vQ}_4NO0V̍8<䃃5z%wL6PVJom-w:m&KmBH* xte]n.wq^9}5E s^ni3drH뚺~kcZxԤ}g]̒G==?oKOU q_ܫ{AxF#TnnFt?ʒr+"N8 q*eR|ʕo6E}yq4$7IV8$)=3޹o>jђfdȓ3H`+ cys)ZI鮝t5Y60dEc cr9Ԋ^5HSm$: kF).Yb/id;sOz8_CZc/'(:.dVU#36WrIGׯXvlދC(S4~g "XYYfzm6߅:2OO#ψ\i,4i7ʘr@x=l>i,>Yu*m:#kx?4USqIOUں(ңSV^]zڞ֊eͯ?e1DՔQ*}9Y1wbm}΢mYO'֯6TsRQuZ>u1\no³R低9R3Zyn̻P# >]IYVH_Cy1H-F_ɸ8zO֦NUdZR V0jVk{+_; )FA>S޹2c.Fg#%UROǟ,,5k9$f o.Dlay?2A)]F{7R2v^Kɿϛx洊[tnƄ8qABztKU>GF; QO^Uӯoɮ#ݏ8 Jr7L-[ |V[L*0'q{[ޟkw0y](S9=?fjԔ#Kf}Hz~-䱻)##=y,cEbI]]Y+_^ju쉧Yc?OƾwQQqѣ{I[vv%q{O}$rҼx*jjM}RSϾybPtXž^^aFJ6Q}|i+Vu*iwZQ#D>#*߇j\h{]Ϣxya{t6/xKkx|LNlxוXS/t߾oQ{ŸIyLȩ0f93Tqiu>_0VpliT?0Pׯ2H\JGz01湾:^m/D鼕 0$Һԧy=.4g;V%ǀtK,{#ݜ9tN*69%7.ȳx3N0}&͹8Sϧju'.k?c_m}u/ZGʡ}c I\d1S*3Wn֪ԧtion"0wM/[/=NY;'''w>;9-9oqnm 0*cbǢۿw5ԤiEn쯧vkoi7~Z{o޶k}894;A qȵljԅ;KNIxNyk]y|D6>pIO*.38CJ:qZּw|դs lFB7u|/5W>=ƻrNڜ9o'- dyzr]5()Y$e,-iJ5xW/vp,!o2GU#O+f (5%gJ'y|Βn!b7ڥze+[˄؄6j$wu_%"T|mx\7^+;zڝ,;[te*nG +ڍ:2%fPܓMuaxBkyd,u´cn3uS pe}[<`dzfó-g,TGA98>7e^wnl,0NNK{sQAī&]Aqg|:2QE}2R}?_->tk5˝>(hs|9݁ۡ{4E;n+_S(^cq?ZeofnC+!|F9 ͘ӕLTmUڧ3s+'z[{(=ΖKqo G+Wc( NY{R+{oku/+xyF"|;}ti;~q%rB@{9EZ50ծݓ[ S N^nߦ׷bɢy>X!UR2+_?S*Ҝ+-c*wmkok2Z&1ݯ1WSVSJ\'m>#[gcS*z5Eɴ9WAZF-:M1Q><ܼ˻:\g2Q/+%Bç^Ғa|~,2VEr)\g8>aq.+=-M+[yQ5?#Ml 1͸ ۇΤUY%G4=LO:Y=zm.}]}ɴW/Ww`Au#(Fjno+SI;$nox\ZZ\̲,r$61A'xf<|%<7*Yc5/4O$ H̬N#p努cF=S[ݢed5kاuNt\z/uGdZLhҮVY6Cq/8P$7GY˙5mwK )Ts{]w>wuN 5;-HCTqSw}\(wiq&3*1JWKgêh:w0PXQ$n;q&wcq\Ec*UӱKbnUJ imz+ʧRR&T̞W? D"d월 UZ-nNjR"ZESo<1{7z0 F y~YRV\QKSʭGhߓ1;fNy9 ޼lfo_z<3>.:̱MxO22ۀ8l8yk{F}KGmm3>+kP$v`fpqG>溨˞2wVaǙͻIp;,=zgQrM{yf3VnuSE߉#On-|Oo;`eS7dzqSUDvinﮛ[q}YM4mc_~[MOdyߊSM +5GHe`I*C2H93UPi'VWkYelF3mk]~wg7X]aG޹eVym$3y#>1u=O3js·M?û \I0Okx <\bꘋAEnqӯF{=utxf#]\ׯ>N:5'R uG>:u|is~Z\*匆݆ 09+RN%~&#术g׉gp&yR60Uzt=sߎiSW116_n%a,}(ZN3rl#N1:wWTYa+8e{r8ވS⵹GЗ5EVƝ3܂ I$O>8|yfmάtљVjSkh[}۫yzkI{$޾K5+W-@~f~[Sr{ZRpW˹*:sI.v䍽 "V\ͻGDQ<[m H1ߞ=T9Uo9凅I6!LqdnYqnrs JvcWqk帀?nn9swrTS$RJױʋy0=8 *q\_2\#oՙV]6wڢ{u8#8'cLi&y6YcPIG|;uEk):Z=//g䴄뎠ןZ7toRXw$m + M$ɲifw3^}J_yKK#vyVe#ץrۖ-AR[]KVLM7~H`Fp?\)YIqʶ*UԲ.#W)P<Ϙdd RgB2_~ ;1fV=$q׎VcIKns֔FʲۀN\zzQ'NL`$*63@}fՖg% 1Uv.Z{%QT鰋824c*{9Le;v8ܒ+YF'HoDIOe*nkqɖbA돮O*'Ncf#V[h\ FێҵQQuf셹ko, m>湜7(4hSr|ɛ摸^}TZ1 8Xi&u9=Fӄs+y0V`^I>ݺЩOU$=ĒH]D|qqwŨZFt)Iޖ؆dY#3,> Nֺ#/y%/S斄1I9%Pmlpq[7k+kt:G4L>jmqKa\ Ao0Z6±!rz~tFV}<:BnnzѕE?tzdki)U x2\6.{Jڜ}v7 *. {[w]s؊TORк{Ċᷛu`<uS\иq`Ls]MOFSa4dżM,vFTyZ؛;pN~JRlgTؼ6w\҇;*QZB rs[zUk//^oby ),pA֟SswNrѱƲIcR؟L¶Ru&1kN/"$@V`-HvxJkB/mQKk,sG%cWR1lgV[y,Ea;99Tn(U ?y!1N?:uSVؙb嶩mǦOW.SZ 7,d*7hqV7 =7Zv;}AE;pxz\e(ӏ+jƥ²kuyfW?7.V)ӣ%s[O{I*CnT8A^?Q8y6f+xDLݵF{+?y߱URF^fh.w0duU $?mOUmL^D[ۙF:玾B?hn2Z&1j,ϰb2ON R.RZը%+|yw?#kmI8)|,,(ǹ 5'ZL(mN5+Hi= ۾<񎞵8ݙJ^1ihʌ"Xe㞼jsT+6[Gw+RQM8r۫eNwJ̻p;y#&h-Qd7{[R슗.ihGv pZ6$9U֦ϖRN1qeY_Rzrguw$[g/ƣf/lĎSȏ{C&B]qɥ?y(^jN*]Hry**2yB4"L(єd~+xVGd21ӊʬ~~Y?y0Vmq;`JJs^*8*gaXN:"1z>j};. Ȱ\O<[$ ?y. 1ttZEk+myH߻ vzs1lՌKzXc,0Fo0^{T$քмo+Lf `_rk~T[$#.?u:~=ZӧJ_X#V5-FH"PZC#qNx5-̽˖{"Y!6眂sf)u: UvMgϖÙ(2?-2[$9קzrE­Rb6ҒiX/@y9V,u~BSgd-<*IQuZd/j'  5K:O81$"cQ^ ^I'9;aˣLo]KQ*4[~\3g=Ui-srВO@[W>_89ٶ*pߡ1!9mnYwaz֟+΅E;y/t0RRsqpHu0yUm̪dnm\32Ulp{cp)r˘֝))igݛEVI{Ȥ>F:{=z_+b*#f$⦤ZMI-;&H&@H_r\ǹF7:ݣiV}nYQר4ͻtQ:w& n[f |:nc9rSI%cNt B4q*w84RRLuY"OhjureIG}d=ϔg9U_nU:2mZ7-USq +a3|AGORh1N[t/#e)2cfF$w}wkTpZ~eU,$X >{vҦV7(8otmwu"<1ɐߏ jwFЕ(tLLxcOgOA40|MyLfWiN~^hRno5ח}i"6Eۻ=O5R-6(ӧ+>>sS 1uOw,|`J9ʒs:WO+COgZW]@ {U[Q H^2I^+cNT|w/o?* 68,T'{T+hꔨӋK_N]ܶgiCʋ1'jSvũԕwԏQXA6?O]t=9b(uUE~q>ZFx?xxFp9iJq-{hWYf?28#CXkuV$ߗ5 yrn3&9y瞞4U%&BkkV5?!e'#PA+)QOH-؈m̭3h=\CgO}4k?43/" 0c)Ԋ|eY%muF3s;[ryW?r|ۂ8D`orʹ'i)s[8UF3=-߯)Keo1TI#y~Xc#y1XrɦrKG$2Hn2d$<կ,eNR2n*NÖB$F$#㏩X<,e)]_Fۗ+n?>Glw5^0иR S/V{g|mw'g+7.U}bJ\&yv--<sq\*mr˗o5`[y+n7;}* otp׌j{oQ$I!Lzzk {YiQK*%҃33>P[$0}ku,s<9=$#3qר?ܫoȊYSW~_ e9xΣME"l,0wݎI\p1O9s-G)ӨdS2Tmg 9㡮Q/*FSi_r-TxՏ݅[ ں5%TQhIaDqm˂Psi5)F1+6}4we6ezלVteb%3Gd8# F;tF<;nRg֏vߗ$ ԎS]N)抷(Y&mW's]SZ9*މB$e 0\7rxE>ni[B#Ri- 2ʱ&'$chU-kM,A`K3AZf:u4AXR^B1Srzꉦ֦ӳe{xFP~8* U <&W;֕9A_ߩFicAn[Z2{{V77k%(oѕfd +\BqwoMc485IIf]JUFM!)n8קSTCMn M#m¯3g'AFNGUl(.ݣf!7|+u:՟Nr>oq L|.quZ(ө#-#+̫>?ʣR褴OOSIm;v-a_ָe/Nz_Z},G*v3mP0>:|]'Y(jvb 7gЎzUs(+S BSz5dPv`OҊϖHIԍ`8ٕ.rOK&VU6Z?/ˇd#@Ad=R*K݄[vqU:6/NQZo~x14إ5vkB?&Aw)\g9#"Zë$K,2)mú1\OsGr8G0G(UMm߶8<<%8ߢ4tR5+5}>RѼqXU0 2NzgWJ>F9S]Wj+pd?»Ww8s*|eI(p?Z:k_N{h[G{rvۀ~c9hƚn&fY,c ܠ㿡iʹTrZİD%eUN=[S*:BF}F,#OW(ӕ^Ti*4VԶdw{$aICi iQ8CfXtqC|[89GXC_c:ҫJ\̞%JH3FG1Y:̜:1\ M9Nz=z~=I!H^H s lGZ&[_ 0zH>mʼ;]sϵ/SU+T,@۟aS)JQ厉t"%Y=onű~-ULTF;W+ R8jQ^^ Q]ˌV\*IlxynpHx?s֯o$T~ъ,/o,2nQv@;NqΟU=R W*#gEg}ʑ t~J 4\k_2Ku>K[x1\9bbI.N1b5ʻlrP0`1YӜgWa?sZK,$ӫJ&1ٌ ;sZ;~dݿDh@u9jFN;2{Kb֠:FB6Q$w힝 ԰FOhQD+t/A%܍rHJ:I7v:,z+Ƚfov#E9VbNr:{(^ϖަtc+/Ge>UHLAA8WO+)SYUleXҧFS:1;{4m S]Ќ՞%u[OԽceEl=Ĩ`T ɯJ>uF2k}慜>lw-3u+6g}?g?SNy$ qq=}umRcN$F ܿ:{IhεJQ̝v [2|W8Sc\sW^]7-HI8i$,rTuNU Yw4mU\o8`(=ZFΉAY]۱%ܻAv'Vӽ1^Z'uנarM l#?5Oĩ4jGqHE2rv$cҦ1I.E{$@w7~+Jqq%U}.A*N#b+nnVT^5My\vcrXڿxqxԩv.*(-:>/"-ewYAr?*ڑRVsb[I#([믖a܎6SR|ϥTхvos<j49"[}n,rGZHir@3ҹ9WOm'U t|RI`ϨK>S_϶Ip@h<ׯaާ?h rh4B 1]ݔ;Np:]~YN4kW߼Zy5(W}-RqS濦;h dbFa#ⶳ<,(JSm8%i#}˸ rAUB2V,eq& c^ilU싺 r&-HJ5 >}8ѕ+-_RΣ%4p..gv1{NXrӍǜӪsbnŽy'#^iՌ-wa[ڮEwh${ q]v=H啣wq W.#ty\}Fq0P啝a+s%)+/ާGKaȥnVYYI҉Qζ9۩BNiv:3i[^^t$wT< Js{7cE{pzWM:q+ԟgUͣ +~_G<q|(c'5iLՍbK;&Wq_2NsS[ӌi%;˖еO$mۗQ~ߝu*|5h[Lʛ$8RN{qzu{Q4am/ww<JJڔ2CᶹCήw7a8xn0$jyL)ӝ;-jho s?ʧF.`gO2&U1qY;~/uB叝L4Ji$_gx2> ~4ܹv_0w/An,ʪ\I6wS01甴j§SIiKmnc+6vN'yگݮzt( $ g9=}NV4ZWN#u2 ,'G?Df.k/ᗓSj7uͽjF~I1Te99Q8*f\֬ezY$7tuSgZ4D(J=1-U#{#2%xI{4bnqUF^ӯu2}i7U-zVy.ld *Jyj9)k)ƥ]L ]@n4G5řZJc:#W#/[w -y\v׃׮9TG=J\f!qgfnXֹw5d O*8U[ZtV̪Rb"H9y<`v\#ӏq{HE8Ԏ$,CvƸ㿵sNZ-Td՗bv7/ yAVr)n_%9;:c \u#io4m(bM$S?Ł>d֚<&]Y*Bv0܎y~I[Tw^c slsҶHt=jzkе$L߿·n9޴r9cBj=Nlθ4q5^C=[&y FFw:)TRJ+"iWGc<.>?kh(NDnIK Yyq6qrQvTr(ԕtg_j"6A =}F3J_msKMO|gdgjX6yݒ@5FUc~3*qGfوvYX(aϮy87yfG!y[YXЯA ^Nxԕ6SbB)hL+Gz~\ʊrES\%!udOֳZ%k?7-یJ7#JF Kycelzk{sƜI,%1)olszZF>Y@MsJlZRQ-R2}UU^sn?Zʧ?- 1j-gv2N4gڈ˞7}rE-n؜Z֬rۜ޸V橬u7NQq>"fP,D.3;VUU=ozܒcgs*`Oc~Ϋ^)oChӦڒHOEc*/Jj5%Rwהm3+T`}G~JSh*OK'E$FUbxpGnTΔo!TMFUM$fXᙲFzV2ZP_kINI$+O0zg<~V_7}mg,mls۰y\UcpShmzwbU}m 1 )µ87c*ѫɰ%1b<~׵s)V.f5"i9 $1ܭy6ڹ{Qڴ05H$S {c֥<5+sQݶ4vpQ^| ٗ)jifrW~敶,m*:sʜV*[w f y_^zzsF:&Ö$VmXkV:l8\s]R4%nKj pm sZozw4&ڽƹeSGo`/*f81sלrLvBx!wN? ǖ9LJfF"oR;6?t }cX݃a;KX:u)SzRu= CʒmڸF U_q2)~{_ck;G{d{/M?ztFm-vFʔbdjV2A m\nn';WTyIBOSϵJuÿsw2ap>l9+e*-jB鿑q-As}OkhP)FPS{ `eYI)\FiB;<{vsx>jCm/z{I vEnbd;vunz5)J&kPJ1> 9 9hN25gƒq|ڶcR,nɇbwt eRSg,uZ,шZICy[FǎF>RZX˕$FՄӉ ?x{ny8hU?nvZ0yh9g;=-$ʹ*6# XQ~F>$2UIKڤߌr9?Kѕ*~I$$U1&*Îqts!0I=p~{?{SnkȊeg4O[ؘ)9]6Flq9=fʢ/%md,'g>)Ӧ{:7,gܠLn^CSsJjۆ@ ==k:zڝ7>}WliͶTኯιРJ} 8pkuI;5cFxڤ{}ϚaJUH4X/-7&u+J\ i0~pO(u6,aI2ƣnU[GӷҾF<Ｚ-ʴw.闳^Lʬ%|0{AaiŒ"o3y`Sn'Ch.Wvܟyӑl"coAT^DЙ$hp|)x&kT,ZjVӾ֧YēeU [ͷʏ\h$3UNGt}_7 [# ~Sk=֮9Jg;FWavĒyuXVaԒ_ӣLlz 1Ϩ5.T'zz<~sҷTԚԘhor6Yd>[+|Em(ni ~"ח,n ʧbS{E>hkK<X~eSw>sdvnS"$8}ri3zQ*|2*/cҾ%ZC,cȿ6 O~WlQ2ɂ7m!H'T]v56׾w`C0$Xh.Nä_5&K{wrrNGbqQϯuhFH-^S?> rƢᤴ2^F*ڹӞ{:c0n6-ke(N6V[=QWz0X&yR"mrB]v5O;ݽ^׶ok,U5Kދq}v~jγo3"ɻi\^f"3G."UQiZ뽌_?gbHڙxeQSI>+S x?uF4^cLDi2J_kkzޝuOU7*țB8,.WNCZHדu(4E'l0\XƦ"啺VtkFt{ft5U$)|f=-Qti:\`VzIn-{~mI-pln IWʬmz$y*|ocu{_'&7*awn[C[f*]6+n CWU/mJ /hڗV}?coVf1lvkvIB37 ݆P{0,D9_v1%U8=Ro{o}g{hrT >x9+P|oi1ꏣm].}ρۓ}:߹PIsNzU^>Gn:-[NqYr=0qG݌ۺWx*nN7|$o+8tvA'(T?wOUa_Z.;WKr$wVdWdr"NA:s\ wlދ6{;ӫGe!>ՒDxVdm!'0zWvQ_M}31O{EIK6I|n^QB4m?STp.w-k+i~~7+ךVd"Im6bӻKW_O}a[v>um ͽuC56a`v2֩O ^|ޖͽۧ)'oM|G]Vn-EmpM5ǖ %r zQxy-gӍ\DՒvW=tw+l-4YEX68`z֩R3r[}J5聯G߱}Bn!UWR01 :3ӭzFqo]ˣ)S:j놅{,I 2F!Hx;q8Ks_1*ѷ~kʵNOuoo+Jj%#r~lz{_%O妾pks^SF^y{Wi}~>2*U#"GTQ8eNTii][,V ClUA[cF$UTYElwzz%]Sa^g}aFmir z?VvqO5Tޗ57. ,lqy ~E$j俧׹%=ݴ[ǡ9] aKIh=wwyd?]m*77`2qXxjڕnÈqU#^VkKuӿ]cu%M{>[#+-=kkSUoՀgj7Wi/v ||'oZlA$ckWF\@0P=F&;&k=޿6t縉G<<]oInW|bZԖSg~?t]Djuo3sg+t6sM>NTzz8q[+tn۳m^,M̪IF{ =XG'ב#aQUX'O<QFaJU>OoxKut1ۘ/ rs . u9yWC<+j/;mݕg9ES{"JXjN'[[jlVln?.r*N>ojV&f}o}cGMZDxW'$Q>e^G={xRZ~O 'eOzŻhq퓃w` TRvۮl[ģH͂z+uZ#*5web:fH.RfS2z0OOn}lR[TefXyB{iD;Mn+F쑷Oʩ$-ӷ3O(JZۿ].£N-FX vrI2rzڽ \(u0ٍu]2|em IgYM嵌rC}A#G=~kV焹l%ޟݽ~^~g?9[y#'']\q¯F׎:}`d[|31:`gekC _jv]Z2Ȍb[qAݩjVg8ʘ~ZV]z'n©is|]L4v2:G*lFPuTUUcbuvhtTsQ2fN3^iƗ-jXE:q5{m[}$zdiCpۖÑz<=.ׯr*7|]}3>.SuYalAR\d`r?ǣ_-hkߒ16r%$շ^b^zuI47eSN\8*˻x5~]=Ӷ{_;km|ϪXXU8+.VoZ_Ӷ_6ݭ1ԁy*++~;C)O| ~XDcHwyyt>9q4p?wiEkMzs|Wb~FW4}K{{`wl=Xȷ=,.R>zG H1/ʲ0^I_ӵyQNSɫ(M]u:/>Eke$*u`qҭ[`==B|7] 4jg= #??Tp~k>#ŜZn߸e2:sUǙl=hӗ>e>Qݎ^GK;LJ1Uk[Yen[ڰ'7xs[So{W|^Zڋ8?k7k||דS{via)cr ǿuM2˻x`sts}-5)3ܖ:gI75>Ad-`}G3 ELm[?#oGz)|;[,wIOBƹjfVΦ[!>#A騛Ab"#G­J^ǗGӼI&;,q̪Fv|}8Zt)]%4B<:K5e$$cGf8QW:~E6R=Ld˝AZ}NsM]_iCȄx'⬲r1>veZn)N.LYTmK>V+fܲI8%~_^i}~⎥ Gv2suE%5u#3*uDѕK8YF[ZJ6=&wi!tw369zTQSI&޽kC ^]#[w<XNiңNWwFOHC n^K.N_i^]Z3kvZo_+k,sIsXyb+Ey\cGVOU-ĚkL ]9՝y)>`k@%+O=8^WO}<ϡ6"Jڧ]e=yS]Sݞl@"y6FN M ؈Xt,*a[R}݅e $}ⷜypSVKÍI S'jJ3z-~g*NrZ.ɞD,oQ<9Tv+ui\A\ fb:~5hulηqI-Y"*FÝ׎)Sq-M1$ywF>̑yߺ#6w+iь73wKw EJѧVϯDIknnnOqPH/Tek[Y zRPQ|WkY$xgi1zQƤl֩4TmJm-b+9Lc @ýr&pJeRT>D! g۳iy=hsЍo[d0 je:FG\dTIlU9Q;e+bFhi38xѽO{KRmgo#̖Xup;$d TW,e(ϧ(SUȒ8~!Q3>P?Z4{w6Q#"%jʁTS=GjTjTI3tei-5bpc][ ͕AҊҤM:='^D֚?* l%NxV*8;s+kbS \ª2sTPqԣT[NaI#t'KI;TiO9befYۘq^1rS:s[vfۭU_W~=Mr|1qéGzxKTr<1l~jtgM QISBZ%S>KA޸Vو^cBi5V\5Su#7N MnH3USMy|,4~pc\(ޱ98WU%vq_ygu ": TaH@<W<(jrʥ8RI.D?24"ia|~KX_YV.,[wRzWf*qZXUď:b?'>]:4WOm2MOq$Q:唈=GzִW55&(eɋ:FoN=ԏeK{u\0ݣnI2j]M)ԣӠ(m\Fd=8:] ֻ"X!\6\wǾ32ԇ2o}k0I(d(+\*aN)^f1_Ŀ]*yebR1 ̷1q 8<2:)CIVv߻Tn1^Vgj}sOTu!EUVƃnO87FВ\]"HqaI3)9ʷ??3Bo.6s}o˒NFz=+h1F8c.kM*50sQvI$Ffܧc~RqV6"8dlcqM9PbrRqze %&TiJM=:[#摣X*fI9ϱSV hKw:ghp Om+mo ׯJj{:RGWZ@Fp~s5"UI* NlfLweUN$slehNk{?z IXF_zIFQt [&|ѷ* O4Ձ.-w%wq&2r2Aq[S@I;WS["XcvQGTT$ԣWI %ȭs9xsB7SOihDYZM3o=6uE%>x-N5:oy% H'nxʟ7mLZ1=Q4i?^95J2?Mj!6f:p3g8JP+FU9z-$>pCb =?tsFۛQQzmW2Uh9G+u*R͛9|/(ݏSUKɫ~m7g+)){C]M+{cTeR<sҭF Tɶ2UUgx9JkF__|lY^9?ڈNwEJO趗1[n|$gMs]Sb22JW6LGLd8Tov>)Ain6ᙗsׯrGf)F}a|{'3HyOx\ܾfQ'+KԚiFأ?/#kk9JS[Ur2dIrv{h*x0LO;7lΜe>nR_%˓{ 혧'R6x$ڻJ`s\򼥩7q[nζumsߨg(&iU (K*1v Jj䔣[T8>r_V%KnGl }>9#<\nbqSR4a,K S#G?S\u#䊑ZD(fwIzX2"1榹~& ed{y%[o0̀~f`8Sgsg)^J:=99peϯִZ=R3m6mB`=zwY{fѼrER~uTev(I?̂h$.Dʤ01JR1ؽyfYm$#u;x}=isǗN菻EiWSy1*H~}0sʕ9jcNS+~maOn3 x#Yfgw"6I*ž}UUsөe+{!,!3b=lzsR僻՛}bQeK9q4xR9Vꤽt|եhՋ3G-|qAF3yⴌF%=Oiu,ϲQUq{E956F J;U'tBV'ۯQT("ZmVv ߛ#x?u9\ΜЉ_n̪H0r>U8:wLnjHch$}<.JRb+RbTB^ֺ\frIԋzĦ<#(>9AEHzƜb$m,.xֈ=ά-I7t}_4Zt Mh ?={p?*9cM]ɁL;glr9#(NeCH֍HZlf*cg zǏJ%NR{[Tbk+H vkRI,;xjӔHƥY-?SnNG F?Ġr=ڪ*'e ssVZ6edUr,9=ϭtƟ,{{NUhK= ;ukXS*2H̅W̅"}xKG.eR_S9sS3aBde?xlu<%&<smll$diR6qlŲy'qG$4u*ʚDe"WVF_!sǡ>y1, $0MSqu%6O%YT_?SDͣV-< ,nSg}+jFm($EUu¯P cn4̯($ۻrOBԣ]=?#6)*/9 t5M;mI8} ?6C%v>^ ci˿df>bx9j6#|?xwPZ3zfa'={sFSNs^6pml"ᣏ$u1g(^_qJTksZ킄 n0ӏ4*n*uNk9fA?=9hGlg9TN˖чN4m Y8g圗<ߑڶTyw˹G_ZpkRw-dT<$3`N?\W>Ux("Yd1 q.?{(^jpԩն- |3HA<1}5(5=Ss川QUBo`czR^6"8^}=jikEڋxQ޳=VH(Yێ# 1b:RO_3J+[Z盗~V}=:qU-)FƤWGvG/TeQВ+"Z;9  $cZݬck-ȵ[-UGyUמ{KdfVBByM,j3*nfsY~ƴb쵿QdYdH-e^:`` \?bԞH(CviM k3,kn#^;<N5"叵 s-/|O3\}XHxGЎm=AfU ua}nѯ@sY{nЩT6w8px򕌱n-j*oU߰rpy<OƲdy򒌹f+ʇ`۷/psxҍEc(#R[U"a哌cӗ3Z5+׌䖰,m"K^6֡jJԧZ2RMzOĞ^pp{ǥsOiSIʧ̝Xnc  V~qhtRtFȶ~o\ #׷҉v,]WHFǭaއ?Y.Nw}(.Z2jSofВjGpdh@~u[Kog*1C V3my$~Y#'3Ǯ1޲m{eZWR8 8Ț9HR{j]7s'*..\Y+7UweQJΚ>TiAmt{`Gϭe)N1u ţϙp*o'e)izGH.ee8]XCFch;ͯ"?XQJ̯uCs+ CUQ^Ṝj5Kbwb)wyܿ20Q[:=1Gvބ:g V ppqA}Z<ɻvFЧZ^?S>Fo-dptmg*u+.DbRi[HD/?:#=ӟۯg(4͏hXy3~EmGݍ)SK~ߠ_^ӏ&5/>,{O 9\+^FmNWnԥ*rk7̱'#TEj⪹7%mI",=0xߩs0IEpfA񭢥eiR{n9Qe pFAx Ti=TfyP;)]WR{;u[,y#~xFp? ~UJОZne't,6b3$1km;0+4Q5}{thƲ+$$r*ݐJxeV0\sU*J#UZ'`d( :EGRұc=lGvh``q8#i9\< b+KQI=bKeFAYAkTqܖKS){Py;FmqY]S*x* Hәգ ѥZve^ry{Ʒg$ﶴ'U!U ff$e/39TU/yw[mXrQNTeQǡN}̿AV HRyJCn^gtVHsrk8ܖ$dNuNG}q^@xUU8R:cׯֳJNuQ.Ykשk(Ⱥ2\7̹Fz)FQmt\EJZwٚL5t.N3?5TooC4cRq5!dKhE.g81OE۹5ybU ʸ-?P%%:cF;ߙyL\.UVW窆?/ wֱu9wۿc,Lj{/wȝIEfO0,e?0/O#gֻtΉ/xE ф/( W޽(viԩnʨ>V$ʺ5-cb4zn]qmmvs]SJ6f|շgn{ةTyszyDFsxQ+{6 _\*kIi[\7th~;۶9*9FZ}Ο4HI6L3^~tÖ~)HYy=}9˪*?‰$Cf GM9>|Ho16l}_>I: tGEǷ$iAw4lmbqDck4M:l)0Teׯ>2d\%kX%Fx`G$giEFQS}H&pXm)02;c҂N-͸ӗ+>m =8Dc)4|Gr12I4RH$FvO(6}MDG_ȑgɒ& ۾mN\ѣ.iF\YY!o5pY?r=k #*=הFv#v=Z\ֹetW) HZ\=yk769kCKt9w|98'!sIT%sEܥsre!U,X 5TTwϼu]wE]~loQ񪸩Y~3msl?;p>[9Bvd"LF6Uc78Q^=l4%QH\YK ^E\Uw54Glwmc H;<߁*v"VLq)|F~r4VϷoQsI:|d 6@p>nnG5sя3^m-wEܭ޽:qq},W+2o(&h[w\zhHGn ymuu0o`i s̕,2IҽxԌU%ne]Ǒ4|NzU*Z֟t*-Z]$elRn 1[—N:1d~e~#;jW S#ǨަtyrƔaR0^^H"捶Xax 鹾qVit8[kWۮ 21H99.hjQFűyIۏ#;N/SZG=k>is&TnwEy~q5%{.hǩzԓ۰zk+`N4\I.;Uv>2X*V.FI+n@f=GI\lȗ75Չ$܌SyE | HżpciWP<1ZJM6Cs 1269 rNQ2faN=:u5թ9N{nr i#\|۹<`w}IR2 ܱF3Q4N11V0"$l)fGk_nܣtTƉ$]sef74 %2nCycṪnO|Oڪ*Ҳة{YTWУy1!;xy*hhrwNG$@f[ 181Ǿ*bFW]L7.$[cGcNT{rȄ]~z'k;>cΩVU'΢BXUdL\(+H:9e6RHЭ-mfw'y`#,0yc1W?=¸ɭ֦-S4ݻmad_zW"JZ.Ju7+Hlxⱟ5N3i[Rboǹ湽FݙO yy+79N=?:SV*Roܫ}VckI}+tAs3J gxWR+45WNn8&Cus~("cB^D6,$"2'xVj5s[%an$[̭"}ZJ1i4ЗO[LGw*hΦOu#;֧jKB;Beұc)gZ>Y̍[Q#Ip±t VKFI9un50ܤu9?(Μ{; TԯnJ>nF}߱)iRI?r2wgN0r9[7J̌EPoG]'':uhz}# v&x ±4cGQKߡ *O"dp.+\iWi[ 'My[6wqvs:氩uC SK⁚dao]e ߅]Jyo{N"2{) 6 pNqVl#[|;G b}ϸUSw],sFm[iU{ayM/ʾf`m9QҮm/SٮYN 9 nh_ |ޣc<ҕ:ucRt_[ \ܳ[ s=JK(fJE)UײD/ Ѿ2zW#8q){E$qK2-1ۊRbcBE$n%R$ pGmÂNt6SS s7jɄ Ypg;NxҟX*tfR%lMpr9 zu*ZޥX{/aRVkrp7y{6zdB:*56,r12wW0ָn׊NA"bFS`c55*lˡNJI8k_7࿓siu*GgT^yj,[L"^7n@=s\r[eR+I_fXn3y'-5)\cS#BܮWcba8)ѩ%%U,A Ik"% }=+9NQW][V%2̫T(~ki4U!4Xa6rۥc{qթVfhZpLn`Oy wڳv:z>SrA lbr88oǷ{Trnᎏ+S $f|fEU =EmRNQIl)T&4&'md.]%*U)B/t<!VwK,\y?";lHd ?9}9UMyZE]D몾DZaێ/ N:ꊒ3oP**0>SwVס88ٻhBڏcq3JIy9?c/cnh-Nʚ`Vxro#kUHd] s zץaѺ{jc-:>3oKto{VM n~ES eGi߭C$гCaɸ7NJtwvO5w;= }a$,Jې= /cjo]Z2v0r;pOk!9{f%RCon>R~RhtR ܝ[d&Ai29W2~uP²1/g݊eB &nW{Oyvh߼w HcugiΊjǷcF6S2쳉=-ɥeܢ;;٢ޙ0-tW=ƝegˈiTU zVu"&Թ.G)5(ŵfR$| \cN>άj{isxVGR$jF5k~gAc#܉GJ+FS:M?mU=\іU#mKIvXaڹN2*0qF]K U\H }IIҍ8TJoii7m޽|=(I%ROӶ,{Yjunkp19;(R,vKP/<Zl Vm}kF?KFtwQGbцđ ; 9^ {zr%M;9%\8f($'j߯ѩk&U7hq xTZ2G'nXs]qtci+Y7O~.dZǞ;Zִ˦unԌ$O<ڔ hJI![vɒI=H'9laqUr^Y]izVzNןO? |7keG\mW~LJыW፟eXHm+62Fq vrscտR{_Ahǿyx%+u<Dyj.Wɇymo۰ޠ׏Oh˱:n,N}p ҼzKgEœE2==yQ9D0P.ߧxS .M7,YVf;\xe>"!@G'ߥiGGewЫs(oW洎)=;MH6.FV\F>ݎ4zn U[ Ƿ3gJdMu[+AuhT㣿r߅fn[q9=[*ϛ8VWO3Zݙ|S.Wߩ=H;i22T/;_œw7? A$(FO:FJ1V?/u/,/~ ojf#K~xʼn:`烕b;)=Ey_+JoD׿Vݾg4ŵյ]$]GQpy#:m-TnR2n;|fqUT#2i\1C^@~9g&r'4Ewyqr"iw⼫F׽Nmm hjlifl,VW8<'a^lFޝ|4r.O%=/H 96y3yձ\|tTg5,]o5 OnFQInI(vx֧{]]mO u^-IԭUO9@3#k]K9tt~0/H$txe)$bFѴv$5a`ۭ:51~IKT_׶Mj49Y,M$y=}iaJ7VgfoIU}̯\_xYmfB̀ɑn1XZ4i_sRS.,Ѽ2~a(?1sq~}>;|je{Iv?go0a_MB0[93]YBu }s-uZo'gyOTHdDMrC`Nܧ)4ӳy =>2;+eef2.Fl|+S~k>Mt5[:<7l뼮zg`F,o2j0V++KCAhm'ܬT:^ܫӣR}cӿfy υ|Kٞ{ۛ{Ūivbr2bp3s`ؘN*6MM<-l:qwkNo>6YF'w " Hϡ_;_:u"^hkʕ#ZVt3e}/X;|FӰw+pSЌB+:4\~>yZ_+vL$׃+ Pޛ[Loi'<{ص rHH$`81_AFntӧOShUV[t=O-Y;L1VXF$n^;RNSJ+Ԕi|E֟{#$WhiVʱAzq(^/w;l|bӻNo5Ե,VeyYV*:dn{ֱUH[MsqƊM'ݬfxSikGkH7!F;~Zto-{XYF+7w[j[^C$RL6ӓ 9b*.I[7$N?UiQE BrO;:_;ZjO[˹{IVn˹xiaf\I<O<~||rZ%mZFVӞ"[++nkͩZQ%iVR=«$n3 hڔkNع$1NUzʥ;5hSRS杉iq8_a^<Ѝ5vtpIm{!y@xcԢZ D\et=uK[褒,&Q #c#nYN͘#'MjTד魺<:m4kwg}5Zyiky<w7O/'I U2P~I=9;y#1\Qr^˻eߥω̪R.1Rke{YwRmpfYBccaʃ9pJ1vwv|ʐZUӭ~y4I$kzskTU*9~Ni(ڕK)5t}3WӡKT RR.Hly(a}wgw/zٛ7K+h0o1[XwcҦ8u&s, n[: U4/חRg`0؊Rw=*xyJTgn;|jI쿯롏O\ڔm2@':}+TkZ-?N&ut}طIӭ~u~h;؆3QWy2/-ʵKigx\FVn=:cyy4c*#ߨ{*{|џ~GO<˱*Hg'ڡ{_D9w=|6,EVV\mQIW%L1Pݼ"y{3[ZM)UR3檝Zm%T⹖+]jL}ze)ٜ5)Ӎ⑥&k%{տR1c~YF5}VZpv}IC| vzL07:OD\}.V'UzK M*$CI٩u:onfVUby;3^6eSVKpr}+ͷ}"ATMsّxn&HUX&HWx)YkFk;qm+cxyBk/_ʕHv{jz>.m\TnxX,'W*U1'X)TGJ|=OO\}MY&6p{sb(k~a){Vc⽽Oò]$ɍy8ǣ~RtԜuk3q)Ƌ]#[b5ɐ0ZTRHҴx[x˶Bn9k?_/C2 ]5n]B7gZsv?""EuMpx07`y??j;e{yMIHYY$cz5^rk*>_zbsO62HלzO'WTjG%T]NU:x{}=Une{}?egZRqEF]MehJڌҪ]ӕ9E,&b13ǗFIwܰ&aiڡTKjt䬆ėchyrvl,F+iY^Hǟ\ۧsl4].U:׈ =Yy=csP[7Ԧbؓ0_[F/,3?9nCchϕӕ連*/Ĵl|ü^Uˇ)NC4%ꋖ蓼Z&eۼq=UZ)SpGFw#x՟cK J Mb\O6Vc6!Nxm2x~QUnhػ\Ă/ s]*Wt]5E H"6#٢:vry7 BLˏ*[GX \ek~7)\0#ǧ5*Sbnrnr:{pTggԚ#Vn>f$yc*lxkGd;nf],|G6NOy\bsos&rNU(m"yk-_$&X Vϕw"1k@mmbq=ҫގsJg߸nmU7˵C:sD+t..rc-G/YYfh?=N=hdBBwh;eV2cVҌy^әrk.#O_}qߑHƤg-nf5ߴ펇NkF2Q:N-|8)&|GHJϓ9B/zu,iry)+rUw]݆ v1jqOЯngt Y2Uc?$:f=QGRׯf̻ۨѬTeKHazO*<㿦Emu(#HhVC |eٖvGBOS ݔZeaҌy٥-"Co6gl~4Ӕc7oiQeyct2-^@'Mt.iJ:T 21 1Z/¥8i~q2Cd)d,gNJڏKiRPP=4"`q 9kerM{HW!ɛv,lh~i-m~B3VYv}*\bhhlK,1J:y7+qקJ9Jv܍Gi`kHsy>x* W?IbV ҴH4S>H$?7瞵йatpN-"k}ǂs *%&\_}_z%4?.`z}~ EBOmGY\ FxTˣ+-J'wWLpx`_yR]LEGb^we\cwNTU[d!BXݏfgRbסL:[bL)\JQj(5&uPI$qn?|@-~k{%&wi"Y #Y$\,k=+XˣЊ4̶~"HEYU>FW2RpM7mu6uhơ[-'s+S4NjKS0yU wO )+Mt dn$ʍd*j#N6[w# j6@Y>U_"C.JWc5%;mHbHXޮq~)ljGSP|In-+`?`h)r|ƜI} z`*coҧ¤c̋z k֌$+ 78[ԧ(G{xxJn)j#_C[iY335o%F6z?\{qql׍jvFmXI$2:M'*t'{Ur'$Cs1q:E\6O,#U֭SQߩ,M?3~"nYZfuQsݲz¢T#oڹrm,b6k09eNU=|K4-}:VQqfZBvVJT &US%:`6_\ ˬ':㈶, E\Qi(mS=pȭ#AK>fIeUP~5M7.d/z1rLB#(s;vX>Z/i)^1W}yRJH=s}q[Z1۹JG4aъ_`O?QXFQ"2jj,3$w,PN9cIfXƜ|S~A;76*h8?ZݾZ!nQVߍ*{qM=ɹ>}+>_x+ݵk(JnpqVQVV"Qn[xU,ʹI!֜K{񍦭Yі飈Χ<.dp<H<-3w *T+T/tξ}]3b\u'Q^itfi0~]ǯpvR3_e /I,fu_;pq(5u۱Fps:j| >\)#zghw}W +8iy l_-qj~NQtSwɽ[qV 1&>Og5r]^BZuQ1zMrG-J2QfW*mQj[ :A\)jjmRZs441<0Y9 ʴe+J2wm}n][,F9eo}1QRJ;ʌB}p7gnG=?،<\mֺTK1;ұ7t;[h%k[R8K;cHBKqR4(JiY-ԹkdQ8R yem匬vຕ,ӨsjU9cwqB:Vچˆg_PTp8Ͽֲ)FI>9WRߪlw\~?4:NV!.dŒ9ݭAK;1mivŏַ'(ݍ#+I/*UHo!!18b.Ir_hr'JqVV.̂;Z2;``z~OeO NEH|ey̬тHml+׵Ljū:-NquTbǝY=\Nr7OS˚Y bN}6R*)ԭq,y=ѰRs 9N>5p{~(R:н;}o$ici–PjAQVW_;8PO.f*.llp^=e.[9?sJkWV;aFx=JTdsT[a1.Y m'$g9Q<Ԃ5B`B%f{ߟ̞\ԍN{7\}̦E`{c/~⬎iFb-ax62*}0xԌ}E -R+Ke[6HB%wd:{j£7NA[ʗo%ݼ ;pHO'ⵔcϔTj^* dYǚF}|q&%.UcXj kv@͍wSZ#kbqi-YfUs[͸ӍެiFܞ !|Kr89)xj^\v9*V~٩- xde h@gNI]NXkJuෛlxY& ayzJ+FYYy1OCy{r{xEӻ+rM"~id׿r _u?v[Zʁ uۻ_zQW9/fc sk.)Mƽ*g5f9TN0둎x(%i%$~VcyC<0kj{Ϩd o,k.1"#A91Mӕ5 VvnHY<1+nݸg?N+8RԽݔY-]ʓ0:z֞4✒_T)\%<.I]͖sƱmXR~d+;Y١"1d tQ~2Ν:~~?ብ*r/n+\:&tV^Mkas#\s&H*;3Wm:Jkc(ZSwZrBfV,QL㷶knoiR;UObbCM=lm[>^WGYE+/6ϚyW^k4=k]}VN͖uVQBۭt+F =U0+i]Y,=V2h%uZvw]EЭyr*rď\wXFr~}h&_V##kjpihuHh⺔ n4ɏnUA`NzV8Ժ*l]#ab:̪<%:uՐދ($hm39p*Rw85%ܯw$ww'E"=4O#]:QY=H5'D)6Va;`zc5#.dsdکx̊[<LB`T]^ϛXy0T ; kʄe2aSZ{*r|YΞ\r3}k&7+mhw}@=GQT))Zg_y~7eЫqoqpTr!m%}25NbWJJ ܮ-Xn"V&C}?+mκ.pi6w184J3XƤ2"a-́cS%9 ]w^gu8Ӎ%܎]ɳ"E) #ZtoE{3dNY6Vsv$_Ae8ٶ+WO_Ȧ$i!^vFx$6{sEiNmZmO .lBG~hԼtթ~vHFIȍ=\#ftS'R1ʷlSsϵo9"hS'[vkImL$o,ýnsӧO-E-(ƦI˖ow#E2HN[tr\#ΧNV_Bry\{1TNdjK«rqGR*GKޅ'"UvȠtc>Vu\Кx' egI3s\yrNj\$MJj q۾+j$Ќ}vDr-RKz~8בRQMEVù(;sY4q_ba~s2Ͳ$8F3ޝm5%N4$gͶRG:<>fx:SnEJ8I\͉#`ePyqcC],*5)aKSLۘbI8mdQNjɊZ:;TH//'Uf̩rR'>UBSnjz5U*Ӕy"+Ssڱ*qkʴlN˖9~I&3]Ќc OB<] {Wh7m\ kۧN ''sJuT;yv.[hqspv \@Oztˬ4mZۑ]ܬ-,Fֽ*vʍ8>ghiH[U`WNRo(O[PBŵYsI. דWuj6V#*DUP}ЮnwS6SrcBuHd m:=ǧ5d.cfKm,I{]qB2+8cIfp"D玄?^hѲֽֈ؂8>Xm8ҫn?wT4j-Iie%ft_kBų LԎ.yUW( =1SxI +@ (&¯}=ӔҜw#f"-x8$8);3'5VdIS LI铎?[MdpS*64R2*bJ πOs~ӱӱRX!}$sTkFGT*FT+K/SiU%ϙsYɩKƤZyĮ|瑷,S9Zu9Vp5~rn7~v֢OVLkd֒K˖c9-*XҹXJZ&"?xFd9O5,Wh{v=Z(ɵ۬ Fvj9^r\O0+'Ű bqԎRQ9i;$fܥkSCzSэ:vLcv@7gד]S]oGJϿldž^o+W[Oy+y2Cͻh*nj;^v"i>o}]wK&:?5=;LJ ^*K1oQ>i2־^T]:sRQ^*\/)31rJ+ͩmUv}D̆/ͻr ǃz֗SmHQyUi۱ԯ۩,}Bd+.?νre8|EKUMаE;g7nܲpG(::U.۟5݉$WGFz0dܬjێv2Oҽ81z4 M$a '1i$8}+zN\Ѵ]v3mwrsx&*r\>M]N@f[Kw<5EDc‘9%NjzV#Khݶ~ld?n먑,oKif a.]1ThҧviY^\hyQ9b45! - 2FqNQ6)^[̟}W9^=kOiʬ˧(>2#8A8>1rGjћur`|yz)qcuFcݱ\=QV1Zw23Ƕ0¼qFGT+^+ 1!mŘ.GoUoRտ'E/ ëHvT׶s#~U6*aw ђ :u9se)I^+SK"˷vqNx9Ur;(Xlڬdw\^UEv$pVYT 7瞇j*vks9ʜ}Ʒ+M+![IWNHϥLc*z>Yx- =}OJ34RXJF<?Xf:v0)5qQ&*iA4`cch̉2)~]};pj^ӛҰե$s";TaPev)\ޜcvZ:K~&m͜2yW6B؅9$/Ct63"c_f'xϒ_gFsђ&c_K3bC$%%l홷Hw ӠgRvn4t(ʬ [}Zk8^Iw~B=q1YFUks=8b%b徵xQoL2 89YN+4a)FMuUo-@e-ьҲR7*tc(٢?lbvߚ7CTR\[, nFc3GMH(QWJdlۇrOc)KH jJg>PykTPIɢNL7m'89IMp8Lg)NSic)/П̗Pax7[i6ίݣ R:s[c4xڰ*~Տ/6ᭊ1i gi`F;FI?ºc(Qrʤ$0+ "*C{CXUmSjҳRz. Fdm_HO^s5GOB{Ҍ!EGv_oDm:g<]kKOqɾTY|26=*UQECe'zfǯ|ܪ &OFLp=sGҹ+neZ撽~@j[hKޟ7aQƢ-GWJOip:r2.Y%I,͜d˻q'se-_N BЉ`fYF%{uU.=jլMV)yϰv>e9i\ᔥ sA~عAb "HF_F1ϸǿ~UޛQڷ7Z1m\'P+)ナB]˦ZZ Vmg =*9I$FyԼI Uvɳj%N1\W]1LV"->[/bhᅎ7 1 sgSQ压Jk}u M߽Dۻ,QiG<.x)X77J#8?^sG TF-wDΫɅd7g.97MKESOOQU*K;`ӾՊTd-SJ1s}KPE9AGHƥ8֩'rO&fea|̧-Nݽ*s(.]^`$#[Uf`tgStC 1N}nv8lm6+2Wqֿ|9T6?Tr2ih^viYUʹ>dUOt}uTIպ74Exʎ$2ь.(dpiko>xrglt?g˥xեnl[ٕm 2l;$Z6k(ؤx1\HY+3zp#i/BSR7CM3g?*Jv\}7bgE+BHw۶yHHsu ` fEtS:tKUsIӜi^[B*{]65*yeTU+,/--\HrYU<Hq{#9PN}B\6vͻ=?E89A)FP~C]hL#NN_sRZA9kVFiw9Oҽ,<}0ש]jӗ_>fT29E*T tZ>$fx]t&|iI*<LY6<'B>Ɯ[y˯_PԵ%-^s}yREv9]7VNڶq%t4%N~]yhƚ:cFI^=?Wq6Qt6FȲ~m`:ⱔyu[=:v .,\G#>g^$ݮ\WUR^lSVn.U)z-ֺM+<. F aa## s'<%wQ+^w!kgV}1o89R5{u3ѿ>_FNƪ6Fqt1u{1FȭC(Ϛ0r&UU/iIvWЫ+|I#Z]V3dH9< p52tQRWxYtH@ui ϩ3YÚ2+B )jިx)ǹn,aw|=O\/Z?c /g׷y4j0Z;* cw ,rKp]ɻU=8{WIEe~jO/OaXdXd"O2@PG9s=:~ؽӿkm}eM]{#mZZ8*CV/U)N 6 Yn-˸m- 7,sߥr£yetG*y[~ dhiTlut\$%pU<vu)Zmt+F6cZO"6X= [珥sK.¢{7$,wyo(>< մ9佤lzWrNwz޹9dz5d-|4{T3d~\C1]0e2nîߛ*eG~.^E5e]nQQ7d$nAZ#Eԡ{?hZW$gʏ6R8Ɲޡic#\0y9Ҵ;&3J5t]4\ĥ#7l%y9ұ| (=ŨF n%߻jH~5{Ǖ$㬣JaQ<|ZMEiסƝ4[#<3Չ=zsWD~ nٴ=̞y ΍ @''QJp!h8UmX1OOs&iOO[Fd> C .vlu#V7F{.qRI>tE~>ȿ-g$OE,#x3_EtkWZ?ƒFk$o;`V [CQZs1TK.7om#w6bq2BOsɨKE,Crcwv4*q~5y0_DԛZM;#7R8q(nԟN:(]YtﯝU|_}<~ \Yͨ -/FxR#jnM_N}0̨SIZ3o q ݷג Jf:uZ[|#Wԛ= SҬ*.8f@8禥ι6ҭZCooϠx!VK[|0Lh֙/42yq{\q ߮^Vw02ӥVQ[w{y߲=~8`]B>xߟ qʬۺpq|y띡arͷ'p;yҾBjψrfFvm:'֘wŮOsScq"ܾ˲u9k٧Rw:5-oشXXncV;c dc#(GA]j=} ֺ{i.XU~'l^ZԶ#:MpʑBYS*`ߺn3 kʩSRV/3FW|[識? &RIH<3̹ N>2J4ڍGS9SROd}!+9VXbKyL~`ݷ*X3r_+RZSKݾLRwDf'-3}8:k}*Wi~\tԧ-ɇ5>! !V,VBNWL R-n%D9e.[ʂ[!d[9-dmpoBI܏eJt8ݤbiNHkjVsF絯Z^!1V u[GNAԍO8O|6HalˍY(=kUjǒ|S#Vmlue]܀J)ԕ9>בGRUkmi/{MWlM)*W+C|.O -uu}̼>qA㐾"PEΓK[^Y~ZXPK/}7zjgYW;"00q=j|V:ZT,wMQX)O`}I{:ѧ};RYIոW DeQӹ)(@1[r=\jNށʑnJ6nQdOp:FR*w|ևY%4J)ݸ`u<=Ju\_ՌqQ֦RKf}S2Mן4ԍ zc 8]>5)O뷒W8fR~e $eJR6Y†kWjy|,~7SKG ;r\&C #L#RxqKmR[+;l4 O?霝%w q9[RJ_|y/[w=cg[xR I<5O:̻l198ǏNo~ޝV狛aӺM[]o+=F˺vYymOQq8Q{/#佄bNiwHaY/#hB@IcG ]]z#Z{aOP^y\do#,ɏqЎ_:qHJ7u{QkTj)wӷϩ"i10ۻpOS=L,Ny%oW3єbk%v˷šmOo'#~FWmi7-z]k;;YRbx|pHBb=D}z{ɽߛFm49癌HZ[v89>U'6ܻFQ~8j =dO/zbN,k /{oatxҭ_1<`ׂ:uR<7{[xTw #?Qz_Rn2xo)m)aFju9t9SĨFVrn~x iv%6<PQ Õ'ޕQ'(>d՛MV(T=yB=n',$Iz$.D wv01|Vu>'E$k_[#<]4R,k .ISrx =E5FIkN|8Gm+tr0Φ%JwvtZC4iHaӥ`:\jM{Xo ]EO'eK+q=#HB2w>GLqT^\ۊݵ/3zx\UiE%t߹&uIReY>Su:p-=wv*Vshikgrcj󣌣SoNgf VVz' IR|?[g -ͻJb?2;7 q^~*^]hx7촌tgI}|2ַi0@2&7 d91TSM|N:sOWum>gxm*[[ >y[t=l.ZMk/=jF$ (QfT~_G.i~]Zn~і B4}zvpkmSn$ &AmeWx +kF^J/{-g+;Wwo]9h*qNdٵt :=Jil⑼F$0t>cל6_֧)F+]g0}W_Æ7xѷNs택Zm{y~}#*ڮ~ϙ&WiFX\T(??Wsĉq}{Id6L?!_E5˫<4浗ݼ8+`+e{oNT\'s\񓃴QiHh 叙~s4Gdh4UY.'pۏ#zg]9}9F8F~Od[]?r̙y2X ~G":)(siY0ŰO#~(a#=:x|2l[hGsy?ȓ߯';嶬3K!?9UDr=2qF8h9y4C|+Jqp8xXG>mc&u_iu]i a03n^׷X+_^\\[#1~>s(iӌZ2OS^-R4~`1]/1{qwF5bwѣFvj5e /Q⪵8] Ov.ܩWWnI`3ӌ. 8ɨ?D0TEƻgny_9;R8Զ|&ҵmFU Ėhw|G<يH.noYZGU9'鎝sXJ ˩j}Bt%1TNRyS_̫{ml9=]TIIw6jM=z?JEi$lُ1ƾƟ~Tێ7Su}IbmۗuPH g911ҒˮԍS'Fjxj͛%wMO OL"궝6rJ*QSԴ uW>?9WEJkRi<-JڽC̴n2fMD4,۾U}~כq'gwj{ڳCB c[SiSn2gg0Io_ָ}{"-OvG-,aUcf[ =t>1VM3X*jQ'VWFm̠{ۿֺe*>ͶPiii#U}}3YFGOGw#{ixl`|̿1uգWHNƽlETm7V,n;̍ϚiԦ_hE4'xܣcF>5jxȨ$-nBk_zһnIoH}?g-nrP NI + LhNsNg:$9niwv\O-Y|'%h+FBy+O;"B$g׮sNOO_Τ-P+HuE Ur9'浔!;F/ՓF2꺯Q([(i:`(=NGeZq6h-iͼS Fa׎@~cdMS ;]ۭemlU8R^or=NY4v%/,8kɖEl1=ǽCjGQSVF <F_U~r~<[+e| ;GӯsJͬS~FRX9;^$?1>^pF{V.W+nRj&bEK[\FUlwұHs8KN_f[Tfuk%sϔ\Zk';wItn=zW]Ԏ9R4պwI [1?oΰ,mԩI7ΝzhUVa_0+Pzt?w7k]yNZV_;iI"q2wfss҂/,zJy*?3Y' e5FGL>+9SRvihSI6\$q[HE/f8jT7 U5Z44-d1Y4'#vFVru{.ƌKGwM/NR$` 9Bpz+rR'QJ <ƛ}GJкݵ5#}W)_n+.{TNHʏQ}бX\<~~[\Oܪb@̯,w?lY{sע0Z?aF}; #og6 (S5;f8'''CZSҺVGB"4s23m5qWD9TKThۼ*w*0n|m攐o'-D^A65rqH#<O65QkZvs#HzQ彊rvq$O.@W~$g5^?Tkd$ފl|68gjY)ywoP=yUozR}!kc#eK8QR0U2cdFnf g|9k)FJrG[%o HT0eOjGF#>BNjKݙ֌;$rIp~r?fʛ3-}Haw;݅^Z~g*y >feg(eS\5c\ܼgF_i 豌caް?p>-U輈&Qs0h9'w ï\8/xF[ D*HeIr|[:jϰfI\s2nGߵiU%& 7:FgiWAlקYJ2liA#V]9?AYLsVŢD9hs溢yCJ1o,1,(nqrvLu?w1)WrjdXN=֝?v57T\ڔ_7y99v'R7zs5.VHx['ޜbZSH츗 W++K=z^KO#z<_3:WH F%N?kr]Tiɤ۸B1$|v0xe.o*JuL4RF);$׷Мvz(Ɣdey{REeU}WUnՉQe̴KfZTU V9!RJWYdy"u~q$tMmNI-II$RKl9mT7~)J0ӡ5pƬoi'dpO>򽯹=\,F^OLWL/$kQ6iy̷]x#>o=Zvl#/eV;`RI^AQTu}گ fooaY̙t*S?u>lH$O#nMЊҗ*kVfd7 n+xA%%gc7[ˑ P|0GOBEje)зܖֶrUy^;JQR\FIb|03 8H=Z V_oi{u5iI5h[)$HW~b%CCoϻ`cdg~KcqrWvz֎4+2 IG=< rsȲQ nnYs}Nc+FZ&I Es <R*.XIod^Jr1k=VEc-^w(QR%.md,0K,^jip$%b/yV,0&̑A!n=k3;$ccw${ ⨣N7禇ԩ+tfmdorO#/g;+ʽH`?JI+[sXԌ`˶wGzK]?-HQONQĹ0fFO &Js612bWqv-F MZ[r|׏M,,!vf0ÌkMj uxfKa5*OOT*>T6-4zhF5pn3G~R9F0w{XX3I u8kr2z[y!02,;~F>oʦ_ 95$#d,[cifa~c?R%~cnݟFqk+19%9:e?9vO|j{73 n=h/W ~緯asY&œwԜy+J*l狫+Ḭs+n}dv^8$ҸgQTV3}껌i ە2xt"X-#]j^hlGzwsUEԻ[U%GpI K!kKdJάK[,sF66g#uٽƦ|͊%Ǥ|ȖqR,mny#^Q܎oU^V#n*H{S.^eT1N6EM**FR `;9B\ۛ*u!^y XN@< jy9&2hN++[[.2Wh{g氩+TP^#^MZ2(c r}F\} cR:o^믪F;|}kgRJ5H69&YYwb*sѶv+S'U*Q &x/,Uu)TRqf;vb;~l! [BZ#2s /'3ZkTׯ:ͯE}EK:]"{ [ J5:&&J#0 8m-֭2*yg{'ko> i-;jҭo89 sӎ"KE4裃"r=hh}8#R_/qUwY>igqpH0q:W>:t--d0upM]|ߡ<+lH# 7_Nڟ;ߧRQj~Њ8j\Χ64cS Kz4qXc+3>޷+j35[(%k|۾=s}zWT#G4Q$SF&XKnQ^~nFl)hpR:6tGŔEXR9n9RFѥTe1o=UWw˵NTztyfz[3Ȏ/FV5e)G1uߩB5$sm2rVѥTm T\mwt ˽UN6lN9`܃ZF' U:tz>F\Ci+yw03(vqQzBU7t$k9۵w37aßNXt:tkhC.Jf#< kHԳ[ѩ,=DԒөQLByv*:,JI3ҼITV[$Of_wqO}zVczĘʤ+sϯE-3'XV=K޾{nznTP쐕i)Jַb`CIR*; w5umϯ_%^J;^rv T9(z积9Y^HKڴD6ظIlYܾ_ہ0zs*e)S>UogN<*ΦˍU~E}xR*1GRR\+9CvJ>19QR/]3L2$n<{a_eԔΝirO?|h6̌+dgdgƸjG5kaJ5K!3\R:u2w)8J%V5ۏ9dk9IF<ҭRnZ6@5li]9*✤e`R6|]=f1ydmcw8\o*tY%'Р#2y+w ןQZ{ꌱttUO+㧭szcQ+n2L}UȘqOlO5}vc 7Yaݴ g5*բkQ|\? >qQFqʷR;DcN\9'HǧP*jJ)*JW/Z_ZDW~}Gc-L<=ZЇ,eey0[ރ.OcN:&7rI p6^ssֺ#.[&TӄZkZ6ͿyOSRRGU+TNM+F34*KۚϚ77bjSW""I/3`={giRwԧ:88]F㌫^ˎrRE'o.ȘKjV 4 3kNjMgR1r*+ɌIJU+5-nNPA2{[xUQso\:t%K1UhlTXS4ԍK)dZ@$hf ңIHX\N%RU+{8]G%ņ~n1'n{yT[{[jO˹{zk̯jQv6=m3336ש+?TZoۭFvn>yJ:na}b.-cg*r(U9>niі\=,#8onlՃ` KsJW$1[F_⑷p8gQR2e[QB mi3!aVMsִm'`榜%rEi &&(2$gG>ìnɜr%+}Dro^3ZVF1M{QIkm-̒[9&-wƜլsӌ+ĆR˱\s dv?ΰ~߻"kGm%TFwiDa+_RL*ªy٢!s0s6GndPzP7s:d+nb9gn?J%R1Y5zU |މO(T2[-d7Sk܅fY^WbF sTc%%nmD-=W9999s&cS6tc*x:_}:%dʞM+6~=kXJ oTd$v]arqɯ2;ŵe)h)EpWeF;g6qK䚲e$R< k37*;.Xe~:=/^y{^0fzvd_Y\w)d"B.F;^=\M۶*Znّ{^ڢJo5֚vؖM.BH2-c։amhW؊q qV#ne"Mr1u#O]Qt\Tm, r+mds?z8Ɲ}59%5ӿ[KHGWi\;^Q_DhT&M|ߌc+jSLKkgwN1j6fފu[yQ)?=U:~M]&<ꛊi5߹8ѕcQ6ƻ#8 ەJKgGPѿCuKfM|`d8ܧ<JP.,\yt%8Bqdiq.VRחk-Ȳoqr8CoԳkӏ_/#rŞ;Yϕ=z+Gk8ԧ9J2Zy62srzۺEi$)F^OhZ4MLI~)[aʛvM[{]'rxZRIGB%˴v%cR .%=*\=zXi :ٺɍ,Iֳ,=͕kyXfIٮw%HH'kw4me+ܳ>RgMrCNJ$h`1YM-Np4 /psB3ҧݲ=i%[HLvܽyy*e.UsTR j6~o+tF[go gI\&e9&VIk#܏z5/F'Rl7?N2RF3>{X/( w2@*))u7xٍHQjgVx.Q ڣkFr;Uͽmiu䞽R-4nκiADn[#`@aqQhөt.dV'W(M}@?ɩrnNHz2*9sV?>Y\!/L,$|36<\"DcCOj]+ Y;X򏠪yE{IrU%\,SƫqYnYSmۭ*~>zo֌e)Tg#Abx'bcx9-9wQ;^[FvFԵZsz^ TYs<ߚgRR]E(7e۹ ry(/%IsrN*52$'h JUKmQNu\xkFn&=4c#daa EFOVSW,*qQv5-wucKO"QvLcsFtxI:M8;Y]͋o$<ϙ&S3{kGeש"50x$YTRgOYc#Ol9 % {HǗAﮁt1<͟,0'=;Τc(m)_Ӱ\dUN Iݸpz}8g~M_Ktgr8oR#mC/R[t=ZoF] W!ND|)_~<+ZwzTdzs}`ya$rg=}zg9ܪ.wtkN#(嶉`IFf0NFs˽RS=78T9ju0l9ִHN/cU-Ɏai%kwgU*n\ռP4NP\~FڞVNeNz:2T%: e(.7b!B1Dz#[JU-UYt+8i#)QTkY̜$cMGp 崙ї>vwV)޼8ߒ=4ط dXRU{8={v]nZ):ܳu(@Nyg(ʤ[qsN*LVI$\,Rdgq&SҩSNR!V̛Ig8nkOϴc 7܎']͑&EM;rS}.S*kƤem}h֜iM`UWf=?,Q vqj8-䒂ُ>osE9h-ǖ#ߊU畮tԒ'rcffGiT|c50Cnb[I8Fz{7u}=Ⱦm$$x88ϽeF4rԬ(ԃW[]Veem0,3?^*m'u/r\_g.$icg_1W+{Jnj>]~^dC=Bjԓ]%+և*VOiTY8pqHʛ ?fW̙efK2:)*tNBYq*(Nr qg#&7WG发^Uƴ~UtZvC3gvQ?w (dsG t9*JG"Ă+fei,;Tֹ*V^{i5bK#)#6\g9z>j+K%;nnY[s*`۱g#zյMo8R*7o:BM"@6sq׌wJ4Spní Smu>sTz1M XƱEv?$Ӳ{[KYtGp m?*EX5faB@$;`{zұU#3NV9TSt;/۟]wvMOc˚S#*TVأs yfiDÁ3]̴)ӌ.GԒ=vgצI=NTMz)껛_nkvnm+Ƹ'_Px=Nȩ)DC}ZF&p̣zXZz,])as,8U'r;uNWRЈѩ-c F]*C]vA9z=̚%SnT${b^sEpzcfQdA7Kye*ruՔ'u_.9B*>*Џ*G_mk6>3[e7uߴw;zG׊+2qqRkC_N4fKn;ߨ^Ռ%e8zܚ>L>!,Y| q}H汩u%wlF5ْYf?x͝MpR[oœ-|[#4y~e [jFV*h7uEI~b:9x*fլoRjifyw=,ZoFjehIʔ^TfmcnӎS#Or~%["HWL l?JQvZ\r5v\i>b#m|$99.4e]vKxHc$}9M3ޜ{}m<;զ,C_]Lm:ǖ1zIoaoס?TTbXB\[Rzm*INq/Q+|V1/"hXO*YG+dǯ"5ӣ2rw+I} ݴsR#/jQOR&f+2<;[w[Ǿhh吲&TS*e.k2*?kxuѣe.4y'j*?˭y}L#e'w6q*"%S#E1 ޅG^V+]=?p][}88 w֮Q7{Lg0W~=$ݖf?ŷ5b^V8c~.g\*0}6GO\USZon#ud#ԮZIp&᲼7"n:﹗'m/ۡNe2m_-Tu*Z,s,F)P u%kMԦSQi*ѕ`t!N2ש^)&GUFuvmڍ} CWQ+Q7sޕJ3rs:1VSV C"es\MKrS;,q:ۍqJ8ߝktc 4w+>ƃ|Σ2kV6ɠx?tWՍ#Z8OcSF\ɻ{scg^vRIic_kW՜ʧ 5=X/{)5 ћn].lYKf̞qc'־ *Q{˛%M+ ><1y&o/w9p:p4rWmgɮJ9bm/owk;]@:4rLЈJLgjșBQJ͌ 4Xe]yk)B|vmCϨR,ʧgk qdfQ'}M#̝#s"aUHՕ]'PX{1\ԣ.f؎K۵>`ϰ|apqk7 r9gRe Yg?Z5s-o%%[ +FҼLtkG%[J3qii/6 *͞xy)J4i$<ǟ^Q,k6Yd.9zzJM%gR}E|WV"Yɯz85F=}֋Cݧ{Ƶ㶞>#>k[5}wg;nz}ezF3ȯMtGUQ'u:{ ;^6wVQG][4R̿xIh%YYBWI74iѬ?fz{>otG~ tCVm=9yUK3^xGRoc[0Tr01鏢4ǒqgW> Px{WMMZ&F`Ԣo+eq#z*Ԧ^;n*:掗{6Ar0uϯnM9GJSj]KWYoc!+ gw˝ۉ uv妴n,i.bkO9J$`Bn sӏz9fEZmȿu 3f^1מNIgF[Wޛwrŵy.sWNU!Nmeb*Ss_ 7#Be a: ;lkZOcI(TvM1\17 V@ )}_6/i\r#UW )Vfzfb"XZ/m xR%،[,&_Mjֆ3I<,2ʴf^"iYSc=NG9sK +4kNO5r@'u<^]maR|ȑB`Y$r?+7\wX^k'G,ȐxdFwnssI~k_VĤv .]~+EfߧRnKFoس>pʺ#e=R_~7 \%d*tVEs0xUngn:z֑(]NoKG}>ft` \wU1RA/KĒysTg]4=aV!qצk]ЍIJI~G?gȚ7cnH9<&*j3>+͡Snkh_39q}OAgk'WZ+&3룊j]{{lyt̞Zy'%A܃W.W{qWB8Oo}$q;NǒUyϖ>xk j w"FVE,&>~?֥Rn:J}չ[]8F^SSO1kq6eQq]JQr_Wޫj^>k:wSCq>ȶIjHr/xjJZQ;n^<߬R-2O{ogcu_|ũH"T^{1OYrn,*Q|ѿM:2mQc&moE=@e'p}kЫStehg+`ܣNeto&gxPg(>aʍms0~\`q+7'켼90zzkmpgR֖|`ԩ8ѣ-;7oGHMw %7#8|בW9Z4GiSE}ס^V d#O1! 鎜l Y]ٻvfӵ^>ԍO4\ ʡ;^~*'QY5z춝)8h- 5wLс  %sێxpڲZ5riJ-]GM)6]Nxc#ҽ|5*NEOOGYԩQ[^{-xω~r]:͵5pq,[{F Ql5#]6D<#i r ӹ`u*|r}5߷}UїmsJT)KY_sqLEU:黧2{GJ}? ϩ32).yY09?vֿ;FKC:kZ}'in'=;OYC &k{ m<)l*rGSOec7w7Vsyg4WKQJTy\{7\I]ɴ}ׯ~.#2{]-B#ğjp(//~n s,_zaw yUN&i k/ݻZr[h!j,koUƭW]^ư9`ԭBȒXwҾ's9h],{lh߳椖e%7S" Xrc*Qԕd=l_|\E[MVsmn<ȳev0RS']ӯjj?+9#VWMU65!!EfUfAktԾ%ʜ's|oqc5ͼoX(3>د[JMw~]N=l.z]v}\5aιTI2v1 g8LDңV[l课Optj-~]?"m2ٳiN389vOu<:XwekU'.W%nl%g3o/#mv;餒쵏jT8cp_Se+b/'^iw'Ӵ w<.7)+uDLj|dV5!0?1 n#碟J5<Ctv_x+zͭGn˵~Y<x>SO_ʽIahԔd}z5zkJ2eu Eej)&h lr2U=04Z-Fw50hvO<{;73Y1GjVY:1pp-{%587+0x8 5yjQݏ_/')5wөFwo߼6ˎ8Vo 2uOc0an޺t< ZU:y=:ErY}rA9^??Vth|¾H?m5F$w?LVx\\QyJRIOxCվϦhLL=Fh*Fr k{k}</aaSW׿oÿG [LSL|8}+'o|8úOGK^ai{xIne}}1K=,|9ٮ߰ļpANGוJu[O1\wէ}mx[Vx1!zVYR#軞)ʥt/"n>sL[F8^ zj%.zzk -%R 'k]${ҕHF}gj{ Ʊ׮^fʅK;VxomRmmg:eN:mtiMOZ $bSFa@nb$cuvfqTNT,%knMwv3pkգ2M{^֋kcV!ѭt? -oyoc܀p#ʷ ;dv5XƋs-u?F ϝk~''GyoxhmPN#!p{:?Ѥz=l䤾m ].x\G$W_s 3RK-Q}Zۃ c؁#Wb>s2zi/=O6zFQ"o:rzⱕJYQ'+yz/3&[ 򻷗"98ߘW;iNֶNJ}hUiC3RS^ZWM7Ρeq$do-vǯ9<>gYGRב'Oɭn+Yv!aRBAБWo NRzԣA-V7-B]P~V2y?C\5iޏ*=N\[nܥIxXNyGY/%޷XkQukfoOLeSiiʞnͭcSɏA;4:{ycP_s5i994r%sSkK=e'gky7ښ@bޣnlTqUTlFumcPۏ#-SQor,_XZh'=4(CŸ;~][ui 3,jc-[d8S)]_м7%>c:ʲ-c@#qsaYK_&I[q֮-m{Lk'#97=~s|RG=[l|i+[\[>-Rx;;~jO B5N>.k]F̊7P NF~2F<bOZV2 'άAB.CzqqGc)-{*TɷS=ZЪ[ Z4e1`x'gZ5%} ) koM&팏Njeь^/?8Un9鎸Uj2etRs{l 5m)N/TF"JUJC3ǝ<*G5<>}''^]>d<>R@O=J}HbYL@ am?5U9^O|kfRY~\Kщ8)_ F3՟*w EF1ux-Ҹ5*]t1z9WrdI,ܧ`ڪr}53SJՈI!{vkosir+žyfYʤvfkXֲRIX/fuBAEݹp]˂{mtny$Fw'9Ǯj9mӷϧ޵"5"}/ca4RA27`zZN\Yά^Mdy;4ЁTPc„E(3Bk[RuK"3]IT3XJ6Uӄ+KOOԯ݉|ncH^ַWF˓ɭ$풭(Z둏ZQqӹՃEfop~nFb$CH s\\Ѽ˱NT/Muhس,}JsOi^︶5ʛʳ8YSOw®Ȳ$(8L͉g8Lwϯj9QJ͵Gmyo?4Wʶyֺ9eJ:c_"|~O&NvAuҪ'4"iݻlXm*:y=I]*5m {E扻a-g9kfN:|6 b$ :=zuW4i)&hZInʀr+33?o3ڶ# C Y0aH0>[w*73BL@FsVȐ s~biKk{} 1ЙryU.zeږؗqy>v]C]ծ@ rֶqZ{ )lȅ1~:Vo]V04[H̸LW9s$gSU,ȐYcl$:7)i>~?/ 1V vYIMn-CLrr8}++yqOnٮY\d'%"Dfp779ytpkw)e*j7І+y[~ʤțH˚㩭9aNo[6/p88q\9TsU*Ӄ;w);X[SOc*nrdՉ1DUcasnjFVބ2#g-%cۯD/fDdv+ ѷ{?w#SE+Vq\IgC9a8_qN%+-ݽFMKgEڬrFNp~V|xĪc-#U^Nr9ct99\(ьRV3 *w*^NItF#%wciT{uK(>̬pʣp`0HZ{OiBTe;4FUƪ>71P^vs{k'J^U:.ؕc>ֺ86"Se^UY݉b_1B0}9?*xfuP`Hq1wS=&RUfۖ-xbc_=JrtMI=4I6br=+Ч Zn§N;8$bVE9n|+na*$|#mJ1WqR50i_4 371ߎȾ.&Űt;mv?{\=jҌe~t8˯nR{gF!\;kYR䒒~NXjkKkv0q1^Z[sԒ25|>\|iƄhRUh4křՖO8~*wuVuj]l^{-d&vwފ4/c1(I[}"I7``y>WDi˚B=F{%nU+rx֝(N%?hK^>9GA0|~vjrۘB˒IR@4]|.ž|{QТ-u:ty\QGqu{tUi]5`wܮ lr`>Ztpm$I ygs+1qz:~J愣$l0̲`919#N\æVnZi2~G݅qI>'X˱8;g=\•NUdŌ ZcݎzZgblzzG,RM]9d3k3ݩ(KFBĨJaxyefPI珧ZY$ʔc+.H&rp0WVMpddT8UE+1_1VH $+7u\7qSWn3p+ jor7ɽIwH׃ߎ=iۚ%)Jg@U;|x'ήJ:7n].͍Y g'te˦̘ӕH=>/]զi+ i#3]j3PNK_3׵k{p-ܒG$aX1O8\Xʌ%z)VQydy.bhc38<s]+(Iu8ūGlo;J\ p]IWHq[OM*a{ eNUnXnJ+%5P#sq^^&7uV*4YŻG}a_7yFpjѷuG%貳Elڎo +:򞜃jI WӢ/gFzn5-j2ٶpAÿ@+>ۙ;y8ʑq%%ľkXӢWc7gۚ+VWg 9UgfIB;{g|gP*JtN*n͖4OnZ?o`zk*ܮ켌=8rqkXUieV QI=;,ghI1j:A 3nS?\gx>2璿îi9ڝ.Xtr^m2DN-ٶ+nTh؃MkSxFmVi3 o#['XmɃǶFuGUaMu$mIF`o_Ϊ1<W[y}@]=qұUiEN2 "E X\udO)IJJS |e)Iue8mR]*jɼڦm) 9A-"o'%t40E|.,d=:LsQ/;=yn\-),,ۜz~5TI;-u$#];bq㩢r%JSӫ[/;<:2ˉ9٭S޵:4ҳ&$JZApz~G;´iʚMзhZoJ sy=k.x%uO,jO6בWk6ӜgR2{JnQM[~$DkQX Xc#+S:g;6O!԰D4Y8U%"jSewEm+f}.?1JO=F^h-ŸVVsC^C\^qT^^k-!۸,,!NEֺ9.^OiM&]e 'zZuvKMdHUX+ʓo*Τ%̬DeE^*맠n%fo'#9>zX,+y/<ͻv_=y+~Q2ueUo*()<׿2Q^qA1 e |{Rn>~vO>Q+#JyUFGڰ+.TJQKmkLH8#n:TӭV2'QԭQI-ڣџO~_坵ljwve0 1ܯ,=)F(iQ=/[#oS4:=.A&eRlzxz5%77g:~ϕc?k=ج,fU󑁂'ֽ QJ +;^Yh|⏉NVmB9eU1\qrkezt)I֚o\]e2gf >ݹ_gUdr]%9W~)41z>[2zכFQˍ:rOR+xF džpF+TGʴ6G|q r(lsL]lƿXbcwjG[2]Oe^VT}&巚yܵѸm݌޵1w9r6]NH6C^PG5QKYku:aZг_1 g:¾RU@_p8=:|=LN_w3rXԈی9'jb#cT/Dݼ,SҤr76V#ӵK|ZwMm=C  GN;gڹu,.jU(^ϋ3Dc䚪N5b)E˙2o 7rvl;Nk(J./SoNZz[^#6#F7nXE)be+?ruciUK.~kni'a*M[R+Ym 2vocIF8{Rw,vFyǽsVc)Ktqoy@v0ս S*YdѭF_D@lYpE$G=?JӞ2VJ2ֲXE~[v~3\MO .yRkЫ* 8n>mJs&r|ivMo,j`#* 穈7,6Ԣ~pvguc5#Uǧ<ϥgV[$֖t& ENE)WAVe=̰ѕMfDEqsQ[y{YFV[,(|?x܂}NJ2B cre x+2#M-Km {tz7o3tkNwUsRQ꣄2m^v1*mt(qB\3y0؍ U8sV::HoqyzʫM9gW=z&gZCOANFR^3͘ةdi>in2p2slyJvdlYq3,m;{`9\*SU9h]$%Y![`k{X'37{)K1jyKSE4Xb.HN*#R\Sl=nk+̝oԣr\r 3go8q2T۲J59o[dc39X+51JOfLdⷍo;c̟<$3u^E*{8ƌo_bd#s8NjC>e9Xn^M&Чwӵi 2mS|+EbѠIa*z㧿Qڽ<^TQFڿrCTF̘ڬ8|-NjӦn>jH$*~,1q5zJff܄f%@nP:סNʎ4]M->)VfS9lԊSH˛(d.#o, &Jxv$i+Hܜ<Һi(zTqڪʬLWTdùJRrпad+7_kWWZOldWVjþMa*)էБ-n:ǀvL2PbE. #g<\՜BehTUH$`W-F2Nu=b&&`3w<,N\;KrH܄{q85/v79krԓOMJl ۹G$s y>\FʯՌmVK1J㑃"MhS+".Vo!B,灟NW(a:qyx .[=2:~*w]:Uy] bQ?Z8kQW+iFmݸپڲm-y=kX^kɤԦǚ"-Э#D}Ƿ\c{ߧjqwr[XU+=Z md:. (ګ Ӎ?aO(k'U2 8|;FG~+֏-CdަTpcWhxK$Fb#&Qrz?Rvx\ʿU{y&Nǿ_Uv\rF-մq8~l~4f#,wK$cV 70S_Z_(L N"YU1r=v+x芑Ɩ6OH#=9㿧Zzq WbQm h3rpOA*_>g*dy7tf kowB?y $n%Fڅ n˧sZWDJ"ǂshJrI>ۙZܷ3H#̀z#O硵:0ܢ1u ǷQ=ʄ϶Onon(ߡıt>^ҋj]NхAOp e-/o[z>뷱΍`tgm+3[2]?SRs/7||{^ݫcu٭hSMiw9Udk÷Ncж==}:Q1ۮM\>ںvOrxueuY mᔸn}^%isIs>yzyzSo]2GTڻ]?.@eՁ%,j\q鎿׭LjsI ҡFobc ܜ*rQB7~#Rt D͗?1N8qcO록Z2z>&}UfZDC⳧:c,.N 7 d N=3ӡ9GeS܉f[ylm@`g>U">\:mRB6Yd$tO8Iԇ3ЪPs$w? Ԏ}骱 kr]Fv4rY.dm=[F+mˎƵw_&LvFL*1"n@qWoRaI49{T%KvmDͺ☲Lv??dusFbj6Gv x?Z<ڙT5Yu}3Xs@u#)%sӕ^/F-ۤIsVqwIlGo1 A\faHѝp=)>WO*Uj|KNQyp<"C?^1QRq[mc){',*,vG5eMHFG=bg'$8}iIǕʤru_/n~ҳU)Դ:rsfRG3;K',aBnT4qζKJV{Եk<<  Ӟ̟Fߙz~p.KHc8d.]?'zQ*b䗼GO.Aq/c)Qjn̨vTqsRWe9{ʟe5-|Up p~evqYʟV7geӏ%uf7e0ߡ#筗ӧUd9i;T*sߪu.4P40aɄ3rwc<On0|G]tCEhpG=뗖Nfՙ2η,dt۰o8|}#zҏcMrNejf mQSK޹U)*Yiw *qӽMXӡ 1&,[x|UVg btD2n ~(B|G"ˏkYEd<+-VYL +d'5$v{w*e;HV{py#=k9`FI...ϗ#̘v&Qž=9F6iB$Rկ"/'$2۷ j9[KX?sچt˸['GV=9oSfazg(ҏ-Fԛ^MSmtU cq 8UJ {_Cʵ"[Yc#zgQ;V^(*uZ.iXOvݸ88=H:\OGos:2LyS7ˌĐ{5*EEy]L*UV~aGpc66[gKYBSwmo}:F6-B"?ݑYWӟr8r+9rn1NuábCmqI7rq񩔩u2C/LLpg?53z[RiKWgsHC)fhg =럙KI3 j[6I-ڭ eb7*z;EuftMi{uH]=ce##koc'-iΟ4Ke-ͲZLnMfss^*c rKB/顧L4af`9lw{S*vEk8#ta9)rQLe횹],NɾO/q9$pG V1kbaF[kdiI6#9Yݺ<=o ՛ln?ƴc'1" !ĈQFa*K-2ic:j/dDpJ1S>UY]%Uϝ|zׁtF7_qE|nb,sI.inEg94Kn(f`d'w 63v瞧]QQOowacSJiG/[\ys9Szqzjͣg[H;QZA$nb1ƽi!I03ҫSޓoœjrswqwlԎgSݓzv)cN|ʞ5ճܑ(oNߗAc%Bwsa \Ew߾ؿ<4-J[\llc>tV𘪰]j|1d =8_z.7RӅ)˞ZhxOğ8Go@qx9^Nxͯ, &קJx֯oy浤xڭ~բ[&Vbٓ6y>[?om:]=x/RX;Kk$ww;mz_M ~bȀ˕bꣀL|nasJ!T-te:t};]Ϥ8<>m"&ZHFyj%RMtgb1RSWH oݲi8#=˨|*h7(wRmh>`|׹9NR2Y&NTgNOWR1+*K+YӋ(ǚ[xj)ݷ#8q 'NwG)<kyhtlqˑ뺆":z8Z__ᑦc4q3H8?zZѓSv ;|bB6==?׎=φ WnDZ8%sw *F.@xԒӣ9%.XgA6 2N~FNqSRd^QDn,͑z]sI]BINh`2 ̪3MWTs?>M8i&ҽZRHPi$G*r.IcWJܵ#|k>pNA'uR'VHo1Xm!Oc4~TNBIigϵ(ʛք];qꌪyGی~G<I_cMSwsf1glyݒyZ]ȣ:ae1Vku"XnF.̯'%ڬJ81գOcd4u<|d+^8x_a|ܖ#j+tֶ_I6#̬ySΏŭc r_jK0ersnNR~Ԓ8.0*$tLˡþp݉yg Ep֧oʺ֙)T=EyΏ-yB\Y3$|39&ݔر<uE,U-Q%sgS=BHFo-њL~gGBxǸ=GFМ#0u.-%wsvF n{ѧ;.m8xeSD}W㚾ۯ{6V煭MM9QiϷemmOz/= 1U*JN7emY`kGRIԭQӅgaZF>g8z2ʦ-:{ﲬ~տbXaq2H[QqZx=H9_gR*VUmߥSs/Ů>n߻Ttl@q9zq-2O>%)ҧY_K-4OhgKaH՚@o wb3 FJ5$pԫ9V/Dk3E$hEH){h֭wϽ:iԖ"#E4o=—o!yjcG,v#sFHIM<ϟ*aԣuOE]heJɴ^:v몊ۅ8Ӕ+=oy.vQyہ N\uϫƝӻWH*:=3[ZHEYB0܊jVe'+[y֬<aR0JFy:ѣ J8ĹUkKw"ӣhWXgˎ@2tQ+9TUoCjc{m}Uy!Tr#nc㞽= RTׯcʎaU 6z,RB ѬF<yu1vw~&8yח^|zɻOLpIĆ ?Fhh1PkdϘ>>^''dgLI''ӏS *3{KY%FOv]{ucψK~Z&]•<8a]u|5Zl[FV)Nާ_ Mh.,ʧ;31?ł b}nKsU%)IsmʕB׍;MOU ght9n}^Mb\<ųe#iS\MUzt+k [Ir]F8 .N˽;WU5I6ż$09< sJT_/;KBIj}},z5΋J] S09RacUUP~%_OMoO^3ubFM>ngto.h^/e9&P;yJ]AxcNn/K'r;庉Lsޮ4jZ=*Qx 52YG4QS>#4?*mIiqyѷӞ ,iMɫtOᣊ'9 "SFYr2O\xN2Rg{єR/#>oq\{Is3U9^fC5Ȯ$JaEajg2[vX2׭O)>]NR£В7짽zol:1wu5q%Ļw§aTc;׵R5ko]{NSյv>/-é^39Kyt}j%~aG>kN4ڽ⯷Gmku(ҝofOUg} ]g%|e $r1>J]?9b%R|ai$Ȭ(}v8]z5&-F4IyϞ-|xҵmNUVިW&1gpA8}&.F2ub2zmU[ſ]4ne\8yxgE|/ס~צ{?[|Pk).nU>=9_9R?XcK ^=,f2YX'LrIf4}¿LQO^)ӻnK>xr Hٶ(YwlPUT쓞kab/se%Y{;w}/GoMo2Fݺi \wG\}9GeJ奿=&GdݒM^:yl[vhm<0r@$5QNTڨwa^*TwC'GOHi$P+p|1Q9|K Y++o/ӔǮ~⧏/ZͺFe}i 15΢{mӱhΦ1R}lok=LדG 9J^Cף C޿v&D.?\iN;/zΙKWf 3ۆPuv]8䏠#)Q%eq1jQnKUgkzShFvn= TeAAȯRw_[X jM]J=[-٧Mvƪέ0 p2HGASr52xz -$ne?@zM,;]Ųz:ʕZ)5N&87t?,~4~ ~=_Ylڤ424k$( (Uj:WS09j"ߝJ͟ct[^Ҷԩ:j5ߓy fqcob3^^Jm{Y qZ[K+/cϵ誒\0I,Hw8=+h 7wK0b%N tV#'v mcmy<\]M31{ ='\LEJʗEVR*.Zon_ѭP[ir#7q䎿=+iRJ-}ǿETY[}{~/ǩ 5SRu+/8nDZhN8xBj-_oU{Ɣa((=KU>d_pV,HLwCs^w9| ZiKe| =^^ݟ dE<$ AO5uRʖZHRI7cm{?Or>Bn8O渊*_~|t2[p~_+S˙i|'֋_D|/㿊2ƥxSi3ܔ|1 N0x|=Ys6_5+ Tɥ>/is WUȭ$u^-5̛}z5tnKoK缐F˱p=<=1KQӪGZ# Rɥ_+N@7Bɍs^kEbsSNkco=]0lg FI_ITFqE'IFkVO |]ӵ1wē4lZ9BPy[N=Ե6:dl[c |wd}n6Bۘl GzW&#-1riFJR{Rj'28qYa~¯'FMz2{numGßڋ$_g~15RϜVTm3)m2n'VklcUw*N@ ٻ`cҜ%kڌfzÖV6wI$Fr29Tފ?q".!4rny*^5QNl+reWZXg?Mlͫij^Z)>m9N:R51<ּB KLKzz~|VnRZbIE SN5/J!H`1ɯH+Ox|tϕ3# y'{wQ\U=$7uCOvֲ+1TT:2k^bHr9mci.7R[iMmeU\I} SgV#;oƐ"`$/#$wi'SY{w$IF[H:GTt۶pGF쌐"pʙ 9$>[nR]E+\p\n r9k5C;hƗ4bhi<۵13,e*5z S-6ĨK0VU#=TImYCb(h^A_JI{3r7N$v[fYak|9<\'k2$vuBf=*]=NiF)(oӨ3%x7?ҏԾG,%xҺ(bs*dשCeZQ-3//'rZBKIvmambH/qE^, &e+/Q߂+>iNM=Lʔbԇ;}1nQ"Lr\p} %N1S5I'-kַ6f[6Dz渪SPXwQl^Ү[Ki>^=N:JwXx\b}{ƅe!IM8 uIU']R[DlyKfV igcjRi+uH%ZmnA16&0$hPG@>ӜUToˉJ1Q/FiyBL$ZF$K6.۽e'[}9+.is:Zf3y[`L~7=r1ZJgHƝi(C-TJ$%H۞7!ÛHR5t dNy'qKhA,2+%FG)lq۞?罺Rtf+[: vG߰aSN.]}IeV|vv=je-b#%kF0Wm˸0c?ҢQEdgnfb0_&Hzڦɴk(RI" Ki&I$SWL48r}4Yt+&2gqb;r{VPi/z܌6o4w #nL1'1Ҕ,Vb ?®3=Q4*q{j}qHV43usu:˙UaarX*Ƚ3#֨w>Zu.UifFp6=)Is%}ΥIԷK۬Gr@ 3q~9CW.׽ɾ{C m#l2?Ne*q܈Ӕ䯨Y;Wo˷!Qߚ]W?i!UfYaGf? FRߞpSӡ`'qV+? z@8l*IT42]]BɻplqdR;0\]7ِ[+I41t1\zt>(K_I‹ C,y-ƅ):z % 2!B{~V2FOL0i\OTT}hW+r3m|p\ᴎ8ʜeih+[ xnqrvk ?|\Ri>{:|=}z^@H.p;\u>T.iXKn"6s~5ʣ%coiZQnA)͟##1ryՏ?{pt(;H!uڑeI^X9QXHȿ46GQYԔS22V$hϨ$OqVTӵ]iYp]9#v靣f֩(acEڷtUV͌;n⪏55nji)Ka]$1m +Jrv{Km?̧wafK7(x=r8+i#**^s6<ΜV0%Ns5Ḇ dW{HÒuSTժҊju3"fhDB4%q=jȉѓq1f3n`ys|GEiOܽMEN6pX''aO=OF&>},"p0@b2 ǭuFa+(PCQ"O*6eb4o圞}m]F4NW{Ցue9n~Ҷ%eتةq;FFTz1?S[QwԈS拗CBK[90ǧ}hmj]{8L$Ǯ'5qe(uTy[7dcf >#NRRrL0g}$'?_Ҵ(7dsJC  y$s#SʡrߚQ?4HG?jؗ޶-ʅ?{-8&U&UM9cQlNx\]l%'bU-d`'RlqzgO.e<i?|x>ԞMv\[$= ۉ''ߓ4ry%e)+q-s{F6s-Cms'~SFjcb)'KܭіFxEW,ym֜%wr4˼JCO~Trh_/ږJJ5)ccr}jcTծU:n70gTέFyosϯNծP~~\裎3WrWGm r/ NSXy摎 RW'90;{ӋR}q>+̕Ya;RA^t[ӣާe59C5cd *OW\mKީV){YYk|sm n6D.8z=:W_$ߧuFd}׳o&oFN$<@.jK=3iT}٭2K!ܙ¨ẉ6Fܞg9MNH{nmnpRSrMeq`'pHaa# B~^u*IճR$￙i#Y,>o6>ms5˚[yuZO[7IcO-|pS:\Ӝe+#*ֺ?/3ÛR{;ɍb~rydc%Ji-jZry,JW!H!ZNT9c*ׂ~柩ֲ^C4̹ t#ֹ%ye)I|E̒=ukQWp4dӲ[dvIUN8s֬N~ȗ:rqzyz!dr2gӔdkqgZQ-YgB멦5S*M~BI]7@n=8yTkd#.և?799(3--VGh{rHʌO%N.znkF""ڇ2N9?BQ*:9ǣ`*}/ gФ.};>8h #WvQw3py"U[tfC7@浛zJ~N]cA|$3ܛyn[i%F^-ʗ7s/.%Ár9E=WZ*,%D#dBߎ+_z-zw-d/CnGXz| =v%iRMlH@>?:FICG}lP\r\#hXNWPOcɬJ8ө+Cf'co"Lcڪ9t`U_C[N-+"5XFVc Xʤ8­IByqh d\凾FJPueh%dsJ<֣Vgo"YAc@z5ݫ~L˒+bBb+7+VpO0ix秾+U%8FփGeGATKn Jq;#ؽϺ<{$ Y91ۯ#JdV.D'OKB}֔9aQ䁌q;I.呔lI=YM/f♧-HJ/G,;vzwFR99ss^ɿǡ)* Q.OOqwzjm=O WFX.8Wr8¬CͼKWr HL V,[r88N״MB SRQZs&[ZP5f[fֺ 92+Az1rmJ?sӣK?߽m>k$#G@x#2 +kG/cjZ3üQ_xgYеxEŜInϸCNp}=+LM9}a;߯]yTH$F|Kpd y :EqSUG.NN1 4f}@#k˛HR9MElW>*܂\g9J'QR~gF%%T6ys^Jis>ZrJK7]dCs zgz^KNTey{] fHL'>+hltGtl($4LeSznj\e̤ٜ9JIXdbeUbGQ?tӏ2|ioK$*Ȱcq=sS6{6+SX`d3d^ )%qOR\۸{IN^~v#2X썝*TӾ=qRwarסV7y!'AQ5(fwe{m6)^oQԟiѕfxmק 1"\"zl'VS3nśvy 9j[-Jjjy IorĞ}qq:it!E4gs|~ڥWߑT|.V#դbY@1sZsFӥ}WBjëgw` r1ҝJ=I|x^1M&﫸pyPpw1< v9>g >kLc} gh$.Wj_ҳIzqhoԤVl'`Roy!3U8ʜ}Ut[Wwis\JM)7~>cZ4jIo׿q+ M6t 2x^rjދ\'VW^D xgYa*#YQF}F̍,"݋*@Re&sNZ ڟq$Q–U9#}}*~ѝ?W)m"K ȱ;n-#Kӎ}攧Rzt8F2̞߈$LZ9`tP26,G8"eVuP7ӳv+!qjE^8?MHWqM5/ʚTD|kr;0ҺfP^ryXTncF;c孳9 z+)S%QSJUf4D«7?uk[R-ɍ._I?;#)#aTn>V =?3^۝oy/O4ZR\*s޳0N1eG仒]ܸQj咏AQ=m<[07G>]\krqfu|7/4۹>o=x /DȖ/(FSokȸN | ~\\9+ƣÐհ&7)ӑ o.&ܒгof z{zn5'?v&5)rOgܑb/rXQ{7G̢}-Y!bX~б nbڸO&SVίm`J-2۬v!ڸsgQ)I5*TvЎdx6M*q~kJ굝'dhpUeǯI$կψN4n_xiw_iIe L++\d^\ӎ~GR; 7߯pB̈2M?]j!-ҖF-켽K+;4h-8<8~= }aPݹ`=8>QRi(9}^Y 0J w`=kZq&y;lIЬI4t]n*IN:W4ITsb?uE]G5L4KfTWGU*J>5W֮Y+⼆㏧JǖVosT(TѭMLVv`]IzιBC:0d[ $*F=AǗޓJ[|Xn qǮ~%'w扄rWG\AdC4H\\~ҧ6(+ydY%e |@_nk_v)N{77IF>뷑vv6U{*r{~UR)N̙x 1{E4GMw"<,ߟqJ5mHNGiu۰ﶡY#Q#퍗sATGݎ*H',&7IN{T\ڲ˪Doz00PXzMjDjF4rE/zDj8s7RtF{̇x#i)c@߼Ĝt~{CJvM,褴jlHGO\Ro4yr5g03Wqݽk \~U_# r)sdZ*ќ=[DrMƸjJ9\c(XEP4ӧoyjMԕC?gNԭ0hWjrALv\u!-1i4Hvm|+жOZߡR1ZFm,1QY8 tgZehC~s+)VUqpkt9c(8MkԩvGjo˷ztT^.G S䋺.u9t(GD%ÞؒaJ1oIgc#N{qe CTizzTwQ.'&)o R1Oavɺ7h$9Ve#'{T(885miSmgniI3U^Rn_(ҧ{wg:*J9N0P{p!e$r)m̅QW==,ޚw/[8.&mvNUNzyr˛[V iڪkcq'8's3Te%ދU4˝;ҹeEskkX[r ff Td沔3wSb)M̥X'%} S{;аl/pG\d9mX$c.~UI|,QčtoX?_QJn]xo1UI?tғ\иYfh7eX+g p?ִٛ|QIjP98_=H5jKGqQJrr+f 9C}u+#~Pyc浧/ܩsJ[cs͍#mO6ȿv-S?kݍ%JJ2vLH(cv㴁 :MQaqpg*gNQ 1-Rҫ]m#w01姡R-^ryPjx fi9sT䵆G|Oˆr&Qآ)eѬ3u1?Jϭ4:[ydVvn z}pn2Jeߝ,S$mFN?OXЕ:65 HVa|ǜd{{+Kv%I Xsa#UnsQ1kzJ#%1#x]^ǖNǧ,=6}9?k3ۏHDc~S=Me|ӊ{l$p#ۮ;wk]VFrmenr0+"ƞ!Nu~~4jyk{#0RZV89ק_?N5F8N+}wӵȶo_|*}}}3\QOMȩSe-סkqE!Um`8=3֗20p}Ѷ#gx 8\tZtemia&u̐|ϩ[h,>ȹѕrX0zQ\+KeusJN/s_-%3ɻ8b= ц"?e?1R]dܻ土ƚxêY[1cz)֊fΜiy#3޴7yC#rac*4\Z"xyF֬͹Ўt_r2\Mo2Hl{Tν)EJdF[J)jN7Q2Bʑ< 2qxXHs-]d!_o=vdmU=5]㒩Z4Fƅm.|Ӟ>j:^ѥQz8]nI#'l;RyЩRRеir &vƻIq;~B’:Rr\@KE7ʾg8r2=WWpŹSmh/vxdҲv-Yc7tw?AUE"jJQF0Wrema F~l1J*iWSV* 3K0ܓ=qרNIy#|m-7{sGzݛaW-=?.+|~jTCU݅]CUv",u۴RHYg9ЎQ(.6ԃOBHbYIդ#Js3zke.glXMе6zi$mdӅeL09qp<Ҹiө9O/fTӕo"ǖ7|61G)8Bjƌc/hun)W,*~~R̝ｂ$xn| :=ʦn\%5#̺nq}'SN2n*j]F/pQ:*ym9蔹]ҽˏnMwt$Ddi {`ҹiG9άhwwni3<[tM ^[T5;6sӫ(bV[v, !#xahs>)9[ҵJSپ[-q@3#\F@$ ޤ#vT'O&,ۉGjn{\{Q%d>.iJl>5y2N=8c&UO1!:u+ezϾ;6N*w}ȨBe*/o/*DCֹҽپ/0RWZH`TM:q5̆H.o7tqpAZ8IsɩĹބ> Y2HIzPӔNa%MpL*J"\<}+ЧҴq{8۴<˂vǃ+Xs)Nl=»3$X+r1krߡM} k<.l =R.F*E(}}"LM;e\>cJ^{~m_cxџw8VR?e, ced/^=L%['~+:uvuMTmR:ls"HdkW_2I&;`2N>_:aYRKKyji 5!(kw'ۆ_|LcOG]˗3kF]OL~]zF˖Nk %ě6?2]稯}m< ZiϨ-#atrOt9"ׯ pIw}Z)ʢp^ّǯܬGvc`CۚU)W9\+s-T)""PeVގ@bhI\RiZ뿯V__$7$1+>/zm:u%KMK~ym %v8~Ƥ*ZiөFo>wvU>59lg~qg$֧SQQ[z.u+˸̞bϖcr:F4om8G'fj:;0_>w]n%FnЋ]*]iIUcUP9+JߩJ50*-љ @_c8")kӣN2k ~8rB:wNhѳߩxP2|F>*TWie5d3G#ZFތ_Tce>ff<5U}އVMb.SSZ5`T+yOtӔk(kӧREc. T&n-:ӰaX[|[qnӧv>'HvM5h'B,I䃎02ğ;%[+._~ﱊu9W]noK~e71҉[H9=V~wQq ˿[s -m\XI?O׎JWO#*V:]i- [``;R+'sS5bs4*ٶgwqDj^F-]>_2;#U\3j #'ZVב0.|`r19Q-ɄN.1Z1}2CnRGW;31FO(_,hl("&1Z+x;+u~m,c?#s4Eʥ-Ӝ&`$ƐEs ?LtO+VПO!}- vX|0=uzk{tqۿcR.wvYױ܎ݫ SRKߍu5H㹒MBc ːx=?ZqRmm8;Y4]ML0i ۙyOnqk?)G&^ͽc< UYiٙ7ޟu^GҴ=Tvs_ H8ENiƣ۹F[E{o+Mkww}+Og/nFJi("e"EqNkjZ>N9ka{9j̭~w \WUSc`ûw[A++׭ JE4eUG ]N˽~mzq5ӬcvZqLMrJ%&8+So;;%ԱdEI pc*JOObb# +˖ws"l噻V#N18͈\Xם/g-:~G_SbTGiZ_Oq\tMSsmnnH/ %J2ȪN\SNR&IYǁ9O rw]T64vxf3eꞇDF?u{unG4R@V9 f؆MrFc'4pR3V{XIkum]<$?o/"UT_0'-#6xS*Qnt߲3٪(k]z/%o.hYԗtk N01ǮkhzG~g,tQ5ӫ;;T2uE?co/p3p2:Qw;zocp.ho1Tmz*򧟦s5Ft5s"}[{trIm56dkyxQjW֩/vry?3].vc"MaI#y =znSʹyV˹}FufueI1>AIWj~Ҵ]B,]wװޱou.keBv7Y$ u:ҜW+i4NSյaqywC$OW18hT[藐gܻHړo0¬0#'ғFBmzืw[dL>SR֛-Uiou~ ݒGRw.u"*khkvm'OZjOe*q[iiw ,̓( p=j:WK]]ӣ/5~WO{MVȲJd C\g|uF5iiӮX27e՟axpZ/aU*2xZ:NWvDzNbi!e<'\Uǖ؅B\^G]?,RY8%U1J=;m'u?qCHB8>qFI}?Z#SK[ڍhJ-g <i7mWTlgreNCEcx؞ZӵW1ۈ؁y^Fx(/JmALiQcLr~\n8oj^j$n5]OcCq"c^2@$ƾ5B/|+v^{X=S1'99e^<}穎"5>duHamܳyxגs^,yl)\4n/);>߀t8yey"kCH}:/;;\9̎f߸2`QRh֑k5֛ ;FáhF a˩k(mfO|ݱ+ QSuz&whs7ʨryi%ʴ?S*[㾚UTV=:W\"sQnh̑.|v ʁҸcNWQK޶3FɎ/,1nvzӥup!tѩf!tI4yy4d?1 OosN<;ZDtG'dwv֊|1A1**ƿ>\axZү9]{xr+~ݞѭ : GoAd-{yn^M[~G䞒~KŵNEkx˕»1<0YJ>k}?e)c[yO GA'#+ U#){>O<>Wˈu$Wվ? $>xm1(#r01ٯGGRiҩco=K6A0Y28r ^}H3ڿc51UiFSVUil۶gB2qV{D⾫Eʌf׻4pfF;\Ti'fy}(;9YY=rK6fݰ.jDe4~SQ~mahM"`q\T_OϹԩRRM[UZM7SVT秊1*hrX.pʭ@;k.jgktx^seRwyv&#;QQTIwo|qsv08 cȮ|=}:G:JSR7J6Վ#ݵ|EJh+_K!9SMmbp 49g)^VWt|Jvm۷'\t8nlW+өT=LSoQ$ĭ]J{58S}yi DlYUS t^E [-׋ԯf-?gKgn5Fޥ29@kαwV~4֟3fyNϫe(D|3&ʸ̱HFp IlW1*MThN/GK3ǚ02]cꧧoʥG5h_MvGd僫~ͭWW<w LcVi72x9ϧ5يV*T%nzvaR^ҜTKuyω $2cj0+)cu~,2q惴˧Oz^]ZVyg'|nYzg񩫇"?Q[׾S]"<Ȭ`|@'>ծ][uJ5ƃEk6^J@=~z.~޾ASס?.I0R1'۞ׇ'$o 8zҋ&sþ)n#[6XdX\rUQ]u}I^\nOwfSRkip>aǖ׏*6TQdiՌTvӥ&n5n.hKqJN7NRR`%nik ҡ6yNvyYTqN#&t 5ekix;xV{p{+Ri6F88Y*m73^1γZ6UaŨ/Zu+TWߦ Χ4yoggSؾ|GӼ9,jdUm9?@rzcל:і+ ~# `#[^UL_6 edkr$X[ta8lT+տ#JZUTOϡS[xo7m)Yfiֈu;*dluIb%N/ݲM/뭏(ԩB3U[y/>-j͡Cفaa"5飅/e+$?5-Y!v?ZZxomwѧG).qkaw0fVBr8?ֵpƕE%mmt^Үu),!쫒OҾ-Q`l~xju#<* \yq#)ZWo{&eQp8wKcQ{\i1k۬\i9Ldz y[Zt!צv3<mݣjߵ+nW^bQqKF8P]9o6Ċ(p?_p*8/%]nOxǝaq,׌Ѽ쿻;{L۵y8ZFZoZ[.>5;V@Ahl}0>Vy-:|ʞzO92~FbE8fFOn8?SRz5cY+S?Q6-|rfў7;?uSTUncҿe\EA5Žk؛OԍL*j^,.;4R3OboY+ 8ȬWwl:Uy7R5E5&cN9YEmO9(KjR]\ ͜.:{stc+#\Qx9.^)0yR1-%##>23[G S[6N\c sNI-?/ #\GnJ1S}MFM3{y6 ?ľg*:>Wu⹮U2m'q|hC ӚXwv5*RR|Wcw?O&L4r6 l#FQ֯-P+uע]}J-ͤ_44A}̡Z#t|w}E^nCy{{uVRr+tg:i읍=/Y5X #P9nIǽa5(jSmRcVvf7!zr9m ^.\a(ꖞcf?*\='ִ["VΏHnt8vւX1~Vr+yΥTVMH.ڄfݰ}ǥ8TZF oʿ6ʱ[F]dyCP "=BKxX<)9o_?^{k}jJ eG$fۺ8[P #Oydz%87{u#-¨~i(SO_NTعE+] QZ{H4.5]?XnJ.OFjVV,vyOe:wwMHilӏ}$%vd.o⺨KGrӍGnD+N~.nU*:F^whWE8mLڭ:ܮ0o[ ˄mj6m8žؗNTjFvV:Q k >\r%+icXK{m1aʞN**J_DtoyJ~Ebw>lT9ykRQj ɹUyQK1rwop;TU5n|# FR*v$aEw'<$*狲[U_,}zX4u,s2ᶑ$dsQt}b7WD6lu_s%T*5o+MdvRmesNZv} +"@8Iq]-ڷk/%ռ˽63(UdssQhɿg^Jr٫+4eS3$eV[ JmzUyhj|h\A1$#<ڵ7yae8% 8D.UN~n0? "ڛK=m 7(#pyf6NO~Q{U<yF#^O9GS+78*.rb2=x\ҫs+rŽ]n~ܧ'9gz9=p\ev$;@U#׃JuT}p)֭S nGG3`8kʥfJMzLU%KFD^778ٷvU8sLbZf*OGʲܥb~{pJXy$ )'lF~%mK%Xlb&sI浧[}QR-ׯq`XEcgqz1}ZH]Q8=+J{%bNJ)-cmV"5x_/u9Jҍ*ʬȲjyRpf=uy֮\o^ʓ% ǯZ$RcdQ'689TJRe[KW/* ._U%xr{Z\q"+GƑ=Sj6۲W6/c{kmtpxU6U}#Ҫ5'Ry^2Kn|k,|)✂r:O7,ms[֧om{؁QK&15pR^drS=ȊanFao|ZDSɶFq3{ׇ-oW i ;F=pxk5&vuԩN8'ӿ+9]͒J zSF骐ۙ@Kmɂnܑ5:u)v4W8UʹK0o^F{q[F J1|2 , UfL }1ڋJU/#NoiM)+[K~T *ȗg7 qzԽ贖1Qr)/$wTgHyp{2(-MRWЯ.pd@ۣo-#t^qu/cR):R UXHXcݕ1 9i=zzkԊm?1r3&yیd#zﱲS-ouoni&y՚D$`9Ҷ{7m[R/R{Dhey',y#JJ&jb#^4?`5Tdt]y-LaeRnKMtX쪙QB*ڸkF)^VQT߾N!eP˝;cZ'sr7ĿficaJpy[$TksFVYXcZF4S+ݬҴم[h p? 䊎ҌbF DVQL"qljbUy5ӡqZF\$=\<WYpO~fqe[*G$ 6O=>C+t"gl Ǒr~)GWbYPsQo*iCEMq0<N.ⓗ  'Y[;g8(z(? Ԛ}$ YW-yCJQl5~mzZHr>dYdjcNT܈F7N$$ݷ`GsNk }{[,` qg1Y\ `9;A=N׆dg)!qgԥ-,[,c^ic̎RU>Up~9M>j=6bەUSۧ*J9IܯTn}ē2G7!q9V3P{pYY-~>ieM*6tȢK_6YV0; `ym(ѵ5r y򓝤|aݑf m^?Փ~H;2pk:a̗RxT)ݻ$;K*o~.sEK/Թe$qY[o1Pf+>iE]JѡڽlXki9>LͷqqMtFgGW3BuYuxcFLW{B'횉ABc(nMnZCt%;nTz䴭WC?mZzG@YHᱎYg|<exU 8HVQ9TrVZXfI$*ȝ2N8YK٨_!MKn5r^J8U]N:1ӹ#ZjY'"^^Co}iQ֑=p\[ 'f''7qb-n}^Ng>µ:Ҕ/N,<[_/an ?<<=9J+ԧN BJ[̭r$|!_0n[:kJ4B<CBSxn9 q\% ?N[z-LW3'q#wwgiRǮ??SJ ]N):| c*/gҰIVvk >Z2[g*vhldgRްTlo Z)ٗ1eӕ<9ATwDR>_C\Nn{}NH)");%ᕂ|G9*FkUԺ$HImzk*+\tך娪;71yulj,LCH~]9NGJP+_"h m'f?>Aęwǵc&VZվ`Y "u`̃,c=QYD1NqM= 1͕*qFWgT2 %o/zn2jUTk40d 7דZr/c.in\V IPU| Q??u^N<049.X_МUNZwk/#UC7N k p踮H84ֵ]F O$,T4r-۷aiӧuw༏w pG)눼9oiuhYWeI' qoSTj7~-k奚e,x`r#\ck|W*u=nޣ?dirGn(xa8?Nn..>||u{Ʋ^K&4{4g˒2=COlt| }1Yri>qhkYwmr a?1漙N6UdIV(.lp߲G9l@»FWa!w1U Xy\ї,A dXv9>e&xӓdv\Ҿc #^1溿 o˾WMs %Q~mF[ ~xUJIsjV0kV7@ֶvʣg<jѨI߱:snlwW10{uIǗ=JOEj-ާj~R+|£cW X>.Jojījۣf`|Gs=xy]49^[r3 &BoPuGLZ{ek|1bӊrA4kq!O#H7g'TrFQ| F s5BJқh;8<%Egdݻ;~$mq8wJ$VUR8{;UKsMF.r17&*|~T Y诣:jVþE{4D8n~n1SQn]h{:B *jeSS~eQllHZIFTԞb[[Zŵ|˘9;W<=q j2rՎ!T ..]e%dTH3ߌdsVu)NmxhԬKw+;Md>t:*'>Wܞ8_hqfqGy..יM* '~R{1qMe'i8֊mG<-Y+$0vރM o%X ^OOS\ت__יS*2Tfv6#VM~f9޷]iGݕaz+wL6NRQNk{h۸0FR;/gVn-3NuKtC=4Vc$A=zsN2S;ç-|ŷ8QW qR:w8,- {I#{O*'f~Tiӿ4*bD[Ip&Y#NG*\/ b8Fk}ҹ}c&;J[GNެ:(ַ̝I.JK̖)VP܊Τ:{qxKS2KI;&F~ry)]hE)w$,Rnk|˙=NsjRxCKFXmm;N܏zi*z4(姘ZnaI s0i7p8#+NoyZKb2F+g EѓaEÛٹX/n y{v$+~h9e9SM.Mnf:8NR\ӧ{BίN#GQ=7hS7kG}?=&V0Wgy?h\%&}Mm}ƍ IX"~}H|mu)yWX~9 =phF+دr.mco̱brN~Q׽sG _}aVtW&is©qyώViyY2fvO 9mOn^՜Z5nIK՗׀;+(%Ÿ%k7$y;ES |i^YbGe,)ιgNQ\ѷ3٘*[1'99S:wVG7űq+C0xX9s:Jܼr.fӡVT26ڸjS|ԊʶjZl,빗bF+7^z+S_IFpƦ"SJ"{tZ6VfY1ޕ:NG֧+YZ+>qS*R[rEi;I,$w;UTrx[N%)KK9bi홡mV'ݬF$Pmms8Tȅ}x)Y^Fww]JwK EyB@n _ksTwW]J2}BiVb#U`G;9'#zFQSOg߉=LҭrF؏q9?λ?f9R~6o5sqx~l݆s]*GH[F1O z\Ľ9n?VU u/i;2x˕jakg7Q4 "5o,p9ֽ2 8Oޔ۵*쎻>t|qZZSJ5qJ)5̻7qLZ:yqXFOztiFߩacM1mwCo\شfFWx8ǥzh˝kgF㤶:M\!kܤ.oG5*2NKeyJxm0DQW8${~hS~#P焥v;-&9n7\Odt*;:W_ÖjZZ\dk0yY~ᨕFsrMk+HA|^Er7|1Z~ ֱ] z$V>مNY??#[O`SdC|#F95I7g.Nw.,-ֲ+)]۩j+8o8tJKc+v%Y?2qfdǎ4d#YJҰI"ew; ge/h>^h%ScsŻkqp|o8$-<ܺ&N1#VF>5r/4cћ$䏼[]1ƞwc+Ru$ 'Һ)S^} 뀯r]6ʟ,^8US ]X18W6w;ڔkm;;#/gope.ʑp;y9i>hmRN+S^n6vrG>=8U:4I<_OΔ:^1b[eb*I95B|ϕ&tjNI ['HPd)֭Iyةi.;Wyvp@=~V9eM9EӕIT/[ɋOoL }mOZQ'厯ku~kesm|o6'Ƶ&ԜTc/Bպ-mW/q֎|l?s)|zXg)/_ˆ9ϽQqF+Rn?Ǡ 9v 9{TFNZ9)K+l93Jy`f |NS1\s \)oi}Nv j6a?3nq1ꌹiisY>;d-) 㞵>>K~Nxh^Dg "4*Ҕmʔւ>V%I${kqrH\UcqkCJ .灒%Sn|d{~5ޏ7B/M/qfR\saOd6NO9N1WR޾DT{My5BtX9`FANM{.YEM4+p {*$*pwOJJjЍ:i>zz {d:^[H' d)FZɩZ!m 1 1ڢ)ΣRfT'A~+ԇ.E2ImRE#/gh*Gx"^ƴ}ޤVjqVP7*!]JVR:OkR晤FXA*Goz%(*1t^+I&*BtJdٵJ ەD[m,2xXZnlV4Rjeӹ4-9&mC#7`O*rM=yc:nGB_2{*Xoim_f1dE;:ƭ[X|$5s3O\:RG%:5)uD㻊vɾV;#q{R45Z8xq>U5Gg,jaۆ. 2"/2qj7g ۗ_.ȥ-۬j7S;S7iTޫVd'qDhW#?c&ur/#'QAf+Zޟ-+V%~](GG<,Wce;R4ݦ/R2MTEƣ#2y_bST1j5k9!~)jcI.kSIo0~g>:ewv= ,p2Ko_ W XtT~g6j;E=M IhUl,diegR:#.8he+Eƹ⺣Cs]FeXsF:#\Ft{"\ӑ^ SJ`UA>)1J.+75mL GY_{V:&חee<7q>OY]M*%xlºʟ}|AZFW]J2Q7c㹌\/1m'#u3IF}3yRL+ 4ѫhtӭ<;ĉc`fDؐ6@pÓteSo$֧S⌻hי8]=r,sy Wn]7p یכS,EG+OB5NW߯Cʼgc,rYUF=xaד(хDw=t-;>QonLV nC夷WbI+#Ņe;*Ni']t5Ҥp]qܸ֖#u){5Snlz2N?C>hmiCu-zWRQS3NQM? FIOJ*8ߞOQte$la ;LFww~ܥ̹L+(Ƣ%OpܹYJ\[R' #H36>cRJ7I}Ǒ[ DE@:QӇqnqK/Eݽ+?ctjTLڳqXJ7MxF<Cj[jQӧZZ4loVrSQ"XŎ({GV~O"qG\8GN[ **߱RT羽Qj]+y-,ˏmG^`iV{|^z_v}Sӏ*[G-q6A#3+HAhZ=0I91ƽeFeM2<)ȱp2ɝpsiTyes>+9nes$lWlUg==d?GN]Hhz~^cWy~Y mޱ#dsJ;kLoc眞@GJ'R__C'N/<,FvUOoNmYFm溚oڬr[sHQ{~x=+濫= 6nkrEqw*KaTߨ]XhkʕSS<MC>!OdHU!h'T8p{}-hвvKƬ*5bOPWϓiݙX@9~K6n1SF7I/[ݠhvp6R[PK 6^~':ZOsgX]ۓvwGm4xbeX2I?^OSCbb,Mkm8~ѻ،P?j%6˛G Kvd&98'ݜs]Z2pj;µH/Bτ|y HT w*V|4m4kP8WG4"QJvz4x.F]򰙤 }((F+1J61[܆e |21׹=ߙSr܈+oq4gyvW{.#i{>k^TEVɴ>^;eNթ,>Wqh~UoI5j-v4-hpJT+`r?+Pr*эHR{y"?{$ZR49IGݓؚIŹv$?^vbD.l pbӛݿP^ѻ/lUn0K0%<5/59mh&"8W%c:_A\&x1_j*)Ò~aАTx>i3n39n4y,֗wk {gksiSxh+FTpjWzX|Dc&L-{KK>{M.wi ey SՖN"9b׶WQOgCB&Q(¹,nR%{R{ 첪Ѷ+g>[ iVIӕw.1fI 6|2U-OS,(9lrπl5[8o7݉6=& f2U+)Cᶾf$j)){[M޿ב "O 4vC 摓{dc` I8/E{oU%oKo_OCqCk-)YF<¹zӦGҾc֪_=N9& x´1@8+o/S4B;lƾb,/2G1^3B4_F}V*4a%n[os+eXnWrJvvǯ:NjrW&ڮo[w #1ht犚*>FҌcɻl78\{Z>,Dd\\[?e۸1V>ƣ/k^ؽ46o V\6 n&_aX'׹(TRzu~r:<-_E].v,}G4b!|,N@XP*'q|k[VZY^mD|~pjSrV~oC'?l4E# Hq|s^,TUZtpю*%~쏖itۛdFq+ 7VWWvѐptdꕺ/.d[T[D~Gw^%chy3xsR2br+3Z5 Tju}"6\.5σJ8ܾqti| JI/d sљTJ2aN>oWqj:6]l:C ܯlvFPSjVeF48OϮ߯ SC,ʖqٙff+NS5(]ύm+k7e_*K79Tx': s\u|S5#̖8j? .Q0hm5m3-Ȼy^8N =l=jZ=6_ 4+%dYұRq9$td*r+izi}b|kon_ >,4o$ySkahITzpe|:k?icU@,\?Imʖ*k8|j2]Wx R\\|qgCRg玤|L: TJIl}vr~F?'RjrKTmcni"|/+[k&ܓvTc A_U+b_;6~U똧/}_Ws!FhHݪ/?Q}x14E.tO#?kC/fɶI dІ7khۙ%>#>G̯yK9"n\HF{goJ{;2ST];jmn[Uh+KLdS+A,?5]}Mo x^YP\4|m, n(Sq󱕜2 y}F+/B(fF<xU*qo̹J"̼1kW6nc,xNQ|VΙBThy_\dpIPKiS EJհlv xH_Y(R2۶2y%y9;F8y2u)UN۔j(ө~=cŸisFWQuD QנOWQ跾>7S#uz#º5X2ơyfq`1儒VjƱ:xj5} 6K+"5݁E_u:OqkսW^hEN_b%VQ2׏TC"Xʩq W՝:iџĶ}WsQżAe 48۸cw^VС)$+4>O43P{Qa6bqu;^ʣƕ1׿[!.ŕYKE9"R'6ܷ*zA?FPv퍺L=+Ii9GX(65K{b_2fLF79N8V-NJ]o亿H76'f-&5*1wLēhGȻV7mnA?gi*k[35 %捵ńF8r}0}kpAǓVש 4&KCgM(@TGSȯFNguZR覥+'`4w7e#?M:sZ|ةURM=Jl J62*sƥhԳ{I9Vmj'̬~ꏯOT*vB˓kg{D$_?c污Nm88#jM˖e1qe1C,JmG--4Hڧv^Rʧ2^8V}]F9UHrNu?vF2bVۆ7{dgwȮjCH?U*-btʙVFQN8eRVХRS-0Llnf9yƧ7MZΔƌGs7=z}}8\r˖MO[km?xFeJvݷvx\-ؘTIy ٵUݻh3dжjОg';z;[<~DW-L>*ؑN?k.DZT#2 \znIsrۢ'k_.[xە[{hU&8 ,yW(vz V.o&GGt! ڱ0:ߡeM9TXZuv;w a&3:EA.'- ruT# 1 &dXQ鎝*n\5Qdֽ2xݭ#4mo #){Oo⠹^%&ٜHS wjΦ!K"89a6O6|{we{Mj?iB!wrͽ7HptkWJSF6HYx OӻStF66-WKbA`.?Mc$'}\K"I"dUT9o~X3ZS6*5)=;FgS_HyiHQ ^RN!!p#+VN~.]4"+3|%L={~U?̧ITDIn*`A<Y/vky-?4h_ '7įp7Hʧ=7"k:ҋi2%dpq!gW4]jһ"Yyl?O\ɲ1Tӧ+A2oz氚6QmV4K,QFT?R:S)ia K7IJŨ%{Gs(Qjr=+WfUXэ￐W3HG,N9ϵsqJLyFW1= UB{}*]>TC\ІiKwgW1ϥs U)ʍ6mvvן''pe*)w!VϚAW;y#ZYKc*((ze9Y*q͵m  q,*| XV:|o/mB.&~^NyJ*)\T ]%G-+Ef~X$'zWhTHԭ:6Fw!XoJOٮh41ö뫥ZG߸m!963j\ 8Q $+gvg=jr^).hVܗB\> }zRy z|ҝSJ74ߗJV'-YryiYjz3rq]<̋U9<jƧ=OR{~^eJQQ^*j""WL2s?ǭ(ɣQt25FY1' Yd9WE:uTC4hԥ;5ͨi`a|g^?vZ7#ᚂ[[NWtl7\^FVO9''#/S(c[X;^ONa6(ԩ:JڙzXwqf1=j5cUSPKO7,LWh,v wZvwo?S:эiZWV{#RQim!1`ǿ+эJ[U+FkHt?*M*rx;2iFN/"o:]h1XIDi#dXzvcN2n2#_ǒܲ{ƍ e\u*͎]H8ϽTwEo*qѝl䙑1Us_J1qgEFGge:m mB H8_u{99iWJ1CF0y*I`^8~Σ.Wu`x 8+Yu'Jkӱj+3A,wK6khh"NV_inyv6lsϭW,cuӕY[mW_83,͍Fzcگˡ/,]I6wb?=wprR_ xX:xkn^h` nƴJѽh$,g-EiM\۷юxjU>](FEoeWܦލ}:ڔt,bU'(zF84ʬ.et+,?#zxڻrg"+(}U[''WsuZ1Ƭ+FnŀR95,]ZU ܪ̊Xgߞ*n|$5gsӯG,+KEdpV92q?gv"Oj9\\J>ɺkߚIٞ~l96ÿPPŘ oH83 ۖ\Zˍ'iXy<>Q(WׂFlU!מyVQ_c1榯!I"Bi8[xF-󑸒[qWo۹PJ#ׯ(G d&Aف߰9ayЩ^eEp#ԅ)2-Uy-`Bp\HɟN~>֝9Iz>wt^?IKIZl|p8zJ5t+Tȓ64#V̪{gu\R0gwɝ&6[34Q*{8Ӵ "{9I˾9f[Yc^T0L=r0:Wœ&E;VTf2mj+ԍNXNfwfmͽnp *m4meYƦy,=ܳGc玵K;.D`ͻ[{fi ƻ|ہ9Wtj{ y,y7| Hݽ蔡WEYJK!4UMT x4jIl()J/J2CϹX'ǕF?$vӌcIɦԮtVK" !Pi_*C|7,(F$ruW?Btsʄg_.#з6ۅH.};޻iK53}KP^VEmr\s+9E9F7iYCTZKHdՕcMi_BX'F7i(n2q9.[{hW#R~e猓泚ދnRR7ײfJ9y"dkrS⑳8af_%O*[vzb+JOI?Ty]?QnFйI03pz};r{Vq-B>OG&d{sg,3d}+8vc)J{i4[I?wݎ>񩨹ava*Ч~eYcXfzvS2tcZZmrGlb1 Ѭ܎@<3Dˢ\zFI*Y*叨#?J睹uw9}+s(Ԗi03g+j#QmrG35FMɕᶷxcCf+?ʬ.fDҏN\,.[wqnNlf6@ooG #QYԩ(R5*7؂rdB$B̤=pߍsU=zKF.+H&@dߵg7.kSխHbċFNy=Hb="կj^5I8c*8?+iKoס^[ehdVT;te*沷bjSWWMﮟ$5fo)Tmٞ>^s\JMZ1QRGP*ۏ1\߻dܷDӻԒC -'3S5*Vh:!P}XȘ0|QyYѝ?iߣ&HDklUU[o+bqֹƵ>nG Y+\EXx敛Xݏ~8GN唪-zieY亐25@9KttL-Դd?=s;׫F3s׆2̞# J eX60zoZ4윗co8VUu]w<)VU=Ɯ*jGhdnN۵?3:tiYƴ}:Z̊RD-$x}3]N;TxDZ CPFt:5MJR摔jSq嵈-j5jZG~z0y=벞um/,U]u~>!i7>..dxG:6mNiwkvݪF>ֆW7Vg|=W|z#Ե-;rXٔɂp{cjl?>&xj1ih7\QGm`Bs85aE:ܵUmu*;WCIOzf55<-wBr@}BnJmGG$c(%Z-=5OxOok ]SWuȩwepy=y9r4>*{=:8ON?r.e}Ut-@Om렖2@'`:\DDa̭OZ4cVkGׇ4OK7孤 NI=0s5,'Nٽo+SWg toqnv㎄0<璔`I3Uz4ߞdz ]K >=rkJ7MnvQ7R++qQ-v)rsJNJ[)`f8Z{<R˖ *L(mŎ#e<} F#:,{daVnIN4[1:u\[ c,&ڪ~Q8Qӽs{i ټ!9kXh"zIQ\nyy!ޛEUn/ϛ;czi]Ls[ 4ZGxBP_::~ϕr;+ߛu9;vsXjtm$B:@GϠ=GG*4eԍnúF\`XJdZ7M4$E#4ԊlTN˩mx,ZhO\[*[cZ>Z3/TyYZyrvĞǚNNoYJy/gSj8M"@_UuTyT'~\jөMj5va@JTd8SoWowNF`z\TgN2uBa.gaѥUqQ` ){~f۽1U+7MW|ɭs5fe}"U$:ƦGn^޿+Vk̹#Rue,zpxl4jK^qp;Oj#OϕkRדRoXX$k䂯3|'#Ӛg֏-NYKŨH`#::u?LW5kIET~ߒkz"жe"v u1chB4.iHеYGh?7=3V8ƥ8jVOzܬB;iH0n<x97PxZҧΑ0a3%"Sך&X=L+yEVhMw4AYZ哇681 ʝEt#t ˜`ƣMiӧ+[Fb\ے3Ǯ*%9;)uYJ2 1)1͟rjͭ>z拊CcFߊr)JBU}\Yb q2$mmSFG':5\J8yF\usmk#n1=kR1XJi8}7 fxYd]ubN6猞^I-I*x.=Յ\DeQIo#YfٙnW4XT$ұR1N:Yzuz8`kU:%Sy& ޵R4$i¤2qwXq,:+lTog63G*Q\ʥJK]6dh]1P =Mz*vװR^>ιw46]q内J63mm޸\d{4[7ƔRViK$m>ߛ\^q)FTԭrEozttG)JNvaydj6øOs e]ƍ5ԔWYe`gVk?m*m9clרˉ}Ω{gvsϚѓ0Kzg FQJ\m+,U Lq}j庱"]r_AY_=iWoR*⦕Ki5Y9ǭe.XTa*qw#7f+'9{cR<3IX$0~W폖9?*9ekI$|YX݈ܨΣ$}s?rRFWMeE8yc9^#~mmȧu /"X}jy(]iԊJ\oY]a+zsS(˗F|B\ 0*q֧%&GJI+KfWUڱ7s~ɤiЖUw0K~l,c0 3vVu)6R/b]!sb?N=+9Iv9hJg̚(stl[vYNI랃ҳRAy J-nɄm+UF#{qkH]c/q(a8UJRFDg^ݰ2E,*Ԝ6W_э}~ta]gvֺ(2uYyUf|ֺ)#4bODڥXpr=yM={G dywuS9|ZQ3>I.#Q&~v @zåiɸZzZ^UE*+*nMrQM幕vQ" ӿ~= rW@챯ʁǏoz%T6Ql6Q-.1i(SPIfb s*rGJXE\yjK\Km;p5hv` #`q}8HnKmٯʳMusU{)>Ҳd ۲vo Tqrnm꼭#]+uI-eQH`_:Jo}oV8y9NSJk|SDK34e;P`f@@qEkg)9;+~}l9)9.Eϵֽ5B^^F']@!GyU_Gj5#U–#-:{]y:pΫ,$ $'yu}cܲVV}MzR5kkֽiz\.vN=Saȶ3*(Y+ѶG[Hm0C#6IQ[NNڥU5m&Ӟ 61G α'ܸG}='x"P+Gqm-soum"V21ۃVU*Fڳ/SNhf6Tm6q䌥NTa7WY-31ݑNUtݎVN՟InJHV(YSTEsn*Ni}"ٚ&I-xӌ>#g8浄,w}.F~H6Ilz܈:xyMz7onXً+m#n ^ⴧOٮkkԊҠ.≡oڥJ~Qokj:%$e %:W?J>,=.ݻ)|aUH qxZu9tJΈU*Y+]2o\DD:e~^HOg,U8Դьp3j/,Hf %Cn2(baEŤL ǵ2rW{UNVgQz.ye%ӕJa*իsZ m%ĉ9#z'XR5)9IVmd!^qF)Gz\gkKBBа32eg8#g%m(Q}\d@3#"n;@H>cZi]Ϣ+S#-cm&V~_gn6.v[:^u&.֭֡gffOW Wt.mFeUJ-F'2#) f,V? qG5^}oNͧ7EY3*HN؇MOZةM~bƤUN1K,0#4y!igqe9H'ak{ևEYSutFA^ckU:7gJ)j6ۖ8?씱;EQ'f:5efwÚ-Cty^c!sY˒U6)J^^U¨.n0k:*A7v^WI9omk!`F֒[yQ[i`rb.v9?oұ,z1"`ܣjFa*=9ZTt92+03[1lay?gaRZz<bw26@Ǡr$s%޶rVFqc S[jM;`3gu(1xxTn%fl,aٮWNɧ9|q Rz=#an޹2OCU}Eө3I4I3ʟd.C5k & s)^\cyVBH"?YT*7FK{bX~U\?Z9GBfh`{T9,LZWqlaF]TwLDiϕYcvKe>cm6*t!I r0бSe_!Q*n^lV=]m_hW#G$*Gn>`>E{ye[p{J4i7}}is[C&,$OHbx8r:s]ѕ8Sm)Ju%m a"M=:?6A[}>Fܱe{nB$ҟwsE`wuR1fxyr-m$II8as#޲.Mg*N)K_ܱX^@R8+<Q޹Z^˕~IT>~= +D(9m%aCϷҦI_wSJ=Mdyw I'$Uwj|6,aŶf0wzu{uKcNQMرii¨2SIp1+IsKcH)5}틠 [ƫF=}-;RտccpX{lw4^o_c%i,74=s0z:/zv8Mkn]/^jwm`GnzRihʴhː#;)瞇 nst0oGͺvhFTU(i>DM6Mo C]2J`Dn|$өw{zz8Eڑ*$*:{c޼|M4*m -v0ϭḥKYS;֍NZS`\@D4hcW^#7wdʶ"T޺!a1U'5m/vsҌj_RY cҷ-XIדIeG&uvNVLƵSVOmV')}rݮkTTo&5+`tdS5+}'kFj,dm`kq_5#xA4f.K36Zb[ԨM)!4+5R"ScRɖi#}kQySNmoI#?J2iEirh^J;} P|^ݾ݅%Qz?a.]΃6G$H6]<<2;}j8{?#H jRw~[ix]Ծ8e9Ww O%pN3={*|zzF]:Vv&kr\4nHRDJ k}kr^[uz5՝Kn6b"Y0ܽ99~#[5P,SG-9=0[G㚯~mo;9p!$Α| ңUؾWr'ⲩ){g}{ʟ#h.MS-Y|=wj]IJI8>xMN/Gu"f@`ߨzgstBJ~s]zc $TqIM;q.u ^_>U|L`Ƴ6k)UM%̍9?t۝m>ǭa!<6MCSx9 <ݪnjV..,P*shUԵȚEUkCnP$ UҔyz3֥h+i$)ryį(tF*-ԊF5d͐Cx(ge}|Xd0dH_Ot#F]J$:?.zJIIa^y|ܤjZow~*4c#Q%7-58]>l,A0;V_c~ʤS4 9v Ut=T'= =R)[}iʟ57/DMi3Hz+\]}WZmR5L#v9 ˖dzRUٲ8Edw(Cpzg#R~/#זZܮYl_UR+5TjT7#heX8pH*guZT۵ΥN277 U($6+_#͎q)}4~!Bﭭ9ScF.@6$z8浣hǙc RRZs$7QYbf|??Φ5)UX,Z.ҭu;fݾI, v#4IVjtS*ܰ_{Ϥ,tt%m#9s>~ I|:rX%{PUgqAn^9rZ1ua,Yʲnmd>'3Zkh]>tHoޝW7iiYtCLXJWovLt K^Sի{ M͑MLqǠ&ѮY!Q~n{&k/dum$GJIakv`$VK^7ҭ$30q,GOV岏R#.g4C!QJ+?~kFeNd۳;WTn]mIr~7nP8=0~JT/ݤW"wdb Nk)k2e$#Bu!]V*:jmcSwM쪑`?6r0 \Z;= 7Fs0S_08拣縶!Vb(sO*eE;TCL7sŝA̎I<=+8Y~# ̒}IZGLApxgח¾Wн̸x>aЯ֧yǟ*N3jyUwr|3,Bofs<)aKЬe O0ƛG;5yGV]O:8IGtoϢ9O"{ M2_*ڪUQX0mW*S}ﯞ}O:%V2}_O-r(/I|Ȳj8 s7*瞞+ZSy[;aiʜ[A-$3\OϢڲu"tOTo'SjG$eTlgǽxx[w2rx=Z];5͉dhpw'gV&䜒5YCqwѹv98=\q碬7ZәhDRO +[Y1eEd}1n1y58њH +21'Wו:izkM;y͞99j/g莜\J\i~|\h'ːVvkYs5TͰWV5DNGid]Ktl"+ cS+mo88ɤ}ЮQiohԳ=O9oVyN6ۧtV& I%|nOuөT`}:_SlrVm{3L$aRd#$x1},\'/ʩ)'_Ŕ5gtZ5 8or GtSylݛtN[%ʿ)ـN*'v}\TTN+T_ tEխffBG29o,ڹaucEVԟ5oҜ)M)+[u;u߇'Mgۧ90WTvU)3NxHNiZ5!x㜁ɯ"T}D_ꜼE[_3ϧ2u#nÖ 8'5~R" ZT+K<SCuI%$̊ܯY2duJhZo^^^]gfwAGJ{JUo-OkY7qE,RP=:<8ѩ ]\кkEz|~TqzngNZz'rU *eG|}7aW~EE}irԥ&vI;>Zjk֤ZJ y0(q3If4zQNY@:#7XYַ:J+R_>MY%H墓vĚfvnmQC+qlgrTB*϶:5FovwgAGyu.˩)P<=k9b%N)I'}RrΝ%xCK53U)YzUƬu9wo]9ָC8xu`Z)&mz8a4J&iZ"@ nHs_ITjv=яӳO۟ 坄2oG !|c$u|i98ʜiSJwQ s=Ēqn7'<^דϭV[lۯe8Mjqe}nס?(-֩o [U`;ځy=0+؞*j~/=ݮsc)*2򳻲S|K1ʲ$~鎇ּ|Rrp,V"J>Қ՜ sݗ|jjס1t$s^Z6TRۭ?J,lii_`x7#i; be*mIj64·6|Bua1qPp׹݃FQ-ߕ#$%IJu(؊\TL2;BfMHʤS-{xcs3Gq.B6^ݧ`#;UX_'rByNZXxJ8λ~`.5xHQS?ĞOF iڕ[4feװ=7^]c\&hd[tGJK/D5@~άα+aKQ9?V*4:{]'J*iG[>!jZF! ,3ghU/>CR稔} _8FZk?f.5k2"xX,36W9tU(;7KLxRnUt?j-д( ^⪴7^F\2 cijϯ1m(3Z%ncko+]i0';r>x> bz4yg%_6[2-tF3.r9 kHµ9^]|#2Xm5ˠ׊=f5QF 5R'2)e@krzz`8yF:Ŷj-}0x5#FIJ۳iO/?f/x/gz/,Z8$eCE*n~yWk]~U*UVi~t}|3e#e$RLIn@ k(u> ZZ_~(мx;|TsR$yU$yef~v*u.Lph}y,^o)EKO_9ww=ZE98Z;wMkսN_gSM6S῎/ΚF=b#*0{hztKͽլޯ"Qs?*_xi|WZkq{ǡV5S[}ޝK]wסŦmWvɸ3*HةְHVzJ3^+u c' N{ץ#g(ҥzW}NƵOmou"i.w 9Ss^ɭ[S)JZ!ӯaCbwes@jha̤-jwm׼+=aWf]]ITt{iХk9|(JơcbY‚;ztEd׶hvEp:$s]~E*з{f41$$Ѵ,ۏ͑}^c%ˢIr+,Udp\w{Z:өRQv? _kl\(1}N(ױSu]Yn$C嗕3+\܊ۜoh>(T֧1W2b/즒ylq>iF,RcUL]DvgJޥJtm+ڤW{&9n&W\ w?g9ETJtceOԯ%˼nPsc[For#N7u#%8 *S=n+:JU$6*5qUG;[lZK2p: j¶:ӣ)[Ӗ89'sfU~jHVt}v<0;xͼRy{r"ۊ5gZr+̯bYTn;yg*?/fTqmmJͽqp+~jaԲ\rA d Ԏ}V|r:1ȥ[o.3+ap? z匣{p盿oBl%K!!l(,$2GCV5U1K=*"*9q#?M:3n{\%VUE ڊ*GP9RqUWM|o-NI˽kNr2*1R+גU)>u#Ҵ\#eT@˱šcplïԌ h8[+$tĶ`Q#z+NR3 U;.4S1JRW[jGqv7WvynXUSQ(磃~ٻ];w,,HE1#'z+ݿR^4ַOigSIxfUiSӚΥlDu֏5>T]=^UGq89k&_#yzXgd[;sp<SOɽGcNk:|U;;V3tے3)*;iwNKΐ[5F#$Y֫˗Ǚ{;R;dt.ăC+.Y_UG.(صA[měwd'2))V3WaQ^rȥw_Ay''=:fӒJOԱͣ"]AϹ4OܜE.[r-,gB9b1Uϧc&e8xh0G=q'*#+%*zofJ~f1꫌}}<]jKRʑS n װel]:ЩMhĵvf ͍NFWH\a!c.Vߏ5i)^I|ʌc.X!FGv &7=LeR1}MRI=m(ܡZYvr?ARJ+M#Jwr!tVn6ȡ'9'<⺣F3rzue??1bc%ntGM:0ΚwVĮ̢Gf U_'ZMˡEqq$I 2(@+.Eu*pdiW2,Kpҿnn s׶)n]ZߡQ{+KVm˶ ^^QqnaKvYL>v6܊ҝ^XꍰrMhIE,+6ݐ>s۟]W(iSu#{% m@[S9Xk\Afh.]c㧯>b%eRuLQ0Q7Z5,סܥd/1ɶ4eET~nZ!FZNjƽ(ͦYfqdl`x=+Zq?z_hjT $IIc,%?,gu_4g5J$5Z߻/qsj} RQvr3K%GFˎ^[jqK]n#"D-w[7$ɽD{Jm||̪*. hHbc8?)N@ֱuE&: w]K y3ߎ?q浯Ej3|wA7IVy[qDsSJe.c/`FY.:O8J+5z[M >^m^r:UqvO!΢q+v &9D)[bIqֱc8NDԞ*d6,OzUY4tF|NW[Klw>\RDnyz{UE$TiqF)]ZZP6p 'G6ϕTi.@H6OUy֫NI?yh0c*сv3yr)',HH79?f$U?v#6 NvW46%R$G ̸-_GIU=n$]kaߕe)JQ"3[wa$\ĨRM I!) A,=ְ/ATJqs#͎5,W~d;WsuiXE٤k)Pqr+t𧩟-j=(<ԗr7\qֹeg*ql#1VDUla6:J咾@G?PcUf޹yd.?4/hnB}d:dٟ~Nyy̅LS~l#onk%):J',ç?^ ʵR2$޾2Kfڻ\^cVҏ2&P/+_UlmL?+"59̕2)y%3,qF vp}zt5eEJQ~42T2d:rӍ.[H$+`z}ErJ<_ tܧ$=r}k8-DS>Dlq#]0%~ymݥ)?wFD;iGY3ҧMA7WUbmoSNf6"_ ј]Y(UPyq7=3]JӆJשF&yEUfátF;NZ$~Ua X$˿獸r3k6пm'E[4q%w^;O<ڴd]Dȩ 571 >uSϫ" 2Vn_3)~97dSczT1uW3+H˕@~vR^rF40TI0vA=-E~PfUTHӯ%Mk&u)VgeFK 1%#H+OPr1W\(Y-I\EKodӴK(o:Eܲ33XEظ]՝4u^5ə_rqr㥬WNkeCl1bH6YBG=+G,c&=ѹG͵,k',;{iN:#*ƣIhG+vdFTWt?s[{9JzJrY~eվĮѷwykXZ2!M%t^PUv˸e=bxW3Ly8cϱjN16i-te@az ga},TaOТ׊+?ޑr}ժi0R Y$Gڬ'J T!ڣ+Hsq}h>iYXӴ-LJ+IH; [- Cr2C䑞hoS QʧD˵wțJT=j%%qw&mvSӾSmP&.C>m{+iϗK F࿝FEb(#9Tf*UwBK|V8#rҒ|ѩkJݭ9;KfMj[$!`*1yT:K]zTj{MwmR bEA}ן9JZ5cWkfŽar6jwZqJnZ;R˥M$rpڹqTdq+}kz{O[kbY]S7yҫ4ڶzƜQSIkm٦%ټ]rz*Xr*Fpuf2Ig~Y8,s'WE8cOݓMv-ZC+%*#2qޡ֌!'ar6sB[5B>mc>z0R6M\2],yBuщDw~ZzJQN~gkj{LKHfܻ><9_U%^1ںe6w6Ho⌱8c:*kƚjH4jsHr٤Y[u)T]!o1 J |9Et3*]meSշdӠ"R,j s=21͈r^Wi$o݆oq=:gSF:!JV=}B\Hao2Ķ3\sjS#WoM]oiFɨb^r.'p,qGUU\\ `wVWTeRrNm,W  l͵UfaSʝMCoxFOiuI#09_ILt\|-\UGRZugEm}nGʈIzA8b⟝XLTqkƕ Fu#H9:qpR)JQvnd6gWbRFV޹'K+Ft3~Wn=u-IdRnN$NAǯj֌JxtQA5mNגFݴ$pSBRvR ^3?YNN{vM`$pU엝[[vLt䃞A+$fi8rF X%e}F5qrzwyy֒=Dž)Nkݳ^DĘ#u܏yd컝ҧȹ~4 hs$2g#nӻz+I]*d+ީcTSByY=b=nnJi[_Z4>ZEr#b'u9^}whZ}HԷFfE\g$WY=cN)uཌྷiJt_2Nu-ez֛'-JǹFEc|YikdW` ؁E(טgcO˼WRGN(dzME8)瑞Ox*JZFWY]t=SRe tm#Ldzo^5XT^𞂲eYS$ s93ri9-CǞ,iMBi!$ee._p9σz1~1тY[{4KY;4?Si-'VBcDY6d|uWlS_#ܕOySյ7庵&fP}+vykz4~MFZy/átXUYq7_s]Vvԫ(V?7^̻b9<瓌B4*rVe'˹x[ZqZL4kw( |f_FuNۡz_2¿yC>6 nF~u'|~am8y=}_㩇㏂[Qliuk?9?SZ꭯SNMm;ݏi_%4v1 ھ!nհAFu* ;H,*8|*xɻrhջiU>rrj_漾wk''[MaVqf"I'V_^^ 7)vi&|J浾z2ա]dE#Ҽ|W4]tk)R'=u"yv3 xیW4SSi-Z`3?-gǯ4S/"+S ֆuԍ.|F[ժtlތ/iM"kIX J+qM؍("G)'_X>2{vllg]R 6{8h_R)l)k,aKpX`>ٮzμjrr,DrHJL>anXrF䵐4*Iu ?eR>+a{6;ib% PGlt}kgF7woaV4[jNfQFtnRNpry5N[KCXòXY%pc։|݊TZ7zieZ\G$V6˲Ҋj5s:_`E$̍tް{rcQZf}~|zTQrkۭ%K3HmO4*vr]N1mb lg}qZJ1tzzQˠxq2{*rqR˪*4jE>ĖJGcֺN\SFRJKbsC.-đ{x8QSrkN#OǠi9dUA=a֎Ǜ1P=liZywmN5hcЖ\i}t VyrnBO sgznbsE2Jypܑx=ks|a.}[m Tew9=s3ZWvCXSI6ӿZrDZ UTN51bO_2f( qEzVƜ֧$jNߴ^нc'UI)o2R-P,-30eʱV:_ҹoEN/%%fgn\$u'ÿn+i+>Zu%oj]Eo8ߌ~5hӌb8U,g5OumI4 $o$_e JyJicMMv~=Mr1up1Rוq;|LsX{TKRQ>53Gl^0vܤ`An8w{klne][xԔT%v\Ѝ8ֻVkR*8t0C$,w.w`F?mےwI" EUYYdž:l:#/G_̩SH*myLH~Oy\oiVgh,޺[r ҽ ߏoZQU~⧄!Ub.TxޕHm. v_1He'\A9k^C>+дmy$o-FF RIю->Bݷfvz~U.v8ok/ǡz#YyִUY=5GDgN$\is)N̘\}28h\`zԔZgh- x6G$pO2k22>e z}A'eǶwkЧUo-LTp4l*sAһJҕ5=iw/p0-&ӝ襈SRcV*zWPho2㪯vN:Tk6']K,ǨLTBy%8cVw{Jբ7bgXg+ijKnXr7QQuC#F>^'uy3?k˼WaEp/?͛c+?Mczn>_"FBS)NR}h{6G$< tX~M>3Yj14R?l˱i< Xq2pOsQR-QnPGIXddgS' Dgd+Kq%ĥX_i}+葼J)4d\]gWlnr8bs֩8)\$fg1[l`ap;`ǞՄI$ݵ'S2 /{*_ƣv*]8f 弶*X'=}p}+FuFQwj *#ȟ18}+hԗ77vQe'ٻkϿ^hIE~Cm7"os+hS'Bc*"b,r9$d=_ĮjKwЁeeQ[$`1h}jQT}"ՀS]fF巙\MLJwh͖XudžYG;13S*1nnϟݾޅWՄ.NVł+`_{kf6~GG,c"2\9USw=s k|rIggUHb"9*᫺fI7{qͻ6z~5n[2Qv2uA66¸|9ҺS(˛'-ڬۆI}»(3hԩ^ކŲmDR ۊ_hW,oKڄy ,)t@O`y'vSlN|bj-U[.7`pzm$1V)Mc{{ZJV(^jSf\ HII.Iϧ:k;UkNkklt˜sIsEϖ5v2/*WjwkYyDiΤ|ն>&lqD34pA; rI3.iRmsZݜe=Aog;{SuԹJ5ʿV[o.!X4?;nuK~)Tⵯ kt⹍diǙ4(80:+UEJNr]6r\׮xQ yEǗc%\1VrR.N~MG]cėcU9$]gQo}pWF27=x֑g B+.#0n}7gߥyTkjyM릻KEo#nr[v}9kɚO/{KGCNq<]#(3vvuk7-bxLn'.knef7-' &F.xqNA-v{Oik?3z%613r1ӞM'\E5DI M!Uzv+jF[ױOue3 n@S8j/iVL?EeUTCrjK2ӎ=X]TE(h.4o.ܓrɮwRhՍժlN_BHz^VRRO{Wf%55ڋ~rԽn*W(jӷq PUwK?Mu pw2Ēsz~Skc'kK78wvAc^RkO޶wخ֒:2"H]/'dc:Cu$+49vVogMoF|0]V(}[+@f-'Q*rw"(a٧"tdV-qVjsE&rc^\vbGm"%ef ,.yǷ>TeS᎖zXT}v9*d´J۟|81{;^Qr5uc>2m3{cӓKݽ:SUuF9 77EKG:iTD{fReO:c*<ӡH]1REpj'>Te'=Y3ޟQ`FU€^5Mu9k{"- Y!ϥ`SE= TҳC-a̭1e>ORN;ZN% }vcF#*m rzYB2m-N:ya|<*qq>hK #mYnZ].4n^O̐F."i(.v8ڱ2iԒ$qIi䥶58C:潺3z*QD)̲RI#;##'sW/,*qU=FnIv]ZpcOvuȮmT~Vmc'd>]08>i(9dg?a"c@6:{?^uWRMvjn"mvH}ū#ԋmhB[橅czǷLj*Fz\n"t4̊ $?jU)-nf?y=?LW,rJ˩NIB{ aP`YydUd.M}R튲L٣Es1gz)UyyWZXSWO%mŚDV\lszΔ]+R1uURYѢO52_{ް)94iMN刞X=s1r:Tz~qkCn%UQ5Qʍ:e]2/ɇo/vArxj,2j1A6@[>I{DUj:J!k{2krn`$95̵װɂM"Ǵr7Ǹ9F7o~jz/P+w 4q+c$^1MGSΥ^[ꌠDS#-[Ԕ\}^NU*3QZ%&U Ffr(tmrY΢t'H<:w_ڳI jŵ/;/ra:yt_ BG8ݷ'>ʼԔn٥LU'% 5I#ZI5.߻$99c*e;@1%iu*鰴>Y|ʹ50?3Kݓ3xrԏڷ$ڤey=6.Nػ.d9NH$kּ`01]=OBZLW[V5153O_J|/JkE۫l;ĦI$XdOOӭa+MȫNdQɁ/kgTj{;ߙHmGGAi.&m"HÊK+_IjqQ.\zTÖ18w ZFF_H?Z|](= Y#ʔwWq{dS;nki?z*.k:Hʅ;pHZr/i))r~ r) Fī7#x *cFNL*svOC.9934Q^ż}\I7 fPkrpqӎ7/4pjE߷C-a^CI|vQf[!Y|-72[nnZDׯʝOuv쎓D%I5cnw9y?׬Ӗ."TH W1C*}1ޟ3VPvoM;:+ыZ͍?W=+H۶ЉP98ssϥ\ZtSZT᮫^c].7gHy, XSjϿQNjiyUfMETPsG7fJ)󫧧 #e-%q*yMj`qogO}/FS7z[켋pm3OĻUO#8:S\rژNJ5W2W&&x8B0@9ֹJ1W"*pꊳkdEܴ5I> n8[gޗ/qVnoqW![`fWλz81"T/{CJ+>νjuUć;Bg9ún1OiKj[fͮ\2UUJ"Ň : <:K}ƌkT'>EKXm _xp8fKMfM"Xٴ\nT}־ϞI>KTW[ӵ'^~_ݰ9^VN3i?>ӣ%ɭUVҵ9'[|_ 7r?U#/g%mҹHϕ6~z/iQ{CTnicin}@yM.qyRW}S:ҕ <_WzƳazy *B#ڦG*<㿱S﯒ظƶI$ϯgGS•>dO)54b;~if=9'vsF/V~GNLy5I'd5GZ'{э/.h?ieH22ubsg+qb2)skCcF{;uhӌ:g&兞KMž[9SsjsZgfi L"Ve yجGG)G_[}ߋGE,QRWKp~)lRH$y߂YFHe\0EwrJMY2Uޚ7eqZw+_[.|KX tG.lpߚ--nt= |๹YY21S&s@·>|+$~G㱱G O o$Wѯk3>QH9=5k:\C?76Go%`w$OH cJ]w[h{'WSNmZ=u=MmMqۆm㏗ƲK9o{ouo}ߩcNnwkjzgV.ٮ/YGTobr,J`qN;KGwwծb!(ۮmomZ#G3#/sѢ.|C|9`םc).c4Tmz GWaZ(Sǩ%k~.%lh*3giݒϯ<~Sӷ}t13ҷD3g·Dnk;.O==?׶*+ӓ\Ϯ8qNYa*\|Kt=}x$X1O٭&m wnp~ʹ{FK_s:BUad,V|sk\ϸԌWlqmulm9ǮޞW-Ҿ*j4kEʙ3O})ּbub#RI^@c[Uܛn?8ҹ9d9gķۉ̫3GoEh>ZrFxXWlw$J1X#n7tj.XbYm eϗmÖܮ?^+5#ʗ _>ŻxlZAU#nqsY˕] f;3j77ncy9'g/x8Ժԩyc/1Ocn֜e"2z6wHѩmh{ҔjKh}"( Mw=q3M\ߵGnݸ甥#;#Gqn|0 7^[FWE*]<9rp -{i-e˹-ŻG|h8}}huhڌZm`v*_+|'u7(A(V36rs޴su^0Մp̌IJQQ?OΟ4heR^%$;H7灂}sKwikmU_QF8[#+#RN]"G8"͜+2;ح\_5zn 4bVLcƪq8:_[hIz6=Xr#EӧSWfK}I-2;I?tz=*>:[[l~o|gI_ A`۴ʞYst} ^kNU$}Du>-\FsdڮgiO݃0Vu{M'txNGfh@G 55ש.Zv]Zj/G)x5 <3c>݇8һIotajRvhi[$q"n)yjD]:nQkkk3F:jjXŦ5,̧k.3^TNKC͎*kE8۵CKϭZ5FȿywVF7.[Ewq4U$u&>hcR&BġHcziehw#T䇽̮c?  6=9=Vʋ|KV!5]Ydf[=y>)QFHeH)?7P͆twZ[;>oTKz>[9<Ǚ:` ۥ|#2U}7^4$nwK񿃧E7{Y~:2rgFMTG#iZc!\vĤOo"Lj{#1ƹzv~Y] S6+uܕ՗Ѓcu\\c7N+EwCua-4jtt÷=` Ej~ҲRO]v穂lT]WIvGk+mUƤ-@|88#tgQӗNU{[EY.,rVF,tI9RU"_Z[M ,9-d6"?4MLz+u&*1$ Jۘ#LCps+ܫ)%?~mg#hTJ:;;iaiZޒ>][ p_@{u2򻫻_xq#>e{&+u;g%ԓ\_9v#6Fy 8 'ʔRo|ޞeu񑒝*~.֖Xӭ6cQn'@)ܟ3?O= Tj_/s|O>I"+"IMJWh\EZ1=,ehwՅJR4r^, ɾTvݛЧ*VѷC/ZZ}ş٦K~IaJSVo~ߡ]UWCVkqfվ0`I:tU~k٥|4_k渚5Zn͵t->o_&ͤ\7=ND{zcn#k T|jf: h87Vƻ㓏mG0}Wsr>-fa*qQp<<5xmu]5c$ w{hJrr>Z⫶oY`3sd{ 5Tq9?3)4wy n`͚E2J9kg3uΝ1|عf8E)U_y>vrLs-$=M|RRn[X7+0|O H&*1+/ A׹SoyCSչ-t;='Ű6cF}-:qO>g rڕNLD6}GL0F2yr1*8?OvNzO_ [xƪ}Pq9p.g=jn[~G|kՙn['ww9#8:~iO5񏇡u+F 6I qsYӼ/{_PVh :m>8)dU02wW*t6O/өR/ ns4 ߑ?ҹvKoSKvOMs߰Hady q{ XztM2Q;K3KHe'MA k,LXT:Kyr^u3=*/0esqr6{g:}JKaQh͵o,Xmv1{׋aѣ)E0򞱩j5桩-m;feN3צM|lg9EKՌ TkI 4+Fe[kVݻ,~ʌܹڜ8Q妛G\FFVhv g=cW{Ӻ54\eDvE媦FqZ"Z Krѷ3G )qF&]$u#xm51\z*bEt`V6l;`~UӋF6k+Go0 ߅ru=QXyo,s><x*u4۩(S?g-M M8Wj|9?ki%w y5<-5/> $y 1 ܒTdt#"%J2^ԗ}; L3 ۔xNN/XQ罷KZݤu\mOL¶* S˲YI.k쏔sy{jp\ј;z$P)y J,ڹe(ɧq[RV~`Nyʧ{c*w]ћ$Tngpy=9;VEJG#U5nY慦xF[N3on c?/Xg*]($9? tncR)KMӵKnu*sl}9ӧ ]X]u;ՂaV]VF_J2婱;{!K+K $`VנA׊¤dsM~?pjN)//Թ\ L@F$\eQ4ݽ6؊n vC샇5hپyZ1=A~^ur7wK;)ζIVZO獼>GQV2qmҟ<~IXė2"mmbpNxce )Mipiծ4""cMY9qߎj^y xʌ~h`*A;9<ߝsƚNiyhԻ ,I)aTL+hGD<:\ycs,l}sVs94Z<ҴYzt[y~>>ijH̡~f~NqraLnC8.OLϧ֮ъ+潮h@r$ffVVH|0*FTX9TJrFrD֨ Jgrt/lJur߱y^5\VnV;)PRNAʹ1)_oNݗ8%vD)Y{5jDv֑,);ӚSmKnF0u#MjZd[QnC{cМa$]HFyڼK$slXOb~>J]m)XAel1>Y}!r3Ȫr٣ϔneo͎H ;uDc-tNW'n! tbp~Zki4yyYWr#Zd>+>b%eRXd2er q~<2UR1D)+F_:UT?sHɹݵOp2GLP)I_MRˉP61]}GWƻ#o:*z猂?/9N^Q.Ox 0}'kn݊RK%F0Yw1]N?#'nXл,| 2s[=$*Q0GLzxRNg/waI,a( $t8 ֿHǗ_ Y )eSRc AПֻ%yE[gttMY=IQ]ژF˃ r2@3姪w*,apߵT/A=@Yͫ)7Y9͓~,\rן֮jzF-ݺr*iJ߉uͫ5Y_!wd'UH_xQS Qy$Uҟ7,:*J)(qgh1x|YXڤ}_R!5Lqo qtW"(ӕh([̰M̓K7gspyawb+`sB˞ryZrmRgXYS$ۈ8wNܯrh^9#nw2\9v洗,J/GsxDlJqgJqT*teQ+&Ƌ"@\3hWATԗWs}|i#;CtkJt=nIo 0:YCyۛ=F;銔UUD;v.Nr.>q9+@]kJ[Gc8,<8=q]ѯF%6ӵ얊%XWI1g}(/n.^|2CWsHJQNWH0S4sm89eƔc+_yi*08<7t⽟,'SGmm34c8<2r9MG!+*u?aԧVnvwq9ߵL'k"޻pSS*.T+26(Qݸ'R3y=IUwPNp9;F{&1Q5'wНnd̎C|(<zz菻wV}Tww>}Mb9}ior .O5UbUI# H9?QTẏ:Lkt휎cC7q#E!ulFDqy@ˎ]|w4=NkSي<-ZHCeI$pOVn+u"?EDkƪ0Y':Ƶ-]}=k$4>Un=:RexGXHXݚE˜P3ڱ88r;-HŬ,v]szL~ϚmV$̥\mF9tGUr4iV9#>\nV?˂(얿?sG|34 -PwoJʥ&m(B,/Q-Wp{~9ӧ5gN[hRPY}ϸt1 rmQ6o]ӟb)ӧF7ztRZ]R8ZIL߮k}:cN8ڭj=@j0*e#uMmiөh2(/f+nc򮈮j~=:ZsڐkiRxF&eG9#jm?W[vsI0Rvn}:WNF:X5LS05ci,FXI*p W|eQKܲ}VHO݌/nDaKs٣Vg_0~Az닌ݭ:?i7Y^Lf@Dh{[Cԭߢ=Wyi,fy`5ܩaCi+2Ly[6F<:w5gRIIGEvvhrvv)Sۓd3sTebLLꟻ#}p J1Sfޗw#쓤)V33u{~|#%o!ƤɶF"#ݜH RVh#yiWp$;U~VCqɭ_R״hMfٳ7v[$B,3Us"fEF(MY`O?^~m\]G=m;%f Cc׎9*T)VD9t'yĐo@IOCy';W77Wr]R8W,i~u9S7m}'KHʍ*jziFNVުpw\!W 1㵎tm._ŗSɍRWQr 6^+Kvo)wVaܒ0s%)F_w[re.JlR[KLA2v]k|kZ=wR寙,1Ib{blN5&]ZTJ+X[^ӰT 8:u TƟ,%oҳXh+yҹ*z-Ir_eۄv!ɗuc g:W>"RM>ݒZ;DĞf@dbjJ/6R2kG/Jbk>`<1Y×n>ǕS\ [0aRayqj3MpQܒ!ߴ>^ozugMe<XBz\R;yKkZ"T*<hkF^1/O& w/ rcb} >N7FOVPxPȫ$=6ӍNCJU٣;Yu1;p[v[9ȧNc/3Hʌiޫyv\Fx3h͹$蓍:=L;[kY&Id |>ʣ.mps^Yzkw ߧ׭g(/MzӔek4^X턣ap7r@9="eNRZf>ҕewH$a F?(R2[LIs?TSVTV0 `f,zIҸSi-}5(7ތ"=Wp`V^:;հq}$͌b.{u&G{\ܒݑ=בWY4Fl[=I'I.Sƍ5% yоMٺec>*qև=j~:[*^Cs0;sVRv'tėp(H5P!#zr?, qZޤsRޥwˈ;*SqSr-2.¼d[֧S}:Ȱcl{B#sc~:=t*"Y:sV}/'/Yg$v*>Z̏h0K3F1nX9sݫ3V2c̚8bJ"0H?(߻U{?@s]y-:*I7u; eht/ O.IXćYLzҔT o6#ݧgپOԵ_i V6VnpH#kS8}6Ks{*J4Ѵ5eqX4hŸ4qGZ.qMwn9-a>%'4*c--SD]N-#܎Bʥs3)1q SwVT9-(xa#S vV)}#Ӌoz1Qf f<7h q$9_As6pѫޯX%-SsyڅΪۗܬs|zqJ^{C{mZ RW{R%ݭ VKXE3@OJ7_i5ߩ da`܅ WnuN# of֖~bMç UlrۏW?4c=UdJ!cAiu뻿T9Τ݈(|xcUx#Zl|3֣$@4~"\ѨW\ySѬJ-r2nxJ2c3v~o+(RqW#M8UekϖN>)ռ)ٵ98NzcoUP@ rs5B2+Irpf>uӥ=5}вv!e[w׎Rj;[#[#2v͏-W,OoT& ѼtL&f꫸qzRXe%̙'v!Uʏ.6z*ɮӋY{:KBdG;dXܝ}ZJiqӷs9FW֍.$ vUG̚~UQaTҎ#r;dk{q29\ϾFoOtӧE6OK+w,yO4@i'٭-bO~l9J4McN74.FVmz:~Ϛg /mRnƒ_3?.ON5LI#F m38Mmzlyr.ЖY;iD{Wk>ٮOz2Am˪RKrR2hq_cqd#ZZ֓qv}͏o)`$ 瞙Şӎx$lPb2fY00x͌B./-ew^Lom(y2e<YMFP^WRDlXIE(+{I0rʹg] rO#mXFH<.=zUOk6V"FK_*v,Ϊ '<±Ҍ[a/b9A=cu;z.r8=+i*FӼ̚mmr?ԭ{"%yZV "mPЌFOISK޴o6[xdWg߼Y dߜn㌥iU="I/&+26\r?ۚ69jBKJZ06cFlASSVJ֋A3#y +;=MI1jERn}rե:ʤnI*4FP<_Fb'&Syǹֽh׏&a*9CE5XK+/ȭuQG=Fq=QbaϞ]U涞!t:iѼŵ-$]9^q9+'R1]:aE 7c3ϭvG:~mo_О[~"i 0 go?+.N-MOg)%ؙv%Y8ֱGkiS9s'tOuHk3=ic[+FunHϺ?۞ *TpG( MMxK6H#*Xj"{R]yM#6q>EMrGޯm\o sRoC2:j{iI}h)w cc_jR{XNvr:H\)!\2(򧧘7#)߲E8f=f+ӓ竎ϤZ2\,D>lݴcSNXDo帗|QYˑ1{:GTtƯ/RJ/dqNx!Q{=F*'&%RXݴ4W7O@1WMu3W#jU+T&i £L_}ӞG ^jIVwe.Q~:P.e$TX9[kǏ=I8ЩR1QKOrn#WWttṵYJ {^UǏ~2VޝH \oaTtI3mLuT 3{cF0ԸsV7ЀZ\.Us/3ԼUy^jrm$*$ԥn%IIFD~eXPŁ+ӏ›+OgI2 Q岮6m9< u<_?3-Ee2f~Xc*g~?J*|0+y˱H, )Sʜ>RN5L;rWk]nUFH#_)‡}1'D01v"%nnKo<-oY>V'P{\+Sj{J:kNGlZKcDM)Qn3бbY5Y6сOnsiSicNF-.dVVh7rGg%v9U ?$k:yUT[R*NJQvKYUٔv~q5>Tu2@V7ȡY|0H8 犥MS_Az2(|7pyVq.UZ1 +߉鎇ҺQU*4C{oc -cGV|.dq1;QJ[l Z$oڻUhʥ;h:wzݧkszs\M>nSs9J=5=xi)YXo=ռ17vyMn]H(Ϧ.p#e ׎u5aTU,DiIdȻKpWrr,99f#jP_"pF4*،@1ױRtIuQzT\]}ifiyS8SǺE ܱQ}:_֧J:r)סiYHW在*mc96zS]c3L=ENfV*[v{vr!]d6F,yUٰ6w-T*uN%9ƅ89/.5+X-r}v̇sDv*{7.Ek.iN8OX $6j2#fCO#95%T*hIcsjk6+y})-w.^}s>Sd4Ml[尬n sc}^{~gDceV7J<^%kK]1e*~{㽤W,S )NvIeD_H%_${1#pzwׇ~m'ʷ֕Xݗf+0vqeV*ڞ?cR|DkI5`ysӊ#N68G/V#gK# 0>]\RBaF:#"[GicOAOJI+}ZF3@y'b1p=c8^K]6 ~亯eXA] Alv?rt{H֞RY&̰%cGlf*+N\fQku#HWX4ǒ[Ǟz/Md[V ^H#=UЊF:+ߨՑ?v>^srwZ5z]g۳-UnJ#;3Qׯ̬~̊N?g=5ZRJ.6ZtuHB~^sH1hF ȰF~VbI<ڣQK^Iا .aY#f13XJ`$[F2IbJ`8qU#t6T,EҼFu$HO|]x֎U$h*^XRF >cڣ}kT䊌V݌zZ\/Ƴ<LDc ;[a8fjxyGf/ح̑{,[|D`n8Ie|j*9*FN͐5Ǻ?cWLkWr#V:{%r; F$*$ԑzMЄ_*w_QVToH,HO%UKC%uli?ÑTGMU+ΥںnndF qϧ=OKQ|VK~qjhGz>f] Q=yڊђBeZ=NDs}#ll T6Ea*ZNO%-Uc1,9TԔh^r=S\]Lۇ ֹgRJ<^ӠR]t;&,<-k9__bRi0ânO㊻ū\s}M:c`pp:XJ0DM.ɹ n۴vٸ"jXtԓM;۹j(dJ2+3XRSȟ0_,|a;2. '#Q){F؊є8S{Qo?}Ğ1Q8H(}? ;aCco*:~jrIJ^v+,jŕgִy}ҽKy&F9+˖V:1}R5@ 8'g-$9֔ut5+%)6AUj~'5zu%Gg [ɏn?HZuP.'8i$8+=:uuOBfS89}H܏8NXwާ=Jնzh% ou djʲ.ҕ$^"oo+yϩ̪9iajsI߈{t Dw=j%|]XҵE 33GnfǷJ֫KH ITFV-fc|oD6'JUgR)-.]5pOwDXYgrH`yw;lW?,w0b+V-q7d,ܒI?c+$M 0tezn&k3G V2|͑_CeLj_2lR;œ1u׶(WӽOk,-xFnWuV1嘓ʤ#Yt݌NKJBuv涧Ej~ Tʯk* u[Ǖy fj2@.ZqqN+jq择':;c(A;B#gf򭤣*k4U1mZ*;HCz rSyF"QGmn46,XܾZp9gۚzҕ5wQI ^}uإoբ`|kG4d6}G?Ju ݳ]YLiK Wri< vV^u#Gs)]*UvL~T)B5/.֦TOvZG3Zp~δԫh./ٮf3뛚N)VsIE ne6R=rT)?(JiE|m{_-9+8SRgf"i)߰յ&o>Prڹ%){Ts1N63Ǜh (5'7q(8TMM#J[ͶNUq.A$`?%uZyqUcuZo)$?BsWZITQ{u= s*>΢Wr; oU8g{OZ槊kbc5~/nfrG٣P>f'q׌u8ŵNQ_vF63F%ݷݫjxgOG)J5'f=;2#y(m xC.1oAX^+ϐXlA^^DN4&k<%-:X!E&fUI{q=zcޜ*۵"x[l7;zW*;5)<ѳ<3+lafY"#A\ q=U8j2NԖϻ՝NE+44qlUi1ǕMRI^<#SE~&Q-21ʻ} ,o#X~kopIRe$G7ӗ/5} =]eg$r:jT*rI*9k͹j3y"1#L%V%_?{#CA}7;J.mCV5RM,r~4an ӧc8mFaN6nFaDEnKY3Ӵ6ՌaZ6 CsuֱOݶ%IKO:&ѭ0 *Sފg*iSou?vsϹ EO[P/g-H(foo 0J\9]NJ׊е6:ITH ֧ފ2,)j^L1'4ϙi**sڳ`ʬmڭ#Cx+bR[< mS~ՠTuX/+n :hkLpFUpƌ<ap0' cv}jm˛fݺ>ZVWE}i^ K5TR6w8֧Z2]rnvz.n[yj[kp상<~Ӗ6~+5mreݺUwW20Xp=ʔ;gEf~+UiHsn3 I#ֳ%'X2b%|2& ~wF7{}ᤥ6WXIcIO,tU99cէ:G dO0+ }2?jR׭/eq&+쿯1sI ė+CBNr9qIrE_^Zti5N}=_Zy̒?i!'ynT'rְx\J{)FwZ}=|ؒN;{֑Tw#,?*k[ $Mɸ9]ҼT6u%_+?am?U+/ܹ>yێZFR'(Ίk{Igkj,Ӳ,r-|<p TVo^FAiiDsۮ@HrFx[{J6cRH|:͋/Cu4-0 u191BQI~5nsm?#u=>H&Vl\mo>Tԯu}ޭiEe@#X7 #)SrC.Zu*^КXy!yrgbN8$wTy[srѩ6}G hbC{'юGBz+Y7„*.sfMkg?.>\ߏ+ǚ\aN\b\%O1T}9 r:tuo_OkN<xkHmkǂuq{UN9TQqSu{“[M X Qhɧ}42U*{] _ t[-%kH5[9#cێlF"bw},ҥ:qP^ﮧܟ aVrn|v׿_*JԏĹJv׿Bň.eQm5j7n- P5`M?y7rD}$kn5kQkfuwG|rL&7 19Fyv-UoO<{;ZjouϺ߁w_jel\F-Td p8 nWFrQӾv~і"1诿}6h}vUSO BKER0'OJjeb6}ZuZJRU6t?c$5IdzwŰX0*cF8F*M6aJ4}ziӿYmOPWF8eUݵH/w/~F:i{u2i{}RT})|=&]J~~A'voFq8_E[˿ki~ ̠NKDgk~|faH|ĎGj3ۻL{hVK prq]4C ZK(cY IZGbә; ]Hx˚P{5Eף<,T[}뭟yt+i;^GT3׫NN>urxRXm^$S+XpA3kVrW~?Sȭ__zoŧ.MH̅ p?2zs\xQ嵭#3M=<=BesC7˵8 |H-|l4:\#Yn5H=P8浤μ$)i].p~,y$_9J630Bw3_IO^3^0τ,,#1cT 'uҳ^U"k2NI־Ộ0!yGˌ;yWVg8Is#n=WSGF>OQua[W<O8?U*sQ_3hSuNG*ڷy{P0pp1>{6=˖[Tfmڣ:Xq˶4($+3sVRqy'{oе+H024I֢_1fs. eFQy5.QoDkVl;`xbBw8]7Oc(Ѳ%BD $ӵa)+$Nr|/Qx?Ck}SNU1U\iy\iqicist>du^U m>ʕz5۽aǩOg+jSwhrԩ:[?u'Z9凌̎~zWfWU׺_^LJ:˕h?"yIjuLʹ+{VX9WqԎ#/jTmt4,K' ෿+jvI|q5%kSNfϪg}-\5(okN v*1N—z}2Ƞe=2z!9FjJ;;Vi6}ϟ|\ܣZ^e晤nS' u(vs>-.x_ďͨIM=KS0]H#i'܏O/*uC֭VI;}+HUHeS=ҔSS{l-*xr76k*|#r=^Դgv{lUc~*8㻸?܍^M M`Nz {5+?bw}/uc)<:|VַW2!զf[rJQ횒Pm{ӭR_kyb.ɕpO'˘bjjV/+{LdRNN cT3g5*K]Fai+i)2˿?gowDcqbͩA]8SrӒh}/پw<\@jΜlXR\/REpNd*9~Ռs|CL ~d[c ׯ.# [sV;9,ieVf-0g=5oO:omZ֬mn4-w2V|Uzu{8\U{nMUEel=؍)Tw^'jz[98W`nV_MѼ]=k-uiPJf<a<389B)_UׯNlib>dvC}GrÒXYզEF8>ڧ4shb*|W|sǑ˫x^C#imY Uqө$pz_SNoIgL6&]\]mTdlP q8U'F*]:sfaeڭ5te>{ZUѥ/!ZZҭW(bV55;43rr*-ocjUou4.c;x?z*ݏJJN1ԱwbFU]jTNWٕ:RH(#1_ o/Hd_asF:I3Ч(߱#\lBVWw;{ִhHtcikڷ/VEdxr `y :f: $?瑎VTF鵣tQeAlnz`uǿּJxʱ~v,^u+=^8[pPGr7skjjU*SV$ީٳSZN|g2dă;FAzp(;;%6z_ -,4I;XYYaWi&£>2O8#޽GR1ޗ^in*i>JYv{G­ 3YDp&/l1<XqҽEdѣM_} 2Svk}T-lKPpcq1^!$~'iF4a~Z,Su*:~#<3=rF@ K\R\,vV;B7$ @ɯcJk;2^>?a]5J˨b8S1isFOXz>?i, BI#w3[J7]]YJH'dHO %1W@gVRzmkF [+vq3cɌ7cͼYkMsH$c3~a}?/o#yGqaaUS!|~Y+n?ǹOިO"д3\]O0_  $d \SZ%]ϬLE.ii6uY%PO-VEh=;LקQZT]_Cvt0kxX_ƻTF8F0{c[KϡsK%)/{9+^cO-;πIvW:sK*t&[~ZoUq{h0}O=v2~?7';CY%*F"_Ni⻛E"_J̡H쓒85~2_詇MHQ.I-ݦY'i$}8_5C޷5/]iQٵ^WnS:~.8W|lfT'^b]N?̥|,Q*Fbwzh¤dʢܓvX r#ܿ3{g~I˕5R⽥ɯg]3N򁰭J>FA:"nUfN-S=*vN2{{$FʂA=ym,ZE%n`hbz^yVo&*FZV&,ё,=`{qS#S~I|ǵdR 9=f&۷rÞjW],:;'X s+%)Qe^Mt}%#V$e>X T)=yKk=pg5+)3)To]cgdښUe njJure|&y4גh3.Gڧ12  r+SQ;5Titz/{qNGBHX'k?a)sVҌҼ5,.$ѮTPP6W_j)FKM?SYԼ7R<ZB{8ӧ?yJ5*TJf\YYFv0ߧkc {(_~ū<1ƫUG^Ҝƾݭ~^`2~1&[=3Xu9VM/if.Ȗ\(!P:oZF3 %.efM=Kv#mYn玣jIED(e-%0pM*kԄUݙb01bHunrӛwG-K.]&7LnpU{翧ucW1N'0G|k?Ҧ1rZrB %n3*|w'k>X򸠩١s۟/чNiStR-DJȌQ᳏M;6J\FWy$W Hۚ++E~f폚u%|ǐrArXiҍo5><2~ r;FZ-/Iken^yҟrQAJgV39]5ZI]ۦ+1O7UfshUVԩ:+(t_0=i.vLeJ-r%>m.Ü``t'洌dZ._fI+ۢo.CrGLºW+H8 1qGNDʶUTƴ5H-\Ia&7 '8⶧%x4{:_ߠad1e-__zѝq{>m42[Hcp:rOcRWؘJВl^X]q GN#+I*pqq6\37Vnz50IᚿUrx&>JQ]ı FeZJR]F2X9$h@9+2{4%Qz-gi&:A]֗)Tdө8izFC NU=Ơ;tQ|MjZ~ou4oRdI އǟj.%Ѧ"JG;n!$kU?urQ>{v&Y`IjN#:SW#XՍntkHR)G'ʟ7 9Zy~dB6lN2s涣wuJ8J'[y$_(ȪfV8'Ӕc2e];\gE!aYrA=qt/Snv;~ΑH!qUvsBTxLtk,'qϧnF+ΚXxs'/Anҩ%VF;y(T$Pd]4mhe 2*茹ZJa"% GN:W%p)Jt3j DĒ0 w}%I\U*IJW&M*Yi^Ov߁DTgr*{=:[ymu]_JVaJ1'˸i R@#bxT17KeRDx_%N[9kc9cYroOXr)J>ܖ'ea{Ky3v BjrVCWte7l[w\{wj*%udsʌykO{X{F8?ZHY"c&fTHѪeV\1{W˒Ȏ4,tN_NZwHQٌUrP22yҰrZƜi^K۫#L_zqǥrJ9Ti"3?f3ncRrt{7fl*@9FHYPx) ilmU1|w9YJPz;`CqHA }yL:ys)JZ"G5ѧYp{ui:iok5*r;<1InjA?_YF7ѭ.kr={K_(ٶWkg`1uɮZ- ŪvoK%,{S몥JWNZij8% h8u#>ҳj{M:bRhʓȑkGvsmJRѝ>Ҝ*(kӵel N JefJ<*s׿l0]*B w>c8ŸFIfU1QN>tb=h/DYce57#sAr[HY_nd #߾@sZFR# 5CvojjZpNv9rzc5M<>".Ncaj1݉ ɹ%E2=x뜂q%(8߳=()Fdd<ȻمTqj/ݗN~Ft^9Fs +2c~@~zQ)J3F+6Vgq?f>O Hp{1y&mL_gSNO/}> jdrӸ~L#.}VR*I_}w (nk;,Tnn:W:~<]y]{ZJ:(mNgWGm9lPO GNEwѩY;_O&zTJ4ysӬO $V*PF8 5Teg*xyVܟ[/So1FY 2O'?UFU9TOMNj6n1-7R9 TVW#KMR6nh|>^ۚImlhaUZ)&iS˝hZM 2~䙼b3~j'NWmy}jlMm(b EQⰬ4CÙy#"HRMȒy{'zgi7W $oiҸX$A*`1caaR5ޝ4q%yXd&ԅR'mLъI.,M">Wc` zJEQI/GRT>{'^z(,DH+EDo=vFI8VbV'w\qTg<)%i~qq)$m9OxΜ#c(Uv/j+4Xn,jow猌{ySݧF._S־~rx\5,!bhb l#=fկy装x֣>4zo조6P< Ut2}k׆FwtʜO0Ef  n<9ƻ:NvD%-6g@$j mn r9'УFvuG-ިEKiILkLf;6@u#t}Z\xxv"v[ȣp";z9$czhr]L>;K^GvVSYco<9nKNv^?x:nzu^ߝnI+.Ҫ&\qYDZřha[<LGwcFȔR{,: {(ƚSmfy*noBu sHֿ3 zqZS 4RRmˡ=Fj0)Ua+YT0ٓ6y˺XՃ\[Bt~_jc KTGʵ5SW2zb.6/͞ :O=٤HqM~!Ҵao VJA;-j NeJ-|v]jn<Ŏll#q@{ 飼WNg3 yKr|oªW83U:u7uεJtR-;i2f?(+ѬNJs(E,$!-+c{ѩ˰Nji<d ,q(&< FWorlE,HX$$>sӭrԩh멾=&-y@%de8qUIA`ԧ[cmJD~UG(] jI|"cRUA#dzW-UT+> +v}kH%5SR5 捴Kn] `u^mj2E+B7~w-#ulYFsU 7rry Le>o4J-{5 XUwmbU\{c %'J2T\ettmѬK:s󪣈N1iϧ ̪^?.mLO˝k{K0qn{q޹eN1v.g[;d0r~voӧzͮZ~hU!V|@l[X0 c*ΒqNgk>E]8ƾS'I ;z5,E_irѢ;KwXnwmAҷrq\\/-gf(UnZ8?la ?g(:v0iӍmбI:0ƥpN3Y5u={'FI5ԹhtFɺ?,v8$?^6۹^ҕ%.e7{wH|ی s[(7g-ia]h޿)cDl0QVR9Ofӎ +v|m~eW#;=μcy+۩tӭ {+ xnikӪ}fGV)QdokI=x%N5I8^[s.SzM:ѭ~^"ؖ)ދq9#5m,EJrMRRM-,i2cF;@o?J襊 sJЏNe/mdHI?7 qר>dӢ[X jYc0ÿJr̥ksB>z]UrGVPi'LCZG02Φ+NM!V}BUHգb|1jY{w4sK.|CZ&@dݾ" 0<ԱXOߋ+Ǫr{<9'B? ?#yb432Fkc$(Cq=OlN1EK)8$ђoC N=VT\턖8lx \Λ|N[[#5)6_oB_aZ=ޥ#1;ssK1~Eq=ei ԉw3TY@=}:z-ͭԬ2 ff7] C0TW}:c<<?O8UgT8[uн˅fMېp=A<G̭geJ2wknmͳ,i<3v(#8#єywkyryn n:qU*srNjN (>┺i4ۤP|S1Y9r*QZNm 1UQpIs^p>2Z|X+,=*d׾dǖn.+)S(ɢ)jSo4aY79=:HӲLj8SK}˫$3ADI+~SsK\zmo^ȣX^k+bH!6MrǖFqK?6Wm'y*^BTk{e^Fb*"ebXqio<=U}$f c[s NޔbpS3uA PI+B\0ߦrqT}&:#F%Q#S-lv8\ czכ)S|̟%kxȁfsn0;cO6 -N8;5O.<ORsx4^/n9=}ܫʩv"A8=:})?e=NbҔRZ}PFUf6 qWZUj*ߧS%Y#FTeۃz N;^S1".B)*}8I펵Ѩ#+u{z0 ;6?Ad\瞝;Wy{KRy}魵)I`7c:ԃֺ|+&+GZ:='\1_P{EY.yb?t8dzW 2Sk]kFUk4HHסǽiS{Qg%H Q(H`q׎Χw(N:[N4x/!cSne!WvN sXERӯyL{|3$B0}~/lW:m7Unbf*H!5>guS_3z/Lra1$g>p˛Y:2vlֲWJ77YA?_5R>NTkZ^, 3m2?N[IșIFKkH/ aԏOX9hJg/C}(䑃`3)lXéU=e{؊o|3 g+A"Y[&]Tlsxje9 ^֊ C$0k&l+8\aqGٴ !cnwJ۶L85 ,nNb_)q=khsraR2nD336pJ~ǚZlims'Q<|fwy=lݖFxI#`c tFwfVW0]L6"Vob='8ezٯԯjEFm݅ͅ=s劝ltBcwvjWo(I\O@q]Qe=7y1ub/oY#ќ8֩FQgѝTvjw1٨unvl`ǡ87+zb \:%_jp>U8<x[~xIkf.4EeLnF;qVBWKNO-'kWjkl< ȱ}.pê\Vע $e.y\5+h<:m+27~:rNzⰕ9{);|[NnJt&ZiTq:߈HU*C6Kmm`iڭmt*H9Mw9Sėgȭ9U֝:/SY_N*zE{mlCH'*"Y{%N5BpKr'>_̨'kTa3F3^o|cFQs'U%ֿ[Eff)_z%OKlEHS槭ͽa"' 9r:cڹ+T|W[JN.v3"CyJ36ڜҩI-76;6Tv3Χ#o]5#nd)~fHTfFa9<ךxhhSkjKC|ˑ}տ3ϭ -7*Qgn[(ZvxpVgF<}Kqݙ-~vFڰtSy(^)n|6Kʂcߚ3L3{-A~p,)\09玕VJ(JRUcnYlks3qo}^cM˗Kʴݎ H"xطoU,/ ]TyZt2*_ YYlb?O~= /4~C12Hǟ?MTҌNuAhvU vFH;j5_2X ӑќj=74O-pӬN?w=? rWhSR]&-6 Xeg<<!ҵj?B"R78K2͵du=Z([[QnWђ= X{}jF|߻1S+i"HŎ$81 8 ¶ifsWp$}Cuc'_lu>MngVRbvk}Z67e]؏ž?ʲffBI򵶤2Y`loOX}N7̗1*Q9UO1&sn]uW=O׹5R>ѩ-w* ~z kdw{8J24%$6ˋJY5),2p`/7aֹN6suw2ysЕ 6qӥMJMFj)b%V\1bXZ"FL$lP5cЖIgVhU *I}4{b*Ν={ m)_T&Fރnì(S GI"lJgszs9FwgM/`9; ,r-s0e9?ҥr*׹w-6K͸L.TqyuѲƬ%nm>qÛ4p1RyQDۗiUb;*#N\G$*JwIX,#V)mޥ'ob˟/EFCc;֔SDuF^Φr\2ıaRrzQb;۲R>w]154*~"pϘvԊW91rhH~ $ ?7sQBu\x-Tz[5bIF6q|Źݫ%Ny8GMu>Bm%H9>^A֜t^vMqy x7$לV~P͚Iʌc j_VYp*啱 } 8,V)8}5J]-RC2x:#rmFOgʓovr׺/lZ eRp0aۏ=]Nhq9e6 yn!\b>r'%gV"JK6#K{$]u8gJΫAt7zX{84 #Nvѡ%<-2Fv%HJ.tjY{3rm#G9xZCޖ4'i-\c4stYowFT?ff# G}L9$\g?*<3rO?8(莊ݑs5gfnt'Jq+Z4#ʤ2PT0 $<2^ç>3c,OQ)18\K~&\L)$O4 ?Z RLrtvע8/hV #6:N+8֫(vbgx4ŵb_+bq>:ܩ-ElTi*,&%!9`ÒKcmR:ܧ'@"0uXzQ_pso[yu8[v ?:є"zt=8F5pGנo:iO54rǖ1L*;;~>bXC*3 ~V,Tc/f澕7\`"j{8SnkGذyKk|}k7tyMg1ts^OJp~:~HˏmLqkKS)99houcNy=ΧNT.* ף{oϠWT$kpʿjuj6#pGze)MXiRTkywnHKɍ˜{g޽(Vymi9J>Zƽ\ER쮬ʻN>l|Oƺ(֔Z}zcI=~}^BR?̩v9==3]Jdަ*QW4."uP d۽tQy%ua.U**Y4Bq-S8iJqv]·R%'奌e{u?K7>UryQi^R_#o>(o CpʿV ԅ8q9޾oJPĸ9Si^[q<+yw  8:8W/]C2k+4-91;Wh}5></pCdnPJ1a٥J*b^zzKK "+ b#Bڈq zUG )疭wU*ɸM06i _-1 _1NOu80^"OޯuvϢ_uS}+>˯?|qM\ #KiiGA$t۵xy[SV}w *Ytzyi - )rKx9珧Zㅔ{çr}֗m [yq*+-+:O#>a)ʝ֫=x:/ZxsQI [s\}A汪wUsyJU#-9T2Do'&o7|+A㚕-ЩXgЮIu68Vw9q֒v;F_1M1]n9 djycLcjwF}AbDl9^9(}JiIX#˕bH``5V侣qпk!Ɛco%@,@vG>';[RxE1,v?T}nkėde>Z۳w/vGS]ѵ˲]-?+rU%57,g{Y,654ʝ'% 7uGͽH<&;G{:ghQY 6*,iZF՝4)xB, 3Ou$7"J<&c))F<.aVU={-=78{٤ݫ˪^JK[VEW9hո>y8 eha TM:V}Y"Bn1'Fr9^Zu#~-yT'vtZ/%,!UH#zJ2d]<eQeL r+Oݻmק}ҮHB5b^m.TVRpožXy~bAޜ\}F[5jG[v4tT O ~RIkƲ/Gok,j;3m/A6!68(S.C}7۴+([kɍ9ֿ6q2Nޅ{ErT6Y{3]TU"ܕcN־i4է4 F ܃ҽ,-*JOt1TiӻoǶN4eQpLU>~d{gts VV^w+Vե˕#ȹq}k4`ܟr:*x=?i̟nhR ${@^p}kKXÞ]LT0|{3g|_b3)g?ʶʷ':ҕd媳9o>+Ӓ~xwN^HVnzf/-۷xzP]]3IrtkUה\B+E_ c pzusUږh|{7 qj/^ۯ~z"[ڪdo2mGxqָ2Z]4rl{ieۯ|A/ܽn>tL嬠AN8B }^+mV/*[].uzK1 )]~+z_D|/,DZfɐKnk9s^瓊Q8лa5+ckӒwjyRN_ q5%-RT;i׹q6lױAViowpʡاC{mP[{{ӧh]:FX=l V%%FRmM/r*sOޱ>_Σþ2] џr9W,%:9+[n2FM/j bD242rz'C{Fo<<)>3t{KUlq'FP\S{{j6VO30u0sץ{|EJoTK ]0n7r=->ImOfv^=K,w# # 8*;^]~zSpMӿc)-he&m_nϫd+dΟj=bݣz,A @b܊&QQJ+qjF/rև>xzyHk}1}?VcbE: _\onzfQd\nqdžF+u*wٞK—9sH9o׺s8۩ψ6n^ tHۺ6Hۑ\5*ZKsZş+"Ү [Hd[9}+0R_IE%&=SdqsYV4fl<~\t~禚}8^_3υu}\ͪB9&)~2y<`q iڤRkxyi&_2=[ĺ%<-$ltOsIM x66vێ99+擼NVj*0ozws VOG oT>u*FxY>æ >%+r?aMVkwFm!S1J W1tg¯mϣ<e=\AMgOB:֫]%gps^t=;CEf[}lU5Pvnάcn]oéZ@|$ڪ/OϿ\x3,*G'|9nצ3[anua6u<%·fe 0>=r~M{X5$sN3qV8K潼XgGLHd8s^>HE}ǽ埻eO5Q5Ơ*@ g*T21j{5.oy=NEm.-³|2HC\^Ӽd)tNGY$d#'$~=+nyN>XּІHwnfl09tOu{ Nƣ{F!`fIV=Iݑ?ƺ=l(ǙKv:MNvk}f6?=yc5^8/k*ti{Hg=C8_]N8㑟js#ǝYԬE\[k-ً rOA}rXЭ ƛo./{ u$K&dv3y<[&0@\ֺc(+*U'MmtVk Y~%Xƣ=l3n*JTo/S>|8#Kյ!:O*O{.sו=<6w\uӲ{9 zeQo_P?ogeK i#=S֩5Sؔp_ςKrۛ??nK*M u攥~G |8.ncc%v9=z3<.tǖN˳1 WPyN,lNu9+aQ3U".wNuI,+,{JrU\>I{S:ޓ݌m5cDYU8q֔j^v:#'i^#PKutVђJZ.rFXڱt=;w*Mł)l>}3I?*.q9FJwqZ 2v c,,p9Jǖ}zytzmYc c+?{i,E֌oO>f\a9^+FBĒ͕إqqQw%8'+_BKqs2H8D$cW/]jY%CdQxH8n8!񨴥֧gХ{$4qGr#2H~^=?59G^eDcjqd՟^*-M]\C#mX:O׵u:4c沌J)m ZYEFUpzoNHϸfiH |1VAtas"`nvN?ZUK%**(0Vm_9s3=}ۚ#hԳ3OM b"=*G#mn2CeM*6D`{zW]:cG>)0UrG-ywl~@I*hӪWq:ETԕe/6DWpH t*l%4ո.>v%BX ٛx${OOBdط;`ŀbIkZѵ"~_4zϡf4e{4LC@3l VݎoR嗼t4m"$)8Sv>aߩZN6Oix`no^湥)Thc [k42V62`cj%ZRqR{4X?Da+&PU2y^by/!qϨ9eho E[ |=߼l8>{fҜX(ʜwdRYȎ<^VsugRҜmrld`29;ҕ8)b4bi%y7|U3a.YY3<:M7-TsNl:\4yܓrV|W ]bwgv |ܒ6X*F`ֹlRtI;H[m@˟_EY%Ԋe,9$o+l9'y=+(j*u14ǻdvYW9 uhݻэqntb̍(㜌uxԭ{a9[_ȪFitknhL O~$Hn B20-Wq$cXEI`7(yue9#/.* i#4Iԭ41^U Ѣ1AbmOs9Kvߏ$)`i=pcdV:(գ(M;۹ G4r IGS<~UB>w6BJ q{z~Z~؊t99Cȍo1jS˹inC8LUSB5$ܟI=Z2er˞2nV2nᙉ<5N_C*VẐ(fȬsq*Q*FRN:['vϷji@acSN^R.o~1 1˒`6 郎W$.cO2S9\m4 N3X̞Z'qխ95q)AGXfݷtc *掬Gp]n|19F*GTeNmnIrvjqUȭ!e;%RQs$fkc09%3JGƪ&737%Wn9ȣ='oR Kt{nvĠndWC Zӆ!n[б ~ג'C\AQ8JRZD`93|cyvE]osjrlZ l*m|Ϙg?l '(ޛMT60X#t\/iݍ#F$Ư<鞾*TGz_|;nV֥n{V䅣ݓAבߚq4ʗ[l,æh`knE+6vQV}[KmL*&cqڻ7W] '+6pEi${T|@9#qPZ~ͭWRV3FY c߰23|ee$YFR9#ַ>XPT}TMHѴ`f3{䎘i<6t1Ԗͦ5T3cnܐ:See65mq`s[]kmYOkU/淒H6?|` #R>OOƍ8K7oĹlM2$qLsy81Q'͹Hþf3 n~߸zu51-hVOe:/YJWDsnLf7c{+MsOB1;IVבߚ%.Rzo/."D;ژr[oAAx(nZ9)Xnwgny^q:瞾9sTI5sl帒4Hv(NWR}5+*%{J蝾ki䋫"/{HrP^u*[w\4{v1Ry`Bڠzx'x5JGfkjtRxhK$F8$i*h^@^(vmFSiP K#@TNORX 3ҫޜ=c%x<IVs8yϽiEB3¶8e>X-|u=T-yjlifU.l3m8onsB[{C;-!`dc7Zӄ9=J5苎Gq@@.|֔ӌ(H؎).`t 2#?=r2y#\%rM~]b[l޺XZNַRt˫e;W ^Xռ:?sʤ_9th^;.J=3} VYQk[`nkmzYTIPڅ5[A 19R*i)\Ӵ"-_>ߝeSkt<6ќqKJ-~2bh>Od JWM\*;:+snڣjGb{֜ؾ^]dֺ\w| m'^zv?5JMKR#f27[,O'jsogQֱ%09Y ~qU*bmܡsjxeF$Ajz VZtFE踎`9)qy˩\[bM%,g L$὆1ozGE8ʣ})7UfP`tH$Vg;^6}+W\Mj| 1͖%wc?idkcz-m7d Hx<pg[JM*Ø:V؏uF>@zqSԕ׽nT̮gz7_]\)yK!\IL=WwGEK:&-&G*x¨%kw)Y{_6M{mn;#909!x+U9ew{[_C>hv~EmmFU6,x1'?sWNњ0h}ċl4r6KB~L.8y)ףy'o%xB2hqYqO~WӋG J-m4{iv'- qva ^]i[s5e 2rZ%d( H;}zWy7cOGkGCWL{{3G猞~=; WjYU۶Fy6v}3XhЎh{4ݴ6# cڨG^:ɭn#Z*itq:ҢOT3+iV1w ؂+yǚ7:ҧx?[$vd12F@pq~P{hƛt(ʒRUu2nPd"E1r}sz?{墻~Fuϲ8ʇ;@=ӑG~JQqsT[W3+CjP-<֐uoͫ:MY)<&Y$_8.S^,gM.5Q++iث=Ha޻/FOVb)EUIw-1uOΪ5tv1Y"3wL\kN[wi*d\6pg.KmR8y㫚WүQJIU}t.XZVٮRuQX>BNI^3vw[|b(FR~HN cH6p3ʤ֫*m^6Tp4^|Η,mw76~g x\ҕ8wUj1iFY6l}8ߵsQzGTk]n[wX=\5GΛ}FQ#GgcyGXQ,䪀dma{YE'J6I<ȥX/8=ԕ'y;SݩͨsnW ;TTXR~3_Ħ[y=GsF4kX΋G-FЈ%fPG$1Rw_0TDJ|5!n>QRQzEZ-F/0#njwgߌK#]I^R=D'|(hԓ?x|VUytQw#͖FL*sɮoŶDʴ8ks%sDѲ3%1ڹ%5'-%ZsdRj=Ȭ?wRM-ѼoG>^?jƴzQ#:N"qJ'B=j7^V'=+Gp#1-#~c(E+qj8vogюX$;_Vy9唩/'9P %}JʹڨO˞ܟYKT,F!QH`XƠG) zqڏ_Ҥc:ppvkG5<tHhGveUdr>mt-OZ-vO8Lfjǩ Tj en.e$G'ʅLn,xJ*Kң%.kΏI<]ҧ&%a؟NG^UIJchD_Zje˱Z5dÜo_-%%yw9ogFtV=)Qgc J2TO(9uRRe{\嫾5YlY|u:zuR-ҟrޠu dna3EzUƜ}eZݕǺcN @K*8N0?ޟ֛_ӓ>,Fr̳?v 9zGsilT[jxKOoa4KHIR7/|WmTޤ%#І=?az $rz`=s)b*J?qU1XztVidNcr!b~QI9kKB. j7[#e1^&hS5@c8bYط ŋsd)6οc FOQ5!v_erfY֩N&i xGui2|fgdB^-hmyU%k(J<oC_LV4rr9#I0~KH^{}=k_dnLcϽ,qr]^ 7$Y]46s4k|'cuSQ= guirݻP"yW'W?/q4uٗkp,yl 29_c~n蚱º_I[gdi'Ƿ_z|M:֓Vq-#h ƻV0>SʎsYϖ2ZwPG%[t̒yΦE@#teUi֩[اvw^DI) 0qk*p؊*4#I.%{feeq򞣜Xʌ[;#Z>N{E4wT ݫ'˖*ǨEich 88䟨Sc^1bZ9!fBdfYzIl{8r[KŚ4VʅpszZog%~GM7t uVتK ~U.Y68rG%)uy"ޫqU:kZ~':#j/y,˵vcұ8;iʧ;ޅE 3߾Ϩ^e8l^F]}G4|_VTF h_֧kЪʒ&n^0@$ &$HZ ̘SM[zV w4{W;W秦?¹')I_k y^@Vfa$pqZ^{rg-X\͏lWkNvtӹ S H?w8bzTeu9a=|Zn텲]rA'9ybLF;$I*1җb禌"QW}~y3/fܬtHs`k:xS۵*NWBUh^M62.+KO3TIy1$,jw7cx[}8ɤTRx;Q6l0\M_)(JUI-m,ExXn"g>Q'8}ES#i,_3,,r(AǯkMF}}mb{=ޟF鷫ų׷9mJQw:T E<ѷrӼY/cd+럭{Xz|X苴n-Gq)Wc1ٟ3?uO1~gM/dH31]ʼ)^ilk:inB=- 6q{)S۽}NO[*Nn9.O.=T_ןλS$T/:f* mcj)<]AjspO.1ɰ?7Gz`#kob1qǧⶌihԍZ׶/aIwS ҳ,x{g'hfۼRylѡ3O@}ǧ5^f߼}; rw37y+׿SUrMlgNi9'%줚Dyv ##9uF>Um=.6QQBz=Ͻ]bycVd_0͇d2s3Bxpxb>-*m%ȝksoN%}^HJvl K{~?z啮K:T7ucrJp8[{Iʝ'nn+ J6,uˈVY& X_JTs=.u4Sl=:uNJ-li:22%6FM폻߿BF*eVgKԯѩu6p6e,R'1`#w8@rQ}ZT}=täk@#mV*^n3 I$n{&\(~}ߝ.UvCL\) boQ{Vk<9JMoŅyND@s'Ϛi*ފݿhydUeg5*)TN1{4lvL]Ǟ ҝHʝ2e]?#F!kmwrG!ܿwf@8~Ÿ9N9V]u54E\L˸}3:Ҍlr⹥%ξ >h1-"}F*c oN25$oxbucfgN͹=M ղI:|7sgnG-|Vyv2WKgEVV Y_1׵oR[iLZJQi%g~յ; %UH[=r(F1s9bFgi ww"h]W) xMqN2Z4?2=MgKUbۙ\?N'pr*j UJԡÖo;|L+yӸ1'/W͈U'%$]-˶FzR'V*o1(\;NkUDpj~qo0lFqJ#)NyX"ԦXYyG< ai8TQܼ ;c6b@:u Tđc%Mp]@_4co 2S8sW*4QNӧZ.}di3]lfż#v8VN4ʕ-ӿ͒}V_FjF+jͽjGIYڄRXD䷘fvfcEIEzq_q-M1"n|gc5\b&W,%k;Yi&eq6F۷\:sZҦ%PVԥBS]Qe׹B۾= 'ӊ\'e9I _So:C0f[.>`H '#ҪܗomJܒK5ۯZhͭN1z=N2ZM%V|"mb^CY8NdD"H.l jrzyZǚ_ORIgE\nY +m,x緮+\022 7_kpY07q'9?4}Z;$i.): h6_ֈJ]^5&0+HT[Ɵ[4U>[:r.|{ecT1}z+s&;Dk>23޹Ze,9mA Vd?7j*Jp%G(r#f)f3y͎׿chיOSٮ,Z, bTz9?w5(wnFn#K dRIf^@ L7/t2.W=-L2̪ywzRukTrR?AֳE5/d\)ԄN@#'Z*P9iSBHRenUVtXöC 34fﾊIQ>TպИ&eo,  ק~zƢaUVIpn^8F\l <9[GJvp"jQm5]oЏL6+{vHҔF*z><=,U>FioIYߎR0p󧢽~e1ݛJʹApz彇&|٤[I-8Vo=sH $nJ|zM<-5m-^n|*B7t+OzU~fRáBfxge7QZZ.Zd`) 0*n6: ϨڟסFQݾF|#2Qv?/LeQ&׼ }_]s=@X4O:TfO[ H5ca Q5E.\_2F<"Q6a܏ju/iTklf vw#my~fW'z{zVOW@SC5.1hJq!39%Dӕu9c+)\X[ya<`|czU:U%EvtӔjSn_{L'3:sҕHoS*5d66 {6ԔbXBEys\d\VۚKrG]-Hѽܰ'x9iGmۣVdmYc˹u[ѕToQA\'+re^>v@'X7MWoSҰ*}Qˌ Sr|?B3G qߞ?5֜T# ԗ{StXXĈ1q"T0O^n"2۪/m\ʱBYdy| Hr A}^{E%my} H &٘7.1'W<MT%Z?s:Fd"!ѿt6~0z? )F~fd]߇vIW[c8V;j''iR1bGz#S2cq:dqںԧ).jTTӶ:}DKEi B]'^F}S RsKU\8SWgki* Ϲ]9rkp};BmqĦm`b`uaߑ{Z6V5$U"Ci+1eOqF8⺰QgNO$sU Y۶ۅz1GMiMf>>u0K^g)^jL7m\- +UU 1vpr8t\T[߄v$Rae*σFt|GfVq1|E@<文5JuS~EyfXȫ_40. jJ渉Tm~Fn%Uq$7S(tc6>g̹/2mnfeɍSo7pqn^fk4"+rcAS>{Is5-3&-WkvXh[6g\5jJUZ1$H˶ݷ\wӌ|͡NkG}xt[v0X3YT*=oRU-O#Լ>%$8t$g#ҝI(IYJQ]9{F{$/0WA!Pp8muPtbZV߹x…,#CF`nH^[Öw)z뱅z:^g8Ox9..^h$:0l|IppqڈB4c޷hr?k渍Z;v;$ќq޴\^&eR=ޫMlq"hdHnU=c ᚩ'7tuRF"IhC&É%Pű3`c=K1F|6\F´hQgp悵ab]^ \YIǡTZ .$u {c:qEN!I/Gܢ]"±A۞.Z1EVk]KF-Uz+dVGTQ[˱o:4qs\2IXе: {Y`F۟\e\OGA.1m\V~/)c.z6O>Z%W+Fnլ\{Bѭ+b,?=IM{m~NU${*ҿʫrE^ikSܽk{I )խ;w-wktt-Dgª >ަ~g_:VЧΌDXo.X9(՗:Rwَ}fmmctuQtc FiY}-jksݐ6fFMYrW )حWMVϿFaNoG% oj2j\ӷi[[K] lse98x]YЛNi뺽BY|ϴ[\ܥUSQXi[V_#^X>FV.55u2~Qgc(-E_1 :Q~Fz| Եr D$*$<ߐ \nMlz}lm7Jm㑧;mJO=0rzgЊrVIB3oSOw{hm;|y͹mrKEoX7ZiNW9%}N:}kJݽƍIk}u}+t H#2ns ds81QH[-rhApr#k(1dEm܌(?^NN1="^U%=2g~eZi{h^L,㧱rIŻa{8VN%Eo^?\*}lV"SܺlY= #kXf]j#wgy犏'$z~,Ӕ[qzOjFco-u+ҕkJ[3QZW5C/CYFpG>5Ye*Q鯩]*髻omif95 7f̗,66p7d^F?B̗Qmo5k_?Bo$vk}On-Z`h q>Q߱~.=mS hu]o_}o05[x8ʟ:[wC0>q۸5s-jɽ,붗;ٜXfEN]ﶗ{wЯ_|>jK&ZEu0ܒ3cYvۜfW۲^%iBb%Sš]<ۑi<$(q.VM@#5y2pJFѫ641cS'dKK]5f OiZNQ2H_*812+52M2V;jaa` pyS>'}SxĿ +E4>wI'98^1U;y=Ў" +cI{m{k 6h%9@H 8shrNI]{;{|x((rvoZt^v>kfT?**B(ā_+R,Zӛ菗FM+9two^zE?lLʲr8=nTN}G~4KV0K`u)SqKCԭ :a|OM = q V۵V<|FS^^?Z+Oy5Y<.Z3Y@=wlg,WK{+"Yujt]ٷ[~f֟)%#y74d*$։`e-#Yz^~=B֢.6ʊUXg8zdn9jRtuzT%$fGOTll:RʼٗLp 'vFޕܥr:Waj>RnfʻCֺ)r_Շ}u0J+33ɅW^ ~}k4zi,?Y}U9ľ{q*dԹ.MIKGOn"`<XQЈi+8_gr m4:uq4peSWD%~&ݭ呙01^1U¥b7(c*$J˹~!?uF]F44ܪlDN >*ipy}z^a$QG_=?:KqSNRR|M0Q-w/z=+Tי߇婪z|W>O O,jd9Fr:F =O_ W_{Jw _aGI*ҵ>mE9{7KRxI.]|d<3|ÖzS;G}=>Y}>dޟS*DgYd \ gDԷHiJzy_>?{ZV9]2h8"@Sӱ$[ykseXc-},q񶡡t ` P P=TZ'{`匟-9(/;kg_K.9O<< /#QNCz2J);78Gh"Iv3wq^ ř@i#8N{sڼ.CzRO9>F)E7j^Nȿk+=Z1qө(ƕb-KD~GCkpo ʋهR_יəSZIҒw͜ψus̿:4*:cPf"%R+'?tʤEK {km>c Ԭi¼20;}s:֏#_N)iuI"{SGR:ETb[ݦݲpq뺤./ (+~O]i6A(65T;4ƊR[fݧ,1~?F2ꌫ`p|VI5{uR ךԩnԄQפys!~RtaNijEsI^[zk1.݋I8N}tUWG^>> jJ>o~Den9lvL}xTaZ\nקx쓩QklM[o~-4KK[[yeܠx^`: lMDk*\Žsl HE5~ek--=KvmeZL~qsۊ&顝srzbI/~۷.OyʍܰJ'):~k}^" +u9.3q}9S[{-Κҍ/\Ij8paA=;ӥR"x\Е6ouZC"ءyv{w*^Σw<\F[sH *]IY۸I޼TFD0`ʟ| ܬy~B*I7px.VNot~?jOvi+}5Y^2JGLFN8Q}>d~fz]S9]ke}յٟ}5Ҵ7qr6yyF:~SZJMw}.y/Ak˧隐hlM!,xUr6;^[EV}-}akSjUqmYC L1,tz.N=⬣|vz42ޕTGԩNQhh:7SVۃUexYKg呝 $vSF4QϬAj0Rި$dQ_<+ZSsN+M7>GuzWLe.nh80hZbo$!1סaڜN6%U=$ȬF6enei{.uвB0g WF1+jSqopG)u& 7m\jˡYF*k[4-mʿ7݇3rK[[ODT2VnZnPx9հ.6v.1Z Ѯ,4Iw'̭@P3߯n rRve{ե8TeO[g_ѧ @..260Qy$vty~Iyrw8mz&KSӵ[|JZv*}8(*Q?095օwIWͫҧZ4yk+QͶ&4k%.)k` yb.^kj׽֟Ы>.dv}-}ھm_HlҳLBH@V;s rH=>1JKm/g]-v ϝ&I4tWJv_Ïz$#WY4餎GBFW<`O3 F-i[{r 4=9+K~7Eރ7<9k+ܬۈa_ce_?};yu?;VX-wzox)qlgXn7!>qeŒ81ҽMEh˙>L~5*kM[5/Km&ܗ}͝u= >%LsRXLj! d9t⡢i*<-2r<݂dv㯭t}_wb}oye(8鑃ɩyeǚqסw/#n_`35fw&6-F\ޯ9KE[MĕQ=O8oƹ8zu#9]5h5njZkr[b I(h8Ѧs4ܭ~ֳFdeYXtcHehq-ȇVPmq:N^ƴ.Ck]MY*@f'z`+ u#7Sftc^I5upnK,*|O{R$?-^ԊG_EJMVTc*ܑ9%fU23Fr:Vw9i/Wm]lSss$sʗq֕jQBdN&g ZK1NwVZ-74{+{U#9?ΚsnV4-.YWdB=MF3~%TV"kXjVrIWh"l*'9TR::ԚXLs,I>XG.-vg i&ݬMǑd3L]}:WEm?ʴ~-7-v^IIrj1*aF]GY9ٜr,S}Nwy zg~m6hû7rU_&S*He?k9UtW]:T.۹`\Ok LRlciVyO|De)ѡRQwmϙ9xϽm.hGW:)CD;o$dlF]⪚)4i{]?ir@#zҶRYJel8`8Hٽ*kw 2$w&Vysӓ9ZŦLߚujM4%UˑMg8(TLۛvO"y2F60?ʶSZ}z%+6ֽ%3s kOzeUi%Xp^5Y@f!w`};UQU/N~V+ 0 zfbE~M mJ N<ѽg\Ji2oLnXܣ#pLAE*1=Yv YQDۗ8xJ= #*oзR7mmߟ<~"jߔdh[-W|qG?AZ$ӏ4КSpvb﹆ylq8xPGv#S6+$. N~$VRmTRKxݽ~_v$xլ-7/Ѝ̗[--͹5#)Iiً4j ͍stv`)TŇZf+ n4G(ǕSv~hihWF={U>_*9sMJ$1QqgSɬww3dHᧉ!~hc<ߚhIJi8ԒE$ȿ0\=OZRo޵Z1ouܞ2m[nބ\ҲG?=>kL-㌬/B?r擻؟mNڻGrkp,ϵsG34Er!+ef|6W D{1 p#2 O̥6KÐӌv*TaSyR xwI$ܩ;N0F};vNccc8)Q{Fَ~X-7n2\RR4c1$>`e={}xKNO ju]Lq{VU+ Vz g?{;}<=+6-Sq_"fYDU/ypsyⱓqNU9-m~.R ;2#9yRm\}܌jv9yHV9es^=_''=+^iQR{د4Pr ]<{֥kc^\[Urw'Qu~H] ߴVҷڼ;1rNTyd֣(SoR;d '2(ڢ_/ק :g't#Mڞ+a2NYL㯾{TzzN$e9; ]+fa~R&Q43eܪ>nzB=kJqtK^汧?̎crbx#xϵU97{(ЋWԢiA)|mSyV(>BOyoQBU8}08VYM=,#hg}6feϗ8'֪<$w.HǙ^{i 푚N GӳƘziMTGw~R_3.2j}uѩMEO> `ڻAV^HxA%N\˛*KW۩qqq%]VbѬ NmXN1M]g7QNwSR ?(yjgWl}HFfJD+MLADUOi##󎼃]4p2~NJ 9}$fYFzGCV7QRm}֏u-ŮGPm1SӀzw>Z:RtmXe$q0֫T\ϯwV'e~a^E[Tmi1=SJߡZ|=~gYt2xnKZ+2jE:FtDy241;tշʹwcҜ8[c0ٱd9-2R.[Q^bFRw &' ^R{ ӎ_ $!-#(ץ(ʯUbgYK{ *UYvRsZSM%IE\Zp#/ʋ!8=zzt'ޛ#jQteIG6qVW5=lE_Lѓ ݴĜEZ$yg&9KItopTvbz/Լmp=3Xu:ş*HZ4ڬ_ Ld{Ƨw}; |{⤑R"嶟q*liĘXxUF2&紥e||Wpn(H,+%nzOQ*c-"RQI?:x6fĊmhgj`2Tg#'WN1ٗ2rWPK$t7>;Us_T)t3HUeYOݜBrX>9+Jrm;Vd:so*FhU*篷z﹧$y%/^üDu((''ִ&r(-G/-՚={)8G1NLNQvx%?hԼQAG5:u/<;bߛ0ol%fRoqZKݥvJJ߯c.O[K[Td7pҕκRӧ^*:BH|3vW6ye=vM)ʴ$㥯BIlmiAs#NQҺsϕۺBzWa$o/#:t9$Ҝ#miʖx7l nlj.gku9sJЊ-YKojӭݣlq'89uZ9$)IMFi]ߺw]۸*O{k#7K[}wwVAI'\N˚6OӤhnWfqm^MHեcϕ:tƗnc}μdl H'JqQ弘㈅Hrkjܿ6:͍IaFMfO0(,wz95J䃜}U{h{6gm٩e7<v:tU)SMr.ЊfԌNmrlҪm$mtbcqFEڬM95&ʣSZiH@Srxp}=9]Rb=Z3N)MZ׋T,/OlVfT&ߩ\j]yKrFLnAYpIv8Zb+%=$naԜs}"\c*NJ[\էY7kwc7ZXeV"{νl%U:nݏCSRм3uQ枲w;'/>ƕs}ibT#޹Zsrpµ)TpKyfo+sU\sI{7Jm>̭&88uN9JHmzy64U3|2pTc)u)J_Gm뎿ZM1O0 /0y<;){[=(,1>Գ(]BF;O1(vU^O/V ޼S:Q[NhڨIvB)[FR(m:dggSޕ멝)J}sͶy,rѾT+x8XE1x{mIXfD rFp # R|HQ3}+g<RS^)EoFt-܏$S*9^69'R+"qȬxt{8M΋\([x ysG"^i˪:}ie-u+/.W?YڿrKmNy{MַКF-q.c! @٫,c+-ΈӢ}FJd6Ȍg9ڱHBq%3t{D>P9G Gݾ┥ٙH\nYH>ǵs.Y.Egkq-~OIϧןt:4([[5uh#V Q jT)_MΏm'}2|;9/ MS9.%gPM`{~Tj%9G,G1Qv5잻=L1풓9`$]sұ*u{XSTlA#Y$0`b1sG~%Qs,6u_oz,.oj֝ྛxݎc4Hgs"NX(""읏QZF_\@ͅyYZ)+NU&Iuh$$pȧ;;{qs%|3g.hМ:]غzVOGִXW>fqBy&t%M g==_E5td{rzkMs>7t7Vθ_1U,QOjI< R\ЧN!>*Z֞e޽ -/F72G$UF4go:`_\Or#P'sUTN+CL;V9.Xӕo_,%f F?N8]iѬZ= EJU%vz7K8VYZ+ c^Wbq_WwxK K=Nºў,˖Eػ AE[T9+S"GOdk1efPUSwO~+'J/CM$!֬?4Ud-n~׌ۜ~gZ z=OI,n":q^qvTUEjw~|*[˷nx*pyjN8ъ;kn047QnHU#qG,˖=u5-9Zy%#C a2vdr5^XZ~7:-_>k &D2S& (ϯ5og9SNk4clfE+Fv UԶyyC_ooe-/;+G!,Ѩ#~WS{GZSNJ*'< ^;qURtT)M+AxBJE>USqK;1T9sCUu3q'.[hrsNXxZJj]lڍO"gy'WrW#S+T gFd̃xJnX$t¤)ǚ*uE߲C, -SؙbpT[t#YM6 sZ1eԧk137F+YIKmUTW/2_J֌ESh[s8Wa]eգ}Xd0pY\1Њ{8jTZRZtGm\n/{VuV=<<4Ƚ_AR^^\ڡ=Z:4ZԪ-hYVƖݎJQ\] %4iyrпVy$TPU$nOʎHM^FU>;&zU8eɻ/:;2D1Uȱmhw,sl#%1zS-_@`rMmi-̍"c~S[Z61i3$bq&ֳI9Qk~K,iZF]w\Vi4:7R0I{7";@z$:w9xDkmi%GG]*Obal-ıHs :Mc*RYpjJRѴik;Q)ԜRoMg5Gzܞqr wx~Zmh5gNǕ:sõ]՗jbO^j񧈒qr2Nܚ4kE*JUGBpHi(ZD2.+;((Nhӓנ%ܪ`rNޕR~:1RHXcdb q{qSqIٜEY˖˿OB"۳yVcUˬWz(]~vr{cߜc jgW(WmHZ29|e{߁6h}R% @n˷v;dc;ca75gTQNm^''+ UeRcVP͜k JTےfΎ*V}蝥k639Yn_QFr!g]#zqQ%R*qV/Rh_FEk%ż*a$ҨUdܤ''G9?.ZTjWMiөf+E4H'6GBB4mV2Nʍ`2L~u4j?k.˺5*Tӧ'h:Zv덪pW;];uјahԕ)_$/f*y}19ӚRJt{y|+Ft$o(.پl?ηs~u4*vW^<5fr wgj֕CS4n=\8)lFs#zowO!$72=+fq\u<]42մ{XYZJ_滗 b<9ϸGSJ=;s[.,y;cZRե/ K.͊dv͓J\J07o3bg\,lH]ף{#<|GlC;Ǐ]{+ScNKKGp| *}]:MGݍ*L/pFTە+j)NkjiFJ5Ԁa̻#~.t wZ#6s #ǙCV#WE vw%ђ?B.aidDjw9N9Tkܫԙ5Nx`n$տx_qb*N \๙=w6e,kv7q?uG;Obk~_em\a|>rF]_o{vE.H]XO]g*vgռ,͉W;=TcۧV-v&ֶԡ-̫]UU v<*|SUme7ڦlyx H6p3ן9{6*rxߩ쥿11r RnQfeu.cV@ېQ~x].q^twԳG([*j=1*V'Y7/Qr:ҧsi.9Teԫwnh\#+|۳OJTU9=|ʕh1\H7I 8JRMь#Q9~k5%9cV`y=z[-vhu+{Jc{nݣf+eUvA']˚rӱ ֊dovM˜m 2}y޻zzEՅg%kYq ?hU.޸zס{45kTqrI?#֭k2y,(P8Qj({xZqvJ9LQ|s}+&;EmpSukk~F W+c}NANztN:(ʚoCW߷ٴwG&ݶ1V|t=qZ#z3ʬa߱"72]wmWجW=I?@:|6wBC\%}ZS#bb }8 K63jZ,G±fv0*sV3ɣMƧ,aaݭ??[ʝFܲynW`r ;{֑yVIԺkT lEekN2Mnt1Ton/1>ک&JS[3e(`=R:_NTwبp4s,w2\bMF_o8q]T-CJ5%ʭV) Wz2Q$VRm*ou8Bdyd7F\m@ܽhƋmsHGDc5%w|ehȢaRGz㷸iJ .14'4n|&fuXT/ϯMyuES˩.Ziy1Ʊr#x*9}LsUmW;6㴜`~XcKgnYM%۫.Z-Y )s5P$g)_BtVlg5F5vpHKE]O1&>^ SY*RTNRn_зo3IB?~5#FPʝjvi՛;ȑ ?ʜiQilL=);+קձ]@\3yyFx>ұ9Ihk%Q;i:#*(CWiSU%.EUֹjQZ&5hvWm$NBI#ּF1d5e$?NU1q,H6y=F^?JTZάGBB|+InkAiS{i Yb9ڏfGGU}n~|*GGUJOʧƯ,ɓH}Bʉ2VH /8ZS%ε8ri} ̶eq;@v ⶍh-NS]t/[beIb/F^>f9}=@.<^U>U,h TKL9A\~:TUyRf밒i+3iع Ck1ERv(]GӖ uxU'2pu+sGѦY̾S2=Ѫ`>R~^3ǭuIA^Q7ko&ZF-H+6u+gq{5?h欙K}R]zMI5S̑=3`եi+ѝ?bMyىYƹ|?ZqFXn`K2Iv攣)KDrʌVn=6bRr(F+)BQN4a)EjϹF[u#7%|ĺ>`:qX.G5HKE)oQ[IFN0At?k}BTM%C> Yu[ߞxp֣ wapgQdKa yUNNujҧ. 傖imU9ck3iFaE$&eʲ`^5&9M+p.1$*噗)FիqU)ͩ-z鿧bwc2#+2刊H<pl9<_jճ+ʝ?kePbXK3ݞ8>9dܱzB Bݼ*۳1\ʤy1xXb"4kkѴ2VF㸮{du#k強g=YWܚ[̱ n^zW&&Q]#\эy$m8a_+{W4aNs=>no6IogslɌPdv?:ʵ%FL/4j=w4~dGv.2Yp221&5NJ9J\|I2*LK u#ָ/viZJ4@FⳋԓI[4Rpf ~yhە"UeR/loq EiˇvZ؊5$mb odt=:sО9ˣ7 := XiT6ɝi['cڷePM/M /1 W,Ğ>e>Ywv\M{6ǝ2m~rsp?{9]ìH8G}$+y3.RY8<^:~5C9өJғȖ'H;2JU+uSQ+KVF*JsJzjC75#A_~M9g^C|?Z*r-FQ_%Yس0b#B< T ONkMjNg"I W+э^C5?=%wWW.cRZu:01濙 {+oޢ%*ue|7thil#̾cmdgg=Hrԍ/Cf7fkl#;sq=k̩̯u8q)Eu=C~4{`d !YXv8`=a\*ƥ-CS=MyfKaŏh5۶1Rκ*7jHNFMsՓևGhʮGއMRU~V猚N13RRu ˎLұZ"Pϸݻ*~a+SƘy'[I+:bω|Eݻr d&=~lfpت[ 匳ch*9c+"CSWn撩hm!l|c`SU9޻M8ԧZ5~f Օ[)䞙 v_䪲R_;nmË-pL.sȯr@*N? (o ߻3mF1$yۧjǖKb'Fܭrܔ(r+u9Թ_,H.^Y72$WL&Qԯ!FhdB'53B;vLLIJDxnN*=x#RRz[꧈z#&bTұ-_'|䓓\'g+ Q~C(J4 (]cvQ\Yc!-v#AXWrszj:4H(]{%zt\.䨤]޶ +ewcnzi<~|W8e߼j r#HN݄9){:r9jӕh:y;|#^rkNN[h&Tg)],nbh>-,{}iKrʽ/} +4=CZj/{cS{$kdt~UʾoGp0+NY+(Ͷ;y{zv&_j{ui3[E3G,ݣH0`fl c)$r izJ *%)Om+cF*?:%(rV_} $͜H< O5NNQՙjQ۽>"ӭ̫ʻVg*Pr3;ׯi݇\~I;vG/IrA&e 3'c5TdG{?]:"6"-8][P09ҴEѩjIvw;ǵUh`u{szWDcZ1O.T*Tw4!{I <塍p%+Ju)85b;ڻ9cTzs۝u P $ n>^յxdXեHWM8VQ)Jڭ+k${HUP3kE-]fvcC8XLdͷ8k S95~~5I']p̱N2{ޝOcN:u=:> .IŻiax!fQm p9u~8B%.em qѧʮuoϡE%qH>¦YBv似pWxjȭcL\ J#q:>*q挣5ar|?bNe~>qDt{,<Ԓrd"М/^^Ǟ/~ۘNWnjXY[&Avjt7o3mM(җnfq$b_3jĔ+SoF*fkH\*Li)[ѣ8KǕZң|8y)=Gqא*%)FN{4<,_)~e;TITU8dF¹kռZzMSmf˙o~>cȄ5}9_θxT9m:O-6G 7K1jÕMi,ݴ?KPHBm,pn F;}q4iԇvo]mt=\x?kUm+V|ţ| ׊5%%YMȠ1vX`p2L}cX_얛ݺk~[/:i+{-ZM͟ji 1vwua2ڳ?5q&5Ԕ>]":t{ʮvr|ObNY3[4sJRѽo?O _yq+"E:29 }7V+ V?d^ѧקGேg֜L:ڮT}~U~c|FKnk]nh~NVJwV+zީ=_>]Lw}dQ۰ʀ瞵*_j^0cQ/xSMfUܛG\~u?i'0~ڥh\#L۶5d,*y{k2.RWӶϯhӇV]U\ qj $vҴp)I]Rp[nUaZd{IE7t;0f4RBaf #Ǹ#t'9G{vlsk{9:"M[^e-43:yK˻S?>+NNm}m(ʪJ)_ӭrF=?H1ۢ$UW lc$pib0z\ӕ.U{uv0&8z+rtMh^%/2v_ۃy'9j:_^~gNZnjvi֩ml6Prqx9oiJ3Rk{w^nΓc$ҏ0&\Bwry<,iޣקM]0tUIvWfn,wH@3W UFwaMSS՟k1lzӧ YԍGq.RTR|p9`hTQ[vz}4aeR=VvwoOeg&}A= s| U;/?< N1Zt?AsywF6VB>aWbܲ|-O`e-m=&V6qalӚTݸPj6ymnjןmsTJ?3q&IWkIGN= =/3J J]?Եo}M"eCH{)sF=>-˞/XIw'TÏLtDׄ\"]Ḡ.c6NzWZ<іLK弊@"ʠ 7MgIe:+ZJH@N=O^֫f!m:neG_\wG*^3~c'"HqsTb>hw/CN~>X؊u*YǩW|Us#G+ZQ2zt5,X1JsE*cIkn󓎾*^vF't }cmoR̓4S[{p>t?0ɜ{=iܧzmK!Uª;~κ#7{cM=SN4d'?J茕:#k6J)A\s:n;r^"lDa^FQ[I9m奏yj}nNc 3mnR6nGv"RNJksϛ>s ;d!p+FZI qL`+b)T~W얫ĞN%Wt ̞#/ :?O3LV.}Kum&fygmǎ@Aj0!ZϚZr/fo[5h"f84r# r~ͥ%ʣx4c 99[֖%ԜnV=,sUZw8;m6l(b2qֹTnN2}Dɫ):ͮ<-6y9"BZC΍iʄZIWϚSj*u4cNjZo{p5U/ުSŌZCY]f̬wni6ꜢKLAb\^Y-n*[?ÓQF{yTg+A UGc~aVk /l=Z4gE;_9q%_^S{#9Skm޵omUQMvƅ5kTLe-[Xp-6l%i+L%:m;30nN1]t[5#(Un r0\B pZΎ'bz(ԡ4їu;fɐ[w&)ө)=CN2AoM /'vv g#b@*y;Fu5R_v?{V_TiwTm3{>'PCN3ӿNh+ݒgBRϝmpb'>>WOEtejqS1$7O*A(i19FWk)ԩ+_O\|υwms#^i#Lbc0G\۪SVV&thԔuؙUWUA59=*w *^v^3t+(uV 0;TsK8pf<^4ڶcK $qC6@9=9?k-ӣ۽>r5^27. (Օeqqz {V8eUnGJݖ5tݎPǺ5  !O7KlaVQK^K[x]F5HcAl.G'/e =w]?೧Qƛקc?e_Okrۼx2\XǾzXbNtV{niR%E{٦]>ׅWC;UW\g韮k⽤Nyx\\)?N$tMF IS}>qKZaԧR1Jn7]][ײdF?+μʌuNޞ]Gdn62cWc(j<~tܞo"n![Qnu#q<2X-ov;}GPz--U8z7ㄪP%/_gܱzڄaxMܼ/iia`Yq1}*#&/ J׶6-o<(g*g+4fnMg+f13ӱi q7~?(ǯJ"dߕXcO٧_&nirʖOʦf*x`%(۠e17:mًy!RRZ7#5ՅEoJT*\{lvtsIvNay9NVnǦ7Ɵftz]fb oO>Sҭ+:ye[W0).-y$A<8>JJ/h}u g5I{W?5} JM6p$. G͌fqW^ics beFubϋ|WLtőZ@cwNKQT*|}Un;;V|3Be (pU#gO@kї2VO{~OduNޟ_ǹo8<=λi2F\~[DYH'9ᇣsr/lO/3V̨'QhӲVOsҼ+HfO˦lhHC9WϹy|ة%9jO~$VW(2I'q{6lUlTny^@B.-"M{nTA=iVr[#XYק7n} is[:Rַm; χt:-UIpM3\-(^77'k3g  ^zztqߗ岌T|y==K |!n"XԖf' '-?} nGff8U czq_5ZRj/EҍIbjb;t<]}h|Dב"#rO别Zҧ}u;}6GH=4y5mF5V4f~R5>QsſN->o+Y)@<`g8 <8*Qw~]=/ymN?ûKHI!s}]Q8iz=㊕+4sxkfb I1֪Rqhә+k=7H`$ɝ͍ۆ@)FMXqn!maׯhM8KD,A%A%Iڽ^g5Eެu/dX=KI#<ʒu=y|W,$xU6UYpNђ7^S;p#1~O~wvLcE珒7dzѕJv{%YKފj>[ XIy2;/9$Ɯ\g[u9~DEkfLE6Y.ENprS;vkdSZլ׼/Ԅyr cLşrzs=K~VZRQmKV M [x\Igs$wNYN.nMK?v `}kbH;f#M(ef c u8bƱTԓtt)tƩi).I%=}>*in'15#'~'lAԪIJǡ7cdhM#{u^3wJ6IsٽxM8ŵϏrr͜8Z'rIӌε ? C]n!VgVcBn=qӁYV5U[>K[ c$10;yǠSBXxu[Z8ldۡq, ( n89p::'u8%eRWH杪5ƔZ %L`imޣ;ڵ8ߙrZͨ'^YT?kXh]:6a^Y]$ 0T#$gq+IEE8)_Ҭ..451_Ȼ@Iw|f/N'Oz %o1Y7-f sp+Q9N}<^9 R͈9a'b#&׫0[qq%R=2OW 2VGS1 dLnf۷zU#ƶ1N KZHsgwP9>VbZQ6lEВ9!ݘv # :}zu=:)1|Y;~f\\lq1Te ӽuEA.3*F!T F~\d{P{Jr ռ֖9cYXɹG<`c]+#nUbeVyP S(OrTqtV] _w/̼'$t暌yvvJ'[?uGK>)L1c#?jeqUaRz39单hrm/f:qӜZ[qjt˚Y.ٗtR[Xn.8JNY.Tǭʪͩŭ#:xӈcR1WE9rϚJSViFSQtxCYǚӱ/z\:_Fqok eb[l$ǥV\*.h$^Z~6Vvso?([<ߡhJrtO[T2,z 1pQStTnDYM|_OF/C r旺,d{ɔlr 8=֜$L4bw]r.ҭęP?zX`p55ʝu)"姡cOFh$TPybߖRjkJtvTGOԱ|Gh(Q#*zrMg'Gv =c)~S.Ժi#*kFGcץaRu4occ*S~GkG_24 As u#ӽeGOkƀXI?W?O^觌n_1dlsҚ;Rm/QrΉy]ɴ~5jGX:T[o[ AT+=Fo9ՕJ~򶨙4-\+/ qNT[R攒ZdhIvPӎ=zG EsxrƏ+̖[v_[qy;]l挛E`nj~`{#NzqaeemyvK>ʓN tqn-]:%.Z~mrigTd0NF9{VpQգRG O)fx;ۚ[#8,Av*p 럧Zr.gdS)%Ա]3cȣoɩܤϒU9Gbxtw(bwǯj=m"j=FLsGgDcn-k(>Z3)*Nնm]5#?\ Xrc(TİOʒq?)pFL:OR}k7R4z=|BIraV UUh^<Z=S VY#o/j%$={W bxp9϶=k)T|eӒPS0sְDass9n%ѕT`pv>vф[p"- p0?GVT4{Xo2b7Dh02W}cϡnTegm{w(ȓ!@ۓs`3.'<Զ Wt#|̧SY]+FgaHpqS*qFk:n-$T'n|m?ׁSRZ#:-5 }D.D;xֳҺ&_wȯ.~4BFQ*1RQa[_/wI(u$i={uZƤ} }Jtv""+kgYH qsYƎf%GU)+uϷ~n+٥Nݻ7cμCnY0߭+SjWoR|N/t~|YY<*qnՌ'rKȣ%d?2;F@*fmfMEFIo!e{|tsZ{9F3nП,,~\ğ3z{WU8qc N2=BWK /k0Aר#5c i%{&X:q>6E`>\9qc޳OkǙRudvSBmc߽zx:#dխs&aBvG'QZ2.kmU+FGU9I.eqLT&B{oE.TǓW狺ȄجnPnd!Qrw`'888֒t c{hȕU:I]u 99[:1Qts{ F:){-%eǝ ˆm;qRd:*pVױsOOJV9kRp3>҈BОΰOʌ&i:-a2hRR4-!rA=+ID*j.Y\XyQ, p 8[I^Q} A3;0L >#?o)Y eCi)TtP29z~f**Z[ŽHgqx|v#{MBW]LJX:nG\Un7w:)0O[swv<11bϵ. T m=2H#iIub\Gq<)R>+U(Tt~{1{ůSr8\0#~uVtNV#uG&2<Lnc+0$o޳)EZU:qQV˹F.n F@@brׯ]wg qQʭoBPp`ۋHWǿ>"}m4},O;ٌNӷpp@W49gȕJխK_jVTfQ'nݐI'ָFQ/pԭd]Fahnc0V0Cn>kӬ'^Rn*{sT~;+ϭ{CάM dV?> ax^F!sە5{Gg-ĩ@Gjn8ۧzqrJ5R]H7/1ZEaG,j8MlDԵV(ܽ\3߭r~G*5m,T]>6[%oǎ\zVrEFa*Q|=۽LXfYl**${db\ҍ e{WͶ7`}뭣V? _xP[mi3Pg-~dlfUHԩ?#JQ&E3oA09檜F.7ڇ,;coKeU ER c2.nI[ g}yy_C2_5\ɺ@X==+ڔ^ 5^wWF4#N, cP۟'ПUvQ|9_1zAۣE4'a9ޜMNij4.8S$iZ1#/GOj]!Kxh= '̬m+R a)(I؏iOn]ڼK2yf pI#k42ҡywڶM(@&`}}{{W7T,:WO#CDpŔKF o nϿNyub}2V]M; {cXق 9-ۧ?JQ5'j[$j+$~zIrY$e~nn" [1E3GҦ0Fpi4:JXmYVX 8?8Dӓ1ycA玼sYMRXkyF+FnݿOoJϚ*W&]z;2lql|`l+[hLiʝ .5"e Ǔu銙7MݷөNy" X:NzD9y˱bE2#(c, yn9R_qG x9FV|6+n2/$epF}cJPVөtjExQv3K,cӿNTȺnԖ&*,v1J-|Zt=D]2IO~k:ьIVZ-e"-oe1 FxK^4F<}N\ooi$ՍA|UAvrT"B/"oZK_ p <#tJTWWc*ma}:]kQ*:ҳu41X_CG|v*)F;+Em*-Ia;I:~Ph}>Ѩwim}SjW/o1F+$@ϧ~cMAus_S:?h;(]ǎ5(ߵz3hK]zOԡAkm⟲[ƅ^6n\zc?@qEhTnw8z׼Oois:Jty8z1jN;B-#ݴ8$zR#o#d`ԵփLe<]=|{+$Wо%xEX/5Y#'=:9R䲉5KF/ͽ4E?y]7FB|gǽ}gGY[Eӡh%ZXfm#;n ГsqzsFN:>/c)FQN_y.K-_a ɸy,¥J=?;08Zh/C[:o%V#+$r~@8gOO#٫.ƮwI"ܫ,V >eG)9cseHZ_9tmsbp<rJδ}9)V53ZtzֹL&nU<a:9>tpT^O_3W^uI.:<9קZҍ:*Jm_ԨScyk:n%+Ƕ8a"&= %ϦGj`^5x=SMaIB0F8=xeN/f~Ÿ5vO$cUV?_ʼFJz3̩dӡ7mYuUNG=ִ3yԕFRu+nfڻKs֫X=tJ;l5fט[ J,۾nrsR֧֟,j82\0ڻn2V'#k\Kh-%ĢEWߙ 6wO8ҸTEwy(I5wܑ%Vex'cXFebUr>[5fcgwϵTy+"e/gA'ߧQ$M >F5%5#}f2H¶vcN\(Y ܯ234mju"{Gèx9nio۵S\ O;iUX^ұhk!fqbhPVeU585V3:j9v.v8mqmWFIȕN-b"vFu( ck oOrㅃjR,'UXU{ ڢQ9JM'hl3n@U?QTӤݚm%,NcSY<ۊi-dqUĻky 2 ujm#)$- 0lhqƣwrb%tMi cq! $*CTK1k̲$cs֬4g*ju^zN$,2c.J%Ed7)y*ƷTc+<m>}=**Nw[~i^}{y2e3EÝӎ)ӧOEK+೘ȊnA+iڻtsTRWKDsy v#YESoT(ӭfIng`hYGJs}@xN-YVKq$r " qk>ik6J5'$b8]̎m)888gy)i۰TBv$ u.vN7c#wRnzb+TTih6V763*oǽf(it剦(>٥1 43HN௯Gػ:aZhkuOos $vQ'G?J\#tԎ.kD^MG l sԜUTc::I%׽FRmԲ㝡_@9rK'`c''W`eVeŒa޸#X缐 o9=QNHԴș{gS[F!SuT&Nx]]󹼿?ZλUƥ9Qw{tas +3#+c\185*R_snU!ͿEgq;dYP`yYK[tMk(ٵ؂8h!VnŒ<ϱ8=giYt}N:5["Kk|)Jv>e'׊PW]t;i*Ii UVEi?0t8ʝocQTK^*F@Ӟ*R^4W-7޵;zu#%[OA .ff_pZ{Juj9ioPLy3yn^?wC6y/08ONp^9$&)Ԍf9y]s[.d;f\1s~5&(6%fy wʬN3܁\Ǔ~g[R} -s *V- n\x1NŒ)զv5m'Mr U $ZQQZ\( F_pnW//+m-O;:j -2h[<9ps4{2:>ŧ$~ vrM$.Qr1ӷ\Іir,+jYwuxt/gVZZqoq<9bX8 sƔst\Ep]|߷~ tJ-V",ZZ[۲c,ImEFN[9^nLGpFm׏ںǖDǚ>Y'D7g2CuzU*1R2G*Q?0'#Q[t:hCԣmrx9U+5 J} =B-4+m -'$sKSVgU@f 4s+pb̤Qq]7l#*T`gﭾq>vVF^qs[FQ_{6Z :t]9OiN8O2 ȿwvG@ppzǚSw;9j;3Gqm%`jN?ZO/ڤi{5 ۮ}:vjzzop^I-é qsޱ*5cSlra[r"ٸ>lcҹ*)6R&25}TbX)J.Nk Tswd\G#eHŒ :pK>a5~~}? Y $xԗ;j':܋k=ْ8B7 }5R9ɨ_ӖE|3m\:tT5َ8t9i3Wo2] :c>}cE\)4}?MՕb6;S9㿵rթRu9OJwhr4yZryF^MGq#G{4[x.F}+y{9&Q(J WЮLk$vi FcmefQ)+#L"}nٜi{[-]48#'SU)vVEY Mk<{1Uڣ8.Oݮϱ$-0 +iTYG*3QޜNrMIӹfؙ8v79QßiBz fg2<f`v73ߎդcN=:Ք1q{yw4ෞ+ٖ'!@q{#h]YBS۫б+^ʍAiۦtG$JKU 7̡x p܎qӵiFK3u\ב-..{qֺj@RP5h..Xbeb3|INJ¯QTYj4M,r<* ~s󪩤.Ӕ9坏([ռhV6zv?ָ?wNz69לdgf6bE nc#u"l&U(?f-6V5w8YdXQڦN:L#8w{ ۺ@|E9h<`)9QڋxJ)kZ-USj-IkQwwKaHY&f䍪Is?gRRGRTeQ^\E+.sɭ*SB:ܚTİڤRC${RlgXԍI{vL ѩ/ &d,~_|9JOQEz ]5_<*U+ӂqXOJqViݫ3XSNQߡ emʹŏ'9VգtTTc+JYT4qěVFmA'ZRٳEJ6lɻY%mef2I&-y*N#Q}JIsv6y$~?j&R7Okt2u'zQxH8:#F2ϧu}i,ZIܶaϡ=NbF*zQAx3SKЯcE84f Kgn78=t6~^]LJhVa3Tm*Tzg(TM#-lQv`I_`ްJ|Di(Ҍw'd;ٛ(;0:x8өMhpb#V2N=SKHUF1 T\N O>(Y^d bX*P? g9j/ynVlFGf끎8ѕF/Kfnfǹ:N*0QZ|'lIEH. pqB=1)TS٭tw[Z8ԓVZ%YDÆٹpL,WJ3'yv*uߴ]]5!F#pC8 u<~?K슅jro}ucѝkHy68W$Ko RF(F˹wu9^\UsEV"Qv2+nhW@}ҹ]5Uƌ"y-IRW~R09z>Vuqӿsz2>ku1uPc5r=YQi RdϿUⓌy{8էk%3gI_.0^:2?NjyX'(RѝHݜ+#ek륽>hӭEӯc ,Ioˏ_/RqZ]-M"XY|XAwmjT)Ԭ.utޅxS$n)#8NkҔyoaROtk;w2yy5~ҤiOR4Ӕ]gv$ H#)]lNWqxh9/[~+ #LU?rfʺU5#-vUފPMpclȹ¡'8uu9ԾN/ݞ8TNQiWOAw"& Z[A,7 Z*u*r(}5]QTpHZoݻUL)6f-lujc*-?^-t(;yS,gnf]ͷWz4a ɜJm椳{U rEmHӨ;%Iף^EH?g)&&bV4CXZxZ2i˨a~Vkڴ2ҡOIZV:Xd܁իdaHOyNge >6KsEoΡ- 3o5@x+o(7O.2\`H$*sʕhשJRSw"-61#F7Xvpz?WR+9>W5ȃjTdmm|};֜)ƕU0jU-. _jCj>i攒rNO_s֮_c)jމӧRJKUBobHoz1ڢiS%z4!(kR f-W/y?jNT5ӡBnV#nB.>Q'ey~ՅiXiN^g =警%aXn '\3Ꭽ56/?BGU8p؎ڝHJ5#Vom,mi3=MrʮGv/UVg.##Ӯ H$t\Tv{ohImp1ul';Σ(K_/jԇ*. g*Fsd~aVeEuv,7hͶk;+`tDri.Gmv^^*#f4?y@8$oqm[K%㰻[;fU!>PNp d{T:u'EG}S54y2!(Q9+-9K]5'SukGf֝/[%i#*0`<2܀;ҹjMs;=fy4moXYT#M^\rik~򝤚} _X%4;T#?*|ǃ `RiJsοž ҭ-5vh 1xڜN*βz/C7 01¾PUe><έo%%$=KEޥ8o4_4&q=~ԋqGjǚ?υgV9F`rr:3j74sGU}~']d0ͨCC<(%9#r䎷o}ommLSNu徻ZU]~G omɏd}g#8`J>Nt֗6|wgYpŏ9O)IAi娽↳.%WJ.le'LҾ O7i/{rpm.QvpuMNJV1szQ}/0qZ{nyY"ۨz}8S䨹9{ֹj.Yw19<)|ҍc4^ipUs9jۚ~46LS,yZF*R7b Q,sqV8=qtStȂ`*/%F}gmNK2ug$e.@<+.:ߑ[B]NQ{˱$QϹ<<rϭzzocէN4jg zv=VVڜm7GUɓy:J*1n-jsU+Q2cNGC }V¨sڳRI{gKmgak\]~br{8\8-Zr~Vwܣy/aIٿz_ PcFk{:;[[FkTJU-[3.6F10~1Ҷ(7~ǣ9QZ?wM5 [KbƋ.:ƺқY:z$ՎsrCw>IգĎG?zdBökHԧBwrBOWG NL%vS O z 5TutK[t3XʑgAy{c๤$Nif?|9{xRXXI-tբԴn-T=ޕyݼ6OQg#rqt҅|=zxꒆzM3gu6ʱ8}˩VWn{;jEFi-_}αAa2\D錓$ 5כ9h֩8۝5u0gFRW5=OcTkLʒ8l#I.`0JNh6?SQt"~(V+u:TnJZQz烾C[;U^>L=nq9n1>omR"srj›= 5 dc$f~_88 mICn cVT՝ߑ~wzVicpw>~YJ.[ZҺg?[TԚV@rmd?B֍:mBwtcQ[7ٽ^$m3p 2)TIb%N+~FMޙuc^}Ia?y\h^G^oIr^m P@[޸/gYKF>ںe(t*o2d3̓ZGFm~ɭ%5n;ͧB0;húܼcJl>.j%=;uܛVb$m{Fx.yw U\gT#+#2evevҌTltTj[j;K{؛nni(ԌkFTGɯ#DH{lnw9a-#jQ_y0xmw}t{g`Ҿ FJۮyMemj#[XVVE8i8_>,<>қںvcMMrYf+jzkv]lit&"F@ y\?Rl^+xwy]'ş=q}4m4a Vo$/?7\yl<M5iw[|".Q^_f|A*af0I/T..ay,dS, qJ\7%Tc,z)}v8l-I!deI%R8i᣻},wFqz>MvֱA۹@ּ,UyQj8x|mhc)`{SCZjJ-Uֽ5o-6wq%I"~v*|01^Tt6cb4~B; [}i"1G89Ѓs%9ӣn5|//|*%Q@_ :O9^iT%ucUTqӧih8>ɶUOʽ[YFȧR5=hTf:ۋ0[W|2mdB~X~~mߗCWs?74{@xʻrppOzzҊwڌ}%kE-^9K0VF 1kJއe(\D_n6( V7e]U])+h+B~6<ƏsϥD(˾m!.QwDz>ٖ[@#g@kN9YCN8Z<;CSҭkk(yy8/aRMeժJh>W>Jc<ҩ:Z_SN]OOTӿcS G3I^ x.2[ehZf {9mJ\4kӔR5<-50 YZO$wn+,W4FY4ק Tu]G鎆V-6W%JQQ[ j^gfhI2rˌq?7_1>VO#<[I-#צ'dK-Ϝj i9iǯփTߧtS*=C\tTV:*GVJw>N = 6rnU%.khUHԫ <קJsY4O OayNz+XiX3QɖKyKUf1S֌+_!du,p6'V8ӟJӜRIݓhN:Cy+Q,sX=ir(nQӷcڈ㍦2s2y㿷]3Ftƭ)7/{o+moZ2qvzuS;F8jT\_2}ebG}}9<ΥTլg#72`u=kZ5*u_$4[ tk [QmʒdIKNm:|Ŏ{ܟ7ҳF.rgWJ=Sb3:w/=:ܱzҌV|OBH.'<@s49"t}rtns]6ճ'ͻpdՕwo0F2s{烌l-E*ƚ|jQ0,l{r;:5R\Ѽ9HѭK3q+-̈s2y'?AY+FQ[ tchFƑyrbdk@IV:?g9ӓV쟻AoVtĠbY$n=Q$c[4OEu5nFCU+>3}jBۆG Qw31ֱ9`JW[2>m HS@(Իi]hTX=է,c1Mr#lfeڻXzZTz`#yO]JC#gGSMs|'=ϹWv *ɥ{.e%N:+HTe+@nʒcZƜyG4ySE,eSUSK6wQ:a K6($il7{V\΢R<,le9s=*&E%wFd̒m#rQՎJ|ɩzFƤm3.pOGcUˮHk2¹6ݬ|]:)G"h@"TfJ5{QF1m.b70ee/x=+ѧQGסQVp<]Լ:w,*͆h[iHP/5>Սfڨ=zGzsEӯO x6qU`ܦ^=j̜i)Qwzp5`Uۏӿ>~ܸƝ*JVwwtc= 0c;rI㠢>QzаM,nD aq;8b3bR'-ccVujJQn%QP<-J_z(':Rdg ql_jm,8Q^2HXd(jg~i{-EumBn:sQqBc]KtkGRx'Q)FT⮷e+& #=@11U(Ǧes= Q\ҟeN4-: k£0_Ejкu#ad>{:+FDx^~Nh.캲)I"F@g˵v7Hq\Z#ju)9YaU~o&R\H.m]\JE[ c,wmi6U[.-g"2[*UːGLXeʡQɽ6(J|Y| 3pxs5*.)6ޗ(p0`\6 u8>d_7~%t3܄|#(e?jR6c'Ok+$~tlG̀1ֲ#~>Ib;|fVܹ¯|tɣ 9=4)rQ|߻S\B7 cQct&JQԵymׂsxִÖs/w-]"Rq[Mʬ;'N2tFTcdN5A]݁}lߧc#qHY?wךqfvSRJIjMk*+&WzF? w/닻ɴA\rs?QǗG Mh~l!i&lfg:2pY3Vv ^G:\ {vS8G~f*ty#bʭ 8=yji}z3{)"ϗ AiGs_Ҝ*z$LBwK7Ue `c~kXP/~GEz1N}+K[q=cp@=hѕF2OTbk/{vፕ卣 Cxu5kyz+9-_F15 y*W]1rROF]L-:RNRhDfoF ##zeȶfSt$M.iy"2Gpʍ!"P70U-2>R RIݽ?Sl<`jvnh_eu#o&O 8'ӌxGr>B*?zSQylqDF*/]WQSZUf2̾Tpo7Uq<KJ[\\ie7O./.5g+g#qqZI4:50*c|uqJTٚ*#WI^~=9>w9iVP`IMcԟg.nV,\yv"9Ic0.fΏ'4W5oT73 +p=O֢T؉Gw$Hnɂi$]FPCѩ̺'$o4"F®7sמ+6umS|}ŭ5 ,-#~yNcnp goN|7~2GlhԱ 9kXfvS̫T:Ndo:"ehJgPlA;]88>TyhEk+"XBq#LpImq ~Nň6r즓mc+rF́Ϩ'jԹiMF奵>ux!RvАy^Ü0#ӭs˖R/J[رK-QFs1띹)+ Nm8ߨK8ax+~[zy&yiN1M|ʳGجy˷ z_j璇3]J4ܓס >G"#ec u9\J)Vi]Q&X?(IpXAbAy2u3s~OR[R+}]G'#=Ҽz59eEXs^lȬXaϿ5b!'(nxэ4E e/8cJ(%NM#IFzdΒdfRhl+jlq5(VI%UhgcLg;Ikܧ~[ԧ'4#'1y8}9(Mlw¥-K)][J䓐@vTΚNMކlIw&o &^әvR |ܸz떥G o6e]H۵IV :]k 85tMcV fO-Wr3tW,W-gS0RNM.|/-kn7+FpY;߻ESV:)]74Y W'QӞ*tIZAi#6i M%[wyݻd)EVt9SdQNw'Ws{{5?=KPbM 7aLP߳rPEljtueq؎*ҭScQ*zw5VHPi .0O=:-IK^[J:-N/ DEn,}vF^fB'ȩT+ d@@*ɜV eɍ\FNN3Y|z{Ea i0o̞}{:/$cQ M͜zq?e*oӚ`Jq׷zԔcDdj~: $ُjpN.O_S:]p'+m@cZQj-4z>mymՍq>c(}t%⶚M1[ii$vځ0<Jɫŷ)EʫcxEyl$PO{jʥ(]}{,DG?27 `jeoשQJrO# C4",]6sӿ8ZUJ;t>$u/m'HsQRS+4axu,\e.qS{OqҸyjSԵc1U|ͽHSݜeɥYO/%˓XIh Џ2z>~&ewy6y:U{:qʏ2 ;Nt*M |ܮ0N0qϥr|[5ߦp5#v6ێx+eUs&tf[ylٷ 8,2s׮23ְ1^NZNvgCD]FdO<_zƬe/zR19xB"aXLDZⰎۺ Q糦֏F#tč~gGYnsʷmF#c|bo/i2zzQP>Z&)!F+.L2O=y)InхZݴi=s^\]_<;,W9_côE:0?WSk.=k:t8L*[,G=+\?,]}Q5~y^>֕9s&9%УZ2d=>!TԎhւn!2r:WmHT쎹BHkr-.>h$ y̼5F:K)W9mY86e!0 HZny~Ӓn<5j=_v*b'+q2彿VTcS~:tO Wv (6I?>sJU1 ;iK[z->qPx{ZКd# #sa iO$ݒm~}Kx]H)ߖVm//v  Ōڒ̎l>܇qxH|ןe_O6f|=ɫMo{y|N>ww~u; L2ik$2wg CM{Yύv}B2 h٤ďa.m#k^8uOEh2)T[o+\{)YLE9QkQNt]B8.|' +^_:1 Z^%ʿ_3o7oXdfp v(B=z»c:^hzB݋?.gpA4bٙKOWڣyyF קV%>Wc$/ʦEO|DR>fm :#.$3|YWѝJ5)Ӌ串#̲n_G#W-hVwJ<ы;4~S^yiR,.~V/Gr^ᶽ?1Gɳ 9*5e*O" r8ڒHIe< VTIt7q䊺d[O01@eڹ9݊׾t!J- }Swhqi7m??]~ʛЕIsߕyO ѶE1r{wԴ3қW~-Y"U[{8h˕m֞iEX6ǝ8aNn+RZR{/ky?>1Mk@ yj%^\a59|i|$][C*{6Ƀ?'jzvfd -VDVHH1I8$58%dVɣQ*.6%~v$<ݩJqv/2VXZnfAlXs<]&$_U6m";s$?dtUy{-;nOR"Q2HcGRNܙ6Xx$'#8\'XSe)st:[0Ȑd UJ±N>=j5z/Stԍk:pidm[ }3nYjZ܊0Qkce͎e%vfC>ƪTӚv0tZ7ulXIU!*ecg_W4 QSOm:-k8Ys:lpx\=0ʂI]OQ2MvVhwN<ɻZҵys?-Oi-´䏮z<+8JIrޟ1hd]c'N4SpFI121yaznl~:snZ7K4@^4;boN'ڵ7)$E+wm;Wg!&7mVrZ8Ԏv(-+H=;3g> ԩ.iyhv{z)[%xcgn3G5\#&#kQӶ +ϵK1 ꨫG <~5 vzjۿ,a@YcG|R9I{ou]iCDF-r;8:/RN1oM e<&/#׃R4rZ%b}'I%Wj Œr:Ó[S ?2dYKMKhyr/̸#$drHda^m,:6hUv5]:z=+8GkX^!LvHf<+Y hit$AYfcGFnQx1쓩R^nyBW :ةkE4bH1%ܚ1"aWgMJz#U\$|d7ЏNյ5 筙N=9S {iv2vaF+oizZy]̻Xe`2VctZYqd.BS?tr)rZ$Ԍ:wm͸|VEJqOwV(Qv*1rzzw5*=LgVe}Ο#7csc»()ntSXyGݒ!9Ive`9=ϩ͵5Vt$FdPWl:u^xE1{}y6-I~ds 2ROBxB󽂥Ni{M7)dqdrׂȬٽReZ{i1y敶WP9u~fjVˡ(JJ.0n悙csw_\V1SQLԲ##3'"RG^:OsXF7燈aWfKXU>b00pq@? jӛfYi~2z(9J˕8c:dZXX7ystӊW=^:*U>rSWTjs>^YNK'ڍ#~'<Q J|ɩ#>IL{Yz.xx5ܪ-S'I&ܷN9<gҺmwk"FTJO]O1# (c3]4*rޒno'8SObH4c$|;+5[Wk~&i{h;X/ E ,P>ϵz(|:;=p`=YuʬvqZC^6[uF=[(A*-2u)ia:TIN!kve{cБ^J5R/rgZ( qtaA rA+آVyF"RJBx Զ2wrR%(;IXط.%9Twm>_i=;h9skȯ泦剩 ū맦LkSc'`5^n;Zů-sr/+ڔufZ".u2h=`?nΫ9v9Q/Eh|Hn/TzR0P4q> #$\U+sN(J4{weȒ$c/̾W z(] =c{FSRBIVj[z`mBJYaU{%IO$^1Ej#kUiߩjB>Ydo2QI>f؊n-N2rnieXeSʪqUY_NϵsԵɋS˩ۈ;., Ǧx֊%IF3I=+}&A/ξ[m'=y<YҩYޅJ5̿g_'p 03q]p\t}NZhXXHhxS?)c%t:0<ͩ[c봷OtB<\ȋ%8mi! xwϦ;w\ocht씭~JK1g|n]::j:OI&C Fxxڤ^5:5%kCIc*bXܣuSkFi){=-q+JHH+G'Y˭F~ӣEȪȋdVlp\hwV*|v cբw0bwgw~9jXx4+oeO{k=#\*qקo,au\?81~_z9rs(1od1H͉TNyG~yZR1ةui4axyqQUi֎Z۲ c"\*uA cY٨ߢGRPtWx¬ 9Qo8>Үy>YGݟ9_%gR7N3SSrƌ otJLjЪ. W:O7~YB>X% XcUfV_&zڦM_-?|WkM;wf\1Ǵ"Vn0zcLW*u9FtoNO$k0P{siw6U߻e+Pq##=Lo|%>ռz|c*+IH9ְNI}BUI(RmtsVUl~TTSڧ$53kQBn&?g=x~U//:|*Os(ek 8b@+R=EƥIYt'm#Č^yQYG*{u~uT>DADglt&1U*ȇd(sw) cqK.-U:jr _1Mm5[ݴd ~WԎ8隉¢ZE*rAY 4lؒEq(#F#nsGJZ\ykV];^KOU:n:?S~XF>  n2OO+d֦4Ў;A@N:JN2t*dIّkH ~9ϯJ*QTE*RS-MNڹ#'=iΥ*MKVNGʱtj]E%}5Hw2y4ٳP{uYbR'j3v9@tSF~{7څ|,U@|ҒI٣ƕ6G)X,Y>aqkp-ͧχwњʮZEcvsy>7QS+9{X&hY޼x6RMZ?0`z }_jSue|{D׻&O^\uz~ѺC4-TQt(ת$sjJ3k/#eL|1SWޛ"ߑqQBw3e_':zTjNR2u+L$MjdQ$=?(6FU2I]rÞ郑]Q.އumT/oub#o5,deQ99GJ援RbJKA.ڒX\/"lo&VpBxUNSZ>IjZTl H 6OqZѢ>[]u:)Ҝ.Zj+omp~G۵\$)ʦ!SO]Դdt3ǂghOy== ax6ֲm0WrB^}q\Q˗X_̵.5/"8c^c'X>XQz8jRJ<,^xR؝smٛ->OJI)^£udJڙ$-U5ӃcόK3XjB]G[pfB6`>yē VIEC#J)tJN{::6Z8Q,.X\4E|lB'cv:$i۱in~!f1`q2l#^^[F|֍%ۂ~PzGڴf' ;s[B&̗ $.sYs]lvVo.̻gW21'pm+Q顪N7js2芰έ'+:d;:WLeR29QqiٜiH#? 6 qzgM$8v21FrIy LUStcRru|7]n- 'ߎzS*jrzmSN8YPk(6㞝MmS JUgtt7?]㷒ID ~U8ֱ)T5f8,MH#,VGJ_hy{zs[SZRvKFT0R[kRګmUojF囻&$QTG1{a,EiF>Ȫ~8{Rmwk ~y K4rrՑb 9.0WnkF:$ȩ/ieISbLv+]Ճ$2b?y$}6̶-̃z5\ZsaiR^`{TT+BQOhޯn[G/bIKm`ۙbd~|CUF1m,.r)֥OkOBݠf+=4ZЭ>^In6 -C7#Fįg 8 қgB+R{lz%qCj.V7l$κ˖F>қQ[9}|LPI_)8^t=*8xӃ{a|VQjoi|5MlXݖWJvX8xFcȑgem2qU9b#Shw]HYi! b6Ȭk֒h#ٙƫ],^VZ>wukF6sxr;1q }1\擻"8v_N25-:6ҵۙ7Ϝ|LT%M\޲M[l3}G?F=6i{Dވ4TU`Pwp˚:t_RRS=Q.bW~Yw OʸsGM/GMqq+ *U/%SE;[oRS7 wW g'Trri>~Ԟ1@UdZ1k3~dWW VgڱB2R붋32F"duZvqotH>8Vats\4)_~90IFv9ZUY넑 ǜԞR.YwSۯ%6ޟ?SwLV_a=ʭqN}+:e;52Ga}ֿyΥmmJ(1#curƜVg*3N)#҅:lɂh+ QZ^oGm`O{qy-*dA= \Э/h[V8ZZhzt<^K$[I Քdh<O>ֽu/%{J:N[󹇪> 4ƵA+`8>'픖vzekKxd`px ht9#Nl4#!v|΀c'ּItۚ-Iw̅d lg>ޜYk[זZI'Ti*e\ʏ樌n!W8b*/gS 쥩/qaHڃ2HtԔ}L՟7+{nT+22h#GDi?߽uirʫ|ܞGKMsY, [xj,JwfL511hhk n RDCj PoM½5N~hҵ֝6q!3+f*UiX#"$pS g:w2;q1lW![8zSFR4q}"¢9ق>usWU7y-:{xq׫~K䌭J&$%"sq[BtSF^nOZI}vd7d iJ54Ӝu2Hbhb.,!v z\׷z:io#(~-=YchR }74x#Im-+#;@=g)G\DKдMƮL7Is;מVrJRr֛"ܡ||Q\u82(ˑ+C$U$ FZTUzgRQnq'wZI&YB)(@/{ЎR nO^ϡӝBPKCȷj[xnck:=<|GhKm-үR;7xՖ/23g?8Z2ֱ8Y(GφlWZ}`8R\c;$ckєu=j85kw[:kRjA,'lgy)z=u-R7Wwߡ\YQ"9GJtWQ\ֿ\`6lۼ|}q)ʌ)-aR_hӠbd0;UGgc+G $]>3J66LWF3rϫ8O_.^; ژ8Ҧ3ا׹F}~;w6xy=NN0s6K*]+SuFR@r65(%i:ZŴ u3t%]nW5%aХG 6k6w!E7mPs)ƬgRJkG#ʭ66{5Ƥy}&595߷gUu/26̄'Ҷ:xxOtga9M5ܬepkƎ_ǵsjZEǓ)ެsN c6؎8sF=p$k7g~H#$Q+Z YݯW~aa heufcRqCR#nrjޫ/CYl6C; I WU{2-W: ks2ZU rv<+Eݻ]B4)^z*&tVfّ(p=y{H_[ O:'y!ehK423)28n&R5'd_Ό(u=unM[[k$c21{,[:R涺\< i$6m)&X2)zv3VƣO?^t+_^ɬObfkvSaې}s^q8ZRZ1R qm~_ 6Pm6e0Kp<8xdU)+Mt2m$;Y[i[wp۱ L1T\R[+{F=M苁|~%MSЕ抢.k#hU̒7ʼsP=?C 񗤕3ϝѨW2{$>Y["'(-F9@`A'V28ZjRV}*)ZsoV:a ƠB;G\kV2Q+ETx.&pʭ$Rs0vWfk))>t2NNZZ&yyݝa6BXl6q+%GmغxxpZ y~ m66mr;MxxBZϮ˕o2I]faq 嚌>ψN^\s=Fm?-/m.TpSO!dU1u>6gBN[3B^*16GB.[hf-AہUmЊFtk캅}aVu9ymM甥5C"(;̾#ҧ.^ƾ K:YN>^he8m;+0~o399S\k }.pqfw$}}+5vO[#֍h%u6t [oI#|=+7IJQ_ lTcd+W{U$^};$:n 8UY&}wa2yZSWzj߯}lgTg^OVm]G{u2)<3odaR!Y؀Pӓ0k:sz4[kޛfsߓ'gxVMBE2aG@㓎s+b)G3эeh#<1mi[_[a[ٰɑ_>Q*N~iUVvׯ8 ֥m:B˺_XX*6 =F3[ [o=m|cZܮ)>sӾ? $AgČc9we z 1^~a%jj~lU9.<׺K;HiXu!^$&QLmrs|cQosͭr{[oG,RIKyk#gOZ\DѴp-?Ոqd61`c(9iL=J nYxR]G\XRlo(9kZ*aa){c͈#|OA5KV/vcy9$CkԔyz*^ΒGcڿcd?у,o''zqש1kW: ^mZ맙7?/>ʬ 7؟Q؟qe: g-DV!oxGmmCI8l{WS٭_{tjG/'%_;+Ze-$^1U'&Os!IBI?NHLH ~yq=9m':d~Vxq柳ٳG\m--)o:kX]F!~;2{k $m8]0婭8ODaȂ7o26TLc䊿fyc3ZLwf@8^^&nySGmjO6;Wa^yUFvyFW_'Ac<ڞ ^Et".ܕr:8=qݭkyjKع%٧sҴ[J̱ 8V gG<}kʫ쌖"U-_K8*˚sx8#kZ4~+2v5t-FL j<C:{2{nN- ?֪pbZt'^rkSJ̌9s#>B0TԮ~M.eư>g$c=?x99/sz.u; i[P\Fb9'<k \؛{1)ʗ^Ga_!֓~*XOf8 :vpۄr2#-qSzOXq*\yms“51a^沌xꊒhQ P,1psT΢SԨ)h^0w}ͽn\Z XT.!_s\J,|[Ķ#2c$~ 3=mnXs=D4DI6"f*T㞾һ+BTwJ>S% [I#yh+a0 _-'~-Q%6)T涫3+1b%,p2s~5yۣSۉ9^};哧(NJI8ix`3eF@#$y沓bx8/ʯXmbzZ·4ewN*)j_32T?J)Sn654492I5œ91$_:yR%oRڱEWvXہ6w9ƹ>XݘQ^Λ]akXjӑku#(%u޺u'Ur-sJΣv3xʝ qʉ &H'ֹG si7UG  ٘:.6x~+yI(6y3)VM2GK$Qz X]S;cjNw,E+FBp089ޔʓ[Stܭumqhgfɏɸ=O+vZ#7{)TZ/ ,vȝwH۶2zd;TU%y%ʜ'mza F'͐@As})sJڟ.{R) qOxtG2Liӟq_R)]R-Xڣd+6HƗ ėݹ~ϯy;#~iT#MeHۇ䓁{Q&#8:qoU VtUdƭvk-ddzt&W3,qZ{[ ߠ@84iS:2;KG4gheeep{N߿“$[L*Fu=86:')]8OUȾ:bՑx;{Mȓov/"2I>gvvTcM?"KXnVݦ+j9GGO}Rϯ9.<ooJݫN_c&I˚+KU\*$ <^U*]3 qRdʝG?UVo/rv =8)Ծ4J54 S I79򨃩VZFU+O+gܰij`ϧ9PkR\XIfUϕߑa)r5qٖJ֢s2Ơx''קNRjsw&E(!<{_3P<^OgR|~UR_x-R; qYJnV]\cӹ gR:w^?a*V%I.(=čn$Nݧڧ#:˒dw ,w+p}X7,5{ͬqsAsk^ɍϖO̿Ľ Sjc-Ѭ>r0ódsXJr֜I4"f;3)[2:v㚚GTcO\ce_ṳ ta+"ᏽaI{m:фy~ey^IYcxتUl21yUsGQSiw}F\+ ms6J厏1~&ۖR[q1ވ\MI{X/I.rf݉}GNn0e*虍qp# ,qYctt{$5[w:q; DXKK4LmGS gb>n{~κ)Ӌl{-L뫟-JseL=#)}cJ6Qqrh=ٙ>u)Fӆ"imĎMBGDk̍.]YI9Ysc%gcoFfY2pGc 7 :_^EKdƹfe꽏_֧Q~Ԕ;z\kpɵUhnaEh9KawjWH<1ǚdzӧS#r-h'9ӽe|Vc(-ZSe0ec؎ }e*vm =©el0R8U쬯cljwVc'VZK;U’NZ^Ϟ\$*ۉ Dj2 u3\SJ*.OɐKYfBUm'/ZhiK߇/shHPHs|Ř7"׿ԧj?2(cK'U98S:Ҕ%föހ5NHGOSt0C;߸y&bS9$>Q1W Tkb)B.idiqܽqM6XȬllA,0|Wl}e>FѢ(487F-ǨEo'̮u3R~i"{k,3Ip LU_39Mw:me{,|6A wte j#>ZkoZ ޵O\aViTqs;=6ͫIy>[" cߙ${ȶE Ut.TA9^;OxryE7 60pHSuZ:/ٞ],}MTmd ZYdEȣ 7ҹg(.xӊT|+\Nt-LІ_1@E^N:w(Y(/3SFd{82+,6H#mopO\u)b- ¿,3I'?a6Qb!<a=S\QR]~gndVfe;0ql-mOطkXP7Ϲdr9#)JVc)SM`S2&+s8L#Uߨۈc1,Uo.m=vjc+vRYW.93"W$iOg)Bps$U6%ǻO97?wsל쌬ܣ4©ʓ@hݍlej1}ѣd9+2U*]+ *u-ey z2}~UFR~7^^GKX 0xvҜmvzP7g2&Gmꑴ9}ulYsQdiG2fob'TRZEBeN~}BX@߼a: gCHNzQ ^ HG{aEQ)7TtʤPRmel6OsI7$ʆ&2x9S4T^ZX+maip,6ݟ2GG挕cZi;uZ.o0 rדWh<^Q52UHªßCҼj;Ijpʏ+SѓI ̸ݳ0ּVkZQvJҸBmx ^kɭx|:)_s8vw ە=yXʑэIZrхq/DOσd`#̏y4tG˳Zחϵfٳlyz֐I~u*THQVWs4pHcWol$)(Te+ZC;:NC8׭Nj.tG֓%vT4~c0p0s]Xzu_=V?VQf,B۷$l׭-/6g}DyBmڼ(R*طmfId< hsֽuZ1oK5"Jz#SًB/i"$#烎QNUnF8u@&4MEqnn溰[*qM6 -qn:y&.ʑ扭h[o3Ycm_`r 'yJ0k]/ʷ$+S;tZi77gw!8b9ʸIFV%Z2Uucj.Ovl@s򏙹ۃÛ1Wnq.XٮyrG|Zo.M(<~x|]w3w~ʾ[FB-d*+G a 9ʸK*jKwݱ}dOmt6/S:1-}6RΒ*m2TjSV4j8&X%|"%4e#܌ccR՜u?o2GnF$G#~b;9=+q8ݟ**ERfF'vO6YFd1޸<{n>Ro]Jb<&ZOsꪣN.ӧ*nVi.x䙖Hգb{=s[ZMV]S7d;s;n_kRYRK[+koR }@ V]Y| {=:V9?CJqɠՔm'qW\ri%O،6$ Uqβm[hg7rK==+sXS[t*N\sanNKp9tJ#JTR6Z?X$r1ͭ- f$* :s݉a3bBͻ>`l*OTVHߟ[載|-i1\^r/vWh|v;A2=iS5:Зe:nu:3ӡzQ~וUaFk8P.ϵcV2ۜҌ;<9ue%R*-)GGK͚qHXV^?/?ʹܢ艫J]#x[*~އpIZQiEtʆ[wkZm]h&צ|]!'fi 7ϩf܏ThϨat~>J!k{s}=GO-J?h<{i}k2HەA\`1z#߼5蜶״"#A4y?6w`=zK]=J6w#5o/-|ŷG"̡x'=BT쿯9rq Fqnc[c~w}1+i]jc<իsTw0kpK1r9Тhulߏ&/>i)f]sqRx89fLN~g+mWKecύ߳{ψ]w#y.$oES 8%βxht.:petp2V)8˯7g_ |~HWAn i\V\cE|~+T[}63\f4rwoKR{om_˒*󞾸2Ozظ<;5lj5˦̒ Ǩ@ouq֣i:WʲKk]Z)V\ۑy*Z1+:#پZn6)k2$>*ⴚsGCLax(cb>(rmw㠡kGm=|=]^nTn$?jQ&i>V;0#e{GFoyLkbArIr}1isI.z) 罺^rs+*V}okГ}I.cg<O 汊~O79RJ$X3@܊}4\|bG{8Ct24.gAQ7x2Xu=daZbj6`|0?)(ԩN+NDpLG\17ֿS ga[5*u*R >ΝH'6͜ns?U8~6nY+ cY+XxI&J%yItNqgӎ7O4y%VQԕZ_2m͓yH$޵%%+oק#@Ѩ G<\r9+/'dv#v3S',E>XIRNhUO_ƴvta];j?5e@L'RH]|T(D BwV<\JIJ;e8Ny7AMM?b3h)Wq_Us9JS%P(jK;%*T?4=HGZRb{SopGNz"Yx6=O*Q=ͥ 6l$g={sJn3ik̮d6¨>fNpɭW1RԤRؑ#X&ݾoqqQagRڅzگn;eO4c*n]݈c\y>ʮG8ETJv\'[يɓxsY*DsʥXS\0f8S&@˷gǧpk暋 R^͵$E c1|61)ĩC 'NQnKqBbqUėc~8sڲ+N7ײؚ+[LLfƍtktwta:~ҟ=a]y e*nP3a+uM'2NEq* R0qzW OiJΜV#SԑD>fI* 8ѕ=]OBƝ%ŗwpȡ n/$1לQRTM T718HT9J+FHǖqnk-HQ|ʹnR$O#gr&/e Y1:g*ӝu(FfDt]כy#p1L0#^+2k#:Ut]2ז4gcLY;yiI6ʜb~] DV\y${{iFWNoccn:V &&W6G[XGpJ1ɏe>J<9(<]:-P-+ T\|G'*C0a[DC"Wpke%bn=kY_njҨIZyY~̰(mw:F ' ccW*˿oCrǕmntlAlkȭqۮsNPdZJrT%bKx]xxʫ,-8wgW4jBko.ߠilđM2ݶ8x[֔a%Rއ<)ԣx7}v$d bA>oE9QT+z3)8FWIRZEܻ$z~rooN,y;T5VK˶fQ1^Ͽni"((}5FTӨH#쫁!'>t4ԟF^%͜؈1Ԏ]Xz:ݯ뿫')a"FUVזgN?[JŴiKӧgy"d(ц'=tS4J4)NM[g(kctA|y^gU:}kZ>ZvZ'w`ˑapj*}T ӾBF#Ό2fbKcw'ӵo =usU$#4X6ٗ_ pGҶjZҳL2)r{5"|{RF\y{;|z~uG(˞[QtU~l}ז oC3ʑלRNgmqVwYO̱ެ8_Gkg˧ʌ]I'YX0դe(˜R,-q,2*k}5RRㄷ-C8hVh:LP\6J2:vDZz?ga$I72av {ݛ߉twȧ-E|z#t(:xrjv3OK{Aq3G?aX˚4ݛO~&Y% nagFkJOXiFQi/BY }m ss+g*mI>*? wm?2̶3O̢0~T|ޒrZ[3RݼȣҤ`[hSHά(Z65տZ<Fh)OAHY?D{W RQԵܥ'7䌝SAhcPd=ԏZ5LY@Wn6;Ǹ氭WZӌM;ө͙FUv+d00b'{yFBnRV-|*ph?SYݖǙ_/FJJ=-8[^cnF[+)Tܝc*3Tm{%V 0\}MT)[̅dD3Gntc'c;ʗ-*SV'i$]4asGcΧRwks:^)7!{hfDk*WvX=~iiimM'm[3 2ev`37r2HzX-4G]?.9N[_.ee4rn*:x+9Zre*ui#LdXH%8k+͹EEqRۥ5ͮ K6 =9Uکw)S^Vqޙ;\[䜝}=j蔣J"{[ǡM-\{qڵM/r/1] =;WEDӌgvjk*gU4ln~P;x"刨lrTy['!kh%VrdYllnr*GbNJ^v&u†2|#6}y? ? kCoN4i23eap H+8;J}?AM}{w\d_-zNVe8NDua㈌wKt&^_c<1'i5~δwsZrw[[5CX#mªdp 臻uөIE]}b6Ѵi"F9'Ǟ0mzsԚM+Օq9z?v;]J5-}lsƲI  flq1*c4NtUPI +YGIWMQ]_茩զ;[fR8YI`r 9RGѣKw{zG*4ַ{knR,Q-~\lH̄"|+KE~iQnsm[Os/!!uYdx?Ҽѭ[86㮷UkHS]4^sEoюiO[ImtVV7ӫXշq+w_iө~y;IBR-LOJWSF%"XA܋Fx*zOSjueqvGEڢ|L>Ag}5֩*reTct!%+#{W,ˀXOӞ+QւK \еәn'YUcI*+qg88ʩ7s*_D^`Y7rc#T˨X;Je8A7$, 탞'Seޛ驝:sgA@MwI֜bFR^2)i!cgo]fP0N2:[:dPRW5Q(eUV <~P6b5nk-YU5U!x½ jTinJ*R_--̚pxʊ '~pmF7nOo/gQkt;JOiEJ*rw7<c}>aVRҳN*K@[Gُ5YJ .ReMIt3;yZ8*۵sb%'E(k"7ߙv3:Ana򑞧漛TZG'^HB3(;Xg#DT̗IӴ-~rL#M=?fY+ c1u2c;HA2qқK^u11f\0ӏnMc3ݖ}:l&FҲ6I #t6Ӎv6(|W2*0Cc[#Ue{wԔʫ"]v){:T9E`N4[n &1zf)j+ RV] b47;}qӧ^GqѣNͶ\Nw$RPc:krpn<ӔvNs@֑vbgjҌ-)#&tn8`܊LE~֋m]=ʗڲ;Irx99.Xsn5(}RYcQavzA꭪RkuN* v]̛$Cj;N9?UEM%fRpxD筎fP"Ց_>]sc<{7 J/I.Ǧ#FmѬ{ rFvJNM?-OJ#FNwg-wLҤq&خѩ(Ǜ_y/ETU#4vݖ'pMyugM{ҝ:-ou}N$7aUa~_jz;3 :ڷv=xqms Ѷtt:<6d%ӵsʤysTjM72,<.~Zu3d׃/ܖ1,lJMsFwTӻԴC!kV2Ē:֕:xYEԣuVmm];y?jڕL)ϞEy5lʴl7c-v+)CLOy7o˾Zbл|dg`wRSk掺*#9Wex΍qj0"usEe x3=>ca', ?gOHީib3R+G<ZR/f֝K6R3fWYC|`{jQBi_b<>EDoYX1ݻ< 8%Caר՝дⱑ2mŔCiU'ت6{h'5Y.A9ʻ#Vq} !ΒvЫz6+XcC wcZoc2k7lj5垍XϹKef+ yBYN>`1:sSuqG NQwK0PgeB፰@>םR-7m.e_R Ck(o%]$s V?v:jP#umΠqHY|+*XwW{2Ơt%BRz\x_R>iݴ>rTI{A w18ӏ4i ̠Uc )RКR}-f\iU)8bu%J2JL&Rm9UN%a.]wu]*9u+ŷ[TH8gưhǣ#' ʛTNGte3EeX@ee3su;6vz>ӅX8ꘕ8﷑jNq¶:Vl"Mb:J[ Q)E[[Z=Ԫ@?*GNk|- UJ |6yң69Ta߰i%V7n_|޹3Vw3F\ίK0X56d<*Fzq+fHVQ1j^#m#yXcw;~Pq:댣R| #+]{Zۅ]uFy's]5+1ܵ4K׈,?r)]*?QNo]x\S` U%*[[ObpÑO˴v>TI_ψ!Y;'c1mU9%_#գYV;Ϟa*~Ӓ(qB~5s4XX{u t_Rǫ(֥jp^Д%vP7ccgSW9qRΒ٢C1WK78I*x^iK W1lckc#N]b](YVyFUc9''<N]4ԭ+6sm|]TNY;zrSvf+q,q)d]'4T-9(ʌ];o&E$>Ҵ--.5edh7|O) ªppAQ׹שMU\9̵̨?}p8NN,SVɍg.2{ibZGdoFҖ9קU*GM.k?Ꭿ[I}i偍AV8', Ÿƚh}?[ s]Y=5֡-Wi,JNPٌ1$"'ѡZon}wG[+c_dxVڬ[5ռr]I9Gp{M,I%8l5FZ8aZ+K}ɭj;"賨L6'=q9RouKc*8j^۲[xMREq+gᇮAkaѧG:3;''ܹn=MȑK4<~b?i[ٽZz~hZ8{Y$۷kEkc :H)F }$*2y-QxBittg~j=ljYCɐ;A!IRRmurvKB"C66s'8/|`uh38xvVwŭJkĆx9$kV?30*G8ݽN.k^m~w.kmӭ>Χ@ osۧŽp@䓜:4vPRSoԚBFDv?rE|JS)KT04=ҿ$X+nz}jju֋%~];3+*83M;Q%M[cPiiwi<0BT@$j,%S.=חO[_%=Tt8_ 꺿|Q5dM2EE f$#ߤN/ Z[hޭ۲K#*j?%]m%7]p7qIjeS,3]<'i.]>L{Ɠ|,z}Oa/g'ʻ+7'}O`k#L|®1#'xccɍXѴe7 x`GA*zdsb1z\孉SRսM 1ht6B9G g i{3E >noQ m*՝ܴE5a*VpQֱNmLt#5RXn&h8#oq^'s%5Rg썳`G _\-Yuv"X۴`1ރhRqIa2.i +6_59YOs6NIX Z*jƐ,ܖ?j4ED?&hSc9%RRM+pFVrRhҝ8\Ϩֺ s6~ gsϵJN.ngMm}:Ȏ_ u֒76+zI[ܸX`z1S8]5"50cB>Gh?Nm{ܶ+bS[Z,G *Ӛ\[ | .kurI0Ubi$FbPx`wsqUNumzYe$WVu1#iX :)8Q{oɵJrwdΗ[xE%7`Nh7tծrԊMTz_enkp?aV5;Tv>ϯ54T6jws$E%bY]>G$*sqqNw2k"h;I~=y]jRUN1|utاp.4 .ᷫ~=kSR\ֿpR3WKKpJ^\1d0W(aenI>m͆F(::OʦMM?aiT  n;#FBOǧj*2IWV˒{Zt AッRrV#|ݿVqwVPʶcpOVsuG}٫YԤYOq+ȫqp}}}Wq+;c$k~\~ʟn!9?s ďчq|Ƿg7ϧDw[o 4+=tN[:vi%ַ/8n9893b{>vrZ;5cZmkX%lm;LƦ_]aaaJ0Vս&è^\]\+ýw9OK^gS֠N̥=:N'w9-.L'Fv^eh^g(^,pqYҹbk:iĒC/WT=ڋS0+8O,KnJZɽSfz9V޼59dVnWN2h\bP}=LQ}W AnzoR6gL*gM$8=yd63+eJR' o}=uE+m2qce_Һ(=trS{<ՠ9a$[={,EN2i"SE+jb\xkҥ5 ?潼Nq =}~gWmɚ0ca^2Em>ޜYj.'[0kt$dki89潈Sx.JsޭꝴKW%I5XpX$D}Oo=3[t%KȀw)n=|QʕĔC]&[|E^XUYwc9fXTMwL*8~yI7ﻭ~^x V?3Lp<kӔjsI:=|/)yy~xa`Q;ɥ`S.7apѬ,?Q7{_^} Z6K~M;Oռeܨ 6=N8?)ƛc8M>?*:e YwWS/ N;Hk+ve߽CS8s$pƃոsTTSMy+4v/}vQa4*-#:ר5ύQԔd2a襧ǡoVD-0B]nkn?EǿZᧅEK_o%Hdmo^e[mk=湦yLM0,clzp=<`k|֢kyy̟WyNE+f$ 0[L)Cϕ8γ\+Oٛuw)Wg#JQ:SݓӦή-.䓵{gȭO:!Nv&_1LN̽ ?ʺi6Hc`P-~+N܌sV-!ʑMo"m",#22G;漼W5<ʼѬ~(ǩ[G$uHZ5`1\yp*#Рөw_K^mmgGϗ gs`qIRT^|vF4k}Ŗ_gW5J/hpb*Pq} =o6,# 0SߚFmK/ N-/2}VSq#ey%X=z{}LE$㢶*{;^ )xdOy+u!(Uo<*QsCA"J|ǩ r{(I>\c(7ױ5nOH0ȡUpsO]ƝO}m}'uЊ[5ܟt7ǡf$YI+'hr}_Ўu[9]Ux9})1k SXi.o'y: s3֎[E+z|ٕŌ3]E9J?r7i.šZάʭ|ۏSIr=E*Qȯ|=iTÙ9عi(1uM-y!:Xsκiӧ7r^+tH /TdsJޟRZ?ko,/L1B[i3NJnseǣN0O\}8Gl#O5L_3Gٶk84oڿ>ǞXsf >yU;FRg (UǭN.[nlzϷZITs8 TLU_'p'+(ɭ'rtݓ,4(n|mˎAޱi;h8ԣNIr*up:qZG2Tu]ɭTiLCm~zW./c)s_MtJd;|Bk8% 5B!c#iǗFҡ%O.IdWݴnOKc(?"YDT>X*Gz5*;Jk_6T%Wo¯,+7s׏η KjTPRIo258/$Q 8SƺcRo&>*N~E+e@ۃ2󸎧?Tc'ˣWadO<7 ?j˖ZoRʷ s )fB8 f+?3SVúh"WkWUUO?ʻYEEjc*þo?2^&oQ9h(Fƒ(n6:ے8e؈U˸Hݶ0nuS8˖F"y[ d)6; NԹm];zӍ:2振%q'2o&\/pGZzfV":k-U!c T,6a瑒:8dU#V ZM4+ @;b1snH{q"o#GOg*tmXr$jAuYŻa(ӧL*F2Qظ5&^*2&i0sFy:*ovDJ哵gsvWRHYv`:~%T9(VmNIE+#ּJj>gR4!Mʋ>^Cdq횾i8/$R<ג _]ȭbe*rT.{)iFR[Yl_yҦ4mVAui@&Xu(+>*i'旽-ߪ/i#y٤UjN:OJVl76̻^/=+4aRTMo 놎?ݪܨpNjjF5)9Zwql\Cndr : s9QBE99]H!*cVU_?wcAIޤwwI0-fM[Pw~vrr޷Z߷Dy[jaw pCU9+u-M"',Rg=NXG)3粪\623''* N1Jwm%vchؖN>lWO_Ԧ܆mDyÁОx)f S䏓]I5țu'?0ƗKJu 6Ȥ)y!ڠSu|fHm:U`Pp{;Q*~ƞ_"0.nz't*=K_m XF㑡&)#1J%ˣ:,$7{h rc"P mF9oZVFvPkc8<yliQV܉ +0v<xsHt;0M%j-P=Ŧ<=zI-K>ޮ 2IuRq'8(/_&:Yy$J_=9荣gsuRXW5X޲{HnxOr$ r冑`w8_ڥJI5ޅSaVI'8ޕ+o]Bg z ۍOFƺ"yFHjn~6ۃc}Ӝ>"nh5kB{mOGLj=U*SIlƘ hzyEcԵ,xyxѓ6=OSG9GDf3}VhV2=1z[r9Hf2oϧ^3Vwy';GdCsϷ"~7?_CXs3\q}zVj9~Ɛ7Ԇ{𤇕EO|eJn\yVcL;2`iJ7i\Vhl:ľfЬ~PJW~]ʲfyT Ǩ7~WQkgW,1 67*sǾ3e{htF^4URr$pbfN:Q4|닥2JH*m??˚y)(iE͹+yE ݤm](_y$'_2%ݛ0uy{p8W>w>cndj/ne>[z-XgbҩvӜ:#MTc1Qc^\ʱ )#n OObOJ,mLiEʯ,_d6I^1ϵi*|gRWPԧ'#`&}G9aKd t2}B[\&&]%pTke^T$wVV_$D˖"cOٻu_ƶݕnq_xÒJw #6'vc*O^>Ɲ6=pwpW<bR2OkEǙӢ˯nLۣ|sn{zʟ5T˯ ݤ)$+!m$m9ڵN&jFMZAVy$ۿt8p;rHsW n"LEI.Exmn$1,+i3?0ڳ=T;@M9#(wzwօ^<ܚT9exS>hªT 9c/`~Smc&+%5j NܓE\e e)H4[>ooY|m* Fɧ>f֔iUwIgx`TF+h9$)W-뱡hn𽻉cuH|RNx=krЩ˒rmZ12-XiUi:8JR\+Fo_c}ɚVN7c=zQ+&g{ _Wc^kN63tl9=;Sٷ)c*;5V+r+D˵[ QVZZ0猩N˩By)eF c=^Q;cҴ+#\yen[8pOGj;V`:[tBD>S_|5mQxꜷk| ey$tϾ3׊S\­Zܫ]X71.w3dg8>XGT彋hzc[셐* v~98KF@vqNz5KNXJYPMU]yNYJJř$0.&\0#zY]Mc"Y%IDPX>FfqԈ X\IM ⥵Wei9eZ5YJ)RۡQKs!}NEYNxxY{H6Ɉ%R"PIr÷yyь)WKAu w+grqтl.*/MO&"ymvI$r:8<ݻ_?Z2{=L=gOR*&U'ӭyա˫OF:?bvl[2d?wfmע;&%Nj% _~q:Z=ZEYF$]mͽ3t l $, x#ߎ J4#zsY-53.H3A8=O^ʚ}k '**MS"Ȫ2d <:[~P)RO^ Ћwal0Cҽ,:++7b"]Ln_/qy73%JV2:ubbnT@3 ӕ8QyʝHJ Kz. *HWk *^MtW=:YMXoo¯ V2GI.m:7e.敺a+@H.Z&8(̘GMr3\}fOr7<֔,[`okNU9[l>7f\H[k/>\sǃNWUOr\[呲BƠ-vqSۥs9nc[×qwiՑUrvg*5ɰ0ߺr=ڲ6zK{35vj~O5:~i2n{6\6Oˏ^NkVq3[ 1Mᶅ|t/dȯۛfVۺ{w)Qc9Q'5^7,8lGӸXaӣVm!+{۝#=rz~O+ )a$r֞e:-[a#9K][5,& eldx~hsA_C5e+cCOnEۀy]Z㍪jVA$c-SZJݙRVۑֹ/{S_gf_Kkj1# <;wliS1Na-DE2yۤ*\#צjgN^kXoQM\"HyX*6)*ߩp"z~goY 0}e^N7eA*i]LєhE5+-)4aԇgmDO%9>Ќt5\וtQӵS.oRJLrNtR_ e -["h'x\@糰 $a6ĕNsT ?-IѩSDw8xbPd>Z`dRCaW5=5UM=x1\3Vuu]kzˣjQ6kO-% $`dOrэ}j׮=*p6j/*Go:T b{d}+ϧRjۭ/OūeAwm.T}$72oYUL 9k5NG(өEJ%_5 <1<`﷓qN9,z`09zԩNM4ϝsD@b!y6+̻W QzyVXn/~2_b7:z[ԅ.G*{}梭o1bnCAϵq2R8.h&_RQu%y䙲HF5~32#Bt-Bpi*r}z}>tk\ڊqږ[iPhp? ci6^7}+S)As'%ffJ#*9Ԟע%)huab1rjly6tv빧ht瑏ciqa{IQju_mϦJ4\U&|.a6Ѡ/$w|99'bQ z5w~ƥ9:[}lt4>ao 29t=1ۚ,RQIw|2{f=5Zu`4MPffoN ;굝jZy^&:uM5'ƾ[ڿ)}j"&'/e?o&5`I(l/Q.hhAѕO}X 9m̓Hy{py|'5͈4تpO%O=Ւ]5f>L}q=IҳΛ9RZHZ0asYKvl|ժr?";4m#wzVjQ\kTNu!9Ъ՘q>=x$oyk^Uq!Izr['Z\Б#Q9kȳx",G |DvC9gՖv(6 HVq)+9}jN!WܪSyc=jTeQb#[ZMbH sOęڨYp}mw$,1^00 r}Oz%R8Z<,%-?2]| y`T6Q݅qVK٩ZϡWUFitqzV{ZKyu6|N}kTv8 ݃iJd*R~ߙR(_NS?rFG$A= QZ1ki*+s'OlVu*ʳN,g.Z&f-i#Iܑڰ7+,A+XYcj04[ O1߶+(UHƝe*.?BkXX9ѷ${_. 29v8i?k?i{+U!{( [pk:.YK̹^JQJâY aC|CcV-su]:9c~El66 yi݆?Qks"RGX~Kn 7qpͻ,˒9?8Ѿn-߱aDtղƮn;|VWiiխ"cMwמ9q\pRjWcOܸAݯv8y5i8|ϯsϣU$AM%턋Dq db t9J3׷O*T-Yy-#{~RSiQQGC~Bd_NIs[# qrI;D|>incn2}Dy\<%nY\ҋhuFUȓr:a=:gZ+~bl㢾[-).m߇\bU:*zgc6I.--?œO54 7M?O!Fck܃8*4R7kv&6>KQ*lasoO(֏-TL{XE-ֺqZq ƐemY7RGp/<4lA+G]ΩKrğ1{A3/ʣwIlkNiN{61Qo(pm$ncGQ}ܞ cJ0[Fz2*weNw0d$d4*I9Et(ǖvfnY4Dbm4~c SJI:/c ќngvɺhݤPow?v6%9sMq"<][Bw6v 1ׁ1r75J&pQY%̻Ingo(ʲVߑrg]oҮ2{*|_i-Z.aWmVۑWN)ZW"hLDZJ,i+oxu?2=;W~RZXzj?hu.`. H7HǖU@>gVҩM+KGgI8*qw35[y&8?ec'O%{{ Is[FSR]^:m:e‹.qr=kXU"5VNWTNVXˏ+<9ɬ8os+j6,G̒jN\6_|yx$pO^IQ(J,aeSJRvV-$TY ^tOW.dwCF};Vk#H岣$9{§35ys53Q9 3tϦGT)-o\KFc|XsҶ(E^h1v["_Y)ܱ۷q}}4e>ehڎ[经svr0A'? XTiOr(AsqϹ济4c۠ڴH$!~dsV[Q+l$ڔ?QU "22>f8|ְ^y:uݵVT1$bG8 j7@NGVq}[izך35+ֳ;{xh1CLeݍ}T}CV>[43$wRPͭJ/v`U_1JXRLw*Z99A{2@\+nRYq۞baRv8ԧ7ivq+2kmq?p+yc%NU׊GƟ[_m^deI(><"F'IQ8%}MsNzZZ7-9kjr kS=Q@b[K xM}/o3Br\,moN`~UME7cGVm:^VsG 7qyJJFr#u7[7.~UԄaQJ3wKUct+2)-XUĵRZSaI?//3ӴUe^\U$M uDGGi ml[n {qq} ]XƷv:M?pA M Qd9*{Eg4 ].&YULuY@8' j)jT/w~Ru)G?zҝix9ToNV׭"I4}0PHu] ﹠CNhJG8>f{{NNW1:uyؕw·N8#YTV =[3V7d,KOZR5f)OSJ>Y-dپ&FQ{Y]l~0o#rbStI{%vֽ2M{rzjkTRtna5U8'k:{ɘƢu9ְ+*|?* Ӟ3ܯ' Smn Vq$pwCLNխ8Ӌ8p؈V:VHFS$=2}kzrΨt[Z1pټl,޷_ {ʬvs3ƾlo%guCHtQy*Ož1"+#TBu=MxShԊ{[BiLf3nUf Ӣ%SU{-ź{mX̘䓌!LSZԇu'ʣv̱<[T^9^Vf&{cf ;qqYԴS?iwM]tQ6s]|ۖe.s9Lj*~'6BiVрv.7p\r|T _%c ϯKS/ԩFy$o8jr7&^Sh``r?*5M/?h)Ij-9.ܞIP )Wwp\4+nS0'`ֹ47cMB/KI1H2ls<f4_7KJ`0+W6^[ZmrFw6T3m#sr>cQn_UeGHha*rDmfr0Auy,fѩ~HK+X``}Gl*Jv+EZZҵrsZJRRRC"8-Z: ߷c&"R-l_1YSpR|5杖rbjZKyen{8mq\c.W5P(&=ׯ8ʒQw]neZ56RHݜ6֍I8[E[v8{OcR-Y6$"XZYB#O1[pGNGOJUeߦDԕJ] Gʗ*y~+R)]Gsh֩FsW3yɈ 0a';=*FJZ#ϧ[QYd1JJ{OlVTԕe}݊qߗBh.!!i$F6R:ps[Vdgn"<Ŗ#/ _ghَ^ҼJ*.kAnh.ۥg>b$iˑZpZMt8IQn8<e.m]Tkrl~턁*1;֕?es} ')-fD!<<Fqz7ɯrkaZlbeg27!RB+HᓩM)IرZ\\go3oybݶuSxOEj>jFW[X]sV,77\fuH}㊻qN:~teN Al0i '8淩R2Zqqs=UY)'BqZBTx|NTi;3ЩN7Z;˫{.~5+w' ezW3bhY[*x`vW^;c)(Ӽ>֫wg 29_OB8.ֿcԹ7R}BUHD(IٝxXپSWOX$<$W7V=/N2;OAorqBe=z}8jөNw~l}UY \W:? 飈(hޜuѓe8nY};s^R4v1蕽 a(ZO`Y;TT|1pN2^r7ۣ`Fc9ZmNQ|RF{gWfB]e^3^p1GRznmN04gkԯnV$_-ңZ1]NyVʓZη>СS ~֐We8EEnFUUǻ{)ϷXAjRH|Cgy\0*i#Ueg 2=nRRrRINx銸5"uIbyFԓ'V9iʤeϻͭWYyi18>+%VGbM^-Y&rv#]6_3sFךϵv6,黿>Q⺩Kv3 >i9'ejEMLlPmMߡaә'_޾*Sq(Gv9 vo'e_PztӗCΟ+[C6L7r8ͶB֞ݵ9JՒ;_-9Y:u*I{ݺBT^3iveUϧ=*ctTPFL<˦n?0mN|I{NU9HM+'L`nVoUۭľtֳHҝ̪#KՒIyt;>ErZɷ {_SPmF/T[}o˖%Fc?<3JtqR"EFVj~i2"xkVjZxRxYWqyycXjPHFm͍"Uۃ?[ѪQ&SyVo2'g$VU |s]q%Q;ˡ*)ϗ^ʣOgKĶʿm 1Rcx@xxꐄcƜKnzݕ@HT74-1s|Ī%.ge*7)mh사Ҷ_݆^㞕)JWpZtjtcVwLX3x1*vSTmZR nr9<ѩ;u=Zx^{#iZefbap<y<}=Z}hBcfվGh~"ј.F˷zp=;ktTc}:te{Ea ' xYRqj-/s;K,l* E%Ooҹ}c*u/A,H|Cf[_W4gh7]*z'i$H?|`}Yѿ= yeFͺ@NO'Nբ;%}R1o2%`q#9z"h)k/6i"6;ʷ8n8Dc -IeEOn3};<䜼sNz0G#JU[Ww*xϊTQdU:tY..dnTޜg\u*uFyF2LevUr 5)^ǡ*6W8u<`u=3yuzDtJ+nGt9#'WU*v8}%Ð?Y[ #<{ZJQ͹&NXB}4Yvx98#{Xx== ~Ǚ(|̙C*Uc"-L{Մ{nz .)A+9iJʭ&vڷn%R6D~""0;|ryO'<7;#.ZiyZ[Hv6' zVrٿSH{r~.f\xY;Qx ]t}{գNQ咷o3B=JT_~E91z`?Jᭇ:LV2n/ 䓏,Lw$W[Q8NGy~6FxͺۙI67̿PsFҋmwSi~>U?.8.4pU;KqL1On0|ɍsT륻hV3('ЃTGl2@>Jݹ*om:1N=/_ǸɼFFQQfRV{W]Z.'f zfh]vgF_Z~SY,n-UW5J*ܦrӨ.&Di݀O^=Ji+bMZY:\USW3QSk_N7ZޘLІR*"2 /WʍVѳ7liog{o,!K5'\g?Μ(Ovc:'6p;R*py·?5Iiߡ& cj_[v+fm K]QIͮ4̛/ S^$^סh)Zf{/PèM{* _L?.ORPfX-fRZ4Ϫ>ZiVLWn{sב߃xعq>*{E=zu4>3x];r`Wiy8éw.އyޮLWZq~uUw8e :`O}K٨)j޽JjǞ\߳t>գh_J1ތ(;w|llqҒvݵ}5u/KZn?7ZX|p :2{We:q#)J߻}A;TvߧTI`};Zݿ_ޣwV d?hUX;08<|uA.׽z֧OZfK\cd@eZjR[?[U0>_xp]xk63oۊKgyPzp/^*|+uڴ+FM'xkjoda1[$?0y'93^\r''MTNmmݞ},qXެ6v[f$Ϗ<æ+ҧ?~=,>s~i?ro%ЌZ\Y[S!B= o[ٶOn<"y߈mRg޲o/ $>ryl*Y_㜣RqKŏwVKmM۵e2Aq(8*^뾖a tz('&4jH.i(C";:09Ǘ:qSoCng>>(7K%/ xv@_=:VT:Ip6/8${`x(9tSUy>Z4U+ʝ^{q+8^ߖ1V]Jrc=6ߘ8$g}a~m(Ɵy$V" `>PrƞnI!{p@\x~DFOqXA?x73ѰpyqW.4LøN)`Ů_7cFMz_Xi۱}1.iTwyqƧ.WmWo#2OC[\=~lJڔS|M5sO-u #qnGNUI'wg3C$uFF|8޸%%̬m,^B;ۘ0v-X#H'W&'*t6o&~˘A?+;w$zVm(R{[hZ\%ƌ0q}xG_O:gR .$ҾI<沿.߁ԩ.e$>Muen2W{)K5妧! k+~ #]?һJ>(o5w74*TY,ẋqm/qޥowyhEPx6Y+In|gݱ73Ze)A=ykrWJqZS}]n$Tw(m}y=Y݆}-g #TC)FC L)n38JgR2JZW+*(rsϭ8J>^pΝJuR4> DžUY ]ե#hJ)|mO & d8=xbԢoSvsμE4mm\L0 HZ3 4w/ .Ef>det\u6GZ_sGw4h $鞆~kV 2ӥC,w10үw8ޟ\jRM%al^deVZ&R4,i΅YL°wgfRx#{ߍN)5=S яjJݍq{$k;sgFk({.o!TM=ygTfuG 外oHU@qYTʒQW:zD].6PN?URwf5*4g݌G,NӹISrzsZ"׺EF$ﶚْG(Ec& kޕܴ9gRWtjX*ĭGs>%2%(ӥMܵmkYݦLt#N<N55W>T! I8JqAɻZ bcFۈfU9n5BhUgU36wmҸ8oNȩ,EJm%j#2J˕&=qR7iSJdm-#5Q,~aOp=J~T/gjMYyQi}qշȾaS's늏Q-wҽ̏.؏($+_V|=e0^4Orǖ2j.+ MːH%-e<ѩ+wmNK+IS֦\N5(Ӿt\oRcO捤rGZoMt<*z3:JkbMgcuwB#c}+j 8cRIk%$@*ƍc\U4V)Uk^X^h%Y7\s^մ!SXRJe! \܌dZޜ=7.Jjk] 771Fs=zViSWym4k9g'=ҮfTj)7~)SN^J %k&aQU~iZ7\<@.KW89;շkQm%5L,l3sA]|Κ24j&ߧz_dJQ^.$R"]y7mE#sg p r~/H\V6FʬR4rpq~*RKcHRYXcmV>Qs~1hU#N,3TYpzqew$eQNVha?gU\Ysʵ))F>,Uux)2ؐ0$>]:qKo 6J2ۡvY ;~8Q-ͩMMzX6.0߈80\M:L>r{dfV]68N$zMrV&XculOccJRt^In&OնG J^3)SZ.{v7ʫ|H?EE=Jqdؤ}S&#v>εKKgQϕr=m*ww*NBڰv1 iRܡw6\*9b{^-HW [ۍ7#F=;G6Tװsp#\a_s/0zⳒ.(Y[w`z<\=d.?r# v[Q'a5M-)jRk&[1:<2H\ӻשN|v=?tU#y\zJN 7(@/.Vf \iG7kB$ܓ&kK=:RާfT#kW#B#y>TV/Gg'F5-^;G$q~Q``g\IeEN2:rɱps?AZQ/sӷ7$|Z0ٕb6N\gRz4imX˼մ*sˑjkK']t0&VRG=ܫEc$d8]luG)[Ŕ 3"d`d+S.RIJMw!SFbv)<{OcX?$kFrCI^IUTc$su&Fjzn0rZ PeyqZF䮑 I+(pZw?0q78SSTթӧhi^Ax"dO`s9XVzocJkMK_g&?wy@?1[b\㊌k%64;nX@Lw=5i.Zfmj HXak;|>z4*Q|Φ*:OߡpFbh4XP)_]t^taTɧu<+.ߔdK{=+MvUJҕU6fiKpx<w1WmظU5՗dc+䖓 Tà=}zj_%Bɶ Ujybi'YSMI-ĥ$tbǒ2}[JI$أ'ʟx$(VowRtlӜjs%pPJQ%),̹;d\qUɤk2U>[.G$nDjh##}KFrԗڧԱ%C<0 h\rk>dS٩ZM=zڵhᤑO `<KsY=h,c66b #i89Tm[CF!Y@n*NW J;I=FV*3=뛛ЗˬZy!F vvG<_)xyYt30enYK~-1HCn\[ RJ:#/ickxFۙN+~9R#D1I~'>Q)E} *H{㞼u}nEr2oݣj7zT#̮TT4ܧ,07 ?w'jՄFe1"^ ں讷:"NeBtJU<%_Z'{5u4ye,DbFVNͭWF}bXC2mmS5:MM6ٿ%Rb4_. <~;wUකx,8|G8>֕=S1Ijaa&2ӯr{U9?f)rs'2ݗ&==}MTyjGM 8jV'2 4#f_\ y5cl<;Fv_-לgOLu>tJ1OUZf@;U.wcN=늤ycx..>R3B9+\xF5e⮬G{{ C+>$W:yWsTm`d%Na}t\Ur/u]"n-߼O׉nU/59[sRFTWS]YOyU[uPe)3"ydMgV&~~ls݅xU-fסZOz3"y? E"I2v'srq'LJ#tủ58<"Y1rw9NsqSN;U:kߖP^S "9R9U*F{>iJ~O"I,v28)݀9b 0ԸTiEy$LYFm%9ԀoETWt}Sw*a9"NjWqkی=gN;>̣,G3d[r:J{JvmܧPщ6Wze)E;_SHԍ:|gʿԞo<ȼߵzX|,c?TcESU!a`Y [Dd8ߚIYu%gzkvY##4oN=2ycE꺘bu`q= /̏n0+'3S/u;3ѩNL;p.SLg?j8 {Օo.#EF^ 4~g)TEĮS.hR*n3zg.huC{ɢA$Enr9>j\ܿrqdBnsNxv["9%t:xp#IU26Qx&iӗ+5oG?&Xa,i*@G8z(Uul-. MWGqEJ1tZխilU?|H*6#5nW ^Xߚ樋j v%yYF1iƔIijԳ牑k+{ ¹jSZ۩dRY"_xB;<% tj.7ngS9*GlsMJmn+=Ew۴?:Ql\$V#[Y0&&|*F5/#jL7LUԐۀotg.kBK#U2:0*}~ة*VZ$yʭgZ4.51̪s*!h2^{W6#=.sJ3zZXv" B6ʲFJS+췈ċa@nW-I{h5iݻ6w-d 妔8׎pq\μ?x]^Ws|]ZMe]jBs׊sQTV>RE0ٵm%)g1؟Uz)CIhz6oQ[HG2lm8;}ApIrw;Ö0ODӥ`Ve71SڥH7?B橥YDEV2~PF3<:duyKKN7[lSJ}*k ?G' Z2 gkRTB%JIZ_9GAX/M;kG8=VUeH\kZrSR^kNiSN[-;/IycnuQ?ȌsCZ{.X'̭~JJqGzjEMemņtej2AO|(0u#TJϦeRue/ec ƿgB3L\9UYvGUyhM,,Ӑ;;A>cǏNK[vg>`c2syx}+X{8vɧƜ+| Hs\+5,yU\Ԋi_g{Y&?>1ӊ漚Lcv߈?/*+r`ObQ:iT*|mgU-_$Xأ.:{wo¶ Foo3BtE]=M3k)%Fh"E+yy9˖"VZ^ΊQKwZDGcKk#aIH#1#%(X4fZ]ױ 201LXTmu*T!Iz×_M%)x"ۮ7.@O\5ԍwshZnYj1xGnuq4dYosیwTiUZv:g.VMk}|_,xc0A=(|$ ӄwf{iҶ%*GFyoy)%%gRi+9.5]^N)`8ťm{[* m$ n=k22~CT@)q8=קOѥxI .1Yƕ:u.3ͧY=Ķ+Ih!Un2C{U9yZr5:1Kicr <o]9[n&HcLq`a;ƔX-32.⻛pǸx+/iQԴW&J]1\rQwmR?U:UԒ!-ӓ[K88`ⱩSVyZgoA<̓ݸXԝS1.1mZKl[DcQe<=+ҩvZ'naFy%]I-HEۀ2OϵcӦA+%(K܏ԩӛwoiY@gm'۱5(ʔSr{z [UfIg^q\~<*)Qiz"j >M*A=x4ڣ((5+V(ku/+%F rD*B0WP>/+3\6$6a]XJX<{ndT:tVҸBf p}raRJS6ޏ˷q?Ҟh#mnGN'4vrIr̩S$>9M\:8z6RU?0|[zdvb4#WMJuܢoe0A$YW OwwBv$lo`pc߸K?nIg* 7pj)=^wbݗ`UUo@8<{E4-$<ڕ1Pq;YieU9e'uӇ&6c'ROт]AaT4oqxhGzػ\a.͓fڝJuԘB&W]?`c9Q'ǫFQToQ!|,I{c;zVnq*M'bxR̪HS$]8ujR+GKfGhnFIG9jc>(t7Q9%tq+juκjtdiqcF_ xϸ#S9GW-}_9e\II:~oQ^2i2DkYv:zTQh>"Wwprsr(7r/&#Uv ͆]^q:aݧr7bdA#nb~mʹ}dy-A:҄[KN`~mP~*9W} R؀ٟ.Kgu 7 7bTk:qZRf2츅Py*5~Ijmz)u5 F&A7=[ǛY4+NV6V.Bn1$W9'mТ4FYվS##ؚ8J+6Q *᳞N;ƥOFu)SuVЎ8.?3G#3KO9 ӷRgߩ,Y9®R1׭kN[T憜t"(UUd뮜trtw۩<$,l71laۜHdye4JsЅ#e]dfLك.F={w8u{;y=u8Ǖϭ翖}Ffr*OcnUH/{Dg&$I^WFIW]*Qo}&þ8iFZF'i9i9+z%8O)-xۏ?\gZQ4#N|IJ:jr&Fg@@zsN=:!xıW&hp%Y[jnY1p <s I);ftJ1isRG"ذoz{Kݒ<꣔^v&YN~MB6gm5)z\Ųnf Cnݹ;;z{[F1]}J"lSu2eW ̊`sH s[>NRmCFoiΨ;r̫! Gkc 8[ORqԤuddسǮ \jJRy{XZJ믯MM-˖Vٿ$ԒB/[jvÖ7= P j$+ׯׯa֗49?rƍiZ\Vhq A?Oo4^N"|߂4qkM1+.TIϩ?E(nsSǛGil$̑,˜3ǥU>iEIvo3hӝ8뭽 ]6 VQff7toM$ +\c}?JӖQGm^MkD(:玟ק4Tpm8mQq]Ac4LʾeĘ9bNs򁊊{]t2?u+յ x(DI2eO U.^WEC._~Eˌ365aDrԞe[:Qj9[e[p7`n2yE)C'/5iOUk-4ž\D?.QJ{+F5KC^`>I՗s3 z/IVNZJvjʯ|l*sH'~1RM.}'Vemk{pW?2^iJRg=*nl>pKm~5WwF3 oX=iv"(nHSvl=ӓUp;}kh"H ѩw;'?֢DxGpHpNG_k JvX4(vw4좑̿*(=Z_s41tLo]ǯ$g#%7wcச|X?gYvFR~rjoڍKz K]p2=}Ƿ5)NJ֌czkO=n]+HB21O~ϊ?3m(E`$-qRAV##mni VӴR]UO)K j+s^zS@KO?sӠ⷏,WuUtf "KHvm`t(-7rEq,qŽ<ʢRv{pyұ_,^弼(9YsYyQE)lȎmB"(fVdb{sޢFVb0In]UlpDB sQZR)[z469^qn3qszw>ՌgO`^)n.^H%kr*Z :kbPc[=AߝrK%تIZa|Ddf_=9YJTF5Jkבfl-x(\F8Vu)Kk*qx촷_TBʬ03asr2NZ֨z #I",#2:vGVn1"8njmFJU%]d4>S+aNZJ3N.pIAJkl|ͨ J,#Ԏ+'z:ss\"bhd(a/9o= J+[g;^K}?Ƨ7S:Rޝn0\m7|>jnhVyo1$QP2!oV2.Vp}voOuL}Q^]4e%i]]t-G"I!8n0czQ)K{b)ʔRkkhX4<,H)s}Gt_6)^9)J[_rЈR9A&@Hmz~~JI˄OmrXxD| W'=:7~ndA[. #UƳ:yZWJq~y/02YeW y]g&kI/8$8"HsV㌞Ma'dќs[:|m4sr08:V1(Շ:Z]h<#i8_֏g1.zw8< =g$;}^5+̛w,_ϰ5!'1εJ碑]M1K+2: 9j17s12nߔrnqY){Z?#V+nY'nw3*eFOoMԕN{CtZu'C@-y[Yƴ'uxNi% oƖ{dqۻ ӒDoEAIs/ a[3*S>MTQu;fV<8׽5ӣ9hJl!v/cZaS\r؂a\4㎜TUt̫w {JIU-'0ge99\TwCG(:vEׅ] e9|=iYjwZ!f~TON)5t{Jrg}y&Bym a>\v Jt=2 V;䪮~~yW-hʤTgU(ѩ:6(n>h!T^k&2bF:\B%G=1sMMgI۩4*/2@rѳ6X?.U ϽyҏDjtKq FKyF-!(ϰ ]Vob]|+^"r[ռb_Ms)9J]qh`2܉UW̎?oj܏n\3dMQz9Te党PG\. 9}k5NTV8eM֫˫ɛnq1ҽ,y+7*C>[;jkXk7lH#WQ!_B垭nޙ *U+J*?x2ԒZ40,dbvLr#DkKEOk*ݙfFW@>]͸/n+(=NS)ˍ8D3w+mb:'#NghttԢCfɲe`+QZD֥5}w#֣%v6i|l{s*s:|jtTv;s{oqh\y4kU*3^7OʽoiI]t98򸫧gx,)&uE`v| %Ԯz-۷NS4}l~V*5txo K2equa2\YmOMת'N*OfZK}WK_e-a/'f_h>zdjίyGRXNK7nɢ|QRݙb2:8 +IZԍiTR|AuYQfuڠD68MZ5ٷn:u=N_?y̫p/)Jݾf5is+E]>sna  9+Zji>ߩtSV~f֑;[ò8VRnPy8s]K{Gԉ{5n7%ݴ땏l#d%9EjwS{J̯ޝϘ3 )Q|Nz Zw5_gؕep۞^~FW~ޗ ,c'n\Z@)ݑ nC\?k]*vq22uK^1oiU3-aNgkԹƛNiG7d"68G]|G+wʒiw1?,ÞOƕ8T%kG,~o/rEt:r,D}ҍo #ma]c ThY8nrG٥{uLt+3Kk+rA>5ˇ+3sߧs7Ų݊wd{u)jzRin-O'4jB󶊔Bnjk=}iՌ[qօZzGrFᘋu1LuWz.O_"H~fVFRNq*W:-& 6sFVD_䞘<1kΖRIoh>CgskcƔ(ͫw:-+u +:U8'=G~5yWoS*QRw]ɚ$-[hy`G։SFlakuqI 탟׎RE_]I{[Ti$P$#kĐܞQNVԮzɽഒHᑳ5{vTpyOi,Wf8%F^ԫk?б 'ʽիiN.6fpF%"Ie$nWCϜiU}fߩcηZX_88t\k(Ss.ֶ޾f&HnK>ty(ɧdϦ.Bm?y! fܻПW91ögmY5&oZJ/ ZLx7(K@8-_ztӢw׻+p˨+$.b #9N#CKDޖ<^cujK[;Oy<]t1URv[Jh=u9i˫NI'd̖^k#ߌ5)eHdzKčNrO895՜cS5[u:8\ Uk^s,u^l$mՑA:㡯> xz<5Jpi(mŎxo-."mƢ6F rNsrz&J4jF~ζwՅ̰T~w]MCxZ(,no2G庘1*IMTu$l_T N!~행yQS_aӶ,3/ۑӚznގ,W^>W봗$^cg5[*>eor[==UֽKG +KYHo A ̦+k3OBr8==Ts i]nz"x.Z$W}fԜ+X~WvVnot/|-VW3+ާc5Յ¸H8k?wgSaA郒F8E+I5 v H6X7 sp\87l6t"oV0`;f%)Y]O?nR|FmyUFezTpDh-3'==:cڦR_3W暾yP~APj ׃:VR-Z<&iyj +.WoNaNy eȕG%m~zyC@|w~a=zOw#(MP #-p0>ϩ55%/Rd!٦hʋXQݑӑk5MVkqJt϶CdڞbD&F^[#w}Q&݈g~O'_«Xeխ z=q^O=#W~˩*Iw14=X' c3})Tiխף<n-eiVFHwFq]xVڵ:1Q{ݯ:/eqix++HNXT)V H0>U)ԭqI;zu\,=*\r]L$y&c~ιkb#RiA.QRөR:/~윥-_kHm @mJ f]xFRNjrM{I,\4ӒSz&teѩ/unslwny>e_jix 3i'Zi9$UČ:IrӲR*qRN;%ϙo2l@?ʹ3SECu#yyZ<,پR7㡭n~ZY~tV:@6ɻe ӏL[JK_fz]?u3yfl ^h̑}ЎNPpMaeSJ]%fZ7gŋۏϽ-5=xԎJѿӏHIX1Qߡ\+;{Fz'h-FX1qGEiК;i0ՃHSN*iPbӘs&ݪ19kIԄxfv}IC[ZFcj&0qR[S޺daQ-Hxٕ>|ߺ0M-꫌F-\v>Ul~[Β&2(lcf;ݞpr8]涶]ϝRvjOzS^Igu4s0ŻJH_ҼMJ6N4vT|wxZ:7%oC @d׿L}쎍9_Si^Xe}swLWc5#Xs_Ğ˪:/Uih$]ϭmZeAҵ׵մl֛5ߊ/5thtEGS!mX~f#=I)QM=?NE+?%/.Sdx6f)>oG@x9{TRϗKj¥^F㢳]ukxj}[t̀\`FFzkiN_T%FJ5/հN]FA[#O+k8J.FxgܮI%\=M0;A'־ O +Ej2:iP[+{`ls[<ZG$n ԑJ|2F.w={jQx+v-0Uh{c zK^~ѫ|;M&+kݣ4C4;}?J21GZ@3圮898zΜyM};0"bRcwv_>iOSJ.Zt6ŖF<>rٝs{4[Dxp][ˑQQ݌kFuOeQP/'ҳ(駙5+ICC*GPKzq*j=L(ԜddCl4hUSdqFu%5'`Xr' 'ڻ%'ߡ4_zƍˋGle. Hzg'Oߺxriʣs4x)o s `ucNVE(ǖ_O⇻.PѴj}9ތV%>NuOk_Ʋ![w^3g{ W7"zxWmN1N*Zq8۝Y̬o|ZϙF6R;ry!$ѧNTQϭtB5 k4=񇊯fkX%i#s׮?mfc=ܷAhŽD7㓎 W6$wtRqwln0#.3~ 1yP%-8Zy >bn`7c'kJQ2TSWKy"Yn,c˕5Q2Etг E4~E^:Q˔k,߷xzgZ|N(/f#> itNU7mA#ǗoE{zmS^K$Er$8oR[)>ϱش}^uk/:NTIpGWG޽̩*\ҵޯB[ʕBw:Vqoj׾mXA.wkZt%-[8jS9MxquqHy;Fs[.Ӳܴ[i!Y?KZ2OokR@?c,c|sZGzJz}WdfjtR(P7z֘gRnu4͹<93E9̥ynQNUORhanۦVڑsrz)檕NM<'h8?ȬJUڄlsʴ5y'bic8zTGDAyu0  IT\s]NRk3忌 /Q]m9+ʾdcW74c;FQ$-:o*DFV^D^/CPRRkcQZTV4$ *Ta9jgftbƏ˯Ȗ󕭉deȥFe7/, ŎHRwv=zVJ6E筶1?4j^]:x*kn%ݪ GF@8{I'sj]׳4ӍjTHױf,I#=޴'ʓ?[3T -r}qGvЮuzE,ѕ0"h8^Btem% :/?h:)Kj5f+Y>b=c]4}*g{(IGB9Fg,ۿ}:cw9[;h>|`pl/g.Jz'QJI)_#j}MRN1LT F~洄f.Egu%jʴ* c8ٛN~ބ%L7`ygck^N}|?eIVNLh'=1ךGGkZF#m,2pxGZoҹjGn1γKwW8B\ѻʎ&>};<2I+ -s )BMnCfI&y\.|jRQt:2\Mf-ܯ=ӊ invԆa;xN8WFtM\c|[Z?VݍӜLy߽wrFZi-r[T*T"WHvf"~DGv(FV F=I|b *My_ZQ-T_e j<`溣?u&g/iRֺ۩jdT/˴ Q:65{jZɹfvfܞ=?:ǙhbhT.ڛ^HS9 a{jݴ45zrRWUyeż2"]s:qs.U_ϙ;[xó ۶>NNCd8ކ2 5Jmc\qߦ<׺+NХx$3p'k(Դ]DƟ,o)Y=[o2d x7/٬x[[QƜemo,71+|~~5+bQ7] BMtciqNA?aR? XaͲA${4\3F?_LsQ.#^1%d¨:v<~ir+045n[i|RsAQS]h>|Ʌݴҽ v=Zɾ]΍j{-PLе7#秱RST)SzZ0EfT :7*5UF:ءdsFʹ@GD5畡uϾ?c2,7 #F[ntkZvuө^fi۹dSnZ7%OO|q+Z\TR54[w5,6S"Dw:1S] J#`yi~\7%)*ԿreDFxmFiB;:ts'%nV֔yiR^;y/ahҫD>>~?mGѭI&rjSMz4s(ܪ+`^IK a} W^%|baVd p9>ʵƜ޶b05X=W}oe׈oI!hY;nbԒqӣilZrjʾto&wHvrz~]k){:p^q}ôkC5W . ͓s8GΜ*Fnߧ'&+kBE`D nA=-s&14ew"r3<:L$j[>aa895#*ֲc9([ދzld+<#^;ӗ,"ܮz佄dmQxzxLf[?2Ps&I?#4Tosz͓yQ G˷swZ㓔48Tӻz07I+FP;1,'=:\:ZvsJvеmgs  ݎ>޹r΢TW۰Fbc]dpx>5_i}Zjq~]KK!C3|ʽTzT&Kz!>XR5b;t׃R"1*c(U7;5m02|qt"b%)5؈U^̽e1 r$0Cy#1wFSuɎk 8͎FU+СcF~]<* (}f%HA觊 W97̟mm]ƥ)O/3 8'+IFf'RM =6bڪ71\)fU=_ K뒎bhFrx'=ՌN6Mp)JݿsN75i_'5e*%ܫ)m1@f+sp%c݅{}3Te*bĪ"l`ǜg F{srKFn9]^7aU]R]`N?s[_ތV.-;.S"HO gp A'#(uӍ;n tW,EwzOecjcR7q8Xdmxu90抒ek}>HQ$w-sӊ:ۮԧR2>"d.։]yʜq)y6تtԤ}-vGH%V㞸ֶ$͵eԒWJRy-1zcz*T*fRNViԉn].nl8rϩdWJ2挚~dq/!vǷJ)TLҦ"+v}{gC'ty7 sӓؚyM-JGb\:nFGUk)O,yw#9:WF#ߊ} 2EkV#fm!#Oq^]Ysp5u–M/|nB0 ^tvrr(;hU[F@Y6nc==3+Ωh5-ߩ ي)9դfd1ۃק5Vi%o37T 1- ?J*8NM[SǞWR'YP+yxmpƜcwoN5)Zel?ZѕH[R{yUYWl5ڒ]+7nO{9kK!Ҍ"EV/樑D%H9 ] TMQԊU)y B'FV{ngjХ>˂uX'29=֧%-l[GJ ;.CZeUpGLw$(.4y^WkNZrJ=Y?cee9!6ĜZ[q\%%o#I;~`rOzU)HՒqnm[o)\B>zsKl9,Gէ^顕f,h2Yye$սHD\C'L3#m˅$ԚfcO_n!"9vMۂ^999gК" Fr ˘nܥ ǯְn"8z}l,+?v|*>^:c9TrRե)NDcgej4oBk)r+^E1,3)ĜnuKYo4ՊT}bc Uz?Ri7R\^u,.g_:Y$hڻtA_xNT*m-V gfUV9s؞xm%)6LңIbh ~bӍ&ccNAA5ţFBEspF:3N1Վ ڕ7RvȗEY.pnx">]Z^X>\VRkKkWVg ĜVm8׼۷"$hYṂn3y9=;x>^K;ΙNT>\RoqRN=x5~Њq~dr)VO._ssg*q+1I& mVmOF4[o̘K=*!]{t ӯ5>ngz?cX\G\n?JV/s?ztuF"+ɳsQ8:NgQ/"FX'͜d+T+! ϱ^"ꛡ(fhcyqIVg%Olsv顅2gSaf2dFIpq].OS˖VehIvo&۵OR:gsQ0G$LDsJA'5q[9YK94 fIQq]d zsWN9;%V]OPtO7axܰq# '?ϵZqN_NܲϧC-w)fVcn 9<~kRUʥ\5G8oXj1to'΍!W 7<+o³Ν/;K]&H[}92q/̘۵rSۓ3u^ุ9ӖE7Pq{Ǐz|kcͱ|uF嵼SfKy-«`nMrl}S2~t}&_ZIjttxRRRѝă<װkIQDP{LDeMM6EO.o)6#Zuqr*ZvM*1O׵)OUHӕԑn4U;؟H+'94}s~U%ɲP*-ˀ=GHNJ.IIZ%W fm;u%řhӌI 2m3/ z?s^Nꭇ6s3F˅k\U:ܷW"hV]*5A|w8?ҹ]g)7-2QU9tvK#oo?3 H%6ugx]tܖ[q34kgdGYFtEӫu-"_!ԖqHK0]ڴ״܉`QNTKlݬoʹڊ6#RPxFF2%R{_'رJS¾*V0wm0JݯX/&17}=¹SJi⩩'JdS'69H##} {0뛙0xUw1U'`=j4UIIenE~܄`+zz:1UGc8ԕ%]5VCv*vg#vEF=w*MM4KGmKo.ƥpv:N)r68ʭ ne~ryqO֣2*4kJZ۩,f! |8>zGޕֱ%M|߅O4Zm/ })$$H0g{fI8ed:].EjEef2nRtuSriQ |W*S5i%+e4Ĵj7F.e+fȑ<p嗱qEIFDy{>U(o}=3WVṿc l$Y$$x}}J[lWV!?6BdA?1sҺ*[3qqzyZvY-C/̼n^?CVIKr,E蹼c<,eqcx>ƺR3M꣧ C3eO3ؑ6p$zCԙZg\5li;g~ucO9ߠMVS,.ۗn9^4ӋqvnƑ؞a-N Ri3RIqe=MӌnbJRk2$R[5]^7&-=e}@RFWr*3r>?:)kX{BN)ꌻ{c0%ĒGT^8 k*w{h%vf߽$ y끞YթNSWV2J9-Dm\$6߹VO@ =:/wUsu+srXϖBo+F8>zQ^:.iƥJ*7]՜y#v3#?Dc%XxՒ[~gk2erO+ TsC]ƷF29<Nu)?m̝5*;U` k*w[(SV?K"!Ub?Μ =ΊE[tdkYg\oZ4(E%nM)Qåmdq[i-۞kRT[~eӓ_2f0]#kԅJ[*eRIgۡX^¥m:?+Ww{)K姥[ܛ[~lw?ZT).eGd6t\tdUSlXH5MBqVSrozUp[sۯ#8#JqÅNH/m7ijOn!adK9ډJ>֌enU{EvJC$&(3yP}r}jQ4#Npz[-z _έ"0 }Nu/O.9߀#_\쁇q1jZtQJe8$}bnB`EF%#q|jqoPXs# "e;q~U9Bܫt;vo5݋Z^a^N)lt*X)qIn_\iFFܬAQUS/i5b뚰Hgl+N}iߛFZ4eao j|cF?Z¤{o*v]q]^ʲ6$ss\51TqHVOKhrڞޥrzH խFg|{#"rZb@ A9=q^V&ay*Ŧuz2r#TrF~V메RQp]>e#YCny!+JMjcFԗv~d,[1yF8{cV,OCNv:Mub|c?ʸNk-xJZE#IDj~fnS޻ʽ*ihmϒ%CcjӃ/i[Fҧ'hr/;?=9}Ve*m'ɭ4D1e,|u9{8l-[i4"Ico?QqD+ǝ(~Sv$v]Ps=w6qCb-"?lnҳ(Dʷyf@'` $E9rӌ)b궗dʭ)8`l{)/8e7Wp6٦⧗,?l)}]AhsdžkA*ۚ5ʩR0=;k**Moi^N~Tx1-<Ȱ|01Zӫ'wrr;5t[ywAmo(ǥc'RT'ƌO˩k2EopGap~Z(9,Zt5vfF̌28U5hFs҇/Bޔ-JX@$d 98V3Z*ɫYMSv 1 NpSrrkK( o.q\0uJCԌmr$9<3u+~ڜKL/nơv '<ֱ/{vqQvo2,j2&pIzd f#M]+F^(WxTl0/9#w^2MS53֫NDBƧSln[irH}OV:JVK%NOnGaAVxNySDJ8xʄ*zugIHbv$q.,_3*1T_ȇR#xYdf,Yq9?^y)E=4*ҍ}vAT@Uo #X֔yjIZa-K,zc~k9s:;:snI6@)sqz9RZCw"_4oJ<6;")<;Iܻ}%ymLOSy#[/meNU&Cqq4rQׅG$Qri='cH;wEb7yX{E^IߧU `PUwsp9ߎդ_4uSRPvwȄXŇ+2~^y:w:rkEsӧhKO{5U[U6眒1۶kFۇC[T~,O8Dy;@pimWnqV.iinI{-STrcW\ (䗳N/c:e;;~p, ǘ$G 4d19iECWin?xIy럯5F\#ˇIociZGQMJfkR^K[z XZrS-V_ZV0uF3mFUcEtQizfv*k0봩sR9ïO3d7qa#|utTplsGORwEK`twtEԥwx2 jWe˧N a.ߔcn5]<(8+4tt)YDWu2i/QZF3oUR5e.!i2H;>\{?eYbkM9o/nW`^L+#.6ß[;6I-O2"wdg#{pE{Tq{z([u0o5noivtZBw͂3^wLJ~Ź c57sӅƥ>mgjr$7"T6\q׊ڜ)-oJ ]'ܴ%3=XcP @ 1qꓣ~DTm8g]ʭqjJ#NS]-'+YB]XNZƙ`H۞׏¶å뮋c/Eڱ0Uh t'=.5e ;CNI;umSoy$_jןR/g{'ס_\}LnmcnYr>n:}k,=NKV;m-YTX' %%\W*}?|/hY9kn?7JqrZj`j{kC?1 +;ՖFqSiΪٜ6C~NJnRˮm˶+"? ­ Sw918ZrꮯX[B9YzwJR^롣YUh$j[vF8#xvӹFڵ5lEV7*xRiR}_٨a-P_iUdQ\i-5KIpA|}*UIJDcN4O߳g;hLD>floa]QME9#֣N0fXEeI2oƳȺ5*FWOc}:\\dryB2ʕ}ށ ʎsg_kGԊǦkni)m A8Uc(G}2u%);{_];Fir#[$csYJQR9{h5kb`BX:uvO[]=(D]a]Eav.&^]'ny{`w⠝>gH)8ۙ=ӪiW0ȤHѰaӿ=z5I%ݩ1\ k3ZUSYМq8?Z+anzIzn}s,Rkimw]l/n48n_A9 =s]aԤ{=}cs 4Vo5yi˿msuOK rFkH 1{_Xzi&1XJJkuNu߅V(I2j>ʘ}gUx"+9Z][^I;4[-܂~Ry1dzce6k+__L6eSVPI/[{S5 WxI]d+n\ 0goS9sw붾MqU?|ѧӯϷ m{kgnA+3,pWg,t>S"O#\qk"y1#zWTSI4yCCw $v0yYZ2pk >C "q>[}u|=M>L-sC$rH Ccq`(_{+t=ќTjWwOUgBb *?&c$npsִZ[l]OgVX$iku142n);;f^ۓyIkۡ4.mR@ʥI ކYUM+kz;k9J)%Ϸ?VJ9e*)8=[{awI|@qּz)ǚP燈.i-y?]G{ve5yؓ}s֯}X+_Kt7m㳶XI~AH}&ڕ%ͫ߷C=7kª`6\HoԩO4,"Es19?sKCZjZ!%|"\F[FGzKockвaaB3.w)g}kRR}:Z5KVzE)UcIlEqzgflp9+ }OC6{)<1nkG(uя'UxUXnR߼K|ø/șJ{4ekfhn㓅1ԏze\:>]J֣Jk]˶) aoF^#f9FKcJэFkΥWql+n21==+ҥF69Fn2 HuK;܇="#x"48nsMr6cZM;^)5-#fUkary}E>hήogOKܞUˏLSYQa.i>m.hDn!rX0\)'sRrkœdvllUw4TpOYFo]bON(X(.@_+OsWGvc-fF&ӬГrdi0 `8==kQJK >ZZ$pv?sbϗ- g)_x]~Ҷ܀edj 2#}+_.^n>kBq^&`ſ'JEo$)N:UCN9?~ȒYt>JXjZIgS},D?l'HΤ^BLD#k+;zn#M߼U|n8UQG+.Nn3y|-;-W4uF&U>7E}_+IJY+My6ҧ8Nx;)rM^*i얺v05]]K6y\.+F99y:JN5άUj2i;]ѣL9H}۽}gZYw>G[>gM)-u:{cW&22qL2ĔːGsU\TֻZitU']eذwɀ9OSҖ5d]$"˷]̽{J,u[,e>dzx@ZYcnrQKNQa[0R-4%D*9b'~:q韭L>%}99ʰAsY-#WO=~5Bukcʔc<-;I&vHBuޜ"<4rfUզwm_~ ]hxZ=c?(_zYTFq,Te?Ww{ζu #`YU~}IN+GUbף>PY7䲿V;-Xm C_ZNKGyyZbi'g%ެ#N&팮Q>b+R NuZNWNu凖'rtgj/4F?,Ou-_47̴Rʫqc8F20Rxu1\N{_/v*_OO:XsR55jvNq1VE?wsҹփ3UJ4poo/3ݍ5فiڸ^+שR#t::;"g߹d{ϓ$ATzsҺIS=J8i;wSRk@EţUXvqZ>N\tM<p4fgz~8Fj7 }6`9ǛђKLqM64w%wUcaokC 0\Nে[]nZ6U{ʥK$vaj[ޒyKNR+1r3t`X-G^O9ݪ37RU%y3QQ__߻O<@?~4tSQ=4^ 9 n_'O\nIϫ 2H_pYxP%791Laqr>oNզ6U)^imͱ|ӶoivƼdxU&ˎFzqח[KyVvO}=GU6b~Vyzp#{u5a<9o&[G3ҝlDiʫV4i5g$91n#J^S jLFyjk`]EܪV3}*8ud飞8E3:Z0¬xQ"(F,SmZ,SM4rk]|5V>uZ\7:a-c~tni她1/my/֧*1Vyc}Kk[Q$&Ycu'%@|E/:q|xd!nLVzI5$t«mi6a>$txϥdԕG'jGmtk|3?͑ =GZNRzNX3H+KԎ8'ZƧɅ9Kgme:]={ouJ Z%TV,.b7^=zQz-2QMka_]L|B8*(QIbY6N<2ݲBF88+*ΏaԪ.[f|ۭ#뛓/*5ؘR{== "U?Y'#_,Rj_m΢ +}]nF9;])pJTM5kr[2oM.ٔlnGR8##XO>tMӧ&m yQFݫa'ri3b!-YNkF4fqWGKc+ؚkWm0T ۷ZҲv[+ݝВrjKx+y5op \We)KkNգW{h^FH>Φna`jlE7o{I!d~f9~}1Zm}}IcVرgˈ܍cq?3Kw44a5iZY8XL{J>b*SiO⨊ʷ[˕C3nڑEu }wgiqDMYsQMt}iw1䯷OZөN@$֤vjD"Xc*1(Q^zweYbtBnlṃuҪ׭9$rC^8cfZI"Gf=1]87eoBQ>UchU8fPx;Iz^.EǕDP2]ܮTFVydN12!zvXF6&b:!F08asְ*7U^՜Joˌ+yF-r1浳,;$Ÿ_1sk"*-4sʍkɷ`YU*IC{F1!i`0Y^84[F{]E6eP7͸`>S^8WJ5WTJۑ_=eEPqq*S.XMdfs{sFin`X$p5FeMɶtBM{1c-,cU%S\ܳVNAɭ#YIsU=uі 3^A$v1ӞΪ5#NJd%QtZ>Ѕ0Y=?wPSl̖22l͏Nҷ)TihyKM_*fcǾxZьƴFo+K{fh@nP|KJQk^oΤhԊO'} َd>sٙ-=?.JTTbޟǠMAElsѩe-9N9FO^,V\ۙC:̪}}+ hFi(ԜmbleeKEH_d8~mF^֣6}/5l54lW]R}hG^,cRB?+:njYmjpuim54[^Mc"Ff1c皚؈5q+uf봍NnbOFμG;'s _fdw:i{+(drO,Ͱq{Wߴ^kg圹uzEŴM29S[omLy/OѴK9Fց_V (MIF; ((W_NE7ᘳqd.+"0x֓-zt$ͼ<;a20v'=kR5SӒׯoBƟ3k fv~*vLeʜg$Db 0U=9z´e'ӹU+֕NXxi"11˻V63TeRMi3,Ϋ!vkM~N57 6U|d tzTeCJ,D/yr"t@ʬ,_OOZj2Hʝi{I}݊3}Ui"ܰu; A zקRF+>h薅F|MQpHXpg^ur-)[&}]oH]HrG{3]TJṈ4#[e0=5NN-錨k(6ﭻ HfFPy )*9zסN)J/} jJQSF #c^Kg'?}jȓ-FVz,HdhfݺU.2vs|v"t0(Χ_a< ,I"VXUgOcYM1RK_uT y3C#vӞe~dyXQN涛%2,_{qZ¢R%JbIjF6z c< yS▒m-?~KedvdO^${$˅\f}喭RcLdhG9$s%+hf vmjI,[b.͌H}_2:8"6, ڧt2دm۬1o͵=֒|N|MffI$V˸*֑K&˓#27H"?3 ׃z\adW:.]&*yJKgsIRrWDEkn @/IsjQ. nZC,ۛ7quk>ƤV\H|B̋4f=zji4ṵ˓rȣpn[ӌc񯑽Q?xW;7I'c qҞ㡼N1Bvdt:U>^>SHFjPZ}H)#Kvdzk$o.2rC 7<26W pKc#qTԭ֕":,Qyu-Uun''TbO"Gji$iVFpE 励=ӿ: E9*Jjr^릅k,n崊 lzW&n[_MK;KZ9@0 N{wzrrS[sƒ36-D!WNyo/gͷOpW7=ap+nL{,qԩ[Qm$"UI[;kΖ-YYٗkmfC``WxRH$y# \~9h)\Nz)O[Z1^,]d_1èsJQYFo~lg9m#Vj K["Aqk'jkT]Ev. -1]Hlc\'IIصk8_2XLC`22qjXGUԙ L?$> J+M}QGfXMvñp60G8#YÒ;FtS+Cv]v#Y>YjJ7*.u*I3W˔Ilʖ^ӊ|pT -ėF?v,l{+wu9qKsi%[K8II ev8 k) uwEdEJSU(ki K1ܑWYFٽNlֽ?nHFYڣ'=Z=]sVWj&Vd%A~P~(B2mk8Smk&Es67g8ɩq[ס1ѕ9[mLDik-W'y.X<۳T=yniXݽ7VߩZ^֖EhUU#Bq,q1\Ҍ#RRR=­u#-3 mIsӰJ2R?э;7n˖ ,ֶ2XHx猎sTrϱ<\Lʧ]JqEKG([#IUEmOz¤y5N)S;* doi^~sʝJSWLlvLD@yi.N:*Ƣ]nWxw ¹gߑ5qKG* "ӈ=,{@ =u|\{]r~˺nzK׆=,x> e_#'r%^:V n7)擲i{]֮&KuR&!b~R v>B/~?BTcg=zx?Mk+Y. kIep@3*QrI#(T#顩vd4qno[`q}Gc޲TuQ]{\ך5me"Fu"M_*}dȏBԬ5{eȲ:y+:.0KJ.]}k!,qp7߃/sYXeOG>ht\-#99$ Guܩoo qi D<6NBG^9RVXiF7_#;Ph,hUdl=p c=1S̜Q7So5K%Ί8Ϋ&qxq^1+'? xyI_ XGx[*#AǵkM:GQw9s(J5mu Y~e82sx'sCύZwz۩"H&?떵9JWdiSRSUc.UgR[Uɑj.#(l:tk1hz)Vtd-2+QE/Lrp3]|PR t?i>pK,vСFĎ(rSlGvZcֶi#K,GMS4ӂsTULIw=ٕR>U=rx氎TSg->꾄S"=rڦj_OQۛWSk!r:tc.hu( q/]}>ԜyL>N3r[!ٝr:x| CgZINL=*k8s}f>^0fEVUAz*E؉Tɤ6"v?N4oRЌd?uu^hnBPoS;~Ȕk ƌh%y%c<U γqz;/V庹4 y.ވ=ZSױR=4z1mtۗ2M׍+EJIx'nwvEHG,2a %' lYT\r),Ǹ>ZR.^T>x+mc]a4Srqkn1N, pĞ~5Q{lҧk m?$/r.0Kc,t9$ݯJi=~e>:~p3F:OJJPcNPpx\+d3?sѫ)OKO9jUNГӿ$Xe;U5+_oV\CÂyWIkN}]ƂV7UDiVuV55q*-%VvRy#zV9:kJyԷ5[5Vt5kqnS2\mlwf'{W4*T s/N%pV9ey,  xtJ1xYS%}eԹ[DM!oOy}XRfl%;K׊#%-yʲ_O< +ڤmb G`xe(ŧ#jU**j;`$l`+={nVrT{*СHʺf<@HT/G,elϥ&YB*y'e(Y%L03ImѿF '$#uvn[&pF|?=UhH7+G|vZStji)Jk˹0,Q) $չcew&ٝ:սu0֓I'̌ϧ~ִqBTJY'tkx'i<3qFq:qXۯXZk'LP%YSqjcR;9O.iEJbf-⍕m+ï~BU9g5Jnm =p[L^8\Ի{Μ,l(rv:{ڹ QGK-,a4x (sֶ9dÄ#L\m d:p 4*v{۩$VqoV'=A\i-4BZ.D g7>V/r3k9sW-6Tiը-5Cm~J*sI&rOvC$ِFykE̕gm|p .R@| A`1ҶhӻKt;l4\n 3rpoZ1/@w;TC$bMd[A}q拷5K >u\eE9:޻(Q(F!6}Ê>.3J@~?Z)ӌϚ$#g>df)Lqdܹp:NaZO]z%ʖjJcG4e8^L/ޛ ()ʊs]6*"eNNINOSRi^2)(,?>O9i*uWOR{oЅb*7H~\sڶNT !_שr|[ā^?-WrQ/\UGN4_*6 pqnuG^s\=-{BK$Mb=7+1#9jN)^M9Kk4,rgq1vk=K|]dW<ݟuE˓hL"x`*a{ca nWwތS̸5sfuN|iF_ ,W2ڧ{~cWc/v2iHSw9QZGTek"ݪB)Oa 1F$xQ+J.̦꒴>~~NRӳܥwCݹ *2"K:}ɶ%F{brvMJnWhjER {c=xsWh5e%0G$3,.˰ܢ {鮤3,\m[[X 0][*p]#NߕWnrײDJ^FHUfXd/HcWs+G*euv{٢,rsgvgShrKjѪ[6\zuE9/iupkz O2_ ێƺ)J[Sz銺f(929,[2 &Um< :qֽJU5\f^T3Vymg \R },cH[( /M͌c5NIJJ泽j|Kȡym-s_:[|9NMB+ Z2qwY/)Y93CV)6ԭN~5xus%>n_ZƝeK9ǖ2Oӭ]N^u"ie wsܼ%MSo}U%߹ٮ|f/IIܟvauoiKNdWZj9(7jko5Bm*JһMћJ:+KY?xMOFIZU]sԼx[{mۤ]Jބ#qVf֟ùe8lc˚өzӒK/-Bnf=?^Q]FjPO.nv4}I0LR_(*-[Ւ)dgEUTAP(NqުWk>ƝfI~eBIh<Ľq9}OzF%9Ƥc/دn3XO˷O-9EcEJq|BWmost+ss+Z[-YI-;)o%]ҶsN5RyRKkZl_o"=X"b*2u\dgd3|z]NZ|^dRWZ2fBKJ1ԊzSC-XGftb1qLeҲԵU-߯Uu;}B{t7*lבzҬN|jIM":BӴkgfY DksrzJˎuLpV/6rS6  w6|԰˚/ogܞS&]If̓\5eBR9ZXH-lަYC%ytpnl  A51R+%s~o/$ Wp)qS;W=iԍ7's1)I[ȒLLlƾ-ܵq0±]yBQRmϾMom\&vDy䌀{RR;oYY#8>Yt5zZ#IVIy6#sO+D!MFm0yZBՌ{UJQ%^VK"OٌvS:Fyda#<淤X>_йJqPW,HFnȭ4sS}ߩa5߫W:|yҹ暧Y)FVo$ 訊M,ݏP<⢤7g>"(gUfM11zߺhx2<~&{ )\me<㌆kFkNr7(:.6/#dnՔw{WIɮuBIˉ$`c7|8>9r}#N55A7n;y85(dWz$FH$f̒1 iָeRQxaT))A5(?2Ct!mI!{ ތ}ׯwLEVՖ8ۅ4(SFchXm /L`'9]4bjGW8*wIW )M~%me(VFpTIO?J=geƅpNrȔy038.3c]9SsM!T{'}]`7>^2xoιqWWaN.nIKt 3m꧷֍o18NY]EL|"Md1{ܺ~ i3sq§sscSұq^0JJN١Yjf=AB+9G{%)rԕ Q,awHwm9JZ-Dҧ,}فinldG%q:/c*w#8S"Nn}ưrNq!(^{>k(UW`˯3j\Nٝ>{w"3-ڬRmv |2=0n]ؕWʮ#P[k2T>htZ1TSC7{Wq?Jb*S(o CFn2nUFQocJ4ikd^DsC4i#HT(3sԧ)8躣|UHѢ%mF%Q1Pރ>QS:ie4Adc99E(SZ~G."(Tٿ+e"Id\ (o=N^WZLwUFֱykq3ns?i2+_y7TwmIKo$S98jezMƕ}tcT3d;W U0's)#|n(Aۛ_#V>V0 69cR\EmqNW˪4eьuJ֜jJ-s U&YUQaF,E+-ɾE?vM0/2K_.qR^%Y+2. bd,d1lKZcSFk淂iJ.cQ$JQROXsENexэЯ[śz^R[H'FPPЪ#IQcK9VDHbgXbݚ*~s_SVSި:m)F/\q[!N)E}C}t<V]_B%v\]30m ׍J&~>iGp.2KSmM Gfp;O8qpªNZKCҵ'S2ݣ=פƲ͂Hn9ʌ]q)joeW|h$o)9FOAɧV-AK>G&@>bqׁڱj?-מע}}K"o@*3(׭ i֭KRW{ͺDm!Re )ӂnJ][;01u#WYcU&IS#Gל.[ɻGVZú5[--j}K)s ̳+3giUKM+>ZFsq֌}qШJvf~o]m/#¶1|]#S嵽z!(|_0ZVFмM[lzٕnweZ 8ThWuhYU_P4σG7Mr;>q8_r9'm.NVFv+0&a޺]lEIw=*1&nkXjR"Y!_1XʤNW~?yn*VzhIZEO$1݇ U*q[/ƌhrVRˑF1bO+Q7]K ̭ ^_$S8EUvˈoZ%w3SE-&]ZoM݀B GvzWJ s[[y^hi̛T|F rkͧJ5I}n?f'~e3Q=LAdl`d8_ODpnZLgF4͟ *k> ßδis$wص4q3;s9j#rя3ѣꋩ}JKo.5yp> @wz8<"ּR%Oe[D{Y[G+7!689'Nj^_TV5kNZ'|LU?*qu%*u;ÒP68پQ??oֹㅗv *{gtxAK=Yn7!O9$ێRڴ98gxՄzʭktt{eWr1ס9Z穗bB_qC5fP$s?99RMA^>gc0X*(VVѨN+X]=}7cwk'Ιɯb^ק5{Hunׇ-C&6Đ-020+ɯQS[xJ^nZIq461aZ䒏3rg$#(m^]+];WYE/tӧԩ3 02+6t:tF\>("6Vl7s|;FRmDe$hKI6+^:9Ӗ<=#8I6~~onMPj%ʭev}"NZ6-Ɨ2ۤ`Mm8 ֍'[c0J6O~߿ivu|6{׸澇 J=tN<уIi5UCpz"?fVwfM.߲mmC,ATc$cN]'"QYHz*ynOV6ж7{V*;Jz{'rceN6lhnQ*eݰL{Q*f%=af?k*08<JkP8I^M`qh/. }IqXJVMҏ4/Mrn[1{TϖP}nCfKGe}tb2O>ݫoz[ek G mw N8y)RM|pqqWI[սt6HZEo#GOOhnD#W;Tr3Ӱ\ܹ-kJ2 -n$&dTs=WTr~/^=kFvlp8{sXVKy-Tzݞo_hs`h?9]T՝nq=M[[ίY$ p8,=3WU8W/M|Fš_#< sbdkdec8ʹ?63^f6|n'ψG\o#ԙ&]}rHaOU;[ti?燭ԙ*}+0'[t=>*}44+᷍ds$QZQ\];49Se6lW+WFuzD)El>]VuiE:vM{CrMpdll=zLrIoR[Wh~BGHR6,s;WC-j}bꓱk}qFiai&{iԜ({ٙsh5Dw& ~s*q~x5ȯs7Ζ^\dmVm$1۾>y|ԩyA\TZ'e%-|F3׷ Ti4o'j~K$|p8~[Ƥ'eN]Gg$%q*όƝ;W/Uo@LhԬcn-۶:cSSֿ_cwUѶ,cRACڪUk-c{zj^6nr}O+MhqSEÙ7]s4oiSpntK RQTjY !iGc y e'w_*o_Te.ef7׭:->`r3NKZO$P4w]C| ^ ;];@$|:~1[Vngi);+_m/t V%Z,$:ֱ8Ko3RZ-5R[h]ĵR>{w|ٽocꥇԍ$[OSxLݒY\ *\*s[-_tiD;ra_F$f~Sod6m?֨ۥm6ch$,۾e#-GmI_VTZVF^M $[1"45u|,ckbKƾoꌨQ"fU8)"Ĕ'Cׄ!kqfg;ZkЧQ93 mN2Aqbs֪1N6՝*(^b+~/V2v{)(Yn)XكsƖ"}7:J_fO%KwYr]4i[FOg,\7Nbšmqr0z7*"W#5gN;u*X~NV; x!>,- `*y9j(+^+xՌm6o2֑-&,K$a/c1ϧO"NX.]4^|iJ%G=JUleۑ~U0j]R}Z~EYvPuScnmrkIߑǹ-jZ,ʎrpTWW'%Fu!htzS&yfOrEǖU67JK~F՟5)Y x6xf)\JR) V9yv;|&LKqmmt!f9'-EikmV饺ƶ}f" ڹ"W>Z"4ZZ%}oNͻB|EKZ/]"9rWZݮCľiv2OCǩ+הjCU}u4P)G7^_Mxnm|Y[?g0R j愮y2,FiVi{[~'xO>g$l2&|:|Ǩ>,uj?wE}狊&-m?~4uƙ |- TJ0u\ҹ$wtv6ɤ^]DmY NGNzҴ}z4wnS{g 4'Z#+t4?4$=q?*؈ﱜ4iU*PcF;8=9)fue'ueX!dfSѫ:B1S3^Kyn.X.xԕ-y+.Y-NգQ/9'Py\בۧ:uemCg)Cs,6̓L̀9ץ=+8tmI L,N:%F1WՓ'F6ԭaYl$L*;N;qs80jj3Oo|SǵzjZj+S&;/Oo% w++CjWbK,:Ev!Vi`P}9ۚPz9J7/kc1a'8Jt7*qGӖM$-T3` w2K=zʜUf}g8D|£vg=1ZὤUwaph_y>*&)dQ'3y#=:r+~?gFҚ~KCi x-tۏpsץ[_N7muZK_;H.pnjds4˙Ng̽}9,G;IY_85\ѭa^_?#z宭e,dӈˏj<'##ңNQVH飃h6^{~_V[4/xբ1ƭ0ǓS}`px{ʣN^; JMi`ӣcG=sljhin#mM"K1W`G''=kSUaQ$,mk2ʂ s" 88]4ۤѝфc YK6Nk+KeT*Uc`998cbz'+afX|05ns7{kcԩZVa&Q{@ҼrgymNgRkGNVݢyk" j9b[5bh}y5mvUG`<sUǗ#5*sr~O֣4p,70]DqczU/4:RJDf6qӅe]?x`:zUٽoՇR+ Nռs%ʹFf"3hdH /jڍH7Jj6}ng {F #F|S淩;A;LEm1hr5hMQY*R*2FX;y+by=[e?yx?JmC\\jl䎣kOxWjw{v3o¥#*b웓zFܴK]v!ܳ9ܹe8S)Q29nȢa c$UKѳgR1ҧh9KV%?3b<ۣ\u~5'ƥ)N*sWnkBn }1GySߙGi#O8'>VRg J2w۵ 4esi0i ?1t+Joދ3*r\5V/6~žzXONz֚{;.zE4wpQURG֪St_*Ue70 L$콌1PZ6GneͳSBgWcWQOw}oR彼}ZG}1:wԧSY/'[dfۏ+iFQlr?,s\u[ >ҍ-{NÏ}˴сz8F2۱gN^{D:J|ev=iYZZ)Fneo_ȷo-Ѿu1S>{4%RϿؙekw`یc?U%5ZT[tX yk;ycS:kC4*_7B;C)8ggSipP'ͷ b~|Cc_mL%?^>̞h9yԜZTb;㹎<y m 㜶0kЧ oWyeIrg4h}$d$#c򩏻sRz ~Tcv?k5-%h>ouy.!-avPǧ$r1ҵ 'ɝ2kQqBc$(V9j?>O|{)8䣅e6i}̍I$jv7pJ)ֈև&?4tRw&z}<}cX.H޺H"}_e3DYaݷ(=U&(ԣVR]%TNN՞ﰍ$jĨ#.7c<§Wfҕ7&Fɱw7O*j2n.-LFg@D+\",ZSrR7,ɻo#c#Z/,īN<\8֔鱤߳X IK6U8L洍iiH3&#)-ͻRTlPM4(,vǠሟ/5#S/5b|F|U;=47ȥW!1+n$#ۯC]qԌj%(A(=+n*@2t}5{č04~bBcFq{UirTgFw o-9*OȘʥ7d6+8.Ռ/͖$팟NKWmjR@~ DU?9{VU*JMסÊnhlEq0܁ o+*:7KG*og{*SU%hbHd`fo1o1pzu<'h(Ӎ`6F_,;0H9^ON՟,~qe2K<зb'`g(qz+JիYmАȑ4 wG6.9KVJ[2[oUkD8Sx7F\(XwQ̬be_.а8zT;yQ9R"xmXy0K#+C߽ROycNO/wE̬ExZ%UفN:{cZS%N%Er2%Nn,:K_3Js=OJqZbʹ9F9SeȾX+ >rp?L rT+խ'ֱM[X ́ Vryu+B[6*Hs:TztIo4[ڧqSϧJGvi#?̐JH*cx#ϚvsIqВq[k# ksgOҳ.]bF}bӹf;hʓŽJyҴj5{nNRi k8rNH ?e7(4}Ɯc-Q³./ ZS%5#ZlA,6H8\Þ+bs[18IvʌgwG+.71x~5FmB8ԍ)Vo.u&j?z9^_mO#:tGq "@zztksS{u:(ʜhn$3[H!cIyHUSZS1)˚&wlYܘm8koQVӱb鼉| xV<ѿ9QJz\Im䀝H7,,F H<\TjNWhʣR&FZ Uf3cSYޏ-֟kK0o)dIXMNs\mG6+#%d3b'r?eRok_qU#-iu 2o,Y#V#zO&2e^ߩe݅4ORs~/#SO#V@fckʩ)-Yv+Z14| FݎU}*FQn[&xRdr?ydw=3Ƨ4NRoBhgyn^yMgʹl kzYnqZ8C(Ơۉēu鍪1ڵꍣN2R6Af.Yךvv0|RIXƏu]4馵{*qQ0 $6ݽH38;Gvyށ ٙ۸3?Ҫ~f5F;8g-'Hہ}k]R+ ivXhDߛU d' {)GN)7t֋ٵ9FEIUc'qԒn^-hʛ^Eجu]w67zׂ -H+FNқKb9 kkVUs"1#%9{t>--IFϮu&ѕy[/%[:%]u7c3 |NLi 363)9+򾽙6geĂUX4h@\ʝE6iZ??C:\["Ǹy8 ׽xU u.¤bg{"]E|ꀶG`2pbq2Sъ7oPn ?ʥI!Ol>k:{sj&K-&O 8z.T\:4lꞺd6-Y&^hgn=]qSս?JT}-I7flC6ߧaױ%an8mˍ |:֣)'rrsZfD݃7^kڥFN<;eG#7QYeWaPwacNQov*5v{?#>h.&0,1e \g0TYj躗-"iׇ/#:uⲕE_R)J:.Ku10/\I8SR6Q_sK3798Az)+X%MkI( DkS= jVªQYXa$ɴYxt_2^Db<'jr7~JNsSZܝ/I?WyZ8=Gp?*VKTH-~7 mTm_sW$F4nWsIꥢ]6hՋvۛ jSvֲ㩅8TK ԴgfS=39+R+NXFwHF~yLj~rF c8-EHZڥ?c[Я9y]<rA3k;J1VMٟ &rd 4c%F}3Oq_KpXŪmmF̐Z5o~\_6gem?>#zE7 IU$AǏZaw{R/U XFvnW \8뎸Ώ3њgQo{o޾f&ׂeFnUldeҨv0Nrr~Z+v۰oZ}kSrM/aGe;CJ`[Լe;U:^tRCŌS0Oaj4Ԝu?}W;+r Ȫ[`v8IU=[ߡTR o3rZzgеD6sKk4~d}o~5+QjOU#t֧'#Wr=7-&hbp /^qQjVÝW1|Cqjm[Xx7#+uB #jjus5)1OՋrSq`ŏ'8i-81|y%mhmp?y ^vrp1]>IDjU!}f&oi>4Z d7B 2y}k: 4KEPߩ>'4z%ⲣE7v(1\UO-טQB^xMva*C}Cuˠ aϸ>y805[j:8|[~N}k,"(GePHa=H|-J^ѹ-:}%Z1QMw  z==?uGM֩;$rR{Y\,q^sVLko`.QX:{G=8Լx.5#t֠ƪF qۿjʣWShLHUF$k &:i{j۾Cho332m<ֹFԴZ [^yaGJW9c)r%36c6 JcG^;{2YdnCMfFZΟ,t{rfAkmo"$rgYTWn2irDipY$ސDrZz8`bkUEHB+?iNU_Da3rKs9=Ncj\7$dxʖn#nSJT~-RLDRX3'y8fo? (Z2ikFKK[} Q O3zDʚʕh'uͳ}.tm3}F{\uuj5^ө)/AEHnU!{rsZX{(-hS2^Z$)TFD_v\pSNN2KmQa9汗.i{JM'̖{[leef%AI=XJI[mt:Q-9ZV}!mm|ULɒCsɮEN׮,)}w}T3#*ܿ{<׵*}NFiexIiq,$73.p͞砩}$g5%ENhiH\n sМFkRZ1Tڷ6hh_;kF1$۸ѥRv:{89;uYj|czq~e㰱bȁ9|<_kWlczҔ}gJ5ߣ} %eeXt~wFbG? xF՝RNR"Xqs܏ҽ*pv&+-Khmd2p1qJ*U=4(ib+pbqVR$FϯSWr\gk8&>c`3;3a8ҡ2FQ*Ք`׻]5,dij][d=嚪tHKQ{]SN1Rr$gj~CX^zy$њ M5Ā%[׷W5HJ{XԵ*:Vp%+;*OݵZloq"Uvf+=FyڳMJ|kFs^(Szu%E(fY,8%oFh'@5QWoR; Q[:iEhIM`p«~R)FQv72$}=p('U(TPzɖ`o1VF|*['')Zp)rQIp~-rJovmZ hB:紜:%EZ=ȎU1މJQц6أ{,jyYZ]nt4bډd*'ͨEj_ HIUWڬW9V?%ъ2kZfF3ea뜃\Ƶ澗HԌ\w!DLptلeZro#.UEoN^4zhExVnru-35I,Ve_oy#lq[蕗tcIYdCvk_1c o [u=?~Ҥx>obv˱|$a%6F^8>.oFzp{k}5lYTǩ꿏[乶zR娴}NvMEbQbl3\ժSQna)JNHKe{mC,EզVb3+OqYӗ:0% F]/"|`BGPzWM:Z￙(ʫWuNm*;2F$nqSҺc*I.х:n`fo2X|?zzUNQjrp^;g(8OpOtS*WgN˫KշI#mS[GYCAGu!;^]>fZG+1R/yμ=8N^5[$XB˷ֶi^ᅩON-שb=v\a\33`y9t鶝ru`^eey6ŰsǶ9Vwq^NT=_ 0F^I%#46ny}*yk~&Tc5m̎M}.?׆&rn܃J2^=l]R*ְ-FJu=Q-G6O3iaNV]-Jmխež=uF"4xBIA6xϘ=<~u79BXʴy-}7$Q]d=l9}3]uѷ7n'e8㚸մ.ў+nnMϖ7GUnuGJ<fFx(`,qFw``&tܹխ ; 3,A-X))_T_FhêBvLnUQ0?)#>Vs^ؚ3 K.#YU9j%e[QoORrJ&*~5w:PWoMܗ<n3׷kW9qUu;kUɬ-HXݷ'ױҸ׫:㇩e,%I!`85[ J7%DRX)_.9pN{kʴTmnkCS9'mu*N]dfw%v@z:%;ǒ%wZ馷fM˞8³ΕodO~dKƒEk_-U67C1Ӝ?RשSJ;X/#]+'ӚRAN+wn'ϻ ;GJnU;6I=C'8,ӭsW7{iԍUԜ5$]# 遞j{ٶΗS4@y 2#c5c/k>DבG&'iRƅRg{R+rDlۆ~_Zƶ".(Tr$i8f!2<gְZ򚕝E|$@>9^jϹ^[I]  tg##r_@Ac(K\T9&MjLmbC7%r r=(SnI$R.ԑ$VUU#Knu$>c֊/3<1Z+G-~MLso1+Ҷ`i]VkĒMomtHxH_uF-$nʯT62:\Seb5*.9IjqBr Sy#AXӣ%[>رsՖkO7*q}@#+2nfiF?~yCLY,Ki$?#9'sӥN"3u̵wʍ:{=VȾ[Bo=UTԪɺ[A w(,UYJOKEbj|3rOuC5SFBwS5k{>m^lȕY6Q)JKnvSѝ7 KX46QVBUHWZ R9YFWxrrzqTv_j%SY-5#..dxm6DG|C㞝q:,pk@NleG9s4;0*rS)ԜSmw)]m$Pǹq}/zomN{#F"4]hX#Ee ӒN>yT_3Q{}ŕr/tF6֔c'kH,knp*=jWr8Z"݁4vw ۂsXEsGrsF;MXЗ`8]ON.6ӹ<7 r{EGDtSM=_V2~[^ZC)EF(Q,ި{\EUDy=y돥iѣQєKzє bn'UN.fOjrʹ?Q'sG59JLj*6>Ik5Eʜ*uqh5B0R:jv0)ivbrR}-fRi+cKd_=rGɞGEӲKRC֞&ݡӎ{u$R .+Ry'NuRJܵ]CR8,8侀m!Pdfۗlzқ:_3XRCV1is3!́kI\Oo>]VZcti3\+/t[jSPimF59*KW{,?fqQ4s6*4)ҒI;4+j)V$q4 e$ڧ5n9GŌ>Lp9Erʠ+=sM/wv[=L72͵uf^^5 *#\r0skJ5^ƶT꨷i; x)٣̋7?8R>Eaۧ5t$?vFkTQjENib\t˼Ւ/5ª7$➶2 '0/cd d]96g]8+ɯ%޶65.8Ue*ZݏNek# [kS#lG S/\AtZSqr8p$l)a8ERTě(]G;QUorGVt{Fg*γ~enLOHV#9 zZT;֭G\p<{=kR X*CBKM6_5QU 1yq*4O~YV`HfFc?6==#QQӍN^RNpriiW18BcB_Tc+|T}u)6ֆFerF۹1Μi:Rj2/!YݣkAF{w;}jxkF!*i_4g\X,,0B0n;~r*m9ƔkTeϽgU#f=Zu;CgӞ .Hi_uW-+O/4pM%ͪVKKd.U^drDCy.hgSNF5^0MڅbO0LWNף抺3>5UnviTv{N2׷S6]$E(uP $$^dld:f{>Y^sU}\ 翗ȗK,{3H׷^+ҬN1I]9*Fh4'F;+}O# 2]՞_t__Zu%'h^U!Vz B,T~*=o^dF>rwk(ko{;eɬSj{[~z7E9|Mv%<nT}Ɲ:r,TiqA#R/iih凣**JݮZҼ]$͉T09__Ҧ9aߙFܭR4.\(D+̉!I6ј.?2L?k4޺GYI+'~<a}G_t)cn<ލ VAFq<=m^2Zv'LJ i 7Ka:Lu'*Z9RdK@ CӱZܘCTv{te'̙>n޵:zSHA4|t g-$ʰ,n rG98 uaԯSG=l<ۨ'yyk?B=1OO*B˵yV>oarE4-u}UEOOiskvh7Wc =Ԋ )ay rA灌BXXmgO5)A;h=.pUfvq{.~h<Ҟ+;_ k,k)xYwmH39)JJgi O:vZ,,//O Đ enc==+Ĝv1SPQkq-i22\I8:vK)(j켿YW5Ggno2|=e-YE^5vN$ʃz^5K+'}[5nzׂ-M$vC4,vpè {י7v}-o;ƞkhrI_-g9◻tɧ'vV es'4n_ YIq%1_UGUڟyU#Ҹ>r7ԩ>ȭ7uNkQvm-;˜Kmm\{_\כ'1RӍ:\o%(YT˺L 2xYb9v/ܷgF$o%Y:rGR8\}Dlh,ʤ>Mwӌi(̼WR5I z>ry"m^72ejڦ,v'; zTp=cvzZ:^XLym]K *c}Ev\^aSZMڕԦ4Y6%O1'ӓ_C_Վ:r(=|j4|*~Cn2=½ qqPz1/i+Wwرԓw>9Dwcni/OR+Q#nu4`<W)=EJWbR+\D~|ឤԭϣOCvkͬg%I gAcyi)E&U"سm;]KqPx޻x8'ʳ~mտ&S%k~L.Ջ1"p2y?Q~yeȣ2q򡉓oj#8?^GYkmTio"Khspy'/qWc-#1-/]͒jhdd~o_ӭqhTmM:sN]֠^hvʬ,$$;cV+Pv~GxF}9,m^ i nʲ8^A+qӚXiU=|JiRXx6z<{]gMXԈv9+x%K4ܥC׫Z.5i4Lmԝ+e@BgR{"E66Nrx<ͯCYsNqjz<]UQgXUYp}N>|DG~D(ITrKTͼklj8ԧ% XLTM-,kjVGV4MqZ.:1ĕ(N7m˿jGJcN]iȎ k}@}"E®y |5.󹲡z,tz.lcr=Q[xbY"#V&/:0zt񪭍sӨj]Yt\|Ȫh9u9ָbW5͊RS[2[J9mi:6۵88]^2fx|EXsi<2[[8hnȠ2`A8#?v'ڛ^"*U)\|9t6smU_clg׸I(kӕ].n<Pнs2j0ʃ^HbRZ t{7MԮnU-d]ڋ*ZTJ=ᦁyC^ı*httl u<^8B(Ƴ>}l<:kY[2١Ar;5i,EnxyN+<⿈ŭԺp zA^Tv}K_5zDž[VI2-Cv)끏jqVHm^wϣרtvs*6ڃ(7|uFT#: vg'Qi"=CZ6pVgO6*)NyjǁrA']v?VʤO#֢⩸VOBܪ{R/'gRY0ZixZ3'Wɺ˱MX˪9G]:ck8jZݻ\mk =EԘmv1b^4Gm:0QסQ`.T}oʽ 8l̊تǒ1zGԨtiT0bsVʌ}eNYsv9kKIkY&~fVyqJ*JO'^8nGXEkmdY<ўG@=գӊ[/ҷ+c:TI.aU ^}2p+k4{Y^5qS(ӧzkI{pfEjUy'R6XVѓw}!O5Qۙ_GSە8\*Uh׫<]Ѝmq+۟WƥKsNTo߿&4hN n-~ o^*f{馾ZeTV]_'k;ۙ,f Pw8/E|WaU9To?s8 S F4}ئ=z~SKmYw}# c'o˓g`╣/MVЂ]]TwgzQ+ lrgFgZ[:!&oĸm&,WAUKݕtӤ+vFa5X3076OSk'\οBq[rs^;78N..BO;neuk\97rC74&ټ̍==E}71Su潌zҖeDr<ۊ=gIEJSo1i1j{h̐džf!22m89=kHƣl2r51 cxei4_6 hfyUg&ED =;S)SQI~xʏ-4t$k? IU!&쟔6z}8G RZzr2COk0mJ~J 8I73 N򓱡\ZžF~U9׌eR:>Uj{z[in[UX㵟^rPp{C:VѬ80TDW>Ya9ZRG|%OG[n+{dqV惄MҍyI+K4p[5H'8+JqrTJ7n $7pǜ}8*5Ɲ:տy5h2FnZcܪ {ԴQ5*Μl3/719+>>M=- -,˸.>oδhi'tFR_[Ɩ5+JvkKp?gSTkeJ?*e GU"6:Bj&eVln& ݞoN^1*:[E>vn>^6ޯRӪ&5=Hʻ(b/&4g d gh5}Z"N"cݷwQ241iMvSSGZK7fkivc fFv]{,9J yb8VCl'SQRwܰ&a)}R}6- Fcrw8jFIJwzyZ [3\9+.Xr۸I m!C+1pEh1ïgEm 4B&/<R)Q﹫ 1IYy#zud[nWsf;z !#p28 vFԺ~7=CFxDpfYf$>?sZnqv(p}]6KǙH! .]Wtnc^z=[jh7wR5|ɶ]y-SSӂ;Y§,yZ+JO~j[w#:L}`X֮C!.b@w p7n}*=:0WmrYN{s=?:&^Ȋ8kx_$ ~k2t.JsZm&ٱcWw׏r>NOsRHkDm=sZF7wJkᶣcyn#VfRl_=s|+.MZz.7\K%r;O[hiKY"Y պ#,h6_e8'$:qe>E8VkKwpqq"1+%k-(8=,:W ,D+'O^(u%nۑ2$]W71on@} iN43yI))&a=ҫ/~N1#1VMJr;0,VYOꮘ\N/4tXq̑s:犒Bkaܫr+K$/Q26v iJ8Ż5#[ɋWݒ`'Ҷr4{Ւ\mKY1H+/M;(m;J4:@gT .ҧh+gj'7reB$XAܱ"zuUFj۸ec{dcarxMe#i8)rY'%yc,HyN74I{:wnϱ+\ѲU%#*܌?֭VG1 [UG'=hf]k̬=JWTeeyI+LbZ˳Iקjtj{Ne'a֕U(=.do/#K*`1x猎뢍Ow^iPGAE-GRUwJ?ȱyI3?󭾱);1Ky#T,jsTjGnj2jFz9裈QlG΅wzI\^k}H?%`>x֦2w%[޻-f5eU|0FGܲkڵi_L3=/v888gWEWUc:u'lIre]2^<`576=JtFgU~W0 =:1~_beKv~M7%j%@Wq9z=itM^=ՐG|Wg? z3 KZ>L s41; rs?Ck&ݘ4~Yo;dsV0ĵ;1I `W2NFOӧzfՌ*|^>3{Fvo*Z8*Frw_,/oUqøʀx?˾**inm ,tc 1MG-a' Yޑ(~=Gɧ-0UiSr0gܸXp*Z2=XэH"ڱF-26]f|{TW{ԣN&}JHnh鶮u= ph敢c~5aU`63ӑ18Eʥh#)dAUmݮz:I=̝F8HdgӧB|*1]VӽNىV, OOc4]|{IVjۧTrBKhYZUأ~^~n2ǿޭ*ӍH"kSUC4JѲ 8IǶ{V4?z]b)g9[9a'ݖ$gҮsZ?Y5H wcGvP:z[FpsԼ|]]M#Z8+]U(ϕ%o#*v %yjAMmFRӝ#>{Ndn(r3>tz|J>hKyh~V@c|$csץqtkGMѤѳ<5iw8;/={zWZ%Q5N[gXO]c!GJ*r9U*:pk; 6XEv-,``sJkTvVe*5'mĊ8c; g q~52䝞l5RG21kQsFcN [x\fی^:XK{~Jt򥨳e)瞹W=4U):j y N&e'n8#ӟΕF%ho[d6i>vvp:\u /JsحVYxp_2zS]X|De$µDE-k}7vM$r3ϵmt;*nwo2{$*ecR6VKͣ>kMVFe8'_JOzRzio/>i\ZI>Kt_8 {J#S(F+Jɷ8b67Z0#w}Nj~s-A [,T33k+֬]3O,uf*8c'+;t3㺺܍qCʠ׏]Ց4mn kh{pх^d֧?գN\wt]nn3WEӌV4iŴS6Mv z^NTR9[HoURf=fV5(18te.?3Z47ZMk,wl_#F9ѵ6S{wn ϴqsj!howFc}՚޻+gpz{ӌRwjϱHr,ŕE1YTNzֵ(Y-uhc5>58y\a;:ьKRifkH6Y#LǑ;g~qNK5hԳO&ƌj)_"am!R>ef!`26f8Ӌ^D']»)SnZ.ToQD|nёFܞz+.d<,M .V1ufubŸ:m?:#'_#sÞ-knEJJ.9J|cpMTj%vsbTX崭4Vo,2,`g ܞN1RKUO[8y2?̼nSֹYN e 2O2erVN-yq2rpG~x)y->x{r`iw&h~dVexc~+ɜH2ZgLwy(fJu/>IwL1`Fa)TTM8/\Ri#DK"?/;֊2*sFȱ,Ž[v;M X)?E^n98|zq؂aXcPѶ>ޕ]jK+6Ln}/ұ-:kS{^f[{xI1pzS5Ou|#31I!Gw.{/;cJɶz8:4+Z'2jyGwgؑ#ӺwiysMCәVYHN୍~gЌi=K/in_MՌnYE©p+:؊٭<3vO$we10.GjʥH߉qdfc:kyrn9prFqǭixӧcFSZ~f$TtWԏW3Zg 3ȥ2G#O':JQa/%C!j&L?T3N8һZ=GlkJ4ǁt% pRݹ`1;2x8Y;~= j[Nz ,kWˑJ1H^guO&8\׿cjKb4v,/0`o\#j2S5H2َo dcs`Rۚ42iiG޼nͦ]1SPKaw8=N]6sU#vt:-L?fdY: 0:ITU9S<ʭ:Rzm&Y X ƭ5Yw]'gWp,R*WFqU_vO$4a*]vwye0N]xx{_,ia%Ͷ+1+nx'550jaݬx8eB/qy*N=0+)#f}{ؚ4c[;K!2r0=:WJ29j{^k5,Iq{N]$3<ƥZQ9}TJ= \c5`듞?NIJ^+Iتtص %˅-Eeo>eR-pRWmk浕Tg =FGt}hSKvGpNH vws'bVV~ ?~ir6K{>\a vii$t:xZjn֚4|k(K 7cylEQMQXzOB9oO֑HS^G{\=^2ɇK]sG*evA'>ߥsF#[lD[ʝ֞]GG#47iϗ>5Oy18ԌU=ZyR7O0G8:v@<4[2XfƪɌ?F17 ii!Rnln6y#'N=\w19KXmB#FՌqaӠkR>j ZN6߱hM_`*9){4ɡӢ[p' fV|w;S*\zR4ܹz$[YD31%;Ws稬_+)R8#y!d_z洣[ћESnt'U&l(FcO=c:^[ZTn'0^GnۃOCGnIsJrh(Ҵ\Z{51E'~*v8Oqmlnd2,&eXgV1XwIU8Ԍ#'kÐNC2?xZ#OOVq+m[~EtUF=3̣T Sv>IA6+3r@8;׵ee9Ti[-Iէn-ZfX=qURQ{ےۘ,RNy@:(EX%ʩHY ۹wQ^994zQJ&?y3ac?<`~u5-3TtiEA!K̲c~{1iOSSK/i4vi'?wqgEY7dJ:MBdvQij4֦)(8*IMZOrldpX;wc<:J2*¥ԩ''N%Q($3O~+9ESqµ8rzh}I6+.:=1s\=i 4yx1*Ux9'VuioBj+I;Zޱ9BUXeNz{}k=:;*1uդS۽<.$ڲy)78 ?[Uϊʵ ;vdh] 5GG洩(ݸ_aBDvZAi23mB,N{O¹kR31I.. ;GUݴ(ϭKP_>g:O2B[ecHQN_e+*)5Gin9k ɸLJR^[X;|YT7lcjɶܖ}eSVoʪLkHP'+*1%k9Yt_|jݫG܎rANqf`\Qd '}8zR%޽Ge;ӌ-$m@-Lc?|lxI*NF0Hʜu<Fn@\.;cZqVӱRizf,7XK`1S({7_TeY/rJ+g{p:lz=D]=luFK t+t6^ʴZ)$mr@,i>osJRiE^/_ۣNaUzQ(Ϊ^I?PΈ*SO<~8溰tӨXv_-UUẒy'1WFM*{{A얝@-9CF2>^8JveceVm:`[? (ƜhƝiǩܰNA2B 1`rH8EvӣVDהjEBbNYFS*{sJT__Mܧ o0xOO_ƺZM+Qe ZvB¨.7M?$g: YK[[0і~ٿ fmZ\,@N8\˚OBtFɴ4j2|3 H=+{#^hӁdYV$cnO汔hu:ҟni:* [ėz+TwcJPZ74lx +w0]ޢ#nEiFNc$ڰczQ&ز*vzeh֝Z_պ(xp+oƴ˛$!. n G&{lu<,F@V%Iʑo^+O7gD*vehc!Le @'WK[͙j]ă+gkY5Utw]w::-u*4B;+~&]i *djרGn=d{T(bRӡ{m4޹Pߏv5NtZ~fB0qZŢjm"R&a`c<`{VQD:J0Ekt1/,`OfvGctZάMMZk0ui粍hUEҔeyTN3ric${7+};|~U+EE]#eu}^θԴ{5mvVM¤q:" kIR\~_.?Sѕ}R2[s#5Vy1 āsۂsk<ʽMNO GE{9:T^wEZԫaOWrYnUIj4>[#h 9inq֧F1sw[z_KK<C[enGmKVmUp4+VTKmї|Akmor`3ī.#p0z8eWmv.UK.O7[.6 Rzd("imm~,e/fkekEsؒzsz~{r/i1QK]QtE0mf^dX }QqmRt++ߩIT9PI$c:vѫ،U>Yk-ƻEj(wvy*Hݗ'R1]FI#H&8oZᩋ旡R2uϻKiJIσz=LEoiF.#A Tu So ` :V3YIvMl5YoSRҎ/{NÑ$,IlĴa| e ZY֨FIZ$u}4'7e .GSӌU.RiZ~g] }NO\n㨯>jJVN5U㤽~Y:w ?ZaFsԨW*\Z@FޕJ2rG:%nKTWh_n˖x=UuR=*tjKn֩[?P60צ*?i$rԩOM(V] BkXVtQJb%Us+2*J+JMG_Rib'V\A)$hjLže=rq]Qom[ SOm8tM4gwUzܺܲp{JR0/̻'/)'-Յ|jFp2zڔ {>XY[K rH؎^ rǯ_e9k=fmBrwq'ϥkѫEU$'y_$S=mO9oeۦk^5oU%,4aR-qssn"L=mfhObs?G4L9'9YDT.USNJR19%%u M~5ˑ\vj.'u55p%.99N+r+ѩMJ2[2OH۩*WtJS<1c\Y3%[sUwk#D˹no~=\riZk]Ey-ivlFOڳZ+zyωT8\$cU_rN3"(˴|g?)>gs4*J0v_DVao*\A<^m͘H#R>%N-fIF\2T쓷א;Q9B? 1"8}D؅z~g+ϕ{9;hRe ~V*NGKնgu%(ӡ&;c5._t}A9",C*niDQa[ݝf]CdϋKWHyٻ#G8Z&['-6@ckJCp}=De*qlLR.y>X[fn1''>Ʊj-vytz&@'zTʥJ"N^Ϟk $&yg1O>G{h'^8UwgGZvoyv59Mۘ ֪eXԜm&,رԟ,d`bG֢?ߙ8ZŐ|%HUG|s9⧗|{z8Ƕ{{%KZOm*Ϣ,"̲IsszkJM.hԦv$XGq}r#f #H:%{V R=mA6efY=+cv?)JTk]|rVg5i f|c6*e"#ͩeR}6djG (]KvQ=IƝHFŞ 2OdQ[bfχZ*ޯXhو :tJ>z\p˚hg#uc$1P e޵}8u3CK<։ݭȣ|Eh bӺ#:a`qmqԎ:Ҍ*JwGNRwkwy =KMm9RCLq˝Nk1F5aӅJumQ4b\xV8&A!Fd[빇 =&-|ΪUѼ{is64lM+0=t(NV.z#=:uߩ?/'kf?w(U>AR+U)?u&mue 5BUUF8 W~LXVebv`:zW*rov"?Wrվ: -Rfڿ)ctZz:Z92گ;gk4eZMLޏ,՟FmmyW=lG')hîf47w,G'^+ϩwԨԩ{i|/o#:V&qMS8SҼ=j˗sϊf-+;^~aM܊|9k> faLpQr] qӖc_'vr+ ѐFm[wc_S]+AkSNDOLU.Cշ'ʥ8ƵMpňccqH UQkKUrOA.KQȣzq]J待`Q"T mV ÕH ޵Iԥ(v;Qu*ZZynajZa緷z鵡%-.WuN_'H?F^3QNIG^ζEui "RH[n[ gM\1rK~{>XKk]Za|뜪8z*huRF[{f w#`4k沧/gQ6rb+Ə,[밑4֙X+g8STxE7Sjk˱a^V۹!/?Sf!익&yeG=KZk^ү=&Y6Ng,A^12Ӓ;+7OjCk9ڬUZ886N;9j>ˈ?譥eUtUFԶ=q>KRlr֒J/:{yRckJ}+DrRn7h]ftWO'Ս8{9l&Ɩ;B2/Nr8>S(ʦ/Vn̳m+G!Q#;G_SiNU_y*pM;i963Gct ^3J^RoO^W.7.xq_ҹ㈗5Mi9{Ir/.F.翵*sl˙s?Shdd>oj:=RJ30N4%k+A$T& 7s};8whGle ~e H .F!刯fl(evG~S.T~ҟ4{%䕤d =:6Vc2+>NHfBK~֒ur|ҽ@UEQ-#/k ֶF1bUڋ+W.=B8VP)OM)<̍͝v ɦܵ)ݸY4aUfbdy$2q+U%( 4RVz&%tݿU\\N' z S^GoUVI(h顓yy$ [Gu]BVIgZ2S{Hʇ{R;Ks[*Ԣ?xVϡj֭ n{W+VUS۱_Vro#Xm9?7yToTΈSq;OvZpgoZKܷ߱3mQԗ¿OxJH٪I%`r y@UZ-ebxFKW{Ht܆Xc(HqUFǧ抙:ӞK_Tq/sEoS~;5- ]אg.9VGN {;(-tx^7Ozeջ& ;PKxpr8D%[t=Rԣ羚M 3Þ/_ MqHV̷hh8+8q^*=nkbQNXYk=ᦑ}4e™;v SHqJ0nb407⭼w3s1b5m9]zp%Z*Xi{|y)rIwˁ$m ݑGҟףεy_mJ2_PdWm]i16r@9a?UV+ReyiA[HD0q=GS yRQ.K\kiԣiii[$.OsW`(Ǚ[cN05O3:{{]G˅?Q_aq}z}f4憏lVe*A&2'}1ֺ㭾%kzeo_Wݮz/l!Ė é}Ƹ+Tg j$Wl¤r[ +8ǭGxӺ dX@eY1qiԎX2#n0O5JSZ+bɵYpzۧflqFu)J?7ԕm3B̭8f^ ƽ XYF)R[ӡ͝;4!9]pӻ5.j{gB$T@eڬwgӥvaǘ֝J,),kFpڽ5jKzѕןo"t3mO9=*[vڒu0̪$Xn#.=?Zu%?ƥ7koDVU 72k_Sc97r՜̖* 3:aZJHR)^5 h&L+y>ְpՅKJԘ+\dny ,u'.cC(l7E`Acp:3׺4nq%gM8HNҟs\axon˲я.<ږ|ˆce_-!%IyJTڭ_(֭LQVF&v̫=1zIFmμtcc׫1$vBCdH]%32K1{X5 xZV_Aqy]fH|2;v8+2-= K0L6ºC45s03(8*FAs^?2թMI-N v]Y#0pzdUSmKV$զp- uڰ(rHW,uw<:dnڄȐÈ|Ft,;I猓8< q2r+ĝ=yZZeݨHgdEaӚUʴWsSz_Sm6[pVl~q [B7ΊK4NlWN7z=:s3N9w.Xr[!2̪q#UoŸ-K߆'6̃Xn'G=:Ua݅,tj]I[fWv[\ƪ=y8+MlN@Z+F A9q|>.x?DufMii5feI\ Ioe<qom>sK&k˄< kcvp@Qۓ%[*+p1qI8c41,)ٝާ'TѧaB (+[^|Q]j'/,>pG?ϧzj1i&v RG'x<}áiy^#9:y[l8{|ҫ%QeT/ҍ,(>vovK]4[_})%M/$YOq |89$VIsBM>،%n߯Cc.?D".I/@U@+PLT]g[fX\/J|׺MCg?Ѥx&ArsGLg*ONQIH٧nOR𞠻u8=fe=qҏnMU1VV{~2^T͆S+sO[JKpF1vҷ%i_’iDQBD <5:7wq۲[)~XgLOn7Vۍe)ߩo7-v4;p+yJocKIO$ǨXǷ]Vi8ۧsti9[o4OEqzˍ<ۆ`ZMp$B۶G8~R \s%Z26}"T?M䁓۹2Rr~V G^wox]kQdxRHV7$&[99=k~os2rw7¿xm^[[yd 2 瓜wX hF1Q+_"v6fHxYY܎҈*Q\z3 ;nlP!zQFUE. %cq-GER \1▯bv6HsΥoG{~k?}܀OFt3nq}޻tOBiqhsBQ}[O I|38<;qgp1ط2pGPTUdJ]9mu+ߕG*xְK}W^ij/M%mBU`>]XB-v*>EZm^].V&-?u -aS̏teo|1OI#9P{?uF/F|Mzk,qU93z?iTKSHrE3;+zN$siQS7s[E핎-$/9?/jV:ocRɣll7Fdl/5=wm $sXԄj7ƎU%u񥖧Gr "W2 ^(+sVFVhb{(S\+qǓZ}Z"e5yZ1i|_ uHn/S2:#Ib8$gیרԽz1匽xF5 YBkF=? ƤypU9kg,vۗ$~qsr)-Y| #p9y::u~ӗU=|"v̍XƾgcScSMK+鉦iW*ݪbL#WRNJ_bhV= km&bu\A?0\tA>n[HӦ̵gmJX X˶ h119=\JyOX5"ѧdɓL0X0zxcyݚSN4:-kz4V2BAp˕!:VΜY.]"akr v&u |ՎMJ[-[Bx:-q=_>komI<)lwUYyv]4A$xa>w-cCQt8ӻi껞Oyf5u,cYaU  [_C,dkN2qRqv3~&_"p .pHsQ[0J?S=saMuݳ.'SIc_;fpع(xR V,b߿lq*b_*kϏ77,5WIT$Ϲ_- 7ʤן̴H9(xw'=Nknhr5%)}oJYiYn~bOSS*e8[r1w$-; $B_94SQw9Tg\ hm|d U9ܥ("{sI&'Q8ⶌjZu)Ҍjr}g})Ǵ~c؏Ns]ڜ=oUéSi+|//5Ly[vs{suRyw=f'Vƹ4:chcr[\uh?c?^;ץF2sԩZjUEYYlaP*tcGr}:7m6m&RRh:ЧȌ=RS*,j_9㸮6Z׹qTmy_OaIdA59=URz<;vpmW9'X4U9;Ԇ5KUTi>U|LsӺFTiѥ.nm;wXnbQ6U&FqyRTE6_qVYL,kF~zq5.h%:o]Xwa_w5^du9Jt܁Hy=*~+zrUSv#E Ț5,,3zr?iN6ѣWЎ[(0'_r[1Ε+̩ARZm՞ES/oOoy/g?l⹏g̏muDƫ[OTb̬1,_: o OJ:>}n;o{FY#G婎_ۭk# qrױf8|bD. ~U37cS1AE7 ~v5<_6J7wڼx~e>_{0}9WC*&bP žRi>\n?ZYSkTb}oЃ$ 9;#'89J :#At,iI,b!$eYF)O_ך*J"NS\ޚ lzK؊3N"Hɧ_1Q89?N朥mjiF\К -\J21sI3\7IZ! ySU*pI?>ሣRDwB8>w.@eAFRȔ-Fg.߼v;vO׊%kDmbIAw 5 YGDQǚ=wDr]N}JQ"źnk/yBJȫu/nJL qDTEKNE ^^0ʊ?(Gsҥ3~Oi4܎s,gۖO˘1_9/gʒFї4Ewzc/"I !y5>]MjrZE8y1i<5RRIǕElUI;siLu=RR/oCSm~aa( 2? Su&(E7"Y~e *4(Քt첬EvUCw#БT|#F7IsthћU*7A#ڤt c]QѽI_rJMSS״?6i- 7Nn}IXQZ5ͬ\To{wv-,24`( 7d_UB5{xm#-kn7n>3e*N{ ij!Y=z*vhc*FT]=-!.^3]7RGEJq}ӿD0{Mxuݽk^Pk}5IVO~kn.h.a!~i9aW4}ɝ~bRTjp##FkUcR Ŷ QWcomb$yeynۏS{WZ2rS[#lDRc i5+ m\s@=1\ҩۖ<~OsjY"Yxތ럧rt~f)$SZ`ui_`z\Na<,eK]UZ6²SwX 29c}l:UvGjhn)Voq#w(#ޱU,NFpZ5 >}khmN_vM+Lɼ;-$6 #$bN\HҌ]{v(jYi̫L1-T6 aIMHҰI2\}NZ:_wf݌ }s}3j$TǞetvE #1 @s"1S.^W(qENԍ.`yfF* VRA# 㞞+ڧ74ψ*wm?xfE3u 8z&vFX͵䭩L\*xw`z^QMW)(y5Ր]jTfR[j'鎵37N,gKHёVQ9S7Ʋ%R%YsƻcxKfN+sK#TyFYX0pGֲNߩ2گl O<*yPQ)Z_o1#/g ]~]F>;egHZj.v_&KjPpY3'-+2bmcyU6﯑+utܼ9p'q#,V7Es5v".u4ř5t&ݡVXv1^6hMVOc2H | +d4bF0-RwvɎŐfPYӏ²9E=_ʟ%jpUVJ,{APk.ӚVԱ H̢wdO1Oʣ:{tZ"Z˗}zڗrBʫ49sw:9Gm`hR l?L[]5sVM%8M1C8*I;aJrQ7W4n{9s{\@Yceݙ`{Eg)tHRW=covLKfVCO\`?*r+,\&SW_&9O&іsen<7oF/m-:~ݫhwi)Sۿ8䰷_+Ztu֝[E'mɯbԿFM VE 9JrkNQnr>&Hᴑ..lo݃?N0zWe6eѝQNKm4E-{ˇ-e$dk?$rԷ.qi$ʪ1dԞ/)rN9Cnh֑8R \Gfc $7azysKERQ4c> BK;ads) pF{g^U%_3*J4ݟ^+/M%W9}9N+c{5Xyu io?n3}c^ƬeJڔ/\,ef*:F0x$qT[ZtWhap߶s26ן_ڲ +\N7kba8Ĵ| r=9cew#)9rko褆]6cГ{uaZzuYu NoIG;ׯ^acZ7ͫt$!o ͒F+=O_tO85ew.:L-[FI[_.3}м'jQWG.">*֚yY@ "FK0{JIs vkp$Y1)KD!fDmaƲi%-Qӭ-n}&-Uo89xcu辶X5/ +;DBXr*^w\U$c~YƋ[mp7FyXxӼCRDavGiP ִhTߟJN2АUA\Hvǧ^~깅OeI(4-CivI'\99#3X    DpۍYq>r*Z]sIN/^i.CO-Ͽ^}*bi-jJ v/W̕r\RrO}\ ,ZQޤ=ȁ$a̜G5NKsۺq]}}4KeEaW}?OδQN7LʢKwE >4lp{Q]߯A[v}(GUr ZgF\i/27敓nyz9T"UE]싖#WvՎB3u;GNƲK}Jꢏ+F~>ϰ;#Bzz&#SIC>YqV>|tr6 ul㴣S<=9(DD-qn1Y HuXMs{I\K40)`cR#GYJ9eN 2OiQZN 52{<%*~ҟԒ)Ɋͷd8@lc֦1jVJι+!,=ʏorceo˲ }|ȭa~Pz~5/⮶jb=替O0 HY;bhөg] EQp{2acZE&jUjFn$w8s3ZSRl‹džRG ?SRc+IJ5%f{yyH`*{]zNXxiE[Qf Zh-F`:6^U=: rב^[XVg c+\+ԧS*4ps^WE{E dUWt ?{,Jn46*934r0.r1I>+1\FybeIEmdvRH:t+҄$חnO$Fs$2ܟtcN1ZptiӨk*d|άZEc#VhJ:NƵc&YyʺI1Ǎ'T֣[>ƸYb($(s~>rӊ)Ty4 Yp_h1dG*FPv yIٯ7.^2 3(Ƿ'V`7:ͭJ8=&9S%5y@t뜁ֹ+Cɪ1{m#|oV\OB6y2IS&Q aQr)]'-u5+s0¸o0cǏX rAAk2⦧4ZW|ZM3 6_8gs]kN:!ycDl\g={{V Ψw)^];e 0ۘs; jRj9e;J3*2͞8*vѼe Z [A#$hnrWYJU"_m 9Z~0do^yN,:#(;[V"XV5g> csޮ 4wG& I{* ʻ) riNummG$dqiUeuBҿ2ӯBݵ"Ȳ/C؏\fI<[FўkQwBxcY odr}*.&L> iԢCg#ffHnFrs>N+Nnj+֧epk y.-q&dLWkm8=㑃tBWpN:2rϿR[_ܩ\$CҮEɺLI =(9TN^Z]aefvqy*JNB3rnZK۹jPvF(hR\սt0n_m CufI2xiӌ]m(ϗRZul,mضO}+Hzi_ڠnyǦ~~uy`?-i]:^Y%gzJjQ5y7{y z8033)N.[{vVVyv 49sq]'khN\\l>A:M*nr}?LTeCkR.ܮ HXfJl89!){6Iѭgh2)bE\?nΉ~Ȃ?*yKGy=y#8]tJ6qySJNW$Ii?Mc܎P<ۘQyUlR;iFˡFuٳi2!o[m%NIیi,TcY7vcM*^CX|T)lN: )JirjU i7\D+F=8jNk^ iT[Rgkm>;bcl$_)/?5IsIihFvsxM%4Y?J]erVAIdZ-H\<\EӣА@0,ryc08qYIIt7'6'/@K VUkq,Ԗo:dr_Y4R][UCًE&ܠ.9qwXqi5Wvs=BJ.^NZ1T~˶O*E\\Nt^c|˕^\1DkVb&a~8S/yno%Qr,Giogg*Zn4q-D|EV,Suy|禣+2Vl]T1ƟחA֖bpKwsy=9n1ygR4ۥʢ8Y,F2@=:zⱯRZeӯ1#Ż'֦tȫ~Ypr~_JM99_gdhZ]I [np3g&ֈiԦ>yz)˘$ʴyQuԩ?f6-7a#3y)늪*j}bF8y9˨*?ʭH@8>+SmVnHVYVǻ*N MN]cus1V}z"pU7m u8q}q\cwOi0kkc򭷷/lvY-K{^HK"F;9n%Cw9*FӾfiVĀI#:V>ֶJ)Yڎ_NEKmxvJD\mGʠ<)&h8'˫S 4u; %I,O;aS3t#\}I]r[aw3ӍA_ pw}GC4*9ףjzASNQ+[ߡL59qm'vQN)b|Id/33'=/뽑~K&qpbq ԄɭMFoCpS^jmU'7tb71%˃EgkeFZ}=G GʣwS4waeR_Ď#,2m*{җ-8seAa5>z6 3> Ҝ]HuI|I?uY9oN*qiDgnKnlQזblٶCӞSҜ+8TBU=ޏסNıǩ({uuݶFw1+,FSZ#R]/5^]I[qnn?\Ҥ)_R5R 2VXOjҧ5vzO[lCBwZLUU׷Z4v_XJ\em,El=3\rTsN|F&"~ϷYM>xVvǵWg:j2^hQJKEEUҸn&%j:4,ŤBݚiRT֗mOZ1嶆8+'?z֢_Ros@38!O8pb)-IJkZ}i3,0Rg%QҊtV7%v30]3zלlp斯Zx4k+Algt)E9eN^5,N y1*%uǥrԽH_͞+{=[ܿfo*Fs޹JqЯEA{>|9A@ΣK]ꇿʿnl9f^fc}%U!R^ҝ ®͟UF1I-KV/.P[TOY9 SGrT5ǝ#|ҮdoSX{>]N2N'C+Xthb1ljQ${εϚW(ɩFX\+288WSS= x{7FKK+4(>~|Uu]|_fO'nS}5)Eԥwo @4y󹾔RSɣNU3ZCLm8˿PZ9. (-ߘ#'5#ZMi}L(6jns?YRR| )~s'L0zUSc#*SZt0o r:+kML{{3*XnPY?{95q9se.X'u7ץ{tjS ^ƘxƌGR Giorvk/kFm*{;VZ]%חm*4biLjTݟv;O8֖jY& yڷuJV+.e8ͿcF\1S^g5Ŗo(Y֩M%ݍ2mHJ;=yl_4M#叼&[EpxcN4bQSVBE$toJΤDT*un?z3c׌:f]z3(jp#_JѯmUcX3s}38kJtvjtܭ#ц(-2dr{n'5{83H)_ot1嫬{n)u@Ň=8u֜b];ԫ7$5푤xZelQbEq18FOR!Ro#ԖK,&O[پx?^'cnlyoϪӚIj<ԣ.h'} x> T;lr1s{V1R)IVwcω6`,!yWg'_=xGzxy>km}mz|05kJm}+!yo ㋻ #8D(U\]sZT⽭$s3BS&6f:bkoikw(}'zuW^Ofi_VoK3޾>6m`-S$ S8XIa'm؟mE4DK29cz|ak4;̰i+[2||:̾deVI 0R8'=q~*g8=O2..e䚻}={=k_/⥾{M*ڛ>(ԏ^t׮G;qx? _I&?jzv _qmrO}9lm;9.V=֛^KO= QLF &XOg 8Ҩgwc HxӘ򯖯S`z޾(ʏ2^Sph=;wkw.1k;wNجkJ|EhkJ,>v[ϚFWԏVR%g*BQqiv>b69QT?pӟNïk9BQV5)/iIDl# U9ROnxƥ5 ]45#4aY<8V;#;WRrrA~ưy39OJS%J%.F9fqMDWhab.Y>ӧKQ6U5`(Sˀyw,ХF MoG5ĭ&,m'k9")өM$=^kY]^dXpN2O$gO]PeG]:8EhKjxpxʽJt);zX~Y/eH3ka[.3vj}FIFsPy-oḧH%m8c{ױ┯{yө^.'Eܘ9~c[rO8XՍ:j^>t((i}~GEq2؈Y c=8KپNeoKܥOqܮ@c&䔠tFjQ庻\l\ܬ7nN1O\bV*ߩR AYjUUefD&%V,8i*}c֧Qk an B8.0I{ *q;5:&zm.M#cKKq. q* e~eК\Ud?Vrw4jH,B{U$Rot:+T9Cm͜?I`IdV "*>:=riשN<[Wiդb.vI\AǶ:{W߯up_F)ůGepѶ4[BY^K9`;ty^Te;y\F%O{Y#o.{V}BB&($(Zܱ|__ 'R^J~}<]*{i$3Bf>S=_z*a wgv3~77a-Uzzי.i>YcZsE I]*+׃]g+CbXt9fOecCNbGU5tL_}OL?oXȫ2Z9)ʼgjqw޵5ӒŢHa]==h3[t`o#v kJ^֠ZˁL$dMt8sLkIQ-vu;_݈W,sc\u>*҄`qٚGy7pw1ϩcڸ_yYyjAF[Csš\I@Ȼ p{;sS,LEec iIN; d4f_i'c to*d~j~5ދϤ_,5œpq8hW-eͩԖ>ukn>|5D,-кI I'ITjڽ4<;s8; J0E81Avj_qjEs9Y=u=goZsMQď 2Bl0>ahӧvPrFqcJ)uhn$a2cN ;ONLUH56x6{6fKG.dccp^~`j{q0:o;\x3Q;y6l\x+3_I,E<6I^5i~=mDv ?f kky ${5:v?Jf8ϝTNt=tV vKp? V;*rl%)rk> h[im+-gV1мJuY6ggCǩxrċ"v9ڵ)'f|f:eQ;Yl| k%ޛce{u1_cb*SIﯛ=l?Ug5gO/o/Hh|u;xl'pv&]"^ɵ{hv"X]4cŢ0H:xR[8˙+((jv+ieXs޶SڹRMJZ; t( x`ןuE>UU|R;ʟ-G [4|F]c)= %?el67Z6ztJHvǑsqv5aimԩ&9~Iޢ}|E]v ;}RAe4LeāW$ yH^z\ME&>g^|TB7Q=n]Mt3 wV 5 + I0\>>SzyǐNom㷧4aoNsh~&[yd %thƛmoe*^wٝw=֝u?,e99scȵyXl/)-9_U|VzV$qܨIY€;pH+*Ў*Mzy>\p]oQ4᪴¦ۆ-=z-7= TRT>156@69?UW6*7Wߏ bnɂ{=ܚǖv3Shv u V% s0Ƨ-ehwZ.-5e[1<cҭg-ngEq^..uGx20F c85P=+sFaVX^OrUne 1x/⇈-'Ȳi:7 99%RF O1UT٧o=zOc3a0D~t8ߊ6>+MeҲGtUR?'# R#(ۛi\4UTײkK^E;Jƶ0x+ʶRgj\.<zGapZo{{? 7JZ<z]߱2Ø9+i|2+LWfZzm2RJ1ߩ>$pT5+X'a^JZ))G:/_(4 &W{W}:kCtw}`ui51wVܥUm9}6_)-:\m9k|&qBw '=Oa:J ;տSH{;E]r|ĂX'j5#R7KO=H()*vv,8G#Tr΢m5:m_Fhg*<{p'8=uZXS̾G :Lj@:9o(RIGv[wB2rOB*e>/ sƸӫIɣiMf<#q,- MMMe0kGfݺ:^zS/]VE۱9۸G\<_44kkkv+X8>Wn֟z/iKW>{W_U-w؊b4ku3a0)@3Y[~o~ޭN^kܺsu+#\a~_WDkKIE4WNMQ:n-Z{S[Xhgkn\Y!MpPn'ZQN"_hLyiUO$cޯ5NJqiC18E!I9 cq:u=GZck*ӌ1-В-~H؜ry#9W-JW ͇cW̺w!eϕ̎1sRނKDWd%fxv0A)Ǚrln o(|T;[Rq3e.UTo_jʤd܊~ҕ>Ztfs"FHT=%S. 9#,+Gu㓁W%j2瑜T?* Qn s;3c{;ʤ>Y4·Jcdr;uITj7o}B);= kQֺ8;[Ȩ|ܶzqƵ(V{q]&Mdܱr;cZ^Nv/ahۻ5xaBā|3Uoҟ$dCEI]=`˫d nI;= Ny&IO۾l~뎤"̎zu(խ^"E|dpGָMk{tr*1.R l3<㠬ye-;SFk]7q3oU!zYIDsObq$\A/n*֦sYS:fۡ]2#Uً,y^nsoUUڪGF79JIݻtsƖ#m/+ KY&H7lulOZppm+zu6%n[JO )W,=V d'\$$lm!N#sZGmFeh'7ΕmHk${>n})Sµ:z*6nNHn1eL94L=)]tdoyNR8IsJ1DsRD!f2$ѱ3ޮ9}F BdW#xƫZRRu3Nb[<12%dfԧsIR㫺u&pzy늺rWW/U,޻ߵ|ȘGqp;'?bkϛeNQAZ.&HOĄ"'lVp.f۹NrV{i#+g0"7'NǜzqS#+>N,|vK9fޙ?_5Ef^勲f&%LGi8R\\yEIVQ¾s#nǹhUa柽t0icLcҩJSR5RiȾay<x)WL RӣOn .˷p;ۮ=UN12j{!Wd 6~~ӟj59Teu.B8|T60NӑQRUDMF?J-]8>U]u*W^jFwǘ+x+g:RVfueR=˘Py64GNm:#IF栉e' pCc}VpsjFzv#Ď!PY7t)k}MM-V3|%|n+53FUiwsM rT3κZ3tgR˝zu-@!܍߇9Tmw;|[Bϟ"ʬeWQ(\ƤqR oӱỏSc)۵y<vt֫2281#h߯"ZR"1~ֱTKEFlXSA8SWfܴS\r9M˷7}脷l#!=ռa%b.;Uqu>,l+)i#UF3t݀{4F\f^Ѵyu$#b2b6UMǛOzjҒ*D0$VJM-IdۺKAyŦažY]9Q'55R2KYlfn{tƬܯ#8H,/wN2W] kpc*)Elim-џ#9Vp|V3c(5hGp;\ĥ=!$p;8(s._6;gܢHw֦~D:}I2${\N9dYߥ0FrK2Lii?%T}mtw-ϗKne]AXzqRFHݯEޤ.VÅI>A܀}UNzZB/ݶ-9hHvf'=}J9TUuاf3HGUxO_erY|7W c~VQX1}QJG^n+Mwmffb~U%:0J9+TQ$_mnl$|Đ=~kro_ Iedju)׍־]Lشk{f<*෡=m8?z8zZKr-q ~` O5ˤ^ǥNEG:۱N](9kfB@ueU89_w"ib]J3Ft`x8=ohdXF0:uR"(E]VCkZ_|6ROȽan 6ѐyڷ璅k K#[M[PC#pb}zֲ+܇N/G/_e$Ms#!]\[s`yexŨ(Ÿ楖hfG;C~qg'5:mFng4ùvcaoQrYcOԖxhcVq1y汕F\׻3{дE/fʮy2~XԌ)ˈ}ji,Ɓ#Ud!r[iЁ\/hYhZF̳NYn19<`i售j`K)P\=;G+-*/ً1TT J!I oj8~cOcZ}]_y?&_lOhSʬr%2#se&;ZrnXۖt܎8f!X–oq3~+jtբU(Y{Yvc&s{\ZzOq4Rs37#'JE{r)It2PUcŒ3U}]I{c*QǷ*0+я/Rg9RIۢ]JK,<ܹ/׭uң.MWN0u#+?]=-м45u?#We,=ևV\iA*5* pb7N̛rN|oKk)DhW~mf*HkjtjUGOe'g}gr*W}(:Q; 2F."6{a]eOTR*wQ]_n4g"H)*:4O9SY>4観Bmhآ|.;+Få _r}Kc4M?2o=+8{;7}I|yhcvCvcn0;?Ljʛ7˫<,)ݮZ&c yqh9;r̉J1jJ4ا4泶vbJjQ칟c8֥NSmo}=>eR9VK޹+3=s:i 9Tjdb_(#{!,>çI>ڳF^o6 ʔ]LoԸYeozxrYo\jIq73"*9pR7QHlbZFPg$p3:4-["k $?.^8G8wQyi;Uw9>MQ{JiՕ}?R}z*_:u>hEhf>Z) ;t:9_̨֍L32`Hw|s`,gJ:R朮i%L#'אv9e9eR+r-@uy9C;#8z5~ރ{cѨ͞+Uv5eF1Zݼ~29nrzQOԧ(sǗ:m߉`2yCU(#؀O|J,x^W~Z;msooq9omdI6Z,9#<VRjG|"gtiwBJNHnc[J &9[w<[gsnf`8ϯOXՔFb?Hs\nVVMX}1gۙYy aqA5j>5aqyhP\,߼b5,Ėڣq݁u]?iSOL ;_5$^X,c ah93VRiiݝOٮkwc QW  qk15seEOLfWemۗ}4bRִݶfTP$ws^W}^VIjl|I4s;V:#ޔ*.T/w*au/Ʊ$Gcq ~VjgObVWεqtd󣙤kY=3OA*}=:1t{p^wue`}s+8rpxt%m,ac~PpO'zG-V+15,dTm=9l}:t(oG.lYXb%IV[D卮Fs1ӕd #h6Sr{tj=#+NxJrle}3=pLDTQaNu/_Q.‹Gj q03j*E*5=zybw*@9J/tpU7 osH̲J#;┡hﹼi<ע b[cpQAXEThŘJ-}ږ= oƚ~ѭ9؀.6Ԝsa'=,6WQIťMȼIJI}1U{e~/ѐ1{z_mᬿmWhpӧr/ًL7w ZV D8$OnՈȰtSVO/SWO]VmkZ>4pͶ7F U??_4iqrQ~nڳέF)1#Hp7|질S&q} _q&K{bSyЩm[{VP:?8R\;pQ .70*Uys۞+*TC4/,[i,[{G'U7Rjn)%%TIzr=?N\g=YN1J_I\B$Y;*U卙in苩%<ӵ8`?s3RIyΤ&Ҳ,YCm>ݙ万v냃Y2U/6eӻlսV64/(p{rV)IIZZJ-,Ƥ@[ˑFQZu9pޚس,sRc-d]RsF7.WSٷkw%?g6uXU tFySN:t:*2R)4-]]n5 ](ێjTJ+c}]biZs#GL|1_^G^ЦSN*M{߇LVD99uc⚦/&:2Ԟ'!I1)] 9N~oZ4֛Xʗ+W}l"B&xg?W)sIJ0*Pj7rK d\˴ϖ6ןf?fTTg-S}4(~$Q .^l&'hVգ]{ܑn36۽n#9^tQR;QGt!fOU}i8rV^5֯|-xϘ-pG#VTNkW5kVH*-O>C=yl0 wCzuV4qVnݵ,QmS?7OoTG莈m)nLQFf?7ASY&M:*7n?ڗ{H^5?F3sǹ5XM.~U(=Q:,>as2yW4js= *JQԭwF| :}NJ*)8)~dNAF4+9$㞝h)&qƧ-D"<) 3?1Yj ۖrc3 NxkGS>hdض~K ,df2;TuXy=}F*U>RyYʧV篿ךqnu{)*J7ϡo%W"w7 g}kHګ#.+q{W3yN5D9]m7#+ۧjo-} " q̭"ER3*e4У(RAHn-ӃXRk.S(C,}=:84)z'\{Ý5*4FF*[=k>y^х:z)>Ҥ|s˟ƊI/.qI&1݃cHuH]w!;6{zt%/kGNq_/EVҽ2?J?&ym캄I*噤vh O'BG)rXƧ,kv̖Mwu9v'һ4Q">Ο4U36Sqz,yrǥvRғV8QT.z;b6d%B2]i*.d.Q&X8#{ꔹuV5+G}k HydS:;~>(ҩ)7k/#YF)<57+GDo5ArkWҴ,ZMa#[lVZ1zA׭irV9*MJ+3)}$4ѵj l<Qo­eٿV켼a,x`(=4]h]I$ݡB=ҩ%x?*k^.܃PmFp[؟Ό6X_J3z4#F~khX̒Վ"mQjs|ͫ'ֶMTnYǯn Zw TRqaAjT8s9eWJnF!fV@Fx>մ~S(SHƹa0Fqӯ\ղRQ ]giC7ݷ g3_¸V+S)s(6 QUONN+ r5g,M/Ȗ,w-'Ko'`汩 ZNFoi֥ ~uV(N5VvkC1vz=lY@n*2r[J4ZumfEk4r<3َN?y%RO>r<$?)L~yKqt:+YaEͳpX~SdgLE?)س\mc!o^놴FiBNZt{"ƀma9=GCRh5.hoAm.}>Vǧ95y[rng-n͸@>O!B+g9R)E 7/5*sӒ|6/ݵ-} JJQ`<+nhnRL[Pdr:ٹksDRIcUh 6*ݖ>WE9N5MoN] B #M25\9F^aZk}dܩ3:(h1 bW8Ƿ9ںyRM{ZSDKp?Vs'~e+oW_mq{i'ԣ}˕2mf$cZGWcϕ8rEnFc hБ{GXrȁAx :n  ҟkݧ+k]F3N#o/U$gq]ڌ9eBkV{c74)N%fSb 햞Z9>Ԍkc  I'ǵIlºqK–ϹZ,;8ZGA?FU/d4k2Xf{9N9R<{ԣRn]㿯^bI<ƾ[yAbwӊ橦ϡ(u/k;ykɻ|n,#ޕI3N+^x|42 O51ϼv>dRѣe`d\nLdpknt}_봹v|8K{T@6sXE)5*Y;<6ڄq23 CWN@[T}?٥}! ێ88( N8z)B>WRkQ#iF*r@̓e%cLJ>28^9}k*n[u𪧱[%aN smXbR iI%d nc?i.kt"R ps=OJt㲿~2QZ ~d(Ue(gOҧMEeI2k\8T:mdrqB2yGF.p}#G?_jt9ǚ߯ot+hlI> 8O:#%I+Y I1Z"GYdZvwRi8-}G1)^U028ϥs(9_Aғ>Z$vc4yGW9#8qF)S%E>ε;!2&'iR<k:s_w_q/2gYݙ{>"){=:uGufc&~ ^B[l#p{WF2OFQ37QPܴ3 glD ێ{Vє}v:+FQ>H]- T[co r?uMG6^gzWr.yҦ޽|WQi= #FT&8~o4߻^>YI[)ndjɕ_ۺWeNKc쒽[9jV݌zs]SE6RMcV9SFT+Tѧ/a;u]*Pz9H䫃TITJZ\؋3UWF#Rsڟ}1v1\2/hԤԜ. vrr_j+hgmHaƝ8ۙR E2 S# ޹7v/e(Ͳ6ŭf~bdhJ667mS+ ЭRƕHЛ[ܙn,jAݴ^ewg<;}Y]VA7 I\=cpUYq Xᶮ>u⻨1y)üZooF]mk* =+sK݂o8aMȰ~x-cI':a8Unu+f%•ҽ =Z{եG nXmW"C?βMʼn*dN\,,Uj,ҶlWf>ujb3ރ55BVSR73G&w=NU,ںїY*jSiQh3vF}ЍoUQayJ7<6434{θ*㹥u5-It˸bV_3YO5S\RM:Y@yш't6̹U4hL1/{|3KKv8G*iSWO_DiXE4ܴ+~J\V*XҌ|[ti[K*BN;7czJ5=M>ym2\XJ=*;VWOCcM刮H#eiٮyH׵G7.o)HdA,$R+zgӚX-= tb7M3T='Qi {Wu :,l͂%+SR2C6YbYޣS:ҝIF-)nʷ6G'6Wo$jH^0E*'}+Z2Qg=7Z)λ8f%ccvEX͒SZ7q6,Đ{1icO9bh$}}HԌgI8I L8vRxyRrdb:c\JҽFk5}b*V74beTeij)Fr8rkki_ew<Ɵĉɷq8/# 6`#WuZ^{_1RVwVIeƗ|*yrC ꩎iD~hNI蝚z |[jk_G$w qNT8=Oڽuy*XiSٵ3< [[,!MSU9 sl |Dҡi!_ڌ?3|8̶Xee|lxz?ٯ慢Y _5m>uj^O4p쫹7ga¼]>k>~]=i`e-e[W\uOoY&Y-2GI[̾ G1doѫCuٯ['m^ 8-p' \`zc d*sJ7xFRjvvnv.5#HDl*;q8XGOCcaYTOCŒ..$&E _OƬ3z҅RU#M)-;dP|:FzXʔlܚǕ$iJ$q3Z?09ogi3̪4.qv$9ž4e\ieycʯ#suB-IԥtKUWq p?BkBeJmS#`C)`OC^G"ԃON|ݛnviW6Ɛ[qzn݇ .q#IwַiMQJI4r6`a8Ff(z1냌zWQkc\u+p2o1b%)$zg۳Kҩ.h?=[V\ӭżkFHJZBOfU[ׯA^G[[~]sʺ:Rw3r٤Kjf[iw7 U@rshqmI'n;<]푤's)uadaErG>vۯ5l|ݵ7 %Oz;׺t:rvt:]=N$1-0c3t[Q*wv]oK+{4izN[[ˆ3R? #UZ4jScߪجž$cN8-[ⵕ-VY2D1 YW9-8ygR6vv]7ns֧UZ4ݷs0 95hU2tn<ʩ|s۱3jTZ5]K*0jWtI%{noɪw[49U,at?ZV¸ᜥ;J-]סذq'9{k6?jΚZ5y[1NҴR¦~W=G0pi7k.^9ftK)wI q]mi W}#1ʜKjv-Gk[HSn p7gc/叶])e#B/yn|n9cQMӋƴ#Fw'S[Jc)ӏgR4mrV4cf~g3{zXYj{4pqz^UH{[S4a̓=SNJ([֔?9$@d$+ǭ7d{u9y+.X߮/xsW PLnrmڹF6^h{G}3}]۷ƙ-%]h89\D*ԗkjpNU=bݻ~f&7~m{oާpNkU9+b֩)8>:wbup*P8rrp{u?LWԌ]躘c9):-캜`yi[X21ۜ;{W=LUISWRiSBX!vlP$p5TNm&7~SLW I&L#(Լ:Kksrz;R71SmY_\.ڼk+UUqN㎞oT6gԣ} o x}-#0S c|q\N)6ڜj/{N)Vܩ{c׎֊8gS;$gNim_.X ,fop8'< W}Z\N7I]hz#~tFlKyF ulsR2+8b=^k <=n A_x8۞+䱘Mvz^iB%u9DFXmS=)ETg'W*ӿ[%zյ fI"qOx^v'_ʧ.OTrYO k,\nܠ##=pэOhՎVky3wDKN]RkMG[ҌkTw=Z}4m{xc:J5lz8zr'ks>fWəf]r8#Q8Co$3]~9Nqkrʤc-Ϙ6||?}&IF݃ 8 26S1ҵ9sNR}lu< Db)8G!]rIӅdƤmh;sgm$]43HT7z9a*ʴZ\Ց`oJ\`WmΘӭR]?F62|n9+(ExD0~ֺ%^yaElCh͸-#7(wqnZ֟772fpø-?_ڧd ]x{WV #pPA8 ,.*kI[O^2f&Kr}t>T:tR>_yMV} v>{- ͻq? )RN2jSֿscGc 5U{^#Qé*idhwgrګԅ[a^K٭6w^ү, dKܿ+ZT(~T4 [vbbV6֘\D"zp#kc뷺mEe[?XZS2NN^w^A*Z=[W]E;8rXiMynY5QV*ύpq\uc ɹ[].by>9]/acxgb*WoDvPBw zÝvŚuu>e̤Adx#ӭm^4G05uR>㸾!jkiv83\FZc2y NI92{.zEve/9ۋMWJr1=Zu)ң]Sinݝy]fj6m̗Rj/쵓 y32==+:zuNUs˦W}/$!n%I^T>}s<XԼbk-:1~˄M9 WWwi 6͸ۆs>nQz8YOڦ]0MS-]h7'RXu-SXkli'F1ϣ M4}qǧ%eݳ.v|)oū(5OwB1ؓ Lv*9nU*n/^/7aru^}vui1э %X=A猜us|Yt?bb+^KѭZ/چwv^VH۽x|4bOzZfq/qnH澣FQё*+M 'òlCoI1YchSDRovZ~i0?[GݕӹŖz=ܻcߨʾ?fҩۭ->w T7Hnjd>XYF֚,ghNF*00GO½N.ڏc̕:=箖]O>O,^ostL̾ F?HI4Znv?Z > ~JP|FdF$\Rgu7x^B\mbjʥE/t(6'i,!R2̝q^IyqR2M+y Fv3G ;z,;WD}kNK>$ί2 7gh{뎆(ԅ9+c늜y>j~[cw8T u#mb1N7f:oŘn5MONI ''##OJ)ѭNO__0e)m_gQl\E w'LUNe?;ihyD.gkskBŖ5Edmēۓ#'Zh*2̤ n mOS#l=qgaJ ;Jk%eݞw|OSr\ ) 19'H}+Tܜ-lg^(죡Rj2]ʰ8t%Olͺ:(өN\M驗4=̓3ǹ9AWdqQ^%RUo3Elb}O+i_sjrn~;˙aI#;7( u c>Q䇘OM6L{۱0gr󹏽uCڷefg%̜3?PYPD7y /oPMRmb0UGoϻ& ߍta7+X]Obfɫ%ʴo>t.Y-NF<ϼ9cW\tg֜Z.PwԬEGJT[2M!h&vqުTAyOڭ̽CR_)iV3/5Ճ.Vnq vz#gnN[1\ԥ5RhسeVdY f?.O8y9#ָ9jש# &fZ81j9}IsӞ!8UU\4eR}yV-j"X2FGoEFXXtZD_mo尭dcA{TԍYIJ%Ί6P48^~u9s$j}^C{M,ѯnp:2A+u yeR[~sLu99G4oC3Y$1% !OUN3mؙbF߯*E1Ϥ$6;2xlߥ9sDse=T[6.P&rpNq۷5jrDk(q-dXُld9ʓO~,}gu)ƥ8Z&fe\Ϛ+9(=ԑ}61ߏ޳+µJ,^3e%i[#;ժCUEΟhV͟?RTy5f}DIU-OmF^,JkPxV#32*̭rqߑ2[>XV+y3x +?TR0tU%*r\]AkvPjșiǬtK%m+<C eGAzӭvuUFce{Qu2n{hF+EeS~GV>[sƬkM*jݴ%$-} R'TJFKnD.w;qcSڎhwߖ -+]q#n w?OY} |'Kۇ/@|8ZQ7cu%ғ YWoʼֱ*R QzXd YԔ:+Nq[ p;*i刨N26`Ͷ@=N9JqU57ҰI/qܪܶQSJ7Q# G~RJn飉N,do1%>8GNki+X֗2{E,Qc[,ёtvv}jvsJj{LIrp=NN0fyiOQ˚9sr>(*5)]}좑[͖k#n* ={9NЕ9EV%EuUz`{LBpogڲHc;$]wF8+,aFV$`4.]N!R3s{#>蕶krfmݰcںQc~ZMhy?Im91ۿSҮ25uԅwmi<}9]Tgo%e=(FeؒnydW.ZZylݭ׸Qpc6]stnu}a<јc1=1މrU> ZʍrB%pHYoyis5t,wDp GTfggjς28TzJ>M|7QVrGְv=:^RrzEH{),ɄQ末lltө*9E2m#]IydVRu)F(Ӌ[TicpmۜOJ2qJ+n fY7hג>lW51BQެ|"c\ƭ+FY 'n3VCu"^U-ecO^j.-;ETq16$e۲[p>U9kJUQWtP?29JiɸبѩZ6ͺ-/v Idu*#)#M'_ &@d ;vZԍ^NyhdjVhIZ`3c0RQvMz2-۲Lө8kԪȝp$(.xֶu)ֽͩՍ9YJRB\wl/2һR1G]LCI͍"K0-4cR6@^:,j4`kuӞ5;2 Lj55%O:Jеey4I;M2>Rrfrӌ%6^FͼK*EgNWj1վ^M;"`ܮ\<r*4i6:(n0w]mi}} 01 p+QN57-u A VI>Tvs޸IJW2_kQ1oXԟ|QJR}}zM@iIGJWvR*u(j-y]1$cQٱԠcfm^ WN_o[&MuO.kNT.1*M]rKq=1\&3 t){II]_Oi/$Fyk32o#v1c_ҹ7ūF8~n_"ž[5[q3AV5)Uvܕ"Hu{E[ȦkŻ's%N~n߮;Uymv_ZLsYV{*SKPIqft9>0'J-0tnܲo dtkiR{:13^{1$ݬ9T(Gdxg^ÖUBN21=T^>X=_e woJ6m#o=PʭsJѵOco3Zsq$offV c?PH )3DѰ:nVӣ3N$jG}XKd?̠@n =+:w|ڿR%V|WFFUA;zko^-Y^R(Ԋwۢl{s$ bV N+ǫS}j-.gid)rrcFn@z}3^elBg0ϦXݼTPQ4p׿^~"JO˵:Te+8]?2aUGFgVb5f9EjJ]Rv'zI]e US}Fnfgr!ip3߮=Kݕ#Ӎ[~RY>gScRxW`yfUi$S95N+)R}!Ҍ_&턚&kq3F)-%RLi˖MmniZ3/Bܗ op#{3InW>_5JWG.3rm_㹉M|ҪBO+j|*}/ L q9=Y{;+dhoqLt6dn\gڹm1yk;y9$>V >5*wheRh.mW i6ҹ, zg.iI_C5E#_,\ӭ'.S)ʤMw$Y3xٗT V^3;Z) R;߳d^rK 0k ^~?`}'uy&Κ$.ʗhU~|tRQ̟qM: =H3펀Sw+U?Q!q,v0b6އަH9D5-.KؓK-KP ͻ 8㿯mXTMNty.9":BXؗ'xJӖQM40Ӯ!՟Reθ+sO'?AE~fZu#r5~ǠKQ"y1*+|w8u>$5K[\m'?qeF>,im֨$xdcVCӂ{X֜b{8x=n ,s`>4iʶ4bz|{Jk6kffwsӮ=ONQsoR':ާFhle+&FރrrH vFO촌SV;iѭ58h6k>7oI;aP$mg|3u%[m[l K=Z?_~xn+?6 VQǚvpWEs uk ܀:` zJ=Hמ -{;wO)uvX[p}F}A?LW5{5\<̶-Mєcy8>9-FQV jjHA<%#ItV.d-k0E-]@ C`ukb8],D]׼WKuo /xm-R,zWqXE;N"pKgxUm_Zfv̸a W`WNJmo#VS&ݟ{lx-n<rp1p35pyyeeۡK|WJռmA4 wvAtNN,v]Ni-OUۡ|H|NS+#"*6 dyc6qo[~,՜iʜee<2o|{xf.\I96N!m?O2rjl֒yĺ^ Wyݙ._g{s?->Fon1m[9#wF){t8Is)F1O+U\6\v?1y-I yq}i{ob⥯b9eN}hbrLp!rHҜ2ĩЌeE0jgzOYF6{Pq Giût-I9$קc\(Ƴ~MyLqZPm,Lvu[4cfس=@}㏴1#GQۻo2 #+y=?֣B'NEJև[(U`Sv^!++3ˍSnW-AEp-'X;vqn*(E*DK(pea_OJ産-ѕiVSV,t%VRywp=q?a/ߐj{ aeOsmc1pZPRէqӏ+.Ř$֏B>՝ovJ ck)8$[)$WON~=⤣feb{ AKw9lrOs\սm4Ըө:IKسsG jyצkOFY;KhF嘈㧿޳QI]inaVm9 r{~oRQFm:ufEG̙*r֬8fFT҃[ ;H?[Sa-?C͍p5y;ƀڦ8*%젹U캝ҔE5}Wa-˫HMǙ$rH 0ay낝Gw &Vve~{&|;U;u5,Rpv'$Y䙚Ok)p^R];kƎ݊dFYU=vvOnNۻX4jI7e,onMnzg |ki/xn[QK*yypW烟WF7pV?1dd${sӯJ0uiuєSڻ6m-4*TtQ<0T!mm ulz%uR-Hu=1Ȏ,CܼgNU'-*RC.ْ+Q̆ݤU#cҽ<ž;qO^L(Mؓjd@OïzyWeB6k2hu[)b3Y0+jxl1gR5S9FrU5]?lh>nb󼹛sy͇v;y/gvWn麉Hys 86z>VZ2(Ӭ%uw"Um.6'_oָ*7ybӿ7vwUeryָ⑏,nMM_!`WǤ!y>ssJ-4~fREx:OZ'zJMbI$"=q몔(.u4BSv#_5Va2G_qF/$+nKrsB ӔZ[^6_7O 698م7HϽf ξ[&#?J2|:q73E¨\=S֏moSO$3>U'Y5:i3X7ZkRFBRh*,acS47LsZSGK\qh7bK]lV~pH9ێTHIufN//+mM cq4sfyxH֌Z]HTF:fCUJCFUqH=5'QkD.߸1ֱ)[Wf7Rz+/od>ѽcxp{W}98pSN*^_ydvzn7r^ӚV_Y9Xц+&6F={סM^JFOzc?{#j)R=%dk0\EWE7+na(s/}Yy\,BtGSz#jnW茻;Iv"H\iNVS{R%w?1SR)A}K)ZZ߱qr&ij.Wj}?ϭvѮWΝW{5kf*OcNRt^=m۱Y27##[IثT7$5]Z6 0ÏU kT~g̷o#r_޵Lj5(n]ɩh/d{=aH<[۷^R4}QCI>Њ":ⱌc[Rj,E%>ݾbsc=Y˕=/t^OGlwwʱC.;^Q ʜ]v=/mr-<Ě5$4#泧[Rd5TO0fC*y;8JworB}7̬{ Hz3)S]䷍GU$>2S\Di?sSFU_:f|ʹdtN{W,FJ3?b]Di~5Ъ8Z7T#m38?ʜjS]G/44eDc<Zr6]Y<\eQ#oRsWZc4tUNuR$73,6~d)lvz<_CϕJ/=I,ၛK9nEh~UʴlfwI4aFw=OtRӛʥ:ӱVu>ZQsYV}Z"- uϜ+.jkmC]Jnݮd)2B0*nJ(׎)FR1IOͣw^] isq5Gb0e~F^ϗaɌ/>Hi2JT6ܑa]q-=,'#Is'nK+09RܸIE唕K^G, !wf=x뢝^ykS壉?WR}J猭ʍJinޤ^Sw0]Dq9WLkӕ5Q:nE "[UNE)vϦsU)FhV̎Fb0psfzJm[_͒,e@UKn܂3׊Q-;KoĕN\v~{?;[!đ  c=|4} a7؆iCs+I%daZu~Y*.~E,l]Fݞڸ%+IKZ%n_4v$_eD%5R)˙G)N.7mᰖY*c{rz=j(F*Oh5]Vi74m<{VRu{VM$7$ţ+~+ǜƹy[שkh]e]cNI]T}+,MmnI3u?RV"hʊRwkFjt3Z36[K|K)8zUԌRmGpOuY\Xq1f1q`cϷj)s%Hm_qBPm;L .i4Ej6yqH,ѕ΋; Ϛ$XZ\}B# |ʥ㷡?`AR[ݿڛUu!ddr1;YIA=֐<5^{]k:>sym6Ӄ^[+jӜP$lxv3דQ:qCSJ'w=>F]\'6d .A 85܏ bʍUrI'8iԌbzVERQݗ4 XP.jv)8KI+Xҧ+kz $-$X4۰6n=8Qҩ{_i:I,1|푁Ǩ瞜Q _83]}ty2E-w:Is#'"%c8KݳZqؾe[ކiOĒN;Y{DXQ*;lnD&B`!$X[9FJEIF-k^H{H']ѵ=V,yw(T1 MyM*˛̖^̥wһ#)A\Ayyd):U{Ԏ?Q6ĮA$c2;7WE߉Gui,s>Vr@[8=3UQ7"qQiw9bΰLl~rހOӵf䭮xyGh3nX-6ǻ̚E(NOG鱗2ȮʱI(ʎkRrs֫N.K~/mH!?U*deRp~S:A~(sY`6ȏP̻WGe_=Nj\D׸8Qý{VWG1S`w74PFwmzNQRG/;l`]z9so-^XhX"/-ҽ9JO{C%徇;ib>Ypx<=C׍k < gTazk:qdF2N" [A H3u?%)+-V-==z @~k9sJ*fi{͑ډgVgFҵHrmBOop?>ocfS3Mjrhh#:Co27qy3&:5kƌ\JvytzT9T\.%ZsYrM_閠mFf2Hأh8]dEdtE,e̗suUVLUvOOTkSw ݄N4u%[x++A]4[5SNONu+N>!8Sqq?VBvWN9vZI^_2v"ocf l>>I+rA%ԈfǥrI#ú.ϸye_' 7O4,35Qi}!ܿyBsZU _sFrjX\,rnkE\6<z-Zrg:EEm(5_;yw: KWAyBЛg;IڸrKEɩ-P}1ӼݱQS9*×ZEǗ*/WRW =_ʴ#R!:sڪCn=hNi^nH-)n7I n]1.wk]g(i|f A'teWeLGZt9(ٹl;#&$YN.{z3Jvo[=ד5m|4D`>ռuƌ}ֵRY6[Ơm `*#:>ZZMP9'_i3) {+IWX{== Jjs1fmONKxK0ͼ5nFa[Yy}YAI,r8;V5ilƦԲ#e.tRrv`1Jo[Owb$LзF=z{vCNU'f~EzRgRW{E~9BGy?{YBw"ΥǛ<1tյ!-١&FBS8'8$g:fԩrkK 8Gkdٿ]QɤQs'SwZ ڻA F7bI8"!%nާFߢsğkĖ,jʷth ۻGK0wF$v=qQu].G-u=BIUBs+S},mYJ.{6ɣRrJm V[:25+yxY;XmjKPqk~hǿph_eIU6\`3WJ}6ۚ$~W'v?_zƷ$Qŋ8(%ߎn|m;uN<:]h.FDHw}~5g#-lg+hJқ"݊w[%g=!2+4Z4wщuE j~u՛EF\.:/BlYr[Œ9޵(ss'wvS{ʱ$=crd1NZ:1ONSne"D (eCEwƴce>UȒ}U:4z-(ݙ>Py݆g<1I{9}jQwom-zFX;O^kGQ:R%W_c]VѭNVW_4)*oVkYs,I3nQyB8znT[M4;EZ@uPGzxEZ3V?a/[+{mh(F[EQW,ҼbfMBRnxS-̖6fh1Lx;(]]:rQ[W}XcւIhA\Ќ:gּ\NF+3_Q>X抷,cW9 w 55ug^4z]t1=>m;WFRvٽU?2f[E䍘}kFP)J8K~Wڊn,UƤhYw9g^iQkF2?> #`F~ֳz9.:#F-eFtvIco29W,aw c wڹ~Fs(JWzkAX/Yrv$c;FeF:FZ^>)/<Us/ ,қޝ=NƬaI~!KNHn,H_?0*\єyg i%P4X/Ӈ*3ЎԢߪzN+馗gacoq_j4:wcV۞y\^TV3Zp-nu?ZgLo p|n1?SؚS7tCʭKv9-mUYۻ S Oޤ¸+ 4SV~ɯW{SӧTU4GX ^+]a=Xyd;ָ|-f7~څ;WB]SNH@ʭǡB mZ2}7Gu.\F1rB$beG-{= )]:zpX}Jvq6' 9ȯS_/[NGɊi+ݯ2T5b$2R.J[;N8mr,ۙP02J5^ֱKFJܖѣ޶=4*1kh|$f;CBխVIcUucq篮1cRl]JtZ2z]O~T~-߇e ZH3Ly&s&m|4Sz~h$̰xfIJݺBÖO~U?Nϡ>]ZGA,3Wdz5с5G)F^M67 ͜r{?*+I9Z3Fse}"C)8ٷ'=ν\=h{%('t>B֡T7WoҹkÖwyx˖PNp硬!>mіU+xMC kQ_D{匝4_ i0p#9]r=z殥z[}jM{(=^[F.m[ur~aROܬ٤=ɶBGʩ89s)w߉SAs3ׅ<3%bɾp sتv<}*ǚ@wCoO Xc=zxl[ܫl|`֮^l? ܭk;$goYd1/ :=yjK߾2J3^vjY5T#l3s+8T=xG +$K3cZU6j7,g1;]F0A$= ruV*okhtg.5K{mBEG%ީ"?v?(J *y${,N"ګ o;zKݖyJF3@cmF$_0,urrܒ梟zT'Q'u5V)Ro3tEQ˒H=r;g])҇KYU:a.OkFѡhu-$8-FF8cTUVW]w4q[HjFVXxUfs=+knLcL wmڪ#S F~5'-Q#(i}gD#1n s+^ZДj-iv}d_/63jSE̹q~pqWX4?⧇"N~?7м[pNGc$m)2QSݭkuEO-(Oqgw(0^bPf4{z]uds9?gyI9> 7<߼Pve*5#>Ud;)ע{^g$%?kW5FWwW^8`;}i! iGeӋȿk M$rQ9VI$Kv}O#KNwZl+3Jۚ2J5Z6))wr*soXrcj%'n-&ܡvFI?8rԔ\,z}ִɖ+a@#Ur+q +SUBG{tе*%V|*L:TN4_yZ)5mrŎXTR2I2pCI*,7לⱌcٲj~6"9lFUSW2êPv[+"8Iۺ*ʍ׷ QF^:N1]֤{UcO}Up lE s8;Kl_Thw}k9MuXT#WhF# o5u4Ԣz4jFM_/VEH ͐::yNm3*nf~ekǙ -܌1j>Y=z|dWiR|$݃=ፚ-H("Hvyy`8eR:h5gB1V%ԯ[9ܾg;_UwrwGO-3W|E-ۻ+ּe&M reQ CI ['=eAR R gG>WV28䁟+፮Sͪb$őUV6~8YԚgVkX$ba#<+|3*|Χ_b1"+_iʬZZi=g۳ՍI%G7=F^fxtv?Uy;o硤|,+42nj8fV<:Ҕ5bRܞ@fŋ`bTzصbyffqʭ 8ힸ%_ymO[.=f_2 _&6ׯ?2~FsZrR4ZßڨOul8\ڲ奴%p^nU:ѣ&Hn_|)ܹӜd[Ƨ2Ge*֤zRk,.C"6|gVƟ*۽!UD,`SeS6Lڌ$m:YU .t֪mWrk5wEI ay$T]ҩ$"hsE^{[y`vHoEEK8xuFM*&k<ǍU]~~`QrІPY#iݡv==Oz+o [t>9leTRDwFEF+-̪˺oqZhDcztȶKVqD c@yxA3Urd*7]5Z#G_G?2ul Hʩ[8<~}I(2Ԃ֑Dıt x?EkF7n7ǖN;n$w/rɵ#r0:\wU|*/=/+bʛVfqsF6QMitG, uP>n135).זabwlZךM%LiGJnY[l|mU r˚ڣE_nM8ggkk8 s6m\ 8U+N+DN%ɭ'hm# lLuF.jWVB\2I6a{N#N}?#x_u%w1,zg=;P/ױW6װM+DmەV qV5\Rƴ0\ilb͸^JK+B*{:uO23)u\5ZKٸCպe<+>hԥǖi;ۦRC(o(RwV<~J8ۖnJJ,:3{XŇ'VTT{2N^זӴȊYC/fcù>Z~ߊ֝:߳Vl9YV8Pc{%[W^fX\' ӓ¸Y3QQkkGrz^TNrFJ̋{'݃kE2c+V(PW1yqJur'%fD$RvUj\XBUH+Gמ]yhM%4ЧwԾW>^展J4exgg4^H9b[3ďcZtv맗]J4iэX;U˚o`ݖ&f}v߅'wz]< OG}^F~aլlGhU^{ S|źjmpw< ߯i/.Ekګ v1۞{Oҹʖ9eN7]=Ia[YYGօdSsZhAn3I\5/,R1_y%!+F!aҳsLG%bkEoqA۸9u}V^>ͳM[iXutXflX`0qJp/6qN-'k"k]ofۦO9qUuz莊teN?[4[хnTK ~yI\== -ίku 2#1//#H ]0jVw&Gx#]Cu f[*>ƶeR}'j:RVl[H>;;Oku@Nyebʨ#T.WsXdgq7TԡEؼ*ˍIǟ´(vKe]xf|Lca` oEgCRZ;i yl"s%Մ8iPrA=Zh~Nʲ{zz?eh$R)ݸrR*]Z*)IioDc_J׳]Gu Xz`r'S[]rjތZbB֬Yiof2CОtc*#NI|J7zkرb/}+Jjq{+[55 ',.TQfg=s_;-龄}b|ѽ>Z򥈨S;"72^3%;2%)?gr)$5Ļ 95I(}*v߶bv滽9jNhm$ή.X^:ޝ8]9ʬiI9Y@ی&?4eR-sX#)Ny75@$l/<{^8ԉ:#/ؾ`BsWF{TګA u:J+LuGkt3u2IdiONNx=9jrqw1|l׺NM4Iw"6T9+ks9;G^\]Ë6}oL)ԵJsXG1MLjGȿiѴUԕ_gO}=%,w:2X9DiUыN-WL2iIF p֒Mm+[Stc;6ۿMYvm'_!@ԚƝJ<.w%%M+ȄCnV__AU}jZ~-&q#3˜>ޔ:Y&1G?T*,$UǯfRWO# ~ey۵U;Z&Sz~cWG܋;jJ>+'[wT@unlg5:pOFv_i +~_3듓Xb)rM;L4ԤV~Fq,,>fnztRI_n= >U4^U1BB瑞r:W]O=QFMPFmnmڙ^8g=ET$ԍZu(˯D^6rI,[<ɍ> ]ӎ+vT⼗BSR[]t:+9"ʶ'd*{K18QB󏡥d&IAVٴN~~Rs,UE%HL3;*#Γv4я=f{;fo,ĘTUA;S]\F9Ue:ӌ]-+J˖rcjB;4]%۬{U1v; nޟZ֓7"3( 9 n2o%K`\#}ZWl8ZojPqqޜVzpF>kجnK$Pk۞8JJJ6:^Mꑛpڣɀy}{ӿc9sWV_V[;hG ~T^-xY+wF & 6w#8湪s87{CRZ}Zd\3j=umM+Q*K%$rLǙӯ\Uc'F1Bvֺݼ& c$pJҌFW5XT,Clǥh_iK2jx݆9?SǧCiOW(o#1né(q4ls)x>t>BU({K_4jbo4LY=1۞sӵy #:xq)mo-4mV̸V>8~^Às+ \cʮyr-gwWDJac.w:zg^:WvpzfDӭ`R͂If89<1\)JgRR,k].?lגr9W)'QsTYA۩N,0U(' Ͻw׳6erSi :<;Iņw.x=>UTyq4hK}5XFȼ+z{}Mzy*Ѽ<Yb$IJսsx䶺{ZKgguN`yk$]:'Y]\vZGݲQznoz6 ][h°i0ZBJZ8ciIif Xb3<#ׯZ-IS9VQ=0S4[j ۶ v=;W_aU5_ =cINW02N< [\g>hͷCyxxBO c#<{eZT)kzQgkWėMiTgP XeߒGzRd>Ft _4lm-ju'?xJijMd"gѱ+$l}:*ʺRHi+JUFM $|u=p[:r*jF15վfC@#j]\z\m+X.#ݣ-rD秸q2qj<wh{6vr{=Tsn:M}/S7WOI4mZ6iGw$;*80+EsI;~ :(ZU]>g7Nem5Ï13Lb5$*qߞk*%uj)4tUJJ-||xJXԿGOOCgI< up7R/TVDʓv;bv5/kb( x{KiQ6A8=zWt矴e9iv滖Ŧdhg-\<שƕkQQ۱gOXf>dֱ?ٮt^eb 2f O$JVHҝ<v!3£{W[?7j˿IZybfO˟98=jΝBZ'-A.ng쿫؊Qiooi`)~Vf$/N1ڦU*I]ݎgMk>MW9odm˷vj*TDSX[u c50hs08`A,1V>U'(vԝLU>dio^`ƹ8W 98{jLK 8NhD0i֕=”LvMر+$2A&Ƿ>՟d/jqDѷs>n,qؿxjIO?S-,HK;+sqZ)Ҍ6z?̱h.­Hw>IQw-GkĠOG$lp==zdU9;.Ow>WucoӃ\To+:z~Ҍ,1OO[Jh&*T=ޥh?OVZut\r9!-2>㸖ep:sjQ*RqW8S*߫XfGXUcb\:rzKmkc}>kAgm7m$а!]u8)B4wnL1|,۴DMq#)eXفaN^Z6%S}U] TY.n3U3oκVhpԣCkd5Viw8E܁͂x=1?3v^Z*TSItvC#$KS#F6o%@rg.znU9ftRrv KqʊE\)}qJ1MY_6:QZ3$3xdѤJg7=^1ѕ 9ZmAqQz^iJt]}|l͎=g5PtN5N5v]O,jk Ym6>s=k֢ʑ-:ؕR7]{gY'1#q2X:gLJ򒋍ΊXZn{2ȫBJ6;1SsHb䯧ωZfv?xb}Üw\׭FzF4R WO}uNBeN $\`סNTuEZ5gvq\\[G5m.\)6؜%.f^ΝK{]XFd%EF8:}1ߞ+ E u=`hybY%JUNbN}s^5oiu;#II~gAKm%pMIJ |s?^}N{OsH\Vl.T˕7,z}^|ٹEcjmuGCiv6q,_UKM@ JbTN^]mv'Z$D8c2f0y`}XsRͦ8-.dY {*x⳧QqtFj>Y}1qq 6` I7t1(>Et73m^:ޜ[UvqOwWInff_ݰݎ9]Ts֩5ϣ+2nˬy玧~aΌ%gZQ&IZ;`?/svIrr[qK,~Un\K9Uٷ4_bJ*ѓȹb)ni)hUf\۞v]WҷTb~~"*awsp}EEE=BMIVÝ\C˕I{gm^'h IX֯R.Wжu8a6)ӃzUqwgJr~躻iw&aV|ots\U+U!ʍI8,_U-I$Igy?u;;9k:oKᲱil!,XYT"~W'ӛ9Ѝ iQΑr)f*z ?J毉*QTJrJD6-v}=Eg-"%d;dXH呤2XYmh*h87}=шce *3ƴN'{4oN7wzvq*j<Q# ՝ߙg3 *N8<^;י){:s*NiE7t]v?<(Ny:ytkO$jߴG~q\3FVnx)G]w5/&fAo.Tϟ~:ƤOzoQWk@ȷM7ʾgU9`{4TNE2tv.fTM2xRHsP翑jtOWcfU,i, Njro-:ɓR°F_^y<{vCϚd-{&r28_PN15z9T:|#\˒635c5+ǚ; ",Ov1]ޓʿ~ԓ ʓ١##=t|Alݺnkxդ/-ZBRwyT",tf|l6:E's `g95%>)$+fi6'p2p3DiQjI)_VDɗC}}@WMJWMhaN0ŸrS1{7{k޽#E.]+{v՟=%}Ⱦȫ:·*l+0}m#(,Jr攵oOA.E7nܖ?խ5N;Z-4#=ryi63׽Tc+4&5U;yh70%cls:~,i7g%!6Mw̨2:sZ)sG/|r |w.~fjݝmRju{8_66⧕\cjYhF)ūӡGlW1.R$mFMSgD %f(7FrF9; _J[UpWdڼwVuq.``wg=T/ Rt-hHp߻Y*H< ){y˕Ǒǯ̲t\ۆB-Rz޹wwu#]-<$%Էc̼Ev+Jw ={'2,{Rdwpszc ZxXI{['KdoUm2G1]=OW<9Y"c/yݢ3DI>U$㓎 >kH֟~DI9SI0661V"cFA*y3UVT}e.Vo3'J4+򽎪)Yy|q܋dS op=qQ'kzE{[w ]ln%1k_fa?:U7F,S4xc]f^u~UR*m[vd}É7UzZ,T}u2FwN5q̹uFL(%cNjZGؒM6KDcm7ry:t&mS W|e۷UrO¢JtbE_ldiD"ɴӭr.ކ.b%tlMaȚVyy7*1eCIԏJ^ڝ4cV"ф%6.4mFxRږ׸Nqtmd;nVI:IMΝqz}u -㽆Tq,ޠO=}"Jj>SZT촿BTo(NF=^*'m*:WW_?6I 0D ukk>GfiB|mmBH\e5Up:}qfE7=om_FW 紒/)PFGN޿J몼%)jWM>7hݻ"dC{aHs޷u=muQW_+ώ GcY$یM:<'-$W-V/\ru[ԍOwd\M=nsFzb8 Q;A!mX*Isڷ{KRhVtJ53`8'o^?vQiiլ$.lC\|XsPEk r6m{_ȑe_8ݮl<5NTh꧈i5^Nv |#MǸ8))'o O3>GY&ݝrcwo+NQCƝHsm:^m{ ƾZ)X*I$1ӽrb#:wo[sJ\^oرec/ALVuZy|cLkeY FA=NGZNֺM%R%h]GKoL{U_fB䀤ZG&2%etBV_n~Qη{ov[ |c]),qOjםyԒKj:}9&*(+3?ϥfܓi0QvsE qaI6ߓ}k ǚj-~hF<ѳ'9Xy6˗rrrC7x<֞2tGQgd{XO!P?:#g buDӸ\հ)˚+CiQRR̔nftgY[wN^z.sC^,&2d?u{k ԼmC[#nO[WRzƣkT>e$2^g})cI\5T{ NQ^07ڙtAn#em0ϵaSHpS[?^[߁jV>Ɯ7?x36J2hiyA&_HǐDc*V쎒4 K/k*|=} JR+:]6WNJ\(1:- 72<; 0=+ό#M%=JmZ)anzYb9Rc1۝XZeBYr]O;NU0kubK,Q$Ы6Jfbҹ]F[ -om}Yb &u\l>θIh9(֩']zGdܭΣz'Uc9qTMC#j3@gd.Y]mym .߱KQ[&`~eXsSi޷5-F:[xo1bqtFuTI[ɄcU=v~/s/e꾾qQqj1T'[=ȱTIT8mce,F7.E,w0vR#VT뢱=YvԱ|[G9%?QLKzt!!b˵H$ϵa*u>'N)[&|:5tq.QR,L];rޓ+ ,۾vVܹ*NvttrΏ,V5XѿZc+TJOkWk^F>\zQGfG/*CWee^+Ź-82~^Aoޛ߹aTR]F|Mxڪ+êIrE(y zpTSSBp+CW.n_Lj3ڮi欴KuX(Siߪ_>Vz\ykA҃emw6v;FrsEjIׯԮa6z[6 ^w Э.V[<3u $myG+y'5=#N^Zj~Qjڄ:ش+#nho_ C0<2?sovzzEF)ٵԓQ񕦂 k\#p|zsW`V/m|*T_:%ݭGjE.VRhdǨ@Ԩ͕ZժZm[~+Ϲ QI)$'m4]O>7]+v tpѫ Nvg%[nmcQ=^[Gۭ~#\3^Jyt5㓞$yJ1K]᎜g=yZ'}wHb(#gּoyz歈nѷK_*]_4Fڦ"VXX\p)x]z{vzU/ ZW0v?ÚҶ"TZk_je+ob؆vIrcGR1AcqOhʵ9E-ZV^/NiKi攭g>;[F:25q+bKAˎM[>Or1U[Uש?ivד> z#Ve >p6ORJ}}W30JҌ]7ЧOI jeKɕ`rx#}kIVZmc7F2|oOS~|BtOkyUU$f {㞜bYFU-O)RX8['kmgH|jז͐FTFB0GCב*Q{9, 5N\M9&nXxVY7Il6@q׷uRl4j>TϺݍ)/rcvQ)>|XΤܦti2훚*xr)̌|l_.?k{HfM:C3l.K`b>Lg,re"rM/#r[[MV061mZ|F/n䮚KF.o1|aۓ_'4M$lxw!(cuTn̾[IU^ G}KũK^eY|Դ+=J=1F2K"a;B61ӓ1FU$5^F4+C&thΩs [%玼vgqaM-rmVx^D'6fifa$:Μм^_4}M(T;jf2J <_ÑQZ5)٥ku#VZCy_^&X[y 7";Ȼ#邔cUZ7Sc#Z?;wkm߳|Gn-cu kk ' Y 򎿧e:ќmQYyj|#)O}}OG RyVL0 sQY˓i┣O--u_6ؤ)s;g-^zQݽW_ jw0+6C3s'&񕬞Ѹm$Ŀ+m;ۏZ9~$EH˘uUyncz{uN*U#V0woC"[lL`$*QNzĶwm#3n(#Cs\8{ˢ>˧-9Z޳$i,+uws־N\nǷs{//7TҐ[,x,_ƼJv^Xz1{Ṉ_Cf$">/F=x^zW-. ĐǷn+xǷNFtE|WJod^wc估YG $'$H:ҴcqUvٯ3<";ۖ? zWE%gîv{|InÙ}?tnH)C4NJWqTee\aF؝>ㇱB?@3:Q:SNVVI;o|A/WTzx46 |``:cO7R_Վ~0}i-Ns[!J,eZ.X~j7z+MyH~`-YmnOqnQ[08I]Mu>dxZ_f \iX1v1:%BRvѾϹX7vqӭdtӖ;4C T$q)CW21%YIuZkz=$xOM,$7A$~r_BOZp|ӽֽ6}ha*y&\/㯈R(i"I7|rAN<*ut}4>wɤKS2ԝL=?;){HQPikwuʵouyrS E{8`j VV߂0FkR=TeR'.hO˨"uiz턣_'To~al%vfb5De#Qy9bKw|Y0I\u/wVLZ-W0F٤Y#c3aa7\BBm,RuIllqeS};>ؼ+GK+6]~{\E|AY^F|ь,dW9>^OOET97dm{Y]N R̭u趽w'ԟ |/obdhPGt:ÓO#1|OKu"sxGOJ |Aw̮dԯLq{Wʐrfv="v3%˱bGGuOz+:\ejJ~O –ݜڽ2kͭoBIJǣG|_'suC=AJP{w0:r~ouoMi%OsҪ-v|b4b*z|/8=٢ Yzg#8[AUmguϡ/z|k'{xX`K$"4JB\`>9{B1Z[oS)'c4 n cei+RQmO[G[H>ޕە¤֔ܬ{uOvN ncc3)6S wuQtOY4*_1wҊ'sJeAK"XShTm$jS<싂~#+'ԫ]G8;]8]-.U>lEg$Ч$ene׊xqFϽln;b_3ȣ*8]`s閭Ԍv{1뗼q,tuyB?X.߯* Wj{`ǾsЏQEuG׼הiش {H?^޵8TLJu# C~M=3he*|ϛs$fޙzu98{fM8ӎTni04UXq}{W,{8++8cth,#`mbAs5z|#:؎jQZ"?+`[XX$縦qQ6&o:(lLqjҧ*55}"՝9(sndG*C+}=s.-_rM9\ŲK#`O2.xX>z?װvf۷B!{zԨnk'W} Vdm .1Ϡ<=Jz|؋:+mkhm,P6;wYSV8*S/ߵBr[r?WR7㽎XҩNRww4~ܰ|"\sϯuOdO&>{]733Wpv?rSR5cҲ&{G#~r7G\ɬ֝x?,%#gwRcv8_48/tΥa63}"By%'DGG sKoZ7וt9e $%5v0ǘc#ֲoEiUWZt/Q{PڪXYT)=팊?G8/ 2E' H)}Aoi~RZIy+ qwf%T7V޻g."*U=*I4T0m(%_י?g(p hEg8Qy*VةӅ=+)Clqک MhJ֤ԒpտVI *)=A~UbY̩qm*T9J5*drKѽW@EE݉MQ<^ƊNU{]&.c`߅8VeJ3)=VKSN*҇ATiHJTݛԚ ÈeŸ#9c_kHdӱVKe1ln=>IBbj)jŒYy}I[viVrRQZ,ŷ3n>%%5j|"H؟q|/R<*-Zѓuc[ySs0n+Nܗa"VXXcִ9TWFrcs>Y[KsFI [㚥'z1tM+[+Ǘw/+ re'%ߖ^VdwXyY'H%h&9y_rh"7y;sg}+Tge)X yww7fk #7 CNhN2wZ8Ҧ_%\ 4hx'fSߎB7Uim?vUst]>16[ 4#U2㎵rԻM0v~ŋwgDZ[nHs>.QHIAYع8(ɕf_I\U,eQ%Z_} ;̱J+4{{zWZqЧO..H -zǖunƐtyPfě7Ƽcִ=wQVOWrKM6ȹ?TjGfjE)^?r';U?>w)7.>[܎S=pFӶ?:˓~r¢W*_,蠙UwqZoSRq26-َċA8G nMlE̚nEF{$2a\~G<+E軑EC;߶ ?]E }SqKp? [*2oF#r]q;GFCӑǥT=V5̏Uo/~9穮TwVZ3tjY䎩|3q&~s!㎟}kHrѻJ`-Ϟ8Ü`}j)Ft֤wBkxZt$ifW;ҕI)dk*V*+|n|f`}xB4^ϩV2#B)|P$0Onrl|_,9nnh+{b u ˎzLv8]J2m'h @9a-WMt3>.@)C<>\u*F2&JWN2|G0 iEZZ3Ѝ F丙mc~fr $ 7h<[u]Jr1o2k1B' B[Te*rE[ V (^~9L*- \fUm8ې29zrmf2,Qڧ*pO?%( VmO4۔QZmos* l?Ƨ',ITQ1f sܱ3g9#=sUmfT7ձFf,BŕN{r*Oh%ԣ;f P}Y )G6Nݝ m{dmaU^sַʕm5}w=IQRX+IPV6 *qたUEJ:-JN]jW ;yml*H $T8ьok5͡7#KI-rƫ+' VsdSwQrB^s«Zy)OsәQq~aS|gNXF:9K1uKSqjI)g]2ǧcQʍ*S9l9!2Y~Y/bKUiӤujfGKT $Olθc(8(򴵻u{ 0Ʊ^xv䓞}8p˖Oy?0N4f9dR fe\0fnXw׏MQ.e'u}NO7+3v)CN;z˙ZyTmTͨ oۍsYZRަlyod`e9}+>ws:ih>@a@4Ov+TuĮ"͞6mhgFi/ywvCeE*YW\ǚSJx%&WʧNI*iԄZF4%7ʞ̛d,[YNAֵ4?Gq$Oco.Y& ~POlw Hn:pi;lQe % =sWZ>ei;^ϖ w~qmUa/9`N;gqOW_[5nKf6S.TGrC4R?"Ԑ{>P8҅gt~efmRrMZU捕[UrHڹkCݿiSe5/EڷԄ EY tnNOc$hǚ[u%_k HUbHK?}tڕI9>Hu%_ku--{)G#~]c¯<9%NNJz3{F v3oӏZ*TV=-2=zݽBTƫJ0Z%YD Ү)]ʢV)Frj_.7W(NC OZtbZ.4mIUn_On:jTR/W6٦ex#$k/R5Z{~e}APںi˕6 W̺IUX3c=:+E՚{Y-nQdnᅙbDYw;SOt~nҢa6Fx6'Fqߙx,_;Tc@j{NG.*tkW$I|`| /s֥NQV2IPջ[ԑCHxrGA\u9RnOsjNA

    OG(G*# ;Fzf"׿Q9fcu|H;6bHq:*ZzΤf9F8\qdnye >]WVyҥNm۰/"M~g4UKzsƍju%K_RxyZCV,dYGD>}Eݝ X*?zXT!Fo^x/VJhWH%><36u{~;#kBM RMcm4rT_CJ}*ҕ㮳C6vuy.RHq+fZF~5$CCLZS]CtGq20sT)otW}97%+z;i%dc 8Ў?E9R{:saeE̯+#|}+ZN:3+m^`嘰I$ڽZ#Ԡq_3钄t3&nP plg디֪[>J1ԧpM|pOץsʜV}.45| 8'b*J֎*SyuRi:$f:9=~S8c(V5T%bAasƲ 5ðo^)M.-,ykbJZK;3컨K-cD$vnT8ܯ1x.!8[_s)PNtmV>x8wрs'Ӛ4jQ[N8PR_2^"\ x! >ӧy-io; >|ԼUa7 ޿hw8;wٶh Z뷭%wl'q.Z5_,Oz1Rִ{ut~g ps:Uogw;%/M#']hՙx& !_RG35fKN㱾޿%=OmUVmCREfP'qֿ4϶ ,G?]v9णQc\\D#W]Fr{ khѧ6^gEҿF"yi) yNFsZƲq?]ܵ$.3&ʖ 2R-kM?̎Kfcm9J<]]>-4o#oʡJ3I9Gk**QwMolv 3>ݰ1`=}?iU[~ =ܗLXȻF7W??mE7\~EfGEAeL[8=ϥ(JrZ31{jtWq(EbIܾ[epqA+>^8(^PX5wȪr?:c cU)k-LuqʱLq=#?:8ƢmNoa̓~[8I~~+SI}L=erEjc"rǮ{c)ViB)-!`V;l/gIa*J*rv2@3:yOc&ܪ~ҥRN<MF,3's5sZzr%G_kMde o-ۥs<;Q^]NY;?>cw[#k3ߟOn+gngpo]HoimxB5>MrZ"}+\$YQecG͑ bSs[#eS0m>+y#F_a `g?tB3)8E>^>-#_,2:tiOwZ -o2Hh}*抍){i(Ejq7u]EcVܻ';W {4{IA:{54ۜ2uE^GDDyZc>_w Fߗl^TGV?WOn[8h7*gl"9ҽ,<{mfQ=}?5lѩaܤ Bxu>W*)He-dQ/7p ~c5JjTc$3uAV6ȡ3sX+B2PNFpyiOz=H45S+0'u5P=3KGFTi[ʆ8|ǖb:oƝK>٣^77ΓU)˲' #^W z.2n ݽKGEo̤ʹRFv_.?+1$I'z#(ǪUq~\r*Xgc:<{U(V~vvaAv?CWde8Dfh;[58(lyH r@ҺQʚќ񢨶4muqKb!, 0.iGC\2h!y>i }p@Ry]SRIi5~-mnv+v9?vh;JR$ԾCE$dMc׳N4^F}wqduk0l6pyD\Iw"XyZأsdy7C:uzxJpGNldNj <@]nndh*Bێ2^N?jFteR6Sݳ'Sף]JA ݑWF-!TWQm<5hmU^EH9]98$`y+I3OSWZ4qYnvx́70)@`}3Vӣ)OI^"2iss?.;Q/ b>PyN;] =ntӍJ{9+} .%1vE#/!_r3xGfҒЭd׫dn^>ҥKt* 6u#LVחEFXVb<N9>5\Mpҧ^ulsowK6dfcϽiJ,]ιG|lQbdY3{>;Z_2Jݮ5L+ZT%.k{NY-<;Lk0>Z>U9CZu5mle^m2đt ٪qMcS3,y]1TIKmK>"OD`f%fhc2c;[))ZQվ4d=_n7[GS9|rI]~EmqqK8_$9g F0?fu{6~6PWU)aWSɩy."&uYbI9#҅u(t*~_MX;d%ځIfl9҉*I-=>RRioc_0]1U} '}xsTiF˹bG^=,/sAZ{=yc8{IS[ԽaoVO2PGֺ#GI+)JO5級-6mĐfmAiUf;ZSߙHըobXyGd>tc)Ji/mC,0X|ޣU::s]dREЦM$ʫ3oH50JڽLe: tasY?JΤ4FjSjC.ұp:859MhӌRo_!Xg Ep{c#:ΜoBĶKku t.0@'涇F4ROM?jA5ǒ\+ucU.UkyW-M1oYj]<.!{ ZԫwGE/d^_[:K@kõ#b2E1Q.Ne7<|BOvWص-4[ùR1 øH 槢W4:rVb彬Pˍ\n,KVZ^fZD,T'#ߊofc=w5K6]㹩>.4ߠMej>T;pqF=۵L/QiB FiO3ros=2|Q[Gk;> BGČݒry+R%-AJ\6A.ʲ|q\@+z?Tt;,3ٜ4*vLGFz+ϔ)wQTI.]P <%oɜkQNMsJߛ"f,ɵ0`7ӥfadz,BAUwɷN{sΜ/R_SLUh*)]xo59' ?>Sl=婪$yn>Ry? %8ޣ_+JQ^=ֿٙႻQqqʵhY.xT;kL't ){J~kC. a=yj1>v);>Z)Tvc(cV< >3܁tZ}Mn^h?B![d`OBZiySݽdI]vT<K4]ȩZJ%o7A7̋ I9^\i%grIimڭ<ȨcCHVLsR6[,~XPQ'm4O=)S|wrٟw#tsRJ,9Q6R䁜z~TZQ%F[&fM``)+.qVM2H!͋2ntgztzC-:?`1Cn#|Ipcڿv]*Vd/Uw^]qccܽoԑ|X!S68A3Ҷ9%R&ݘ4b32O{zOKC~jjWm4';kiU.n%ku}+jte't?ԏ-ov72yCk1zJ*n1[WiH3)\BNԧ'm37P)s K, >tk̊u3"2>e@ԶyۃWwwnuQkFQo_멑-Ρ2q,y]xֵ87{n:S'G~gXmPt84 ;*#,9#z*F"_BQAAtVjjI,*ӭזd,|n$=I#rshc%)F5)E[Ănٷng,:15-S5%C^FO9~hI힃9'᎗\z?=P"]@U{HSVֿRIat 2ƹU[}p+ r|_U8Zs9oS= 'nd8$d`xʴl/ 1kv2LLUHc#98sNPi05(7@Iv)e*A#$>_1^joܣ$N^Y虤PRX ۲2x#N1]etEۿ*o0nA,)6吮[\z~)E6[O%s fg-^ml$uZ}i== 刢2f{'P̻Sj8bqeaΜ7udK`~a}."Z2%d]YE#Hb\7Q:'+9R$Iq^JZQ:QR~^~ݕg",y;qɮqbEBQN= NkV×SztS<*V熋-ڈ1fcWWYsN ѓ6Zy$lI59ehdBŢ43 <~dQIԳlD#mmvMs&JH}r7YƄddfӗ6IgXQh9?ݷբںܳ,Ncdq֔%R 5J? ں=˩RTZٓӬTt{jn uz|]N2t0NQ(f]Ԇ>ǥgZ;hmYRåО=FWݑ4pokjh)jt8IEwztQjFFˉU-ÞIqճUsTVvI<~`?w߭MLEIRM*%RVSlet rswqŸ$XuNN[^T;@gEFb_5t|%y?=1Sj%SHg>6J3hvk6m_\'rJ˹jyW*[2 rՏ5³Jo4v<O +:sn3NzrQBդ\ۃm 垸&W0Bn2ٖ`30Z̙Nm0囌ftƤ+eRv<1b^)EӊdJ9iI Lvj՝4*b*F/-**6 cR2YFu5Sy^OgkQrĮROP=dGDu4lmˈD{rx┭Pu4!ӣر0aլkJ5V9VKxDJ:ݲFe*`} eS:8xQEcѡUKIl@#oݹ3I۷,,ny+2`mwϯtѩQMuvn|Wh {֏9l3ڳHV*oRNJ/>>d`rde\~*:߼˄kBY`vpڸGӠWJ*X-e}.mIccc'^A5k*僴{e*{6S]iKGՙy8\(ҔirAߢ#Hۢ #*^-n cN1$3uW%=q~tSJ{GdR|2k}. <03*{U ԧ7_FZ=X5̖ufE?+ 玜ttjrzTmj} rƼ[{t֔ejpaVztGfep!PI \Wn.kSIV#;tj`us*kʤo7gөxI3$7rMu+'e(GN%qba-pڵs8ƍjiH̷K1?3cRxrYlkZm/B4Dw33^GSmW{ʐxPܯ)ycxF:ccz6z7ɺdC׿u˕}tvc)7Mɭ};uInP۫B9b7q?/L+z4}T.i{Z=lᎃW-gkFfk,7(-At\q^x摜$i]=4o9k~[[+_>"nYXId%-ʣc˹8+Vh4,tt+sn<.W="R_#oOk Z=qsy|TVi#j-=sr]}mY"AFmԂ_Qw%ԉF}:t}r Piװݭ-yvJ8C16߿FCvꏻ<~#rcp7scхG]>Uս Qhmw϶?´6{M=:֟:|߁%{o亅cvȒ@28#qF3Mеt`_Ӳ%׉MR9->R\p|.e*E]MG唾x;F{ѠM,xҿIsϭIFmۧKRO}I5ESEGo.xYT"0۷ T?L~xMVյ{X|ʜKuK^oԏIJAfviŶ=FsjK>=|QbNb˜tjùk%k\ Ҏ޶kϭxm g[tv>7yckq"cJ>09̩TRN{v/V|&eW^vZ޽iyzUph p3}+ʕ>d<*:Jbo49n1|p=NIr+=NUa!]O=ސ7!88qԠN9Q6>vC+I]#nuv bBm_--SҢtV-OkY Y]ĎI9U[z1hq|?&i&ʿ}ӧդkh}J1six.-gG+7ڹW8~uݢyut2ffi-Z5?S_{NnvsvRL"c{D-:cvSzRӊ8M,ڋ[Ǹ3(+*3lu8R=*<[C|Asnmϖʱ8r90] U-&y[C5bȁn&wݍvrJ:KZXzp[yr>(̞bm1)qm99q=4=`Z4dF>{P6F%dv9rx_7R<=-[ֳO@7cs޹yr__Ɣhʜe;to⾌C5̋fy<}0r>:ܽLIuhkGUDQ@G8ۅvxAʥ+3:{Lq[5 Deu tēҳRtkw6N&SӒNO~$ ܖXyyn<|RJ?ZJ˧<⮦fiabGabu9*c% I^=G}',Brmy]{nw2a qYhiJo__VmkNFk:4۲]jQZIk3#yq.haNy֍oz"ڲW}˵T5ocR ƝR2qҟ=Ԍ؂EV8U[Siӏ.!Q0 >7mjUK[=OJj:ҥ9FOSԣR2䕣$ %m:{WEJZOm䭥BދVݑQG?wv6щ0+/6*RN]N-e幗w_>-gg{+\ܥeӡ5h}6em|W3OˊT#Z2Mn>emM(p#7!m;]䞵q]ϕQkn-FREd@08`{֭R\Z1믥o hP2PCq~q㈄q\~LchmԠFcVUh1 sZbRQ^>9*RV-h|~6  +GxJ7wtӣ//XY4VfoUԔΜF-ʙfhRI\ |.OJ2G VwG驨$#1L18:< (f1kvmX p'cqVrOnR*$5|?&+n-H/9ۮ>wjF-MNm._iXQq#y{`0G`\!{'aR1s_7n{^v)clwI1UBI'=1W*`ߧc1V[8áxP 5ht, sO^٬iR;_n繓Ҕpg|+մ%fETF9'mzoъZ&:?So1*^Fz-{>g{ͭ^]smk$G MLT68TzbY(L ל:i+JLkSJk7u?sE Wj'ަwK%ׯ*&:t ^WF%gTjJ<ޝMmG#b+wvsE*IMvZIpt+ILW2|ҳdk|wpiKVe}F1?q^l:io,T(1wپ8=WM[ʷm;F#?2!x=9x0]Oi%-SR8EvI HǗR[GSV]_Fy}o__aka2,1bHv|m?.99+ڡ(6<Ŋ)G0^_㦿f:mV{-t#sxLOMi.,^F<>kQLB7ˮIzYֽz]eu>S; ]ODX¨vk}gHF28 xqOK'{(Lv#ݭ_O/?>|Aaxޡ់0sFM+Av&X$$Xpx=4nӯ~ʏMi϶=~,Y>Kg3I6 vƭ(UrvlF^^{}Թ_:MkoM:k{=_G薖+s$Lz*NO'Rڱ{Eo9sU3)rGQF;*qi}ɴ)0<M"!̀wMtQ:IEiK/޴-MYizP97yH;rFuUuh,R𭼭nh4YK6d4ydA*F}qO}ݭ4q79G'~q+xj<)>8YN0Rz+hnb*QJ<;)=DH u9uo Jl6`ʞ8eF<ϔthƢ:qkл2ہۧڽz4Uooj JS]#zX5)_G! ^z֒{j0= 2'#P)87pNŸc(&#benTq؃}?F0}IEK^)uKUݻ'0>GqzO_m|B4%&ݛ]G궺ռ[* ԩ=U¼d)E4ջU<+-)%_7|aHr;c95NuvG%S F*wv}4Vg_/[9ldyطʍV1dz; O5{iN٫?OC8 \qkW[SVu}_)0:U^ZB<[7/)ڡ[qwg z_U')'t_-,T.ey\?mc&t bg$?lt~_ԧ*8ŭt;)cRJOFGsc'r_J۲bO=J綥aV%|Z)k%1+;bb}xq>Rhp:[x1![ 8 :ӕr"hnh҄9{NN΍>|%g%dRN@g:Ob~ۭ!hu*n: }:6jVgHԜTjZۧm+#k"mqH}&(QZ||wFDpd9ڻ($Nj[)Y7ծ̷|FAcRC -G=.UZqmݷo3Qt>u-KS8_,;FJJgiƕ;sHUJ_/'tIo~Iu븬G|~jGLWF;A YF,pƬvGZJQO[zĖ~d^[R_* Uekvedw򃜁Lsl)SŸ*2Ss OwZd6i]㞼w r-bmgc,|6b<^jJI%ϘVuۦz^qqo$ḋ Cw+kq6};3ɔR*Qzgyg&-®c]m $u5;-ERSQj>+k =+>Hf޽ϰrݱ?iRZY]$2mATƲ+w@xuZE4JtirfiiUn>3Q?Q[\_h#YXƫ0q<>~3o_tRN~HʖlJҧSݵCùB]-є/ ՝+o:3of >iWl\}S{%}ȥʹsruRmc̪}R}1ZsKK;'>U=3շEծuVN6׸*n.Z~&=&gfݷzk1n%u*Oww bI7nW\aB^tmR;MiC-ġ|,>i?qrn\y+mRr|v.;*Ic9iL o=a<j7{tɻ:4D&o>sGj*yG'}NIHݳ'*S3cJ0dgiKISRkT:I:|Ξ(V6Op&}J ?yRNIhneO4x1EETZjl[%ߖvcSUcGSƗIm$lXI$gnWuwe 2+;PX1ȵc-hܬw.FG88Yԍ:h#N)S5$Yd|hr7#~āR}mN*e#7qHfN+:x N(el^]:=}GjTJq*^pw׸;E>ZQMާbz븲Swٕ;*J+ٽ?1.o2 SsEG5=:GʓrA /4}8 U9(6N\t[ue#/s4ʿ7lV2R`v]Ivz;6f҉AӍ;Az]u6V0){:Lř6ڬۓMv'ZKAqXNRճ\ qSG ҕXQvߙP6ee-vNF:s_Jܓ>¼iŵw۱>h=3Xh5;>Q\C5`'^3_ZP7' |9jJ.K~xk0FLtinS|fH7h0 )L'8{q4{R|Es6Tn[k?io><2RD֋_#t n{RtҊ9?izеE-ʲ"eGў;~u ҅9JWK:7NYJ}OzM*{UؽnP&K}NT˧8zm8݅˸7rfTҶ՞HMwm<`U(^Rkrn9l9OuStyjiymg.. }y?*%[Ar6;UZ;t>bf=vvOqzcv{GkhUPkV$>`2v~n:TjY vLS=+HԔ~3z5d?,rm+_ҪHɷ7258[ΚDHt9Nxo*WZZRZ<~Ӻᐓ޶jxHGS[>/)Uی)敗S?ӍiX[zR?9eRJwZKe)X6.1G=?ZVe.r6w*Xnb#(]nT|=Q%26l.s?ڝ7Y*~Ѥئ~˱l09ӎ1JQt㮥;1+[ZWqrGSOgF]][-].T-ұtfjoᣵʯ9 3^y#lWHqkQR^L+~7)\߯OΫJO˹}+\k8ivFG]7NW_M1QTVwe nD6s]QY#:X:8xq.;VByFW95M<ү$kT ^ucJ4v˹~+Y%iiF0);qMcZ?4ܙhboVAE._ijjOqob7wm0 G^TGܑ1Nܓk A 2ǎkJQ#HԌ❞~7+V'f<뜏^~"q՛SԩFUj*iyv,[kW8&Q{{7N^kз•DDrr<2?i%m-cc;"%7 !O}A?eR1ȧ#~h,޲N1qI޶*Ԫ*zo H/+'? *E.שNcQ>ԼQo$ .9F-rx zN4֝N3Ji]yt0|O-b27#D2|Ү1NI#")ӗ*Z 7Rn_ǛŞDKn۹c#dԟzn%zIt:TN1}50"I1b1WNRqs ru%y^׵{8I6f }+iU;+/cL=>i׻{ط'[n-,ce ``sA>YGU=9TwҷԾjp}^eɞ<g]qZk]lQ?WI=n}tV:\n~BƬR8FW%JX"Z*z$VK'6 w\lU*Q_2NدH֑[(7Wnx=;{ҧo}q^ɾ.M 4rvNQNOqjJdƍJKdS4s RqpH~*QZٴ:qk~^{廊8V塔&5:՜n|Yӊ=$^ӼA-|IlЕ9wƥ8GK_1JkgOͿߟECq< ௦i/-/de+)l v'Qlgmgw9烟5/6ݖ#V*8-Zf%ԏy%Lkm"CĄ=;RQ۷TM7^f_kFE8qyNu,և*2m/v>}a$xNC`n9#*yTѯVبod]jI*}'_ݯC`c#O#ZT{_ӖI:|[rW$ 7}ܱw5Xӫ:jQtft͛.e+Cgq*슘|V"4]uƝNk9#l2q~Os(WJQ,iE#+sY 0G=;V1&յڝJ17iGKu%)6ܫl>1LCRio\!Xsa8Fۋ5FMxowH& >Zp*WU5kzl/d_-V XinJ^تS24ETK.ޣ-Ӛ8_uIީw{(]cx݃sdߌbJom4':tթ!- 8QQw:#-߉ Ow B@TNA907GԺz>`㊥)>[U'kMiRF%N"+Bd@8C|ƈz"4Fݖ!Zq_(mJ>;ecOA?uQn/muEyuplL{Wli()u;ԕ[)h6IR?Ȁ3/#e$vܘʜ+H77.[RZsVtm|AV<5|Ȟة{*\5NCU3 8sTQUJ5{iq.5$qT{1Rde *V7%oq'" 3`$]ZAjQw{npTsBSԋT~7g)*zjq.e5ih&rdc{7N{s^.>k\#}ow5v_v ͷ{ rN8MR=өy*bNr3S]z4eN]5KTV dAqDi+ԏM D.)ʲexb::~uKV]zEV#9x `fGM[۩iq2 RC.2}hӍZ]]e-^$xUy)@'Aeﮏ)FrߝO=4ym$6pF^y8Ӳw#"vɆfzs֜en/޶.[b\c|F1z+ӟY+vFnt'S̾\V+uN 1Rz2 r՗wvWg{ΔInads֪nf͟ȬOͿI(X&csl9/J՗Ӻ~5nhҟ9v++s[89kS(T.ۄLa3K+9;+RgZgu^jjb }kJu5c;yK%؞BJ+*v珩!F<_:%M;\aXu 898zQ_F7/[Α"'*}jT彺 OZ)h`K y=+3Nq98_~r-%e[q,LdrЁJiJRjeR.վ"hm]-Ia IpG*Z5)c[eֺhZnc6`EhSO߽m}~Ecd\r |+9JSMZKxn̥QWq/g:xxI9=^kU9 X}=*U%)UMOʹlol/UfHO3hvAmNSQosi5:Z"Ϯr"?L;fk7:kKnǃnryӊL6}F<{<:-f9ix;s8vv^,WRaXS=뿚3T(.uڝFjPI|OHƞ;ŒU7$qi.Hg8קJߑiM_ jwe26.nGˊxs91T㇗=7wÝ:]23j訿,-Q9+TRާJRR爧8n%I f0bIm'𨍥%g{1[}ўMʭ3ygSz?7}zWSk*4[m]~LYFTUj,?s1undommռYYPqHGՅ~9~M^/zv?NL >i7-z>v>EK75ӓ Ҕ)&i/ T׳+81[.4eZ~l0ɯ0EWk}m|uqM4ލ;/'jέ_;˛svʳ|S;EC~!>>>j*eB٬EA3&vcvIA^}SRtyiڞItyB7&I8<g*uirT}g)Ԧ7si2Gai_o-oن?qTo*5#ek*ů^RəBtq[ $錓QIeIN)5g/cqo<̰xb3ϡ'FS^&k;vNfc sKFoi)>dzƇ<ɬ^G* qrqQZ*~+iʥ4ȕu-lM3Be'ҋԛJhu @xU00>cۊٷfo}5fxcej%`WXh?5om*{>+ZmI^u q^h{;kn\A Ҧ?+iٓRooo1q7ƣ' I#^'R-'kNRZk gb*|c c54ah);XcQ˝YczKn&%1f}ZRiųxӅ8U6 mO.׷ҧތ}Y1cSEvrA )"͵Yaόc8F+b0iLlٗfee@n*AcP)F͚TOiky9qSV^+92#%ɒ`66cF e G6˱%mip#lyW9k4-'պirJ[Uņ-/zq>^c0J=UݑrѢQf]#}}뎵ez9f_WBfOnn8nGҳ*iONJ${[KGozQRἶ\\%x'S N*4]˻yb}ZFݬN2HՄiuսքZ)仛l335iť=4k_M0?*M*ci ƭk IF6+yD{CJ\ 0;ӏUv"UxkLK>6QNpG՟璗7#M%נYs2)Ӿ>~ۓ-{7NJ?y=@YcX:TM.YiKvVVVݙ~QG~y)Z]z6^:C'1n=jjT\MB,RIH#6F~8>rHH#nqO:ɬjtG-IjvSaKR>}}jbKS*U(cNJYe5K[ɆrI3BWK-l?, o&I6 q떤hΝ~V8jRiͣۧG eaXYaeX~a;nc*s&kiS궖[$Ixv1cIKԽ}y}HOm *HV蝩 dݑF5Jy }|M:ryfcSy 1y傩R{F*ti,갢mU*GһaM]rR$\gl2`׿^Tc*1&瑡1f}y#=Z#;#*ҊC~~Ĉilvp}3WdjFQӲ4Ma~ l߳߼ ӁשFc{rR׹4[W[x ]m6G͞rqӚ ({[ʜ5G[}e"23fb@ m:q+ڌku6ΥH5c;PӢP mj+] 4vOKʯld 3h(= [ǸP} dpsGZQ Nr\5|+OSog m؝Kt O*O~H7-;lWr#aW}[7nߩ^]MY0_2ss Fory4 :\n65y2w#]sr*vq}cV6XAoDy[W;er*ɭmTpÎxuNqZ8%gE>̖Uq)8vy-82zX)ZY+AЌzO|g/Tg L-zNj>9וq>9X/GMiƕ5$צu6rт2F8<?xZv#XZq8,:O[5MNTzO7ZZ[eס%J$`˵pֺUg,D[-V)4IT|]+\yrdGfw2zޟmN*V]ww6-F5OcNqI'^T v?M[Bm]܃5I5_, #s# .H9׭tMSNj{SUbc}y,F55.g7}_ Q_~Ҍv=NIG-ߠX\$-$?Ҹ*Jj(#[Jϧ4ml-nvՄqexwVqju")2;)7.xtrk6!iI9݆ yZU*j)\0qCީ5576.[\c}cYS8ݚVQ'g][Q0wA¢J Gc8X-Z%űqEVgg,g\.,W#MnNw/%{ɬ1R|*'س텶zuy)Rq*ʲH[ #nP1xX'8kTV7 jJWCҦgdp7*S(k_vVcZ-J>j3mE ç0rGZq*wJ*9TkҒaN3:QFʢ]M#V61B!봫kZt;qWbh.I7t#7Aq%vJ}K sy`?~qG ~U*.Gm,b;!.*$ JNҌR39>i]dI̹2nņs*y{{Y%]Q$*C$iC0:0ZѕSϩOҋ#YĐG:JʂA&{/W*vQz{4$ۆlZQ8%OfnJ^ĄEq21m̹lxWtEE#;|rgӔ8*4lAalOHOSꮉGM:'*J1|̗ed]=nsYƝHGӳ6t>MKgЂ{EkMϗ~\c<h^T)\Km BHr~gәihmk,*$̐9zǂ:׎+ƍ(>~mioRSG5pirRE|DQݴ+y N;᳟~U 6¤܁B$4~i sҿERRQo  }N>W5ʜ˶S&ˆ,Yl\5?+J\ċ6ASFʣOoZrɊk8wZCK <7 =;Ea+;Bo|I# Dm8-BJZ$"AhDKa# y;v59[$,MmnV]I-mnSFBBF>beBSN*F a8*u"տ~dC$kn{q\tEi͈]֗gȗ߼pvͦ5+NOz_ ƣiA>ѲkL_j/i5wsjʍ |#6FdnNӟo:tyc25t8X GyxTӂ!1yȥpŶXg q\r{sQ^B̒=Ѫrzsu~$:RTպ[rATlw,k:j)ѧF|߱Iʜoܑg+Ҫdgo@iZTKPĝf;28\3}a¶ܩ89ϵc)>eΜ}<o [H$RV=Xe)TZv89Vi|Hٛwe'~"~Xzb-WG,xg$)b2@֪K**6}# u#&ܖd8Ԉ6py:Vuw5R/fBbhn8;aviz(k1ZHMǘYo}Jި\"Zz8 46 Nطt'{%ɫax^96nѕW QRNznpƕj:]: XS|۫AU޸ή͝8U vvJAODliw sp; TוXY.U>*$Mg2%z jiE:Z@nS7F8O"jRn%k\xmkT&ԒhW_.+vXJ܇GwH˖=$ӕ3*Jr+2f WڐFͷsm t:~+?yg{w*XV5HvX )KU?S8|?)%i{ ʔ\lrKnfVD(WP1JtҨԣkNQ4WϡpEbƊg889>ߖ=ͰOw(\D2ϴIO]t8M$c/cR6W=LFFY>ڽl:uo}[^h/?.zסNZMѝO}$sJ ~8K (SVShi$AİG8G~Ⱦ+6ܷjݧ[+IInfA;vOqU{Go\Ҟ*Tnc0۬$*rfuq-5+{[,WvqXGBMXQ󟲳q޷8U`FY.#(̯qXʅ>^IZSEIE\&J-k$7󧆧Ȅv0xU*1?QCLgefU֊ʟ*}TI뱥nʠۅ\߳& R1l VoqԘU+XugqMYs{o}:J!+Gq:qLTiԒqv!̎1Sr-zt:4Z#<%ݝx#Rmc#qly3Ҝ4{)IKO3_OŽɀ {ygcm7Z:k1en^XT: JS<Jen~\g\үOG~4Fwzƫdye~A5&JIGznQg]9Si֊MM[z*ZvZq]kaekIZF'zskE(kU[&4v#Z{5YABߡ 7(Q地2Ң2FOM_NNMG73R0JQ-K=f%@/ڢSu6,pa\ujӺЊ>fX]bboҸE;xQȼmxʩ '9]{kBZhIXdW9*!^C8RJNX|:p]ھRq<[r7=+Tvk4m~nXmeVA?:zX|-Z|"|=Zu\H 9}EۃדکJUbZV,>K'ޑ3=?TޭlE𶝬C-ӏcy}v0xzѩ<={_TCRB|j'knv+S᷌=oae٤h^dl+Gbz1\t>ne)Y=zjS״hEsB Yԇz֣i`.Y||MӴ}{Ë[b,۠o~px^ih=,=J[Z,v6c!k;2Fprx8z3_S#Z\w{m@7SG:o #%y+aZ;ۣ:(eڔ[ՙM8nZi]#o15UUX۰Fj䃵~g7zoԗ ^9p~u4iE3he_57͗ /"dpxNqӏ&34W]_Poa߇ɥ[mRW`@,o>N-8~oV4g|Ax=Y>GeQp'2wZ^G +z=׿SO15k ?7$^~U#Z* M-_<)ƞk}$>oh/ؾP>0H;go}yF6"\'uyuo]G✱wM 뿬|1ͼpA#@UV5۵L`ּ)T۔N"5";ٯ%ԥ;5wH;㷽qrMimG8馦&sg5¥)\(A4jO3lu)󨻻[?Zc-b 22ũgHb^<9k1ta̞ mEԖܬ";cֽ:vr4aR7q=][5asЩ[VU.jN[Sۿ鮧^7+w,VBh {ycbN8ϯjG[~=Nӕ%Yw{rZfcUĩ<޾>?Y8[YÊRq~,\6hdl,[y8緿jaBUe8pң*_'^h̞eĘUڤi ja]gEZISR_;xYjdHg LbqݵzԣSIaqd;*\߮3ZTU.P}j4iʕyE60dhv6N2qҳVhRwsTt);3~.F.G)Ǘ89uktuy;t=!S~Gs}Oo* uVQu>:4$ﶾnPe湣N<ܡ^8ǛD2 Gֲv*J#ԊHKv ygt)#̊>n)IS匜wHUnyiNNhb2˱B&@5:˩=ǑZ6n>u TeqJ͗u]Ѯ=TVhʫJ5'r_;1SFSTTmCJ1QD@եP0Ȯʜb3,L_s[+N;Z7tmx)Z[d}+IK72XV]+ZsZ#ʢ79{oIg ]c; RN1w{htѧFy%}vz͢$x kQ;ßƾcq [өЫUu_i}ZG3ojK ~USeaWs+)2zw,9cqtjo{΂q- ,w9ȯ c([ gjksjJ-/-dNdۍG'_m﫞JIӓBC$L ۲sCgx ZGت.wg_zp[eRq,`7yA]>kKxUJryܴvp6Az}ˣ9pզ{~%K̫ʬŒ8'ƴby?3Zue:ZxO=$J0itcЃ{uQOQN6[I}VHn~:FUHudc8wa^J \CwߩI[)o-k>]-O N=cr Y6ܻz)?˚\'TǎxsY>nhpsbR'è|3Xǚ\o 7,2 ###<5-b}nWW57$# M$:U"%Ii>R u'l|8q^eԭQJRvj%y:{:haxMt[Dy`[p8сkRNNWoBFUZ\>ou=:OX!uc+щ;Ѷ gx4)צ7n׾[ZN}2֖յw~ d%SOH= ]a1l>_0/fzN2ZO[]dd#Ṯ[=ͩ*2G̍dෝMx!yr٦̑6WoR8iE)Ɲ=;_Y&C:pykXhsNjrcT|y5Ɯn#ԡZ(r؞k>ٙ#RaOӟ4SyCZJ4Zz4<#6ִc aNo½{:Mn+U;=WȎ5k s%GϗXNI80:n_P\-%,{d#V,(ƌokwѝF,#<`i1)ƳRӹV# ˺]>yubdaaqQ} V.Ta 1PJ*W鮉v~}(#ү<[Íuck(dX˜Q:vpt)ۛmwjaiu+s=s>xAG<'-?h4?qNTFP`㺥USJ3vI7Z:u$)}7}n|8m[-Z//H 'oZxX8N5Mq(Q=oכi$­yV[pMa:4Qdrsz9>c)^ʷե'o|QétMko"P1$w9c_=dvd`%-jhںa~$xM拧у"4,2P ,UT^~׫躟w2*Ni'ezYMFm'4{cIn,Imn8dh$8 2+aㄭg%DVVM]9pJ/ѦG\qwg#t)8ݭ;~3P,Smө;37̑ $QIL ִ06taj[_mߗlO@.5=dOmÓ\<+exv<,-?}OmChw3񍿡N1ISN;+[$#8V~O~3S+NydydޙieN{йTrP_"֝,ǹ zV8Xq*Iep-_4޶V1f}dIkfzwnB?ߐ=%[\b'Mrcd[q1)FFNssYF=O7i?ڼyՁ0P 3[QWlv ]u3=1cn I&Tr1]HN g,׎|WdjGhRRnԼ;wqly _Dnd=A<QҸJ.Ni"y> 4'`'т6y_^xZU)r꣌Pe ѭ4ź$eՆ2rNW:Wh F)MN-Y&senlrKpmPm z((vkoB+٧kmf-̑یH#Xg'GV3ߡR ;$\e.N;8qYyrF#.U_E|Җ Y9߱?5((TfU)Y#q@$ ;֔Թ9Edt/*[ƪ~ݱB(*1zޥTiEoW]䷌̱n<'0/ek*~[ÕwZ8߻PrxxR* eR'[X0o6Nz|x\0tEzڿ(f|xOz\O!*j1Tryۚ:rz8"g*˲."/\*(ރ%wMOu҈f,~Y`A~?Ϊ_*ʶ#oף]d(;RL1Rǟ$n j{:֎5|BkGow5ruM:cvOiĥy2vmAV8OVmHVR4տQHge#r ? i_Mz8Vnq*[݊4(_rH.A7!b(?7 :\1ǖNHiebk57;#R-M˖hdYwKzϵvhޜ!RM~w >UK.pP;ni2c)~F۷ӯlU'to'+DIq/3'ۻj׃xU\7SKt [@Fn0a?os}؅V|ۘ3It is4hj>ex<5'YE?Rxmzg-ykur'xtZ\Uoo"Vx5\msˏZ嬼ڔ*~qc5uRp[x%ƜTo{hf:dGa<QӥlEס*u%]z7UVb_sVVOe#ε84KʍsI\ -Us8j**U~Vi[}r1S߯CNJj6V*M>)~i|[r~b95#̴&JyuЩ$.-[9#Rr #7uIHLJ*@#WSJ1ku+G5+Y#8hUU2ʤR"^Ȣ; GGoNF>Z T_f[)H q߁K2UF>B;c,K#Ir<#_^8*2:={G_N7Rnʓ?z}jT5}nuN>^e+o-Z\2.|)ӑ}z=YJ>:w.O$O%ZC n1pr={5YEǙhɟZo$ڳϓʬĬ`QLj1+VRNhEݻUoݫz~H8h1Wk"ϲ)D&d_2t+%9[G}.j&m_wL1rUʍOynA{83ެ.'+sW=qJ# ImOuzw´FAT\A gj]lcFQN0sUH+@% Î}j]JtTat~$y鹶dgbqgmNnog֝|#*i¤ei;5wMXJfnz{^hG*u$m4V:$a$r1&{'ΨWJڽ[ml!W2('xR8#8?)м'$ݶOkahʢ7Oo[ 2Ven={^FoߗҏZGp|˅v돧a=JvCU[߱ܕ>mǖpT76= !7GGuIV2Zn;RbI(\2V 6䷞ !U®G:|8j Zzl_꧃2rZ[WвQ >R".AӧR3Q9SܨB{ɻ","I<̫0FӵI;V/Zih7TM,EtTeeVJB-gB#8?]I]NENSM4ՔXlYmKYʒ?9$Wuc*/g+WktJP//>u;'3y ca&匥-k1I'}}n8nM2G$ki9r_;S `[S_2C\Fsۯڈ\ݺv<ڔ-m=-}#t&"a&Fwd19 F:B2t?[S*%:Vw22Wr3r8ҼTRRm/'~D'{%kZ7W}%q3 zI7%N ZU] xIҾfIf9J4OC.d>Pl{g\jicJiө)DЭ-9Ueڣsrp*\sΦ.*^6$7'?vҴ# OKTY`_U\i*MJ[,v^C6]ApqӏZM2VS￩<ViunIQRMU*7[iИ]E+T+' qܜcN,n:t9V~d34 lU>cv<5)J\@362Xdsx5j~D\ylj$(n>c㎽:u}5|^(lJ]py>WW,HQP\Я5ܣƨp#')׌Ss[n(CD]+Ğ[$$tcO{VUxkN+Y[>b ,s2*M>S&˻_=TGOº9QV+S8M&ۘ SJ7[-:* lx{֊,-r9ytG u'i' D(~;ǞsB#\)ݸdt9VavcFQLoV P2>R)}b'(%̒y'ӛص.Xη5Yuȸ~cy9R9tmSF1I5bs3朢K-:mt!.XÖ޺ ښkь4}-R_0>-^Dʔe4o: )E'?k7)yN,䎞8nY@ 1{uԍH|[ Nz7z~&Vv2XqzkTvg4cIGU@E瘒-asQӥc)JqJKtU|K3쭤_M_:F9b;'ߊ/;'d\Th Rvv7*I `#}p1ִvsV:2-Y"[1rn!u;PrzsS.Y{nWiզlm>mvۥmV|5oq9lX$Eϩ5[)iki940hF$[a9:t5:w"hХ8)In#.b9 lna֪1s=gOc6#hƨ0o9x]ew-ƍ$ݛȩ3 8I+9S&tv{ ڋo.H~]#X?c8~r*VB$}yYfc98nj.Y&O1V8c@FWr'\xSn AYǫyjC٫%I& ;Etɍp#X*aF1;ݚ[_MKDm>a$ ,~g<3SȌ=nZ$qOOASQКXzqXsXn^Osӌ_Um5gdirqٙO@:j.TxRíWo+>~h}j9Fֶ|ZB|pG^9qvUK9{98>oNM*0 yltw}SnOԓI76Lhfz̸\WVPϾsAQ[$*d`+ʧ%kt>-SNGBr1N?ӫ3֎*J.[osè^62On5NVv6m~;D_,>V@r~R uw[){v3T╴mp?0K(>Oӯzeu>_Os%)w4N(<{WeT+uauo Ml$I|Xp8>Be::N.ߊ14iݣT6mۆOClWùUm_^N>mԢPRXUKc 'iT%VO8WTúpi+6[8?WSEn<`,n2A v8%w;s vQƵK8v_?7Ooyc wŻ! Ӎǜrq:x*iY],z:kV~uOC_>nn+ y鏓[,ooĔ1K٤mwׯ_5uEn"V5GWKwleH;X9m$a mcڜ%veJnRKżxiӌed,XrF9ȯ(K]3ph+_8mjy#BYמSGEi˖`VQQr Fhͫ<<,c#*Xv#'kJz{_׭DƣPZUhr<\o#Ai/$j{Eic]#ioc3mܝ9H0?u^;QW8Sa%z^O*- O^xzzѨ-/3t;Wj:2F\SǷEEK7xzu߀Hf6\L~mNBG+^+2J6zۡwN\MuH@o~b*Nh<*u+Tkzy3$Mt6Y-cW{[=xiTϵ|"&{/"]%1ꥃ21=[U.d=Xi$_i_kIycQ'z g8#>W"Sb}-ɺ"]L^ cO {sϥZ4)G9' %QB?)A\s¹1xJ|Ϡbq$of=&.[ n dg׊kyEyό2Mup!b'={c޼lvuxٿ9k74y£(AvU?w8Wvݽ9EԋmiƣuЖO(DzG,TRO\c%(ZehRM52J>9eZQ^DʏgbFBFx-;w~+QKTkM@ryNݪ-b\jF[h".#+f1m1=j<ݕC*xG%ݳ;#q 9ag}7g,b*K7(B2>^wdVhr_ UGH*:X²+qXRCyѭ>ezzw F[]JmfB ^ ힴV6y~Φj5 S@ [**r?P=k)T7{XYQR[Eg̑+ k6I'+*-ױ*!IFi%۾CyMgm c8`S:tZ89J|ؒ+}8 W fԴFRb"vqpqLjjH֠MϠJE?r*:Xt0C#x=9U#E+|TqDdɄѥ퍾f4.f:}^T߿ r%,xe'N}q>Tdk4W˅Y$Q x:0}XKL,-$O/j Q1koi'5F(`#ff,G<ֽwKlLHՅm{\!'RlܥpW9q]T+UiF][ijWT|*"]Au=9Bh.uӜTِo{&/wsv'βdU: OwtвX˺dP\zuNkϩ%uaay:GU-j"hDAr~+˩*sLcJkMB·(Lpzm{HƚwNжqP~e;~+T9raN%(GEԷbDM1gqҰս #)Sq4'׷\ݰ?zjRd.2kGmP8gQݕ,[d'ܩVc9^/mB)5juG#mE2~NjSGx'dc +O_Bޡ6>l')Gb2qSӣR+-}WXG=d6xDiPj)5=: d<)3GYդ=STUmnzo@ȣ€H}k%4JmnU֫jxx9^^UTN*͢!Y³+6qqxɮTpZaVQ۱uy}Udܱrp;f.e*\?97p;hwXrtru9J Zyry0pCmw;p>Τs+R5Gޕjh(ʻN:dj(|&cYJT6.V#.Y[z[+hr֩j54 ? *(ŵFt֒˷aaslaeQr֔]DCWYk JņT5q2ߧiBL~1ʏ~=ZO˙s٣c4Lۃ{W;E/q6bƹi;r1j㟳$uV6L,[~gLiǙ~up|@m'UEr|!F{}O1g;rp{Fem5R]GP^Qx:$t>xyKVYx.yn}1wzE/S4pij%.kNjt^ғ?Bav2#UbWcۿ]F7murri3k"{6h=i.{_2/}fz6Jĉ;(5ZkHQ\&>_ǜ뚷2r3Tcu-zQmn`$O6rdpOsgMӌ}ki}HARc37XqԌ78^IppoMI ǽ|śT1=:t(g){JKwF@DfY>9cAsrԧR6"[|Wew)T=J-F*\K.AmգM;`WV*g-;ϗ oRRGB< r?gHJV)9]CnxQ]8#v5*~1jh[Z孢h*k6u*ߩim&dIpU3Ǹ_J?HƍeRNWI4ɭc]"ɵ|®~rF EGVٛ|`̰$YGc>z)$3;nUor?\S/Es9s"xpynrN<חBͅG͐;ZF ltW4y9]ƽYӒU~e,H・8Oo¸sr˙}qԺޛnH-Ȫ +wY>fG J2)IKХ{*n cʑԨ=܎Ҵ:t=7^4w7~`8 zW%j2K F7_?}N%NS(Tݗ{uG0"9Ɋ8sy{?ϵkr~e˛E;ĚX1xٶ2008y\ѩH{E& =*?/ʴ~tۺswiDLn&yعF^B$p:-hT҆XuЎ~g1\gv#H[VY\]keU?3Hc>mQGVߞ)Z)̻Kʓ׭c(X>RS[Mm5I +{a*+9zEBm=J֔-4Եrliss zz?rխR*<ߣ:jђRE㐀# 1מ9_[mӔn鞡aP*q KYksxƍD紮XDB ª~oEqh#*U󁏯5Omvafɖ%<6 R^7)skq5 ETfͷ[+^qLyNdnt*)ƞ5%2ƮA?ӄe&JN)ImnH+3u;}=%Mu_mJTc+Ta%ha!O,x#LV+xoù [ ,{f??kN_zߠG<X˨Mۗax#N`_,QˁO5O?/nEΔ\ QuQʕOZ>intSBz<νyFMSb)š^ՊzGwUl5IKwcg}_/~0zDՔc*ʣMlg_Z`V21zRZxvVR_"|ŇͅW:~{RNOh@wcw*\=4:;N7nn[]/Ewdm&7_JTn:q_S"]~caޝ8iЌiuhO>ͯcLEeQ9$N=I̪[BiӴj5\ 2ySpZg\V2.?̼'VUyj2{jҌܮjr%Ә*1N.WcC} /:Y06J sКb嶘ڃ}G?tW*Rc4qy6VN&eO.}-6Qjv;/fzƥjrW5kt-b%f#)7*VX;;U㈩NJͤL,6q8Ô{^ YT/}K(K]$Kh_:9vwgj ˚T*TknвG0vƮR浶G4pq!ԎoƟGEݴ9V883\fV(ۙкሧylZRHnGʻ14KB#7!nd>\3ñ(NЕbS"߯S^MkƷ4x1AnKϖJXz9KUʴ0j)Y[b]xʨԏ=LU=o3Q)9q_zʵXj*~BRu}kŔetaFosCfK*M./*TueTCʄgy|r)s~G5:xxɹ萦Itv-ⱗTek$>7\mP|H_LH{>B"<6=cR8ޚm&E吻*ق'y*rzyFRGyNF͗/xn/g*-cZM4ؙc~M0s6=h[he,iѼz89qUԔFzv%JğbjdܲyQnQGORJD{quuv+.~^>U7Z>h5oU[ZIo'$3Ojӌo*5A)?%9 ,$V*Xrv{2:]8K{B{ӱN[P2O<X)C:cIFA鱗S2fBY Ht}ֆ9V#<\)Eme^s3IǴO[/@Rg-mY%?& Ec:ҫ\#,2WݹF=%bț P'nI>*iJbiթwMnF+*ܤ|2:+_ʕ(Ǚivqo1W=ymNrWaZPQ:tKĚ--Sr4s3EI3hd;r>L==ֽJrVM(Qi;Kv AzV7Rv9R\.^5ocSx0eyڼ潨Ԕ Ϊx՛ٗkTCU+ֵOǙwSp:.뉶F'݇7vTp^;N-:K]NK~X\ }ig *xh$k۽?K6gm.2r}J{N>.[>>倫Oyi*:GNyl-z&3fr:>/ͪ_%՞ZC*UvT8q'TR\ޫsխᰮd;^y-q<9JFKݶ0~[.đdyp4Gfݗ1Ganoǃ~LiZgIIj,D-<ˍ{ElFAHU`3#\\kJQI[Uo3e=m'~~ )bHH+݁#{|JWKsgXjI若O9K[K Zs13~Fzd[Uۡx>!.kf_2𿉮%o 5ŝenGN3u)׺Tqedy[hwQذʕ~K{cy5M=ᎺuS_K~v(?tϴ%^dR7$ٱ61c]NW8WߩR-6&s YL5SiWNJv'ZJI=i+x-l&fFZ0sOVx{JiNWSB W3۲v/mKK7VKR,CʧpvqS N5Fn5S[rTqqrMi˧Wi]{&I5-$`ʆpHE^1ҺRR**nQ['_+_U(ԩJ 9=/;-UgVpb)d<8=kʯMS5N[._Þmi!v4p߼ dc{8259uއBnպ+KfqҥʜFѩMsojvVdo9V3vT)ӳ'}j)TfԔJԒ[(haiQ$H$,㟔4N**"4~2tMmaI-]9cs֯Qɨkv˫,GSq]tm--֩Cus|ʤS5 -/&5c.H-\M/Nƍc)䞭lb0$bihm)MTZ +d$EN_^ o&g]mzڻͷO׏s\ѕ?~?O' 1Vh~'CLSls.G'mJTuieMF*3ztw^Dv\֪R7sKv<\G=oOFډݷ\˸5yT_?:qM3ԗIVX,da=xx0anB7_y_˘Lzzq+wrӫ-|mQm9޼]yR=L-3Mn&O)eeld6G#ЏƸc1}S=oaR2]|GZ6U27Ͱ1:saT>U+j; 5n7VDcnbܧulS_I7~<x8MѽcOJ.sL+Fz͸ߙNhQfAՇʻ@݁RuRy8qnl[f]۷2Iǿ+F)7[Wu0t$ݻFilUÌ1_TSb趗7>N߱6]Hz 97ʵiwSڼ_=3OҚW5 @=sXʓN+^ѧ~3QmT7'wHyڞ^ү3c2gCOR"V8ެr3| ~u4#z×dm'aVU>(1ͻ|K+RiYx8*mFlև|J|MY卶<9,6"Top؊Ѵs𶙥xZ;Vao/p^0&XIIT愭m_S9@ռ wYd&[co;o,G#=_UgMIާӝ*:q]X;3ѼC3i7Wƞtl*:3 fQH$۶ʆ!]$14˙/@LygV/-MԧK-Wc-;JOϸ¦4;tg䨙tk-[ɴy*QM4ӷT\N.Crrk uU)gRTe Y-;קS}կix3>=7q!}]3)jvH7vepAhZm=}筁wc*r(p7]1ouK7!pdPOQ`ӇU{/4_STe̓׭Ce-6fgJ9j2{+*4Ԍ/v^v͝Ï[y'/oqdW9%#$c|ੁ,`O=S}o_! tż#IUQ px59J5ynu>Wit} 7sF,e1wr:q]=RmcZ1j*ꕝ/é֋igxn 7LmPKg OL0fI΢Z{k.{siF^*}tVϬ ?Hj@| R0x }󞸯14ܟVw8ϛ87C/Zƍ"=taKp;cuZU+LVSSѿeo2UǯX4ْL6~ebc>āŽyxғsi ͞+%J!x_?_ZKɳͣm9KV~yxeN~'-4-m Ŝ <˫g/?0'Ob*駥^g>:،oo^FmxWhkl+-U-F2˖zoq4riLFԏǟƱ/p5)ޏ]Oe:?,_-jʭp }yQX..I;y[']\0F:>}qߩS ͸ [?Ϊ5v)'E\)s<ӵaR/["0,g[*۝;}c~HJ-nIu$:2 ̪ǧ'޹'/9b3.}S~]˿8'*HFk$0ԆUavYdIr\ kXCu>xC,r`#𭔜jNQMQh|rz{r*pCm9a"Ljaoξzi AkR\D;Y 6>ӊ~g5h*<+j^DH럕X9?\ץ2GM/\ڕH Gc 2&leI8\_}([ge꒔)ꭦR.XKq*SIM˖9ɶ2wbyfYX|rԄl8ud2֋q5דȫalȨ+Si<.-#VF*RHܳ0b?/uSqm>Xm\/m|ZFKmrn[xa>zZ2G_֩IJ6+F&N|%EPFO~a*jZ}-`icv95}ކҔy.<'RB71P8 9P3~ְ8FS'khEOh2|Ē#j$kN/n&H$[%f@u mͷc$Ⳗ=Yp$s~&<[+*Eh󏛁^,$kEyFws][{ii&o Hy_*q{XU\*EO{9C17ReZaoUzQ1he|ȱdcÊ˚\0QLUw ƚUg+vqn֥JRoٕ.ee*/mXd5CiN&R2O͑bq9_grF0OžQUsM43u >\|Q,aV5$I4S>fHn9Q]Q*S'>9m6ռjJ!G*l8Tթ bgRWZc2y~^7+b*U58ݛƌgסv$28Ywz5gDPa 4r~`t8{VWœF~]DP3V624O:g׵Uu+E9i~#͒' z+n*-cJM)LnTArcRQpKjgG_ihƟ,Yن8t:=6뷏k˗qE?uNI~贳#DH0O'bϯ^\u5#M]e64 !ܥ$8휟b(՜aiR1N7-^C߻ \q0\qQjv"KӌQj͂XL~^$SUE3Ϝ#SX=|X)|8rRde+jO N%E xhuCs J1&nQJ!F/DdHInqӟʫ*T;J_ HS 5^ =ʴU9uf,yUrQO#ӗѾ?-ҹ`wC2|ڹҕOȒeU#|wIFܞzv浄c+pF̽QNXdO>_.xjdX 3[/!@dT}ڳ|ב.T X-p8'ך/~*5?vtrGcYQJ$]x$t;FQ-yRZ^H3{,L\s1S(DZj[~oZZ0/ƿvp8?NUͫ3R:j]"H툪gSMzIZYVKeոou` Z{frJ wJ #( A`zpA~Y9HgXm!FazJϖs"ova-p^ɷkOƛV^sb9TZI.S2\7m2_8穮l%Z5- 's m|t~5j;^Uex#g-ۉ2IsJ 2}W8X?jӖ5QDSwr]-Ǚl gOfBqLWEX4Me~kHg#ʻc|2q*e'JbSGX"=v*@l?NjaF<՜XHbDVVo&oyrpz+h:hVW}!iv3g-3?z{p^Nn$I ݺg}ֳJ/~ؙq C.ނMmr\qTR>mSԊO5߯nǛ{I͚/_ozc6+b-WEj+P܎瓐pGqQN^MTV485I,e2@-m(ةTT:/-浕!t,4*2=їٶژIJ4DD5 ֦zrQo\;!Kop ;HګOiN>:Q"[-6eeV0Y'>+xǛDgFF䮿"'\z)9QLW&eͱV.htRT{ksnlP9}iis-K姴Eڹ$|FJvy!1ۘ?Jr~j";,3d$SC*W2Fb|ŁmO@k9cÞ9? ZkcjyIhoF-zzw"{9Ğl;T;mmcjRN6SخR[[n)|l',8mL_ՓZl.V%j=yԽJQh$R^s6T*wO3oN#kX{H<)ämKqUU@RxdR:.<aAF,Ctt{b_*ןACeE_rՙѯ)Jԑ9deef~:ޱrv6R\37*ry<֑NVӕ&>fЗwY坨眎9QSZ#<ۧȯzbdr 2vAۜt9uH+*|Z[ve0"IJ<^+xJ<̊Z|V3g`!ġD7/l.:}+WTi%`-N[[l>f'i${sUQ[[Q<c*ȟŴ͸t#ԕۍbLJ]3yW5_m nsU>4y]s fz~Yr1xy]:٩o,q;~Us򯟡OIŨ?RI5I"k\F$ܼ/|ҧΜc4"^QӡjRYy>ϔh4iᇿG\-B_:4w"*y%oS F:ԃ{WT Ȫyݳp2ň\PVO#]lXwyqiѩ)gr.uTgy[oM`qkyr\k{LCa E$~>Sj+hi%7)Kϡo$vl8>?Uq\zV޶}h6~s~?t:k^lex<{5IWKTM1 nuFf`yes>᜺T~-JŘ aijsJqqR_Vw6P]yKٳ]Qǝ7RV~z5z8zR\;DpJI֦-+a}W=UUݣtͩ)֗-6By 7m$rl۷oN+ԫFiۺ*U#*ܑ؊}Umدua}I$6pq{|Dj|Y]oclMC;c\WkSGJ Ͳ1["ˌC :Ǡrz[$o$z؊kr줵{=mo&gх>9$vz*F?[MW+T)i7$V'R2"~ݲzTNT({u.T*-5m2[u!U/&]aTJI;붞KUg&]1M:=>XFY^ydmhʩ%C0j%VӲN{5GVrOv^{Vz6G.rB qy$&6e}y&U%+[譾KR{^VSMi-G{Bdz ?u;Z߻N{]4\۵Y?L~5Rydݕ^Y(* &)(ay-Yns,>wV8̍ƻY:qEcRIm|i:qHnSR6n٤] 5b1ҍG ~2nE+Z]NZԖbiZ-l6zs?ykJIWy!/ik;=w9MkfY1͸獘u'YT}<اMnuPk.0ʫOZ>]ʟT^si֋W8ێs}+UuF2Ft3uF2SMN3jGLJv~s֪.MdhRuF[`[TœNN={A39]w61c9}9wIIA*>\q~W?-hqXi|KW˷Hv4*p>M\y.g`kT> XB]kHS۰xJ-#<Qr(T/&ft8#5i͇שj+lľz Qh:Vpȯ%23Rr(cᗏ3nFU(Sr>iE{$o\+0)Cwߦ8^k~ƕcN|뚙ʟ-G4u.v['1o}?Rqe[ ;djghP|0n=A5YRj/^5Z5bEukR wn!ZSjFJ&zd9[>Q=()$SiKJ^Yy`&Wu*28ns s|֑8{чU.:.ʬ{Om+mu#<5oBzRJP5 fntZB-Zd׏eYF#냎quUuW ~K:&?#s7,Tr3ǩg)KrZ"i2IV:&QIZEk2r:m2;9cl G9ڱqHm[ԚtpU>5<띘ݍ=zz\diRWcgO$e ˙v .pH ޳.vqU#NQвdڋJFWdpp'g?jqʧʚIش̶%uhdf=.x ִ֧a,;RߡܳFK+Ƕ=+ݧ+G>ΊyP)URTB'mz>wvU2$6eיf#3ki''ea˕'wu'"ɷrHYm|ؾG6_QbkE{vD+eXsz.[$"Hm8m Y''[I1HMmݯʏnV.7+|YVϩңEwiYK$)fcB q\uw61m[{(9>2nX*ygJV}&aR*tN`jmf$gO'8:-E \ꩭtwCV7# mp882W9{4u#-¬K6fqɮF23oYJĭYNz?=*:hVV#fOdORVImm Q>U ;WOnRSMxXN]/m\,kNZS`Jԣ)zuEn` g#8ꌽM#Og؆a ^c4kk0>һ0%bǧC`,J9vWtqU=,{v#{qm0 ѱ 5I=o08:j:gWA_0zuLA-+uyl*pvmZQ[]~w g xF-4]nQN781Y+QJבVeb1=MO]Ҽ;*ZԹm[ּEV_",6u'=aG GFk]_VQnQo^2iO$dAќc-9)F*˱,e. %ۯi>O L5{;tP?N=\"Ϭ|:h.:Y.V[p܎N+Z3*+rߋ%Z[_S4y^E6|3.0gdd~uR>TzӃ(-,"a*9Ǹ-jRtȯbGR!լr#O!'n+T*VtrJU&vaiƼy1lO!c@ϕ:r)rũ;\ꌕ8{VAq3^sQURz_o?1a<|,_={Ռh5ZİGl(mmNq 9ǵ%F憩Xҧ)M-ؤvݵT߰{CbSQ|пm4k 0Rѳ' P@դ쵾ҔȚ-:䴷V9-$ȓn\<`G_JUj(j2ҊZ>ۨiUAӕh{]*F4ӔDpJ. $- G嗳JڣzYnJe1;xS]NZn:TM$-[Uꢹvly}tq,[y~k69ϯrϙ:rm )=oT\,-Nz< ~ΤuuyjsJVKMDk2o.W!9*aWO*q}P0o3y{cߏZHӎo\2ZͶ[dclݞONV8e* ){pMPU-قG3ldlu<}cXp)TXfYUi:njr+?g*OC $墨/mt?ϖnJz%ku&X϶_M#}z^j44"B˸2Or qXT1Uܷ$a(+Go*Ty [E$kh&<`?,ݛTJ X8Xi[͵^ZJ^"8]).kHsjz_~i-rEdIf$#tV$ qǥsTiJəJxӄj_șö2mśb9I@RWk4kӨڼ&[ICʞBsr+::VM%jrNjY3|3V8U-OJ.vi*m7퐺H7.Ƿz*vsR<N"HU-*"mG\aVtԻz/奇%h{w 3܃`sNs'4aFZhe-Щ=3Oe(IB뷑47=f?0pdjv*@{{?u(1dsG$9$( ,W*0njRUd߽K&m`j̫ScZRYQFMljHgy^U9~igrnqג~}qU=՟g۩X9" 6ov8r*]EiJ?zڌH,q#bo%8<|SpGO^u*sG|ܸv-\j dUR1-O^~YsGOjvhu`\ 3}}zErTNmcr^i"<{h4j>Ɠۏ3y aƊj8TfF=o>m~,r_ݕ7tqxǚ:XRRԚ\*(_Ls+8?{VR䄭-tۡaiӜ\b=B7̤vq湥[O"aӋ+kr85fR /niRʟ+݂hgf!ƤH^p:ڹFR)ѭRM(/~cc 7[S,=uB:zEuJ F{jT/zۘckJu:.]X 9+NNv&s2vSc.Uؚ{5 FW`ۚ^fqC*=mFoiw~L* /\1Csxzc))oy9vٕaWY1 ,q=v GNsgsU6b)# t~[ˈX&Ն v)Ƥ.juέY{я{og>Gn#i6q(iSQǕF(%āgcf/gNQq*/ulgZE E+&i :c}8N'NQ.yo,l6ѥZC;y?x tܛG^"ݑ#A"Pq"f35b a+6޿Z[sIayhiA.g6Ѿ?vK |&J>J_6l湒tq#+*県 yI +#*Nђ߿B섉ymg*~L%k֝JtIw%yf۟#9P*ݦJ w{H+?^ݳW*u*RI}MRgq^enW#N3 qXXTF-"H̊pdkTWQT*dܲkbBrI~V.ZDeima4$$ GZu>6.)LwH~=3"ަq5CJ {nX]~[_t+d3,ַ0eMֈ$ZoԏJnWP-Ŵ}BmΑ~y=N˙rӍwО+ 1F7ԑYT- T}DplU[Y:WhdŻ,&9A ;e*RXJRf*TP~cЎzT2SNϹh73ͼXERxcgN:z4کଗS>G֐vgst4V5Ϳl{<޵SU6iю䌻wm$VnX$_W(غd5{fhcd`n>pRv[8o+\DmH#y<16:qǚ4jԭ/gо\q[ Fi9_CsuRӰT"kz=?e34,f=~/i$uFoNܖ'siʶ@R(wyJI Y0vPd| }j9^qN%y-/Ѝɍ ԓ4QJv9T](U5tE:|Y|'$8Y>Y^/)G/[UTXRCC2c=3):ud8g(OݻM_"ByeAC<ZV}Ju>o 'n2zz e{zjvS)VC-+lGG}I*(ǣfDƖ) ˓EїTJ~"VIڹ-s>]bz8wF\+~"~yjvOvEJӝ&ʝ_h~u v(76ձS,\{,qUyZ'}.⵶ks7U!IUbpKk+ԋ߾G-KcmU n?Wu'Ҍue4Io)ӂ9#9Lק(~dF;ZSV/gKDO$p|ƀR=O<T%ٝ~1RӸEsgvmk1r9t%EI]!;zv*\ha1?6ӜusZE-Za-T. ჹ<~y/fo_ܽ]=d싟w}Ȣ]$3Q$W&Jn!@nMtKj4VWc7f#o'>g(|RTlz)k[ [?.6Sޘ(ԏ3Vyyn15̞WGk3c$sGsDbGwio$^o-b$wtQS2o/u߯Qqm;x8u~rY$wq:zsB.BJ2)-[ UzSQZ858zySh[f|$E+oU}jߡtᝠd`.=9ckG*FMF-Ƨk-#Ç͉$0wNim |ϻۆgR8vH=6))K{PR5$Jɷ}orՓYHhcYky:c9$=LWm7]4ہJQ˽ң2Ѽ*Pnhlӷ ry\w)um2n-nfq8Y>E-6~L>rkՕo4c9}FY *W{m9$\zrniR|#OIj]-<ֿhC&X{G'RVקO"):rKO/H#fy#Dccʑ}놤b9+TZ_ "FXmɍ}?Zt!ykrh W,nkv~byx漌f5}ث\0FMj yy`UFi8܊kѕ۩WN\wOS5$-+FXˌÿc.E9 }6gǎN{}.Ju`ֺeQj+&戆nfV#} XAr9c_7]vRQyQȻW WikY.kN}㬱,pvK7_N0iGOq25 |kҶs7ϊG(UlCs7Na)5i:q6F*'*DU{ڰkaiFg,iǞ.yyoLW'$iV(єwRHe0+Ω~kΦjGݪXGkXҎ"{oѩ6Ha=~֝9F9jT~ |7S+(yc4ʔԳ,er ֞ƣuJ+[CWj[HW~>;_$jOp|3ϧEH8z#(FwB [1Y~n^U+%-d{JܕW/*%fbrFRՎܯGaZ\_<%.RӠz4JNO~Ƚ+ķ`jo`RtRCRN0\437ˍ浔V4VƝ(k5{@XH~<h!N1׷SJ DC͸6 8h˞"5%]hS+J¤vbկ~g%aٴrIjS/G[ޠF|85*si9V,tK{_/F2r s^TsӚo=B^kk գ5^kxfx/wSǵrԻ{ӌU"in͵9~ pGS:8Mb9es/OJR-F*5%=^փ^u,xff0+SdʅWLeHȵϘ˂wrkqԗ,c-,k"7G:WCUEc!Wks*W#zg\/Qٝ8UoLXlv$v6c+IYY~MM†sc#bOY֔ћѣ&[Ch]$–g$mRs\VeIRn_o3OM;x%O.M ^?ɨs=siƊs}>?ii휌cncCFң.O֌h5W SݤkS*=h0Sso Wͺ]#Qwn9l09rJ$cY}|KQNu|WC + |@M^]HI1(!1^oeXGq*-=|س,-XቤYY[DoýOZ Y5  eV?)R8oP:nAم~sr&/+Vrt_cd᧵#k3#G>Ѳ!=?IFQFQOxJ1 `|Y״-5dM33D'<8ΖU#N*!s*)+:JԾ/Ѽ#i9#ctxA53_r4oJ-U$Vӏ~.ŌiqZ-.J+9;sH9㖵% Ń*|D$Z¯ |8}׀vTau Z\dnFxjMÕ=Woǻ>;*[;mW mGMəxrK`@LkT?L<R7Կhl.>-6r3wA`s+`sKzz]oxLdp/ОO½Q% ?Y2IB:Q#k/Y~e=$|}K%b w4R)PXv;[8#^j}V,—"{'W=ZIb$%[2ǹ d9 F^Hہ}u᱔$}kvsڕ9.YlEd_Vzܯ|Tw.#{]bC|]4Řry p#X~-ۛ_yz5)QTC)g? s*l^l5)oWNЁgSMzߣ+ Q(Vo}+yzҵ--үzǙ6 J듇#1TNKQN˻}^iGeөJ?y7}MRXEom ,@(PHWz1noz_*FEVN~y==k͚wI+̩tRkl}(?3+I䎤W:w7ԭ$3B1XÆrB#-~Q4e[yy+mc>)\Ow,Xv2ѳ$uuӧ(.r4ޚt̉0V(,!RN## +8x/8cQ|?ĘZ2qF}3=y±GKS576"?cIRvHB7qsGc֦efmň?l]L) H.Uds1ǭgKbFV卞l31O 0J?}9SӷNTeޖ<{^D:}RKvԤAfʶw<\0x3[WMVu)ҫSٹi/pĽgP\[˓PxڴIjnq2GukO^g/I{yoFSp$ o)өU7wM^<8ѝ>{2{:P.c8GPxcr95:Rz4NTM--6$eQ9=O=Oj%JkCb%nx薚QRb?6@K_/w?Z譆`쭦jU1RWz[cH;H5< qυR.Md CiknVoU1ij$[ʷ(9+FU$+ϸmaGqC7F葼 {Nk)UI{;hՓkbKlrziRq:h#]_2\c8<eRR;- ^*3JB˻tr 'b*TQb^fZ'FFBp+ϒi&ZUPxOWs 8ySEFq*Ö=qkU(6,{9F8=x$ZH֢- JܴKpplֳݣhⰭkdC&u>[:u)Ɲs{H(Ȫ$o'u2F4;[OxQOֹqTe|Tg[úZ.e[d䕉c xs(ʤZiSW}A+&[ c%ap[lxxE9Tϭ(O]7/[{Wv26vѴq2*vJXE]e>*(Q <\ <%yh ZEGhz\,5(W2>Os37}F5]]F޿ZVWWQH7t9ߕ^)gɦJ"yO V>Ɲ>~gttకMKuC{B]!bGy- +VWJj*CJ>C#R18r1Xtk]c3bziʻteEhT8qǷJxp=e+¹=[l.6<:ib%);3߄x-BWX IмZܵ F7|{8ey(oCJTSOgڴ}FhdgYpa[s3drL>+>JUCCˢk\ z8&lq F0z寇uIoE> <5Gf]z3]CSGnfmn0{{.YO8Fw_~m?^%wpʾalۨ pT:mDzpSj@kOr?`ںcR5u)9^1׹xiA䍡)1NU\u{tWfɢ[*1c9:M 1 R~g,D S+rVqAp'naǥeTԔZzlyσ_?S7at&<]BĚK#C4v6Jo9 m6|bpj賂}tڶݼUWui}kPCcۻա;4RghǴƯUbqZIg}5jڔ>>aUX9?#F+ޞYKR]DSl.w{|R}5ՅU6I3vޱungNJ^C6֒p7..ץO)FRiePK82n{۵ii<9=L~V #ucsʧ-MU0&/"[Q;G1Sr3ȩnTyu:)Ɵ3߉wq-ēZw*O˰yz )TT[z>}RoLb{8ֺ)kf֑wFLVS\4~DfG$<xtKF񨢵VkIilR6_9ri 68s{Eo,Ö %s .1cߧ+eʥ/gi^˹gJb~ee#O~qRE4^K3BG_QO4-^F3[R;_ӶZ4;R?+#玝qTJPҜƕXZ7cq$hYrd8:WӖDYK, 331 QRy{@D1g:S٬kBdL#Wysks=ǵEH)W io_U ev8=~)IԼHԨ84B$;!u_,F ޵kyai&8oxD(T}>[3ݜ A^1\ӝ/}[p[ŜN#WJEf"2܀s^&/,Zvtii %?+i+ 8JNGKwQrҕugjNg_Z,Xl*3x<~5xa,:oh8˞GxeWkFTfO(X(~-+*FXn(^[Rh_,ďq^)+}jZ}}j;=z1K0RE۩VK%nGJS95)jOl)ǖ tactEJ{ۿMʒOiHG(?zL{Τ3*Kb ִU%.jUVqLu,E, 3]mYJ6Ռ㔼xb8F5`ҕiErBO8aʝ[_"\,7-Z*Q9k"}5!dr>[$1kY$sN8$18֊өem6՝j7p3޸o騸=mz=԰$ispxۚR4׻8jSC: 8b%vqSZv0N5/FΗaBA 3!4zsҴ.TTR}M%[`r[=&uMToOY&&]rY_CS*rJ[8>f֙ 6#2 ֱwsLG-O%iA"*UW^hN8p)t]8Էpz'TvUxtcfkg4~avg<:~Q)GGtNEpP0cR?8 fW,=?[v5kE(;'Lʐ>otH> e;h̸]NIJZMsƴ|ݍ|频 1 'eosow7{JkI@ۙ@('\h(ȣ©%.kU t՜U%SJą.cefUTg{)hʚ6Amh70ˮ@cٝ8=wc?w{}iJ*ԦW]Q efX׎I98aRSg ʫ#ɍͷ 8roKTyKQ{_"HbYO| -l>f&Gg]Ѯ&pVq\iI+[#}ʪZFVʧa׏YU)q9JzK.ܤH76sz~N-nXǗ+ܥ#;ܹNva9JRSۢE[ˠ$FV@˖v翯n>ΥE9mƾ"P^w;ư[YTիK_qNTKG ,\+(@qkNzsklޤmxVqYmsP*'ܴsBya*G=ǨhʤZrkөz([Q{Edx⦜tj' ,:WOV>-Lo~Qqn֦O :ZKn9zQRZ1KQ8-$,ʌFn7'8TyRxraKzE @2X;.:Oi-w`Z4\ek dˆN^ޤcij51|OknVB7C7FR͐?jTVxBQ{v^X'; ~^Py +p}-%Ux<*2){eί:xy~$',Jbv1֕(tSo9Y>#Y6,7}g).Ur֕|0BdlYgFU{g*8 g6 ԔlGz,G;I3#ڴi64jVrY9Zظ{|Zi ż̯ f8GWFl({}[1{iv>n1$@VܪfLJlܮeqmE'xFK6\FБЊˢ&wӷR6es$ EcjI[Rp40H:w>kZRorkVz.w#Iu_։pR6YY6mUvqҫITiI.DɈ ګU'|VH9y;ަZ9<BF3۷\s/SW7R[A8N6I&j˙-_VЂCKq89vԄ{Jqlyl{SNNIJtz\ԭ}$fz[G^‚K3\O Xd1RN1LdKXՐp C7^ps۾+jVGӭnTFnю}"yaw;+HFRŧC$^][Ĉ|6nۃw^8F2JCod瓺'HfKBexM^dkNQk{{.o_lF$W}zWg'5Ne)ӌddw27eNy=hQkn:h+(^͹Ek;jc/v+R0JKԆ).c@6%BX8`}Hh/%߳_ e%#W$fª{{5%6)-C}Ycec2zڤ$tvaЧMVr宻2no{,h~~f=*: {U"ť,*W-oiSȑuo/ ̌}O EiT9cKNtq$I-oF5 ԃ7B*RhWhfDYwRpy:74]I]p}D\b' rO'Z>FJ~þԼ@YX/ˎ+Of/}wJϽ2otaݲAS sQg$Ռ˷Y?6~iSqiNUKO#>񮝣ϩS~d)JU} T+2Å8ƥhed?hfUwj8N)F8uZsEe0WLeNeO0FI;nd paNR%oCt%}7&-@#cF8QdU(ݯ&LzxZ8'F>9[+!OZƃ3| 9x*Z֫:pE+?[[<}FۉxNP9]TCZSF1jo{՜i=7+[i%X6N#ʜ|<f*{juk;kmX{uN em|y*dj*N@\zg>jJgF(ū_eտ/٭";fAU<9 q\I)ҕJ\V GQ5L:?0fnø#:(d{=zt4w1),+ykk#n.\672 F@9#ǰ2[{kѳ%h.]r>CAs۽r]ft],] M52yq?s .DDƚsNwTVˍ.c~KԣRUE3 I-)St$J*1Z][Žc}˃ן\zֻ-vEbT^nm>mqs(ro{[}իYE,_vG$ߥz\Ѯ^OsU^YFBC+q1y--ܸRv]U G*~1_ͷgnrE;,πG5.jiͣ2rڃ>\PF67FdPB=uJ8zx~i^ϭsJ ~FŜ7X\x;>feal5j:I{9OQp0狀x;UI-,y,O>ނ#R9YGPNO֤eSjuP@>ilєjQUbmg)Ug)t;kaSM]Ȣkw`GUR⣈rVƆ<.g+chwN5vu*u$K[H_&vnx\j*^U4X/-#0G>{l-Ud޽-OSi~[߷2<|HmuW لI[BC$q1ÚrtaajYwu4'ۤL;yVk yYo *qoiSKo .xQ*|­JuekOHknc J;p:1N)%vo ֲlOonNT {qU&^28JG+{BDS|Щ^SRZ//XZT}MܯVэVNBYeNx#=;$7z]n[b--k$._n@4Re)$өˇ)r'ʞ opv&l+LX=x޺-$TRcMFQTq7 q,MCWs`kΤ*iiq'*%jxٳw*zWͪ8Ԋ{8F3E$\Fx+˕Ys9C&Qө7s*塒Վtܻm rA'#X9JW~=n_o{9crgnʃѱ=kݻǙT{~?xxddA|\|RZG_]: i!=2( [ >Y{#nLȿ+I9}v2{4i׫iEd6@hi4[;p9cס݈49_t!8RKH1}ZbxҊi:Ta~fbqb RtKS<ݍ;rHO\p{p:wsJESJ8>ɞ<ֵ?xI_&K9.'tڿ9ͫTVV3z:U)7v{cebUeÙbszu^a/h< X8Ԧu3vP\߼HN8NhH~v4tM-k'-D@'n~bo5\MPog*D;wyǙrsϛVwJnL*Jzv8Ϭ}Lm̞l2'̪qq=&^9sGG6s&KKQu 9n C`H'~ͰO-KB8uI;{[+5wm6Z-}"Og-SjOr_6!s9q)ѓ+P.bx7\@׭n HK=z⽥d#.: .* ,_lw?);Wc't*1+[wZFIWsTnIQ*sR:cJ\;xh|āpڜla[V 𥥹iZ2zA|#2VL+b5It9!udWJvv>9|W*^;2yrM9緭s*rsۡ]Fܯ)J>a*|^Jl(|<~tng:^aR2} r{F# ێO[޹.V:皗G${X*1@V29rsF){lX͊TSqU">.y9bUHKjl(4s+U9E/NF z{KRyf=q膘]1F?2ӟ5旻}|T؞F'p]ܷs28ά*Iu{r*_juOHhuU/.1R%`F}:g5jR_ԌuH374o&1crʭBI% -N}.,Z}M#/iK޷5`iFVEpjjT yTO~>kȴlĀygk2g5N}RN1/mD$q*y?i#t՝*XeN< '{=H$n6cgLУZ**$HcyVِxg_SlұiVݻ]gؑ%D alea㞝9r 2p?|ư=ӻ01,v8ˁ?jCKv9#N7~DxD'YF"Ss׿_jԋ.U_2VO]|tjFc,C*C]Q[ԚFz_?AAeCp+۶b12[kO]IO&V[u_ݿc0=֟w}ƙrǁ==>F1)MNu2͜m,_T'Mc&*ISuU  pZgL,lбt=>jjQVjj&:VIxmXN̛cڪNO~N8WnBݟ(ٔ7̼`A:z֞0n*S}_MuByz _~݅RTn8It1&hKs#I! `c#~9^$#r~UZC!ʻ=Ϲ]~mM0KҚ}43`ʸ'eۜ/'ڷms."$k/͒M8֕H9NXW BHoS8nR?MIHkbʧk+H0*<_k&$llkgSк xC@k"~%_rTIGuhb[[mQ"h;I"x^h.w+uɿe[\qǷl҅i.mhK@ Ʌ$|Üzv# Tҩ+/y,gh՛lYsH?,ma}ch[ejZ@LJa[={UF2* V)^jp<[Dm%9=qҹJW#\9q -~M01f?u?qW ӓ'k}{rn.k?i5#^NSѕJ$esETʤyWVv]JMtW0n*dN~ OޏOɋ (+46+:Jű.ENofDU#$VVY[oьi[Eq7imx~\*cB*iө*>5ywQmff\nG^}yXu74N\hPR;q^:~)=ZUm#"\Uc~3짅͹刌[[-}L{V\y7޻'F5=*%EZ[nwdx涧>+~!ʋrFm:YF=?ɮtenh֝OiQd˅URODž^_[-AagF/\j&k@ Dhj[`x&رkcYe>ѵY}РAy=}U%N[LK<ۥ׫fUn2럧ڦ*29<]mk]EN8\R5=;.*Ք- ay[n^5T_"7f:`mJTQq/ 2c$q˙;0r8=Zt﬋ԏս7gb\ 3WkNPvoBcV*XZnd[8ۻ QRdf5DkhW[ansO8A*V%tktn_[e[`fFvT=YETPMJw\ +AaJ.KBFebkOLi%'Hʝ[KM"X ,dI9'fZ5SqJ9Œc&~̊wA߾q\$de«%u44h\we/{ruv]@Q Tc%>_ORUFy1F}kxlhȬN<.*YArky!k7G U[FQ~M V$խ;ک;zgP*|:%9ʪ#Fxֹy\d87H丌+$*EYیl}j*Jlʣ 5q{RƟZVz{W5Jj/cao̕F@vm۱v-dV>cmYxܧ*s=ӡymWMm͇pIP,ms.O|qcJsF(Qo?"^Dhn6Ȁ8ǡiʟ4Xx1Vܱcq?$m>LVxW9J=mWp7k[wf4]f^22G+ б_:+ 6 W~v9ه*wDFXwNZeIm{o,v(9=8jOގG quM- '52yͶ|Q ˹Yx=z{UFWMV<pF@7q>W Z>.QfZH*54O+(1@4e5XՕemoCu -:W=R|T\,}o-|G** p>+I˚ϧTcU5uPFIR ! YR^#N֎+qxY6MBq؁WFy%:Qf a*\~kvh9Ku(YZBTmQyJRgV4~9-dO1WjnTgkSNVT9f+dv9TcKLEL\ӏnݺ}i:2>zdW5ISѵ;:okH|3 4rn3 DCw+mn'YUG{(TWmRto2䓓ӓYJ #N*5~f!\1 nt'cY{YUM744 ~8HOgI~#uoc:篧jK:=Tiͷ[x⛳6^B9'oNs%yYLxVRWtcGL):Fڬvȋ0=5عYХQǗ1n^\:$c翽Z勴qT} ] 1dV:9bҒ[ԭ,T)m?v)&JiĠJ"1i+>vL}*$sw`]~ٗRqE<a#ߔ[m=hƵ5b񯐱FIU3ނNW!|nr) Hrr55#>$trzh8HyF2Wr1SkKQ_dE2χRw:)ݩ9yWw #|+ry>µ9hJ:wk2o~'i3 zC[JQ涩wΝ>hrb=CLo|0FN;gߵm/gUm.zZ){8dQ/\}-ǧnfW{b33C4lZ&v J~8j>яjsKI %DπXd 5hz_Z:+٤nm[D Kk$AU){ݿ֩.tb>v>~NƐ`+g "֭s]=rJ|G^o.OIcVy'Ql3)SeeY\ԑZEsrNZni3$u4TF9bG:VX4cYʞ'#jxo6c-O#i>`s3ۯӊ mm{unQl~ ?7۷p%{G˛72SMe6:izח[RZ#2]緵ffYN3Ƿ*ENq4cFڂu:˅o͎WK4޷>+Z7Ч,6eWju#Tyh.diKV-C|OOڹ~ EKN+ߩY^-3YTߙZl5U(;+Q8v}13bri=YYX8j^ͭΪG>쨦ߜ`z4Oֹ^qEI"ݵێ:nIG1'$w6,cs֊,κ4ybuBt]8ϭqW[>3]kB>YJr9(Хwoy4Wܷ<J*7d~ʔFm1k(U9@6XsVƢre*|-5dio%^C2Fz0Oֻ)2+#'Ur`i[$`m`F9}kwW"ЌEJzkStFWecg*tv={WU:7~u9KG˱~2EVcX3^YDUԷkkZ?7}3Ome!(Xk<8_AIs1Zcd8C[+d8E?:Zl>Qtk:e{jӪ#NK HѮgd=hXloFPU%V^#uTwtfAM2xO_U2RNIJ]FtfQWr  ~XH=yU_k/|oI s7㹆E NP`  xA+|m_wĶ[ӖC~G.\H8vrv\Ԏ-xKS+H7ayec.(ٴ&X!#ў%G9gR˾ާӌ)T :&71wm~3[ƒik11V\c`F@ǷK/8?dk}y߃SkNŋL8 3:85x,1z5#Q]y`O*xTK7ëFو=Np{h 3N ӕ*pQf~; &k;dVnrsӧlgӥcZ)q4Y ?5ak$O@Gjæ}+Io/u:=I`}Wl<}1unɾR9-)οI,vɖ\#1Y9J<yIEIFZ=$~?k5_`SIkHV6m£!A#4֕+NRs ԥO^ޟ5yes̭VzU7oFW,A=~j,DxtҎvgTĺDŽdּyd9.U{ği߇sqRKejXrvO㌀z jYQR?R)ʥ;)yo=̽cSԼ/KpoG9ߊ婊׭7e{.)WRhŹ޲0o2 s@&P%6G+Y=udP$.r2s\uTT]N n# =]޺_qӫQ=~Vx5{nsemhms+"888*{8dݚ[huPEIkzh'4[&?\Hn^O'k ?jh^x[Ko0ִzaV9feQ RXx89%7oR +99rݫ5kVf5>isZ$@6XY6!ݷr}A=GJTr^S-[M.>UMim|EePߐ]}8TӖ"5#+$y'[}֓=ί M$?J+bhԫ7Bxe4:_C6ܔ$廑Fk *j8t)ƥl;XY&EĚ'vh)B` s__AƆw8vW]4+Q}M?NG摛31]t#3\/npZybׯe^.C.+g6ܽnsQ[xF]5C|oy|nC{sʆ*IZIwl:J6%{P\jln&XچeS^>NrK).^~_WXXFȁcpSҺ)'c sJ .=GWH FZI)KD8YS>??:-On7]=11*۝|F7NWwZFdլJ*T).ܣ}0G:ֶZtkTRUuZ\}if ۼʪ:d׌Хra9+(6CcHֵ&],9*S9b+F.*Qq$~j/bBE|~\dZg˶ t5{/ïkxmcjbದ\ tqd~MRS)r̒Ju{,x{úOsqou) Ƨ8#'۟rꕧh-:80Z˖.]Zu?E5yja, I<ș2BLEl; }l\UFnnڵ>Y[KYZInᰛ@!;Ó׮OZj8zjU{Ob%,5zqK3R |FGlrG)Jaz8SOn.dUּ֬w,D8i-~e"xQ奆rսHK$g^ Me,j[+OtgwQaMsW)Gw=l=XFM';{V cpn^Pou(#RRl}k0fh٭kwk,>t۳ <(:iWfha3Wd~&{f鹿gJuv3y7DX-sHWڽj9kn~FХ]?z'xV= ZlIp̯~9V ($t`yswt}Asw}xzʝX>nLGSc']Tfg Ez2%+:RX>`B 퓁sZ>=۷C F"_{|0TE6W †Jnrz_.d˹>fw985TSњ+RXmtV?1xv`܏OrGR5*4d`16BjW2I:,241s Fy<֑|TZ䶆$ǚywcOϖ/-gȆgXUVcnDtW3ա݌?ypzׄeNb:Xf g|q^ђL攡GYKuጦU \ x?צxI<Τ'Ѹ؄e "zd~1]L\1HmfFdoFuUt)Th2Ak'.%<?J\59r qOF}\"D{߽z2~ZUlԆ+FZqqD#JTips'18j0ӧin!ug?>m3X\Lt(W{[Y$E/1A8>4_^O VXU\dcGMu*>}690\qxjԔ}D (ȻY`J\}H^,Y['⯒\ӻk6$'a Pofi*k٨ԉ"!kޝKޱT%QE P(Ip2>+u= )IK)ɸ46gcTO$Ҫ%o{_Ӛ"SKzXIM\px'i|sJTh9WIs*y%-"r8q8JXzv}64Q{=M\Fwo~pӨ(~ƒzOㆾ[9 2|/|LMY>YVrkԣp\|dMNXh3ZFm:$zFhe>`w_jR<:ۨ|/)7ڋG>qۮz[:qWzQ\[Y`/=OwrG} ;A PycJR}omNmd_0݆]zA\kV1b3ckOWf@7͂1۱F<':oIzjHPWrjrNӕ_: 2ĖܿSxJܒӧB-JcRxRK|M9 }.YR~ŷ?E\SuՊHس#>eQ}yA֡Ahh[Ub`D+I:li[c@]oNk:# mtpX v#myӎ>V4Zi~W<ګm۴"23eZ&lbFnwwӽs}E^Rt!ZC_&rHbOJ2vMEaCFC#,[S3cA}㾻M403 +y!s댜-$?Ƌ[%^p[nF=5.VcG;3jфЫrh]KS\*I4-jS擂;w8krMh,ͧvHcړRa*fN>@λ捰6nHuK*N۷JoYkqY@$p0Nz4*T~jr~ІhlW3=4Mhh֕,>rm_4 ~^20sߓNhq~~,04"c#gpq$xǽ%ODs[^rvGoHm*ҌSF#R!ƅQ[>ҡT3 a;+ߘC5#V!mO[4hΥG+%Vۘ5NRqg\TH˜_J^_Z|8MB.DG#8#oʮ T~a%eiVXoyN՟%ESCaVR_>~UGL z8aG hէ7dlG߈N0˞JM|lۖQKTifA#n mSCt\gQNBCj4zBx֦IMMV_ E_ݩ->2W\o$ʐF}8T1C21V멟5ju=Py& +Fj̮8b*VTa(רխ̚%o͑OZǚ6,=*Ugk<؋t9sihLeJFܝWEsOe[v;ISn:&y_2tVXp3[GJ*N2vJϧn5$bhׅcqߎjb%T\vзf-OӜvYFҨסv |"<*ǗMR1hpa q**,+ӧSrWC1.XgYSE[oGW,k;kh*O=w*qs\B{EoD!ݖEx;VS_D:Zϩ4hMG1I #'\1snbSm#`8ǵt.kjc%m`eU*ͩjSr{m{u\Gk0 rxִQʍ4Wkv]yqNAATo}nXyj,͂Ywsֺ l̔TbVI|fQ8#׎qVѕ:*NI%)ɧ4"Iۻcɜ˯kifC, UӓkHRc-e;,QI|8'U1w{JRv3gҧMjmϔNGcW)>XQok"v3ϗrsϵm§RqMsRIAY\܊xj֎Ʃ:Li {c,nZnS-.v3uDmX368MW4_ORƤF0MVUTQPF*ة{JZڣ])gj#N>͕F2f} %v{i*Mҵ7ku-qs9G5Ts>[Q-^6 . ⒌ocsԩסV}F)ݢVY׾|t?Griɧ~L^A6Ӆ~S;u M7=J^:|:ZlަuF1fs>jΟRٶHv8:Rve&K*4= 4-I٧ȧ}}FzQFW:j<>nbOyjb~bj+sr4RJ,a{{QcFӎ'm~)g\LʲyHzXY*quӣoIBk5mu,/$ypȸ(g'5*ԨoK'tM/ur6c$WIʭ7@rFךn^ktߡڣOB:M[oQxxi#<#ߡ,W,z߭!kO6]/ByO'_,G_SJ!Z4燚Z]G.{ٛPȭʜ1q铎մSRmnzUptr<.Z;^U鷌5+SSvr(J^κ4VKuǷLcl*5]/RXƊ;bKݩ?y^f ,?4egukuCִqli58 (x0Y׏4dZop׹q)'9nA\yy7&G٘Z2 1>+*45q\jə:Dnw{{JQnTVѺKue},S`g#nqQܪS]S m~fK7AWN1DڹJ>Vz؊0=7Iti(vgW{osW9@Ty^ɧΏHTkC50lyynsG.K#H$J|+)̂XalOӞޕ<ЕW$|*Jv: d);a$=T9eV0cN!wSzii4nX,vJʤm(~F5VZ/u@4 v^*X9wЬ%:m_ݿ:IA1ǣ6}sF1MFTҗP9E- [-B۾UPP9֤=ؽnU[\ʶR98f$);$p:TZP7:JK_ⴱ]3*])i ~9IԐ3q)ޖ.#IsٶО6:)d`HŜye;L*T*̯&45<]S¹ۖ:OP\60|[)-[?y*SKFfV;M3M$wϟsaS(+ 4VIH7f{5b9d{|yr*2LJAU?R6X-{u.[iӼ.[ mNGnت9r-z/#J Hb}a+232w)dI#J20ҭg/kqp4LdSpz{S/kC+l#uѷlV2^%Z5-nY_dUWJQp5?[fycwpr3ۓv2ZJr儕[R JܨB3މޤQ (־DZxg~߃D! yXڤi֫{IͲ;eU[h ^9=yhRI%_a-<$$+S掛y-Z&!avLveaq]Tt7ͯW m|$8UϿylLtʛi^䴾ũ ꌦFeU 8#oh*MmzrHm0#s9׫:q(֋5>u-]qX@vuZ5FC5ke7_e$a~b>8J# /{:|7.hq#=j]rrQ㧢(GtQz _QeS *Ftz'kJ稚wVg7| ;fx+O{k)GQyQW {rѨ нkl-gdgaj{u%e]||9O.k>sF mÐA0LFRirm޺[S,F PKwEՖmg4kՈIwryqھ/{W$qYӯ't{Fܙ~γ3V\'z1Ԋ1RJ-o87v џv#Qrj4e?:+;' 79Ruj]l[_7BN{qrTR6+j3]Dw,GlsVtrVO;3MP9ݑ>y}kU%kG9o.ռ7o"_W~vxN ѩL4s׍a ,!w:Ag %u3 zj7S^X!du?[V*t^昌La :> H0rqbҩY՟=֥cյfA&[PxI9#?.=zxU|:Z8/롡zE$dWY-g?>?NLUome+b%Y^W*ծ.cR>f;PN2槎PdΊҟ/~mޥ}-Y\JͶ=/.4Q%jSOlSqRHݭK_sƗ4o{_oȎQ;!pY]`S+"UEymjL? R6v*mmzVsjo-Z5RհGYN#W9Oޓr=B6[HYXUqz8.I9)]>z`i:ީJڦM:+}J)ke&HuH+)JRvh圫JNv1$Ddm#.rҰCRr哴Bxe-$hXgYJet4]9&B;YS*Ǩ=>(ӕGk~eJI4L$[vnʎ(Gs[wLF=$~u°qWd`$4aK+`~=k?c(ZI'IE5Xش+prcۥmb[+N"KdZSuԗ5*Ѩ"[Xbˍ5Ysq-ĬWm1* 0'h9z./}ʫg=GD+Gnte]h2@?vAtF5)E4Ȯr֡~]cch5&Sy>ckXBv=(^Vb^hIjLRkus&QJ&W4}mCwjYvnxYJc[YSjUϳ#6ffeVQt9tX}Ui~M1NL |*1Ӷ+cO/NyZQRȎI,pP0y^p*Tc+XsS^k'~ĆfϖI&g;9O\sۿJ1drkIaoY]Yr5!{2P>AJO)EMBu ,],Knȿt{‰8XIBqm4\`[3L%RnKaHA,AV0OP1hU%vG;2b=cUKV֛V-\^cW?¹葧j%rI%O>v'sfZ%+I3>$6J2u$ӗȜWM+}Nq +`a݃XՌ#R۹Ʉ\]z^M$kwu=Q-ITN?wj˫{~unUI>},e(G:;n3"dNkFQVi5'SrM<~\k82܌}UJ׍ٿݹRJ[]S.G(49呗rBk+&uQN2ZVO%ӀdFA烏jq޿KFw% K^YҦjqZ¨y- d|ɆeIONW9^/Z R0e߰`M 9xVt§5ڿON|mg%;xlk-FW$s{c7*rQƝ\DI{l%vk#r?N=ʏ&[ʄX` w==R?tF07'؎FkxYI'#׾0z{UJ\fsTR]4VY~yf(Lc5sYQoz]!և [>[ߗzUEisSj-.V+%Ife%+=Gr;T%\4}jhӓMnIw I4rϚf09$]V4JwD nɏȹۗfa'g䜟ɓ'Z9Yq#)qkʌÁ?N)Rnݬ'Jd9Ǘs8UT3ZuU="v]IkYwe+֗rR?D430>Q ?ɮ5B+S*4Is]c2Hχf w#${~aS}(n6e(@i$VrO;eMӣIKF]Gqd }ޥ{c/RӋI\tVlH~Ub3>淌&Q:tw忭{ .\?xJiتqv{Hou]~_bO<뢍RקSso nc2A jҌ3~k6ˆGU8T`឵8ԖN2\yKlB÷c:D~gn Vz+j5Lv+IўutZ1T[y! c>SOEԊmJ{uڍr{nssUj;=[(=<~U?!{)Z]~ӝfEYBTl(#NOsi+bkO2H$n.r5gttR-*8%ya۸ Q-vEh<554iӌvQF>3M'^A+K܌19SNyƢv7A"?wE(*AU)k'N>G}u%]]MݪpOҬi7;s4r2T ;B=w]I4,ǭtVF4S 'mR9e*|tjRᩈZ-13.7V#[{WI졶{ȋVݜs\i&ieQԫ+vQ or>驿-7+͇wvBՑcR8Y@jԞQi^%\ȒI$aSm$۾}jrRש^cU;]n ZKY3hԣZ_e"'ogIEK@*n~T罂U#{Cj]L,n{U9GȌʴЬʍߌ^Ǖ6#96㷗aT + JIuPJq+j( ]fdݻ{pkB]JJQEs1xU$hJR6.96gӿjy!&eoA)ϗ#fP>IRHS^=K&HZXR%#eq;rRI߿BɷAݍ''J+mzU9E=,Y9Y]hޣT۝Xju!-Ynƒo57HvŻ}zuiGw/(mմMXc]2ݍZayhLn4ܞߍ*re%|Io|աP~lf8 c[ѭOgR̖i1o d~=*ǖT1WzQa]M$2VTykFkn,jsp( ra)FTew5 bTu#3ci:Rhz'8=Uc(VOs8Y(˶/t|I]/ym[y2*n1֧9i{JнH[|nnrqsY_:TKh+a;Da|VaĂ{te/{c)(F]TfFe\Ak~YtHJ6,Gh¬HU)FOc8XIY pY8NRcun@jRv3mjrac-Ѱ#<]=GOݍE 2YwÕ'EsϗT#SE[TʨK;Ȭ5U~)+Si|/¤uW3f:K ^Z;AB;٬*F-+/S&Om[S K~g}+nRS&c:CjЯ(W$ܗC5)jZ+ms*ki<沓jWi_jN *ѓN)ɶm<ȒLn\_{>Y(&q*+cCW/US}Oh7R Xo#VL$>VzSF2R"Dk+)cĆ9<;-NnT4g9ƕGI?vE ڏ.\H0gڎZҍ~0w@Frp0'IJ1|wؗZRjב`-ܲ`N|OwiכeZiær퉎_sYUkݎ W(.ey̿.~b23x#.4i)%'A F { unsy=ڸQ(Zv o14e)庅eXdi$ʻǸoJLJ*6n"oTf,lO<)B*N̔~aGƯ~KZ5eأn՛NKAեNMgj]cXAf*y8{Ӆ\^+hݓLcWij51Gp*qG}oNF/ŧm6{{cO.5UXASI6g_49yhY@.Y6{.1x&>՟u4W}7s[Qݱ8=sDZ/g5/r/Rz~_&ә!_=9qӁZT#KO3e:{'+y^K(o[| uU~ &28<:Km{]Le9Ӎ+fkBb=g%c 7\uQteE}{e 7Q>d5zϢI>[KHWm_$v8#ڢE/?=MeN[y foWcrx׿DiE)P)8ʢwadKbBwzgNf3XjrUSvH] 1=Zmo2sk4CkÎ?u:1/SROB-E7z 8^ul cͻƶoWY]M̥vX6NX z'բ*4kKdz2q= :4F9YF18{Osbq^ujOsy+r]LN|yLx[F/'>! ]vVY y]vMGê>{YhӊEWcm1otP#tǵwQ^N*SS,1i!݁1(򴓰Rz+ts4[|/Wu*5%iJV&}:{fs-s\NJ9M>[ƳV|;UsouF^g^ Ԕl@8muf/OzR孅[u%= '`VR74~^^DOP^Z.[G8fpM_{$*êt>6EKa R)?i'rԕIC\I[kh~e U:5)y=;zYuFh.w[RRGcWMr[K8yI.;5HVӄ*K,!;-bNrlLg\qѨy85 F{x?7qLDk{ʃBicN+Wq$a q4-;wW-JԭN& \yWvn*=j)kղy5Rj4ˑH]nce 7g)T5Y;R>UC9vsYJtjy>uM q̲Ƭ0gsV(*Wu#cJSש y~m.P[)oֲV] jN˗KRibYk%R{YKmvb q;(9ܥNdeGص'{- м'lU 巟SJ;sB vZœf^N,) J|%_gߺ֗Fg^J*ԍNUmOb}vv"g^5r4gG7ԧ VHȎFb;dtϮvV+B(s^HYOe@۴ddK}uGy{Q,SMm+}VMekqSQI"??iJq35=cԷm\eq?pNrqR}в9[T/[{IKUNmQ;?8O1w.ܕ98?Yʟ> R^$a}svӚkV VV;r{s QuFu,kit#VpXp@8LTJ1洂zq-F͜eM :ƚ{>iBM'ݶFsZ˚+MkxyGjH3p?:ed3匣fjHZ\'}*>w9*S-2cqVո_6 SM>Kc?DII(e(mvZKD>"Kvx\=zҸ(ӭ֦j*tKa̒h8Wd'ܬ֝+ {2T~lt]ч{EK F1^6ǧS_b50n(nmV2 usd'M#:r/oo5־'oM%⽽9YLW_,TkrW=qO-U,~{]߰# K t!|ͼpH:+ϱbeR~{K޺\]kfq8LJ *4'UoNA&x_Ev,8Y-|nq3k͔x攨Z~Gwt .kV 7~[(Ɯ+w௅Ok}cPmJM{YÞOe`yQSjchSw|CV̰JIY] >~_ >7eo3'"2HA >Wv+-JJ1eW9/u-<ŴL^YGq4jmpޥy8<JXЍȈ}]t*I5 ǩj4C $d: NXǟ*>y~L luLãijbѰoHSo#8M l4o{\O&K]_rD4ݵŴ"X2(0 'S C܊MF*^gifv(!OApFߙb1KFs)]WMhC $7|S4|\A%\ sc8>>eN$gn8#> 2|qh4[蠞=:ק(]]4+M??qҷ,8Qe۱ˏܭڼv>-FNkڲ{>3i IOӶHbH@ p=8mo5v<R}>mh.#3D F SЊX%it}5qqIm7O}|smCJr:u#+9AM(s>}F[^,&MV؀x7(4$b+dd1%~^ƏѣkQ{KZ/M9?ZӔcVKG%g^׷]G4ѭ̯`ܸ9{b>TQ(w] gdka;In[iYFq,x5+F۽U+G&Mozy0]Ʈ#%%C;fkVWj?MZhcoOf^Mhr>U l~Z.hSo/+|% 'ͯO/+O?n5;b 1ٵFc,sqʟ4ZuFNj;=R]{v12M_[OL'7$7H庨 xM^G_]jTpS SI/"Q׵)JV}fY-Z9MN9HDzW[ R#)_RLڍ͜4kbicCk+o,RlnⰩN1F#ߍrUQ4dMnSUSya}Dz*nEӰs3KnoN|"p9#sYJ4ɕ~]wd^|[7nw&*9!. C/+qu`* oK 7 t}Wt4V+5{]C&:jTUE6-WiEk[[r8D܃>YI4+ *knM8E͒'.:eh匵Ne{;ܰn- ۶ztNZ5Le s:u']>lL@ݴ8ޝkCScMsJwHću! ^\VB*d#`*cw_4v9'OnWxgLq]rṣCVKaȄ11 9RA#>^YjJɸǻ><}?N|U8Ӌ";tTZZ7}j6 y <6a' g_e?cN.^hRVOS)xCX㜍D܀x#=9B2/|Ҷ_>K<ѧJi|79=B)/?{mmBSuڭo.$+|.q AZ,긇-U9VG|Zwaku%f(~!`Y2$v J<ɵ}9h^z??,䳙֜qK8׏qm'Tx$Zt%T/ ʾZkeF\nm]rpdfߛ$`gWq~.J׽ ?,Xt\kK-LeN"Ȃv2zҖf-vnkXVZI"Bc{(Q,%R5%[^C,$F,Fac0@+tF#{j=GdM&gw5ǘflpZzȜ3ev^iΛA24m̘/Ps]Uc 47^ S̋M]GgUi<Ϻ1}jbj^ކXqzQ_~||Q΃F[+ Ƨg˸qPE}h΅h:VAXF+{k;K*G$cQPxffޖۻe:5t/>3ܾB#K6Ql ʇsˌd:qYtgkZ|;;_~ }˜kH޹8ٽ9*<%S -ەj:owpWfbO8'N~e<>QJn?O:Ɲ%֓q#[~6ϡbAZM{ROɘWɸE =f +y 3ǶˈMNQnk,豺WSԜsӢVRv2R۽Oދ2cu~Is~zשRNu;)ЭZVws𗋴۽Fx?r.X3r8{lJtu#NӎߡWßiͧ4.aF(\NsUSyZb1/Ҳ:rzg+*$mX(HxJ×$9$ERYU=z_Z2+T^fhp6wLw*euRJtH-Ta@I?z|6է54g%^5H$7͞yn*9cx Ot =ehbiMU F0+&=9%9;tdB=ʒHYvzc:IRWz62Apv5O2TS߸XE$GP9Q/{)EjBdV(=3Edw>ݱXrr!1UT$gLht)Xd/"K,a{=+{C\=M·o3"\R/31ZGAI ,NZFTiY.:jΪuktG&J 6tqɴZRo%m1!]VSM[:5xw 5khǛxVnO^Hϵ8Ҵu4ʵ }.ߛ5sISKկlVWx,~f#ъc)Q}>z":ejAVsӧ+.+呼gmnjFci^Rc jwܻ5ǘUi÷W<˕T򄖷b3ysds utgo9^Ul T@ǯ qg\iV$䮭 OǐE:|+QRMs,[܂xE^a֣yOPjs|ݿqQ$۵y%RZWm,Hݞ;֒#dKD"HsznFsҷW}?:vw]w/,6c+r$iƵK^E;ȳ]|Ǹ 4FV+^2gX8ZJMb=乖p儇 o޹c*hDm^^SQSzap+/a[Γ0w{w9Ihsb'|!ڄy+#oK8u~kݼM̋7 ^MJmoi >{[ް?I|w>o'xOQŬDz?3BlOMG9_]ZM87y -:vM7pX̸i60?< gV4!欖hF RQ$xABrXsWELU9K쳢:kؑ%2Ǻ6y6;V2FRZjI59HQ հӞ D +A5K^ w["Ƌ=E>sJIZ4_y.ͫ48zu,;oӝZѼՓY^J&2F}8]QgRrt= beFw-noFD\w\"8BPI?֨E.iIq`.nvՓ,7Nx*#IݚTQi[lYjrMʸh5Z#QK~*Zac{}y,Ucms.$cbzz4^eZ0x4t0ˆr91\4q+t8b)EE1o2{砮z%JEu$F݌J|xV5?_9zF>y;ۣUSCZK*ȠW`CgxbعUJކS)_=Uo|vSv;ҴO⹥ٮ]]I&B@TcYGM!'~)ݻ1IIZoGnfګ(or[z=rXtVuBGa=GQYJ2JOO5SIlFnrqĥyr?M0Dݯw\Em]ʛ_QE_ٮfwzϥu9ءea&F`{g*rMV5*F_#9$UX^Sr2a*#Z~f~~nz2[KcN7)\XQlqKnOG]?mj-:̯-~Z@+.1N[= rI;77QZQEhU}4E"|8nuR_BbeW= uu KgŽDq-8mo:qk&26|UB^*cR?k iTtv:[?ʫ{ttӍ<ݳsӬkmDD˪Ns?sGjg '%QϹcR4͌5%}f>\q!efK0v$28+jy9h'5MR4ª'>+x&- T}䶹mXn۱\:qZi齷J8QȒXccBdt4F;wZp::zFsOX׈5ӊ8~4FX{{f>cI!#l:a#St캾`wvѫ*A0r{G5j~?/z*j5L9$i=q9VK=NnYV߉o*or9UQ^^5" 5Գ(*tlO<˽rT,}TiQoHNZ32y|>ryV[W8*UjQYHcUrn1nk5)IFH@*X:xW+bDcZ\6hգwt6_ysZ2XT}:ӠŞI-/ 5 UTLt[Ɩw'KB흅[77!qԁRU+nqK{Vhڽ[7 0N@#n9UQiǑݢ%R_Ū<xWiO<Z:nJFUId 0<ȻTS>-.QDۑE'޻zՌi$[nKxmVE1c?J]:w7^DCjL%qW+.D`Ӧjm3/mW~^eoolq" Vݸ~5.gι*qݪ͌?R}ex&rΏ\xdCQX gONN2R5$y3l(J[V_vմfYmV Bc;W~#4tK}Ϥ}^]-džfK dI3$g<WOTr>̋HTzZyk+6py8=JUviRch~FƸVO^ Ee(sӿ[ة頒!feʿЊUb/gVROD[hey %ipzw$fI?{>]eo in4#0,^JDž\os1ww2%M^7!0ab kGs>i-SOne+aBd1Bҩ-L׳/gV2Hgц睿w$cq?CQ>;{|9Z6o-n.NGc뎂U[~v9הddBAoi&_1Yv?N<ڶ۶ɚg_<^r}}vsj)>YnW PV|IC7=HyeN\ Uhd )c{9=GѱFQY$fQ ߻76=N;B'R-˯͑}([if}nzRiC߯ȉ <8̨<`>J* F}I't/Rl;U$?3ceNJ/ԊTN,$'w%YBssT(ӭߟAHUcxB2_J<Ӎpo_5q{hR X=OF~AI%1$1txDb<\HSf/ua[X4)~PUv:=Lyy[2KHĩ7}9xik'uDS({jcȔcdд3Gqw`7mT}CTjO҅x?Ⱦ^Z Ԓ*V%?&hƬq 8p~hhS:xE8xZNi^N`ٮZ?wWs\=ZUbͫo9[#ZU+Yy6n68Kz]hϛ#tu1Ɣ{>Yxm4Ta66Ǘ<Z:^Ҝ*׵vMz=œ2f1s*Ҍ*(YQIKM3-ǖ̹e uvƧ"B}|Y7,գ*˜sQrөݾiU4!s2.[gOiFRViPB;V Gv챃$avkKW&iVӒqqVf$V ѝ̓2H𮚘vo3R1j*.ϫٕRDCJ.99 w {v[ɹI8Ԕ_.ԬߢɜeWGOz*r:|wsfv4yn0I>*qkKV1:k^hHՔE}sیc ;jS٪9$`Ok#Pv'ʺhԅDSIGZ ¥YUJRce\}Gj.TӨYK̝R}ʑ3/olץRRSю2.\Mq+V`~_iFCSu~[G-q@vp={Mv:uŕcz)ѶoQߘ/IxAY՗wV?w[[xԂȯp3ۖPGМuZ_v}^;^(4챰SaA9'98$F3%c){Zu7Oȭj Jɘi |`,Tb#=اu!24#+PL?2~FƝH.df݅{ܬg/iM%rhj6dFmU#\Y_OAtuv)۰Jcӎi(ܩVPI故|ȗ 9#S{xKuВIټ.NV=㞃5jyZiw5s4DwڧrN?qʵOg=Jɨ1E*Ku5F];u>el]i r6)}a{<&.zʋԳwbo۷>pzXƵJ2WS {CXqW:S]4wc(UYG55%JSJy6-wmlҹ*[IT&*t'"IڲYu:[Ni$ZEXk/lsԕ<3rE][mj'GCo}9>Ϋ[8\cT}opVa!?/ˌs5xʟ#<4PAFYӫSug$iԣQ]e^| `+zy^TORN{[r6'K6f]cH m'`zT59҇+z7BH%\y7LRqj蓆_qX+H7mF P g[gMĬ+>o>tJƨ ۱an'ŵ~=r5TNRw^EGo:TUm#gZ8G˖-J9*Fv'vkHӒ}sj5Noл ǟ̻ Fj/3Zʤe=cP.-qKe=W׶p}g(˙rԞߑvH.?y8j>xҭV-2k'DhǾ~#-[^1%e3J2qO&#F:Y+KR*w؁S)TX*Hidf=4S1"\]),@CV8ϽuB\qz.EV^]\i3R=Aw>"wԔUEm+vcY+Oɽ;t&8:j^rd3s lp?2~.YS;krvbtC,7u0zߏΜcdަJͻÜ۞kEOԙQs'nńhdfIveU}rqZ}^jRm1RZ;\зgX3ZLߗRMZteJM'{%V<0ǽk+]Xh^䩵aoyzW.ef{سET ͺO1k*|֓IM4Vn;Bu &Wnۿr>/[ (u#+\iLd/|a~*ԯg5fGw,B@8_| ǚ*"^S.Cqg\r R% (u]ث9Zʧ4t%Owǻ|ZѧxpAQ e]c#u#rKKW*X55i[ķY"n]kkYTuM~,GH6T/e=xч/Ͼ6& m|nem(E)9:i]%~LdO*Y@z+>_)$WX#-&zW-ZnqSkנCgrc_*WvZ)_^]hlHYʼMZ('_:-"67'9sYԵHl2kSVխ68\k2W^FTuiյtߗGs#lP[yA4Nl*V[u=ߕ%ܑ+Iy#$w?aS斥ΊuU7xu}-: NYRSn)X1=?Z2M9I6"cF8>TXH)g~sDcJNvge:qMw(nK kJۡ,kG+^($mp9һ!?wsX֧*Gй ò 퐆snյ7} z!ZK|G!s"dWuhyTẹ<_eoʲ32Jꏴ5.Xh,%O8Zꍶ4JzN'r2{mv*\/+fF[~>֑vF KGB~m̡3q]]]!Z%7Jg'Ǚ6ݕ#GW kBJN c?8\H6VrE|%c#j婟3.XRۙ-%;Öm9.taM.WhI`bۚVS*?nce*ʟB97Ad/$+.t<ӊ9[sS:2;^,eV ϖ˖sv55%eQo{O%đ7+7lO}Jt*NZC&aj;c U8ܽu mG-p'"FcDZIBݴ&O5;[vnAmx^zq1]*߷UV^XmY~m|PqX:T*|ܥ]TU_"K.$s2q?*ך/)[uSRRCsj\bUWG#S SQt y,[Eu9>Y9T G݄jfd%ch1+ gkU)I>]MQ֨R*>QY/.roX㡪++~&(ZiX 3qgɯ䌪VC'VY, UV}Ǵ)}r3WNSGҝ:)o:wd>e88"Jtj?O=<"hKIP 놢/q+Ϟ c3R6Yuazq;9SRoY<,}uO<pڲ3ѻǯ5[ v.VXekzzIMy23F|\]XgG8t̙cM|*JjyX+x-.Q?yi%;+r-7ZZl۵QϒcZ2d\N |̫oOI[u S)vI{: =U,KϹT{}r?}kZr9(ȩƭ:[xJ ^WoSU:刓nW^¬rVejsʛouԊq훖b. 2{}kIab{SF.]ų҆~m?&h:R iГtoOJ猥8$U5E7ʹ`Һfz7ZO2)?ЧyildU61olB]N2WlzUGrRVT\Va#;|ӶMQ֕wnTIR[^. 7wGOJaj~˖+ Nڻ2p/-a^Μ͜^{!-םU(g^+.sC}'mjSle*&YEDicUjƥfe(v\+Ï{hqSe- Mznw;֜9hS2Rk-ŶRApv2XʥHg=:|К䀬XV;Nk0L)#Kg6O7{nk_{Y&Yc*׵mѕ68ߺaTD8on\kpkS.гc#>az8RvMyVyYU7J^Nj4)2{{(չ刏5u֔b[KVZ? 6(T0ЏYʳq~X7Ͳ6SimlҕHQ%,ì2f70˟JTC*xhӇ=-kÏ6[{q\5=kaZGWWy'w/==h`Xx8-2fdqJ5Tt[;ђd,\nnykWj5%eXeF}޵C݋rŵ]mT#_#~9 ȻIW#yKލ+Ъ6F:MBNVIE{ίHU0ʃW85Q"zY}_&wVlu;9U#1jTz^kqntTE;s&ՆoqbXup6_|t⺣))Y2zY;vvO||meS9=ӟNnh]u:j{/cS5 {aȘMzt?OƣF\F^՚1-e!YX:ۮ+e'Vn1w4)IsKӶOq 噡m:_En$_qMEA=:G-F3a~^ӍJ#0'(y%Ny ?eZo7GOܤ5mFr2z.jjF.FU)/fji27cp=JKSޣ'O#GL).ݟ3 nr:ֲʥ+J*ninb껺+cס}b>B d,lcuܴ_ *WK_2^Q~X$6>Q6zFqO+{k(f l޺hjJ76Рh,{K;yG>ׅ(Ź>1*p+hX}^Tڱ PG${9 rsƍsT`%~DrcFzq޾j4k}SKzhq!̪dU@YYgdÎ^xՅ<wcNIQW6X5ipff;uA]#QT䧪KzS[yzMfi#HpX($czSIrkOvc4mh4Elqֹ%_U+J!>m%mod3R89ЕXk+t߸z0Z맡@z1ksc*8 2-%{{5S |kmg>11ە^X*E3;O }\5mf[fѣԡ8e;~sֲge7Fm`ruu4+|DM]jX᰻>Aס9NQx_CNvku#!g,2N';㖛nI[^B<-so h|vU>ct?R1^Z|lT0XJR6|?.Si6Z̿lUZ6#!؎pz1ppx0-E<) SV6ӵFga~$Ewb1w׶W;}joCmFKx&UeS᎑9db*}bS~Zle{7QF+fixv?`y$ 6ڵѢ|UhoN uqO޶+Մ:K[][e]ik_e_1EQ8瑐zd3J*K{Zߙ >k-{_x-Gđ2t߼-N@cF5(Kˢu0}[׺{.-bOx\ҡO7X?}B1BN=N|oyq*Qk]O#忋q<_|mrz<,K,#H:aU$1ncL>+n&UW[iMnUcA߳>k-լap7ʠ}؈;NG9={0Gu~^'N7mt>\Dl``3׭B9TJ׷lN;~ߦ-n1b7O)yGby0ys5PUjN*Z=.K^q)SJm^wWeouƻZ\Č.2F5>i0 pt#pTmz# Y5պC/|UmmB~i2kKjxPu{&ccm߷< ELOۺճؠ}Os'g> -m%웃߷$sbquQSm?}NKYe3qƾSJ*o.[&OkR:u*ҧ󹥦YL. sslz1M7\F: B lЁ=xԩw2%^-YuꭩwGn:WVWZ_uEOfozspakw'IWۯai{ݩn՞j&G;P'%+aRI'yZzߧsLRM%;vø??]xğ{Xk}^+_h%_eU~FҕW_/g?ɞ9uҹv:cY#>l=@Yl+9IIgͻ?7\W]-FX|_3.ںR1r c5j 1Yrك^3nˠmF|}9өwv^-r'6Ѭq)F5*Jؙ^[خe^(Ӕߡ0<5cq;7ޝ؊u"xcZ0mG]{vWQOh̭#:qَISۀO'8e^*KMLҔ(i̖eA-Ze l1.B21ӵyҧ''xӗ+mu"=|׎ٯ/4r֝(\eX'k$b@/N9,KRKc=RW]C92.[sÂ+Xnj[S#s5mOkVuFZI%34ێMe|;$*ͻ<>>^InuQҺhŸ\WʵYU.UfkK3}J4cR-ˡՆN%)M'm<|,MG%bǸ+=FqyV ~__3 D) J.G7 E qۂO֝J+ck׌~^i/:6q6x'ϦzMsu~Fxjը8RNTǑ/uiY9k{Z<+}>1 0l8V8$cE:vkfSҞ-ԢW}AOX#"*>vW$=:cRTb(ӍpT̹G'MѮvn rjJAC8oݮDž|@o94^|Wۦv~M<=:zNT|]UU_+JV4#a8|5+nVZ#zGM,gUl}4QMb3#b*auztmNnzwfj#2gHT0N{W}j8f~|3&(sjdݍȫ?>a589_^᝿خ6YqIKomsg[ocվYCdsss]4%grOmU9kV==+8Y[v\\KC׿g]]jJ xcu]Ĵju }SZMcuW҇+w蟡_)ʕ駦O/֬=[k+Y>L2gЂ ӥpbkSqSjt㲻9If 6;TS2 T\j~=j;<8Wv OG}=[FO]4`۪{|T_W%LDt6u(-mlt{D^e0=z=L'WM%{tM<,mV~ ǢǶ6ŪԶ̠n鑷XL7n.EӔ7f=oNF׻dA$n#==lG9#u9ϙrش1|I,$GpYUd}{w p*4"3%X~ۏyU:kcx.W}Խn]u6o>drQ}}GagN4I\ r?319POːs\8Sr?eJ-֟ j1vDA [ 9Ƿ>̬_O 容weusmhe#);pCp 3xM;鲿}UJv/]6hu &Fn瞝=+U)To{l\.*VS r\~;}nJMy220R:xZԱJRlO1R&z57O{x": (RT*;`dz+Tr&x|eJ垷p#r3zT%q~eKF3.𠁻q9dU*hͽKl[˗wC<irb//d^$*" T2~XY^竈rksɏ?%U!>fZ]*qNe'+m,NaYO̼' <#nѹ;uTHΤޥ{)nF9=9`23%QܳP),~7)g}&:g&uƵ 扤;Zғ;)QݾKGԖ+e.Vǖ GW%$#Jx)rשȬ-e FZF1qՊ45r_J\3MikGUmlMt4[^xًaFS=tr4LF8Nt&xR͌nŽzsSTm5)$Ӹ$\*" u)^Œ}ؚ7eDXsyZOcE+?%4{Wns:v?rRFZo鴏l둜Ϩe$^<ԂKg<b3ճqթB^ Ek[Vĕ#\q =jU%ʦ-/=JF_܁ɏ)$?Z8 NecNmp5w6avf' h-_GM9Qr_'k]B8愴&_7hF'n}2q\ѧxX(>V욷u$_@'uz٢*%zyjd|`ym=~W*U9b9^ƤvmgLۅ=,TO'Kao-Ws\-ݒ}FRwF}4NAW \W=J<9VD{sb)BKƪ>Q jRܪܭūFh8$g)r35/u)B1TUֶHt,hY[,99jcԔ7]}< vʲ,zy;zlTJjF'7~.ʭ O/h #P9,s׀:by.X.Uԩ5(SkC&y V;r1ӓfkr\bģ_eڤ'e%o)WmO<|eCLT#w-mCf[RNFFqV#]:˖KѴ72H=ǧ)rOPqָ̒"nj{w^A=wZ8kY=z$uyj1)̓ ǿL}i:s^_$[yC2GAe,DikNU_[B0혙Z=FNtⱔ{}.%qI,O.OVҕhF9(Ѵcwdil}=n>=QOK{ veRmd8~i_S*jI2 n'~:̅QJ.Zw+ܦ8vorzEK޹%'kW^[79y}3v^n,Gˎ^hUe4Zޝlܯm@cF2M=lgܳZ]n%('o:ݶFyycyDjU=ůZ0>6PwhU*:Цv1ǮqS,ݭa&ܷO 28-8Q?ϢBtVIcbF8'z*OvktKnۙX!wvV3[?˯H֜y۰3;1VyD=ߟz(ތW+fu!~[R7|cH}TM-ǝFi'؞Y4hsŀPr:dY*֔9m:zu=`mroK*6oNJ#'o#?.? ʤE9CoTKmחRc +6w+Mі[?AZQNPq5ٯ"DK6WW38]=Μ\y$y04h2C}3ϥgz:jKm4pdqÕTfR~U,D+Fjzm \E m|O!yYF4XM#F'H2̤mc yޞwtuVa aMAg󢣩N|5)$ܔ) -ؐ1ݹYJt:8Kt0nfS2'TQQ?y1fTX־ކ*n:4Kn[wPnWX7Q~nN/&кq{nV\D*| In}Nԗ#],$R}Vfz_j9wiAjHhʾ[+6;[=:]}s&5$Ս.%]`\׭M6wʝEEj^d_){O?OY2F M6rǨ+hrrjX9+٥` 8]W埶bdc=49t-{H6ry^cT7w3޶ĒGErwkNDc#*ϳjc+Ug1'&[Uxh`>緾*m%`RZCbn 3cTye&svōH-ChǖfF_i# N\ h<};ZrQ*td^O4yssT7Lu%ceuc,O˸ 9ջFm[Nʹ-$we*iѥ@ NyGOµ.d:FTs9=^hldIw~%'ǭwJF3a(3VԼ a#5#lsV>]?hۉ,ڥXR#23g^=awS5KkvQ\v15=Z;p"o0G}TJtѧ+:SIl9oPe8H0v#⢜h:nɍ9V*>m鹹st,c1rO֡^@sc{'\S:#؊mZpE:汅J巡qh%eUk>5)sI~cXRW(՘FIlIQ˟Z%o,͵FTڵ3u*.Wk qgw z#N/khm`Y}E:sNOCjrӋ[2Ry|*P嵤8{W7iHQujSMɛTm76t8hW1<ֱnWRX5廗lm#׭h~VtCFTosTvSZ#rmKCUjTo+_o'\m.: [f}S-iULzj_Zw*G ~_!-Ko){W/؛`̓mWt5*Ыנ*񭥽xp=O޽g%6QvxBRUBgˈ֚euX 1w*,װ4ͫ;(Ӵ}<^+_ qvlZO*53ק3Βikеu-lk靫c՝L_3*nͿ칥k1%RK24v#z[[keܖIwX;w Nwq姉tMZ[|ƴ9s!n~Sc+υH;vI*f]މ6SrKԕR-/z/Op8WRY)d^ye_ cN*-jۤܨ۟T*msHԪZlڴJ D ,.]TԹT;IYrI/Ʒ@oJ%!kRuTj'iZc"d` rB5(F׵ҷνj2ٝ&j2#u~#88Qi=z؏F7+hߟe2FBZFf|2csGrQTiAGtWpYe*ss\)Z$B+I贘eyl?8>cAƕ umm+-F }^? em}go_&hY\2GC ۉwс峌{ҍhsY7}(Tck[KkԿ ,9;~J\8JHrRZDۤQ#30Dz+:(W}J:yڭmzTAR*r]^ɫ6_+lG2'#SQEW*2;m̝A2ygTS@k1u%7zm!O!bN61z*Kݷ^\W'/>4vKXڷ~yϩa*&ף:*TW9]KA|{RM2mYsw#)֫N6j3hԌ;;d ]dkXԔgT*Qh4E*m d>z $εi~5~7tƱۯyAlv<{ss'kmc/ֹU/n432>h|ǜpgkF {EHODS^fA;~uF5)IT<_i;];tæq$12MX?om~~JUks_9Y?ݠ:~_3S4u*- x3_ y##8pk#αn2_K|{msUca5 {x*UH8=>^ڎ}sciʝf_j끌pkIS>e윯۵ܐ}:w[(K4mՖ\ܑɻ-=LTHvCT\ lvwdfb3jUݲα2I@V<9^JUԴb8S]ߧaln)s.N1+_6r>)QPh`kȩZT = urm滵<kF/Z#ʳY۬oR2T<yXt<8zmӕﾄ"`$Eʖn9+*Z6R1WD  8U)+H,=M6_TI( s8WҖcST$YݕU3ُ8tJ.K>ݟtmZaev^@՜9/jzݶw)9Ҫ4*r%Դ;Se>`L)tOFMzS+.LmV;FA8 &8J|pȻyWJRSU_pknPW;GMOvgNN5Yyl񴅶lzq=^e:#_E%՗sG¤)j1|"˶MݎzA*J<1JRdD-78ֶ'{^٫!џB1S ?Z r7AFr|Ȗ7e O,OֺMhԧ+XAƒrͻǶk9r#JrZ^ۺnt(ʥJZqW.(-̎@xCھ/g.I3VRG?|QoWuUSz!j;zN1VW=jwk+_eOGRe8m>s5cj}{FFvބKBR+$䖫Vwe~|C* +$֯g}Zn-{M'{u q$Odl=:,cɦd"qi+5NyMZ-ҲygPxnD_FЬ,ރ܋t{+O֒Zt%hZiդRV9# #7Yba\t=|q4:ܻͅ8(|V6*ܐR,A܏LncƜn؁?#?uGR)NMBmy. 1x)-nP)?#~T|:{^F0^r&/r4Jd=b #-S*n2.68*YZ۾Se[EȺdYݴ >VQi{JX4}\^$KF|[>g*1nmNTWHX2SNO>㠩Tm;3 NDWKoG.# ӭ)'8k-Tzso,c`jc<=3J-BssOG}juęJ<9GNk46yU#Ǖ={ܴϵXW\ֺ&\Mc[q4Kص=:J9^=QKG|{gjI-d0ovW-MĐ#dr0=>UMIR$~bI$EWGޟ=jyeFhE5"̅cX5\EӹJ\ζ5"|mmc[3ѱjg9 {ЩϓIX+ӧk!]DIU^נĊ=y`cirUN3jZ (^zpn.׷ Epr?3ӽBOi1fZ5DQn[n;p9ֹ`Q;?GKⷓ%*[mOߚU(862toQ`q2=FYcwAW+Gt1)}e`-,#UTk~Q}1\'SSrAө#,goFW+-~F1Rםs+*Ihn7w? ZrzkFQk_[kj>&5s9?sVQƘ ձ ־=|$5TFm!FrGJn[34Ӫ╽uw~R |j)S q~tPnrY\UjFѭ>WcFxc_ǽZٌeJH£> Ǝ\oľYx>\3O!JuⳌևC_{|K__"M;-#?21IV9UetlHK{77 ^ r֌=c7Jկ 3)bMc .I1\qO\ T&kN?@'q'_=r3wשּieHЉbb:O<{2d:8Tɭoq 5&_1-:}ܔI$ҿMms IW+0>]89 åLQʫt3c]S<ňKpOVtiߕɓu_$,7Q[Iw 2O8W}>Fk*qwHEYX`v=a(9s.J۪Hc65ٳX8#?j\қi+*t/q^hٷG۷^zt8ֽ5um\[ޭL͜F?mR<7.)&X'̕Uq_/4UW_%(MC52,eE9<#Y~SNJV?ź4LL@n#WTeەY8G{vZ$|sNJ3ka0tyc/u_p([vܝ͐Ol*sjiR.) 𠴔.C$ݾtT;jwG1xl+˷<6zG޽*tUnOi/4&ڨʭ# q*RQB7̤Ӳ(UCavFNIE=sGy'HZ/Uz)+ǵ,7"X(nlo\quP|ݽNzڝev4 ,eV21/H9m)u,7֣ =^e;3uD*TyGU/g_mx#5rҹJfXcc-p3dQuRU9$}D37;zSZ~^V+ϭ',9`:w?J:<$Nj|C;[Z̀GEU~u1tZd<1ķM"[-Ϸ&FRЩe"k~O+>X =thL84.TPIdE͐]< p{wja%8Ge*VЧ'ȣVuG榯ՇS& 2rIs\T7}ϧSqHu{h:$%[w=t~u'ʴfX"rڧkjT9EM_̚PPsgv#W,WEU:|DҚIkwWΒ֓+H}kn^mN8Pݤ7U"k0} " 4#.g۱XZF_˷͖UH-o˹qֺ9e&wo=VOޓByRnUi…OfWqcj$q'C]zrQқ5% 2.Ȓݦg`~UJd.%?b4~eNrmR״JƕK+$V2ImcғQYazv^ \r gZQ[E2m禥@v-#f0+hY\Z}|*sߎ+y)\q+'[I Ƴ\_$5mS:FB|I^Jƥj+t=#xOx>ʭRC:e7`gzFTߦMiZ2OȾzз)ذ? yկ_CHO-kE 4t|ܣ-f#|nS?JF祺w9eR-FkeF8 ==*flxjE緩3MjsHUGVuG,,Cuu$yȭĕTc.TLkTTֶf@UNY=rx?gxܻFUyY]n-̛TS`fOWEP{>E¬gwcǿ9>9z)cRrm:Q/!uaZ^IrDfv@XҺ49{=9v-UTdURwsARQz_R~ 8n完º艬uVG ѯU;Yu5293\=zn7lBR5t2j T٪эFejZȱU!l9}irBQq*єkwP\${XmG69TǚW*{Em2^cQV⻢:Rrv6ں'Ö8a*I]=_QyY#,T0͐?L禚 J]YKmKw'JqZUn/MH#TWy\<gӚu)s]rѯϽ>}[+$ۀ{A]WZ4-.LOQVkMH $F{vҕrMSԵ *ײnfbs݀H'9>)[}ZZ5șX`2)1eBqJ3֖S׻ؽk\+;[lӽc*+߱NW/Ayt7Jn|#1%%]jU)oi34ٵ 8UyZ^[/jmk@mVR1>BjSJjJ&6mQ7}3ҦTSH Q]L)EgcRd*jrZ ;Z tL;'*Z;Vԩ>nO:k f1[G_YtޤT+74nPٷ,:ỎkFR~R6"6eghYkH7t9SHrݢ<хU\Oi9Td%yC7v@<xGݻFym߯o"[YZXĉd-{r:f4j?d!Y[ʲ473*P?32kcOgŭ;v6mQN>lg#1)+=ŲUfo8#9[n6*\cd2# ,]U*J}ÍLqcb5Z/jvFwc>;#,vI ϬuL㓇=z666!$ AǩڲKI3(~Ql)+y@VAA#y5(ڦ6O 虉tr| zֹ*s]KukEJ]C2Mb^=zp>ͨZJߨVng)ۼPTtRX\L-JM+tanTEYcZ1u;NKq#I,#2ƸVݟ$dqXM\`Ue|#s :ۧk(4:VJj|w8hI3Ѳ7폞xRK+](Zmq\6zzQGqU>V!o3|Q vf F#&ۑEu],`Pʢ[H]3cq*%I)qakњs]R8[pjm߹11=03rF͹NZTR ֧5H+ԮjT y<|68XU#=M m@C03CP[mNvYXayP`ºY#,wjgBy=FR@=FG󭠴tq,{ZEF۝㷮;zUF2zjuRR4o+M@ֆHXf?pϷ\%3lы{]y]a%E(=+8YZ{59_oԆ;kb`kPm9㧥9Vm}mZfjK]Hm̊Zぜ^=z %!qYH"s;ﲷk|eO|&qn;W<(ŴZZ15ivǒ )ƜM{甩Ԩ(ZK15($a$^^F+zqϩ(b3'YvxeUև4m%sҍfŽK0pqVԭSRN-5O @3"w&=$gO \t]fl,c⼺-zJN1c݌Nb?,[EntG 0{gunaӿ[SZR#.=Gj^@D{fӕkb&uCn"͹ 28+:|ҺX4 ׹{a W_ɀ+ԣRR}DU5+nMj̭'v.2mmtcb#娭^l] d~XG){*3:1܎;.c>XUcԘb,nESZwqҧ'wbl1$˟iӇxtSj)5~5s;x:a}=Uȱʪ xx+G R}5(^ݷ"1y[U8QFkK쿯jM.J0XYj1(Ir֣vjiiR(QtB/inWȟˑw4{:nqZs|QY kKъDEH?xo W5E''aR.2-csW,\b]]9Y0Zhhԫ-Xd.y%N+|gga58VcOJldYau`L~ܬGN.M&<|c*$#@t7{ܮH5:q弎ya*M'k,(*ԞC4{cr{q5scا^5EF=RgS"*͟Ҽݬּe{t64ϲqidfbFdz~URRIw6~y˙oc{InF $ˑe~I{NWg){G{UGA]{0@ۤ<}Ѹ`=SkFFjJMj6{uVYFҏit.ݻEyf$ܟk+=+:t\7*48n1KA*;^ Q'a^^:b6q-8c8ҝ*8IJwKfPrVTmNQ(|[J2E(ӅOYe1ms\gOjNXC1TܛoZIr=~n*~ ߗqO7vLo|XͲDRKاMq-I\}i˙l_mlw?(ph*I;sՌts6䠏ˑUܣq3ڶ?g.kRi[U/V&Qwazc3TƴÖ\hRIUeu1O<~UFUjIǞ"ض   hOy[ z+^Jq-Ylef$omr1~cIJ;#J۩DIm`eܩ#z׹7kT(]hsƙg%ydU`/r3Ӛj8u#+7m&/feeᙺzÚ:1Z{iVâżIIhEm‘޽+׊OM3)+Fn^3B.scONSJ/OFR6-t-Wlp<8q\T&ﮖ]Ŝh$,یzk:? Yz-֭XUnhUў{sy迗Rdڬ?qSV>l&|?%Uf"ܯG<N^H:؉8}uվ.XjI3u_SW{{Vϝhڏĺ=6ͨF+|݋=zaRIYGsp&[O'ώ_/XZ]I ֺ5+Cnpͷ,3=iGRmCTaq9mu._>,'/QOɺIL7Aǒ0BW߬\jII]w5aq9]6Ks4 ᝥՌtk4qrfD|u5T9Tr~p拥WގڻO~.#~+C0T}BUjmݞG-W=CyQ\$:}|RMnBYA;bzDh1T4ԔSѴIENJπݟM vvs@v>^ iROewkNe^ ko_|5ٍnN51b ^ cF9V[%onf#0pkͧM}}?>"U==GK- Źee)y#敫OUuet>g1/u~:g|Q׼+ÚndyidƤ #)Az]yz#R5Y^UI~η>X7dᦎ;c}ÌopvOjWkuoKt[/aŎC#3DPbve<JNg U%>֞Eev\%Rl2юC$v@jӥx;/#=3isSGeDsrp ?O1Z\};lmCY.WV&lJov&^^eL<}Iߵo x̪v73`#>=J=vi$ާԍ_}b-ɛq$WAk4"<&G9q;>LW/u⧋7 ujL:cѓ+j=J޿.{3G>riAJTR:N7[[+>v1Z!ѫrq-.Fꬬ mE:&kƲikW|]zt7)qo϶+Ԏ>iF{Et:HVGQeŋ-#q"F9WE T/iM>C*]ō0mpyWONNJ s"dY̙Qv'aK= Ju42oR2k Ǒ{tܣ5j7nޕ9Kc{@J-59IMr?TKmx֯Vn+TJ)IQQi.OTErw2fsҪbAִ8T)R_ xGa):$xccQю*iVa3=kxӇc$̶{AUՎR%n<|2ȣ9NqjhsP.ʬ?"iZ~QCI3H6'=^]iNvZ+mt=*6^oHgyq${cVicN{X12 ҖSM}LqS:]S[oc~'8l,9÷L9,EZnGGF']lha4m&dEazõi, :m٥~REz]Qޏhj*# rt*v U10yz[~ejRo JBv^F_EK )M+_⩩'S^e#J.n~!L;#~vc*8gq^<="T-ocűUGaӴeunΌ)J3ZMƪ ry]:\N%W]vo_5fɮ4m]=ே]'[˒m`r2I]:ѣA:4B wAc1&eFO\³4s'dyT=ͽnw4+mS@ ǿN:׫GS$J*4eOlonbC\c&xgM\n%/5K$a.UN ##czҔUmeXO}]ODgzE}n,] AS^|˞M:)SmswikNxk#DɼY%Oab(2k[/"XT"~h//U?C|j4ͻwK}/]?7t$ f3#!?P7Qj|FzhGoTV?P02>j![QuהkEV>S @YrFL3LҗIu-/%_N<@oܲ+H1i#Zrң%e[^{~yXehMz_|%ZhZ$aXqG?B8{1xO3_uʩ_0#)&ߡ|IdդkXSn?vF2jh'W<X)6ںV@;IWGӹ?gu_>߭tW?Rν\#]rɹvǟ`nII1SZ=K$.4ҪF-pQ7dO*IV~pOV73~|dxvE!hUA2f8%x9z 1Y|~R~WwdfdPWC@8r}sn??0ѷC_j_I>jH̪e<NknNjZ G7-OE}wi?#Ӭ-IT y`~qv t1Ҭ>BR־;>cnQ]Wٸ|@=}2Щ?zOmZ6]LROe7!'5'(#?{cV[Uy[tv{g=9W&r-EI,kt$ӽaQǗ1zkۚW/mrĞǧjN2JTb]ȋwVrR0QOmh,bEmwǞg)jG-S޲uɏEnzdu)6Ҟ%{!YL?0tTc̖߉1NNODXEgkWOl?ZҜ%Q$qF0R1䪼 {{)z"WJ+FG\&KƬ_snBC^(E{YFy{c%nGܴєgHҼDW,y11ZKvBt9J”,E"?OU(^TtmwH/.@m}y?On.VI~S4PDmfDb:e;2QG4p$n`:B.FeU֡\J~vN;NRٛF%Vԍ,઴xXN?}6Ob}<ܫsĺ%b3'ׯ*e.Xߩ <6nR_زO9Gd \*itQvgj6wv9) ܲg'\ϕHZkK+ܤK/-8ܪSp8\qPrzc 'NnkyWRQ[ x_h[rYUyLÆ럕j}+_`jP,0Y 7#)r롌kr䎈#Xn̍*>nƺ=Ekc]hKC.=#7JOF|4eN̋2z 5m:-ٴ٩KFsR7hנ`n*GLyWMFc3N\]Xw:y2F98<[hvƥ̵y<y;wr SlӹZyEBSڶyR\Zv:~^s|O}sS(Q[ztqY,,/GS9FfU)Ɵcv;Q{n#*;p3ךr#~[턮+G'ͷ ֲOIjqS.~UӱoWvɖw='QrʕNv۲}Kv%ϖv㎽+Qu/%pHWrOHX̏62_G.!U>[hȲD7[wP,9GXI/d(Q&̑*#sc:78ݎֆKT5VvY6Y`κ'OCjNrq-}爤Tg̐u5*FN6z_+ղ%em޸>z^wZn y4O3ݣc]#3ݖ\2A=MWHK2S m̱6dڮҏ>ZrΧEB'B2aY#Uvo넨uyi*1qN- _Ѯsc\(ª;iG .Տy{H;??RQΌ7NSNqnmlB2?kUdKT^UD k!/8۽tQIBInG3,avۜw1eK"RA I&>c|2<Өݺyy)r8--og`LwMkO F1VbJoRʨswĸd/ c'?U*r5vssԧ7/u~/l%HHԨϷלTRRm ѭ&a +}Ze*́;9猪%3i-7uqWY#Wr5Kd[.}e=0Iz+qr'RU9Z !I Qi+'tNq 3"~fƫv<71t]:X»G~_q[iKdqJ%i;}2a\6`qEҎ9]J]k+u^#zǮ? ԞOɚ֍ohQY}O2">O{yzU -s,dڧl~: EҜeZlGwtŁ+\gNXջ+13g\˕i_&$G1@RQI MeUWvWGٽL%NX%d}aު]W%8sO TRzHXj(f|QX5Taf`h4aY]2LlGU#%fR4in74q4"fVׯ ]4&Ո]CtɿlAS֏,u9a0З-}ƕ%"-˵wӭ RKl8Yae:P7lYA5? -j#ԋM!SH"ve̢TyH?3ZGIqIrr1k\vVmR Wa$->IRJ*p3T'g9-Q_Q^ pzNO&*+h:t҂dW9I#i*E)-z*8MΜJI&bn!`DmGaozUqhdFg2K<>Z[q͸a gvepu%x_6imW-q3Ƿj%:*FTcw۩FG:}l9styJq!ɭ%3J&Kpwt}%z8vQ%);#"=&;JFUOOuR/g(Gi[\IbE]ʥ~>ZԩF4VQ=ڗm9N<9t#${Ruç'RSQiu6 S/$'v| ޱxI%ta[G9;[k5?U9 7lvwB7]҃n%;㯭tQQ2%E=lՋc,G${ mF9~EtV5vU9Ju-#^[Lii9\ {?i%Ю &IG6`Ÿ<}0XR7v[TV14}V߲ğjqi7V_L r'ӋaijyzVy朽~/{ lnK3Go}>߇̳hbd1D[3kßgq_ZV,DN՞ 'j,2 ў>j\# # ?9N:u|O`([y1ݸ5{ E5>UkJK- Y[yw4]ln q^ g[&ٷMVI"7 .$bzcG#=jVМFZi{ܜnr2OӊÖSgNT5t${+n:N=Z=N=A7О8?+KIFScqyD{,:ϥpԭopNtzߠ9aUf~dgL+ȩLJ;4E7dc.0o=z6"2 9[U8Z1Zŭg6Dž[#$r9֦g,γ[Z [wVSi^XKؚѧ <\jk*ykfzqsW9ԩfp갓roeE|[}\f#z{泔8F*FR`S͈y`ml?Ҧҷsoi1bnKW|9Yq ik("dtw[H:W>~Vܼt5(io"yk9ܿ;r"O֝zV;BѾۭ|aUF5Ԛ%m&?@kr:iWXIDFhU)KI0j{|@ijT:5$#=:XT/u,$\Z~Y F 'wM9dK,ZGWb6˧zij~U3j>Bތ5Z3Cڿ6jBeR<ǹ־%cG_SҥJi<[hUvK2FNÜӨ,?b18yK_}N3F+ݍ}<"ߋ<Nޛk=,oPKl<7\t+ϿF5QJ;mo;xBih#$cb`}=}r4Z1#ݮr5^ \ƳHXWZs{TcfuL}GVwr8=4]nKxWb̫*e(o>\&r|?wsH> ƪN}8zD^`q1Ue|=V\xKSU?;Vvy:.8?Q¬M/Tt}Zf9\0Vktĺro>]W^{3;e88w \7`zqj8.8|֩A[Fz=KZwċ4-]#Fpwz ǖjs7ɴ}3G$;ml1^rxI9NR,*SK>4 P.2>̪I >i֦gB.w׿bfne)QSR۝طOj#hs4]GgEKhEʞ:{{#ι"4=-}㹱,NzV*J ԇ+[n6K3 {L3lchvgWG1ݦ",I#o^׊F^>#Ӓv#h'{KȞeg cn3<˦F^䵿nqk+-gϱgO.i> kQceavv(;y~J>I/_ԣJm{oQ4{-R8T5;Rҳ,$6Ѩhz5\Rh-c2oh#U+rg-y`G[^&e{\LlUJ2~&ƵSӸ;vVn6p2qn8I6J)޾OkKveFYPsЌZG*d﮶;xd6;sǭK'4m6ӣJu$iO^#GV#O<5#R;$Z4s̡6\uXT'c(֔%=m8fVmyjɂIOUR1ITO*\ĉ%cqTs߁ZBehiVk+GtrB~+)>٢1ng'*s;ҵ"䧟!0N\qOafΣRַbżn&w:E 3ߡSQjESͭmG, s"q< ==hc̭Tc4+4ݻ 0e UOk(SF$v9G9$ xZT}^ֵ7*_BK S5ܿ9#=jFϩtiʌ}[inqJG\!=9u*%쿭&[HSmc?QZ~'k]_a[HJnrw ALkRY\JhSJONL[gG;``n{]j4_tJ }/Q!$-'=::uWrLt[O|Ǔ2n^V2g*>]4#yU=mXJݜyiJ喩w=jn3WoR*oV`Iz)R\4ZjkU⑸vhd x<`sajJI4O(I>?.'໒ \ `^:WdU9z>%Jq%W2 7ie# @9 ZjVos^ؽ -%e-r8ڌ)ǥR,-5$(DAX٢C`}kOZ:&PmY\c3c5["yhbiLD^Uu ;gVZȩ):kz͔4%yjp0z[sFvua:u]|+Y 2Y#%'dCWU?MJ mYJrX~7v`jp,Tm g98JGW؋MI6Ր`[%+3#zz>֡S9W^DS5_8qo7ں(ZvQJTkb$lS]i7$w/ߐqҦ+CTe~#Y-ޱ}Qb+UZXjH7jDmUWKD$,6m쪾Jtd4(JWB V+5-Lh9ʱrwUrF{~m $d3+gkt5e-5Jr W|GWZ7ԪuX{D;zUS,Dմ]ERj5M+bdWs9e^1ik8)6n^RƷLC ڱNj|8^%t^2sP)-5L+W+bLFyuPD`ʻTc>/iQMmJ[!9OSfGeGkVN4:vhX}\eSCv.G{2ųrBe8Ԩ,24?iUH;hڻ۠6&qU%+lZZ%Dez1RCVo<{oyձ.+I^WBh݄}:tOMqӥ8NhF0`O ͉7b%7QgQRv~n^Ds=y褳Luu*Fv;\Vb >TRB9qQyf+Ri&PѪ;n8^7*t5b EܪW'r3so_Z=R;^Zm*׏jrn4JORtv4;)Fɍ(KMax%wYr;^ySOJC|3]mW)s]2ŵ8Uu$o*ԫM+$Y7Hr6{R깤g.IEBު5yZ ʵ寒4hh,{Ws4qscZFc5+;Y3V2dTuUTG=w&is*sW͘N0ۈ=V\z(Z{3\B* BVI"S`5C)BG[{uAViP 2472.Y8퐹mwRw2~jB#|gV%+#zՔ3"~8=kjG(O h \*@*/vgUnU 'VH ReW%] 0?,է(Ÿ>#IZϲRkxf1gf73c=Tc'-{^<؆\\//+ rJm4q%K.bˊP=٤RKBYQd۔x@NKiyVqkt(^s yknc=^Goƺ(wih{ruW$l<4uVȳm"csk R[Xڝ/i+-zRO=|tQ}? 4޷17Nߧ__Cb [ƥlĆ=W06]鶛u}[b`lハL5%ڝ:tcSR6n,sVV7zrB$F=9=N)¥fqJiS>[o&XdZәWC(me\(8U6˄NJ2l}<$qF,| ?mO-ޟq|Խس hn@q(sTqv]Njyjo=,r3ُ ۃڕdT+THLiڹ?7g򷩋õ=HuIcb+n\mU8{8U'*ke,ĒeJݨE֨m}U$w-_wypR p;//Vnw·Bᕂ\c=;֕%|] ts.Qȳ4 #Y<@N0s;JɽW.Dzm HQIpON*2|>JG'e[;ٯ$`wq:Xmw~ڝ:5+*|Ow׷k9$h"8UힹɬK˖R|EJf,YNW\v*NZnN:"t-uhUy+nq_;R<ҵrJ3MĮܻYjӇ,;0I̾uT+.Us{GmMdC[cp,zU(өy\9ֲz-c-Ϸ\4ML<%$易ӥ4Wkf> (×QGEM.䶜/ !Rt)-YT&&6 hɓiOkKKs1UZ& yFȩNh{m2'·(zs|Gwȷh7Q`8늪Ȓ8R2%fa|46()<1rƯ,ZyN.TU ޞg"6wwֹ$dT9e+6+M8WOEHQ5) 8Wv}KqПZe)]Pe8k(yM0kMI]ˑj_ߟjk*G nR/ˁҜc/i̳k/EaRjHҼjrKMOmֹ+GTSr{hѺͬ3,;|>ƫMJNZ>֌;SR)F6ڲck:BxWZU;^u7>Zw(,Șԩ,D} vn>VkcSn[9g 'Q2zkT%RI=BU/gӡZ9o%޵GZ4Z\K}NUp |  xzr1W<饈Q͇jXwewmJzT*ҌޖFcH)苎j\FQkt6~#X]2ΔiOKzo#ս,o'q OnWaYnT-1Z'k,c鞼w&ϯތjTCZUUYBTݕOkTt5֧Rm=$&HʸU 1SFwA*3$7&lBY} 9RRF^G& rB杵F>u0ҽBj>ϕ7,R;6hJ+U W?f-*e9C[鯑jq#*crXF8*ZrVXUs*cֽTdq¥^[==R% CN99z8_KVIYjSNBAYC1׵J:տ"jSP/ݢ֕oq2E;;ǥzTe'OSN"㧟Gw+Mxyp$d'8 FI%h!VOk̿F*Jdמs5Q?yｵ&U+I(I.ۡVWKI+]GBT2}?s15#+b%R-E_R/fۛrY#ʑd~UZ,yhgNTh]m#~YCO[9#|tA851I 0̛\#}|5axmp· cV#󯛎i[R7Rpr9,\ߎуGmv(\ 9s_EOW:iֺtiZWcP(tmj[FAvJ@AF><\.Tkr۾I7Z>ݴ.; ]H,!Bщ#p0VE# dҫQUkݻ|zڑnRjٴ~g3 Wx.kyd_+{t'R9%:q#7 q~U1ߝZDOLctbQ 2@ 5ZJ#ʩApx_Ľ[xO@4 * J NJci˪‘3RHߦ'e> JL_޹oAi y&h/ypoAרRx1YVn2ʮwGebV9t 29&?+Td;}ާKgnf| j쵍?M}OeH03d%=xF8qu%vՁbRzi>;Vj횵i(dlTYB6pI1-9rT\vK<,s+QvZKNvu^]/Q􃱒,qsz`8Gb̾w|jxZj\=@S_-trb;W<9~adp:\Dn鱍lNSX uunytw:._~͞2=~U9]Ǹ;2$'ЧiY_^>_Yq#Z?b3UxJK϶Z-1HX7#>jq^N2 +Oj;k A^]ڤhp!eSNr95eS/y> '-5w3~mEo{FMBe֓*?+ ⾿/V2=S]v7֭NTrϯgͿ?b Z(,æO0G۷`nyB?#3n˷}>R1n&ߞSn{b~+-H.OҶ&uET&zlV!M{W{'nl+WW*OEΦ/UalvC ɒ=)2g筊NS%g*qƳ$ ~l9-Tsrq5)4feҲQӊti(IY7X̴I+2\o_jڤjs(cO[mH3veʀxJҏ(b[6ZhU7/mZ8OqtQ5(GK~Ɩ }PJNnzXW"鱦-4nr1SU:r:rLL=; bt}dvƌ_ -*`39 ˒}NSKe2@,Scnu=)8`]:]gqjPbS#am%CEy~-(ѫz)QMOCfrəݝA +(Ӧ<\tgbԗ]/eb2_G|~J*qK S ^[y#.YvDms^hG^0ѥ%$H=rx;FQ̞ك{29&7L$Bq(WcJRd\Y<gF+nE|-IO-#ҫ`'yc\f\E ԢԴq:ϋ|7u5Km3 #>V)JTx\iҊG~6xK5+NWT$w==0 ݊Ih'4aeFJ.Wnާhߴ^,V]˖&g#~l[a0M8wTR~0\/lB.81#6`9:9(Yy^k>|XK {`|W֭ʧO(%ܫNM!`9$t'*x80DycJ\g=L*4dڶ~k, $ /9AǧgS.g}OVX~pmJtqvo2ǧo kLGME,hэ-{m麤2[&FH=*e'k+iOR5ve4PsKc+8'אs] <=LsTdhd1#t1גN6bj:r[Ntg6oas,x`s0ǭsӏ5ktקcϏUow@OHb NIlcӷֺ:0bY|yjYOk?#B)i/o'%o&FӸyWffaOԍJ7i4^PТVkp4#:.R2O#8=휫aOtڷk.Q;?<%MUD!Ac ~򏕆N@C]zX<ӳc.IJNmޛtKuCz/&iƬq$퓀N=p%+/KUZWoE~掠o<=kpvb$Xʙ,sЊOJQk$^sš->EahK, *nm8cFLDk'uTKN[_S>ɥZ-]K|w-rΙ}GTed۾)J2)WOdOMzϏu-U{idH'A6g99 jtxpT񒔓n7<)Bk7pj_0<60$ seXSieMkA|%_$XLnGŊՏXKwk~0[!?)hYH˅n{fr>xK={usu9Hy!Xn2AOFNޕ{EZ?p]ջY%woہwW-#+),|a=>Xi{(ZjmΣ8Ilާ4}*?\]F&V$a8<sd˯x1άt[A4 m0 n~f9>TNHʥH;vgxYki[H$f펫Гr}=-9{;I6ߒOBiٷEOQYУE)3#nQ& rH+2n]=,s+{>X]4ֶ9_КI2mxY0z'5NsWaeQ=U9xԭ̠{4|UȷSy ˓?A"*:|U*{xCwLT6W 9Cs0؊zcLʯ.N7M۫]d~~߳Cǎ5Hbt,z1WbjԡESo?,QNmi~_hS EV2n,  \=9Vpѩds-~.kz :s aA8{v ,IoڟWBhr'𴐴fPȋ.JV3FmZ:r&W=+E݄$(p ׿Lב^L)FKe¯A8>RN{n^Wcr"d $bw=y=96<;؊e"0f>l 3ތ$EyKgͫNXٹ6i8P=1֜ aj5NZ}n3GB?2$=W] 7OXs:e\ |X_|?ҽ tE:.3krflI$`?gk2+J1+ڞ8~A.@ u5هd{NYolF1sۡ^9U]Ii{npDWw[w$anU4NU#/i:vu"s2H>|zzw4O撵W;oe ,(uےO@ֶr%*iߧCK\21g Awq(y76VZg_/*PGJǗ疏nM.RE#˚>iE}yH"YyZ(Ek%Gz!b2N}MkNyS}MhmWzCm_3+sJrWIy2ԥPƞ[1k'5ZQaӋOWd~#|2GF''RiŻ^ߙ:ry|S_qfi<$ 9$=О=1^ujҞO븝7ΛZzrZ&21cwϯNٯ5Nu mwN8RqIliQ|j7s{heW՘Wy2ZIIz5}TZ~V&1jo'ub3#4 3)_3'8:K_Be*O {}eCKe O* d_o1rnkhg\P2|〼"kCJ5ZUⵚP0. 3#59J5- jԕJ-CNbWDCh5Rr0zt[ճ/_S0o1AWcNSɿ^SGq.WROҍÖ4%Y0E5^t9wx"9vXawvTBxtgEĒ$sʪjxJ-lv^ڟ+VCmt %RT⭩ɈRM'+[^GyxJaM(?3itRݥo2VvT&0Gln\Dժ)өniirFUoЎHdRGV_A^Τg哼ښvF *\+mJƧQ.^X;֯o׊\* yrkg*яE:.Rޝ{4$UY+¦?5B1ߩj#9|?<0'3RQynΜE5*vnnIL Tv_+8Y+w;I]-4._̭l;tiOkbF$~ȿg< }8/%QUS21XhU|4L63lp,NWqXʜhݭgROI{+loi|6$uqsSF0UCgLqlV9*+)[G>ƥ*)~fRmdqg>dL"MB |(݂ͅ{lQ2q]סk°{U~_2M9PR{zVru.>Ҥyދ̶}E[#>NJ9(۾o nY~h ^Q6,W-u{b©!CFk2,2$Vq=mEV읒DyΧΡ?V*GE#cKNWܘ8EǸ^Or3b rS5%NZ?~ Ջ;nfm &rt⻛rќy^DYI%FQ< }'0HICH3n]I:c󩖱g<$+yq7)\I+rbFuU|`HqUNw'ȵ0rYjV+=e?d@5fh'`zۇnI٤)Q卣%$R1 Q8rxQ)S7'RӶ<$Lfq۟ASk5p#*\4Ȟ%GYtM KssҴ}?v{u9 W֩9_v gBS׺UcyOG4VU}ꛂs{~ZFUiFea#\y:}GJ֜f1h \`N9*9=?ZrNޗ&4sx%2h3[Qsbzh ]Öim|e78>U\b&U+SwV$Kɘ]׷a|Աq5bT+e ZSQMt:ѭ{ۥ$X2U 9mʹtƾ1O!3ʻ挕~c>dҩhK"E2[Pr:UF2jL:kEiQBduG׎ vv8.D\"+lQxt䤹tL*qN:핷aGE%oORkBoԘ,VUDquyy+1-A +W;h,kX_L6Qq-Z" r;ts{S_pZ*SN:[4U[vgdtLj|{4hA;jGC֔өNRܺR$kJ/[B |,G0AʓZ_rh2]d,Vpx82Fč#2m=y:2IÑ(_I7;UIO5;~ Ҝm{X | ߻mÞҩG_2*:n7/0icUUo|/AtҨR7ȱms߶zWD#ke9KFŎFq*x_9GٕF\ܚ^WiMVRmyOPx*!rf;.KeWtZFyK~fbpY:{>BvW`\[Hdgz9YFLk)ϖ2ჩg⟳p u2(GɺnUqƝ=N~y979JhrzŹ`кB݀Ǔ9NwΥ8%d8ƺ*SUf{ӥxEyp(O3ĨͅHUOKN8zr(ݥiսAgwybs|ts6{Hʏ,y^H$,nf,[9sN;54sRYB:[o5־ r,% Nkzt6Kw e.}vסZ^XfdwiFקt̯}o"Y?mBjy1]I#>UBwY{W-DFtp[͛MX]d0jM7B!p_JV6=:t$+,{TiuqrZ,^k%hҦT%s*R4C.0r?ZNJ4U)¥+XN=p|cPKɻ{c<涭[OsԻi\eo/ymtWsK] Oޒ+,,k~.hij/3.IRApcGPR{.Zi@&:׾#{.Br)UDjuFٕg0y}kzvJku)}I$U8 gʜ]#Reӽ[Zq22nk/yJ&tjFM [u6 5%;hCukBBgoE׹8n,V^Ckt8E `2M]c{sQs/Ӱanv Ww79Vm{ 2|Daw}>9ˮƍƍ5w_&Tla_LԦ&W/qbkf /)$*d9']TcIˑ;thi[R奁RE#}0~ltHʫZu9jVKCV+X۔ed㷵T}U)QvKl%Gfnsr?m$K_Sj)j^F^,R2so=^[c)sGEfsQ9BI^dUĀ瞝rUf&u#B:.?#-ԷjNVXƴ]t11m*OswjTO[omlݤՒ8vP@cUFi}%8tРZY9T8oS?CV_2Ibo݇n W5IFOViBjʦlQ;L]gEJ*ēl 篠JrPzRtLX5Qwr󷞕I.ku Ju$J/ɤ–r<4,6zѩ8I9Tn'jh^iYoѧ+[}zY~e?f7-WE/S-JS3 $NsZ*RFRridQs3IpTIm\d'[J2mNk41͎{^k ҔZnqywvn͕P쫝T ^uIW7gוJ4X'&Út"1TznF*TyDS/+IiyVEWF#c ~>VrYR,mF\ؾ?6=xҶi4HZĒHWhYʅ$W -p/txEfSշs9W]=FJJI|Xk /wqJ肕VLyyVe+3qw9>]밣G- f-c//ᎧקYԔ.%'ki#*L |ڡ_ߧSۣR)ECC>x$lk;;4z}@}}އѭRoQ+uXMn$m,bOmY''^8E8׺a< =İHa8"J2MV姫s޼ JHX#+f`6 :t<׃^ӱxT=ןCsQԒS BGKMrCpFrF1¢4og}3k8t1,nn_C#MG}*{:E5o9oxMYUXI6\ǯ_$~U7R kTR6GܣPF;g3M&3bXܜʵ)ʓ|"cO'mk1I"Y]GscϨj1:;zqVd姡?vž5fĒmceBn=u,׉&6Lrrbr{e viy"#*oNMzD| YܲࢷE=~v+b3`={h<}LMmq_N3^S].Ti^Ѧòhzٴ*&Oy_JS68cF2)Ram>Ipn`<4/EVSuPodp@v#JOT{\jZU#FVi!KIn:1(ӍՊ:։<5Dnұ:AgNm\Μ:?~$Gʜ,q"*9n8g־xs\T_GoúΟN3nG\ׇZ)J4#Yw$m_;i;(7mV5QnTS+ӓ\Q5pu+6(}ul67CS;9$(֓~0|Z=펽9arU Lne~Pt8S&pZ\KgIo3VczUK9IJN/6 ך}zV2V^薄) rs<{4q鑞洌Wv"6\F=ps #,7=~e.d}]GQЮu>QJi43 85|W4ѩh~TeU񁍽Gd3c(}zq jە9OQx*5hRŮÜndԞL1< Dm9WfR5׮n@!VU~\>\ ~ VtQ95bHUcT'wj=>]BŶ̞E.KP z92*eNWIF(IglZ֚O1V08>Sg/WMI vr!G8=Ee8XRNصus"m]G8Q60cɆctHe8"O0B'I?\V%%硤bki~) V$YF9r>i7-tG<%\E,/`]WhF}Q)E>U*{HǕ-bM*-dk1zRISzE8=_N6,L䬋V#YFɻO YT.߹4Ή}ѝ3Q[:*Q9'ͨdI7pwd+w.Wx念~-,O{'6L>VV~bۯ!>Dy\~}M^ʟvc|CR]ł[a;27\VquFtF-Mv_py'q9*%w`I&K¸ɀc;`@#z *|ѳ^%N*%WkʽGI\=u|lC!sț@]'QJzԜZzn%񝤒vʿ5Pu*]/I:a7\MtFOBUSSwg]:ҩE+_c*fU>dF==q+Ք9Sۡ(a3u+2{mGҚNĭql\IxᕘgN#.I̷$>Z Q|r]hөȾRU݇=F\qrƴmo07SrCoftГ̊I`i71:]m};dWQU1jLye uw?vbӖN^GRy9zur3Qg,=GQ6V1+Rۺg~w PQS7\e'c:+-_b(U8\v#cƴud],܀s 4)#jI5t7W{[=UJ:qz2}y!E rTޏi'E3Z5+S_gWaT 5Ys3zjG ͺNJUjS*V,G15[;Ih' 0ij+}K |&˖*9zo%Q&Meio!*NN婇u9= X IR7mU|sܘӴykz06rs6Z);%|jI[baض㍥Muӝ;Cz2y *yzכRO{VyMh ژEs^AX2Lܳ1O¹jJ^'NTz- 7#ƵjݛGQbQw/k9>n<wgJ^2ЉÌK)LWhJ7z儆cnB>bsWtXDyElL- $%-$v .nT1Φ"O!-U?ӯne%dkNUg(m۷̓j85.ZF*y]䯪~d7*\ws5[--Ύ! ^TFMcZTSmV6,CU5Z\XiC4{]ڌT.*1.67.kg~]5' [X Tƍyf']1Sq§N\bvn1޳?4W&囙77: n=KmYE۝?j9=VqNqsiX^UJ7|+3VHt9^g}67'ySNvadẛmeei(Ӵ_Էn̲UN,sp+t`ZҖUj1>tn|WjwE6 G RMMsҭN5Q5nI;As 1Σvӓӯ]iq=8f 2%|x┴Lghir 8 Ǔz=y{:5>cp1}х9%x>!EOWjtd~gvg/ҟ4uW+N4帵so. TGl #3ު4Kmhz4 Q|Tli:ͼrȩ24WnzT.K}ڜiQٲ\[|Yc=EǯO#:-KO!C0 qCB4gyYϠb?J\g.VtlREmͼhş۟Ae.hv.IQn\Mj11Bmcq'$F"ZvƯyY1Ǽ >)KHiRZ46tnُx!` ZU*r]4^Fxʬ>`Wz,9^dV:/7ʞFC$lZ33k.4ЇU/ qd7iZQZAԄT]CTXn0>iVBۛ#?ZhKTWP Gj# ~)4s{52ͥ*̮>>Xj?(NݵjF^ĬGqlgԓSYW(n;Om)GRR0J~^4I>F 2yz[N*^HQ{ߌQ8Umj$>Mns R_iѩMdu_1 Xd=k>nXR.qIng_J6ϴ랿ʸkrJ#7KwɔI,xj9;9~F1WxrHͽTQ333+uyOUש/c*i{VES%~dy;gOfekG,1EHYvr*ѺI1C>汔Je/T{H0r}άmk=zSVz1E7b8|y${;8u% z>Ǻ\v9='Fe'ER\Ց{oW&e<3H 9JT_G.x$jmͫ]KR<^dO!b" b><~UTJ}?:te 9ZI($n;p֔u6n!)ko`Z"Vv#U"'(VKGE;wc*ؚn ~W3ߟʺ˞7RQ$S^˞59Zɲz0 mDmvXzRjwZ.NluV]A- >ߕi+ oaYňoNsWW|GR7bB4p~d߼FڍX &>Zh7Ka)FKqv,!Y2c>2jR0ؘ+_}Jn bs#7FoA卓/SӷsTMcdp:秮i˪dQ+kaxTF<ЖhٯS3=6gg%wnv_b\]JOf#K[TryK"h\1»iFHrrF5pWT5M#jxW(RVx^r$bnf  퓟Jǚ+؉B>Y+5hfTS$G'5^ڧ7#zt:ce5)Mfa?x;ZٺQU?g(gѢ4S}d [zՓ̬b)S~H.V#va9ST~.IoiR]oz2X.hEٳϫjZ:'y p˻YJ1:=,IB7:r[I;zU*u}?TSg(߷]l흕KcՎy\ZV2k8NԢ@9oH~}y)T=֧u$C+QZ#7c\8 =?o Ҧ)|弿nvKiub~VYUw u8 uF1G(=͊Y6Z\BZ8ȏ2gF!rUy(7d>7(멗33i챪7m<sQu渭LB1JVwF<+f pk*n-^C2#6.-Xtf¸9{>Y/ W/3u]2HO(Aqן)T'8[FL-HkSN\qQOJO,DCsϵp9E)[yrC,Jk'O:VڦtZ"{H1r# 3kfue*pJ_Y̬nkJuHҞ"Q:g0M>U c̶;=W3f8*qY7NR\SjR-iizUq#~ xj׹4J5{z$J\?+xj#Oԗ5o_4ki~b{vo"V+:؈TKڊ}_O#Y4KxnET[hN.aC#F06vܜs(RRߋ_. oQ*aZ].LkEO=3&ZU+:o$(<x91QORZ0樝]L=G«ohl}:U}bU$)sv"X:[O鋨CQ`0G TNM;iͩ{$&NjG$teSԊkD^B\(<$&q3i[yQ&Gc*Tq{⩽mm;I8D{]Z*&:麉#$m ٯ:u<굪>wMm>\E>X)[;E}TN<ߞ~(8fl)T?0s^挮Փ?7]NijɧO펂c(yF®sҌbw?c>俋qڟ7F1EFҦL/vf4[XTԩ)7f:sXVЗ4TV9#WNk||^|,;/ö\=M{[٢FpWωe+kqK㡎 2m e*rVJwE/(:u9edL&µ5 %R*6z2w3tr43vcn<ٷTN??zS:!i3f`rO\U:nPxySg&nb)Q;5(Kۿ4x]O-p[MtnpH\ŹQ?]弭641Y%G4LjW)T};sdYF1pթӍm։y?3NRRi 6Fqv*?E&FesL6X²pNONz=+tε_SڍYb9`h+GfPpV+)b*4gFݕhY/'s΍h=a8yM]4dnh$8qVFKԉRӗ3ɾ,0ȇr5Y99XƍEp2bd{s4~3)=:pߚҧ:09HP;s?^>(BKV}@0mszױ>^u{ K@gw0Vw,|xraNrQI-mqV8NSn$0+h¢b_dƿb̢GWen.OO멏$!xTֽw;-͕\DiV0..w(QQu)uyZoRhmŹZP;Jt뿩SRncSO7+l.1U}AH~"ݑ*t~f`6-TM Yj݃iׂ+`±,Pzk+8i;{֮|GateBMЩLv8v:nmu` `dW |CxQ5 [Ofxn6Mg82W˖|E'Q6Io!B_NG塅d\%ȯrqp磉ӗg?RѴQlYGrCrsa`3#^5(.[}\mJɶlkV^sM~ ibN[[vS*\]ϓAI3wԔJn)KGMN?Z. K)jޞ^G_4?:lK,6 V0ģs/q2A~Zd}St}axKƾ8cF%8ګNyr*~)J!-VwJGR2wnLJK!k9 ٘c1L9`q.13|kz3ZtiƲIZZwƕG5 &5o-:]%Oc+{ҋ];kbhN+oeoTo}o KS{jh.>dLvv$pIjfŖxҍzx2Uީ]_?S,2uhݥO+tv,XOgMש<q؃UZ1PgKU֭-ݒm_^b nw9+˝J^E0(ɹ!"#,ǑYg*voNƒ]:mz}mܪ>]+Oc(A'ZRR빧iֺK;|͸knM7;]OQNZ;-i5ib9!ec'3ӏ~OZ.iJT3\j*EnU*@#'[Sv2hZѱxKU.c`k\2_';өS{}aSrw^ eKwKȥ*ьdrr;}*:m1)[5c.CineYnd8ogsRiwaf}-52ެfmwl]$jHR/G 4o6~ *M$vF_Zs {:.˻C6%?ZuviFoi6ZFEUOgmtl[]AM.ܲ}ɬʪNmKWVE߫^ZLmSһO/g/|맊O ;C{vl`Akoo\zWM:n鿫>v3I{և]xba3yʼMj,TjQq|;qxLVT3a??O;[ Fs:nm<);]d+f˸8}2y־30̥N2t9m,L\lRoHbcdOD9{Qrӧ_qJVz^}HxKm=Zg`Yr B,ɬb5Tm{iOh0|Uߵzp qR5VOD;4XFFޏ=u2@9oa2udpQyэJ[RRC1XPՔt%i3'_xմ۶m̋ )?gR] pبkZ}O[_ؾh{R$?{07י3NJP-oL/u3eU#2}WOƉYU#hmݳ)KE%dw4qZD^&X3@M|~)m1(ϾϿnmXĞcI2,q\汣G6VZۡvWgc|wD$,WR 8r?.k<^{M<(:8yN[?_IgpVFE~T˻O'`eJӕ~~Y:t뮺uGÏtGⱙbɡ 3d?:m]yJ"\w]WT{mF}JUGK{JҌsp?\q zj_~]4;_Lx]uܞb@BrN03޾z/:{=y*מc[:g5 wdkș"cG#o 04Q+}O xSj=o=g|Su&xsɑ cg B>V22A}^AR5q]=?#ao|\/ Vښ fz.sK>7TNx{Ӆ|8Xlu2m#95aZv8\-Jvm΋z͵N2RLs6~ޞ+I{ʅDޯMבiGW2o%nV$(Pr2s k(ʥjo^V=qo5{]OU~^^6RmD=֞KDSv9#'=?kQtJ}xn0Zi_}oc~qnKI&C32W?.{7Ojy09vUc:x̬魄oľ$&Bq08QZF +s>^mUTpֻEJǏƷHh!GpG#fJ.N\PJuJ)o^"D{E8Bp3rT)!HӗX9Y_M:y-u~R/IN-5NfAY }'>\qчb(TkK,Q3P!;T?O/,y$/8VtԺ;yѬlx̌O.;\~A¨;pyZJM[єwM Z\5嶰4fWf]uOQ_SW`dR:%q]QK[Ys1:8_Uo7ϋ:o]ZiP*޸n? ae%9|QkS{:Xz] eF>@<+rslKmu߱ШBDm4<\څW,yvmJ(O͕ߌWT)2|^i[ׯ#FiB7V8][lZLrp"[ͅa>q~R[8 c#ףu=ʒӥWmm[u}W mw{-L)/i[|0Z.@a >@O{<A*xZn[yu?+X-z{wsh/ɯbfLeo-g;p;W乤RSSlo>X:$K6v@ryc9Ror}ϦN<]W}),~ɶ%x^Ud K%Shc9#d.ATz~Xڎqnzw/&ዏiڄpGYdP%bS9a=sYJ.PZ3?f/S;bם.U,#\gv#m·@1WNz3穬n⌚qYwd(QwFn4+jϻYWѺd{B?.VݛF3yfkk>HT|=kէ16+ﯗs7zhAfnNFy}ϸ#N2ֺlhTVt01Kn$2,gV pW.g)ʜi;+U0QWc6e- k[S,wׄ{?3)0$6w?#^KVVOgVvqDrmt;)|+t}GE#mkr3i%ЖI=zwZu*7ޝVyƴei^W۪4Fx@??Ҝ_ڷ7r_yœyG㌠,,ɏ/i]Z%8_n/5vyr zW%3D{*)t96@iO8 5pl֝FW ;>mUl?r>i[bSM̶*XF+fFSd,5h{s<Rx֒IՅܫUH$:Zm֩*Ք4O.9f 8\zq~ڒ~ۣ*,.]/ԎU&]F99㟥(ӧK['VU Np@xlfʛ\F4⽫ի jLM2Z@ь񁜶kӛ4tF,mRd:ǎ {ZIN}+;m%匀b?]\Ͷt^q^ibm 34-${(qk4I]uԻ#۝|9׽k1t+xrAO)r_kITp$y;QJV**ִ*+9Te}@tp0"J2lrRh8pm_ֶ+t&ydX<*en ?3S8BkCԥ84+1EO )JrlD3.p>Q}zUGWwj6 |*{U+a*^: Vx6|ȶӟjR^2iūF_Z&܋rOzjҲ:)Ѵش%+I ,rˎ玵ymRIi݇_ 厝{ڷN/Vchʚqz.;\n81]\ֆꧫuٚ8*I2k>!7M[U aW;ڵjRymPȡAtVzN3q]2b래d-AM/b8R*|n=*c=Q%vlq,^lsUI;#gJ430"tWkH͙`3JODwmL]Q8і4vE\Vwi3.&[gb330 '9<~bCJT(ٻEQ82,H>tS.u4[c#RIK;r$ru1w7hS_i$:CQ`dǗsPy@9=٨ֲuJJw_[zgI-P|15N<6*ΚsU#Ej7>Nzc sF53CU]9_M&n.jPq?s9x|>V ֲH&;tTgrIbӿexw$inf s\`C2ztPCg5km(qcU%N7^ȩJ.vOmZ;5ku8'%kF\3 [s4Lmo_sT*ձT:FSKUw" mrOj0ʌ[۵u.ȅэߐKmh'ym;kH6+ F :W7,%+XVZ g7&vf5*v8*{O+O-ghFqU}QSY= jvmoݍǧn+H%O^Rb^_I[h[rb#(EJ.y7OG}l>Y!?ރڶM]JNG.>{ɸLmg#O9yoRhj-4 \J~%RߡD\۴ߟ wJJqZv֜.R=FAnw')ӕK7oCu앾$Vfg3/P\(TrEƽJא% mkQZ\ʵ>m($M.?/h(Ԭz.|W,c{أibYY-nZJ#z_I[܆šnإ){I躘BmV;H]NwUk{5F4i={la%K.B2q>Nlkim:NgSo*N8/68jJU*6޻غ|~WٚFen~a\~9VTRe½8]8E:{FVBp˞+JrF|Ho _j`˅**Tl\c˵zbIVhfAevSsGn, %"?8]sScI97}K"0UqSKV~_+eY@|$_^jykKUsʵiK"Hle!0>ܽU%k9#K3 llwG*^΢Gr,Ww9S\>7m<\( bG&u+Q[Rؽ-eXWqYrJv10u7r%rRCpŸe1,xⱏ4rR09+"Ϸ˴⦗ɔb8nd}}r=:Uc_Npy*vݴͫ`yӶkQM)ryQ.xkˡ{9 -pCV<)'_\V)iN-[aieE#z1= nvqΜOln sm`G'u\XTdRJ%²/oÏZU9~To;ȊHbW,۵sV36iVDc Co!T=FGlI=g6tGB:/2ޑ*^f]7Xj؅R/~SxLs$%ś+n&M͞s:6x5/ \O5hW_`}}{q[SNT\_ӨJmkx{omJPD ǁZӣN6R:ʖ:> &im‘3H9^1QTMc+Ւm_C_EsxW_ zPI6nol\oNRy"՚W|Ϥ|΃cK?m=̤ ~>a,un*sBV|V?fO x5uM $ XɆ$~0h7ͯEc՛G"7V,J,jrQ9+Aԉ}bZo~D2_Zd3޲8:=hэo|W~?ֵ{,dݓu"7o?aom{vkN*7ws{Jxo[uw|jT? o9h/}uлcYmɒq?0^J>n;'*y*+U%XR) t\:ן'ld(Ǡ/͵K %dc;ןNJ3bWRFͼʪ]˕f9ujMZ&)'d/2Z,s^v"P9#C[qpc |72epJ e?W=(nmjG.Mji2jlrF+s+Q)>*cO+4-^6 i]p9zQ%.H.fu*Q:z4f5_&O=ee)$gΤ)J)kT9[NejhEر[{dZ1ȹoOgNR_HԽ5qzBU*9f7?/~դy\{}Ƶi^ECNrjeFI pH>j~QjV__iqEB#0g7QZ1Së?P'Q:tsIyUA{cDe".Οn;o*r2Nsv85݇i-dҌ4 FQ}Muߛb**n)iܞPp9<[?gXcȵoyzrOJ}LcMEE2*|}1=y'y}qFɖ$%nVUt{ zڇsIT̒e2mWR3{^ /4kY^MzSg\jBrjx9 )`Mz_Q|| ~qt[2̛`l XaIݑ.IY*QY8'MGeIɶ2V2\@O\}-No}v-aF?=K?σ `}1,a,ٓ9~\qҼ\f;n0w|m,m=`ѠEH}$r1ӓ}+U'7y/3Zn;#|<. yM!͞=GwSs.E/dKK]U qhw:g#{ ~=69_|[n5b]?:59 ?p`v;}L^ :w_՗Gu{exzTb/H魺mWR(n.Mʱ‹8^8>5|:n[oӡن)sE;=^xtdae+:TϾ0y/똊*ԏ*^dѵF@Cqש`烃\88uN^GEtN_DZ.R/ B!%9b#dҜkF%~I/-]|-Sh/[8T7JQV{;ocլ>5Z7Z}_c=8_;S#)_Cŭr%kFHbiաu~^z}s}23/֕|n]=3oƽ(zIh>Tn~4]$՚f^ǯ \2MoyhuOTM.9^-o4ņHъͻ 'duiK8׌8o7x-hն#+JX'BT^^cAs^= z|r<&|2ucT;En~D+'7 ]ׁ_Sʒ)\tgGJ^i=o7(fC$mb[8>^q?ZXLҤeRZԀEI4迾^>q$Ւq>BqiȬ,c#_EjtU!$ӧhnn$$xo39QSٺ ҅GR}+5h&ٛ#%~`>o^h>V7uLA-ẺiBKoQ'֮mǡQN]X TF8SSTri,m$~6ONySj ҳO,WIWFV&?&u x| ySnxJKV4kSNJ:]l٩˃&cOqDiǝ=h伟+CY')$=y'{19sʝk_Vxn<.Jn^ǽRz 2 hƮХFۻO#~jehZ.4.neh؍eQpgrہ$wY*sRI;|[Cp DvJ'*O$Pѷ+4ҋD#j@ڿ63/G7dyfu\.+?\ycPIky'89POQ^~" > 3L%6RI9g:mu<'VNe}5!5U N\kJ4:U, e[ jcG<=Z{*5Pyw  #wʫ?J<>.jo_}=YȃAιe(U(ӝVVpye+Fqe(&aNe%5'hQIVSx鮧V*F|%؍U mp I+R䨼IӠ5wW7Z%rl}:et8ҧb~ :#SwsjJG%Djyѥ"fM68UTR:0{s\vےXҴi-RUd/[or3ɷ@ϯc:8'"Jת-yN .1#s r524R*V^#"xݺHrpx^ROc)Tk, "B9 Nc5'yukCwpLK.@sמ?4i2OMLeTU$gm?1V 鄇nf]9jM_iYJin,m>[DsQ9W =:OݻVA)TWk].qx<Ԏ_Si*woo.7;a3{{R-4"jV{ri$^TB6eb\qJ<҅s^4ӗXT1S{g_zR'4Ri8Ԕ ca!i^Ҋcichb=SK! @’y?Li]Jlw#7K5ԛd|YCG͌Њ#S_>Av9!rz /nNq\=}fzJ#T|]B̐[,wh}ӂ~ET䋵~GQU-믗bn#]nاjyrkwZJkmhӖ\0?2){4r{X˴FW~]Q)SgDb*Erm6Ը8iYAϾ8UZ^΢7ەKʯ{;1>J5ҼWr dxi^\خB8vWn!ԭ)e5:}r~ 3ִbV*2ⷷ~-Rguen׷*rS$ُ{nf@?cPW#bC18ן*]5]oQֺܲ6uj ԏ&"K_smds砧YM%j =^$fh.j] 9&IeP.|9ӥD*To{ 9J &VU_9=[QEϯo#)Iη,.rQdVU/h {e|w'Et(өomB4ui{Ϡ뻕m#Mu/&ޞA*${Jmrkm|sqGu%*n/"28-ҦQ`j2-5s|~PSuRF2VzW?*D=~)JX[7b=ԭ-J)BOOZ͢)i? XYd=R֭JkFdvv6ȿxdSR3z&g[Vd$.ۍ~< q)~ޤVJvwq{b9Nsj眬]ذfFሮ|E7*x|Cnho)Pu-ʅ;zv5moh6h8ӓNFQ~sJ>ӪrԒRCCN،o:T{詊TWV-Eq43|nej:e̫ӧ$EҪJ.+ϩYnU=4p:{29KR.J Xf9V"6N.6񷨬eZ4ލLEXsREM|^3uRJUѥU5Ķ'gv:WçQEhש̊BݫH6G.8=ʲ]qk us.>w $J᳟zާr=mLλ7fvqW jٹIc,E:4=N=emPg-EomxB]v+N_fiZRF9M$eZ.FN*ѕ.mo*Rva)D0ʨc$cjT2FN>J?Ȭ&Wl%];u7 ˒2Hӌb)6#U(Ђ]7Iun:V9)(߱_mYޥʥC:CVqMגzt:6w,ʽN819NMMl7-u n# j\d?wtIc-͐uTNQR\lжK9DZTSOgq;]BUiH˜)#sך'N99-lrSWФ4mאzS:q>^4J]V@l ܌ҴO]ܹ)gX]Y2&IYsk/iSc9ʭ{K/r \JT`^[AuĶ4 229}OqZEJ1Qs.Qi4wcR0G:HʧQֶ*)ro3oﱆګO_OZޜ}DƏFF{WrV]3{'eMB域m8Oz륇;5f3S&>KfFIvR^=lE8F\=IgzʍooNjUU:εg}ͫ=P b95n{y{X΋o6n_OCm.ǵLcIG}N[SKjw:41f- s#qɻns2V߇iIVfgYʣ$Nl?U&ӿCG!SX5&.N {i;jCw 1NrMl_IKH2HkSz= e`xٹA\Hs).k&o&֦kj2LUn8:U(ԩ~f5+F5N9n?v+ⱔ]8i;^RHn/7s۟Ne{*Q>_tcK5m؃p|̎R;iʷ՟Kjk4jγf?3n%sPǛ1㬶/^;W,(.Hܪ\lg9d{c^mf,;4n;We8I)u?WK67q*O3rhѱm]1_A҃~jGq 1]gY1+zu]9"lr2+6vXd&B44vn=Viѝ:1|_1̍)>`9  yuJV.e3U3vQddRjRw$w'EX==}9K#ROu|˕m1Z/#ԝK^-gqrmATF:i1iBm^q[}T}KE%ų\Knˌ{TdˍUVkwfI ?*݌lFewn(N+3'h,>n{cZDeB Iu?)Q(TesT\ɎEP$X؍ۈ=;a5HvΤce+uc R1hCﳵ\1'?NzUӱ5JoGd>]xI&m*90cG[s:Co륍Vt4iٷ|b5r3 NfԺrm[wVE5d\bBrcuRjJ7iT6sO{˷tKeAcB4BBz\hö{;Q"#9rhXhƢ[!-{lV?1Dk1kgK`rNҲq[u4|HI18HP8tӔh֓޽HO2mU?3 yɤ;RCA7KjcyY?NZδ`V7 ۶V\0o>_zXʛӱhT% 72j։ڸH==yҌEYq7GO Ѥ|Ͳdgߞ^jFO3OcMlѱ/.?/eXFru@iN#]uOoY{No֞JW~$<;q_zTc4r8-D?hVKc\q9sv5?kGOC4ͬt8gA8Up`vӚeoK kk֚h,ǀUZq̎zu'*.5d塇5ed {EZ%ʶ6O%h$ 7N69O)I,\~>.>kƜjI畬%(&U#Z2҈zڸJnO$Q"' OAXJ\*3;%ek єS*S&nkx^X9rQs{#m8ӏܹe}fZ!SHYw:9tyQ9<, DfRTV5zTy*I;2xCnX((* c7 \Ғw5s8.P#oCFWnRw`gX6kU)Zt*+26"|Ʊ*'hOzέ>wWܕy+FJN%F)2弲1މS\t=:-lc91fTuƌh5Y2f;>\?U$#f +\i+V枚.ZQLZP;i9#rx|TM^]GFR72ӥW+nMۛ*QD{ZtjiiYR!r ~Zzqa9$*1^ y#\oe`8?ξc$FTnU30X(SQMXx>XYwdꒋup)ӔsE)tQrpl~f)Ss:NwbWh#_1ʌxirv] +Q2sv.i[ydSGOZ5ihȁcevžn=F?iI=8=?>!%ivG>8?A霈Jש<5)G'k|tڻY\l9.l7nzz 0xSj+߷uxBO^}ë\ ,.@r)*Jyu(z???#q4'ޒV^>5׊xr|tg# Y:єdݏ~TF[[q򮫠٥Źo381nh*QgkFO/+M]7OMZ~جe==G|NeZkk{C T\/O4Zg1­EuW6rtܩa\zvZ\±P¿tNkb~}b=%}K&}f=]}1wm9Ui8ԍЪP]yt*0q`ub(IwvBywtljZI|Syq0S2^[FS6Azrk`-ՊGA'STխm_[➁7_5FEVX 7(q2rG7 ={^Pӄ&x]6RҬV|˅HRCYNN3ֽ:U*K4diE1U'{7˧~&}En-_v遃t5gxNϢFUj>i7emo_H+g{OgW_yr?io/?G)b9\͉Eq[i׮a,/lq|N;FOo9䣃{#E2uot%=N'pb#Y4e+H×F F p^*Qmr#٪Qփ_mr!Ea‘)էNI]j܏IAw>^md"G 'r+F]壇dKWw0^&6Lc߽tbkJT֚TN6Wh]krx_Rk-L6 vx9*"/݂۩pԃN;OZ2O0Y[z^F,/_S5*nt(-1ڿ,U?矡g ʝ][Dt^mv_Kͷs>*y*vwԎ9rO!T?QkQCHTFfi#;m95\mc.hʢK['R<4fi!T}{WTiэ xTvqG hd_ƥZΤөsJoq5nZO2FePq'qުTiRod*xG`\.mH#,{w*71ڜIrjtBU*IǙyx潻 V;X*jcӾ\EI(;-{͝Vag\,c6/GOTӃ孈FխlQk,2meT 9RgKʝމifl|y-">A|0rBwrkSڍ֚o=UѦSQFBvA郜aJFI٭uK9y_V,dI=O)sF;u:kNIvoZhy-9gk$EeϙFI9c_iIEROp#t{(/'rwkJ2Egv~gY Ԍ6 81]:F=Db (.[cn8N1t{Qi֬˔femz߭u^c ֵ=;v^*MV*F%OZסΩQ9{_k}i d޲^[4*AdC 4k̜כnL)^^  {;<{p Nc*=+JE QK=F8F$W=EtFR[yyBͿ=g_grн˴R)% d\TqvmrҦ?=) g!*9%]ObO_Mݜoޗ"E+F02580w>+Z0Ml|[#XHo Wm\68^WթN2{ EEy-yw/F>dvz+-TlN*)]O:ּKoX1,ƾպ߿Qºuhi [;LY~?vF+(˫]jOK[^# u)dc2A8NNGM qTXn?;Mb*U^7О:b >U݇ʷԣJt>4bHْV$8\iu:X>GkwE}pxtk_g+>V>P2zsbșOIo9mZ\nC$W\D9V/~Db}hhž43fHdR9^ Hy|-W4a$g B2:{(yZUeo?SJ;#|Io-\D$fm'9'A1ӧ"<"שNqVvwJl_C6f=ч*btucRnxo4}wFY wWc-|$*~е{ +t\._.@8u >P掍oMZu+SOUӯ$6 o420iq>] sS4Tc).e74jmXi3#NT) { 88EI|˝ /7m?3aլԽIěyRr>0Es+i+XKo"+ e}ȵّĐ[*w\޽kq-m祏s%KW-FoaWNIWa"BM+ia 띌N_7^3;RЩ.jI-qHNt~tcY!{U@0Trֹ;OT|}.wmv~u;oY2Zⷘ4`d21wmkgT֨+l#׼cxlUm >y#9$WZCFާF8|/4[}?<+} e>`9 d3FqۊҤT(iekh^yXʍiJW_-j:q#7}ݸ=@<@#Ԋ`(>㇍LEp_y/Uƒ9 F\!;T223>OFNe|T=}i}y@5Mb= zd#5e5%E<=2rG!@bHSq8Wg)%8,<:M:{'SҥUfJqsѥ5+uZ_yyb:]pu[jqn wn Lr1VvZkoK}V_J*wmZUpmO^mTC^GYg (%`FI 6pU&֮7׷[U\&y[k]Z.|quseoљV7Oƹ$-N5Y5F3rzu?ιiwR}E 9FtiSJOCKNG)H^C>q] %N356X.b}u+gns)T5a`_]eku㧯ԋUϱڡM%gqKtC0W۩'_cF F֩uӹ{iqȒfQs3ۭqN=F]hmU{Q,3/cp-?q{yFmhDVezπU*/IXɆFO$ǵw1JPsr9cZu'uz_|k}7V\q`&ø'P@=08JfvFTTt~yi?5merqeNmӧNj1hݵ]<5Wsum%[y2A  &"w_vb4՞~?R_IUP_k Xiyk _B'2yYMRX$y+rh2nQݓ՜˘9?l Ht<V&4uu-[Zu_S.HZݗxkLrsW9hMjE-I'gS>_y˗!em$C| ֏|儖ZަcBfت6T>$W {I9ve(Z`էk1]Nܐ9汄e{ <jMjXc&Ue-^ERw S()onA%^^ 6cQ8沫[[\*+Iچ&mIT\&eOFm~svi8^ֳӲ)H4,[p-~yylW5T3.^yU|c03Z*rԗW Xniݰm$wjBѳ+TjR,s26c26 \V{߹+J3X"~lN*5SW_e;-3K8S`Rvݼsc]5?}3ώuFmͬ6gK9A{Aaj;Sq!)mkwU_,[Wҷ[NXkч,tkR3eo[?Y;vS9fuiÖ)edBƛ6Fqlc\0<~+o[ts?39w7u{Ϙ?աك^}^iF%ԍ9{NK.LԎ} F;@uo%ZѬҔmi3!1,7w? ʽ8\¤u Xaet.s}9rbRoFsՅK4өzT2wc-R^33.ީC8I!>dm?XJ4k5XK2x.xQ)V}n'>3YTяdj{cGEUlHJ-v4sbMAJ0e ӔR$d KЌ:aZͦXfWUv|'oSҏeV6rG-'PKIDj$UR^F0{s[R$v&JN*!%V%VsX8nV˕/gȕ5DB3 :mFES]#ku:rVFV~P#W8%rFG5hb7:J=\̲i0jGTsKŵk?Z x"0 z{(^z4ciiW$m Oi/e̟֕:|o}g/f`$,rO>~_}'Ԯ4ykHR!G''rԧnr}N:nqkźh 6nms\$f.VՓW$*fO2E6yï|q\(ʞNe'27p+t泍wsB-Yg4be<8ru*W|)hP[$l >3ӟަR:0踤2{[)#FyXۯAj:Xҥ̒8G nZ׌Vt6U*BV}KV*qmˑT0#dz=+Hm:1 8UJ*vFn=J^^Mu3VRծ)"Id 7NQ"hۚH ldt,xsۊj R%MAzG",GOŰc}2U;~OԦ'p7O2e69nxR^*}bka,#,a^x5'k NITٿ-*#`iӕ9hui-)$`vPJ{m9(&HI]/70ۓϾF5/*+ۡZKVRcd۷-x?ҺNUwb)Kv2“U*z^ȸԏ?<V[y vv(e* "4lF$WD%Ij^փZdVWrx\2KԽu,i吶pz'8ǖ[XҒʾPmbxqϿ<EoTkSO~Zkc"ѣkVې 4ejUn^UNboOiF1zj>Qݙ7Ao'eP̼/\N){zt6Ɯb~W1`ry}:t4wV_TkI9SWыyP܏?B^w$r[bIa\~VL*vA#R[k~b֓&|;Z`f1G*CX}=U0̸T,W8\"@>iw8#xI[o.{2**(=+ 2Aүqۥc)6kw?)F'i6qu$+JU=yw:xSٜH&٧¸^~b;~vZPsU2Nilou8y+%Q٫Xxb9ZoZYrYv+UoKR=wUH$̃jTXb1i &.# 8Z)Ǒ٘Jenwl%[F ^+i5+~R,T=KPkֵ[*HEvaCة}ͩ(/躚vnc[lⰩN:>d8*ujIJF&+Z"?̣- !F|1/a늩F*<~gDpS.6iݎ"kzUGv3(Ӿy7}J50c.g}QB=oՈ"o7j[ \{R2mOџm՘}.*j|GC]JW̪J$znAwmt捱 %FCgڐ RFeNɧlt~hC:+دqe-ѲFve4mCVU4U[Y<ՙ*r}hUEz8d+7۶XRMq:<ʓ;].YؼN*#+3ogAki/(jpKMz?SY| [vJISeN4^Ӭ'-,ܬr,kߠ~抷]t2n,:5*F$((ROZ2o{KR+K5e$ՐŐg^kXX,:Q:}7=K#Imγ_NqN4%&eiQv<ߎr1Ւ*[SNAO0.qg*.2pujYM$k o< 5N25]KV7}ϔ}h2Vz3RG,Le;Ӥݴ$xZh[y[`N1 8*N::emYFXY~P׽_59q0E/CSM Uwur(ԡMYHE]﷒NNsT59]=#-]QۙmdWy7|xFZZ]ʚ[^7K̘ i4ҍNp5/s6Ssph.'u\veU[m \+rŴt*R]/.OdO?<ڸV{2 Xic߹ϰ>'Qţenj/> tc{ktLdc,1Ƿ5zu_#qW9a-Ya$@G`g i'RJ[SG % n o Gok:-D4~H>J1匭kfXD+z/aMCiUp<=?*c*9;c֜T{y"&wdrOVR9ag COo IƚvY’W'oѸVTyS>NP>3MiV[ !Qy88ϰ+ Sە{M=#N?8HymjҖG+Y[<BKGO;cǯm ROخn5h;(]=+UFJ-#-?3P5wd9'O1JOuƹc/(__=+ I;#RKTycvaJ眏tQ[SRshiN׾\ZArn"XdyghV}x_r, 刋88ݖɗsGwzm]*}%3e$~-̶4B~U,m8).-IG'jtO;DrĞ\ ɑ kIGfCc0i%n7r1IZfKN.X-FBs7~2~R/674?koL+4cx$}yQuTdNjAסz q1'zcrԔTu5W*fƝ **[yͭyKmԚ0Rzv,keٱ~Oc.i+c 523[̄#.Eu''#qZlWSO64ؖ壎[W{FҧS]I9&榋R̬}m'^1eW) ]\ҷEEڍ`?geteLiRkem76!eQYWz=sQ]9*WzIf(!w 2`QGBRZzXQ.L4?w=u)'}z/hܝt4KKVH#ǁ!\緥g/{=,=:rݒĨ m(}P!eτ͞$ d?8> RSQ+nқVUUqo=F1~Ek:u)ƤՖpq RʹuOOhUԪsl:Ky$UC7^HGBcn3@w JrU Ql8?)3 Zӗ4U/R[O/@*8M$a^ ́$WD\t3q54;dRI@^z7cNJ*qT ]YK.o33ȼaԌU҅ on\G0ie_")c'f=*TjE6䮺[s|(-UR*z8<~5\IݛT-^Ol<k..%cr2'1 oR ǡSZ;_ iQ$v'(WJ=\y%l֞j+hSs0]&޿ƴCRU4щ?25UGa?N{I멼RChs$,78R:fi% %(xƷHok[[{KVdb48]πX]cZRW]4eT.dޮwz>t~o.fa_1cݻjjצ]sR1NoÞe Bd2 qN;+k-O^iuyQ^>|}K[e.l~ڇn ФF.Z61t8:?[].ING̛ߚ!x1{O?:h6,0 y N9Nc[+5o7ߡI+=;ߣ3gjެ:Ė4Wo?.6i c+ANfY}ji٫vKn}kTJ)]-{2.|t{`HP%nG8x'N-Q/K+{ifx(t-ZV^KOo20 0+NP]zbn$}39fcxz|MY˛0*%,g[ß.x:Cx$zrJŸ42f-)#t1Aa_O茚Դ~oV b2rѲ>5-#TG##I G$gX.MZ1Q'̽VzyҨuVc b|ed ?*hµ87)nګ/21V=1ӏi鬉h֦ܩ ,n]z}*u?u~Z6dyqَϮ? Sqwƥ_zM-ĒԬ-maۭ )WZ|V*Cj}$cq!8#e Ӵa-/ZsN݁aKʔӍ5Pi$ O'`Ͻe⦬qEik<%bKa•7JӒ1w۷S1|d[6q1F?{g'br9\>ҭ9)QVב"b6dEs9{Uke*qnz}ğdxT1"{v*\e(|R ڳN#1al`dV^Q*%-Fkhг3o?Z.kiԌcI#nxT y>i(NDr˖y,P-Gv#}}NGAJN5̪*ik}u&0ۀ!V.~_vQ5 JA UX33CG|xa\U0몹8jtn ǀI'=a|-J5OשՋll]3U?#\zm۹ߴh+ c67yrWs:&-KE]uU+-Tw(w8ןzzqb^2;+WpB_8'Zdo%vv!O%@!Cn5*Q~f4|]*+o镚2mVY~R8<78SVsvViRybw[[˺3kFʯ?g:cF]XNllUN ];NZ?+w*,_(܃\ӭƪP(kkc!d2UfQ۽{C 卣SUhݯW|k쯦s9ϭvSz| O98Ҏk I<"ͶWb chP#I d!Y9ϱVI]۾m'# $m_6۫Dz4jl(`@Fz}9[ԧZU%t_aIBDH$bb(܃ӽuTM*ҩNVDV3fiTaI$sǵoFE/FsaLGmu_D#;GPvq׵iB9u'}c2"a5.~E$޴qQr^ޫ˹^8*3չw}8yܖIf%g!m&WvjQ抓ыD[۱  |Tm{NsV2[_q3.rn(+=LeLELE%~l(]Hi0I>ץ.ڻw>ٽ tdvqq1_9?Bkʟ3v5NTI>mm-հ$fVN j}M^ziVlٴkUtմ}QRL/͖Wci}ާeHJa}m,Ld/\U:U!cQƕmn[aG֊ДN8u*z\^ʒQG"Ġ=J1\<U'/y/B$I6>߼rQT\ǩN\nm)HՂܾށXwҵ_m-b9eF֗Ԟ"r]ϵgR>V׌)Z/кaF;7dV .g-WCb[VjWwϻ>i{KWЩJzږh+ tR|Uԗ=WJ!urzNR'Aydgܸϗ`ힸt;,A#"a1RsC%{6?0#lZB?=R[y7W:qEG*.эu{ЦiЭ{V߳.S5'eQSNZ-m^KYpGJUjFFPNzkO gצ*j5jss*W_^&O*Hwnb{8OALvmSɕJt~5YHgocy7ﭺ {2*(sdg=*Bn)]jSR5_*KnöciMJG%,tyZoIExb]q^ڤdѭUbi;6bk/ge=j-䬍+ +Pd``*樣H5jXJRƦyMʣ气yS5iF'W:52KZ^E-O\8Z& B2\~'5e*:Kr^.:KAa:Փyu"ɻe`F? r+J<]S^mnBK7+Ԏ5eR^teJ]>G.-xk7UӨ~f6ڲ;$8皊iF6J.KL~Y5գ26YZEv/zNIgN:R@Q )cQEL1!xf\׮TWFz~-Cysq>NwcU1RhJn@*A'z)F6SMlSHh-pVU2lu6} n#9!5f,Zތ#RI>_XԌd_6 ۴qϽtúS|U=7$<@auf=kiK߱9s.fn==_B8^Fձ gR՝:14m % w_ge8'q}T#VZ6/Iayn_݂pr@5M:y6֫iZ9ȁWvz))ʛ潎x: b 6ݭ]}T'S xFZuc^e*'׊ѳ{}IJeڪs izz1kGqkNTe̞{믗oB*EfQc:9tԈݙ.$@ 1l<-J19Imث2<[cf #۾z5yagQxkԮ.:e#'ќyFUe-b2[v{V:;㇧R|AYnVʫu89W_o^:ކ-n̒Ĭ{q]nn{?ԲNlzQ2>⊲KR: ]αH 9UU?cO6M_]eClGjtJObNfVӲQ/]T7%quQáxvǙvmzcze,:vL,vtk<-+,jXv c8+(򛌼\F){ԹSuzs<(MƣWMMʞ"ius4z[&VFU^ݽ?ʔcYԖ N6荟2?uk EUo iGh4ԗuoO2е$uY?ճgԂYNT7"8U5--`2+ L kT"Rwˣ%;z_ȯx"lڥyzs^MJ\݋ۍsI c1c=H-5e1Z)?T.leVqޜ.f35ͭVKn+tb28Jե/r~{PFl#2YH d~u<)^W"ZZJ7P^b7[-NNIrӳ_ϱ$Tĸv0GJW,_cRd-uё#[3bU߅^}֒}W]**niKЍ k,=n}\z?A oi]gv 9OiAثQ($ޱú?e$o|ÏJtVJo *Vנ'ZhfȹC;G-\$LrT6W )WR>iaӧQOܝe%iƴJ2kn'٣e2F7n+:w~>Tyw/Fr\]ēL+nC#-KpN2]y1Ez}֗fY *f2Cr9y8t~nm8i=Hdh/y&ornE=?ֹ1?2t+[z"mphXz^A+:Oohk+uW [M:&r9ہ<9'Rw/ifJ?㮧U7OZ\ִN.`܎HZҟ4] e%t-'ڔn8$b*pC-r0l쌸ʇ{zuGkmd *Wo}Ȭ 8彎S"`dl++c$9#'-A4Cf#dw9+=m:i(BՃEfW&s֒'RrlT67R~aqZG]4yc$B1ʩ,a43cUj0R(UKr]4%e:Ei,,5?/mkRUP?.:6$cT-N*kl 0W {]Ӧ1gds569<;޴Qz2߹{a52%24墅 w w?tFgeB26[ǿnmD 9NM=cg| ef*zMSV3mTx]XC(=͂E!|dr15Ԕj)N<jYJ҉# g3kh=}ui9b=^[QOE0d xNqXN50|6o(;7R#IU¶0@<挥 35LG+f@l*!8qzqQRVRU{n.+5fFܩsx=0+sS,(bu$[aFgOvwsJ*[:Wij(^Bf ӊJ6DR` 7/x6-X*нr6^gͯ39W[6fX$q" [F1~z穯JR3XӣFww߷woo_Nq/һb1p{r+Ih}׿^FE)Щiat&B23Lku*+c le^>^=dnwT9ZWv ((;k{v33M!Whbi62ÕgSH㸮RRwкUN宍f̗:m<[Xvy# 8P٦sK {.icio_Sy橥6yԣ=bXFa+^Ui~)n%Յe#:͈1֢Pu{R}~"h+!Vr#R:=nY?JIdݲ/Lt)Nʌ̑qҹeN6.WTGbe9|U+4`>$mׁS8zFZzZD/6Yь-jԍތ҆~"x-p)7}N%%KqNjniiͦrXwBYA:)FhL2|sk.1 1u'$'2ewt SUJ|%u>R>@N*2Gs= ;iÓVtDiѲeOO9{THFOyܿaG"8YV0B\o׹z.?*Jt)([nM6sP;1Y:*;$[(Z4KűkFW[Fw[k^E~I[swfoq)TeR璺2eyWpW>#2-B2qEDwLv5$և=J,1L~hun9j5VK*"<2ZԛU ٽ3+S&[ҴCS -gg5F~}L4ߑѲcjga)TaR5%.E0ˇ ;F  *2֨T#N+"7Es!CsiӲfR:)hE{{w_ߕ'X.yOz8j|t߹BvwFvl7WI.LjF)sio5DvrT:aXuByK^]zIxq5ՁmbguFh8|ٵ8e%ղ偎~l'=;sԕ{[O9s)([O]NFm8fxwʼQ)J]OS;<\3e}ER>ﺵӲvK+@z^}kRԇ,T$Ee/4l=ʸ _ Q9b3τ/6.u\zqVSmy|GR V|KK}FXF(Ar 9r"1若=5RPjP&,cPۤu<`֍()dt:i,gIr+-5浒oV6wPppԉi{>n}zlzX-Is_V1+r8>^p1?ɵ}ߩƪFt}qVмmeAo{j2dV`No# @==9Svk1׫){:Oo#k"<2 ?ReԖ  * sGq ;9}lJΝVC<wDOcx5Y4;60ftэXFv8{*bۢW5 OQZg{|39's88\.r@YRhϑvmvoRhBd=C_Ubա!1.J8$H#x0kmIF"6̝Zվ:Ml4rdlj3As8ka㌣' _Bs]wsڷù}װF9:f_^M%umE,eTJ͝OY. z/pzOWFcӕ3Z8jo\DO:՗lxW<{7]G-voo_m_x{ž(4$tJ0~a| gud~31xaRi;_uGxauq?3H݆zQǿa+UhԌ\/奎8x{:^ﯞZ]\_GQ~I y"XxF-I^㛔R^꺆ahi4RnI9_QjV]ZrS_ӱ]kZgCB՛ɸ{H Aʒ8~SGJ׷Xʔ}mz.j_m|U>v_-~aޙ}S%R27kwM 2&;$W׉1*~w-6#"4jrt]>C RO;u]g㯆q lZxOB2G͒w䞥3\XӍԩ}^?)jr^}4Hڦ$z}ZKO^N|ݹ:.{y|~om+7O>+k7$ssTKY[|Ί\z~lmtOLWyO՟_Qu_}ej΋uү^ďQadp`^..gR7)\؏vne>s$L*#woMBTjS k]-~V<~ut0G%OjޏyˉHFj`NNtG='ӿf&$v7:zoz{WͻΥWN#wcq;Jrݎ`{\ V8{iFMqRmsC 4kxln YEEJs7){e)NE,CZO&)i.FɑG?* ƚsZc*Pmw]͏wPlGO|&D62m]xG^pz7%OuZFZQoS|=jѵOMUK( az~s>*Ve_4O2ƻ{iMg{HN#:^Au<F4IVxNXZ˹.!.|\)^>r=zVP1Vz%d} 6!Yr͌A ${8?~ΉRS'f/xZ%em`5 0^̂23D05RjomኡB׭bx k~4gXOb>R:FQvۧSN2T֛?|}C0GV\.]n$pcJJwRQS^IhOmMX֭] KYn~ud<YҥFw~լSVhyiZ'`K&q$*ǴaOygRu9+=*Hil۾l[c6^]nuQ0SWg?%4AE^i[ eMJN4G++}ٝj3C"*n~k:XO#]VU&ʶګs&k:rA986eRfދg*N;h,$ ^ q>f]5Uc)IoSϾ ٤Ym#88]8斩lzZm>]oqM}Av ڊx`tQs&m>sL=lisL hToI!NA r 5\O,^7ISrT<%-X 2c㞣RJ3NO5#I;N/?jnx|%r'ہ}ϕj%ȚsQj$Ҳ9?|?V]NUkxxč<I8ajޟMLe7MOmc:? ,OG#FŤnv*3]%nu_&\A[fhm] {5RtuO*nRM_[s-*, c{_ƹӍ>1UvsJԗRᐘܧ AU-N6Ѿt*Vzy [,, NTes_L֑F+JN5ӡemcHP//|C0Wr:08Eq(Wv]=K8~3R ovls}F E$pT%ͳW4>#xF4G$̱YتݢbHaw cazz8ݯcl%EV$y۪Xۂ?}[^Zj3}>(X-c;Ipa_UF y%59̍UVwQv]g; 巍!lS9TX#Q#]`V<}kgYѦTz[Б3vT1%N)DTۛIt)fk&6eyO}+K{CR.%rGadsVh*>m#ҟ9b%+LO.}h _HdR{:(ԝڛS;I獵џ _dU-uvf o, .98?ʼF:"-ӿϞ)RM>}=omnx+M6mErHg\b+^4ӵ՟Rr]쐫sȾnn!p |ɸ#Jxb%)_5(K9>m0 1?_9J4'~{+3#|CM֯;W]k @ltS{攣iYcqXm{XV9ga#22z%WSSV߭u_wa,1Mi3#}ztJtiBF"Xx ]:_qMek"26#8Haׯ'ΚUR :5gݻe zd.hϳbsz9#;R2tMV )k:k^ZLlm3D###Ro}u_̻H-ϟ_fWö+rd69 {x]yQOU'W~t%t=e6Xz`g'QK(֧^.9{ A^=ŭyoF_*e1#'$vGGV3Od{we.fZJ_gu E>omf{v֌>#93|dCr5c` @-#9"m:؈&zXhf7*}X'Yٮyu7099 tR;=J)_!{r~|1nנwѕXVZ]OՎ^.><0|;m),`k'lMYcgҿ01QSrm_gbTݖo[VaTOӓ^}z~v[?Rע:វ\Ub^>l[ ׸OFYN:77ͨ$Q=ycc8աkz _,4S=ido9ʫ=yTl?Ŏj8W*vG V}YZzdԡ|H,1[vp@{Aӳj(OaUNZ]wkrx#9ګON2ݟG=r:kηH8 <Ҽ{iF}R_bթ[XHTs\u6/5.E?"wlOXFtZ0dW׮5 X|dC9|q]:pzߡ(QKWзk!zx"O6ۉNuZc.n[[ӱԦ*];Ჱ.n10˜}: )c)YU|o(pSyZ8<9ՎQKm[SZ۞ouGtɖ/@yU:v^27O<`<tqƧ˛ $(TnS:iGVv-42;q[9jJce*qܥeJ躒H>ICrѣ' ZQ*.˯<׈}ImumCs}pGrԍZ~Vgu=Wiiڕd% a1eJC ML5h7 WzjYsXҧ%h;[sQ ^t2yd7 /BrI+ܥWJ:z>{Iare7{GehBj-+3yv'+Nsr~ d>IF}OaFk(iڵMȎ?7'90=Xȩ4̪؏aE)']Z_6mѪN?&ikN.kܢ|O[ DVsŔ!H zrňOY?O1^<]&޷Ȏ1J.ׯ+=T׍.nZo$UO˝ԯ7Ɗ[Y nȂ6V'R]M~I;:ǖMKn6M;"ZL;ZX 6Ht=+o9JYw8[9|Yyc8"PT.h;wj Cs2,EJkסBtYi 2[ :xKN6mV*1mk PM[=ӂxxt}BQek+Ef$yS& tYCJ];o +ma'OUo_Pθ$dF'!1HLFVr7ߺfU>g p:QJ4Fuw5Ϲ 4fݿWgÅO~{gVaIFY yۜ)4ʎꟻKcy\eSJR\ܹI7( ǦXT"9VZ#b]Axr3ұI6]9Vҷ\M ~DWG%F# 0r3ԁYԍ;[US&1Ѫ*8Ν̪p qYeЧml{XmV$dus^zXJU$ڏmMr쑩)a9St?sFQ\*qnJUUT13ێu?E`7,'[ Ehٕ81? QVJU^m% ll Nu}XI6zN <'G%\2Gl~5?iQ_*t\嬼VZf F @"e)=6"**wnIP jњ7 EȈ9 Ҋ啓OuE&H"iѷH$@oEgRPVzm_W,dzuU(֯gńLD9K\rS.EpYY&hVc?mN7ETk2[{#m]y=c,?*hb_Q6%y˵#,ӚrJSoNcܘ刍ycrx}Nx8Z/魬Y= iy\qg󮈸TKKʏ$}GDzu{TÙj{:mmYǹd L5E{R %[BC2c`Sv}xririNaUFdyq ncve(|>iJ y^6\mc ct9mgY+R܇1<~*>Ѷ_V#X?51+MƗ-K^+Zpxߞ$:R;9+TRnne3n;ʪx.MoNjFcR˙.[ɜ990YO 8Kᶎå@cxs?Wr:{X|.# #8(aN]j zYbkwd(RN¦6 8YȎXI1ۧ&ݻP0"},Leɰrx-Ҽ!Y#]b9[sm.Τve^qjؒcʀ7T~TWA#w$mQf~c<2dbvvQ2ĩ+Eig;h@k7(ś-8h5lU*J-{u-[)v Ol`[nɄQhhՙOɁ~k#ޅ7Jzщ")tUd {H=tQR+YrT:*;2z]я.26`H6a`[<)KɩD[)&+h냂皸咿SGyDmB\Xq}zУn.lSyV/y|gx5lg%j}w!{^%Tݷ$.?ʴeШʝ9&o.*cgD;_^pzT]XdekI~FUp9?ZJ7ˎ*1reKNGV S;MӍj{mԫ6vi(tg5g(2O5n1Tssj{I4NRD:v>fs҈;ٽ{zE]Ioa۞N1#1%nʷwQ%Iͅcp?/͏^w=婭:m ۻ-[&^ n͂Ú _SV?"cax>p+j֖FAoCSKk6A#Zt4S--WW7v6U۷ϒ̫(;z\ܵ9#]|\kUU+NtTjESS$gy.f=>|b:{WT*(FnՙkGy#7n=Tj]ݬezWn)ۣHHsr=$iXօiQ_6H 7+`c(K[o,T([_Qu[ª4fČ<P[FJ= לj9Gv24nX_-wEJO4ޥDrYEHJUelgHԗw5{EYmf#5/#ƞ!F%("4mn}k9}^[kTiB2Nw;de z\RNJTkTs1yuPzwZYl#*rno)8>m (u.y Sֳ|r59+͒ķo;Eq\=k9{>^h9hmJoiST[R0凪~# ^/79')T9]F/gn=[O_1OiS:lF^VF٣37xEXFXlG-Iݎh:3Tгqop$\= %R[̥5w$umU5aV;}m%2$j~mk%uFR4-$]ncg^5/dr¤{X[ Ta4`ƥ[ʅqxkADyx Z^.[3 SfdKiỘlU85bEoF)dm7DVfWu?δtR*V儰KՏMy#bl>[K^◡1'mtɵ~i} TN? $ڗZoD8NXES-3 q\"쎸EʓζŊε9IiRZb Oy,I{0ud \5q(XK3$ǧڷTܞZo[.F!m,:үYh8b#*DuC%hx%U ATUQO^捥ֲeQح}*rR<4eߕSNXNpyx5Fիbcz4BXU.meYX?g]Y}x*:鯑T2|Ҭ+{qqڶ^1-jgMmM.HpHQ;koiNRCa≯xTcu M^,Tu-6l%F#+m689#zֳR;9Զ.Zk@ِq{bQ"úw߫zvnݹȪ ÿ<g?$p^œ F5fMo*Bq^)rȩb#(ū6̱lZUvݍQkhT/C|Λ؆]D/uQpIAOzBgӪ~uHw|1o|uN5-9qU%NQKMQ,oEq2t58Ə'~ѭRѢ=7jr}NZnjҧRwwKx$4,U8cd:ε':nwܼqk$QƘY[GL}kˬ̜:/nmLEa/̥RE8ϿQzzChӭݺ+||6'>s=GO4mLTpxn[jᏃ*Mb6N69{| 5񕓵 Yjpgg}3Cq2kqg=O4n}/oW Um~ōk"hA;󓀹#߯Ly5u GGNenoci{mZ=sո!W3_n+iÍ>GZ(# !O?^QQΫ֭Vxm ͬ;[yiF[5b~<Ѵu;vKp}:fԚe|cXXfn7skFU-1 EYYdq}eӏU(1SuՔ"+7^/'wg-L`pUg:GNgFL5>U7r4޹|{~Gں*J)FyZ4ch0c~+>jj&Ĺ{բqqe(ԷwxkFCy䅧s 2foԎҫ0Uzylm+ahd]6|I- 抓JKgȾv}mdЪ*5-2UW,+:hϚ*Ԗ+xx>J~<͕ӏ<q:κ%3fPI9I^6eV-HΚnu*QuUh_e v8҃×rvΒ#3 ʐzc<.Q}:0c-;`7ds+:{"-ê|7 7Թi援$h3`l1Ž;`ְ3iY)-Mm|wҺ'dt$Q5mFu8RVchӗ+Q0QUE2I'g:L~uBޏFz4c3 q-զTr %x'}y?ֶov-Rrc=zNr+ZSܚiUv['~uycSDq*|#K=ė>Z HVJqWV)Ÿ%ORb xC(rA~U5!)hG_?11o2HᛞZPoKsS|}a^Oqz$ ˻T0lGP35JJV0x*mBN+SV|/VN'K mU\yvC R^7UW8bAj-alC3 *9nzc+Tt&i[[/_K+'ya6lXMLۑdVH`02X#4Vrw᥅$Iui~I.[?ߴVL i!y!~ɆX1 Bmj5ڴ.u-Vv{nO[(rIkۚ25k-ۺ㶾.nu;UXۜJXO Rc.Dnnv[}e)F)6}muim|@w*VhdPhc)P:'p:ゝoiijݧNl~SĔp5)E-wv{iZ-S:X&V1'1۞<{{ 6]VӴ3)%1#Ȩ_$^{{!NJL>)wRX2ǧucNI:P2(یgWiVɄ\sT+\ۼXՒv yfC+.Qw(-5Bf 'T$hCH,<$wڵymNQd2kXq.L֑:lT B@[Mi4m 8,$ΜeO8N<,  +6ܶܜ }j=ڒZ,]47im7t=i-0 7M9GϥgR7} SQkmv6K" AqtF ϗ ƥIrAlʳȱ1ޱ{~Qk;撹͈ӥPWB)!QsTwyv+E5˿TU:Ta-y 0y%d\NTS9|mʷeԨ*=FrFQTofw~)r>NKJo!+$ggLK8dʤ)qA|+6o ޢ_:~?*tݓOAea,i 1ӕ Z§*ᱟ5JK- "1|鱺us\)$2ΰ,_o xT&5>dk{X<ѯ&tUV\n\g=Fn5+&յ*A.}4my[ckIq*jC+6q*N"y2-Y8=zzWE:0vY=|F`v#G`{|zuuS,mӠT]y8$vuTFsKk[ɌO #giV%i?SW.~hHIM==:)rWSiя4YhHeHHV_}OP4:#FG{vW^D=UJ"]Y`*~8rAkyeu%.XċRUm*SNNSՖ_'νH֏r%S$ɰXJ[}3[ӯߕniNӯim{2 F #Z&rzzw˗VvVq*hĸ6*7̧ ={VkJMyB N;3*u`ѩe^x\}zjޝIJ;'YI)7{9H}~Q{n-־G xzv Eeha#$9٣UKOA]oCjF- >_5>f}Oigӈ-rw43^}Eh%*Z[5<6 keYebf41ަip-e֦\ЬlQݥܥ[ wӕ;X`sFIG?2Η42+Goz[o*Jq\ՔGTu%{ѷ/]HͷI4anobjXMꎊl vW/{-IQӪobixpŕBNU#g嬪F1V#; :kry\$L1mƶtR-{WJj7 .WR?&psF&o1ÿn=ΛkkNҏE-20VnwpqOmw{h(:+n|݊V4\pbk`<.+ʤ"Vwht ;7ѣ Uy{;]=Ɏ|'HlכRO tUTl(+2NgUٽ~⬖yN=~iʭE[CG+,~_Y^Wl㜽K'T9l&!:eTP.ggYvQ]l-Zm*}sjZ4&ekg-q~*ʴzm&.iJTXYLۨ :ӦE_O[\aڸK[wVCj)niʧj]HȼQs=sXISUtOU`naUoC.nzSԿen<ƫ w^kJ5jEu<:;1el}+)Yl!ZU=Z&k2F\+!F %0*b5d/4}ߛ'my5.i^՝:uF"ѓZ;= #AB\%Ll̴蜰V*vf'hmx#QVy9c_^)֎/ ,ʽq~rʏ4X]rpͭ2{)>Β=9NqT}OwDv{ĩ7,v1aϡ湣O̰sUG>7WI,Z|Xnv΍)s8;Ұ-,۷m$R*|dPrM) G.wnݷ׭5RR ժNNCbP9%t1M o0H\wvMIF}z23 v0oP{Ono{NڍOTMm$rI@U߈Vѥ7vw2+Y$_.4b\ߚS售.y*iiXkucʑ&تi۳˶z7e|4zL4Vla}ծvFz|2@鏥pRqw2OeQkdɭq4pH)=OScͫta%%Ԫ܌ Z2\ӌiV.nWY˴Z=נ5JPv85S [y~`byob+!SgԫiIY"̛TR}A56֞CΦ4NӝYz GNQ[Μ6˹"hm.6$[N;(=F1ZԒ=8ƾeltp@ͺr}BQ'MB北4 p\ YVIK|s22;2oD*eȵE{7slLT_7OB^,!kȀ#[SR}p`$T 1ǿZ9|2:RmikHRA{:cߍwRqt.T)CFmYRܪ"7;zuWaRy˖$I PMAz8k.VmRxCre!~*N=+XRƑGA^c4$2<~+ ],*/: "]T s_vܲڶ|唛SZ2tmG9VRSb8Mo$c("mN>vECZ8_gxs9'f,!Vfyv:]6y+,\y`3(W)VQz3+Q]bj#U0ˌ[B=y)T~&!Kx,D1+J1u=n-仱n$mecB9xN)1w_9sR-/S>+8-edd73EINVʍc2zZA#ʆX?NErިԯܘ֋$V]_pzPy#ҲvqV(sڦȂX.L $vJv۸hߔI5 *$F`#9҇8ɯ1 7ȭ%6Vq x=[{U~i{73c4f*0y_qksn'ӣ hWZRg-BTqMGdgذ7߼k36AkTF-%",chlDf//ŅO(9̌9FNZi$l~=ʝ8޶>[2e\햮=^' Č9kڟJbGxinݷ8<ZV7%ʴǗ )[BHa,2Hf#5>dnzuV֪Woˍj}^ۙribH9X9#;[oSITcgc(|Ո᳜qj;ʔ%}z՜)^`Q*zS{w_>ޭ5՛$q֍V;93lzҔc(rzp~Zј֮Ξ˩ҭYν2GҪycþiSRM:'OomSɜ̼^HPl`hTurw4RW^]=k|. Imu~!K*7dW,[5{֏Б Ժ~ΝұN}7.Y8є5Z%.W-,G*e8Sh#jT }-R@O))ұwșS)2vo:hZZ2˼xvivoUZVN7+0ڜѩS{oȽcjTJ+YF*%RZҺ߷R1|r"Fm`(bhi(ۦ܊K: Uc=^dTe}Ԋ=y,QbUS"r2Xd 󎞤p8Kzb;lQ1 ]*[;cֱ(AO<:ӹ{J'ur9_%fm־SJ;+2I^1 x ,rBpzJ­"׵̇Zѐ$=y}?{T:t3*҂rHvI%9}u =½L*3H֌c*umE̋/ W^O7Ʋ8us6mN,X:89\r#9zQ(Tw:1tkFj7ܞ& *rq1vq&qI7Ɖws$,2|IvG=hrqMbm-i,@⼼W竆FWo~;c 蹑6bq*I9=qyUcWwiX_bF>caftT"\<Au!`OG`r=+R+l.ZNfrTc'qTͦVI'Þ60ŭڪܥy;p:L׃4sIajsy/t-gLuM.ͳwHw0`zsԎ>XZu-]uGNuTmFIZ-oWL~ $Vro,D*X@ GeQx&?8ZY?o^gW6խk=6̡$Kx8\p ic(QqZ][zj|7ş O_a {;vXc`>\;7]}LDpx:&|G-?Oxcx kJO4x1? RW9NxM8-}}OJVPXژ&\r=8'5eLb=]3$[a5IL`d݀#h{U2M^_֧jXPL?+;OV9?giY'z jtq6N۫_ѝu0!]Nzi -u95_ \5%H̥O$#U珥y4Z&k2oؗğ oh$?0 ^i;s)r=7 c'JKp>?g T&nѯ[T _<xWEigDp\g%dvStC*mkOiK8ԧ]hו^ )ZF|# ܤ cO%adѿv/Ǖ{|;z= Zmt{'Bnl q[F\OKD\vǂ jZ լ2 '!`Uq=jx SH^e6,|xs`p}rztM_ȚXES|3XR3yxsu\pU_"ZIISJZ^Uoz~jA[GQIjqΤ~2㰲} uyq;n=+ҥWRћo,G5.켏.,Zi-:)FwI6'9Ǩ8zPgM}csS/Iw]?^s^P\2ws8aw)JZU^vch}kơmu4,pRy2+5*֣ڕ*E'~Cڮio79*N{~IS['v|c#%}fkth_ SC>^[xr.'%5ܰz0FG?0=TF4 >{(jNgi5G$pw3Ƿ5vm棏OO>OgA]KTp8!1Ѱ1푊zuwꎨ󶤹Vߦ~17Re弓+[G @̤B!Bpt (Rzv=,Yhwr!QquqoQKɜ. l1=d}4~[F 4W_.:oOoEjIH.*r8U0>ҥOMiZu#vvo[[KZQy `W 'J(=տ NzըJcM;}l$24~`` xaVNHIѷXn62āR^zZt.?KY7oKi.0a^x8鞞?Zӌ^mj~k?WK1s%Hۭn$Vq'88ĭ)}U).s3Wz&-֟r$]gd;S9)iVThԋs[gaU|?ԗQc;x9ϖ&_߱:<ڧ~yۍ.d_"c<(@Jn^\qzӧNz|g1uc+LN٤fDrOz֕cM.r'Ԋ/tj[_r^Y&cH}r{TiS2V5#%wnkg#z78t7~Ռ .~jԵe؊9E?{yJ7qyA׵tӯS7=%R< |S}Fi$")ɓ[Nt}kF[knx$X}32rF}9+O7tӕRTo}~gh 鲳m':(7u%aNX^z6|Ee鱺F9VW[n0Jx%d~Wi G!Sc\HD5V2e*_VQ]Z$lsd1nKc,_}lQ"ҒKfjLprkS9)E*xMsh+[H]x<{s_cVB4AN/^x;B}:(a}ǩ׀_";2vʗSםJu,z\.Ϧ pSR[/j o$\e{V)TU}s )k^kLO-J|2SQ]N۱Ԍgu0>ǖֱi/ڝ6zT;ے#ʯ3Wz'oo_.=˽e)mGEKWzY%~G j]dof<N)}ϭ-OBGM)|GJ/E$ѲM 4+| 2Ip;F8ޞL(Fmkxƚv%I ,x-ܓWappWVi?ըSѫއ bVq}*' J3gf"C?2Γ42N]jۈ=(ӫ]V-58p6f `rG=y9)Ѧײ<\VtRJmi۱hZևȷY/GAcYF*:<˚[V=~1O%;nyBAR0+%tޭ}PF>R:|DД,Sݧp`6۲~s_ISnQi] KkKY#¬9''0q+CW?Z^ۙM&FZGrEYd-߃Bt2~푶Ue-^iњV('',Lqj:3֢ћh~ ei83ʒ^9= #K K:qm\ YDFNF88ـJmih*-{ԥ I*tf=xSQk[z8 ٷ à3 (Jd`\Kؿ}- ^[m.v?۴cjqsHƊM9QM_ZjFdAgV*ʃNOOJ<)%Nĵ*k.#ś.%sNAc:SSwIotc9^Ahfi[ ;zpW޶%SG{z[hv/[:fisVbg{~Lj{8w[SЭ[ŵgZx4HlQ+Io6$QG'Φ<I&۲G: |Z\XŌ%K#KqpX9aV ^uN'~2US-Z?5KsFhFJgo?}^8|-<*ק>/ ,$ҳע{2uIY&ck`cs؎?fiJ}5ejahM n]>F_ᗉ`2}?xRKgFA|#07Nf{m3Oc_E~:4?hUm㷆m% ׽ynhmw9 "]t]HcYMMM/IԌ#,rp ``Z裕کKKZmJQioukϋ|_%i%ƤBh'yWAp?iOe}-JQc=G]:ۿ: <hrINFGp;2ӚG{_^iEҶ"hvmh~ɾ( ,-vV1哀$\rs@aNJO;GqE>\OmowbӐj"4[/80p}+ǖZƥOiYǛD!I< Zq̟+6@2 }FA$Q{=8Ԍ:kZz1{vJۊy<?ih_sJPkTOewHa[vnRJ; t5X8{_yZARrܽKs.C{41J 3^,W#w]:Nubvۣ:[7mcU5$l@.䃴\2NԍEμ/~(]jZόM2FIϯ\eZ.}l!MEYYY/a~nd6yNz>V KvZXҝ6մCjMn;y3ZH>m(mČ;*5Ȭ[F٭7}4o[P" dhVtgv޽ֱ[zTypteM.fֽyu0㖋z#t* ȻK'vrw/8JGz`.TKY>abMJRnV"Z8V;Ac$c8ki)-,֝gkh++mt\}uln'[$g' ߎؚug6+HYF[wױ1]Ae%6Bo\/^kˏ-F_>RԗG#ⶸh iRN̬%ʜ$A8~2(|N!ӏ}yu($Y!Snbwd|Տ['S2go|A;"{?Gᗺ zڙ78 Z7O˕'+\ju,{iM_>nYc⽿S*KMZWfB_^%O|N#rK8އʧJXx[*ֿ}-r3t)SK]\"G"gB:z#E@@w$gȟf~IK5Wk5[ںQico.bJ~xP,WH&r\凹 <\3ZVoEتN-y(<^z? ?_xFy7Ϙ"n,q*Sq0Vr5%ʚיG=lqARWeʚWݗs|EO-~&"ó4_G݂#0 qmhΜu^kRJqzizi|gkwQo*p͞dRuԥN*^-&he䶒G_2Ue߻d? j`KBZqʕYr}H{4;yټ[ 5id#JW(k|?c3χ )1\|_zV14iJ.24jFOvbX\|rp_9 Gke+:79۴-3>xx5GhnJ![}߼PX /v?`k'͹kTPȭ㸾iq2_kyB15p҃J۹lJuJ֒PW_ѯz2żmDN| R圝;{!m#~n}=GWq8+*SVg1JU%uڴ#N҃ӿb틫=F3!pK7 PBOU9UB8Qa%)ʜdY'kFP ~GiEIS~M2d{*(eE$LxiQ4B&s_S([ȨZ6~nsڶeMR\ v(Ywaq+K)2elY̮ǰkЇQNoq,vr۳TDyw۠耼f ̊F{bVj5ԍ݇Z \aU%kq%){f6QVi-UyoЫޚlJf7^=p}AEvB2hוrd!waf{sˠө̗QIvo }rqһ)pttӒؒ_[M~Uq?2{G/,huB.ڶHZ&m['9n, {ַ} 6ڬh_ ) m'Ue̓:cEšGP|s㠪Tv0|ĦqkʙHYʛwq:1֖ԎA Jk{)l u$zFo˞j1)v0!=jcEK2eN7,+p~݁&1nJjڱS I=@V?*iX6N+?uT#܆\]$1e{?yae9rʳKϧIm**Uݝ?N٘J}ǺВv˙1$NI뎕0KS4Ekke+&6N;{f}$XVۃ6֍r>Ea(9.O|ѣojƺ}L8 ۰{g(iԜ-6N`uc>zrVomMI7}EEqGn;%'O^]F*y#N\ܩ9Roe1dgvx>k(crwR`\ ¨05̹~۪* US;zþ+Vt:bݿDk`~FNPhI[C 'lf@&i7O|ս5.VҚn!-;Qs@=':SiU6zrs߰W՜{t*M$>lֶƤEKtuk.IlV=y=Oz7KkP2B$xىثn)Ú"ͷQ.1Z^CӔ``|Og(N[Hr%%x)V<`9QsYQVz#4>S ǯ©T\}{do-e SAܑV#TeN52wmF1kHRw5*Qn-}[u#,N}:qG$u:EN4ȩ&k k!*>]<۵\J1浔Z_LnHmfhn w}ߗ98'5?wi+q\ѳ} U'~֐[:f2u*2uI^#r2uO=Nw{{(j=;>ݫr#ԑ>uRZ葠{vq?ɮ8((ӣRRRSԢ 237~}]ԟ,4<=&ixQÓC@O\u'-jšk]+ks~9T29C]d9eU}1\tۍva'BnγJ0i ~[0 .*.;`2GN9~5['?4q\OMj]ʗQa\v-jtQ]pcbmMhv{0U=.+؍q*1{˩*rYy¬K^3ՓZ\M"Pn%IF\S'v^H'iaޅOZ|jK|{ݾQⲣJyr=SVw9ofV/rxbKǙb;Vu#(\8cIFTruS^ϙ;T̕$o̫{V.^gehх9II{=m;XXɓ#*Ƥ= QI=I&tD梍8ƥg-<%g*:|\*VN)m҄a zbu'Zy|}6m Ҧ8RZUOwTKQL~ojϥew& kBfhӞҳKԊ0Z>ϑK[hzYEXU]t ק9%3*t?3J-*nL2_/;폭T(aݬCy~>f&Xi|:cmr@>qkmRض𕭝Ae&cʽ$sUcOcOcZՋu4$,UL8%Rs1:TBuÇU֎@$(ڼ~vrGdBRZ>'ӭ7 .<6'z\R#UQQc[Τn9*|Ju4ޥ"G呜+wR2!᝘!Ȭey>EgU#OS:WIdsy\F};']oCyZ?Zk[,%گI#uݬM9{K-r=Jb:n"Ttn(}u[a6λwQ2~R6N? yiƖM>guO!KFm z'oZ3]=iF+ ig:%í.ΌFm" * ⶏo~gꙄSJKZj}5w]e[n19 E}hcvMol졌*ʥ>846P;BĎr%(GN}MgU[IՙR6rAqUx]v-S,znC4-x8(x8J*GI(h(՞ TKlUdhL= r~_SNh.yqe(89pՔy3̛OS׮P]8*`zGFJqn[fե}v4}<>eaOiWq瓻%,>c>kUn)۱kjEn+(ũoGO efX6$6H=#)+FV:FKDc唶sҵ喉3>dW.^=ta&N Y=|a)w[ͷ>fI]tF6ÄhsmӮzhoNRM)Za{@0 !~c3VV.ZE>B9sڻ's3Bk8Y X`y?iG:$xe f_3k^x'ߗ*sT~]~jBa;FG66g]H|W%U jV9?bP# Nn{1AN=R&lXĺ\r,"m$G\q_i&9&pPIU{6 +V|ʍh3'N۞N~nXdvN5I-ԍIjp:jlr/qp2څ%(>nC/=}xw]5| yuC ]ꜯ䟛0uoG$mc-.AHaB>_GZƋO-_?38z<ד^o]N'>! b # 3GW7-{t5ׇӯvɻY53is{H dcڶMӭ)qjʦwV<go{lecժaoۀI_eF7nRMu=-o>l` AjJgoycF<_tYik"լdhndbN9J ֨S[[n畇v 0,l.eNF{Ὀ :WK˒泽Kz8*uя3D%o>uȖko9ffG!$`}6WAQ]jzW#&xym歧gVw9ox|e[,#&VdmːX {pt$rkEn^GS,:_۶z+_ki^ɐ7Rrb%x!]璫6$\p ָsT)]EpH.+w56I9WʵUm\p@Hج.#Q}~H2!(l;K˫}Bnl㸸WミqңQIǟF8."ji5k63֯4E*SMŻnq&(GII`瑐{q_eVNQVKsF+etx]($ܻmUczs,W1hs.޻,^)-.H{OZy"nmʠ`ۑ֡ GȆG$vO#i7llkhZ*vz"4) ǖ~)aHy5bi4ۍI#XZmN=Z(:|ܷc[Bщ|Sv+_[CxVѝ+d< ys[I9JX4MB#B_ vimHTuf>b=4lc:zT3} J*O'UyVoY1 I탞R|Gݬ=t-q3l_;QE._lFI$7Sa5uj̖e*%I*RORrz~dTZTӪJNf-UHSKRbHQXeRU23mN4 wYm$[fMQt⥯C::v.eV8{2 F6$ zA&>N0N9Rxjr]P0TqjjSJ,n ~#ҹ#֗oh*|T*ׂ+.[lL}۩-&buc/ތ1lf"՛¤cV`PuG5KЃ+ϫJQʔ#Զ#~EH3R}:W*|曷{JKDDFsl' g\XTirc^yy [,v^};Vb%(8]u*i3[+FL{q` g<*aS]oFdh,hhى 1'ׯyKos8j^o[6OqyH=xW,jƝNY# a/=Eh6fmF0=?c\|Ҥ5ӕ;)>i-L_IYʜTSZ!iS$/&2-?1` gZR=JUHjmIW}?*Ў:.&V4]#=ԫo+nWንs7G,j5 5hבo+BPq3g֧u:{yroY_q̅cR98[~}%g23n2*,q6=eN\oE9TCIeDž-!2ʸzn1k]CgRr+o]N[?6s޼Uө.U%T1aC8pH?]m}~yeM6uBB$ȫcں='w>֕iT=^@Y}' #wa:1Oul]kГΙRᵮ71%E8SF"SQSdA<\ª|ͪȸ@zTciN*JjzvU$W,>uQ.Gt] DUt[|1dgrleR8SJBi%dh|>wg8}iS[[}:qo$.XFtr~{u겵~M=|wWeܦX8;=sc"(ڋ]]LWJ[f&.'<޻#ZcPmzqzqFQOj%R<ө{9-n7&B꫿7qR)[^N>ڳvk J kاƛ[SO'idVڜh򴈍9ҸɖV6%v,*yI+^#a)ڧbEIh5Fq2F4R5.5-^idLY~jqjgR'u*+߶/gHS58ÖML {FX gդi*B7d6EYC6ݸ:BZ<_Zm~x灤e +q泄#E*ѧ'm~&u>wSeN\W]Z]$ۣ*oN~Z+ZVV~eZʴNJ3t/^mB37V52zʑo"嶖'wg,G[r7fV[FϧZۚZNs{ Ut4U+ˑY"{ %3u1緭q֌y9=h({dݴFTIuٗ.mm>n } O/,Jn1H2ѝ7 QEۯs:U(vzYJIt(ܚ:,?R__& ͘T([=SZJ.% ܷrk]ŹUU%>fS8kϫV55"&O.ǖMϳ*?3v^q\tWΛבļ⴩RSZqÃ/guFOgnˏFݲ?@Hڸ:qC}Z%[]FLcr9d\8OqX{HөkwWZF[߼-<,N0I#Ҕjw*ѓRpo9dtqvOơU3}e2Ͷv<ƌ=/R $[9 VEQq7<۞XWב\ fYQDFIF*%r9/'-սkH811~)Qmb:J4ڷ_^Cg_(H*xSڳ{9A*܊2ތu yq#LVN4tJʝ6ߝ"WzO.I$*v5JS<7 Ae|sV5}nw9TFM !?F9=ywkjs& gۓzJH(ʤr6͹*kS_2CR\ZHSO%FޡV,{z ު5e)r.5)Mm L+0.1Bg.[FT9T]5I*2m!]Z7BV.sn.5_в3._y$sH nrq֣Smk,̵k<3`Z]eIiZ[.|빺 ߐ?j5%8kTq[!j2H$HwܐqvPoJE6l>+E@TL +cvө':u!]RkmUc4?J}f U++l^SG,~RxtSQCu%%{|ՄNNNՍ[*898z7Qr7fjܳ#XyhI܎!]R:_BB. s0eI`tߥi9V8VV6gm>bΝtQ).Y"V v2Pcǐ6zk9GXgcNߩ)o*\ng;uҴo<#kI%kF.0ƯܨO¶d-/ff;\'nZLi$P眑GN1k˩Gا-ZIpe(UYYN to\*̋|sFUr:sElMZ24ȍKl<]˜d{_j7G=Nʜ){d3ٖ|Ϙ09szӔydM(PDSvtw9; ?ush{IZoWkYym 5Euؑg>5eRzfبK6 Ơ.T"bg˽rԕOfzwCgu"H qs.ei߰ŲXI2f|ݡ3#ڸT7{t3J5=ZtVR I<;۰yӚI/yFܮUSMib6LDzUsT1xO+N,I<ٚ8Y%GLQһ'өn}n ѓiVvsm~GGØ{̬+@J,;zWOu_MR4ܗ.tq E-%ԛ n${յJmKo'Y;/%-HLbʿ7ҵHťeS*>VbVQGgiUKCe<GZ\Irk*2R\uz4ԢvVݣszc->*qC{צٍ034wsQ~ϖRqOB8{ˢ3㰑6(e\1ʰ:|6a pܪKRhY3Ƭ7]zpT>VqiɵV}}?Rdv?$>TF7MI).[Y8rS.[t[UQƲ[m_5bu*h7L薾Jp^E-\~U>ҌbsʌZ۱VF.wzaT`US%-՞hVI ccQA }.U}:%ZHNԓ$[k :$ؿr~1khj~sq)O^\($$*fǧӣ*.u)JFp&[l^2~8gc{4ЕJmn "Cq"*;@8n*Qחs3pWg;N8f6rh 4Iܞⷜ^OcFֹ%}n"qkchI9sԌ5&ZKZ})Vo[Ly(өVneI̮q~Wd^IYt0lyM ;W!A{Vr44(Jyu0Aƛd38֚:4sh{6k͘lO8yy*+D_p:v1dKEYFOV0{Nr^n˗J{sZFOgjVm;N3p[+kTN{O ZwCQ?e~˕'oO ,4ԧ-޾Oэ꒰2N(.-w 6;5?w)4սmX0>\1ӗ5I%˼nSEѬE~lW,ܔ/R枚껈t Z7U瞂cNU;T~Fԩoq+wJmzyԔewk2r'_JzuGVᧈ.-Q& FRvSZr朗dQ֬#7>SDԇ|%Kh!z%}Yi#I=vr1ZN+GO,Ɠ\]p_38 ϵ(ʄe/CNzƼlbOv㎭J*hkD0{&_+w#b-yWi|I6r~s7TU^hE ,Z~dWLi~=Ԧ.رXWcG-yNh#?gRI] |(#^tjK}7-,Mݫ;G:cI^,9X˵[UގdzAܹnY,5Vnq6rfqS]9/ᨂ@sp9yYFP""4m}Kky$Tyg;[m/=:3RuG|H`]TjEC]FjEɿ_յ16]> Rs{ktRQk|;VZR:I& lkQn3Fͨڳ.o4_Ì);ֺ(y?3MKRė0]>cߞ+ѺkRp{K7l5,K;ȩ+3#B{%kKTֲzӭ-7SEdX׹G'qIi7 ^KgBj1E{N,RNcGYOrVײ4Ip3,uRA:W*|۝w˥ KmJsةBX+o+ Ja`6hcxxgN ##NemUuۏ$1swZ0X~Hڜh7_>cO06EoʛKmm#zSz:JU#ȵKej[mDϦiV5k7]! ?F95Si7nN99]CC_kv$FohSOi|x\:u#nåtdw.r26PgM{|tcΥtSrwZHq[ɑ1= cN4̾h58*K^j1nHo/p x㚟g7Ƨz64XM܁6X*q-?҉=\U[q3?sF|~R$*q&Պ(L;QnR,?;'Z=c^k5dUysxxҼTV*j֒Z#>+1> W2îK };J~Q?Aqp+a[ERts)*քlٟ_zeåʇ%JhW T'{*=m_F}DA%msGQ{Z4>k41c Q?PQaB[yt;hU~1nOKrOy :ꗋ'Y#\ ` Q#ۺJ.KȪf*1M2BAHڅrlE6e(`>aF1Tʟ&݆#+w<5Z;f|ņ7($>́׹+Nj(Sdݿ0Zj1M&=TP*O'Znw220@V# S4z^/Kkw3N4oJkkj-y$2i3Wx<.9TEr{tn~z]}tV3MCO,-fX%h#%iWiZF-&m+ҽkrӼ.:o A7a_+uإFң1OWeiIߧyR\vtrgE'Eզ'eѶ q#;XdO't;9jJ+E{H{5.YCD[]WsEVʑK#M8=FGN>kbtjYmBhv^&v4(c `6xgNs=JqJRWmt_KY%muz&/nF2:v?X;ƜwcTfɞk>"m;E5!Y$IRo^%FdwMtY֎"I]tFzd +eN7.!r[ c28"5wIy~,G,hթVo_3?N YcX9%'\tj)K_o6i̾׷s2K,.BFѝgs19F1'bi)TWdf_U!.>G4.&_2;uhꍆ׋~m>oRXEYҭجw*&le$g?y}-<\*EAin}wÚeIo10 *-qt8kHƬcu.ZROO?5 yUTm~k*׿s*vm<9c,RyKfsFx5N5 Gy$j? 4(Vh놇BGW;Xwך=Iޭ:bTRI]^jaOtM"9vasp=k*bQ認kC OmqvUF+]r985+5 j5)OW~zBVf7$tys^TUu?m:M%&>W5ʲy1ܞNj*EKC>0n.=Xljlw'N\\}ъFTUzw-ZCei=ݱ_7|AԟAd9%^K[k)gtRzT秦3GN)o;喟ܟ!UiR`2{dO^hoN=81IKsVز&q>ڍc\Jin d3l %QѨjkvk3C|i+=sȬw$ͩQ䕟Ϲ(T+=:+4+|sG㓟\#Oҍ9{<*QKTGyZI".0'# 3WRHGW~4kFfۏUg].MgTEmDyd.qqӊtW^merƥJ'ӱrX%'c@DYPܜf%(F\-Hޤt~(BX;|0t8GacmZz_{KfHvUW ъPK^cV8%Vs:uZncYNQĺ8[Zn.vrvjN^I: Jqݕ㰹;WTCh8ғRByqs-V;ZV6!D 2Ҹ)ԏ-MHѥ%?loN[XOKMŜP{\USuQr 0Jm5:QQJE*^xgWThV1ʷ;c1U1TcY^WЬ=yC:SVjշH.crwʲmeGsҾ S jt%u~׬ckxDZȧx8׎Z#MԜ!dpZapBGq0['!#MakAq3J[/.IJ szcz<>|${TFj;jK_,idK塏y< ]l=|#Z]72kR連q ojvzzn" :zԪM{=ftp6}5W o ޮ0oV&6;Â}cS㱕(|_kO][i4}yJ'^8ֹ+FuMF u{ 9SVkG+.wy$1~ѷF+5JBZ]x]y:iw$e[+Mu 5){痢;+z+M_j~\ìlVyc^%,k4{[qISKZ u?"(Imv30m=~Z mu8S/y>*nfb}5XiF1Q[zxfvx\Hڄiād#דTpR{mF1U)zXi#%ƣoq G:dEL@',yl ǡ'Fb]es<5J1!VNQr at->Ծxn%xGt#[M .m'ufUSh31%qM(=YV5}"P窟'0rݾc3^LjVM0[uO]/tG{UvZ6V[>q!XnFq4k57~byI!԰ 8zu%%ek3S߭Gό4t#[VfV Ǒ}u(w+Y]w_nGw4(ٙn_#积jiVRK4A;-JDʳ9" rrGLZTH>,׫w󿈷é0ǐ'wo_|Tiq'}VR+iW¾+}W1hpB I NZVkG7u`OeKCC1 8'0^2M$ol駇^2qM캷~_+jlng[u#P$pt9h:\ѽR+a)4}7JCo~"4VLci/I|тB;= x*S;Y.}?)Vq}?q-6m lo<Z4'x e rq<OFޞ]N 4w]^}?(kΗ׿L.3ANГhVk=|N*jﶫޟXڶvX,)o0A$=qFqcʯ#g'o𽿇<]߼]~RI%_o·/4t{n"v?CoΣ&ѕƬ’8\.aR+"yU{z&><&ڄqgYRDsդb]G븩r፮˿i`p'e{>z~Ï ؠD$6[f?o¯mR}~a*rr5as*j&_}֔pvk_H?W~ uYa#ҕ| 4V*m5GN_ٷ:] [*us2VOyOʹtۑ~JW-Z+#l{ET´cRۭSB'nVex .T{U*kE蹧IǷ]V599ΥfiEЍx8ygCV775m ,GׯҹeS\ɜ:Ѳamj(fVn83ɮy^F8I*z:ufG3mf^\\N[hDlT$wLpSNJRIy/2/'`~ui$۳զ_ec݅F1y'<J/}Kɡ-|>߆:%݊OguQM#!ds1ߎ+yo{UG٨E;nj@^&;쎪*wqkΩ$^kQIx÷wNzƵnW'N+]$b-, '*N2HOvUHYEԘԛK% Uܿ.?ڴT=d{(5nw6 qȮҫ+JN(J/KA`Y:#'Yܣ:gEtF/ɕO<~α.L2Ҵ-,FHw7$eJpogFqoaoȒ>!X0^EQ]I-XFh6W'hOPť1VoZ"K"ٸr3Z&J#%vHT%R8Wn0=}I}Wh\ M?=j=w ?OҴ(}Li{jMHH[vvpϾ?Uq֍4^[n?կj/Ʀ1PbUVKy,*3 lx2wHΝ(ʢs-)$^>U?LXԦKn^2'Hn5\9Yԥ%QJ9].A@YWn<^2c|*nPi$mʸ-sMSkC#*rBj) y1~_,=8OfwsI(*I4Z G6-z\JThݖ߈F7 ( 0Fx\r(rf$"nJ$j+Hι ~?CZrƚN)VoyZ_=$4Y%WsJ3jwRAhW\pGqOζeA(J-j˷ #p.s#sǿn)GF#8A&e<F op] GQN } M.ЕSijiNqKdPIf\ m !Qanwk/(,N UOg zRQD0hSfnJ^q-1*ї,qJaٵc,>аteGqA?w]5CZŨVەIXe9<]^Τt[ J1q;doG=kDc*J59MpfU[hnLo5eh9o6kxE]Tz.ޥw`Ƞ xcOֺFזB9/ycA˂Ǟ31~5q-ܩz~JʷC,N q:t5c'*9ӏ4R)%&~ɞpz~iiʛ̻k7;p_+wm-;ϗ޲+Iq)Yg 7hn[wC4mSc6k.#i?hu=qZ*2gQlwwF^8H~^zl){E1HՉ.ssǥg(2]MfoϡRT{h ttcR9{pNZ^.2khwTw~)em2&]rzMFRtT_3y"ȟ۟#$ 9'"4ޟ픓KC68hovs44zc%&2[tTC)9qǧo'fkZ}1u㽺_ F:Q5R\˧mz&p7rS|g׍MR2):5os0'wlqEik~M8F9RֲmI%FۊtUJ1嗳cIg DzV]˓_*jV4JEE6ӷoC!Y]&6m3Z>F8JTi};ΰ˸v/*XzaiF[,˹^U(֌]ʩNW%,V{q}jcN-;Sof>X.tqm*u&u62*0m]y+V媘>wZ9eMBa"eh$V?7L(S,W#u T·CyJZy yv]ˆJ4jJ[\W:iTvspYb(nCvwR1?W,9gDiDd78og_ZXɪ{-MhruUzTqvW9kфnQF[<\9o;iﱴ_l*{֜[}bf\Gsg}LcMԳ_>Sկܞ9"FUfeRB9N=ꐩ.kLg7nZ=ۀ>QJ?xэ8/~~ݔV8GevmWt1J:WB i,B'rYvq޶{NI(^9o W"Vzi{9B ku6Zº}(դBG8_ZR*ӊ&d]B FcoڴN5I{hV@[$V' aW*$HURdm<}9?8ӆ7: Qw?1YU"|fbnU&Bi`Qn,H74HBzmr:]xܳw998ƣmrt9}? izYv gLv=xyVQ54j%9'cBKkhC2pFRViZ[ 2n+.T=\5rUOkz"2ZK2,\')@eOYIhzh Lӭu]3͵-Ӏ~ b*xx__8Jo_î cjNQv|eS=V W~wP+c F>y _]Orb*(6׿_ CɒdG^Y 'Xʵ:ݙy.Rr=np5ͪx"2F2eUarO9ҊьTd+T*{vt/4SJIZɕNT1#yǩ6"5޽1X:tj*^wh!s7ͼyw K@}*tџ12Am' [ 1nn=sp#9(.}RKFf_,wЌG N=QVVFq:4ms7 =;cu{:N-}z5rX$'={)?=a)rYH7:Rv nڻ)Tȭ'B;JXZH]_0><dVHGF/gxzRQFvbvFv7 }>WN=4!{HѾp*)420idV7]jC{y/Wwכܗ^ǛNN>{lk"Ʊ'-{sۥc){J/)>tZXf1^Iq=U)OnG,jT]_t:l7)F~]>^0k2j8t*F\QYA'꣟=3~*h;_IGM!^A3|$뎞)Jndy)kf"F2:Hl=CC-Y;ícͲ]ogؤS08os'Vbct~ԱdfUO'fgvFsӎ̹ٵ:5%N-7ܰwَF};ӅsZws/pF|s7 x{DiڞU=4i![[DzBujm$NOq{Wʅeiy;#XWFRi7~'Tm-rbO3 ಂu5*Z]ҵ~>ֿs ֬Rm廻u oaQ"Drx8}!Ӎ7M}t]/8\TvudoG=|\Gi6*[Rn\8FJXZNd^O=_ rQm{׻ͯ_ύiֿY٪.'*7}1Ceg|,:rR]f/PjR˾0o<'$Y &Y%VkeH'&ؚ4Y=m~zok5bqeO{I쬝jvMh}3ڝ}ۈOVI$2Ì`j;sT2pz=egkwm5nm[K-n쭯M}Þdeԭcs&֋Ty:VFQΫϖszOo lw5oL;!,2ú<ɮ-X[;`$< ySltJ1NJI;R援.Q$־`ϾMۇ !Dʯk"c(C!ݾd};{VQ9Quehdu5.C p+N<7cz| V61wn*)˒bU_Xէ^•Gb /&y,Xqd^=u%%,﫷20:-HlFK a\~Q|cSJ'$gh,Z0a2~\#%ft*rd"I< }>R~yrTvץ}K Ye=}ZrR_ *ӤSٽծ]ډxLdpA"ָg*U%5gӱ_ZM]=ofkqX۔߷:sM_j{DƱl_,K@>cGNjpqQsCEVޏӹbvkMR3NxO^I>{V=}cx.>Cj3=\ORtVsķ ?Ȭ}9/,-oiΞ|B\p+4 XgϥMIWoOXFt˗$amc9-˩x[XcU?1'6,xtOg?e4_WHmaF_1<~X@ߚ1bөW=Nʸ±ۗ`8$qM;9y_j͹6ħȎ{M9JRAJW{hVWPF{yFT6[-u1a(Boim,RO-xU0!Tyyu}>"<& zۭؒhwhizjA;$B_̐3ya_rv9]蚘yTQwnϙ"+F][ |iFQ[bc'utf"2,h[k %ziYIԩQy5߲:ή`,Oŷz&x4XXFdIZƤwrIitM6ۅF8I?[:|խJNfmU6NB0jb*TPL2e"|Ǔ_rO[Ql=M8$Ȕm#eGcJxПE! *xЎ"*IEOgXD7NsޕNM;Iөe)D*7|Օ8ڣL֍9r=d]UONiEI5qTU~A{vក=*{J [b$66Vc?yݳzUS9j'[ho2?Ϙ061]v"\ܾٖv}~~b)ө6iE:2qIeY:׿h |w23} _iƕ*{Tw>Ja۟)TcR:9 Iiv/|6?沨I]-ZԖ Yh0Y9aϧRHYQRY_pCܘn\VJ4SKIicF weW{VxtP-N/&!f,#cy*EG[v-mNɡ9_`He]@u:Vu]ZE h22:pqieNz$3S{nfn_*I7pi6d89"ܛqtC,[RyH^}j-]ݔ' cWTT;08m-Q|K3ֶǚmѶyJVs һIJSU#JhRO;1V[qVekܠvZF=~OrZyC9A}쏻N_r*QKR-Of֬Τe*øtfqwrT*+CGFM}zk9,9 *vhPNR$7|pi?Lm.5dlFaQYTyO8.m_1UcuӬ&;e)TvKC e9lԍ>nxǒ5-eKoSq4(֏9yj$14B#ې>эo<4?OCV}n_f^q3ML5cmZu%;4[&"$-+s TOuF;mRC|L&Bw-n5FT"XVMM |rxuV_k-]eVHx"D^@})Fb׹Q֩ԧ}YY>@ڢP*>ӭ*# E^Z:ލ4WRo3H^GUvz\]?f#N2^7p>&dK 0t8ҺZ"ử:K㍾fwlwyb#)+}*ҒNNŽ/\n/?w=N-Yen^hLYW*SsRY*p՗ IIECJxק7(֣Ɔoͱoˎ w7)CeU5%vhV`~U",a* e[Sh-S9B,f\r5[ Ӓ:dz~]1W*Vk[V,FB 1sϨ2(^2zY$>:xR-xV]Aw%0cNsp{Ǹ7Jv/NGL8j餬ZB΅dnO8BVkrS^0pE$ 0x=k_ig1QN][uJw?H9=|F"ISjޝ*bsb28A8Ի|͝h)ӕn iGp7}OҥFXQ+qwIo$i"'t4Fg7Tk{Ӻ~hD7Iڧp #h8I5m-#Xh G˓?Z筈k'U{-ВHmDA*io:攪9Tf#M+ߛtoVA,WQv[ˌ}멫QK^1)c<#'s=;kOJSh%B/t]|*ӯk8U'̴zSNTnoRIk4֐#*aݵ}@LXQV]QqM0fdYUN2pp#NXEr7j]yK3YHϸ88#¢S̫Tguny&>mФ-n|?+&Bӊ~֯W>i~NrrO# qӚ2Ztt$Zo#$X ظ99?T9s$5KoRk"""+ 6 {2 tJTeErwRV4˂dd}s8^L#?IѧM]HKi#Vn1-:~hܾjf8?"fVG,`fagNj[$a9GHyɝJ<.w0ƺߡqJT9[3=fYI\>CֵNSJ{<!]cV˚TSmp%*vF8pzs];cfh ,țAK?>PqҴ} Z;F/V=$lfsۈ5FV\ƊNnpU* ~ۚy+-^,8QOoOݖ4T+^4Q,0x_nx?ke)[`7JH7F^ DU=O]tۦcыS2|BNǸ,?85NM.h*̾!՝㑵 #y G9~t[KhʍZqk} s+K5*YTlQt:+FM"6{ڔcNg\HŔyYO¶OmI.dvb+5/uV*sU\girԌbDqr#x+ʟMG^RnD밝~M{k{ʫ UdzRc'쎊nm^ -/FɎ<&hӌeƵM-]5o5.-z s?ڔUeO 4kA#d`=֗7kVsާ2%ʉ+u޹19^;8|%d§Y-:#Mm:)!͚58ĘqtF+m6їt#8zz (n&4IXquՏ,9$t%|O>Q罅JݺXD1o7Ozs]*b# (/$AʴpxNv̝H ㏽^|;acٞ5/7dr0dmЖ|A Q)Gxս=Ivx~U|ɥ=Գf{*( ݾfmSnQԩSCRm{KmI>eqCS:7O:%Kz y%//EGo:PޤsM\wNz-,YmV5LNb /^s|TThlsWδYodvi@Yav o'j8y]]u`BvXyy #~T Fp9}+{zգQۙ3BY iKR*50Km2_92RM+~BqSz/ӯR^!7"9KqK" 芌vxi+hrϺM;tB368fA,[LJq T)sF* .s^Ż/wu[E2N7Ae}{WNm<)FC#̎g$vtssZHۖTd6ia&DܬřFWh9V|wn2Om]x:Oc4 8x51zxv!3[^ ADw qWs^.ӷCٖ:tK];Gpt>eJv^2+mOkMx}+RTy~^]}pjs[HprZκGK xK02|%\Hp=>9txU95ѩ2~^ͽߜ5|@ݸg$䵥(6q9% K-x7YXivאL־bfgP |<?kކO9O.}N6R P.bQkSolbrcnAIXxϞJ6۷km\E7RJʭڄUtmXw2 1Q9#F1Fˮ_ד.ocNI+>v\7dsڇZ&+a Ha漚yD1Ki'Ҟ_IRk[l %Ky3)Fb%$ҿNCNreg /VUmh>fsxX8l-XRf4S6]geŤ 0C4[TqIsY)E2o%F7|.a->Z1s0p7*G%q* Sc/+^sF,\̛?R|𵖧j̑FVuho :G^zgWYI=ݖXxHcE/-2rwkJ_3?CS[54 v]߼f^FmIehV@ 1$=HOkҪyY芳$i6J،ʜ+>K3v驩ik)V9-գm\8}0+a}9)ҼX. 8G\RGJ~^mc{h+lE(6PI yiGѓ(hl[۲ª/7/g8ȭ#u9僕C1i3w2 >F5%wSjY^UI4YM \}3^c&ٵ9KQ.lpE§4t]NTd܎l޲ UGrnMJW#ǯ GkinЍ^6s瞇$ZT*ZNcZT.t9ed݉68,=#ѥ)VPNe9Ez[ox{[9,2m*gpr:{W5lv:pg*~U-//|kKN.o&ikv x]{g،(IѽGFo[ס|/|7D2Ky[cnH3vr+ f޿TR`:oÿ^\CHt[b1}'qa>"kiBv/kUPn9NeԬc$l+f>xsg|CVz]>"9|6z5wg UNQ^^2˯m9~*in8֪2 kN𭖇aZ>$nt7wRrF;R?cW#0Ruwfm#?c,M'%#)LHH1G$q۞},E'ȓFt˲k"ĚCH3> dr:tіO*VZitGxI{ݤ<+vJ4(RYV8{?2-`:HG@F:ץ)ʋ}3Ч(ԥ(u(xCFrVe%>SEB{pժݜZG zV6ݎgqgEciۦ|SD99+{eR;,jx=JnЧEG)gd\֪7xzt)TOȇ|nXoysM4rj%hK7}NJQzF{K;͗lWzxzQV[*odoBKZJRpՊB\W} )li"#dӊϖtg,췱˵E#w»cRd[AF7e"^ՔdW,6NP֨r+|*ric<"N]7Eo㥳6sC#һqrc<m%}yn[:U}{#MRvlnN]ZtsJ<̯HjۅHV ʣ͓玠TRnx:u$$ۏDW4K:NN>+>U5'A7IZ_ t˻-iEn?0&OޘHMUz^{ԩ*X›g k5Ȓ2H~cǧ~yrԦrNK_ x[|s4s %8xڽ0 8QZZ4o^wTR.RV]y>]OKN߹xprzq޾_8ԺFj*Qv!}엮m9!ǘNr3{`Ejw5ѭ.hmePmq_1x#:GLQr|TkΔWw]<ʾ n֓4m6I (]: 9zTqՏ˔'EEiv˵&Ȟ`Hr(<ې\i7QM|))S{:,EmȬcm6 5و{F'gǍ [_ui֙]FF$rx|UʫE_F8$ښ9cML)ʖd2jԩ"z|=lBU5X#Y#8^q^9Q6=xzIvًnZ ]¬mg:{WUJreJPTָ|hјp+W+OGs *M{voO122WS2u1#j2Q{YݦyԵkItK7wg-FؚuRvBSFZ5i0s=nO!)t:OxBX[OyFCG=:@jKWmtriΦ!r}oWcyl\(9 ;AחFnwxi)|˲CZ7N+FKy#m89[a%Z)Z[hV*Tqyt|;ֺq#UYmnehGzN }U'-m~m}vhNkֵ53|GqEK|J=s=TQ{7-wM?_z꼏ffx27(eQ 8p2>l855b%N^ӯvg[1"A!9 ~ԋE-R> p<[{̶ZD,kC"1:H=㢒ߪmk31KeK87ߛݞ9ɺU.sF_ npsӞ]pK{[OFڦ֎,ŞE𵦷s%N$Sip^L YY-gtWԦom7[;򋫱.XcTRI3_Fr_.eV*/q [ɹ;brNA=qRUZ{][Gsz{_ eCokb=#kέJXy]۽ wmXԙW;wmrE$v1i<N^}LL„߷2\vi{i>emRZL8k^cƑnR= l ҰRvzeUK~"ʜ9Wv[k(~^'oYxWCә 6XC)8_m#.Sѯ':#EGƜpxKYvZ~~?7f-n,/5[jMr-03c1q^VIYmx,}%}USa$1ʂ1>s3\.2)i[{ɤd"?3xJksy+K i3̱]N3=眧i+ӌeTDbrNrt߭c_jﺍŷQɻ$ {O5Ku~G,G޶4 >/*v3goJƧ2[4C*Eqv|:imGßW 1=KWa6K]fyVe,*{GO϶N=jr基CWAҗ#,FS2}Ì{ab~x~mĜk&=Q61"2|+NJ\ү"PEuȪ6rI+JwkH^obYC}xUNjm5h-|ƍ9m9j)ҧwscRWwk͟O+);#hӕ~U6#J2喝?"o3]-y ^ߞ֞1k,ESslrvRh,`H֒FZj< OIYEV|`RΫ_Ա6|Jƻ,&sT|Ʀi%+*+R=޸㈝-9Sn4w5TE{=DjsqzT@n r*M)INqu(WZsw浹[WkhYI6IJVT\ஞyfťزw FG׏\rF֢ZL*UJȼOqnmTgwCמ{"+V*~m%dƱU@}y')U9ejQ熑̑cyGCtZ3=[=;t,ifAca*󃪜~?sӧ+t<LB+9Kdv\O OB}GP姗jM {b^"Ri=.<ȩb&?ǽM(ƳwV:Werd(]cHn՝iΟO8WYvZ[xI ɸvG'>J\Ϯ6m ^|*; Ads۩yj^kqӫzm]2_yidV6^SYQjUJw=z{ףJҩf?On#éu4TgZ5Q՗kfQpj-d7E]^2 KnqWT[Fmbڳ}$QApොn;ƒ+T$j{y6^|oE\G``p Μou?鏌w7A?jgaѴvK+xUXICު)*v4'R6(0n.nO9t'5'dav)w!d`v/~ʫ1;(3h/>gRL4ez"+sƨ `QqԓqkZpJ>Le/e&Mg{\>5ju9 *n9>RM-JY|7w*u0\O%0d4rld'<%R273EAfkb(O02QKhӟf@8uSe2:я4Wn9"mTV8X`zWE:u9بӝh-&[v0/`ߟýtZ\nz{&d,ʻBN;Zqr_q.2O]zzzC?aOg޵AƏ-4؎i3N| Fk9FIVLj˓S߮ u3}̆hZ4*v{>}COg(I+g F3dc}tS6*4T]]ϞVH2d,7`x9Z鱭:im̻EEmdY$elIK޵LԦ̡5ǒ:p~KP66+Or!Ѳm1Z-$45K[ZifY>)*9|&yӊT4S7#)XDd<')A~%Ne^'a(Gh#qd̒d|h~ktjGe),#t\mcб g⦤Dѫɿs6W0gw{I8VyM;-uSN<ߡj$a(ˏz=NYԩRqWk{ls29%fc?wV+Jn[imsp?.y5Hyl*pj]3C0V;cr}kZR}N*~rMr7+S';_ü䷜JX]>GۛGsw}v%Nw7jʤJw ?:@5Ir=921RU5drۛ {Tgi5gtUJn VxEb+"VrVG\/ķ9_5W9[rd4dKOO_0$.Z86Z[y}x?srMsU}6qyܣ#@RƌoWTSHQ5i7oCkShӴ46%wAemˀvt>᜜;.Tמ穊iX~0i-3K;ma#Aal,W8Q+`QR;)%VzqվnZy%tyXOvެ坍~pyϯ𞞞ՅZucZ͊C33(xvjƷ7$QQwVʸ,O=yg G\Umn;xn*GFvZF/s[Oo.O1;qY~^*9˚bD b:v9Җsd{E%mkihcw8 :kQ:|^\Fڣ+N-JR<4 q .ݑ5ڭmo *r맡iO)|o>fiW?RgFESMU)g8ϻKԹ1ي=<:7zz 0Nu"kiߡ*nhndY|!9 q}j-GOC:3攕G;lqbT 6qT#JTKt9a$9\y7,USJqzqئiL3.Y|jW6R:QOENjp29*9Qd2k1vI%q9t9.p#˯SCq;B}ki;_tuGzl:}w׫krӲ# r@'Y~g/j5间Rqwn㑓2y~:zթNV3B0{]=-Bk9< Myӕ3yGŦ;mde*דt渥[5/::VN}4,f0$mxOa\ӚVoSl?mmֱ{m]Hm;Ug,}xygZ$kN5U^V}gtYl`7 F?[>JuF YX-f]o7ʥ#o+x1^Ǔӿgh蚛yIPwn9nǧ#;8燤w#xjыM_ϧS/G}ώ-/㺳aF0ݘ>zt/g{KÊ2aTv+~NJn|]ߎG\hac.YFk8WOkᾶ=֥ ~M61~۩;ZCF/_|l9qWZ|p֍JtC9ѢM,:҆&V;=D{4)jkKdvO=>;[Fz{:>nu^KE~vlzֽm,J5-+YǼ1\zz[[imbhUWSv@>IJT{*{1Bn`mLpyG9ѧ=yQ1`m盻q'ӷ'Wm t6 mR{<qj:?C $urᘀs|=jmMЊ_1bBׄfgۆcҽۙÚZ&=ccNn#Wm9iS⢖b4be,} \e}mݗlㅤ#rO7:#NThBDռ$nm$I"|WpSrZ(:"-ѲO궣=V1\ڶXi }2动秧t*Vꪉ(n ^T9=3]SzK&p6;idV]q mǡo +Fu%-&4hnv,q^~n3UF7w2Hojbj0aЯcuK2N :~o;C ]ZWo%^÷]9'۽x027R.N[`:z0ƪd|OvO|w>Zr_]>2K5XeY7DN<9*%ŧwq5yag3%tkx{ELS1@ncxN3}RU]~O^?BNuIu_O[LJcSl/"Jq.(\@q:+Fy7uݤɧ}/{۷ӭN\ߢdӽ~}[ d B)dw_q[]{;{,:EOu"I._9 ں*FIEG1RܥeNm`b<A}ji~Ʀ*IO[=Wn]Jb'4k^G9\Wלcn>ޏhF-] Kπ>5t%1@wrlnaҺcV|>-{y~g{EkYXAwƑ팑^1rrJϩҜgx/@ҡgWt $~Ǿ!DlLw8^}\gm:Zj65zHWfR7wgY~Wh.2*e]~AǕUX+H;#Xqr{akXΤ9eQ9,= } CFX͹ mɐn,x,5_ oE*:t.g(NTT:L]&F^\'ګi(´ceN̩F65:|mNxBITGk)`1OLK\rܬ'oŔz5^Μub-զdAfܿO;2̖JsIRdKK{݀AWJitG>j6X71yokH'+Ǧw+b[v}~1E?i$EITN;=O'aᔪɎ@b˥\snf,:2drFR*5GUUry}0N:}?{W~--!/ߓמY9kQpe$eecG$q tc{ %] Vr(+{:|W"ڽ v瞙W-H],]gc@K.Gz'NU*=K! B$ 4|dxz=MgOls!khYͅcB&+J7ΌeBLFT++Sm-ySjW r(8#=8k̋rn-Og^BGP 9$ui{9)j2:In$kspڿtן8. Ք5nad;9'EjtJڳu3{|v]Jww.owEqG,G~x~G,ZJ6ooN&HG뻢 L/8{Qv2 ċLM{d5)T|JuMUeVIo}.xQn}+WJ;GՓn"H:;y uT-]NY]ߡ5̑[TGSR}ZcSGk4cm H\񞿕MJuOCnXƕ?[P5lC `6 c֜Oc9͸=I1mcO#4gfQJ.I4l}>_8rGc׊Χ$W:ERyy䞞DPi[t8O[F>ԖZ߾y! j"7rTa Q#U+>U' "gʝV.V$y Ej\iR;MW1f2FESNx UGӺќӊ2~҂(ZGƼî3j08=֬UwKq$E_1TH*s޶}|L1n z!,h/ΣA+>Jw6NxzJuݡ%2_EV黧?ZZ[|ԌHI8y\ B"V5ߔ~:B⼾J)dg,PMs2n+#7>}OgFI^-SlZדM}T)ԩ'$=m"KJQ[FUe;.S\3&OcY2[p0zOֺ4N<*v67gvrĭzͶF/ryzte%=3%Mp9#9jrscB4VMnrk/:lгh2Fz~YPZq_tz4j9I+&G j":u8r'.t] +# ms>+IR=ʡ|5ׁ^rv"%gv9mZG泆lP+: VvP/dIͽȶn:ㅷtQu)u#Es2#⣏KD\C 4!G}54l-f $pާ=:s٩o3! ū4սU_,*, 7/MJLJSq%nS=;uWd+6ΏgYJ [:\Q^ Iw|zbxy\5s[TKϹy?75qTokuU/JWVAWJQxRm ۯoR:)Шykdm ^1>BŌbZJ)OJ˚ U(I OjQւs#bGڹ/QDbk3O'퍣:Lv|Uޱ﵆K46 3m 5StQs2$LѬ*SLj{˪LQ窥ȓf Ѳg}RmHbVmnr@y}Dc(["*ʫzW=LG-NVsVrK%.7mc:slRPudOJ-Wˍqi]cwՌs*17 `L5)OTrUU>,3:@<~#rF}F ,⊜%J&4k+Vܹ޹&F6}LԩZ lH3::VT$&ݞ?Ʋ m_)\}DGqKI7nNZt+K1iۜuJ6ޜ>=΃lm r亳YJ4'.+uQۊ菳jˠNR?2Žʡx|猝6DZM]QSQitЫw ˳zy^8J]L۫ 4@Aڭ]Ө쥩"5.VɖGvfl]\qj~y2F@WEHޛq1_D77C>m54D;ּKH*}-g_1b*łUЧkڛQRQ3f-*dgkhS*i#k54oGzv㹤ۗFR{q)9E۷w*y}- cH|7.IzJYMrS^irV:8|9~/!ƪ6va r}:bR=EpTJ1ױԋoc÷Hxu NqfvC ^7whszգ~9ǿ+'D8xu-rc]YsgYԌTZf0؊ب--~GOInekvf }8׊(3-=s8ߖz.wF*]s7/m}N2!m4G{h6u\vⵌ*z=F ts`gkogZt/S eR-[uT tvŌYQ6%8JJĎ$NRSh5iodvz5jD( {gr:kS8tW<<,;d^*(ǒ~徯v&MY~bmۛ9={B9;5Jx'вHF?338u)ChJ\`߮K~ALVb6kJtۓTScO6i%B+5Q|G4hkn}>++``YOpʤg K40,t˄3d`c,8湪:8SKN΢8mEqT>^ekSq]_A*4pO͈VPVIZEi$c#;A;ɈPu:{*7wO}Mr|sG{zW,s7O&hMM^]&5Y<9#9>zUy-4}>or+oֵ{+.>Yq:j%gTT皺-L!{D@X6H#NP̙֋p߷aYr>OR-npfϢߦ;>eݵnEqU;TMTk$ -ܱ.V33$?OvȏVQb=+8%.i-_SXag_:2A%^ 儥}WE%'7ORIk2Zĭ46 {\򔹥VL;J-wV?&6aNcw=)ӝHҺmoS42wxeeuǵ^ViVv&ۛ/en\U8˙ ~]G9h.4oc#hWIy3\*|pbc._i}S%y1frݏ*)re{c J>RZ$_> \+mѳr95=nѴjJTbZM ƪۛo09Ǯ|8tӦ7.oy]K GY<#U7X4X US`8:h0Uĭp3 *q5exY7cm}o'H]{Vv'8^Òu!Zj/Me?NmMFR:*Job+G0-VFI#kSRVi*WV-ƱtѮq~?kTw7)Ů!Uel8H9<]kFqҥQ疚:\5T'vzr?ArZM]TY'|fn$OOtRoChFQ^Obݞ@?# >]-sZnޥfyyW60;~jEϯbp8ֳ\Z&^ٸ.x#oU'0Fy#8Zk]>W&2u- #Uf[kx|eyaѻ\a3'W_5l[Olaά=}{ £zXԦ^wfY,gѺq\ҍ>F+tԣu;'vy*Iu# |ɉ`N{ISq["M*qӹ%;w1eS9ZT-N1;8Gd&$ ;r=+Z2oDЦR2d*?W_/-}:61K3-8hbia-.py`rGS4yɿ#j+MsIjjVF7Vs g?laNJ]N5F$ڪs\HT^h勭BV{(}\7bV+#MB'g#UYEKjnQn49`BɍρntןmVݎ)J:K#K-ߝT6O\7c:1n.JVe2kEoRaNq~xoi9_$G{.H/*hk:3o,}}ڹjC[̚SWϗOR-G$]gvAeZVNM[O%[.hq/<2psG5H+(}M0ʇ?.S.ʳ۠Y'kp0qxq}XJqQ7s6{[y2`l. S>CҩjtC6-b)ʜ?/C׵Uєg]EG[HЪ8V cD֯Sow&I[nj}E+=/2ձA+rŚIS~>Hjc#Uɧq)'{&|7˅2NVIXZ\DcyM ',~\`uNHmnLIxaCYԄ.uN[.3{cO͇k̖wy1#nb͜TOsJե {$3^,rHimLtiu1Zhr ¤,NH;`cOMm *QqkE 1Vf3*B:G\WDcF˟S*n&OБstF\=z1Qw鯑xw Kq?)ۏEw`Mp55m 9˸ҖEVI#h <+8un؞iJN- y4Y3"F:aNStVSߙVp}[eG-jj_'4d)>^\ˑ|2Em z qrs[֌!Dy)n_ȸ4P!'ѕ`zzp@YP-j4:rяQˢbeeDlɴatysXʊ疶{8ѭ(j:°Rnf6dn6JvONYO"У4ՎF|y t>x0JS9+[ak>EbJ̿.9`}|۫t3ۖ]/QaY&FQݻ\:OV81aN3b_$9ja\@Wve1JƝ=[EJ\RcyJkw1f-n94cjwwFU׭aRj)TW";eT0S3q[gFyJ5Iktt*j2RZ*q$˨`Tkf'qWN}SBtR3+n<=;uYǚ-;>Qom(EmiEy/^{WD0˕ib%rځ 7 ?7V>VnUc{jC} 7C|z+xԩqȱSƍYwON:uzU*2Mra^PZ sᇗzNOWdhѻw5ͧէ-Ʊ*\an c~T/R8}6Qcq U-7FV)}q2[WMԧ(*|u~[Iuܮ ߩϯlUpmiԇ4ݛiH`_n^7]Q8:tf0Ч̠G`{]Ӎzbjayz ji7ޫQ^N@1mu/kMq-ew ڤ]QNm9KGN?2.Ƕ,TWmXo9s-]u Dj1p]/`gtiJP{Vnm3l\sAqUZ]_eطDV]GWDceTO<3$v"5N[[ =(^]_ށ,Q=Ū4c- BprA!{m>NѾgr*w/u<$[يRWuv=kӃJRn4mݶuՕ%FZm~-q^suIJ[v:8#XBv2~\dV8 [MF+)   㞴ov?x\LH2UIsETc싍:u5ڥ1I$ʱ[$ANT~]wsZ,~[عUQc]qd*X^| g[H<ƩWN (P1_[G1)%-7v3fCm/pՏI'oW`rG55OogNWvrvª!R :q_MJΔ嫱u#FJ1/~fjoC#o!?1n0s\O}us9{ T˿BeJۤl~]h[}NH`HRi )e،d#Ruwm]2ҥEUm_j4mX c[xaa\*0989 H0[WTo]QQgm5v2xOexVcZ$l Pӂ0ybS'RڳrWhvJIQKK]kVћ:Ot" $6ˈ]7'*99FGכTM-qMо#xRm>[.Ԍnr1r9 8"QGrIwz/˩.}A0J3._G9v+ӢbmookSi꯯z5?6̲34wn]cr8ן*QմYԧުv>1#̚Fpg%9\NA8Rc(-￡ҩӓ}4=ú~Dv4D%99 dc+Gq(ӍnT }\k4HNq]Pi] e_C y9wt KI=:1?eucH[*yHqwQdӷpՔJo]+Ga73͞xQ"Cd2 w~ jO.Wx_ޗMѤhT7%%+"ۣO&fR~=˙hJI2E\ôvy$[S2xњ FE#yZgٱ'һ̥mm=Nl=ik/Ha6v`v|qWLx$mIʜZMkK:1cU%pxǧO`M?aN7bkk[O9e7L2$;09W{_.8>4o.Sb{#F=e듞kE6өr rmxUR9@$g )IX8niZvg*.'H6WilvN1\(q8ƽ|Wkk{G?Lg]#-׎ 㩁:V"Q[צ JA<+ !x ]%R%qii%¬k黮яP+ʧ%f+8CoOVesna3G , 3) ۑֽ9\~lKѕOk({/b߈~4ѵ ySz1{]2ڕ)ֽ~F/Rgj-\[jd *qW#ps^RVELUrރŨZ3yjF_SHw@_NoE^|tV+KZCz]ce[یeqh,-gQ{:m(t=??^3,SDN2wm/tؘd9 w9u󸬦UV]x}|4ŞYQnx[H#,YWJSU}~ߩehT~{KO{sb_,#Oq `T33\W.:enJQ|cnQקQ]<<\kJh΋N$XѕC#{Zޞ*4M=0^P#J~]B>"]w]pFHϧy]h *6c֖yō$jSuf;Qf(POjʤ5]Oo]!U(%wGx±E% yGm}¾J67.]Smw#EdExn09yOBU}]97?U_B<чcѮԚս_p^nToʷN؊|{<>|<_/9]#?Jb!+Sjs[UXT^\gk_LⰭ+&ӻE.XI>kUؚpf ϧj{;k(I;n{EOwn+@?ƺ(twF2,3sR-b8cITNIhz7.ץsSֵGs(Nwk{|7blhHԫ-ѵ=`%ArqОC)ҏ,# iХ7Yc^<Dfe*X៦^c%:˅RpKK_ק3'5ʧmG~к72\EUUٟNF}rV|)^ouXFx!W/sӞRFM:#Nr_,[uүV6o/'`>쬬wQ\~;A+;Lrr9uq<2LTJj9[xCZx.-α 6{p  p6ױ8KZ Y`$[U ?SVFTZA~~Y.a\;F-5(œ+bkvafE+WڼԔ0yS"\\͖enk M֊VQjmߙrR<,~Kr{geu~_.F3jI[;}a-|׆|7;vӍ澑X~iJvRKg ܼS;zhw>Gu{ X;iVNGB k"^[۽j`qU)Yۯ~OwɬL/I ہ) ls_ 9秃cp^0FG/(SêX^mln+_s)  x?_|,5K_b}t&b$n%F6vHeFNqz_XWy;s_fϩ¼fNZ/׾|Sĸw2܏+QS憞vz8U%R+U-SΧ ->وW<Ϩ FS}y|r٫ڶ[c<'sOO\Z*5$rߢ#ЧS8Jz&k{t {cܥXWF9 ի&(5k7mB,Dnnl얗>?Vp$ {r  lHk h6՗#ǩF]UVyf%}Z$wj"@IXrr2I#F2a.}_#1t^V9Ku[4YTç˟֦t>:z+Q~>bhCFfFn$ qD1JJ]8N77f 1\\]w[mP[+m^6kP7'kvǼ^Fsj֣ :^}?"(ӥ(SWK56n5bV!)olQxvz]mԧ[齯=ai Œvs^=|x6Z+өUqةz~٪&=i>TɴRz`I? ьp^[w4Q+PM%{ӯm7g~ť\CEf(X9z gx8=6?/b&ߺ>' h~$iW'׎3+֝FxuU9z_| [泶<Ӝ}UO/OcJ\젟NLM`_xc=I(թM}?.]?cN6O̿r\ȭoyORMsH*Ai mi:EbݷtĜ|ָaZ4$2 m6-[9bz \ʥ8[Ku= hF4\*M'\ѩ?\ᦴ5?Eob_eS_pMY3#eِg<ꦪK|*5]h)2d$J5OO9edB;͹UzVo3Oj<=k2E4[%XC7 '޺+Pz~e'(HT=Ja%*)u09Y1z'*tTH㵂+#PbW~:ϛjRh5n*[{c<HQ&2++Ιa8kQVDVQnmn&`p#֘yGu/cOf;FPODc_sqگ*t֛Wo=>݃zm#hn@ O{QKS4%:[2/`wd%z>e{TܜtsWԬNxHo;(}[Ҵ[éW̥2>y_˽t^*rR3M6].{(?>zTɣ(ƚ$& ̪^>s*SZ#)Z_5fln6}#֦ITqV~}J9Rs媌T_3XJGL䥌qe`ˌg9чO{`9{$,[stD9(oTʔZ.qmVnh8?J>Qr}NzQfjhVUsVN4ru/l f̢[qߌW/,ZZXvՓiqqw30Op?ƹSViъwߡmg&`Y˜cV-[V"5^OFXKr$ۙcMϵC3wxsXJʶou&kCv̞zvr ceG^mwrdJk]ی"Pָ︰F cfߡψ}_oгEo3j.Yr."r[6c0^*+FӖG=I{Wg28b$-ymW=Ha孶GM% YIu\^Ƨ4ެy攷knGHdhi!1'zcc8^մ#h]I&34ٮ~Z?ݸ2"6=v1{WLkF1:hajF.i_MJu,ڱr*E's3QRȮWnO7}3鱵g Zi.~̷H$ s/z5yiԺ_RKqCT 9x㌟F/UTa{")l̑kFE1ӓ[$#$~E-SNR_Í1Ǹtr~q*\I~J6I#Z=-;ewcVݴap^랠jc9K0 MB Q+J7>w>iN9GY[m>qfnl=B:rj+~ӣN49s gApy.%OCU{yhpQBSJor!;WFs8J*ѿC>1o1nHhJzsF!ºӌGX=TyQRQ+g4v6yqpXqۡnjUtg]E"YS~TԷ/q"]ΝSpv6ݿwڶjFJ(zFַFKUV$ ʧ~jM}4jprij<Q\ԂgyPq9N:y#ٝ:~Źor P?2r)J_K/d]gf\=x]j{m5g:הKu ]0V:g緿Q*qOW& bS8[o,ƺcB*7{2:)JE-4IZg2c1%IDD('sǥW/,άRXkmcW 8er79'(*؋E.edŒGz&2r=ES-:zZwr5)pG\[U"R΅?guV\%keU)j㒧2M/G)_е,I4j$Q؎~|y!N<{ZDfhff뿟˨މTQ⇹[صYɍ(~tJ5li[1Korz:%y|̯2_czs]~NfrkVsxO<ֻ5frƟڳ-ŧA@BL';W9$:ʴ^*uR)hoiUVHF"S@G4G{_oZ#(5mtѮu؅Hȹi[x80sUROܚtcF?ӶRׁe^ 8yTh֝: jZP}}f&qM'%}$x,:n?{``z15(ӧ*PO~Z|GFƛQwӵ/cEm;Ade;dwz=|77/<*z=:/s6[Ӄo5NLEW N]/SW27csh3>r mYc$s9ӜK4Խ6u+$Ӌ| ?ZKO)"/Q|~# ብ ZN*]/kYvo{Lxz>Zw| [Kѯ|9kP^iDDʹcrIo =ˁ̪Kvex.޿=u>WUQ2 ͝$՟g:#ey)=r, .fzsѧM$Y\y?gO3JmZmʄ9+y-,涚Qaǵ6SZ2;թVfݕګ6nk%t^Is7к.tR>_O«;ҩ&\6.0۷msPoudk.Y0o4۟nO(iW(l*Ğg>uQu}eS5!BRIugkVwqJ4(YjMi}}ovI.y~:ӌ)޺zOs' pf x9uѧFSu1-<~)UQ*q*1e.>ަ-췱x.ܨMJy}0u?[dB/,P(GTnJ2\n B'!jn…P=R~[hiN>W<|OVmGsV^6{\ɧ)VB|T*[D?3G|VדFt7CithV7 {q%:S(^E x.yn#1׵yuqE.] E7Jo -&9S}~_3a"pp\Gs? e%S%tv֓^MWηe#i6| 8 όin*4GҿyHH˿^~(Mӣi~Ӗ;||i5unvT=kf\b,UX8lwmp(  ׉WPI#z5˴؟'OgNNh؊qN{X?u/t}&k.#أẹ7=}[RERRs<üY%v} {{eb$W[1ҡF1ӷZ`eRWSbrm]7#.䵆6uSwˎF_:{8qM3 Lv^릥Ⱥv7 5 Pѫ۷ Lzz~2ލ~mZ5!%؃jWR3G6?x9ɧJ4SFy56#}$OsI_ZF륕ѿ"&aٲnݍ{xw [S:u6+Ş#}'r\ #4F?1;>)F\GvJ+sόZoO5Z|# *?Đr@G£FI&GҶϣ^xB$:}1r >cg$߇Z.9ɦx2>]8LrI#L|w\{}F js5vGxcpN_&x-}^ ΢p>jy\/H~bq^$N:7J4ukIdyMT^4TRUU/iZ7kcmE:fQ׏ Te<<\^UQVb*?aֹ%N.R%юߢuZ}}]ArzpF1wL!!;}k֥XϢMt\j`+es$@.Gs|QqI1rtzkypfxV4UTP_ r8XzqoI_5멭Z7٬ޱ22|O]#eHOyΌ6p9\ӧO_CQWfΟm"\ưF>VUMu6nj0WZܕ%ϴ?1\:sc 쭹ROw%meR[lp8jNOe }n (Ҽ]FO2, / pO#xz{j)%hMsA!X*P6y7JrKGYJGʛ<~앖XT~`UFݵ' |-(⒣tOgw>d17q< N=sRErJ6k(kٚE_3v gǵvTJtۖX /hlnfHԐC s{ -zVI[_LD}*Vͭ?[}ǜJsK`hKoI\CUN] }+,Gyr9F:ӧTrL_[fw v'2z:j noFTZC}sR\q~]|$3]2X4Ol>S)AK# y ~QRdԜ a - 7mziCWS.KQO-p?@#-Qz:tݵ"xeFf1ɣNVeBqFe.ۀ$Ǭ̽:4X 'f$ y?jƥI&nmDZAg:sZ+N!ҍ3Ëw*,/˻qǦ~.1έ8F/i6$(Ue%Gp &4ے?s`vʼnw}͸==yrOC:Z71Q٤LU1)${Ph&7WyݴG#e Ѧc9S}XVC2NyzaW:)\M@0O,Eުga6Ya n rONNJsgKo ;_^@:%Ma73^QFX y^SX>|iJʳo$IUJqDeJԌ"%&ͺMm=tij9^MoFJy8<*}%G,y\v+ʼsw8ڧAߏzҥiwrQQyN|!hdIjܭ6^ fS))Խ+ȶ)ݺ3lpէ(NҦ%WC63­!Q* y:{}bDSMsi3U9 cwVxͩ}?/5G$HmCMTcEɸwW5Fu-s; uXϾ{~GR%Q.ow8hO Xmr`Ȯũ5 j+9^ȯ}i$&ܔXیtgSNRkRjG;_cᴍZEXlZ%*ϾFZ4WisI26ݭ ݫ،~c)kz,Iv\2O?{ӿZA|o};Zڭ_Z㕔8uh=ntԧUSm7?y#8s5aik#ʥ:1K[-C{}Lqʘʩ9k"*ѧQfm22G  p^.hۡF4hǚ+gÛH[w}vc|+QW&Ju$cdŰ3kQJG>*Z:bQȡܬ /'ך;<j|-rx\z䄵Y{I&1ӓ~\uJ)5I7DwqJceS)I6:r%Hdc?jj*ըA+M5w;z.OaNczU%%ʤ~mˌ֮f;#E i2k8X@}htJNRUػTr1qNWNJ7K9Q̗o#Fx%ͨa@^篶0:*eԤT(U!BsK#-0,w$'Q;J8IsI^LZ56ހF)Tn[x՛uj$;|J>UYQVRYYr8LcQ96m c5kJɣУ8ʧ4I0i>NGTs\ ͌?`OS(1kUYx|Y Q8aUp8ԭ.}/ױUjVN.]79Wò4fXնl3z8ƋK{:y.KINoQY['(0=Z/i[C8juʞ{jr:΂K5In߉;`~o_ҴȇJWWE I[?6֔17"5F[9HU9[Lw8k :+ݽu%dsSIlcorN==׹T5Skdn[D2 sJ5&Ne\z}k,aK{bޥ텲$0e#zʧUvί,(Y'u4c I^L9W)8RXXJ/6M5 ᙁ=ǯ#uURT.7"u~ni}4WW(aǜ=;bqkֵ~\;U5wNșfSIq3|ߑXmӴr#Q)3̮مQYѭrǩX^Jn}ϋvQ˷,-\ZC_cMY;"=Iu z|V9yu_y(qjZm-rBvF8v2*0oMB4T^690HPͅ$iGJͳJh7ܛY bEPCOQ*Syhi-׹!# W7̵>qƞab=q,W\j7k3 w+Ll0L =ڻhVTuMı\rGvzyN1#HѤÍk1*Y#v<)qc(3K8J=4s4{k}taOq܉#+ 81qʤa+o>{E*ƻpTl3΍Ztgh&Gpג໔[h]̻B88Mfz28%hX3m˃8O~Ա J>}<ɭGqNľ6o7^ǭrE)%~KӥۻK@^w6ѵUg}iu9T_W4N"$v|ZYȩחzDUin4T\M۱frݷ+*--Ī:7}LR+ZH+2c\v*a(Z#U({6O)gd;coIӕ'5V7MY6|5/ʉw5mne2W2F_Z-S&:4T`z߷%WHJBgDK&^%քl,#{T=0[Gg%+$-&ҡ7} ^OƦn.ikoCºKڮe/y[K>ބqt.m|]j1k ti{?O燦{5Ťk6dbHhݷx9aӳr/]rM'gwK7&2aV]חVQ~|oeԴ:|s"2Ȥ90aʐqOL`q ܲEt89FdWMߟɼ𺋹.V`կ3޼NJ"SݶwaFI[̶j)=WvHfY7ʯ/gΎ!¬m%W#Vr[&8i<ۏLF2}} jƄex /_vֹ%)J*.bVe<{QZ1'ٱo T.qrǟ8ܷ e+k|UR*SeNFZtYgo1q\%[u>&X]DeOB8hW5XR^-TҲ}G]X4I O]˜q5e{69OyNBlˏ:MkІ-Qbpzڹehq_mf U=55&oNKp5e)n4B8ʎwQt&n [yx| ZkSu8eF4b}Z-^o۾TFr5Ljq\}?h7ue4d0mqJ}iH&uKg.pck(~5%ybȵeXX׏֒a+ΥJti>6[ibH vNO=~<%I>WO4{f&g0#x9ZJ1IFd=2+ݶ#7#o0q{F1Q7(sIk]?gSge+<>Y'AҺ%J[cq"șF?{S哝u_܋ZnaC:hwn7AB9kzqӴS !B$, $,#FF6=` k_e(ۙ]ov+֕%NkTn*Oðj8mqr9eM#Wc.ݸʱV|M:}k[Ʊ:ڏc3m䓎IL+qt>ld~ŒxNo*5>d`9-J`vl>c*8UJ2?SxKWrwu)"[֞K፶0rWO z *(Tei+26|nƏ}bcta9;GLzY~"tp!vsգZ54^=nxbWnwy2mPln2g#p߂=qNn}O J|g+2UӦ,/m[IpJ'_yǩy^_NjFu<|or+e>]Һ^3zqJXE*jϵ:N6g>GFF׼7W[5`5?&7 m ؏=*' -sюZnO/{m[Pu41yHnמ#эj2I:hvὯUYrI&v< ?''W[f1$QB|:dޱ:ʜi~Wqdbcksm#Iv2]bcA\Ò zWd1rK~?)T)+믟N:MM-HñV@Jn6Xyc'owk]sE_=t񦸚ՅG<^Z[d8;IϿ Z$۵[OBU9]8ꓺgOVK^1|wmv-Hx.e+`yke۩jIvT4S{y?3>!^/ CQcp?319u8 WVRCއF T˵?zOZ!ԮOFxe7so@W6Sac5BJd}E.K⵸kٮ.vHcb1pJg1(G&3(ԝ(%ϣ|/f* Fؒ3*[}y-5Mպ[hᑼK*Km}LJ2>yش$6U/?,އROһEhuSl^#˛Y6[Ɍ ![B22M39SRoM>3tn}- ;P |w)ʪ{<{Q%R~y^*i%[MNC4d&Ay,<#VΊrf{u'*۔m B50rС֒o:&yl~5q(=S*9% |j$r,k9# 7Q^GZX4:uh)_[/4a\fr,QbqV_+.5cVfrkH.$X&U'zңJ*4i$]hfDŽ|WgvD,p,U@' j/f)k}R"5oZJaul 2=;Z9:~~]/8$x 9n9>|Wjz} 9o߫t^1˲X(F]衇Bwqiw}䬠VeU$A#<ӚҎ[NE.DzTpu%qtkoGnЮf᳑kXO#XHrF~GBm.$gz9]km$ܣmj+xMr+ ˌzu?dy>ZYYh:Rc;X}molc}1(ɯyFyF9'u֞Gۋ[Qq,\d!* [9yڼ>j{eK]~][:? ڥ흝Ω46p$+Bp܉۔qgjrrWo+w9eB2~#^1}fhX<{koQ,F5(cڰ֖O ³cuq댝_=]JmT⤮ ׈5Kdi#nS鑎{WⰓq^G%*+Ǒ.Oܚq KM9 1U`s鏛#zfVKFXeen]K VU%9'9kK[Zz zؖy@^~1O&e]-n>E7N 2H㜏~qy|+C|;#*\2kKMYVKUi9RGx#Zh#v:;<^lKm7˙[bCmʰ15J(R0UkX4WjF!߆W ߩEBm϶,:nV?cޯbzܾy$#6:4+[*QukGS／ _j`kż85`-=9)-a͕O5#sv:TVe5󑥱Fry2XF\{3i!,~8lag湪RZx/ڦR\G R~`^xgWj_ߙəT'ɤ`S׼M&_ TRIhX$nq 8_%ZX=ocښ>9P9:}oі{5PzS?tsUJT7-[ß-Z\i4'ծ@"Z]yy9A%5&ڳtSQ^۩ŝR4 :$4ra{ȮRif]x$2ܬ6.7w#W8تsn;uh×޺hu SEdel# y9<}}21kɵs ڌW4[բ'CmamTwTɁ1I>15*s8=buh⤨vODuV 4$c52Ƭߺ\Sw:⼺++>./TsL6ܤӷҟ==g֕J Y[ūuߝ6YSZIQseCS]^ߓ( 9*1_~7GqX~jY]K:exXX|u#9q]{cj?uӶtS4g#2_q-Zg=5jnFTie;jg*4 -m:[;="4_0$1cͱNy[=L4VZ:B3N[ָjb#ȩf8RIugjZ1$8#Tmjy8OW!ңxRb}Ga\, wYYlR;kY7r`c͓٫*9Uj_Y۽-zR78eKID*_ܸV@t0P1 ;k6r?z0 WӕFꖗMMLDҖYሕEB_E/7*N=V0X*Ag$&ї,3F%oZᕷ#ݸ5N\׋_בH^̹t>g*S%]:x7,ѱ$/WR8}_X-"cXc]V͸0t)ÖgFIIuZ6ielۮRM_ּR[[6AotiXIrqyJ_ig/* RzFf~o2I5T4c]7НVl$eQz{Vo{D2~Ҝv4+{ ۪8}y%NVh璾|v2ZO[,;OzH_Gg3mT7?# ۟U~S6C[/,b6Vܞjp(VG'-Oi;'r:tCR*h9-;f"ʫ{ :uܗatmfI0F#ӂpA[J)F2撼vR{?"Vk8a\dy~w rQgU0 G#Y~E8_t]I?2.m%xݘڻiԔsJI(l眜v5彵l<"٧kZw&ekMZƬ=#[|Rcy#ɔۭ)ӏ*z[mWk"o'${_~nHk)TѲMs c F+]T~ߩCZ ?G /BhsSV1d{,FKpF2ޜԬ;յvuRǥs4su_޳fG:pjn2*KF-T+;v gDbkLS#:٬e ѭFW#r3ymk9\<4cu mد08wB%(4Vʪ啘aVr:rZ=I <2<ג.[hN@߭`,QFKO+¿.=qȌ朹eEE<1+o}\2-֍!!.\9NyJ璱NifcQ#H{H63Z\Z.a%f]^F~lv^r:S(Wr{_aƢYa|'ҹ)sAl\kD8a KfGS8RqKTnJqqЃU- Q%6nۀ8A]~+2}8hG+0e$*d1<GN2+/mPƿ6''ⷧ:h%o%C*,.۔EXϗߩOR3.]&UpMGF juct9)eʽGaܼs^M"6)G$z;|G[|Թoث,XҔ_({uN9.Ujٍc>da65u뀽y4e j.:25)R[ M]̣S[In-o&MHĬ^d<ҢH:!T{KErڅVq2|ۗ'{S)s% jp.Q< uV;~eB LR7HkSU5c'2!۵_`硢]TuE-)nX_NU*(>[ol̐In9O)7#8$B^jbi2I[S2\0VUTt8)]Z U*7jbjKZJ-32v>~9J5Hd98'2IhJ4}ey?)HjT8f߯WS9c܌Ҧ>Y95\RVOVO;uE2>aڕ:Vw]EJөJ=E&I3+cw<%ث.{)SA5s\oxt?v9Z"߿bTd~Zm-dA $n_Կ*r]!d~UYTRw`r-}6]z*-7/˶4seNKGdYyӆ qa[=yW[Fw=ek+upx}kik#UiVײ,W6=heB҃Փ˅]. ܬ=yVMUd 7CӏeQQWZ8?ylx-oFb?OƫB)I]>*A=_c_NmqjY)$,r##r8qvM8QZꎛF;XLc'5ό4Og&ڊCe66PMG*i^ϱR=>kZ̽cdEnGIc9;rNyRJg'h'1(2>QBg<`g{t%.t֗3hO?q6#N{z{t9Z6ڵ:TKdh=j|GwbGn~͹;<ѻVO*/W*\ȹW@Z1ǚOM2 @17c!z瞞GݗW]SQwYsnJsUK_C:㇛z&22m2rԟ_]ĬGI&ө 9zROWnwNJUCn`ӡ r_fgYVjx]VZ7> } m_[̪Gc '`}ʷխ>OS[0Rts?Ļ_ ɬYͥfNBlc` ]~ޞGJ8yb]mmmk>U=VpO%uUJmY'ʮO{ꭿW="]#RBuHNMy01RsO~GU29_x_­g\skSs%\h' t5FB_kEv =SINi>U~Y~lnĝʒ;JoHSN\km>%Mw:SpCzclFv2*c/nk`cZN9^^z?&XzqG[x֗4זSȸoyKa`6gbr]:P;=У-oߡ'zώ~4]kTnoXϕ#.9‘^EJKtv:m̩b1x Zz?~9|,:x_>k:̶7b̷A8"DfEt߰ )QOKIEQb=*nz5o$ߒ\mDWV C'+2s1C1^TQJnܘy_"աI32Z J^`hv2aT2[<7ǹ5RTVKJ .4/. Fbv2c xu%(ֻg[FPpG} -Zo:9,#Ua_n}|^)[NݮJ|uց(m$]"ɐ[q\y+N\73Ul[qZ.+ۋ9M7pcjݴiZ*EMס_떺̐ɨ+'o s/Q7{=ѲziZ;XxT:"urѷ*? ?Cce*[{YRRtyu=3Kҥ||<$y7>y81_A ?3qDdb[Iձ2W]m(6ݓڽz_ gRiTwѮ )H.kXm1;O-ަu-7M:%GxߝӶᷓNzrZ|D_xAaok8>Hچ䑸rzR2Jͩn}E"XU8kẶmcn$V.rKu:VrW[[Ԕʗ5Dߩx 6F̨]?ֽ:u)~ޥH9[#Slx%ҽ:5[',DaUI%bX+<ˊiJi{JO~YěF.юZNEZԽ3ҭ%ܬ++tj*S˩dQgݡTRoG簮oNL*rZ'b,_G̣ 1+_ӹmݱ+)U=ӂ2G:g՗GކfomUgoƹu8NKicЭO7 va@ ۟Ryo /c:M+{[MA#Hgaװ?)=-Oyt13IX)=:FU)(ϡmbyn0=^G ^DSrm",rϡ9񩅤̙)imE#asҳt.R,t}IV&I$VeEvǦ:zsjb;#OPJ ok81ڥ;؏gY=R{SEo'=Skcx8FT*|_&c猽iJu坪,s[F65Mrb5!ƁV}kN^m% tjOVt=_͓{]>OVUJ+C X&;W*FFG^OZBe{$ti~0C{#ZnVi[ʑ^\[>Ei[t!*Bъ{J%w+ɵw2}?kI{A֜p4e|@[|2u&1yLѰpW*qyϡ%˳,WU8}( w"2xݺ]|u5H}" e^seTlz\l=#k4Mٹ`@A=G9y,0x|TӾw>efث5rcӜq_5+׺{7_^x02py'FZhs<9XiM eJ Rv׵}]RR7},Ռ-;ՎQL8) ?79K K]t^wb,v H*jח7KM6@Yw;vzctK?K#(/Rk{?Wdږaqwh^O$Qs`dNzrSQӊvӲOiCT~^=>><爡_6o>)ݘ+f2ŒWrM)9)&՚i%uNs)v5di^]D ;1 /0ܻ$GÒ +`= oT)SNٮwgQYŒ},K&֗{5}z"Qx|e P$w9C|*iNggNNVD .l N8O-jN\Z##X2VoCTbSYԧ)^N ɥ>ԛgGnTm#w""6A9c~UqeA=gr~IF,\ ѬmDv==]wESŸK|ĈzGo|VZith*sV=Q#J?4tV5N3ߎ7SӖ G"kYFJ6:)GQg]qZq܎Z L,2?l}:VU%g;ebZR{p_׵._uDr:K5Ṋ5;%u$ `iSo8Rm &rsƪ쩿vNXֹG@Ʋs'^GiƕI]I6bYVO-VW, 85eR|qݒqfq_<3{]+-rbHIxn1Zܪs=܊[K ¶s<DFx+'Wqh7$6rۗZhΤyVG;?sʜj;usrԧSwml:{&3 1+ g!@skP6=UG+$-հ+Աjj-UQ]4Or 飊4*fR[jJZ3 {סSEds_]cYRfk[ U6|1\rwս+Ñ-ă1 aCu^l(ݘkGncV8i6yrP=u(8g(O#i esqZ҇60 i\ϚW $9=?sR۷pΌjٯ'#eEhnFꑗ3rr)׷Ȏ CdHr0ke*M@:߻UoN3\ m~2G1?xu'(bT]I.#h2~GQr(7/VVܻ6(I9ޗM>XJS=;"03l6rݽ+~rZ~GJqLvab 0yc!%$rGpt?<{[NVƟ,`mx$y=溾m\9sn4~Gcw{gьмEJ*u,EyQ7F>O<a^UɅ9Jor[`Ͼ)J*NHvqvaZqXQk.IVlv~^e?춵;Ē>9iE;!C/+gnzq:n9bi+jU:TkEc`#+9n})Ma<\:G,iʜٕl) F|6@GQҍr?#^KS.}&ifV6cVq]q˚O*gWV#:m8D~qh2#k1:%MW @SnkuAVq|Wa%s]OX*_+1gw̥~+ߧ8(WwTKS]n|CrʅsG\]RsQRmxLMKVؿ28݆yR`凄hrf*Sn9yZm;(Xʶ5Kx^;W}?iZJu{'?amCH1:ڕyy]AIG+]J5g. eRgWE,,e rS8}@ 6bƧ<ێa*qn[,V^Xh.-ѥ[us-V?}u6Kt˩q-+ c̊ڗ:,Վ>YVPX[3?~5+ln{8):o!vFcU)r6Ibs?˓FN88/jƦ"/+Ԉvw$NIsͽ3U[suG Rq~} Z^Cj<K EՙTݏZө*iY=YTpz0 d[][s}ls榧4chlg^~LF6Hی?ƱU'M߀TԻ~>htV[ 79 \^4֒ʒȬ|̪2OSɨ:ʲi_Oe*n^h ŵU\gZBN}xÕ-4Va8(J'=?.+}Ύn_iS[1Zv s*tܺ"WDZ瘴Ķ8<OֳujdOnF=9r3+2Ƥ򩭙F[V +ػ[h;M3[kG c5RJJɟMQj| ҔӢ۩}oHD,4ÑM_gSI[6"4 ܒn vG"վZ_o&OGmwkxJg[lbY<266k`z+?kJ^5NkѦt!8e4"+efQF4~_V9Ha#V tSBSo,($499wzcg]EFZ_b[IGeH"+`==00;皚sk2.TE4<Q_糕7xryky B. R3wp=k^jzJ S>dC I9`yʠӧnՎQc}lև=$#=&)%*윑[u9褬f͵*];OT )ԕ{~{.xi=yNGCj\[vsnsVKoQ~UGr.YT|fDgo72/qڶYVJxh5%vn[E 78ⱌw#yMM'̲Wѩx& 2Ic7ZMfٗmhItgRՔ8.r:S[3eU|˧jJbLeqloooƹ*S8TeNq՚7k 0cn 8+2Z1GfJwɹCw99ڥg{iԕ YIۧ5jT8'ʫ7#ds:#V13_*pjw,P[*÷13㍹XT)%teF*{_[.ņ$>|цSˎEcxAcN<bkM/"km!g1LK }GgzT*QnۯxYݪYNW'8m]nT4l{9`%HӍ^d*5N]_}Q]Lֳy|gֶF4jG\,,bP]2#8$sNzNkJp}L`i{[k%xMXm;~\XFxyY=w9A{vq#ZI{,l7J晋 7ɂO#+:|՚_r%N.M/'1mk,yHojԜB5RI{paufm7|8w=/z*jok5 c1R˒FHki{9z#rj 279IV#ǗqXg YKiy=7~_#=(Feݯb?t֮N q6NCд#!-g#tUkYVSnKc Y /=E+c IJR#Tk;~\7rzǵs)R42M~eY^v!UNY߯V<;{/;=yK$M\)) ~oګ'eV)m Coc6p͜\]jj:𲔣W#e\b O{Eњ{9TNvpyhTרcZr.EGrߑnwNvZN zuFQV!ї7$7˶ʊ1?N?*RS5JTiKF ʱ\<^- W7*a?ҺcvmTM&WY!TY m`Tݷ8N75Zokg"g3.k* ]kG{VUPHi72򓃷=ҽ55t7rӥe2)˚ PQYgF ob%s{xx{뿡ְ(O_M̚ *ᘪgMG//G,/z:z-EOu 8lUeJq'hSz.eK>bq^qΤTmWѿM-o"2Ap= ӷNsԋhW'Yys6Tk/g+3kjGd1y!{zR#-mQ^K$C2b690.Hfg콜Zko <{]x-{IIYOQ2wUwuߡ*d:P g'UJ2 sVlUyӫ,mWY|~QCMZ߉}d2'],N>W3"/7ڭFN{zޒRSIa\r~c#[y25:N7*41m,mܮU<9yƥJQ؂ּ.Hԗ$c㣻Crь*n29}u- L\;(@g<ϭ\I(&ĈjFl2pT`#ֹ~6_µTwfz[}$ycr>\䎝k*e^wtv8E:~_qVrpKEjRc156 2ɵH;1kY[Nj!*nͭzB0;^=*)I~u(JZ8G-GCN 0}g/g+8~6q|vǠϾ5h]^o$F &]~{tkS5۩zcZG#L%@q\YymJUe]VIyܒ@ҢU'ۢ2/OCkJKta(-N6SIF]RO+gï%:ѵ|*~궫}L uFlmQOzWsÏUW6;τoOI]{έn[cS9K6mfepnG B {6:n0VI&հԴeku}ɟFyXd?գ}FT]z7ϓIdh3򝭵zqԦHQZv~`"B b߼Wq]7ɑYdڶpOc*Fu*9Yc"w}5R1u4,hqœvn->ΞnY"1 oҸMJ\GLvwR>:QT[MZ\5{{/+B0y\EZt]KI0BUo収9+.kzU*r21G'r4D֍8E'/_S>r'1v%q99k:+L*b%~dr,csBwsSLE8Vk\X6yjF1Wz2q|'g5:m[yfUCWeSNr _Zhδb7$(]>XnWg6Ea9I2I kßz5#v;Gs4".q]mZ:SX|hFl*r잇\.gFEMҝõzz;އ-LCVkyZ @q׵C^Mj4Urۙ zWt]IƵKQiBW[A#ȼ+y`3#RvIn_c 51%4"审/q \n~GJ5,oo5 m_!A]JJJirܚj[ $q c$*ꗳ[}IRG+Zbq,ʄ#;Npǜ8jҳRm3J5}LmnHCmmV=sڶTgB"#.I4CY^zJ5/ku^ҷUz]n>5"ї7.QU{67uxevEeFVP$<ǜsrʲU{V#.NTL9F'i ƞCm݆ϯ=@]1J49ӱRl?#h~hW]]omș Wp2z*JI-;n*R8M?ĞI+۲O{pxo2qϦ{~ʜb};OBJ:=CueA xy1sQeQūFrs~us=#kk!R rFAmĂppu08iIk=_uf79{ｿ_k_i⽕-t=_uiwnf|[0r>e bmJ?E ̨c(ǖ^oo|֕"hQê"3f<7U}C㦞kOM 7m3n\Zmr叄co ML1۬I#,K qb-ZjIvOX<M}O;xQk ה̡pwq O厉_NSЭO\uW =Kwfe 0ןViY%mU5w}[ Z?G&Q$+\m`z^ulEҵ$]<9RǼx?^KVckT\FqdW$➷wO9)Ys_Go-b].Ÿb6?&q?z|Z=:Rcw8KYm_, œ#d޺iMsFS*BSwjxߊx!5F,0+㿵uN29JM= >͹J޺NIL.J8ֹ+T=*{*#:$6IR[=Xܵ[.Z4t_[yk$\x#$⺝ZmfCJ.1E7۝&IlrE!|eHp r;T Oo=g*T^3wX\޲l.iע;zu*rI3(i;JuM F|ˍʊCۊQr}7C0Zm=ؗޘL20m;N{+Z2Z$ٽNƚ_68z8?rq䫬R~= pgE^>$flazqMJUdޖG`![bBvgegYzyEyR%w|Th~Zl6E԰‘uV?}P*hƵj:1 4{㥣{X/LIHr~sIvSii}unkEh>(i%|XbYyVGS RߏB}l|āICy}4j/v _SyZkb s#zבԤ`*|&Ѧʿh18bG^;cpԭ A5RSd[^veoݭ`zs὇85-L!&gdwQ.NHz?}vAң;xWʚK!*8(5-CJ<~;KmɼH|mc$1ߌ&Xz[s4A^xE?nz^b0Tu0Sz0ψa;-Ϛ lQz3ҧF#_x@,%DkovO~N3w|Rv߹ 6cs%qo"ڬV#<c 0qJ]n/URۦe#/9wҾ4oQ8-ڽȰN6LV>Ufݕ\}z[нb]iݡ w${*hۚNzuʕ_?CKW|i6;f,3=3XʵZQgE**G?#~,$ l.dkuQf턒]g0>ۣ,:W}߻_3ww#6j[$SX.^[C)Qp[>+vZ0E2e`At]24k[&On.j˲z."َDQARv]ץtQ0ӌmMn&#qP+ȭN/sIaT.AԁXCYӕ9kxYa_jö7˽63lhj_+l]RMm0RCҝUJgHƢQn&e{4iy7˿ &j*mCJj1 {׶Ü.~ONJNޚ4i״ӲN>я2,*`l=x5#)i}=mԒy忺+SFvt?uUqӌtzZrQNn=7~OBti=P8Xy[aKלWN*l]lmar-J?w'/û&K.=;{rOnn1_gYPI-s)m|hzt$ia+E2#בNWwweI&ᶻ=KM{jl]lźF:9|CZKPV2~6!wp1khƫ5YN2Քmv+VtuXƶ|&VۀA<^jG›zke&k-,pr=.Io$McWJRmkqٵtuŽhsF~mvn$x\>k=%jk QΫww96ESr0s֦x<<b#^I򧲽5>*{bǐ83ԣ^*_[^oԧ{D5 F<̙$ ]8Ң7{2,=xU;Om, ,Gz{ר5of}DC^{m}6_w Toz /6UNg/ćFy-/{R^lkp>V&c6A4s44 糸KdehVU#ЊSUzD}.:|PnldRF*IБA^\,W^v9q\?[V~O_:/w:Awqv0wc#3^ԫQPJʍ<$a줜ouk~="eM 6Iۃ'o_%RRw}o< 9R\ r~I]{?P*(KK%\>'`xSrOĹs RK88g86۫y=̗D- s_8-^ YhtS2{LrGtn߁9>ԖVQG]xrF1?L|U:rNӿN̖ dۍ3^=JW^F#ҡHדny^miF2ڊWSNW-n )O>t\%QR5ol,>˹n$% >NN}|֓eTNlkg)ieiTwy3CFӒo/,z#bƫG>djY;$1ҏ(/?ND#yKj ?+zV/ ϑzljmE3r:ӭrՓcJ}KDp噶ѽZ ~^[ZyQ儬8]k[ho̮C|SR4įz'ٮɄl ?s&]h=oP4lghP >Jl{4Ԥպ>|Lx[{ciUa}~lzWJ0cڕUy7uk|NNqt P*ǰiQmۭ9Ԧ(Ԡ @$hs98TkΚ}B9.ZeS}cmtʬat#ke*r*ek;' N@I=W>!G7vקpQgA$p*K% &÷2veyjva}ƽFt|P\rzҭG/K(^+qjvqE+Sx'~qsn .V+#9һF4g0Gqq󴩏q;c>8 *4[Pǜͽsӆik:eӡW>3"$T6qki֥*-GGUތ5[s(-};u4̖̬{(O܍fTkB>.EU̐Fp[̓y56k*Ӳ]Hn̮Yg9*e4fӓ߿Vi&3#~eNRTc$Χf$$kΉKn4ֽ̹7ELο2)p>5OveEFW(}¬Pav 3s6Hϫw4jR\S(+$y|&sL+3HTc۵uaJ%Gwyx*CzHJ4=ԥ4GR6,*K(ye WrlsGLwo*1v3j9otVLR|a ~ygvYʍNiIoA6kc#7_pFFkQ1#30 yQMo[xX[*I2 w<Oz1m,EmEp3vw8KTT A$,ŽFWR0Mu$dv[oq~jYɢF17&;` qKZ).0#=z{VVTc(JϪ{If_ ׷Aֶϩ6tr¨m\#8pOz{L_7!ߺ8dءr3u66er2wYF؋2|$ '%xgH _e,ڬr3Ok>YzRNWkpGhcW56҇X6윚b[G(nq?j9sENm˖f''\bF)'.˓cǻy1q7c\)C TnK#G ƌnSܓYL?ywOS9„K+AAF4%N_x!= `:>"GǙ2±V?.#y q.[3u[l cE&I pq=_c\/5JOQ#uʿcұVP{t(ydzPwgUR̆ळ4"ees4ÕJOX B oStXFF\jp̐xeIdqֵ-$e;yV9FvdžEvь^/zT!4M70mBSZc(Z]hoN>VS,'RgdŃ)l} G\d|[OSJ]3Ǡ'ϭT&yz|9KIwsJUۗK{El|qce^ͅjRSZHi?,kc;9#X--rBߩ`y>au\,2;rr1I#[Tb4ov4Oe.?,Id_5FcFbOgNܿ+vH4de{ic 53 qӨ'{){9GS{,rLHې댮yAq^?mث[B֟[Ctym71ힽ8URs]켻XzoՎ[O zOLc)N^ʣpOut8YWo9#<>^&5IUS?TӦauRx 2F:?:և.*7fC4 h.ZUɝHͤ{TӷG,ӵ[c9g֑QM<]ІigGiR!A#zt:nhV՗NxP$ap2<'J7x;ʥ7{Wc^tۻ+)-ћ*/M +y|*ME6ڶ}V&޶|4gXERM]۫{w[GO/ifح)b{+)>l >- &)u-<SKEJR[+z'fl/z/O[Xd5;y#bNyDSxpyjkm5K͸^֥-լ6kZoc'94y0l L|Ì\N_^T>Mƚ֍ikk˱MP"i.V;NsNkɎQ Tѓ;om>jM㝔2=s )VpA FԍG]ZܰWmVs^xkXc$A=nzו_)Jj0{?#ȩs٫a4-} o,J̿3#3qRY_Oᭇ F$ӏ~r~tj׋t_ r]/uFHÄ "0W]MldkQk4yW 7:8>wZJJ>[;h8o h[ÓMAkTe^ r1yЍ*sR&d[ٶr]zYO%z'Ķ! GD}X*\Z,/k3k*彟aV*\s+'.e>6ooz9xZA'jѼ펪-mlJREs(muuPPQGڮw{'{4-BҼzzGTʤ"[tp=j6KShʤb.704/ٽr1ySeSGP3nf r0O_ƴN\*6B՞FнчY 9<NR|ױeUK٤yuF+JQtc_R)3lkܮqN 28Q"VfD9Nh)gUHN4[*Ll5J^Ʌ/էvEYiWw Z>Zs49kGz,>VeO&U|54gB)붫`Uev'h_T_}_U: .2b@hzW-j+GvݮcKmWv8Lc Ew64i(EΛM(㶓i%Gv b' TonTHRoghy2=K'|œr$9ҼUxJmtƝJKs̞;wKt9ʲ/i%uc{Og1ӿ.QcN}vRRZįG._*y>`U_GF&);_>R\\i,[Pedξ'8VeN?SڔMsmOK> ;Eafff߷돋*C O+8I]q7?xYdfh* y;{g'p9h7;[{_%wVښb-{IcR*G C!IBA|rp _AQRw֝oxYZ-mmmK_dxgN+}̬0$d=_]sI$ާ8 _4#љ$3St3 p>9 {WBJ3j_O9j%,_0K#v ZndLeOGcԾO,3$+2dn 5ƴtV"G d2z;fT8p*~Jꢶk۪mgo4f88;L5^ևi*8qּٍiFVhX.VBj\utkN\^jEk a~ar_zQpT64&?jt-[ q,dzZ6 Jϩ(e[%%d_&_pG 9?3R\K}l^vDg-ˎW@?C燴{t]gIm.UD]+);*s>GuZtʳE՚7 K0\Stt|2NkҬ䔕R5ߩoRhF!F2su#8ڽ:5H)Г>{dpL۱+NI`H+08>-O 4]ŧ4JM-ٞn,!8%󓎣:SI/hee伿?=:1S-޾{sмֲd&mQ*_#1|*~I<͛F0Z-fz\S.h`gZ~mzOeiሟIdl ݏlU׫T~ti$؟V=Z5ʹn99מhJ1֩exbimQ}h?X{Φ"6w7[ʷ4}-c#n e/q\؜MOkgWWFn=3rk~*xGz|n&u$S*{Jrվ+D׮tKvG VPŗ2yֽ\/Zm#\,)%f<3 ..m#23.,.pO̹q_F:nMߕ?hѥ}$W8/OC\++#&@NC{}=4}]4E{[l.Sw nM<<_=aW0Ԑ7 Y@Nd$Z~)iZ[mZ/Z1_X|+]](VZhGW/MX]4q]Gt >_1Ρz2OѮM8WF߳"myeH#!e\7gIɯgkNRӫ{[ ،+M֞gU|'("F[fy 8xvK5>O;\54^]iJG'j&ވd0"}VP|= 267e̛L;ߧN8>(R)9_w"E s*/:p,QF>!,n${#=s韥sIEfM8ӌo-4,<""9='72-dPqbK*1u8_S<:0OAn奎cڸ $;zb:r:x>Kx|LWSJ9^иU4E ~S'I$⻰-sҌ=4mˑ~d RA<?JF3i{V,Xdrorv5N<1w$Y$s؂ZҜy-cE(رk6]LOҮQI6mFҳhI-<#W+F*SL$We]LwceqMiKB3k8j.㪓+8ƜRE:|Of6N[O>'v#RKGR SM.@Ǐv>r:rR-+z!<\+/gkܪtkЫWxm̽@8Oe죣7t]HgB$207#ۯ=J+N^ZqIHqa-ÓN*}:&yRRvV倷Χnٗ 6r=O|2ΤcZ*\[C.Vg]d/0rWJ1b%Nq7 %'aZFJrEFܽ]Kdɶ6Eisמ\ yN>ZKs&lkJ8=yqӃZo%Ҝ4Y=Qygm`.Cœ< 썝Eϭ)ʍHښoى{mmwhk ~i OAʞ-ʕ)_CO]oV i#18U39OֺR2]:R[c2I )G?U2ՕB#FQtk[9=`2C0 ;۱mn}Z{NWWڣsrlӏ/^AJ2_5j &$Wی'59d)Uv~絍 Q~ na8¯]n8Y5zeǛ (MInv_,Gcy)sh/ J\Ke؈y$7?5N}JucUC~.$vXflk(ʷҥ9GlF0|Вp6֒)NOYm{R(A*Y~o60vc<py\Y9tZiDP5[edel=Z!-aN1[R澭e清B\(ny=p*):~8횊="HUU.qVu+S;Jf: [vb{zfI{5 J4:ӫ-ZsL V`8gߚJi8&Hh[}Ҥk,E4SQ;J?q"ۢFC˸u,Ĝ]ϊ37m-} "q#>oᩭ/g+1:+Co vjsUDiHR42I#VwK'>^zqQDLjSMX]8/.ͱYI @A?uԩªT)FVsJ3o&⑶ 9s{+Җ"@ ͹+8};',} u]{%U`"$#VMm=䏭m 4ˡU1*bReYG˷} P؟i.XrFEޅ-h>WNk/y?SҧBTbz/C0ؿѴ)͊*^{;z5Sdpou8ֺFRw՝%hGo%F9#1Ӛxuh6q\#Q;ړVUК/~T{Gr_4s'8k֣r؏zӾ.b`Kw%Z1Ƶ?y;s'ݱNeM}JlN;eUeo:|EJwu^>m;FELN\-zt&: LFm?yQKty+ {91i?s49,ϕLΠ.9>jw͈K΄GxWGK{M\+,kgs]18ԕ=^uo6b8"vLoԔiWotK S'vw؆,gfhUp>bWsԩ1ΥYrϯ;'Yڄ-]8ct?ih5*EglGconҵ)YyS7cg˕!d`NAPzheԔf;yzeq/7D善=3<Ug(RX[{?oUZr$$sʠU= (abWM8Լ{;f2mcu6H%fʸlN5ÕnCyVmrՙ%h7>Z l2kÚɽ:iLUIheܨ۠קҴYFM$:4]޺\t䁚#>\֪2uZhW[zb,cHSR玧96eU:ΞEjX,\F^J0]QjSq߹4^3kGMͲZs/]8Tu#3UpA@^8st8nN?yur8otݵp$̍c;{W<}Ƶ;Ry #V9bTi**,Ǐzoܾw՘NEzcoNd! ,kq$S1$3^eU'#Fj'`WRQ[6 m6[ d02I-36oiJ-?zWJ;۳$CrGWz΄(UVM4;,&M6̛d`kERzt}eyX'\پo/p;#q%vרּTH;,88^Ʋ{;?]*o 8 סl+f#rpqO\xP)%}ċk7 0v8[SK2IrAoXѡrɝ`qS^ZSQק{7fuY#X>^99QL!Nzc(˖Cp*YX+r=x>+Dwj#TLˍP`c~4ST){klkqad2mݎp;=iٮRIHci#lܜ?ˊ)ʛcQTmHH4$.G oOz8J1䕚Doh}U)ۅdZzKOᒶϽG6gAHtO'y^U&BWnŒ(Hcw\F9o{>F$3,-0\d ? x5OsKšGg .ZA^Rdzn=#⹜ƢW%J8wM˹sUdS<>t^^DUo.6A玽\DeM#:i\.nR-\=ƭuU_8ԩM}Z*P ֛tp<$gVߝY*|vK_,yd$ OTr;zQXTuPLú#kY|}Aa8cd`?/{ "-Tc!jO"hɔG :vjjaVƆ*1OMFp1uQ#(Y}Ӎ>h>E'ti+n E̮T!g 6Td0A 4evNq)_=߷iO~F/^y$[gv'o~? &\|q`{8T<*~\P澯BU;TdI[>c+1U5ok+P_vv38a]yҩ*qXF/o,>єN+_MVlGfTy^9Kk:5#`0Ik35FSW:*򢽞+RѤp&q^J %OhII:6r,,#l++W4SUn%%F,@Ę8gO hwEt߻gWٳ:ݕf ǒ=GOgڻ)FjqZۭ"X#69eqr{S%멗<';vEViFS#͆'9 nsS˻i 2ru^hR9 y@A=s֨_$B 6w{g=k9OhiOY;>ÞlluҧG2^ߠn8bTf\^ӸM'S$vz9ң[FTX'ayKH˻gԟ|^-ʌ7Bɷw!8gc_H^f ?w1_b=+HU$S(˚5y737sq꫌%&M22Yoq$1-p9$ W(ӌKMvHMIG}gFsE"ۨIً(q>8MIɽ4oȯm8ɨ۱r{8#ҳ?lܙ)O)Nzi]cG<cb(;7JPXvuxRjyh{5=_&VP8d!My.mm~>'YJ騱Oqcd(UQwz>U 9NRrl6p o*=LD"Tx)6[i.\7 @SB.7R6_u2|ȡ;c,tkSn[*Cxݯ5buhje|Uےwgq]ꊋz^gEUK0OŹ5V$ϿOҴ}t]F+Qow,yYʣ#Ggk!S]Guy[;c=.hn?gN-˼eoYUJZWSC}WenV(-TR,oga,2!wTnnYrͳn: '>_ :\^Dy|H<Ϙ[Tœ:?>kȖ]* ,ԫGUՇ*nZ_dKڹ`G9^-n14o&Za[= g@c9'$\co5%k>ڌ#%>mynE$k4fV+±+Ч)KG{+_S.ͤAd-RդN빝ǞX}bGWiKC5"n98>gM5*P^vn.̶(76 qy'=' qMK^뿗1N ilh'[x?sRc:zk) i\2*ɵ(R$ɵͪaԴZo-5Kp$;XV5p+8~{V|{Rpq 3yHP7g}RHX61.˯ſ]E hv$l yGa\T/ge^iSJt9[vFmo9@8{*?lq]ΚxZu74 xn7sx(jS;Oa:  ~`]K=L gUmt[m+;ϳiC3M*d0 gNSt?+tVjGKV2g4I#dh`. ܂+}/s)S8~]IVݚ1q 7p2?yƜ~-7í Ht:szvoiSiܼ-OiQq9s\2Gn_ )ѧମi(+6Uȯ9[̎isa=8#5<-W:6槖źW{_ֆ у7&1)~MpHkt9c.Y6{/G6cH2:WjUتթG2lXO"yE^Ռ^R%-cMFζR2HQtskE`Իb}OW.Dk)mF9(Pj-n)a/=F=MIsMǴ8#׿(J-Z:>ƍ F68&y$8PT{ѥhBS58F$Kq̬ l?++Yaط{jkP+ɩy_P۔TbN־ tqWw64,H#h#g* =3 X7~>:.d46>,3[Zjx-YI<|c38hԎ*LDeKpYtSj*K`-yx&Юp`[p;tFQl)'8F>ۺXFcn2; [r5czZI'{DzOq|LZɧ]uN120Wp JO 3ﲶb+ C_פM{͟b*0n37{2qdb_s /?9vq׭yrT [- 7o.\rlW^1RyRjڎN+Zn\i+Wn[_zaFG.k-Jj([N'AZO%9͎Oҏ76.J}*\,La FФAޜ|?<}e Z)We{E?'{VTѳʦW{L$ mюM/z7[ղ5m^ɶ׷1]F4sOi$/2+:Ǐ#80Ez|^yz^~a˧eEo<]VRVR6k̀|y8zM<>'12x.Xў%~߅˻!mfHo% ?(!rg˭xu$0x:o?& uo>u&5̤5˹,2FBN;`uppΔfr:nm=C|IYQuʹݥE/d;Xw98olW;%4iR-W׮/'RSPJg^|XUӭ#'H^gӿRF.ۡO~]+WJ9Gmz2}$ܮ;\5V[Yipt-vx{xRK$$Îz]TQ۹,.WxW+^Y c8ur 1x^M}䉖S:i'hcm3SXٲs}HqN2RW UatKm5j;տ.âɲAsHǸ\9_VC-mh{%gT۷mjWߙP˫8V=u^'Io-d'nsFN9\1k`e+hշ!hSj6ᏮH \vҖ*5՗D].2D]X RG'ݴڑ#Iom,z'EiJgۡt&& yE <\ϗ:ZQe͋O+Ɏ[v⼚ه$+lʦ\V^#/-<nThvRx|NmtܽuOqtQu^|qW(ӻOGO pg`3~ycwrΣz'Mjuk+GKtfz[㛝>ٖT,'gnzW lqx_NG*1jK>ҼEH,Ē+  c ^Ǔ^>',I'5qe:[߁G/chFYٛoC|u#(:L7%?SI:u}Fօ֗R!J>~_{5U| *ZrN;b8[]z߈'ѤQkIsGuGԴ6iU~:rA<]{J%pzm$|}az.:VrwSrܛIIy|^Oj%;_B)ԍ$4Nqyc4˷*\W/3d}L?oZ/6m(u xЅ•#o5]rҡR>nIai=1n*3&8>-lD6*lG}J>ﴋyayh sԇt57)N ^&զD,0qw}ZNh(SLk%aXO9vFToZ9QA+B2Jg)-5*JǠ7ƣf=`vSQcc,<kjQ᡺=eb3Iy郇xM/ǡG=̥uwttMG5Ċ<%dG8$8S,u]w_|e+G/6RCD їyJx٦|'nu!;{dn[/BPzC޾nx~}wjrOƋgI>-^z6c'J$RVt/+ZQ# ic=7䑁 c<}_O |Oɭ݃'yt]V 6ҧeܑZ"ݹ+y FQe֍}\h-ާw]#! x78V<" og3Ir̩~]0G3M.WzKMl[H[VT?]wW[dTeˆ)(^WvQO)(76J-(I6!.HRmH‚:Xf.a8}]j94)D/ʏ$=+ϩk[cΤ]'czD2B#h0A0+;4l-e~~G[,/zu#Yֻۿ}4'hrwJd-?)tя=R^ٸjk !YsFgutx:r_e) >KVu*59Z)?vtKgM$HmwO½ 880ժHo~(MRi$m\rs|܎1WQgcgP{Fޟy$~ߙH`b ϠsUࢴfѫ(ks诊:7 ᤾{yn79;N GXz\Ūk򔾱]ݭ;Υ &u'('~z_[K z5S劌&u9|3%3yq٣'97GNեJTrKW{>nk>0-rjm՚"{;@(YE[3|C-hmޤm8 c¦7m$ݚ}"*w\̶8B; 6&b$*|T1Rn-&MzJ+-%g}[&6>9u>~^4E6m?S0O鶴-)4k{`hd ?1g}4WV|p*TE9Jn*oc|zq\JWJoςu&EBy^hw}VoTuy{khI~?ƌeL=jҌ#}4}Sc­Zcw94 Qo>iWֱʤbԞ=|}bR.2oc)݇#.q뮸F*${3Jxx)7vbǪu2YFvajhk\G4y\]ޥpQ =+Ĺ6˧CԧFQet CT] Xn,1E] QZM6~g>279v T\6ru3 6۷=l3-KMU_/ŸؿL{ZRꖶl[ȝ>̠-)qCԕyQ3_սHezF1<629*2O)fsZ֧(g]&|GSg1^yR]u1QN.s's4,ڽq8ErǖacQB<#U.5r3`^#i-n{j2WImђE>]Ue@XsOF2j)S(__i}19JQqT=F7ׯq燩N.Z[RQ$_[H+ #/VrΝR 7dM6cL4V=}`T ݹdB9T{utni,'74}LI"+u?kX1PgFf}ͤnFۚ5nݞ{VyNi:գ溘^ (n͹03ɭsoTFW;>вLsHWv'o3E %:ԮL L?mNwOC8M ʴѢCx 3L^:\-IcϗpI[;GA+*pJK[0Z%4-#{n;sUQyVUy!WVQhd6)XF&nI-Ӝo\,cZ?K3٤v启wj-Vu.[zՔZC6Wpk*JrZ)ѕOSyx$ooN1i*yE(;Y/q$,{ ~c7Rճ(V҃˱~Y (ƪHYKu%ʖU+{99/C>|)YXa ӿβ曳FLEvNF׉ gN7H|:Վa^wMl=L5eeG3{idKFE'zWԍ+ VRؖU|6^u¤%EkcB~^*B;X`njOʹQPQ{<}EjZƫh\ѕ-Ns=MhΑcÆ_jN=HǠ$uJrw>]h%0$?e'3_Vrc#:W]Q E2*4`29=v[TOy"\GFX-sxyыt^"|F@-djI`qk̶:+QT^e䑳'\rnNzk9B=V5$BX γFY[ ̹A+Ӆ/6(ѕ% IVOݱn:wcQrە{KƩ,6pH50cLOKȵj"fJ~ep<`zM`Q޿wR[2Gl7:s urUF>͹;.|R%RfV*VEl|ܓZ>nM*r.cv1NH\0?Ͻvӧt:jc1ILlg['Sݓ)jۊԒB" !I'=z]W.F_ٕtFwzE(rV*U/'ˮH&vs& ?8upuV:[*$-xt=?d_+o`$on>#9ZI&cЩ(i5e_&SR'?oNM}ƕkJ3z2BнȪ̡t [{))4Qh SMl$~uУ YiRn!!:q$?q)7Wj==#\$#GeYdhF0=;Is]ElsƝH\IyYj圃C1 A]v%.0hFU`xw` MJo˩8NZ\GݡZ8li@K[J-M B\ޣj*QUNXlenڪ6msYjGD6:T$+G#oVTzp~<}q\rsTrj:y=)r6jS|!b+̙9bG5Z~gi>]!-ʤ=-MrѼT6,yO"YgwvQ-i5 /OZ۵UNU$}ordg,ۀpz#cN(ɵ4E^[TO4ryZE<JJ2ٿzMJmGM" 9U4] kr%]me^3ڣ)nrZ*hI.#0P߼ey?^ u]Z|Gi^Kt.\Dct吰ys'84ϕnZiƍ;u.iZ}9]Fv<&ќuo=-4lY[U^qOҦ^VQ楳ܷӚh~R(r}Y{GMNG~eMB{ pۇ|ұV$sTSsLm8S<{WIJ2Vؼ7>ީ=_~|\ozs*/:3dIMט>aUUWn1[''ԣ"Ku#/n-i s3ww#M:t+ )ԧſFP<,zk!.|@*|MzJ L^:nGR:\*dss[K4Z>zVwmjZ.:V>춺yj&%,_ AGU_MJP^g復+(*;Ǫ~oZj:e=F ݷ n968Ziǣ\-E4Ԟn9!8┶\pnjMR-WrF$7 m̫" 0rGoҺcS3%Z;;hEPIJex5bS 8J{t봿? m:qXhʔa*ҧ5ē8[YUn?>>ogMƲmKT]}};Kݫ[WrN-o[FTyI&SNe:LewKb4i-1 ˻,1L9ITԎ^Z[A-ǞY=6n<5oguHaVf'NxN1$v^/CTVNZ6יֆ:wѫUV8=qS^}hFrIdx.|}oksGF>HCƧe}^.7ǀ7s ToO8++y]߅t֚I8kenֺGWS٨;k x+ҽ:SI9T+]ٷuv.?yq};Z1Sh]WIibeơOb|N͞}:%6hH购>+EK{GwϦҺmRW4R֍GY鲍X,n=Y|뵎9Ewzu^Cu2[Y}I$lC*}\(qԩ-iZ^/.R8f^}w+驝Jm.tN+ZEgV,̼}=yg+-/]V`#WFf]7&:8ջtu gw/zW] v5UDu+j{c\cƸ>]4s~eEmFQ_a˕5Τ\dC0lIsvV[Q+ČZEfC9YQoiq:FBo~\q>Ɣ^f}+H.WeurtB\ד#I#k7$҈'qq,yk_f=c,RѫHGg܄=V4gyM]nFu }Ͻo ~ɡJTO#fml0-ש5VuZv&;]*G^Oޟ}fO ۵xB3Kr˜NG&Xj5{.<+g$C#DZIl%<8(/*l{?GGf{<4.~z4q ÐT@kÎUw~nPubxv^'4ZmY}P~g-=:_3*8>Z9 Z][qp)_1d y{KWS*8M+9%Ͽil k us cx+q>i98{i}_Ң=[ZZ+o_jqHqr,k6#A75=8O[Z]:w}4e*1-[Iע.o?[4W2.:UTFcob$|(ܹmvzuwnf4ptz}W7ٛTK?Zל,r۬%v$I98ӭ)ңm?Gvҷyz}nvw= 4!~e"խB/0i"iFN{Z[6f90T[N6w6gIFI92-sQe{X8 ݻڤ`uYB% f bgOU;+(\/{qc"WImnw,~gt =x1Pvԥ99{>Y1Gmi~8\A]o} E9]XǷi-,cnri<;\& zҟ%Z.xŭ&Wk#+Xx O..)EmHQųteu'Խe}ᥚˈwmOnUOFgF%&1RI8䐣?:K޺rR G)X;U$e㞕*^R+k`HwD,3N{N2dJV&6Fѫ.v$g~^[U=lF[qq?1 /yeG[I ;ca[EXT}n1,FAE wp?Q\һ8k8)*IorʾfL *ETƊTnHR D*6~3+^ўmO{r+\6wd ^:ka+915q4]"dXPv%޹矦s\vѾI!$"7E2t\m8<\+sKZ6i;xn0ӌW,~)}e,DvoB'eE3nC֮9S #t+4IgVb_OQ};כZ9[Kєqm7G {{z_#u՛fT,C *Xr5*׷Cof;Ldi 9VHg,$c4pOWA$ `Ldƚ] aZJM|dp*rO85yv^k7d^dLYʮ}ֵƴ&GdiӜ5mTwU1I>a*Wэ.oȵEp,ymfx⳶c"(hUS鍹A{d4KCb}w1G-!n#*|vҪw_#Jp|6KX--F'5ܥ&-mkou%ff˴c<BxRMЇ?eQ9=4vd[jÕ)'N ԃߣsR!ݻc4,}'6Hdmj5X(( qfuygRt';o2D3*B.(=叩46YW*m̎z،F{ԞL 1N*jK*Tg+w=ȹY +Z56'<F3QMq9͖_4!|(?7:-dZɹ2i"+6_TMskpZ0'v;X9*Wɡ&mH_zɴ{iU)QϠSFr乩 ^^ a?\,`EWVu<ݫHO5Sq}KNU!rrSjwkM<,jR_@3 m?ɁޮH˻rW4+0e߻DNUaO]BK$QQ䓎*b!Fܩ)mV|՚9LHCg9ѴiƔT篢7QHҍXK*O:S`kFP>Je(o]LDYewc]ܳG-:gH[X1h W+$sPN*OxOI#cVWRsH^_gZ ֫U%CgU{†6)fUaToSև{t #]'bX#:>wK%'s1RNz?(T5[#b9 rr?xkKN[uw4ԧO\=z6u̲Hnx׏cZRKtc*RyhW"Y< Ymc*^{Z5sFyuLltss$ildr{oyzFWG.n+8Z% J2qdX2m/=YԕON s$1O_zq.qӊosib#~!,9% }d6AS)K9Z-gOBԖ(fɶ1_Su)(Tt,Wy8dc#M4ޗ1+&I~wʃ>ݫHHƝYs3ilI$C0ʨ_zZKܓrٗ*u!>hEoik/#< ֑]2S-Gnfv21l0??´Wkcqs}CXDɶ4P) ]x+WWv.ThSi8{:+hLQn2:T3k 8XIS'$+UA2}R*-Risڍ 3q?ºCiVj/c Y,w jy+7T冩hбk}qim kjTم9JIV"5[bf`ACsYNSn|Lk[yfi3VJ*qݫtu-Ox+eemP01G5>fԪبEhfFm|FO'zj:N£⹜cnڲ4-e|6Cr}ztysGV85qKj.& G:\<'͘grϲRilc$z*F4߾SGliu26c9޸f/S<*VԷѻM3mͷx){=Yʋn+>_]nkhPss>uѩUTiӺot͍|N0kͬEZ<5iiؘUodVX q=+jѧyxוGU߱=5ػ(>H>^ȔE*ӶOB쭍{=[Zhj~%U[7ߊΟ5N*rz-Թo$hp^2e5*>FvЭBHi/FP9=zʥ:1{"m)tt1寙aW1jqNm qO[bc{86VR)\8=h5tp%Y-巊bl7<}'5rZ3У |%ՑI*\K!#v?#NP"rN'W.^زٸ)]CGqo}E*vEoqՋ u}n#z%}S&u9-yTYmXޑS=:i ]Ƞ1c0F9?j%ӥ;iGf۵M}dfܭ`eO˞N@&8pꛚz_@i|1R2FGQF{GOO$J4)Rnw li @~c7evVNE):|4ı&z.Pzdq\,]wׂUw#|JN#r}Nk7F&WEޜ}k,[x$,`*Kn9NtJ1]ҜHI'-l|yVHUdPɜnn6^KNS~j<{E9J޻#*:Ӷ}٦i~λ5n>?N}HԫO35%m 7w۴l1ycR۽ (;IZH-OoOjAm3"mʩfG$h I!#rGi@@8{V5)oԚY9s'{onܳ >grCgqWKn%WffafRT<ZQ4:zo q+eʞq@$s>Is ƫX{*cN{C{A2j60ԊکxYSrI22@!~lvS%镈g2/+VHiY8$彆8 ZsKs7tu%Inc^:ѡfH¯_NwGI=Z3onc3ovc8XʤnLU_n6ա!ɚcs{ёQ~tܺ2im}[19b#w*&#$Rp߲Oy#U@GZ{:6QI>Ν9sZ6Sj\do;Oq[J3%Wey,QE:\y5̋2E>a?c9acS*$N4쭱hR9سnbĬyu2y"NQt`r2+yz3Uj)E莚b-mr/chOKٟN #|#d~fr{i9mLتtڽ?kQTGE-+ux>`3Xq}qڻ9߉Ɵ3jQ VxE͆f_ֻz4c;rHūI MpnN}+ܣ'NVў*2;EhXFܪЏ޻#Nq~fZ;nXK;涖62]bf ʮϿLd>կR/i]էRc8Kmq`u<;zqQ_aK *nZuvw|8ώvu#?倗ZmyxqnjgR鮶 [ԏMӮӓMHV7b^7}: cTeQ.u9s;h.$[YpJVO9¶y$\rs+r]O6TunI&{r֓B۸ 8kTa$l*{}+h.~wz緞!U1\eCײZIg=\S:Vy\`ii6n:*SNQԎW*nﺼN19oumPYv2\M*>XrKx+R|WT~b[ͶQ{=x5y=٥lIf*Χ֕5)%)[B妡2@ ؕoC^HOUOkn5^ȹKp+zfQNTޏ[[sNijۿ̹idp']S"c:2[uMKknUlfk⍌KVF1tNTe^~Fk(XrJ*zP1]__tF2z.+MlGv06TNzd`p N7w 4.W-5"!$v0G c>Y'.y^pW2N[eWX5=ۿwNM[g{Nw!t{&?m¶Po H sJ"Ro/?xc4g{ZY&][Va`Gqֵ܊7u=ħt}5 xkuy^[ȸU|HŒH3ĘyƜZzv>'0֋“{m:eԗSJ{V'#s>WJJQgN+?W.Xj#e [i'60qsSէ1K~ǭzUJ޻#X=[_OC>8xRt:0u #9;go&iQ&O/3>hr5o;]_~Q4$SrnDJs̨][b}F{hyvIqY-8pHW*OqMl-lEH-c\jaqa+9-u_,K˸x#m+ 20x0{tc>YnhfW#g/ GG͉$^]Ğu2<1ŒִKSN׻ٿ3,UM]w=՛ƺU3[^Jȹ =m2:^~?u(*,aH1'޼匜Uh^;h3y&-xVszW2wy5J7H<-ma2ͶIBsZNr^)TIk y|:z7^hi2gϮkukc4]9N;a6yBr:O|c=ngJgڕĚ, d`c]$4~٫9W7Hcc(t8=8)*w^v Fr=cckvfViU-H8Ff}NrfjYךy>ｑ+ϔCTjK5x̱dm'4ڌHp?SWTn5Q4[SQ%ܶ/,Hîp+B+0\9kӓ^s}oܲ-7)p3 XO׿_vs[(mV?ȸ,b|}1a<ʭMi}B2|M_OtmGTk:ѧc[F{$k[ 9*yOCq$ά\hʪ}nm쥄k#o`ׯ津֩5.~*Tk&qY3eWlK" ocmG7{3 DYXE+{rEyq#!a__Y<ۮǣJRj⧇/brV_]NRZKԍFM7o;˜LB/㩯IpEzB\nvKqnk [+TVLsSQwm7g啇^*eN4b"ߩ^Zؼ[#zjM2[xTe$

    2+ɟk>˷Ycp-,fZ}-umB[HXþϥpapM[#өJrߡ?.ot7?UZF?vԣN5tQ*xM~=%P]{5vӢ >ǻ\Te%Z܌4h)izG4HcRY7!\ Qz~k-GL%>[yɿ{?JesuiJܯSw-㱿~Qp&0[q)֖#=:8zWh<;ov-0Nּi^2$Of{hcχkFx 2c{ J&u SQ]Ns=SњMܥ \l{}l;Ϸ yr)IYZ6/~NWjZ8-g҆_<SzI_Wwάj1@>8sGUtӖMhgݟgÝ#eV tf_Xh;^zj<̣VR]{?=kxe)Na*ݣ ]c0HHt{E 5˹8JStSv[_9͋yPك^~cqvyY2e3˥cYٛc8OX\~̅ZS$seHa`r0q{XiZoӡe@7A͞jaN60ӎhhCno:6Bd^*efJ2_;Z"-w1 WE<+o}~^FtmLy~']2}F 2}=>زr?7kJ/<-ľTSIX{OTyKoS0y|rz+ow љ-DH=y: _МV"}?RyYQ'-O9f^hV&A4NO>TΥ؊u(FݽHLq(L>`s׭ngBq>EdR)$)̛d}j!ShS$ԟ̭-dTbk&:qZ_iG^vZ0d뽼wr,U}YSYGm3ܼwg ?@G==k4 뱎gum͜pDyy\#'Q*S1;V&Jzvʷvca[qV=cɤ s?.'PvR6cp+uBDcIR׹mkXTjF_o:枦5h¼ԞmJ79٣lf!GsМc:>%xԍ51݅zZ3W̗Y6#` =Eta.VGT]ȡ%೶8e(I_rF(~ފܹSi"< ,yf sʣ˖5ثgn#RGȦ(kw B>Ueœ4lW2":FjfnO^+ЗwOxzXEgijUgcנ5b0J.Y߱eׂY͇cr dqqھ'0RrW>_ӕkt_?}5ӬCq v:|~+..Un]k{:= 6UI#l~Cۿj*` ?2ku#*ѣF5|'u\nnVފF24F[ڙ*en>ҝG ri_յͶS*ɕ|r0<X\F,YrSi>MҦV

    c>3?Vv:)RV{u[дG"Y7mmSK励 P^`YvR.WVS{4RM ~yw3卞%C;#ٜF~<}3]]+G[)6߼>i{CSem?csvV`@[TnOuXu3rrq^rJQK[ԎPүGaiǕu\t& thi2w1<ưR2jFnnbT\*Ͽԅx>Y[SI4gHŖʞA^5e1<Œi<ݘٛ #%{4*qJS峚mttr$plYwwjƴu+;.LQ:cUVR]wukRVZnBWt T 7u? ԸYfB;By+gi'jg:mO~1+AqEŏ }q QomI8H襶yDsԶQ\u(:#S.UwԤMnl/9't?T*6flWiy[k khx[ }; 7N4nLXۀdbU6mV7N=I=Ly>Y=p;4!g=1?L(QW΄X܏|H>b.@ `:{@b2GֵycEӺ:Ṗ%W |ӏQԅ Swޅ.U% 59I׏Zҧ'5-܀F囩zTzѕhzC!O=tƚgE)T &_qoS[RͲMKb)nbʼqF)nݬD#ѦNzg)|˩Hio܂4XouU{A{sF\$_2\*!;Wsg/t2_s4LmI gv3OPzb]{:jmX4*A;YxUOq5^^ƒjnJВP[+O{evc߽mj9?(t2;*_q랕;_2iQ%[ vǮx+>JeN<ܖ(Xdu,Uu\ GRZ眥ŮiNWm,8 q(vHj*U]!JLQ eGn{yoSQƍ,4۶ۛ I?tDԵJ:zuIpQC? ,V2叺{JmI7ۡN'$2iǓ}81z:7ٗ}f^3q%Œ$&GFrxI5))N.[[-G}r_BO9JN<괱YFrDe,7 NjʤMkh9^W onWoκ(NVΨƛQnƸbdkH֣Z[^TeZQ05tk4N- 'vjфz(5"7 jePB_a[y2J]\,HvJk:3NU+9K(YʶG'#t=}hٴ[U=/îm| r5*~K莪pNV-ZY{ƒhrC0kIS9۱kyECZMڭwY#e*J r1J"*5v,ug+#+rrFI#Rq::5Ho.A9_D/"4\|RJ*'\.-U^H:PN?W:746,x[sr ۑYJhLNZK4"$ CI=kͯOI)]۵ȭlm^+%V;s投&cO܄A*IWӜ}khnW[Tlkuۏ5cc1=+N^F%>cU<׎O+ITN*Ӈ7![kU5xb ag8 J|}ƃKGtZM#$HTV6rO>LyWQRI m;hFù^Aڽ;0'*14eS.W-3>cM*ra{ol[5\KnsC(տjX].Kni4֩yKr<Tsϟ/d\O93@xXc9k*qL!kޞ} B GxW,mymw#ӑ-1 2a"Sgm)kTeRF5+tSg}9?;0ec99=Nxȵ)VTriKuune]N `dbwǮxN 5Vdy--wqTȻ?/'\rqcjyֈ˺BZeiKy}ϯ>QMǞa&g[lDqg ʼ`tԗ/<mRu ,3,Kdu:cxOR?*}%_~X%K-[R3ܙ66zfrZ+6ߢԩqb炙mn'}Vk]Iyv|.c@pFkSB[kfއv keU'x;4wϦe;c7;m46W^U+$aB?0{Nc*xDЃpyifU7w߯O=Rqa]68ViT0p0H;8ظkEZ#͗ԧR)MKmKoG/ů Dxn>Ư,S;hI mTN YƬ=tNWGv.rקW>N|g/nZNo%9)6p!HE0+8l7έd'+8tݽo{*\>Tܟ*,ldotk?k~?_go[AmH9}b zgoʰ!φ|Rw,oWcl5HL}导D"hD~"Ӵ!vw3Dx-zKHxu)N^{#QEc{n5#PiC0ݎA 3kSPR6ZwNvz}ԫiOgc#|F3|?O_{kS툭(Ԓ:nyoS5 5ĺ=ΖV9n~tܧTggܳRG% =Sği%,?moC/ݓ;]pzu9UlwJcֆgπ?f?0onQ/&Wg'px:r9~}"Jv7[v__UIȷ>y XQʁ8ռ;?%v|.iO/jUo>\xOWwghYrU c[Z#7}o^ >*RKVw© ڭjǑ=Rqq2mS{m[8Z>o5b Q+yc5e,jr\ 1iӻdeJ3[sX5]\I*ס^A>㑚Ҥ}5ΓLϟT+2]㎘55o.M4KVL\.^ e(֤JnTU)wn+SRQiu~nF-X<zg}ksKD9cS[W:YKZEo2e7ݏn*Wb- R45_qiA"-sەƼrݷ͝T\]uKAOd}3qbBRm5{>՘i #$; q\*fgYFQKjGk?g݇&_SS܎]-jy5)woWk:"8oVlT̟^9N,(.֗^Gus|wXb#]kХbԓ-cpYBw'X)GC^# r[qrioxmv͕s,a=QϷ^Gzv2~"[Qv^8?~K/͡gͶKm #+H9NhSNmR}&;䗵M4[]r|D[/0۲+-NoLq[e'E|%LTGih~ Я5bH8;yQъj;^`F\!py<~Qec:~Lmog]b`T$ʍﴅ2G;Wln亾ƽԴXݶepܞ?Ҝyvc:өxܐe$mWnrq]~~{-$w0i&ljǜ?3[Fĵ-wʿ*7z1RZ{>XtUx u:qeJ*K_$IateQ3N1:{]*ڳϩ.mJg/\Ō$+y`s׊qrZ2ZMj XF˕N(5 vpR|]Ҵ;FǍRW=1k0YMlD4ny-jU.>17$kC6:+A~Q\UvRfyXk(x/@toG<n۴{SVƟZCiu֏ G$k\ gz?N2dy1@ [EgPKػPYx$qf-UWzt/0u*^oof%>_|NmGs[qtJ*_y A88kz9lvs0ǕKE^]x[ ݮIc}83־ZKmM}iK-R^+w&_fK-}L$W9ڊdr3#1}5{^Jikk6okjv ÐGgsco6٢0"UϲQ_fYmI>tgb3VFzNk5il6rPCe ;Wkv۞q֍sGXhC%kӷnwv>JQ.ӧ[w0q&daylßƱ}ۣ{g&XIX{s;BШ(pg-R9GVķ՞IbFvXr9J\rƅH~),}\ؓ:qw9/6:D!|`>R\ΤTiF-w*MCwڱ̬?gS)e*hսG$\AJ2|HƶGqۡp93aԶ3j>$h|;H^dhhp֥))?OB%ekp˖VtGWj|?<$u1 [kQ5^rN{j"@ԯ\nN}y;Y-w+Xz/^u*\䁲o), Ӟz.XٮsͭZU[ D@U9{zW[ݳU_yV5ugrdHh_CךW88UzV{:t]=c"hXd`r 9==7WV49Qڧ^R[SC Xf眀(Z΍yR]-mX|hb2eXf\wϮkS{Fo:i&7]/b:yi%fS8^h:I?p#<> uylsjS>H^'cUhXSvt0#wy+/"#wį5hYR|j-bfYHcqxrOWdpul/g)AвyeUI <kӍ(i.Z)?Cj$U?xzנnRgZ~Fysle\ ]K5Ncʗ m)۲UH 3#(u.X[,vL.w~JG~55ӔYzOϘΤ}:Z)[i$p Pv"sSb"2c铧hgsu/ͩ*ۏ, 6Ѹl59sjlUX%. R$ne$7՚NT9Q\TIwmLnOs)ŭVSOՈe\S3S#ݕZvCߙ ;'N7}WY9Ю`A7TiQ=HӾՐݳԎzZ0ӹ2[I<|{۵a(Mˬ]wtTJ*yϥcggN[n&*UU;m`9-z~UT_S 7fl>RRHG*6>٭q^w$vw,"gd$wd*F^˼K2.UG^z*:BӷL:ڲ*I`Ny=}q]qom3T7HA`1kx3yQ{X$q]Tx;tֺ:0>Žv fYJXNs+ 1gF1O>FF48F+HsNW]uC_5VV]ێЬF3cHjv.E־ 򅬍mF0è'c?tQ)>kFF* Ol~~} %NUgnk07;:{ǚC C F6_ ~^^F=y ;|ǯ|Ioi'Qir k(]$Kc#A󞆺hӕj7wN*79ZEfE !ノ?`qQ)_E*g9ژbIJ#y3Qqadw6uRN;y5ȇ/ám?:Yu_YUxYFޟZ~ǞQ9b7,1aҔ_GGMhP:e*`GV5ԭ97U{e.w]M"]4q]8&TTUTc%~tXcn;b=Fz7[yygxsIx-E ǿ?/GO*ܚ1*HIrlwGXi'G2HQ{馿Ɉ}6lzG4dzU!eݠ '{Zz,VT˙PFIs\\[IF;+4v,p)nؤFH2瞜 uNismc,:u sێ՜o98x4c1*3̅x3G%$s{,O"=x(f[j=c9AG{_T%M bF;wHF9' T+#jqp'DxUv0l)9ퟯTn%)EY0bY!^R6RܹrƟdYɷ6>\:qc)˛BF2V>l X4)K#uN4=Nv[ k,k,K\u砧]Jv飈exF7ڠ8kjUV2S+%k9ٶ˓yB~_zߚKMR)(5X딏*ݓGOZ֖Knf]-\0Yʂö8q\U!'jTܒs2ƨvM{$ XvR\Ѽ Vx#$c2r㯽?S3|^+}mp')ᛝO($߀HK7$ "U(tS/˹B_~OZEG#E)VcG[xfbR7NUT鹸Elt w2_>%t8긹롵bK"ݳ'LחcY[_ѶgiPg85MsϬZK6?&aN3 0>֗[vsTV14mdh}*+7wg +ʍ5*rq.u21ϙ3ҼB(u6.**Az_¼+;FjҩSVr;U9'ןT\^cdlkF!j0R!]^&jNqmt+^bHIovo'8+˩N..֧SV5=Oe/4MIpΧGe$]m~֧N nb;UI@]7?1=+X)N(юeU]~c)K*PTa&k4OHGXanq,kթ%hQtҥw=Ҿ뽇Y[GەmdvjkT`SDKgAr4i^ڶxm%+be)I8̋BJ[7*Z8Zp2Nz'?Dfr6p>^``*u%V>m.6eR$c&i6#$zE(sXT+Zk%xծ"EfWa'W?ciITm[4gyňWn o]:F1vlYT}#n-ղfO#Ns^E(qﯖxӒC`$RO͈GګӲ6B-JVoTlm_Bʭh'fZT$2{ fh 쑎Tk3J5%(d2T\NinĻG/ސny\E?d㧐S^O*(wnj*z2#*Pbxl  ,=xͨ>C##*['wNNؒ9xUxԗ%ߙTEZ- <.q559HjFXVf!XF2O%}>VaI뎼`J1qJ;o4QN̚&G{Hw\Ҍ#}#9LC6/88Rz 0y F1kOԣ]1䒿w'>*#ÚkF/$#w${9ϩ9(wV4׿MLۻKO;!!T,cg<I9`{7%:J7&Jӛki2e67λr͹2GL)8zV9}8k.42)gd#29R3+9T9{FwkT%*daq{='ddgEq/oG#,9d=+kTaNKI+O/ڡss}:W:qi."*Z,M5مS{W :¬qZ?_F =nڮp7q߭(IIٞu:ؚu9*kwJmE7V78%r5qRnV;*!xw9b2M9Z˫㭄7o^DQ2e LCTT)wFdžuXi6mVs׼pe(i}s5,N:}q\ʭE.{^tj b)7+=3z)E4tgZomw҈cۀہl?ϽpS/QG iCE<)Зhԏ1T2=Gz{J> kdha`~e9hNJ'FQn0HEYcG+էrتFTߙ==ۘ7yy\XzVQ2ĭaZm]I&[mF:@+ڦR-W==jM0'# O?½~]}yJZ4ۻg{vdc*?13^xjFMu+W&Gtᶠe?8NQ\V:øSK\E#)T[p'h59e%ի*R1q_3;P[M"$mW=="cKZ)iX:5vucUi7E,:9>`pEghӃI~gӎ ih b6P,Ʉc|dI Ȭ%N[Y"[n;:cݷkI\U0nZ5O;Bݒ3 0fG+Q'nO<]hdY'I ;sUyX4!N5~O xXW̚Tf\d2v#ӭy#*SefJ Թ "*UVmsrI ʩջ¸kY;jZ3y|\gq-ӱ4cZZeadPzW$TYjLu,4wN nmǮs沜ER5*S{Twi6P9ޤ_,n%o:9fjU.GnUիL׏tiV]MtI+B`UtS;t99FSt@Vt]5MEntJk|/6}F(Wf;~uƌQ\<ԉfuW[NX`rpyƥnUf{SB_njbKHlU8᫆2Iz%/Z,Qżܟw8uDJZݵ<BgVQ}$l,ןkMlHo6 O*8HR4B$ڻx?:omysTz&,8X݂)TP (6ekJdqeAۀ1ӦԜ#:{L>0]t2[x[7]ǞN1o=Κx_rZ.u%VYIUE$`qWy(3X{j^arQK5Rߟ+zq]*ޟڵ/䝦ImV6U6Ǔ(Cݼާ}:TQJr]<[ȕR y.ggnWzjcGشF],5j*3-]O)A K0 8АyurݧkmV:4ڷǰ~)|Ww^Oq-լXU1{O-МzKߧnN*Bke۷ҵ2yR4Pڅ,  An@ GOjh治=CRDA9RyQ1,1 >e>%+_ΨF~zv3yY+by.)Lۧ[ m+/#vG-"]K)DQ F첮p*~ϚǹNJwo}ս=^>-In.Ie`IϿZMJRѯZpx?RWQ7,&K-q9:VE_:*Z_~&d̟ ,ldtԵe_^*Okio⿌֍3l|f|q>⼺c_)&ׯμ<+TӾtwz7{]Af"؋0N\3ۜG/ԗ*KV=j-ҦҖ;YtM OM=m6P@VI-y]ck99kU)t{z~','QKJַOS~.D͆AcO LTU#I*F-G]~Eiek7_C^iԗo+].wVj']!H\Ν 寖reJm;]jXO 4k%k$_ zg8q5T%*rJ;~+b#O^U_2"voMy7N7p=ȪZ `yimt@\547EpcԲG`r5Ti)+nks .;K^}gm?q@|3l<xHIOkr hehZG ;D*ө 8溻Hms'}:Wl9%zt= V˩yG4GpqwxNwv.yN-9%~KVѣfxr7om<ßC5-&.j=&j$mFO&Ud%x7n^Gq*ֱ_%Z>Kz-Ӕ\H#X2u8$|ճg?`ZÞO-<^~s 㜏ƹcjN,|iܳP=8M:nkFNtwm'9>yԌ^ngԂ^^N8گ*"Qzu;#N*hCD`3/Tc+7=U/4]2g'R2jKo#^^)^)6#O(a?yJ[⌣])xEq ڒYd d@>ahӕ61+Oܜ}:6p8cZB[!dESUڸO\j1;B>KTy!]YDU^3Do.L9lcp-A^<4q7mk]> F)Nڞqhov9~SKR6]_ѯ.JkedJ&Ir=+M&:cŽ:kHѳV\zrּRJNh^kWU^vzJSOSjӕI㡃[D|pvOһ'%tFkF|h:y20ڼ_4kEt}MN76$;EYU!^n"owCH<,aYOJ)V{*+[EjttY>xo|u<5*u}MVKEf5tJ|a4+/QNxߩӇ+N8i>Eҟ+nǠN7ht>hl~-dN|{Ҧ/z{Tqr%m.&jq5)Өvb)bK=:K-%z[}j*UZiBF%4u{>IcP]3W `R@q#Ӷ<бh%mg%yG(`mc2#~L-T{XSGF>sZMYjc|5Ġɉ pz``{׿K/f=62M/fhYc]k+_XEy+SiwoTd}Nfsohn٘B~:r"tOQROGץ^#ѡxUd](\FAGSW_2t߳JwP=3C߈L tb?OTPS_;3_V`%@&kzrŶEޫ&#$קc{Ӕ`;[Zn#77*RWNєjGӣBSVQG.YWk6G篿^=)Ku3,CI[}NoN6LrxJjԛcާR?ezic.w|d2]|E9Sq #<=E(ϩZ]UH̻2qLjTQcM%ṱu.#m2s22zv>28{zV^{v5Gso6M!o.% }H-#s59Dcʶ!TדF 1c$93;үJC5?Qձ$jvG=?J0ƍ&zp8wIoXwҀ|>dqֽ 4hGt=*8ztq G..&LI9F2mSG<){['/q3^hǕm=5'5z=_^[624|nA sub3L=())+>[/<0(.W}+_ xcG0!E#WքcEv} *j2M.ͯ|_흕ǂg3@mufVPFC;[^GPx5ӧ,DUtnz^hJomuWZ['x}Y|_\K n*I1GPqH8[FJ/n{p_Z+AR_}Z#Uaya1B/cr8u**]{xe'v趚fא,1H N\c;d_/+*~V|GŞ.I᷵E9&Mx  cOt>t?㊣NJmn&cx]yj0o_czpsSӫ-%]AFDv}{;Y?p{zHK$cN6o̯uM?ÞY7MKo%NH>QjɽƓY'uݡS\Iksb7s^G+ף(T®Jn=zt:_[k4)~)V+z;zכ+#LV!ԣXulp:Υj܉ ł{WM9f7e릡Hb<͠GOtԧ*64p^1ζ:/^ 1q"zڽ*uJv*x:NWI鮽ϴ>v_ 5,${y1wdd.gԩm-V޿1j3cE~'u5y ,L@դF:'I'@QΣJ6n}QF+_eyd|8.ȼ ?J.9WQ6Z]@ܯ /ގ RTSֲۡvyvۙ`t>vB\qC?^=F 7$#q~oZF;w tяKE۹$uڣfco8''gJ1qIF2|AEl$=H犏gNQҝJ1g_3m#Ǩj}k#e:>B PsPePg:h4g̛RO3M4S( ۾e?!+93֫NØԧ嘼OŘ#IYcȒhNJXƕެӖ:S3+,2.n7cG L*ABZ<ʤʎ}Mۓ&T= "HKb:c~Ku3~ǖC"[gr#Ez0q}4`g1_3ޠShԖy´N릆-2 UWz劉v0X[K'حϚ ,s-唭M?3z,Q[b˕  _J{]~Yԋpt )!wXdprzxx8*^Տ>xB%K !VO{s^5LN[(,նK,+`^N1U%z^$ifKHzz5FNGn?¶Q62~235|fE#ilsrEFϡ7<W/ ݜ1=ٷh4w'd2v/s~?u7NIhžȭ+~(9vKN5VesTΪ~Z5Y%fmA`'=x:=uQu-^H&VQV5G8Qsc/i]~Ėv*M#,9ڵ"ccZN$˚&f ,kx@; U7Q3Ue+Zmt VV] aJ\W?-SN}ב^DaI61m=V4ңRc !7ϻ ܑ׌F8FBԚʋm+˻f֎DTaz^4(Y,a 4ryESOCxƭOv}}-q:6|j<zrU:[µzMoE6Ұ#AXӯ*'n2<>&Qr4n"WxT6[e p9=b-?'GUMmk E匨QA~}bU;teK)f{XmFw81qҺ*5),5z1]Zz<6[X $F1 <=FFk~F"mz{ffϗp0N85YعԅGh?$(nPd\M+ 9mi=:4V[Hc1G JoF0;cJeʺZW*8/ᶍ*Cm\LL(.g+jJ:[hgoݪF;s҅)UV4k3<<*U8i#]5#e)T;W*l`aTe+Fi-3f}3JvVU'#4BPrjݎ8ƴC"sSm9}[YK.m# o(h REvF1ةҜge3.Tg͟-w.хoqݻ$puWU=t.hŸ y+yl;].X-:okc"R|'iY>Bᱎ o)FZ$>;JIV[h$ey\rzW)K- h٣CGxt"uަoIpS9db^ E';Zvֿb%uS%}/d=ANuv0;}w=A#hP*gm)t$4 +A3=kS-ΘTd^g]xOAHl|O[K;ro+AcY|C{uW],ú^Rk_-VkMm$cό:~k!Il/J L W<`U\6iGb'**J-55#zx -|sԠ͠ zرdmE1aB0VS08S d^~i,+aJXw߮/xPՠ̑g: [;(#*z3uR2MEfU֖t\I|W]߻oh7[-&{Y#&mB,}ё U}zioK|qEiRKvsZ/cI֚m6 ^Sm*IC׌LW,T:w%}#fX^olx+ ty"8TcaU燿oF,481y4Y[uHL'_ 1ZMx17e=? b1txم]LbÙ%3?bצ+sMcjgG"[Hftq8?NNG5u gEm;3ūZ.iZ=5˟| yoZoRZ=u٢i/3/3CZ:^mْ޾:ie8u̾w6R0|{j/7~x~"FYHm~Ϩm9cJ1jf׭}֜5W?,|[?‹ⷅl<$q2LAJ6 #pVܫsAkO՛"vΒmV#jGSVv&0][JU-]99N\:ީP5()r'=:\Ӽu2༵U]ˆz¤ۡN5+KTW>9$@8ϯ_κ%Jmz\;Y}JxIF;ן9.e/S*c'vii^[0f^<eNƖ謡ee.v,7Y O|<3i40Vxx<yxʑt-rz#+ aEb? l6v: ({j^ 8ּ{H9zHӮW}.d|{I#ʝHnJNju^Я5˻{ \nu AEʥGve4ԧxRMjc8LƹG})rSuq'EĘOLUz&U|KYiUy_-@^f"-zxI+Z-ℊd&9UXu?μ\W%OzާN<׋gxᵤO6׏kITy{UbjhQovM_q4uvLpB zJs;yki8uVGQ{xWNfׁ< {b^4?RWwMCմwyap됼ʽhW]O:U*S\?0Sʶ 7^F2RLө+*xwZݝH;F2ti ]x+޾,Z/-3!^Qx,%>"n 9OS*ZsG Zr?Ϟ7k:ƶnt`\34# k9g,G;1wڍJ[[Fyv ltmC11Fּ^4yo9kbYBjw<nѕI$I8Q6ɯ3[MH.8өwNSs-\·i3̈B3}MzTiTG5W]6E) |˷\Q5ѣN1ia(ѣMF:ioqq$0foǩ9B*R{lMLMKEMVHsB1Sh˞ks4t].I+{$TdX{x积EYJ^gNܼ]_OC-RCi D83IԁN?JNJ:N^=) I¶$cb;>H'9pyCfզlP%\pBy9c~}O.R!6r̸4,s)sȮyB3:y/N"y#ʷxvx82hеV1ȫ'`y sJ:cj2K#( H?ڒ?}׌(w"%^gQZ-Fm3'}^qζ9JI(uug\q`FsѧV9I&e! 'UHs(غnujoYnV̌wIGX^RW],2w ܠYw cziU0__RVG1,_9u kFtF{դ걋FI?2s{=ylorlhee B+jo6TƆ6 dn, 9+3惖Q里, A|#66JVbNR[}έSWcn8?ɭT|$2̋+1צ \%yz' qs{&hc_G \x$yOYU)[2j+ L-kkp1_ 8"jE~huim8z>{ :^L̪e \~5FySOWEᓲ|8ӣo5{{M0c0Sxk>/R6{w9^AhfB7mpѐ0מpTfM5 BN:#"ᰪRw'cuH)uJ]#}ELybӫ<^3,Ж<2NOB3m<=jgtiשN^?;1+ʨ؎hq6#Q_+kFNR޶}]zQ-7.2 ;#2NRi)F\ xGI.c_:&fpSp# 8Zg-xʔb?uw_368iEu߲Z_3lE5ķEgp[fl=F21Q)&dMRi4-㭴kc3//[kW} 7W'x0<k:/U=H^™ɦp^FH?jq}{M戮|"".=}kҝIJQ~" Xa19םS =Shr\i.[dleO=+Ʃz^YX%?ͽm+m^[m|k8=ҸU*u46eXRجVW/j)9TQkH#"LbErrc 9n2F]3̫L 2q5IE>gy|E^i*o&d.I&ߔ'9A\[ʬs9æ~"F+1N-4y}lN=: ƣEZPZֶMkc{- K]-H断y-XfMRTF1tWo֞*.tu/[Y#w$۴pH4ESR~w2SEݾR?1g ^%'e'koucAFfc?aEvQjSPIZOM>4hEQ]O?k2c]=F}޹w(QԩEs}uE۸LXͬ2IDBOc]1'F}2FݷZ]*Q˗^V zP?<ֱ78#4O6=y_sRm2Omy<Ɲ*׆Cw4EwdzV7sR~kxf̐19kVHڝѓm1c#j\I .OĄv{@+9G.2qIYsϧ%YFoca*͌ӟ\u˥*-$Lq\&n=f¤iwN%TE}Ӥ<3\M͕,Wb2OJZ+SzΡ7V3r1-s:F<)j`]ݵEb6T0{>n*]VM~Mf1G+,IWo+O<}BSۙQQ+_jWQʡ>&ӖQF=]8ݥ S +Yv25 ~P2k6mj֥žSP<>\L3xq;iԄֈ R#.~_UW),dR{{Wug)^Ko鞆= Y-n&FEV1+TӪwx2R]cv\sD*NU2K3ʵ#VӐ>`q:דqшw u(@.fBȹ*d$1@篦Eii҂O[05=r!X㷍$Yr \tc)I6˯H^ >Y{U#N'ܯbżvǖr9zW,*ҿM\Ujޚ攖HcI k ц9k75aicSG 2UQ9'y%gmz"͕t2#o=sn2K,E*Ih'gU1?D꼙FRmml2#{+rX⃌oW浊D d5ьeQ1d)1~Z%ZzƤl훆?te'Ȟi{5U#ձZQ1(g$d*iG;:ZSt'.Ɏ˹HڧIIaO/i}YfX@[xVoݎpsҦNif֚Ж8-`[deZN[jTJ M\Nʹ=F9mjSjļDԖS18Wi֤Mpz>bhfT]^vwNZMEFQ}I;gyrnUϥ?cRe` n)-HǷ9<՛m%ڻ;/OƹʥhZnU*h{rT?R($o'r8SZ(/84_Qen~dSJ5o_#HJbܓˡ"*c'b A皚Xzt&ΊսTa M| ^d\j$3oǚ쌣Y4p]IZo>&xdH<[<*8Ttޟ3*[5#̍)H=ֺ٫t'Z5pʊVٮF.%./ymZ`RH4՜o+w9XeeY`91N&U*E:im9yoz-,O}H8IԼliA%ʪ+s+U۱ror9'9:w抷FT'{_S줺R#oauN.R'BqxOawC3nvXө*wcsͧX5ZyzV~!J)T+d]Q%}M#:r_Du>$q&wޢR.cN6炜LX,qt}ׯ=[֧SkSjS-[E6I5ƨrno#rV)ZL_/vO&eq8G9YCNgލqW_/j'01<+ ^1JQQ߹iZ0@wHps{˙aN\ۻK:-ojG17̓hQՕG#U-uG9i6R{usGy^0E Y#Cj[;^TT)9FTw)ۈ}M+I72tCT,- G o_C֫Wu%wԫzG9nYn'pJu4Ԛ3JM!FkX`6(؟lIy3jbS"Eef$aO<=qX*H9)koUwI  9Vѧ+s\~WfG Dc(> vix+=3fKMM]HUCŜI㧯4TZy?Mu֖s9X2Wi۸$c?J8(CO=[u3FPH" 3 y'xYEƍ;^:orkH.7~)lvө trͱ. +YJ~53E- 2#uUMTMm)b}N~})7͐ x8VngL"J鿻^i'՚HQ~n9OcܭZбd{}GqZTI$iMԩ' KZF7 jEJ%{ڔʛJqth)[VBE0:>ݫ;rMJ׍/6N[y%/뱡c5V }I7w'jbI'xio3ZS[iom\^qI*nL5]n]Kb0f3'TѨ%dFqiEݵT7TQϿ̆%dwuQԷ=z*:J}ѯ')-Qs}(~zA}U?59J1p}I;>Ņ ct{I]pGCkJSs̭ :~}$1jf2m *Lq?fˎ"[OY#fݸ)XSJrT9mӪd ")'ǾkNxnu=)>. _&CRG>JgVV\9tOkݽ][rz<|c)k]Ⱥoao1_^zb2eڥ*lF{E̒*vO[J:^{Hv`m>dؙ#Lt*sI1 r5܄jI!1CqbevBUQidP*Uk~I7\zc(GGmNp<皪 c*v q3wo>S=:uWCޅ5*-{)U~mCc>>ҟ[Q化UmD!+2'8JjfHVsq[F1mq.W_;U|޽ 2N5;tySO'gi-^0_$#ֶttJ1ZЭ\".89?UsjQ-bk;}I@pn {s9T1F55.MͳG-͝wL9$+gq+gTR!ΔiM%je;ګO\]9ef4߯bVZ_@}1U4֔y&s^n+hiEGNOdYmm,s# %YͶwUNW99nKeQWˑ&#ls\;2Ee]2R[cNHJU26y#|RshWpN2̶4C $뒥iTo{ǛVVO%fە"-kUZ2>Dם\\: 9o^^"aRRQu6~fdz9i/FC1yJ&*I~_s3דSNQwBTE4j9uPnu\Fөh- wڼ3\Č5|K秇FC7VP9gZ/I{5ĦIa]9⳩EA2hSrV+ẍ(RiF9I:8~[ramn1gW/ IMjDw_FڲkV\aZQm;2gU_+ ֹs*7jN*MKTo<)ש?zWԔltԮӖf9ԪU斪șc)EY6qڣ{;#BR̝hO 1o6 O_O+ NXZ+vfv%I-fNHZtﭯoqfCe|T/’1zb4މi=7UFN9KD&o]K:}[^,arg` 8^((q׵?:iIJ J]oEh VkIx2)ܑNN+ʔ.edoi{ۿ|([ ;aY{zu3/')QSTu]nE #[v1$?x#y:iknיZ#Wd鑭*VFr6jQw3xZxJR嶺,JV Y̒H͌drIn+ҧ84BU#Ve14"ȌzGr:lWG;*k[X痵69!IY8󰌍F3z~`W/jFiW~q{u)[eˣG+\|'9=cVs[eJ~re.X(+-)*P[$Xb27w.9WFU=޽,ϸ%[M' ˃x5ʥ7uQ: ?c>gO26`Pw rpkTmvq g+ߘ>զ6Wr:%N>o]KV(U{׌+U%G9-^q>nܟzNnZkv[yLLc'B}kY 3HG,w _^.[%sEE4' E%e[NzUR_qޢ\EqLc+>(ܭCJ7;.%'ʪ͏7}kxGkC؄2tkW6&F֗|Ip=gε4KhpҭxկOR-t'Z(>_Q8:W~\{X:1)\s6/8-϶?,~]qSqvyi=JV}>CG`7eIdV7gw$g8qӿ>#z|+osiUgkk/'x}B%m>~#>Y+ߑ(īs%.e h̛w. Rq_pJ k׭RQObI)L| 8}F[CkQ#miז3Ye:Ƿ\8=s\S>O{<ܱ4ݟ]7\8^J_aQhޯΌU*zY N?mf.Tb@TjKY?ĥiM$ߡmveNhXNvGҜiMW(6bʣs)`#=;qބ=[Ԛ9:|ʶK&cBrTo^ViګI]b#(ڬ-]1kacnJJyUۜz/g)F+tS2Kԧ,LZH^Om ܷQ&gò4Zik舽IM^6_A=FD9 r c ӣN\:I y-7ԌdqmpH8$y{[5];I:N6iW|{6ɷ0 :름b^R_3wבA%{Q#4r1ʻ̫n-m9'ݭWMmgk[K~AVxNWus宴md|L7}~LJ"j2Am=By[;y>|n9?JxX%_Wˋ.Y5oDb5 $su̞Hm1_8VaW+ſ+8<]uTjڮ2dE/ Mk$mn˰BG*G8xǧ`qM֣_OSU^ϱ&;'g2dg rz {u|Ul/=f~mUESM+V/UvkO ל2#*B0d=@ <U]mfo,)Btݿ]{y]~7Vz BB)e7!\8",L-6M[o3Luh4ڌ8oKIƓ4k;1i%e>r=s>G[MSeڎ[sf˹Vi}yzr5y+Lֽ,jJ[=?3b#GRowOAеMROO4paO; @?yE:uRnWoi}9I$jkij.|H,IO}:یݒ:+BmQJ^e*W1kfjƷC!]!^=HxLTSQ2|FW +oT躍ӼakY]\m c"{VppKY1(ו͏^mab.`~Pp\q޺-JO]^oJ*t>_Z~l-"#<s؁58ME1)J襁GtwIԒsnۉa8+ͩRr^$',P@~z繭4SSx+tCZteVUN%OCxV|;rmkX4D2Q̞bIVRXn4*;Zѓ嗽)_nYLDkI<{qFMZg=ZE;^jQCmKf"n8#q6vz*KszJɶE8r~>6'Egú)JϢ3>حtHnuL!u^N"Ntt"5i:JAh|'͕z{Ub1*?[JT쎁t'ϽpμjB99ikvj!L ?:kJݏRK~"l.;,Fs8k1wC73m [FHO6[[,G-=G,4[-sFlX =Z8%­gzT{kq.ܯ=xoF;%OG_]>>x-l[ ӚvI[OJ2j~2xX|hsЏaߚ/R'OX}_E)uhU;9\Eu(ɩ?FrVNt^G##N9~c*>9k j]z;Gһ[u=Յ:?CZǑ/- :Ҏ"0yVQx#HԥH*5=ԫN^T组SzVRko$>^{iuS*J]dXWG cEIG|=.H^@d99qVu/i|~rYWe]çoz#.ebh{T i"z1Բ2:j; ++}ltabXlF1U{Y2jI2˻nS>Gў}zR/osHߋYW\Wʬ{5q+/SӼmp$+ϧG3Z2Ih0¬ݚa;{9-UhWf6QWWº5U[X}ׇl|[帹_峹 !FsH玝S)N]ROO'eIQWi;]=#xYat1``3xч!)KKy|~jSpiK:/;׻GF^Ҫ.9Cv1g=޽<J:pypGNvEY.~Ƥjr˧t)XbCx/+d.&$,͵s޺eZ4pu+Om9|yl ңMrm# nTz-lAs7گdf136I=Peh-]I{YAG4K -F'e8|s8k(M|O'T%ƳXiA=-HLT*s` Z*RZi<\4:-AiY^ ލ:qc_+}mN>Q+^|>Bk V\.8_2S٪vT!| ù.!Čcsciџ,bKJ^uTˇgF> :J̨嵩RD5<92>]*1O4lq,?^ƽ-lDfTŨ;?=L/izs^^DWiy `q{zbITSyEk}Zq$я?9^3IIĽ#%i+'}>ԣF)H&I\gJ~FThYWĦ}Y|U<885V;ƚ;&}u<eŝV5 g Kꬎirr]WfaV0#9޺Ƣe%x3 iAFY2W#ӷ9*-[k;)kUê.[Um{w*~&ZOi",[yݿp%I/L(ѕYkdNZ"dએyaTZKv8r$W l;cl8Ǧs^"*tT?]K%hUsMR7FQӥu0yZ]ߡ+AդKef9XqyȮ)JWwG=jэGem|Am|)?~]om*2i+ ;M4l0zg+,Sъz-7o#_rBq;ȧ)STlN1[/!k/e兑;p M;y>#[/T'QZޖwC4fC_'k؞iK=z-, n5Fm)@N֟4JRWVIiym|Cm@Jp磇ѻmYcsj+vK;dQD$O刭pua* ${'/-hz~-q2G>ᵓ%:(pQv.v8=Aت2A_=ϑ*Z儺z&=ϰ,uK=2٭qpvŷprBYxj:M+Wi@8ˮq>{*tzj*TT[f\ ]ܱ,y=s3Ut6xuV$UfɯIzXf6O\DhJ1NE=GS˵csS^3b{J/\nD4k#'iø.{~KaǙaDyUxzumcR*;]WDL#P6/$FS촱.,-}J_i6' &AhmsD%>^k"Nj ic/8l G@o3 P-?$U1cnA9c畭IZ)ܳ|MQdΨi#t\8'u0n"=HZC$SI |( u}k9~ȩFVu2#ݩHn̏\g?QzۥT)t0_1L=U)5-5MYZS@7<ϼ9{{>Ve^MZ Fmڴ)JJ*y 5 IČ[L28ZTWBHS%G\JuZ_ WtHEcd^0qӞ{ >[c37x'.m cx֥r;7"YR(eE71_º=Go ){;~MȆ>WsYԣZ+P:w՘lecڼN5NUo[ŻUıiiQ(ry]q{K<7iH1hRYЃZڌym׹U#]nmofL# ᜄ FTd=Xӝh>Ue#cks٫Ug:n<Ǎcv tyU8E&xuqգp$.>w,!-W@9CjǣB{m|GDjS(_N+)=\74ZV6<{]}_QfVΓj$+' H5xF1N:[=,Fo7oζ :n_ܩp@GMyU̢E1&p99ZՙԣOK3м.r7HyA#W'h;S9OT,eTW+U,<Κ_,$myka?jmj?05*r*KOɗ/6Qy.P#{־6˙aw 3Xy۽qPv4FS/ ё V_9c2u)bڜyω<ldyrI?^l~G:|TyU驪3sh )qmzWTƌ]ptj75~} '{F3:t?AhaFO\:V3/-E$p1PZ@d=}xں/vGb|^X|:ۗp9[N=Y98j˜Ly=p U9Svܘѩ*NddJUEc2 ~q]a$wSq;o万YQ`j#)j?$ӫM4e93]T73QME*Gl%lp:>}缍'Jj*W,R9cYp<sbIn6Fi v;~m!wFV37_ KʙaEHGUEjNBA+)Vf#6ЧԜUrz4T't'ĴYpc\~u ~H1߳LMvLl0g>oNֶR溶o~۟4&Y;trmzՄp6 ]7\{N<%1EYQ`6{~9FV1!BZb<4ȁ#xQM3jQ>M 6A2R3\dgs?y0ctj5(g $#<6wF~\4 u9YeAэL-Bpۆ>)KXTH|rUQ͏b3*61r=´jr~<{?M#to b5$U^&y9m(gpMk 8]qKtϒ ̲mh's1Oި}nLjFF >sGO%>,!yFisa~l`u53.[- RvW*\F'dg]ֲ3+T{yvg,͒N;q\+oyn H0%#ӮsVNu/{Yg 7J^ױوTW2YSd #]ck-Qjr|=AXf,v{緭uF7&и.UZVe;X/n}:Ν9}M}1D̐E'2.6B1u3g;;biv,r+l[#]Q 셤[4}P4d9[SJ~ΞYe Wim`8>~pe[XZA230P!zgZS DXGރZI7ܒ3npz9U.]RiFyeHǟ#q$xgq~[JWyCI[J}[KV|⻖$*Nc\y7jvo6O Y1c9?z֝8<ބʋ2r#xQ *#9'(r-Hm$[Q.LAS<~8DTdWM(?2neW*$vs}WN15JrQ+JGn~elKV#xFti~ɔ܈337<36S{:B36X9Q^,ӎc.*2ko_3R9<+g82ۨJNlAb-īH\.8eӊiufҥI)TIi6=:·7+tD[ -|#68ҌD̒94)mwdn3*`$(rT.X˯[[9eu1Kp9U^9ya񌁞At[ө&oCP{[OvJ`dWtGn0FGlWMNRsRQ\tM,-w3n#q8py}+*JeTMɦT2FOǍg΢WONV{>+üM#@h\mf!y8kN1N1Y)&ޥ[Ҏ6,]([m~#Z1:2]v6ZhSiwWZ\Gm#F$j؁Yy^=+iN:uκKrU-2ޝMe'c˔sJ4]Bu.-45i*q*jrγpFT}BK]2gh)>wSrz$of_9KGΝmfm)!A;zb=%G6M֧p',yr).sPpG;CVa#CK&||;G㊚2N5 iy/>dsg;>+RazY.^ZMzOij'u'./5dˀ7.d\i%Q:ǗYuk81lFH KR=FAF } #{FGo-I8Uz]ji-m}_9dzrzDΛrO:&XaIYISB#4ҩ^3m/iۧSԭU-:u#?jOx2M{;[XG)Ohcp mƯ)Z*TgVm-gUv]p ImIYYhpH(̯?;[NNd]?xUXI_Z=z>,f\m ϱ㢎+'TyN8ySQ\_}QxZ\ls ?+ъk]HP*քѥwhCz]dNs`87OVhʝKosQ[U[v+n#|_;)ν)K[_ OkmFQZO@FOc5){'Fߩ_Q:Huvd W#nKa9iv7~F?O?doVV^fn O1ݰ. y}X|luUDYӶ{6*smffޮ%1W7,j=v.[kE9ѤW­CyqNU+OnXBTO5s {5͡+[X|fe%##|zo=L(IFǛ-& 'fNN<^dϙbK{y$g nl7'xS{nzQ|*]4fiӗ-exN7T{븀s޶u룊\^LϽkl[i<}+ݣBP81!7ȯZFYC9#ֱaܕ:Br^i1+y09kʝz3ӧU5r{5|S~睊}T;o鋜V= E0]:`biԟNZszjEx3*ƻ`~PHWpn롧j](_A>"]vW$]ΉVZ顸цf{< q^̝F񃍪GO.D{XB>^;C߿ns;\d~[͕U ɨ"1O}S괱iEog:[B4gs|}k9g.h[n86`yp֏<<ӕG=M"xl-P8r߭smkSSV`ڬ[#>LjeN2r[0+w!*cNN~H+^4ۖ{T-ۺNDPm( ,)e<uJ#oRi\G3ZT.ݼ88-*q Y>{->>B,uguJa+@eWJq8CDؘ8dHg9#y6liw3Irdeq'޶qeNMa#K.ra%~`G˜khҕ;*&] ic*5Q|_RTDW+հif*2dsc_L}+JvLRtet~׵K\22`yr2)*.ujJPGo|Lǂ-.5#ekslmz2z׹`֚h^tpڢ獢x>%Wz EY ad$cÏetpҋI^ֿקf[Oʔm_^{_k; 'c-ԍd9㎧p27E.]/xf_|Q]b& kojy(ʍܶ _*zW^8_c))KVգmϧ<{xn OkfЬ&j6Am5a58ih%g&~O?/#eH[ln!4C6$gK lӧ'8XtkY7ϷD}._B&w#OxXG5޳$S(R0LVvs8#85o]ҾkkGCRVoNtzixEx E$dm,p;FF@= VMBxiǢ[?[+N*Ibi.M,^zJiC%X.7-wc:(l_oO멅YԩE^ʚ:]{_rίɆk{)SK+FaRΥZ._5g_GsKYuftxm|i./H4_[hHHL6VZ7msک 'vIEh=׊}KεWty1ӾkaҬ߿9kƚRoOv֞!k;[;d[s!*ɹ NԢӾeFTth>&F֥R yF^+;U0A[<CrKZק]ܿ CK-֪~o~;KsjA2k6w2뷜nwtRgd׭qNMY&Nn~ jw,sfPqF@F9=Ttߏ[[#ӭ̢Sm+ooI-UĚfT:[= r;*QRWrwwwW?,ړ5%(ٻ筭پFJʌ sރ~;RjwHz߶Sj71#Ŀ*ٳ9\Nkq2(C==OvwO,i0Ĉ8?Ο*izVb(&oɄUn}>JQM*VZKM݉ʬ$q契@U(&'pH~u--X}KܔY})97Mݛc"IF %8D" :}ޜyfL6 Iݝz랢ss 拵$ *+7+8O֮0IN܏XDY~Vp*zwѯ#"ed{A-_.::rz7D5nWшҴ9ikՑoBsWyi/iVԎE}:QVlǚ]R wl6`JQ^Ν(ß2;eds\v8SRz[tG,E;nWv7ngJ6"S授D>t#)%/ `?JTG(QVr9P y31q s;J-ZJrJɕ\(ZO =kWw^E>Tp\ˌnf' <~rN2sˈg˩geByf s'?UIS:tpܼss:qG'/Wy\m1A®JxLsJ2M$:*jId HJ#KLy5cMB3T]ܚzv؏an$3s71 c=Jo(_#^䶶n1w0#g'n_woR)ޤ7RytyQ.`7N=M){ +Б3A$ꑯHX*ϧ=*cN2ս:ժr"vU¨ؒ7{vctF%FPU;n| h^~Ϋ uUШr֟$ɒOm, E1x8#˧{JFyo~ӣOv^Ln2x$?SӜdpRtc[a37 ĶO&Ts 1䄛izi;?ŞztS\*ӱo>dlX:vNo̺8hCXspǎܞCKIGUԻmFێ=ϭuIG4Uov~%lW۴t_Qt7#NJ7ː=-#Oemjҝnmre,%<rnƐ}׭'-Gמ&RO,R$,v ^/\iӍ_u>gx^%S}v>?g.kn]dFv8sZ.mt Tߥ]fuRޤgL"F0R qn1G} /.Tu*C=5(ɚB"]~rPqՔ]!IsjK=Dn)֔m]q\JҲ9_x8'N+ڜZݶ"i6ΌC{dIk5'tױBagT~fREBV%Sո=r+껚Vi_lxVeW 8>FR1䨛jBo r$x;z^ՈSJO}2fhչ&<֣JU*X:. VR9z #ב^|aOǭ^wصck+G*lcs9r=EsԌB:;wJ 4,[q/_Ұ%QȖ!aeX9lW^qg*McE:‰{9Qz굷s2uAdBQ f < ͽ䊰$-r86vkHԍ=?ӨT46873G^ϥcNJF]w\v"dv>2V85i[rI[o=59lYbԚ^r9F^G#񪨤乶ЧVat nc c$`zN.VAp%'6ܴoK>nvEѴpTu-|C.7ޙ'U(k(ө$XoE p99|=wq~E}b2POBܒœ|rr hwRh'[ư?1%IpOr+IV,?Q\7L܊e͸x֝Gk#KNv4e2٣f2qqMh9CPYu9|"1Ђ5M֕yS冶ػc$~R U9,=zs+1̷3u)ӦV{N4i hC+'?^%]PR6(TPI=V)WRF>f.ȆH_wd䃟q޵TuFp喞Lǹ)YvO?Îpx9+ZQtW漌R+iMi&+ N}WE8ӗ>Ztg3Ggtd$A$stZN5:45>=ǒ\`}2@:3eyyM8j:/)|#8|\UN1{IԌ9)Yclbm;Uݖ7R0~54IIkn*qZαgl홤3 ^OPGJU/+Zu/+HiesDLc8gԔbo5ܡ{e*YyۊL/VQE]߁ѝG;4KmBYfUl`##TBQכ֢2ѭ"5| 㩮?{NQߺʳi*o-c(`#98Zn:L\j/g-$m*eգ[+ɍ䞹3^U_nK.2rH 5)''ec1Vۺj ;:G cD]$*en~+ͭV1d%CD.+]>E2 &Ay=**=%5q'fDD"mp3R}($- s8_A6S,ΥWq3Ãן´ѕr=XIogɸ7Vc_z`і" +!tg +hI_2p[-g9펕<\O 1\kۺb@cnjg<;dVuFzK^Cc`m۰~m.hӲڏ,5[{+m  ,cOwi,W.mNFw(GV -^,bm<)84̎ǔ#f F@0=ھ쮞4!b9Z#^9*`fq!霞G\i˦ΘTI"'ֲ6IvOA+ NPIsIҬMiAnlYa<10[vOG59ދ5JTff w= "$>`EClFHb9c:zKR;}@M6v1Y*oįkNҒZ]_Gy5"0<[{NkZ:W/g|ĶNʘD}q ?cj__O.UfGi--@ߺ5<9u]X+Ӷm4p$[~\:rcrt#.*J+;ǚ25$)$t1s#9'kQ6i~FcW Sik-{ȹsr|N2zt+ t-o=*U喽Z]0Y՝YsH#G-젉RHP.=??ZsVfS)-&`m~ΪVfҢAh4T+z)ݧ ;dfG"TvXٺ~UnΥ8M=-bDIVk {{W42Rpk_Br.2WipA9K^t}>\۽4^TNTN<+BWZ'u=YJ)bs#k Ӧi&TYms6#D^:玞-J&|#iGOA-vq[0a6yb_;M^}E~d-HUH\ }(6.]N+m=>w##npqK9c)_d_ug{m\OʥF? XԚP+{ۢ;k">7dsӎ)r+t3jrODyݺv1I U9<)KRƥZ'uWᷖH2$C:|,Y}{ ߅yueNtP꺋>DB[dzڥu#߈*2F15[KC4-tjЪT(ӍnZi=:hFO+Q/ږf]qg\tKA$9c`}UmZi]=7&;m6fgpxƜT5]=L)(&t %eROhN"5!%c.@l+ԥ%ʚV;B}?CNVKXܘcpsz1ʧ#ԅ9N-J] SJY޵NJFiӲ_#Ria&v)=rp?>ЧK)hSͯwDYOX^KFNU]EYnįjoN1]5a.{KsҩG˩N!ՏtfȲyeN 6\u)ʥ8f{]2իoK="mIռbOS9E)Kd_UQS4}}4>IV#VefӞx5#*Zy8qҕJ->a̾W̬7N9gUgFhr,Cn%ǖc$)hr{_{+^[BPvJcc[H[Foe9 }W:PeSg5Ԃ{F{M 4BqszW0Khy593+8+Gbi94T%-:z'dsj\\ 7$`]ydRHp̓/;r9gi*Y{CsYywYʈ9JU/S>U:/c5R'B/ުWe$=gv,s FR*jRW W?vgʜ܎;_3'=kim?:YR-Vz}=JXXb97+uVKGrIY|vMfڜsʥX |~^h}8T(R!2G#*)*EyZ<rIJɉwl<^򼷱|߳F#¨Vڎ@Q pAzjbUu-﫺-~O~ڟIc$Z{t{j̲Fhl&溕sJnIL ҏg[594TVkm;i7_l^2\h,ŏ9(F -}䭽+S$\_2o%e 񮽤kgiڬyeY0aAqۂ~>W>Pwo#u'm6om~zT۵%n\ SzwdzBj:pw.xK=U٭i#Y`랟=9K* OOjY<@ַrckufV~9 L.8T}?ejBIkN~M?xźIjzvk~ni~NI< OZհQJ=׫>n[W麰>tL+[MwKF߄텅đAlbçV8 <LW9!95ͽ-~g&;Gxt?_乳Y`\C̩lUO%~9T\ޏM)kol !88O H(֕o}v8Pb%8-_Lbwdx٦]NA=󎇿TKqRTMUZBM]uo 5Im[N6SG4m5asrcq*֜ɥMOWF[fӕM#lX89"CݍkeJoOr=_H|_d/#bc z{Xy6prdMEbzu=sUf%OE Ui 8V/¯ $VGI)K;RC`c=={xzuiI]OFJ|uk]f~UQo `Ē7Y ׏RifϖJR^]#OOIf _L^ i~J\o#wVMcq'ǥcٜJ騞Oi$4i|cֺ)”Ϡ{QzU`y$1 :rQqV_㩅9~ﯚE◞#FѫCt]rGntъMhve>]Sږv1ĮnI}3QZCͩݢ%f̓n~^1j=%M?{hy*8{U.)Aqy4>xl(8Rz=H׽rbJ9E+VzN+^F#@۶k0~KQEHishʧ峲 #Fbc?\k˩ZKG0ԋ;#QE&;x7]댫 Iz5)cQJ!;KSֲTp:RE*|sb)SAӭ:cFa;XGJqRtMJ6Qt f{5 /Ϟse''/*)Z#B[ke x$vQqrߙԧySnI&B\#I."@H9&z&}KTQG㫈ZA|o,I'?<yXJO0I{e1ȜlRrCr:X9FyQVtoQ06o%C2lo1xc3U9wRٱڷMSrI"HD@,GF~ .7;0橥QJ:Yn1g]}$5l2c^+مpiT}fZJ.ܽt9eVTRkF.2I^KN=fn"@l\dfV4im+bcMSPpZdUwf#}k֋*:Jǹ MEoB`4K}4\Y3>՝nZ~5nDTtWgܩL9yuM;cNDsFMMY{`4k{u2ّ }xzjS1tRj~=KH42|mwq628yBQS #kߢ:C]&70,clV2G5<:ӕ'kw~ HO;Yvw}Cھ3(K[F#iڿQhkI,?+;ckkONUmm2١d㙐1p?N9xtkԍI4I{$iu<:ĐU$e)$%Tt'>}61mغ_ǚDIjfo'vInݺf1JKȚ*J4;=ҥ1^.G4GeݚƱB_\ҩcϣJ>g_SKj K?ڻi8;{X_KWՒIX@ǖf&|*][ yfe/gN.˧^iVQjmf֩AQ2=OCkTsu84wú5HVSx^Yclqz779*r/{['+6V8\YyeVW\Cush5(+l,yJ Nzչѽ h3SC,Ψ2L0b[S88zJpv~Ӧ>m7%jѴ ŕ[Xr8W SQ^o^qY!ŻZoC];+ڲ= 0F{)cJZ5o3ϧ(M5JjZ-UU++gcs־s1E?¤(iGXII _9on c׌#崴O6Qzm"K[FMDQw/;Ww6g,ʳϏi B:}+J+5entkOKf̬J?]tqSM%qQNUC(,4(VP8f3dyJKl`vS%y:4UM'Ny޺qn˟'fp z0 Z}R8Zxj[O^Lw;3*>]'#ҧ圹wzjir;,o c< wzKI!É9\Q]61j[_ywzv]Y1 =j;QEVuӂ#g.VBw#(ݏc gS2QzEHN#o>7*\s֕)C&ߋrC|e&& jʧ|` 7dc?5SJ2zw9ڣg3sj IK2푾UG6[JNN?v1!-M;QQ啌=y?6:m:{ץ:4[ƘqM kwmk%Ř)ʕ;,ѭ vo0xcӷ}~_-nbIg$uXѦk㰹uZv^gxGᦧC,(6,xy?F33*kEu< J'Kd>aWlUھrz{=ⱙeI#T٫=Yíxx]ͼɌ/*_)_3*%YlbZ2u#Ժ]O?xwCuIcٿ{AdVK27QV=񵤛VKo{,:]>}ZqzW`cOrKoUp1S;#޲9%CE=ڽtw)Zil֩&ӧTwȳdegwv$cJ8HӨ֟OQ; Obm262xlw8oζT^*Er{htNVE^vA[U"k3/gN=X-48ᐯB#c׶EyxSSVa,m:b>1U$dvm0ۯ梦ң̽o+ESJɫu9 ľfFHy+(eG4*/z=֝n\b{~Uo*&ZWTҵiz n溣iFW=\DhQ排VZ]2l!L5L7aBs;N;uq֩%i4ﮚ:U+aښG(xVOuVm "1Ns@zbۆ8$>jѨݶ{owᱴV"եkݷ}WC?.⻻bdh5s" p1p1fU(hAϪVz|~$0>Ӧ~I=>g'í!)c/P 2p)NguʤG[u Ds6S3O2lkKkc i291mudR]IJYڄy231',9\6 #'*9Fޟ=<2x+4=.])?c':xfgV߯ʄ*2lAvka߸qr0+YQ+.Oj{/Gn<5VENe}fV}m/<ga[XN bWr)Sȩ9iz-6f|qߨ~0Rṉ}oLV/^De<-nHbbAp;Ec)?gŽA#$m&bXFGZQPCüMw%Щ&O0{O (Rҕhޗߣ2gæ\@!eo/ivzx׏ڕ+[B+3 'ˌz*R%jF7WDo$HkIѷ {ԩRZ-ߤVG ygo 22Ʀ!HujpmO 9郞՗&ױr(̼W+WVxlҥb"֏(܋Y2 ,azQcQPQk$sQ?w:֗KTybmkŻy~kT5Js4Z)# ҅-³_1H#w4;FdGl{qjQ~IMַNI4/# mcF;T?tc c?]RR\%'סdFوR2G8Ge3OiPN6M !TG"`JTpӔ 3Xds隝i4x^3l̒)ܫ\c`~W-HUqԎ6t^on_zc9?~k:_VrF=]L#=ݺC &HbC'VOws:r'?%R/coӽ(䎨Tc̹= mcZk*BUr{:]%eg#aBG99*Q^>h.A+ ^V"Fnwu=WLv!en35[y%iOy=尩T81$2]EkƧtrWUn68i+#$ʸVTu ?LW׏MUGC؋Hcd'J2Ɲ;or{{)\*#2pz@kXZQ,}-bI 1gfQ]4WR6KnFZ7ԩ*v{˚bR[bG|6sGp^rLsPJ(Ź|#Y2ܷUn?ʚ2R קQ\mYd%e#ӡu2G=IY\IH0YKry;O'ϽRW+F4״밡v izvc콟=nn96L29ΥK0V?f:SyO~zs]~hmFceڅNsa#H|җv9)Z[`&e׸#v&3ߜ~N4f*knVZH|rЫmyyRKAkM,Hǝɴ+rbTاRv4M9瞹>1.k8я3Im+>}mǥoYˑ)jvMHJv.$3G(ҩR2s鎟5J4-9(hi^>lqc-0`z' tr]xJe¥vnqܞO7oa{8ӗJ3'Rl='-/*ǠnReNRCy4aԢ7ϑ#9N4S(ӕܹJ ,sA90x9Ѣ9(Wm#? {dֳrڍh5׹u6<'Ԟn6;:y*mZ)q$t&,=< 5(Y8Zx|54)ԫQN-]j(>窹ce<YnS 7|v$$r=J?mh?SnyrǦ7I|Yg*do݆9 N+TOsHѭ9 wo^;BR Z_}Ik<[q*ii}Nu"- ]F$2.K1$`1N5[TjJ7q$\G|؍Q,Ƕ=k*8jlUY.t~慮ZM1fnⳍg ͻ2P˩8,l}Frӵ?l[l)TǶFѯʧI$1\^T4$cJn;qڥKVbR7iH i$^=͵Q+ZmTj[~e{+8cH<r:ZJckHYEgvnŏLW3F!%sv۶-Np {U:1徆ƍCy.lm6 ߮i~ԮHG21c`Q~ݪ#rw7o]Hum>9G?ufRh$]B{K{{PY˓9S'tVK^RV MӡZ_KKgr}h+tA?t;Y~-]9zߵʙ)(8N5n'okxɡK}#~Uh`cʥY{IrK Kioq%~$},u=KcOfeY${zjyeZTfS7S[&ۡo8XIc?`{4Jj92-7%} o,w%3,79;IapGQ).],f5Qȩm;FV)Px V ^] P;MFݣy#+!Vi{REM8\ r1pjpu5$jrBXTRZ=s盏|*~9VK]}OܱctRU-E}ԭ,$TW5}:}-v}-ljFY|VvwtwZYݭvy_h7A_[xI ' dnav}V%[*eZk},z[quy#gx,.ֺY bOUVyQ]d\1i#)q9*r*´cN-SѦwwN*_W=ѭow}ăkqouaCp6as<8򳳲2|Ik~Ƿx@:\:%݌{K[YqО9Dxh]|#/V~-=?Tr/4dQʑۓxxFO3WV5-&wtuݏ؞~]/ YJꯢ|)ҼS{Fo$hJH&yנ_A؈Ӎ3xG[d4vz xr2z8[{J#uߩUrnW9mGHCUm4WUpFz}r8EJu+^_XY>(w7WiEhVMy21nC߂j;c({Z k9TU?t~ٽ6~^GjU,WzYt?5Ö0x?JhkOg[ffrH9 rTWJ/oG{b%S|к{[ob + ' HCE:5NRkEЫrmk{n8@3cx?g >TL}9|3K˩`Fxq\-9h4LRͲxmg~LjZkU'-9~Ef%pjR2Sձ"i^ב^l:ON%3y?QҸjqʍ:^V4VXmogsW8j*RKSIb&cG^\$Q<Ҏ۷=ϻqcֹǟXWY=vNwۢf䜖UaviJSԾ j \پU5)yhy5i~gڤ+ȟHس31y.5EXcYC=|ʇ<8yu:k`RvX,/X>W&qO]e&Ԭ4Ցw3cܻz t3^9kD>`ၲfS…>#mFU;zu?JR]K*~sϏ;cbƔeOm4=sž7OM Um\qos_IGTvZGKPiiF~+ڣO"t#};mW6GzsӭlrsJ+(>iF2 R4hۄI3޽Jvf5+sT\w,1!ZO$]tx͔]O=yЀwH99*y9edږ>ZM. lv9}?J%N͈Ի= XFcUX6z7=+ľM5>طX=k} {x`1LcVX*G'vyNæEqԔI*sY=\H䑮t^a8|e.qF-?Q*D?/Ώ tdy׊ʴ Y"aTSsF9,e|m+;r;t߼W-=};LIn0].o:XZmĽP<u~/9[J?(6HwQK ؅iL-Nz'2ªHM=l}Eⶁ+Y-ҚOcݣ13|卲Gscw0S$&uwypfYWNzmSKK7U$LUmS{ @$?<N 3ߊ^J)?fZO-.H~)~=V,.a1O?//%2SF|o<_a&/"oԖ5ܧ Xq8\Ҥj)8+;^mK%}*V)K([_)~.ftd!`~Psh)Ԋmh^W;7rNj5eK^޽ c\M Ȥӌ J*cOK ݞ^/|'.hړ[FɊo8<#kidάeFk}[WnMx;n,I4g\񃃂r185O{(I=u[Z帊x.qU迦{ip$7e..p=ƣț֝ۢN߃8T刌' a~^_v[{=[M,4oB5w1A`YuGZR~~?089?tj?M+]\-M"ȱm O!$ɯg riNN7{YYzi roܱ]5^mxiIo=/aw>YevSWTr6馾W_T(]~{I U<גI>UUi#0sTR[]?ҭ_q=o_bdeUrTc0>WyM%ȭ>j~Sxw]j}Ke(xUUv?s˱J>oiNG؝/RZQ9<k^{! bbw?9c'O,9*KY`gitS4U֣PCWwٲOlSRRm*C,Fvtj|7ZZl}K< V.FI+KW8%&MdecbI0z}=(h.Se$VjYi#\k #pT20* _>YKW posOC8ɴb%d,.KH(&%'By+\} 2ߘu9tW)Q kV!щ4f:zWdvkS*+E4VVnU`W v3Z+eC*y`8z:z׍Rn/}Җ+/UhAgq'.zgsӞk>X=|zRkv9R4&=U nn:R4_qf$#vL~=q֏59/3ӥLt Z$szV˷CyScѶ6;w ]6p*OolW=~uKGJu%+-}K&cWXޤ7>Zꦪ+wF8hZ[ȳojͮܳnGt khJGsja+$ԹLow:V|ۓY[E8yjɹ՝{q֞Υ9Y}$=vucAv4irXFāP,Gw~"TPz+mԞfUN5b |"5v xڝ>Xfu4RReJ\Udx<EuKIX֜a{t'uVЀqQ9B̷9Fq^PQNb؊FIQܟCqߨڥ;&5v[oM/Ҋ\f+qonyb'vcB\6yk)GK0C&g-ݬ;mӂVJF]UNUQu cR2NKGDS|i~SG=D$_WW4<&++lS\[ΜeR7Km 2m==PDLTL[cv0=zG,em63|ҚLǽś-вRH#u#O6EԢ+v9[P$oNq*]eHL3) |wR 6jmHTNZIq1R'RVIivajZI+C3QaՊ=zt!r\·ZEڋoh*mCg޺9C]5hޭ7NN23 Pxy|6zcƺ==4][ՊnV }EL4̻=@`8=E\_&c׌jrm];٤ Cr@I]h(E==Q&W]g#<S]kvEJ2R#(=b kIswU m5bJ1µ?ϯE%X",S”z"*VGݜZOZGey"gB#]j[鲤!Vf?(=Q~*ו ]++X3A+9rG,¥toauIUwg+ 7X:tZɾ嶳4-W?Q>܊)(ĜCoyoBrE3Hb+?JƵIO lѵjEstX 了_ _/9Ar8jʋ{- 0@O=i{X4 {Jr8:U%.kMIg FeEUh,@c@D*J'SOc,E쁥GyuUU!^yfJ, ?J Z۸<)eHDjrݤC->r[+Ts+sO~݇٦%%xsKjpj-ѝ d7t~dqӡW[w/ZKqqc]QKŚ:rtyc8mm#r,` vq9S[ ˣMH5+0w*~~iױJU}{ElO6yʬ?R[{gV˯M.G[:ܲG`{AF@sz pRnϿVrb'%Q"ܖq#~_|;]#fɭVEimt]b2mm^x&FWbwCb&bYW#TzmR˩ΝT99fa!?j^6pfPjZ6چ!-ueXm_Þ_TM0Xz\_`0nR(c]Fo:Hح n8">mT\'tbv1:n exx RmΩSƟ,ouq{vO ܟnos_5B3Ȼpl^"Ì*ҩ'rHч]Cu9>0zh#ESxԔj֯k TΙ|%rN2:5c8Ŧdʧ4!0.Rv]ǻ=eMmd+Tƺ,Xa!8Wpҩnh\IU9{SV)d=#IrWPV۴rx>kTmAwߣ9)ъwi%Ր&s+H#<9::"b=YyYyyfʶEq!8$d׎X{ߑRI'輺6{F|RIɟ1ps۟q^~:֍yMq$ev$$}PۗfgtY%oJ" |2w[-Hn6ۨnKg-Es=sӓpMŚqo%CƮLjl՜e)m&\_"81tx;vgZ%U([;|e;F/ZPm]?a2Nr@εj]?ZW̸ẕHF[og>Vv4w8hSfڦ^9a"Cw9cDyeӨbkz$fU1R BEUSGr'Tr7w,o5ƪ9=ciQ{7 ٬%ZfIegY FoJ'=ڱ~c2 h^Vd7srAAY5+QҍWRAz$8>H`Wc֪u{)V ZcKαec8 GPZΦ"}79NU")~:l|7$h%" rlg箨ԒQvhkê]L4|qy"N+hJV~c y;\|rz5j5$3cZ[pYHB[ ~^s9اuz<36Ѷ5xԧ^Q2zԕ:T]lIQ)-\ӜmgࣅNq=nI-.Ji ,sFc2e %Omiba/>Gcqzg:'nՍKT,Yd߯^YGTǗJpm6b yq?z3V<2}^ZNW-L@13c'wkJs۩{͞M]j;$$=skJ9JK;!5Uf2Мgqǚ+єj{O,Oq5IJHasǽpʛ/}{9YEިi%k+_wt*8:gi-"[5Zw53nƴc(8^bרB<۔uʱ\pAy+jxx%eϓͶhId댂1׃Rʖs>"9$8kK{xbw+amb3ۿ\Vui>r)U5&$$:ylg#le^S%cgybXH$o,w+XN*H|zy[smI6e[zRqwT*4cJgGIo7$͸|<~MMXq;85}ԍeh;P$mU`q3:VhF- k*JI,?h"r0q\PNR)sZ#E+Λd10Gs]~nNZ^ w3I#[ᣌ|ܶItF:]i9𼰲=G Y$U0]HPzb7mY8Ɯ-4,AqggԕZ<ֳJU=e}727TcC N޹}TA(ҩ%8;{wHҶ>V#MuN4cR3LD!9]۾@JyQT%ud.0L4}80:Tz]ђpﯘ\,+w~]ʹT[v?u'C_F\D. 9'Vtj*ri^gY8U=m+cb˻F~n=k9VIkG l_G\bT$j7pj*MT=r#ukrC{aV7N 䏠]=k{є'$Դ]XKy0m~xgRUN4)Fwomv,sr1"f<_s_~ʧ72GwuvHcק޶Wv*\iޢL<ݲ]\gL(J%]wϝsC-쎉sNKĒI2,eRR ]zWe/ZxhfWj{{⳶mU%9J:5%̈%sS]T[m4iSO} $l<8#cOj-p 31"ƭWt҇2%+JԱr4jz)yǙ%^U(՚ok\I$1ۻ`XI5NQQkTrD*HwT 9cڻhFQWh>)^Iq$0T)X{GE/31I-ڮd3aӞ~5֑}J1r88>$K6cY#mܶx;z#ͫ r)kg#Vi+68y#kr^`r50޺/3u+fIcPHаPdDM;_bU_het㫹^A,[yeTXnoFUFjgNYNg|Im`SxPݮO׏s$u-%2䖤&sCFk˩<[i;/2 Bo(x#漙9FTw_#._ySd,|ŐR}[;/&Ue};mm9.#vk"uzs ̓?j T2:ՍGg9]`]JNGkNSsud-qqXӞ:\Rպ"BKۛw4UVQt" O S+#NZgm$ f(} i%:w6yySM:~HՍg)KFC*\yr%WtV֝X1͹xv 1kuS1NZkOm=( 6Oq?Nڱu+SdR\Ҍ]K7HFOWz5%k+ԥίmAʸaYԗ+UIU.YmLcr 02}n?i{D*ǟTۯiqi]USvg$AҾOM+2Jr}8EoHmi26;~^}$3ӣ:5Ѵ^ K+w^҃H88p@*Sw^oSN\_y~rݼbI )XՎC$iJ.ףOETon|h[lpq8?yW*SK\(شWceR !rB.I߾síR~K[OB;I7m ׯ?ZQ98n;YCC"+6ŭ+,?gF)n@Ʋ1*7`p}C^^"+c N2Vf۸|¹jKmM_˔;{5Q]BY[qFHCZNM%w,z湜xk/gBM.S`3]rP܊/QЯ|ǎ2[a}^<|5VS=SN[VFejc=ߡ^rw|{zץN.\gOV[YZMVhD|8P`THhw)KJYUj?GjRΧ|DݭoyqMj%l$$OAWW{np0ҷ"zlZwWʯQi|-eMn \4UyjZ595wȞk%AM7BzUNQ;X`X+)lOhmM/{V hPfTus>}rR^v-UZlab26:~5a]>tΚ+F_\˹&%v緥{Ӎ8/wkv] T4ﵕVXfu:WEME~~]JtY%=.]GQH^X:vރ9ҪU)`\Ѿ竈Q?Q6{@ghbø<taRMI)ԭ%4ϯaV$(KB3c >(Qңx O"K+vvmѳFxjJEuQCT].%%}6Of!+I-8c⤠30K%gonBJ,#98 d~^$Vm_[_CJx꓏%K-ִh';Km9E@Ab99rԔpJys#Npo^eCb <X1mzr0xOs:\^*엕XҳIܭgy2]بxy 2:m.ZW%.\'IvuiE LTG g)F+J SJe3VhcImۈINIЍ[~6ٺx59=t˖t7W\ #=N0 MGMFP' w +i4q#HDۉ *s;R8H+zt_9bWӢ(M0[hfAハNk|/rnVFc.nY+[3O)2iFqn~v5JgjI*#3ԑtF,uTջ!}za5ۻ e,<7zRUVul,U_#7.|=Ǧ,[+ws#{FSMnm|%*r_ݻKo~;/ZC"9VVbO\p1sڿ'֝:^cY}rtjw>3gFLdR$qzT8v\%Z|-Պ|/ nE}7x8> 2bQwy+2ӌ!r_=3x_-TZ"[[u#Qq= =G5]Yݻ}j{^Sn8}nﯝOW$6\yIqjuʉ6=Ez5 q9h]̣ÿdMh]v~3gխi[q1e0dW̖$yhג_?R{ykŤf19һ5i|oCCX4(-}}F!f;[s΄vnֽL},/8=]:bf6>j+`yJ穌zթNJn};m;0Vr"Go3dt 5IUu4<wkZWJۮyZxG=UF2GAtJ&'VPiɩi}-🍾_]^DIզWPfg'v9$pG\uk9'tz,}Ry E2\ͺbNO{vl*t_B9|e9Y[~jsChdZEċtdӟ*Y)Fv*8~w*rMyu}O%սz"iM !Px*>Q׫uio/Ҏ[~S|z/6ڭY&V^NJ7I8_Xz~MmRRVVO޿X+}c= q!rǝ7ͦ{狛Gwz붇ؾ ͪZCnsHvpp|J{j}Q4a4mIWso!@2\Sy-iӹ%hfީr9?ua)9l{Tei)ZK|㿉O Ց&n7lmzcU:QOv{_U^1nߡ_+aycve>Zc@8rGn;*ԋvqVJ7W; 3Ő$-umM2\@nBҒW*nߋW[whAN =+ +nZ57+}໿i'Wqoҹ1i1kK43S xim*w`)Ls_3jhmNGR.w7c c}O@08cFTEn_gx qvVҭeZKW~1IJ WPn}s ktKG' =FܨekƤ=,O9۲FyY`m}?JhB\NoZ8IJ ~xr1GbV"SRk=IQIs:qWE:u4+rfnUf"Sw^MJ1հc:v[)x63$ߖD< d=3__{ҹU%'gH-ZZdU'ؕAJקJ#S:m<ьa޽HP%$Ϲr[nF6 Ԟ8BqQOG8߮3W'kKJE/`p9b''t'F8W׌=iKQu#V_"ΌBK=^N3/媬nUVBTu~G)(k ֒*;.X3cpϭy~Ӗv^]N6){e#;y9ʦWwݯF5TNU ݮfB\˜nQ]rޝUQe<S(#k֪DߓvŽBxg۰HԷ54JK~6e WAW;m5Eic՛ZT$.5#zWh_Sq{qs3aYg%1NtΕ+3dMVZX^]sS+Z6pl,f5gg]ju^iZڿv!&-#N"Fsn y8k'oMzjԒZ6v}.v&X?< ln"TfqJWk3YhqfIO1 q_Z(%f -!g,q=N{HT5iKV<׹H۷cwsDycx~'1_#]Bcۮl1n3ӧֻhԎ.=zy%g(`vɺFfUX-CJ\^h?:ɖ8[[{U.͗q"ͼf@ FsɃlI-%k'1B7/vQֻz6teui#_5|94jK^օ֡RNS~&fn7g6ԯmK7dOԏKYֵҴp$ǜAl[SQ:eUb#eM;=ݼnsLO5 9 :{t1_IhegŽ3J7}sx-nc! $Hz|ČN!]}:u7x[k})u]Vk}p쀪!Q#L^z~gONT&{CX\5֦4+ la:sF1k[N)3y}2m}Mk7 x5a&)[GyB,4wu9mVKzQ~q}`Yx+OlUGʑ.ʑMoy^ߛ3R/.𜁤ᯒf@GxR,oG S9|"^"xyGi7N%YBb(^kJʵI&@-k&b̘c뻂O׵wrөM5S/M?3/\$Emja8ŏzٿgyʅ_Eo1.|Ct%lkA?s5(qrՄsSƩjVIs_0r]JR=3T]#b;~[Fj{VO 9z Y p̢EF3>EӠVN8}bio6z18?lw\M{ ݭP +6?2~RR9E)%~XIǕ/Mvv i7:t]ޒI$˻`oONk%R#HJw缹ECZls5u`,XdcqB4jJ>[ukZ_..5vٰvey Vo]hȨb+*p4V!^%~!|2кhuŦfHJ$1  [,DY'}_ź5JM}KZԛs~ -ŧ3 $Pvrpæv'ӯn '1oeeY/bUV5gae'3_oFjS4[_3c~M} WWv4u2X%F ьTA5V^|08x)쭺}}>~z~%rmYe5r$2:כZ.1NZfQk~o$Ԡ&nUc7S}Λtx4{hY6S95Q/gk;%*7\G:ִ+)mˍcfUڣە<汥NJ҃vOʣ}ׂC̼r.Q\]wh馺q*F3є1ku-"ko_t֕9]Z+S RQ.[?x{Vm6aAS'sWT8oۦG og{[Ni(gIIkxd?x6sW~[M$zTOn|) YuKbK([;q*ǜTx`{g?g5OpFZ=v]㯑Um_zź/ȿgF.;l ,aJUs^ΖC ]>S*=9^3GSk[dž]g}jp$ϯ5uiRIN4MX3t#."UsxTңm~KV!iœ{\2Wz[_6gp%_kZ]os Bm>?֛ӽS>jM/.rN\eYG#ï#1i_+<ǧ6exNO.22{t>.kb1չG*'+TwZ٧Yj;z`!7&hŨrR@Lgϛkeq}MOj6TDe\}ޱѷc3YlJ:w~`:sU-RSʾ$ݭ#gĐN~mZ%NщѤlI\qN6)Sؿ"Xc'? /T= AGngXCH39e NN ?Li龌O*[ovbFc#T۩'~[jG//٤;VHTFEn-NQ-A7_ G.e#MFnx=u芷wC$nXms2O;걲mKl^hN Z纓ldj~3'[7dtۿ]9jdo}w 8ZmRMw׷S6Z0FXwⴍIFOfz5N>7KK1)<>bWE:>pGoA8b 6|܌yxSROcK/mHɵdA1RI:O~0kŤr26cr wg04gF|M9j u˅?PCF=+ީKpW}%_e {9RNTӐ߿ Ʋ;`WdYד?cǕh\lwRIǸLd϶N8e̎(ԊPHZ{巅eFېJ;qۨov}&-^nnۛv$20[>y))rSIY!p$$\/#=?ki?ttQ{+vmYB.^FI>UF<\<4k_⻙Wk Ѥwoj˲:pjYŭf@tl"@O/>gdiGUc۸?{u/0yO$o8#xx4Ŧ#M>Tdė+qpd23_ +^֧5rsr4r#$~mZ1lsʜ=PO:dUʕH`uR=q^.YJؘY3vRަ;9+L!f 9E BK:4ph]{=1ֽZ4qt&3$9 >akjs;űI7ͷjy+ncVPbaQq1.$IJn=;d)zkpTJiiMēH6ꠒq[S~PNth$njs}xNqV܈ѪBKuq+upO8r_BJRV$Hp̼ ce;^>{iir;Tfm.\f4ͩI%^Jf`}F?SVԧYH1\oSKٺqԩmzyՑml,qaƢ1r'II;irwrwNJQ\4IsnWFCʊU`n>?IF]Ըڕ[[E"C JWbEkzi$g]j&EV,m}s޹ϩ>{&eG*X=N=z*~ Pl1p?{L(N.wCUF].ck\ڧk 3Ī0Uo*%%R&E$F$x<ϕqjEfPza9ǥS.i*q кU9!fNq5r.[Diԭu1Rʧj=>*etҌs=ȻW;}\ܖkIid x369#y9=~wB21[.=6gֳ>A}5F|Zm*Ξ}zy?iJ5%j=FplBv3<֫r:kB\a?>:NzF/Wz[dmr. Tr9to rT^6'O2Ȭ/$f qtFW:kBKWRbKzdLl9NTbk]\ n_i|hB.b=A!Fv>bsmGGg֌y[+OeUP-$#s+1i-&t}ܭ"\yjʛ `Id 9EHS[VVgm} %g|Mʄ*F;cgibRSZ+YZ7FB{YʛyZQC>aڣ4j˶F'^Nj#ZT%>Z)dJ@pTmv%'S['̟d]eҮ03׎O^r+L%zD>H#ҩ3;2-Z x|nElϰ.W.i_KU۷C>c}0l,QSugM>Wgf7Ef@px8#W.پ2%n2,BB99Ӯ+F1t}%挝B-vFb(VG jVv[7EёFx})5V8^۹*'&++YG]':mZtבUvYA9㞵.3qa&ja'aV(v4Nks)k1(Nq5;{2//>>h\H3Z#=*."O["3VemP˜Zڧ4BZvzMC{F$]߶3ұHӷxg*~/}|ΦEc ɵwLx~n7V WRҟ:WOTndvŝ-^6.\sRR4{kiåGMpв>`;s͢ЙT{t^g7-bcW}g)FQz P5*}ݫdE+eWhNFN{zܵхX^=UHf*ETOϽLޥHӦ2G'a].ݫQ7L__M4FYVYZO3;|8=O^ѤbEeЯJUeEeri1Sⵥ٤cO['KL_N{]49TV"#(~Ȧc Ŀ/,lWnjzWl^7TWGsn7ٌ2:ȸ20Wi Z>"Rgǚz>ȥ6ɜyj dwƥ2Qsj^&Ikeq⺣RP3ZZWۮ13?7ڭ;~P*r*_K]G,˹a{֍F^5l}F{X6qަ4w&EV2&0 翸+Pu֨J{7z1Ş?1[UOix*kNMFVFNu: $q0GL5y{ۣ8˖W}:im!Eda?\c){Wenr__U*_ʣdQ}r[ыGZ<֒Z-0$~$`6T²{jgSw= 㯏/6&k2GOo:ͽfY\xVӃ9snk5ﯓ]sZ+TTjq~N4f~Za:u!Bg^#z .*mE'{m_L/.x[_??=cJ>ݎ<ˮ?nJF$g˨ZY#ڦQe^AQ^i%ʍ<-Z7]#?.ջ4[f$:<ֿRzݧcXjҦKn#g2mm%x+}=;\N-KvƔp1]#ľ-6qoʅAFXߊFiW,+^;+KMW*Fv킌G}鞾XlDi孺6⿓>͌Ohn|3-ۇWg  3_ NVvkž&N'gxP׮>{|Moxjp.O@8mL:+|֛?juSYzigKĞMr'#r&RNJep;OFɩ{8K>SѦtO u3PhO5БeB!H+*39UJ׸kE}jvGYP?wvQju{WZ;5Ln ( ydqN*JkfݯkQeʵ*KUMkuhED_UlT^Qc>$ExXƥq㲟a%SF{oTydQ"`@*= yxt>c孵C<ZڿotHA>n 89xx f+4CAvpJ?OjO߱l/N4j9Y];yiݻy9~S䣥>[ume-]]va|!4~F闚P;>Tl =^|va$rz[[uSb1kߞ|}h:Mh6%s+ev?8B6op9){JJK7֭קpL;0t湱^MmcAbcLH]?wcOƏ2z"565}FJ+/E:ӞA?mLcVw6ѫJW{Vo(]gUYBzv>%RJw~&r[[p # 8 x>}45nZ3Нe^n"*K75N4DG:I4c "*ZZh'D6{dX'MÞzs^sJ-DC(eeW[2IJ(2y {g_[Ӕ0aiʛSno Լ*_G d6I[oWfm=3SSsxia׻n/agXw̘>bNs^mLGӕgVF| omc\g= *2y5𶍻>ٽPo HXX;)\V+O[*wxݵ͔O7ٝh8E,18]RSӱj9$K4'řۏSNs^8(pÛ6ZnNsѧm\z+{憝ۢ(yy$e?9Y8Fkoi+^:/uN[hBAu?1KƼ89*͈7[vkHn ~J1mt<ژD,bHbMc&a$s=;W$8r+NTշеl0՛*yoOƲ~'w 'ҸH1Negc. SՇ\ZE95 iZH;Km$7ƲZ3vKSU#ζ8yr8v[rÞ5RD3Z.Q BE^5ιcRZj7Ig\/Vl7шrc2q޴K8b6ܱm)9OBN:Њ׹%ZR|<4Ϋu,ۉ- zrqT_29;Gi?v*2Ct9MȄFIN;$@xFl; ?c-DydcfXl$ӁZQɚJ0К&`"5p=O|`#։ss;쩸6ф4a6Ÿ*_-مjrp4\1c~ѣdfrκb[k.r0N{N\.)rnWi)8d[r#tV+=:z!8ZlݞYF2>?fakE%c=4gM'ŒAs~S-/}?%ku*odj[Mkӹ̾&L֦ߕRGˆ󏔎xI{(&I]KjWu  8F-Je[[o MCK; )$xղNDcTw{Ksbe(|OkԬM6g8fۅFo3$6W*Nzn8|ݪmui>W[J -g׷?7|/pͩXژkY6| >Njsj}:9<X{J=?b? k3[o_IAot:tWg[oc9KU&ÞK"a 1l62Q5X?z>z3k9II=_COh$fv~~Lya! rkrd{]h=z3h׶OYI8# W=Oy=:'8-.y 8\, 8N;q^lU9QF*vXy.LMVxX\7QV3̣'._Kٳ|C[-h̨|ԙ#rNWgAC/'.WӾ>"JNOw}gR[M?MY5d$vV;S!IcuΥOiI_{7rto{!=wgq2˂[ƬAzv'ZʽP}f{Y,UMlJM/gMuVTRr0>ƎRnvt1OOwM}[- u 3V;K&f^0 \z<J V^zytuӧ*n -4n]5]tnf_ i] L#`;k FYYÎU~dݮ{-;sSTNZn3V.K><#i]XvXym+-^c#Zl_?;]:uOuwG}%+M+0 +_sӋ!Ly>1bK[1EɽHI$j[{/OǚKIY~-/̘?aZrE=GZP#G[FVbyr}> 1ҳkV&%]Ò?\dKDk'/l浶K7[UX'mKRfR>z\&Oѷ YNn.7M:qPZ]"I恥,g%^⪤LqޞLgЪӎeIsvb"Ю֐{hT{u 1nN8$,,-DNH=q޵$k>eˮi2 L끎[iQEc$sl96=Z'(#MVmO*UAמ ir煜u.d l qkt-ٟ4j$I̓ˍ_֟f3~hwa[Eu#:#[AI +3U)J6k:*J*e#w-kk*)n0qH<~u\ ?mQ HvQ}?ȩcF9R-Ei>.60z% ݮLcROȎ6jV8R:u%&. sHͺn[2i< cxD#V+UF,FʬAff2y1? 9W\9(s>IEFRdJ*Qk̊h>Go͐9Mr˚Q3R}JڬsV]4SywG5mrZZE1#YUL+O8\݇5(dY.xdtW-F嬷G [9[ Ik ګsp?eQ Tq7r}\-1U'өͽHC푆^q휟L,sΎ*J (tb0$ʹǧ|9?k{J*Z6gC -/`U=#%mX穈/N{9 fesWf3$</ynqn{;}.| s>2c;lpsQּ|E/hߴ^H~m_Er%>HcaaB ҸkyVRu9tD]Nhw2ڡ@?jJ?mhI%,Ai/(9eP0-Fef?CXsجlr*@'ÊQk9T*ʠ%;~gϽSNqNJ0qv_44Nv2|mUc.kEߩyR;z2H?6RiMzgfe]̪NXtR{ִF2uǾDQLYr=ۚFXii/u]RhG~`~eȼsZ574iQR35MIPjr9c:wF*n9E 4DvOҶ囓ZԗtsZm˟k5Nc^IOFhZ3Rы>q4Iݘ#c+YSԖ=9$_ 058慤|hƴ'{-MS ZkȫuvQd;͵=yQo-Td.^ǽ|8?1ٳ$}tFMb)b+sF-\DwI,3+,**r#ӯU8ӏgtfݬHݿ/&YJ÷'g}a$XMֵŷs)IhXM5}yg?i{n"?8tD$2yk^2x8sQj8U9TRJ=[P\!hpc<Λ_3͕=2nEe;]]OyZQuF->䑔ozժB>}ڪ}u\ۏ*Id۹f{cRh֎)jܔXl< 4^`fPÂodܝM:*ƾ0O+Pm]#ۊh1~\>|p']9kUUhfuZC q&aeA=1Զ1SR\6)EūG'$=px#=y=:WZ朹[6*<\Ѱϳ:QI90sbRpԧ;V=FeL31([RRXdNtF1r;h2#˒Ÿߑ(ƴo{n"ZFRw?] eCz W˿c6ۭǜ>YN[* 1z4puET|sF!zVb8Huc-S i6e k)lm'0d#+g#Z){.iTFZm *NٶHǯ[T;'Vg;dVZ6̟8eAZsY;"O[Ml6KHx:FTInsHΡə,Qz\ҦXzu:}Njk6׵~\vx ӊYn1Kk fo͌XIn{)PVE9v(Wv)irTeZ* du5!֏R8檜i¶R$д MnFc%Zq)k]-aJXR=Db;Tf Q+HC]S^T[-;=XyYe[yW_-Uʮ2zJgV{#>zJ^[iYI#F#]ć;n:-s\F gyVǹH1k*Mvf/X1,-p̐ApG>dpľ]v浦}+ϻoos5~G;F5,$'2+84ErLaV5nQFXϚR{8jM"β[}ZЎG^+~Zz3gSRw̻n6`1r۰[ss:T')&ORjsTڏU[{=vW;Q7'v`~5g#bdFm'26y8<eb+t Ycs;a$`cX/=r}-EY|FLtԊhmﭣ6p s5/r*T5hN GHѩ;ch4\QӳSFC{\y?c2I'n^ݒt3ORNhZia|Ϳ**8_N- )_Ncjd pFNV%'.vs*~Tl.tiI6:'S{qy[UUݩFMmwcpܸaILdfs0$#ssWF2?}hhKg! r6nzP=GUiJU9&lzV>\8ZT" 8˩֧wgvZilq#uEǚ򕬏EMɌh6+4X++ jNҺf~_H_6.g sU/)mo5ΜW4ŶE2lĮ'?Ru=W +KVmsh2#p< sZFQtS rtޒ]n6%G=)K]Mi{YJb8Rv1Yf|z}{ou(R2ѥwĒ}-q"6o 2}[RZ[MzGUzk\[4+vl@Pq9Td+N*q]vVFhea`OLr3SRr-8Όon!^IubFr~oֹ]6qzGq~ufS\72x繭5tڽa],g?j{k"Z-g F#gk.pӭRUdOfz(py't%6 IԼzuoƱ[+gUX +c*qdH¸SrVߩB.[M k߲?ؚ6v*IryRis^цcx }I6Vi+g8~PH{Wv{GFQrKYhv#WGg&20q{*%E3 `wMnc,c nV0UWju*E'ktIUEN/#rs>9Lیex[V+oIR0$c?kaS&查կΈ*joڧKϱhxX>\%Nx8\ԋtG4*߿Ũ -Qz nJw[JUSZL;, ݓ2,Mnec+%A{?gSkdޯ4&i'z.b,[ll? 蓧*~ߧSbw{;gec2N>54ΌE}w}ӆwκ9:k|VI."*y݌gvR`eZ97eȵRn[GEsC:c7~QvkuyRMmu*GѾ6et.ڸJЊNvR۰ȵ.CȶZ2a@#'Fzktʊqizw:gndwO<$E`|,q9ʽJϯcS.ӽAe'{=?s/ov9#9QQ?}-*쵵 !i^fU9's/#b3v֤i]KK6l6(uUsgDӌwc y~"rfi|F=uZJo.x_(]-)':s)Kޘ檭hƗ-B~ȟTibGF\Gȹ:Թy멛$I2|tⵣRrz1N0I^K} H[Cf=^:ie'cA~G}-ºn{haI~E\=8*6WSl&3F\ە.iژ{ۦ%Vۖ(Xfr+*Q7u\MI{G]u{kk˱sRmF&XaWE8B~N2@BwTźo[%/g/]ݝw\xWq;9-GcX|A9N5CY9ܖ2U{ߙ[$ړOo%*L7Z|o!U $I2<+Z;;>hvOҲ\ڍJ1dV߽;m<?tono>6=0zrFOZ:rM$~aW-[(gצOO9RN7fG#%V~Z-(y 8H>2J2垮˭Z}bfRS0>*\!/.=Ȍ̩#T_ 18uہQn/&~[xX+MZ۫3&U5KrYْT SsrS"2?uk:3n[z!p.mYT#=T򥌭%+[u^V4rUߥ\#𧁼=yo$YI c3O^8,Z.:km}|LS0h^!Pm=q}==k>teQ=mGm7559-FT3[-wHd-?`>Bݕ{yԔcF{ӯm6"rHЌMmmm#fWC[Zn!$s$20VN8qiZ*8Š -o?2ƥdsd.7#uyhu-kgRy'&DdrF$rA#(/AkUzsMeӹ%xO[l9N#PA3Z؈%hXB^O]l|0B2Vm$lY`01:}qJ,jʣrM'oc Oچ5TffVس“0I9^]/SΣʧR_h^H{!Q"qDHdW%ՠ3?^" {/#cH/3qT𜿺WN\>2V{h֧ᨮdeP-ʡANP0ҠHO:>&zy~Mf}cC%rRI4L&?$qG8xxjjSK)ZORI5E[G3 xlZQp;t Rͭ_3֍,?5>5m6LIo.18*I$3/g(M>GS-^fG5x䌍Ѷ8zǍU1Pw*;{'m~E :SS01Sĸ߫f>ŽGNeuk]^+P'dnV ~^s0XF&|wfDibV\Lʜ/^zcJ"*Vv[%.iw:}זr># =ңesS)E|1iv݇4G-H .]YeOvy/ʪrggkN4ThsMw͸v9]x_jζ"5 ̷MNZxѵg4ؒ7NvLcGN)WiԟCW}hqڵ̈`||A+Q;Y_MZتg%{~uDA,3bs~V*4\z,S^n_zmޗuqƃ-i6Vm[0w^XKߤ䩺u&S[:fj~ٶ5&!Y *J{=Lb]C>me,${Tv04ٍve+TO3 9.O48 .k&SZ% s3֫$d̷~BFOjg*mjN1i΅YjSMw^c26Pc@]3)+z[B7 V96w4-ˁ!;9lӥ{X{NmӾ2F6yt@+ȱIXf2~P</fHRO[ kzl#C[x'PT0'zqXGQTr JPZWZەURݻ<5IsJJma x>mS!ӯ-_qױb6YQב>/[[W;mp񘊑~F0xxbkeSl4=<}pq96?ɯu'ú[vRƍ{i~{q[(KvIGakOe3[H[wb8<G F*3Ӌ毌I_GjYDfUXil[ps"wO$vd Uj.gkJ)tZ[er> VhmIm2 98$zb *8Fk͛ӌj^/#۾w$.q"[#4g 0>sA<RMGoNy^io+|:׋<_5d֍ZeJ\ԏ".o~ߥ:|?먩GϚ;~=Vb!O/F :t~S*I>Օu-DV G$``F6>Qj)Seikj2Gpb]2 6=zQѲNerzEf\Y1^3mQSvGUJN1ϹHmw;ŏ2j>ҭ:V*ww_갽՟-fdyxp;z8HE=7>s2J.tH=+_ [M@ `3^#F64sN"@mWIu62^ǃ|]%h% # ;9 px:US0ڧ5֋Uyĺ, !,I'f4}V8yQ ScY^6̽y Ҷ978h7nm%D5ۣqԜݜ=Jߴ/<:qɢaYwn ֒~e8|`!>e9>?Z7;iԌ}"sL*c+FsWOa{o;L&ߙp8N%׉(I+~'LrXg'' )я*J:լ$ 4$9l{UsH饍>ɴECucKdS1r1힞e`ӲcѸUˬ Æ[0TV/MN:([0I!$?pْsEQWfn|#-NFI݅}WGk?iN2w}ox^W8۸~22:1m=7Y5{]qB~]K+tk,N{jSZ*A*~m  |T*kbeګEf׭oԉS=߁$,](-6\DZ~kkcLkq$\uB[6cR<犿p"HYN۟tFtR¤t՘Dsen9VF4X ½svF~cjF#;~uo3snPs׃ȃJ(ʚt3旺%VO(C~uOMM##Bbe=*|תYA 7JN"{~5g(^9ǟU:'-dg߭t:0ӊwHKi-~۱č%%s_F67IRV0X6>]ގ)Z=F-hl>U~M;[J8(~"y6knns9nEu1`ffQ&Ƿ'Oj욑R\%K 92h [n74X+QQQKFH4vҤ,A^j/)Is!J!ʺh6Bs~D㦆H%.Bde9xRjIB<>nbY.̀rqs)̶3TkrE/oj*m(&Dg/s$n<7^9֦QwNhXC=FF+MF-}F#_2T?/͟ J[Ɣ]5˱r[t+9ߚ 2NSsMxp0tee$-NHWt)$wGRsx֮#9䥳[M?z6XaC|0}\oFU%..2Lҷ~5>ˡ*t~{nwj_ 4JrdղKSݖY|üjǭtrrN:qt2wnrqV>ǚ*Jliha7'n*#̾# s8rȷ}mbG"1&OHRmz")|uLvn? - ISQ,~LڢQƬ|z湥J/E.-h;c*ԥU}ɣ1XԱ`[8ڹ-kܮʌ~%$xOMNm/T-iu+8r# TnI UkNFLEۅ+c,NA{*{l:QuRŔG[s{؈5)_ֹdh搟v9 S45qڒ%nVfan[*UgĒ:qnԪ׍InLjsTzF@[g˕ҵ痳} hF=L]Uro'#$#?LjVl :;}y=0!C9e:uiF8+:*Q`jig)>FqЎvg<1S29biX*doϪd8n_q~ 6}`5%K)c TUs|fU)J:|ۥQ6 ujv[]I3tf7.7Ī>qON޹%}ϸUF\~gcbolѶXC+Ӌfьw淑h(oܰUl|?\םRɜQ-OiSKțU |NGћ^Z4Ucȏ=;ZD[Q^ѱb*㍡ xF=G+{]>E)uBv_Jwꉝu"0pFY \Jվ2jwTR@ny?֒V^GE<5*m+Qctd6mVVN@=GqNUWMt:*I6vͱeaKn 'cׅQW}ISy,O@Nn뮍UNjyԗF VRy7>TiTi`O^VʦRwzRqIKdsEwq=xq6RrX[y y~`l^ZU?vG*Ҩ-i kp>43_JtE$ו1L,?̫o$^K"XNyV;Lg[IKЩ2D1C.O{gյ}"teo>z}Uc|> :n]]~zt|IFqzMW Y]z28=k'{u ՗Qե<4xLZWfV`v\H8鎣鲸ajS/V>GZħ+'o+E"G>!jvL6>em0'#eQeʾ%y]误]z?W_a wh|:Oxڌ_8eI;9rr Zj۹X=:t#̖롓o66=ݼ-dPA9=xR}+mDiԎJ1Z~gu{A?[2c3;?.sAOQU'%ֵwyVx5ZovYYi_ۍ;-Ze1}†b%O }80+']ٯ>/4ӆ"O|YG. xfP%I;2s>IEЫ'm7O3ZURxƳ:'KH-[O8 r79vIӪy5kr=,oυ+%<\&3# FrItahQFuahf!ƪu]m.X.-݆\6:$ץLVPq"i~絅UVT/r|]~iOWmVWUBۑH`6 v/Siqyo}GBȮN9ݟҧ\^$#/u4r[za i c)7z![;T H)݇#0yNE>nh5+պtoz8n259+lϖ"~~)?j_o.bfNfHʎyU[i' `烩4ܲZmu߱GpTҍZIj5osJ`-敧i|3.u .[oޑJlm$ʝNYjpn1M.ޏij`0V//o>zjuT|k6y jRʸȒ7_ c S]KW,YKn,cd]};jGEF3k{hww q>\pL*-(t5ئ-p :yr**!OoScM۸o۸RQ&e}.jZB'֩)'vu~бMW9#ߊq۽5{nLKKp]G|\5{]%Ү%\B@ q{JqiS[C.%VOeg`JGrNz =ek8Tq%ݤgU_ױ\H̑"`b"|*4vm qfB`nFKr7pqkƭOV_*muIU$Xx^Z9&tg՟;TMi6wWde%RU݉JhB !6kv35p')]ǟܚm:X& duvgWȠT|*G^ӏZ^GkNdjbQn~duPҺ4워7n)^rzuZ^Smn.5^Ka{W yuY=w˳*c?{s+"Iq,#%?x׳*΢I>#ڭnXۣ}%փZ}ioHI0YoHU qE?mIK[+R{w,]JPM.ͽyzmߙ CC4ѷo 9群+G xjimmt_>iRFky4^n}qIjYF74kZDzBW|Y(lT~[;~:}2-ڟ:3g_#)^;=?R {uKYee+vf8PHj$+imxmZ;z,a$tpA ͍ Nhݜ]R ^h;zD9>_k}qe91m3|ɻn)R19ߨ|AI›/+t:PRMKҖMco,#qOg[V#.[_=0E; uݹ[i#RY95q8v$|y kFJBNb} 27y#<~5/^Ŧnyk=}}?7'!&9V@YW}+X$̩ߙ"jwnӵT[_5b?kxGZ;YO\PB2DTb;[~{ V4a6qZQybh:?a&Ex>SC rٻ>ddЩܤ1U sGS\Se;a*JW6f 5ypҼ.EB9!Ee#v*y\a)E8OU-n9BhwH89ԄUkӕKwZ+q,F/cFF~a8^-9g_llGn3ߐAk|,ci;"e7nZBe<5)F79Vz~$ۤ.'ݸ*Ik-ıUO?iμ4::~$*8? N3z#oe'gXGU) H1p듚ոNjfRвڴ~S|̾^s19K)ǖ.h"f,͹~i;Gu1T]*rM<5 wc2mt)E+$UJ1DQq0cWU.Í9rĹf,x_x :V9]Ͼϡb$&9o3t+Ni{a-Eo#W,>I]=Y71c͜e}OQO{dkp-(˳'է+i)#M:ԮJ8'.k3T+w w9A]Yi\zWi!S"H˷G:vac&No$(B˅`59Ii#(gyyt35(؄ݨU{hvm^{g$ Vvo0XsޡKK(S>}?Rw n7=6ߙI,x9?Ojɽ %N4jG-QNAV ̣F{CYOTy\ue{ᑇ#&A6ZrӥwFHG&%;sTƜDQqU/s/SUK$ VUA#ⴍH7N:cT>XEmqUSMmE{9-VnvC}ת\ѕ[{hs`/I P͏xQҺ#F\˕ڌi⟳~G%qCodm[QF'g.[5Z>sW3̯sΥ2w~ rr֜Zc՞he\2_9ս9K);y,,m-}ZmW*#pp>SWG-9JkBz~G7 ʸf&$p:gi\>$֩t3V F3ţ  Wg,{1+]}&{s?k:u4ޟkN.|}uơo=!v_*9pc$3~QqχM/t]R[%b{HoZXVL/ I5KuܩFktwK6"W$cp<; "x)e W;*o/۬,I6n5Iko>MJ~~֏aBVnwq\X:G~>=B8ߡiwKϒvnUn}uc:*^ѩΖKk>aVGp?*gZQgD\Y[Fi[Xȑ2Lv.듞z{hIs4dFMK. )aXc~YH~{+U$\Jy udaEdʅ(yxw_RjԦK~dr-vF8xN4T?2op !K{gXQi+T{&ljx w+J1s)FlWwF?Ī{JNu&4KIUdI$;]ѲgʕYT~zHydȳmlLrz_QX֗"KV}KvCFFD1zǙFH:p1szq$ѴU9Lw *q;t#ӧWn]V*&$_Fo.4^(;S[D?U\ߩ1J&$ڴקȪ3!uiEtc)F5˝H[QQdT.U&F3BɌ~lwR*IiTz^Z4w"@9e` {59d|i[^.`X%ovv?vU%/w5T䞯}:ym$nUh+Z*vo"q&Pq[(g=yϵuae*rW^TVU-)$m 5%JO-cUWt#o?z蔜vZw2ok9F_gv^C岱N3ǷzSvkKZ8N׋Mī!{nցDqpϦO9eZMݜRxG}UY`|)|gp1knYScN[{ܯlWӣ_+א>nJ7rp+Z|эjSݗ~nkû{1rkzTc-FQ9=]Q&wS,6m2fSz2eNϡ߭ްWp9\?:r$FFks'8ۖ3އUhM;;O5y$6fW`1Pji5zxD@9㯿JӚU/wRj*gZjs{V7èJ:=OB rsu۸TJaVs/X4͸moSQFn`i`͹:?f՗o>敨yi#7Uڏv5\K;#Rsе$xWiI7dN z:{_sNW[߽DE#$ 3}rG^åeN5(.Ά뎢ZO4vpji d1=kMJJCMh"3,G @޹kK?+9K/N!Co$6L$s[ 1aҥ5{>-VFUX3'qj\e{߻eVE(DcԼ:qkj*5' c({Ҭ5$>Xvjpqk/%T-D.,Vy'*gWy<#19LU9 眽 j&tg6KHWh;Lsc *r{9Su*Fϖ)[^ 緍/H1GqXѕ?bɈ QЫqv;yө+Fwlz\$,ac8FP2zi= P,e!Z+x3Je 9+y̭n"MBw}l2[o2bUܻ's6R)ƌnߘxgS˸l8 }qңYaQd~W6+݅IW=L*uLhƝE&zjA,qH)X|p#NjU9F.^(?Zq$Ėm6ὼ''zt/aM>u^g5g2}G2,x\rx$DsM4$d_O'Ey).lY#*#7=m*1R1RZQVWo$' ۏʊ#ʹ^Ro]W[yq/@s;r =:Wj|Cwʹ،ی|͵K0^v(*TsSEI*@&?UCO{zt%dO1tns__$*SzjFq˖Q1"䶕Yd`ckUb9FVvk[4WWpXAcXYeRxOO>*TQ$C &C,}$`sӷMϗv1JTGg,M>eEf,v\V+V1ٶDϿQlFؖ]Nsc :Fi?{qUV_.cV@1Srpm/.QvpuTzqʝi_M5iBY~lxᇯUHѧR-R3S_Fэ&Wڟ2p'+J%ZQZjwEfZeվۜcT,*FւF8pCIԎzV}..}v:`Ƥo~[ny&M߼^Em)ŭVɍ8ʜ8#Q(fT.su[wSВ Ǝ(ܼLU~wî{~Rf#C:z֊#da<ztym+y^.nE Oler{x+jvK'+JuW%ʪ6|oGlcVN]zQ.NYG^^F;;i6?L}{Ta>{h$ T-ܫyd^q/SjymaB"%̭Nӿt:$vʜiSp]+M\C6d 0=c^67U(ʛdHlꩿoN9]s[42Zb(ŤBѪߗ߷'*vΩSס Wh8*mSfy) knۀ<̪#91Q)ʣRH)H|˕hGhW'8'LF-d9F5*5mz@aLlc;ʷnsxQvrbIU/3ʖ9@;?ҹy)l%9T)]٬mq "ʆcAεu ]EHnڑjsC4F[gnAdOnZy7w)6ܶv3#@UW@J*T`a]_ Ǜ,LB9wǷҦU"qljF+2W`^\YȆ@RJ>u@ݳ^rI߷r*l}[B4~01JZqNI1"dꚋGHFBp=F98ZbwZMTOKS\Ckmb{HZM= uk9?n=XjRQ61Q@k"'Q).g&#(Դ5F}Ѳ@UϘtFNtym?#OwyJ[f߻ҳR (ҋ}Lufwl]0AS|QQT̍> =͕ISMZ̪Racn7GVI9md7Hoћ*xyZL^m\NTjF0zN[^iEKl|nNN4}m7y#Leڱ)Xyѕ}vdJ 2qZX{->7KT֣T 0>ƸNk{о~Wȡyo!$:UjJ)Jn05hԣa[DZN[U/y٧RkP "5UX¦2%*b;j-eR[7_W4iѴ[8z(M tIB "}5ZŸzXklEnGCJQ6VUޛyqٖʺqmn"Fzn;iZlG߻q)J7NսNG\i[̱s"IꣿL {~|DWGe9U)rM $H\?b7\F˵z@uf4'mJQ|ҫt6,nnV($ՕHcr{,ew{^:DiPXw`c%'{79QZW_Pj.e^#6,sۿaE ե&xzq.T/w^Or-U.Ͱ"c {WGNU5[l*}jW"m=<Α@;rz|㎊^RvkM|GR\]'gfߩai*\Cy 0@9b*&vK,T򟲦֚N]hTs_hZHNH~1 1+TJE*/oh߉-ӣ{, y;|НO$c8OKW&9-OǐgX#BO^c*jS:Y浼ne5,J>aӌ~53:RJ* Tq{2$,jeo5çZqMu}OswAsq\چ54e#$0۞Mp3UR]1FR|eY. .y{RU'}Xk/!b7ES7TYLDa|9}pyqNQkT{SN'.>\IFW8qsikk XۋZYUv㌟jqs++/ၩ:r啥w \V1 =Wøe}L2=W^[[gKھf q-yӥwOM3adwF7|.9Ez؏<5ʂVfuoEyp1J5'I[lsbN4Ֆ_B_1fzΜ%xh3gZ4¹rzgֽ<-)ΛчS^kG\揸߉Uђ徤 M C/6Th:uqP=M06WG]gg uѣ%W"fF3NՇh>]F2ik)6͡+#}sJ6ƬU:lSSx9bvN1悎z0%xEtVvqD*IElMX9_3NSqXu)r]J, #Ar4F4%c|9.6j[kzO&kF&%rZOKr(kIJt291OH;޲뵸Tx+֎*1u[}= xU@y ]{H܎eZ454Mk|/WNRa攡-:fӧF/۸'#W*s9=tjs ťBimnR'x+ه_CWNk:Ѳi%дfeGHċ |/SzүGMOو*/)Mt{A@4S|+?ݏAW+NZZ=Wm?VXiuHUO>b;N7eNv:BTwy"4,Apܼ$kg9]^da}.뿚ƵbsW܌3۽!F_vr¶)K4&a˖yT.ՍG͎v8|DNxO jb3kD{ F8mVr(ѭhk;oǦ|dŝwO٦kUXI^9:2I^}OSe(=^ٿ? ߤ\68sGneYK8$ r 鐾1ޖݬͫ[/asL4g;[$%o\/wXhrZbh ʳ4i1r9{jRRI׳߷_' ^ʤgMu$K-[څfc tg '8jb0x6I;>fSˍh.MtNbxA Pmے~]L㧇)=_3Jnߩj?.qmd(}&;X mS?S=x0Z-toV<=uhkr 2],jo$z`sӃ^&&Jxc~F<ƷpwVi/߷<NgSb**'<5숣hbfXn:N1?M<32`v{wk?_ՌQQqT??=^ ֦?ʬng>v jNTK4 9FKlKm#WFK 4z茟6{o#85F R䗠VҭY՟BK|xCaxb<[ Wק:qWW\k4 JPu(v#/I(kZ2)8[{k~VU?ȹm6վuqt _1p7lubvIzWf*؊:.On{'ÏxT/%# "*x$I,+)N1kcɔ=4]Mև}CZ[xLḎw>p2)1єJQ}ӾܤJR>'xB߾<-:Mi7)][u+3~x [MzM#X 8^ys8I{87=O kK>4[!?C,kNrpG# :Ҍ鯗zu{>YS_~þ l|5Ư~\#XՌԴ9rV-{_|~I%} w{(ש.Ikrє]=;hr,2d%8.>g=wF޻U[v,9ψR4y`lg 'SC/T"gmknvb^F`anp T> %Vo-?zyGߥ:㨯J_ShyAnGr=9Iϖ:j=ʔi?Mo[;v29N鑜vk5}]j*3~j~0[vcH%!eWrzUoOegaG~ZxUqs+Lq"G=kԩYsM$n}^yoQc x^gf/#o^8/R$Z-GVIF/[M/j^mj*V`JfY|N+{jG h&Uf^OF2t$.Zs>&ṿ]QN5:wcJ%I4weWdp=iTucK-yOҴ<p=h+rꘊyt]uJ+}?ƼYTFk`cC[9j7^Q1[hJ6:,LO$:b7R]ݻWQ=EZt55^[,> ݹ]wnǾ}?ƸB8xI>o^8ݭ\Z=[Uk.SYxá~b d猒;+kॄמNK.%-OʹϚRSSR!;yûtK*"|q^n1^MrsVfh7|sUOxxIA-#n\_bWU[w;kNuj6*M]_9 s~$hetYA}x.k5Tu4h }tw/q8szz1afi>cѤm%ǜ6Oq9Mg&rJ'[@b["6X'oλa"%7m |u޶l$x䎼|zi8;_bj:~ϚiZzW< 4y^աhۗBۀ[m+G?^+qJ1[yCOwG:L,XKb8rA)ݫtESNl:ō[MX %\'\R22{s]k7o!aJ[Okiim$ yNN7 T\m^1;]g$kXYێ89 ] i2c^(-)o2!36ާ`Lj)+_#z=6w;m.Uh̭owH99{יSKKWJrsm5kσdJ^6lnB'pf/|z>Yda"d]^ߝys m=F~~kuQ)8jrGV8,VwJ?R~kDiOxM$dHw,r0rF?\XlLS.t:a*iǢIx`mmck#m3js:jPiplמ"+uM"y[0Rs~++JQYSg5vIwzf54&ײZXGji(؍rK` vjIԲ?s]Ɲkz*w_33C^@/PA?J*1]7ϱ.{к݁+O '@\yLeSqRwuΛ]Xl 3^%5\rI@r<XR8xf ь6.4{t&h̤ 0d܊ΞaI9KO~Hҥ:NvT{%i#Z4 %G^,zvb*TjsY5矊T斑j +a,~~.s6GhJW \Ă6# # 2v`R4Qi[]V_;p)YyMMy8R=l$HCrP66>O\%U)oѝ0Ek[;nnWËaG"6hC${O |`#˯Cid4 fcUH'Ls_p=^]|ѥGtK˿̟ VX3׎(J3rMw򭊕YmfPB7`1Bb*Ǜ_sOU{$u=BŬpk'[^κit1u}>J!n=A_?WԨݷ1Js-ű0\xi'iSjJnÅù6]fuF5>xjiM)L·oʹt5%sl}ҍ? xʹaN>әjgB.35{bfg!aT$N9''uB8u -a@\H3 <`8hQݴK`pXz|;EOAi3wDx,K?\]*-oeRj+}m.G_{GWUC,)*O$3.XOgFM?>ysOO;Qڋ>$ܛgNhaFZvN\-6JS}>goN2BZ[۠*j%oˇm+_a渷Hci̤aNJ~KA"G0dhmdQ~`s?2z?i>봮z /o;&&73؞8YS8M Gc+Q~FxKxfm=[1J:T[5hb*xn]uK:|r+gpϵpծU?)|jygQ>,`B f~r$)Eoxf+Q%°T<ʰiSQZ$o3 wpܒwp#ަ8i_MN5~ˠ^HVpzkEy({a$că?ʿ-0u({Fe+Yoi-ѵ`Fl7#2 =X,"fT%&sq#?{"0y9SG}}5)3r,wzMyAk21y<|<'3Z~FZj&7եżhory=;~jjȩZqiعkEv}ckv:9J3ϡAipG[IFG^ԫTo{3<^𮯬G[!oA{{\ʌx9))Շ3ggx;S$49aP?!l~_֢b3n'ɄAx>RWFz=? ?7$tZqj]UE|.){e勿r0h?@7~?]Yr]0kFbgd,%Ku=y?mN_h~TFRnF?2a8TO1p3>nT'T\2A`N:=~ʺ?wR.RWeN޿qJFR)y#y^;TSrOOcj]F⅊#wq3~{k~hʟr%V=c3Q5(ڰ3 H'Uk(ۊ%y[3|[\+ZJ8㊝>Tdח+"@fq'HySgt[CsFV>|'o21̐R5S,)hϚ})Ge 88?0/E]t<ǟDHrUapnd{8<<+J;A,0Y$^lݕ\7pp=?Jl}ʣir}m)%{os|g'+~vΧ,emoh0ܦm?'&`Oc}:{V7S-} ʝG=mcTn~fub_p}8ISs]Jr7GsڥnXqױ~FT9{ɦsTD՞l2[^U '=2>:jRiFS{ߩ`!6瓐9<!<ʱەe qݎ|Dv,iSi$UrblɹIQ~?Z&ryy[Ta̲ \k۟S<}+iKFFxew]2ʽVֹ=rǩ4E04s" dGݻ9^2ݫXFP3IB2vSVʳ;$q˴#$*KmL g{[-$)'&̏8OmYFrZ\oxb/qnFk9R(é.xW<.D,H56W[ڙ$ynf@<\U5*Gd¥_uYi@UKg~8͟s9_s'Z?kAW |nN0XK2 7(,y\"+#cgR]vk8Z3ʼm Tsr~U2RDՏ3v!.v'f-l\h6^5hVYk('*N34U&4|$Gtg /9zq sIshw(حqt;E?0 2i9$tVRiRTdlyrVGKml*d#q;Ȇa9Lc'듕NWcH䊲F 8A;`˜@TW5o/ݒQL|{l>^kus:I#\6kA d>z:݊r-ZCU秧Gk JUS;NWqo'cJFYpF;0yZeJԍbE¶^{Oˊڲv6槫Z:F\^wHlz}=릟4d TԋszY M$-=xk6yF:2lH'y+=6:#JR۹`0\¬9G$n*qqCd=,ԫHs=)mHUpyn~cG4^ڜ14!$4~jJ9=~4S!s6,}XdRC PM'fI[rv~f啙W4yw*2g+#gdf⍹awhdFڽppY]c_WFx-2;lm8 ;zʰu%-$y}Egpʚz2a?=ұ95AFs&;U 2e]pT3˭U9Y9ni m{ǽ%6Ѫ33s[Om'F,5b~o]PN~ecZPҔYBIe;v0H]OrnsKJɹdTr(*y:uKurH>dd;xʚ8N4I]e0хHi3W\^5Qowe{ZÔѴu1\,{X7\wj5s.2ӡњKD=St]Ef8֧.ynϼ #[1˱X+ AycOzꩈ8٫#BN/Qn6r_RQh GsW{v28UCzZ\7j֧)5o0.&>d*s31skG]rru \q+QR/acܪtX ^(ThR7 gqD 8z[֨ST:*j${.5)AJǠWe?iW-T证?3<Ҝ+Pn㿝sϋ:]PK57U(?_Jz\^"2kup74Ҽowk"21p\k׫JQN=F_U.O!LZ@7s`qJ-r}f+Hw (S%l}~OٿyX鷖:YXQ𐭌 T6@ahṜ]]lz 4{_cO֑;MX\kn加lN0F1F-Ӵ~veOgF\[gח^,-|L^k 7V8 uS+G,|/hϫCj67+a6x$_YZ[ IFot 0i:$-uCbKc'98\.I-vy롥avݾo$+H79PN2pO8kέRkR654I#Wa~ed2NT+:w*%g'C:Ѝ~EpZXy-OCkN, O0IןW?zxӣ[/ִt(M2¡13\愜SfoVTBGLEWbJP^NId+F$zԥ+(k.Z5%&k/" 8Z$"TRrѼSʬfev=87Gai.6}3ʭd`t^e[5DRx7 H~~u(Ы)Gw7<-G)%$aہ$q+hۿnjʤoOKV=S7hU:uxiў iG'lr:dcj].r¤yt>Zk|Jj5ΗgG 7ϡ? \im= 9 û;cce맡eʷ5YifI/$v$eu3Ant]OFpcס> HQHʥ<ۯjHkT8w !mGTFVٕ_GXUܽG*\N֨/c<ܖ~.\ʖW*ZVCcEq~~a>M^\Om_ )S3\谒grY=2kF,DMoXJ(/mٙH~UkrIJqz80UҪ䏻J/-vy*Q;W joЍ 74*@b1xgTz[mER n o`(bFϖԊ^pwn'8'OZRTʺ:(4CkȲĠ31ZR-u)Q~!cm$Ӧ>j#O/u`eh hzȲGq(k4atfXwA>I&e5=.--b=cA,g͓te{1Ջ"W;Drۨ>׺SG%H!arU P\@彖ߩj*[Kg& ne8ϧJ^KAӍJE߹pK4f~l}t}@#St4hygfm˻${ԥNO{Ly(Kθѵ;}[\ү!(cpdwv~3fj5k].XsGTx>\^nlYci;sZ}}lT08iGh+m[ٮ[5g} ikڜ<fFSy [qN<*V[].[[X$SS~W mrNF:߇);[ )7 9|eEoz>+}jҩ,Taӽ[Ϣɾ5/x{ GŲ]ǣu Lk$pg= N+ʚtS3=}i;4]_euswmvlefpCy N*},k'仦}Niz~y_NĞ MC33Ak!Q!i$#=87>1?-L>`wɟHQ̹VE"S9\91gk mC?#\[sNe8l5jߏEpT4fQ䲹 ᳌sߚ 9]hZQi]FQ#VzJ.as=OS]tz[uS7̚ڴm8&}~yde$};s>5=Z+ae*jWGnGƱn1W<zWuB.d߮dhԌ"in}/hzXv*" N;ʀzgouK)'&_ƵR]Xm%ܻVh dgڽl./,}}/_K{u`L;0#p ǡ}hI>ӥi}l=YS55o/pr#g7ڠ,ʃ S)c{+ք7\t>\?Oͣz%yt?,QcXSiQ{Wɶ˹?NLsI۩z^J ׯ'}},w9k)OtGCelOCپkDƍۖJ!uIq52Y^s9Ҏ? Muu).I>Y Gʅy'Nssh9%.dd?:Msч4ؚW`|Cz#5tfqM5oFŐsOLi*qVt i efzS*{%ס94 4~r g<TbR0SM YWmU>j(ZnN_ޫj4A$|9S8x{cEH?qSvƕM؞r ߵ y=zO? 2in2l[bzWҜdV!d,͂?ִb}Jy,-`wiԧ+Iq_yəѣѳ+޷C:zJ.ޥfOdvն\ |8ϿZʒIJqztЋB+G$,}9'ƹ9E[)vCp|,rߵsJJNNLT#(&EH[hq֔-64i>B n_4/|V=kYmLc(ѽ`;d-~3\598eiSK W&]O-UsrXΜSwCԉD[k`Gޱ(.ƥkAn{`Mnl眜ָrn7I~'=H**4{ 3Uae`\| ~qT>nQa!rv>`˵yr9\u4bbVZIƲVpOr>بƝE((6 $w|K)ҽ9[N%y*j3եM6Ba8zNt,iEHrM][.pU/m}sR4j\kc9JUkJqEyY6O+*F9n^:[FtSrVԔY!72r9E7(r>UtyHMqF1TTRm>DI:B*HWZGh9˕-l{yj-YfU8l@ s6ٴ6W}YuNUtCX󍧃5e+]ISQ8݄xWha(a=1+xs_SFQ]5o:8nIfmI{ pFRfKRbѪUsOԚ0c9S{; k9.fx9_zJ24R3edYP^v{Qe8ǗQ+FG$ޮ-utQrn2D0^ +dȹ'i9+IKGr(t%mAL6B8 9PjeͲvgDcys!x&زbQSeRh]'Fkг,RN˶B3'#w:rw* ]V@YJǿCjUuP"F Nh11*:Ұ$+b`=h3_E9]_+k3cdb~{Qwn#}yn嚝ہrN?~4JVFP݌˽]E oƜSS`-R|A$Oc:⹝/-;ʒa{rǃ}jʥs$d7",c29N3jq:^-)K{I'o⏮[rsxtoN4 -V48I,[Ws*ymlq󎙮5!FhNr8SP\nyFK7C~U(nRJ~%pInBp8XcNq]z0SMΩ]beUu(ƛZL?%h5͓W(y9Ϧ8/zV#8ѭi{.-;Jµ4cUFR;I^M9y"Ql\ִi%,EjqgJi e.I?4K/hcxŽ6DlSpfxrUK;{T1x2z,T$SIϕ!o9Ʀ115/Q4޿M0e:+VԲDJgr[uv<}b++c)FY"WF 3gTU*uwe;Ky(NN:_ʗYӗŸ(͵Qoj5QƜ^qy)EJ澽|#K7j\ܯsyȳ$ 3͌:=-ݯm-͵w1Wh˷ Qu%uVRl1Thc*rT:~4^s1Z!I( 1=+*F\Kݷܐ< .F=?+sta̔tV>cEY ÿONxYJ4jѥuXmtѣ* ^ [!H_.=$+p yY!TJZjYggir> ֺp_1TMU6T0\ ;s[rˣ:W5 /XMNSt8F +E.)$:d6 ׃*4}6EQQ{}?3]&G<}+IJHպj!yo'\O?Һ} <؉#[7~bAp\{?d;d]ISuT#i7i+YG#m$ni $W-_cZ_~-Rw+L_vv֫ 8֛[icte68XJiIk錩XݼovҙGQ[T֖.Nj2axg e֑f[֥NT+M4{v{OUTi>kѕJVYmjLgL돻~U-QT՝^~"%{OYKޤҍթS# %G֒Iѳv܋8\K3̍δ{yQ%唂Xdcs~_Z䍩uL?3\%y!k؞9T$QƧ*F0I#D\U8'ZfHW;(yϚ\~PehdG;,O }1SӋN6hK2NEȧk?hI뢷DƤ=MtpiܶI 9XXXG 4wpyP82UApLz:tiq ۑa~R6֮c"dK mm cW=Y(SU%na$oByU!S䂶N4->1 ] YKQVB~a\s۞4{xE?h}U ap1?fqêXjot-$k乐Ei3.+m?:9cCxZ#i~-RI5?6?u(Լe;VWD֬e@a@VO/{9h띠sy{Tt%ѮK5m<̾K330@c5+-ԭލU䜨n<_N03BI/2VVM_Œ#Nw;85{u yq5ǚFeR1+fqqU'JZC%|wZ6WwB^T2#| r{Ӛ# +o^de٬[S6ұ `*S=*$r'#{kv}xۛw~gj)TsTToIw_w6%m6I' OAc8"߹uhMɻ>CZ[8[&l)x8#ۥRZ8MbUkdYG(f]#RnƕNir?bq'܉~e߅aڣl쎊 JѕԠұeRCyڜn޵Jj3mm/X~3SaNړ+doK7~=šOo܃h]435S,;0@1W'2W\pRM}Kx͋fC|ꭸd8kT̪^V\]G.m^n1^IEs~U|Rz,..|ܩor=?wڛnq{Fr|'w2GBG}룛K7sF9M+qGEԕ}&ջm?HFl`AJT=buQ73Xz:VYVq1;KrO'$c>uF3[pE;nۖ'^S#R1[ƞ-oX^Fh.$Rr09h{Hu*T%+[[ 13J7`8~Z ԥ.hQt,rƣ1'Ԟ*x*sy=[LZ*s$22q˙Q8}W]:e@K;1ۿ>9ӽd}":pjQzƋ5^F7nWHu꽪>ZR|ԣ-E22h^(4W4h 6޶/s\rR5^E5/ұ($V){W:nX|= M%d ^q˕˗όDv3BHѢ߹zfbcJ: ݚ]Mcn?\b~:K#*TbWzh+ϭvTFpe^Wq!۴Μˢ&UV}Ka*/̫`ds5/*Ӌoߩn c-#ø䲎^.<=i؞(BN*;uGVR|meY{]:Z*rˆJ\!<1qemv~b1Q^ F)"^\W2VF <]xi5=Z+EٽK JO*xpEPry83zpK}?0`4OKh?*I-JwF9=pq^Q%Zɧk6AYXٙn(꿧Oz$hWS̷kf>KW-kSd[FCm+mcC`[ߚIc|+xe7r6,r̪FrbF;⛕:2J_Niw{RRMKW|`l j.\BV΍jɥ}/n8|0 ̒rcIDvqlg'QʣΩNR+[f8RʪPrQ-xZ{򽖽߮u:%ruZwWwE<-lZʦMXO*KOQrt_/䱴S>s Nm7Q<)Ud 6C6b*p]]n0^qKo?Kȶ̻$fygѝTZ;#Gdls'YӧOٽW3v 32Mn M$n_+VOJNY;'2IHٶ쌅l\\u8~NU-|$kާݮ"1rH eUf#:QO)%9gPk!E B1?e[*1MJtpcq[sRy2+qY\x?|' *\ZEœ+jveF#3GԟA^"q34btb_EiB jq}(VUT㊄c̛4^{yqUFمxӏ2_vrڻ@tn׏R17i*u"a#76ܔ5إ{qk K깮/zܠBK$f󏻸Wo2Qe8mZVAtG_=tN oޟrf~_JZ;H Af05y*+jhS&&>oCkJNU;)фo)dIJ;/O$-zTy5 fϕxܭһ)w(ӧ&-X*+#;1Vu5-Me%<1Nc۔_Miػ֩,Z~TuNHWUy&|=koc*pQ[WъoWur\](Gan 1)F*su[(\՟9XB~aJPދZSf՛ȕ擄^KXٶIpyH㷭t-m{u'I8^[}%EWz ` ziR:u 6!V&[Z^ZCW?uFEmUE5&T3IXc^ 0;Evz>ZeR\zf{c5 XcڌT(۟c*jowWu*RPj54m?J'RrVy&jvq'7+F93Nl峿.2 Em6aBRZkF,j{Ἆ- [e_ފb{ttt#5Quj ̿gao6#Ku:'z2ںoCIc#Zo !:[e]|H㜎՝JO zym2DvC#4qI&s`: U~kȼEUR$k[̧۝B%٣ 60ǯjΝog=UQ%R ~**T8+YT:z]1Qs4w&K5NInUONsJTSI.U'701^{~Wy8#RS~kI>deTjq}*}?G=k9}{KpӽW`+XP଑*yu_*ќSmf;ͼdŬcΉc8eRlL.g'y<+j54V]ocԌc׎KsifܴGg{78_hqZgleemVuEH85=mmYZF3Ч,-:\m[>zu1vk.#*[^OwQFOgmV{AͰc=#k_CѾWN-Id#;88q:(6ۿR[B=o%ߵ[[g\,;>g%q۱':5/Բ]5wۿN2N3^>6fԣ$1;TN9=+:UKCV?J8i%~-bŴUF׊PsybI.ǟO.rӵ Dlk;1v2p9q2TYB1^ϩ*5#$ֵ]oy\C-ny,VY̸ @ܮ-0z^Z}7K]Lӊo澮]=wܧ&խaY3lv? 8XѨ=Ҿ_γaZ|Џ_KӮ$[A8X0aaZjWzosicթJVO]7FρU-cPr,#Mp8ãoɌ㈦M;?+ tOpq`R?b:WKҋ?c#Ruz+k~JGsp<6NWrd,7Hڻ!B?1j7mIv1zqq59֫[<RV[駯ȥuZ^)&3y-4ySjGG* *0~exv]},28K.mvV݌ ጱŶm뭇85?7xckBI4yP| tEJXۿg:k_xR@35H)+gt!Z)[uceZ_TWK{oom)tKXOq»ݣc,ֹ+`q/ IikjΣ@88l)|܎sW_euQZ2jJҽȯhf U?.24e\9x8_WKNQ^qIA6ݞ@<8>kIT~^.yɻ(x{W,wnb˴ i\5toSJKWZ@ւ28d`K|xӑ[˙KsK|y_%Y3*I zpR:i`TM/NA,IޤeR)-0@e8=+ԎNJ-gӣTJϪ_~(8UhYlCa#ҽ*9=]_=<_SU魵(e۟޾v*\xb#;Y|EG92#J`nd6Z&#.NR|].]>17Z\ڪ,ke„nHysק)Qui;{l :o_.yk3嬒6}}:,}ǁudmI/[\q3Tr>Ɯz%mgEqg)̤ާx)5d41<񱪽FOԍL'ӓV][ok=*U )]J ۮkm?|Cgms /4hg-2EFŸ1O<sThbíK[Fi";ulpx^ۛSj1t'voYxMb[xQ`%pCg$ S5T*TkԏMs>IC'o3D48uf*NZqI݊j6<1vZKF̃snR$Vl0H8ӆϽgT/g^2OjU}ƤM_#0oc9Ǡ==}8^W~t>DW4lC,*NF VUJlWu?qrP:~>g9#֭3/U6~v%oۓ^235󸊓{syu9k\lK m.=篿^כJRsԍ9azk.l#62q;gW澏be Eo{u n\oQ?=Zk-tU4Ӌ\Ec{x+l<)DoW5qlF>]uǽz|ʥh},B.OsCZU,+ӑn"EgmyzMʪk[5Vfwg7 3*G_N#[aw6xsJYJџgC.A|)W ͫ^yL"L,|(zg228c%bp8SM4>8ogt[_ft>i v;FN3q1 v^G/Q^[V׼u=9ElCz28/ F&{q u۴^}iS].jzh 2T)1xS'K8=2]ۆqۊnY%%N"?ֆ6XQvs׽rJ] KpwvYw`AQ5o-HY"L`~C$]Z:/C:;w3Ҿx)Y8MK.$r@, tU7E=Wt%*4~_q쮵R;"M,D;z'z )Fa\05*SKүUA?ξn{_g[k_O#խ&Zĥp7~'9NJT6l;%#;POGH1(NrT6zץZ2ji߿(Ӯm][k72^^q}nؾm9폛3:B3^EtF$Xaf@@ڼߐGִ5-iTkO_m.!E2nWN(34LOmEB]5(-a7v]'^Ym3-'0A6~Zrr1>ղzmjҎ"1KWE=qRx ֲ:jZ]8e+w(+>splvAXV&S T;~tfo _<19ǮF;{JQgVOٹ=nh$qJ%T fFӓ)NR[:mJ 0[Xdln;g R\^+b#R74`d4cko^B^k#Y-;~Ggc;I ?_6x<1YՔTMZ"Cb,fyJ2zhLc%i!ZeYq '^ߩN4uYj.O.FNH S'ұe8.V7ѩu78z{9m 㩎SV;M~1ƻ0p:ȧu'm>m.֟5CuD7\+}}rK޼ⴳR-9G_>ŷEԺwf<#H&Hd XwdjWM1M5Ԣ~(udp *w^kӧ*n7# ԓڷkt"?O5qdr0d߁_Tq.ǗRxn>kie0yyX~I85XԪ|zG󬽜c5{Xg%8oh{Ty #o3o0́<¹&coԚ֜#uMhHEd`JAnG~>iFGzy}7͓`=zB1סqRWէt2Ifn@#8AT6Ob܋s0j n#ӟΩABqNS<4:. 7 @?U"1k7}mxVT*사TZ)^ڝ\ѓUbbq]ϖWgC1~7s͜wZ(::=NS9([6'vN>u5GT6/!XaPeֺxΚO$rldEP[pAֺ)Sc$#!]z쇽-P(Jb)etV[vmR%d7A* `m\dN-q||[<ϽcT-\H[rmwϧ|u?5pt*V ,n^;ƳEF1y'n9:rvvйFJ~?^I03.bK` YI8˕+)e3)?g(J?Cif^Dv??vZ%o!sġ+ۯqV~ƒtiz2vdw>m#8nߩIbXGZ8v 7.=KYY+~ʭLR}ɺ26O)IIY%Sz_)M BVܞlv1/^)ا>VeWmo0ɞO=siu:c(։XqF{0Uʳ@ oʎΚUE7f#V?R6zWR^Ь/&++GGmCTiǝkNe;B0ܪCNJޝ9O[#.W^Wˬoo&9 8'Ӕ`*4$;8M՚n%X@y$bwڅ.Jr2yZӧ)YoBUUdZA%gj*mJuQ=5R徤0:q\dVRH/b'I$!`:dof%gژGRn4:Ė>·fN[=tQ̔_O:=>E-^&}{JS\U)V^vvڍ奻KlQD+Ïh䄞zz/[udmo 8>Gᰵq-ş-XǷoʄg.z}9皉sFvs9rJoo!V6Wh VO [ENyy[NBoc`|-ESCS؂uy cc.A84Tyl߉<w({3C/v&WϽrﳫhXUvi]B9su:Sko-(ԍgE+.]:!%I{9N;;))h9{II.S,eu9jRAJ4TG: .(Ɲj˹go0} :LmʚgDa)NW{76/# sU*RsrV鴙.^Ee|D's\nRH֍H4-vu 8z$Ey_Ȩ\y_B $gtf%YRK;.~WȲڹ:I5+O/qx;c~N8 wb;'N4ȲiYFqKUFJ0Z*4UF ͙_>xŹ\x82]t9B +)p);nӊo/g== #[eƧmч2*x?{WV5+?WcN^4nR# e]g\g NkXut ?xێ`Լ|&7m{b95 9 \dbʹ{\ʧfkXUḪPE@}M9b=c{T]}<ѕs]鑱86]SF`u.K>,nxXRBe r_[^=nyy 4Iϧsv𕼚t66ڧl(䁴zTb'Wuuaq/{]m}mڿ?zUϏ= -{t yPXR߮qbT bpX;;ik~,jVO}DkM!_E|lcVnr9P+ч, 7ۦ=~}Ie_~Ty=>2Z~iڌY?[|]0H8'08n1^׷EG1ʒaxK?eIqZ]i!iUZE9 ۋ*,!VLUVv?UkF_pU7OQvo~o+f֍[ͿSZm!5kwxiX 6ayRVJ/[_揞ԍG{_O#KFi'QoV8UْB.Anx;qyuH*->Ec2zi84Z;vG3l^Լ?4#}`S7c|+Z1U!$7p֞Gv|[/A_Pٮ$ pE qr@FAex}/:ɞYQītoy-vq~4𥾕L״3.1$0 +ݕ fN~ZlBNZ6,m[HC4%ɜ 0cue%8saOM.px&xI&h>fp`Vu5 Vi,xS287f޳Mv3;#V~f.:rC<'k:{ݬᬧXo$' (3ycʧJ2+~zvEf;Vhf8{pG<`W-j?X[ou:؏^[i^CZ\Z̻@NN|rZ1/UoO=cjkZ-LLw6z9ENjmltb`J2Z|$m0|0'ox~3`Dm# `T\M*+ӵI[W;J-a߽uK?$&]-ѝ9֣hҳ٧t~[#)+Mm}v:+;8COkɕ*=շS-GN֦u}8ݞ5F 1)^yg~ W,^kͬimN}-~F#[J `z v(|5v\ԓ4-ofB~<3ק5NϧTӛz9ch?glJrǯLtO_#q׾ £HFNI9J$ַd~zԷa4JY۱;{ژ:ܰ[(Z!iu 0fq5b#'E4N7*]zGi[/?}+ s*VԗTpң( ep+XQSu^6Z7F͵r#δ֕:nԴ஻m=%CdosWs{j|5,uevp$|W6#i91u?G`jB#gcFoNm鑕\9 ׽yk/=޻:6ZFVMۤ}⤟=J\F7<ڤ=ϑf\YI~0cjJ-Z|w6I#">FrzJMjGV[FXGo^]FQ Iy{@;A>}+`gN*XYJ>KRdt>['래0ZjCxg (Эx(-/4Q[(ϩ)I.FqԇAlVݑLۤFBl?QU7MEm-мUiMSk_+t=S>=" ߗJajF\ǃêvv?mmLn}JO=W-J<(ѷ[F3C"[UC^eouH%;Wm xYy$P~: s==O>$xfIX+(^mI1N];]TS}Z; rHv&rG'8nìi$βO!8s8'5n[FIYߡ8pV%$tP-BM;J3Ik߹4cWZnR]"yRy_#sweߧFObX%+$_/82 ^W=Qʧd~~5LULc1¹*rF؊23Ct6Z]ݪ8=zpה=j*2^am+8k5{lSk6dcsgR1Ng-E<|{dhOG'ZS55猢~2X97`ck<'i<=q_pӴn>5g~ai?%^)>ϥW+#4)E~,SIϬ[kVO/{jFb># u }G~+m|C70![gkr>3ZM:=5_fL&lN+O{i>xC 5MOiz^Io}&߾O]gks_!NU2*qqwꏄ+/u%5gmoFgIOɛRxq'`i"\= BԔN"IEyh쵲Wv1fѫCnE}gKMz٭yZWt2dQ&TF;8sVZtvZV=UueiGF= kc}Z]AhٲUcR'7/#9cJ"I=4_3#Reg6mK}$3A4|wc`OU_;.2ũK{-<ߛ_#>:NmimI>-ߙG_'ra\^eox)nl 0Hc/NOEml},jZ*I._X1$2 f2)`v* zWNPnO,C?/#M?zWg(e8Ss] tƁE< ym#8h@F1g6%ʬǝ,EIVtSm.qzйAcTi˕tK]S6Z>UuEFں]_9qЍ:mŧ߹vI͵˕+s^fZ4e̖[gjI16R$ ."W_݁އ54ުݷچ>.{뺾=s }VLżڮ|푞A+pG:T5gU5&4v:#e oe[ϸ*;Un.:u!VZw{iSխ%moW~?fo76mV8 }7Nnm&??*Tfu"vZEVGˀp1$׋FRQn{ҢMϺNcJ4oROmi+y^[: \*2 oiTfԴ|@Hxb39+jOğ#,QUf NkS>iߠnsF# 5~M$9̉Mm"iT.w1y{TX0Km=os#trPVb֖ԛԱ0p-9ǯ `Srzknb4QmU ݏ#Z!ʥ%(X_qd_~RJEu,5[˕ x8E0vwj*\~?a~kKc\;U}קRm>D+*;!W8@?/eήxӌ̻+Hۉ_2Mz?ZJKChj$i#F(7qoF/\|һ'VNQ5 ̼9W4I2ι+[l˃d5M:\i)\̑v ?gSeM/@ xPyJy5RU!gbی:xpY{9a$~īJnVb8n/Ю(0\4jVۻwR9'RRq4( Iu!V?.4fIVU-5$^7In#3)cӁ?Z)r8螽-A$ѳbp^Qy^4$;UvY.9ƹjJ~6Ԛ p)-Gw{vu9ZJR6A)+梤eиε9Y%cVޤs/5[!sF,F;/ okH QN5l~b#%:I"x *K@{[3sGEf,Zq[ B"qZBc\-Bmtԝ͸JX~}To3Nk+%eO;NsZrRјxίn> :1egI^4Qرo<~r,H̠󙘨'ݍL\>FfEHK]6^8mMXԣ8=7K#ڬ>x}J%MZ[]_n\zЩJ1ywЊc46ەzq߿jr}2N%(y.VL)=ƺ"KB3ku  `ͻ*>uUjnȚh1m3(ÎxKK|+߫M"W!cmïpH&ѩ~kGb΢Ldlmi:op6=^)$eV6>88cgdUF10<7EaW'ǭTeίkyFH-_O.rꈓf{U^f''=1-6]OV>lNYab̪WhF2´.S˻K1eG\8{k;'F^sVʫ b[p; ߖ({J+I#7VdWwGm8߭^4j%q,3qq#4sVVsZܒDosN 0ps=3uS+5O؉;[mw8GQkɡ3Y $T$督񮏫zIZUYќs$~JI媌00Oy>(T:+֓xu#{3bZ}Gק9]j\qZu= .".Չ|YԴ~TL5[XF;u*~i Adҗ՞jwԖ>ԤePnYT9F&7zW>cp/ڻ=訨ң]23G޳r~}LN.>rӷckEImܪ n8:҇-c)a~u,62}>/&S2 -# ZEIXG4>6wo?*QN֗C<Y5cI'3&܈:t8=C$_"SmŴsjWlsSHÚ[! qnf7?Wc#ݺEFsXKKgXYU3|ہ$Zʧ2ܵ TNȇI-N3JQ| 6(A8#"crkn H"1϶k:n?E6ݍ -_-'?5V$sZacKnQ"ݓ88 uw+cz"E1Z- dx#z78&k-4>@}ˀ}0z_|8V7.-+4jL(F q铊t¦+gS9GS!m 뜍ZƜQE#JO5K/]Z<Qb7#g?ZJi-/ #V_Nyyi`oӒՉ'1S=}uק8ȥFv脇Ƣ6eSdqUm('.kchʅjo'tCx;)f,B‡`d>F:#ԯm^gq$LX$\)>`~hA-u!N}k5Y*bֳelֹo3h8r8EsѯJnd|j[᥈))svcʸ$r1OC%y>ƕ"g5x2>emdu9pƬ6w#$?SZCQ8=jԔj.g"^ڲẒ]V0̾X,Wf<ԭQ^qf("jEo1?MJwn:%*hYsok{99 V2kFh_iBv,;#\*o|1묩Ԃ<(%KxW;v\8 cڴI;?ǩEKg/Ϳ psZԌyQؖO6?(Ŀ(€=qSrW)N#y9-Uheqex:uZGٻ[KɭmTFĞd; t=OU9SdL?{ClL24jW9qS% Dʚщ52H (ۂyڶD>!Zݡ2[$ &ݨ73tִ1v(S-=G>P[Gd }(/_CPiɣD FTmiTk{oKCdwp7n#$yu*:qam̫wgyx cvկS>XԨWq!U9QUx#נʜuR^=h{8R5AH#VJGAQSM;Jn76|ϛ+ܜlODhI˿pJscy˴+`@>zR6={iZu`R26CgxH+;Nqedg DU GqJ R17uRkg28k]=˸6`P1gc]OƕՕ։[mjt$EdL>QJ#xE+[U:j5h6oՋ>RWQWhG޴edB8EHX0crk4>Qa-K!f 'NZW橊~]~ka&&]q'u⴩b :SRVw\\eS31-"թ:qٓ )Ԓx岸Oy ʺW%ʒN5G?-ȾX3US*-'fxJ2~|~ذZW'IJ'yn2;nWY7|&Gu^Lu+K}wbU p?6OcP{9(5ªWwqt~XR7">R:;\j-%}:%^|ȯ=MHP|c9sJ6GqiU4Ԓ+kfZc}c` ʤkm["nk]6}Scp9sDU:pFQRwt~lڄN}tj2$8?^k~i*{yF|"+i]mjO<cihs{g[E}/جmmlI+Ss#M=mK:G2GvuˮT.*<O,&(lMKQǯkFq}q4mka)*`d g~'Ժ%NIsBVa#Gq2>C-r==+Do4w{jpRپpGxȫ ֽ |riN[5M?,41-zq]Tz*Վ0TՂɰqמ滹Jԗ+Z=Ʌ,{vgoϸצJ,sHԨpʶ<۞3{Ok{hIm.YXfTm9 23luT}qWO,K̖Ku2O#+W'˷jSG-6J#د̿31vZ*U5Z~GDjEQJQZOss`V6}Z(s7Ӕym ,2_03|ѱBy88(Myepe))E̹Ry.'dnc8Cd遑3$d*ەN0玍;uGws]y0rx~Mc')Sfя6B"+.pq5:] r*=&<X3sT}aӋH짊䦢P:,yY@FmfgRJnfUq7OV{+쐜y\aF)SWsP\JRHA;N{+ϭLQ'-V9-np֗|(.=kn~f/fSMcseNx##N1+J5sgj\sz%O rI{c5\1IWW[q3;ugcerBe[E⵴hyggv\էw:+B..vFzݙ\O[{>Y5JrI9S(]Jo6nCw)ƛTj5=zYc*d;z  F(v4?tFJ=;MN;n&{;9R8V7t* A2}knU++zեq" h GLT2Sت>nh^.8֍tƝ:tlkNh41q^<ߩ[SюF5Y-.'SpO5&..RWdClˊǚ^*RQ4}[Ibn:Tף.[cNgcɵ*e餢7I-tnۈ0N Ti_SXS6:]+FLMsqt .Oq5VRcNQ=];+VAY9==Z|Ҝ#ZWZz^Q*}{TƼnJIS7n4|] wy<)zg =g Ut5rEev,X^1~"5MRi.?/?77bmU¿^zrI-% ?J~JNhΦ_>_UסT9uGֽ .;˰˚oڽ^>[|zWB:rSsb!6o[o]83 2JȯzIInLӒ4.Om-,1WQr5#r_=^zm&nVf]B^kQiZC)wʗV^XX5hE!ٴv~A0 vErQzuj5bkki;.vo|t19>$ydC{JNuh?x![[gż8؅ަYIׯsJu}|I-?RX[Iy* >iʣC<650*ikSB.]bM4rnZ6\(A2幥;FKKo]Ym!X @^ռe=ԯ TpdYdv [1W뚹+[Ko 4U%VuH5)YWt\y[qz){s^:ta$_OSҧF$ǺSqp/n Wtds[J<:F> _:\ghZf#G sdぜ 8̪TU_#9%_@,7Jȑ3)F2)JTڿnJ8lvٙ+{#[X)[ 1ҮvrO :u* /{.=:Щ(ѧ̽oeo,e_.$įTmg]H:t]מzUG F~vwׂ|lUᶨŽǎN M3AԔeB<Ǩ]N֐S st i -I˔&7i1ןݬ{H]+ d9 _0F4vQrv79|sҹ1XyJR[+QRR[ZjFncFUg8{;SJO/F`+Fe`6^UxQN1[)Udݘ (qQ^/Ǘ6*~0Lִ|3'܎]KVzЕMS[si'̘2,f$9E*5K] .]y=,Z"7˝}iN5RvI5ʙ3WVW܏#is>B&+V,vjn1Ѐ}GJs9MMNT&ͿZzX\d<vcNґU#d/=\/[PSnx1Y֩LMԨݥLu{[iGfªϵrΛFVt(j6*n`{¹*X<Хy}K~𴖫UM8?2lzc=]:~MꌠdEie8.C7EfTTB-z5j(icBM6Ic7q\*0j_yLDijڳKBw(rSr(>]dj ump [=םS% -NEI%]-M.ٞ&.yUoN#En1+>rE!$¶( q5R28b]ͽ";2ylW:3Y$V,VWloM*-X ڹg6nsQi=?ZM?2ޥ9I?J>k5MA+gG#:|ӗOS=?UV&55t{CduvO&+OҎ:8hkuk?3^A)4ۭ.(E@g`7;'=y=qR3᳚:2ӭ>6QMyWS<c#F'/4e:ܮҖuAC7"MtŹʞv'r}{-T2XꘊǕg>xA&mbi[*U~l яA]q.ֵUٳfԔRosǨ9F߼@ $ ,41QuhUF>Nm\\ռy|pSźlmC4!_%[ >av㦦W-og5wd֛]P_x[E\k7zEm2P D xGJ}(it2b墾~ڻHeO^M/-FkPFFG9(֓{|<ʟ5e~ϢO? +U.fUbfgT\Qܟ͝)').שM'\6״Gkn!S3Yrjs_x]:t#*UUJM|-}|T**nRv];okxúmn!h_sPuY̶}:_Z-K[K^E}vòim-;&˾ݷĄTHk^"4}|'🀬u(4xVOa2#@*6qQs}`JZ]:+cxu[~U'1gХ9FQ[|Vj}v3߼)v8lCw,>[· P\։.I[UӧZJQ}>QZMd6lel%NW߁^?c5|jp)(s+=`}7PjBѻuPJD=^]|o:hQi埘yL1X\?sOcG-H4鹉݀#a^F#N2pc#JX~/[E3x[9ݕ<'ӏ5p2uS}C)?fӯkxo_fG+('~ ueg8өQJIx U#c627sۥcZ߯FhJھݎ'Ğeo8~Uxekю*KdZa_ Mwq4M:uF=Pc 3秽vaRXM`kKQsSuYߥe}M+9e$,r.J%\u?^mVvQ^Vx."o}+XtCZ(}}7=j8gFODןb?hvcFR8)8eKCJX[zlݎ>ZiN1Qh:+L%_-[fN)*XnW~]Z, t庙~os]2*x1~ڢTWxfΥ|U:N}+<47Izu;-*{lt+2{~+˭Ox(UUv芶I4/Hŋ`Al08):sk-:~Lg=/O/_-DMQso.>&nXI9$1_'bm.ZYZ)57l d&-q׾q_R2uhb%/S=V4Ԛvkۻo"dl@8ퟧ\RJʛjtK4}{yv:Iѣ 8Zkj6q{srVihqT;8{7K.9C|#?y?#y|刔뾽} *ݷӡZK}>tVK`(Ul.3vWS߱ZXR撵,gov"n$c^<w8_RLTckR+3q_:D&QkkbM`6ɴR.c%F?dV&VRfUأpdsY}%>$_uLR f|F}q|ߧOR&z/ٯV]EwKF+ ~5GۿSSJ.*M/&D\]Y muԂ֮ _#9F[t(/6cvdQ_xʤ9/ft}\)w3.5QoiU̞J@8ahcRQz7L+b(w8oLzCζ+ORvo(QRU$bS4׾ʥaAEdȮʘ<gOU*8jײŸk7??</s~c l{8$t1UJ𾶺m|/X< *&{DizZ㯆Eլ&qn. K"U%Q%1e[E($z;uV<F$w\Ip  zc R)Jϣytdo]^5}SR6hI#Όo;N22;`|f%gڞn"%kS{w^W:>.Yh.{3Ie/VVg;[qǯzʶeN_ua^ﾞg?ߋ *=nhUoC e֕;φ*cϲC0nqJ,+qt&[ѭaKUhk+o "*way[xS#ܿFG*Խ_I_/_ H`[!`cwFG]tCt+F~(|i]KLII27D3%o,5\=*_O3SEݿ#˩ P1+¨qc+ʩ.ﯞ*c'*m&c]r.GڗQ/?n*F+H.=m9:wtCexsoknIjF1'iV$iV\=OkJM-J K^?G[,hߴƂqm6啺&D,~b`x'= &_)s;OM?2SMmzۿ~> /s\kvBC4sH"(Lx95t:Os2֣QBn+][MZߩ,†/ i9lu0rq}:ym<]d4qMқno]ާ]|Ipu+:*ten0BqϦ>h({l%*2^+[BiZk zgrABQJhkqDlkhv>)[dZ׷^S!ې2w1d8J讯xURUE{?XWB&b5aF?|k{i۷WE8+Kh t/,^n*hTUi%Օn,irجeMNrF`|Uylpy+oyQK>}Y6R'ǣVԪk~G^uii>\nl_{zcixztc3ieipZ c++Ծژjm`xTa|cw+'##zh([k׹P`[ٷٞS}\ +f^(ٺV*Fru7t7e[v m:tIaS)+= %7GZ={RL-foAmZ&I-a6ݖW*ɦסJWM*C7d`ǁ u]1;fEQ;/w:Ƌ: fݨ"G${vZJ'v:4VRm/{^Yui`Uh7[Ͻ$Qi#Pew`8'kB ||PN맯MKOwƻA''w![:ͣhE/"Yn ʯX[ן^ވ#+.劥KFrK/ ]Fl~ܳl @ gFhҒrw+[<;u7ʇsrN@ҩZ2{ _o#rK6B1l{6p%oxKңbFK}-k'͋]yh:_Gs.NCQx 4˺ӿ1h.C3 NS9 1ӝ^*/ߩM*I  7g;=}YQ%YJr6[j[Yefj sO|\;A|\#&7p!INJz~x8o٣^²;bӬfft 1Vj9J/t#,B 2\(#'1ΩF5%-z6ʋ~nTT֧N][Ԋ%s~6WxETgNRWKRx[",od.8i8aZQ1ƊUr_CoK/ojZ#rآ4%,sn "׌^kJ'NPq*^RЪƌq8~ṇRqVxnmv+, ڱff0S~&wN"1ߓW͆ eHmǶH+hF~y[t+^H6%ofN^+u)mնfa I2rJ^UVتR'QOCE뭷0o{yçi3LGc03t(ӔۡҊn2/&VHm( R8R821_Xޚ_?r֠$GnTc梾Ùs^Ϻey!X8 [9<k?\ c*Νݕز$۷mÞNOS|JN W܂amQ=UMǙ*~W}۾ nctRX.,OؚQ#jtWIv[4gL7\TSta|n\"h29>M*q9Jڷ^CHbX#'#JKXsQ{$Gm^_j*N Y# c'ׂ}}+ t_7ı4JNs cAM~ҧo?|^*-I$gÏimn$`RI7=騺>`6V蛕z+.nYrҽkKhBjd]كS ʷyS0X,Bd}&,J8??*)TG-{yp%ݖ3?\QR)kt}g(]f3q"+-r{J3Sӹ!mc34ozR9z%đ̋npr3^>Q"f +Nepq}+.tdMJ_{otJ.!m7q]OSNZRݮO+ŒY+aUrrkϦQTHv˷GU>jzUI9+X  $~fy$j񓞿S](˙Jz܇pce-ֻ!)Xu\bic͎OZqu"J}>GrFHw){fZiKZW7,uݖ _q͆{43&2FZ34߾+70ONOK迫du[7:ݓ3*}9o{>狨25{vDq1( "6;w=FLߵiV5݌{}?rFQmES4쭶b n4dgQ1}~]Qi{K#f?AjԩJ#KWZ؎YJ0oc>ץwƤHӼVEY ?{c8\N;]41*Z5̥srUmfl|1nr=xbOmN6#> xɮ2z}~lB﫹MuG%NWCs[F[KR,ywFJZL9j~*ҵ?ԨK6Ϸ^JPf4hGb jpzJ7N:1QJi婏yJ1]wǧJN̩M~n3 og58b'%tcMvViR6bzOz>-j^*!%|ۺ}񌕙RTVwUeXp8/+jgi86P5WV?Cv?0N7-FW=XBcO[[{#2H|NIRg/,&*84>Vi]t^2?^F[_ZԬ퉋dH*o+ UFF@<{#e),ߵ}n=;:9ˬynik~|cjЉ5R+*28ҝJuoug7Rf^ݏ<xZ$6> Kqj!R!Ջc9ܹ~W *jC[CU(SKFKnzm1^k4D1dX;Js ]ԱUkrI-?[XeRʹ%m:-:[^H~ia <ݮ pT9 ;&oMY2*m}Uﾏv|_O{{V3K23Z䒁'*w!e|EIO^̺.kaMڣ{vkK.d+t])iXI,챑o(x#,g8zXЋK^v# 3jI{I_mk▌5?Yk[52 9>6xG ~,xY>ӥW87to$W*_]毿o?bYOU׫z6+j:Lc䕙e`;H8=0If|J(^)6j(S=p9zį7F9t gךt)}X5q+nUw$~{sBn*I4{O[iGi%휡hn&c#*Rz]LD\v%5֖uHV%bvS##zW+K_0NRR鹱c".S[zqeiGVϷ~+TJ1q۽[:V*>i. S)eCHiO͜g m>J9]Z՗4g~X/6q{˫oM?pX?$\ދbw ´XX#ۼ^mS)+֧U-]=[j~՗u>>+oBXmǎ1q9^/TJn{T-:*Sh&[xY;9^ KXE?K8z4[ῊuMq&Bjp6,bymhoyuq4R5֗φw8ZܗMNcP丒 5uVfT}NGiEE.WcGMئ3pPK 8ΛyXsGCkƾĩjTÒp2y=~#̭%tw+XwJR[Դxc( J\p|vEsC} =`+~ mq_Ur# ]Fc{5xY,lF&w߃>L,gRmY?i p%v+Odc>߁}[\t}Yn}V>zgkq.gzcيݻmn$':rړ]{-5#JXe6{6tvHѳ"mpH=}ڳ˖Snii'n]ͫO# sIcVIa\T:7_Zg\dO6H'-8^n"#e5a˖.߾x[lUG#sr{0Mx0iSjR||L-/Z"<wnep#_^Vǖju#MWJK%, ^E+~c$qPcQqzFٲ%ܐʤ@`søSZ60R[fr䐪  q\v5VeS=RZ]Ia!kv&O9=޹FR},vG٪>,\2< W,*szTb&Ei]ctjkmPs1*ʮ+mln늉Ѭ7]Q# l|bL,2Ig,+֭OIont9W1o9ŕI> |ҲZB*A4VFP\E< +gq޺ ':gF\S4[jّ`Z$ uy8I+7]F5&{+3I=mFq)J4- kqG$2F0N?qXiǧN֡724rz5SWeRTAZG{}1'jyfqo){oĊm mY<1"4G f-#8buVjE(RdNU`q֜OHs 䚂k͵o7\lF=3rc2z.1EVX2rF<~Tٴ(صfj*id3 F'Jgʝ?]VÓc]FFTRp͸)Fϡ;9Qi۱M>Cko-u8ô`#׌c&HjCQʵݶ?a}[ZUqN\h^{co ڦAvz4n)D'w#*خet{Kzt= 1r9'ʞoMw n&T6fu&P1R+|61a4nu~CTJ0Oe+7goߩYWOmW7*Ҏr=A$W= SMlWݿɲ_,wצ /1h*!ʫn$mF[b)FOOgӍ9&y顿khlyK4r['=Ga^MHG]#\ncr}2Oy9JGy:,wmgFR^Mܛ#9=c)I^EE[+45 FN]YG=O_J^{[]_"-ZUS6*:UITg)ad{_'2+~ c6G>1qM;[>~\gu>O]x[.#DiQy 7c F'_^c=@4;Fe-kՎzT!^+x713AŤ-z1=ȥ*>Q:!FTr{Tӯ|sDK&FzG9UR.ɔyӸe<@>Z:qӞ{1q9I=z| ,fjH'%3WIǗ0RwЦʓP]Xӵv%,2츕r۾ev'ִuNne9ZXܬĨee1n|޺>[ԉY"Ud*xH9Ztl!hђ>lYhۓ-JvX{ݼ69#^dQdY.p{VZZ6▽H%1q"&:9ynu E+n`Ll_Ϊ)I4iF-NdN X㗝nޟAS%ԘF"WeG2'Y$ ɿv߈ESRGvd{W4vu5?J2潎0WW]M3'̬nH j+V)KVISn68UZbF3pMn DV^~zȭ)=*m'jb5e>9ZoQQm6Oc .S=eP5O'\M"Ut=zO*n]"DR)?j ǻ`GWE9sI1ͫVbpSr)`V5Fcwsr K9iGV?9kiX蒏-޶m}u (+9WLf+E)TmkͩojYWhPp}u)oj/v ԐM,w+A|pp9<{qZ{eO(odrd=xǿSD{\O̫s<HUW"Fo? QN:)#ymp՟y 9h;)J2 {g7yܼ? KCx}VP3>avgݸ11M-2*u#f˯I%wvX֭S̹]q뷡Myy_]AF1g5Y:(ӊRO&[٥q2N+ݨ_ R_FMnF^G9gEIFh)b#Y^?q]u&MWi򲑌tg"▟שR[jrjdm{zVd9]ݺGȊ2Cקi)oT9Q{ky/^ .7}1r\ֹR3dY<'׏^=+133 Ur{ךfEF9;v?Ne=_ʝzriwwQJ:I,Im3$x3q{lmOF⹛Nݭ.D{`Y8$ sè^v8Ti5ӱu,<2HDyA>ߟE8ZoC.EKE:|v*rb*FRRWFť̕GGO7Щ)ԊWКZOLOI1RV~$VU󴲍cX*rNZ]ˢN l'fdc8s{Oz /"iѕ:-tI'`{vK4rpJqJJ+N.ϯ@צrױLZf_Ilzum>8QRNUGIO=1,{Ǚv1צ2+׹/udvϑ )%O}z`5*sS__yYS 3*ě~UNR).sZN\Fu C"ǘϒ(\δKCcxV,%+OWL~{:"ՕL.mٽG0y説CON:t*Ѷpl"GoWs'yF,CKOޖhlf7W#z떥J3_KknY:6^GU ߧzI9Ya/zʚ]K0$c"͸/OLqڲ4(\Kۚ)*۹=k[ԭ*UneSVl.UP; |TrӔyeӼ۽ű˱AxTuhso>;Ka%m9R=WdޫfAs,DJ$HbywMKR hΫ|dk4T|EJ֋DgMm$py-Fel|98+T\tԢS^JDjM\<ƼѼNoCUa `W#8O\FVw(h+}}#!m+<Zȇ_3 yڲT3WSհ췵Qu@L(fb03c5u>[3g<\ch>%̉&IWn 8j ]ʕ{yoY_<}*aZU8u4\to]4H彑m˂BI-v9i0m%טO=rmI ?1jB*<҇]ǽݼ`F\g?RM#J:v1k,?]QC)TNc4wؖK*-Q a|y9aSY$AaM?vs^xaTtn,}fi' 9k,y(b?p ##ƺѣN.?_־6M#mjwKo媡l^cDeiXeWoW3Haᑀ$qz攪YصR~Lo ,IJlXN6z1_S5+N/+$h#Ja`3( N 94dȞ(y9;{:t;#2oUG1Һ!n7SŻY`gx\K7 |@yⶌ\%==Sr}khխͣR9ZQXcʼ?JSZV]PKy[dQnާ?O?Wyᵊ PX zVuW=(Ui{hr;aVgf (xc.G+F5)ԧU3S([9'3|{hӻܚ5! CTOs: {̎q =ϯ8RQwjK[Utk^0Xp9XTWsͩ#f"GlQ/=W,s6֗:se܊;V|@F͟H0{ڹkrٜ֕eZ },śsnl=Ec,EHJRtTST˽(HUlOa{W-j߽9ycNTבu1ʸ}AKE79b#IIRz:Zr)8ƪ/~G/3dxY`|>NjM$PJTF.HƜ̔ûfaH UE;UiQZgHq G;6#U8;͈tBi>JR<U[/"+Et᳃NZIJ&G>= n~!nf=Zs{H91Җ#ZF"yG2R[Ч0nU+xyo3ԗ%8+Aa =H>ei/Y%ZiI:+GΜ|\[l?WG?*:ڽ؋nڃљѭZ7N9QI$T`oMX=פcEOwQ鱥8J?qG摷vJ4emx붟hUoN>դ+B'>*:-;=|NM"OZXY#0 MMhJْg7j?%ҧ1(c#3֗4+'*8ifh[io9BvsI>=+֕S)TmYv^DK˟%(^־M,,_<:$fI#R۷| u+ݝoNI_oBƛk2GouqFU<W*nxehw6mˆa2sF2dA?:[ѩ=] OFONw[ Ӭ!>uOa]q~'~~ACk4m䷉1) 3V~wwOk'V.m_^4l/^l+1hCjNk'Ӥ$.$I3i^sǿ_7ln*IJ+綾&RqõٚLGG''NܚZTm~~Er*Z=f-=cG,T$dq0;ƺ#YJ]%yjFT"3t˃XVa6oGmoRկЪu)[7efkirMkn033MFǜFNǵuի%h]Z*vZZWym^vn܏ZSYEI?"Vow[ȢY:#:$zOA;Vz04E*4i%mk_a6sŤyn{;{ץVS skZ6r :D"Uk,©HL3cOsӍMsiu, %e`#߿ԩO߲kRV# u: `6v6G5ܐx ~έNy4ݵ}H{njߦeY*ͷc܌s\2ZۥbW_ZM3`~ܛ~Qդ^8q%r;E+=J «3Be'nN:*'&z\ƽz/kJkwwL6$W8Ӕ©5W^9{4 Mu5OVF(Ժ.ԭ'd8E|*([ʑyFu[YXa&~\0(kԏ/MWWK2Cl3O3ttVJic8zU(jY_q,!FǷ GPqun?YXiR1['=vWO\lKdfh]pˎjgӱ {eXY$Ͳ͞`' Ο.9sVhƾ`G,vӵ:Vrsxv8ٚ604q{JYv%pI#mKTt6ltfNrn9Ow7Jo9eRJf׊iZ*p䋵.E{dKI ^ݻJ#ZQͩ]" ~V,Kz>&n::kDEkE nSQ{kəGJ.[8 YkdZ"TɣRr7jZ>oEy?(МU:'Mn_y# kVX3d{p{v>ʴ[:p]9{Jnkv[hܱK.0G=0sz٩*bϮs'ewჭjxr4rC:pyT#[ݦuO0Em8Wz>,]6kWXR?Ӗ8hkK4# qS!zwc/߲MZFdF̒msI{mK#yTmFiǿLO€ r2\PM]]W:I/3~$0ME7M-!ܭr gZ.9ץJJ]uW_y x9<7:S~g*'`A#G'R+[٦]L.JSUdZ.ѵ[h7d w8(*T'GI[꭯]nq'RmKKu-u؊q=g+3Xr8lnp@ʳRu>Tr|0\VҾf*cpG\xqۙ>Uic=Rسf)㷇MI?ϵm#w+")Fu%fs0jZ{zMcRG'^aqKSڔhS$_C>C.-|,2>sN*Q1Qԓiv:kcif{4О̪)r㌍I-.ݶ*dbf7;sQb˲=jx4^8h,RɿzFu%FkΪ8Ҧ'=~}Z1$,[ l{zvSnmVѥ,SOu_h}nu{D߼U] V~6Ѧ21FSn1zQ*[O|2TۦCnS LU!u3]ocW;a -˵sڪae7=|՝u~rkP}Y;SːČv~UOc˫F8ZsXVOQTVS4vA+7:K.3GI]_KV5.q]8g5z ˇiH6.ٍTusStmΊ.YRV״hȆȄf<ʦ*V.e9[ +k FPwtc^LUSJ+fCc#ai-B U+K6j|]hzs_\c9T=d}l9UJ+f.2 J[NSY~Njo^e$L Jxu8;q֊$+r^#$hCBۣocy8s_{ޖ-4bk&I'xՕ8Bk.1sOhϟLu.Ԭ/mcĦVTYAr@<Ӓ?7xݏ|W rmog2.|Q 66#6mNCj*^~--ެ&[u2N!hܫg~o.h\P>lq^ ^+Qi9凭FӬU{ϋk^z"*OcPxfeRR}Ժ~|#jKnx {ؾqhT*< )TeNgoi-𡡒;6h7`sҥVEuUޅV*-eu"k2I[Cy#q}~*u= s>bzߙ*h!?̾#h Vr6I=jIӛ{uV;O~?VywdaTs9CVxjr*u1n.]l|j x%HN-KR=nh _M. IcŻr${0${W27^lpן-OFssh~*m~- sE g r#O95.Tc9S&xN:Rqr]yنBޞzjW>m~hl\-3F2{52[wGjN\==LK;hi13~aHz0s N41 QL=Ju+{ir>NO$ÉRqն;v>/jp8WJ)hcܩ5%ծo}:7-nbb4)8'5c(/*٭nZ578IZ/S [Zk,[_L5{!Uqa1O|I+o{}V*TTy';H|UZH#f%DΥԆFں=o~-]V&8yESwG@cm!ym;v<90qNrQv>WRJ4ӌwuv@ԯխttfT2:F{K/Z4ܥ}zAaM¬7m_uVfE+23I<ק+}== 3gMF0Ynkkv-̷7նq?|2g-m֧8IӧfQ9>==krW9avf,6JiTս/S陲ȳnOU>['O(u4l/2~_yG$U ڌv6IO,;zqF\S:Ms8iӒs׭FjsxA,,1,r2<{Vwʑ+u=^ȏmѶ['?*,njpєn5]F=nm*V_̨*;Bמ*q*1=ӷZZn3_UVxѤ[my32ciVTU<5H'F#i#8^ٯSRTdKUR~wM]i#5kcm5v! zuCZѧ'oum7S 7=7Rm(zݯ=$W-m_.8G9yB_|4ah]N,`5,hR^HeZTK"IramwnR+Cep!㱯8Y#Z=\vXKkCMl3h49\󯼣&<)8V&Ӵk{i Ed-l9WTT+TޫMoZ<8rA ;xϹD'35%II em8\zj?L 1l Jw~XC/QSZ_ց^nZ*y-ʯ&2O9G:(ƃFo4TU~~³NyMTQf?ِbBjjKs= 2a jKyq?YImN1^O|^ETw>V "_R׉>$ǡ1۷šʣr8kTc؈8-eQ"Z4s[O yefYQNВ?6z' ƒ]eTz[nȑ>(r7Da]gGiDJhZxI57P=q^jyuE^Q=>Z:paA_4;4M/NGm>v41 {wKߑO = AOHXMnǧ乪-5gՔGﯿ,IF diF@&VN sޥQ-Ϣ8fw6u_=Ƿ\w;hJ0J)ro_2I> -[sPZؒ-Amc՜icJ5js^/k#|I >ӓR,[KՑ4ƭ(*쿼$~vrEqRB.t zZF'!@#$պrTFlҵg\A;8݁`t)KbV+T: .[51t]t^f4NoR5ʒy ^t^#~Ugk,D(},wtˋ[.b>[\0ev0;*jAoKQ.-6߂xz }zXZ6/|fv0O|cWQFs~hsV3|_a5]*^5ob0szTpUܒk}-8(uվuۇCj/2FR%ɬN5Ԗ@ ?ZS=|^NmݢA:ZMۂqTVQV7F7f_3ۜk |K_˒CoȌrG2lyj?<3:s-!B|ܐA{tESԅ:qCḻ!Tc^k1Mg\fdZÚ6W1j̻pdy $˧j5/³g()Ccjg$~%G%4v>9Vq%koٔ[f<ͅU@ siZoqqoVVץ]!>Zl3~ JN|.*}cYF >jHvŻ8\zׁ'?i83OnsQ2eS4\-Sر Zmҿ"G< ӓMz#\;1TX]'#~JIY~et.x_p $1$f%\un.[Ub+YD~QAs){JQu,yo:܈c`}.In@[2+AjJ0Cb)JE_jzs^8;USE,pv>N2z}+6ʴԧou.@r3.ߑϚ⩽/).fКc1nhps۟tSwN|RpIQH嗝}F189jo,O=3ۚF6Ffbe-HV>.mQ\9{!o$o[8ws^CYTR܋h-T %sk啺3XϗIkrw29 u9U|#N{WDvcNU#&;HՄ!6^N?){HNSn }C-OԒV3Rv"F3y鶃cVRkԟFIEYs܁K)F܋I4~tR6 Ӛ|Ƶ)J܍f7J. c5uPK~;Q*Ԛʧ$Aw摨[+H8RQ=-԰LĞf猞خYJ?9諦9pX>nk hZ6,jr6r~oAڶ_jO>Q&@EedXXXߗZe¼lg#UOUVwQ"+m6q Hv>5qM|̽3gAyI&77:uS-^>T(jh(e˹3}2;֔)!5Qw2nohHYEZ& ʴHm8.+\A2ʭ<瞹 |j.Uk;iS;[fIrd #xFV]Z7JK%e̗% 1ڪ<~y\q߈=']YelsY$rx Oecȩj4Fe+Iţ8לVgARu+n䍗,8lsҕXjϠsB)=/Twi+,9X1U\ҴW]}J;w|юz9# SmV)ŶջC;y/ٔ`rs@\ڱseu(e`KvfOܬ.T$cRwrKq!U*tjw;{nT~Dp#)OU};d[;O)EȺNrĜ9#=+aZc>X ~K-d$J[]ͻ#[iF1g%|4ߡuX6һ`"ck^^ᬱg?f6XH6 Į,`b/VgW ue-z4O5ݭ& Nt#FŽecq6:x J4\VU>ݔgR/?7o}&mFڗCqv2l߼K O%(|ĽvOo(Uۑ梜RC[km}3MM@]Zt\I;er-*9n4PQ7%{vq~SsLU*n{K_^8c>]woIyNW 2NGGnۖ+kkoM6e-eJ|ޚ2`t?omnHc0#lnv $9 - uZ.zY]uO6*ֲ\kv]{F+˅ڦ4+eLqz漌v)VO^myY)Σ{k|XWx~-C]eRoiʍ$mڄ6 c$Zei¥ףw^OmNlaR*\Ue{]i򥾧187pYrA/6%xiZoܕ7(Xj;wf=Ox+xPᮕL){!Sb%6|3<[y-3krL| 7+2pTiPb+[ '&]I8ѫ=R{vw٣KRL/?ZG"=`C&GE$6ޟۈ[P-fVm5e>6-ZUT1 užeev^U}e/Fuo,;wMĠ+nQ8_)V愒wM-xw}ֵ>U =pQbFUZPӹ,E__Ծ8WŚ/ ߫beU9N\2YmLD=y|z}ټdp0y ^85`Cy'(l֚5:VM+Ŷʝ 'G>溣qӷ&NV; jze}{V ~JNQw}6Q咔M6<;Ӽ;yE"GqqyGS\iʷ_4NH*'gj44tΥj6qmt1u>,>\R"Z*)ԧRt|#owꖑQF<~I=AӡRf_OL:k[yi_\Zۻy嚟arx~K/o1(_vwjN4c^'s|<|dhn眳=1{MFϯC$W GdIpxwkXv_s3–۰0#b69XͣW C)ò'$ds?Zn&ڤz&Ekkk{.m Ay׭c*|ƣ'.ejwYnpwm?r4gga1xی7N8ӎ˛tdPRlgnܸDe+IHZM}NtWR|0Isl<כRQtG+aސ{Kwçy7#0ge跗rN=:G*v#Z;5sCJ0C4k vT`Jr0;k9JN[NZj}_E*kaFъ[~x#",s9.lϧ#JEZqx/cRlmbd@ŒFG(rd<;o$3^=n>SOpʟmHS\٠_3̐b뱰\~eI_2>gvi除syvx㯥ab7ߡ uGxF>}OҸZ1b:䧷\a0 %]kR1úZ붥"Icؿ3Vz:娥#VkR8*OBCG"7QO=W.Ƶjʚb̳lXby0oUr>i]!?i(RVI$To,a[{)IۡkSqMq8fV]iO 4%({49^)7qsӟrkOJʹou4N^p{ǘ6zn? 4Fd(>Ϫ}Ă9^0W+1kҎ*{+*In[;/ZF4`:zXbNU䕷zQ(ɤSsC`0my5U\8~N9I؝&pJnk)9攋VF ',ڬ6I5,T`TF[-H!\` xe:r*>V ;`_cɷOsu/|.GNY^"~Ϧ:#]OImj_祴7º4kOfHcill9ckJJRoݺM+צtpu+RwognNO{Ǿ𥜾9H2|W(=dYurmwCN+pR}}޻^|Sӥ-m`>߉3Z<>; )FQ^*z kJ59*/q\RR\jy΍48_`8: iZөRRz;DN\2!z3 O'99 u  Zm}QT-T,E$"L27~n'Va)_׃FP.W2οmkFL2C3,QJZVziR,(kp_'٦)q kadNsJ*L!uolRLs 3`9+L1qcu=?Oifbf >>u;^z?lվgHDzX0yb)ʴov~Fr,v䢟+cֿsŶؼ&D'6˸qϡ<<٢58gVTo ^O,%n,m݁#Bѫ)cW8 N*cV~ͶW=~_{T$ ,)+Gc?CUvO=GS݉RHbWX4ܠ~ncc[¤^Μ ?̎ݒ2cvwm%T'VRc]Hm`h5n]~*is{Oԏ*ON؉cɕxʦH|'tJtt/gCYTXYe,x5ihS| uf*Iae)cL+IVTR9J)CDŽ+FE3Oo|UZ<am$zq*wyΫkZwog̳1}y8xhz1k.ޤ$]]_vzzs]F݋^>ϗu/%Үg Nyz؉S3NZ/gوXFvX|dN{J&Veyh=y{єes2oacΑq s#$0sɯK"1~V?sZBg﹨߿ȶLv3/+9s vbJϘ!A~<хBI3aO^qߟV%4b!Xd3$Waub0+F*n*;-Ye$Ooz|vUK^I%MGUvp$ %S1Sz2UрBuO)4ޛ\fYv6Փ'k\Fsb=wӣ+,;E*~Nl YJ3#Ư:O bu>vxk\Z m[E̪'ǩLVI&G`嘵J+Gsc._u \i({Ao;yPGCR\#PmS:n^+W3Թ/ݑH%*NC`OZjrdB5)9^I&3\)V.R[lC"ܰ\,(Y| 8# >T][S1VD TӜ :B U\h:kȰFJOCyJQZmݷA냻*5]Lc'T9&xLWF8Lɴ0ֵ抎Q{;MJНeCmU,ͻb;~4>:gV+vK+ʀ,q.8߂x8'EusSs8R$!YKw(nw#5çZ"L/!̛W-Aa FZr#oLu[_O~uQ-ȣ"ڽuJ̳ IPy\_=nWvk*[]͞&lmB;ĪF)˩R%}3|qmh_N?8Vvv&U)$~nآ;|:bV-sF=R;VT !TƎ:kݳo)K= |̹fD(^ǯ8K7N59d&S 4ֳ*"wn=YZ''vJQuܾE}82DѺPB<ӿEFUk:*y:YȈ7+ pFFmV8)'2R^ N܃rY^3my]( u=pycR[Mkeї=7;#Wxzo/#9{yU9K۬Dbj L Fr:W\_1Wzic+Uh18~}hΤknLkJ.ю R-pFUR]Е:vcY:37Iξ[e0y_o\+|[RqPѭ ff1UcA|uN*Jڝrbٓ[ٵ2B;UR\5kF.)s>9ˈd}?ͅ=rzv{kH~:޷d#mec;p+x{YIk[o"OmQvG%hZPܝs3MAWZazKKM;%!I('SZ#N]_CF.o*BmFt^ԮGmJu:{Zcs|`mלWwNYE/Nu.U[s=9tv{jiߡ-]f-{:]9%V/;=$dB_?{fjJmv;MY;qMy51笒gU9 ߟb+۹(5_Usv'޽R-lX%^nDjiW{%>ZB!R#@Ln9De*'kN4m LĿ9|7L{W޷.–iT~,}&EJ[GriE䢬jrhV}922$b|38UJ%*ҳZ.udž[ӲVe㑓剌 u){oǺѮ/ͼ~LreK\/NzN=jpSq\ԴHfo2[~/jS}~q:9%vs1h ~lG9#NU&Z-e*v]Jey~wňu6pI^]K+9ul~K+K/g J(ђ>sG':u**j;uS(۷ZrJRю4c/y2H&i)%rGcZᦕvT&TgsGVm&ݯ$iw{=~mGqWO Z4NXT՟sr}^USI4ܖ;Xp3h8voF-*ynI򣌎3:r:k0)>D:Qӡa$&&!a1BN1 'ZhUԧ(4z˨B^fO=r;UХ/l^*C]i], N#ʷ%6ܻT.=s]5僅Yryv^CkxyzHco,rzø]bQNUUv셤3n7(98)uB:z=}{QΥMt To\mBYY*I99xc(ݿԭQ)}ꗱD ѫ \Nդ%SLD=.F絻K _>_rzW~~FU2\i\r}]4=[nH<.6C1X8IS6(I8&|mi,siUjI]ԩjAu/"@>RዩG7Rj+Jf#Fq::j^gRNnx=;2ͤjt(~ezFZYFu*[mokxE$ ')UR0sj5'{Ѭ"X~i8xخ\*ǖڦRQm;H`vJ5#cmnHUGm$X_U*= %RVo<؀"#n ~],Ƒ2 I2y*1mHY9b;QVb088I:lsԟ-FnĈ:`|U̴܉^Z{y|;^津/Rc>).VlaJn}Nz*r}L)ʛ\}xˏj8X֓G4-4!j(1b9g bL۷ctD^nF>d7̥[v֔'RkQl%^z|?E2J$8TKFK2+iDtgb$c4rQ\Ӻ;?oq=iMIk6@1ȸS;^:.Pr!3noq󨔥{̹%Swj1`[Q9jJZm6Bncp#v999=:fyevƔЭ,eiTe]JC1VU7v#ן(i3u#(FE)UHss׌WRiQr_9Z\ʪF#װU\'oNJۡJKVXeGey:cѵE.Vi&]lF`cf},A?ʺeӌ]l:[#VF1U 8SN/oz1Q駠١%"EUU99<{Vr~wKOS\E>J~Y"02CnPۜq+H֏:GK9mL[I6 8_Si^I9Ũf4U_9J,c qyEOTRUVg.}T+ oMZ4eg5NImu{=%D369֓+6"6W20NpJu=՞gh̚([O>ۤ`݆>*{IE[ѧvvHu_>iQvFxjcr~[5tjaZqZvw Y G\=LcΜj`=]]ṟxvp,guF/5֦WImr( 0ִIJ6:90Ӣ]R)&(( j8<=/:(ƅM"%7VHp˜qlV~>BU}{ydURiE9_m(1m"dvYw1W =O7cldkY[Oiv͓o;^LH((hՔOQ$ 9jR~/֕TtIfj|kzk*)!fw(f/튚KUxl[ⰑUV[?78w5Jls˓$fjЃ˿$l_y9)]CO4vS^7~e=gˇiZ2AQ)J2WziʝnL"ŖG\3y,۳g v:5+(k]\8?/I+_ M&՟A6 GVTWq+U%zX儫F-=}LFfb4ۼͬ;J5%9mNU:IۯV[o1^t_֬^/fܣ|/DNfVjƅwp@:qhm T孺grۤRcxԌc+LԒmSV1e՗IcU'pl⣅r&c[r֔%6ņe{uooo|bb*Ilc𫔧R\OgSMc^P RgYTre4'V BF%*m5f΋lzh8өR!H8vi:m5siKovlz}{qŻj]I;w9hՌ*1a+\޶NS:U9s]nۜ# Z:S9TjZ_x/He gsh.YƾZ'h&=$]M?Y[kJ )F4uZf>a|\/g#|NkQф!fNJ&h9V]$6kǖ6[_MyR2zsYTZKs\픏׿a*RЄ:iutڻ† בR*|Ee: 2UR);N;uJn@m*$5JU4|DhZ$;aAxY]QiйaY_KHەmSl:U'F4qou4[渗t&e`({+ vc KGgMgʷq3H89sU){hTi,CtWVp&h; q^خiNr|SOSYO5ܞL[w+.m݀FG9T?SibF+ZoԟPvᣍ m''545woIU徆%ݓ}c}3[8=]<عET? }Ke,р`n9ϥ\1R}:-F:kXPҚ:I ~ƬcQslKXzq_+w,qW v́ȮԂOwyGFRSϧ|Pܒd1Wʅ ) z,< VڞM5UߓO>ŧn%][. d2{ V^➚?&n>&( Kvx./k}lWRcc~NoRd_zNOC$,vW[eFIV#F>51Q-HO-2h73ֺ)£Vf/^3C㩤BH9^]Xw&^>8d1J5$^tlr}U>hBu:ߺ\ݧRs\JsΤɖbmc5ҩ[ڝir& V,q}Hl)_r|w3xөD }~fo֮9hL$Rw}tTFz{vB4#A YbWc0ʹ@,hfc,w#nBi*n5w?pSvl.A5q4ӒQW}LctfV++aV%\m*(+礧处3F>f2xS.j~g^J&lӴ'A}j#v1FRӭw1@ίՊhʁpO =EI)EP'ImnHژIV3q XʏT瓌t洧Z1ø^׿͝S)'kEIՕ@Okmή}hmNhRz_s);yQOi[6b4c p/#t=:?z{ҍjRu#a/V5ОG?/\0q׬J14XӊK^'enTHL3 rߕB{F iQ%8=Y+? ` cNִ_GZUuDdq-![VJqլe"Q6f_z~d%x+GdsJy[D֢G]X]*c39qQ^p.Z0ʹa(i?SUqkƛzYhiv UekR3T#$guor٬ɗgt& cyѭHҒ5Loo+Do TTC"1~:hcJ+J3yp<l§drTef}I0edlOjvӮ*V]<&-#̊V7ym5R]yȸϕQAƤh|߀\?[ 'g풗-_,Eq$.(nVv*}1V֤ӂt'nP|qFzp@SvNQSrjWPs"ۄgx}H?ʽZhz%He8K}J?qҽ tac4NMV썄[vSQQIncBcU$֎Z8hV"\G4| N>uK2rѕY}̩ckx>랥 -o)Q38gBXkwo$Q8\湩aj{E%GsJIlF7@ocnR˺5Jv$О^l=ǮEoknF' 6ۙ  IۂNYZ9]Ԏ<;gᮤ$3o=W wckF\MJ?cKȲ[BZ+_ׁxފrQ[}9T De9Gs}V–3Xw6Է٨M``@7;)ӣR,^nirDקIL)ft#ZҫRיqe Mrt'I<[ #MlfٵgO<;]-NGƻ^ktSaNVy i9gl1(Jt8UZ켌(܄^rJHu@U\ma?kFgYsVӣJ^İj0ʷw/ NO}gM/MM.K)pP999=}3I:1U Cyo䍝'^ze͛o\W7 kYYXg sۦ;chӧ̬66׌_5Em_C>ŤjKnYC+?d:z ,CZ֖"׺Wv5G`bM\fq >ZҽmU"יNKZ|EcEd 9$sTы3kцy;YꞮ'C=̓RmH=ҸS+[_ˈSˆi>nU}|~J;AmT=RGǾ&ѼrܲB ds=y`xkSߥ)*q6/j1Z4I+snqcˆ?mSyԳ.MVCF̻dܤ`o^Qowk*Vg; n#ӭ.t6$R| c@1eT?k-ߡU(՗U-!8m!H<*־4m+BS9+gffL<*ERޚr+}FZLfg|nI]# Nftvܹ/Lծ^[emr̬TryֽXSqK֣wӾҩ9$sjY6Z\Җ":vnB_4{Ii۴?/ֳu-v30?c JэHE< U n觍T8۽97[xG^ 4 K9~jEfT H~wPaqJԣkfz1X|vrϳiSScsyHHqb(<_K$Ia%*iֿ<fkvxSTTy<]B1cSU!w}yW\&U;8?TFwzO UIZ,Wk7R3\sgO#Zfft}?CU*jN߃Frc%F4z'V/ $6@H:SEӛGu?WJ+d}bhxJ"·d.H#yl `d {;0է*qzN׻;KԴuḡ yl;IG4SRRZ&#RT}Usw:.[CĞrE_ ``]U1QQϖ+|6eoeS?h d7˴kExєha\[6}jNS 忩ioD/-o:q_aqXimu4Vej˹h9tx c89uҕnWoUayӗ*w#&ӡ[QT3bQmY%{[uG`b*8RZ[Kk_>Iυ'Et[6Ef/29S8(_5ZY[]{Y_ѯ;&{k}{^X_'m8_ G/~پϯ}j٫ۿzt[;rn#-Oyg9&*8_bܥmW^o5=\-kv>*7|Z~uc4;_9N";%Z8^:RLjD #op~bs^f"2T!gPGS 9ֻ|C{c\Д&k{K6NysQm1ye[kZTT"yiURxd}VK8TࡇpkXZE̚{?n8y'.j|5$>!]>嶳qֹTx;3ԌN/>=ڍ"K_S<Cz;I~>)NRs|=+kRвxwܧN4}[<؊\]MܲN|.p1sӕ8ߑeB5[ۯc7RLPfaHس19PJ)aϧm kBRK|#R8}yk?>-Q#] NOZpz)]QŒ oo&9o1'k+33quu*TkZv]ZofuSVymqʴi:!-e]̫08 d.0}KS7׿5KZ2hu8z|K+=:0)JTllR-!`r1Z:_D|״Kfn!sj3x=G\R/mN|g  "*{ FX,FUf=>+F;54Ļvߘ(%UGkiJ:QHR8;|Ź>Tm(*p\1&\dI$|n,SƦ]-*n|Ƌ2p^hA9yd)CU@Et^[ZAFQ%ycO1IaY` ?-I{yBxYUNnۿ5VʒX̉␶T:^Ugdq#Yj7%͌4=B\a` ,OhӴ^^:(|RE$`^Oe:hiSrX r[9nP;SO埱V2SkU{-nYu*03 x?Llv{YŲlIq941 wA er'@kx6<,5.ib m|Xqq1&|UHKCڧslGwWdcB,w}_bsoĒ*?.ytOyeNbՔj#{aG˻?wiʒߡ+S7]QSݏZKo 3MR0p?*NC 3''װ\Fݒ|ė>NQu3ʤUvgܴ6tV>nU=}F?\ө:v+F^[Ub`G+m ۑ=tJ+%>co} )Ws4+ֱ^U"'Ӯ0g>fMʞx V^5Tg-tmu[ l3';Oʠ#݇\NJ-m4خ4!XuA=vˣ$=%R^v3|STO[nv[fфGڲ*#6̓p8W:N|jUN|m6eG*ӚJ zw Xqo3ͱHXwm%@ڦenŨđyMsb"䗼F2gbhc…QQRc鄤EI,<"-I8Rrɷ-Μy\n*H9׿^JQnס<&NEy3Fۓ׿6ui*OMntEU]d^W\\4"Jn2Sf8s$stG/$.錒M.[﷿oJ\ȒfH䍚f|X`=mJ} \tRGcqČԞ=E'STKWмI X*㏯mMƜߡiY_Bi1Ue9̦gH>Ufn=:0?su9Pȓ}Ԇ5.(,; #(v9172~1ʲ=_bTD1HUZ5 c$8'h$u96>~"tHGE"/ެUR9Ǫ>('RR,,Kܞ9TT&ս(J"6T`۹`G2[*3n2 $@N J v2tA$B5s3r0ƕ՚m;fHi{pw+zrFzqK2gڵSGmtrI͜z=(eg-9G! HѼXʠ^Hdc<EiTP'#A 2Bq'Һ#J =ZrpSp s&q9:PUOJ.mԢۖMȠ~?.Z.hѕI8[ Cw ?2H8v\MT\#-i٧}0nLpepG/9ӯuFNt*I4MTVi>̽\H]=J8b!'n^]cVCq=ZNv.<TBȮRo>^ڴJ2tP}tDufYZM}*4龆*G#8飓'S33?Ҵ#NѼZUq7J<{ҫNWۜreR<,).qߠۥ)rԊ:QjI-, 5ŭ[-I/3& .F=Vt*4өS[ork~}qb]`sEӚ N wq֚N%gVUa\Qs߭Ɯyӓ%w !Ļ|V-לzZ|Pj~EJ25NipZXIrцe{}\)b8-aVS9֨Ϫ[^m$m)EmEsE:)JnCTԖ"ѣNI ߶s#.VWG3jF"j7fU+fX=~gҷ,W9R8DvV'^S*tvgUI:mnGdz,pU"Q3)P{rkbF\O2M6|ZBdcv{ΚPV*wNM峱v sy&5MhpI25&,z좗2iTNggׯ!1r1]rozCVa'g۩^iBG3˹)O' t6G,ԩu8g܎Le:х6ԋ%MlZfqX>w|k/xӂ&E]v#5SI(KΜqREJq2 7Ak>[R׷Ui2E:4G/S.p9. FIKOS>i.v"ӻ*JJ17;E#mw$(JeԧRUeq|>׬bM4,7. wV 9 qRc&I;Zni_M_)f4}%wѽ7t߇O᮹qk5O|0|W j^I4k=_޻n~JTeM҅xFIfV[eo)wi+ѕg˃Ѹ_ =l=ђjNZ6KoZ!֗W}5pH͸gR:緩zl Ro84XARoҳ[s |FLshzfKUguVqR|@ls2T)V[8|&cSUmՖ:ok>,|Lj|?sj:>»KZȲ/cNm}u]{1^ʬ\[Z^{Ϧ'In([Zo&X 1t9]tԡzusLVZvI&՝7n? o$~ j}5?Ab +1빉tXx?aیZ:i.] TRQIuZkMmo-w=S⿈5ixKA֡vi<&e 9\`GGҧB~֢k˿s eW]V|w]7~} U[eX (qgku=6ϧۼK ÐX=yn:rr+:mIn/Kٽm=Xe头Qy퐶ў OO\^dc̭'cǕ$>#k@簺[ږ6 ʓcTpVOWn_S˭eTϋ.-cInv#w͜RjMMw} NI+u[骶V}n~%~#jiz\BkԘ&gMqP<$Va_H׿gk-{ۿجNaF2R徑k߳{ؚY^M%ecn~c_ F6~nl5!O?=N"'o$. ݂s?TjN*)Tס9/"K[G8 zȢQ]ގz~Y3CޮZE+ l ]I;=;VR&o䎘gy=Gwcb"ȱ㒻yƈөQ:浛#icSvj9*3Tu%|3Qk ZƶD r6];kRwC4>C,rJh xauS˛d=֧RYO#| d…A^MjQ 5ϩұq)&*/dl]љQVl r3±rRԭ)5Jg8t+[CgN_Veȏ Fѩ- ⷍ>rZkB%㑆 nsxvB4覆o Լ6>T1+XMmGMC&70D3*ɸ;`qRmi7) վnZ֞4C]+,C(mcfNxҪ*N/2)FV闭~i%[weh~yCO=x#+Gʹ㬔[ș8$ke8=vxTTEiǝ=|g$МrG?Q%m=K*/Qup>G,ENWwqt3W>%!el7w<{l|'3_Ehd} U*ѵ5zsg,#v@<Jm(u0Em;owbVGM򜎣\1M,q\խdgzѷnGM}f5?3~IÌS{``qt;Ts+3ڍ`^{r9t^:.ؤW\|w3ԣ>c*vu.3wwJ1ƫ^\G JroQ9J;rR76$n#*V~+FOX&#vv x\"T_!^k!\c,[ oQZtrZ @Z8$3~vXˌS䓋/TUH64'jcw44RvIo\&v%(^}oeEbkx.>gmnkJp*dⴒ&~IX|{AJ2΄PG,+#n TΪtӔ\[nڦ\[Gl'op{cqU?ujTKH*3$ϖAc=ޔo#,vRw~Cx;\TngVDgLٟ]ͫ*P!&[V,*OZ٩3HQ:nF±a7`}OZRi9K[!#.˼mq^DS\yI$3dfl3?R悻7S" [r^OJML3ʣ}<gFVfޙQFAF3޺c(YmӨYGDR!ݟ$Xr_gtPET\rqAq۟V0M9:X_n c*_Z*6G27c0vVT'?_AG(*̺2{v q<v+9'>GY?Ntʴy%żNpY]2y4REN=4#Y Z>2Aیקqfzbd-Ʃi*B4Y^/"kn]눥PX(?H8=)´- .!c$(<\yЎ;/t^4u*G"grNz=myb[|`ۈ8ftFv(u,1&78Lk5ޝEUٿw]L^-M4nd̊Iel#ǥvQ;|tjJm bgUN+8|:R:)֔]i,RC6ݮFylqFO};++5lsz.(dz 㜟ףN*{r,/{8]$~ZCІ\<=+~UzYJ+~]tC"0iNAF1b+mw*ܵ[I7{fh+jj`#tg<|}[IźJ)իt]ۢ1{>^Zn{d ;Dw/ ?ֹ*Fck˩*;,V9e3Xx>(Ԩ%+%:ҌEaU7ӭx: 3åEu??;ށ2ԕ/LZ+IG^SvާkA 6c88>|~,/亝Fe, s3y yoGՂ lWɓn)S}GhƏ՞7=M{wc$ݲ9SX{i-JRSI: XT;Fc##yX{$BN?*^۰m̱=w7_+Cc:Pj4>o%7vgoOӞ:Re*iN)N\n',T2؞?)N<}^RKQeY[tR@a sYSc%\*hS)ͣKq!&E {m)TV^{"THe>hʺ}9=S-)X𻳝9kkN̩-rJaq{d},Sde ΖLtxVO\6>Z*fN4ӊvZ_ƛO-sm]NcR6\#9F !ݜ{XrVNefև9yhkg7p;ֱeeKTy2wo382qnUIrGN1.o2d|Vn2LY8RtT;=kH§nDbhuU*=+XQ{RqibEgS+sg ?:{lŬ1$g+M{>TRﯚ:Kk`$gsǵ##9'F=S˪z7!M{M m*IH3K`>Ɯj]|Ε tF}5̢8s)p?ũjr:LUj_V#n i&̐AGusCɎ0"#m4q}q4Qv_eeRrk[7OE^cT0=nA\Z5T1*ۣ]=ZǽUV-drUOٺ_RTmSBΛER>p1T#̖]8Ɵ<%6t?{ncD`FUaAinߙSRz:];“B<͙/܃YRqw14-(RLDdrё<*n|K8qMJTm5#ܓjuE>[k2ʿ{<#w*Ϛв"J59ZVoZ<g C`+ovGo\(FM*t[QW] 6'H07_\gpr_#4~mo%JDz3zWNi5cx(Nk<TenY?^%NЩFzy"H_Q\u*{HI}j~hz 3?5UrH4SF4Jr~α7-BVM8?Շs.Cmy>R6ktEJGsŊLF2j[V-A Ql*sxϿ\TWH 3r̬vyNy#nq ԢhZ0#?@ֺնD̖8Dcc!=~e̬Ly]1I$GݰVƥIџ,zv3gb_ֺbe~}ޥHôs$kN[kVtEV0t{qjFI3m=uq# %*#?=ڒQkTm|F3&*Q:kXѥXjڬs$o隨0J\<9}UHZzJ>yuk4Ev09u2,Y{YMKh6Ü4XnzS/{˧sOgN2\UQt4oH|::c\Nm5!w1UHF %?;!Y\yF-M)M$~QÕ-Gc4*Q־DK v\q15?zJƍ9KK^]Hf_Hw.O׏q(җROO,Q[y.lUdRZr%;kا4*4YUOW?S\׹Ttgpo?#cp98XVOFSR=VeYRM䎝Δg$ޖG>*54{Wuo5FD'^4OOiwnFJ$Fq dO c*r^=S"<ַY &[&z! ʌI+QN4GTG BM97{v-  S"{}E[ 9Eg-4n/\8ߍaR2N8Sح+>#Z;{3+ߦăs<%o-w<>I.TjETM[Xi^eRIսAzY{k/ Os$;4Y~b#rf9 oUJ.IVsvV8 NxF1pA{5gNkuQ{-WK0 pm7Fn'7^f!TPtNe|pU:=w)'QM8.2{ !,d'n^pGN;>jPܑ{Hc˄ 3ۊ^VM%[{_:׀E֋V%کM?m- Hm6JU&Kmo|GCjεX6WSYU6Vrơ-ȗOkGPy{=LG/B[ol}jS$'m5/;Хw]C[c=x?*s]&mSRI%Ԏki3F'>Χ.ݿPRs)$MTO"{y#x0*MJJtiKTԡܑAGS ZAx|X<EyO[rhz#j Qϖ& $aq~mI[өYFk`:q2wskj4oƢtyeֺeC&L:*ӋQ6s9SiHߖ<`+.[%5 .Y^kNkB4vf%IJ>V\|x9#*wlP#%gܬ#CnT4,?(3n޵>_ifF8Z;/&K}mۜQ/frsT+e9e#n{V7Thӗ2Ԛ ߜvlyD8E%[ԏ_qت=rk}U\QwnFyjb*{:ɥesLa2kcyIc*I_@K|PY@01ߎU/tQ{5)5swN٠,yN%hʬ*:.͍ȈTY{NXιN'ulAa#q㎦*b9i#(44,'Ffi,l2y{zV?M P擩(vI%1͹K޾Fa($oCZzu)ŭ#ۯB;N 0ޑe9N+oe'szvF/푕f\3kIIJJHc(˺,8MP;w򺷊ͨƫBФYC&6#۞+Ju4jIIkУo8 OZҌc'C߻J$CdG@5jjWCE)sSkn";t:ݫs]nU=+C׭8l{6s)N_ڍTw8=nOTc2IV6Oh̯I^)Ҽ~ic.e(il٭,c^hm4Js7FцCdsVXZcƥe{k3=ɧH|iRdO\ctՈ{ed_wcFDZ]|qu&|l7C232ʱ+gZMEIMn"*b*k{&[kt$Z [3*ȡr:_ιs8ƓU];ymvԂҹjK.w.4c)SGkl rVG#iG9c8C)QZlӡXFnKrHѥbh7̀qyU)'(;?"qzN/E3.h&Sieh6eܻA8a<F2JS揹+[_}s)ϝWݿT`Fy.%TkF"wUR6AXI9[}vwo~nF5=k]BGinq#]*>P cFX 7y'ӌQJ:mviNTMRMG[o}պ̸XdO:#$!'h3\~U9 <,rBOOC B7YX638ԩjnϪg# GڡjOzqYMr_8Nܟ3m[PWS}PNZu)"Èڢ1/u(2"\6^j5=R:$i7w۩"C!ם*|9WT?~_RCZչфVk<=ëfVKqR/ԪIXoNzW):~RW3 m&@ojo>EӫMFz$IAW ޵;Tzv{8O٫۠723, jK3uⵕ7'o?oh'(:4S)J*m,Ze`?eOkSomF_č4-n#Hm\3曌乓>]_J2*qr[ʫ!GAK-_KcNU)Y}"3HЃS2vPŗQsqIsLхiԽe vNcqQzZF2RkWo7uƢ[ypyܼ5/LTBpͩ['ˏ\WTeOR4R2a!> n/1w?n+ djF+ۥ eGs#eM<6*s㯾qoχ*}.jXHw&OCӞk*Mrkgry6tmi:m,KyNZkZJv8-M-өE5e;.O]ҫ(u;1Jjh]ia~UsSo7՝SI|2 n01RkrTsS\ađƒyHPH8֝9mZa뻵i?ᑧXJB^[ jN8˝}8Q)7ttvVf V5 LZe}:_C:>i[O:M6ݤ.W*qzWQ^/<і">ŞѺ+ͻnq=+U#(~N卵in '~K_UD@$޸=[}znWO?D\챤~?k]뷕\6S{#JI$6~c]0SRUj0)̵ocoe,'# V9ב=8Z\ϕu~'QڧiPoʸ9ܝg(Qۋ~5 [2nzXS)[}06Ơ&x19X§f:^ JaP9x zgt֚ܚCϛ8hĜnB9yIY$H:KoET3; v;?Z$~d攚j2ϓ,^A>eb|;GkGTOYϬ^gQ[y#FY8$kR5"E+䝴goPMd1",v8$p:L=: Rf3D"f|r+Ҝ=̴3|Ӊj6)xd݂EH끓sT3OK+Mc GU\F\}iE+nU59{JY^u&yD}?*N_>gzT䍖~5Gn#1WoFsb[=NFWrޅ5 w/˰[x?12x=lw2ӴvtVU$m#c+זֶF'7Fcٵ;u1*IOZK~;.V+59Z\Q[2۹c*bbMkbftjۺMoT?6F8;rQtPZOzKݿ+ w7vUN5%nߩkm|G-u MF@m!ujʏsЌP咳[57ZAcq_d\aKX.8_{}|Ե-f}^&_1y' 5)qϥtbT]]t> pR)ozUe-j'̺9Jw{=5: _Gtr6ߙ TeZ*:#0JtW{}s1ne-՘pt~^f"ncŕWRRZ >m>',Y瞢*X:q tDSԮ~Vq2'tiURKW vnIehh-"$epX8%qZZǍZQYkc+^HiwYU qz>UR*l`'};#ּGf$Źn{UU),#e9[Q4mx㞽.%*9њ%-޷ #dH=ywQsIva(ҩ[M뵍& oW TeV5uu ,l*y ($UkR7TGoJzſ9fNRuo3h3hpȨfbzcYF]br"g;,Dw7#VNWίeJT[iYhw^#PsݦO.+Ξ ypgfvF7?6znsDӦkK{x?z6i|NZ-[6v~*ma3Y kY5N:5Z$qP̫N㓃ߜבZE^^[V5|:;/Rrdr,$'?sb%Ogӡ5=8/#Njn]Fo2U89zg5ZQ<ե%9+KCcXլ#;FD`r=;5REk|7i{ܲ>B ןg*^ꕭ:PTRsVkExBCq)P2t{vU_.v8#0QSuk/{Mcu}%hRb}VUcSH9<+]:z;-__U d=fC9`іQxP|V61j*+ٮu{Y VIhx@01soCFh]+$uV]nT@U#]1z1n-FK6j~_VHǎu[ GpQo[_gnBE k J0x g u>J>Z][V+NIoveiR!y+w$k 8y&II4C~^!xݿ_/;@wNC+1NQqʼiI-|ݏ~#|^&c.8*jS;Ab3(&3 nZ=>"#[ |:Ox|T)#.;{A_?RjU"+؄MN .~Uv~:͛%Տ6n;N8jSt:u!'$}||1[jpy|vzÎjStzgMn֧aN@pܐ; Ҷ/ܨY[V%(߭ oTSL^זJ2捹u}ok:KB;RH1&e }11_y=\WOԟgfv9nfa`}dhӧSdtfiTkR6Ai^(ݬ>8MlammgIk!Wi^=kG[_V)MWOӖ0igY$~dw?ɮ)Ss9NWQIv:+3ղJ+K^|Wv4)Y,6*2:u׉'Y__S⩮{s+]mgpwW]߰3 fn3ϯ8u81 =&oXr8`UTqؘJb'[B›Qs^UhI?Ezx:>΋k\'\ڏ$<|W=EJ\3#Uhj]`8=2O0x F|*֊{#]amyҷ*[t:[4m@<o];I،8OO[3I)&iu|?}.v˱n aۡ㨥,\S/huOlj0jY[eUP7m7c<dF]z]*5SRIu[-h/ 94o @$#4Qfmm>ZTʥI$^^nݻZe3hvZl$qI/ci7Hwn,K7Lp:qҼJE&ݓmyjե+?D_w:s,Y5n;N&"3G6 ~_n}qT)W/c[Q32n$w9ں)ҕl8WV6m{ɳvG8jJV_ք֩W:첮p{tyy(ӝN2ZsCH#ZFhݣ"bheI10^Ӵsd=N6z(U7#p\A<*g $M-:kX6ڻ߮s=;{UFj;3I]ͫ ˛dXLsy@Q~MHŻyEhi-y _G~hϱ5(WG%JU%-L UiFܖ_˥ih|&ܲJ=:cG+{M]i4P9p\;pF^Jz C'cK& =sw&*Q[hrtE+3mF`>^ Ӂ(u; F2mWfqBk$ߕzQ_<ilgYwVAz^$D.iou8a#?Cr Y?290?ʹz{\<-ޥӣ<=o_VWyp8"7d1#?6jSO2NJQz_R\ђѦv܃JS:i¤q׿m?-ll*!{laN6*ur?F z귳VfGީ[К[E|G[9d)EkS-Eo-DyjpiJt~㣫*ykmoQlާXP21ҵRܪӕD:uu +m\8@3iO>=f iG'Xݓzq_Y%&gJWz㳼m pGh'aӽG͞FzJ^t]:#r{@Mss2q̓1y-znz1p=GO_+-R݋Uu"8Jɺ;ʼ`9m^R}u_חʴeE>gK]?euKQmnY-.r3p:wzoqXKOxuætD-2y9u <XƼbu._Zd6OnVhbs0~qXҧUQk^J-ko#=.}f<O|c^.l:Q7~*$ qG' Ƨ,ֆpzu6+[ϴ r 6Hku긾k!f\0U*E5Ъ1Z_5)]A#<F1tѩ~S g}t9NKvmG9o2@[sF;zb˦= 1PkF`$P4)#AXq܌`tfi5>__tW1MwY@0?S|C9'5}~w"Qq(MFp<Œ7.*bM\|DTɕ]܁AW=H{ڤ =ITU&5Yp$0Oq.Ӕ-""^We9~^׉)T ~ʫQ^co&4H#H?YJZ',W-řٟc`fuS ѧ%M甒M7b/5/c[j6|՝:29ܬ^gaK jf$e?S+4{;uI%4 y!q3OZ)ܮKN?/OC=ZbԴ)9丼̠+N1Lگ^Ȫ!M$fV,s}E/wP'k~}uI"fVo#% nC~ޣ|[BȘGCkcϸr<%hU%Y p=ߏƎh{bmȠBs4ַ2InNisqכc~e'ҰsTOG_H)Sss#ťiI[_48 -U[87)^\ٛҋ[U 6=ORF?/JVfJrkv( ]H˽~ɏp`885W猨s9wg2_?Uڬ$!:޺9%ݻSqQo 7ol)Lpz `W.flݒF< 4E4uaJ2qԦ %U}8u*J?qmk(71.=JU%)r/35)Ο+KmF[UoX͜׏lg)Tqy"dջ%m 6YgvWTqUTkn/ʢ_Fwac&[1wnNƪE)&塚)V!}BU9q RmFO>"2ݬ؎8c8~(98?t96P樜g>"`:qߕu)^[׿5{Hs8Ƣ0$tG͞p8c-c+wc8W+j\k(\&XAo8#NHԩ_ܽj:RO;%̒@zonGq)zQ=H΍|uo]7]˖ZVhLq۪0TϚU,޽>D+Nyt3kW!R F;zTV3ҫ$7hjDڼ(I67̛q+̭9J\Oф札gr95',~\^Ϧ+RqΥib$-Fys (*<3YZv8e._1\[Z4Rnp?ɬjb9.F~^6;ث άo$q:ܺru;FN׶"{kZ= Yzk7!-IUi[4w h!Ԏzpzo~70:ғ&e26jzzRp JpߐIJInQn[w.2gjӌܼhtg񬛕Yy~1QQ?qcR99Ͼ;w.mcWLiΦFr^ԡ%וFi˛GsK3d͍w rI2[+yf9W3NzISFj> ORo-3/~kfج;H-:kxHֳ͝M%h-lg3MptoM\TASOUQk,ե(781 <}UrxF5%R+{+ .m*NWi4vifƿ|[]7UReI 9 * c<ҲX>7Z<+$UwŇ秘ՋM8v]{)_FѼk]Z .468$WKg+Sqi];|reQSA%y$m6߳V:펡&֌oCnʔ#\95Brm-[C̸F[MK?1M׈Ŧ% Xu,Gg/Ⳋrz?lZU+>4VE n|!0jWLH va9e*-5̰ cI{=>aᅟ[st)Nx|%+:?> w8/?}\dg+zPmFGRQ=_3--fӴYYY`~l`"Q3Hiդj[u]ď;y$;d T1┝8%sQOܽ⎇ZDZ׺}ǒ;Oy`*~,ԩ.c.I-9ɭv_am$}?1j>o'r5љڦJL6Rr['޺hܢiFoTXn3VƑ;Ck9]_8VQ~USRJuhrZK;s$br͵l'⻣n;Xytc̫, B&<Ԍq:_< :J$fa嬛[vF8<~rWrnbHlU}f-NNO8IsƤv4.^fUnn'%sҢZʴcQi6/iB/;STRER:xx]뵍b$Qn>\BNxh&x<s&t-J?uf9$:qQs⣲Vm#xo,{h9 ndWi1S|ܚ]e㑓{UF+LԌ,Ei"iXhy z{V1S*Q榣bY#67IϿ+ZiF)F\ Ȉ]uӕ*|GH$MP(x5N=Rs&֢$o7i$ڬ9==+8'd(DMơ/8}HNF0{V78GH_a4e&db !@9nM+u-Ӽct+(!l)ˎM09U9ji{{ n*JUsB;{V*mdGFé\.5VTg4۞Nzy5ʤRjRԿIt31m'Φn%03L܁xǑQ`\9^Rn|mxpϮN~ʝDF4-[aq%RFmL G9:c;*FZFEM[ 5j1$Gsz֑;:0fn^2ƧP4;mcOaA:½,&&zտ#-#SOljxIºicfX$84N]RXdc@ 9딪{HoVWjͧYfU8yy򾩦g 4=C^/QmVE֬U)&egj汭Vj(;rk=ugxv.(jmە[Ym꼏.oog ڢ.V9D$$ Z=rBv-]^UT{>{l޾T{%|{T֧+ Œ@rQZDzx<&"PZCaIM. 0÷~yO'95sE=5iJ yJ$~fQ 8mQZ<$W)vo!<ۤ+H7?*te̺t&%8O:>t숢ܳ<t@ad# a%:꒿T:d,4:/>_YYU^$ߵTz3f"8zUW׻ʆwU7CږR$lO^h=lݾI͌'ݻtLxDZj;g - lǯ |n/8Դzmi{˯v뛫9vvO^= WVpS<\fN\jwǒ:U矤iчpV# N+,eQr8.yQ&.#o1;w(ƢMlzu*;?Rxf(.Ǐ,m?ޛLƒ޴H"#;pϿ O/7_R}Amw5ys}=N{cvOO1 }:=uƏNQlL>gu?)?U=*%mlXe,&_6HϨQ96.p3z $ݹfJQDoIhO2$4w*20+3RNR_y9Q;>E~ƦY#fVLơLUBُCz19]?{2bK\)"gf~l?t{8NUUF·ꚽ$fA 9=jfNZ5QN}O_/VC-뽻_)b// ?.P=,AN@ۂ8';ci[z_֧^O=#F7igKIr~|apN3v%e*1*N_??a?"bYk!X 0r  {ta|NyF84?D>x-Ymc:1vߐ{}9+7 w׹=b)re tsOZQJ|+ƾbUw {a]E_O0Os,lUOf褓 xEܛ~~Z}3*^6܊+ܤʫSs'-qN.ut{u#dI+5Amv_Q6Oպr@ʷvdooY9SQo"X^Yr7Aw!U==~({K+U+MVxl\ wxȬ*VuؘdV]-LC4rFڨo3ZRJƔit5eYywH~Y%@RXZRkᅷxms2_l>r:|s5Q@[nw7w89_MI{~,i^\иҘP3!p p9VPuNMM'bX|6F`(?Rױ9Jç{n[%['zҟ$F4miȩqΒDUZ< g[ǚ6svUy+na}'A֚A5'J<ۊљFhfڬS7+nZR'Z{wo6,YU:֩&ԷNc(|ܘܱ'hlCiJ1k3IKǑLt^(C-*g@(㊧(K[S:gn@ mv?Y]}ǧJ4q\77!n3<簮~Z՝ҭJZ)uvѼ\G9kGN18JPl066SOc֧xo]o`pWk~A ''ѭ5SG}Qf# vpKmcgl沔&iN5Rj4sG$"S(;*Hqݿ+n:qg9R-%L4^xj[wQzh(Y_I-n Y#W |{%6h 69cq3$=Ѻ޸$姡fAuol/eP̭*vFTh]'7g ⵸[IEi/FqWhǿI-k4``#EII8֏9C[ӼZod(ֻi~UGCDK%*]p=0HסN=&kv4(JjHխ!ފn?*RRZ5s M73݌#ϴʄrI#^ǨRrQG]LKF8ZI77ݷ?LwXҗ5o~76avs4!12¼lGBXݓ8~69IuKl.@d^N'8;2NMB,2/r4ʻyX<{,VZh4TIr W~eU~k&yyWA#*}|+3gw?5wƕ3nkYd;[M"[UPy=s]T֚4"5vFMp%j.@=Tyrb*KEd^2) aHU[ 涣Z,-5QJ2~vo/ >a%RP+* rr9򪋗5t09r7$)l1zcM?9F ;"g wG?u2y*s= RXm.k` kJ4u8iחqT{ OIWuKcZusg5$YNG[z'ͬ^D߹[ d;q8q֔k{˪0&E$t-U\cW$hs}~]=5ۙ81#O#rb WFU7V/c71Tus߿jQ2*;|uyޱRJlL*] ##iv«09wW^Rr4^U+{iY[[{&1]e 븂?\{3EvJq,x#.?\3Nw35I^E kG>hcQֹ'N6^TaKLcvipm۝~%Iӧ[bJ%r7oq$2 ҳ"zjv@Fһ;i8u}jJ\.q&뮽Mxg>Z;r7c*(G?MB(".wIv較NIⵔr~Ŕx8f-Gبߛlܑ.v.~gۜsϩR(8I^3 ۸1ZIy2KPz]mӖZHf${?\?u!$@두qsW3qKBV'9s5}L(+0M1Ucܚ7j:|7&ܰc \J*1#{8ܪ$^cJ ?kOTO@V\6T`374h'B\j2\;[F1WNQtw} G4c-W#ۂ~E%+;Z*;7'48^ZRXuH`P]K+a-d"JBή,dYHrkVt"ayt'c#sJ2ѭK բ&3~3kMN{vrVjYjc$"9|2e#ε 󍣡u V1/293I7sTgnuf"O߮N 8ϣ~~QQZw8i29vbߙ"ad;\<^MIJ["4(Sn]ٛ7ln!;YK*Es0>Tb?I8T;TKFgo(91޹%=2Fkʬ_>ɖKEsLDC朥87VV/m:)_6Yt;`qNgڣNRi1#A[%pF!̌2~I}4RHǗw뿘3 KJ O$==c:qӿO8zҍw=/HKkyAqi kG,6zG*JKݽdrEb=2ltǠ%ʣFӏۡ[f`dN?i- %^ⴹS" uMwG&Tm8??OWJN[t{>ZQVMuL⒝:άenȟTKoɸ[o_©F0g)Ti'g\)2 ң~F[:Z=~+W9Xܿ3ar@qi-"?ym^F+ݴh#8>s=>Gϖ6i8էNNJѣl:s3,?>ZvN^^ T9^9=FZqб%\Rc*%ORŝ%sٸ-NsEc:u?jܹzJ5%byf")<7*)@|?mݔqǯ5*5BMӱs4e[w@353_\'gEJ5{FĆo-\t;wiry2ἸrCNr쭨(ѫ.Y;VP[#|+${g8ӭ%NF/[=些:ĉnݑOZb݌c̡->K`̓F* XIއpbeW}Cy!A46*+߷cVz 5Jө|nd&@ִIJ񊶇/,&Bm!+5u +c{۷js+rSӥg}zy2-do267';ld8ϵTe֋{w?#leIlUXu޺'&ԯөU#+|Sw>ʽZ8[QћKM_1W^)E(+԰.Vs]n 0|~⾂&JQp9tdhe m 8{v>aޝڻӌZo4L+n^}p We GM/uس?e2Ko4>NJ?һԚ_5VN~ Vb`H6GwG6m ѳZ.{/OR(r)Y2 4MI$q4T~9#ۛRKu)^8#6p)`ecW*vqG$= 1K[js~'i.wZ4cCo!y<֔8ۗXFҼSpzܻmkzmuy^44]-mRjKŭ{t9O̶Nm/$ڪqN>oíkGѕZICOΒ!fgiv3'Zⓛ}tcinIi۹F6>laXYOĊJu4ߥQEUll3N?+.5#S(JVkkƝn.qݝǖN*]Hӏ^]IDZt{y/.r*mc+kQL;I{iЂN@oVfnOrzooUT却[Y_{)TFvVIml؎)SݞaG86;89\}u"~ 3Q׭Kά4Mʲ^q-ԤeSbS2 GmpL*g tiNKК8hg$Z-KiC:y(-+#ZJ3wМegTctt9]CCF&")ʤ.S5 ( N1 R>1Sx9Q)p>uѿüyŠ->1|' t>8c $1z#1 hEq`crvy85(Vdv7ul RkFYpЩfeP5*[j}.x4x()GmKwǽMITE)3Oe.ng׹&g+XEGW= >~@elnt,dߐsPmMj6L`}(tF\͘iKQ&ck2TjU,+i ՟EoUeN>>nN*%Y ;H.{֔%(^JL\0-UFRuzQ˭Q֍<7ql+JꨩWйc>tXX`Dne鬽(֒i6Wi`C?wrׯN.)8:ƚF1vjqW6ʔ(5N//LV}LN%̙q/RU^5oJ+rOO![)mn~CuSHbI[J^1Wu%e-j̢֧sjFi-V0xx<+>Ԋ(՛kmXNMO6έ*@T^r+{i.L|~URQj#嵕4ט+UfwPYvj^Nl=h8٫fH8FïqV*KJJ:a'NQrW\4~쑶Q٩]3zz4m,Wn\,rr夐(/qE+|[o2{o^rkF4JNPZu7o`yf('Ls95:Q1\鿸$*W/rO65+ԓռyZt̲ǹR4v_0)E!Iqjʩrq0Gջ-ΛG^:P9i9*Qqo4i鼮-a޹Tmt9SK$Ek8 Ione+6Xn9 ӎ:Ҕ`'C߳.dީxnw#g yUsJܗx{ cUZ4֭zȿok1dISv9qc ޷Kc\z>_OҹJ:i)o!$1$Ѽ篧oj#*ϖێ"unHVe; }>t]ҌnS 0Uvsd'%PJ[=".|>SiK~tH^I$G]ۑz)ӏVfڻro29.V@?ÞOַeMmG˖o&{+%fx:3_GQ)|AϽW+T\N/.]G%y,'1߷cF1Q+h6y[ltI$T~V;z;ֳ/{jK)aẹ&{Y36W(>޵\&CʢԴs x- nU?>J4*M)'3rij[7s^}L?,[tGFTZPd/#jMeÆʎ 5=OfyxcUkؽ%ېLDluOzѧJ<۩)YEjjxgž[{>}Ck91,]'$d"'oԞ!Bk.mKs H2*H]Ӎ;?+i׭b_Oы:p} &HԴ '#=ySס:p^X>"\%>փyg<Mn 2;rF=mO..ag;E5z]Csx)G=Ԋ)ڪI 01 cV.:pVVo}m5GSÐwL#!'w]?Ìv⾚5#N*OTOSY+3[$F$p`O }[JJ硂ѽD'<92͹wǜ{8^HJzkH܏/M#|8۬GO/t< sJDv1̲J<qcښ~Vأ51?-,l:c>]PRv(W{įo([m>d{l>q劫(FM#^JlC{30\|Á9֥r]8֍GʖM1fR~^(FNj4F76;r>ڜNR- ? :}r~,rʓܝ ELJ4zLO.Y^ mv$ɐ8=6j(}^3,>.5}}njY#KuOkWn #q*8xhݭ*u'h}Cod!\**8O=z} )SR_S.)#u&ݮ`mCMٚ_̒xE`iNھߟ,N+^Z__|)3ܭ$?&H~SFVO^z+ʭەƫ5컕3IqI\*Emr)//d^|at4>)P.Ap'lXzʜ4N1֍/6A5-J9*+0Vgg[eĽkXtt7,r=H+e]Z[AoGCƽlv5Ҹڪ s:ۿ.U]՗S%-U5s7_^ mmn;>e_ZJrOxT~Uk3:qsnVYzWjMp# 9Kw|W_T]/ܙ2gF0潺u04iJ^7rOK ,x2^t)El#cɀv@o~^\)7>[yrj:vQN8HMkmGF_;*v^/̌#3j֤cJjF<#^%!ǯ3W Qrg-mRmE].m{V ܞ1zX~}TT*rYA^iYmIʹcd~޳嗺^f)IMG][gcKHsz,>!Q愶 ʖZYt xkĒXqg{m5*0A LwqZTh۾s{I$~ghwwmdpI nOz8)z(j+;-[T+I#%ԭ$K cp8qױRh}rQjoOhdop,~ZR=@'J:nx5*-;K Xb_5ÐbE+cvΪs+Eug:䶻h ˘eq f:+ 5UdVI2ۛ<gn-!wlG[¬g[ suf1|0Z(1i^~~ڄ1܋гn۷.]<\[/e#V<3\n'=ҎZvO-jmEz$\[s8[rz#\xݚ/$Y۞#Λ)+:eNGgܤ4*JdpV }j:[>)%-" %ӵp9&=/7y]ǢE\#r93,`aR1N{30*vK T`9٧|i?,WSC\'[̟9'N[:zz=[ЮuDIwpf2"n<JzzZp-v61ov'n\`ss^;QOi bm.dI#d\|ǞHA`s°l$lpԍ:s3kvwyycS\g؉Utcѽk!Ck{xR3mS3>Wבu RsZ[R1 rrF[ru竣}6,Kx#O5m2x;:ҭG/-'I|BHW,">bKJ~/EA@qxDjrɫ&o*]?K;e4߼HN'3Ƶ q*pI0Tݶ6O>kt8eQ>WpkWqa8+q!,[m͹Me[e9}-zWnsS疶oG1F5ٺi~\KR]k5v3Bx{4veU%%W_k0"8B \kEoidX"Xdk!3 eoNr[=`DZհd FC%ݡK&ݠۑߵmiZ&\}U5e0mԮl*NW]|x=u&C`$d 2{־ګQ$f/s1|y8W/cj`Uʠ.>a?ZrQ{u38?(Irr濻wS4Ux޾*r&5OM.=睡%ČUdo~\=2Tq^읆8=5ryS3EJشn"_Al̹Va@޹)o# 82h3# \aWd}g),uJ}]ɴ1ƫ-֧[=5S&ۋ`z袣T(HeHQw2&+~ڲlGJi$MWkyU`vjy+}Ե{ȁmżQ2 ~WlT Cp}Yv aXsJ͗ʳi^c @,f1ɻ,'J_?$BIc{,\r;ֱ\2qN-DIn%嬒~s>b?UQHǚN,t\%*<Ė*@GȃGn=UWbbȭupv+.ϽӹrpT-|AuV]`~zmowG.~KD2y>l}xkNe Ƒ&I f'u%eda]x~fo.RϞKo35f`!VH_JKSrVeVI Zʴ֤-֥ˉ_gG q\1vU,4i^ls8ҝJn2r8.MՔ .GJ*Ocvm):5>y6\S)U 3SOrqԅIScE57$,ͅ }> SZRii'kot>kq$l'C r~SWZΝ{OkɯCn e-U\ЌbF)+_3` W4(=>wkTjFRq/&h4S͞MlM2=HE}+I4n5SR:>+tofG?/>+Tԩ髙>oNO"ama?76>CK Z-_"ԿH.hF>[$] $cx qqn+_/.NtagumѫjﾾsϿ/?gtVm2Ty~˻,齘L`UR᱙gV+IY$e՗#5dVow׻]F_h/)& Ċb&6' ]~b0NI?T"M%=7O?^ry.!i$_Vf2?f㭜5[]8,u Ā+{yGEtfr+_C)pZ5m޺k|}?Gad;LO%N{en1W}4K_%3Jݭ__r_|LooľŎ<0b8 Νk[O#׳䶏mӺ_ϊc] }BfX`y`eH.1xl^RQi]Wu09ts*Jd+s5${}s.ckƷ'9HS0)fs85)aヴ%xԓz/eem%Zhtڜ[խ]謻xH્-<-i ˘yjw@ea_;SR.ihU81*Mi~Z~};68_½FúUhmHUռmb nS9=vMve֨άw[[-;:󶚮V~͗&_xⅮdjnHh%rvՋG4i*.3ES~iȥ[uhﶖO=jo4H-|!q*ܹXʓGbHa&ߴ-/cٽogNk?Yz5<+.9(r7nN:nzu#(5elڻ[YmR.*JrݓI[jtllZq\xfaF[2+{#r|nU Mײw/99{V4-ײ!_/f $<~\$pFt)aZZsr:vwx+)뮻?_N%wkw&q"挟'vc߁^Ncjwխy2?UƟGӵ>mPxzӇCHX|W2F9ϥǗ{8] 5|n$s'\R[{ӌo:̛R}1{WU?2d9xv"bW,XǎⷧkXGk[n 2\lc۞ r+أU,]vs ӭdݻΰ>U՚Gͷ AFەq;zqswO5`;|N5UfՇ'i\1ޝ.x(J4Y37_b\|$UՎSH#7,d݅Ns׸XfR#hԳ <&ͻQrc+ּ1+G'w>+(Ν%Y#\C<ۤU*zs]8x=j<)8mfs]JZ蕎U:%ormRkƫ"{-yi*j0Ο,cy+bՌ!/) ČAxy9'}-z3(qJߗSwEFx6I{WOݧi?sʩۧ<f*^a뷯㎀5$ߡ{h6e4vJ dNJRh)NЊ㵈Kt4;]dlq˖-Y5Kak^:=+ "?-UFT(*0N8YTkIɘK:??S}$XTT_-SO~asjYwD/+>#=c~?ӌv_kNc_U[9{Ow\/Vv~SJvQz/#&O4vCaW%H$vkIʛZp Jw7!,O[|{#y[<4/gGm žV/T9}낥izOufw]\cz2/R_iVմ>呎2z9*T_5'ާQCߍ.MOLn#1V@LUmRR*<߽mn쓀ad90}:OOn*4dsqºU[ݞaY n?$l\߭rʍHhu0{WTYӮR9|$)Rw߷(VZ)Q;FOˠj1]g%=yں)/h.TgGI'eCw,jevS%9rp?/JaN| i-Gn)Gtۚ4z+_cM;hͥ EIj2/ۆec'D)wsJIOԱ1\Ж[ށ`$<_&RN`gt6ؐ0>RrٮpVB. 63p[18ʲ|&0 ]x;sr9[rKhnYW׏ZӖt5)r\bsoȒrS 3c`u#YmA@樣^^[[}5LV_*{mE5m~Q:ķ24 [G_[:#*˫"SN 1ceR5cO#-ZwO˖+^ϧ{hOxWukwZ[Ŵw-H  K *NqɥW ]5V.7RoVF=z}XU*uiҳK^zYq{ךaqSoS׬I#!A )QR`^ŽV+w=LV[jjm>WOF=?Iͭo#Mw'd8V"r}6T+ Kmw}lEv#nG\}ʛ0:cW𝯆#/d09^Ef;W><pzv&:kW+Vg5mo]I3p]llA@Ju]GR5{o?/S2<-'Q?y6KKcMŭq!;UT!`dr3ӲJw= •|5)Φin~o'PaRrNij~ Onڔ.R>_Cw_Mkmq$e;XOu+ˣN7]1H]lOx[iY 3|vU1z>;wߞTy`.맮^z߆!$pyq}~5CIiN)*ߕ35)&,7mU<}X߿z$Q~d%Gz;r٢#(*|C-C$ޔ~䭏؎M8ڜwfA%ʴkܥmۆ3QF<3j1ApD2 :vUy^ڲNN2h3"oib{fxH2F}cALjFPn:[bC>Xp県TzN<)FS/Bxc_n~N kTU,Z}r܂UbvnsjF1cM.X%]NF3+`OxqkFPTE^Ҫ3VvOc^o{sy#[„ɺ3䞤}9ѧ-՗J4MxFkx@3\g7)zxҳASVV94;I n`ub;t=bgfܠg Qy.JSul9&!5}NA<u9ȔjP xW?eGGr 'n ?g? /0Wȝ* 2ھLoC5k]QW=GyXQIV`ySM>53Ru"$a. 3GmyT$u+f{*Ƿi}-FTw!kdlUvXIq58Fg"kюYIC ^yFk'.qUJMdw< >cXl@GҹnWeh`oPmݴ3 r'1-F| cn8 rn\٧OdIN&ǹXzw Es4yw}B֐E1ہۜ*OC5okjMgUU'k ~-58*I*kTnXK☸7Q3Xs6k)S[ٴ"#XՏGzʤyӏ8k 3jʑ,7|wkFUb >`q$|n5)s/vJ~\i s]\s.R]mX`4RXFO\έa:TZRFV!?*Ӝ~sJ2R:#>jO`1$ZE6y;UX˝ܣ}+6>__\T;Irя{ c@ 6_Һcs֍9F ~Ȗ7w7Up3ПOF9^wy,rSOj44Z1-c+>-d>s֯ltѧMGRSjlю/ޣnc6qԌDj9FF:r4jSlY#V%d\`69C,;RF[kd9)[ZFI]cE cZfܯHG=U{>ih5U&vS{IRpNwqG8z=V{ !}uRHϕdNZۚTR*WeenOOTԟThZ (6ӷcRi1QN+I}~,kq TgzkrN5Abf8əZGbIc*/qZ5{̸_2UvUl֣BEwfŷo,9=*%jrԜe.is-ɭ|[!gv)#r)7<iZ]ۃd׃TsQv۩ǝ+艖&fDInuX֞.5 aV7VNnܿNzqשIJ[gu-!dHePꈹ'z\%/i"ͣۗH6 瑃xuӟ7#G/ce$BЬ dY <:ڔL,hm̪gԏO\}#oNrMBvNe #Yx%?J!V+:UGNa-CӚpٶXbGOLv(ͻ:#i7F.CflS'ʃM9){꣈I:Q-Ώ (I8]֧ArO;\OtwӴK"$Yp'(d'Nq]8Ӵ4[TɳяG?}-H-݋0?_@;攪QWVwf ޼d 5bˌ9O5%dנ>ۮ4QdYW#Ti"~)-[;g ʳ 0_Ƽ:9>WYQ̝y|΃Ci!`1y7(g{׃k]jF<+ \6'^UJVԝL='jvZejVS;bB2;W%ʎMntv=ӴU8Fj9-I7Գ|cݒH qڢVgR9Y9j 2eF9?r֩)S:#F2J5tJZ]λ`1Xvf`9z匩8RJYCi.*]\d`aۏU:~7h#yvQ/%vz- ַ+ "˟n.x{nXEgbЯJ1I1ϭzOV3I64/>-ml!Y##ȧi*'JӊݿS͜/؊eT$yjr <{WU|___#{iJ4ѬfYYrsޭ{p1X]4Ԝ_[NG*F|}ϩw8ի&ӼoKs~S69*x22ՖXn"vdA|9ӌ:Q䄣.ۇ4cȧm^ߪ2ЪB$Qm~9=9 ~S+&k\f3IW,$ ep 9"Uqpi;K=]+|)'iNiӹF0AQVn w.q۷?g8ɴz5sxab+? +FT՞֧\aS nevu%<, (JQrJFHSj\hޤy`n!.+Z6#1劜50VXЇL<«m 3+ۿ沍g m,e8ቭbi!YDk 88ΦTyoSEkFXM% }znk1]KI*̩ZTaguGچ4kw8=EV÷xT{9GVsb"kuՏR9j.YQNM7zE;GmkKa!NS؜sH|baI)l~6e*9xj+X%j۵~y͚c>oE*[#`jr_*TE|ͩ4XAY9E\sqыU[cRSY9C^k&QatY= ϦHXԏ"Ty;kY}&IPT6qjTqtLjFzTI,)++<ͬFrӞrӆFtR/qYcB}m]O-Уxx*in&a7wZ4h3v2b]%I t\uN>ߟmZ܍oѫ1 # Jr?OCT/sZ+vWA, ej+GueiO-4/AovK渫B1a){#%84y$q\јs8*I$GVigo/x >`[x.c sG`m%qI#I7,!?LjMNZn'v[~#@aGyOݔZ^d}yN!s=1ۯ5͉.noD xiѦMC\umʻPiGzXݛSկeMa!UFYwg*?֮1[&e)rݍd7ucL˭\IJס$A"wu92Ӱeչ>W)T&mEX' G?gQs+#)J(Ċ!O Sd,D]umj#+FdT`rr1_z|s< jEݻz.K$gr3=xVTZ3[[gUX0,{՞כItJUcVlƋlHQܢMW)'TJRtw{|qg]4UDv>դFzi4/y]xsy=O_OHꋍJM-=Lt/ilADeWq$q]T߸-S3M7[Gtr 7:i#r&"R-orIKF|,ssg^1o^+iI kR%>LN=72Ϊ4ʧ49)I3Ί5r6HԻF&$[IUxoO+DWrIV}LbP*acxK7cjWB #=[x1 2sZ5‡BZhi)yY`icbܑԳ9ѡFpOIV]bjQm]ݻyy023t#WjJڂ3ZsNs#`vڈǞS>1qh|gUӧJTU_ܲBJ255$i";H\ȣr -EZN-ŘʣZOQT}=Kngfx9ӷjڜWcz))T^gnG{u-$*xʜ6t!Ю$0Ub5%掉sb)WؐEPT;mOR׍rZe7_/sV ,*dR988Z_R(l6to4FY3)$M[/s֓4]zEV04.vdF:W-J9}O>yI^OG:O U'=;#*JyTP3-t$] ssUZQIb#V0Zǯ虁wl.b \F) ( j֣(x+8 lc&M/{uoŚnmdvfXvFʲ)珔R8nkj9yUܭmo/ _g ݙg2BʄPn@T[1sOKIjK,]DFӊ{=zt9?.#­0o8^]J1teۗFJmsvQi+zW+^]O.`ܤfcVe+aR*k{.mCZ"ۗw#|Ki{># i2+*,{z^RQڃC4ѕftR){Dk+T{qr˷Ew{j4vTQ(Q4hD$}\g^}9ԩRp'^IN{_B$mYnmzq{U*In.YhژgRIkI C8f=⮓O 9|7Xn8XIFhRݾeڜbXr9W=?h#F-d|aZ}j5'.]Ϲ\e΢w2A UmwcGӭKcj-s,YXal9ƹG)?@J|nD Cv˗Uۉ_TjJzSHN{ BCy1W+˞u)/yER}T[,27+qRgs`NORo$9֏k"ڶ#y1uѶeS;7gOs:utvVT<:rok5̔5K5]/[Vy$EWhd` H$d yͯʟ*MZtم:JnOT吏}5gevq&$edl'#i8|:S)9/Gb74\8'Y![ uSM( Ԕ^JvX,,`f}{k *tױ`t%+3<Y1Ƕ8n&[ʍ< E/zdxI`'#*>RWZ֔eBNCD<H!3B>I8=x`Jb8ɾ|?WRmlr:jKIa&Y[!I?գR=*N1mv^5e*쒜g;W99z~ZTaGԔf4ܪ.6rt1EC֕W[kD֦vSZܦ>l<ΥZF*}}vix$WZ؊ʛpF:~vZHͿ{JQJI]<+Rtiyg1xU ܍7aʃg8uV~]J<=HѴ~~9/.4`mgl8ɯ>'x5+bdW;n ~NXQz߹Die;okԓb\$d+z<ׯCez22:q;/y[UF u?y(u!;\*]J[>  EG5OKn4pa1R'*L.ʯ)S6h?zXgGNkO*S95VÚ5LnltN:F6F)Un!vg/Ja\ o2 Hc'dQzxd%;r䞋rְNIW-HlDB'8;,k(-[+ G듟8iZ\SzM.?\u li O%eZjIl;9K_ˢ OQPcvڻ"t+g|hFQ]-Z+I6T|#J<+dbZv Mwpw[.k:T5x$uI0?+*uing/UC{Vso^ǵfM2ᇢ5cBZ׈誶 큞~pڢ]}|>#픥 ;w7ִ;x;qKr`WOJnةVZ'kN$r8"ǯ$d5(Q~_CҒt/FZW d9$1S8gˈZ}mcNvi=Wpjב<~81ׯ W-j;'4M譼YH!C>H׉Z,[qMk6-/dson2? יVa5)YZGYwW?$ekM+m8OtZt{)ԄxZ=;Qt'xT,pxb>"\=9kϩGE*=>gP|gG0%"HL.z'=:eeGNG -]z~ 8O°aQA뎜W:{w=d՗>[e9.Y.Tx!+ŭw7X m]s?jFRv)+2D3+yY]溢mq,G!mOV5ֳHKت$fuW7,}2uvѱ >X]zub. E*|ܱ'==:ewcRjTB9hjyyg=V6%ݬWѵ!ћ~rԧhc)I%8uicy5Ɵ׹`FOsG~wV9p9}Ӄ\kqk{~4 hGXUNi~"_cHb=#[ly^.f>k na!9T`21S >[=tۯ.=Zj[wx^J,]dA8pzA^g'+VP۲u>xee㋛.څd]sF>mcIBKEo´匭R֗WZy=V+ϲKxDQ&"v.>o#Aa'i~y+L>4 ~^8Ayƚ8Ued0"5+V(ªS$82پo_]kB֮3xVM>M-'IZ0r+VQ^KBJo];oڣ,:pMu+ Y95,e t)]cg rKt.ƋX,4f?p+-gRTSw$C>Mlo¶6ʧ4^2ɤǥy,V9|~$N7+J>Ɣ)bU3V7|'_'2T.& –1#py"im٧~ՎVۤq$?c߆->`>27]/|絡(Ifyik-]Ya;}I=͢q"yGj77 U麶I̭ 2NfF:{ciQ}>*Tr\fVjlsOs˕;~MڲnSzVW/y%()S$<>ۋ= azv*QiMYt5K6G=}89IKonvtƋjc~UPtϽz*%vyNOMQ˸5 FסF~RZoάbͷݿF3BRSӏ7ujڜ7nyFl`ןZ+;ƥFQiyT] ߏpƾZn GaT}1t/I!)4y2UN0GN1^ƏOފZ4_U/I14Hfp(8}*[I=tO%wV~z@qPvmI!/ czN#Fսu6*J*TWzv xsC|=mռ/e7O0E  Ѓ\R5\guwѥo^vI^CF o=s{t.Z&3<:s*ǝJD;uxe$rzz0M{kٜݯ`V[ 'eYc>fۻ91NSվ:wc< {g.AP<p?wk̯*=|ϘCTqkz:8.YHME~\sǯ֢3斊íO*enVyUkz 5&er'}GzsiTWUOh\bunT|q.KV~MiWNEa6;XQ^ưE7/gʖuWpK۱#ӚRc GK@&Ey7m Ҫ#nբa)Qu6bI7`8[ *nTޚI?Ѥo7nҟ-Hc9?̎PX8J"ҧ;'{`meQ~+1;,iZ+]Gn-$qZZ]>f+q⶧I/&tʯ;6JlLy5{H%G÷N+sr} <;ם*rUsvٟ/xD5]]F9b018 z(yQa#UDo'.OLT!-K}ݍ(EJmek64 xl-7 g|tV=ӵsδ&ޫU/4tTE a`'S%۹JVE54!G|YRF0ӓSO Vzt/t{tVIlҤđ"I޺anu >k鵼jz}P!UC9Ev3js32NOGR/3EQk7K*8RW5X4c<2O|J.Ym{TNrN~7O`4Y=3?*=ܺ{M&2?1f;wnR:cֹ*TƊRZ+2nQWSR7stN}9-$V7m8ӏj6ZTi2n`g>nɮ8*?q2^AÝpp?9׊J-{j_ݔt]˟gdL>D{pQ$=cRQM:ta')O~CBvJ2(VNޠ~ =:̉S/,Gћ7h}@A~#9q)ƌ쟯{Dl`G  U3kF-4aO*.[Em6xH-0zNJ\t!Z7O{_sug;f2}~oNA#:qtKR˷5ﶌxq bVRb120F=*TU&yJ-Jd8--&iDad#?@*+m'?z3Qŭ&;#r ]rj~Ӓ7!ƦZPI?29ZtftRN^)X8LK3Ih=1QGa:Mɏ 2RqR y$8=ʭZuew}盉)Tkm,ɮv͆I>NwrWåsF2^5KG!Lk(تʼ;g5 L#[Wԭ,/.FA!iU)UFJѴoZMaCVn{WOR-TDӗ|-KwQ-sN٥5eorS,O 5oUX0Rq{3jFtx:oS'Iif sF}6?;}fjO?7#\ȃ <|MH7]61oW 1$\:9yKSlZm1L8ǯ߭c s Gh,R"nnvNi^Q~5QSvXzFs^Nq&y'[nY@"zpƺ+fJSW'99|gp^C gx-Վ<}]&B6V@1s>F\=6uaJJ~],JFticWy]*YX; EZ~m)^^l e2/;W;OoǏ~.GT_D{ՖǗuٌoRz=mNTtx1$v,{dElR׹y}d^RUa21RwcK ~ºE9&TVxک$ H9svєӚKE?w}==Yb%GY6;I8Ğ1E:e(VQm&FnK;zpMw{moϙs~T~pl~r)&#p\[8zmz~EԫQ-K1/~\\ns\w5:TJo{cA|ś6 yvFu%('gbIjѨ?ݺ|LzD)jT,2VV/lר])/huJeq~]t/h/iN5\k$?#].UUQGHmyZc1+*5j)EJoRHf~Ӛ2֦V?ۢZэzMĝ>#5+;\ܗ$yP6~8\Vw)r+[r<ʼnSa%M5> ZF6VWly1U.U %Qs\2##d oV$?ȡK.F~), ,(k(J< hylNc8hc<nlʕHY>iQociNqZ~y#^bUoÃ%#]2妥3$,f#J>{{4FZ5%}u3o."xy<] =:f).Rӱk]۬PFd62II4JO%d ۝i|>G㜵kGW*5)RvٲIwk2EqNyۥmG2:R)j1s3](kvF59[ӥKh2ʽ~R>RFF2}*5$bRqG[[S>PCgR$Sp>UZƜ\LiыսlL,_dnqҦQ啛S̞%[fvq咖.R]xul̹f6ڬ1=+D-J2 oj0^eQG[ЧwpSWddhy*'9?Jqu(k{ʬQ/[cfXvn5yRSr6#\2[-߹fd !A8v5Y/w2I/a< U .x m;iN:fEa^i6ƛpw#IBbKMJiW}Ⱦ.<%`!zt.4j+审]]2#U1H8'?Τӏw^ѨFa3S^b1RKJmɒ ݓ?!\5!8bݽޣ$<dT>n3y84+!ח/~dvS)@ ?|W7}Ͱu?ߠZ$v9 t旺ȩI~gA$;t~**I˹/}B;GYcv0qS,LyfN\DYrhQ۝NN}I2өJIGdii 6*d4T z4ｈNEh:}5U- !2pq=+JkǣG Δ:w44yWqVI)xu(n1yj*ll#Dv"zszcVr6eRz6--4UVVmIl9Qҟ@I*tW5b|EYx*w6y5l:+T %cY03*=+լ;'ӵNFiN%W?)E*וMI i}XM }eNpzyQto%Ao|#ɍGcfTv͊Zc6k\[uXLhR\~ʥ9Qiʜ/gC-Ğ`Uaeqj7<GOy/'6Q'˹j!o%.#vd=;hI%WJ1u?Kz&4h8$uhgvgF\EM.<卋nwRkCwʟfI<_qٜU{]u)?֗WW5p+|6 [envhSȨ)Z=eS+MzxȮtM*^9 rO*ޟB9>U$g"#Х- {ַ9I^'.cF>daS-7$OmN5,6Jw\^JA=UFG.geJ4o'!7M|V)QdUF>S$ps>iѺTj]jtBI6}Js܄-'RVH_.OK~:w5\\K"XY4۴saʥa,HĎgÁlQkηѥwڷrZS5M/kѻ,CeSg<p9~r]<vvٟ2ܧI,'2ݭ4_RUJuWOwMٮ/?Ŀ z׋542ni1tn(VwpB:_U]?4!,<^[o{{w&:tI} P$ K0wx2,bKmKnx9HgU(j*Wu}kKnu`i68DRA' 挣;tt޿ӝ*#ˣg±xQ5h%>qtw9$px֦-fn$ mqU+vGxabOZ?5E l+ZV]tןi;-Vt\y7_i9 Vpr90գSI_˭crZ[un?'_mbp(]r7F7ZB:jꔫEo?PDʐd{q^S匹$5,AsxmYquoknXK}Nt(+oXhxyr͒=ԨZEYS5̊Ѿ|sn鸌WD9c3Xaj~$E!wpIB)FS~SS**QW4}h}mїt^YF:iRig Uo^<'DJn_ cU =|&e |_i=ff&F!<9.vFriCh^]-E|(795mB#_츙c1dSR<.OV}K7tZV ufyUjrMf#fhذya)wvaMFIXP0| 'h{ ^96nzѨEEzu2"{ڻ_lE:nU:ѧ&{Z~i[h 8f${d\Vn]M*︺ʹJY?I!^W9?UNgS.U9Q$uQ\9?SGӭ to|$DwL`2ǖ^"q=[*+,E_J ^Sũ*q43[{hdLfVןZ2MDG|lNeզ-ݓmGH'9 K_U1NQ\eXlq=r:MXөnGm5=J4SsRA!Դۛ-Km;_FBr3HEIGTo3)p/CEonȶd.&#fAc==tådΊq]}k|33b年pSПK2 ̻D[rg ߵt֧M':*ECHǩb`XfhRL19UUOb\7t̵:eC)6 7:|?rԱ*7^rso:pMyS'~^cm+vUM(1=yG⿕ky.>j{gT|A g#ǣNMEmC/RJĭ/Z5 Qc V1˪-n2,]L-5ۧs4'P~vۧsoۃĺ"%Hӯpڽv@Dr}>ONۊ}}-fslJx VQ畓{VkkG:~;=oòKtw͟29b 3V8k]%do=9baIT枾j7[]~ټgS־YfS$s\,$.FFXt5IUi g2_E8 }2H~դ.BTdRq^U"ߗ Fs{cgY#в! gtajFge_GxRZ8k1n^pYAa [O/~m[z>X+օ۵[KM4{Uk͋°hm3\e7;Iڠ0j*Tqzh_{J+ΠKI..Cm->U8Sv 5IJcdgd5с5 k{V6N%%xz;rGt|l G# s@Z_Uצv92XZZ-֯hm(̠M-v pp=F3ϙVʳt|w=ζS5)?Km~~iVm"+$%X9n?J2mjᏍeF6?x䴸lC1O=k˧MsjF5=Lm;6(m_1vv{3F5" L1,~R犻s)jL+CEY}v ڈrncN?F{.ç/-򏙙8V0NJ̱eėQ̑4q`ҢTe˫ w6$,śz2?+JqWVE*#5y<;s)[y6^ӯ9b2ɄeӰN.6´#RR.~7]sGO-r?J5lqGާiy`ulYwMo=zb'}NYF=7ZݎNizWNLVo4+*,xVF!_XTgO ic|C.49Fd0UrrN~8, [sad+i=?p~8ʚEܫnE[U/!P%o)TfYpN+JWצx2RjI 1fh~f2.!|6 >Xcs榤jje*6xcO5wrQɲUG%ubn[=Gg&߽dn`(^7X_1RR巟BwE1}݆#sw+Xn<:#ܤ} OBL<9_2ʻtzRF:v=U][[)쫹~oFɤF|^ܳi$j[vIm yĞinU(M٧nVi#s֞R 4t$`TUV2̀v#_Ttn嶵N<|@r1t8oh_k䌶dswmbdx8洕Ԯ56Ny9'[cV_yy$iԔ%9ON~Y5[ȧU_'Vقy䦩=228Z%F\G1Qiw^8p&lpv.Ic|TC,E'%[]KEs;U\B+RQMR4E,Ѧ7mB ۓR}8aN"[I .pR~zvC+.S(ެ-`--|dpy9sS~oJt7b)Y #9Wbv޿9Uis}~Gdb)][ԍRCHԇ犹bX[DT)g'q϶}:Ԭg-H뱩ڄ4߻dI~VZZ|Z64-dU剿vݫpw𿹒[Z4 vdEۜhQ6o4c%Q[U= |?L&/mOZC6appڶV5m-_Ț(ӕ 'CTȡ*2zU(9sr٭\)Z<>+xcg-+@*ZZ[jkKd&aH 瑁J+;dsSOߙp|9C24G9Ͻk9:m.zRZqb;FyuK6ހvYFq=>FҌh(e[[d%%ShV#=Ar2oSV$uBkMY.?rȸc2N'R4\}jyyI *ϞAyn+:oe(i+K4g'oϭbGmw&QeSA"K*tNֈTEqg,e}JdkɩpISyz3fw)U{JZ61nW (is|,ȭ,yc'<{kĮX?0VU"q^[D_+4BEV]϶ y~IiXз'q2lR[dZ.I{י9Je^|Ǿ(;j*FWR|zi ׻Xv "ye?zUSHԏ&賂Uct621 x'>eޤ2huc0 ە>Lߌq֪TR\{>ƄZѤaY>awv?ƵnY]jͣmr&Xi&n9S烽qÒRM6Uh6yy[8_e-[d֧e̟ܿizGk}u|<9ƽNnhٌ}cԽ!G`*:=4/qb9eN]IKayv)8݃nʪ>ݱ]E=jɖ3lyK`6?w]!JlE227zz5#8eR'uݫ8rc](:mN>"*Rb Ry _[r˕\Җ+ͷsתmH2Wd{[^w c#X䒿noyhDGs6`1NH\ʣ_Y]خo$7Ѷ܍N?kf$ejt ٖ -w>\'q摕iFSc* @(wsJ++Ey4ƻG8jZZRȋ0a+Ӂc)JTmԯz=֩nA3GP6??r>g'Y2Fhʅ[+נ=UcgQeWg_6hբfEfz tⳫyo+UgYJ+4q Tr+ƭʚT*wie0gĆBuÂNy*Ӎk;>N6rWo)%Bsc6 u&1ec1жѼ=]šS(ߚ3~.e Ya٤Gl9o KM&^{=GUEڿ-K(g?m2dn$'OW<1gV}S:1)VkVis7đx>G.Y_}WMPu&6rU_˒I>DE9ߊhƟ3K]b1Zx(+;h[0Q¹ Ǩ=\'Ͳ>$q{+]]$/BnY/^hN^Ӛ}vg,jb'ylՖ% yt S׌)TU=a+Usٖxʲ"ù38R9)QUzc`%jt{]DSsUR|ЌcӍu0br54l0"iO4,bo";f0nsny`uz+G*G`$1ݬ3FvQNy:VwԕR?&&/m3~npބ|q]W[v""Z=3]ZR;+qgϼj)KP;$_83TeRWQ_בc?lʁ8&y뺥՞@XtFcdfcUU{ER6O=b)wchSһi勇\e%u8fԲ8IB%E5ד)1BEV]#0Sj鴺;FYIH>ӽT*sѝT4YN[[iMkR({HwOY mP~o?k\ҎEJ}i >@y;z~usjuZINMzɶw/cP Ñ>J脕mGRFmy K@dֺa.]E]{Q![jHqolV1g$Ҿ]-o琐g1A\5[^qD238U}1c%(敿uGLԯq%ʰٷUĂs@w:Ԛ=іA};q4ی7^I^vH x3S[niAQKס\- Cy,@psɬӔvuƳO1Vq'=Iy:8X93./ggZGDcI9lFdRD{u'SYQyՍ>N0NN`o9%ɵ68ϥuT\sN.J=>M?32ӣ*zb)ʍ3D8c׿Q$GqF䒱JG eq>WM6?iFR˹p :wEPY#"6FHpUc*xoJmy.C2Eݽ5+*c5nMݡo7gm(FT]V.]6;WW4{ӌygedV8櫚P\rK}E2E5ݓ@#Ϝq\9Sͅu, OҪ#FiZ7y8EJry̕NxK~僵Vu+1vAR&l+xJUm(79\XөJpoil`w}^Oލyb9joETE{8tTJtt: Ą3jO^rIϧJ+{?fܞ>5cdA#4Wm۠SNjkV)j͝!9 ^Xx>rMNIb 7զ ڕ z|;s)M= te+{M:Fs+W$|] :&"U|E#P74q-Ӱarь%[$)cdPx,u*1{_F*1\RaS@ =)Q:(*8X+:c)QESvO*Ktf7޶9zSK~>ei"V30f'=yeZ 裇mӱu ՝ԒDۈOl~Zr^BmbBZ>?t^4a'r;t8DvLo00x_]4yTUx*W=ίBB2|'ֽ4MF*ɝiӵ(ڲh6F/3r`8;z4F,`a1׌'g+;z4RT҄]u2B BzO5?bf}h֎xեl[sX˛Nee'u]Pl+,Ǐ?0QW̕z Ql9#XQ‘Zgq>rwn8Zj*Fy>^~N}SiיWQ4Si#%8j-\kh#f6#ڻNuMkBTqNj_UVtSTif?2Nkh~}hzGXLliF;ٸWtw,yo<9fdjlMrgqq5H&w9T;[hb-]҆DkÃ{}*=;Iw9|KQVz_3l.vKuɜI (|qN+բ־ϩHԫMkS5$S!Oh=rzy3vhQN>/zz3.*Nqн 6fS\#9+hٌdw&k+yؼ)!&5S*Bzk5%JJ^~*RO ;be7Yl\m#=k9^J"Ĩsu: tUWܶ+b\nMiO=ᵽݺ_#Xre|I #޳G548J&6f6U=q1WTpnuTEľ!/k_.C$29ry=)Fwm>g*MOWw ݕ 6㍗<7z,<yoTIKv3oWҼwWn; ߙчPqo4KC+PK+ d`cNU12T>os;C:=b][2_;mǥk֯EB_#RR잉u9زX3? gU`R;0xPIaEdybP;kRI;_']=H<=mNXmFDgd$l@_Z%F/T~_/b+/.ӹ溥;利2#YԦ0nvvZYܙaeJ[G+Y1kIF. ~][Z]-0 s[[ދxtw5m0:kʤe)IhKM9e-߀V5Ƨ3`GW5ժ̗vˆhwYCzi܃CIͬNHU^>֡SJʶ#z=[=G:"^_oױ1N59{ZWƺ Lѫ `s*f D:5go'bB+{i #Cwn;!N9vWRJc~ZՔ$B{V]G3$Fy[J7M۽0tJO 2lnV#TV8|J ^j÷hu.iڮ7˻;뎣ͩMTK9W[M+ b\pGV皻GEz8嬭ϡ|.׮W['k$a\qq~GNtR6RvkM";kiډ#(x{Dp+yң(m۾xLj"ǃg2rozĖkn(`` u׊K[ThMNՂcc,SW}In0Fd?/Q]vɌw/Z63[ 6[=:eksԦj)! ;*/=w5|QՑ}1 }|ZԕԑZrO7 ~yɩѩ+n]+oF9{*Uc.U}4>G0:"մӯb]nl>FC\Μy'mV} J+2S`GzU*Skous -0, h3|[1=Fb&nXӻ^GʟŶH_k1\ x|<>G[S>Nkwx°X:wu :?1d=AXs+TMT(^K]<י azJ;כIk[u="k(TմH1l9# YT\{C*ӗ<#'vwa|#eݦ_vr܆kլWGOM|v6\y-~lSS~GӌCzK.ėrֿu㧦 gQtp#RV\ݸ[v+ *w/7ܿ{=ͪ*V>TSQ]7}E+^GU{K-ٶn]#2F+5v[Ku]TەkA׈hgM +P,IbH99鎛?\)٭zbڊuw͟E|a};nFXGl|dlfW>jw_/s>/ږhy3d kh֓q^o9%_ :)4s]BfIfe}3qҫN5VC)Sy~i<Beڼ)ƣm\jU:#KE1F2. .@^Ƴ9b:&:/A.9dk!9Te8'q5yjT%#N0,*Ȫn䢔%'.*uiWius7YGYBlMI ^z߄U:қc]~3 P1C2K6ͻ;֜QJH4#K/6hS\ִou{*tkcK& #ml#SX<=JyS6Z mn{}k(g{{ծzyz fSmy<*lrx#귲Q2Bm﷗.|O7/inZ8I-~IdqŘb0yc{t>74))).'c2OA]5:^4PCqH`I8xVUS/W|f'J0G^}w|8jZUBK;jpO\oVu40{8=_NgZ~&n!AY&qEy\Q]3yέ=O>{J6'1. ) aq0Fy+HpʥE^R X"m3Il̻h^JmMcuDW6DwlP(Ft;o{nSt[z ysӯJ*(8E+F6tuei頵G̯8\=rqqriSi{;4x~Aۤo%cG=3?iӓ+k=Of/gH}}o^o2cXULX֔iFkˣNQk.#뚔qǶɴuz^iZv8cϨѥR5Vm:جU*+Imc|Y`I}1_{J=ϝ^X!nvmF}L؟ZF\uG6?5h˺Fn3ԭN أzt/;$Ypn^JƯ4mcHf?#Y$ {{Vjj(;_Myhf< {GSg)Y\g 1Pɢrw'Fѿ2ź$6ܠ#/=HҊu%vUӕ^ pը'u\t*jOKDvӬ,b}*%indy=M:["<ݹmx9zc:R#->W+<fIMo7N^7F]<2:X~ӛC<Ḵ5[@ v}yz4fxX^)|C=18*! 1׊p3`e(((e1]N~7NrÎ>JrgQq\umصtZђlyI+/Oܱ5-/n.&bc6O )$sӚm+%~sԣ(TMￕ~e:[۴3u/rž7)duU<f?h}j#]5f2Cl%I'z 0ͷ2/ӡIroU[z]:zmX,xiѻv9 .*P߽O+zLVJn WO/ohsѲG]UGvm^<ק|j|/d札ݹX `q_.t'Xc@67n9>fS>c(|]qqkG wwmihfrxbkXsӓqWfL+Wo쯒ח@ӍjnR'(^5I vrr:byW76̘Tt麖ەkxLkrl_3sYi{6oEF t^GIwGdʢxf8bJCV U9w V;<|qNVn te u%ĮQ"6ѵTN; uS 9].i0ۿ#Y[\0z pqϩr32fI&I›1 ch'9=zztv{e ԩIlD` >:_#JXtif%Zjp.ݭy8']gMD]L 8ǖXEnICO_y +%Ķmkaϯ_icJoIsƴ/cFHsb%e)8Ϯv&W͹i6 >cHsuQ1Ij}xr9e YEN3V~CI!w=Z(GD`.hb_>'C=8ܸ֊r6_3=~C*@w[@ 3=[s%rHTfs8kUc+T_Йwd +c8fnPEKDio- "Eg*ʱx€`zU)>R/5 k]ՕNxr;>k7Gٺrj4[eNk9JNZ`%Y]Yd "2s:ϥL*I֣>W4ӰBbt}PzOT*kaIbwgk35~쟼gWNՖ6]Vf^~m`X%$:r?'fwty)cNҧ+2)$ mVS8Ղ Rz4trӢk]FYssUg1EfYeUB/b?©GTmԦVJ&>wq׽oFQ[NjYϒ`Ĭ.n8_xg9_4ԙFki k~VՆ8##?J;ԥtR@Yx_%O>ݻvMR1\}NG -q=R[wl]F|e`Z0I#@$gک)SmoͰJNmKቤP|ʆn}~QWDcJ)b=I&F1Vq/ui3TqwEIUIS?eoU}Xm ^rRsgӊөSUmYLU@'}jhjANRM[C[YtNŶ)*{aq[N2w9cW}Š9WSaAӯZ#66ssR?+\YG>mvV;=J`Y!im"wdc9wpQS&zaԚV}mRo"6BO R>[V7|Ȓe_1h?)=+Of幝iSe:;m֠E|f9 W%HJJw:e:'5{+n0{ |z\>ghdr[|#)^Q*,E=n~'sGV0>f8.yZ#9cOB\b1 ٭rwW< *r[Vԫ:qQ0ܐHYF(S >d|;w%v[ٮ-uz{}o[bYokŅ#aG2\q8=4}>{tq2TVZYk'ٷ 9moɠ'^o^9 0Qg⽹q_Fϝw2ڕe8ռ$ߖw}9a?đBŚwm.o"E<1գ(Ѻ[NM~v[>ӿh7rWGi.cl sH*yy&b+k+&?9Y*uW[ZGMUK_ޣ4v0ݎnzfa*N[NSij[vŽ<6v$;\ݣ`"F !;U񽜿Wc5j\^}2WV ]:5Y ȱ|ghЮ{*5=^]?RjSj)^[]S.; YIo*VnYvVY:e\- ty竖nڞg^tMsû3VXq~q`;+t}ݷ_־y`SIٽםʵɩ'f>p{헺U=|=W,DTbR?7$VR7IN" -c8G>g/??kݬlyi>U~}:kB}uy"mۂl6ArF=NkF7O5lUht>dGC6đ'ʬ[m5WNSVΧ$(w ߉tk[8ୂz Y=Z֧QURW-AK[uh}t>ԣS>1d\-l.#4nA\:=8[_=\9V4<_i;0| ~fFU<}aY3Yl;:+%Z۬\gi`gGZF1yN_F^1Hawvx h9lɭaEEҧ;8Z8xGm喖?8 A##;]ԕ;'#ejv8ss[hZ8ArGBO?u<wwv/U'CkCRX|;Ҭ`$Q=?SE=|^~fnyȓ;\+/4̀(o$zt=N[KkMS n6MK?-4n팒Cm0xzZƼ(gx)^4~m o:w-n'-R1+A򷷗4\Rz?Kv:+/qG $<1#S4ލRWRiefE~lpq=+j{=S}OY5'T|:-celZ)$]˞y]OyיiPŔE]`O玬YBBb!Y''5IE;]|Uc(˖u5RZUX18`Gӵv{Vӕj=>.gUeʪP|OQ1^# Gm~lw%y&OGfټ c< 7i/NS6f1En H Ex'+\FQ1|mhwzd\G#!8#g9JZp}_:5ex3eγ5'q@'"#ebNI$<`c9L6)=:8|I:5ӓ#C=HUV3 cO>Ujy$ZLѬVBvc9g {*8II8fQ:lqE ;do#UU(˛c*uhhrd\ 9ޫ.ICxӄ))L$S5k `|I#UN”=hD'XWޫ[IHwNh:4P#OG& #>J*EJ <9gdͧVMW:ܯuj{ .<9gq׎O0( &ʯ ŁpaO)N5Z՞6g0y0%kg}cm8K=ߕ|c}cºůx[Kmn]Ybn윂9I%Zr2vv{']ߪZy}H`l֜ӵ]n}|!Iִ١&҃``qZ5jkzUI%]7?9ap8)uշZMk^*5 .d\X9ɩ;.T߫8iSPڝn^ (v *v9,\swOoyyhjr3I#XanJq>^Jqߩ?yQ߿s+n;A"XL;Y$u9'>EEV^+~R7~p$xm.:ۊRC2[}\c>9kZvjgi=7JTg9𯕭Nf+=nϘ|lOYjpU\Ac㎣{9tyataq.4deG,4G"oyHT7#9a>{4}fŦZ.kyTpI|+m 5XZ[2+}PƥGˣ[4FszǥuF:Ugs[*2 gu:9_GbM?i $IdiFgnl'a^Q娮Cv[R-%U^n1@ޟQOK/0Ul,|$(coDƹIBF#"qXzs G-u}.# ysvZ>zvsWQӳ_p)Yrk dž]"p=ˉ*W]zzN"[q9l¼|U udzY{U%K>]a%VE`^NpyJ2NS$vi|ͦKvx >wAtԣ(km p[{~5=w6V+n2<-u-|!/VDl(>P}{4}.tMu1~;* eF}я3Wgr{fLg;Y9㯽aRVmT78&2ώEBvdR-+ƛqʮ7vewNR=xySg $3"6oyw`Sdٜc%wk]<;#r'[8I@=̲1d]zLm/t8D7(W,g 1ԓV;fcOk;r$Jj"ؑWr1zq5£F~ʧ+rW$u0?8@'ի.1\vlMcEU ǽy%-TwQ+]9Xk=.ф{)- CP ycOݖ0RU)Z6LHlhQ3=sұNӿ̑G,ȍ.3gk?Oq:uk6]qY{8NކԩMJ H{c,aGRsS$ee$RIqfN.Tq{JZ+Ɵ#FDc0ׯ=;wiK3JxB6vpp:km۠YDW;~F uWDt9FN\iܷ|wd9#LUF2Iu:ʚM7>9U$6x>WDiGS2!6YrWl?&vWIfww,K񞢶"Km4#dHLʅ:2^WU*ekIFmjtǙ/ ܴQֶ4uV"Rtj{@vzJVngN<9^-IU;pJ'y¤cx›Mgm<#GVE pqAj%RP"V}2(vn+$ Ny'Nygd)VPn[w O1'y0`TS5M7vQ-u]ܪ-imȄZ,4?r' 8# )NZrε8y[r?+F6Rƽw%TeIɽޅ{2y_lXumΈ_{:KS.' $lsӧk3s*6kƶ.  ~RO^ս9ԔՊPkcWҮ98p$=Xޕ^FzQ{;٢T7Oz׹B\tPI;15Pi\Щ' ~uy[y*N}u}a Ѥb<oNOhۙu0"}5uhL$CqDyeΤ4o'WD6W92I9ceN;k<ʆ呔6W>Ğ8qrWES*eSm~ )vAjELTw6^WO[duI}+oPE8Z {vi"hy8VRA9#:h5-L[E:2R^ST HYrpqb[qOF[ǿXc4vihۇ+5Q- |-$aX<cv85Vk]MM'_-}kT}J:<:ٖ/|fU\~nuhѴ*Qm7Fȋo9v[ 0HWRQylEgmIu !l@q#rpzv,Rxj,iz6Z5ߏgOJܢӿ^:\まXYf'-Ԑ FKt5*Rx]?[ڌ;_onF:j[(ʜe5dwKuuM?rOLXӥ.a(IOsScٌQ,*Mmqִ}[oRj|Va|nQijsѥ*,-aavgz qUJ.U+] / %Î9Xԋyu8Uwy?1Y^=瞗1r=5ZTbgCIޔo#JŮ$/F7bޕI djXOwy 䃃qQ,=H= x\EHOn՜Ϋo7J/éXi\F.fbDI=ϿL XK-^ 9rnӡ6Şn>EiZRT['V8WqNGe?g_2P&YAdS׷LTѫnE3Z\J׷oR曥A} dm .sl{WTk{-ZVXh_-M;F6a[Ric򊬖7G]Ө4JkvgEj0RO;KƊ>^ƏrFwtN95U&N';E9y-[Ko\GBbgn7F`N\RW4eӿo'!3NNH?JU'۱IZ5_F-o"DZ=z7>c*-zW=B{=%巶_-6ݍ:gsҢnRYF8Y([&j hYr0GC=}9{VIwCe4Y4O6Xl@I}HݍaGݞ!<32Dv#KOq #}/ȋ|nfs=|U{oSnX*\~ v`ܚ(8sJN\lޤe۴c\ndAI{X,$0d,2Ǩ\9K$]ĶHrޝk/{)Uac_ qenk̩ԕ海<7TZIͱd(c#5NI;NXvNsI,1ȻhIҸ'm$^*~vٍrکfiۆ{z_;#Y)Ǚw{auKuVɾa>NpO_C1UN0ZoEw-M"UUr[u֊UF^Z~?y=ͺ}L~_EO'8\~J\Q59in]e>^73mIQsەc cEmu7ۍ h#UoGz~&Eq9BڂWIjW&8,w3D`猜g %Y/vR_iZ_Yb>ۭmN5՛Zm[[4f=͹$Y=}2st39JYp4NϵvSlgN56JȻ\FrJ1Qwsj{\@+*W;'6m,=hVV :ȧ|' cw]SԜOq2Q=5";;";ˑm 1OLz\ҕNknx5*{}w̞KegX䐶a}qJ **sI:pzw؊~鏖Y?*F|3J4Qw滙2On8@c^4s=_~17&կ{F\ܖmnV_R3qjeZoXzԩڧoŃq,4T_-*Ab+n}~=kGڨO䆬(elQRsZV˭iT}P]`IE24nALuӶ+T/mPNBZwyo# # 0׃[?i{fab(Rnko2(NrZ .I?_jt#NMЭa~ïd57Mǒ{:iћ#W_> uQY7m.VMbG"㪕PTV)%+̫ 2gש^4/y;rK(Z{C>ewӏ\\9[4}[yfYd*n;srFn[_ |Ҕ*sѶ…|<2+R*]vÈ(TC,[O(ߟJߛ<,sw~8fi?jOs\z)կ}C)t:*Y2\3_B1vzCN+WX.o=3g{<ש9}^4'ЊHm^u˻Yy>=(ev498ŦِOm1TxeۃT/λ!t:NW4+T֛A=̑KJ,ی~1޶i+rzt*!\?JVQ:j8?&f]݅Uܭ~nNO#^7أqxdu!$IT8ӍNkZ$Uwg#~Iw;dML[,1L ;ϯ/>F~άأsq44v<\FG#8$o5eۓ2']2v..Kmo\?sV^FJ*15)12]c+S h|jXVq֓*ߗW޷W*ig6aƒS¥NY&TUu%C2k$A Ҵ~ҟ,4߇K  V_ҪTuzjΥ:f\,Y빵I9۹&yYOT -־ETiNmZp~n.; Iԝ'4Q7am[zc$G+Q^܁'1TwזuiVeieæX#wΝ:#̞f*wq!sұUHX:u%v xhG[k/n(!-y-cFlJRz+Xk&\wu%)+3[G"nz->V1K(2jQr 7SDoX]4*̱|ʂp{ϭU:4I;85tvpw7\oѥCܧRZY]htZ+q;,&GNG[j2գib.yVJyiO1eAnwcڹ:r1焽#{OJ..U8Wj[UrEYt22oo'ҵGYjt%I$JKd| ͎=;ʰ4ܪT؇ȕa7Hܳ3cd+;1#UY{ce*mL*9b;XQ檦.RJFRq+K=䌱HOޑimC -FuQQ+8ߡn=*]y_eE\`7} Gzlq֌k/oZhq1"DJ`cI_CRme}ͻ}286/#2#\eO\?414ܱ,(YD&b1O WͬVv5&5o.9m-$R gZS4n^m\20 J\/>;koloqrY]I;Ī‘Aךދi-Wc>[ d* qlԡOCZ4*2me_DBn?8R+-;BQm{xىWQh*@!9Tc(q*t8u)\@f0F Ƕs[FuM҅JN1[t+ŔmO\z~5\c$Cχ%']ב&y0iebx>Ƴ"9w".6 i-3ƫ5 u]6̮ںW/ChTG1*S7V}/*xNk,;C6"[ڪ59JV_NFX/̱H)AJFrN]M__H౉a1s8cАq]T/''{i}N55c[JַaʖimSE[ZMXo#s3Ás֣~-N1y->]oSٮ KRtuF]4SLFTrE~=Ʌh%f| X{ާZG/+7U ff7R1ھ_N$&~ 95tLY/F޳ 5S%{hѴ͹uiGc\DJ^zw+T#N9)_Bխeq[sFpY; l)X湜ZReu!xUδ1KV,к- ˌ8Յ2:*nn ozU)F/&Xѳ};Gu\+E[=<Ʈa6q}ͩ5#^RZ&3?۵c'gڊq槽jєhZ16R+x {kH|я26m`C]1\;Itq]f8bFsu]'h19ʔ Z>hC' 88iOaJwWC,I[i.~뎕mbEM=$ěv^9B1sJy\`儀M&V<WU:a*mqף,7s!;3m2GO\ ڞ2QtKUfTY[c,_ eNyr08bTM̚8E;/xZ+Ɛ*qȠιm62 A,֍h~c>PttȶR˃:s^Va,Cw)efarYq뜊 $AZiqkNGguo`憛i;q'wLV:/FRMs)Ms--&ΐEuUH Olk,,ZmJu8]qSA)mh"NGVZ Cc]]q;Km$4*JF6`yau8|-J wQZ18Tz$~xS.Ieat#=zJ{|*_mRt,$m[K륎PRbm#~6 w>:8Z2 UF9Z|2mbH0yjJKGM_ϹD{]ڔixa!W#m]r^^#ʵzQH3unyrmus6נˋXmJWs0QYFһ[0jn7Ӡkko*p:W5Z1t)ӭ>tˡM{phDp$:ﳵq\ЧZ>CQ3DҤ_g5);ڕFWnEk1 ;洍Om%l:_ ;e~uZ1V1+uF\N|xL^SrIIsJI>(&N[,0T:g@%2 ~MӮg*&P=L{pu&oXu/}kf!~\l n aiQ?1:ϞWWw][5^k&A?ww3>p^0j(ɨI_/#>m䁄qy$@:58ʴyK-z["j講}٫H$q;PNt^v#Rw}Hx)^2ӿg\iO& _-?t@bFIVXd4W{Xy{<74}֊ݚۡ/Q5~Ӓ'޻#S%="Rz&|U!J&oܷ6Fkb>=9%o̺hafyZKY$T:S\ܲWEZ=G&o6< mFhز$>RF3Ϩx<өɈ}Zc5|UGAJ^ UG%wji+ZI/-()Ϊ)֓ Y,I3|`^Glg͊Ǘ}?{II:k@Լkj6e {+U8F 7]TZ=jxCi}H6ǜ>Pj7rmkdcR}/.5-)IcHuJ5>X;f'ŏi*[xTa` p: }Mr;9kav릚 6 cYQ֧Z3^S1*^Nᖰ#EWM)e([q9IeܰNvv_Zd|TIٛ`$y)< + nڷcѯ(ߙǭ ɼwF2non3¸W/[tUY%Wp3S\.Tj7+#LCH@Pg4F Z-2Vebv+ǢxFW~ƞѵքȫ2I:ӧgrh:I'✹vUV$m^Q$r6O&zRdo}X̍I>+?//R__,K&9`dO'+$[$'_?>ӥDBn}^6W*,eV{m,.xfV<s9u? =6T~g}i7L2uhԔ@cFéBM;kO/biR*:}<}ݿd%;Xܑ#y` d:zxTwQn)h{Z6Swh3Wwsk>[ZוJxi(vSY,j06ܫe_A_YJ>gքΗ::TH< ˂OqY*~#* [dUӼ?s=4V9\r.{_*piߥ7"EF[WMU' qC>Y{e +5c|[.Ie/l GVQb'\j$㦝]]ZO#Abqd`2#i9ɥcϩqD-ĖRA$IZHHBǻn?1XҧZٝNzK;[w~S|/&ݺ‘|:؏u2,q[hֶZ+-ULvujn??^+7.-d[KMJl;\C@H#0X24YJ֯eWou?=m϶],Fxڊ8Q ~UXVEö3ҧ*XK{ti rێUHVs%Q{z7_SD}cÍ:`gdTsШ^6*QV5gLWF+!8tq;a{;0xXєkx7cs$RLcA9MLDa=VZJ;Yl~,T!C4Q4^:-Fwqxm  j\\d<`{iSҼdСTo.i7,n 8۷#=kGN/7}M)տE|zE۵9cȆG(l N1+3:ҍ7۷#1Ztn4KT{[Tv@ef$c9s_G7<(QԒ\Fm^6j5& +2Ǖmy(s䤛k-qڼڒi.F"-TQӢ.C6YOͻ{}+8RWOۇ*J{ӺQf9q^OM1}GAgysAUӟje*dpʧ-{As-d?ڻ"4jB?3ˇu} }b؆b87Sاhe8ͯ xGTZ(SrIٔ#0$?xc\f䩊Q閭xU5+Z4П\S6ߥ\Iv'Qqa~ #Q˰u~f|޿q V4a}v<\غMꊱ Vܪwp0G nڎxXIhnn0K S mgf|$گm*TtldH'8FwdcL2gKKkb1Um,ў'iG&$ҭqX^#O pye)[E]E^]VLMn+@u>nc:<3Q Y\_n٭cSTfEJq7m#x9;jc[rO2Bۼo̤u#tEFN`i^,-lλTV%ebqWOٺ_&8<}wjYLFl)3b1qvqz.Z|(중,\:j2rЧbb2HCۥmRj(xg[dxAcF#d3Ī2*3WV{g{Kydq N;ߕvh^O)*|eZu6֊@Pp0.O|e47nE r3|WF6~QKLpfcs}:3^c%r񮦰[J8̋iW f_֟絅f⭭^v8 E7٥HȲ[ W'5Ɵ.ޖsg_s,h: \mO1 Q N$wֲJZl. []Rv/˥;hfONeY`Ǩ?Zԗ7)ЕekvA$2;Dc+vFNRXDsd,4ϖx#ڦ"} Fom>[[D`}ڣZZU"&Z%YEO[KC+\˵(olq&*SikgEYC崛6I9*'96ԑ8H#?3]b:U(ǙecCߜBIt#@UUqO r5 #fmۘ#ߓRڌ-GL#VLnc*~Qnǚ|݉%5ܡ<#223O^>o]\勻%Ҝ\Bcp934+GFPsKYeXf?yA'FiT);X4̶#>9n֗,[mS.K5%P3F^ԨlR._B`nw4TfaMI32n,O =}7UPۍL3˒˺I1C28^7DiF1rM|H˼,YFBUpqǩ3ONڽԝkߩ܈c44_IS~69ka-S2o[fc_~Һiӏ:s;B3u6D;3z8暾Jj-W1\I|)Y?iӌvn:cZT]w3k#ȇl[uS}ZUhU.M$c˓`8ԜS*aMJzL&k&2I&79SuKZ2_F޹.B*Yv]v$q*(Ҋqz.cڒdjiӌ}~V;R)D^&7;Jsz2X:deRv3R;N+~cZC0UwjnR2} HD$RM*\|$ZL.[scsQ汤ع_$;nڔ(FݎIS**OüAxKNj^2Ԛa4`WSGBRTarkQ$Rv'Ni':1TSKWu6t TGYͼ`=3؎ǭc(2OZK74.$hRfcv\{9{Ih8lFGgsg>fR;/vZoԎ%Y'5*2ӹMIAeZI soeN҉aN-.V1%S/Z- R$#+:jo3=tm}7s$D?(fvG??Ϊu9m۩ *ڜs$EVk2|>exk8Txu"B1/~:t4G%Suƿ{ur޻9}CI?m`d,ގYKKSXdr\3Q=EF4^vJ;1=IZIT*JR)W~U:o˝M*++LynK`biԔZV=i wcWS۷cϔjE˨3eUƝ>h')k}O_*jI |Brpr0^U;%WIdg[-ӼRUN1v{vDSdm\ҏ4G[qy=C&T-gZ2,-\ u9!;R}/c:xJq,nỈnl!Wmvec#BGF5=n՚kzwM{ck}8=bۣ21n}[EԜoKiF+(%yYlZ]{ϵ/|⎣%+}>e_+rpGFOZ5M;4ennYh#$-'Ɲz[PZD,ۥ#fNqF_FNbu?U|K)pm޶Ϣo?g-Ol7WVqð$|TN30g)WNIt_Vv|%\*TI=/۷dxo6OOgn!) цᘺ N>^:7=I:xz8ҚwVkO?Oђi+TOU{+iOǸOYX[MB\{d]LD*t)Wom+h"v!~~ ]Rk;5|]?,v?]\r֣NRVkV:uu2MF_7ku.M5x,W2"(9/CEnw /Fe{%~ k~.=v yTK%c$H<|)RZwo?O;V`*iӅoN!&tm&>!wgbɓNB=>a9Zӿ2_>c#_Zq;v]>u߇7ˢ5MVU|6m=;:#F+;/׷S0)-;uO-b%ޣs%6c0@89@?#ZMS[B( Nm}MN?4GstqgA1"9ym8J9}_WuPR|mFVKލgߺ}6׮"tiv*2fKa< @80uX,V[?=ʴXUZ+5 [6"W~VM-{k$.EFva& rqϮ{U^;!n+5 c''ӌV8gֿzpe,juŒʿ0a[cBexבIuU!l3=;S^eQ%C#xՋmWUqסFZ3Ғr[آ,>eLߩ\WW񝙶"Q&}Ƴ,*FG9zeʏ>r;ښjMi& 3m=U1M ԧfy2߆SO?VV)Ν7[5ΊWwqm$P鸵c*ї2j# dU!:ғ敐ݑߙrf  y<2_BFBՀ{_3qS>hT厚r(ƾg䳾ɕ|~B3YΤ3rNkV~֐/~npAյ:ro뱾IN^]5#c-J fTT]iF{f=*}}>Eݻ7zt5+8 25'KqSTn߉ÙSYykG%n87co2 )F)w%[ R$_=2+m| J< Qz[9[BzY>`YI;^+9J7[S]#_Zu [~1v3+)ruUhb)Ѯ\u.\j:?jv6x8^3ױ<^"97]}SqK<P55hfOYxWj0GN \<(KV`[~k;V}T4` guҽ/vrJ3U##gjc-2S'ޫQmI!?yU%+2cH~nI='Ƥeʙq)SzEy_ei|bFT`,X|ʪ/;֒qN܉Vb¬h񭪄 xe回>(E'Nnދ4qܻb}W׊Q4 lcq+2"F3*cueښpvܴ6HT`IFG5#nԣF2DiGORy/^`+V\zmoꮭ= ?a_ yBմ%Wˣž{4Ka\(2 |n"zrrRK.rRJQַiz/o!>o4[ v*d.݇5EƬ۵זmK؏U~{Z]?+ũ63Q\6%Ԯ4+P%GBWnccB+ޕ9**UVNy]H߯߿ݷC@񊦯5ӵy$G{q^N:t )RMF3PUon֝w>&jD>̭4G"d^s?ªs{[u>2cɻ~ƳY_I {>c_?X6sMq;NV; WFa'cGOO4=#iڊ>P"*O}H+Ԏ"R*גxImOv=7:FTnS@INJjUJgUyJVlvj#IWkv۴npɝ1s~ʴת=_E˒N^K]v?L-{cPcR|+){G)_:\Ii}SϢ rZU*c3|niGu|fu.4Qb 7a¼Y(>gυJw]|^mw2zڟ*TeB5*XBpp6vF0>9_ʷ65(F:f$UUPY1UI'yV9mR,&C|'Ob=J4⬵eV]=af?w60ZH8YT)s_[-E>\)fn z)v{h'dIw%.8+̻瓎LzTM.vEUK"f^pvz|c>FF"e:t`EPvqgNPM 5>q 5̑|\Ե|kJ2杛V<{zE 9=,jG1ktgSN\]NV)dF5+nǿ9VG8dlt:+i#lB_s{8VTT*Jަ7|{pR&kZapڮ~`OOUF [ک7 5bp99?: |i~V'UX/?J[ӄ\);?̐}2~Xs9*zA浥UMI$T%ihOYvǜuCܕ- |Vqz\?0[;dEl'è)NWBB#_vBI3}w=5q۔%>XU?(sӏ;f]o%DiY>B3N8(ʞ/$˺8ϘQE$ I9ϥL_6%)b6pHĊC:4#8JB#/c5ף s c˼袜#}diTiEɭP|.L1&PNR+(ՙ##Ue?/:Sn]4mWH˛$^•;[3^?RI8zP0AiM 3])wIS6o\T,pX`r:F5hJ1ݳa[ˮdeyB+(? ~jtԜ//si%;纑9_θZ)iT\];F+/͗sc*ԧ+cL>:U$Ym{IʯǷ@J$c~o-[5l]?^=1EJ\ѩӛUbU4#^f-r}s[SGJ-} K#cf '9lp+?i& 8|5Pcqzv7*sɸ6$;g;WRTm,{T(CފW荽3ϊ2O,zqWm*M֠nm+ʭO6_= ԭQ]mX5|2 +ϩN8ݣfonY\$e!cWQESv 1- -.HI&O:W<Y^U+&bܦUft&S33?e,DSKt[o2Ŵl| _jߚc=\XyϕWw-yޞchJͶo-֛Z i7,^g͍~lg?*;MAЍHvBŚ[#$,U0Gק^-:S&-ЬRFLÁc5ӔUJNf;0Dwln cⴇ,-~j"U4Dv897 u^~c팥}+敹[sߟ۲410p=ISZ]c:TuxeɶƪU.t8U^G_X24 0#Hakjtb)^0Z|7_4W!Ь+֢͈rc9/&YP68_L{s^iHURHDb*Tb2@ӍyTڥTJU]K[4th%fq#+FŒ1NMʥc59%M:~0E-29 }yzW4[G=JucQ(K5YѭdpThn裇ʤ{t.[_Oqsnd`Wj6 px׭tѥN1vvo)QMjO=K\2{q!8#ۮ{!R*^_%q,;~wFRܑ=qV(Вqo]|goM;XLN9VgM91(/ZEo^uHI(KJm5žtpz{zӧ*ߩ:s\ԧ6BjFW߇.#و< C)8Jqq57Ze歂mpW)J+ITMMFݼ5O4yʬV> Ru={JFPjgGFu[*ϯ%KGgFoh_-K[Dh!C|veR/T䡷Ƣi #/m7 F gh-k:r\i\ѲV[$eAS68Ү1VV:!ZBkhR[ߩiӫF}UfLRKc?*c[ƌ#@ܯ8<c5;7~KbESs4` aS ;wd}ӡ5%'$I o }ʶ}W%iFZN(uA:ȭpÞrzw둸,eʝ#Hen9îsTFQsS$ȧ9Y-κ5F*.:댻}8f8c] __Z󥇨Ӄ#+ӎLoʿ4'!jS^?U?_ծhF "57gA׭qFUwtԛN1Qꐠ)_;p12FSVW[4^{V,0' zǽ:Um'}~FR3&,xa\8X}OgZRΤyiJ~GAl!&nJߜ *;KIskT}Ʋʫ/3+ǹg[Gr~Oz5{kbur""r>np0s9hѧݎEF{*hbYHn?}+_i.ej*QRVF\MR0s"/IzI#Ĕ!jTFr3 Ҝ>؋lJ5+A$l J7NR/nk<#۷noFQF>u"YY7`WzZc\D}F28 䃳zRh~Ek22H$BKymWEb+Q9{M/lalNOTh.Z1q{]я3fYPvXάrv04yy rP# q9Iƛd}f8i&B)y*TrI#\5SO/_#>Y-.,c@m@Rnڵ9k掲R<6FCܹ'?5sJ\mѕip~O0l Ժк).o_eGֲS>X#8*ܮ\!F5(߿+M{"D{MKT`NZ[!RIO=vO6kB>ݳ7Lړ|1ӕzeF&`[<t¹%)]sթZ۵Ăs̠9ߩ5Ԩ[weUS_+B=ԸVTIڞ:rqEjܼ5Znk%y1maHch38$p@SOXMnؚrU%̵KK?1@$hKc^LN~)W5QVIM<M琉쑑cAq[֎"'kFݴКKi,R &n>N *pG<76$N0W /Ǖ6S==m/߿ae#lmyq^md"1!B*t8Cd5%fnwJP<'ߵzj%%==Vzww^!1Z4j,L$IF3=8:QorkӦs'i輋O)Uԡ/k2:氖"Q~}+JSN[%jGo.ؘVQK0j܎IlfP7 o_Nq]UmۧχhSSZ9/K#KI>$R|n: vFLkAq## 3t=J}:2IY;ں,[3Ed"3Es2;`F]ƶ<ڽWG/5Eac | ԊemxnlγO<ɜt񌹛]+Ra[.i\ӥ>`ul0FJI[F5R%O5#S6}9nNV}v4tX6۷ֹ+F1ԹS5_sF YIU~ȥ8ɤ VE!Uk3TSUľg5˪5-BR2Gpz,oOP(m͵Wc86]L\ye鵰 z~rJzY#Jl6D/F^C_;wM  b8? xޜ:+KNAyZ4#*wOz#7Is1!秦z\ӡuGEJ%GNjV44]W9H!#:a%nEE^iiҐ&(|9v2xtO*X0\՜P:ҶKCiTSAKu*f۹aQ#?rc Rd/bINO<{sҴ{E)T67٣Oy{R2Wv}O^ RVhJJS{kiGp^ YV'sW_K)E9mէ*ҶhTXFƊ9H^٥U9cu_"k30_3-5F1/e(VqbM%0~N1RmDkJS}>O"vGY6a<ݽ1]owsz)k$P-ك4o# rO#֩QtUxm[ʿ1W-dbR='9գ-_eW=j.WiCrt*'"-W?r\WPBn:q[ot̶kR #r2yy'9?k3MM$~ԯ6`mn2o!lQ%V}Uxvx .&5ycRK$ņ ;yx}(gr+>s> :|dTB$pKQ}+G>E:5RKVْ6ͷ?zW\eZkMqZK8vY1Xys]N5q'"k#m}cPq֨ 5HXٜ\0zSuˈ3{lJ"!3Վ8ieSwoh?2T-]$}}x?ZtԮMBV:LRVXq}a\"E{˯Tsc1dӄ=;z[[;$?n|8JR(o}|r9_Ugz7 m)\7' !^|QJ=_uZ5D՛גCYʤ""s4$}7leG9ۥpʤ[GTLc*Sm4t6VWqOjist8>oٱ좒8噕%X8kͩ3SuT HeYQIQ>)ieMT2[RE :}N[Ui2tw۪KHhF_nぞz(b(Ӕi]_I#Vx$>eI+QT瓩o_2qmo*J t9v:ܲ]=:q+[[b>c *&4m>k88IekR%d i J{Z:T(Z4Kɮ5Fg H>J¬ ;5Zհc^>У.o$|`unu&a;[pv#Ga{x]ov5OSreGG]yNNš=͇var=+׫VǮO RMn^[e]FG6M*y燌c&軚(SW-yᙡwmBo0psz4RJ4g}oRV'V[xIL+iwdfi7.2ϙOWc0Y ȯjr޴-)H=?JT*j[ѣSpwUw0u&xvVvU+.ׄueEntC2߅zRNki<_Mx௙ ׭uKB-qR|LqAm̶/"c3XʍJ;:ukSRnsw@PD~+9F^~~22-Nnu:%Jqt65F7b/`"ۉ{4T 5rCr}a'*tA'[ nW ?{QkXJ? A܅*S*Q] (%6~4"7emx$kvs֣lOshn']͸9q EZ-:rS4 & 6z'sJZ~mօɵgp﬎NNIEyJVڰLs}ӆ' =?^xKk{_S֌z?6?j+[};Əy+*2!< ;mxz`¥4f=}ucw= ?kukd1o1U2ݴ)ݐqy}C%8nz߭{Okhh8ˏ+a8\_sI_|='';nGSxQmQm%qt29$vuM}Ry\w}z?E`{5$;`` m``V]:n-O TSp+ݦ翮Sm.Z+n{ e"=fTp\$7g2WMFEZ{k=FSK{y F(=CC_+/ݵ;O,]JR}vZ.V|cS'N) _%:ֲK9(PnөGDF1ܓצ #^ JkQ+Кi0e\wSͧ3FSKD mq8U/&cF":Eѿ8yֻhbQiU=h)YFq$qqק*-cIStZuq~n{,BdTϼ;N5ұ PL<`ԑh¥d>z3J_E:-%Cl(@epʞFF9ȮFO5moXa$J{炿`\w^>JNmrź/Bk˩jۮm՝ӂAmǞ+<mЌV}{앑eѾ9p?5ʼHcw'Wԍ:wy##{tzt(W¿K[XԦZyg?}}Zب\$uyҩMe4켺/ک~"|-6([N_qq2"&Np2o$qFG=:2K(% /7IsƧ3w;0}躞{wP^3u0©' ^:gTRfscthgxQ[Eə8=y:q$s-Kv#o9>hW|h^sWaջo?3Lf2m9++i3?76kҌeLᗳyVQ2(]䜞Շ-:mEN.x놽ժLnLʒ~=s?e6?bke4ќ,0 !Elԍi<ص}Kfl|9>7)V+EERUuyeRsk{'(_";,%!RO;F:5TTμ=:u#g µ͕G'BGOU`R=#[] .A<1 9w{IS?zr6+rc<г|zc&D*|7Lt5גWr6Pc3(Qn K~$M *9& áÏ|cRvFp^vws߉eZx q}T=\`p\J1m?SGRWZiz"y'ukYm)T?1Es=IfSo2!BXumy(F_Q$j]wu{ky-O/,`Wp{כ3-;TM}RuvNϡx_KH;~Um *]_ל}i֖KLMvr@.iI]Nu*5x[Yf6O6.'vWe W`u:ӭN)FZynLy5-֢F-YAXHyA8ʍ/+MN^uuYo|hټ8\t>]a$֋EbH6ћT&EI&+9xJe~D)I[fLJ{ָSH0;pk2tliCܧ/gR1{Y05lc#kF[jwI6Z1X 7͸~uǧU)K^gZn_{^K{v:&WW.+rMEo#_՚6ܮLC!ݒ:QQOF"1tW3g컮OGf]Iko&d7QP9,J|$ޖ8g]J:44߂Ss3BYڋͲI ,lmnj5ra*qi>[*FB6VbFх9\ORUy:=HVi좑! $WesS(3,"8Ucc4/ ۴ o8z8WUEYJcPJݵܿ[xV۟hO^j{ڧ;%4<'es-C(u>}?rj9ޞ֧I[n}} -6]-R0܌v<],MIV<* nYsDm,u&w$BmZL 1~URTrN4ZծRERsrkX¥^ZoNz>PDfYJ̓2X]v'={y1;0@#uYmRIz_F^5?ey+W4䌥 .SE2-n$jFb)ԭ8IdЍsc_dÓƣOK3% AU<ϽN`qւbiL=ɩXOuhtFҳ}w,+\@4~cm̃frqE{Y #[ D s{\g'ȇD빖L++dVC:/HBم#܊ތnէNi#K#o/b$OIw_:rI8Jm9VLHЗ,br ǷmRms8ʗ= ,F[* lsVћ׿b(KSh27Ҷ^Sm'k+۩VVE.|v33s:}=n[SNE|ZeY9+u.h+_UZh<4MQvF;5Q(ur:u9Z: LAj(G>tSMUITZ(\BRH*?+xmWʐk,u-^y~SFXZ5f/4Ix\SiO5˷ůލ\w<{ծ*Q۟z:Jc.vc·06oz0+IC+Tc'[՞UaVfO'k$oY+]̛˳' ɰҮe J)k\ңv2cHvFύyqץm:ѕڝZr{4leqM(fHN1Q+J<ͨ֨Vʐ+ܴ}=+uk[c?jk>07+4‚ǟ_Ju(o;%[fS[ƒȄҮG{wpQIrGN玭5t`$Db*IlQZGƐ~A Pry?*Q'gT;8^/0/*5\3,cэ^{FosZӧJ֚MsI\onEKRT]^sJ1Ú V;yqir֕Ng$\t [{<폏8tF5c&[|V%YVӓO޸WOJM붟qgn + HTq;Nܑj&Y5eַ{" k{SٞXS\ܸ󖍷 Fl17Oje#)NWKbf" ̍pr>q$֊3tytg<*TQz\.oq9OW"hF;0Y8bc<0 w~aEs-QkPRVaHYO߿z4_5yj6O,esZFFI~G/4R*ܰ &Rt6RhK_]C|fR{FXB˹HLmc2S֫E*7}JW^/S]Riz/]֝ @꺧ntoZI07ۉ8 ]6uE1Nu+AUZ\Ӷ-79+JO[N{}_i.$΍bnp w#O^yeZ0ҝ~z_C1d5&k[i<[_-]3.IڴZXZJ-.~yoT-H>M5\v92Gե9VKUeJvvѽM/E:?ojhY+u p98FIlCNrt׶EO ZI^ukRs4/q?_Sj܉E5؝ $1Wqc=ڦ\o2Tt3_NҬ,"dݿ# REncJMOE[ՂkVcdd:8=y ЏQm;73OrO2}=RMGSI:qz5Oۧ_XaXIݺV?US%Zʤe%'J5^}R?h*p΁U}r{UƟ%NԵiq[yنrU=^7.4QБa㵣GBH]R`qQQZ7*4&ҮH-I `\8춴j&9E[I^{O8fuQ8xvFeeݐ{NTJ+E~EH&ö9V =O'THՍJnPS3Dܫ.XI }37Kݦx_ȸEQ[?3?iQ5 NwOj]%v'g(Ir+]K4<)vG ;U{)[nB<[\y,pI89cE:(ƛZ/r՛!(7I"1=hTgugE RJ;b&pÀF:~R FT⦵,Ң6ٴe8-ծZ:ğj5zniCbͪ_Cu$qBgO7m|ElrSNnյ_QԎ bZ7Ivk㶩|__ 5Qe|0x}&[ʶ%7ϨdUnխZ}=ӣhMտ` 8=acm>_0U=(4=ŗQỗ,TI[ |s`iQ3bs⟍>)Zvafd\I]N8=NOՓ]pTMJ6ohZe㾺Ymn 6cC8E%UzyvkZ_Vwy<ē n07BFg szW6(%v_ϓ*+Wzy^O!׋Jb:lt88###ݠ 7ukhʦVIJ+M.u.51r]1^9`k޶ٜQOb{_Oċ+nﯦH+u-dpŋIK1FʝuS~b2C:v[ r8 (8;);5kW-QNSv]ӵ.qxJSQ k8JF*ɥm9i.Z>m5YƭzsGQBt}Ώhq} oCivn$fݷh`Ǩ8ڽ<$ԩS:[-MYm:{xdP%hdw;^r=Jw]:y1?F->q~i0D#_LλY88BkcNm6oc7.k.h+KbiR}$c@ /m*157/[z{SQWd}ƞTI$`Y#!xz\mC8iNݽ ywxo-4k1nWh==+Qt_;<%NTWKTΒBw\S9;Oz T] I Wbϑ$ 6bq׎N94km)rŶ-I7nFVE&v߼\]Vz>nNWZZΜyVtq6AЃ3*U]ьsg^[e y_!̀q~3]TNRR9^\{mZbLrC,,XFt+J9{O.Teƥg=!!ue&r,/ppx x5B4*s^&5Xo吷Jj@-;N8-}sթ.yVҲ7o./G8BgŒE>kcǺ)Eӱs6z<{O)uGia,@wmgNҏ+=f2}En[j~<#ٔ-<"V.$k$0:1:唵Z|(ā$Q g.TJ9˕]\ȫ4̓Vo7c9>Is=AP,{,dc΍]= Mr6MaRe.☷*ҙ>8ӏ-q p+0 N@F{?S\uyKgcݤd|Ɏw9F.5> YE4ʨ(BNoZ啣{ȹW.$*^}N-2|%Jc7<&w\Tx T.aҰ8K\R>:E ٸo<|14Z? Cx\8ʖ y>Jʥ9i}R\k̴Vʑ Qs6NB݋qͻ3߷WNu{8ZJņr9ClO@IBn4VKQCG"vzi5/q+I;D.2g'V⣺1[OAVY[$37+!U dp{ ~aMK~0;ߨmC)z)Ei |Nn(̸fo1=yϠhջTկu-Eh0bN>ʴlƕJҿ:e?_4iΌ<'5eq-&$K4FG^[sJ1bf|.Ft٬Hڮ1*mrRIM4uZKBjrT{VITC) q}+ISRw*FU#tyLr,<.ߘ1v_ynZr]ͽc+ÁӷP:q-iΥls3Q/dugzz溩ӽ59g935j1鱳/eg9ǽ_:!Fd[^5f)L0O}H+G`F8]_2[H6Bv),d_-92 V9vFk(_y$P3#|̭9]kr=!h]o^Du)fzmq/{c̛VnISnH'ͻ=av+ _zÌ8ُަew^cO#e {ӍRoN5|L F,˴.sI?+7;b*sPRUn1%nDesSхql4u/){4`Bc>UХSZK:thqzԷ7-$p?>F%!;,;O#֯wݜS3Jp׭BMJyjsֺpܔjUW{~~n0O.F>&C2 9dmO6T)ԮvC[]G?*cNs•k߉-bKՏl4qlVNжeM;A[:˜ٶc~BQrOoSFIdc'撋Ic[F>0oig<}:.SXXKgO:8\^ޒ#F-WBח+SQ~l՘8ǵqJ}v0iSшI"ȯtqFޝ @SZJw">OFv}EfzG~$V+^ѹYC Ѫg`*+c=9n]IВ`MN% ͐r=%3bݽzzF֒1ITOo~^,Ƒ5n>[ҰȻ|/qI \Dg$ivqEly&vtBkeN%{꘶1Ӥ`+~Sg(E$($vx⹷ } g(7rRJ#|M<g{pNs9ϵc)F^KZݟ!2ʰ]=O=1ֱ|ӒWU_(H́+Yʥk엚+jw D8H#>v^TLeFqjWZihڤ1(Ҽ¼*e-H3ܨaָ/s۳F|Qprk˔\9iv Ynvi\'xj4QUv(=gK,c+X:ʣS*.Q-FIao,ӿ+9SRv]G4,b h&ܑ/#Nmg˯~=O?u_҄I\}a,I_f/*J7Or8yx;A zޜH$#*E5:L$–$c<N>Ғu(ƕjnQM45,u9i'I &6<5SimV"-ac3 lϭwGOh)E{z?!H̾Y݅q$p;V^/io!d鬭˴hg :~5Y+XE7-$SlyrҼ{J|MM'$aj.lvQkc{LbrHe$з Pxv9K_F[T2HU۹L7L=_ִWs(֫S+O~:![v_v #>Tj{Kк9&S[Dy[&O7*x iI96qNmn\[ðea\1u9j˕/uu"+w\wq?,Dev&5N܊=IF%"nX-ʃ1\*7;Fxmmu mZ-<3ssʳtTdo| /6 Ik˭)FWU:4-I^ vUm!d1xc9{;k.^[cpط'۽qʼJ+m_=Vi7!T FO8'Ry1OUԨ6yz F֏HGoțTsƜ*q⻣I%hVhDn=zVtUOh9RJtM]=P.Q ,v8E7'[4Vu!+[r8V˿_m$vZֳ&cTTeQ"b6"VuFG=:ׂ˯"U9Q*tc*N?', p6=z{UJHX*Q^Siq* r'p8=JnQ~SRtncIxYmlpNNVlTJ连H?%SK/Յż;eTom޳R5i-NʕFK\ĺ7J2#`UH#p8Y{5FRhQ dhnKc˵Ou}s52Y&$`3?vwJ4#Rc)TĨŤ?LcO1ƊTcHFQ+wF]Ũf򙶎y^Za҅R۬2coCߚU(S_71.NMߡFႳ$a>Wzl/m~2E-ʙ"SIShԌ_#*]Kc&stYV qZLȬwga^<*4wЪ}͜e96ٕIFn Qٳ'xzu=BQ3L2ͷ 9 {Q>e+ WIY~ED 'ڞEϵYG^~5E8?ҳ&5O($JIezg zi$ t]#?9p+SIfiaH#N gu(TRėo+ȱysӧvR:;ݣdHO8:kKJ&;9jBv}NgP[SL1!P p@;F~uѵםcS{;*It+(LFw+*[H=NA 1Q)9@+ެjcUi q ^+zoFT:u&^Ej\t鞝:SG2w̒H_"RnGj,O /ٛ|U$6s~Fc I|Fg7?"M\ 78玼ºEUZ,=5̱,{b1c<=k4uZPbؚi-5ݜa֔["RE]DpVI{1}.@kka.?xxqW:qf)ԊϹZu&KxhՔHx VѥG-Si~B1MvOM;}7X4S<̓mXLW(5RVii.i{8sIz{{oc侷N,lId޲1tNDՙˁJsI]kV1]^BɺCߒ}sjR)#XTj{hbOfZI.SxqEɽkVݴS#̆]f\ʚrsšj\ԧY$y5le-̢?s1t兊|wr坳K7 ø+9IFɉR{ԃLRIK;a{^H_G0L%F7_-@yۺ2qQc )5 kn^-+lZ\CSŋvk撦_˷µj"_{;DmFq+ӣS^[W֮ɵr͞N>*eMNZ9N7f]n}+*q>"?iX47t\;yƧ:{YPFb3{'IM6>K]$aWc} *GM;w<ьU5O+ 2?u?uЕ劋;(JuqvzekwY" ey Z>5wP)-۽;z/ hqȰ3*b1=sY´ͫ'ʇ,eRI/hV,+̓mEHwm9 Tg$qV2Sjb>JGxsOXḶ_3Ώg!'I|fr}r8;۱6g#ǘ5lBQ.0=2 q֩*[QI+GslRX8dEBq+U9e>& 8[7t rIO?W4IkKǑhi`nrl8,?:#-.rh+N~m6m?ack̕^j;3d)>H 3\;)hc*4aKڷ0kX嵒41Cc<H>;kROc2*˭]c]ΦC>lRTRgz;Q^y I,_/s2ȹFG^0zV\=kE*[4ȭy0V8\})j=B$6X^?GtQ5%&G,c dquHYp5%tNFi7г ,*'dx2G'lJdb;(SȽV +leJ8ӍXyTߓe.ui[{I%}I#nd`r>\}^MFgEk-a%Vd(s@'zTy=efo<9If%m;߃w 5cДy#]tM)/+U9<F<'pPV]S?L%Y\oGɯTWQVm}S՞5vnx:;HXLv9K0( z{Q*WoE}ѶJWWmw__#i6rG$k*$on sОqi}V-nӵ~n]b0-MtooDzE4pi*\1IřsJ㥷o=ཨֱH8-ѷ^tqN7{J߉ڻXZ,)E(qWVrzS)I|?x"7'+˚w8*qAy^eEsJJ}j=NYO%-#ڬON^MtaZRiONuA2'>|`nyHƝ9F__tgEmIΫj'd*т_:`~{#F*J^swȯRxb*wF5gRot8?fMFv2۱\b=FNx+iTlݏW-Kڬ2xo!1.Z76?9k4R)0ѩnv<4i2_m[Nӻ֩Ғv֑j2qy52NWvM^x\FʸңRb& zjrޠ]R(5.EXBQ$6{P]G ʒ#fefV*q1X'}LpM]s YmִM'^N>n]z- EE&Ӧԡ'ȹiw;`Y֚EE;慫S 縮FXF/*hj5xoU-OBA8N=ONa~c S%MYt=#y!'1(FkېF36Oe(i[[=OA8ەۿ[\x1Xƍ&5RxB<`ן.^ItƤjƜF^[Þ]Kk^bA u$kIhTEK>qj[JH#e M6@JI%vaͭGGaw;$)Z=lO?DiԖr1jGI(ʴïL.~8c)SXQYvGÐ>1+IFI/0JRboe܌9ۻ$s{bt#M(oGhy~"w%fKUS8{cӎ&V}ˢ=>JV}~ _S-k4l#ULr `dAXb0qQ[o̷Rk׵OnPf_3h1p'9Gxו*1Q|:C?MߙzoNZ0=hpH`MZFWj3A+}.E(s<|DXɅLۭ=˞ǯӞ:Z4\=,Գ٣㗍-A-gc1!dQdNcQj4m%k]ap Jou%nӺxy$̒;V)>Xv**WĻ-?qTKmIúL˓ؓqV1Rۭ{˗Ś~2FIDѵp0T6~yJn<۷SEջz?2c(i\[}_ƛ?2o>t[Hb3#I T}5>d;w{X!es^}^\YcؿE.-,Hz*(Ԛ}^iũuO%6l["8'}ot2$,W8n:WfjT\MPCsQ^UR!,ܡsIx4cR-_c$ݴ裏v>W#2A+cT)#C)F;og<{j]w8;KYLIqɍ& 9c+ɩ,Wܝ={ g7կ#<kײooOYeP1<{m.OO^O{7mnשa[%g/߉|'ѭoXy*feX/$?79kԭNixpEs-tyOƿ >(xKx[Qe+dA(`2rB=xژ|-:˚j)Zi3F,VMk_k5ݽΡS+x A(qFyn%`iөRVz%Q5XKygGҭ^ni^17s[9{ӡSQ>emmuCx~uwNB55i6Se+E=zvlq5ycwgqaaE>O|,׾j% /jEƟ vHT dQr>Mm֎#NI__5|[OF;8+'u./K}d&+`OIsK0Om4?e[R]G8t'k,*ҬjO" lhPJoF:[Pi, 8+r Ϩ䬪J[:%dvv]GoJ 6W GP + NlaQE[D~a yX F &N 4Vo= >$"lFvz;dTN$SZ)PӮ";!SeB Ҹ}HI'*4Q$BrFv2*efVA-T$vm#ִ{jqv;xV/jϕshՕe??3r}ǯJ|VrA!ACN0JA9[b5#y8ϙ3:R\SouK>Seݿ2׶j-\Jo$Mu*{}ƤV¤/_ȒsFI-gSrzmmŰhVY$bC+1j}w9IaNefžfImٚFl n(q m$k[ӷM^,տ&[j+ii16ܸq5H)F)O^"_5@1c?ZTtCRPmoR-/͡H'=}kT;'H}sJԭw&"ys%$pY\\չ9[Uq1}heط9ioO7/#9zcʾ epguMn`WL&m^]AC^8# N7} &Qf;S!bxm'ZT~AN#]~[[Bg]y-9zqRI|#ާ*P"m"$4,Vh&,7񜍼y޺Fg Tu'Ei&i1_IӜ:Jέ8V|RʚWWއE M(n#vpJ6ѳ9s;.F{ etUkĂ0qs\"/}y.YKM ho׏v7\NU ~UӕE꼴ԎRkv̞X_8 $s편U/Vji:xfog,o,Xž7t.7>jM)>>¿|6ӡu(Qv?8|~'^cq/&tWe{ʬx=+ >Znm+{ׯ/|uJ;xe?& Uv0Jd|"`h^[igO1TZ]%nZ[}]xŖ*[Ko%Z瞻y0x淩 %F4j*;/'(29ӌכ[ {^V0XhOUZ6w9{{*>"6#T~Sn9:ԕ[OӮ"J=+NSV%vLbKIZ̏+2W*v184r_@WT.h?* I2Qjc."i>ԡ!iq&g:~vl,Sv~V}1BNJ4m-?ELlWȅE-*e7mON{/{Ry7?d2}=U8M/O ^Uo_/"k{Y<,7NzckZ%AZ?0--|bcH}l.*Vv([p]sK)9I֐+2**[Vn2+D.Qw*H{gjCJ0]1V$itac?`GPsµ"U#fιQF-̏QmVk8Si>a)t * ps;FIy+BZvnTYskIiNRJ[ ١r9㩤}7"L]U)'@N{B(RhOE,-H{'n { ^QΌ%Ԧ5%8 JI${xR~Ѵ왒*Rt֭ݮ-Ƒ*Uyz==U֍%ڮ:S:18SNnZm*<ћ撻p p$8;U{Oyɩ/gE߹3H&v.JVomtԤ]y0䣒sI+.خc9 ɹ9>tmFIY/62>nzcմ}|Y^Zm|( ! R=6ÎF;Vrswئe|pmE(+KSle ]os.F<r~83ͯb?jg2FK KBj6¿lߴ\QהVRtMB~VcN q&6@>ӚJ;Ke(|/KF܅"t'Kr\_g%3'=k ƥuseN7/r0ƪN=9N*ۻ5TlI=B.omm7HAL~rBv=k8T[^xz._{.j^+`UiFG ]_]uq3Ev=}FkF\dͮڣ4!؂pqGs9R4W}oTeO6LhF[+ ʲ9 >Rps>ZcPzVq}j,rz=k[c)J4q]G#ۻ8'qaƵ5'I#<߼‡ɦӋm>#i(ps\xTRJ&3%[:W4̍3n]>ʴՇ Wz{K䍼8vx^3qd&oTE+FV+JQzkrǕV: F.9rK>M̱˻w uƔ=c!*ۀKUѣ.tSR3<^rSS̜Φ8|H3swㅩwjW !7sU"8ER)pFviks\A_E$;joAҹ9d7ج4\wSF88cbW=NU*0y(m*4-e "&ۀ< s N]]8jsRt$k(⸙l|q=hX[W"4!6MpH$V=|qƽHykq2 Fu"7 1<߄T$]<&8[E? HTU`2lOZ˚5Z0+U4r2ÞIxۨԫ}_RO iz}W($N1#q#9LMJӕ;7k^\ZOnS㽛2 / ŽQ&3cgĥx4߯BTSk+źM;e% ڹy8W.nm54RU7B#Sq#aFq###^M=WkAYNJt-rM3a]WzHxoR 2l__RaMϿuӾUnȬ7gbˎwTT}7M'ќêZRn^eiv4j+u^>*&*rQonF[2&ZmF޹ONּ}I(GN"ݎkeR'fF?YβԺpvKm3Nh |dg^Rc.TN'~d>۲ *}ަ*:ۿ"ܼWfbbp<Ƿ^zmviO>6U]xNUaӧ uj觫\\*܄R8ζ9|U=O[Of!ۻC_3洖5R387]m6(M!Q dVeջyHjEF6.8hONAdӏ8ܽl'XVEq8vn>3|Y~;JQgWN _2ؒBZ+wH~*+1䌡ξf#q[̖Rn#s`p+XzS5o8f3,`i2Ur;5-t=:jKz^}:@ʻYF,FB'9)*9f2$ի!]+ ߼ǖ@/AߩjJ87%)!e]mK~c^=MveRI/A.r6 O҅Ow4Ro˩IiQ#3r7NOc/7si_ )\2!dbxs~ӌe)v(ޏ(tѮeɗ[WF>I'tov}]kCI-^ea囂ISzw t0XU^5%(ׯoPppi.+M.ڔRX6ֽWۯzڽ̗HxMĀu'qhGh{ xzI:IknC? JԤ{ v&wg#>k%<\v]Sܶз^JicB*~c^OO݌^Vt= # :k؊š]O\i:WKMM6ⰵ}i>\q/mq*ڈ?+&7+y5ψuIYrŶl` \y)ǖ1wo^t}+x˓l$*6To= ]X<jQ*>W4]ީ?bZACsq _4nV3cEvyF5k%Q06={W쳪6n'nd`7¾:/#׊J!~TӧσG]QiEm֝6wgxIDY-"v9#gjB:t{z#5lKs2YEi)rF,+}˩*իR&օ6MĒǻWrcסJck+2iӣNo$顏 (oW'9rԶcJ-K)2n7y|GJj,D*ƢwZi`[H|ʑ*39#'ӟzԍoC/m?s8j^]Fk}P_Nzq>n̙S4ZV-nzˎ=LE=YJuM7 >d|3yǟ9&6yy-l=Zt}CZvY&xdg([h5ov^cn[\K>yGl*>b9z֑I~4^/zz>wڌ[jE-oonΈIQ7`3nl`U SNJԃkEQ⻎O-Kɻk pc=J-WSjX{t.k^ ]V]TCA&@`yNVkfMY%o6{dU96;,1aQ^"6ݽ<5Jz5)տ.^vv$kF\g} xqψ_*^/& "ʌHqUQ*qsS[1pDylFRynO<O^%4W:}WW$L/>l6n#T{e^5>u۰$v𷘣i[n}9IԚG hd ^9+X?ӑ܂v"E34UH~Z+D |_prM>*%] ._*BUd` sdv|ާ'*wq$x%TCK䑆${V-I:e+2D$.܅S㊊卒1No_1Iw)m0 8kh凲݆ Ȫm`AӠޢe_Ȉ>4p'&6I ǯz-8j1J촗+GnZ+FO<ן(FD~+iu$֎n8$qI\WnUbxjIIG #]MKmJK پ\/W$&%Rn ȪdLm1~W<+H悩Z6~kBxy4f,ƓNz)I^^[ E v8uK#%w:y .Fq<`j=+lM<ѡfIUăa[Sm8b;Ҏis Us8-o*qz;3~%,KHy#.iS݊3业E$Y&@khDӡϣJgZj3y۾]ēx[JJzӄM+Yt0}7wFBWykZ2cg׹a*j[O\w!Ǯ3ZsESfr\ks<|sZۖ(ʜ9CR23ǻ?^(Qm[CJ":5K {fl~]2ۡ0]C֥x--%ʹ9`F2X[ӝI&cj墷`j^ x )Q nN/*%N\RZ=VZ+v/PqgJIYRtb_<R2zw+bS%STA|s|Gqڦe{K ]Y.- c;%:s疷qXXǚmzZ-kyK M]8b+T_Ue(B_ -g搶9>Wtʝqjli2.!X92qtѩ D_<\R]ٍae2==:Y.V1RѰtďwLgkyu-N4t(<7RN3e%T8*tN)y|$>ƬYQY[A:|j4[os<@ۤj\%zֶz~+eZ zj7Yf-%Utk4c˩u*r8n䄑F+XNҽ;EDwqi쩸]^=OS{tIk*zu[0ֽsJjGx'R9XvrJ39(9ZѤ4`2aFϧzwSd75RQwSҦW [ʍ:qo++Sޝ x-6l+aUz[ӃmJ?cV/l#KGY̦o9>`=#;щ{v\m٭YbY$>~aqҊp6sVRzu]<3=T8O_6NT̝eF͗P#iӋ*B2tֆRȑ!Uh=OcJ;>O(ù鵧ȻW`6TcѺ}!biקxmŒ4S}0Yhbiӡ%uz!&)؊cw \(Ǚkhg)UNfK. Ÿ`W$ʢ,^ pz;4jdeXNxƍ:O]D|NOA?SjC:(NQ!;ONv7:o=r3sL9X)npnu\St;#R5?wݣwNhDQV0rqⳊ9)'ߝ΢-Q<\qY#VpF?>{~[{э;I[U ,7S)N[o RN-[4X$n><׵Q=~R,6dc9ҫQ}ɟ5]VX#9D+|ǡW{Giد}oq0U 6G8Q9:JJɡ,Qɵ_3 ׿c[өJ>$cL7>ܮ8?ׯOj{KS "-C y?x˵K6x9YԔtsӼ֏[Fy*C؅}xUQGӖ3zD$Mw|15νٜ\+FZoG}y pYKH)s@槖{z'=\\#NJ6hu_YHll3I8N̝O)Z1[~In䕚;([sm*Fe# 2>_cW(VI2|`#'=+}^gUJ5%'M/ϔ$f% yb{⸥tF*j3Vk +ĩfT$nDqR|{,mpv,B '?)F&|еrbh(n~oGV./iԻEhbw2F62z~y޳Rd+m8:^fYHm; VGO^pz]QKCXx)oɗEnLUThWhS(⎍?e("rrXlJ3*rOGcҺƞ̲MnwG`Td: B*e%fFF[R&.͂rvgo&_#zRyu&-$gh/J FKbԚ@`*)=9imWSTcR.Go,`ȳH`1O,4_'>xOtct(eN2kS3USܪ]blg}OzQFoRn#6*%ي~?*RIjP9/6/.\k 3$ަXMe.1:wVU֌2%]UUd}3ޢ8i+%)lۍJGM70F 2G+ [CVFJ[68߻7$ָKyKaJt`k+jl$_sӧJ4MxcN]ޥ oFM,oklSR|4C,1][.1r>5MuiAMYu][zrAc іn_ix{:!$ k*}:gR7迮.&VPӶw^Kۛug,6w2˜`$UFMf5+KZQY;[ g9'돥tʟhșɴZy]8&xs*M۰qQ,_,m8y$Z["tXV6~W0!N@3dVѭNIڲ jG ڻIpHc7I N|G#c[1W~ Tkh*[n:`199QTqi-"hQզma V0FA?IJxc[g[r7r8<ΪN*c|]G jurqݣN^ޛ.rے[Ggsa=@9ZT&*U⬣u#19UPHv3ǯR\}X8Z]#j)K =ُ9g82OQ9NR|>ƴ%NNnpTcgs򜎣?z֝(iFW#x~ߑwANpie9U]̒EV̾Jml c۱1*j0DrZtPVD]J7dg5#؇`ݤ&%+$1w)YiNXxя^+ZR *6T$3zsڊq%kϙV"T!H"XmaXrZMߦ%Ji]5˩X24q?1FRstө1rm5bM#3]Emb<x޺c{{9J=oGʷ .7á#tE5i#z1܊hqWMifu֍ZqIs9 :\P 719fW9pԫ])GK2rF?/A<~"Z&zq#QNzwrFUUvq#OG4cOnƜ饷.I{#=41.hg0̬> weSݵΈ(V]F!݂Aiwzѭ*7SۡZُ6xO9+>hN-ȞXFV%U<A;qVӓ[>Zj}Vu \y8*FT+їޝ̃dGwCHǫI\}+5~a]ҩU)̻_ F\ˠW{Pͪoc{6[#UUry5ʟsmONuѐ`pCCGN%jm+"87?d9>՝Jrf}Q[ Yoc fUbpSo+\"F_1dQI=- c-RPF|2G<֖hG k)Rn;[k5$KZu-}[{US_0*\OGQ_/cS2.1r\koݹzccc8VOf|[.ȩh݆p{ya%,k8Tn9oyu!,Z+RjFFo!l0ɷa\e:1Svd1--4۶˻USQms˕Xя%[P ooZQe$C:VjR[z;BINQzTT<7,Lp݈9d׼9S\elVwZ|(qֵJSj+EK] +i 2*6Sb=Z孇[TЙQ_-2Bֳ49h˚荭+;r'c}j:|mR3bk8I&?n#]\{vU "Ɇ,Hz}UT9gB+)ot`*U Us{̔Wµ=ьiŽ/3%W#+21g5}敿RkV<:m;v.$O25bcqy* %sNƦRFgJ_ՈV{zJF:Z~_n(pVc:{>E+@R6$!a"9zi)J:GDI 0c RۊU:6t3浽Rgo0|0qG+УZ:ԛRÐM_C*[6rGq^(]/lߥ/m촨ᱲ[hRی bԫZNStTR8ZX6]7"qwm~a HYZfTl8錊>j-V. ]M [_4]o]g.}-ԩA-oSB I(MްM4TcOik<0rjc(Ftk6'K9sƬ[w~U፣FGZSf"{W3Bcs\j^z輈;oӯBl/RWie7dsۧJuSvTQ/R}؍q$g>jUhԛqb' vpdcu:} uSQc*M^~XC($bα=S8nF#V#`_jKɝ/VpXIRƲev,.STkSPBr޶'xbTF#򛔅e9涋U4CYAk}FGj3hA!N|]\ӕju,:fU~Rz|}IsY,ZgՉ a傫,z=GAVTT}rMjc"%_, >%kl}V+~x.Kx3#n?Jk~ԒқhygzJ\oRJ>O4,TPb*܏+h Sm 1m0uiVq.5[n:&Hgq9GT32[/]sXh `6sV-S ʵ>YcZ9ʑT¨ܧ'WrﵟUT ^s6^$O0xz p:}U9Jd-wԕD:qjeߧAxU2 0q=:tn"pZ_[?.yuTb{o=GݯVO\0TrsaNqYIk^ ZYD[[2X]j9VU_-g8cz}jkrї-)hpqӗmN57b D޹qYӢw{iP.y{"|I M>s\{[>JX|*ޗȧmLqkʪ7u}9+LYҳ0&U\=1vKSlN3vkMO[}$E";\ܱ'|+Wt.UqGqR"߫}#̏gϷ+rAka{*CҖ}mC}0)#•e+gR.z|ȿQs MddVU2Yp\oF<_ۚ]Zk<7&YZKxʬT?0w#iEߩ:ѧhUOUu}CCjMJLhkTJ #yTeR.khpJTվ|O4i l#Xj*@53|^'ya|r=TtmKrw7Bwb8MIFQjOvDׯ.Y=!&Ui&8"3H@OV~ڝmqA[ix8}},J1w\Zhc*۔}*~SR멿`N68njTB>]c}u7ДcrMo3x4rpB\2q2%[I^7Vִd[ˋka^tqPG$3UZ\k&,>l~R9ޱjܞg3U#ηWx NIDh1t\#hkmNN-y$ha\kiTcnuC[^[+`7Ϲy"TMͭzH;VZ"ԩ(%Xb>Rqȧ աWeyJ|W꺯_]a 0001ӥz4q.ܦ/jI{?ΗgAlYyp7-`n0S} R`o7˦Eϴԍj0kZm½n;ekdmyPtq88QvL%('.p˷rPˎ5GmL01qܣs;5k_ܘb!Fp=j|/;u}yFS֙i-kjm't[dOxrtea)%f4/]y6fY|NZoK-L,)Oey Ƙv|tcsQzVg*K[wS9Z`yl%.]=8xY;z)I75~?(wRwv3˛SFozF1yFU,5U8ӕ7n'mI [gk4+J]; Q98;TnOO8ϪΜxy~+z& M%b7YFDl?}u82V4.%jXu:!D[#¡Y^0zwR/)E{KSMw5kdgs4^T?#aWKDm},v}[)]2# [}ѻ9r+j_uwG0]4wt~|oj췁R1$A2B9Þ}=zͱQ[]>_4W_ϩ=GiZ]xds :QW>j OKghQ,0I˽b/q]0*bv>\dF#O[LVkK~y?ƵueFg%ίe$ÑxFj6680]Zz~7Jo#TdNzxOW)N7o^[Kv#ٟ wV^ah?ǰc%I%%睍*r.}ow= Um.Vj(wvm:>sQ+xV30z?__hJ_4mXwy>JnM͕Lt6^oZ۲6TzJVJҭ0gm>o+)o21ǜǰyUg}#K+U" 9{9/_}!DrVFzz浣/zwGZեʥeu |'Eq)ţ0`x>rGOԍl/v>-aw)K[fO)a;c0G<+ZqZ[fձ8XÙ|W_:?k,0#TuF"|F*M-hψtZ6A>c,sw.^Sڻ6՟~g|s+zxic81>}P,̫7<#?N-S\ZViXն͹[1A$WCImT|qZ7 :p5ǒɧdzaXC +DF9,EnNgT| V. lNN49ګ߇巆cFvkʆ۽WN-M/q4GIme#:EK5?*JLβ+帞~*xd[K%O/v[gWߙn"|_鷠YJ+s^ӗ.f(wGS=nKnˡnΖq]6Kr{֓q1j4kI{,2y'{k~'mOrsr&=R(_/lמ>NՎyGiؿchmc8|DtQMd6sb8XnϿuԖʵni]0AkiA?';lcR&. oXbY$@#8=AiU\#RQR;̳܈<ƆL1RygZ,-)̚uhI^YcxȲJ 붪:咧'f{m~3J-;cp}OkNRy{v3V[ZOS^MWq FIubgy*Xu65x_ǓQlxg%*qrNUT-7Fn\Vf'N3g$ۼ3li{Ӎ8TbccU;yH p秽:sb7cJ^J #m6;Yi mUZ7=F1OJt՝:jL\YKrqjsK-7*S\ImmU< cy< st~KOkϸlmlo&D)֓Sot&ZA4QssƜc#.&H_;JRhTOכbī0ӖHcvQ*d)Rm[OĎ[=A'yiR>G2M8hƥvQHkmG皨US2oܑTܳ R1ZPp:_P4C#lH^;qkZu)49S^Cf{$*|+J~ϚȘӝ]ůQ{#YSuǗȉTXQ>N@<}<~8DT+N5[t}# \'gޮ5*8ۡks#40pЂr0zWw,nޥ{HUk$yXgoLjI$;%Z[td24,X+*0zhONsѮiKDזڡ&,!@uIUVV7ry⏖;qrOROO,e%fmQbw!ݾ֑ݗ卉ݐ9ZFT{2xՂOGu3+(z=kj5*]rtFTߚڽ˴vܢ6b=۾_Ol+ze)\L!KM m`1>j21iC5gf3\mLwFcW=nyFVtWO oɓ8W,v'VkO#vM3C)$J:b1H$ͻ28'm<5dynAa;;;= i-{KzFϹTQu?ֶXZꢵYn? /]Ee,=IIm$Ff3& a喓!p= DTΦ"4~.9c5;nfa[4Թ~tasTkQ/*7d>~<o r?-7bQk匒023w5rOB3>wJʪJ6g'O2G2k;1yaF9Ŵ}^06IfR3TVo[fVUo2O4iH裃h.ysi9PM7*m:w?κ>fky0f뫘%/,QNJVV̻vqwҔ$#OI-a]5p?i|gg)uuzywFcn kNJqBU%,:KTG"KUWRQ$齈#IHյHӔ/uEӕpUP*i2ՠH]\[ Wщ#K$,NwwӍ:/R4j T}|՝J|CJ2xUkI*˸ʍi]JeMSBԈ]_ncO]^4TeE$΋J@1xzZDTY7:2G۔\&ڳ֎KW6tqc6ܒ@qW?)'5 ӝSX'ˍ=,rEJ5E{_i~sV?sJ4n{8Y:w;knZxSv ,2 KP:$SzQFTVȻY'#{MW4#/yt7%2oݽ'q=;vWWleCwqVƝ~] \ 3Oe[PrW(%VEH'b8"e;9qSۯ=k"e+ǂk0qj>Ɲڷ]?3wBZk_.FnIspx]-ztgeJa]>Ftu UF91?޸T7n㎵Zr +!Ķ4Giܹ,[בQ\UvPrw/ {mrAs+؈ӕVe!9nq<95;; s:4r쥾ULO:T-ucyto&v,gl\zyv'7'[%춑$Ys=Ϯ1OJN8ԔVۯ14 w *C#2oi WN<>]*1N:jE'<BrzTeyJL9mX.%e +e-[R6tX"*4"Yלӧoa\u*pԒV̙^s'#|V1rl,AlBu~T~Թne˫648e2#n`g.cє&K5e]lǯ}(~[7qA Y+.W8v5˖l4eYn 'p8ǿTeN1WO3n"2l+&ջGcV5R֓$7Ww?4&B(K]242]f\3Q\trKƔi%u(ۦ 8L.3)dZK߾(x^-EYR#{mQLZJv*SJ+~2LRA=wT[o*Wa@ A]זFXXI2Uj[]z]F?>,*1hV$}x=0jIƛDci Pd߷a^'=/GOkصOq {.g2y]jn=TjAK__fڪvƻ01<*T׺X|=GK߿L~mm%KdXnV.v囟>)GW*̅R<# Ԍ銿g~R[©ro1c@8뚿k-)<R&KQN#Kx 98I]nO2|)^fK29#; ҊoXQJ̧fͶ=uƤ9 yQQSB6^ѯѮAXy;>ՍNoego_"BzoxP7 @ז]1'+8C_7Sգr~xƶwn2/4Kug"S9rIיF[x+ron勵㷉V}_EhibY܀ߺi@8̟Na+9hNWT3fM>ֶֽwW|E_ֵm6 hi_qU'=Xþw&Ϳ nOE4ZIi+[6?{ 1O ֵ@匡]NsjkOE+=\.c㤪~"x;_4;bH$U_ @$g;^ֻ)I:y'g{ZuEJK8e7K9*=A9#ֽiK޶`i;9lϝ?i kHVT/ip,6P.|>OJI=eZYaTFnY+{ 隵ȺаmT7 y뇛bXyrɫtU=*R.V~T<%$ G>-3 +L/Q䔮*fϡxQծdd["`OBGvB1Q?tԄ0I'fFMo— gs2IFqx֮5!{WoVկ~KPcŶ{GZ>V9bũ[Tlæzr5atNWjz˺yt3' žR1ӽzXzu0iϯ]Nc U"o{^Z 9Oh~H)9UꔪCOEܻ}==љdzgQmZ+Nw}zR[\#:B LvTcg'o?Oau%dkxZe-դ ,#*q59I6ݼv?5Jg]]xXҮZE@ '?B+:2iFr8ٳ &XKj:Ox⚎et8xskGA$σw=+W'kz&F @KU0onܪCGr:4{Б;m,dH$s=8Ӽ!V{wheYdڬOUpxGNEz6On|WQ"7aOAjTos͗d㭵5-M(bO i;]TkBM{Djb3s#},S2Gp1x?c1?Yn#DUs;ek\+!WPTdc5OҿbqW~zd4Sǯf#~\{84/߁OVޫ^SuhDwycO¼S{ NSP"KhfY F28z~Ӕgs("rS( + SJ֤H'Mrm1xcl.ND+MO5~Lđ泩XJpII$Yi6 ݁g(grҒW'ͻ*5cˢJ,]?2`K&1W{(ӡҗ7*F(OB.0cx(&s:lOY~|͏So}N8e#?-'#wODr=_`xGlr8;D{ }qSRO[BAo71*P͟jN2J4R dDrִ᫺7*Ny$o,aƷ-㹅Τz"deA-$|\XΪ4eN.I T W 0baZ-۹< +65\6 K_w$rOH08ӟ޴=t]ʋ:i;OlU(sֺyj5v6{ȆI&aFe0 ? ^]aSK}JVYS"9\V*GmH~zݣOGnszSW*叻f^U]-Ƕ1biKRK+\e%H`_0:cں#m Qu[DsXK۪#@0N8޴4l6Ə5b7(XDF.?q[(];]vgp9zgUQ٭Öi5:}ƻqx_qRkjtzxҼywZyhLjħ+ǡNksFNI\ecI`G@ZONzjΤzosj\ٷZ.$m`1'}1j%F2n/ON)G^zumj5ia2.'q5ZJmQTWWiA 7lk r8GvKS5i+6߽]쫀z:mxm)թN--?"d[xQUxfQU"S9_jPͼCkeH'X{VJG$ʴ9ZFTsԧeJL6qmgKaNNpd^8S.i;7cEQԉ&,bvUm^zZ##J9^#<#O+yT.Ws5sJtRmGݾeK ?ːlwnUmF"1&ߡV8Z6b#uSZ1z{9Fz#QjbSӟN^QFnUÅQqmyKݍ#9Wt!V@>^NJgm:vJ!F%U1Wodz-"Բu]7(cw>ߕy-Kq-4n[}P +Ϫ+r#̪KXZV7+$|dF~\|qy5)I*{M]D[TFiB-`?JJ1\3(\ TFHڙ-p;cߍyu],{'x.,$!Y n_sǨsE?Bȓ6$\HqNyQPSﭿRJK s{ce;*P=boNK(?6qzFZxJy쯷TYFƲH{pOp3}E* N[jT {`Wm1ҷh (%9^8bf+q4yI0+֧INN:ݜ,N[v~S_Ky}yҕF׵Ȟ5KSQbk̾JC, OU_1=qZoJO3*=tVz\"ZyN> yzf)K*)]3z7 &WipO~S5g'KgC~]~r Sgg$3D4{|$3<8rIA$ں8u9'ܑw,ѿ9׊מYӷoB#v+mQ If98y<ZԄef5JFI{isyyGgQ3ZN^΍i+ḘV)fC"+yc$Tiөtcѫ^p7)mDS'_/k cg<\~"RJסϭ`Ds+/m{/aY_q Jϸ\݀W;N3+*:qRRMd %lyAy:cZ\EiYIYKG'̠p ?JjS/GJQ|ɳ# \cAkJ(n\G^|$b}xjMIAceh7~ 1ЎitJZt^tix1fFWe[8=[g-[u%ιU(̊]4g}ZݩW Fef$߹e~g#<qU{9'- Ww1 tҟ-#S D+ieDn)?s usN0R[}D+pؗFL*ZR+sb E9}y54)H:6Yk_AQrS|Vt,/ퟻ:VR|ڔ5u5eDv9?4/㚏+k)IE/a9.UaݾF y18zJr9.5QkZ< #idx"}\[dyHHnْp1=D#-+Ŭ̱L4?xw|ּFNSJ"qГUmo2L2x< z7+pƍu؎iK!xy9ڼxS at%HlWL23nNNN{嬪B, ֯;\0XXMlV?"FюsRv<TtԬޯ&юE{niq׎3ҪgQ]nuƷ%9Q;&E6r,;G<wF>Փ;z+%7e')Ac)rϖ=z}^Z7eJOMʷ]m~G yՓETJ!E?u9MM4ѽFRGcPcw5Z'wZV*х#UXcwY]=Yx~hЙ<KF傥 2ЃY{l:qJNG ff],{GfRp)J;[nܶ&xYT##<rWo(ʥU7WoE؂V2oSҞKzXŠbմK 7ָ,;X~2j^!PcV]ʲ9TF.#u#ݎzTRZVI+ʝZrN1,[n~qhe˻NaO RWrkԜV"n)_usfWf Hl0bf׾8.*8ݮT]_VjTau{}?oܓ̹fmHܜlNZeFuoImĒzVP eeFG_ҧNx <[&F,nzuB:#ң߮-k3H tn@b5QC.|NMvaF4[ao#tu&kNRF ^eJۻ-1ۼ@x>TcԍNHlgTM9#v甴ZjxtG;IunZ@ dێ1#Q>=OZU%^U|ȼ\q#'*JInDHD( y¸^O c)I%k񭇋NiͿ-!t%N͑=xFe*QK25Іm*g=ԧR2Qn= =l=9$}oPEd+J3q}VT}mwfK^3}Tfc v+zz/KSWRE׽4v#nv#rN8OJ*nz~N5+TMY[mN~H_0iҲV1\צ؜LiVw鹇(Jum[0WjIP8(ʓj?ࢩKlﴛK"o?yxVqe&uuҩ(wwۅF&1*W֧k0)ӍoDRD];*ZqJ4E8<_ε>uBU kcHjƤR]FFߚRb*F+>]( x¦נqnx=8~o_Z{i:/u5R5}keVX Y*@JRSR4V+Bi.lGBpݨ+>4eRsǿɏ͓r@ӴNbh' ˷L}jáZ~ZY~Ck2}J$s[U҇5PN7žӭ%vOʸ[ӔF\cc{VRy)ZQ}XZ]^Z!Y[W:4S&[3*}6:?Y+K',/k՝/5$+B56e;qZc1T_4vQFYU&-̴/&%1d2||qqyz#eMrmI Q/R:v>rc*WRQ>ZGݟΪ2jL4 "C:.ݑ ֒E,=.kEo2{Iy"9ǖ0p0]>4R>W_7ڮB.>\d}3QĹB힥Dͧg3Fkɑ/Rv^a*{mgowOBqU%\X.N'Un GkkϱQ|U{N۵˼kenbkH3y NzzJ[_׹Ǝ*hLw4ךULJ5>[] ;yc8ߛ{uyZNZ޷黎vy&WxY<<0I #= Ah^(׭P啒{}>\duUZZUZ*n-0\V^^9/)TڷB Ew ,#Gtj֭O}|E;u4m(ii9mzWkNvNt#LluFR"ғ2nF8޹m[/S9li֕[{H\le͆:kFOFc9ak9Qghmњv`#\|H$7#JNjۯ&to%ܳ𕮡|~ ۱de㸓;~Qqxzu.I徟ןcϖ[[o8x7zw63G ))JݭCЩ/_-_MN>rB'8N c̻H98'Q9V]r4oJ>,[$_u\aO gf9VvkkTcG[K9S #,1PЀeF1ki<`eaU{e5It8QE&顏ZjO]ػM3byQzʽHh Z8A_yfpmݼY7U8>QǾq+Xҿ6 Uhֲ,^,csn i#ߊtԴR{~aEESXYZ~d~pr0 o ڱu1?T/,|U"CXV`Z>vƭ4}̩xxԌv-kh%|L_v dWdjQO^ާ^2XmT45ό_y\o8xR 4*1{rZ挢+itbWm|Y7{C s`5Z߁ReW[h Oeݚ}@. YU_;H 9'RJ_{iu~xJeVWO_]*Y5qq{^=3Kέ{tku5F+c7CZJKvHc~Fx9yӍd>xXlҷC,k^Oq $f@(X䎄G=xZu%Rz'd{X9Tar{g:MYf|(3<1yob+ D%RQr_8j|$w{_#< e+vym2"Hʌ2zH_9TI+=F5mSu5f#;%W#9gy9Tiݴ'ѫ+h D=,/l&IqU/;_ qUK{c(ac$Yկx/^R_nRY8,pr0q0kt,7=?' VVؗⵏ|] ;hfPzzW>zJ]Zﭺu<3iy1d\Gd$8"lHJ]Լ]糧/>EkLj 2 9$Rw"rU#%k'=ߴ5ov4E Ȯ|Mis%k=Lhm'+jml[6*i \F8$cmSy[t]?gϊ|/۳y~blc `isEK1\q*Uu;/(Ik_+}柢kbBMJ5~01 `eF8J7nӝhT 6nio}Ot |PQ\}oiqjk01Q!MP`;l/=bm64OGNj".4Wektz^7Q-ex'-?X^F?p6B1h㲚78{o)b0xsrkܚ{ﮟ0֥Z"+Ne@S#mTP*k碵պF"WM%m-[Zd?[Z/vTeRs껚Eeu)g~lg?khXQ%2Ļ,.U.>M񒓔m{:=k1ê"CIb)Yuԧm*SY$WZa V>(xBo L7d'8ǽqӄ?8ԍϡ홦J-Uf?gh(ɔ+:ILAֽl"u"jn]{<{|A,w+ -?q\{M}J=W\Z!rN!sn'SES[F<9Wj.nZnzN.O.C;cci-|v\=rP]:0}^8M2ᑇUJ H)08Z1 ԗ~;|f__T7ߧ[BΟ('Mf+ 2F?6?\*|^k[6o*Ӓƛo N7y^[Apd&vS03Ŏ X']|% ?֔Oߊx~ɦ)2Iv%^2o_>~aNk{ꕓox3Epֱ6Y" A7`TZIFin.TTcR-+Ofu;ho!]̍U} 2{#j(Sn;&4֠NuK 7~3:ۦ(ZK[1̏`!1zb.S)_zztom_3ГZF6IO]7g|Myi2']Cu^TvRëV{֔#ku~geaCJh171 .;/r:[niud$.DUC u%cOO٧̵ Z-fDd suҭN7껜%Fy\ZRjZ<(E%܎2=yQM8_Ίt(4xIаbroWZWF7j.F ϻ9UF39׌evh/bF̀v`t@j,o9Iӵ?-TwѶq׹\VI+IYk;#ice#i@x[6 ハZ֤){7eN:-:FGici>VQ}z?y-nY\ T߱Z_%˙[kI+Oq]hFT<.uSA$uNJ,m5lKem/\\pNQJ+㯘F2yq^*~V=%(\ܶ"溹>dWRm8?hs2n4{,B80@?±hoF*N)TFwyȟI&;NmQ{WEluL-?{tbeF ߇|7Ia])4AH;^0yS_/xXyq(7>i|FڜpY̍?Fsc<~UIWO3';Їbw*|/l(掫e#俴〢Ҳ2%~'5dغ|1K4e)enp*֧2_VK6_@͝n9^sFJmzjqO2O#KEK1!Wvtr3HZ˖TR~VLЙܱǑҡ'Qk̘ҕ c2҄ Nm|}Tg)-zTܯo")$B9o´>j|RO#42)Io\iԩd5Xyhc3c@$duǒTքU5'M] fR1Q r88 3netb9hjGciu^e-JIZQVN!M#r-F>8㧧j4ʮOSJAG/"/<⽚j =J>P{925wMnL~q玹۵z[rߢQ(Q\>p77,˶w.UTr:{WF}~穃+_ JB)*~R+^i{5?^ӗU?o-n(~vm܏ZFn6SHV׿B߇n(H,'dr=qgխrkSSQi6ӧY oGgGV*Jg=rӋWjʺި/!B6:n88u/߳&T18[[CThI ֒V%T2g'檜Sw֌}m+ Sou0Y{<z~BvC`cv8yק穀xGHNI&^5+rBHR88\1y5N%x{OE̸J sի3isrSŜn. XyLnkƤ59rNEnؚ1!?ԕ HNM,-.FU_MߨܥhM%Ҵm;a}z qIF]KYbUJ33g894:PVkuF<Ϧ0y6@m1=u?E?zKVj!C "yL}|}8ǽMj#*$$][+h[ҧkN6bRm$;H%$ꊱu*YLG>իt{.rۡ$q 3DT\~4ք[L޴a:j2d6FzݎNq?ʷyz1̒ Z/cmܤO#JRIo4Ez8xͷk/̳cql𮊸t4- ^?T@-v :w1\֐NSݒQQZt&t3"3qEIˡ1QddYY?O_i*u.eZqn̂ vmn#F @?Z#/uÑK^^jL>^\1ZZTsя/kMo,Ċۂm N㎂\ۧXӧ5)I{ڮ!nV8$eO36#~'&Q\盭R6C$ZIYLas㯯]4DӍ*rr~}He:ӟʩK*WUEhY+N˯f Zo{dsөS&l2ǶH@>Sy`G#ZhT{ ZzE KV;\w~:U#kItQeo_2S~Хѕ8f+{ҴynΪh54^eEaDwsIf 99]]95m}b L#9rj2|Ry5*KU~geJ4i5RI>VL nvƢK6I2瑮UY]^{^ZhӕLU<.ѭ=JrA&c)d hRV-SV^DN#*y58Ӻ.?u&gkA \w4ӇuԢ_P߹°\ua2ؘ~Τ}-[yTҝjjK[#X5*=y¶3GZPQ x!knXqVR匒nU .Uk~wIo\ҋWX>R1q&c S:NN2ƈƧf~bOluEZttv5YJ^6Yu4+c^?z<oZ`,kd=:|(On+, KGt޺iƏ52ugMʗ6֦S C*S9tZxTd2nDu2U\ÏsDR2N+Geɘ7462w6~PJgvuG*L[f!I~o0mqPsTrWtD PG=p3QZJPTu}{i'_k>i?+#MșOo^^G;̅6K^q>g~V0!&mW,Fu%"!Vl ֶ8Fryy-#JdVb/Zъ:չ.J8eU] HTeF1'=7Uj:y^+^mFV݊ޕ(Qiػ·NL=ΜcY"۞UmYK)Oz$NT9Fܶ=)T*"apʡW W?K.Eyt:\aOa%{S2݃~\ϭMIKc+gTӗ3Kbd#ji+RvckmoqM9J%yrW2: aV/cYWq߯c_c$λF(bTƴ-7g괸m-1wyoNkJK~MB2R}Z6lm96V@:*EIڜ}k6RB텃mͽvN+7-QQju7{rH8GZn++ q_=gug tmM+rI>:i>=H5Kev rѢV7 2{*N+RC*r0y!y=T=?N;fIrqDc%hkS]$@HB݁s{FT~h"b')8^f)rۛg8Qߟ^1Zrf">TB95˄eWb >`k1Σ~3Eӥ:KØ5-cYcsK'pJYWou=P4z[a@2cgre-1XQdUVF4rqRyքnEG8R喿#s^7#-Z7`G؆kH,StNZ7bUw3I#l,r{n޵qgV/kױFx UzG6x=:\sIŸ35tm3o䞽خj\9%(XZI13nU?SͳZWQyhף63u+))($4Rc1F_a~Rlc/ȹ vfYq'8GXR.e<;m ̲'Χ\pq9D.R8]vG4jܴ{hx890O޴W5 "4Er|=CsIHH)VQz{׋)};ԬZiFZd#O>bTo۞'Zk?ź]s[ˌ&Rr?kR%cɍGd:|nhn!=kY 9>g/TTܚ?FkE$}^g rHA?#+pk+kR08wG6VURVVߥgcetIZ˧gw6 wh:̞{Xb3} ^iϱ\{q)SSVzZ_׎*%Kk(赶&Ƴ&qk &Hnf@lvb)MKQߪ[|D-R;xd`6'A$Q-^ЧNNOvuw _v땆tnpT6:dח q"pG^䪷t#d6Rd }FW:\[S S2SMcZm̲i3ZۋXYȧs6ߗXz"Y~+&ܷ~t~V%ׯGP?-^-ӯ?Sw;Ո9 {̡H4[sakb7hk￭~x/M92+FV%W-2GUVod|viens#R}'NOlȆ\}׿Ӧ%grSi'vS_GFw r,ٓS99b+h֋ڊշۿ?}C`qNrI$z}C_xؕ/$F;vI2q=β~C)9)xṣB0o}4׷_ӡمjxUN7wv[?Kz>tZe{XẼ<51^>eӧO};{wKm㗊WQ3cAr9 hھKeomm9͵Wn[uGދi['zNVM-Ǚvz`q^5xqҖ6šu_v SR,WZ|?_ݲۚ/ᚅG~ N8ni6ݿ g}toK[YOJ*U>7S:ɧrAqTcni#={l(=4GU*Ryp9?yԌcPa'k LT|8SSk[CR|ٔn]8NRM8sti[Xk7V5Ib e<=Rv_=?橌S:z]u৆4YС|j\?rm^yU]v)=rm9K6g|{~<[|N?OҲ? Tɒm-譂Ae'lׇN.b|?=i/&zV'Q1ӧ|wC]_e͂+͙·?U1`8b)$ܣ{/Īx4WKK~h3G&[&XϒTNFGc; ej}QGR!βmGEz$qʞ<x|rm= Va6WsO ^ȭii%4;  >`߁))rgHrB,lp8\al3mP]2eԴٓ"$s6Q<ڝދ'[Ѥ}_uӌy-}28^m7* %(Ue7Kln݆LXOu-7_e1$Up >n?.}j+TWU´mut<$OB/vǚj3?O9Գ}ѳGwMjr:&ܜm1"cp+HŽއDbjB~][}=suGI("hѿ:Bi?zR^-fHZIXrx>I1(rj U'4`.;8+J*MhEIFcAſ,>z?-}NVܳsƤ^L_bzYw5)wEF_h)ndQb~==Yu:=h܎f8^d~ba$T$ x 3W=jե{1RIjy]>$lL2yG*Og>kd8O ʿ7Q+Iŝ>3{>ԋϓޏ7gZ} +GivDfDq`eEJI4ВAҸ[chJRq#RK]th[$3߽ycNױYj44jX܅ռ0vC{%+E~mƩog<0'ۏz*/wwFrQWs2_B1=p3DESGuԜ<*Tr鷡jfeFAeV[QIczДnzciHNvsN_'*FPk8!mr|7#zb(TyYGRVWMnݺʧ3fӣi&kYyk(l}kӎz5=C_>#% (XfJ5\lzs+iWF\J6OqlsCx6~1gnq^.G&UdkJZgb]z]N"B;_^VmK 㞜V˚\R3{EKeUcy+}HӶ:TJ&iZ)ڭsӜwtbq^Ν o%a:+ C&AAg%mivz~"VF51QG" ӒueN~TrBOn<~oGp?浕ISݍ'J©Rwz&BM,׫2Lv<>rJ6B94ebYӴ+7N5R#Es]7`,o2F3*cj)V~[~~:>Ҝ^SӴ屷[pnA v;uLT99t0tCEܱRY ƪ:iN6z3-{xy<)S~_j剷$:MDcXVEn $r JeVZ{te?A"nwcl\gεEM>]/b*Jڭt:{g;HS6g5U)NcZijmiӼ4xNǭc.NDMTSӦ,,B`Ȣ*P:ʍ>IU򷒡<y{Gь5+6$u0 2I"` 0}~%\8]ْ"0v/q#?QM~G穈]"ne0񞜌g<GZ;>I&|Zm2ϡ#9nʝHt7ZE ! mܳnOLuBT%9~+BJCl4=Ҩ̱`#+noh:>JT},ز. 򦽞飅eAkOD*1a•;Ve@y"c|~Sy5.H^nCF4,ef89jӍE&wC5R=OWRT_<2gXƝ^׿ڤg7470LaJpsR^J Oy#NЃϝb77dc,j~Np¥JݝV$K|8xwb>QGLYԾM(Ir=&՟ʒ%ݤo8 qq?rӲv]TT?mt33m#2>C5dOG yy.T}: ן_3^2+iGwO1]򍤜duR|oxՕzy&k)TO!'.[|ίaǝ5euHk9TgyqǡU̮ɭբ-$A4gIq#{xjN1IIFJRow\IUmd+RyBcOٷ^iHbEY)"H eQslrrONʺj4r V юP30>=ͤ;)і"ruڴI~& BB 1wu={qZEۣDIwwykg=y#ұ+Rqp gjukiA}Lpbcy^4jr?zUFQZ9U挛v'(fYD22P?NkRQ]{Y$Vd~ /~\߇W,EH^_4aNoh)ZFFfs?Orz_&~NYl*j7oipc3u5Rӷ_&qtchϯRLKͫ6搂{ Φ*i/;5q燥{+k$v;p@G#{ZF9T:J1\.+JyܥCgcۦG?ZTM|\>:b߽=M-dnỞA>Ȯ:s\ʩ%?zN$[fHX󓓓DjBRknWtny"cl UTgk*Q٦#(a̒d4]pñsf*QjWk[1xSb<ۉ$$>S뱄k'>{yg/19??竈xU2'e-4(U:u8ްNqvPj.kY#3c?0}ZsT<} SON1nBGM2c=\7OE:da#*yw(}ZU(ORf˳\7G?׏VnF^*M7}C[;wo&`**'F*d,=H+q!6GӬ:v8 v9+hԤvO빇֧(ƛ^bȨrI" 8$]K;BckOy -3=J`W2$;ӽkmTRM9+'FI4]ʨ>[҂N]Y\cN)tSJ"7cSSN[J>VK#rxe*>9ZmZj_fY*xʜ˯AwvfKv9ϭiRu)'ce[)Y \eiyg>_?uj2>(8,dLqqڴ29✹g_o/hF\)8^޹"rrm5s (ZUeUd96<玽?fϸN J݅R3nrNO}{ӧ-;To5MxػHV#v?Jv֏5Dӽ/OXdI'>zTeG(Jӷ<`ʇwͼ2Om'ˡƥ9{*<2ܪ;=E8Gl>wm./d{7anXՇ'HʜoߡӍ\"ʳFJM})Er-N+/bnu,F13WLW/zQ~7KGCnPghwտrr}ߘ c${ &55+hE0##$KGIDnuܣ/4~dL9eW$=>eo^kBhmq3!Ry}r=>ִ(zh8I^/UІN+u-8|5ңSJu\-c2kʕ5k~ѩM6ܩ.o\V1r܉b%^\[| v:U0ֺ[;n;|9h=gz> MQV)GEJk\+юF>VjFMK2FX^4cxԶEj{QYԼ>eJ.] 6)cf[oJ ʌZ*soei)(6~mWڴUT}<^U+Iѷ7A\rCţAKcZHX/h;zW<6 /AQUM]ľk3,nV73 !F#}S>u47DXts~'8CLsXԜ'U+:u;_tVZ[ ZSM{nݟo1WөYʚk8F vNHϷn6jRiҒ4`ClU>{`򬹣(r+ay}osr;7Km6' ێO?:G<=E$1u[nSnx?bJޥ8JQӿקR QiLv]0 ,\*5]h?h=>U}uђjouƟNlV4Y;o3^K?ИUg]@_,å{zv -kvM,F;T\7<1^-ذ7bբI7Wkզq:%^%Ɲ=8L%K;aϽzT9~YE4G_,!,ؓ.o=F?Ú)9A7^άEqt#hLjaKcG޵Ny4tF4M}Ɇwn:>eҜeN?48 {qO;nvsS>g1!{(iKxګSt=5V+H+C8JQiik7!1V1vH~y._ڶ'oCycLmY㞙GQn)o"^7rav kǝ q1jjrےtONtka i(?1ɹ;8#qU`Oz99t"w/7=뎤)so.֩QTͭ:haӱ+aHssۚ^L ^݇]`c1ö3W\u:RfNRSѰ>vh|͠Ε~gև~"1۟a.5&6z\fuSJZTZK_9Zk_,[v=2r8{eySԧZ\[м-{m Glt]qyugaSV免9m#w+DB; wҏO_CNN_慶YnW nE-;FJl #+yk Hb|u]ҧ%iӦU%Uԭ#լa ͺ/r]8zUg mm4Z܊3`dV$8R6G#9y^iJdYcbr@yZ)KҚF2`GsFm&?ztqQ_"V1+O^_qĦ{uq-ӬlB,1c {'ãRy}Q˒*u~ŻI.JJhʜץr#J1,VǞyn:Bs[]v/h$װڹjTSJwQ$j׮V{K+G?O|3R]:%lTy}_O vUwtl:Ty}sN¢G;4y݂O|s8RJM뱣c.C6\(EeW]V-͉dS~>ks?v<劔7RN^͊ҳ/XN8Un[p5Z|aFyi~O`U`3QzXyIioSVtV-rIW4rciӄZȹfw, {gӵMX3ZHsnV9Yg=Vq\QKn8ܬ{mfR(Z2l qXZһ4Ffmv8uO^f#1QoT#)sDEߵwq,yxZ<էQ>qT7)E;jkIg p;{QF0e#)ק:\׫!ObBA=ԭEҝTdF,h@VY2<ǧ~ rTtd҃}n"o0@`(qIGm0OK.Tf0@Һ({;k{8naEl[p,F}~tE^얝>v1^Ro8'#כiQjH|7^ݎ>jC*ҭd Y+՘O9~̣aQ|vb5śFǿMgNvFxzow.G*܃#>iRq[xz,O9O-Agׯִ;I'ka5/#+L6l#uQSm*]IQ!q0ͽ(۸g88Bivb[.։Bޣ=JRNZ-N %{.ߔ=:N0z:)+ie_*2yh?^W$2B;8|E;{_֧qqt'cj٥r˹8d׵vVJJT?gL)Ɲ׾05FԬcn#"ƸpN:s\t;Rw_#Z':}K\& ¥c Gq֡bק"u׹ĝ[X|"5tdcD4^ͮ[wX>}YkZEDE M,=0=z7Mc`oFփ5HV*r Μ%%lM t}֯4o\ij:c 1~ tMrwkS:}[׸?ږHI0=\u(׾B2%rxRZjHD9$Aw{Ex6'W;mw#htr`Vwg*M(5#Ѣe"Bw#Zu9a硇>[z^4Zdi| =}}3^n3?0۲zC| #};W*s]_yУw4ܼ; I I w}1>҃w0'܆s,O{4q"/R0yyjXcqOs\8SoU(xꬻu9so@LzWTN4iƛM|xjlpt*+mzҩRxөi-<<0t ;mXF tN}pRVnǣ*Z5? 5x>{R!/wSq72HT|HOױ,,0֚v> 򪐄{_#KE01Xrk<=7{3ṽtn[_ 4Z;3 *qHgLWZqQ^DW叼ۧx%U~y5QQ8nYZȐoE1ng*:>ٍ]VRe.ܓ3Y:u&m*5*Իz#)UUW{Vf;FGVfeV*z֕OZTrk(dD(fgN}N:kSWE{ckZr;_s1tuT~j({Nc5lxsW^xZ\: OEE aV6ӧBF~NU)R' /w_ZıOܠYnxZʥs)}ԝ*P-krT[-L/L#Wdrw#8 cN֩޻ޭiOwtc}zY'o>_ Ijק⣇9֒Oo^^jc̟+!f #Ҏ+Y5k}6gf?iu'OKhi]ؾ¡YxVGce9vGFR8u]Wt0u)^_V]RM_6^L7FO&Tc,Cmy''0MaNQݿ|)J|^}eG7PR\RB֪EΏB1Aҥ[F\o{kȼ=>*e˫yןj6'@akUvxC7trqkݾ튩ZܐNzvG1M9,䷒8I͍Q\;qpk5iԒnWWWc-6+K}Wdy={XS˸;G+% tO=+SNZ>WSSUdnyǀ8E++\)_h` Hx5ak~y$xfE|<{x97nt4ҺK<_[QȒF r0+F8mw%zu]N]|WŽ֖$,Ͷ .x9O\wx2MNNϩTr]z+q}m6HDqrUZE\ܒ [ d^tO_6SUբBxUnjg&Bik9pSCk?7!bWe@ 88p;FMw=jymg4M_E۝5Ÿ>'ĖEkHV5eyfw}9ozt޶֭q[$v^g`CX;,jewIϗ*G8\HҌ[ޏF8 8+ox^ BvO'Ix\$DWM(VkH~"ϣ ][VVu9Y<5z6%0Z!LM`1gz݅⣈mnEJx)Ż^ߏkv=o}%;i/t;-l,Hwέ2BۊFTԻS/ԕ9*~;६Яѡlϕ7Lm\`0%saRkn~?C˛^ݖfs9lC s^H~+ =wyrN=kUaןha3l/`x*G¦*Tl!&K-&F6{g^MluDƔ~ZwmtZ@ndm** 3X{[zXdyTWy׈5[؀If~[ y q^,kS|Џ)y]~#i$b6Y80ח*6i3~hx_^(oa6̻ W3}r0=NtujSkz熭b4+2 }劚MD䋩-#b]ܗ2Mhw/߽-o|lӗurs(?SEpEOeYhg7Sih({]F$3 !n1^.hw]OGsn˽CUnm&m‘'}]V{j2}g7_|8ӭ6*i +*q8}/SU)]&Mnu=[DSuwk}wo^M~ӳ\׍kxZg*$7p0=N[R8Y^{妚?-|4^ۻ이?kwX4Hܭ?0'wZ*`iƞNNGajJiH|iGgopwFP[L3KYy3o4mVb Jxc%Ƥ8omN{${ن^Azt<ǴZվNǡiZY]p8=HJg"DOm +!Zywc9z%I9~*=;Mė̌yp:zj]hOkp9~RѲjb4w.FѠ%w;x 4NkкoHNXnEqŒQ,o.\YqY Tf9Anޝ+QI2 $vʳ~Mv-@JѢͻ>0}ߓWuؿDA^x"Ni7v6~"ɥY[o|#~t8{edS*pZ]tVRdi\g=ӌUB=yRki =܍bD܌RPayW##؅86g^}/ԨhJkkJ]wЋZ׿fk#$ae8vQ*/kz:+$v{[s]7] xnsqq*4'o'߫zwߩJ8h_K}ZO6{;FYwŒg9򥇔%v<׵eOo@k8lnVVe.xg\zJl4[Es8sN޽t_&Ǭ2yS~_ٽZ_.ȼEGRWv1>VP7xգv^.r8Sߥmˑ;b$cAj05Sm$h]S >ГqZyՅL<Df{5A ު˒䑒O\ڹ䔵l:T^Y&H'c9F;Z{,ۘaIh$rqS(N&?RVaqmHN54iS+ԚYMjTGAgrPҺe[7K^搌_.Fc΍%˫~T| 8IEjqxtȚ0Je.̼Tv8zִ}YGN}%ݼ2K/r06SМzѫS_s5+5geiX2LnO?XƧ}k.XJnJRb6J{b#ٹ5R.z2#7cF77#nq=E)aԗۯ͍F->P5 8Uog~d.Jn)mݾR,G==EUFx^j$̭5"ǃk1Ԍ)mZ.:ٿ>$ysp*#'N}Z;O[g ܓZ-潒d 3'ۃt䭪RmFIo:")\(xK{{eç7f mEjKa#B8'mTnFmG1Nߦ1]#hIkc8?OFs4iLDE+( n H;#qº(T\7۔iBg^n y>ZC/\zu=+H9T{+RXkFM$!*989< VJ{y/k?me<ÉN]etUh%neL+lQ99;(41繺-oх @HPrZsiTy]m/S7Z#8h«H+jqf^_UbTA ֬j֩>+ lCmvFᾕφL;˫dܘ.`Clu8=*eX| G`vQ$`y{+RTW+R{vj6_gV@8*ت*TͰ(*mlH姯\+{IeJjK" 6k9[YrU"=ſ4[V,Wr9=ZQ]Pzq|쌴Yc=o.YS늩W =9>ğn/jh.F9F4idIynG4űed.ieIs' `sA\1SiiA}Yʝ5{uiJuص8u H91-?m9;;:#qzܷlöLkČ?j)sYnbԓJ77l|YL6GNI82RndŅn*xfV2syDMƭ;qxrI)J}М/rq_K .<YRGlv<=iNJ#۱O격e~[4-c4km6+cvHXz1.yyWwQCn"ՈÍf~9Tc/z cpwsKnrG>k6ٹxVfwVgQzt6{yU%Unmi穉n-~e-omNrٞ*v*ZܫHG=EvV%Uh+K5'3+fGJ֦"4d)j؆o6%PKsVjZf3ݰmͰnT񒕶/贙P"?1$޸E[:ܒ:6fS1}?ZT[Ά"3khb ^z sVc8 Siڍ>JK3)cx*zۡ*J[2SYH3YԌ:=k%qh+7?uƞAL}j&5Q>gv܌g4h^*Cr:Ŧ$Hٮw0 gsRg>^ۗJJIzuu;x1IbiiGztQOg[L͹x^FG/}tmd?ihm9zuT.o0%7ֱ"@s:GWs+WO'ө*U9Z[+.u$rLc2u'{Qj6ƭ9ӧCq~ޯl훈V2랝s޶¥Yg&[VQǃwkkkoyj̻$9b}}5<_׵tL4[R{;FJgt澈,ѕrp?y'lYJI馆#Z/]Gk:uR#ʬ̦1y'' +zԥ=J#Լ;yg pX>6^S꼾SII{M}uV: ! iď<#+pT~_#Ɵ3|۵~f-$%w2o(V3ۨیZQ9)rS׮; [k#Gn# ws/69{uyҪE?vw_zHWE>>-sfMl>h>^m44SF$3]ÑqzpZJ7ZMKh}W70+Lƫ=i^b4An ig9Z5 ќweI=x?J>h洫]kpH&|I;u9*mjoN2EscJYgm|Up $c5fsgztlo#I3d9,sԏf)Jޟ-8m%v*Nn8#ޢI^8Yo+e nʎNj'b݉4=D#?9s[*.W_p؛2}T1*J<= b0~U_'rvC3.mS{]f 9=UƞjƆ&Iw8MᏯkU7cԒmv'-F'owuf>*Q+IԢ~ɵ1NK2q)|GE:qRUUᐬ0G#{ 5k.]oׯm;̍gNO&I!aK*7tc޴>Z7_Ժ5k]/iUgO_2` n p: jT.ǵ8Ԕ! v ^aA=B}/lJO$]5Yч%kUyrã 9u)ݨM?O^5ڒo“ʄqiHF޻V@=A72iXfE뱩cK-.],vb6q\ּyվk_.PUtݶo='ȎydD*9`^G\|"wÚI]w2K[DJ}#k{(Tw]O.fm*Uǂ+g8 Y{{^" %Qi xkח\<rD,R%B\nCG9@BhҫDմoGgSb`\=_75 N9-][R_L"c*68lzc6hۧmm^7i~ jðj";_>KO ¿m9c_P,TMKli$XQI,>;W~gE,ΛZ·YFFߙ˷{{δa~i4(G64Y/hT chP05,-Ss_*nm^uEӅTRsqf}}v9qU9Ox;M$_,y,"niI[[daA. 7VM1cEO5Ou_'/Z mE{Wi#w7#~K٨ݽKVߦ^ǿnZ%w~go? ۮ$Yv,U@o\{clΝHvw{zk}vׅի'w{_::v%ԚuKuLᕔc;cUq=cݓI=}gRxs^]ko\i:5ݣfUooHp2eN4.G噣Qx;--N@Oaw๮g"'RU $;+,f!FևN9.*{Z<㌷>(X49f |-U9^xG-7QɻOO?Nôӭ''kkB4Ԗ5ayK6 %yZ-3=V.]GC5mdKE~|"u=#U»+sI#y{tc9vwսmʽ: VV˧|4hkwϙ&P~CaOq\rԓMG_mwʕjzFI'ek?'>"}:.'rKJb;~zYE7o{ua DV~VN%%6QULJ{:1Zn4c(H;cttI8+eylO叠7QqrqRS_{[..v*@T1݃ujS(Ku<*X\=VԋQwti?]{ᦣoL\U9o 1߅|+NX_ WK5B :{鿧m7}a<[ɛʜNQZZS9+k]%dwe/!^[>ЌߧE=(VtZ--fY~c)ʢ4(֦Vc4?U+g#𹗳T*Np(ӽ|^A( $rG<Ęnz8_'R^Ѝ;z)tkN[YLlǯx_;aQOC4_ ۈ+0cv_ g+,=:xWQmk:fD_/ cP3^ ҕ6exexg!yc6]wcl9fԚ=.2hު饴9$x3d<׬c$}4:R*Dky;(YTm={<1i.kamd/ 2~#n*)FiGDSH_60e̞dLr8%N^ϙ_<<֝:j0>>C kdmqUF|ۻJZrݾG^??9d]"UM%Y3+=i7m;oe$-Z2|Tgk Fg#å|;woO!,."2J+ɚ>'0)9;@+>RAr0qR8'/)֌b.g#.Iw6A'of:*NvGgo3YaefRΥI<0}GPn{}ԾzmK *22AFqQ,WJM]ZЖ7VeʖXQwe$sKs?#^>2-W-h+?ZZi-<>b ,Qӂr1ּTVs?wً)^pi;'Gٷ ī19<~NGhxTv d_QJqogӮ}^}:qq\TQnBĪ`7CҺ#wR5{Ok2ż*~C=k:0,ت{>_g4:[i`i7ņ~>)-.;;Z: $&9Lmi$#gd`zCڱ*\q#$dncgTr];RNR2eq}XќF.M´L0~BF>1E E2W~ᚚed]ȩcM*oOu&ܼY۝ gsߞ8xQٳ.j DQ`dv Lr;tS)TA4~d{GrVda9#;xT ?#iYTcM+{Y%@#B{c܏ҹ==Q:p۸k3o!P6Ư)Z笧NJXۗ_&4dY0@\U%Sfu)A!CF(`zVR^}>Vvܱޜ)8qJ:o5?1a(g!w0ۑkUr}O>1Mt-6G!UV5U 1KbuBDA*=Թi^U. 7"R xxzz[Gc[]1i5×vrU=< Kp6$ebs$[SSm.i.Tؒ(6F,˻a_2ޠsѻ4 tvS&Ѵ=8# Z(RN$&Bd"u4RM_N^ Xs<{V3cj[G,;|N2%.NY [q+ qs[1m{NH͘6fݸ*ODBb\.ߛ;tSw[ԎxmZ8}F랜*)s^ZqkD`[bn#sU}ͩTe;+%ٷ8-޺aʍ%ŵ)1+,rmcNqVϪzH*j2ݕ$ՒI g}kQ 6[-v̑Vc:n:9T`Eo4=ĪTA^N <nk^^Uҝ8+O2vC o/w l1P=kyN);=SiդMj9^8+kJoS._wD on"K׳ǧ^1YeurW<}Wӕ(ek6qz ^i4G^")lѱU T1rOq֢k=oԩ)Ӽ+|`#$nV8| lĭ/zv\ex qN1VN!8gm۟tn>ےk 䮴F#+@Ur)aϹrޖ쳉'皚tc)k8ʥ>k\h-f݂G ϷkR-~XxԖ|h8 ANzc޲eQKcaղx. 1OZN2f#N>ioBNHDp@[q`WZy<6ѮK)g%~Bq^]Hܡk{?k'u϶;yr:bF#zf|=9I97wy?( U)= #tdFwKbRf?{s+9ƥI*҅owՒ/q,y~ׯ0u(ӭ5k[MzuRX6|=O]c̹"dN;R'`囵z,RLy^1Cv)fVl}9QFgZjRB|r$c]iԴ8jQN,eqqȯRIJOdqӔqY_yomܧ( $5SEIGU?iV-gO̫܂q^+ QLn#̖Acjqމ{M%/sJ4ֆjp iO r'U){rI*Kj2Cqǻ5&ScxYSegjdt6]Ltg%Nx8ZҔuO#W݊7VGw# &q׊Z#(Z:Ԧw2;[.@e\r|ѕN.Ksq5D?v˕* `zc^do#iQZ5o#y(MrJD~#?l6Fk-7S(17JΤ#RϩQJ7e6?n[xY$'<5!bܝ~E5E*4.A$q}k5 J΍/ⶒlt:%pi V3#N3ºZilҝ7:Ri%uc_[Γ 0>f@?_j狓$3Ҏvh]Asl&ݻʎƵ( #WǘڪLQ(Q`q\۰8MQv9"vJgKznN^w35+K߰ϸnQGs(Ɵ<Tߥ32&(` >5J|N[?Vڻ_Mu%USX73}@!һ},U*O{p5]Fn'e)G%UOv;3:VL-~s9Q<˓[S}tӣUթQJkc=XInIC?qԩO]NR㥗KjW~02nmBvh_m9>g޸sr cJV O=n㯾wexlMH=:Z]VIveԭnxypDϺC~~RU#E+o""Wś]F+iCVeӶKd3<@v~ +J4N_R^Ji^f!iu8 {qVR*(]@ԐyV4G: 'o9ͣ,OqU/gJp~V&丞a8ːƱnj6S[z[mKw]1*695ڹWRjm$ DyrG9`ֲysTSJ>#ΌI;mGs+|?5c8%.nYsmUݴ~XKѕGFQ tEknc{؁NjtJ4c/b*s˱^m|>=V2^[|cF+mw7ˌaSsȗ[h)}{?&>q|х6pשѳ#[3<߻SB>\w?q{b[#:5ڤ9a 47Le;)ѫ }N:‡4e{2ʻdܩӵ )?zZܼ7ݮ$<$``zW%j1Ir FiߦB1!~67Zu)EJ2{TT#Eriea""hB@f8r qQSQ瓺]9W!uiGsn%W߿>QR1MNy+{dӧ,lI g8Տ+v~GW=J1}ؽudmVbLeINB3J=8RJM߭ӊ9s7#YNޑla\Z{h^}ngX֊i+;?wqk:ٮN胣ƫөf<5z2uv[w1QG0Lcֳ)JXz\Ke f}5~5TcW:J.Kr[OX6220O=EXԩxqRSVsZ_ItT叜M bgr M;;qOG1>ƻRtH3.Bx:Z2nuf1B{kkI~pg*ρ?5s%%ecJqCEՖMCq߸wsX5ȫ$zݰXZ٢6+0=1:dXOʟ4ttppxekP##R6tFN*wRc>Y(m鎹V;(ө8hdv+G>fy*ڜ}WRQk5Nx.WUgf2)%r?*Rwg˖Iy(Z{I呐q<1W:jM? VuF~2[cMM $Osv:}N;Lk^6-UVKTf*E\IhU_a m>8cK32ANzoj/)GƜ/Ko["a6VXsHdzgHIY- RgSʒ&TYbS|=~UVvZYKF^hƪU`mG)%Eyl -:G.v|VRnk?{IN?B06T{L֨*`EE*q8y8~WTdv==guOS* m2p=Z9sEP4[+GlX.++`)928j(4gO2+\<٘3& x9ִT"}}4^m;-( n$sϷD+QDݿj"ҹR]!]"mhZΤ9tW:*BjU4KU4pvj.0=%ߩ4b޷3>4sE}##ֵiŨbj(Eimʺ6szt{ǧS9^M.~2X޻7(mꩇF)9+[RkGev 2d#J|5c.]fU[XVE]sSR-S[ U5}wpY<ԀO_ӕ:vL<ۛ9bt*}=xJ2TiJ.&O%m-?zЎS*4=%tgˡpʅ-V\+G~Mub| JL ҌJ攪{uJ\"bѥ[+2Ǘgm#vץJh:mMHnndHDˆ8c<֑V[ )7}j3țDg~Uؼp$ֺ#˷Nt}wڬ7* Hnڠ\|W2vgwN^בGPei˕no7,,X9$(sҲ\7rR}<QWG-Ȅ$8|\ UNx~ir}ˮ*MoBȲGNzrx=:yKtkvyimo#.NW\u\cE>:1$oubE FeMN8f7RJ1v-mmi!T ~2\<}_O3F܂{Ǎn .P,6G9LEJtimJW==֏I-&է0p䐖;{vj:a*Q /gv%DO?t9^d9k ~qv !HI p0:#[$t5Ǚ"ʋ/kӧ--kJK݅{cb'zT#-975$a6f*H#є%Nu%".VaYɮ2{9KGoǹ۵j-^uZI:: ]pW|n%FN#u5OHm\ΥJ'Ꞟ^9F+ 4ɵd,@ke)os:ܪZ72.Bq+6:ÏqXβ{j;kU3YƿhbݶF52p.vg)T|Z]'ء|m$3ix>HF>ѫ[myjF]kw1(guK'}~`rryQЃ3޼ETF8*0{H&s$7xdXHibNx{ۜחN\zKp:%)zWvS¨¸JZ5*=~JwKV坃O\F)r]iTQ(ԙ Z/<猔VU;sZ|bEelƿ,Zվ6:(qs4o(ݺL+sNg9G (nߩh$X0*\IVfnf))^ץҝ5*|zfbB {v;ʲ8bvW1ߧ_ZTU9өLjN{sr-5Vd `J*}50x|~+_25SdOJucRT2jXæaMFNUҽKKП|W揩S9\ڤpԍ9Eqh9ee 28U&;9.JS#\Hv噗,ø9;gr-)T.Y"0#^~m|!V<GqS-T|8e{4R1"6`v*iO{g1j4;Ś*dAIZSƟ*^Ǝ(-pF7.~\U)= *1*m5}w-v(3&f_FZѭ>eoU~QZ˔E҆+Xi%f:OhӲ&xr"F lqڝ*U%. D}9mH/.e_ӏtV*u/s:j* 5%;I#6r߿]T/gg**1m/RWVV;#) H7c;L#>^jU?}Z{gSRFwqQB}߯@8Qwps8=|prgO4K{U)!=Z @a~)$nTy1X )ؠ)fcw5QՎ9\wCg*U1סG2Rq֜~fj]xQcu㨯(]%w> } %њ<5* p2 pky5scykO]xO[B%AHl13c԰{EyT]+[,D\]]M"gǧi_38}l>ߺ#Uڨ&뜏lc)tWG'-̈fl:c'wZq;8Z+ٽTED-O%N^GS uODQ61EמޜVTk (jKc|jCo-3*zzWy,Ռ},omNL[u{5*?$f!q<*Ъ{:ňqQE\ΈJmt*#/I9Wm)3:#O#>;[Ztηyn)2ֽ=eh~xZnI,#CqYU`2_֧%kK}U:x IZiY[MkFh$2r}'thԜ'4q|uMwK`p=QQkQT['Կh<\덻^Jk=iFw^W,]kh]8CN׶AqA&X򥽫=G<\Gfsڢ1mozÚ}敊"25]M ]G-sZ# #9bhԩRmrxr;u)s~XD8'v+_iV25BOV^~$A{rqlE"MWx:c.t9i4% y\$I&hNؓIQKK)NRY+ߊlXa{9|.= }NJ?fR;[]oJ3c);s+NqFH$(~E{e%Zg.J򏰩-NyKofHi(m[ZdY F#gj1IZKzzzf~KW971I%żl9=r=JfқTw_"(cr?6Ӳ} kds΢Bљ|ĝ$\W%lN"Y(-=~F50)SvN<|(jr5*3~qhڌ9ErOKv"<ixJUUηv-~V] ),`k -J4əkF"Rpi-Smt(yXE@ʬKsm1klfu*֢mvwR8Un3G<3{ۇ=BBbEq@|iezy9Z뾝 | ܘxn.]sOl2t= nJ_;^0OsTP kY-x\rAH=zJ8{)aSi~/S_eZ/,p=Ad pQ"y&+W_޾g߳][[}< oqK :W0=Iy?*8NNmg/oA ޱkQ@9+FT~t2/g$v? ~gzܒ閸fŖ*2zaYVRQFXIެ CU,!"!qMy5cΤom3JӤi^L>qtyƋ.tgk6|Lv~YV5lwr1'^cmc1&J2Ng8ӕR*{M1',?Qz{ku:x'ShT_Ɗ$OȥqHx[WFޝ?# R-E8uMr+q6%\n iNhWRסprktXO!4YZʖHTo@QSgNS䲾從,dSUJO]ϤM"VfU~ψ{g:5*9E]%xZ쎳tw/4qƙHG^g~чI/qeZ SM~Ehfw +o*aM#tT)_]~=lDkaյv6 ^mn~rn\\u0]zjV{hkzZi;C98zW5z>Zƭ {/~kk/ѵ &u+ ` ۘN{vt`}"/GP;_)Y_%3F#D)F yE}8QRW{yx|^ .ywc˭^[gӦў#Z|Yjy2ȽⳌQY:RKsJ.B~:m̹+FM hYzԍJmݻiӴlgګh^3ݷ2FѧF{.yVhUIӃ~z`4F1g4-QNRun@Uil7y#˽ﵴ1j9Mmv/>XU%X?_ZYIMmTjIr?v6϶kh/Ve*oeԹ gOzcgSFjJqӿO-M iVe9a H;D1Tc2kXhHٔG2=kb](8ꙭn<*1߾GJuHϖUp&O]:;ևȖXLV^AOvQۡBBlOR^z #5X>Vnݕ]͍F;;M1OY  y9gxKN\OOpk۳FcIFWFQ~}.օߞv2n-滏ι#~ＶJNu}.PR[i B\p}CDcRSzw=iTq[/wX1#,iJP>ixIfF{.Sr>:kՓN|Ļ=JU"U.#(o>tyz626+i7tX~}L\j|žG4tڔzd\H$`"S^U:h1"Rh HP~R69鎾ņʔۯ~x|]:T~Ͽ4#P}hXG"nNCqPJң,?s_G]4e֭QrNɽ鮗NfH'*2r>>Tkv~ EU `v,/ >r'/u rneB홑UINy=9VNJvZuJX(Nw4wV\9<3ienm\sh[^#^_WsoϪˊRLHG88#׭LpK^4EK=]f8 ͝O 3ֹE95sҌFɈ% BmXo#)FTuJHE>z۱~^-3?"B.P;9eGݩf6Y#S%toiKc5ZR5{"hEEgI rpqS.nmvce= IJ*c.]zvwȌWrS37PouCQO3<|`9#>Ÿ*8Vqe*SYo$YEϗ4 >Qzct*~-Ts{ndOu,4-$4(~=5tN}\-e}}L+4nEM?}9q[)i竈tM/vzZ$`#'#Η1z7^'Z(ևTqTF^D2Upfn2ݝ7̧7o+g֎Ch׭=*hWefwqx6*+-UXF2&<{Ӗ*)-z6e9Gqn,UUxNgnW$[U6@烏ЯfmN57݈c*ﻹs\cJ}4Y=z#2^m?):eѩV5]ӧLU3+_4ԫKcΐQ&H#Tq9XӁZ .gz6NYw'X*qU^%u?&pT9<NNvaQԞX$\4#3H#'[7G4#+JQ_OB$l=jSc}z49K`<(~q@}Gz((ԧMT~~n#q ۞*TM;zЗ0)'HHǖ`gqOӥZ:#(S2k]݌{*"_3/8Lkj|YyԌOEwKI-̙KJՉ'cA]g̍ГE y>3B6PJ)(72u( đ;+]i.iN9pϷ) k>cMoF%tsS*掗cPUYkjOu%dҍߦ7u\{Z^ͫJL姊Fwˆ)m#wj(_6q~wΛU[#<ԌwOV?e*S[Ѵ F-mt!Yejd9zdB[+uV̴ΪO^WgzW7-ogy +5gJs4eޏrVr Ak5)-:sIAm,1+Fݎ=){1oiUY$l8W(˕s;VhT #6jz(NGkO )TkNLXMdq[{v{j$K)wPQˑ;?4,ʓQ٣TBEz9?gFޙiG\})YqE]vr[SiQ*ٵN\1ێj=(U" Ya{ FɿnQei.w(7FwG[ f q\qv&)TdݹXّB |3?΅Q򶙤ьS)RKrC<^֜o'/6O3'+3t^akq֖!WK[ͫ.ZEiqc,x:WE?cg'{v8+ŹeԮm|>U-Jfx;%ߨ[nO<}~gGF\;*]G̫V(eggS5, ŬSzK8HR <ʎ"}N*I9=O=m6`ث4JcY[8#Z3NV$5m},P5 _Zs~e9:~`+鰸4h_kz4}=:N>Yz[x^Y"wdHs<.H dg⽈(բkmszN:|;\"1f䀌w'S哕{·ݴkflmC3 I׷J\Vqʤؚ io7(#^89jjGI$**ZKr)Rۛ{7L`nzpnj%-__V<*N#V~9%Qƛv۰R' 7sڦi5_$7oá-p3ͬTho-M"7+Gm'(''5zWQ[Xc&Um}}=Ju=05䳊4t@0p>ztsN{Q4ֆs833Ky۶Ʀ-Rc-&Ic 2\q><.1ђsldul TT掍nM/$ @$`@OZFOЁf@^8%s^͙T qIQ&ڭt>##+m hYܻ3׶8TԕN#^;$E!W$+eϚ<Ĥiyh~mۿw8K&Ԥ98T1g'}M9ʮ>D3)U-J\іƎ\^gtg$=+Ff/cx3ˎX]ϡ]ܸSZ3;Qfl/@d3U6αM I$̡F;s=?5̕;=ru ]\\06$9'1|]9SvQ Bc?_UM*Y ƫxAr{=˫Z88si~#܍ 1?<|# |MӍ)5sis=q-,sIwXSqRlt/-tp^Kz}g|_yl6#Mg;ădkzI_wΎ3/t#UV6r1 4 ZWm|ۺiiй㏄9IF]wj3 N  c uYV/Oc2MS_WO23x1)G ޹^ۚ/sJjocFCV{¶D08{>+T/zcmZM涷s[7$ÒYٯ8@$qڽѮؚtㅝO~nME׃Xd b$dg89dUQFR "'M-5htI#-L1)`pG`Xh4W #5{YsYxJh_!f6{=LEZxz7vPk11X<:^Kyk]1Gx⅝փcb$Db\ON:QV}tzm>-`jQJIm럳?GE yaf[jaP< q{|qYkO]t>+a^iLj^+MEzI R`yb[$i 2nvm>zF{zx_UԦ̗u7iyq F0cб Q_=SRnWnM|/k cd)Nǎ oQIau5宏|_RXasikk-wݧ;[io.=eJxj8sKEu=\#' $利,x"354I M-mcqCu?޷O*-Z4Vz\8Awo][;nn˲ 1^֪T~"Ue̩6YĒ~N#+:K^fJeʴ_n:@O3ly>}r2Q_ϊh߉"ʪG9y>57m[Xb#()5v+k].n>H䜀I?/sW4[jϗjT:멋s}kH|pƱ3=J*8M7ȯTC m*Цoc߱6󅪛_2ܐ/%%nvOl.ԞVjB|:YtcR!bm R}υsQլ6xaZy8ʧ%FVg|tojqVt~k,݁8##~߈L Z/KrT_V=W'>`0cruNnW+ai`o_t p,k$2qx>wz5[7e| j Ԧ嵑OI3GNݙ`qU+aOS;~`euX Wh)i">FDIpIwbxunr5 IbAw$ѳ=v-={u|Rl=Bˣ˟thePceY bO"14>oK7#eS:ʍ3Ipdڐ;i9 F*lE_$ב6Ny\|<^o jOfl@ R ~|l;Yf]4TQFS|m>ƻihoN4:}v#JѲxvUĵ~ گ^61AeX*/QקZ%'oSI+\OuÍ'sӞJr&P*NKu4M䉢?;:q\؏{k+4.yҝ {4W) +dJ2>$z~=:j5e:\$"Iڻx#zcS*-24Vֿ2Wn8){KIW[KnVnzIEÚJe]~`ƞcn*s.YOb>mYؚ͈YnلR]y#tӱ5Mj}K*\|;ҳ'im,Ѣz"X9G8qNQ%~ôǵV36ӺIWv}bHwF)Z1[io."K#w\y;s>Yro#͍8^yj#!|3ϱ>ҹ.m2Z[ꉖW(jF>RQt0'f)CDۤQ[ g>Î qԌjnU.K]Ysk3I 7̥ZF8재OaYSRQoTgGbՇc]̪YgnG#(-_֧ʡO,%p̘茡-w5卭f83d x'qJJ2Gq72K{!]iUlG #kOH^Μ6O*g.7ἶt]dsʜ̓0VDv=rws(^R5cͳZF`FfTqy܃k1vh;KtL1*JuDT8?/Q Fy# cv%fۏ1u?h˚`ںDqۥ 9#7/€2q(Ӕuo&RnFr$G)"4ng׮L8>M$6{wޙ'ыy@;c8<%zBRP5UYGEҺ88rGԫq\l{[e6s`x6q*B1IQBPٚ==ǧNjFZ[]:S[w-%aVG9t΅iTr% OVbZ?+oފtVHJ|ojA=H'#/799?aK*6' Ԋd0H|:~*q\ֶԦNQ*+>b@U~?{{# Si}嵤f`fpǞ9QRUbʢi>kʷV h$ zCϧQ\N,k;rXgiOҷcIa=*Og}<7Z-$L$ˍ~v:emZǖwz.޿mnAi_GؼJVU?g r~Q˓MYG^kkZI:-^c<2Ɏ=gzUkm6E̜cuȿa{`w4~g3622NyEtƝY/^FVJޥ5=YnY6]u>7ts]ɰ3+0 U{<8*jG H9y@`/NA=kXZ⤛קBY{q#6#R=֢-&ULu*TXuMF5S#v̅\9Iu*Wk|mt -V]Jgehw2H<Vڛv30定y=8{:*q512G%I4lC }qzq5֪ajTQ&sCʹo"|8dr*Vj{G엳FW$#xW 1+Od./S~^D]U2p=o}*\ҵ!Ck ěwSʸ]3$:;VSKL#?JΤ*[V~m2|d qץpFRؚ%(w:M;Q";fVkxuT[U[KXڎqp$p+"dN=gTlӱ'> ޻`@ƪנQR^⾥=Y/'#wdp&_#r[jOW dr zg'p3ZCB6jÞ5{S.}zhnD)܀_?"7B0w ctT-Q)Q_]̥uKoB,rI'ҵeMBOCتk$*=ͽVO5dy|c ; ^J2Mv1o1In.ͺEp:'ӕD۩uZ7._"7T̹TⲨԩRRJѷ7W,s,d1iþzϡ7g>gEJU(%2[2v$EɍyVuVeFJ-=S ]iyI907rF=}*SkBT_4VvyeB8۱F9^yԒMbi'v<">R-[K|cPG`|npJJ^Mj#**2Z{j.$`$,O c?`*j7'd,Ip#{60w>/J2ڍzEңi;yyzִkv92%w^4Q1[ʑW21qkeNU$k:lwՅ(IߙW,[z 2NU9Vȩ9aIuH m9@85jS(+;ϪUۄʏߊTƤC#bVНѳ.XW~Z/(FEF0gߡpOhYsHkzL{9̻Kp#+)Vdz˛/x=|;_O4+Go8;XsR=U2Ob'v{Ak Ui-||6WB#"qʏmFQF7[[vLgޢU%R)%2j9W#̋/+H~fm3ҳF/z-z_k(Eߥ BƾD֒Guۜ ߽qOSyxt,.H!yQQH8=n+Zu!Q,UjSV~E'dU+'O^@QOYjVV oy9IzsfV-;FsJu[ 3cV991չ9UJ)){JҜڷK-Bžm$)-dU)XҸRƲWm}ӔykYIh! cIm\eʎKcn5IYNeM{"vϩ3cFsk}NR\u5܊q%͹o2AF='ӌ'tεwzߖ"@z:d58b=TEfv6{-XE?*RN[=>cR8<67vVmsVswK%3Ys>'O*F.23(ԂU:m%˱cVn•:tҾ52J qe34.DS<hv]eNױ*VM; ,Zlb]øz=sY{vɮ⯆fȧWJbapaPq89N2N[GF+k%RaF7JWk3ln{=9]vIFia# xR]H59 r W茪ʶ$K"w$JO,=bkHQzkEG܎w*ȻX+'1[ӌcRM }"85] >0G'O_Oz*0HX#p:G$*{Zw"*qjvol`.88URZsBZ*b{JGBF)cX6fm5.\WԭTGq J#yu]NJ71v]n 0NthƟ.Q'F!y#6Ld;FV'铞Q_::UяdSI"} r1=Os$L.Wpflm"#^uw*tTT]U.1,'z\Ғ<U[iōp<[@E(E%}{(躮hVDdžNpϮ9+NX:rko %5ki>-q.C<.޵Q)\nmhbyeޡOJkJ: *Ҵ#hQuS^?Cjr9:ad,(@cj{_tF8D۽Yu{~UeˡZ^ʵZDnFXnrUNy{Щj_CRXSs*0 ӇݕS{Rv i~pUd\n#So7s(S\Ғw"k$@n埘'9}meNKnNed˶i?x\/?}+E&yru?rT}YEcߘ|?5^-J* JZ=][gp~/-+5O*^WV*5ǻڧjʜ*{TپH|Q߹qFF_.GV= VujV/mq,EOoһd7ZP.؛gow~?eJ6nzp*o뱜1L$j*U9(um9\ OZ֧)IIKFtTe.si&YbXr$=:CMn/l`O'.TsXI ŧ J:naRTZݯ$ZKm(gS)S6W*|Z_-q2m˱ʝ77rJi3mxns!c<$Gfm[hPeMm1r+XiN,hЂ>]SS*iϙtgSJ !S]5ܜ9?Ҽ굤SDcZi}.[zTTcZ kVjg 7,r3Jg+= 5әynETdo ԹkXU+smꍍ bPv3,?ȮZoN.Ue}6W1?-˳n8YƤOZp*wReTg7Gw'je$-LSj7cEZ@${q\*5472u#DC";umX?:sXNWКrtX%Vv2y#Sj؊1] VhyW̜l~ub-OU}4k[;P|z׻-~8ɩvEJT8>ߍ{4z4tӔc^c,hPAWNU>i| L#szthKe믡"gdQPBp8ʓpסF7UtƌyW*׳}[$+ f)?zKsyF~e޻[>^觯#pK=#,$P)qm)*q{\>X^]檨$7 #f"4;ݸ@NsB?8-LTDuu2.KV_6U3,7gOz 8uBһ2֯m/s.K NcxJrb?:G1Ycfglj[ikT/R(VдBO&N~ q>1U$EVyN6BDg۾U-VtSjziSgj}cҦ *TNSkՂ…R#]Ͷ4C,qG\--ZlMndSk!Ydٛw͌c==q7TP$~`rȓin?]iwO.Z)YI ƣK[vSd8W÷w5#AN {o/;vwH^zUNcѦG+onU>2G q ֱ.eRGnݼaqqK$r%ۜ[hʨ8#$x5TT +F4-,t1mUq$ɝ?wsZԓqIhyR)'sxge!Xg ~U57*t&t I,nm=:0ks>gʽVu&O%Wi exNzpwl۳MUd35FOrm̷X]s,rvaڲ*<ӧ)IOR3c`y\ڀ`1Fq+ZUZr\pC""RJ;0瞟5eNuZB$eOO v$DYyTssV-Z-% c!%'=;vYΤ*Z ElED򥡍ِ.݊*cFQb8v|3&ߔg#q9Gc[P,R8hﵺ #dSm= 8ϧV#ߡjA*iԛmnv2]G5m"w:aSm[ʳ4JUq$0rsR;GRV2;gO|s#w[ԩ*ގ(IZ,[*)8鹛`us]c匩V+j!`7OުZܚR*_K ۷[}cH{dVQ}J^m$.cB@YxkN4geq;6,4&3q"ݰOt[FBtiԔe']MluGKnUnsמZBNZ3L9hC zFGSXrg-mAJGF%[w/`5J<*QAZ'ˀJwdz45_~V.#yBCg2;_,͞cww}#O3;5͹RW>3fo]u9-KuF$p!$R9GnN`ESקșF|mdm=ѱ=Є)aq'#>k KC2{;[ױjnc-IGC1Y+Ǚ>*ԣ9KOMemjAq]Mp9)uͅԛ B>NM}_yKV}O{z-̭;R[cv&iUXە;3sԏ@kLN1'.F7n y C'wH[yO=2x~WǫQ59+vK~ɿ|Aa ֢ӤIENQuVOL>=Uu<tݾ~G Bo!',uVx<)]EhJV~R-4{fTڟ{XmAws֘yKũ>k3c;LhfLF7w#5X[6xثr=ն)HxfI$ WC'v>nkhכ#䯊_ai̖!O%J`x2?/ITQt{m;_5K_X¯ʪ ?JO|wQ1UuGs}ea>y:F΍L.|܍'1gBX=*u8RXiڪ|bM]ҭN2f5,{V65 8lZS66JR^>Gg5}' hLV)jfOxlMeR,o mnB6 j~S]I.DD~CZzV"m&4ޱޫڢ<.j\do5BѤ[\4F\ӑ\x7IhYmVW4VrqmQүS򾧯hFk(UhUvj34u쒵_DT7v7 v~NG==}3,:~vsi*2֕6]+Pi!Y#vq)6cxֽjxYeyk㱒6Fxqݬҳ9/8Ӽ?jc.~kqٕi)c|jrt})o|s0G"-<`g򘊊흸w:rpkGo#6٪`Va^|(=t Jմgkm´i/z[بSTO־"K൷$vm o\=6 ?mM+l~}#c4mk߶#6~OMlᅚ4nD[!OSFqXX|rj+eo,9)/;9o)CǷ |3go*e1~eDZ#`p-:|9޷ˈ˪S9&kӭ-b#xYڭd]ruF#;N}skt/}ȹFۚ/S5ӭfdVm<7 rO9#rQrLT[_rTrFZYv:^9ZF4~xH<>\qSPMJf7 dIQ_éi"!̮# ac'ȯ`pt*w8(ի:R=0τ$ ?/#| і88ccF_:^mtrW mk#/E x*d]s7n~Q<Rx6TՓWvv}g-T cq۲A+sP9힏٣=\3^ *{]w{X7).X?)<םQ*-/uKLM$7`wG$ߩԔӒjΞ',l/[YfT-9UV _q8ӏ2! 1\KDm_|wle >O$uסGZu,Cy?޹i}wep7%Tn޻y2JKYYtxVVV`CZLms{gXB<345=N3FVPJq ڹ*S4ԋRl࿴'ƫq2BŗnѴ$тsߧYFUOQSd7×emvUV5-9|ߑ=|xeRnJ%ƥ5)ŧn7> [BOypᔓz#mJi/QrVC-漎i$sʒ` #ۏp1 mn{xƎ" FՏ>$x;yBB< 9~1z86_/ 趤쵿3|d ӭu/xX(oHdaN1Ǖ)ʳTbծO;psv%u~F^4ȷ"衉:j*Υ5nc-G[շ-ZyPگ-Ʊv 9`~H%JT8;K m\E5.{1^mJhyyS̪mOw7,EaQ|Wjf5g(y6$7s#8#9n|V_RVlzNH?hѸ] i{:nKKF*i]]>˵oYOյM.S\tfLhB?lF"붚Vc=>wk7dbzmכcf Fݼò6d~s;믚;_չTkw;/ BdSҤ4ei&S9UԨ_+zeJqw4_DqGHv3qcnI]omK MLiԔ<Ů]ڱ5clEոYv'@+i.k7W&U%)$U鹡q[M>i kMs\.JS{XY8yό.>ΐ )a8mnマMOTYΊt\ed~%6\-&Y y#vI$GU}22eʕu![G*ql^xATYRu1ЄZEeo3/s^>Jh=:/"[m&327a؏ǟ¾~C֕OoM8\[ܬl,[$*ӋɅJj{9{kWC@mmfGO½J8NU4i=|E6[mW*JQ[)S>g=9={ߕ;OI/c0+&3ddc8=*iԫWܛݗӛص̻Gb]o]gY68y#E}vv1Z*.D_s{]%đ];+y 7A'+Zs>n}>c?c {1fZuVt*zӹDcQ3u6ZJnɚ4n޽4:3zAlSs '~p1ߟ#R-56t!iI7лhm;lq~ZR0%)JS_"s$mfr,IIӕiQv^(BD ^g=JҤ:tJ.#n&;Nz0앬cR[wt#6;~n88{W,**0BVeb}qZ{7N/]^ݍcEauKK#B>Ts;U掔֯soNKz~dTD nfj^jie4{d2*Gh}Y2y ;Wvn^W5-V1xJeevHϙ)0O'0}=kQ:}|FP{}ͽ{\e6d=zk갴R=Jt)ܬ{;K#Vݻzq匢oo#ڧN8ɷ Y-ٖF|ʏNEYcXܨߵ sЕ䢵C4 hme1/#s"r8%휞 M?UVEIn5i9X$pǯڇt寕RznirIoƫ4nZgQH;]ENe8³[/ ch[Q//Iڤht/g#ҥ-5j={ඟy9RB$q̡1~Ҿw6YB;>tFܧSWR ,-Z;cܝwLc3\0RpP8.xo=6$r mBn?ӟe[4huFtF%r0n[C5jSW]CnyߛDžZ7wGrd$+d09'zYnN[uN弘jtӽck{JfMhm%ؑ=Fm +YuV]խӿ+Ja6յKvT~ēHX0*s~?yX\MXjTkVR1O1lt,y1!@:8fS}V}-;[74WO-*빀'i^|Xm]<k$mzttC@osn:]#u٘mͿq;ӡZ;ikY[sH[hTw=l.GY.D6AF.OTp]θpZ-gwosbU;O eFt-Z̹jJ$Y[rK,2+"ŀr{^\)˚GF9F/ײ*}V$IGnqU.xERY $ToE*;m'; zzqv=h˶$HFvG-z3}9z9Uv¯iuKs|r ,Ar8GqjF*W[X"Lb.?td[(Ɵ,g)t݉!Xg;J=S([jh4Ku]1͒Y nS)J0Guk "|QYJqZni2yO7ĀH}:zqyTثYn UT&Pn#|S8E$qv p2`=*"R+_T^IjĒ ܽcc{58E]iLɍꌲ`7@Zgv˩TwQlI&I'~4M":%>J žel'NPi[i+Wr$"C0VQZFQ$e.!WU̔>yQo#I7ІX.!s.߼9>IJ>srdSRIѪ-7E^ws+u=YFt$Q,,o-Yc2nĝ߈%ycItWxDTqhbN3h6k{8u{?І [jH!ee&9VّLKB$d*(rsNzWW-㥷:}꼑 ,A 8ƺ)ʜikG$+;̅پis",~_g.e#PEq b>98#8FK{J2|Rkjd%WvӨ>YloNbQL.x`ae\ݦ׷яZ ^m_𮈾h۩ztmO~B24H̿3an}Gqk$֧VI:O#>9nn1żʉ`ˌ!Otsrپu='䕚f|⮛KɳYc>kJ6"傂x'𭽴%KnT^:ugد|x_jq0vy$J{u} ɢȊN3Wi\ȕ|FBcszU([g;FۙfTyjpBqIEHR- sJt_}ۦV08Y\A<\$~eRVߴt=k(t8YpylJR6!6:r&Z dWVG^J:[+fbpUǽpN{Ѫ-wI½6\Lx=RUmtO[QQ{[ ]+"PێD;1tZҧ$: 7J0,QÍ3HϡR2n/rNRw֊"6%sx\:Ԫ)b坱eifU*jV|G^2S|>vo=Uh+T)Fz\lXϓ U z|o䨢Mz[ѡ-??ҥoћUT;X,|{ڮgmm Q撻MwF ve>x8ūfs.s5yJR65cNϚ4j'9|vmn#J7Ēyګ;$by'.zu`䥡t\t{8jBip{eC&MˈVaoώO+Wi|?+R.;6vIsM's׷^BIܫݶ݌k&,ˀϹױ#s)^sS)xPt4bM'~3^GwF7ݨXZ=v'۸(=cr{u=N퇕m >EV`??/~+QQH}j.Q 编j%NubڢN8nsDRwDre- KңHܪJ㤾d#;f|mjIkS֏h[ 4EUxUc*2wO~2ju is79^eWQVW#Y,d( PWFzr=Ic^ ol`LBc*>8H^id ۉ 6 q2y]T/v'FF-t6PFb:?Z*S敇E'DEpwIRshR#ط`4<}3BMǥ4rJ§/-usQ.hصepO+qªTsNe.H^3ҳTtGToFjy48|}eѫjiEz p+(ҍii&d_Ynnڬx±pOK&{8l:E7zLisEXЃGD˕ngxu4)+V%zssu8'پn[iR+؎Q [U׍J1B$^zizwK/͏T/2CgHR苌l~ʲ~Z*n2SqT{b9hq:J7W-{Rq}{u(HPj1j/oDZ4ZܢHQ;~:ox|7<3-CA-Y2<=sjއ IJSR4 O\,/̤*kFf\y\.u4SG#DO$;\u#xT=u+qH!r#-}ykƁxn#s֩}#ZR?YNxx%{-SR.w?d6іl2pzq^MHFU9:|Qj}NF;%N>:o-̪=i~s29NJסCD)?a=kxaT6Fd0>nA<>+*T!~gs Omuo>5=/R~19$MHTgfVs?)%[ZWNfኑp `[SԩQSz3QN1on6~*xh/ wyvH>)y8_jUII_e_G(ӋFwF_g&e=n4RKwI7Jo^20Cu~G´/f/=}>|rRhqKf:x>-pLZmRY%]aeU62q$̰Y- ugבћ9 ,eWt{^GhZՖX[sTW g #ڑ捠={FU}6&$'oی6 ~\=<5 ,55Yګ> I ?p8ѣJ0ZgωOLXE|a0 |g$ Rq9.*|}+χGFeIf6A;T$I`JF/F׮bWwOEo<O[CuȅԨ })}N[SRRjc*jfі?1{!r^^̕Ii~.Wt3eR[nGʾumy2$r08:WZrd_v}*Z](7gm6}0۫MOSZgǓdr<z|bR8|N[+m;ю[U=_ƽJҴ{[;vgE8[hq3ߧ_ּRuo&Oĺs뭞"T 5<-poiƛ=QGZ$7Rgsr3Ѿn1ThvKG,4ykӕM"eq']: is/$m2}N>iF4cݗ=<\&|.}hZC#pԌAlqHtZoG}|ʦ.flT}KxqF!P4a`QRsq_fm|6}u2~Mb(r6}unw_sIss\GyZݕdёpA8=yve࢔G_C(1ծG_ӴU9#w(=8𯝆6j|v*i}_PyHdCp2;r1BkIw)-:  cXXUo8 `\f '}PƾVv}>J߇av6^WgRIB_g^ˍB]DV\'>yjcT3F~nHce8^L{U^IX/Z]bpK 5u:q5(M[JU#jF,FyH>ZvAG=k^߯?`M[C<[F<1,Wtc xRRYJ Et=SJkin´lqsXbjӝt{V5gέ!V45X0<3ߝx*RnjIdM l8f9Q`~ϗbTfҿD::uqOp)*a^##n\=Q"&Պ}r7Knizze6n WV |z_U\{_S>AWvڏveWva=~f&"95tJt兵V_#쿆{? v2Ft n^sq_M{IYeZJˡxQ.vý}vH;=Hj[~^\S 4R^$gkвNF8|:w4#j8#E~f4HiQ>HY{X$ln1YQ;khJwC=JPbGr;"U: 'Vsprߟ…)r$Xӧw+L!3VUyo sXI/$<,U&py(5MlaW͒!n >ICjT9^EǚH`YX_Z*rsT~g-Ă3r9 p_irȤ&-eheԒy&pB*mo\}k.,y^ԒYHMA^9ֲ\\Wm{46\7˻vq-j2pJjzG RKr1pVu% yV?f5wtM-H+G C'`Ԕ=}w9yWx=˫B[Lv#I;p[J|DSuu'I.Pel08Շ4chr¤kW-nei14k6AZN2v b :,[\D\g n+1},0r7Z[abO(w[ zhtS|'i$\>FPBgNjPJn5.ڿRHsnr`}2HZSoOrQ73/Yz?8+_bH4Q`ŕޠc+zF(pYd]}ߔ N(rRB9i wߓkz:kFL#[yeWTVs-}y=ƕD[ZI29Mu/g}Io23 s 9+XޤuFw ӰC%# j<{[H~֟D{$<{8UbX5bU'{2xV[gmSrC >bZltqa|,xUݹ[^F]ʦWl,iF2En '_ε4te^fz~D2G_cc8vf7{ܦԎx][ym![u'nA={֒)QЉcI!V`Y'>ʅkG7y6Xf=y[*N4ݑ@ y"+n`}1iE] Ûlh.Xy?vFe/Vq$D0Ҍg=aN*0!q$^#UzmU~ÔMh!@~UF<ι8ɹ_Ah v`n;zW<Ŧe*UBefV$rN0ϯ9(*㵆kvamG/90Gj~ەnmU7t}JNk}bPhFp٭n%Ȃ8?u#5eF~\5k6FdY7) ʞhqUKrC6OipOҟ4㩝I:]J7:Ԉ©ݱz=UFK7ȡK+}q^彚Ը{]7ۭ Lp|(wךKTQ>;ċ#;B{(+oΞ]]S~|08X.6:+XF0E[q\.##ʝﮅa;c'?"&[=jQXrlŕeq"[֧KKK{qǽ  nӨ+.)E-p.m\)j4iݨۣeܙ[#FOgRޝ:Nq;oȅ9ڧgt9#Sn}zI"2{wN)h:'rWp }:j6PS_%]b!lێqƶ.1Zv\xCnfˣ#4r {Emʥ-.x|rOm 4s r7HF:QZtc N3C\7ˏ=+S4DԩEoe$2{[kpFXT(֧x'cO7tcY_--? WjmJJ̻ШzXA|kЯ&QeY2w+[P9*S.aZKx+|{q޽/vV5F;26-mA ,)c_eNWdhzduYQ$pK qW7Ӎ8aalmG8=::R"4%u#.zpnևK&y`dqޙڴ\Kz8PӿoS\hqZ^Ik23jzO]zt6-tּ 4Po_u>T{Y8Ɵf߰Gqk{{u1',z$է FQArN]KXi$qe)ݱzrsJ(g(VInXA"nܦH61*}G>[Yz~&+ cx3^ˑi&RksSN4ON{4:6_1Y=^cSZuٚFQYK:w%33Y~]vd1ۮq\r9jQSwV#-l۱V)ǝiV9JA֓l-YU}+ϫQISZu SJ~g{6:ީDPFoS1g9?N(S5ƙV Tw9=kQcg^ȞZ螖ѝ< :g==xS/g)CQRo~WaDH[EnOw^jV6~6iX5l9uPc9*Ws6eE đyj @22Pq;⹯)Rwtm(vb*ݕcq5e*n{ѪOڵڐTy"Y~x8cێ*N,yR5S\s+3>^)/SQ;R;oDR0Һ'(ʒZs:4~V} SU[QfbF(ƣq'FV}ůcQ*J멙?bvWHUWl{I>nψ*4tս=<{:RKs}o큘I3F\rʤMFj(ՔT|HįT4{ݹ^\ig2}I-5y ʰ`zw/ݫ-|:Qj8pmБӿZ2OXHMo8Rh1ɻ zR"K(4*7;I~:訨<(Ij%{_52 }T%)Y7e,1p;'~e_O_Y֋(y}Vu^`){Jny}F"\7EtD %ϧW<-sz*iXmk6[ⱄ|Rzukp²ƶ#>Zaw_.q*5v{lݚXeuGdE}P jƼ/WS^BM+[3lD*#`ݸh:u;VHڭ:tWi%UQ2']8simtocb}cI֛;u-kj-ǛjcsRz.=Jhޞmn݄<`F#h q=8ViԜycg5LdQKKwؒr~a~ʳF7}:C[M{T 26Oʼ}H5U#SuQ;S~4݁Ik#b촶_TsMn$-cX 6xבWRU9R_bPq\ZeԌ빝Y` C2+I[ᗲvr}پWm|vE:u,somFUIA말'whF9Xf$s; +To3ӌF2Ohԫ|FAG==q[F5eM+uɜTI8>.BL$uۻջMYά]h>exZEN qϾzh g|VհmkQ-6F554t0Lp'+c֭w*r/w G!LJɵv&4iR$Zt~^Ecќ2㞄;W_,}Lt:c[FbW ǹ9ai2sa Gf`xڶjc*FIɫsȭ!,ʌi“`kӌ:ηZnH!>;ҋjm=θFqonYaB#d>_iJRQӽJش NTͱW]F}wt7ld[}ރþormYMf%2`-I^ե*;VN ɕ%Ր̿Gp}=DHm:KCqs#Q99cԪkzFXXͻIh7˚+w~vr}{-H#SXoܢZ9YcI@8N9ִ4uяve+'n鎕t麒ԕfoib/3^FWxF9U5x(b(+!Hc%X[҅ȝާ,7>o0\y<*^R2Ox(kM(t:& p(,kZҌTiXa}lT:a Ѫ ER-M):V{& Ϝ:g֟4cRUtc|pwtsWU+-UU`=ewI)'1hedөQ=c--9`ۿx؆"^Ώ>ZدBIܾgT{9Qv9êRʖIV6]3(דڸ(ӪeR*+ ;9%jʱM c ?8CZoi踲#b&$$usXQND^7i-Bnav郞QRkZؑ!PO#ڨ=ϽGI4c}o'Wܪr=}\?Z31ק,-QO9vb9${qWGQROLy*vK-1.D1Vd-L6IVt{#ynDo2F$< W]Ӌ\zYbfmW >s{u= rkDw|jLT$t{WBRSQUGu+ pw4}k5cH4qe$XV|ǜ:FU"Μ=>?bUcUzEMksXR׳Z_n#IY66˓x;zS*=&SJH-eI2se22zgԕ=Gk~9-Ee;l׭rrʭ7Ժ{˻WAX B](JF4xSt1T5n. Ի 2۸u*܅*FDX>\rWV^~N"Og HlEY21ּUnz/>p5{q찔2k 8p;cҸjF27ZRZv>8>+YM<{HS,n 8Ԫ%nS|ӷRו1G ˢļIfnz ~[{m-̞LH$%sS^ޓu`֭Lf1̊X>ҡwwk-9kbfz2?+W\czj+vkOHynF۱ҽ qbmz~eV&S_+]Q/Z(HI9̈́ʥ@;(&?[Zy ?C>[Ϳlhm6TV,&?{ `׶Z7߭FioԼбa+}r39'w5U-vxyg Gi[csnjo/CƊc8١G|Ʌ8d)rЭO(mjkq/$roآ-̠8ӓN9\ҕjz'HF+5qvV|Rc3OǚSIS;n&@s 2qU^Un~az=ʌyn 4hqJ ]pT'ِ}w<#2FQ2"TNN}KjKy>Ptiթ{jsSG7dfq\8hH%Ү[Y^ciެߵEt/mw&TV1e6DihΓJc=yҌ˫8"Rj] [(-Շ&ҌSrz T&ջfb7qo I FEy<3nR({^Ke++CUO񬽭W.[ ?ѫ&0'W+4[Z5eo}PجT)2Dk㎞sKFa,;\J(cڼ[T;}ٟX .b*0I9'qVNjڣ*H]1$G^xK^zy*o?ݭ T=Y*\+ܩZ/Ԣ[Hj曚t}ɺwEU9Ԏzj(U7)ކmd\*7 ?s^+eAɛQ[ +^UqIsF%eȹ~"$,g;B7u#<֢a*tEQ-٨lDs}+(En$;ʰnS 8|ňmmڝ)TvSW?{{rf>ΜBmt6n}ѩ„98FpTZ}z=B$f g<~5ˈHC[Ⱥ|3N~EODo->z:}n9#ZfU|{ӧRREqiR^󶾢Fn*Q't Ndޤ*u) KjB<VեnT:Z~$H9pyRJ4y%z0tbBぎ9Lc+9贸O5btlwOs)_Ry'(}ŠRM&7.s8]zh#eCِ;7BHxqj-nmߦDspdU=ElEAت59"!YIEX&:kJ%M󲽴|YU>x^Z*c+qr֩wmߤ #mVuq}?:2JU"K$?8rJ3Qj)CK 0i $m_ErOZP{NN/UCqqy6siy駈I{cdhfc#^n%c5Wvw-L n)]ʝyFTn*}yb= I$sT-Nިgov|G=>1i_"T'RmkYf<}9'qkIT2Fӛ_SSkV[wXm,;H5)7#bJ}Wi^U?_gtvy#8ǧZNj~ԕh-WFzp{mFبwD^E1q;ׁO݆-=/vrRg>P~ +A`:Wٖ!ΣkF|LT;5ƚ[Ƅ&GӌWyK7/fu!QAr$OׁYۛC9U4ax+{Qke*22<^iGF8?RGHdקظB72Vi\B|ӕH8U8xe24}b@q^Eg˨is..Ye2m]88>ָ%4匥{vD';[if?zjoCԧGSZ7k!v(6뜃5˖S5Zrйw}14qn lҚ5얧kul||9u(ܯNXIdBS̎,qO l =}:P}4q,Ҭo,YFӰBCsUyF6VR[4xgOˤ[x7 q}1UR֧e|j{쮏~?jKgp&E<+" @qO=84b鵻9\iې}Oe.U&Iя-5Ȗ+Yq֩NQ|R5)ٽz _JeYm~Q ɒդaO&bo:7Y@zۻ\TW]hV;XHr^ǵ{[-3ҍ?Um/Yw\1&W{LcOIӭhRxru`:ʕvʣS1MnMgfa-J^Ϛ^} #HPHY^ֱQы/m =;G-0CW꘦I8q>2( #҅@k(PNjFPz-3f-_BzifiP߯S$ڿkFI3m\m9}+[9Z#}KV*kH1ʻ㹩wvOi˚uwWl9"0pG8\69rMV85Yr9-IiH^"4JvxVb۳g%IV9}X7y*ۤi==S]0Qyy舧SUg{o2K+?xa|qקC N;ҩ}4(u{m陕U⊎jrB6d*U4>5$ ?4e9jO 4{t?~iO>t.ӔPx֊ePU8W_C<=M6y-=~RcWBZ[DxXQZ-neKė6y%UU{aGZEE$a?i]'Gόaqvv`O˞8#icrHe:}iٜLچU0^-e)=Z[eԫKhR4N8 q?Z9btg?ʲQMqh33FF@Asta躴gvtգ=D]|΃gTxT"r͕m"H`yNlqT~=zn4MJc6ƒIj8zx"yk¼{W&Lrso%z#'8F+Zu$t?9Bۑ:ɸM?ZaATۯmx?x{(tmcIn3FG<IEJJ 6y50[]+i_ng[G׍Dž4[VH?7qG~b24Yޞ}q9~N2ntlkZsx"; ɘ䁋1 6;tr$խx<=9ԓr'prNSǫA}>drs3c5?vg{RRd):šv^a#Gd@sW?*VCa֬.٪Zek^Ԍ;y:{=/XLX$6D2FXapa׃-^i6] Ws.k+]}x&ͭΛrBq歳t(p~Rs{INnN_CԫS)6]Z}uOlt۟ /o&OnSnA81QRTJ6Z=޾}zYWꗰ{;[y|&rA;،a::i֣>+v֦/(_j;y_vi|8<;NGnJ^gn1rF>7{_ɜg>+fh|3YʷїENHfnS8R*&*m~VU0ѝZޚ8o~1ɧvp&*UxV9'<ӁYp;-G9(-^9-T줸nhZ5w 2FR= *1tpꥭ++FzF?o{KT=v~xİKkl%fvq/S EKqKUwV}>/zIkVw_~( :7I}ڈŬV傿6FUP1#e5HvdX~j5*b,vmɮ_Z~9]hMHEyw;l9^cSm[}%kp#髻m~[z$kF6NQ>!s3ܯNunO/TG)˛k$s֯MIֵk3#+N:K*Ǖ+v8OAmrֶʪUqѺr=?iEGsJMI=R [m@7t8p;S[w۠`kIiMsgpn\f'yʎ0Iּ\Z&k:ҖoMHgkH8dprʷn^ #RR|W]YӅM']> {N$xֶߕW$uF\EJjå8Oަ4㕤߷w:=JTEe :KkkkǷ#Evo݁<ӦjgRSi[ivpukWTcǮ9rƌoM\,u_Jds *cMrInɧF+l$O>cF>];SQn+ȥd#)Ww9b#:R*'7M{D۬Xδ;w<㊭^ Ԩ'=ssF*#.UCFD"H<䪪kI"f;7}?>iє3v6J0md~\ ѿ,ةʴ-g_2&eR3$ye)'ʥgNVeim>c$yHeQp'wsU╣mʟ,'dVmA^OC5"ԋ1(swci+RJW>f!TeglɸOK񿡄יYqaCٳO5O㔣$D\ozaU |xz֪F{*(t.͡.ܮFOCz0i}oȕD̒F[hr}:Ҿ-[]y$5he8nQap8Vo}ᡘ/?w.[+oZkBGȵis<[hZL3Gg~+HN1o ''w۱&a;h+FW(7.j@ãuuJTq] ˇQ#q_ctQ̞9J'UvCBdktߦ^xėrIZ\٭P[#*H#{<-4Ԝewݖ )=ս^}-_q>[!c˗ O^aN+S륗e~a-]YE.گf5o46}uk8g@Khg5 CF]R6g gMko22(]ފ_;[HV9 ],e@$s+xϡ$W(~ҩNZ%^pTNpqW(-|ȣF2u~^DF$*{ڰr]?[hI0yfd_Á>1cX֩eIKpV67!v$#/yod/ϡb%YǛ휶x>߅rToEdk_Rh'kg,՝fnUqn~Q6}cy?o/PL^]VwKn27rI9:EԐ ט檴i++ۗH9cs3SmV,GαV5Q(Wz T2`TF^9NYFwyk&тLxR )>Z2ˣ*ܼz>+ۃ'jFB74@6lO^wsƥ;BӌwշXII&]ŲsҺ#>[F;K H#6̥,z~8N5%)+ 4pjsc2\YGlax^ޕdoT|$ʣl^Ù;o2W$LyS8I)=e%g{׻㹍M/] 71PkJRwn4̠q(*&3`c'E+RK7lZ"f(feҥ9T[:\b]\[ؼ+1XӺFCʹoJ=5_ 5%U& ɧ8e%Fg]۰1 ~Y]ǚ=w4EK%ZHW-HTv_M+ {ioCO2^[yq!EywF:Y:Yj.gkt^hEkb9)E3봘Z ?h '0?>y YǙsG~.m;4Xv.Ji:ROӣ۴R<aH#'ָS;&:b+?ȱ,yyVpzzuJU%)$nLiZA;GKives9wy<'[\Vd?lnM]g'2wv9+f-no~i~~D2@!0HVTy\yroln =_nOJNZmuZ*GhIʸSi_ꔢyV3iHƞ u6fMf5iXk7w]ьdPNCe GfXٿz'j8FQo3.ߔ9=s]i2=K?=>HԦkƖ|I9>pVֆrG5}|wv=;rSڧ+kՌ0󋨧rkrYm^y ѩFI^eʼjԔk瘣m ˏ42Krk+;`K, 2ʪ>U9S0 l x̒|W"{8V]5M$"Uiƍ}4+02mvJ̭Zrm'eJv1cJJߑGZ2X1U7*_кtjStPU8Nc.Z; Um'9-(l֮r۠b#Vq[=oTgj%{:X<\ّiөy5fYMٯ'2U#r e+@\~ʤ6P@fXsǚRl+S["Kr.'vngtZF| 푺4=QtgԤF([Ļ 9Q>/Ƨ-'-ȡ|]5)sr#Z.,fCq ^Eٞles:M&K;6U0e2Qӊ´7߲:F8zRswzkٷ[g) "``GF/ǪpW44]MS#:v1}ɵe1),ҵ Ytq~gCm|Yk&0ecʞ>_ƾ)=SDo噥?f|ZI򢸌@e,3נ;WakS)_K=ZNw}\."ЎgY n`Lsxʔ[.T}ZI$r;/\kI.U̥YUAR[]7˞:t{M4(Mm3n߉Gҹ/W)F ڤ}co-$ycsu9Q))Y6qש%N2g_26;6e\PzsҹjG"hn̸n\2Ue({yE;4le=|#Se R7+n0SZm?g̨0eU0]NS2NVevL݈,mCLq5VU?wR#2*w`T/ߒ}xrvR9FBZ2lc~\<}zߛ^Fqk k&>P}&.]N~is^(Ql]$C'Ԏ>J^ 2~MyNҌP?Yl=0ܠ{5+[ByRJ9?}yiWVBޤ^浧VS ȥȖZ3Cnia|4@х$9^s]z5izqGVw2Ƶ|,_dH$Ns׶0?=jN~pT쨥ͮ޿3ό4yyqKcӔy~< VRo|j~%[$l !@'SQ^D.MWyX|ٚcݎ77p#?{ ԿR筗{t߿A0OK+&n7}|o9>4땖7 t Ƕ8֭ZUm |^3*WG˦H|;'ƉhcIq:{LMIm~}W[C텅FeF;Q\Wߴk~EB>UZ&ݷ0zГ*eS想Z.ciy/>|/ CĊ!ӡa *r0{*㒵L^"u..%RS?;_Zmz[Aoyg"`0ypxR?6OʦY^)_]>#fO|'jG :PnYfRP8F' qN3iOIi_vSG4q&gm۾ӧi{Rh^Iyh 'b8۴cyl")rNӻooSdU%RSN_mADu%vS4KN; >'#V8RR=ޝ=m|jp\BadYR- Gu JkW{~%e֫]Uo\ u(/+QϠNjjzk< k;_{ˋҮ%98 |>aSnWU鮞Ws. F7_|'xv9љnYYIO1+*/i~'yq}vC'DtfP8^-jx|+]t0{TW#_>owY.Ff8-;s~t+`q v38D엒K.2*iϪI{&j]4*ͿTmb I ŚZI!qz`vq(c+(ٽa*o˧EG_^g-myivr"X?fUT7,{P3֮u~˚ھC)V6coj3G Sּ0 MY TI[)s_A]Sƒ!~8F U4FnGum=?:&^Rq$<+_%O6N~][akf׫|2)mvjf2Nr<ld׿WKf}-突VEJKk|ߙx{V{hgX4Aؐ0D=EqU|v^Zw8Qڗ3{i~*}5|)v61学!a3ξ a0ſ>|-L!KUg|[sBk57ͿΑԔ~@;p+UmMY/Qb;z[ EttIȢH=}987+69PRq_z(ӏ2wwG4IIJERCN2[ ҾZocRfzzm#hgpct1*+G#ºGTz8=lyk>ƕ̰ynbX뚪nU2LՆoSc~"u $<Ge4Щce[ǭ_}sſ k,@'89KK68ʘ(uիmyO(u;UOaiVfg1~R2\\ *Zxc’ͧ4ӎ0ùQՎINnrg(/ I_unn Xe9?}&tiԗ+Kki_l07]:~S/7i+XDXjro`Gߦ>Sk-k b#ݵZt>_Q~֩41 Cܴdac ebkFo-:p|!Spn!sak{H~gLEC+cI8_QlWe"eVȥ{-G K漁s_nGgG͒[D~* \RVI C6Ҍ"srxޣ.Fuثvne{?ݓg0#;mFZv"SOf,S@#FA^:NWN^$݄HqecʫNh9~RS>m̀>bzc?JPϚRZvM ̒]}U,=Ojƥ5lLWQ$Vm1O#Fx=1޹LF1W"G sz~G%OrUJ-Vm=:ҹi驞!Tm+ yi!]o+\zK޲JPp'7YM{vm F0pǩ=u9d.Xy+{1"\[XF6ƪebxҲT!ʒ&GhH2JFѫvZoc.jы|Am4Ii6!y,psǠMs#RQ%oCʦ*HUP)I!57LWGu[rGpp#pד*F 9֞inOw}"n_ju}yð-!;z~kǑX駆(]!;.np*֩'(+*iMFW.]^?!ykj͒zt2I+Y%\*Z%Gsid%PyQ"dyny3eEKݒBlrQHa#ÿZ2QtgmBIGΪ~`X6:5w*\f;@߽h?6l[g+^Eliλk[WӡثWR}gZ">~ν*RZLmZ9 \~qqJTC:4kӨ,aiQ q}kzR挵:}JjRoWnir@|ۻxWNz*0Kk4\.֦PT*\龾Fޙs%1$V(;J4jEԨTN._bĻYbXQKQKt>R,N kr]VX{+U y& k2\t%΄iIALi HyyPq Tu|ܼ ۆ::$ތo~M,-$ߍI{FJ|N}cF;fk*8kTFvJtSR#]1`ҹJ$kICM;#UCBp+4}Kˊ+cjI,ꟿDQ2OZʧ7#1,k][\jPgxקq]ֽZt[5.zIN]v8\=Y^-~'+8A*6~p}:Wdi{7)6]LoşW$/=OZY˙;2k.]uEQ~ʥY^`5[ϵztM(/тya>]㞜e*Ҕ|UR8Gz4.6<N~ߎSQPqo[v:ySլvNJyH'E {TBduҳ4ʥCQ܌{zތ)sA[O$s^[KN#I+Us{$\eNtIӧg4oC?'$)}qUʤ?_]7,LGW<\|اF+2WРTo4wg:w>"JkKwF^I#7تłʘQrzt2*ѧSe uf8_r} :d׹刅;J/kd1HRI;pw cdIJRi#*SxhO}Rc֦Ycګ1mWh$8:U9whUY)>9{-O>dc >Yk2']\MMm2gUNMYT0Ǘ)`u9 FtEEnZs̍*< =ϭrr{H +ERO]-s{E[Ίk|yz㞟c/ewbs> WF93g(9P>OSX)SQN=ѾQk_1dn=z tZ);FVhrӇ4SV\6|\ʸcRJ/֧"_-Zc%čsyMӜ"Vko&~kUd 4haJdW.i%&\{.H:6HqҳEA֣MM[2MbHULN/QMtEҩIKR- ׸FI9^/u(ϖck:[FRfcݱPAG@r޹ROcѝ,}+jt2J.^ΒtQiN1tU!oDmYܩ;eݐ~EKX-uadWY]~αostwMCjҬ%-OѪʨ z"lJW_q%f?襻NmIjczݺQ^H$ۼg>W綎]q$6zLfo8u<\̱lC P>R=J䔪FNUEzY5"J4{cq\1ێ;u)j"%R4i+Y~%Ka~OC>5)ǖ{% }Zg(l[WvssSYt|/^ǟ:+Sf迿;2C޵5*C}u+Zr]w'6 nЫ8N'(=;4ӎW^f8Qi[WR{FV2+o*.he{+~ᇊKZݼHmė"WvqTy¹TRaoJj$hܬYHW{gy`a*Si܍f[T|[GtqZ9U̿K x+aiFqG+Hï{o}|$m*!??sJ7?6v=|Ѝ=oDZ)؍Y#W=r:viOֿrtg>t2g(䓐ш}UЬ kiS;Žt];'7 {!i7++0b89FGAZ44\[v8GJzi-nQ7l33  @t֚w"GS[v4As$ w7|n89DZkOX=W}gR8f}oG$Wv̱| Y{*Azr=z5)ί2ҫ)^;RgI1ڈ յ'i-v""h+|&rs#ZX80tF^ Z0b x#+u*JDjQzHL/2zwUJ1IZS}sKX=$KXm~Y۸;znc:S))5D}*0ϥ}4Qኳ&g38HN1i=1S?ۻ$=pHӂt=_p(R4.2i69#=qn8gk5w*Um IY%gIWg5IEq`V8u{/ԑB7̻T+8~&5)a+hCg s;sB59_̊8Z02Vۿt0ڳ'dEg$vV`TGA~+yk%V:FcOa?z߾-6bʫo~-n/s&߯B"C(ǜsJ?- d"ۖ܄)+7ɌeRI{WC6!mcw[ӌiZTcM'|q"ǹ2zm'm"כT66Ŧ3Ն ۨxϯ8TUrmMI *lgێNj3N=*u%(ʷ"f؏sm'jQK eP*FUdyxNR1Z%''$(ѯI!lc?>S:l_\Zy$%F Ip'le(۱1mtec纳:8m}=ozƤNcN|^߻ުH]:LD.hRb7l`c~Rq[/ Ra&ĹKR|0I(.y?F^E}e8x/)NOc]Rd\WU!k5?HDW66?/_}42t}=k8Ei:qN)mk4&ڻdyA^ֺ's= *ñJf-㌎QK5%ݴm26hd=:eΣJ̽a۴6Aoh|5U=~ӡTi17 ygi"WOjIm?3KR^ȭwp03KlUcx9Ղ3rRןA6$;ctIyو2s$Sv}bo#6tKw bXWrt>^N7߹R1PD1N( B9+_*&Լ̱C*;tTӨƕ=:bi$YEql;zT~ڧ`()kTMomXmmgʊpw|bJIA ]2ˤXO>*KbMӍn] 9di.Mr,[nDJv3J]6vʍY,svq±cy6iç&4ߗBhlwel>x榭l҃׷QQSUOgib4[c`Ydc'<׷a\riֵ#Ir7)Mב ps?¦5!=hIM[G%CaS'޵\ҭoSg}?1ȱ_ z29;qҩ'ir)"h6Gt}Qz]7Eʪ@gti%9sNȭd[_ݻ@yXN5-$yԔy鮨\=3B$ ݝ͜dYJRMyhZ-_rG<4T2ϖ:3*W)R68lm,41o^>n3?CU*_:|?*P't26T 7PGYrӍ6סӧдi8|Ojg%mM$V4-$ sQ%e8t9Tu<[h,6=GCsr3ZjSv};[|VȉK`12ǰ>WKޏ4^pJN1&h|#>?y~yc(%u9MKoHWhSz]>[]M*I:;XsqCc<8V+2Jq4mE F$7w#@=*ܷ<ݻJ)VF-99#?p7 gO>k=.ZTc'X|Cv\$+ +Ki8Qc'n#|m﷟SᜪF>u7S 9>q4֕3n)5~Cny5ܒb'wGE6by$p:UN_-3cOt:$i!34l۲yn]:;.j\֨"iU"A^{ڰSʥܕi<H&3AX>17I-Co~RITdrK&8_,X#0œ \vjtm m!Hgˆdw87}j=5%QR6fjv7WIVR]'Ү5FV[g2nw*j:zƮK0]oZN2rnFMݰnߺ)חFxTn}idycǴ.cJ{9^oISߺNnBai=yZӔeO=3Xʝy_֍NE8h< Mttu{ZUf>R6S ь_T׹h62ۇ3DL͕w#SXJ\E>/ukExg%@a!޹x_DeRTZ{Z:nNWP7z?-:pv8F29mc'2hH˶SJќҚ J#/\>hi?h_-dĄ S+v8j)6Mlmv .'88=]j&<7{mb82u۶>;渫Fdˈ('[!lnܳ?('Pɷ89Tyz?Ȯcǐȱпo\֒jJq.~Alc2.<>85*FlƵ95uJ7}Ր^tTy^^VZ .#qHan'V*QMv0GOwC.Cs=9+S3i1T] W7?x79EO\G-Z7 !SM"Tͪ{NMR2-b(/6Q]|nZRvszDjJ7mݙFKIfUՃߥkB~jQSJ~,O&EoS@2t5oPVЊ\<=;pJRƣ2F;AliNZ2 8'3קJ`Jۮx᎙kP?Y|Hcd}0(7xϰ_c-|ku@~[xϗn:'4o%' 8PmkgiەIz#~6"i ee83s,1~'R*Ռ{VۻV~ > LYa><=)aOk~;[TvmNǛXG?k/>bU9m85[\n|JזW'?zI+Wש?sV9x!t$HK SZ$֥ܬK 6FǁeR.yvfYyǵyt}JʹaF1WMLn_OZ9Zԣ,l} [JtT5ȣZ{JlUf1ȾxpmZЍH6zR ;VeM7ͳk<ٝhʝ]Dx?6P057̎&i[ Us}y#|,UiSB7kFƸҒ엑(O#[X'*ӵ}<]:ьmoS۔WZ8.$b7Oktd#)G3H0I8̒Lԝ Qס7RXxY6[o Ξ*qz__B1tZ]lnx?QX5\2<>^.2#Mw=:Qfޡ[5ް՟塪ND]} ;v#ے~fȮiaUڧ}O]HVD+ @G!|+DqҕtO5:u%г|:E1iT,k~fqf#0޺Z1ef5OA>| |n5K0JnV^SXb˞J2i~bVi#㎣ڲg5C"8Ӄ~"[iӝ>kn#ߎ#=zd~8y+qˇL=Oh{ϱk;BLY"r0 z#5d7Jل~Kp=I .x<;WVW)mӦ(g Ŭ,4l*IS;I c}}8H}\; tEݫYmxSt֣MY1A))$F1N&Sݧr}{Myd )֛U]zFe t4q&ou-Ugn3f'>UTK?K|6QiR+J JY'#5~&T9[oHyfe;~i~myo~UWR2ZW=zJu嶌0_;ϡ>ТݝUI 5R1/MOs E?ii$ƹ䴽ik293^!)Q[֌vVZ [hh VrsFq:PmG G Fz{_X·o' xnbIW8:OWϞJ8vVէ\iNVPe`181 r{yɇ%(Խ-F1 ;Qʶ.hvܮ\<;xƗW:T\=XBJnyH t'j%u4)եgc/-4imhS=#׏5gYiԒ)˥RLhkV6  uhUdЂ?Oʳ:oFyʱuT"?A)mI k1ث 8pc<,ZwX|FFiv5 6y5˝FO&OBF s#LqTTRT%ݽO36RK/ͫxl>y7E+Y'[ET53=w5LJtۉmfYU/ATrJR~=ݭ,-N_M-;M05oc9 7@zXƝԒΎV.tj_np6ӛy.-WnòMH##EJqh3jw_AwK0jMӦjxi(]tj_X#\U=;I;t~F}u[/86ROz&29J-tʩ/mT X|O}9Wd+.ǹr?Oj5JP|p{Uv6Yc 6Et'Ӏw;iOg^EUʍi֥Ż$=hwZi]3Udđe>SaQ{Wa2Uw=i]TvM=Ŷ&yl2N dn47[sqrՇ.e'k꒿ϾTOEkmoeͯߊzXFYhso!n]w,FH,sa1XJ5m+ZmCR-+A;Ӯ?=A-ޞL:ʝ<-8)6Ҳkkoc M9s9][|ExK?$i[{|]`sW嵱RQ.LEHEE۫XmDQUrУoAoʹ5&<Нj|w6Fi}=bFItBhT݌cx:j4m^WۑN".Mc#c1fZ~fr)VvzSP%lhdo;M\Mh e4c;]:Ic\9KCZR-/kxd`p'ؒ$QG*vQeMs Er64qiP.y*}ȌEzQؽbE~_ϷeRQ1(;Y'=w?ϠF5bi/EёJQ{mr[[g{2Bљ8#FU[:I} ⳶38M`ng=}i1"QV-6kԑLW2c4jʣ>fr<zg]1ZR:#CV{jUC*#yq6 q{֌,jJVs?k4Gc]BIIDI$طNk8hK-8ΥinӞi,k#8gM[KM;NI/i{omru6i?zvIG^⺾S]?v_Džnnd{7崱Iykѣvߡ`P.Yߡ{NԬ.ru*GkxpHXrlVR->"mj {di3&!8^>;+V+n^܇e(?(=yȯ`a+31{6PNv!ta]N9ObVsUws¸SLƧ<з#G}rs4JKloh8g)xNp9p2 ʏQdIohU!W%OiF%WIA؂8V= A];̱(;$) O/nGtbOE{Etu%fGMrxuԞy].JmTzU1 ]=kfYJ3޸bi#TxVe]߼X^\#+ų4\#wO=aj%^;UW>IGV.$ɶnR8=k7OoΜjJM./)o3Yszsi\JV-Ff˟(0:uު*1Z-p%FIc.Y.UF3o [(ӛc,S= -܂?˯rTT([l'9~#R+J1lз@,%y8tGWIXR6uJs8=6G}?:TN1kdQ=Ǚy0mioz_{GsZBi"W-y|H=ֺ%8ԺZVU\=$v#vl)?.GuѩRFT'JO^%gb0f^BI9zWTe.fGGQA[y/1+w3|7) eP˱&a`yWM:Cz.ץ--|۸-Pf=x?/$s]Re&hԤSծ^4DH# 8+xJ(Mμ5L3;vviآ.%䇠[ކ)Cw]$%"X?x=Tjʝ:)TO=kK[dHb4zzTeNWۯbGבNcG p>fߙF3rNj]~jhwxqnk͍䓜s;T{:teEuN~f{%n ̡T`䜜ʜ};J8KtfRKokw*0{ОxyIpڜv3nm?vmYg{v!fیvl}:uNpչd~LW XBA&'=]ɥ~87+[MKEF!Mcf=x<Һ%Q)ͻlUj.ܡ=>ϑwHdă1Ͼjyʞ=l*c<, m@UA[F4n*ݾFIEFDFe#I >Zzt5ztd- g{ ۔GXF3E;;滙체ݜr=8JNU7ZxlLu~&H㈬葃_jʧ,zfa>hGsی&?o腋f+Јrps(Ə+s~E>]BO8ʬ'8 ~&NeΛN6 -3Hc X ۣ}65Zsem**νщHˢ}ӷCYܯ[J4Ĵnqmc0EڠMFFA^W䍰Tr4z]KeO:+wh݀ cֱRzQed2j=ҽ&"N/)?Ï\vWv59jt6M@H ~lS֤9j疷_gi6f%{WM?m˾:w[zpLs gq\v1)mf̊˵WP9tSF1jHҥRk];Y٢ٹ>\{`}+RRR}«/gQi=oF[G"6dܫ?^QU$F.d?`e6놓prXjJ5=Dƚx['lN;#5aWb(K(M-KkЪNw3wS X*JYdR]=Z/#5X݀}M?om̿{ͲF5N,݅QHMTq[~#%hQ_3%7}>XE\Ti֧&U-3iݶ)0x?Ư4GcR_x;#1FӒ+sHxG SzԏVqTeN-q'0|۶ ^y9k%C4ZRWh}(cE]\qJ_X7* &ԑ50E3b˸#㷭q#[N*UzhQdV{u,wG )/]?~ 񯉾]6mf%rqqW֦ȴ֜)ƣKzNDSC#I6_sq׎k0vTn#M_j-/u8EȐd$e~PۘLv~pR^WtfU*Jp$Dv:XQ6Ց$l<)s߃]Xӷ.E˳סi-/I#}$'m35-J9Oi5XֳMYW'9h旺'i5%8Hz}CDB+K6p28qU(˗rߙu,5šimO,t?Nk?{;Vʺݳ;Z$HJ26! q#)ep }3Ǹֳ?ƵI(]t5tMeG_0:%TO7qF $\1RqIR xI'`1ћ9ך\d8{ S+*?Ұ՞ZIE;uqQ)XKoݔ3M8ͼ@RFJ2S83rnmtiby19L ,۽̀҂1</瞃ZnsJjsGud17˯FTeHg`d/RAۊZ#o&%r2n5Ks.z xț$'x5 Ti ";mePL2z`WNrR5o36G_+uT!-`{;)I& ƥgo 6pfPUv st]EIhǗ9kjjEKK^G b}rxF:J($V31cs ߞk4t𱛇.D3& 16eV gn8琿Ji{Wn]ңmK7Rlivy3IW{30m1ƝIrk]ңzdkZ͚Go @qB98=ǒ-_U:8tV^=ǎ4ֵe/{J?6G+ s^*jJ[.BN|utz埇|YF./3۶W4w&/}8ZQZKd߾ 5*hEu~W'-!5 HlbHfG˼3621$S(ӛJoNG⧊hJ-ݩ;;YY-~#?eEehu(v4[gA\p~5MC<g^k;G\RԺGS Q]~GǞ Y$!ܞbTx+$kƼ}սcc&w'9B~+nHdk?큀 #0gk<^^ Ws}^ O,}4>G>sҼ]gM MUˆeMx#I.oۢVOUwׇWVջY'~Ir>6tJĚtD^7 HOc/qI$=2Mۢ]<պy9v2J vi-.O=_h|]FRerj_oer q8.(T|K+i{[_6ut0 $mZ+m߯͟Nx3;i?1Q0H^qJGV*ߩ+x'܇#y'Vݽ2R斦^}dmVϘ^_JRMc:io=Wxo=:CS +"m*vq϶3_eF?hމyAM;ZH?؏u=ZHmå$mG'9_3:TUxܵm.β>\?r뾗ZY^3ů;=Zl9 dg<a/+]_sœZ]&~kñSZLc찄W0#iyǫGpʫZOSQIY˯{ӷKL ,Hf|&9$^޼N+Z-.lyR2+[iÞ>]:erA'b1ԋc3Qc(]=OKË[an$VaVָs Ts'J6{Y^7@pp |EiOSsIu:}Մ[c=GY:<qf73 ?L*Nrq~~ɞ#/8odL}H\8op*֔$އV3'Ry9'3ľۤUYm4X`9cl)lDj)]_gߒg&+{y#㏃4M"ݓcߥ~GZ-tcV?#Ac!b;} |+WVityRMIihУ]"z/cjTp[-ҥ{0<-;Ttd˚rWnQqldQmh*:|[LI۳XiElʣ63STy`c/-_OHsKo&6=S]hѕvW.XoK}|GoXyb{k)I]h{SsJi jK]6 qk76rUG<<1b_g{]/b}-__τt;^E`T#ѹ^өlu9ɶ1Ғt>>m6i,rI0*#iy{%M0e C^|OKi'Gi7 nq+5q -_KuT|gП :x_KxTq&cDZ u/i{;>[Y=SW h yZ[ԡ9 G"a}'R5%xS/>KSOk/Ve :xѫzn̼>2t(sFd@ֱ]*n:)VRZ|XmψnW-ܭ#$|Þ݀kR-䮬 W5bݚ %3BNAc'zWO+;hѦ{/,gev|`AԥFqSE+ߩ6#Ѷe{A褁ۿ=3ۡµYElgk6qejV\ _xݱ?xkʞz҅H/~|nprz=c\XltvLa~n9y?= EH9dϣԣR3cKΆ>s4RMČ9Đ9tJs$jp[.?OlOG&INUs<秷<\]u) 6}IhceY n}MyTio50KXב唴Z~M 7.2Gw\ۜCZ_#WWho'mK5T~%wlLJZV|Nu|l=QZp9Vdleqst8/z՚#g rhѹ?ʽRG1Wj_՝Y''dU\;o{c+`¸\S׎֒9ӹ$*Qk+dy߻lg #8C9ybddSYyb0?:ڏ*~{KD.-cX0=93T&_wWװg6]ĖSF#wgus[i!\$3Rh\n{OGڷ*:gx<-yש!vnUpXyp;pOҹsZ)ʤ)*JKWw̫;]XN.pmukTrքF' 4fcw5j{1V.U_˙K e+rn9dar6@9GιeBZ?9fojhd_jrp2s$vYԗ4䌪Tuh mdU* m EN㎸U—2LCAySSkVpKN9]n՟KyV#Q#|=1~UJƾF)IFcxv}p+Zw3NQԽdq >f:1X2_YS.Z_x!+y>QUn}keJj{I;ld@7eYF0yYX)`wuغ ӷ)ˍݓ{WDa 3b-"l6냌R-q]7fid=1֒)44*n}VLAt >U?7p{<Ҝ֩hr'aٛ<iK- Zqd<$XgI##58=]/ٹK>KyIހkxɥ*sJ#o6'>=?¶zI;(ڜic3/',1SsќWƲm_!kXwi &}F;+^em)SXer@cbngp=ZrKC?o/gIs'".63VK#RǨ%i!Qv:3WjN+_O!)MȎÐ{{gy;H%~^[jc@s|k9JAcrvW6BR;\Ҥre[;FA9yƴs#u ꨡfСr2r%.jz nBŽQ3e'\yuaקNqQ-iG(jOdvo@i.ZЗ~vo"jfpq8e=2˾bͯfhL+1hrA#:BRQi}#LQmi53Met6x 9rs ޜ%R<]imS5%eLO"FAwqF1'XxIƥj8V'vfp2 !Wnj.Tq8Nⵈ[LQue<}nzSN2qccWp֒@cyT Ps1V5FT?:k)֌gIۙ]ΡbѺi'8ke Y7).NJd1hBWnMGV^ {"j0W-9Tq ho4K]NFV<}m)k'b2^!7fY{sv m$5 '}T\A3sk7bCG^4oM+ *eL2A\TqR]LaNm_7:|8Z6V2帷+qerWL`~y{7Ϊ2^#`+o˓cҲпQiJͫi{F ֪*'ԚXJ\LKWb $lmO8~C *qdVÒK]E-oA(zqMjsSj2Waٔt/|\Vq-HQښ%M^(#/,`<{O[SoC*u%-`CN&U6ϿOαGQr9*b+sGg?3UaGX~Uܣ7TM*I9u0GiV+x՛jOS +:TSK@wϧӵjJ1՝jތ͎WXVGdY,m1ןaҵXomj"3-޺#hCӧKFihZ{ǒfX Saө\is0=:-ecyʐɉ=<3ںcWyY.}b1!o>kiγX摌,aLqd^淧FN*2_ZqkmsFxYX6r|:ߍz] i֡&=ÚCtd"m}Kmc-\R*QOGۈMP夯cZ=-;[d]yo8>m)ѕ* K}  [,:oeb2l>##ΉME[1u_3N־u)ܽKb76;*+H9wN|e6olS NFˌOn2[4qF.z9}i.Jz5,c|D\o0%Wp9UE9o8+w{~#%摚E_s򹔩\mkV2>NмU Lq& k^,Vƫ5M3 f~07 n2{h>Rc-]|FYebWfVx"4Idk,ok58cbf܋qYTWb%h$cѵ-nf *ϺƱձ RI=,:5J26aom[0 \L*gFQOgʊu- ZhPg)XF3f9[74RzJʝKjbG[t6?*~F/fջWڥż#neotzb&Lqg-qנWVRDjҗ&ɖOm?STAcGXỂ# sӛjVIae(w{^D,F-mfi ۱Crcތ?5XI#VGW-tc "/RŃ =@o⨭B3-Z88"Ue̒/ُs`#ⲭJZr u)wa!KTh#*%Iۦqr'{1 ss|E)3z0+s4N\ו7}?,Iq,q@sTSz_]whBz|Qn#<3o #{%m]+ N8jZt +dpO~Fk)JS4:rzYc( {v)X YFXjƊ玞%Ʀ$X+9gokU⟻ٔ&ߨ-+n-dxc,烎v[J)JIYkO;,67ݫI rvGb[#-W]:q}E9UZ==-BLѤw.*}pFNiJGIƬm kHi - b@9}{M9Qo{$i.6Ny#1Ƭ[qr}NO{Fņ+Su`[jofIl8\<ϡXTir-{*؉a*Qd7*u0_0FN0A'Msjb%Yƪ׶_v"ՊM} 6jf*r/'?[F5hƟDo:i}4]gyϭd݁FȢ?oZpѩZzld-8ON׆rT+o-B@g+,_Gcy,.o}iŦ8iIhF@#e۷ŇR܁8}+Xgcו:nHAcUXm azi{ ?2jރ^Wi *ג>m(˝+^߯ȨtK]#ۂzt4֟fq^%RעFnU|2H?ZcZ;iMЅё6y]yy4ӺId3͎ѭroLu}E \J^wE5$R7ewb@8'5]˝IFi; 1 +ۋ3|Ii^EX[*rU5O-Xő0 !bBYʜyZ[S\?&f EIt {?ȧ<#R{fsq$@n4{,#R(Pm܎]9' VM?p#GzR(FeȤy7,Fr)S\&݁K\RxJ6h=3 ǂ3sU+˩(+օI}ЮCp1шnInN*6+*˦^˹%U^G~rƤjI)JΣN/w!)ȓ)m*:iNveҥm( |{{X͈T r +s[}cV9/m'g/CegOe*Zs?JBiK/fs=%R3dD[H]Kv1KɁ c>Z5g(ƋWms.+:էŒGIHu_n~sV2q䩌yZ 9>"ßwq?_ifbF<:9y2288e9F<kJ>Ikb 5NMϷkCq~UΥ(h]_ZI&F+HcAZέiFRۜ5!O=Z;PT 6<2R9[գ.NmB1w&[h}zq_eNJntC )S-hY[-l;2n5G5jNiQ%̒L E.ӂFO^zWaUNk:&O8ڛӵ})RWꏳZOԔ"rdkm?)#=cFևBQ_wM"&E* &rx<>ٯN3ݴ{8;Q-\8&W[S#ȧr[6oaz+ܴL֦+[C+T)vwVT @ X`cJ\ OӿSӍ:1q[ԯu+o&>f[nO[z:5i:(ѫ)8Z;|wֆg<Ҕ Ͳݚ& +d9=9S8N-WT(ӕg4?̣O7?R|2GZu(ԧ y5N8{/z_/Q̋>x3.fױ={TFM\֩[%KxP\jN_k;;`2xsӞz0Fv/v6r72l󷒤c9:q}k/G75>X5S0|x8$coNR@J.kơحMfLcG*jMyZZVFݔgn1Pr`gq+Em/⛥doK_S$Nʪnm2s}k8joVPQr^\l4"u;AWv5ׄK?GrTڻOkw}o^TR[=tQ)ֵ?P;+rg"N*S9+i2lbvԟ!FVkw)r[\] 게5וֹ/p,.>}O]CF:R촦If}#%ilaGٮ2kcen2ǑR8+1(8CFۚ+vhdLkq돘cEs %%k}HٹX]I>a.ݧ:dt?\!YTinP1lj[ {W/ ^۝gc-ELXt>Uy3iƊIλӄid$¯gFqnTN7} ZD͒n}kISe'kjJ@:NEJ# W-UA׊㔪UUjҌc -#vor6vr O`9IVukTKWyOJDђ[sc8<{֒MF[0Z mlÆ]Wz)׭Oz :pҿ]:=2T,YY=K]rU+Vwֲgo)! 8CE{e[_8\.rzr g/u8{)Mߗ&m bTt'撋gI-Ϙ#A1q)up"(cl>[OK۷jKoC}C*cӵ6/S EE^m֞d@*1w{b]9gN}x)$ip}1sB%+Kf>Zn} F$%Y~֪^ΜZv5jQz\ dOg*DC,f5l*}kW{I(ȎU´-eu%~F8?h< )I-i M6c'\9{~G^-lŷ0Jk{u0xZޚp."ᅤ?9ӒjUW2T3Ie/e~Xzqj|8Kq[z#)YvyG)$ΈД*9j^ĖkI8y毙B.ck+n|^pN{|+3=i6mkc@s}*')GnJZ\ϰ\)2|ڮ>\&'NdJ4=Jvۑ{yb0%@iWH^#lq|m)]9=%$2Cf#VUcg99jt{fʵc.QOEms>:HJREO޴r3ct%G2H4ĸO&ۅ܂816n{˗N-o69b~bgOU[VcQUG$dkUFoXsZ_c3CkmXb&z{}HyGqGour(f~QXv>A1SN>bj{hTkg[=Ik?Cމ|</fu$̆?=UWlydpR@{i6^2TNݢ0ctl?wA^q'%YI}[OnXȳnF06a}9ϵz\ث56#>x0q"!=|F>'] ͏0s^]IrTiˑtLdRa&R'k=.hJqͻNy9KVZ)>"*v<:C稉$e]:GIJ-cIxM1dkH,ެWGFYO^|ԔuFtjSsFĞiSs{~MqE[MC CvOZ6I䌪dtJ^=IٲNIoƝ:؈Ǖh*-9_wmcywa~:u 枟jHCC5HA# ޣzK-_sʝEmKmb79>:*Tc~u=D{|6TiSЧ9-37ڤ]@-Ox.gR-= pn `LE6l1;'V>*j8Zѣ+I5s&dFeV?/m)N~XB*ZƜ7AtwҦ%z#테;W(ԅ9j2|1ZhkqvcY#deāqҷ7 o~+QR7>F/4}>7vr2)h^<\]㦋oSyumNwX1mq=Ͼ8Ksݔ'uӹzC6ZTi<Ԕ7҇^7|Uڽ^W|K_38FI__SƑdNﻃ^z14bϚOG9fi`͜jԪ8iGb 2}k)N\GR4b&t>gfhY8ۏJrJ^)i&/~Ok_m7"F4H|} 5#&m|' +[qgBv8e*IJSNӄoC#Ԫ\U#TΖвcN=o¹1%KU8^e xYWԤkV`fI: l0l=&69:d>QSr";6YY-x#A^1ZgRU</m<0|pn5 %I]?0?7ׯ^+ƩZk]\D:]WmfmvgCp7s^\{IȱQ\e~voUz:t.&uZX}1#w16_J|jud>$z8f$g>Xj>GxΛRc̾ѷ9+ W&*[ qzEq-˫0N"rnN%ѴƺYc<_j8T|CϨO7GHL:߷<׭OQZz9Gk{|S_nEK:[J [ OU:dJadT?0;8žk[zs9]nKWQvm0 G=kϚr-w1G1^!Aik6]`ABJסV1_?@e x:E#:4<ۉIRFx݁)7cǭS~u{lmf6{=^ٮuN*srnO:׈&Y<| KqGֺ=N#b2M M80r QyҦR4hM_K]^mX~;uӨsK*4:_S 8J;;MYB:|Lb8ʢw8XzǪ]ŧ> R)a!=9󞇞`*.UQ]܌#>nJ[mr[D+۝ O2*̄y+!~5Q˫ixu2zu*JQZ46TeݣG0dc#e4iFR]\-QKE۪q|#\XatF<`W!zgiMwEY|IE>w0(v|۶\/E,Qmy$~Lnp.F H;nݷxXTkW,E7/vI-~#݄Zn4KtHѴa($!ǡ85U*SSNnά%nukoKs՞&o+q`vw1}pj"RB?v-~f\";&r2c8=:>7~M+ԧN-}ddeGoSi\X8\N^_㤻]0\~;Oe:ԭcەq?z*۹NMpIRMϻ){:,,t Mݬ*y-YYY!ض8y}l6=kyyFRg ȯ@䓜ퟣ3ZKO},b֍ 8hSkS\29F{U^^ujumN*˭o_jJ3+o_25cRVZ5weF*sz]Yo#mFcxcccHGQ3skcFлrm^}ԧ,[{io5߈5-v+MV(5X@}dNzSrJ_= 1tէ:?x.zڬ1NђIPsV~+FֻK8z1UK|KNVH[,Y&4["d~cR*?6bR-]49oߥnxbEfVuUJ8M[^GJ8YakǛ{6D&(!eibB#q]v89==vʤ88ߝobݰ}$H>y{e*v\*v^"0wɹVIj{\^}l \SH|OK[O1&FY-p L8 dO=+_>k_sέg/ݫ>mjPF@ 8#X"gIs2tZГȝc=dgpx^ML/ju~9mŸF$@cYDy\ xq\T掾G/5l=v)4kw&so{5+K͈³0^2O𑞙 :jluGSOqQav7O-@8PS&T\imjc@޸e) GB)'v;;YMq7gf`;9T¤}I'zTv4ieXn:i}U8Stl/|C$qXvw/*Gn8׭F\4INONR=/Q{hY#76%llq־;?ٟU(&~o[?cI׭B9nB'* *rGm]u}?~76TStA6!9rǙk>ugm2 Mrյ+%VĀ*:$~*rJ6_ssr'o믩>$+*6gc9a~.kapܡs5M~rd`$FW?2?ꪥ)qw[_k)7N+8O}%p$[|2&2 #8#`4}&>^mMW|EuoycjdcLXN2qqMkSCE+ȌڌъI^A 0ɥ4|p9=0y? ejҴ skEm5mZ2pS\e gFźE !|o3ݱfRV.v\Sr矈WV%ii2.-Z+6vx}nID~O>-|\뺿^V<œ\O pUQ$9s}F׌S>NM7duLHAGc'tTAs;]?OFU׶vշ~_/"Kn#q5 A)־;6ԓWz߿٥Zr so}'ךr0HGu+~᨞ZV]lcm$m,cQ'8b:s{\6U(9sK,1_w9a|'=o9R-KI'nvV2I}3j|It0$eHme\7_9?zWgVvߨQ*ƪspsJR]}S_wMߡ4nO0{-$6?^q\Eu:Μy,+2O<%I<+Ro7_¢I{wyKb~S$E*qFUՒ+AՊy$ rwQYrK9FJ*Fef\t`t_\T8=^=<ڳCڤ=;<ҹÙ7XFٮV 7mFާB3@ We9Fy2U**A%*[mnyrGҵVhkF*&רa|Ự~5Z\բ̧,ְJ!# n ԁg]1bOa3M"Mr#/,ɕnC`}q:R}fw)o˱[A[sZgENn^x/C6#YFӚꌟ-Vn& o-\qNZKOI= P*wbW9"7{nљȋʴs7ʁ_ßNqz_nX1vwʓY-[EUx?'֜]O{jXtNwV’Nx#]5yԫ*u9ZOMWG1XzM<3攧-S}o,?*~]pj(RnݍNF׹Z[I<1rNivzКtZv[UIfU$ =xu wn۽*%˽Y~l1+cZ2.W3[K݊yjҍ8ݝY;\$*Q1\5cU>XI l# >\e(KIN ],"a;uqI7BUW.u#7K>N-]3TӶ͋Q$vo&eF?3I}Jx]<::-7V(oOS>_bDM'}^6J]UۆG^MqJК4W::`EcB8\àA~J;=9^*nXZ2HwX#g>hd}zҧRQ7o𹡥 $O0avt}kUf^ѧͣOȹƄ.aUԜpxӑ۵p:~1╟}~-6Ę8(|w9ӊT_I03 *q"%SCMZ?|A^WTo^;{="$zUP34T`eS{%n 'w{q޶|h :E- 0OEn nrzq^pҔW,4b^p 䑏L=[Ӈ*K87箮lHn}*LQ v5rQpN5S$ߡڶIq$yGO&֝NwZY!UvR2[q~>kd6:+OjWm$)H-O]ыqI?(Wڋ՘\g* 2:|.)rj]RvDql`O98o9=ONNzl٘Z5ҙn&#Q͎~8w6EZŶ ^FYpN9#ڰ֣^O&tN7O[G±^֏,ebmzuc$vk#|=? =NfK\Ck2I毦JY9B[z3^ҌӷPk?tV>wzJ~Syjއ+҆N|t(r7m#iFԔyVzQ)8H޽T=~=H87w.ć˸[Dݻ|k0r*695OշTE2̿cRܒ=HJRv{T) A zcڷN[ݣХ,,F2~Z\ٚܩ;[EhJQ[~&8QcaA0'\u%Qڞmijn{͏YF/S\\.3֥:>FFzlh1||x气e rk&hvk8bcUQ]TRMxi=_9Aͭڪ,iZG,eR$}Iφͼzp݌zW-lDjZ?"XzUk{h;uU-B^$kgk.lp0y{T\vV}AwȦ8'aUBy$jqj|)z>Zԯ=4M JkӚ^MR\]nբ n.%P7*882JV.ѻϢ1of(@#*Ԋo92t=^1f^SEޟ,D:n8rOSn' w lZ8ԌeIұI;}Ag/zQFrTĺJJv7&+R^|3sSGE^rܬUjuZj5K[n3^=?uJ%gAsj\wf$G EfRtVptiaNNJ ^l~Z&VFߛ>ZmQusGiVlo2>RkKZ*\t}#Z>nYgArԮV8#pd g9 z }VOjEeeC-)gm"m-_ ?h k>5o\o:i;DC+rAR<סZ8TQO,M{P@4l?|sxm}G,({E.dQ1qI~ uW # Qe$8CrF7c^:Vê4MʦZN^^q ?ecVyEns$ c.[]]W EwP'5pIN%KǮjrwksx2nf޿t.~sy[}aA;6Lө=e(Qǖ7܂gYhVQs/c*d򝱆RaqϥL"LZ;#-wʠɪ\%̔e/hڲ"y3\$ox:W=HJV.q?s[ަsm/V| qigcnbzskiJR[mON=% S,Z+ݭewG} NTbRkM>sž"ie#$8nmm2H<5Qqog1FPRIzW<>,|{%+<1ۡVs*N1:g7nÝӭNnJͽnÞO}4qtBI>W(._n{/m xi:Ub՚6K_*Þ=o9$Eڧn{'E|ec%<7}s3LfRTI={w=^*a [x[duGNFq^"u^7kf|*HӬ^Zωj1feS>޹2g<󎕞*GǑVZ^'m ,}^֬yz_ /z޷5 ^Ǩ1cpS0:%Z<Ƶlte_%uew=GHѤ<3ɕ,*\qCFd={yp̫͐OONJqܯ:sfbq#czּju4RIܫ$odc_z\wEL|]emwk$%AQUV\ҾF/]$>sX*IxGc:[.8yiN u:{xH۱&UN];/2O6t/2Ν;FVA [ƥC( ہqQxw8RIu_[$ͩƄw-o}/>Y[f>xڽFT5=tbh$kr/ӑJxmaUɜg o`ɰ`tmMkT9OUΥ]],/P@UFZWUەYxGTZ$H'y NpAǠ5NM%2 %Qm5n|>ñ RL|D>av۽+x|؆}Vv-ײX~:%«21\qr9Zo0!M~gӧNyouLh"nd[-E2(۾RWdqWT,D[Ԃ%saYXV#k P۫"ܦKAS~]gFg&KG Ӕ_~=/Ğ'ž iϗpg=uab欙Ke{z>:%3[Ky%pN: 4hM#)^jڜo|@h#o$H+؍IAFyu%sr< 6:_,KP:׹uQ~<>~pvY$YѕW ņv5s+}C8ޫ[vܯO%2HYXwn:Fj(ݫ}1s@ieG9;P>6;(֔Csz8z2cUc%^`Tmr(R{{q\M]N>n]O--a^dILp* WgPR{8}<=aUj/Uپ$[wh)p6:qܚ0z3ΡFq園V󤨳c!ڬrq'vbPn4Uպ bRq'XǺ5@#ʤ`޷50rksC]JO0IVW{WCE,D\*|)kP̒1|əK z{W(Eath^^g1 6>}lڽ얍ne9#sSJNO[Mq{f^Q*d{S *8u%$vflwVzIVSԞ&u7t^/7>VwiZVgD8%ОkYeF#R劊9QV^BK"ƊU )ﻁȢogJ]6$A -~b݀yӎkIJ1reeб*VO$t𨌵3O1wdč{7#=kB\*+SO*L[P7ryELlgZEKm uvV1;vAIяWR䖖A[,wdmZ^WJliTkrd*B2FzS*~Ν1`QVnVbcNchӍqi^kQ CyNAn~a;uѧR65̭ AW5&2rzM=pF2Xc8[J.1R]g.I$T6͍qr.J~TA3[oTGznƊ1+E\(%@#.~7g8=IJCa0mRQ=;b#64{5A0g~b79+f# TJ 41c_eIm: oRL re,eY#sQ˲trIJa,UYuPY RFY1<\֑RIZ_*ĭedR$e  Y]4E*iZ*E2lۿymsҶa*qDR|`Q֜jk}@,\1N[q F*Ȩӫ'kxQ_ZfLTKظ(nhjv[o-c}ATZCeȾh mÜքV#=\X[)lnq$Vqb%k=7eYTK W+ '?TkK!s.ھO1WƧrub*{[ȧw'R&C3MTe*u-$c1lVj8]ίo(K~T^p{œpp=ۛ0?32& 4_zf.GN*Z`yC³aݙZӥ'GMsa\;S=ZHQn' rO~ޕƛw*U9ᦧ/ )|B0pF[kIB:-ͨNZ<>|'ζs:T;@}qk+7犩N8RnnqӖ17-9'V8ԧOkmo*ԩ7wkVBnXb:}CRXx*Wr[ܖXe$nG_ҹgFQz&tу.5ޙ$rlgJ6Xxѧ-_װTU`Wh?J4+.w,w {֐P]{{qkGQ  )MHΦLCi=OCbJݛ9QU]xacxNV^t4"9ӌS3F09Szytsl?̾*eOKSUw,Z\]M{i,=6T27 p}?sTTZ:*|QCͅ6VlV#h`3\VѦr^c'0kXeUI/ #\RQSi>U-_Q'~Y4fBI$9=3QRBኩEZQǛRX[[?*3[,sI'8x'=QMLF"zt]vVg`x,u}i Uy,ZhV7uz%F4:9-nN]:J|iw{76e/8x9E?;t`#lkUv8V֓H/18}cO9F۽5Q/S`fR}몎P/gM9O驋yt|[\9TR.-NXT&!~}+\.s*|TNae]+S^X+[rmmLaGEՙje"_ 챠$zuQWCӧ/Ӵ Oa˪V8*9RWIm.|X6ł~nNxak9ӏI?/SQk;Mû }B߃7w@ܒ:qNm&9Q=ꉿM7vZVX{feR;~r_X|qo!'y`:&eIe"+n2KVNQni}E4tP!933F8n;t}55JS-V{l1U,#Ԩ%!V+c+H:t5uhtVt'g?\#ca4ll ]3Wky_mdtfi S 0Iƺš覥Ni]_qݵh(IsuL>]53=aG YE~f+BF[$ chI]geTQNַKwy-"#s׸#󨟵IXS .WbFY.W=9IVQGEߞ9)ol޲vp~zo.ueQ EţO_jPM*fڿ;W$U&zQ=+Ehu?%X+\FM_g)cGMډ~o=QRK]۪kJtk;i ;ՑX=Oj1|u#V%BDu$XQaN8wRNϫ;-viǫyGwCWzƦ:p׹eu;6G9$c)iS*qӹ:/U_[By㢡7-ZQIX1Vzu)'.8۸K $U4Wn{r0G⹥%7ʏCǒoukI.ה W' :sUS۞l/f#mL?—5)k览\OeC4op,ڱRPpUI5/'Pd 7;t4hR_n荰O|\sVi?Ҋ"іNw2U?|1ӧx䋬%&TYCbrO9\tKWs֔iڎt,-4NQwp2Ԋ.ӭZ'ԡ ܅cskf'؊2Y't݋Iq{.%XZ@ rH,Ic>QimSn.V+"ڌYISxy'Y5^=ˋ.ne*)rx/1_;)֥NRSCm5)7o")&bcyJY0x )F=[SU{hMDimeXd9K*k2z FzbjNeGi~iB[kQ }*,osYFj_ ..[rpJ ֕M-UIt$S#~e[_iF/WˉlEi'vOiO9~mV01DcmZiR`Kٌż~mnHڪy oZ?k.NemE` 6;W%JܶmUTbϦ S=+=fb>V\J-7 \gӲWU=+r.jwތODl+29yljFX)Sk*N[<.g5J%tV/u6{jFj[! ͸}>{zr}xԼJVNxa|rhDև_2J$82zMMॹ1+[(@7FqO0Q{M I%ҔKuYK{Qo3+nA#;]؉Bln٩񝤑#@)C߯~sXz-X*wm.JO.Ve :A50v_芍2,["V]r:xu9yמx]Kp 6rqWV)G,gJ5y#M.^9涅4?up'MX畚ӱXեEN?ONmSܤ}p =+4SӪfSN/Գ RDɴ;O?yy#WUr#FxwY0=6|zF#Sjqˮ hNn%'O~+zxTq8cN|ץK+"tv돗~p+ju ͻ&i+TF~vTJ +S/᫰6cnq>Osּ5&i=WN-HUu A{-^b,>!`Uce Fsz@yvѡݞtk̒],iAffGm|`FנtcO{#}_,'O!pO`NNrrKNϹQNJjW-Xɮ.>Ss~]W抲\ߘsJ}HdQL8lZ8ti[T%kL%[Xy[ޤ`2@ӜzWUBk7($]2xTςR8櫙JԽ[In^CXO'g>4+Ӳf=7xl Nl7w:N׾A&LҨ,2;Jn}8797-_yv" ER71$1nhٴܬ֭wF3|ʡ.r:W4{p̿3Ģn[t˅H$1,EJpqgGYkC/$ʑ۝zuU#wRZKVSk#j=Oܕ~3H',f'ssY{F9븭C"o45d~+ƛq߱4I-Z׿ȧw\m,cKz7[X, 'I68+5=֊RTۍ&\\ RөRՕ7(Ɲ̻ݟ2ӕhitf?XVWڷ'`i~c}k%GNKaTMǙ--A.XmuOs)TmfltUWxb_'qX?i9&S \=ΗBks($z:{\#F3r;Z8Nu]Ķ#I23WzTaZ´/M5':0R;<' G$\`gEYB:ESO,lU%d-GۭM.x'/冀[۫[Cӧ&&yFTs^Y EapۭeG9ՓR4VDqbOEK^',6c!8m-z+\ʔ҃fK,F~n8-?օNNwRW_qM6^USG|qYS1AsVkw69'?zWJQv3w}lA:Bۜ'3/a0zj1vf9eMٔ糐ftBUH +*?5v(Y[Җ>NC +F39\ܼװlu\zJRsKXiLx}ϚNWpkNK4qIud8bҶrţ;FO1|Ք4ź3 T+67@=zJRN]>͊VR8ܴsH C4OdФ˿O#Ҧ)U۷PsZI[­:wz OB擥:62tա֔eJK|xKٽ?^35=J/ۮP?ӏ1Ǽ+ژB.:~GoBu '^=sd45zXys[N |^φtv})i3H,Hk:9ym}|hp&^x>>Ҥ<+B߽#` c<zWaSR2c3|*/i|ȾhuMۍ_o։גʵF9X1Bݵvb wqԩ%txTV=᷼gN$_۞޴Z)R)/@I7mRO͌p?_yTrIyi[s)ثڹwg/'}!$R|~NJ:\C$̍G)Ay*y?{Hݛѣ$9k\-68fV+ +tۚI,Sև(}?c_j0̅Gc~#KC_ 5ofr,ʰ9\}z~+J35{ksN%f3".o40XmnVX{ZR#GCh6W$H[ɓs4e 䎻*c)ŦgμSYԣLP_k7_GϽpVu><[_=qӝXzX8ʬҔt䦯$Vϭ$wopy+0T*-?}=:mɿ8eR<[y-K'̤ ^la sKiso{y%V;n;+)N4ݑ1R_g=ޅŃJ+_iM%iԋq[Y48q5~SҩZzEۃ&Lj+FpSR KቖYkl*WVVN1f9.?.uoqYumR>Z3n$o v𸩕/iMG,f֋sP3`~5ɻԧ(Եڎ<-TFsӟigRQQv3Dq]&l-uѥRVF6lX[` n\*R*m:JR,nGZ%QI="rk{"#2svSqWF8Ah6y{ͷ5Jr)T>x#fI'ݎz J]FQ}I{?4KwZ6SRK/|;N#*H*b}nݮ4{~%J1F.A)?Ք:R(ل7@Zd囍RjQeԼj>_2֑;I82̤Oiԥ9TiIƅ)i8oh7ʭz ZF۸;חOZ35#)P׹Inlrb*V8ХxCݩ.o5;gg X3^-jcjT九skcܹXܚKs'.XOʹ~vXOJm˛;O,毬jVa{ &GWT^76*H'ӭ}VϔM+jdAr6mo$EF*>M]Io~E\eObS**T}lip7ۖZ)Ki^*Q5+7mBXnkE<?c(>Y\.y6Śu'sq>Áqŵb(օR>t]V7ΑQ6;`Z!hu{xz1Nש[Gf/3b\y@=+U9omr9-5Oӧ[/NI<˥ZW6p;~:nI-4*,=HRvt(%V[he8%wqykӟ2NE,FBx1mh8RTtn{cSz4p2*2W]># ?g-P; +pgRTA8䎇.59)Zw}z[euO5 <[ jGḪv*X 9)~_2f oM>;Ea4iYD_+x_3u}{yjV{u˦x1OOhGˁ;R}yVm+3oEJ}jirܚ9*rj޺irbnJ*VڎS^XYkF%ؒbeX9rQ+n'wQMv2 HuhYv=[>iu8iÒn.| =יRCIͭYzF獡zIZ+N7ko'V9J.rwCyX+s+dz~e.[aTftoc]is汣w_r%V}g*ҍ\jRu%$iwoP@l;ץ^DFSn\Kn>eX ܝTnV\1F>6z{3δBcn4ׯ<^h#W}R[7b m##8tSJ$lwVݴ8Mwַ~\HdSʲouƵEZ)zldMX7K[4ڨ5HO305KujTT_MbY~QW,n=9>TeRvW;*#( Wy\Hu~mOQ\ԩ% i_N)-SӼ8h|ɚT,ύy 1^n*16}N:U:rvnn\WFa5?qFm0S֍dyʧTuV|[:)~$`Tc=0:'u˽&g918pN:Wz+aʿ~[%#ħQǿaۧuj1lnJ#H_s4e8^i%Xps[X:F=J\btx(۱̩syj0Sƅ7rЩ{;;=iF1GkJK[2:~5F:= =])CJVfe39zьMJùEԹkȟwiKVhss(ѺeeWBT_z1qJ}tw/yCBf*Y-GEuQ4[]jY[mq6 @#F{Q(q5)Gda)& -5?k-&ei5%B1rG_\~UV!kJk߹5/t|y&r2y)JVZ_o&J8d4 ' (sȯ`h$9eRMdʪ-"׮?}vV=Rq(^ mmpr2znkӄ%(o(Լ4R[4?G4Oi~C7?wV;汌5S*tgyҭZE̎WT?xYFua<~>j_"UDKQYQ ɯF4+BVۺZcG ^2j񾫿o_v0evcy..0Cs9 xG[ZYWnۅXw >|s_o1eM|.qӨ8>um'Lɻ|m/UnO?O2 >xX\wYY U+={**ޫ0rZ x=q[lrrpT+s׏^8$(}41XTm%kvt%i|_흭+ͭu9HluHkF3мEjIC$?*~ e䌣F:oVwB:Iߴ+&b; ?( 9W\T_F}imIAXm-2#6uT`9Kͫ+zCiS$ԥ]oMF[[Y_ȍ[dCF9zھ/]jVn>+o;5fҶO_U*ׇ]q\Gt%VI6qcS06i^׻=eZ~d.{gg,t[bѽk"ٓG+lk"7[?-Z&WrFy}ǴePtԭgaEk[T"X gюWΉԧ$L-Ֆb+6[iG~xyS],e<<'ou?M͕X?̡_TF,$S;rܱq0|qUf iբo:.#n^޹FQctQ OPo^ fdN֊y55Kie6kv{TAWW&?i% $j8csN}Mb/xJQW[>]"[yqq't9߿ZkS.k'0@I SalaGZW7;Su[uyyCl ~fc{ W%z\ffʜm?"d.?V;2;j*Ch%5f^ ݂eRGʸ 4osmQ:Ub/˩rDfx7 cKKD3u\ sL31eaz?LWԚxv_?Hec@ŀSh*<>s`ʅ3"$ci9nm᱊YJە{-#9ܱIJsV)FҬWJv! 㑶ld9G5Rj61<.iM335nÜxk?*R[]2@0EIz619\һ9?3r32ZQg̼̱JN]^ds# $e0Gr=1ӊ5*'ebQȯ:s]y>}J39ٕnmf64*/2{t⺡Q"v'LwZ+*IR;uDY{ EobN:Rۛ8$= y\Λ}CI-25 :kk0wQ1{ONi4,/\{cjΤ$uR+h6n5 /͑sUEc1 D[[yJrE5\>ʗ@U)˸ )'XY3j#w9UNi}iҼ_MUnʸvfcۏtF43>[JA*g-26l͏|*3擳4Y)ȭ=it. ~⳥ {[Rmy=E-Fc <# c[OukTOQԴ'#YQ:(RE6fmo31!F1B=kJOI~NXF FZ5Rw(UUhW#z8+rnD+N0ӧ#;@NܠE8$}{7S|.Yˣ2K|$EǖrƸ+>ƝiF˯>gUTҴq*:|I,Iqg9JK8cni{cӭ%BNp՗$vsKNزE܎Z_1aSzimtk Y|H9^}HӝkK9bhI{Fղ{mMb9 d#\Nf.c/Y]fq$0eWb1ǧS#݌Vũ<UW=:nSn[W$I]Kxw'Ɵ;rƧoROl v̤2z`wW,i){HknKo sg'N:Nj˰FWs:ҴSݷo#:؊R;Y'Tfo3rɟT}n)U//3߸kIGviXޚ05)&ip8]FHZj)+-8JQs.^}|e5t  å3x9ϿJhԋi9j~Wк1v|(= N^fUԎ/>#9^S,ͣN2$.Xik^O3߯]#Os'e̪P2Zo#6̱I#wozYssKTcF5ͫ ba},g=W9F2)ӌ̕.w IBWYKƛUq*+Vm[4W@6D-5…HX3{j]Nt0"1i4[f-a֑oFjr/!RG7y̓"«/z/n敢vdkvH$7a+:w:iITnzti~dkXUEݷ':=SJ|5=ԒGY$ n['T-5!F3۬y"-w6735֥Z{MFnjZG UcsNZJ!N1v^}L}OFh,ʬ!`*?ºonNe/g%h FТȫ޳8Y抋2nK3/ilg:r}-LKKi*yTݖMu:V-SOB4Kcb7KC4ُy%LX7m\M[?ڴRm4,&BJs^׫Ќ=iBm5lDƨWuZVV)BV}JV}vޯ.rղ%Pv6oֲܚis(lo˳k@Y[#nEsZ>e1j*{ZtAlu㏱Qz#j>vGr_T Zig q$39<ڮv'ٹ>$/" mw`O#ڳ/7pi_ZIr 1&ըԗ4/?g xǿ4ѦIy,Y,K\\)=@$iݮW'o艭x)E멣ux@{i~H#㺅C2c;7ʨCzG;)oYIiV{F5',ƶVIodQ7AFp }]b1OmZ,R2Be2>VHN(]߲novۯSleMcR\dIZtzFcUdp)=* B 4>vOu7}ofiOGZI,s,ʼn%2;l ?Sh_ⰵk+}>-OHվx$gz609#:pଥ%}:#,:3mrq}zu[|7^EyN&̵Y 䑀(Yw8ӳV{O>'Z2çf=QY6ayDy9oAOOQ^]xžz~v^U 'PV]1['8ͭN0*}g{-m;WѲmA=G+I:*7[#uo$`=1XJ^+Nj7HB.#i$-xϠMroc0mD2H1? 1צ*s;t7R\+jcme|wKݓMut Ui$-j*1b*ioS̺vyvbG\u9EԕO,e˘{&e"<;@<CZB)lp1o3)JNOAϨ@H A=:>z-F5߻q˹k|sӏ֔#̹Gv3 I;Hc |q^iYZv(b'eT6hGnğWCЫ{coK/]m'%aw˫17lc]w+oٲNq_Cˢ3*2OԋT0PGO𪄞CJ\˱VCf㏙y]4;*Fte$)E{ {sQ*V3!PEiZe_3#l0ss{C;9hsY;%e9e8`=,/,)7it7m)OkY#*MHgo-8ヴyبNT㬣BʬKO|Jhze֢w %5r9$q؊«j[ VQ_kSp/ͺUXqǎO^Sq{k>]TKMz}?>+jHOhm03zי}j#Ѝ֞2>x[ƺzg9C\9[t,ujlOmRNp=k5[R8KsʿjχjUtX~ ޾kw_5Ұkxtaۉo9?729FkV=L2Ri5|Տl񞥤tK;4oT%PGps滱0Rfkpi7 ۍݏ̣9ΧWJiW4pl-Yd/ǙU g\ b MISyWˊ*r7>chM,uz^Z7ؚ9濒='JlmVXq3y5{QRܵy~Umxr Hi.6g1+"*rwV")$ڒ^>Oٳ0巘I9}N0s~_q6n#/iY>#8wI| dByzkԩ#+wca׭fVk~ .]~k]GYOH@?1BXT-UgF`hۻ!66\ʸF~l`׹O ^g-Jь:O4ug9d8PIQb.j6o3VZɵФX..U6r}:q:rQ|K3D3vͦbA&x8rx:FQxәz ={߉?M$mrn9\@#èP>e5'˃V>9@iKpf,rC ls_W)LphrB:9o]k6b/CG  sӺullg[2;=^[!!crG%yʦm4ub2Ozw$MOI$awso:qӥyΥjכR5k+>cu7QPch7nFֻb}GvW|ehB 1bK9zcOϳ0U̶'Gi(>%.Wx=ұ94䚊-jvv-eY6t`іR1s{WPMg$5 |qI ⸥*ӊvKVV:4߷O2J,lULNR:sH꫖scZ-Զtvv K53j1Atb}zu<*)ru4l=:ϒwqԿ 4<#V4e1d-$~P@%HcW\Q^s(5O^,pr)[?rFRt]N3מzzK)l%ḙȻ7+Uy$ :skGi+NDs6 WN7sFU#w}.1lv<~57Oސgv G<',;Ke܍/|,[vz7Nh}0F.rJ%y[`nAžsi{N|W4j{=#UukN]$rc$"gvPy>5(TVjYEhmw~}Mfni%Bb5oA֪TOrzߡ~L$r}:Wi;/-D#8˜GOZ7h+Ҿ[̥ U%pq>ޝ:jWqTSObDf|07G8t(es)J%Ũ9[9bpsӕG-.}IeX f  }JTԭ%7ԐĐʒ;"LnZNqi{9BIf2m8cϿii+%h: <ךY~\F7JB1kN%QElya ĐX4bpF;Oa(g Q9'8sed6d 37 ] \Ҝk95e8ŒۗiʼcW>[NRVBXmR?ڶx4hLˇ'߯\?SYҏf]H=[dyVu*\ڦ\R1YUJ\vsۧj]OB. xݔdn|w'-V+'hNr!9>F~T, s2\!0hSv6|ђĖjK$x vNFD՚TZ!"FOj1;sZznb g@Oi.Ww4\{K"yYHP#Xq]'28o dW-I85hȌdp9=3P=턥oanRpgc֦\%bFJ$KwnYxd7szyjrpJP6I?uF8(kBeB/UXϕH~\U9J/5?B cTxʖPqO/D)oF @߻-Ӄ5qqݎڛEv6N74cI)-Q/a'4(hqmN~l@wH3מ#+~ocjuJž+B#cGn1|)K݋Z:uG\BT~-K]6NC]ȭ /x֑唚#{NjPzĖ%Ԗ?إ@V5f\r1מzSIHW{9=^$+#+W)K(G\cTv P1ߩ=^lֵ\=NjMtܬt_0#zYsTMÇ9I)XKm !Ujuw=믖# Q/^Vøm\1ubϜޟ {*qNtczoڱF̞U٭?Nvw.2捓z"]~2GumNNEiN4=8.x^Fe*#V5)ѪԶUԼ,a:5I~k5%mt)Y=NL-IJ iȮcW=WwOƹRTZ.AkS]\ޑ<~ҹ働FҾәnʹfI ǘy8N1DZR_n%w]73s'[+aYK HΈ}^ZçSd[ڿ+}oƢeRj)ՇĪj;/jyvW\N9muWZ +"ʒyiӔ[c7D5H`q|!],:pi^+p+a.Vџ,}u%rea23Ec*.ւSJ:+.ڄl$CayH8*izG:YmsD{gRiG+j UT4VqO+5c"R[c$۷.ӱF[<쐩ʖ&[5TB r8刧[$F8>2qUn 1\&XwuJN_Rk^^B垖c,wmn]jGW<ζ#΃NĐvȥ]y/R:iݷRF7N:i<ʉ)4 c'WjTlߑSJ̯u:}$,FČ/r9zp碣u8]ntFq>3 X# R.GJrX4>K !r8᏾>Y[RʵnVKH٤.<4;R'i;0e$o0(` 9zJXR#eivo8qsUZ:&)i6J7;}Ùh#״+t vfxmF'1C F+AF.ʣQζ֖*5cS=ZxdtuW33HY9lT)5і"po]w:,Kȏ˙_087gXԏ6c~fs|]g,raFCuב\^^zE}WU'U'm[[IPr`q?eR5R:ttV+{\хߏHӲϹg.'bۙd/zU_6(G-2w]l3c$5Zŗ׋\y[U#*4#N2VRWqnGX;q9z|Ғq1*TJŌlȥFB=j?c$ק ro/||9'}bNwOGQ:ێ㞕eJu;g zT;ͣB*OKd]7pOol{Q.h+XS-H2tyIi#Oi)]w%{-Y7qӗ.ŋk!qTՇ5nQEfw{?8["PA17ɯRh5϶}Ibb[+ 6\]Fխb%iE(6(kEt8҈SѻJt)S rs[Su9l|BJۮ%y3= Ҥ=E~>4 ?Kbt̷8azR#|U㚙S+(V9a]^jDݺA}=(zSP+\+m[Z=왹Ruiiڬ֍X̄}3czz8jFR{GU+{EZicDU׃Y: IU؇8ԺMSJT]a& -Jsu=݊ӻMX.C dr{ sA ᫤m-CVpjkѵ9x>oܹ?:NLDTt!Xʥvr^eJ#wbe4Jz~F o8Q`x''۵y؜Djh9S.t[|p1ǸusS 9읿YafUw鏯NOzT=iV2XҢ2nJ( R?0#܊%O]<09~פzuRQ\{idoCszv%FU#h] FLBM_TpZy~d&WuHWVAkϩZp7k)+릖 Eʵ_$圕^:εIմR#=+˕y2V-"nÿֺM9d,G/ȱH,~{4q{ >s y麰NZ Vyayp*It+-oxR#4* ~?y$jڥ, 8lSnyWl1w[9*I=SuZ4 '_[ %bnqϥu{ѩG5][ ,dXBnlNA=8\)ΥNmӨэ]j??1 0Y8c[ځvsSzS[.*T㇩TK!Phd1\$u' }|$]joF3ֽ4on$IE.Xs_D.hn}iG"WZ錣Z8u2̪Uu.qrQ'yV}}*aʛ*r5v2TiemX*Urq{(ԩ iס{;l6( YwU8>/Oy_]\c .6EQܫ#ܳ0mVs㎕NQ&){:jNJ_a݊i7 ֜ɫ.,*JU/!-|ճ++z:r~ǔ1U-ߞռ*]Z]{{IE|ƒ"GWpRsqCm=ׇhO#Oo~m .B?g]6dQDZ8-o}I:)t bG9#74kIf8bԥta]-vI9fW}=3Z^1/;c9JGwnPnUy8=HV{sνGlwdluNr[T$9VXD*MSRQ1b8lv] D|Ҩ {{oag)8Ǖ>oVKEΪˌ`~^kݑ鵨@lnPccbFI u_Z9a(pOko}H.X\\#ImlO}G5-:1dk,ҴWݎuKxBH|7UOL=MbaR%+"Vmf_,gA#W=99ɨ)3Ha1F^ \r擲~Q՛v#eN3׽*U#edvJΚ];!T+.;pktFZZoBe,8ǯֹXԓVc(I5tUVʶW8ϧN<;:7Awg5j% |=r>kԩjrv]|Y,,}9hV;?ON87hroy3.$m=k^j죩GNQmrYESB2 NI4vnĨ$oo5>#ȍiQdhK>jݸ{H>JT쳺}YPӧЏZ)Gk JRrnѽ 2zt~G)]nYUN/BգrKc;ޕӫ)A"q%x!'={4-[Ҕ(S"7kSm$H{8x1U#oRu9ܶ[v[a?#efbnn#8JQ{wa{(KM3.amʻV22q xd{JGвH˹Il7oNPy݇UOeԓU2쳂Im?9׸Jr~T~){̗˨Cay%`W`ȧ G_һhkK~'O{#<"UH$c~|QQ{4QI]IH zPZ9 Dl*,F?=\8do(Zj5eVM5ĞXG)fٞ:n'nyyc]=NyB+TKnVQZ@t:库lMIGh.ac)o̓9JOCJXS(A? -Eܱ\<_$a;2x=+8ӝG(tArڻ!lc֕0*W,7ө&~]Vhd ";OÚQj[eVZoumddlsmQr8FvN)^LBЕg c0wWf V\do s͋5|{]#m(9lJHr{Ւ;;u܊TAZnBSpm0c*K{{5NQQQn멳{&_BkI5CML4_x>Ǟ;VrhiF_N.'+$njx8ZN+cyJ78?0V9 I%-M)nSM\E2i̤&3:tvԥboc .,a-\U?nAG K]ߓ >>ϙ><{XieehsC+l*܌yZ.O5S:t:v^E-aicPy= 8q\FIh:uk4v[4pdzn u=ueU]t[*y8?f0 2qLץE:7s 2Ho촔-q##GK(''}5gzJ妽fdvfa잼s랤yv3/ٻ6t6y$T R?K2zЩFw5`G|v9-8Vz__fHȧ:uVѽLev `Z`ѪsglRRRߡ%ٹ·+^{HI# м|Y|۾^6r9qR^Sy~yImq>T4)澩t+3N<~S\u7b'70Ht=F;=O~ZPu, E3qNM,,`ܿ\zW=jQ恟(- #|?^1挒zֽ-!HH1e>`އ>/io4N˨bkb WkNӍ9r#Ui2#AÂ=:z֜iZ}URH(ǮqC,$U8]~iTo]ZJ^z,sTmp?iӍރ(֋%۶CK_Ϯb;:cQkv"ʌ1 ں)ԒSEJT-41߷r8t=~(|X~ xQuh mA>͠uFFGGlf+)58+f_(ϑ?~VfV[ɍbd${JX$}t=:XmzzHoZCʒVNq$hKK[C7LUl };s\XQZxX:-#SIXj c`(~G鯩ѣ2:M/X9Y݊nYހ1pays[NKxVdQr xn>κ\yѧRQkFtoFڦ8G<~sW{^+~ u=^ykcR~G/xɝRy9^=i٦GWjJy2I r8 9xɞ8;yqI+*༜TiSQg=JqwiߡSRXKd2!N~:tN.jG/i\=ߘ~_N=xW7H<>.iI stOT>R2o#I~FVFAr+*7\SS$Zjݵκƙy5"Ǖv<=XӧִjJY-WZ^ݎgƿ&«\*C.? jYgG ȜO?<7Ǿ7y,/8x,͕:0+(N**g̩MrFxQ"Z+6H#ڽ>rܕ_٤U$eRq8zڪ4%*mգj4p5%o]OGYZ61fU86j;v'>"VEy\ƾҪ ?RajFi̗ 5ʶOFQqJvNU#OVԭw|˷{꫖Յ}*UjA{z&7{EpܥZ%NŨTjVޏ_zuKio#fw5F4{,6ђwfy͛\}Xt}=GYU5hƬd>oP8Gn5mEh=jhӏ:p CM;oՅZ]eSv$Ydu6:YqQR)ٻXbU̧%^M̖ndmkr;20x*$M,+9Xb>Ñ;'RoXo#6nWV_/W;Wj#juR4DtZd!ijΝOiS#?hUt׍ ֧R.~~(΄|/S'd!FU[|~G#+FV;03NK]?!FT3۳`⹪b-QEU7xm Ykad EoU٤nv'Nyz)?m*kIIJ鮇MCk~c#xz T ;?Qϕ?kV}o:I!쀀۟C۩ӶC̯N-/zGe6"qQo>xwy;$#7 ~p?Ҷ"3e\^HY_O- Ic4+ G?)|ft8W棅tb}]c-̖l;6&v22p?^=DŽkTV$u4Cr]Hm'tjjSO_c֣:˚wℿԮ|!+3< 8cHy'<1^~jߡ7/tu~g4#"U A 28e0}׿1/f il-iת>B7 <k.0I[ ]JdOn7WwO6$vpq^grsZPQqsmp꓄.eizufi0p#MISvkQ 唑WxLJyBk̰-rED\+29z*>M,zZtλE˚N IJV&g[FB1\XIgQ_#}qI_Nu18zM&o-qç}9<|:rLGzkʌV 7qi=oȇUx=%0U%<<sqjMzxŸ5;u ;i AQ}+6Z:PO}nl[i-k JwHe]t0M[Fzyo5h^6=`\ 'K?)BGV+nwr{%RGoȩ%ݰDP>DW ~ocWOGW*<.'?յbLW1h_O:E%`x/l0O]ow]_#/îT]_寵jڼ{ae+1 N~تu#6#Qg8>3IW2ʿ*pw>Z<] |-YiSjaj*q[&y/nKorȍrO'=ȩO<躽*5߿sTc qNoutvb=pݚV+fSF,el=}Ɣ yPͷ!x9ys2-|F"Tַu/$6DE#L Kק~{zS[7crNԚe6vVY0bw8 `c=+:Uc1 OB`Ԫ?(08u*U\:5'B]9lYFIG>WR5*iex48m6;x9g70Y1{L*#vz̻/ROEi kf񯙁֧i;};ANRot{o^w?tceuFd@v *+E%mڳ{>Zid0/[ު64O=WCcpnɹ-V5QI$O.N~]Fsu0{-o]:ݶ< :Xv3%mA*ʥ>mFGczkV%.~Qq5ƟmvRI#*H9~`wR;JJ*nW^wԬ$5!';{g˧5X^\kOO&G$jڄpw^[yvsgy=;VQ_<֔i'uЂR&Iڧ8s{`dzu+WFRv} voxs|.8$?z [Q9*v_4M7JkbbD.껉둑+]yNa[N-Zgm;ja뿴v&u ;i+m޸@!9ֶ_GX+u?/%ƤirYȤO)!2:on'T~Oqj}*ziw9^C[O2[?|å2tӗTi;ZQeyί'%v]]z_m𙤵YiadHT !b60U~9XK]lկK]:juF޶ndMu_/5-w[2->0rzϮ+KQ+;~kRՒC |YY#pIG==qF}n+ni®C|ƝI]&Im~ԾjS9?_ֹMvf|jV߉ad 3ZÂc=XV4-^O&h= 1(!㎜p}=S-@ш=#F9沜c15M=YdX}ul?Uc?3JxiW,*zou$0'&P =?jc~\4'{Ĉ _2D)ЏsӔjSi)r/#mVI%lr2Dv՜SqjӪy6@39^y{V1MktiJ).4$jYKBd7I N5$R~4߼ⶎG?,͵Ozr>b\^z+t*>h);ߪ"eԉ$N[@FRu,EJoZ\Krng .A3߇}Aַ&X@j-1#G:}=uӨ|]\`*#:zhʴUXy>CϺGPv[kQӏnَ%3 d+`#h9I]^o̧A=nVmHs~sֺ۫ SpD_27;jV-%G#?kITm;ziK Z~cK7DJB>^MGZT*~Z=\)ymԚIJ<Ѳ^I2?\1Omsx?<q~\hӜ9=J3*um {q]zi>g+^X3p>hU[6Nҵw6tvHnXLcb`Al=O]{98˩RPhG$x2F O+n ߼o֤s.?qQIo#ekӯJ\Rcj^qORM:f=앮Ⰶ8#HVKTV85tE8=GZTݍ:By6Fݞ\WZгyR?1K1_dJÚ;?!S/iۡY=ݕx{u\<.ߴF4]T6WY=_c-fhfh-6_z/mO|'V#rb _X~Q>yf#߿q\]^:$evǐR_u3oy&0dۏ[SLNذsyrɟoC]tP8}יa(TeމTi}C?W+qon)&|A3z*嶛V&N'vߏCR#__uߓK[4UiQv@y2= T4D噲AU?NOQk] :Uu̡Cv}W4*M9ԩ9Jw!Xf (RxW-J28\e>֛z΂6UU cֹTJ(7(mm pduYqMa[/EoNeWv}I 4~bqr^[jtߺلln6xZs&9JXlBsExpTf擆?uNUZϥDf7yK쭎7FV<-pQxm9=rʵ%ș{h=-XIZ6@9>1+?&ԥ:Kc@`9R;y qFgjƥG:y+s{.wY&hnkdS=HoDQJ:N6(å|41x `+b!j)i֌jYzQ<:"W|ۿqceNhMazdB w1\%V䋲_C"Mx[dۺs]䗽}PT6ih KK=YJ-)޶MI !eò?>E}F5JlI)zsYƢƤ#c, 9;>\|G5Rcajϧ_ź$ /Bz'RLEv-#i_W,)T: n/Gm-U,Uy=)s=ՠMݚ5>l}?!\\ytB.[S 7qMjsp[ 6>jƝI|2b*TV+q8o槚RLj].^FEeCX+eOCYkQeHGٔ19[)RWgٚrYrۊX'umbx8˞~Vqpyc'FVEnӵ!xy=]>VZ6v4JQ)dB8oR1Qx|HRJz7huޭa[WƶK6aŶvs[Y2v uvY4;_K˵omV75?9m;;DYTɀF0ONΜ]G6 ]l^0d“G4eY^WOM*^ƤZ+?OR> il-\+欧[뮎:Tyb֏61ѩ }fw/glU9aWȘ<!W%\gm-eʭCocwoF>?/91/m7n^gmOkEK}N7vV>Z` ϥsJT+YEZВ-yr|t{W,ROwϝ} ,b͹b@2iRv:Uݦ\|)-z}jr$"yʴh#C 9WG7s$.f2/[U?gXm *ǥdE]of>)H^m_F`}aQwcӣJW^{ɕ~cn?kO} emt>G*!cwCzQm ܼ>knlF߃_ʢ(ԔաFT{y@S]CXZڷC#L_5\1)al[%w|3P+2-XfE9=q0xs c^T[-|/Ff\b{nsؼ]g|ZZfn[6 gr>z\,ROZnugsR,I#*[TpUNIU ٌwR!}N#TUvn樂d{}HImǶ8d«w]=_=birZw{W9c8ߩKJCӕUTYKxVwӯejm]<ϗunb<w2H̹c_1,^޽Op׻ԥI $3609מrͲzy1u=P7>j*jL*FJ'v0ph*RS_-C2,VӗC>$F{ j,2|ɖЯ#ۡ>_w xscTefٺU#+ s{|ҥ>4,,_[><3QF9ǯ+Y4r2s|8#<[鞕`В;S嵿]j0&D>u+LfcӲt:NpO߆__ h#H*\:x+qSV|+a:3mI{MtSV^G_kƷ +{Oy>¹tϕs7=VVIK|Sݨh]zpc0rjQ]?/+c'eZU/ɥ= 8It0Cwv0}>,T+FjKK\_qnp+H2BoF'lQl,e5w6>[=8Ʊ[T-9r%aJ6U=Iq`]Cnw($ivw,GvMhPx/amOGxE B %g9œ-,}/+I;w9|Iy3o*B'A8+ۚ8VԔe|p{]ѣG_GMR[{ _?bܒ`?=VIQ44gm[E}Mb⿆doO1It:q{_^0x)m0+cw{V!1=3ǧ9[=b *Ȋ9s'Z kя2w5I{I {~;r'oZZy%Sr$'cPIiO9{޺jNQc 20D%W#mXWʚ aJ0pA_UӍE}rY}eR۾|B{-xw ^NLm8,ץ1Z8g|ʬ/~?|YkVʸ%Rr}Ϸ)PT1N3Jϡ*BY>3rYBnj[\ǷJƢwkOUahijX2}g#n)([~{J1w5۫GA7!=}<Ƥu}X Jko5kݓBlj< _z<ҼRnK#[uݳT^7{j_; je<ȡeTwCBe Rj59Wgc5c(~Qw|1~3m.VIu5Ʀ}^t5Q7( *$ɑďܪ2ϮN8j9SZq]-44O:MQu㝮1G=usd<|Sڭ}my7g+Iy1qRV=vZ\Կg(gp$L힧>9_ *N4$Ii엑4[捙(xh\8VMiTQ+m$h'%q:$E#9S'b2xUvk>:>͆)c7"-ˆ]=?ZiG9r'{Ir,q$ [$=zRѤ]:vs-UX^z\󔤹 ^h՗q([)no1[a#ߧgg.jتYSë>o1)DrZhd[ؚR2[cc^f׭.y>׹ݘ AȬJ[t.hбlֶgR$G\v:uWOK1jTڲ\v6}|;R[hӥwߧXX@[CO'j/ycB"Դ|<$kBӹ^V~ce+-G,-sXXg qC:Q*lDXFW0|R=:vDk>eJM@ Vldsֵm*^6Ky^\x @+@sq]uha}frb06Z"?m;+(!fPY203M*8ɴϢ=OT?{ekjVy7(`Aִwt9ʔ5O[3[DW5msP+Et5C ңj~%!UnUlQ[̩{;ŲTO1_/=o|QtTTllQ<ѧ,c)L8j%J+KNRV _=JI119iD*$У",~ocCjm*#&N,ɺɕ0zr=Ǩ1 mVm={D .̤ x~ߩR XuQcJ\QzA\6~\^^o8UNs1)6_R+ŏeQGܲm5֊mu VT$n)N^VG-aޖO,O5R捥%uikׯ U [dc >ª4*F5qxAzE[R䉮gڭfg=r}SI#Z'b[p7'nP.+Fy';|xPzQZ|j~'pyTroVbyr̫a7enEXުZ&Lڿ(Y2GFwIuJjnh5Qͳr oUmgqGq}NVRG}W+G#lу8HʋFTz4;G&>)ʬXq0Cq׶k>P{V9eGNS;nx/R=?ۉݻp<둌)ӭF-GӍ)a~hXLF&,~Tx9eUWGxC#j O.E6>If#N{<({?K"dXVlc{xdgJH׹4S]ɉgF I鵿___Z(E=dw/4D"fcߜ8N>/(^2ZtfVTNr.y|;4S\\7: XSܞ:ESY T= B4Izgynz# +p=IA>/S8'rwvl1}5Jܺ#m5Ցڮ?wקZ\ʓ2$]68IoIKkNZtZFd9a^*QJn˹%M;{۳wJQ/+/̼ޜyVٕFR/ws$ #}+Yؚ iw~mR0.S8W %{mpOC.v=_4C. l 4y٧M{Zyu,ǩI{on}놵:tduN]Qgg_] Ӝczc(ْųQET o(R+{z׎4cJU9,9`fT^a 4USozZcQ6sDT E' pD'O+'ܴ׍0Rcn:j|tdf9}W4FrT,sʝNX-<,Kuz$U>^zӖ<5Usֲ/Z6ʻF>aִ,dkZ&&B:(Usvc%I{J˰j [+u|éGlnf/۝[8UqQz MjF%<_7`{WWqv9q؈wzňuD-һFT@d:yʕ>gNs 1>*R"j{.YR8FMbuҴnC2 zVs-3:XxƣkwlXnQZFnjV1nҥ(ҒjUKV^lcls{7tԂUIj>QDᤖ'kNu{۹42ƬO:R+s# ]iT6!'++˩6aj_jbT!^wc^}JU7ݻ]65yj֟Ge qמpSOziZ6Wmi!Jpx\rʍ"qsۣF卌ڄm<ͷ3U$(;_Ab%jUnbYEtqgv:r~BKpzqV}_b";g]ʧ# A95RR<=%+ׯ_CQAm+Vm%jOׯܳ,>|j?*ߏ=q]%TӺ[jVROOD$KyVF>[r89<XbZRguo;Sj(Eٴ!m4xRW# ֧97%e_cTyiԗZ(eIa6L<չƎ"Jsw]Uжw+?gAj j{)wI/\6"gcӎz֦Oa\@Rg=ii?6Hk|q jQr|jiR\-?Rd6Ҵ:~ЩV畛N- ~d1Dcj0zƽwu%˷߅#>ƍMii"32<re -3*S2)֧"BVcvta c923 ֽ*pjwoKݻ+ݿXKI,M2nxGֳimku붿:DGӾV`:ׯAQ(ӅW2}FG*_Ȯ9n.힃ey? Gu!(Ky8HloϿJƵH{W9uNϣ*i> ivqXs{:z=zkFqy7r’g+Ǒ>E);&6$iYv=+F;+RvөM;G+019]u*Tlt"*IJ۴=iM%ne:3O}r7D2/{ڝ*u#GW;x>񯓼8v\H9_v;7}qN$Ђ96XaiTV?7V.]Njܾ?"x{gX"`y8"e%~dJPIEZI-$)9=I>wFc)g Z1 Mtm '9ZTy"2e^\IH]w.3Q;h槢HdvV6(C*Ì'Jۗ[U :5myl71}-nte80eU]8$zw&=!+vNr^ԱtId_O|ϞHTKg ܝ;nF6I``.+5!,R}JS;5CjiȮ.ے=xT\.~[I'IPNH$sE>H˕Njuy'.H&~\\n JiFOImw֏ٌs8҅EkXu!U2Q-ofHz0@'iwCIJ.7~FK,!|lb\gVR(ɍOkM[wBMkfI^Y a>Nq\.^hi,K FȝwLkY3McESWȊ4wk>o$=UT .胤{>ev\d_O{;Ȃu 3.;x'kHߑe)Y:>IH?%O9#X֧͠UT.;iw n:r8E:]AZFڪ` r֧)GRZ~Қ^Rf&(Ű ;Uƌ9ӽњYQֿ֟"JYB0`q|R:tSRJu]\8$6݌v}+|Z8ZpjϩO/X}nfĒrH}Tj{Z]I_\F*1:2|eR9  uN{w-r6lfhr>b;:Q5ޥR(ϒzNkc$;@{~krS~wuXn6S>il>eSxYCKu-r xET1vSRle,q#9Rk_-P jrC|:{:˕*iʬ @l^S;l's{r3nk$mۓߟO˥c)Kh~US9VAo?x1s9J{>Kgeh9l=Nt̵1]7qq@q$ea"ߎ1CE:ocQ¢J;-\/m !{cұ^쑤M{qn>b9嗶?U~Nwѫ)KN]be2[Rri<]:})7cGjb3IUm\㞃kîK-PBфp3H'z~єjKEŽe,E;:霞fKǠaSv) Ѭ2` \ױBZ5fVV)5nY puɯn?/;f8kOA4jߐx$s޻ٞ>Zx~F1u % t҆gf׊ϑ+Xq:5#z֐_2<(8z^k1rV3x'$gq̯xխJ2NUHTGؚͷ-Ć_97S)={Q.eS++tSF2.dɩ*\VhK,wޖK޾{X2'n㱅jyVx=מx^g.۫!VKX8U_k|ï55(E*dd|ƲZ(Iꮒ294{n?k2'7( l{H$Ö+>駵ӆ迹hƌ#pנrE^)k RU9GhǵSqi/YFrI99^|Wunv{?Qv~FJœG18NRmg!v[-ěܬ#Pz(#Q~NUqi2H%nl5xo.Vio%l̿)ϐSc`|=JnhM+ajSoKi|~Ny& wJqJQt]n6|a% qa76q(yԣQɷ.t~{#-S:/۷Vf'2}~~L%+e[c$޹eRN:ciiin5IED8U0ѩMױR{E=2L.WUw^;1 [z.M[ *3Oc<.<)}S XmsRcȭ^k5-5%IniTGU]ΛÖRI1*6YxjRݿ3ѣVO_c6YdUPS۟sx5=>[oߡz\h{p7[![g>R\TrG#Hj2Lq\n2m3v)AEؖwXZ=pqJqr1*J6'A;@ç ,7+>[D omcUc1XM׍Kv/:(E$`Î@9>oI&BQouu,Of w#JʴT R;Yc 7G7'OƲOf[еamU`wml)#U%;{XT\ݱgQ泫"d:OX* $gaAg$֖b/X3lg# -g'ݨJi':>n|^ק>ߕL+T,hkqLjwFU~a5XZj54RMkK һbn'ԟ´6je:֩(Mpa[ݏs#ȹF@tX:`tǽ\*JR9>۽,dKfb۶g$NR^=w}HV©ڼJQǞQNR3.į#MyJ6{ԭe]#8YY[ <ݸZ}NzjOߊ[)^9E/6~_t#+%%*w1K'Bs1+TeI9wyhV8e`QI]ɌzqY5#-aev#AfI}ǫzH3\Jeg.f5<0^xEoilsT2ĻmBC>'reN_-^-k.֚8bt v~4"/ ^eG*[={ӕI4ތ/yFj)dh+'XLB2N~VJ`I|C`s~5UbR/CZ4q.IYNW ˿sYi$UU F)s91b%S*kNЂ Y$9Uk@vj.m n5#R)u,#gs>WWZ=lj$inW]k=*<&2] ?ʽN[&a%GL\Bc1Kp@$qֽL?2[Vsv{#(+zErU1NMj: eˌY 銮U*FrRk<覼fa5MQG-^YI{Ne; 0|r;ޣ;YT5#h9dەϠ՝HrUV1ZF*oe!wHr8#c(zp9Zs׊[tudn߇ƹrcFGXL"G]&`OGן´bgSRqi~; dC~hkn^nYGC^Jcw6,7j$`e l'֮SKUE*VKFWy-]d?NA]iWBQu%.:;k-*zuk}g^2[i g=|>L#]Y?zRgѭ<^/aI6-۷]4ZPCIacNI+\/5]J-ES֍:Tbo} `iapb&I6fw3*S.ZFtթG(NsKqcʴ{׮foݶx⸧Z)vR?}:">!2d2sUR'S]>GGi0]$T*jaZ&lUkQ|ȜUgIrnhMG Z/GeKѡ Quhէ6#y'!'\G~cjrr'Es+pՌi{ڜ򇳒&g͎mrWDU(H²C^5.e5}t5]>iٙQ }*XWl,18^8iZM8:,,)l)Ⳮ8&^:5tw:IveUgWcounM9m>\Дo\RSysey\5c8QF Lу `z?Zᩇ9riMN뭈結U=ng喝ouSnz*W]NP-#!gɇ[{~UeN3MknI{<#ˇk|WSTCB:0Mz5;|:mߡW׷`ҷݙ8vJiд5m#wVCAb.޼ЫԧN`决tZ]ї<+hk s,cG$aj1MuGF*"ȹi!%% J?-H_N*JWbY>k$Y2F낇8JM%JOU=M_ GxM^YJ7$u?ZQ-; rYvOįGĺ\i0EXcvQu8y渰3 ro5r_{($}bmJIye` v}3۫qTeFYbp1ήڞea{ -dvi9ȹ`jxsx G; ;mnDKmonN6ڎiȳ2Sڽas:^W_35p5zt;A[L8Ž=YT=sF/mwj7l!m`1 y:xgRO1nb-/-乃U3,c88èɮ1pNZ;g KBKU)j(m'w?k\]NʕSm}nBgUb oi?z"4VUӗIn5+6[@2cS,:]wZKt+[ ɪ,_u|_7\IVP1)ugVv:Kj~_#m<^-8hۿO&ձtW#V~ םsA d*QWx1WEi{_oc'ǣLK M qoc_`)Es6ܯoт?yJIj]x45̸eUT{rE:יm_.בԊf=z^Ҕh_=-ѧ(GMNME~Y# 㷧z ר{eZHvmR¿ٛ^(_?ԣM-]XBn!c [bܭӲwz/(fTާ&{mz \VI3ku6yc  POS~++7(R6Vcru.V>y/bBK8mZFkn,FT![p1kNyYhqԔfQo{/<x9zdO*$~(ͪ}SF~eUt2ë]( QjMjTI_)֓Ro'R󇥻ܓӨToz1Eūhk4-GQ(w,LFz쎊/k1{J}2nOD#[ylnZx[]>vf܍N}\:(K SߍڣC/_s1x/Te-N~hJF3:bnLDU:rzO[iΩ_MmBMP9f\K"dg>(+QPk[ *,^Wee {HjtiHʿ:Np\Q汄1uk[fŵ|mhaq# O*.]u9cT26]Hy"7=Lb>SKd0E w,ŷ2݌v@qBT.XΜ#IIv4s&@6_b'yVJ&)yfmM Km`4s/CG^{ȱ(!{? |3aLj2F{@=pyЏ_Ty(W#Э`4*N.9ے{J*=J*v︗ɒVO0E9ʜW\wP=$j-lm-מ4^خniJ#D-s}>A3hִ+/.[U_v~Us;r~=~[T̛݋o-w~PV>GPx>t^:2'Ь|&[ə OE9 r=V#K4֞&/n-Np&_ǗlpS؜W{eIiJ[ס~%M+Mh:XL\ۘG.H#i }F4|˪ݯ;zCQʬd溧o}>}7lyj.t!RmT:~\ ejW߷wL3-IE/w}o C,Yӯ9Uy? RXr濙:u8'{/ڴ $gv+ߩZpwߧϩԦMݢֵucve5^>m%?ǨG Rߧ8iP־9ťxRsBvՔA'1Mu-t_Ny&!ԌVjk} ~e'.-kV]t tؿ:8{E{;?ߎSfGD[zi|qGz}G7KGe$V`}F[aZ}G/iө:nK}_߆2ԯ!bi݃F2'x;r*z_ )aR~ VW $`: qcxxvVɞ+>)YwwvRnIQ ̋4I#n·l9`tfRvqIKWM}yK-UKCqqR}=^_׹ߝY]jK̇OAm^YLUx\IӃzUKZ;BBXѧht:dMmT7O?x#Jm xv$pQuj.ͣ[Cͼcqbwlr:WN ]],zTuG8e (w2}:p=ўh^U}?FVugJI8|iOFrRLȌE_Rr#M۪E*û^Ar]Ymue)Y[ҹJ.Vx\-I?i-ޯ띲Drb܂8#){7٭I^ uLox^NeESGJM480qr3\^K&T*>/^%@%ٓtN){3J8Ν;mWڠmqJ)ɵ*RYMTI 6/`q=Tc]!Vc1fI7vxS\|,RZGw$٢2ʬc_<`tl 4QNkfGyriƪG{qgZNc1JvDOEXA':v=*8ͷ.9但Y1FPxcO^E:wGrIװL]ykeca˸u0\mmɫ}alzB-ǰWYKg,c(Ӽlw%$nUfF=jcJ}w6)b"ף%MKpӌZt6 ש^S#yc]}1WwD8{00Ii%MIq˸e{ ڂX_f[ݧAJùXeu=}LY?TSKѐ# 3pWoj>ΟjnZ 6ӻq6>Jfi-hMsqzg Y[y# \=籥E.][.dQɲ@!X6 =t?Xg^.OAH5I&{ju(Q4q ܶ)0O u 93ZƼc{-N+ݢآ"*@b1D]NtT>eZ$-"\H1*ѹ {qkOiNMR;_ۃ1,3aPO (F}*4TfPFa*u)4oNjvVne0~fWSONxєcefgR5O~|C@Z2+XƦ;*+S璿 QH#gn< =:FQ*SUiS&͖|BWS~һ:_^Tefem:oFqm&ۊokظ/kA)m!Qi*mxފS:b#$3-͚B3G#4ۤUU\g9=xyɮ5ڍ޻P;nGy<Y=?Zڎ&S~>Z;YnByA&݉I'w:~57-dS滕23a|[ $?]*>k!JSF[bOݱ-C?zڝH;)ԭ[Jn2+G"x]3J勫N3jˡ^OFtתA/ʲ"\8ݞnJK^3)RM i%'G Y3^3O*n{ё>Vʵ"Ty䦜OP Ǔg?Ŗ+$cO J-w)<f5qk)F6G}[ж!wnF8>޹%(Tڳ* [VJ̮3y9rJޕQ*;^ߧ8#**)o<25d{zW-J27˧SJSQz.Xڽ"y `*|t`r$8ө^z\3\,rm8~uN{XU,שm:Fĭ"ī#uqa斲z~EaJs V.n`lx۷O=~. zTG]|i19 dGY$1zWsZ*۩j#k.׹0We!R C>ITcfsJX#Z5N|Òq{?޸E/?qc̓r;,~|# T&T-I9( 4?0 jGG&EHPNkF%X]|?x*xG^srBܙƥZkm+KdY.2mmc/z4cwWx|#nر8ܜQ\_ ~]f=ͽY! fk>4T.UiJqwndE*MlϹeݷ~<NNW:0i9}VGp q4y폳+bƷ,Ϲ۽-Z#u+TuRwc>%iȩiT)0DnM25Q(9Ny>H+(9_V4}ڷLcȣ Gt v%%dRR[jKuyʳ|pkG۵1aO9nތyf~vK]QU:uz}V'8RUsFTYZ2H͏ьW6pmR2n2;vs`Xg*ѫ|¥F]̺U-pNNю5XxS۹59|6t>5+|̧Fp}ⲭY;(ޫI6m t*>[ X^Vr~.4{ˈ$}ݬtvA_w"ykI\5:Y:#Zꡗlɕۃr*r;G̤OF)В^[Cg:U0ȍ >5%4OUi.:|)H^}Jxz\s['LΘ &>ϽaZieJs|[˭:-FXeH<B,_ty&IiX.Nn8]?ghFw6iӻ{\|71FtVhc'nsY\ΛFtC.^h*tSR>Yҏն{"߇m9V;sx=3m-FFlk ՙDg#fc:2gQq$XTpۿNMuNQRVZF9Џ$}Y)c&M\ݏ8i>hzTdw׷bji4dϩ\~g5M#v+S_=OZ4x4_uI}Re{Om8*XgU@T/'~4n;JqhC}h)#e{r:u\ϺJGK𽍋\ݮY#8wa)Tׯ9*ԭ*SW]zHfY$>J0.O=cy*cU'?HIP&@ s׬gR8e^wqhs.N@҈˾ӏ$r]r D82yA˙7*Щ5[_}906޹;AxުScJա~d+׳Xws8ƚ޾Qo~YQR$Rpc̓ÛƎ"O場Lyc p}kǏ+MRh~\N2{סEKӕHMFtSm'bHC+b%cDڂmi.' GLTͲ0zk቙-Ѭ,`[=]ny96N7z_[|7t;/p_۬$7<27; xcwqӣ:S6Efǟ2QmYY.K=U];],|af%FWʝ鼜}𹏳rV̪ѩ:~>qxC,-F[ڤw 3SӒ9 {V RRY|cM:۩x_zmBgs.c*^/gl|"%vΏa-$#3nN'15L|eq+]__.[m#7{.)}8~j<:Yl~UDr21fgR2w;ay>'i G||I?ʧU~Dp$ԓ;&}/Muôlt$Pkتuߩك8v|-:Y9>K#>[/ȡ<|<~ݓЧ}ahUizk!Ҵ8[11veb/A##rVUt3ԩ+QvVƺծm 3/q?3sNN\v6tJ3O}uckPUWv7uJ!RopkFEN{uKKp{ZlvSM_G;#ediRQȟNPl-C5‹dt=s4AH89Xz5miN6ݠI \sϰT>wq;OmGz LGӃ~A#c*T%Oƾ*׽twzݪX<`+cp?3XǖU5۷݇ӕKkgWA4[I!٥1@y>^i1rt.ЩsTI's5dmV6) $QԓyPzSI_ϱ:F{>:뱆H_&GA7=z۟q/\|~7~W)/Z%rK2E۔PGx̵֟gT_)-m F"#eAy qۆʍE632U7}ᾕ :T漶9Zkkj^i ~u"Bې~sJd%~&8x֪7бe< ʻH~ت\enJ+PNEbf1Ǎ'~}{VswDHӓjfJ$T*ԷgU ws_}, WV]b0zkU")Ի` .ۗϱ ßR8^;zmm! x߅ZoЍ(_RFl+'[~Rw':thcɢ2qk<4vfJ/,!w9 ?^*yy}Ngndr[NGΡYg^1[R)£}r$ $bNp17$Lϙ$er$^Rë5b6SI+,7={IF̙m\c")v s+MGD}ڭZ )gGXuZJ1P)9-䑡7|N7p9ϯj#jqW10˅O5w4ikA0%Q+MSD٧MI5X^ 1ګ3ש5%i'ʩ>_WrסjSQDQ{7r$fֲ7ݽY"L F3v6\en$eKZ6HA6:=1F`sq}ҲЉSQt}t! =qLRwlr4^]Y<׽>^Xn5n!!/"z~/c)?yz]D${:yֈI)ױҍ9N;IZ!p# ]#*arU'"MXL2non8̵3ocM|0oq~z2 m{ԡp,}ӨNn>{ DJ3.cX'q2͐A}'G7&gҔ+L F?,}G_-[tl;:c?_j>שjif&%bC q8{Z?u;+Is+_ʭs _,ec=r{J*v]S"1^]Y$V;_7i\}`SWNsBj~v8jFy꜀3yj.q+NDsr #afi#^Pg۹厍j̙[i7fsIfӧ-.c,EIFQv .prILc^XwL#?W/hmohdsk^4f4{}|a}DJ:kwr֟[}rncfTzd^u%G{.ƞI=:JDwy2[JISȾJ|[yT4;CG9?iENNTL|yv$qm=c'O"gei20NZm.f$*[ɱ`= pyPt=K*I6]IgRK,1`#±%-Wz~k|)%.Xg*XZu=ȷ}LnCR;u c[x[ӼWZn<wq7(=FhTi"f&DlI=nH^_O38QXK9r[q={V5(KՒ(՜}\jjΟ6q֛kmN1=,mߘ6I,b{KuI?{oJ$윞?g'.?Qzڡ86c:H8MRMnnE uih'k)Ӕdiq0wӎG2uIDdʚ.u:})nQg)f0}GJbԶƓ\5̳NܪARPw.=Ԫ/F2崏 {+ZZ6 qO&F0t<+{K*+46r~3aa=sY?zN6L}^ifdMaצAy8=)JVFH>V1e>4F>#.nKgOjKMٿDfT2ß𬹪JZcM^?3Ku;x!(e<0{q]QSsSRpk^&oe![w$GldeG{?2.4~cRSی*Ɩkw N4)ynje9e!z2ӽ%Rc)o:ѩ.y%mμKrVGrqQڼ%Qvcտ3QhnKcEa&yiaPSYDsr u nQ܊qн:iMjŗqToysS/wCW'QS?u{UZYbeiYnoL1ewN{[O<-w6?UƦ&qBwESw+I;'jNWyE]N-ZBd>g]ҳ:ӖTг6I[k'񭥇 rryeF.ΡvՔWrrOqWy.PƱeyi^6©ԋz,˩ YUiqO~gFֈ+JR劸u\/vN=*ݭIu TfVGvsw*B2Պk) i Wʥ'uN*eY'_KϮ\#I 6+ѣNRFܴlbzsNfRvȩ)F.suik.רRF@qYRw:j:rM7dxڊڱr\+Jnd5E??0?N#h矵}קk6TB*<Ҟvq[eEqzƹi7v?*ܱGqTƜ}?kaU}bc0.vF_~qWV>œӌܠZWO̡XF8?_~}.ZU%)r E#"Jgt3d8?wVmzv& .|Q00pGSJ>1lo?29W>Lвys\cҺas9_QVewO)v5"m@|=k%xv磇%ZW!sgf)#59Ap#0,9݌*xc'ZAjSu!UX^c=ip;>s?YIi溢N+J2KS$/3*}pNs3J 0J)=C,*JztkZ5$cmc\FlH ldsztUi7ɥ5U~}TsU޶zE_<̑uJ >ɽ{Kx.''6 G6i'F1VFG^GvT27{\v#u wRIF_h8WyWJѵ $mrqZs7T;] sݬRKwRjuBoK)@zgRiK(/it kOgj q1tzĩS{kUmp.ISYT]$DqR}NnOȱ4e|+ u\nR ־Zdm) \8>zV5?Ȫ|nrz~^B]QG B[ly';3N1lKٮXDwI0ڼ=z^-zr\5&[pΪU\ns+QqgEFűK2cX ӧZI%>V*έlҳprmlW'8W .}L)R%7y=YLvŚb6g=@\iIzFR{|gd0KUNmmJ5N#If m)emzu52+޵J1o.UadFY/ \ҧ۵m*J] y Xhd9Ϸ"ǕEQF]GІEaA\m mbrt(am \s\dUa9Y^ڛ~m܅!pIvS cJT.ѧy\Fdin6݌:czR:b2˙Un>+#{֭ԦnȲao|ߵ.22{f;|ZTym\|sQnL=%y"5ʭ$XZ[8 .y#'x汒Urs[VDZC(fb{{)JҶ;5'˧y3ߢt݇><\Mɭtv.TSs杽-B;.;ۈP>S4_i8Թh\4j;۷7R0GvgvF3Mjc.W9$7['RiӒo2ŁB$r,9#>*18h\&?#kYp(fV2qͻOQ6_2k2k2h%$pH8}[~E<)K{X%i߻ p :ʤCq<Gi_(̧ӟ]U^zz'wBl<>6u Hǖ,VhԪQX\lUFusPElۤM"g##pQYKdSR~VGmtjrV_,~ѩhde\cJ9 Zv/V>hWvIt9^) 6VedrA@nq\c.V嶞9jSFMo[ha\Z^6Y`|([-xsEF8Bk_c~2`B2?JJ䢛<nQjk|)ڋ-L+ǝNklc6j:_|۞Y:)4Zҷ٥E۬{vgVas? j1N# OM$qʻ_UnKnmR9IjDer|`omMaӒ^KZ.үgjei~[;*x-cALm;r>^:W-;¢,?6|?ֱgi0*q߯&5Gɤ{y&UfSOgW9HY6aI{}G_ji(SVkS(ƥ:-{}9~v^{Jo[%R\ZZW;lUTu< YT4۽M#:MD_>oZh-gN:śe6gb9n]:TJMl|&LV3)XciyןS9S-cb1Ӄ뎆%+76[~neĖvJ]݆qjNn/ PȻ#b!f>jWk%ZyRn8֏&ԍ!l[+[}FRIhlu_7 3~:K{Hr[!فS=qE)5M{(9%ifYTWP Ӧk;8*cT\Q+X 4FV H\Qd^ڽ9=NJKfr{U)>oN"[*HWG=FxrrRT%n楚4jvXnqRkGE]=ϗu4C<-gZEi%ZeVH@gWi*oAC~']?BzyU98zЧ0Iԓۮy!y]D)V厯B#S'ʑhǦzW{G&DqJyO4}dc[Jq\Ј;4m#˹%5 Zr?_^k-JT7Q햍m7E/?\h.Vp$c> d|w<3<ԺJ{ ~oh"NH'|7QoM)n#H)$cF#}98mRNhD?,L2 >\=z2a qݠ@R13) 7V^ |zzܤwLa_1x}la5ԧ{vS)Gs4ucG`26Arz`NvV39?iibs䬏TswNG=ѧƲj:xU|W軝%kC虇~gZrxy(4[q}gV]-H󙌐`L=L.2|ܺz8gy6Oõ{gi"~ UNvjtݡb3<^EJ|T?hd>z.U̼dҋ>Fzifգupm|eYrѲW4|ɤh5η2!rK?l{ӣZܓn Z0J$ϨUx:$>RQoR]sHMvaO)j工CUs_Ojf N\DY5fu(s^-nxr]6Hog̷9?շ8=sI8K껮ǞWzkD&KXF|vP [n ?V7iKt+ܻ|_Y 0kGoִY4s K n}OƼ#)}QŸOɬ1f(R1֤Vv_gi>oLz"De rkVj?;Xf /Υ$[6f3)2#GӱhaɧKcq#̑@*~/}~Qv<ڪ5 lڶh|Y4Ӷ3[>^GϿ^ T⭯zXZxz^>Cˋ oKHf@2WB<-aԴZV_-z;PV˥I|kaswʫēz;b0~&MSMk菠<YkZJ01^y 5b2R289bk4?:5HW s[I &:cӆ8Z4C˰էRRk[>6׋wѣR; m&5e+)T5,F*4m-T.Zk{k5\G-EAZꊆ*IVkfgZQFZ_Zk ${+ACq|[FL=^ҿC+km%<ϕ{a}1UkYRVuY<[k.W^~΢^zt$s#CoH.`\e_gg8iJ&_GXsi_2_G͸fqLvgGMBn{؟igU5 %j_|UYޕ7Ο ;vYVd|F<_c,D\j_qT̝JQim];ZP|W5T$bff(1B@z_mVuU_VS`Rs5 Ic*5]FҚ;(U'SkO&8瓌Vө*F&MѲf/SfڤrX{*Spʏ)Kn ܼVҽ:īG5[lh[Zď䙚7de_m)ZM]v3Fttim3Lsҏ5I%d:}w{ xJWcT尼j)=ECLw!e W<+קC BX28پ]OW 5 Cn#M~@E=H,x 8ǖwuGE9Bo_>|ΆQQh4UA9k)SQ$9T{~o;K m牖߀ĜpGN3撺<\]9TIˡ5N<,q8r9;)QVOT g q ݛRv^Zueiqb*{Zo6HSj^eV卛iqKk/Z^CY~= Ahro~ blmTQOVkV.Ɯ$@epUW!:AL5+k|,{:<ᘝ̽u?iZ9\X(WV !HqzRNVEaOWeԴ1sϔǐIXKZi<_\Hp*ci=I/Z(G,ToSGOUw*V?5HXp4><:?0YaSd:<K[p0Vѥ~2m-Kǵ 2^iҍ5cֆpqQi+m{R[pq63]Ptre<cU N[#[)9]NqRQ1ʇq7^*zrۉ,ѴH< jS]V6n$;W#Z1¥HmZ&]Oq\%ȷ 3yml4FX>7g_"7lff 00lu882z_ƝUs'ױ}kpP\m%Np9_qLkŝJh{9B7)r7 +=l||JRy n \;Q\*2T,C~|C䁸Zrɭ8'5}IeU}rWyOz{cߚZ\QEhm=Iռ*>͈Lc?UJGw4UſtBڢMF>U\ko"N;Mz1qd}:%.nuQ%i#w|pZZ|[t90ܩ?:9`\J8fgvq9RHUfr$g W-տqԌ)s;k2/0lw9j#YGO"G)E]jE=ݴ2#g 8.pJXǚb%KK+6HzÞQ?#YT悚V2b@뚬UJkm>l|mӉ(dR^]dϠU:}&ut%3(6IUFQѧ)(wrHq+yFOI RF*4|6+ ?G~\Q榾oAuIXƮoY >h/Jwx#$s8U%fi@8$uu:+ijS,]V a1k&O֊+J1!=ss5^DFTٕr$roMѱE]x#'ێ溡\^g$Kd$r I^wRW:VUd};CǙ?(tBR &r:k|`Lmn b>cyJu^+ B{wۄyq'N3 >3僗-Kk={͕xp'M ~#*R*2U(Ld/cU{~$&D$Wlu9WCi}|ሖ_Kul4ok~||FާTe''{9?E!C/ݺF ;Hþ>tJE#̾DylbFo0X>渊5TIyam{ш~V<q+s%FöOԫ48o6LL==2x98'c {Wg_Ipb2t^8/,]_#2Rzt2X=GqC3e[?UErY9+wWanc $Bː7cqUN^x:RRg1۪hpˆuxtJ|C}SzߡFY^U*{Z%E;Q[ܦiR")B]n#h͜,cx?ZΔ=76ߑcF4}V;F<;bqW犌i_̒uĆPy+>UOc@:ܰZsknXݫ? 3[7\IȍYijކ7q. c+ڼ*ݎFl{".Uyb6 r@'J\:iۖc[ 8-&up瓽;(Ƥbhm/̋'m9 vQNWQrW,}"u#\;N:*'NHjdGԿvIXH1=)Ч6KO}; rPXel ܌oƲ?wqԖ2QRC nFc<T 峳yz%e=V: ^ΥE Nuӿg?L*2İI}23j|KKPδO9ɜfhf,|0F ֱo-/ƕ͢bޔIW3ҵUݘT5bI#R$9ϰ>V\A8RvEiQd1UB[riu*mϻs#ܬ*ݗmNJ-$#[6zQڊGʸiRNwBm,YsRQF-Yuw&Ij4/q_ ̹%(ѳȳoHB}wvmԧ%Ǿb=z5'xU|ǚp f`G“:(娢}QF5nm,ם/'ĭ{pi,񞇠BH3t<^vwnsN7E9_ޗcEsʜ]_~dx .auƧu5-?;qۃ@o 7b[Y+ie~?^MB5=Ue'}uo~"q;ZG_̀yvvrp:pkږ FULL%ogUOש(WV۽Kmt殮?C/A_ſŮ^d\܋d۝҃Pz*$洎 Wj)/kۓNXzv̒Oۥ鷰"k/Fe(FG2+N1I>tعk෥qQU-e_Y$zϷms)2Mjq4V,I;\EWnުev˕j5#zi2ŴXsQRU4[u3 Sucwf.HWUUdeܤ:WV{1(Hwg/45 ;p8gWO˕ 'oZ#HԩNNOS|){Z{X 6'~V% 0@kڕiTvC!](zkCJ-U)**pq{Tҳ.?.trt.EWRH,r'v?ySZCkli GujI#*\nNNsu?zW}_Z7tOt*͏῕'Z"iNxwLImbHvya rH8Vd۵VR|։a %@l'͌AIX>Z"K{M^<֑cFUv؎+.fdlxefi[޽*_hP̷ yfuin<~UQ.^[ލjtvizGGCs"TwҜԝTevo8{p̈́(Fly(bnǎ?xiє$dPّa'׹[{>T7qqMZ]7hو ׿lQ̇VWOb9V-ؘ:f>طR}&ݣhmCaGQˌT:a)[D>t팍u$9cn!9Z5QI wC?N4MO7Ws篎:}ņMDg'?w=nV;^g~'Ri֧_dk[;[bԮXcYT&3VM]מьQ֕䥣n}~u AܭK:<=1:8j+E;6~Col(ɠ\T7 @yvȯΨgqϖsw:ߗrou 5Kn>g5ROIg<IZ-ЎǟlU ;*«rqڌvo0Ju8#ŏgj-r?yiQY,4~4Jym#hc2Z;e֜nJm 5SR<[=ߥ9AO"Xmn$~YG7[tʵn )[Ъ1;>;O9k{]ཌm}<<C'8wzey'.me'%RjnO C$,.d%Qs>fG ?f gyx%\H>:vۯϭboT+ڌtMjDo)pQvwa}qH8Z4!%]eG cw>m6yۯN*rnIhimw:iv`y.&&_2#5f9~I'_^~{yD#O_c-EScX۝MYa?6 ?9r| bߕ|n|jb*(ՕMG8]YF,p(͑y9{ 4{~v_#T蚶k umSN!f=j6o$9?x֋V[t8ʷ4V=CV;H..)YBG9؃$\q\۩u1^\\*RQW~WZFk<1EvQD 9 m9q:ڿ/뱎[N4\Iukꟕ'|[ &3] -y0g6|U:8Cj6[ZסjUZ5*(kfd/?58a˗ٴ-0=N0-Q'yXVQ<{_O-pV&dn@=}\)<>+^.1IYhڷ|ק ?7푤X2.mVU):Wi I}eQoo+V3Ȫ%29 |Νh?vIY88^55[zY_՟wBoj g&fV; +QU*t=^>{WN=ӒmMN5M6e7 UHb9XQI_er>g 5´X3+ʼn ^9N97m^ٕN\4)Ғu: Pg-:řaw텀edQ50ogܗZ[-s>??/O ҥ۲Ө+N:q?z~~g'57nmZz)'S>5ӡIv!v\^4/f- sZ T WGV}Jj^dKr4qR.3d6FS(NnYI$*;~&ښRn]ShU̼ב9⡾Io8hHssW(D*9fHٕ[v#z+9M׹RU)Ѷ먮 I8=?ފGvxTU̗yKFV8Q[Ԗ XYch_қcz>t&bdei#A?&fE'o'IY[YsΎhǖWmp"cpx8{Bն״rUFť)%^^ثycx_w^Jdܤ8R?Ȥeө%͹51 6=sLcG*ێ<2GUau}SJ˩^IY3ɹFU[КsZ[FHj0ŞuOU9< f_ZS/w-S#dta5$;1´q(Z[~H ’0 &Wn7p}UI71cqݜsZG"fۆvxOcBט|L} df'4늘4c)ToN$\*zB?~0ej2F<JU%u U!O]09 _ܬvՌ23{]7.^UoQ^qm\=dU [bT.Nҋ[3F+sڜy1h\>1~өMrhrmENT͓ |ҩ?sJtiVWyjyxQ;ZXJ.gVmWPV10+ڱYE$eZIba&Zfz ʮ{ FyT%'Ioh#Yymp溰ʽ>h9~|G`R$ֺ#_NXGnJT\Jm~^җ,ekoԉcn1}tNNGuo޺US|JOsA&z]Vbw`:{?1̵o";f2">Rߝ*sNZ=,סZH.8 9On+XN=, ѨWt~CHK #bѪN9Zn"4Q=\y-mK.qjeǕ/V6/PV2Rۻ:YLκ.e1ȋq-JrnkWrݙ:mӠoO[ЙTQtdg[xIqEtaqՑMz%E9’Fkʩ*{nT++߱WtekvJ¥JО[1#'B+d >PyޛhdI@LlqסSLoRZ;is6((2dR&= u(ԥA>ٝ&?-Gmۅ'#xjy\}-Sdȍq+#ʭHcg{ܚ(֢㼯} b{o0yl˂Nb?%4ԧM(]+ 2LJBM&rҨ.ðf,Zܳsh#im@l>D_/rY63H!+4AUhd8$ic%F*rm#XgpxtJ.*n#S9;MtIH$s=ހ+EͼdՖUSqZoi$nU] = #.Y-Z̊_Z*4奕6ʸ !eͭПqݽkJKRjG۔[G>#\O߼t=zSX7Mԧ-bNSŢcoLr+>w:ISM]<V$\Gq\Uӓ綣e̿w[xو*T*Z.|q1cZFoQ҉a_2ݒ[ >?s[Ҍ1746ݫISSаG~{*7P~PkE$t]:z2Ð|'tg͇Qz6;a{%+QbDp W2QFu`.o3mNS(&&Ju5^Ds\[@p 5/gy=w7Z7g#ju~m:=d4-$s>UD.k#Jw{w AۿJNz< hJFkwȨ6մ9EEhiwݳmrFƏ5NhA1O{Jb9Skv9;c;uc1Th13(jiԖ[EAi {<,󞂽h5ڜy]tYOy۷ZPT엽߷p]Fa~ϒsjoPdܓ֩mϗPc"vsI3*?]ʫT};"8ʜe{;ZlEY ۲@gc\Q4q2tZl}CqqeYe_%F89+ S#+㮆N57x˳-CX6&S(ԝ5+.,[%>hwLuȭ*SלtޮjVՎBägdo˂߼rp~g=Y\K^9!;*fW=H]*BXz1uo-{G \ɵ@.2x~n.iЧro^~g*r'Z/B9/-Pr,ʬ;H\S#N4i Dw͍YԧZRW̓X.RWנ䕭OA x s#AFqn*4oNO[ʻ/ǘ'>"Q[c(r-тMjr1?Ԋ50=J#x=s#Xӗ4VR#c8ʽX?+.:U9ce0Id_ ˒1`#N>MbJ7 *u b9W2}zW8EAbܛwH3,mN:m r}$wFJ2&|bʹ8' ʟ7bPxԲhoXMpKc6vNp1ױuԯ7X]b sd:aRqtqjՈKԫ*[_l2MŸGDh1vz#+ƤFIS5i*!u3t*I$ӎ/s:r=d%B\`ǁ>}qYƇTRs橷wj/b,GՍ~S[*zXqoёDbndw|~x& vIM䀱.|3<1`Q[wNeZ*4}o \ɈT=dH7myl+_D ڛcR1N?SDpV5yFW{|ڪ }{p̽ (T׷/,b|ƻ_X}@3qTTiMQ&]:챫Y^oJ˗} ֫RJSTS,1,w}v2o: 5 {铣NWB!K(ɿ)7m$zV~Q ْ=yNT `qc$^FUB͚snL_c*G_PES'G=yTX ̟gOWNB=jSY?$EO9acHq3c4=̫FT_#>l{ܶcq: )ǚ" "rD`#m H?=e+˚tmO+f&EV%}PAJsӝohޝI$vS=1NGmD6Fu2FX{I+u#Wq^TiԭHҰS+2B/v^#yglv89:׵ZQW\{#?X3ȄۮE\eOҽy:}LT˱x/`CyK" c9Wa)J8J4ө=}XXQhs^qw~hSvM4'Wa}k F4mϧWeoG^#NXFXJҵ}%v|(NkIS;YY;iIFN݅o 42CǸ~g^ß~U(J0F-'/n1Wi>ң+4Ӎn^2͟o ndˆزI{v5X)!R֯qyd@͆hJyJT*TI|$uḖk!WHl?9Tc_M~z~-%܎ o[47* \A}kIS/<5TSiȳhʲrM{}S -5hCt#n~lf.W% Xʹ:ׅ:?xlqؘS]z㍼;327;Fx'5֕IMZj1ӿa3<\t/Ry1Jk/$ V;鏯"jWNt).cY>eWz'>Xs oKZT){i̪4QRK}ܽWNܘ\ԻksCM$$0Hq֣*.Υi{8kZ$X Kؙ(8!rK8teV۫ڤ!NMik[,[hw/*5-.f1Z8=4İj ϊ娣YZAZ5%V)i- 7L"ǹwZє_,#ku!%~lY~f#̥.Y]#FRzV:u1eS>UiYH|Io9}Ls8P7Q<~^k9ViǩڹWsZJR}D_'Ns=\hVHڣii0h!*[ |x?({}+T8էgn~HK!vۀܟ\1*5Haժ=/i.g2pzuh_^>h*ɒEg`o(zyE¥c':m>w0Z6FGвAJ]TZnݎFe~WcWNuZ Yb?6-"l+~hjUk8eٚQF~y{]FER'bԳi[4"#=d{PUӌeR/)q,ʼv?V8Y6$.FZfs׌*|nrөoS>@YcocUT)s'3_˹]#7?0=yYEArԍGqUrгm ghcZ{KEhL@in#דY-D9Eح剖][p\xu?us{9A*k$>c /)FA۟ZǞvmʣq'6۫c[8[KPPyԜ+Z|08Gf\y:;X$ԨjqoG+S' neGl¶7 ޽-=RιSR,ז|4|GD|ԾpE{GOhn)M/ uDۼrqy8be5!8T>2ghumf<XcB{2I^|s6ᏏմqmO j8 r:'Gu*N O͕kaeU.dϦoqvxTyNRQcQI8{?OLxSγ44ݏ9 @F~cJUz#tc//-WVbXo2 Bs<,O4̔{4gi^?]4aH*<$3TqǷ`1VPz<ք]J ~%C}X±7cwmzyeZOqׯ۱[|lщվXP$6@Pfpx:əM{F]NЭ Y6-U#[$L.spwm#=+催ݪauc:+E4w<]5O(IӞ}RWFNm$q}ΉHSE+{tPϗ8\FΖdYXr䑁' >GG{,U8E^K$pYFf;EoUER/#/Kާwuff;s]ƚNZձU+Yh^E^\/n;{gzb )g[Jn_#uӒhU7yvjr@R/W]_Y&&+}¾ jEooݜr0Xgq޲1y}ӋZJ+VSPB # VFvON:s^K)>[x؉5ϱim/u%=fԈ]~WV*jvPwNiFMoX|UXxXm8Cut?աV7c=:"S^FJSķKm']4߁v=s}v V4b1\ӭMku5|Cgg,mK126֮zXug 4bƝ+n9$;:J/tu>G7[lvҠR\j^W#ќ8ҝ֒ԎPK؊0pA\ܜܤ8.qc#$WxWwCU<S>IRw x&ދ^}zqfW:v-槕b_xW<3q"!i?1XS5}Zyd Q]rhu}BM۴~uʵΤyeWU?Oz2徻J[,1h4h$ќִۡ8ԕ4F$fCՍY*p0dW1#RS7RsVzWmf;q:tn-iKF-SYmHl{nڐ_pw\F̼6ן*Z7"Ys49Lġ͸%TFN]Ci'RUngkt`ҧ.kԛ*}=:g򻛟b/8IUuݜψ|3y\"ZLv}EJqm3ҭR*d|r>4𨴏YBܰ0^5/KM;6vpORigiszׁhc*vsV8QQOM.s'Mmk 9,yo/9VjqGWtC׉"{nna˫1Ā  Т{oeԾܷ=OωMc\= E%9<6g8y~RͭZeM7Myi"mfZG3YH2GONu֑GM+DgS_'d[k˹Z;K992I'nzVԧB9'O]K9$c_X??\cOsVOn:SԣuYmBm2yJcA61_qݴ=qKeJ1-u~_8, ,C/wJk__/]z\Ԛxz$w,<ҽF>_(֌ȭӡ{9#>HRz5ԥRwRNS[ȒdUTް*ˡхUFdI UrUF7&=-Zu%'vOOicO%K#iQTjLkFMZ[Ǻ։vJs蕙=yV"yUfp1M9|F}MUxT<{gBEEhZ\MΣ*}׌{jocyS^~0[kr=J+[fu mpA?Z|-i(C~(VFWe}k\7àkU#ԒץX.E#P|$=XBS#m::v6&𕦳'ۧSLxo^x }=QrsSIuQ[ =999sN{i_ߡx'zdueʍ.*IX\b[/7m/mtJUk.χ& 21U*xִ1QTV=.>4p)A{;t>ѼhӵI6۴3; Q'_3jEޖͳ*^nm=[yZ%FoPD}y;^GOIQ2@ǒ2ʮpmvZ.֛AUWVemկtſ2,ï=>r4׳zw= 6' ]6;rmwNQSVs̾Χ=|ҵ^<15B!dzV^ͷjrU NO[/jZƙnٿh\qSUq'C.%ibUWx]T-a]NndB]G oBʛqVSRT\}~~]g+FW{/pjIIsѧN|_e˫+3|Icݻv;R*qvyEb$|Nid5t :{^=8Fm]FR^Dw~ u[=9+6L *U_[}GS̩SK-zU@g}_*Q汩XD qUWrRԞIiȼR[=ln'Xs>H'L}gtU_mM{y V;XXXѝpv-n7,Cavz:§*)%5v4(`g67 6ϔH#٬#V\Im\/вqƫ#37Rsӏ3ZB^zԳm$#LxҦߩt/)o1;qڱZzNJROoQH@E*x uRM4c5̷'T{e. =8ƷPZ*|_Sk߾ C`A08IJIoѧZvvq[ۣ=z%VTđGeW9 zu8єR'A{ݬq4/:,@SnW2;ڵK%9[Pq5Yf6+m睹>$7N2nF{Y1PwJ$?N攩J#L껔cvR{k.z*ݢ}C.oC8%R]f6,=HuV R\ )E$f/ aWp9Yz#'.xiLyIMXcԓһ)RX R1%M1THxݟ9:Q;׳/K~F{ןRc+X'R+7v'KRL)6х=2I_z *\ӵ)k}Om"ꯩ_+A8W2u  )c}ثk;Zu>ۂer\+}m|n=jm` hi̹yR;s?DY͌s|OBo󱑭^>}4SRܲo "4clcgwt\mU}˩^;JUbkFp:xg zW~1%w  nŭn<OSj,ޝL8EI=:[C** >a[FRo~N.[o29M H:mPZ{:|akJ^O"Wm'uLeK4F&dI!ìm U vu+Ii4"&hV]y(JwRIǗ]c]vyJq7f%FR\SXEo6UبsDvLfKTrƢfޯ8̶L-]uƋ௰k\Z׷膬~fJ*ƿ30Ϯ~.V5ޭ:5͑3F+>ݧ^;N2uZ4k:m 煰 pb @9튤,o$I_hqܭ#4 #A?JJZ;> ["Mۛ,1q59ʜӐC.yfhK:]L t^3Iz"Tek[ʷ7#)ٲ>蓨H;֔wyF5U5wp<7l89SN-VKqӧ:ݟ renA>>T枦*R_gPӀp;5Ԍ*k:i.U0y#c#A󮕭Niho˕)o,rJZm5uTwu8kdEDjԧyَ$POua 3Zɪ{"u'̲Nef!rGL8>N1%n#i'Z{x S2n pq+KE*nE{HʭOi:TER:VjNKȣsmVGIV<WL9ݙ4b*YGQDx#NXsǽ])J/Eœo/$K[$ymA8*}<>մeWv4*rm^7+Fʸl**gPNtRQ&(,$+g*- FQ4Q K#lG0Ǯk~[ʩRVڱNip%f…(* r+U--ISo%4]}AY%ݻ#Z:w !N[7rUN;2;VJ:[or}JJ9HZxy3c߿\ԥ)Ux}-%41^/Ο/4)WHMh~E9Dsqi,)W6ߛalvۏYIԜ^j-B1lב"rTR~AEUIbwRn^[>n&.azqV>Cʦ!I+?B"*ؤٳ:qڊ9N31, Mọ8YGgVE$|)nAsr#e;.m t#># ERo%RsHd*tg׹=;_ΌMNRnz$9۹LwJ#lcgUr #A[{J^n˯RQ̌YmXc{b+\܈Q&`j1y]ˍBH{TYFRKrۛ?uFGJR>kX]m]S2ODy,ʻywukR\$dmv]};h)oj4u,idzYIqWvNqmlm?{zS|[3[ȴi47j_7w9[ӧ*7IQw [yZUd-T}+3ޕ:9tcZ?yBl~)zQw`d{~t^XөNջ<5ijFَ9mzv<]uk{'鴋)[in]vHPW#fa /Y? ៳֗;R2WM.3cN2^Z!V9BA$u!Nt9+)jﮧMۆ#Ɇ8ˎJ=놳:k}>]J4)j>L.~mXQU*à=AT;-8Ptt{mܹein16y wҰjt=r{|~afR/PNi(6XY.XVLhJx+ʞJ.4w崃d+Hʙl~*aS"fQ73rW<~9JFI?p-49?0du޹NyfU;_G~f\d{ Uۻehl`nsڊu&ΜE?yӛa_7|ZE {Fѓ^hs jCw891ܣ-OJiVZ0K728?]9IkUUNw)Hͧ{LyaH98$7n3m*ܐߧkDj/VWW< KOoI&mѦ~/;TwV*ӛEtȽf*3ӲZ}=}O. v b;&<ˁݗ`z0>~~hNGfٶY:]af[mQ#§ԧ.X晄.SW؍O1ڶ7,p8iѕ:|ڽj=oĿh)i$9̌1zX2Mcb*:0u#֭OtSm6hSCdF88@865+`iz3d^ҟp捷W?4t-Rn,t4}WUG ,|( ¹b$ U<CO~=t;4Tytd瑩~[8|z?iٮH&?41u ۼrX>_29%[ W.>09#f﮷JkR4m|w7is>o%ڳ 21Ͽr]] r;+_!u=/S{}] 8e<uW)+Itr֧Z1VӯO&ެ Whp1YΛwԟmU}eԶZO#ͱVef %18OZ`gZ[FJ}:g(^\TI&#<)1\BQОOl}+|wtӶ/ VPϨpntI,i,T ~G8=x9Q}/k]~{4}ҋ{;2Rٛs|a~H9ZN.VV:iBdi"7 J3=0F9SoU!7Mo:J"@)}̧hOv8=iK GC8$Vm4k@%s; J0pFM? ݙKgh=0/sԔ+9]J祴7ݮ6_u=ӽc)h9n_ymeYR1vݤ'G={UqYTx zmɇM#[7z7&VS:KZٞ0ɵӎxVFWFiJO)G[;$u=)TE(m=@vQ\XpJR؍[Xp˺?M);9EryԙLu#֩%t9:m=Txā򧙂OxW724tof{f3#eu'dF~鷱!WbWdWץ*QT>!5Oۨ|9<ձ))E"İ4sAYn۵WҺ>] q$r,qܳ~B"m%7ܚ ®8+99 c(-]N>1ZQ)ayjs-Bڍսʫx\#F2{ZʬkpfKI~!.3>ZQ6ߡ/3QrUXVU''q]tI$t1%4,|ËuTpp'~2|]G+/$ YƹcjVRBK1pՎmJ]A򲤊,:8f.I⎫##}vw|aysst&w+Ku Gy?TۛK׵sZ\M&O3Znf\pY75&kіRo}:TM6F;lua FA#kIGumkˡmjt⦒i]rݯ-m/:į Ｙ>#c#[~xH Xql5w~Ktk;1xzT]vGx_';S Ҳl9,yGy1kԓPN1W'ڞ6j2pqc>~z+ 鑯ı ʮq g"99`(mUlTj弴bՕݴٳ믁ڌ^O"Ԟēar# <3ΜYv7:^!{v/N}OֱWepfeGyy?s_?/*Z_C>@|3LѼfm,eDNyqTf9ssyW/AmT)9D|w̱8_m8cdqoʷe:Dž=j7o]Eڵm\B_1(NKHBw~OM"?xI&f,_wv9ǿHsZǤ(Ihd9c]#y衔. fUjjsGHoq{~79YT{$i=3^]OJWcIQ[WWݔt-T[[RKuI, mzFzs]XxՕ'y~)JTgDxJkցݬvL]K_ ^Z[%qb4r}z-{?ZpGM8lx퍯k5-cv6z}k*#*SWQi}zb<`p\g8:zqҿJE){*i%9T+4a!+cݍsY*5!ԺS֖=+F𷆮|4,*$8ܻv:Ԋiwxf\eMM23p;s>- AάyUo 5]FQӒ.qckL5J4j;{ *9Io]k.q'|^y5 kVeV5b>oNZ[Qko3m$89=O\.y#ifZ=-:|;o[yt=O~ xk-5Sm@HfvM[EI;tG[SU4]ﺿ}/2g06S#o N=5xZ?|_^P'n^z ?7DPx֬M%Q>:NHNF̀AǽWC5r|d}QJ }4t"kl,gJSJ)]~~xY(lkE}K4d+wL8<_Yuw^qstȾЦV5RW ' y+X:bJm;MYZ֠E*nQ9#=:`!VQI-j֨ӃWj =B|I$qn 8g#ֿNr\~|gBEkN*ܲm*vs~S;s^}I]N.uOII+4v0 n!ro7(֡"ME91ѸLu#UcmSMԜZ&N>5ɬxfO-{0vz2s^=\)FGG [ڵ6]G˪]^ :mƥ=7mH<kR#iqEJ6nNC'm᭳:wƧ4eeYFӂz(T&J)r.~eZUZF33UW9#9?iR5V*cv̦hY# 48ǽj'˿aGwlV %H鏯֪9YԊ;v'P oe qf?-#;Ku+Gwq6~bܒ#vuQR58_V;/16Bp`u Q]ΊeFI_k7Z*?i-NG%߲FUf`{siFܺxzwdQJ0234)`iK.[e2 ̪/8#G_$e˽eB#C7R%/C:Ό_xǸk$7pS=?ɩp+:sj׋jCVbO+ є#c'bbgV8ٙd`2?Zu9c WqI,4y%3;勋:ҟqz]\gosqRCkGTo{/m+Ȁ]yqp=x>])c{4tf 4(?3v\NpE^ nXK>XDtgqmPzeF*U~ߐSq+izcR:N`UY ~ֶd*uSoQv|dTەW81%>j2fh..=V1!A=JN2F}|C/nQIG{W !:pǡ?ΟootR%O38ϊctRUGCx;233Nxh: 1fG>)>Udo 41 h¼@^>TUwmmiSocGOuW,R"Jf`^ԹmBQ/!\GN(*cգdZe7'# ˻ox:D% T2n|őr?vj)/Q*J^㤜KqBPƣ z#9Q||؅$2$Yf_%OrGv(%wsJ0n2 π37G۱G͓W:m'LeRNh5K_yѧrZC$'aҪU2ӡt ؇){ىX;i7d6ܞ֕96ֈXĺU#S8A,>Nbn/WӷFuROTMyv\г)#?Z#>jO2xJH"2!s]1q+A;MeosӨWqG+x/tNVJ[) ہ|WE:%= %1K;V?x?wsT"vJKyq%Y| [ @F;gL~6_ViՊz_ʲX.|șr $5Q%.WsQ27;Rw批Z"qw}ELn}sHdgCD.dc*Ji^tM#ұGKݕΩ:5%hnsfPfEXkI;N8cFN4l7F9*[koƾq)VU[&EKoeJVrӪ13EN,źsi;MI{9%a_\C}av!;Us֩T}\z=)Zkq۹VMrY]|=:2_&ˏ$Cw;en{I8r:&oC9Mr;-v'Ye*#)^ogRJT5~BI-0yP~aҮ*S|>*2M'_Kp6x*=kbsRJ,\FM=jydtV^V&<\$(ʯ6B# ;%c}gnq\I:rk>f q]4m%ɘ>ϧK+ҩ.Euk1kh݌Xv8=Oι6_!sC$Vy3*] JznJa:Ȩ/=z5}L-wڕ\yRp\r9F6_ס^rwV8~(!M*$t<,mU}bAW=_utAGg% !YV'-sTK_mj1pc WK0YJzu8=yr{5ͽeN0iqȐZM^$t#qU+Tڽ:sޜZ~{nvs-29={ny~Fp$-ٍ1z 9qU8;V)kb+٠,;]Q 7h,N?8)lb)0|ͫzc 6׵m'Z޺/jեb9'ӞvM,݂A/R::^[gK,5J~-%Z7B{2:4raHrzeo{jvחANF\#7́3 :{ WZ,~omQin6u$e#8뎹~i~]|ENs$S V{Xјz>F03zS&;QQd֫'{F[WY%۝ Wq\HɻOӭaV7 uF=zV2揻sNRӾ|ѬVlj~L;q֌Zu{K!i }Ցx;v5ЩZ >…:r+؁p@0;p?^xI{gJkDZoGJ\0|utAF;+ zqou'c]%+hWsݮ01}kiCI*MrtЪ"%n3Ӆj\ xhs #.W;V>fto(AV$aqY67r?:H$1Z5|_haՂq{ԗ7K-*tK EIo3g}qZ{g 15&~7wKmE, ^~5J8Nna=aFs6flntJNrCJXΜdo.%-h#UT.0r8=褟^a: o&OfUg֮8usҭ(;bd1DdfUkw<v/xXYZ\z>tb}%n\z/cjtjƵ#&8!z9U^Uݺts$n+nYGN(|܅(:,sjɥiV譣X! 3@ ˒;~8+xӓM[omfg\~\YTS|%Љ+]JY4l}޻yF>vR?:=:xwXnd\.O8 BkN-5RӍWqWTuLz;:UFUe(HC1J1 8YʦPEݼ%kQ#0zٶKש%khX h7ʫ2c#cRNU'%{ YU`bڲ(ͦeF',v #`+@lӌ+iI%+ZON k f"w(}_[vN9iR-ob)mbd*GdprN`GkGޱh)rܫoa]:F>7a0+)6F֍r=pԣr*u%D0=-õa(tߣ47m|NhDjP? Z~feN.=d eYWtdsӦ {?{Suv[(7H>\rι${1w[)Zʮd}~(3RQԦޤ"-k ``pqjHv'@9tg)VTm}z J)խIFZ$F"4Nbuf\``AgpuyRIMՊ~k,lh[˓wFϨJTeNm2+I҂%Tem /=Ҕ}֋G[̍IϦ{vNQ/Bch%HIvیb,\w*;E Yp c%voG3%*R9R2fV~AqG-dRVX٢v25݇NkjNi?̉#6,r"ʠ88+wOWggR$Ua:pSҝ:r+}1;:܎z`׸(KZ4dfnȼifgGP6!O~y+ޥ)hmzRONW;;b\',NK@ ׏bE^gm}mwgiyeCgHQkԧoKj_$L`_5w-0㓴dc'.O=TcN] [#Y'?63!l<b+r[ŕTV-w*aO뱜*rf+d܉ ʫp85h'𳎭Oc'>䗰iiʨ ;Wq$ikMng9?gVUXUHي䞣s]|1?em&w/>ބTх&+|҅m7ɓqWZ$i#Z59$\ncTo_;Dc`g?^ioR‹eI#͌'1M9I&}5H*{~Sk$rƒK ヒ:cWh&]ZUcf6B[oA#qUKp' p,\>ג6+~=}{U:nR{.Xw-\Go5y 0=xԓ]Еh^JT2[mumF8< /goԪyp7u~e EsmEZ79YG_̪*F:zխ1][{ ߀x稬cV4z}CXJhMozB'Xdfv4u@ĜY֕u#J ~)Q[]ؑ,[9grit9㊒Q+~Fχ쳐|1aSdҲj֩gnWKy`t)V4;Upp@vkɭ6TK1u D-[xvn^YGdkҊ*;?qTc)V4ki+]xnЪvDI]ʹO89t:Ҥ4L^Ri0t64DuYc Tӧ/idN*rxs,09>_knVTok<1wE1y~Zoi%)(·];%֣υ;vmEe G9Ӕ\oʧ%6Oteo7s⣖xW_#/iZQN:8#V?*)폧[v4\Mmm4]4pɢ5;*Vu)EԴminceR/pԭ-PX`[٦۵]lJSK[nUӄ[[z.yyk(Dtji5C+3#+H1=ҼBԩJ$$fWxzыe,V"VumMK-:k*U9鎸ݫ^ZTro}R{ض#[e5.AhO;~ eNu&--ԚwM9u$LvTG6@'<GN:zU.u~}N g*VoȵeۭypHa=G_uw{hKcFHceY#merfo^:=W$hhW5:S}f҂KƬ\!ߵcV\rJgVU=%̓G^gR"Ms=:y~k5>]#`5V #IghkXifvB͏d=e)SI5J2qZy6^|,Ɯh❶i}L%9hm tuct18Tn^ ZQ}WSaǽ|19a*єڴro0xA'5O4ԌTشs*yCßκ8Tc(sٯ^敗ݷnl1~wT}XIMؽl|ګIyy1F-ܔk|(nOcU9(Js|E Ul}1V˂S΋j^KَnvH/:j7"tN =V?g}Ch+J~@ʏԫYI%ʖ",}>}h {<Ƅ"¨1c5GjU<9{Hu u3 95l$ݿǗ,0I(3&FNJ.?5?=TWkO3OA&G ۓF&;c>+(׊X|&Tt߈.%C$9<u h甭KnLdSs$y#,\+ ԓnCpJRsӼ9=2=±\F,lO8<;9 I$19>4nxWY9y,R36cB3 oWfXʕ*'U7woMe[sSƚw߉KQi5 /Xw70@8weU[[O*x\E)J:BQhk>?ࡺGI>6'[>Ul\AdlG#9"8բOo>"WOO{wV_;on. K&[_0=H,=FbU%UBn|nn5iK.];N $tӜ~-Ja)Zo?Sϭ5}z5gd䲲 .FTiWjT:vZy?{j5T3}\ӎH#]_^nmo/;{?[(u KZ*h\Hs=_ wn~Ǐ_Yβ11LOuYMm孻r 1K UԔSѥccj˕.xm4 -7h%HtFHaƳ:m߯E{P\*O\]?T+]_.TȬ7 ƛy=FF@a=N1S)̨ʢou ?mIc3e7Fy`OO.@+upV=?mKߎ]ly+@C"“HL 8^:iY],T\v[ = OE0meڹ rqpyNI^:=&ѵxoM&ճ{z.?=Қ[XYES8rӮ2[O<2 -zۻhht)^{~k)Rn/G}"Pn1s'=Ipg+w8}<<}]s{C72y6?vcv3}/5}e[Sv6]ơ#w M.XƔa:zI4VwXjw#G0ABrn3zUFFϦl!ïݭ91#ͳ۹zI)295.i7M%+ vZba>ogعE"_sqy)_K=BΦhג8zǿNOfx:E{іe2chz f[$gToyFXo˹kN<+J;Z.]~QF:kaQ}uUկn$ܫߧ|jSo4xx{5kMN9m`y郞+ EJ}L_4_9MJy%L\WO+ΤSCI#ey*cw:)MJ.>LrNВY~KVc~Sy;֬n %ĐݬM,B'~Vp\9v#FӢUOKui,R-+HUzqӕk`Ԏi8`״M>LI"𶴺 ae\pG:Ҏ*82v1f֥[b뺽ǘ{})}0)rD|kX{Gk26Ӓx?Ng攓.kb&?}J]\h cw#+f~zjyvWtuNj5]Fw;o%׮ ˵H=y$0@)SH)toӭ^T҂劷k_뱃?W&s5Fc$}xt9-o2J+]o~)nva==В7ewaВ ZX+kmr7hwj8n_i$rI)3Lc]Ҝ/uG=]c[,>FPiۧ@Ƨ#21ywלU9akIxƍL;,-tY&]Hc?#h3FUkF}\;m{Z-;i]M<_,' uJK]/sKZKɯ\qNGWF喺t0N2uԴ?m[EPWBG};px~}|58^MlOϩΝ:2Tou4kM ʫo7#xҾVX0%&mz LW% %~OǽQ;mYJ(QUi=z? ~tmr}bHǗn|} A{f*uG?_W-ܬciA:N./\k˛S3|= ]B_Il1<};n+}')KZKĞdE4UXY@*xzrNRyh)Uwu OrQҲt8*u^iu$^[Fj1?C^b5{yI&cWko(֫K[բ>[8ʾ9YQn?SERZ+1\L[%y{ª)9ZFcKl %*ʥ}|\0lWK_7?A6G$H6NV?/ dcRSs5naJvz=uw|ŗmWFKTjԔiC $X/ɸc+$FZ*PM&j8MX׋III= {_WSv^$V0KQi-? Q GG$#zoVv|B| -]>kM7wQ(]G|J 1!"hvU'309 lvT$Z[[{18w[EhֺO.? MeRR%B+s)b}NF!fes.}ѭJ^ZJ{xWwZ5e >tڧ;#xI&wpzI}ۄ<.0ӭvBpwor72ȋݽ^cNy[z^.̹qG5akSv5l=G.^6RK&Ʉ6ܹ<2RKau.wkiLkE9>mqϽyRe}N{+~l| mUU1#@N8wYշ5 $VѶV}{0 v<zp3Yn-{?೗'JU}lu=6٧cI32eTpy0IsYۡWx[Ko- *9 Gjsic|Cem,J~V2q^9_N;WrF۲yq)Um8(jSҳͳ*$e.ge̸l#&jBUzqsQZmҴ-f<\u# NRFSZw/Y`/n;X|r?ZSU=mpuMS̒|ڪ3Pǡ'U:I|ѳ-ɝS|xSR)bZOm69._uo)sNrU9j{!y-mc"5s-֫43ټ6Z2!ۀ=yAҾ9rGM+wQ82,lnC:ӵz4y]8o39/3,xsߑzV5\-k"$ae<5)>m4ҜdRxa$:g'Nz*}H>rz/`H5lH%V >oߊ)%ʄwu5"YDSd*$V}3庒8(KFZI Gl_V43%w,DjnH ErmCjm_!UHN1QRtua2Z\O*Ksy&@QpxU!8m4efq>f-90q8{[ㄣ˾ڗNu]?Z\mtmONO䎇OʵPvzZ}ϩgh'wm^__vʰ,b3aG.A*BstӖ}uߧV>3R*I]{oEJ6G<`0AFU9TTS"XxJϽ}vXߏ³Y5[M;G=1\{jc8qUOu4;2dv~Ny6﷯(ʥ /FT&EݤiM{|3+'nl^mJUiH٭J;_𽙟'rEKi<-yc\g>aW;4pVJ.Vƛ?L#]eav1'=M]k``K?_.!lX ޫ gkE5L>mq6 )*dNO9ƟXDo_38`e$ۭO7<=I6څMUsv\mV=>1\\#%Is˫=⛶4i;ݯ7 {}R[vQ\&:Wsrz~"JP9qXF*Ke-__ X<9+Y3=|1Xϓƌz-m5( yVy؃^:q^tծ|3a,o*q@oÜWL:*P(GE7`aPH`ֲ,ZN_ - .[xV8cdruϰ5yWyxy]RzIlTïIc2UVls׹#ӮE|"2S[9{nD+j&#zsψ$ޭYm_Xe2mVc!f {uonaO!JgюD,sZΜ's^ʍde ;n>fNEs(պ)RPxhFf^vA#["HO̒.#7b8!}}1߭aZΝ\)_еaSdEe9oO~+:iWmMș3Y|'*bTO+jaG_2%&IHrA,*s[8*ZRrTn;p*GRNVRymcs֐*FR.Qosͺ,]qs;w\WK`>U ӹ;%vfi#= TyWƾ̭Ow}HDJ;*ǾFN0c]Qa"R$. d'xedE9\w(Ҍ*=^]Cg0ˍ)iXs'=NQ26mWi&p6xs穩u{-RNiߥ1FpN둜8V$lXko)GA)rz7sWwӨArpdR['?qһӢ@3't̵ai-hhrǦq~7';'FUS^CL2[?t6*IJRUJqEtKiqo"{QDm$2I+hÖZV┩z.gcZb)w3*F0|szg'j%RnOFOr9-k6MU"ka?sQӌQ:M?D+`I% XР둜`?W̥(Zy? ڻBΣjĆ3t˕Cz^+f{mvlߗ_隺2 q-:+#/kg=uQeQR?g3oI>,я9]䤤F~a啙Rv׽Ugft(5(/‚1ǵ9e:rþMKu:=$f 7& "T8SӨXɒo.[.99%9>)KmIG=Jui-5!W`dڸ*JH]"J1 t1HR>fYiRj0ž N99S l|31S>ɠ =2M̰<`+\?:<.RGc}$1a==9q^~ |J躙beZwenxcH]I|?L/-tOfFTb*ԣ8Qhۺ>lߋm^y7>إ?D"CVV?RӍG9g-}N#Q;nο_ZDž]r=r&kuس rp `d/ey=LI4}ޖk[ H׬fWoαiI$UIw3 -rccqpz -5Kn=Z;̯^[=᎑nbG9HEV y5O-FM٭k?-W7R}-tTŴ0̕#Ec#$8/gko)jZ<9,Ĥ~d*``zq_im|U7m[1NhZ;p|gߥy5e+7sjn7 +NʒFI\0'tRf'Rtw0\fe, bǒ3߭LegZJRxil}̌uۿ95mVgMt!Ьpqc*·v{qZOyZG,)krI=LVG*464/۾?ݓ|s֦H˦rʔn3Ms.q;8{4cN1Z|>.d [e~XI8C] ]lҎd`ݍuG*ѿ::)r^Kv6 qnQF}M#SV%A 3N#C{wSf!N19ۋ SW,ڻקOo["ۨ4`+(eS{sߊ6}/0裏G}7}^;fmђUPt5[rtfճ4&xcDQ$~BZ٘au^y7u5}1"͑רs{˧C${#&`җLD<˞J1UeRWUiNC|adP/o϶GO^mNZz};loo F0]͹AUr8(#Nu%d{x*tyo5_KhYgBoxGA޻)ѯ^a:2Wl>Yp_1!ryl=ovTjJJ-kgh/ūM}m$dU 78qיYFqw= r.9W\WЌcVZW>–2+s~V 4a&Un-{.9$zWNI&<~a*t\)ە;=O }V҂T`,$q}kcwd`+bb.Joi5Z&h.-%beVfe$ytqQK'zwc$j Θ,e0$apğ^d|\WK5ij>=}m^4ym g{~`y?~k+ppMr}_xޝ+ƚ^8!@C1O%p b~cF=.jGm~5cN漶>,zg%dIlֱ-]d睠yYMqS [Em3YUSWpw8'9HU=0EGm_KD\Ǟnqm0TFzyw'bͣm,/lv,=1Yr̹Id-OԿV -ӧSXPv;(Q! W,Iys*<1#F7ld7G^ V8}[oWi'B7[zz~hV6 DiBp=r;~r$g":/վ3~*>+LkU =TưPoa'<¾$KҮd6,rMխvXx8s%towGe/j~Ue41d$3dVOSzK+Z?HbOCFU}sOq֨&jIFDofIB/JWmeRZٞtI60ǯ* B>w_'ݵ#IٌqY˚6՝(ӶjI 4k uifxsXs,ַ6d#-7"O 95)6۽uR|E#o;hrpq; sP]u~]=ID9DũsIyOL7FH)i%didyS6k gqqJ<|ބ$%yV ʺ! RH6Igeoθ]댟cOrߣ,ڧ&V8Fe ? >5.ߚZ_"HIwvUoxay5Wb*mCo_q$y 4k\*|Јʬb^e 8 aSZtJѳ!`visӑo~]Kyo3ǥlVFZ1P$rt3s׊J*RSrCS_72}zcZ`+NPyԷyq <֑:yI+!)0A8uJEFV5:uI#4n]>N+g~n\ɵ8 =yaQnAjcʯ~:ZsJ̨̄s7?L˽iiEeo.GU?wzjy K]|盟i>˟j}(ڿXJ`?.ʁNxǪ~"J̘ا?u=O'l8Q4tl5c͐ nhC WȪh֓t*4ߴl7^|6sO6A_޲J#|[RqNRre b?^rݧcX1igGϷ`rG\ք;n#9ɓۃ8YӇ+ԦСw>ZW;9yک+i)[C*# 5;pAeb3U'Ҥaȧ#'VwK c-6A9I迥8i96d4DbN^:wk)r5.R(>Nw]c*:{?99Qu0J{Eޥg,yEfhyfl21^^GcW<ː nc}IVbb".Vj0j c[Rv̫"^GQ8gݝ U{[5kuRD7?0?tm}+Ԍt99譫r7gkpbȃ7ϵ]:`#jF}^,򺪷s'eIG.[R5)ӏ$̊w%\G4f۴8!Jp5JU$㵭IVeY77ߵwӧ%+=Qoڑ`4ّNݫ(Ӝu:qnfo)FY'(nuNIĉX/6ݞ 'cҕI(i ܪ |t6K2f]<7G*=~Qyf+˫'e NY-~Ul:SK{-NJh-'VR/ %lsgF%55Nm޹ڿQ]KD̺Jn_}Ŋ{SϹݞbc,?;|~γahX%q\'̚׽U7mS 1N4Z-^?Ydh]t򦵱8ӝQV k3ע9e[44n[Is_cЧR0c`{WZ.|pJ˺6XN狠: R[JJTc{,?JQHNXM`zGTeRqSioS%%if ;vz\yU*OV*}XI*ޙFqKՔԒg?⛉d]r9ZVxQݜvrTI[;XԄ4H̖br7#j5#V{Z՝^zr9^ԪBymcB;W2: DSNΚVK#>ǙhKh΃Oɞ1uUnõ/iVd]I`_kt{4ѤӖ\lGNYp+8IX#i=JG`m?ҝ:|w,De^l+Y9KYl'?^2F|W$T6@*٥(ө;AFX^iedաЩVP&y >\9۫&Xxӌ\ͽ046hlzҜ5UJ4umksfy$c}iBSu9-2Q֧xCHfeq8$y>ޕVN8Ė7ZߊηE {IFs뎥h$VBNGeu5J~V8=w+ʟ+*Pn6"Cm#yve;g? фj49>R)$֚%rǞ)YUd;t9?yr*Ri-e,Xדf;>)s]jsʤd^{6$p)[\2*Aڸ%Zn][8~W_ؽs4wPe;pX]pRZlGcR7]}{P:z˜Ukxo=JZMt6%(?I *M Pђ̤ݧm;\9O#Kɹim=]bo?[Ü>rקZ5㪿Z\s> Z4[fl_qӊP{_G>BHnĭh0mv+Y{jRjzcL08E_^V*EaTc628rM,ʱF1Wֹ .ӹUIr]ۑ3/2(.NrIӎ**=^UZte%)r8W1+˫yjCa?sZ)_CXiQm6ﲰ߲H0]<]8vN幜)6hWW R$H 795NKٷk3S޽wߢ%Ӣ8٤GN9ǯYQY=^3)ÚwIiO" )n oEo'x ~ί2M}ǃWJ1DX"e y_nxQ){(jAx$m@˹]p3F>MHէW4 s:[ۆ W<T)JZnኒR.[VA k?#fݖb:⷟:?3^K_.vwmG/4thlF8Wswcr{qPFQQ*=&61;0pK.Xۚ,Xx:bsfRvInxWj傒9FNRW;k/{9tQw8I>Y;_$jlFFIsK$~8masg13>޺L4v.!!y~_Ww.^>2u)k" qp6+68{F=]>^F>wDWҥyfn<G=+jq*}9Ekq0aV9קŭltKZ<)<}7GeΜewdw[nN[ʹO8I#**f`4d[/FGz銨Z4ct#< 'a,ZAc9 s?tER0nńۤaN8$.mV" QMu#0,{cQf x[F\qFp1N2먿jhdPC6%[Wӭ+46+t{VhjٴESﯧTK3^1~Xr1yݔlf9)o{";gY"ZǕMVh82 ȯ#mWm}s+KKm5#̯rn  2 ͥrԫRUw|LHHۈے}jqRןA8G,c:za*jvZYZK!A.ka=MiR<\ed f9 G9=:4iV'HCUxKmǿ㚾HBF>Ҥ)& WFݽcS[sluNU\uZk"cɹH9psq҈Nzv&hݱẁgw=k kU}ݽ+n&U0 R@ dthuX+Hs^CZ7XY7/ bcҕERpv(%L@Yf;@sT*G%YՖKE!w&8<_G &۷(IJ,c{aIu)ƜIQڏxHOUez{>2S;Wif-`m8jW^TjZ+O;{`*˵XcW)3zyu9qdv5aH6=9{HZ]VFb*um#ԩ+x=;.V R֚ӡ$Ϻ4]e-9 ԏRQdVEEu>eV`d]Ƹpy?v9qU%Rܱ&Tu^TgDS9=jvwԞ5r̼|@\?5neRTcBX!n۹w(<qYԌ(ƍ9Qiꅂ1chP QS8k#xzoqd6;:4h׎_ĊQ8j^C)dF>(@K+oo݋ ޿~-:X€۱ʹZ2;sA8}B8%bbq*[׵?i+(7=N0ME;vv wlTU#\+<xDT[bδ`I`Dc!V ׎D};Je̵(ܥԯq{yQ9!}:f4a:hƤG olV$(eÜ-/|o_iV!W**Jo(Lo"?vێIu1SO[kOXnѼ5O-T ~$`G:VҴiEk~7 Z wio妍,a+vLV{bR^;ѪnWh3#7)^__OzgOF,.X恞Fi6@ MMXFE+J yÒ[B,b4 G8_Ӗ)$7HC1 yw+[mKK!6\ilƣiЎ]NZEױkՖ"~e#;2W,0H^zTmܚ%s&}:1$1K4f8X8rrrsҪU%(+RkEC׵v3hV\δ֨姈('~{2i Ug,Ue*i%Ê9Q Nk8 4k#Gָ'^F=A4[hV~I:cW*rrroMz*8yUmi#?|%ZJ>EfsB 1d틎2渹>k:0SVOS&У@Ȳ6nIN10T/irh@\,*7p@{jc:~Cz1g}ŋ[8Yd^9:R\JRZ7vV/2۬>\rXَݙ=N ӊPx;ۡjʝi:(]73m1zJ-S VʦۿnZ#{vv~X:q*:Ս] 12c&6lӃW,mަr)J3OF4mlcv/$2Ic,-9Gɿ# G9]䭵h~E?qj:\/SΔNkai]̱+F8랼V )=7;iRz_R, .Nõeeiu"Xa.v+$X`o/m.3pqrV,zq1Ok*Ɗ ms}MpT{J 4w~bc潚sՕ׹ J<ѻy$.cyYaݻ95*Fs#z>GDy63,[6X0^+}24%jc UUrǥqGyt&Zi[n9Υ5<7 w ",bbei5m[ܵ 3F=WO4g+>qK|rF̻SnJ#eFvӡplve@~PҺ#RW1(e%6\*@'1U8J)ʞރ ],f!km<4TrZe3JŷgiL֑]~^{ZnbYF|V8UϯQZ]t*U-ߚ"e,UpXzjRFz l~UI7r <ִ+I(f)wnm>_;O|zc9[S#h9s&t4Mtv#񨨣}NZ=іVG6{kUc!8K@#ʝ)lVF;Fbt޳wW_-ڪ22Fz֦9iKw:Z=5mNϽDi4chՠs\nP6G?ֳy]7Q~R(@hp۽8N1Nt(ۡ}T/64lr8#Ӹ88^ Ҝ5devhfH}{+8`㤷58ZعEj>.5t]~{=to(Q䖊lԝ' EnX*{<֚Ŧޙg"asۯӚƖ`ũOmJ1|nm^-^$XIIq_gJ#X>{hxn!XA ݈^~oޛz1_v[7|j0c$d^F;Ťz~*#o]jHזG%RXq6jԫ~t{cAiW?u/Z{!kX0Lt$`3^.y?[{hDZ-uzWG-,nOf-9o8<`t qq\WR ZkZ߁嚇W⵿_ P#dC&Nq_X6iY6)fJK}뭮Eeuֶ>GS*g[wmR1WR^Vyѧj^k^_ uKwnTˍ͓qNz[_O NoL,!Vݕ7N߅zW^zIZz,o_saQC+){' 1sʢKgy}aEۿCؙvo0ٱWf7aG9_|֩tGsK߷jj^QLodIXn\D39g+J/haa+O[ҭi-E$.g8L_"e¥wn>j?.f{#o.X r$tLVڽwЫ]R=Ko5h~&ѣIhی{g$#\]S`q7 ;Zcu OMsK,In>Hl^8!߯zUKgۆ-|ܧ&_bh/iQ_SJuS+wl<[뗺rwV-.#CQCpFhԣzZiN/U\eثeC/ݖ<ȽHB_;w;-Mlєu?j:n|>i$}zc 0 㞙u%2I_qt1RmKn+u{ÖqM=s(6.zcgUkImWd:~K`zknaY%.+QoײHעͽW|Υ5r7 f3 A]3`F 灜2ykSJ:=U iKO,<#勐~W*yvf5(^z.=xf,!BuO,m{m584js=E QlMkn4]ڟ a< E:ݏ/g&,YHʤaZƴyӚraBMi]{.X(Cr!yt?۽qrGܒ.MpW*\nΣ798|Z+_ sr!*Nzyux3qM5{w檶NI[fL*G&ajIvuXP C,jrrs8\u3 BomJ2skftV+}|u\,l@ 8I]۞fEsmaC{xѣ}OCʝ4KhM̓]YFWio8~m}>5ȸfFw(p8sUJUMir/uѵ}dju p3\5#RJl,DԴOb>HP0˒Gʌ Gnyx /w ;Y[Ybjt\(^nۡ~ÖwIZD+q6}p2kϭ*7WzТ9zw_GWZoC$ƞYe[pЌ9~ϦarU??a0%PquZ]xJ.&of&?. NGOp:хRq8R 7}{EDQs(=[6"*5A%w1IA cE.Y;V2jJ^G|&㿆:܇EםtX4K;Ub8rx[;?[/gЪJW#WB]*Ff[XȌ${`v,6!э.}{ii^'8E=nxdM89gBѷskz3;Y~.Rzz\u$vz>EaF{k}/i*Q.ZG|-S_$7iЖY,D1RI (8\x:mZޗv3j7V[yU n@5G $g68X3=|AlR!09Xq1Rmx^jmZ[o>:JU'k@4iX°&W:0/kwmiNRi%-Vلb5'Ix)TiJSќh3y.V6SH#q랧<iѩ=GOҾ$>+t=9Vm*[^i񪤭mV_z|u9IÕ7M~6qU~U_0%Ǣo:᰿XۃQ]Yzώ+{]?RXoJdXā;rF8'82q)N)uiɵtᏪG)J񾷼]MwAy$7#;79 r/%hiK[i9Ά+$+t|Muk.VkƆ3* r⽥ rww.RQ*mmn}o9)pѳ)f,A=@1ފqӫ7QK6R~xC¶z/Oܻr[ӹ?OA\ձ*٧<ʵkVۯC>x;k{$JLʩ1pr3+ѧ~4#\(Ǻx{m |rF[908J򌫫q\,Z}$w]z,y,2~{_]Mm?^~϶Hcnp2mFQ&X֣bM$<1Y0EMJr.|YVG:޴QI_˷H7~yӻJ qu%dӷCXs>cy_'Z2~1kݶzƦ oqx+8EةCtKD?i$mێOzϨj.2r[*dW ɵY6`rG\-Ψ|q5+1m9}}+?i_Somv}bpʳB n8zocE[\Տ(%Lcm;a*SrZrWp$s$)Sל *D)QMn) wt\:iKJ#Ju]|͐#):lk7)$6U#R%R/̼;ɈiM%iZ.jEramm#H("01dsJU#SE1 hY#J<?µeͩQj6 :I S \~bzr?L{ըErN<ϸyo g̗ p1h8iTN_M[ܒw/"O3(7S?rNQꌟ]6vng#ʺiy#*nkܮk"9fwg+Ϩ}~'4eYSu,[Xbihr:ѭ*|~,wUPNz֎i\o-9FN^sȓ*m=ϿJ1{Ӛ˵y 6ֽ!b1ӧN<[4rҒw%B̭Cq'j״Mju=_Z W[ ֺ/s0*j-}F:wtel61[E] *u)ijf\<>\κq}李"L^[0mdgq'W*,^^2[+Q.O۽W {*쌽/)R8VNz߱s x[ ,h.@>!)K8gh}2oGUbK_B#Euwue&9$Q#3wo]t7KwOWn Fak4Bx fi0+U=c)TZIf B* ;N @럭WbܭwE:)SJ#t=´max8'ұcQ',m=IZ:wߧXU8y$hf&5}rsJ+54KKDn.[$}3jisF4N#j4D7`7(ya[ G\~4N6Tg5i8yb$ 黊)ʏ6X8μ.'o2Xck-mԧ(V2n'eyWhPF3={gmNqqIҜpz|M*^N|neݸryFx4Z8~W&C*3?sSk%}*̍#ٲ voҮxrQ^l9Sk)UTLSG|SJހjI'$70ʒmGqcӱG]9EEFlw_\"mSsӯ+ӗ=GH3>i9,6y+R2V8?1]Q8Q%RDtnگJZ["PjwE7be.o|ו5kC$8V;һ)ӏ3q&Rx'Fq~WaS厈h 1!zÆN1[?Sxoܖf A9uSR9ۙ}w" x7eszWl} |Ƣ浼ˍ,,$qS'`00}).u 'u*E_fs'P10n3[Z{JV{& kvuHԬ{6t8ݜz_:4ԡVI>g#6Td1cf\+#0XG5vvZ=gS$j0:cwu9+e4a/:&IKLpO+<:}_c^JQZ{tCI<(~,^Z14ս 4y&2~c? pk!NdT*-Kuh[^nBr;F޸%'٬eR9^V[ӂ/h*fb3uq{)]w1:tei'GSO+~UZR_P]oz+iB3926H<߭rOi>]JQ67 `-(8h=}{ʏԡRULVM$ap̻xO#_vUECoqq5Uesg4Ҧ'rz&ݭ>{ _EGhՎzE<)qiPY+y%ηܬʣ)I }*i_Ǐ+I]&^%<}ZTfdc*~p1UGYOs'=9ٍƩj5rRF5V<B|"{oso+=0_^I" Hv6{5/EIӎNe%$O+oMh"G a9=;;6aq}VTJjƶ9RZkkFƍOW:d6w˓vz\TKch[Tӷ|& .5Im?XF 0XnVΥhE[[wEh|}/|qujK(mBE+`HJqjMhR:uUl,*> 6_6lYL 9 :Eyu(R:SI(k/.x];t63}FXpzl⦥8kΌ>3(rW.xZSֻ%4r`r8<#\ZzU{Tq:4h~8|B|9}Rx#yVS pA㞾.Q*oNM 5*K~G~!O⿊k {yGoƪK8 rw?ha˰tEs4/mIIE4ݴ[ie-%5Hdr@UXuSJJ 1^VE>Ѧo_?mU&&Mh@ *#R;w>97DZT5jMui^M=2=xRDLQMM~_cC *Ϙ0۸dZ+R΂e{%TgiF3ʹi۳Ns53'ncՆxOѶ}kyf;]3A%&b3cY挹ޝ,K .fsH1mПZQe{gv"=qG=:uUnPTNeV">UV9baOKq9aH?15.0ԚrKm |G;~cR;FQƵGv̹m,qq\rSjlONkB127 u9g**2W"T"Y[Rn߬mÜtח:p硍WKmG)+}ܰxcFv{9EGS+6Bl #ּTWZJ4t1o"b!bTR[Vѩ'fAg@h$P퐒ĐA?B0?McTUk?%Vi$?NP3^%%>OIR :hZfU|Jv 5=ۥ2##BJLwkNN{%Rs6O؎g]M~_Qq߇R4Es:hIlM{4i9#8_S-]˲n-p+>R}\ݳl[A4v,x^)=}NA 4F ^bĭ!f;rC9kMxJ22,KrGN_N|":hYd#H6y-.:cuu:iܖ44 k!>[.z@za^Ry7bR>Ȭ(#1Ny_^b:Sm\xM(%6(3cFC[qw/Q\kͿ8xVmi[7-W{8FأK ^W'tZv0< Tdkkƾ).E/kX#eF#*XG^sQtxkk'do[sQܖY[}srM+쑟?{%-0RH=ngۧuLNޖWkO nWz1io˧u1 %ÌZ0rIwn_SgiUj-v쯧[#ds&. K5'9vctj`8i$OOS9G+Qa%U5{;;]/>(e56;M3II|̨%ߎbe|6d]tZ~:8)CGz7]tZ~ן O^&_%Sp*ysǸ{|^:hǖ+S|*tO6{ Vl%|g󯑭NdϝTy*'g}lu{pcڹS$yߊq8ϳjFm4I2#DC(\2sڼlEKղѿ'JU9\5L\_ʭ#וJT\crqzgVQ78NN9cQ"u#_"'.6{v<.V3;)ڵ]5**rSΗwā e̡%s58B⣦$[l +z^l{ZWtk4/k|hPI\gcm#jay&믈ӣnx :dU,ڻ)N]oe%Eυ^*_Fp63}B*Ӽ#Y۩zծ42c_pN Wt7>!)5gw{|n~d8o^޿5TZIJ1W<|=IhT3+߰=GQm4wW> XTwj|qwP ?'#܄ c}=,7}[b+:4U{EzmDi0}zs^cj:L=2QrzWIO1p,&Gl5L} ө^{=гs-֡ow4)_F nJg=0N:u{k_Ջ-{$O^]SՉs+ɠ4'D ~98|dԧN ՍZ [ )N.=w1ϭ}xpkiֺt=ЍV읽uojyϐ 8يqӯ'+S*ʴ6:4k+ۧ=g+i-u+HjBd?3>ku44sԗ[| "[;-^)f?f*=rs|~iR?Xn2zז:Rѿmϛk/>xb[噱#Y۳cr88xOP 段w{2ѣz\zeo3 KW> \ZG#gsj 7dc-?1:z\>_(W 4p2:lWMCB6ö2q`0HSMV*u,,W7: Aimz;u_25ܩ͌s~^1.*=5#)b;mow [_i{%ydc"ylX㞧o;vJJZt]ǟ|p0ڭ4s:۰2xt5G{<۶<ԮLգYGTgSob)[~b**N4|qw`idZBI<6;1U=P~篙瘌TIV] OѴ6>dbNe*7)hS~0Xeú0^H̀Dq{]2F8m7>%ݖ|M)tq|q W~Z_RrZxzs d cې{+ЩR5ʕݑ[NW}5K~?WVkվR, w zX5qoK}K* #/iW6:Vw -ϛ }XgX<:3J4[kO&.闰i΅,dVWlmA8ݕccQ֧iI3[S춷S֛${GeKl]AYӾʍ<]dV_9^5HSj]xKG}Uo0\* <=\80zqӕ>ZrQW9O1x|y~Vb-:j6ʣ%+)jλKmc}oo b ߻ܤ>TwoA\|$u+Ʀ 3a1#WJ5wMU7e9~M^ n^ZUФ:sxY07H2S:9&%.U}-Hmnx.QXR*m1Awg0kЧ:q(zxb)s ܥii6Ƿ}M?g5[}4Hr^ܦ|(X7N#棒My4*u[>EP2,_}P_Gϵo?z3{oܺ˞IetT[r]Ĝn6szr+8Ԕ})|onYxʮ9'T1ޖ gha!f9=֪?,eF&<뮅čuw.žb[^׵f.VuJRMZWyuI u`3׸pER\/s0RV7Ptrl V7nkкèZN+ݹG:z׷jA5VeWL4 Pyumϓ_O?QJMLe-{L'CDN1Q7{g<ϕڟ3סO/T,qRrp# xϥc'wu$筵i6Wѕ\yt3Tep2J ӽ+{| #.`8j~HqiFϧ7ݲy g݇JA)7^|$>Bc};ғ|[TM!6c=;sӒid2UaW .ޭ p/ѱC+IFy֪1{ɓ(Ij7;hdmڹ9FzqJ59l#Pq&hUgFKvbt̯̑o&8̸'yOҡٶtr^ƾ7BIwmMٛ޲jn/JQkERHyrUay8ⳕK;k}W@^_ 98O<\Tzp'Msse}2HX4gU~tb5x)F0J:[Y#hU0\*8WNiٵ2tmn~I *؞I#:WwU.Ӕ^_éy9Bv8ׯC}=O{ٽMKUo1ka=yДy<.XXԼádYJam<xPj)өNOKS2KȢCq_%WVE'q8ӷD"S^9Q6n$jڌϏΦ:rv_P[,:VH S C`(Jƿ6]C$q3A^TyBEٙԕNh>LNanǘcmI0sJǖmµ9FM{>^SLVe5hAȮXB6KZNjo㛻͡FZ6h[ yq5MoM i7nSZ=͞;_:G^⼹J5gȷ2Z%i-}aQ~3צ;V_X\]4 (QK|3qWF)TyCl/kۧWěvjQG c/Eh@ 7t֢oGr4֯b6.YҊvԴYsG@'+{{/MNhь[eujZ]D TStӗaYrZ4-f ܴ{%QTTTɥ-ܷ,FMۆݬt~j 4AZ6Gڱ6(ʠU9;^ҥz_ӯol{~ѧ}dʞ Slϡx[]]YxHٷ)29#J\٧~G8-oI8"6#]T_9rqJ;X봽N9CIL:` O^_MJ[i_4۴dsdR$ӭs¥9TN:/&u6vY;2Pw?xQ~G/6"~O[= p3qycߎOv648nk5Ǘx_WoUߺͨi},Zէ6Uro~r8!J1.V";$Q- םRNP3iZ{㧚0JʪDjT©iKə1BY#Anvd'Njo]{U,g$ࢾ8Rdlpf1#,qJ4ʇ$|ݎ:<5ITORRSJC+%) Ns;v ;ͭj0`\%x֕=;anvYW3Ilwueƛ<*WNTo=偧+c:t5TVisͷWֺ*V˓4ͨ rm(ו5/COhVɧI#G ߇Ju[rU*qn3DiW&8ݻRwOR(RԷe>ޝ:Vu*ԅtXK Zum 'e;#;R7,L}Fll]vvIS3jգ~[wCozʥJrvg'>+.3nƈU)8lPT.T*֏g]ITw-J3a[~jis򳢤9((ِDW}>ZI7Ou\Oq]~RzU'qJŶ!SXʚƤm">ܳm=9FTe*vGZn{JӖQ̓`S:D 2FC%I&4]17iu#R/#E۫EpԧYc17:n ,O2cyIjIJ*7΃_Rz_b Dm=xgFQN[DWnv=vӍiKY-)?}- yQNX ^A;~uW ׿E槍MZN?vLkx!B8898zWUǕB+VS.N-9{im,Q>h^O4M.?ֹ',yImۡ%mc$8Hl3a9 lh#wtVS Ym8d$M4heVHQة9Q_驭t*[^^[KRG4X.dp3 E(-NNNZ\h& HՃvcQS^G+_"yV)پVX,8=?0G[JJ;ugJjb=՝2FK'71'9±9ԓ}40OGnȥR .ݸڱsө4b~VyJeQ;[-̒+'E7p}{W"I[zz\UhOSи`۹pzUIgLeJ-Gwש$2M+8ڄq۶k=UGzZ.]i@.cC2Fd sՔo+BWko~ǕJy?+*RZӞ^/nڍju;J[! G~nq^Ge(׬חȩNRN0Vw}m{O1YӍ3>b,=?iVa(F ru$)3;> ''NNk-R8ݿ$@8$۬:GǵgJ֎ngKdҼH#Yikk'JJF{eB!̠&ržQ{$vHSDxЅ'ߞw9%+(o'j 2I#EZF=t{:|KT_ kf-+;HBl uZQ4o(WoЂLwn>qoU$\s49IH<#.s9]0.yVtyQ~d&0"=F<G>κܩ,D#7t?gsJkMR3\RS3KG&H֌u}ṑoa몧R6 8fn`!Y:=p[߯Kw<Ӫrܒ9]\tG\)FII=_OЈEoq8h=k) K{ZFҌ]RII:ktNV3aPs mN1u{F112*&7OlFmeFxŭnm.XZ Um '+ӷqڴos*{WPo\O)&Z&;"$~ tccl=j21dFVf9ןֲ6VW*|C"KJw(#uZM3 sMsuRU#Y0GڪeZwАC$r(b# rsFU+Z\]^L#Hw9v8ƚWf0uru&K%1ƫh#-}?:r:9i)'{h/%gs9Z{3VGYF:1;NqU?mOޣw7*eA7o}8FUi'Qи\F~R}*w*)\Zy]BӅ]eʃG]+"!ڔF)< }7z%V FIK+9EUu*"ʓNrRbXm&5n)#w?jҋQDVIEEe )~=}jjBq̝@{@ LϷy:Q(MaKj|ֲ*Ct EO"3m{s\|vRHrʶVV9z\°q9^ƜSI\Dצ0yi(Ԍy$A \Mr=9>3RsE~^bxHg*4nӎq\)Wc^RžF$l;QW,*wЈJN_fVӡcBUb>3\qnÜaJPMTP&1M|ߟlFi2[) j痳zz%R1NQ6e+ke_ۻ;tkIIH*24qvGnelXF܀gu#G:WK^DOT0x?J¥Ka]'VT͟@z#_c ^)Z#^/0AF'4M3o7n$<ͱw3O^BI^1۱eg}u/YBxYUqmтrUZ)QI1R'&L +f'j^ji/J2bUq-G/ɱipA޴nEzTZt$CnN 8u%?1F_J:Gߴr[!(.oV,c'i[܊+^1pmSՑKj^uV"O.j;k4im`K՘μ#ԏץB%[v;Gv1FHD 1QI;>Ҿ8)-NzϺm]wNz}x^KW41ݟ'vۗo?xaҤε*-lWׯʟ7QQIfUTnyY2I:q^*ӝ;:P0y(ln÷!p wاQzKu>iUvJo.X9j~b֊L=5j/s:+FvJ ")3Mm;B.x#QR2ЈU&&g2VE#<.i*.p,}*[3N#blqsj%WK1TьڔdhYQ*|q$Cr{ҳu>_>KGnKg-nوh_ hkV4;J˵pTX9iYo$FT(]H'OAۊKQZ9*)io B$lo#u 1~F6niJڥ(*![,hF%e;r:w5,¼9'{lUX 8x>ڊnC'S{o\3>k8Ռ2iVg(R]y! X#FFB9ֱM_K|qVIRVC%~gogDf/?*㔥<ڞҥ큀*~]#J"ަשʤo[>3K1M0o{:)K[֕J)Y=Zdo%X ʹg&=IiaTCXZD82'cӶiJu$+U=5[8\*[BxO*A)Ӌr0>ϝ~eytdF9 T=֧TvWk%libx3ޟ4y7MLkYim6ȮIFƔђSNH FG$tCwV#FRɧѐnLJѶ:11ҹiߙuyhqvk O&;vpT8GNJʔRL^;lih[ZlG3 q 8<:qڲjFMۡ2^qJk[C&B (8Ud(PWpV2I֝kG_׳ukP~^*}˨)XV:\os,(ʍ`ryccnIfgFEI#۽ŴdOqee)qH׿xq-IQ>HI_R7i-ZCT.( sTJqq^7HXXcC`/s{TJU'R/ؾ ,qmPxvMm0KQ+9ma4Hoy%hcZjQmѧF#H,k#מ.f#Er$;K[uUxOs{u\#y{"|w4"YAϻ=~R EEv2w񴏘g+㵒{G̵Dq /g $4N}@=xǧZ9]r}*i脎-w*_oќҨF2ٴi:J`ڵ8Biʟ3Fh$RKO91UN9DOk"r~f°gqF?i/i(sES%m-Z.!uoN{:ҵkʔ-gvkk#]b/;W=VJ r6wqf8 ʜjL'qNc(.S`ymwu15!7ׄ,SY$ȕzwGI9$}&[QEzS4[͎ϖ\־0OKs|]I2X`8rfAOXU,kzK6fhF_> SӭKv_'th?- wȥ3w`}?3:u%ytu`N՞ZIåjZW~ZoL0sgI4*vZ-3~|^4}ג̬k0י֣?wG[ 8q롫x1D2Bx~Ğs]cΟS:mzY(nZO1V߭%knQS6תm'k $<.jz:Sb<8n% p͒u1?WNއ^ћUD 2qn{絫{Is4ç/vkEФ]O y $'О':4bܬT:1n2E-V;Zծ侐tc\ecPǞ+˭R%~ӍiEl>0}MVR&$6:1^NgRROK릛mRm6"K$ݱHcw71;g⹣Ri~5'+vdw4o:~u4˥Ar;N@oʨ:0ߧ[ K9ԒWzkOOtOxš] "/`򃑁ۏSQ*.#eGWnWw1f<].O2Au"K2NAQAH8>5*ZjzoaZ]k[GeC—>EuApHe\##8}IxZt윴CG0nR˰g"VZ!BHVlgGҺ=9Sqԧi'mQ\@+nQZbvn^}yZt&sNu6y欙o906N e$a_2OK;;yI>k]Fk m97xhMΪ1)Z]:Z]hj֭ KI"L"y9wq1ҵU5g?PuT>YC E.$fhlvC)f TMmܩa𲣬:#i~),q%<%'9zo{k_TU:1u6M%ϷsO m)5H";[`N |E)ZW_֦xqv<cLyL;ی|Ҏ{~Tmt[M,޲G$gv<^hFҧRvνe\df̛F?z1^"IY-iF馿yoT6F9>\SOEig}Ky 7em,dyTEV: 8ڵHT!MJQ~O&xY:uROT.\]kqOj秘֣'d:uFIVkKuТ}Ի۟s]14%dm/cuR.tI4R<i:q*_"ZbS+䴘 =r9OR cb)k[;];vS4m;fT'uZvFK+;uF>QjM:1nVHe w8gnׇ4ZI/Nk{rhkz㭈LGqG{ ҡX֞4. XZq2.琂>f}zeyJzxī}4!aݽN>&J5gn>:x:qivzz6E؊(^-QNt]F;y m3Ta%NvaIEhmV&^:ݳxKꮂVX>M{Wu$/3#gzC:q&>QߐkkM)<#׽qP.^Ҭ ,r霷ZQQT?|,ǽmR,Obܩ՗,/g*܋nQHg>:ut;V4ܩ^σcԮT$rI, )ǩ ](3[5S#KkFwz5&*n~1b8T5{nV'!*5>V$:ײIm|KϜW}J~ƚ'Ъ'Czu{{hg^ 0EFw:ֽ~wb35˪ݟu9}Tk]杩љoy-VZB*J*]~< {&SyeD™pIapz y*\×R^N_ӭOk&`~G<YieS-kk!F&{,ֲFMѲUPsAWJ=]릚`wױ^n'HmBT5kCI,H-62˚){K?(bS~>Wn_z%0Iu"$ \0pLZmt7ƴh>h$=Wx.M?XXaW8%xz9{W*'*;7ArhAlnʯ'׹ӭ̕ݿe۫6&iloB;r$V纰=F=^IM7[|VSy> }xGpUZ*"qor3$d0QZڍ)9w5۱%Y?u0UR[PQr_YWr9hUN/]Cb&ֲH<*qf\89'dLUwWmӕK/F۵bt̵.5J&ZJhm/RH<~^{VV9al䜙jXif=H_$\;cin\ךg$C[O \wgGNJN뮞FTefo37 `סSUK+t{8+ku;wckym#g- Fq^Ÿ,j= *롽s/ڣ Ͷ|>5U'UOdzYv"Q:5H<َuݔs^92?ÏC*SJOWtakSR5!][m^kim g΍19p=+1TIoo_sfq}z]w֓mL*")c|ͻ&~mʝ;J-۱x-&I#1yzuRkU'{!T޸U8--$c=HQ|gzDc)FtM-+Uvs>Oj2 NMd_:Ij%vC?&ma-!}ц_2=noZt|U8G_̲dU y#zwj_QQ~%a˝#8՜*JZʩ8ʣm}mرan:)s)}EG̖`NN?qm!|ͬNӞ8|خXkuUO^w mS#T}Ҹs{8hrlQd}uL,t],Jѯ az'-NWֽͭ"Wp}.<;KW>7%$F~X9].o݅*ѻLŶ3Ѯ)-vȮrrS}t5-uňdjtJR|]o*K*YTMʧsr{HZgEIF%ӡX&\\e%^O:J+oki" [?Ã߱Vi߼nvUb;^CWY2vys^mI˕6%FKwcxZI<ƣYXeFy9ǧ9UIu;p6\f`xSbbPz('=*9mZw3|Ez u[/FhņYb}ҽTj:I[˚5V=+:~Y/WKw;c=F4}וA97c(qcN*iSGSe-:zuŬw52Fȏ_|bn#;t=p=d)G&綟p*"&粷跋om<|Fm%~G8gG*曺ӗ;˫꧖g~KM;g/ZP:۞ּhsӭ(ݽ?'{b)֟:voUף?ײj:4¡VO3ǟNظF(5=|u*2ӝ 5ܾzIs7BB\$%0}1$;0y5`R6]z^? [muKiJm6'w&?ƿ2 TqNsNhufjk,x%c^*4RM J复JG<⒜2jJyc d$ފA3#(ybzZQR]Fdr7nJũw83uHwUi#9?Nk7;~c:4k}ȑ2y`UeXgvUUƣOMby<I.|ĞjSױ G2QjUc[܌J uRRQPhD^SCW+yRvw1|",oЙ܅ʳ0xZ1^/=L%*MBs4b9 7'GNTGZjk[yVv4{  gp +[eO /BH?chc=OLqQJݭ,Kɷ Ŵn9ÙKsj"'E#UҕV;:|߉a&I#~ѷsn.qu{X$c!.v5+O|pM:pi3UjVlFYV_1N=ӧo;[aqN(XQ]4|wgӟ|2%mNѩQE[N!1G[o_zi5 b%U+m7'wv]JK6wWya@#8R:Mԋ}QN SNM1nZ:w}^p+*:c miKTUH<VԹbn߈Qܥ+\R x01u*J8NY-[Z;|2n zcڶ{C,EG:'ic !l“\ϚjRB cKʽp7z9*R^5S>Uk{.vf`p6G\sRںMKӯko8Gt|:ָ%( jˑ=ݭ ϺD ǥgM~Ze%eOCOO 0}Wfrr#V/Ng {ѵ7̨@>jTGOy% |Ö'\ Ϫi'FK%]yOO*>hʌǚ+}h2ǐ{j!.֕N{|&4hÑ p8>Rlef(2Q_R@tYX1۞p֏K.e̥_q~gɆemgeS_ԏ9XzU#}B˗eeO~IMg^Gs~FT^k*}(Q냵"_3SZ*/NOm-{N~UPW9b*̖WN>]VETQTVfm+Fmr:We;Ӵ0)MwEj6ƻ-sԪKSe h[xV1Ҷ)s3:~5eT63I l:Z&w"aqJ4Kjͪ[JzpJ^Ӈ:mN9RIvvȬݢ2K>_|f s~XYQ*N a5Q3zD9>ՊHU4] I4H]n@wcW]ZqzlsԨkeXͦ_'ܕՇOʷZ4tBSNCl vc)ԩ8lW5irܹokI9!9>=/֨=R[;F_թ$sq? JRvoqz,w)Ttds<.U]NWkKtmuzuY/UH;+N^[kjRO+]CVWw~{czZi:n1iJ33Lk2De #c__yIݷV22iϡzQئ㝨5kG6xt/@}J#]0ɯ Qd܉>/Zq4E՘X ^*+ȵoqcBy[~YzOh"TT[u\uhU2n'sxڳ~kE+:{_'3m%]۷~?Zֲ#yS)V$Umfl1?1gX<)ԨaFo-z[__ wgu'۟mVs*ru6Ǡ6q9 8ӵg]6n} ]D4l3I$ƹHņH!!_f~Gw>kGcd[[|4[UBC5=g@~e"dҬER|!=J`، JPj֦9'_.xᗉu|bֺQ*L$'z,U:vZЊKn饼swjtjYR p>03zJkR_̃φ:l:{˅ ;IBTĞ[$dù4$u zo?|%aq%?L\d}ۻAt\)=:)ɩ-i?QУl+ 1`8#<8se(EStZuzόm=FDgT807 dN[ ʶ>*+ўr<3q6쫹<ǩ*Rt%*ɸbK]7@|rҘTI;@ RS=V}N9hrӒZ'?mԼ)kyRM SiUބ) #ae/SwZZ['+ku5(Nqf*m:N4v$veTӭ]KnM6vs18}/;JM8J7&_jkha[Y##`YҾN Yd5~mV}-iTE4k/O1;g?)<}Gz/Zb%RP\z}a˨#?n|olDAjI%yi7U8 ] \v8>5%w1ˇ9YB>e9Vyֈ <ERIfFO$ }PN'6ͬj#i|<8$}9yJXZutݜ&;008ǒO*?CVVLwC FבTrF:!S+J*z~})2[7=>nO5߅ʜmkbjOY?ykm۬9rol<ҽZxzY?+Gs+lwFꭳM5=-0ZU&s1חw#+{[Gi%Vu(:`WUnqPVE75RK5E" 7`E'hWEOo7OS9=ϊ? n55nZO%I̙%106~tVB6OM4V}s*z.6i'Ѿ[x|5wٴR3(Y@DN0uKwQ׷Gw9uR^}vsg3 ۲FMǘR^>W#FNLye*JSjZ[_?T9kOZu'%9~kq(+q:P~6x-Ŧ3nߦske^Y9ۭk}34S+LeVrNqNM|F2GRc1 ]-]ցcU]w8p3O¼z1rzMu9dgެ-I#f$'9?Ҽezvr/&~*oB6jLd2:_oOH|e"+TkNKᆋ_YJCd+0N_x8µUIRUV'dmINOvэLV#<1 ]d 2o~xc ;$Ta+S[|fmwnl=zVuݡfv`q SgVZMAy6oe-(qSQ^t.ehROH~,xŏŠ@syM;pʸۏ|^8FJwou>eGN3mFM[z 5b|WV-2'69Ϩʲfֿ >kɧ0{)#H~T,˷E}>T R88sOª//;Gq}f[wL29J!9=,ςu~X\~RX+ {DNVW8xԄ$gi>׮%M>3]+0 rzH֡U֧,4qUZ6_#?S+41XC@sqX{IF]B8ZXi/i+.s_f{H!1*F'>WׯcHS2Eס 4໦PDd);OeIucOg}[^qU"w"Vm[O0͹Ye22GN+>I8zѢ5W۱uyc{yf~#FJ0+Tu8(+4ቧZ4(Gmn3yau(ېெMR$\ vI2pb}(Fi=}uS"eyvz|^)l0~*-O#h 88|~9Wcg?JynZ爊G#_|7H&5n,,|ż)āvY8{W`Ӗ-fߣG,aN6VWWVYw)c9'#Nk7%;M[/YCuΏe~TRHN<+u1w.)*ER~? }NI$G3c$=:qTuBjy{KB7ٿv 75*e .X`n'*#?VpucVtOv2,l.dsTI\xӬQp3ӣVm:tI];~&cN#=|8fiWZڥxQjGVos~=-NkYU-rsc=k`Сy-}O.JN-4UIqyhYJ8~?g'ec8x7ktԀ34[UM}>$DiԬ3^E+v%Gϝi@nOI#+om(O'mV];^R1hQ89tTd57N7KORq 6]I;x$㓎;UNZ1Tа*8Lf8ٹesӌߵ)F Jw=4mW{>C)Ӽyx҃^x%w=TEJU+6h2C!X/8ӌdөVvNch,eea*7] *n]w ̒YD6ͻ (H;7hXc3dc(EɭSE>[%xq f$3Nq|S85(YO*P# "jGG˖w` mQX+ GsT{I]MzT\}I \yKs$$[ @ V'dp`IIMdn9U<HNxuWݩvVPӲ~fL]0NOgwN3Z˛CΞ*Tj(f]0dVYc~UǖI>#hY\36X}S厝)1nȗ̅V6Vf=u g?roӨWੵ[Cy;q<9-$eBOYs_5ਅ;\ؒ;gAԟ֥bh*'g;L̚ϫb}wḴoqrIK"K.Z8Õ0'N-@(cfx,c\' do1Bz^Kju,> (99w淧~nb#Zڊ,C UQ>6onӨJz ۫򜌒fJ;)܏)FP2ܟ_L~Se'\99VFeW]jRe&bA,1nePJKOq>F$Gԏbj{1ҭR7,a'@26];VzSpE4O~XWJZ4j)I"-$KR8R1^ܑMeQ&DJ$ucLqWͳ7˖̳!k9cs늮WjRܒ7xXcԃǽTdL+mq/#n|rr;qۓV1ȹFQ*8NƧt:"RdFMjiU~t|[;`}0=9/wN=z[pN׎1̫T e`d# x?>R^V59Uߩ9D2`ӿ9yԴ*=Nsmi$^H,Kts/zlghJZݵ\ +ʣN!JfH AU<펽}K[SyYbkV qYOE`ߎGNW1n|aeIhxs{rN ܧ[f pZ4o6vr9FZ+Xcn}cGn԰T[IVhYV.bL288\ ~.>KIi۱8XV TcYֺRm-oj̞dC5EaXꎘ:u!RR~gRkӻԧ% v H +|ˑL)Vi^V_ü \e|:2r:|[:jRqR ߼_1PFWk@(Ԕ~-tyńyj&@?*+|F/:._Xyc#C֎?,F9MrZoMX7i7Wk 1 U`$4lڽJqјZSF ^\p]#0TqzNhݽgOZ~|љ]"m|:ӳ;0)+~'+uy$̞^0yu=Jֶi+^;#(nqq<\qeNKTVO1[\ʗg^Shyʬt@q_\#ݷrQ,L݋>h+2֡gjy\w~9w{۽b)ƅV:d)#ߌ5T$4|zƎ4VYbp8#uEyGG\dfc崲mgapOq{l*IN3:?Y\+BaU\+,l7֜떺sԣR1IpAg $_l'~= e)Sj^Z8y}evZ =^Nߛ[j}8#F6k:mOikUnPgRN*s#O EEEfᶊa397, G}+XS:Qn]~k V;i i pB3X2W79RSOQVH>F,xrN9>V8﫲E,H[9KɷTƵ7f }u̮Ude$n#S(|=7(֣-{5+"2#9-:u%R{z?Uh'29Kik#1䬎\yc2GzV[__ȈqEs]hwp BKoG=H=J}VFV8mQ7>ҟaEbJGns]Y*w\ʢ{.K s?}x*tpn3ukCʍC"USy8˫]|i-Cs,m9 kZ:]h~g֥QkϩYZR\¹w0\W(Tኔ^xX3q$ocjyB;m=~(v<)=+h9[={u*rޟZ*JuorQQWQe94+0e1"{{g9E[O4eZ-;eVkQ汬ʔ]"4C>GeVwVUkTZ94۵W;R/fV5%̶N{Q"̋;zяt?j}wodg#*zb˖Ƒ02t׽w%7~�tƭ_SS;hwI1YzM/4/_3!-)5bVpƼF L4h]{zD׿cޱ--8G5Lt3ʳ3썟͒Oq8/>,UJ K7GUX@Yh}܌98OZ1isRJqJn%yΙk$۹}rAshT-&UZћQ74(ljF<`t#XߌםZNuzĺ>٪ZPE%Kzrz\+[I;;?Rܳ[Ρ6+*ɷ '*ǖ1W"U&9rfI5n eJEF>R^]jJ̪b_'9+i}F[fff4llb#Zehf;Z 7HȊǸxu=d^15O >HIp6Ӝeޱ`^Qrtثtǃ"F,QbH{ֈ|s'ױ͉q4]I=m[wMF6:}zT'mlstGwh_-JmG 7v#'ܜEwCFۆ{hlC A汝J**W8aeU얉>`iVBUYSNؑqJJiri+BbHP?a0 GJʛ撔t9b-Nx׀O VRI1զ=~ZԢTOTR++YKyNG}is{xkTKB&U\1Wc#aX}u<j _xڄQ<6;FN9ZJyG-=z*RM42 U=r==selTq5-մ&2K2OyA3g$rȯJ*N+'%]v+\GOs2J)7ƒIhb8ⵁdo3gH<1]wwq:1ɪ}zwW-<ǽ<='=k?fVzA>QJVeE÷}=ZXiYŭN24һ2'}Lʫ#X:UZ1iF:iEnEeZ6ЩK~WEyndOHU.; vF)XTf$i{?͵V^)מIGwZ9aAs oo UGN3@ZB-]?ga omHsb\ܾr0_0OvP{~XzQN>C)_KЩ=u&U[fV,rN*1+qZ SۉܠɎ:<ڴLJv+"309瞼]bGHN}ƫ$\y9b㑸} in[(&i'4{vZHVj7 ܮ;b[z9Cgo"=տ|~ g*֎ϯS4\ku{q^eC! H+C/%rstFh!B]eɏi5}c5qz*o} L /rXΒ|<݅IE,Z!r USq&>R!w G$+!AR3;y*nGk*q$ލm7˂idGv&ڂIa؛NzgiN5kI7A,Z^+Ny8ZlpzRZdȊs$8U`0 gL8ƕ9)E$JEN1 *߳1|=܉!,+qm9ln0u]*c[2E7'{!tb&H1Sl\,ݻ۱XI@݂ÜqⱩOrN +IYtdmr'rk7*g*J˲ІIn a]8=μDhd VdHC$9֊eg9Q }6wrW8wrgNi ȳ]2g'cp'gWW}QhF\2H-L=TTJP|xsIn\)pg$YdmI-Y{/g/4crK*4p7~OrgRǚt>8,CӴG)CO)sufys?Aβb Q0vHnϧzQ2RAW/F#4*)BAG6%R-e0y) FBUA=xkNlұԕIW]J5 a!v*aO׽:JKlu=8ݭZ,"uɏ$shrQ¨n{2 6mZ峜sauJF? ֗D&?!p3{޳GV2rW]dT7Ӟ޵Qnhu{jL gA/|,~najKƫXǻб{jvB|Ӄ+pezT&^ݼޡGj@?=9Ov4[]ۼk0de8zWON^gF\˦2OK![*ϯ\^Ni#/-.ŋ<%ߜn=JMi2N+5M ݨ M6{F#<}#o/d2N. mU>L6ۂ^j!gsSN1oKZY6'\6sn{sӧ'[#,LT}.f 6:"wK<k$։Ӓԭ%d `Ǹ϶Jb$joBוOr bR4SoyҹZFuE6g0I$(~|8S'mKkBնefq:ZG'y4GJ'"$@v;=AJiO3*ʦk[yVI<.$-*5\UOSOi'(Fƅs<̱Y36}VNQqVRKDY1,#OO\qZZoneY~_A4Vda.ngdU]c?zўHe*Z/ZȨQ+GJZv:֭$Z̯bB:z?}]Hԍ1%R5ȁ,ڭ^YXQy<`sR]/B)FvЌ$JzIJ\تҔZ$Il[[E[X\qyFr|ۮ"餕gɣUtqn>;FNrTpdqi7W0HɑT̀;duQҋ2J\T[ t..<"y1dlv2yi*7MqUow2J-8zQ K9k#ӄqXA4^oٛs?#) zF<*JRU="6 JbeFlHcuY´\BdVWW-,I*[2{Vu"vGULE:69I#F+ָo+#8rQpYhAa~TU/$LBR,%܇s+|dz?*)IBSI{:Nrױi.,ѯ2Inb*sIEhRoꍋ=2KekLjQ:bZ#ErBֳxF`cv/=\JR6oՋHg̸q! 78<Oҳ&U*wwld'Iڌns#ֵTdfti: @$[6,77׿cfiN2VK۲C&?^ƚQM&U[K[tʂf@BNZSqЫpȳ\9z{5k#єjWk l2}O5S乕rJYq.X 2:5хD{7x|Bb_.\ '+s7)QchmHX =8Q5SΜeZifiһn3yl$t|W#[~FUS٤*n#ptW,}}$zu\ѓCk:*۳_^+ˮɽ:V|v L'z^= p{?$(B̷f 26,rrYA?i~2wػg1HU]qy\yzJjsԖYH@[˂q9WO2Ss6Lc(OHf5E{~(ִiy4ЖU%>^5IJ5슣*:_ū|3u/QVR %P`A:aR+)rmZNeG N*Dҍ~<>x]o{ho,h4ۂV`2.N26!xG0ե췷GV캮>gaq-(IX?}G8뎝*UgM>t>/ Z-HRxx^Zrw bPJ3[k~gIǫۙ,O Oʜ0r>a]wZQ1t*zz$Au4E|F$eV=#AFrUP[6ܙe(Ut3ů^C]7QX瑜tҟ7,=JKUk: /ŗu2Tn^1#^k8INQVK+ .}villX׌H*z) ^8<,jVu=|$kb4u,/ M?1#t#N1]ըrwku:148zvemNSc&?i֥B}zlJTVsV!kX.?=nom%t}1z6kZY (fy:9QRv3Gqt7t8Ҹq50oM'1F4f\o%Wǃ\4ӳaQnA6;rcīU+mEe+A]/xyl翎k0ݻkέ-ONuط;+mFaUW?{\&s81z:l't1EmS cu#cVJudޞGU$T;=ἂK_ݿ1u}Ef Zg4V;VºNNG 'ZmXk\-;FsS*iֺÎRXmmvdڹѩJ4zo#KK1zr7dxUSR]ɖ+=4]tA~cs2>v`sɨ9RZ[JմwKϹ뺖[Ѫq5cpiÃTYIw%H{޹1*tz|?=KI.}ukkIWR<ۖS8FyqWnxyaӽݽ~G;/n.$4QC}ߛzVxʊJvoF'bܪ=뎵Hb)[rɩG륎oP䡐Em ׋8}Y/~8>ҫR~jjrٕ Dx*iN4R{4y/Y9>:dQ̎ @DR2Ⱬe95̓$FVv6De)Z稹MҴG8dfb;P8NuMTwo; ¶DҲFֵQ q{cɾ[Y_-RHۂ@*p~.Hy)rũ|.1Zw${6][E.n߼kH~N 'n8{UK+%F6_[[S8]([jc<~N7th+CCDEp.s]q#[ȥZicq#q6aʜ}ZJCε/3>T*_A[<sԬ`OμڔcRn[Tc*Wi͞ȁbHs675T4qƕNT?{IܕPM~ӊJM,^>9O3bf[j9VvRu ̪R7*{ܣiGNg4{NX3AveSb8ʧ3eXzUZ=kg+ .=gH#1]1Fmw%hm-15hU^:˵TwwM:ћximxFVXIiݐPǩzZҲ]].F6Szm}ӕ 䎞n^#5o3߉g&?.6aXVa쬺=:~fszuz'O6cbѵҕelu_)fUpqW:\M&ֿ fɚ&*norOLpqq >aQEx(ԗ̬z-/^$w)3#9ګ'qztjS-Xѓ{uګ>3$r4p\neO-T >PJR28^>)}[n*Z1;{ |9pHԶŻ]q=+yEJݴ6έ\4%ܻ3^J|y䓷NINHm!X;Vw8{Kz6R)w. g)9Rn&bIJl8(Ng4 %rJѧ˚ ޺Z oko4tynUZ,p޶".*U#[2٨ݩN45$Y pV_j5:!Oi-.ViQ^~ҝGJeN1KEn,\Kmpc,K*^hFuIS*k_g~muMkG !*2`:9m5q贊Z_9ed9;yKEʯ}zG~OڃB-|WkzMl%[FYAP8݌sʂ,?s*RU%RI_{}x%Zh^VJ-Ǟk\WIgo$J_)9lʐ9#c5ʤkr?zU[RbRi;=SiKu\i$1aTy>N+:($n﮾F8ugv=-4V#?$s#)f~Se8E/EJdH^v*Io>nھN擕MW1&ckU8ؒZQ!9lrI6Ŏx O^x 8_;Yv꧇*%/[|A~n%K"¡do3JrZ_֡o7\܃y/,5  DLҶ6P~bN ǷN h)ӌ^"{] v9r+ڎ^wz[c׆rr;-zt<_Aj[LbpI½X.g}FSju_]ٗy47vb$s$_=J֜^룻m͞Qtݴ%lE[,z}2= eNV7g[hvgӭJwOk～{9jsiosmu$Ю@:1 :J&zuI>'ۯejѣZSݔ[vɾNH P6H;Z2uNvGN[)j=mg_]+n/R>wZWPya[eX6wI1U#EƜRvukio~ʤajSm ,XEjЖn` 1QSZTZSkO4w^z,Ϲddϵqb*.XhgFռ/ioi$LHxagӑ^-h5wfgTrc[St'ԵoVQGb>c̰sޕ4+\{YZFFJuEsSXmLjjn8fe+<6;*>ڏ+Zv|FÞ5̍o{p!ڜ86yCy>g`MhF+eu*blCּiN1oÈVdz"a$p,[{"kTS NRԒWo5equ8U9<ť-;uEkbo\^K:h)a֖Ek`ψ@ݷj~8sPYJ3KӧX|wUzfhIJ0ī$RܬB"T^F/{Eа54X۶)1z/SԿ*).IcSr[ISPhzef;G 랃=8SGTI*|^o0O=CIOqYqׯBJ2Z-N\*Nt܎{pݍ.f Eǩ*s]H B~玸VZqlg~n== #8޵nWَGHR&@ZE=´#h0>JOI85хn1נ讝a;f˜mqWz okBh֎}][4d-${r=5Q(Z芊}/"d%KG۹рyvsQ<,L>7d_d9.KH}O^9_^ҏ`Fr׮ҝۥ}πbFNJjQwut&g@eFRw+SwuUO$2Qs+VM?JQdgR- |s1s4ԕK5*QbYd^Wm>՜cS_yQTB Mǟ$ls/ʹs2kYI-_Vh:.t^Vhw%y#:qviJT$gMקS:T?b̲&YwmcO=HY%'fMNjr߭Ud)r<={tRc(jiDky#feY^38sD.f5%mؖAKi=9n+QdΚRe;ʫj$ G뢍8DׯcέHrIyq\o*a }^?yFRse{VB쑲@]wStBi֌mO}¹Sql(*feOymVʧ/Kk~>eW2~Z\L󬏐}}9<{\cE+lnB-A믩^4D򼵌+/hϥ_~W+.Yt9kTՖfV1*GdMpn1ٜ_b{bF4M+LUJ.Lgo盛7V,IgA*18ݎޟJϖ.6{Gg/>yt#;U:dӕz2|BMh.cVUc'3=*n+[5!)>2ڴqkcʃgTFIZˮC 1I^^6`zzW)UycR-6WaKS?VWݚ۪ϽӭP%Vg+Ɵ*1^]J%|UJ4eN1CrCa6ܹ NrL_kUlRR̍]yjQYU0QIEyo#.o;1m)munffF%}Tiӳm[ !ug%+ci+0d,wzt(8qjyD^ɉOkJu%-i{g M>O*#r3_cVXIk*qi[C%[pU|k%F:|[ KO]_4z,Q0%=u5Rwo`J.]-өiD~?ی:u*e#)?}b3욷[v: 3Q&󑶆-pwns\NR/4i]]I8fNOұD[QPƶw]\~yh?כ;#*xyk5!h1)\m$7$s⼧NTs=_EJK;ElSsL/v`zQ3Ɲ9r_VU,kDFY\2 tkƣkuIa$MbY>UNXǿ %/Gu{Q權rz"bYJk[Wj[dh(~6LRv5)SҕUE[;II$qZEF3g9_OkTY؂NH?g'+~ xj{W%mS~gE\?F4U|\|K}{v՚8p169+ӾkIѦ:jdP =o8h}W:ur>o-:ʴi误Km:(EqZO5sC*lX䍃C)*7w*)WX(ťmWgOKԗi)uNN[>)Z ?!-!=YV2Yn*GT}Nܭrѩj.Mj_l#^ӤO-:iAYz?:m9gi_RZ^~]-Ό]Zr4m}¯K\[X2ȖQ_ aJcG#(Zv~gPUXm|#VŜwޒ<]c<}q_=ZT3C=~#ͨi ED ,Q$k$RdS*FA`Ă#hߏGo[>Nu}+^5>*-\CRA"601cޘSrapx_a4kkPs+;$wu}~ r-!4r2Hq+^0w{oSBuVo3NbY*V"2UrӮQ4уh1\4Oj8frN3sۓ!kzAS2hyIjךsyiɔ0,}NFO?*+(_cyFJ˩ FYɻy; uW+Vc}J7 *g?kJӚ/voT0n>ѡ͐@|yW)GwE%Gf U;U" z(kk O^Amۤ•ã2ӱRW8Ԍt߭X*YW@#ߧ4k{6ߴRzyBKo%cJY~Fj\c{TNVqV+e2f\aW8?Y`#Hu!.+)Uݘ4$ZslhB>Yy.&6+s89E^Og,"2ygJt#{\Tt1K6GkHeN/qb%Ff8lZek0QOnV8%! }F;ut_2s?MH-9`:hG+&Ϥ/kyW_/;fo>Fz1݀^>e^6W[YUJS[(O?K(0~# H ,kSj﷯|)FU[i[]XJIv}b?b$WnN\gu vUڟ18$`ݺֱa)Jh15MRvW=ޙ$Фͮ#oo1(I8wb\WG p>c0{GM8Yu4?bгǹ^38֏-9GJ-:m_i:'7걮ȗ \1~Z}4]<W 8s޳.QqגZ涚izw|Aw3۵yvjC?/Ht)T:NNП 5HC"ƪ$G'מܪOMeJ3s!V[d^|UF0x]J1}QNq^ɘF6rgsכ[_׹x ѧRw⺞@:UiMl (8TnOL?8[\g7ľ4x}f!79+::ou5G&*U1}O~{V&y n\\9SmўELTW{ǟ\^}o3'ǩq_iT骭iQFwV龇~*$u6IXʔRIS>NN)Y-j}Na6DDrw${ ^n&I{qG4yaN[sV[I S温ԩ*3VIÑRҼ-eeݖ5 #idϙId={~Uڦm*ϱpɸiѣRקg1wE6W YHՕ:n%'&r\MVȵhcm$wIH6V?p;ҩSrIZ揤)U/;~g֟u9hzs&ǸH+7F5){{k_|y:5=d'.Ycba  șܧ:3(Q>Hߕ=t߷RP(ۛt_3Ѿ&_ ?~Z%ֹ%-H*Ñs媦5hgp88Vukө>-u Y"m!A8 ޼ ^21X2t9,DTd+;8W ]Ϻ6_&A+`5昺j2u_+wZߡ鶞9Tg6o'{{{\lvŨ(ʲ9o$R@g$g~ǖ[jO 7f̴|^58PxO:lS,,~ROۗek4~7(xY5[_8{[`*F](֗6$Ssѿv8#]V3pUvqW"Rpz<FI}֞|PJ4]˺G$מ 2.}AVQG 54QM[f<ōQT/ozݛt,4gRM++𽖝sYܿpoS*|+s|[F_ *SMMT%l72m>"ŸmUчaYtb^_FK~G*<2wMwOu{(nQ]41l [x{8\=XZ7O[vK0:V ]zZoׯ\kz<6݅5c4ca*8l5'(h۲]]Dpj֒] #IIsg#nmgg ~:כ_Q릺S[3~6MY[uUch >ZF2~a8i98Zw{8 .c4~/MCJ_&&dX$~εqapy+$ݻi\~'xЈm`d+2qNS#٦;Zt;, -IګN˽~WoY [W3eg?/'ھGaj}aGiuٜčWca᷊]wQTӸ,gҗ1TpvP˶&m( 6.جZ-pR1w6*CGhة{cⴍi[1y4-f!4O1P.z`9գ'-KT.,mbYU&*0$\gTVQ|uJJOo{wkpWFTchRPZ'.xPw]!ciYwk+lr)<<*{6И7@q3?{ZtF˖/2y'XN>Qy84 TSw2IshTz:S9'R.x7Lj[W{$lmFWXxq娟n|i̓9s#(ZmoQkq&UI2 &p1Vciدz*ְUK̉vs}>r5Om>U46rsUQڤ\zڗU~֩JVƥau#A+7J峑I1ֈ:)Sխ?1+S|Ka\srx ڟЖ{EW,>d^WQ5orZ:CS=O׌gM"飑d hG4ck#O{ħe.OqQn7"Y.9dFb#'rEHΟ%:^{ kv1iNR}y%R\GDg g\/_3-UR2aB*˸}+7v*4OĦO)߻,SR@Vy|Ʉ=i@ܢ'9ןYKYn9R&ܕSBQ8w8?Ν:pq-nYOŸ5qbǖ*\˩V쀋ˇhr0H''޲9s]4ه{5dWq8x?ҕNnRus#J}1ç$dc){)*4̝^;)!mmUq:¿-Irnb=1 *ejGsŸџ%̓$865O.S:㇟whp2vާgְR{WE:$ks .ߗw8榧I۾|/c{H˚:_o/|7 dUǞQ\K_F)ϻ}la5QK>J-}U PY =y/iyorx˶ [ߥs{j\LEz|3쵽yfZ䴪u;?=ulGw2ː/8\bi=cIi1ƤU%+FlQ[cZ8xj#NK:}YXۚZ72dJ1|^OO + tFN KkoCZv""U-q1i#E|Zߢ54)Pyxi'SJ1R6ō\͝O [хGfq9cP'i3\†T-$l!HsO:uoSWNriiϕ%CT=?ȯF>ͻ= X\Cqkm>vG6$Qwɻ2T-vzIݒ%iwAt9cӷKQݭnng̛Jgg%*Ӎju)[KeQ-fI7Hن y,qßʪ\vݚsҨqs6P[{E9(ڤc$ |*Uy5kU\Cd?n$x|w0[wLg*,c_ѓ^-/,6'|qQZ}Y4q_nr<,oF#y J*^]JXiEU7E{]zƱ*2Ms3sAt^Tѿ2S'Sfy1cSVU5ʷ:V,n)I# kϬJ$^GS6fmcyWQ.ytznOÊ2^U=*Y 35*tyuTk^N>T_-͐ykJQh4^Ft)=f";dw|`Jގ[lqRgf uP_1g*kazqISL<֒jk6-o =I6Iۃ}X} m+];?Kz];]hxFiUP $$׎՜޾[RJWw$祣|wR+a{MJ0m~ZTSI]w_rJEUl㞽HpMIT卤Kz#07>Rlwié˦|ѧ v˹^®b_p1dңR4B&ڋ}-*Ϡ ՖdV$@=\r1{Rs4a9Qh.V7~5vlNՄq1MZƵD?w,{eUfHiFc+W/zvC 6eqVqrin(ԯFWswO-~f=ЧZ5*j*M1"Fu{֒DcZOf0Ks1áⴕ8JW}7+:L`w}еj.eLB2ۭ\ͻ 3iY@ΕTiz)j oqcoʤyyJV#ӄ2d}JiD>ZiF >ķʾZ%LO[@ӏfnJNj+MBmBs8"ڹT(^'ڽT4Ի]~ŌPɻjJ7j_- 2ybd)w5ˊS&3C&O*w\NqWPvcO M]wMk64wnʧ^QN :ۣ4{$ [8Iwr \y=zq8KY>g)Vi.q_aƣ9\!MSm(FR,0+\# d1d|߱:F10F05w}"!쪯"a<qR'kҫE'"gK$p>l;9泭G^NgnX~lEyvq*#\=E3viVbKvw",$nvʴoh=Iϵzu8iYe@pNNqǒ-պ] اI6ӥ|[kx *xs{[ΝmmԡZ޷NФSy3$wuVU*[O Xө쉮-ZX.*W{>VvV`FefnrF1Q޻c(ЋZXέJ&7Ko8~mػZCtۍ̥5ۙ)"W?Z|aQK٧h4뵋F!J$AG0?.s9tn+OB4S]v""ʹAڥ8ʊtdESlEO_H*\.mgyndʳRk"+}w#ˀĞiuYA܁wNSMvؤdz[ROGks&.*ߩ%M1N-eTF-@ngp&$RP}(ZqnטcUn1<$ipz}}kYV_yRNQH}4.H"c*ilٷ{ESaǵI@sV⥈nK3Qq+r[&0H*x[5hE=^qɧ~"S6XBV $榤ٯ~/ԩU9wvH`w/̩#2\j}\򔭯DC  H~eKgSt4N1IZOubv\37w>+N* S[a,O-{ y+k2"m㐻a|u@psiS*BT$ބJBO&yd''ֻMHEâѰfwo8]ҹ:qJwYr8TY7/gcǽm'.J,lG sw.X[r]S5mRC.FYAyZ{[HvK{dcHF;TcͬCބNO{%@U~tS}Ik{N_WkE*K=ؗ Em'gN>_#S)sCJ8LO, d-!qQ]_Ċ莚|7W(Rtއ/-$[<9  v+;.{oعFwWG3B`.MXOZMcT*FDq:D@A u q'InGd{Ϳ#. ؏ret֏*AS4~}sQ(;jgn-ؖ˹vȲ9dVq:4~8sk[$kS ,^)TSmѢG̊TkոVpJy`zrx9{5eEcVU--o`ui-~r08g.]mG(ثwhaٱp}=GԨV娝 ]u,"8%p;* QYƛhTsgPy=HRwdө;=m%"fOq84IS6urΜ9fRI3.&f4)JV{-=N) tAyd$FFi#lGO~}y*ydm<5֧(5,B#F,ޔ=$ܩr֪{jM 'y$r|#Ǯsb;[cJ=!h %7:8={rTHfΨSXo,W$Pݿ+#?_jhJ ^4i^H ʫz4\XVku'E9D~`ō zW gϱ_SΰI5;d\>ⴣ.KhVט~[\Mmu n#51|Щ*y Y+pS=hZ5ϷR'y;H۵O^}1QSTcZnՕ6o8qQ7r.B-LqF.jq'VJeHdn%?0"*8Nɭmz#>gt9>):yeIjMqG< 25'8 `Əb{h")ۘma#T y.v`X \m9gSR]53ÿE.EaK[vZ5e1Ɏā=qڣY4F.ee$MƑU=1SQAS]ug*ҧuUknM PO4дbFnssۥW$iӋ"ժTn-Oӹ"+4FVnY\Ԍʥ/{RԻ߯AO_"F,ƒ|ϭzJQ#NJ%h122C9hʟ÷usFݞ}CsF#]g}q]4gRc 8#7R#eNvdM\r hTc/+:cݹk}1YZN79z۞×T h <+0بGEi8%Hk=ˌZ8RSb(.WB.$Gھf{"㌏*S׎*:I(̙VEh;C8=GqޮU\c~beH.M5Pǝ>?y{d)jyӅI"#2c;zҭ_YIu#>-{䱸KMV&v݂[Ϲk ܑ:5g ZzHbi$[J/g;3Њ{(֭vҷOuy%d39N9S)Z_M,TdS˯orx!kinՙGi*qIج=Iѣ&$_dl%VQ+0؊Q2m9*Db#?.G@&ws{HRVOZ-|Ĥ"ņ9X.;e¢"]>+˚h[yv>cB*V[!*ѣE^WZyu-I$FIftr 9汧QKW:'^kDw &Uo9Mq($j֜ɻ[(*{GvQ,d,Igs”䞤a'j6惻؞b+"cw.FHq+G4¦"buݝ|yb;cXԫ}Y5$'>9 ف1Σ#cN7r "pFzy2փ9*A3H- 'ߞsDj1n;~ӣ>kyYDȈB6S{9B.12ƒ),FEcJ3qfU}IC*ɲiPң*OT ?ȢSQcFݯ̽omK6)D۫QR4,t#^eܸ q`S\ šf"0wf8;qׯJZt{|Ɍy5{/ĝt1X8>ۯbK>ś{Yce;G~R&rՔioIx#wew+OQ֭#i>]Κ/ĮZrc]瞂֌-z|{$Yz5&c.XP[2)vs7Gn[}(X̒t7*HB1Ϩ^~&hRbG w%smu8=y,Nq мU̵teY.<"u<^u_zvF4_dj*-fn˷v?ß\rDAƝlH#FF?\VU%\{5%H_x#ڼZS=Zyי|DPlL0G_:NiG\X9UW[8h*Ff4{w䐀:~{XXr(I=6~֬u5̻9$%w$dI*Q竇3MEy}"13~Hι N"xyʊ T%ßQþ(Տe4@c4)ݗWZ9׍4Ֆlvi/ONsWPN[k4kTj:^:1E(fS(cc)ѫ/7k=[cqX_k8T}O.X .I KFK,Ǜ-i[Mۢ~w￮x5TZ螎l[<+{eU#b>W-ϩGTwzh9 XY$4G<7|k˩Bw`yd]_[W@%VrrG"䄩8w|צ)ʄUJ:uGw"8.5&])Jqr{VMKmQ+Z7yOTڝf-sP|v䁌 gicfO}R[h]dW2jWew~Ixkև]/ *ϧ2η^S4JCA5=|Rx_+u>:8\FY-&߁Ɲ#I I$Lbv ķ 0üDZWRfvm֖7rVz7m}xsFlcY,mF Yvb Rq ⣁*fՕӓ^xeS ի黺Z>Ot;Wg[<ːs=x*9ؚrڶ=,SZ|k]c;fe;A%op >aGՂM~w<\G F^6/>7L^m.M6n v6V*V]ow&9. OTDR0WM'78^,Q~e ^'/.$ڏu[W+>y.Kvi&c WV+tK t$/,]p~~dV]ۏ<JmcFNm/=;/׳iz=QC7( Q};tԠwƿ '뿻XViJs(Vs69qXC*{5vʏ5VNOϧ kv֬F$9dJR}J-V8Mgݝƛ=v=I`Nw1jβcɯQT&b) 1KInQJ$s98WJwY#JL_\U#j|]CSC5Lޛx*SYUrVYsqI4&V$%6lEv˴/JTa4J|u+G;[=xɅV.nڕ/EvFce٢\ĬkrV>*!oF SXɹ{v"Vuo30-zaTO+aiTV^~ɞ?bdZKkJRJoc͌5+ݞ+R^kVj:yJ<^h/rh6Q,3ɕ,g+l|rR5QW5wI+Om2hC̤ɗ$x9>%*iG؟mQK]ciam6^k$Ld@asI<~/RboC*5)Rwnb>1L] np8ӹ<}s\U$䮵}Jes@tK%Fcy`}À~Sӊ|<ʵeR<_ߵEHUy?t^N+)AYlҜk98,9=cB/3)M[Ӕo&߱O9kz./ߍIyK>,#;kFU&e#9Tva`ђ#o^*ZjOϣ4=ᓿ}EuBJWV:/.Guȇh?09 dukIPiѦ%{ <)3I'atӼHF<]~GĢKp|-RW}F?AS,d=QYZ/<f_,ֻ[nF\FntE NMtW0uy4[[6eycU֨G15'*knx5NͅN@"9A{c"29(NI.H湞ݭypeStS>[ZdS"q~f' u沞>Jp/+=Mq<;~,"U(V|wwѭxR[1b$m;ץxso~GXU5Ԃmo#!o=}]J-&tO݊xj cdY,aw8?#]R1/Ww'tiŕxW޻09gQEOiedz-cYj,I`w~q*m&!)ƛNܻc^"+(hxlA#U*Ww~8ѕV__|+%e=y2jX M pQ ׁJ̭wwC찘8ҧNJ:mCQYhv®_P1ڼDR81TaLJTy7=+PL,i}݈J،Gzꄴٜ!Vз8m*En&z3H-gc*~s5ދyؓJk7ovWFJԛEK1RܺXֆJ<*n^|] c=_PQjr hd'nM2<|A[S揻Uo!fw_$ӧ)ٛQ~񩫣}oxt{]<iUa#3GzqR5.kK0OzF~L}:熴KE snmc Uc QyME 秩(,<);^[;ѭdQ4|mUmAF1oY^C/3i^9Cezy\,Mz|>21sQvOs 6څ}.|o!mA*4mI8ӊ\)+ջYor׌7K迮ދ]*f(:|ݱA H:ZDn- F; 98of5Ȯ#nbҲNhݿC:R6:{k--U 89FzgrM{6+rS,^ Ea揗#=F}8))s^yN 2ksqy$U 0:׈X/>FTMtZ[u "Y1hqHHΣi\ʎ&2#D.!x6HDqÌ;0sEHƜ%oCZKG)YxXs+},*Th5ƥ;5+/[']֧U[ˤLc;ܴoqA0ʤ=IakVZ|1*d3F~c-zu<96NWu1Ȉ*e]gY# &瓙PuGw6~񤗣yOo#/F_v!JZu-%Ԓܳ=sWV:qwS!O{>C da #=笗*kn/kR\=ך$ LOF$u95}X2})."m!QOQ񎴪>dQuN%wFp?_S.Y٥ye&Z#uCe=2SN>3Y-/dKq>mzn-?{SVQSԊk%].ר}~GLBu=s4bU ys~N\ڹY:YulylE&+N2޺iםIKMK漈cbW~mf2yac.Yh3YmVVI~Ѣ̐.N3QʺJ8JT%m#i#)9F#յ:u73^势GM:t֖;[d<01N8#4FxxW=ƪ3&,yO Tg9+NXяM"}: (&8ef!z"(ӕh7RUSq+lR,_k*|t4.Ur%^O# i??ϭLcNϗc(FTd7e/Ϣ&W>VPt#AU)ǚ;5*ajb^o>̒F[Nq.lw<5LiKoA4bf̳?Gg#֥[+DO%F"ՓJRT /s?N(QdΘϖnQW\dyY|WqNq\YJɔe{\r#(W'gzc|VҧN*U!FlM CGy9Bc=xyc/Sj1n}WOdHU۷*Ѯqhye~)q=} -nf{O3||O<8ԧ:ӥh晑? ?;4[yaBWsnngwyma8뻜y{9YvvY<2Y>Dc##^k.7֜* 6FΏ ޼R \Vg{\+{(AylYX9)Jc}bܭ G ьHZV9R9xgW6ބƼ7Mqg;WG4e}lT]hj>zn%Ml;Ёwi1TEŒy+k܈Z6 $mSݾ\wVc=}eu+{^ qQNt޷ߥ Jw {mITw9۷QjpRVoqՕ9JO>+Gcfps˔- rgm۲-v^;Uw2TPV ݏN $}W͹6XdT2%@-SRGKC+X Đ2n0bE_ןNߊkܬ=IԦ}?͸_&Qh.dVy G$6ֶU=[yßEfuΛUvf*1ڼcK8ՊXc¹R;[#xʥ8hm-H585{ҝOz/R)%Ie*gj))m%.$a/AUviJev mil=ֲ-}|ZZtdO>dl; JTݴhpbZ 52#lW`: 8'zYs5-t̺xy')QWZ^B-ěcSxHʤol 8~bBrG@zVݎ;ie ya_3 YNTc.g07\sy_Dѧ;Cuԝ_[lmN.Y=_Beo,l8>?SQ>XoR|&޻SB2=;[s,~b8V>frŪu3UePMlm)OQF["6;j(Ҏǖr‡hXT >λ)⹢ #SM_bwF犷j*~F.]i S5ۅ֋6ubO;Ap3wtzQm8J]_U]Tyvc t׽h um Мmb(^Ԓ)ݬ!+_3nzLHք*J7Mɖn5M*r谶V?8gg{8ڝ)FT۵יA{B#YwLislt.UQiwm][tb vFˏ\xʤ_3w1j{56f?x.3ҹjTk[uשyt庹(ǰ\ I36ǖ+4tN4MEy*ۗ;*;qXKzMӒ///%țJˑvی`hGxEz] ]?U©ݹ"`356=Q5Fb\0DPn}0>(2&tKV{j`* K<,Z63yqT[?;qP*Eܠ7$Kr\.Q{%G~yhڴp6N#i#9oFٯ Ѽ^wvmu IslstiFkT/VuBkKoO:7ıxKu&q$ c"Uqڵլz}juө̓*k'ݿbio Jm\rS8|) <8Li'|M_UUF15ek?>^F|Zl[E.<"O(Ԩtt"+ ^2ٷ{3Ѯ#x_/OPm\C,jprA=jʎ%knsԧy{Mmr24n쟗q0~@ɯɥÒh}fUGtM?߇ukm,ȫ+~BHtԣ"GDQJOwzΙ%eYav cZӔdcFކ,fhe,qxcJKGcVO?1LEYYcfK6Kc<}Nhߙ8BC2?z Cʕ9k ރ|)ڤcbJ&2u}H6U>.\r押YM+sK&"培?7^}>huk Hï([<{d!SV_%c/[\H6el=5zܫCzzy5yϟk-M Mx?t(ץNl_aFK2m}yi=E&약4Bwy3Vfgen;x{qY詹uZv_:'X4Jss9 ?xJ]Qք%ϯiI1!S'<ǭy1fy|$Va~ھ"Awq"$o ˝ѩb<QSM[|}'x|~7hlǺrUo- ´Q(~O.iwk>\7ê)?4ɻ<vtT>Y6ziޜ<; Iiq7Ѭ`rϿnIwaOB:%W.[އgR*jX$5E$[9')OOsJfG RR[{{Y4n+oIKG<^H*q_]J[gK/28ԢS@h?gWyVQ"xV $]|Y#l ǀ=JHѺowe{_/[ϫd|Utbnl㊘Q=>qNg*|wZgɤޤ_e*Wc6w-_cڍI(OCM>2+W[RrQ fSn$WfK);pd:z2z}f[K %5OOOծӔ^Vz?u麳m\}ᇙ `I򝇒cZiIlikngF#78pN7I6ĺ'O17_:Y{-j_4hs0;gq_c1\o_^qe#'^g~'^iXH[ [N#p#=04}b}<ʖ_ W)k}ZykM76G' )r1y0qh>UjWM=t>a=E4M?Okۜ_ S:WV{5I:ɷ~>o Z2#m @$>ڼ栤>ѭ,TMu^"v╏fX~eA'8ǥ|/ѭZ%N\|yŞOW+"A/ap nɥos>a]:n+]m=N^"wi #V01:e{=;/'Q${?>NnTӭTi< , 瓑 *W^y;q+{ mi}## P&y8''O{yR<pm%y#u8ԨcJxJ0:wЧ,#syjJ6w2ĩ|1ѳCNCʻF,<#ƜKڧgG5jOD,ؓrnNc3ߟzXXʍ8ӪgMoϹx$[es36#m'8?iqjtO~]m_xIӪAt.#m̹/^zvz5~^dbQO݊k]%mg6 Pg=Q0^ޞ[/`Y%i[7FU_?)xze)hOGRk~=3'G6ӫ5&%|@.# Ϩƽ<:um~fpz뙶Vz~{`㾴d(ī=R{<:7rͧkZw2yƄ|(֭; `n?www>hԧe=fqm&7:K<;BY~*'NzXlXB}wV[p|6uekˇ=\>Pۋ_1QGnZڟhѭjv~ZmM|Me1jH~&01 ־bQW_N^8˛5UjUтO5[V%46}U@h0r q rBV9?gLow.)0=\&taWԹchVپ=ʌS8Ǖy|k87!;UФ~p8?iO"%bneg,)w9zTrQ}zJj~*h2d2B0x>ڕJ'5k}&5乖MzkPGfC<+UǎrҠ梁i[Mo5@#?g8Ν:rfZ;Be_~s*gSY=b; rOnx.OhƥY8,y>eU6!~Oi?wcJ~4whZb_5FW+'eؘԗ//Rm/ n|7sʍ~/Б˼i*H ~tSgTkTTok'{2K10_'Xǎ3Zuje [j<2U8<^WLotWrKnnfQ7q i_騢˻, }L>5:(tt-Mtr}l =~S׹F.jSZt4#FsQR4,#.RU%a?ɫXԗ:.qsUOѓHa/溣.HM ѝF ~mkg3q<O+sAt-ItLH\l| y?(tF9St[X{fmQ 18\~^<]8Tu}_AHY ya>&Q2DܧY$*\V=iI&GWmxa8#[!׎RsҊ-JJ:!UvV|lqӞ5SJ7d{|o%,9'Gz^IF*$m z{ssrhtECDʗp[#ڥ}*Rc)IKDbTXѦ#\|}9?O4s涛)?omE/\g,=֋pMu*]J,l,u8ZrDHS,3]#kHA'9?zOYh]Nl'ͻ q8ǡϵ`c)TJVBysU}}Ǿ>eMMF]FmzHVfXf%O8O9+J|f,ez:aie}Elخ0ܞ;WSV3*fs_Onm3r?O\S%%KtAʣw̽Jm- nԒGPWDjʌS^5Oqe9/mb 7Dڹ\<}JwfOXDBL{^5v iSV9oڍIQK5qq֕O[5[[\˖s3d Oqb*SqQ8Nx}\Q躞 Qяݔ[(nfYpvv:si>Ÿ{f?h ;W#-(MV=jazY=1v5È:A+ccvI.aYdU\#VO{*R2(/ȽYm/˴~#KQIu{\*vN1ԉzumi^gY$i9nN)ӫNhp8(b*7{XN%*|]O6]l.e]1ѣN)ߛJXfeY%3z^Ϛ*t)K ijΣLF^7Jt@r+zUhD[dveR:^t 2k-_w@^^==9%]7wSNW&ڒpˏ^Ojt'+O֢ʝE޾}zU%դΘ[=qqQRTyjoM~KNq;O_wAVr\]hTEEv@N?ײַa\鶝Lr޺k\iCcbvG|Bu59rZVsZu/{,ѳ‚BϮxƵC8է%{ϱj1]|iyѣaCq2oZgFn)^+ӫYՔu9{\Y-X?:L&y:Fj5Fڜpms=.76K|,G+F*u]Ysƥq~V#L|7I^H3^=EwwvQVUM4 ;+m*IF+iҩxѤ2$t*Fq' l?dFn O+4zչRoMB#m6>^pJVJ*I[{\HWֳq+E>TT&Ӽ1l Qx$d8QRjۯN#SoeTFaubw#zzRO]HEXk/#-d!$\1HeFƆ{m"7)Ҫ5rc]5%= ҕJQju&߻֗,Kሲ-Sw'@qyu T}kN[ 2fyWwe8##klEniCI-Y<$%BbW7՗';It-2Fu|%1ɨ]1 }iBq'R2"9:+Og4tz g$!c+t'Eͪcj:phߴ3d~b3oM՟#GgÕ_ۏwI[Zr>h~'x~lVJ0ީ<F5Oޖ۽cn} ;)9<sJ*սA Y^+SF-NU1O裈Ї`X8*RR*#%8m@m`T>.vUjsH̒]ޕ:BCkVy)Ti/&tUH0mzzg޹jTGTWcp0~S~뵿Sӌ]Vo%嚲0epK{5(ԒiˈkATjDD#Y>l29X9OXM^Ɗ3Q>ŏ%dp;NTe*4=JknkΆN".]mo=:U%Z]ص-'#G 'fxq9QRjSTdxySNenvب+w=wӧJ7[|>+ Zޝ::K[x6y3ȧ@p z1N3l-Z<{Gqk 8Hٌ6NIlt֔j:uo+hߝ}ckaxۜWp$`\E)F Qb/R4n yZHKF['#$99?KZ[]O?k i,ədI6wg NخΝ[}X:Ѵ,;N[YMUfva5%`[wNMrΤ[]6^$.ԫs5KZ]H."ʜU1TRy]ܵfM$98(c$+ %H$}?*NZn/Fwa)Rm{YeF[7Lqe=O'{sn)J.}hWvV=~;G31 dN:f/-RvF&D6F*.ʺ%"8v\ڌc~xN\ҝNF㤛uQ$n9cZzԍi;-,6Wwd{UYrpy#և)/@+ s NQzVЏhFtjvy`1_NN9~Jt㮞)Hde_#T]"qED58y v<'I.׳%{ۏ,Y9R6?Lci}b0j\ra \}yr:Wv:+5ُ"9XE9s4+ы*~H$G++.#lgs\(O숭a[U,J[q_ϧTοj9Tm8І7$DpA<gZ.;~TBB 6W,Zǖ\拚o &9V6Ot\'J4Zkq,LYs"'9 ~ԩx-M97y0-h_ǐw^*}\mk(Jj*hC*Á?TӍ> J*}%܋g_1!AS:r95kVLgIc?N}Vd(<ݷrvĬwgjQeҥe4m-WؾY\i¤-LFIF 9Q7CNs0 ijWmoʢ3x1Q&l)F3)>ugs:ӎG-v߼5v64۷y$QFK <8(mĊ6];-cḛǻAqZpN-Oݓ_b ,ٸr6.x;0K(OW[ooJ#rZ}k-n?8qϦ:WeYJBRg\G5UeI{:&T(ʥ7:*FPEFw߭wS>ny= !VTҦN仹ln'+׬۞1:zI mk֥Z*\ߩSpGԮmd"Zfv:%9ԂԆG ͵-$uʬdgO_f!䲀@9XQNR %;eT/q'm"х)oRMmfі因_޼[>):|ZH n&*cnNzs׮? *Vr2JWmB[ib31܊T>CsY_ci*1t|`"2*ƥIۖ8,qQCL..U#^DcXPnͷ> 弯birǚ2vר!+n2==9uc/ v\L 2$`yMMZovg9G'do"1 !8fsUsӂ U%|X iT݃$;}jUxZۗ8JT䮺G0mEQfx692qڧQw}C>hզֺYn#CnʬndL\c5z[A+Xd0K鳎<s՝pZ/gB6lvȫzG~O4d-lg*qQeK&݆}Ѕ 9j؉EU}b) f?Oc.iŦ#_/jZ:jȞxFpW9uRTcU%o:=> WYNwFxJS*\bmP1v Hws߃Թ{Cq2RV)6- qٖ~@?M(TjbXϙԞ֗TO7fOof! d^hr5#J^ϕ2 16D%_.8X2ݴpzgASQƞt)$%.^F ]\*=yrԩ8N0'e-`E 'ɐ:x9U%S1R#.ɾv/ Yccrt"-"1Qؽ[$B(=:u^I8NQ+9ѳGh7sg#̍R~d6Юd 6q55%)+01m=Fe0W!l=0q.XR9J'١?ѓh*2OQښu%A$/628~(|iV^ﺿ듗{yie1m'Y_^4/qHiRg9ޱت5Fޭ%ir=yh3Cn,&Yeۓ qԳҒv%~޻!=ݓ24$2Δ2p<;1ǫʼSn;Q^RwW]pPwן\(93Mh'*WMIr}=X\ ǥyqqrNk6Opd3$d'c%-ٜ}ݖ-Y)$|1\~|CqF&۹z⬎b4Y9Gtm>穵< c%)EouMM㯏èjK -&fRJsTV1m]X\u0dW{.i׾8)$i+I-z=!o5oyhJFf=Fx|+V娚]?Ϲ,TN_e_ޅ^Gc{+A5scFo(sjeEm?^!sO9ԵƳnI&lJ̯=Npzq\Iem\M5(꼵_;*`2؛5nO_?Síz0Ң>J3 xtx9w~⿑8fծ}Fjٖe,MM9|Gw˟em,7_'6:WTF4֎蒿޷>(ʋGnyo >1hzŢ0j 1 x#gMTOá9~)Ӕo]=W \MK<+lyP-Yd(7rA%ɱ9 mݕݬ[=>[̕U;vnwF=_ri{{{6,lT 3 rG;}6 i9v˷1>NSPn4i;Ov$j'hP*=!GjupҧjjωkVYN7woi5Ԗ–K )GHSi3{e)'7_it +,[p*N?>A2XYo` 3ױR0*))ŭw<%Q8E-ʚ~܇,UN̒/H_8R:N֭NR+3%swHw2@@`.ӎ50?$D7gk:SO.3y^9r ̍-Om.$ @'qϕ>nUƟU=O_]b}$[Z yrrA鏧:TvJx8wOGUXeFU;@99Gݾ {LE[N>zÏqhYKBΰP9+O7ϩ0i;5_4W!VvOӟ>ڌOCxcOV8?|եVM26R6GʧkْI֫(Y^A^t^jb"Iypzs![i#_ߛ|;.#-*Ot^uS[4pZSFF[l9IsAi,-JpRzW4#>ji\FYd>l۽6ZNnƸY)|zit쌬wy8$u89zӍG(mڼySrni"*c$j1azAR8rt6anFso͞p+ Y'©JNN ~lp?>E\ˌ^:St9ѩ$wyioF#-_mVR:mR;/f" F'+ɷ,Fs@Z9Q4>>]8y-2zY:rhJ,cOSokbR˳l+Ws}xa*t] 4eU{D}Gci2}nXI`;v~/S/q|Zzr8/)TS<Ӗ)U"ʒVA}+\^:J9CFbGe[v׽C*Tܣ3Ǖ:IG~?ANI[1iR͈O+jT+tC%eHC++iՄbFӧMk{+!#doJi?W,Gu#N;EjQv-,eݐyhԩhivFXr*h9mj5#7ȴLBwK⯄k9a񒡶np ^\8Ԓ][/O_̩NWծWkۧ]v٣?m֕(chЦ>i6Rºqr\]X|%H~cyry; 쫫=/cQSJEnՍcOYkf4wV $D\tcGLE-V&TuW]|חO=wAb]GUxq>,x5d۸:g'yzs_EC*2R㪶V.z-ŮȟOk)|Ӥ5|Zݏ  YH9M-=Ugj9'gL%ݴ2|ܨڹu]ƌbF[W9Nx.U32I9}r?ȯ֬|Qss&m=J0r{޶S^]P[yaU$2~mgƟ-ͥppQȸ8UTdK_N=Oi[Ɋy۔Hv=qN3qQSERFERFZ,BpdwҌ5U\(J {~۶IiN7 A5Q浻ڵ?-ɶSƧ`! 8?z^=VR:q%~斷=V5ȏ&lΪ@y׽YZ;۬%C~.Am$Vc&1~={kx N[RUa*<;Tuy)#nl/8u2wIHH7_/tTnr="CG M)`~WSQSL-o{G}>n$ڡūDҕ"hz[=QRP贋ݝͪK6q zǿtsJg(NR4fSd-*8 vҺ?x}2J9J^DK4Vё]ǯ,q\UNVvaSMICXnd8$'ҧwZS[|QGߴV8 &V=(ҕ8ϧqr[fgYep1V!~TU ܜKIEۻ߯dI?$[c V1*rX+sDp廳ouڞ =.VPR[JBRBI㟗n7-]k_|*]z=>Z<UY}S8}$iCVN20 Tg/iM8k*M(/!Y[s؞:ZG=շ3J]̒-7j0sČEZKVUHk4/t$hcœ6v1Ԑ+'nRDgn֗9ۙublv?6ݰQ9;zT=|^m[_us8Scگ,S-pdVHd=r1JQ9Y+g~ڝDVvS,dUb!mB %ןFRO=?c EWtzIfN˜+B 9$'<ϵϚ4"ZR^gFen!Xy ^rּ:t}O"/Dnx }_]#Oɷs4^w؏g寈4KHXV/-fb6'^]:Ж<ь6RHd9g+ZJΝ/gSC񦍩kg.Zf"9[2AR{~GFQqn @`g=;w,NEtX㗺t=PvMTm8+J69j(tYMqvCrF@?دrz2s0R_qhG#X|{=f4cçRRԑ.7]+"wnlXcZ/.UUR%vXϧN3x\%u-GVUN-}-XJK4aiAF}:qڵܓ{t5nr=7͍cn9<5gs#D!X(vLdBӿ5 1%$Ƚ>[|wЬe)RwK z&&FCpq]RWo:|XhWj ;ՅE%55H8z_-U;Ϝ^O?SE6Oe[NV.]n 2Bn]ߌw;iT*:[pb}Gw`7<<ҺJ2MKk+'y"s*\͹Uf?{:yex=WcT+Om {o.l#3b jhiFTNRIn>s#ܙ*@Z(өRjɝ^7fb'vF;tJ3pLsv#K-q$2!n;WKhrҴ|)62?x z)ʕٝ:NRN^aPVIѷFQ{u$ci?ȗZQN,F]$f=͖1;O"F\)'X0\Ȣ"[rǷ>S qm,7"5b{c:/V,@ =rPy2EAٻXm@BˆP˕l-=@5>5h’.C_t]>FG=xTmSM=mܚ9evx+{~u28[K*oV/QWAn?vGzƦކXSr]!ڏF3"me ߓ'J1l4S܄6CjrÅY35۴-A7E-HaGG0,۰N35ݽQRTnߙK I3j>@ 䒸Q*%hw4[5,^bs2qYxw(7VE݋|]]ݰuR{_rУYFI% ykCgO8*c5ϩzF-'k ,I; wj(pl2G+(lmFaekL敺z||3U?gsӏ4s+PYB\y dN.zojw_B$۞5i2{8(Q߼(v8nS^{dJڴdXyӿC*ˊkyrɉ_ :u[{JkCJVhR٠ܬfvu;O+3](mbO2̍@uQTz{סKS^Z4M:[[:iޛZ.{9TW%Z"\T:zEQif\>f-9+%Pj,ny VN{*ѩSzGM*.7RFV(wsIk4w{(С}ĒHebbtRT +hь~FQrM^ɐI yv\NrAcv湟5K'w9jTW{Б̌%{#9odU{Qr{˱4preXDlw-D#+$W '?nԩ+3J*xXn=OzԖNDz0kv/)saq^-jmkxG̽;GKs.]=Lg\m8-ƛ~ϖ;*S:;8-zquR*~%b9סsɚ_#2\QTAi۪'g>KyJ` zW F5KW}w/@։ތ3UoUOs{G thY۬PȨEsԼv5W$Zk8>|+6p}sVmB FYk7v=~Y1R9r%r@p)AFwӦwmu"yʼm;WPev`mThӳ;ImμU ?On ӭNzĘwOʓG~)<:}WT1P嵎(F<- OHwrcmtQK:>hT-ȸ0p̵A4q (W]JZ̍mAv ^ƯۿTvJ4ita,Sgo͇nj=zTaެѮZhdwlb?v+[(DtY.W̚G°1+П%;z֣.d:M7W2Uw^׽aRWmz,59VɅf=I?Y{kO_VփM,ΓAc,AUS8k>_vOth))*{K7' t)F6M^_h)۱΍w? OSzrД~~3߳4-uG OES ?YJk['SJUd_6ˎ :qvѓF>_H22b fT}{N֓WzuhD< ЀY\#8N2iW.W:MJ5{Ho*@S[e=AraJcʞq9V\Rtƶ&NGkf!;6,JscW_e̴{GYFm\۬ku#.z*TT/cxIsov8(,Z?]j5h٥!|f;N d a,ExќwRV[?ogc*x{%[˱:_ݬ&C/|˳?y~Uzԣ:i+^^[=_Sg h57<=f`Wh$1p+x ^2U{$wnlUI{?_~&> ^2] [pHG"G# sQ| {loK Z2SkFijk #B/&mQ|Ɂ*dc_ZP{N\TiF")?Pay&iI)"~X)m^ q Tpnrj릷vz<,c^&3s޷s~g#-.C28ԥq{m^g|a0oud?^]#-%*WSS˜t'TTZZogGT}gPEgHM`?^3G).gxzQWӵc#Mis}E}$'FWZ5}FeZ#4j4~c23jQ24)>ck2L|]6XnpVh\YB$1۾Nx략)-u3KyUpf[ͻs#={'֧G,կ}\RSoGׂk黜ro{EF[q/#e_TgofJ=(GDAo<svC1>S/5Mg__5,#Uz9֧[@O^UK/ <|LԷyMYkhev ;~tsE]u9qm;h¥],n9<;pmͦ8z#}K1=I a*wsӽ>72l0'ۮ3ݮtyo4_=Nƶf%HΰH1svBqZ}lnZ .gv#l듁k?v.yЇ7llD2ʾl\b)#R4]Kr,0wSvq2\Q]:QMjBƌվ\}ZriF/*-NbF BU9'?MgIT֯" #[%'* ޯ,ic>vd;ziQ>|ѽڿtУ*z[CP*ĩG )J"QzOpgmfI!2v.\pNp3ǠVYZIjɚr˚HY.۸7Xաcd&+6v,O <i9Als#\%e|Ѯ:̼63Њj1ӫ;U|[:߅,Z98Èߜ|}t&t*soNFp~]_O3ݴ ݞnyD+z>qs;NtϺbb9 V9݂ ҹcF\ܯY.f9%vKI3hw4r {^N4T/3q1\X\F:z>e#zo_JGF[ 8ӕ.t)igf3ܛ~1?yciNXzb< 1- !?E=IJۛFRv|Yys]C PU8UۅԗW},S+Ӥ3}z#Sq̫8'ν4Q1Qɿ_cq&5̶0d#i58*~gF"2u!V&}=?y}CJҕ#m打AXdc$`\UT+n[_5ĪJ{tB|RFyŐ>c ^~FNHܤP:G^>.O]ZV_nI&>Y$'x^3F"+V;jQWxukEfU,8Pnʗ)/Usl<}hkcڼ'tJ? ^Z|g'hp3†$sB }&9UwR[_`񲣇ROEhG_|)]~Rn-cCqp2' +T+{j2l`KZy^Ut =m Mͼ @`r\ =F՟Kkm>(`򟵩̝m7s|i w[mݖFܨ5 lzz #)qj}tG0\i4VonL}{W:ڷ8iW5O>_3湑/y3=bǩ3kM_?זJ;%D[Cu=OէV9y[_ƽ,=8{D}-*rPNͫO@[h2͎OxǯJ5)4m[uzѩ?ե-#[[M>ũkB–XO:0,{ ;6 dfݒ~8*_D]mlG\ƍ|+l>\^Lc=%OEn|n:ֱj6x4T3I9'7AJTe/SүM85wuH.ZIc@TllTEssTD>_mG]ew班U]\:r7^|Qޥaeȓi 0lv'8q&'Ͷݙe/}[oРFVm p9qJ-Z0rv=Gq;E7ZSGi$V"VS{vk7bϗ1w}=l} [KtXc_l#H:6?WNNVN4:c߅PԴo3˓ls4}H!SĿf[vn#Rx 1Ӟ_QToը䩷՞k#=G;$1ȹSC}ג6䩏:˚ 5qPH**9r91\KJw;M8KK}& ^R&֏;4^)ԧY7;]B).ciWql\359)Z++tn۔  \~Y'Fѧ{:Z,)hG"ű5j\r'f6?A?zNx[s8ΚKֆID$9yErJ63zy*֛t&"-fuV^W׏EiƤ}jnW%xX@?C1Ks%N2|M&Z丟r<$9ߑ7Ft>PkCe۷G]9J/FqO~ˡ-apq[sIWZSe'+j%eЍ('=7t{9E3JQrܱؑ٣A?\}=ZB>:u.[ݨGS$}7>_4ӕ6&1^8V>нoyGZ ye͟N?W*ԭQ(ĘyGʧpA4 cu WO@.#IBh6&0gԟs8Qzr~:Cݍ^G9^4[3?cM9+ߩE4lPVG s޸ot.>k8l:Xv`=T Eq] -J$CuU }XS8l.!I])dUmFF+Fӄt:96cPg0iU 4gfy?Ba&>~IJɋ|T1ofjԋ*(a=lF@,f!죬G{8Ocw$7 A;Ky:ZES&_Sr*/{*C33GBrzӽUrΩeKI\u*I;.ߩ4Tmzvi]Ixcn+&N/T穣gITv+(ݎ=J6t3*\Fٶ um;+e!f;uDe)$'] q0_3ڇgڴ_z7^un-[k&e#֝n[Y.Ւ]^j p+AF.NVT Mjb]ۗ #kq=q.zkWRՉUytA?* mZ/yE 84~L*8ڦU$11m;"gުF I%pv\-Fv'冲}^YGo1\6ӵkk{NrK^4tǹM@1m'N\Mumu%.hd̷RG z+H+8rB.]]DZAKHܝ|=3VMDJXTYK$LzB.7ET慜u ^M`F|N 'kƿ,(mQ~S$+vg$s>55Njt{tEh<*9QnHȑ gb1q[3<4j\~zwEªݸZe'uRTyRiim/7GMq0iNXYuY>?4}:!"o2ܩ0IS~tb(MOlDc-(K7 HY|ŏn@?6r5ݣR?y}{3o$j$6 x:|SNWSm'6òY.ɺCƒr$jֵ;%9"i!gf-nCc@AaV>RN3m{\hV{qqi1f\eqo ztk:|hMJve{vh_!B}h*k}L4˹&Fu8ǭc/cFܝU/&.-xOq8Kt;~np8pAMu1ggI]5x~hTQ)`x*~0Grѩ˭N8z\=IBRԴ+κ9&nZ$'ZK~1JT/~6DIFgn3%9 W6;nXzºUaTjVg1=\ (66G4wbOI5-YګӍJ^T(m1f'rQ*om9_0}*ɷkNJʕ4ݎX哧``Pe)Uuz2ԜT#u 0̸q:ȉei%k1Ւוi$4'UGfnR' ٭K; G"n˝f'j3bT24mS5m2uu:oK8p!4β,Qp2A$?W-Z>N-[O3ɧ,TI[O&tmp|Գm\30z$5+abRQ+\;E:i6s'JJ2mIzJ>Y[.fZf;UV$~Pzs:w?hsjZwdo[{dۖ2Kc׭yzg[JTJ߯CsOI-y2Gʭ:Ty"QM ۫M $-g#5T"1G 9'}ת5,ū٢;A1 ʸ'ڹ)V4&SƆWQ ˵I#㓌J# e/&Aѹ?f#_˟ƹCjN9'RJ1Z\%[!x7E dӭyƥ):zJF1qtתH<j 9}ܴ^Fu"IF-ۦBDZeR_rcmcjXXk6Tam|< Vyt: *grbeK䮷vΒ<6VgRQ+]kzY~aHr,q^Nץị?atIoLFJ6f8 =Tx~NJM*2q9I7.x!l +'qq<5Ov mZ!a-+%李rH,E;X;l*SU稓_Ei~(ũwzW)r'iN.*2+Ԅ^Gc}1W4)Vnb#RϷH@ڧ$JwZ}[YKuJT9moON!FVw|biT(${ U;j_q4qG3H^ UT7q2m(ߧ˰5ݍt,yOLfԴZeN&W3)w 6*JzJ?U哔EL ]r]eInQtP"-O52H͋EnP:XҺG-Ld';=K"2 !-r;ڹjGzrJ4#RO̫<"^G8<IwS?fWNϢ[ϙȾfU~\i)EnG&+Y++9aN11Vc80~ӕ}\BI&$wϯ+0!ҩF*nlI$71~*T:t_mR>cl'?Al%º2;r;hҊRzڔ7ڃ] G˹,WqaNURy- Yw{r+7y*z㟼2{vVnTQJ[3n[6O8 2ZivNF{tEiN ]JJ)wz2yJn~U #WN7So\k#PyeݞӨʮT6%kZIqӌsIs+6LeFrvvۿȯ2`|tw) p+Od+_5NZmBV!LڞY59mtNF62HZ1qf ; TS1{VQ9C ;c >:t{E78=$#f$|˂{VܺX?wN4qOfB@^$qI;4S䛸֑%?Üǥi+4kZwR{5i[YC(?]5FI2ff$yU0@}k1zgn yKpBg#=J);)ԡ$J̻`,qG˃ui'"]9Kث=!YY%2:E:بӧ#&ggDg?{uiKkѮ$SHy6~EIU(Մ:1VnVg{ov`(1ӚaQ˩>Huua=w}xD5act< ڜOCGZ17n>7;̑ItH+{\y,\2qZJ\ѽcKN4doF9?=1ҳ,۱Պù[]Vg G"Gqw&7)89G|uc(ϕU..aH{MUj<h%i(m -%5[*┣')ԩ;:[,*THp=:gv:u>Ikq ˽k֔e+ZAVeQr#xvO~tss;8|DIyn.fa'kקj)+ت#+(1pnaͼ1b4ϮF'#.lNk'FT ``Qvyg̮&9Vgrլq̂dh68Yև$O%-atRŪ6IqE)?_^+;E5&g ]6heaM21Tԏ.kqkͲgk~96F21AlqPՉOjL&pxb2ǎ1JlzYJ8|ō 0R{ϧvKi3У~-0m(sRRt*.wb`VGzH0x^jJjJ8ǖ%;s3YY;8=*eSyȕZӖۗ#H~#6Hpzg+ s%>~Ks[ٟ̑˴uq2ܞϢ:FRBTcNȳ/K)n+9Iފ3r̙G%mFpz9et TK7!k6XdpV#O/2wfuWA2ܾvɬ{bQQܡħʒOs\s]^G%d31?mf>^;Us+ɬF-h ̹RGNc7#&z(smx 9e)r̔sJFG!pF:k{ѳ4ʝޖ$H!Hq{L۔4}qXl3^/AbH o#pۅ5NFuNH0U$qǵ*qѳIB2DY4 3v[J-S]1d’>X*Is⳾sKݓsݠ?:Tmّ׎Klr[ f&3;_ Zҏќ.kBy8ܬTzd==IjЊхX8:~sHᏴںw,؃<˝ nS[-J.I-r0/*2iRSRޥxveY/^~\==OLwcyuи6@7NʤQGDRxMlaY1N-)TI t\êk*{t[3b%7~UEYHQEv++pfO^z8嵟wz rJQ`.⶧9Z*bHeu[+_a!TP~s|/`U8 :Po-7$>IWRĎ0uǻJj]oh}VJ)uM?4 >[4c̘!J6*i$sYb/%“o6tŒP bAvs<:~[k[uM/o_vY*tRq۫Kן h>Iff[u !eNTmV)η7.NޫFk⭝SEx5ukr:%O˅1 ; y2QRѻ[]e\)YEꭳZ牼 XhX3+I1 +иq5*ZkqߢB1RRY<=ǭ:ҕJMEtۡR+K~ ۋ+|ŝ>U`>R9#'qю1TMVk}b\YGCb9w.Pq'uz,㩤ՠo<0C4w 0l70T:o_>ֽƝ <٧`N98+nG/U0.O~ &)#*=s? sK?><թIlfu+"ޕIB2\Tc [庶h=xUN˚;o~8?:>d{ldEHXsr+j)ʝ|]<ȡF4#~%O;tgC^~0ܥЪ.Uy-,mxCA_w+6zp?nk_ݸb1T8:OoMjOʍ)r$.X2Rr)`1e;_ST[G}m;OA YZ֩)ZrF~V$IbcNqv}šK,wc_tK‹wtFz🊍l 3NVS5&=z.[]lfeڇ=O9=*1hr)jk1 6{¿:̸{:7fˀ#\ӯSҹ7O՟FmϊMC_C͢=ձq$n:z{Hc8u0|[BhVzZmidVɕ~1ž9Z|>g øx+ݣlcbZkcci#;zgUEֱN#Ri[Xj<@ޤNހ|[%)gj:%t˶Q<@刖^5R~G|Ew63C JM%O=1ִNOI-ٞ1/+ ʏ 1_-q%F@8?ZѺ2;Ռy4m[P*/+_0}k-Ӥվ6UOiGu껙iQEw3v{~Z%;5U6F$j):e\u)ɶ7uwx/,Օ[=ߕycRUF1z7KgxNZ9q=?{t_xq{Ju%8moƮw4Gp4b)_~govTc-z߹C=Ya`9Rh4F*ϥ}%NϸW;{3߶#?e̾e*G؊3˧28/ yݷ{J=L=JcWsϗVo-6xq+Qù$.zcF>z/J+h4} ޿)֧yэH52Ot)#3ylː{VI]>/JCcҮMǡo+٥F*ֿtzS?nӦxUhBeX3I`){=Yߩ[2N^= n/,_·Io#\<@V<6-( Z_F Rk >s*pRNzlZkZs6ּ2Maw,*8P88+e^ez-?M?rthU~vU5-mW,C_?S/ydT*a⹣+osu#Mk7dgָ刜Y*mvaG$AjQKH4ZuԄ$q7*.\֩C|vywwrF-6t{JT/KqgsQ2X`{Wyu9ku#RVO[mC. =*Wd*1P@g9bn:8>no/O)Tӳ=O,_ii_f!M$3 Rț[_S8C`ssRZ.X#[ڤ҉6A{WK;7-S8#: knXIVMŋW^:+_"k*R[_CKٶXYfaedd3=< Y](nJ+c)zT?\5c3 N &mGS[2{$м2ruG웽;aO.vv9R_m 6+ qۮy|*a&euc1ºxGzA4MBf=ܜW`{dg#ݛz+}@ t m4vG2 qUIO~X$Mw8Tj{7}/-q#>߮+rN29XnSҤyM<'_ <;q/M'KIyp5$~np9ҷ%U=ahBiid黲LdAf H>*rZ8Jwg;dIm2Q:QR]+sC._~Tnκ9i^/^ƎF6ݷei407 s=OkF =J~ocv]* W<*I)ҩRNZ2pMKhq(ӳ^eHPϖFlARy z4pU%(C$-#Gyfwۃ =QRzpFk:X7߭O)hM#~f9#;׹zt_yKFpJ}6C[NkmF{s1 $c=3]WjZˡc5Mly8[q c#e[< |Dj J :>ѧk>5Yhg,+H`Gs3I?m8ʬ[I=yꭷTq׳j7^q# 6w62FANW6^umZk!3+&"bf=q\NZA5;BKG44Egy#e}$19>8tg)۠{һM4*yd0M8m=52cw"8ntZUY%hmݸ=e+sƄyT_SӦH xڈ2,|vyU#ݓZA61$ 1cX,~Kpy71ӧj?y&&5%ED C;v qzQ|)Ӎ?z[soha4-/c8ї*owm=쒽jA$\埁qEo:|}S\.i)Ǽ@*G,SF7+1"-,vIM̅Ԍھ.+Z*JZ|[{)/ +gڋ+#r\ss۩t-__.y2T)N i_.y$,PkvARIϵrF_cˣ_kw^`z[r&[fmd8Lez-ץ#6ZϖݴZXxFǟ~ՔekJ*:X魩_ykʷ79LVT+Vj>.m%9$p[+m#L׿p]mJ+F~]-Q n>B<{H#5XzsT.ס׃J]ϷT їeGַ.#Jh[u-[Neh<9H:88:f]4hURcFXᶞw+*C7G9rT'To8[iھq3 !w2O98ӖTaWVQ8ۙ= ^׵{8u5dRH_L1={tqխFmoŞ^/K G mTG6MR[#AW@kũ哼S[U1ϕz?7u-aḦ2sǽy1i9*sV=W_sVjo,[\|k*xUJ<&7ݷm]%Ty>V'O1RmU%m6ait?{QVEӺ}އ1 xc\IKXCT#QYbq9^-><Dz×G.0;q8]F;Nms?TsŬsHILzSk9R#J$SU0ڙl,2Cؓx'i.u8V}+5J*ܹnq>u?8*1Էܩ;3J AO^9"uK[s~-.O)g*0X)8߆kP%y;FOO-LVΦE۹#C)Ms[w7R$o\3<֓c$8RR2oR55ɉ[uYz|rO^stuХz>յ繞h՟HQY6ʑ6߂?:Si=.HOT>vB/e(]77Dpqg^htBSIuKcjKĊX,ɓj2fXYR^[ [F 5UR7L1iTZnfGg,tœe߉T擴#գmIvlg8q[պsb VMH"IO.=/ʥrqߏ]zX{f%mmcn@ӹyRDcS F>k4k фfں)TSDȊ{$UtIwfjXSkg^KQH2|LZX7.ر}=E{ϠV,I-]ױ.4:q 3Ļ xiF6H;*U18' ' F/Gs rvwkk=Xdh+&8}qOYcz#Q(ޯXuAr'Nv sCƱF5q=us?arLhϩ2RrVXb,Q̲wDTcNNm=Jٳ g eWpaGlo{xKۉMݻ}Ie|NGc:p\*֞CM3/&0p980y:0>H&DJdi#RW Tԣ+*qU2ۯB`C[RrNk;Ǜ]*rGq ?ܪ9JvzF;Ŷ"|dF i#'jm~k?h$ 3-"&0;pIOZ9yj]39{U!uo{~1o|`Ui$(5'=NT|m-ޙ'~QPJN_+s.۬GfY>cW#8ַN^5]nJŨ)c\Ǟ6ߩKmVv[U 3$#=GqUǚتJkZKO̹̓ .NNմc)/ة9+8]Yp 8 ~c(Fe;bh;3(|x[Qx~F"U^}tM yq뮊󊎗7TQ^Owl6j oEd}~,ng^|fծ"5':NkGkUBYTqgNfךl2ʹX;MDyZ3iePGy4`$ȭ#t xռD'ч^$V;Yr8> d҇iy(ԕd+\HCy{+wUM~dzxnyͽmj#C(wƛR2o֒M#mf4bcc6# H{˺jFsWf 7-κidwW֮imnuQws:/*8#B!{Tӭfܷ ?Nkx)5 MTsJ;ҕ,E7ǘ$e.6"mi|)]#oiw,p+q2'ۚu=yV8S\I5jV%T.v1ֱ-rԕl-hදϢ6g\I3}SѓVtn`Nc]ɹ^ӥq5==z*bVߡΒ\ɒH'9ZiN g{.h麋 ef~U-WQ8YRFllX&FGjSE5TPrrH5"?2l. 3yyf+QV؜>շf$T6BG[f5p9Np9=\^KUԇR M| &YG 2F}f/#q{XZR+˷wLFcd팩'9CܶZZRzWVԞkO<cF׹?iʔUaNiOTzo6+G ;m`9Fzr'fwN꺝/s㟅Amump sᘪ18'`kp~jWij}<ϙь*M(qh| 7/!5Դ>", HVVdGQƤO-4kG N3qOO8oqOM|:ސXѴi'#ve#OFhZw;}ކܡ(uyg(uJždEco IҟQƣvkMow4RrW|{R)o}ghV'w9Ajqs-ߦ3 w r՝۹WFj(4l⹸n :;wU' \}<4%R 6ںߓѧjNTӻqto??Wϱ*Ig5KkO8ap>v @l3ʏI'4*|\-|l]xƚdždi$"dSeea ӕچ+^oUrzwmY>D.k/T˚nSF$p1:VXcU{Yj۹ňpدsK5m%o3o0:3jVZkqTUay@Ab)F9ʌF{_O|1&:v1VfIǦ0?[9efOR^O\ZBdYWo[^٣\C]ߙiќӌVu5ϖ]H?#~cg8S߷ҳjr-iʏկض&SH5Q?i)(_BqZ#cHn>̾ZB۷j/v[]Fi (X׶r#9);I:\t}*56>Td~i^ONJr֝,HڝRJ|+[U.+KwƑe)Zɝx- Hp,?62}Azovyr~c{5krCWKJwNZ7jH.nBvT =]1NpqrNr:L-#J?q]ҌJcM.mm"xGXKy .آR0SG=^ *et]zq$g3;-#5Wklf@ Ub.NW]>ڗgmNuĵuV ۻ9=0{gⴒTQ*HynecN73sg^OW,䎯9jb+%+6&MAO|oԏ鞣jX~- *ay9nM [4qgW)sTaRU{nmxg]{};f8 qy(Rm-:8jP%|3j̧k18T`mU|},w b)[ǖ2GO7NԮ[ΕסRaQ˓7`Sۥpԥ)KqVNXC񦏟 nH3OnԗӛO4>[fPvƠ(>g:w,֟Cרe+|ZH!3*~l`>a9<|ZpM;~G/*Vv} %R]?sK;Jzc'}x/vw{m"y(*Ϋwnl-;-Wuc;cgBiu~F/->zŶ9 s׃S:rW{/Z5-TFa oq"4-Hz׋”4ʥH}cjܬymZcE'^\B2#}{ %n# ``O=y֥R+hө$xgPiY>mXZ2SzNf ({ݷŷiPzdu;b W::˚ 'Kq]YT/Nz\h{J~|;1a%)&c^=qd%W:s|ziڢ ;5J/N>ʷO9aUmPI:!sv:xLTeo#Ӽ+$apnV*xb0$g3E=:zS[I4jih~|Z珞\[S'Sԭ%ߘ9lLy8GJP5F5*)ӗlHcW\d#:u#m*˹:Uh.|va.GHa*Ro8mžנJ Z3KzZF%S埉mmɓl~DD#q }zk%NQRZuGԭJ$o]O'cM+Ԃ1Z֔ƛVZ0<Vua~jM莪8:cޑI5͠]jVr_Ͷ~;m78#9I3,,aQÙE_OF>H։jn_!6'u;~MJȮ)` IfXzjq5}|l/kbewSdﮩ|Gw4* u4 #̣/A ?AWu1߻?N<>u$KFZ;.<:HԤfeӽ8'Mz񧈥(FOSxђFW]Dyk= !^e xpqJ4^+}~u/5=rl)VvHq8rךWzv k撣NVӏ,vj:ev0N|&|H˩O. étHէYpqn<s|W)J~tk*tIoN_Wo$l$Ny&=OiFjV϶˫[mE$J0L|}y<Dow߱QtՔ-hVcԚ6eRE)^[ sbw=ǒ^: {ei6bֲıHz~EIK}ZzRv &y#{ed:&؉W]:[wӝG6iCǗˤ)/Fv1'f 4+F[FIŤڶ:O"GWVM#<)v*9^"JڽwZ eЧWIv7͞ i)WHSN멥!Yf&e\OZҲ}L(ʛvg ??s$$g4>M{W,Uj5cc1U(N_ ^zX"@<;_ WW0JGʵH><NG41XSt:(y*52~7kr[CY#;X{O^F+'UbmuԤhO)r1S/R5-'ҹVgo&41Ħ%ba1pON~ڷ}R3JU՚(ks3Gv֫e {z3B]BqdВIw XFIN{s uEYʩI4ò?)eUI<Oe(tlZ:վ4M A<8Xہ3ױJ.4}s[./+3a ܢ*޺z!Gc ʌ|5pۂ8#~|٨$k۹c.fj=k Wb(>}vFu%'EA;Mi aExV޿)׵hd$W,a֗X0T|.3}jSױZLk~a_*5 a gۂ9qޡƤ]hN֗s%hؠQ"3uFU9-q*J BHQWz[-fєc/g}SaēomER4e&-fU,YO S˥Jf˩p_q8݃RR)-Ņlg)H[ 385grѩH * ُhݷr+g}sJ]nMowt13aq=VtQmʬ? ҝ/]Iûېes*WC*K.Zpr}\{ONtW7QںH;^FƟ:gBmPмhyjbsY"\웑O\T8c?4ȥmc>({ZӼ1yϋ~p8s(9i)4ES;+S-r{4 pF7pp1ʥvf! QZU;rqrR4`Ռc!br~NO'AUFNڛ[0EX.w*z~g.f1Qi[oL+mʤcW3n7Xo0ٖ`I>qR~өQTmۡZKFy[;vdIJvЦ}fm6֢qwa("Fmgue2adU凧j}{˖5%fNpTW?\JR?/Jy-̑ߜn91W'{- #OM n$ "cUZ<彫t1]'zOP ?xţ>^$w1q]@;+K}k5gkߗMOY_cF̒ ܬ?ʷIYIigS YE>og}KU효ՊuJ:GξYb ׌5iO1NNwvW"-`ҹ귛:iԦ<ֺeR$ጫTTk( nWڧ?ww+eZ^DE99;nF6cfZy݇NyF̏vcc:Щ}zcRUGˌ&{ҧ31'cUn?Z797cZp+4$iҊu%{wam#!Fs՜Eͳ9rԐJCV~hԕ;C_"卡Pl^9JrU%u4<9czTӊPY~\G;}Nِ|]^ ԶeBvrںcRcxRTgkڲ*Gok@npiwJoQ}{WTj^Vѧ57l0X|ڧ$uʴԩyEt04Fo BR<}qc?һ)˙zKo#RQpfo1n$}~c_ZQve[ ~՚  'zq2Q6Aq:|іoR'ϼ^]lyI"L'9##tKrm_jIFen.`mpd;Srq<J3n#-|\t͸S;|77'w gcS*cƾ9rS3P mXU9S?߿ȿaGqq"2pە=ye8}ogj4Kop+ƣ^|MRYP9̈2z`JˢOReR=-C;h|rG|ʇd{qЏ´re=[q*1z3rD-#J#WU(F\{)b14cƄ:"Hwݷ y8D}VxeMC^F扢 慮P.b7܎"eN[Q^]Ϳђ;Hc臜st\'Ј7|}KBd+1lᗑ4QӬ,Wn[ N2uKY6O]|qQZ;rڦ$̪O;}ke*48'[})m*+"}m uzVi9IB$GbX$TRˏOwI.g~VFW{l`jY.[]p~<㊜hsmQk[3"̑.9#jSg3OUqԎ{g>lTvhteTiϙ;ߩօwqNQ:)} .mlj FvD%{ ##֝HU$e]#kCӂ2ܻ/^iOQ2u*{4=:F.sҼrƣ%9Eu:& Lec*Ɲcs\r*skpJ-5&uf<b{YG$D,*pwgkU\E9ҧ }sz..6n9*Nxzޅzo~;O Zn-&qda0p}k͗4OJZ Cy"VɌ8^i9]/BIyu0[wE ʦ<(ncVs34J(qjSn +KrgGqMHrKdraNXI)e1[ ȤU?]WN~}NT+98/"S"[ʱ#ysGs{gg {8{;]6刭ySijקCj-amb#6X'#8\Uo˥׃?e/]mbh&XPƮn8Tp8(ys-|KӹS*cNR\H-Pwhm۳ZFQQTnNR*N/_K1Ygfx2!dTJ>E}}J*Dhl%`mͺv/:>YJT~ER!a*;+Y+4 򭥞I-~ 2yEmJW[ӍYJQ\p/y=}5({_}N_XwR[㉞F'eՓ>f/Lr'GLV%h;y~fQIbNw_AJ>l;URT}ڿ+SRM&dBe8 9檭ERKDJR8J_l!XW|PθZeEfb>|㠮qw*<ЗtGs:CYӞ=kJu)(>w{u+@e1 8֑>RNh]eyɔs0g ZƯӅS)h 6RfҥJ[]/et 1*IxiErIO j.l @9fZrWя3no.dؖi'>VrL}Rw$Io.0͵I 9+ҵ8ӌcIgf\ܳ?`7t'Vr'.TJ:m5g K*fcJvR.Ng:?يyJ̬_sj9T#we$X.&64k o;A#spYj/C(%NkNDhiq+ǵUH rF(|Gk(yٕٶ8su9FN2%nӥ oddk)3E\dhRTMYNsGb>\̸vXJiNDE:n9$ ݴu#V9T63uYVܚ1Ө-^ۍ#K(]ͷ=*EɥZrw{-&g#V@ln2}p; 1 t]7ӧ{j#{DMH>fIyxbu:C5m-+o 3~)a`]kTgF1' eLe8zgzWT1st~WPM iݸ7UGR5/'aU|LʋN34UJ 8F@dTId͹p00=G*a?u}P{ffCe*=`fRoŵi=>1M '߯i*ZOԩUi B $|Y~QSM[YJtVTWC䍎$uVj\l84鸷DM\ь.W5}?xԾOT u-$HU[kI=ki9/gz| q*!eFYOxWm%M(SZX.fk)<7  9#OM 3#u,J$=;S Ҕv&wۼąnyKT\sF^)_1i!Fܱo~jR)'ZrkElŵ0H;UKЪ؉Eشy37Lnͷ';~u<9[zjJTqޫKB6A~Rzgn}3ZFZNT[~JoORnFֱaE)TCvh1 (r3ONJ.zE!uo"m;\$owЧ)]-;(Q4-x L݀z7QrZJя/*&)ϖDeӥrzDJ%) s<mY;I5u,oVFnU|}?CEAԏ/4 o%CUv3nALzUQz'akYhP]+\<9*~B\

    >f_=f-Eިs]}P2 U#)Qhbm[rt8JTdƘYğ#9GR1WJtTco=7#XR'3.reOMmFqI:4."xp3Mq{ͥs:4#9'r)0G&]3VK_SJJT>~q׏rִVaRה+E\3fI7Hr?S\ыӗ|P:s3X~cuI)[\5 o_LW3"rbӫ-7Էl!p?V3d~hYm$u늯i)ǗHiu&W_0/,ZNqsZSھ8 2OsC& m\Hk)%KWgV̪S߿uMk[E{yI`2͌e>8TQSwSbE{My:Ti~$[VP@XH|áR8eӌWGQg%dnv}硇bʝ&Ko>͗>4] +*6rNL۞+han=ߢ})Tu*$$~?YNJ#9@>0x$Gr'EƥijW;>;m=<;FĚ=n"Q"o+| VfOÐ%kɦGdɏe`p3Ԏ!GiG݊QG1*Eohg67:ry¬˛a9'-}91o&}t:5^QqnN+ZHĿo,.{oPmqU -=k]j0wA{ѽf++&maܸ"8NApysߛVNiFoCc)pm['R '`Ŷ >Q\K͵0+6t:ֶiIݝNcxSˡv=%FF2A2r3'[xM>qb ֜*B>45-9I IO2jv02ulqGRvЌqTݻ߫v?HV->k > 'k纆ܮ#F@yRۃT@S Λ{h>1JYW^{y3/Ά^%bы2 N1|LކO4qT6aiO{)eRrB3}yK$= MJ2n][^i'MG3Uk,ppOEsTJ-[U}1bZeۦ_,wƅ扲ۮHyW5xښnQwzu_ F-mZ =tgcy,Vt*XNO.}Zÿ2.I>N+|t{.Gv3 =Z3MŨfl@#aIU^Iԏ:Vjzx75nkVMnfk G'`992:]T)3*rz_;Gf>k &cRwG OfO(J5(C'gYLqC`3׿FYFVU*)Fpo kľ<9:jوd(GG T`ȘpN3{ҩ9o=OO'ȌvNM/~GD°hzjS?1Nz܋F*4kb8]j.:$@n+:ԡ( [%'CS+r*n';?Z\<=fYDP_]|tdEeN^;Џ/m4"]FD cVkri,y 4ѭb83WN¿&ZL~nd{G`ֈ{ua=zE2[]HjǠ9aSP 抯Gٮ"f>qYZ>=O.*XM_ΒV9u!w/J*ތgME^edyc3gEiДydeRrd2,[=+ҍ{sd6'sZ Ƭ"ӧ jI$4+sp3A5,ESkS"r}ˇO##̂ eYKҖ\e 47s3BXr&ObQiܒ+l' o[Bj[l־Eǂ?>2w7n+9W*xxZ*]9T20oMOLtK6#wJ8-Q(7˃]-]|4jJTZɄ;KviZMp+"V?wMI٢븏wF{֦F:=b)KgU$.ۻq^g+Ζ*7R;w2e=BŖONؠGViU*|P+QTU#9ی=8a}qRFtQtk=_W ww~'`0 TqWvW8:iqo66lH[#F? 6zcס>ycȟ>-.m?N]/CR8h}ѫq^ ?BZ;ii(,ʡD!=QRsR[dGaowXbD 23Z9{ EGԙFD<]a,UpNx Y]?vWC1[gx.K ܉ .2(_~=On[;o..l-TKwp-a8FH8>(=F&9)T3XkqQҏVO s9q (=~=<62E$t8hӍCWsӼ;WұzwO{:&o5ZeK[#cS[Q1UfN׾}xZJ1eLNI]p%5T !i6N;;%E(ҔvWMQ>;ІWdɻ`Đx9_9/gYTU֭3<5_NXwUIJGM>mcOѤcDA ~Fis9y#/un1%IcQ`v>}W5ݾ .X׷SwDӇrIaEʾּ%M&ziP9]>Oq"7n{j\Xէ馇#qRٮn#({^ηŤԽr/h/dգm|s8eJ1Mɩ+^4=_⟋6w3nILVnW"/>9u磷rXXZ\u~٥?''WӮjo\~8K,ZiߵV}E5O cþ+Vi7pQH<~W-LDn-WxY}6_mh^iP(3EՑ[hn+(EFOc^iT;|g3f4 M2ݕmC0ːF~ jo{`\v^_O쎺<)-u4IIIw`j7 6X0yXSz%ĺ{jirZD&pU8c_5[?^d~gUƣW[WFl%Fpp~\uFѬɊTU-ӼQ.YrzMtF3+SHͤC.7K [=ö?2į"C#u߇**駯|iڲ}N׃HE"/~Z?P:w済źt۞*֌k-jF mdXnH~m1zٝ}8-w}>򾭮`gmw̫JJmϩ 36`W)uHJǧz R)ږJ(}w:K-T-h]۾VJW)̬cb74_ ߔ67qHF RSIƬ0P7t6r>J M*2N9jŴ;=rO>cv`jB5uV2̪ITM`oj Xc2  ҮX(֋K[kUN:v)j|E5YX ,ۂ,#N@#99,?1rjM{}\#l4{KONtѴPFr1F}OLY|TQWW属#F3j5kg\/Ȓo06"$~ֽdxa_ ;p9WLMI{4ڏn}_i^:?~:-ßv| ׸".8: 8U;T}ak ]#xfu=.pe/H `p6Y\+]켗OvG%97mnڲm59MN8res"RfeJ) ff34̸=7=ft9tˉ,wb%lufNz;ʚiU"j*NrJgRgQJ"HfYtTj~C V"{%GF<[80pO4;a>NJOw>wx#+c)}qZBX_$Ѷ u1gNG ^8֖U9өF"1=ѫ-m"UR 倻NM~Cջw4mkCy+y+33bO͟{~*I%ꩌʣM@-ӂXk/ WFNeyw{dS?~}/;l'2[N4ky-x"UQFcQW|5n5Hx2'>C^k{zv!oZxDFSN9,Zjh̤{Mjj]?o繺%GU|ÎadYPr-|񆪱j~+fknT߂:zgvF\]X|6>x-o6وelF}z~kSwJom JQj|kq*0|}+ R߿C;k4|9$2E-V{:m9TOfj8sr5n駫=ƭ9SҒin4kbԷ]yd>`M !$ gZ:tKGu_[v#4c}z]ko]g⎰3\]ʲNAznㆍl=K'ugm_*h>㦻hRy=309>*2ZNuJ2uۧ ;6i8ˎ]\nxSR [~G|xT۵}?-4}V_k5xX|y;r15yaZz&MJ+Qv4_v_7QFVf*QW'9@rGy| q:~϶u;QO*(|8b2AcܟZvm߉ˎЋwX6 6v){j-oi*J|O-5=tF ʨB29){E+Yf)Js/'ӹ Жv[eV`\a #=IJ^ϖ19m2/5Fic20*|U=`u8>zT9iKj*t*IHD #md|>VqRTy%GqtFvu5lƾʞV16wy|]6Ν]ӂӱw ֗ΒV"/d#2\{f-7{֊iv{5%?YcZQٕ\qMLkWJN6,iJT+$\~JNP :\9>ҜbbؽiZ]7U#7.à#+)T:[!RV[IL\4\,oona~oJ#օ[ٽxZru\xR w%f냸eA$c u!N^Gߛѭ?C.xahWP88:שop*k?1 MSMt@#(',y`BhZ$oNSM%mmkmޏ1dpMI xz}놥ihV-Z/4前#N8x}ԧҴ(ΚqԻXyx!7- 2;?)=:JzΥKR~x&K6Z{˪4c%שn?gvZ.<],dVG)Hd+}Zm4s4#NF X$NH(ΣFJn+F6^SڥIۿGb># gӱ{ocj[c7V1]o̙)^ ksœhO̱.g4r:7d/'/ӑ~U.yӖrܛMľZٗNHs_:T.w~ :9#$Ȕ#eE>Y}|t<֘'\:Ri5gmi*gnIӿZ拗*tQNi|גp\+υubG͝èn;kJʹwTQJk]F=e<趖;_n=]R9nq4pU%z_m8=\39}kA磈RNMYL_"d;TeM6Q]jjʘFQ9+;i!;cܑGl޻ZKK/' ;VK)hcV]mn [To~b*fX'YYRfD,j̍}qvSmmJ&f~4Hf, pHmzѧ-Xʱl+>.ek+UYk+%2qn0)5޾O"Ycr$ S[cݽDQO-B`mG*;znǦIK{mxGV7al# .>vt&(۝׽%;k ۅ1ӜourGٝNjQR%nԳѱf;L`t=#ԃ2D)vml)a|vTc6HMUX <|1x~KsJrngyoط,oım{WEjjT#RtFmY{?vzNymo2դr[^[aY8O\V5)R]9{]/!xlEuby`rOTVc(([pL9 $q/ϿL(Nc:qwćdGc* =}{=gdV\=ڡs(Y{wR#]FKyS~BXrH>eJ.+}i:K–aZ :dAhyƕ+T֩Ћ&Y?2f.FIK}Nb#a{mINÀsq(77a'-6[ۉT4kt\wS*QWziO#_m2{Bs-iSRz#>9:١+&e`ǪsW/eR:-CFQʦHD,W9TPҍjJV^F}6`LoeRi4t}˻+fecYh`۸?/Q]KVi_KrNFY)1y$\uZ1J1ҡ\˨^ fwy|I̍=#ߩBj<㹕*kF;_DDbVE GPΈ'ް#JFܾ\i'[Ԣn gWV0+FZ\ܻj4in!>[_,t\5i. H qVN~ΝMc^1R]446 pF1E+^+-J+/Ro6#.79)?m'cRZr_*!a3dz[sjrRړo£@>KW\+2,;|=zu?w+cӌeibhQm~>fR"prTuk5-EiכR+Vjvf<&\Qy]Օ9Y/OCb x[oV>^ݎG8?t7R =[A覷ZHA򎤌j11bҾ΂ue ɐy\+aK+rM YxV7Fq޴pJhS|-J|1ǵhB1.Xr; 4_eGDTS̅7M8K]IVzӮ"n̫?Sе84gk3Kqow"aܽU*k *ӋZ>c9xi];7٫3OjWVcyqpDF?)=ʥ:|}k9}I0 ]moigk$o 0˕L>Ֆu1Q]مOci]-WgZk}̎e,W`K8W!TwsIFvo.KzKRT9^'M}idMY効_) ,~T6x#g}/Fi rUtVUh魢-g˚Y33dnQЌ`޼tJ=D屎"}Nx~euH*% xӾ+ʕj 7v^mhyώ g~ki695UΟ})0H` z`eקӈm8+~~GϿP%дg_IsCm$sƱ 00X4ezW:/]̋jŕ||0wp8Fc|,U?iWάK.r,rǮ{ieO OԟFq422}${=K|()vї".̞5̪$$d8u9kE|)iפ!4!߯VqV!ђXtK\`z:tiO7 ng -g<+|+O# SrM/u/4%,RGpWjP<ϕt89I5-8UM~.{m54dEVji;xwmoo/doM$zm25"ᘕʤۋsdrK4MJΫ|XwpL'̒Rf]׾J~2W]JVo"SQI#ظilfG?\XiT޽Mp}l4ڝȵco#Hѵ£N|T0#4Ӗ2mqQJKwj>u;+Gj^8F g<:㯭g:LW.wy0++ʯAzzsiSG zmDj[6hHUb0J@'+ zQ©FϪ7kkDr-.?v'vD۳1%p8#ު>ZrKM-aک-SiVW],{r}FuHWZEl|IN9ӎ+i7=X˶Xma #+קF2!)K3vqm6oy12 xZ1"՗Ό?,|zn<̓:x9'N*i”y'W~WN ݆q} ʤ%o^<\E.jֆ]y?e #O=<ʣiգ^u-nbRDsm:vK TEդcKEmᅕY^m`8 {Ӳgm<^yזr{z?{T'MFe~g{8|{UWV[C oi4CnWX^&TdKt ͐zB窲Ϲ e%}6NzF$z50ZL @wB}Oԗ-I4cOK}ˍ%r&vq\N2C/g&ṉL`HE{8 cSk͡`qRοR[In'xӺ*5/2+n=ħYVn:mgwXDflo5*T=M(jF ՐIW_}gmB);mqN׭uoiq PY1s\yFR~!U&-sg:w;Hƻ;UV7:ͥGsN#W/Re FF3RN2CnR9*nE r5ьeN _|w!Ti&2ڡ r6Oӡk5~R&3 ׶=gDYվej$mXT=ؔFM__jQ֑u̽N\t{[4S)Bxq>){f Sҵ#~Xuu#D̈́99Qm:sD$׻S'FǗkџH.5xJ} hw3lI} 91XZqneuV/6FQD[^/ηI&ukX܉Xˑs9>!~i,^F׶LI\ЈaUm\ըշ>"nRPnncyǧI&_8h#;wweZTM͓s>b? ||M[-rѳ:$-Pma< f>Oum>Mhr1;Tgݸfhʯ<[RqOծ__3K=S ձ,XYF!=\LF>N CҧIZw}z8~Si?k4R+!x5_IBMTg_=ׄ ڭwZ9BTԱ_YεL"6jT^ޯ~V#lKǷf5s,)?w=۴6pڲ\1u#..>걅Njr-ebJ>ɥx[:qTv4KZx yDI vETgWe}I 6ܨ{&ʍt%̺ eS ql3&x9: KZ7]lj}B;0𧖬bXK`njT(Fϩ.qg65l;;o`lRrzh:snOi3]y0L4jCL͈߹qjNIK6OW`l$ 4ImPu#"1jq%\%Mqo$-+1՛k` #"ye.xfDFc98}ިޟ7=%yıQ`gN=(OZT{R׹Ws+vر-2%opwkIIw8taί+{yƲL,0]X:{.eέ}Em-ęONt{MmV.4+ndwϡ#v5ܣoMcd*#+2 #BE9-X7bnVRk&T,] 9<تqWJcDVszq9^iNm9BTy&4P 6~f^VE#g(k(Ûgc˙;Xl$Ȓ*dd u+V4ī1bYp[z:ę*|Kb-IDVEPWyҜe*]jM:5t72)WXHPN3ܜZ}tJ6:W3n )-׌qO^Žedv%2aY鏮jgchǶ$MWiH`/8$j攤gRymf]VIdiiXX %ΛW2u Vm%gxy$AHN:uk:W=ՓzF7uѿ,6Tx$VY$G<\6] Е˱$C,O^O5ש#R3uݕ$?y#mU-*ЧJOqVJE7yU[53FFѳ1;Cdמ=,tF0TNoMn bHSiGNb*sʛF|Ed"6hsDFRZjա((7u6vW;ۺ\J2R필ǒ;KI"CUlWMJ^Nj;J-})2\rTG,e*wM$mQxYrSr1NS{Eݛ-o >9JQeX:yy#JUcNRZ9#UIm*1gђmnWRh۩ha}X7+ZEqSI.c΍IF/ݖcbD;K.x\9nhY-Y UPyj)Kr}9Fձ;ޗ#ANTeʖSM7Fw{]&EpA8Uk~R*N9IYyQZ~Q_lʴyo%u*^{Yyz!õLs¥Olu/8Zw?.N+J.ކnj_X8G}6+g!w7ޯ7ZUs%uhʥ;._vdmB!*ܑRiɷ| rs2~)EI{=5ȹoA8\/ix*N1k:6bS 푛3ng7Dь-z{zDi5Ul '5~H FQM]$Lt6|#ܢ/-\v9ɈӋjކ\չ+>#aKH*򩑔 0>b1۟_ֺiԧNMj^ﴂw_u-)>d+c |IՊQZb$ڒ^6([Y(3NQj3gS|m-`Yƞwcc'i({9+|'nƀHU>cG!d$tbPy[{BŶ "\KÄP̤cZQ浭}ĥGHۭj!Rd5h³)§ӱڏiOn:/{G4Qn3:q3~sGٻj9ɺYvF)^XL@cץrT)IuQugcj .х\bXg^ 쒿T{={s !,{m{Vҩ4)KNrZv N7zWI{Vxh/fM|̍NŝY;){~r8 NTcXF^B;Yd"\M Y|JV\$w(7('{SӒ,J $=;RJvr~3xNSWӢ*Mu9V8߿cR$zZKnNݤ?/ԃWMDinw}!3q Eʣ-۹-ãF6n<ף U*vKerhԨ֤L4x&ٖ<jКڛJQ?$V>$VׯSKy.]wZ#`2¬YS.3fj]؜DڗMhP4dca.\.2i#50\ui6:D30Xh<`c}MaV4]9-:QYwm-.h\9AKTsf)^fYeڪw8u\է(J CŧV2Mw(Dl?j*Q_FkZiٶby1!A=s ,DެѼlZ}HdhّH-&ÌQ\R1mqJ._\ܐe do;u}wcCڴu}w#Rm+FV`BG8+tvdя u'{gDj{8I]J%)-d gUȯl%|nbIUXsz9*{M*Ijzp)Ty_ޓ DYT\,S9Q=zg%$M D*a6Y;H]iaq0qǸ=LD}&bWѯ"h0{uf^1d*~Cnm=_ķMlLv(88p8t]ɭzyu`Z켽 iRM2oABml8µ9Ri<-Zm~2;pC7I'^+hSTֲJuCm卙Qb:GZU{C`٦ 26a<Dž8<Z)byafNRnx^{ #I4#.eװ۩S pn;r)g/6,x89GPMhtTQ.ȡȬw|93-1RfBTyj:N?ҭSk̮jQ脙.cdQ'$ҫ1tLiѧIYLmol$Vxz]E_VX 'mNZ٫#(VtW G1e}ҍ(M*%W1 RkLѝdv.r}¢iUSkm?rmdo1޸Pik)Rh/-qpudWV==@'ggQu+O+#}'TY |Ƿ嵭ʚnL%'eFf 9G~ yԭ ݒ,7j${ͽۗecnӃ7GedeB;,eA֦5M9NVӠL|@<\N ;TƟn汍IS#RC[M#+ nnFczzgcRU17n-[@OsFW=Fsۊӑg'k.A"!܏OiF4В9|ד>Tb9$z s%}Z2 5ƙo3ZDN\~PHz)8Um5#Qb"]ac 4%YbvdUR~G'etJƖry3W;5ӹ(+,fA#>czt97tMؑo,pSiݧkl7.pG}u+0>r#s>jsQ'i0'G'oZF4riwr=[iP^sۓZs*r:{(mE Vqeq8TVR"S܂%(ТMq@7mTӌ{s8Qr,K)abX0\3zVcfKYYLO ֈRzc.i|]S#7)$vQR%''BYKąQ0K7˴t$tjf*0}]FH eM90>2V3*qzR3'&d1s'rƔjJ۵ QW p_LvT/GVT'fbxLFF$ 3rWz^."5SU;ylq~4)&J|ÆTn_oι15ԓmae<c2:)A V2ɗ6/ҴuOS4#T\(|Uqoq.mnNUm1i#4k@<}rr#ϖIr {['TܹoN?il"6ξZU#F̥y=sT)GSc,Idc=O>Q%+y}5ԒdL3̹9jJqkrUX)ۻ&m<hF"c2u⹪rƒ/'9W?y|d)ϱ~R*QQz+ANh<+yגs<+l5oM1Z7EunV8crUfDHdr_̍oǏָjTq]6bOh=_oιg#ҩHdmmOdlu\CSQ`b ̻Mz)۹)TаfȌ {ƣ2rIKGyP3pJ2TtԹyм(Fi#V=\Ӟߕ'' '/,Fv:,zuW2唝Һ-+HԔvSvګGcO9y_qahXy!N;wOіm٭%Yf_%2rAOu<{yrK -.&|cz[IX}fdX*#$m㱯F5%(|K]mtwsOG}|Dž[hI叴E  o?>㜾orR>W^Vݺ[S3-Vׯ_߇. }WinfV2:~sF;i6ӧ*xTWe߈~1.<-<jb$ҠwOpO K]6y3'%N{rkϰhJz->,x:sK3Y~&&RxQER'0@Qھws [-~kZe^/))l.d##iОve8u-JWWd엧ODԾ_ÿc8n,n4n%۞RuC?uvF5s/vJNmgY_V1ZrlVQ@֡?5fqN3Qʕ]?gpíxŚ4~cY@?tg''VIʚi^gcӌ"[Gzwu_x{O:e l \sNG矮=}Omon9$em:tɜ9ֽF2'硞T#Mo]i?4;Lw#rG 2I5rgƘU:IЎ⟊~Me4Kyiծæ8B1]XlQ毎VoC?06~شYaʲC1#8<^YznL%RU#ZZFKǞߴ& ?H6|0@nYKUnպGeEF뾛۹ռKq[^^e;]HBT1@<'sz׷R]_ub`k=͏ڏ{H?OM^"Fd+`hr罯v]ZV+a%1n/bscі>yV_wu~?OFrfe|mp%im~k\F  _NAs_⡌qwo'.Z|wri߽uMFŧ#&6~SuѬr}^UIŤoSA}z&yֵjBy$o6a%v0`J1|]2{( yV#)ki쎊sr1suGA$}k|.?u}G_C+ #\>#^37-j7k<~Cn {8M 5M wKK$~nsF2U!+r~efw[YFTՈXwu~J>\butH3\xERKu Aʜ*+{j䩧r!TnoVO!/cNꓻ,iz!ݹJeFVFU%/h5ړQ&*Z"u#Mtg0QaG ?.ޥiM$yVT*Ju3)4-*l± :W7OG[ZJml_3BEm${&Aynԯk)TikԼ)YW |XyjQzTFq!ke hxDdԬc)y&ֽ &ꑵM7ʮ͍|ZГG^0$5}"Mleܢz +(MmZ'V˷t>s.L@[מFۧ&"Px_GԭAy44W[+P7ڷ|[N8lsTj5&oCTz4W_fa|XZS̢տvyU[.? .;&I3q#n`TH9^n'O&z<6i*4]I2H 9zׇF=ݺuoiZ{tM>x[6j}9aWoiQᬧZ;m&ogkpJ|Y'$F=8c1m良bt9bi!Uw]k̝fm[S{M<,UHBF.{3ڴ΅)~-_5]zhשVZhdVqǭ{iMF/OCzcf7aV8ZDTT( M6=_H5 Y/ ɍ63r9z:UnxrͱR(Bҷ_Hq4EVS6A89+MI)^?#2jZgJϨh>V6̽ .1s:%gt6Vy7I<I`r=p5R>:<-wĦx0IZ0Ѷ2w}WU=J8~V0Tm:zj5?\Zi77W2I5 ŋ6YN1EK;YާONK|N4oWmGQtOc2V'hp잏[zGVb|y3teR|ƕyY(R+=#h;lfiJQ,DQP_yJͺlcwM7/9TtU%)yG][^:*4Ҫ*:0Ze}k;Ŗ$3Yps/]a(ǩ4œfmt:K7$1.gl-o"ȫ嬋Dz t_RI]=XuZ:T*&7.3NS|Lj5dx=tidFۺ4vErAڽμ5aV G𲃟qJ%nmӖΧu-Fm7ðƫc*&Ӄ~**pqzJ4ViOkYë1$k k~=2Succ>N'ջP{W:"PܶcsuchE:Ц*+ߪ8x߻mʑO^qޚiǚ0rD~}]}]}{{ǔ9wLFLKgEQj_[,mDQLq4fBK7}+XޤIT\ԸzuęyuϨKJERE AZpyF֗cWr)E^gDǪjPq^!Rc<;4[|۽5q7xErF76 z`r'G^VxZ1jeM),Yڪ!ڼ~Ub.nU{=lf#ZR$o괿[5Ri]=])֍_hy_V9r]S\ԵMNXVOG;O'ÁǮxBJRmGd*Ftg ^q Hhݺ`t?*-LC]SOoSUq mc%2Hx֔֯M]{k*ά-(r)[~gx_d.]cA'^VVT {ݾ^f,a 6rp$篵x(Կ5:jJJin_!>$kY??1j+*1Jp2sG8Ԕ^Y$i9#c<.]?ZʗwȊą,cښVf38&ӏM,;#vV&coN[8_^Ҍc9r%~SP-'o-~ ^quuv麒_*i>Zz]G3<{f1/ڤtzwZc͢<ӌ}B2yq^:tУNiK66BFUs W8yUx^?j33`'9pkxY9[z~VVu3|C㧱uf`$*wco¶stat߷TzTpvשYr7 \GtXTL\cUэu~hVݫ]H[Gk2Nΰ2<R>K]MNaokX,]x*u%w_x4RIJ7u!_m dlyTu+/2T*,Z9DWO0.cߵT4[ϡ#-u^~Gx[:g}"DC`$󲭈Z-E;Mu&4Ca4pW<hTry85i UѨo=HㅩQj6A-#A>% eQnovq-{G*:=<ͣBtb}t0ln|_$Ҽ-m2HHKxV'ӣ{?_˙-#4F1g'SrG9F픥RkKXwn|=e7ٵb3M9RPVz>դ;0p%s}m X0(`N |w.nYY%۝j+{Y]sC揌d=\82m5י8&՟x6-hCxk$ǒXWKQNJHq>{˧-ؾ{/c랠w+gR.Vˊ*`*5mg\Lv|JtmR\qZ3mNZ5V"1rŭݙ^lwnm?/Z\Dj{XJ/6KB0434r(Fwq_jʫ^g6J~ 6՟[[`1Gp]F犪u|}̼BNY֞Ivi!2xCzorJWZrԧ^\\^&Ē(K{?qۅF1yREk̻2Aۊz+l77mESw*.cg߿=zTchJtINj]F sQk5#R4zvm6> HƔb']FľjckOA3]e/lF@fBBϨ~%+4uT6x'\meo>k2cN$& i۬홺k4=NRVz#`k 3dT(?SϭiJL3}[.Z gS]5r0(ek:).@]7  뫛QNzioN6AmmŮZYL;qʵb!R?sWh-!f9On{EZvL^/M|H7qomm&SRF犟gqJ蹶V?RXeLwclH˃D)]9N^wkp\?21KI\'n~VUS Fw pԳ) ^6zA{Uԩ(ŵsjao݄_nRrv扡Ta[s瞽oj='Sx5~lZxKPNSVҪ}ycRX 7|5c.Ӆe+'"mIf_?~QrKT/wksҲnoAǭƜݓ_2)KmO˟Iqj;yӣzɷ{- nX[o\3mд%$װ*ݷA2s_[B^ʚ8PR{4#LE%ʤʥ-8X3mG wAySnjZiUVob~Z1d\}iFsUԦWy$o >[2Ez,y۩yybhu;"8F8ڣ{`1׊4Z2N3Yd6ܨT^=ҏz;1:RR5vKB˫2([%v?zco7sUg;r&[hx{77S#<ZThd,UùSZ2Hq(+mc4SkztkV Fzgq޹8KuhԞ[멹g6 9Wef|$kZHЪ?|S'+MErymCpzY-PTRq6(Un=Y5M*iYvAk~i?@6\,XNu);w~|ǥ8p!Uou3sKJ-IWsƤjFw:ΌiIT%[L7|1VtjQeK-R-IiN/&pQr8³QOֳԦ̋`drٹ'aN1}t5-dfA^G_˨&}NQm8\Ss$w0[In}jsRYi%.29Jddqp3㊯yQqOGJ9)hG>W/1ܮgZNN_ Vݻ'(0nf)_¹-%.ڑ^59e꼭#Cov**n9~srǙ=ɥ*ձ.5f-~Q/+q"/8kxҋ̎Joz%$#Q)R4z|oDOtEkLɹv`&F>8q`qKߺ1?i7Xş.G-d`HъN6 }u߹Z֒Ms> _. }k¿n-w[ƭ#?/Ž3RqáB%՜ DONݧbBЄT̢>}|e[$ս5G>$D/4y#O4FbyHUXm+GK9JT%Cm7wmјT'${ko[k&}}č 4 r 1XW&ߥN^*uotC֟oʤmĸ)qĂny׌yfLKht{ {ۭSQүՃ7poo0ܚF}6] RV_ߊ wjk5WKvYn'w*A<іc+Fr[盙eƕzM{m|·ſҵZ_&o92nXӀ~_Pkb"_Տ/Wu~h{.gϏ ºQEo!Wn'< {W*a}+ QJ30z6޻g~iW F& CqۀKʞS[hZ84*jI5z;^/5m=n$FF9UyRG;}>XzU۵`処'r}p5Kui!cEkȫxލH:i.k_'{6é0vi/ܹoH2\4sȾEvypA'ڕ<,yomVvԥeFe:|}n㷆d;Y"-#oZS{SX|ċc 2e,+~|)TBQ],Dt D{5/.uIo zĿoᗐ@opr)P>lIbehw[>?5SWմb6x#/Lp0PezX)K8_mcEkk?UN}N;Ǡ=1XI$c潿!ߧ#߹Zܷk2ekydg$S\OU<=YaNܴhcaoysUbQrJԊtE,~.|,xCێ3=C^V~IYkSG!Yxz- ӎ{U_e啟6J'dE+Is3*&.eeHxz4;^Kͭ[Q)M8ow}wۦ4Wj__-d6r[-$UrchlǨ=qCQӔRT)owo>GC:G,5\iL3{H $Gqv_$^= X=EZd*/9mmgҹl.(T^d6[i p-wT+^އtaM*r,\ypolAV5RK8畔.B_ƳR>Λίi)-dW췓~^6Q^i$I{?F<y?g NmV%r{i{ۦ}9z {sVRZiFrRzLJ[DOF/mVb^:z|Zp]NJ;$LhL<7 ')JNISF// CzWۢ*FզiBX+Lx\U7J[DbO/3%%Y[}Q/:2Z8:Y^ؙ6U|KWԴȥ6Gg͂Aqc=&ГQZ_xZ9FOkwg.}o}yT<#Wԭ-dѧ)UNI#?4?B/sIX7?wACAv@r]4=C5WEѵ]NDKksxuk:*Na)7SH]B_5<$ <:lʤnyJm(9>оwk6i,$pq8=xSEkvFtF5v3< .g֭-_g,v+ mI߰s4,.xrkmW+$-Xnc'}+1:I]//3)ͫjZ[di2s JqZ+[x? -qs㫭/Pxmm/. =~G<Ö:qNLG ֥쯄/处*y >a)t~e[/Ŀ.ʟ'5o@W2b6N鴁ǵcNK{Ibi{MD/斒ls뺥G"50)N嘆v+HVvVl2FϥsZNkw}>iXv?w}ITq~f8DRW-u5+.]~,}=ӕΨSR{[ $ Pp9~>ҝI$sVWO )$cs3%IL[zu#y=֭ >-u`扸8*rtyTSByG1#?S]\tb!9SFSp-ħn2Vr9#AOF4-։y^Glm8%NTwP\.9U;Us8uRIaFD7&Trr={+oih[4pm"|qr~TSFqP~cBFfę>EjM4#ΆGfj fftYFVR+L$ѡV^8ݟ_/iV1yEň'3Y@=֒RQk_а' uzVj4k$Y'Oj܍]Vv,1Ywu9O<9b+4ZhɅZ/|Es]QN[U㘤%vJVhވ/8SZSe#3jDc-:c0ݸ1z}rrVS󬇀2 '9>%5%g p-?NoxU9ۂo#&]=*#)smNR n-!-4QY#(r^ rgl6+Гϥ(.Y;-ػu0{)GhN2RO777v)ϡlمT- 'W-"eorwQITШԌ%+ĔK];lr,ċS=},a5-THtq [> aR\^ƵJh\f?ސp#9?N٣r2Z3o-cK?)hc,Ke<~U%$Ԫn42Į0,}{{psB>Zjk0X+V\n'gAg1iZ IH&w7˷G拶rRWR~} }n\M2Q7cH9N2Gw=c;\VmC1oNGj4ʴ}L_=)wFeb gn3=:Jqp 4䡹p$m;uxQ[TJS;m+_8~hT勺NTӂ׳0eٹ8QyI[ZEw5(g̭7Iˎ_zӥ ܪ<sZvZ  ݫsyǷAҴk+[2kT)NVOEȶmݐwqⳝ9nʴG9۞ppy(ߏ*8z~[i?v}sZQg^AdVeP)SkXNv1rzQR-DrJӖFT >+|Ǖ9+ZT,6:ՍHGmĖ?%cy+i*љ% ֒\f8NRz>77DF͹uGf1qRDx.aUm֖"3?uQ)Ik2ı$?5>]IOIOVùFU(ʤm"q)^qo%ݖ"34[:j6b\ܼƔdDF|7,(c:йj29fڷݹ%ҭ)rKTaZ7%ױ! R1UϿ֫V9刕:+ll[nycz3V6fdCyr^UI גKRNjoCbY-"^aSמ?ZN*nuǖT+niE+UrhN&X|UwF:&Zr;DMFC}:5+:/k>lyo0e+2J3vTo%jy?)֣T)23H(Y+)8מ=>*~*Sќu0r}q8w MiԩS)XOcV:ŌF7c_A>6z;TTfGS:s6ʵC/P&ָf wX^Ӛ10Q~h%bVeI`c\^Ί%MKX~qJNg* ՕHmZ[J~VvĐsk 4} % -p8W确x:rm-Eo#kK.{i'vLBvǧ=Vӭz(]uZ^@*4jF̣99MIC(M*T^Efu:$ܻ`z#cQ/7um7?ҵT?S0xVT@b$䓞A<#m42Gj,̲nU ߿zeQ]NhE5fF{EnJ:NrS3=-o2DncwqYhHڌFMF*6Fz&TSNZ;C2IdHa|w[kd؏+iM̝W+o_#"՚+lng.OCSH:u-*DM&gO*F˚*֥۴nCHC?U%*qeS>U}9}zm[FY*3s1NkTϣK;#-㵾㙓KRylǩdqڻ*I{>h%~*x|пkZEHl39lYjxk%J6NM1XF&Mf2=<9B7gNW㵈R.Cm5S$_]B?UO}?'3+nݻ:sֻ*1*j؁-[ 1^ZMiU\[JƕyjPUgOCOݷ|SBU$얥aF&л" Gq\gS(-''f扦Fd ,nhk r5WkŽa/٣LoY ϵy +UWSҵde2A&LrN0x#k{;&pc=ߗ^卹VKAy*߹vyrq('F3G}2\Nr^mqeJi˱²yVio#/'S$pyQE{ΜKMq&c[Z5c}vƝz|"iӓOqIp iFUXv cmGO|EAefY){Qǹ7kʽ]Rѕ쮡xhD{r>[݆DJGx3H[1; +l}Et*MYyc\Id1{Ն?9K-{by$,}'M[~̏J)9ѺKrq LAao‘hT7~%.lZ+($TW[ie.al- 8}iQi|5ETspo^zkܑrڽnjjgASnV5Zr\lI; Dyqק(V^"1J5ɥշCb(VMǕ?T]{2*h̞6idg-rǖEbpG #)]IkkjؙFj~hU[&X,mIU3z:tTT ~7?RNյS"M1bzt]qJ;挩vv^DrV3H)A 1?Iʞz./֔ru#dY{w)ڲ =3ڲ׊TjMFPSV4j'++rZe˫-; 8a]:=i?3ԫ1]_ol,dy s.`urkZM\N`Ւ$Af1tj~&IsǧZѕ'Wp*UkzNUcKlޯ`?\~U9FwN˗躯&XhJ6SјMI'AGmuy<2im%VqG$vZ1rߦ敽N:}β7ӫ^vGNzw_\۶^ңeqn@UsqC/$8_-nCdpN1t`V[]w*i$j3⴦yRҒBnm.6 F#N#YlsԋHQbv~ZYN;SD>,6g|`b=[r4h+jOup% 䎙tcU=-۶1g%W&*U婤r]G2HYFI9Ⲕ/BˈDw96ۮ ݻ=ִӻzjjmlKlQ7wi8SJԩ/h9F˥He93yo#)Ҍ%;[*͸J-P'%v3Vl%Ud^FNW kƘt2+w, =&] sg`=^%R#hi`Ufa梾ݣ9 XʢG;Ib o^q;cQ"2'[Gn*d,ő_qU:d$Mp!ƪ815<쯙Q];. /P~aҲO*gw%]cg1̪w1%ΥshtJSʯt싳q &ߘ^:([I!Qq lP#=} Dv*# .d #2^큎1U |ɹH={^zf%`NgtVXX^/NbDY _38ggqUSdҩ(Կ.&b&El lU mcV{+~c.!t0JN6N׹U=\p<eaDIc*q>ʴ/k49̱[6[9c[Z7|Ĝyy D8oXpr匞^ꏩ4P[nL+2Nzv굟,Wp1,LH$y038V50Z":Cn & Ƥ+ep̣;Am")BovQj=}Gi䄖h+chTJb*u8B`Oaq4rn>goF[o\qxkӂg$Uj5%f^7+ʝ !^}{?,ef{^7Ģ:U¿+ت<:ýc%SUX^6Oa.j%nMxFŊO zsۓYqEƕH먑y:/n94a* 61ݟ :keNlaiMl)9~Uo:~E:uܭi!+uRrO.21E+ju(*<$$j=g8U/2GŐۙ#[|Ȁ94劗5k.V-*mb27'mAWtj4maNF1ϽU:r"}Utlln\/iCw]]s:U.j$ȗ ! o[85*E?iRVi/d7:XOـ8=?*k[DS4K60?k~YJ:j)NO.-(.DKgӞ#?z1R;VH)F 9WvwN{eQ\5u ߒ1XJMQWm\.I;y_vjң覂Mpl-ޥіteOWeGfFGt6K:GMg(wY~?҉Pg,5G1\^v8?_z(rNoYɑ$[ >w}H:wWo#hFI8'xd[w`Ԫvќ*qdFf+ bm^.\nBmCkwܛyF9$uk FL.z.H &,NH5ym'%$H*i3c5Vqb?QQ- #ǏoQюsyOCYӔkBVSw,.(ex/Ⱦ#xcʵ?ipj4~V"]>]ʹn3'gJMV\e9`/TStV{ߵ?h*P8R ױkumdSej;Xaq4,fUXw8()*[-z5q<^5əc[[rL#>>WO8Ǚ;}?cc7WCGN.ѹ[}20I$7r9=: wa'wc*ʔRjwyHľ42Nkc32Ad[p8up"[ucWVZ˥p|kiez-y^-gD9pr /#9StRN1w>mCZ1͸[y$hRmAI=1e-C;im*C2 @{W#߽̺jSr9QJ]7STiĪYFw#/ o3!*ԁֽ\=c&]CI')m~5P7lb7t9$#SRlՇR/{{v< s#<N;zbM{Oqz1uvO<z$.|Aߎ2S9]ߠ*sv=ᾷcwD,6auz vp;c>c rRKEӿc1FQ]7Iv`}iRDHp 8u׆"GgE:Zu}>Ю-/|W8m.av'T)эkݮ>MTO{ײ%y\DأmFuJTk2C#;Kч喫<_:[!LY?yW)ũ=ƥ~m,:rN)w%+|m>[46y)SΜ w4w$h3B۶t)vNj'QƜ6ռO{z "z >|JRC8GMwu&S㈔GZũoЎ P弝(CZhiI4|'~{x{QR"(D!XɮNr9BlЃÒȦP{wԕ: 5q7ribr:n.Y?9*(ʣ4H497+^Jvz?# o\$q̨W >kͫJdKc~x39L2yG'I`@XWWlfKͻ&č=:ףKHᥖ¤eyuз7=#PQu֘٘%21ROqZu5mΌvEhk0L]E9ֱ8F:*VGh2X?CϽr83uR7Z.cf/jةݸzNA}V8t}~m5Co" Hxzrt&4}}nhL\6T>A\3@㌃]T~I'ש}4N5Z( 6P6u*NRvrW(aYobmE,TNߌEc|pxLLiϡG?}v!\2Uۜ~/obiƢm+?S'g^9F1Zce͔m|Eqo8W"8,co^[q"ȯiv~|%cOe 'k nl*ϾUZ6oo_<%U\ۯw3#-©%dwcϩK $:TQiOqA0%W~R:W4RmnR#.e >epJv(ZSnn; {vfsI 7 tSz'JQuZZMѲ.#NDJOLqE/鞏r]ʩd_"Dd`GNsLEv>,]9O?~bOBH~FL@sFU)TQѤmgr&Zoߙ!DѤ13Ք(w<=j~&SooXggF`eFH^Üy_XV[N:uRj~kJ3Me y zWW83i_cek~3FKMwt:#Uy $o\r @>ZvcGs[)ԧ,T~{ ^@u@|7p8 |.S|z?Cף(e kf.;[¹#>.qfƤmoOǧs"\Q/{3meFVlvA2?{T0ӭ'uxHJKjv>cjK[uC$$?9x<={~KB%)-.30tiyZ;)MNO(Y( _WG-c–eR8O<h7LOw\#9b6@_Q4ou]NxUI/OsuMGe[y\[\o3}7=<=GwF){7<Ɵ/"*ͪ#M6K\#XXdr1؜zjSI{I5ͷ!鳐[v#u pOnqt{-o.aG^HK;:φP}זԶ$'NT̨ѧ媯k|ʣ}ѩvOO;vп_O.VԣXg!e`>`7sHY?R!ZЌTcN;^g9OOCXmY-8x[nX'&d){R;E+Y/>tإX i cۧM?GJ7ϡQ<9= تJ y8< ネjs-oSZ^Ϛ.ҺV|n ڴ/y&8#qEe4qXw[rzQ[ԕ;]&eOҢ_]Bڵ$'c#uueעO/FcUr֌n#fM )c#Yh^ySksvC#ָR2u--$w WE:ti>+r|:*Z#6b~j+Iޥ:ȅoFQvEUM;G?6dY 껈aw2[G/L,6K3w-[SLFZ.Xȁ6c  ӈ=ӡYtn[J˕[CMWXh%w7bLE4_#:љwLjY^IrrzvJyrƷ›mGU~Wo< 1tj5+&~gBTx%ךEg$}Roi=.i;^Ԗaksm/<QX 9~n+s9l~k*Fծtg{yKGK[Y5:|P>;]3G.|XU pNMzõ Y]u)Umzy7VԦgeg r9)JrV[_ Z\Egf3rd>H:+RyF{yz?ؒ#?3}{~ul,}R}RMSlj"^8|۹3ӌHJ2w=]Bnjĩ $xޱGZvM;0*qJ|hޗ}w=s?-t^8@k|v;vgn `5ZVdm|6?ҽOUK:qKi#|Zɻ\.6l91ۋnnuW"5es(靧8#ȣظЏrTt~K}R飷ȒE6ۢzN3WjSr=xSPђcf g}5ˈEwZS=3ޫHTFsӞ qSϓw?6>n0ϧӥzXzGЫNr3ŭ풗PW/4ہs\u%{, ͧIpXRĨyrqϯWC+_t%(+WϞgrI|0ΗJ S#r<& V^0y LڷWkťxsZK-WN7;g0*qOqhZ/Fߢ^|a"^=׻Ow|~j~Co3]BnN9,nC`dd+0\Jϲ BocBIm_Ϡ#-ṷtF x#s_?ϕ*?{E1w\jMč-~N}FVO> )9;ɗ2 .s3dn*;=*NzOz2OdFx9ӨߦOi%m׸r6STT:~Iu{ηcLnEt Ҧ]}AJu"ulaC"O==j$qY[$*Wlt;W<jѳ(fHʁd> 'q嶫cJr妓N!O,pHjG*ެ#eۋ1 mHF TN)ŊTTCc7yf1,*0}Jʤe{ޢU|y2h9r=v&hے{w mN6y&\V=\Nr]r&5+򌟛 =Ȩ"cc)GR EU]4ylֳ=_QAKةJ un-r#_5Ya@V|KETJq׻Ў'U1? Ȭ`G 펕P}2 s\*Mv#Ctg3'͏b 9=i-=5Tc.zݮP7R}3 ]w*c=}IRQZ'NYbO˺33Ah1E qwoݷ.t;Vd7b+@b2|}:1StRf]ʪdbF\x3i{$WɟUx~V ig:\#GN^m]iV]B5+ |Rr>Tk'wPJcBd唬aʹ}=+ Y*pkk_nVhMŹO-T[Q cuiƦ[#/P{S\w0^5J4I6/,}٘[1]8FRodޟ2*i{851u B)dliQâ{[Ւw!XZF' e#j\{R`8?%:!:jsWCWRw*i)3h:G7 O'H(*lJ2e(:ɴv1ҹ+|hFR> kwɴO֝Jܴk(խ @P(kG ifPZr̡gszu*KJ+NnflFHϗK{RY=n~m³˲Υ(ߛFiĄFYy'pgzWsK# o-:/޹jӍZ|j(ʎ2jC>wA'-W+Rʟhϯ=j*qw4J50i- JqoO\R)ҧ>Voԙ _ۯKUTy2yXFni)Ǖt8uZ*n< ˑs;<-zN7&ebJO;SVX9Jqv))#++t/1 $zT*ҧO+EyW'`2žF>,ElK,c泧VRoBch%,r뷀Yzu\7Pө̜&xi3*}kCgyX!Pu5Zvfpzҹye%k\ΥH{6jʷaXJVNIYjjBdyOjG[6gRxot\.F9xU=[*MGHs1?zGHqUI++օkb!椤6UU gSQ^{ߙjQ?}+i֖֔z{ ^NG7=Q5eU>b#3J1^ɻg*GY5}.u8UkPFzg»rӸREEɭ5~d| jn,Zsټhcnz1քqv1NKaxXtkK+{Kcr;`cN=HiQW."TO խ'i:?[Rڷ<އOzr SsXadYf+?4_!^ӤJW :rza銥oѧqLf#|w[eNNN>$gF]tH_1T]߮+Ϋ5urxy>AM6ľ^ǧ,qh-&|±, s7q 9nۯЩcbGv/<]~+R޳j B~q 3`lw͕Jy5z__i=^_]/Vվђj,FxǃNk'm_4iRjk^~''n&4ǑR?8C,;!dSYJIt~B+ƾ]A8nUFa`rWe8]kӫi,L*itK~??~{vm-va ג9Z/<ڽNJj͵k3z [jv~K@b]m2Nv =q1*p۾fr~04z&ҦeW/mGxk)AcBסmu q妾cWѕ= xti4pKg #4fsP洖툠Zw1oěg4,ixfKe" WkPqYcr|4*^7]32aN_U̬W]}vJLȒWo')S. m>'kwa#S5m$b6?3&#srAOlx4m*GmUk5(G՝OuzѥsCp0_#Un0PrAzH諟RiOdKӧOC ZxRQUnoORҼIj6P/*N m'd5{WvKӻ{hJGG֣y5-Ǝ%0,49U`0z#c y0~[yF晀-3I^XTqVsb*J|GcZ{sVm<~+ u63:q%OYd2*1A?0g WU):I=ߩƥ{$Ʒ׭⸚iL}nq8^Ig']iZ(J)JouIM$cq]JI#= |u5^_V:Ե796Mteq8zd=8>eO<ű> מ_xf%;d-(97ةSnɢ7 c nv7}s<9S]K1g}Z3N\yL3y>n?Zu2iGQ<6/c<;yrBlے{pA|i3(4q浑Df̅ksךFrG1NFΓfٮI僷9W^-7M[שćĞ:NH^f7~Z$%d#8@9K/VLn{#-B]v4HȸvTt^X%m%NZZK[ՒUvclx99{>c7uk?>w4n<ϯjé[?NǏ^\v[3mF=Zuzg﹜eR%*[yy>aiVJj$[npGFS<z\#^_qcG4B6A8*#2zd w_Uko$SbEwjsC/m/w!b9f'lcpV1XwJjK[4]$T_y+9AуwRʥ>W^鳱kHu] Ǐ4\ǒOLOWK9^ZTxdtz9϶Egqji6B|&&v}Z2eqrceG,tTEmNOZ ᙙ (]ʮ9ʎɯsl]xVR[Kmk#Rm߮|˾$XJEqsq $#d^O?ӯ̱QNO[+_[%tb1U\tiۿx.H7f!3vCQ*k{9;=K4JOE˦)泡ͪi&KQdYv1quxx,ǚ5o{ގexllx;ikϷ|wm->,5KC_ȱ:60G`k7GWWJTT,zvs⫯ yqpʿl-~FI+'L~M(ݺ_uk֋F="IkyռU%֞*ߴӒH :cIbiӚ-z_xYE,Cn˲/jWv?]5.#rNHb@#?,:4VJrƌ]~h%OWgkbOO NuU QJ7OϯGTɸ]181δOM;0+%UMfV]ˏc7J^m?mZfmeE$Ŏ޸umԩhV5)#cWכZJG6yj2U%yΦ m*ǎ?:(_59MZ~gfl1aO'OUNzܭmH}J&swc98+9?ֳ䪬])Y UnSׁ%BkVuJ<%_[OƑqN̶=4ɓú ڎNd<Ҷ4RF,6'9je[ݘF:r\_oty>U,1th>k+e%c.Xn4O\}u@D*8[)sU*x6v>j8E+'b>b+8o}?Ku^ RѢ. vpI2{}r+iʍ;0xkox˅d{g{Ӂ8kӭ,RRW7c`$_c*fy_QNo^krŸQV}3JocuM %  .d?tzե-o>FjXyJ.g7k38fߚ9/w/PG=ިtTɽN ũ"GZkMeky8vEFHH:򩧇y{)J>+DhiSn۷ 9:n,8h×S(uXBʰ#ZΤ}SRZ5=nCo_„~}F ?>i)Sn`%,yi`jQUl%ҏr{y[2m[-']JQwoS&={ ,K;g*HF$ܪAcB9Za۷;LdQ3sZR>h(}FC,Gc`ov*Tmt=YgY.M7n79rW! jUBX v*dg 䓻frvW;)> s7{2姪_,q[>q>~yy8FpeHktȱist' xQ|]v:E;G4rG6Xq=+EE?w\F\<*wTq;ɫzC2Ȳ8(z <} .vYy$*'F~3R匮:%%Tk$.A3t(ZKNLGV0cZ^w$20ݘGʤ8<{5pqomy"vDdc2/ Å眃;!F7'-A +|ރ?WG,{Ӽ"K6#f ϧA޳{e)u[=+:mJbW,~!YwI*xՈVu$JVVj{YdY'ι?֦2eh]ʗHw&魁9mpwJXx7^qG%%uљڍm$`ߵٛq'?Sdq֌))˦u`H/Ջ`B=8H\{py*VߏSz޻yaoܧa Q/v)?/뭎w[w.۷;})B2-R׍=;:],\sWKReT;}J3 pw+K#7:ָ*F5)z}Jv;9k~Q:(FkB2qlBhǖ-!9|0e mʑ2~zݻRT^LXc qZSk3"cI=k9J"ԕY]-;V?7gmOVaof"xeｂ0[KE85/>I=w {hY*ZQ١kfG vjb$*2InՎ"]яj#.UyltԜW_767{ET8'ȽFzeXnfX4cH٥1Nс}ҸkQq#*!iicb$`9Tq.G"NN捔,OuFQ.8˾ޛ_n8zҋ)_bʏ$&#q=H>U˧($kiuI#/o=I{ڻ"PNVŸtȕēILbBqqUYJ5ȭJZ5Ъg7`_ú[e7vlU=9v{j2ivr,O#pDY?[\5Th/q^r\Jo+|H}iW-=-nVkY8B6>Jli,55N^0Գ79TM#7RpN;)\žEjuSq)ɤ$wP7u휣{ؕF䎞}V622b?Jr^՝9JSZoʰG#(K~f ErٵisoFdn@ZZRQvNާEki-Cu4ӼlM>Xk/3t@^~rԃOi^ m sONquةS[?:=̝?-d¶6N5IS|>!:t:+XtFf9瓓ֹM;%۹y>vWk\4 yſxP:d<1ZNRYVzD[hUfu6>XXgG]IYz\n[Vl_p~TjIII+.̃옏t2~^??œRNM'DP꒏CoztmN\m>ZIUS%EP_1"8֌]mh?#,9$=t*9c;uGV,,#~;(8,a$Sf4MZYDpLv篱%R׿q$W-[:KM;X~=r8+V)PQZ[ۢ*T[8+8֋WpV%MSk7bcH3;V+4qr{(j#egdH{z-J}g4*J2RNj {]\Ypy~5Rqi"P}jm>LQmb2Txϥa[6m3UX֦]:=ɌҎ!ZKӮ)I< {oa[8)u_c'OЫgq$F4̧ =+~I{.iE-IQ2Ek$.Ϝ נdd%?4uHц\5y&s`89(^kMjO}퍌{'PaGn?mO|:}|-jXWoV֋NˠvV6eVrdJN)ӕiJ7zߣGݤkJF71%H b yuN"RIBE];z[]O'㌿ɕ'qZiB4ѡ[XiY7Ÿqw{s^ܵ:)ȆD6EdO,)XnD{lTaiRm=,ZIk]صK^_FQ7E%w<*̨2#kPaVI_Op4y nfmҔ)٭NiJCffK 9V>Vƴp{vlJ'~Rn‚s g'JREVGjUIi+V 3 99jҔ}T %Q]-GmYk'c^k(k˻$bx"ofI>l#6 RO: ۬)3m'tdUӽosI;0 4fg;X]=U/i,*ߐ[sM5c VJDD-?+q}=tB|Znկʯ`\-)mW cԈъf#CoE,K7a;qGV ɺq-$6fb[f_:$OBj.][H$Iշ'U{w3oezS5I]n89~Xm)o5S){9h2Iv?Smfu1v5 ⒋h-W̵-5W!vd>arӭ?hߡy&Lx Uu\׺3FjZXuڬOm׏T)T9F^7wnqۜ[(ǧLiʞEЄF˵],<; pC߭Rˠ)Rq3(eۂ~;1BeN12KBc3rzs9T|3qErXOsr1K8ZkFNXU(%,A=px#һQ*iƌ_*%YKyY6{V2,yz>єEQm=D!ܑmdwFًJ1v[h:J_HvJ˼8?Cұc*$}{ G3%{dʞr>7 ToT}MK*V5 ϧnҹ[ՒX(WY6-YV˾'~Mb/97 YWn?kJ҂,$Zz37l cVJmT9-KH-w8zДgjh-#F 7rp vr9RT%ԧZ3k;݌>Oz#XTT˹ _8\oJÕV*JJڭ<#V ?ZY:w苔ʧ+[- mjH?kOm%:qn[`oFӁ99F̗ŹRKfFUqR{nT5슓ًVo%B㢓Lr0psҵ)K'tU0f)IF2v>D"=ܬLD  ʵRR|P#ݽN̢5S2;pq]%rJژԟop0XUvy#?%YAʢw\[b|V*9U:R~Ό-6I+}r$A1Y˯tSqe/A)IRܝڻp}i(J)EV)SMz䗘2&^8S~Ks; %o];mxީ1[um H$s{9g#0W,2;ȬՕ_ N9wZr6 Ѵ6K$76|#?:^u/$h w$cw#wIө r`쭹Tc99 r1>_6R'U{C4Eݍ~qWCPػӠ`ϭsIK9I\WjXәS%FB.'iʝNkmRĩp,7u}sު17sө$AViJeI c9څ/zoʞ--„q%Jz0}Zxc3{cr3oRtޝ9Kn;$L7/o58ʯӠn7na<׏ƈZLz-Qv=pXR.Sѻv, T#|yj{}q\Ue-Y(Wѥбk$'*ի9snix°J02a6fb.-U6y<qk8Ԩ_gXK?y掼ֺ͕pI?\WH9'~p*_.F+y{_~"dǒ329>dqpO>7-[rt:-,/۱H8?W=oi%0=U!fi?7.2βQHQRG*`WlLʪ]N LVu+Z]DQ,g̍ۇaZ:Q4TvX[Y+(<ӂ:i:N3&U%%xօRL3,dF@׽\%atvי$nLC6w3g;?S-ٻkng%V]j镼M,$'a%Нo c.GFVR[Y;o{xΓUW[]-0ΜTWFݴ6/~!hB-|K?c"B$Wyl4#Η{a]6.MŸxyQOoI=o+ -3tNݗeO9jݑWTMc ܐ#zJ.1xϖVii|!mVX^;m$3ddcھ- V#l,*W@o5}2NUX1*Aסr,k~}?@sCt$]m׿/Sڠg7, R6֭:sy[~Ʀ+.y}]z[Ne_) j76Iv6O5{kPkIB1jU<_wi1 ~XЩ[/hY]\Ig-l_+9ʍIOpn09}̪{TmRVnZ5ghfEP-ڼӖ2ѵnQnZnt $󣼑2I?ju%R.eIR/o";,^d&~`x5#Tz.ߩpMƛ۩DC,夒\[ڼvI^8(ʥ("33p8LE:Q.qk |UQGf*NEKik9N*Tv_Q*Iin}X MjRGw*tz,BqF*6\y.hrԣ5 {;.xʰ8#~-c2U=AGvʟqWGDUf: nƺ㌥amJEz(ԕK#:rM'E3Tc-.[|Zϖfy TXtTmpmPꔡN-.Z#+K sc:qKzٙBGib}{S^O^ƹd⑶c=NSJr!.g܌il%Hҳ]}~G#n[9$Vш #AF5q OCRZd8" PCyYp|^溾ZߡC܃\}wMǡ$qҫY<,KF9g#{./$aC _s^/IgZW+u`mۙc+j{NYO;kW00Nо UgDګ1稴lh(5;q$1ʾa˽}YR%{:0UʫV> \\ǯZZ]|qǶhK);mIWգ)[vz^z}~1FP:q}k0w#59;;;K{xf sяL?bM2ߵn"r RQW8+T ]vNjqMjh'Dvd32$ۈHϮ=ʟɵ<_Pm-ɺ%O`W|kUk?`)SNڮFzƸ^T&)Ypy#yS6QӦOOégC=1;1ȷA]ĩ+ g%HU~5v?prZqk_ JK&V >emװDZ#5!y<ڕiւz:E$vvbfϜ )pnq^lh+++.SJ% 7WrCijsM ~-ZUMOʧ9{TM־U(/#¿_ūȑ[H=qЌ犵 Uͦb1yqnUiV$#uVuPmWr\80둓ړ}:_}\>e{?js:ʞdbuh>noƻV¡(J1JM4cVsֿf ]OUl,&O(8d"AC' ioc}φۻizuo;>cFM%L`qss_gʚjoWrңZOWzc^}$q9Pou"\U^-z^ih*G|s}+c)²ޝ:6t{8u<$gQ:įXgq5֭ZVmyv=21QRFq>t>8%xvS xԞ8 bܢyڕ{᭺keqWgt-gHeHdZeMpuWg[뱍LRjՈ?ZGxF ^!p1݆9xyƭwFu0j]CXlfw8ơs2/W#8{iGKNR6iK;trع1 xdq3 ({=6 Z9tiOs.~^[Ue;w<{S¾+xk|%diI$,lsUJ3ue_O0yhԩ}K׻'գku:\1;'-]lEw]]tZ5,^m6]Lm#HǥoVUjY'ʒG RVv3n46cqTNJӪHS^vex5kﺝ9+IZ2i[jk= siw.tiF{vlY6u; Re$/R5Kv-\9}5*xW$[3sF +1.|'֏ҬpV9J<-͏ {vcLq9{p{ج_WRk3Z4K^ΒqbE$yƋN敚ζu7H-cRyJ5v^ &2! 4t.Eԩ7 \1 -\u&7ss#caOqNǡ꒤K}?%[٘Nev6 #%#cBWk'=LioqEdžy~kssk7Е0`GVuǑ~=lƴTzrhiIsP*̫qy*}?1SSn: uf+H͐28n󎙧K3\-J]U1u-b͕cE.59=2ztҍM]?R?/?Skº/6s<6ύ?LW.*OzyyLD}m9E}FgC޼t#$XnIEEk^Դm3&晷$jӒ dsէ,Lc_z5ķ+6| M(;~>VQs.ԭk /7F$3dn+Z0e?Fq_;.xO˷Ϲ[ؒ}O^է] I*'vy>_wWleGHeaPG̻G ?17+tO{vz=y\s񚓺o}~65ƥ4qL0Cp2AnwoW<VYRP*nK}M/:n/HAq|WӃ1lpȢѫ-ךL5:QSMY=oOC|SxS4HJE4 zA1X|6niyz^.tzI]5mw tFƶvŽq rҖC9$ezuq6Imӭs1m7dӳQKϡ<l|KLGqHaX+2[|"ʝXX]|uWGt'khS}s]ߋ:}Pi2C:8NՙA9G8?c_FSskk?:XdW+A{\I4ir Q^kfcf"i]{t"溵h٠W ΟB@=CVQYF5edsm-r45N4uid_" /;tLUJZ^RU"SvC%\<"-my9cu+YG!vW;$U<9<sV4i{Fi r:_ɖGFRr#{WDj(ݯi[O2YeCj@烞gSo{֍zVTvFfi6pJ8#4NW,OMm ޳VwʼȡY&>y*ViVJܳLm)*iEsJQ\Qe(?D[|09p~m%p2uB%R3Nu"V69F*Igx%(STӋw}K<>לso1dl7qU1Sp䖯ˡ !jqn '<`cqUr7j.PmfWi#,r$X-FxݮF,HGv<֞δeҿR+rZu#YCseգXKѫG/+ϱ4Wn /q$e'[ӣ84jNwz}zwTv+z1啣:!ӤZdWuۏ+ҽ zKԣ%MTKFC,p]s3}81߿*֏s Gtݖ<%{x4vqnyQu pAo#TTQrWiUu^^>lv5#)k[,~J)A#fGQr38J%JEw+Ze>S?:~NiRȡ&2@n6㪥OkRy3F7O&^xW[oֶ]}iq aNqrQ F>Yͻmz񡊩N0M{ڧǟ%oHr@fH9t@1A?m99I_}OϳveX7̛]GG4_QmWH1ws_3.X.X<W$(̛$@OGB<_)GBыgk+_N|G|4WFJW΂8wm(~Ar<¬~aT8}N{=:Yw[IVR0x xrGy_oSfj;mn~F׈|[(`Օmg,qVxS IQTjW}mxzl,fGOo |㟔Fx|c%EA|Yiսri#9‘7Э$㤓7z,nV[=g-xᗋvW&oK '邵]yTNϋ%Hּ,gi$Ym-R$}yRp &>=?+Lv Tٮ۞9JE GD^!|^xI3 &eUTpx$+ NZ'mwOgsQ/M?.in'5tڗcvHOv c;>‡BK;1!LZYfΥ;k.X&W*§a VOZ"ڇOyqYfu;!$IPw#zIQuvI?.QXGrug:?]_-:lE]I@ !p]H޹ Vi(]_EvyjEs|FTSiBjDax/5}eZ9r'9fP}0@lލZSjoUm~IZ>y+lKW_>f?%\ X$z I{lQծW_ӹxyBҙp<涏*49hQQ~~lw<>l0;:95чy4oaij)%J~1B 21Uv*08`A_pXyAJeIūu~ } 7&d9`mbF zҵkO+.[M7wۣɵ5pNrpkJIkժ/KФPC${w7z14jr?M,xu{9JqMNױ]CNu̫mݞIOc؅/qvm2_ss 8/|RyneH59oH.s]Qv1'Cpɓn2EtFc-{:n%AyzkiHªIUΏoCoo.sa/JӚ.'LbI;4ͻWM%s_-P_;HGM%#e+6vQ_}oC˖P}gI$׋ 1m_1]pN0GAgǙ[~/Εh^3Z{ko#.I<"|cdؼca6qҼʤ0r[ZuWif>henf?{h}_gdc/tz]:TӴ~=[}~G?Hyqm19l$}@q^(Kx{+=, yQ%oŘ2xޮm|d qzg }+ubprIҕIb#)9r+ugAˢȶNcX,̻~+C߷]Wtq+TGhv׭ Kba,ϵ|S~oCbX՚Iimb?X #SԃF{v?^Nq7{ZX$xm.-tK]'tA{sO ^+sӌtZkw=D -jbL$>Z(3;:q힃#RݕtG֕K={u}zψ^~:j$<.jE˝=SiS`]^g^KF2,[U5<Òxo7ۺZ$"8 GC_K곅Mt>ZX}nry1Muk5C% kWMBZ^3Վ *FkjyoV=VET9$/?wH' <|VAIs>FK}t鯞ܭ6>퉬2x[_{MCƐ\ YkC.ю GU[%<֎zݤ+zR8j־mg▗i˧Gm?Ry]b+A%t0Pʂ_ ۢ9N2f~{?;2kta+S֥:~vθ[ɚx;HtԧcNiS| *ec.[}h+n,xN-_Խk^4ͼ7e >tT9hz=2*2^Gs麷%40U.J},/Oy8F3<0RR%%5i?ٷ#* nf88OP}8~&mwQmڭoln>x{n5ž0۪ʱ"B2~}K7oGIf\kl/-<0>̂k8I;ScO_|qϳ},uZhe;oUn+˧SV7G{T{#V9@V=Xt <M^I4FKsdkd5l^R).h48',J3>2kŔy{w=Jx9J\lq?Nk3У(BI0la?~%φ%5"#0fb%8>m;r3 ݝOrmkQ>Җ/ d{P?Z)*ݟ?|M-dGm:.:=k{M6ꏤF6cߎ'Ϊgu;{y￲I]4]JK-᷒Hm a8W"8D$VVޚt*U%^;۽=B-[f|(xzeRPHr8 d=<lBm~1ecRSy=xG~3Zn<Шc)C_]QN{RL(w'k(yq-l*{YIlE4q,VnEvn\z52v57NPm~hw5>o}(Z[-/6gU4hsס#k9_tkJ,o.e(j| xT2WYeԚ &i7c8=]/݊l=F/^1U0۶Sju^񅖞OX%%p'd;??´t#(d^G)zn,~dƭEx3ҧ)GE$Yseqqx=?!WFRFusMmnq "Jr0xu9:4To~$YZcNi$ւɨ\DfK,<kTIliFcd|ɤcH|呰 ~^6ÜRkW.7&sc[BrTjI/NT F>]{|;VMb'=(,0O]<ܱwGTTSEԷm,4% j=~jbReӪe2I<.qsnTb$֢vhwї]tfެ8O]Id1?a=wҦF>m]-Ks44jqڴM)Vj:@? }.>,k.ZIhtWD Yu$Z=v!GUj[$ŰonjNQqJoCљUG|6~bF2II1dT`n8=‰^J{Ek2!`i38$YGa.>[}{E9^$+%~ѤV>7nVe9}A汩Ej{3&IH~ϙ.m(K o+~@jcy nn\n"Ҥm).hm)pNϧ֪U*qU5LqH̻~H=R喟ycYr}w;?'b'n¯;.ÌjP3KR+}sDE%k+̧klFA=G#񢢵}%u="Qx'-7?>w%chя:顗qiIگ͹ ȧ ӎUj34n1nѿ# ϧ?ֲ-^&Z9oT_-4s'ϭaR)Je[Ў1 .ծU-!m&qמzt]%O#aruia _dˈE`n+*'.x۾?Xj:u6fo1V SpWD rKj+t_WYZQ7|t#>:jٝiR浚nI>nUJQ/cu7[7V>lAi*qovFu#*vI٘!e&dgv< >SʝM5姑ˌ8tӿ9mcN[tc[t pFxùO]_eKk0-7x=qQ<} 9YÚR^fTQOb0*3c)^:~ٷk-s4I$A"!ִ^˕; ަi7E~QN՞jRRP+,SoSw`+Ӗ4X a~cRfRI=CT/)Zӏ5;&VR5L%.>hAŴѼ.WZg"SqI''W-Jy[oAVMR4n4Dת=n{q֥JPdE4y͛5 +**,iNN>Z] S7s$}z4tbĽޕH|,jnk"2UUp:cڲyINWo[ QrI29T94ΚJiw,@lc2[!TzfTu-'53n㎼UysYM$O`o*u#բUwm Ʀ2(] ʴayGCRoYtaaym%U8Gcqyms:%&cͅݓԎ*TOF;h^W۞z^nT%E{FA۷,cr9$WozVEӡ.hUqfQ^n;C$Q] ±F=֥YnvSeMVy0U\7&4h)O_56D*Xb'T鹍GeI>杙(EUUwa[cGJie*=֦>R}Eicm]gk8#Jb'菪Ɲ=zߩ LieskdaNV#GW>&4nO]=]rFjW#@ :|d`W>=o쒽m]ެvX԰䐁`<ӌi?;_Mz%|N!b6'1!m׎GOS U㊗2WĬa+Fdz5!YƷ$jr- HBr9#ך)FҬ!W٭?Eԭ ܙQZ0 s'gޱڎg4b}\6mnXD5PTu=1q]\jTAo7*o{ PUQ1~V gH:yV׭T>*ѕe{Z/v>ib%LNys覹%Z ~ZJ/MfF] hH+k~L ;x'+3*4mk},~rނ\=HݘBfU@=pt JNo_"y1 s{z1ͯtRtc+yc^ڧlsʽI6$K_9w40Cg Iힸ>"*pwzm|ɔq+ƟG o8inI=uЏm4IȕF8l=9'UF#ӔZ;ܚ)bKHj$#H~:j)3Z**5^\k)VD,?c%prG~Y_Cϩqk! Yu78ⷡ\Jte.j{ZHP\uv8 cjUJQKߕӿMF=œMr%I[,(ݴEJ%h[#(ҫ*mkױh9 P#9JN; HT,yfkk]Ǻ*Ls=eO䫇{Wj{SL#yooe_@<5T#O .FkIը]ིyZaGr:g:οV4QCe6u Bc'3ڿ|iwiO NdBF5ܞ=֒>f5Nj>]Fcϖ `Һiʛ/i:ߗ&oea;5~3MhUHӔJ$ by듏j)ӗz1儚өN -q+6996| W$eG$R2rEh9`B1މZ/ZNsuV#6\30I t%I#S'R KQyvxv9b71?CTN^Xp }3ޢPEQQ%;?1ua#lP7/Xu8=Oގz:%RX| u54;0!^q+߼kD/#[;$i$tK~z{WZҾ(J`ˬ.**6Hۺ<=h=m=u( \݂GP.ϕL1:z[{:JV"5an,K3p+{{cRM]46veYA=sEk)F2guhR!+HE;kTI1 $tc_D*tRi=uH9kUm08浧&K˚QdZ91UVݖ- 2#BۗA=jdf)a⛻o"628I G~RH<9w9Hvb\KZ!Xr@n9,H8᎕=NnWyb*6Kf86^Y~VNԹg{6Mj#jkmjB5?ʡsU-83V]E n qs~anMF/[YwP/\qqVu9j61.rWE,A`h6txK}u2cN=["KȄǞܾJ^'vkkJQLqlbU!{dYǞzR%3ڒʉ1g,MnR{ֱWml)J7'6淞60Vr2pzcq(T*k0466c K`9~USINI;JVXl7-#~u䌯/%nKo aUaU'{ ӽO3Ӕyb>(#\īi1!oN> Ҩu.o1>|a"iFd2H+ β(6TFI.zGcϭG/46IHV//+¯gV{uvL1P0< oN2rQjCWxXX+mב}N*1j:ϸn"#e _`w$eO֒ԒU[;X ]|8}*R撕[/ b˷;Y)94hXW̷nnKOJX5c_o=qK2s3(EHN k))5m2y&܊Hʶ/o {hH\t Jw+[r|u[W\"8iʭӶeW-})]qלczkȧnʒ3M')m2)SQtn#Hܮ#'+EӬQM}HeC Ors#_OJӌ=0r >Z,As.p(7iJ痳kbw3~@ÏKg$w)ǒSST+YRU1Z0;d*8Mluҟ4}4)w UAv@κY{c5#trH+5/_1&1_ &҄[E iq9SסN(y\ΝyT|KRidiٝąnsLW)+G;~)F^MIv0W{7M2DI}MjƋAWOc|ђt-RUe<5ꙥL=hD$1r4>bytucv{ݕIr&e0NH2'!RRzK Oos"?kƤm#\=Jw4Mejh2FQ'QNv9ڗtM<{XUݕdd-#+} j4ȍ쐺ث㪮0y&t-:|u"S\LҲI&Ъdz}}zFQUG}Ǖ׼r:L~[{M/R$$Wh [`>7#r) wZy[]UH#cӽTՕ6Rlu+jS@yUaF{{VNexSM?WyLO2HC9GB#Fukw,yF .l608㌚EF:ow|7s${|rco9`_N/On@~i[r;⳽E& QtZО !Nc,UOsvd忙\Nڟܿ:9 y}x*!Ep>gR E="9:HUp[ {ZQQrʳQ1ۻ{B ,Ѽb5$Qg*>\̏ϕf?{=sYԵ; SSWL20 x>K,)VvtxL>܅۶>?u rRܖYc[;F> g<{TrzBSo-F"[H{?C1ZQ[V4' !bSol~jroAsE>WI">s>VW,l_,7qg\~iŻ6HY#$z}?Vr5HV!V@B^eF-T nam%Y5)+UvU=`$G~@Ox9y8Ҕy^΁Bl}؎(RcrDI n8ֶiƧ~ZDK"2r^;澻saF2v=LS R9/K2m>PF-ku9/uutNY:a#~KM{ѾJNJ/Z&}pιdz`#J9'Jv~[jDK>+5uӼova,'ؒWw'OGuiyז(,we85yjqNe9+ߧ_#?5I WUY*NA]1JT1IgI𦁧-퍲*kI!3-LN#݂#*ZkknՍAۨRlqq߀{T:voN4yUG?9=fWEǮA[ʜbN޽F_XW*j7"_[ic床Y#H3#Ld'J5t 4nI~1WCPRPG[Uk'}[~FE4|jc d$/TBoU`Glq>ŨJ[_fх vjr3uknlVKPJ#n}8G#_e;Gzv$﷗߿ Vso0 Ǚ¸k%VvNǟ(JOpixSHܒHѾ&l;~^Z-}&"MQ:%¢E9[3=8㢌4iʚ_'`jKFTg{M}-FcO>azҸe*j53f#'nῶRQYՔ >T 5 :aR,&WץmO:mF1Ux@1^֥Zj%Ia]6~{n-%fʙ#1L;]Z8-WZבhH݅i8U}z~(''zPMJz_[ku 0,se)AN#קa\v1KG jc^]kwYs&:uy+ڽ 9 si/ꩊ4g5"drt(2fqe0/Y۟]?XTcZbͤhY]w_gdKVPCg^%.5BdZ0$7YSx;5aS{OmM^)ZݯD%mvw#F]@F2'sCE8奌ץBuW4qV9&;׫kwFRJϱz;IZxO/s Ҵ{^Ɲ78͉l._1`xqEթOcZ7 4ԋKmׯCd(U6dlylrs^.ab篇USWunhwB8l䑷) _XboyKV$C|%6[ۙ?v=͂[nb1{Waph~{^16U4ۛ~,ʛ:x:өUӜ}hqɭZkݾX_JP*aEƢd&Js]h]KTyQM*ȼCϯOJ1Ɲo%wzwG9Fk}*秗QZO&F݃jPVƬq˪25 $TUv݃G^m\<}[^G?g.K_C3Mnb,\ʢɮr"SǟS;M4iwyYF@n }C(Ez;}RI;y~#?A I`g u9}:Wh}nj-SG<[Co6ИWq8^_eٖ_*n_yQjQ$}/ScG{csa]yb0m+c;}998GNn۽vb/_KD|) Iaj-qE<~_#u&z_C?ut.kh8כt6H$dt$2ڑ9{/;ib0hӜvS!,vȤTV}-=Ee䪜㞸vSNe&vsWy+?Uf+^W{K]ᶒ;s4X=/\4Nki{<QJү%1py> S]k#Ԅ57-L;KF~&eo3R>Y^g'WQ趐Ʊ<傒3}?ZiH[)EJ߿C]G/ċ5eH21rAz Q,6//ǡN{WOt_+OG;V=8#IT*-VϿFvaq~)>g?>+x㧆| 'c߈#5[n۷ ՀnP.x<5QIh֪5}}ody|Ix< tVKonﵮÏxuu~$S;8$q_f8LU۷o>85lɴ3;օO^Z+zm3ү2Aap#O>eGANlTJ:,CR֩k1HbɅ=xf_).]@\׋1I ['&IpӓǸ#姀*;4C0R}|/Gnfr㷵(;;Kw&3N̟;|_x'M<.ocTL``yZ|ڽ=N\=JK+'}lʽ9Q\yG=e{B 4)I!'w551oN3̎r%W<*Ξ"5}y˄[x{VHeF9S)(~1G ?i7uo֚x5;Mʑq7ER8[SOvRYar\v[jsڔW*^F_tcX1M :z,ú{Ȍۜ >jJS`;OĸI?̥Jv5\DeGw7'S P2Gwv'yG>Og֟#vy1ڧtԦ>y;u:iQO2F\3Rz$zhWxkŞ|~Nc^L8'>OgSm] vktAeHUZV!b*As܌VM_N_,CR|3Ǫj?bemr:sߎk(X^tʴQ լn!^2-ڿyrv㓏%HNT];8Ե{x"1yNu F[,N{ ^Ӽ劣564$-im[9wEVTm L]OCo2}3=MdCEϖ|?QsI65jp@Dn OF<緯z/k+ M0"6\q4InaVdt~ҥcUh|7'?/8#n³XJX-R{OWHzw澒4FoOzbѿ+i:Ŝ-R]CG# 7s;mu?O=5],o=:yi\u?ux-mYl>`/csqAyI:QmoeD]}w2#8ɫ-_U]}w;U^FFVhʩ,][$gUqg6tJ;j}~U0T֖a迲X9qIyxNvc{qRL= SU_;]5[/=I%EYk{MOuny~>x0ǧx_E:Fb{n zʻwZkfSn~К{$KdX򞅳H9Ÿ8c5yo[SJ 饻#,]H FvP?ֿ)|}ozȉԑ-da29/wqQ[->jη;O#v\nnlzبʥ8!#OwDY$Ƒc!O0s0=yzUaO_6-Ӹ:}Ymd@'x>ƪ>7Ojjkm}݂9&5e*ꟼW< s:%*jO*֩(YWg~\V8դvײ'xQ-wہ saǭvR)ūXΥb!-;0~?cFI=jU/v+cF1b]'?(ҽ*r۵>˛$ 52[lsG<^YF.q2ZvC )$@+gyc4-f8ϙ3߿9ANz){j*}z z)g׊#8kT}y2!+,#ğ´k:1\˹ 2"yGY7_J}Ũ~hmc"O%=Ham\.H=N=Wc̯^!A|brFMvC8;/+T\ZhU%I$BeC|ss?>ZxݦmI(xao,m@ >|}.Z&\[vmEm*f!v ؓ]T5GONa*VO4t|֋fԧG h$Y<.2{.9U"kթNN-$Obk{,j]͎ՅJrO:4RK[771Ua 1c;zqYgwaVRq^Ë,6éK1e ?ϗs Bs_7+BMZ뺹Mo4xI{G-JuVϩiխ%ӱFUuK7UO;dB1N^j.<o[vF*G[^Hs; x -0x@F^zj3iZW9gd QU ?OZ4J/U̪ڝNʬussj1<Ȗ4t]lU[YVI([}NWBolɕdןj8*}hb=RĒbm ZSO7qݔS+rI8dl-1Ҫ8-۩єtzB%IYl8j)*Sǧ<dݕ=chN4a;{WfKrm%}[UXsTl~drI"MnW+ʤd.6?3ҳq}GZElMV'^1ϯ?KuvԗQ\EZuq+9ZөW^wtyuRwz>ۣ9o]J1߉tO#LP$I7/79o/ ׾yQ~DQ_ȭl湥)AR.iWG 3h33a@8d޺<єzgO(G}FR598'*Oao1~Q~uy%̮e*2t͸vy켈%(.،ⳍNWckF٫B;1I8"Z14WOr%*\Ίr.91 g*r+Xӏ'ȝTB2O`B 9s*FTAZdeyEW;sQRTQF$j"4y+opڵ.PĮGo2^49ASoyTB̹{檝JsG186?v{NgvOihlw$܅fwQ%qy^I .[~]J늄=;r&Gyuo,k.Wr˓ڵtε*<3Au2_Bż!DV;d1]ќ*pvvꕻ*^umW_>%#9l#h#&7̒F[kezrFx8+`嚺M7k>ZZ4oZOυ-w-NL6!y*I-ttiKtt/=3⏁Լ= {V ~n$#ˎNTf8qXY8cRMԚ¾5 \.y`rW9;f7Gq[C%ͱJB=޷<ᗊ>5纇r6;? H@x0a׏/ą$I/;iO[ZLjl?PVV6@ ֋<̩Un  R1m)drLi[ mxt#{YnyOMNIݽO'qMwN2[i9V;wPќoG*gOib9{${;v+VFJTnKѕ jZǎme--I2\H5ROϞF9rfEllzgGkuQVB0rZ~=]xIJ]J0Hup?10sXsrEs[{^_O׫^v*h[ηnXa"ʃpJ0?yXgR_:rm(lw>gqౘE5MFOIӽ^g<[Zۈm,1\&z|:Pzٿvzt908A.i&: ɯjr\Q4-daRE^R*Ae}z&5[ьxQ9&9}Ok[u$!끸H=sQ:4RN>j2C2y]# 8'$裌CK} -FR+&W۹R=uV=mF OSvIՙUs^G^SOTkReIzx @899sڽoz)_יRR-ej/kVvUl[U]ag]=~çxD]މGX~'T𼺕̝2]*(; <䃌1JYt4SUYEf֚;_<7R =6Z$fczu10sd`1'$~SE%ؑG鶲>c^{ztr%M/O5kܓ\=[We]˻yiޛo>uyE^Pd;O->WQ=od[鿧M^}kɞ}4a r~''iI҅}ӥVu*kmoʢs3/bH3'j f5(Pk_c⾣q5-'r>~VœȘTkֿk+]9kP79`=q^L)m&;=x:;˦;{Ŝfۻ6ORz\괭]WE$`ѩ6.}+%g9Q/}]蒿~#5&qsGw,aS9P4/Pj,<=E%s;uSSLʧ||*wVZu{iΗ˓k'ꌱ UTOLm$Fl>Zy#z8Y9"\L7=[*b4Mr w/6SgUYo4k9;n6r~lB{ѥRSo|kwy{˫i7%rO>~R_]:]_J3O T/î\An/cWap3&=ۜt5)Ӯj_ʜpt)wooORYZK꫷wu<= s^ul4[v~g-]Xi==c @cp3z|n_Uɩ-*i!,&5c1=}{}+ka#)z!U ?&񖝋H^3n+ղFv; Jqs'&fwp1댷~݅{OZ4*5\{˯0i/$v鏯׵}=%7쾵l=IY2u}=-w2յjU{U5%NDF?2Q8OIv#S(;v_ihc۴O,?i.r)Fw^G1D>Fz;Ey$?ֽѭR ٫`q۶VU.62(# sko{%~*eQ++aokwf697$W]k59=O#׾xv=+Nkoy>u8'cp+J[7ft*Wާ3+^|VëV*{O'4Z𾞾Tq3_-Z&?(bٯDiz*;ult{r4+1?gg*XF!H'w<\;ЌxtZNĂH#n1{}+8:5*^}iuRU23y)9X9vXQÜcDh542W1]Ǟ׽N*vPճ*9Ent;gYmU31\ ji*/ep?+v_}7[mB9mڨyR_'c$ީk><1/6?OxXqs.4xy1 s;TMjuju{ѳECo?jw&%HշyCNq폯>uKaRQV?-X_巆$sӃaSO3IGKm5pChaF?xOJ=%{t;pԕ?o>3ztvwzrC #*B=[o˟#^:Vs~BQiJ1w^{^d? |gg[3pe1 {sEIs>pFfFgͰ`7'ހWoo?Z>Yk㧅Z*iϜlo^g= Ƒ7[*z C-K/JV[Fjmm|5TP GOJS޾fxժ_}OqׅStQ{Pѯ~o~+YTzG5)Ei^u0 ?:@92RJcgr{|y <-m^1OT:)⚛ԙ/-rܣ{NzfxWDkm$`Q܊Nՙ%Fu_",qRl91y,WDe&⎘֣kek+;/,kjP3s!#3~g<7#ڷ7- ӎk5 덫ɍ39$EY(/f$Riqݏy[Ob4%!\+3|x^+#iѫ*oIhv)l'r5*vذ*Dn$/s'U8i6ZQnnXYm#Hflx5ңf*cZܫ4r s;NSMZV_Q[*Ċo?iwQTzDYN}{cӇ2驤#ˢT[LŹJ(ǒ 2Ghl󑞹 )rc^P["Ic'k.?t~Y{ƴ-e=w J~PNqZ6hF_Ai* +59--qǖQIeN 89׫5 J-sY~b,ۖeqS/Hӽ7n#d۴*wTVK^,:ᙹtwo\K;~n'y=:tcʔ}ExY$p2xD}×,"{W\3==`i~/(4UP8/*TܣQ܎Rt K*cqnNUӽJd7ѷ*)ZUԏ.3eeNqs`1c"6ڜ{~ }+fm_1T|)FRjsʤ!Iɔge%'A\J7.WFl[I8j k_C[lfV h:tޭӔpTZ3n.#7M:k&jss-32tyRS7e.hӺhe|zu.Y;A'g޴[văwӧk)s^FtiԚdKr3F=2 u{7hwU}2Xo43;eɪER6M5 "9 $[}g0:uMUMmb֥CrۃZʶ"6 R5=GuHpU'qӥpYTd֦1detۅ]=ڤV*2VcN䎿yNx#FXUۯyuG(֧-ƛ$D7S^%$UŗO3~Cmeܒz3΅(ߙcI6eWeYXˏ?jάh#l h6\>*Ͱc8v5Y`uWkDt9jQ'umYB(cج+x9oR:bQ:SOV.$Dj<}iQuOGsi~llXy|ͽdӿ<⺪~V׿cvkKhLI~OgTzT]ͫ=EަHoY=u'G$*F%Z4mQI+)fp==:J)58G64+e%j+7A?O[Fqy4ˑK)]zU{i?yNjH}̻dtBC~<֐+ʭF}[x]HGM$tZF1=׹N^Hˉ$\p3y*!Ѩ%ͥb^8qB?w1rEkHjcNN.SX7\؂ T)^.z:[YC-JB|a2xpoZq&TcME=/嵈fC2Lͻ,pS׮(KDyFs^ioS 'D0'-}*cϑ~=@TT\8չek贵Ey\U'>Wg*^d7v~qӊEOgFt:iy#3)Fq^~9+Ǖnj:84⹒Y-c/!b0׿",r~Kϣ7tkQ㍝2 ֲZ5y*V5vk7m4pm՝Z9~eW RO*qԟmK#]]K"ĥQ $wkʝJm͇7OCVVmdΧs1ꓭ,M\r8=F5RKM59*`JRFwkmZy#7*F.y R# ZۣlIe+,,^0Xy'8 m.wT~yijpk$y-4IuڶTjQ9!F]vfl%1mw9Rwr;c=U%>o'Na :]5dp܆U׿+9TMA6T=bYZ\u%EimjT(fG IT*RïwW}>`b2su{iӍWy*)K~p-|?w+a*Qyn#OVIhT򍄻60snƪ9SWM_Tq\5r]yVfSgҴR5*r=:eJ"-9%ftt| |ͥ1w**ksS⯲}N5=fbEՑ!Bǂr.}z}k5NT2iùSխZ)wӧxTt {}=u(m~7~MI.Z 26U;Nˑc;4'xبN_%ku!!UQdA:D.֍zR^bL?C*9߯\~3g.u6姄U&2I2b`3HdsEZw^SlfȒ1p% ChrQn1{/Mʣ?i+rA{ \CwpFTuO8$sXj/GRmI#[\HZxm"AOQ3g4EeZ-u/VEiomqRUfPAI;I=c(SMZ^f8aIR]{>,1!y8OFyl >U~휵'Kϙ{dvdmxדҝ8rnyF,Z;)QDQ[kdgO($KGӯBerNce9ʃ՝Sz4ʛ]n'q˒#uF;-o1ʤk']_I{0b*K3 屚ʟ ?4tW9SdeoZBZ ̰P85U`^_ѧB ӒCpdd~V8%=ԥyZ[2 ?2۵yjބie3YYāgeTo.YM}@ͺ&QIro"6q4/|#`8H(XxX?uRԦ.Eڼms95t.NNTK04/KDe)UWҌ!N Wt+G$x]AzWEXRbUHS|oHo)-|іG`<DViY:dQY 4.G2+];XQU[> ڟ-M$%RQI`x~Ͱ6.6Tǖ1#EIʦƔhӳwu\g;"f;nߕcG^Bry$n0`tǧQRRz5Yɸ5g7ٷI纨qRǮ}Y9=X*fr%zzV&ѵ5R<-8dqϦ:zT9{KfTfܙYWϘ*N3kg EW1c ;Z~lKM6؜SOZ6M;Kߕz[1'̎5I qڔOeT7)+OQl]2.܅?(aNM3g ^ROFRj=)>SzrqdfQ%}N✹v@NR#rey|?Zuݎxn|DZJ~+HZ:ksmpbF:<*Ǒ]sT8a܉d=B J2ۋqe壳EIg q$rA7* Tj=sMYch[T/e?}Gi{H#Py*X}aST6q{!$M$# t__ƅNwI~<ՓLm\D=ۛTOv]"E Ƴ`OU B/Fͩ8.͚>'UHFGρWɬ1aN]V3mHw0?tkũ{pB%åQ }aSIݝ(ҹФS}Sm# eA pN;ܠFRfvF(r$ڻ@Ϟ~3NF}շBD70l=XnKS5}FZ,s1q.޴/.qFC+̪|vʩ^N*.1N]Hgw\2N=F6$n8gFYw@YT{OaL 2K6oӷV'taZfƳK+l¹'e,$Zk]{,#쑷?xc94gR2ɢ"62y'RN;sʜ}}LcNdXbc-| a&qzE2}FSvBeJ1k=呢}Ln) 5->ڑ7-^U?-ەXEX*SyYMHla_1?N)1P.__ihvɳn@:e&Je |ꈚGK`Harv#R/'NKYkZIQ{`m΋J:wȮ冟1JQ7̴d\zM$wild1 spJJn&(ۉ.1ss涔jFsJUS'HB݉B yLOO&k畆zgѼlx)o!bgi1/)st(Ԥy[۶ͧ+%ݪT?8\VR5}~EfxEHˮSd`zZ.:oUy +ozr9*9j;%i˛o#33ܬ?ֳy()EbƟO ;&I0.w7׽*bsJ˧a;bSm#~:ZNu%X=7Lfe1~KKKD[զ۩j&f^FU Ƿ-׆*Tv J嫽S̹2#l\3q? 0u&ɣ2Edʏ/qx89*Ue*7ؔ^\]}9T.UBpGzZ{5cRU,.4?nLfgW.ER%eneݲ0})^)L+n&Qؘ:o֧N:빟v]KF^:Gw1l|1I[#F:K-$S"1#o8XS]6Jq4K6VH:4.xz+J7`Px\gSʹ~ #Acn{.!rϒLKǁVdclG7]I0<}j%%iFt!@_#y<9 +XTSaʵDmМr*TM%%{*'?/;s+>gtjG]m؍a.n9XMJ9Nތ/k}U01kS9yĬ6v2Jyc`QwuB#78=y9)sr[Їȕ.Vy`'8Y[sԂ[}mgn,?{=W Vp GNq`& qׂJ16?i(ƣZ]+yegy^co,[*/pK0;v4b[՛gF+tm^ ?W9}oouK?4wS!P޻W'';g>ggk-gwC椕Z=-SǾ'Եm4k[WKvtw`a6󎼑L-7Qk;wv<%:uOӷkZwvzM%VR!qr3}Z\U.%BRﱫxEhm `Y|\եVG-I8uG/M:6̫ϸ#M&\R$c(o0uޛb²ڸasE[MO*-6K(sDa[)>ۗm\+I b5VF1KiCG- U[2tm ӫ- #+,+$-čw릎gJޫiRZJ>v.nfgq ȯW˚ /wbU2_ç[jUIJ-;M"?CaNkyh}{4i9{9yKQK8?y˸}~=k^0P^2VgzRj/ǗV i.z(X᝾T˱%YK^XVHlrw`TwXUR+=|z\X_<{gA"8U5*rM=LԊkiZ7Z4%tbQ66{k J֌iK`TN6ZRV3VTnNPWlSkveY`7g%'XPEiw̧v”6}v:#K~Gv'ց7]D#1pua2i9+bGֲ;݊*-jX[ :ûcҰc̥)TG=Ks886(ckRp]L'5*i%k7!W:rɧtZΞA3y03ҜW5]r֥GmmMIT|NN4Ek71,ezz\%R5v*xZ2MTZ54flXط ÂN3O{/fOv6,'m^-Tu{dqkʥ(SYI5fuZm[h]V$ULje-hٮI]#5ؽ4$)W yO_Z"bZR{it{MݤPh*"VMHn݈RtQQe޳u 3Kv~b#?W?yN*.:h|cÖ~3|O(ut6*1߮28&~f8aiN|cX [̸Wta9dbHu.ѭXimtd$qۧ3zک~22N=S,>M @q=CY,5:((/F2)BK]0OA/-Y@rAt־hqXJ]O0>(x,K$~qqe4O:XsWJɭ_i !~C;`nI:]ya7_]L**q~oGo#Ȍf{F=:cJކxMj9# N\F+ +{QƤS_2D89 JUj8=-! D_~7sq>ZJ~m^UbiﶕEvUl6 I(U9hѦufM#yo~\;WL*+MF2'u;8ViO'z.U$=7 ވ$k|`=v?e0)'vE뿗72JٝRh~h#*.Ƭa~F*8%hKUZkvӏ-\4ǼA ߡSTF;kvݙ0CnnNzUFr;R\jQֺhٙdlzGn9N4hzѧN.Y-. iB{n# MUH]SCıh ctEUĊd g= sVy^9JR|kux KT{_j)7n7+yrxO*sGE|;5Z3]ڳ;axrIc60^e%S{Z슑&Q[[RmBFcasVz y f挀F㧮W\mqV׷wo@%;,{=2 *'wYaӭٰw?YQ1N͝Хj^+qýgWqҴ;&$]{c<ڽl?>V9Vy>owWwލ>ǥ{rg.U{Aޝi.hѿέr=H׻F,nf1OI{+L%]6!$c89w{Mfٴ.`~x\UڛrlDw|>dQ7*VltS˹Εܴc ^ϒoru)xD!NNps\ݱDin<.VoB4bEmƭ"Pv^m˗^~)/ k+Gpv3?ug{IA&2YZƗ[$ܹ nGjabGRɭ8{&}KףZ>pji[?>x'^]/:.ł=xz`#:UtnЪJ],g|qf\Ô4uy1oy(VB5 abߤ亽Fk~0i³š\}Po306=0TөM|J˿7(o+u?U;چ,y#Mk*rwvʚJcńl^[/1{vqIŷ5vukt:iZ0ky͆9U'+BO@J4GZkP2B @{WK eJ Nyk=-Ju7M]Z֭!2/ݚ᰹c8q8xǒvѷ޿cǦhvG>:&X7_٫uVmB 0S֎ *S\wnZ}Վ wV\rh?)?L4&;[TU`:ޝ:c?v!F\՗cjӯYNdzN\[RvȭyۂA<λZaƜ+^_n:]Im0Xԟ#L."T J+VtO8M>#j-a'd0u<~kю]=X'c0$Ox>д;Z[IbU[;X)P< t>) ֭HnoO^8HU/%s7cQpT#<֡RXyIiYu}O5;hOyQǰZV_CZJ\vfJIq!]8[t*Mԍg8~%R7O*ҔW,M1TUK&$pV }kQ:6Oi*S.GwCYc\yMNkJ+A}ѓteRx[sRcGaqu%qoOùFrTIqʥ:N={Cqo<㏸o2R>eWVXMJKi>_^>aGJ0؈T'7u!h,>oUT+5اz>V#ucft.u^;bIp pf uGNkbx]ד6ogu FP:澗M[]y'?LpQ2_OdӵL>e%fl?NTP^9}qIn#kin $l,8%IPIeS.g(=:: ߶pml[qrF zaV>*iN*?ѳỊ]MukZNK.=N~zgF]o%SDHR_-q LBĽǧ'8F4Slt-0i-ȄL K<;tiQY{NNeϩCicYQx_{4:uoR/>T]ĖgUXZ9I8!J6j:{:tz׊YmbiV/V=9^eNMCk\K[75kM/<ͱgl:qa~ק;CEk:pG3n,tneF88=+s=|GH>x{MK->"Mx(#?Jrӿҏm]캫ٜxN@a?2Hr#"pvzw=,>Rmtv*.qj\*۫!]ɆʒA<5^4Vz}eXTj)+]Y|nċsj/+\c|5f㌜0=\)Yݷtmߥ_K+FIOvvoEѷ~I~%*_`ݶmİHrqs 6pxs=9f~l|KjoKw~AtX+ojO-MJd rᔱzi]/u{x882smj}ݵ c{ D$6trN/02;r*eY;TOKd릷8rZc/Pt#\KX~e8]'=G[,MO'g-/[Rqi^گ!!"\ݦ``J݌ 沧[JRuNz8F8Źmny_bU%WLjl0x (9#8kݻ^uo8d_-6ww_s^⦉Mwl,r+}ɫ:ݣ͝|p_vWMt믷X-Wi*[-Ӟ0H~WYL>Ox2h˧jr"D\C2x+SZGs%N7Kdnfi6D+ WQRݴ1xW~Gi͡M# pN1TƤjuU)\y, 1d& Upy8p bԗL&< d@9tjtۼrhg|~>*˖⽵V dfT,xmy=Q9KJV:Z2؎8nێ8#M)$ޝlyXƭF巚gɎK ~t,IfA|RNd{w;՛DF<(n14{f wxتV^vԒKcf" =]Z#egQ>e4#e Lۿ(ŒvEuh,wQE#B*mίn;#ZjYDv!^T,b߱qMۿS:PIinݬ,/8?*8iRY>nk~"A-m k. GCckShb0z[G+p(#_?=J2^*/4~Eu?.9!}7hyӽvӔZDKMj,[n,HBұ<==+sCIH>„y$SY.8JN>z^kriOӊMuWBlG`˅U=]*KTgd}ʪC 4k)|nCZާvYF=W-F,»w~4_OAJn*+*k]7,(wUv>EOo=iƟTys=$hncU .6ס*(.s9tV}%"]wۯ\)V[IE=6ɼ̭۟I?x=qJ*T5%h]BfnD261<{\q5kXZ4yIGA9 vP?t8Ж궕OH^Mn˙OSsι=tS\I.#%uVۗ\rTN:F2\31d%%Rq򫒔s FHhPm"ZUUclq1le*JB ]0zq[T.]p)Sj\~Lg1W Ü*JrV\d qn:1oLs>Ҫj 3n_J1RhUBn3ZXl\Yr0lM*3tQkk؈آF܂ Î:v4 r]#:qwޅ J#}BH}iSҤ\~c%Q:&Q|v]rf\m姫o%{Ea^c}h'=k8X\?/(j mUV3殜&NۧKqF # FMsF\S&קbYcYxy´^ƴ՟SxҺ!ICXf'(%+sGTvOzvflИ||n[kHTsS9_5̒\+R89ZrqQDhЦ̩qr/9ݳN9(4f)NM2o{TTS߭v:t4ў`ib­- ޼rƔQlڗ4g2ob0S]Q[ D`[hؒ$wSutFuFy݂{V/8Ftֻ6ZQ#*qj"+[[#T@$;p8ZSܟm,'Ib$v۸YpIϮOZ5)\N:r[~Ǟ133֮4) (ҧ%3ݙDxo\Е>V38EMn_yfMZ\u#Intԍ<=?uv$͗>^MrF5%K- ],+dޱ\ߧCaR^Ʋ*reg-„FQ}zuS汏4UnhZUfY!]GұRӹ|VU}M=&A:CnVc%ZRgEeMȟ4z~_rJ]RyU~/VqO(߭Stra䔴fƗ ,wrʳ+Cټ<%Ƌd)i9G|?iR%勔IұPmvy+NEQu^קc/<7-qelfUc83bq88z8:vkoVއèRk[o=柡V?_ڻ1 "Pܩ ZjE.i?_2'R88ޥ^]N'gX]&dA##>cR7j--y Súh[yyOߖ<K&֚ C{??'Uv+bǨ*DN 6O3,N\]7rǬHwGoo6P:'i$)dq<Ԫe_*x學f#áoa7U 619pWQp\EV=w953 \eI{omು%U#rdd+c/ԏx(_ ]]>%Jr]g MwPo#mBK)CYFpA`gԴ cP]oi1ac4; e%0 TRqz?/>_O qMkmqk@_[Svkp>q&w*>lrIrk O6*u(sYC/%_]\Ca$弙[sd6z,JWoU'-~ N—fI lH@R7v+ɩw&ө'Rzٽ?#]a\h# UiБӂƫqvJVY>f׾;Q<3i+ n?X؄f' ~RaU&yh: (9=U1֥ql $=\'TZ\Zm~G)8>wk/Եk\iLEcd VI}9a kZ6-]7 ~-]F?Sh$`pA u4:'h#R>i#ׂ.Zdb#hTӟq_'k¬D5kkoѓNS|P˙4}IaVďw! .2sq@@:U[}G 'e}Uwqf#Y fY-;zƥœdmV6 xxƤm~>ڍl@/h=@Nsָ8Q4vOk|zXYSu7oȯ+U"\K,YT2}ƫZ8]T2R#4Hs^|('RB{Qyw79CʥJF2Q5wW\Ͼh`qʯ9e$ b]4~Og,I^ΜFSѹ݌}չ~+F1хO{fGpR3<4W.E>_ 7mD[?1si'NKжܕR J_~2mMXy FecTӔ=ϑ2;+LUʣU#r9[-I=㭠c7 u'#XG5שZiV&a#(19N<=IbsEY- vu >UaC^\.ў 1v¬lpo*P@nvW*1Uc?uk~{2i Y[beiqw 9έ9Jwvn01P眭'{5.{Žlcx8qCҼVP婯_&osFEoeBfXcpsn@?,$kaܥk=7*ZJ=jÉ=ڟ+e|$n}k˧aW;kR`#Ǿ#Oyiion<'pF3K2,-۷.s޾I|Ws0WRjJ}۵X\3?>cWU?˞:[2*2Svӡ>6v<_P+omk扞*}d;3Sm|r Kd3=q=UQ_qsr?OZ$wN<`F28BXhS[ux٦_kyS$cI\drS#[꺿>eS/zmӬ$ (-ўv3*eQь$iڬlc>2Вk1< ('=N<n}+Q2ݍFamx?n ?gCh-F>f AMg^ֆT-oBƷ^MxjOEPBϮ~^Hsھ/0e_}<;.ou{8=cXeXH4e]==T wB8JG=J8 ⺏^_y^Z?Byܼ`~] ｉ5T{ z[55 Җ) N28N? r>/uaWRR>|;gH97a7+r_x ~iGK0+SGy-;*{nk>|mFR#]I>q :jn_?rW߾M[X_Y_Goo;Dv|М`8"˚F]|<.-{Z˒]M}=ִKÔ(c,泝#2z^Mrr}W QJ/{#_[Xх&X`q'c[0*iuf9Rkm,8<4\ƥUIwq^%j{*VW_-LޙMyjGgpU[*.y-=>l%[LgO[z%[ R7W YoO»)Ú.+I=JYvF爾eoo+ZݛA;q׌zzzf4=6wkJtR7_ sYյk}>WGA;LN.rvQWv=%HᨺY.>#x?0obed1/1$ddco~xIF][CŘ\;^eѫm6|2|?Ag5Xbku"B!F0qj2JZǹ^e}w*mmω1LQ#\mڷ%zp.94e)ak74>$)1dne?'kSFwb2yӤk?jpi#o2<pH;RZ$q<$#vŬ,7 ӟlMBU0s_ Pw2̘p0x+ZYIsD2=.j:twF~ay_7XqGRԧu;8w&6r*aqy[vIVm|ϴy*88Ҋ{'Ѵ.~C[c$F3NSxZ|N._V?qCU*:pW:~g#*ad]NZ|FytpG e \U$mSYJgkcm=Ll&b77>ʗ3=*_,T1o[Xv:ߋbKeEwI X=TTXJO{f/vn Y>~Sch{7,56+M +L \u(ԧ;n^3p5momc?gp}pz\ܩVKcTUad<޾~(%tU(rqv_qNpir9?OVxgji-#Iz5fd*~=_z C"89\Χ%kmmRJi.,X1fF&2sYԬR?SeRN۽%>!T?cN4Tݻ*t՟bwM2Vj %Y^{ήQ/]XC1gWf2xZS,OoɄ7dۗڬ6AWdcJ_z~FDHqۀCz皥JWiG O&g!?.w<3ҴK4T)ҕ~Ifһ4ؒ]-EdX8%~ah[a^7 .{[${Vx8=MuEK&KJJVDo݆ rv{cT);WM?Eծ!^ - 6l{K'#i{*4.3r6sz5Th:p5*Ѻ\n ==y%S<:%>Nny0m|k"iOބI`+0gݷ*d3U?zjƑ)1,1οi*5i?cHI9-6Ì8<cҗ;GG?2HlUVL|=qק?*ny\*Kdsv1,]<ں(LXY5ń;F;J \ rԗrNUiN%Xyj7q֢5뱴Ǒy?~{~uN=N%>Hn^{;x5RY .R7 mZ5u٫OnJGRvnM{vL}fL5Fʿq{ӏӵqKF.[/Q8SXdM:gW*VEnѐq:VPNITZ8ZNuv ڝ[ZG^}Nxt}iReF*tk'K)]W$R5JHFM_8`a3tXWZiF"4jP̻ [rkFRZ47+)w>^+ 63*x:rvuFƶ.fNC0nsʕf۱!CSR}bi*kwضoƿwT8NjEIF,Ɛ}j刔 jAJԽ/<@ W*yk'oݰoމ \_ ZZEJ{˳رUm~_=OQ)sv4a`۳tcN=wl4mTk/W G.FƐimn[OT9x8s]KFꍭ:X_-㕪Zj<0Z_,^OscOhn6E' &cQڹkT.څr)w}<[ƉF>a߅?ҲS-[SyQҸ䶍&Fwgjf3FKK2 *K p9UΧxuO *^p֏{Gmc9V1Ffn2MBz52mG}jq5"4{(ҋl^l zⲧ/zFKRDN:TaMGߡZK8icoϧaSݨ*ؚ5*:t}[ b;?7?6A}rU)GZ[X+p~U!m~uẹ(߱z]\W5('L+ԺοiE|=GZtg{y#9SHMi'Á< G\J+mNi/̓s<@z9*:'%MvjC.۔pn3\ D2jrӮ$8_\):RPїAUcwkD34J|'g8?t7 eiz#c_n-Uœ>Iԃ]}8iRVy 9#[ڝ/~)˽:t*8{-sWM+xi]{AӡkkKs_.cm? L(9=1ڵڍRi*I^D $R''uȻ_dU,Iz *g(/hZ/۽Ymy{I#~cԜzw㊅Rʵ:c:#?QnV6W=sҊqio~#^v=Y.@̵ֹ4};_B+I^_+a|IS葅-1g[e;'瞿#Ssަj ;4rHUF.1s7*u8˹cڧ b20V5bsdaJ>빜iJs~%K[MB"P;=z n3Z\{zjg}٥-"1ClSOlsW=K-qJOhx4mBċ7ZX2@A d9EH~Ntz#Z^Q3V+hT`I$U0^ =\UW]2=J+]u,YAyb~G 1v>Un<}9Grmu4 y'6(̹$'>NJ#NZc+ZFK fEkq#:z, Ca}.$WxXgmxjE]߱b+Tq,r"Q:HllH#LYJu$ uKؖEui$rC:v'Ӟ+y%˫oq{ئ梖b3[YRrswQX6RoڬHĹs1=x)PgȖ3>6ٶ )1 t #r+Ak硝2Ro[{St(,_݀Hl嶮ȟSjbլ` ~eHRuxZap$ST}#4*nj.92܏mcZt煋Eo]>q"oETbz TOkZE{w!K4} u(s;ȭJW:gkļ*ϵ:߳fɹEB5ܪ4I8ڿsJU)ڷ~3 RmvpEf8$u9gTp5=[z}A6zr<^~d+pHzc:[vapRԣ}cV6aIf2ʣ22O]Bq5_(SVw~\kSkh1naݯOk;LU,r唰,?iVƔjO^2B.OT嘁?JSJۯuԔ(h٤F[MtʲH='HQ+_Rhx7we qߚCWNyF45ۣ]ϲ]gn>lT$Ri-mՇ*~ѵO3IdM_J8ҕ7N6ǙR72Kϝ$jc9(#*{1h]V[ci gJQUWG4o[>eUd*WU8cTZ2TmZ㧫VpdtޥpNz֎_iOd䟗 !_:}*0=Zj~GU.Z!b2|ʣY98ִik`u5ZyR"ʠqR*OZor b.Fz׽_J3KzD73G(RxJ1bUh-wэ!rn7K E5Nw:J;?29 jZ(ѕ7hTKHSR]“5N.e-FI H$fOTdv'Ƶ̥{mRk]!IahWv(eL8F#J~A~TUnp1T'+]uSe {eqziIvij59$:)BIorsu鞞5̓*YTw a(ҫ{g̮O{\MA7y5V"u_\pH>sF0ZPEl\o9g&k֔k5wWpxHEgR4S*_%6fiT<@9y=N^E'/[( !=yU(cob7'+[,d?Qr(Toyyh hb_k('V~9M[qaIʻepR3zVÎ~eS2OOAcZp^]?wSB<˥0(j|wo$I(o;+x" rA*#'{VrtS^dfpzz݅DIYDog)+瞵72ԺPaV;wHTzrmCJXXp~Q˪DP[a2՗~aXMSk6|ń+nm#`7$)ˊ^ӗ}}[,bqD+ǟFJu#tܵ.ƍn}F a-dzTr]BuV܋ێs5B->U"FY>Y9Z72tc)_}=7W=;9FpRޞQ̴K{fG̜<5j~ͫ6c{fX>g"F\猯s'R2mS)ŵL{!ó1ŽGO5ڱҭ)*o#\4c w yWi\uYTVBg9a(e+ӊNբ,\cr.d}+T4QJj0C_̕ _SzUDʋݯnK![vp%sgrctyTYg<l*~c/>w#%_,vdF8$y(؊;S%.k5aF?94oU$URFr0r9O|Ot8KyI;lEhH·ŊOPj%S޳V0A[Wrʭ [ZV{n_[aWwZf;2cd]W"l;U10w>_ʥT~5(ɹ~Ln]vcJ{7_5P3$U䉲>d=F{veaMe{*t==+>W՘ԃwOEИ $Bdgd}i9F׎1U Fѫ[lq;*T{*R4!ViTLƳutM:$eRHÜ|x#=}qZ>e#iifrdfU'3rLJ-h 2wI9ʢ*|R^д5!׿N:q~G."ܮU[=1;Թ^W0H^G*̉{J5, ecuܞXoϿ2Q*v\_O""ܳl˝V*t"6۰ge)K$2gĕfF@T{rH-H,1Jɽ̄dNP~JT)nS_%p!>Ƴevh8Ϛ2d\ `yK{ݙ,0?\g?c$%C^p(FQ,ekEnr Df}LR͢!OF{Dve~VuwuRRЎhr}{we;ghWrx\uy =/aUoxG\o:Ej:N۹fe*-ܫ5R橻1ǗKt4ln-R15롅*|bC/}s{:q[{OiRa0,P,\y :rt}C^J. ;HY"P{jt(zU8:нk3 ;qܕM; xU8%7 1GR7zsڮJҩЗдb2ߜ,XCsS»aˬe.OyY6Rye+4y{JjG0JIR}F\(|oVqP 4ř1=A]*FTIz~"kmV=I:=;z׭K:5gGY;YV+4?unC|ci6zɇ!7| gЌ< $gQ̰o*5"=uÛVS6ۄ0rHɯ8xzi[|S S N*U%w{ً VYeޫ1f;RGulV5j9$3&*RIoFiX -Y& 0 r{P)Ŵ{zՌ}$h&L1G T6)˗V5['Nuo22PAyHc1#E6P ߚ2j_Q?q^-P1IE$`z'5|jֿ5N.:y_}kBk_9fلW$u4[[hUÃIv#hx 0j(N2Nc'F]¯j!4nn#S*]{߯\җ+甬Hc>hT]oߩƋdK0uyΥ7&IөV!)y-yl8=9:qq^_͂R'Oo8[ 5Vn6qvIFO?QZk-ԛOӼ>]b}>9Qn~\¶EuivLCBNKVݙO8<9م5]{(m~|30(-U6Fs.!'vs㆗(%Kn>VMB*Gk=|þ%5߱61F(}@yӦQ{ݟrb,^w;-~JZ6qU>Z~~[ptԮ^/xmOTMhg?OR;+a}m%da[-i}k'Hma_$kլǛ/9内(ky^k=k/^cϔiZvTa/݃ndY2j/2)]FL8\]~DS*{_;P>; N=;NIEۛ_cP>EHTy`dfTS {}:X gFe?0`cW,uIäV3#RbUܧ6~%S-dM!bz |;=_k [$ݿϩ`kWwWv{(G#*6@R1G$ m)k1%,V!QG gwNZV)Kn~aVwrAu`Z)ɸ6jΜo'sTWM6,2]jn*\zMjeRսي/kI޼ڜI-^u,5-c 9 3ߏǑ^WCI믣5(Lg3y) g놦 U+dN0Tszyoԣ:o=?:rQuF><y =ʱ 5T5oiR歺*lDxTZUUxVR\cmn8wS[}u]*S贈ih[i8s2g s*Vh>=IBR\H܍W_Xg8D8uƮMIuNާcߺ \gzNzvv]KZ6kaz}{@xkRTRMKh-֡`=2+7-@}i(>Va)ɺf]k*B#ܲ< :gvɕJN4y7ho,Q9f{JR+fνݚn|?1.s(ө*sœjTʇM}b Gfᛷ;ӧM9!E?*B:u)芭׳Z\c*q8qYԫ.xsr:'ij3LFd-ҹJ1,U͈B<7M4QzHʿ4DH9ly8?pb).^2G.h/U2}d]Fב=[aimխaC /htZֳ[?3G\Csҽ,O%JW}OJ8ZR|lx{ R/8ZE'ןN'ӕYK-I>=OshzodfS988;UXш-LF*|'gZER杚#ӾR|#6$1rȸ=3jz9{ڻ~7:b͌R2G$ W q]5Ǘ=Ɵ7|Mm>;*So_U~'g7:>[7B3C#e8cqC<qDqm)ּiniUZu#Zi3b0ZtUnmKo+.IlYi#Nw#$'iJ>g_ئwt]Z@r.83o*^R:eV-};AZ}؅*}=/SݹF6lO10V˪SrʕDhh_:O. N*lugONk;i}(B瑂H }+4}8ߡS4me0B%/d*^++7ka#~--ku+Nno}:vVy?>+Od*-6ǥMY-[FS[H_65)$Oe;v9\_pg}OpSWM/!oORMW2]H7nF1}kXXP{~wӔ]XEE߯V%-FWU qslvRv+sZonzv.e]=N?Yh v8D\u'A;g},Ϲ*^n{Kc(!VwqاZNYPzoߣ-TmEU08=15+%{Ri叁Tا2nKG9A1V H{Z+^xkOQ_ (Q׾x]0hݭ}Ҽպ 6\c-ہө>[^Zu+Yt.YEޭ!{p *֋KRcőEK)*#ˆOOZ֜$Ֆ殌cfB}b+/qgq@Gnǚ\cf$:sydW#5Rƕ){oOqI,Hs&ϧ^va\lMO-1a4+?.Hޫؾmql_ҦrIʷp[!ƾO>=ӺGƤj_O7:teizF]G 9uA+<[<5;O#8֩5m޷9W#} "I"_Rz#¼V[)6^}լwM[uO?gϏ4lՑf$v1’1>!)Ti< zޏ4;_ {\,LVHIu'>fQ']>ON>*}SG>~ai4!W\'par2aڥ~_wvѯ*ʫNOm:V>9^M"ܠ7L*1=ھJ}me/rWܾ^VVWvZvDԔÕ+~]c(ԭ#TG ӻ`o9%ލyI,<+uy=:j g$bv|s^mUc>y+ݻ[[%ӧ="8>Qx֭F5}k%n]m.gfP--lC܎}_R' ;uv Xiv߼s>$hϠ h̄yFIμeG Ջ|]R1kK_7~ZF4&$nwrA O><.0ͳՌTbwi~-_>OGWg|:/~Ϛ >%khWˊ4W>⾚WBIZ盌VǓ>k#w/<ᅳܡD2| iQ+ԔͽjzFڴ#Geuu*mv|ԌeaZ.gGОmcNCmOg*1lD[QLJw/4wn!9f8>(m冷[ :["eX0y kԜg^)QqRu?mFFݳ o{3쭩<\2k跷ӡE'^F2jɞ c-|[(lh ӞOx:,[(Gr0@4dژm:t$v,`cZ9Zt%ʑYe{ؚ]r~VO~2uMîZRiEfNP?(̧b+iש)]N=-swéAGk'2lI g`*jխ]}8tF7RnKGd :,z]MǛ k D !9Wak<,sw`ѕjןUu{~WgIw[6g6.0@u9m'БF5' (Wʟ2WZ^x:K=hEz ϭxRQ咶]^DžR.ڽc<g}(2Ws 6睠`g\jIMuHWgjckV,Pħst.9r2./,vsF%e1 Yl:GWtqPrSC2T:K qHOp#^G'5%E#*Sv_>)ȍ;I㊺2]#Z2F<߳Iޖ i^s.uN@WR[Yh_QN*N\׶~m|9YJ_b1Fs^[SI]:3['A$ͧh& .g19g  kc(PMZ Y =Qs;->ۯ{t=gᆆ"kbg fAFs~!B^[^g)ҵ5g3,̐XcUÞ=1_qhXEtŹ呧oT6@ HT*j4m܋+ypnjva_jڌԭne,=,yct.GSUVFF-i/VLUEGRub՘C$#3mo)#z,#utѧ/wr&_0;qk = :nfʏ$l6%^e }N=5IK#9SGf;{OEd. ' duUOi>TGgn?:#kڱGUIJˮN7+%ԅ"/?v~U=۾r޻GOZT+A oCJSEږrw4KJZQ߀j+b&7= %ЊR-*<2-Wn.W(Mzcmnp[N41/\DP$Vn0~cۯm6;9SYlg1ܰ]{V5䮻FUUoB$)[8ʲZtFvfW)e4oeJY6F]iԜ_뷡NRrF:jҝ8멥XƵ5SpdQZB4(WnYϔg)SCREpS^5z7th<sKpwK}+v-]ΥZ;.2[LQ\y^`p.ק>6֋ ȁȍ1^ 3P^,dwJEt(6mOܯw1*ҋj#Тڗ{?j0}Uܐ@ BwNh՜P8bݷwb|$㿁:o;vu{*K4p 00F:TqSt=1Ɲ[>[﷩QqlIgq-&we##`<:_ǚ]{H`qz=dqh~ T }sIHTXF8?6P#rQtф^G Box#ōzTm%lS:. 鸁g|3V;ui_~Gx|"yI}4m)qq䞃zEv</ggS>,ɡTZ|su-t[5Ϟae1z2Af2M<>!Iu^ud9׏=oj~>M&h|YpdeͻliU]2axkZH{zg$鱉Q$~T۸pW)|ۺkњtVm[zkcޭx|d 9緮wө)SiU%w鱍w-uqnu"^m!cxUy]=|z_y<,3o1 Դ5m*+[du8z/\8nI>ns(ˑO_SˣTo?Ͽ9o~\[ wtΨa`y9\`r}:旤-wOC찹.)tke=>HaYnF:miʒ\wC8+׬Rzu۽=Nk^o"f75÷'jSF^y([/}k/0vh6 }sEO5vn]7N|dz]֍K><4vG͝VaV^mH~TZ۱ ,e $VXM/gTmch0U^emq8:NǠ fiLN ?e~hjo9X'-ySPNmXZ.sұk/w}=ju)]Ksb`ⱩKETXjYeefV={׏O٩lump!^d*rXy{8q:9'[ӜeJO\OAf Dcەҹc[m- EBqmc| JR>yXI5$k F2^zq]]*<֜э:-t:kLPɅWÌ~qSU7U&vcV8S^,un 8dg|N2Oo˰>:tһNaMӽO<;'@K5n!vgi.;68W|cMTMedM޿/3ԍ7+|]ry&?4ى@IrÕ:u+IIsl_,S^_>1ѭ w7w+ղZ);]i̫-6cs ٕ~2r:܊(֦.= l-w*{J4?d(|#fڊ[A<zW,74cNﺷ:2dݢޝ^O_Yj6-2_Mn9fk ?i {78W,fTy6="71D `HlgJчmu}jڌ=w}~;KӖ@8<2q#5xÕG>_S%ڤZh6cpsraOV9ws052̭y>ŏpNvn={cOdjS1R]4}W5e,6X62be*W<]51XZwosV\U2⦣z7ﳣbf2!d!u8ܻI85a~FNM}u[vgʄ{ޏnn>s|K=k{`,v6#- gxߗsm|aS4֗zKܬ1М+_7'G&¯ժkTs^{W%f;mvyʭ(!1>agUa)E;+7(Jhq?Og/*GVii3lpj]k.݌O-|gi>uut0gBpWۿS[ӳ9T)3M_x-dk͡^N[$îquF6+G´pIJ%q[V8v%Lg fݻv+:ЩZ;9[_]WePWerҺ:3ю9_R Iz O%)rդ.sCAyf+FwT =YE(Eik:8¦fXญf~ ݾ2Y7FΚv#YIɷ Nde9֩yr2K:d*6cJ*-]OK N66 MYcۻB0oJ4[;}íV"VY$qgq! 1I$g#'gT\ױxis'/~6՞g,񖑧Gw̰H P ]۝@^I$b㊣96׭&8~Y]]$wm=y j~xWZO]oF#LtkTO>_5ܗS0`w?*:wBOFuo4뵛,7oo¼F)y|}i `[Q>0޵XuSXGEs ,HqӍNflQbogoMwF\2#mXa{_ j $2uaԒvS#̣(?^ڋ$Zkn Q |26v;AGM`{z{Xx׊uK*e!Tu F  o}c<8Zî_?/?i>,k 7m } 8SYC/*_s(⯞.N2Eŋ}VX|ElbfXTF [>Z2.TEZ eH[9~u:ofGiJ]d񟕤K|mhӒ;JcZ^;sExK?*էjn} j{F;♒qp8c~zr| J8[@\C|:vTU#f얦j.d;}rGL#=I'gZT*ҳW~B '%g+5-^<ߪeNvmiFq.mԚ#\ y>NGRI|WS/e:0Zӎ=[ ;F( ׂsZFlgFyniOKiTY XXSG<A]45=Ӎ(Om4ʴP2+!۴˚qG5:g/.Y7$U =O~kNj2RVJٚ;4T\O= #oNre 458c$ۼPp8LWL&֥J=bk^okVU'tV*{luCJ:vȯ$F׸.7Y9]dܪMa5tܣR-¥:R-؋>\$s#b窹}v2`=3J1/i E;Jz/8v# MƱ[.kIaUf,38ʣ7>Z~DzY2d)F|STkFU-8ؒ>zΏTIu}Jڜ _}G4릆tqZ6PIٙvѽNy ku#m-ye|ݤ1L.28?^I/+ٷ-ˑb˯ڏc-9e;3[a4 ƫ t*%LעaVϐ'߷NXXG}~u$oO/#l34C䪰!SnGLZQiBXӳѿ3'^ngW<:\氣N*^sz|h{9K<ѤL|q=+yG[P8;3ujo;4Frn )z`^i{_CjU*F*Izkb ͽܫ#%UH^v3BU).[uuŊ攩;+k03Cӣ1*-^]JnޝM*r9zicIe%{כ*5(ӿarF*:s &O3|UDi)E:&'ziS\qiff*mNMIqMJR#{E!ߚO\g]h_n^kiT*<,AvxqatWre]KcN5iSMC,Z^Je&bGicTjѫ6-/Qm=o4zJjvm~fbe4N4,b攟C;PNħid޸ιP{ ^C'5֯J҄e-G>a)2vغxt] o*w_5ql.JRWHZױ\8I ;.aNTh泽[hUڸ*)ѥnRCZ#h{<@*=RqUV~E嵂ݣbM8-=[_yiT}t} a7mH`=cf^ueF6|xHdqeVr:s9R{run\C8Я=āxmo'g=*!sN%OI̯$b}1Zu#nh8ԣ{H(Yl#*ӽiNNRҒ?/U!Yhn+9sZ%hj ]3_ZQWjxV-<&mw۹4Kl1K- rFG>\sI]ѝH.K٣IGFU*j瓞kӔ;jbQJtܿOq[,\du>SrQ7+99@/ڮ4)T}>f*Tj. td-/tc8z:=H>즩<_ԛN[q$ۋ3n;ZQZ\Jfj̿Fm.EP;r>[)IBv:a:Te~k-j/nD<ŌB F8iөЬE.I)tP!Y.VNX=3';X9(աO&4I#eYl=jRR[”ySm?7'$JQ&:2jW.VokyJjǝݴ[ediIW Kܑ=2zV4\GFr*eJ:Q+]G0+ڀz`bV咄_N8Z׭.:=DƼ':NN^gOBEU)ϫew*8%sTy˔OlZjXg+v9 {S},i֧YN U;mÂ=폥i֌o~T[^jc>WٷAgn17)-SSOѣ#Tyv* ׏|{W,G.nk9Zl #RzzWGQwױ.c\Et$wHĖʖ%J/JӅH(˝Vp Sw*O1Bەr3}~+hDaz-le][\wվl}2}|6:qJ]yo#,ۆi9;޵Z(IS喖1.BqD =< \}^W+wg+lwv'ӓm\!N\ҭ@ݸ'kK7s9_V4mɳl_}A\ueEg><Ke%]+QVT4}YԭSSZ]_lgTo; \\5~oeSuyvzc+mFU*6m둎t/m4e+Ki+]]B+v@䪞F{kKI)?uv͘42Y# W*|)F2Ӻ5|lojT*%}ĒÏ^p>SrՍ^{QϡntW0\ϗ3zz95ꚶZӬd/J0d%OzR1ǽ\qfx,,T_rbC,lf])x'GPGˊҽteY%~f.бqs4{miaU݀]0:qvg<}FUj k+V5) ӮGO_lRF53,h5rKDk=n`FPb`G#"ӝ<MoNGUJqF7vk~CodFrӯOΪ(jRƯޫ]"iQUW?19udߐRQn:HqJ'7{*qdڳܾYʚwK5-ZF;Mr`xjOn+qӛy%.㍞w2Hex\թML=HK^Fv/oNkN\20J1N* I!Hȋ&yG$c;zD0UԜ`εhԒU_38KM͹,کF]I{^[ӎ{w9nny?Ս1q^-8*Tiԋ|m?hPbdT;#{Vh^]XyT/B}:Hg6ϳz*=*%jU.wr."&IL. CI?SN m? &Z5嬫8=#ָ4NOєiQr&1ҸnyB6oGFRO\jb FdI};TѣN]#ZT._א%h IePIl5ɫT¤cȡ?3˳7Ț~d:QVSG9^4{;[̷Ƌm(A<[vb`^y z1WTjF1?X<`[Ln[9W9⍦+۩ 4}%XҍJ~΂QZ%0[ɇB|nGVU$5+;U̯+2qcR4c9J]?J1-[x}\vDS|~~J2R޺RQ/6ܬq;AۦO3 <+ZpOgR d[I$UBּ#G|#M5>MoaJGlp>/Pѽ zaӄqȳ$"Iw20L`v_sk~:xz]z̺inaYf8YFrIߨR\R ]_$RmcpQqh3Jtc9F2 D'(6#pSЕ?Gv}Fe.E%Ƹ1sjʞ#8?D)^a:өn4#lǟ.MO~ bֿCUN`uanEmĖ%T*q~)$U}[ۈvM1%U7^W,,xۺ?q}~QJ-8,G$6dHrv@*TSU*{M~mvyq֔c)SaDOTڳ͌tLt:wNŘT xϖzRV~ߞ/bhM2vsJ匹i-"nTzVX~񝾟αk8s|ĝJ׾?ƕJNO^d kk2ʲ}S^!ѤV6m;Z+ 7^EmGɸZ.Jdu,J+nf~lDjGfDj{J:?^yF2 ܉$g8yT.52G7Gyl03YM+Y~!:q-gX.S̏st|n㵣ЌuJ+4FJӥI3o~.PNZG[5oOȡqُ5EnGWԗWwwȖ?Ɇ$j*zьn:Ns|IvU2#f " 83qj1NKs:~m4$O"Qj =}z rPCJo}IuY@;hվ`9Ppִ7xU)ޙ{,Vet=zJuiOn6j/.iڔPmhRHgćӧAYQEfp*FtYvm;dct9c6(gEJ+$L 1NZJ4ew5yԽ߹_P U1DQY8Gs^X3^Jﭑd_;Gsv5F"wryn9l\'ڹ׳m+ݴߑnugh~VsnRܚJ ld4O3+7*#(\ ҩR^Zy_nd\Gac\|c~x~u$cmwmؽj~8PV`p~`s唤Iu/YM2ɖxmzp9tcS:mvօfIne sft YƯNK<[5*U2R|LF?-uUN2FUBo.[]>ae2>Dۡ2*nMpL[k?&s9]Qk#~P79z?h/J-N@v>^1<֜,JOEk ;Z3uE }GLwϚU#834L&nzM>Vf*)ԕ9j[7.[~&@-+6eoNs8:9+FMyXlT(<3_e$,[\4ͦܪ+ ܰh~gIar}N_VV&(?BIgp-#-3serQU[z~ϰZ.V2a s)͉*-rgǭ(⩵JW=9jW͍GkBV A{]X|L1S :~i{GiGU\h~kP3HN U*r/dcD*C+?ٽ]*sgii$.:IO7gqRﯯo2)}GD?!+Nz]su*mm6!ӕFһb_CZltjɅO@c`Agէ_ϲ]ͯJN}?wl"dPnNy RNOMSd:iolvDrFX(^ m9qz k--H2uۋ^ Bʧg9nAB8Ѥǩ*4}yi׉V=,1?ʴ˚^?9^V|yiv6+0Kc9$WTǕԩ5̞3ry."/^O BJ1XHՒ[krJr{^>TUy [VdTDbBUQ- `~Vmק*3i7m?wpj[~eFa F9 ؎}Xb=ۆw<#N3u;>2ԖEnR'Kgҧ )TʵH(ӭʒ{.yZkvWѤ"8_CV8J4\bhƎ^-e?z՘rו"Zl.t2lkdK"8?y:j=J)F7ʷ:C#=`:6V՘{ysԲfeƣu=ךQ%m}~Xz\3%B8J;H2n|k5JwRbi{G.cF]:rֱF^?svДrPyknޥvffm$S9WVqFu^+(D>yzW S_Urj>%uȖd:𪧏+FI{3w{، +XySisNb4\HKS^竫[]Ku~Hi6׭:%&+c{a{رajWzXf(WgN;NvޖJ#&[+k6Ic֮[{zeQa&<,\I6*FѹS'I{cpDH{b*q-0#Ui+$𾽬eIBO=O^"=pܹh~d6JQU\W ѧ[;Yjs(jbъaN[r:4hhҽʛ@\xi( J0oנmMrQ MX{iЅZ_s0绞ku}&7nMgh*[֒A[Yvm#rw8uݙT#Pdƽ^F+ޯV:E9aVaQhf&oX#QYJ7_B4UI/fF%7~V>cZueE3U"JtPjqUu~ Y6qW9pm{;Kzn̏|d[!"xv>q]j<}woTn*Hԭn-4r\Ո@8BN0C?*Tun nuokRTcϧEJ=M[]me]OF*{|JДn׫ 4d,YW*+KVOFLyhSӯZmkV,{PZZ"u*T+ ]]3+oCqUuwpRzK; $A6ݟ*?x%N*c*~c9co$pךiF|0E{4b%W  #9{X/@:Qoy׀.-/6ZRf Gq6(q?7\㢎[9Ps-wRJ)E(cJDQꟴmsKMC-M<vq4F^O]*{j&@& Kob51tqҽL*t\*IN>ԍD9_؂n#mojtwGh׫-<鬝0rTY¤ku19Wl7j8UTmmA>aN.oDL9S*Rڻtkף}*\3,;XNN_gZ(ԣ$@ Pj0?~O>E^.w{(|G-H\\,^bA,۲'hNH9S>B*SiVI{yO MGwRțf47[8 H9Nӌyv"󍨮>V?] KFΙFY;6Ubϻ8s4`5J>IAt}VvR7~m!xaR3,8e^渮QQs\=#uj'XkȚF Ln\  x:rdꏳ /W=>m'P=BI$n5gGN@S**GMC£ o1yE"K/W8[?BXҖWgzR<3Kv$^H|᷵گ'ی 0\_7)^[kY]]OvӴ}SH03I9_?R\y3v)%KH>c,קvwJ]`dte@RSj(bcM<=6+Mfw^8mFcRkXi߹>Y|;n%^1֬=Ev>flr1ӿ<F㭶<ʲ3fޙmc;:1Z@7:gӯM9Jnym "_<3_W-dͣʩث%ЉcUʮ9lg E2t.N.hO$bm=yQQJje*qe-VEr1}T#zҍNh򦝌,_尸z9UaSĆ.?cs[LB0bv?2eGЀ%St[qn.M߉3 uʝ{E%'xi:RmqAaz)$0?IdEQ wZ.{.X߹^9_+:oRЬrkv'#GmB򽞝>խJ:]$K]='ouTefS,"*xc)SsWWO?ZnX, 1ߊ"RkKg9ޫ}cf](%z^~6{BNZ--YOcmclV)m^B%61NJ9MOáU^5>tspc2?V2ܺ]Z<۵faiɬ[y E̤l<?^MG4rHJ̬A<cXJWݵN=vF4iu|U.q "Sӌ} Q^*aR{XZ_GHJ}VQ S??i[< pRy|%U$zY"|t]:]X<V]hjQ,y{GsJu9E9N*feHt+3OFXWkuc~ZsJ"F*ھe%ا*iZ9ɺY:溥:oDwCir{{x<ݹfޔIhmF5ydw_ <sW;Oi\*S$8'$v,_mOSZ-9ZKo?$~~?tK_OїJPzn^xNT\"VzsU$sTeR2Rit2*-%rKuS/j`<ځM"͌j覽F)Ɵ+ܽ|a}FѪJ.["Ph-E*G?Z?[u.ԟM˱%Ι$e49R m*7_p7e99Uflntarїm GKbxVv1+:ڧigU\=:83/ė-Ү-[kP #񞕍5줥{褫Y.[rI3xfmX7dL[~^QvRjmc R֗om K*ı۵c~ƺhMi~t2Uk8zk,Qww{ch0srɂˁG74ӷw{zxg7;&Ut]moc|Q>ĺlb40DUB匫ԐyI}J>ʢk֭[};{m.mܯ[nǛ|@ѵeү8Xb De?$ P},z2Wy.znqwJ^zo}v[>1W"_ƨvʲ4kr@ʞ湳LQp;_}ߩܖnlO=yg?@L4fKTik?`|y'>=YiJ_-z.GaqXEKM]"`Yљe0",f3¯ :mPO9qkj[:xA%vJ1|EM6=B1wH|unxjv x &`T}>|Ax8ⓢfٶ+ui>ᶍac7m5brq3_fa)'ջ' J4-\p±En!8N`cγ,Λ>g'rhC夂5P6n?[J֚}O7Jʣ[ZI*H2GX/[ƫtGd(S!EA,6aɵckW\z4g%̿˒r̻tzFy:j~T潴h[ITؿY0U[3WDgeMoDw6XBrGCXPHOڷPiԔjו$ m6UU ˜p*t˹,Fo)b 8VS^KZ4fD&[eȬ,06`iFI'^A3*}$isEZ$PŇ?ո凯r5N2ehݕb+!Fܫ4m~Ӈ2B+A}y9d^_IuUk3'v3cV xu%z}#k_/2Kh92NRzwrIhSZϙM#ew$m |ջ#FJ1Uk Qn[ni.W`N~VR!TOe*>=12Ȳ?tvN4߹¥Nx+/ri];[+jFmN̥{Sn}JrI^ Q,=O^VƊqWti)w NEx!F-.>qֳlN*rݾt$nnU`w/Pzki Ah;e ,"Ņrϔ={= MSٻJJU#i"94Ky`bfXD|`;p(r8{5_3TػXr;`z{8ɡʌjJ~&v`11#Up*5Ԫ>ouֺ4޲{wtz2=[1ntx[Z|(Swy'SZ(+O WJ[#PӚH ȳ1d1Gq:S~+'Jo&b]c) y#wf_)U$m/Q"k]3x! ֻ5uٝFk}J Ǿ;3Źom5J] w^L{(u.β0 0~b=HtIQ˛I&Tf}>61"sI/Iӽsש)婕ij*6,abIo74-%v˻H!'N{{M7Q->lqU<UBQPt2K+b\A77x#Zcj%{&WR˸m̓ӵ]HJt=Og){]n$َkJ8~T<ژxѨO]]|T1-6:si,?,ەF4y}v1oԉY%CtEJWMlZ cpۊ-$s.r\ҲR>+4i.;_ta{tntTԩŷ2dzs467/2Hgl7F^Fl4gN2Ĉv/'ztMW^ 53pNk'̬iBWԦˑ?m5ttb)ƌSwl/$=wR(~[ (lv,MU&I;`/ݭq3YF)$dqȰXsUTaᇬԶ?̬@ V<\F =-׫;_sC'TDZ4ٝls'*5#.}voזhԡZWI7%ÿx<ڰݶ c׌3ג鵮N'i㨵(fVVqi߁^&$I켬G˕e';5K)]Y~+eت+I8}Mu:|3VgV0ʁr39NFOyE˖*nϿs*}bWO껜'OQ֝|,0BnN$o+A 6Fsttۙvu~oU6vwO-{|zKMYJŦWkUi \9 S%8sl:% Wd!aQ0x42Y!;;cq[֬_IV[>Z_oS *rezi7ܻ/κݨ{nSoڤ0 HYQ%z7arZV].[[*R}k\ =q;bGRjVZ %hh6u]Q4ۡ[99W+<=>h-)Ro{$aqVvԎx|R]>EKiݑ`VtI]w$1׮:qjr'x:^u~oj:YQ +,{XdeN8}^Q+nόUg.[|Ϗ5i-%*>U;yI#iViHx(ފo~.КJY>7#NF, až=xʼy;U$G1a~Ye[@`t7Smg|>>+KKZ׬##;Ivd ,rs--Q-5u}_Oíuլnlm``0dsaTtM9؎l\egkz'dF op-ėi`jSd>,L=ViL-%Vv/žt) unC"9}r>'=_Fs֬GϪ{ܻ;>:$׋y-[Oyg==_ɇU1%̻~oK<YU9Y|ϕY((1bk:ʥ{xgR< ׵;aX縕!TVS9F>cUNM7J0Pm[{ψvMvE@^ׄNMάR~fӵlc5"e>g+.}̮[|C.cK~|m@ gNޜ֤pWUԷM^E>'yo{o#;f88AEsb%Fj;.ֲSQvs"yurinzz>Ɯp'V<7:<-K n6rf1j80kb+T&ZBֿEsZ>Nӫ:ybn퍹UTٳ^QR]o x~ĶNB F׊D֗,'Mt:X>hkRK]l44uՠ;P/\ww*j-Y҄\q }E Cu3 ۞Il*kJt̒ٻiN^Ԕ^o3> |\~1ht}?+0?۲'4oq ԅ>h^[unי/%k8r9?翉"gJR*M+nxo@׵Ӧ#EMȱON^WcU.}o QMnK4x HcyԹ7F*:;/;x.&hv޹9-/x]/'~8xcKhg2s哰=1q68I5;?3~9xHʶw,lL)-^]zN5,Q V%@@ؓ=9kQH㥃\GO\kQ6|]n0?{24K.4GNAsc-ogGr38+\'ӫ/6ذfsӣ(/;\#mR#1 my$raۄ=GFzkTN9kc󼹱H#z^n+LymL=(z,ꚪLoܖ*vql^OJNe*WQz~~2𷁴2TeXIێ{`F NJ.)%w^0^|#IDjj_\.&w e-9+W\u*{_T}-m!u]-u䕤%CnH9+ԣ+Qx$|# M'[RC'$E`7g<;ϡ5%];x*jDL4LLrx+3vV,mYw695ٴob٧L+nU5%.FT}zA,R}}YA@[RkNƔyW;/Nޝዖ9ZKU-qjY1b%i.Wwm[Ϝܺ4*Sxu)v!o<loXc Q8<}몞NT[Đ C䱕bǟz>N7Z3> 27ǿG/N~4{H$P3y<{pjTVkcj2Jr\M3G4BWϽSg,Z2&yha:~cں"&ͥK'd[mL $*ݎzsSy>DǞO$4H˺2[o$U1I 5$*1 ",JU:c_mT"1fg)JQarZ௘NuWOQ&^"h6E6?7c(R}ItQ'DQ^(߹czt}|ܶٙD6 ` TW[4H$;U(`Q)G+BxT+^b4^YF\nmՌc99wdէ4{2d}v6wK rQ9|qx-Rڣ=+rkhE{R DQzזRƛR[KDU~bό_k%ܫ7#q† 1둎@#e+I:*N1SVk2u VGiR6GnpIjqG+*8/S.ڴ2IkW0=GӽirO;h~=37ݏW(T+[~>P#jssX~zoqQd7=ICtAʤ-/C9Q"N[hgMjz|[̫犙E&iIDoXvZ}Z)F܎D^M4a09EHjXcPN1.uU,dvdV5>Rӡo'{! 89=s40'}<%OgC}U|l1Z] Թ]d!TmǗ$33m䞃ҼԓK[XSIEUkz̉;¬|? eմyV_[:G"n7~l*9Kͥ#Е:{V)kqy"[Ote׮zu=ScFU):2+xH7$.Q^n"irh2.!yx~T,Tϒn)GrtW|[YN1 xyV,D# yݷa(i#5Qq9U,67RRCxTucOFD`0^{ g^#wkЫ}!jt5Jl9P7#q!SOu.jrh72+HG4%Ri3vɎ.{WkNQƝh63gȅwtndF$zK戬"h]ۊj*Rw[|Lj6DL/b ?\~WfQWV,-ϞByBfbx|zYݴEHޫ7;ewڦikeHʵK_mHt4OuT)^LΧ}.acPXBU.˩b#$XYzoaֻԧ9Y*uө*q6۫C2٫,\nR1GAYIr}'r'bɗm$eGVnYq{9J-ZЂf]u,l*kSErXWMl_ipy?By7vkNO^;I(?wF3Y1E$Ҍ(ܑ/Cܐ輒kiSxmN|IJjA$f(^ΊKImMX(gÅef?*ӓIFOcޛzj bβ0t8hM/m}M4␭6xp=ޛ{ʷm=unfGog~Nմw'}S;Q,DxXC6X+I2^N?L4U:Җ˧[xhZકL댜{q=V!_Q$b ;1 ߚ>I$οf;~_2;|$ETxG#? Zˮ v_XsF+HI|9{>hhHu y,cgi>m'jV?e&Xu m,`N&FF=OZ韴m %[e ]n#* fĩmEeNbԹ7g&ZKwoҗMDZ*u+%qYi8ٳF ?ץkZ0Vtm'1Σ2ySr q9)ܦ׽ԧ4>1-Y6s(ʚ>3R'7aW= {Hjpf2 nUGȝ/j~mFy`2s=9v柽nyxzG 41kG(::l˖zQ[[hUrܚ$Yi#o'$ 83\%hemswon)k72>Oa?未('}t,\622цֱy1QNzhG43Qz|+ޫ7}mukswDb%dE?-Dd9^C4iy7cc:ֿUJI$Eu9^XE -ݡOL޵'8ěNe-k;Bާ J]x~YsE5SY`mlf)FCd  ezG|$b!O{9a0O%>JR>ҳTR/]#*q-7tmTkYaVle85R5)iԧR:egO:ǘHoڱ*9==g(h.YЭ7R_]؂䲻HaQeݜtd8rJyݮ_UUe/a?HyZ{LwoT u8غқhaSWײ}3Z *%Hd+nOnEtFT.ejb暾%EwY۹yytT)'}zI$P82TlSsk9KZEяG$PD{yٞ@9dht a*w 'n#N?WV6M[Iߠsj37F#^N~\ӯZ-޶(Zqi?BK(^xm:WUy9%vN[Y~U%J]lܴ-V/>a'lYJQmJ7'y-z۾M} 4G#EZ902e#hNr+ӔjW4zu)]z]qb[JӶ?13r_ cS]ѝ7'SUb;Ǚ 3v/-͝:ս-W6\Oz*z-|ȭ(J uM:ENX{Q)SRZo|uCn9sэ*uUYrWNuM~NsGZҖ$n3N Oh[f/e+,D&T>ze6J_ kh"تF8FnqU9NM/5>,19'qYNNc7T?,-M)FRf̌?Hc';w4ܯmM)o4%.$9gJyOQ 2b_ݣ+FӦ?Q]膥)^to#Y#nUH֏vu/ĩQsN%pʖv=z%t[u7k '[q+n \1P14e)9VdLPɶ1(2px?ަQwf_|i3q#F,y#>\&ըO)eWlmWT.[Y#VA?=8^}X^\>[g·BO|b"gOIr;wOR"D4=k8EOh_Iu1U1.6|8ҩR쑶"TkzX.,2"nl.1?w\ҍR{)-ǖnqv{uzrx(nHу%$̣@fN:^h䵗UOi ]h\LrG4$ =tKٻѕY}_+iv\5hh’<^*yeSQK}bǜ=8/n~g4J 78U#ny&Rwa~/\Ty#5dh Qz i&ji+%yl xlOate`oMt0bbžsݻc' ӔZP7JRp2ܘ1#62;Ⳮˢƥ)]mmvfIbdoU(=:yhػaMnvyj۔8bڹjQR;$势.Z'"b`cVrEթM7YLUϹKa;<9 xұњT9|ܚ.'UVEmP7+3m?Wrç}T$߁.vH}Fsr֕2T?:tnr*Y9'Nj)0S:gbVŁr:uϠJU/֝5̩,L;le]8Z4嬝~ڤm++n I0U>c+a=>+XXo2O7Ph[nYA~\㎸ONTcN| K>iʻdzjե)Qz_4mȵI%bx35Q-)>m4KK$mJ7e1wYKI=Ѩ vʚzU7ͷvs<Jq|It v}ÓG~*J'r_clf6~ qmjH>\QDŽ Q׮ ̫L*2pN/a[M,lc,{PG rIIF/t.q&\7ߟZǗ.=[Z96̮v߼t\GM]TƕwڭQ{ 7厩 jJMErn7cHCڦyy~߉3$ܫԱ\*+j]^i+IKk mԊK"XyJP~r{Vv kSr|;[K1VPwQ;C&,Bݷ#gnqY2:%V"JDUUYQ=°Ij>8ҚMkWQ8oNޭ1r>]5Z)RuY:[*˖FcH6вt)]`V?NQuw9>gPQp޼d |NOe$bc qkN•)rnܼQMG{GU~3FV6o-'קcVmNqQ_]^`pjF8Mgvc*۵H\[f1{JۛFѭkGKЎUG%Y7C`=fUc$wPNU9_^MM2G.e1O}vOF}6(Ef|?࿋x0YIuj rcrTcH,:)j}-q*\vvϱiZ֎wvZ`l(^bAW*ʴRK^GRsgN iѴ/)&Tv=k(ܝD1̳w& f_TF}qN][_Չ9{8ͫk7=·s;^ShٵUB <9-o])UXpq29|]:EuGݎI?]_>5C6|EۑݦȱY[ѭgk۴$ӧrԆ|{[ /]4 %P',Td+=I L.9sS+Y輷OOyarWIYUkx?wk71% 7e1O<=_VR\/c9_SΤw \ףWF24\OC؆:c59.H9k–qt ~_v~E7h5Rtq^-ޱJqTܷ:#nn,}~'zg+_ Bk__33S#q/tWF>yY7QSB4Q}N|*}msvAop]x\]X:֣O5ɾiKK1}?*#8DW4qS[X9%,EK7zg7eVʍ'Ѿ^6 eev'ɁۯCyBRI"gRWkEԇJdTv%[kX+wשܥtg~^EE/\IvUqUqUyi3hgK 4Y;J9ZKw1]KpXIaxNiJҲM>ineO겄.΋F[tPԮSap7-u 6L>"NmuN+o͍Y'k#jRD:dth&܍ǎ:{ө=:8Ժ>Ծd§Vc\SKE8^gУ{OspsH~BW}*F"P5yXA:$ǹA?!|o'8}0{dS;?y8ZxmUqW:kh*G9VfrqOgӎ 6=W{y|<9t?n$%o3E O;Axrʎx(o%G)=g%4[ ac# }AX~o.khiMZ-%3&K~ox¾> L9ɴ{RNw^ӭ.\JU(bFq_[E4>TqE}y';K$K˵f yٵs<8^g9/g~^.+Ͼ#믂>qЬe+ђob#yyi MnӮa㕬cRrz(;iٵV{#2}uqiN2Vv9xrkdd䍈/.6z+#UwS $k; jۯ<o>,<9$qzر܅ʽN:z^Z7uwnf—mp?ЮwB( Z+ W&`F&ݻ]UqdbSD'X[N14F2 {+2h 7t~U*9e'NW)]j:}岏FqzqYkBH&1<ݺNzHiA:QIoeR /$8d-'qZڄm߲/ĊJWln+:j14c0^#]|?6'T;8#'Sc[vᶷ#8'_JꇽS.xznWXW+ }*7/vi,y{LVͫK$vKp H<u]Xz}?_qede8M]:rqS)b9[ǙQa"Əp06wB(vfDqw[nձn;qV>>Obƌ_WMuxt !?OU[\oB@ӂ={NSVjC?'/td}I H2h;O86ك::]u?r))kϓ: 6w\˵)&MZ YRId܌p{RkVXyM3:JR^58ڋG|oѴ'iw;v|]HYϿaJʞ6~]R|㯆&= "շf\ ɯ^2cGQޗæ*G}u#* 瑦>O-z=,iƤ]Y:tºݔe6q @1]Tj8JttVu%.N믣=_PnuF?:HvBAcÜWG0}y=AŦ]a!8|Nz[TjFsF:mn/.wG.Y*+Vz1ԍ5~٢lH $ٸXOZYSTkQ%5$ )<>㑒3gmGFn١{LE7|ս1$;VسxFG#_i8FqVK7W6WѺY3:8VMome>൥l's>2dY{)[?,a] Q}oyno%f3,#/w۲>|3%vjgZpSin XCvyWǿLsα Wlή f.aD1,aۅ'fggD+mqWH^=r+ǭ^=㿠^MhP]MqõR.2Mi&6`_d~bXOZ-˩jG9kIl۸_1rrA}O8cUsbQ {*{wēZ<0E\m݃31pkBR߹H⦣'%Qկ#'qrHs2\Mo*F{~z`!e`P yV:ݾ]ͪSgh+ tDW8S#^ ۡ,eGVy{)ݻu:ыkT] S~˓t65[ky#-ck8Gc]TN/Ayae݊d٬8P4+gtrki)a۝E-3qYH, usW\d۹fH85 DW,q4MԖI1sc3ך弹՞:vGeznj7H9(1ڽ(ƥwU#XeaY 1ZIb+Bzkkz(> jю?uBPdv3#y8+ѣc}:ӼȂh&fhRIl|w]=*xp ` U|38HTJ*UXMD1+=+~C%A#b8[6i>kNb; V.9Rk_i8]Nnzm ;F ,T(}.q<`{{AgfH-Y.2e 8(Et5OzܒTV3*B 2 >GT+-#7Uٮ\ tQRu99Wtkwm=2#q]}\|FHrz~9TtsS)MK^FEw5.ݥ?z#QSV{=jY5{,ź¤9sʺ F b5Ug T0O:a(ƶ1ԩQ$",sh$;vV:Ju6riMܰk4U6eVK[~mmJv>1SZ纰sFp{kis'GW4LȍWxRvݹ[ݦa)i,#Ѫ.lv^uhZTh2.:uت\"(w>KB䏾qԃ<fsL{yѷpKd㞸ZҚ#ԥ)4Oe85.-|X- 4ej{5Y!cwqSNU"dZiz7ɓŁ} B^׿CEjWS 2yPƐVOUʢ|ֲ6iʟ #ǜrs܁W?=WʽI)M8ݭ\D難-_L;c 1OWԺzԯn;Y"Iwmc8T==}k'Zw^9JfV Plۑ=Aծ *4ܪij~K6IyUV]Jʧ.X1:-Vކ]SX@cfNHdG9LrPOgC=_rWq2V7nxA1]5ש4*qH&*E6cr^JkV6tl9;Ww6IQB{zJ5):|m:6؅NuG &߻"֙ rߠy䓤~ˡTԧ ]fW <<})ƝIJ5y䤖3* _~*出s-]2-yUګ~ks(s>Jմm_Я*-!Niʥ;4o @n5vjQvV:vOb8an)Tޝ Z-5̹4h9z"%N:v{G /dn](ӳf:qOЩ-Pcڊptcri2o*}ۻfL s ؈B1VcϕGYuvo#nU!lhWޱuye;ORSannS'9gn_{Q~2tߕOz1燏$ttJcMrI"M-v|ύ/JΥZn4O24ʏ~MjX.}jcK14s4ag@858y弖c QIsE}=?}6 ei32 /\2qV1rݻ=ߐ2PM) F~cߌp>lg^R+[nEbprm:[O5kY"/m̑oace\eq3ۚs_/^u+:SM.{MCX>& ݉~N9DT|).~QGEK]G]SQKJ[Qܠ|S#ѧ+nn8qJ*c8s4W8 I î9ӵK-@V2,sCݥry Ѝ?S8ݵ6iROz/~,#R&YV)n9$ 5ذtT_KŶMN<*<^]SZ"n},v0p~F-䗚bo1FAƖSk,7JĹe9Uc#wz[^aS$Ԓegx74kh^- S a[ T?tlcф"_}L0ҏ%m59%/̐[C6!\` aGp>2k E$v][~Y[=5Y>".|IWv}'H kY%RUF]mfCH=5J%wM[2l/U4%dVΛRÌ?{}R=n;릷X\gsw]tk]5+yn?v6Xp$8#UɹO_OJ+ifo5-hHg  71PڼջkF<ԯN?3>5~ѺtӴ }Cm zs휑FjqW[yy_ʌcӿ.iy³=1_CѯFPm[sZWˣwQV6k{gzt/:BbV,+$wӯZTkY7M'g뿒oxQ#\E`˞d =3_7*n2m%Ӝ[jU>e"$ F/q^ IԌ.{^NZ#wKZb`"EY n]ϱzV?;3}8e(K}n_06ڬF@NyzVT꬗? MoӷM:OwNR"F5-v*>'vO7nXzTQmj]|)y8_lW#F^Vrrb--KS]=U $ VЋ^a4WZ7R㌪+Mλ]Qe0NH}đFDasoFғLS5Hѷ˟ƞ8"yF(.'Rӡav= ֔DqI!3Pѫ:9miYN]K?RR5E%xoαdCO,8NF|ZHSeRW_#juDۗ< q^8*}stiϹ"Y*v!$ u#$唬ޝSIUַ]iG$3o#G"gS:p=]z\pZ25guGo+E յo5%! 0021ָX=m{/zJXs^- L|s^;sKEyuo*]x-vX?1o' Ty$!}[Q?+𕞿Iq5O9#?j1jBb< fd#Ie[N[P쪭\JTᥝ0(MZv2,o% 0NiN\SJcMm,G= )iՀsGXܬvd\Fݻ#C—7+ 5ǚv-e5A⿉>omuInbENrHN=F K&{_ٴkҔt֗_K0'3,4!{/͎s茱x98g*0c%۶*ݴP(\Hͳbv'1Eϰ>]QߎvV;*uC`}^f iPί^iH#k.F0FpAN> Zh]EhrM>u~^ac{f1-ʊv@{v8Zy[Z5/tn~߉q2º`-4Mkx䭻ye9e*;Iwiߧ~ㆨ4>w?߆!9&u.GБF"RU]+[bi+rD<㍷uIt=| 1[qs6MaOF%n%Ռk1XA9]Ӎ:9Y/RDݴo]N~HX"d|(%O6﷙ZŬXݼ_O^ӯrpթVoo[- *CхkZx ¢"󑼻B˷ҭSj:Z+蚝եTxccS|}{>/Է/m]\}+çOdq%5] JI5(}k #K8ԕB隖LmlŴ+Gy+Vic/35;nҌ\mbY9oԷ;ׇju'#a]l.#z4}#Z>~躷.uf;:Vqk*̤}z+J5"WӿnuLu¸N~#*#ͪF&&џG.&br˞3xyʮC*-nKYYvL۔I{|,5mh:]܋q\tOstWNFNܬC"mdgm0Nr TB/[N]ڥGW|pRƿRJhUσ]e khSSim׹ZhخИܠ#?ҊfZYOy_xf=KNYM nXtagx8Ԍa'OS{Xoijxci+.A,r'8Rq?Z\lRn5L?3Mc>"h}G $a[m$ @ם UӇGUo]{QNᶟ[[]G!8xۑJU#^l잗7կ|mK+ls~"kM;=lS:Jګ>Qqy$ #8 |ːr~,ÙI;;h֏>Vs1 \3 /?jO&Ҽ9; ٗ e˽I.gwO_1t}(}S=J|Ic7ZS}i~[I& H(Pc{ڷ"5ɟIƼ6z?6?e|2t8by #[)IKVᯈvSxK?$W%}F&qT\Zw4BZۿ3G,"T8;YX ׿jiR>jJ255Zv@y ;$RyD[ƬYoیgUaj8һy1-{˩a^~Vr+G̬z/6t{ycVzzd]reg%=5hM{u[v̸܃:bdpFsu-}JXz}_o!XaF2SHBJj*qPgχIJ6eG>^ :F[I> )W6j/:q^/V= 8z|ϗduV^<*%we3ۭz4{eulig­'y9&auF~􅶞;tY$#=uG˙rZ7Q`nPiǒWy~~֗//7ɝY\S-9 4(dYVv"񃃌7W#IK{v05 hZ=7&:JPRuf/a$1 ˵<+9n}]mE_L$>3$Fox%nYcU߿1*TWC,BYqQTfRN/FBdW*7Q5|ʔӚHLn31 x%HQ򩔹7H:-OAf UX"'#91x*{w.N3-ܬ0o=NzwfYeXᅌq\VN55\̈́ͨ!3+nRf7?ƔMH\ъq>Zm[c'vYv!rDm7WumGwPyR*mt_lQ&;TNRi\O[|EDV N}{yY{Wjtb%)nfP6͜nuP%?Ȏ He2:%O JouPVo:]mcV(ϱ F2i6ߙ[N(?xFmMiB#xajIw3o# zvht؎h]cSe@GWp8Te4tk [ّJGs{UEs`hn؎]RnkIrOi 'qƚy)u-r$w V6'9ǧL*Ӌmr*Q}m Q4Y"Myk n֔OG-ct̿T4Ƿr!{nN=T_$uN7h~ƺa8  mWE.YEZ;gU:4Zv+[Hnm⸗FO~Z<2i迭Zz+;flRϺ=p 3*ҝ9N4 F"5euh‰3$>iYN {>Vջ:V9=qL)8Z4N.* Y7:-]ѱ3t/wR%ue?i+ʎ:qҺ)Iҋ8O'/if(ؚu#qC4nِy xx^-u[EH~r¥U$%c"̪vO*GtTJg1/#f=)B5pքe&áYo7pvMJ^EN*7_FYRTJpV,ëN{wJR򉳍WgaysG9$2TUI]z$*c*O?QF'T ik nnY]9g5S*n[Rث/O3^}n_k)5fvmQךT#IFR" ލW=9J0w6wMM:XV]:cqHJS.K^ݿ3At_,\צ+MUNƄ3.e$0Ax5#sy!yVm/ P.1n(.I^t9eZ:'ދO u9[sGi w~xۭo*5N2N)V#13\(?lѵE.k!]JCv)U1m':=-׹j%~"e܅|0PsҮ5yf㢴©Z$h! $ UfV26XyLqj亙ѧ|:)][ԵvhB(ss:T\Ruѩ`rD-0/C&!NNCzu+kָqcn23199v9ѥ*yj"]fw:zg|~_ʒcS GlV:'"ϖݻ;1R厱zg䒕޻ߢBͨvgsHp98jUrçSЩT\u"_h!Tw« `vqZ{Gܾ^Lq՜"ޭ7q 02Ry۟^{:ܛf&vdp`?qXT4m:s,?wѸ8QXJZu2i{7}ޥHnd%wuz1<#N]:w+^ΰAɍ~wƪ͆G=;URN/JΔl2no-(CIu /ǥt˒Pj] *u2M7(_Mn2I˄X7cӞԩ(7<ҭv"8$/""mnR?R/i(м]j Ve˻ަ\ѧ)؉~]M M2y$[X}k2<veحY!t6dF0AZў.*tvֆӾqhwq]q8+qX˔psjƖhr2ٕ'tN9+:u;Sl_iMK[6!+"U(ڹXX=\e*j2lT[ێZ瓣%tqʜCFM^+NUh/R˞ QFeP<6x?(S*u֖?kZ%y-יao8_Fao{'ӎ/z^Nm)Z,-p'LL#+859b9UOu$3:#oR8q?)^=@*Qҷ߸,dnG#0fgϧ>j'Ze1ݦO>LqźiK|ұnx=+YbSSmȳkm$lHZX|wu:_sK^u6ui7_K mqrpyƹӵDL^"t)gKXyjF?DpU~:QILX2ew+1$9J!Of\u*Ѯ,?!6+pWxZg3HS욃wwmZ(V,A0>ZǖRNo^^V"D6i g \TAҒMSCFn,krxoEl=9vv^[RRT⦜S(ŢC03rӕ&kbUdׯɮ}w71I4pێAxPZreަ2*;Zϩ^.bY2u"%$w=sƳ+˫NoM? Sqoi|ku 1lܡYrySV3էZH*TK";V[j X]\N?j8&9`(o-_5l q2m\TV䕔os2x5Q(hˢD֎mqW#dV7zoۮUO>ɯ?|eTDftG29qrJ*GZ !1#7m Xsεx1~%]SktsMoVK"C[Qץx‡4vT=XUOduo+7EV@awxє^ʥ)(5u]i!S3L ͑fQM.UE?ڥٮV6kY<1WeN;uKZ[&Y^ *i7KϹwuo0 嶍;=p?_"YEwOخG>E>QkQ˷댁CUMƴnt\>zݲY| ?O"C9avr1;[QlUX"2oZߖ.6K~qW٢<iiG*t$FltQ+SrEUilhk3u61q g*){9i2nu#{˱YTx8:Jj^l쩈T=, 0`XqDZN-Ѥk{OyE> 7g&܎?SO{8ݣ:F1$4,Я3ǜ~RElDnD\\pu>V3EO;J],iNjǙְMktU=J\x[J9A()nW{`Kv16 w/gIIJܽr~cq*ۈU3r+QKJSk}rO*'q洔i"HӨ-4 $d-0s#W=:$?idصik |ʑRhS5j;u'3/#^vQѣn5#m ůsL푖{s\>T*|ѼYYaIT슛T*Oh'S"BwIqƲPQd6fpI9<яQQr쑌(H|?7y8ZWjp\p_&$g@%SmN}?66Ű}gF1׬/~̘qFIdfBg !Q*uydq>?2[ U7[QBJJʱ,sGjǖW99))KrH6-=gGJ|4 0UY n|g=fϖ !w YO(R&2i=QLqRgu66 ~4msm~q{V VgfwܭU?J#RU$:cVTV1nn#csLp:QZ>$^zMa\G3 ,@Ǯjo89jQF2L|Cc8֓1S}52+kTT'=rVJm]Kyw#dg #shԩci/@gN,,sQc;\U=b1Ydݴ,%vcNA%lr֔}{%Ye N?ɬ%J<{h}&a*|cꨧZQ]wZ";Y=Uźیpt?Zδ9,1̀e3ʝmCjkT8kHҾ_u9kСzjWygǮ9Μo7S:tȊt& #+sW*ԯk}{%ó;ud‚::ZwJN_}QU;vW)!Bnx9=pGrN{ioR䶀2HnOz\YEFNU)k}Drܛ@0T#'oNާ\N0߽7evfmY<~&Nm:5H.* +󎇁F/r.v*9FቔE/#y##rz=B2=<ћriƯg=s+9_)^Tky "aezC N2Ww c8lG uK7IøRϯC񤲹}ۚ?WkQQrb*E*kGGi𫪷|9SgTNv} ie'+9⺾hMe067yF%AN-^YNQjPK7 }{=q4S*58-XjsC:ڲ4ʭ*rAc#ZgMNqQi-̱kw*v.Tr0b?]Q~/imbFX0f9 TS\\•D5Vm(̭o$c@`1Z8ըйR:o٫{y ԮG|)?,“ӜXUcXRR"s4Z'l<@Ͽ5RLں: `yo->UFGN=+YK\EhjQU5~ڍǗA/n8_g)7R[^cyl}W;1qX֌c$n3R6WX՞FJO=9xQX|D#7rټV7v~_ѸLXӔZ">)9m}? zNQ5M0H2zJ+I*tTg}COsMy|>:HtM;ݘŻӿCuJ{a76[6hR(ZGrHf'璩R{/ NQ-RКO.SʡU`vON?V88ع\JŌnvJXԊ|WinlZ̊u~P ::scR3Vcx| RLe^-Z˞62/'L 5IZ#ԹIg*AR;+;7ԯm^vRUuzjV5RRw}ĩsYW!i5D8=U{R]wzPyR5>Nױ,ZE\/e.m685&|VOH>S޿c8B7.VMM-UDRgOֲRө.kI;?UIOݫG}=Sw)j*N4 4'qPC1|#Szj /ǛqȞZYTfQURR>fl0R&呆\`gSQQM+gI[l2q4)>W6ğ3Lq?^+7G̩TJA A4k7<2OM4R s&2&BI{W=NZ~l+JZ.-VV+ߓ .GD8(:sdW1Twe%yp}%S=H)#Jz3AnG*|O$M$o'70\p? >Jp0UK} DxlvȤ>qӧ򨄹EOz[Y5d$:s{Bq^ZrMbh].p#Vܲ;-S\"X8/2W68I5BBY+nl),N=j_,t1Og'v $c笇o%y>5FZ}|VDM%n#ʳqӧPRR]c4 ry}GD}KZ߷B1nffe2=1Vp99<裞V@yax5Mq'MJzYدE.W #o 9 z6pk^/6֢WOs]ugTkN_ y].[[L+y}9:=Gz}iJ_.祅kV%h}g24h[ˏ8s^kIS[Z[K$\H8K餶nG=zJ<}n [kϱȧnc'5˖M_sH1SM>gMo.u_-yס6*^Ӓ9KJ1ﭺWi Ei&:t)r'-jcgDJs݆x5*VGCUmȼfgȣ+ihO1 Giixzګ4=*aq+];HkB2KwӺg l=m9~ Yv޸fUiڜn>³[ڤZԗB+ h00ÏÏ^}+ΧSԗ"歅W漈 Ԭ[9cQ4,E8].kWc+Tmm-46[Sn޸y9Xj+Raj Oiur~`˻}u$k3(N{]! ׇ䑵:>ﴶ3{p\1!m0~E95/ey^} q=.L1t)ʢuEhw9+X=}`U6ݾHU sr߇=)Aiwҕ<^\Jzǃum&Ѽ˝y)]ɍr0^uH*{[MK6"nwo ۡ$$Oּ+RRΜ/+I]35u In OX[9ǵcQuЪc{mY*7G]>tNɻKF8)13+  Ў3u|ܽΊp8껌m^!qf֯VNRw\4R5lqד\c5>H֣neRym5MYTm^=>nenSn2P|kʵ8i+im63Rko xpI<<;Q]q1P))]G~w;08Itv"&𞧤/u(/# (C0JBӡ5Y}l˕VdZy^g> >"*I6맩 Z2S9Z`*ǒ'hXrxj%R?_C19E8Ǖ;Z_7mC^2kc״ܳmVt `U+}^\{C B.ѕ2u'5դr-I%W m݈`G-YKW{o:-6m{_BoY''yu+J_r~ϲ6Ö=;z~g~ &Ѫ^637t@>Usjt޺:pҍ7']7/mlj.H#bȤ@v'yGijpn=/_?5K]?ğjï!l)}w탾zGެ}W֯`5ٮVYF܎+W~Qor۶#SM?wIo%ʑol>=pG)KWs\VV{yjz֕0Մs'UnI98z,cP'{5Ԛ:wMid.T`9=8 qgg;m/S|og_auRSzݐ{xܳ QҖ)Nݕc%n]s}_c[j DEA:嵯)R}/ޝN G6>63WdjŶgfM^엗Z 3 s)'O Nx00Pnzn. cUT]^J vy)rFC˽J0:qէ{kk'߲|{FݛKvƱ\ZF,wNᜃӀ uF]{IWIuB-Yl-o(fBNwIP;pyN;**2yǥN5QRWԱkIXDQp~efۘ`=*+FJw{تPJNFIEQ:78su4ݯ屍-ZSZbۺb?A= [R5pׄg.[[R"xw[7p|pxBjÇRKFIg,jnZC4Xnd?7@2;bʹ=>V;凓J׶+7I{ےuyf6:H# N-EumgVOOiM7~VxPФN7mHĒ=d;pXiJ*_{_2/kQwuk.G!i+&[,xڣ9kXonmE8ԗ?5_2$EhI%$3}0hX<<,ܚ}IZ:0t0u!eyM_I+ozij&o39!0!A?7z5+~:]-}e{W˫GH3čd'/tx ]=l)Zʩl@+#Lc^2Zyg,5%&Ӱ]:+S UO\$] rt[_Ҩ鴮]UȆ }ʅlNvѲ՞Ks_\SdGSeԸ2_jXƪw٭:r~m[(c6#]F6@tTjTQnU<E~o͘ed7HkynoTT~yk.}czp\!*n9jӏ2`Ys&o:6߽d)ݐy'uw{Ph.>tu$8kdzY){:گ^z' dt%@Kq^ٺ:ZVzBw|įqvxk\K[ ,fxOwIytFMsr f,ƁWp;c׹B<>X{Ika3ۜq]3Xj1z?ȯF *rqTgzX>Y#_i*w王K[KA2.?t烌\4U;b-_:D ~uB^κtQ^ig3b HJӌӠکʤ5fSqӽK%tL?FALzڝ^ rjEI/1\y%.bkF3Ȏk62o%VI Ŷ,? c$uM)ԄbrԓuB r1lczӟz)Jui?N5nI۶X2mke7pQ0Oa_躒gnğh*{I5}R~9Z=^K>Uqą{bNx|U/a%2@<-qN#8DjGܕ-#h a=9c{sl-n^Xޥ+R>NI #\2p3~~)}{khR{i&#|8=WCa>앁M\q7sgSєa2J2@#J;S餴3heghaȑl߷[Gޒ{싧WSToϢ2fΒ9[yx#UO/$~«ӿ*Vkc3چcczgmg)rҝOV*G,10333(lӎ>~|p: VU~E]{DhZSg?)\o(ҪQ7JU7$P[{Ԍn܅cy%)wܿф[w#n_bwzΎ2IoQv($uo4a5l=Jz] ΢Q !qL@7YJ {)VT|kb "W|#>y%fEZKVU`FWY,OJK R?h⌶ Q^w<ʕ'BRۡNhc1%tvϯl*zB:OĢD!];/n³:U,䮑JܼUl|ۛb,cϗ+&xZt]좷-Ԗ\Qp֠DewI}e݌yJ[rsT,EWއ]h[i{uU*-M7;*1l+" euמr~{]̪T8^UΨ~AHA3*{KJ_.ӔjhrMq p٤lgx}Th|=γBӦy1ĒFXGN_~DeI`|iY'8s[wMԁipyrƍJyǿ\5'oCR;L ^=ygrbN!䍫tj=Ny~CJ-6Haoͺ?.W~#}PJRɤ" cNFFRr[rY(;PI_8ƥCn ˖jsrjUu/\WބRZ _ϕ}IsS"oAR!,u zc|+_SHE]1CϿ?ʲTLRn+,}ǎҵm{z99Z #"`x=N{R('RϢ(Iƒ' Ӝry*L5.[O7&쌎:g?jʮԒӳj{r)y sG~+xKSy*v KBC (Ϋ[.zgRNJ_1aj5)\ʟMc^J)-qiÔ'|tq[Z[RZϽHԭ _Һէ&8W/GdN9ҝJg%taŻ.@]1~tR5NzJ1ntՄ;UhKVhZ8YeFxixZRmKbڷ6n+I%ⰳҽ]t-Yi[[F6&V$knIobdӾs>7H:gN-M9JT=࿁㯀-6%Bjk=ssb|60>- Si]vKTKRvJ]~x_(?Kǝ$"fޥհUpq#1y]J4iƽ?zi]hҶ~lDe*S罬ߗE煼M 7xz..i"Ԗ`1qV; +Kr꿯eѭYIot_u"|@մ[?<<䓹wl+\d c$dv>+b*a~mv.xE<.14'&8\湾UM]mcR]wߡ˧54htdRX)ke}4R*I'}/ׁ_?)$)kz!RpP~7[i9=x再:=^Z"Tikcx[owB 30ɀ3 c8m|,g9ndl݌O8C()צM;ٽ_w~ea+=ףz%XxMힻn6ʭ*OáZ\ѬӾq4JsmZE wbiDXmV^8c$Ujqu+5~o.XzS{3~*x'Υ[t]I,;yJpG8׫B+5]='GJ+D_;vc1a+z cن*Y^k:MLyx7!dRd33wGVbFQ k{;M^icgU.+=qqk 5o~[0JnNGZP]:L"`^+[e;hV^JKNKk۾_KMSM9C4Ŋ cԣZt]}?_3c>RPI7uO@O3,xUqE9'c1^ǗI}?.fiI=NҴ8ֽM%k7$d?hW<+GTvԷ%!=nV嫪1jL T|MȚ&4F/(vKw֝_K[ִ![KX`y1qԝLDڊ]-LJ[QEA~yCQј~|7ROv=N ЌΩJGmlU 4S?>ǫX^iws!` |z9=zW7R Z#j/~oys$$$6nt5K8wF6dzۯffUd^y^n:Qw~T%.UsYfT8^m?gsZ<^-%5sukTtu5Z)+"մ-5Qe -q8u5vofy'H'>#NVrb09nHl-7 ү\DR6qUꨮ4C#yNpX{z=>[-i$q֦W~s9TL߭Z+zƋt:*FFKdz.&hѮuƕ r&ֻ#͜K?gGmRr~5Xr2tRB|ǩRuZ\Uݫ"rghZN2S߂+?T22r0q`zױr7 ;$:%*S4"u~u`2NRnRۧu化>}vI ^9+J]~Vv3^ ּ%\G%Vu;DY Nrsrq%8pK^߶HGFv~־~]h(BHX<)>ǧ^<xeͿKhݟ/W F3wotӱoh&/$7%ߌux~~S֜c'uJt' 5zS/5; Xihindm,wς4ۏGOg5NǍ*~Rs"<=juѮ%f[W_ZԳd88,zrMУZ"rr,dSK=m=6C:Ρob%Q1I?ʚ]ӈ6=}; Vҥ ۗL|JJOkG.'R/w>ki%vbŋN0coChJ{[SUY:~fOe-d=k/bTU&3KNM6{W*:͌n uzeیuV.TW2o>֝KSY~V{ė:bWS VafrѼc-i:SN.KՍ.=ϽgRJϯcN\5l `RP>uV S'Te*kKǾ˿[f8R; ?0Q/־ ˤa :CS7WV}/qiq_V9cA#]|&\zvKo.Dл}N7T)嵺b0%6i{>g-[˟eOt#j6ݻ5[+OF &I܅I#eZ;ҬJ*6DŽϦ]BɸmUFتnbӳzԆM29w|&bۑw`\1 w8RzuM Rcǿ_|;XGyhrV:KNd}+\Bݟ0vrr~sNU9+'p]]b&]:9׀kiN2];^urG" Ufbƒ.=}'NKrYFTmFtZZe&W£ͳ*Gp9=]e,n2e.Hn# x^2꒲z8| HO]n q fܟһ5Z:QJcï.8y؋&> }pn2JiVR)#UbbTd^,TlN햚%XÆאO1_֟{]J7:$x9眓e8JImҜyt \$dACʌq4j}b7M<{uTc(F.ٚ]9*}}bبFIAB$ЪH Usx&#tB-[hhŢE(V>ǎyɮYb$f2*k:{keR~!2q~5%2+>^kЧR[~';rWrCǼw . vr~['x9GGtSGK-3tم̈+.k^k8֝omiNnUQw9}ʮ1r.9դh@_@A=<9.Xpi}[,kŏG=z*rf/kR9 BT/G͐1]J*W*BpRYY~2:V;?_1.$HEO;Ysw`>Nyl7#$y#fhU$o/6d`~"\׻5G$"D1o˷ǿaըEѧ%{?̐21 י~fR{] e:9+=:hC4kw1nsn;VfEJrI$ t"l4 OueOXFT#Om"+,+'r:sG2_79&A^Em-傻c8v?r(w{I.Q" YrCUMlLbrʰ8CkR4-kvi$Js-H]F(n7'߃ҴX#)֌h ӱVV{v(ZmmN5}9^LhB[ʌM>v$coҶoszrxR67{sm_JVd GO[ͷvۜʹ.Yױg9K]4^FV5^~KML_qXTo޽0qZF+$sԖ1}heo-Iқ~=\ID q噾`YIoo&+Rk:-(g;pmI3ֹ9-RN|G`oݑ8 ,9ҵ !DE2E9 fE(uMV ЮtEfaQ8gLK^fvn8S޺i#rZ[:QJP3C%cX\&`T)lMER8uZ<ӻoryMBV2m}'3v2ɵ66\kTұj2SF*#ۑyDZTTi6O{ RC7=ewSadi^c2TᗐOoCQEEWִzG/je[qʰ*qrsޟ{ϞZhQv-@'XԪ@?JFR,kiB,JJ4ԢL^;zШkJ9bYTȥy|#,ۏǩ(HcO1E;I#b= @}~u9gYS:MH٧g(, 6-vi4j@ǭg{$B̲nU,˵N1G^2GC.m<-/N8"Yi2> iT92-&hҴKx`s=;W-z\ʟ{piSȎƆ7 9r1yt'ʟ3$Է TY%8(0G^1uN2rߑ8TU%f֋lic\ܬS>ȋvqÓeG=GQ,[ rFq}_zQ9II- >N)])q6߼ cCKbcNh^J2^[nH u#,Dy%bQ=Z+Ȱ!FbAp}qZ|ݜִb~3R_h2rTO^RiG[)BHEAlF9e/x}$fQ朵F|.|yL|\8PO\s%ud{*|Yn{$ιk˚1_QJNSUm-6>o2`0sٳ=p(?2v}nk[~ծo>O IvZp#ӷQӷ烑ں#OT*E=MOaRv9*x8RG#JUct_c=лdN|O+/ZEb UT(POE .>uuA8*7 oݳNmms2XͿO8eͱTN+/d4 yfZ-#42޻v㈣(U^Xɗ rzp;trǖ:(ӕ,&$}جX N9CY:+{F*rCQW2HQ2I,6汔GN<;]'ݦUp~Y<0G\fRtG3G!ܬ͵gsJ2M?{ޝU]t9idIFMXh!1id웗p\f>Ѩ&:2\Ȩ+ }{{SR{=wܹ^yʲn,sǕasʤZ\3&ǒ9=y犊|*ouWm 6נ$qOcR:cSV8Z8UDjfltW<XcZ(y`Pa~:zzQ"6{,Y[ny&<1>q䓑jsdۗ#eU法.c:ѧ))Dr8629Zv' CUq-q=^W$ ;kFV un:ֳ*TJZ@w&}msDqoICWo,Jl6sjǚS:T[ϧ_u%Xu== f乙;Cz"Qn?l? e2Ȫ !*\(-)6"`$~f;RLjR4HFFׁ~X˛Ș] hag2 ۜ3nQ:rak^ՕR=c?=+)srmIkFkatS־Q4h}koqY >3Feyg(F7Pp99wkܴYZZu*l4tg2{r^4aJMg8tRx=~cqJ5cwz6߈ZfʑJ2ר7Y_rx"QOt޴_vT:KDu2܀xc)N~Vrc2YA5^1u㞾Tt&/>I[fm7إz!qJ}};Q4ʑO~Ueao<Ţn=y;y-wv}GYn1wnη m#wLzҟ#ؙ=AL;,+6dc sz%9GSTuCno$+ g l泗NRoCZQ,2dIF<ӽqu`UNMIXX)<|a7G9q5Q[][8}Ngrefb۟=TTxK+$275@yxC):zݭ{$HR`K@w.[籭N2a(IR ڪnxNmu,,8]˓88㎹5,ZJTjE{Y%oőCy+Z3%eU=3޶cMꄪF=@-Z x?*+jJQ[4Wn]m޲.qxMvӍii|_d꺋B4]]tNkÖ6N"=&t)Q-ΫwP;}=vr=J>E-QPWco컜?ַNƬ#%xWH9+$j2#Zӣig9Rz*r%Ib1rQԊ/$P#H\g*u4m˚T(CawhnI#3!Y {cδƟi]'dpmki;H;+p#YiIwI=\p0J*SR}h]\TUDֳ԰7htܤdU:q^źu>;[ȹw5p08W,sʴ\?m+y-;X,0E+pxkjrקDivD^ eDMcQkb0TD-pۖ9 l̹_UR$]~Asu#m6_ܣI wqJQ2FTܺzC'ZO >[d29+qbEF=4,ؓa$ 3ys?Z1VL磇&:Yj3zʶ1F/ Էipm$fJײB:~ϙtg$d nĤaÝ^ iW_O8youFē&Ս|-wQ޲tϡKVUmV7Ur3ӟcuF~PSnI^UxsQY\os*tO$]u<o6xT]be^%b0•B7s{3Jx64,nj2g?"cxǕ=KA2ydw8riOj.=Y \. l>IrԕN7,wJZH#Cg(EM؜4JHIݠesҌlcR0U/b;g \v'-TqIaT't_[8یOX咏ЙL|6DXtZ!yI_.io%X9W1} LaIdֶѸ?3J>WDMd H6x|$m۔gErrHڲN}nU1Po9lt&c)V'oay; #`9 lƪCE˷IgF ^+e̹ͻ c5Ozr挈Y.Lkl];ߨZ%F }%z+nV!Mۍ''k?ȏvyi꺽p=֍G9<[FR=SzY,#GgۨmF^-?_#8M\$r<}+R娤ʌjF#K&}1kw8?=q!`L\mۂ\RzZ} Y$ScR7O_̨w+63-LǛ*~(V{|Nr+H~GFڒ>p~e׃5SmF%Hyf$d۾=}*)Fov]ztq1U].O.13;0qls$ٽޱ.g[j{Ge8§"mXڎ;G5UF8gXoşNf_-?Kk淏OXi u/rIڈ74oȚ˻4+>EˆXf;q#VoՙTU=^ߞxB]AⅮ9X+.fPF? ѥ6Ō%Ny~[il} w/ϸ=+<:;tӍs2qqR+$keu}=-DOie4HUQ\Ji^Ep G1T?(hTKJdFj%)F8rk.{I>* &zU8Qok9UI;ss~[&o-fӨxzSgZ1K5Ķ#g9*9FVDԣEu]Qghx=y֕:){סq(> GFi@YJOYaNRϹ=dQ`KIڶԡZ-۷sF8la|5G#UHJŽGn{vþM[V,/V};Y-ܛ?ErxTR(խ)7ʓ۷rY mifUR1 Ķpz珧5JUG 4zo1+_ i&Ҭղ,3#߷]}b%=.ezqwpc6lv|:ӵieZ</kWU1ڳj=q5(Eh[4ZیhYG{tK y.D;QRgu-ѥvD,n?>pxj/uPFNZ~'?iUX[\ni"ڭztYT ԚmGHl?icٸc$dkis5HF襫yQݹSFHI/vOJ|ڸVztyu(5ơZncTNӱTM);j`~#yYZl䁸0oq|Wţ0E8kwVҬ?8el"hyziPvWzQF'kk߯nM z#t{=yN2n*6ӳkZ\yє6Ys؆>OS%O^ޫ5S[-?4zÿDᡷUNI2MG%I џ-VտԌ$+%^ZCռ/-ʪ(`@8G;{Wt6<ڸ\<+4oMq^.$8 ~Մi]a, chGU+ ofҳg'y#Xg44u1ݖ };UFNRU9CR~TB-au?ݲg<uMtrQwКu(?.^kp0>GX8 8g)L4dԖXĻեkK*dUULz^=t”trI]RּCrV0d1WN,'O}$]eh#V ,3 ]Qozk/ Zx~i4{.~D#K7ے):-}DBkB'03G͎~RIB [ȴmabi3p8wNj1S:w~xuӼk|sۭ:OiȄ28#ׯ[wIo'K%'>)tK}:G@yxwSn_sy?2 NYiH&U c]P~o1ETJ+t=^L#7\γ84OWWm|PMmu?2JZ2/Ast OeGHƝGzև꺟BO\)k{I$mn qzp~8~^ڞ[R SƉ=ߡǂln>u;]̵FV] p}ppj-o=)c⦶jd#erGon¶UƼ>%uc r*3s |/m>IlV9ל:vcx<-hSPIGRTSk]YouUW{qvA%=~QjUct%֫_6&s(ixBr83WJ.UNR[|0|K%ֳM 2IF:⺣iSoʕgʎ-Z=TuZ&1mMN,uꚔR]u46 '>`8RS.fX,=IEB+7g66@ؑ1ݜv秮4^C,SN0N7H.uFxK>Yخ[=~Ey[}?+b(ƴ\gf^=/WMqY^nhWːp͂~⥊ݟ2N5$kizRi42^fa̭¨o_^])*7c!5ɯ~)FOid{[%`{tv4FjOc BjrWz6KsU7ou_k2#w#*0z&pP=L=7tϪF.jb*7Q\%~vO".dyD*ֽ* 0+ѧ*Zz0۹1WNMirN9T児xrk]a|~4TT[Kn$NQu&—S .VSݑQ~u,CmQoގL<{*-<7}qu;Fys)i] 5):t$Z:oq>U{7}6jĀJ?) `M}CUketM1~߽,Xe(hVbFchy5F䦯}ޟw\\,1m2z}+,?3vTޫK̛/ ܤje-ź[Bu_q A\t9'*n*3KG{O={5F4e6]?n4#&Ku]h̎N2OLg5Rj:V8(ʻPincs f͚i,Q ,0NJKQ_Vߥ>}Sb']J=;0$Yb'fN2[q%GxhEը宖RUEoo%ꓬQc<{֕!R}~f8RPr^q>48kY`Ur^IdT&8zׯo|:Ƨ[;`y.A;NXѣ%kvKk<OQ|>&6&n6䑴u?Q_5FR4U϶Iaܕdw̠]q];{8ͩ4dk rma NIVU4FTi{m _\p̲y4k#8&@#y<5:dtIWi w3\8)<ʻ~bw>AM;+hxJҊ躒[lW{:s_ M*B:iMJHLml1mYтCЃZMN7]-9e5i'"3Io4ά.Ud䒹'د9S^yƯ5Y?T%w4+ӧQO)%iGԕJQ׮T}W3qy#\zNmN)nmd$sg=JQ"N1ӿc**Uz(!-ܓWc $rc \˯9cgc[jeH>e'Stӿ4Fj]_}В#DGxUI݃jTtoU޽Zv ,{֍BL ~NH>ORwRОMty5lGN\-Y.?Eش$(=֝TRR4Ay{}+5pDʗ*@98l Ԍ91U,f$7k_b4mm#z|ҝuT s䊽#)Y$ajֺk48Pj1_^V6ӐqҺo/愝jnyj!#Y/,?c}2ziL3}Mn /rrqpJFS|=[ԛȅUe5:`%Sk?my>-8XNC`{+9F\)FUdn~Xl 4c/OstF2:0H۵A)fw2~Q#ٱrFC< ʧ0t_qm$L^nÖw9=+hZGֽ 7sw,HuW(#qU|;U)ѲVf6nddc=qQvʴRѠZ73DRdbrSߑukSS)=ںyXu)(VJ=h"99#NH]+.IYIأ1K,*O^ҶFqINЦKŋ{ќn^kS4b~[uU)SkK2*}IنFRu&~*<1]վfzV֔oQW5KPq˂348G ƾN]XRLme汔eYk} h֍_uJEkX}=֑OVOUA$V),Uj:#R8yEJVVVqq"6ǭ~Z&4S\m/uinFpO_Yԥ)i9hr{ Q#V_f>Oyۨg4ңrz%Ŕȗ;\є9G } pF.3'e%I¤tZ߹ ]˃Ϩ\oc&Wdvmnʻ1ӥy}NZѧN]Wsls&i7'ʇ*ǁO:Ҽ*Ne:[7-,|3>~1W,+v%Vӳ,@X?1d9}Wn}íRN:Mlq\5#W4LtSO-}UX,4ǵ2#qҝIN^TsGS_.Qt96Y 8qϭCcשu"F{NbT!L%Jk6lvefcs\qzוo )uio+A6Jq۩ӌcFQM?rBܬfaJOn,nG m2N_:*DC4:mR q58R"FsFU~^=*J1*{W>T8fYUsxr15*NFOlzwn ׹HqURh`,v?jqٓĂ/|_znR*Mffn˹?)ߑ֥7{oodd#ʓOwn Y-> }Jn05 XbPFȍF'YҥR-9Tcjj}ZRLX$~-w3s=n3ZStk^o+Ze+f@Tʚ+#NR(Y{0Ŵܹw F4eN2w+ϣRWd6K994cvR2u2;(x\ʇiEڝhƲRCMiX]1ps޵Sܵjӕj{\3Cl3I -#1>+܊T[K'4. 8Q'o'ںS9F6>(R{] *`ˏ^GIQsٙԫh)69E;ǽW[ۧSV%um 7ӧ? =HB05nQveWh@v8sq\l+UmOkuXUݷ??WVе'M,laXgb_q$r |ӧi8잛בLJ 'w+`j`qF]WhuA{꿮ċW~mw{LM$xf!9cfGEѽzFZWEdKOj÷쥕8r;021gZ:i-:MtGJhׯbdɌc?q\V7vy5(QUkd9H"99qԃjTinݼiۗ NQVm%t仸xj{fCkc8 'Wk*BTMߟ,2҂R{^/ /O_ ]E`C#h<1!I=/[/%*x$_鷟y Z3]]^-#χߴ,t-u8z.&^K4 dpjQo^sGR!i-k-~7s^}zn)ԍ%]leqkT=*h/<:FRۨfc\,)Y#:+'r[ky" )e'=¶uNѡw ?EOgF\Z )SΕ3n#)pQ)J[Щxʾ|p&mk*19994YkVdهZUKJ~Oqc}{e3vh.~^7{~:{+jJzIVV4d`xqWˊ]/ٜ5]85ZEfopֽ<e6gQڌ%F\m=}xzko+F4O[uKmZfdzכ:ͶxVim~ƹ s!zTNi;y/?3)S& A%*ke )SJR7{ɖuN)ZF>ykkߜWXmSof /n$Vwji˛U3t48 Oq_DѨӻz2t7Dpy8xu=)."j5:( k.2nz&Xkmi;} iԥekBR*ikYw9`{5=g{ Tecι%wg[FesЩ Q-i@ۤ`(6E=\;p˟K/|;HJ6Vmbs`/pkOk$G&86 %I .ܓ\t9uGV2ըng!ezo"UܽiJRt*Y;5tR%;[+&^:\W^Sx[#^MMr{;/Nز5 ߀xu^1Z?~Iޚ-3Ľc_2b ;qOs^"^줧KN/c1)RivOHm6ɷb;~e929pP}_#FJw}?;6 <~"\bFF;X|`c۸5g#ucumgXZT*oImy֖Dq&#h1J34򔔯>4/{g=Cn67}=>nr:gQ_~;)_gE>iw$ҵK.WT^'T=A_,UQǕ;'F"W4m%uziK]<7GxgPX쮊𽹓p!PGL`򧍧,:_DZQzzyߧx- -wXcc\iF$6xǭ~TUsUҋI;F֬y<&{Gw2lN#z~1vz:3 Z)}< :5#QӤHxNڡW8վVtmwW_{kQeq$P ^8k v]~Ukضￕ/ "Z^ֆrlv;׷J&-iJj'dnr5mNk|\-3S+J9yRj:3*ѣ4h@H,8\iO.huLQc;-ÍzS|ٞ"iqx/jk1*q3ѿÇeOz-EMђ_ˌէRDΕO*[_ *`EsIm){IrwjֹdYN$?RH< w#S[+ۿwﭛkm\GCKbVH{ޣ'ڽ jrMf pUTN..7}Ϧ4]WE>Iz!Fw·~IwR֛~Z?Cn\eOA_'S+*#)R'}KVյ7(2G`ySWcJ<4p\oSK[ Ic{ǚ8_yZХSZmOFe`c<:bʵV/OC&\eYi0y\'Z[~H[mFd`Cy8_g }>}?#*rEٽ:x̐ڻYшbcʆV9cw=zUwapg֩lXݳ:̢l;t?}% ~}898Eݭ9xyr 2;qאX˞KoϡًW2<74+ f 1]=+^6hΞ"|Mjn[ivӯ^uFZIGAbȂ9mA78ݧCY|^tG<ѮWBc&U D#:ڑQ?JFQ&J<~arJ|]£ ;S[z S].g_ @9*{X6W -RU Z+]N<2_Klؚ5VYBx#?Si=WDTw`yZbFHwA[ߏNe8BIkg%t*xGESVWrGȃj 8W,E]~~h5%tO=b=ZE]#E>^;qE!hPG# 0x{svFַ]%F4.WP ,,[9<֑+=|xZu#lg_w}apZEfhQOWTeJZBwO^2[ Ć\w.jZڍzqtY]Iq͹X.pڴdT{oƞ'thn-ȐCsIQq!dW_,U=,St.u4D[o6o0#ӎuIHڲVeX1_mh 0 {}D)S^ӿ^6L$/=wbdR[,'!H]Nn}:zQ[wOSϬuCIeoK.<~o0G 6^V]:|whl j]:yukP<VE؃،5!% EVj5~L: -JWZEJ\%S)WܣqەĊ#c-`(ʜ֗G4Ԋ|M~^6a&Wq_.y[%LVp}:w̽cc wsִi;*ԕJj*[i{idiClٽZk%RjWTԌm)] }KK{i;;k^xzj}N6ޓ?+~AG GK[ i^6,Wj-qFyVp [K3p?ZR/u/SITWr, ^sXG-KTPtD֑#s5j0B:te[ҧ[niN+&ȩF2+6Q»QN[R_O' S_mu4yVhPsҹ]m2=MI$[4_0tV?5F\ȍss)ַ$Q 76>eW,GJ#UTIcVlyf1PtXʵ8ImclEZu[㵾y'̻|{㎽+ͭ'V,0zQA60|Y_i(FEV͖+ve*"e\/C.,NX+x vΪu#Ӧ2f_-~^Icԍܖ*Y#dnK*}okQԷ-g +Dq)^~n߻eڍu#yȕgH.Ua5R2:Zᵼ4ji@'5E-N|DE Lf.3ny(V+w^z9)GދE+=Ԇr̳(eW.sq]As6yt0n&knu6,,LDPfwӃ +;Z>ϑ̴vtbwpDx灏>njio]zM *bdln\+z4Tj9%lMf;q޻=WWSz g)mUFݸ*I=1UN2<>mDeڱJu^q?:1u;0ܖ=Mtg匬1՜!9FdQUGZ%F6WW7%ס_S=ȸ}rE>U]a[N~$Ӧ"COI_ƪJ3QJt3nb< 6TcJ-e50֩(F}R8Ԓ.ژ'ⶡDUShǗ_R4{䷷Uzˑvc?*g 婽82XWe]$9S&fRX9nUג<|D96tޯ̊XƷ"C؞cR2;~䷚[_3>[a<8ddF ׵c><_DF%+3ٙT^n"bvHJ洱=E\X1= \ZN5&љ.LvGV^ i/{lpTkJNd$Pm/# *G޵'YkOo+y1ˇIfJhRMy|U ( [8qֳ~USnJ޻˩5 r0;:1?JTTt[V9jc#%OM+Fbv&O>ߏ?c)JrK(cGAaadjryqM OʸuJ3lFxL/6*z'mIu?bHhxmwB1{vXtc:1PWnI=z- PWxQU|A#8tw;i#(ƕe~moQ&1FۉmyVq%竊F[+y:,-;#,Aa8R1۶O{tլ5͇({Ϻ2vy ל*%N.<Ԗ+K|+~зG+ġK>w z;TFJ`s-C6l67sOlUs~io8i_KoUr 1mmcc8洍8ԺogMH^*ruX?y⿣N*r(ԎUKm!d+O9~=?16SrCe mcmi@sd's=;ZfH(Ͻw{\5 *m]eeV7K"1 q͓qӿoNjT:F@ɝ~RkgQjb)5 F۲ѺyQ(o\*qxNdb5[A Yn70eaj d&N CQ7}-e(;P"*1eE;OF;jʩ)syHva{t;SMms/k}]3*Ya=ۤ:qOTeFT%{G5c| vy?iNiDkiDQeo Ǟ^>ӑ kRūFtĝ7mg(~ٻ2Вm!DknI2rGl.S]:qn5 AXv38#+_g'r֙s;ðOʱN7عS24*m͵ S\fsƧ4ڬW{cڎh򥠛\>$pM7*HYQMtqP3Ȋv׎+TmR%e%kuV`wmh.JRbg&QCܬN˂yVrcʔce'Hؘ.<)9\%*\yfy%$SR^эG>Xnoǖf'Iݫ?{g(Ϟ7@x]q9㞤JƧ75s'{`^N.>J2Ԋ%"źC + I#FSV|FΛ{x-Lnԕ'ݝ?{F(v[ {?u-J2O ݞ:}?ZL ri0 2H"c,0zqEeKR9ut!6˱T3|sv"^; V`lq9 SR}vTn~? ?-/DiJKÕo#[r±鞣NNӌlF2DYұ\c5*H)|bw^z~U|#Z‘ E5-'==)8\vYөG?]R>tڟ#_V76;@YTkX#cyGUmni>i|Z)'uܩ7$N]Fnx;ƔǚEҩOĭE>םҶ[<(r敖D42yȷQӵ te(y\\gkme893>ԒMm(| 70ǿLVNYGWSb.wܱswo2۲$E5==Ltj8)ў1s巕!]Nʎ87!$rI>ǁ5O+;*J4MqP,YCnlO>M^9У9NLI n HHfe=G8W|ˠT?KFS\VexJOn8ElkYEߛoRA9U mϠc9+#-::?y'T,rG@}Mcwws_MX0]s4VfʎX_ U. bnv6~V=p>+N\ϡ\Sń[[lXn=w6q9\*rW;;r0[I$4gvq**R- ( tBz#5Kp'vrO|=(z3|$dX^8棓tsԩhG3LɶL=N:>V.S&Y*2{pNy#r|gUm\-h#{A~ʍ!+L?/>H 4weQyG$zoZ+T&U%y \#n[4D߻vEowc9~}>cӸ o5O F}+ Sڛ)sX9Gcwg'=iA{o[UJКaX 9ٴJۚ^\^qܗr* ]Q岉IJnD|䬱¯?] RVv9+FR*j̰f_/y9c 78zןF-Y5Fg]|ѶԞG3-E޲J+6*<ʪ-I>U&k( n쾣dg$۹Z\\vc.-+ycVjQnښJMn𭂪I#$~=+/{ry#ȝʏ[ꮚ5y$i YY=i8i$vV+Z*ɟ噄q$oͳy }i7ab1Q%Ecø֓w~]JJ-d#yF$t9N4}mv5)9_{tl ٽY6<㧯#5nYEKz_##[z|DI2$\_=^f"GξZ=o2xXYFد̀VqJ/T*ڞs EI !o*ei&~J 'O\ms֋=19Ĵ^{cG{w [ u_l{qǡFuf{|Wi{u;oN0:Q匶zzV8158M!gkil 1wrI gΏNO9lw9]s·ݛ I. xؓt,E8(ׅ߱Jfeywq˾e>sLp$5VK}-u:++~mKY =³ٸSU"׷r}Sz{~G'…m4`~#ח(F>V#S"}_&[o3<]%qsݪj֍jNyz2ƥE>e{_mb-5|ɏ9'S :^S D#IO?3Vhqϑ\,) \uiߟrW}s7>hsjb26# 2IYC\{۩ľeJȣ}m43u]~ [Vo(¥5:]Öۡխ-[0]ѕ)n}2h*;Xs&oխ/ Y`{D>NIe=zbir73CN-=CbZV*ˆ۵igKpL R*4fӖUv#ze0>Og+߹5bgȮJjS~dIiiUm1bŲNx?w+ismm`ud[|;D$#]\y dt'9^"bֽlgJNU.tt_em&Z[vÏ#;W'סQ(M)(ӴiLi>[Rʪn @$zc[TC ϩ %4jϧd1%F;Oڻ#FRԮlLk87ߞv? 'BcY"+*#ږ#2U?F){=;4 Ihx"zsC\?]Qju*k%쓷GNw׽ 5&ߦ-߂Dd6cB0V3됅F0n/ha."_'lF\k뜱8ƊsV}KcB-UU`J穎&.s=g\PaSf H9<={匩̦M(w3 ,pºm{;~GzjaGφ{{ΓvC(8ǯ}mPiz2Ig%8E <#):uoQs˭ˇ=VS |5t)<6625Q>PÞJeNub%WI)FNKgώ6X~l;׃N<C4TfV@}x^^ >G5)k#FY;n[8[ :t=*2{s;yY^\ʦؖ*ǻ} jByCad䑿efevIT+-XymkFfz./Z`v4l2{gb*F\U:Oǟ4k`V@A߰ Ǘ\z__R^2n.ϽUEJ_ }}Ciجrwl9\ ϿJ\U(2pNF*+waiյHoŦ$2nwc;hۛgR/DsWS'mwH${V#T*UM CHQ =Q*pr8DZo{z=V4{,k+=pGZp5ʛvWՑpv5_|GnaݣfX\ @{>\dhoqaTc<\_,sOCMMFز`~(̞_m忑uQ8fֶ"Cqȫo?|%N~`(*rVM0pu}W7)a[DREcʃ2~*)֟NZ [UwO]Jܷ6lfHCR`P9gG9[GG Q+>D4\yfffi#<㌞>a*tl:Vu._z[s`rX6$*}ث%/ӣw*귫aHߺF:Q*kNe$/c[ݲ.g'XI_q0%u:$R'ʲ 3 ߌڝ>hۜ4ʤ׷e3Q$32@!/1x I?7^qU qIiFk;-N?^$qS5+,9qvSTS)X{=4+\y-m21' ޴Pv悵ͥ~7`bUYc-n2!e>} wR稕 Ejdm!Fa#S}.k2v;cNTGO빽a$CcnюOnRO?};|͕ơkyyc%;SlC.{l<)Y|ݿ;{eiN7!IY-|2YͨJF֝Y H?؜^;y%qxz2M4E1*}~1Z*zQ3i?Cgio!c6G?wlkBPڜzr'M6G ̣8¼Jrٞ՝T?.׹|\5QvchqByKXwt +Zxz>WQV޽/iŸѷξRpIa0OcFᥴ !u [zB9L4rbO vJnU#WvN24twښ3⻚ #Kˁ ,Q qWS*OWr4%ь~گ.~Xb;C8,9c8*s U\6"9JJ6|_Վs_7¯xf}O[J $Ϩ >~5*EI~giGHE~|@'fci~x͵l%F.HaO~^#{nEU{+K+ߺ02/ɫ?5=Sgg4II,dQ9'14qJvv5N87ͳ}5xhp.'uCzO>cއc1t➽: 6 M_Lfՙg J1oCizO}kagܱEꏖ?==OZV5iJ>N~ޞ/'}Vך`r#O-X9N~^9$F#UkGF垳q.j5p̑1-9O` SOt~{1Xiu-;ww'Kp4Rw #v<: +'뭿jNz7gԥ6Mn#9^#);kk֜eVrM[ b*aif&Fp9 2v t4ikK[C<-*(YdyZ$(H]<0smKY6vz'?e= —svmHvE@29z,FQs}fn\uz> ֖!CI/xߏ>'V&U%=RQnnM.dSlnR2@ UOo#K>zZWx<$ v3u1ug&ɵƍJtye}: Jk*9Ej^QrHʓwx_tPM>Y=t1ef?M?sg%*M_&'eF)Ry0[H68 {qʣGGN"˓z+ 5%cޝx9=kΩ|h|TIkH'sH.?%rܠ'#^^}vmggn'OxK[;[Yѵφm#Q1wRY:r9q]OZo[gLޝ=#Q}}5м)-/x(WL`}:']֣}$WFªcih.xqF:wwV4⭣}mS2j_o kP[wծF_'>.hɴ[[Ь][w:XL?|K `mz79CZWMp֩y-:K _1dbE`~ipl9f p9|F"7{mcD+=ꚭ厬,mdgpsùay~5'(sZoKTcmQvpwQ#@<ܵU[P8'bj%'ZZ_G,NV:jN5#{ ؚ?E3.#({$ Gߚy]jͿEqêT/KMld1Y,"6Agi/%+&g1*Z/VnO=~\>4>ֵ.CHnC&{ֱy3ӥ ̻\9ϞF_*MYs#.UG+hZ>{"o.lƬBEVe9ڢ?שqQ*m4syG[/G8=zWJuy_Mo婈N)]urGmng>S8$q]Ijz~Gn)%Kغt͵~FȪ10G֦I4RW+mmeKJtcbd=>o_޻(ksb*B4kdְ:-Ud7^y~tFG㥷hލl^ik[J6Mq3ӌdo/zZpQ}o$ Y"ļdvf7NeY{{m8ceYYFTSduƷV]= 1V:g}֔&8)5WW;DXnTfةFRWUO#cBbG׶}9cR5.YIyjbqT\-.lCXi036Y>R;>tRٵf-Uэ/˒ǠV?qq]4gVEc'wO̜]N3Tk}]j2,$ɗ+Bp:?$e},G,as4iruU ;iԼ/Ė<rqsҹ\*V.4cNO]>SJk 8GvF:⽵>IGPi;$8f~GCֺiK]GZ1t*ܘxeu_&ascӷ|Rnk/A=iv3onV9*C ܞ^һ(tT/c5 :)X;1*MkrۧOW5 qkU(Y[>99pXJowӸÖSJʪ6}B4F*nCqMʲ (mZF-tFWV~[اhU:cv;gUi\CnYwDn+N2c,<5Ua2OHF ǚ"߳]F0>.0n|ǍXr]rT<z ɭ912{RY-(YFzzW#ے V-"cq吘@dZQ{cNV6R%N:4c>,Ԍꄳ*1cuk|:_$M<4UZ5NIJJnE:Gd_Rr[*J澁H@׾qjSD3v_RoM1ą##;-G;䵞d֔Ucg ۅ@ <+GU9*CӢd8ʐ6PÊ㴬&bR]΃GK˜O5TΞNAVF\ҹFNGGUq UxnH$Zg9{z},uVVK2F#PrȇJ;hs:?˷j0Vq3ױV2MX謣(Gpᶺ^y=q֗4#*ubol[`pګɵ^W`q'g._n-dgly6;OA\0-O9#IQI9/"w$EέI{M*8}᳎jy'8TWi! VQ啑%)eb'7Ѐ}95/.%z+>Bp34>R]J؁$7lzU8M/]г!F_;XT$͹vLֿH63O攟%:+{Z|j&*T<Nj3u=e-6ɌD3vZTqjuj:׹BKH`o_wsJº5 [H3":A2mVVl,p?gN*J_Z?,j챰mN:= zj54u{:7nStK(կ$|/p2??pQc8SOVљOY&m̹kF(9ۀZ΅F9SkMznr#e~'+hi;%u{onCt"kvfD01:a(R%ZSQu!~,ޞد1`hʵbTeX۶H sZ]2i'b}5e)/vc N.]q=ryϷyъ'NS DTfҍ]H1/q֍rU4n 3{yܭӏO3S8Ӣ^oSZ+};1*䏘\0Z^#} jc; ?/>MIA5֣N#twz-D"Dd,I6,gioNFȫ$(w{R5Kb%;bG6sҺVSxyrȎ]6o9ky[K֧*G$Uu9ܥNvPAp0ۉ6:'t#SNk6{:ֹ}H4+wuicOFv+%R"L36wp Myap ONWtikn b麰Jz%׽מx]bluG$v;@ْZ,19^+СӋY8ůvz´^+j(o5o, Ȥr) y8 xF*M[O/Uh*=8=B;UKKWtQrg ד9VgIޝg/o޼7}-b컗s%G 7^S|^FFH|MEHSWOJrmr[Yo B ]z%UHՏHSG dnlpҥ%O]]KKc3Icː7%}~^0G|#R1ZaEX{-|o_o] 88QvsHmNHG$u//jɭsx2~Yoιbamc_?,*[M_}aJnX+s=g^}w5&2$Vw*Xƣq gI;tOLTW7nCK|D$Hn, _NRZ Lt]LBxy?_x?ǻ(5/_jqYGL1͹@,#r1q0>^XI-o_\/.m_khy_4f2eNzץZvX jSމ+X-&tAe.HB1ZܾOkSͩ^8X5&f:}fI?(ٮ$YJy9##q8jM.>ܧk[Bճuq E#?)#e==Ei KqxJ4w]l0`ZY&4C#МbITU|-uIf}hK]Rzz5WyYla,ܐ>:2F6XXSZ^V.I`֧N;*gQdhw}y=kͩF6%ұZk9$eJq֥F_Nom˶z [fnW2:0cSy|(Q"9PNwTyiQ}58N-w#6_S(J[uel/9w\KpAAE>J1QmZݶ=O"Z. |+T[aD ҼS]k,E>Go{r \]kץfn4$G77yx*%6|E{ŝUq4ӓkTFWN8J-/OٴO lIzIP]ObU&"Rj5a@ҟ-7T()-_@Ցbuo4r]*wvT/C6+饄mjpeѭ="goswM-QYc'́B\]89kcPMg\0yz8Z܍YwhʞǚTҊ4,~]%Qk:Ք9_E?hoʷ3ohb>m+KCӬ{vAּcRZO^*m{Gu͛U sܣWTQOC(֎"Q4]WO nm *v:s\QtjQ<ھo"?djk~}#3wl.13 0?0:g3jB*k8=:?u+E_D׌{9ýòg rkA$㎙arm,JQ8VWek!nc2;mP3B$'g#eU)Hhn;7߽ޫ|<9xOF6'RX6&; `z b)8ӊ׿S̱ܰ_/Ch7i4gdOf a0ʕ`ɀOt $*|EIN1lr;pR֒z'~dWW][]>6z奬zETq.bdfyS]lCA5R1t{<=ukEl{w)ҵ=P"fo.a8$`/jpRWiXoiv_o3<-uIi[ ${?5ԕUxiՕ;ۗGkϖKy50+N/S[Ww\2)Am1L8ǎ[[<{=Sqִl|5Ofۙ&ڛʌpO#ֽHJrk} 5IRfs܅Q GG&#WݲV?z.+DO5l̎IY7^1q]T4-F8 wd=W=^3 TrGKZF*lx23B'@/z qd~_m}*/M1'?*q,:c;ŧo(M[L¸dq[q? 8;I$Sa4x3y) [">\*rN{ׅ(m)jSjZsQjiv/ۣ܉-ihϧ˖U6> {%m?so´w9ux|"}dcR1Rj7zn xMX4F5-o~ʒ78 c׊qN^wz-K8Է^ '{W.{$OWj`C2BNj_C޼3σ4"s2GA?eR˙%8?*ckĈx1;ӣ nX(E| $Ǯ=zTiige>1j.D>/uL.BNIp9э?캫J},^]_ m5s 庻J͒|ݹ 9:Q1zt%N3=~iQA(%=OJToW#yfK@VMdg/u#Zj}H<]GM+dpw=\uY8)E)9+~ D"y-mNOաBK|p}כR{Q>!!bI#y\չfn+R `?ߜfi"c'̟*8? ׌ֿW8sGT[Yv]xU.eCNzXeI1r[qß*:aR*74gY.FNBߐw+ף(Tx{y_G, _teQ98j7%tƲ|'˂9DaF?i˸7}Uq8:tB-gͥ1R$,c'ԹJm+w11+\G?/zTK%&3b#~M#-N1iiBprxSկ&L}\-dS+coMiKX߻Nΐ[@NӐNG=FzbT\_\$I6'kaSŸδRKygK>Y#_*99~5X)bֽCb D_hv'wSuwȮXc!<~#ԊF+JLTi&dlpqÎ+7Y'w|1ælrAec$<,aBN`*ϖ)_EcLF#TPYplkj"i-e+b9i箥IB-=?([hwѬỳI\ZjS8Mߧbp`y:QԱʒ5<p9֕;8%wܺ1)%'vsF!VEYq6t#Z.}R#~e+ {ɟ/tork˭U8ʕY)+y~^Fn,<3|c {^m5[WӡIGTW`Mś¶cS 8ҸjSQ凫II>7^`"LmgN5?fQ|DBVOI3Z/&y,5d%6̸r+soUK7e`TW/[]4c,m8-#i^Ɨ42 nZJIinq[tmĉVQk͜EBeemomٖbNJzwaZWC(Ֆx?ٱyVϘڽ=N{4eZ7wմJ$ ZT|&DrëdI\5)^6JVtf9,M6ni9ZцL[m )'V#=== u=p{hZ<$`#pUF Rrq]2DQngW=F:(գyv-$LSst^"T(`qڎ8NzNJDT؆5m>5^Rqnk*iIFneEo#f?3y׷N,u91\Wkfye! 01>S]R׷eDe߾ ?څg2pwhoQ-PwGv;r)B.r@!c{VЏmHSm[230m<㨮j1vߙb1-Qv-8K3# O׷#5^:Ww驈Rʒiidw6sG\~ ^g3j-qeKW\ :ⵥYԗ+zu9:mKֱw#c]ȧ1\cRQoC˧(7m/Q=߲ib.zם)NU4z.|U8ӧ*!BIJg?S+W]:thYZ@n-6fJ?UEW_xD tINM=M4ਏǹm1 g2qJ?JIF>.]Po+L+jrJ+c͛}ln쳜u^kQKҨUQ14 gǮk:J ^4)Wr[=rZ^ 2<;Km{ ,vx_|oQzwc*04osԍ>e_7v,pK+ ,3؟؊2rJ;uyxmNI+kV=dYw1#ovМފn+&GlM>_5#!w3hF4jKiWUb^GRfR/]:[Q.Fl$CS8BN;եMrtu :rMr)ʭ73Z9|#Ͻɤ[mf ),3SQ{I%.VV_"&m?y.,8IɯBJrG62yc$֣|.6a8G^+1[J7:*c6QFoNA EJ!XUVxPTN1^}HvFY*,q u%*t:9E\,?7ʪ8^*HٛԥZq6r}\N>_drqԍnFVe3~1'i'${vZӧN 5N,&Wݴ+FA Ng#iSqؽj&L. v汔yhtfӨ& ~ZGNXCrMl^Yeʫ E\M7rJM#:>ƭks2\ޏw"Uʔ%SR !ckˣ䒥}ڶ-cB۔c}&\a+(Kh5~j:x쟙5r. 24aUy?j 1nmGn#m݌{gܹ&Gb[X"7R0W=?YO}攨ӌT'?+˝P9\pQ56Xi<1* ǞGmTkBX{)̫4mc..W ۍ9>Y4S,Ȍf |ÿk ^RΜbD1L6w7N{Uӎ#IZfha{zָ8s>n(ȥ^K㈇Bsm]s|w;}?:KNxyʧ% O6̑Hڸ8GGٽeRlg[[Rh^ى?(sV)TRrz4^,F"4]g{,=ؾVE=?*q :njb Id1&6@g 4*KGm0Xwc~u#>TlLbϧJ˱~:fJRnOk];iЯ{jHw $dd2x8thIUmoȮcQ ^j4iB2=lUp%و$* 41{Wd9_-lN#Qn+66+TaE+X˞ feF7I?],ob'NJ5MHy ϯZGIQ;$2M%id?<͒|Fx9[FJ8~XnoSq4T+Y[ wGn߯el՜t0ҧk%d㌬^c;3cs`qڵcisN\[ 6./ ?:/=gEz #l(ÙB-Ĝ]*RpO47.^UIt:Vʖw7 0^Mq8':RW內USnk~件yyCV87^f"72'Ҹg-}7lK+ZA'w4y8Sry$βIsIZe=%mUT@~orͩibcZ9dc(К(ݭq .39JKX܌9Wdx[oڲ6"yYò0L)5F? ?S'sY%*e+A^[J{_1(KUdCڭ亍ʧ7cbk{9TJ^&kkeȾ$=c ̝XUR!mKi"PSӷ#񯝎**ju5徇+?ׅ{(v'#:gҔs)J~W:)t*Z?LZ|ɺEV`YUYz-)]k#tb4yuYc&t"o@A#I~q54/b%뻳e}w-ƎnCC[ǻreP1rx+Ύtnjh(ˬ߁~7#͜2 ʟ/@8#Uq=}/s8|-wz? )-ՙB2h'zJm)E8kayM;-Wgb 3/ *Jk`g89קG:O2aTt9tht%d/ͽc tjVkZv# ͉)_]y edGɀGgήa[>nmRrwz%߫y#Xe3:+sۨp={)⽭9+l<BI:KȆ?-l6̛}t *~F͋ޝ8ŧ.7l]ܩ!|z氎&j+n;'NlsLu6&}~~_Zqu0NSJ^Oӏ2>ι(#Xڼ}OF}9mC yvNc#y1\q xXsFq""Bv[ s짜Q4ye^3Fn/wS{9MlNҹƧsB{vmXͺѮ-b3p0ٵ)Km=xgO[kw%Ho^ @1fʼnnO;Vq/ș*۩ͦ$RNsǩ^*a[k~RtZvM잯1oE. g˚{TjB2F.yEhCG =ަX9{]zQ6n/ڭpy1եRW9F20-SPo_?ל,aISmmZo)Y>7Z%xt6S,_Z:x(LO)ZɥoNkJ)57Nݸ_oyc>OR1N+}֖.zqNo|}o&&p<М2ɀ˂qx?jfurC~_CK_wHIȽtA+ |/EVCʸ)컟<߲~ݧbjϖR{fk0 nM_և9+}p]5ҦJSjSUt}-*[Ѯ4ˏM$H9 !\t_@+mt3OSp[m6jĚǎM.%Iȍ7x>ƿOCXXtN2Mi׽kyKiui!MHnQ{_1W J>_J䎌{%[# ptWZ9SZ[dmӌvf鋧wxzïeNJ;ֽ3 !C$]*W{~҄yշ[%auuf]d;zλjb#x-U1>nk"0Z|n"򋲗ҏΤv)>{sl%ܢ%E,\qs e4}2<][֟5 ҄]:Oao7Oֶ7Wr\-ͷ9e}0+s)GYV۫1b*7?Si$ n&Fh*9={sYєTZ:ӏ*W-pyT6ỏĎ8JTԽ `;&  pjsY\jw6ܾB?v9 |_-0Mh|S5֚񮡵R4rHxm,KAE`ҍ[QY]}ާ+ dN+[VB}B>p\sMik7^i7F:jgP-UG +㞣pkEק|ܕFmFUGOb+J2rִV1 q]ϧIH릘a8zn}ڜT;K`uǵaNߨIGEҚZ>#O!*$YoFpygftƋm'Om!ӧu >fX+zѩy}?cT]>zt4QZWi68`I89p}i┤8|aIu<9=+c)${t>rb%tzg> xHU2Gqa}ĞϷVcQW I|?Լ{pgh1 qQsd>bT*O[Ԭӯ_M|jX[MPkT`N*n8hoy-*N_̺[܁@7}EE(}{.H;$7\Vn&*UVS(ɽZ2 ?Һ*nW6-徭>2!i)vZ&+j! xś:cПңWw#(~1~hן>yqj)fiwͳ9׃Tmk->OZJ ВW>n Yk7S]Em͍Gߒ0+`%)>Gt*TVI|-cw6"GsI_/'Z6m jHWP&;VH,kHS{W6uj2¦N<5gō'VeT/>vdiV`NRFzw}_9SՄUejwjח-+\JXJ۲6<=HԼe{ے2Wqў/hs[J|'GJ>#[[]OZS[]NCㆋoZfmQN6TC{׵K,*~K~.#jxh^mk2L<|?)^8I귱l;i]S:J˪X٫,-m$?Nzjo5{~EO*J\t\V0 E/,mP8Z:zBhЯ^6nk1ns܌ݳy\}VǬThR$_zNldHdX"c=A2yFQt^sFe~im)_Mk{UXh7,x`{% ULOMiwi ❒i.>蚁-Cip3%{=חd#i'kWMi4cO xqjSqxʵ)IKM,{F`#8m"^:R_温TmJt=#K4=Θ$?N@?Oִlbδ{>{mpowvb6E ;WJTk_f;J0nv_C'D Bkth~IT}1[*٥뮷RX&jJ|;}Xڀ3zg?GGTO> a\h^e$mp ӶX1k`z8R*xZ;mhzU0\7C| (AjmU{e\ $qϽ|6Jw_yy9[]{߃ug|6_q38?fo^^[ ܬaF!#$q\NauQۢeJOJm,/{O{$j3ϔR 1?'NNI6⹱ܔecR]FKHd3xЩʡ k{z: 麇h~Y摝xº'9s$p+2TOW}0MGhnMi4WHdmHs^U%rk07O^csm$GQF>#w(_iv>+VzhyY5mZ[m@Iq}2I)eªFly=$Ziuf6j%RtMyoUxOHIY;vIne- mI:7g./ףϦ?U6`c qzW鿡^Qy[{omi*x3 'i3<ڊp^U5y^?}F4P|?$c81RkORu)ҔjF˱{"ӵ+ɏTY. {SV#tޛ;|L\ѦM-uީP` ::9㷮+ǝkK{."4yT{tq>Kjc ;k2\HA}gTV*><֋x|H(mF0kc dy<>:n5MuO{<+w}W _E ?V ^$s׏*΍ENZNbq 9n2{k}SW9Kƶ{)#u k]JM}CݚVgJQ_s\$.s9R3:^%$ԗSҾW.2YVI<{'$gs<8({ykmϯ`i^ڵ煴 ד>Uٳ%Ymlv%ɕ c%f9iJ\[ӌ{k`uu1E;9 wӛ&iU4v B6u w>Щx?^^;+N--N-J5X䅁@0r85馒8Jr~dZƀ!jF0|$<2 7a:A}s5%땝1r?hϕYcx/PDq$Sp0F}=84*Gխ5RdίNJe*#;'ٿz‘J1 ۵x_U/z{ge̩ijkhntE7kx\3ny NJ:g;'R۷CӬ{fVw~Wʍ~Z՟"$ﭼ ıpʎY7a6e(\\k]'[m!#ǃ9=8ѩ\\e\? 2m;VS89>r+ѧWbZEpYX\:O*}GLqQJk~d0kNZ݇Fv ؾH `cָV1tѥJ?_ȱq;?zElx錞JSDummuEoj1rȭgιTqN-6)-YEQ[A %Rq=z`?i{= kss]ٌ-#rϞ235Je)hvR5zato/X9|Emi;4YFVndae8mn-ٔ,{w(, G_Y5%oԚ4i?2$5U~ u']q!QOKj(ԄrEI6v )8u/^N\,*8)]bKr[B AlWEU=BXYB*3wB,"l9>Zi!T1>{qDeR2vfqWr[;_mYf 䝭CEu{G+rNԨ7/R'ssלMt{Ztw0_Z/۸dxg02 B!ϡh oSw+]")XGvS e1\{ITwG4w.Z;ch1zcҶ%yk^ƥJo[VIT#mݖ㏧=3Ҋg8q R9J Gzt;y~}ikf6R@G`+ƷŮXN7kNc"Ʋ\:c ,ݪ凥VFhد4f_('q^A5Ծ-ta%&6]wqE *3>N5)J5,ֽrNt+7{8z(^O,ܵF<;a:sp%_(^:JU?x3F%M͍N{\{Ww(E!эZ{t*| J#(ӝ晅)R=ɧ6#W@Ag::zA)Gjr\z؅٫ܖDHY׏Z(KEh:ѧD̺ާ;FAO}4VffY qwϯr_Iԩ9)BϹptb3c<`sҹ'4x7߱xbCyeI_'$`ѧ֌Id_C[{}Q4ՍH_Uszԩ"9E|]scRISovPnI0PGNss]TcA3*_#f9Vm01B]Y.5]"[ $90TZ[$E u\elg O[X_VoNB#e]"2򭬞⌥nTb2;D{v{?ݻn.YJZXذźYُ֢eI''Ycǟj٥͠)ԍS: ^[uya69SG~M[2nto$@ҭ<)j3/_rrJ4ԧww|\{Wu4h[i)Zr] Ze?ǹv9鑞3+w1N/}QZHQ&# '˹?Jyv)CƔ٩iQoWG.^5 EHeĤp#%UluZ{ sY$dޝ߿g\y5~q^iՒ-ֳVІ}:[>[ڿ-SPҔHxLaI¸#wW;RQ\,Dau'v.ivx投)!LJ+(Ӓ{u03Ʊ8ӟ;5kV(Cw4w]~\QHk_dɿ.]x<ȐB?FbONy ?gɜ2h- ܋i<̖*ރkIt=,$QZLlv|w۶y<gFU_N Kh>kXI 8?x7wT~gVfʴ\_wfcv=b@u6UN0)F榭iS{:**~kM?18{t}᧓? s,~G `H=z昨:v\y__&.&RMo_[~Z{|=0|-y0CkpUBFhQʪaƳٔkV^Mu3~"4YKII(;DhI }~BN7*J9υ-m8IH8@rN_uՔ$_o=L r)T_(HK8g88 @ %f֪ǭ+TR뢵o]|<9? ՚V.#Q.<3toF{}Z8R{;w;O |86[|j;Ԫʤr1 U]tEGG G=#Q![ḓ;Urz:w=YN..ҷeooĴssBg8[[Tns3)TߥNÚUZ.k 3*f @c7$~lmZu5qJ׽ Y}6C%ӥj#ݻִQNJ9*).<%W,u6f/!WqFѷ-}GenUx.k=Gؾoc.NyܑWOQpžu[|7׬4"1o$?U9VVmX1P5R+#R>NvΫsX:rW!N/XYH}w37^-5)lvѝ8GwuH-R}+|\uU)KZ] YEhe 0V+ƕJm6.qV)E>d~ֻ0*mR37eƜz5ҷ')=Hڌ`i$iܪ67j1EMѨQkwL6*@s֊U1:8ܿS֗J$>Nϵҧ?3wSIzYC$_iETe;J38{>YjUf'ݘ:,hiiL[6:Ϛ0HXNIz74㸒(s@u#Q4z#TNU.߼kmA~Us:u_ƺ0yj=22]]PmC\[{aNuKF۵SO O88K>g5<,㺺U[8a0pv3``B+2֭E{k#rV+y;#o㟋i]s+ 9l:t)֭iQѣ9B}_|D+[mvo1ٷ,ѻKm.w=g+oO=.kϽIO񖖶̞c4o{qЊqb-"KJ)d.5kZa6|ƉC+HI*H'$d@I嗺7?cS&[zQ)/+1dke*\%t毭{9='N.^8:R*mJe9Vks#h'6TJ2IJ._Gi- 28Tmm?\HI&ݹUMtTv&pxզ#T悷z4,[q5 afu 1`ebcgT[Gw}-O'Sl>#Rqu1|i*Zh'o*w X;q_(jֻwKurvfy9=c_|#e&H.cH 3u =4⪨]wi0ɪ޽|kw>!x{O4|Y?xx^X; pXѨZ[-,p_ ׷u)үtc Cr CjSm/2lm_mͪk[G~0~#h_a`nc",Adg[ ӽ>RX96瞂h[9kvzݯ_enջgqDzŲX_>hmݝw2ڙ\ejտ6E4iɬxo^8&S=z#Aכ:u/˧c§Ns*CX!ۧ^37\zzz8BRq1D7Y好EonLT>a.Ky&cC/tb{lyW2e~r~zXzN=W}vKKuG~ZFMnV` '#ߌ{ZjTMXUI{JߍݣBc/V3|x=y s_={eZ~ _qKVxׇg6nw,1muRݎGC\Cr]OaUiJT>S rӧ;O/bp{O~N}gVW]_/ZR_{^[&]&2mYCosӽaF\-f_#،E59=~-ATZvc$f%&ǹc=БIBwy)tW94㾖9ncE<'>囹%ڷ/IͦiZM$2GPAqG_ly7<`v#޽jxVߒ=9a|xvk+}zuԈѤX:[J9FOAIïjž+ZbsQ 9gAԳM|pt&e(Q#$=% C-O{,)K{WӯHѼHdѻO} s>ʤv]ac朶nq(|]h|[rls*TKug^L:K 鴭oĶS۔oѪ@}߂FzE%]&5{9Q֭/n&ܒy`I9y߇e ;u;?eoi{~6=lWQ`t.#N;<"4ithwl}15u70}:[aiIiQ~ӡhڇJ*ɹb<kM%â:X5foIXQ#wF>:+kv{ Oƹ%)_e-u|Ϸx'2ImuVLnǦ}qb5ӷ٫Om9f9%Ҧt5R.ь*kOwF9wlyǵfQēk f?,} ln=}J4y{\Ѧx,&:m8>k)agQ5&"f&ϗ~h$hYd߷sn=TOm F|Mx<+9\VG;'M+yшD3aWn< AZr.eS7ЭztF~R #mNI[44]jW4Wc veIFmYHEg`": ?8r0kZkD)kdi]Ysb98=W/9^eHǝob$f;qA9K^u)]1$bz`'mRVr4hnv>PFq$⯗ٵ-Ȍ$ۅDϙ+7}+7nFrCڮ vA0ON;6uIr/yao0>UU;N'EmNH.i){K'NLk"q -YAT$$ v/﴿s8U"~ff,ZM5XI^5# 5U߷cGF%U7B VGj!R O=ˎOUƕNG5]J,i24{;x +R T/'+3[Ës# #21Yv8:q_t[יy.<0Uw_1}6╭O\\DL*e U8k(JcbjTmW2gV)!s EsV*cIV<73JOZJRPδ%%bhǧ+DG(>rC5ujKWWxk4 M2{"\F8VsL=J|omRFA; ?¶nƕ/6 XX [ӢeN-Y(]!'oNFpx59蝑Td&yNrlt=Nۮr9JWwrtЮ+ֱ =9FH)$? qϽiNMͽ8I]l!I7*FU>$9I7Xet)O#=9?(e̥zڸ]r?35^[RVH*$*04W8==)"~Bf;v3+=޺39OFVe <~N~jU9^LuiMrtek36L@ݜ )JRyc%Nt#+DUp1AԷDS㦞h4\dVbs_3 H=}ɩUylj*2O~k mq1ˮ=ԁA$Zx˖SFJ[!IhmKR8 r:a*N.wi?OҝNK~gշlFeycxӜZƷ5wo[ fQT5w tIEt$.YJ~Vq]\4R}Lqn.NU/}gu!LEuoWh?(]Au%Z^Vխ3Jկ^y Zie.ܣG\s+aZ Ϣzjdoz$U]b)TolS%{->RJk=b!Rv6vyl e;3SZpw}AT(EԐ"Jnn>a3ҶKnJ/Nh0]]Ey]>gʼp$2nm,y-w1g%+=#S0ee߯K qG$Wۿz>ң9y# XF:tkj<>e,O, a!f>7ddߎƝrr:15ȍ P7>R}d6;6G{O "]GwRFi$m}1ּKS^'/[0[ s.A6^8凵E}^m^:F5){IJB̊U8#&|MWV:+%N*k^l`u8֦cNG\YBv#<ؚsk+.ګ^[3/?+mP߿57a%8:~#IfC ˵cQeξeb+TT{SyʪV3km~JNUf>zѣCRAj4iI wR+ة{Ow.\40/'ɒ_PL=<}'_&o!FfOLۙjRzo>vڰ"yh]L{[eŠ#kW9aeKs~D.nW|rx4mkNj蕙a FG;][`tQj74HdFV( FC=$rVWdIsbIH[OA,urc |8g?qO|iOPJN_}ެƦ!8;/HٸLbe?\NܷNV-nMœLyqֱ.U#*qDk'p~p<%`cx^dWL͍ʊ'ϧjR22+JCw,c Kc$R8Ɣ`tBqZՏEUyI&_^,i|+S9 v Am'Dc\+E.^1;%;Y+in?-Oh.=ا*Qg(ꊳ!rI72O dؙԩZ1ӹNI'_KwcMUdڳD{9F~-jh cpQ۵`v;JU-(,`:*~Q!sG_Цn rG{tiҭjrv1SZbm=Fwphٜ1jeqj[c:8ך3sԔZۿO- vv+@V0\u#RkG,GmH_CIX0m%^(+o5,1]Lee\2?pb(ԩ+-/mW Ӹ7 {VPޢk9a^4gw}_b7Z\FڙC1`EH.T{=Ne}wkF\c)'h6&|+e仉sڙ6fFCsq\Sug7;nAg 4q WvNI鑟\VҩQEsje%9GTZo0Ώn<ścaN^xWNjNaMfiއuRa V7XQϽDdNBd쬉s>avRpՏ-_afVN0?<ϾzѴZ{e{~Vܜj]Ep'̎껲aruʢ&,BU.2ݯc(` ڲ'rjMGP7fGr}ZSmz5}M[#}S󃻒9F)Y2ϜtHgiMGrrZlwqUHm.ZǝZ$ K$(lmS^OX$q@^.j399H}S:eL~K̄G纮Þ::gVF#%e*wce x0#Vy"opxX26T!IOD^kqQM; oqvn/t*ҭ=JWŜA,![_3=?־R]C0JjZ]i/ms j8a孚/ivB멗(*o>VuLq^"nggm7&˴bqo TgmuFS}BϲIp`W# ³M t$ ikC4!O9[t=档Tѣ+ݒ6m##xb:Tȩ'%Qjյ*xw#W˥6Xʿ1kh¨PéG;7T0l/'wn2iFUC G& # `ߎO{6<1NVMny.q&jiPV}C`F铜W;I7oO1Z[ߢ l:^ oadgצ;7^+*(52øgxCѴ\Ga +7A-ca_VR\ױFiPCSJMܳhbOۼΝI lncMj([Kh6& Z5m˘2zpszVu~}N:Ԓtowe`]pb}"9$ida3|љ[ӞZ㧆5^5M,HV }3zB7V# '+IfxJ $ H~cWe8V:(*aʟˋ$[}H4̹~b t_e'YǪZ%zҩBI5kӇ[k[#X['[O_zQMyԇ\VuqS6쟕1ibtOI-|o-p5{*ҜMs-*q#a" Vx7sK Q+.R9mSc>Nv>LjSRN%Z1,o59[AwGpO*Gz*vaQOcѼE[A!Dŏ=AOጩѩ.nklWJ>oǰ1$Uzt1-|s籉Nvۦ}i,5{g#G083yyNXoe8Fu6Rw׽[dv;Mj:]_ZIosiwU9oo%_|;ŎhpOsלQ|3:r{?WisAZY]BEC K{!U&H-ߧP0x<,g-ˢv9I>[=4];SmJuof* '}Hң(K_S?S?E-~=^_2:1I6f/ u8}u\fXoe){c5.gsf^j[^mk3YF1?ͱ|[w:i80>GYn|:]߮$ 3m$=+ɣ"XmߩkZWy5]RdVX¼6F;{ڣ^Q{UNrOݾ^|jGqd%;E۹,z###Td<Ag;[E{{-D2>g##3]qӭFUJvzXuqnpkq*OٕRY״b^}ZAsRMmIAf׷x׋*3W'Vͫ{.V xH-I>y'yzv1ԢSfq-U~ctg H*~QۥeOmhJ 55vt<׊ukie`!a&ea/21bJ/FjXcoގ˺cb?w?{{kRKq4*VVI܌qRF<|F!s}ku,| =V+&[vWGu_½xʢ>JNPF-PH&VW&@cUHG4cM+꿯k^lge%Yrz9{:~G//h| s¾6FY[Uc,$^$/A1}oƔ6ҵGGm7z ӣIh=\=:kU2ܮWNj׹|aOhXYA'o9 O”yNܺ^3.IppRec 4{ [K5C1z^xDSu<|Jdtwmk4e[ɺ/U F?ZRi]v}Y ȶ۷i>Xcw㞝=ߟS"*T%֣tOhO#@ m䞝; -wkiBobUnV]3Ҥ[np%5iƧ4}fe($B-[N;_iYcJR8=Y{Ogu'^"H7N2|J7msr:g=s\oqQ8ۙ^u1.O.b2y0zNr?}+*^ѵ-~QL* ,I !|;y8b 9,~}3m QsI66-l*ȰB=1$c{zWO6XIN:^SxiG"HύnGSWߴtBp2nxtNj_jkr}/_ȡ2I.`W0Gs52TTcᱹf"6|2U[}}?_6'FrSb0ċh_h ̪/>积+HfT/fT^Z5EM>ʭ6e(6Ojʕcͳ0[^ _hZ+<űUp_c1ܩfIE* 'w=Z2u%5<, ˁhRܖu]Jʷ$iR R"y'Y;UO~N|ܞHqQʵ5'#I+FwK F=RO.yw0IsϠ걖 涏gfߌm5gly~hỨyX*>F;W敦Z#SE҃ʊpma%yr3wv~ivȐ˅l'$qڰrz򏱭SF+ $j" Em/Klt/Y1;O>z#>FG+4y_oz7&˞8_˺3ǑSVT:Sє_4x@wZfV /eH{qѫ]?[0r-_T׾_w> _^ڭޗ=`;) `)+IדeXjMKkf^IÙI5um?=N]MCIkEXX\dg.JR}}GP?޽MA?[rFI s1Z+}^qܩьanWo#1-H,vۆstRTyp>ɯ;E!2*8Y˚7M>6p<ԌSӿFL34k nUX98⺩JՌj8￐V ]bU;顽I:NM]YV0zz֒pJndN쨢5f=+J~S|꺮+S"9<DUO$sFP(yZ][Žʵٛ=ju*{=ӈ[(I+w73G?VDUBÀg`988Z5#52*GG3"X2o-YR5F[p>߇uΧ- t*N;r8X%ϒqϽcRu.%TG+&#ukÒd g׽vKH.TmJomKR?y+**3UK7F6o]l6#\y@2xxݺOrnoc96Iw 3sJn[Ѵ]V" ]DAlH6U˕Ng^+}[n[-5 E:хK܏GmnϙZJMt{_zu%or9]D-|4S#.UtߚWV=WQVg #mی SJ֕;Ԁ]EKĞާ5j-:Da𶼊7uαmd,xqnM?˿wR/`Zݽ7lѻ+YӓoE{MBUYvch9rWGz#$kVbռ.qywHLq.>R{}O~+WqZnrabWt]J24pDѴ3=pqڶ=?c)Tj+n;YE7ʿ;]cFT}i׻3N FO)Ɲ8v#r\pdhʺ,rv}}J̪aޝ}9rGY= R_.H0H*pNq:wfO%+t'ެyۨYnn~})vI'W^kXc\3K_3G r;2teάZUu{(i3ݒmsMR0Wm攭/+ɦ5 #(浌c*;_ml{I=;RR%xEu&iNdz%v]4o#Τ*',d1Y}k4uON1niXXϛǸNR{b#F4.[n$P~/?/Jߚ9Y>X-G2ۊN:QEm$; qB+*ׯCQzڪJcD v犮^z~0'&mh|%^"b99ԅFU0(o3iܱ1\9/5%Rz3јM$'޸)_]V&URJަ֋M`|soz֩Q[kjCҒUeO+{rp:s8~QrMӌTuzr}??_¸*RdS7PPK+6pcUS^J%'T]NLXd_6^ *2ț|A=? r5wNZ]vMưYTQc*ҩdlˆ+W71;N{bF۟"IE}7Y֎9 a8T'зY_|ۊp>TtԖd*HY#}1{֑Ų9t"[Ü9JRvDF\?;)Tȧcu{U_6]/_&@F9V6|~*%mXk T\0X'=2YK:ʥ5tdr;p2*{NM-gK^Tf &WMLǚ}Sf'P$P2z*T :?&vad}zԎl Wp;,sǖߦ+zt TR{4eċrTzuөQ8J;&[y7C1x*15*וW&R̫mQ:ҌU:)dwHƫm bLhwE2f[w T%jlfUmGַy\ߢ]w 5AX~UIK1$nߝz|ةӧ>0һ$󃌚ߖ푘ԣ*A/i `7_z\[1.ihQpuz稕[*TSWrR d;xǷ48”%?nߺ[v/ۻ;iJu~b_9aznSOkW /uI[WOd,o[Aqdyz26.g9Qds,<1t׽y]ju+QQ浒ۭ_ӇВ ?tmv{i,CāgȯNmeLr*Yj?O׌|@ӭtZ%vE2ϝH\=3(ң)'kjZ/:5wuS-vF˶E#N7t=p9>i KAݫ7OE~S.[^.ROX.XLy΢Y@c11yycqF?ѧgvmu_>_VZRA>Y):?:M^c;nwv hmoQkǛ[\)'vJaW犜N:5ڶS2O 'w7kKkc$7R+F1+FNz8TҌ{#<Z^kLxw]Q%ܬ7n^ '+͝i}O+v5c^tp1:);):~TfoױΝE뻲0t审II?Zδ"*}_GR$161tȯ*4{0BVVeL,Z§5i&gۧ.iJ+4&X-3|qEQrUڙ3Z `cXFZf_֋譼-aӌ+{E;%tuйbS-疠cӞkP(I]KWͯ#.An5cJut}iʶWϨI,r#ǭiFOz;$5M)ʸHOݐ6{g חYK.1Nϛ@Bve5ﲡ x*RdR3\XRˌq۳=Y+n*j$ܟC^tyǚ?6PEb2rr6cN٧5~6K[kEg?/q]Q+oJm;`1AfNNOC0bC4C[7&c{FD @~7N_#֔%NJݙao)%@s^Fe/r߯1)]jg[] Oz%4Ks a;'e DE'n+⽜ydtӏfGsi--*t#$Tiw;&QWNp+5ΩQtj[Go6Ix_^J>iZ7ymF(uz*ѧ+Ek$%љ5H67C]z--ʯRo4ΏWV c +ud2>s%\Oӵt{R\)8Ϯ{[+d~~Fũ;rԥԕO:M{TD%nw۶8cK5uf3LJ%729qiwc#ii%ޝԗ;V._# Y-~} B ]6żRiByx$pغWt:2׾պ־Y:STbA%ƪmݹ~PvT\#mZM\Nm*toi=}ywaͼ!*䨒r[9#ǜg5U*b${txƏ־;wp~$֮m|Aun!9 qܚ,^_J#FWW=,hԔVw2+qkC̲0<#Fm+xQ8o^ǐ|ao5ƱI 岊€O$Au%o>u.zn%wD-^MرUd`` 8u8+:zRcFu;M>;~Nd;V4y!rOQӠ8S.KONNlTWZ2exD՞k,7K(NFHێbkG5w:rV"gko[ߵyD>ŃPGB9-Fi+u^fk,5IR)Gu':23 frmx<~UR&Ϫz`R2pk뮾O^VhH[us :c(_y)ʚj]m6AU=9 ccg=Wr2:g4aSyJ65)cMl}6)? _kq2HGe`T c:WDYgvM|O0DGZSiI-HͱVO8ϵ{v2ѕ8֔hmw9bHNmJV>, [_THcFh́?0kF-6oVQJ\ڽ/{YDu 1E?ݍER@Mz^ʨS{uz_>>҂}쮻 |4na ĖIi4ZXفH8 c#=Ԕi.7GLV.C~|:Ԭt+[ݭ' HX&vFߔg)bcO(s++Z;+Fg);V7vׯκ6w6m"d2M7W2[8ǯO0N2wdfapr~[_V:_@`R᷃Ԍs;UUrF9CMDžtwW\\lXqe|vǙs^[8ei^V]:i֜VkhmuxRɩCTnq]0A g*%Enio.u<*\oK]%޻ׂt]ܐ2A2>x>77*Y^:k/Ro.-yV#1V89*A^8#zF#gw}9Fm 4EKɖhYwnQ|nB8ZV~{=|P/k#ē71^*cV *iTncy`eOgĖ~"VDȹRx\/A^ ʌ=nNitJ3 ٮI J?OjعK۹B^ߟx_y 0HX+pJLD鷩#&4 4KMKkhme' {=wʛVz?3Sgji)kF#C]8鞀_KҔOQa%Ze7jw)erbSxjn_d:|9n"iiȷRN^ ~+)e/qF\蝏wZLv&+69 ^iv3MT~g{HbvЃF+G1+أRG)SJoywş_i ed  OBz09R;xMN+Ocja>ImN༺ Hޟ$6V:}rY~|iyUMgŸG[dZ!ӭ?pU8>Fc<61)Z:'_4+uѳTdie$ _~;5Q?fwEI{:ʤVgPL%/xFy=1ӊR^^,8r6ZƑ2MVu~nyadzt#::u$~&~fN1R#2ϭ{=)J)m=jTxIoPqu C]f-@ ~mO{oGSJ4҆h|;?*7rZFI;9w{aӿm?58{xGԾe Ti2# 쌐1O*F>漽V%=w:O-Kcmo&9l7|oK޲OFL;uWVHX#wNsǭtNϖ>:+%StiU~­.h؟cϫv6mB" gn}N*%yaiZt|e95/-,[߽ĦENgq52bc5WqkqV+iYL珔pu*FCq&VǿJ=6PH=ɟYh$7 0VX}=?=}k?c+viHռiCn;9jxjnNOuBK*ٮf&cwC+-m׹:u"3>*6"L8a]QqζE|7$3ە7=F9ּFRf^$ĺ}vs${d'w9>e̍yec5IqaVuT=%- biK囥[Yn:×lz-ބLn " +?0  Z4lA:Y};u 0v?w8O(I_tH X]6ְ{||5V)Wf΃IGZN~W儘8a܁\"lae ޲VAfh. y)V4JL/8+\L嚒WLֵ P;mӿqT~·Z}bkU!߹kv2p#L末F1Z4HED\`םSJLߗ.h{R7Un6WTӊMn4:M2$ĻZ=vU}hr`}#2ZZښei8A(ԁSV=oo/i*|۵)1v)>sj4Z;TPӪq#Un0۹cͽqZmvtV634/2M 匐Id_8kЌMݾFK(⼳6Y>XTgnOסhѣ 0X[KC\efPt޲I|.O_2P;;z1cmiKNP]K6A lk۽*p|ͳIrS$t4v nbG̸Q޺cN1=R~f88?[{>H&ty78l*=3MՉRѮo  Wi9=qZFcd;S8-f#e +nX({=QCS<#%t4:?q$7Sr1J$֝NR2~{Wu6e oR?SכZiToh-{jR5]v+)eHE !^WzqnLJ䱉?z 6E}R$hΒ@UqxR_2|Ik"ol+^/~iUjN_#.&Y@ظQ{oMz؊1EE57Sf޿Zʥ.K( ѧ:6} !%d/|웁o 2n{jtrJI/`iE{eX $=QJ2rRјΥTO+3K k9=u ʕN/mﳽc6p&`n~PlMbY{NJHn 7˽QS6\1^9=3]'W'}CQ7guEC5)eI^yѯ~w:Nxt|n.$y?Uڠ`Vtm^.Y&\aOjTQS)As2Uw3^ں'Z::rޛۏ6t{X.THF9W$cwѿek%CmUX}+I^59s"UdXpz%`1;VΧ>S:Z]}›xљ\ܨ$d;{8ӨR>ϱ^i?Xm00O>/qV٨ӾK,ecCЊJ0FUNXo#2.4xscQɭ9'$Sîס\Gf*6;AUe'*?fZpy2IO {WOqN㸻YH܆_v׽ JPqkڿ x moaaO$cVJ+By{wf I%X%i6𫓜gֲR2NU%gejP[]3*7ʿ\oǑG<'ϹjEs QǾ+1eoCK6@X%r83j8$iʈٕ]w0mnexҾ9#+_cGDI2ޫCᙉ8c<`zW6!Ǖw1'N^]_J%vԅ>fSXs>]Me.xО).63FFnJhlgzqiˢӶm;ȡ C{~xrDq\ݴ-AoS"oAV^v2صođ$R|xgK77VZYJfeTNbڿ9YI&ʁ u횘ǖz|txtAv,G_9Z0kBLiʠduG7rdf+Fr[9y<|Ud']K+9-?{?ХX[gK)LRh yJa3qDy5}Jjg(LRDq85V@F< {̸0[ƹV,:}c.h032-ē9<^ioB)kmP OޑKJz#W݊eq~=:RIJ0I})vvdrsϽDTG]:t7 -{u#[?"M5+hh۲rڭ\3Ʌ+篹]ѓ T&D6څ0TumudR):ZQMSQ^ 2ϰm'wGeF8b%qKV2T snj9n]P+`a霃5w-UkµHQUD'Qvlemapz'ʧ~m2\[{9s5r:1.i=lU3+4q2CR38}$ѵ:G)Z4ԡqm1Cyx.ueEy{Zj4{4{{`W'hA<⮜"8Mg%nWVh<% 1 s9崹bsƎ"8hضwM2P~\r+oehv*5KM,EQQ7e?{`t5S;FrVy V8c`68,=@1^R2&q*Mqrdks*; wQ)OXNxK'nh--.>hBTwx1]}V'g1=ٌxo*|˚*̹R^%#3=`nQlgt)G[y/l0?7*}=Jhsujı bf' dVrm ^JKKmo̅aH|{(m+Sb$ֽŷ$Qw@9ߏà^ORII.P#c$N&d=0$dH?JڤnmRXF;W*Vgd $kH_JTr^4:uz-5#8s{*Y{K4]lU:M+vCZi(ni1wsO٨w4ZR5fl6U#gJҌZlÒJK#_<Y\SKrm+'q؛ xUfhՓw 8Ur1׹5/1x2)\_ &;Oʤ$r+GNR8 -| W̽cIba 'VkhJ;y`܁;jչ.ԩQ'f7r [ʹ#;95j4֫iiYG`\F?G˸zsqMQ] PYS2og.XCQۡ~+mw1zkdUe 'o$@_q U<3Rr-*r{ELWo<-Vєcs*М+2m[nN瑓X{m:j9Y?R ++LZQԵ&fb#ڧHɓSRte(|ʿ/9L(bjv[xR@忇=B3/3̖ȍ(vœ-"D1׊2ڙ9E4E@fiRq֯JQLҜTylDjʧ 8YN `1<o5' -$rݛ}?"c>uQiE\A/+Οu2U9[U`퍫o0s u|v'~ѥ/*w< >vG3Z1LA mr:Nk*$nW3w1Tz璅96N6}2/ΙtR9=xDLE=W}~e}"i_X~+ቍQNr^վgZ\}khvz}!_:ms&;;rxܶ-mR{E;r CDe%/yPodсa "8xT_gqRնzjK dŴcokI~>Wg`vS:1psڦQ=J6Z37%F}@z^UӯDPyHr͒,cɥTn (_y 9|x߽kNgúb9Pad}G5$TiZm$Ӣ?ͷfrdppN1߷:gˈ䔔;3ВT1M${ve\u%8UZKF}yU $)^+N[?7Sܺ^%ڢERdf=}8+ůEjyUJy{YձDZ=x2fsaƛr-Մ>Z6͓+uVCaZF=W-J~MrhODSoᝣ!^1#sacREjoB-Ę[^[{hJ2Fxz4Õ&Gk^b7G[%BzgGR߹WF5U}mX`1` c8z[_D'WIi?ZGV0vWjH`#8c/}^<:}.-'TMgHїj!)Qa7QYt|FC. l24B8_*8Fwv0|0UuZYyi|oaZHıȫq9 2nq|i?y{o=|[;*Nq#Mk5zXxLDbwjwBJF'h$ 94*ec$!GO餬ݺo  4]KPxogi"2U[#^y">4qSsYNB?][j!H|TzҧNTM鶇Z9AsAghQNL_,ݦ[>Ӽ'jxeGN ;FNM|o֥uF[?6M@ yt9V7 g'Y¬Q=|-nyO^rY/11g<0+));D{xsm| e-{FcWj `1(ss)[ϩ|cZSW'4$g͆9 ,N~*#iƶ]?_/ M'i tx\Y*oʺ2mɲHc e@2A*o/LWrvl˧om+׾+i'{Q8Vg^vPw3FAO_8Q2eG.r~W[ɥזq i$LOl3]zI= T+a,QH+ ĂAӎk =7pߡx[W+xmMu O5SRpqb(GY;[~'pi^U$C^v+/.+BUywZ+u NGp;W(Hq^ΝKE|+3L}Sm~eE8^1`#jqgu?0Uķu>ڟ:k'M͒, " .+ь燊滞/ pmDE3hWdКg-%~u8iʦ[kguեwPn >S`7Ǟ _gORW]D.2s[Ie+ݸluYv^vtԫk+/C1[ikm[2@=1EoGR.Q[E`s=Jq"}sO.w1Xs}났 VǹFV1~f`͟1Rowe'xgTu= ڕEs,o&.x' =}Ei ^'QRRQӱxUKZIl(ݓv{g3*ѭ%wvޥ`ԍ9&֏^mZ;6e]f\ep0r9ҼQ*mOa^Rc1|AiZ5V82 '#ؑ< gc5(q5=^ox _X\G6$cq6"83azc1~0[I$_SʭvJ|0SD$r[dG:.$_A{irqQN^+߯E[MXHƋ 篸 ~/'WarV~G^.U7jf &yL dWPTZ+>X]Y.CKYZDc9n ׃dfjU'-GI||}x_Qho1 Ø}#9a]Bruz_2j]tku:e5ԋ(1ٲl!haՔcӷLlI+O]_^+Jڏk=wHo @UA@?t-unM'O0+m~ixaKɐ[F]K8vn;^eztKE{}cyw4M:,1 CXEϯ\:pErTEɴ'\=>Z-_WȆKK./TGF0X8+zV:$'o"K]]lu8Zem޲ ?^ySJ2֢[w6ƶ4l^|U,nnKHv-z`׵{sr("R]/٭4̡n+bP-Q5w{<;mcab)8!b1~٪R,]h=[yu5s=^B|`,\[44.Y[o~8ָe(NRZ.h殿?2+;˔7ǃ)R%t\e|虧e 6[fo,tvG==swvΜk˖kmϩ(!#ܻYղO'ys+K l4K<%waUrç@cYKE$g>jq䎇V믯CDpmek zy|Ԫ/hz )FsN<~spVVeweT]mq[w+ЭʜAN;m}z?TEU޻~\Ұ`%_-.ў6czR4 S3L[pѹ$9ƞ2I}Я5 V6ozVLoH+[wc',ķNӣ>j)C_Ț޾g}cR@I"$X6$r3ǟL9r['< HWhK$ FFyx=9ԩ$d&iNgM/KI6mE99ǿnr'/K -E3Z}+x]v+88Q0tw]3wK$ x"Y9+m3(`?6?.+*xz.6U(Vk8}K o"`zcӁ[K%}J)*[]-moؐ^;-GoC̯OK%KM\u܄TwWg&Nq bWd֞^zj m9 4|/͒~ǥ~+q8:ҌSmdxid5yhߨ0TT^noظ)u-Igq2°P1fy>iozgFթE6VX~ mi'3WVZ垏Ni*i {#sB?re| Nk( XM&oޫ*6`Joum3j}2K{$f[$FbDHpXd$O»e5({5k w3TyI)a\m9QuyalK">mip;`~UN9Z/DCgY藝Kh/;>pvӯ>s?gk#'%k%y>آFtmP6}09}sE7:I=:2RN輟 {d!@W@#?z4ϧSbŻ &-y$ 0TV=);d(%Ohjx]:ӌW[T.f}[?H%R{ qO=kh֕Isi4J[j;)l*qb[-;NS#qYw9s8nc^ʛM&0[O #6O.Mx$AtkiT4U5URT_2&#Z)h#8p,5|ϚB^^W\ݬm* zqדUG1m;TrG}"Wuٶgv;Nx-tꬩƚm:JQ ҹiFQzJ%oЧ:h~) ޼1ԩJP~Ч!ڠڹ*FzN7ZFN4m vn!8ӿW߱CW'6zovϯ<{wNJҁsӡGrZW%6(C oEUME.tajGߍٔmdhb5hQM-Q:4 =)|fvrN?[۰ \`::[w]^u;%Is=X-:>Z4CĹ-{inӔyrVdE(ǀSa.H¤εe V]7Lk5% .mQe'+OT-Ow*FET}I# lt ּ<:Xsru6yY`xϯ5*%?I.]gWgkic$k0J7Q҄Tk/IknqA!# `S')F+jnK/Kz^ ť+s+ңM;oX[6;nTa.NT=*C~pve sr/VQKM7)_]զ(2onz&SE{Om|nHm ׳g<~u:t㥯%aRu2M΍,2e_h8+4鴖[X㷛qeQQӵiJ*U8(IyxH|'G[B.m4aZȫ,w@M,߾G Q`'tUR=IofuFPE~f=%_Lc~I~^y;涍ʗ*߹R3h,n"]>aJq^9-ֿtY[* mnX{NhFSme64HX AzGm6#Xөe-V&VCLc^xwRMWT'⶟wO &VI eO8x^P[j;f$7 F9_]q_Yӥw]zmsBT(оbJ)#xcm8;sGҞF)t=UW xPmw+d c_#rdP%k+]v}WG^eAmm]25u-B9Dv7y#pSG VNaɶOK4W(}5E]:_vj𞞶|JI$!#=ϗaj<Ļݧki}G,;pznwk[[sYإAktWwe1=|XgFTrM|Gj)T}]3Mdk1{K0$@83Gԗ.iQtMzkkvumfɹ7w#8<8=xU=`|7~JX%(:xh!S̞k6{\V/=/gN7nҾSʾ(xS]=5['\9k 聯9yTbxٶVK^Ǔxyo %7v:ZܴKvJޏu]&\Feef $שʛ5Fsҳ٧L{W6"̰8DQno=eS7o?CKX|FUQ8c;wƔ*wWzt;>ނڨvWr8D],kJhѼ3boKVPܖFd8=xf#9BRt594%7OKw0[jyP;6.Am8ǸRXmNWZRJrI7nƕυ-GɍVIU~NH?{Z4yg}O$y(;wKE VAaFFz%&MVg]9KޚWZ\z]΢e^mK s3ӚGEm|2)+\O3Z&i SyҺ}RVIk<5J8X΋fo=L{W5;B@*9]Aϡm$ʷ>W*+Ε%v_N KK|Q.:JDaJb89;kC+ԅEeBwAҸ(я,6zWW*'ɴ{k|vh WwNUݞn*{i}yc}9U:2N.KٯƤ(<^jƷgf cl"rRO4/n,LBǷkMoR9KzwОX7>Yݷ!AQS$$ZnLmEݭr5ejV.ɯ[ HlWZF:3HwqjFTX2zQT\ui.dW7 Fq1PSjzcQ~'~*W~_7 xet}[O$rIRuR>zrRvw> )bc)Zw9-/cr+}+Zb8秫חԵvWjynV7g AtSVB1]^&Rvlmi~yJOya|_к޴'rIv`rc=vŽ7oK~}:т1ڭlq֦&jQK{'g|O㫋佞HJ" O|]vc+rьylw:(6J{7\Nӧ 6ۏ1yu(wM)zZ3: ")9q!Fc'<֔ӕvnv[Tqqӣc"9UN2+XQU%=|eYۼ(hReʳ(?9UƒȪƷ5<df*F =OLb=T>yG/g/iԛI=n5:ıͰ}T(/wUo2pt(i>m*t[닛h;͘\mEa?-gU;wzշFzs<6K RF]be}zZi2"_ d ž~JouO#QR|ZoZ|Vi!+ &` d񟗩#R1o^z)F?=okU^ bF\ҡ< ?O(ѩMEm~Enx9_.E(FIjՏ|q_y}su" x`?~FvI-}WiTEu??;]UK"C`rǀ6{c#{$IòᵼԼuj+k oAs1FqQНE -~K>x~ho;Ko̍ZH:qhB`pW8w-{VZl_[;U5#ح 39u2##=piJ Y,TrN3W53.kڒ Cg{t5nɹZ+O&4+p]Mjۛf,[ڼ\tis+NXn=_--=7pR`B͵3J6hS~tmmNUiVKvXnBc9>y: U$3_]>q2pH)?Ѝ~-NZϔ?j:H-laHQ&,e@q;ΝXP~uѧOwz-4kw}Uh9ũz+:`ub=OE]NJ/Wi5k=mKY ,H;*v9xm Kth7vγrxEՕt67.UJ5}cjyQ|kxV#nfVt,V_Bꤏ-Z8ib*C=]7Υk'7Wm¾Vٕ0It;pޛW  +jSmu-Vr-$wJCJO:S+;v=fyKZ߳߇?}&sq{8?wL'͈mG(CCs4f12Y\3UiuF/<u#)udI| w#$13yYkl\¨ҥӏ5iMބ2] g?z`5j7}My(|e{qݪ-bc{'`s"#aϩ8ǒszU'R[ iM%gJt~^3*U\Y8r.HRNW7Yr{虙GzrILIYrN'<`OFZ4ZwsmpKoZ2QjK3eUʐ#*pQ"<,yyLٙʬ6/z ɯ/{ޤ:چyȁ9A޼t皊d^::췾j:ZGV|lx4w$3>nm*so1:my3,Wy>o2 Wo^/|Q[F)}'~L;6&@yH u9qK]7<~=,fI.ݴnrBqEqTj_Yytqvc[q'>_ʧw˴rsֳ[_ӡe7o"rojr۱jS8駩ueỲ6ᏛP\k}_}CHibxh܃38NrOn+)-oaNte1o6QƱխs h}grWRb0(7ӣV,`*gݸd"r&Dh[FF+s1aZ(BtܚMhÖ_xQڲ&҄ܝгH&" sJ.=NV}֦'JnWyRWG>)лbFz$z{թӌTteyꖚmiϻknVq>[59E+Zo.۸c x?!NZ^}nOn&ܶ I&>˥DJtKE׿(dR[V*)Jn=:VIl&&Vxƨef3ߵtƥU]JN^YjI Ȭ;%6)>ʶNv+rR6ߥwQ卢'斑i"L抔c*G*u|m&$k v%_#eWs8B5#N,ɌN~lκ,LrUJdi֍:v]W%0-'ݔyb!e9QDV7lus:^,q8˙=`3_,EG9jޝ+tJN0pk+gd$??ZpW3>ri7YB!M4x9zckzCٜW#%hεfGObSfmc:ъOSxSMAi}HƢeq^%CZFjS咲7U_#oa\QM!:i(ni7|ѶՑ~iR2N_ *E: ,W?kqXx㊘J>Eզۥn?3ӧ#;YܼVjȦJBEfG /,qSz览e8.1&8̘ٙ^9$ҹj˖M9=.z uIS1\yք_:M3HU.4T* Ae놷mDJmi\:[nN{֔F}>yyDrΪ HW-jciZQKixcϦ>[JLJTenVin}ڝ>b}9W()Ӕbzw.IJyeYBms>øQ.X.Jѡ4]& ʫ"nr?1\UZv1Np6VlihqžU9ֹ_Z~'-*ΜwCJ *%6,{ l}Z3;*'Zv-b d+aE?g*iU!"EUػvOVq}΄$cܒgVG'X[О1iFm̛_"8 H47ەىZ.nkFRU9lTiKkAQ9>&>Jja^7&GB3F`Cz~5.)ݫz\Y$3B8ڟH<Ԋ[ہP'nr89?ʈRثFuE}QL%3ܨ\eθƪw}GZYIR;)qsק52'g _ɖYCE;e۷;[A5HsGc p, ia v?g:u%tWν j(U^q՝_g&u9H-u)]IJ<vKC:{ԡs|@>TvdW, ;]Zb4e%+orCۏvqR[0,+;99kks!VL)Y $KWEԧⓚ:MJi߼q3q<4=sNǻYUc$V_/?.3ZsBTikTJRV.Ex W~7,gʂN@#<U eA)]i&VQIhki%7JVصӋxX̆=c}m/deZNѺ~E fqq&l<37 ǥcJG{%5#BіgH1&c#[iyֲglo^ܴw*,ʻ;@~><]Nxuj/<o}oGՐ5А3eP#;rx;xJ8zYk"0;z>S3$VёYTH7`e(Ȫr7]K-+3eR%yFk(Vh6β+Ca0e)6\_.a4ҟ `zVN:Z)rݗ-ls6~nTn8=r;~ue(biRgnqsE|%8rp2} f$UhQV2aYHU^ǜq#{8ky"4_.ѝ8}zFP2I+7 i0О}U%SJrrHg#elv˕+_i&ۉxXbeYwqՉ9==75':Q?jجfuVpX^)ruAFJЄHZf.ͪuOhݝ}+o'f{Oyɧ҂VgX7J$N5$V@+lp@d^|u5W^tGlo۟ƴRk.Zx*c0g'1֦RYFN K]z8l#)Km=JcH!f;prCvLT{?y_yHʤ.; e2 &N\>Zj˚.ExՑTa6$r8ވ58*M5X`jq𷩥5*1Rȅdiaio-5W.ds߅[zUUYS 6C֒4Z4&i"͝N{ci(ѣ;Sw/s`nX#x=gG4ei.byU9rMMAu-H^ DknZM˻o!A8=5H:ԍI;SbmDiQ1de2+$xEjuZi-*jNKIs=̲fBX}(]56(TZܕeG#q=}4SQgs+s_v3^יTR58f"ZVulN_X8;=I<ˉfm7`ZJ{-<,iVw~d0ܴa-]VЧОXJ wpd~#PT0TPYi%p| ƍ8|!)!YO0R1ю =^N/hبӭ51&l7 s>J7NTey Dev~틅:rjQzDwJeoU)V0vgFkhv iͧ]Wd:)[Yl z!穷5JtN%cb 4B?vU\w#-ׯj^]͇%^NqVnYp •^>ݔlΊT%Ghy>ʥ;iҒk6)^v6xJЦYC8TԋҲ})(Y$s8cln?5ŪC|򴯧hw9h懮xDcn5^J0H PTµm4kTZs\[!?vZA?γ3|jSjt3A1S#\vJQpqCO.R+^ƖL|d85QRVRqM;١"BEeWr@랣)8ey *mGTߢ^lu'Ih$f;X F=+EOMQ9ʤ]%fIoU>l}+Uqr#y j7G*J<~.+-hP[ aAeSp;}qb}{thuos[mjX|?#cS4RWkGkKᵚ86pvБ۾8#ٻj{5j,`3Bqd{W5J?wQ玲ɗ,Nf.ln-yUrx=ybzu)Es/"o,n70?ֳ{z\ՁߺYoSkow'GC A';~qʌ˕ާ8w-isO8|NQR19JԱ@|6F:jeG(N1ע,L,99Gz{]%\s)HN=sӿZR,nWQ$@YtQs=֦U%fa<5:;h]H`!IP~T{Ku'$o#w(=:Nn` 8ۇ|TJR~%SA[<VRy{G_qǡuݚ(],;IkPt1D&2vy{ddzZ7ci^Q؍!#HNzGm'F/_ R6`+jWWw]vsK_R2e6G`}kW-C5y?M-no9\r-bݘ?7#v_:Њ񌢔VHFK2!sqף9cVZQ׿R0Č۸%[?/_֪>җ,j-Gs&|?:HQɩh$p ï+./b'MrEwv8y˒R*i_Ȏ)#xqZ{JW2)boUdni8eNW[ʒyI7?,P{or9J?QuWc\ԋSJܴG*F[ˈl!uqO>Niԕ7/fرO5R0I0:c߯2Fi\Z"햟ƻ7#qe KBۤ,X{W˖>n^N7B-aR_vܱ0}Oʾ ϦdOYEvexhcJ^*Fw~)Ka ~Ow{:SC-YnTSF~-Vu8=omկ'lZE-Ѷzsɬak߱OU`7\;IJl]x92ɭjMIO%ЭF< 9;']UHtadǻZΥWn龝{ >ޝNU+?5tvm{)*護G|x>r6֧ԊӧM?AHdV*w sI|7e7k+lwQ*sv٭%i>\~Vo;Ioxq0(%QY0< s2\9Q1~XJ{'+k vFu%Q{I5O/d7ܶcORQ2ՙT*u9e.3ŷ*aprF V Ӓ%`)$s 0:GaiF4ey)Q]yxk7 `cli)b*KIz+G{"̿9_ƸjGr;9ʟR徠Z\ұ,R1^ᣢKc7lg !\sk+US*ҧ$Ԭ.!nZe RHPDt3_y9[zr~!Ӯ6o".c*ZTRrO_:+U0֗+ZHl\`0qS.j[5sѧ*xok&|hx3ma$yu 2q8#֫OR*55~iEMN3k{c銶sN_(rpvz`xewo|q~w9}<>Iee[lcx*I=fʳGfu򧋣;ueL@`؇𫵯nµH%qm/TY-]_b@㎝1\QU(o~gSQFmui[_ ˘cg?tgWZ}Dގ6sq',;nN:sqeE$~kB*S:TԬX[USzaFXyJ0w*05#'{uW4E66 ?ێac#Hryl1G[)TQqC<=:ujI/K[Hk{$;-L7*G$.;_T*8X'gm;o39bjJ]o5q&UcmWFU;aU !ɫ]-s NiKٴf[ݡ6J~b~oĞ>7WrKm߷xjϧx8QH--LHmHݹv0M;#4B6/u akg}練jo^qۺjwMidopπO|=ZR潕kk[ojv*0I_K/j֤oū{8W_ ye]sc;q*JpӢJ~wo\TaIa<dӒkєuF*SGt)O$\m27E<qӿ^uJ=Y]7mk45ٷ)3O<VVm+w8){8NNٮ2 ȲΑ~nÏ~ͫRZva1)8;cZ[d4]Bz0n=߇xjg2hW|r>-m,U楹 $`Hq߰>Xq#5\eh;lL;\ۆUx8$uPwwyl| i&ֲWKbkJRHdS:Uø^A1Ofg|,Xò8V=%| VyTN i:_Uoc,jPym/V-eǥ}V8S/5ס_f}{&_ |(%όg&+mS8&:d&mSnnV*j7~gkۊ?t_Ic_/vD`Yv;d6FAxR۟y#xG9 eUSI}b\lѬ\GrJ= 7zu=6*U/Vj)OHAt̲` W,95PwJ#ΖG=o~k qnV-Cҹ}Rn6aN\~>yq7QAk0 x#<u-5*(ش|`O=ϿZ#ͧNU%ΝP?'M,䵹ud߻`T!^ uwєjG_N9Ƥmzu_)[է/·S$tyuZ--%ӷ~R[^5Znlk9M7ǘdgdztk/ΤF 9ZSm|UeDV!gHJ w+(eJ:ߧnVU<zԖڀbI<6Q39T*p-%wGBTNWzI߯<Suƪ-Rfctx9-<*Պ%Z̎{d*xƋnGVPɽV0|E=C**z匩JfuOaMTI߻][պwr|ΘF4KlLWC/{gN)~閚{$kS-L!Ԝ1ѕJrmT}u׹ G&F0c;h- ;Vدң'y#(^g3.2 =HTȟ33FN/˯N"IUnu{[U|΄bLR-[>kìD~+MD4menK9DZ2rztʴc)-Z_Ly^-ʹʜd}kx qw4Jl[/ o|#yR\)Snc,UhBKjO38z]vmgxi0%w,r==|Zz~.RPM%ۯM,W9pUfv& ` rs=v_Jr6͒{~X 9p*{E_1c-Eh1OaաmcoE"x]CdylǷjQKuImbTlg>ѧ}ϩRMyz:1lHiE:'7uK|1=|_5EJ/G{O5;]1;sxqB xԔw6-["nѫEup3ӐF7zTq gumיLB\3>d`zS*ܒugFe6wyg7#ӡY$: cg&RUd4\G]y@c0ooJi%RJz=N[" ·~>SʎwF,#/(ǚgc>^X+f_AI]X LK}J8u+Eu2%r7$p@9v[,,u~7,vZ׵~V=68n_/2crvlWR-V*PQ{8k~2KmGHd wnRr8#y#^FG̞64MMoaT0ɿ([wQ2vGu(j.qEnM mcVE0G``gПN3_,Rmj*zԯq~8n` +ѷ7!s` ~Z|#tO{;Y$IXoc!؜g89obԳzi{)ǫO5ZcX1ӌ0!NQaxO94?c K) ';N3xSɥu<-˰t%[={ZmhlU:_]oSΝ җfZǎEihdVe G_ RR\5dD-źG*$i#4JrT#/Qs[(I[dl!Ny#\+vFWATJrq,f?XR*#I45&h>M e:EmMˑq~G\m)SF<^V{2֋rp*+{ZnIEi7$$0kոFM ˱U7,*my<9#=:\ykJv[t){"BT,lF ؑؑӎ9ʤZ~G:.qQ_3\\C܃& 7c#{rnujQ֯OGww$͜nʏ29g!i'/`*GKGEvSeF=?kj~Wsԗ'4Sܭz/P M6nؐ=*˔ʣZ,B6"Y B66 59O{FAuY6hsB㎵^}&5.(5+t1ȱU u'}=iF|׿si(K=͕+,'hn#(\ֽ)F_ n^{\Mi#`6>RC~8ŶzВߙ- 8maITjFunӧO&k6+P~廒kOgˬ}g/50vh?W'-}OC{JO34j4jWiQ=?i;*r''{.vf] 3Ϯ? )I S5 q12ȸ vctQQDI֩&XAG"#r A폥mN{v6UsE5\˹e%Y61G?ShR2擰Sˌ7ҷcKʬO [sOB}^e;ǰ]N#<9>սG{zsJ(UY' {u5iIװJKj^1p0K&ygZە{߁R6|ʿdʈUqr95%(ZjETIiY'[lPsoi$tsQݮ3BG7#Z]xabRֿy_{ĪqW~8F*6LUadB;s+R4YO4UzrnCu R@f)I c*qrMw cx؂OѪIYX)JoVWR{@V3٤2݄!mpY==Qvq֏֨>I_/#6I:̓n cӍJ)BTb˺ ƞlF;3Ƽpˊ4騷v3h7UpzR+v8Úiku o\f<{?gSIݾb],6IltZQ؇)4<7Ld'coN~:>"+w0ҵz o;r9ҹMі[TWyVϣGc-;ۍMvָ _Z4 t2+)8jRVeGNҽu:-={H6v׷~k9*<ֆu)46y[)!v 60W=nhG#jڶi~ۓG3v5zl &-4r37:sGP9EtLNE" =AS:g?fu3bFi6pO?O~hwLT#m+KannOҮ1ջyEV|f]Ǖ8O`t[LKS;;k..'t<ۼ_,3$XrzQWNtFC* ͳ~?ҪϛR,6FzXg׏ʎXǨ{N$%1,I9B叽cJql)~N>nY@lT~6ٜ{̆T jn9z= rt #!zֶ98ݓN.2u(LJ0+ R]F\ܱS$i[q噗])c9\܍- 72yօ#@7HY~ҺùTݴ)G+|1I'ӟuӍݭf_{fܔwmr޽Gס(}RIIw3no,$lH$fsrxWNFJ6eY'2O­lWdh>\*ԴG$bTl^ߩ8^(t%Ϛy#XJΉ#|}sɯB48ft4ޗ3tv[ !rA{b0Qky a+-uc^Ɯy2gIaFrON}} *Q#bu(imRG,Kn7Z[}[_7 Tfi©PN1ɩbrV:"B1Ruz:J XmUdUG!T\g 7lgkQ6QJPTj/EmhnK vpA@Nx#ֈJQ07]m}9B#gt[1mŻg$q銙FSKEŒ0R@ #L،p98M:rz~g_s[};-^̾[&xG RQ&C+Q-(/j4ъ6R(EP5I˚Uc9SrGujoGc%ԗ$ crzE͜cZXձa~gSR-J3,~ek8E=ѳ%Z,nL:u[nih SqF^YŧcN ˲fwWYrZvۻi%WEv{׭ 2]˶{!`F#`gjT:q8&v^C/h2Kq>㞞~/T³"*U:]&Ko͟%@_duⰷkoQNKtw>D0_7y#Veې7 3dgAOHh6kO_Em |, ,5Ky ʲeNp9#NAJ3Ztaqb#ZumgEZ 5Ʊf֫sgSKjYX##`zsJS$vZߵ_>4ɵ+Ϗ>.*־xR]]EԖ]b=Ii^~c=U'OJp}Vi{{TCҫN7M7$=R׵^qs-Ze.4%[ qߌ,G[[.X,R[ҿ|IHG|Ԛv1@V?0p0xA!^3U#Z:9;Nm| vu+l "䏯ҵ%/yսK~t=F ڵ͛0 "( y$X|=L.9SORR4V~=?n!s5퐳),jP8.uҍ>yYٮt~m]6KJU${m tCH[RuM1bO?}|"1rt|/NT#(]7@%Qԣ23316K'I 5uz7Iu^ʝj|G},r޶-¯ﶷ{)rt;Szr[?WV]#N:ÆݺQrѵM5Z5^gM6csqn:v2P0D.fiyg)I%*[-dI)|csN9(Ӓo/gknx?hM ŜՖɃ~eo9RyW()-էHE.~v5h.aR#?AU-zᗽGV{JIYjff#=Q$.""T*t)6[4t\hc}'^Qr# Ա7v]f։wgt\,j"WhhZ6NN;_UTi-dJzwayye` #T=&qF\Xh];~/rz1M(@{UNׯ} x5rwO<mc xrWq[KGH/%SѫGNǗGZ>O;Y}ƻ%{%>GK)bKhZׇUPμehSTQOuzMԞ!PVO.4c1׏\W*ªNPO:h]öfEي27Y*7Nm.Z4I^ YHʸSסN*.C|<}7+= qͷimۖyqOSn:5bʝ5guiׯ]!ľmZnrЮʀO98sҾO0SkLj+~u S\IE=PQP2־71xk= JdwS| BI}3Q$A'@99v'8n[t^~"eMEZ35{HdWOӭd-eFz c=U$|*7:*UG:OxfmJŮ.\^LwA2pxpgm-*U1=_]+ӼAၨjKfFHrX$a6KWe%r$+kv+LZgm=s{`z`WUNU9FMȼg #fy>Rm'?/lrGɩR3;IJ9_wXmz]d0B 4 ؓ$z0'8l3xR&K}@<`yN_GMfЬεiu^8-xo,_ \Hns]/JI.oպ}NjFXe)TVz׌-,z|ɶ9{3GzqJHuΜ )B9Y^ηr[FM>Ct9]  u{8:iNnoΧ-zA 8i#F[𭓐ANf1#oGknbr{Gdӿc|#5[?Οj 0y627qQF5eZJrJJ*gy>~9$H>յ=L32vLWxlm/kόZti4)%u,pd@ȫb#;8행+ZC4Z&禮16oZK?0E~rr~RF0yskQIBk= x*QtKד$ҧJ*Ht!k֧JRz~*[۔Ɲ:ݿ7Iiw-ljc .3oC k6 _( ![ Vʣ{ҕ)apjUiY[\4.-[nm̍e1La,rq)NQ?oNM !Fq5]}-=]N'AYex qGkEt=L>4𴺈Ӛo&I#\xEJ6}._,5DPiZjf&+cpcvlkq2VTNߙeJ2k%s>%m7z>yo${0wrH/ik_iҩQ.rZˬk>"yf>er3#zʾN2Cҫ,=jim<+fHl }G'U_&i_;m]=3i JqrM$?]WtO:k6KjVk[KdQsuJ4rN=-Om>I>iLqxxkIlo)v 'G9xcJWr*xFޖk[^־Zn=K }ZT~}8'q<ߴKC%R5TaxF5ƗZ_;@%KslWԍՒ}lLpWqi$> $Cܴ"5 nqoiSQqI}sb#8ьiE37.#tBdn9#^uEvm#:vWX'6qiM2ldyֲm|~u1"/3 ͷv{2Bef}|q ˤ Yz_-טnHڱ.UW-r{i*љ|sֹ'DsphKc9n"F\ y9#+t-HƝ5"(pbb80<Ϲ4cQ_',bdeaPysDm)_bJEG[>rHb}uRꥅ3m9I H^Ӆϩ]J DgJ,25z49=bv)^^k_yOSЎ {j$TV{e˺fqמzOT tgB|߁g{ٴ;qIz ?:#+_6N.eywj(¶ߕ~R:dwEyu1ReVo$\o'$|;qyҤ$9aRQ,X!&8¯\zjZuسݤ ʏI}yZvd¢!v۴ #I,!%HH$sqG4݊IK2Er7)G+HX=Lg %ւ&37#36Ҥe}*=.myK iv^[ $gҩGߺ掟tG#=3ܫyg%|lwDSHNR?oK&L[V0Ty'*mq)ҔRn8駆\'eo/JUIv35Fi]_pG 3\|c;ʔE ^pWly'߯JRԍHKGj(y$asǽk뭍c--z^8Orcs^ǹiѫ)iEyi#[ .߿Rr\—ݧ؎#E됧^DmZ\Bc;?̙5Y݃}j%&2اr2#eyosFwRq=jrNSikശf!(cϕƥW8?2e8km HXICIsnݫYSM"o 'fI F7,8` (=36msp횳k.&ԣ-sQ}jfGTH7s}WǖfYaH܊`}j%8E8sVRAO1,|QO pԬi[D5c-|3%ᕞ,(XV{f[J{tQS#׌?N4bijOsOx:>&B/@2rOֳ$oM*j3/<9M\\+1V<McRT#;Ezz*N:>e GH*6USۭzT{ 4] <2qY8EV0?N"Vrz{H1g׹ cW̙ؒ!\q}qۭXElq*ʥyrwZ|.p0ISȯ:HNЧ,EFZr",!x\͟A<zpr3XdVZZ5Խi]$G0x\bF.Zo%4߼^ќc=,eu{2[ kyjiXNaLf\04d3y唹bu{Wk~ެ4N0#Og[Yju5'[۶ߙkfZ%&Qrw"5iԲkȹmnTzRcfqPOlۍ~Xl~^Y-z.R$SBOym-oZ]ݙk5DEKm%R( 8oZҴ*b%迭ΒP\8x'|-8RKd53n4;lg>沩t㦌0*VsT앚p2nd'E?kyc̜j5h{j[+iyG4d:5*rX4[[xD[*~mާ;W%t9#B%uw:+8ضĖ<n>)j;%(ܨl^شCk.}ݬx،EO6,# ѲENݫΕKF_yLf"I]?ˏݢǼzpssZ+[׭Zg9+Yio+~eX<鎕5yv**nK-K,W ;s\'.->jW;.iIf#FUr9r\p=+:jUIjgRTiEYw{//ky ls_ZN5=sTƝhۤ;a"U8l=8^zh^xa1iFRHxZ+Fw 1{J)FֶrLz;cVѦLSԽk9oigшThQ}&@e"UѝNPxWSQR{!8V~Ь +, y(WЙ'KgmzJJ;-ɣ(԰b,bEcʈ}+dy\WD:)YD)gF+NTn[6a T|ͣdgҶ(ӱiJXgnQI$ִQtѢͫNIbHi[%skh84{3dNbߙ9rY*4EK^'a1-H냜r>ֺۣ_%kUFX_sRAi5F5!+d $\ #k(:EZW'BF_OZAsF͓V~ƢЫ\dY`f*{>QPucEG'rK,iU!v6 ~&[ʥu.^pe-k w7:j%hyyi˒E;'Hj178u)4J9O3&)+U#v+}z7Ы3BqeCݯWCӯySiU?ӯ*^d+ȍ_w^XG&2Xӌ>wP7֭HȹcyǵySQyҥ?[ޫ͒ LyȤsӟW5[Ts,U:%kDh$c#w,rH﷎q}i*IEyqRR{vE;KRۜ'+),Dad&F!0* .@ǦGz⊚VydHkwWesz*rǩ9ͻdjk gޣ®3>YN[sJlmYJH{*=f)EY G=64Z9O#JUH5BJIlZDhBvn `}OO9ԨybH-wcݻg3&Rb.۽1y?sJj52I <בST=:zϚZEJ8)7M\Mʷ>)$T#ekD|˾9+#DWO4S˼7ouӧhpsIf+y(Տ{YlmӺ!MA`|{GҳQ-gN⟑$ 펕UyhXƭIrܡ^3ƃcGXcڦ[;cRRt[[FSLv3'3h,<ѴMBɀ:ߞߝTjZz빼ܩt3D,W& F9Go0J)r^Ƒ #mu??WqwVIe }rrר[)ujIBS]-eAݻִﭓ0G]|KiZO2]+VLy^GN5^صjpʥNUȭHıQڻW8:vZ%6OT5Hf݆7|yc"B#TgHmV?a~T,L')C5RJ"flm_k?u1_3ƭsd\[YGw Q uݓ c:sIkܚ4jТL.o"cnqu?mOuN1ʂ[KA&ܠ#tJҕ:uѕfW9ۥ_&^G([Xqe[z{weJ_ƔԱ׼ֲf+<ϟVUE=BOT$].S&V?Yv>Sc[S -U;4V"aG$jJ9q3_Ei&{PVp֧*Ԍ[ZdudCOQi))>XS؂?k2nf29XԓN2W(+h;XMv!X_)gIt >ѹCB Ќc`+?hT8mvZt&4ڹ~DI$䏺+?i82}N 9>sZc uWXⱽIIJ?D H+*<' G9{9Z.4+si{ji:WR89iؚƧ)KSDnf7[]ȸU=yhcQ*ND9ߜѿ)F,Gl =9FQ.7w#L+ Iԃi>YWrrͻ]NF+Mk$/!ۓf%hW Tf`c+1OMrʇ.ס 4<{B%JwCygsDzIF8 !yEsTM5J̢s$5;ӿrԼݙKݎȅU|1McQJ1[?gs'ƅWֹkFTsOvR, B'?7|j^=u0T/NeIwy;I&YJ~\g+E\˖;oԽk"*ͅf5ꪜI 6m?̒!0EHe]@\]J10$ڶ_wH`IT+luƣP|hC3enf8<#yk2ȥo%QN:sZsiԚ{-JLrE:O/+@kS1noQW2Ij~աЋ6hԺ?s^/vF犜o_ʨSݳӿ_YTϡm(M%יnWnsZ.:ۣEʷ57h TgHU1GJ4UwQG+,$]yҝIBW[TY+&S׼3n7K;ŽO4FJ.־9uň^۴p1dWx*x#WNq;%EʞXmr[k}G%Hl2y1eؚ*H~ۯ'8QɪummJ-ks7T՛Rm׈o˒iGlލ:q{>3ԷZi*lb*Ox*i)kN;$C^ {hwcp<5*EӼ[R.be-*cwgons蒥xfrUnj(3ՃRT1ꟻOMuO[ܻc-;ʁfܓ3qSZmDN*LEf]ˆZ&Z?^X9𞟍mힶFaݎHo9m-a,y@#j}'k~'?[Vb|ih! l6MLoF=瞘U59So^;0:u*8Jۇ&Fn${KH0O;\Ms{s7ukRҕF'?GԾdM&.sƥsq浦F/B­t7/89sIGmt;ž4亸Q21A8ɣtQzS5[ÚQ&5e-ye^JӺQkSCXOtN=)[֊|Щi+d&o=x;k^5l#F۳Y.V5-ZN74-ۘ\W+K`)Tܰ&R_V*u}aڦ"I>0ilƎy{v% :+X(/يKmRXGU%՘`Zh1S9'GK.u=1Zo&S v F*iԚmR?&'{5óZu'W|)}5†XBA|µ7R/}??r n`ߧ\Ӯ/ex1 <iS˾# wIkݾ7F;4kU| Oz>RU'~4$ݟe^z*^y= ? (Ӆ\^im㧵X'w=B!:)GXK0,5+ lm̃W 8z5e},m 2/bkf`DCU9eR)^<-Y7/+K#9x 02A0>-b1g {wIN[]GFӊ|kE\k>KIC2(< * okz1^Ҋ´ny]lT74nmb_-d]ۛwOG}ltPTՓz7eM%+1C4p:*N?uөS%{׾HдX!XE㑏\vHKP*5_2m}@M%܌J#`8^f":sqWK~WPNrk|7wfI_29esHsӷ?2JN5y<.Xƴ'$ҍ %kkSq*]wGگTd/&3Uu*?uQ'K+xVVX#F[O\`K2N=X2|ͧ==ěkO̊#Q!g0̠z`c$*Qk_/CapW5?lB-|RkXnFr?{_>'F.Moum=_S\#Q][c2{KIxFfhcVd LvA²»S>￢>p8QmoN>:lS Ui3&SwV_>]>Mŭߩ횯]Hn&ya1c/񉕕Vt*ғЊxʕ*8nՊFiL0vS_+/2W~r𷏴[ r7 s_Ja񧇫NN|\a+Go Ǽ(bc'1޼<5-cXT׹~VeH@ę7(@A_j-Le&[l{TxLekfލiӻ>yin[YWLᛞy9IR4+v~zT8MWz¬3l>]rfV#U)߭#U_5ߵO$vWBsҹ1u(IB%Jrc-.ШtҸՄԮy8Ѭܚ=S]1t*~:|ƴhYs>b-igi\ٮu{3ө¨^[iO>#]oq)m}4SODмMi^=Q<χuVn9돧L\#QZ^3{dB32&Oԁ8ھƞSa|q%8>dﮛ%!m,L.!rq޺y'wU*JE:{b~fg9\Ee(4mNmgwfIdoOJdn ZLCq{tF ]2Of'J듧QmRSZ.qHA!=^JQ\R.>ԩyqϚ}=iRqm?|GBz5͊fUmqœrGJ*1zf!"i;ʑ՚I3dG=t)xGFg*p輎~6ImƒqקR#ZV\Tvt.Mg5մ#1W-֌&6JfsWO 4⬼=4杭x~]zM6mooCߞy㾹e+_U߭=̯6\WwI>׿[>(4~26V-bcːB.2GfX-U0Qs{YmzXQNNmg{<ڞGa\G8#z )WrV{78֍G-3{c2wFUmH]J4_1(hyůs4y K%mI񃁌|GejFR%|sN>֟y7D979 `~yYS3#:؊iE[) hVIB1i^2FO'~5?yO-D3<q}W-JdR|ؚ;O>ᡐ/19Sק8QJT֮ՈWN'|y+&>\AǾ_Cf lEڽ.U !߼ N82I#_yYgTk[u8iu$PxFVl8@~ϰxqjMo3rZimwI_j]e]ڠ >qqOno|a8Zt>Cg{7/LIc~7q\d:rW8 f*]RўhK)":݅~gO>wv3SM4tY4v.n2 cz OmWXpOA<ÞX U*w֡KT[Dm2u]AqEhsܾIѭ>H_ /BLsv?Φ4#G?ZuAEo~%<#e@\pFpÂ8Uu+&ڌvZ7?]xn;b6*֕Z:&f}L`gh&N+߹]: K[YUݿ2}r1QNUy'OC6FZ-,{vjtcj湔NR+[<`ܡpxׯf(ө)sDjGJ wq& i X6?v8cjr˟[/ƫZbӬRbX-2Xm8FVM%SURiHmJ :q]kUiҖ/Bq1Q ~=IUMr*߽HX)}1U\csJJd\mFׁ9jRԌeGanyʯޖ6RWgfnһXj()6o^u9;_d,r=Ϲ=}~yJ (֛SB!f?P:Z~M4o->} nח4jq'}Zbܕɇ֩GҜtӯS9ʥlW-Hmקϖ;$yV]Ȓ.OTo)s/MNT._u50dU6Wc^=OK zr3NE|.cVVUX)EJ5='g絽 r-Ķ 3).8#8=y浔%{qtז l8i_7c?kh٨wUQDci'ozhj6knI"{c޶.YݚRwk[}n7\@Tg(RQ{r<ЮM֑8Nʶ{?JըnfbX1ӌ5 ߽۹TJRM/$_1Dwax( {HӍU#HEɫluKnd>S&ާN5eceNm56g%B?sTF1]:z=B7m{®WZ匨Z#J4%+J3Ť7|S|xqQWTIJ[CJX´)F*jX*r\zVuEV#6 9jQSݕRNNDV~d!\Ejav y繩N8j`҅RҲ$<͋W,%x\m?hqdyN)G9V7+Fk8v?(n'ZSWMNZGc-~]GA~k8:LZVٹ'L QL(/v9[ծ<߶5pөk(U배~m^!fVfiG9qwC/iMlkoܮmeqltǦy*f1 KKٹ`eEE,_`TuԣFn6,mXߙұ}LKWI~ŔwS]?tJV3+}{iN- m\D]\n6oTcR*E6jL ,ov:?u;Q5>dծR2kv̎_+68^~t#M_C>˝{ xnv$Ӕeֆ wo)W ҢJQk#ZLGYȏQ0rqӥW+#&_lג,au?_U()ZNl{=+ʹ*S(Y*dYdcznd*ٵL(wƉoG:8ӭq]M#Z;=3˞{Ҍer)ܕ%Ք^9AiԚuKJ:|[ll_CMu8DWq3*40$NI8viQ啋nݳ3aU:̃N$ցoD>k0yqg3US[un 9S Q]H];x?2լZ2.0LaJVGLhML4m' '͜z޼Jyj__"'v3,LVko۹Ǩӯ]чtSVHD3F[(³F۷m9#J-tK7rZ3iwxv*)s3qⶋ`Frwe -c~Q8nSQ_JZKI ,?ܚup0jMkoߪCgV+%sgAF+S\\ܭʣ =?JeYZMuz3\kK>9m%L|y\W{*ue\Š? W/J\Z*NX-Un%c*jq&XYaۖKH#sYasXOg3/z.XGr0GrK7 ,r336rNk)F5z8]Uh31or^F=77-+ sSQ{T:ӵKyZ8z3ﻜ)7+do3k700z?ZƤz*JMܼg7dJWw2F䵿k[λœoZQ8n)kE5m-"wU:i<^߀ө-U[![c۳5+gur=:V,:E}uSX-o#15M>?Œ8s_aM'xj)T[uXY߱jTf삤R#: .;p7QqĀ=q+撦T-z3?(컠|G}:t}VG{Le\P # XĜs p1Yʥ(JOmJTeQ;]-.xM{ITZp1L3!36~]{cjWJ+X}[Q0#ɵVFWN>:]܊P3K&)s(4NŏhM.ÆvX;^;Vu0kh0գJ:{ɮ]IamǞxx uƤE+jS״Hm%wIoݚΟ s+\9 vX܁2\?B-&Zkt-7zc':.׫}^믦(Gvs8|eiWZa)\3ּ3pۢ(WO5Tn5gDJ˫]}T 2ڠ1! +Z8BdSK^F,!UP$ڣ- V8s#Ez$z^-%U% >Ǒm>Zol>7ùFQ>^ roޕJn7M?4>Evei<漉CVH-Y,9^)\RŞ  TQi{rشF^[tknNU䥧^nđ+#` ߁eiF(E?ùc=FK6Ur=3c(uG][FOݻGhNt*@#ۊ}~^Y&RRƝʗ6rQY~l0^i;0|5H"Kj&sۊ(˙JcB(Ju%+Y i^6c#8RN׻6窛Vd࿆OEf|msۃtSRv~SufuTd$GB i(MzFTz#PxC鑯;WZ ȬQ=L)Vjn]VkoVD]!Y[=;W`Sj}Ph-<5ku\n,V`:285S WQ˝&~'[V?\Y546d'xʕ$Ű3c5Y 8~5Síy޽?R~aǡ\][3{OW EV]i[SE_ݿZM1n+&C'Ql cZqB*wdmSD4! 42cpA8ttfEFjsӖ2#$gZxPMN9,2c*A YUJr\Rt^# GJ秈FIDkV0po=xuljG+-Zݵ,G#G[$ ;B#>wi^//St9k-,<]e].9ASy)Q Qչ<,?Wz]}#ŲMQn-ayB@rN?E{}7xJaenu$t<.Cw-ooM@=:־TqV:x9J["K3d0%*C:zU}N{0jk}诹6htlPк* <=s&秃%[s[<9*USȹoqًQnmfAf$rxx2_k}_SrNt\\\+FЪo tB\PgZN0Ov5R$;+[q(Hh6K+Œpr+Kk~?$Ֆm[cx%K߯8}0%N5?{;b"JtDZoY7`UemdTd36uwiMjzÿiĩk-$qgOdA㞇Ӎ 7:b%vKkq_FsSn1^o3g;pX1^u5v19TR=^tH^1g2HZNޫ9DirF c&kyW2$з+r )0Iw?rꐖ"zǚlxvs-1X~0  sƝOv_r*9&ʝUqfIp{v2E˟sklF6uSSh?^xwh|/RX<6SMW=FR Ӿ7xÿ --Ybq0TnY@Qծ{zX1 vM>g~^$׼Id3,7#G3.쁍n#g_X(r] 8›T>|TӦ^YjQ7XJ8r{_pi~} çs{OXirIuj6fU0L`|<5Ҥ֥F-^NGT'5h-Vr\q`G^qq;<IFmnG? 4k>#M4$$:䑏@¶ӼlWr;\W3LXE{ /0$mcqG=eFoNka0VmߦC׏/C?S {#F z8=x[Q*j:i娹c?8H;me2d#GBO1S_it{4wyω5Z2F l<G|]q>eM|g|v~rݺa乗nz'ȹb#2^[oз/ .ڜ֒4I&*C HiM2'*xqtVv&6d#U*А޼|eJqUX8/'+]/3xfMèvqq#=Ҽ>;Dyɩo%hǖڪ1sv_QNa)-?RqAsBd8<H.O~{괛WؙT)sZ+ƖFj}{9Gs5"ropY. ԌN>c[5)oa]ct.<k^:H쵠⁡g F,& V3rKEs丳ܬ6,HT{~uN,qmSH}OZ>eߘRʗp3Q8ti~N̬K99@p4@Jx݄`$ y?Qv⎬<%:Rߑ.F[h{q^=kW^fXW$[@O&~FQiӋp(Zі!Gك3|G-.[H'u#9vYLϧⴌR:(ܜXk&Bw3Nx9zTctT✝`$9y|HFOߌQH؆{6P8}W-Kyd!@wgj͜uRiE}cFdG#@c!|8 _}wiWPH1YF Nϖ7͸Ef◡TC Àrl`:֞RNt,͹smdQR(Fَ;7ľvsq۟j? ROؾ|Fd34LcimW'CS(5){8w ϴMde7zEjNP ඕHՋ)eP01R嬉eene.dhmsq o0t FIUW[+\[ ;af[n@IQ8ԙKwy#_1X/ϕV瞿ZƑ%XEB]F%fY/=VyT+SZrY&Q ىd<ǧjZ6#j϶Գ[zD2+zzzSZ_wiMZ_.`'1S.Wg*'vKRBy$wg8T{IrG'=[޴kk6ެPG9#źroRc.,mk4v8ly=QX_ck= y#F|җk{d[*Mö錜n*kB%82^USo<7__nyV܄ F Ų_ާ7mJ5pT޽Wb,cSǂq'8֒85s ay%'Uͣg0qGnϚV{<;z3iW0q7UWN: 'YKM%E*njW}GP ũy0V| txR]>Qurkoz$9k%t])/+"PEX#b#XV@9Y{8ԻmkjJqےg2GTS8JR3 ;loS3k9S.g[ѴrѧYw܈ոVŗe8)xSc>A@#PdN82J%b\I8.yyUdjҩF^%VujڒOB#Imu.ŘeHpheʥߗS'^_ MʻP?ƹy#V2{~FvObOfdTyn5ѳUCQ(q-a.g4M̊#'<>QFtmcɅXN'5LB<F{J{z4p5/tmDQN~^$=1ҸhҦmouFj4EVI;Fj|$yWnzWMÞG_:S5i{;/tBvnTTnHR֣ fdZۻylIF{ qU㹍*55mZ߈ԈB&*2j{ÝRmfːNќ[Q{,-Hs4Il|\VPK7n?ǦkJ5#ݢcgRTu4.\ y|`>jNV^y?Tu2Gjgkirc*wI!j޾T[ӕHҕo_?N3yi|]}N{9E" `R?)*h%FkFy (m=9UI*iuEG_25!2g{*QJߧmiXmf\1#%7'96IBT0Uq^_lNǟ s#cNb`p HǭpԍIFNxJ㱫eً7pG5TAjW4ܿi7G gw8x㸮S.gR3VWfI;K+KvrAE(J;*:td荈`m^I?\sVk+ϩOh6(6xPJsG~gFTaNP{^^W42dvXBd*q߁ShʛZΌZ߷{jJ ϻtOgN+DS%߹npayT۲{VQM+.Ee`ݏh>$:Ϛcjr._RHh/˵M7gF\$iѷ+MOq8WTey.mY ڢC,Ӳ33+FY]*e:rRߡΚhFܳygۜrGT)?Bq35۲Jl ?NR+ncFסZy$-'ܲeٳ'ӞTT]jiB/ԯ4ۖޕ:{q)NC9Fk{uUBOjcWQF_O(iw}A * feG?N+EͨΔ5>*[,\G>ǿNOʌ;tsө Lū_RfH⸸hm/ʮNT}?P~zj^әY 6s#+|ݎk~f6#}/AsW?ZNfku54зfmccqqָjӨOC8Sԟbo/fi?oZjEs%l#\y$RF*99v5*'+7L%vѷchz(Cddy9;vڱg.."m|8-?#7 {{*֫*zrVmF dv+x/W8Ni m#~"@c8ۡ1;="Liy͹l}=9R&4GG}#'kd9Rf7 qBg<9߿cRڲIk;;6pU$ 9r?S;)U#֤-s4a~AoݶX# U%%J-do͹xEϸTm'9aRs*It>fI –nxɢ2rP}Lx+nnJGq7B@B)^F{M-}u+Bѡg㕤عӌiCWY†eI{~VFov"yg>}辥Jn)ǣu~{wlƲrך1|ƛe幎T$Y#G|q] 25W4!xd<瓎O~4VF}mgm<ʹ5ěV5oݪʂ{q~TGNU.%\yGQG>u{1TGtwv"DŜ._#^=eۡU#uQ+^y?m.0\rFhm;NmZ[vI LIE9.MꑣRdHh+Qc _9ᚨԗ*gӣIMv$k1HXI~mpqdya+6:<}QHKlHUR99]2q7͌,/*O}E0b<{m޹e)_rFT7r8I:t&_z}kZQAݭ# 2W@Ⲏ#-GU3{-UF~m+TJ:VQN:[ULѲ6Qm#I8 N.c5^mcw$Go<3:scksש'UF _i JiqqEg)8s-;VQq"f?OJRW1FsW{vVW.$O%hzU%qMn*5ʥ.="dwA!?.2UNp{zu㿙rGQ8zۚ:}3,ז6ॺDoS2Jqk4bkNCm~TXI9{r~VRLרnMs?=]M+[ig8YWX^c)Fl馓v_B#d嬞^gSQ1U'/Q[M- fU ±.^Tr-QzXy cl?sI W݋vS9oLzӌuJgr>YӼzVHi<dgZϕ9'l1G']f} %ʚE1eV,r*g"7N=^1 UG4fsSlރ\ѿ WUW"ʕ:}VX6NGJ¶d?+*+0>X+_2ktX3{⹪EB;gNT+R4*̣*98=AY˖ЗJ+W)Mɵ~`ʪss>ƸFv*ryDhvXtVe黟NciNVhJQQvP\ ީgkq4J3J Qm-]<;QKܖibeDUn/ө]ѩ*Tiݻ/02yN0{ӳdZ7Hp q oelfϥuIvD{Oi{M*8PHyOsw\/StWtc|AO/NdFSq} vgs[F2qn1F@ y|cץ{,,Z/cj8Ys)4mm|6Wa/[cxC7)펽3_MdϠa)=[ݤQzרN1QGJS{{g?+I\q+nZv&t ȏ(>cz{q6ȩrWOs5 xgp2Hz_Z(-;a4kn[6Dn Qs zt5S;z|U 1Qz%ջ;ϵw2dF1z|xd_mN=ok/wU]娙».0s78cFUg4/ə$h3v )]u DiӪ5Kk&_Xʼt#)I&Ei-kAu*yl/q##GpYkvy5*ʥ6/Zh*yQFGUh8 w/z'R5=M;m 0"0C>9q&ӯ]9C!kti [z(DJHM+,o!-4ݖ3$7{_pm82s׎JrOUY-ff&rs[Fu+dn.TVbvgiJɛ{Mz$K_acnJ}:tYkЙsT.]C,qʗ[I UX:cXk[ pĥ~Iʙ{t#t"T\܎-y$u@ÜJ*HƤiЖ'Ivó*U{kzA AA#f,89 'Ҿ N`J^ҝspyO:+I"zd<"ƫo<᳀ߏ0瑌q(qC< h.KN#v-0T3$fc:w>vm#eб2;;l8\wR{#ݕ?p.dbA݌aKT[RQk3.ooi*w3qֱQՅ:_7V_[GV?EPHO^L=8zTpeeU~'$G>1v#*aTփ7wCu;Ylge]fi sg=j`*iuTu N~YLjY gRpGO\=/-;;Z$e"ବmt5q:~f# }c?S|rIpԡ xY[[(8e"5g'qNX:ɹڭ5nZZ3[d2q^ml?,&({m"DB1flT}3b'B KicVy[JXWg?/{JQu3IԛjeZ7cbY法ӻ^*t:ūGDޓbkJJ&#C&$91>G~*Q_R?fQ[_%:,>nwnNQWS)ʣICzVSMuy̓̎FqPO89<{uC5e{&tPEI*ȬGP{ n8\e9xǡ=U 'qFi}tnq6(!2[vp{kb:-(no#ի8j6>_1|RmsT1sٸ|(2HNy9߯Zc}~~[q:տ+;}}ECo8#p4J)~HR;Ti\F+ۏ-OviT84NxcJ]:51,`-$<:X͹lwS̡b ԮՑQe>.joyi|m'cJ4֧ї<7vtG[pӬ'Wz;֕ -kBi)YGvO#ܴ_CYt9{<Ɍ~SMKN;j}]KګuJ~:'x{WYm`|+0rG{e=̥֩iie/}}<*:3}Ww@e'4MN8GWlj9N 3UJqlf#Qʢw]z=Zg TВ3=Ɯ\㥉QZ>aeȐκ /by:R;s,ߦxzѩ狲J_[_4VR$d*W0篭mZjn.oFNq$u4{s'Xz`}qymY~+jհEyT|#b-CwЀ?{f8ʌ^jaڵ=տT~cޘ<1%חrdIb 9:q:cS]I$q㰵pV}޿q~\WVcȮ~ԋQټ+[[e2$C Ϩxףs8:'n]svZ+㌥~!V<\m$%!XHq@<1{8Dbg}[?'ӿ5P,}ªw){VjϨ3eAqrmd7? |A,>"o&#s#ܯ@*9E Om}z6| t+M["[ɤegCgcG9|sElrMf[eЬ1x)>[Nn˽յj][1\`33YuiVkW'7q¦(wQa@?}5˙Sqz22ŻݵY!lp7땏-8.jn\o+QݿiIgFۋ6dWTǚ:+BeMߵSbږ(p[-jKgJZ>~[?miǗ-F]$gsEOQIG^ 0!$2./#L|ÜN.>AK٤jRSZ4ԓRbo}NWoN&([{NU"V{^ ?St˒5mȍF7 Tj~v{<-9JOkk[T]$Qy̲ |v}zjZgα 展۵UI<,hOI궳ͻZe|F'kݵf{y}5V}~/ῖ9#i3sO8ђWuxxT؇Yiyڄ:$K" <~ZJk-J|>ӼIkxi`eI>v*-z|'yRF쏊ࢿ|KXcs[$v t#*x|E'_i%j~e$wFH|S'o;m 9G\7MTrYy_a)ΥRv{o\6G;Nq^.'4NN6t蹪n'ijɺVU޼FU8r!Pg+)=~G㈨>'Mw d=F7pӍKIk}M8xm+LÊEզnN1)F[:^0ɷok̍omO6}[~g t:&Fe=#Fw;A,ʽoN:ZNIYvVǖ+E_^";-RTV[:~19>+]Xƴk.YY|OIe'F~FT7q> mU1U_]]\'mZ陦6ryWO(efm[}wQjzrN̑ȑ8}-~DqzNa4HFYeSROcY꛶ݗqOhLDI;t]|Ҍ#&oCխRjq+%껙$cgF! b:=>}PJy'Uӧ5˩htk6.϶<Ԁ뻠'#wjFJ*_cIrޕ:C~`tx[y|F>au`O?# Ѭz?3zkGۢ^\(-uOE]֩MNRJkak7q4r/S_^v+M{mzRY˩kS*y۸cp1FRR嶮MRj2Q) v6ټs+ٻN:>v_n=|T=+ͩvrk^&4p+뫳h[$1\Wָ!?v#RQzŇ#IؑwUT)ZV%MjNmUe~!m}p;=ۇ/BrҜӣEBDS&b/NJ8skxuGϱiV$fT ǵm89:-OEF=3چ7Ay2αN9XI{P\<ЅÂy|4c)=eǗ\}6؉'ka6]/l>w>eR r޻6*Gḍ,N@gxiʼE%# {Ȗw[|u9tԭUG V[<8mo/,޸taOקCJ嚫K Z\ UwjqH=UƤtMWQ'>MY$vo1T7쪧vG~r1QҺh{JQV9e|HIZM;E"u V{8OFXa0V*rē]ӗ4c*rSI-V׶xI乚_(1ѶUq1STSIƊ}Sghcߔ]oQ8T\چ<$njN)8tIWw|[yP]ۺ<~UӅNkniNQ:[I g͸uw3S:%O ˋuU7%s.<͠1O?*.]ԯzr~EKø o,㞃8[ܰe1!;uT u檧,yjӯ[tD۰F35>>6(>ؘʝ9ݠNJwM9Xorrq׶3Dh^qonbKO3OEE]D9x8ʥ5Qq[He܄ߘ]KKROrc{fd_.m8\:dyݟ'WJ2_I`ӥR4N?vӽ_$Mq-P,-zvzt{uZpw+4]ͧw{Um[1I T[Y]2s $c5N1Nۘǖu$bisԏ,nFF[Y q0sڦZ%Wqb$>kYC\K=Ca杛_ޞg"ofG[v~Z $fs+ %R-'k~$UED3Yd 0vvÚNU&#UGU7v$#mhY;atJySqn4k˹$xGXԎ4 QM:#5۴6Xu +(˓Ezh=tnv}ي5&^EB Z*^ MNG7w1y/+޴iS3ݎG廁5ݸ2ı냌ӞR4u)ZٛVF e9t?\i9XO'fۙCt$?UGx_zkY}Ytmes߯`jhyKZ{3̾_O1{ߏ˵e(GzKR7I;2FWz&9b3$h5eHd*-׏Ztt/~{2H/eT>^9UmF^z0d;I<}(|z{rn[<ۛߎ {9J[SR}o#hTܯ**Uu6FƗoeO^irSHÕC%gV >kJt-{,+SdrǙA}ݷ=x|wjM.d1fzە{=u4F}vhٕ+g?iJRJq>ο}@ms޻!NR(Kln|Xr9Nk8B^N?W~7[UVE 2㞄J9.O[KTUA4+xײG1czբ=uUX[#3&Ӑk4]8i.XSUg)LK"b5\ ;t~ֻcZ6*3zx 6R*`311КFN:-L?i%.;*yc wc cpG\$N8:=٘ޒntn6oS5V'4bg0O) 1"yx 9~w?>&>*M+n^)|Ymwx(zʹЩʝʏiVَ@@8^rkC:#[UB%/2%XG A&FxU/+I?SQ[ر*CuOl\ІfEieA֪u#dt=4zQ&TlwS*zIq762@X֌daG,ٯk$2"2~? /ƮTBzyV$0fیǷs9Jԡ^7ts"mT3} &20=F~Vc+NTRћ] 洭*C6s:7_#gkUu7f嵋 yҢ ou!גGPzwzQrU.M޽<)LO̱(nWqھb5:/4cZFy6ݸ\goθAZ yW{kxwOM*HLf^Xn.8D`rxGMV>--;œY][K%%EgeR88$pkU'S-Mw迯#)c>f_[yܱwQA~yWVJ2oMzQja*Ed֍'ܟ b?_xy7[e\ e?c_!G=`{8;']O̱jJݽ,} jOI-઼j Jz1]̱?Ϲ;1&o[v۹Һ#ԭODrָjwe%}v{fM;躿3㮭jR·JܳgU$eN0*sCm=>)U.msޫ-J^+!*aFx'9<=˚j%cx "iۿjSYB m }y,Ta~.9bkO}Z/UYHV+7DzJ唡NmHkNNT֯,h4 bHV)]lqʞ;9J;{85}OzO]iڌ1ary{1BA9eM{q(jBFWq%ftduV*i3Z n#t֩k>GdZ}> HfH{ n.I07$6*rQO϶XTjFNim5ktڞy HŮ#,.iO_xgЊoߩ.UZo6Ϧ뮿?;tR;,cmvmʪPsz#^?IE&x;:QOϯy揩hzq H͝ҙ9pGR[J8vWY֧t]vZ?+u#\O{imr&[r' }jpw윧>[mk_݅b5MV| j][ڋY./<-pKWY]j8;[#KO ikH`2ӊc}9T$-vV"ki^ҡhe 88Ӟ3יVWsol"2RzgsO 2_6Z(0g#c9Q$RWGM/#hziiVgVaHS==*ғMgf"Q]P/B=B2Nxj828&|Pzl==DkUs$c9װ5ӇW?iR<]d}{SɓFG6Q$ Ѩ5}{NTN&|eNiT`>9] g3Ͻ{\ %x8/̥O0m-0-ᛵ4陾F|;PcXbÖ-馦daԵKKNo."֍:hcy+ y 3ǧ9*O*uF7\ Rcf#g>: {9(9au)(u;_hiVe #Fʬz1QڲJjZy"5qy咶iً^޴vye#oi$pr}rZ֕,2~iN5"잎2M:X_[*H 4WVH#{r+h-]Zkob)(_ku #[mF9-fy@q]6[.糈O^2[v^G{=O(U?Ã#+{9Sߙl>jqw}a5ɵ\ߺ1?"QB})T=[XҼWY^G=``A\kރ}9FVM/x~9&&$7:{O'cIa.ͭNm$ǹ^fxgRN íQgOϊ-\Q]BǍ]f"e,_2*c >U1ʥ9S5mO0D7\4j|%1'S5fzYv=ײ(Iqw${Km'zt?ֽ=(<=<7-(]o "Pa+3 [gccWSothR6.Vg5=jmS&=ol,?)ے9f QONik|lMGk;-{۲}z^Լ/iemL<~wW[{[FUbH=R(:?)Qy1V_^Si}cT!aCS;$rV>#7/OZ]cx"o?1fڬĆ c#,sw+ڔV>[?G2K)yahḆ̲ʫa+oS{Rt\].pN4% cuк~XwI-ǝ9lsN9lMWG-Zre}3ϊ:p/z~Mͫy;,\W}<',TU}vU'[{]ng;xGHu(tʷ19Ry> |[~ta*U-d6aM'JŽ2C=#17!lgq)^\vWk}f*cZOY|Sk-UwiFURG>Qd`er䬠kKia84涝:,5߇jcY#J80rqiU8ҳpIs4oMnxwmhG~c9Y AFH $7`8'Μj{h8SQmk%^ էInokv8+4'U8W3S]qd S9ImsR%дӤb%]zH&t&|O ۪o&9_4s.7cF9Wdh#RIуvn+UA|ې1ޝҶ攖>B5ki5JdAIӑYÛIX6vs[Br]*q5a"I-u]w@~<*ۗdo*QXwUy\18QE+B)D1}~+zzZ>6Z!3/y[}u5å:4i9oz ImaArp1*ΞʵnWoMn$v3B7Sy]vTe*q+<}l ;p:g=zUǓ >εK wf:ܪ~V/A*}KKQ%!s7?ʬ[ ƶlƷk%1<[0[s09 O㿱DӳEs{̆,F#6 ʼn?ܥʝ{n7 q3$^GÜ<|nQ%Mw!uww=P3+?o.E̮LycOȊqopL̑y~_oA$洧i~J4m_]Gq~۾PAN*QLcVvkF*߮p-rN?_ZTh8+}RZlZ&>f<c99r!ԩ-_n˩ t,R10RX-n" |ˈeUY&%r!sgxeR"bW(V-U߻|Gg 5!~i=L*ƍZ=t*C:\*n{{jݭ(s+ܰ,,Ͳ,XiY)qy=T}2j_OXւĢ?1$ϯ֦Ċ(<-K,EoҥU*]oCH:2Qn 'fR޸}uFcE_bM67/<O> U"jTBy#ő6 䉋͞=s\UFZl2iJ+Y]̹H-|~uRn]^V?3s:ܼ-o299PWn1NsmRgta&ݴ鴢!dѦHٟz,k_akϔUgթum:ŤCmj*Y8$Ib=HEJKGբ׆FW2+FC-j_v?$2[Iߎ\FwΪԛ]dxum`7I kxn~{%iCgtF\5!d q3}y/lў|cJI܍GC#nffry9YԠkgF4S꯮@(>v "F3"evJg{v)7ȡvUdf'\yӸTJQjGw&PRʼRTnΈΝL:v].K Ocj01\riN.JpEEBiZ:E<+3-r{+4ϵk9F͛J.2z„pݮ W85)IB1r:]܅xpv\c#ӿk)NRj0J{u0vⷂ}hA=FN+5%NsYZDwLJVF;r8M"s ,]d_Imd*Jsmd3N@w9l29M,K[8E!-V~BTlj%&u_ #ٓ%*O~ }=NvnʃԪCƜibYZޡX_{l;Z:~&ǡ:wBJI&tEw"]˻s<`t>TT5Њѣ=_t3Y7\zg:KCTegggFYw\EiTl,*(VqwqK۰ >ֲF.eJ敩k~fe; xQcRX4~дO;˞1 6Iy'=^kb=.\yff˷p%cxQ]QUymK|6`~#ڮQuRWIo%>_ѧDi9RRxK\"o_+7#4(求kʏ:$7_nk>mjH]w}A9#dR/[M XĒ,IuZuqO^e49Nζ?B$dr\$8l)ڎxygwR<ԍ38_3r(ۈ1WR}e=^ñPl6OßcY{i 1f vm#rޘJJ7KoZT$In>Vךc˙hW B.v{ug%jf59Kuww[%RWΓu7V~5*5M*II1cSI8W7ZLG%G kIX@vr:;jsFa^KGcf?a'}\R8CKt*_nX*V-A~VSRIFSViuٔu 6ȗ,FCGvQ8jb(~wwVHBAp~qWW}9}*9I=ӲSp6 **NJ*93_c%%&Y5kQV^^}B\Y;<=2r.qJv qZԵϥ/"I$Ek,|7z\V1ioܺ~N؎KXdi}+y=s]ҧG;9jQU)A$]M? 4n&0ɷy?5*Jsu<-L=iaӺmKR0d`]ꫵpw Nrs;DjS|zu N1G[p3FFc]`8>ֶK{FV3e(7gu+[ǸHqdj;cֹ'Mio5<;U[v.E7d$v \UOzISҎ*]9Y6bÉ#hח w#MJwYǒkފ6!Qe;c^2s*G(ʥ9rקB!E7ݑ8,32G\ ,~HacxJ}xZydf=:W[TZ?N1z+yjVTuRR{ ;^$p ;f-(ǩ{nVשF3+3?9yqc?q:ӌ]^`C ?sVrg~c=p|}d 3UnV9'b%bPEF{wuW0IP3pq2kJtye} F"خ'Ku+60O#q]S/*KKӦқkEv2>4cۿ\R0Xm8TT%˩y-ж1jRXl)AzOI-^n"̽{!G6s=? Z1vG:ӵ; $bbEFIgz䜝8l8ӌ{[mmt#௝j:u/'ϊףԴգ*6S*2`T~73'RqzV]$KI7 OEX2K#rӒooxYy]GlkS湜bQ">/a}\Vqw'bt˹sF.W^ ,yP.AP4OQ*7`z@q!Rv"t`\ZA3zkWmk1*[wךyF2S}&5r̭rx'ִo[:IWI62%vgmd|edAS$K(#;$7,꣮7`9;ȣ$őp9=z1Oi(Zu `( ۗ$d9jTԴQY&@4x{5OmQiԅgnu0UPn;~P9Nj'S28F}v{t%|bГ{SBQ:4֏C+R;MSiҶ3EG (~6,iVCLʛtrxxǙ_Іss&gҶ/g&iэq,%3<)ƚgMOeZ.0zh͎RP3Nz$qRwIje(;-QxD~YS*]%%U|z-,ШV$qr1ϊ맅*msևږj- nprCQ,75?3i{(drN/,QUX_-5y _+o0 ;c ܑ+.]FI#gY)$ 7NI|:[~s̛V6n=iZ4Ъ**F){C>zn30=YJ:tbb]WUSW1]`QwiA/hcR?1U5;,pUylsܟ^;b$;-^?WԄ]C [h*˹A1ZSyuь[е%fub8PNgS D*ANJAq$ϼN⻲1NCeN\[P&*oyot6FOevHJDK/3ь+֔y-f6KCiS򱏩ӊ5)'s(s%{hƵV&m6) B=B1[{zm3֔9(B`i yÎA?y*j{Yta߳%ԲvɅw=;V)tRiEߡ5ie[v,sװG.XF[ѧ(ҾұyKry˃=j¤y\l-[n2Y0 FUTLt"=oNIip.۵7|$q^n Y2ɞ@sЎsް>YZoԄ&o(cyTnrZB2DV*9+JF'v1x=V=e(M̂[;;]v/$/ c*J&}'uVW;uq2Q*9)]]oFU1K%gJR朝>=ڸmpoF4տS21Qڗ-.P4^eI]+XQ$K D| =:܁\/ixΕHV} YefmcȣFQH%v\[inҩR7G%nz5:t5ՙv+4)8]9eSWZ# 3[MmD>fs֢ \3qZ]&ɷhkEG 'f7,4`2*y-iVhJW/=/{+}5L;q'#j|*L/r-r=F1ӯ`(.5s,g|Nzc4ʫW̵amG6628r=;r2~,]Gx`U+>ҳF7/4~`ŲOI9jj{frZKϔҲ 0'>s1d7ZWX,8{zj=MړO3%MϷj3z;XYJo{2dnd =O댏Ƴ%G,IҾ4fs4L7Z $>N޷#YK <y#SkFzXzq#ʺ(A->WPvyz=l'I&@9Doj^:S%)|?C:k⅕flî['t5IhtsK2'r[ϞNZB"Vq<3q]jm$}Sͻ/|j}Ƥ_y\ZI; d䎜~-k*%Q5Kmy#LL^{9c+J*`1vw4_۩'UXl9oLǒ 5fδFu֤xeѭ[:Y[yV?*rqTU{G]mfmHj P8ONRH#5V#תf4mUkGN=떤}-Le~vMB/`.g9Y2n'ܩSK߉_F**䴋 $䞁*9#ы&ddnUY0H$sӽ)|M1M!FLͿ{}=3J6RIMDG?oQtY6RH }3ʜyOӏ-~\\jۤʻӯ=kjr|.1墓[x3w;o ;I=k2֥+~1ۙ4e>q{h%x.J:YuniDnRYP;yR274맸S3R[q#d1Se523Ahs`rsєymFu(:RG QfL?p1J:p)׭*}k2k/-+s^̪Jm];gT6~zh;i!l{@I䁟ǯn<{sY_t}-q.4T%FUwFaq;V}JSrJ5g3/ keVcȱW%3 WZ1G~lV֪]]-w}ok۸yIl$z`t)r&ֶQpܼGiqJpX#N zAҼYF:z|支Wjrϋgk#)'{ҹ-q֣uZ/6 \fcy̪.euc[S&?br]68یqUڿNsQ|DK{vu`7\ks˩d7nݑsJ%hmcp@0=Ӷxe漶POGm,o*<@sWDiٯrPV |d+$,:wN{We<-:JΌ%8{Vv b]Z59{9v`rG}k4iNϭB8FI)^޿1KndI>"b874&~^Jdk6U) YoO>x뫺V}.-5ޢK$k{wfF! 8^{rz ᩇJ+O&՝VDռs[ok(zQҼhJnXQto9Xܳ%ݬdϭtc0iZzYGtT4WM\ٹN.6LƸ*2+Ogw!G[`Jױj4}ևO GwmeKhs.>n97ӗ<~G.imsz6[cRQ^f4cW9|˔[FXu('aƭIQB~k&9U98sXxO?Lq{.QńI]xS [A,H^SJsrViK%c~ϗTiR4MzYPT`ZOGi/*^H8:;Tk-;GqӱF&!-r# 6ٿb%hwSf۷ D,M|g,g,U|֬Ƴ44֓[o6XTH8<灞&4M=*҄^kk.𶫥]6ͼi.G2HRI9\c76/9pN{;#$3<34o=?ʺ#)ƛqƷ2n}3RgnhN<)\s%ב9FY.^ I,xUOg5D}Pǖ-2Rs|UWMv k+o'vS)[e~h)Pnl {Y[oȵ^] w=^_NirS[}_n+Ul}:vW*Y{Ja@ }K8 cG}443*$ݵ]|i0t:(gɼ‚3d_Y%mat)r!q'׷LNч=0RkK4|4HiT"カ8"l^ko3p|S2$Rʃ+? SeG߶_eyO(XTیt#R.M^۳xc[Wk_=[2go9e^==kIQ Rj6뿩h`kyw7䉂;wIp8@G4e%'UVG %kZ~5\wX:gx0vn޾Gі7j%u~M|s~#ڡ$č#aNaNkUJaIM-z^ϳfgHm#FU<(>ǩSOM:ufTqQwAcB5 {§NzFA+襚pҜ_|?:Pr["Zo]dy~n9#wRc᷉,ZwKg4k1 V=q-i'*kFc:n#r7ϧZGs;>]-@@}WV2[K`04TU&5sRMvzu[ƻcO418UGJoaTV#G&/}B''ۯNuxYJY6}ϹAʍOSYmtյݖ+wU۟k?*UmJ4X-ccz)ly~52",i4k}6,T"7oAN[5n9"̍f V2W g隨 (ԬWP > O~k tSCxfYbvx&T1hE_]|˗5;ﯙjW0|{ٮzԪJ\rՅYǙhG4fͼj~QB,2y{~UN-{yQN74B|49!Y;| svʔkFQkkùog!<e=cspc,OK9F.CU-HAj4<d9&jrw [g 4*% @vFI.9\;zqԕ_geD/]ɬW;Ig[W)7u.Fy[U^>#%%Uge׭>t0eZn*v)zΞ׈s=H8+_唽^[RII'_ny% ;b)i/x+8͹@̲r[^ {Zt`SBRW߅|)E-dL?X>܃A5cN})]SkKލzP0-7h3YF99 %,B5Vt7YJ87,s +("4_x< >z)ocJ8ɮ;w{%nܹ0?P;e/e+s[|?|E3Bw@8 ּo[M.RVkn<y#nn,Kʫ00G ׸E:w+:0Y=-gzi `4^99N2⛵cBE]^۱}Y٣QNNG?^T:/Y7clF"UF{o|d5 jRhsVQHI">LqNsҺ(֌ y<Q*}=1X%VN3Q~B$ kةyW-JRU+GڳGJ|[J:_'M bQ95._ierJ cH2\.l=kJ5+Im&4qvZu0c6/'5ԍ5Z)QqB`ڗž]?گS Fq_#Ob&7o YXj;'4 =R+]GY}O[kit~b-1p$u'<+?9F>V81Mm5Nժ$r,?Ǚn<tkJ63"KG^k<+o k*H 6cڳbU|͵޿ N}ng#wzgF#/b3ejzz~gY+[[6#8WN6MJ/aEΤhaH d41R>4tz0ny LgW]:6-5sr߫{[Ya9$ԧ%;U#BP[[t- Fg'89iR-DɊ7Kt:ڴQmY ٪? =#yJ[.Nj*t;/3ZBOƸ1\F}cj6՗nn]JB7ˌr3yy8?Uz3Q+qmY ңfs򌪞;t^6e7}ߟUҿ"s* |+ٹQFN8BYG2\2=ϻq:݃T攚V:2qvVfʨRnЂ;tje9GWሌ(W'G|x=&e*nɽZNrېX[oּF:s[F鮭ʷR\#SpK3Lg8k­5{~:5TT:klfQq6ehoRv/\=kNme"hГ}j3{˂N9ݱD;~FlU>vu[Ԯ 58q7yjQSc%y]-:lP+! G=z'N[UjS)/Vk*V~w=w9鏥VIY6֏E(Ta'~~@1v\|=>u'FҶNFзk5f0I?1$rx?J֌oW+ {O$XZEER-`~(ߵ[vu!N)]B~H_358#J2Jn*JoY Ѯ>uT[8\Ei)l]QϘR BLBqxђ_yg݇`ZG4RtT'+R%*]+0+I:]DA^mȥIn9k2HK g3'nm%J)`/s?/?SuєS.5;[{+ ٌRT9YPU(6k$;źKc0>Tjs?aZa6nS#4L[ǏO֪6^G]NOcd%>d`i 8 slkocG9d&BЃZ1c.iY2~\l''oZTl]Y:5TڼH%<2 pN2x#t 2:zk^Z\1XVFyyt̢5XcӁtݺi|A3S(HΚZl|K qܭg`:sל`FT zui/v:9#f`Ud]MiN:oɑ uӷ٠YaNKxMg?hd}jif.'%P}r27KZcdq :ZΥZ?(Wס1Vy?vڕjqw#X߽'|Jw܎[+hv۸V)ST抣S y3"]jr?U-`ʶ 1b3ӎ2ӏ5i;Dc[pif>;T^o֤)(ɥB9 e1$87_U#+ ^l؁V[yKr< 5-ft$Gs9۹v?JJۊ֧X=% o8B7*c=hQJ1|6V:K˷"Y7+]v]CJMv:R3Gn24co29=9Ў\^ѭ |Su|q?ι%N5'fFJn1߾杩LG,G>EoЪxjQݎ;\~c}p{<qJΚ[[TlYO,rH+Ys8ަnL[y+tmh(ȻY`0z2%_#Ҕ[rW4o8b+q׷(cHʥJk[ӋTB}2Qsӧ{MybI8X_Fq_\eSoTMښz-5[#CڊU}?ƻNR9aܷ /͝gImЪy#RN]:rv:,o#V\QOtB uH#s*Ba;pAu#ZԦnw*|ּVGv^E.sߎ;s[R=YFTb;xB߭h3Uݸ=힕okmOd㭷-[K ;?CUw*CI{DX*[rx?i('([O%HٽQTeR9XZNJ쉼?+m-n;ɹx"f6bi$eI'3Z(V9jb.Uy37 oImc]m]6C!z+]9-C99<ݷ}_>M q4k4ʪ1VZ5cԣJܥo[Vq >OGXƴdG %Y]ošvvF\ y ==>͈p:}xįڏFѴ{o+:3w^fRU,rU(Y<\t}y$W6Lqw6q9#?:֎`W-^?1Iy=t4z/H%--n4<덭⾆'ظ˚8cFUFo>U|y3xKD ≮gQw V`*TmbcH28d}6WedgCsSCլI$#){4tkoGَϨp 5]5{_ vM[cQǔpz9kbKS|Om}碿C [<~I[d`z|̪~˴Ҧ&\ŷGR0{7kI+ס`noīKus5>c,ʬGLyĪ8xd[OV='=wrB#i 7/H8SXbVѫjk~~a)I'^Krx8k<+y?(ǖ1ǩSM.[Mv^EV]X/998$w`XH;J3勃ֺbv_m>b,C8^9RNJOTz4kVf[\yXԑ x?uSV\I-;)Ԓ3U7yWb =MLbӥ?cEI 镛9jUK{miGP_??:9bgTcq]t;o+/yY*"۷wU{WlB3}E+-ytsIRM}5i\21;fE*:cg9"3۱t<ȏZ&M59F'WNG-LuFn;ouGk6l\y# /Wևio~~ɭ]rHr0F) GgƤdީMVۯCIkYmKi3MPNA TF`jJ7uNJ+}wU>%7Dv$I\=Nt8 Us4I4q +ۡ,XW0x.c}`|+g#oǥBW{rSG_Tkw9oxg[ɬƟz-ۤn@qtq\Ƭy~s 'v/0[O+7Kvh^#o俽c]ta'׎;}}:%GJr{ZJRVNEs$lٍ=8=9Tm*rP$t3J/ pp;ی#=ϯVmb#R9K D.n<@Xfen21$~Tª-m.tby.L xQZ4Bl/S?!j8+w#5dtIkMĞ6psy~JȬcL ڻ$xε?gkXrFɽvOX}~W|+&NTϯ;N zl&U|ŊqJRwzO|YxHHгL-9:c8 iQ2V0_Ѝ&ҹFFZղb<r99ƭJc[͌FiyJVG 9uvˉ~2{׵]<<'QFڷ}?mZ%il4j]2K*UZt(#졧XKxYaeT3/ߘ=F0pF5Χ]-mO>Q ZZ~ku_iQՖ5۴&J`X {{+mu3O++}sz^mk,*Dܨ*0ryC. &TϰUY^m?|>ט4F:# Q8k9UtIa_$ݭ}ta~Ҧw+T^$MiR1O.[N1i];{</tqϧōt'J石&取Oy{m(/(lܼw.U$J8k?B55wߣ.]bm+L?| >gwwxxfX)m$7NJT}jK6e^T_)KGO_?M?y\MbHo.&vY6MANH8l\kZE86f0tOԺIy4}=.u^ Mr4Hpm8ʑR+O=0URׂw_ף5+SYEkקt2wZڵϗk0 b@$(צ{8]+S:)oew>پCHJXR18jbӢ֩ZP4?<ORg_]/X.䒸+qxcR05UN˧cS7RoMt>Fa +Y s^viJX(O>2xK}şUXYT3c2{Vm =mY[A$n\V+zv#W::s.bOrp|% zv+?u]v:!RXU4٥V`m<=tub@tu 2ve:~e촷u}GTTvvcY`(>֍<=NGgmr1xY:r߉vm57 ,puxy8i>˩*av85; )th_ ԎzױcF0'dۻ?#߲ե94tF~Ձ?4uϦ=ϩ*5K;NgZG&xY ȋ*m;N87s^= \]z-՝vw`AUR8lkRy%Zc()MV]~x{MSmB9 Dʟ}=VqBp9,qV}_,1KIvf5EE1jX,KտVi쥅9UZjgxUl !Wv@+4fSFQR6q?udN&E& $_zN5TKܹׄKKv/xoO}Ff7RpŃ}/v1w#W,o'OUV ЛexՕ>Wl2lnֽ,F9ԧ8; 6T*Zion߳wA֮Lطgp̥K( 9A_%fSj)%ύԨMky6fm"/x;;2XjgH>]ˀ>e5UFQVWmZ\\Zns!>*ET{yp1 / s^3q։o}}VѴ(f#~nx}A2m֎# &vGx{{}NV_ءpz`^= ~{a#"]d-sK}|svHOns|^oeͯއV3OקIS&{qꉤ0 F]dFF@eԎhJ:yGc3SjM:RM6D0Hymc_GN_ՙS,u(%g¹>1|W:DYm,D 8_"1n]_zV׾>ET{`l7j Rh1o]S֕lbZ|ϋ~5~IoVe2\+G#Cp:ps_4[oᶖzo`r֢]ݿ*-{Zj|m/#ױVjbvz {9nYv彾/ZuKV/qrN'rp#d;SI~=^߁{<% T-[G}=_+ mMo&ɸ 'Ќ '%HFRWoR6_%=/wIͮa}5**F3Њ<`K^76oHºr;r@^CmB2%$F֚7k_~QxXʵw{[k]5Mr~%a_:[uNv Mwh]^qۚR-N9$qpѩݴC!rQJ^:+wS*t"Q7s!ۙ3|ÜW^JO#UH֧F јyv_._8[^[Kd A=::yyrq&w YSllۭ*|W횛iEsq$+tUHV%F޽U(ӌE{jiQ'XBy<\zV_l:E|ɿ녑pyuTid*5=]v|ȳlWi:rxihi(h|cn> j"U0J|6݅4Y6,cm '޵,JVm|^E3MW?7qׯj\z8)N[" fXϽS}K{?#k)]ɎH\ c}0Fשv9k{Ef'bf7ap~^I'qSk{Ɯ-]q=čүԻvQ+jOi%Ӡۉni# P9qJ-&*U(w0@7ǖأ$ss8D)=gN1J+Rlsyl:~Q]ΝgT*qzCjim-ce998SV1SOpR!&jU 21~uJ%BkbILqtpzӔiW[̙FT+:Gu-Je: ݲO&<ܾkG*Z,j VsI4,ܮܜH>{W\h: E:v/mVդ/\0sS(r>(Ӧgfij-Bs+;gCԀGWR}5}-mUKue2=9T.G2 {29={TO8'/cFՐ3G2]q#|v?hF1 O[M>T$BF޼g>߇3QEsKdcʲ "Õ8qJrwf5+J>iTLhlCn'$(捣eB1D2E"ȗP"@GFUW6G 7RQvMo hvò?yT%FR.O=L>TDP* oAk9.+sj8jz}3%ɶOpƟe>uG'{"̛mx8q4[F櫶i3;R&mR+=e1V NO\:th(BWkG!m&l$X[8cӌ%:9h;^IH5Ŕk:wu;XՅXW:*N/^q:*ipIh+>\zF3kIZy(ohڗgͷӎFx8cQ%(YK2}21X^'Z-kNQO"t#cOM&ާy5)7mt[ %~76&am]N.Uwq*R{S#/̰8=*yyGD(>V(͙V g<ָyOEmWpN_Gpj2یރֲF^"RQE=J|si :U*{X(ԊE3$tqv1vq~55f+㝵VǛRYI8m@[h2kH~Wj5)Qߘ+#f}[ҷF0q6J|maN]<Í=xwp*FjJ䰕W%U5S~ХqqLۚEN6y'ێWx㤢Q@Z;݌0[ʤiTM +{)b9cwYo~t3n,dxǖ~ULEH;_iR2nm:qQ{۝Ҝإq/sҔLS:\Ԧ:'1USVNޕJTΏֽ iCn_Jڜy9?)v;Qׯ9u{ocxTܚ[3-*rVtGjFU2ZnYq3N*=c- aQͧemiVKi`F~T'ˢ9Ni4Y v֕:ҔԕJSrxvVkmܖn?k^J*ɮWZ%$Ʋci d{*8IГҼs+CrO< ~k{5nUqQWi~^AibUYEehFb ;(_ JVmE΢]/iHh AޘJ{hE8VO_CFlEf261޻ihy0띖c6[$ 9Oz|?c6dSy1vۍm'gܢܲw@8V$7Fq0Z_:cT.Ƞܜ s/y+9hԜeˢVw )Tv z_nKݏ*3**K#i ONiF2n +JoeBլjӧƛס(ʜU__"^,-[`C?JTy FQ[s;|I(HyF~_jFRө$sJp.@>1prd)$V7|#['!Jgn&r՗??ά(9.~N;}kh7u#v9gM2YXgg'JHQATj͑ydhG͐ 6{gһhJ ӌ!α Ͱ8g/Ӛ1KsVbTFTG?֪e*7 K1#jηߩ͡Bk[Ti1rMxBONK+Ox-i$͐A4eNϕ#>$QY`'q'AMTN(4Я;!b`>+ TZ**6{2PB#&fLgx9\NR^IGey-rc3?=v_#jqmrnWō^A#g>د".pCtbdcOVصOVheǏPr0NpFyRP]}lOg}IFO9ݽZ1YT5PN}$^Zɮ oԩ$XH-t7 Q#'>ʔK}YRSnZ/?#. L2~,y OZ%Sپ4=%)E-ʖ2ѴbhOSO=}WTjEAïm:Z^d$Y&Vi#nu)k:BRU)YZVMZO4?k;HW̝78~^3:zV&T6޺tGөh-։#Gu<6w\U%(ZoЈʧ3j֞D:@ 9>H˿ eiFS:csL \BquY}G-зi(f26j.j|:ҒEq,ή03 Np $O7;rm^'q}Ssc+Gqޝai]VNrHYQR6®WVFVJ49f^Ghʚp\{ʓk6;Vg*J>ϮmI+ʌhaw[@tcye+3Jht$ݹHoQkbS{k[j@mzG&q\#Nwzzq;PF$ }3`\aR5ܷerRg# ,xf Yu"-ꙭmyIVn~\ь1R~zKwȍrd8~{񂎇t2q&,1(DzcOL[iIw ɪew>YESklFOy-׎8C""`xZwU-V)́o&!N*\θ!WT%zwG+=YjnA{EHIIm~L$RnK; Jrƭ'ױņsߡwr)S2|0X3}%;Ӕe*kWՙW:ؕLv랧ۥi*0lrJh5tQ(\ĂqxnzqSJ-Jwu,"gY[#nOO?,*.hsӨvWt֮ɰ7"y8=2 Brt\XRzRPKۜ^\p1ZQ(EC CU/E[x]ޔ(=g{hծQ}NxcӴ]]I _#?4dk&/VB3ə.wn~*F7yIs=qd]w/0gld,m#jF'i&T껶vkxQ*n;{gN+{Mw},oJcz+,Z>26PVsy0[8'<z4*6z:B7Xp'ZQ5q.Z.#5}ՙ ]4c)FsJ<+f#&8Umޫd3z;tF,^}[BdV=69Ng8K'w ȵev3(ڼߍo){;:{4^(m./!Y�ՔNyqǡX{i+}Ɣh{X?6,27)1׎بQ{lκ)9E*EYl~:{+TH-:㟴E'J41z|>cQ~C5-Ӕps姷pI.r-/ܿwv8bN/ebbzx$r7masLth9^yb)F ۱<.OjΥ87/NZMhDi 1^g[+RdH_ *>ʹ'*SDrGJUACd-+42A9%hTqNNsUoeQǚֱ ϛޞFCKf ιeN2z t%zsMzKs*?#q OP1)A; ѕ.$$:OO@Rė3W%~v?'\{W,ig(|k[<,OỤO^X'jXJP#5$1n頃Tc$ywi-۹fcykneOlb\{֧JQnnOvF"?y tc Z|9TԻS,ϕR>Lq.eqV8`0{s[SQn兒M\v~L QQF/Elw[Amܳ0~ƛRqw}F9GUG˜3U5Sv ϑܹ$JQ.)CTTx&pӼRzW<ʑ5)tSApV09f .0~cJ0nPVv~e)[!A Y@/Z~%}3yQ*.OH8s3Vu$zwi]?_0JmאqֹjӜH9BF5Y@P鏧ָkӓw~{цu, :F~W' X-N[o>gyc9>o# 7> koBsNZ1nDMfx9uSR.H4#aHq}>;KQ¤]>k̿$mv9_ob緇bDrVF8cҾFqOSa 7%gV< >zWQSIɣ[EyoG|3Q)TW-J\ש[V4Ya`ߨz619Dˡ>fՒ6c<0lȊӖniEɞʖ5bd#s砢eSNTһ(è+cۆ\ʳn${b7/H_Xӽ6 ϗT_2?CYH?/lEEJk.e-wĆSw/?zӎO3SZ2(% ~R*CTybH֏v|;Izz//+jJk3e'ֳkD(JKtVi$bƢ?=9zO_2լw2l=AY˛s/m%߹jFԝ+38wu,kMUK TKss\Xi0scvj=tBm+;2w_1+ʌ#@ϷNK\5Oe.VE!F9x޸iǗۡNеgEhFot>aaw*xjGƝj33>w0ۘy|L{ZMN=9T*wW wl+bv&H;cEIu]HH|ߙC=8r7E ea۾x=s֢>zz~&cR1/;Vw4m >ĤcCXXŮ&m>[s.¾c.O>dT*9\9K=v0, R5q##dg5e(˨uʧ"{%m]]kif+)hԪVNFg>}X|By;(ƶmkcϥKsw}.Vz={|eUcӢ>~GaA8lo?_|#?شmc@)={ןdtkW_D3JTQʶz_ UCrK .מx~=NI%+/yS(¢+lcд>Y>0fT˯rrIqǵ~jpNn·CѴV*.v}sF;f':3 MKI?޻ߧěvU7^XTQ+H⧅^{mڰO®NI?OuVGszpd+bycN2ӫbRrR*GmKFc>z4%6/Tgퟴ^iwW˺9#I] ')$x_ƹ&.g&#R1X9 lᜐ2O_Y*u%GZՒm{j_nV6a8ZEӷ֢xZ/,-Z7tZ lpA$zMi)7}97'S#iVI>\ӧQ19s4TykKhnQ_屎`ViZrR.XNW鱤6 9im;)ԭ*jZ^'񥟃Z 2#2WNO'ڶNSmu:0jWڿ_~]VyJkxdUbIcSNZ|ǚ`Qn'x2xgloIuoqcq gsn?#*J|%}]xy~&Ert]5wOu&XGHó׵pTqwwjV(4FU^>%\uG\ :d vʗW mN%(\*6$CjiJUo6~"]R)]t:%NvﾆvQ߻q*݇^JyB~J6]siȫX[V>ӚD匹)5e,&B?̣,=s"G)txʥkksݷ33rXWTOA}V%roJۧb3E<<[kmN*yV)h7>!UbO3H ,UK=-gu}hz?,<2+ ]ΫcۊphÃsIQKݎCv}=GgLXYXqOssSTosQS~g2kvr—!"Y9#o$מbU%-OSx~y=WN;x955qfiEnIly+Sثޯ{9DnsR 6$1-mD˱대8yxžy7=UA5֝$빥۵a &O^ZկsrJ5OMoC"6Ķ{ _QY=?.|q]NVe!`^755*T+j؉GwKm/j>[^rkJysIz;_NfI|+tܢnRIU̸ʟ09]WERԑd2eAkƥJk[Zd]ƈ-QJj5} Ik/#W҈EIY!իP_>ׅc5mX* -٬(.iNQDSZG[`9'n=yWV_JgW^N:k{ZMsd{ײSsR."¹jb"_Mw%5ފ>G_u 9dYfxH c ?,Q[v;*TJ5!g\ݙ"H|H3Fr88W -ňF ]]4)Dho܏ZIUi#Qc+zE(pF;s}pk"G*Q~wķ cg 1=OaNPos|ikFB7-*ś$g#q{ѷmi,5h}uͿ!Tuj)E^s{:jSvgnu+/r9[SENv{JSOE]LU۾_-,2q܎?^>Ys&姌u?|5ޖIxmYGRKf[ ̣q+m ovSN[Ke&uk^ܾ$a_&U#xbK<|*ҫ+TO@DzgtI,5MAD̑QA qz)9(/s|W6 #^fα~\03_c%˭v MF|'^o$8wv)҄}-f\=Gg$I "f;r0\~QY\4zH[s!8=x8k:oK4WMr Cyzn.V6+iH#ޕN,]풧Ȭ]l&OL cuv =3RIҩ-dm}|Zxu[ނQ_~3|O;iZ#6ހNy=y[U=NZz,X),9n5q|cR2B[uݍjHXJotk{gM^eyX 'zo(ǾﱜK_f5/͸P<Τ)h l;O{}H+{%3+me(pJRF8|4av縷g9-dN<2."yNJuUXR1E'xAneR +-e#-+J:vߟ唦gEʇo%BBPjJPև3Ԗ {y_93rF;'t^6CKZֺ2V˕nom~fbܕy^aR2Hʬnh5*#,d2QWe0絙VkysBZG$15*w4*xXI6a"o?֫[iy\nԑg2(,(XA돭ke6R<ܲӽ۫ra}ZS#XԢw@[&9<QN2Em咧jzA&*\*\KU?3e =;z(ksDv@5Vh5Fc};Kx΅vp`I#GױVg6*IE%ͪB,t Qgg)4K=L,c*sVU eݰƬv󃟧nGKmJd]uKbAL`c0=+<ӑbX&y!p09}Nkx1F1K$bћr9%pG#OݔwZRDr\Ps#*~Gn~XHfk |ꎳeX.o?Y*5#R_ѨZF,FahPmNSeJtE jӷJh]!2I  cMV_2)9N-ڳ*x^GRkYszВLn:Ԑ>!;S*g?AW JUWcMFZ3V oi$9 ɫO,?.}JqH֒ f«cs޺)1QUHhu*7QҷUg$u>&5ϻ+YVB3E k*Q}-Ͳ v;.Wh=>^krF5{kmn=([qq,f^ f'mC+ îӎ:W}ʤ]qVM4# GSN=pGֵ(i5kgܣpIUn9uF;Gwz\DUpj["Xed[#<@ulסo~VZ\BwVqJt',8p>AU*IE+%:{EIIJO6[GK/ws DeJ5wW%nafy2c>Ժz2 jZ=u i-l%I]~n+2OcNckiKHB{a3x+(ͷm_fTK~#\M攪F6ʼn$sִ}K}OFiS$в6a3rIgYR߉(oj6J{-?uzc$c*q.hNЖP{]ΗD-t"hǻQv}+9NWE奍+MuVi3+/^sqU(J^[ncSPIK]mƵjFa9=3^1OZ1;ܫM+G6*FQ}1]qH'auzđxhIk N[RTjImA$JS̓̌Hp{Vw")6ZͫHoR\/>HcR8Jя%ұN4jG߸} $eW{<;VOTeRo"idSѱq |8Rƍ6*6wt*tR5{0/;\㎴v.^{wO6f\LtcfcNԻ~=Q`ò99mEr>=S)@+ 5N/y=Z,Oʯ4Ig<]j1)QEPT@-s}MvFͨԽ+-/)EHffP~f2z}+y>z+K2"}C]\ɽb[Ɇ9!*+F{pGr vB0G2x۬‚=߭km͝rQyhIc}YC=緵k rR*4k*^l\1a¶INnG1rOW;%;G~A(TII>NJill73ns^)r[C\?/j]oYӭdIG%3S,A9OB>SDS&__8]{3+-ծ!fI0eǶMLhsԴ]jiR';7i#}Fۏ81Y#ds2]2XJ54rӢG;2{m#VR <7qqgF2nyV[}z_y(R~+r\1,sp(ZFjS}yƌmRرehYX>ӓiY'*ߙx&TrYg<=:˧Sl,bcN7GݫW$*J3P;/~r+zub*v9kw.pƜzvlj܈>|Sj=ccQ_܏huz+1ɹr@\߮ktE{J7gahX,LHY㞘lיi9ZӔ+W};gu|ofmȥ|S O N0r׽^5aR!?f0ہ d5_VXi/#277x᮶:' X v~#%ϢWQ++]/Tlqa{c):|ר?l{[]WKI渚2W&7^bs[z%؟e$rnz׆L~-+O+9~jۻZg=m{ J])~άvQm ?^׶+Yy?kP:Ӕcg}_04yXG$HNX'*2Jm~d_LMw(I ,qYI Ӝ+ɝUjwkqop aZ4'uB%ZhnxgW|5ϗ4l~B$~{T凧:jѽ8iwP|c0#[v]֔hӍIVboI$$$ILt}9Fn[\Τ\tc#9Qz]n;:CnQQkq^/4I%Ֆ)VG¼7q|dRU9)Y%*5$8xO-u qL%*{W+4?vZGOO#B;{;m5SNOdcQ(iN'CTBſ{U2#*y#z48n8 6ڿ[FsFrKEn/e͚kuc4b䚕ݭqE/T  FϡjGN:ҎHIu>Ҝlﻹp}^W656xR^>#'N[zԠzZHY][I&C}N:|#+ )=ֿ֧|PO[.]M3|3KV{-lHdu9c>ǃׯ)%y 1FJ]ϱsþ#GY%w˰;dsӞ:}z0\G73v])֜A|xFk]шo0s?IF?#x[r;'wѬu pe^8=px!-=LiRRbߑ>Eۈu.|;QFrHQ*4uǵEVj_y-S& Ɩ9MLbp㜆=q+JY=|j2)JWmzKh$2q'#$*I+hk[NeZ.wGiY-t|˹J$cXrZ<4ۦu=l0u$F6lpzS[_|Y;I(B;7؞YYTAq4=j5=:Kii33intH=zqӕ9IsO#Ԍ]SW֍%Yq!R>VR8'' :WE8Gr%%spE&IlolkN\dtF^:]L +n6=澁t&U]|-LJ=n(ˎWn}Z5=Zu*8T,TDw}.AУϱ ˹U]ҠXs'\IہWL+JOih1u_Aՙn#uw FxO [X|L$]s"O>hdVG2q@6yz1nlTcV\Oy ak_|._ xN&hv$w[N+4?Z8aPfނ<#r;cz=JrIwO)צO-wK,W^Y 3vӮӏʚ{v-sU(=Vs4,}=kɤK#8aǂJgc,.lDn~GxRTW%n.V2˓@\{<*rm>GQNܥ75{Sdh[\ @=y9>VJuteZ[{r~#۶H䙛I 08 `-UZ=Q38*峵ʾ㾓At@ڋG&<ـ9œq 4bJ7}_$6kn?NwGmy,V 3rUz^JtuqiO+^'^el|qgo¢S~ 94(xzvb)ݞg\ukjtisajՏO֧M6u1FH$؇iS3^v&JwgWuqu7OeФ1c;AUP>@>7^kXmWME۽?UƯ-3.Eٰ1*GQ6uj8U0S iB{ѣP>i!8<}q]إMy#.6q4:MXNƦK_5:![D%$WZrBGnNrzaܲR|ȥwӿ#kX{}z1a(U1\nai9w< +N ۍhuak^~?!iZ"L+<RxwqXg'.fY>2RW}^=RW}:u$+boKNG|"l[JMr':ձҒzZ5+YPV73"H%ORr@'x|==Ogq6mĞ(~Ʃơo,\ xn|.GӭMs|l"`NvZΕ5+5kTJUI5 PHdU\ͼqr9׷#>ߏ׌V[9S:M +lbF70̷Bڟ1c)AE{ݗ*]cf^D  R 1 `Ml6A c-8؅9]4wｼfZF)t8_>\Z jôL NqnFym8;=ZNIFRmW@co/~j<`=БϯMa{H54w]s}bz'}kC.\BorCϖ%'9֒RFVN;vݭoc RU!eeml}SŠmk{Awl[=?w''zW m9# 1ђ}vhn߯S3,DeRi%[O[y=]7?Moq4cUr=`;StU]Z-ѯ9I8;uVVz|t~.\xƒÞ7-V wȘLt8lpx(I.z/DqfLj-uJֵ&#?SS/vN6MNIAhO~Z2`D"T=Zj5w~g!Qq7Asgmi-W4 Cs-®HRy~hr;e*j{eʳmy?OzpS;f6݄0픍l$dӜf+Tz;E4kiҮv00;tRZG1%C)+ ;cc ?yS7}^yi><|.#P\?Z2)xFPzZ4Q//.;|TxcyQE8IZTiSёNM6,Kʄ|UQs5gO5JK#\}("oOoOg7Np%e 6K<m&fTr60N~cOԌƟ.1F/xb:'WeHc$`;q~j.ZݢH/Cq۷=kF.ڲ#κh9 ,1>b#z)ɪo_ Ȉ+H{[*[o*C,4q*8\vs׿^4"};owqU6Zw zKa*wb*sǞ>3]Ix'#Ӫ.uxkr\D6#,˷pP?3 sSGyQjVt܅ I#z뎇YniJ6}vĖS̎NZYH>?ҸjsFoNn7I4beN  Iy9ΣRsgkϜ6XwI3(T*>YBO"ɥ\yVYd˄v8 ddwri8Ч'*z: xO9pwÂΤ9i1QQXK}]ס2L醛k&-ԌzW iFQ|IG)j}^ydG+IēNI+hưq殮_hI:ܛ_ݺ =GAk㈏1qku̱C RE οxNND%BTDfem0 :,9%FJu6A.E?Gޫ;)sV^EHT}1gn$p7Z䨣)8?9:ҳz˯,t#'k> N5(ƞ0J~~N1D: 9ʳ <*{Jjˑ^ݼƝkj,*͹c+0qr ҹFQW.iMY7ol6[ĿL|7`d5Z0%;j~L> ?#FafV$<ێ+D%КkNqnw=ՌJzQTyZz/(.Ŋ1.&ta\r*_gRiފr$[$О:{-^hLIMܭr VR62? O{*}EsF)=;T1ģjI ~7Nc)ԏ43ϕe7`0Boy/)T+r$K8Y$AFxiN<)$ʖs;\Z9ng*~IX\,걄_.GS6NG1ֳc$FY^ >I"+a0=G޴U%-֨Z eIfJ+\d}k1"O'[ߕ# v]U޴Ƭ}=#|Ȭd+#s§Z^w"trbXFH8>b"ner02 I)zd2tFMt^}EG}⼚X{eJ0fچI_mtFz" #sҩ+>`_RՐqߏ%$ЩT'mZ5WdJRcΪrJ6} QuOsYkS[zyv,SZ*Ƣ=+9dW=Z q1UFޟh&psgYS)VvhւU<3nZ¤'<7ջuίFݡVLC"'8$ d 6yv9sJ߅dsS暶iF+XxVI(դV3ך*B}z,,cN7ߙl0KylF8#玟_ez6}Xrb#R $6\p9N+);߸>j1Vzu=Lk 7*g2/Q+ogR-[e̔=gxGjF=Yψ{JZu"2FҮ$ p:s]{Rѩf/"󼶃oQ`0=kS叺a\-[]O/odeH ؼAYҧNvZNHRߟڐRyv壌trץwճ7$8]$c]z:*\GT8*0ƻNހ=Lc(ʮ%%mm. 3y :Ȼp6A=S'RnƱio4\G ʻd9:猥3_mZ\oM}㯩ZUNS92F!uV?1sϙVgD!Rwb˾UfTHǮq1 T6լI< )ն:6q5P}H&r2յ˖`=,b:tObe +錒b<ڝS}zci[>:*D"^r_ppn2;u's2^sۥUIb/4^R nrIS,cyk=xLחR'J˶r!Ʊ!Olcfw'e'NQz߶ y֯t#:V1ֲCSF?\mIg=LռLUO8=,K,[$yWΐ*B9< +V¹8&Zxl\]4*78ǧ5<ՊKMQ#AAO+3W(FOZ/s5}tv ,~hLn9\doo#͍(7eao4ʭ#$wtܹף׷UPI㷢Z~a6p?Ê44Rl!QtҧރX _;w=OJs֭}?R.-tMT+#6̴qӌu5J̒ tהb+^̎tu܊)?wQs:5cqRm[ubNUv!Y"# 2Uq\m ңHe.燊^Ds—m[gXb*C 7ybũ[ddL-mcfQ2]ʹR+oRkQF59ԷE¬5ڼROrSixW/w%#/ݷfLe48A)}kZ7rsbLIjurU9j159㪒őܭ?7^GJoq/2iT- 5*ͻp:TWu:(ՍLCQWVee"P,9=G? Jr5o-t]XY$,INdRocԩneV6[vB=eo1N%"}blCB\pp> ҕ>h{;,{v Fef@iJiFLQVب'ؤEY8y9׶VZK(Ub>l~tFc(N7IeSrGS? ךj):˷ȤȲ8 UFU)֟.j牾c;731MTjCjpԣqepV7ƬwFLzgkGJjF4ܼXy$@ 895=CЭ(rI2)T,wm;k8~㒷56^Ӯ@+-CYO;EQwO[[X!f6:gnp>~k)^dөR7wл lś,oV8#NiܘYZб0˷ £8P2NN:gF+Zҋ_2&+ry)&}cX= ;+jkC6nKX}:C04vɕijmFPmm**68?α}W+(1iwDdTi ;xFOPO)G]/gv4 "qs׌fE"is-KV-v*,i\tET&TK]ݝ^@xtyTZaN.|U[2FL3` QQSrjKkWؑ&!;&I'}ogcK[ 'VEܫʪ݃vdF4!k4D̻Q1q[Zt#.VF".iyVܼDӣFRyJIpY'?aEu%ڒ]<C l~}'* SaUTrpG'ZӂTsӞ"<7VɖUYWlA~ gjQ%+s:xVi,؎9ϭi&ԧSz[_SyGm,Ha#0EAtVw3J%5t-WiZk*ʪG8/'cmZeW,0Dt73JV0ip8=Q{G,jIԣ}^J~ΦURQF#q E9m1%w{ٯEDjPHsqq2kzt%af#VRu%uŐ=͓_jBfm )j:if$,|һ)Ɲ9'=ѕJvmGwt{q Jї_iv~eŠw]xEJVX=L=^VuG݇yss^, RN^D9rF9{]wv㑌s]9Vz.Fu)VUzm${ ڙdpOj֥>Yrz8YCIZĞ[nw3|۹mORиӄy>}:{%OCꮪJi]~Dv.Ǚ8.8{EGj7Fee3=L4ps# +Z=bNUiSZ%v7hHae U@LjRz2XU_5Đ\={eUds׆jϖ0xRRO,ۈ&[U.EVT/O7ņx?tTv>&\MF %wG2`#'iPM6Vʸ*Ќ~UX[4>}sB:ǻq\^\1R s6Oo\]:UbCwL̝7ʤᯧ]Tc@=qZ<%9Sk?ԷTsWQ2(Ǧ=&/-qh]:f&foݶߔCӡ:۩+Sci_+uToEnF}N+Wc7F1x*O,G,u7rxXƲIHngJ^wmUU8ht4)splwQߎd=Ju)=^߃Mo5ݴeT+Bڗeg7G$ #ۊ7&4 %Hc=>g.iomI[WtwRN*R.-")ԄɥZkl$wbt>;)++i}yrߕ5#*o67,)e*+(=]=9ُidX؜uj %/y{([! |?p`g-i8JgѓZ\1eުe)s]99SܻjXsDTʙe-b!NY6˖Wvfаh@ˁz^}8s`kiuarGn%`Y!`:-i#MZ w6q󯮣M(J8z\[BEso2v2?)ې7+n^W#k+{Fe[\mbrC SdR켼$ KnbFI?ZOw J_eXƼab$ʳ1m[q8MJ\޼LBm s+bh^Ɣ*rtٜ]o+3G#|[i=*)A]}Sjdi"Im9ۜ{}*yJ1|"[fR* &K-A~Sdt'# ui 3M!MCTe7H[41{,Bml13y*f6esvS?\Җ")KaZVvU\4FbNO<qI^է 8UczvUSmKN[8ə3_yw3F ,1F=Fcuݜt􅹛%L,x1G[^&o7h[eiٕ_c,|qߑӵy2K2Z\Xi ťaz=zsSis_b~ #7QǧNg$;T/St i<$RDd zZ[mvQTԜ?iKg)gQnpc]<;tSNQyPcQ ԒWSZ~5r>2V]F@$>ۛ:BМ.Ta0}~0 ¤!4lj}Q:E""I>Os;NXc+^")F>뾶n:yw,Y,Κt)kNުϾM91cJ9'9|cZ>m]/թӟϵS/^O+H2mWϧE`Kzt`d__#Kn+"$SrKg kը'O[_ylU6nUe \`sǮ{>7$cXiR}w&+yLk-ă=p=\գ$5#8.37ZNdY&i C\瞔i][_xIߧ][i1RO1amFcNxzz9eY[*\vvl5 Şaa"i#QF0:~5R>U՜)ҕ(v]fX/39lcqۡǷjeYǖK0qi6ڶ,33Mn apJ*Rhk}]'ħ>wq}OUY^瞝+Ѩz<\EF,%mv-퟉nvh*ZOI ssѩ;|OǷ1GE)r>ɷEi<aڿ~Oq}Z;s+?-zq5R~u7E[GtЪ=x؂V0aTEJN=Cu0 `=ADZHՕJo?CKkeŢ۵l&6i/p:vEI?c+5˽wvVPA K]/̝9ּL\CQ妞WIj\y`* ~ň:xu$Cz&۹k͕d:*-3&&Ig?ҶG܍HiVLYt>M&?3^v2 Q\J^1FIQ өԩ*m*F6f`Xy?wF9~zyxzZdrZD.iEFzF_P hey:|VLq:qrjfɤmP~-;]c18{+!V'nxk^ndU]<jyjҕo i~b1|ͳ41H=K i$W^FG+{߇I 'ϻ,H'z*觌正sb1P.vҾKiM,rF$knF;㎽ңZfy1K+z>$ÚnǬ^X;Y0)e8 c.xsWtQ+5J$*k~ g4 ;U!8X!QuVR|#m߼t@E8Q5ߕ֧[Ck!9_I#Hۿo:ԕ;{>m֏Z+.,#: nb߳OՌmv? RPnt\eFm,_*xYQk/.jV祶sOzLXGCg8t#q2R6qԜ*?: ]n"Va6,BYqӭp~vƍGDaQkgh_OeYmy{דR3z\'SHH-{&_-@eϦ:w+h=}L[+|q}e7[rNdҾg4֍֨ [=?O~K-0xHAb3d*' 7ta)ӷrȯ&R!6%cъ6xדK {gU)u:Vӌy]޻fż,rvޖIRiI-RV-cN7ڭHy_'l9z9./ N7Oޟ2_ 5THIve&Xd}~841U.bc^u??!|CG6rC$+  cFaZ>-e}پN.4w~ş hwl2*DQC.y㞕?#~=Q|kv:JPK u<9_p4hN1gdihL<#URS6\i;r1WG}[ziv\GAao0}r+jp\Ҍi˗4[$b#fI^*|Ɵr}hg -2v#7͌8ygJ\ݿ2ZTlfV}Ƒ.]"6D+ױQHVΪx\^9=G\G\FٓvHpI}э9s]+-nU8Գj\\Ir;dv5 0A<{wR}90ݼ=n`mCs4xQn&Nc(6Oᗹ?SoͨXށru;it#stgZtKJ`GRןQ\pT~+|Vo*Vlz?x8=.]*agRWO7LNۿtc$}6@梄UZܶerЧ*չc<{ſV=-pFOLEL~<潘eQ˿S0.k+{i9o>*c k13}R~BF:1(cdRVzK NO. w:|n!ګ RV 8#|I{>'T~ݚ1P)Q:忕uk2g2C$Y]Hee uu=)qp|ݷ(;ςYFZ/&nFz@9=kQ{9IZ++YY$CӡO*Pj4{4/;`?]UcdYS+ćOlh̓V 2ZzD7Sr׊aMUKqNߖZot8A2weW<-9USY`劧/3sB>@e]񌽛nLc+~h7_nR}8O)R}XGCԼ=mLҡgS!OR2sҼlv241N~7mYg6+E-s{~_ʺ)b\W{nwo[S[k.#vG]J}~f%+(t}AҕLMk>?;TPotxRW.~ƯSs-qaG |Mt=JxZx:Q%?]m{Cww:#1+"r@A''#X0Y/tt󵯿>k^ h59专Xa |st>?[I%['Iߡ[u!r>U^7Z,Nc9IdzM8ۓUZhޛ7sQKUUQYg'ߥn{TMb/ey'"LzuQKJu(I01 /Jҝ9ƛYԕӹ' ojFT6мn.F)T3J6ב}d%+HO+׊J.-*oNr-5e𕐎E : R9GViN{$Vm1E5qVG3m6Sk}۹ѥ¦᷸C.V2q߁IϚ*:};iJŭ"u[?E vM7I45GCVki,G\E$ܴѳn,FUb)TUb:+G:ZtzAkk4V,pnSut_{O2k[~aKkW=~:𦰢kVḦ09ߚ"+vaVH|OеnlZIoa.)=#х?cӧ/u-$vp,E  dHyѦFPi*m\yYLbm>0(}ORTq1)*Jpc W\^k,I?w۰H9ֹ%(ߧwVJIǕ[ulP[Ҹc)FusJ0{+2#ps'e._S:xҏ+iqAh\yFeHu=q]zCKw{< <d*==xCBs9{xl"]FV=78+ӔOFg[yJ%cnj?+TʕeVTikHl϶kjQ5F2u+YrҪƪ?zs\:)#(TJXTGcV٘aB<`{ڰ^mt;a/|->l:D͟ʻykSJu*Qa^ϺW OrOrqszsv9#Z$}nHpʆY6HwuoFճXySIGH'*ܳ9'WciJrˆn$'?CӦK8KixI3};ִe)SqH*؆k?stǩ)E{V]=Q?\qj.Oo.+,nBbqʵQѳUb$B*r;}޶ykc}X"@ܧ*{~VGcz^닃ѭ_B5K77R;iNoKDʣVY=*Eɍ9** ߉5}Je;C_166oz/֔򹤩֩hFR<\Hw #r+URQn^ڤqWw}.U LjN초%)VvܫvM%,Xn}Yԫe3\*Wkm.qО ڍj(IT¸GY6dg2"NA+寘cp?٭ӗ4vv(K6ۧ˞q].K_I>j2NBc>mďZҦ*\׹ӌT-VMy"Hs>Ɛs=![NO FonVa}hܶzlZSjNXWaniarX݁R}{F;comE7"ӥkmɵc61V15cRkKBb,1+t쿕kZ[JuE{ecjwqDjkQݛ*.qߥ}.0WtEZd6S/Oƹt;0jD2 e#RݞU+^SllrzJ6LTDѪ|dcڹiel=%as XQGL Ok8Ы$r$E{|Uf;y 'ְR57"F,d2rWVq_/1ܛfݱ[ְKZQ~30єjMrAy̍!UdNzrGZ\s0V.imQ{%vFiSMq5*NkUTX%qa>W4JNWƔFe:Im -nxHBW{γe;70,s?m{/\bSW9%i e<t{T*r.ZqooQfBfX9ZF+ԚjV v6Us].kt&ڍeu/aݼr03gSzr:iӵ_u;Xwɀ#u%)K]+_FSgw-ӵvSu)G2׿N`m] srWLiZS䗵܆M^8 2(YIzrO7R7u_!˶Y)ePvorRZFcQ+id,HG7t5MsMl~DNum%K[/Qӧ GӱE+k -dYWqs]T\e+SjQON^էxn9?m~K;~=|HC]9x}U5ud2\/|ŐsIE9BGay?-iC1 d cL,֦j.9Tc8qw#҈( jjRC^\[<Ed;jI^ˬ7'df b0JҪZhi'uk6Ў[HЄ3|a#~ǎ]H@xsEۿkW1YEXrq$ w3W%lvʮkM=m;G0eϟ9MIK)cj6FTdB ¦@$O:3m -3CqHgc1Q|bcF5{]Yvwf|n$_'I9n9jxx|==I:Z_繥iA&ۙ0>sҚRwgu5Rtl1}]9MVJA9Lc{9J׺;(ʝs/Co|AC%lfɑaAݰ[|ѫC#(+k>f&@UO'zzuaԝU8o;ƶH^alUTz֒N.e~gZ.9xle)@F6޴SuݞQ|ZukG7_.bPr[$@¢B.U4.8ëA쯫=;þ$K/$'ޚE>X?SҺpuF=XDc.iu~d~6y.a%I$sH׷)>mڵ: zsm~*k-.˷|rGG5ZtJjңk1Q^O4`iI|~`~?N.5#={Ƶ7[ N8 Ǖb6gQU]z4fU+;2O;##iG\_]`rZ~Go᥽GF+y+#?)^5ڪ^#x,GE{ǣ%HQ#,ʕr} sڽ<:npx~m*asc~X4= Uvcq*zNn#S:U*5QSߑ[ {s x!-;4̏o>gʛk4|#,|ΧBa[[~xU}ӱkɯ´I^O ZVzG¯y$]݇L O?SBR:jtu_z"a-ux􈥋u_:?u>H~)aܤ]`~U#[V/[ZY#fwuyi~b(ʟR_%{feU`U  $=VjZ$2\ֽ,QFܫ [>5OT[j!ϚUt'?Znt=9T\7k? tw6-Wl0 O5BIlwNT`owDu(Vhē2N|܆b[!\sN_[?Of{4P{}ڭO9I.nVo&i#)Eeד =1f :vpXwiu9 |W])'X<4ܡG^qӮ9XSOMtrb9wO޾z߯uukmLrBgRDqC1j u#ͣu#'$z}E-ֳFn$+lG? qo:hs׭;Krd]YDA=TN1WV{Q{7E-yg]BIloezsOOo]SqtbN[Lƺlj|)<3\Ka/K =dBE̞|{KOZz4B2ݫ3 d]<>iEx䛷7NqI&\̒,&Bdsⵣ}Z]ўW>~[>{HQ%IR4n8Nå|3[QWgFRzc|NݳnBY*H9 zqJJ8qK.kS<7pǫK0y\0ʷ<8N 0oq+_M:q').]FiVwcyŹY|X]p2pAv{',R.$Hnk_ Z1uZmIMxG]wK]D89z㒽Fy-JPvǧMRvN)u|[M4Ͷ=ĂYpd!WڻOfA:quL=VӦ+62s-7#3zxٗ C]~P8 #3/SV۱%Q9I)-/ݏHǍo- t8i'i;G#G$t3)ѧ,CMǜ޳-q3d|iXIߧ` om_-SpΊi3zgһTTGw1MN>G;5 2WUcb 63z%:)%My|G-fu?_C|Tt}6I&0\y'g̻X\qk[tOMӤIcwӷ5Su*zh|콍lBKSnZMUqږ"w);vvF4-#\=56?ʹ tR;J)ԗ2Ts~Gtҧd%k:mgF|3Q40[޾Cմ*ޔHѕzOw߅R5cUgu WTX&EAӊ-J1j[LU%Ku~g_nuK;MKgkUCX FrH=4RZ4!cpzsk=_-׬{G::"g#.<0ּi>jnI]?{J5ɮ꬏_ꚕf&Kq8Si# 8m15uM$ܟLD*JӲ=᧋5;4/~u=syM#'\ĶBug*ݴb(ErkW=|.9ƞᄒypF,K RN_(ʷ,;Tv~<'Ɵ`׵׊I9 OPk(F4K[z_Zp]:5&%k#9Pvdu3ؼGb''ߩχ;h+y2g(J6N/R+N[85u5ZonWEIjhdatnyЦk=N\Vmi~Mߋè[יc f3p $| 8 [Gcx>0SR{>Z|,S5Xo+p2 `u;~˗K^{o蒕5V}R^Z?AҴ'Te[ A֣)SrvZ-u31\c=Nz 7hTެ$ck):|ߵgE5*Sj#%~EoYamr`Ȉ$q@$~ƍI.#|v80R߳:Yo C $uUK$$x9kաMY~^K2> V2\}__Z~nHa{kSIX+T֗TnUd>zӶ[/;jz)vZޙv}Mhc!ʳ+*A9}A&6j8q5()ԥJo+nGa/. *_n`voAy,.!Jn#SIn{?h$of[w;r ڠ|O%3նmFuzγlDp՞g}6>ӵ[@' /U>5ѕK-7x_XPy[l ۘ܎z~u,;+EMH]mhf-8#\c=r Fb}K[^\ۣRy# ÜcNMW~Zz/"nyW_:"iNW}V2('>=니ٝ+cnz*ۙ|=s[GЌLˆ̦Q0bxlg֢*=Lde˵ @/ڨorJ>MEi~o [[,6wF=1` k2byn]H`'}Yp8}yc^}H((X _6Ff$zEfӕtRz-#3[S|ZH| %\F$oF'88ڊsrKbYr-aOZ)T!++tgtk(^;ƷBǴU,u}x9#ZIjٵ>gH.mԖ "g`QFBfq58Sn;R~Λiiԯs 2CMՕlJznmz͸F9p~*"m4\lIcU|^k+EUd۲ȳG$w.ܝMgXΣ#J~ҒQ#WwWk繡l$BMp'#?qcD3]~UUF̛adUUQ]t'rU:o yeh$_Sg$ս8ӍK-4E] Mf=xH#Dtӌ"*J9,kGy'?Lw]\eҒՕ.-)'hLYh =)ZeW3} 7,6EmOg泌eRzѩI\8^GLBxӒ =J{2QNews+Vu*ZO1T,3¯ӷmж1ٱsSJ*-[ɚv0ۅݵTzVܜ\ڜrͨΧIHluϵsʜ'~4qr'KZey`s$2'#8#ҔFFsUW*KwfĐ9ZusvzU%:IQCKv1êP>r3׵v**4t{mgեhXh.e p,}[s`< J+SRUmm t,*jUFr3܎qөu{]=װV5NO}/KzW۱*u&Mwd:݇XBdf9QJKM4:*Z-5I i?u_Wz\AZ[Tg$:F6r$$U-HzWB)GSYFhߕ-5'JV ۀ:gTٳ `g~QQ6'taU(rFaRobلo!RrÓoccFMsn)S h/Y]Ž(Tow2Ê\/VUE:XIqL=F{rƛO 4u#Y"x.$j\*LEc' 2e/{VKeqlᛧ2 uk[<{6HU'qR.^[jgaI(uW.ƫ#rrw`dJU A)SZ[K#0OY=52$Zd{Jek]v.XN6꼶V\sn{[^+Fw깕*Sm-0id L2OScvYXGD儜Q‘.Keo=MiFw*R,^=֫iIuvY0OIkWZP+خnX_3_Y0@,gsSs1SZuMing ԍU=m+j%´r|ͼH!de6zw#ܴ~˗_S.IHc,:ҳ.o᫧(Z=Hn(RUs#bDǯk?J4>Fu4zdGQNd;M=<8_ШcSV{Q9`a('W'$X^2wt^w(jr[HC]p3ϵy=*Sůh'hdRقo nkR'^DQO;ϰK R7ij+#tPC׊RKo3" ̝/c6 㞬1X*Qd]lTh9-OԹ q+D~f\kGsM֞/^rLp9Ev[/\=I9]%~JvG|Io}+jx1h?66,REa2`#w$ OJ~Qo :rn>hK erd\)<sD%[o:0窬߿M;]62V 6LޝuUʕKEv%*w[*ȁG@d}/mH֕JΕi{ͯ$Av>s%!#88=}=`y__>s)a)+_%̓FV5F;,'9WZcK{JI~7Msnϖx'x9*urrqo̡evbGp*nzslEx?cI$ZNKIΠG֪8Կ> rTe?z[^ 8oG3ʟ̍z1ZR-KB$a$Xnh12!^rz28Y֩Iivf8֩Dֻ?}A24ߺa#kdvsT.> H˚~zylOvYc@9Q=^ktkQ\}o9qOҊqlʝ;_"!5.fw?ii֣xc#F)Wo{,Fnn; Tק`9UgxgTHocΑj>X$ e9*JGZY4nenTu^ZTYjvJaMNUԐ|7FF@ל2VϿ'XtcV~cLQeȩ~*Q>7Q4nf[F|4kF,R*mHжӡzk>D+֎ E_#]Xm݂d^{WgDkF)i_Rqn0ӧ)UURe;.VXo,GFu^KW஗Bdʖ;?vr0kYTcIϕZR?-;hՌ*B3UJQzMzqIe1$uusA7)C5+\%a#QNzӌaQm񬅌2#k|>@8(Z9(ew7rIㅅWt=;hgm_K[,,ۖm*jә9iÎK$u`śJ$rҔrx+i`i-<gN5uPKw+Q}+U9]o3RU-ec[DdHOp1~)| ֦Խg0GkFLk_eDcw/j͏ɖbʇ.3qQ}䕺,<o4i{ 2I_1X/-HZэkҶK~ηO~2J1BI]{ًqw*i{USQ]G0Dfe-QN>Ogfi$ Q<mSasy3O~ \C_oCN^K2򼗮LX6Zq*ѩN*zy2r$60xV~I#_FZ%x&R_̏1OrK]]>[%4\b~8{>Uix}b9uXĠUa׷oƳ>m J.2FY$\r?y/i-Ԯ (>$ sӿnW6:Q[Mٯa5\9iZ6Sۯ).Rj-$},]+ȦMzQtan[NZ-mGgl"Ffg'rBMֽԆglˌ F?(#m: }z(3Y _f ?hG{CjQ(ٴb, $k|p +)>KS,5Jm_mU43~g9ssKT'GbΤ8UbR:ڍ>_ur֨iFԆQbHŔkhF.M#S0F;+6]>5(ԣ%oSISZȾ3EIv#N1RoZB+ʫX]Os]/ }b/)E?ę],N2wԈ,6s\+/L0<Х_V7R*;]23tTbpT*ݒسmp'v=뎵9:nw4VL3m=V +;)=Q *+:r0 ye& LrBƠѪʻJ9#Vis͕J;CU$#Ws~yY8:v[!\&_+D(!H]Q8ԩ5fڏRQ[s_Oҽ,,[*A֍KIhn/̫UUu:KMk##w@OUpɥv4FPU.-|Ld2—2~ ۡm^⺰ʝH?=l*N:rl28|vȃv_nդF2rKzqRN~dv7E?٢tlY[Ώ;=G8?iV֗Bqjm#y|L>tc$|ySFH{/9]9qVq3L";62I`o7[#g^[[Z%[EY?GҌ>Uy0uRu?b)Ku7\`8cRRM J6N0o-nTI Bds&ioO^\ܯl<@bBï*VUi^{Ŗ5q7S޼V^i-]ӌGw{d [Ʃ1-u玘e-]ލt3ԖdMvco$3K7l{\I(V!pb۲*ܛÃګtJiNISfoƹe'cpK۬1*VV}*Td1-?h_V˦de$,q+U%kŘTN5fMq+lFd ~ޝrY3MCӭh,w3q3X:KcjTk-&tBhTο*UUxҮTvNKeCa+U9Ep09SvƟ7#uZ|q"4 Cw8N:gWuku.nXźGuKNlEIڟӿt6<[ˌ+){WZr>ʤiӧ=핒vƧ9<vsU kXeړI${IA9Z--ɭK$Z22G֥҅8RѨ7F9Y N~O%x֤O:k9=Ittu&RN$8ozn_CUN,{8Ǔ٭Z}IpБ>NIّg'gZ[ T  ySEs4.-#rˑѾRFyk쮒0|.sev@ZZ3^_aiDX*19ڭ0>\^SFJm߱$ybm7V8 Lg*zZ*]YhwIq*[z[Ⲕ\QrTrDm,m V=xsJ1&)Ծ2v2sd`{q\ܵ'f1QjsOЁn eds'OMR55+)Tk/Q\()&Mēlp>bs)GrJ*9'4G6g\2.lʯ]ەv}s瑌r0+K(k~'?6Oh^/#4rxt 85u'%zShHZ7cG=0qߧTk8íν6ަ,PT wF*ڝ\\նc /b۰sUYOnesh3{>h䘴X|oz ,vZU%9i- ێzNM}U9Jv>ŒcC̓q핓#9yviNN6#ܓ:;ZM3װ#?J%%OUWkƒ"_:u Q4mfFFA{K+)};$/ߗ#qisTF:wZ%1UJ>Nգ\w qYr˯7bO,l_ #O)]+J#nki|Y] ͞=Hyc{)- 'dL3/ݐ<~e;8{HqlvO+I*U*rEcb@}qm. 2-cydgqk&yQ743@ .-DX9؏\]R^wSμk;]4vP(U994ܻTҧ9izyo ^?,kV2Hc7Cd =F=yw*qWk[OS谸 rYz[K_sWu0yeߛ?̅N|({j<^!{;ܻ[# F `Hz>F..n|jvm^2Լ-GqbYVTdj[)A<Wf4yqN\׶_Lڃ㤢k]ku}zZCI%˹(m3'.8ʚO>r#t2ek A$i4lw+ \"֞CQԯ(]= nupVHes3irϝŰN@qUZ|ؚjh^ʟG~, L0W99cqCV\ߙ{H^̣bلW>aPhcqS%{%t1[dVyw$,q0v*@fyⱕW-5[EI]={ s\Fl{q{{cjeN==ϩJ,t;s'd!\' H<O91om/zh<s+-4sxYuiD7H`gSYK G٨;*|&}oda0}Qm+I&xDQ[iifd9:+M`ظNG؏bI-nwZqQw䏛8Q|ϕ wNĪ`1SrSW 5aR[ )>#@pOkYQY5Ժ2ROK꿮1i7H2 ~5*1rRN[QL~~u$^TT%t:'$U FHMy%oϩ5qQ©9I=lstJ%NPFp:wOgʝ~ZxKmVu9#)aцAsFr4[s[}0%ɻ: D4䑼Ywmݏg05F4Qk[~NɨCep*GnӑcF{bN')jKrE[mnFch&m!ܣ ;sܓu|Ob})a=zVvΜZz9~G jmiȻn89R<ǽRU9~aR9?A$K %± &3Rij}nEq[̯VIp4qeO0OtԔ;Zw[RKim{|)4Cso̅<`Y19^3gM6ץv<,ejK5-oSmUp '#4gDZ{[rRGrvx`XruI9KW4"m_zRnTޢ>~nҿ̦EI9j}#QUq~2xgd=#15SSBN :Q{Ksuu_n{pu;I W|'ӕMnv*T}$ܯ ݤo+6T0'''N|\ޛxn$#G+n+ ^O+ҩ6o$s)VZ%4z}<*BvƧ#=3_!O Q̬{x_b{b>쪓HW`= 9Mq8ҖO3UtC%[̐n2A`'kLtգ᫈鹫j,T-Ҭ{Yy?37~{ש*k}?S͍:Rjݭŕܓ(QyR85ʔnTm$&"efemȬF: +Z_=*4d׵[e]D^2LSIn6_t(z<[xM#DLQ:\}tFnխؿ=^>¾.%bh9߸%|,V#:v7sjRAm\:w7 dvVncnN[ :v]1ƹSJΉci1Uzw5GDhd~cY,9^`i*7Bzr o뱿vk®' gy9+bul>|;.g /3\(g~L"'9c*J*WudB"5З?>;@"YSN >>J7]KZmڇV7jXS ̙Togy#=Iۮ~_-n6#v]9?tYn-YF =zdjS[=]K3.]בz4xn5-Vݘ$߀zdִ'N?L.aݢgzW՝F<WqSpRp 97NRO>߆^ڵ|Ԟ^-[6mOz/oy3GT{ rױ<.WG MBJz쿯kTVdWSIi7-ġHհNq=8V])_nWʯ?jwu6o·esw|w%B[M$?rWNbO_WxӱDuJ_i mN%9emk J*>hr-Y^ͺF?3Wab"B^Zv~7>_7I#>bR*ZWjAm*bّ#2cT{2nTB2\A;;z+w5PqK[ꎉI={ pN!Sz믟qʵXyy-ucpFwe쎔N΍5ZسB8*tMg5C:1ֈb5؉`_=pbpTe ϦӖt:O x{[`<&a-hMI)(ӊܹědgbs9\ Ǧ8RGGJg{Gvc.VOh<ڰƇa^[';߭Nb$ӿt/4_Fסȡۙi2dH9'qt>c(7{Y_KUjVJW~ǍfUw `H sq^4w_y#*9E<{֖ͤ7y%*6v$gCRzoNq|}>u ?ZqXx*qt~֮D[L޺TFS}vk^|O'ܷ/ JMeݍ3{STʝ7 4iҌDI+~gJq)\'ey Hb95bo+EiUɸS^yȖEbq]ZjKAQ}^559GWEݻTt7'? S_JVQO[Xz/Լ.+э:qxhf˓Q+ WyRG}JTևztHjRXZќbN_ޥh*cAMpʝEȓ4X<[uSIr(rSHMCpc8a1^G'GUL,j{еm<|Ssm~z [D:#:r? {=$G YUJZXhLѲm#_y8Kč{gc=G?>h=.Gk9?2 8]x}Ҷe-hv)ŘE+X\x#<s9($tC9r$zaxmYX?*mZF9Vr.Y]P[` (`?ˊ5cJoc/u ׶n/ʹr~JU Ona$vdMm*y#XJj5iON鱨nno|khDb7\㢏/ZQሩZm:?M=?9deDVRNFךrʎݺu}Y:XR_Twzu|WV0ZFy2O;-89ҰE'i}Vޚ[|5M᠎kvXRFG8XߩFWom]xڌ dht3 F=yVu_\%R2kwsg6qI?)nr8'ֽ|jowv>)^-|[o;~&g':ݍYcP6uOֻ:ouXJ_2k>٠24vI#I%gר8XԊE-e,1U/n_{y}I0]BB8u܂TR!&eK-_gtݼGR9謯dK~vk}DRL(F۷,Xncq9pk~8{m? e-~Ed*˸ї<ߌ=+=yNb7WI/)ӏ_\qݕ)e#<.[n\1А=::JV9%J MtSA33iPM:ѧ&_35M!01ƹ]i7;t*oI?V_Joo s"r)>t*dDODאD]P܏S5ʝHVDNw(G7%FeBT/|gy5RZ/ԙڝ\]DƋE31Xz{QYc 9?]_?Tw^D|Z/:6}ʤ|u{H7zGRNg3ڻxN;=+/s0KA#3#M~5oW8QZ!cHFpXrURU8T5td32Fum?]V1_qztnHQˤ JڭNF~S*qJ=ĸy&@qs֔d;%R3 442bۿ^4e'&g:T%vu"V,BsvS9qiZi1cbæ!Fwu=e(ֺi]Q^xY)k1W72HeW*gtΎj7/nN%«Ƥa}1=?!]|ާU87kO5ӰG h۲9aUɻ m폦k~x?wUmKnfmpYn:1ӌu+^ǛY*܂mV;xdqq?o{J2^R׉&O1 ^wF;ַ(7;*(Ƥ[y-vyϼ3?ʧ2S!yc}J1I#fݷПl{fN^m4fޏTD)k<܂99h&q*\n#Z>Zn_+8S\εJЗrM!|3mk?exjic7evag:z֫hW*sYĶ^= ٳ\c+iQ8;f1[W#S99;S4ORHi?a}茚[:kQw`:cgݣ:BVX⹍?)bJQjV+厖B[VMe\}c?iFrWQVs϶x>gW#{] zU{c gqk^rpўdGs[$v=K䜁$7VNDw·F{5hcʙΕHV唾'wh$,P۳vmF_R{vpN5cynzi%r^Is!ʒ$䌓rj=tZNjvMhI!܌bL21SМg?ve/EUM>SOZ8ȬHKym@c|t=D:%^-M]?[ n|!/p>y=JNXƭ:RUmm-h,M#mp;^8:IƟ+;f6wv$4ю&Mz}^uenǯ]<ܞN3cYŒ%+^VjjgӒ(8Mn`pOƻmieʜF2k8Ye1nOlchcv*9*u.&Mqߴ'sW$Ϲ5%[nNO?ִYrrM[̧mCFx~N#$7>FW KcabەQ8ݻ=mNݚzu"^ϛ_Q=QG+jPK 2V9֟V/Vu}eefck y4kTzhE>#Ydl;?B3ֶi5QyjoŏSlI".G,ɧGբ,64vFPOs8]W,*.2/<6Ⱦ\`_V:v9YS䴢YDX(Ei8ȱxYY#e^*W^GعI%d&ȑl-Ď76 ǥTTo+nMm%1;Dܨ oJ2dKophՈP:ڢ*R([,om+EnKzLzbȔJWukOaM>I4[vJ$qb8қU#$*w饇]^B׾\m7ˠۉ 5WuSk{[i bk1`l {mqZITnթVC:}N[y *hut$Jrne !RQUF}:JBxCa x]/xU5Mg{jǽ2ʜ?0[F6^=vc;Ⱥ2 5 ᣌv}y+&VP'31-7!<9$kNZdB#_#k{6+`v0*^o}89+j-<[V8 30dOKn6xT7m]V8:^G3wᕅ$PO-pqu%Sk[¯-u zzsD42/8u\(^R|4MSF&Qr1$Ƥ9+SV<#'ːmq*Ec[ t}5.X5Nr;%1Mx%k9RmdQ泳nr}s\.7k_§_s{IҷK9o5J{2jZUnlvӧx#1+4lp=޹B\~C[kשYGNR{Ұ_wݞH{_s~x~+G>%[α8zK Ok<<v%R9JkGQcG|6mILq6NXnF}8FXxTLjx4I=IeMiqq͠.*>?u+Lc#H8=*' $r+Y5it)bƭ?ƴ+FM8'<k?jXtIXEefAQtSӔ<=+ΙO\ZfX̹ yy=*8ӓw^DkSNwyuC>#_ɮ|= +E򷘣2>Ns{+5)l ާ0Z:|Iywd%sJxkz4ptg{V]~L3"c݇^yiRѱVe$GkkLue3(e˓zdfɪǍ'NE\iKUC#X3Nu,㥷80z'[cOV5y;S Cpd'v@COJORG[E駗xo5ay̟ AϺ㿯z2y_^FS[_3k3gjC+hUs3\KK= +ajI^}#n2J֗}<zw2qI>VT%E(u8Iu;o7m\Balqߍ{Qjށ>3Wt5 0#E#?ZXRW~N3(rI{d[}*8ċcr8;ןFѭQ˷/'>F ~{q^~)R-OxBwmWvzW:>4K#)bJ̛M W6ʬ \O5cSRen=(֍VZsHŽj5%OB<2#h32|Uh$wHū[*ކ5%hs|%͂F̬w*c`q^5iRZ8Vc4C }>A ;Bp >R2toZ0yJ{XsԫGsy+סͮX(:{)$;pr7إn##qavAʝԥURUԬdn԰ 眓zE:m6zT%n]O]YgXdW}E8z5->k[]ʲ+fۇz1qDsTRj8)z//Smdu[,$fgҼ$8zR;mV+uKEœ6'$baei>,տ,[D|O#)i~dD$8yٶCQwş^_km=\m+!oPyAr$sgʚ{^`h[iϭgZ%u9?u~>GeI{9{VĚ||s*>oZ8+ǕBQvg?.< p+t|֟+dwP;.=BVZDүeu9:ˈʝnzqm=ScHՇ65%+0қu%c Kx*%$?w~9823[F1MD(Q'%O|<uo xuQq&f{~Mg#ĕ8B-y+]ב%强PT>bG܁dp}sx)ԍG8t;ߧ{-i67>-I73\q׎Ne*qBV"XY.[YڹEZ$VݛqS=su|W6~iJ%N7Vchz[˜UP|s0=(4W梁]Ua労pwm_kjzev4mo@MPc$arsyЅE<\ǩO OK_^ă~5Sk8bѨUr#2FqONɝ:?^25}5[CC+jy #`s0=3䤜W迫ZΥ;Qas*FǒЌu}SOڶ{]:8s\ڷzu4oq,.C*K 8JNyuM:m]Y]x4kY-ۮz:gzuqQH)µ}K1ڎ?W$mÖݮ<]*@ w'HrvZ?_Pr*˚,_uoNF}wgvfܡ2(d$ =,.4>v/k%Yh0uu hؗM%Ռw1aGh-p?ppGa #ȧUt_:eZ*t_֟SѼAK HPYڃ5PX*:`u9iR:rU;sϕMI}vW l hUUUө׻t&Jt$שxC:L;N>}ik5~Jt*ߵiMs4mǽgf!si A6y]MԤwnmmԿjOPkREe"hєt>>5N KiXrRm'nt߳Ǐ!|C3阛̌I# F{n:u@8xFu5w{;44Ԟֽ/s#6vxTxB#;@%W=rP)ƝENKaJIԝzy.ǀDecgտ#YKmx+$A~xJX֚yݭ[{U9.Xejw{}?g?o4tq QCs'F>nؒ=Oqoj^Wk?Fb8?dk}/wN9?R{ׇ'5 U$%eU*_= [5_깅*߂y88ӰnmMlEK1ϠA?=;Z{pm$?*JAc"WE5YWV?aeh֝4ߍT|G+Ɛp;@nb1!{toiGB gꬶ?#OKݝ͌7mh81bS des^V*.!Z$ﭭk߶gxZN+Xյmv]-}IZw?~?o΢>&3)@iel2DCsg\ǽi)TU)4t- lW# qZ|yꞭ4tX4mM$O'{gRdWR$u-+*=y^w倡Z[9SC15+0nӆ$gҷII),z44hss~3s|l{I^=*VcfZ0T2vDkIqxW*pG(2i;Ԋ[T2/ޒLyAӽpTvy+s/Bx<ʲ#` ~3sXIJN1֩MI=;\k{ӛrJ{Ƴt]$IU*k[-̄FBю1xWDpRn1eK|C:/g =Uh+F:+Tu_as}+IMy}fʝ}zxgU$ bUq?&zszstoi*N#-t}N-BKWa6UU2 ?ɭNiFђ]5 $1?'{ѭŴHv̩;=zFp_”cԝmv*"7ǿz1 TNmWu <>u]Ud!@0r9#:өf3o 趚~)x:rr sф+xJ> k}lW!yeONOs_Eў\sʾyUEi 70݌dq=*Tv}4Z}E FyiKZ2Ce5<(]n#ȕh+/;cm[τuH,Z8 d-9xlMu'bUcEݕHK~v\ymZ*lQT<,o.~zv]53Bͱ[lONb)r[e{ C6րGoqYƴta(n]H5D1[m?j;;wڕ4I]Ίvu!+z\`vCN2Ğ`D 60}f6I8ҳH%)r> 2왃,ۀm\z*ȣBYB_ϱaIQJmόqWҨ5e9s+d|2+}ʹz{u+~X迫H&i bβFѷ2zpzQ+ߦeV$HL?evYaӜu=)7^[z>c DՖ5;rOͶC}xl)>#O[9 2(#3(uL_ldp:gҼ^mxNTӋ3.viQAc|Yӕ9Cc)*Mj#XNqۧ^CsUU.BAoݮ=YC 'cjE#`;gRU)ښK3Vkj!&wtzz ^TK'z+DbSzRT6H1y;ްRjvF_Ԍ@go«+빅:ҥ&/XJwbI$Mzo䔽o~Dͷ8=?Zʵz㨣NGgnHHIYsb13׏γQ4ݽ59k(5uGS()1@c*O9=;N خ]nBɅ7dcctF*kќi'7g-P2obg3[*54VXN4˰hs3 Y =3:0j*ϭE/V 3*ܴvHŶ~5tTU-̵F.a\sںeQ("Uy9n7>xEx 8u9BU%X|Q^|՚FpZ쿭 o576eViOα*Q*9hsxK<3ȿfn;5_Y%=Sz\m.i72NFp(h$tcϦYEO_wasG4ؒi~*@ֱD1<~=1줥b1K1yuc>"FVvr8cz?Xe{z%G) s>gn̎$A?1|^Oԕ(-l9)FMȂ4kKG$i8x+?Vrvֽ(MI$b+&hdF2o rFW%*7GnF CYWo"$% j NU)[xSЖY<.fJ/#+ 󌑂*c|XP殖hV[e$i,呟q"p9srp4^z8㊣*ϙ{խwjoU֧~^G@6p@'WYBpORQiΟaMk"6m2n=Gn~ҍ;OSgqNZnG2gVy>oF.6c:y;ٴfY$s6YQS]Nù6FOpbHYfVV)ds)ʷ;9^Ɲؒ6yoю}ERJŹ^PWGrx;ζF<Εc\T;i,ȖvavƤyq }j.h-kneomDwA76Brk*Tr~kyVU_%1uՇ5zխ-kh-"<^c&5y{HIUBr[tefa.;9pjI1VB2Y1pNzv(ٿu(t5^^C֊,^V2UKߎsҺ!kM(WneBBlhBLG$(S*IYte{-lAsm5y{,8>ST=ƕ)ק}s&bnޓʴN*i ٬0yE$?ȫy*]RnvӷZHfp둻4iK_װaC$Ӵ4!c Gqj%VVEL<=9}ַ4mobo̿ydttF(rX+H\+S{yFܯ^{9ϺV6=qֻ=64Ik]_k6;nc#XJI-/̛˶DʿYwZCMN4m~%. 00cpP7ξF />} mMs,k6jA3?*U#*` zt7eTͻyOB|Fu#{-. s,-+HzbN@H`խߘ$Pd&v8cK^F1iZ3\HqXՂ9?_^sZrH4[+mέׯ+8;{eʏtHߡhuotg)ݍܬ:s[kvSSz6k&ec HS˭ޥENRP;Rp<59F̫+FgrKD\rc=}z~ǔʥ>hۍR$X<76$c5a1ThA)leO'eB~\է*5&w)l0)c ޕqrS*qK7:Z<|6ߗֲSjSR9N3:s,vYA׃{{SFim?f`O'8$r\DVqVtTRzU5Ԭd,f=vƕpܲqYgٻ{Rc7W156nV8|v]7@89`G4QC5*2.L6!hp*cqgeR5FqûCwS-uh"/nCہIՓ0cS (az.8nA i=hiz8 M0DIKF_J2VT.W5vȭLXpRsssVI(֍j:~ݼxFy{ӿuYrJJ¥j(R:#Ux]n>l Zӓݳ1FIs7oԫ2YefܱN$_Oa[s_2;"T5EQi]Z=:cߧY{*~a9URqKa:6۹wV^3lCqx cUxWpkC*58Z]Q]%C6剒>>UvS"t{أkV)z{[b'$2-kď1]MgZRu9Z{3.K9#VXێ|U({J_vWV'HXmn'*j.4iVI"3Mpks^ҼZv%yt^xr1UAͷ0"3e_qJj²X]^{20wzBϑ-^:fuot9U^@=ryWU4= rJbCv&(m^fwn['$scۊG/]9QqRX/²VnO{w\oME)s9.Iq.eU78 TIBu+O}{Z==};c*u#ͪ*F2$sc5R.Ij*δ&Wy$zoZԅmc(ou۲ -q"y7˞ߧzMJd۲}AH FV A篡#=G,qMк}?m'ii%vQW$Is\cE=EZ" %!36@t9<>Ys1Sf݌ɸ]'%@+)•83N2{,ڸ6y8}SQӔ9VnXHTUO_G\dcj(nؙ l63?Z)K] NNؑVFM6ha*d>]빕KdQ sR^5)зy$#bWsg?:q-.:n-#^b;|N&1qjr"4G.fi,##;nrWl V7UrAw5FQjSer4N-ٕYTNO\8[i9"AjmheCqH's)J+K6(89JK凗s$plw@5N4]e6*bH 6݃sg_ӥU%wRhsv[Θdaǎ'[{+m6~V ԏ8&\ 9qM%64lXXmLa?茢DW/F[indscAbJrvG fk_К}L؀U_W?*DK]0Ӆzsz*hJ5eR4K2oUXUdۘj s҉FR3uR|^KhE$BC[zQU#-3E: %tfgfS"cN+*pNwSͭF[; ^Lo+2tݷ oόj0Cqq훔vzL[m@xf9g ?|~*M3ũdccn-ohۛBL~~ՔWWnZ؅ zǯ[g<9-BѼ˰XߎzgѰ)Q׽ϲN#N[4QNO #~PK u=zcGʑRn22_"k]:lQn~G6I#xt#W:2cRZ?_h2gp{׭K Zɧ{houhHHf H-ӷjS#.o)CzTn ZowޥχzNX푉 |מ[ rQ7wsd1|ҧ{uۻGSfߥCex----$GoeO UpT03W.Z5=Iop*TR=^]E-u^]cE[3zXS ?pGNՌ)N;~~+s+Z^.s_ jͨjƖFHȿx' N:}[ F7V}-oƶ>Ti~ۭRk }~x<\Ǻ*px++G@x8#^rNz4ЃW9DU[^#kϧFQ}K0tZ^~&hKqmx}z{)*ӓeX䩇b1MAU1o|w_6Mzqrsduԣ{-ҩ6b& W_ZJ2jNmJ9)5*9c +6>ꪎk<>&3(|%eFl{*c/#1bѨ8`~ cbҿK+cabRFz$RZF֌RS]4sH<1$ sR2nwU"x؞Lo'N0 k MKz=/8hs?cRVC c9)XoIJ:ozM-ob:5F|>9#12juvqT]ni_ v1wC?Ͻ|&ޞG+3Re&o3I9ݑ.򖽏S 3U!';*;ܜیvUZQuա:J]uDڼ K W3jƛRޗڅ7DlKШXVO$x鞝T|Ju5oBt[t'Į;sQ()jR,bޥ_ hRP@=S:rG58ܽwn/.w ?OƊxw8yNwmu3u(wj?yTIu9 Te*zE;)՜iǑW[ ?%t&>P5}d'}*IE'?GKC)$QSG~/ekį=qjZM`g~Q}R<{=L;7*wIuNŞ4o#rZ.4m!ؑ՗ 1V)(߾b)E(I[7׾' /'Lc^ڦu>])O# p/R%.׼[}-o;N|/RWٻNu>Kƭ*RG6SyjDf۹C3X|fTʵ־<\V*{ie.VO퉞F\,{pc׿\ҍn6_j&#fs6ml`i>),aRv$ G8pt[-_UiIZͯQowKoe{VEsʘ@1E}65#}]{wo,<].^hk[Vջv<Ŀ'Ica]!Hox"EN37ӮU0I+{i{տv4;H$V[wğ[澣s(ݻ5cʤy%v{v{kS&]Vo3T/%e@o}tӔ"ӪJvvRMRZUzt_xWαXLO&eG,qPrwe|yUxyY]wݥ]O'N0k/wuen4]4dS $ $pQ撶g~Ԡiy}߃UBRͨƖC7 rzAPN\F;~Y/M>xҩSvϓ?~x"Gcύbۘ!aEd@e5S(룿'5uӷ ťͻfb>\yIhy2 &nqg&5lrު2t¤i56< ?+p]XѨu6NZUԚqe}qUoկԟULڃ,~gr(7[tiׯGkn ZTEc%mxlUJ0YM ܡGBkjqI;sԣ(ǝko. {7ctSU09ΘЩJ0uFEǦG$*I ^j|0жVrefE`]O5M}*6w5n,b7ٕX۷NOzέ4'~4TT/V2ZO*L-oSFKXPDv4mƗRlm8eOqJĵ8-U˺実{Ocd}knhF\5k}cIrm3aʆ=Cğm3tzd\oƣN2g^1y+^$moWfEU8`c˼=!U&y0%SOwX4]Pzgi,4ptdG!1\nE]pkͯ[-z鸦}zIbGd<(sҫ RR4ʛеA69ׅk*MyKrq ;zw^MyNᇗN{o.0*tWF&غrqn^}y'*nEɭ*ϸ~c{XjjQ}CpE%}ob= ud^X !mSԊtq'#%^o^> E{Œ:{WIONmA͑c6_\Qy" ӥ%>Nj-*6s#.Z6$*AcJWvI~G-6TUOG^iC=Q,+@v:zE]ivð'ZDvI&j{GQ?ifLH67Z˞Yr4Ibd4ꕮQj$*Ե8\wEK{dTQ^j}.#W`lέwyRw ;cVn';Xҏ5>g_AIVLclыܽNgJhsr:+#g]4ZOKҴ"Ċ2r6,y_sF+CboEy{yj^[v]ԧ;m2Xa%XU^8#W5H{I^6(ZUir,RI 8=2+\ҕyx/D:D xmn,&F2l5' c9ʞ!٥#0Hn\A6CHI @1#^,Z}_o"PɷKFxWdݐy{z~V}.kOk8ff[u 9QSվ Q}35_z<}"e!EcGyr4f#<^N ,v [BB݌pA#m=+rZ2\oVN~گ''?1}ڂ!9 7g}x?7.ۿje?"j#,;Ņ (w9>%Znڥ~Q[w7 1I|猟c}4ajڸFcEI{Fݟ#ֹTeu"56+|D$٧|IpJ6{T"I;7ӭٵQDwAUwezs~>jh_qx$y[2v0n<0FmouxK<{\H߻r7Qq(-nkN[K~%@, Mg Xdms㎵;F+gce~y}̱dDܐkJ[_*xi|K2K+ C?tzU9}^꺢kx0 1BŎy[*ѩ3\?h* MUNTƝYJJ=WoV2GX-N2}ҷrͭ[sNi{k740rJ6|pO汏5)h]ΪvMA߹~\E;rqקkB;A[ҮREoFʫc&E#pkԻOQ-lmq 0x~&c){++չt^Ks M9 j"5)k8o[ >ZI"ȿw ܁ۡ⺣.f*jp<~ pcYXp=b߳~CXƝiZGț:ꭷqZ#Lkr][l(—~3ENZy޺{ʦsmݷ$tb3֤q.~Cq,/,b8Lq[ѻ/Jҷ'r&dg=~S)ŶЮ{p@?MI-/g+]k 7̻+\ֵ~dABI6dAHsOB3V{oSJw kZDƤ}1yJyIv@8}عc-*1~M%ޛ$qMQ1q1=1[*+5yb얜c&VuX®rx9 S4CueHY>d1]zuׁ΍9}a.E*cvWqME}l(`>֫:蕑Zh|%Y̲ w=kTt!V^JԆayǻ-qzsҴRU~R2^ibV:7^]~ҟ#{j:IE*a>d,"^968!AU)Z=cN s{ cfFuA"*;ƳR<ծ_ XC1EuS-/ NcΕX !Ur uk:r_ЩVWhAݧh0M.WR5iRmD4BzӔbЊ1RZE$}ͷ:8s472-FbѼ`UԔTyUKVz=+YȏRO<»TǚV Qd߽mkOyU:N4؏{pp<^u9i^frOcu$}go%cU8\Sֳ̮7DHDycwgB00>i.\"Cg r*\\6b r~k>g疑oN.yʼyGv t{*2{տՖBv\c;d:z_q4)Kޱ1OƪwnR0G_Ot^]ot:qlޙC3v]9b~QsSRRq]MQWjtөv+ w$,[ff8=Fr3YI+53]c8NH'p;ޕ-iԞ9pYOƳ(Ԗ8S?5kq!jQ@g4mcw]u"xl̸ef#lzJ9`Rq%bۚݾb0<(=TJ6E8y[< %s0no9WL33[HXH-ܹc̖yTg'ִk, Ǒ7Hݔg@qFQkc.{lG4k܋ G"AI#1HF]z8{KWDhH|/i2OOpOrMܣïG-<86!veՓK` wjX+k㷷-8'tUN[9ia+JڭÿShߙtő\I y$wm8zu-moO is4-V e\qGiFЪrU:x1u(\Mw s8նjI8[yqXyҩG]/ t+Öv_LgܢHRO=8jr8 <*FY$q_yviUV]xQr@b餛Oҍ?g8: 3*IO0 ॆ{zJu5c\ԭWB%U )S^T=HuvWӣ7ۊ;ۭwS-"1S2|Me)O{u#F5aJQz}#|YS^})~vGU9gCǭJݶ1$y=!> kڅջ}oyed`jHb)ӌ%}dz|ƍKsioA||5Z m|ƒE{p8{ZGu xyFRWÚ\ځLr~` 0;syFNJԍ55:$p++|G)r3çR8|Rğ# $nʲܸ*)CVTܤZn{,\vms>1|o]LY 2[@R>9Ǘ,w4\8\0EvO'y-L3_9PZ8ӓ[-#ww]C Ėpۂ|;rIxڲU)J-<E'-}~o?QXY&=FJU"]ȯc9Fi"(yP+N}LXհ IwМc<҂Z=/ˊ]*s%\ , pr8(犨{v#*;HMZE$i #r0R(3{RK^SJe;4!U|# 9qOE㏽p1)T~t㊭USgk-WHܠaYuQEoG *1N.{nK.,w>wͪHCgVRb{> uQ%ۿˡڽO$Y k'J7JT ZI-@Wg7sJ[o|ukve_3n3KUsשOӃ54Z)bÍݫeN)+֍%߆,g[H"g¦.*I槈uJ<9wZЖ\y2t:Wݼv/wăM Xm*Pv_a8qZ^v7$ė +4$oBrx*_]+hyTh.h%ևo'q&'^KomI;Auqc2jrn]~QSK/^'o |XEN!~srqϠ}kͯsekgB-KyZ61c,1?w8^ScY譯19N3I]o}'y4,Dy;=~ayY%U=n ˧B_j6,FH9lG^HFRs8e+$F{kw~Ms si`J }:4zz4T7ֺm1ǖ8CSW\GU%⼙?&E'աXӹ+eOV ''y_.`oʮ5|z5K-׿ޙ Z/2qcxMđ̆Fj2[#QT"9$׻tol$ٍ+I"#d '$ zWRmaҩn@ś,VZbܑ|CZ>Zi~ѭ+48Y4Ƴ)RߝЂOJʵISzߗ{eZܮܖvG|wW+$eP2:sOֻ8cNJi;]c)GUP2>|Ҵ<;C,T $?,v}X$9ou#[I^iҞ3/nkKo<_T+Hma!yffR>Nkƣ'|Z%#Z܏Z[6y FkC㸚gXB)P~\sGnVuwikΟ&ݯKV{zh\%kG꡺_/V>_B##c}i(A<[̎88W*xzsQ=ysJ׋~|94C+s$ynd{X0玿u9V򌹛]ӷ[m7G>fzU $e'=sVjǖkK *_rC{F5ۥù7[UF7:+L^!FB h̄>bJWIEYYcmt}uW~]y;G|Ziƣ|qWU)PyvD,7\FB^hugHWJzdz*8]Se<+#Go,;߀m?!Mc.T5F5=k4߃mq[0:V|Ǜ%d+cr5%6)dI$: i<; DqPOoǛOXlm?'2988|.)-c{v3Xx.z7}fģĖzڼNт_ׯN wrX8B[-,/=]Ÿ s4a>Z%_o3bqu_ZGR͏hyf1sȭ:Ѵb]` OAr6rzͮOB[ H+~?%_= _c }_Oß,Mo @NG峜\V1.h^vcR>]_m}ؗXӮ%k/N ?)^=ysFT[OO>^LOw]~]sf7|/y,hL|IX-Zb$ײ]֞c*tp| {_Oᩅ-OXti,kWS\Fׂprw0 |%Nd􏔭JJ\hyUɻe Lx)}KGtrў24U+/4/:g=u66[3F g>XpwvM1^Q7u<"MCPY%i}k5+.v&ouM63mdt;y8#_ԕ5gZǩRS僲15 1>.eҲ8+(ܡsQuW-J>*료b|׃]+.3 qԨڞ/ͫ'#.l?.m;oG~ܿemm<%e,SnMq(fN1W駔eWUm%mokM~~ Qa/v)nk O<7#/j-LڴS%8AfWF-KUDtR7Ch ~-JׅuK{nDR[g ;U*({vxq (ݫ?cʶ:>qQGW6]Wf(١?ty:F0%rp9DNp\,W |M^jK(C48VkzkXL,8>=AMwSN{F+Z5߿/~.wegIlP40ܳG+X)ϩ`8iKkv]G nzh~;UtIa@ӪG~`y98rkإF3rkNMin=yb^wZZoK_k^ "AyhwĬ;p8#|Y~ScqMڼlDW,N7`瞧ֺ$qө(֛&-at2zkWFr7]KnƵɸ8D`lpRw5N^n[3kE3E4g4܃5RR8b~9Q jZb$njwVҝ>I6zx7+10AN2~L)laXBEik C=uFR LuF[ws'z=onHҠ E dpJ-CͭʢHihc}$)c;]{u"w\Uֶdi,şv~KS N1:ӛQ͒/̌a<ִu#Ok%9%oy^|&5Xj@< µG)oTͫ6z4vî7nߕi9S_P/_y?I. lьm[tJ҄c(;'DEmUaxY|8:ߠU9J-[|OO" RHn#FC.XcҴjM=G[G@ۃe+O@2I\6Njm]O"71yXgOz YADoLnO׮aSʷl\Ram%bpc7, 𧁏=ҦK'A{)kmo.2Dp;zGAEIB-SN[DLmGmf*cEc֍:qIq$3d . zu'mJKGܪ1H9^w+ދhnd o2 )<)NRWLiƮ!gsťmsM)-[FnYERfkY[ K#0T8ʧ2Ti]s˷I.]GƧЭv6$B>5>Ɯ;yIF 茉mIݬ"ɂACRQ;-7NRo_f mTS+šת;%U.L*,pNX(ɧ2^ E6v3ܒ9?Ҹ9ԗ*!R[ɣ6|ż^~?Ҧ4mM(JKǼ\/|HW=z?U)JvgZGM%w^Y2ۓq8 ּD}֭Tԭ4rQ![W-8TC#"yl2򁊩N(#v$Mim_P{oo fZR,:R/28v ՈOR-ar9OK Q>W!{|!^.N}WU=wLv#5cvc(M|AfL#uN\ʝIuH% rVr]i'8#N@~t/F[;[_d̉ݷy 4VlK5cbv FT*Q:rjp6s]⬙K)S%[B[CWݴVjQ.1u.O>f U>e'}iJI܆<޲;'SZWDeSOz,-vҒETKe`I,q*{guGe*#ii$Ed#Uڭ c(єNzCm^{vkh6e$79汫bB൶ĭݩHX=F} T)Ԝ8J3KtZM${Wj'һ)\^MW,S[O"qvxjBTF"2Ċ r,q^)ƣi3*Rj1[d&)`V?.`VR4+:8g/ȆYՍ2Zd{6ǡ984a=g~G YTMly1WWwgK1n $]XzjrPiFJKtȔKk8N0 +8BғkD"q2m͍p,<UNb^G]zGG32.f/M?+Y(gN.OVI;k?/=OfٳIFYj/,rhE^2s fsr9ʪmw$ *pI+_J%R4 kGN~fvA-U#3rN9?^k^Wo*g'wسmœ,&KNz}yQZZ y6.0~81|z&O qެy3H#ܨīlc5WhڳKM ,VfsYkS1"zEAT(m9={ʸ/71{dDQcfE=_cS9A+2(3d<"i#w:c.Zo3*u&m0'K`>֒,";dRү{x륷3Z>,O#lRniԕQەBۼ @P~^J:穫U(~i?}K6%ɑ?Z2V=Xf"YefI*++cctcyGO#)E&{|\ڴ{C3dL)*;s+|ZevnaJb>`l4a9\srA].>]w}e˅< aN{{cW\g+/!({*Q#2y&Eʳr@SJ^is+~9#N2g릂CmD̊F )yKJz+ti{zw8(Ν7եtQjpszdcVqrvWq}!6"޳36R=0TwzsTNMg-aDvCOQ+(2y8_OՎ+!vdM.VN0 퓓soR^WotVO꒼`l2h$,;1g4#O18%R 7АJ[;I3EHo铞v&-,\8wkn-F!U/J.8Tｴ`:V_!cw {rt%gǯJNPֶzۿ>hRM++[nBsG.cJrH$*/4xco3iBv'=}*Z"} q]].ٖmbg[hV8YIqyWLj˚Lxyפ~Б&ak sMKQF#%wlRi@e 6p}buJP[+X:y3u3]~ނXI%I$-tWl'烟CgnxSJ{jC-Ą4fm#wG4GԺ 1S{&|H_zt9^X-iP"LBAzNiSRCAШ"YJ}Uϵk%ZThƴUZhndek_1U;kZqZ'|+D?^̡<1*~FѤQz~2Z=v ^aGiw,ydiݟ3)S/أ*AG,Y'QV&׫u?xۿk ;E6ߛ~Fؤ^JqZR:˗%yo;e޻p9$q<Ӗz 51+Kur*afn?&gfMlT*{oee&%WV=z|==1M+ب/-YkH*N!<{tXe j>  ݋K-14b>wG3m9:n#ӚU#N}RK[/Z7loF8Ϲ:ӕ3mfY1qSN++ W޼cr\ֿhePWtco\`/' f򶙵HƌyԱm,ErB XW~iFU/gfqJ4hI)];Hov.lZJ0㠌$4ck+gv0FAx*rьf.%}qXTQD~2ԢߠrIwĢ69 /=Zqy3Ԝn3A.!yQC^1ʦ7RN1й2M3+7`p?cMom>o{Gܬs,!aU7F ⷍ:wA82zjY.edeǐ >[JWԝN_iu/opBA,~\fhg\zoE sW <+ ֶ{DFV|!'/>L襆m۽mR uO%;MZܵ9ZR|ӵĺyݽqN5$hFSݗQQjwyj@?{VҦJi>)EȽ\\W۶=XSq vJvwXM;/c \Lq5c-SI%ޡkĤj]:S@,~ҴYY|מڞ9](Xc1ް6J5)^MJOu*OFs(Ʀ}Nkm=K#7Bɴ|=4'u+:}UGsu}߯aDŽ:p[t(]5lOg*ִ62hԬrkC6 gKb..cF@'z5J:$r{:eHQ٥vܠaH*֩;rz՝EԾ -3g)V۩Ufofdڲ6:Rq8ԧEV- 7 >vPwVXM9oq>0ͥY;ȕaQ<}z\u}{O *}~LܴhO)jU|ǹDR*eoC{LuvtX+XcvxsS^ i:+[;6ۦTmǹ?Ty ka:JQSdϊHԇ?18SrW,(^Ÿ[,k es=W?+n<ɹ9TzG+@s6 '}p? =ʩV/[oo6cd>G VlqT.}Fc LF8drQuNt䴞B7͵nzzNї:שie6=?T*=:^Κ$ +ܹz|n&Xq$یm>ޢ\J\̑ge" 'ZX٠::\t̘P0dqXoucNR6hlo0 c>3Q%t]QpG%WLvF2I.s'WEyR6f3psWZTK:MgWXME'rq8=D߹vv*tm̭r 4r^xkR+sӊ֣k[w|]H%1f0w}kTb#Fz;RPX~g](5*U^_VЊz]J7XmE񓷏z8ӊRT(rپ\kw&sn'$96^Ti8RݽZCOH<ϜF?FJ%*kYt QXɳRYVcuӫW9兝qqiz;BZ%4}?ZUM+3ҷ+F볫IF~]ҭv~~zQ VfQ]zM>h]o.E ZF;PT3ҽ UsTܫ5(ֵʬ}rN:\f)aJEU,<ޯvl1QjĊC'5Jq">Ҥ8rQwHj7)&Ĭx`S}K]Qjdo.7O_s*rBJQ@$2{W$V_Tp5rn b4(R_JiV9]݆?]y[^ۑ[ogЈJE$iHָS 9;FjYMɎ4_7A.ea%}f㿽iQQ/ZBҲ0o? 9N56ZgS[Խat0|8`7}fUQcwO2֥ w~b#d rF3sE~ⵍgq\Ms6y]pnG_n¾Jv}^Q8)^_pN.]-{tMI;&cW[m ?5Mݗ(Ӌ^zK+yw(~u,b}{cČ^?_S(ˮ9TnN˅YxUGcִϳ-BHrڄ0G+'u=}qZƟ,˅tqq}[cy+ZWk0{5}n1}M8>3{n3/̻NsqKNVsR2I/gxe&5W<x]xx2OKv= iӭ:}~xTFoS-7~_g>R []SnCG1)TWJ=mJxc;tN;ӌ0;V65c)EK&I3޹/vOs?Fy"ݺle:Zؽ却n+n6I=O>{ER׳]QSG=+SM*Һs`g~|Wm**~V:%V+w}RitbP[{9c]*2۩V53D$]FM4>R۞wc)reX]/{Irh^g2$cQݕr=qE{v~_ #v\sg}qa~m jb#Z!+hu1R}ȷKG8xug5x{ðj.RTc*ۻ/yv74ݾm[앵]NbpM˖ik_ǯ_nΰma3 N&e^=3:|.' Ӛv53̱gR>&ѻS8[,oկ{F.ۯ> &x| %wqC22%p\yQYq1H;u{]ϘFWM|\^iC,WWd{nXN .X~>YiF)]]hZρ< vIᇶ8P;/9VJWw9eIwn7<+=d#3,HW `'Orj9{K]I=.q+mᵽP+Y >^b*{^eU:؊_X=?\A$b"5w.F KbG֏ϯ{;(K+EkVRVkPGvDLIϖ+8'oZPI>:{iSNm9/ߤWo-a*<5Ǝ'ӸGQ|NKu~Г]Y\/-Xv|Fx*_篙߈T>Wz_^IOמ9_uO0ǖ\OR8g0F$vnFev:!Gуtk/79IwFvC/2n6?jo|LiQ3{g pIr/~.ݏ'OZpӗsěԮ;Հxy9=Nz1Tc)[N>j*RΆ?6;{vfHi7ێ"2sKcVn]SN: -$fjxŎ3'/ӄHK]=%߽i-ԛXZe6ns%J]HޭzoxAY+H埗'h2}?⭅KE;7t8-_0N=8|ɤhۏ;dוNncmgu )\J '߸q\~KUͩW_нmAѕ"EMQ펵.iOY=ZR_g('ex0TW$7Z Z/)9'} ^%KVUf0nTc{`~j|c/sR7 A?LVthԩ̪jMnn;mT k$j12umϨ=;Vuh[_#˖7}V#nwc獐1Q('5`f*jkMVPv3/y>qQhӦ߳w\.YfT3$sgI<'i*|"Ț[P& F0Rg_xbehrNfzEsSXhg5D*CC#49v jiԚMAukHhml)6S'?/8B'+œimsz.L{h"c9IUJqnƤ-JK$bwI +#'9c= O4i7kBe حeK3ɹI=2mi38v׷S2¶l*ȭF2p>8)֭S'7Z;#&ƷVL^2\N 0NNWRXF6ߗ,:ڽ<6*tq 7nWU^8WGԓiYg43jq&3was9 \̎T9ђU^{KC7ZҊngAxPEa5ԍqʸU^Bq'=1:4I~wgUOM;;_>(5 /TI.ZWak=ֳ]u+1-n590#]N8ڤ">enktKmK.+^F|K ,2dW!A@$AA^gka.F&kGN߮elL77/-G%tW졧x3S:~ F̃MI4g;JI 3r3ը*q[Z_\N;ZR}l|+jVs^£r9\מW.e ~#))F2Ld:]֟%嵪 $ڸ9sSq`VYELO&u<{v[@fG6:֙ApwnM/=yQ?b+ޱKo~oj:sEݣؼ /qV[YҫU巢gST*+>٥{GFYʱ8ӧmZq7/.E5Rvp*Þ-Xӄ>Wd}> pҺr ,tBeLs(v[^ ԫENuSk7N[QJ݋}FMJt eO3#MB=YcJWFu%Gҫ:tZ6S]rwCZEk]jN<ַskLbkiZ=х]]9%Q;"媦]5 .Vam .">BxlE/6?(+˭9aZz\8z*(M4n\m? <{V%c6e9)NR ^oS.V#)*SvO_OԣEKku9MVqr5'*yk:Z-vNwb/- 6̾+#FT#j,]|Vv̓wG-& ZIrvY%o+m*qyIlaj}zux _cRBhëGQ'8UYy4K=kyRvYw*9(>bkG귵Eq*{JSɃʶ_ѵi:#V8%Eu,?5>Y;zWu)Y\k7JL_i8]F[vg%J4fo%l;39DZ+'JjosY}.i{QG2PU*9goEF~$UVM_ec~xn7l̸Y F sPC]Ǜ]Re֚/F{-uIcg3XY+;)kjQdK&+Tle?UT:5~q%ip4v-rY]+t;N1$B̙U6w(nA8>E>UbQqmoXjvh],\đ8׊aOc|/.+>zLHrѳF ,rmeR8#5KE/v1X/VI[],jY#VuSG_zL*ѢVk}vY}8J+S0$զw4vJlUxR_83#s*XSޯw|]5!QGwVV=[_㼩bMï< `ctNkTqƭ(C4qT\ rőkJzuJuXe='oiܾۚb젱l%dgQ}2ZˍhTzEdmAh/K8EkGl|U1~v0N/]ݯ]Q}g eڪd]﹘+c8hXoi/\."d[-Z^_{<[Ogh3-C,~JʗIǾFX> SZӿ}mtfqUO^׶ku-`Ia¾v؎zckO *Sr? u:8 o{ydT7, _#Y2Z_ChIU_-ydvҿG m"ıK+2HY'LFQu_yWB%X"cU Ld$_C>U#S'ݔGդi; :%%Ctvס,-;`Uc0~UXTcu,UHQi}cWYh~[s'pG|g3RLq*QkzGpѪǹCN3Ҳ石涺}l@En7s;;Z@)Sǯ\,ӧ.Uuf?yt qʱ-Tz?'9i+}R5mqGx_/wOqҸ=[ЌSv,\Q `rS>Zޤcy j2. $8eBLrodl>h)J~Fj+zin#~]!oSz RW_>ZQIwcKgk[pYzr;V}k^6z[\>-?:M41kGQԲJ޺ ^s\iY[q9=o{MjS_I5D$ۮ`kzq_*n[Elӻ/={t5'Z7~&n#%Fx NhB4m);ɭ =:dҭTVz?$X1Zp0{kl$ -˫+2dR762֝xB]\sΜf܋wSZGˈ!#c9 ҵ/qJ2JIu[z#O:'-zGeSoN^qkNܫ!F;#q~ʼc׷)C[8ِ{G*͌Jw̑KTAv48OƵ%]? T%.)ün~֐ޕQޯo"!QArlXH`?WF2{J =7ŪE;XmeY8`+YTj{3zŎTQͺ4Yw4` `5MlNT)+u*d:!W#\n8뎕*ь[[ƌIBm>Z̪vny<\.Q#1Pe\ FpG#utwgVuТ4y,K>8ܹQ)T/ e##ⷧEqNiBI_{l@4emn藳Yn삤O* or8Vꔶ؜<#.r}= YLbV?2RTxCZ77VXƒ-V-O>GX}aIAֻ4NXzrV\dXgWc} g9ڇh6#SC"74vƬ䷿|S}I(tP|DF60sMj2U9,p1ؽWtQ}"u(vO.o~ǯU*F7Rjy{x Nl2_j|ϕncRT)ޜnW/~|Vu%c%մ;+v8SV*!'*oEnadw＼F{T{i:i}*VSӡW{[2Fӝr1ʔ.⍰WM=|tuvvU(ԌSԙԔe'v!-$l9$sF3R%C$aҩR)'LjHtsNQJm>?#'R\qi팞SdkTtzƥ䯦rD2܂1ڥqi0γ8bM3RLۋ'\Ov*tSI;F'NZ^Fw7JmZjTN^.ٗ԰[llY`_Rkz\J-Jq-Ρuquլrr}m6mq?l<ʻN-Ԍi˚ls?ir_xz{;kˏ直>lß{sZVfqU"}?#O} ]ڣL+~9瓎*-Zãj5#<9(Yxo4ψ -՜/QGV9aRse+b'55=m3P{oѮZH~^I>bisR&"v5?vݾe9 1XxTs(Ѣn/]-jQe܉![$Ќ~b<+F-McaӾ!\.5j4ˇ87 W5O%% BhQpܮt緮kZ/u)$7ۍR)Ӎ(++k?-moZybL(FsUS"Y8?N `zdFܥ3l?pHR*t znnMwjSy>ZK vtfu Y{"4ݙOAip-̹0URVGףR6n>-i}5orpp'u:XӼMaI4=fLm9oZh^1Zyd[-RV.a+wv+IK{ΣEu6obW%qWlO_S}^]YeKn9uNCO #$v+3|ܱϢ:騩?=GPʾkZ85%f X4ASrF;SXx׊vӇFXV@~^У[J6} GK}3Ѽ3+25s=r->kKmw$fo[w̫6:|v]Wi3O)tV x Ѯrf*TVT?C39xrR w#}Tu~'#*cz.ZHY9 Ts^wF2wL EsfLr0 UWסǿ\-teF[Ȗw)cyG p{yfiԻZXѩZQދ~8f]b`n 8SDq^kZ$Uvrѱ \t+0F,}⮣4I+{`ߟ++`$'+TY.~Ӕ*qIZ}NG/o-hv8dr7uӋ7<콢t>ox|U&[,;@젱#82IJeGW}k*t[׬zwu8O1O \We+=5Ԩŧc^v-wZcqԜӽzqRjՕ|Þ.2OM8nI5!LyKS#RoսsRN-ƹВ$͟Z҆vb*S 9}wOKYtaqf`8_m6nxkWŸDv+ӂ~2v@ 3˩EOsr[ }?JVK%ecQE.gk<Y O/K:N쩒G̠l:Te޶J߮z~R=R[mk.1!gKH̯66W`@W[WZ]mgRZSJENMOD1t#eP0ana%;-S`ⱱW߯OCl<}=FI䷓$ͳ`rI;sLWV>N G}~z^}jzҵm_~%jv*CeRH =sWPm]=\Tj+s;Ÿ!mo>녕Bɐ|zqӨ fi?k͞Y(94mَ -A{z$q'0Y`AuTMozrU"ӺEGT 2q8`E]~n:`޺7w}t= "8h=F_<24cUU8 cAXzTW'_{_&ml]/miMfHقmK#ROD|]KP -`i!Ǹdr;<{dםR]z EFo_'E4I[$9F{ʟ6|*/_3~1kaqgr+MT0,1ǟVQNPZۯ_CůJTmEl jMPOPUfhܬ<3_9^T"zJ24]mN{PsȩYq>5SsntQ՗xrr a3~<9둎>SE58[mX`΀.*zpr?Z0r~ow*%R wu3|EuMBFt_˞F7 Ts׎&OW]fKjXhhSV_2Eo9pQǮ^3S_ϢS8٫tPKoE,%h2>fI6sGCч9+^RPK{ [QU+@6,vNU"woctߪ_?\G}l2L &O oG|-nyۈB[fh|hm,+j01㧭s+өyEYSiVSK8_Yˡj $hP5UHM:*եߡw48,!o'a$NG?ֻ%RNS08kRS_qL<$hԅ#8&"a-SU3:Yji^[mfy&**Tx8}*q'8Y-ouUO }/{)d" {~`A#ӧFvVkTpEq^lE4^>4u_2B()=yⰩ*tzw6+建]s<]gz_YfuW 1Ԟ9'# 䭘*J7^k=ܓosfo,߼o?*=;i;U\T+o#?PYlVQ'wǠ:ou/ZT.i^<ִ{=@ewZr(ΛȨÚTtC~ ^xT/V6T0Re r~QN5*(^_BTNo}_ǚ5⑃J &szzN]/4iƳo4;BM`7hs)ܘm:?nkSaiԽi'MlkB4ꖅe*'=yW*)ӊz}MzSn~_y겋3ѨhsRЊ*1Joͣ-R8'g)+0d4VytjrnG= QR:}id#'v ؎{0w_5F=ǎ|EQm*7pY0C@:c5:'xVmf0b!&ֽ忧Ϡao.TMAV%QD NX|/QRZ_T]Q>ڲrUʛmG>.|Q2_˿hPs[߼mP0`T^qWW*UKKyLVgwI -[7?ѮI=au $,;pGl X<GE?]hþY[kv^gπ_<1w]A=" Aq gkjqʬݛZuzSVme'nxTȷEd0v62kΪBTߟR*R4>UUO$+*ʾApQ6phAcy{Ikp1BeC^"bܷ_3JeR*/mU|G}\LI{@u^djFe6%R=d#;.k:ugf%O*ft6w_"cwN]T!ƞ7-VTݩ0UxH uԖ*vW{15(;}Lѡ^+Ȣy7\B.y7/_N)1%D3̱rJpZ[Fn>:ZCܔ 6#B$7::7TÝ-  ?hAqꔫF.+NL$W1Pglg'#cSv1U9_64ϳpòF2n'$$ce.kj(Իm:{-Tf3ͳ#5UO^3nUeo/2NI\/~>D)!#;uYԌvgqjEh"uqcl*ֹchGkab )EfVlGET1E7'!i"VdpLv5QNRR-%*̗2Fő@߯o.kl3潍+g`3Tpqԩ'Rӗ*w/]4Z_/jk'Vїnn4$1>'Ϛݱ~u{xЪܾb^8hU9Z8zg+бtn2{dNeR)=Wɣ۬R~U0Jۭz*\~%FtJ&0UX njn[Ƣ\JW1-L^LPF#*@g\344]KZrq6!Пoz[rLެ/by@]T_ nMiMKQH`{DFܶv~QjY%fB]nګCc`3oi:<#^s^=:Wꏚ^b6' ~J0:ͪ~G4VH h8w}t=Ux7V L߼gt>׷xcm?==kTS2'-3i`bmm*Tz{d} D]TՋvj7Jn l\Ob:\¹js%kNDz7ʁ`|Y?^zW$5g/@{seTn${TsF^E{o"ymffA`c\6XUMC~y%D1cq;c\gT4nRwt 1d r~^Qoءcyk{ټ&>q Ӧzܡ˹Te)N]uR4_lĬ*^ ԑJ>^y88J;~Īqu>픲"c_F2aRJUImV)e +8v?ÜZX˞1wN>HǾH_.gSNIkIfު $۾^O^E*x= {2F޸Td%[j/Ne8hn4F!c5EaCKZ-Ĭ.|lznLF*)RRo+޾սuBO1E9ƥ>Ihc){Ѳԙ h~TӤS73&$w&ImhiT:?ʜE(JTM 76"y@yp0:y<~nQV3O5ԫ=_Oz<ҧKF5'Nm?nvݪm(ʅNI=i~VhjU%GGKqv$Ϸn~]~FN܉׭:lQAyS( <}+[-ȫZ#hեHnm:αmg'>.*i?Sn/IϷڝʧsg=C[){]Θ2^Ba +irf2è;|ZN0г#th瞪zq=iՅ&jŠB2&G`Ojqwq1Ty7$k=>s:?5R\ʴCbiL|) s< ҧRvK˞Sk6bikvbqܣ$dgXtF1{7u: HNߞqҺ(߼O$.[ƸTBpC+K޴V{OfNЎo!}붔9usJ\Y-ץC N-NY6:XIjKsXg-뮤];Yo8VS}Igdkr̳;}ߛv9Ͽz<џ Tj{i~_2ݬ*Z(#*r ϸ^`UC$=שMo2tn2̲u=?:Ӆf媽ۓ#G=?/JΥ8IFm'7H5kT#|/L# W$G4گ"0NmIËot4q&I1nW19)rsFYGm㇄z;v5)JK>V4JzVګ;[GGʱi5-Jin]M\G*Ui ^) y$VWG5Y^RO,UV_)~sOQis~'-ER/c -#cZ1<7[#'\=Dku9eJϢA&s%2${F#E7u$r0?#^mJ:s,b*nD߹R{uoc;n}k螨)*.֤Pyd$ {u9V?ZVJ}v(++%232v@kU]:`k#q>.$fZT[-T Ʊg̜CRhIGWQ[y̫sy^jrIOWܙTc)Yn-Ƴ[3y(ʲ.c@뎂WjqnZ,Y.g2mm vsTԯ*IVIwH-¿3G"fa\ex#y$QK*G&ބ䩉H_TL?u1Z\ 22vo~%Im#ĥԞSӧn*ϡjtї+܁kCve`sުgR6Ҽy̱o2@8㏮5Ul$:i˞V#i˒8y{8I=>S)T9k+G2L= |Ѵzu`="B$QV-sb9r{oi,Ej|6dFʯJUk꟠ۂ7F.&hd$>j0nwrFuʭLF1ŵfV۵~J\KV){/u.4m#AӭLjb# Eӆ3<$[īnLov҂[HZtW{/1K#&mbe_1`AlJ*򥻿Sʒ?r @yQAF:32u{}QiF`tJTӞ*;Y-mI-ซo˙ˎ $ƚvO{%+yd76QƷ mS8py1v-l,QQl-o2Hwp;HL(l@;z=iԊ[]饾d2!zh2Op-MΘ$eiӔS{Sg MHd&5v͞Pȟ̊~Ruq^}s*JZ@Ҷcc\pO< g5iJz/!}c˚]mmݖ9 /VzW,c3|Oڝ$7Z+qc;dݖȋߵ._~NȜjW-JD3,q2ze; TNm՘{ZEokg{q+\@Ubsg98",^~ӿm7or%A2yuvbrqdjj/Ecju"WػjI9WrXpquFt&cռ|-#S,`deݎ*sUTv2<ЙE| 8z LUJ%rV*&ZZ6گ\*-,k8ǚe VQ KGצ?sJ5#2sܖ7K 0 f9<3-XЩ(WEks$tN;B]Z[bե܋RMFXH\O /e~v%\F_h> udT#'p9A#`jBk2<ɠ5ƾc 0P8eٺɳ. g'c(sJtʲ7aIf\|7pqS$vnאabۦկI%ӣ3}3ԃr8N>mnȟ3|e}] F%R9Q(݌ǯZi!SETdwPYwF&߭o(Ԣ׹J|N} ]b̖џ6ʌm>hGKzXT'\-JbE v?8mW{2јwv,F>] ?CG5أ$:UJ)řS_aZeQJqs*1+F{]TQqӅ)T\髢;yl5R4WIZ4][EљW&F (ӍI{MN.^vվ;8^%ͿuS"5Wx]zq |,jgέʚqܪзQ8H_)'pRj=M̑v69ұhݫ>FxF> A| e yWtc>RqYͭ:#X5m=(o{=6~e.ݿ;k!o&Mm'r0QNU--JQr"ApoFA[k^ԡB]=#$Ev\𢺣Vh5%Z-n#L7̻z}kэ5{ש4i>ҳUVtjJMQ6H7Ѱ>pnqsުΝ7{,ҳF*OvіU5啗O'vǯ4ܥ}?iF<2\ a3)MN]Z/Ychvh-̮<h9t*2r.m*%/{+3oDpDYT䞘]zX}:N7z/#5WvE!h' p;{JlpkT9v7l]m#ɒXg9㧥uSl+F1޾Z\ڳ}B+.Wq+iB=O3^wyN &6{Vu{lsT,v Œ[O3ʄG)#:!%֨s X@۞ڔ=U5_P).ÎffF:ޕjqQlQSܱ / /˜4i΍z:c6$) qRtcRl\ҩ.M[(q*2K2~klk.\?ޣ(>~Qp~\rJ"y7fL~XըgpzBjQ3q!m7dR*&MyCV_m>y#q?GoJPIÇKzP2/_ӭgF+|;ŵ̫& 3VThyJk݂.ZHahU=zk /c+&0mjq <2nqӟqqm= ݝw+cT\$_}_8KWScԴbxKm.iK|2}Waў>85hͲ ̜C+ҌQ.ݏJOA5$R71.N̐HfJ֗R]Vг5mSn28yio#Zty++ڴniA9?^ݫXTd.4U:hB$Vy{$coJQkїR4Z}v p ; ʑ<};}NJpMŝı,+q(N WLiM?h3NRކid?|lXw<Ǣ:(q4cggNmc э~V {OT93z0^.졘6z=zT]kR V*`i*`e#y;hrTɨ7cIGn#fns<*:4~Mld-UѳDi?{ ߾R:9_c>Grj/NM ɹYv̲![ 8_s_N۞,1|МכֿRE|#c zc/]̨˚\/ [xzm>7|Jê~B5%fRT #8HĬn Aϭwa򧮶= 4;,ڴ0F{ qzUG3L)ʥ*YG^ZPl3HrU{3}OZe%UJ҅J>7CŮ`{vY8$u]OW4(?#BRgx%9n9#2w*4oE;=쿼Cմk7:2[an<_p 8IMң\޾id}Tq^t1u+I|1F3[GAF'êUi٭O;7|$ M8-99^n"%NViϡ-FtG)}o{l'p#@$vb}q\]4}>ZsweΛ3+.$l;ù>U{+çq씴Ok];u=k&g3 *XFqG8xQk狊*/S%.0;7=x<` \_Sɖ[D;iKxoޕ4ja!m$"#վ]rVR$A֞Kk_A;LΆeU"&p0x['[iԖ]ְό/늙cF&RUiK\}[/jcr1#ܚN!)n{/O\^Zڋ#ʪO\NkԉT&ʾ. xWRq"|{Qq~q9O3_×7os0 JZ1NI"aӗN5vZ͜n^U^x٥[׹B*l2Xydevݵ/$ xDk;-6&O"٧p~0fӥkZAFKxY޻PQLTbQwQJjqo[icx; zY` dퟯ'JeuhUʕVN- mƲHݼ̙&B8ScN*(+=OFtak.uռh"VIٜɆ= {jm{%NJ>v]K1S\[s,go^F϶G_\Uʚ+I)=/Чs%P弶l^Ƥfr4t+4>KGnJIܱ0z{WN2PM>_O^B_OA/~ںל䁚..Hq.._96չwN>'\,VuFhdpNGXc {ｗ}m> Z˓_'uyT(*7v'#jetq7V9To&%o|gөV|$Vwr|\k\U+SU&]Z^6w<3R-䀣 9FQu*^OW\S9§:T*bUR +$btZ7ʑW-\,U楳/"މwzGZ-ŽV#̵n|pz׃Y{pt)^I/}W5iE77~΍MnQ5Ya!lr{$ee5aջ|+40i׻ N8/BD;Ѿ=>z52M mޡ~\|錣(PTE:{h3O΢CSkF1Jbʹ*WG/Ƚ}L̓TaWE*u.hWm1;ҽNR~e'!&D3oM\4|fڽ6g֗BiVw2Fxc38O哱gYHqVc܌TI>zKlM%JKIxLW[Omf_pʴ$wc&K!pk^2I6ıhE>U:昺c^@&wLޙ}3\7ȘB+͚L,{Th"eR"ZxʋWيkFl8xv:5#ngxo2$_22GyVZݽյ4>V^[v>Yܿ?5 , 30̝~{1Ung瓅iSn-kܱ%̲'bVBQ:usEVJyj5~C-Ȯؿ+nÑ d#*2Imnr$Yfs^jsӿU9)ӌcg]Blߏq=s֧QO|s٬1p2ecq<ҳ+r;%ЊiWQI"XHLϠ''+:9J".?*($Y*g#pX[wr\EY!I sӠ1jySͥӡ/1pnCxCq}crncO~"9*:/ad>jޥ5M-/mEwYa\Ťɑ71?^=N%ym͍-efhT^#-}:TR*/yo򶴅a8Em}ãMZr?Udf!o_'OJFTm.֡%[V̙`d֘iF0r*R񕯽3K yHI-j::bmZ εD MA6O>q&^AGS{c~;4ssA+Ri٤Si_akԎ) A$wIҴ|lS]'kd24JY6j)\w<]s N5yeZeބ6.#C\cی~2y.g-o͈78BT)81Sq)GKHmţ]=ii=a%F(~DT(hӓZҽ):q_n\ $R["9G92}h)>ch>ˠ5̂U&J@ώr,Rk"in /~| w?3:J>˱1P{u(J3L Ѐqֺ8c8+%oz "brc^~}W;t>/H入#(u&*6R=OsOZK&8r[kٰ%Aѱ8}#9b^Xy!eYf-6:t*9{8ө)A{WO/rIdqr}~ש%/nߨ"&Pܲ8nrc QCU;n]1NmmF)J]Y$֗b_)[Y]0P^nXEKU<jdC3:-sZ~I׽pn.K2EUl=ri^VO%Iʬy_LZOsWvzgLqcR+hU׹jVW$[حnO6XٗsUnN9+j}b^4@ ڼ洔yJ>t,k.б1ry=1vb+TNZJ,d۝gh+'{E ؤvɐnr2_ʓom_VO6vUcnRTz"mV5o/`XЌ۝0krIԎ?y$qqyk^jFV:hׄ ݷ8n&Ѿ'N)+ӧ+7Eڼs:G<9RIJ1~Ao8iVSnRQƎ&ޅ8ȸY>eVĒclk'kneL!O[wtDeP oJRR4] 4ֹmѢmfh$ްT}N:V-͵~[̎avn% g:eˢh&ߛ[Xi.6˲OҝJk٦14Ԥʨ+In@=?:+8+?qӡ)#ө WC&Ձe\nK9VR:ӯP35kD7F8f+'M]);yaQrԊg[h^yxƚosBȅ\ȻH.XM[FϺGXv`3OJNݽ5 u*(Rw{RɊMRmۛ''TnV _>ژŕf1{"R2?S֜=O%g+E=Te)Mg8+֧庑*.QM~2Z]I/ؒsJDP9&Iuuӷ/T F}5S9'c֣4]3XNfI8ȷ7+sW#$SG(/˥Mji(h+0xqdڍ UcEJ}hWf"%3,֥TI [ +88z__gm4|jٌqQ>/ IL,y-ʫxwFou=Ud-|m8ʬ~mh^8+=(U#fi? [8[̌1ON]J>tϖV|>YMmBWklܑ_q潏a/yny8zfkZrIEf||sz=+Hӧ}+vFU!*Zho4EiF-v}}OWĝ\rF:g֫F4)5`ͯ^(?SNO6y !8>۶EwSlM?ejRM֯MFH#G{=?*pѭLWR^w9_x\‚(F̻es=2)׍FwSa윺4BM.$.3V2J-mN?yI5e'ע%Ocʒ@霎YdpLsjQ4A$jY6AǽzZJ}L"[i:}̫]UKu޽iaS|ڭw2}aQ&WmL?⽥ZEY6 vpz+ϩT 7:s 4eIsuƞ5{&7uo+o+O#zk*ɫ-ec*U6'?! ڢLZV+ݳeSٻk7HX[Ly{Qh+~>U%%ԫjP#^I&r35F2n]ՎKzQXԥ}j2\\ͳ[LGػ+3ԫ.eo]Jh.JAoy湴~k#Kp2=զ=/?\E;CX^ͿjN>A?M-C4NqBeίg}(ҭ$sz^F25#Q7_mvy6*hvtfFj3k)K^q&v- mes]8zSV)/O,C粳GQ|CӠ,5.NHV#(?1ԥh$z#t&^{_;gik|Nv0*Qw**6/K"4FQzúu-eȒ *Fx대zc~3*UǙQӃkXC{-[9;kG._0OLcVug+ˢ<%N*t~UXmgUVDM091sTw|<$w t ӧ3[ݔvT>W dsmɤg{twLD+׫^M2mo!mr8<&4o_3":QRMnyi-64rJ ;=w]QBzFQI-] BGrcx 80UKRnUEY5mJK7ϙ2m bp㜞9:6JKvѦ֍׾]3vwZ^\wL05 3G>h2c-U,sЍ63\*rmQ 9=NeYe~^3n)5}~f}KF4 ? TjƜ>uy*[#{Ze&E:p}vK e=3r]j]n#M͒S n>b1ռSJWҎ/RMyO-z4;-@`9f8#^~+ j6".YZRev}@= ;ս:PN7߷UfMK[}@f/UOmҶ"/I>x{<:=rZ}HmOr̹eƷԥ'rݽ:huX9]]SV;] ͦ'3\!vNyN];&,5wk-1hfh~{'qs׊xyƬ[,TRԎŗp#JVdvmO'x\_xk%_u-e^4~s|2(z|\FneU,My[X*u=֎,E2 |S[Tԕk_.ړQghdh .QSi=4cu+z[cpxNd~+hqxJ:ssk6Ŭn\`ۿֽL>.U-w`:T{5=:~M3A3F`UH<מy>º'N)^i;w91:˙&iywZ; ʚ_ UI[6YX.Tqy#*9Fڵ}RqaZPSm[Q2})Ѽ쟳ޙĈm>5蚌,N9&E$F2W/?iQhkr:{$Z}/,|3DVf3dd ppcw>"<Nݵ`1^r^c{%t1-4@Hpp@Wu8lҶ(ۙ6]gdtCG)Nj{>a=Ž+M5͞O 70A]=F4O[%o=9QxXI=y׽翷%ß{a+)C(VN ׏zs5DC xޭ[k;&۷˩FcxW֒;uQN[N6jU=}N*ӅLw&o5"Ӥ{gZ >6TSrZǵS['tӷC$Exc-۟])'Gc=4<1 HrOӡOe-yxTQ-tOF\5LvRj2t֦-hT=LɧriXĒ$(8^3 JP=*X9.IkuZ>).e]{Qfg{ ہPsSũIтRi'8kʫQѶף֖\Q] O=WZW EyTk[~'UYCk~e0ȊX2yo ܂ i\7>WݓZZw+mg=9gȣxrE]nh-<ʳe5Q[*ROr~_ViYatI$\7X9}svzme'>anLϚҋ+0ôo}Zyd'={خN2.c4x`ܮ}$Y|λszV2WCISU*+X|V9 ֳg**[Z^ m&3^vךUcOsO<MTiԘ1DzZky5nZFQiBWn3d |wn$q ?[Sng+}ek6 *.p1WMjuV2+&p§; z[ɻzݯ͚MD8wKCoW5zkOBmU̽X-Ż:4[]ד۵yuKt/i Eyf2;1gݞz0U"rbrȑfEie]R>v#jQS2{n6 62V3#2D?089'~1oiӯ>h;/RfKwH18$ҋZw4nirh|Yyfh >ˏ+x'y9R_}!i [e9zƲN^E~hSqo-v+In' ;uj\U*]|R;x--.y(H8=?mMW=(Q&W,*n}<6]a'k|O9~JsNIF֢^ys8dUEu -O$nI5w3ϯ2KTRd~"u$"h~ONXJ*}Ώ=GfYxUAPzǯ8^t%U$QS(bQ<Q:tW&13m6v+ \̏ssFn:$5}*4eWn[x&Pj03ۦ=R8FE ?9$u"ɥNGEIFDyv6y[xœTˢq\|hQׯb͡v$WOWozS#sJu#;kͯ~=;Ϗeۦ1M'&gRT7'neв]M ʲnm' ~\GqZ>E77,\UsEgXѼݍ.=O+)N2z^g ,X#ƭoHIT/ qsנM;v8S)N:/TO͸/v?׽sƬW)Ա@?x%h^di ǡ'КI2O"R?Sۿ*QۚdV m~mݍUID/r2|?_Z(c8J+}!lawcDFKTw7ʹց)2p0>jR3SL0f~9>ޘuy#XsV"ch[bϭf+kԧQ6ٕ.\Z<*}G3B<܋HwRȱ0LgF::U}9Sgԥtܻy`;wyr+m9^+ J} k2:4oz=VO:U:xswbI\+7Dj>՜S7u/iee~BT}GTcdT{[F((KBO+_&(XnEJ *~Eܞ6s|BrN}~8SUco^.hd-I9g#r{-hjBV'NUwgbJW=nXr*"8ڵ%/v6da 3 ;}MDc;)hBİh9 Q$Fݒum(w4l׆*pݺqI]+c;AC^Xs,ݜ ְu?<ت8W%,rww+9sJMoCҌ}siN*QvwaTclORz;~T$Ec:*{tfU觵hG'uxeի?4G>[/l3g޵T]-ΙTfKkywK!"6V{gt˖QIYTz;kRЛiGcMSױO$}~WKQm\dqUcF\RU9ml[DW1nzV)h(+j^RFmcRYJ`cG5ьy)Gsxfehh<׷zҡuJ3ic1Y<;$= hkάtF>KLE 36޾`?Cס+N].;ɪ[ %aߙ}r suWV潟*Ӥf]XAw+UYw)d{WDc-tiR]G.eD0%wp9JԮ*"Iq(xJs׸XNKCGs_vEj) 4{}gNX{ԤQU%2yp.WlsC}qC%*iŭJ6: V"}y{Y]rp3nR2qT"KF,[8ٚFV}ӜiӎEWkKI'dl6>Eϯ\5|,4wԱic}ip}qԏ.V9r12W/h7}gy6 `OZSSaJ16 iwci#Pys zW4:u5}ӻiii´zܓ>_V2k#/g=|Gao8ۈVLpOy={י8/.h+FܔjlʞknY[a? ʥyKYmr,T[2LFjwni-"IΪĎ2FHNº*j*uԭR>Xgym.AAQV~zq^rN1pF sXUׯRH=R -,FÌJrj)nڹ7i˭ skp፣b"v9ZԊn^^[ZVcIoU+1(H82O\RԔߧATS>[KZG~ۙ7L;OlTT<#YJrײБ!T 74{x>Jiki۸!V$CjŔ;cb*NZgG^-r:;~Kmefvg8xW|Ftd{hѭ%Nܓ!eǴ͌O{bB1磷TDKMSߑY9_٭ޫRMIKUꗙ3$r[ ČN.)wۯT3 Ɨ%FyB9݁Zʟ,}ӆRX-ɍ@~0Ynv{>sTQUF1]Ļl=p{tӣir%9S<ู6'lNN=>z~f єMZjRAhl ?Oֱ xVWƴeU)[ͽӡ^8![y-. /<$pa1Li')E?Е%ֽ_R5(@Y.|nl ӦP+ަەٯ!Mu*+K.QU 0~n=8+Pzn̽Jl˦ƽ-$B@'_Bѩ)KDȯb #.1vO)&7c.hoym[vUU$g=X[S(ٳT*Iyn6;.WڊủcQsN~L"ۻ* 1]T7/k͕|dJ*6 ׷Ic6ѷǞy+JN:VR/CJxW۟JJ.#G&iĎ3 kho=/vOd^+JхbG$挥ikiRvK ֙68Nɖ1qҫ$ FZRZ_BâKCwGM(G֥gGtw.Ѵ vW,iGsXcKOW~$uaIOz`*Z5ߠ 2[C.64knޣN37NSrQ{"f,ӧR+/e.X/`Omp3\.103¹ 0jO[{N]a]i9.m>l8Ɲbf[bMUq{ {C9T橬5`M"IȓnV<G3ޜ֋<4,;-VOg1֮qoO# ɁMٕG~g>cUq#xkI"_KI&lV'vkҤIKC/%YYc j(ݣ(ֺKE{4/pϹO` R-ZOSm~whb&0_8zBGVrا5yvi$Vm/dִcN#NQRk3d16=w4QmfO1foZFwQjhe5$$xzэ)%/wϹeIdΑ3vW's^5g5+I.mi:qtww2/,(ko+ǹ.$T-ߢV;iN57쒴ҽXG0=<iSK3mnLΞ%QcBij2Sj8nt{Iob_\F}9M:7{=q\ۙz\-4CzjxƟv,Dng塉wG8,&v;(W枾gM:qd&1ÎL-;[*;$IfFe9h4(;|:y"S{c-²̱*J"QG}n7QIlg2|׌Tr4A ᾁL?J\'ciѝg=}~Y1V3]];=mY x\[O<;:{soSHF{{zѦ}M*Ӫ|>dEaqiQ+iAkkRu*GֹR7.Z=͹8=g=ʽYGݩʢF@g;|3? U=G):wR% )C(jN>̪12'rʴdEJ[iY",gT$/8x}E])IM\޵BB2JO{ʣni-s̫*8ck;}^]-{h %'ɸ1<>~OA*ƛwF&*IhSTpjEʝ+O<ֱ躒ۨDrFFpSpǙN?3F2oNGK GrV>'oMZFتwzTk_#$grGCVnWv^f1g4E*GȭԀ:~s^.*Tb];G o\Ҍ5e'敝G#:|ʪ'/_z{%rRfՕlr:}*"zCa oo"ҋ{ m=}j(i̎ze-0WFZ-E;ajkf#HսnF[ "8o@~Q)%iB!djU&Nvw9Ug(<~kǘ2FM18ۂj.GorOY ryg9%S޷CTy]̫TK]C(<~4\kd{Sr|pC ~R1H7F=G[WiN W`?^MrrqVFXQy5]=meW0n~VЎ:YT*+' "bꈯc = ds+UVz Y$|XasU(H^VE[hy:\~u-:~ލ=FqhT8gN}v )'N;:?S Rrs59TU:xC^ҵK"k 1cvSiw8^lCg4ItJ6F9P~vR1ߣ77rfcn0A#=/$6שm!)0oQOTbWÕVN# ͌cȥ*z5޽KHwс 6 }kj~~kFV\.-<~FaKލ. ,3o0u'y㞕N̊q~F͆jeu2V8Z)4qŵeRASVݵo `d)ڧsk(&tΣK f,_HkHEn=NfڼCn7%k-.!eOOޱ8IcOW"VGyq˹cZJr^ b2WHXg[ѷzJ/͌ e.Z^>Ҭ%סjDu2+W E{k"HdeFA$֋eG9d7/hR8;v)['j{kr'EkIu(K+w3,)fr{ƜdՌeNSX˗jHWSN6gKm2H;4RۮRK(9׍=G#)YInjYDjU8Z0W<\v7^546!;*I玼"/I9E3JbPZXQݬ Q3~Ҽhז"Fz$֬<%&~t8] oҾ!]4MkjwOeX74r(;c 1uZu9+Zqer= 6i 3'Čw ^GF*sž枳akiboYpg-8+^h9bGV&y4̓YXe+ʱs5S NGufw:Σ&q'q95(Ӎ>Tұ4UĚN=%yw@r@+[=S8W;]@X-9/CE:8חZ4ZsֽwexHĥsמF{xXӠK&tkPx[IHE,'p}6玙>hTyosFeߓ: OtL{h9!̃rGpTk8SO`Fђ;㵚$RmY6\`x}:qp )}6﹯2ƥiUlɮz_mIt%mY ^iU6 W=8RWQSqR4ۻ̮d߷r(h(ӧkaQ$1,/tʲ1ebqӓتFw]OiOQm,H- $;:U{Y{ͤZֶ]-6 =FNr>Tb0Rw#xIIHZX$vp6j5lP逹{},/]쓩:w{/6gٱVfR98`?uw8g$RZ%)-u dXgb12OL{V%);7aѭ:ugZu[<|grGظ$%ZmTv܍ti pFXO\p=+QIm 9Uv\^\\jܪ]1Ztӧh(N1KG#gDmtj[˩HS"yrv~{gM>\=7m=wϻ1e%ok.gj!#mIÍ檼:52ѧ 4prVOkCFoyry3!5%IRzg!mVm^GJvޮz[Y-ӷћÿjn2*=s'?*u9ϱeKMyUlq0R.mm7ֹ˚.'xGFցαYB@:֑μܤѝ4iGAwg%ՆVhn\tͭ./Mz\2H0'j2n11ؚ%8ڣ_;F&#};޶geH``tOtmV= 1c%w_5CB7vZ&0~ec@V,[AG R)3oy\7 Ks[9  ^6ۧOVgꢼY^+uS30$7t4#CG;piЗ3oFcV8xKR5t [XדϿnkIFKf]84nw۷('جa>8/N Sݕ;^4CvO$cڮ4}tߴ"ekf)B'z@gMNYEmPa=ʍMsǬ>>ӗݲ2dhΞ"IcVa8郎G5%ylcf7En1B2=(H*8MiU+Ó;juzs֥7;ND#*Jo^koF}[9*Pz5SOW5i6ZU#a%QxA906w+V_RJ8wm^_:xPJiy(F1˜ӣF5%;;^E *IFvM}= &;9!匬 `dw!<;8؟;跶Vb ^n%l u(ֱ.H*ѩ 6!pr=1x2~j{fj'M={)1tZq6ۆl=pGoަ׺EL+HZ)oc,~?k0Yxkw了7*$!YnsTcNmʚOt[vꖝVE%'+ZͭumߩGR){}zi{u> =NHJW19-FaӛW^GM:rvWkgFO}q" 0K)SjN>'nc7~;𕿋CwEk6d 88qu)zQӵ#1xyFKX-{^UwasXtԜG5,%GQ"ՄQ\](@3{Z3j;8ijVPjWo9gv"5)R]L&آ3ZS)+[.jvHʹ)JdΌ+Z>4XmxYMf?sM5~xM5cg{W4TQǥF:rvM<+"Fo^\,ʫObmr$ب{Y֣{rAmq1Vmw˻*jF>*1{)'h'Y~_i|]mcl>i(mwbKT4w~مR+ʖWQ!o˻8nE]X3qԩN r4z lڹwʦݝ8D-Y-Ƈ{$t1qn[SQpgfqd ޞ^tX[R)ǖwc>h^(ʶ# C+NxZ֧<(.}]+EOe5NPt)RytR coiu*X[B+rWBrFmØ3QX,s`6X7ʲO_.R˟+Z1￟oT䒄a$QYF#5JM٭':7SI~F7a5*O(qBKW6 xdU?=%&{9NmFKמ[7~^]5߬\a8Ռs8|< yML..z5n~0sɶik_GK'xaojOgc3yrF7ڬ1h\\WƘ|BnI.~qQ8TӹnH.'{xf)gP+8ϱYG7|jҩ-[},j<[_\X]WN9SVxKe s+[F )?}{Ϡ/kHUQWlxA=?:Ʀ'ܩ*u(-׿8q! Įm~;v+Q\ב/(Tm"u}QQVrMWsU?f$|+v"E+=Z:zi~ڤOT',O$;x[sk?^+:)Iӊ맠*d+$1#Ts۹5eESVoT~ C )"@Y#3V1XR0m.ȎtYіFROL85ZQ侍4kkRo'm- *EvLʅZ}Hy 27`;V\MʣzȒ傯62JWF4Չ)F*m9kA(מOAסU9SttqE*n#(iJ[ь))vo2S gc+U˜+sj]thCF)3++';TMȯI4i,|}ю3ߞoF_/c4))iY/&[1%_ep'O sk*=֧U:Kn!_:gՋ6J׎ՅOw0ƛj+E&Y9@b^A5R^ը-/i׳O{,>bn}:h3׶Jnϯ{.ɕ8*G^pXzZF5%.nu:nRn[. RYK-OrI 1XݓH FC^;O瞟(V#]5NW%NTř-lM͑l 7={b+h9T- {mC07ecVa|Qӕ;(ǚ^0_m3LFxW]u;pཟ#Aק5\z9cRR/cr3Q֦hԏ5QQî퍼7fUЌ~=+*~Sr?#rEɬkHṃr4ʨA$1xt{zi[G~ϕd qm2mY3ۊʖ"Rڳ(ʳ$0Y=N7u*ϛ*:ŗq{+>hJ.-zԪl$xat'q=ǽWRdmei$@6Ds0= z$*ՔhU[}UWa+nI$R-Iۆ< !S\F5(1Hڥiy.VU&](꛾'fљO#?p+%jTʜ[| ."W$sOZ)qV^EZlR3gbRB~ J:SIԥwMnv[Y翥kMԌԺ-f,i$mߙlo':ԪEZ6OVΊxߚף3]R͎ʙVĪxS򔹪KFv"LffpWc qgQT\jWۤO <8=N^tgJiBtŕo~46]zy㞸Ukc>qClC0P@F*SdKy`y-cF I=sː+Vq̹4]L3ڗ]9u}0ԜqQ Tj윬 KJQ)[z4Fi) C.ws~k'hrI(f7s#H_jrKjϯslUINK etZLEInϭU*yHϖ־i l㏗o*ijνeD.+&+2 }Gִn1Q5#Q[]X$U6;zb9FSFm-8v`OQ{ ¬s9T1?3mܠp3zգo۠N>KryVgc\*cwO}b6mWΘYr;p?+R?g5=^aC:F]ɺEjj^+ש*yiR qCb2J-(>o-Nvuyu"4}Hc+oִT散N>ۚ{[dToDZS*qnqt%RM_Ց߻cNQ]MYdi9oh|$uV&Qp!rSjegqym@/JS5FϙnhZ^}R95̍oq9k4h)b*{oe+5Z$s׶??]ЌZZ֝C J^wo?}V8V#K1jmYTD.;3:uӋzt=+MJM]3SFK|ydg2xЍdpUӛӯ _0X"ё8RN롧U'v}p6.ͿPx:R9Tq~r.uYipWWCi>Y'cOiʽr2;/αOUR2[1k[v>m]Aec }7qhϷµE(~:w ' u cч< LiJQV8N{_%7O:܎tB\6]9M~O *6y:ieh6NXN7%`gH#Voݹs׏{.Hߗ{/̸JJ_?#6=F%#>E;p};Qvb*¤oWi&Լ4 0;Uѿ6zuRe5漍QpqZ'|M>⎃zFQd \w#fN8pPku<Y*oO~6xTSaOm=x8S߹~o_ Z^I;ԕE[,=nխ=9Z;;FQMhٱ2<5u.=<aA.F Fqtj_)_WX\+^o{WHu&ڴ9yzS9F6>&wuMΑ}nmVEQ 1?)^kާ)$G)/fkmoarфl10A=#$uN2Z[{VWXV9#ȭj9EI\ŋcLXD;o'}hcBV9nPoA4RC&s6ª8ySj3/&eku xڅ|wH猑+j|Z]ys{h8kWHdG4q N8=Zhڳ~eӫWNL#ceU09 $q\jJZg(3G鲲AqnfnrHޟwKFIrRu]F:C| 2g?{_sE9G/u/鞆/ƊtemSK| _e쳼"{."E{^ҝhEF^g葩i£J*[_rZv4B+dShצq\k8Wu^*\Wϊ5[61[}\ps޴ʃS, fiYn6Ǔ&{QRk'ki\.5ۅVkib#J cJ!OnjI Ac;_k+˫P|k㩚`Nnbxm .lV+5QJs8#SyoFc]zq\}/dlN(ÚT.acFMܞf_M7̼.{ rir-S4۲}HUFu=9}7"Jm'OuJRdoNTޭ?rL|!bʽQ]NE>k[_QG Fxw\!M`y۞9S.y/TIT^Iou:mN> 1x-\ fI:i;W;jfXd:wXR1 ]ch#kXac?[_thE62[Ji#Rhԣ~ΌH0OQx\`rqqU~ߡߖewM<LZl6K .ۍ{;q]ؚpS^_3Ͳ= JtM=SZ_m?M{d3nQr=1׏ h6GbB6:-U׊+ٷ0%Ps)a)4:دK{t*u}MDw{,rFo:M|~X郐NGSrͽ+tӷchfsmW]x2 ǀTic8=ң>kߝ.Tw{={^ɖ{Gu7$Hv's9hqKuԣWNwC+'L"݅$בtRu"u}38K6Ok[{guM$r[pqk!r4ֶљaﴗ* _-x_%~bÍ=bgMɩEKɶϥgo5GƑڹ2pO#`CJ4{ԩ9rwO$bG`䎙׭,Teʡ}liCtլOuk[ApEs̭֭zQ;iV}zdkڪ['qܒI+2[[XөI?4/<8t@2ˮn8#^U.ߟ3^KmcV]fSfO$9s}jSұrӽY ׸۟sE̖l?m݂aqY}sZw0G9%%Z~Kb&EsHG\4W4۷ȇmtU8X t5sM̜4gR󖩜$I'"3`}sH-z ٫s-<=NJ~eN6?SjΥvQEF[@{sq퓆~$}1z-Jzը~Ӳ46$=V[Xv.[߉o߀||u$қvaw#Ps өRR=,oc< }:ކ[G|qKq~HICE''v# ))&xUѮ{LTq2Z'}4].yEnRxEۍjGnRVS֣%n֧=|-eҾnGY>N?3˫<kJ55W\;ԡgmrczXi{}ZU*uC~o E{7.A826>VF65FS|yQcM>^]]6\? ?T&j[~فi B*{dsAҖJwKsLN]`IEt<[e0HQ]ҟsVj6_ȧimqqq<}kTeRZ#д SBIH-&,}+:*mOҏN3ѿ>&K.}tXUYlFyc `Nߪmtx 7:pz"?>g'VZA,wݰlf\'RT*G[-^˧Caj`J\d~]Wz쁡| n.4};޷McTi?Ջ\˱62tBC, mfU tTF5T_%{]֩k^ޯq3lhFIsݥY{uǃ|EKgqxPΚ)\Eq, #@CF#r45;9cJJT֍&Nkyj^GxwѮWʶHY#B9 %J!p|TNgZw};8?^jqge{I$ܡoM,/?S ;'8(HidvdzTj^[{HAdc+MbJ}YF.-k{Annc[n9%T:Tԙr~n/Ridھnwc'd*tcٟزQþLoNMoNmZr'{}u,9Uьl7^ĎkX6^9FZ|v05Gf򳽀g*}sRGUӦNZ s#HTdd?Pd.OX֬u9&;hSA8^|`=NiS2tR3I!L#qNw rclw2B졔\c(_UiHqb{W;]5JzE.ؤ(;x%$sk:Ӗieh\v*R۳[JbOjpijz%l<,`*6895#mJsF[YOU3ӟCKnmN>eKp4QL9ڜ_4ӽ2@HYUjҞ[7$* ]gϜdA435H)]iz5)26z tF\̞İ /6,{c#S'R޴eRM=Lۨoa6]!qzjrG8F7sױu)NZw -'O{U9ER^ǚzW:ʻ lOsF&TisEܧ,H<~^Hz5hJ(䌣Rzid^W̍U {{zcDiS{9{5(3naD2 ptpynyR頑f򤸂V-L+(ѧNm/!^m6퍈Wln8<GOi!˖T֣d;ou«sڕ:-Y#g%o%b.аFVۃȬdNUV92cqZƤ^)QkݸƎ$]7?zjVZU.^YO3 }hFє˕ov*4Kgb˜F)2p{z{+Jє}ǻ#Z&53n_3? qqܞOd3F4l/"ݽv/jqK2k~QirI-6Ry0%~W=8'MbFNNmn:HV,|0+ϯd:U{%e^XTlqYfM#"fˬl}gJhQsקAdfcPw1jT:6:E.-$[ e8v쓹Jޜ(9!hؙl&C!N5W̾yKV^OVf[ӍiDEI3>ccs}*k>J-GwO*OA^9?zQ-)%vHѫa#\J~(I{rvZϕ"č5L ? ҵ?i.MhRܗ^YepYĎy#jF.0vM9{B& 3P]U9jUI 5}]1Q .}`w]%'c.%IJ$C$2qs=J텩˝t9TeO܏Wڴ3-aHm #G>Z|j:tj 7}v2]]mTXBGa1nA=1= .[Ȟ|qGy`ʻo~n(7a~{FUYT#?7lg㚚nmb4zdխyjC䶅°V\.*52+׿Q娖ݖYx_j\ٍ&9zZʬiԏ- Qס5EyF ~nxkƲ9i"*Snu\ڇ˶Y|͸`t> pq^e~jJatimh+mBfǝ!'ryWZ>~L)ռp-iUӮyWX[o5%Qk iv;YvJ ~וYSG8+Z6ԷŒ*,iϦ\R-S<# *_v%Zш#, Z:㯆JRzyGPI!xEBsmLjNxKZGfeܻqrzZ4V_#R4` |mq ~s޹mJ/Hʍ . ̸e{LH O=zUN>Mn&, +n'{_qJj[}fH%-20̣$cqpv)Œ]UgnZ5SywF{qx_yʱ5$]gjrFb!rU,=@S_j]S^g/LZN~_מyzԊv[eS^jňGX҅n|UT 'zr3vV4FUw{H.˹߃FHҦK.]XSM+I #1I2ܫ`g>J2[JVO$PG!X`Xmx#ҧ-X]6keMC8s6,TgZR+WÅNwK $&~g38?Oz"QwJꌧKH#u$:?`쪴-}dM[G͂;O=jN4^]dUdgoky(ӖyXxEUK˱5@di7h[^zֶ]^ʜ*j+ʭi)8fmfUCHzV.ijﶎ= U*}bn&-<͹c'n@޴ .3k>;n.DmH}q8N?9Ib)9TG2 _1~emb7c-0ު({,TZZ2fAnX2>Rrm^ڞ:4e>f&VQPp緷)_8jaR) ͼo.76(3ר /iuӧ)sNR'}lD,l߻ NOc_jXj;X橍MY͔SfYd>XBF86>bOƶƻT4 I3]i\i'V. +'} Ks,kC}? *1:(R~%;'۸e;yzVyo)qpq*#y5+eHE gj/:42WTq"r0Fcui>`O5It+بW!ݚM "XEU$e$Bzqٓ"V&5b'*qIF>Zvq*Ohq~~ֵ4R9FjU/º)=B&ۡۇw{Eh-\Ɏ''vrsiQF<ղk[e3}#*H?AXʝG+**.xvηPw`˵r0h,G2켎&RʱGl?ZǛIG.l,n4:ʄHUh~m_Ʀ$ޟFr>i%2|d( ~UV散+w4Rz{W@os\Ju-} ճ$7_4UW<9cs<#/G3*T\~zhqF*;zh.&w2'8 xcGz{[dUW$+Jqr}twkvIirѴ}+ji]iJ8jM+f'98JZl*~}1~fhʯ~lg<=+XFe)?+;xxAK7 w=ivwc\yv[|27ʣ89S!M8.OH T%}ңPGCCךKNK T^meY'%yJ+6s|ӵ.Y?vZWQu"kȼXQ#:G8>\#hF& ,cݴ'JҜmtjSճ6cbb>~}~:zRRPhum噇O׿lW\#ͥ5^u췷db#J-uǨFM49c9J./(^V5A=zҢI:=Z3ߴ鷙^[ċ+HdY~b2y` ={uy[ V(뱓'02F0#ٮutƕ43]QjirF) )%0UP3LWNYK|'獪SwFMń3K5-Jѩ״UZ-2R GSZXx'UUmQYޟ2ס4]5yqEp̠ c+YS|jƕ(EK˕ #0F/n٭iޤ[X$EA\ՖLe 9u4{GocdkR4KZ:+a5(;.pl%۷9TsK~_Lkӕ4oԪї!\ѧ.̧;GMj*+%g%c.f ]OsWm'QZb9i ݻcSO~a\yfqu Eolyg@Epn9rHg~NIl$B1> *THMN8:~.C,!-s>Glr0}9ӏ7_Ro-m>Qōӫq󟽌q5jQw'e@l 8ۧ-;w/CJ!3^-\hv0:q r&:8o\isi=ܗ1GZFQSgY-퉾_c")FJm|9.H7fC> }w̸j-0QEvǏbq8qԗ5ս<{Km}g2*\ѷbjF{\Ӧg봶8)rTҍDފR%,(oeC@TTO륎oEɷ+ŭ&eڽ\*QO]:rut] VE/E,~zWzZҧt~'5Oi*L<8`nX:8ju%oĽl(K`n<`z.F 5Wkgsاctu.y6uQ愜 -!cnVwd 7ΧT8ڕ]ƥIn%VMy8 E)VTS*RSߊjtZT vgM9{EG)6qq=cpUVY/==y=M:֧-=it'ªZfuxygf掍_C6dgvCcfs>o&q<1`{ g)^ΥNi75ku QLb+I .i%c<};8&TUTS&>q.<"R!oQ?ތKݮ4xvѱX #8:[U)Қ}X*|ѿMu)w;}'˻ˤY,S=k٧R1WnJ:K~&Εuw}y{F;G_νHV̕>ZqnoiwosMwU%Ƶ=W+wFUf=;~N毹K1.浜п]hnҴ9ejFnj~qIssYaR3šf>:ϖf?JrvL䜣/u^h䝝mϺ5,Ǧ 8>ƜmsBTkZxZ;yd \qA{{97FDollglfݢaK'g˼ 6#%#;@5Z]T8ϒR[>:7_ݨ 8=x:QJ~ۯrDv@O" ,{Eq˖1qO-ukXrp:rJ1QqIb!v!F:zZNRJr!ts *=pJRQʥX~ow/^YTc*4ũ}40&JPdΨ0wзrػb3HR*%aNQ\]l: s"=۰CWW莌< RܲHUn u8z\M iWC2hVmeܭׁѻz]{]"e]Z@g_D8]$~T}{Ij\Fcn+k"M#ʽ[h%\/or}OS,J7Z۹бѩ܂[1m{\uaI=Mif+n},.w۲q$)y'SROa7^eárXa4Q&HO=?ZUBTGʮ/!nmⶓhL۲9#?)EA͕9rEԛZٯ2 \rTL`Je$ƥJ؊Q~$mjlt{ߕn; |҃sZv1H$5NmZ24̎wq(NV] R\LG/up|*;4!IX|S=~kԧgHbNs|ʷ^M!H8[T8q |à5:#K%s%ZFel(Z7mf@@?(#[A.qʤyڻy3pzޯV+eib%R7gP#/ cn1Ns cJ2oK\#+ZEѡKf5q~TBvTv混}I6 -/0w:wY*JR~W+4uVtoאNpb%ɆQ{/3h֧'o^6l$MInW*ckNȓR=ս4UZ>A;k5>NQ{G4|H{XI$rE}QK)﮺qyVy{g¯־FY>GfmfۂW=8#9ql~dnbr4{FhۣeF=xlvyʃiGd\E1q=ߧCs-Wr QGexplyX Yyt9q4qiڧ^u:h%w3nAG@~%ƹ9e-ah#Αwøz=Ez*;Z.gEEZoqZ=|O@^A]0cҽ,,cNj-z|/4/58-EXڲo߻n[ zmRxE.f}6ՈNQ7G \ u  o˱1` ږĨKxzXl|K>KPw@!r ch`8䔚K˷Sʝ:N>l=hܖw6Kݻ1ةNnkh?e+oã=@KC*4yRI#i'W,䬛9Ri>⺥"5\۷'W+IM8X~USkF._]MWu1]ps}姠ZVV/:?YX!XO9E`T99GL>s8KT8ïO35O6+t$LC"#>\R|O?FXug,jҺDRmNҦ2hƆJջl2Jqyg~LWO[= ae*|ߪn+-3M)k+wz'>ij"K%{\]Ȍ3ac1s}OrSW[XwۣdIrȣwLIUF=<:t/ Jy7/87e,g" 7,..{:]8ɵbb#w̱k &'2ɌWJH [Xx*wQn|3Ӵ6yr2(H,͖Q8r)&.RW$d_S4DG6F$lz |\U154_[ F ƙ{v`1]\a}u3!]8jaGX{8.Tz=4OJ1ZlGw%K;/t+CϭN#)A"e[zCZ3Ж_tw&[(%B#/'L&em,cƜahE ͂huWRU>JuU#NoY|,墤ބq77+XLS'RqW8ƻMc^< []?o3V_No߸*Sj:|:X4#2(]j1ӽkZ}4IۚnnKt=¿G4S<`feW%pz`7 x2=EjgZz=~)I1$ W5lGQ<鏭rrխ{QmtgCgp^Hai#sElc i[I#ZSK/XCv~|vyȮJƢ^w5!FŦɜ=Gӥs{81o.ҧ7+^Nq+|΁P=?*2JZj$N:5MC5 h渷|ڝl1=oє(q[t;#⽋JcR]=dI8YWb\ ۅ>Wc*')6%;ֆҼLmv{)y>RkFJvPb6bA$rNp{tXj-R*^Voܒ䍡-MrǸzjUKNgX7ש#fm ̓q NqY{ZϡYPOuڱXđG.8<"ÿS\w3F)5BFC\d1ߚ(~NI)RiuK2+48L>+R2mM}}t2+$y\:gz=Jg[~".j#[ c #n3uycnZQn$,Q4)ێJy{_LKJF1iU7cۑz٦s%b@Ȫв9 z񑎵cQs5{}w gwi_@LpO ɜJV=ߨAmpIHdSUb#=?投92cMw,+F"vǮG'ޢ2*nQikf܏.1c?ZJb#?cOymo$l эy$:*֭w!)Eo ryݎN3Zδo'gaF^"iV$ڨݻa'Z ;Nc+JqN vˏ3<~< ތ.:*bؒ sdm8ʹ9]N1t˾+VRrhd^dk6ǰu}޵T:k0T,Eq?oitv\ߵmRe%()KI5tm0*C oa_]O7m%[5od Uyfq]TȊJWXnM`vzFnUksY{t[f˻qJPc,DkSZJ*셕*#)\Zr$H |?3t9J R?gyZݡF,@QYU J tƤjBۿ"8I6FFW'(' cSuׯFNJKx$o!V7̇o\S~d֩*,Ն[,yjVi[K >zqΘQ#>KjR)eT$R}29ۓsָjb*Jiݽ)P4cnm"*рpxWY(GSJGVw{T%Ec mxhqo Vꤥ;7`F1CT!' 6 pHa֮RfS Vo-xQcR1};= 4. oȭn#: މb+JQW)祵۩o>[ϖ8 Gݫj59v#uV֥;?`<}?*o^,Vutg9b> ^9U 蝟sTi~Tȡf:ѕc98(֣*YEw̅f>~2OSNr;USv[k${e|ӎ)Jj֜c:z/f+yh-t ڟXNKfVG%sʕ0(T~Hy6]mFߗ mGݰTTg+iy!藗b-&W8zBEleRt#wTĽF$) '=9Jbhhq8&dzyq&KH=GmYi'rCulU.ɸHx3zRRvZL-4O~(}:^{y9&9Ѵ4o"(& db?{'54VV>^:4ŕ`uk;=SŷE )ve^e,LyR n5[7#=>4tfF5{~$PAɗo6xr mSORaKug)F2}/R1kRvrXdwL ? ֍Ee(®<G#2U9(~&-X]Ψ 9vJh0jF^Ł4Y,T3һheSzlȒV6ܬz}ku*ܷ8$޽_sRRg,ȿ1?3eONRZkIJqj٦Fi<שΒkV)CsbJcLm2}=J4J\Վju%NJ)_v5żm& 8O[۟º 5%'˚}ͺm9=**sJtכ]69Զ[Fd>ccs~lF:ֲ=JTX\e/#| ܐFʟGZ8M7};~ZҌ$,HI%o!HZOqzq9V};FTcf[CJmCPk,qo3o?)%<ҳ#%kµP|W o$ueJ˒폗kEbΌi6ށ懷7q6ː‘s=jr#B|V+ԛkd)#qsגr;QzQSS6{ "f#eP\$oуoΗ˖-JOF$h9럡V|HWM8k}$E$ߺ8 NHd{֑?J9B*g qyiA۞q7;}lmН䷳ 9G6h'4fЙRqN9[upsdnT8PW,uO>O(cFp 7qϯoJ)IiyrJ][е7WB˻G9\9yb~ӣ$.rm,v=xV5!˚?q8ƌ{xNc$HF:)F)_?R(X' <,!9Ϩ.Y.OIuS̶д<Ϋo ߃VVN~F52ccc!1M$rFXS`ЌvZ[Z_EY-UTkxap.y-8鞢)rNdJzZϹKxWYgסӽfTֈ¼9\6{R]yYq rsÓQ%N[n:έ~ZM5Byk¿F7W2.[B<-~wwvk㊓ENlW54S^E;+exy$~W'5W.jE:6E;ϵK@F"&Y{V.g{ӧכRmxB!'9^\Oڥˊa*z5gQۧ&ׯCgs*>ϨOҾwRnOT3}KOO~(w\|о=Hy8{8;?J}l<+xsH)`{`Nj?e.G'/-$nF:O+qQ9yS[]SuضВWV, ^iƤ\2~"^qig PE<-&Ag+Z֒kb09r]|/ hwxb_jya}・^q^NJK(Ty-/kW4׍wtbX$l6aA'i{quF;L8ɤ).k=ph}vKozF*'*~ =bj^o mO]b顉b]&ܨ$h~ppsN"N,^v8a|mo?#ӯI(<;m3]4V6.=+UJk&ݶg~Z8y'6 |X5PD2L6+qtv[d?UjE6ww8jaN{p'# yP*\ v 6H)J4dZoTM;۶ס5R/niO#d'nݹϠ;Ie^߶[THcgd {|VZ8I>d%K7(]]v4O6wdrBdtͺ<[$6x:c­ԿƵ*rNKyz|[(dkI6+8?waT*++勵?! k(uS$8\6Bܒ q^\!iGVG(b%ht쮼_g=V;*HʌڋuOLk2:2O;)^ۚZu8ۭ5bdFEgY!հ;Z2SRg,gx[5#[R#%ĘG'^*Q:迥Rc*g^(T)Yr둷9?/ cB{5ͪShʌ4Vwᧉnmj*"#l.[8?]=5&gX Fk;&ᳩY"vsۀ;WI7瓉9{{&ci~"ȒqBY>ЄhI+Щi_]m֜cv}ѲuNk  .(*=I<ˬldc:ޥ㻫T[98$W F@?OURDR4ڽX]6pw ;f "sq8u K'CNx+ɇ <,BLv?.zdqjƛrww9SFO4h};': T朽ظG )jm>x-^ n9=o4vGEۮ,뚫$sd'q@vN4DL1p$ 9V&}?#i)ms"k򳣈ZONNH8b~vǫ*ha8&|KX)Y.r1֖!-mgBjI{έǨ}"w^MSգ+F[qttk9b)¬a )ú$ɍ"P.Z?9z},TɨއJ&}ڷy}G?-kv @2{ w`*Y]ktic֍/SOn"T_)2heO$23+b=!CGCNNhT}N6w̋t$Ь`p!siT-ziF/5&WG9F%\zD;1qz \yj^7[?úsMYi{'trGOvPpG9{W=\kVm4>3ømom$"(C_U7%Ngap}ggŋ.]w=~b Kx=qiUmotNʤ5^kJQ#-P #gU⒂}Ld再^|:1毕mknvǠ$mrr10L$R߽4udԼ7w"k6R-x#:5|iZ]:y^7OEӪG-geh}O><˲FwY7,I^I?Պq/+Ң=/So-(# F+[N+b*X/SRMn݌VNI;9l@gX^/XӟJ 3(px<~'&Ti9%xN;۬ryUywqӠMOC U:|e2Xz8kݦN1f,v1GsT9fFR5 Ś>q)汼mCql0s#55)򸵣GK F+;ʕiel6NF C_K[w^S%[;>6//I&TqtIQGUsєTM{n}+Sڶ?4\֑_@ۘ N;vԭF8uIJ|MlmCT\zoN;tc#%ջ9s|e:~I+7{>K .,VhB-@pqv|J[_?/so{գd#tm&qy<ʒSJķYyoOQOz*sfy5(MEa/?x*}s[PRwب1kP1X}1]gƤFuֲhDsF bz Q\iꉫ(s߉V&lWW@ 58Tԣb9c&m~5'<$p"I?0vsmqMvƜjJ)tV7RmIn幱Ig]efU*V N{O=*jF#ߕwdFn?R5x̧jo\>}TN$iUOEߩr!}c\ʌ^FUc-a/cSKIvjv47vMc:)FuXӯoD $%N+DR{-n̗ۆU$yiǢ6S4V~trdدU;H3Zb?(S}6ҝ:SvM>!2nV0zЩKOIN;aNSW7e̾79bFgR䞭4ܤ E1ĀbP:(DoV"ȡ[$X +HHE-V*%UݙpqB)I+G_/261J9#]i2Qh9mGPmv\R99EP_q"^o`GX퍎Fc޼Y*~QRe 7 j,|9瞾Ҫ+ɣՂf3?x\qc89SNUZsQ_M"QA mf7g }=\x,wi6G,B?2󎭏{cjchD'gNr;czWVs"-ǝYHxn J#%GQWI%ݴ[cnccWFQ-#Te){6m1H~XI$l^*GN){4"s4l~sC׊)O,Sk{D3B򫨍\3Ӗ({ $/:n_*ݑ*(͗qщy.kveE*Qzۏƹe(lEkrL{FHaȖF0"<ס/jSJ#F`Z%iIHu9c\bD$n'eU=R/iD$n/Nz~=)7:)9MY"Ӥ߬~\kX6=1JAFUڿ9l,1늸HtͱV3,тUG\ wڹ?gNUc#TٻiGU- !L ɵV88rEQkʘJlQvv)˖yB8Y~idpq֩׏kcJn'eyxOV9b8TessV17!UN*ɰ07ۜ);lT}ǯk!Es42a`pqFGU*˕jus԰YۓU~UC{g=k>I^*qNQv}#i^rcs|=kJRjp#ԕ);YA=nMqm f'USש-mT]M2Bv>Kx8##HpJ&iFe);K5Σw~ӏ)Ԓ|?}+*Ep}SjG=brI{˩4,y+7OSͭ(akoU bܒ@ {F_s>DTi QFO̜\x۳oV殧,R&iMJ$l=〸sRƔQgSQH}*JS294fwLm>9w3FHrrgo'\zVҟ+O"U)4E 卥deY=Yr[Ƶ8Id9LhX}P=23]4_:s. :o`қvWfrVkO<d 2zz׊RƔp[Zh ܕ tѧ IM;3Gk[0 l3Ȥ<lu_m=K.o6PF֔)ƛvZҏ5Y}eV "ulx8> Fj:#L,SVe4[@RmBwǨ49b(N._ɨyn7|cץtѩohCPx0v=dt䌥JuENm+-V.[-Yr =9^ 0V;S̊K0@O#ypXYG?.O\z~]캝SN[?u$SۈRX>M`tUX^H/ne_YK51,b5\-YG ֮uwK++>.-=7;!QQ#{[V[nU1ݽ18ܮ\*2yF+eg)Y s)ߦkԤ鹽|c*r],c3^-Hh*C-ЎLIe۟xMp׭*m(R\i+4 ndl}y(ݵ\΍$xۆ| s^v#:rS[Ae=8utd翯^}IF}_`R K KÍ$?uɻ&VpM48 HĒy;8b)#=xqJ3ϭ%*nk꼉F]˖f'.Մ# ;{.l8P[ē8JNrh32:iZh˖S /6VQ{JNicmϡn8uF[Ϝ~]۞qNןrc=Ti[^Oϱ5K~T, muuZ\V:ŮoBK֒G1)ʎU:ѧ&o签g=ձU&ޝ5fXdvıNfs^vIӌ"ݼͶŹ7DفsnRSy.*5O$MDؑdFfQ0:穈qh_<HՋդ}}u$fPRfL($ sG85.j]:bVq{!#VU4T\49<0G@9Tu_ҤkyڠX/o3w 6kJI/]hq0a% 4pƬ|ༀNAҳZN(ӫ)E5n,o)Rν[8g[ ]WQk-:"y`^X$c9j~WtOgU^L,pGn§&G8%Nƣ~frӲ Hft1xhF:tJrE֢c%lr2EC#*^OzƢM4Y!iu-->[H~z\NԜnУ*ؤ][m:1o_#=#jδT"[ntG'M=>i3#z1EE)/^}.2ie3d6V>1t#ZSZ3Z?W54ae@YoX#q̗ndc2Ȏd< ?^J錥ZYC|p,}[Ө嬝F T1˹aVª׏\Vmws~1ծҶKBh?7HUB݃S(˛&t%bkf<2n?qQj]7fyi.Ѭqu=sYʔWU%Z[b-Mr`ۻ-݌/,_2N*PTݶn<ȁGC!a Xh{42ZussQHUF0mS6m+Ddm! xNT(ꕥJcm[Ze[2\b9#=RWϖ;|q/%| ~{Vҍ9N4JI;_MJb">2d7=N:Q_.T+IBY$ѭ`n7ш:9^gqI92+Ww{=9OSy^v2Af?RSj-e;d۵b_d{:=$N;7FcdVoAlz-8RNF0T淵s Z9iIq%{慣8,Eid^6*գy&:@ysF_yWt1/3=vά죱lg84=)|.roF{:U*UVœԋpwKF^.;:+z30-S,VBcT+sҩW~[dyVjR7:Dq+- : OSRj,gLi<͠D>65=+_[p?稩(ҋs~5N2 G6d 7hiUz,ro]n6qi2DʣYrNn*jZOqmD;@+S(򕈩Fvf %p`sNW:0+V YtOtdfj充d{;1$k++U#g\Tyi*&ՒDi6LOSd)ITZN5-nXe}4zeŭu}-i>^0>º*?kVJ=:䍑1'a''=Gzԗog,=G+.Q݃&o3W8?1Q{3:5ɽeT/JcRG aq[R冭zN1^j-Iv]C*].W 68$g\qNo& ;t%Mܐ"l%ws=i4rZ.n7̡#>|Ge=*s)+aZJk[+&eyXb#*CODBGqҲOg%="OE{Eo9h)'֯9ofYy^ksnlӭNpb#^uwAS&ەmW,`9JԞ FKm8_gs%R4>];x=}b>#4ZRL۷{KEb99yӄiʵ }_`YZX[8'k- (˚:سlgdm\~ .Zꓬ$h2&#1V} c՛hJljiڄg5«mF QS8R>f]f\3.~tF1Q74mK`[hj=Srɵgd],]&]F>(4(hdh̍aN69^˛I4a\n${*%)rlcSTV\3zʏ+R9ӭ$0uhiWҭX*NdV1ѷk3*-ymTՇ#ָzNLD-{٭Lۭ*8FxdN,,}t;N\G䟯k%(֕} (tj4: K\+g cFg9'W* r=j5)M6DnH=±ަ8Nvzzf>[Y%IRz׳y\W*Cr:o]TyheQi3Zжٷ2gݜz֯f2"IWG+]-fBMDf4~BUvkVsUfhF&f\ gc)B>u!Z.Sӯ6 *XO8Q4J1+'좤H%𞇧zsQi!$3}]Sϯ=y,XD_*OxqڹnʩNQu]Si E9vZ˞4sg:tF<㞙 M%Nm>MG4I~v~'{+rIX'o7` J:q^]Jr#};-@]8]~Q' WV;.Te'muJFҶ>#qs敼+QԊ'klwpz_Eʽ 8{/yŃʪ l[uR>I_N•:jId8% l=LJ2J.޷,Fm2No7UAߥiNRz4"OM;3[\ۤRq'ۚarrЩ^.k[vIj/ Qbc#YAц=~́wGgeDacUZM4/Cj%Q*'gb}ӗ,]#֧ѭiE_Ecҵm;Q|řG*tָlylq2gfݍ? hڃ3pex|||\evI/gfHmp?^}L/}S F;qWdN ʥju] O <'1Kq/Ju3uQrrmp~<*5[2QLVtUtvF"ƫv_S^.76[ܮסּn f]/z_54՞r:G\+2|nFNrN+Ωm_Fv-˜{l~.ٜsþXnMW:5.H&kkfa2f\:_WtG'RQ]n*#Qfd ̮qiTbXJQwGA{u 2ݙF@1{Vj}Me cigC&sjqDE~}K7]}q\iyհm5_M"O|qVz(]ȌRMhU{>PUV6B7n7 S:ƫamu4BKy6yJ=vC.Ciga&Ac]NQj-7?䙂ټ8I5hR|Ng /Ot;BMQbe'qӞJhP}Oi8xm7]e2t)"]8e*'ιGRNW1Ɵ5Κh$'*@[J2#+(ԩMMñ}z\I*f.6| 3>eׄ&̘]+mo.s9N- )ΧnC>\I6k#~P9ٴQRW__Zޏr6v$01x~QpA>eN?WqrI>pr%啽mqo/: [HZ68 pszN?9RTq/5bpyo\8}ts+ ^ S ic#:g$Z֎"r'gwCcZmwԽW|7θYmrC#=+pM5fc1+:qzt~]ݘҕۻ^^3抝H]fh(tF=.8-)|fKt߭i)^kz Bs>L{7'ks=S;V9j9.;%ܦKi$8#5ΫE4;r;F]ӣLfe\a㞕FjX7%t[:Oi9ri._qT~[;u켍 jW1ÈU'ӊǪo0GpJڔ]>v. 5+I44t{<ݯ]գN*/ObH|VoAֳRuLi%v]&GkyTt*m8%ZjŠWd8QⱍY)hƤ_hKC9݊"^¢r˙NFۼV7a|KYJzy#^\6ݓo|\ӵ=S/ q 6`4X ,1sl}Ṗm،#b=ZMG[¶6ZlBy$pɠiż{HUUA1 sjW+]sth5c.V Oqc+Fh'躟CQQ],{oKGm%Ig$ 00:Wc=5$ﶿ\c/iɡRޖ{fiC*o1R5^-Ԓ>} #[a= `7gYnn{|%:w*}֞ohLqq*ʸm cc*J]f8Yܖd?,xcC3aw(]υ $c{Vƒw~_בPNNZjn^GѴ Je_ E5לXX%|sp}ƾ-luvmmc0ѕMolSonM=cY$ڭ$rèt\,'w~> ' _k=eXԴI5%q!߻r^.cNrWiC iќj?v7gBv዇M+Ze~weYO䜆ftUޖ،uaխe>9x,F ac3ӷǑ}_K\"2q5ҫ*KMN9Z^:eg,g@ a9'-ZjS<˳A b9\7Ci{Q w.⣍SOfOQ nV8 wQ-ʧJRhYiqnҳgjXBJ0 Ƴ/x|^d1 5uRr~4gV"XJ 7;zW*Q-c:q'w~Zl\׾-ϩDlblɥN)ކZ8ͧe^sH  ^}LW."MR^k*OyjZݺhԣϣ9eJTaySV,VUvW4ѕY7m:35̫p_'Ylzh:5LS[ʬ}ʹNwoԜt7wO"A Fw<2.\h;=[9QcXuKyIWPwI깢2u=FqKٸoS|.Vvm.NCZ:ҩskKt;2ɼ2+G"Ԋ's`=~^F11M1U*wiZ[_'ت.JJZ+Wo‰ydӝM_1Oc ח,u Uxdk/Oh"laaǹ=:1ǥpTsSm'zΟEuC⺣Ft%ӛpWc#|xeJۖU*mfo8O+)_vm™fWVe9º(tIIIZ=ڽ.0T>oN)&O`lgޔS˧WYK֒V$Hsn$}(]=w0]ѣ v;|˷.W˹i+>E $9I%&qb9= ]:}xmSrCY.mQh:}ng*<4wϻ-(W6H)\O\}݊3&yrC""pw|k.ekrƝH⣭Bݤ˹E.Uqv9Ƣ"O%?g˷Q!9>ߕbJ+jz)"x'hcd}1G>jTi۾sGNrv̰LcU$.~E'@*CIS?\ɭa"ΎdbX!$d}ye):^Eۦ<(T]J:o4rY&7SÜ}EaQo׵x0$#=pW,'{-Ir3aJZ42J>c=Z=Xž.3vWՐC,,w+/#9u2Z[CIn764x+e@Ls듁޹)/q&_֤l"CIOO?6O9#<{Uҥ*潻yF2®c r=?/ˑ3JZ+M4T$^Z[]Ivo͖_$*#ӧ)Y>M- iIZmSoԺdԁۂֶdbw+q߶3SsM>c*u">mN;]aos ހ؂*֥HWd5SM;n6rחmyh'MsGzirT%eN|<| ^t`۰-v#E+39Yk}*[ƉF6{`kOm TuJ7} aL2*[$p18*T2}G W |gtvqc!WD%ͲΥ>ZOVI'Z5xԟ'PjԴ[{/Ě()+i{?.~Վ+ԦfaδGEޱr[=xWFHqc˥cmdxH)IVeV~1wΪU]#:42Wv!kkimU{7''~];ԹTySMOM%ە2BiC:e廉-a,AӜt sLKiΥU+ n/F]Ӏs~sڦcSߕS^Ks h3aXJ1\+^6jꇭq>aqqӧ<%:SZ!tR;_I'ʸ~dg,aSGWmWMx€9Oc%(9W6XL6-pjJuxr>Jn!jRUFW}N:c`Zpp6G ȱ`>Si&iɥ{ Vmv۞kFU_9է-,8#s qq+^gFjw5?v8E"$ qsڮ#t{捾вx`r{ζS82+X1kll`L ҜOY1SPmj睶mqt|IayۖHш,q8:5d;KP(Jd*?mve:NI6… UYZ=:?-Jvi}A< (UUeiьcI] Rwܑ?x 󃟧[QZKD?~VQV}<3Ѷ211Cͯ5cJts1[m uP5ҥi)hA⭵f ?]TZW= _"Vޞ}ʒYCq`8 6ݬ  ߁[NT}ɳJ){_;輄xѪܲ;y}x{(׭B EPڲLd8$[QOG5*ߙ MN73|~$z_QsT}ӱkxx] FQT2XV^?٧Z@"J}=Fc4&D&יI՝4Ю%ui 1|~5ZeGIn2Nlvps?J6eT9))w/.EVQ&[ל_4iɧIr{Xk"X}{ sj˖Z`eiɻV@>~otaiFέ(/6W;z*=rO&SHRJܩh*"?y֕9cعVroE H6¯FpG~5=7+M]R4s|H(G^8Ù;A>KUJHfױEItTɎ/EWy˷&\s]cqWeQ +$p~f}ڴSm_BFRW\k6*uЄ >g=Wj  B[[U  ]1kmBWSEih]11O ;m9{8lvUjav5!ԣH$61=>N^owVPؼr3G0Y~o==N{/keiЌ\y_j-^a:D"d)Lck}'JF7 NERJ:{Hj=݌(Ԍj(uh_),p~bw8VW62Ku$.2o8k+'Mͥ_$\ӯm&dP۰Xר8)Fҥ9{>jm46i]8ɏLk8ZX~վI+GK[ܤwU" n}wڗ4om("qp7x,"[pO8{?v2NQƛӲ8Q9`dLmSҍazv~sgqfo62A/_#i%NvdtrBUg7~g,Ш5:_}MN gw"1XٔtI=ZT~EE9Qk%{hcwBYfۺz֜yiﶻL*r?]-[^m3GX?xr\Ϡ}ɭNTdZSQM3$/[k0bf[K~:ӧN-ikkuHȹ7 }3(-pJ*Z|׏2WI]:b+Ȯn.gc/Z Na"Ifč=iQ74ETG)--ieX|ÃR? άU`[+6"Œ\ 37=R4@$)i)+|(*WVmI- [I$R$,=jF:&4-XY uKwE:4h6}:2y:`j6kSNz.2MRRrFIU/$jh>9㹝|ZctT9bzggRW} G{yuDJ̪Kȧ2It~JrwNp!Z.nT{6?S"#HXΡd.1!=+nuzF2H%;==\xJ,gF&u$\͵w X8RX`w3fh4e5F#rߑ$eHhMsӝ1u'דR,O6fbx*J\wxS{3Hs,Xf_z1MN_f J^1DW^E$7g^OO|ןRTi;gX[!!ddm<}kϟ4˕m*ǑW"3[˨L$hǗ!VnNp{dwڹy|N4/4nXKq*C4b3)+ͩ{}撌dMCÖ~0.FF*p}A0xr}^5)rj֫3Z^ǡைt oZ\[`)R7n\05- 㭓W^j:{u l4XAo3$|br 1: ­OcYZ9}$Z:zW4qwE>Ct:m\գju/M\Dgz7-ǢGmo51k"( =:v?^c2ZOTcyc) '{hlhZ,c1#q'}v~_ |?tTOϡ>OgUX#>p7gk@sߊ:5%FW?OB\۳5_OR4G"\Hׯ+ўa*穈>[rk߷S*๚Z[_}9ah;mq#nYVV[4% [g}ws;OҴv/vbA!~p$11 g,u9U[ JK-WN5jڌs[|*>[K QmXbb_&MCF~yp"9d-KAc0ÁcWCǎk+;ƅY'X}ưg\zןRQWTiuw]JO>c8be~gͷ$xeZ^vpTê8~ڞNzͻxu޼t0e;Wz%[eFyyϓG/|Y'o펧nVѦӵM]ދUcVxQUߙalwg*dmnjnO- Ndsw*_Z2]W]Տ:1ӕ_ORnj#޼_/$w*qx|pONj*q{=Ws5dw}gk6M wR+\^f 8=>J_Z\+DעwrN2U)ⴾ-Ng)9nc~_CǬ,}_G5 Jin_oV ||gϭvN{ rhI+i#YmVb#+*<8yJ([޷--eB.gwKpBeL*F0q=8JLW3tku{TcVv]u_ [ y| Ilg}8+ɦ|~iEi۾_zVk=>v_3ʑ Fu8zjShC˔T˕^tD׿/5 -EXU[+7'wLg'\)zi- Šw[=N㾹dca٦rF7楕)v[N5Kw(vzZ3My\d2Nynԍ |y#u:\ze4(Ɏ5ǩ~5Ew֍Fߑ/㱵m oʯLju}v9{'7ޝv;V=l~i1.NuԯqZ].q{KG㡙YXe}.7DpOOҹV" Oq RFk~ķjfcVޤyN1]4kT[Ѫ6[Si~ʳ#n3?Vvs~'Nwn$/%b{cvjZ>>>Y㳿O3]Ou[-1H?qǞⴍ% =E()> fxHFvw6:.ڣ_QtBZn;{DdUTqqonrA5}漢˪%CO>ߎ+{ +}_E*6e^d~].G$dy%RjeRFT}H贿B>neaTs'rE5SkݦCb_J˫0 $Kyerxn0x^[pw~]:Y2vNOMV_ 4x+]2/ni6бwӑmF.Z+%~gSZZKm:Zm~<23;}ۘqݽ^e?rײMѣBݛZK/cǵYk0͟-O _7Mݣǭ8ћwtQi[(o̲ 3^tjrJT*Qi,Xexpp}5}8BҜtKɟIVht$SNzZ^WVz$Z4Uzn7N^?;;֕Dvs9T0z CԌ)]l}.PWq{k_ּ;7|G$wo[J`HsU<nZGORktןuz(Z k]^K_'|"K/$ӵL5ϐ: ed`|>KSVk}Zϻ>rn ?n$[2iOe$E Tpd8#15!/dyhbGYK֟wsQoNwrrsֽ ,&v#ʛ: iS\iok׳46i Ǥ{x{fɆg+(FJ(yoY{׵޷'e<VbOQ|X6U9&sS**[5}̨W%MߪwmE> [I5m";{d Ѧ0 ;+c[v]w~}f\xRSrkKBEoaoP0h[kHv{c=:y'+'JȣJ{p|?½7S\/M{4˛f !ïpO<׶+9TxQo%+eb-J=ϱ#wSn?\Ʈ:Z,Nx09 ˌzW|%y8=kO*{:Evk"ۺƤg|U:x9Tj71 A* A zrpjUe-Lpэ7'Bz @dWEq9$scڽhʝFmYTk>̻Dsuj㤬.i~dbiGcC e+F4/wN+<ꌩD0g#жӏG^rWCj 3?J]3n֤WW$h;bcN4?g,jkU@f>dy6I [ьy_TQ)x\VV'Xli4!(_35RlU2dps=3zW%[~f2Gs3<2(lnebrH9 G8t9?zܩR5 wͨ, &amN9'UHF"YG嬌|v<'t~nphvk_ «nۼI yRMɟ37SsڴH*qV^Џ5(9$-" Ag<p'AR6h=LVUH݃| =Һ)vKHX! ⵌfFS,;P0ǻ'eHOCu)oQ)5]Y)jM0T˫FVxj[׺Oϸp0 0>k5=zt<ʜ}<Vf2ܴ{1*d's5|*tG_EϹEQWi\|89u2jKuUZjFYm>}08a4Ժu3CԊo1#|˟60kF4}:_I(@f;PK|`zQ(EZUpKjX"+UYuNy v1޳H9s"إjz.TF[cpʞaE@>c9k T|٤*Fiʎՙf26s#׎Տ4ZWNW~z-6re7 nqF;}+)ԕHZTEx>ԤR}뗞Pʕw ^F%t#UPG8=+>~i8(ڟkBbb>r+Sq4Zoaj ]FY9A'5RoКtW[QY3|+Ą¨xgG^QriE^V]R}/N2RiBNܽl4ʣf*[;gڳ=DRˤPMydǗ7\Ҳ=ȧR*Yo^8tJ҃S>He9+#(R0a J%.X\3& X2w|TSR۩%2<?)r{|s[өQ8OM˾sU8GnWlĒ=3 ]B^8Jrj߁%WS XԖj|Gf$Rqp%R~o_{c^led]OpwwzU0N1jQ|嵫g-oeR;䜃GFͽ?"+T(qw9ᤎ=ɜA_~𮺰m%'vabcRVN.9.9EYȌ **գk{{ѧQJner!†!r=N1kN֤!kf6{E8e0ojU pmn*twf쮮ME퍳qw⹡BsW{A̙6>bt+9aT[/ԋОHQ$Zt#x*88߷y T7Y׌"]e{r5Tn}cF8.Vr#~㵿RxXsc8Q^2+2#|w$~+:n_ˈ(SouԆ+ɖ?xGb;YUMY-e$p~`qjzu5HOH[+m ~ΣVYJ&6*IĞA+ԥ*qT,\@wB =j\d؏i.jj˿ro% c?1N>8$-Jvѻ9֑[Tu{j|)4~B+3gm:k/dJG$YKῩc$Q[K_W#%čf2H}jƥ9+jS6nߘ-bvPYy\~S;[l+Gf:tw 3FnOz޷عҳtm Qe ]?uQjݴ9+ZQPWKGdC.-2xKJקC|\j\@-j*TQ]4կR BJaz]A$gW<(Ǜb9}SPϞ ) q=HTvV%i+~#dX6W_5$B9]5#NzuoB=+VE 1x =+H=;)S}vIu]Dv1~$ɍ̞\hl/9qEis{jQ*^_QѭYг*|cөjrW5XIA$㑭ORIq!+g󊚖M*u/MsG,-p}teYAxǖJ'ZRwRJŪbdvHyU,27{{V}.J5ή%B-PTs'^tK/q9"(B<꿫o!0auf\|~[ƣRkަ4c'Nw}Q~ۺgsgM:GIZX8QWؓSV%F%ٞ_jES[Ē!X> HYvp2z珺RwJ\Io fBf;HU'<ҵ*t)5nWF{owB94X-!,rx'p9o_ШӥS4MdF -dWf ӿC،\We:lNN5=8wz<[lޒ3uJ操*Jn3޳F52X\p^Nr,M33G_c uӭgNNo(ƎԻYF-,l&nTG' g>ZQuwqSVj !udQ|~YƚU6}T;IE'yd?'ӷMЧv{jN{v3.] z(۶uJٸ4&DBOk.9)9<ZRʌ}>bU黎-.I=;Єdhl4w, } (袪Pg:5(+ij yW]0J7UZRVOtףeVx` #\$N^Zig(ТDq#yuֶ*EF6Vy{DR8#:5͹RYonOF>aN7ViJ3v!YoRfWurס8mNNqk+Pysk0~9\d6N4ΊSW{mF;WOӡ]tN*VԮXfAw Hˀc +Wp#w8{b#Z͝ J6 mhלz~U=EO:U}7ރ$68zsZI͝tRwW6ȯ1X2DխcHǚRiku% plz<6Z<܉y ίk.ҿ᫞/|u-V*zhdPA{#c&WɮҌwEJ/K-R{Őȹ sӜs8(`Q*4B/> O&2ohf@TtVKK/롧RN'n摷"ݤVfcOqן[2$F:Ec6ePmnҴh6Oвq2? Μw]i*\tw"ۙ>C3NpMhٮgtVH-T*-n$L`p3ֹ*ɭQSi$Wu!3IO]I{:m6]?cɵ-WY7T/ӎ.FVGWEiah+$fۜy2OE85.3HFNm Sl7=}RKܪUcqu!IaFS$0}#'sQqJϸe\J8lܷF=}(iu=(ѧz뱗s \]ڤbi2#ܻ=1o:qm]mmΥˢw+f_1Sa¬{I;'lcZµy7:&9QIbbqln9=GX労3.=KNόp}k˖7 o{ne]Ẍf6J>)DR֌Rm[jܮ6zϖ:A rk'<| 烎~|ZOH2]8*9Vh\Cq2er*Vʥ*qJn!"ێ=+4/c4/tKrɺIyf5%SKDuJkGt4i[ecYqWGh=cRܴBрYҾݫTBW(Gwqhp+*ʷҦ*:Rї-^$~ucu67rRZ2ŅA-ӎ~"2^ԥJ;V$mvs{chnfJt:jZ_Kn?'$pKAsZsSnZ[.[iYIƾX-TUidG)wOqK6=z;R^ҷ!y{W/3?*R)`FL1B"!'QUB#7qƕ:𱰶Ȕ,]~\yS ǛߊV4SoY[nw8jƬj.߹r\ZEŒ0ֵ洕ٌ%+KKmX2NQ:TO޴NWRC,о`aܐ85UJsWz8\2mmL\"JNWҲ6ЩIU`?P8a)=5'F Gȧcu׎ՍX]u F-GR+u|n'#Jkz<.p$ʹ1 3:{xGtԩME)Żvlmc}†?tj;S)~\-|&Wޭ@>FRzncA5`;Ӕ /S*ȑfhT'j'44 ei7Nzn1 sV÷st)!J}9fhӭNjsV޾h$O-/a6>][NPR۽Bo;Fn%C=;W5-OJ#gdFo^5%zc5ʨګaJjtSoԽfIQQ }&HRv ЩR<=l5l.Rʷ-_ |o^ +B#i$UќsϨǯܥO!Q)%K-sJ{9 ѕ9n6}"h)7d.dӵuon}M3 vd`Mpy8WL=_pRrJK4cMc<ESK9ܶL'W_w7F8#Ӕv{}2[=sҥǖn*mJ±.w1fL8j_4er˨N]M_C1tT;>ʥ($pn3+ɭ vQX{^K1p fLzpMxN ,m;IT-liRRε^u]$g5[5kB璽{IU[h p2sT,,*ь=.օ U3b4ۿs(Z]h:ׄ$HWl=+dy3m .?6j_ u_o?=hm4rFIu6䞪yn>_V8He8MskunF&`V ޖm?r"K9x8`A"G0S'9b'vvz-ѥ%n>0C\+a㭕ϘK4#PoK"8n{}=WW NN HҩXI>s."BYUL'2zr,0y:yϡEr%X `IaI[UckмZ,yݺC!]u=˫~5qTvFJq3CpA^WQDR^ebBs\ެH׊S۴Ѩ==qO1npѫ(͹-Y~l|^yxCq[,潝cTV]sבy|5wZk%B2_rg.2/2Q"߹CvqceȻp6bH}F+\itKNzX\ E':[OS-zPvX+ѶK׎?>5)JoG}zL_%m J#j]\_Uu;oŦ&8T/AzG|\tTjMEu[o`!Kǵ2on:*7m*~Ed[KK|- 3ծ1pZktƶ&T($6N{)gMc<=kԛWIvwJ ˲굺v7 0A#pp8?ҦTkK=䯅7S'7 }5y$5קP)ԍ7.hc*II{hbBYpf#+xi;[>7ӷ%ҥrE/o7sN59[E(Our͖&f(d3g=NV6wtyV}6!UU!*IEqb $Fʘ85ǭFlWT*j<>+f~WRh(|OE23|sr8$֣5c)N6zi}LC\tΛm#Z*X$8?ӟ{|fQJߺ$ F_rlz׿U^h%G_«1,_) (=TqݽM71|A@.eLq1d\e.y+ ._}.~f11%RMO61^G= +8%0 \` $H# o薖]_֣|r\ݵӧ}3.QRKedl Jj9$]{û*REQW7㼶UKvC s;{W$2)Ч}x-(HHlcnAFpzG^6N"]jSImAd >)# gOQ4q^jMȯohb\<lVoWMSKk3I Hϳu=Es֦N:+6v֫$6jN#y<1ަ:_:q}5KI6DL$NW8ޓb:Wtc!o0A͆x.YrǗt-pK, ¿{?sr=8%ep)>F6A+A۩*ѯ]ov % (xO d}3bhEMVE+GKָo^3ϨWBPWkcR\inj6̍koo]79IaޭGFUE7ꏙ|QxuDzmqt;x3צrkrfu_=?Z|;7{M;l<%}}3n0IwS^%j4iXϙrBɔj~oWgyF:iwR\4 ?_΄zbTteF5+IGhdVDER|9E˕vt%FٛSn6e8[SXxԢ4.@-b+E)#͍9Ii|K%^qZJU5Ҝ%Ni,ѽ!5N ?F͕pǹF+V|cMX)5V%OnWOgS SLBa&|W{j~(FǡTHms DJ,zdp[5 G$Hb@,aU&is*2T{9"wT}Gil|pkz_W^Z[+oԚk;>U\n=kTJܱF{\F ke]9#9Шt:㋒ӡmw0ZLbNWڵvOu9FײeųB >3]X=6At:z@6ٙOҶʊ;[cT)ʴ~_ _2mi?\tjP喈0x|[}|ʖb+3Vꧯ*^խWV:dש:qwgYp|h1;El:rgߩn_܉"473^ZJjuaQg߀iY]1)eq{R[8&8BwFTCl$?y8&C1)msbY,(%aUUB{?\fiԩN/O8:Es_Rƙhva2qz֫J6ex_2 A{mퟙbrBHF7G#JєduZ dQp8jO_v&JoRmgr()SyUȺloɗȮͻq뢍?gg'A,<̩Pnʅ]OB{tj6mfm,,l~miMGt{osYFņw>:~$ )Y*ygX(GmpcjRjJ1f'+6X?:E{4)-zTc(F59$Gk/Mֶ5.:1Ti\4bn`sZU'-ekSTm?6r_ Fx9\;ǨTS[t]Mk(bmdcӚZtRU_5Mm6 \51SQg"pF7j^5PۋmV[2}+d3#H'pOzjWjQYjGjgo,cSƜE~i t9x^w*jz UW-캗Rl3da'r8x>*~=K[ I H=vqԊƤ::'.3B5e-<9$¬+e|p۞8s9¦O-ͱނqå6Mz>"8nSrr^%?.@6ݔ⌜9 Iͽ ,S,$_`:W:/qwnkLuÙZEm_|Ac0[3*gXnZnf*tZZ9 Pv'tew jޟtvwɷljFޝ'q]B4Ȥ߽}Ilak0AG_O~kxvoyӔn]BU_ [s k3<Erww[H dY4Vm1uNR_B}bihȘ'ULqێsO _˗˳W}ؓ%g 7F9tӖS֕*jb^N$ڥ4/<9vkU#R _ϰh>רHU+(gA'8R 4yݭצ_;[yvC[427ۿ} zq8{S敞R2I%|rcY c|ԜayjiTRzWQ|Yxw͖;J(*ӭ=;)V{I,Ywx¹>`v/$3ɮR2KThSyŗϝ6Q.BZҏ/*]Zm dL˖;m:cʶ^2hN49E>LJHIQ0I[6VK:3ʧ145^EclsZZi+'XВ VW8wb'9sK_Q B֖zMơ&$OI~u.8Jii}QLKpmǻ{'z}s啢U [[rrsQֱj$tfeWVz=܏om]wBRFtߧs(׷Q Ii6`?ϧ=(I<0璄ǖYQkqϦMmFJ5t:12}=;FObN6`>*[Zv׳١ *ß.wszڵQ1ywD}@#!Hc*ѕ;%*wmIhcK󃕍}kJToR,yg{4VFuRFXnծis]RiE+^{yh%ZIʉs{VrRRkmoإ,ok,+&Y#VəJGM;'oUdD[}+Dlk&0y׽z09SIuKh" mVu^vi>b?JޜS]{im5eim'o$iryӗ6oNuZ.7t'__Zѭ(_V1T1kaZ|2Z5.]1n5u=:PQ#5a213LIH`۵uaSID]hͦC26Qx&:09{7udk+V:qjZ#YKSotܐ5F̻ԝ})Hi>VZ)ŽH` pe\Hpzǥ:˿cѣ)TåZ<{|^(g4+$?ZSqvH**7KUЧ=/6s7g@ׁUhaTd1]ȉWpEMiTl2}-bLq5껬lv$\ߞ{VK=v!J_:Q{^+,eYǵx85kJ5ѩ;者 @ c]0t"BmBV nchoW ==j/FVj*rE_}`.eLw9<:ηjQ$uE{ Cq* s7,(EʓS%wP]<[9̚RZ0!mxͩ߆Rsv,a%_1p\7gY;ˡ*ΞRWΗKYQҺ#% Q-FX|UYsh*~J2][ުU2q[{*u)%O]YWjA[Тnqt"^ # Ǘxj=W5ԡ=wjǂ1^%7-18Suaguʨ'uYSr2JU#ex|Ϝm3zui}mjMn0ȊVlcxQ־Eںz?P^B,r=ַR˲{ކeJXF {MU>/mMӆ[S =/Y7W;YW*s'=vџ2\{[:kFh s#[%ԑ++輆zFq>~[.zVFch`ZH{VXKwv7R'w۪.[Ck7q1T(DZ s޵%IFSZ:*Q0Ktzu-jO+n]1Q\jrsSNoMR9n6SJpߗ1쮟~׭[i軾ĶKK2\@@؂??ZF>~ZJ״^_2^?uq49O8n9X$S5YdwB6ʪyf=9: uT5%iu+Qj6w,e#a#;ӎO?CNnI%o[KLΑ]̞[,NwI7W*5]>K]!n űdRpjԧ(ru= 2]m#>fbO?=G5 jn][QZ79nWn289jޝHƛPoFQrA) e;OpG85(\J49~zY[v,v6`rA9 :[u6S3MUgljS,k'!T$VjcK}ʔ42[kw[#t߻]1zk^UkE'}I+>oZm/YL&"0܌ zU9+_m#*/nGU͘fMGB22+eyEHo!Y#bGȸ$gU9i[ђІ=D^,U!VD Fp84E7:lY_{+Z{5KovM&K _3k' ?~}?qq~R,TCycHXinFG0C*#mU>㊝i𿼣 ^jjvQGqy?]IF,=_oȺbHڊ%[.rdOJ^5eTԣ}Lf@epZ?,$w# gGu߳W*]#:QNJmX}e$g)&}?ࣺj5iEum|aTw~&\omx-oԉ/$H ^{>u*,[$# ɻ p;JS[t3הq N.}B;0[H|gUJ4cQ,5xmgK x$+=3\(KWTtpTڿga’d,/,pӖ8滲G):[T|^x}ir-_U'TޮMh+ZN3P*`v>`c`kWǥY{kks밹aU7$~%mR#aOEQM A#OZRh=vK._:;b7HD ]GP3pkJ"Lz/~v|>ןW,6H8 + g$g|Vezq>o2S?y:w~gh%O%YWgLAA 0?>"rë3;n,W,NF3)^N;%M٭z#ҥ^Nqk&gi>1] Gy98q^0ռxn;yb)U?~T1[y6H$ߞȯnPSݥǥ9,d*ZhקЎwpd/gj2㿦A㩺ߙxEo xv]~_zZ6WLMu'Wid`UIa8O־+ˣߧ z5c/uY旞6Xj7 ,̬#7_U[ ~\})JI0ך Ʊ5PMm.0qNH#|aַ̽6`f{jz?iosy~ʍ~l#w0]޼`zW8=ӿesXѤʄnDg|Mj#,f&ܮB_.؞r{޽o}V}Vi5u2mwajSDGTQYi|qM[ʜ#$s֭u}Qe _m55}|0Fz]gO X #N=W[?gs?X䒂Z;}=jHOv=m릟3У%n͗(Xqw}?pԨ(*J*_s*ӣ ^W'JLG7jTJ=Nv+]w5rQ45vM76{"*TQ^#nkWitSW#gS?HH w>/2rVqvVo/&Y2(G @55+fgv-tM]}5Ipw˙~gknڔN8i/_E?w],e6-6bЪqXw''oe({Numk&FW`?0S,'Q7}]c-@ $Z15.IOJ{q 9.u Ju%MݽZ>B)u=?wiL֑ܠG8gsQ?e 3Y*Ȍ1aI ssQs?wY_֎aG lxkjVq7Yw/~ X9qTkF-_U~"5oi[hxj;In%6f#cS(ǕA۹.N0[՝5kD[{E|T g^a*'\!F6E5Hrѭ`O˜qtsk׋)hkgxeI8NqzupaRy=K:feU98VܥRUSn[h%;Qy'iTt]9ThtmwikԚ6p{V'{-JFDuسk_ A|ڣ0f$\uߪasZo? wk[E{mp69<ٮT=[+{w$߈&/j^׬sw,fnx0\Jo`qs 5(ksWH&޶_[-{SW:.i-13ݷB=eX[+ۏ*Jk5 VMJ 9n ){tnx'n1`O8TkCСd'm zW5 )&vMJx7Ąq01w׏2wzw]eRJ5"m4l}>g!#y7Sk5ak5 ,#BFjsU('۵1RmFWRS3v2k_NWjtyW]W#ݶ_'"V^%1ŬF= JHh_r ZpHwWp.WΨӨr[ڤj[t\=ӨM>n\FAonVFtѧq#HbیSƝg()ay >g;z88N\hmF:i,[wzьKQŃ Β΅/w[K+_ҝOi.]^[j +cU3ֶF(IߩՇ:tW_R֒-It;lִc$uK; άZ:u}SM*ԩJJ\[ImoNWH΍wXsswύ:C,9^0~tOw{Cᴴ2)*r kRjou%,ci7M>|87w:~+H^~P-nA&rMzZImowqU0xтNoݥ֝o_yPɺKYTnB̶?[# ,jƒWw~;πn4 i[>k~ɧnVO>7..F/^)$w\[ulc15(aM^S~,*ע2߶yu4,x' 34dG{|"4~.WItqzu7OGk樂-OI[)U.i1FG9NSEwTJN<]/#Nkk}*FX|B)7~L~߳4Zӯт HcpH^:Wf#3ȝT1YsNW><ݡ?.5O,8zҾ^:u&}[?4&mq~/$m689?޳OSv:9v(?*OIn ڪ3ҹm+lQ։(֯,q(kZJ2G8bIdP0 'G*W=jI)RWhy>Z\t'N1MnjRqӷGuvk7q{QڱG78שz1љڤQZ]GGTЄe_CSM5ǘۉx=Me*\M}ŮhqPMf+9壽k+aHz9# rD:hV8 ؜FR }/Th`yeM!X\m[޽(RRB$" + wqJҟAUݭ'&*#V p4>dZ8硫;/fI1c&PGr5{u d-Ou$i)nc+8D,m#YuR]JҊQoܩyyv$Fb!lުmc(5' rZrq29>ZS"+rbΒں孑Ä:v9qwz}*7ͣ]?޾XڋqoH1==Ǘ.} ~ߩkP}M' 789kңME+/h2?r#\vzq^#(z4\yPJQ-UeԮs}ovWՓ̫,Q"m?o}ۜ[9u*Ov9*TrImۄ#%m}>+h'+i/:zGyO$}:{VrF*}ZK}ͨ,Fqo2V`p;Aq\2G&c(G]vVBI >|a4ctn3XZВOdaNN*;熠$n^#lԎ>oJ)%(NT\RFq2\mDig*˖ɴKkX~`g>xJ<ԍJՂGc2jENVrڤle+S礌d+W-JҌtMm2ʿ{y5ք2Q2YHҲp}Ʋr;W58 ##XaOU)Z7l:ӕBh%UI\ ׭LT94pw0n9ێ{}*9Hndᮾ},HMk,gMʳo٘򴰺̉nLV~{uc}-p |yR#=+5jJi-Q75;y-w֒Mjw'v32: #uR(ޫs~bse3}t\Gޥ[KN&Bn\3)<r=2y<-HΧ `$ |bUw7O\0Os:*vk 2O,pFf^>-FN*Tn?ZD0d#q~֦%w2FjhQc7|`q-m*RRl-HsNQ}8ԔoZ}y? tIr jub-_̆<]qOg9نX55Ը$eo/^٦FN;.i-^Ȍkgmea5S'hRjI-_Ʊ36d;'5rJOm*׍k \/@{Wg'T9)+2ܑHq_6M̳H~Gk^kHӺrZ*S[>R6gidl^9]jomӦsT}壘,' 'jiǞWQ͛[@?Ð}N{Wc攗b,=kԊɮR.?y11!#yr~5)PPq0Ɵr nNWouOj 7Δi%R鹛 VR}N,ZqcȊۛvoUs{gdB6[>{,EJQqkWUݹ1Uj_cWK-omUWW mχwZt9SæՐX;k59j\٥I^6фP=[m gwOzkSzjpV,2߲Vif1 [k~gwsj*|~M;A1V,|'玝QM۱|*b9i?=nl&5żS%0\>o_n*mԪ*թ(7fImZY6ڪ̮FO\p~q֍SV)4ږ߉zI)mfV>u{W jr&U}ivrdhᶑO=3:`2u9Rف&56ER*.HqT3,e/~KoSOMH6mo&N1t*ѴTkbisMۛvƋgpb"N}y0Ohzt"NjkX`oǏqwYŧF݋}Dh@eT AOzp_.U0M!"+l㍼ sڸkaKONQ j'$ c=q]g*V9+ٵ65䅋4`V`>۞k:jekD%OMsEۅl.^5߼>b3CXƜitV"tyi nG5E]͍ۈ6}[#>U̕gOKis*Gj̏~O'=c6婅V{[/y,q[p0BQ98UMuRZ1ھ$0۸`FG@AΜZUH\I]$~2  : Ftշv=Vu>WgmVM+1C9U޹UN55.UL%&٥gkHs,A䞞Ίz:tӸF5(a[K%mkqmuƩ?x@Q~#gԩif:R)Q~귭f[H38 ǾOUO{SӇqܻ\ɷceRn:G:ۡRRVVli^F3BOmgBF4ۗpܬqYЍGe?i^ 4rվ 8n;d8"tV9(ZJK& ӤsȼTy<#z瓩MusSM]ETByocspJR8a>e-WL^tWߊSJ1zT9F =kYi$䴅N9<#J44e{-:gZDgW_.=[UA0?*>JKE4'mEݔ40ې\sDERM/bO]~0.mqGpg `r9 Lcǖ)_qiܛrNdCYm} ,<=5tDe"M 6}wuSrrѣZ1匒Ko4lmmKZb8n6ek=di*թ*j[ HƈZ[\gzJQm)]=ʧZ̕Kl@3+9\ciQ$cQFR}||yZ+f3,mfLy`7SۧΞ7]:k]֋^wNefcʻ 811?oW̐DŠm"DžەpH:^ggӼR^I.WҞ[딢G{够h2ʨUqjʤRWV"vm]HZM*;nr۸J\u<<}g -Tbd?K$}zTƜKCKšSKߣ)6~Z6 7A\8ץiX\D9ZeSq-cs4+b \*s*8Ǝ>D&e'v3P REJ *!(*z}+hu=[E$Ew=LnX0?N:s]\хT'>XKVRɰ>BA"kcV:z_!ZF670ϵ )IB_\OkdEq~}Q*=9I<ۘ,fs@w5MM]$*ܱ:qAgm oQRZۖIEl,`&_ܳ>dʛy 1.JO"k^RrYeY^_L*Ǵ+?i`m"y\aWyO4/]_t͕亷HA*p0Jj@my۶@~UJUK'18b#o.F` ʮRY+R)&L/yr$g->ozz֍%$$C'h`3ո{sZʴ騾s$_ Ȏ˳ǎqu 1:r穥8F0WNz+9FTZ1фUݯd6ZkV1D'?8=4S5X0*nVd r: u\e)' eZRi$,grۆ/+J[?{ZN,k 4)?tdqp88E%i;j=V\Z+yaUR.J;eS/h3>iن/lsץc)r^/(qZ_Os$:[ wZVubnI]JZomə.n}1YTlͪVmY{}2_lwO4om_#.Z-~eyt)gUL*I#ܜoF8=<=IƜS,{C>㏛ֲh,*5^\V9Rt;biX-gd21 S%22W=咨 arF7$K6xwy\`cN*xUOFlR}ݒiCK1ⵍYFo}y8.GB{{oYy{xe nucMj1&ksZ9F tzVyEǕ^FUe*ۺkiu!v֕:qzݗR?Fn.Z)ʽqnnb%'jf~?|cYMs2/RlSFF^<#~2匚Nhƛ]+ō26Ucn\G<uKmoǜz}kE5**[#'}йzrBa\l1ڪwʣrӋOVQA9۹[ YF=kj9$MYS8cfu9.38yy}Mӣ$] :7͌j%aSR\u!(H`?SG}N)O[|\hc <d}8&,:@I捆y{v8תrT:)-Ynie2dٛ@=zsJ81KPR7<+ "Vu=a(sNݕ*ط'"9J\C?R幧`-T c68UN@;;F}\K48BӲ99r!W=CܢHeelr95W4{?ʯѣjMvϵ[%UBs+# 2515=}:wzzܱW v|[ơY>\ש\ٝ(.R! 8)%TG51^WQJfFV-ʻWH^S49v|95)ESI)J)ZP^6Rd++|,e-LcEʥkQG䲌w8r}=-'USc52cgm̩sr=VaT{o<]?7sM7M"n"i8g8 5R?W#~miSVrV."BXEr˚2Ъw勩:r[Gn4F9 Q+OOƴ\9=SNYdGUNݻ =z}ӍMR8劒@`ZA?~-ǡNYSشlmY'i½3˖/ز3 :vSZKO>A`&ܖg"I}cgݖRi$}$\0=AȢeͬ{VVʪw\V˱ۗ}Jwέ ͹}ƵiF9yݖKęY&k¯|7j-;/cHNHa_;?rT.YN?u H#*9'>QTs1\*1IG9%n_Ƹ+|E[BqȌmVa^]X;!/mܟ"r d\OWw#_-tyOGcSkI=I]ˁҸS\'%n).&hڭO/J)8N%QV9/ymOF_JHt`jԒIhNP'+90]< dV-FL8zMIo]m>X۞׾_3Kk][!O5m9TF1_aa(ݝ[sZl4l'f{nda?c=ޢM&EH+á {Js,eRJ*R{ٽ?Ǝ&_Wz"ņGč30 v2Q[52'~'XԕN|! mS#LдJlG\J2]9kS54ɵMlJnbifq40+۞IJ:iZ=՗r Mi_GF+򼖥I{DpqZkqWoMdߗS:]u=,>_2[멻]\G7ښ=z 9l{dˇ|{Eo#z}*Wic|X眒y\50uIs- q4Y.0>L$q׎Ӛ,Z5OWn67\u/$vy0z}}kԝ?v=LE:wچβ4sԃe>ޱʉ=w1¨m7fH$ʶOӨϷR+8G؞y.u`7q+:ьiޥ)F"4gʬ7F71܌㨯>"diΕ|ωbRl1a 8fSa׃zyNPKv\ӊ= u]V!HX(R9#c}8鏧9cӻz_?FKRW~yyCCBkZ]Ưc+K˃k$v `8'Si wUtcZL:% G巑BwR} W>[BŝA#O5Up+fFewދMmzOY{F5 %uF7i=LuJ>'E~'k&U2Tz+$ue;xf&M#}8OSRO2HJʚfgi#y=Ǡ7N@6oO^3iӥF&(SRZVv*sAK|̠un}0yZ^}p([H]hC$Aaչ! m=6>(b]W\[Yu2wץ,(u,OSF*kt)IP-~N[r{Sc@bX`rs#+*I׫N_;W4c/!-I^}\%8FR9G*mыP5SZf˨wB=%)>ux"MCKwhDyu'YGn{/g  #\RR7o:p8]>h+rԻj\^FWs.8kjr:w:]Nj|Ӣ4W/!Ysךwsp$֝;rƌ/@ 6f%ct.H^3r;W4{?/C<>"1*R_36FF+^WOe:gDVf+򷙌r2:skV獢^3xKV xVEIce6`pAwA_qJ\~_/KZ0u_ufV̟\mqʲ*6,F:u'85γfgK[F1T*IwݻiS\Ev!]r$=1ijtŎOhͭ:[9Vkі\;T{}FOpqnS*8ӮVVѫl˾ Y:Ě!KhD1yh^5_0`n?Eڤ5nwi;7z09Qi^lzïM7wˎI8$@=y2R~Vm[X;s^--h5-ƺS FEi$ȭQIt>sԝL=Oݭ/wzlqSRKl.e-,H`JguL/׌mvr^HӚϚ^%(w߱I1$7 /,  0;q\rz=b#.!.-|IiݍawaGtkSn'b.o6HaߨqxFvgLJ~Vџ|W>,14γDFehm`8'>њ<>:.otϱ7_K[ot^34yʊeԁs>O4F~7UOiRj;o[ZݺOm#GU c= zx~8Z*t\Zt+Z[G搏684ys8+u$ >8|NolAéZFܱn8A*s28k Gwz~ttj7Jܭ!cucGnd~cߨ } rөzM;F?X .V}#Fki8X4$LUcQq]Q=N-yM]4AƳ*bX0<^c꿮`ꗦneϡ1}{94#FPẸoU xftԒxڽsI=ķ7Z9sT8{kUZ\ʹ*V\s3iN6PJ056U«e벵! u}IwOg'b.(V-Wd(ROztosapZƐ*.!޻jT2v:-/\Ҫ2J2Գs$3vmƷftBèNip[wa]Ε*Z;m[Y-,Koms$m.̀1Z8=:85̖;gF_'j)F,ޏ5T㇇<4]_J`zΤZ=kbeʥ 6'UߜZ3YZtOJ݈u5+.+-O.Z*oBr@ٜnL㚹Ĺ۱,1 /l(fž t5ǍF5.[IZMllWÍEf6Ja8=y#yl[M_s͖2*|K.|7:XL0'yϞF>q8Y9 URw8kG~ڧv*Asevd˃㐾3$VJ> ÅOjs<>iMǚLNZMl!UE*}N5QEnMUnnH̱>x?˞ٮΥ8gҔӖwW0ߺN<݂֙c=NN2DRj̴>MYbVۆ=q3xIJKegl?U#{$;%y,7cwW8֪R%QJ&m̑7,^!#uB4liJODson?yq¹+0l@Qb&Q*Z%Jw:ِnpk?gc*y8RFQ6 eA)Ʒ4cУZ&64qy{~sTm Hdc9f~Q\>ZRܳ,{S%y3Ϛɢ\\¿7 %7z<iv>H1oQd3eOW_Mg5ȗ՗C?y*'GؾI$12>1ǧ\im8X&fRs펕YIkg5IJG0Y䷑Y9fqȮX׭/Ԋ~l֩̓өuBN5ǰ c#9V5ڿrH^ޤ?s28ZZGnXvanOPhpk:u"/RL$j dm 68\׵aR|y{L=+Gs]$Fֳ*u90D7݋5IPX!82=+8J/_Սh+FI;.yb!嗧~{UTZS 7KxGeI30zyq{V 6RtFY_7<]Y &$w)R^zF1?V"oK]yzpd˅@6qOj擌z[Nձ . $R~UDqK?8յVZݭ,$emve4eZE?7888m\3(y! =h$ n'{C9b96ۓXEGb39Yk4o!I=N?/k)TQ]-g׭*ad۪}%9PW泧RSZ[ \yńq4f˗ ӟUvӫQߕ_GO)vȤbpKn?<F3-y:ڷkb-Jsn8kԎfv'jZRU1ǿRw?_rxA_c a)E'kyJ2dn]` 3nFWkoثJ4IS_Z]5ZVHXܟCiNJݭSƝ\],K5Z=R["pM8q*R7V{D1YCǽC`J޸AZF5rU~ls\kafa3ElڼrO#b&$mG>tG3i2?qnC8 ۚ6wV9!#[tAhDm@s~1t*N3[z5S;-B8ntmF9zWiN(wE..a}oEqI-u]0:yUҧ'kTRQ[zh ^~eR͹͎s~+M9=|<#{YW1G ubb_7R;vDg۴zGVt֚RRѮ/l`U-;y~lTSIv֩iG5vas! 6T1pxMmxOҌ!:RZ\L#9b31'q*ڏm:g(&H?To{I\QW(?g0^Fq9;)ҧSs+HWPʆk+cv}ISKFy|].4ڻJOΔ{$-R^ޥ-&Wkuffڿ* ҅D\7ct'׹u9QM-M}+-fW,YTg(rԫZ&Q[lUC|6oZnmQJi) w뺮JsQ{GRqg T;U*[M3G #?\G϶k5ˡqDvDwWl$[{x׌eܜQ]6٥ZiEF}A|gRkn4e)տbۙX2ZuTi؂+c"مEEkt٤p\q޻)VpDmQP&6jT95mU~E׿/c:j1W+\41;ȇkqON⢴.습M%^Z$CDݼՈ`\HG84%픯dڿȚxF*IZ]yu/j _gqykJr01+I0mneB,,m0AV=3u^RFTqZkFHs8UCE^p*Smn:vM2g|ؤÜ8Yݓ֌Ts%my%Jf] 3j*p{)S䩽Ikrn/6$?kv|cZVwٝN6o&ߡ5GrO˻430A\9[Mo"'Sv#J7dF[|0Tc#`{ǗfsG3makvHǦrxB#8twڟ4ȸQw]X4mĝA @?QD^M;t:-Jm]ǰF ݃=ǧ9bZSu!gVgXH:uJҔ(I6ޛzCwqgɕencqۏ^ԥ(V~ʜee}?Ry$tpUS$$鎘T9Uܵ65:<[h%ĂI5Ev~Dn1mܺhԌ5m;4j $q˳<& =iro_!ө(Tz--KY q[ˌzҩO*tEͻ4\Oz] ,d=}+.iBLKR$2ɨ4rJzO}c)TXTSj0p]] ]66Åߟ Oz|IvQ ASԆ-r5ʍfhF{%Iks+V.)5YElEZrKS2R]-xㆿIxiYeEY#FHn3i&6_uϥ`pɢ/#vmhWQU;#x eݜA^;W葩RGχŵ{5KK.Ϲ V\?S 0Nq{W h>%yvӠgOSXe&5k/%3yWv" پGG$Zx/d´Fa+#Z{ZIYG2>ʧg~GWMYPC:y,YIH'ZƵ\=ػ>Rd=:~/[~C,jL+wF# JpWʆ**DSǼ5֍gesY$2F>adF3ʢgm:jrwk{?Em/#W/.%OM+gj x"~TY}J5=nz?zVo2+*bn,r>ƽ*Mr;uz?Q['Ӳxfm!nf^x&鼆(A+=p>Qݫ[3FU-'{qW [qq3JG䟔`ptኒr{jzTH\/#/_/Wՠ?1і?_^kOE:_#Aya ks$mK EwG5ܳ-&ڣT'˧o|wGAeF3 ?澱`+5OT-v_նC^i*lHd+ǞOnSRmIn6[R-%mnk.|N񵇊4[_Xp6+9SiN \Xxҵ_ n{[pYXUEzmCbtuJT[]nx.o#MF̡2}xO]?dg)J{4 q93: t~Uٿ#΅9ьbӒ{zwe+Z'ˍỌ#U=ZX,hUWvfguME^Mf9u<ekr/\5|*W2_X=r+,˿8 wFJ2iFli~ CLXH$,I<\_Q*Vj]Μ=Z/SwGu׷o5$zJ!II'M%wfWovQ8[rb8!?A^Elj)iek54j{W63edY?.dE*#r\q0zt(Ԝy}_GxեՅϦEۿBRc&U%M]̃jXGukJM///3yjSjy=]NKpw9s^j.T֍.GeI r%+ue TzF>_8Ԍ{Iǖ?pՊYOuݮcG75+ZC&Y?=kʜctcRq;đu jf~q٬e]?wBRU%~5xl.p^SN\Qsp3%y8XV9W;VE9)ۻ8v?mNL* t:7Wf*12>kTn(QKZ[v # F I>潘b*FIU->g}INIFN[龥 i-h*4/~aMє}%ec\G+Sw~s3O֫{kՇ*Qpٿe~z~l|,ArCu<0A2;ӵU͇|Kf]|yxP{]WTw+5RH8 n#={|oasiױ%Ndx%m5e1+r F=jxJo kcdӏF)'o_e_zΗ&(EPf8lI?}k{hʞjy|}(\Bu龝.~ds RT;_MGyNM)զe!_\.2ͦe4~Lclh_< pHkWmwFԽ:~JclאX& .2rUѾngexO޶-O&:c'ȩѫ;}o>9M͕W,qQ nߞb**v﮺_:cR57[A]Bݲs^N+%^ќjr[.~}s$@pxToj]iSy\V!YGɷocӯJSlg|;yxY/cv=sԕI4<؎yrkH< 5.VSmn-\yn*k:jtӬZ?w7|Evf/޽ZM8KSte!Hג2GJ a ]J}y8ձTJt>o1xԩt֧x3ZMԣo6<ʹF0xϖ9\ֵXk;i3mk-_>O[=np#0#caOCౘU'w}Ox4۝7P5M!ުAI sEF2߹3 T>ʱˀzbV`wRu9cS˖$Q I+ IkmR-,Īr:54Y2ZIcBì' #|ֆ9P[>bnyq]wS[8vK{ekb$vV='GER.cib~[ "obX0#9X*ܪzY%jcmυT=3#+~\*s/f6 \ȸ}N;{ ɥ+#0-s*۸`zgO©kKRG0emŏN.|P!JyA6fʪwVv]q`|ܲTƷv#[v 3n.yߞLVѓwwܧ̯wZ8^&RAq[ִ2ftW7,!meYs")*MJ\ҳH*ܹ9~8=rO+FRZ:)Ƥe|ڊCSrq88hG#O:o{HśfSn!UʞܜսiL?X8Ҵ.ܪR~.;o#/,m$<#8LJY .5}44lwo:Iżjp#zVUkKDQ[u{~?3EJh-'1T݀2@]kʬ߶nwsRYʫ6y-k!UfnUms۷v%Ru9:Siܪ:yayS+ϵW啭{]QQ&C<[;19?}k] N5}j^ٟbT9rpeZ-SGʍ)T,ZЕ $sn觎_e6i%˙ Y5v\ʁ?1N4U{c/ ώiܪ-Ys=+vw,='SJNy%a9t(ԏWKsN;FQ|}je)KE"/XyL1ǷZ瓗56&,N۱U*(;=9%+nM ev=?D'4!fpBVOөFQS{3OK Skn,9Ϸe8JzsӧM-R,[/jcM/)Tv2 uY͘?{>zV>R~:%{"ՔFH{v w= UQ;=v껿$Gm~#b7arr qO֝J\іۑ7ER>mx2<Rq"KXn.YyWp9\s {h4N5n+", o?RN:>S'Qd&R6Wygꦎok.g2qڧ di&ݜ8sۯJK7~Fqytly1;{*0gQ&k3·, {q8X֧ux{Ԓ&+'Piی=rӦ9RR7z4hD~jI~V2Q-V6mo$w Ii*0}saRaD*4p 2ܷ<(sc1OxFs 0Zh\{GjZLVdw$ZT}\wrPNj\ۭݮZ= >~Ƨ}#%+{EMrIJOxh+8gNNTNbda6,1Ѳ;O@:WUYQ^{G ^N/[, &Y}N9C5ү˸gFwRkfiK%Ino+NNNp}3+jj['/B ݩ*J5ֻiՏքwcEK4Ϙ(svV(rÚVNk^E;uV^ONGN]jb"Zum +zrx(RlE89SN1~ۙ4Lm8+hNBHweg_==OҕJyRjd*ZAkʡ8p3YµJFujb)E?utK!~qܑ<~iV|ѩE!#1*nzXNﶥFNOB8YcPX`w|SFiŤЅ-#O$ cQƚRoq{{ۿcwÖ#BaHq^ˊ(I=FeZNRkv=on]z*yq8˦멻,O-'qtfsJwI^iJ];}<ʥ8(KtӹsݗIu$[9&P#Y-„~U8ƴ#&wˡ/#=xkQ{J0lRۗV *vqӧzksNn((ڧ|M9ἁDaV_$~W#S:WmFjtvFD)2hƜ'W<9|g IPN3W,РW_D?0#9+ʔeFG,isuF2X`5*v_prJEGN@8$?W!4!n!sk& ;~ty'2øRkj|l(^RHYytkU A"oyEIO|Oz(rJ%Y Fd=랾NKm5?b{ImܽҪ/'.Bq9RdׯOJ*\O{Iٝ!y=HJ\V:uiÞIs]tHdC4,*+2a3֍Gv:7e A`)X&TqGJԯ=/N3*NnZ4I"ʟCzs[BFy1rI;nedԠ`o/*2z܁S\Υ9B}9ʲ,ͷy>cȯ^;[SF0TѯĨp E޿s |NM.]}ob]GʄơT6$>l+W<%RW^v:{HWS¶7|&{>_0={{"0Sr{t 5 mգK]IܻUPtƜk.IAtj]kBֲ̪BkrF Gg:rg-m*գ+SgWm1m"wyѻ*=:緭tZqrױxVnmNUӭ6Yt  9SV枷3Tjtj^Gr%ɵwoX黀9ISU%*kTJpw>ZJx}.G^xүݍIJJu9ck&JCIӡ=%wtԕHe5H$Y\BۙX2085*1nHX)+>D]nX&0nVNہ98>zgƷ<$Ǚ2Yr 8Gj}ʙxGꖡ? hϗ&z:RP-캣}ݗ[UXrfeXo|ySb*VT'-47kC_TTGv#Bam@T#sTRumm;PsEXwYI} y6#sS㫰T*^AM@fC Py>5KO,>ߩq+)MYܩs^߅rsZ0bPk[?ƆJ0}W:և5lg\q}9?QU{X,r.̅d qS*ni/ߡV@M8qy\tڪ8x-*qsw}}+Jљ̷ă >aje()jc4H.1ۚRZ+s|23nuɞ)>VF :C֫wܮ:+TTj?y42t$j_C|G@OZU#R/̨=JZj3ݣ8c]E 2I7OU=L-nd( 6WAgQƜ֭%[X˺̏jhʑ=O޺i-63i~EK9 K*OO^Su:j뱙{:ኅUkZXxTu>Y@ۚELV$FJ;.n#mʫtll{^"8t 2Jz-d$nZʥJvJD8xO ѣcJU~j8JZumb \J˷jk! {NgrI,LWFSEߨǏΘ7qZS_OS-ӦGY otȩE/u^o_#QL@xViKb|n;L;&:fܯbHcq3݁p+xʵHLS(|,F'S%*Wz4+l:̤3"6֯Z6WFTs]. ܻIV-фkrV͛vwV7AL߳ѯK4 YnF ѫ׃ޮQ%:Ҳ5,G-zqH7{*tjƋ_ ēH^^uZ qe 9#-m$gfoSOqw+*GO7a\2}>UkF7~WYN[erZ\NOWܚO\7FXj_X_3oS hRW-Y2Eo6eHU]؍φ=uϟFMhӌ,0#26u_g9&kF*qQ%ɔcIAT|xyǧDghR>[{4iM,i+4ʭ\_ZǚNIGXӓZv7p[ٯF*~ʠFW =q޶,E:r-(YQ\xoirk*U;\]^[\1/rZO̊ՠIi=&5km\2Jn eJ)y UE*#)$sG\˱9Cz f(vZǙ e0ZΥԃe*IhhiS";Gۓr8ڱ+F; sdW#rL5ݵ ݕb*\%xy#[OusGxٮqI6k[k!^JqgnzyjҲJi~y OӁ. Qއ5>D+qvnZ"4Sȫ̞[zsV5#'QerIy$6VX={ ySU$in--ÐѫfB:{J6jܵo06*SP{YOm2jUQj {+XDIdzq1zc5źU(iY]RR~g,0ry?zQt[w5Bp=G$WUhuޝj F dp{sZS=NIƜI5_,YL;7SOZ쌽[V껉<,ǻb#NZTG%aޭ]́ۨǦ{%+3gιb7"hd{yl]w+OnINP汻/fERfpsQ#p+ ݎ8~ewqAw呂$^}hjhL$ʓI'ʸO_# ֌{;-JR9$?ϭy5#.W gFQjYyͻ`;%H㜞y*psԔmɷmI Ndr.":qTPGO9d ,+qpkS,.RʢF*J`î?yNtcWFo*#/|ns^Q_R u%FIt~:2Y|7wiol~&g3×]>/kh~{~_ҵI.t25,H| 7cOiM{G~߇RQ-.GzaRq,s*??6J1 BYVV[G{7.yu;AEȈY[ 0IG5ӥ(=?U4RZru{GmV1b6_8 x<9fGs{Hɸ7e[&c'oijuʟΩ mz߂Q̋i¹R<xǵx*]Fxx<Kvؒ2s n#kdWHC%դ}N K՘FqWC^/#Х(ђt׻ѱk3{+{ky$*S#Wny^4q5#~N˾Տ28:pz}jЪȱ3'II{:QN}5$H9im[Yc0F~#l>)ԅz;t>#<:`Xn"8?gncJx.[Ri{hխts<>X. hV!8̲sn2(xt=>*Ƌ>~h]ELԟ4Z/[YNR~E0[RA~\ V\8n ~͇L)$קc.*;ᦛj}ijbh]"79;18@JQ}܇ΜRTީӺm~gc>z ^6heXC u'uT)v߶?C*zo_zG˒]Ãۿ#:WSm;B}Z%X%Ġ$P[>rӌj[&]bUH-ùB6ncnc{уvͽzv4,?,xiQٳ4seH#>s^t'NH6k#/x? qENU9pNSuki,,-ch"@# F2cQն:yZwX|[Jg8`{;F*'iP[2|SiM3j#O$ca%yQԂ[݁Ҕv~{9UcUmdIOө!\*1Q^%nީ]tb^JQmjy]$*Jvc{t%NK1RI_Wzj6b*RӔXb+V꼙V9\@WNnXɯp;ح :9Ufbөȵ8Z}%!i|7 ¥NX^ouQ\b (}V^/Z+T\\2fkP /X+a:}:ΤȮKy}N[=W@=3mFW¤#OFqʅ8Z~Kuiq#}v1xZۭ>xq\QQwFu(l!olMIT/SSz?$j*>Vb\D 4lWkUk}^vŮvްV⹝CϕITE0S|~2?rŝ Xԥ04Y>aǥye(űԭIrE/^"6-q\^.*cI6cH[K/`I-f{d HYrX`yw[cp-B2O/^|-]nkhZ1 pFDqǨ>L?fVW}SQWդvt>GgcܾRlǯ'cM滪-SZjսޭ e[v φ7\'T2kγV^Ώ-hZjy?tCA]ė";$c~lc+ǡ*ѭZ5Vi{,B.{?ۆf`3f>Ͻ>iV)TEƔqJ[kc!]\Ʋ-C.8{u*n%cQSWmG֬d s7,@IG886ӭg}Z{']m_.(#wzx|EyIQ՜$]ja'HwX1>{zҾ q0娚\7 ~ NיGP͸I ucG14sL5hn窟֥ehoz湫Yꑠm&XpO?8ⶥF_N VO_qxZ;vM+nbr<ױ*GN6w:'b'drvSJNcjrߡ.^NM̐E|eېOk,Dhԓnjs0/I!Tz(H+J+8I6 V;?Y/6ݎpsQ[.Y-L1u:3^=?^VjݝQ5ƥ̮xԍK:Yϊ,N0Q tz:~'ew5 C- mba i&[g3aqqN&H:-ͧy|)Gq~2Gi2Na3Zq%V ~F{^Yږ#,a,ghp1 c9j 2eYvR#n 4Ow&5ZeȺ6#vGlu#WMw0N\ \3j7oDVҲ]񧋅=`KU88ݓ`W,dhNwit\:FS`ץ%<>}OpYYUKI3׹gN2WOc %N#n_o/%[KěZ@A<=O5b9hqkOϚHzyx퓉lĜ^-XKiL 3>NnOhӆ_C2-Sݻ މʤ'n.Nܻ+m=~[.p1mq߀+ӕ;/jQkvyo$p0Ы<;ruZᩈpo'-RX?Sя*~5Y<=}#){CSKG]UP uhS䞘?8J2%%iJ [)|`Aޛ*y<3{I\Zڥ*Qu\edG/$V-£7'$dӁqќ"ں掊ṱae}9fw;|ԕ9x?OJU7[91]=歜1i?/3Uj ;(n˦C9M Yp2?? VQ/?=a[g; A;{F4&t:n< >ff` qAөu*`|_ew:%y &U$^>JҬ+Yra_;y6۱9wqJYPm{AuHn?w`jyGj̚*n^'4¬YUԱ*ԎpzJ8)lb V1|Slr[AܤMr2 3Tө+-/3:7̷̙,g]컝\ҝne%&rIw+#?ҳZWzt^}bvcz1#9FumZUR?*nNy< O*V4Z_2HBWʎ4!ǾHǧ=kZJ4lO gb71aF,ҹOu*W؉ZR#n#x<*rA^ƶ/زo=mWeʌrsԥRM61b 7+}I(Ӧ״~+X7I!#{=涧Rd#Bd"ok9$Y`bۘ{dy9ԓV=ҧQ:xh-3.JׯZJ1Ө9b(c'̮7NJVhVRtTs&~E3zrT2d6[DY{q#?N}#~wuVhhB͵EQ[pqGҮZ۲c:mjG>YcURFOQ)ӕ:iT6f= / @[{sTy (aRof{(mU iܶp?C]Nek%ۡS Z.J̙wDA&:Vϖ:ekQ6ס ,:H*ĩqҏkr_SJ"6Y>ƐA3p7}=S"5/_CVuFuš@ەǧ9yJ0rgR"[" #tTI'#ӒC3H4S$"nnodؠ:O~>_X4z[P4yu yTޣ3`'+<թ{ f-W,yO+;R^ʒ]Ԣ#Lf*J\jRRLvR<3gi8cM)5r7_/yfX22@]$sƥE'm{42iNwj֜btQJ^+|ot4z>Ny0Zl|Ƽ/Q(ԩNs9Mǚi.ȁ(ZQ欋5o7Q}ҺhidJn&tD$.іW^1qV%ԄZ{_z壞K4ִs~tLqrrmy>#ZT;RcVn>x1Vi8>{P aӧ)+it nB.vldӟv,LcIz+^_+{,"UAEb ?]ZϠ_K4W0w.C;gL{u]:J2{SיݲI+ܣN{«*iQ_6z2LXRIn1tC٩_s?iShi/|Vc̍3Fw :gj+KGf.בZn,"gS}z̘^RZ"ݼnb+OU91"gJ nw"uY֦֎U5w$XkwCXF-z0;U{"ֆTxɺN嘮!YfG|<_JqvI#V^E+#EbNt>ޕ7S>jeZ+ZA4`]+uq]_CibSP,$K`w˸׸;vV5;GҢqw.1Z0~#rcvI6${{:vF:slmRڣMQ f2I8P9G'&b媺zko_#EOz7_ > S佽ӃIN3aS M_qEԋ]?OV/z=qGn~Oܜ?N4k*);*eZ|Z1̸LO@ˁXJ[C5= f&v>_*({]ZU$۽*Gi|mʂvs9'h6/z7>V6+GFX~N8q ~9]nA{'o1s+cbΎODR:7?.UczyTRF+b7ڻd,=תg;Z+GŵW.>agkT*ԥI]NHu M%vʪʽ~QҔ%8yU0RJXC{o6e\<kΨE.WdpC>M|"m64.|Ղ)F9?OƸZKjm=Ua?ؕn`z[=8=9TMyq'eGF%z1^*sRګ+C{%}A_˾>9SNIEhs6[v3\9Z -R:xWٺj^-O-º k{ga_ U{J{욷⏦fu%db_x>f]_l#H S@y8aNxY&8m,Egϧ+x^4H|uaqe]6=Eg(p2ylz`9-JTޛ6V; *Qm_Nw u _L!ӚM5b<N KTNt{v1=}bkx/ϢsE򕈞 8 (ISWګ߻^U$:tѮL?6e+qZNS{~:TvGEc,VbIfnA9ץpӫt~)|Kz|]XHE ѷd=``{|+*ׄ=5ϩciƋrG uPѡ_'4L!TL #Ќ5Z4\-e*G~L]gt=Ue)Cnnl(AЏȰQ;S̫VMRwjbszl ;G 2ڴ*'9^Usb9&j)n?Pۨc[ hZ9Y06#pP9mcIBVZl?QMwq*5iW!1 t!݁iG.̚nOz.zFy.<UFFe&H'FxݭЭ.[.=yQ'^;#ƝMu^AUd xQeWkN7Vީ=#IޗKH%DBϔ8zҹaE]b9(jia岨 w q=T*cg5|Zqîg~k3Ǿ0x> n4Dٹ7B.mCgyhKp7 R6ܞܜ~*%*Uag|5MW3/PmO ^3mG:28SuǝZRViu~]t ;]Ѥu[o.FE| nK9Nun/ŽZtLI-pG@w{c>kJ2֌]Wߡ>%ޫѮfV@-v# Q#I~TyS<|3S𧉣]rVn#(NKgpcoK :8ysj50Zѣs,eҬ:٥SaFuB[~` <aRr[[ JQ5zoc"kZ\ZȢ;\[/W8 <}UH̛o_(Ɲ<-90|="̐qofe!O5Ύ"UݷVyxʔ'QvӢ3<-:ji'8;9p{YԔiԴGcco]ORgoiȽ*k!XȰ돗#⶧NV]gYSޖݚzσ5G-,Zn&7|u>h9'],v|s#W.epůT٢<587c<,RR:>0fb`z:t9骔\Igc*N?k{j9qϛKa֗Aʶy![Ԅ}C%~*uU]BeuVRV|3}&9YmfprO`?P-:(TOxgSm#MRḅ`x9׭YSSnnu{:λN/jDs!#^2ċL\jJZ"e&nDGD*J2doCTM25RH۱_u{m-4Fs3IyH7ggn*t#^R徟|:9b%4O_ϥ? !ι$Vf ':?oSI6|n"M}]u>^[󪬩G*FzqغӕcQKlX[Ϭ$kGz7\g# zc5x rb+YoeYN =5tkb#vُMk} mK\uq [Te^tT>T~ ~🂬./uo BB͒1ݽ芍8͙|WvMS|Ep|EuO0̒]a)<8qYW};\p={~hk-wٟs1MN~do#g9#.IAh=ЧUNźOg$: f8콹4*u=䕼v`pN*KD_K-Ym^9U.^Vy4t*֕wu9kV-vr$}pU cУRJjVi'/k_>7J[[O¦k]B8bTFwGln@ۅIKF3c9)IM^t_~ğ/Z]ɨe<pV;J|!"zPG߽ߗ|32өR,~*<_qK^I#G%J" TLP0}LaFgX)T|_=.Y>R 6~dp&QN9zu"5؉FfzZu#nyVIooxಔf;>lt9czy:xwfwF?Fr{[{vz_ ]_*@H\E3 M7wC]R;WFRcEm_L[ֻd,q<=HFMY=eRKOG]8B8{k/X̒4e ʸ*}=:Nԣ-7)~wt~˞6n{|֝iz+ckŌbby*،w9~`9jۿ/O0U) K?1x_~/՟=|>]CX;AuAe~Vv=Wa9gیy/?3 S'g'^n/o=sEυ m/# pt'0N9K3 캮v0*q;94VJoǡMx -/6eH6';ђv82=,*)6}mt4ѩթtKkmV}AuXF|Hʾdpl\9_F[.VGTܯ4Kuw඗sejTG !-є,x-1Y+޷xYeR6׼[;t3x,`DZXR<|? =u>;:%ymLNxzpZ%6G٘2i6qz)Hʛ}l_7mku\67䃐8<*彈R3m 2D}i^RIx#p\px%ˤ=:iA-eN6V2\ހkx2kKRu{lYcI > rvJq7)5Hf̟2up0sSUVⴶ/+Fa]f~ldqxǥD] *$^O'q`0x֫ܵW9Zn3c"yK^S9^խD|Үmqk#7q".~e_=r犮nYm5ZCh Dv_3qt?~]qjb)Yeq=GqzT++ 7nT3ַ\U{g_{l sJp}8rkhJRөQM{3挅6H]21cֺa2̢D򫯕t~^R2kfU -v8'4k4Kݷt-u;x$-9b|㴖'OʮT֣t#/g(֓𽟖#4Y&q Ϲh鲲bQ7-%r,E&hʦӞsg39b~ѡOXVq̑$+dwbV=SrTd잿8{xT\|[*J)Q!Y9+6 8 c(&k+ǖۦ1g΍ʬH$9;֫oIJ#Kj,{qQzjI_K:_juܝǯ^~"t癊SoKoy,ٕ@n`S F59`gAcr6oez~YCHntʜн5q[yOܬ{UHsJ1ӯ89s7,VJ^I̮6onQi09F"1͚ܣjdkDgRKʜ23[sxǛܒnQ{p`>p2?ʺ.X{(ȶ 5P N;.H˛sS.d٬j=<9zwsi7gԩ4K""9x?:#{,oJT-VnyUԮ|. ,Xwd2%P1ҶV+{],Tzyоf[|~ĜԐM*mY;{ϺSA{9F\?7ȮZ]hS;^GxSU%6I:}R{F4-A+y{OVRƳ-3|QhsI#il!Kaw#a^NIxe=B|C m8CG>Nmj3cij x\pti<(3ϯ֓/y~ ڗ7Uu>fH^\ \cvli-UQcY99>inJN=IE}˳TgROnk8¤j^:7c8${ܧ^=U98)4O6M&x1'9׭(JN^Պ$T|*4nӣ?hJ }js-#İ*O1.1b{Si$nZVRïNx);FQafA&y•a#"hFq,r7sܣ,r?:%Z1MKsjMJRW "5*7)b:j.-W-䤟^ѾVێNMazwV(_O{܅c JMTY.oH~#'F;]c.k{i}EYv~;ס?p>g}:ƨ')pȫI'Q'Ў#5=.ՙ}[$ȫ}bis]:|Q6F_C)lrF|Y b11yBoVKjrֲ.w3zZJ9tkҪEnXU򌞟W1ډxԔO_KKK$0-~yq{ߗdr՝?v}˱\466 sl+HDvGkO#U^T{vQ c2{z\vQoU/ܠô cQ8#'GAwSEFQ:sJul+Ivc `=N>l=h%oR1eR|[ 'WnY~us˽rB1ٜI+[ORƖkkyռğhu+ cNhwvKmRsvc\u0Zܸr+/R(%_ VS)P3`+7,})aO޶ړxeӫ~D6Wp",RIe\y WoqքdpΥiFI&Em[<\.QrNg^İC3*ZΫUʹRr9o _9yqBcRd|A/Rw٪e)66;&7䪞sj\hFJ3Rm?"hHp̻|?SW_Yi;HȰ;ݵfpmu9 II1 ʼB۸ w)I빿J*-o e*HPyq[ӧ׹eR}7ﭿtI,T.U_8|q[璋 t#9Zqn#mb_ i?uN,XsgQ.rq^cze(2gy( w0_nu:.9 SVv=5Xc]hVMm__ K{o@9j.A|1f<'i"V~]:QG[dFgFr9ךҝ~_7:#IZY2zUXRb*;.E-[X/"GN׶e.ն*Q:rmb iI>HH6<ýJRTRV^U9nu=ǽs)]ljU&b |>%(љTSC[n,ZK"oTdw(.£GsEV, ?DWvD.D]I^1tz^D-# 27'*j|V55Q="l[Z˻Wc&KcUNZ=፛}=1^rzrLSdi_2/7ܐC,+#xֹ2ҪT6}I#^hb-\qn pb?wS_qJOا؆x$KYc#LwO8^RtrRJ5i{nBLΧ4އ7)֒KE놚9nf1ɷ @'#[*c7o-uHSOzq骽պf|s ~f 3։SZusy"u41vvõO<ܔamƊMo&VVG_ݪwjQkﵵɫ:߈ɉ~w*2Qג:N4gj{N[u 8yw*SN1cvVkNn/$r{+ju {Q[U$68]LD/:.vfD\B_Tj^Rhi1Q+1)>Oqĥ\8m XEXM}LiSj5AzdT3j j9mJ5k'U%b4Z EaQUbgZ(Ú^E85]- |73M1nV;Gj$uʤim 0U I g8+J>T] :u T|mx.Xe)3p 1T*s[KVrʴUEeuյxǘvɓ`Ϧ{iӜ\ҔRei3b?mӂ–nIus~Vwo:1q[?zrZš{b sg=+u)1JNJOaǟ 6x;x''<+Jq-}NէR|,E<{:zZZ99T{Nc,cC1̍Gc$uCuҫ2>coh%[yc;B,[9>9SVvVQ^}?Uw9k1rӧRw#U-ɻ,t'?1I˪v;"%%v mW+@ۥ:T󽼝;IrRX~o~O%+*Ăx>8yZL:vqwXiuFUۈq߃Nk*lө칧ȋ; rѤcS{dC6ZX3r9\"59I\l#nr6@8ǽsªuJ6)˕tV٭b/6ܯ(${ө+.\{yt0ɷxcU"=?B7K,Yocndf%Z䶷^8gh&Ukvl9Vө tUj8ƃ_-K֢$bM.N.>pk;rRN'(J˚f #aOcit]Ti|Zd٥2< 9'gu13ZeYO>\[:IcVu_ʕ?zN[%9RH7c,ۛ@N01?:R;)&.4F䴈ƫ$I0w0ؒ{b̥[7en_V#Mr>xRoeFT;]h0%srO ^Rk.g^/UPUx:)ь4ҘOCWc͢G-jѭB4{{h<߷QUH-{=5OkS`Jޤ&!8W1jz`P(_w׹je6wu*L 8OnL:t[߹0kkx1wcjʣ&Sd{K+H8xjg4W1͆O$aeZn}rs܊:+yʩ˵~vkO{FZ+Soy ti.bTڹfIzR/{_2makKVvu7恷txZΤShiSw<;9vO?rJQoN^ҴX2n1mS{m>j1Zf!Y_19m_\|oRNG7{DBGY$ 9UVƔeQG[~]KƗ?CUc#gR=*Ț|X)o­_AݞtJ59 lwuNs2;6iH򾟀$Vb+4erz~[^r5 'Dj۶y=hFRcRr[[gZ:)\ocsCͰ?<#0 WkݥE5svXXlHUp p;oι*֍OrԍYrY-~[tw,w/AAn1ESMvXPNe|f'9c;^(SZ>ńI!QV7 ؉YziQVVVKN-C|reہ\-f_2CK"'i0m zSN[ّx>dNn돧5qdsՔyԩ.S>KȻp;V~4ʷ;dMm|N3{)MKh VyG[k̩'YFi8\ګާ+/E=1!i|?2ՋhQ/Ve(n=2 uݻ}N_cN.iKcJV J\09y2qmyY[RƗqma3`~V#*%FR;^G4:wұhA.Yρ\#OI7=oа[,3׏XԄc3Y^QԞ;hq, ͝I_?Z+{a*BkY|HUK(Ǘ!㷧N*{(2図֞C<@hX4'&Um=s`GsnlJr)/T|_f,>O ҿy^nX^{̮O^o6]ts>cAQ$xР|)1~qыjiw˯6JѯY7{Onkdz Ӽk 67ކUfv(aV*.wջ$֮K-oo*UbyMkޝYo/J쮡 $83m9eP½*|ɹ'~|ڇA4rOQGi׍ChI;'y;5i'Hݗv|wʡxϭwIUZ磇ejn]vpl0V[; ҡk׷*es{ukό+T}:b-l"u;_-o"CZ״;9`.n& ˰ 's#_QO)TU"i-Z֢PmΒfmgw^F9]FIkiX7pҵu-=5k{ᑦAHͭĭ YyW+Zg)/eO8>;vnK۶ Gq7hes7޻yh(Mik3оnmuV[Z18E>zYqOj5{4J:.VM?zWFavns"Ox#>O__&8w6/NJosTONz$ZZěfΠno<F*3e\*R]"FS.Gm)9 vO[ԦN\vO+jZޭI,!~GUYAr9e8uۆP%sG}WN|gj1ӧ{;ݿ->o Mu6$RUR8>ߏ+iʞ2͞"iUM&voʪcI=Q'tgZ59wO%ծaіyJ̫ F 1Eqƃ+&zThi5S։yɌ,~,yNuu83^5NqSk}_KK-<Ϣg8Z*?q{?%ۢ"VvF <{uo^烏6'WoM#ǯ^qz]q?I9>ד#9_LEHI%W^VW Ҟ*R63~dᲛ!}\rG^r1]KOkCV/ww> e@fӞ5هB7]k(%<ԢKdyvp9ꩋJ=?̚8JuPMvQFa:?7r@N'TiU]o8yQdZ%JBlse7e8!QJZU*{ѿ.ɖu $q+%巏wʭx5RtTlF kys_ZGnk\F~i z?FJy^ҷ˖8єۧ$#ԥ$Qe̲.@rA?#Zu!%'p>&/ -$}O`sd8=kkSz(Ɲ>촛%qʹ瑸rwWJt:9VN^1.8_2l}F?ָԠꗲ+Xү4 ZIj@l]L=ewx+;%i$, \x{;K}2{kƎ-kt< 5oRx98⳧QVpnYZNN#^z67$habݒW#qQwUJpz-tv+>sk@6*LU?R;V~1r嶮yXh돊zh%µi"*[<> ,,)4kUOKJJN{tV>{-b@|"\-H\yo 73.5̀.9ZꔫSupN0ùs)H3ɯA-Κ~z#3I6tqIFM|hy-kD6^~fj^}<->ČOJT{Jqu)$[ҮFW*+i՜$;-S- wO.pܷ1O.1ϯq]raNz<=mNA>V&CV=t}-|sckd"kTQKT&2ǴovknT"5E9nİaifV*Ҝe)m8ԩmeEtGIf`('zƔF_#iN4j(^݌V;'D qmC9Kfb\FmHقL3#ʢfryZs2{$j\sVRT!zu'mS/Yc_)QctKʕ㞤ѭh-<˕]ų/=kXwcej kVYpʹ47*ʑiG,m8c^s\"sIJ4ӲxJohOĘ{nx>Qf5=J>%9Y|m,IG|-:s$!³n,3r֧NQ'6-c=͔Fg{H{GĽhK0Q)ẹI[L_3ijgNkv\ٝ"~GUP18kX2ۢ54 ho0DOTzpypkϕ?ktrƓ#JvY$w6yF8%/gxo҄J. J18~'l{ҼZrOJ-Ok'*;38,$zS]u8)-on-IӒ35={ڱZ3fe}:Ќ#%j"y>Yq= Q(BTZ*NVV.a&2ڰ*Vk@~Ue;[E n7r3ө-NnK[ )-c#H<2898[~HBFC`t'Ƿ5PiZw29 n FϿ=f9U־C.2ۛ''zyR ;:kF 45]7\|۹sTI掉$okkQ݇D`2S#'urӝݾ4kR9hĒKwV*5UmP3cSOv Jdi &femSn ۇgyzTaf”Y.|¸gSk'`0xce忻ȩz7}Ҕh]߸MmIV6VwPy߽\Tj:~FL<[z[u ɸr9rr*!*R|v{Fv?KS79YF]Z9GkP). L#Fpǡ c#SSod5:{۩ o9<3l A*NV:'[ J7!Aud۵[g.hjT*ԣ-Rm<6U35#/bS8Zl￡ e*㑸ۃZkR^k7%/-grY/'8늸ԥ}:ShU6ʨ"H*u*ʥhiѧ)Zo--fTݹqoAWO4}lmRọ.vR 79oNFњJXu%MZ&HB1';灓8W`"S%̖E ;3׾+9ce$a{qRm:+98鎿ZrAhS\ tx硗*V9sFXz4T ϖΘ*uU݊3K(X`W͸_ֶޣ"Rg@čU(m="#׻d븭 zuN$]jz~e+`:ɭ\U8Nb c0nv5Fu'2k>Rnvf_qkDD§SnF*j˳wQM'VR^:U4ئ$_N&F,?5RӏSHw{w\?Viƕ0jT!n?6@fZ/霓:ue l'oAv?¦4`1W "]/W[ƢQFRTUˈ;1Va֮5ӝ8n^hd|ۛի+29F*3^țY0 #dևW:gqN*jrIzܽk-Fە7;9*($TkS:*F6sb i+XŒ`;wM܌4"֪֗Kh&VS1tzJW.5#˪[]hc1uS*U5^rw߹.?)mUbH }zrQv*3]Irj,fi.h5ڋN=VZFLcn. щ!ѣPO e g'Z5 ~Kԩɩmk| D d8#zZ{J|[cT!Y{Hڥqr%Ԓ:F$6qܟz27g.rђn:=t*RGʽ(Y +> q95Uo VyvRlW73ϲٚg3`k~jp_rF)Y.+o͍lFo2?2`New~-^٬# Tޝlkʥ7N+E_o"\Uݎ GXsJ2{yU񨮮RWrH,I4*˹G~*Z^1NRn刵U*c!qsc{4?R9h;FZBU8$rb<ɷ$pUq(Zˆ/n4#ZvW+>޾rkVN+魐\j1NMq"#0q88ah3ӣ\9L_1䬛i$;8u]{ U*O݋^yZYXVky, <JՕko~jVVֺPDj#+g#q+O}|Xэ=LBw`˷*pq֒՝V)hzu-AoUcySoZTNW21u=Hn&mһs\Kjj?G=K$PʂEp>LWAw6_Xu],tFmGb0gfm٘`NznF|3'PHih>Ԏ+H 97kc]^=& xO%gHӕ(=&vZfwH99۽уQ0*wl.exWE?Oc*4ܹ}Nr.MZekvn4OJDVg?7Xb2xONԧMZX_5|?MWMPVvHW㯮+%uX,>&MyxEI J;cIN=./nlfyF4br 99@UQh(TG~'VZx"=r8'3g >*Q4|eR:8]OVnQ tQ.388N9S/if\uxq1N>/qm$ te~kG⹺yNz͍7Nsq32fd* sߏלtiTSݕ_qcZRu ݺ7UZ\%Ue=?sQExM֚溊+:Ʃni+ciON~V>is*T}x))NI񿋖 TѢ͟g؈ '*W8lW`Q`y_O?SlͰWO}_?SO ]s}+؈m~֤cZ-Ӳt!m=b8p<Sz|э*m|ˇj6FpI# y# gszf2xTJѶꗑ6ڕ*ȭR\u4+0puӭ~gk>9d\ysb}kcjiT-ߧoB[UnxsTiTrөyj~fl%ҙRs`YǙKcХIJ\v2a#ľpTUZq擳rzD$+ʗ5KŻ?Rqտ nff$^ejU'Gmkln|:ixV*lG1R^]LE3["6r#߱si &Yw8#ߦ5R7V˿ˉՖ!SRz~ʾBIǀ8u.e֧=a'MV1'yhF6!al}ܟjtqUr6jxUzv~KmXfYj2?,aT|~nIa TԪk_}_[둒yZ4>^'5 iz9#}o_W*M׺qѣE˾e!hK@=ӊv9hӳ[?M[9œ[ SQp9{~gIcuw5Ne{Nh^[{uY'٘.u{z(B˯iSTݴ{i:R2cyTRZLDqM]nbղ}G;7ۼ^k`\G<͵QIS'c+jWU)|>}c麽:3ooHϕ8Ο*8c)R-+_m]N=B&Ϊb79mBekGFB2'P_;oц*==w:1zxv4[]NwYuRs~rƇVW^w ח8KblyI-<ƏcrW?vOB6D5n81;r/6+1JSw^f?ϺOˡu9+68SUF>T8(R<3о N,3HVQD:jXN.UtXqssnH!Pn8j9Xy%M˧ۅ9FVqmFZޫ{&6l$`)%x89]TQKͲjӕi{o-t@,>[cٹrttʥH<fvrY˨*iZ` &wg#qִWNe [On{^%ӼKåR j[Mw(' m#7jcI;;?n?5%ny4`E$~#+ǛU=|E:TqVݶo|mRIQC B$ q^EJJݭT(;֭:Duy4}ET ,X6Hr'#<E{:rt߷Sxh=O'm#~HѤiHu,#a{tSHۻ]O{ V(;o5ŊdqWsEJ8rTkka+&ztbNe_SͧZ>8eة<.QR:5ZJsr)/Ava:FY[*?U%)Qq嗙tg0|\R*eJH5%fPwixUF噍 uM-M )$k˷}v*\WoC^Z>ɭE֤w +GtFeO7g0e+!,ianW^f*J-7}:[}I.oVC<8I^`F.\SJ˯#!AYFRxo<9+a+HFQi5'DѮ+Fhx v?r;gs: Tvw<eocIԒc)Al?"gkeR~'|+sXIqm\^/`y$*W)lEzx|³tilI]>3c 9vwWM=]O1x8j@9$2$⟞_ןhӔnT^[??oCwf^Nm6Y'}ܓcx#ˋynVحo͆jԕ8&5:t㮍ڼ4LfqV[t2h|%*W8o1M˙ePf uB}oG7\ҍwVpW8<>Va){Q59cHԜTjJRhoR̗+B}ϛh/ۉWE5Ou-xfPmޟ,{2- cXbUoμzs=kYRdofU?m%rήx}Z ܲԧNN)%}IJvpnkhaԢkG9cHc%6rǓ}IJ2ױOZA.#ڳ,($pgOS[QZlތdɼXė2<24>G<ʩ{8z^VX{VT+22Fp>VjօS -:o\I"ϩ9*FR Hթx^jlnUG|ce*|W*9Rv9mGVkhZ4U[#OwEԭ2)IO['7q]PJquy5e.~ΥZo&ҷPkXCurZ4˸99=:zqc8EIZvݐZjn-j6;Ud+uNN:.7voNj#,Ynzgk_98sׯt{X5'bb<=}*"ͷSzJ:H;Y,r ?^R;ceʴ0$o2ؘa8=:9?N=1=gkni1Z*B@'?LۋiǛXyg"K=mnV8AJSKVT(9%RTFnmS0NpL4N,jMAd<*ҋl7T\{nUCgJ1dm>{ c 9.s޴7U97F5##Gl敥- ksN[O~}i1H"rW:iGCXPEd{}**{6~ZN8w/E2tw*f x8^0cPvITL*m=Ny(vc}">,oQ~3FJmUnBxjO/hgYF^ Xv?.'e,=(I;|4mKtv|L&]Ψ~n[# ٫Ͽ7e]KIarڸ8gt#yCvqoe3K)HIc¼9YД)X3[ɁFi s**s)Jo: .+~Ѝvh_j^u57Ț8̨DnAU=IhTc IxOÖzsZlm S[2¥pY=4} L6[7|0qYU9tKN2B~uܔףtNW[rݕPGZ(ԍK[~iFtۂiJ{Du׹iS SP 3ni1x]NӴZiҤ4kZrry aNx4y_5s术UZ"5:2r˞]5ަ4nO-嬑̉ ˜<֣2 15z:0CӞR8ke*[mk%Ϙ+#C*_ʡTFJ ZMO,X}^3HxE)ZU(c]4i27R*J+s/[{wV4Hyv:*Mm݋NeEZwǽ. yW*8BKTUJYS޳HW{^"?[3Vʨ wsc8]HЦx\cr>R ׳:)ԔbR-XE#F؍U%OgrYJ.cB.HU/#FaժJ+1&m>(Llo*Hz¥TitW:*I<2m$((ʬc'uT&_Uh^v1r6R1tjs)TiFGӳoC~8#9;2}M*Q*sFL3lk,2x郎#眹6o8k'G׹sOE.NlnV6 |*+^^:5IlYZdۘf@nEbNM۫-4^z۵ eU npGL~5?Vq՘VR~/]>ݦrtaY#E\.%ָKK;Rge&K-fu>P8#ܪz=S{7&o}Iԑ#}i{Lg+K˕u}:}L,\Sk7Dbk5cPi!T <#rMq֡xc(SPJ/~>F :5Hi~^p⼊sΥ8CE{F"X_Q|וZU)Ҳz=JYѸGwȬ5w8IS\vcR,{^E&-V&8F7sb}ɫ5/kGe}ߝɒahn,C' s내xucR̕HRI{e 9 ]xW}_Ty%RtkOԕdGy>ʱeƤ%=:tF4qm7?kg0ϻ$YF<%*KZ0V!D6Ʊ٣ۓG4\%RQK$Kj~Ou:U(֕;4vPqu}^Sk}lNs WpZw8?b`kbX#e+6uV =~(O>#*Q\v"o;p7"I@SQWN]0|qDbEoݕ*Qk4b͵^ J&^ƴK}1emvҷ*>sq#J0QIy?39..Y&_3摙 m$K*.ڷew69.%]1<><'AZF;f7O fwuHHc euiXwwc)vגmi euҶ 8cR 4F!fo*OS#k$ۮR֍W'} \_I.ޡ埭jG/g/=,p愾%yWI3p ͞~?}:}7sMRpXQ'5=ډ:M5˛f gvTͥ^#H{y)[!a?z'=.K:#JH\U,e$`Pג+J12]Zo]أs]<ykں)J)'e6Κљ 䤏p=ss]^´co~ݕUі+{S}\q}?:mYCN˰ưoΫOz1+zь6,n"wc)~ReC-B :swst+?MtѣRN.۽渖O6D6u:zU){3,E%Um4\OSpzwg(n+}a[$:HD7R*!Gy\:iJ~y+(IGK;Ŗ A}T=9TV q:3ⵞh^UYGͷՅ"i㕄ЏwL?tJJe7TZ9wmֆdi3N{cj4*:ijEGixi{̕{{87?,’s3TuNRmYl, $[~~UTJK^`2HefRze\]ʧ[2n{[ˌ‡mg#ih︎NHm [-v]u+ eʛgl vߧ\[O4F嶴ۗ/B$ViY5jJ  92[q,DosIm8ݻqֲU~˿XCbtvnl|"U*Mk"Sk_ QY;2/ jK4{~SZaXU9sڔ_e*$ԓv@'/HMaEVq{;js^7+so$qU*Pe5apʓ2(mu_d*yh{_ȱ«^y ڜ\$;( 4k'6Y[Ɖ䳓h]2wӚ(ٜ5#QEymu2fU2;N8=yQ|קp$~,rQ˶UJͨ5{Ʒ@yvz7mIh%}9' &w;t9ҹF2G~{8=̝w7##~*V~FM'W,sI'7p9u֣RnͶQ G-?SFķ5;f8ROFU,=Jzߗ}Ak8ۙ άYT.pO8q>§پV3CRZ{ҿivv ss۽tSqMYJ1wӡozrm#r 2r;v\ӡ/b7p(FE׏5QJ-:V'{ך_$BsZFe ˤʒ9H˵>njd#>eFJQn؇Rrۉ;NOO(qhV̋#ĄO\vZo(m`*:#ɡӔ< ;41~V^$;=ҩ)P#*;Zh@XnJay9%Jj*?Vicǝlerx#|BQUZ -f=?jе 5)m].#G$՚eWן[7JM6sV] ?#yJ2O:QE)YN v237ͱ1>gN1o[Η2wVR](10O[B75N+n],R>RgۅX.6}2B캖 h$KV$&Kq?z4aN۾ҥ樝ve6<=>mGrRmEDz9dmopzOj5,ZVw\}GQ.4m;(TnJfΞw[m!|cgF0z+ӝKV4wv<6X8n1N1m F[ӥ~~KNIò灷3泌Z/!Jre./呿yibg9ccjiZ1J+&T&0Ik+I$W4}zf 7ZfCWpkN3Rjc| PU3f=МA.U6{:rU=Ժ3vTO3?7n;_{+Κ|+c_kF/I5h[i#d6kzc5Qw;5* <ʿqGJT+JCiEя*|ɶU9|+w]Go Ȓ}km`HPih;]]٫'w?Gyon^3^kY%KS %Hnp:sYQZnIKV,/ymޚV[ijqj*390IỞlJ)Bk}Eo:}6!h$3gnH\דSj==mho̙`֏,տ7G/V]C~jl'ϜrMT0.VߦOMۮ9IԼ{ڭ? d8! F<^n<U#RQwuO|%Zn+;]q:cukSqJ?wڻyۇT',?q"NM'CD|l< tyIm?MV:s J}vnMos~ Z/{kn%g A6scg qrYn[]_ӺHq=NZOV4{_4Ğb׋S >daSgS{o)na'lj0 }lTʓVԻxelCtykק-JΜrSJwt+Aִ]M-u 0b'R*nO;O#GM*c(֊?Zؘb(;_>'ڶ%)JIm>$d Ac QmR08Jv^ѷѥ^5惛r[4] } 5M"6cDZHTePpdn¼k5-*J{3M[O\ MA1vk4cѭ*|qOMu׿ol- (wzqtqNur?z5}!FMt0,V8Vi$Y>EGSܕ8b3ȼ)Xʃs񃃎8bWןJ8)I:^c(ԭjtbw{xLH1܍9ǽ~a0_zuwG)'Y^eo EH *0Hpcp9pkӕHϝr]֞8ڕVSjzZ_nkuq[Ow,2eܬbpy9+ Ώ-JWIYt~W_~X:TJ)ui{=}= _ xsM}V{[o+-G`=9$dS[Z黾};u߿Q'ۺ羥+-:ϖ"spqҼF"tkG*ӊiMpͰ0_Vq1VW^BrtdtX8c̻ B@pMihR *.Nb/:~UOh 5#*H 1隺OWLY^;ݦxH,[m(aAi_Ӛtwv2FQ.k՟mC^1"~Pr?֕hBl<ҋUsMio+ԶVbPn'ڴZXFuz8\ڹi9G*Z4-4nxZi?̼zJ4y-gnOKuq=V1폭y؉g*sԇwfyj+!KcYՕ'yQr74KMk!sYTVybJqA U o3uqۊR)a$FX*5-lݼvV9mZ2VƳRogЯs*fǸ}jV8R5^' n Ҭ)ӋMJҋw:8eDxJC9u:q)l@+|ŔxƵUJi{tSKJne *8ߜzlWTob'Ql q9tX᠜93(ԩ-nd{\LVXrqׯNя/ZigRQ伏m ZWۭdWʍɭoӎGrykѣJݮc'YInVs<\I)031k?xpr].?|3b\<|?/rt;H'#5[V_Lq*1zDgxDpI ry`F~|oʢ(겎"2yuE+j#:2#;ћ$9=u{*4V#뱫Ѧ}ˡ[*I/G8 g?)I y;rkZ*~F4Zl}yX_`zf"49PjJQoW{oCcZ߬|YeA I#x$㿷\qqzz:ir[_>gsq B K䜌H^(JV (rQz_kQx$U  r}+ϒG5KIkF;h`'pN^2{=<rofWv}q$ UKH5sTyȅ:^66ccHDx`Xrp~zz,aLB~cc+ӜjGsƞ w{z_a&iʹ+o8Vd=hcԦ3r[yw=:xAFD\ہXpq+'-7{?SVRt&8ymʬ#2TԬWSO3|y yhΣэjj/{ і6mǡ+;RW6]`DnsAeUhHУSlږ+m1F[:FΝ*e/.VZF{kJ'/ciȷɑnWqSNG'zu1QI5p]>sl ƻ)Gqxůr}D諍Pg+Nۭԅ<B^fU)n Xuץ~Z0祎 eK*$eK01'+Hf8eXϒ+ǩC_ )WeϚ6 A+^3.G.Wyf.R~K~vS1e6lIl{1?JIݮsV9ei躽WZ\z6`7:sELC|f5^[>ie5Dr+sבӷqՌjukSQZ+iZxNV!j]L`=K6掕N2}>O Xa#£4`;qsUkM)-w;1XY(=mUlov?^@OQ_z|zASYMT;i[۴K#l.3=WLejF5 %MەdPǷwMٌLq(ң%0r;tns轱ۏKem;j$dʍ+4Sq̣-vu `r1o:ƝOeQn:x>UNJVr`vlL8Mtb#OJHfveUV.(f'S1^|%Nv]z0=Zls CjfYcː6A5"9YvQQ+@uvH7zpkj5qj_ST*Z~dY9gG6˹f g4T+nnljFQ!0imbrZ$N8IUtտSϩ,Ӗ:|Dpub/8|/aHʟϧNO4Iqi1c']y|Ĺ Q0ٔ#TF{OORP:\|}3N6FZ5֩J:;BJ%z-Yɏ.>9㟳foգSk;>#KM7zsVS>1Z~C`ӯmI49o'r1HʊkNcin͒G`|&0n0OӚQQV^hKY+q&XzcҽjzX~ZӻC{hEU!k$w>ݪjr$uɝ|+IǕXH\c(/uY6z\`VO&y3=<]8٥v٭9PnF-cS42EVkU&otTGTNETFwѐ̳ϐrN1QkJuBR},DbYG8]\}:O͝4aN5խ=|ikH֒_ zcM$ս\usJjrNDOCigec]Gʝrjѩ$Xy8:kcD˗PG+miR{w3q*/yl۩R[y hn_f:'cHqћJip18>%ېloݯbhhm.e;66il9U;#BXSe>Ttu*-& 8㎃Z|JOcqŠ=pyfLƴeG٤w(InYT) uz{V峕WE3B>уIx]ҩ8+z.u$<,KTvK%鑮O'&)B/l'5~aNq(ӳ;Ӎj-={o൞ݚ@4F0}<өvN?pK}YdF&GyTR{B^OVɠH6H؍c|=A]U_?'tӢϩb)${i&yKnᐤ}zFISGMyKk4#WWd́XYzg$t#s%e84ZeVןk8o;$m6ʽKg:qZߥFsc?loH+6BӜ}9DUZMOGRTh;i̩u0 )dH]@`=Hkg<-ף9#%O$1 y?DԔ6sӅRW*ZZwgmmmdnLX3SGJ3{W RmETdX.9#@l ps?RQojAҍЊF摈N14U)FoC*ҝI4޿ք7 f[!NݫS1S?SKYȑ!i#dl*zeYVfO/ ~j樂Aڷmn"iϳEn#azӯLfht8E.ʍ?mG^qL*̫3mĒ~bzg)Ɯuk)as7뱛&IC,ch ~cөxu#NSQzf夎wGcy rʤ0)o}~⮣Lвvόc*{t&>rb8$K(s婌vѥ(ަ{Os,lG&8mR9MMXVLcdKjK~A]B9}>Sl۸<9ֹ'RMN:hnϢdOk0jm%J0>S r 0q ,o/=Wqp0|m~ޟtKwKmY1G9[ʜ=/:5^8>`efVԲ=FܠJt)_8_[JHh~9Z0:41ҍIGݵ ۊAFy''k_cN;7&/[<.(ȼHwzRZS*凗<Hڝ$U?L\WL{"7uG+q,1JyӮx>c8g{lʴ^i8o_uyNyŹ)ax+3.(G{莺Y*y5~ ⏀<AwZEn#t39 ߎ#q4tj=fYN*q//';?>,-Zw_3|b!{ő_2K<Xd9G6/VKlo<PlVSլ̿D^؝6k0<=~ߵgSr9_-M%Wdqó'ȤsLikZϪ9UngzOG^񿌯ASO3<>bWkp<3pqk=5b~M:QM.k~?_ύ #HR)2\pʱt`x$U4n{_eCz>K-}z'|H%4-e9Hd|#gZ̻sc\=}Ue{hsޗ)As.ws^!E\yG1H`yqùۖ1> a0Z[ŦnHBXԧOVӊwbۨmmoѣW*p{hBSW/UЛGKsݭ[d{zv?Srtۡ͊tdlu-F W5W4u0:55˩IdֻbI%[ұc}=꘨ւTG?1$%CRE-Ώwhfii|ʸ/ޮXU1}xʞ)85\ ?w'SN\{ȼ4lnLl gՏh`C08Z59?+iJ2{K>OmV谁49=Gӭ|EV+T9T|薺nCbcfc]<·Y+<7T:4&k ~p׏樗-g{7 ^k|gECQcY-Wpy]GQSZQvڟ9^|=VGM&Yd+t{XZKN9MR]}]g s$p6Mmo88 g*O9{x\tcO_3yJ\Ҷk[D[_#`P\@IOSIB7R[+}ZTRyw{*QDt߂$ow<&0u' q,§:nzEԭt:KR_AEodn=s`ROK+8DjEZSv~Zk\r6 ")q2:hcEѰ$F:jb>QJqiW5&ԭY.Hz,=kh:0&!r٢A4_/ܬ?T{JF8_޵Ljp4Sn]ܪd+:O& ޏb &W|Iu}N׋ct-WhO0?tg3K]?Z[4 ]Y=c/*ՕLUiTKo<|ljPO /REՆt'u=qVG=H9D0%5nWo6I7 nA7ey"GZoC3.Og:piRxmܮdT '8pl_c#g?iZ<=g^6IQ,logwF1|i.OMO{/yI{|W=Xv|A}$ u s(H~1}N84k޽Ը֧ݯ}!kًOsvH$`?o5Ύҧo5O_&qѯMΌkj niqV/g!,k*v?9;9W#S7NWSSQֿyџ?-E㯆IhZ?'yJF_ SUe~GfOET 6ހq׃k˔i:um~{44X#6en7#@z<r.\&\G+N N$T7]_=rH`cFsjʴi{%N?.3:/Scg'c|=?iX_N|Q$"efG#;4R5NNMZ;FiOMc >${6{(+6qПO|<4˖$oAVO(Z>4xF-p+k|m+g(/biYjU.ߩ>yn&2ֱ\J۽NAQֻa}8S{~w} *<[QZ+^/4A~X9;t#9ҽJt+FnpzSZ|zf<⟳%iɚI2רz^m~ǗS7Vr( Ϗvkku2[LTu9 H##c5%R%R-A=tfVQ|4~,7 s4@Wmn12%i7v -t)6UDZ剂i0UM{ZM;5M;R{sB3<-7d`1<}Tp#(=7ӡ׌ӥR++?;0]O‰<'6*y ߀ju{^Վ OgN_V8}\I<;@we{}yiNorZ([B@,źWnnݵy_MW#%ZlҳVo!k3 sO=}I6k꿮BONIY?]nK-χR$ԴU:Ɵǁ*3qIkPO)tvv[=, Pe%w薻mȗ>hskz6^:Mg4,˖GRYpANW8SvZJq2+uK>:>#Eqp=̇kmiY~^$r˕*ғw{̊J{Okȼ?{[|,c=G^q 5/jv5exJiFwM-o>izk}^h}lV`K 'S ;QV>T%jWg/_o.g;KMy08 c^XJm>}i5t3 X*lѱQ+#ãß'f|j}[P1:k2wba'1u\9Uh1@8L$j 3̒ڱuIBSQ?*\ѻzv ƟM6kl:>[0+ @|y>IR+)VbM1MtVKw;1'NxO©[;N׵CepQK2Kr2]֝=zr^[@Ы_j6r*'i=ԥOWn3nXQ4C $}#?mMyӊekf42F{nfw9=D\1h`EmH#7]Nyx:W%z˚Oֲ{t(V0J/mbNO@ =:W-J%C U.xN%md:>Ĝeccy%`Әȑ?)2e~痍rNRJ~H-c`Fʂv=8x*x"UrVZZVn~rG>Y/uTZu&">xb2qⴜ$$F5S}W2KIeGUpOSG\W Jyңm0:_mhןd\I sλFߺN#SثK]V3OQ;'٣]SSzt鹜}j*p5l n,@WxvT %}bW" 93yG*[=l[XJ7k'#UL.N?ק:?Wׅ(Ukߖm/R`,q˔p{J:*nuZeB5bOݳAʏ~\E JեʶCKF-{D p6@T g%~lgQNo28Uk_{3 k' ^{cserB& Zݰk#~9p?utһ_?E:Cp;l+2Qxʔe}liNm}_ Y.߉>Z>v4qWߛv`4v1ʷ ϑ~[U u#݆FwN_wR?y-9cX]ӊXP%I<>DkOy{{ wsڊfuBbiLœ۷T\lmN\U&C HscU*oN PrL pʹ>{g=¶8yVE[ѢI,r9\0O5e+ *O夞t^]t1SЍP- 9+qӽW7tեN64[S67cUF3toҩSsu7sXiVѣ>{߹_X6)ǘ`,r0A +BCu ,p}Ee>{ފtgʺw:*JҎrsE ǟ Dg,6G8~?uF2J5St̞Ъ!U۵cV}LK + h'c†y[KJ3ҖojĖ-ǩ=S jOIcw7_cn|pp1q]NJrNڝnom}[\I C ?ZV.i&%DM3*=rj*BU%7f $GeE_0m~~uR]M1cZv[J\qOUGRS\˺&[%fO`\xD'41_+r z$ Į92q[_Km/)F<֭Owx4.򬫏% eӎ"7uuTnv1e#ֺBxi$S+Tdܿ_7+MHӔՂ?m7SDX-*¯^,W,6Di8iuasrF*60I8l=z֔slezQc۴rǨ+1yt.{sh+Rnteacau9vM? |-vNyȍ"®889L)F4mNΌ_2y-KvY%`vsןQۏ,i}G˚M+잮Elw A|9yJ=T]BVw22MYYw .A=shm}!NnﯧH7#fY|yyNgtϚ }FaĜ(S]m{QpעZ6Gwmeo|ٹޱ|dǟǹy~m|:"w.CβIN֍)$y⧌u?";EK#$r6.sw#gN>+~FO0v" ƪA]΀8޵UK#__ЂF˚3ùG>GM$1tlejYR[YcVݻߧ?Sr}ȥS;۠\Bim_/r\g>zZ*ҎMǕ$gfh)&37(=?c:4Ξ"4- Hr@.V&9g%}9I{)أ6<2qM:uu.5*JH"eRy1$qq]ʹtJݟyiwv֬m:L~IS+[sF׻+_\,m/FQٻE_*Pk5Y{}]`%=og^yNZƌps\ d%>qJ~;N5)?s43nWUJƌ2:vDVtk9>w{-fml(oXn?Jq[4CUӽHΉojTUR'sTm\K\2̪ӓZpL)ZX&ұJZu1EHI6o |zi읙._>eՂVt岹sЕ(ƘeVgF\W#C2*ߎ}JRUnŅҾ 3aʫ}x?ct9h,W閖BC3aug+#nHJ;-[i1|Q,D+{FyVbA \:YEQ9's#=ÎۅOc ".Rv98H4^\IJ33{KFVTyݴӡawnVמTn{1Q* 7l0epGOQ]3^sGN&gf8PʄBW,G;@?J\Ϧ~΍nIQ1#(Ӂu*ŵJ1*2}/wFˍ~+9Ƣr۫7xya;7ђABm,7.=w|*JMy\7{4mr4l#隸xzéi?4KdgkRv Q mRpqN{~Lѵ:4GnsrV,D l:nB x_mԦQ#u)>s,6I%zhӶB123\"fG/V{tpoR]/Iopfv¯HM$rJ1Oԑ'm=VZws]geJ;.@IBƘY#$UUG(h[^F0I76=T~}x1cxx<\i-#31;Bj={ʳ)7kk}Miԭ( }0fl*6J|2Cnu.UN6ݐJۅdlg=U(l//̛LkKgy?5nUVשi"*~fP6( ZiN6JtkgtQj c;:1tus$WS>{C*\ ;;dcJqTZmsK~e_m%C0%w9F6oOR)4Ȕ`ʬF?>3%ƒoQԽIyyM 5flfR?8Msj*#G\הR<`QvzN"/hFP__%ND*QIОqȳio!kb| +1i[Vgc)[euǁ$\f+9[B涫rMmkTt jǎc.5j7(Z5q'<>U 1IT4r^3@=O*5%W9jGWJgx6/R4٧kCgr;`u?OjJ4#˕J*ӹUx#; F q 軘ӍE7{ӎD2O<m=Hzb{M[T~/"eހ9_W3uBeN**kI-/лm;o0, ZJtO^&4kk-䬄GヂFs1^WTkrkѨAy>[Y/]=?~jpeͱvի#/O%լ{#4>d |KOG3U+7H(E*ApkiYCf})1}?>xYt\֌`r'P}8+?ivvigٳ +nVMzGS[]4gqvͰ}sVu1k_rz4u~>𞝭ƽy2bKy]`T:z?`WyhtW(~M#GzRHOYX֋R}5ibΕgjχhC⯈ͨ3,mXclsy׆s5aztrދ~ZLsX] }n˒L360,p ԏpY+-։.7]9,fe%I-"m/4^l{4_n/ ۘ~I0=|Fu+sn[c24e+Eyw;M֥ef+1;8'Ж1pê|1yxEKNuIRKYk7Y62(F<:g0eJ_rf<.Hrmo9]ɫ_I]cAksӃ39+8rF{6 1Wnt֣O}!q/ Oc8t'sɏ6_mZ5eQCCoGЂ=kөnߏ\EF_f.WlVb*8>^7&&eRc7w&j/<9A +.lWu?r&5+RiV 5 Hˁpӓ+ ҊeR;9jw32" u'ԖLӒZGxSVkI Qz{a*q|sڣ:S+{;_,v]Jͻ-w/>ZUGZ3/Oɞe9SpjөnÑ-N*nAD) qZ:Qڤik6g[5wUhD%*vN6sG쩫=.]v}rZ8^Lׯm<|qn5cK[|<ӵVEɳl[Zc,{9t\QnW+z-캕)ַe~'h<>WH$ d]nSqxE|:Jum. ti>WQAekkok \M]@e' z;(Bj?cf+tZ1MwfCnX\x9Up18V孒w3(ӓpx$K(ec,lr7cb-(ͥQiuE 3:Mޫmr\mPn " vEF]|[*{3V]nkK2a#~Sd?ַzUl1^[ՐEIϑκeF&/MZCxCB$21ˑWj~^N1چ(|.J oZVQq"Xv8翥}i\:VٹFV~fqkϹ̓q9b1 WoݎGUʟ/֏I@XZV(YءqNXz VTVTַ}Z] ҵhf6!5uO 4rH*nRqz-p[7!FkN\}j71č_SBdu楇Fߨ\n;AWʤyTճ2}

    o^+eͫ_aP*ů-; DlڻaeFq{g]~'5VeFb;B27$sʭEһQsOMEX|Bbio>ҨLj %9g!gk d.bıwkObJF=mt6\j[c_/A!kXoQӯSuo][(ޭ]e| 9qZcGFULGE-=p2E8LWl+2}V,Dy[Q!Դ1avm;H7?:NZmQ._h26t+*jQisM5`ڳ$VJ{\?KRD'˴ Fz^\ɵs9TIZqd'MvpO|W\OTNiS[/.>+̆f¨m@p'׷ӏO4UwODt=([i56yn$vq@#繯>)FhQT=;^|HkŔe 2)ێQ편^=l\n>5>|#H^txx1OOC|H}e Ch8XnI#d||t\SM)+;[O̵q( $Kʰ x:VZ,Kzz`pq厯KLq>{Ⱦf@=85dՠ>Y:UHFcuxhv>e@<3+:SB4rqC$QGw0{ױr!(s5/#X哔d_xEfD;3Ӝw*>RsۢN*uC[vY3,sw=}{~]x<#Q8<5Zmeysާ#N P~PH ?_L}_ƍN6^VR6vw t]/M/˱G>ϱݷsm p)N[8JZ):i<0˒8d1uMRNz{}Vь^LeozTVZFW#x4%^`}hTmc:/e^gr|1}u%e~b(YV`.4Fɩ A#h'3o^3婇eF2qs|yd4*sty#>)%}IܤE[8B/m5- u_,eݑNGJ5t8jFJ<.Gnݎ/UgfV5czc9'˚Zt/oF);[eWi"+4ʲ[.'9J5M]Oƚ"Foqޜ-*јӿbwM4Hx~ 8єK^ș⾯FP;:YapFJ\˪'N2wWR dȓl^y8#4\m 2快"Ǿ6`F7º=b*)FrQ> c» *UNr?bQ?b[-2W'9#9ETĺd^DZL$eS.0A?J#7>j~+yfhƥ=3NߝkgU*8[7o2+k<͕W;TG==rj=waʭ4b,p&S#c]~^FNsNfɠxM#ۚ#YktYMϗjnjW+zR8 KӼp|ztQg-Ɣ*4E"P~VsSw+teh=Lumtod㞧֪^iXZU*wjy+MY2Nx~FִUU pX6ѴFA¹jry\Y{6ub}:9TNݫ?iD5F*ՑA*\]Ưpď?1pxұRԴvzQ%h_r-etTa۲9xksF"ٞeiƔTm-KM΅1pN6}wꨭ9ӔfO84m۾n$dޕjV+(o|"X }-{J*W4䅚Q~[yܗJtyRv c|s1~U_PV\̂)ܸnzҢfe(jVK}} ڪ`#=~͈I;~-_-6P"g\G?qu)קJьQY)!\-|=S d!z2|gs'τ,1Ǽ=Gb^ZnJ.W+_Rżg\ebSc1{V>U*E[,W/2I]6ʶjd7,Xr3cխZF6yXhQ-׫M-0HB 1 _¦1mϱVԥBE6%K3O 18qrJӶ5ΝITk˸n'qk"f9 g5˭i)J-| 䜥Mg.VL8깧TjSi 0 QfU70=҈^4h¤{^%ՉT( fnp~Jڝ9Jҗݸ#&[Orrt8㝼.%qqqܞ-ҌfۭE'̬c`\z+'4d/,7 =_)EԷw}7=_>-K ֑WlqJ>Vihkv:5=J6E8׊Z>]nnXV+G4Dq])=?NݪuQJql MF QE0m#:z]e*яeRds:n *L3nޣޜi:N3$vifOAǡVFUKF+NݚWltqjFюthԣ/u7&95]Bp{jiFOu]5SUleCk2s*EHrfd`mzGIsNX:[v+Ier-_Oݔq\"ƴ^t:Ȋ)Qqn9;Wխ#Y&gEYW`zOZsF:nˡG5%ԆKvHQ> 0:޵FQEV%S:34p",/o`qVGVOgf輟|ЫH rPxU& B˹qFqXJL"4kN) 2ˌBݷ?lq]c(˗vc3-D#;:xq[lLIE8=>G27vM2_'=OVua¥F3QIIpdc=v;b.k5?Af;ҏ,eo4d˜8\*n(/[xع#Zӟ5PԮ.R]}eGZ]^4I߀P{q] Pz64aX`p[7_^o}Wl޲K;c:%v͹WnҲ&%T{HԽefBd9 `jʞAJѵUa-7Uԗ+fqrEmbM~_c׸*qٷw)JvQ֭F2ؖi? Uae;t&{i.7/Q\˫R#˽ːG4R no,n.ycJѺ1kr2B ׍ʏ8$v559:qii6sēѻ, ʌ1ĀǹUYrtuYF՝Ս|I.ӷ;Ojގ"2ޫk%iYz>XcIwm_$)ʥ8}GlTHM<#5NIGbcJ4b꿵-h$n,Nzo[S*t#. n̸\l;Ezקng漂mXd|1XS3tFn1;nɗČV2 pO^x~\zRK'ݷmU\LUhJUnC{zoO1QfmR`V\r}t_42 ?tP\]^{Z.kZRj^Y/!V;/Tnsǿ?m)J+٧f~u Đ{68tQkXM1JNm=ы3yEcm\yz3+5Sw*҇}\~k>7"3zcg=R+b):o>,)yn Y?1}8*%{JpKfw#2hH^9ڹGGdyGD+K[ܭX g8?󥉩:6iGJ*M mVLXeO9;*+)G}qSQn]R;X6ݹr{ck'VDUYqgoZ(()Fm z^K7f#1ZƤ+3JtjVV4 en`ʿ2{+(;/t8cxyIY}Ч_,be 0Bsڹj9/zLu9pF -ϼ(P4(qn3pRu*tdE%UOm5ݜ3Y*K`NU?qa#2E\D}uiZ]^F!jd`e*8猁IѦ}=nyx9Ud˹VG{/v>as4#mr1|gvy)Z'+ь%&kdldg5Z)^C/[tυ̼z=&:#'*wCu-eh#dr6ѩ}+J'v'>ߑE_7˪0Mgqsں}&KL"*/ YDhLYUPr8'8_ZU4:5o,ona¢1i}%RPw]74ͅL{NhztYTz޿X[ʵd?3snPsӏZQMniZ~:_C$iY"wd`^V;.bZތh]KojpH6Мt0\5;k}sP廽sBZ­)B5i49d хcI(#.ܑNqӁ҄({ )8rOmZK(V(oHe>?(Tp?\j~ϗx:M?RVMH$#j.1ᴂN8F2vw맗U28ѕ_z=DxS W9).Ҭh?1`Bx*ӕ_+ FҢKx+:H]O"[ @0 éÕߛ~z|N6imt맕mzE֏˔)%Xʶ~N >rVTVm'Y}:/oaU@з pA뎽pkzبWvj`Nֽ=KCM{5kVŹU%r8,.{t\TFYVՒ)YE4ҮK,36{Z{7)&:~+fՓ_q,'KżIvpTg#TYG޻K3Z7rZj]!XcUv^1pWjAqŎRIWYʟ-ז |h-b:Hҳ0Y@%As9|[v1je߿|CL346v ' TƌJ GKl߹o丵6uцLnQ@ zQ×6ϙ8=:=x%yZ"a7<Ypn6I\b L+Kˡym,M4WqeSM+Ya,3T^/zuqŤl%4g*z>eSۣq JRV~ ]Úbs]Y^g(Kr~~FЧxgko?0%FI=kWtw2*,r>!Y >n&d$R~/Թ9kT (CZ+?o %,C2*9Q<^`e=]φ#FE %`|`~aF3mN/ڻJm)KC/_!F7$U [rAg RV0N<[W熮D1$m_AN6Kuͩ* 5([V[gyXWl11{Tx7Ή8pz_挞GV'eaeϭsԚ3ўLU-d6X;[ý`ǰ\Nݼ;kb=YiK[8 4K2woUZk-/J{O*dRv0]Maկ-=<3 V8QOB>"NɉB#ߞuS|4hC䬾#%6iHۥ,i8O qn+*1gK Bwc4m:]3Iu!g,NwCr1q q1on{FzGÝmD4h ez6`eHHӁ1*tpv:帋%M[M#5៌t?<;o"Z[xGǿ;GfI-oh,yL %LPɅvGcN{{j2t=Sx*JwVd| J=͉7EnɶVIcԀ#{tqЬ,To_/H?ew]o|tǯPG\X##O MFn䬭*gx]jS/"|&TiYXs'=pNp1R1a=]_WqXU▍//Y\XDZ2Y'_H6܃\qG˥EwgFE)ja^Xo[,xHf|r' =xܪQ{ CEӦ\wMp8X|*VlFV._O#ZfM?|dw* RQ޾G*]ny5[GN/Dge SZQU#+f{dz]X`Uմ%U,F#5^[ejڌm@]kJ(EZqTiZ'wQ־RjMGN&#R}˛aXO͚*Ti݊ՍܫP6'J]-KA}~.kݦyג\ٲyRə$8U%$t}_7)+W8ZFb֪Teyhg/fj+&;H~}=g(sX!LpMjiRW^{tTu5ڄsAj3崛K}=x^,E5'uJ"qؼ#[M rYUFQ/v9SZjwZg6 V 佸@f3WhG cEW֣M8v.l3q*{ש=zcZtibg14lw =kZJZkt:ڔQS'CknBːzz/g/y]-MRq mz:ß7u%o$ 69=;`cuZU `QdQ]v{mChr ,)`0̤qϱ(ʵimw4aR\ɥ5+jk-NX,@fӀs<ɜ'{M_Vu_u/9OjXjƚ3Q.zG${]mSiпmաYwd[>6k4FG-d-_9)v}:kӱ Gt[SՖ ُb38 jձ0}~||l -3:=c ;[]ܤ=}9kxt۟SEL=9M߷/|;};LӯV҄` 6aOP 0r2k'VJ%d᱅LM Suj4KտOKk6/,dqsq1r$ :b񘯫0MYzuc3Zxz|f䏰xVi (~Pr};t_~߱3DgȅKf؄qڦ2kKH .U/pÓ|RCrUvnH=kNeۤm{2J-]6YQsjb\e)j '|zp{g{C,]:<~ʥ#v#)̞gi7q=*HGd)Tg3R{k9E> A'Ue*i3P"Hsla9ڳ{R%0/'q|s=}vS{kN%E7opf1fa2d⺥[hKNQOM_eT"s=9>J驭>GMOWӿ!HKy&ei$\lt}V*z)/Rdn-?`9ⵌyjZ[dty!?CVU:ҕD&, S)V{61"{zqZ_:~as 0͍-'Xve{(ߛ̧o%Vy+UФ˖ۙ]] Ot6EcӌWvؖ(i2ƅ2pRp:tRmD5(nːCGS-$8b!C2TjJmb-nxm>4q6`&0=ʸyl>ѫQTuc^G;oit[O0r99kXhgߩN8IJ'rK2W xN3LIV*_s1$գ0YƲ|B>eqӥvcjqkKhIko bw3I®Or ^Qw"Lzgm>(UaIpAzAŠ)M_82dۺWw|L,t뀾[HdvrpԔ[~gJv^tz]1i6̪4hO98w֢e5ŇPX* p@piۿ;'Ɔ'B!""$- =yQ'uGH$U\,+nOSߜ0*R< /[Ie@F3#O}xRY((_Ɔf!ymG˓R1SmE7.;;З~"v02(q+y;tǕ_MMiЌeg&d~P>>sޕj3)Ri>iB#I y#ӌ&QBMr",ڝGv?YI{Gg9TRp)\N|߈Oq,<00ss[HݣjJklbjӓk0c?mqVK&sr[JFImNQC=y%r &?/,y23WӞ*JH9*jtyUyJPKcɒݙIlqqTgNtWv9;vhfyc^SZt:9֯R˓w骊)Lj* rmol^K }?zt%RpQɽzv׋lg?޽ |WsҌi8opi&[CaE]>KshZ)qmnn-(w<~޵J:؊g8/ZDX~RB-J+:rnFT,p HI>mۏ}s끏sЗ<ZFs'{t)J48TzZ""{gԍNwkR=5QEf+FfN**Z59DžNw$' $7oZ5- _241IJWS班y^K%wgRTgY!veǵ6#8#zQsV9 O O=t{Y2YsI>[XsԡjfD%)]Ĝc5U9mm;8qT_wg.$Ehqg۩[ЊԭJ48oԩ4R&^L{oz}u)J535gMTfܟ8G2滓؊e.|kHSS̔Tt{..l[PRv`8qֈӗ73;)Iz$̳H2 ?ʔUSvztDP＋'99 WjJJaJ/GSaa}F8ᾕHAFӜu5ZPn Z]:|m-:j" pʹFg<}\H&δjU[b84mIG?.y祺"h'nciLhv5c~X2Zb{n̷tr_y}pUfнm+αv4©<J52#Fj]MhlPy>bYYCAZuR:^ʤ>2f0'885gگ 11``S0kR捫;(]2f`0No/6ɯ<}(Uvejt(GNIY7Bc [Xnu|izhsiJ7w3-4yH;8=zr7&p>eӱ3Kٜ X^sk˩cq~I= .5܍dO ? yucvq~%GV'Xd,Yz=p>oj(FN2_qʣK G{oFE;۸m݁dxƝZ<Ϳ3.1߷n=k*ȹΝR+C5,̮U'ִSiԩV8eS^vPk-ʃe8U롵jPN/[Xmc8r:s뎵iJMJ6{\ hfW8ۥi^Q1F05on|]vA?UN9G]\L4F՛kiӧEӭ+>[3l6JON1tZN' [Ay"ѯHGNy9;LU.&aXһd;1!1aԌŰ5 Hۆ'?=3֔eNt4SknȇtQ]Yy,Üc8 /kZq~ԥG%OWu5ّdBd8q(N+a9NV{,GZ]<~Y^iU)Fbw+|g~^]/=kUkAEY[{wBHUo1D,:nW!올r:q"ce}7DaW1yt{V} ҿ![͵ ^ҦC)ҧQkAsm%I?#9OT2RwO[2F6".ܞs{{җ2FҧN'(fqof]諷qOzrn^[h]>4ѓRR}߁ Mhb FsqNXyMVxhAsg,3C-Tڮѧ9cw 0ѬY<e:w#.IhFΛq{h4V_:4y8WR yƾ`|,k`qVsE[(/-$G0G1߿"jrTHZVH >Z$^}+uNEGJTnyKe-CYʟ[ARJ[s$F$ܾ`UNk*WRQ'uԑu(m$*v~thb(Ǖ+ym&<O]<=;OGeEU9&$6(8-i+Z;u<ڒ*jr{mk_Mz קV6UvջzcG[7F#XERI{ R)'mќQU&DdRwn2@iQ˙9?Jy%;x㺰*\JJݭ#R[dl0s)ǒ}>۠\i#gʜԍK͕9VTyuQ4}I$ 䏛d*[VJڞ TӚ}+N[?ϥIKFfJKqmn0> @(N/ TNϪePeUwqu~ujJqz"!bZ2V:Tuq nmo'sZ#]W4\ I$۳/Wn3};r"}5}c`جWcj u{!Rصln!Z*;g%4c%j&C$QrcI?j^yRWO$~wm}q;t✜fԅ9TtvB=[d!"`C2)y:v8>7n6g)rIYeDelbA8Lc'S笣5d6V8!FKx ,grq㑞jӷx~ZsN6oo?Ee*zJ{.W)%!#>rGR_̅06˅ F89$*mY,y0Lϖ_/*si%I(ᴖ-of8V@9׻MMΤh#bb$Pۊvǐk9JѾ[{7?MSYYp;>W}eti1rK_/R ;%ӏCeeSp2gd'kP3\5,?Vc7z&e+kx[e!^I$?iNW~ԭN2Ӂv6I>i3ڱޕBaލbեy*GH~~H~NnߗՈ+?wܭyevDkQg̏`6真?kXVeʝLJܵ6e]Fb(wuǯzo9m鬽8fͧ;2:zg4|V-x%YTTed)zpj #o|q 8TI'4)Sg|zkrVN0sz܌2Ye<*ԓ҉WaG(Cb3-ݴ`TӚ3N["@ƭ&RzUSmǠaQRН7;+/cCsh9J[ tJ$eYדJi1)F[Ў ;Ehr^pYEsԌmKFfecv޾ԴgF Ӗ@:URNzԭ-t r6nV'ҳc.I^q!ee qUJjE\kd]m#U?6ݠdd?J){FBiXħoFdӜݩF^EIN\VG9U^;{8ԷSF2?yח+QZ4;6lM'ٝqa;NSu*]s%m Hv::WU;X)B.:Yt:,1-!woOjJ̼U81tK/5B mǘ o<ItF1ġ{w$$f-ee;p|iG5ApKzF sN9,e59:q(0 H&^ clr;f)Ƥ˩)UJJ-;%+mD89jcKkY>e3!O<"<`cU'-7BL׹39v[kN/ʝkqAULQ@ss]Wњ֯GMs>fIo^RB-݂ͻr>Q]jJ`Q'5}>~ayaV`nI?/^:۰涅5ˮUJRw["a#ː1*[lt׊贜 1q 罴d$eu90tFI_KkZ#*my]4il*}pwz; qu7RqbG=u7ݳ; &:smIK]u$ߵ*k#(Tf}z[BS}-e?e㻦8XʌjyJ:t+ۨ7kyJ{9ݻ'<9lEF1i|[Kiޟ3RTƾDrr}ozjMTcFM=Ynx͎%>Q~xҼQ~GQh6tR '!m*;s'7}tг8+ A5b/RQMKhi߷a$EyfU# :_rWQ>eӕ:peZi#,]?gnRjߙ!h+m%;b7Bcyc7=(Fj݋f[vw*ƣ?1]HQM;[d%\l7n AyZ(N^o)ӌF}xFUX`}vKJ!rW3輏hV|CuiQ O[t?8w0ST&e|E**5e~>u{׊4Mib4'mْ馇t~^vønF} KWZ[M UOi>1v1JmY y]1U+Vo[볾=(ʶ2qog+="XWRwgneTABȍRBb_6Sti=^zo݃cc 7ummmVս.rY3W췍 CG9Z*,G?,Z]]y[t=x:j'Nzni}n//d@>޾N5JjmV;?Mxb?,jb$uʞMr/dߝU=Jx7ukiR5߈>3գHUkY iH2e}W+M?_jSR{7}Gٟ{i2}VO]3,cPT@dد̱nu$ TT9sZ]t,wsyGP8׏B2ͽNx&{۷c7+Y$gdUUUd  u{fQG{z7mS|%.t=2Q#WAg<dg<{qISƢIwߣ|?UԮn3o jZ|rjI12\mד|}jy==.| IR/g^n5Sf#3Ȼ|ș csyA>ykA[yu+J3It}7㶙orLv 2~1?\}ݗmVyV9x_J,ϗ. "cFiƍKWk&˘PuJ*MEI+y+I.W5 -HTR$~w}/ Q8oy/$dem#1܌}GaEvѣSh$ 2<Տ2fh9>N;xy$WoJ+;ϭ;cmzxV$lq_|P|6T)9={׹Su}k3P;+Gz}߀V rSF,8V$X'K?aD{u>~N GkxV\<*:ؤC#n [Yu+/zm!䀽Aܯv G)yJ7oax| 7ni&՛Vt׼ ChWojc?$)( z`g <‹)զ]>8ʟ*zOsT!5MR1݂9OA\U0U+ZߑOF5=əJf)Woy!TcҰdo/]GȋZq͵Pg 0yKStkyq٘r:ӗe_-[O^9EzP;hs*xXa̞ۭ˖v+YIlU]qߞxڿmVFd6襒+0G~{Һ#M''qVY(--lk0Zfm0)'7VԩԺqCRc=ֶ~Z/mSӑ/?$u{duvtWn絖7zzۧۍ^7c#71=99Ϸmahͻ8v:+;Ɛƭ#,?(9 zҼXb,LU[M48iQQ&!Uh=:c^\y..Ii}ok~/cH]kHAFZWI5oRƕ;bI**'ŽN =;V4ާ R\#N鶇Ax*m'Qyʶ\9Hֺ5oBΥreϷz-=wRZ *i%,|FJg{sTҍ;ncxF3FFYe;YG^zt^N:4RJݣ."~fĆNXRy*X+EJf}7zyIӀw98ʵ\ j'bSK϶էd<$c׮:V~/_촽Nzɶre0[s 1Hҫ=W>6^ӭosZc6s^4Lƒ0 e~`}zJ1i^NݟmU`?ſ'.G3`%5$2*MY?ǯRj兦8Y|dA&NIeg־K2G\,{[RS>i&C~&|f|Ka~m`gC<|U+JUnՖtai;4֏}OpvVFާh8Qq={z ]I%=MsFuHÖqN1=K]O˻JjVѝt~n2 Oݻ3:딩_7`sC/~8>PSόgN=Wh4(U$]ڴ^Z_CI֟:Z.-eSn>V})G(oE.J5ս NREk$o3z*OsF*VWc[#&h]¢2k)ۙ]JTgh f]ێxDyl~']j;ol/lW*1RMiuN>1W[v.ZibV]dM:ZU9kد6n%eeUnBޝӒvQXtgO݊~}+]=WpRj+%f9xYQ%}zwL|1ᨄK^y36繧W7-XRV]E|>z/2qNH5TBNg6*HM_yiӴdpZO;r㧿kqI# tN3tX3jѫXxRT|>?Vo/˷Àt ^h4n|bJޭ6qmro*b\ra"1eRnP̊M"^*脏o PRFPqxw fۏS=}O|'4r5/& $;i,g'=(Kȷ1,c|wtYUuckB)bICnd9Q}838v9G.&|嘆=8UnU/[CNdf|Xn}G漚/_*N4׳V^zm{ "r>wi*:}ןC_7Nx[c#NW^6r7FO5R4im7ŋդw '?=8Rc -dVIHf 9=1*xٝ~oien[rbcҦ2Z_):?b?-ftrK6Q몌ZRt}OlVUmL1'{Q(ԣ-ufoa)M2hI$h<סֺiIJU#l\:3:K4r6w֮68bmκ'Ȕċ d##خ|-[V*VRZaFGnݫK<*Ikm>譣yzڻ#>oteMqW_qn7!r^T^h&"Z)Mž# +psnҪUSXҜ(F*W~e#3ұ(ӗ_5~P9fݟBSXø{aQJk[M#rN+-EftZO]Z"{][sz t0K<hhH|d=ݎhܳWVbTҼ$3ٗYG++kMj. R &~|99E~Kͥn=ŸI/˅O<9#ޡ<ܶF&3O-Kg%[#7>nwmܿʆV{ye<|<^ϖ2_3 8T"KM/m$y TI9iNև%hCsvgV^~I+?S+.qj[:$k"ބLp?*Ryc!TS5eܴJ򴱏*8ЅcNz%KDZX[m:vnsv鳴}}8T-p}/І[[bI-4\ccSITti֕.Y[Un̒3%tڲ0<ߎ񢤩ӞNNU14cRVKr>b}{Z#yA:МD:jjޟcfFa[=^/ieF>3rS۫#Q4VÎ)VNRQmBn]KB?$l,F^䎽zow6V^CIlArTzV~qPٲ8SՆΦ6c˻ ߺ׽t7Z0}Qr#+ 0JNIE7x~]]nFaVun2x R:UNVc- )NҿFu )R߾-zm>OtTN23:Fo1#ڰ?2 9޹yfzѩ*vM駞V[Kcl3Hm%rz9=+JiƦj>#1\h$C ;޳VI=wSV!SI+9XaXmlFۈa(ܚ~\䎙b)P)k}̒nun:oN{s/hR)UuM4cgi0ژ`Nqg߽g+⢬sak(Aul,!2a=0z/CщdnFkqw>ՎnG\qZ>ҚjFcIKZܴm.`NtF~'NOP[+R2j㎇ߠ5~qn-:xIT]$층0~QۚҌgZm1R$O̻UɁI#](t/iN6$U,P$yuQMʜBי]i`}M)NW4*DvppOtap;Ȫ%Rz1[ǙvAgʀNGT?E]J,pc-֎2&֍~'E:E*jlUJЍԓ~yJ[ȱ #;Jʫ:m}>jZ'(]Z[kB;e/zkUzҭv~>g<͘Ӝ9ԋ-15"r·̤gq~Rk%f/JJ0daAjQ=*c̚ZdSJy뷓1n^9r^uS=,ŻSO2 oR ssD o;v7uZ2EcSfSI/z͝.J : j!Wc==+:ʕ8|b/ه݂:B@8 >C!9ҴRNFG'+"вݭk9Iݘݹ54iJAs"RkeQntb)>B6Kۘ*\W)9S:~F->Wew|޹ӻv.e:jR^[KFlVҨxJN[&eS4}5i+v:h֨2+K͟ sR]J= Pt­oҦ.16g^/CWO.Wk/)^/H-Eyyu?QJyTMoAp Ijw8tmzRr҈hKۆG!KHrVYYn_n>{ ʬqJ*cʭoA@i&JORT̴{XiSd'no_!޻#R2ݕk'einrgf?λ]屄jTtTm{}kR:ƾZ0(<p3'3>hJ3{5[[XyCgyq+Nt׹1'u%vL x>5ԪԝḘqMƥU)EirZȤF*sӡ~7{{Xԍ=OB3nIN+:ʒmM{\KfG:yz2QɭUs _yP+{Z]46q?wc)ӔN^ݙ7%֑!MΪO;Iqyy)Z2)Ohb3y2"l[-=k.^h:(O]y7v]\ҷ&2^z28lTUU FXqr(U//?_Sتqw?5m(i X} Ts1޺#?i$2iV寙^ZUlf35\SM%N2~ޙzDmyINgX=SQ7nc8Clt9}rnC,ʪr8'k2zJ %Yc̋/"{ZSOu2n6H˷n#8XݹUJ?i4U&d&2+:u=tTUK=zب[ŭ|Ο:M֯.&e3o dqc^}OY|qp_lT[Eii<FUx͐s< Ƶ۵MYz|ZՖ=^KyǓw"Cq"kdNӣSFIzkG FUQE=ݴߙ~ڬh݈$^A9S_f/Mb5)ШM-ycӬGk-9)ԩzzdJyu2].-˞V*4ee{0J{ڽ:Ԇ:;]d~|v]Y9?PxjΪ_VQ$6xjIaiJkXڦ8NIl/GK8],v1V{Y%dٜcSFݍ͊N4VA[əWa%F1nўdq6cQƍ%RIuܱe ܷ0IdmyF^h ۨW5VڈʗO x5r(W؏mӍi+). K_5Lv[&qA$=z]㾝pSj1{_S=$h#Y_p/`+NWR6_k|ܳ UJ͹'},¶nkv, m͎䞣j`'>^~FU+u;XR,L͸c=vԫ}^"\֦xԞY.S9Pʄ =3?o#ңg7oGii"+ -yN=뒦ac6޽nII'.ftdTϜ6;S'#[32XjzCK6Y䎤cA%K/<\:j|PjP4# cq8{B>=]4;FÜ# WU*Mܩ5|+m 3ܸzWMe.5{u0o1цbg`]I~^+ǩ*ϛ=x:ԣx+ԭ3 |goo [YD iHf>Tjx.lg5{3JYJOW~̓R1ͰA ㌃=֌t-S֥>jJQz/cإ[eEo.Xʳ}x*tv.ӡᆧE]߭V}tR3篦)aʲ*14OibkaZhv 2)Bg>T^^"Xҋ K^fB;f+*?FLEkT緗tSrRKK_xau kK}R27?98 Ns+[*}\~nkc%S*4RV;][wqUM#cقcnG%}:z<-kvZsiJ^Vktk ln |![ tF6xpIOkأ|棛Iqi_C]FdRfi#x\okC4R4vZnMRT7;$lK˞s'=v̬V*uF]G+|{yPW`V 䎟nUjj%~[ SM'꟡wMGik S΃  l+ Zu(Ɣ얯02~Y쟧?g-^Kc@&Bx 8Շ:W~oKks匏-rI _-OȠrqy5Z?WE֏:)^iurm ҆1&y"kRJsթԹ}qҗC {׏RW=Jr/zibt'٫XFpz|q58ǚJM qwu(ܜSGq+2|5*m:>͇jE9t .G۱TǙ{CR:ʎyJ2UBڦ6P}Y&Ĉ|ۗa*Tм=8ԲӧSw@צԭxcH?ϵMjU(E#j=K>#ח_XɽR6$\Jp]\8Wn>#[y+elo 1\c'$dRor _k_MIޚ^36ė 5ƞfUmaЁq׸ze s/}^)(Qjx##f#H\J Jed}l%)&gciBܬ4ôJ!}N۟2f8l{7sͫ*QZ[U?I [GӼ)oo.Dk`%A8=sֿ81vn4{J_4t1Iy+,B86ЬFsIיTQş;N'}Dݠe*z?{xnfRvt^e'seܠqQ'TΨkE[0Q3fYO<4TF/}ݭJoef2=x88~ksj?Xi3u/JZZ6e Sz>UM؛ o͑vZyc)RS|;̍W\>|>G0VL񾵇X毋>QZ/ M#feLVqЩ$e(T\~lMn+1Vl1xy+WxFhK=ZDmc+T;2;OtS}=Xuv9ffe]C墀c_ֶoݦÚݴF)Vy1`FjQ8c{:6q: :͈yJ-]>BXÎ:U ]u8z|{꺯#z&Evpx`aqQκ8]+ 1Mw1Գ,d0ڽr[35iղw,nrG5zf*;w'k5v%k[VqlUIǚRE$xm"[X;K|BSMܴQ9&.b|g' zrOZs扌(˛l3T۠˶j.<$g۩\I*2QFgG'ܑ{'$pWJ8r$+X -ovǜ=%9y5TZ3Ot5+yڍ,AyaN5+?O.QmMkCĒX޳Z§?)] Nէ5)0{ۡys m.$*?P2@}OtRJoz+[-Nia$%"Ĭ+zrN{We*tR} +S\/Nοᗇ.SPf%B@sOrLS2j <}y'=/MeX?\g%<=6o#ưY F;Yd2>νt59x|'cHbUN2tqvoȺrJr JVV`#lgZjGeeM\/Focڧ?l89TVڏ4Tw:%\"g&0@ d{sKet=#tNՕr'JnJJe̥}O&Yx U<ɣۻN;Wt}7K{}iqvo~Yhvdi˒+1lq'LC>ߛӡԕ%]:t'վ D4;MaR53<|jyZ[ۧW,N W]=oMj{YUm\&oݍg#`=1ΒyTekЎW\Мy a`,k˴ԎsWe3|Vi^l{nǒ}svߚ?m$sϧZ+/EcŤw fWP͒RHspzFRۮ1ԕH-G^kmF3Wf2NܞNBסGN>_zpڪzno*0 fv>V+u`ϳ[u7rʭ EHdܪ+#8#2+:wKwmLZKwMMKO8)yy#.CHyX䜐 CY^)hw0Ό"_k4Ur c8$rB<׻SV}?WZOgP:lLeխ+^=E(~KYZF8NXW[{J84vMgIUʾ);ؚTmryW!B#< d̕TsGxHJ.Ծ`&霞G^^"^#íR2սz2EsFOOQƸuqJ]k=6Hč^XcQR:xLj4u|H Oʹaw8ϱ:ߧB~9RۡS@p|TqQѬ{FiMD^Kuy[J> c# 6:dת3S6,GvBƇuiZkjU)>nfʸf>W1\YIA ,hc͠Zy0Xmm=Jl㧩{4gڴkc|ŰXR1SmijtENTjJ~&M眎L[w\cN424}vvH!`Lc-%jG#5V/ -c?BFRӯq(VWz?vS?wsRXuNv,6`Hu]yJt%dJ(dg7eQ*rNIyTUIZ.5 UpPI^yB\[3\ceMNʐ>gˮԜhvܫ$XQ |7MN%mxTUۡW]WFJ3^\V?Lodʸ.S 8R˯y򨥈RS߇hfӏ/֯'~YiN&+$HwW-IjQ,snu~{KreL.p$cӚDdȻ._k~_O2:dgdf n=J8oesF)FQ fZy4kiI6ezH8(-7AƲȵrw@=}Vt%;2*%dXfJvJ>ڤ^.rZcnk%{BI"f}ʮzgSRteR|kۋ>(O˸pVR-%)]9[W焠O~vriԟL'+(5Уw:Vfv=޺ckS+٥m|38\ŁWDZ䭇r~niq0uTZwk24b[{vw4C鎜guƧҋ:T?5^cRQL%ҩbu1݁y57i -:Obi {p8b JVHNfo,S3hU71 ?/:܈S99kDzW6"ܻO9NAT>T;BjS_O[R$1@UG3N2M[ zN<\L8:W,d^3Ky-F[x {Zc 5SY4ԑ  Q~xT䍣H^ U$NOIFa8*fc+{=cSA;%a &v#m~`sO~Uefjb(Xh|$\mب g;$*Q[by,qשT[*i%ܑ5ml g5ʩgOkQu&t 㓠q¸jK\ҭy;ī3y1¼_]5i"swN<0U$zc+V<\TqsI&8g,Si6MǨԥSnO_*]+n]0] }>\/׮?fQ'hj2ܳ1|-spz1䖎qF2=R/-m+l\ҩS Ա\W6{it2ߟ^|T%(|=J1쯥۸\)wr~@:B -74*T5YxJ?9ZyQ@^_ڑ)["QiuӅFעZiq h[24$!Q sk5*E$uTe'V jp) yd,G u!3Ǧ{QR^{HWoocoֈkYU#Oq޶iZOWRZw_IH6"79_Nk 2:l닭]6Y`,#pۂG8RNY?g,{ ie(m܂0w~`Zҫ*ѷvT<gFy\@V(*z"+ߡZFtb,]G7d m[reeS׏_үJegT*G khKt.;,ݴ=?tNЏ<cJRK{:Cq7#¦֒ש~ΊU{uh7*'/C&\j7+5F,HfhOAh9Jju7щ$mKRe ڛK_6c`v#zu%_C8*Mkk\e ҫç9<jҌ)J멮&ZӏĘ4K2L`TҁOR֯.jIvtaXs'cޜ%W9ٮ6y]aV8I#8Ǧ+R=a-SV$l L[qdƹ.Rw%RYY$sɮQ+hva}5ٔAv\_w+j~ϕ驍8rku%ٵyc9?xţ9' ֝gJN3NȬgib,h +c֧N.qmɻk$˵:_wzUQ{-Ι{HRI5vTs3}YJKK ev53Vm|߈sr^O6QKoQ.3qmFZ?J>ҟF1?͹|b959J2ՋiJJtSs>c8)ycy¢U,U%]2̷LPц3׊9#eѝ5/ʯ$dF J,>\m1Oc"3ԩrj&t6X3ЁuƤc(9kU+i6(cT-e9OS9F--o,$.v ~uP'ei-%4B7O-Vn9u5eu\vƪ^xiNrO}(:^V2VVLl ΠzVqqEug"[iZF'$VU`guJrEn6/~5:2ZSVW:\Vv^77Su)BOZ3N[Oe{sELcݵjjB[Ek)Z=5 hw9nOT(Ǟ캲pVsF #>Y`=TI]\|jl2#TL~\)TlمZT˶A[|w =VRIE3v_weԵ QEg1nCA >ͣXFʚ~Z.|-!1-<\ҕݕRRO[t!Xw!`|$b$/R>ѳr+QvCwEJw6X7!\F1#)s/mfKly;l6b;q0Z5$z-!UUVI0cy Np}a>YFMLi+hgě$m?H˕-yܭ.ζ0{~tRW+F:j#B"\ѩRW458RZ\$hX+1= ))_EIAva g^?jJZӾˤmuV+eFtz2kXsn*O3:Όi6ڴ(CnlB]oTQƴRr9Iۣ{((>mtQtY3c{VtS~TAdDpƘ߸)+d>niJG-Nh:HbAZէ4V ayH^1|J^Ԟ 2J̻SO9yܟ\}!Pv nOs;cNji'v_2V,~\w*0d}=*a.f[ʍB =B A.ѝ8Gu(qFTjRQ/bXN2@\򩼬oRhSߐLVbPy})T54[;neKY7HT;9)ԔyR5#NGmd:-VbG?쁎U+-Lc:RIvyzHF7eqަ\kԩ$tIS/M72#:|㖅ЯZoԐUH=jwKYʐRZk-bUH) eIS6#V">._XZWDppA <Nָݷ~,e 9Z(E${ti-J(4ӗa|% ]V/0d}tTtCsԧ]Gr/πO͞WOV}:2û]]QxшDTy #Os:qEe9JUgPԛuyߞ;SqUnXJ?'$l,Lλ86O#>VSvӭoc{k{ܲ0X*F{5RVeR>n5umyarrp?ZQ4^筥ٮOqǯ`kg/icvoK(ffYFHNrl{8w8(| qJ)^ڼb+6AƱlOqhl_ բy~ ڢKjR18qXʝIꉩ[Rl7*PM1;r;}汕9\[ԭ*{P[۝JBd}}+:+E-F֊ rvqڄ\*EqŸuRBNtΌeufx^ҽr펲\R΋8q\K+5ԩUR$FՏDOp7-b?WyS{Y^ A+qo'¡[!FNG^9)ӽGsRPjN H;\i*.ݜ38kOݩeF"*Qd734Lp<a JiGS Խouj~^EC8}Nqib89EYaMүXTxQem2jG_8Vp4kI%]8# ~eZt{\nm?ESQ}<}'uޭ«SdrՄIX}RQWL\VJ7:J4sB7o! !, zvVѕZ:zMܖUcYd;v{dc)TJZ#p\M5~h: Qv受c]*\eNoBk6A&\F`{zkjoN;]ۻ AǖU?Z#&VfxF2MiK{UW}й/2(vvT}.zRzF.iuf匝2 .cH#BX/< Mчqѧ$[!G(BofSIn3r[z5oڬC7˞3~=)U[B>*ںi}ZG̍k C޽=aU]9!j)sZ.p'e=H/[z1yUnèt{'}^5ҚFYrp#qOde{VBwvz-s\-ޤqЏ\ݏ<]v6FU#˧{PϚVܹ^9WUV'~8z5%SG2h8Ԣ_2nYk2ڭ9r5=jxVVlBF+rw6Vr2PGCF+2,N7޿L3 U?qOf37±j4,o2fզ~z21Zo85;|:z|Y=otCu XJNi$ ~2~U?.Va5^]nKFAq2789SNqV[4ԣRMIG[[MFX2ZE (嶰ӽoCɸc˕IѧxjskkkZi!>X\B:G-IӂG4_vl }?1Igo^H=dZqy%W9$`TzXuNW<֩[w_K_K[hw^8ay|'Lx뜌s^mϕ?f+)G;+vm＝:H5R̫!2X34Wnץ;k}ꔽehmGPH2KT+kpHpz6ѧ/$ewok? Jh)6;}GxkKB 2ZF;Q(`u=+YU8=hmսvԯ'-Ya_-<7$9\Qte[i.o]hq$1( 7ec\vAϿx8ZZW>8S+KdV?cH2%Ts0{WZ}~]O;յ8cG͇XZ.s}1S|;ڹ}?wM/͊omN7˱ 'wp]SӽI\8`I':k-wRatc5LnXg>.3F!F+isdbwkK]j9 ;jUբSߣ$}.8$6sZQ8E-z(ѕC9bf5SONeMKF ѳ|1ҹw<{h]v$,0}F1[bkSO{-JU$7S2!4Y9⮎9sgۣ;>Ů]նՌz=1*QolZ^l"#3ޮ/*SWITTn͞ys;\3H6WRp&kمE/(^Ǝѯ,6evI$cS\K)5mE6zon ~U`;sC6^Oa΢*<mpӧ.Nnu^N,QC$VaeiksII5q4h*I'w.N9lŒrn~>Bist<=ʄ%=M\vy]nci#Ff9~BW `qWIYkIƥi5v9FTMw'>8_ Ԧf :;\ B+?47&8)ӨvE0չU#oN$/;+m%xH'$$4x_[lN[R{ݕ[tHo|\L[]Mb(EMJ˭1u'^v.n<~nH>0.,'i,:(ʜ5$_O D16\$X9 xMƘLFNܷJ#lV6iAA>W^g 156r ߧ_`ooeYӖEohPR1"XiƦ*/ukecwGfDʎ3= RN Su9wZI$[tdbh']i:KYƏ+[KVbA:Ng]͍׊m~g]>~U(V?9m?.Me*7wzo'7,Jiv"X[MM*6R5"EZi/~nXF[g}盪%5yn[\jvjKf& c1Vjj2)Zu}2-rnSi[ԣ)Fz=')):mmNodwLΜ4VN?f<LjT)Rn[߄ݝ>VRq:7jSkUu"m 4qμ 3r{VN=OźAi<0dkq3]E*ѲYNp"ݽ$ܮqzTiQz#֧F*.Po9IEiErvAWWc޴[n㿑g/ؤlyǂ+TU%s:ZJoUҼ)u Xџ{Ev֦jg̈́6wOWs׃oYeVd~eSGCdV_X |O_ùatܺ-XhP{R)Ӕ[oS0_i9=[oXUw€@ӽxNF'ݽoeu,?+~py8oƾ_0'Rv4-}nUյy&)b_9<^#(|ڷ_b%{ ]5@ܲȭPsåyoG_#ϣ9F1= .nK־V$Iĭ7s2UGgV˞WVQ__oYU7쬮(۞H8Z8:\Z_>ƒ)Qo<1/`%[s>X?OA^$tc\U }.mRGq) nb#$F2Œ- meK7݈;N\ܩr[Y$NsK`kFP4m79fxY$w-/pbx'ʹ؊+]OXĠ#kyOc5%xU9e{j8Dғrfo>,qוYCٽ-׋nǓx!t<-mf~b[8sWc-);u3ѝFߩVfx]}nf^ЉBH'F.19VtԊ(v: 1[U#eZ r+-g;]ʜo8[@WoI x}OSNnȕ:e` QW*X՝pqҴkTގ1J>)&_Bi(^vǿ:,UZeg 3nr7I$S>LW͗ /sluۧoR+H1kj_zޟ/`FJw6)KҶ(_ ޝ[y#Xf'JQ{RU#+FZ0kE"! W5QG<9Tؒ%odm~y9jkB3ksZ7 yjuT{{{T^/K[ [Bܫy9ӰzTklULEJrM=6\,aRϿzŰr/ϽrT[[#B4rhvKyddqӨ)ՋߡU1F3bwnpxc^\LrT*k VkYUfFT9+cҼ9_-d;_[6BHg]ݔv>YN1UJJ跧xe`fYweV"NT[ obG˞98SYzik4H|hbMNNq=d|uN+/W<w`|zZ4~/ݴ~m%Kfs62fLP={=+"RȎ,.ň" hrçOJҤcR#ͣT`.mD{O$x$ jiӴyu9UNd,I7~5f:0*]:qm=NZhZyĬ$nw1zןVY(D;NM}໮\+#n* _p@#ևN~וJm1[iwyyaH摭#dUe':մch{F9IGkl5FI8'G^aa8J(ռFM,$!ScB%eԪud)꯷4r]jxN3\N[kF{~^dkyj˴y9nzwC枻éw U e~_2&e%NH={g*T;_9+{Iyh pY|l7]1KRGo=3=l^3튟i ze(ڧR䔽snñ+z1RxuwnX;'c*V@ r{y8Z5".Jjɥ KuYmlVH=8FվzxF*RqZt}tGy{ sFHVa 3g 4FOOSAIFO;|V[aU~e-JkAGޞgF#uՂ]\,{YW]@nE(Ɲ}S*Y}^FЏ͔*]GfRk_SR߭Ē[( Y/#v#+J*(MQi.5&StFCHy IIiU(Q}!hϘ>iu5'RɲaƑlFG cemB6W^jR1K{-OSOafP,qܪ*1sRDNƵ9TI$BG)U\eUQP|\RZyeGb6fWwӧlsGҗT_O,Aߧ$my*! ft'tp]uJ6+\۲`\.> ::]fK;q_W\ېD~S<;]x +*>O[Y5ygl]U! GE\Ν `}ַIr:t,gN-T]FvU w+3 2Mmu%N-{aU^//-rvI Vҋ֧Z 5f"TOmGV9 x烎Խ^QOmV)no-ci|NR,pA8qtm3=obf{Ge<YU}zeK~5E-6n/S R58.Oufiy:m;[FLY{E=hŁ>cרji&:V.yaws/mB>?2yTF۹q0F ʿ.1+hԗ_[ 1%3{WE:ND @xOS*6k;vdQ¶܏ʻ!V18r&&[ڪɵzqڴZ" e<4C%r$Vѩ:Uyd.mb.4/ROyJ6n1_Ŝ֔*7Bḥ%ws[~]cں)^6CDOnLLЮr_\V¾}N;K=԰FX߽0R7*Rc>REi͂޳i&lgsyStxc*0{W$TI\{#2\1N݊g[ӭeUEsF0^NK^Ē,ylɵcCZn^&"X6zIF_JeJ.a >lrFX:jΜnjΓc{^91,}%J7Ӎz$.D9BcOzu99%$5nōð2U!]ymagЊWE.@ѡlÜxpQFmimܬTջ}1lZ׽l}_J2ԍgŰ]I6?+|ӹ>kWWkKyPtbwfve3bݾҽJu&U>]=J3^Y@ZîPAd'p8LwrJ2r/G{>ƠmA3+L#vr_ԕiV׺CQ!#Ld1Fk"RoFJͽlv>e=KՋ%ȁTf۸;q9刧ROrMY~e{ǻy%kՕn$evLx$ӭF|~2yZ}ufkXTߘsW4Tu*4Ԝ-ԉa$f[rOߗJ>i^KVtU*)kMĖUV+^QG N:Jmz;H"mF~U @tW+:feS]]J%3Jm2/Y p?>ʲ&1QsIU-lA,lUzzx+[7z}]S͸kNiZJXg7~ױY(l+zT9Z,\*rN־+r{t^դ9h]4ժzG(«p;@Lc޳XKnSI¯^VL~ùlB}T)Ɲ>tfΩK#3/5+CDg.hT04"6 [2} }4^'hLp_lc qDkSUU05}uϢfiu+=^?ĿjhbǠl`p>#G+i*MJvG^ ʷ)RrwHa8zRH)T$G~Z&/Jv9cq]- iҔU~^6$O' XOM{+msyP7; |4m[ܤP`wOW jw8~k|+E yj甹{53V6+826>s)YVssTU9CXF5 vLs]8hwStԓխ|jdY3`8x zqiNw؃Gif1 Ѭs7NT߳_>3AZ캭>XXF17!_X=qXJJqN75>p,OdF $cN+GU9:=s2I{xUmNH g<]Qq_aaq\Gc#Tzzqf/+cR` n6Iwͳ˓;_NT3\r)'b(ye[mR7O_z>\8*T~JZ3VYpNvG)s{Kyo~Z=2219mwmN5MqK}͸SM Rӱw;;OMZ uH$ "UQÅ=O=Uo߯NMHcbyoO iG\_M +$ &Baz?FRAĝ:ONyu+͎r"ιݍ2Qo[m3¥*}c]mOj-kpm^Bn?B NiFsOɿS1u*V,ɭmW1LsoB#LjFw־s\}߱SîWMGE"4Z?;Y>8>r>փNsrjֺwW<]eFy<Ȭ}v(MsK >[F}?PTeU`C鏭pӔjb$zm%.JIzL_GۨG&y{*8^^|*ծO뷡S.\Uyc},aʐWo=kL&P$ն[Þ\-`5A l}UJ4RUއKPjn䌋Yws>՜qR'nI;y?qvUv'ێT8Ӽnzy\[{M +/-׭.U)}uF 7˵:ت+jOO#HF>B]Kֱ=,~~<œkt=F8>Z׳9%{mm;߳?:|=ocX|89n=A"R5fԟ*٭{tAlƫ;5@Ӂ}yPV~gFߦ|j_AgnUM\Tg(5zyIX {[ܲFF=}^"U-cdUiKkw>  CTm H9?ͻwkUTxe$A*Č;q۽sjQ;ʤ01_7о367s4{I}acRW4Zk{of hB߾ۆ9*QN:vR-v_3qe{kIrΧ>EBN;1=ɯB2N2f5ʜ[j;zuҋXWqd힜WLqRk9EEP;ug7iͺtE;dے_דWR2q[u]aTPpgiR. @bytxY9EnFVft(2^s9?^#*vIh&NǗUޭH-cr<+ar1۟c˖9)2Ny4%-۶qgtWU,D4xNXNIexhrma,~fc˥{X|;[_3é_{^?Q浩Y4fsGJHXF˞06?NM4s>$L"_ 6OF#89T} yW+n[/X3HJ| ucQѕIJ[XT+M}7pW{m˳zJU#(?:=v))5ЗwUfw&xԓpvG`Wڒnkț4^ BT9} c_V]_Уʧ4_3O_#Z\|+$mY' = L>+4G=Kmou8:5$]~GX⼚O16Bp# zWAJ]^C "XuNX@]kuqB:Vۏ1s wmUކ"xҌ/+iZOeN%RY#鴃Ϡ<4F.***1Sc6($-tZ6tVVL1~`F9WǘRkz8kuQʝT}MV\o>R{l̛7bN\$/iZUk[~ѦzY>37NaiYڗ 7#w 8 rK3ܩVRm=6;M |/p/.MG ߳{/ .;:z(k^گ-pYJNo}W] Zo 𮅢hyjV;J:9jh%m-30ìW#+/#.?oǺ8KϾz]rS+_Um̰,Z[kw[/>TIJFb^2}{NuSp~J%Cܞ(оԋCfb@?>9Jy]R8V4NSKw Jr 8Pg%.UW涫oNiotD%|qL'N4}f}Ju*F3MYyXr#rq?J{j~ 08{N|wvf֤ ky: t'ھR40߻zVQRi->~gbOHc[xn ߂9x~")7wԭ'^y5,;FksJ|U*s=K ƀ!nLܣf6e&6g3eK'-ִ>FѝNX.hl[r!X5 Ӂ5QHĈ:|zzסx{N\jp%for(>_iQ|eYWnz\:RD5c5ЯgF5}r>]n!$0}}:u`4}^4۳gh}JIw3V\zY,[o#yXN]J*Ne:6Nx6V%Ѭ}sνUHN2Q׃=nS(+7/1 ys*9+֍SўO\Hl[s12{Ə Z\wG*+} ƫ{Xoyû yq{;I%}|))4Kj=nyDhkmn9ܬU$)pKk1TTT(4߼՛vo>s1RhTOt?C񅾟xPHiWsW߀F6nM]/6^eSN}5OODm{>&ƼCdmWGaO~s.1*qoc?wM}v{0ʵcPa5vCn|˂ͤ5-Eo pƷ/Q7A#{oW$axൖ&-an Mpⱕ%Xޝ_gxMhI[![ibF>mڼ| 2~ ѻq[_Ɵn&6T</¸p9;6rmYl G$qF2nMw:jy;-Jq+_|;Dȭv+0XEZ&7f||^d~N p9'5'Nc)<.RA=-s}OzεgE5|TcU|Ч%Y$3q~/zMzK7k7SYXܭ*!$եby9Rr[z֚ڣO0/y2s@#I^0-tM')'ob0: sy*RQK?m[xVW92)?UߣvG j-BO uɆ*9U݃ܞx#QߍifTp߯Oun.YI$U *F>leeSyK|Χ6i{(ɫ8#&cO}Nw՛_ jfKHտtYwy'۽Dь}Y|)UPݽߡ5Py*lb?œ!g,*SWH3|ŏS](EiiЪVvn?h8?{aRN5ѭZMY2>GǞ⦞:#SJVOO7>.Ӷ@+-)$h;Q4Oϻې0r}:N~ ֥k^S;O 4dn,rCarrxciz#Xꑦկ}cGVvfn l19 +1⽇+bFcJFF[I`3T&2~,Y=dԏʼn3Gi,DfsYVJ_Γ~akif],:'4TF~f5ǗsIPEYIhc$k=\[~[QUk]C$Y#FrĜz+UnstkagPA8=kEITvsJ1<I5;ʬ m|6iqipYJY__;R妤o@L^A87%iq6G PdmHpF3{ֳ|gR1fq$դXWl69vSq8WeYQ=y'C.?xbikB @ ަVЯiR۩ p1csۜ~N2V{{(jrEm˽0rpzzg)Y#Q`Y%}Wa206zu=k1dR}7NwU%X+JQ~v޿y Ԋv3.yr9c]>Vc~Oq^g^o_ƝJu/ylΌF冮rk,K[Hx,YIҢ4eqҠh4{NqҪ&޺VQIfQfܳ7en*Y8iF59lS[_qen9ݠdc9JvKdrS.quna8=1U)N,[3zq}__?Nņ4l<$,-qls(٭wE_f+ZDa4 eB8~35k;[3ddf vd'tF;5_-Yr9Yݯmq41yJP\5Qꙝzn߼H1\]*65ǮSNhelB}mē2U wYWEBYI{׍R^ߑ*yw]o鷩X GGmUՎbyޝ1U |iG:RJkm${vVG@OLg9{c5%f*}ֺyK[Kմ16Əo u#zrNX%BM6䯾{;"+&AgϗEc1J3o*ҳ⢡Chk^ e\HYwn=h6o]J1{ I|DhBT̛"8VN쟛#eYc6 Ubvn䑎OCY2TH柧zE2m9^喫qZk؊7vK͜r1dc < <%̪Q\ZGY; Ѫ=+rRU=+o2+͢9$y_+F {Zքg9]J8uD[4w)1 f[IssƌjEnM7@GΕ?m7sMM=kK;\=z֫R3MX8vG u-Wj@#hSrm?CV!F!VyUnbI)C$Q<|0!Iǭtz4umF^ڟ~'%s QZ:ql-a(i:?ZjvGJ.qv]RX$xѾm}Oj[3У1S0y%8ye.cӚ^QIVs&c\$P4k<>{}e)+D+r[)a7ϭmF+|2 uFkb m)vq~=EtS.2ʿ4Ob9w3d6o-p9hƝNԍIEZh° nk~TkQm!$idggir4t6Jثq8&_j2v-G٥#ex+©#'>w؅jNvTW2*[ܖH j\{G'NR׻<钬:ܱo{4ւF~b͚\;cZ1tw+hGS:b3I=NZTSUqqKvOu =Wo:5%Rֱju#jKЎ [o-w+`@n`zs2[j1Q\,k{K4GCf*Qm;})SOJbpJr2,3 θ>tƤc=~#^y]ѷ%fm^.u#hRVYJ+hET(,O ydKrp.y䑥b5+epT\ҕOhTeWx7]<ʫWRYsMk.o/˞NȆF˲ vv=~zN;U^%1 2}ƺRRE{iJ:-ŵi-5*ǽw?(duw1:a? PG͞}ֱvcV*Au0Kw ]̶)mi|Z7U]N,FZ^۱vI NiN\ҧSrӮa,aHJc?ڭJL1o#s0q^>N[ij5bF#cx{?:5e(tjRu:MzRF[+YϧjߚcoOފbe ofcN~T䜙֞[YA=qgN^G^1ŻE>J4۩+ N~c.U8zC/*|ڃ{TrqԫNT,$xY֕IJNX+J,*[*#<~SWrh'-oѼqw`cάɦΗ_[;[g0_(RҔQqC!WӒ=z(W]gR3'r1g =@S}Jغ6VtlhƜ'wAQ-ostr4|21UB vXPT䪭oHfn>CAܸ~jN4ʗoYYm_&l+)^R3JZtsYJ2 S5~3"-cs!A#q3\5ϻ{Nu#NIbF32 s -7;sێǽMZ rR{tQ6KfѝYͻc+5N.+A-i_D(X8ϳ#m?:(gܪGpsKu;eЁ4Ӆ>n~J3iJ2J[6YNoT}3ګ #L*0B]%G;7̪qK{Y7&pN17H4vlnA= JU?y#l- S\˲vbEDExlH5:ӻ2Kjg5Uߕc `=On*~w2~$YUcy.ߺxVIh7%ݤ$KhEejk򢃟dsVNm<0[Il:C-^Wti_o&KVFG@slJZӖNť@S59i9[[n1;#=r}{uRqˊzܐwKm cg $̙nBp3;T٫RݟrxQo5O~xNcYF{~dQ<яNw9==+H2ʥJŅ F,͍>{R9QϚL8@eYx }94'F1gaHrfS@9 Ti{OVS&vA$w*{sc[{V?u-2F3F7)d{TʔV6^R(tܧ,$z>g"atd/!{Xp/]=42V] I "2ɃswNҦi.[KI>Ub_prp+J*UcC|rfR:Ƨ52/ihhcue̢5,sWitW.?simIȬ{=ֲf*ʍm [-'\(s~p)i)6k $H.T]$#8>kkFh|{]E?}N9#<}(8H&ثmqqs{4F,>f ~@t'{֓:-MÚ[_IX37EQF2Щ/SW,aqWnzz"Ɯu߶ymn'w'^tR3]sUP$ou vl#'3Z#7.hI\_o`ֱV39T5%o%giۘ$\e2MeƷpjp?/8])To3VRM;G7/rc3DwW:U}ɭ h LcY3:N{rwX:T>@#~릞K~ '6֏GHNcjDP# s돭tRNdc͗+b4W1bvV1'>T5+ ):7ԯu\a9 /.em6~ΌSYэ9(bfw;m9{?ֳjr:#ZZ~RjA#mϖ9h~Ӛ[nRi;7e v".+)A﷡I3۴#%j1SK--ߚ,+ar۹X>㷐{7O@URQ,ҸToow[Pc"kXm#n_:6c ߞ}9ӫ V*&ӔZ {Jǻo˜]*jwL֥<,k7Q+CѶWolb}UM5=өyB,-XC$\a=_vZq,T$wS+hfȖX5|ݹkOMG+թ'M>\Cm`F98Z_ qH'J0ʕk<$~qVU~Pz ٹEu}s֔/ m5FS*Lo}~T;)",I% lNWe5ۢL$c悷5^ 2ݻ$`+NTxlFkV nz.w7u#eQ9JSWmo/ڄEfv"8y;bm צ5cRo^s{`SR\&=[HZ*pn⡸ϱ;M+rN*tN%WˢA3dc*s|"9ֵzҕ7۱X5q,{pF yxkC$IQݝ^dبQ<׷_Ik-<ןR c Ӵ3G9iYT1{.3rkaD\2c'j 8Qjg.{+ic:t*|^ BFo]v#o8?kjqN3)RϢ,3E"v9rG<x̿ZKAk著&PUbGdwv98s/BJ:SFLD\^ɿ>}<29y!Y3P3aNk,WG??d1ң/eR+>wOg-!xH O-%e 1oK\Z&{*A][wWZ XWs_[\6eRMvs#3k^(@mElIe>\ya'w'@ǧa׺kuV󷟙P^.Oޕ[mŖ0(v6ZNT)pG_0Eg~9/=O-gWb iF~^.[N֤fI> \G-)`z w3%i#bͳ w3>Jw:p5Wfiz]0mg͇0)Nj{hiIk/之R`޲r9=}ǖwxbߵ75H.nWh]*%ÕN2A`rH꧅%k_[ju<2r+ReԬwc. w/$`x"wuUTKO?3;w.%WWKEݴǧP99B1Un/ަ*OV}w<$ g{WI+EJ# R0޳dDUu[],xMǫ7gqo4pcs4=t?(y=ڛPWMko4S⠮=iӮ>y v9]9TteMQ%i3GdMCDW0HR:#-8o. ypo?*gǽ0?jiz׶̷O2%^o֋^}:s}žrYȧ рPæ+gM5 qSFֺ>?~%ׇnYzr# 8x1{:9NZ0pyZ[4Ȳpxje)?ċrougVHԩ9㷯CH{Mg<5*J->Xk>hfkvV5(*E&Qz)#FZ[UҖ"fՙ4Wsyde3=وN%ǵMf~k)F{-EaL WqͽW~{8kQÌi;IEeT! s\rm}Qåi%ٱa)Ynr8J8z"ȣMv▛ع&Z>G+XSq9e%QG;L6գ҅Sެ%{0-^6Y#+>:u%U{H_:$ttK|5{E #cPy8<U[pkeXzݜKnIZG{lF8Ony<}fNU"R8nh8d۵luc<ݫS?歂bW>>Z:5$c|du冧 />i]O1ӧ[_uI?<5ʻ9'g)<||=L=G9|ǣR+B>:eR#U[f8oc>E]4\3i;oC}Z}o1TsԎxeMIǕ-5g01fmF65Rin竇NLBZ96fJ51y{shKߧ[X;}Es8\|5|Q{Kwգɓ;908M/N$M|7ƞ hD`4pg<瑜Z֌h+[{ߩb~7*kT> E00(2G]TJ'"'eFwNG+v.iTsW_hdzn;kJs4Q ֞܋;}$=mNu$Q۱8Z4q瞉lZܼmɩr,R8qc.W{Ʀ᥾7G JJT\d9dkEx7Zn6|\tItzbe*З-z6Og^0eGcݐ N#g<{{n"'w$ԥOgRm@x ['ɯVNTx}e\"mKo_Na=H/*e Zv &٥ʹ%A8=CEYo+ezE?w\c~u ޟl_j62sW^pGN4Un6s럆 T+o/!ʎGN;k] [19CUw=H 6wqma;.ﴀ:^4!~ӝ6J^V:]+GL*ԕ۞y?{#Gi$nRR ^75ԗ;@iw^)KV3K??|sW ̬_};{֜WDNwn:MbD+1]8'xTgi.^P~Tm*1buOyکr3?8heoq{mbIN V0L®2?T2OXktсG>TT^R me~m sS~fIF6{ZVzy4lFKHpFy?WYGF U&3[l3IS9l/m:1S_72@E4KɆ,Ğ>'v9%R٣|UvdO glڤq'8Z2c+8mfYeQ1 /A&3N>JJlA=~»W<?*ڜc3>Z؈9Z^E-nTˏ2dy c'Z8tua,,U%m]]zd׹=?Tݷs15WBGb~ºuc]U14' ,*7{=P)^r'b!1[T卬g8;r-^~mxQ I NTr^յkKeE6K{BRTcr߉TӔnꆼbO*nprNzb#MM$[༐/awO=l<+Ş0AzZ?˷?Ou!-69E2vLsY!]@X Dk9ToFLEINkf0?cSF-Mi5#g-zat n9 k?yFFSF"R,.ʍ/=Ol?*ucgianYoз/&=:wpI- Pm9_L=se% ұIW58_ĖHq6̡ߟn:n\?S͵ɩp#UiA99קVU%K˼-E$J+1^Lx^9V"[n/k-[Bx~Fd@9%CxթR>kqӕ6.'S'zxz[6:1$տ?KZ&Wyꠎ/P ==:VU[WymIь%xFQIHH`֤UݯtQO'NkVn򵵲~L֮XZ)-[ղ)l 9nzÑ\xV!)=﹅*~2w#ߗ"LU)KNgmJ.Z 1% Is/Fx5 Qů]{h6Ri6,qnF]sG<ҩѤB*1n֗_/!LRYb6lNN2=HJM757eh͕^9QW݋ȥVhhQ\$OHCHV=ؚU9ݕ%XkIJV5ЎAZܤNqE,%m#T9>z]mm G?$>,\HcVUFsuXҝ:| 1R-;Z@ *9f)}gh֌bMur9cM#/_KdqtTx%4gRWw=6dvpǧ$~_Jq*4)QݕLi,ː̳6sBPӯp'EVyVHt0 _ZWR2k#A36`763=ȩJ6'VUdW}-$ Y_$IZQԫ+7-#6mcxs~+J<;N*4]#̐*|k:jt_/|ۗp#sNo*[*I|NqR4)(،Ӧv7com0nf1:e3]*}煘bQRn:~3<=5F*+jg4,FJ*߯qJSMY\y1ZHI+9ƚz}̆"Z==J|y|(4)mܣnҬ~c_RA8{$INkI++nniЯzE@" UjT-$úr▽eWGOU7):IgH񍪹jV4j<[qxyTsIJȅ\t1LC 2N544v{Pغ3O52KҲΏ >^fCoFT}sʛQ<HoFe^9֪HKl(4Hnm [³:95.gºwodHz»~g2~HW3tةn^EKFf?쌞?UԟfBIEFfj6qkma$0F2  <ڽYF\Ee=X$vp @xkl=U.:З?2^B}g-ڬ128HӍj6z͗qF$<68t{h:cw.Xܯ]6B>9UToSRN-2t ޔu6[tF]R8V a>IVix